diff --git a/CHANGELOG.md b/CHANGELOG.md index 42757783c..4497a9ddf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -285,6 +285,7 @@ Removed: ### Added +- `climada.util.calibrate` module for calibrating impact functions [#692](https://github.com/CLIMADA-project/climada_python/pull/692) - 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) diff --git a/climada/util/calibrate/__init__.py b/climada/util/calibrate/__init__.py index 53d753aab..0cd610958 100644 --- a/climada/util/calibrate/__init__.py +++ b/climada/util/calibrate/__init__.py @@ -26,4 +26,9 @@ BayesianOptimizerOutputEvaluator, select_best, ) +from .ensemble import ( + AverageEnsembleOptimizer, + EnsembleOptimizerOutput, + TragedyEnsembleOptimizer, +) from .scipy_optimizer import ScipyMinimizeOptimizer diff --git a/climada/util/calibrate/ensemble.py b/climada/util/calibrate/ensemble.py new file mode 100644 index 000000000..15c730f81 --- /dev/null +++ b/climada/util/calibrate/ensemble.py @@ -0,0 +1,652 @@ +""" +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 . + +--- +Ensemble calibration on top of the single-function calibration module +""" + +import logging +from abc import ABC, abstractmethod +from copy import copy, deepcopy +from dataclasses import InitVar, dataclass, field +from itertools import repeat +from pathlib import Path +from typing import Any, Callable, Mapping, Optional, Sequence + +import matplotlib.pyplot as plt +import matplotlib.ticker as mticker +import numpy as np +import pandas as pd +from numpy.random import default_rng +from pathos.multiprocessing import ProcessPool +from tqdm import tqdm + +from ...engine.unsequa.input_var import InputVar +from ...entity.impact_funcs import ImpactFunc, ImpactFuncSet +from ..coordinates import country_to_iso +from .base import Input, Optimizer, Output + +LOGGER = logging.getLogger(__name__) + + +def sample_data(data: pd.DataFrame, sample: list[tuple[int, int]]): + """ + Return a DataFrame containing only the sampled values from the input data. + + The resulting data frame has the same shape and indices ad ``data`` and is filled + with NaNs, except for the row and column indices specified by ``sample``. + + Parameters + ---------- + data : pandas.DataFrame + The input DataFrame from which values will be sampled. + sample : list of tuple of int + A list of (row, column) index pairs indicating which positions + to copy from ``data`` into the returned DataFrame. + + Returns + ------- + pandas.DataFrame + A DataFrame of the same shape as ``data`` with NaNs in all positions + except those specified in ``sample``, which contain the corresponding values + from ``data``. + """ + # Create all-NaN data + data_sampled = pd.DataFrame(np.nan, columns=data.columns, index=data.index) + + # Extract sample values from data + for row, col in sample: + data_sampled.iloc[row, col] = data.iloc[row, col] + + return data_sampled + + +def event_info_from_input(inp: Input) -> dict[str, Any]: + """Get information on the event(s) for which we calibrated + + This tries to retrieve the event IDs, region IDs, and event names. + + Returns + ------- + dict + With keys ``event_id``, ``region_id``, ``event_name`` + """ + # Get region and event IDs + data = inp.data.dropna(axis="columns", how="all").dropna(axis="index", how="all") + event_ids = data.index + region_ids = data.columns + + # Get event name + try: + event_names = inp.hazard.select(event_id=event_ids.to_list()).event_name + except IndexError: + event_names = [] + + # Return data + return { + "event_id": event_ids.to_numpy(), + "region_id": region_ids.to_numpy(), + "event_name": event_names, + } + + +@dataclass +class SingleEnsembleOptimizerOutput(Output): + """Output for a single member of an ensemble optimizer + + This extends a regular :py:class:`~climada.util.calibrate.base.Output` by + information on the particular event(s) this calibration was performed on. + + Attributes + ---------- + event_info : dict(str, any) + Information on the events for this calibration instance + """ + + event_info: dict[str, Any] = field(default_factory=dict) + + +def optimize( + optimizer_type: type[Optimizer], + inp: Input, + opt_init_kwargs: Mapping[str, Any], + opt_run_kwargs: Mapping[str, Any], +) -> SingleEnsembleOptimizerOutput: + """Instantiate an optimizer, run it, and return its output + + Parameters + ---------- + optimizer_type : type + The type of the optimizer to use + inp : Input + The optimizer input + opt_init_kwargs + Keyword argument for initializing the optimizer + opt_run_kwargs + Keyword argument for running the optimizer + + Returns + ------- + SingleEnsembleOptimizerOutput + The output of the optimizer + """ + opt = optimizer_type(inp, **opt_init_kwargs) + out = opt.run(**opt_run_kwargs) + return SingleEnsembleOptimizerOutput( + params=out.params, + target=out.target, + event_info=event_info_from_input(inp), + ) + + +@dataclass +class EnsembleOptimizerOutput: + """The collective output of an ensemble optimization""" + + data: pd.DataFrame + + @classmethod + def from_outputs(cls, outputs: Sequence[SingleEnsembleOptimizerOutput]): + """Build data from a list of outputs""" + # Support empty sequences + if not outputs: + return cls(data=pd.DataFrame()) + + # Derive column names + cols = pd.MultiIndex.from_tuples( + [("Parameters", p_name) for p_name in outputs[0].params.keys()] + + [("Event", p_name) for p_name in outputs[0].event_info] + ) + data = pd.DataFrame(columns=cols) + + # Fill with data + data["Parameters"] = pd.DataFrame.from_records([out.params for out in outputs]) + data["Event"] = pd.DataFrame.from_records([out.event_info for out in outputs]) + + return cls(data=data) + + def to_hdf(self, filepath: Path | str): + """Store data to HDF5""" + self.data.to_hdf(filepath, key="data") + + @classmethod + def from_hdf(cls, filepath: Path | str): + """Load data from HDF""" + return cls(data=pd.read_hdf(filepath, key="data")) + + @classmethod + def from_csv(cls, filepath: Path | str): + """Load data from CSV""" + LOGGER.warning( + "Do not use CSV for storage, because it does not preserve data types. " + "Use HDF instead." + ) + return cls(data=pd.read_csv(filepath, header=[0, 1])) + + def to_csv(self, filepath: Path | str): + """Store data as CSV""" + LOGGER.warning( + "Do not use CSV for storage, because it does not preserve data types. " + "Use HDF instead." + ) + self.data.to_csv(filepath, index=None) + + def _to_impf_sets(self, impact_func_creator) -> list[ImpactFuncSet]: + """Return a list of impact functions created from the stored parameters""" + return [ + impact_func_creator(**row["Parameters"]) for _, row in self.data.iterrows() + ] + + def to_input_var( + self, impact_func_creator: Callable[..., ImpactFuncSet], **impfset_kwargs + ) -> InputVar: + """Build Unsequa InputVar from the parameters stored in this object""" + return InputVar.impfset( + self._to_impf_sets(impact_func_creator), **impfset_kwargs + ) + + def plot( + self, impact_func_creator: Callable[..., ImpactFuncSet], **impf_set_plot_kwargs + ): + """Plot all impact functions into the same plot + + This uses the basic plot functions of + :py:class:`~climada.entity.impact_funcs.base.ImpactFuncSet`. + """ + impf_set_list = self._to_impf_sets(impact_func_creator) + + # Create a single plot for the overall layout, then continue plotting into it + axes = impf_set_list[0].plot(**impf_set_plot_kwargs) + + # 'axes' might be array or single instance + ax_first = axes + if isinstance(axes, np.ndarray): + ax_first = axes.flat[0] + + # Legend is always the same + handles, labels = ax_first.get_legend_handles_labels() + + # Plot remaining impact function sets + for impf_set in impf_set_list[1:]: + impf_set.plot(axis=axes, **impf_set_plot_kwargs) + + # Adjust legends + for ax in np.asarray([axes]).flat: + ax.legend(handles, labels) + + return axes + + def plot_shiny( + self, + impact_func_creator: Callable[..., ImpactFuncSet], + haz_type: str, + impf_id: int, + inp: Input | None = None, + impf_plot_kwargs: Mapping[str, Any] | None = None, + hazard_plot_kwargs: Mapping[str, Any] | None = None, + legend: bool = True, + ): + """Plot all impact functions with appropriate color coding and event data + + Parameters + ---------- + impact_func_creator : Callable + A function taking parameters and returning an + :py:class:`~climada.entity.impact_funcs.base.ImpactFuncSet`. + haz_type : str + The hazard type of the impact function to plot. + impf_id : int + The ID of the impact function to plot. + inp : Input, optional + The input object used for the calibration. If provided, a histogram of the + hazard intensity will be drawn behin the impact functions. + impf_plot_kwargs + Keyword arguments for the function plotting the impact functions. + hazard_plot_kwargs + Keyword arguments for the function plotting the hazard intensity histogram. + legend : bool + Whether to create a legend or not. The legend may become cluttered for + results of + :py:class:`~climada.util.calibrate.ensemble.AverageEnsembleOptimizer`, + therefore it is advisable to disable it in these cases. + """ + # Store data to plot + data_plt = [] + for _, row in self.data.iterrows(): + impf = impact_func_creator(**row["Parameters"]).get_func( + haz_type=haz_type, fun_id=impf_id + ) + if not isinstance(impf, ImpactFunc): + raise ValueError( + f"Cannot find a unique impact function for haz_type: {haz_type}, " + f"impf_id: {impf_id}" + ) + + def single_entry(arr): + """If ``arr`` has a single entry, return it, else ``arr`` itself""" + if len(arr) == 1: + return arr[0] + return arr + + region_id = single_entry(country_to_iso(row[("Event", "region_id")])) + event_name = single_entry(row[("Event", "event_name")]) + event_id = single_entry(row[("Event", "event_id")]) + + label = f"{event_name}, {region_id}, {event_id}" + if len(event_name) > 1 or len(event_id) > 1: + label = label.replace("], [", "]\n[") # Multiline label + + data_plt.append( + { + "intensity": impf.intensity, + "mdr": impf.paa * impf.mdd, + "label": label, + } + ) + + # Create plot + _, ax = plt.subplots() + legend_xpad = 0 + + # Plot hazard histogram + # NOTE: Actually requires selection by exposure, but this is not trivial! + if inp is not None: + # Create secondary axis + ax2 = ax.twinx() + ax2.set_zorder(1) + ax.set_zorder(2) + ax.set_facecolor("none") + legend_xpad = 0.15 + + # Draw histogram + hist_kwargs = {"bins": 40, "color": "grey", "alpha": 0.5} + if hazard_plot_kwargs is not None: + hist_kwargs.update(hazard_plot_kwargs) + ax2.hist(inp.hazard.intensity.data, **hist_kwargs) + ax2.set_ylabel("Intensity Count", color=hist_kwargs["color"]) + ax2.tick_params(axis="y", colors=hist_kwargs["color"]) + + elif hazard_plot_kwargs is not None: + LOGGER.warning("No 'inp' parameter provided. Ignoring 'hazard_plot_kwargs'") + + # Sort data by final MDR value, then plot + colors = plt.get_cmap("turbo")(np.linspace(0, 1, self.data.shape[0])) + data_plt = sorted(data_plt, key=lambda x: x["mdr"][-1], reverse=True) + impf_plot_kwargs = impf_plot_kwargs if impf_plot_kwargs is not None else {} + for idx, data_dict in enumerate(data_plt): + ax.plot( + data_dict["intensity"], + data_dict["mdr"], + label=data_dict["label"], + color=colors[idx], + **impf_plot_kwargs, + ) + + # Cosmetics + ax.set_xlabel(f"Intensity [{impf.intensity_unit}]") + ax.set_ylabel("Impact") + ax.set_title(f"{haz_type} {impf_id}") + ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1)) + ax.set_ylim(0, 1) + if legend: + ax.legend( + bbox_to_anchor=(1.05 + legend_xpad, 1), + borderaxespad=0, + borderpad=0, + loc="upper left", + title="Event Name, Country, Event ID", + frameon=False, + fontsize="xx-small", + title_fontsize="x-small", + ) + + return ax + + def plot_category( + self, + impact_func_creator: Callable[..., ImpactFuncSet], + haz_type: str, + impf_id: int, + category: str, + category_colors: Mapping[str, str | tuple] | None = None, + **impf_set_plot_kwargs, + ): + """Plot impact functions with coloring according to a certain category + + Parameters + ---------- + impact_func_creator : Callable + A function taking parameters and returning an + :py:class:`~climada.entity.impact_funcs.base.ImpactFuncSet`. + haz_type : str + The hazard type of the impact function to plot. + impf_id : int + The ID of the impact function to plot. + category : str + The event information on which to categorize (can be ``"region_id"``, + ``"event_id"``, or ``"event_name"``) + category_colors : dict(str, str or tuple), optional + Specify which categories to plot (keys) and what colors to use for them + (values). If ``None``, will categorize for unique values in the ``category`` + column and color automatically. + """ + impf_set_arr = np.array(self._to_impf_sets(impact_func_creator)) + + if category_colors is None: + unique_categories = self.data[("Event", category)].unique() + unique_colors = plt.get_cmap("turbo")( + np.linspace(0, 1, len(unique_categories)) + ) + else: + unique_categories = category_colors.keys() + unique_colors = category_colors.values() + + _, ax = plt.subplots() + for sel_category, color in zip(unique_categories, unique_colors): + cat_idx = self.data[("Event", category)] == sel_category + + for i, impf_set in enumerate(impf_set_arr[cat_idx]): + impf = impf_set.get_func(haz_type=haz_type, fun_id=impf_id) + if not isinstance(impf, ImpactFunc): + raise ValueError( + "Cannot find a unique impact function for haz_type: " + f"{haz_type}, impf_id: {impf_id}" + ) + label = f"{sel_category}, {cat_idx.sum()}" if i == 0 else None + ax.plot( + impf.intensity, + impf.paa * impf.mdd, + color=color, + label=label, + **impf_set_plot_kwargs, + ) + + ax.legend( + title=f"{category}, count", + bbox_to_anchor=(1.05, 1), + loc="upper left", + frameon=False, + borderaxespad=0, + borderpad=0, + ) + # Cosmetics + ax.set_xlabel(f"Intensity [{impf.intensity_unit}]") + ax.set_ylabel("Impact") + ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1)) + ax.set_ylim(0, 1) + return ax + + +@dataclass +class EnsembleOptimizer(ABC): + """Abstract base class for defining an ensemble optimizer + + Attributes + ---------- + input : Input + The input for the optimization + optimizer_type : type[Optimizer] + The type of the optimizer to use for each calibration task + optimizer_init_kwargs + Keyword argument for initializing the calibration optimizer + samples : list of list of tuple(int, int) + The samples for each calibration task + """ + + input: Input + optimizer_type: type[Optimizer] + optimizer_init_kwargs: dict[str, Any] = field(default_factory=dict) + samples: list[list[tuple[int, int]]] = field(init=False, default_factory=list) + + def run(self, processes=1, **optimizer_run_kwargs) -> EnsembleOptimizerOutput: + """Execute the ensemble optimization + + Parameters + ---------- + processes : int, optional + The number of processes to distribute the optimization tasks to. Defaults to + 1 (no parallelization) + optimizer_run_kwargs + Additional keywords arguments for the + :py:func:`~climada.util.calibrate.base.Optimizer.run` method of the + particular optimizer used. + """ + if processes == 1: + outputs = self._iterate_sequential(**optimizer_run_kwargs) + else: + outputs = self._iterate_parallel(processes, **optimizer_run_kwargs) + return EnsembleOptimizerOutput.from_outputs(outputs) + + def _inputs(self): + """Generator for input objects""" + for sample in self.samples: + yield self.input_from_sample(sample) + + def _opt_init_kwargs(self): + """Generator for optimizer initialization keyword arguments""" + for idx in range(len(self.samples)): + yield self._update_init_kwargs(self.optimizer_init_kwargs, idx) + + def _iterate_sequential( + self, **optimizer_run_kwargs + ) -> list[SingleEnsembleOptimizerOutput]: + """Iterate over all samples sequentially""" + return [ + optimize( + self.optimizer_type, input, init_kwargs, deepcopy(optimizer_run_kwargs) + ) + for input, init_kwargs in tqdm( + zip(self._inputs(), self._opt_init_kwargs()), total=len(self.samples) + ) + ] + + def _iterate_parallel( + self, processes, **optimizer_run_kwargs + ) -> list[SingleEnsembleOptimizerOutput]: + """Iterate over all samples in parallel""" + iterations = len(self.samples) + opt_run_kwargs = (deepcopy(optimizer_run_kwargs) for _ in range(iterations)) + with ProcessPool(nodes=processes) as pool: + return list( + tqdm( + pool.imap( + optimize, + repeat(self.optimizer_type), + self._inputs(), + self._opt_init_kwargs(), + opt_run_kwargs, + # chunksize=processes, + ), + total=iterations, + ) + ) + + @abstractmethod + def input_from_sample(self, sample: list[tuple[int, int]]) -> Input: + """Define how an input is created from a sample""" + + def _update_init_kwargs( + self, init_kwargs: dict[str, Any], iteration: int + ) -> dict[str, Any]: + """Copy settings in the init_kwargs and update for each iteration""" + kwargs = copy(init_kwargs) # Maybe deepcopy? + if "random_state" in kwargs: + kwargs["random_state"] = kwargs["random_state"] + iteration + return kwargs + + +@dataclass +class AverageEnsembleOptimizer(EnsembleOptimizer): + """An optimizer for the average ensemble + + Attributes + ---------- + sample_fraction : float + The fraction of data points to use for each calibration + ensemble_size : int + The number of calibration tasks to perform + random_state : int + The seed for the random number generator selecting the samples + replace : bool + If samples of the impact data should be drawn with replacement + """ + + sample_fraction: InitVar[float] = 0.8 + ensemble_size: InitVar[int] = 20 + random_state: InitVar[int] = 1 + replace: InitVar[bool] = False + + def __post_init__(self, sample_fraction, ensemble_size, random_state, replace): + """Create the samples""" + if sample_fraction <= 0: + raise ValueError("Sample fraction must be larger than 0") + elif sample_fraction > 1 and not replace: + raise ValueError("Sample fraction must be <=1 or replace must be True") + if ensemble_size < 1: + raise ValueError("Ensemble size must be >=1") + + # Find out number of samples + notna_idx = np.argwhere(self.input.data.notna().to_numpy()) + num_notna = notna_idx.shape[0] + num_samples = int(np.rint(num_notna * sample_fraction)) + + # Create samples + rng = default_rng(random_state) + self.samples = [ + rng.choice(notna_idx, size=num_samples, replace=replace) + for _ in range(ensemble_size) + ] + + def input_from_sample(self, sample: list[tuple[int, int]]): + """Shallow-copy the input and update the data""" + input = copy(self.input) # NOTE: Shallow copy! + input.data = sample_data(input.data, sample) + return input + + +@dataclass +class TragedyEnsembleOptimizer(EnsembleOptimizer): + """An optimizer for the ensemble of tragedies + + Attributes + ---------- + ensemble_size : int, optional + The number of calibration tasks to perform. Defaults to ``None``, which means + one for each data point. Must be smaller or equal to the number of data points. + random_state : int + The seed for the random number generator selecting the samples + """ + + ensemble_size: InitVar[Optional[int]] = None + random_state: InitVar[int] = 1 + + def __post_init__(self, ensemble_size, random_state): + """Create the single samples""" + notna_idx = np.argwhere(self.input.data.notna().to_numpy()) + self.samples = notna_idx[:, np.newaxis].tolist() # Must extend by one dimension + + # Subselection for a given ensemble size + if ensemble_size is not None: + if ensemble_size < 1: + raise ValueError("Ensemble size must be >=1") + if ensemble_size > len(self.samples): + raise ValueError( + "Ensemble size must be smaller than maximum number of samples " + f"(here: {len(self.samples)})" + ) + + rng = default_rng(random_state) + self.samples = rng.choice(self.samples, ensemble_size, replace=False) + + def input_from_sample(self, sample: list[tuple[int, int]]): + """Subselect all input""" + # Data + input = copy(self.input) # NOTE: Shallow copy! + data = sample_data(input.data, sample) + input.data = data.dropna(axis="columns", how="all").dropna( + axis="index", how="all" + ) + + # Select single hazard event + input.hazard = input.hazard.select(event_id=input.data.index) + + # Select single region in exposure + # NOTE: This breaks impact_at_reg with pre-defined region IDs!! + # exp = input.exposure.copy(deep=False) + # exp.gdf = exp.gdf[exp.gdf["region_id"] == input.data.columns[0]] + # input.exposure = exp + + return input diff --git a/climada/util/calibrate/test/test_ensemble.py b/climada/util/calibrate/test/test_ensemble.py new file mode 100644 index 000000000..1230af415 --- /dev/null +++ b/climada/util/calibrate/test/test_ensemble.py @@ -0,0 +1,505 @@ +""" +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 . + +--- +Tests for ensemble calibration module +""" + +import copy +import unittest +from pathlib import Path +from tempfile import TemporaryDirectory +from unittest.mock import create_autospec, patch + +import numpy as np +import numpy.testing as npt +import pandas as pd +import pandas.testing as pdt + +from climada.util.calibrate.base import Input, Output +from climada.util.calibrate.ensemble import ( + AverageEnsembleOptimizer, + EnsembleOptimizer, + EnsembleOptimizerOutput, + SingleEnsembleOptimizerOutput, + TragedyEnsembleOptimizer, + event_info_from_input, + sample_data, +) + +from .test_base import ConcreteOptimizer, exposure, hazard + + +class TestEnsembleOptimizerOutput(unittest.TestCase): + """Test the EnsembleOptimizerOutput""" + + def setUp(self): + """Initialize single outputs""" + self.output1 = SingleEnsembleOptimizerOutput( + params={"param1": 1.0, "param2": 2.0}, + target=1, + event_info={ + "event_id": np.array([1, 2]), + "region_id": np.array([1, 2]), + "event_name": ["a", "b"], + }, + ) + self.output2 = SingleEnsembleOptimizerOutput( + params={"param1": 1.1, "param2": 2.1}, + target=2, + event_info={ + "event_name": [1], + "event_id": np.array([3]), + "region_id": np.array([4]), + }, + ) + + def test_from_outputs(self): + """Test 'from_outputs' initialization""" + out = EnsembleOptimizerOutput.from_outputs([self.output1, self.output2]) + data = out.data + + # Test MultiIndex columns + npt.assert_array_equal(data["Parameters"].columns, ["param1", "param2"]) + npt.assert_array_equal( + data["Event"].columns, ["event_id", "region_id", "event_name"] + ) + + # Test parameters + npt.assert_array_equal(data[("Parameters", "param1")], [1.0, 1.1]) + npt.assert_array_equal(data[("Parameters", "param2")], [2.0, 2.1]) + + # Test event info + pdt.assert_series_equal( + data[("Event", "event_id")], + pd.Series([np.array([1, 2]), np.array([3])], name=("Event", "event_id")), + ) + pdt.assert_series_equal( + data[("Event", "region_id")], + pd.Series([np.array([1, 2]), np.array([4])], name=("Event", "region_id")), + ) + pdt.assert_series_equal( + data[("Event", "event_name")], + pd.Series([["a", "b"], [1]], name=("Event", "event_name")), + ) + + def test_from_outputs_empty(self): + """Test 'from_outputs' with empty list""" + out = EnsembleOptimizerOutput.from_outputs([]) + self.assertTrue(out.data.empty) + + def test_cycling(self): + """Test correct cycling to files""" + with TemporaryDirectory() as tmp: + filepath = Path(tmp, "file.h5") + + out = EnsembleOptimizerOutput.from_outputs([self.output1, self.output2]) + out.to_hdf(filepath) + + out_new = EnsembleOptimizerOutput.from_hdf(filepath) + pdt.assert_frame_equal(out.data, out_new.data) + + @unittest.skip("Cycling with CSV does not preserve data types") + def test_cycling_csv(self): + """Test correct cycling with CSV""" + with TemporaryDirectory() as tmp: + filepath = Path(tmp, "file.csv") + + out = EnsembleOptimizerOutput.from_outputs([self.output1, self.output2]) + out.to_csv(filepath) + + out_new = EnsembleOptimizerOutput.from_csv(filepath) + pdt.assert_frame_equal(out.data, out_new.data) + + def test_to_input_var(self): + """Test creating an Unsequa InputVar from the output""" + + def impf_creator(**params): + """Stub impf creator""" + return params + + invar = EnsembleOptimizerOutput.from_outputs( + [self.output1, self.output2] + ).to_input_var( + impact_func_creator=impf_creator, + haz_id_dict={"TC": [0, 1]}, + bounds_impfi=(0, 1), + ) + self.assertDictEqual(invar.func(IFi=None, IL=0), self.output1.params) + self.assertDictEqual(invar.func(IFi=None, IL=1), self.output2.params) + self.assertListEqual(list(invar.distr_dict.keys()), ["IFi", "IL"]) + + +class TestSampleData(unittest.TestCase): + """Test sample_data function""" + + def test_sample_data(self): + """Test sampling of a Data Frame""" + df = pd.DataFrame([[0, 1, 2], [3, 4, 5]], index=[1, 2], columns=["a", "b", "c"]) + samples = [(0, 0), (0, 2), (1, 1)] + + pdt.assert_frame_equal( + sample_data(df, samples), + pd.DataFrame( + [[0, np.nan, 2], [np.nan, 4, np.nan]], + index=df.index, + columns=df.columns, + ), + ) + + +class TestEventInfoFromInput(unittest.TestCase): + """Test retrieving event information from the input""" + + def setUp(self): + """Create input""" + self.input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame( + [[1, np.nan], [10, np.nan], [np.nan, np.nan]], + index=[1, 3, 10], + columns=["a", "b"], + ), + cost_func=lambda _: None, + impact_func_creator=lambda _: None, + impact_to_dataframe=lambda _: None, + assign_centroids=True, + ) + self.input.hazard.centroids.gdf["region_id"] = ["a", "b"] + self.input.hazard.event_name = ["event1", "event2", 3] + + def test_info_valid_hazard(self): + """Test retrieving event information from the input""" + info = event_info_from_input(self.input) + self.assertListEqual(list(info.keys()), ["event_id", "region_id", "event_name"]) + npt.assert_array_equal(info["event_id"], np.array([1, 3])) + npt.assert_array_equal(info["region_id"], np.array(["a"])) + self.assertListEqual(info["event_name"], ["event1", "event2"]) + + def test_info_invalid_hazard(self): + """Test retrieving event information if selection somehow failed""" + self.input.data.set_index(pd.Index([100, 101, 102]), inplace=True) + info = event_info_from_input(self.input) + self.assertListEqual(info["event_name"], []) + + +class ConcreteEnsembleOptimizer(EnsembleOptimizer): + """Concrete instantiation of an ensemble optimizer""" + + def input_from_sample(self, sample): + inp = copy.copy(self.input) # NOTE: Shallow copy! + inp.data = sample_data(inp.data, sample) + return inp + + +@patch("climada.util.calibrate.bayesian_optimizer.BayesianOptimizer") +class TestEnsembleOptimizer(unittest.TestCase): + """Test the AverageEnsembleOptimizer""" + + def setUp(self): + """Create input and optimizer""" + self.input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame( + [[1, 2], [10, 11], [100, np.nan]], + index=[1, 3, 10], + columns=["a", "b"], + ), + cost_func=lambda _: None, + impact_func_creator=lambda _: None, + impact_to_dataframe=lambda _: None, + assign_centroids=False, + ) + + @patch("climada.util.calibrate.ensemble.ProcessPool") + def test_run(self, pool_class_mock, opt_class_mock): + """Test initialization""" + # Mock the optimizer class + opt_mock = opt_class_mock.return_value + output = Output(params={"p1": 0.1, "p2": 2}, target=0.2) + opt_mock.run.return_value = output + + # Mock the process pool (context manager) + pool_mock = pool_class_mock.return_value.__enter__.return_value + pool_mock.imap.side_effect = map + + self.opt = ConcreteEnsembleOptimizer( + input=self.input, + optimizer_type=opt_class_mock, + optimizer_init_kwargs={"foo": "bar", "random_state": 2}, + ) + self.opt.samples = [[(0, 0)], [(1, 0), (1, 1)], [(2, 0)]] + + outputs = [] + for proc in (1, 3): + with self.subTest(processes=proc): + ens_out = self.opt.run(processes=proc, bar="baz") + outputs.append(ens_out) + + if proc > 1: + pool_class_mock.assert_called_once_with(nodes=proc) + + self.assertEqual(ens_out.data.shape[0], len(self.opt.samples)) + + # Test passing init_kwargs + self.assertEqual(opt_class_mock.call_args.kwargs["foo"], "bar") + + # Test update_init_kwargs + self.assertListEqual( + [call[1]["random_state"] for call in opt_class_mock.call_args_list], + [2, 3, 4], + ) + + # Test passing run kwargs + self.assertEqual(opt_mock.run.call_args.kwargs["bar"], "baz") + + # Test passing the input and sampling + pdt.assert_frame_equal( + opt_class_mock.call_args_list[0][0][0].data, + pd.DataFrame( + [[1, np.nan], [np.nan, np.nan], [np.nan, np.nan]], + index=[1, 3, 10], + columns=["a", "b"], + ), + ) + pdt.assert_frame_equal( + opt_class_mock.call_args_list[1][0][0].data, + pd.DataFrame( + [[np.nan, np.nan], [10, 11], [np.nan, np.nan]], + index=[1, 3, 10], + columns=["a", "b"], + ), + ) + pdt.assert_frame_equal( + opt_class_mock.call_args_list[2][0][0].data, + pd.DataFrame( + [[np.nan, np.nan], [np.nan, np.nan], [100, np.nan]], + index=[1, 3, 10], + columns=["a", "b"], + ), + ) + + # Reset mock calls + opt_class_mock.reset_mock() + opt_mock.reset_mock() + pool_class_mock.reset_mock() + pool_mock.reset_mock() + + pdt.assert_frame_equal(outputs[0].data, outputs[1].data) + + def test_run_empty_samples(self, opt_class_mock): + """Test execution with empty samples list""" + self.opt = ConcreteEnsembleOptimizer( + input=self.input, + optimizer_type=opt_class_mock, + optimizer_init_kwargs={"foo": "bar", "random_state": 2}, + ) + ens_out = self.opt.run(processes=1, bar="baz") + self.assertTrue(ens_out.data.empty) + + +class DummyInput: + def __init__(self, df): + self.data = df + self.stub = "a" + self.hazard = create_autospec(hazard()) + self.hazard.select.return_value = self.hazard + + +class TestAverageEnsembleOptimizer(unittest.TestCase): + """Test the AverageEnsembleOptimizer""" + + def setUp(self): + # Sample DataFrame with some NaNs + data = pd.DataFrame({"a": [1.0, None, None, 2.0], "b": [None, None, 3.0, 4.0]}) + self.input = DummyInput(data) + + def test_post_init_sampling(self): + opt = AverageEnsembleOptimizer( + input=self.input, sample_fraction=0.5, optimizer_type=ConcreteOptimizer + ) + samples = np.array(opt.samples) + self.assertTupleEqual(samples.shape, (20, 2, 2)) + + opt = AverageEnsembleOptimizer( + input=self.input, + ensemble_size=11, + sample_fraction=0.8, # Will cause rounding + optimizer_type=ConcreteOptimizer, + ) + samples = np.array(opt.samples) + self.assertTupleEqual(samples.shape, (11, 3, 2)) + + opt = AverageEnsembleOptimizer( + input=self.input, + ensemble_size=2, + sample_fraction=0.95, # Will cause rounding, always select all + optimizer_type=ConcreteOptimizer, + ) + + samples = [sorted([tuple(idx) for idx in arr]) for arr in opt.samples] + npt.assert_array_equal(samples[0], [[0, 0], [2, 1], [3, 0], [3, 1]]) + npt.assert_array_equal(samples[0], samples[1]) + + def test_sampling_replace(self): + """Test if replacement works""" + data = pd.DataFrame({"a": [1.0]}) + self.input = DummyInput(data) + opt = AverageEnsembleOptimizer( + input=self.input, + ensemble_size=1, + sample_fraction=3, + replace=True, + optimizer_type=ConcreteOptimizer, + ) + npt.assert_array_equal(opt.samples, [[(0, 0), (0, 0), (0, 0)]]) + + def test_invalid_sample_fraction(self): + with self.assertRaisesRegex(ValueError, "Sample fraction"): + AverageEnsembleOptimizer( + input=self.input, + sample_fraction=0, + optimizer_type=ConcreteOptimizer, + ) + with self.assertRaisesRegex(ValueError, "Sample fraction"): + AverageEnsembleOptimizer( + input=self.input, + sample_fraction=1.2, + replace=False, + optimizer_type=ConcreteOptimizer, + ) + + # Should not throw + AverageEnsembleOptimizer( + input=self.input, + sample_fraction=1.1, + replace=True, + optimizer_type=ConcreteOptimizer, + ) + + def test_invalid_ensemble_size(self): + with self.assertRaisesRegex(ValueError, "Ensemble size must be >=1"): + AverageEnsembleOptimizer( + input=self.input, + ensemble_size=0, + optimizer_type=ConcreteOptimizer, + ) + + def test_random_state_determinism(self): + opt1 = AverageEnsembleOptimizer( + input=self.input, + random_state=123, + optimizer_type=ConcreteOptimizer, + ) + opt2 = AverageEnsembleOptimizer( + input=self.input, + random_state=123, + optimizer_type=ConcreteOptimizer, + ) + for s1, s2 in zip(opt1.samples, opt2.samples): + np.testing.assert_array_equal(s1, s2) + + def test_input_from_sample(self): + opt = AverageEnsembleOptimizer( + input=self.input, + optimizer_type=ConcreteOptimizer, + ) + inp = opt.input_from_sample([(0, 0)]) + self.assertIsNot(inp, self.input) + self.assertIs(inp.stub, self.input.stub) + + +class TestTragedyEnsembleOptimizer(unittest.TestCase): + """Test the TragedyEnsembleOptimizer""" + + def setUp(self): + # Sample DataFrame with some NaNs + data = pd.DataFrame({"a": [1.0, None, None, 2.0], "b": [None, None, 3.0, 4.0]}) + self.input = DummyInput(data) + + def test_post_init_sampling(self): + opt = TragedyEnsembleOptimizer( + input=self.input, optimizer_type=ConcreteOptimizer + ) + samples = np.array(opt.samples) + self.assertTupleEqual(samples.shape, (4, 1, 2)) + npt.assert_array_equal(samples, [[[0, 0]], [[2, 1]], [[3, 0]], [[3, 1]]]) + + opt = TragedyEnsembleOptimizer( + input=self.input, + ensemble_size=2, + optimizer_type=ConcreteOptimizer, + ) + samples = np.array(opt.samples) + self.assertTupleEqual(samples.shape, (2, 1, 2)) + + def test_invalid_ensemble_size(self): + with self.assertRaisesRegex(ValueError, "Ensemble size must be >=1"): + TragedyEnsembleOptimizer( + input=self.input, + ensemble_size=0, + optimizer_type=ConcreteOptimizer, + ) + with self.assertRaisesRegex(ValueError, "here: 4"): + TragedyEnsembleOptimizer( + input=self.input, + ensemble_size=5, + optimizer_type=ConcreteOptimizer, + ) + + def test_random_state_determinism(self): + opt1 = TragedyEnsembleOptimizer( + input=self.input, + random_state=2, + optimizer_type=ConcreteOptimizer, + ) + opt2 = TragedyEnsembleOptimizer( + input=self.input, + random_state=2, + optimizer_type=ConcreteOptimizer, + ) + for s1, s2 in zip(opt1.samples, opt2.samples): + np.testing.assert_array_equal(s1, s2) + + def test_input_from_sample(self): + opt = TragedyEnsembleOptimizer( + input=self.input, + optimizer_type=ConcreteOptimizer, + ) + inp = opt.input_from_sample([(3, 0)]) + self.assertIsNot(inp, self.input) + self.assertIs(inp.stub, self.input.stub) + pdt.assert_frame_equal(inp.data, pd.DataFrame({"a": [2.0]}, index=[3])) + inp.hazard.select.assert_called_once_with(event_id=pd.Index([3])) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSampleData) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestEventInfoFromInput)) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestEnsembleOptimizerOutput) + ) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestEnsembleOptimizer)) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestAverageEnsembleOptimizer) + ) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestTragedyEnsembleOptimizer) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/doc/climada/climada.util.calibrate.rst b/doc/climada/climada.util.calibrate.rst index e56cdb6b8..1c069cd02 100644 --- a/doc/climada/climada.util.calibrate.rst +++ b/doc/climada/climada.util.calibrate.rst @@ -30,3 +30,13 @@ Calibration based on the ``scipy.optimize`` module. :members: :show-inheritance: :inherited-members: abc.ABC + +Ensemble Optimizers +------------------- + +Calibration creating ensembles of impact functions. + +.. automodule:: climada.util.calibrate.ensemble + :members: + :show-inheritance: + :inherited-members: abc.ABC diff --git a/doc/tutorial/climada_util_calibrate.ipynb b/doc/tutorial/climada_util_calibrate.ipynb index 0efefc5a2..ee430c8d3 100644 --- a/doc/tutorial/climada_util_calibrate.ipynb +++ b/doc/tutorial/climada_util_calibrate.ipynb @@ -40,16 +40,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/site-packages/dask/dataframe/_pyarrow_compat.py:17: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "import logging\n", "import climada\n", @@ -69,42 +60,22 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-07-08 16:36:14,126 - climada.entity.exposures.base - INFO - Reading /Users/ldr.riedel/climada/data/exposures/litpop/LitPop_150arcsec_MEX/v3/LitPop_150arcsec_MEX.hdf5\n", - "2024-07-08 16:36:20,330 - climada.hazard.base - INFO - Reading /Users/ldr.riedel/climada/data/hazard/tropical_cyclone/tropical_cyclone_0synth_tracks_150arcsec_global_1980_2020/v2/tropical_cyclone_0synth_tracks_150arcsec_global_1980_2020.hdf5\n", - "2024-07-08 16:36:28,741 - climada.entity.exposures.base - INFO - Matching 100369 exposures with 6125253 centroids.\n", - "2024-07-08 16:36:30,939 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2024-07-08 16:36:34,188 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", - "2024-07-08 16:36:34,646 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", - "2024-07-08 16:36:34,996 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", - "2024-07-08 16:36:35,313 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", - "2024-07-08 16:36:35,690 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n", - "2024-07-08 16:36:35,733 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2024-07-08 16:36:35,736 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2024-07-08 16:36:35,736 - climada.entity.exposures.base - INFO - Matching 100369 exposures with 6125253 centroids.\n", - "2024-07-08 16:36:37,907 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2024-07-08 16:36:41,611 - climada.engine.impact_calc - INFO - Calculating impact for 292230 assets (>0) and 1 events.\n" - ] - }, { "data": { "text/plain": [ - "{'v_half': 48.30330549244917}" + "{'v_half': 48.30330871103452}" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -114,7 +85,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -208,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -1029,7 +1000,7 @@ "[27 rows x 22 columns]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -1061,7 +1032,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -1494,7 +1465,7 @@ "2017260N12310 NaN NaN " ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -1537,7 +1508,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -1551,44 +1522,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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", - "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/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.util.api_client import Client\n", "from climada.entity.exposures.litpop import LitPop\n", @@ -1605,7 +1541,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -1617,7 +1553,7 @@ " 'climate_scenario': ['None']}" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -1644,7 +1580,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -1675,7 +1611,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -1722,7 +1658,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -1751,7 +1687,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -1787,7 +1723,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -2200,7 +2136,7 @@ "1458 6.700905e+10 NaN NaN NaN NaN " ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -2256,24 +2192,21 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2024-04-29 14:09:45,569 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", - "2024-04-29 14:09:46,990 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", - "2024-04-29 14:09:49,255 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", - "2024-04-29 14:09:50,873 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", - "2024-04-29 14:09:50,874 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", - "2024-04-29 14:09:52,698 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", - "2024-04-29 14:09:52,699 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 4\n", - "2024-04-29 14:09:55,673 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 5\n", - "2024-04-29 14:09:58,819 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 6\n", - "2024-04-29 14:10:02,072 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 7\n", - "2024-04-29 14:10:06,238 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + "2025-04-25 14:26:34,488 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2025-04-25 14:26:36,470 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2025-04-25 14:26:38,750 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2025-04-25 14:26:41,150 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", + "2025-04-25 14:26:43,701 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 4\n", + "2025-04-25 14:26:46,994 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 5\n", + "2025-04-25 14:26:51,476 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 6\n", + "2025-04-25 14:26:55,846 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" ] } ], @@ -2324,7 +2257,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -2406,38 +2339,38 @@ " ...\n", " \n", " \n", - " 246\n", - " 0.790590\n", - " 50.164555\n", - " 0.765166\n", + " 219\n", + " 0.711722\n", + " 51.676720\n", + " 0.773888\n", " \n", " \n", - " 247\n", - " 0.788425\n", - " 48.043636\n", - " 0.768636\n", + " 220\n", + " 0.920148\n", + " 48.767231\n", + " 0.771611\n", " \n", " \n", - " 248\n", - " 0.826704\n", - " 49.932348\n", - " 0.764991\n", + " 221\n", + " 0.903950\n", + " 50.001948\n", + " 0.765957\n", " \n", " \n", - " 249\n", - " 0.880736\n", - " 49.290532\n", - " 0.767437\n", + " 222\n", + " 1.000000\n", + " 52.968129\n", + " 0.764202\n", " \n", " \n", - " 250\n", - " 0.744523\n", - " 51.596642\n", - " 0.770761\n", + " 223\n", + " 0.799534\n", + " 49.721017\n", + " 0.765107\n", " \n", " \n", "\n", - "

251 rows × 3 columns

\n", + "

224 rows × 3 columns

\n", "" ], "text/plain": [ @@ -2450,16 +2383,16 @@ "3 0.194398 68.718642 1.683610\n", "4 0.402800 92.721038 2.046407\n", "... ... ... ...\n", - "246 0.790590 50.164555 0.765166\n", - "247 0.788425 48.043636 0.768636\n", - "248 0.826704 49.932348 0.764991\n", - "249 0.880736 49.290532 0.767437\n", - "250 0.744523 51.596642 0.770761\n", + "219 0.711722 51.676720 0.773888\n", + "220 0.920148 48.767231 0.771611\n", + "221 0.903950 50.001948 0.765957\n", + "222 1.000000 52.968129 0.764202\n", + "223 0.799534 49.721017 0.765107\n", "\n", - "[251 rows x 3 columns]" + "[224 rows x 3 columns]" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -2478,7 +2411,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -2531,32 +2464,25 @@ " 2.406088\n", " \n", " \n", - " 23\n", - " 0\n", - " False\n", - " -0.799484\n", - " 0.001409\n", - " \n", - " \n", - " 25\n", + " 24\n", " 0\n", " False\n", - " -0.794119\n", - " 0.006756\n", + " -0.793780\n", + " 0.008605\n", " \n", " \n", " 29\n", " 0\n", " False\n", - " -0.791723\n", - " 0.003026\n", + " -0.791065\n", + " 0.003432\n", " \n", " \n", " 40\n", " 1\n", " False\n", " -0.781115\n", - " 0.013581\n", + " 0.012737\n", " \n", " \n", " 44\n", @@ -2566,88 +2492,74 @@ " 0.004119\n", " \n", " \n", - " 55\n", + " 48\n", " 1\n", " False\n", - " -0.772557\n", - " 0.006929\n", + " -0.774136\n", + " 0.004876\n", " \n", " \n", - " 88\n", - " 2\n", + " 60\n", + " 1\n", " False\n", - " -0.768626\n", - " 0.005115\n", + " -0.773844\n", + " 0.000377\n", " \n", " \n", - " 92\n", + " 81\n", " 2\n", " False\n", - " -0.768494\n", - " 0.000172\n", + " -0.770928\n", + " 0.003782\n", " \n", " \n", - " 93\n", + " 87\n", " 2\n", " False\n", - " -0.768144\n", - " 0.000456\n", - " \n", - " \n", - " 113\n", - " 3\n", - " False\n", - " -0.767889\n", - " 0.000333\n", + " -0.770386\n", + " 0.000704\n", " \n", " \n", - " 115\n", - " 3\n", + " 89\n", + " 2\n", " False\n", - " -0.767105\n", - " 0.001021\n", + " -0.768256\n", + " 0.002773\n", " \n", " \n", - " 116\n", + " 117\n", " 3\n", " False\n", - " -0.766561\n", - " 0.000709\n", + " -0.765309\n", + " 0.003850\n", " \n", " \n", - " 122\n", + " 123\n", " 3\n", " False\n", - " -0.766400\n", - " 0.000211\n", - " \n", - " \n", - " 142\n", - " 4\n", - " False\n", - " -0.765210\n", - " 0.001556\n", + " -0.765110\n", + " 0.000260\n", " \n", " \n", - " 146\n", + " 156\n", " 4\n", " False\n", - " -0.764947\n", - " 0.000343\n", + " -0.764939\n", + " 0.000223\n", " \n", " \n", - " 173\n", + " 178\n", " 5\n", " False\n", - " -0.764000\n", - " 0.001240\n", + " -0.763951\n", + " 0.001294\n", " \n", " \n", - " 216\n", - " 6\n", + " 189\n", + " 5\n", " False\n", - " -0.763936\n", - " 0.000084\n", + " -0.763910\n", + " 0.000054\n", " \n", " \n", "\n", @@ -2658,26 +2570,23 @@ "sample \n", "0 0 True -2.726950 inf\n", "2 0 True -0.800611 2.406088\n", - "23 0 False -0.799484 0.001409\n", - "25 0 False -0.794119 0.006756\n", - "29 0 False -0.791723 0.003026\n", - "40 1 False -0.781115 0.013581\n", + "24 0 False -0.793780 0.008605\n", + "29 0 False -0.791065 0.003432\n", + "40 1 False -0.781115 0.012737\n", "44 1 False -0.777910 0.004119\n", - "55 1 False -0.772557 0.006929\n", - "88 2 False -0.768626 0.005115\n", - "92 2 False -0.768494 0.000172\n", - "93 2 False -0.768144 0.000456\n", - "113 3 False -0.767889 0.000333\n", - "115 3 False -0.767105 0.001021\n", - "116 3 False -0.766561 0.000709\n", - "122 3 False -0.766400 0.000211\n", - "142 4 False -0.765210 0.001556\n", - "146 4 False -0.764947 0.000343\n", - "173 5 False -0.764000 0.001240\n", - "216 6 False -0.763936 0.000084" + "48 1 False -0.774136 0.004876\n", + "60 1 False -0.773844 0.000377\n", + "81 2 False -0.770928 0.003782\n", + "87 2 False -0.770386 0.000704\n", + "89 2 False -0.768256 0.002773\n", + "117 3 False -0.765309 0.003850\n", + "123 3 False -0.765110 0.000260\n", + "156 4 False -0.764939 0.000223\n", + "178 5 False -0.763951 0.001294\n", + "189 5 False -0.763910 0.000054" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -2695,7 +2604,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -2760,33 +2669,33 @@ " ...\n", " \n", " \n", - " 246\n", - " 0.790590\n", - " 50.164555\n", + " 219\n", + " 0.711722\n", + " 51.676720\n", " \n", " \n", - " 247\n", - " 0.788425\n", - " 48.043636\n", + " 220\n", + " 0.920148\n", + " 48.767231\n", " \n", " \n", - " 248\n", - " 0.826704\n", - " 49.932348\n", + " 221\n", + " 0.903950\n", + " 50.001948\n", " \n", " \n", - " 249\n", - " 0.880736\n", - " 49.290532\n", + " 222\n", + " 1.000000\n", + " 52.968129\n", " \n", " \n", - " 250\n", - " 0.744523\n", - " 51.596642\n", + " 223\n", + " 0.799534\n", + " 49.721017\n", " \n", " \n", "\n", - "

251 rows × 2 columns

\n", + "

224 rows × 2 columns

\n", "" ], "text/plain": [ @@ -2798,16 +2707,16 @@ "3 0.194398 68.718642\n", "4 0.402800 92.721038\n", "... ... ...\n", - "246 0.790590 50.164555\n", - "247 0.788425 48.043636\n", - "248 0.826704 49.932348\n", - "249 0.880736 49.290532\n", - "250 0.744523 51.596642\n", + "219 0.711722 51.676720\n", + "220 0.920148 48.767231\n", + "221 0.903950 50.001948\n", + "222 1.000000 52.968129\n", + "223 0.799534 49.721017\n", "\n", - "[251 rows x 2 columns]" + "[224 rows x 2 columns]" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -2827,7 +2736,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -2873,34 +2782,34 @@ " \n", " \n", " \n", - " 216\n", - " 0.993744\n", - " 52.255606\n", - " 0.763936\n", + " 189\n", + " 1.000000\n", + " 52.392756\n", + " 0.763910\n", " \n", " \n", - " 173\n", - " 0.985721\n", - " 52.026516\n", - " 0.764000\n", + " 178\n", + " 1.000000\n", + " 52.176366\n", + " 0.763951\n", " \n", " \n", - " 177\n", - " 0.881143\n", - " 51.558665\n", - " 0.764718\n", + " 185\n", + " 1.000000\n", + " 52.647236\n", + " 0.763968\n", " \n", " \n", - " 146\n", - " 0.967284\n", - " 51.034702\n", - " 0.764947\n", + " 222\n", + " 1.000000\n", + " 52.968129\n", + " 0.764202\n", " \n", " \n", - " 248\n", - " 0.826704\n", - " 49.932348\n", - " 0.764991\n", + " 180\n", + " 1.000000\n", + " 51.656630\n", + " 0.764398\n", " \n", " \n", " ...\n", @@ -2909,60 +2818,60 @@ " ...\n", " \n", " \n", + " 139\n", + " 0.081255\n", + " 145.935720\n", + " 5.822272\n", + " \n", + " \n", " 35\n", " 0.028105\n", " 118.967924\n", " 6.298332\n", " \n", " \n", - " 95\n", + " 97\n", " 0.012842\n", " 102.449398\n", " 6.635728\n", " \n", " \n", - " 199\n", + " 204\n", " 0.031310\n", " 143.537900\n", " 7.262185\n", " \n", " \n", - " 99\n", + " 101\n", " 0.025663\n", " 141.236104\n", " 7.504095\n", " \n", - " \n", - " 232\n", - " 0.010398\n", - " 147.113486\n", - " 9.453765\n", - " \n", " \n", "\n", - "

251 rows × 3 columns

\n", + "

224 rows × 3 columns

\n", "" ], "text/plain": [ " Parameters Calibration\n", " scale v_half Cost Function\n", "Iteration \n", - "216 0.993744 52.255606 0.763936\n", - "173 0.985721 52.026516 0.764000\n", - "177 0.881143 51.558665 0.764718\n", - "146 0.967284 51.034702 0.764947\n", - "248 0.826704 49.932348 0.764991\n", + "189 1.000000 52.392756 0.763910\n", + "178 1.000000 52.176366 0.763951\n", + "185 1.000000 52.647236 0.763968\n", + "222 1.000000 52.968129 0.764202\n", + "180 1.000000 51.656630 0.764398\n", "... ... ... ...\n", + "139 0.081255 145.935720 5.822272\n", "35 0.028105 118.967924 6.298332\n", - "95 0.012842 102.449398 6.635728\n", - "199 0.031310 143.537900 7.262185\n", - "99 0.025663 141.236104 7.504095\n", - "232 0.010398 147.113486 9.453765\n", + "97 0.012842 102.449398 6.635728\n", + "204 0.031310 143.537900 7.262185\n", + "101 0.025663 141.236104 7.504095\n", "\n", - "[251 rows x 3 columns]" + "[224 rows x 3 columns]" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -2982,7 +2891,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -2991,13 +2900,13 @@ "" ] }, - "execution_count": 44, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAGxCAYAAAC9csYjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydZ5gUVdaA31vVuSdHcgYVVERBRUTBgFnMOaLruu63Bsy6a8K8q6KuOWPOaY1gAhQVBFGRnPPk6ZnOXXW/Hz2R6Tw9kXp92qGrbjjVXV116twThJRSYmBgYGBgYGDQwSgdLYCBgYGBgYGBARhKiYGBgYGBgUEnwVBKDAwMDAwMDDoFhlJiYGBgYGBg0CkwlBIDAwMDAwODToGhlBgYGBgYGBh0CgylxMDAwMDAwKBTYCglBgYGBgYGBp0CU0cL0N7ous6WLVvIzMxECNHR4hgYGBgYdGKklNTU1NCrVy8Upe2e430+H4FAoNXjWCwWbDZbGiTqGHY6pWTLli307du3o8UwMDAwMOhCbNy4kT59+rTJ2D6fj2x7LgF8rR6rR48erF27tssqJjudUpKZmQmET7CsrKwOlsbAwMDAoDPjcrno27dvw72jLQgEAgTwcaA4FhPmlMcJEWTutv8RCAQMpaSrUL9kk5WVZSglBgYGBgYJ0R7L/SbMmETqSgndoJLdTqeUGBgYGBgYdEaEIlql/AgpQEujQB2AoZQYGBgYGBh0BoQSfqVM1w+o7fpHYGBgYGBgYNAtMCwlBgYGBgYGnYC0LN90cQylxMDAwMDAoDMgRCuXb7q+UmIs3xgYGBgYGBh0CgxLiYGBgYGBQWdAEWFrSaoYyzcGBgYGBgYGaUG0UinpBss3hlJi0ICUEkJ/ILUyhFoApt0jOl1JqUFwMejVoPZCmHdJcT4dgr+BXglqDzDtmrCTlwxtQmqrwrIqmQglD8x7IRJIPKSH1iJD60DYEaZhyNCfIEMo5t0QanEMeUOAmpCMWmgTWmgVQtgwWfZCiJbZFXWtnGDwdwDMlpEoSm7ccZNF1934AguRMojFvCtmU6+0jh8IbcMTXIoQZjIse6EqGWkZV0qNav9vBPVq7KZeZFiGpWVcg9SoDVax1bcGgUJvx1DsqrOjRTLopnSoUjJ79mz+/e9/88svv7B161bef/99TjjhhJh9vvvuO6ZOncqSJUvo1asX1113HZdeemn7CNyN0X1foNf8G7R1jRvVASiZ16LYjmjYJD1vIWsfBX1747Z61yThAKUXWPZFOM5EmIe2mEdKDfzfImsfgdBKINS40zQMMm9EWMdFlVOGVqO57oDA903mr0Pko2T8DeE4P6LioAeXEKy+HT04P8roCor1MCzZtyHUnuGxdS8Bz8sE3C8htY2ACZPtUCzOSzBZx7QYQQutxl19C0H/7AbJhMjGlnER9owrEEJF18pxVd+Gz/thk+M3Y3OcQlb2rShK6zMN69JHefV9VLtnIKW3bqvAaTucwpw7MZtaV8PDH9rChspbqfLOov44FWGjMOMs+mRfh6KkluJaSsnmmrdZU/U4fq3xHMu07MawvBvIs+/bKrkNkqMmWMmnW59jSfU8JDoAJmFmVO4hHNHjfKyqvYMl7F4IRUG0wtFVyK7vJtqhR+B2uxk5ciT//e9/E2q/du1ajj76aMaPH8+iRYu46aabuPzyy3n33XfbWNLug5Qt8xDrnnfRq/4O2vrmO7T16FV/R/eEP19Z+wTS9c9mCkndCOGXrAVtBXhfQZYfg151M3pwBTK0Hil1pO5BVl6ArPobhJbSTCEBCK1EVl6E9H0VWfbQGrTyUyAwL8rBlaPX3Ilee3/LYwz+gb/sFPTgwsh9645D93+Fr+wEpLYdqdfgLj8Zv+uuOoUEIETINwtP+SkE3K83/7hCq6kuPZagfy5N8z1LWY235iFqK69A06ooL5uMz/vBDscfxOd5i4rSk9B1dwwZ4yNlkC1l51NV+0wThQRA4vZ9xcaSowmGNqc8fiC0jaXbJlPl/Zqmx6lLH9trXmRF6YXoMpjS2GurnmRp+a3NFBKAmsByftl2IWWeuSnLbZAc7lA1T6++gT+bKCQAIRlkQcVMXlx7K0Hd34ESdkPql29a8+ridKil5KijjuKoo45KuP2TTz5Jv379mD59OgC77bYbCxYs4D//+Q8nn3xyG0nZ9ZG6i5DnZULuV0HfBsKOajsOk/MihNoD3XVrfcsdewKgu65H+n9E+D9KbmLf2+B7OzyK0guEE7SVsSQN/7/6JrDObbEUo7mmgXRDkwtkxFHczyBtJyLMjSb/QPXNQCBuX9BALydY8wCaFOjBP2n5uYTzOPuqb0C1jEE1DwHAXf0vpPQQOc+zJOD7AF2G0ELrosihEQotw+N+jozMy+PIGZ0azwd4/XOi7NXQ9ErKq++lR/6jKY2/qeo/BPUKIh+nTo1/HuXu9ynMOC2pcb3BTayuiiaTDgj+LLuZ8X2/Rgg1SakNkuXbkrepDpY1U0jqkehs8q5iQcWXjC04rgOk66YorczoalhK2pd58+YxadKkZtuOOOIIFixYQDCY2pNZd0dqpfjLjidU8yDoWwEJ0oPmfQd/2bFotQ8CCTzt+D8g0WpP4j/l8GB58436lrBC8mB5eH90iUFWIn2zdjiOzRCYS3ylAkBF977ROHVwKTL4W4J9ATRCng8Iet+J00ch6JkR7hHaWLdkE6vwhErA/3mcMXU8tS9EtGglSlXti8T+aWvUeD9E06uSHjuku6jwfEjs41QoqXk56bE317xDbEc9iV8roczb9awlmgyyyvUV80qe4KfSp9nk/qVV33FbE9QD/FIxK6JC0ojkx/LP2k0mg7ahpqaGK6+8kv79+2O32znggAOYPz/aEnfb06UcXbdt20ZxcXNHxOLiYkKhEGVlZfTs2bNFH7/fj9/feNN1uVxtLmdnIlB1NVLbRMsboQboaJ5XUVFpsZSyAxKJSNCzWyqg/LsiPOPU/MYdD5aHt1+bF3+Q2seRtkkIoSL1CmTt43WzC2Rc5UhDhpY3vNNDqxKSu9kxJGhVCfnmQDZooVgWoMb2IoEbka5vR0ovQjgSEbUFgdAK4sseIhjagGrJSXLsjUjiPQDo+FL4zGuDq4gvt4o7uJpCDk56/I5ik3s+X22Zhk+vRsGERPJrxavkWPpxRO+7ybH07WgRW1ATqiAo4z+sVAS2oksdpVUJvwwa6IDom4svvpg//viDl19+mV69evHKK69w2GGH8eeff9K7d+9WyJIaXe5M2tGBsf5pI1pExD333EN2dnbDq2/fzncBaCv00Br0wByiP9VKhNSQcRSSpJmaj35tHsq/KxotJk0VkqaKSjS05eB5Ael5A1lyIHjfadiloMRRkATQ6GgphDW140gIrW6O1Bw7IyMSiiKKhpLg8abyuSR6nEJYkh5bFTbiX5J01Db9PtNLiXcpn226AZ8efhjSCSHrzpnqwGY+2vAPvKHKjhQxIqYEvz9VmBJ+WDFIACHCuUpSfSWp0Hi9Xt59913uv/9+DjroIIYMGcJtt93GwIEDeeKJJ9roIGPTpZSSHj16sG3btmbbSkpKMJlM5OdHvtHdeOONVFdXN7w2btwYsV13RA/8GHWfQGBCQZCYbp30haeJYiL6r0pOIalD1j6JdN1C2IoTttQ0lSO6TBJhaYyMUSz7A8ncyASK2of4Pw8VpW4ek2UUQmTGbS/UHnHGVbFYD26VUuK0Hw3E9rkwqX2wmFpGR8XDZhqIRe1H7LNGJdd+RIz9kSlwTCSRJbYCe9exkswve65uCaSlhUyi4dOq+aPq/fYXLA6Zplx62PrH/N0rKOySOaZVtVoM2gaXy9Xs1XS1oCmhUAhN07DZmj9s2O125s7tmGXSLqWUjB07lpkzZzbb9uWXXzJ69GjM5sgXcavVSlZWVrPXzoAeWkOwNrKmKwCVcOGnNr2gTM1HWgQiIJEWkZRCAoCMvtQW7WIppURKSajmfgLl56IHfkMoWajOs0n8dJeYM/+OyXYUsW/uGlbneWF5hB2b8yKi36wFYMKeOZXYN14NZ0brQtxzMqZE3C4l6BI0CRbzKPwJLTk1RwiFnll/JbZ/kaQ484Kkxy52Ho5VLSb6Z65S5DgMu7l14czthTdUySbP/Jh+GRKdZdWftKNUiSGEYHzhyTGXSnV0xhUc345SdX+EUFr9Aujbt2+zFYJ77rkn4nyZmZmMHTuWadOmsWXLFjRN45VXXuGnn35i69at7XnoDXSoUlJbW8uvv/7Kr7/+CoRDfn/99Vc2bNgAhK0c5513XkP7Sy+9lPXr1zN16lSWLl3K888/z3PPPcc111zTEeJ3WvTQJvxlJ4O2JeJ+JcmvfUcLRcI8WN6gkIiAbOn8mgbq5apXRgD0+iiewDyC5aehB+ZjzrwexTqhrlf0mx6A6rwI1X4Gtuzb6/KV7Ng+/PlZM69GtYxs2GrPvBKL7ZgIcyiAhcy8Z3E4zyYj68YIbcL/zsyehtV2UAJHHh2reVd65D1WN2Z4XCkhhEBDoCOo9n7Cmm2HsK7kFIKh5C4+hRlnUZRxYZRjUBmU/xAOy/Ck5VaEhb17PItFyaG5chf+vLOswxleeFfS43YUHq0ioXa+Trh8A7BnzngmFJ0KNL9m1C+fTu59Gf2cu3aUeN2T1izd1L+AjRs3NlshuPHGG6NO+fLLLyOlpHfv3litVh555BHOOussVLVjItyE7EAX8G+//ZaJEye22H7++efz4osvcsEFF7Bu3Tq+/fbbhn3fffcdV111VUPytOuvvz6p5Gkul4vs7Gyqq6u7ldVE17aja5sQIoNQ7XPovveI5ktiQknYQtIahaTZkk2yPiUJIuv/k/X/2hEF1F5YCr8FQPfPIuR5DRlaBZhByQ1nhRUgzHthcp6L2mTpR9fKCdQ+SsDzBkhPeETzHlgz/obZfmxLeaRO0P8NPvcMtOBSEDYs9qOwOc5FbZKwLBj4Dbf7RYL+eYDAYj0QR8YFmM3J38yjEQitpbp2BjXeT/GFNhPZuqFiVnsxqPgzVDW5jLI1vp8pqZ2B278YIcxk2ydQlHEuNvPAVskd1KrZUvs+W2s/IqhVYzf3oXfmaRQ7D0dJwVelo/CEynl59Ulx29nVPM4b0v5LOCE9QIl/AyApsPbFEiXh3UbPCn4q/4wN7qUoQmFwxkj2yz+aItvO4Z/XHveM+jkOK5iCSUn9HA/pAWaVPZ+SrG63G5fLRc+ePTn99NOpra3lk0/a34rXoUpJR9DdlBItuAyf6x40/7c03nQEKkT1iDcnmOMhKYUk8w6omQ5URFdAklJMFOLmI6m3iCDRZOy25rwZKNYD4x5G1LmkH6mVgLChqIUpjxMKrSEY+AMhzFgs+6Ko6VPQorGp/P9weT4iusOzQmHW1RRmX9nmsuxsfLzhSrZ6F0ddwhEojMw7k/0KL2k3mYK6n9klb7Cg4jP8eljRNgsro3IPZ2LxOVjV1KK+uivtqpQUXtR6paT0uVbJWllZycCBA7n//vu55JL2Oy/r6VIhwQbN0QK/4S4/FWSA5k/BYf9+KXXUCIqJlDIBS4mJxPN6AHoJCB1k+E9ExWNqfjgFlh4v44kKai/AidSWxclckYhOraAHl7VKKRHCijCl/mQYCq3BVXk9gSbp8cOp5U8mK/sOlDTVjNkRTa/B5fmY2HlFdCrdrxhKSRswuuBCPt54JeHlqObnqkDBomSwe258a0q6COlBXlt3Oxs8S5r9doLSz/yKT1nvWcIFA+8xFJOOorUhwSn0/eKLL5BSsssuu7Bq1SquvfZadtllFy688ML4ndsAQynpokgp8VZdA9JPNOVBR6JEUEDC26OHUYexIdVikBpC30zsm5oF3I2lAuQ1MZ7+b/0PqD3D2UZMIxC+T5CeGaDX+5tYwH4CInMqBJdB5YVI9BYWm0YriQg7TMREtiqapbWEQhsoLzkO2cJxN5xaXguuIK/wnTSHFdfNrZUQLwdNuN22BJVVg2To6RjJpF7T+HrbXQR1DwoqkvBjg9NUyJF97sFpKmg3eX6p+Iz1niVEjgbSKfGt54ey95lYfHa7yWTQsdT7nGzatIm8vDxOPvlk7rrrrqjBI22NoZR0UbTgr+ihZXHb6UhUIigliDg3oVrQautaxkIQTt8eD4HIuArhvLDJFiDjb+C8GEKrgBCoAxBKXWit9QDIeRxZdSXgb1BEGpxbEQhhQ5O1ceaWCOv4BGRsG2pd99UpJJHTsgeDC/F63sbhPDftc6tKdkLtFOFMSCGRUhLQtiIJYVGLE86JsjMzIPNAznW+x2rX15T6l6Og0tuxD/0yxqK0c7r8nys+IZadUqKzoOJTDi46o91lMyCcZl5pTfxJ8n1PO+00TjstuZIQbYmhlHRRwjVZ4hNteUNDD3vUx3061utb0tzPo66Pkg96BXGXenJfAssYpFYOwoposlwhhBnMu0XsJmyHIooWQM3d4PsUKSvrjsmEsB2NyPg7WvnpoFdFkUFFWMehmAbFlq+N0PUqfN54yycCT+2LbaKUmNQCHJb98ATmE/07Usl2nBhzHCklpe7X2eZ6Gn9oXbiXyKQw4yx6Zv8dUxoqG3dnzIqdXXOOYVeOid+4jQjpQSoD8SOtvFoNtaEqssxt7+9ksAMdsHzT2ehSeUoMmpBwFELLkzScMC2crl2vcxKN7e+sh8NsmybNUvsiMm8GkUNCvieeGciS/ZClY5Ele6OXn430f5vQESiKFSX7dpSin1ELZqHmf4Ra9BNqzoMopsGYc58PF/trdjrXHaVpEOacBxOapy3QQpuIv3wiCWlr20yGguwrif50rCAwkZd5cdT+UkrWV9zM+oqb8IcaK0lrsoZtNc+ydPsphPTqtMpskH6SSQWvCuN5tUMQtLJKcEcfQOsxlJIuisk6jvhnoMBkGY8w71n3rlEhad4qnn9JGF0tRhT/iSj+A6VwFsJ5HiRqvvd/3TwZWvAXZOUlSPcLifWvk1GYBiDMwxFNliUUy55YCr9Ezfg7qH1AZCFMu2DKuh1z/vsIJYFaO22EUBJ0GJRWXK772LZ1FFs292fb1lG4XPehaSWtliHDdhC98h4gnEek/icfPhMUYadv4UtY6yodR6La9w2l7tfqBd1hr4YvuJrNVWHFT9Nr2V7zBusq72ZD1UPU+n9vtfwG6UERKgOceyJiXvYFxdYBOFTD8mXQMRjqcBdFUXthsh1NyPc5kZcGFBAObHmPgfQQKBnXyhklSG9dyfgma83WgyC0lPjWkh33h9/LmnvAcgDCvEurpBNqMabMqzBlXtWqcdKNqg5ENQ1CC60lmrVCoiDxUVvzKPWfi65vp7bmUTzul8kveB+zOfmU8E3JcZ5Ohm0ilbWv4Q0sRggVp3Uc2c5TUJXY6fG317xE+DuPtgSlUeZ+C4tpKOur7kGXXkRd4blN1Y+SZd2XXQofw9wO4c8GsRlbcALr3L/FaCEZW3Ci4fDcURjLN4alpCtjz7kXpSHZVtOTUQVhw5H3AkLJRqg9EeYxtO7rVhGmloqDcJwRni9lu6GK9LwWv1kMpJTogflonjfQPO8jtdIE+4WQCVRCbQ1CCDIyLie6QkJdDosgkRQ3Xa+movw8ZJw8LIlgUosozL6SfoUv0LfgWfIyL4yrkAC4/YuI7RMDId3L2spb0KUXoK7IY7iPy/8LS7afi77DZ+0JrmVVxX/4veRy/iy9gVLPV0gZex6D1jE0czQTi84BQGnycFFvPdkv/3j2yJnQEaIZQNoyunZlDEtJF0Yo2TgL3iXoeY+A+xV0bQNCZGB2TMbiOA/F1Fh22pQ5lWDF2eyYL0GQ6FqzhuI4s6UMak/ImY6suqJu3PqbSsu8DNHGJfBzAu0iowfmE6q6EamtabJVRbGfiCn7doSwt5zR9xUh97PogZ8AiVAHYHKej+o4K6XqtvGwOU4lpK3DXTOd5hYHpe4VIrqlSUPT1uP3f4vNdkjKMgRCG3D7fgCC2CwjsVv2TLyzEDG/SilBi6mUaniCyyj3fE6hczJSSlZX3s8G1/OEPw8dUNjmfh+HeRB7FT+HzdQrcfkMkmJ80Wn0c47g5/KPWev+DaSkr2M3xuQfy+CMUYaVxKBDMZSSLo4QNizOs7A4z4rZTrHuhyn3MUJV14B0E/7qJSLBBGnCcT7CvHvkfbbDIf/DcL4R3+cgfWAaAObR4H01kdETkmFH9MAiguXn0PIpXkP3vkdQ24Q5bwaiidNesGY6odqHCSsDdblOtPUEXXeg+WZiyXsekeYwVyEEmVnXYbMdhcc9g2BgEQgLVtsENK0Mj+cNYjvDmvD756SklIS0CrZUTKXWN4ummoXNvDu98h7GZolfuyTbNp4Kz2dEs5bUB2rHRqGk9m0KnZNZX/1MnUJCkzHDf73B9Szadj779f6kS6WU72r0d46gv3NER4thsCPG8o2xfLMzodqOwFL0E6bse1AcZ6BaxiX2VGTaCyXznzGbCPNQlOxpKMXzUXr8jlLwMSLj/4hdZZfwfuv+CR9DU0KuOwnfzCIpVjoy8CO678uGLZr/hzqFhB361C2iBH4kVPtYSrIkgtmyB9m5/6ageBYFRZ+SmXVdnQKUwHeQwrKGpteyruQkan1fs6OpwxdcyrqSyfiDq+OOU5R5IfFCmuOjEwhtQ9N9rK9+MmoriYY3tIES9+cJjGlg0M0QSutfXZyufwQGSSEUB6rjdMzZd6DYDiShU0DJTcmkK9R8sB1NbMVERzhiW3ki9gqtRgYXEdvBVkHzvN7wLuR+Ia4sIfeMNvczaYrZsidhf5JYhOraJUeV+1UCoVVEVig0dOmltPqBuONkWvehT85Nde+afn7hCB5nQrIpmNUiKnzfo0l33Lbb3B8nMGbboul+1rg+44dt0/h+2+0srXqTgFbT0WIZGHRrDKVkZ0bJJ37UjBpWLlJEZP0L1AG0PNXUuv23IkzRw1GjIUMbEmilI7V1je8CPxLPYRNZjQytid0mjdjtxyJEFtGtDQIhsrBHqEgcj8ral4nt16Ph8v4PTa+KO1bPrEvYpeg1sm0HIzABArt5KP3z7mK34jexqMVxRtApyjiZkJZIPhOdkBZfprakzLeEd9edwPfbb2dNzeesrfmCBaXTeWftsayrmdWhshl0YwxHV8OnZGdGWA8DrEAsy4CGsE1OfQ4lB/LfBs+L4SgbvQwQYBmHcF6MSHHpRiRYwE6IptEliRbEDrfTgisIuF8g5PscKf0opiFYnOdhtk9OWy0dIezk5j1GRfkFdVuaKk1hxS0377GU6uIEQpsSaKURDG1DteTEbZllO4As2wF1ifYkoompuF/OtawqvyZKTxWbqT8FzmOp8i1MQCYVWxMn7famNriFmZv+gSZ9QH15yzCaDDBn2y3Y1Fx6OPbpKBG7FNXBChZXzceruck1FzAyZ1+savrrPHULDJ8SQynpbki9As3/ExBEMe2GEiO/hVAyUTL+il77SJQWKphHISyxFQepe8D3GVJbgxAOsB6KMDc6UAolAzL+D5x/DzvZCkuro1yEeVRdivvyGK0UlCYWBsW8N3rgB2JaS0QGwjSIoPdTvJV/r9sYbq8Hf8NXNZWg5z0c+c+nrYCezXYoBQXvUVPzH/z+OQ3brdYDyMy8Bot1TErjKooTPQErSCJhwU0JL+U1v/gVZZyEptewrvJuJCFEnUIlCeG0DGe3wqdRhJVc275Y1R74tW0xZtDomXlKUjKlk6VVb6FJf12o9o5IBILfKp4zlJI4hPQg72x6kR/LvwHCYcc6Gm9vep7je53F+MJJHSyhQWfEUEq6CVJ343fdjuZ9l6aRHIp5X6zZd0dVToTz/xDSi3Q/S2POVwANLPuh5vw3pj+J9LyHrLkdpBfqEmZR+zDScgAi5yGEkts4lxAgErNwxEMIE2rGZWiuaVFaKCAyUO2nN2wxOS8gEJgTpX24j8lxBlIrwVv5f4SXtppaV8I3KS3wA37X/diyb2nlUTRisY4h3/ommlaKrpehKAWoamGrxsx2TKay9hWiK2EKNvMIzGmySvTMOp8C5/GUut/HG1yDIuzkOQ4nyzqm4RwSQmVo3k38UXp5VJnybAeQZzsgLTKlwhrXp82sIzsi0dnuXYg3VI7dZCSEi8bL6x9jcdXPTSp6hz/TgO7nnU0vIBAcWHh4R4rYCWmlpaQb5Jk3fEq6AVL68VWci+Z9mx1DS/XgL3jLT0IPRa6tIoSCmnk9auF3KBlXIOwnIRwXoua/hylvBiJGoTXp/RTpuqFOIaFu7rqLeeAnZMUUpIznxJk6quMCVOcl9e/q/tb9KEUW5vyXm/nDKNaJqI7zm7dr3Iswj8CUcSUBd70vRrTlHp2A51WkHq86cfKoaiFm826tVkgA8jIuqvP/iPYz1ynIuqLV8zTFrObSK2sKg/PvZGDezWTb9m2h1BY5j2B4wQOYlByAOqtKWCEudh7LHkX/bbY01N4EE/xe/ZorfqOdlPXu1fxa9VPUgqAAH295nYCeSIXxnYhW1b1prULTOTAsJd2AkPcD9OAvUfZqIN0EXPdhy4seiinUXoiMv0fdvyNS6sia+2O00CC0BHwzwX50wuMmgxACU9YNKPYT0DxvIEPLQdhQrYeh2Ce38DsRQmDOuhXFvAch99PI0IrwDiUfk+NcTM6/IBQHIf/XxHeI9aIFFmKyHZTWY5JS4vfPodb9EoHgEoSw4bAfhdN5LiY1uYRiVvNg+ha+yMayKUjpo1HJCicsK865nSzHUWmVP1F6ZBxLkXMSZZ6v8QQ3YFKcFDgOwWbqmdJ4Uupsds9idfUbVPtXoAgTxY7xDMk5k1zr8PgDNMGm5uONmxVYwW7quJpKnZ2fK75DQUGP4Ujv0738Uf0Le+eObUfJOjmtdVaVhlJi0AkIeV4m/DQcIyuo/wukVt6qSJpmBBeCviVOIwXpfQfRRkpJwyzmXVGyb0uorRACk+NkVPtJICtBhkDJr6vpE0bKxJ7eZNxQ3uSQUqOi8io83rdpmvnVVbMSV80TFOS/gN02MakxM2wHMaznfKrcb1Lrn4OUIeyWvcjNOBuLqV9a5U8WRVgoch7Z6nF0GeLn7Tewxf0VDb8DCZtqP2Nj7SfsXfgvBmSdmPB4Q7OP5/eKF6L4lIQtO32cB2JVsyPuN4CqQHlMhQTCPiZVgVg+YQY7I4ZS0g0IL83EL4inaxtR06WUJFS9VoeYDo3pRw8uR/d9gtSrEWpPVPuJiAjhqmH/lshPuqp5JCFtE/EShqmm+NlQk6Gm9lE83nfq3jWdWwcClJVfSM/iuZhMfZIaV1Vzyc+6lHwuTZeoHYaUkgrfQkq8c9FlkEzLEGqDW9ni/rquRePvoN6HYWHpNHKsu5FjTez72iX7FFZWf4RPq4jgW6KgCBMj8y9Ow9F0XxymjLiWEolOeaCM7b4tFNuMsgKAEX2DoZR0C4SwI2X8dXAhHOmbVEnEdK2AWpC+OWMgdTfBqquQ/lk0FgjU0Wr+g+r8K2rmNQkngLM4zyXk+yhGCxWTdUKz2kKtRUo/rpqniO7HIoEQte6XyMm+OW3zdiU8oa3M33YFrsCyBj8UXYYIxckaLFBYVfU6o4tvT2gemymXI/o+xeytN1LhX15XrE4g0XCYChnfYxq51tZVbe7u7J17AD9XzI7ZRkqYXfols0tnMsi5C6f1vYDejo613nU0UghkKxSL1vTtLBhKSTdAtR1LyDOD6E/2AqH0QvP+j1DVLJB+hHlXVMfZCMvY1ApwWUaDUlCXdyQaOsJ+QvJjJ4mUkmDV35H+uXVbmn8OmvsJEFZMmdEiPpqjWvbF7LiQoOeFSHsRSg627MRucIkSCCxCyqo4rTS83k+7pFJSG1jB5prXqPTNRyDIte1H78yzcFoGJ9Q/qNfyw5YL8YW2A8SMjtkRicY2T6yoq5ZkmntxdN8XKfMtYZt3AVJq5Nt2o6djPxQRWwkygF0y96CfYzCbPGsjWktkg+4dvvasda/kwRW3MXXYbTu9YrKzY0TfdAPMzvNptA5EQiL0UnT348jQMqS2Ft33JcGKcwhVX4+UiRXla4oQJkTGlTFaqOFMrra29ScBkMGFSP9sYi1habVPIPXEoiWEENiyb8OWfSdCbWoNMWGyHYuz4GOUNPtjyLpEXelq15nYWP0iP285ji01b+EJrsIdXMnmmtf5acsxbHa9Hn8AYGPNB3hDW1soI4mnw4tV8DAyQggK7buzR94F7Jl/Eb2dBxgKSYIoQuGvg6+jr2NQ+D0qAtFEGQlnfGn8t16X1+Sl9ha1c6Gk4dXFMSwl3QDFNBBr7jP4K/8KBGi8OYedJQUmRIRKugC69x0000BMGX9Lel7hOA1kDbLmP4RvD/V5TkJgGobIfSptCcZioXnfJ3wqx7rx+NF9X6I6EkvKJYQIZ291nIMeWgnSh2LqH85Q2waYTIMJf3axbrMqZnN6/VjamjLPd6ysvAdobt2o//fyituwmweQZ48dgbGh5v2I20XdaLHyMwgUchKohmyQXjJMWVw17A5W1S5lUdU8fq/6BVewCl1CpO9LR2dV7TJKfNsosvVod3k7BYZPiaGUdBdMtgkoRXMIeV5H838DMoAw74kiNaTvA2I5bWq1z6I6L04pdbpwXgS2E8D3frhmjHAgrIchRTay5hGk/2uQHhB2UPuBfTLCfkLCaeITQisjtkICoCJjLjVFRggF1bxLSmIlg8nUF5v1YHz+OUT/rjQynOe1uSzpZEP1M8SODFPZ4Ho+rlLiD5UTSWETAoSsz4YR+YIs0RmUfUbiQhukDSEEQzOHMzRzOEur/0BPILlXiX/rzquUGBhKSXdCUYuwZF4BmY0JsQIlhxA/50YlMvgbwpJa2myh5oPz4obLjfS8Da7zqXc2DW/0QagSahYjax6EvKcRltEpzdcCtYD4lhINobQ+IVlbkpN9B9tLj0FKDy2/M4HddiQ2W9fJgBnSa6nyz4/TSqPCOwddBlBilB6wqvkE9EoiKSZqXWL7aBaTPhlH0ss5IRnRDdoAi2JNqJ1ZaV0Jii6NYSnpDitQBrGQDdlW4zVMsF28YYK/IV3/JHyDiPZ07EZWXoTUNqdlTtV+EvEtJVYUW+eutWE2D6W48H9YreOabRcig8yMf5Cf91SHZjpNFl3GKvTYFIkeJzdM38zoRSGFCBc4sChZKDRa+6xqPrvnXcmYoju71OfWXRmZOwYRx1JiVx0Mcu7EkU1GRlfDUtLdEaZhyEAZ8XJuCNPAtMwn3TMI67qx5pMgfUjPq4jM61o9pzCPQlgnxHR2VTP+jkiy8FxTpO4l4HkDv2cGemg9CDsW+7FYnVPSurxjNg+jqOBNQqH1BEMrEVixWPZBUdIYzt1OmJRsTEoWoTgOxmYlH1U4Y7bpl3kCa6pfwa+VRoy8EQLGFE0jz7Y3tcENKMJMpmUQijAucZ2FcQWH8NX2Twjqgajp5ycUHblzW0oMDEtJd0d1nk1sBUFFWMfvEGXSCvzfxpmvHgmet9IypRACc85/m1hCVGio+aKiZvwDNYkU+jui69XUlJ2I13Uremg1EATpIuB5k5rSowj6Zrb+IHbAZOqP3XYYNtv4LqmQACjCRK+M0yFmHhGFPllnxQ1LN6tZjOv1PDZTOBFe08pEApXd82+k2HkwZjWTXNsIsq3DDIWkk5FtzuXSwddiVizNLCZK3W1oTO44juyReObd7kh9npLWvLo6xq+2m6NYDws7nvq/ouV6vArCjinrX0mNKbUtSM8b4J8NBMG0J8J5Fph2S24ZSLqQWglCLUpq/kgIxYE593H04Cp03yegV4PaC9U+GdHK4nbe6n+hh5bR8vPTAB13xaVkFf+AEiFz7M5O/+yLKfV8gS+0OYKFQ8VhHkDfrPMj9t2RUu983KGtgIKos4jpCASClVUv0sM5EbvJ+A46M0Mzd+PWEQ/xQ9nXLK5aQED308velwMLDmVY5ojUciZ1J1ob1ptojHwnRkgpu8FhJI7L5SI7O5vq6mqysqJXwO1OSBlAq3kIzTOjmdIgLGMxZd2OYh6S+Fi+mciqK6m/ITdD6QF6cmnlRcbliIz/S6pPe6JrJbi2jyF2Gn8FW+ZV2DKvbCepuhYBrZzl5dMo9XxB/ecoUClyHsWwvH9hVnPijuEObmbWxuOI9j0IVArt+zO252PpE9wgJrrUWV6zmJ8rvqMqUEGmOZvRueMZkb0PajfK59Ie94z6OQ7Z6wZMamIOwZEIaX6+/vXeLn1/MywlOwFCWDBlXY+a8Q9k8Bek9KOYhiBMA5IaRwZXIquuIKpTaZIKCYAM/Iig8yolocBPJFJXKOj71lBKomBR89mjaDr+UAmuwO8IBFnWPbEkUYJgnevtmFlcJBol3h9wBzfhNCdXG8ggeXyah2fW3M8a97KGGjcChd+r59PL1p9LB99EptkoWGiQPIZPyU6EUBwo1vGotsOSVkgApGcG8W/QyQ7ayQ11MtFMoMlnDN3ZsJqKKHQcSoHjkKQUEoBy38KoVXsbkVT6f0tdQIOEeWX9Y6x1rwBoSCNf//1s823kubX/YSczwqcHQSujbzr6AFqPYSkxSBzf56RXKVHAsndKPaVehe79CKmtB5GBYjsSxbxbGmULo5r3SKQVqmVU2uc2aEo3uNp2E7b7NrPE9UvU/To66z0rWetewaCMtk882J0wCvIZlhKDZEg470TiCPvpSfcJ1T5HYPt+hFy3o7lfRqt9nGDZMQQqLki4vk2iqOYhqJb9iB1BomF1nJPWeQ2aU2Dfp65abywEedaR7SJPsgR1L8tdX7Ow4h2WVX9FQPN0tEgp81vVzw0RM9FQUFlc/WM7SWSQKqFQiH/+858MHDgQu93OoEGDuOOOO9D1NFvEk8CwlBgkjqkfhFakYaBw2nGRdTvClNz6v+Z+Fa3mriZbGpdNpP97ghVTMOe/iUijo50j59/Ulh6PlDU0D3cOH4ct87p2SUXfmdBlAHfgD3Tdh808CKupbdOCD8g8mVVVL0bdL1ApcozDYU5TaHuakFKysOJtfiybQUj6EChIdEzCypj8sxmTf2aXizjx6d6wzHFWZ/xa1yse2eEIWmcqSFKXuO+++3jyySd56aWXGDFiBAsWLODCCy8kOzubK664Iv4AbYChlBgkjv0cqLml9eOYxyAy/oqwHphUNykDhGoeiNFCQwYXovtno9omtk7GJqimgWQUfoKv5gGC3o+oV4QU01Bsmf/AYo+ebbS7IaXGZtdTbHE9R0ivrNsqyLVPZEDuzdjN6UnCtyMOc2/2KryNRaW31t3YG5VDgYLdVMxeBcmFtrcH88tfY17ZCw3v6/0uQtLPvLLn0aSfsYUXdpR4KVFgLUaTsXMRSSQFViM8O2naOc38vHnzmDx5MscccwwAAwYM4PXXX2fBggWpy9BKjOUbg4QRjpPCYb+pYD8VCr5FFM1HyX85aYUEQPfPAVkVp5WK7n0vJRFjjmrqhzP3YbJ6/Epm4ZdkFn1PZuHMnUwhkawqv44NVf9popAASCq93/HbthPxBte22fz9Mo/nwJ7PUeQYR72PiVnJZkjOBRzc+zVsps5V28gTquKnshkx28wvf53aYPKFIjuSUTljMceoU1TPmLyD2kEag9Zw4IEH8tVXX7FiRdgCvnjxYubOncvRRx/dYTIZlhKDhBHCgsx7C8qOBmojtFAAK2FLQrBuUy+E82JwnN16M3VCVX41pJZ8aHKiKEo2KDtnqGO1by6l7vej7NXQdDdrK25nePGLbSZDvn1v8u17o8kAuvRjEs5OW9dmuevrBCKGYJlrFqPzu04VY5vq4Pje5/Dupuejtjmix8lkm/PaUaruQbocXV2u5r51VqsVq7Vl/pPrr7+e6upqdt11V1RVRdM07rrrLs4888yUZWgthlJikBSKqQeyaBay6gYIfNtkjwDLgYjsO0FkgLYBhAXUQem7aSj5CTRS05Ih1qAl22peJezwG810r1Hlm4MvtBmbqW19O1RhQU3gab0jcQW3IepqGEdDoOAKbm9HqdLDgQWTMAsz/9v6OrWhxhugXXVyRPHJHFR4VAdK14URtC7QrK5v3759m22+9dZbue2221o0f/PNN3nllVd47bXXGDFiBL/++itXXnklvXr14vzzE8u0nG4MpcQgaYSSh8h7OmyRCPwCSDDviTD1a2ykDE/7vIp1PIgskLEibDQU+0lpn9sA3IE/iV/XSOINrmpzpaQrYFUz4lpKJBKrErsYYWdlv/yJjM4bz/Ka33EFK8kwZbFL5p5oUqMyUIbDlIFNtXe0mDslGzdubJbRNZKVBODaa6/lhhtu4Iwzwpa6PfbYg/Xr13PPPfcYSolB50RKHQLfI73vg7YdlEKEfTJYD0KoPcB+TLvJIoQVU+ZVhFy3R2mhIswjUKwT2k2mnQlFJJb+WunkFoz2YmjmwXF9SiQaw7ImtI9AbYAqTAzPCufo2ehZx0vrHue3qgVIJAKFkTmjObLHifR29IszkgGQNkfXrKyshNLMezweFKW5JVtVVSMk2KBzIvVaZOVfITifRrO9ivR/CqY9IO85hJKTlnkI/AzSB6YhCPOwqG0Vx3mo0o1WM51w/JtCODZRQ1hGY859PK3hwAaN5DkOY7NrHbGsJarIIMNIJAdAvrU/gzPGsaZ2XkSLiUChn3MfCm2J157qrCyvWcITq+5HSh1ZFyss0fmtagF/VC/isiHXMzQz/ckNuxtSCb9a0z8ZjjvuOO666y769evHiBEjWLRoEQ8++CBTpkxJXYhW0jk9xAw6BbL6aggurHunNf8b+hNZ2bqaNVIG0F33IEvGIqsuRVZfiSw/Fr38VGTwz4h9hBCYMi7DUvQDauYNKI7TUZ0XYc5/H0v+6wglt1UyGUSnOPOcugRm0Z7kBD0yz0NVbO0pVqdmUq8b6OsIK2miLgFf/d9e9t05qtc/O0y2dBHUgzy/5hF0qTWknK9HR0eTIZ5f+wgh3SjFEJdWpZhP3sry6KOPcsopp3DZZZex2267cc011/DXv/6VadOmtdEBxsewlBhERIZWgf+bGC00CP6MDP6GMO/ZvK9eC963kZ43QNsKSibYjkM4zwVs4PsYqW0G/2zQIoSQBn9Hlp8J+W8goqSOF2oBpoyLUz9Ag6SxmXqzS+ETLC/9W92Tf72iGrai5dkn0TenYxIudVYsip0T+t7LFu/vLK2eiTtUgcOUw65Zh9PHMbLLJU6LxOKqn/FokaLxwkgktSEXv1UvYO/c/dtRMoN4ZGZmMn36dKZPn97RojRgKCUGkfF9TuxICwAT0vd5M6VEauXIirNAW1e/BXQfeF5Cel4mvORSv+wSbWwd8CNddyHyX2ntkRikkTzHIYzqNZNtta9S7v4cHR8O8y70yDyHPPthnTY8tyMRQtDbsSe9HXvGb9wFWedejYqKFnNZT2Wde5WhlMRBivCrNf27OoZSkiJSSjyhDQT1GuymnljVRMJVuw5SryW24lCH3vwJSVZfGw4HbpGDWtthrHhRHHrYEhNajzD1T0Rkg3bCZu7HgNwbGZB7Y0eLYtAJEEKEb4Zx0s7Hq5djQLtndO2MGEpJCmyp/YxVVU9SG1xdt0VQ5JjALrlXkGnp+k5rAMLUN2Z+hTAaoCDdz4KUSLUIAnPTK4i2DgylxMCg0zIkYze+Lfk8ZhtNagzJ3LWdJDLoyhhKSZKsqX6RZRX/obmzn6TUM5ty74/s33MG2dZu4GVuOxZc9wCBGI0keF9DNjwBtUEYmXCkf0wDA4O0sXv2KLLNubiC1VGjjHIteQzP2qv9hetqpCl5WlfGsKclgSe4kWUV9QXhmtsqJRqa9PNb6c1IGceO2QUQSjYi8+p4rer+1vuJpFuIHDB3zlL0BgYGYVShcsngq7Eq1hZLNAoKNtXGXwZdhWL4G8WlPs18a15dHeMsSYINNe/UhURGQ6cmuILqwB/tJlNbIpwXIrJuA7FjrRczYYWkbZUv4bwIYSTiMjDo9PRzDOT63e5mfOFhWOtCwm2KnYMKJ3HDrnfTxzGgYwU06DIYyzdJUO3/s1nJ9Gi4/EvJse7RDhK1PcJxFthPCYfv6qVIkQOuG0EG23Zi+6ng/EvbzmFgYJA2CqxFnNL3fE7ucx6a1FCF2i1CntsVhdaZCrqBmcFQSpJAESYSsRAI0b0+ViEsYDss/EavQUpP206oDkVk3Wlc0AwMuiBCCEzd7BrYXqSrSnBXxjhzkqDQPo5Sb7zoEkG+bb92kadDEHbCp02S2RlNuwFmCP0Wv63i7PIKiZQ6Af9cAsHFCFQs1gOxWLpnngoDAwODdGEoJUnQO+N4llc+iia9RHLsFKgUOg7GYe6+FVKFMCFtR4LvM+LnGoGwPdGMyL4HhBNZdnic9ipYxrRe0A4kEFhEZcVlaNp6wgnoJKBjNu9Nbt6TmEx9OlhCAwODTokRfdMdVqDaD7Oaxeji/6IIS0P9ijDhMynDPJg9CzquZkB7IZx/IfFfjw4Eka5bw0nQLAcCsQrm6Qj76ekQs0MIBpdTXnYKmraxbotGvQIbDC6mrOwEdK2iw+QzMOiq6FJnqWsZ88p/Zkn1UjSZyENR16I+o2trXl0dw1KSJPn2MRzU+wPWuV5ji/sTNN2D3dSLflmn0yfjBExK98+rIcy7Qe6TyKrLQXqJH4WjQ3AxMrgcsm6DsuOByH4pIut2hCm5Mud6cDm69wOkXoZQClDsJ6LEqDTcltS4/oOUASKHSGvo2jbc7hfJzJra3qIZGHRZvi/7kbc2vktFoLJhW7Y5m1P7nMjBRQd2oGRpxsjo2vGWkscff5yBAwdis9nYZ599mDNnTsz2r776KiNHjsThcNCzZ08uvPBCysvL20naMA5zH4bnX8dh/b7jiAHzOajPhwzIOmunUEjqEdaDEIVzEZn/ApGVUB8ZXA41dwHeKIM6wJJ4bQwp/QQrryBYdhSa+1l07wdo7mcJlh1JsPJypPQnPFY60PVqfL7Pib2speN2G/V8DAwS5ZuS2Ty5+tlmCglAdbCaZ9e+yBfbZnWQZAZtQYcqJW+++SZXXnklN998M4sWLWL8+PEcddRRbNiwIWL7uXPnct5553HRRRexZMkS3n77bebPn8/FFxvVYjsCoWQgnOeAaXBiHTzP11UejmJZkX5kzb0Jzx+qugHd90ndO42m9XV036eEqm5IeKx0oGklJOJno+vb214YA4NugDfk5ZX1b8Rs8/qGt6kJRq9S3JWQtHL5pqMPIA10qFLy4IMPctFFF3HxxRez2267MX36dPr27csTTzwRsf2PP/7IgAEDuPzyyxk4cCAHHnggf/3rX1mwYEE7S27QDHOC1o3Qn8T2Q9HA/w1Si3/T1kNr0H0fEj2TrI7u+xA9tDYx2dKAouQk1E4kaFkyaESXQfS2zo1j0OmYV/EzAT1WqYuwr8n3ZfPaSaI2RqTh1cXpMKUkEAjwyy+/MGnSpGbbJ02axA8//BCxzwEHHMCmTZv49NNPkVKyfft23nnnHY455pj2EHmnRuoVSM/ryNrHkZ53kHotMrQavfJv4HkymZHi79fWxx1F935MbIdZALWuXfugqoVYLPsT+2el4nCc3F4idWmklGys+YxvNp3DB2v25YM1+zJr42msc32IlG1Q1sCg07HNux1VxP6dKyhs9W1rJ4kMdiQYDLJx40aWL19ORUXrnfg7zNG1rKwMTdMoLi5utr24uJht2yKfYAcccACvvvoqp59+Oj6fj1AoxPHHH8+jjz4adR6/34/f3+hb4HK50nMAOwlShpA1/wbPy9RXBQYNXDc3bZXmWa3x5dIrif9YIJB6+0a6ZGZeRXn5GVH2KghhwZlhLDfGQ0rJotK7WFfzLk2VPFdgFQtLb6PEM48xxXch4tywDLo2VtUSv5aYkFiV+NeMLoEiwq/W9G8HamtrefXVV3n99df5+eefm91j+/Tpw6RJk7jkkksYMyb59A4d7ui6Y5IsKWXUxFl//vknl19+Obfccgu//PILn3/+OWvXruXSSy+NOv4999xDdnZ2w6tv375plb+7I13TwPMi4WRpkkafCdnklUaUfDCPiNtMqEXELwKo17VrP6y28eTkPgpYCCtNCvUWHSGyyMt/HZNpQLvK1BXZWPtZnUICzb/n8Pm2yf0Fa1zvtuhn0L3YJ3cUepzfuSZ1RueNaieJ2pauEBL80EMPMWDAAJ555hkOOeQQ3nvvPX799VeWL1/OvHnzuPXWWwmFQhx++OEceeSRrFy5MqnxO8xSUlBQgKqqLawiJSUlLawn9dxzzz2MGzeOa6+9FoA999wTp9PJ+PHjufPOO+nZs2eLPjfeeCNTpzaGX7pcLkMxSRAZWgfe19M4okrjDSayMiOcFyeUpl+1T0areSBOK4lqPyEZAdOCw3ESNusEPJ63CAR/RWDCah2HzT4ZZSeK0GoNq6peJazQRbshCVZVvcKgrFO7fPZfg+gMcPZnt8xdWF6zMqJyoqAwwNmPoRlDOkC6nZMffviBb775hj32iFzfbd9992XKlCk8+eSTPPfcc3z33XcMHTo04fE7TCmxWCzss88+zJw5kxNPPLFh+8yZM5k8eXLEPh6PB5OpuciqGn4KjWbis1qtWK3dxLTXzkjv+4QViXQlKdIh82aouZ+w5aX+IlM3h/1UcFyY0EhC7Y3iOB/d82LUNorjfITaq5Uyp4ai5pGRGd2CZxAdXQapCvwZp5XEHdqIX6vEZsprF7kMOoZ/DL2U+5Y9yHrPRgQCiWz429Peg6uG/aP7KKZdIKPr22+/nVA7q9XKZZddlvT4HZo8berUqZx77rmMHj2asWPH8vTTT7Nhw4aG5Zgbb7yRzZs3M2PGDACOO+44/vKXv/DEE09wxBFHsHXrVq688kr23XdfevXqmJtPt0bbmqaB6pQO8xjwfwnmUSAsoG0BgmAaHq5GbNkvqYuLKetmQqh1iomk8claoDguwJTVviHBBulBJrUk2B2CIA1ikWnO5LYRN/NL5SK+K/2eykAlOeZsDiw8gH3z9sGsmDtaxLTR2iUYI6NrKzn99NMpLy/njjvuYOvWrey+++58+umn9O/fH4CtW7c2y1lywQUXUFNTw3//+1+uvvpqcnJyOOSQQ7jvvvs66hC6NwmGuMZGBbUfaGsh+Athq0tdpWWRg8h7HmHePaWRhVAxZ9+MzLgEzfc/0MpALUC1HYtQC9Mgu0FHoAoLWeYhuIKriaV02NVirGpu+wlm0GGYFBP75Y9hv/yuXRcrLl0ko+uUKVOavX/++efTNnaHp5m/7LLLopp4XnzxxRbb/vGPf/CPf/yjjaUykFKC2ofWL91oYYWk/t/h0ev+uJAVF0DhlwgldRO8UAsxORNb9jHoGgzOOZNFpbHqSAkG55yFEB3uq29gsNNRbzhoCzpcKTHofEgZQlZfCw3ZUtsKHWQteN6CDMP/wqCRAZmTKfHMY7N7Fg2WtQYERfb9GZJ9ZgdJZ2DQNnSV5Ztbb721zcY2HjMMWiBrHwXfp+00m45sc+XHoKshhMq+xfcysuB6nKbeDdvtajG751/JAT0fRhHdx5fAwAAwMrpiWEoMdkDqHvC8RLs6EOo17TeXQZdBCJXB2WcwKOt0/FoFEh2bmm8s2RgYdBK2b9/ONddcw1dffUVJSUmLKFhNS37531BKOgFSagRDy5HSh0kdgKp2YIhj8BeQnvjtlF6IzGuRtf8FbQ2pKzEKmNpufdKg6yOEwGbK72gxDFpBUA8yv2I+q92rUVDYJXMX9srZC5Ni3IKa0lWWb+q54IIL2LBhA//617/o2bNnWkKzjTOiA5FSUut+jpqax9D0+iRyKnb78eRk3YTJ1KcDhPIm1k7YEPZjws6qrtasL+oIR7S07B2Ppm3B73kHXduAENlY7MdgMo/qPnkRDNJCQPOwzPUNFf4NmBQLgzL2p6d9uHGeAEuql/D46sfxaJ5wHRsJs0pmkW3O5oqhVzDQObCjRew8dJHom3rmzp3LnDlz2GuvvdI2pqGUdBBSSiqrbsDtmbHDHg2v9yP8/jkUF36KydTO2WdNgxJopIKpLkOf/STwvg/B32iZfVMFHIC3bt+O+xWwjAbr4a2TuQ2QUuKtuQ9v7WM0posHn/spTJYDyMx7OuGqwAbdmyVVX/L1tkcJST8KJkAyv/xNim27cHyf28gw77xWnnXudTy08iH0ugKKmmw057uCLu5fdj+3j7idIlv7loMwSA99+/aNX5soSYzF2Q7CH/g+gkJSj4auV1JZfUu7ygQgTEPCyc1inhpag3VDCCsi9wWwn0wLHdeyH6LgfUTey6DuuESjgu0ERO4zCaWVb2+8tY/irf0v4WUpnXAG2hAAocBP1JSfb1SqNWClay5fbv0PIRkuSKYTQq8LfS/xreSdDdcS1H0dKWKH8tGWj5BSRkyIJ5EE9ABfbv+yAyTrnHSF2jdNmT59OjfccAPr1q1L25id726wk1Bb+xKxU7hr+HxfENK2YlJb1vRpS0TWrcjyM4AALa0bAmzHgOWAxi2KE5F9FzLzGqR/HgQXhJ1XlRwIrQTrBETB5xBcCKFVIKxgORChFrTjUSWO1N14a6NXngaNUPAXgv45WGwHt5tcBp0LKSVzS56jZchy3X50KgObWFb9DXvkHtXu8nU0Xs3Lr1W/xszQq6Mzt2wuZ/c721jqgi6RZr4pp59+Oh6Ph8GDB+NwODCbm0fEVVQkX6XdUEo6iEDwV+InJpMEg8vaXykxD4f8N5Cu2yG4qMkOJzguQGT8PfIFJPg7uG4B6aL+1JKel8JOsblPICz7gGWf9jmIVhDwzUzAt0bF733PUEp2Yrb7VlAV3BynlWBJ9Rc7pVLiDrkTKhng1/1oUsPUCS2mBrGZPn162sc0zoIOQpBYjgUhLG0sSZR5zcMR+W8iQ6shtAaEHSyjEcIWsb0MLEZWXkqjohVq3KlvR1acCwUfI9pZwUoFXS8n2tNvIxpSL20niQw6I55QZQKtJO5QecJjVga2URHYikWx09s+FEWoqQvYwThNThSUiNV9m2JX7UYUTh1SCb9a0z8ZBgwYwPr161tsv+yyy3jsscfi9j///POTmzABjDOhg7DZJ1Fb+yyxrCVCOLGYR7WfUJFkMA0G0+C47WTto4Rv4pFu5BpIN9I9A5F1fbpFTDuKWkz8EGcVRen8CpZB2+EwJVJ3R+BMoIrxVu9qvtz6HOs9fzRsyzDlMq7wFPbNO7ZLLm3YVTv75O7DL5W/RFVMFBTGF4xvZ8k6Me28fDN//vxmuUT++OMPDj/8cE499dSEx9A0jQ8++IClS5cihGD48OEcf/zxqGpqCrWhlHQQGc7z65SSaAgynOejKI52kylVpF4JgTnEsyzgfRe6gFJisR2KEBlIWRujlYbVcUq7yWTQ+Si2DSPb3JPqYKxq2pLh2ZNijrPZs5KX1t6IJkPNtteGKvli6zNUB0qZ1HNKlN6dm+N6HRf2K4ng7KqgYFNtTCqO/fnsTLR3npLCwuaFS++9914GDx7MwQcntiy9atUqjj76aDZv3swuu+yClJIVK1bQt29fPvnkEwYPjv9AuyNG9E0HYTYNJD/vCcLOrk01yvBXYrNOIDvrujaZW2rb0GsfIVRxAaGKC9BrH0dqZakPqFeSUPI0WZ328LG2QAg79sxrY7RQMFsPwmTZv91kMuh8CCE4sOii6PtRyTH3YrfsQ6K2kVLyv82PoskQMoo14cfyD9jqXd1qeTuCvo6+XLPLNWSaMgFQhRrOVQLkWfK4YdcbyLfuvCHTbYXL5Wr28vv9cfsEAgFeeeUVpkyZkrBl7vLLL2fw4MFs3LiRhQsXsmjRIjZs2MDAgQO5/PLLU5LdsJR0IA77cZiLhlHjfh6v91Ok9GM270KG8wIc9sltEiqrez9Ar76exlBX0AM/QO2jKDkPotiiO+RJqYWdWWV12HnVXJerRMkjvg8GIHK6jBna5pwCBPG47geChH8qOqBhsR1FRs5DXeZYDNqOYVkHEdCv4uttj6HJAErdA4aORqF1IMf3vR2zYo/af6tvFdv962LOoaCwsOILjukduZp6Z2dY5jAeGPkAv1b9yhr3GgSCXbN2ZUTWCBSjZEBz0pQ8rW/f5vmtbr31Vm677baYXT/44AOqqqq44IILEp7uu+++48cffyQvr3GJMj8/n3vvvZdx48YlPE5TDKWkgzGbdyEv5z7Iua/N55KBn9Grr6Wl8qADEr3qCkReL4RlZMu+nrfDKeX1RlO1NI1AZN6AsO6HtE4A/2yi+8io0IWWO4QQ2DMuxeo4g4D3IzRtI0JkYbUfg5pQgjmDnYXdc45iaOZBLKv+iorARlRhYVDm/vS27x5XcS31bYg7vo7Odt+6NEnbMZgUE6PzRjM6b3RHi9LpSUeukY0bN5KVldXw3mq1xu3z3HPPcdRRR9GrV6+E57FardTUtKxdVltbi8WSWpCGoZTsRGi1TxJeHoqkOEhAQXc/g2r5b/M9tU8iax9s2SW0FFl5PuQ+jcj4P6R/DpEtJiqITITj3HQcRruiKDnYnOd1tBgGnRyr6mRk3vFJ91MTrHRsUjomCs+ga5KVldVMKYnH+vXrmTVrFu+9915S8xx77LFccsklPPfcc+y7774A/PTTT1x66aUcf3zyvwcwfEp2GqTurnNGjZUbRUP6ZyKbONxJbTOy9qEo7cMWFll9E5iGI3KfBZFTt89Eg86r9kbkvYpQe7T2MAwMuhWDMvZqWPKJjmCXzH3bRR6DDkak4ZUCL7zwAkVFRRxzzDFJ9XvkkUcYPHgwY8eOxWazYbPZGDduHEOGDOHhhx9OSRbDUtJNkdKL7v8BdBfC1BuUASRWyVcD6QORER7H8zax/UUk6CXgn42wTYSiOeD7Ehn8HYSKsOwfzt5qrB0bGLTAYcpir9xDWVQ5M2KiMYHAotjZMze6s6xB96EjqgTrus4LL7zA+eefj8mUnEqQk5PDhx9+yMqVK1m2bBlSSoYPH86QIUOSF6QOQynpZkipo9U+juZ+GpqGtKp9UTAjCMYeQGSDaBKGHFpJIjk70FYDE8PJ3uzHIuzHpngEBgY7F0f0/AsVga2sc/+OQGmIwhEomBUrZw24Dbua0cFSGnRXZs2axYYNG5gyJfWw86FDhzJ06NC0yGMoJd2MkOsO9EiF/rRN6EgUVISIpmSoCMcZza0awkZ0P5R6dCD1Ne/6MGEjmsVgZ8SsWDlnwB0sdc3jl4rPKPdvwarYGZEznr1zjyDTHD/5mkE3oQNq30yaNCmpVA1Tp05l2rRpOJ1Opk6dGrPtgw9G8EWMg6GUdCP04LLICgkQtnaIsGIiFYTYMSeCCkohirO5tiysE5G+j+NPbp2QvLz+b9HdL0Dgp7B8phEozvMQtuON5R6DnQpFqIzIPpAR2Qd2tCgGHUhHLN8ky6JFiwgGgw3/TjeGUtKN0D1vEbvycF0aeNPguuWWJpj3Rc25H6HskMjINglqeoBeGmVcFawTEaZ+Scmq1TyAdNcnj6sbN/QHevU1CP+3KNkPILpw3Q8DAwOD7sg333wT8d/pwngc7Ubo2lriVx5WEI4zUfM/Rcm6EyXrLtSCLzDlvxyxWJ4QFkTe86Dk0Nw2WHfqmIYjsu9NTk7f13UKCTvIG7beSN8nSM8rSY1pYGBg0OXpoOibVJkyZUrEPCVutztlHxVDKelGCJFB/K9URwgHwjwMxXEGiuP0cNG9WOOahiAKPkdkXg+m4aD0BPNoRPZ/EPmvI5TE4+EBdM8LECcMUvc8j5Sxq4t2BwKhtZRX38/2iqspq74Lf+DPjhbJwMCgg6hfvmnNqz156aWX8Hq9LbZ7vV5mzIjmShAbY/mmG6HYJqH7PonTSkWxTkx6bKFkg3MKwtm6wmBSSgj8TGyLjgRtM+jbQE08u2D8uQOEfJ8T9HyA1CsQam8sjtNRre0fsixliJLKm3B5XiGsoIWvJpU1j+G0HUmPvP92iWKMBgadke2+Mn6tWkZQDzHA2ZsRWUO6hiN9Bzi6poLL5QoXWZSSmpoabDZbwz5N0/j0008pKipKaWxDKelGKLYjQO0D2lYi3/QVFPspCLUwwr72JEELiIy3FJXEjNo2POVnoodWE7Ym6RBcTMj3Map1PI7cZxDtqASUVt2Oy/Nq3bvmx+n2fcm2ir/Tq+CFdpPHwKA7UBvy8MiKV/ip4jcgnOdFIulpK+SKYeeyW5ZRIiId5OSE65gJIRg2bFiL/UIIbr/99pTGNpSSboQQFix5MwiUnwP6FhqTnoWdSYX1YEzZt3WwjCK8BBRaSkzlRORCmjLASqnjKT8PPbSubkv9vGFlQPN/j7fqehx5j6ZlvniEtO1Uu18kev4XHbfvC/yBP7Badm8XmQy6L55QLd+XzWJe+TdUBytxqE7G5B3EQYWTyLF0nwq9fi3Av35/hHXuLQ3b6hPSbfOV8a/fH+HekVMZkpGcU357IoVAtsKi05q+yfDNN98gpeSQQw7h3XffbVaQz2Kx0L9//6Rq6DTFUEq6GcI0AEvRTHTv/9C8H4OsQqj9UR2nIywHdIpQW8V5Pnr1dbFaIBxnIxKsCxIPzT8bPbQsRgudkO8j9NB1KKa+MdqlhxrPx8RPSGfC5XmXQkMpMWgFFYEyHllxO1XB8oYbtCtUxdcl/+OH8ln8fcg/6esY2MFSpofvSuezxr0p4j6JRJMaM9Z+yB17/KOdJUuCLrJ8c/DBBwOwdu1a+vXrl9alsaSUkuXLl/P6668zZ84c1q1bh8fjobCwkFGjRnHEEUdw8sknJ1SN0KBtEcKO6jgV1XFqR4sSEWGbjPB9jfR/QcubswLmPVEy/pq2+YK+Twmf6qE47b7EmnFR2uaNhqaXE7ZexVrGkmh6RZvLYtC9eWHtdKqDFS1S2Et0fJqPp1ffz60jHsWktN3zaVWgioWVi/FqXopsheyVsydmJT0PHE35fOvchuWaSOhIFlcvp9RXQaHNSEiXDr7++msyMjI49dTm95q3334bj8fD+eefn/SYCT02L1q0iMMPP5yRI0cye/ZsxowZw5VXXsm0adM455xzkFJy880306tXL+677z78fn/SghjsPAihouQ8jJJ5IyhNTHwiB+G8DDXvZYSwp20+qbuJ78eignSnbc5YmNQi4ilI4XbFbS+MQbdlvXs1Gzyr0aOc+xIdV6iKxVU/tcn8AT3Is2te4opF1/HCupd5a+N7PLLyCf6x6Bq+L/sx7fOV+MujKiTN23VeZb+rRd/ce++9FBQUtNheVFTE3XffndKYCanHJ5xwAtdeey1vvvlms7WjHZk3bx4PPfQQDzzwADfddFNKAhlERw9tIOT/Gil9KKahmKwTOk2CMalXgf9r0KvDETPWujo4URBCRTinIBwXgLYF0EDtlbYlm6Yopv7Et2uGUNT+aZ87Epn24ymtug1i1iHSyOqkli6DrsHymt9RUKIqJQAKCstr/mCfvHFpnVtKyWMrn2JR1eIGRaFeDnfIzZOrn0URCmPz01f92GFyUBPyxG3nNKXvgSftdJHlm3rWr1/PwIEtl//69+/Phg0bUhozIaVk5cqVWCzxa5uMHTuWsWPHEggEUhLGIDJSd+GtuoaQ74u6LeFaNEIpxpZzP2Zb8iG+aZNNhpA1D4BnBuGbbF1ki8iCzOsRcW6sQihg6pPAPH6ktgWBuU55Sdw3xuI4jUDtY7EbiSxM9iMSHrM1qGo+uZmXUVkTrbS3INNxMhZzegpcGeycaDJEIncpPY1RbvWsqFnJwqpfY7Z5bf2b7Ju3D2qaHqwOLhzNOxu/QI9hLelpK6S/I31pBnZ2ioqK+O233xgwYECz7YsXLyY/PzUn6oSu7NEUEp/Pl1R7g+SRMoC7/BxCvpk0pImvixqRegneigsJ+b9vX5kC89Err0AvOQhZMho8z9H41F/3VCZdSNfNSM+brZtLryHkuofA9n0Jlh5KoPQgAqUT0NwzEk6uppgGYInjo2LLvg0hbDHbpJP8rGvJzbyC8HOBApjr/gqyHGdRnPufdpPFoHvS1zEQPU6GZ4mkj2NA2uf+rnQuSpzbS1WwmiXVS9M255E9DsSmWlFiKGJn9Du6c+cr6WIZXc844wwuv/xyvvnmGzRNQ9M0vv76a6644grOOOOMlMZMOhRD13WmTZtG7969ycjIYM2aNQD861//4rnnnktJCIPohLyfoQd/JXLekbCS4que1iZzS6khg38iAwuQ2naklOiue5EVZ4P/y3ByMxnbXCpr7kPKyMpr3Pl1F8Hy09Dcz4NskspY20zIdRuh6usSrm5pzbwRa+YNIDKbbRdKMfacR7E4TklJxlQRQqEg+3oG9lxIYfZt5Gb8hYLsmxjQ4yeK8/4dc+mrrZEyRJX3J0rdn1PtW9jpMut6QiWU+f6kJri5o0Xp1AzPGkW2ORcR406lCpV98w5K+9wl/rKYy0b1lPnL0zZnvjWH23f/P5ymcL6h+uOuV1LOHzCZCUVj0jZfW9DVfEruvPNO9ttvPw499FDsdjt2u51JkyZxyCGHtK1PyY5CvPTSS9x///385S9/adi+xx578NBDD3HRRW0fvbAzEfC8TsOSSEQkeuhPtOBSVPNuaZlTSgne15G1T4G+tW6rANMu0BBam6DJV9aCbxbYj01aDq32YWRoVYS56taove+hWw9FtR8VdywhBNbMy7BkTCHk+w4pq1CUnqjWcR3ql2NSC8jJvLjD5t+RrTVvsa7qYQJaacM2m6kvg3Ovp8A5qQMlgzLfEhaVPck27/yGbXnWXdkr/xJ6Ow/oQMk6J4pQOK////H46nvQpY5scg2pj1I5o98lOEwZaZ870+SMGQlTT70CkS6GZQ7g2TF3MLt0Ab9U/klQDzLA2Zsjeoyj2NbSIdOgdVgsFt58802mTZvG4sWLsdvt7LHHHvTvn7p/XtJKyYwZM3j66ac59NBDufTSSxu277nnnixbFisXhEEq6NpGEsmAqmub06eU1P4b3M/uuLWJQpIMap0ja5IySC+a501iKz8qmmdGQkpJPULYMLeT70hXY2P1c6ypvK/Fdl9oE0tK/49d5X8ozji+AySDrZ4FfL35ymY3VoAK/3K+3jKVA4r/xeCsYzpEts7MkMzhXDXsdj7Z8hZLaxY3bO/vGMJRPU9h16w922Te/fP3ZUFl7LL2FsXCnjl7pH1um2plUo9xTOqRXufddqGLObrWM2zYsIiZXVMhaaVk8+bNDBkypMV2XdcJBmNFExikglBykNrG+O1Edlrmk8E/IigkrUEHJTN+sx3lCK2LuzQEGjL4W0pSGTQnECplbWU0P5bw0+7K8tsocExCVdrP9wZAlyG+33ZbnX/Ejk/e4fc/br+XPs4Dsarp+R10J/o6BnHpkBtwBatwBStxmDLJs7St1WCf3FH0tPVgu68k6jLO0T2PwK6277nU2WntEkx7L99omsaLL77IV199RUlJCbre/Lv++uuvkx4zaZ+SESNGMGfOnBbb3377bUaNGpW0AAaxMdtPJJ76K5RiVMveaZlPel4nXgXf5FDAengK/RKVoXOERHd1trnfj2tq12QtZZ4vYrZpCza7f8CrlRErC65OiNWueMUod26yzDn0cQxsc4UEwKSYuGHXqfS0h3Pt1Du91v89tGgCJ/Y+rs3l6HJ0MUfXK664giuuuAJN09h9990ZOXJks1cqJG0pufXWWzn33HPZvHkzuq7z3nvvsXz5cmbMmMH//ve/lIQwiI7FcSqB2ieQegXRljKsmVekzy8iuCTqPMkjwH46Qk3+IihMA0HJBz2WI5yKsBi+BOnAE1xDXOUXU1279qXSvxKBioxxXgoElf6V7SiVQTzyrHncvcft/Fr1G/MrfsGr+SiyFnBw4Xh6G2G53YI33niDt956i6OPPjptYyatlBx33HG8+eab3H333QghuOWWW9h77735+OOPOfzwVJ6IDWIhlGwc+W/gKT8XqW+hMT152PnVmjkVs+PsNE6YjjIB4QKA2I5GZKWWRE8IM6rjArTaB4n+hKxhcl6YqpAGTVCFrc4xMToSHTWNmXYTRQgT8WsFibp2Bp0JRSjsnbsXe+fu1dGidAm62vKNxWKJ6M7RGlL6FR9xxBEccYThLNheqOahZBTPJuT7nKBvFtRldLU4zki6gJyUGvhnI30fha0QSg+E/SSw7BcuRW2dgAwuJhHn2uaIcGVf0+5g6oNwnIwwt86JTc24BD24GOmfRWPFY6hXetTM61Cs+7VqDoMw+Y7D2FLzWpxWOvmOQ9tFnqb0cuzHr+VPxGwj0ejlSF92UAODDqMTp1HZkauvvpqHH36Y//73v2nL/2I8WnQRhLBgth+P2Z569IPUK5AVF0PoDxqsGahI3wdgGQc5j4H9VKh9AvAT+elUgNIX9C001G8R9vAyTebUtCYgE8KMOfdxdO8H4WRpoaWAirCOw+ScgmLtgt71nZRc2wE4zMPwBldHWSZRybUdgNPS/llm8227UmDbnXLf0oiyCRRsah59Mya0u2wGBjszc+fO5ZtvvuGzzz5jxIgRmM3Ny4S89957SY+ZkFKSm5ubsBZUUdF5ix3tzEgpkZWXQag+g6LW/G9gHrL6RkTGRYQVlijmcvNoRN6zIL0QXA5CBdMIhOJsE7mFMKE6TkF1nIKUsnNnY+zCCKGwR/HTLN52Hr7QBhotU+FlwgzLruxW+ECHyXdQj7v5ctOl1Ia20vTcFCiYFSeH9H4QtQ3qJhkYtCtdLCQ4JyeHE088Ma1jJqSUTJ8+Pa2TGrQvMrQW6f8GggtjtNLB/xkyMBvwRm9mOyFcwVfYwTo23aLGxFBI2habqReje31MifsTtte+T0Avx6b2pEfmKRQ4DkfpwCyzTnMRx/SbwSrXh6ys/hBPqBSrmsWgrGMYln0SDpORGMug69PVfEpeeOGFtI+ZkFJy/vnnp31ig7ZHBhai1dwDwUUNKZdjpZwOd/IQ06nQ8wTScXJSBfEMug6qYqdn5in0zGzftPuJYFEzGJ57NsNz0+jYbWBg0KlolU+J1+ttkTAtKyurVQIZpAcZ+Amt4nySd1iNE+WgbQpndjUPj9xbSgjMRnpeg+CfICxgPRThOAthGpCkLAYGBgY7EV1s+WbgwIExLdj1tfGSIWmlxO12c/311/PWW29RXt4yh4Smpb8MtkFySKmjVV9PWCEJKyUSGd9Kkih6TcTNUmrI6uvB9xGNjrSA52Wk5xXIeQhhM6K2DAwMDCJRXwe+Nf3bkyuvvLLZ+2AwyKJFi/j888+59tprUxozaaXkuuuu45tvvuHxxx/nvPPO47HHHmPz5s089dRT3HvvvSkJYZBeZOCnsEUjaerV9DjWFbUx8ZGUAQitAnSk79s6hQSaJ2DTAIGsugoK/ocwDUpBNgMDAwODzsQVV1wRcftjjz3GggULUhozaaXk448/ZsaMGUyYMIEpU6Ywfvx4hgwZQv/+/Xn11Vc5+2xjvbfDCa2keV6PBLEdA75YWXkVsIxBmPoiZQBZ+zh4XgVZncDg4WcA6XkVkfWv5OQyMDBIie2+rfxc8T01oWoyTdnsmzeOYlvPjhbLIBpdbPkmGkcddRQ33nhjSo6wSSslFRUVDBw4EAj7j9SHAB944IH87W9/S1oAgzZAWIikkMhmoZTh7J0CQGQhMq8G+0nhQnihP2lpLVEAEyLz2rBCUnkJBH6M0C4WGvhmgaGUGBi0KSE9xGsbnuPHijkoKAghkFLy2bYP2C9vPGf3uwiT0vnSVJX5K/m+bCHVwRpyLdmML9iHHMtO5KfYTZSSd955h7y8vJT6Jn1WDho0iHXr1tG/f3+GDx/OW2+9xb777svHH39MTk5OSkIYpBdhPYhIlpIdI3Aazl/TbmA/CSGskPcisvpm8H9Z179uHLUvIvtehHnPsBNr4IfUhJP+1PoZGBgkzOsbnuenirkA4Sq9TS4FP1fMRUFw7oBLOki6lmhS47k17/D5tnCxV0Uo6FLnxbXvMbn3oZzT/3iUnSDir6uFBI8aNaqZo6uUkm3btlFaWsrjjz+e0phJKyUXXnghixcv5uCDD+bGG2/kmGOO4dFHHyUUCvHggw+mJIRBehFqL4T1SKT/C+otGTFDgoPzkbUPIzKvQyhZiNxHkdpm8M8FGQDzLmAe03DySfcrpLQ8hBIey8DAoM0o9W9nXsXsqPslknkVszmy52QKrcXtKFl0nl79JjO3f99wRdFk2CdNInl/80wAzhtwQscI183ZvHkz119/PZ999hler5dhw4bx3HPPsc8++8Tte8IJJzR7rygKhYWFTJgwgV133TUleZJWSq666qqGf0+cOJFly5axYMECBg8enHKpYoP0o2TfjVa5BYKLESgQM/pGB8/ryIx/hBOjAULtDY7TW7SUUgNtVYpS6aAORHc/H7a8WCcgjCycOwVSSiQailE0r82ZX/EDCkrYQhIFBYX5FT9wdM/0ZuNMha3eUr7c/n3MNh9unsVxvSaSa8luJ6k6iHZevqmsrGTcuHFMnDiRzz77jKKiIlavXh131ePrr7/moIMO4tZbb01d1ii0+grRr18/+vXrlw5ZDNKIUDJR815H+j5FVv8TQSB2B+mG4B9gGRNnZIVm4b4JUv8EJL2vUJ+6HJGLknUriv3YpMYy6HwEtGrKfQvRZZBsyy5kWPoDUOpdyIqqV9jqmYtEw2nqzZDs0xicdQqqkr46SQaN1IRcYaumBBnBmClEODtyTcjV/sJF4LvSn+MqURKYU/oLx/c+pP0E6wDae/nmvvvuo2/fvs0cUgcMGBC33+GHH87WrVspKioCYP/99+fdd9+ld+/eyQkQgaQX6S6//HIeeeSRFtv/+9//tohZNuhYhLCg2E9AKLmJdZChBMYUYBlLWDFJcFjCpedlw0Wn7q+sRK++Et37ScJjGXQuQrqXX0un8fn6w/h5+1UsKLmOrzZNZu6Wi/mz4im+3fKXBoUEwB3awuLy6Xyz5S+EdE8HS989yTbnoOs6umzMe9HsJUHXdbLNOR0pZgMVgWriVZBQhEJFoKpd5NmZ+Oijjxg9ejSnnnoqRUVFjBo1imeeeSZuP7mDtrtkyRL8/vT4CyatlLz77ruMG9eyOusBBxzAO++8kxahDNKMeU/iKxFqwv4ewnkhcS0lGddDzotIyyQkgWaRPzui10xDJqAQGXQudBlk3ra/s77mfSTNMzuX+xayovIJwspo03MlfGus8i9jcfn0dpR252FM7rgmn7ho8ZII9Lp2nYEsc0ZEi05TpNTJNme2j0AdScuvK/kX4HK5mr2iKQxr1qzhiSeeYOjQoXzxxRdceumlXH755cyYMaMNDzI2SSsl5eXlZGe3XNfLysqirKwsLUIZpBfhOIfYSoQKtqMQSmIhXMI6HpExtbFv03EA7GchnFMg9Dsy8Hn8AfUyZGBuQnMbdB421n5ChW8hkcPCw9vUKCZ5ic66mo8JaJGzAxukjt7wW49lfhDYVHt7iBOXgwpHx1y6gbAqe2BhfMfLLk+alJK+ffuSnZ3d8LrnnnsiTqfrOnvvvTd33303o0aN4q9//St/+ctfeOKJJ2KLKUSzqJsd37eGpJWSIUOG8PnnLW80n332GYMGJZ+p8/HHH2fgwIHYbDb22Wcf5syZE7O93+/n5ptvpn///litVgYPHszzzz+f9Lw7FZb9wX5O3ZsdTxwVlGJE5g1JDSkyLkXkvQrWw0BkgcgAy1hEzlOIrFtBVqPXTk98QG1zUvMbdDzrqt8i1iVEiPq9kR+DdRmg0v9nW4i2UzOvfC5KApf2BZXz2kGa+PRz9OKA/FFRHfEFgsOKD6DQmlrei52RjRs3Ul1d3fC68cYbI7br2bMnw4c3r2O22267sWHDhpjjSyk59NBD2Xvvvdl7773xeDwcd9xxDe/rX6mQtKPr1KlT+b//+z9KS0s55JCw09FXX33FAw88wPTp05Ma68033+TKK6/k8ccfZ9y4cTz11FMcddRR/Pnnn1GdZ0877TS2b9/Oc889x5AhQygpKSEUMkz/sRBChBOWmYch3c+AtrFujxXsJyAyrkCoyZd+F5YxiCiOsbrnYyCJ70XsBKbZbkZtcD3xkucJAUJGDx6XSReMbH8Cuo/NnqVoMkihtT/Zls4RRhuNykDLmmQ7ogiFykBFO0iTGJcPPQ8JzCtfhNpEldXRmVC0H38ZdFqHytdepMvRNSsrK6HiuOPGjWP58uXNtq1YsYL+/fvH7Ldj1M3kyZOTEzQGSSslU6ZMwe/3c9dddzFt2jQg7K37xBNPcN555yU11oMPPshFF13ExRdfDMD06dP54osveOKJJyKamz7//HO+++471qxZ05AtLhFPYYM6xcRxBthPB21DOImZ2huhONtkPqlvJbyck4hiYkFYJ7aJHAZth6rYCWnulPsLVHIsnTdvjSaDfFcyg4UVnxCUvobtg5yjmdTzb+RaOme6dqeaEbeNLnUcatv89lPBqlq4bteLWe/ezHel8xsyuk4s3I/ejkYlUEpJVTC85Jdtzuh+CdXaOST4qquu4oADDuDuu+/mtNNO4+eff+bpp5/m6aefjtmvLUKB60kpJPhvf/sbf/vb3ygtLcVut5OREf9HsCOBQIBffvmFG25ovmwwadIkfvghcrbQek/h+++/n5dffhmn08nxxx/PtGnTsNs7x/poZ0cIAabYWnB65slM+ClYOC9AKIalpKvRy3k461xv7eDI2ki982IkK4lApU/GYdhMndMkr0uNdzfcyRr3ghZO2mvdC3lx7ZVcMHB6p1RMRuftz6ySz2K2kUj2yd2vnSRKnP7O3pznbBlWqkmN/22Zy/ubvmW7P2zhKbbmMbn3wRzfezyqSDwa0KCRMWPG8P7773PjjTdyxx13MHDgQKZPn96hNeySVkq8Xi9SShwOB4WFhaxfv55nn32W4cOHM2nSpITHKSsrQ9M0ioubm0KLi4vZtm1bxD5r1qxh7ty52Gw23n//fcrKyrjsssuoqKiI6lfi9/ubeR67XJ0jNr+7I2xHQe0D8RtaDkHJuLrtBWpHNL0apIai5KbN+aszMijrDNa53iG8hNNS9RACQlJAXfK+hu2oOEw92Cv/mvYSNWmWu75ntXt+xH0SHb/m5pvtz3NS35vbWbL4DHAOYrfM3Vle82dEB1KBYL/8A8m3JrZkK6VkcfUffLX9OzZ6N2NTrIzJ25tDig4i15KTZulbokmdu/58gR/Lf292lm33V/DMmvf5tWoFt4y4qHsoJh1Q++bYY4/l2GM7T66opG1fkydPbggXqqqqYt999+WBBx5g8uTJcT12I7HjRVtKGfVCrus6QgheffVV9t13X44++mgefPBBXnzxRbxeb8Q+99xzTzMv5L59+yYto0EjUtuC9LyGdD+H9H0TzvAaAWEagLAdQ/RTTIB5JKa8pxHd4GIipaTG/Rabth3K+i27sn7rCDZsG01VzePIblrvJ8PSn/16PIgizDT9nkVdFNaQ7AsYU3QvOZZhDftMwsGQ7DM4tM+MTmslAVhY+UldJuTISHRW1MzDHapsR6kS55LBlzM0M5zmW0FBIBqcX/fOHcPZ/S5IaJyQHuKRVU/x7+WP8GvV75T6y9jo3cwHm//H1MU3s6R6WVsdQgOfb/2BeTsoJPVIYH7FEv63JXZG2K5CvU9Ja15dnaQtJQsXLuShhx4CwpUAe/TowaJFi3j33Xe55ZZbEq4UXFBQgKqqLawiJSUlLawn9fTs2ZPevXs3C0nebbfdkFKyadMmhg4d2qLPjTfeyNSpUxveu1wuQzGpQ2qloJeAyEaY+sRuq9ciXf8EX71ZWAA6KEWQfSfCOqFFHyX7XjTdDYFvacwCW/fXvA9qbux1y66ClJKyqhuocc+g6c1Z07ZQUX0nHu9X9Cx8LVzwsJtR7BjPYX3/x/qa99juno1OkBzLcAZkn0audQQA/TKPwBcqR5MBbKZ8VGHpYKnjU+pfH3f5UaJTEdiC05RgcsJ2xK7auXLoDax2r+Dn8h+oCdWQY8llbP54+jkGJDzOe5s/Zn7FQoBmVhcdSVAP8p8Vj/LgyLvazGIipeSDzd/FrLQlgQ83f8fxvcZ3fctkN6kS3BqSVko8Hg+ZmeH1/y+//JKTTjoJRVHYf//9Wb9+fcLjWCwW9tlnH2bOnMmJJzbWX5g5c2ZUT95x48bx9ttvU1tb2+DHsmLFChRFoU+fyDdVq9WK1dr9bgatQQaXIGsehMBc6n/q0rQHIvMfEZULKUPIyksguJDGS0PdX70UWXkp5D6HsDZPxiSEHTX3GQguQve+B/p2UPIRtskIy/5d/wJSh8f3aZ1CAi2jUSS+wI9U1fyX3KzutUxVj91UxK65l7Jr7qVR29hM+e0oUesxJag4JdquIxBCMCRjF4ZkpOZM7NP8fL7tq6iJD2WdYvJNyRxO6nNca0SNLoMeYJO3JG67rb4yakNeMs2ONpHDIDIzZszg9NNPb3GPDQQCvPHGG0kHv0CKeUo++OADNm7cyBdffNHgR1JSUpJQCFJTpk6dyrPPPsvzzz/P0qVLueqqq9iwYQOXXhq+uN14443NDuqss84iPz+fCy+8kD///JPZs2dz7bXXMmXKFMPRNUFkYAGy/HQI/ECzZ4/QEmTlX5Ge91p28n8FwQVEDv8MZ+iUNfeg6zpS24wMrkDqYd8dIQTCsjdq9p2ouc+gZt+LYh3bbRQSgOqaZ4mdMVenuvYFpAzGaGPQmdgl64CYyzcATlMuxbbkczN1FVbUrMKvx156lEjmVy5qMxmSuUp0h0tKV1u+ufDCC6murm6xvaamhgsvvDClMZNWSm655RauueYaBgwYwH777cfYsWOBsNVk1KhRSY11+umnM336dO644w722msvZs+ezaefftoQI71169ZmSVwyMjKYOXMmVVVVjB49mrPPPpvjjjsuYi0eg5ZIqSOrriEcprujL0jYWVG6/oXUm+cvkJ7YSbJAQmgFlB+BLJ2ILD8WWbI/etXVyFDsJDzdAV/gF+Kl3df1ckKhjTHbGHQe9s49Nq5Ssn/+ySjdwB8qGgE9MSU6EEdxaQ021cpAZ68YFc7DiktfRzHOTpKhtlWkKaNrexHNB3TTpk0RM78nQtLLN6eccgoHHnggW7duZeTIkQ3bDz300GbLMIly2WWXcdlll0Xc9+KLL7bYtuuuuzJz5syk5zEgvFyjb4nTKATe98B5ceMmbSPxkmSF2zVdvguB71Okfzbkv4EwDU5BYAODjiHf2oeT+t7E+5vuRpd6g3+JQEWisVfOkYzJO6FjhWxjett7xG2joNDXHtsfrbWc2HsCD654Lep+WdemO1lfOzujRo1qSC1/6KGHYjI1qhKaprF27VqOPPLIlMZOKU9Jjx496NGj+Qm77777piRAV0SXAaq9P+Dy/0itfxEhrRqzmk2+81gKnCeiKsnnbWkXgktodDiNhkAG/2yucCs5oMVyNYuGBrIWWX0TIv/NJPt2HWyWffEFfiTW56oqhZhMkbMUG3ROhmbuzyWDn+HXyk9ZWfMTIRmgh20Ie+cdSz/HHt3+JtjT3oNdM4exomZV1No0OjqHFR/cpnIcVrwvv1WvYtb2nxGIBh+X+n9PLBrNET32b1MZ2pUucFqdcMIJAPz6668cccQRzXKVWSwWBgwYwMknn5zS2CkpJTsrUkq21cxgY/XDhPSqpnsQIUGNfz6bqx5l1+JXcVhaRgK1mVxaObrnFaT3bdArQMlD2E9BcZyLUBsdDMNPe/EsHoIdTwthOw4ZXJyidBoEFyGDKxDmYfGbd0GyMy/GVx4rJFEhK2MKQhg/t65GjqWYCcUXMqE4tfXxrs75A87k9iX3EtCDERWTcfn7MSJrtzaVQQjB1GFnsVfOMD7Y/C2rajcBMNDZixN6T+DQ4tHdJrNrutLMtzX1GV0HDBjAGWeckdZgEuMqmQSbqv/LxuqHIu4L12mQBPUKlpWcw8he36Iqbb/GKUNr0CrOBL2SBoVD34Z0P47mfR017zUQ2ciau8D3OfGtHRrCekDzTfYTwf1kWOGJ4zsRldAS6KZKicN2BFnOi3G5nyXse1N/8Q5fIezW8eRkRl6iNDDoCHSpE5IhzMIc0+LTz9GH20bcyIx1r/NnTWONFIdq56geh3NC72PaxWIkhODQ4jEcWjyGoB4uXWFWjNtXR3PIIYdQWlraEP36888/89prrzF8+HAuueSSlMY0vtUE8Ye2srH64Sh7w0sb4TgUjaBWQoXnfxRmnNqmMkmpo1VeAnoVLS0gOuhVaBXnIfQqBIk4rSmg5ILtqGZbhZIBeTOQFVNA30rjjTfeUlBTuq9DoBCC/Jw7sFn3oarmSQJ1ViWT2o/sjIvIyrgAIcwdLKVBRyGlZKNnFVt861CFiSEZu5NrKewQWVbWrOLTrZ/za9VidHSyTFkcWjyRw4sPw2mKHE7b19Gbm4dfw3ZfCVt92zELM0MzB2NROuac7tbKSBfLU3LWWWdxySWXcO6557Jt2zYOO+wwdt99d1555RW2bdvGLbfckvSY3fjbTS8lte/GadGomAgEFZ7P214pCXwP2roYLbRwbpCEznQFhAOR+zSgIP3fh60vahGY9wk7qhbOBN+XSP9XIH1gGgQyBJ6XiL0spICle/scCSHIcJxAhuMEdOkFqSOEo9v7HRjEZpNnDW9tfIxtvsYoNIFgRNYYTun7Nxym9vM/+77sB55Z8zwC0bAU4wq5+GDzR8wr/5Gbd7uRLHP0GlTFtiKKbUXtJa5BF+CPP/5o8Cd966232GOPPfj+++/58ssvufTSS1NSStK6EDd79uyIMcvdAV9oLYmroTKcybSNkf7vSUSvjJb8qBELOC9CFHwCwSXI0oOQlRciq6ciK84Jh/l6/4cQFoT9WJSch1Byn0DJvBbh/AtgJvpno4J1EkKN78nfXVCEHUVxGgrJTs4230aeXH0L232bmm2XSJa4FvDU6tvaNJy2KaX+Up5d8wIS2cI3RCIp8ZXy4roZUXobGEQmGAw2+JPMmjWL448/HghHyW7dujWlMdOqlEyYMIFBgwbxwAMJFGLrYijCETNWvjkqdvOQNpUnTCg9wyiZKJnXgu8TpOsW0Mub79e3hRUUz9stugq1AJH7KGHlqOkSTZ11xjQEkT0tPXIaGHQhPtv6KkE9GDFdvURnq289v1R81y6yfFMSex4dnYWVi6gIVMRsZ9C2dLXkaSNGjODJJ59kzpw5zJw5syEMeMuWLeTnp5bFOa1Kydq1a3n33XcpKytL57CdgnzHJGRcJaBebdEoyjijzWUS5hEkopjEV6bMSK0MWRNbmZQ1dyIjWICEdQKi4EOwnwoiCzCBOgCReRMi702EkloSHQODrkpNsIplroVx6+f8WP5Fu8jzp2tp1LDeeiSSlTWr20Uegyh0seRp9913H0899RQTJkzgzDPPbMhd9tFHH6WcJiStPiX9+/enf//+TJgwIZ3DdgqybeNwmHfFE1xJZOfO+th5KMo4C6d19zaXSdiOAtcdIGsb5k8J60HgfT/+GNIbLsjnOKWlLKYhiOw7IPuO1OUwMOgmVAZLE1g2hYpAaTtIQxKXh1ZcRwxaTxdzdJ0wYQJlZWW4XC5yc3Mbtl9yySU4HKnVIUraUrJx40Y2bWpcI/3555+58sorefrp7lHxNRpCKOxW9Dw2U//6LXV/G3/EZpz0yb6KAXnts1whhA0l+4E6WXb8KsPvRd1/McdxnIPUEvGZMdW1MzAwiIVNSeyCbFVsbSxJmKGZQ1ESuNwPyhjYDtIYdCdUVSUUCjF37ly+//57SktLGTBgAEVFqTlFJ62UnHXWWXzzzTcAbNu2jcMPP5yff/6Zm266iTvu6N5PyVZTD/bq9QlD8x8kx3YgDvNwsqz70jvzYnYrfJZ9+i6gd87liHZM5KPYDgnnIjHvYCozj0HYToy/dJNxA8K8KwgH8ZUSiRBGFU4Dg3gUWntRaO0Vs42Cwl65B7aLPIcWTYhpuVFQ2DN7DwqtHROqbFBHa/1J2tlS4na7mTJlCj179uSggw5i/Pjx9OrVi4suugiPx5PSmEnfPXcMAdp999354YcfeO211yLWquluKMJKYcYJDC9+ib16/Y/de7xJ/7ybyHUcitJOTz07IiyjMeW/glo4FzX/Q9TCuZjyX0XJvges9fUHdjxbFci8DSVjSniv9TDi+6doYD08zdIbGHQ/hBAcVhw9JYBAoAozBxSkVh8kWXrYe3BO/7MAWlhMFBSyLdlcODD5MvMGaaaL+ZRMnTqV7777jo8//piqqiqqqqr48MMP+e6777j66qtTGjNpn5K2CAEySA9C7QFNQm+FMEHOwxCYjfS8Hq7kK+zhEF3H6c3DdC37gWkEhJYR2WdGBcvYbpsq3sAg3YzKPZDqYDmfbn0FBaWJo6nAoti4cOAN5FnaL+/HYcWHUGQt5JOtn7GsLjurTbFxUOF4ju11FNnmtnVIL/NX8U3JfEp9lWSanYwvHMUAZ2xrkkHn5t133+Wdd95p5kd69NFHY7fbOe2003jiiSeSHjNppaQ+BOiYY45h5syZTJsW9p9oTQiQQdshhADrwQhr7KJZQgjIfRJZcQFoq2nM2lr31zQckRM5xb6BgUFkJhRNZvfsffmpfBabvWtRhYldMvdin7yDsavOdpdnz5w92DNnDzwhD37dT6YpE1MbZ0jVpc6Mdf/jnY1fhR/mhYKUkjc2fMH++Xtwza7nYVfTVzulK9NVat/U4/F4KC4ubrG9qKgo5eWbpM/G++67jxNPPJF///vfnH/++WkJATLoHAi1GAo+BN/nSO/7oJeB0hPhOBmshxip0g0MUqDA2pNjep3b0WI0w2Fy4KB9/MNeX/85b2+cBdSFBchGS+zP5X9wz5/Pc/vulxrJBqHLRd+MHTuWW2+9lRkzZmCzhd0XvF4vt99+O2PHjk1pzKSUEiklAwcOZP369WialrYQIIPOgxAWsB+PsB/f0aIYGBh0cWpDngaFJBI6kl8ql7K8Zh27ZhmRP12Nhx9+mCOPPJI+ffowcuRIhBD8+uuv2Gw2vvgitRw8SSslQ4cOZcmSJQwdOrTZvgEDBqQkgIGBgYFB92Re2W8EZWwHelUofLV9vqGUAAgZfrWmfzuy++67s3LlSl555RWWLVuGlJIzzjiDs88+G7vdntKYSSkliqIwdOhQysvLWyglBgYGBgYGTakM1KAKBU1GzyarS52qYE07StV56Wo+JQB2u52//OUvaRsv6ZDg+++/n2uvvZY//vgjbUIYGKSCFvwTf81D+KrvIuB+FakbFzYDg85EriUzpkIC4ZDk3BjViQ06H7/88gsTJ07E5XK12FddXc3EiRNZvHhxSmMnrZScc845/Pzzz4wcORK73U5eXl6zl4FBWyP1KtxlZ+MuPRJ/zSME3M/jq76Jmm17E3C/0tHiGRgY1HFAwUjMIrZBXkPnkGIjSALoMnlKHnjgAQ455BCysrJa7MvOzubwww/n3//+d0pjJx19M3369JQmMjBIB1KGcJefix6st9RpNOZV8eOrvgmEDUuE+jwGBgbti9Nk5/R+k3hl/acR9ysI9snbjV0y+0fcv9PRRaJvfvrpJ2644Yao+4877jieffbZlMZOWik5//zzU5rIwCAdhHwz0YOxzYJ+172Y7ScihNpOUhkYGETjjH5HEJIab22YiUSiCgVdSnR0xhaMZOouZxvhwHV0FZ+SzZs3k5kZfcktIyMj5WSqKWXNWb16NS+88AKrV6/m4YcfpqioiM8//5y+ffsyYsSIlAQxMEiEoOdtQCVy1tkwUi9BC8zDZG2fuiIGBgbREUJw7oBjOKbXeL4tWUCZv5IMk4PxhXvT19Ey8ZZB56ewsJDly5czcGDkiKlly5ZRUFCQ0thJ+5R899137LHHHvz000+899571NbWAvDbb79x6623piTEzoSuleNxv0ptzWN4PR8ipbdD5JDBFUj3S0j388jAfKTsGiXLdW0bsRSSxnYlbS+MQZsgpUSX8b9jg65FniWLk/ocwiWDT+as/kcZCkkkuohPyWGHHcZdd90VcZ+UkrvvvpvDDjsspbGTtpTccMMN3HnnnUydOrWZ+WbixIk8/PDDKQmxMyBlkJrqO/C4XyJ8U1UADVdVJpnZ/8LhPKd95NC2IaumQnABjWexDupAyHkQYe7cli6hFkKoPgV+dBTFKHnQ1SjxLefXirdYUzsHXQZxmgrZPed4ds85Aaua0dHiGRi0PV3Ep+Sf//wn++yzD/vttx9XX301u+yyC0IIli5dygMPPMCKFSt44YUXUho7aaXk999/57XXXmuxvbCwkPLy8pSE2Bmorrwan/ddaCgfHn4SlLIGV9V1AG2umEi9GllxJmjb6rc0yqOtR1acBfnvIkxD2lSO1mBxnIzX/03MNkLJR7Ue0E4SGaSDVTXfMnPLNEAg634b7lApP5e9wPLqLzmx3yPYTTkdKaKBgUEdgwcPZtasWVxwwQWcccYZDT5BUkqGDx/OzJkzGTIktftI0ss3OTk5ER1YFi1aRO/evVMSorsTDPyOz/sOjQpJS2qqp7X9Uo7nNdC2Enn5QwcZQNY82rYytBKT7UgU0y6E/UoiY8282qjT04WoDZYya8tdSPQGhaQeiU51cDPfbn+wg6QzMGhH6jO6tuaVBLfddhtCiGavHj16xO8IjB49mj/++IOFCxfyxhtv8Prrr7Nw4UL++OMPxowZk8rRAylYSs466yyuv/563n77bYQQ6LrO999/zzXXXMN5552XsiDdGa/nTeI6Z8oafN4vsTsmt5kc0vMGsZc9NPB/gdSrEUrbljFPFSEsOPJfw1txMVpwEY2ncLiisTXrOizttBRmkB7+rP4fMsZ5KdFZWzuXmmAJmeaidpTMwKB9kbQy+iaFPiNGjGDWrMb6RKqaXNTiXnvtxV577ZXCzJFJWim56667uOCCC+jdu3eDqUbTNM466yz++c9/pk2w7oSmbSa+c6aKpm2KuEdKiQytQOpVCLUXiqlvaoLo2xNpBHopdFKlBEBRC3EUfIAWWEDI9zlSulFMAzHbT0ZRU/P4Nug4NnkWxlRKwki2eX8n03xou8hkYLCzYDKZEraO1HPHHXc0e3/LLbekT55kO5jNZl599VWmTZvGwoUL0XWdUaNGGbVwYqAo2cSzlICOouS02Bry/o9QzYNIbW3jeOYxmLNuRLGMSk4QkQGyZVrglu1aZunrbAghMFnHYLKmbiY06BzIOGnIG9rFVVwMDAyAFunfrVYrVqs1YtuVK1fSq1cvrFYr++23H3fffTeDBg2KOf7atY33o3TnmElaKbnjjju45pprGDRoUDPBvV4v//73v9OqMXUXbPbJeD1vxWmlYrMd2WxLyP0CQdcd7OhSrQd/wV9+Gpa8GajWsYkLYj8OPG8QXTlSwLwXQjVM5AbtRw/77pT4lsVVOopsu7aTRAYGHUSaom/69m1uTb/11lu57bbbWjTfb7/9mDFjBsOGDWP79u3ceeedHHDAASxZsoT8/OgRjKlG1iSCkEkmqFBVla1bt1JU1PzGVV5eTlFREZrWufMLuFwusrOzqa6ujpi3vy2QUqe89ChCwT+JrBAIHM4pZOVMa+yjbcNXMo7oPiAKKMXYiuYiRGL+yjK0Hll2HBCIMq5A5D6HqEs6JqWEwDyk503Q1oHIRNiPAttkhGKEaBqkh6rAJl5be27U/QKVXo49mdzXcHY1aH/a455RP0e/++9EsdtSHkf3+thw3T/ZuHFjM1ljWUqa4na7GTx4MNdddx1Tp05NWY7WkHT0jZQyorlm8eLFRkG+KAihkJv/Kibz8Lot9QaqsEORzX4ymdnNLUyhuJYVHfSt6P45icth6o/Iew6Es26LQli1VgATIuueJgpJAFn1f8jKC8D/JYSWQnA+0nUHsmwSMrgy4XkNDGKRY+nDgUX/AEDscEkSqNjULCYWX9sRohkYtCv1aeZb8wLIyspq9kpEIQFwOp3ssccerFzZcdf3hJdvcnNzG0KGhg0b1kwx0TSN2tpaLr300jYRsjugqgXkF35GwD8bn/cDdL0aVe2D3XkG5ggJy/TQUuL7UqvooaWoHJywHMIyBgpng+8jZOBHkCGEeXewn4po4iQqa+4Hf71Hdr11p04evTKsrBTMRCiOhOc2MIjGnrknkWXuycKK19jmDRdbNAkru2QfwT5555BhLuxgCQ0M2oEUwnpb9G8Ffr+fpUuXMn78+FaN0xoSVkqmT5+OlJIpU6Zw++23k53dGJ1hsVgYMGAAY8cm4d+wEyKEgtU2AattQvy2WKnP+hodHSES04Cbja04wXEmwnFmxP1SrwbP60RXirRwhI7vE3CcmvT8Bt2HKv9aVlS/y3bvrwgEPRz7MCz7JLIs/ZIea0DGWAZkjMUbqiYovTjUXExK8ue3gUGXpZ0zul5zzTUcd9xx9OvXj5KSEu68805cLleHFt5NWCmpF3LgwIGMGzcOkymlWn4GCaJYD0bzfRinlUSxHpT+yf1zgGCcRgLp+xJhKCU7LUsr32RB2XQESkPSs6rAGpZWvcXYohsZkn1cSuPaTdnY6bwh6QYG3YVNmzZx5plnUlZWRmFhIfvvvz8//vgj/fv37zCZktYsDj74YKNKcDug2o8mWHM36JVEtpaoKNZxKKbBSY8t9UrwfQF6OSgFYDsC0TQcOaHMshJkbdJzG3QPNrt/YEHZQwDNsrDW/3teyV1kWvpSbN+rI8QzMOiatLOl5I033mjFZLGZPXs2I0eObLaqkghGleBOihBWrHkvhXOLNPuawmedMA3GkvNQUmNKqaPXPIgsGYd03YqsfQzpugVZMg695uHGfBGmAYkNqCSXcMeg+/BHxYwWTqlNEaj8Wflqi+2aDLK2Zja/VrzOksoPqA0a1ZwNDBroIlWCE2HChAkMGjSIBx54IKl+SSsl9VWCZ86cicViadg+ceJE5s2bl+xwBjFQzMOxFnyOYhlD49kmw+eeyEFqpUmNJ2v/A+4ngRBhf5H6v0FwP4asnR5uaB4Naj/inuGBn5C6YS3Z2QhotZT4fo2TGl5js/t7dNloRVld8w2vrD6ZL7f8i59Ln2ZuyXReW3MaX2+9i6Duaw/RDQwM2om1a9fy7rvvUlZWllS/pJWS33//nRNPPLHFdqNKcPqRUqLV3AOB+SiAgkBBIBAQXEiw/GT04PLExtK2gfv52I3czyC10nBkVebtxI3+keXgfS+h+Q26DyGZmAIh0dFl2Ddpbc0cZm25DZ9W3bAPJBLJKtcsvtx8c8KZXQ0Mui3tXJCvLenfvz8TJkzgnnvuSaqfUSW4EyMDc9B9HxNZOdBA+gm5bk9sMO8HicwIvo8AEGpuYjIaSslOh03Nwaw4E2iXjyqsSKnzQ0n06tMSnU2eBWzyLEinmAYGXY9utHyTKkkrJfVVgrdt22ZUCW5jQu5XqU+wFhkNGfgRGVoXdyypbyP+162ELSoAekUCEkrQkzPNGXR9FGFiaNbkOD4lCrtkn4wQgq3exdSGYheDFCgsq/ok3aIaGBi0AQMHDmwoNROvTk6yGFWCOzEytJz41YVBD61GjeecKnKIn4xNIpSccFXi4J8JSChAKU6gnUF3Y0Tuuayv/RpPqLRZ9A2EnVwzzX3YNec0gIScWSU6ruCWNpF1Z0CXOkqC5SYMOi9Ns7Km2r89ePHFF9ts7JSrBN9xxx0sWrTIqBLchghhj6tGhNvFr5UgbMcg3Y/HaaWB7ehwNlfPcwnMLBGOUxJoZ9DdsJlyObLvs/xUcj+b3HOoV3gFCv0yJrJf0bVY1HB9pPq/sRAIbKqRmyQZqoMuPt/6FV+XzMEVqsWm2DiwcD+O7nEYPe3Gw0KXpIMzuibKwQcnnkU8WVLOgDZ48GAGD04+R4ZB4ii2SWi1K4lelI9wkTzLPnHHEuahSOukutTxkcZTwHYkaFsSVEhUUPuCbXICbQ26Iw5TARN73Y87uJ1y/5+AoMC2Ow5TQbN2fRyjsShOAro76lgSyZCsw9pY4u7Ddl8Jty35N65gDXrd79mn+/h6+xxml87jxl2vYNes7vWgWOGvxa8HyLNkYlXNHS2OQR26rrNq1SpKSkrQ9eb3loMOSj65Z9JKiZSSd955h2+++SaiEO+9Zzg+pgvVcRZa7TOAn8hLLwLVeUFClhIAkX0/svoq8H9D2FdFEvaM0sB6CCL7XmTVlXX74iwbmYYjch83at8Y4DQX4zRHfzI3KVb2yjubn8uejrhfoJJhLmJw5sS2ErFbIaVk+oqnmikk9ejoBPUg/1n+GI/tfR9Wteun6f+uZAkz1nzDn65NANgUM8f0Hs2Fgw4h35rZwdKlmXZOntZafvzxR8466yzWr18frirfVBQh0LT47gc7krRScsUVV/D0008zceJEiouLI1YMNkgPQi3GnPcswYqLgQCNFo6w0qDYjkHN+Efi4ykORO5TyOBvSO+HYSdVpRBhPyFclA+QgV9IxI+FrFsRqmEi/v/2zjs+qir9w8+5d1omvRICoVfpAiKggiKgINixoKDYsAuudVfXsopldV31B2LvirqIDQuiFEU6SJXeCSW9T7vn98ckAyGZyaROEs7DZz5k7j3lPcmdud97znveVxEcveOuptiTy7qsTxHoSDy+/6PMzRmd+m+V5yZItufvYnfhPr/nJZICTyF/ZKxkaNLgerSs9vlo9yJe3ToX7bi7bbHhYs7+ZSw6spE3BtxGM1tM6AysZYTwvmpSvz6ZPHky/fr147vvvqN58+a1ogeqLEo+/PBDZs+ezahRo2rcuaJyNOsgLEm/4in8BKP4R6QsQpg6Ywofj7CcWa2LQJh7Isw9/Z0Nrg3lVKeoAkIIBibdSteYC/gr5ztynPsxa2G0jTiL1hED0UTDyKXlNlzkuDLRhYloc1yDfOjalLsFDa3cLMnxaGhsyt3SqEXJzvzDvLp1LgDGCTPFHmmQ6cznuU1zeOHU60JgXR3RSHxKStm2bRtffPEFHTp0qLU2q/xNEB0dXetbgBSBEXozTJH3QOQ9dd+Z5TRwzCfgbImIAFPtXYSKpkWRO4sdeQso8mQSpsfRPvJswkwxAMRYUjk9cXJI7auIIk8B8w//j2UZP+MwvLmfEq0pDEkcS/+4c/yKE0MabM3bRLrjEFbNxinRvQg31e2SQiAxcgyJ0ciD0c3etxRdaHj8jMMjDZak/0VaUSbNw+Lq2ToFwIABA9i+fXtoRcljjz3G448/zttvv01YWFitGaJoGIjwiUjHTwFKaGC/Kmg/FsXJgyE9LE9/g3WZnyEx0NAx8LDkyCv0iruS0xJubJAzbIXufP5v+z9Id6SVCZ1/1HGQL/a/xsGi3VzYYlI5YbIhZw2z9r5NtutYTB9d6AxOGMbFLcZj0upm9qd9eNtKhYlE0j6ibZ30X1+sy97tV5Acz+acA01HlDQyn5I777yTe++9l0OHDtGjRw/M5rIOyD17+puR90+VPzWXX345n3zyCUlJSbRp06acEatXr66yEU0Rw8ijoPAT8gs+wuNJQ9NiCbePIyJ8ArqeGGrz/CIs/SHiLmT+y3iDrZV+KZRc7eY+iCr4sShOHpYemcH67M997w3cgDcPztrMj5DSw+lJt4bKPL98n/YRGScIkuNZkvEDp0T3o1NkL9+xjTlreX3HC8hyywoeFh+dR44rkxva3lMnyz/do7uQZE0g3ZFRblmjFLNm5qzEgbXed32iBRnbU2uAS2zVppGJkksvvRSASZMmHTNBCKSU9efoet1117Fq1SquueYa5ejqB4/nEEeOXozbs6fkiMTjySM370XyC94iMeF/WMxdQ2af9BxAFs4C1zpAR1gHQdilCC0GABFxB5i6IQveBtcybyW9BcJ+LdivRojacUiU0o3HsRDp2QsiCpPtHIQWXHh7RcMi33WE9dlfBCyzLuszesRdTvgJW4ZDSZGngFVZCyv1z/j96Pc+UWJIg8/3veu3vETyZ/ZKtudvpmPkKbVtMprQuKvjzTy56d+4DHcZ2zU0JJLb2k8i3NS4d8b1j+/AtryDfoUXgC40esS0rkerFMeza9euWm+zyqLku+++48cff+SMM86odWOaCumZN+P27KP8Nl4Dw8glPX08zZOXIUT977WXBR8i857EOwviVbHS+RvkvQyx/4ewev+uwnY2wnY2UrrwZhO21aoAdRd9hyP30ZIw9QKQOHNMmOzXYon6e0h+N4rqszX3RwSi3MzBiWzLnUfvuKvqyarKOVK8H3dJ0kB/GBjsKdzqe78zfwsZzsAZujU0fk//tU5ECUD7iDY81ePv/G//tyzLWOUTJt2iu3BJi9FNIkbJxS0H8PHuRX7PawiGNevZxLYFSyqPvF1Z/fqjdevaF4RVFiWpqalERUXVuiFNBadzHU7nigAlPHiMNIqKf8QedkG92QUgi+cj857w2XHcGaAYmTUZEr5CmI4FxfOKg9oVCO6i73Bk33ZC/wBu3IXvIo10rDGvqFm4RkSBOx2B5ncJBLzRXgtcgW/m9U2wPi7Hh3BPd1YeNt/AIN1xqNp2BUOLsObc1fEmCtteQ647j3DdTqS58ui5jYUUexyP9hjHE+s/8y4FHOdfIhC0iUji3q5jQ2hhHdDIlm8AduzYwUsvvcTmzZsRQtC1a1fuvvvuagdXrbLX2QsvvMD999/P7t27q9VhU6fYF5gsECaKi3+tD3PKIPOn4/9PLgEPsuD9urVBunHmPhaoBJ7ibzBca+rUDkXtYtOjKp0lkRgNLpR8c1srbJUEANTQ6BhxzGEvTK98WUQgCNMrz6RcG9hNYSTbkpqUICllZPM+vD7gNoYmdcckvN+rybYYbu04kjdOu40oc+Neomrs/Pjjj5xyyiksX76cnj170r17d5YtW0a3bt2YN29etdqs8kzJNddcQ2FhIe3bt8dut5dzdM3MDCa7bNPFu9xRmVyVSOmsD3OO9eg5BO71lZTyQNHXSD0RWTQHjBzQmyPCxkHYxYgg0tVXhsfxG9Ko7ElTx134Kbrl1Br3p6h9pDQ4WLiKfQW/45YOYi1taRV+OqszAgtaiUGHqGH1ZGVwmDUrAxNGsODIV35FlYHB4MTzfe+7RPbAollwGv4/wxLJqbGn17q9JyPdolP5V6+rkVLikQYmrbKHvsaLEBJRg1gjNalbHR588EGmTJnCM888U+74Aw88wPDhw6vcZpVFyUsvvVTlTk4mzOZuULLrwD9GSbl6ROYHWbAAmf8qvl037lyvD0rhhxD3IUKvmZOi9PiPRHkMD4Znb436UdQNea405h24j2znbkTJjKB3+6+JRGsn0h3bK1zCEQjaRw4j2tKyvk2ulHObXc7ewu3syN9Q5nhpgLILUibSyn7MR8Oq2zg7aRQ/HppTYXsaGlHmGPrGNe7dLw2BIreTOftX8L+9y0grysKmmzm3eU+ubD2IthFJoTavbmhEq9abN2/ms88+K3d80qRJ1dYKVRYlEydOrFZH/pg+fTrPP/88aWlpdOvWjZdeeokzzzyz0nq///47Q4YMoXv37qxdu7ZWbaoJYbbhaFoihpGB/0R6ZsLt4+rTLNCa4f1zVyaYoKzdJcrbsweZPRURX7PlHaEF45SmIUTDmuZvCuQ795Dj3IoQZhJsfbBUcSnFZRTy/b47KXB7/ULkcX5JBi6yHJtJtHXjSPFfJYLFm1tJ4qFt5BCGJN9fi6OpPcyahRvaPsyKzF/5Pf17jjj2o6HTOao3ZyZeQIeI7uXqjGp+KbmubP7IWOATL6WOvtHmWO7o+BAWFTa/RuQ4C7l1+ZvsyD8MJfNYLreHr/ev5Nv9q3j+1GsYlNg51Gae1CQmJrJ27Vo6dizrWL127VqSkqonGmsU3aeoqAiXq6znelWcYGfNmsU999zD9OnTGTx4MDNnzuT8889n06ZNtGrVym+9nJwcJkyYwLBhwzh8+HC17a8LhDARH/sKRzOuKTly/A3eG/cjNuYZdL1+g/0ILRJpOx+K5xJUbptyeMC1FOnaijB3qrYduvVswIo3yaA/DEz17ATclMlz7mHN0adILz7mgK1hpnXkhfRImIpJCy4I4rac78l3e28QFSEEuI1sLmn1Btvz5lHozsJuiqNT1AjibQ07ArBJMzMwYQQDE0ZgSK/ACORorQmNq1vfxJmJ57Ik/VeOFKdh0+30julP79gBmDW1e6ymPLNxDrsKjlQQC8a71+iBNR/x1ZD7ibM2HV+axrZ8c9NNN3HzzTezc+dOBg0ahBCC3377jWeffZZ77723Wm0KeWJqv0ooKCjggQce4LPPPiMjI6Pc+aoESxkwYACnnnoqM2bM8B3r2rUrF110EdOmTfNb78orr6Rjx47ous6cOXOqNFOSm5tLdHQ0OTk5dbqLyOFYQXbu0zidS33HzKZTiI66n7CwkXXWbyCkew8y4xKQhZQXJt5tuYHREJH3IcJvqJEdztxpuApm+ulPR+iphCXOQwhLjfpRQIFrP7/sH4/bKCgzs+FFI97WizNTZqIFsQX76z03ku74q9JyY1u9SYKtSzUtVijgcHEOYxc8F9B5WiC4teNwrms/tE5tqY97Rmkfrd98BM1e/WjZRmExe258ss7vb6VIKXnppZd44YUXOHjwIAApKSncd9993HXXXdXaQVnl3Tf3338/v/zyC9OnT8dqtfLmm2/y+OOPk5KSwvvvBz+173Q6WbVqFSNGjChzfMSIESxZssRvvXfeeYcdO3bwz3/+M6h+HA4Hubm5ZV71gdXan2aJX9K82XKSEr4mOek3miX9HDJBAiBMrRFxn4LpxBuGAC2Byi8HAbXgoGuOvA897LKSd6VOa96+hZ6KLe4jJUhqiQ0ZL/sRJAAGGcVr2Js3N6i2ijzBObEXebKqYKFCUZ41mbuC2M0lWZqxrZ4sqh9KswTX5FW/9gqmTJnC/v37ycnJIScnh/3793P33XdXO6RDlZdvvvnmG95//32GDh3KpEmTOPPMM+nQoQOtW7fmo48+Yvz48UG1k56ejsfjoVmzZmWON2vWjEOHKt7fv23bNh588EEWL16MyRSc6dOmTePxxx8PqmxdYDKlYjKlhqz/ExHmjoiEL5GuDeDaAOhgGQDF3yHz/1tJbU8FgqYaNggTtph/4wmfiLvwUwz3HoQWhck2Gt02QgVOqyUcniwOFswPGDsENHbmfkabqAsrbc9uSizxJwl8s7A3oIitisaJ2whuxt1tNO6kg02JyMjaCWJXZVGSmZlJ27beRE9RUVG+LcBnnHEGt95a9bwWJ6qp0pj5J+LxeLj66qt5/PHH6dQpeJ+Ghx56iKlTp/re5+bmkpracERCqBDm7mA+5sAnwy6D/JcD1NBASwTrWbVmg27ugR7do9baU5SlwHWwEkECYJDv3FNJGS+dokZztHhjgBKCGEsb4iwN239E0fDpEt2iwuNSeiWxIQUCwf7CHObsW8nIlJ6E6U1gdlVI76sm9euYU089lfnz5xMbG0ufPn0CzohUJxdelUVJu3bt2L17N61bt+aUU07hs88+47TTTuObb74hJiYm6HYSEhLQdb3crMiRI0fKzZ4A5OXlsXLlStasWcMdd9wBgGEYSCkxmUz89NNPnHPOOeXqWa1WrFblBV8ZQk+EqEeQuY9R3r9EAzRE9HMI0XRjBDQ1TFpwa9N6kLtE2keNYEPWLHJd+ytYDvJeM/0TblWReBU1pkNkMj1iUtmYvd+X+0ZK8MjSkKfexZ2jxbk8sX4O7+xYxMwBk0gOiwmh1TWnMTi6Xnjhhb576oUXXljrn/cqi5Lrr7+eP//8kyFDhvDQQw8xevRoXnnlFdxuNy+++GLQ7VgsFvr27cu8efO4+OKLfcfnzZvHhReWn0qOiopi/fqywb+mT5/OL7/8whdffOGbvVFUH2G/GrR4ZN5/wbP92AlzP0TkvQhLn9AZp6gykea22E0pFLrT8LtjBp0W4cEFODJpNs5PfZlfDv6DI8XrEegIBAZuzFoYg5s9QGrEoFocgeJk5pHul3LD0tco9DjxSKNEkJTi/bn0qj5YlM1dKz9g1hl3KFFcxxzvz/nYY4/VevtVFiVTpkzx/Xz22Wfz119/sXLlStq3b0+vXr0C1CzP1KlTufbaa+nXrx8DBw7k9ddfZ+/evUyePBnwLr0cOHCA999/H03T6N69bLyApKQkbDZbueOK6iNsI8E6Ajw7wMgGLRlhangBrxSVI4RG59gbWHP0SX8lEGi0j74y6DbtpnguaDWDo8Wb2Ze/BI90EGNpS9vIs4OemVEogqFNRBLvDbqdmdt+5qe0wNGoPdJge95hlmfsZEBC9XKuNARq6qxa33qsXbt2rFixgvj4+DLHs7OzOfXUU9m5c2eV26ySKHG5XIwYMYKZM2f6/DpatWoVMKZIIK644goyMjJ44oknSEtLo3v37sydO9eXeTAtLY29e1Vkz/pGCAEm5RfQFGgTeTEFrn1szX4Xge5bdhFoCGFiQLPnibS0qXK7ibauJNq61rK1CkVZWtrjebLXFTSzxfLujsW+pZyK0IXGwsObG7UooYbLN/XhU3I8u3fvrjAMiMPhYP/+/dVqs0qixGw2s2HDhlqdHrvtttu47bbbKjz37rvvBqz72GOP1cn00cmAlG5wbQRZBKbWCL15qE1S1AFCCLrH301K+Lnsyv2cLMdGNMwkh59Jm6hLsJvK+28pFA0NKUETAqOSsFpFnvrNKXay8vXXX/t+/vHHH4mOPhYd2uPxMH/+/Gq7VFR5+WbChAm89dZb5RLwKOoeKR3gWoeUDoSpfbWEhJQSCt9BFrwJRnrJUYG0nImIehChZkiaJHG2bsTZ6jnfkkJRS7SJSMAtA+8kk1LSJiKxniyqI0r9eGtSvwZMmzaNhx9+mLvvvjtg7pqLLrrI250Q5VLPmM1m2rRpwwsvvFAtG6osSpxOJ2+++Sbz5s2jX79+hIeXzRxbFWdXRXBI6cbIfxVZ+B7IvJKjAqxD0SP/gTC1Dr6t3Ceg6KMTj4Lzd2TG5RD3GcLcscK6CoVCEQrObd6dZzd+S2GAmRBNCMa0aNzO+KHcfbNixQpef/11evbsWWlZoyQ+TNu2bVmxYgUJCbUXm6jKomTDhg2ceqo3pfzWrVvLnFNez7WPlAZG9j1Ix4+U3UEhwbEIj+MiNOtZ4FrhjbZq6oIIHw/WkQhRNkKrdK6uQJCU4gFZjMx9FBH/SV0NR6FQKKpMmG7hoe5jeeTPL/wmxLiry8gmlQenPsnPz2f8+PG88cYb/Otf/wq63q5du2rdliqLkl9//bXWjVD4Rzp+QTp+8HPWg6AA6fgBUfoxda1EZi8H63CI+S9CHPsTy8JP8IZ19xct0QOuVUj3DoSpETuLKRSKJsfoFr2x6WZe2vwDB4qOpTJIskZxa6dhXJjaN4TW1Q6hWr25/fbbGT16NOeee26VRAl48+EtXLiQvXv34nSWncm66667qmxLjbIEK+oeo/Aj/AkJUfLMUPZCLFl3dfyMzJ+OiDzuonBvqrCdcri3gRIlCoWinsh05FNsuEi0RmLW/N+WhiV345xmp7Auex/pxXnEWO30jm2NLqqcxq1BUlvLNyfmeAsURPTTTz9l9erVrFixosLzgVizZg2jRo2isLCQgoIC4uLiSE9Px263k5SUVH+iZMWKFXz++ecVKqPZs2dXp0mFP9x/4V+QHPu/PBIKP0BGTD4uuV2wkW2bQLhmhULR4Pnx4Hre3bmILblpAISbrFyS2o9J7YcQbbFXWEcIQa/Y6oWhaOh445TURJR4/z8xlco///nPCneq7tu3j7vvvpuffvoJm63qcYamTJnCmDFjmDFjBjExMSxduhSz2cw111zD3XffXZ0hVD1L8KeffsrgwYPZtGkTX375JS6Xi02bNvHLL7+U2RakqCWEfyHhX5CUIHPAtelYedswKv+TW8HSP3j7FAqFohrM2PozD62dxbbcY6lGCtwOPtq9hAlLXiPLURBC6xo3+/bt82XtzcnJ4aGHHqqw3KpVqzhy5Ah9+/bFZDJhMplYuHAhL7/8MiaTqcIYJMezdu1a7r33XnRdR9d1HA4HqampPPfcczz88MPVsr3KouTpp5/mP//5D99++y0Wi4X//ve/bN68mXHjxlU7iJoiAKaabuN0HfsxbBzeWRB/YkYD+5UIrXayPSoUCkVF/Jm1lze2LwAoFxDNkJKDRdm8sHluCCwLLaURXWvyAm9aluNf/pZuhg0bxvr161m7dq3v1a9fP8aPH8/atWvR9cC5zsxms2+DS7NmzXzBTqOjo6sd+LTKomTHjh2MHj0a8K5TFRQUIIRgypQpvP7669UyQlExUkpwb/F/vpIU8qCX8Q0ReiIidgZeYXL8xVZyGVgGISLvq665CoVCERSf7VkW0A/EIw1+TFtPlvPkmi3RhKzxqypERkbSvXv3Mq/w8HDi4+ODSt/Sp08fVq5cCXjTzjz66KN89NFH3HPPPfToUb0M8FUWJXFxceTleWNltGjRgg0bNgDeWPeFhYXVMkLhB/df4Nld4SmJrGT5RgfbeQgtrsxRYR2MSPwBwieBngpaPJj7I6JfQsS+fpz/iUKhUNQNa7P24KkkGJpHGmwt8TVRNEyefvppmjf3BvF88skniY+P59Zbb+XIkSPVnqSosqPrmWeeybx58+jRowfjxo3j7rvv5pdffmHevHkMGzasWkYoKkYahwOfL5kpKS9OdNDiEJEPVFhP6C28MyJqVkQRJFJKPNKJEBq6MIfaHEUjRwty82qlfnNNjFAGTytlwYIFQZWTUpKYmEi3bl4Xg8TERObOrfmSW5VFyauvvkpxcTHgzeJrNpv57bffuOSSS3jkkUdqbJDiGEIEdhw+tnxjQvh26JjANgoR+TeEnlyn9imaPh7pZlP2N6zLmk2Oy5tgK9nWjV5xl9Mu4iwVMFFRLQYktOer/asDzpZYNRNdo1vUo1WhpyGIkmCRUtKxY0c2btxIx461FwW8SqJkz549/PTTT7hcLoYMGUK3bt24//77uf/++2vNIMVxmHuB1hyMQFOYAhFxP8I6oCSia2uEFltvJiqaLh7pYu7+v7OvcCXHx9A8XLyZHw8+Ru/YKxiUNDl0BioaLeNan86X+1b6Pa8hGNvyVCLNVd+mqqgfNE2jY8eOZGRk1KooCdqnZNGiRXTr1o1bbrmFO+64gz59+vDJJyoceV0ihIYWcU+AEjpoiQj7ZQjzKQhLbyVIFLXGmsxPywkSAFkSoG9t1ix25/8RAssUjZ1OUck80G0MQBmHV29EU0HX6Bbc3WVkiKwLHbW1+6a+eO6557jvvvt8vqW1QdAzJY888ghnn302M2fOJCwsjIceeoj777+fq666qtaMUZRHs18KMgsj77njjgrAA3pz9Nh31RZeRa1jSA/rs2ZTcZYRLwKN9VmzaRMxsP4MUzQoCtwO9hQcRRca7SKSAkZjPZFxrQfQPiKJD3b9xm9Ht2JISfOwWK5sfTqXtT4Nmx6879KSIzv5YPtyVmfsBQQDEttwTfv+nJbYpuqDCiHV2UFzPLIel28ArrnmGgoLC+nVqxcWi4WwsLAy5zMzM6vcZtBX0Pr161m0aBEpKSkAvPDCC7zxxhtkZWURG6uezusSLfxGhG0MsugLpHs7CCvCOgxhPbtMbhuForbIdR2kyJMdsIzE4GDRuvoxqJ7ZX7ifpZlLyXfnE2OOYVD8IJJsSaE2q8GQ6ypixtaf+PbAKhyGG4AocxhXtB7E9e2GYtICx7copW98W/rGt8WQBh4pMQdZrxQpJf/e8DNvbfsDXWg+H5X5aVv46eBm7uw6hNu7Dqna4BRB89JLL9V6m0Hf0bKzs0lKOvahDA8Px263k52drURJPSD0ZoiI20NthuIkofIYOMdKNiUcHgdv7HyDVdmr0NAQQiCl5KuDX3F24tmMbz0eXVTtxtnUyHUVcePS19hXmI5HyjLH39z+C5ty9vN8n2uCFiYAmtDQqrH08N3+jby1zbuEeLzTbOnPr2xeSNeYZM5p3rnqjYeAxuToCjBx4sRab7NKj9mbNm3i0KFjIYGllGzevNkXtwSgZ8+etWedQqEICVHm5li1SBxGnt8yAo1mtlPq0aq6Z+bOmazNXguAgVFGc/169Fd0oTO+9fjQGNdAeHP7L+wtSC8XiRW8Yvb3o1v4/uBaxrSs+6y9b29dgkD4FdEagne2LW00okRDotVA6Af/MFF7eDwevvzySzZv3owQgq5du3LhhRdiMlVvFr9KtYYNG+aNMnocF1xwge9pQghRaax8hULR8NGFme6xF7E64yOfY+uJSAx6xF5Sz5bVHXsK9rAme03AMr8c+YULUi4g2nxy5vlyeFx8vX9FhYKkFIHgsz1/1LkoyXEWsSnnUMAyBpIV6XtwGh4sVVwaCgWCmjmr1vcG/Q0bNnDhhRdy6NAhOnf2Cr+tW7eSmJjI119/Xa2orkGLkl27dlW5cYVC0XjpGzeeA4VrOFy08YQnMAFITom+gHYRZ4bKvFrnj4w/0NC8MyR+kEiWZy5neLPh9WhZw+FQUTaFHmfAMhLJ9vzAYqE2cBnBPwC7G4koaWzceOONdOvWjZUrV/rcOLKysrjuuuu4+eab+eOPqu/OC1qUtG7dusqNKxoGUjrBvR3vjp12CC081CYpGgEmzcrYlv/mz6zPWZ81h0JPBgCxltb0jhtHl6jzmlTwtDy3/6WqUjShkevKrQdrGibB+omYAuS1qS1irXbireFkVJJNuIU9mrAq7OQJJaKGu2+MevYp+fPPP8sIEoDY2Fieeuop+vevXrb5oETJ3r17q5QB+MCBA7RocXJF4qsPpJGFdC4H6USYOiPMnQKXl05k/nQo/BBk6RepDWm/DBExRW0lVlSKSbPSN/4aTo27miJPNprQsWpRTUqMlBLMkowhDWLMMXVvTAOleVgMKWGxpBVl+V3A0YXGwITA3021gS40rmrXj+mbF/ldThIIrml/WqO5Xhubo2vnzp05fPiwL9R8KUeOHKFDhw7VajMoOdu/f39uuukmli9f7rdMTk4Ob7zxBt27d2f27NnVMqapIKWBs3gRedn3k5t5K/m50/C4q7/8ZRiZuDNvwnPkdIzs2zFypuDJGIU74zKk6y8/NriQWTdDwWvHCRKAYij8GJl5FdLIr7ZNipMLITTspjhsenSj+YKvKoMTBgdcugHvTMlpcafVk0UND01ojG9zRkB3So80uLLN4HqxZ1LHgXSNSUar4JrUEPSJa8nV7ar3xK6omNzcXN/r6aef5q677uKLL75g//797N+/ny+++IJ77rmHZ599tlrtBzVTsnnzZp5++mnOO+88zGYz/fr1IyUlBZvNRlZWFps2bWLjxo3069eP559/nvPPP79axjQFDM8RsjOvxePagPfXawCCovxXCQu/ifCoRxFBTm1K6cLIexFZ+FZJOyfgWo8ncxx63BflZ02KPgfnEn9Wgns7smAmIvLe4AenUDRhWoS1YGD8QJZmLPW7i+H85POJNJ/cM4yXthrAX7kH+ebAKjQhMEo2P5TGCZnSZTSnxrWtF1vsJgvvnTmBlzct4PPdqynyuAAIN1m4sm1f7jxlKFa98cRyqmnwtJrUDZaYmJgyDyZSSsaNG+c7VroZZsyYMdXa+CLkidtpAlBcXMzcuXNZvHgxu3fvpqioiISEBPr06cPIkSPp3r17lQ2ob3Jzc4mOjiYnJ4eoqKhabVtKN1lHz8Pj3gpU/MewR95LeOTUINoy8GTfCo5fCBwLQgfLGZji3ipz1Dg6Cjw7AtcV0YikJQiV9VWhAMBtuHl/z/ssTl/si1NiSAOB4Pzm53NJi0vQ6sFfoqEjpWTx0b/4bM8fbMrZjy4Ep8V35IrWg+gZG/xSf21S6HayI/coCEHHqMQqRYQNRF3eM07sY8CcuzCFW6vdjrvAwbKLXq5TWxcuXBh02SFDqh64rkqipClQlxeYo+h7crNuDFxIhBHfbC2aFhGwmFH8E0b2bUH2LNATFyH05gBI6UEe7hpczcRfEbry/1Eojifdkc6yzGXku/OJNccyIH7ASbsN+GRHiZL6pfHMazUCiovmADr+ZkkAkEU4HfOxhV0YsC2j8CO8Lj+B17hLGgXPXvCJkmDqlKIuAYXiRBKsCYxuPjrUZgBeH42VmX+xKWcPmhD0jGlP75gOTda352SmMSzfrFu3ju7du6NpGuvWBU4zUZ1gquqOVItII5OAggQAgTSyK2/MvZXgBElps8e2+QrnL8HF9dOag6byeSgUDZW/cvfwxIb3OezI8mXTfX/3T6Tak3is+3W0CU8OsYWK2qSmEV1rUjdYevfuzaFDh0hKSqJ3796+4KknUt1gqkqU1CKa3oJKZ0qQaCUzGgERtip03AxMx5ZrpHMpQc2ymDqrpy2FooGyp+AwU9dMx1WS8O743C4HCtOZsvpVXu//NxJtMSGyUHEysmvXLhITE30/1zZKlNQiNvsVOIo+D1hGaHFYrEMrbUtYRyIL36HymRfQwm9BHJ8kTHqoXJQIMFVvH7lCoah7PtozD7f0VBiDw8Ag31PMF/sXcmuHwEvBisZDY4hTcnwg1boIqqpESS1itpyOxToMp+NX/AmCiKh/IISl0rY0+3g8he9W3mnYeIT92jKHhLkHsujTSipKhEUlT1QoGiJFHgcLjqwtMztyIoY0+P7gMia3HxuSGU8pJb8e+osPd/3B2sy9APSMTWV829M5t/kpaha2GjQGn5Kvv/466LJjx46tcvtKlNQiQgii4maSl/0QjqIv8OYI0QA3QkQQHvVPbPYrgmtMbwlaMhj7AxbT9JTyH37baMh7GmQhFW8J1kCLBeuw4GxRKBT1Sp6rMKAgKaXAU4zLcGOp5zDqUkqe2TCXT3YvQ0P4ZnPWZu5ldeYeLm/dj3/0GKOESRVpDKLkoosuCqqc8ilpIAgRRlTsS3ii7sNR9ANS5qHrrbCGnY8QYeXKS89BPIWfYjiXgwTNehq6/UqQRZUKEgCj6H9oEbeUtUGzQ/S/kdm34xVFx18YOqAhol9U8UkUigZKhCmszM3eH1bNjFmr/6/x7w+u55PdywDK2Fj68+d7VtIrthVjU3vXu22KusUwqrK7s+ooUVJH6HoL7BE3BCzjKZyDO+c+vLMZ3j+0x7UST/4M9IjJwXVkZFR4WNiGQdxHyPxXjovsKsB6FiLiToS54Qe6UyhOVuwmGwMTuvFHxiaMCmZMpASBRrQ5lltXTifKbOfcZr0Y2qwnlnoQKe/vWBJQNGkIPti5RImSKtIYZkrqGiVKQoThXIE7517KL6+UiJP86WhQyfSnAN3/ll5h6YuIexfDsQyKPgbnn+Dehix4D+zXICy9ajoMhUJRR1zd+lyWZmxCUPZbQkpwGzoGggOFWewjE4FgSfpm3to5j/+eejPJYbH+mq0xhW4nm3IOBixjINmSe4h8VzER5irsJDzJaYyipKCggIULF7J3716cTmeZc3fddVeV21OiJES482dSfmnleDQMEY5OIYF20Whh4wL2Iws+hLwny/blSUMWfwURdyIi7qy68QqFoko4DRfFHifhpjBfvJHK6BLViid73MC/Nr5Pocfhq1fsAQPvw0rpTEVprp5DxVlMWfMGH5x+LyZNr7jhGuIvL1BFBOMXo2i8rFmzhlGjRlFYWEhBQQFxcXGkp6djt9tJSkpSoqSxIKUD6fiVwDltPCDzkCX5N8qX1UFvjgi7zH8/jmXIvCeOtXd82+Bd2jF1QNjKJlCU0oVRPA9P0RwwMhF6Crr9MoTljKCTCSoUClifvYNZ+35mReZmAMJ1G6OaD+Ky1HOIsQRONQEwIL4rnw1+jF8Or2Fz7h4cHhc/pq3H33eHRxrsK0zn9/TNDEmqmyVau26hpT2WA4VZAb/BksOiiTKX96NT+Me7NaIGW4Jrz5SgmDJlCmPGjGHGjBnExMSwdOlSzGYz11xzDXfffXe12lR3mFAgiwksSHwF0aKfB1GaldSE11EVMHVBj/sYoR3LWCqNQqSRiZTeYEuy4K1j5StEQ+a/WbZHz1Fc6WNwZ9+BdPyCdK3GKP4eV+Z1uDInII2CIAepUJzczDu0nPv+fJVVmVt8xwo8xfxv/6/csfrfpDuyg2onTLcyOuV0/tblCnrGdKzU+VUTGguOBA7/XROEEFzd9vTAZRBc3XaA2n1TRUqXb2ryqk/Wrl3Lvffei67r6LqOw+EgNTWV5557jocffrhabSpREgpExHFCI1C5SLSwMehJf6BFv4AIn4QIvxU97jP0+DkIPQUA6ViCkXkd8khv5JHTkUdOw8iZBs5FBA6+ZoB7fUl4fO82P1fmDUj3jmPnwdeGdC7FnfNAtYasUJxMHCnO4sUtnyCRGCcsvxpIMhy5vLjlkyq3W+h2oFXyPGxIg0K3o8ptV4Ur2vRnQEJ7RAW2aAj6x7fh6jaBhYui8WM2m33Cs1mzZuzd641XEx0d7fu5qqjlmxAghI5uvwpPwVv4Fw3eMkLoSOlGSDc4V3v9QRwLEWEXI8MugeJvkbmPUmZGROZD0XsEnTtHOkv+W4J0bwhQ0MAo/h7p3oMw1X4kP4WiqfBd2pKA5w0MVmVt4UDRUVqEJQbdbgt7fKUzJbrQaBEWH3Sb1cGsmfi/AeN5Z/tvfLxrGZlO7wxqrMXOVW0HMKn9mVh0dXupKo3N0bVPnz6sXLmSTp06cfbZZ/Poo4+Snp7OBx98QI8eParVprpqQoQefhOeom/AOEJ5YaKDlogefqN3OSZzQkmCvhLfEuMQMm8T5L8GsnRL8IltBClIRARocd4Win/Ae0m4A1XAU/wTpoibgmtf0aAwpIdteYtZl/UtWY79mPUwOkWeRc/YC4g0B39zVARmQ86OSsUDwObc3VUSJafHdyHGHE62y/8yqkcaXNDitKDbrC5mzcTNnYYyqcOZHCzKRkpIscdgriMH25OBxiZKnn76afLy8gB48sknmThxIrfeeisdOnTgnXfeqVabSpSECKHHY0n4Alf2A0jnb2XPWQZijnkWoSdgZEwA33KKLPu/zCA43xR/6GC/8ljYe1kQRHuadyZG0ehwGw7m7HuEfYVrEWhIDPDAioxZrMn8kota/YuWdpV6oCFj0nSmdrmYR9d/6LfMJS0H0i6i/rIHmzSdVuF1OzOjaJj069fP93NiYiJz586tcZvKpySECL05lvj3MSfOxxT9b0zR/8acOB9L/PsIvTnS9Re4luJ/iSdYQVLRGrQOektE+LFosEJvFUSbboSulm4aIwsPz2R/4Z8AXkFSgsTALR3M2fsIRe7cUJnXpOge3b5S3w+ArlFtqtz2Oc168q8e15JojSpz3KZbuL7tudzTWSXoa6w0FkfXoqIivv76a98syfHk5uby9ddf43BUz69JzZQ0ADRTWzC1LX/CsYDKs/0GgWUgOFcCpYFtTGAbjYh6CKFF+4rpYZfjyX8lcFvCjhZ2fuAyigZHkTuXDTk/+I0xIZG4ZDEbc36kX/zl9Wxd02N080F8tvdnv+c1NPrEdqzS0s3xDG3WgzOTurE6cweHi7OIMIVxWnwn7CZrdU1WNAA0ZI22BFe17owZM5gxYwa7d+8GoFu3bjz66KOcf37g7/jXX3+dr7/+usKEe1FRUbz88svs27eP22+/vUr2gJopadBIWRse9AIR/TQiaQki9l1E7DuIpN/QYp5HlPiS+EqaWqCH3xqwNVPUIxXm8FE0bPYVrsWQgXyFACQ78/6oF3saO4Y0OOrI5mhxVoUBwpJssUztfBUCgXbC16yGIN4axdTOV9XIBl1o9I/vyAUtTmNosx5KkDQB6numpGXLljzzzDOsXLmSlStXcs4553DhhReycePGgPU++ugj7rnnHr/n77nnHt57770q2VKKmilpyOjtqdksiQ7Wob6tw1gHVV4j8l7QIvHk/19Z3xEtHlPkw+j2i2tgjyJUeKQrqHJu6ay80EmM2/Aw58BCvjq40BdnJN4SzdgWZ3Fxi6FlkuMNTz6NZFs8n+2bz4rMzUikN3hayiAuaxlc8DSFoi4ZM2ZMmfdPPfUUM2bMYOnSpXTr1s1vvW3bttGrl/80JT179mTbtm3VskmJkoaMKaUKhXXK+p5ooKcgop6sUpdCCEwRt6CHT8RwLAIjC7RmaNYzEEJdLo2VBGubSssIdBKt7eremEaKR3p4ctNbrMjcVGYZLMOZw7u7vuXP7G083u3mMuHde8S0p0dM+2qFmVecfGjCQBPVfxAtrZubW9Y3zGq1YrUGnknzeDx8/vnnFBQUMHDgwIBl3W43R48epVWrVhWeP3r0KG53ZTOzFaM+HQ0YYRwNrqCWDNYh+BxaRQyET0bE/w+hJ1Svb2FDt41At1+BbhvqEyRSOnEXz8dV+DHu4h+Rsrha7Svql0Rbe5JsHREBPvISDz1iL6hHqxoXc9OWsCJzY4V+ORLJmqwtfHNwUYV1LZqZKHO4EiSKgNTW8k1qairR0dG+17Rp0/z2uX79eiIiIrBarUyePJkvv/ySU045JaCd3bp14+ef/ftMzZs3L+BMSyDUo29DRkRVXgZA2NBiX0NKpzcQmgivk/DOrsJPcOY+CzKrjI2WiLsxhd+gQko3cIY3n8Ks3VPwSFeZ3Tel9Im7mOSwTiGwrOEjpWTO/oUB3Qglkq8OLOKiFkPVZ0ERUvbt20dU1LH7R6BZks6dO7N27Vqys7P53//+x8SJE1m4cGFAYTJp0iSmTp1Kt27duOCCsg8y33zzDf/617948cUXq2W7EiUNGKk1C7Kg96tSCAuUxhypZVwF7+DMfayCvnNx5j2JlPlYIu+pk74B3O79FDmWIHFhNffEaqletMCTmSRbB65s818WHX6dvYWrfcfD9Tj6JVxBn9iLQmdcA6fYcHKwuPKZy8OOTPLdhUSaw+vBKkVTQ9Rw940oqRsVFVVGlATCYrHQoUMHwBt3ZMWKFfz3v/9l5syZfuvcfPPNLFq0iLFjx9KlSxc6d+6MEILNmzezdetWxo0bx80331ytMShR0oARRlpwl6csrFM7pJGLM9f/9B+AK/9lTPar0PQghVSQeDyZHM36G4XFP3B8DBWLuSdJcf/FYu5Sq/01dRJt7bi09TPkOA+R40rDrNloZuuEJlQUzkBUlOPFb1k1S6KoJho1jOhao2CaXqSUQcUY+fDDDxk7diwff/wxW7duRUpJ586defzxxxk3bly1+1eipCEjgvTO14JI7lcD3EXfcCzGiT8k7qIvsERUfV+6PwyjkINHL8Xl3saJQd2cro0cODKWFknfYzG3r7U+TxaiLclEW+ov6mdjx6ZbaB/egp0FB/3GehFAK3sy4braMq9oHDz88MOcf/75pKamkpeXx6effsqCBQv44Ycfgqo/bty4GgmQilCipCFj7g5aUkl+HH9oiLC6dU6Unj14d/cE8qbWkO7qZYX0R17BR7jcW6g4yqwHKQvJyn2eZvGv1Wq/CkVFXNzybP69xX94dwlc3AT9SQ4V5fLB9uX8b/efZDmLiLWEcWmbXlzb4TSSw4L0e1MERW3tvgmWw4cPc+2115KWlkZ0dDQ9e/bkhx9+YPjw4dW2oaYoUdKAEUKH8MnIvCf8lNBA2CHsijo2JIKgQtprtbuOnlvwfiUlPBQUfYvHyELXYmu1b4XiRM5J6sfGnB18f+gPNIQv4Z5AIJEMbzaAEcmnh9jK2mVrzhGuWfQ+ea5iPCW+a5nOQt7etpTPd6/lw7Mm0Ck6KcRWNh10IdFrsHxT1bpvvfVWtfrRNA0hBFJKhBB4PP5SoVQdJUoaOvbxYKRBwRsci0VSuvU3HBH7FkKv2+yuJtt5uPJfqKSUG5NtVK3263LvpXIx5MHtTkO3KFGiqFuEENzZ8Qp6x3bmy/0L2JK3Gwl0imzFhS3OYmhi3yY1S+KRBpOXzCojSI6dk+S5ipm8ZBbzzrtdbXU+ydi1a1edta1ESQNHCIGIvA9pG4ss+hRcW0DYENazIewiRB37kwBo5k7o1nPxOH6h4gizOpq5D5q5b+32q4VjGJVHGNU0FRmzseA23CzLXMKCI/M5WHQAk2aiV8ypnNtsJK3sNUv0WOguYnv+HgwM2thbEmOp/aUFIQRnJfbhrMQ+GCXh5bUmekNedGgH+wuz/Z73SMn+wmwWH9rB0OYd68+wJkx9576pLq1b111SViVKGgnC3Blh/mfI+rfGvERx5g0YrmUcm7Hx/q+ZumKLe6PWnxIjwi4qWcLxNzWoYTF3xaSn1mq/irrBZTh5Zdt/+Ctvk2/Jw+VxsTzjD5ZlLOH6tjdxevzgKrdb7HHw4Z45/HxkCS7DG05fQ3B6/KlMansZsZboSlqoHk1VjJSy9OhuTELDXUFun1JMQmPp0d1KlNQS9e1TUh327t3rN5JrRRw4cIAWLVoEXT7kn6rp06fTtm1bbDYbffv2ZfHixX7Lzp49m+HDh5OYmEhUVBQDBw7kxx9/rEdrT16EFokt/lOsce+j20ajmfuj20ZijX0TW8LX5ZL71QZRETcgMOH/MjWIibynSU2ZN2XmHPgfW/I2A5TZwWJgIJG8u+tN0ooOVqlNp+HiiU2v8OOhRT5B4m1TsjRjDQ+tf54cZ/n06orKMQKIkeOpKCGhonpooqZRXevexv79+3PTTTexfPlyv2VycnJ444036N69O7Nnz65S+yGdKZk1axb33HMP06dPZ/DgwcycOZPzzz+fTZs2VajEFi1axPDhw3n66aeJiYnhnXfeYcyYMSxbtow+ffqEYAQnF0JomKxDMFmH1Et/FnN7miW8x+GM60vC2ZfeyHTAIC76USLsdbPzyOnJ5kD+bA7mfY3LyMJmak7LyMtpHj4aXbPVSZ9NGYfHwcKjv/rdTlvKgqPzuarVtUG3+/Ph39mSt7PCcwYGGY5sPts/l5va1bEzeBOke2zzgLMkAG5p0CO2Kjm6FI2dzZs38/TTT3PeeedhNpvp168fKSkp2Gw2srKy2LRpExs3bqRfv348//zznH/++VVqX0gp62cRqgIGDBjAqaeeyowZM3zHunbtykUXXRQwVv/xdOvWjSuuuIJHH300qPK5ublER0eTk5MTdMQ7RWjxeDLJK5xFUfFCpHRitfQhKuIazKa2ddJfvnMnKw5NxOnJ5JgQEoAkwtyR/s3fxaIrx9qqsCV3My9sfabSconWJJ7q8XzQ7d615nEOFB0OWMaqWXin/3NY9bqJdtxUcXjcnPHdf8h1FVcoJQUQZbbx2+gpWPWm6wlQH/eM0j5uXng5lghztdtx5rt4fcjn9XJ/Ky4uZu7cuSxevJjdu3dTVFREQkICffr0YeTIkXTv3r1a7YbsSnI6naxatYoHH3ywzPERI0awZMmSoNowDIO8vDzi4vwvHTgcjjLR6U7Mnqho+Oh6HDGRtxITeWud92VIF6sO34zLk03ZnT/enwtcO1l35D76NX+zzm1pSnhkcFsGPTL4zKJSSg4WBYrh48VhOMlwZpMSprauVgWrbuLF0y7hliWfIpFlduDoQiAQvHjaJU1akNQ3ooY+JaIefEpKsdlsXHLJJVxyySW12m7IfErS09PxeDw0a1Y2LHmzZs04dOhQUG288MILFBQUBIwoN23atDLZElNTlVOkojxOTxb7cj9h/dH7KXYfQPoJFCfxkFG8hHzntnq2sHHTwt4SrZKvGw2NNuHtgm5TCIEpyPD4Fk3dOKvDmcnt+WTodQxOaucLtC+AwUnt+GTodZyZrKIpK2qXkH9ST3RSLA3GUhmffPIJjz32GF999RVJSf6fgB566CGmTp3qe5+bm3tSCBNpZCOLvsBw/A64EOYeCNtlgAswEKa2CKHCYUvpYXvWS+zJeRdZssvn2NUnfeGxyqJxtHARERa14yBYos0x9I49lbVZqzEq3Fbu9QEZmnhuldrtF9eTZRlr/bYpELQMSyZexbGpNr3iWvDmGVeT6Sgk01FAnDWcOKs91GY1SUodVmtSv7ETMlGSkJCAruvlZkWOHDlSbvbkRGbNmsUNN9zA559/zrnnBv4Ss1qtAdM2N0UMxxKM7MkgiyhddpDOZRgFbyBlSRxKEYYedgV65JR6iXXSUNmS8Sz78j4oc+xECXLix1ygYcjK46coynJF6nh25u8g15VToYgYmjiMzpFVS7A4NmUYf2Ss9nteIrmoxQi1Q6uGuA2DzVmHOVpUQLwtnIHNWmPSQr55s8lR3xFdGyIhEyUWi4W+ffsyb948Lr74Yt/xefPmceGFF/qt98knnzBp0iQ++eQTRo8eXR+mNgikkQmORV6hobcBywBEBXESpHs3RtZNeBPolfWJEHh30HikAbIIT+EHGM4/MMd/dlIKkyLXAfbl+c9lcgxJ2fkTNxGWDnVmV1Ml1hLHw10f46sDX7As8w/cJf4j8ZZEzksexVmJZ1dZPHSKbMtt7a9hxo6PEAif2NFLrvOLW4xgSOJptT6Wk4n/7VzHc2t/5Whxge9Ygi2ce3sN4Yr2vUNnmKJJEtLlm6lTp3LttdfSr18/Bg4cyOuvv87evXuZPHky4F16OXDgAO+/782B8sknnzBhwgT++9//cvrpp/tmWcLCwoiOrpsASaFGSgcy9yko+oIyCfH0FhD1JMJ6RpnyRuH7JeUqVsxSyuPydniQ7m148v8PU9SDFZZvyqTlf4XXraoqeRsEFi2WRPvQujGqiRNjiWFi2xsZ12o86Y6jmDUzSdZmNQpENqzZIDpFtuWHQ4tYm70JQxp0jmzHecln0SVK+TzUhPe3ruSxlT+VO55eXMBDy+ZS6HJyfRcl+moLDQPNz1JksPUbOyEVJVdccQUZGRk88cQTpKWl0b17d+bOnesLYZuWlsbevccyz86cORO3283tt9/O7bff7js+ceJE3n333fo2v86R0kBm3QnORZQL7+45iMy6EWLfQliPRcGURd8Q6CbrexL1edIbeAo/8S7jiJNrmavYc7gksmhgvJuBodQvvHviU2ii+tv2FBCmh5FqDz4qZGWk2purWCS1TK6zmGmr5wcs88zaX7m4bQ9irMo/rTZQPiUNwNH1tttu47bbbqvw3IlCY8GCBXVvUEPC+Ts4F/g5WeIrkvsUJHx3nNgo8FM+ADIPPIfAVHf5DBoiZi2GYLIfl5aIsnSlU9zfiA8bUJdmKRQNgq92b8RpBJ5FdBsGc3Zv4LrO/evJKkVTJ+SipLFiGHk4Cj+kuOBDDM8BhIjAEnYhYRE3oJuC39YYCFk4i2N5ZiosAZ7t4FoHll7eQ3pL8Owi0M22wnh54uS7FJIjRrE75/WAZQTQLWEa0dbuyo9EcVKxOy8Tk6bhMvwvCehCsCs3sx6tatroGOg1WIKpSd2GgnKfrgaG5yg5R0dTmDsNw7MHcCNlNo7CD8k+MhyX4/fa6cizm6D8HTz7fT9q9qsDFpXyxEDfAvRWoJ18oaIjLZ1JtJ+D/4+BRnL4WFpEXqQEieKkw24yYwSxGmA3q0i5tUXN8t7UbOmnoaBESTXIz76nRIycqEo9gJPczEkYRi1EjhXRlN+gWgFaxLEqYePA1BHvDEtZSmdI5Am7ckzhN560WyZ7JD5PQthZAAh0vPllvb+7JPtwTkl4IoTWKRShY0Rq50qT7bmlwciWnerJoqaPLowavxo7J9+cfQ3xuHficiwMUEKCLMRR+DlhETfUqC8RNgrpWllJoQiwnH7srWZHj/sIT87D4PiZsss44rj4EN5lIS1sHJp9fI3sbMzomp0+yTPIcawnLf8bnJ4MrHoiKREXEmntGmrzFIqQ0SOuOQOSWrHy6L4yIeZL0YWgd3wLesWffLOsirpDiZIqEuzSjMvxW41FCbYLkXkvgMyvcL5EAsJ+bbldM0KLxRQ7A+nej3QuA1xICYZjodd5FgNh7o0ePgHNOvyknSU5nmhrD6KtPUJthkLRoPi/My5h4q+fsDHrsC+UQOn/HaMTmXHWper7oxYRSLQgnO8D1W/sKFFSRbw5UY5tEvVXCj+5U6rUl2M+UuYivGHPkMiSLayy5JjEKFqAiLgLUUEOEGFqiTC19L3Xw6+ssU0V4fFkUFz8A4aRja6nYLONRNNUGGqFoj5wejzkuoqIMFmxmWp3q3qczc7skdcxb/9Wvti5jsOFeSSFRXBpu56MaNkZix5c7iFFcNR0CUYt35yEmMw9qXwbqVZSrvpIaWDkeVO4y5J/pYIEOLYMY2xEOhYhbGfXqL/q2egmN+dJCgrexSvCvIHIhIggKuphwiOuq3ebFIqThf0F2czYtIQv96zH4XGjIRjeohOTTxlEz7jaW1IxazqjWnVlVCu1nKmoe5QoqSIm86nopi543NsItDPGGl5DPw3XajDK5gU6cd+M73jRHAiBKMnOvp+iwlkcE2ne34eU+eTkPAxIwiOur3e7FFWj2FPE8swlbM3bjCEN2oS3Z1DCWUSYTr7UA42FrTlHuWL++xS4HT5/DwPJzwe3Mv/gNmaccRnnpKiEkY0NTRhoNZjtqEndhoLafVNFhBBExL4Mwkb5HS7eX2d49L/Q9Zo9qUgjI/iyMr1GfVUHl+svigo/JdCsUW7u0xhGYf0ZpagyW/I289D6u/l477usylrOmuyVfHlgFg+su4sVmX+E2jxFBUgpuXPJbJ8gkRLfy21I3IbBXUu+JM9ZHGpTFVVEB3RkDV6NHyVKqoHJfAoxCd9hsY3meGGim3sSGfcOtvAJNe5DaIlVKBs4q3JdUOgL7OYfKQsoLv6+fgxSVJlDxWm8uu15ij3em5c87p9Hunl71wy25G0OsZWKE1mZvo/tuem4DYk08EYmMITvJQ0ocrv4cs/6UJuqUFQZtXxTTXRzByLjpmMY2RiewwgtssazI2Uw9/YGNDMOVlpUhF1Se/0Gicd9gPJxWk7EhOe4wG51gZQGICt09FUEZv7h7/FIj99lQYFgbtocOkcqX4KGxOr0/WhC4DEkyIp3vkhD8MO+v5jQUYV/b0yo5RslSmqMpsWgaTG13q4QGlrkAxg5dwcuaO6PsAyq9f4rQ9Oi8c6UBNpl5EETdZO9ObNwAQdy3ya7eClgYDd3IiVqAskRlyFOwpD51WF55pLj4taUx8BgS94m8t15yr+kQSG8+TT9CJLSgIt/Hk3DkBJNbdltNJQuw9SkfmNHLd80YLSw0WhR0/CrHS1nose+gahB2vfqEhY2lsq3PWvYwkbVet97sv7LxiM3kl28jNLZmkLXNrZn/INNR27FkK5a77OpYUgDh+EIqmyRR/kFNST6JaZiGJLKdgEWedz8fmh3vdikUNQWSpQ0cDT75ehJKxGRf/dGbjX1RoRdiZ7wA6a4dxDHhZivTyzWMzCbT8W/X4nAbr8GXU+q1X6zin5nb84rJe+O3/3k/YLOLFrA/pw3arXPpogmNCJNUZWXQw+qnKL+ODW+BeG6hcpSUAgEO3Lr3wleUX1Kl29q8mrsqHnuBoI0spCOBSALQE9FWM7w+UkILQI9/HoIbzjba4UQxMW/R2bGBFyuNXgvJbfv/7Cwi4mOebzW+z2Q+y6VZU4+mPs+qdE3q2WcSjgz8Ry+T/sa6WcJR0Ojb+xp2PSwerZMEQghBH0TU1mUtjNgOYnEpjeez4DbMPhpx3Y+3bCO3dnZRFttjO3chcu7dSPGdnJcg1oNswRrTSBLcOO5YpsoUjoxcp9BFn0Mx0eL1ZLQoh5Hsw0PsYX+0fV4EhK/wen4jaKiOb6Irnb7lZgt3eukz5zipVSWOdllpFPk2oPd0r5ObGgqnJ04nCXpi8h1ZZfzLdHQMGsWRqdcHCLrFIEY27pbpaJEQzAkpXF8BgqcTiZ99SUrDh5AEwJDSvaTy6ajR5i5agUfXnIZXRKC35HYWKlppl+VJVhRI6SUGNl/QxZ9wDH/jJKLyjiKkX0bRvG8UJkXFEJoWG1nERP7InHxbxMd8686EyRegnsSkJUIFwVEmqO4r/MjtA5vB3in+7WSr4REazPu7fx3km3NQ2miwg+jW3clKSwC3Y8TqyYEF7Q+heb2xrH09o9f5rMqzbvT0Dgu+Z8EcoqLmfjl/yh2K1+xkwE1UxJKXKuQjrl+TkpAYOQ+ibAOC4kza0Mk0tKLHMdKAokTXUQSZmpdf0Y1YuKtCTzQ5Z/sLdzti+jaNrw9HSI6q0RrDRirbuL9s69i/PyPyHQU+lxeS2cZ+ia05KnTzg+pjcGSlpfHN1v/KiNGjscjJUcLC/l261YuO6VbPVtXv+g1XL6pSd2GghIlIcTwBSDz7x+BcRDpXIawDqxHyxouKVETyDm6PEAJjeaRV6Fp1gBlGgZSSvYXbWVt1gLy3dmEm6LpHTOUVHvFgsCQBmuy/mDR0R/ZV7QLDUGnyB4MTTqfTpE1m51qZW9DK3ubGrWhqF86xSQyf8xkvti5jq92byTXWUyriBiu7NCH4S07YdIax4PMoj27/QqSUgQwf+eOpi9K6jkh37Rp05g9ezZ//fUXYWFhDBo0iGeffZbOnTtX24aaokRJCJGePVTmHwGAZx+gRAlAvH0kzcIv5XDB/yifrVkjwnIKrWJuD5F1weM0HHy2999syVuJho6BBw2NFZk/0szWlstS7ybZdmy2x5AG7+9+hTXZS32JGT3A5ty1bMxdzQXNr2B48kUhG48iNERZbEzqchqTupwWalOqTbHbHVTe9WJ3zTOvK8qycOFCbr/9dvr374/b7ebvf/87I0aMYNOmTYSHh4fEJiVKQomIwuvWU4m61VTgqlKEEHRMmEaktRf7c9+m2L0bAJMWQ/PI8aRG34yuhebDVBVm73uZrXmrATBKhGmps+mhol28svUe2kWcysUtbyHOksTCo9+zJnspUDYxY2mdb9Nm0Tq8Q41nTBSK+qZDXHylIb90IegQF18v9oQSDYlWgwBoVa37ww8/lHn/zjvvkJSUxKpVqzjrrLOqbUdNUKIkhGhhozGcCyopZUNYzqwPcxoNQmg0j7qa5MircHoOI/Fg0ZPQhDnUpgXF0eL9bMxd4ve8EN45oB3565i+/SFuaz+NBUf8+R550dBYcOR7JUoUjY6Bqam0jIziQF6u31uqR0qu7N6jXu0KBbW1fJObm1vmuNVqxWqtfEk7JycHgLi4uGrbUFMax6JjE0XYRoHWgkCJ7UT4dSELkNbQEUJgNSVjM7VoNIIEYEPO74hKPnreJXYPhe48vkt7n2xXZsDyBgZb81QCNkXjQxOCZ4aPQBPCb0j82/qfRvsQ3igbG6mpqURHR/te06ZNq7SOlJKpU6dyxhln0L176B5u1ExJCBHCih73Pp6sieDZz7GlHK/zq7BdhhYxpdb687j34SichcezD02LxGK7AJNlgNplUc8UefJL/EIqx8BgU+5KKoveWVpWoWiMDEptxUeXXs5Tixay/shh3/EEu507ThvAtT17h864ekTDqFEAtNK6+/btIyrq2HbwYGZJ7rjjDtatW8dvv/1W7f5rAyVK6gjDvQuj8EM8xb+AdCHMPTCFj0dYBpcRAcLUGj3hR2TxTxjF34PMR+ht0OzjEObaUatSGhTmPk1xwUyOTY4JigvexWQ+lci4d9F09RRSX0SbE/xGUa0IQ7qxaBE4A+SqEQhahrWtDfMUipBwWouWfHXVeLakp7M/N5dIq4VTm6c0ml1EtYEG6DUJnlbyf1RUVBlRUhl33nknX3/9NYsWLaJly5bV7r82UKKkDvAUfYc7+57SdwBIx2Fcjh/Rwq7EFP2vMnFHhLAiwsaghY2pE3uK8l+muOC1MvaU4nb9SW7meKITvvWFtVfULT1jzuKnQ++XcVitCKNkdkQI6BczmD8yFvgVMxLJWYkja91WhaK+6ZyQQOeEhFCbERK8cUqqP3Nd1TglUkruvPNOvvzySxYsWEDbtqF/sDl5JGg9Ybi24s6+G+/N/3gBULLDouhTPIXv1ps90sinKP//ApTw4HGtx+VYUF8mnfREmmM5K+lSv+elLBUkAoGgmS2VsSlX09zW0q8vSu+YAZwaO6iOLFYoFE2R22+/nQ8//JCPP/6YyMhIDh06xKFDhygqKgqZTUqU1DKewveobP3fk/8GUtZPGHSnYz7Iyi4wHUfR7HqxR+HlnKSrGNbsanRhQkrKvAyEb5ZEIjk78RLCTOHc3emfnJ00Cpt2LDlZtDmWC1PGM7HNXWgq6q9C0aip7yzBM2bMICcnh6FDh9K8eXPfa9asWXU0wspRyze1jFH8E5UGRDMOI91bEeaudW+PkUn5IGMn4sHwZNS5LaUUu/aT59wACKKtp2Ix1X+iLYcnn79yfmR73iJcRiGxllZ0ixlDC3uvenH8FUIwNOlyTo8fxU+HPmJZxk9IwChJL6ChYWBwbrMr6B3r3RJu0+1c2GI8o5pfTobzKBoaCdZmSowoTgq2HU7n9+17cHk8dE5OZHCH1uhNzN8kFMs3DQ0lSmob6azdcjVE05IJLEgAdHQ9pc5tKXansS3jUTKLFh1nk0aifRQd4x/FrMfUuQ0AR4q38tXe+3EYeT47Mhy72Zb3Kx0jz2F4ykNo9eRfY9PDGdviZs5MvJhlGT+xNW8tBgat7Z0YED+ClAqcV82ahWRbiyr1s7cgje/Sfmd99jYEgh4xHRidciap9ma1NRSFok7IyC/kb5/PZenOfWhCIAR4DElyVATPXHoeA9qlhtpERS2iREktI0ydkK41BI7SakKYWtWLPRbbOQgRjZQ5AUp5sNrH1akdTvdR1qSNw+lJp6xIMjha+D0Fri30aT4LUx3HZHF48vl67/04jfwydpRmFd6W9ytR6ckMTLwxqPYOFe9lXfbvFHryiTEn0Cf2LKLNVY88GWtJ5Lzm4zmv+fgq162Mbw4s4rUdX6AJDUN6r8u9hYf49uBibu1wGaNTVHC++qTA5eSnXdtJy88j1hbGyLYdiAuzh9qsBkmh08XEtz9nd3oWUJJBuORjeySvgBvfm82HN46jV2rTyGatC1mj3Tc1qdtQUKKkltHDr8GdvSpQCTTbKIQWWy/2CGHFHvUQBTkP+imhYbYOwWQZUKd27MmZXiJIKlra8lDo2sHB3I9oFXNLndrxV86PFB83Q1IeyZ+Zs+kbPx7Lcb4bJ+I0ipm192U25i5HQ4OSfDQ/HvqYsxIvZGTy1Q1iWWVV5mZe2/EFgE+QwLGYJtO3f07LsGb0iu0UEvtOJqSUvL1uNS8s/41Ctwu9JKPvI4t/5voep/Lg6Wc1ueWImvLlmo3sPJpZ4ae1NInfi/N+471Jl9evYXWEN05J9ZdvahLjpKGgPgG1jGYbjbAOoWJnVx20WExR99WpDYYnneLCWRQVvIOzeAFW+1XYo58EUXqTNUPJjdRiG0Nk7Ot16kdhGA4O5c8msK+NwcG8j+vMhlK25x2/dFQxblnMgYLVfs9LKfloz4slQc28N3gDDxIDiWTh0TnMP/x5bZpdbb7Y93PALzkNjS/2/1yPFp28vPnnSp5c8iuFbhfgDZ0uAbdh8OafK3l08fzQGtgA+WxF4CjFhpQs37WfA9m5AcspGg9qpqSWEcKEOXYmnrz/4Cn8EGRByRkNYR2GOfoRhF41f4BgkbKY/Jx/Ulz4CV4B4HVw1bRkImKeIa7ZGhzF32K49yG0SCy289FNrStpteY4jXSMSncAgcOThpRuhKi7y9JlFAZXThb7PbevaBtb8vyLFoAFR7/kjMQLCNNDlxyw2ONgXc62gGUMDFZn/YXTcGHRGk+o/sZGntPBv5f/7ve8BD7a9Cc39OpLuxgVyLCUQzl5QUU+PpSTR4uY4IOFNVS8uW9q4Ohag7w5DQUlSuoAISyYoh5Aj7wL6fwTcCFMnRB63TkVSinJzZzs3QLsm8LzfpwN4zC5mdcTFfc+NvuVdWaDPzThfxnkeARmAuUBqg1iLa3JcOz2+ZD4I8bi33luTdYiNHRfdt+K8Eg3G3KW0j9uWFB2SSnZnLuNA8WHsGoWesWcQrS5Zl+yDsMVdFklSuqWuTu24vS4A5bRheDzvzbwwOmhyc7aEIkOs5Fb7D+S8fHlmgJaDXffNIXlGyVK6hAhwhDW0+ulL5djMU7HPD9nvdtM83P+gcX6e73nurHocURaepHnXI9/B2CdBPu5dW5bt5gL2Jb3i9/zAkGctS2J1o5+y+S7syvNM6Ohk+/ODsqmjTlbeH3HhxxyHD2uvsbQpIFc3+YKLLolqHZOJMJkJ8JkJ98deHYoyhSOXa/al3qh24HLMIg0WxuE70xD52B+Lrqm4Tb8XzcSSMvPqz+jGgFje3dlxoJlPv+RExFAu8Q42ieq2aWmgvo2aSIUFX5M4FkGieHZg9u5or5MKoPXgTXQjVzSMnpSndvRwt6LjpHDqMjnxxs/VWdIs7sDiqMIU0yJc6t/DDxEmGIqtWdz7jae2vxfDjvST6hv8OuRJTy3ZUYZB9WqoAuN85sPqsSnRDAq5YyghcWPBzdy1aLXGTD3ac744RnOnfcib25bRLEn+FmZk5Foq83vjbUUDUG0tWk88dcWV/TvSaTN4ndJQwJ3njOwySQV1ZA1fjV2lChp5EjpxOVcidu5nkqDtgEez766N6oCEuzn0i72AQBEGfGkAxpdEp4jytqrzu0QQjA85UH6xl+FSZS9AcRZ23JxqxdJsfcI2MapsUMCLt0AmISZ7tGVz5K9t+szDCkrzIMjkazP2czqrMDOfoG4tOUwmtniKxRRGhrNwxK5uOXZQbX1380/87eVn7Ep+6Dv2NHiPF7Z/AuTfn+HQnf9xN5pjJzfrvLdTW5pMKZDl3qwpvGQGBnOO9dfRmy4dwlYL4lTogmBJgT/uOBsRnZvOjvHvD4lNXs1dtTyTSNFSg9F+dMpzJ+JlFlB1xNaZB1aFZjU6BuICxvCwbyPyXGsQqARaxtE88grCTPXXwAkTegMTLyRvvHjOVCwBpcsIsaSSqK1Y1BPXC3DOtA1sh9/5a3ym1RvaNLFlTq57inYz67CwCJRQ+Pnw4vpF1c9wRZpDuffvacwY/vn/J7+p89eDcHgxF7c2uFyIkyVx8hYenQnb25bDJRGnT2GgWRj9kFmbPmVe7uppIAV0Twikss7d+ezv9ZXeMXoQtA3uQV9k+s+iGFjo2vzJObfewM/btzG4q27fRFdL+nbjaTIuo1rVN/oSPQazHbUpG5DQYmSRoiUkrzsqTiK/kfl0VqPIUQEFktoA2WFWzrQMf7RkNpQikULo21k1ZPYCSG4qvUUPt/3Kutz/vAGhReiZJlFMDTpIoYlVR434cgJSzYVYWBwqPhIlW08nhhLJA+dMokMRw5b8/YA0DmyNXHW6KDb+HjnUnSh4fGzlGQg+WzPSm7vcg42XTnMVsQTZw2j0O3km+1b0EsC2WlC4JGSPs1SeOP8i5rMMkRtYzGZGNOrK2N61X1qDkVoUaKkEeJyLMJR9EWV64VFTEYECAimCB6LZmV863s5UnyAdTm/U+QpINocR5+Ys4g0BxcYLyxI51K7Xjt/s3hrNAOtPatVd1XmHr+CpJRCt5MdeUfpFqOe9ivCqpt4ZfgYbul9Gl9s2UBafj5xtjDGduzC6SmpSpAoSvxCqr8E0xR8SpQoqQek9OBxLMBwrQYEmuU0dMsZiGruWigqeA+vL0YwmYa95Wz2idgj7q5Wfwr/JNlacK6teiH6u0R2IMIUTr67wG8ZgWBwQv/qmleLBHfDVLfVyume2IzuiSrnkKI8Xr+QmtVv7ChRUsd4nH/iyJqMNA5y7Nf9CkJvgy32NbRqZAp2uzcSjCDRzd0xW/oTZr8ak/mUKvejqFtMmomLWozkwz2zKzyvIQg32RmSNLCeLStP3/jWLDq8NeBsSbjJSrvI+s/4rFAomg5KlNQhhnsHxZlXgiwN/nMseJL07KMoYxxhCd+jmVpWqV0hrEGVi4h6FIt1cJXaDhXZzoOsy/qWfYV/IqVBC3sPesZeQLy1fhIXhooLmg8ny5nDd2nz0dAwMBAleXQizRE83PVuIkyhiwpbyvi2A/j10F9+z2sILm/dt9H4k6QXFPD9lm1kFxXTLDKC8zt3JNIa3OdKoagrlKOrEiV1ijPv/0oEScVJ6JAFuArewBr9eJXatdhGUpQ/00+7XoSIwGw5tUrthoqN2T8yL+0/AMiS9dR0xy7WZs1haLPb6BN3UQitq1uEEExoczlDEgcy//Bi9helYdUs9IvrzeCE/tj0hnGjHJDYjps6nskb2xajIcrswBEIesS24LbOwW0tDiVuw2Darwv5cPWfGFKiaxoew+Cxeb9w5+DTmTygv/LtUIQMISRaDTL9CpUlWOEPKYvxFH9N4GUWD+6iz7BE/bNK/iVh9gkU5b+BNxhZRRehICx8EiLI8O6h5EDhBn5Ke5ETx1EqThYcnk6spQVtIhqCX0Xd0Tq8JZPaXRVqMwJyV9dz6Rqdwns7fufPrP0ANLNFcVXb0xjf7vRGMUvy6E/z+XzdBt/VVhph1enx8MIib26aW08/LUTWndxIKVm3+QAr1+/BMCRd2iczsG87TLoKp3UyoURJLWB4DuLMfwdX0RdIIwehJWIOGwMEEeVSFoIsAhH8FL1uSiUq7g1yM2/CK0xKhY/XqdViOw975NSqDyQErMz4DIHmNxeNQGNFxqwmL0oaC8NTTmF4yikUuZ24pUGEydpoZhZ2ZGTy2boNZQ9KEB4QLhAS/vvT7ySYw7iw1ylYTLWbh8nl9rBo0y7SMnOJDLMytHt7osNVBFeA/WlZPPzcV+zcm46uCYQQuD0G8bHhPD7lAnp3q784RqFEx6hR9i9d5b5ReJzrKMi4yisuSm6s0kjDWfAGmghmN4IVjpvRMIxCiorn4zHS0bVEwsLORRPlv7istuHEJS2kqOA9HMXfgyxGN3chzD4Ri21EtXf21CeG9LArf7lvVqQiJAb7C9fh8BRgDWHGXUVZwkzVy8fjj61H0/llx06KXW7ax8cxolMHrKba/XqavWETeklcEAAk6EVeMeLNDgXSA498/TMfLFvLuxMvJS688sBywfD18o38e84icgqLS2LaSMy6xlVn9ubuMWeeNLMBUkrWbdzP4iVbKSx20bJ5LAP6t2PKk5+Tk+vNJO4xJKUzp1k5hUx54gtmTruaTu2a/o4l5VOiREmNkNJJYeb1IAson9dFIqVXlfgXJjp62MUIoXmz/OZPJzv3P0hZQMlXJEJEEht1P5ERN5R7ItVNrYmIfpSI6IYRjCxYHJ4ilmXOY2nGj2S6whGAVbgI152Y/GxpcxnFSpQ0QbKKipjy9ff8tnuPL3S42zCIslr513nnMqpL7YUQP5RXNtmdVoxv1bD0k1X6/46jGdzx6Td8fMMVNe736+UbeeTjn3zvS3PguDwGHyxYTU5hMU9c3fQj4WZmFfD3J2ezaUsaeokIk4bktY8WIU2CilIDGYYEDN7+bAnPPHhx/RqsCAknhzyvI9zFPyCNo/hLNCeReD9pFckSDTBjibgJgOzcF8jK+VeJIPHWBpAyj8ycR8jNn17b5oeEAnce07c/zPdpH5DpPAwIJIJiaSbDHY7DKK+TLZqdMFPw0UcVjQOH2811s2bzx569gPdmXerjkedwcPdX3/HL9p211l9sWBiUCnsPaIb/BwaPIVm99yDr9h+qUZ9Ot5vn5yz0e14CXy3fxJYDR/2WaQq43R7u/cdnbNnm/X16PAYej4EhJYZGhYKkFMOQ/L5yBzl5RfVkbejQShxda/Jq7ChRUgPcjt8InJkXDDSgdKrbhG9ySkRji/8QzdQBt+cwOXkvBWwnK+dZPEbwOW4aKl/uf42jjgMV5Izx3h6yPWEYUhx3VKN7zPnoQk3qNTV+2LKNjYePHFtOOY7SI8/8ughZSXbdYLmga2c8JaJH81SeoEHXNOZt3l6jPhdt3EVuoSNgGV0TzFm2IWCZxs7iP7axc/fRkqWZqiOldymnqVO6fFOTV2NHfdPXBOmuvAwamv0GTOZ2GM5VIAS6uT962GhfvJGCgs+p/CvSTUHhl0RFTKqp1SEj23mUjbnL/SaxK12yKjLMhOtOBDoRpnj6x9d8Cl3R8Ph83Uaff0VFSGBnZhYbDh2mR/NksvOL2HEwA00TdGmVRJilart9ejVPZnDrVizduy8ooSOAIlcQzuoBOJCZG3CM4J2VOZiZW6N+Gjo//bIRTRMlyzHVIzqy6TsFK58SJUpqhG7piavof5WUcmOy9sFsGwF2b5I2t5HD4dw3OJr/IS5PGgIdCxq2gCGGTbjde8l17qTAdQCzFkGcrQdaLcwguAwnm3KXsC1vFR7popmtDX1izyXanFDtNrOcOewq2I8mNDpGtCHcFMbOgk0BBMkxHNJEOC7aRpzGsOS7sJtiqmWDlJI/Mw9wqCiXKHMY/RNbYdZqd0dFMKw9nMb7G9aw8tABdKFxZmprru3Wm45x/n+/Ukr+OpLOobw8YsLC6JWSjNZIdrkEy8Hc3IA361K2Hclg1vdr+XHFFt9Mh91q5vIhvbh17EAs5uA+A0IIXr3oAm6f8w1/bN9XqRO6xzBoEx9cHiN/RIZZKx2jrgkibA0jHk1dkZlV4FeQCA9IXR5bWjsBTROc2i2V2OhjPmVul5sVP6zl8O6jhMfYOf2CvkTGNq2MwScrSpTUAHPYJRTnPA04qHimQ0NoiZisw3xHXJ4jbD18GQ73Xkp9USRuHHhvxpF4MFe4LuhhV/48dmZ84zti0+PpGnsD7aPGVXtbZlrRTj7a8wT57qySrbmSv3KXsfDIp4xInsTAhLFVai/TmcNbOz9nacZaX4AtszAxrNkgekYH8wUviLOkckO7R4gyJ1VjRF5+ObiVaX/+xJ6CY0tecVY7d54yhKvb9a23bawvLv+Nl1ctLbPrY29uNh9sWMszQ0dyRdce5er8tmsPz/yyiC1Hj2URbh4Zwd1nDuLSnt3qxe76ID7czr7snEpl6qtf/EZeelGZqf9Ch4sP5q1i897DvHLXxZj14MRmpNXKe+MuZfGuPUx+f05AwWDWdcb07BJUu/4Y2r0d/yoJ0OYPjyEZ2af2HHobIokJkWzdcbhCYSLcEqkL7xqNn8/l9eOOZfP+5ePFTJ/yLjlHcxGaQBoSs9XEhXecz43TxqPX8lbu+kQT3ldN6jd2lE9JDRBaFGGxL5S8O/FXqQMmwmJfRYhjH5I9GfficO+jvHOs92rKkzoVP1AYHHSWTdxW7MlgTfpzbMj8v2rZn+/O5r3dj1DgzgFKA5ZJJAYSyY+H3mJ99qKg28t25vHAn8+zNOPPMhE/XdLNT4cW89XBpZW2oaHRKbJfjQTJD/s3ceuSWew9TpAAZDoKeXzN90zfvLjabVeFr7Zt5uVV3jEf7zfhkd75ogcX/MiqQwfK1Jm/bQc3fPYlW48TJABpefk8OPcn3ly2ss7tri8u7ta1UkESrpvJTS+s0BfBkJLlf+3juz82V6lfIQRntWvD388fGrDc/SPPIjqsZksGcRF2Lh/U09+9Fl0TdGyewOCubWrUT0Pn/HO7+58pATSn9M0E6rrm251js5p58m9j6XWKNxXH/I8WM+2al8k56l3ukiVtuhxuvnjxG164aUYdj6Ru0WroT9IUsgQrUVJDzGFjsMd/jG45PriXwGQdSnjCl5isA3xHi107yS1eiP8or94PpfOEP4uUkOWxUSwrfgL4K/sdcp27qmz7qswfcXgKAsYJWXDkk6AdDWftm0umMwejgvYMJFvyDhNpSkYLcNkZGAyIHxFUfxXh9Lh5dPVcjkU6KM/LmxZysDCn2n0Eg5SSGauXBVwi0ITgzT9X+d67PB4e/n4eUvpf5Hp+wW8cysuvVVtDxYXdutIiKhI9wKyVdtRDgEkGhIBZC9ZWq//xA3oz7eIRJEWW3WqeGBHO0xeN4JoBvavV7on87eKzOK9PZ8ArQgDfDbhtszhmTL4YXWvaX8Wn929Pty4paH4e5YWEB24eweNTL2D0Od05f2g3/nbzuXz91q0MGdARAJfTxfR73vHfiYR57y1k+5qqfxcqGg5q+aYWMFkHY7IOxvAcQhrZCC0RTY8vVy7f8UdQ7bmk17+kNEJrnrSw0x3jt7xAZ2ful/ROqFoU1z+zF1Tq45HhPMgRxx6a2doELOfwOPnlyB8VCpJjdsLh4mjirfk4PIVlypYmoRvdfCIJ1uZVGUYZ5qdtJdsZeOugEILPd63h7m5Dq91PZRwpLOCvzPSAZTxS8vPuHUgpEULwy/adZBZWvu3xi3UbuGPw6bVlasgIt1j48KrLueHzL9mZmeW9MR8nyG489VQ+/XxVwDakhB0HM6ptw8W9uzG2Z1dW7N5PekEhCeF2+rdpWasiwazrPDNhFNcMPZU5SzdyMDOX6HAbI/t04sxT2jZ5QQLe2Y/nnricJ577mmUrd6Fp3pg0Ho+BxWLi9pvOZvTIngAMG1zxktnyuWvIzcir8JyvH5PG92/N585Xb6z1MdQHGjWbKWgKV1LIRcn06dN5/vnnSUtLo1u3brz00kuceeaZfssvXLiQqVOnsnHjRlJSUrj//vuZPHlyPVrsH01PBj3Z73kpDUp3mPhHoOuJ2Czt0fVkcmUSW7K/DNivxEOuc0eV7S32BPfEXRREuXRnFk4j8E4FCewvyuGf3Z7h58Of8Wf27xgls0bNbW05p9kldI+u2c12V14GutDwyACP19Jbri4pdgezMwtchscXTXR7eqYvQVwgtqdn1tzABkJqTDTf3zCBxbv2MH/7DordbtrFxXFZj244ilyVihIgaH8Sf+iaxunt6j4bdfdWyXRv5f/7oakTEW7luccvZ9eedBb/sZXCQictUmIZdlYX7PbKHX0P7TpS6Q4ej9vg0O7GG/NFFwTY7BBc/cZOSEXJrFmzuOeee5g+fTqDBw9m5syZnH/++WzatIlWrcp/SezatYtRo0Zx00038eGHH/L7779z2223kZiYyKWXXhqCEVQNu6UnlW/91YgJv5rkmHsByM/9CggsSkCgi6p770ebEyn05FVqU7Q5sdK2rFpwYcfNmol4azJXtLqLC1vcQI4rE6sWRoyl+jt9jsemmytdbhJCYK/lMOkn0iw8ArvJTKHbv1ATQKuoGN9Uvs1kCsJ2b7mmhK5pDG3flqHt25Y5LsMlLROjOXDUvzOsrgnO6tnWz1lFQ6Rt6wTatq765z08JrzSLcWarhERUzupARShIaSzPS+++CI33HADN954I127duWll14iNTWVGTMqdlZ67bXXaNWqFS+99BJdu3blxhtvZNKkSfz73/+uZ8urR7i1F2HmbgQOuCZIiLja9y7ZPojK/0ySlPAhVbanb9xIAgkSgUZrezdiLZXnnIi3xJAa1hwRMKi+xmlxPX3vbXo4zWyptSZIAIaldCrjZFsRHmlwbkrnWuuzImwmE+O6dg/oLwEwoXsf389nd2hb6fZRjyE5p0O7WrGxoSOEYOKIfgH/moYhuWrYqfVmkyJ0DBzTF5O5kmCVHoMhlw8KWKYhoyNq/GrshEyUOJ1OVq1axYgRZZ0aR4wYwZIlSyqs88cff5QrP3LkSFauXInLT5Ajh8NBbm5umVcoaRP/EpqwU16YeP8UreL+hcV0zKcizJRIq4iRCD9/KoGGVYslNaLqzqE9Y4aSZG1dYdui5N+5yROCaksIwSUthwf0UTGQjEk5u8p2VoXWEXGcm9LZb0wPXQjaRMQxpHmHOrUD4M6+A0mOqNiRUxOCnknJjO92TKS1i49jSLs2foWMLgQto6M4p+PJIUoALjmzB1cM7QUccxIt/VkI+Ps159KzXfV9kBSNh+iEKC6YPMLvdn7dpNGqawsGjG68IlWrhVdVWbRoEWPGjCElJQUhBHPmzKnpMGpEyERJeno6Ho+HZs3KPoU3a9aMQ4cqzjdx6NChCsu73W7S0yt2Kpw2bRrR0dG+V2pqaFNgh1k60yX5O2LtYzl+9Szc0pv2ie+SEDG+XJ2+iQ8Tb+tV8u74P5nArEVyVsr/YdLCytWrDItm5bq2/6J9RO+S1oRPoESa47m2zWOk2oOP0zAk8TQubTmixMpjdmpoCAS3dxhPp8i6n2p/tv9Yesa28PZd8gVW+jXWLCyKt868Gr0esijHh9n58pLxnNeuUxmRZNF0rurak4/HjsNmKhuV9N9jzqdzUmIZ20vtjw+38/YVl2A6CRwjSxFCcP+VZzPjnks4s2c7EqLDaRYbwdhB3fjkH9dwyZnl47womi63/HsCQ68cDHhFCHiXbABadGzOMz8+0qjjlISCgoICevXqxauvvhpqUwAQsrYSS1SRgwcP0qJFC5YsWcLAgQN9x5966ik++OAD/vrrr3J1OnXqxPXXX89DDz3kO/b7779zxhlnkJaWRnJyeScyh8OBw3Es90Rubi6pqank5OQQFRVVy6OqGh4jD5fnCLoWgVkPvERiSDcHCn5lZ+5s8l37sGiRpEacR9uosVj1mkWdBEh3HGB7/mo8hoskWxvaR/RGq+aN+6/cnXx/aBFbcneiC53esV05L/ksUu315+TnNgzmp23h851rOFCYQ5zVzthWPRjTqnud+5NUxJHCAjYePYyuafRKSiba6j/+hcPt5vu/tvLZnxs4kJNLnD2MC7t15dIe3Yhs4pE/FYpg2LJiO9+/9QuHdx8hIjacIeMGMXBMvzoRJLm5uURHR9fpPaO0jx1/JRMZWf2Hjrw8g/ZdDlXbViEEX375JRdddFG1bagpIfOYS0hIQNf1crMiR44cKTcbUkpycnKF5U0mE/Hx5bfgAlitVqzWhvlFrmuR6FpkUGU1YSI1YjipEcPrxJYEawsSrC1qpa0uUe3oEhXaJQaTpjGyRVdGtugaUjtKSbKHk9Q6uN+J1WTiou6ncFH3U+rYKoWicdK5fwc696/7Jdj6RkOg1cAvpCZ1Gwohmwe2WCz07duXefPmlTk+b948Bg2q2FFp4MCB5cr/9NNP9OvXD7O5asm5FAqFQqFoSGg1dHItFSUn+lEev1rQ0Anp4vTUqVN58803efvtt9m8eTNTpkxh7969vrgjDz30EBMmHHO0nDx5Mnv27GHq1Kls3ryZt99+m7feeou//e1voRqCQqFQKBQNitTU1DK+lNOmTQu1SUET0oAHV1xxBRkZGTzxxBOkpaXRvXt35s6dS+vWrQFIS0tj7969vvJt27Zl7ty5TJkyhf/7v/8jJSWFl19+uVHEKFEoFAqFIhC1tXyzb9++Mj4lDdWFoSJC5ugaKurDaUmhUCgUTYP6dHQ9uKUlUTVwdM3NM0jpvF85uioUCoVCoWh85Ofns337dt/7Xbt2sXbtWuLi4iqMrF7XKFGiUCgUCkUDQCv5V/36VWflypWcffaxoJZTp3oTu06cOJF333232rZUFyVKFAqFQqFoAIRiS/DQoUMrzblVn5w8oSEVCoVCoVA0aNRMiUKhUCgUDQBdaDVKgaE3/thpSpQoFAqFQtEQ8C7f1MSnpOEsw1SXk06UlK6dhTpbsEKhUCgaPqX3ivrwu8jNM0JavyFw0omSvLw8gJBnC1YoFApF4yEvL4/o6Og6adtisZCcnEzrvrtr3FZycjIWS/0nHa0tTrrgaYZhcPDgQSIjIxGiCSzAnUBpFuQTI/o1RdRYmyZqrE2TxjpWKSV5eXmkpKSgaXW3N6S4uBin01njdiwWCzab/yzkDZ2TbqZE0zRatmwZajPqnKioqEb1wa8JaqxNEzXWpkljHGtdzZAcj81ma9RiorZQW4IVCoVCoVA0CJQoUSgUCoVC0SBQoqSJYbVa+ec//9moskJWFzXWpokaa9PkZBqrovqcdI6uCoVCoVAoGiZqpkShUCgUCkWDQIkShUKhUCgUDQIlShQKhUKhUDQIlChpAkybNg0hBPfcc4/vmJSSxx57jJSUFMLCwhg6dCgbN24MnZE14MCBA1xzzTXEx8djt9vp3bs3q1at8p1vKmN1u9384x//oG3btoSFhdGuXTueeOIJDONY6OjGOtZFixYxZswYUlJSEEIwZ86cMueDGZfD4eDOO+8kISGB8PBwxo4dy/79++txFMERaKwul4sHHniAHj16EB4eTkpKChMmTODgwYNl2mgKYz2RW265BSEEL730UpnjjWWsivpBiZJGzooVK3j99dfp2bNnmePPPfccL774Iq+++iorVqwgOTmZ4cOH+8LsNxaysrIYPHgwZrOZ77//nk2bNvHCCy8QExPjK9NUxvrss8/y2muv8eqrr7J582aee+45nn/+eV555RVfmcY61oKCAnr16sWrr75a4flgxnXPPffw5Zdf8umnn/Lbb7+Rn5/PBRdcgMfjqa9hBEWgsRYWFrJ69WoeeeQRVq9ezezZs9m6dStjx44tU64pjPV45syZw7Jly0hJSSl3rrGMVVFPSEWjJS8vT3bs2FHOmzdPDhkyRN59991SSikNw5DJycnymWee8ZUtLi6W0dHR8rXXXguRtdXjgQcekGeccYbf801prKNHj5aTJk0qc+ySSy6R11xzjZSy6YwVkF9++aXvfTDjys7OlmazWX766ae+MgcOHJCapskffvih3myvKieOtSKWL18uAblnzx4pZdMb6/79+2WLFi3khg0bZOvWreV//vMf37nGOlZF3aFmShoxt99+O6NHj+bcc88tc3zXrl0cOnSIESNG+I5ZrVaGDBnCkiVL6tvMGvH111/Tr18/Lr/8cpKSkujTpw9vvPGG73xTGusZZ5zB/Pnz2bp1KwB//vknv/32G6NGjQKa1liPJ5hxrVq1CpfLVaZMSkoK3bt3b9RjB8jJyUEI4Zv9a0pjNQyDa6+9lvvuu49u3bqVO9+UxqqoHU663DdNhU8//ZTVq1ezYsWKcucOHToEQLNmzcocb9asGXv27KkX+2qLnTt3MmPGDKZOncrDDz/M8uXLueuuu7BarUyYMKFJjfWBBx4gJyeHLl26oOs6Ho+Hp556iquuugpoWn/X4wlmXIcOHcJisRAbG1uuTGn9xkhxcTEPPvggV199tS8fTFMa67PPPovJZOKuu+6q8HxTGquidlCipBGyb98+7r77bn766aeACZxOzIIspWx0mZENw6Bfv348/fTTAPTp04eNGzcyY8YMJkyY4CvXFMY6a9YsPvzwQz7++GO6devG2rVrueeee0hJSWHixIm+ck1hrBVRnXE15rG7XC6uvPJKDMNg+vTplZZvbGNdtWoV//3vf1m9enWV7W5sY1XUHmr5phGyatUqjhw5Qt++fTGZTJhMJhYuXMjLL7+MyWTyPXGe+KRx5MiRck+jDZ3mzZtzyimnlDnWtWtX9u7dC0BycjLQNMZ633338eCDD3LllVfSo0cPrr32WqZMmcK0adOApjXW4wlmXMnJyTidTrKysvyWaUy4XC7GjRvHrl27mDdvXpmsuU1lrIsXL+bIkSO0atXK9z21Z88e7r33Xtq0aQM0nbEqag8lShohw4YNY/369axdu9b36tevH+PHj2ft2rW0a9eO5ORk5s2b56vjdDpZuHAhgwYNCqHlVWfw4MFs2bKlzLGtW7fSunVrANq2bdtkxlpYWIimlf1I6rru2xLclMZ6PMGMq2/fvpjN5jJl0tLS2LBhQ6Mbe6kg2bZtGz///DPx8fFlzjeVsV577bWsW7euzPdUSkoK9913Hz/++CPQdMaqqEVC6GSrqEWO330jpZTPPPOMjI6OlrNnz5br16+XV111lWzevLnMzc0NnZHVYPny5dJkMsmnnnpKbtu2TX700UfSbrfLDz/80FemqYx14sSJskWLFvLbb7+Vu3btkrNnz5YJCQny/vvv95VprGPNy8uTa9askWvWrJGAfPHFF+WaNWt8O06CGdfkyZNly5Yt5c8//yxXr14tzznnHNmrVy/pdrtDNawKCTRWl8slx44dK1u2bCnXrl0r09LSfC+Hw+FroymMtSJO3H0jZeMZq6J+UKKkiXCiKDEMQ/7zn/+UycnJ0mq1yrPOOkuuX78+dAbWgG+++UZ2795dWq1W2aVLF/n666+XOd9Uxpqbmyvvvvtu2apVK2mz2WS7du3k3//+9zI3q8Y61l9//VUC5V4TJ06UUgY3rqKiInnHHXfIuLg4GRYWJi+44AK5d+/eEIwmMIHGumvXrgrPAfLXX3/1tdEUxloRFYmSxjJWRf2gsgQrFAqFQqFoECifEoVCoVAoFA0CJUoUCoVCoVA0CJQoUSgUCoVC0SBQokShUCgUCkWDQIkShUKhUCgUDQIlShQKhUKhUDQIlChRKBQKhULRIFCiRKFQKBQKRYNAiRLFSUtGRgZJSUns3r071KYoguCxxx6jd+/eNWpj9+7dCCFYu3at79jvv/9Ojx49MJvNXHTRRaxfv56WLVtSUFBQM4MVCkWVUaJEcdIybdo0xowZ48tYWnrDKn3FxsZy1llnsXDhwtAaWgPeffddYmJiQm1Gg2bq1Kn07t2bXbt28e6779KjRw9OO+00/vOf/4TaNIXipEOJEsVJSVFREW+99RY33nhjuXM///wzaWlpLFy4kKioKEaNGsWuXbuq1Y/T6aypqQ0Cj8fjy1bc1NixYwfnnHMOLVu29Am466+/nhkzZuDxeEJrnEJxkqFEieKk5Pvvv8dkMjFw4MBy5+Lj40lOTqZnz57MnDmTwsJCfvrpJzIyMrjqqqto2bIldrudHj168Mknn5SpO3ToUO644w6mTp1KQkICw4cPB+DFF1+kR48ehIeHk5qaym233UZ+fr6vXumMxrfffkvnzp2x2+1cdtllFBQU8N5779GmTRtiY2O58847y9wonU4n999/Py1atCA8PJwBAwawYMECABYsWMD1119PTk6Ob/bnscceq7TeifaccsopWK1W9uzZw4IFCzjttNMIDw8nJiaGwYMHs2fPnqB+5zNnzqRFixblxM3YsWOZOHFiUG0AfPDBB7Rp04bo6GiuvPJK8vLyfOd++OEHzjjjDGJiYoiPj+eCCy5gx44dFbZTOjOWkZHBpEmTEELw7rvvAjBy5EgyMjIa9SyZQtEYUaJEcVKyaNEi+vXrV2k5u90OgMvlori4mL59+/Ltt9+yYcMGbr75Zq699lqWLVtWps57772HyWTi999/Z+bMmQBomsbLL7/Mhg0beO+99/jll1+4//77y9QrLCzk5Zdf5tNPP+WHH35gwYIFXHLJJcydO5e5c+fywQcf8Prrr/PFF1/46lx//fX8/vvvfPrpp6xbt47LL7+c8847j23btjFo0CBeeukloqKiSEtLIy0tjb/97W+V1jvenmnTpvHmm2+yceNG4uLiuOiiixgyZAjr1q3jjz/+4Oabb0YIEdTv/PLLLyc9PZ1ff/3VdywrK4sff/yR8ePHB9XGjh07mDNnDt9++y3ffvstCxcu5JlnnvGdLygoYOrUqaxYsYL58+ejaRoXX3xxhbM8qamppKWlERUVxUsvvURaWhpXXHEFABaLhV69erF48eKg7FIoFLVEqNMUKxSh4MILL5STJk0qc6w0rfyaNWuklFLm5+fLW265Req6LtetW1dhO6NGjZL33nuv7/2QIUNk7969K+3/s88+k/Hx8b7377zzjgTk9u3bfcduueUWabfbZV5enu/YyJEj5S233CKllHL79u1SCCEPHDhQpu1hw4bJhx56yNdudHR0mfPB1gPk2rVrfeczMjIkIBcsWFDp+PwxduzYMr/3mTNnyuTkZOl2uyut+89//lPa7XaZm5vrO3bffffJAQMG+K1z5MgRCcj169dLKcv/jaWUMjo6Wr7zzjvl6l588cXyuuuuC2JUCoWitjCFUhApFKGiqKgIm81W4blBgwahaRqFhYU0b97c5/zo8Xh45plnmDVrFgcOHMDhcOBwOAgPDy9Tv6IZmF9//ZWnn36aTZs2kZubi9vtpri4mIKCAl99u91O+/btfXWaNWtGmzZtjpkv/gAABLVJREFUiIiIKHPsyJEjAKxevRopJZ06dSrTl8PhID4+3u/Yg61nsVjo2bOn731cXBzXXXcdI0eOZPjw4Zx77rmMGzeO5s2b++3rRMaPH8/NN9/M9OnTsVqtfPTRR1x55ZXouh5U/TZt2hAZGel737x5c9/vA7wzKY888ghLly4lPT3dN0Oyd+9eunfvHrSdAGFhYRQWFlapjkKhqBlKlChOShISEsjKyqrw3KxZszjllFN8fgmlvPDCC/znP//hpZde8vmH3HPPPeWcWU8UKXv27GHUqFFMnjyZJ598kri4OH777TduuOEGXC6Xr5zZbC5TTwhR4bHSG61hGOi6zqpVq8rd1I8XMicSbL2wsLBySzPvvPMOd911Fz/88AOzZs3iH//4B/PmzeP000/329/xjBkzBsMw+O677+jfvz+LFy/mxRdfDKouVPw7On5pZsyYMaSmpvLGG2+QkpKCYRh07969Wg7HmZmZZUSiQqGoe5QoUZyU9OnThw8//LDCc6mpqRXejBYvXsyFF17INddcA3hv7tu2baNr164B+1q5ciVut5sXXngBTfO6cX322Wc1HIF3DB6PhyNHjnDmmWdWWMZisZTbQRJMvcr67dOnDw899BADBw7k448/DlqUhIWFcckll/DRRx+xfft2OnXqRN++fatsQ0VkZGSwefNmZs6c6RvXb7/9Vu32NmzYwGWXXVYrtikUiuBQjq6Kk5KRI0eyceNGv7MlFdGhQwfmzZvHkiVL2Lx5M7fccguHDh2qtF779u1xu9288sor7Ny5kw8++IDXXnutJuYD0KlTJ8aPH8+ECROYPXs2u3btYsWKFTz77LPMnTsX8C535OfnM3/+fNLT0yksLAyqXkXs2rWLhx56iD/++IM9e/bw008/sXXr1kpF2YmMHz+e7777jrffftsn8GqD2NhY4uPjef3119m+fTu//PILU6dOrVZbu3fv5sCBA5x77rm1Zp9CoagcJUoUJyU9evSgX79+VZqxeOSRRzj11FMZOXIkQ4cOJTk5mYsuuqjSer179+bFF1/k2WefpXv37nz00UdMmzatBtYf45133mHChAnce++9dO7cmbFjx7Js2TJSU1MBr3/M5MmTueKKK0hMTOS5554Lql5F2O12/vrrLy699FI6derEzTffzB133MEtt9wCHNtie/zW4oo455xziIuLY8uWLVx99dW18nsA7w6nTz/9lFWrVtG9e3emTJnC888/X622PvnkE0aMGEHr1q1rzT6FQlE5QkopQ22EQhEK5s6dy9/+9jc2bNjgW1ZRVJ8FCxZw8cUXs3PnTmJjY0NtTrVxOBx07NiRTz75hMGDB4faHIXipEL5lChOWkaNGsW2bds4cOBAwBkCRXD88MMPPPzww41akIDXMfnvf/+7EiQKRQhQMyUKhaJB0K1bN7/RYWfOnBl0gDWFQtF4UaJEoVA0CPbs2VNmi/TxNGvWrEx8EoVC0TRRokShUCgUCkWDQHn3KRQKhUKhaBAoUaJQKBQKhaJBoESJQqFQKBSKBoESJQqFQqFQKBoESpQoFAqFQqFoEChRolAoFAqFokGgRIlCoVAoFIoGgRIlCoVCoVAoGgT/D6gHnKLc+colAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -3012,16 +2921,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'scale': 0.9937435057717706, 'v_half': 52.25560598796059}" + "{'scale': 1.0, 'v_half': 52.39275573380861}" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -3045,7 +2954,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -3054,13 +2963,13 @@ "" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3088,7 +2997,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -3097,13 +3006,13 @@ "" ] }, - "execution_count": 43, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3113,7 +3022,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3145,7 +3054,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -3196,7 +3105,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.641194e+09\n", + " 1.629343e+09\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3205,17 +3114,17 @@ " \n", " \n", " 2010236N12341\n", - " 2.382896e+07\n", + " 2.362421e+07\n", " 0.000000e+00\n", - " 6.319901e+07\n", + " 6.273895e+07\n", " 0.000000\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 7.558366e+07\n", - " 1.253981e+07\n", + " 7.489799e+07\n", + " 1.243066e+07\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3230,7 +3139,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 9.292543e+07\n", + " 9.210669e+07\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3250,26 +3159,26 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 6.727897e+06\n", - " 4.578844e+06\n", - " 6.995127e+05\n", + " 6.668112e+06\n", + " 4.537917e+06\n", + " 6.931670e+05\n", " \n", " \n", " 2011233N15301\n", " 0.000000e+00\n", - " 1.230474e+09\n", - " 2.364701e+07\n", + " 1.221974e+09\n", + " 2.344844e+07\n", " 0.000000\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 7.109156e+04\n", + " 7.044665e+04\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 7.094676e+08\n", + " 7.033207e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.383507e+08\n", + " 1.374375e+08\n", " \n", " \n", " 2011279N10257\n", @@ -3281,7 +3190,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 3.718903e+06\n", + " 3.687471e+06\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3298,7 +3207,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.577538e+08\n", + " 1.564085e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3315,7 +3224,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.901566e+08\n", + " 1.890366e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3325,13 +3234,13 @@ " \n", " 2012296N14283\n", " 0.000000e+00\n", - " 1.323275e+08\n", + " 1.311881e+08\n", " 0.000000e+00\n", " 0.000000\n", - " 2.751122e+09\n", + " 2.742997e+09\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 3.101404e+09\n", + " 3.077018e+09\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3349,7 +3258,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.352591e+10\n", + " 1.353240e+10\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3366,7 +3275,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 9.440247e+08\n", + " 9.395908e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3378,7 +3287,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 227605.609803\n", + " 225671.780693\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3393,7 +3302,7 @@ " \n", " 2015270N27291\n", " 0.000000e+00\n", - " 8.433712e+05\n", + " 8.412341e+05\n", " 0.000000e+00\n", " 0.000000\n", " 0.000000e+00\n", @@ -3417,7 +3326,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 3.127676e+09\n", + " 3.107738e+09\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3434,7 +3343,7 @@ " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 9.101261e+07\n", + " 9.019579e+07\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", @@ -3443,37 +3352,37 @@ " \n", " \n", " 2017242N16333\n", - " 3.750206e+08\n", - " 1.354638e+06\n", - " 4.684316e+08\n", + " 3.732403e+08\n", + " 1.348337e+06\n", + " 4.696049e+08\n", " 0.000000\n", - " 3.369390e+09\n", + " 3.351103e+09\n", " 0.000000e+00\n", - " 2.693964e+07\n", + " 2.670109e+07\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 1.172531e+10\n", - " 4.040075e+08\n", + " 1.164926e+10\n", + " 4.024997e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 8.060133e+08\n", + " 8.060703e+08\n", " \n", " \n", " 2017260N12310\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 3.413228e+07\n", + " 3.385997e+07\n", " 0.000000\n", " 0.000000e+00\n", - " 6.646546e+08\n", - " 1.189164e+08\n", + " 6.658893e+08\n", + " 1.178713e+08\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 8.918857e+10\n", + " 8.941185e+10\n", " 0.000000e+00\n", " 0.000000e+00\n", " 0.000000e+00\n", - " 9.235309e+07\n", + " 9.182423e+07\n", " \n", " \n", "\n", @@ -3482,67 +3391,67 @@ "text/plain": [ " 28 44 92 132 \\\n", "2010176N16278 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", - "2010236N12341 2.382896e+07 0.000000e+00 6.319901e+07 0.000000 \n", + "2010236N12341 2.362421e+07 0.000000e+00 6.273895e+07 0.000000 \n", "2010257N16282 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", - "2011233N15301 0.000000e+00 1.230474e+09 2.364701e+07 0.000000 \n", + "2011233N15301 0.000000e+00 1.221974e+09 2.344844e+07 0.000000 \n", "2011279N10257 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", "2012215N12313 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", "2012166N09269 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", - "2012296N14283 0.000000e+00 1.323275e+08 0.000000e+00 0.000000 \n", + "2012296N14283 0.000000e+00 1.311881e+08 0.000000e+00 0.000000 \n", "2014253N13260 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", "2015293N13266 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", - "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 227605.609803 \n", - "2015270N27291 0.000000e+00 8.433712e+05 0.000000e+00 0.000000 \n", + "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 225671.780693 \n", + "2015270N27291 0.000000e+00 8.412341e+05 0.000000e+00 0.000000 \n", "2016248N15255 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", "2017219N16279 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", - "2017242N16333 3.750206e+08 1.354638e+06 4.684316e+08 0.000000 \n", - "2017260N12310 0.000000e+00 0.000000e+00 3.413228e+07 0.000000 \n", + "2017242N16333 3.732403e+08 1.348337e+06 4.696049e+08 0.000000 \n", + "2017260N12310 0.000000e+00 0.000000e+00 3.385997e+07 0.000000 \n", "\n", " 192 212 214 388 \\\n", "2010176N16278 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2010236N12341 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2010257N16282 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2011233N15301 0.000000e+00 0.000000e+00 7.109156e+04 0.000000e+00 \n", + "2011233N15301 0.000000e+00 0.000000e+00 7.044665e+04 0.000000e+00 \n", "2011279N10257 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2012215N12313 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2012166N09269 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2012296N14283 2.751122e+09 0.000000e+00 0.000000e+00 3.101404e+09 \n", + "2012296N14283 2.742997e+09 0.000000e+00 0.000000e+00 3.077018e+09 \n", "2014253N13260 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2015293N13266 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2015270N27291 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2016248N15255 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2017219N16279 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2017242N16333 3.369390e+09 0.000000e+00 2.693964e+07 0.000000e+00 \n", - "2017260N12310 0.000000e+00 6.646546e+08 1.189164e+08 0.000000e+00 \n", + "2017242N16333 3.351103e+09 0.000000e+00 2.670109e+07 0.000000e+00 \n", + "2017260N12310 0.000000e+00 6.658893e+08 1.178713e+08 0.000000e+00 \n", "\n", " 484 630 659 662 \\\n", - "2010176N16278 1.641194e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2010236N12341 0.000000e+00 7.558366e+07 1.253981e+07 0.000000e+00 \n", - "2010257N16282 9.292543e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 6.727897e+06 \n", - "2011233N15301 0.000000e+00 7.094676e+08 0.000000e+00 0.000000e+00 \n", - "2011279N10257 3.718903e+06 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2012215N12313 1.577538e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2012166N09269 1.901566e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010176N16278 1.629343e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010236N12341 0.000000e+00 7.489799e+07 1.243066e+07 0.000000e+00 \n", + "2010257N16282 9.210669e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 6.668112e+06 \n", + "2011233N15301 0.000000e+00 7.033207e+08 0.000000e+00 0.000000e+00 \n", + "2011279N10257 3.687471e+06 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012215N12313 1.564085e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012166N09269 1.890366e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2012296N14283 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2014253N13260 1.352591e+10 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2015293N13266 9.440247e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2014253N13260 1.353240e+10 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015293N13266 9.395908e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", "2015270N27291 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2016248N15255 3.127676e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2017219N16279 9.101261e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2017242N16333 0.000000e+00 1.172531e+10 4.040075e+08 0.000000e+00 \n", - "2017260N12310 0.000000e+00 8.918857e+10 0.000000e+00 0.000000e+00 \n", + "2016248N15255 3.107738e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017219N16279 9.019579e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017242N16333 0.000000e+00 1.164926e+10 4.024997e+08 0.000000e+00 \n", + "2017260N12310 0.000000e+00 8.941185e+10 0.000000e+00 0.000000e+00 \n", "\n", " 670 796 \n", "2010176N16278 0.000000e+00 0.000000e+00 \n", "2010236N12341 0.000000e+00 0.000000e+00 \n", "2010257N16282 0.000000e+00 0.000000e+00 \n", - "2010302N09306 4.578844e+06 6.995127e+05 \n", - "2011233N15301 0.000000e+00 1.383507e+08 \n", + "2010302N09306 4.537917e+06 6.931670e+05 \n", + "2011233N15301 0.000000e+00 1.374375e+08 \n", "2011279N10257 0.000000e+00 0.000000e+00 \n", "2012215N12313 0.000000e+00 0.000000e+00 \n", "2012166N09269 0.000000e+00 0.000000e+00 \n", @@ -3553,11 +3462,11 @@ "2015270N27291 0.000000e+00 0.000000e+00 \n", "2016248N15255 0.000000e+00 0.000000e+00 \n", "2017219N16279 0.000000e+00 0.000000e+00 \n", - "2017242N16333 0.000000e+00 8.060133e+08 \n", - "2017260N12310 0.000000e+00 9.235309e+07 " + "2017242N16333 0.000000e+00 8.060703e+08 \n", + "2017260N12310 0.000000e+00 9.182423e+07 " ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -3587,7 +3496,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -3605,7 +3514,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -3614,13 +3523,13 @@ "" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAIECAYAAADxU5FMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhXklEQVR4nO3dd3QUZfs+8Gs3vYeaQio1CUFBQA1Ir6GDCoIvRcorEMWIgiCviqGLQlQCVkCEKIiAihQjRbqGQEBI6IEgJCA1hBJCcn//4Mf+2DQCmd3J7lyfc/YcZp6w1zMzu5M7M8/M6EREQERERKQherU7QERERGRuLICIiIhIc1gAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDgsgIiIi0hxbtTtQXuXn5+Ps2bNwc3ODTqdTuztERERUCiKCa9euwdfXF3p98cd5WAAV4+zZs/D391e7G0RERPQITp8+DT8/v2LbWQAVw83NDcDdFeju7q5yb4iIiKg0srKy4O/vb/g9XhwWQMW4d9rL3d2dBRAREZGFedDwFQ6CJiIiIs1hAURERESawwKIiIiINIdjgIiIiBSUl5eH3Nxctbthtezs7GBjY1Pm92EBREREpAARQWZmJq5cuaJ2V6yep6cnvL29y3SfPqsogHr27InNmzejTZs2WL58+QPnExERKe1e8VO1alU4OzvzJromICK4ceMGzp8/DwDw8fF55PeyigJo1KhRGDx4ML755ptSzSciIlJSXl6eofipVKmS2t2xak5OTgCA8+fPo2rVqo98OswqBkG3atWqyBseFTefiIhISffG/Dg7O6vcE224t57LMtZK9QJoy5Yt6Nq1K3x9faHT6bBq1apCPzN37lwEBwfD0dERDRs2xNatW83fUSIiogfgaS/zUGI9q14AXb9+HY8//jjmzJlTZPvSpUsRHR2NCRMmYO/evWjWrBkiIyORnp5u5p4SERGRtVC9AIqMjMTkyZPRq1evIttnzZqFIUOGYOjQoQgNDUVsbCz8/f0xb948RfuRk5ODrKwsoxcRERGVzebNm6HT6R7q6rigoCDExsaarE9AOR8Effv2bSQlJWHcuHFG89u3b48dO3YomjVt2jS8//77ir4nERFR0LhfzZZ1cnrnh/4/gwYNwjfffIOXX34Zn332mVHbyJEjMW/ePAwcOBALFy5UqJflg+pHgEpy4cIF5OXlwcvLy2i+l5cXMjMzDdMdOnTA888/jzVr1sDPzw+JiYklzi/K+PHjcfXqVcPr9OnTplkoIiKicsbf3x/ff/89bt68aZh369YtfPfddwgICFCxZ6ZTrgugewoOdhIRo3nr16/Hv//+ixs3buCff/5B48aNS5xfFAcHB8OT3/kEeCIi0pInnngCAQEBWLFihWHeihUr4O/vjwYNGhjm5eTkYNSoUahatSocHR3xzDPPFDq4sGbNGtSuXRtOTk5o1aoVTp48WShvx44daN68OZycnODv749Ro0bh+vXrJlu+opTrAqhy5cqwsbExOtoD3L32v+BRIaXExcUhLCysxGKJiEjrgsb9WuyLLNNLL72EBQsWGKbnz5+PwYMHG/3M2LFj8eOPP+Kbb77Bnj17ULNmTXTo0AGXLl0CAJw+fRq9evVCp06dkJycjKFDhxYaxvL333+jQ4cO6NWrF/bv34+lS5di27ZteOWVV0y/kPcp1wWQvb09GjZsiISEBKP5CQkJaNKkiUkyo6KikJKSUuLpMiIiImvTv39/bNu2DSdPnsSpU6ewfft2/Oc//zG0X79+HfPmzcPMmTMRGRmJsLAwfPnll3BycsLXX38NAJg3bx6qV6+O2bNno06dOnjxxRcxaNAgo5yZM2eiX79+iI6ORq1atdCkSRN88sknWLRoEW7dumW25VV9EHR2djaOHTtmmE5LS0NycjIqVqyIgIAAjB49Gv3790ejRo0QERGBL774Aunp6Rg+fLiKvSYiIrIulStXRufOnfHNN99ARNC5c2dUrlzZ0H78+HHk5uaiadOmhnl2dnZ48sknkZqaCgBITU3F008/bTRMJSIiwignKSkJx44dw5IlSwzzRAT5+flIS0tDaGioqRbRiOoF0O7du9GqVSvD9OjRowHAMOK8T58+uHjxImJiYpCRkYHw8HCsWbMGgYGBJulPXFwc4uLikJeXZ5L3JyIiKq8GDx5sOBUVFxdn1CYiAEoel3vvZ0qSn5+Pl19+GaNGjSrUZs4B16oXQC1btnzgChs5ciRGjhxplv5ERUUhKioKWVlZ8PDwMEsmERFRedCxY0fcvn0bwN0rqe9Xs2ZN2NvbY9u2bejXrx+Au4+i2L17N6KjowEAYWFhhZ7osGvXLqPpJ554AgcPHkTNmjVNsxClVK7HABEREZH52NjYIDU1FampqYUeMuri4oIRI0ZgzJgxWLduHVJSUjBs2DDcuHEDQ4YMAQAMHz4cx48fx+jRo3H48GHEx8cXun/QW2+9hZ07dyIqKgrJyck4evQofv75Z7z66qvmWkwA5eAIUHnDU2BERKSkR7k5oZpKug3M9OnTkZ+fj/79++PatWto1KgR1q9fjwoVKgC4ewrrxx9/xOuvv465c+fiySefxNSpU42uJnvsscfwxx9/YMKECWjWrBlEBDVq1ECfPn1Mvmz300lpTthp0L1TYFevXuU9gYiICijpcveTjv1K/s8TryrcG/XdunULaWlphgd3k2mVtL5L+/ubp8CIiIhIc1gAERERkeawACqAd4ImIiKyfiyACuCdoImIiKwfCyAiIiLSHBZAREREpDksgIiIiEhzWAAVwEHQRERE1o8FUAEcBE1ERGT9WAARERFp2KBBg6DT6aDT6WBnZwcvLy+0a9cO8+fPR35+fqnfZ+HChfD09DRdRxXGZ4ERERGZ0kQPM2Y92mNGOnbsiAULFiAvLw/nzp3DunXr8Nprr2H58uX4+eefYWtrfeUCjwARERFpnIODA7y9vVGtWjU88cQTePvtt/HTTz9h7dq1hqe5z5o1C/Xq1YOLiwv8/f0xcuRIZGdnAwA2b96Ml156CVevXjUcTZo4cSIAYPHixWjUqBHc3Nzg7e2Nfv364fz58yot6f/HAoiIiIgKad26NR5//HGsWLECAKDX6/HJJ5/gwIED+Oabb7Bx40aMHTsWANCkSRPExsbC3d0dGRkZyMjIwJtvvgkAuH37NiZNmoR9+/Zh1apVSEtLw6BBg9RaLAPrO6ZVRnFxcYiLi0NeXp7aXSEiIlJVSEgI9u/fDwCIjo42zA8ODsakSZMwYsQIzJ07F/b29vDw8IBOp4O3t7fRewwePNjw7+rVq+OTTz7Bk08+iezsbLi6upplOYrCI0AF8CowIiKiu0QEOp0OALBp0ya0a9cO1apVg5ubGwYMGICLFy/i+vXrJb7H3r170b17dwQGBsLNzQ0tW7YEAKSnp5u6+yViAURERERFSk1NRXBwME6dOoVOnTohPDwcP/74I5KSkhAXFwcAyM3NLfb/X79+He3bt4erqysWL16MxMRErFy5EsDdU2Nq4ikwIiIiKmTjxo34+++/8frrr2P37t24c+cOPvroI+j1d4+dLFu2zOjn7e3tCw0fOXToEC5cuIDp06fD398fALB7927zLMAD8AgQERGRxuXk5CAzMxNnzpzBnj17MHXqVHTv3h1dunTBgAEDUKNGDdy5cweffvopTpw4gW+//RafffaZ0XsEBQUhOzsbGzZswIULF3Djxg0EBATA3t7e8P9+/vlnTJo0SaWlNMYCiIiISOPWrVsHHx8fBAUFoWPHjti0aRM++eQT/PTTT7CxsUH9+vUxa9YszJgxA+Hh4ViyZAmmTZtm9B5NmjTB8OHD0adPH1SpUgUffPABqlSpgoULF+KHH35AWFgYpk+fjg8//FClpTSmExFRuxPlUVZWFjw8PHD16lW4u7ur3R0ionIlaNyvxbaddOxX8n9+xJv1lWe3bt1CWloagoOD4ejoqHZ3rF5J67u0v795BKgAPgyViIjI+rEAKoCXwRMREVk/FkBERESkOSyAiIiISHNYABEREZHmsAAiIiJSCC+sNg8l1jMLICIiojKys7MDANy4cUPlnmjDvfV8b70/Cj4Kg4iIqIxsbGzg6emJ8+fPAwCcnZ0NDxEl5YgIbty4gfPnz8PT0xM2NjaP/F4sgIiIiBTg7e0NAIYiiEzH09PTsL4fFQsgIiIiBeh0Ovj4+KBq1aolPiGdysbOzq5MR37uYQFERESkIBsbG0V+QZNpcRB0AXwUBhERkfVjAVQAH4VBRERk/VgAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDgsgIiIi0hzeCJGIyJpN9Cih7ar5+kFUzvAIEBEREWkOjwARERGVM0Hjfi227eT0zmbsifXiESAiIiLSHKsogHr27IkKFSrgueeeM5q/evVq1KlTB7Vq1cJXX32lUu+IiIiovLGKAmjUqFFYtGiR0bw7d+5g9OjR2LhxI/bs2YMZM2bg0qVLKvWQiIiIyhOrKIBatWoFNzc3o3l//fUX6tati2rVqsHNzQ2dOnXC+vXrVeohERERlSeqF0BbtmxB165d4evrC51Oh1WrVhX6mblz5yI4OBiOjo5o2LAhtm7d+sD3PXv2LKpVq2aY9vPzw5kzZ5TsOhEREVko1Qug69ev4/HHH8ecOXOKbF+6dCmio6MxYcIE7N27F82aNUNkZCTS09NLfF8RKTRPp9Mp0mciIiKybKpfBh8ZGYnIyMhi22fNmoUhQ4Zg6NChAIDY2FisX78e8+bNw7Rp04r9f9WqVTM64vPPP//gqaeeKvbnc3JykJOTY5jOysp6mMUgIiIiC6L6EaCS3L59G0lJSWjfvr3R/Pbt22PHjh0l/t8nn3wSBw4cwJkzZ3Dt2jWsWbMGHTp0KPbnp02bBg8PD8PL399fkWUgIiKi8qdcF0AXLlxAXl4evLy8jOZ7eXkhMzPTMN2hQwc8//zzWLNmDfz8/JCYmAhbW1t89NFHaNWqFRo0aIAxY8agUqVKxWaNHz8eV69eNbxOnz5tsuUiIiIidal+Cqw0Co7dERGjecVd3dWtWzd069atVBkODg5wcHB49E4SERGRxSjXR4AqV64MGxsbo6M9AHD+/PlCR4WUEhcXh7CwMDRu3Ngk709ERETqK9cFkL29PRo2bIiEhASj+QkJCWjSpIlJMqOiopCSkoLExESTvD8RERGpT/VTYNnZ2Th27JhhOi0tDcnJyahYsSICAgIwevRo9O/fH40aNUJERAS++OILpKenY/jw4Sr2moiIiCyZ6gXQ7t270apVK8P06NGjAQADBw7EwoUL0adPH1y8eBExMTHIyMhAeHg41qxZg8DAQJP0Jy4uDnFxccjLyzPJ+xMREZH6VC+AWrZsWeRNC+83cuRIjBw50iz9iYqKQlRUFLKysuDh4WGWTCIiIjKvcj0GiIiIiMgUWAAVwKvAiIiIrB8LoAJ4FRgREZH1YwFEREREmsMCiIiIiDSHBVABHANERERk/VgAFcAxQERERNaPBRARERFpjuo3QiQiorIJGvdrsW0nHc3YESILwiNAREREpDksgArgIGgiIiLrx1NgBfBZYA9pYgnraOJV8/WDiIjoIfAIEBEREWkOCyAiIiLSHBZAREREpDksgIiIiEhzWAAVwKvAiIiIrB8LoAL4KAwiIiLrxwKIiIiINIcFEBEREWkOCyAiIiLSHBZAREREpDl8FAaRxpT45PDpnc3YEyLSOjX3RzwCVAAvgyciIrJ+LIAK4GXwRERE1o8FEBEREWkOCyAiIiLSHBZAREREpDm8CswUJno8oP2qefpBRETWp6TfMfz9Umo8AkRERESawwKIiIiINIcFEBEREWkOCyAiIiLSHBZAREREpDksgArgozCIiIisHy+DLyAqKgpRUVHIysqCh8cDLmcnq8KHhBIRaQePABEREZHmsAAiIiIizWEBRERERJrDMUCPqMTxIo5m7AgRERE9NB4BIiIiIs1hAURERESawwKIiIiINIcFEBEREWkOCyAiIiLSHBZAREREpDlWXQB9+OGHqFu3LsLDw7F48WK1u0NERETlhNXeB+jvv/9GfHw8kpKSAABt2rRBly5d4OnpqW7HiIiISHVWewQoNTUVTZo0gaOjIxwdHVG/fn2sW7dO7W4RERFROVBuC6AtW7aga9eu8PX1hU6nw6pVqwr9zNy5cxEcHAxHR0c0bNgQW7duNbSFh4dj06ZNuHLlCq5cuYKNGzfizJkzZlwCIiIiKq/KbQF0/fp1PP7445gzZ06R7UuXLkV0dDQmTJiAvXv3olmzZoiMjER6ejoAICwsDKNGjULr1q3Rs2dPNG7cGLa2VnvGj4iIiB5CuS2AIiMjMXnyZPTq1avI9lmzZmHIkCEYOnQoQkNDERsbC39/f8ybN8/wMy+//DL27NmDTZs2wd7eHjVr1iw2LycnB1lZWUYvIiIisk7ltgAqye3bt5GUlIT27dsbzW/fvj127NhhmD5//jwA4PDhw/jrr7/QoUOHYt9z2rRp8PDwMLz8/f1N03kiIiJSnUWeE7pw4QLy8vLg5eVlNN/LywuZmZmG6R49euDKlStwcXHBggULSjwFNn78eIwePdownZWVxSKIiIg0I2jcr8W2nZze2Yw9MQ+LLIDu0el0RtMiYjTv/qNBD+Lg4AAHBwfF+kZERGQ1JnqU0HbVfP1QkEWeAqtcuTJsbGyMjvYAd095FTwq9LDi4uIQFhaGxo0bl+l9iIiIqPyyyALI3t4eDRs2REJCgtH8hIQENGnSpEzvHRUVhZSUFCQmJpbpfYiIiKj8KtUpsEe5Isrd3f2h/8/9srOzcezYMcN0WloakpOTUbFiRQQEBGD06NHo378/GjVqhIiICHzxxRdIT0/H8OHDy5RLRERE1q9UBZCnp2eh8TYl0el0OHLkCKpXr/7IHdu9ezdatWplmL43QHngwIFYuHAh+vTpg4sXLyImJgYZGRkIDw/HmjVrEBgY+MiZwN1TYHFxccjLyyvT+xAREVH5VepB0MuXL0fFihUf+HMigk6dOpWpUwDQsmVLiEiJPzNy5EiMHDmyzFn3i4qKQlRUFLKysuDhUcKgLyIiIrJYpSqAAgMD0bx5c1SqVKlUb1q9enXY2dmVqWNEREREplKqAigtLe2h3vTAgQOP1JnygKfAiIiIrJ9FXgVmSrwKjIiIyPo91I0Q8/PzsXDhQqxYsQInT56ETqdDcHAwnnvuOfTv3/+hBkoTERERqaXUR4BEBN26dcPQoUNx5swZ1KtXD3Xr1sWpU6cwaNAg9OzZ05T9JCIiIlJMqY8ALVy4EFu2bMGGDRuMLk8HgI0bN6JHjx5YtGgRBgwYoHgnzYljgIiIqNSs8BERWlHqAui7777D22+/Xaj4AYDWrVtj3LhxWLJkicUXQLwMnorEnRwRkVUp9Smw/fv3o2PHjsW2R0ZGYt++fYp0ioiIiMiUSl0AXbp0qcQHjXp5eeHy5cuKdIqIiIjIlEpdAOXl5cHWtvgzZjY2Nrhz544inSIiIiIypVKPARIRDBo0CA4ODkW25+TkKNYpNXEQNBERkfUrdQE0cODAB/6MpQ+ABjgImoiISAtKXQAtWLDAlP0gIiIiMpsyPwrj1KlTSElJQX5+vhL9ISIiIjK5UhdA33zzDWJjY43m/fe//0X16tVRr149hIeH4/Tp00r3j4iIiEhxpS6APvvsM6MxMevWrcOCBQuwaNEiJCYmwtPTE++//75JOklERESkpFKPATpy5AgaNWpkmP7pp5/QrVs3vPjiiwCAqVOn4qWXXlK+h2bGq8CIiIisX6mPAN28eRPu7u6G6R07dqB58+aG6erVqyMzM1PZ3qkgKioKKSkpSExMVLsrREREZCKlLoACAwORlJQEALhw4QIOHjyIZ555xtCemZnJy8aJiIjIIpT6FNiAAQMQFRWFgwcPYuPGjQgJCUHDhg0N7Tt27EB4eLhJOklERESkpFIXQG+99RZu3LiBFStWwNvbGz/88INR+/bt29G3b1/FO0hERESktFIXQHq9HpMmTcKkSZOKbC9YEBFRGU18wCnliVfN0w8iIitU5hshEhEREVmaUhdAer0eNjY2hV4VKlTA008/jRUrVpiyn2YTFxeHsLAwNG7cWO2uEBERkYmU+hTYypUri5x/5coV/PXXX/jPf/6Db775Bs8//7xinVMDH4ZKRERk/UpdAHXv3r3YtoEDByIsLAwffvihxRdAREREZP0UGwPUvn17HDlyRKm3IyIiIjIZxQqgmzdvwtHRUam3IyIiIjIZxQqgL7/8Eg0aNFDq7YiIiIhMptRjgEaPHl3k/KtXr2L37t04fvw4tm7dqljHiIiIiEyl1AXQ3r17i5zv7u6Ojh07YuTIkQgMDFSsY0RERESmUuoCaNOmTabsBxEREZHZ8E7QREREpDmlKoB69eqFrKysUr/piy++iPPnzz9yp4iIiIhMqVQF0E8//YR///0XWVlZD3xdvXoVv/zyC7Kzs03dd5PgozCIiIisX6nGAIkIateubeq+lAt8FAYREd0TNO7XEttP8vZ3FqtUBdCjDICuVq3aQ/8fIiIiInMoVQHUokULU/eDiIiIyGx4FRgRERFpDgsgIiIi0pxS3wiRiJRX0gBLDq4kIjIdHgEiIiIizXnoAqh169a4cuVKoflZWVlo3bq1En0iIiIiMqmHLoA2b96M27dvF5p/69YtPg2eiIiILEKpxwDt37/f8O+UlBRkZmYapvPy8rBu3Tre+4eIiIgsQqkLoPr160On00Gn0xV5qsvJyQmffvqpop0jIiIiMoVSF0BpaWkQEVSvXh1//fUXqlSpYmizt7dH1apVYWNjY5JOPqrZs2fjq6++goigbdu2+Pjjj6HT6dTuFhEREams1AVQYGAgACA/P99knVHSv//+izlz5uDgwYOws7ND8+bNsWvXLkRERKjdNSIiIlLZQw+CnjZtGubPn19o/vz58zFjxgxFOqWUO3fu4NatW8jNzUVubi6qVq2qdpeIiIioHHjoAujzzz9HSEhIofl169bFZ599pkinAGDLli3o2rUrfH19odPpsGrVqkI/M3fuXAQHB8PR0RENGzY0ugqtSpUqePPNNxEQEABfX1+0bdsWNWrUUKx/REREZLkeugDKzMyEj49PoflVqlRBRkaGIp0CgOvXr+Pxxx/HnDlzimxfunQpoqOjMWHCBOzduxfNmjVDZGQk0tPTAQCXL1/G6tWrcfLkSZw5cwY7duzAli1bFOsfERERWa6HLoD8/f2xffv2QvO3b98OX19fRToFAJGRkZg8eTJ69epVZPusWbMwZMgQDB06FKGhoYiNjYW/vz/mzZsHAPj9999Rs2ZNVKxYEU5OTujcuTN27dpVbF5OTg6ysrKMXkRERGSdHroAGjp0KKKjo7FgwQKcOnUKp06dwvz58/H6669j2LBhpuhjIbdv30ZSUhLat29vNL99+/bYsWMHgLuF2o4dO3Dr1i3k5eVh8+bNqFOnTrHvOW3aNHh4eBhe/v7+Jl0GIiIiUs9DPwx17NixuHTpEkaOHGm4I7SjoyPeeustjB8/XvEOFuXChQvIy8uDl5eX0XwvLy/DDRqffvppdOrUCQ0aNIBer0ebNm3QrVu3Yt9z/PjxGD16tGE6KyuLRRAREZGVeugCSKfTYcaMGXjnnXeQmpoKJycn1KpVCw4ODqbo3wP7cj8RMZo3ZcoUTJkypVTv5eDgoMoylHclPa0c4BPLiQoq6TtzcnpnM/aEiEry0AXQPa6urmjcuLGSfSm1ypUrw8bGxuhxHABw/vz5QkeFHlZcXBzi4uKQl5dXpvchIiKi8uuRCqDExET88MMPSE9PL/Rg1BUrVijSsZLY29ujYcOGSEhIQM+ePQ3zExIS0L179zK9d1RUFKKiopCVlQUPD4+ydpWIiIjKoYcugL7//nsMGDAA7du3R0JCAtq3b4+jR48iMzPTqBgpq+zsbBw7dswwnZaWhuTkZFSsWBEBAQEYPXo0+vfvj0aNGiEiIgJffPEF0tPTMXz4cMX6QERWbGIJf+BMvGq+fhCRKh66AJo6dSpmz56NqKgouLm54eOPP0ZwcDBefvnlIu8P9Kh2796NVq1aGabvDVAeOHAgFi5ciD59+uDixYuIiYlBRkYGwsPDsWbNGsMjOx4VT4ERERFZv4cugI4fP47One8O5HNwcMD169eh0+nw+uuvo3Xr1nj//fcV6VjLli0hIiX+zMiRIzFy5EhF8u7hKTAiIiLr99D3AapYsSKuXbsGAKhWrRoOHDgAALhy5Qpu3LihbO+IiIiITOChC6BmzZohISEBANC7d2+89tprGDZsGPr27Ys2bdoo3kFzi4uLQ1hYmGpXuBEREZHpPfQpsDlz5uDWrVsA7t480M7ODtu2bUOvXr3wzjvvKN5Bc+MpMCIiIuv30AVQxYoVDf/W6/UYO3Ysxo4dq2iniIiIiEzpke4DlJeXh5UrVyI1NRU6nQ6hoaHo3r07bG0f+b6KRERERGbz0BXLgQMH0L17d2RmZhoeLnrkyBFUqVIFP//8M+rVq6d4J82Jl8ETERGVAya+V9cjPQ2+bt26+Oeff7Bnzx7s2bMHp0+fxmOPPYb//ve/Ze6Q2qKiopCSkoLExES1u0JEREQm8tBHgPbt24fdu3ejQoUKhnkVKlTAlClTeOUUERERWYSHPgJUp04dnDt3rtD88+fPo2bNmop0ioiIiMiUHroAmjp1KkaNGoXly5fjn3/+wT///IPly5cjOjoaM2bMQFZWluFFREREVB499CmwLl26ALh7E0SdTgcAhkdWdO3a1TCt0+ksciAxB0ETERFZv4cugDZt2mSKfpQbvBEiERGR9XvoAqhFixam6AcRERGR2TzSnQtv3bqF/fv34/z588jPzzdq69atmyIdIyIiIjKVhy6A1q1bhwEDBuDChQuF2ix13A8RERFpy0NfBfbKK6/g+eefR0ZGBvLz841eLH6IiIjIEjx0AXT+/HmMHj0aXl5epuiP6uLi4hAWFsabOhIREVmxhy6AnnvuOWzevNkEXSkf+CgMIiIi6/fQY4DmzJmD559/Hlu3bkW9evVgZ2dn1D5q1CjFOkdERERkCg9dAMXHx2P9+vVwcnLC5s2bDTdDBO4OgmYBREREROXdQxdA//vf/xATE4Nx48ZBr3/oM2hEREREqnvoCub27dvo06cPix8iIiKyWA9dxQwcOBBLly41RV+IiIiIzOKhT4Hl5eXhgw8+wPr16/HYY48VGgQ9a9YsxTqnBj4MlYjIAk18wLMbJ141Tz/IYjx0AfT333+jQYMGAIADBw4Ytd0/INpS8WGoRERE1o9PgyciIiLNeaSHoRKpqqRD3TzMTUREpVDqAqhXr16l+rkVK1Y8cmeIiIiIzKHUBRDHwxAREZG1KHUBtGDBAlP2g0ohaNyvJbafnN7ZTD0hIiKybLybIREREWkOCyAiIiLSHBZAREREpDksgIiIiEhzWAAVEBcXh7CwMDRu3FjtrhAREZGJsAAqICoqCikpKUhMTFS7K0RERGQiLICIiIhIc1gAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSn1M8CIyINmPiAhx5PvGqefhARmRiPABEREZHm8AiQNSnpr3f+5U5ERGTAI0BERESkOSyAiIiISHOstgA6fPgw6tevb3g5OTlh1apVaneLiIiIygGrHQNUp04dJCcnAwCys7MRFBSEdu3aqdspIiIiKhes9gjQ/X7++We0adMGLi4uaneFiIiIyoFyewRoy5YtmDlzJpKSkpCRkYGVK1eiR48eRj8zd+5czJw5ExkZGahbty5iY2PRrFmzQu+1bNkyDBgwwEw9JyUEjfu12LaTjmbsCBERWaVyewTo+vXrePzxxzFnzpwi25cuXYro6GhMmDABe/fuRbNmzRAZGYn09HSjn8vKysL27dvRqVMnc3SbiIiILEC5PQIUGRmJyMjIYttnzZqFIUOGYOjQoQCA2NhYrF+/HvPmzcO0adMMP/fTTz+hQ4cOcHQs+bBBTk4OcnJyDNNZWVllXAIiIiIqr8rtEaCS3L59G0lJSWjfvr3R/Pbt22PHjh1G85YtW4Y+ffo88D2nTZsGDw8Pw8vf31/RPhMREVH5YZEF0IULF5CXlwcvLy+j+V5eXsjMzDRMX716FX/99Rc6dOjwwPccP348rl69anidPn1a8X4TERFR+VBuT4GVhk6nM5oWEaN5Hh4eOHfuXKney8HBAQ4ODor2j4iIiMonizwCVLlyZdjY2Bgd7QGA8+fPFzoq9LDi4uIQFhaGxo0bl+l9iIiIqPyyyALI3t4eDRs2REJCgtH8hIQENGnSpEzvHRUVhZSUFCQmJpbpfYiIiKj8KrenwLKzs3Hs2DHDdFpaGpKTk1GxYkUEBARg9OjR6N+/Pxo1aoSIiAh88cUXSE9Px/Dhw1XsNREREVmCclsA7d69G61atTJMjx49GgAwcOBALFy4EH369MHFixcRExODjIwMhIeHY82aNQgMDCxTblxcHOLi4pCXl1em9yEiIqLyq9wWQC1btoSIlPgzI0eOxMiRIxXNjYqKQlRUFLKysuDh4aHoexMREVH5YJFjgIiIiIjKggVQAbwKjIiIyPqxACqAV4ERERFZPxZAREREpDksgIiIiEhzWAAVwDFARERE1o8FUAEcA0RERGT9WAARERGR5rAAIiIiIs1hAURERESawwKoAA6CJiIisn4sgArgIGgiIiLrxwKIiIiINIcFEBEREWkOCyAiIiLSHBZAREREpDksgArgVWBERETWjwVQAbwKjIiIyPrZqt0BIiKi0gga92uxbScdzdgRsgo8AkRERESawwKIiIiINIcFEBEREWkOCyAiIiLSHBZABfAyeCIiIuvHAqgAXgZPRERk/VgAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDp8FRkRkLhM9Smi7ar5+EBGPABEREZH2sAAiIiIizWEBRERERJrDAqgAPgqDiIjI+rEAKoCPwiAiIrJ+LICIiIhIc1gAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDgsgIiIi0hwWQERERKQ5LICIiIhIc1gAERERkebYqt0BU0pLS8PgwYNx7tw52NjYYNeuXXBxcVG7W0RU0ESPEtqumq8fRKQZVl0ADRo0CJMnT0azZs1w6dIlODg4qN0lIiIiKgestgA6ePAg7Ozs0KxZMwBAxYoVVe4RERERlRfldgzQli1b0LVrV/j6+kKn02HVqlWFfmbu3LkIDg6Go6MjGjZsiK1btxrajh49CldXV3Tr1g1PPPEEpk6dasbeExERUXlWbgug69ev4/HHH8ecOXOKbF+6dCmio6MxYcIE7N27F82aNUNkZCTS09MBALm5udi6dSvi4uKwc+dOJCQkICEhwZyLQEREROVUuS2AIiMjMXnyZPTq1avI9lmzZmHIkCEYOnQoQkNDERsbC39/f8ybNw8A4Ofnh8aNG8Pf3x8ODg7o1KkTkpOTi83LyclBVlaW0YuIiIisU7ktgEpy+/ZtJCUloX379kbz27dvjx07dgAAGjdujHPnzuHy5cvIz8/Hli1bEBoaWux7Tps2DR4eHoaXv7+/SZeBiIiI1GORBdCFCxeQl5cHLy8vo/leXl7IzMwEANja2mLq1Klo3rw5HnvsMdSqVQtdunQp9j3Hjx+Pq1evGl6nT5826TIQERGReiz6KjCdTmc0LSJG8yIjIxEZGVmq93JwcOBl8kRERBphkUeAKleuDBsbG8PRnnvOnz9f6KjQw4qLi0NYWBgaN25cpvchIiKi8ssijwDZ29ujYcOGSEhIQM+ePQ3zExIS0L179zK9d1RUFKKiopCVlQUPjxLuTktE5VrQuF9LbD/paKaOEFG5VG4LoOzsbBw7dswwnZaWhuTkZFSsWBEBAQEYPXo0+vfvj0aNGiEiIgJffPEF0tPTMXz4cBV7TURERJag3BZAu3fvRqtWrQzTo0ePBgAMHDgQCxcuRJ8+fXDx4kXExMQgIyMD4eHhWLNmDQIDA8uUGxcXh7i4OOTl5ZXpfYiIiKj8KrcFUMuWLSEiJf7MyJEjMXLkSEVzeQqMiIjI+lnkIGgiIiKismABVACvAiMiIrJ+LIAKiIqKQkpKChITE9XuChEREZkICyAiIiLSHBZAREREpDksgArgGCAiIiLrxwKoAI4BIiIisn4sgIiIiEhzWAARERGR5rAAIiIiIs1hAVQAB0ETERFZPxZABXAQNBERkfVjAURERESawwKIiIiINIcFEBEREWkOCyAiIiLSHBZABfAqMCIiIuvHAqgAXgVGRERk/VgAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDgugAngZPBERkfVjAVQAL4MnIiKyfiyAiIiISHNYABEREZHmsAAiIiIizWEBRERERJrDAoiIiIg0hwUQERERaY6t2h0gIusXNO7XEttPOpqpI0RE/w+PABEREZHmsAAiIiIizWEBVAAfhUFERGT9WAAVwEdhEBERWT8WQERERKQ5LICIiIhIc1gAERERkeawACIiIiLNYQFEREREmsMCiIiIiDSHBRARERFpDgsgIiIi0hwWQERERKQ5LICIiIhIc2zV7kB5JSIAgKysrCLb83NuFPt/s3RS8psX854PUlLmA3MtKPNBucwsW255y3xgrgVlPiiXmWXLLW+ZD8zVyjYtZ5n3fm/f+z1eHJ086Cc06p9//oG/v7/a3SAiIqJHcPr0afj5+RXbzgKoGPn5+Th79izc3Nyg0+lK/f+ysrLg7++P06dPw93d3YQ9VD+Xmcy01FxmMtNSc5n5YCKCa9euwdfXF3p98SN9eAqsGHq9vsTK8UHc3d3N+kVUM5eZzLTUXGYy01JzmVkyDw+PB/4MB0ETERGR5rAAIiIiIs1hAaQwBwcHvPfee3BwcLD6XGYy01JzmclMS81lpnI4CJqIiIg0h0eAiIiISHNYABEREZHmsAAiIiIizWEBRERERJrDAoiIiIg0hwUQERERaQ4LoDL69NNPMXDgQCxbtgwA8O233yIsLAwhISF4++23cefOHbP36fTp0xg8eLDi73vz5k1s27YNKSkphdpu3bqFRYsWKZq3d+9epKWlGaYXL16Mpk2bwt/fH8888wy+//57RfNKw1TrNjU1FQsWLMChQ4cAAIcOHcKIESMwePBgbNy4UfE8tTLVzC2OqbZpRkYG3n33XbRu3RqhoaEIDw9H165d8fXXXyMvL0/xPECddfvPP/9gwoQJaNWqFUJDQxEWFoZWrVphwoQJOH36tOJ5r776KrZu3ar4+5aGGtvU3Ou3POx3L1++jNjYWERFRWHy5MkmWU4AgNAji4mJETc3N3n22WfF29tbpk+fLpUqVZLJkyfL1KlTpUqVKvLuu++avV/Jycmi1+sVfc/Dhw9LYGCg6HQ60ev10qJFCzl79qyhPTMzU/HMBg0ayMaNG0VE5MsvvxQnJycZNWqUzJs3T6Kjo8XV1VW+/vprRTMfxBTrdu3atWJvby8VK1YUR0dHWbt2rVSpUkXatm0rbdq0EVtbW9mwYYPFZ6qZWxJTbNPExETx8PCQ+vXrS0REhOj1eunfv7/06dNHPD09JSIiQrKyshTNVGPdbt26VVxdXSU0NFRee+01mTp1qkyZMkVee+01CQsLEzc3N9m2bZuimff2QbVq1ZLp06dLRkaGou9fHDW2qRrrV439ro+Pj1y4cEFERE6cOCHe3t7i7e0t7dq1Ez8/P/Hw8JDU1FRFM0VEWACVQfXq1eXHH38Ukbs7URsbG1m8eLGhfcWKFVKzZk3Fc3/66acSX7Nnz1Z8h96jRw/p0qWL/Pvvv3L06FHp2rWrBAcHy6lTp0TENAWQs7Oz4f0bNGggn3/+uVH7kiVLJCwsTNFMNdZtRESETJgwQUREvvvuO6lQoYK8/fbbhva3335b2rVrZ/GZauWqsU2bNm0qEydONEx/++238tRTT4mIyKVLl6R+/foyatQoRTPVWLeNGjWS6OjoYtujo6OlUaNGimbqdDr5/fff5bXXXpPKlSuLnZ2ddOvWTX755RfJy8tTNOt+amxTNdavGvtdnU4n586dExGRF154QVq2bCnXr18XEZFbt25Jly5d5LnnnlM0U4QFUJk4OTkZPigiInZ2dnLgwAHD9MmTJ8XZ2Vnx3Ht/Ael0umJfSu/Qq1atKvv37zeaN3LkSAkICJDjx4+bpACqVKmS7N6925CfnJxs1H7s2DFxcnJSNFONdevu7i5Hjx4VEZG8vDyxtbWVpKQkQ/vff/8tXl5eFp+pVq4a29TJyUmOHz9umM7LyxM7OzvJzMwUEZHffvtNfH19Fc1UY906OjrKoUOHim1PTU0VR0dHRTPv/2V5+/ZtWbp0qXTo0EFsbGzE19dX3n77bcN6UJIa21SN9avWfvfeNg0ODi50pHLXrl3i5+enaKaICMcAlYG3t7dhPMzRo0eRl5dnND7m4MGDqFq1quK5Pj4++PHHH5Gfn1/ka8+ePYpn3rx5E7a2tkbz4uLi0K1bN7Ro0QJHjhxRPDMyMhLz5s0DALRo0QLLly83al+2bBlq1qypaKYa6/Z+er0ejo6O8PT0NMxzc3PD1atXrSrTnLlqbNOqVasiIyPDMH3u3DncuXMH7u7uAIBatWrh0qVLiufeY851u2PHjmLbd+7cCR8fH0Uz72dnZ4fevXtj3bp1OHHiBIYNG4YlS5agTp06imepsU3VWL9q7HcBQKfTAQBycnLg5eVl1Obl5YV///1X8UzbB/8IFadfv34YMGAAunfvjg0bNuCtt97Cm2++iYsXL0Kn02HKlCl47rnnFM9t2LAh9uzZgx49ehTZrtPpIAo/4i0kJAS7d+9GaGio0fxPP/0UIoJu3bopmgcAM2bMQNOmTdGiRQs0atQIH330ETZv3ozQ0FAcPnwYu3btwsqVKxXNVGPdBgUF4dixY4adys6dOxEQEGBoP336tOI7OTUy1cpVY5v26NEDw4cPx8yZM+Hg4IBJkyahRYsWcHJyAgAcPnwY1apVUzRTjXX75ptvYvjw4UhKSkK7du3g5eUFnU6HzMxMJCQk4KuvvkJsbKyimcUJCAjAxIkT8d577+H3339X/P3V2KZqrF819rsA0KZNG9ja2iIrKwtHjhxB3bp1DW3p6emoXLmy4pk8BVYGd+7ckcmTJ0uXLl1k+vTpInL33Lu/v79UqlRJBg0aJNnZ2YrnbtmyRdauXVtse3Z2tmzevFnRzKlTp0pkZGSx7SNGjBCdTqdopojI5cuX5a233pKwsDBxdHQUe3t7CQwMlH79+kliYqLieWqs23nz5snq1auLbX/77bdlyJAhFp+pVq4a2/TatWvSu3dvsbW1FZ1OJ02aNJETJ04Y2tevXy/Lli1TNFOtbfr999/LU089ZVhWnU4ntra28tRTT8nSpUsVzwsKCjIMmDUnNbapiPnXr4j597sTJ040eq1bt86o/c0335QXXnhB8Vw+DZ6IyERu3bqFO3fuwNXVVe2umFxubi4uXLgAAKhcuTLs7OxU7pFpqLVNtbJ+zYkFkBVJS0uDv79/obE6piYihvO3ZPnU2J5qfXaJyurOnTtm/9xqJdPUOAi6DLp27Ypvv/0WN2/eVLsrAIA6derg6NGjJnnvnJwcvPHGG2jRogVmzpwJAJg8eTJcXV3h6uqKfv36ISsrS/HcxMREvPjiiwgODoaTkxOcnZ0RHByMF198Ebt371Y8T63Mkhw/fhytW7dW9D3V2p7FMeVnFwD27duHAQMGoHr16nBycoKrqyvq1auHd955xyTLqda+ISEhAe+9957hpodbtmxBZGQkWrdujQULFpi1L4BpPru3b98ulBEdHY3OnTtj6NChSEpKUjTvnnXr1uHvv/8GAOTn52Py5MmoVq0aHBwc4Ofnh+nTpys+lkwrmWptU44BKoN752I9PDxk+PDhhksHTa1nz55FvvR6vbRt29YwraTXX39dfH195Y033pDQ0FCJioqSgIAAWbx4scTHx0vNmjXl1VdfVTRz5cqVYmdnJx07dpTZs2dLfHy8LFmyRGbPni2RkZFib28vq1atsvjMBzHFjfrU2J4i6nx2161bJ05OTtKjRw/p27evODs7yyuvvCJvvfWW1KxZU2rUqKH4zfTU2Dd8++23YmtrK0888YS4urrKggULxNPTU4YOHSpDhgwRe3t7+eGHH0zej/uZ4rOr1+sNl0zv3btXnJ2dpX79+jJs2DBp3Lix2Nvby59//qlopohIWFiYbN++XUTujomsVKmSzJo1S9auXSuxsbHi5eVlGAvKzIej1jZlAVQGOp1ODh48KLNnz5Z69eqJXq+Xxx57TD799FO5dOmSSXNbtGghgwYNMnrp9Xrp0aOHYVpJ/v7+kpCQICIix48fF71eb1QI/PbbbxIYGKhoZt26dWXatGnFtk+fPl3xG3Kpkfnxxx+X+Bo7dqziv0TU2J4i6nx269evL/PmzTNM//bbbxISEiIid+8j06ZNG8Uz1dg31K9fXz7++GMREfn999/FyclJZs2aZWj/6KOPpGnTpopmqvHZvf+eMfdukJefn29of+mll6Rjx46KZorcvSdPenq6iIiEh4cXGoC8evVqxW98q5VMtbYpC6AyuH+jiYj8+eef8t///lc8PDzEyclJ+vbta5Lb+n/33Xfi5+cn8+fPN5pva2srBw8eVDxP5ME3fUxLS1P8po8ODg5y+PDhYtsPHTokDg4OFp+p0+nE19dXgoKCinz5+vqa5EZ95t6eIup8dh0dHSUtLc0wnZ+fL3Z2doZHuWzZskWqVKmiaKYa+wYXFxejq5Ls7Oxk3759hulDhw5JpUqVFM1U47N7/7r18/Mr9CiI5ORkk9zE08fHR3bu3CkiIl5eXrJnzx6j9iNHjih+g0CtZKq1TTkGSEFPPvkkPv/8c2RkZGDu3Lk4ffo02rVrp3jOCy+8gG3btmH+/Pl49tlncfnyZcUzCgoICMDOnTsB3B0jo9Pp8Ndffxna//zzT8XvgVGjRg2sWrWq2PaffvoJ1atXt/jMwMBAzJ49G2lpaUW+fv31V0XzAHW2J6DOZ7datWo4fPiwYfr48ePIz89HpUqVAAB+fn7Izs42aR/MsW+ws7MzGkvh4OBgdKWSvb294mOS1Pjs6nQ6wyB9Gxsbw40I73F3dzfJTTx79uyJKVOmIC8vD927d8fcuXONxsLMmTMH9evXZ+YjUGub8ghQGRT8K68oR44cMVl+Xl6evPvuu+Lv7y/r1q0TOzs7k/0VPXv2bHF0dJS2bdtKhQoV5NNPPxVvb28ZO3asjBs3Tjw8PCQmJkbRzOXLl4utra106tRJYmNj5bvvvpPvv/9eYmNjpXPnzmJnZ2d4FpslZz777LMyduzYYtuTk5MVv8eSGtvzfub87L7//vvi5+cn8+bNk/nz50t4eLjROKMVK1aY9NlGxVF639CoUSOj05hXr141Oo2QkJAgtWvXVjRTjc+uTqcTT09PqVChgtjZ2cmSJUuM2tevXy9BQUGKZoqIXLlyRRo1aiQ1a9aU/v37i6OjowQGBkq7du0kODhY3N3dZdeuXcx8BGptU14GXwatWrXCypUrjW43r4bt27ejf//+OHXqFP7++2+EhYWZJGfJkiXYtWsXnnnmGfTp0webN2/Gu+++ixs3bqBr16545513oNcre1Bx586d+Pjjj7Fz505kZmYCuPsIkoiICLz22muIiIhQNE+NzJSUFNy4cQONGjUqsj03Nxdnz55FYGCgorlqbM+CzPHZvXPnDiZMmIDFixcjJycHHTp0wMcff2y4s+xff/2FW7duoXnz5oplqrFvWLlyJSpVqlTsckyfPh3Xr1/HpEmTFMtU47P7zTffGE2HhITgqaeeMkzHxMTgypUrmDVrlmKZ9+Tm5uLrr7/GL7/8ghMnTiA/Px8+Pj5o2rQpRowYAT8/P2Y+ArW2KQsgK5GdnY3jx48jJCQEDg4OaneHqNT42SUiNbAAIiIiIs3hIOgy2rdvHyZPnoy5c+cablN+T1ZWFgYPHmyS3K+++goDBw403Nxs6dKlCA0NRfXq1fHee++ZJFONZVVjObWSyc/uXaZaVn5frGt7qpXLTBNuU8VHFWnI+vXrxd7eXurWrSsBAQFSuXJl2bhxo6E9MzNT8UtARe4OYHVxcZFevXqJj4+PTJ48WSpVqiSTJ0+WmJgY8fDwkM8//1zRTDWWVY3l1EomP7umXVZ+X6xre6qVy0zTZYrwPkBlEhERIW+//baI3L23yAcffCCurq6GJ0+baqOFhIQYRsnv2bNHbG1t5auvvjK0z58/Xxo2bKhophrLqsZyaiWTn13TLiu/L6bLVOuzq5XPkVYyRVgAlYm7u7scO3bMaF58fLy4uLjIzz//bLKNVvAmdg4ODkY3sTt69Kh4enoqmqnGsqqxnFrJ5GfXtMvK74vpMtX67Grlc6SVTBER63q0q5k5ODjgypUrRvP69u0LvV6PF154AR999JFJcp2dnXH9+nXDdJUqVYxueAbcvfRXSWosqxrLqZVMfnZNu6z8vpguU63PrlY+R1rJBAAWQGVQv359bNq0CQ0bNjSa36dPH+Tn52PgwIEmyQ0JCcH+/fsRGhoKADh9+rRR+6FDhxAUFKRophrLqsZyaiWTn13TLiu/L6bLVOuzq5XPkVYyARZAZTJixAhs2bKlyLa+ffsCAL744gvFc2fMmAEXF5di29PT0/Hyyy8rmqnGsqqxnFrJ5Gf3LlMtK78vpstU67Orlc+RVjIB3geIiIiINIhHgBR29OhRpKenIzAwEDVr1lS7OyZlzmVNT09HRkYGbGxsEBQUZHiMASlr4cKF6NmzJzw8PNTuitVRY99g7fujU6dOITMzEzqdDl5eXoo/LqY4au+P5O4FTCZ/VI3amSan+LBqDZk2bZps2LBBREQuXbokbdq0EZ1OJzqdTvR6vXTs2FEuX75skuzVq1fLkCFDZMyYMZKammrUdunSJWnVqpWieWota1xcnAQEBIherzd6NW3aVHbv3q143vr16yU3N9cwvWTJEnn88cfF2dlZatSoIR9//LHimSLm357FsbOzk5SUFJNmmHtZXV1dZfDgwbJ9+3ZF37ckanxf1PqOqvHZnTVrlvj5+YlerzdaRj8/P5k9e7biefeYe3+Um5srEyZMkObNm8u7774rIiIffPCBODs7i729vQwYMEBycnIsPlOt/S4LoDIICAiQffv2iYjI0KFDpUGDBrJnzx65efOmJCcny9NPPy1DhgxRPHfJkiViY2MjnTt3lmeeeUYcHR1l8eLFhnZTXDKoxrLOnDlTfHx8JDY2Vj777DMJDQ2VmJgYWbt2rfTv31+cnZ0lMTFR0Uy9Xm94ivfy5cvFxsZGXn31VVmyZIm88cYb4uDgIPHx8YpmqrE9K1SoUORLp9OJh4eHYVppaiyrTqeTunXrik6nk5CQEPnwww8f+KT2slLj+6JGphrbMyYmRtzd3WX69Omyd+9eOXv2rJw5c0b27t0r06dPFw8PD5k0aZKimSLq7I/+97//iZeXl4wePVrCwsJk+PDh4u/vL4sXL5ZFixaJn5+fzJgxw+Iz1djvirAAKhMHBwc5efKkiIgEBQXJH3/8YdS+e/du8fHxUTy3QYMG8sknnximf/jhB3F1dTXcgMwUOx01ljUoKEjWrFljmD58+LBUqlTJ8JfCqFGjpF27dopm6nQ6wxexadOmhr+A7pk5c6Y0btxY0Uw1tqerq6t07txZFi5caHgtWLBAbGxsZMqUKYZ5SlNjWe9t0+TkZHnllVekYsWKYm9vL7169ZI1a9ZIfn6+onki6nxf1MhUY3v6+fnJypUri21fsWKF+Pr6Kpopos7+qHr16vLLL7+IyN17Kun1evn+++8N7cuWLZPw8HCLz1RjvyvCAqhMateuLatXrxYRkeDg4EKH2Pfu3Svu7u6K57q4uMiJEyeM5m3atEnc3Nxk3rx5JtnpqLGszs7OkpaWZpjOz88XW1tbOXv2rIiIJCcni6urq6KZ938Rq1atKklJSUbthw8fFg8PD0Uz1dieR48elcaNG8uAAQPk2rVrhvm2trZy8OBBRbPup8ay3r9NRURycnIkPj5e2rRpYzht8s477yiaqcb3RY1MNbank5NTiadpDxw4IE5OTopmiqizP3J0dJT09HSj6ftPM544cULc3NwsPlON/a6IiBWNZjK/YcOGYcyYMTh27BheeeUVvPnmmzh+/DgAIC0tDa+//jrat2+veK67uzvOnTtnNK9ly5b45ZdfMGbMGHz66aeKZ6qxrLVr10ZCQoJhetOmTbC3t4e3tzcAwNHRETqdTtFMAEhJScH+/fvh5OSE/Px8o7b8/Hzk5eUpmqfG9qxZsyZ27NgBb29v1K9fH9u3b1c8oyhqLGvBz4i9vT369u2L33//HcePH8egQYOwcOFCRTPV+L6okanG9nzyyScxZcqUIm+weOfOHUydOhVPPvmk4rlq7I88PDyMbhD4xBNPwM3NzTCdk5NjFZmA+fe7ADgIuqxeffVVsbOzk5CQEHF0dBS9Xi/29vai1+ulUaNGkpGRoXhm9+7dCx0ivGfTpk3i4uJiktuGm3tZly5dKnZ2dtK7d28ZMGCAuLq6yrhx4wztn332mURERCiaeW8w5b2BlbGxsUbt8fHxEhYWpmimWtvzng0bNkhAQICMHz9e7OzsTHoESI1lLXgEqCimOA2mxr7B3JlqbM/9+/eLt7e3VKhQQXr06CEvv/yyDB8+XHr06CEVK1YUHx8fo8dxKEWN/VGrVq1KPBW9bNkyxZ+1pkamGvtdERHeB0gBqampWL16NU6cOIH8/Hz4+PigadOmaNu2rUkq5T/++AM7duzA+PHji2zfvHkzvvnmGyxYsEDxbHMv69q1a7F48WLk5OSgQ4cOGDZsmKHt4sWLAIBKlSoplnfq1CmjaVdXV6P3X7RoEQBgwIABimWquT3vuXjxIoYNG4ZNmzZh165dqFOnjkly1FjW999/H2PGjIGzs7Ni71la5v6+mDtTrc/utWvXsHjxYuzatQuZmZkAAG9vb0RERKBfv35wd3dXNO8ec++Pjhw5Ajs7OwQHBxfZHh8fD1tbW/Tu3duiM9XY7wK8ESIRERFpEMcAmVBubi7S09PNnnvnzh2z55pyWbOzs/HHH39g6dKlWLZsGf744w9kZ2ebJOtB1Fi3WslUM9fc1Ng3qJFpbfsigPsjq8pU/KQaGSQnJ5t07EZ5yjVFZm5urowaNUqcnJxEp9OJg4OD2Nvbi06nEycnJ3nttdfk9u3bimY+iLWs2/KYacrcuLg4adOmjTz//POGmwXe8++//0pwcLDimSXRyja1pkzuj6wvk0eAqNx644038OOPP2LBggW4dOkSbt26hZycHFy6dAkLFizAihUrMGbMGLW7SeXcJ598gjFjxiAkJAQODg7o1KkTpk2bZmjPy8srNAaBqCDuj6wPnwVWBk888USJ7Tdv3rSaXDUy4+PjsXTpUrRu3dpovqenJ/r06YPKlSvjhRdeQGxsrGKZWlm3Wvrsfv755/jyyy/Rr18/AMDIkSPRo0cP3Lx5EzExMYrnAdrZplrJBLg/srZMgAVQmaSkpOCFF14odrR8RkYGjhw5YhW5amTevHmzxIcMVqpUSfEvhlbWrZY+u2lpaWjSpIlhOiIiAhs3bkSbNm2Qm5uL6OhoRfMA7WxTrWQC3B9ZWyYAjgEqi4YNG8rcuXOLbd+7d69JzluqkatGZpcuXaRNmzaSmZlZqC0zM1PatWsnXbt2VTRTK+tWS59df39/2bJlS6H5Bw8eFC8vL+nfv79VrF9mmi5ThPsja8sUEeERoDJ45plncPjw4WLb3dzc0Lx5c6vIVSNz7ty56NSpE/z8/BAeHg4vLy/odDpkZmbiwIEDCAsLw6+//qpoplbWrdY+uz/++COaNWtmND8sLAwbNmxAq1atFM27l6mFbaqVTID7I2vLBHgfICrn8vPzsX79+iJveNa+fXvo9RzHTyXbv38/kpKS8NJLLxXZfvDgQSxfvhzvvfeemXtGlob7I+vCAoiIiIg0h6fAyqC0N2YKCAiw+FxmMtNSc5nJTEvNZabpMgEeASoTvV5f5LN1RMQwX6fTFfnUYkvLZSYzLTWXmcy01Fxmmnab8ghQGezdu7fI+SKC77//Hp988glcXV2tIpeZzLTUXGYy01JzmWnabcrL4BWWkJAgDRs2FDc3N3nvvffk2rVrVpvLTGZaai4zmWmpucxUDgsghezevVvatm0rDg4OEhUVJefOnbPaXGYy01JzmclMS81lpvJYAJXR0aNHpXfv3mJjYyN9+/aV48ePW20uM5lpqbnMZKal5jLTdFgAlcGIESPE3t5eOnToIHv37rXqXGYy01JzmclMS81lpmnxKrAy0Ov1cHR0REhISIk/t2fPHovPZSYzLTWXmcy01Fxmmi4T4FVgZaLWnWPVyGUmMy01l5nMtNRcZpoWjwARERGR5vDBJQrLycnB8ePHkZOTo4lcsh5a+Azl5eXh3LlzOH/+PPLy8syaeeHCBbPkqUWL61YL3xk1nTt3zvDMNVNgAVQGCxcuxK5duwAAt27dwtChQ+Hi4oLatWvD1dUVw4cPN8kXQ43cevXqYdKkSTh9+rSi7/sg+/btw+TJkzF37txCO7msrCwMHjxY8cyvvvoKAwcOxIIFCwAAS5cuRWhoKKpXr26SQ7VHjhzB/Qdit23bhh49eqBu3bpo27YtfvrpJ8Uz1frsAups05UrV6Jp06ZwdnaGr68vfHx84OzsjKZNm2LVqlWK5wHAr7/+iubNm8PFxQW+vr7w8vKCp6cn+vfvX+pb/z8srlvTrVu1vjPm3h+pkXnp0iU8++yzCAwMRFRUFPLy8jB06FD4+PigWrVqaNKkCTIyMhTP5VVgZVCzZk1JTEwUEZE333xTgoKCZMWKFZKamiqrVq2S2rVry5gxY6wiV6fTSaVKlcTGxkY6dOggy5cvl9zcXEUzClq/fr3Y29tL3bp1JSAgQCpXriwbN240tGdmZoper1c0c/bs2eLi4iK9evUSHx8fmTx5slSqVEkmT54sMTEx4uHhIZ9//rmimXq93nCvi02bNoler5euXbvKlClT5NlnnxW9Xi/r1q1TNFOtz64a2/Szzz4Te3t7GT58uKxcuVJ27Ngh27dvl5UrV8rw4cPFwcFBvvjiC0UzFy1aJG5ubhIdHS3jxo0TLy8vGTdunMybN09atGghlStXliNHjiiayXVrunUros53Ro39kRqZL730koSHh8unn34qLVq0kB49eshjjz0m27Ztkx07dkjjxo1lwIABimaK8DL4MnFwcJBTp06JiEjt2rVl7dq1Ru1//PGHBAQEWEWuTqeTM2fOyMqVK6Vr165ia2srVapUkTfeeENSUlIUzbonIiJC3n77bRERyc/Plw8++EBcXV0Ny2uKHXpISIgsWbJERET27Nkjtra28tVXXxna58+fLw0bNlQ0U6fTGQqgNm3ayMiRI43ax40bJ82bN1c0U63PrhrbtEaNGkbbsKCvv/5aqlevrmhmSEiIfP/994bpxMRE8fPzk/z8fBER6dOnj/Ts2VPRTK5b061bEXW+M2rsj9TI9PHxke3bt4vI3c+pTqeT3377zdC+bds2qVatmqKZIiyAyiQwMNDwF1a1atUMfx3ck5KSIi4uLlaRe/8vaRGRjIwMmTp1qtSqVUv0er1ERETI119/rWimu7u7HDt2zGhefHy8uLi4yM8//2ySHbqTk5NhJydyd6d34MABw/TRo0fF09NT0cz7162Pj4/s2rXLqP3gwYNSqVIlRTPV+uyqsU0dHR3l0KFDxbanpqaKo6OjoplOTk6SlpZmNM/W1lbOnDkjIiJ//vmn4p8jrlvTrVsRdb4zauyP1Mh0dnaWkydPGqbt7Ozk77//NkyfOHHCJPsjjgEqgxdffBETJkzAlStX0L9/f8TExCA7OxsAcOPGDUycOBFNmza1ityCT+r19vbG+PHjceTIEWzYsAE1atTAqFGjFM10cHDAlStXjOb17dsXX3/9NV544QWsXLlS0TwAcHZ2xvXr1w3TVapUKfQQPqWfSAwA165dQ1ZWFpycnODg4GDUZm9vj5s3byqap9ZnV41tWrduXXzxxRfFtn/55ZeoW7euoplBQUHYvXu3YXrPnj3Q6/Xw8vICAFSsWBG5ubmKZnLdmm7dAup8Z9TYH6mRWatWLaxevRoAsHbtWjg6OuK3334ztK9fvx7BwcGKZgLgGKCyyMnJkW7dukmFChWkXbt24ujoKM7OzlKrVi1xcXGRgIAAOXz4sFXkFjwCVJSrV68qmtmuXTuZOXNmkW3x8fFiZ2en+F+0TZs2NTq8XtAvv/wi4eHhimbqdDrR6/Wi1+tFp9MVOqWwatUqqVWrlqKZan121dimmzdvFhcXFwkLC5Po6GiZNm2aTJ8+XaKjo6Vu3bri6uoqW7ZsUTRzzpw54uHhIWPHjpV3331XfH19ZciQIYb2xYsXS4MGDRTN5Lq9yxTrVkSd74wa+yM1MhcvXiw2NjZSs2ZNcXR0lOXLl4uvr6/07t1bXnjhBbG3t5c5c+YomikiwhshloG9vT1++uknrFu3Dr/88gtsbGyQn58PHx8fNG3aFP369YOLi4tV5A4cOBBOTk4l/oy7u7uimSNGjMCWLVuKbOvbty8AlPjX56OYMWNGiesuPT0dL7/8sqKZmzZtMpr28fExmj558iSGDRumaKZan101tmmLFi1w4MABzJs3D7t27TJcVuvt7Y0uXbpg+PDhCAoKUjQzKioKer0eixcvRk5ODgYNGoR33nnH0P7kk08iPj5e0Uyu27tMsW4Bdb4zauyP1Mh88cUXERgYiD///BNNmjRBREQEQkNDMX36dNy4cQNffPEFBg4cqGgmwBshEhERkQZxDJAVERHk5+er3Q2TOHXqFP7880/89ddfOHXqlNnzrXndpqen488//8Tu3btVu6HcwoULcfXqVVWyrZ251+3Ro0exYcMGHDt2zGyZarH2ZVV732Dyz67iJ9U0xNXVVQYPHmy4fM9ccnNzZcKECdK8eXN59913RUTkgw8+EGdnZ7G3t5cBAwZITk6Oopnr1683uu/PkiVL5PHHHxdnZ2epUaOGfPzxx4rm3TNr1izx8/MzjI+5N17Gz89PZs+erXieGuv2QZKTkxUfuyEiEhcXJwEBAYbxR/deTZs2ld27dyueVxI7OzuT3U5Bre9pSUy1TYtiynU7bdo02bBhg4iIXLp0SVq3bm30Pe3YsaNcvnxZ0Uy1tqcay6rWfre87BtM+dkV4WXwZaLT6aRu3bqi0+kkJCREPvzwwwcOFFbC//73P/Hy8pLRo0dLWFiYDB8+XPz9/WXx4sWyaNEi8fPzkxkzZiiaef/N+pYvXy42Njby6quvypIlS+SNN94QBwcHiY+PVzQzJiZG3N3dZfr06bJ37145e/asnDlzRvbu3SvTp08XDw8PmTRpkqKZaqzbB0lOThadTqfoe86cOVN8fHwkNjZWPvvsMwkNDZWYmBhZu3at9O/fX5ydnQtd5quEChUqFPnS6XTi4eFhmFaSWt/Tkphim6qxbgMCAmTfvn0iIjJ06FBp0KCB7NmzR27evCnJycny9NNPGw1QVoJa21ONZVVjv6vGvkGNz66ICMcAlYFer0dmZiYyMjLw1VdfIT4+HtnZ2ejSpQuGDh2Kjh07Frp8XAk1atTAxx9/jC5duuDYsWOoU6cO4uPj0adPHwDADz/8gJiYGPz999+KZd5b1qpVq+KZZ55BmzZt8P777xvaP/zwQyxbtgx//fWXYpn+/v749NNP0aNHjyLbV65ciVdeeQVnzpxRLFONddurV68S269evYrNmzcr+nyl4OBgzJ07F5GRkQDuPo6jSZMmyMzMhK2tLV577TWkpqYaXYqqBDc3N7Ro0QLPP/+8YZ6IYOjQoYiJiUG1atUAQNEBj2p8T9XYpmqsW0dHRxw+fBiBgYEIDg7GN998g+bNmxvak5KS0LVrV5w9e1axTLX2u2ouqzn3u2rsG9T47N4LoUdU8NLwnJwciY+PlzZt2hhO07zzzjuK5zo6Okp6errRdGpqqmH6xIkT4ubmpmjm/ctatWpVSUpKMmo/fPiweHh4KJrp5ORU4uHPAwcOiJOTk6KZaqxbW1tbiYyMlEGDBhX56tatm+KnS5ydnY1uJpefny+2trZy9uxZEbl7hMLV1VXRTJG7N1G7d1v7a9euGebb2trKwYMHFc8TUed7qsY2VWPd1q5dW1avXi0iIsHBwYVOS+3du1fc3d0VzVRrv6v2spprv6vGvkGNz64IT4GVyf2HJwtKS0uT//3vf+Lv7694rpeXl+zfv98w3aRJE/nnn38M06mpqSb5Im7atEn27dsngYGBhQ6BpqamKv6laNGihbz44otFPnMsNzdX+vXrJy1atFA0U411W69evRIfJ7B3717Ff1nWr1/f6BlNGzZsEGdnZ8PjBA4dOqR4oXdPbm6ujB07VmrUqCHbtm0TEdPu6NT4nqqxTUXMv25nzpwpoaGhcvToUfnoo48kIiLCcDfqEydOSMuWLeW5555TNFOt/a4ay6rGfletfYO5P7siLIDKpDQ3B7z3oVFSq1atZOHChcW2L1u2zCTPq7p/IHJsbKxRe3x8vISFhSmauX//fvH29pYKFSpIjx495OWXX5bhw4dLjx49pGLFiuLj42N0i3YlqLFuBw0aVOj5X/dLSUmRoKAgRTOXLl0qdnZ20rt3bxkwYIC4urrKuHHjDO2fffaZREREKJpZ0IYNGyQgIEDGjx8vdnZ2ZjsCVBSlv6dqbNP7mWvdioi8+uqrYmdnJyEhIeLo6Ch6vV7s7e1Fr9dLo0aNJCMjQ9E8tfa7Iuosq7n3u2rvG8z52eUYoDJ4//33MWbMGDg7O5s198iRI7Czsyv21uDx8fGwtbVF7969FcsseOm5q6srKlWqZJhetGgRAGDAgAGKZQJ3HxGxePHiQjdZi4iIQL9+/RS/+aIa6zYnJwd5eXlm/xytXbvWcDO5Dh06GN1s8eLFiwBgtI1N4eLFixg2bBg2bdqEXbt2oU6dOopnqPE9VWub3s8c6/ae1NRUrF69GidOnDC6OWDbtm0VH4+j1n73HnMuq1r7XbX3Deb67LIAIiIiIs3hjRBN6M6dO0hPT1e7G1bn3LlzXK9EVK7k5uZyv2RhWACZ0MGDB03zBFsAc+fORdu2bdG7d29s3LjRqO3ChQuoXr26xWdeu3YN//nPfxAYGIiBAwfi9u3biIqKgo+PD4KDg9GiRQtkZWUpmgloY92qlalWLjOZaWopKSkm2d9rZf2qkckCyAJ98sknGDNmDEJCQuDg4IBOnTph2rRphva8vDzFHxehRubbb7+NpKQkvPnmm0hPT0fv3r2xZcsWbN26FZs3b8alS5cwY8YMRTO1sm7VyFQrl5nMtFRaWb+qbVOTDa/WgAYNGpT4CgkJMcmlrmFhYbJkyRLD9I4dO6Rq1aqGe19kZmYqnqtGpr+/v2zcuFFERM6cOSM6nU5+/vlnQ/uvv/4qderUUTRTK+tWjUy1cpnJTCWosb/XyvpVa5vaKl9SaUdKSgpeeOGFYg97ZmRk4MiRI4rnpqWloUmTJobpiIgIbNy4EW3atEFubi6io6OtIvP8+fOoWbMmAMDX1xdOTk5GVwPUrVsXp0+fVjRTK+tWjUy1cpnJTCWosb/XyvpVa5uyACqD8PBwPPXUUxgxYkSR7cnJyfjyyy8Vz61cuTJOnz6NoKAgw7y6deti48aNaN26taKPhlAzs1KlSvj333/h7+8PAOjevTs8PT0N7dnZ2XBwcFA0UyvrVo1MtXKZyUwlqLG/18r6VWubcgxQGTzzzDM4fPhwse1ubm5Gz4pRMvfHH38sND8sLAwbNmzAunXrrCLzscceQ2JiomE6Pj4eVatWNUwnJiYiNDRU0UytrFs1MtXKZSYzlco19/5eK+tXrW3KMUAWaN++fTJ//vxi2w8cOCATJ060+MyLFy/K5cuXi21fs2aNbNq0SdFMraxbNTLVymUmMy2VVtavWtuUN0IkIiIizeEYIAUcPXoUO3bsQGZmJnQ6Hby8vNCkSRPUqlXL6nK1klmc69evIykpySSnNrXq8uXLOHbsGHx8fODn52cVmUlJSWjYsKHi78vMB9PCd/Sll17ClClT4Ovra5Y8c39Hr1y5gh9++AHp6ekIDAzE888/Dw8PD+WDFD+mpCFXrlyRbt26iU6nE09PT6ldu7bUqlVLPD09Ra/XS/fu3eXq1atWkauVzAdJTk5W/HLM27dvy5gxY6RGjRrSuHHjQoeCTXEJqBqZIiLjx4+X69evG/owbNgww8Me9Xq99OzZU27evGnxmTqdTqpXry5TpkyRf/75R9H31nrmg5jiOyqizndm3759Rb7s7Oxk5cqVhmklqfF9efbZZ+XHH38UEZGDBw9K5cqVpUqVKvLUU0+Jl5eXeHt7S0pKiqKZInwafJn0799f6tWrJ7t27SrUtmvXLnnsscdkwIABVpGrlcwHMcXO9b333hMvLy+ZOXOmTJgwQTw8POS///2voT0zM1N0Op3FZ4qI6PV6w5O8p0yZIlWqVJEff/xRzpw5I7/88otUq1ZNYmJiLD5Tp9PJsGHDxMvLS2xtbaVz586ycuVKuXPnjqI5Wsx8EFMVQGp8Zwo+Df7+1/1FiZLU+L5UrlxZjhw5IiIikZGR0q9fP8nJyRGRu0XYkCFDpH379opmirAAKhMPD48ifznfs3PnTvHw8LCKXK1kVqhQocSXu7u74jucmjVryi+//GKYPnbsmNSqVUsGDRok+fn5JvnLUo1Mkbs79Hs71/r168vXX39t1L506VIJDQ21mszc3FxZvny5dOrUSWxsbMTLy0vGjh0rhw4dUjRPS5lqfEdF1PnOPP7449K5c2dJTU2VkydPysmTJyUtLU1sbW0lISHBME9JanxfnJyc5NixYyIi4uPjI3v27DFqP3z4sEl+l3IMUBnpdLpHarPEXC1k5uTkYMSIEahXr16R7adOncL777+vaOaZM2cQHh5umK5RowY2b96M1q1bo3///vjggw8UzVMr85572+306dN48sknjdqefPJJk9zyXo1MALC1tcWzzz6LZ599FmfOnMH8+fOxcOFCfPjhh2jatCm2bNnCzIekxncUUOc789dff2Hs2LF49tlnsXjxYjRo0MDQ5uvri8DAQMUzAfN/Xx577DFs3LgRNWrUgLe3N06dOmW0rKdOnYKTk5OimQA4Bqgs/vOf/8hjjz0miYmJhdoSExOlfv360r9/f6vI1UpmkyZNJDY2tth2UxxeDw4Olt9//73Q/DNnzkjt2rWlbdu2VpEpcvevyylTpsjHH38svr6+smXLFqP25ORkqVChgsVn3n8aoSi///679OvXj5mPQI3vqIh63xmRu7f88PPzk6lTp0peXp7Y2trKwYMHTZKlxvdl9erVUrFiRVmwYIEsWLBAgoKC5KuvvpLt27fL/Pnzxd/fX8aMGaNopghPgZXJ5cuXpWPHjqLT6aRChQpSp04dCQkJkQoVKoher5fIyMgS72NjSblayZwyZUqJ95tIT0+XQYMGKZo5ZMgQGTx4cJFt//zzj9SsWVPxHasamSIigYGBEhQUZHgV/EU2e/Zsefrppy0+8/7TCOailUw1vqMi6n1n7snMzJTIyEh55plnTFoAqfF9ERFZvny5+Pn5FRrz5OjoKNHR0SYZV8b7ACng0KFD2LlzJzIzMwEA3t7eiIiIQEhIiNXlaiXTnE6dOoVDhw6hQ4cORbZnZGTgt99+w8CBAy06szR27doFBwcHo8Pflpj5xx9/oGnTprC1Nd8oA61kqqW8fGc++eQTbNq0CZ9++qnZbhtxP1N+R/Py8rBnzx6cOHEC+fn58PHxQcOGDeHm5qZ4FgCwACIiIiLN4bPATOjy5ctYtGiRJnKZyUxLzWUmMy01l5llpPhJNTIw1WC88pjLTGZaai4zmWmpucwsG+s/cWtCWVlZJbZfu3bNanKZyUxLzWUmMy01l5mmywQ4BqhM9Hp9ifeiERHodDrk5eVZfC4zmWmpucxkpqXmMtN0mQAfhlombm5umDBhAp566qki248ePYqXX37ZKnKZyUxLzWUmMy01l5mmywRYAJXJE088AQBo0aJFke2enp4wxQE2NXKZyUxLzWUmMy01l5mmywR4FViZ9OvXD46OjsW2e3t747333rOKXGYy01JzmclMS81lpukyAY4BIiIiIg3iESAiIiLSHI4BKqPr168jPj4eO3bsQGZmJnQ6Hby8vNC0aVP07dsXLi4uVpPLTGZaai4zmWmpucw0XSZPgZVBSkoK2rVrhxs3bqBFixbw8vKCiOD8+fP4448/4OLigt9++w1hYWEWn8tMZlpqLjOZaam5zDTtNuWdoMugZcuW8sILL0hOTk6htpycHOnbt6+0bNnSKnKZyUxLzWUmMy01l5mm3aYsgMrAyclJDh48WGz733//LU5OTlaRy0xmWmouM5lpqbnMNF2miAgHQZdBhQoVcPTo0WLbjx07hgoVKlhFLjOZaam5zGSmpeYy03SZAHgKrCzee+898fDwkJkzZ0pycrJkZGRIZmamJCcny8yZM6VChQry/vvvW0UuM5lpqbnMZKal5jLTtNuUBVAZTZ8+XXx8fESn04lerxe9Xi86nU58fHxkxowZVpXLTGZaai4zmWmpucw0XSavAlNIWloaMjMzAdy9a2VwcLDV5jKTmZaay0xmWmouM5XHAoiIiIg0h4Ogy+jmzZvYtm0bUlJSCrXdunULixYtsppcZjLTUnOZyUxLzWWmCbepSU6sacThw4clMDDQcM6yRYsWcvbsWUN7Zmam6PV6q8hlJjMtNZeZzLTUXGaaLlOEl8GXyVtvvYV69erh/PnzOHz4MNzd3dG0aVOkp6dbXS4zmWmpucxkpqXmMtO025RHgMqgatWqsn//fqN5I0eOlICAADl+/LjJqlY1cpnJTEvNZSYzLTWXmabdpnwYahncvHkTtrbGqzAuLg56vR4tWrRAfHy81eQyk5mWmstMZlpqLjNNu015BKgMGjduLIsWLSqyLSoqSjw9PU1StaqRy0xmWmouM5lpqbnMNO02ZQFUBlOnTpXIyMhi20eMGCE6nc4qcpnJTEvNZSYzLTWXmabLFOGNEImIiEiDeBUYERERaQ4LICIiItIcFkBERESkOSyAiIiISHNYABEREZHmsAAiIiIizWEBRERERJrDAoiIiIg05/8A9+tebdFQjqAAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -3630,7 +3539,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3662,7 +3571,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -3671,13 +3580,13 @@ "" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3719,7 +3628,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -3789,7 +3698,7 @@ "1454 NaN NaN NaN NaN 18484889.46 NaN NaN 500000000.0 " ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -3809,7 +3718,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -3859,22 +3768,22 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2024-02-20 13:27:01,235 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", - "2024-02-20 13:27:02,398 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", - "2024-02-20 13:27:03,922 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", - "2024-02-20 13:27:05,573 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + "2025-04-25 14:27:18,449 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2025-04-25 14:27:20,708 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2025-04-25 14:27:23,082 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2025-04-25 14:27:25,550 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3884,7 +3793,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3908,33 +3817,32 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2024-02-20 13:27:12,398 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", - "2024-02-20 13:27:13,605 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", - "2024-02-20 13:27:14,991 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", - "2024-02-20 13:27:16,771 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", - "2024-02-20 13:27:18,916 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + "2025-04-25 14:27:38,008 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2025-04-25 14:27:40,210 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2025-04-25 14:27:42,394 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2025-04-25 14:27:44,707 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" ] }, { "data": { "text/plain": [ - "{'scale': 0.9893201575415296, 'v_half': 46.03113797418196}" + "{'scale': 1.0, 'v_half': 44.48812601602297}" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3944,7 +3852,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3966,32 +3874,32 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2024-02-20 13:27:25,785 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", - "2024-02-20 13:27:26,845 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", - "2024-02-20 13:27:26,845 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", - "2024-02-20 13:27:28,241 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + "2025-04-25 14:27:58,736 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2025-04-25 14:28:01,264 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2025-04-25 14:28:04,332 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2025-04-25 14:28:07,387 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" ] }, { "data": { "text/plain": [ - "{'scale': 0.07120177027571553, 'v_half': 134.9655530108171}" + "{'scale': 0.029173288291594105, 'v_half': 110.11137319113446}" ] }, - "execution_count": 29, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -4001,7 +3909,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -4045,11 +3953,768 @@ "4. Calibrate different impact functions for houses in Mexico and Puerto Rico within the same optimization task.\n", "5. Employ the {py:class}`~climada.util.calibrate.scipy_optimizer.ScipyMinimizeOptimizer` instead of the `BayesianOptimizer`." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ensemble Calibration\n", + "\n", + "The parameter space of a single calibration task gives an estimate of the uncertainty within that calibration.\n", + "However, it only gives limited information on the uncertainty stemming from the model setup and impact data provided.\n", + "To estimate the full model-chain uncertainty, we provide additional method for calibrating ensembles of impact functions based on subsets of the full impact data.\n", + "\n", + "We define two types of ensembles and hence calibration tasks:\n", + "* The *average ensemble* (AE) collects impact functions that are calibrated on sampled subsets of the impact data.\n", + "* The *ensemble of tragedies* (EoT) collects impact functions that are calibrated on a single impact record each.\n", + "\n", + "We provide two classes that calibrate these types of ensembles, namely {py:class}`~climada.util.calibrate.ensemble.AverageEnsembleOptimizer` and {py:class}`~climada.util.calibrate.ensemble.TragedyEnsembleOptimizer`.\n", + "These classes define how the impact data is sampled for each individual impact function calibration task, and then defer this task to an underlying optimizer (which we showcased before).\n", + "Both take {py:class}`~climada.util.calibrate.base.Input` object that could also be used in a single calibration optimizer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Average Ensemble\n", + "\n", + "For each calibration of the AE, we sample the impact data by drawing a fraction of all impact values.\n", + "In this case, let's draw the default 80% with an ensemble size of 5, meaning that we compute 5 distinct impact functions.\n", + "As underlying optimizer, we again choose the {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizer`.\n", + "The {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController` is passed via the ``optimizer_run_kwargs`` argument of {py:meth}`~climada.util.calibrate.ensemble.EnsembleOptimizer.run`.\n", + "Note that you must provide the *type* of the underlying optimizer when constructing an `EnsembleOptimizer`." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [02:03<00:00, 12.38s/it]\n" + ] + } + ], + "source": [ + "from climada.util.calibrate import (\n", + " Input,\n", + " AverageEnsembleOptimizer,\n", + " BayesianOptimizer,\n", + " BayesianOptimizerController,\n", + ")\n", + "from climada.util import log_level\n", + "\n", + "from sklearn.metrics import mean_squared_log_error\n", + "\n", + "# Define calibration input\n", + "with log_level(\"WARNING\", name_prefix=\"climada.util.calibrate\"):\n", + " input = Input(\n", + " hazard=hazard,\n", + " exposure=exposure,\n", + " data=data,\n", + " impact_func_creator=impact_func_tc,\n", + " cost_func=mean_squared_log_error,\n", + " impact_to_dataframe=lambda imp: imp.impact_at_reg(exposure.gdf[\"region_id\"]),\n", + " bounds=bounds,\n", + " )\n", + "\n", + " # Create and run the optimizer\n", + " opt_ae = AverageEnsembleOptimizer(\n", + " input, optimizer_type=BayesianOptimizer, ensemble_size=10\n", + " )\n", + " controller = BayesianOptimizerController.from_input(input)\n", + " output_ae = opt_ae.run(controller=controller)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The output of an ensemble optimizer is different from that of a single optimizer.\n", + "Instead of the parameter space for each optimization we only provide the best estimate of each iteration, along with some information on the events and regions the particular function was calibrated on.\n", + "We also provide methods for plotting the resulting ensemble of impact functions." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "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", + " \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", + " \n", + " \n", + "
ParametersEvent
scalev_halfevent_idregion_idevent_name
00.83749946.461399[1333, 1339, 1344, 1351, 1361, 3686, 3691, 374...[28, 44, 92, 132, 212, 214, 484, 630, 659, 662...[2010176N16278, 2010236N12341, 2010257N16282, ...
10.23900941.636576[1339, 1351, 1361, 3686, 3691, 1377, 1390, 374...[28, 44, 132, 192, 212, 214, 388, 484, 630, 65...[2010236N12341, 2010302N09306, 2011233N15301, ...
20.10465430.352453[1333, 1339, 1344, 1351, 1361, 3686, 3691, 137...[28, 44, 92, 132, 192, 212, 214, 388, 484, 630...[2010176N16278, 2010236N12341, 2010257N16282, ...
30.88012547.469999[1333, 1344, 1351, 1361, 3691, 1377, 1390, 142...[28, 44, 92, 132, 192, 212, 214, 388, 484, 630...[2010176N16278, 2010257N16282, 2010302N09306, ...
41.00000052.683885[1333, 1339, 1344, 1351, 1361, 3691, 1377, 139...[28, 44, 92, 132, 212, 214, 388, 484, 630, 662...[2010176N16278, 2010236N12341, 2010257N16282, ...
51.00000054.416034[1333, 1339, 1344, 1351, 1361, 3691, 1377, 374...[28, 44, 92, 132, 192, 212, 214, 484, 630, 659...[2010176N16278, 2010236N12341, 2010257N16282, ...
61.00000051.411454[1339, 1344, 1361, 3686, 3691, 1390, 3743, 142...[28, 44, 92, 132, 192, 212, 214, 388, 484, 630...[2010236N12341, 2010257N16282, 2011233N15301, ...
71.00000061.782055[1339, 1344, 1351, 1361, 1377, 1390, 3743, 142...[28, 44, 92, 192, 212, 214, 388, 484, 630, 659...[2010236N12341, 2010257N16282, 2010302N09306, ...
81.00000054.942273[1333, 1351, 1361, 3686, 3691, 1377, 1390, 142...[28, 44, 92, 192, 212, 214, 388, 484, 630, 659...[2010176N16278, 2010302N09306, 2011233N15301, ...
90.09419430.650607[1333, 1339, 1344, 1351, 1361, 3686, 3691, 139...[28, 44, 92, 132, 214, 388, 484, 630, 659, 670...[2010176N16278, 2010236N12341, 2010257N16282, ...
\n", + "
" + ], + "text/plain": [ + " Parameters Event \\\n", + " scale v_half event_id \n", + "0 0.837499 46.461399 [1333, 1339, 1344, 1351, 1361, 3686, 3691, 374... \n", + "1 0.239009 41.636576 [1339, 1351, 1361, 3686, 3691, 1377, 1390, 374... \n", + "2 0.104654 30.352453 [1333, 1339, 1344, 1351, 1361, 3686, 3691, 137... \n", + "3 0.880125 47.469999 [1333, 1344, 1351, 1361, 3691, 1377, 1390, 142... \n", + "4 1.000000 52.683885 [1333, 1339, 1344, 1351, 1361, 3691, 1377, 139... \n", + "5 1.000000 54.416034 [1333, 1339, 1344, 1351, 1361, 3691, 1377, 374... \n", + "6 1.000000 51.411454 [1339, 1344, 1361, 3686, 3691, 1390, 3743, 142... \n", + "7 1.000000 61.782055 [1339, 1344, 1351, 1361, 1377, 1390, 3743, 142... \n", + "8 1.000000 54.942273 [1333, 1351, 1361, 3686, 3691, 1377, 1390, 142... \n", + "9 0.094194 30.650607 [1333, 1339, 1344, 1351, 1361, 3686, 3691, 139... \n", + "\n", + " \\\n", + " region_id \n", + "0 [28, 44, 92, 132, 212, 214, 484, 630, 659, 662... \n", + "1 [28, 44, 132, 192, 212, 214, 388, 484, 630, 65... \n", + "2 [28, 44, 92, 132, 192, 212, 214, 388, 484, 630... \n", + "3 [28, 44, 92, 132, 192, 212, 214, 388, 484, 630... \n", + "4 [28, 44, 92, 132, 212, 214, 388, 484, 630, 662... \n", + "5 [28, 44, 92, 132, 192, 212, 214, 484, 630, 659... \n", + "6 [28, 44, 92, 132, 192, 212, 214, 388, 484, 630... \n", + "7 [28, 44, 92, 192, 212, 214, 388, 484, 630, 659... \n", + "8 [28, 44, 92, 192, 212, 214, 388, 484, 630, 659... \n", + "9 [28, 44, 92, 132, 214, 388, 484, 630, 659, 670... \n", + "\n", + " \n", + " event_name \n", + "0 [2010176N16278, 2010236N12341, 2010257N16282, ... \n", + "1 [2010236N12341, 2010302N09306, 2011233N15301, ... \n", + "2 [2010176N16278, 2010236N12341, 2010257N16282, ... \n", + "3 [2010176N16278, 2010257N16282, 2010302N09306, ... \n", + "4 [2010176N16278, 2010236N12341, 2010257N16282, ... \n", + "5 [2010176N16278, 2010236N12341, 2010257N16282, ... \n", + "6 [2010236N12341, 2010257N16282, 2011233N15301, ... \n", + "7 [2010236N12341, 2010257N16282, 2010302N09306, ... \n", + "8 [2010176N16278, 2010302N09306, 2011233N15301, ... \n", + "9 [2010176N16278, 2010236N12341, 2010257N16282, ... " + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_ae.data" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output_ae.plot_shiny(\n", + " impact_func_creator=impact_func_tc,\n", + " haz_type=\"TC\",\n", + " impf_id=1,\n", + " inp=input,\n", + " legend=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, although each subset of the calibration data contains 80% of all impact values, the functions differ quite a lot.\n", + "We can investigate exactly which impact records cause this through the ensemble of tragedies.\n", + "It can be calibrated the same way.\n", + "By default, it computes one function for every data point in `data`." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 22%|██▏ | 6/27 [00:32<01:50, 5.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[31mData point [ 1. 25.8] is not unique. 1 duplicates registered. Continuing ...\u001b[39m\n", + "\u001b[31mData point [ 1. 25.8] is not unique. 2 duplicates registered. Continuing ...\u001b[39m\n", + "\u001b[31mData point [ 1. 25.8] is not unique. 3 duplicates registered. Continuing ...\u001b[39m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 52%|█████▏ | 14/27 [01:34<01:21, 6.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[31mData point [ 1. 25.8] is not unique. 1 duplicates registered. Continuing ...\u001b[39m\n", + "\u001b[31mData point [ 1. 25.8] is not unique. 2 duplicates registered. Continuing ...\u001b[39m\n", + "\u001b[31mData point [ 1. 25.8] is not unique. 3 duplicates registered. Continuing ...\u001b[39m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 27/27 [03:25<00:00, 7.60s/it]\n" + ] + } + ], + "source": [ + "from climada.util.calibrate import TragedyEnsembleOptimizer\n", + "\n", + "# Define calibration input\n", + "with log_level(\"WARNING\", name_prefix=\"climada.util.calibrate\"):\n", + " input = Input(\n", + " hazard=hazard,\n", + " exposure=exposure,\n", + " data=data,\n", + " impact_func_creator=impact_func_tc,\n", + " cost_func=mean_squared_log_error,\n", + " impact_to_dataframe=lambda imp: imp.impact_at_reg(exposure.gdf[\"region_id\"]),\n", + " bounds=bounds,\n", + " )\n", + "\n", + " # Create and run the optimizer\n", + " opt_eot = TragedyEnsembleOptimizer(input, optimizer_type=BayesianOptimizer)\n", + " controller = BayesianOptimizerController.from_input(input)\n", + " output_eot = opt_eot.run(controller=controller)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + "
ParametersEvent
scalev_halfevent_idregion_idevent_name
00.62391843.558467[1333][484][2010176N16278]
10.44672049.853994[1339][28][2010236N12341]
20.87034630.882206[1344][484][2010257N16282]
30.33245368.510883[1351][662][2010302N09306]
40.65966638.132968[1351][670][2010302N09306]
50.50147892.838101[1361][44][2011233N15301]
61.00000025.800000[1361][214][2011233N15301]
70.57745750.142499[1361][630][2011233N15301]
80.28560831.604609[3686][484][2011279N10257]
90.25777530.957414[3691][484][2012166N09269]
100.40981440.494643[1377][484][2012215N12313]
110.455964148.659015[1390][388][2012296N14283]
120.19040050.537864[3743][484][2014253N13260]
130.66565237.430581[1421][132][2015242N12343]
141.00000025.800000[1426][44][2015270N27291]
150.56305846.037049[3777][484][2015293N13266]
160.522021112.298359[3795][484][2016248N15255]
171.000000117.135848[1450][484][2017219N16279]
180.47391450.544738[1454][28][2017242N16333]
190.19322130.347552[1454][44][2017242N16333]
201.00000032.463875[1454][92][2017242N16333]
210.48209430.424033[1454][192][2017242N16333]
220.14212869.089890[1454][659][2017242N16333]
231.00000062.107956[1454][796][2017242N16333]
241.00000026.131008[1458][212][2017260N12310]
250.39972651.035757[1458][214][2017260N12310]
260.55483437.334453[1458][630][2017260N12310]
\n", + "
" + ], + "text/plain": [ + " Parameters Event \n", + " scale v_half event_id region_id event_name\n", + "0 0.623918 43.558467 [1333] [484] [2010176N16278]\n", + "1 0.446720 49.853994 [1339] [28] [2010236N12341]\n", + "2 0.870346 30.882206 [1344] [484] [2010257N16282]\n", + "3 0.332453 68.510883 [1351] [662] [2010302N09306]\n", + "4 0.659666 38.132968 [1351] [670] [2010302N09306]\n", + "5 0.501478 92.838101 [1361] [44] [2011233N15301]\n", + "6 1.000000 25.800000 [1361] [214] [2011233N15301]\n", + "7 0.577457 50.142499 [1361] [630] [2011233N15301]\n", + "8 0.285608 31.604609 [3686] [484] [2011279N10257]\n", + "9 0.257775 30.957414 [3691] [484] [2012166N09269]\n", + "10 0.409814 40.494643 [1377] [484] [2012215N12313]\n", + "11 0.455964 148.659015 [1390] [388] [2012296N14283]\n", + "12 0.190400 50.537864 [3743] [484] [2014253N13260]\n", + "13 0.665652 37.430581 [1421] [132] [2015242N12343]\n", + "14 1.000000 25.800000 [1426] [44] [2015270N27291]\n", + "15 0.563058 46.037049 [3777] [484] [2015293N13266]\n", + "16 0.522021 112.298359 [3795] [484] [2016248N15255]\n", + "17 1.000000 117.135848 [1450] [484] [2017219N16279]\n", + "18 0.473914 50.544738 [1454] [28] [2017242N16333]\n", + "19 0.193221 30.347552 [1454] [44] [2017242N16333]\n", + "20 1.000000 32.463875 [1454] [92] [2017242N16333]\n", + "21 0.482094 30.424033 [1454] [192] [2017242N16333]\n", + "22 0.142128 69.089890 [1454] [659] [2017242N16333]\n", + "23 1.000000 62.107956 [1454] [796] [2017242N16333]\n", + "24 1.000000 26.131008 [1458] [212] [2017260N12310]\n", + "25 0.399726 51.035757 [1458] [214] [2017260N12310]\n", + "26 0.554834 37.334453 [1458] [630] [2017260N12310]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_eot.data" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output_eot.plot_shiny(\n", + " impact_func_creator=impact_func_tc,\n", + " haz_type=\"TC\",\n", + " impf_id=1,\n", + " inp=input,\n", + " legend=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `plot_category` function helps to differentiate between impact functions by plotting functions of one category with the same color.\n", + "Any data in the `Event` column of the `data` attribute in the output data may be used." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAG2CAYAAAC50Np4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA5JBJREFUeJzs3XdgU1XfwPFvdncL3aVA2XuDqEwFQUVx40AREeURfAFRcSsueEBFFBQFB4jiFh8ngiDI3ntv2kJbSvfKuvf9I03aQgttmrYp/D7Pmzc3596cnFQgv578zu9oVFVVEUIIIYQQQpSbtqYHIIQQQgghRG0jQbQQQgghhBAVJEG0EEIIIYQQFSRBtBBCCCGEEBUkQbQQQgghhBAVJEG0EEIIIYQQFSRBtBBCCCGEEBUkQbQQQgghhBAVJEG0EEIIIYQQFSRBtBBCCCGEEBVUo0H0v//+y80330xMTAwajYaff/65xHlVVZk0aRIxMTH4+vrSt29f9uzZU+Ias9nM//3f/xEWFoa/vz+DBw8mISGhxPkHHniAoKAgWrRowfLly0s8f9q0afzf//1flb1HIYQQQghx6anRIDo3N5cOHTowa9asUs9PmzaN6dOnM2vWLDZt2kRUVBTXXXcd2dnZrmvGjx/PokWL+Oabb1i9ejU5OTncdNNN2O12AObMmcOWLVtYt24djzzyCPfeey+qqgJw7NgxPvnkE958882qf7NCCCGEEOKSoVGdEWUN02g0LFq0iFtvvRVwzELHxMQwfvx4nnnmGcAxqxwZGcnUqVMZNWoUmZmZhIeHs2DBAu6++24ATp06Rf369fnjjz8YOHAgo0ePJigoiP/+97/k5+fj5+dHSkoK4eHhXH/99YwaNYrbbrutpt62EEIIIYSohfQ1PYCyHDt2jKSkJAYMGOBqM5lM9OnTh7Vr1zJq1Ci2bNmC1WotcU1MTAxt27Zl7dq1DBw4kA4dOrBgwQLy8/P566+/iI6OJiwsjC+//BIfH59yB9Bmsxmz2ex6rCgKaWlphIaGotFoPPfGhRBCCFFlVFUlOzubmJgYtFpZGibc57VBdFJSEgCRkZEl2iMjIzlx4oTrGqPRSJ06dc67xvn8ESNGsHPnTlq3bk1YWBjfffcd6enpvPLKK/zzzz+8+OKLfPPNNzRp0oTPPvuMevXqlTqeKVOm8Oqrr3r6bQohhBCiBsTHxxMbG1vTwxC1mNcG0U7nzvKqqnrRmd/i1xgMBj744IMS54cPH87YsWPZvn07P//8Mzt27GDatGmMHTuWH3/8sdQ+n3vuOSZMmOB6nJmZSYMGDYiPjycoKMidtyYuVZ9cB2f2wfXTILZrTY9GCCFqL9+6EBDm0S6zsrKoX78+gYGBHu23usXFxTF+/HjGjx9fLa/Xt29fOnbsyIwZM7xmTDXNa4PoqKgowDHbHB0d7WpPSUlxzU5HRUVhsVhIT08vMRudkpLC1VdfXWq/y5cvZ+/evXz66ac8/fTT3Hjjjfj7+zNkyJAyFziCI5XEZDKd1x4UFCRBtChJmw8mDTTuDPUliBZCCG9U21MxN23ahL+/f7W93k8//YTBYKi216tOw4cPJyMj47wqcRfjtclAjRo1IioqiqVLl7raLBYLK1eudAXIXbp0wWAwlLjm9OnT7N69u9QguqCggDFjxvDxxx+j0+mw2+1YrVYArFarq6KHEJViyXHcGwNqdhxCCCG8isVi8Vhf4eHh+Pn5eay/i6lbt26tn733tBoNonNycti+fTvbt28HHIsJt2/fzsmTJ9FoNIwfP57JkyezaNEidu/ezfDhw/Hz8+O+++4DIDg4mIcffpgnn3ySZcuWsW3bNu6//37atWtH//79z3u91157jUGDBtGpUycAevTowU8//cTOnTuZNWsWPXr0qLb3Li5h5sIg2iRBtBBCXM769u3L448/zoQJEwgLC+O6664DYO/evdx4440EBAQQGRnJAw88QGpqqut52dnZDB06FH9/f6Kjo3n33Xfp27dviTSJuLi4EqkVJ0+e5JZbbiEgIICgoCCGDBlCcnKy6/ykSZPo2LEjCxYsIC4ujuDgYO65554SZYMv9l6Kv35KSgo333wzvr6+NGrUiK+++sqtn9GePXsYNGgQQUFBBAYG0qtXL44cOQI4iji89tprxMbGYjKZ6NixI4sXL3Y9d8WKFWg0GjIyMlxt27dvR6PRcPz4cQDmzZtHSEgIf/31F61atSIgIIDrr7+e06dPu34u8+fP53//+x8ajQaNRsOKFSvKNfYaDaI3b95Mp06dXEHthAkT6NSpEy+//DIAEydOZPz48YwePZquXbuSmJjIkiVLSvwm9O6773LrrbcyZMgQevTogZ+fH7/++is6na7Ea+3evZvvv/++xOLAO++8k0GDBtGrVy927tzJe++9Vw3vWlzS7FawF1ZxkZloIYS47M2fPx+9Xs+aNWv4+OOPOX36NH369KFjx45s3ryZxYsXk5yczJAhQ1zPmTBhAmvWrOGXX35h6dKlrFq1iq1bt5b5Gqqqcuutt5KWlsbKlStZunQpR44ccZX/dTpy5Ag///wzv/32G7/99hsrV67kv//9r1vva/jw4Rw/fpzly5fzww8/8OGHH5KSklKhPhITE+nduzc+Pj4sX76cLVu2MGLECGw2GwDvvfce77zzDm+//TY7d+5k4MCBDB48mEOHDlXodfLy8nj77bdZsGAB//77LydPnuSpp54C4KmnnmLIkCGuwPr06dNlpgSfRxVuyczMVAE1MzOzpocivEnuWVV9Jchxs1lqejRCCCHOUZ2f33369FE7duxYou2ll15SBwwYUKItPj5eBdQDBw6oWVlZqsFgUL///nvX+YyMDNXPz08dN26cq61hw4bqu+++q6qqqi5ZskTV6XTqyZMnXef37NmjAurGjRtVVVXVV155RfXz81OzsrJc1zz99NNq9+7dy/1enK9/4MABFVDXr1/vOr9v3z4VcI2pPJ577jm1UaNGqsVS+udlTEyM+uabb5Zo69atmzp69GhVVVX1n3/+UQE1PT3ddX7btm0qoB47dkxVVVX9/PPPVUA9fPiw65oPPvhAjYyMdD1+8MEH1VtuuaXc43by2oWFQtRKznxonQl0l+YCDCGEEOXXtWvJBeZbtmzhn3/+ISDg/G8rjxw5Qn5+PlarlSuuuMLVHhwcTIsWLcp8jX379lG/fn3q16/vamvdujUhISHs27ePbt26AY4UkOLf5kdHR1d49tj5enq9vsR7a9myJSEhIRXqZ/v27fTq1avUBYtZWVmcOnXqvFTbHj16sGPHjgq9jp+fH02aNHE9dvd9n0uCaCE8SfKhhRBCFHNuBQ1FUbj55puZOnXqeddGR0e7UhVKK/FbFrWM8r/ntp8brGo0GhRFufibKKXf0sZYUb6+vhe95kKljp2b5RT/2TgLRhRX2vu+0M+zvLy2OocQtZJU5hBCCHEBnTt3Zs+ePcTFxdG0adMSN39/f5o0aYLBYGDjxo2u52RlZV0wD7h169acPHmS+Ph4V9vevXvJzMykVatWHn8PrVq1wmazsXnzZlfbgQMHSizwK4/27duzatWqUgPfoKAgYmJiWL16dYn2tWvXut5TeHg4gGuRIOAqVlERRqPRrQptEkQL4UnmwlXOJikDJIQQ4nxjxowhLS2Ne++9l40bN3L06FGWLFnCiBEjsNvtBAYG8uCDD/L000/zzz//sGfPHkaMGIFWqy1z5rd///60b9+eoUOHsnXrVjZu3MiwYcPo06fPeekkntCiRQuuv/56HnnkETZs2MCWLVsYOXJkuWaWi3v88cfJysrinnvuYfPmzRw6dIgFCxZw4MABAJ5++mmmTp3Kt99+y4EDB3j22WfZvn0748aNA6Bp06bUr1+fSZMmcfDgQX7//XfeeeedCr+fuLg4du7cyYEDB0hNTS01qC+NBNFCeJLMRAshhLiAmJgY1qxZg91uZ+DAgbRt25Zx48YRHBzsSk+YPn06V111FTfddBP9+/enR48etGrVCh8fn1L71Gg0/Pzzz9SpU4fevXvTv39/GjduzLfffltl7+Pzzz+nfv369OnTh9tvv51HH32UiIiIEtcMHz6cvn37ltlHaGgoy5cvJycnhz59+tClSxfmzp3rSr8YO3YsTz75JE8++STt2rVj8eLF/PLLLzRr1gxwpGl8/fXX7N+/nw4dOjB16lTeeOONCr+XRx55hBYtWtC1a1fCw8NZs2ZNuZ6nUT2RFHIZysrKIjg4mMzMTNmxUBTZ9hX8bzQ07Q/3l76FvBBCiJpTGz+/c3NzqVevHu+88w4PP/xwTQ+n3Pr27Uvfvn2ZNGlSTQ+lSsjCQiE8SWaihRBCVNK2bdvYv38/V1xxBZmZmbz22msA3HLLLTU8svLLzs7myJEj/PbbbzU9lCojQbQQnuTKiZYgWgghhPvefvttDhw4gNFopEuXLqxatYqwsLAqea2TJ0/SunXrMs/v3buXBg0aVKjPwMDAEgsdL0USRAvhSa6ZaFlYKIQQwj2dOnViy5Yt1fZ6MTExF6xqERMTU21jqU0kiBbCk6ROtBBCiFpGr9fTtGnTmh5GrSPVOYTwJOdMtJS4E0IIIS5pEkQL4UnOnGhZWCiEEEJc0iSIFsKTZCZaCCGEuCxIEC2EJ5mlxJ0QQghxOZAgWghPssjCQiGEEOJyIEG0EJ4kM9FCCCHEZUGCaCE8yeLcbEVyooUQQlzapkyZgkajYfz48SXac3JyePzxx4mNjcXX15dWrVoxe/bsUvtQVZUbbrgBjUbDzz//XOExfPfdd3Ts2BE/Pz8aNmzIW2+95cY7cY/UiRbCU1RVZqKFEEJcFjZt2sScOXNo3779eeeeeOIJ/vnnH7788kvi4uJYsmQJo0ePJiYm5ryty2fMmIFGo3FrDH/++SdDhw5l5syZDBgwgH379jFy5Eh8fX15/PHH3eqzImQmWghPsRWAanccS060EEKIClBVlTyLrUZuqqpWaKw5OTkMHTqUuXPnUqdOnfPOr1u3jgcffJC+ffsSFxfHo48+SocOHdi8eXOJ63bs2MH06dP57LPP3PqZLViwgFtvvZX//Oc/NG7cmEGDBvHMM88wderUCr8nd8hMtBCe4pyFBjD419w4hBBC1Dr5VjutX/6rRl5772sD8TOWPyQcM2YMgwYNon///rzxxhvnne/Zsye//PILI0aMICYmhhUrVnDw4EHee+891zV5eXnce++9zJo1i6ioKLfGbTab8fPzK9Hm6+tLQkICJ06cIC4uzq1+y0tmooXwFEuxjVa08ldLCCHEpeebb75h69atTJkypcxr3n//fVq3bk1sbCxGo5Hrr7+eDz/8kJ49e7queeKJJ7j66qvPS++oiIEDB/LTTz+xbNkyFEXh4MGDzJgxA4DTp0+73W95yUy0EJ4i+dBCCCHc5GvQsfe1gTX22uURHx/PuHHjWLJkCT4+PmVe9/7777N+/Xp++eUXGjZsyL///svo0aOJjo6mf//+/PLLLyxfvpxt27ZVatyPPPIIR44c4aabbsJqtRIUFMS4ceOYNGkSOl353lNlaNTqSBq5BGVlZREcHExmZiZBQUE1PRzhDU6shc9vgNCm8H9bano0QgghSiGf3+77+eefue2220oEqHa7HY1Gg1arxWw2Y7FYCA4OZtGiRQwaNMh13ciRI0lISGDx4sWMHz+e999/H22xb23tdjtarZZevXqxYsWKCo3LbreTlJREeHg4y5Yt48YbbyQ5OZmIiIhKv+cLkZloITxFZqKFEEJcwvr168euXbtKtD300EO0bNmSZ555Bp1Oh9VqxWq1lgiQAXQ6HYqiAPDss88ycuTIEufbtWvHu+++y80331zhcel0OurVqwfA119/zVVXXVXlATRIEC2E50iNaCGEEJewwMBA2rZtW6LN39+f0NBQV3tQUBB9+vTh6aefxtfXl4YNG7Jy5Uq++OILpk+fDkBUVFSpiwkbNGhAo0aNyj2e1NRUfvjhB/r27UtBQQGff/4533//PStXrqzEuyw/Wf0khKfITLQQQgjBN998Q7du3Rg6dCitW7fmv//9L2+++Sb/+c9/KtRP3759GT58+AWvmT9/Pl27dqVHjx7s2bOHFStWcMUVV1Ri9OUnM9FCeIqlMIiWGtFCCCEuE6XlL0dFRfH5559XqJ/SlugdP378gkF0WFgY69atq9DreJLMRAvhKTITLYQQQnjE/v37CQwMZNiwYTU9lDLJTLQQnuLKiZYgWgghhKiMli1bnreI0dvITLQQnuKaiZaFhUIIIcSlToJoITxFcqKFEEKIy4YE0UJ4iuRECyGEEJcNCaKF8BSZiRZCCCEuGxJEC+Ep5sKFhZITLYQQQlzyJIgWwlNkJloIIYS4bEgQLYSnSE60EEIIcdmQIFoIT5GZaCGEEOKyIUG0EJ6gKEVBtORECyGEuAxMmTIFjUbD+PHjy7xm1KhRaDQaZsyYUaG+z549y/XXX09MTAwmk4n69evz+OOPk5WVVblBe5AE0UJ4gjW36FhmooUQQlziNm3axJw5c2jfvn2Z1/z8889s2LCBmJiYCvev1Wq55ZZb+OWXXzh48CDz5s3j77//5j//+U9lhu1Rsu23EJ7gzIfW6EDvU7NjEUIIUfuoKljzaua1DX6g0ZT78pycHIYOHcrcuXN54403Sr0mMTGRxx9/nL/++otBgwZVeEh16tThsccecz1u2LAho0eP5q233qpwX1VFgmghPKF4PnQF/iEStYuiqFgVBZtdxWYvOrbaFWyKis11X/w6R5tdVVEUFbuioqgqdoUSba5jtfDxOdcqhecV1XGsqkXHikrh4+Lnueg1OK/F8fmtUtSuoqIojnvnOVUteawUO8bVh/O1i47BcR1qKf0Ve23nxYVPcfXhOi7Wl/M1KevaEudK9lv8pFrWNRR/PfX8tpIvX/ZrnXOtyvnjLmVYZbxG2c8t7fnFx3Oh68p6L2U9v6zXuvAJty5jZK9GjO/fvJxX13LWPJhc8Rlbj3j+FBj9y335mDFjGDRoEP379y81iFYUhQceeICnn36aNm3aeGSIp06d4qeffqJPnz4e6c8TJIgWwhOkRnSNUFWVAqtCRr6FjDwr2QU28q12CgpvZqtCgc35WCl2TsFstReeU1zXFxReb7YqmG2KIzi2K1gLA2SlvJ/8QgiPsNiUmh6COMc333zD1q1b2bRpU5nXTJ06Fb1ez9ixYyv9evfeey//+9//yM/P5+abb+aTTz6pdJ+eIkG0EJ4glTkqRVVVss02MvOsZORZXUFxRr6VzDzHcWa+83HJ8zX9IavTatBrNRh0WvQ6DXqtFoNOg16nwaB1tOm0WnRa0Gk0aLWaEvc6rfPY0Ze2WJv+nGu1WtBqNIU30BQ71mo1aDSgofDxBa7RajRoKLwv/OJE47y+8FhT+FzH46LnOF/j3PPF2539Fb8e17HzyxpNsccl+yk86zxw3WkKTzq/6zm37+LnuNC54n2dc05TvIOLPbdEW7Hjc557rnPbNcV6Ou/cBa694GuU3nyBL8rK/gat4q9xgb4q+BpBPoYy+7rkGPwcM8I19drlEB8fz7hx41iyZAk+PqWnLm7ZsoX33nuPrVu3XvDPQnm9++67vPLKKxw4cIDnn3+eCRMm8OGHH1a6X0/QqGV9VyMuKCsri+DgYDIzMwkKCqrp4Yiatv8P+OZeqNcVHllW06PxSoqikpiRz+GUHA6lZHM4JYfDKTmcOJtHRr4VeyWmeQ06DcG+RoJ89PgYdPgYtIX3hcd6HaZi7b7Fr9HrMBW/Xu84NuoLg+HCQNig06LXatDritoNOo1HPiSEENVHPr/d9/PPP3Pbbbeh0+lcbXa73fFLuFaL2Wxm5syZTJgwAa1WW+IarVZL/fr1OX78uNuvv3r1anr16sWpU6eIjo6uzFvxCJmJFsITZCbaxWJTOH421xUkO29HU3MosF541tjHoCXE10iIn4FgXwMhfoaix8WOQ3wLH/sZCfE14GfUSTArhBBVrF+/fuzatatE20MPPUTLli155pln0Ol0PPDAA/Tv37/ENQMHDuSBBx7goYceqtTrO+d9zWZzpfrxFAmihfAEV0705RNE55ptHDlTFCQfSsnhSEoOJ9LyypxVNuq0NA73p0lEAE3DA2gaEUDjcH/CAkwE+xrwMehKfZ4QQoiaFxgYSNu2bUu0+fv7Exoa6moPDQ0lNDS0xDUGg4GoqChatGhR7tf6448/SE5Oplu3bgQEBLB3714mTpxIjx49iIuLq/R78QQJooXwBNdM9KW9sDAzz8pXG0/w7aZ4TpwtuxRTgElfIlB23urX8UWvk/L0QghxuRs+fDjHjx9nxYoVpZ739fVl7ty5PPHEE5jNZurXr8/tt9/Os88+W70DvQAJooXwBGed6Et0Jjo+LY/P1hzj203x5FnsrvawACNNCgPlZhEBNI0IpGlEAJFBJkmvEEKIy0BZQXBxpeVBHz9+nL59+5b5nGuuuYa1a9e6P7BqIEG0EJ5wieZE70zIYM6/R/lj12lXebeWUYGM7NWY/q0iCPEz1uwAhRBC1DrZ2dkcOXKE3377raaHUikSRAvhCZdQTrSiqCzfn8LcVUfZcCzN1d6rWRiP9m5Mz6ZhMssshBDCbYGBgcTHx9f0MCpNgmghPOESyIkusNpZtC2RuauOcvRMLgB6rYbBHWMY2bMxrWOkFJQQQgjhJEG0EJ5Qi3Oi03ItfLn+BF+sO05qjgWAQJOe+65swPCr44gO9q3hEQohhBDeR4JoITyhFuZEH0/N5dPVx/h+S7yrfnO9EF8e6hHH3d3qE3g57RQmhBBCVJAE0UJ4Qi2aid5yIo05/x5lyd5knPuVtq0XxKO9m3Bj2ygpQSeEEEKUgwTRQniCpXBhoRfnRK84kML7yw6x9WSGq+3alhE80qsxVzauK4sFhRBCiAqQIFoIT/DymeiNx9IY/vkmwLFr4G2d6jGyVyOaRXpv0C+EEEJ4MwmihfAEL86JVhSV137bA8DANpG8fmtbIgJ9anhUQgghRO0myY9CVJbdBrYCx7EXzkT/sDWB3YlZBJr0TL6tnQTQQgghKiUxMZH777+f0NBQ/Pz86NixI1u2bHGdnzRpEi1btsTf3586derQv39/NmzYUKIPs9nM//3f/xEWFoa/vz+DBw8mISGhQuNYsWIFt9xyC9HR0fj7+9OxY0e++uorj7zH8pAgWojKcuZDg9flROeYbbz11wEAxvZrRmiAqYZHJIQQojZLT0+nR48eGAwG/vzzT/bu3cs777xDSEiI65rmzZsza9Ysdu3axerVq4mLi2PAgAGcOXPGdc348eNZtGgR33zzDatXryYnJ4ebbroJu91e7rGsXbuW9u3b8+OPP7Jz505GjBjBsGHD+PXXXz35lsukUVXn+nxREVlZWQQHB5OZmUlQkGxCcVnLiIcZbUFngpdSano0JUxbvJ8PVxwhLtSPJU/0waiX35uFEJc3+fyunGeffZY1a9awatWqcj/H+TP/+++/6devH5mZmYSHh7NgwQLuvvtuAE6dOkX9+vX5448/GDhwoNvjGzRoEJGRkXz22Wdu91Fe8okqRGV5aT50fFoen6w+BsALg1pLAC2EEF5MVVXyrHk1cqvIfOovv/xC165dueuuu4iIiKBTp07MnTu3zOstFgtz5swhODiYDh06ALBlyxasVisDBgxwXRcTE0Pbtm1Zu3at+z9EIDMzk7p161aqj/KShYVCVJaXVuaY8uc+LDaFnk3D6N8qoqaHI4QQ4gLybfl0X9i9Rl57w30b8DP4levao0ePMnv2bCZMmMDzzz/Pxo0bGTt2LCaTiWHDhrmu++2337jnnnvIy8sjOjqapUuXEhYWBkBSUhJGo5E6deqU6DsyMpKkpCS338cPP/zApk2b+Pjjj93uoyIkiBaisrywRvT6o2f5Y1cSWg28eFMrqQEthBDCIxRFoWvXrkyePBmATp06sWfPHmbPnl0iiL7mmmvYvn07qampzJ07lyFDhrBhwwYiIsqe1FFV1e3PqxUrVjB8+HDmzp1LmzZt3Oqjorw6iLbZbEyaNImvvvqKpKQkoqOjGT58OC+++CJareOraVVVefXVV5kzZw7p6el0796dDz74oMQPcMKECcybN4+AgACmTZvGPffc4zr33XffsWDBgmpLQheXIHNhEO0lM9F2ReX13/YCcF/3BrSMkpw/IYTwdr56Xzbct+HiF1bRa5dXdHQ0rVu3LtHWqlUrfvzxxxJt/v7+NG3alKZNm3LllVfSrFkzPv30U5577jmioqKwWCykp6eXmI1OSUnh6quvrvD4V65cyc0338z06dNLBPJVzauD6KlTp/LRRx8xf/582rRpw+bNm3nooYcIDg5m3LhxAEybNo3p06czb948mjdvzhtvvMF1113HgQMHCAwM5Ndff2XhwoUsWbKEQ4cO8dBDD3HdddcRGhpKRkYGL7zwAsuWLavhdypqNbN35UT/sCWePaeyCPTR80T/5jU9HCGEEOWg0WjKnVJRk3r06MGBAwdKtB08eJCGDRte8HmqqmI2mwHo0qULBoOBpUuXMmTIEABOnz7N7t27mTZtWoXGs2LFCm666SamTp3Ko48+WqHnVpZXrzRat24dt9xyC4MGDSIuLo4777yTAQMGsHnzZsDxH2TGjBm88MIL3H777bRt25b58+eTl5fHwoULAdi3bx99+/ala9eu3HvvvQQFBXH06FEAJk6cyOjRo2nQoEGNvUdxCbB4T050doGVt/46CMA4KWknhBDCw5544gnWr1/P5MmTOXz4MAsXLmTOnDmMGTMGgNzcXJ5//nnWr1/PiRMn2Lp1KyNHjiQhIYG77roLgODgYB5++GGefPJJli1bxrZt27j//vtp164d/fv3L/dYVqxYwaBBgxg7dix33HEHSUlJJCUlkZaWViXv/VxeHUT37NmTZcuWcfCgIyjYsWMHq1ev5sYbbwTg2LFjJCUllVjdaTKZ6NOnj2t1Z4cOHdi8eTPp6els2bKF/Px8mjZtyurVq9m6dStjx44t11jMZjNZWVklbkIARekcXjAT/cE/R0jNMdM4zJ9hV8XV9HCEEEJcYrp168aiRYv4+uuvadu2La+//jozZsxg6NChAOh0Ovbv388dd9xB8+bNuemmmzhz5gyrVq0qkWr77rvvcuuttzJkyBB69OiBn58fv/76KzqdznVN3759GT58eJljmTdvHnl5eUyZMoXo6GjX7fbbb6+y91+cV6dzPPPMM2RmZtKyZUt0Oh12u50333yTe++9F8C1gjMyMrLE8yIjIzlx4gQAAwcO5P7776dbt274+voyf/58/P39eeyxx5g3bx6zZ89m5syZhIWFMWfOnDKT0adMmcKrr75ahe9W1FqumeiaXVh48mwen7lK2rWSknZCCCGqxE033cRNN91U6jkfHx9++umni/bh4+PDzJkzmTlzZpnXHD9+/KJB9Lx58y76WlXFqz9lv/32W7788ksWLlzI1q1bmT9/Pm+//Tbz588vcd25KznPXd05adIkDh8+zK5du7jtttuYPHky/fv3x2Aw8MYbb7B69WpGjhx5wWT05557jszMTNctPj7es29W1F5ekhM9+Y99WOwKvZqFcW1LKWknhBCi9tq/fz+BgYHVulCworx6Jvrpp5/m2WefdVXTaNeuHSdOnGDKlCk8+OCDREVFAbgqdzilpKScNzvttH//fr766iu2bdvGZ599Ru/evQkPD2fIkCGMGDGCrKysUncwMplMmEySXypK4QU50euOnGXxHkdJu5duai0l7YQQQtRqLVu2ZNeuXTU9jAvy6pnovLw8Vyk7J51Oh6IoADRq1IioqCiWLl3qOm+xWFi5cmWpJVJUVeXRRx/lnXfeISAgALvdjtVqBXDdO/sWotxqOCfarqi8VljSbmj3hjSP9J561UIIIcSlyqtnom+++WbefPNNGjRoQJs2bdi2bRvTp09nxIgRgCONY/z48UyePJlmzZrRrFkzJk+ejJ+fH/fdd995/c2dO5eIiAgGDx4MOMq0TJo0ifXr1/Pnn3/SunVrQkJCqvMtiktBDedEf785nn2nswjy0fPEdVLSTgghhKgOXh1Ez5w5k5deeonRo0eTkpJCTEwMo0aN4uWXX3ZdM3HiRPLz8xk9erRrs5UlS5YQGFgyoElOTmby5Mkl9mS/4oorePLJJxk0aBARERHn5VoLUS41mBOdXWDl7SWOep3j+jenrr+x2scghBBCXI40qqqqNT2I2igrK4vg4GAyMzNLzaEWl5EPusOZ/TDsF2jcp1pfesqf+/h45VEah/vz1/jeGHRenaElhBA1Tj6/hafIJ64QlVVDM9Enzuby+erjALw4qJUE0EIIIUQ1kk9dISrLUriwsJpzop0l7Xo3D+eaFlLSTgghhKhOEkQLURmqWiMz0WuPpPLXnmR0Wg0vDmolJe2EEEKIaiZBtBCVYSsA1e44rqY60XZF5bVfnSXtGkhJOyGEEKIGSBAtRGU4Z6Gh2oLobzfFsz8p21HSrr+UtBNCCCFqggTRQlSGMx/a4A/aqv/rlFVg5Z3Cknbj+zenjpS0E0IIIWqEBNFCVEY150PPWn6Ys7kWGof788BVDavlNYUQQghxPgmihagM126FVR9EH0/N5fM1xwB4aVBrKWknhBBC1CD5FBaiMqpxJvrNP/Zhtav0aR7ONS2lpJ0QQghRkySIFqIyqqlG9JrDqSzdW1TSTgghhBA1S4JoISqjGmaibXaF139zlLR74MqGNJOSdkIIIUSNkyBaiMqohpzobzc7StoF+xoY169Zlb2OEEIIIcpPgmghKqOKZ6Iz8628s+QgAE/0byYl7YQQQggvIUG0EJXhyomumiB61vJDpOVaaBoRwNArpaSdEEII4S0kiBaiMlwz0Z7PU1ZVlYUbTgLwwo2tpKSdEEII4UXkU1mIyqjCnOi0XAu5FjsaDVzdNNTj/QshhBDCfRJEC1EZVZgTnZiRD0B4gAmTXufx/oUQQgjhPgmihaiMKpyJTkx3BNH16vh6vG8hhBBCVI4E0UJUhrlwYWEV5EQ7Z6LrhUgQLYQQQngbCaKFqIyqnImWIFoIIYTwWhJEC1EZVZgTfSpD0jmEEEIIbyVBtBCVUQ0z0THBEkQLIYQQ3kaCaCHcpShFQXRV5ETLwkIhhBDCa0kQLYS7rLlFxx6eic6z2EjPswISRAshhBDeSIJoIdzlzIfWaMHg2UDXmQ8daNIT5GPwaN9CCCGEqDwJooVwV/FUDo3Go10nZhQAMgsthBBCeCsJooVwl7NGtLHq8qFjpLydEEII4ZUkiBbCXZZqKG8nQbQQQgjhlSSIFsJd5moobydBtBBCCOGVJIgWwl1VOBMt5e2EEEII7yZBtBDucuVEy5bfQgghxOVGgmgh3FVFG63Y7ApJWYXVOSSIFkIIIbySBNFCuKuKcqJTss3YFRWDTkNEoMmjfQshhBDCMySIFsJdVZQT7UzliAr2Qav1bP1pIYQQQniGBNFCuKuKcqKlvJ0QQgjh/SSIFsJdVZQTneCszBHi59F+hRBCCOE5EkQL4a4qyokuqszh49F+hRBCCOE5EkQL4a4qyol2pXNIjWghhBDCa0kQLYS7qmomOl12KxRCCCG8nQTRQrjLUriw0IM50aqqysJCIYQQohaQIFoId1XBTHRmvpVcix2QmWghhBDCm0kQLYS7qiAn2lmZIyzAiI9B57F+hRBCCOFZEkQL4Q67DWyOrbk9ORMtqRxCCCFE7SBBtBDucOZDg0dzop3l7SSVQwghhPBuEkQL4Q5nPrTOBDqDx7qVmWghhBCidpAgWgh3VFGNaJmJFkIIIWoHCaKFcEeV7VboyLOWjVaEEEII7yZBtBDuqIIa0VC00YqkcwghhBDeTYJoIdxRBTPRBVY7qTlmQIJoIYQQwttJEC2EO6ogJ/p0piOVw8+oI8TPc4sVhRBCCOF5EkQL4Y4qmIl2pnLEhPii0Wg81q8QQgghPE+CaCHc4cqJlo1WhBBCiMuRBNFCuMM1E+25hYUJUt5OCCGEqDUkiBbCHVWQE+1M54iV8nZCCCGE15MgWgh3VEFOtKRzCCGEELWHBNFCuKMKcqJlt0IhhBCi9pAgWgh3eDgnWlFUTmcWzkRLOocQQgjh9SSIFsIdHs6JPpNjxmpX0Wk1RAaaPNKnEEIIIaqOvqYHIESt5OGcaGcqR1SQD3qd/G4rhPB+qqpiV1RsiorVrmBXVKx2R5tdVbHbVWyK4npssxddrxR7bFdV7IpyzmPH+RZRgbStF1zTb1WIUkkQLYQ7PDwTXbTRio9H+hNC1E6KomKxK5itCma7HbNVKXpss2OxKZhtChabo91qdxxbCwNW57HVec7uCE5dj21Fx45b0WNbYeDqDIidwbHN7ji2Kc7joraqNuaaJhJEC68lQbQQ7jAXLiz0UE50olTmEMIrqapKgVUh32p33Cx2Cko5Lih8nF94bUGJtuLXnR8Mm20KZqu9MCiu+sC0qum1GnRajevecdOWeFzyXGmPtWi1GhqG+tf02xGiTBJEC1FRqloURHtoJtpV3k4WFQpRaXZFJbvASnaBjRyzjVyz895e7NhGjsVxn2u2u9rOvTbXYqMaJlxLpdGASa/FpNdh1Gsx6bWF94WPdVoMeg0GnRaDTotRp8WgczzW67QYC48Neuf5Us7ptOh1GoyF7XqtBr3OEcQ67h3X6bQaDIXtOq3G9TzH9YXPKwyANRpNzfzAhKhmEkQLUVG2AlDtjmNP5USnS3k7IYpzzgBn5lvJyLeQkWclM99KZuF9ibZ8q+s4I89CttmGWgWBr1Gvxdegc9yMOnwMOnwN2sJ7HT5GXcnzeu15bSa9DpPBEQCbDBcIkPWOwFQCUiG8l9cH0YmJiTzzzDP8+eef5Ofn07x5cz799FO6dOkCOP6hffXVV5kzZw7p6el0796dDz74gDZt2rj6mDBhAvPmzSMgIIBp06Zxzz33uM599913LFiwgF9//bXa35uopZyLCsHjCwslnUNcyhRFJS3PwplsM2eyzaS47gtcbWm5lsIg2YrFplTq9Ux6LQEmPf6FtwCTrujYWLItwEfvuNbVrsffpCPApMfPpMfXoEOnlYBWCFHEq4Po9PR0evTowTXXXMOff/5JREQER44cISQkxHXNtGnTmD59OvPmzaN58+a88cYbXHfddRw4cIDAwEB+/fVXFi5cyJIlSzh06BAPPfQQ1113HaGhoWRkZPDCCy+wbNmymnuTovZxbrRi8AetZyppSBAtarN8i90RBOcUkJJl5kxOYXBceOwMklNzLNgrmBuh02oI9jUQ4msg2M/gOg7xMxLkOi5sL7wP9jUS7GvAqJdKN0KIquPVQfTUqVOpX78+n3/+uastLi7OdayqKjNmzOCFF17g9ttvB2D+/PlERkaycOFCRo0axb59++jbty9du3ala9eujB8/nqNHjxIaGsrEiRMZPXo0DRo0qO63Jmozs2crc2QV5m6C5EQL76QoKsnZBZw8m8eJtDxOns3jZJrjOD4tj7RcS4X6C/U3Eh5oKnGLCPQhPNBEqL+xREAcYNJLSoMQwit5dRD9yy+/MHDgQO666y5WrlxJvXr1GD16NI888ggAx44dIykpiQEDBrieYzKZ6NOnD2vXrmXUqFF06NDBlepx9OhR8vPzadq0KatXr2br1q3Mnj27XGMxm82YzWbX46ysLM++WVF7WDxbI9q5qLCOnwE/o1f/lRSXsAKrnYT0PE44A+TC+5OFgbL5IqkVJr2WiCAT4QFFAXFEaUFygBGD1EIXQlwCvPoT++jRo8yePZsJEybw/PPPs3HjRsaOHYvJZGLYsGEkJSUBEBkZWeJ5kZGRnDhxAoCBAwdy//33061bN3x9fZk/fz7+/v489thjzJs3j9mzZzNz5kzCwsKYM2dOiVzq4qZMmcKrr75atW9Y1A4enomWRYWiuqiqSnKWmd2JmexPyuJEsZnlpKyCCz5Xp9VQL8SXhqF+NKjruDmO/alXx5cgH5kxFkJcXrw6iFYUha5duzJ58mQAOnXqxJ49e5g9ezbDhg1zXXfuP9yqqpZomzRpEpMmTSrxuH///hgMBt544w127drFb7/9xrBhw9iyZUupY3nuueeYMGGC63FWVhb169f3xNsUtY3FszWiT0k+tKgCqqpyKrOAXQmZ7DmVya7ETHYnZpGaYy7zOQEmfbHg2I8GhfcN6/oTEyK7aQohRHFeHURHR0fTunXrEm2tWrXixx9/BCAqKgqApKQkoqOjXdekpKScNzvttH//fr766iu2bdvGZ599Ru/evQkPD2fIkCGMGDGCrKwsgoKCznueyWTCZDJ56q2J2szDM9EJGTITLSpHVVUS0vMLA2VHwLznVFapucpaDTSLCKRNTBCNwvyLAuVQf+r4GWQ2WQghysmrg+gePXpw4MCBEm0HDx6kYcOGADRq1IioqCiWLl1Kp06dALBYLKxcuZKpU6ee15+qqjz66KO88847BAQEYLfbsVqtAK57RalcSSVxGfB4TrTja/RYWVQoykFVVU6czXMEzKccQfPuxCwy863nXavXamgWGUi7ekG0qxdMm3rBtIoKwteoq4GRCyHEpcWrg+gnnniCq6++msmTJzNkyBA2btzInDlzmDNnDuBI4xg/fjyTJ0+mWbNmNGvWjMmTJ+Pn58d99913Xn9z584lIiKCwYMHA44gfdKkSaxfv54///yT1q1blyifJ0SpPJ4TnQfITLQonaqqHE7JYdn+FP49eIZdiZmuai7FGXQaWkQF0q5eMG3rBdM2JpgWUYH4GCRgFkKIquDVQXS3bt1YtGgRzz33HK+99hqNGjVixowZDB061HXNxIkTyc/PZ/To0a7NVpYsWUJgYMl81eTkZCZPnszatWtdbVdccQVPPvkkgwYNIiIigvnz51fbexO1mCsnWjZaEVXDYlPYcOwsy/alsHx/CifT8kqcN+q1tIoKdATL9YJpVy+Y5pGBUhdZCCGqkUZVq2Jz1EtfVlYWwcHBZGZmlppDLS5hv46HLZ9D3+eg77OV6spiU2jx0p+oKmx+sT9hAZJ3f7lKzTHzz35H0LzqUCo55qLZZqNOy1VNQrm2ZQTd4urSLDJAysQJ4Sb5/Bae4tUz0UJ4JQ/mRCdlFqCqjhq7of7GSvcnag9VVdmflM3y/Sn8vS+Z7fEZFJ/SCAsw0a9lBNe2iqBn0zD8TfLPtRBCeBP5V1mIivJgTnTxVA6pinDpK7DaWXf0LMsL0zSc//2d2tYL4tqWkfRrGUG7esFotfJnQgghvJUE0UJUlAdnohOlvN0lLyW7gOX7Uli2P4XVh1LJt9pd53wMWno2DePalpFc2zKCqGCfGhypEEKIipAgWoiKMhcuLDRVfrMV2Wjl0rU/KYuPVx7llx2nsCtFeRrRwT5c2zKCfq0iuKpxmJSbE6IYVVWxKBYKbAVY7BZMehNBRslbFt5JgmghKsqTM9GFW37XkxrRlwRVVdl4LI2PVh7hnwNnXO0dYoPp3yqSa1tF0Do6SFJ3RK2iqipmu5l8Wz4FtgLybfml3pznCuwFmO1mVyDsfGy2mzHbzEXHZVxT3Kj2o3i80+M19M6FuDAJooWoqCrIiZZ0jtpNUVSW7kvmo5VH2HYyA3DsDHhD22j+06cJ7WKDa3aA4rJiVazkWfPIteaSY80hz5pHjjWn6NiSQ64tl1xLrus+z5bnCoSdx87HBfYCFLX6NyLTarTYVfvFLxSihkgQLURFeXAmWtI5ajeLTeHn7Yl8vPIIR87kAo4aznd2ieXRXo2JC/Ov4RGK2shsN5NpziTLnEWWpeiWac50HBe2Z1uyybXmum451hxyrbnnzeZ6klFrxEfvg6/et9Sbj94HH70PJp0Jk86Ej84Hk97keuxqL3aNSWcqcY2PznFOr9XLtzbCq0kQLURFKEpREF3JnGhVVWWjlVoqx2zj6w0n+XT1MZKyHNu2B/roeeDKhgzvEUdEoCwQFGBX7GRaMknLT+NswVnSCtJIK0grEQg7710BsiXLY0GwSWfC3+Bf6i3AEFDisZ/ezxUEFw+K/fR+rjYfvQ967YXDBlVVsSsqNkXFalew2VWsiuO++LHVrmC3qdgsCpklztmx2bOxKlnY7ArNIx2bCgnhjSSIFqIirLlFx5WciT6ba8FsU9BokKoMtcSZbDPz1h5jwboTZBVuvR0ZZOLhno2494oGBPoYaniEoqrl2/IdwfA5gfHZ/LPnPc4wZ7idBqHVaAkyBhXdTEEEG4MJMhW1BRgD8NX7Y9L6YdD4YtD4osMHvcYPreqDXdFgtimYbXYsNsVxbHU8NtsUzAUKeTaFdJsdq03FYnfcW+0KFruC1Z6N1Z6FxeZ8XHgrvMZsK9ZmV13XeG4LN5XRfZtIEC28lltB9LXXXstPP/1ESEhIifasrCxuvfVWli9f7omxCeF9nPnQGi0YKjd77FxUGBFoku2avdyJs7nM+fco329JwGJzBEWNw/0Z1bsxt3aqh0kvFTaqi6qq2FQbNsWGXbFjU2xFj1W7q92qWFFUBbtqx67aUVQFm2JztSmqgl0pOmdVrGSaM0kvSCetII0Mc4brlmXJcuUP2xTbxQd5DoPWiFFrwqA1otMY0Gn0aNCjQee4V3WAFlXVoaoaVEWLomiwmxUyChTSFAW7koldTceuKiiKiqIqKKqCigoaFVBxJD44HxceFzvvuJ1/jea855z7XECngs75XM7rTwMYNQrG8/qg2PUUvlYp15S4vqjtqP1u4MXy/JiFqHZuBdErVqzAYrGc115QUMCqVasqPSghvJYrHzoQKpmrJ6kc3m93YiazVx7hz12ncVap61g/hP/0acKA1pGX9GYoNsXmqp5gtpsd1RMKKys4j4tXVLDarViVwlvhscVuKWor5bHrOXYrFsVxzqYUC5ALg+MSAXItXGhmVSxYlfM/M8tFgyN41ZXefKlrFV35UqJCVJUKBdE7d+50He/du5ekpCTXY7vdzuLFi6lXr57nRieEt3HViPbgosI6fpXuS3jWpuNpvL/sEKsOpbra+rYI5z99mtC9UV2vWuykqAr5tvxSKy7k2nLJseSQZyusyFBsEVquLbfsoNhmxqZWfMa1Juk1erRaLZrC/zlnaR0zzwolZzzLoIKq6kHVoyoGUA2oihFVMYJiRFUNoBhB1aGiBVUDaAFN4bEGVMdjtfAeNGjRYtDpMOp0GPQ6jDo9eq3W8VinxaB1tutcbcbC64w6HSa942bU6TEZdK42o77o2KDVotPqQANatGg0GrQaxzdcWk3hz0Xj+Nmc+9h5raZwLvvc6xz/pznvOSXazn1c+D9Hh5T6HMeponbnaxdv99FJqpvwXhUKojt27Oj6y3Lttdeed97X15eZM2d6bHBCeB0PVuZISHeWt5MPCW9hsyu8+/dBPvjnCAA6rYab20czqk8TWkVX7YYPzkVoznSC9IJ0x82cXuL4vGC5eJ5+FSmt0oLz2Efng0FnwKg1YtQZMWgNGLQG17Feq3edN2gNRcc6Q4lr9Vq967Feq0en0TnutToMGgM6rQ6rDU5knOXQ2ZMcz4wnISee5LxEzloSyFPPgP3Cgb9i80e1hqDYglGtwSjWEFRbSLHjQJzzu1oNBPkaCC68BZj0+Bn1BJh0+Jv0BJj0+BfenG3Odj+jznU+wKTHpNd61S9eQgjPqFAQfezYMVRVpXHjxmzcuJHw8HDXOaPRSEREBDrd5fAFk7hsebBGtHMmOlbSObxCUmYBY7/exsbjaQDc2SWWcf2aUb+u+98U5NvyScxO5Ez+mVID4uLBcqYls1K1eHUaXakVGPwMfudVYvA3+ONn8MNX51tqUFy8BJlRZ3TNaFaVzHwrCel5JJ7NJzmrgNNZ2ZzMPsrp3JOctSSQbT+FWZMMhhQ0urIrV6iKEcUShmIOR7GEgbUuvrpQAvVh1DGGE+LrT3BQUWB87s0VNPsZCDDqL+l0HSFE5VUoiG7YsCEAilL9RdeF8Aqe3K1QNlrxGisOpDDhux2k5VoIMOmZcns7bu4Qc9HnqapKan4q8dnxJOQkkJCd4DjOTiAhJ4HU/NSL9nGuIGMQdX3qUsenDnVMdRz3xY4DjYGlBskmnckrZztVVSUjz0pCer4jUM7Idx0npOeTmJVMnvYEOp8EdL4JaE3JaA0ZRR04Vqo5EwNQVQ1ae118iCJYH02oKZZ6fg2IC44jLiSG8EAfwgJMhAeYCPSRQFgIUXXcWlg4ZcoUIiMjGTFiRIn2zz77jDNnzvDMM894ZHBCeB1XTnTlF7sU5URLEF1TbHaFd5YeZPYKR/pGm5ggZt3XmUbFNkkpsBVwKudUqYFyYk4iBfaCC75GoCGQCL8IVzBcPEB2HRe2B5uCMWhrV5k8VVVJzbEUBsd5JKbnnxcw51kKFwNq89D5JDqCZZ8EdAEJaOtkUtpcv1HjT6gplhi/+sQFxdGsbmPaRjSjRWgcPnpJgRJC1Dy3guiPP/6YhQsXntfepk0b7rnnHgmixaXLQzPReRYb6XlWQKpz1JRTGfmM/Xobm0+kA3B/9waM6BvM7rTlfHloO4czDpOQnUBKfsoF+9FqtET7RxMbEEtsYNGtfkB9YgNjCTZdOjVuM/Is7E/K5mByNgeSCm/J2WQXlJKLrLGg80lEG5CAj08CRr9EVMP5M/MaNDQMiqN9eDvahLahRd0WNApuRB1THa+cWRdCCCe3guikpCSio6PPaw8PD+f06dOVHpQQXstDOdHOGtGBPnrZoKMG/LM/hSe+20KWPZ6A8Hg6NE1nnWUf//ul9IDZ3+BP/cD6xAbEOu4DY13HUQFRtW72+GLyLXYOpZQMlA8kZZOSXXo+skZrI6xOGkEhp9H5JJCvPU6mLRGVotQ/Z22M2IBY2oa1pU1oG9qEtaF1aGv8DbI9uhCi9nEriK5fvz5r1qyhUaNGJdrXrFlDTMzF8wiFqLU8NBMtNaKrX541j63JO/hw/d9sS96GLvYE/jpH7d6dGY5r9Bo9rUNb0ymiE61DW1M/sD71A+sTbAq+JGdFbXaF42dzHbPLxYLlE2l5Ze46F1vHl+aRAUSEnsVs3EtiwTYOZe2hQLFRAKAU3oAI3wjahLUpCppD2xDiE1I9b04IIaqYW0H0yJEjGT9+PFar1VXqbtmyZUycOJEnn3zSowMUwqt4qE60BNFV70zeGbalbHPd9qXtRyncqENf+J/P3xBAx4gOdI7oTKeITrQNa4uv/tL9b3Im28yGY2dZf/QsW05kcCQlB4u99IXiof5GWkQF0jwykBZRgcSGQqp9J1tSlrPm1Bo2pZVMzQgxhdAmzBEotw1tS5uwNkT4RVTH2xKXKEVRZWGo8GpuBdETJ04kLS2N0aNHu3Yu9PHx4ZlnnuG5557z6ACF8CrFdyysBFlU6Hln8s6wMmEl21K2sTV5Kwk5Ceddo1hD0BY04tbWPbi/Y1+ahjR1bFBxiUrNMbPhaBrrjqay/mgah1NyzrvGz6hzBMqFwbLzVtffwL60faxOWM0fiavZuX9niRJ8vnpfukd3p1e9XlwVfRWxgbGX5Gy9qBk74jN48vsdzB7amWaRsmuh8E5uBdEajYapU6fy0ksvsW/fPnx9fWnWrBkmk8nT4xPCu3g4J1rK21Xe7tTdfLnvS/469leJXfY0aGhWpzlqfhw7j9TFnteQdlENmXVvZxqEXpq7RDqD5vVHHbPNh84JmjUaaBUVxJWNQ7miUV3axARRL8TXNduXUZDB2lNrmb5tNWtOrSGtIK3E85uGNKVHTA96xvakc0RnjDpjtb03cfn4YUsCzy/ahcWm8N8/9/Pp8G41PSQhSuVWEO0UEBBAt27yh1tcRiQn2ivYFBvLTi7jy71fsv3Mdld7+7D2XBlzJZ0jOhNmaMazPxxi28kMAB7qEcezN7TEpL90Zp7P5pjZcKwoaD6YfP5Mc6voIK5sXJcrG4fSvVFdQvyKAl9FVdiTupvVp1azOnE1u1N3l5ht9tP7cWX0lfSM7UnPmJ5EB5y/oFwIT7HaFd78fR/z1h4HoH+rCKbf3bFGxyTEhbgdRG/atInvv/+ekydPulI6nH766adKD0wIr+ShmehTGY7awpLOUTGZ5kx+PPQjX+//mqTcJAD0Wj03xN3A0NZDaRPaBoC/9yYz5PvtZOZbCfTR89adHbi+bVRNDt0jzuaY2XgsjXUXCJpbRgVyZeNQrmoSyhVxdanjX3K22K7YWXNqDX8c+4O1iWtJN6eXON+sTjN61nMEzZ0iOmHQXVqVR4R3OptjZszCraw/6vj2Y1y/Zozr10xyooVXcyuI/uabbxg2bBgDBgxg6dKlDBgwgEOHDpGUlMRtt93m6TEK4T0shQsLK5ETbbMrJGUVBtEyE10uRzOPsnDfQn458gv5Nscsfl2fugxpMYQhzYcQ7hcOgMWmMG3xfj5ZfQyADrHBzLqvc6W27q5peRYbi3cn8ePWBNYeOXte1Qxn0OycaT43aHZKzk3mp8M/8dOhn1y/gAAEGAIcs831etKjXg+i/Gv/LxuidtmdmMmoBVtIzMjH36hj+t0dGdhG/hwK7+dWED158mTeffddxowZQ2BgIO+99x6NGjVi1KhRpdaPFuKS4YGZ6ORsM3ZFxaDTEB4g6wjKoqoqa0+tZcG+BaxJXONqb1GnBfe3vp8bGt2ASVf080tIz+PxhdvYHp8BwMM9G/HM9S0x6rXVPfRKUxSVDcfS+HFrAn/uOk2uc8c/igfNdbmiUSh1ywiaoWjW+fuD3/Nvwr+uVI1gUzA3N76ZaxtcS8eIjpdcnWtRe/y8LZFnftyJ2abQKMyfOQ90kYWEotZwK4g+cuQIgwYNAsBkMpGbm4tGo+GJJ57g2muv5dVXX/XoIIXwGh7IiXYuKowO9pWvKkuRZ83jt6O/8eW+LzmW6ZhR1qDhmvrXcH/r++ka2fW8KhBnc8zcM2c9Cen5BPnoefuuDgyohTNZx1Nz+WlrAj9tSySh8M8JQIO6ftzROZbbO9cr16x6Um4Siw4vOm/WuUtkF+5qfhf9G/Yv8QuIENXNZncsGnR+a3RNi3Bm3NOJYF/5hU7UHm4F0XXr1iU72/G1dr169di9ezft2rUjIyODvLw8jw5QCK9ht4HNkYaByf2ZklOyqLBUp3NO8/WBr/nx4I9kWbIAx06BtzW9jfta3Uf9wPqlPs9qVxj91VYS0vNpGOrHlw93r1XpG1kFVn7feZoftyS4tiAHCDTpGdQ+mju6xNK14cW3wL7QrPMtTW7hjuZ30Di4cZW+FyHKIz3XwuNfb2XN4bMAPH5NU564rjk6mVQQtYxbQXSvXr1YunQp7dq1Y8iQIYwbN47ly5ezdOlS+vXr5+kxCuEdnPnQULmZaKkRXcL2lO18ue9L/j7xN/bCzVDqB9ZnaKuh3NLkFgIu8rN+9dc9bDiWRoBJzyfDutaKANquqKw6dIYftyayZE8SZpsj4NVqoGezcO7oXI+BbaLwMVy8kojMOovaZO+pLB5dsJmE9Hz8jDrevqsDN7aTNFBRO7kVRM+aNYuCAseM3HPPPYfBYGD16tXcfvvtvPTSSx4doBBew5kPrTOC3v36uAlSIxoAq2LljfVv8NOhomo+3aO6M7TVUHrH9i7XJigL1p/gy/Un0WjgvXs6en0u5cHkbH7cksCibYmkZJtd7c0iArijSyy3dapHZJDPRftxzTof+J5/E2XWWdQOv+44xdM/7KDAqtCgrh9zh3WlRZR3/50V4kLcTudw0mq1TJw4kYkTJ3psUEJ4JQ/ViHamc8RexkF0rjWXJ1c8yZpTa9BqtAxuMpj7W91Pi7otyt3H+qNnefWXPQA8PbAF/VpFVtVwKyU918IvO07xw5YEdiVmutrr+BkY3CGGO7rE0q5ecLl2+0vKTWLRoUX8dLjkrHPXyK7c2fxOmXUWXsmuqLz11wE+WnkEgF7Nwph5b6cSNcuFqI3crhNtt9tZtGgR+/btQ6PR0KpVK2655Rb0+krt3yKE9/LUboUZl/dM9Jm8M4xZNoZ9afvw1fvyVu+36FO/T4X6iE/L47Evt2BTVAZ3iOGxPk2qaLTuyzHb+GjFEeauOupK19BrNVzbMoLbO8dybcuIclcOSStI48PtH/LDwR9cKS8y6yxqg4w8C2O/2c6/B88AMKpPYyYObCn5z+KS4FbEu3v3bm655RaSkpJo0cIxc3Tw4EHCw8P55ZdfaNeunUcHKYRX8ECNaFVVixYWXoY50UczjvLY349xKvcUdX3q8kG/D2gb1rZCfeSabTzyxWbS86y0qxfM1Dval2sWt7rYFZXvN8fz9pKDpOY4UjbaxARxZ5dYBneIIbQCZQ2tdisL9y/k4x0fk211/PmTXGdRWxxIyubRBZs5cTYPH4OWaXd2YHCHmJoelhAe41YQPXLkSNq0acPmzZupU6cOAOnp6QwfPpxHH32UdevWeXSQQngFD8xEZ+RZySus+RsdfPHc10vJluQtjF0+lixLFg2DGjK732zqB5VecaMsiqIy4bvt7E/KJizAxJxhXfA1es823qsPpfLG73vZn+QIeONC/XjuxlYMaB1ZoUBfVVX+if+Hdza/w8nskwC0qtuKp7s9TbeoblUydiE86c9dp3ny+x3kWezE1vFlzgNdaR0TVNPDEsKj3Aqid+zYUSKABqhTpw5vvvkm3brJP/DiEuWJGtGFs9BhAaZyVV64VPx1/C+eW/UcVsVKh/AOzLx2JnV86lz8ied4b9kh/tqTjFGn5eMHuhAd7B2z+YdTspn8x36W708BIMhHz7j+zXngyoYV3uzlQNoBpm2axsakjQCE+oQyrvM4BjcZXK7FlkLUJLui8u7Sg8z65zAAVzcJZdZ9nS+4KZAQtZVbQXSLFi1ITk6mTZs2JdpTUlJo2rSpRwYmhNfxwEz05Vje7os9X/DW5rcA6NegH//t9V989BWfhf9z12neW3YIgDdua0uXhhUPwj0tLdfCjL8P8tWGk9gVFb1WwwNXNWTstc3K3H67LKn5qczaNoufDv2EiopRa+TBNg/ycLuH8Tf4V9E7EMJzsgqsjP9mu+uXyZE9G/HsDS3R62rfrqFClIfb236PHTuWSZMmceWVVwKwfv16XnvtNaZOnUpWVpbr2qAg+fpGXCI8kBPt3K2wXsiln8phV+y8vfltvtz3JQD3tryXZ7o949Zs6t5TWUz4bgcAI3o0YkjXiqWBeJrZZmf+2uPMXH6Y7AIbANe1juS5G1rSOLxiv2RZ7Ba+3Pclc3bOIdeaC8DAuIE80eUJ6gXU8/jYhagK8Wl5jJi3iUMpOZj0Wv57Rztu6xRb08MSokq5FUTfdNNNAAwZMsSV56eqKgA333yz67FGo8Fut3tinELUPA/MRF8uuxUW2Ap4fvXzLD2xFIAnuzzJg20edGsB4NkcM498sZl8q51ezcJ4/saWnh5uuamqyp+7k5jy5z7i0xz/LVtHB/HiTa24uklYhfv6++TfvLP5HRJzEgFoE9qGid0m0jmys8fHLkRV2Xw8jUcXbCEt10JkkIlPhnWjXWxwTQ9LiCrnVhD9zz//eHocQng/D+ZEX8rl7TIKMhj7z1i2pWzDoDXwZs83uaHRDW71ZbEpPPbVVhIz8okL9WPmvZ1q7Kvh7fEZvPHbXtfW3BGBJp4e2ILbO8dWuFzX3rN7mbZpGluStzj68o1gXJdx3NT4JrQa+epb1B6LtiXwzA+7sNgV2tYL4pNh3Yi6zBZNi8uXW0F0nz4Vq+kqxCVBZqIvKiE7gcf+fozjWccJNAby3jXvVaqaxKRf97DRuaX3g11rZHOGxIx83lq8n5+3nwLAx6BlVO8mjOrTGD9jxf4JPZN3hve3vc//Dv8PFRWTzsRDbR/ioTYP4Wfw/u3KhXBSFJV3/z7IzOWOBYQD20Ty7t0dK/x3QojazO0/7QUFBezcuZOUlBQURSlxbvDgwZUemBBex5UTLTPRpdmTuocxy8ZwtuAsUf5RzO43m6Z13F9ovGD9CRZucGzp/f69HWkaUb3bA5e2WcodnWN5emCLCs+0FdgKWLB3AXN3zSXf5vgzcGOjGxnfeTzRAdEeH7sQVanAaufJ73fw+87TAPynTxMmDmyBVjZQEZcZt4LoxYsXM2zYMFJTU887J3nQ4pLlmol2b7FsgdVOao4FgNhLrDrHvwn/8tTKp8i35dOiTgs+7P8hEX4Rbve39kiqa0vviQNbcm3L6t3Se9G2BCb/sZ8z2Y7NUro3qsuLg1q7lef51/G/eGfzO5zOdQQc7cPa83S3p+kY0dGTQxaiWqRkF/DIF1vYEZ+BQafhzdva1fhCXyFqiltB9OOPP85dd93Fyy+/TGRk9X64CVFjLJVL53CmcvgbdQT7Gjw1qhr348EfeX3969hVO1dFX8X0vtMJqMRsfXxaHmO+2opNUbmlYwz/6VN9W1orisqUP/cxd9UxwP3NUsCx2+CUjVP4/uD3AET6RfJElye4odENkvcsaqW9p7IYOX8TpzILCPEz8NH9XbiycWhND0uIGuNWEJ2SksKECRMkgBaXF3PlFhYWT+Xwpm2q3aWqKh/u+JCPdnwEwOAmg5l09SQMWvd/Qcgx2xg5v2a29M632Hni2+0s3pMEwLh+zRhzTdMKb5YCcDb/LBNWTGBrylY0aBjZbiSPtH8EX/2l9Q2EuHz8vTeZsd9sI89ip3G4P5892I24MKlfLi5vbgXRd955JytWrKBJkyaeHo8Q3stDM9GXwkYrVsXKq2tf5X9H/gfAqPajGNNxTKUCXkVRmfDtdg4kF23pXV27OqbmmBk5fzPb4zMw6rS8dVd7bunoXo3m/Wn7Gbt8LKdzTxNgCGBq76n0ju3t4RELUT1UVeXT1cd48499qCr0aBrKh/d1Idjv0vk2TQh3uRVEz5o1i7vuuotVq1bRrl07DIaSf5nGjh3rkcEJ4VXMldtsxbnRSm1fVJhvy2fc8nGsO70OnUbHi1e+yJ3N76x0vzOWHWLJ3urf0vtwSg4PzdtIfFo+IX4G5jzQlSsa1XWrr8XHF/PS6pcosBfQMKgh71/zPo1Dqi8dRQhPstoVXv7fHr7eeBKAe69owGu3tMEgOxAKAbgZRC9cuJC//voLX19fVqxYUWL2SaPRSBAtLj2qWumZ6MSMAqD2l7ebu3Mu606vw1fvy9t93vbILOvvO0/zfuGW3m9W45be64+e5dEvNpNVYKNhqB+fD+9W4R0HARRVYda2WczdNReAHjE9mNp7KsEm2XBC1E6ZeVYe+2oLa4+cRaOBF25sxcM9G10SqWhCeIpbQfSLL77Ia6+9xrPPPotWK7+RisuAzQyKY3tn93Oi84DaXZkjJS+FBXsXADC552SPBNB7TmXy1PeOLb0f7tmIu6pppf+ibQlM/GEnVrtK5wYhzB3WldAAU4X7ybHk8Nyq51iRsAKAB1s/yBNdnnBre3MhvMHx1FxGzNvE0dRc/I063runE/1byxooIc7lVhBtsVi4++67JYAWlw/nLDR4ZGFhbfXRjo8osBfQMbwj/Rr0q3R/qTlmHv1ii2tL7+duqPotvVVV5f1lh3n374MADGoXzTtDOriVf30y6yRjl4/lSOYRjFojr1z9CoObSJ18UXutP3qW/3y5hYw8KzHBPnw6vButot0r6ynEpc6tKPjBBx/k22+/9fRYhPBeznxogz+48cujXVFJyqzd6RzHMo/x06GfABjfZbxHvtZ9/be9ri29Z93bucq39LbYFJ76fqcrgP5PnybMvLeTWwH0ulPruPf3ezmSeYRw33DmXT9PAmhRq323OZ4HPt1ARp6VDvVD+PnxHhJAC3EBbs1E2+12pk2bxl9//UX79u3PW1g4ffp0jwxOCK9RyXzoM9lmrHYVnVZDRGDFUwa8wcxtM7GrdvrG9qVLZJdK93cgKZtfdji20p55b+cqX+2fmW/lsS8dOZ46rYbXb2nLfd0bVLgfVVX5ct+XvL35bRRVoX1Ye9695t1KbS4jRE1SFJWpf+3n45VHARjUPpp37nLv2xkhLiduBdG7du2iU6dOAOzevdujAxLCK3moRnRUkE+Vz7ZWhZ1ndrL0xFI0aBjb2TMLh6cvPYCqwo3totzaCbAi4tPyGDFvE4dScvA36vhgaGf6tqh40GuxW3ht3Wuu0n6Dmwzm5atexqSrnb8YCZFvsTP+2238tScZgLHXNmV8/+ayhbcQ5eBWEP3PP/94ehxCeLdKV+YorBFdC1M5VFXl3S3vAo6gsVmdZpXuc1dCJn/tSUajgSf6N690fxeyIz6Dh+dvJjXHTFSQD58N70brmIp/RX0m7wzjV4xn55mdaDVanur6FPe3ul+qFYhaKzXHzMPzN7OjsD76tDvbc2sn9+qjC3E5qlAQffvtt1/0Go1Gw48//uj2gITwSh6qEV0bN1pZnbiazcmbMWqNjOk4xiN9vrP0AAC3dqxHs0j3fqblsWRPEmO/2UaBVaFVdBCfDe/qVv3p3am7Gbd8HCn5KQQZg3irz1tcHXN1FYxYiOpx9EwOwz/fxMm0PEL8DMwd1pVuce7VRxficlWhIDo4WGqeisuUp3YrrGUz0YqqMGPrDADubXkv0QHRle5z8/E0Vhw4g06rYXz/ys9ql+Wz1cd4/fe9qCr0aR7OB0M7E2Cq+Jdvvx75lUlrJ2FRLDQObszMa2fSIKjiudRCeIstJ9IYOX8z6XlW6tf1Zd5DV9DEjfroQlzuKvSJ8vnnn1fVOITwbh7Kia5t5e1+P/o7B9MPEmgIZGS7kR7p850ljsoYQ7rG0jDU3yN9FmdXVF7/bS/z1h4HYGj3Brw6uE2Fc9Htip0ZW2cwb888APrG9mVKrykEuPlnQAhv8Oeu04z/djtmm0KH2GA+ebAb4bV0sbMQNc2tnGghLjuemomuRekcFruFWdtmATCi3QhCfEIq3efaw6msO3oWo07L49d6fhY6z2Jj7Nfb+HtfCgDP3dCSR3s3rnDecpYli4n/TmRN4hoAHmn3CI93ehytpvYtChXC6dPVx3ij8NuZ/q0ieP/eTvgZJQwQwl3yt0eI8nDlRLs5E+3MiQ7x8dSIqtx3B77jVO4pInwjGNpqaKX7U1WVt5c4cqHv697A46ktKdkFPDxvM7sSMzHqtbw7pCOD2lc8/STTnMmDfz7Ikcwj+Oh8eL3n61wfd71HxypEdbIrKm/8vpfP1xwH4IErGzJpcBt0UoFDiEqRIFqI8nDNRFd8EVxWgZVss2PL8NqSzpFtyebjnR8D8FjHx/DVV37cKw6cYevJDHwMWkb3bVLp/orLs9i4/5MNHEzOoa6/kbnDutClYcUXSVnsFsb9M44jmUeI8Itg1rWzaBXayqNjFaI6FVjtjP9mO4v3JAHufzsjhDifBNFClEclZqKds9B1/Y215qvTeXvmkWHOIC4ojlub3lrp/orPQj94VRwRQZ6bkVdVlRd/3s3B5BzCA018P+oq4sIqnmutqiovrXmJLclbCDAE8FH/jzxSzk+ImpKWa2Hk/E1sPekoYff2kA4M7hBT08MS4pJROz7RhahpZvdzop1BdEwtSeU4k3eGBXsXADC+83j02sr/M7F4dxJ7TmXhb9Qxqo9nZ6G/2xzPT1sT0Wpg5r2d3AqgAWZtn8Ufx/5Ar9Ezve90CaBFrXY8NZfhn2/k+Nk8gnz0zB3Wle6NQ2t6WEJcUiSIFqI8LO5X5ziVWbvK232882Pybfm0D2/PtQ2urXR/dkVl+lJHRY6Hezairr+x0n067T2Vxcv/2wPAkwNacKWbQcKiQ4uYs3MOAC9f9TJXxVzlsTEKUd22nUzn4fmbScu1UC/El/kjutE0ourqsQtxuZIgWojycKZzuJETXTQT7f1B9PHM4/xw8AfAMQvtibzJX3ec4lBKDkE+eh7u1bjS/TllF1gZs3ArZpvCNS3CeczNGe61p9by2rrXABjVfhS3NbvNY2MUorr9tSeJcYUbDLWtF8Rnw7sREVixb8FUVUVVQQUUVUVxPlaLHitq0XUlHhc+x9nufJ5KsbZSXqOs68MDTbXi305xeapVQfSUKVN4/vnnGTduHDNmzAAcfxFfffVV5syZQ3p6Ot27d+eDDz6gTZs2rudNmDCBefPmERAQwLRp07jnnntc57777jsWLFjAr7/+Wt1vR9QmlZiJrk1bfs/cNhO7aqd3bG+6RXWrdH9Wu8KMvx2z0KP6NCHY11DpPsHx9/7ZH3dxLDWXmGAfpg/piNaNSgMH0w/y5Ionsak2BjUe5LEdGYX3UFUVq13FpiiOe7uCXVGxKo5j5zmbXcVqV7AphffFnmNXVGyKir3wOkV1PlZLfWxXC69VVBSl2LnCx3bFcY2iqNhVUBRHH/Zi9/bCoNSulN2uFHuuoqpk5Fk5m2sBwKTXkppt5uaZq10BrqLi6qtEQKwUBbfOc95idN8mTLy+ZU0PQ4hS1ZogetOmTcyZM4f27duXaJ82bRrTp09n3rx5NG/enDfeeIPrrruOAwcOEBgYyK+//srChQtZsmQJhw4d4qGHHuK6664jNDSUjIwMXnjhBZYtW1ZD70rUGpXJia4lQfTu1N0sObEEDRrGdR7nkT5/2prA8bN5hPobGX51nEf6BPhi3Ql+33UavVbDrKGdqeNGikhKXgpjlo0hx5pDl8guvHb1a1KxwMNsdoV8q50Cq0KB1V54c7Y5bvlWO2arQoHNTr7FjtmmYLUrWGwKZpuCxa5gLby32Apv9nPuiz3HYldcfTgD4MuR2aaQlGWu1tfUaEADaDUatIUPtBrQoEGjcbRrnNdpzm1zPi55faCPZ37xFqIq1IogOicnh6FDhzJ37lzeeOMNV7uqqsyYMYMXXniB22+/HYD58+cTGRnJwoULGTVqFPv27aNv37507dqVrl27Mn78eI4ePUpoaCgTJ05k9OjRNGggW/iKi6hMTnQt2GhFVVXe3fIuADc3uZnmdZpXuk+zzc77yw4D8FjfJvi7seV2aXbEZ/DG73sBeO7GVnRuUKfCfeRZ83h82eMk5SYRFxTHe9e8h1HnuVzt2shqV8g128gusJFrsRUdm+3kmK3kmO3kmm3kOG8FNtfjPIu9WGBcFDDbvDSA1WjAoNWi12nQazUYdM5jLQadBr1Oe06745xe5wgO9VoNumI3x2MtOi3otNoS58+9VqfRoD33WAM6rfPY8RqOaxyBZMlrNWi1RYGqXVH5aOURNhxLAxw7dN7RuR46rdYRoDr71mgcAWphf1pnAKsp6kt7TnBb6uPiAfE51wlxuakVQfSYMWMYNGgQ/fv3LxFEHzt2jKSkJAYMGOBqM5lM9OnTh7Vr1zJq1Cg6dOjgSvU4evQo+fn5NG3alNWrV7N161Zmz55drjGYzWbM5qLf6rOysjz3BoV3UxS360RbbAop2Y4/N948E7321Fo2Jm3EoDV4LKXh203xJGbkExlk4v4rG3qkz8w8K6O/2orVrnJ9myhG9IircB82xcbT/z7NvrR91PWpy4f9PyTYFOyR8XmDfIudtDwL6bkW0nItpDuP86yF9xYy8iyk51rJMRcFwmabUqXj8jXo8DFo8THo8DXoMBU+drQXntPrMBm0GHVajHrHzeA8Pve+2DmTTovhnHNGndYVBBu0WnTFAuZLZZOR9FwLj3yxmc0n0jHoNLx1Zwdu7VSvpoclxGXD64Pob775hq1bt7Jp06bzziUlOYrHR0ZGlmiPjIzkxIkTAAwcOJD777+fbt264evry/z58/H39+exxx5j3rx5zJ49m5kzZxIWFsacOXNK5FIXN2XKFF599VUPvztRK1hzi44rOBN9OjMfVQUfg9ajVSk8SVEVZmydAcA9Le8hJqDydWTzLXZmLnfMQj9+bTN8DLpK96koKk9+v53EjHwa1PVj2l3tKzz7paoq/934X/5N+BeTzsTMa2dSP7B+pcdWleyKSkp2Aacy8jmVUUBaseA4LddCRp61xOPKBsMmvZZAHz3+Jj0BJsd9YOG9v0nvOGfUE+CjJ8Ckc7Qb9a5A2Neow0evKxYsazHptTJT6WEnz+Yx/PONHE3NJdBHz8cPdOHqJmE1PSwhLiteHUTHx8czbtw4lixZgo9P2auLz/3HWVXVEm2TJk1i0qRJJR73798fg8HAG2+8wa5du/jtt98YNmwYW7ZsKfU1nnvuOSZMmOB6nJWVRf363v3hKzzEmQ+t0YKhYrPJznzomBBfrw0i/jz2J/vT9hNgCOCRdo94pM8v15/gTLaZeiG+3N3VM39P5q46yt/7UjDqtXw4tDNBbuRKfrH3C7498C0aNPy3139pH97+4k+qYvkWO4kZ+SRm5HMqI5/E9ML7wltSZkGF0yKMOi11/A3U8TNS199IHT8jdfwN1PUzUqfwcYifgUAfPQEmA/4mHYEmA34mHQadtoreqfCUXQmZPDRvI6k5FmKCfZg34gqaR0oJOyGqm1cH0Vu2bCElJYUuXbq42ux2O//++y+zZs3iwAHHDmhJSUlER0e7rklJSTlvdtpp//79fPXVV2zbto3PPvuM3r17Ex4ezpAhQxgxYgRZWVkEBQWd9zyTyYTJZPLwOxS1gisfOtCRTFkBzvJ23prKYbVbmbltJgAj2o6gjk/F84vPlWO2MXvlEQDG9W+GUV/5oGzT8TSm/eX4+/7Kza1pW6/i6RdLTyzlnc3vAPBU16fo37B/pcdVHhl5Fk6m5ZGYnl8yWC42s3wxeq2GqGAfYoJ9CQs0uoLjED8jdc8Llo34G3Ve+0ubqJxVh87wnwVbyLXYaR0dxOcPdSPSgzuACiHKz6uD6H79+rFr164SbQ899BAtW7bkmWeeoXHjxkRFRbF06VI6deoEgMViYeXKlUydOvW8/lRV5dFHH+Wdd94hICAAu92O1WoFcN0rStXmBYpayFUj2p1FhQWA9wbR3x38jsScRMJ8wxjaaqhH+vx89THSci00CvPndg/kZ6bmmHl84VbsisqtHWO474qKLwTecWYHz616DhWVe1rcwwOtH6j0uM6lqioJ6fnsPZ3FnlNZ7D2VyZ5TWZzOLLjocwNMeuqF+FKvji8xIT7EhPg6Hhe2RQT6XDJ5vMJ9i7Yl8PT3O7EpKj2ahvLR/V2keoUQNcirg+jAwEDatm1bos3f35/Q0FBX+/jx45k8eTLNmjWjWbNmTJ48GT8/P+67777z+ps7dy4REREMHjwYgB49ejBp0iTWr1/Pn3/+SevWrQkJCany9yVqmUrViM4DvDOIzrHk8PGOjwF4rMNj+Bn8Kt1nZp6VOauOAjC+fzP0lUwNsCsq47/ZTnKWmSbh/rx5W7sKz7DGZ8UzdvlYzHYzfWL78MwVz1R6ltZmVzhyJpe9pzPZk1gYNJ/OIjPfWur1kUEm6oX4OoLjOo7gOCbYGTT7eqx+trg0qarK3FVHmfzHfgAGd4jh7bs6eORbHiGE+7w6iC6PiRMnkp+fz+jRo12brSxZsoTAwJL5YcnJyUyePJm1a9e62q644gqefPJJBg0aREREBPPnz6/u4YvawAM1or1xx635e+eTbk4nLijOY7v0zV11lOwCGy0iA7m5feUXKM5afpjVh1PxNeiYfX+XCpfJyzRnMnrZaNIK0mhVtxXTek9Dr61YH/kWO/uSnLPLjhnm/UnZpS7gM+g0NIsIpE1MEK1jgmgTE0yr6ECZLRRuUxSVN//Yx6erjwEwsmcjnr+xlVubCwkhPKvWBdErVqwo8Vij0Zy3cLA0kZGRHD9+/Lz2l19+mZdfftlzAxSXnkrViC5M5/CyGtGp+anM3+P4pXFs57EYtJUP8s7mmPlsjeODfsKA5pX+kF9zOJUZyxy7Hb55W9sKL5yy2C2M+2ccx7OOE+UfxQf9PijXbHtSZgFL9yax6Xg6e09ncfRMDqWt6/M36lyBcutoR9DcLDIAk77ylUiEAEet9ae+38mvO04B8MKNrXikd+MaHpUQwqnWBdFCVDtXTnTFgjhFUb12t8KPd3xMvi2fdmHt6N/AMwvsPlp5hDyLnXb1ghnQuvSFveWVnFXAuG+2oapwT7f63N45tkLPV1WVl9a8xJbkLQQYAviw34eE+4WXef3x1Fz+2pPE4j1JbDuZcd75sAATbWKCCm/BtI4JomFdP5kNFFUmu8DKqAVbWHvkrNSAFsJLSRAtxMW4ORN9NteCxaag0UBUsPesnj+ZdZIfDv4AwBNdnvBIFYfkrAK+WOeozf7kgOaV6tNmV/i/hdtIzbHQMiqQSYNLr91+IbO2z+KPY3+g1+iZ3nc6zeo0K3FeVVUOJGezeHcSi3cnsT8pu8T5Lg3r0Ld5OG3rBdMmJogIqX4gqlFKVgEPfr6Jfaez8Dfq+PiBrvRsJjWghfA2EkQLcTFu5kQ7Z6EjA328qvbuzG0zsak2etbrSbeobh7p84N/DmO2KXRtWIc+zcue8S2Pd5YeZOPxNAJMembf36XCG7UsOrSIOTvnAPDyVS9zVcxVgOObgR0JGSzek8Rfu5M4fjbP9RydVsNVjUMZ2DaKAa0jpWSYqDFHzuQw7NONJGbkExZgYt5D3dwq6SiEqHoSRAtxMW7ORJ9ypnJ4UT70nrN7WHx8MRo0jO883iN9JqTn8fXGkwA8OaBFpWahl+1LZvYKR43pqXe0p1GYf4Wev/bUWl5b9xoAj7Z/lJsb38K6I2dZvPs0f+1JJimrqNycUa+ld7Nwrm8bRf9WEYT4eeeOkuLyse1kOiPmbSI9z0pcqB9fjOhOg9DKV82pdRQ7nFgLe/8HHe6B2K41PSIhSiVBtBAX42adaG/caGXGlhkADGo8iBZ1W3ikz5nLDmO1O+rWXtUk1O1+EtLzmPDdDgCGXx3HoPbRF3lGSQfTD/LkiiexqTa6hPYj/nBvrvhtWYnNTPyNOq5tFcn1baLo2yK8wtU+hKgqy/YlM2bhVgqsCh1ig/lseDdCAy6jDb7sVjj2L+z7Bfb9BnmpjnatToJo4bXkE0SIiym+Y2EFeFt5u7Wn1rL+9HoMWgOPd3rcI30eS83lh60JAEy4zv2g3GJTGLNwG5n5VjrEBvPcjS0r9Hyz3czopePJseag5jdmxZprQHWMq46fgetaR3J92yiubhJW4fQQIarad5vieW7RLuyKSt8W4XxwX+fL4xc8mxmO/OMInPf/DgUZRed860CLQdByUI0NT4iLuQz+lgpRSZXMifaGdA5FVVyz0He3uJt6AZ5Z5T/j74PYFZVrW0bQpaH7W4ZP+XMfO+IzCPY1MOu+zhUqE3csNZfHfn+dZOJRrEHknryfyEB/rm8TxcC2UVwRV7fSm74IURVUVWXW8sO8s9RRyvGOzrH89452XrWGwuMseXBkmSNV4+BfYM4qOucfDi1vgtaDIa4X6KS+uvBuEkQLcTFu5kQXpXPU/CK1HWd2sC9tH356Px5p/4hH+jyQlM0vhfVrJ1zX3O1+/th1ms/XHAdg+pAO1K9bvhzQzDwr7y07xIKtazE1/BONBroHjeTx//SnY2yIlJ8TXs2uqLzyy26+XO9YTzDmmiY8Vck1BV7LnA2HlsDeXxz31qJFvQRGQ6ubofUt0OAqR/qGELWEBNFCXIybM9GnMp1BdM0vDFoZvxKAPvX7UNenrkf6fHfpQVQVbmwX5Xb1gOOpuUz8YScAo/o0pl+ri9eXttoVvlp/ghnLDpGRV4Bf3A9oNApXRV7DnOsfcmscQlSnAqudcd9s4689yWg0MOnmNjx4dVxND8uz8jPg4GJH4Hz4b7Cbi84FN3DMNre+Bep1Be0lPPMuLmkSRAtxMZbChYUVyInONdvIyLMCEOMFM9H/Jv4LQO/Y3h7pb1dCJov3JKHRwBP93Z+FfvmXPeSYbVwRV5enB1w4p1pVVZbvT+HNP/Zx9EwuADENN5Ptm0igMZDJfWTnUeH9MvOsjPxiE5uOp2PUaZlxT0dubFexRbReqyDTETTv/R8cXQGKtehc3caOoLnVYIjpBJfijLu47EgQLcTFuDET7cyHDvLRE+hTs3l9p3NOcyj9EFqNlp4xPT3S5/SlBwC4tWM9mlVwO26ntUdS+ffgGfRaDW/d1f6Cecv7Tmfx5u/7WH3YsWI/1N/IiL5BzDvxJ9jh6a5PE+Yrm1EI73YqI5/hn2/kYHIOgT565g7rypWN3a9o4xXsNjj6D+z42rE40FZURpLwlo6gufUtENlGAmdxyZEgWoiLcSMnumhRYc2ncqxKXAVAh/AOhPiEVLq/bSfT+efAGXRaDeP6Nbv4E0qhqipTFzsC8fu6N6BhaOn1oM9km5m+9ADfbopHUcGo0/JQzzhG923CU6vGUGAvoHtUd25tequ7b0eIanEwOZsHP9vI6cwCIoNMzB9xBS2jgmp6WO5L3gPbF8Ku7yEnuag9rAW0u8uRrhHumTKaQngrCaKFuBC7rWhmxVT+GVdvWlS4MsGRD+2pVI6FGxwLoW7pGENcBTdDcfprTzI74jPwNeh4/Nqm550vsNr5dPUxPvznMLkWOwCD2kXz7A0tqV/Xj58P/8z60+sx6Uy8fNXLl+ZiLHHJ2Hw8jYfnbyYz30qTcH++eLi7V9WPL7ecFEfQvONrSNpV1O5b1xE4d7wXojvKjLO4bEgQLcSFOPOhoUIz0a7dCmv4g7LAVsDG0xsB6FWvV6X7y7PY+GPXaQDu6dbArT5sdoW3lzhmoUf2akREYNEvGqqq8tvO0/z3z/2u2fz2scG8dFNrusU5FkSm5qfy1qa3ABjTcQwNgtwbhxDVYeneZB5fuBWzTaFzgxA+fbAbdfxr0e6Y1gI48Afs+MaxQFB1/FKL1gAtrocO90LT60Bfi96TEB4iQbQQF+LMh9YZK/Qh4S0brWxM2kiBvYBIv0ia13F/AaDT4t1J5FrsNKjrR7c49+pC/7QtkcMpOYT4GXikd2NX+7aT6bz+2162nswAIDrYh4nXt+CWDvVKlKv778b/kmXJolXdVjzQ+oFKvR8hqtI3G0/y/KJdKCr0axnBrPs642usBSXcVBXiN8KOhbB7EZgzi87V6+rYirvtHeDnmUo/QtRWEkQLcSFu1og+5SUbrfybUFSVwxMpDz8W7k54R+dYt/orsNqZUbixxJi+TQnyMZCYkc+0xfv533ZHzWlfg47H+jbhkV6Nzws4/jn5D38d/wudRserV7+KXiv/hAnvc+4mKkO6xjL5tnbev+lP+gnY+a0jXSPtaFF7UCx0uBva3wPhlf9lXIhLhXwCCXEh7u5WmF7z6RyqqrIqwbGosE9sn0r3l5iRz9ojZwG4vbN7Ox5+uf4EpzILiA724YGrGvL95nhe/Hk3ZpuCRuMIzp8e2ILIoPNzybMt2byx4Q0AHmzzIK1CW7n/ZoSoInZFZdIve1iw/gRQCzZRseTBnkWw/Ss4saao3eDvqKrR4R7H7oFSy1mI80gQLcSFuFEj2mpXSMpyLEasySD6cMZhTuWewqQzcUX0FZXub9HWBFQVrmxct9y7ChaXVWDlg38OA47a0r/tPM3EH3eiqtC9UV1euqn1BTdteW/re6TkpdAgsAGPdXjM7fchRFUpsNqZ8N12/tjlqKH+yk2tGd6jUU0Pq3Rnj8Dmz2Dbl1CQUdiogcZ9HHnOLW+q8OSBEJcbCaKFuBA3ZqKTswpc5djCAkxVNLCLc6ZydIvqhq++csG8qqr8uDURcMwWu+OTf4+SnueoTqDTanjqhx2oKjxwZUNeu6XNBWfqtiRv4dsD3wLwylWv4KOv+aonQhSXVWDlkfmb2XAsDaNOy/S7O3BT+5iaHlZJit2xi+CmT+DI8qL2kIbQ5UFofzcEu/f3W4jLkQTRQlyIOzWiC1M5okN8SiyIq27F86Era+vJDI6l5uJn1Lm1u9qZbDOfrD4GQN8WETxdGEDfe0UDXh184QDabDczae0kAO5ododHZtWF8KTkrAIe/Gwj+5OyCTDpmTOsC1c38aLNf3JSYOsXsGUeZMYXNmqg2QDoNhKa9gNtLVjwKISXkSBaiAtxYyb6VGbN50NnmjPZcWYH4Jkg+octjgWF17eNwt9U8X82Zi0/RJ7FTlyoH5+vOYaiOhZbvXlr24v+ojFn5xyOZx0nzDeMJ7o84db4hagqR87kMOzTjSRm5BMeaGLeQ91oE1N2WlK1UVU4ud4x67z3f0VbcPvWhc4PQNcRUCeuRocoRG0nQbQQF+JGTrQ3LCpce2otdtVO05Cm1AtwbxGgU4HVzm87HZUz7nQjlePk2TwWbnRs0HIyLQ9Fhds71WPK7e0vGkAfSDvAZ7s+A+CF7i8QbPKC4ESIQtvjM3jo842k51mJC/VjwcPd3Vov4FHmHNj1HWz6FJJ3F7XHdnPMOre+FQySDiWEJ0gQLcSFuDET7Q01op2pHL1iK7/BytK9yWQX2KgX4suVjUMr/Px3/z6I1a6iARQVBneI4a27OqC7SABtV+xMWjsJm2qjX4N+9G/Y3813IITn/XMghdFfbiXfaqd9bDCfDe9Wo2sgOHPAMeu8/euiX/71vtDuTkfwHNOx5sYmxCVKgmghLsSNnOiEGp6Jtit2VieuBqB3Pc+lctzeuV6Fc7z3nc7i522OBYkqjq27pw+5eAAN8NW+r9h9djeBhkCe7/58hcctRFX5cUsCz/y4E5ui0rt5OLOHdnYrzanS7FbY/7sjeD6+qqi9bhNH4NzxXvB1b1MkIcTFSRAtxIW4MRN99EwuAHFh/lUxoovalbqLDHMGgcZAOkZ0rFRfyVkFrDp0BoDb3UjleO6nXaiFx9e3iWLGPR3LteFEQnYCs7bPAmBC1wlE+EVU+LWF8DRVVZnz71Gm/LkfgNs61WPqHe0x6qu5hnJemiNw3vwZZJ92tGm00OJGR/DcqI/UdRaiGkgQLcSFuHKiyxdE51lsrnSOphE1U2PVmcrRI6ZHpXf0W7QtEUWFrg3r0KiCvxR8vvoY2+MzALi6SV3ev7cThnIE0Kqq8tq618i35dM1siu3N7vdnaEL4VGKovLmH/v4tLDKzCO9GvHcDa2qtwJPxklY9yFsnQ/WPEebf4SjPF2X4VKeTohqJkG0EBfimoku38JC5yx0qL+Ruv7GqhrVBXmqtJ2qqvxYmMpxR5eKfThvOHqW13/fC0BMsA+fP3RFuWfrfj36K+tOr8OoNfLKVa+g1ciMmqhZFpvCU9/v4JcdjgW2L9zYikd6N66+ASTthjXvwe4fQbU72qLaw9VjHbsK6mvm3xohLncSRAtxIRXMiT6c4ri+SQ3NQiflJnEg/QAaNPSs17NSfe1KzORQSg4mvZZB7ctfG3rLiTSGfbYRRQWtBr5+9EpM+vLVoD2bf5Zpm6YB8FjHx4gLjnNn6EJ4TI7ZxmNfbmHVoVT0Wg1v3dWe2zpVw4yvqsLx1bBmBhz+u6i9cV/oMQ4aXwPeupW4EJcJCaKFuJAK5kQfSnGkf9R0Kkf78PbU8ancgiLngsKBbaII8jGU6znb4zMY9ulGzDYFgId7NqJhaPnTQKZunEqmOZOWdVvyYJsHKz5oITwoJbuAEfM2sTsxCz+jjtn3d6FP8/CqfVHFDvt+dcw8n9rqaNNoHaXpeoyFmE5V+/pCiHKTIFqIC3HNRJcvncM5E900vGaC6FUJjhX6lU3lMNvsrq+uy5vKsSshkwc+3UCuxfF1c5CPnsevaVbu11wZv5I/j/+JVqNl0tWTMGjLF7gLURWOnslh2GcbSUjPJ9TfyGfDu9GhfkjVvaC1AHYshLUzIe2oo03vA53uh6seh7qNqu61hRBukSBaiAsxFy4sLOdMtCuIroGZaLPdzIakDUDlg+h/9qeQkWclMshEz6YX3754z6lM7v90A9kFNow6LRa7wmN9mxLsV75AOMeSw+vrXwdgWOthtAltU6nxC1EZW0+m8/C8TaTnWWkY6scXI66o0DcqFZKf7tgYZcNHkOuohINPCFzxKHQfBf5etH14NTtyJoeoIJ+aKR8oRDnIn0whyqKqFcqJttoVTpx1rJiviSB6U9Im8m35RPhF0KJOi0r15UzluK1T7EVrOu9PyuL+TzaQmW+lXh1fEtPziQg0MfzquHK/3ntb3yM5L5nYgFhGdxxdmaELUSlL9ybzf19vpcCqVO0mKpkJsH42bJlX9O9McH24agx0eqBCZTUvJTa7wt/7Uliw/jhrDp/ljVvbcv+VDWt6WEKUSoJoIcpiM4NicxyX4wPtxNlcbIqKv1FHdHD1b6tbvCqHphILjlJzzKw44JgRu7PLhbcMP5SczdC5G0jPs9I2JshV3m9c/2b4Gsu3mHBbyja+PfAtAK9c/Qq++prb6VFc3hZuOMmLP+9CUeGaFuHMuq8KNlFJ2Qdr3ndsze389yWiDfQcD21uA93lmcZ0JtvMNxtPsnDjSU5nFgCOhcnHU3NreGRClE2CaCHK4pwdgnLNRBevzFGZINYdqqoWBdGV3KXwf9tPYVNUOtQPoWlE2bngR87kcO/cDZzNtdC2XhC9moYze+URGoX5M6Rr/XK9lsVuYdLaSaio3Nr0Vq6MvrJSYxfCHaqq8u7Sg7y//DAAQ7rGMvm2duXaGKjcknbDiimw/7eitrhe0GM8NO13WVbaUFWVTcfTWbD+BIt3n8Zqd2zNFOpv5O5u9bmvewNi6/jV8CiFKJsE0UKUxZkPbfAD7cVnVWsyH/po5lEScxIxao10j+5eqb6cqRx3di57Fvp4ai73zV1Pao6ZVtFBvH9PJ26e6dhq/MkBzcu1qQrAZ7s/42jmUUJ9Qnmq61OVGreiqFjsCnZFxWZXsSmOY6uiYi98bCt2zqaojvPO5xSesxc7p6gqdgUUVUVRVBQV7KqKWvjYrjoCAXvhOcXVXvi4sA9FBRUVtfB6RXVkC53XRtE5UFGUkm2qqqJS/J4SjynsA+e54q9BUb/Fn1f4tKLnuI6dR0X94OqjjDbXE4r+u5R5TRmvX9w5D8+7QC37lOt1yzzveh8qpzMLyMi3AhAWYGRHfAY3Ff55vpBz+yzt9RvYT/KA+Wv6WNcAoKBhtf4qvjPdzoG05vArwL9lvq8Lv/7FryxXX+V9QQ91pagq2QVWsgtsrsAZwKTXEuijx9+o449dp/lj12mGdm9YvTW5hagACaKFKIubNaJrIoh2zkJ3i+qGn8H9mZu9p7LYdzoLo07LzR1iSr0mKbOAe+euJznLTIvIQL4a2Z1Zyw+Ta7HTtl4QN7Ytu6a01a6QkWclPc/CyfQUPtn5GQDdg4fz9fpUCqzJmG0KBVY7BVYFs82O2ep47Gp3ttkKr7HaKbApWArL6glRGak5FlJzLJXup5HmNOP0PzJYuw6txhEo/mq/khm2OzhSUA9yoPD/iUJmm4I5x0Jqsbb0vMr/txCiqkgQLURZKlwjuubK2zmD6F6xvSrVz49bHbPQ/VtHEOJX+i5or/++l9OZBTQJ92fmfZ3YeyqTL9YdB6BbXF1mrzxCeq6F9MJgOS3XQnqehfRcC1kFNlc/pohfMYbmY8+vx7crQoH9lRp7aXRaDTqtBkPhvV6nRa/VoNdq0Ok0GLTaomt02sJ7jatNq3HcHMeUeKwpfOw81hWe0xZe63y+xvU80BQ+1uBsdxxrNYDzmuLnil3veFx0HgrP42wvuh4cjylxXlPsOsdjil3rTEFyJhVoNBTrS+Nqw3X+/OvLvPaca4paKDneYv2ef+W5r1/8mlJe7JznnjvurHwr05ce5FhqLkadljHXNKFTgzrn9V3qa5QxJgBT9knq75pJxLGf0aiOX+zO1h9IfPtxhNZpwetlDawCr1HyORdXnvQyT2aTFO/KrqhsOp7G4j1J7E7McrVHB/swsE0UfVuEE3CBvPOoGlhfIkR5SRAtRFkqMBOtKCpHztTMTHSWJYttKduAypW2s9oVft6WCMAdnUvWhj6bY2ZHQga/7zjN7ztPA3DkTC4D3i35NfTna45f9HU0GggKyEap6yjH18rnbqLa18Ok1+Jj0OGj1+Fj0GIqvPcx6IrOFbabzmvX4aPXYtRrXcGwrjCgFeJcx1NzefDzjZw4m0cdPwOfDu9G5waV25yIjJPw71uwfWHRgsHmN8A1zxEa3YHQyg+7VknJKuDrjfF8vfEkSVlFCwX7tYpk2FUN6dEkTP5+ilpPgmghyuKqEX3xjVYSM/IpsCoYdVoa1K3ehTBrT63FrtppHNyY+oHlW9BXmpUHznA210Kov4EAk55PVh1lR0Im2+PTiU/Lv+jzW0YFElvHlzp+Rur6GwnxM1LX30AdPyN1/I2u9mBfA6+sfYn/HbFxRdQVfDJgeLUvxBSXrx3xGYyYt4mzuRbq1/Vl/kNX0Lgy3x5lnYJ/34atX4DiyKumaX/o+zzEdvHMoGsJVVXZeCyNL9af4K/dSdiUooWC91xRn/u6N6ReiFTfEZcOCaKFKEsFZqIPF85Cx4X5eXZFfzn8G19U2q6iFEXlaGoO205m8P7yQwCk5Vm5e876864NDzRxJtuMj17L3Ae70iYmmIk/7OTvfclc3yaKjx4oX8BwOP0wvx79FYBxncdJAC2qzT/7Uxj91VbyrY78/c+GdyMi0M10gexkWD0dNn8OdrOjrVEfuOZ5aHB5VZmx2BR+23mKT1cfY8+popSNrg3r8MBVDbm+bRQmfflKXgpRm0gQLURZKpATfaSGFhXaFTurEx1VBMoTRKdkFbA9PoPt8RnsSMhgZ3wm2WZbiWtUFcICTHSsH0KnBiF0iA2hUbgfg2c6qgs8fX1LejULZ8uJdP7el4xWA08NbF7uMc/cNhNFVejXoB/tw9tX4N0K4b7vNsXz3KJd2BWV3s3D+XBo5wvm4pYpNxXWzICNn4Ct8BuaBlfDtS9AXE+PjtnbZeRZ+GrDSeavPU5KtuMXCR+Dlts61eP+KxvSJia4hkcoRNWSIFqIslRkJrqGFhXuPrubdHM6gYZAOkZ0LPO6PacyefK7HexPyj7vnK9BR0SQiRNn84gN8eXb/1xFTLBPiRniN3/fy9lcC03C/Rl2VUNUVWXqYsdCwLu61L9gPenidpzZwfL45Wg1Wv6v0/9V7M0K4QZVVZm5/DDTlx4E4PbO9Zh6R/tyl2F0yUuDtTNhw8dgLdwAJLYbXPMCNO57WdV5Pnomh8/WHOOHLQkUWB2LJyMCTTx4dRz3XdGAOv6lL0oW4lIjQbQQZalATnTxjVaqk7Mqx9X1rsagLX2ns+83x/Piz7sx2xQ0GmgeEUjH+iF0qB9Cx/ohNI8M4PbZawEY0bPReTmLR8/kMG/tcQBevKk1Bp2Wfw6ksPFYGka9lnH9m5VrrKqq8t7W9wAY3GQwTUKauPOWhSg3m13hpf/t4euNJwEYc00TnhrQomIpRAVZsG4WrPsQLIX/JsR0cgTPTftfNsGzqqqsO3qWT1cdY9n+FFd76+ggRvZqxE3tYzDqqzeVTYiaJkG0EGUp50y0qqqu8nbNyjkj6ymrElYBpadyFFjtvPrrHr7eGA9A3xbhvHNXB0IDTCWuO5Sczc6ETPRaDbd0PL829Ju/78NqV7mmRTjXtIhAUVSmLT4AwINXNSSmnAuF1p1ax6akTRi0BkZ3GF2h9ylEReVb7Pzf11v5e18KGg28NrgND1wVV/4O7FbYMg9W/BfyCisXR7Zz5Dy3uOGyCZ4tNoVfd5zik9XH2Hfake+s0UC/lhE83LMxVzauK+saxGVLgmghylLOnOjUHAuZ+VY0Gmgc7l8NA3NIzk1mX9o+NGjoWa9kLmZ8Wh6jv9rKrsRMNBp4on9zHr+maaklpX4orA3dt0XEeQH2igMpLNufgl6r4cWbWgPw5+4k9p3OItCkZ3TfpuUaq6IqzNg6A4B7Wt5DdEDZG7K4w7nzoNWuuHYKtJ+zy6BSuAuhc8dBu4JrV0JFLWWHQtWxs1+Jewp3F1QcO7M5z52/4+D5zwVK7CpYfBfB4o8pdm3JXQrL3k3QcX2xnQpLOXf+jn0ldxJ0ja+UPku2ndNQvO2c/s7to/TzZZ8r7fnnPamUpnyLnb/2JJGSbUan1XBNi3BOpuXx5u97z3/euX2pKs0zVtEv4QNCzY4Z7FSfBqyIGcW+On3hsBYO77t4P2Uo9f242ZenlLbzYYHVzsHkHPYnZZNvtQOg12poEu5Pq+gggn0NLN59msW7T5fsy8Nj69UsnOtaR3q4VyE8Q4JoIcpSzploZypH/Tp++BiqbwX6qkTHLHS7sHbU9anral9xIIXx324nI89KiJ+B9+7pRJ/m4aX2YbMrLNrqqA19Z5eStaGtdoXXf3MEHcOvjqNJeACqqjJn1VEAHuoRd17uo6Ko5Fvt5Jpt5Jht5Jrt5FpsrD71N/vS9mHU+uKTex0z/j5IrtlGrsVOntmx9a8zCC5+bFNULDbHvdWuYLUpWAuPbXbHNt9Wu1LtQYeoPeyKyt/7Ui5+IdBBc5jnDQvprnXk+6eqQcyw3cE3Bddgy9ADJ6pwpN7PpqgcSM7hQHL17bQYYNJLEC28lgTRQpSlnDnRh2tok5VzdylUFJX3lh3i/eWHUFXoEBvMB0M7E1un7LrVqw+nkpJtpo6fgWtbRpQ49+X6Exw5k0sdPwO3doph5cEzrDp0hh3xGWg1jucuP5DiCJTNNnLNNvKs9lICWjv+jT9Ca4Ls5B5M33PKkz+GC3LtJOjcfEWD47jYZiza4tcUa9fg2HUQKLHzoMa5kyBFuwpqS7SVvLb48127ChYbH6XsJOjcLdC5q2Dx55W2w9+5GwGW2NWw2Gudu5tgyW/hy95psMRzStlt8PxrL77zXnn6udDzS7Y7TpzKyGfpXsfW8YE+em5oG0WdMnbeLP5CweZT9In/iDZnlwBg1ZjYFH0v66MfIEAfwMgLvHYZXV74Oo/uDlj53QhVVSUxPZ9t8RkcP5vnag8PNNGpfgjNIgJcfxeqW7dGdS9+kRA1RIJoIcpSzpnomihvZ7FbWH/aUcu5T2wf0nMtjP92OysPngFgaPcGvHxz64vWZv2xcBZ6UPtoTqblcjw1j+NnczmYnM1Phecy863cVFjezklRYevJjDL71WrA36jH36RHG7SebFMqOjWQHuG3ExQbgL9JT4BJj79Rj59Rh1GvRa9zbL1tcN0XHeu1Wox6DXrtOe06DcbCa/U6x3nnFt2O7bglV/Ny8eOWBD5fcwyrXaVzgxDmDut6XnrSefLTYdU7sOtjsFsADXS4F8O1L3B1cCxXV8vIa47NrvD7rtN8tPJoiXzn/q0iGdmzEVc0knxnIS5EgmghylLOnOiaKG+3OWkz+bZ8InwjsORFcdPc1SRm5GPSa5l8WzvuOCc1Axw5jkfP5HLibC7Hz+ZxOCWb33Y6ZoW/Wn+SL9efLPW1FBVMei3RwT6uWarHr2lCy+ggV6Dsb9K5jgNMenwMWjQaDfm2fG76aTLZ+fB09zEMbdWr6n4o4rKkqirv/n2I95c5Ngsa1D6ad+7qcOHUKpsFNn8KK6c6AmlwbJQy4A2IvvRrl+db7Hy/JZ45/x4lId1R69rPqOOuLrE81KMRcWHVt7ZDiNpMgmghylLBnOjqLG+3MmElANHGTtz10XosdoWGoX7MHtqF1jFBJa7NNdv4ZNUx5q46Ss45G6s4qThyDxuG+lHXz8jqw6mowMs3teaGdlFEBvrw+u97+XzNcXo3D+epgS3LNc6v939NSn4KMf4x3NX8rsq8ZSHOY7bZeeaHnfy83fHL4Oi+jhJ2pS2gBRwr9vb+D/6eBOnHHG3hrWDA65dFubrMPCtfrDvOvLXHOZtrARxbcj/UI44Hrowj2K/0MplCiNJJEC1EWVwz0WXnRGcXWEnKKgCqL51DVVVWFuZDr98dgc2u0L9VJO8M6UCwb9GHoMWm8PXGk8xcfojUHMcHZoifgbhQfxqG+rHxWBqnMwsYdlVDxvZrRmjhIsH75m5ABW5sF8WIno0AR0rHd5scpfJGFrZdTKY5k092fQLAmE5jMOpkAwbhOem5FkYt2MLG42notRrevK0td3drUPYT4jfCXy9AwkbH44BIR63njkNBd2l/FCZlFvDp6qMs3HCSXIuj0kZsHV9G9W7MXV3rV+uCaCEuJZf2vxxCuEtVyzUTfeSMY+eyiEBTiQC2Kq05uZfEnARURYeS15Rnrm/JqN6NXbNviqLy685TvLPkICfTHOkXDUP9eGpACwa1i0ar1XD0TA7XvrMSrQYev6YpYYW5o4t3J7Hu6FmMei3P3dDK9ZrfbnJ8+DaPDKBXs7ByjXPennlkW7JpGtKUQY0GefinIC5nx1NzeWjeJo6l5hJo0jP7/i70LOvP5dkjsOxVxww0gMEPrh4LV//fRVO1arvDKTnM+fcIi7YlYrU7Vvy2jArksb5NGNQuGn1Fd20UQpQgQbQQpbHk4qp4eoEP2kPJjgoe1TUL/ffeZJ5Y/CWEgtbchC9H9Obqpo7gQVVV/j2UyrTF+9lzyrFIKCzAxLj+zbinW/0S2xw7Fw32bh5ORJAP4MiZfvMPR0m7Ub0bU7+uo6qHza4wb81xAB7u2ahcC43O5J3hy71fAjC201h0WpnpEp6x6Xgaj36xmfQ8K/VCfPn8oW40jyzl26K8NFg5DTZ9AooVNFrodD/0fR6CPFun3NtsO5nORyuPsGRvsqtaTvdGdflP3yb0bR4uiwWF8BAJooUojXMWWqN1zFyVobrK29kVlelLD/DBP0fwbbAXPfDYFTe7Augd8RlMXbyf/2/vvuOqLP/Hj7/O4rBB9kYQcOFAHLk1R8ts18eG2ra0Mlv2a2nfT9m0sj5ZNsymtszSLM2FIxVxiwoqW/benHH9/rjhwBFUUBDU6/l48ODc49znui8F3uc67+t9bTueDyj5zQ+PCOW+YSE46K1/zM1mwa+1C6w0rA39xZYk0goq8XbWM21k/ZLcqw9mcbK4CncHG27o69+s9n66/1OqTFX08ezDqMBR53HnklRvxd4MnvlpPzUmM30CXfl8cn88nU6pwGEyKoHzxtehqljZFzYWxr0K3j0vfKMvkLo30Qs3HmP7iQLL/vE9vJk2qgv9gjq1Y+sk6dIkg2hJakp1g1SOM4zaXIjydnll1TyxdA9bj+WDugqdQwoCmBA2hhO5Zbyz5ih/HshSmqtRc8/gYKaPDsPNoekc5H9P5HOyuApnWy1juyuLGGSXVPG/DccAmH1NN0vgLYTg89rFVe4ZHNys3MnUklR+SfgFgJn9ZspRL+m8CSH4aP0x3l2bAMDVPX14746+2Nmc8v8xKQZWPwc5tSsTekcqwXPYmAvc4gvHaDLz58EsPtl4nPjaMnVatYobo/yZNjKUMK8z17mXJOncySBakppSU7vQSjMrc7RVebu9aUVM+yaOrJIq7HQa7h5Tw9IUE4GOwXz8TxE/7jqAySxQqeCmKH9mjYs44+IqoNTTBZjQx88SFL/111EqakxEBblyQ5/60ea4lEL2pRdjo1Vz9xXBzWrzR3s/wiiMDPMfRn+f/ud455KkqDGa+X/LD/Bz7f/bh0aEMvvqbtYVOIrSYM2LEP+bsm3XCca8DP2mwCWaSlRlMPFTXDqfxZywzH2wt9EwaWAQ9w8Lwc/Vrp1bKEmXPhlES1JTmlGZo8pgsvzxaouR6Gqjifu/iiW/vIZQTwc+uTuaz4/MAyA5LYj4LKWu85huXjxzdVe6+Tif6XIAlFUbWX1QGbWuS+XYm1bEL7XpHa9c39MqOPl8s1IG7OYof8vkwzM5UnCE1UmrAXii3xPNvVVJalJxhYFp38bx74l8NGoVcyf2tH4zZ6iCbR8qC6YYK5X0q/73KVU37C/Nle7Kq418tyOFRTFJ5JVVA+DmYMPUIZ2ZPDgY19Ot0ChJUquTQbQkNcWy5Pfpg+Pk/HLMApxstY3zMlvB5oQ88str8HLS8+NDV/DL7jRWH98AGqgu6Up0cCdmX9ONAZ2bHyz8eSCTSoOJUA8HogJdMZsFc34/BMDN/fzpG+hqOTclv5y/45WA+75mlrX7YPcHAFwTcg3d3JpXS1qSmpKaX8G9X+3keG45jnot/7urHyMjPJWDQsDRP+Gv56EoRdkXNASufQt8erVfo9tQcaWBr7cl88XWJIoqDAD4u9rx0IhQbu8f2Di1RZKkNieDaElqSjPK2x1rkA/dFnm/f9SuJhjh7cTEj7aSVZ2IQ0gZKrMtH950M9dEBrT4detSOW6JVp7729509qYVYW+j4bmrrYPexVuTEQJGRng2Xf3gFLFZsWzJ2IJWpWVG3xktapckNbQ7tZAHl+wiv7wGXxdbvpw6gO6+tZ+05CUqec/H1ynbTr7KSoORt1ySi6UUlNeweGsSX21NprR2saQQDwceHdWFG6P8raruSJJ0YckgWpKaYhmJPn3w2Jb50JU1JtYcUkaBtxzLA8A94Bg1wJjOw7m2V2CLr5lWUMGOpAJL/nR5tZE3Vh8BYProMLxrS91B7eIqu2oXVxl+9lFoIYRlFPqWiFsIcj7DoheSdAar9mcy68e9VBvNRPo788WUAcr/zaoSiHkLti8EsxE0NjB4Ogx/+pKs95xTWsXnm5P4dnsKFbULpER4OzLjynCu6+WL5nSrMkqSdMHIIFqSmtKMkejE2iA63Lv1/4CvP5JDpcGsNEGr5pnxXVlTtIQjhTAycMQ5XbMu73loFw/8XO14d81RskuqCXSz4/5T0jWW7kylosZEV28nhoWdfXGVjWkb2Ze7D1uNLQ/3fvic2idd3oQQLNx0nLf+OgrA2O7eLJjUF3utGvYthbUvQ1m2cnL4VXD1PHDvcoYrXpxOFlXy6abj/BCbRo1R+R0Q6e/MjNHhjO/hffolzSVJuuBkEC1JTbFMLDzDaoVtWN7uj30nLY8n9vHjxv5OLPjpMADD/Ie1+Hpms7AE0bdGB5BWUMGnMUrpuheu7W5Vus5gMvPVtmQA7h9+9sVVTGYTC/YsAODuHnfjae/Z4vZJl7cqg4nnftnPir3K//v7hobwwnXd0WTtgz+fqV+q2y0Urn4DIq5qx9a2jdT8ChZuOsbPcemW1QX7Bbny2JhwuUCKJHVQMoiWpKacZSTaZBacyFOW/A7zbN06rKVVBtYdybZs3zkoiM0ZGwCIdI/Ew655y243FJtcQFpBJY56LVf19OGpn/ZSYzQzONSdq3r6WJ3754FMMour8HDUc0Nfv7Nee1XSKo4VHcPZxpl7I+9tcduky1tGUSUPf7OLgxklaNUqXrm+B/f0doJVMyFuCSBA5wAjnlbSN7StP4m3PR3LKeXjDcdZse8kJrMSPA8OdeexK8MY3MVdBs+S1IF16BkJ8+bNY8CAATg5OeHl5cWNN97I0aNHrc4RQjBnzhz8/Pyws7Nj1KhRHDp0yOqcWbNm4ebmRlBQEEuXLrU69uOPP3L99de3+b1IF5mzVOdIK6igxmhGr1Xj36l167Gujc+2jER19XEiKtCVmPQYAEacYyrHT7UTCq/r5cu+9CL+PJCFWgUvX9/D6o+0EIIvtihl7SYPDkavPfOM/xpTDf/b8z8A7u91P842Zy+zJ0l1diYVMPHDLRzMKMHNwYZv74vmHs1a+LAfxH0FCIi8FWbEwvBZl1QAfTizhOnf7WbcezH8uicDk1kwqqsnP08bzA8PXcGQMA8ZQEtSB9ehR6I3bdrE9OnTGTBgAEajkRdeeIHx48cTHx+Pg4MDAG+99Rbz58/nq6++IiIigv/+97+MGzeOo0eP4uTkxB9//MH333/PmjVrSExM5N5772XcuHG4u7tTVFTECy+8wLp169r5TqUOxzIS3fQoc92kwlBPx1af4PP73gzL4zsHBmEwG/j35L8AjAhoeRBdXm3kzwOZgFLGbs4fympudw4Kqq94UCs2uZD96cXotWruGnT2yYE/JfzEyfKTeNl5ManbpBa3Tbp8fbs9hTm/H8JoFvT0c2bxGDNea2+B7APKCd6RcM1b0Hlo+za0le1NK+Kj9cf453D9p01X9fRmxuhwegW4tGPLJElqqQ4dRP/1119W24sXL8bLy4u4uDhGjBiBEIL333+fF154gZtvvhmAJUuW4O3tzffff8/DDz/M4cOHGTVqFP3796d///7MnDmTEydO4O7uzrPPPsujjz5KUJCsJCCd4iw50cdy2yYfurC8hs2JSjUOvVbNjVH+7MqOpcJYgYedB93durf4mqsOZFJRYyLEw4FjuWUczizB2VbLrHFdG51bt8T3zf0CcD/L4irlhnIW7V8EwLS+07DTyhXSpLOrMZp55fdD/LBTWSzojkgHXnNYivanb5UTbF3hyhch+l7QdOg/US0Sl1LIB+sSiUnIBZRqfBN6+zFjdBhdfeTS3JJ0MbqofkMVFxcD4OamLC6RlJREVlYW48ePt5yj1+sZOXIk27Zt4+GHH6ZPnz4sWrSIwsJCTpw4QWVlJWFhYWzZsoXdu3ezcOHCZr12dXU11dXVlu2SkpJWvDOpwzlLTnRblbf761AWtZkcXN/HDxc7HZsPbAZguP9w1KqWZ2DVLZc8obcv765JAGDm2AjcHKxXNkvOK2dt7ejY/cM6n/W6X8d/TUFVAcHOwdwYdmOL2yVdfnJLq3nk2zh2pRSiVpn5sncCI1M/QlVZoJwQdTeMnQsOLc/776hikwv44J9ES6lKjVrFTVH+PDKqC13aoDymJEkXzkUTRAshmDVrFsOGDSMyMhKArCyljq63t7fVud7e3qSkKKtYXXXVVdx9990MGDAAOzs7lixZgoODA4888ghfffUVCxcu5MMPP8TDw4NFixbRs2fPJl9/3rx5zJ07tw3vUOpQzjYS3UaVOZbXVtAAmDRQ+YTEkg99DqkcKfnl7EwqQK2CvLJqCspr6OLpwD2Dgxudu3hrEkLA6K6ehHmdeWSsoKqAJYeWADAjagY6ta7FbZMuL/vTi3jo6ziySqqIts3gS48fcDm6Wzno1QOumw/Bg9u3ka1ox4l8PliXyLbj+QBo1SpujQ5g+ugwAt3s27l1kiS1hosmiJ4xYwb79+9ny5YtjY6dOvlCCGG1b86cOcyZM8dqe+zYseh0Ov773/9y4MABVq5cyeTJk4mLi2vy9Z9//nlmzZpl2S4pKSEwsOULXkgXiZraiYVN5EQLISxBdGvWiM4pqWJnciEAoZ4O9AtyJbk4mdTSVLRqLYP9Wh5g1I1C9+/sxk+7lMcvX9+z0SpnxRUGy+TD+4eFnvW6nx/4nHJDOd3dujM+ePzpTzSbwFQDxmowGcBUfcrjGuW4MCnnChOYzSDMp+wzKfvqths+NputzxFmQNQ+FsqX1fapx0/ZhgaPGzwfzmEfp+xrsN3UvmZvn+46p+xv9nOa4Yznn+ZY7XMyiyvJzSxlnjDS1S4LX5GNKg9QacA9DFwCYOv7sOW95jbmPNvbUs2/VmGFgZT8ciorDDwEPGwDPi62BLnZY1epgVXt064LplX7HWUlyn73tO41JamVXBRB9GOPPcbvv/9OTEwMAQEBlv0+PkpprqysLHx9fS37c3JyGo1O1zly5Ajfffcde/bs4csvv2TEiBF4enpy++23c99991FSUoKzc+MKA3q9Hr3+0pkZLp3FGUais0uqKas2olGr6Ozu0GovuXJ/fW3oKYM7o1KpLKPQ/b3746Br2WuZzMKyzLe9ToPRLBga5s7IiMZ1nH+IVRZX6eFtz1BfoSytXFEAlQWNvmeWZ7G0Kh5UMDMrDfXHQ5SA2GSoDZAbPBam8+gR6VLhC/jWvW+ziulNkHdU+bpEdKr9omFhm9LaL6nl/KLauwWSdFodOogWQvDYY4+xfPlyNm7cSEiI9apqISEh+Pj4sHbtWqKilB+0mpoaNm3axJtvvtnk9R566CHeffddHB0dMZlMGAwGAMt3s9ncxnclXRTOkBNdNwod7GaPjbb1qkQujVWW2daqVdwY5Q+cXyrHtuN5nCyuwkmvYX9yJqPUB3nBxx42xVgFxuaKAq47mcEkfQkuxRXwzpmv+5GHGwYnRwZUVjE4K7VljdLYgEYPGp1SrkxjozxWa5VRSbW69rsGVKc8VmsabNftUzfep1Irs7ZUKkDVYFttvd3oGKcca+o7zdjHmc+DZm6f7Vys91s2z1At5mzPPedzGp9XUWPk+51p5OdkcKNmG13VtalK9u7Q63bwbjp17oztP1u7zvla5/Z6AkFCdhlr4rNIylXqxmvVagaFunFlNy862ds0es6FaFdrMAtR+9XgsRlMQiAEmIUZs7n+mKnBY2F5jrLQkxmhfHhE/T5B3XdhuY6oew4gzMpjT7c+9GiTO5Sk89ehg+jp06fz/fffs2LFCpycnCw50C4uLtjZ2aFSqZg5cyavv/464eHhhIeH8/rrr2Nvb8+dd97Z6HqfffYZXl5eTJw4EYChQ4cyZ84ctm/fzurVq+nRoweurq4X8haljshkBGOV8ljfOJ3jWI4ypNSlFfOh0woqSMhWgvOrIn1wsdNRUlNCXLaSXnQuQfS67bu4W7OWG/UHiazei62NAXY1Pk8NBIL132K9C9h3Ajs3sHdTvtt1IkGr4o/MPwF4MnoWKtew2kDYBrR1AfLpHutaOXiQOqqjWaVMX7KN60q2MlP7O3qVQfm/MOxJ5Ut3cVdyEUIQk5jHB/8ksDu1CPDHRqtm0oBApo3qgq+Lcn9Gk5lqo5kao/K92miixmimxmTGYBIYTGYMRjMGs1C+m045ZlKea7VtMmMw1m8bzQKjSbmGySQwmpXzjWYzRpOwHFe+CwxmM6a6xyblcd13o1kJgo1m0epZGefqUSdPGURLHVaHDqLrKmeMGjXKav/ixYuZOnUqAM8++yyVlZU8+uijFBYWMmjQINasWYOTk3Xwk52dzeuvv862bdss+wYOHMhTTz3Fddddh5eXF0uWLGnT+5EuEjUNPndtaiS6Dcrb/dJgQuF9Q5VPXGLSYzAKI11cuhDs3HgiYCNmE6THQsJfmI7+zZzceNABNYAKyu38cejczyowFnad+L8N2ezLU3PTkEjuHh0Fdp1OW1rsg3XTEcD44PH0GvDI+d+4dMn562AmP//4NZ/xBSG62lrIoaPhunfBvUu7tctkFlQZTFQaTFTWmKweVxoabpvrt2uPVRpMVBvMVBmMnCyq4lhuGaVVRkB57+lsp8NBr+GvQ1ms2HeSaoMS7NatQHip0WlUqFUqtGoVGsuX2rKtVoNGpUKtVqFR1e6r+65WoVFhtc/quEqFRl1/vJtv4/RKSeooOnQQLZrxVlilUjWaONgUb29vkpOTG+1/+eWXefnll8+xhdIlqS4fum4U9RRtUd6uLpXD21lPvyBXANanrgfgyqArT//EykI4tg4S/oZj/ygpGijpmCahYr+6G3/V9GWv3UC+njUZdNY/8jtP5PNl7nb0WjWfXTkKHE7z8TMQmxVLTHoMGpWGx/s9fs73Kl2azGbB539uxW/H//G5Zruyz8Eb9TVvQM+bWvwphMksKKs2Ul5tpKzuq8p6u7zaSGnt9/JqE6UNjpdXG6loEATXGNsmVU8AxZUGiisNZzxPq1ah16rRadXYaNToNGpstGp0GhW6um2NGp32lO2649pTtjVK0Kqt3adVq9Bo1Ohq9ynHVGjVpzzWqNBp6oNenUaNRq2qD4w1tYGtSjlfU3vtuqBZ3cqLS0nSxaxDB9GS1C7OWiNayX1srZHoYzmlZBUr6SNThigTCquMVWzJUCrRjAkeU3+yEJCXAAl/KYFz6nbryXu2rhA+jvnJnVmSG47eyZ2cymqeGdoVva7xj/vntUt83xId0KhudENCCN6Pex+AWyNubd7IuHTZKK2o5M/P53Jn/mIcNVWYUcOgh2HU8xQLe4oKKiiqMFBUaaCooobiSgOF5QaKKmsobrC/qNJASaUSAFca2m5Sqq1OjZ1Og51Og62NxvLYzkaDra5+21anJqe0mriUQnJKlXUCdBoVQ7p4ML6HN55Oemy0avRaDXqdEuTa6pRtZX/949Ze2VSSpPYng2hJOtUZKnMUVdSQV6b8MW2tnOjPNyuBrFoFdw1SgtN/T/5LpbESHwcfejh3qR9tTvwbCpOtL+DZHSKuUr4CBnIsv5IFsTGoVVBcWo2dTtPkEt5JeeWWpYfrUkhOZ13qOvbn7cdOa8e0PtPO/6ali5LJLMgvqyantJrc0mpySqsoT9zGkITXuYMUUMFBdVfe109jV2wAJTFbON+MBhuNGge9BkdbLQ42Whz1WuWxXouTXvlu/ViDU+25DnqtEhQ3CJT1WvVZR1OFEKyNz2bB+kQOZigLa9npNEweHMyDI0LxOMtqnpIkXR5kEC1JpzpDjei6VA4/F1sc9ef/4yOEYNX+TAD6BXXCxU5ZtGR9Wm0qh8oJ1VuhYCivf5JGDyHDIeJqCB8PnaxHhevqPXeytyG/vIbb+wfg2kSVgLrFVa7s5nXGUXWD2cAHuz8AYHKPyXjYXTqryUmKaqOpNiiuJqekmtzSKsvjnLrHpdXkl1VbgmIXynhO+wP3aTcAUCQceMM4iWWmUYgKNVCf3uBgo8HV3gYXOx2u9sqXi52N8thORyd7G1xqHzvZ6pQguDYg1ms1TbS4bZjNgjXx2SxYl0h8phI829tomDy4Mw8OD8FdBs+SJDUgg2hJOtUZRqLrgujWGoXelVJIabUyQenxMeEAGM1GNqZtBGBM4hYwVIOjT+1o89UQOhJsmq4ZbTSZ+XV3BgD55TWoVHDfsMajzEUVNZbFVx5o4nhDyxOXk1ySjJutG1N7Tj2Hu5TaW0mVgdT8ClLyK0gpKCc1v4L0wkqyS5QA+Wz5vA2pVYJ77P5lpnkJnWqLH69UX0l6/+eI9vJnjH19cKwExjatWgqyLSjBcxbv/5PIkSzlnhxsNEwe0pkHh4eeMdVJkqTLlwyiJelUzagR3Vr50AvWJQLgqNcyPFwZ4d2Ts4ei6iJczdCvqhoGTYOr32jWxKyYxFxyS6ux0aqpMZq5uqcPwU0sCPP9zlQqDSa6+zozuIv7aa9XYahg4T6lSs5DvR/C8TR54lL7EkKQU1qtBMn55aQW1AXMFaTml1NYcfYg2UajxtNJj6eTHi8nPV7OerycbK0e+9YkY7fmWewzlYmDR80B7O71MrfdfBtaTccOlJtiNgv+OpTFgnX1wbOjXsuUIcE8MCyUTjJ4liTpDGQQLUmnOtNIdCuWtzObzWw/kQ/A1ZE+lqXq16WuA2BkeRlaBy8Y/UKzKxvUjS4bTUolggeGN17Cu8ZoZsm2ZOX4sBDL6zbl28PfkleZh7+jP7dH3N68G5PahNksSC2oILlhkJxfQWqBsl1lOHP1CQ9HG4Lc7Al2dyDIzZ5AN3t8nG1rA2Q9Lna60/9fqKmAmLcxb12AWhipEHo+19xGv0kvMKmrXxvcbdsymwWrDyrB89Hs+uD53qGduX9YSJPpT5IkSaeSQbQknaoZOdGtUd7up7gMDCYlwfSp8RGAMqK4PnktAGMqKmH8fLBtXp3UwvIay0RBs4B+Qa5EB3dqdN6qAyfJLqnGy0nP9X1OHwAVVhXy5cEvAXg86nF0Gl3zb046LwaTmWM5ZRzMKObQyRIOnSwm/mQJ5TWnr1ihUavwc7Ul2M2BIHd7gt3sCXa3J6h2+5xz+BP+xrzqadTFqaiBtaZoVvo/wQt3XYWXk+25XbOdmMyCPw9k8uH6RMviRk61wfN9MniWJKmFZBAtSac6zUh0ZY2JjKJKoHVGoj/ffAKAgE52lhXO4gviyazMwc5sZrBbT+j9n2Zfb8VeJSjXqFSYhODBJkahhRCWaiBThnQ+Y67qov2LKDeU092tO1eHXN2SW5NaoMpg4khWqVXAfCSrtMm6xnqtms7upwTJ7g4Eu9nj38kOXWumVBSnw+rn4MhK1ECGcGeucQq9x9zJ/FFhF1XJNpNZsHL/ST5cf8zyRtjJVst9Q0O4b2gILvbyDaIkSS0ng2hJOtVpcqKP55YhBHSy1533LP2i8hoSa/+Y3zWwvvzcugNfAzCssgrbG94GdfODorqqHCYhCHKzZ3xPn0bn7Egq4NDJEmx1au4c2LjsXZ300nSWHl0KwJPRT6JWXXz5rh1RaZWB+JMlHKwNlg9llHAst6zJle2c9Fp6+DkT6e9CpL8zPf1cCPVwaPvcY5MBdnyC2DAPlaEcg9DwhekaltlN4s2pQxgY4ta2r9+K6oLnBesSOZ6rVLhxttVy37AQ7h0aYqmGI0mSdC5kEC1JpzrNSHRrTipcsF6ZUKhWwb3DOis7zSbWJ/0FarjSMxr8+zX7evEnSzh0ssSyff+wkCZHCutGoW+NDjjjpKmP9n6E0WxksO9gBvsNbnY7pHpCCOIzS9h6LI996cUcyigmOb+iyXPdHWzo6e9CpJ8SLEf6OxPYyf7Crw6XthNWPgnZB1EBseYIXjTch3/X/vxyW5+LpkqF0WTmj9qR5xO1wbOLnY77h4UwdWhnnG1l8CxJ0vmTQbQkncqSE902QbQQgl/3KGXoege4Ylu7kmDyv+9zXG1GKwTDx7zRomv+FJdmeexip+O2/gGNzjmRW8a6I2dfXOVw/mFWnVgFwMzomS1qx+Uut7SaLcdy2ZyQR0xinmVhnob8XGxrA2YXetaONHs76884wbPNVRTAP3Ng9xIAinHkv4Y7+U2M5Llre3D/WSagdhQ1RjO/7cng443HLG9YXO11PDAshClDOuMkg2dJklqRDKIl6VSWkWjriYX1QXTjCYctsSu5gKLakmMPjajNW64oYP2eT8FJzwCHIFzcGuczn06N0cyKvSct23cNCsLepvGP9uKtyQgBY7p5EXqGiZF1C6tcE3INPdx7NLsdl6Nqo4m4lEJiEvKISci1LNBRx06nYXAXdwZ0drOkZHSo0VwhYN8PsOZFqFAqxfxkHsXrNf/B0c2bnyb1o2+ga/u2sRmqDCZ+ikvnk43HLfMWOtnreGB4KJMHB8vgWZKkNiGDaEk61WlyolurvN2C9ceUy2vVjOvhrezc8Drrav/Oj4m8u0XXW38kh4LyGgB0GhVThnRudE5BeY1ltPr+4acfhd6euZ2tJ7eiVWt5LOqxFrXjciCE4EReOZsTcolJzGP7iXwqTqmY0dPPmeHhnoyI8CA6uNMFXXGvRXKOwKpZkLIVgAxdZ54om8wu0Y1re/kw7+beHT5nuLLGxPc7U1kUc5zsEmXU38NRz8MjQrlzUBAOrbCqqCRJ0unI3zCSdKomcqINJjPJeUpu5fkE0SVVBrYdU0b8RkV4KtUUsg6Qs2cx+wOVcnOjg8e26Jo/N0jluKGvP97OjcuOfbzhGFUGM738XRgc2vTiKmZh5r249wC4o+sdBDoFtqgdl6riSgPbjuURk5hLTEKeZaSzjoejnhHhHoyI8GRomAeeTh18aejqMoh5G/79CMxGTFo7Fopbeb90HGqtDf83oQd3Dwrq0OkbZdVGvvk3hc83nyC/9g2kr4st00Z24Y4BgdjqOugbF0mSLikyiJakU1lGouvTNlLyKzCaBfY2Gvxczr027s+70jAJpRLDvUM7Kx+nr36ODXbKNXt79sbL3qvZ18sprWL9kRzL9gNNjDKfLKrk6+0pADx9VdfTBkdrktcQnx+Pg86Bh3o/1Ow2XGqEEBw6WcI/h7PZnJjH3rQiq+oZNho1A0I6KaPN4Z5083G68BMAz4UQcOhX+PtFKFXSf064j2TyyZtJF56Eejjw0Z396OHXvLrk7aG40sCSbcl8uTXJkhIV0MmOR0eFcUu0f8cd9Zck6ZIkg2hJOlV17cTCBiPRdfnQXTwdz3mETgjBF1uSAXDSaxgU4g4Hf4GUrazzVcrRjQka06Jr/rYng7r4bni4B918GgdAH/yTSI3RzKAQN0bULi1+KoPJwII9CwCY2nMqbrYXTxmz1lJUUcNvezJYtiudw6fkNnfxdGBEhCcjIjwZFOLWZM55h5ZzGP58BpI3A2ByCeZ97X18mBEOwM1R/vzfjZEdNv2hoLyGL7cksWRbMqXVRgBCPRx4dHQYN/T1a9362JIkSc3UMX9jSlJ7EaLJnOjjrZAPvTetyJIKcEOUP2pjBax5iWK1ilhbPSBaFEQLIVgWW5/K0dTiKsdyyiy50M9e3e20bwB+TvyZtNI03G3dmdxjcgvu6uJmNgu2Hc9n2a40/j6UZVngxEar5squXozq6snwCE/8Xe3auaXnqKoENr0JOz4BsxGhtSW+y/1MPTqE3CoVdjoN/3djJLdGN67m0hHklFbx+eYkvt2eYsk9j/B2ZMaV4VzXy/eiWvBFkqRLjwyiJakhYzWYlZGuhiPRidnK6PT5BNHf1KZUANwaHQib34XSk8R4BWFEEOYaRrBzcLOvtz+92LKARLiXI8ObGGWev/YoZgFju3s3uQQ4QLmhnE/2fQLAI30ewV5n35LbuiidLKrk57h0ftyVRnphfY5zd19n7ugfwI1R/hf3EtBCwP4fYe1LUKaUNazscg0vVd3Jz/uUlIdIf2fev6PveVebaQuZxZV8uukEP+xMpbr2jU1PP2ceuzKM8T18Lo70GUmSLnkyiJakhupGocFqJLquMkeXM5SGO5OSKgMr92UC4OVkQx/7fNj2IQAbAiKh8CBXBl3ZomsujU21PH54ZJdGo8z704v480AWKhU8c1XX015nyaElFFQVEOwczM0RN7eoDReTGqOZfw5nsyw2jZjEXGpT03Gy1XJDXz/u6B9EpL9zh55Q1yxZB5XUjdRtAAi3LmwMfZrHYt0pqzZio1Ezc1w4Dw0PbfvVD1soraCChZuO8/OudGpMSvDcN9CVx8eEMbqr18X/byNJ0iVFBtGS1FBdPrTOHtTKiJ3ZLDieUzvi631uQfSKPRmWoOCWfgGo/n4BTDVUhY5iS6lS8q4lQXSVwcTy2gVbXO11TOzj1+ict/8+CsBNff3p6tP0aGNeZR5fHfoKgMejHken7tglzc5FQnYpy2LTWL4nw1IKEOCKUDfuGBDI1T19sbO5BCakVRbBxnmw8zMQJtDZU9T/CR5PGULMllLASFSQK2/f2rvDjT4fzizhk03HWbk/0zKJc2CIG49fGc7QMHcZPEuS1CHJIFqSGmoiH/pkcSWVBhM6jYpgt5anOgghrFI5JrklwI7VoNbyb7/bqYx7A18HX3q4NX9hk78PZVFlUILyB4aFYKO1HlHcdjyPzYl56DQqnhwXcdrrfLrvUyqNlfTy6MW44HEtvLOOq6zayMp9J1kam8betCLLfi8nPbdGB3B7/0A6ezi0XwNbk9msLJjyzytQnguA6H4DP7tP4+VNJVQaSrHVqXl6fFfuHdr0cvDtQQjB9hMFfLLpOJsSci37h4d7MGN0GINOU4pRkiSpo5BBtCQ11ESN6LrKHJ3dHc7p4++9aUUkZCvXiHC3IXDHS8qBQdNYV3QYUEahWzLa9vnmJEBZXOXuK6zzqIUQvPWXMgo9aWAQgacJ/FNLUvk54WcAnox+8qIf7RNCEJdSyLLYNFYdyLRMRNOqVVzZzYs7BgQyMsKzw6UwnJfMfbDqaUjfqWx7RJA5ZC6P73Qldk8hAINC3Hjzlt4d5k2D2SxYE5/Nwk3H2Vf7Bketgmt6+TJtRBd6Bbi0bwMlSZKaSQbRktRQEyPR9ct9n1sqxw8763OXX/bchCr5ODh6Yxz+FJt+vwFoWWm7zOJKDmQUA3B9H79GE+DWxGezN60IO52GGVeGnfY6C/YswCiMDPMfxgCfAS25pQ5FCMHGhFzmr0mw9AtAqKcDd/QP5OZ+AR1/AZSWqiiADa/Bri9BmMHGEdOIZ/nScBXv/JpEtbEQBxsNs6/tzl0DgzrERLxqo4nf9mTwacwJTtROiLXRqrktOoCHRoQS7N4xgnxJkqTmkkG0JDVkqRFdnzN6PuXtSqoM/L5PWdjCi0KGZHypHBg7l93FxyiqLsJV70qUV1Szr/npphOWxzPHWKdqmMyCd2pzoe8b1hkvp6YXhjmYd5C/k/9GhYqZ/Wa24I46lm3H83h3TQJxKcqoq51Ow4TevtwxIJDo4E4X/eh6I2Yz7PkG1s2FCmXlSyJv5UTUczy5Ood96ccBJSVi3s29COjU/pVWSqsMfL8jlS+2JJFTqizN7Wyr5Z7BwUwdEnLpvcGRJOmyIYNoSWqolUeiV+zJsOQuv+H8E+qacggYAL3vYF3smwCMChyFVt28H0UhhGWZ717+LgS5WwdJy/dkkJhThoudjodGdDntNeqW976+y/V0dTt95Y6OKi6lkPlrj7K1dgl1vVbNlCGdmTayC24OF3FpujNJ3QF/Pw8Zccq2Z3eMV7/FwmRfFnyZiMEkcLLV8tKEHtwWHdDubyBySqtYvDWZb7enUFqllI30cbbl/mEhTBoUhGMHXdhFkiSpueRvMUlq6JScaCEEiTnnVt5OCMF3O5RUjmjVUa6s2Qio4Nq3ESoV69PWAy1L5Vh7OJuyaiXX9/lrulk33WjivbUJADwyqgsudk1X2th2chs7s3aiU+uY3nd6i+6pvR3MKGb+2gTLUuc6jYo7BwYxfXQYXs7nvhx7h5Z/XBl5jl+hbOudYdTzHAy4nWd/PUx8pvJvPqabF6/d1Auf81iWvjUk5ZWzKOYEv+xOtyxe08XTgYdHduHGvv6NJsFKkiRdrGQQLUkNnTISnV9eQ1GFAZWq5UH0vvRijmSVosbMq7qvlJ39JoNfFPH5h8gqz8JOa8cVvlc0+5rvr00EwN3BhiFh1our/LAjlYyiSryc9EwZ3LnJ55uF2TIKPanbJPwcG5fG64gSskt5b20Cqw9mAaBRq7gtOoAZV4Z1iJSFNlFRAJvegtjPwWwAlRqi7qZ6xPN8uKOUhQt3YjILXO11zJ3Yk4l9/Np19Hl/ehGfbDrO6oNZlhrc/YJcmTayC2O7e3eIvGxJkqTWJINoSWrolJzoulSOgE52La4l/P0OpazdJM16eqpTwNYFxrwMwLqUdQAM8x+GrbZ5I4d5ZVXEZ5YAMGVIZ6tj5dVGPlyv1Jt+Ymz4adu66sQqjhYexUnnxIO9HmzR/bSH5Lxy3v8ngRX7TiIEqFRwQx8/nhgbQUgHqTbR6gxVsPNTiHkXqmsnSoaNg3Gvsqfal2e/3G/5dOS6Xr7Mmdiz3fKKzWZBTGIui2JOsO14vmX/ld28mDayCwM6X4J56ZIkSbVkEC1JDZ0yEm3Jh27hKHRJlYE/9mXiQhlPa39Udo5+ARyU0eP1qUoqR0sWWHlt1RFAKdn26CjrfOcvtySRX15DZ3d7bu8f2OTza0w1fLTnIwDu63UfrrauLbmlCyqjqJIP1yXyU1y6ZfGNayJ9eHJcBBHeHWuhkFZjNsOhX+GfuVBcW9HFuxeM/z9yvYYwf20Cy2K3YRbg4WjD/90QyTW9fNulqWXVRn7dnc5X25ItlTa0ahUT+/jx0MhQuvk4t0u7JEmSLiQZREtSQ6fkRJ/rpMIVe09SaTDxvPYnOqnKMLp3Q9v/fgCSi5M5XnwcrUrLiIARzbqeySz484CybPiIcA+rWseF5TUsilEqdswa3xXdaeogLzu6jJPlJ/Gy8+Ku7ne16H4ulJySKv634Rg/7EyzrPB4ZTcvZo2LINL/Eq4fnLwF1rwIJ/co205+MOYlqrrfyhfbUvl4yQbKa+te3xTlz8sTetCpHSZQpuZXsOTfZH6MTaO0Wpks6KTXclv/QO4fHoK/q90Fb5MkSVJ7kUG0JDV0ykj0uZS3E0Lw/Y5UuqtSuEvzDwDaCe+ARvlxW5eqpHIM9B2Is03zRux+2JFKde0krf93nfXKhgs3Hae02kgPX2cmnGZksqCqgEX7FwHwaN9HsdN2rGCnoLyGTzcdZ8m/yZZqJkO6uPPU+Aiig93auXVtKDdBWWnw6J/Kto0jDJuJedCj/HG4iLfe20JGUSUAfQJceHFCDwZ0vrD9IYRg2/F8Fm9NZt2RbEu+c6iHA1OGdOaW6ABZaUOSpMuS/M0nSQ2dJie6JUH0vvRiDmcW86PNEjQqQYrPVQSHDLccr0vlaElVjv9tVPKdAzrZWbUls7iSJduSAXjmqq5NTt4ymU3MjplNUXURYa5h3BB2Q7Nft62VVhn4LOYEX2xJsoy09gty5enxXRtNnLyklOXCpjdg12IQJlBpIHoqjJrNrjwt//f5Xstqfn4utjx7dTcm9vG7oJPzKmtMLN+TwVfbkiwrbgKMjPBk6tDOjAz3lJMFJUm6rMkgWpIaajASXVplILO4CoAwz+bn4X7zbwoT1f8yUH2ESmGDyw1vWI5ll2ezP28/KlSMDhzdrOvFJRdY2vHQiFCrYwvWJVJtNDOwsxujuno2+fxP9n/Cv5n/Yqe14+0Rbze7JnVbEkKw6kAmr/4Rb1mAI9LfmafGd2VUhOelOxmtpgK2fwxb3oea2jdsXa+FsXNJVQfw5oojrKpN23Gw0fDo6DDuHxaCra5lk1rPR3phBd9sT2HpzjSKKw0A2NtouDU6gMmDO5/zyp2SJEmXmvb/aypJHUmDnOjjtROmPBz1uNg3XXP5VEezSvl7zzH+sfkOgD9d7+QW3/rAd0PaBgB6e/bG077poPdUb9auQKjVqKwmDZ7ILePHXekAPHt11yYDzy0ZW/h036cAvHTFS4R1Ov0y4BdKSn45L604RExCLgCd3e2ZfU03rurpc+kGz2Yz7F8K6/8LJRnKPt++MP6/FPtcwf82HOOrrZuoMZlRq+COAUE8OS78tCtOtjYhBDuTCli8NZk18VnUzuUk0M2OKYM7c/uAQJxtm/czIEmSdLmQQbQkNdRgJPpYZl0qR/NLqb3+52Ee1fyGj6qQVLMn6qGPWx1vaSpHan4FO5MKABjfw9tqRPLdtQmYzIIx3bzo30SebGZZJrM3z0YguD3idq7vcn2z76MtVBtNfLrpBB9tOEaN0YyNRs2jo7swbWSXCzrSekEJASc2wtqXIOuAss8lEMa8gqHHTfwQm85732ygsEIZ8R0e7sEL13W/YNUtqgwmft93ksVbkzlcWz4RYGiYO1OHhHBlNy80MmVDkiSpSTKIlqSGLCPRTi3Oh45JyCU1cT+f2awCYJ6Ywpu9gyzHi6uLic2KBZpf2u6TTcctjx8YXj+ifTCjmFX7M1Gp4OmrGi/bXWOq4alNT1FcXUwP9x48O/DZZr1eW9l2LI8XfzvIiTxldH94uAev3hB56dZ6FgKOr4NNb0PadmWf3hmGP4UY9DAbjpfw2gdbLJ92hHk58sJ13S9YKktGUSU/7Ejl+52pFJTXAGCrU3NTVABTh3Smq88lWkZQkiSpFckgWpLqCGE9Ep2TBkC419kDCpNZ8PqqeF7Rfo2NysQGUx/M4VdbfQQekx6DURgJcw0j2Dn4rNdMyC7lx11KG3xdbIkKdLUce7s2xWNiHz+6+zYetXxn1zscyDuAs40z80fNR69pn8U4ckureW1VPL/tPQmAp5Oelyb04Prevpdm6oYQkPCXstLgyd3KPo0NRN8LI58jvljHa0v2sfWYsjCJu4MNM8dFMGlAoFXZwrZQbTSxNj6bZbFpbDmWZ6my4e9qxz2Dg/nPgEBc7S982TxJkqSLlQyiJalOTTlQG1noHVtU3u7nuDQCczcyymYfNULLXONkno0KsDqnJQusVBtNPP7DHoy1yamTBwdbgs7tJ/LZlJCLVq1i1riIRs9dnbSaH478AMC84fPwd/Q/6+u1NpNZ8P3OVN766wilVUZUKph8RTBPXdX10sytNZvh8O8Q8w5k16ZtaO2g/70w5HFy6MS7qxP4MS4NIcBGo+a+YSE8OrpLm/fH0axSlsWmsXxPuiVtBGBwqDuTBwczrod3mwfwkiRJlyIZREtSnbpRaJWaapWelPz6j9rPpLzayId/H+AH7TcAfGa6FvegHlzd08dyTpWxiq0ntwLNy4d+5++jHMlSqjfoNCpu6acE5EII3vpLWbnwPwMDCXa3Toc4XnScV7a9AsCDvR5s9mIurelgRjEvLD/AvnRlyepe/i68dlMkvQNcL3hb2pzJCIeWw+Z3IFf5d8HGEQY8AINnUKxx5autyXwas4+K2hJ+E3r78tzV3Qh0s2+zZpXWrpi5bFeapVQegI+zLbdGB3Bb/4BG/3ckSZKklpFBtCTVqa5P5UjOr8QslNXYvJzOnAqxKOYEt1b9TKA2l5PCjU/FTfxycy+rGrrbTm6j0liJn4Mf3d26n/F6WxLz+GxzkmX75et74uWsVGn453AOu1OLsNWpefzKcKvnVRgqmLVxFpXGSgb5DGJ63+ktufvzVlpl4N01CXz9b7Kl7565uit3DQq+9CanmQywfxlsfhcKlNUi0bvAoIfhikfINNjx5aYkvt8RZ6l/HRXkyovX9SA6uFObNEkIQWxyIcti0/jzQCaVBuV1tWoVY7t7c8eAQEZEeF56/xaSJEntRAbRklSnrm6vjaNlUmEXL8cz5u5ml1TxZ8y/rNT8AcB/DXdz7+hIwr2t86jrVim8MujKM16vsLyGWT/utWxf28uHuwcpkxNNZsE7tbnQ9w4NsQTWoARQc/6dw4niE3jZefHmiDfRqC9MxYumaj5P7OPHi9d1t2rjJcFYDXu/gy3vQVGqss+uEwyeDgMf4miRmkUrT7Bib4YlFaertxMzrgxjQhvlgeeUVvFLXAY/7UqzTNwE6OLpwB0DArkpKgDPs7wRlCRJklpOBtGSVKdBjejEHCWgPlsqxzt/H+VZlqBXGdhq6kmC+xjeG93F6hyj2cim9E3AmfOhhRA8/+t+SyDq52rLvJt7WwKv3/dlcDS7FGdbLdNGWL/GsqPLWJ20Go1Kw9sj38bdzr35930ekvPKeWnFQTYn5gEQ4uHA/90QybDwS2y1QUMlxC2BrR9AqTJJEgdPGPIYov997Mio4dMfjrLhaK7lKVeEujFtZBdGtkHFDaPJzMajuSzblcb6IzmYagN2exsNE3r7cseAQPoFdbo0J29KkiR1EDKIlqQ6VpU5zj6p8NDJYvL2/sE4XRwGoeEV4xTeuKU3eq31CPDu7N0UVxfTSd+Jfl79Tnu9n3al89ehbAA0Kvj4rmhc7JRJZzVGM/PXJgAwbVQXq8VfDuQe4M3YNwF4MvpJ+nmf/jVaS7XRxCcbT/C/jbU1n7VqHh11CdZ8ri6DXV/Ctg+hPEfZ5+QLQ5/AFDWZNQklfPL5fkvesVoF10T68tCIUPo0qKbSWpLyyvlxVxq/xKVb3myBslT6HQMCua63H456+WtdkiTpQpC/bSWpToORaEsQ7dl0EC2E4K1V+5ij+RqAxaarGTxoaJOLntSlcowKHHXaFIukvHJe/v2gZfv5a7vTt0EQtjQ2lbSCSjyd9Nw7JMSyv6iqiKc2PYXRbGRs0Fgm95jc/Ps9RzEJucz5/dClXfO5qhh2LoJ/P4ZKZbEbXIJg2EyqIifxy/5cPluwk+T8CgD0WjW39Q/ggWGhdG7lfkgrqODPA5n8eSDTMlkTwM3Bhpuj/LljQGCj9CFJkiSp7ckgWpLq1OZECxtHS4AY7t10EL3xaC49k78hRJdNtnBlqd0kVlzdeNETIQTr085c2s5gMvP4D3uoMpgBGN3Vk/uH1QfKFTVGFqw7BsDjY8Kxs1ECcbMwM3vLbDLLMwlyCuLVoa+26cf36YUV/HflYf46lAUoNZ9fntCjzXJ920XmPmXk+cDP9Z9MuIXC8KcoCruJb2NP8tW7W8krUxYocbHTMWVwMJOHdMbDsfXyjtMLlcB51YEsq+oaahWMiPDkjv6BjOnujY1WlqaTJElqLzKIlqQ6tSPR5dhZUhQCOjUuQ2Y0mflsZQxfaH8D4HXDnTx/x0Ccmqj3G58fT1Z5FnZaOwb7DW7yZResS+RAhjLC6Omo593b+1oFpYu3JpNXVk2Qmz139A+07F+0fxFbM7ai1+iZP2o+TjZtMxpZZTDxWYySulFlMKNRq5gyuDMzx4VfGjWfa8rh4C+wa3H9AikAnt1g+FNkBFzDF1vTWLp8s6VMnb+rHQ8MD+H2/oE4tFL6REZRJX/uz2TVgUz2nhI4Dwpx57revlzV00dOEpQkSeogZBAtSXVqRx6LjEqQEurh0GQ5sKWxadxZvAg7TQ07zN0w9riVcT28m7xkXSrHMP9hTa4aGJtcwEfrlVFmFfC/u/rh5lC/alxRRY1l6e9Z4yIsI4/bTm7j470fA/DiFS/S1a3xKHhrWH8km7l/xJNSm7YwKMSNV2+IvDSWhc4+pATO+5dBdYmyT62DHhMh+l4O63uzaHMSvy/dbJm4193XmWkjQ7m2ly+6Vlig5GRRZe2IcyZ7Uoss+1Uqpa+v6+3H1TJwliRJ6pBkEC1JdWpHovMMyuhqU5MKS6sMbF3zMws1OzAJFW+p72fhDT1Pe8m6ILqpBVZKqgzM+H533RqJzBoXwcAQ65zqhRuPU1plpJuPExP7+AGQVZ7F7JjZCAS3hN/CjWE3tvROzyolv5xX/4hn3RFlMp23s54XrrsElus2VMKh3yBuMaTtqN/fKQSip1Le4w7+SjLx67p0th7bYjk8NMydh0d0YXi4x3nff2ZxJX8eyGLV/pPsPiVwHtjZjQm9fbkq0gcvp0usPKAkSdIlRgbRklSnNic6q0r5sWgqiF604QhPGT8HNXxtGs/tN1x92mAnqTiJE8Un0Kq1Ta4c+OLyg2SXKBUWBoV24tHRYZZjQgg+23yCRZuVhTyeuaorarUKg8nA05ueprC6kG5u3Zg9cPb53fMpKmtMLNx4jE9iTlBjNKNVq7h/WAiPjQm/uKs+5CYogfPe76GqSNmn1kLXazH2m8pmY0+W781kzd97LbnpahVc28uXh0d0oVeAy3m9fFZxlWXEOS6l0LJfpYIBtYHz1T19Lr262pIkSZewi/ivoiS1stqR6PRyZeLeqUH0yaJKDNs+IUxzkjzhzOaAB/miQY7yqepGoQf5DGqUr7xibwa/71PqDbvYaflwUj9L6ojRZOaV3w/x3Q5lMY+pQzpzZTcvAObHzWdf7j6cdE7MHzUfW23rBF1CCNbEZ/PqH/FkFFUCMCzMgzkTe561VnaHZayGw38oEwVTttbvdwlC9JvMIZ+J/HzUyB9LT5JfHmc5HOrhwE1R/twY5X/OS3ObzIIDGcXEJOSy8WhOoxHnAcFuXNvLh2t6+eItA2dJkqSLkgyiJalObU50SpmS63pq8Pjpyq08o/4ZgHdMk3jp1iFn/Gh/Q+oGoHFVjvTCCmb/csCy/dGd/Syj2WXVRmZ8v5uNR3NRqeCFa7tz/7AQVCoVfyf/zbeHvwXgtWGvEeh0+gC+JU7kljHnj3hiEpSFQvxcbHlpQg+ujvS5OFM38o/XjzpX5Cv7VGqIuJrsiDtZVhDO8tgskvKOWZ7i7mDD9X38uCnKn94BLud031nFVcQk5LIpMZetx/IoqjBYHR/QuRPX9vLlmkhffFxk4CxJknSxk0G0JNWpHYnON9igVmFV93h/ehF9j87HUVPFHnMYgVc+cMa6yNnl2ezP248KlVUQbTILpn+3m0qDUuXhkZGhDA/3BJRc2fu+2sXhzBJsdWrevyOKqyN9ACU15OWtLwNwb+S9jA4afd63W1Fj5MP1x/h88wkMJoGNRs1DI0J5dHQX7G0usl8NFQWQ8Dfs+wGSNtXvd/Kjstfd/Kkby3eHjez+qQhQJmra6tRc1dOHG6P8GRbm0eKJglUGEzuTCohJyCUmMZeE7DKr4062WoZ28WBEhCeju3ni62J3njcpSZIkdSQX2V9KSWpDtTnR5dgR5GZvWXlQCMGvv/7IHM1WzELFF87TeW9k2JmuxIY0ZRS6j2cfPOzql8D+34ZjlgUzIv2ceWq8UlXj0Mli7vsqluySajwcbfh8ygDLYisVhgpmbZxFhbGCaO9oHo96/LxuUwjBqgOZvLbqMJnFVQCM6urJK9f3vLgWTClMgaN/wpFVkLINhKn2gApTl7Hs9ryJz7LCWL8xH6NZWZZcrYKhYR7cFOXP+J4+LcrzFkKQmFNWGzTnseNEPtVGs+W4SgV9AlwZEeHJiHAP+ga6om2FCh6SJElSxySDaEmqUzsSXSZsCfOqz2H+52AGd+QtADX8YLqSB++4+ayjlnX50A1HofenF/HeP8rS3XY2GhZN7o9Wo2bDkRxmfL+b8hoT4V6OfDl1gCUXVwjBf7f/l2NFx3C3deftEW+jVZ/7j21idimv/H6IbceVNIeATna8cn1Pxnb36vipG0JA1n4laD7yJ2QfsD7s3ZN07zF8WzWU74+qKD1kBJTguaefMzdF+TOxj1+LJu8VVdSw5VgeMQm5bE7Ms7zpqOPjbMuICGW0eViYB672Nqe5kiRJknSpkUG0JNWprh+JHlCbD20wmYn/4z3GqdMoFI5k9n+Guxosx92U4upidmXtAupL21XUGHnw612I2np2C+7oi5+rHd9sT+GVFQcxCxjSxZ2Fd0fjYqeU2BNC8P2R7/njxB9oVBreHvk2nvae53RraQUVfLk1iW/+TcFoFui1ah4Z1YVpI7tgq2t6KfIOwWRQJgUe+VMZdS5OsxwSKjVVvoM46DyMFZV9+SPVhuIUA1C/IMoNff24McqfiGYui51XVs3e1CJ2pxay7Xg++9OLMIv643qtmoEhboyM8GREhCfhXo4d/82HJEmS1CZkEC1JdWonFpZha5lU+Mum3dxb/T2oYJHuLmZcM+Csl4lJj8EojIS5hhHkHATA878esJSzu2tgEGO6e/Paqng+25wEwK3RAbx+Uy/LYip7cvbwftz77M5RVtB7vN/jDPA5+2s3ZDILYhJy+WZ7ChuO5lgC+HE9vHl5Qo9zrjzR5qpL4dg6ZcQ58W+oKrYcElp7Mj2HEKMewNd53Yg/0XDFRAPOtlqu6+3LjX39GdDZDXUTi+VYXsZo4nBmKXtSC9mTWsSetELSCiobnRfh7ciIcCVoHhji1rHfdEiSJEkXjAyiJQnAZASj8lF9uVCC6OJKA/qY/8NZVcEBc2cG3fLkGZd4NplNrEpaxYLdC4D6UejVBzJZsVcpZxfq4cCzV3fj0e9289ehLACeHh/B9NFhqFQqEgoT+HD3h2xM3wiAXqNnSs8pTO05tdm3UlBew4+70vhuR4pVUDg83IMHh4cyIuLcRrPbVGm2MtJ89E84sRFMNZZDNXo3DjkOYXllFMsKulBdVp8yodOo6BfUiWFhHgwN96C3v0uTechCCNILK9mbVmQJmA9llFBjMludp1JBmKcjUUGu9A92Y3iEh5wQKEmSJDVJBtGSBJZJhaCkc3TxdODnFcu5l40ArA15hlndfZt8qhCC9anr+XDPhxwvVio/eNt7c2vEreSUVPHkj3sBJeB79/Y+TF68k31pRdho1Lx9W29u6OtPemk6H+/9mJUnViIQaFQabgy7kWl9puHj4HPW5gsh2J1axLfbU1i1P9MSHLrY6bgtOoC7rgjuWJMGS7MhPRYydkHyFkjfBdTnTRTaBhKjHsj3xZHEVoVjLq4PjHv6OTM0zIOhYR4M6NypyUoi5dVG9qcXsyetdpQ5tYi8supG53Wy1xEV1ImoQFeigjrRO9AFZ1tdo/MkSZIk6VQyiJYksEwqrBEa3JydKCqrYsCh10ENy8Uoptx2W6OnCCH4N/NfFuxewKH8QwA42zhzf6/7mdRtEnq1LTf8b4tlBbxZ4yJ47Ic9pBdW4mqvY9E9/Qn1MTNvxzx+TPgRo9kIwPjg8cyImkGIS8hZm11RY2TF3pN8828K8Zkllv29A1y4+4pgru/th51NO6cfGKqUCYHpsbVfcVCc2ui04zbd+KOqLysN/ThW5Q8oqRhBbvYMDfNgWJgHg7u44+ZQPxIthCC3tJpjOWUcyy0j/mQJe1ILScgutcplBtCqVfTwc7YEzFFBrgS52cucZkmSJOmcyCBaksCSD12OHWFejqz//m2mqJMoEfbYXD0Xd0e91el7c/ayYM8CYrNiAbDT2nFPj3uY0nMKzjbOACxYl8CBDCWwHRTqxscbj1NaZSTY3Z7/3dWDjdnfM2Pb11QalZSLwb6DeaLfE/T06HnW5h7LKeXb7an8EpdOabUSfOu1aib28ePuK4Lpc5bJj21GCChMUgLluqA56wCYrRceMaMiRRNMrCGUXaYubDT1JaeqE1C78EmYB0O7uDM0zINAN3vMZkFGUSX70os4nlPGsZwyEmu/F1cammoJfi62lmA5KsiVnn4uMp9ZkiRJajUyiJYksIxEl2OLr66ciflfgAp+dJ7M/Vf0sZx2tOAoH+35yJKzrFPruKPrHTzQ6wHc7dwt58WfLOa9fxIBcLbVEpdciNEsiAp2ZPwVx3kk5mWKqosAiHSP5InoJ7jC94ozNtFgMrM2Pptv/k3h3xP5lv2d3e25+4pgbo0OuPAl1qqKIWO3kpaRvksJmivyG52Wjwu7TWHsMYexR4Sx3xxKOUqusb2NhoFhbjwU5mGZuHciVwmQ311zlGO5ZRzPKbcsUHMqlQoCO9kT7uVIuLcTfQOVoFkupy1JkiS1JRlESxJYcqLLhB2Dkj+mk6qMw+YgrpryAiqVitSSVP6393+sTlqNQKBWqZWc5d7T8HW0zpWuMpiY/OVOSzWMkiojYCI68gTF+lV8vF+ZUNjZuTNP9HuCMUFjzphSkFlcyQ8701i6M5WcUiWvV62CMd29ueeKYIaFeZyxCsV5EwIqC5UR5sJkKEiCghOIjN2QewQV1nkT1UJLvOisBMy1QXO68ESlUhHsZk8XT0ducrXF1d4GW62ayhoTx3PLWRqbxhurj2A8NQ+jlk6jIsTDgTAvR8I8HQnzdiLM05FQTwc5wixJkiRdcDKIliSwjEQL4GbzP6CCA71fYIRdBXP/fY/licsx1a6Id1Xnq5jed7olZ7ms2mjJxd2RVMC+tCLyy+uqSwi0TofwDt5AgikDKpRJh9P7Tuf6Ltc3Wjglv6yaxJwyErNLScgu42h2KXEphZhqA0sPRz2TBgbyn4FB+Lu2YtUIk1GpwVyYbAmWRUEyxvwTqIqS0TaYeFmnLmxPM3uyR9QGzOZw4kUwWhtbvFz0ONnq8NSo6GQyU1plJLukmuT8ijM2xd5GYwmUu3g5EublSLiXI0Fu9nIFQEmSJKnDuGSC6I8//pi3336bzMxMevbsyfvvv8/w4cMBeOedd3j77bcBmD17Nk8++aTleTt27ODRRx9l586daDRyNOtyVVNZgg3gr8pDrRL8rBlKUlAqb/56HTVmJSAe7j+cyd0epqzUhyWb8tibtoWkvIrT5uRq7I+j9/oLjV0aJSZw0bvwYK8H+U+3/1BRpSIuuZgES8BcSmJ2WYPg29rAEDfuuSKYq3r6WGpJt4jZpKRe1AbKxrwTVOUcx5R/Am1xKnaVJ1EL63QJFdCwTkW2cCVFeJMmvEg1e3FIdGafOYwynRsqFVQLM6ba4feaGtMZg+VO9jp8XOzwdbHFx8WWLp5KsBzm5Yivs23bjqxLkiRJUitQCSGa/uz0IrJs2TLuuecePv74Y4YOHcqnn37K559/Tnx8PMXFxQwaNIiVK1cihGDChAnExsYSGRmJwWBg4MCBLFq0iAEDWraQRUlJCS4uLhQXF+Ps7NxGdyZdKJlrPsB328uUqVR87uLGd+7uVJmVutHORCAKriY3zx+Dqe7HxQzqalSaSlTqKlSaKlTqSqj9rnU8itZRyYm2UdvSv9MNeJiuIinHREJ2WZPl1uoEutkR4eVEuLcT4V6O9A1ypYuno5JWUVMOlYWYKgqpKs2jurSAmtJ8jOWFmCsKEJVFqKoK0VQVoakpRm8oQW8swd5cftY+qBY60oQnKcKbVOFl+UoR3qQLT6rQn/UaoIyW1wXHVt+d64NmmX4hSVJ7kX+/pdZySQTRgwYNol+/fixcuNCyr3v37tx4441ERUUxf/58tm/fbjn36aef5rbbbuP1118nOzubDz74oMWv2VY/hM+8/wDV7G+160nN40IZNdpKNjrYU6FWRnp1Rhvsq53RmDWYNEaMagNGjQGj2oBJbazPZzgNlVARUuRHZEEAziYNOozoVEZ0GLHBiF5lxE5jxlZlQq82YVN3XBjRYEQrDGiFETuqcBRlOIsydKqmJ9c1V55wtgqQU4U3qWYlUM7BFUHjUW6VCpxtdbjYWX95OjUMlpUA2ctZj14rA2RJkjouGURLreWiT+eoqakhLi6O2bNnW+0fP34827ZtY/LkySQkJJCamooQgoSEBCIjIzl27BhfffUVcXFxzXqd6upqqqvrRw+Li5WliEtKSk73lHOSZtrMfgcZhLQPO6gWgBKomqikSl2JJa4UgNH6GXqzGUezwMFsxrn2saPZjJfZxM0lZQSYks/8ksYzH26osvarWmgpxZ5i4UAxDhQLe0qwp0Q4UiLsKcaRYmFPMfaUCgdKVA6Uqxyp0jhiY6PHxU6Hm4MNnex1uNjb0NNWx2A7rSVQdrbV4Vy77WSnw0mvbWZ6hZHqCiOnH2OXJElqf3V/ty+BMUSpnV30QXReXh4mkwlvb2+r/d7e3mRlZdG9e3def/11xo0bB8C8efPo3r07Y8eO5a233uLvv/9mzpw56HQ6PvjgA0aMGNHk68ybN4+5c+c22h8YGNj6NyVdEl5q06sXtunVJUmSLnWlpaW4uLi0dzOki9hFH0TXObVEmBDCsm/atGlMmzbNcuyrr77CycmJwYMH07VrV2JjY0lPT+c///kPSUlJ6PWNcz+ff/55Zs2aZdk2m80UFBTg7u7e6iuelZSUEBgYSFpamvyo6SxkXzWf7Kvmk33VfLKvmk/2VfO1ZV8JISgtLcXPz69Vrytdfi76INrDwwONRkNWVpbV/pycnEaj06CMXL/66qvExMSwY8cOIiIiCA8PJzw8HIPBQEJCAr169Wr0PL1e3yi4dnV1bdV7OZWzs7P8RdtMsq+aT/ZV88m+aj7ZV80n+6r52qqv5Ai01Bou+qKrNjY2REdHs3btWqv9a9euZciQIY3OnzlzJk8++SQBAQGYTCYMhvryZEajEZPp/CZuSZIkSZIkSZe+i34kGmDWrFncc8899O/fn8GDB7No0SJSU1OtUjhACawTExP5+uuvARg4cCBHjhxh9erVpKWlodFo6Nq1a3vcgiRJkiRJknQRuSSC6DvuuIP8/HxeffVVMjMziYyM5M8//yQ4ONhyTmVlJTNmzGDZsmWoa0uY+fv78+GHH3Lvvfei1+tZsmQJdnatuArcOdLr9bzyyitN5mZL1mRfNZ/sq+aTfdV8sq+aT/ZV88m+ki4Gl0SdaEmSJEmSJEm6kC76nGhJkiRJkiRJutBkEC1JkiRJkiRJLSSDaEmSJEmSJElqIRlES5IkSZIkSVILySC6g/n4448JCQnB1taW6OhoNm/e3N5Nanfz5s1jwIABODk54eXlxY033sjRo0etzhFCMGfOHPz8/LCzs2PUqFEcOnSonVrcccybNw+VSsXMmTMt+2Rf1cvIyODuu+/G3d0de3t7+vbtS1xcnOW47CuF0WjkxRdfJCQkBDs7O0JDQ3n11Vcxm82Wcy7nvoqJieH666/Hz88PlUrFb7/9ZnW8OX1TXV3NY489hoeHBw4ODkycOJH09PQLeBcXxpn6ymAw8Nxzz9GrVy8cHBzw8/Nj8uTJnDx50uoal0tfSR2fDKI7kGXLljFz5kxeeOEF9uzZw/Dhw7nmmmtITU1t76a1q02bNjF9+nS2b9/O2rVrMRqNjB8/nvLycss5b731FvPnz+ejjz4iNjYWHx8fxo0bR2lpaTu2vH3FxsayaNEievfubbVf9pWisLCQoUOHotPpWL16NfHx8bz77rtWK5HKvlK8+eabfPLJJ3z00UccPnyYt956i7fffpsPP/zQcs7l3Ffl5eX06dOHjz76qMnjzembmTNnsnz5cpYuXcqWLVsoKytjwoQJl9wCYGfqq4qKCnbv3s1LL73E7t27+fXXX0lISGDixIlW510ufSVdBITUYQwcOFBMmzbNal+3bt3E7Nmz26lFHVNOTo4AxKZNm4QQQpjNZuHj4yPeeOMNyzlVVVXCxcVFfPLJJ+3VzHZVWloqwsPDxdq1a8XIkSPFE088IYSQfdXQc889J4YNG3ba47Kv6l133XXivvvus9p38803i7vvvlsIIfuqIUAsX77cst2cvikqKhI6nU4sXbrUck5GRoZQq9Xir7/+umBtv9BO7aum7Ny5UwAiJSVFCHH59pXUMcmR6A6ipqaGuLg4xo8fb7V//PjxbNu2rZ1a1TEVFxcD4ObmBkBSUhJZWVlWfafX6xk5cuRl23fTp0/nuuuuY+zYsVb7ZV/V+/333+nfvz+33XYbXl5eREVF8dlnn1mOy76qN2zYMNatW0dCQgIA+/btY8uWLVx77bWA7KszaU7fxMXFYTAYrM7x8/MjMjLysu+/4uJiVCqV5RMi2VdSR3JJrFh4KcjLy8NkMuHt7W2139vbm6ysrHZqVccjhGDWrFkMGzaMyMhIAEv/NNV3KSkpF7yN7W3p0qXs3r2b2NjYRsdkX9U7ceIECxcuZNasWfy///f/2LlzJ48//jh6vZ7JkyfLvmrgueeeo7i4mG7duqHRaDCZTLz22mtMmjQJkP+vzqQ5fZOVlYWNjQ2dOnVqdM7l/Pu/qqqK2bNnc+edd+Ls7AzIvpI6FhlEdzAqlcpqWwjRaN/lbMaMGezfv58tW7Y0Oib7DtLS0njiiSdYs2YNtra2pz1P9hWYzWb69+/P66+/DkBUVBSHDh1i4cKFTJ482XKe7Ctlvsa3337L999/T8+ePdm7dy8zZ87Ez8+PKVOmWM6TfXV659I3l3P/GQwG/vOf/2A2m/n444/Pev7l3FdS+5HpHB2Eh4cHGo2m0TvpnJycRiMYl6vHHnuM33//nQ0bNhAQEGDZ7+PjAyD7DuWjzpycHKKjo9FqtWi1WjZt2sSCBQvQarWW/pB9Bb6+vvTo0cNqX/fu3S0TeeX/q3rPPPMMs2fP5j//+Q+9evXinnvu4cknn2TevHmA7KszaU7f+Pj4UFNTQ2Fh4WnPuZwYDAZuv/12kpKSWLt2rWUUGmRfSR2LDKI7CBsbG6Kjo1m7dq3V/rVr1zJkyJB2alXHIIRgxowZ/Prrr6xfv56QkBCr4yEhIfj4+Fj1XU1NDZs2bbrs+m7MmDEcOHCAvXv3Wr769+/PXXfdxd69ewkNDZV9VWvo0KGNSiUmJCQQHBwMyP9XDVVUVKBWW/+50Gg0lhJ3sq9Orzl9Ex0djU6nszonMzOTgwcPXnb9VxdAJyYm8s8//+Du7m51XPaV1KG014xGqbGlS5cKnU4nvvjiCxEfHy9mzpwpHBwcRHJycns3rV098sgjwsXFRWzcuFFkZmZavioqKiznvPHGG8LFxUX8+uuv4sCBA2LSpEnC19dXlJSUtGPLO4aG1TmEkH1VZ+fOnUKr1YrXXntNJCYmiu+++07Y29uLb7/91nKO7CvFlClThL+/v1i5cqVISkoSv/76q/Dw8BDPPvus5ZzLua9KS0vFnj17xJ49ewQg5s+fL/bs2WOpKNGcvpk2bZoICAgQ//zzj9i9e7e48sorRZ8+fYTRaGyv22oTZ+org8EgJk6cKAICAsTevXutft9XV1dbrnG59JXU8ckguoP53//+J4KDg4WNjY3o16+fpYzb5Qxo8mvx4sWWc8xms3jllVeEj4+P0Ov1YsSIEeLAgQPt1+gO5NQgWvZVvT/++ENERkYKvV4vunXrJhYtWmR1XPaVoqSkRDzxxBMiKChI2NraitDQUPHCCy9YBTaXc19t2LChyd9RU6ZMEUI0r28qKyvFjBkzhJubm7CzsxMTJkwQqamp7XA3betMfZWUlHTa3/cbNmywXONy6Sup41MJIcSFG/eWJEmSJEmSpIufzImWJEmSJEmSpBaSQbQkSZIkSZIktZAMoiVJkiRJkiSphWQQLUmSJEmSJEktJINoSZIkSZIkSWohGURLkiRJkiRJUgvJIFqSJEmSJEmSWkgG0ZIkXbaSk5NRqVTs3bu3Ta6rUqno27dvq177bDZu3Gh57RtvvPGCvrYkSdLlRAbRkiS1uqlTp7Y4gFOpVPz2229t0p7TCQwMJDMzk8jISKA+AC0qKmqV6//zzz+sW7euVa5VWVmJvb09R44cOeN5Q4YMITMzk9tvv71VXleSJElqmgyiJUm6bGk0Gnx8fNBqtW1yfXd3d9zd3VvlWmvXriUwMJBu3bqd8TwbGxt8fHyws7NrldeVJEmSmiaDaEmS2tyoUaN4/PHHefbZZ3Fzc8PHx4c5c+ZYjnfu3BmAm266CZVKZdkG+OOPP4iOjsbW1pbQ0FDmzp2L0Wi0HFepVHz++efcdNNN2NvbEx4ezu+//245XlhYyF133YWnpyd2dnaEh4ezePFiwDqdIzk5mdGjRwPQqVMnVCoVU6dO5euvv8bd3Z3q6mqre7rllluYPHlyi/qhboT+9ddfx9vbG1dXV8v9PPPMM7i5uREQEMCXX37Z6LkrVqxg4sSJAOzbt4/Ro0fj5OSEs7Mz0dHR7Nq1q0VtkSRJks6PDKIlSboglixZgoODAzt27OCtt97i1VdfZe3atQDExsYCsHjxYjIzMy3bf//9N3fffTePP/448fHxfPrpp3z11Ve89tprVteeO3cut99+O/v37+faa6/lrrvuoqCgAICXXnqJ+Ph4Vq9ezeHDh1m4cCEeHh6N2hcYGMgvv/wCwNGjR8nMzOSDDz7gtttuw2QyWQXmeXl5rFy5knvvvbfF/bB+/XpOnjxJTEwM8+fPZ86cOUyYMIFOnTqxY8cOpk2bxrRp00hLS7M8x2w2s3LlSm644QYA7rrrLgICAoiNjSUuLo7Zs2ej0+la3BZJkiTpPAhJkqRWNmXKFHHDDTdYtkeOHCmGDRtmdc6AAQPEc889Z9kGxPLly63OGT58uHj99det9n3zzTfC19fX6nkvvviiZbusrEyoVCqxevVqIYQQ119/vbj33nubbGdSUpIAxJ49e4QQQmzYsEEAorCw0Oq8Rx55RFxzzTWW7ffff1+EhoYKs9ncrOvWmTJliggODhYmk8myr2vXrmL48OGWbaPRKBwcHMQPP/xg2bd161bh4eFheZ6Tk5P46quvmnzthq/V8N9AkiRJal1yJFqSpAuid+/eVtu+vr7k5OSc8TlxcXG8+uqrODo6Wr4efPBBMjMzqaioaPLaDg4OODk5Wa79yCOPsHTpUvr27cuzzz7Ltm3bWtz2Bx98kDVr1pCRkQEoI+ZTp05FpVK1+Fo9e/ZEra7/1evt7U2vXr0s2xqNBnd3d6u+WbFiBRMmTLA8b9asWTzwwAOMHTuWN954g+PHj7e4HZIkSdL5kUG0JEkXxKnpBiqVCrPZfMbnmM1m5s6dy969ey1fBw4cIDExEVtb22Zd+5prriElJYWZM2dy8uRJxowZw9NPP92itkdFRdGnTx++/vprdu/ezYEDB5g6dWqLrnGmtp6tb37//XdLKgfAnDlzOHToENdddx3r16+nR48eLF++/JzaI0mSJJ2btpmSLkmS1EI6nQ6TyWS1r1+/fhw9epSwsLDzuranpydTp05l6tSpDB8+nGeeeYZ33nmn0Xk2NjYAjdoB8MADD/Dee++RkZHB2LFjCQwMPK82NVdiYiLJycmMHz/ean9ERAQRERE8+eSTTJo0icWLF3PTTTddkDZJkiRJciRakqQOonPnzqxbt46srCwKCwsBePnll/n6668tI6+HDx9m2bJlvPjii82+7ssvv8yKFSs4duwYhw4dYuXKlXTv3r3Jc4ODg1GpVKxcuZLc3FzKysosx+666y4yMjL47LPPuO+++87vZltgxYoVjB07Fnt7e0CpFz1jxgw2btxISkoKW7duJTY29rT3JEmSJLUNGURLktQhvPvuu5ZayFFRUQBcddVVrFy5krVr1zJgwACuuOIK5s+fT3BwcLOva2Njw/PPP0/v3r0ZMWIEGo2GpUuXNnmuv78/c+fOZfbs2Xh7ezNjxgzLMWdnZ2655RYcHR0v6EqAK1assErl0Gg05OfnM3nyZCIiIrj99tu55pprmDt37gVrkyRJkgQqIYRo70ZIkiRdDMaNG0f37t1ZsGDBGc9LTk4mJCSEPXv2nNey33l5efj6+pKWloaPj0+Lnjt16lSKioou+CqQkiRJlws5Ei1JknQWBQUFLF26lPXr1zN9+vRmP2/IkCEMGTLkvF53/vz5LQqgN2/ejKOjI9999905v64kSZJ0dnIkWpIk6Sw6d+5MYWEhL730UrMqexiNRpKTkwHQ6/UXbBIiKDnTdaX4HB0dWzyCLUmSJDWPDKIlSZIkSZIkqYVkOockSZIkSZIktZAMoiVJkiRJkiSphWQQLUmSJEmSJEktJINoSZIkSZIkSWohGURLkiRJkiRJUgvJIFqSJEmSJEmSWkgG0ZIkSZIkSZLUQjKIliRJkiRJkqQWkkG0JEmSJEmSJLXQ/wfuf7ZduXYasAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.util.coordinates import country_to_iso\n", + "\n", + "\n", + "def to_iso(country):\n", + " return country_to_iso(country, \"numeric\")\n", + "\n", + "\n", + "output_eot.plot_category(\n", + " impact_func_creator=impact_func_tc,\n", + " haz_type=\"TC\",\n", + " impf_id=1,\n", + " category=\"region_id\",\n", + " category_colors={to_iso(\"MEX\"): \"C0\", to_iso(\"BHS\"): \"C1\", to_iso(\"PRI\"): \"C2\"},\n", + ")" + ] } ], "metadata": { "kernelspec": { - "display_name": "climada_env_3.9", + "display_name": "climada_env_3.11", "language": "python", "name": "python3" }, @@ -4063,7 +4728,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.11" }, "orig_nbformat": 4 },