diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 579496e..d5b32d7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -36,4 +36,5 @@ repos: - id: trailing-whitespace - id: check-added-large-files args: ['--maxkb=2000'] + exclude: 'tests/data' - id: mixed-line-ending diff --git a/docs/source/conf.py b/docs/source/conf.py index a8961a1..aa3ce1c 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -130,7 +130,6 @@ "Corpus Phonetics Tutorial", "https://eleanorchodroff.com/tutorial/intro.html", ), - "coqui": ("Coqui", "https://coqui.ai/"), "conda_installation": ( "Conda installation", "https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html", diff --git a/environment.yml b/environment.yml index 34f0c22..b370b91 100644 --- a/environment.yml +++ b/environment.yml @@ -16,6 +16,7 @@ dependencies: - pytest - pip - dataclassy + - pyyaml - praatio - pytest-order - pip: diff --git a/extensions/gmm/gmm.cpp b/extensions/gmm/gmm.cpp index d3ee63a..d6a5a83 100644 --- a/extensions/gmm/gmm.cpp +++ b/extensions/gmm/gmm.cpp @@ -2600,4 +2600,92 @@ void init_gmm(py::module &_m) { py::arg("features"), py::return_value_policy::take_ownership ); + + m.def("gmm_interpolate_boundary_fast", + [](const AmDiagGmm &am_gmm, + const TransitionModel &trans_model, + const Matrix &features, + const int32 previous_transition_id, + const int32 following_transition_id){ + + py::gil_scoped_release release; + std::vector ratios; + BaseFloat previous_phone_log_likelihood, following_phone_log_likelihood; + int32 previous_pdf_id = trans_model.TransitionIdToPdfFast(previous_transition_id); + int32 following_pdf_id = trans_model.TransitionIdToPdfFast(following_transition_id); + BaseFloat min_ratio, max_ratio, ratio; + min_ratio = 100000.0; + max_ratio = -10000.0; + for (int32 i = 0; i < features.NumRows(); i++) { + SubVector feat_row(features, i); + previous_phone_log_likelihood = am_gmm.LogLikelihood(previous_pdf_id, feat_row); + following_phone_log_likelihood = am_gmm.LogLikelihood(following_pdf_id, feat_row); + ratio = previous_phone_log_likelihood - following_phone_log_likelihood; + ratios.push_back(ratio); + if (ratio > max_ratio) + max_ratio = ratio; + if (ratio < min_ratio) + min_ratio = ratio; + + } + for (int32 j = 0; j < ratios.size(); j++) { + ratio = ratios[j]; + if (-1 + (2*(ratio - min_ratio) / (max_ratio - min_ratio)) < 0.0) + return j; + } + return -1; + }, + py::arg("am_gmm"), + py::arg("trans_model"), + py::arg("features"), + py::arg("previous_transition_id"), + py::arg("following_transition_id"), + py::return_value_policy::take_ownership + ); + + m.def("gmm_interpolate_boundary", + [](const AmDiagGmm &am_gmm, + const TransitionModel &trans_model, + const Matrix &features, + const int32 previous_transition_id, + const int32 following_transition_id){ + + py::gil_scoped_release release; + std::vector ratios, normalized_ratios; + BaseFloat previous_phone_log_likelihood, following_phone_log_likelihood; + int32 previous_pdf_id = trans_model.TransitionIdToPdfFast(previous_transition_id); + int32 following_pdf_id = trans_model.TransitionIdToPdfFast(following_transition_id); + BaseFloat min_ratio, max_ratio, ratio, normalized_ratio; + min_ratio = 100000.0; + max_ratio = -10000.0; + for (int32 i = 0; i < features.NumRows(); i++) { + SubVector feat_row(features, i); + previous_phone_log_likelihood = am_gmm.LogLikelihood(previous_pdf_id, feat_row); + following_phone_log_likelihood = am_gmm.LogLikelihood(following_pdf_id, feat_row); + ratio = previous_phone_log_likelihood - following_phone_log_likelihood; + ratios.push_back(ratio); + if (ratio > max_ratio) + max_ratio = ratio; + if (ratio < min_ratio) + min_ratio = ratio; + + } + int32 boundary_index = -1; + for (int32 j = 0; j < ratios.size(); j++) { + ratio = ratios[j]; + normalized_ratio = -1 + (2*(ratio - min_ratio) / (max_ratio - min_ratio)); + if (normalized_ratio < 0.0) + boundary_index = j; + normalized_ratios.push_back(normalized_ratio); + } + py::gil_scoped_acquire acquire; + return py::make_tuple(boundary_index, normalized_ratios); + }, + py::arg("am_gmm"), + py::arg("trans_model"), + py::arg("features"), + py::arg("previous_transition_id"), + py::arg("following_transition_id"), + py::return_value_policy::take_ownership + ); } diff --git a/extensions/matrix/matrix.cpp b/extensions/matrix/matrix.cpp index fdf954b..96684f8 100644 --- a/extensions/matrix/matrix.cpp +++ b/extensions/matrix/matrix.cpp @@ -806,6 +806,9 @@ void pybind_kaldi_vector(py::module& m) { )); py::class_, VectorBase>(m, "FloatSubVector") + .def(py::init &, MatrixIndexT>(), + py::arg("matrix"), + py::arg("row")) .def(py::init([](py::buffer b) { py::buffer_info info = b.request(); if (info.format != py::format_descriptor::format()) { @@ -1242,6 +1245,9 @@ void pybind_kaldi_vector(py::module& m) { )); py::class_, VectorBase>(m, "DoubleSubVector") + .def(py::init &, MatrixIndexT>(), + py::arg("matrix"), + py::arg("row")) .def(py::init([](py::buffer b) { py::buffer_info info = b.request(); if (info.format != py::format_descriptor::format()) { diff --git a/extensions/util/util.cpp b/extensions/util/util.cpp index 1560f2d..1608258 100644 --- a/extensions/util/util.cpp +++ b/extensions/util/util.cpp @@ -710,7 +710,7 @@ void init_util(py::module &_m) { py::arg("other")) .def("__repr__", [](const CtmInterval &a) { - return ""; + return ""; }) .def(py::pickle( [](const CtmInterval &p) { // __getstate__ diff --git a/kalpy/aligner.py b/kalpy/aligner.py new file mode 100644 index 0000000..ece9642 --- /dev/null +++ b/kalpy/aligner.py @@ -0,0 +1,371 @@ +"""Classes for higher level alignment""" +from __future__ import annotations + +import typing + +from _kalpy.gmm import gmm_interpolate_boundary_fast +from _kalpy.hmm import SplitToPhones +from _kalpy.matrix import DoubleMatrix, FloatMatrix, FloatSubMatrix +from kalpy.data import Segment +from kalpy.decoder.training_graphs import TrainingGraphCompiler +from kalpy.exceptions import AlignerError +from kalpy.gmm.align import GmmAligner +from kalpy.gmm.data import CtmInterval +from kalpy.models import AcousticModel + +if typing.TYPE_CHECKING: + from kalpy.fstext.lexicon import LexiconCompiler + from kalpy.gmm.data import Alignment, HierarchicalCtm + from kalpy.utterance import Utterance + + +class KalpyAligner: + """ + Aligner class for generating alignments from a :class:`~kalpy.models.AcousticModel` and + :class:`~kalpy.fstext.lexicon.LexiconCompiler`. + + Parameters + ---------- + acoustic_model: :class:`~kalpy.models.AcousticModel` + Acoustic model + lexicon_compiler: :class:`~kalpy.fstext.lexicon.LexiconCompiler` or dict[Any, :class:`~kalpy.fstext.lexicon.LexiconCompiler`] + Single lexicon compiler to use for all utterances or a dictionary of different lexicon compilers to use + depending on the utterance + beam: int + Size of the beam to use in decoding, defaults to 10 + retry_beam : int + Size of the beam to use in decoding if it fails with the initial beam width, defaults to 40 + transition_scale : float + Transition scale, defaults to 1.0 + acoustic_scale : float + Acoustic scale, defaults to 0.1 + self_loop_scale : float + Self-loop scale, defaults to 0.1 + boost_silence : float + Factor to boost silence probabilities, 1.0 is no boost or reduction + careful : bool + Flag for extra error checking on reaching final state, defaults to False + """ + + def __init__( + self, + acoustic_model: AcousticModel, + lexicon_compiler: typing.Union[LexiconCompiler, typing.Dict[typing.Any, LexiconCompiler]], + beam: int = 10, + retry_beam: int = 40, + transition_scale: float = 1.0, + acoustic_scale: float = 0.1, + self_loop_scale: float = 0.1, + boost_silence: float = 1.0, + careful: bool = False, + ): + self.acoustic_model = acoustic_model + if isinstance(lexicon_compiler, dict) and len(lexicon_compiler) == 1: + lexicon_compiler = next(iter(lexicon_compiler.values())) + self.lexicon_compiler = lexicon_compiler + self.has_multiple_lexicons = isinstance(self.lexicon_compiler, dict) + + if self.has_multiple_lexicons: + self.graph_compiler = {} + for k, v in self.lexicon_compiler.items(): + self.graph_compiler[k] = TrainingGraphCompiler( + self.acoustic_model.model_path, + self.acoustic_model.tree_path, + v, + ) + else: + self.graph_compiler = TrainingGraphCompiler( + self.acoustic_model.model_path, + self.acoustic_model.tree_path, + self.lexicon_compiler, + ) + self.beam = beam + self.retry_beam = retry_beam + self.transition_scale = transition_scale + self.acoustic_scale = acoustic_scale + self.self_loop_scale = self_loop_scale + self.boost_silence = boost_silence + self.careful = careful + self.aligner = GmmAligner( + self.acoustic_model.model_path, + beam=beam, + retry_beam=retry_beam, + transition_scale=transition_scale, + acoustic_scale=acoustic_scale, + self_loop_scale=self_loop_scale, + careful=careful, + ) + self.ali_aligner = None + if self.acoustic_model.alignment_model_path != self.acoustic_model.model_path: + self.ali_aligner = GmmAligner( + self.acoustic_model.alignment_model_path, + beam=beam, + retry_beam=retry_beam, + transition_scale=transition_scale, + acoustic_scale=acoustic_scale, + self_loop_scale=self_loop_scale, + careful=careful, + ) + if self.boost_silence != 1.0: + if self.has_multiple_lexicons: + silence_symbols = next(iter(self.lexicon_compiler.values())).silence_symbols + else: + silence_symbols = self.lexicon_compiler.silence_symbols + if self.ali_aligner is not None: + self.ali_aligner.boost_silence(boost_silence, silence_symbols) + self.aligner.boost_silence(boost_silence, silence_symbols) + + def _align_utterance( + self, + utterance: Utterance, + cmvn: DoubleMatrix = None, + fmllr_trans: FloatMatrix = None, + dictionary_id: typing.Any = None, + ) -> Alignment: + """ + Internal function for generating an :class:`~kalpy.gmm.data.Alignment` from an :class:`~kalpy.utterance.Utterance` + + Parameters + ---------- + utterance: :class:`~kalpy.utterance.Utterance` + Utterance to align + cmvn: :class:`~_kalpy.matrix.DoubleMatrix`, optional + CMVN transformation to use, if not provided, a CMVN transform will be applied based on the utterance features + fmllr_trans: :class:`~_kalpy.matrix.FloatMatrix`, optional + Feature transformation matrix for a speaker + dictionary_id: int or str, optional + Identifier for which lexicon compiler to use, if not specified, defaults to using the first lexicon compiler + + Raises + ------ + :class:`~kalpy.exceptions.AlignerError` + Raised when no alignment is generated + + Returns + ------- + :class:`~kalpy.gmm.data.Alignment` + Alignment object with list of transition IDs and other information for the utterance + """ + feats = utterance.generate_features( + self.acoustic_model, fmllr_trans=fmllr_trans, cmvn=cmvn + ) + graph_compiler = self.graph_compiler + if self.has_multiple_lexicons: + if dictionary_id is None: + dictionary_id = next(iter(self.lexicon_compiler.keys())) + graph_compiler = self.graph_compiler[dictionary_id] + + fst = graph_compiler.compile_fst(utterance.transcript) + aligner = ( + self.ali_aligner + if fmllr_trans is None and self.ali_aligner is not None + else self.aligner + ) + alignment = aligner.align_utterance(fst, feats) + if alignment is None: + raise AlignerError( + f"Could not align the file with the current beam size ({aligner.beam}, " + "please try increasing the beam size via `--beam X`" + ) + return alignment + + def align_utterance( + self, + utterance: Utterance, + cmvn: DoubleMatrix = None, + fmllr_trans: FloatMatrix = None, + dictionary_id: typing.Any = None, + ) -> HierarchicalCtm: + """ + Function for generating an :class:`~kalpy.gmm.data.Alignment` from an :class:`~kalpy.utterance.Utterance` + + Parameters + ---------- + utterance: :class:`~kalpy.utterance.Utterance` + Utterance to align + cmvn: :class:`~_kalpy.matrix.DoubleMatrix`, optional + CMVN transformation to use, if not provided, a CMVN transform will be applied based on the utterance features + fmllr_trans: :class:`~_kalpy.matrix.FloatMatrix`, optional + Feature transformation matrix for a speaker + dictionary_id: int or str, optional + Identifier for which lexicon compiler to use, if not specified, defaults to using the first lexicon compiler + + Raises + ------ + :class:`~kalpy.exceptions.AlignerError` + Raised when no alignment is generated + + Returns + ------- + :class:`~kalpy.gmm.data.HierarchicalCtm` + Hierarchical CTM object with word and phone intervals for the utterance + """ + lexicon_compiler = self._get_lexicon_compiler(dictionary_id) + aligner = ( + self.ali_aligner + if fmllr_trans is None and self.ali_aligner is not None + else self.aligner + ) + alignment = self._align_utterance(utterance, cmvn, fmllr_trans, dictionary_id) + phone_intervals = alignment.generate_ctm( + aligner.transition_model, + lexicon_compiler.phone_table, + self.acoustic_model.mfcc_computer.frame_shift, + ) + ctm = lexicon_compiler.phones_to_pronunciations( + alignment.words, phone_intervals, transcription=False, text=utterance.transcript + ) + ctm.likelihood = alignment.likelihood + ctm.update_utterance_boundaries(utterance.segment.begin, utterance.segment.end) + return ctm + + def _get_lexicon_compiler(self, dictionary_id: typing.Any = None) -> LexiconCompiler: + """ + Internal function for looking up the lexicon compiler for the specified key + + Parameters + ---------- + dictionary_id: int or str, optional + Key to look up lexicon compiler + + Returns + ------- + :class:`~kalpy.fstext.lexicon.LexiconCompiler` + Lexicon compiler + """ + lexicon_compiler = self.lexicon_compiler + if self.has_multiple_lexicons: + if dictionary_id is None: + dictionary_id = next(iter(self.lexicon_compiler.keys())) + lexicon_compiler = self.lexicon_compiler[dictionary_id] + return lexicon_compiler + + def fine_tune_alignments( + self, + utterance: Utterance, + alignment: Alignment = None, + boundary_tolerance: typing.Optional[float] = None, + cmvn: DoubleMatrix = None, + fmllr_trans: FloatMatrix = None, + dictionary_id: typing.Any = None, + ) -> HierarchicalCtm: + """ + Function for finetuning an :class:`~kalpy.gmm.data.Alignment` for an :class:`~kalpy.utterance.Utterance` + + Parameters + ---------- + utterance: :class:`~kalpy.utterance.Utterance` + Utterance to align + alignment: :class:`~kalpy.gmm.data.Alignment`, optional + Alignment to finetune, if not specified, alignment will be generated + boundary_tolerance: float, optional + The range around a boundary that it is allowed to be moved in seconds, + if not specified, it will default to two frames from the acoustic model features, one frame on either side + cmvn: :class:`~_kalpy.matrix.DoubleMatrix`, optional + CMVN transformation to use, if not provided, a CMVN transform will be applied based on the utterance features + fmllr_trans: :class:`~_kalpy.matrix.FloatMatrix`, optional + Feature transformation matrix for a speaker + dictionary_id: int or str, optional + Identifier for which lexicon compiler to use, if not specified, defaults to using the first lexicon compiler + + Raises + ------ + :class:`~kalpy.exceptions.AlignerError` + Raised when no alignment is generated + + Returns + ------- + :class:`~kalpy.gmm.data.HierarchicalCtm` + Hierarchical CTM object with word and phone intervals for the utterance + """ + lexicon_compiler = self._get_lexicon_compiler(dictionary_id) + aligner = ( + self.ali_aligner + if fmllr_trans is None and self.ali_aligner is not None + else self.aligner + ) + if alignment is None: + alignment = self._align_utterance( + utterance, cmvn=cmvn, fmllr_trans=fmllr_trans, dictionary_id=dictionary_id + ) + split = SplitToPhones(aligner.transition_model, alignment.alignment) + phone_intervals = [] + phone_start = 0.0 + original_start = 0.0 + feature_padding = 0.04 + if boundary_tolerance is None: + boundary_tolerance = self.acoustic_model.frame_shift_seconds * 2 + for i, s in enumerate(split): + phone_id = aligner.transition_model.TransitionIdToPhone(s[0]) + duration = len(s) * self.acoustic_model.frame_shift_seconds + original_end = original_start + duration + boundary = original_end + label = lexicon_compiler.phone_table.find(phone_id) + if i != len(split) - 1: + feature_segment_begin = max( + round(boundary - feature_padding, 4), + 0, + ) + feature_segment_end = min( + round(boundary + feature_padding, 4), + utterance.segment.end, + ) + following_phone_duration = ( + len(split[i + 1]) * self.acoustic_model.frame_shift_seconds + ) + previous_phone_offset_window = min(boundary_tolerance, duration / 2) / 2 + following_phone_offset_window = ( + min(boundary_tolerance, following_phone_duration / 2) / 2 + ) + begin_offset = round( + max(boundary - previous_phone_offset_window - feature_segment_begin, 0.0), 4 + ) + end_offset = round( + min( + boundary + following_phone_offset_window - feature_segment_begin, + feature_segment_end - feature_segment_begin, + ), + 4, + ) + seg = Segment( + utterance.segment.file_path, feature_segment_begin, feature_segment_end + ) + feats = self.acoustic_model.generate_features_for_fine_tune( + seg, cmvn=cmvn, fmllr_trans=fmllr_trans + ) + begin_index = int(round(begin_offset * 1000)) + end_index = int(round(end_offset * 1000)) + sub_matrix = FloatSubMatrix( + feats, begin_index, end_index - begin_index, 0, feats.NumCols() + ) + feats = FloatMatrix(sub_matrix) + previous_transition_id = s[-1] + following_transition_id = split[i + 1][0] + new_boundary_index = gmm_interpolate_boundary_fast( + aligner.acoustic_model, + self.acoustic_model.transition_model, + feats, + previous_transition_id, + following_transition_id, + ) + boundary = round( + feature_segment_begin + begin_offset + (new_boundary_index * 0.001), 3 + ) + confidence = 0.0 + phone_intervals.append( + CtmInterval( + round(phone_start, 3), + round(boundary, 3), + label, + phone_id, + confidence, + ) + ) + phone_start = boundary + original_start = original_end + ctm = lexicon_compiler.phones_to_pronunciations( + alignment.words, phone_intervals, transcription=False, text=utterance.transcript + ) + ctm.likelihood = alignment.likelihood + ctm.update_utterance_boundaries(utterance.segment.begin, utterance.segment.end) + return ctm diff --git a/kalpy/exceptions.py b/kalpy/exceptions.py index 89349cf..22fbf60 100644 --- a/kalpy/exceptions.py +++ b/kalpy/exceptions.py @@ -42,6 +42,26 @@ def __init__(self, ctm: typing.Union[CtmInterval, WordCtmInterval]): KalpyError.__init__(self, f"Error was encountered in processing CTM interval: {ctm}") +class ReadError(KalpyError): + """ + Class for reading files + """ + + pass + + +class AlignerError(KalpyError): + """ + Class for errors during alignment + """ + + pass + + +class AcousticModelError(KalpyError): + pass + + class LexiconError(KalpyError): pass diff --git a/kalpy/feat/cmvn.py b/kalpy/feat/cmvn.py index f6a2dc5..8ee8551 100644 --- a/kalpy/feat/cmvn.py +++ b/kalpy/feat/cmvn.py @@ -93,19 +93,6 @@ def compute_cmvn_for_export( :class:`_kalpy.matrix.DoubleMatrix` Feature matrix for the segment """ - if False: - cmvn_stats = DoubleMatrix() - is_init = False - num_done = 0 - num_error = 0 - for utt in utterance_list: - print(utt) - feats = feature_reader.Value(utt) - if not is_init: - transform.InitCmvnStats(feats.NumCols(), cmvn_stats) - is_init = True - transform.AccCmvnStats(feats, None, cmvn_stats) - num_done += 1 cmvn_stats, num_done, num_error = transform.calculate_cmvn(utterance_list, feature_reader) self.num_done += num_done self.num_error += num_error diff --git a/kalpy/fstext/lexicon.py b/kalpy/fstext/lexicon.py index 89672a0..788aca4 100644 --- a/kalpy/fstext/lexicon.py +++ b/kalpy/fstext/lexicon.py @@ -972,6 +972,25 @@ def phones_to_pronunciations( transcription: bool = False, text: str = None, ) -> HierarchicalCtm: + """ + Combine sequences of word symbols and phone intervals in a :class:`~kalpy.gmm.data.HierarchicalCtm` + + Parameters + ---------- + word_symbols: list[int] + Sequence of word symbols + intervals: list[:class:`~_kalpy.util.CtmInterval`] + Sequence of phone intervals + transcription: bool + Flag for whether the sequences were generated from a transcription lattice + text: str, optional + Original utterance text to map word symbols to + + Returns + ------- + :class:`~kalpy.gmm.data.HierarchicalCtm` + Hierarchical CTM object with word and phone intervals for the utterance + """ phones = [x.symbol for x in intervals] word_splits = self._create_pronunciation_string( diff --git a/kalpy/gmm/align.py b/kalpy/gmm/align.py index 740b808..8aedfc9 100644 --- a/kalpy/gmm/align.py +++ b/kalpy/gmm/align.py @@ -28,14 +28,37 @@ class GmmAligner: + """ + Wrapper class around aligning with a GMM acoustic model + + Parameters + ---------- + acoustic_model_path: str or :class:`~pathlib.Path` + Path to acoustic model + beam: int + Size of the beam to use in decoding, defaults to 10 + retry_beam : int + Size of the beam to use in decoding if it fails with the initial beam width, defaults to 40 + transition_scale : float + Transition scale, defaults to 1.0 + acoustic_scale : float + Acoustic scale, defaults to 0.1 + self_loop_scale : float + Self-loop scale, defaults to 0.1 + careful : bool + Flag for extra error checking on reaching final state, defaults to False + disambiguation_symbols : list[int], optional + List of symbols in phone table that correspond to disambiguation symbols + """ + def __init__( self, acoustic_model_path: typing.Union[pathlib.Path, str], acoustic_scale: float = 1.0, transition_scale: float = 1.0, self_loop_scale: float = 1.0, - beam: float = 10, - retry_beam: float = 40, + beam: int = 10, + retry_beam: int = 40, careful: bool = False, disambiguation_symbols: typing.List[int] = None, ): @@ -62,6 +85,19 @@ def __init__( def boost_silence( self, silence_weight: float, silence_phones: typing.List[int], only_silence: bool = True ): + """ + Function to boost probabilities associated with silence states in the GMM + + Parameters + ---------- + silence_weight: float + Factor to boost silence by, 1.0 means no boosting, less than 1.0 decreases silence state probability, + greater than 1.0 increases silence probability + silence_phones: list[int] + Phone IDs corresponding to silence phones + only_silence: bool + Flag for whether to boost only states that are associated with silence phones and not speech phones + """ if only_silence: self.acoustic_model.boost_only_silence( self.transition_model, silence_phones, silence_weight @@ -78,6 +114,27 @@ def align_utterance( utterance_id: str = None, reference_phones: typing.List[typing.List[int]] = None, ) -> typing.Optional[Alignment]: + """ + + Parameters + ---------- + training_graph: :class:`~_kalpy.fstext.VectorFst` + Training graph for the utterance + features: :class:`~_kalpy.matrix.FloatMatrix` + Feature matrix for the utterance + utterance_id: str, optional + Identifier for the utterance to store + reference_phones: list[list[int]], optional + Sequence of phones to use as reference and constrain alignments to only transition IDs corresponding to the + phones specified for each frame + + Returns + ------- + :class:`~kalpy.gmm.data.Alignment` or None + Alignment object with list of transition IDs and other information for the utterance. If the utterance could + not be aligned, returns None + + """ if reference_phones is None: ( alignment, @@ -182,6 +239,23 @@ def align_utterances( feature_archive: FeatureArchive, reference_phone_archive: RandomAccessInt32VectorVectorReader = None, ) -> typing.Generator[Alignment]: + """ + Function for aligning all utterances in a training graph archive and feature archive + + Parameters + ---------- + training_graph_archive: :class:`~kalpy.decoder.data.FstArchive` + Archive of training graph FSTs per utterance + feature_archive: :class:`~kalpy.feat.data.FeatureArchive` + Archive of feature matrices per utterance + reference_phone_archive: :class:`~_kalpy.util.RandomAccessInt32VectorVectorReader`, optional + Archive of reference phone sequences per utterance + + Yields + ------ + :class:`~kalpy.gmm.data.Alignment` + Successful alignments, skipping utterances that could not be aligned + """ logger.debug(f"Aligning with {self.acoustic_model_path}") num_done = 0 num_error = 0 @@ -235,7 +309,29 @@ def export_alignments( likelihood_file_name: typing.Union[pathlib.Path, str] = None, write_scp: bool = False, callback: typing.Callable = None, - ): + ) -> None: + """ + Export alignments from training graph and features archives to an alignment archive file + + Parameters + ---------- + file_name: str or :class:`~pathlib.Path` + Alignment archive file path + training_graph_archive: :class:`~kalpy.decoder.data.FstArchive` + Archive of training graph FSTs per utterance + feature_archive: :class:`~kalpy.feat.data.FeatureArchive` + Archive of feature matrices per utterance + reference_phone_archive: :class:`~_kalpy.util.RandomAccessInt32VectorVectorReader`, optional + Archive of reference phone sequences per utterance + word_file_name: str or :class:`~pathlib.Path`, optional + File path to save word sequence + likelihood_file_name: str or :class:`~pathlib.Path`, optional + File path to save per frame log-likelihoods + write_scp: boolean + Flag for whether to write alignment archive with SCP file, defaults to False + callback: callable, optional + Callback to emit :class:`~kalpy.gmm.data.Alignment` objects as they're processed + """ write_specifier = generate_write_specifier(file_name, write_scp) writer = Int32VectorWriter(write_specifier) word_writer = None diff --git a/kalpy/gmm/data.py b/kalpy/gmm/data.py index 185deb7..7ead84e 100644 --- a/kalpy/gmm/data.py +++ b/kalpy/gmm/data.py @@ -76,9 +76,10 @@ def export_textgrid( self, file_name: typing.Union[str, pathlib.Path], file_duration: float = None, - output_format: str = TextgridFormats.LONG_TEXTGRID, + output_format: typing.Literal[ + "short_textgrid", "long_textgrid", "json", "textgrid_json" + ] = "short_textgrid", ): - # Create initial textgrid if file_duration is not None: file_duration = round(file_duration, 6) tg = tgio.Textgrid() @@ -109,6 +110,23 @@ def export_textgrid( reportingMode="error", ) + @property + def phone_boundaries(self): + boundaries = [] + for i, wi in enumerate(self.word_intervals): + for j, pi in enumerate(wi.phones): + if i + j != 0: + boundaries.append(pi.begin) + return boundaries + + @property + def labelled_midpoints(self): + labels = [] + for wi in self.word_intervals: + for pi in wi.phones: + labels.append((pi.label, (pi.begin + pi.end) / 2)) + return labels + def to_textgrid_tiers( self, file_duration: float = None ) -> typing.Tuple[tgio.IntervalTier, tgio.IntervalTier]: @@ -181,7 +199,7 @@ def generate_ctm( likelihoods = None if self.per_frame_likelihoods: likelihoods = self.per_frame_likelihoods.numpy() - for s in split: + for i, s in enumerate(split): phone_id = transition_model.TransitionIdToPhone(s[0]) num_repeats = len(s) duration = frame_shift * num_repeats diff --git a/kalpy/gmm/fine_tune.py b/kalpy/gmm/fine_tune.py new file mode 100644 index 0000000..3950789 --- /dev/null +++ b/kalpy/gmm/fine_tune.py @@ -0,0 +1,2 @@ +def fine_tune_alignments(): + pass diff --git a/kalpy/gmm/utils.py b/kalpy/gmm/utils.py index c91bf1b..681983c 100644 --- a/kalpy/gmm/utils.py +++ b/kalpy/gmm/utils.py @@ -1,5 +1,6 @@ from __future__ import annotations +import os.path import pathlib import typing @@ -7,9 +8,12 @@ from _kalpy.hmm import HmmTopology, TransitionModel from _kalpy.tree import ContextDependency from _kalpy.util import Input, Output, ReadKaldiObject +from kalpy.exceptions import ReadError def read_transition_model(model_path: typing.Union[str, pathlib.Path]) -> TransitionModel: + if not os.path.exists(model_path): + raise ReadError(f"The specified model path {model_path} does not exist.") ki = Input() ki.Open(str(model_path), True) transition_model = TransitionModel() @@ -21,6 +25,8 @@ def read_transition_model(model_path: typing.Union[str, pathlib.Path]) -> Transi def read_gmm_model( model_path: typing.Union[str, pathlib.Path] ) -> typing.Tuple[TransitionModel, AmDiagGmm]: + if not os.path.exists(model_path): + raise ReadError(f"The specified model path {model_path} does not exist.") ki = Input() ki.Open(str(model_path), True) transition_model = TransitionModel() @@ -32,6 +38,8 @@ def read_gmm_model( def read_topology(topo_path: typing.Union[str, pathlib.Path]) -> HmmTopology: + if not os.path.exists(topo_path): + raise ReadError(f"The specified topo path {topo_path} does not exist.") ki = Input() ki.Open(str(topo_path), False) topo = HmmTopology() @@ -61,6 +69,8 @@ def write_tree( def read_tree(tree_path: typing.Union[str, pathlib.Path]) -> ContextDependency: + if not os.path.exists(tree_path): + raise ReadError(f"The specified tree path {tree_path} does not exist.") tree = ContextDependency() ReadKaldiObject(str(tree_path), tree) return tree diff --git a/kalpy/models.py b/kalpy/models.py new file mode 100644 index 0000000..ced90c3 --- /dev/null +++ b/kalpy/models.py @@ -0,0 +1,477 @@ +""" +Model classes +============= + +""" +from __future__ import annotations + +import json +import logging +import os +import typing +from pathlib import Path + +import pywrapfst +import yaml + +from _kalpy.feat import ( + DeltaFeaturesOptions, + SlidingWindowCmnOptions, + compute_deltas, + paste_feats, + sliding_window_cmn, + splice_frames, +) +from _kalpy.matrix import DoubleMatrix, FloatMatrix +from _kalpy.transform import ApplyCmvn, apply_transform +from kalpy.data import Segment +from kalpy.exceptions import AcousticModelError +from kalpy.feat.cmvn import CmvnComputer +from kalpy.feat.mfcc import MfccComputer +from kalpy.feat.pitch import PitchComputer +from kalpy.fstext.lexicon import LexiconCompiler +from kalpy.gmm.utils import read_gmm_model +from kalpy.utils import read_kaldi_object + +if typing.TYPE_CHECKING: + from _kalpy.gmm import AmDiagGmm + from _kalpy.hmm import TransitionModel + +logger = logging.getLogger("mfa") + + +class AcousticModel: + """ + Class for storing acoustic models in MFA, exported as zip files containing the necessary Kaldi files + to be reused + + """ + + def __init__( + self, + directory: typing.Union[str, Path], + validate: bool = True, + ): + self.directory = Path(directory) + if validate: + self.validate_directory() + self._am = None + self._tm = None + self._meta = None + self._phone_pdf_counts = None + + def validate_directory(self): + required_files = [ + "final.mdl", + "tree", + ] + for f in required_files: + if not self.directory.joinpath(f).exists(): + raise AcousticModelError(f"Could not find {f} in {self.directory}.") + + def generate_features( + self, + segment: Segment, + cmvn: typing.Optional[DoubleMatrix] = None, + fmllr_trans: FloatMatrix = None, + uses_speaker_adaptation: bool = True, + uses_splices: bool = False, + uses_deltas: bool = True, + splice_context: int = 3, + ): + if self.lda_mat is not None: + uses_splices = True + uses_deltas = False + feats = self.mfcc_computer.compute_mfccs_for_export(segment, compress=False) + if cmvn is None: + cmvn_computer = CmvnComputer() + cmvn = cmvn_computer.compute_cmvn_from_features([feats]) + ApplyCmvn(cmvn, False, feats) + + if self.pitch_computer is not None: + pitch = self.pitch_computer.compute_pitch_for_export(segment, compress=False) + feats = paste_feats([feats, pitch], 1) + if uses_splices: + feats = splice_frames(feats, splice_context, splice_context) + if self.lda_mat is not None: + feats = apply_transform(feats, self.lda_mat) + elif uses_deltas: + delta_options = DeltaFeaturesOptions() + feats = compute_deltas(delta_options, feats) + if uses_speaker_adaptation and fmllr_trans is not None: + feats = apply_transform(feats, fmllr_trans) + return feats + + def generate_features_for_fine_tune( + self, + segment: Segment, + cmvn: typing.Optional[DoubleMatrix] = None, + fmllr_trans: FloatMatrix = None, + uses_speaker_adaptation: bool = True, + uses_splices: bool = False, + uses_deltas: bool = True, + splice_context: int = 3, + ): + + mfcc_options = self.mfcc_options + mfcc_options["frame_shift"] /= 10 + mfcc_computer = MfccComputer(**mfcc_options) + if self.lda_mat is not None: + uses_splices = True + uses_deltas = False + feats = mfcc_computer.compute_mfccs_for_export(segment, compress=False) + if cmvn is None: + cmvn_computer = CmvnComputer() + cmvn = cmvn_computer.compute_cmvn_from_features([feats]) + ApplyCmvn(cmvn, False, feats) + + if self.pitch_computer is not None: + pitch_options = self.pitch_options + pitch_options["frame_shift"] /= 10 + pitch_computer = PitchComputer(**pitch_options) + pitch = pitch_computer.compute_pitch_for_export(segment, compress=False) + feats = paste_feats([feats, pitch], 1) + if uses_splices: + feats = splice_frames(feats, splice_context, splice_context) + if self.lda_mat is not None: + feats = apply_transform(feats, self.lda_mat) + elif uses_deltas: + delta_options = DeltaFeaturesOptions() + feats = compute_deltas(delta_options, feats) + if uses_speaker_adaptation and fmllr_trans is not None: + feats = apply_transform(feats, fmllr_trans) + return feats + + @property + def version(self): + return self.meta["version"] + + @property + def uses_cmvn(self): + return self.meta["features"]["uses_cmvn"] + + @property + def parameters(self) -> typing.Dict[str, typing.Any]: + """Parameters to pass to top-level workers""" + params = {**self.meta["features"]} + params["non_silence_phones"] = {x for x in self.meta["phones"]} + params["oov_phone"] = self.meta["oov_phone"] + params["language"] = self.meta["language"] + params["optional_silence_phone"] = self.meta["optional_silence_phone"] + params["phone_set_type"] = self.meta["phone_set_type"] + params["silence_probability"] = self.meta.get("silence_probability", 0.5) + params["initial_silence_probability"] = self.meta.get("initial_silence_probability", 0.5) + params["final_non_silence_correction"] = self.meta.get( + "final_non_silence_correction", None + ) + params["final_silence_correction"] = self.meta.get("final_silence_correction", None) + if "other_noise_phone" in self.meta: + params["other_noise_phone"] = self.meta["other_noise_phone"] + if ( + "dictionaries" in self.meta + and "position_dependent_phones" in self.meta["dictionaries"] + ): + params["position_dependent_phones"] = self.meta["dictionaries"][ + "position_dependent_phones" + ] + else: + params["position_dependent_phones"] = self.meta.get("position_dependent_phones", True) + return params + + @property + def tree_path(self) -> Path: + """Current acoustic model path""" + return self.directory.joinpath("tree") + + @property + def lda_mat_path(self) -> Path: + """Current acoustic model path""" + return self.directory.joinpath("lda.mat") + + @property + def model_path(self) -> Path: + """Current acoustic model path""" + return self.directory.joinpath("final.mdl") + + @property + def phone_symbol_path(self) -> Path: + """Path to phone symbol table""" + return self.directory.joinpath("phones.txt") + + @property + def phone_pdf_counts_path(self) -> Path: + """Path to phone symbol table""" + return self.directory.joinpath("phone_pdf.counts") + + @property + def phone_pdf_counts(self): + if not self.phone_pdf_counts_path.exists(): + return {} + if self._phone_pdf_counts is None: + with open(self.phone_pdf_counts_path, "r", encoding="utf8") as f: + data = json.load(f) + self._phone_pdf_counts = {} + for phone, pdf_counts in data.items(): + self._phone_pdf_counts[phone] = {} + for pdf, count in pdf_counts.items(): + self._phone_pdf_counts[phone][int(pdf)] = count + + for phone, pdf_counts in self._phone_pdf_counts.items(): + phone_total = sum(pdf_counts.values()) + for pdf, count in pdf_counts.items(): + self._phone_pdf_counts[phone][int(pdf)] = count / phone_total + return self._phone_pdf_counts + + @property + def alignment_model_path(self) -> Path: + """Alignment model path""" + path = self.model_path.with_suffix(".alimdl") + if os.path.exists(path): + return path + return self.model_path + + @property + def acoustic_model(self) -> AmDiagGmm: + if not self.alignment_model_path.exists(): + raise AcousticModelError(f"Could not find {self.alignment_model_path}") + if self._am is None: + self._tm, self._am = read_gmm_model(self.alignment_model_path) + return self._am + + @property + def transition_model(self) -> TransitionModel: + if not self.alignment_model_path.exists(): + raise AcousticModelError(f"Could not find {self.alignment_model_path}") + if self._tm is None: + self._tm, self._am = read_gmm_model(self.alignment_model_path) + return self._tm + + @property + def lexicon_compiler(self): + lc = LexiconCompiler( + silence_probability=self.meta.get("silence_probability", 0.5), + initial_silence_probability=self.meta.get("initial_silence_probability", 0.5), + final_silence_correction=self.meta.get("final_silence_correction", None), + final_non_silence_correction=self.meta.get("final_non_silence_correction", None), + silence_phone=self.meta.get("optional_silence_phone", "sil"), + oov_phone=self.meta.get("oov_phone", "sil"), + position_dependent_phones=self.meta.get("position_dependent_phones", False), + phones={x for x in self.meta["phones"]}, + ) + if self.meta.get("phone_mapping", None): + lc.phone_table = pywrapfst.SymbolTable() + for k, v in self.meta["phone_mapping"].items(): + lc.phone_table.add_symbol(k, v) + elif self.phone_symbol_path.exists(): + lc.phone_table = pywrapfst.SymbolTable.read_text(self.phone_symbol_path) + return lc + + @property + def mfcc_computer(self) -> MfccComputer: + return MfccComputer(**self.mfcc_options) + + @property + def pitch_computer(self) -> typing.Optional[PitchComputer]: + if self.meta["features"].get("use_pitch", False): + return PitchComputer(**self.pitch_options) + return + + @property + def lda_mat(self) -> FloatMatrix: + lda_mat_path = self.directory.joinpath("lda.mat") + lda_mat = None + if lda_mat_path.exists(): + lda_mat = read_kaldi_object(FloatMatrix, lda_mat_path) + return lda_mat + + @property + def mfcc_options(self) -> typing.Dict[str, typing.Any]: + """Parameters to use in computing MFCC features.""" + return { + "sample_frequency": self.meta["features"].get("sample_frequency", 16000), + "frame_shift": self.meta["features"].get("frame_shift", 10), + "frame_length": self.meta["features"].get("frame_length", 25), + "dither": self.meta["features"].get("dither", 0.0001), + "preemphasis_coefficient": self.meta["features"].get("preemphasis_coefficient", 0.97), + "snip_edges": self.meta["features"].get("snip_edges", True), + "num_mel_bins": self.meta["features"].get("num_mel_bins", 23), + "low_frequency": self.meta["features"].get("low_frequency", 20), + "high_frequency": self.meta["features"].get("high_frequency", 7800), + "num_coefficients": self.meta["features"].get("num_coefficients", 13), + "use_energy": self.meta["features"].get("use_energy", False), + "energy_floor": self.meta["features"].get("energy_floor", 1.0), + "raw_energy": self.meta["features"].get("raw_energy", True), + "cepstral_lifter": self.meta["features"].get("cepstral_lifter", 22), + } + + @property + def frame_shift_seconds(self): + return round(self.meta["features"].get("frame_shift", 10) / 1000, 4) + + @property + def pitch_options(self) -> typing.Dict[str, typing.Any]: + """Parameters to use in computing pitch features.""" + use_pitch = self.meta["features"].get("use_pitch", False) + use_voicing = self.meta["features"].get("use_voicing", False) + use_delta_pitch = self.meta["features"].get("use_delta_pitch", False) + normalize = self.meta["features"].get("normalize_pitch", True) + options = { + "frame_shift": self.meta["features"].get("frame_shift", 10), + "frame_length": self.meta["features"].get("frame_length", 25), + "min_f0": self.meta["features"].get("min_f0", 50), + "max_f0": self.meta["features"].get("max_f0", 800), + "sample_frequency": self.meta["features"].get("sample_frequency", 16000), + "penalty_factor": self.meta["features"].get("penalty_factor", 0.1), + "delta_pitch": self.meta["features"].get("delta_pitch", 0.005), + "snip_edges": self.meta["features"].get("snip_edges", True), + "add_normalized_log_pitch": False, + "add_delta_pitch": False, + "add_pov_feature": False, + } + if use_pitch: + options["add_normalized_log_pitch"] = normalize + options["add_raw_log_pitch"] = not normalize + options["add_delta_pitch"] = use_delta_pitch + options["add_pov_feature"] = use_voicing + return options + + @property + def lda_options(self) -> typing.Dict[str, typing.Any]: + """Parameters to use in computing MFCC features.""" + return { + "splice_left_context": self.meta["features"].get("splice_left_context", 3), + "splice_right_context": self.meta["features"].get("splice_right_context", 3), + } + + def _load_meta_data(self): + default_features = { + "feature_type": "mfcc", + "use_energy": False, + "frame_shift": 10, + "snip_edges": True, + "low_frequency": 20, + "high_frequency": 7800, + "sample_frequency": 16000, + "allow_downsample": True, + "allow_upsample": True, + "use_pitch": False, + "use_voicing": False, + "uses_cmvn": True, + "uses_deltas": True, + "uses_splices": False, + "uses_voiced": False, + "uses_speaker_adaptation": False, + "silence_weight": 0.0, + "fmllr_update_type": "full", + "splice_left_context": 3, + "splice_right_context": 3, + } + if not self._meta: + meta_path = self.directory.joinpath("meta.json") + file_format = "json" + if not os.path.exists(meta_path): + meta_path = self.directory.joinpath("meta.yaml") + file_format = "yaml" + if not os.path.exists(meta_path): + self._meta = { + "version": "0.9.0", + "architecture": "gmm-hmm", + "features": default_features, + } + else: + with open(meta_path, "r", encoding="utf8") as f: + if file_format == "yaml": + self._meta = yaml.load(f, Loader=yaml.Loader) + else: + self._meta = json.load(f) + if self._meta["features"] == "mfcc+deltas": + self._meta["features"] = default_features + if "pitch" in self._meta["features"]: + self._meta["features"]["use_pitch"] = self._meta["features"].pop("pitch") + if ( + self._meta["features"].get("use_pitch", False) + and self._meta["version"] < "2.0.6" + ): + self._meta["features"]["use_delta_pitch"] = True + if "phone_type" not in self._meta: + self._meta["phone_type"] = "triphone" + if "optional_silence_phone" not in self._meta: + self._meta["optional_silence_phone"] = "sil" + if "oov_phone" not in self._meta: + self._meta["oov_phone"] = "spn" + if file_format == "yaml": + self._meta["other_noise_phone"] = "sp" + if "phone_set_type" not in self._meta: + self._meta["phone_set_type"] = "UNKNOWN" + if "language" not in self._meta or self._meta["version"] < "3.0": + self._meta["language"] = "unknown" + self._meta["phones"] = set(self._meta.get("phones", [])) + if ( + "uses_speaker_adaptation" not in self._meta["features"] + or not self._meta["features"]["uses_speaker_adaptation"] + ): + self._meta["features"]["uses_speaker_adaptation"] = os.path.exists( + self.directory.joinpath("final.alimdl") + ) + if self._meta["version"] in {"0.9.0", "1.0.0"}: + self._meta["features"]["uses_speaker_adaptation"] = True + if ( + "uses_splices" not in self._meta["features"] + or not self._meta["features"]["uses_splices"] + ): + self._meta["features"]["uses_splices"] = os.path.exists( + self.directory.joinpath("lda.mat") + ) + if self._meta["features"]["uses_splices"]: + self._meta["features"]["uses_deltas"] = False + if ( + self._meta["features"].get("use_pitch", False) + and "use_voicing" not in self._meta["features"] + ): + self._meta["features"]["use_voicing"] = True + if ( + "dictionaries" in self._meta + and "position_dependent_phones" not in self._meta["dictionaries"] + ): + if self._meta["version"] < "2.0": + default_value = True + else: + default_value = False + self._meta["dictionaries"]["position_dependent_phones"] = self._meta.get( + "position_dependent_phones", default_value + ) + self.parse_old_features() + + @property + def meta(self) -> typing.Dict[str, typing.Any]: + """ + Metadata information for the acoustic model + """ + if not self._meta: + self._load_meta_data() + return self._meta + + def parse_old_features(self) -> None: + """ + Parse MFA model's features and ensure that they are up-to-date with current functionality + """ + if "features" not in self._meta: + return + feature_key_remapping = { + "type": "feature_type", + "deltas": "uses_deltas", + "fmllr": "uses_speaker_adaptation", + } + + for key, new_key in feature_key_remapping.items(): + if key in self._meta["features"]: + self._meta["features"][new_key] = self._meta["features"][key] + del self._meta["features"][key] + if "uses_splices" not in self._meta["features"]: # Backwards compatibility + self._meta["features"]["uses_splices"] = os.path.exists( + self.directory.joinpath("lda.mat") + ) + if "uses_speaker_adaptation" not in self._meta["features"]: + self._meta["features"]["uses_speaker_adaptation"] = os.path.exists( + self.directory.joinpath("final.alimdl") + ) diff --git a/kalpy/utterance.py b/kalpy/utterance.py index caebb92..c43da18 100644 --- a/kalpy/utterance.py +++ b/kalpy/utterance.py @@ -1,3 +1,6 @@ +"""Classes for utterance data""" +from __future__ import annotations + import typing import dataclassy @@ -13,8 +16,11 @@ from _kalpy.matrix import DoubleMatrix, FloatMatrix from _kalpy.transform import ApplyCmvn, apply_transform from kalpy.data import Segment -from kalpy.feat.mfcc import MfccComputer -from kalpy.feat.pitch import PitchComputer +from kalpy.feat.cmvn import CmvnComputer + +if typing.TYPE_CHECKING: + from kalpy.feat.mfcc import MfccComputer + from kalpy.models import AcousticModel @dataclassy.dataclass @@ -44,29 +50,34 @@ def apply_cmvn( def generate_features( self, - mfcc_computer: MfccComputer, - pitch_computer: PitchComputer = None, - lda_mat: FloatMatrix = None, + acoustic_model: AcousticModel, + cmvn: typing.Optional[DoubleMatrix] = None, fmllr_trans: FloatMatrix = None, uses_speaker_adaptation: bool = True, uses_splices: bool = False, uses_deltas: bool = True, splice_context: int = 3, ): - if lda_mat is not None: + if acoustic_model.lda_mat is not None: uses_splices = True uses_deltas = False if self.mfccs is None: - self.generate_mfccs(mfcc_computer) + self.generate_mfccs(acoustic_model.mfcc_computer) + if cmvn is None: + cmvn_computer = CmvnComputer() + cmvn = cmvn_computer.compute_cmvn_from_features([self.mfccs]) + self.apply_cmvn(cmvn) feats = self.mfccs - if pitch_computer is not None: - pitch = pitch_computer.compute_pitch_for_export(self.segment, compress=False) + if acoustic_model.pitch_computer is not None: + pitch = acoustic_model.pitch_computer.compute_pitch_for_export( + self.segment, compress=False + ) feats = paste_feats([feats, pitch], 1) if uses_splices: feats = splice_frames(feats, splice_context, splice_context) - if lda_mat is not None: - feats = apply_transform(feats, lda_mat) + if acoustic_model.lda_mat is not None: + feats = apply_transform(feats, acoustic_model.lda_mat) elif uses_deltas: delta_options = DeltaFeaturesOptions() feats = compute_deltas(delta_options, feats) diff --git a/notebooks/visualize_alignments.ipynb b/notebooks/visualize_alignments.ipynb new file mode 100644 index 0000000..7b1da65 --- /dev/null +++ b/notebooks/visualize_alignments.ipynb @@ -0,0 +1,207 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2025-09-11T18:01:58.068754Z", + "start_time": "2025-09-11T18:01:55.083993Z" + } + }, + "source": [ + "import numpy as np\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import phonlab as phon\n", + "from IPython.display import Audio\n", + "\n", + "from kalpy.data import Segment\n", + "from kalpy.utterance import Utterance\n", + "from kalpy.models import AcousticModel\n", + "from kalpy.aligner import KalpyAligner" + ], + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-11T18:01:58.651383Z", + "start_time": "2025-09-11T18:01:58.647003Z" + } + }, + "cell_type": "code", + "source": [ + "test_directory = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"tests\", \"data\")\n", + "acoustic_model_directory = os.path.join(test_directory, \"acoustic_models\", \"sat\")\n", + "dictionary_path = os.path.join(test_directory, \"dictionaries\", \"test_mfa.txt\")\n", + "wav_path = os.path.join(test_directory, \"wav\", \"mfa_michael.flac\")" + ], + "id": "d56355760da01fe5", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-11T18:01:59.874478Z", + "start_time": "2025-09-11T18:01:59.683090Z" + } + }, + "cell_type": "code", + "source": [ + "am = AcousticModel(acoustic_model_directory)\n", + "lc = am.lexicon_compiler\n", + "lc.load_pronunciations(dictionary_path)\n", + "aligner = KalpyAligner(am, lc)\n", + "seg = Segment(wav_path)\n", + "utterance = Utterance(seg, \"montreal forced aligner\")\n", + "ctm = aligner.align_utterance(utterance)" + ], + "id": "71e993eaf31b6529", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-11T18:02:01.392843Z", + "start_time": "2025-09-11T18:02:01.313225Z" + } + }, + "cell_type": "code", + "source": [ + "time_axis = np.arange(len(seg.wave))/16000 # this is a list of time values in seconds, from 0, to len(y)/fs\n", + "plt.plot(time_axis,seg.wave, color = \"red\") \n", + "\n", + "Audio(seg.wave,rate=16000)" + ], + "id": "5badebf8241549ae", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-11T18:02:03.009989Z", + "start_time": "2025-09-11T18:02:02.526727Z" + } + }, + "cell_type": "code", + "source": [ + "ret = phon.sgram(seg.wave,16000,cmap=\"Blues\")\n", + "boundaries = ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='#FFD60A')\n", + "for label, midpoint in ctm.labelled_midpoints:\n", + " ret[0].annotate(label, (midpoint, 7500), color='#FFD60A', ha=\"center\", fontsize=\"large\")" + ], + "id": "b369083526932e8b", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-11T18:02:04.522333Z", + "start_time": "2025-09-11T18:02:03.822925Z" + } + }, + "cell_type": "code", + "source": [ + "fine_tuned_ctm = aligner.fine_tune_alignments(utterance)\n", + "ret = phon.sgram(seg.wave,16000,cmap=\"Blues\")\n", + "boundaries = ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='#FFD60A')\n", + "boundaries = fine_tuned_ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='red')\n", + "for label, midpoint in ctm.labelled_midpoints:\n", + " ret[0].annotate(label, (midpoint, 7500), color='#FFD60A', ha=\"center\", fontsize=\"large\")" + ], + "id": "efdeef8937a60c6d", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "870ca3febe14a961" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/visualize_fine_tuning.ipynb b/notebooks/visualize_fine_tuning.ipynb new file mode 100644 index 0000000..7e4270f --- /dev/null +++ b/notebooks/visualize_fine_tuning.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2025-09-17T18:06:35.777245Z", + "start_time": "2025-09-17T18:06:30.269272Z" + } + }, + "source": [ + "import os\n", + "import matplotlib.pyplot as plt\n", + "import phonlab as phon\n", + "\n", + "from kalpy.data import Segment\n", + "from kalpy.utterance import Utterance\n", + "from kalpy.models import AcousticModel\n", + "from kalpy.aligner import KalpyAligner" + ], + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:38.508963Z", + "start_time": "2025-09-17T18:06:38.505778Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "test_directory = os.path.join(os.path.dirname(os.path.abspath(\"\")), \"tests\", \"data\")\n", + "acoustic_model_directory = os.path.join(test_directory, \"acoustic_models\", \"sat\")\n", + "dictionary_path = os.path.join(test_directory, \"dictionaries\", \"test_mfa.txt\")\n", + "wav_path = os.path.join(test_directory, \"wav\", \"mfa_michael.flac\")" + ], + "id": "d56355760da01fe5", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:39.504633Z", + "start_time": "2025-09-17T18:06:39.269905Z" + } + }, + "cell_type": "code", + "source": [ + "am = AcousticModel(acoustic_model_directory)\n", + "lc = am.lexicon_compiler\n", + "lc.load_pronunciations(dictionary_path)\n", + "aligner = KalpyAligner(am, lc)\n", + "seg = Segment(wav_path)\n", + "utterance = Utterance(seg, \"montreal forced aligner\")\n", + "ctm = aligner.align_utterance(utterance)" + ], + "id": "71e993eaf31b6529", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:40.311026Z", + "start_time": "2025-09-17T18:06:39.818372Z" + } + }, + "cell_type": "code", + "source": [ + "ret = phon.sgram(seg.wave,16000,cmap=\"Blues\")\n", + "boundaries = ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='#FFD60A')\n", + "for label, midpoint in ctm.labelled_midpoints:\n", + " ret[0].annotate(label, (midpoint, 7500), color='#FFD60A', ha=\"center\", fontsize=\"large\")" + ], + "id": "b369083526932e8b", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:41.797935Z", + "start_time": "2025-09-17T18:06:41.224858Z" + } + }, + "cell_type": "code", + "source": [ + "fine_tuned_ctm = aligner.fine_tune_alignments(utterance)\n", + "ret = phon.sgram(seg.wave,16000,cmap=\"Blues\")\n", + "boundaries = ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='#FFD60A')\n", + "boundaries = fine_tuned_ctm.phone_boundaries\n", + "ret[0].vlines(boundaries, 0, 8000,colors='red')\n", + "for label, midpoint in ctm.labelled_midpoints:\n", + " ret[0].annotate(label, (midpoint, 7500), color='#FFD60A', ha=\"center\", fontsize=\"large\")" + ], + "id": "efdeef8937a60c6d", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAF+CAYAAACf0OyDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9a7RlV3Uein5jzDnXWvtVVaoqlYSQQBJPge1DAjkco+BLYgNOgslNfBI4xLJzw7WV+MmlGcdpjtN0b7OTmASbRLbvAcxxwDaOTw6nxblJwDZJnEDQSbAESKDSu1Tv9679Wo/5GGPcH318Y4w519q7qlSl0oPVG6L23muuOcccz6/3/vXelXPOYS5zmctc5jKXucxlLnOZCwBAP9cNmMtc5jKXucxlLnOZy1yeTzIHyHOZy1zmMpe5zGUuc5lLInOAPJe5zGUuc5nLXOYyl7kkMgfIc5nLXOYyl7nMZS5zmUsic4A8l7nMZS5zmctc5jKXuSQyB8hzmctc5jKXucxlLnOZSyJzgDyXucxlLnOZy1zmMpe5JHLNALIxBj//8z+P2267DYPBALfddhv+/t//+2iaJlzjnMM999yDm266CQsLC3jb296Gb37zm637lGWJn/iJn8D+/fuxtLSEd7/73Th27FjrmgsXLuCuu+7C7t27sXv3btx1111YW1u7Fq85l7nMZS5zmctc5jKXF7hcM4D8S7/0S/i1X/s1/PN//s/xyCOP4J/9s3+GX/u1X8M/+kf/KFzz4Q9/GB/5yEdw77334itf+QoOHDiAt7/97djc3AzXfOADH8BnP/tZ/O7v/i6++MUvYmNjA+9617tgjAnXvO9978MDDzyAz33uc/j85z+PBx54AHfddde1etW5zGUuc5nLXOYyl7m8gEVdq0p673rXu7Bv3z586lOfCn/7oR/6IZw/fx7/9t/+WzjncNNNN+HHf/zH8XM/93MAgPF4jAMHDuCf/tN/irvvvhvr6+u4/vrr8Zu/+Zv4G3/jbwAAjh49ipe//OX43Oc+h3e+8504ePAgXve61+FLX/oS7rzzTgDAl770Jbz1rW/FI488gte85jXX4nXnMpe5zGUuc5nLXObyApVrZkH+s3/2z+I//af/hEceeQQA8PDDD+M//sf/iL/4F/8iAODQoUM4deoU3vGOd4TvLCws4Lu+67vw5S9/GQBw//33o67r1jW33HIL7rjjjnDNfffdh+XlZbzlLW8J19x5551YWloK18xlLnOZy1zmMpe5zGUu20l+rR70d//u38Xm5iZe97rXIcsyNE2Dn/u5n8OP/uiPAgBOnToFALjhhhta37vhhhtw/PjxcE2WZdi/f//UNfz+qVOncP3110MpFT5XSuHAgQPhmq58/OMfx8c//nEAwMGDB/HKV74KDg7OAVprGNOgKApUZYX+YIDxeITFhUWoB+7f/oW1Rvn6b0PvqScBANVttyPLc9R1hX6/j8l4goWFBYxGIywuLoZ/x5Mx+v0B6qpCnucw1kAp0WOcs8i09F3R66EsJ1gYTN/DTR6B1hnG7hYURQ+maaC1vqR3GiX/LiwsopxM0Ov3UNc1siyHtRZKAQoK1toreqfCPAUHB5u/8qLvNB6PMVgYoCxLDNQROOdgslc8797pcsaJ74TyMSilUOHWyxqnpfw4jDFQg9de1jth8ih0lmFYv/RZe6eyLHece30chnMO6L/mORun3DwJpRRK9/Kr8k7Px7mnym3G+ll6J45rk93+nK2n7jvl5kk4ACZ/5bMyTtd6PfXwNOAcKn37Fc+9nn0K8HvPcz1OO809N3kEWZZh2Lz0eb2XX+o7LeijMNZAD177rOwRbvIIlNYo3cuv6Tg9l/tezz0N5xxc79WX9E6nT53CuXPntsdwuIYA+fd+7/fw6U9/Gp/5zGfw+te/Hl/72tfwUz/1U7jtttvw/ve/P1yXAltAAve6f+tK95pZ1+90nx/5kR/Bj/zIjwAA3vjGN+G//rc/uaR36hed+2VZ/Hl5GeUDX0fvu98GAKj+wx9f0j2vhvSOfa888+bPX7NnPhN5pu18obzfpcq17ofnQ//N23Bt5Fq/4/OxT5/tNr2Q+/j5OF6z5IXSzkuVF9ucfD7I5b7znW9+00WvuWYUiw996EP46Z/+abz3ve/Ft3/7t+Ouu+7CBz/4wRCkd+ONNwLAlJX3zJkzwap84403whgzhfq715w5cwYptdo5h7Nnz05Zp+cyl7nMZS5zmctc5jKXrlwzgDwajZClFlYAWZbBWgsAuO2223DjjTfij/7oj8Lnk8kEX/ziFwOf+I1vfCOKomhdc+zYMRw8eDBc853f+Z3Y2trCfffdF6657777MBwOW7zkucxlLnOZy1zmMpe5zGWWXDOKxfd93/fhH//jf4zbbrsNr3/96/HVr34Vv/zLv4wf/MEfBCC0iA984AP4xV/8Rbz2ta/Fq1/9avzCL/wClpeX8b73vQ8AsHv3brz//e/Hhz70IRw4cAD79u3DBz/4QXzHd3wHvud7vgcAcMcdd+B7v/d7cffdd+MTn/gEnHO4++678a53vWuewWIuc5nLXOYyl7nMZS4XlWsGkO+99178/M//PH70R38UZ86cwUte8hL88A//MP7BP/gH4Zqf+ZmfwXg8xo/92I/hwoULePOb34w//MM/xMrKSrjmV37lV5DnOd7znvdgPB7ju7/7u/HpT3+6ZZ3+nd/5HfzkT/5kyHbx7ne/G7/6q796rV51LnOZy1zmMpe5zGUuL2C5ZgB5ZWUFH/3oR/HRj35022uUUrjnnntwzz33bHvNYDDAvffei3vvvXfba/bu3Yvf/u3fvoLWzmUuc5nLXOYyl7nM5VtVrhkHeS5zmctc5jKXucxlLnN5IcgcIM9lLnO5ZtIY+1w3YS5zmctc5jKXi8ocIM9lLnN51sQ5B2tjysXaXJ3K9uk95zKXK5VJbZ7rJsxlLnN5nskcIM9lLh2ZWzmvntTGoU76s2quTt/W8zGay1WU+irNy7nMZS4vHpkD5LnMJZHGWDQvEutk8fQboUf/ZervaRGdqymz7tsY27Ia18ZesQJirUNjHFR9GIPHlwDXXNH9rpWo6jH0jnwn+k/cgGzt15/r5swFAoxHZRMUt7lyfHWkf+gO6NF/fK6bccWiN/4liuPf91w3Yy5XQbLVf4L89I8CAFR9GPf/9sGLnh1zgDyXqy7PFgC7FlIbB2Nca4PP1v83qPKbz3HLLk+sdVh/yX+DXfyuqc+ejdFpjEU5wwrXtSDL79u3wFyCctJYh+oFCGSyC78Cu/BWlK88DbPnR5/r5nzLi3MyN8e1ReXnZDo3y9rIvO7QL67W/vZiAZEvZrG73ov6pf+/57oZc7kKYvZ+CM0Nl2eYmAPkuUzJlR4AzVXimT4XUjXTFmTVnATs8Dlq0eWJcw51I2B1WyCa/Lkx9qrwLxtv1Z3199R9LRbl7cFtasHbzppnt3nWtZbLXSeqPgLXe92z1Jq57GT9dc5NfW6sKGtlbcIcrRqLurGoGotJbVHW0+voUpS4ucxlLi98mQPkZ1H6h+4A3n4S6u9/A/0nrkd++u8AzWkUx//v6D9xA4pjfwkwF57rZk5JF3yoydfQO/IWafPJH0Rx8oeQn/t/b//9KzhA+ofuQHbho+gd/h/Rf/IlKE7+IGAnz/h+s2QWsOHfamOxsvojQHMUxYm/hv4TB5Bd+JWL3vPZDBrTo/+C3lOvCr93D2jTCYKrvdVr38lvn2mhcojBcwIQIu3hYhzh/qE7kK3+E/QOvxH9J1+K/NTdgJ2gMW7md02HYmEuAm4b68L7zJpHzjkY56ZAdgp+rpUHY5bFfDspjv0F6PF/QX72g+g/cQCqevxZbNkzl+3G97kSPfov6B961cUvxM77jnNxbleNhbEOzsl3BATbYFHOLnwES4dfjetPvBS7TrwRGP6n1r2uxlIvTr2/vces/vKV35RiN1Gc/AH0n7od/SdvQu/I/w16+IWrd/8XoWSr/xS9p78N/SduQO/wG6G3/o38feO30Dv6Pc9Zu67FeXjFYi6gOPE+9J+6Df0nX4re0e+GGt8HuAZ6+EdAffyaNylb/Qj6T71SxvPpN0CP/hPy87+I4tTfuqz7zAHysyzqT12A+2evQXnr15EN/z16J/4Kmn33oLz9CACLbO3/+1w3cUpaAMxV6J18L8zK/4LyFcdglv8K9Na/3vH7V8rjyzb/T1Qv/X2Ut34TqvwGso2rW/SlMdPWpDpxsV7Y/b8C+S2ob/pXKF95Bua6/1e4LgVfbWBqn/XMCnxe9zl8F1rJag9Wu62hlcw5B+uAyltzqyb+dynBb9nmv0R1079GeetD0PUTyFd/aVtucWPbYLYxbkcLXDo26Xta60K74YCs/Bp6R4U+oi/8r3DD/xzf08weo6stlxPYVd/8ObiFO9Fc/8soX3kGrndpoO+5kFnj+0IQs4Pi5RDnBa3E1jkYP/+NB8ooH0N/8xM4tfcLePK6p3F6979ChZtbc9tad8Vrvb7xk+09Zu8Hr+h+XTErfwPlrQ+hvP0Y6ut/CcWZvwM1+epVfcaLSVxxO6qb/wjlK06i2fv3vAJz8rluFoBn/zy8crEwu97r59sRNHt/Br0TfwW9I3eiOPVDyEb/4Zq2RlWPIV//GMqXfRHlK0+jfunvw+Uvf0b3mgPkZ1ncH98AbBZAfhPs4E7YwZ+BG7wB0H3Y5XdDl19/rps4JSmoUJP/DrgaZs+PA6qAXfkrcIM37vj9WZacyzlQmj1/B8hfAmR7YZf/AlT54KU3/lLu762UKditjRyajbFTFiJrLZxTmNSm1TfpQdmYZ5cXS6sv0B4fAcXx4DfWeY7uNIgmUHUArKdi0PJL0HAp1AWz+28DxS1AthfN3g9Bb/0rNNtwi7sW48Y62B0svCaxIMt3PVh27THr119CufcfAwDU8A8w0n863KNuorLybABka8UtXxl3UZB8WfP+ecKrnjW+LwTZ2YLsAt2n9P9ZFxU4Y52nJSkoVwLlI6jqEmPcjIm+FWVjW+uP6+V5KXoFdvkvAHoJUBpu4X9Cs/v/iWz9N5/rlj1vxa78VTlzlIZd+Z/hildAT+5/rpsF4Nk/D69Ysn2wy+8G9DLQnEK28RnAWdil74VdfAdUdfBaNwhwJXR1EHA1XPFyuN7tz+hOc4D8bMtGUs1bD4DsQPxdLQB269q36SJiEr6eak7C5TcBSoXPXX7Ljm7sxripz3cCRVOS3xB/VotQ7ur2kbFiiUwBXWMcJrVBbVzL8qrKB6HKBzBSt2NSmRbYsy6CPQLsqymxDy3gxE0MyPhEa3AEBo1xAfw3xiLt8haAdZ7H66+lFbm+CD/YfxWuuCX+nr8MqjkpHOQZigcBewpYgyW8Myec70/nopU7Bbj8rtYKZ/K/ja3szwAALuz731HZQbiu9gGDKVCO/XAVsmg4h0ntFYqLAODLSUdX1s8PwDVrfJ87ufQ+SedZVxxk/oxrExRCctlrE9fBCLdia88/wnWjX8JrNl+PA5s/DDQnMamFk8zncI49H0Vv/B76T+xH/8mbwn/56j+Bao4910173ore+B30Dv9Pob9U9TCUOb/jd66ZQnuF52F3T35WxE6Qrf4SeifeDbP8l2H2/G3AnEez96ehx3+M4tT/49l9fiKu9wrU+z+M/Pw/RP+pW1Gc/KFn7A2YA+S5AGhTBwieAMBlN0I1J+Bsshk0x3bMhBDclZ2/PV9EQJinIzTRckwLrALgoGAs4PrfgeEN/wcmZgWTug2InIt8xMbunJ3hmQj7TDVHAUTg7hwCZ9IhAcgeIESrbdtyG8bU36MxAkjrFrC++Duo+mj8uTkKl78kgFfnxBLHw4N/ZyBgCty7e7b1wN16cJzykfm5c4BWtOJFxaCbKaNqLCpvGew+40oD/GhBbOw0VScVWi0vVcpmOmNC97mpPFsWzHR8XSXj+1yJzP1LE7OTd8LR8m+DN4VrojQmzP3aOFRLfx1PLPwbfK333+EcsG/0/wmgGoipC68UIMtOs81nlwhoZioE+Y1w+S0oX3Ei/Geu+8mW4jOXROojKM78OOoDv4zy9qMoX3HCB9PuPAYvlHSgxu5Ma7tSUdWT6B35TijXoLrlS7ArfxWqfhqueBlc/9tQvew+1DdeW++F3fUeVLd8AeWtYr0uzv39Z3SfOUCeC4COpc5FPp9beDMccsnb6hrord+HnvzJRe/VzYzwfNpLrHXBopQCqcrzX7UCkB8AqqfkC07Ay8Rbnygp7YHW26vJQzbNOlAfQ7b264EWAcToewHowqPkJmgSkJy2JLiRayP3AlrW5to4GIcOX9hOWYPhgGz9Y0B9DE11DvnqP0Wz9P1o/P2tE6oHXdJs07gy4R4R6LcBZvqZTd4n/dxYhzzTAmaa1KIX79UkLvDuIWZtBNN8t8u1rlBBaWYA8FTKGZSVLoBjmyeVCZkTuu2lTAFkEwHb1RKHzvhe+Cewy9//jO51Re0yG2HuX/JXdgACgVbk5zqVqsZY1NYGb0VWPYai/M9omgnKpoBxA8BplLUJXonKr/UrLnqTH4Cqn261H8AlU52A2Z45O3gzlBtCb/wO4CzU5CvI1j8Js+tvXll7X6Si7BCAArL9MgfWPw1VPXzR7+3EeX8+Cc+LZ0tctg/KnIftvwFQA6jxfdCj/wCz8r88a8/cSVT1GPTojwFbAnoApxcAZM/oXnOAPJep4hjMFAAAUD0MD/w2ss3fQf/JlyLb/CyapXdPWf9SMTMODx70/HdSmecsX7IDoIAQqEZwS/5xnmk01/00+mv/RFxuG/+8FcjWvRcQASg/J3hL+bSX9b7OYdfRV6F34q/CrPx1/imItDVG4tcJ/zhQP1JahgcPZWMBb0EnoA2Bc64NMLoBdRMPrs3Ke9A78ZexdOQ7YPNbMdr10wFgWOezAjTkDtO17fvPthUMAgFa8cVCrAJwb7dH5mmmVXCJ892Ymitm57DBdS59F2kd/HvaN7Nk27973nfjlYpZQu9Ek4y7c+05kOaOpvLF37lOUqvlNECe7qOLycVAq3NAs+zH96iMb7P3717y/dvPeobr2zn0D93emvsXf5adUgpnSeXnGZUqk/wrSvMEixfuwf8weT3+R/unkLlzODP4ufC9zUkT1tqV8pCb634a+eovof/kTcgufLSVveVSx3TmZXqA6iW/h3z9E+g/9VIUp38c9YFfhxv8qWfc1hezuP4dMHt+Er2jfx4LT98GlN+EW/jOi37vubQgX85ZcjVoZTtKtgfVTf8S+eovov/UTSjO/gyql/xLiWN4LsSVyM/9A/Sfehn6T90O1ZxFvX/7rFs7SX7xS+byTKW87SB6j7wt/F7f+L+1Pje7/ybM7r95TdvknINSbdde1/JJVzelKv4U3Ev/K3q56FNlbaCUQm+bZwQgljyTlo7KWAx0hrKxWHZCbU7bVN7WJvQ3+37uGb/rdhJBmAdcKvJdrXXo5RpN/pew/pJ3YlBk0FqhOTucCZD5vsY6aCWBej2rWwFxBHROAXmWcLlnjEUQpbB68yksDWSJHnN/G9fZCPLallgEIBapDsBXsv8Lr8tXsIj4brXPbuH8+5KukAJ5SmMdoIA8Q6CgXLjpISwPcpi9H8LWpJG+aiycm4Tn18bCQUMpFSgTZW2wPqpRW5sAxjY9xFgHpaS/qHB028PuaqzDGLfg7M1rMOMGjW1QGwftsxM4C2TaTVFYXfIsegAa45DPMDBYD8YBef8806HdqbV+lrAgCpWQTAGbN/575FqFTZdWcFswQMwia+R5VWMBJVboQS8L2T2c02HOCA9WCSVop7mUiFjgt//8/EsexEKRwe77kCixABb0M7O+UCmc1S6T9G36O/u5fOU5AF5ZT7LI7PSsnbw3LrmOa5WgunEWxisvF+xrcWr/F3BsdYz1ssbefg/LOkddGVgHDH3VvTxTl62cdMUuvwvl8rtiu6hcG4tcd/boZP617rENUHKDP4Xqlj9+xm27Uunu4893afbfg2b/PRhXBrlWKPxZl61/Ck4Vs79zDQDyduehMbZ1luwkjd2JzHN1xC28BdXLvvwsP+XSxPW/HdXLpivIpljCFS/HG3/gDtx//84QeG5B/haTWRu6MS5YIiwtia79nfR7KbUgfKfzDLp0CNaCdcT/vfRABojZF66laK28BdPCOHJf5cBZ6GUY+4C9qrHItArWvRQgKyWWaLaf1kn+O/GVuNgPXcXjYu9sOn0cOMQEli4qH9EC5kJbJsZgUtvW3zgupDcEq7MVINPKOGFscCPSWtbN/JFSIaxDsOSm2Seck+8Py6bl6mMbwn++DUWugxs8Be4EiY2xKK30rQufRQu/dQl9pNPHChFMMRAwvaZL+aCkVvGUzrKdJYccV15TNXbKJUs3fRo4RsWqbGygXQBMydfmiId0fu7SrbXsqzQ1YLvd0Xtk3GxO76Wu1ca62RZORHoI34/c6+69pzw2bvuxss5Bb6ck+M/COnSutS4aJ/1YGotxZWStWBvmCef+uDJB+Z9VVOiZSgq2tyu4M0ue7dSS32pirGvtu6o6CFfcOvvaq2iVvdzz7/K8RpcXCzGXKHOA/C0ms9ZJ6tJLLWtpWqOuiya9DVOGzfrdeqtf4NeZyOV1/tpZeYmfDUmfUWQqUAoY7OZcdLtPfDAPD8PGCOBMD2ytFJRSHhD69/MAjZkhrAexEaDOBmCzJP3cJoCWoNAhCbhLxo9KSeXbX9YmjHttfEYMRNDeOFFWMq1aG2mdbKy1EY42PyWFwLoUuMeUcZHaAFgIMB9XBnWHYmGsD5zyADjXKlgSa6+8EPxGrjEVEQYbRqDPDCqBj+zbSSum9tZ84yKHu129L8m4kRyUVTIXOJbWbe/S5304p9j+YP1tIu997LOjpBQd8pEDT5bKQQfMh3y+l3gAUnnl5d3vGT8/wtjNuO/FaRouXKe2ud6wgl0HKM+ikTgXYxrS9Zf2hYBeTFleU6Enh8pwqthxPEtjMK4MjHMw3rJsrKz9TCuME6Wlvor7VqtAjrFTVvdts3PMcc9lycXGK6VeFSfeAz36Asyen5x9rxnnIu/RlYspMpcLkC/n8q6Bay6XLnOKxbeYzFqodLUD0WXHQ71fZGK9TK6nJYZCYEK3VLogrXNQSieWK4eh5/E5j/Doyu8/K2/cfs88kywIPIDSDdHTduWdfFutiwc3C2uUtUG/yKAVsyL47Be+XxRiCrk8i4dxrhUa58J78u/bSZf2Eji1btoylyozAYzbmJ2Dru5AsYCAOKWcp2dEAEFprEOeWPnTw6DywUqkUbAPSS3oJeOvQcqEvH9QSpwEhE48L9pYh8VeFu7D6ya1gFP+LgDXBvpGagVPx0ErhdJIECbnZq6V95L4se5YkGk11VA+DZi4tpkybnmQhywbftrG/krc4JELjlD5j30s72dbiiQt5JmOimRQuowLFQllDLL4nUQxuhSh8qa8baT7tcYmgZKJwpjKxZ4V1pCVlHyT0kzRA5pESaFi1c0zDsg8Iw1oUGSojUPfe7zb60PGX+8AkItMtQwA1qlWFprGyJohGDcu8s0njUUv1xg3xitO/R0pFqSMXA71JQDkZD+O7zf7e5eVPnMuLYrRrPmSeoXqm35v5j24zrlmu5SlxlhkHVoS5122zfy8XE/AZeVXnzGf5nJpMrcgf4uJmbGh0ooCRIsEAZR8px2wJcDQtb6fco65cUggnvyt8ddY5zCqTDtNmWnnq3223Iah/X63UEoOSFIlADk4R54KQBe4sQ6VtcHNzXfNtIJ1YgWkkkFQQOte99mtPMp2Z95k6mklxYIZOGidhG9/N89wY+WwJ2C1DqF9fE9SJGgJZYAbEIPmwu8esLGfmMot81QVCvNBp/NJK2BiDEZNg9qm1mUB++xjY13gXKc0nXElVj2bvFsAoDamqaMVkICqyNRUfmoebEz1R8CdUmHSMUst6MxkEi3D0vkhm4ZJ0+zZAP5IO0nXDLOQUOGyTuZYWvQlzU2dpuKjMFBQqbblfyehx4Ztmc4TnQYVzs66cbFHOSfzh+M3Kx0aSzxX/rrKyO/TFmQbAjwnicVZ3qX9zIuBxUGRtQA/g5G5n3HNjBsTPg9jZAx2LRQY1g1GtQl0jJ0AMnDx0u3p9akXr19krc+2e7cA8K+BB+7FIMYm3s0ZfcozqfV757rU2zErz/mstXixlJCXTbG4DMXoUrjyc6rObJkD5G8xmbUQUldx+DShA4S0YY5WUT0FJNoUC6CyFiMf5ANEvqR1CC5ll3w/bdblFFe4HLEesFCLp8VUKdWyJGyVJoCc2lhsjmt5Ryvc17KOFllaGa1zoV+EItDmfVkXgTNlO45n+E7n+3yOTQ5TWiVozQzKiTEBjDKAL0ue79C2cgII6auAmJWDIJ0AjdYwAjgGbgaroXEovfIz8VxOCbrz+ZFtdGs7IFBUrJsGp7V3NZOSE3I2G+uD/aIFX2gi8IqA9MegyAIdoz0P0iC92GfdPqdiSHpE1VgBcS4Ck0xL+ya1aaWX47sopQJ3Pb23uNHbPGKOF5WDNFCRB2zwzCSKAsf9UsQm/S/v2AHAnbXYzT7TBWtd5RaI+Z8511KQSKXQsq+8glD7n2dZkFm1cFKZ1lhal4L5aTdyaLu/ZtDLxKOF6EFyEE9DKJpjHcaNgUb8fNJYWU+NxagxgWpVmu05yNwTL1VxCeOceA4oVLZSRS7tA7nmyt3ozyVI2jHA8ipaya2LAHbWI7v071n0hPQsm9Xnszjk6R4zSy4H8AKXN1bd83XWPeaeiNkyB8jfYkKQ2P1bKoSKKQhLqQjpZ/y5Tg5K68Fkiy+YuPoDRzUc0p3gGzuttV8NofWMPMU8E4CbqTZ3sayjtVKCqASANR6gpRxbbnzWAT1/P75DqEbo+4SWzdRCt9Nbdq8lqEuzMMh76KDk8ACo/OGdWqkJ4PmmLI3NzbGsjbyniZzglE8qygQCuEk3fCoMxgqPk8DQOnluba0HgNGa6pyMQZdHS0WgMhZFpgIY5/0rH0jmOKa2rcCRZ5xnaiboMuF6hD4LwNMDbCDmTOY9CFpTqxLbR+tnlVyfBnF2KzQS2JJfHOZSAElpcOV0XuhWlg916QecKBGx/bMCbCO4j4AhzpU275VjkwI3jkvXisr+pCeJXglm8EhBHgPi6AFhPEDrOUlbqOykEvYRh1YlUK1Vy+WcKx2yWFSekpPKuDGorcPZzRKTxsh/tWl5Q1p97JWIagbY3U5Sxah7z5RG071fSsu4WNGai+2pzxVEYr9vJ9thwWdyRqTzO10z4V7J31Kueio0nKSGitbnM/6WeqO6bb+YJ3Hme1zG5ene2P17aMMcH8+UOUD+FpNZm6ztnnqIoBiYbZ3plmlOU6AZF4GCfG7DNdoDJwI8gsdU6Dq+2mKtACtaPQdFFiycqSW0SgBbakEU3qQNFj8gKgfGumCh4jsTJEmfIATB8f2Zq3jb9rpI5+B4BCsxAZ5zGBQ6Aj7nxMptDBoXA/kAUQIIqBzERayVgvM1vfieaeYL3pPgJVMqBCByfFN6G++r4DOVwFMdrCgYxisZpCksFJnn48rBsj6qMfIptUpjsdzPgyueCkZZm2B9N1as5bTApMrdVmlaVr6qkQwFBCIEDWneb1r6+TMrLdJ6FzOWyHN6uQ6BkBFEk3IjAYdsP7/DQhDaW9arxop3wfqUYwlQMn5tpmAZiKkZqWimFt6dhJk7eFn38vTw59pMldtA7fFSB4CbHv4MnpTxTAMPax+cl1rGpbodueXxvswCw/7qZrtJ3eHOTQdcpgq+Sq7LtAoWZAWFXqbD+JNmAYiiJDx2g8pImsKJtxwz4HQmQPbrujFtpWYn4X6QvmNQtk0MdJ6l7El/XRyMX6wZV9so0S00tJ3Q2r6dzLqHc3ENX46kilvXyCOfx7kSKq7OUFhIU5rV5duB5hZA7nx2ucfd5VqQZ7WpDZDnCHmWzAHyi0wuJVp2yhWZLA4ps4wQQAXEwyeNNWlF/ttYmSr87g951flda5UEunj+rGsHslzqoXK5Yh2zaiiUtWlRLBgcxoOdPzOLADfLEHCVtLUxDhbOA+74d+vgAWjbAlh7QHWxPSk9OKikaNI3Eg73roUiUBZoaS6TA3M7N3RtJZemdQhgjTmLaTkhMKeVliCfQHBUNomHwQNRK/QBuoZzD0DkcAImjQntZY5fAtCtSRMoLKUxGPQy4Z96OgfLBRuv7ESwK+9OIFFbi41RHcoIA2Ih3yBdxsRgxdQSmQJNGf94EKcFRpwTAFxkOnBo04BBY0UxyDMVLKzsn1FlIpXF03YyrXzmBF/8JXGrC1c+Bl/G+ZU8j8C5Y4mb5S1K/8Z+b8054zCuTbDEO4doJU9AaZsj3c57TmCxNYmp/ZgJJHVPE5CnnHKA3Ow29zrkle6A5LTto8q0fuc1aTaNIlMhUDfXCoMsg3GRCtQ4UVQypZAr5eMPHFYnFUa1zMWtutkBIDOGw07173bCvYHKM1PNpe+RZowBqLzEa3aippEOdi0lVegudt1OGUFm7ZPcAy/3nLAuoVjMAMgOnQBuzDbg0AN2qVleUpoi13b67IuNTTe94eUA2u1u3VY2L/l231IyB8gvMrnYwglV1rYTFd2wqbVo2s3kEguHbWnIknjfBmulSQBQpsUiwyaEzA+qfRAEi95V3NQd4maRpuxqjBRjYNuZT9UBqG20uBFM1cYH5BmfhiwBLnQNczNMLT9lYpllmrudMrhbFy31BHE5rdCdTTYdK7GCxQAk5dPRlY1YcZXvDOMkS4nwMOOBxmeSr8l+IkAngCutwca4CYFbohAI6NM+pzLhVADITjie1opSkY5B462GtCiTpjMxBuPGYKEnQIYueo4F03GxvVUjlJhRZUIZcfi/j8rUgoyQzSLMc9+naQo78nKpDFEhCGA8AOD4LsZKVpd+rqfoA7SgOhd5x0Wm4tpUMu84XzPf55y75P1aF+kugTLRWS7d1UNlNATpubZFn+0vaxuy1Tgwa8n0wd6lHPGZ7K9xZYIVvjYulGpOudAprSDl1KblvCMHP16TKtVcmyzVze8ov46VQih3Piiy8N1MKQwKoSgxSwZd/rn2CpAPdt2qm0CboJJvO/2Rrhvj2hbLWdIOiIzgZ3PSiBfFzxXlr0kBcvD4JAGsO+2X19pK2FXGdrqORpZZkq5PStejcsltSvrIdH5G5zn++Arjkj47nJGddtFDM62YpgG80+9y8XM7/jwrmLX7jpR0r+hKl/IxD9SbljlAfpHJxeY4D7xUHE8QALH4RKQbSLW7yM0EYj5j3jPV5mnVEn6vSniVwv+dGHG9u+T5aYqxdOO60k29pc37w2pSS6AdgEApCNe3gKBDZU1oB9++bny1r9oGFzSb6RwCRYAbLPtmTNdyAkK3LWyA6N4GIq8zz7QAGGOkSJxDJyhMQD4PdeXd/NoDhLixSjtWBnmr/x18cBxkHLSKaf0E+EbKRWVsqCzGd8wzjcof8tJnKihQDJ6bGBMA7upWFYPbTCz2YaxkdTi9PvFubYOFQgDyxIMThxgIZXyQHuds48FZaSJvlVkoCNTS/NcETDxAY/7raP0lmHVOrIzaBxAyywTvRcC31M+xslCEwEX2PXNss19qa9HPNRzEwk5QxjEI9B8Xv8/5QMshh3Xq4Oz+6qSqX1xfsdDNpI5BlPwbebxp4RaXPCukQ7SptyOuI/bPVtkEqkb0yMR7kIPKZ9NLQSDEa9OUgq2l45WvNMNAunVQQQSA5UEeOMiZVqJ4WYfrlgrUVGKMRT/L0C90aMtWLdbw2jqMTaSJpOs19LmKHFYqC7OEfw4eKn/PUdmEMUn5/el9yMkeVtHjs1NQ4NXEx5cEfC8RwHKfmxUvwGd1/5qC1Mtpp0tAbTq/08emFItY1j5ecDHLa1CUbKr4xfXajbHpjuvF3oOxHdtJen96BS/GQZ7LbJkD5BeZXHyhYUfeKy0xtCgxc0HKzWQWivQw4oZFfmjIJ+tTodX+GuUtjLExHvglAJmHyqW8z8Uk/bqDAJ6JTzO3NqzExe0zDDjEthWZaqXPcnDeEiuHJyD5ewU4euDis3YQXMQ0UZFraX0HE4TulJ4ydal2N9Qqcdmvjepg9eb3gsVXybuQC0vLfARzNrwb29uYaFHOtGT4EA5xzPdMYEd+LdPg9XKNxoNzjh03ae3nUWUtrG/DxrhG43ndpYlp6Qj8tibiyq6sxca4hnMQ5cBFCoxx0Q1Pi651DqOmQZW4wRsjY1BaoTikjtBQRMLFAEemAUznYgrWtI5FYtrFRmyw/AIyX9h3pc/IwXuxzHGRawlWhQDimjQVZ7HgvRtsR+k58FxjqQW5a0Xsrp700G9MzD9NYMrsIKwcyfelApSClfAOXPspHchfz3HlnkFlgoCB4KRxNmRjmSRBsnXyzK5ynynVsiIb1y5QFAOvBExzv9q9WITv5ZkAZFqbOb9LY7CQZ1ge5IFaNa45r4UuwjWUPp99zrlOQLYdoEwt/5xX7H8GJgbc3bHyBa+L33e6aQC7sh2Y3Ansbkd7uJR9eaf37l4XzpDt7us6NAMbaQ47CfeD+Kz2emYftt6HtiIXx5H0ldQYwbZPvY8fw9R7wL01jHGnjekYz3z95M9pPMAs6VJHOLe60h3DOVyeljlAfpHJxdwkXS4x4BdGAlYd4sJnlod0gTGPcWWi1aP2q3BYmlaxgcwXZmhczIzQrSbnnFjNbGsz4c/PtCcQ2h/fHZ5f6QuWlMaDPIP1cS3ueW8N7uc60AUAcZfmWiFXGqURqzIrgfGa0m9cTDsGxPzPxv/rnJzWVBa2MyDPiqBmX1gnoItjNPTWJrEUC8gwzqHxG/ygyND3wWQcX0DGfXWrmgoQIThsXCz+Uttolc0zhdJKZL9YZYWXWVmDlUHuc9pKH5GLbFycR7QwOz9fjBML67gxwbIq1Aobx8hYXBjWAEQxYV+Q8sCiKATWjfWVD/29xn7ODhu6yW1rjuUe7BrLoDGLrBMYRZBrncxnhaj8GD//mbYuHbfKmmCBHZZMWZem2Yu85vBe1qFIgseUt9yz7DnnDQuv2OR77TnTHlzrgH6RBc8J21EZplNjlTj5PXCEE451uk4D0EYEtgRrjbMYGxNKnjOLTNr31kWre5FpOEdF0oV9g69AgK4S6y8twdyzuLeYzjynNZ5AWfn29z3dwgI4cWEs7dAalbVY7GXYvVh4rru33LsYPNvl9KdgKM2SQWC0nUg8QmyvdTFHNNdRal2mkP5DxSTdL2adA89kL90uj/Ml4ONWgPBOQtBKSsql3CtdM6l0AT3ndnqfNNNQVHpn9RcNPDEuhQV+pgq5hLFvx26knhrO0Ya/JM+5WJBt+tc0g80sHnUKwIO3ZsY9u8/ayVhzqXK1qBrPF7rHHCC/yORieTetm3brMzAPiJYX62IhDRbEoISI/cQSRpDI4JJ0w+FmQU5pbW3IM8qUSIziZxvTw+JKpJvKh258AQjGR9ULNxWQADPrxIrHgDS2MQ9R7dbnvrXhMJectm0XMy1vBEy0ZOQ+0E6hPRbpYUQLcTx04zsJ9cMGCyizTvRyLUCKbfCWkeVBjqV+HoLj0v5dG9dovJVVews5DwxjY2U7jt+4MoGr2VihPkwag8oKuNq9WITMBgACxcZYoVtYh5b1m7zQ0gMpptKbGBPc2pIVxWCrlHqOtY2WcOZcZgCYsdI3DjFlF8tcM6VYRS4rosu1X+g4Tv4AonJHJY6HH3Mr87BlIKCD0Bc4x+tGKCi0oFPBSF3JxgMDoYmknG2LfhHzjZNLm/tc1qkbOD3gOVe3E+dkTKk0kNtbe4txbW2wjE/qdho2zuvoVWkrECGIj3PPxTFIKRvpd7jXGGcxKHSwnlqXvBsQOLiUupHqiCGfcTI+6XpJlSCCnLVhFUD2Uj/DyM+rc6MSxjksZJlkUBnkWB/VMfe3ibz5uvMc9j3/dinV80K7bNsS6iBrZOJBMsGh6YwtlZOqsV75TArAdPa97t+m2zH9GfNOz/rsUgCMc5cOukhtmnXXdIzD9ds8vvt3rtfYpm6gq5/DYb7EPdkl3wlBtd77kWZFkefGc6JFlwnzL3pCuu/Jub7Te6XruzEJ5agzHwDvyfB/No5rw03dL8UKO1H9LkcuhS5yKfL8gMdzgPyik+20YYq1sVAGJV0bNmwULlhZQvlc007XRO6jddHqWDYRvFCcQ8g4wACy+Lw0aj/dTPx3n0knpO/b2VTJP01dyqUHV6R/kHNYZFqsk94CWuhoVb4wrFHWJhS/ANquMm6UaRATATQDskjZoMyyrIcDH9Ea65y/1p9ArFy32IvBRxwT3nPQy4Llm4ebArBWVgEkZVpBQYW+MenY+7FjlgDjgxlrD5Ir4/vRKx2sRsYiDClgoXXPARg1DTSUAFkWNvEcayl40njag8N6WfvcvFTgxDrrAIwbsUCnylrjD4GJMQE8T4yJtAuXBtypGBzoFQvml04PojiHxcqczhnSLvj9YdlIWXUP2OkyZ1Ac+4OHKafqpDYwTriyjXXYGNee+41QhIYSLFbJvOuCrXhtOxPKxGdSMTbO09pK7uk0vWEaFJRajAO48J+xGIpL5j/7Ki2pnSocbKtxLlAdIq0IbQs6vKLg53+6jzkAFu1gP1r4eX+uOc5h54B9y70Qg7BW1jAWWCpyVEaCFNdHdTgkU0DBOZMClLB3glZkFdq+nQSFFG3QRYUvzajT9Q4EiouxyDLdcqXPOgI4XrPEzgD1VIxmfeVyDRcXCx4MVs4ZlwUvQQf0z+rXdF3x927u7Pjc5NnJB/F58V+eTym/l4HcQASrPAP436zxmKlwuNlFd7oSg4Zjxpv03XkPl/zNzujUNMgewJQms1M7dsQX7vLnxvNZ5gD5RSThoN1hfpKDOP33+LncK27s/VwsOwxsq43k2hWrYNtqRYuH8tZWIHEtOVqcE76eX1Ahq8PUS10ZDzm+j2sFg1ATb5yAuVDNzEjWhI1xjb6Pbic1IfepuCor1fUmtcWoboTDC5+1wW/cQnGIldU4NkopLPbzKUWGgW8AWptcCizTQCPmOBYQINcXuQ6AS+5D63iDsc/owLK6zh+IYqGVa/NMIdMIQWoEBJOEV54GNzr/74QcZGuxMW48ZcL4PLKAg2zSHHNj4zk4biTFWe05zI2T+5TGCoXDcz3LxmHowTTBjnOeB+6ELjBqmgBgOfaS8cO0yjmXJgaJytxE6K9wyDhgUGjfXhfWAwNOa18WuvBBicxu4BwwNg0a56kndaTgCH3DoLQmzCe2gWMMAMNSPr9h9wDGSao0QAAg+d/GiXUefo6kB3UbFMef2T74OZNyockNrq1kc2gsM07E60RBi7EHgT9sUi50VHC5tiVgNBZ64SHKd6dVjwCt8fM0bT/3LJZLT4urpNK1IIciJX4fURCvReQga5S1gQawWdWojcNikaFqJIfzZtm0PCsaKnC4c+9+n362T/HoKU9ZRxHuCvtMqfieEz9n08I0qQJOqX1fiPU98SQkAx8tsO2CTunnNIikEgrczDhQLhUDpXER24EuFxfAzDOga9Hld3SHgw4g2WPYD22qQ7reua4JZim5p/vx1gS+7fmLVvVV/o3PStO68R6h7TPeMViGZ/ZQ8n42BoV3vUVmxhzZjqfdVbayTj/uBHJ3Oo8vhRd+KXIp3PVrIdcMIN96660h3VT631/6S38JgHTIPffcg5tuugkLCwt429vehm9+85ute5RliZ/4iZ/A/v37sbS0hHe/+904duxY65oLFy7grrvuwu7du7F7927cddddWFtbu1av+ZwKD6SLTS3dAciZN0+lUccEuYAUQxCQEiP7QzEET78gaEmrx6VAnIFUcaN3LXDQ5bq1N8NnvljSgzINBiG4a6xwZ4NV2TgM6wbD0oTgqGHdhEAkBnCNK4Nh3WBUx5zOvD8DOyLwiHlf2SdsQ2ph4MbThM/aG6BWsWgAN1OlVKCFpPdlYOSwabA+bnBhWKE0FoXWHlzL9ZtVE4BkL9fIlSgF5IwOJ00AbEyxNpw0aFwM/iAAYpU0Y32xkOTAdy5aftlWBaG09LSWg97Kd1l1r/Zu+kypUAKY84HPrfyzR3W0IKcZM5hBgq7RlDOejhmtpTa8l/BTnYs8Pq1U9DBYed5iP0va66k3vg8CnceJAkUww7YwOwXgU7lBCldwrm5NGhhHKkQEUsZKEByBG+cKPQldoNMK4PP3JdBtlbP2fZNn8T1LQ5693CMA6QRcVzb1KHFeksoj87CyqXIWwQMPVOMQFQHXdvmmVCRysAPXeBuAnCrsCoCzSZCwYblp4PxmGQrmbJY2WbMOFyYVtqoGRabDPM59wCsgoKKlgPNnJAGuanq/7UpqkZQiJjHFIZWaLtCjNE6UmKV+Hp6deuBazwFgzGwKjnXTlm7OjS4e2o4KMUt4T55Ns8R1L06ERXTaF8IHQk7P9ZRfDPj17ZB4JVzr2thfcez4b3rvNqh2YXxTAJx6m4ISz/v5H2atTa6LLmWCbUwt4DE94jbj4uIcYHu3s7SnayfPVGtMwzqaAYbTP00Fce4wzpcjl0pRerblmgHkr3zlKzh58mT474EHHoBSCn/9r/91AMCHP/xhfOQjH8G9996Lr3zlKzhw4ADe/va3Y3NzM9zjAx/4AD772c/id3/3d/HFL34RGxsbeNe73gVjYnL4973vfXjggQfwuc99Dp///OfxwAMP4K677rpWr/mcCjfmVmR1Z4LPUv5SLT/cy8VAhJDyLABkF/IcxxytMRUU75lncXfkNQG4uLYVKk2jM/VeV7DeUmsqD/R0kwtuYA/wauswagyGVRM2h3FjJDODFeuysRajWnLzjk07oX+dbF7tQ04sykUWAaNNNjNukLxP992di1xwsbiyn+U51gOMNHivNpISbVwZjHywWy8pS+2cw7iKHN5ersVt6GJg3eakaVWuqxrrc7TGNgpAdCFgjACSKeaUPxZSYEopjfUZHJi7uQ1UqXCkuWfZRxNf4ay2NlQ4Y+7lXMnWxnHgmDdO5qhGtN5am+aujnMSiGuqsS6UJA5KUmOw1M9DXmrydqmw8HvkqLOMNw/QQS8LB2bhC7YEGg2A8z6AMg36Yw7hxq89lRy5DBzrni18F/bppDbBCttdF42Nwav8TzwtibW5EUUg/J7Oc7TpBYDPLuFzY8cS4dEFTdA8SQLS8qxtdeXPeRbzStMb1H1Xcpgd/AGuhG/O8eV3tFJYH8uaybXCuBZe/1pZwzih9EyMQU9r5Aq+MIxC4TfGfhJE6Vybg9z4e7IYyaVwPJWS91NAmFNpIOcsACUKimn9rVvWnOIcgqI//dk0qI6FcbpnyGyQPcuQkVp/t7U8JgpzV7olzFtWTz1tmQ9z3bbHpVtcJu1Ll3wvfYcUpIVguwSAtyg+fjMJc7rzzO0sq7Lmk/O3C3pd9PalfcB9qnsvFxoT28V4H9NpT9fL4Drf636n2xd8ZleuAj5+3kh+rR50/fXXt37/5Cc/iV27duGv/bW/BuccPvrRj+Jnf/Zn8f3f//0AgE996lM4cOAAPvOZz+Duu+/G+vo6PvnJT+I3f/M38fa3vx0A8Fu/9Vt4+ctfji984Qt45zvfiYMHD+Lzn/88vvSlL+Etb3kLAOBjH/sY3vrWt+LRRx/Fa17zmmv1us+Z2M4aszYWiwBmb2IEXrMmdhog0a2UF8AbxFJEKxwtPqmFjG3LMxXd4P5juv56eR7al+57V7LeuICrxBoS3GXeukDahDbStlHdYLOqsTlpxCVrfMYGY0Iw1VbdSCCZt4Bys2HKsuhalnvn3j230MtagYwM3JBNug2Qu/tlngnVpZfH4K0QSJhJ7tRJY/wmKvcZN8ZnIxAA2s81zMRzb53DqLbYvRBBZOZ5dbUHmuKOjofI2DQ+z3PMkRz4cCYGUxn/bjzErItWnMjNVDDWhkINxsJbf33wmpV29rT2uZJ99gil0DhRXCpvPa4aeVcGkxW5WO8sEFIMsm9rG5U/HpZpJoHu4VNZCwWFfqYxbgycFqBNKk7jHHQCEisPqjjXGhvTGNbKZ2aAC2nKUotq6uocekWkrCPfNhQwMdK3WThcIzBsH9wdTrJXZCtjUTiB11RkxYMi9CGZCy4oXFSOWPFs4lOeMQiS6dzg56xYpFzMoe09H84rAbRgGedCyr+yjjQMKmtKRXCsIHQvvueoihxqQCy6xvnqjl4ZoDfBuVTJ8MGymcLmWKz0vSwLwa5rVQXrhHLRzzPs6fUC/aifCUiuGodBls8EWezLhZ5GYxAywWwnDIYGYnpJ62S/Kfw8IvDqAkTjHJwFNsd1+DsVrFT4ty7fNs6L6X228Zb1rmxH47NOglTje0Xreap0zvoeMNvS3g06p1GGHsq0fbMKW/Gdp+Ni0riIuN75N4WuBdm1/7UuzIP491jsp2t5Z/8qpdpnm4tGpu3OORqWeL3MB+et6Kp13ZRF3TFbkvJxJjFlZBf8pl2UnkXFjHsC23Cm1ZyDfMXinMMnP/lJ/MAP/AAWFxdx6NAhnDp1Cu94xzvCNQsLC/iu7/oufPnLXwYA3H///ajrunXNLbfcgjvuuCNcc99992F5eTmAYwC48847sbS0FK6ZJR//+Mfxpje9CW9605tw6tRJrJ4/hzOnT+LkieNYW7uAw4eexHg8xmOPPAxrLR76+gPbvFj7HU+eOI6qqlDXNY4eeRrD4RaeeOwRNE2Dhx/6OgDgwa/e3/r3kYcfQlWWOPTk49jc2MDxY0dw7uwZnDt7BsePHcHmxgYOPfk4qrLEIw8/BAD4+gN/AgD4xtfvh7UOk9EQzjk88dgj2NzaxLEjT4d32lo9jfPnzrfeKVcOhx+Tex06KO0687S865EnH8F4NMLmuaPYWLuAkyeOY7h+Fs14HZvnjmM43MLWmacBa3Dq0EGp3nb2SWQKOP7ENwAAx556BLA17IXjaCZDrFQX0AwvwJoGpqlQj7dw+tgh2KbCwYflO0/6djz6za9CAfjmQ19D0zR44rFHYIzBZDK5pHFyAL7+1T9BbRxOHZK/b54+BFNNMF49DlVuAVvnMV4/h+HmBSyOz2M8GmN87gi2RiWy1cOojMXK2mGMG4Pe+UPiPj97CJNyArV2EqYcYrJ2CqP1VZSbF3Du1HGgGqFePY6ynGDr1BPQSmF44lHsWSzw0Nfuh3PA4ce+iapuMB6PYIzB2RNHsXr+HM6dOYXzZ06iGm1g48xRjMdjbJ5+CkUGHHrkQSz0MuzdPAIAmIyHYtE+fQhbwxHG548Dky0slhewx22iHq1j/exxbI22kK8fx0IO6GYiG/O5pzBpLJYvPI3GOhx76hE4U2F47gjK0SbsxhmsrZ7F5oVzwOZZ6HqMybljGI8nyFaPCPg5/TiMA3avHUZtHU4/fRCwBvn6CYxHQ4xWT6AerWNQriMfraLfjLBrcg7KOai6RG0szj79MKwD9qwfFurGmSfgrMWN1WnopkK+eRr9ZoTe+AImG+dQlFvYVZ5HNRkiWz+Bum7wsuYkqsZh7ehBAEBz6glkSmH/+ARcU2H99GHYcohidB7FZAPN8AKUqQFrsXX2CEaTEqcPPyrr9slvtNbk8OTjMKbB+Nxh2GqE8sIpqPEm6q3zOHzkKDDZgls/hfFkjNUTTwjV4MwTcM7h/OGHBZSeegKNtRidOQRXlyhXT+DkmXPQw/NQows4feYs8uE5oJ7g7LEnAWtw7sgjsM5h9ejDogiceETyd594ApOyxPDsEbhqiOHqSQzXz2H1/FmsnTmO8XAr7BHVZCRr4IE/gVYK555+GMY6bJ18HFXT4MLJQyjHQ2ycPY5yuIZsvIZVP/cmqydQVxOsn3wKtbE4/sQ30BiLtWMHUTbye2UMqnNPYzwaYXT+GKxt4EyN0fo5uPEG9OZZoJ6gXj2Cuq4xOvU4tFJYO3YQjbMYnnhEvASrhzGZTLB+6jDK0SZWTx9HubUKjNYxvnAK5WgLw3NHUKgGx56S7zzy0FdRG4sHv3a/eENOPQFjGjz95GMYjYY4feIoNtZW0dQVTF1hMlzH1rljKMsxTh1+HEUGnD38sATgnnsKpbG4A6ewMalx/eQURuMx1PppLJgRVuo17Dab2IURlifnUdgK2fpxNKbB1tYWnHM4/NiDKGuDJx7+GowDnn78YTR1teNefvipJ1BXJVaPPQYAeOrg10XxPPukFOI5+QSausaJpx+XcTp3AnVdo6pKbK6ehhlvol47gfPrWzh79AnAWjz6za8DDnjwazJ/H/r6A6gbg2NPPYrJeIxjhw9hze/lVVWirmscP3oYw63N1vnUGIcTnbXwyMMPoSxLHD/8ZOudzp45jROd8+npxw+2vnvwITk3H37o62EvHw63cPbkEUy21rCxegZnTp1o7eWHHn8E1lqMR1sAgG8+KPc4/NiD0Ap48rGDGI/HOHzoSVxYXcXZ0ydx5vRJrF1YxZGnD2Ey2sLZY0+iqeOZy/V95ulvAs7h8BMHUVcyTuPRJo4fOyJrafUsjh45jMlwE6snD6MqS5x6+lEopXD08QdRZDr0z5OPfANN0+DYocfRlCOcOn4EG2vnsXr2NE6eOI7x1jrOnzyMyWSME08/BsBha2sT1gFPPvw1OABPPPx1OGvx2CMPh3dav3ABZ06dwLmzp7B6/hxOnziKajLChZOHYJoGjz78YOhjax0e+cZXAaUwGY9grcW540/DlrJHnDt3Nsy90dYG1k4dbuGIb/i+ffCr98M6GaeqqsM4HfU44tyZ0zh69CjWLlzA0cNPtc7cR7/xNdjO3LOdd+LcO3NasNYsbKSeATZqGjlL03fq3iOde5ciyj0HbOg//MM/xDvf+U589atfxRve8AZ8+ctfxp133onDhw/jZS97Wbjub/2tv4Xjx4/jD/7gD/CZz3wGP/iDP4i6rluujz//5/88XvWqV+FjH/sY/uE//If4jd/4DTz11FOt591+++344R/+Yfy9v/f3Ltq2N77xTfiv/+1PLuk9+kVHX8uy+PPyMspza+h999sAANV/+ONLuuczkbI26BcZrHU4cn6EW4d/Bb1co7r58xiWTSu7waMnNvGy/YuBXwtIHt2tSYO9Sz1slQ02xhLUtXuxwGIvw1I/wzeObmCxn+H2A0v4yqELOD8pcevuJXzbLbtx/6ELODue4OaVRWyWDTZrsWb8+VcfQJ5pnFqb4KGT67DO4Ttv24fffuAoXrl3EX+u9wNQAB7pfRa7Fgoc2NVHnimcXJtgeZDjuqUeRmUTrEm0MPSOfa/06c2fv2jfnN8ssTTIsbpVYWvS+DRbDrsWcpwdljg5nCDXCitFjn6W4cEzG6iMw0tWCrxyzwrOT0qcG5fYLG2gRxRaYamXYeij4ReKDHv7Pbz6wAoOnt7AvkEPZ8clamuxb9BHbS32DHpYLyu89VXX4+j5ES4Ma9ywu4/dCwUWT/4FWAcc3/X7eOneBZzfqjDINZ48M0SRKdzx0l144NAFvGz/InKt0C8yfPIrh/FD+9+PfUt9/LvNT2G5yHHjrgEePL2GylicHtZ4erXEG29ewh3X7cJGVePY1gjveNWNsEfeAQ3gP1S/hYNnxnj9DYvYO+jhhqUBJrUNwYinRxPcsrKIfqHx6PlN1NZiMc9w88oiHruwiX6W4YaFAQ5tbGHUGExqh+//tpvwya8cwe17B/gfbtiDpX6OYxfGeOjcOpZ6GdbHDXYv5Pi+pb+JXCn83von8Zab9+Nrpy5gddzgppU+Cq2wVRs8cW6MV+5fwCt2L+MPnjyLpb7Gq/cuwcHhkXMj7FmQYLKNicGJjRq37u3j2/avoDQGL11ZwOGNEQ6tjbFvMcfr9+1GrhX++8lVTGqLt75sP142/MtwAB7v/Z/Yv9JHY4TvuzzI0RiHV964jAePrOP8uEShNW5YGeDo2ggODkc3x+jnGm84sAffOLuOXCtcvzCAdQ7HtkbYv9DHK/YuY1wZPHRuHa/YvSwWySzDVl3jun4fN+0Z4OHTG6itxct3LeHg6gZuWV7ELXsXcf/xVdy4uICTozH29nvItEJfZ7huqcDI8+OVAkalCVzvfcs9bE4avOKG5TD/3aG3QymFyUs/h0wpPHpyE3uWenji7BaKTCxXu/oFernGxqTGg2fXcce+FYxqg8Uiw8nhBK/du4IzwxIHlvrYqiSP9MuuW0RZW5zYHKMyFvsX+tioatyZvU+syjd/Hl8/to5+pvHY2iauX+jjNftXcHarxEKeYdJIQKaGQuMsVicV7ti/SyoxNhavvWkFh84McXx9jJVejl0LBbYmDV5/8y4cOjuEVgr9QvaFXQs51scNTl4YY2wMbt6zGFLGlY3FqyZ/FVuTBl9V/zsypbBR1Xj1gRUs9zM8cHQNjbPY2+/j3zx2BsPK4BX7BsHLcMNyD99xYA8eOLWKtbHB/qUCjbUYVhZ/9pZ9ODcq8bb+D8A6h+O7fh+7F4uQIWT/Sh8b4xrXLfW23Z8aI7m+j54fYXmQ4/qVPp48M8Sh9S0MsgyLRYabdi1goZdhayJVK/+0eg8A4PR1/wZfObKKxjq8Zv8KMq2wZ7HwXhuF5UF0EI/KJlTlWx7k6BdZay9d3f9vUWQq/B0ADh7fQC/XuHnvQuvvDPrdt9IPf6MHhFlvAPGALPk20Iu1NJh2Wp9am4T+0gpY7Mdrzm6UuH5XH8XRd6I2DsOX/Hss9XOc3yyxd7knFAIGNtYGw0mDfSt9XBhWWBnIvBiVDfYsFlhZKHBsdQxrHW66boDHTm7hwO4+lFIYVwY3713A02eHuPX6pfCeWitcGNbYHNd49UtW8PTZIcaVwWI/x+6FHGujGrdev4S1YYVBkWFUGRw5N8JN1w3QWKmmuXuxwKMnNpFnCi+9bgHDssG+898na+6Gfwdj5Nx+2b5FAGj1EYuCZFohzzRGZYOHjm1gochwy74F7EmK3pzdKLFvuYe1UY1959+FItN4rP9ZrI9qLPZz3HTdIHDV10c1Dp8b4fU374qBoZXBwOOCjXGNXQsF1kc1di+2bcib4zqcx42xWFmInzdGijvt2WHOX4owKP1y5HJwAQDc+eY34f77d8Z6z4kF+ROf+AT+zJ/5M3jDG97Q+nu3Qy6lk7rXzLr+mXT2C0noKqELMxVrp9+9nfbGYaHIQtCKQkxpQz5j5PPFVFDG9yl5g0wPBgC50siUCpulA7zrXqL+5bm+AUoFN33hs2WkbqiUe/VMhC7zNDUW7+tcTOlD3iwAjGqDYW0xrBsUWge6wiRJd1WbmGmh9oF+C4WGcRajxnjOqQt9JZHvwisl3zpQERB5yC3aRWcwl/o5HBBK44Jj5TNESEYJ0wo8YYYB4U63+ZlCG4kFKSoPWtJ51M2VmXIYC618iWThuZGTyv41VvILC39VNhullKTLA0tYy0HEcWYgn/au9VwrLPWzEBQolBZJB8Y8vUybJjQSaf9iP0ehFXTSj3R1W+dd2aB7dXqdOMR1Qh5ontBFrAPGPg+2g1BCSmN8SenOHHQuZN+I8w9BGdEetAGRHpFr7avaeX6zz+yQBqH1ci1UBpdyKDElpHAUuQ59S1dwaUyYK9pnYpF82b7N1gZXPvuX1CGumZSXzdXK9bboAx1J0eA78vmSmg2B+5562TMtc4XjolRKlYoVFxn8m9JQ+Mw07VdlTeBD8zGjpoGCgGz27aSRdx5VPkVioVFojSJT6GU6cOuZhi911zMoiu9yMe6xc52CFYDP/CL7B6+xLlIxSCVgdqE0g0g65q3nIKGqbEObmBXwyP24K13P+iw7W/drO1EIMq1a1KC0DWwz93L+rhKjCdCmiZCS0r0lzzmeOdbfNM0SwnXvPA2BtBGmKuSYtp7deU/mH07fUcZQvqdmfHEWxYTYJQ1STed1d8/SWk29czbjb7x3yuFvvYOL7e6KdTFzUnce5JmeKjx1ufJ8wmvXHCCfOXMGv//7v48f/uEfDn+78cYbAQCnTp2auvaGG24I1xhjcO7cuR2vOXPmTIds7nD27NlwzYtRpjYRxA1raiNDm3uUauDM68iN0brIxWIwGzm4cr3nDYJgx/nUXhI8NK6SoBv/jLiw4715oHDxK7QXfjeA4HJEAJBrbfaStMMFblemlAdgYjWa1C5kRci1CinKar8hZFrAZdUwc4d8tmuhCJH/LJBBrjbTnW2O6ySPrAuRx2wrgXs6Rimn0FiHI+dG4doAjOC5oaZdIY6KTOVTm22Mm3CgMy0QOdQsF50e6lQaFIDc9xPvP8gy9H0qtF6mWinJtIqHOkGNROlLcBNTwFknfO6UE+z8fNIeTK8sFKEPKx9oCAClYZGJds7dTClct1Sgp7PQDq1i2jZAKjemJzjHHkCITo8FMWIGDAUVMoBItb8IMAkejZOsFS1+IGKqOAWFXClf4EGUya1K+q3QGnUjnPXAA3RyX6YXI0jv5Rq9XIPZY7p5eaXtCIGI7N88CS6bmAisRKmLhVisz0Ah+cCTbBXWhiAkKg+Nz4sND+4mtYFWCJZuKmDwY8v+0Ihrnn3PccgzCXBLP9uaNC0+LtdQGjDMLDAEnOyHULDFv/D6uMG4EZ7v/pU+LPx8bRxyJUBZKxUUmSKLnG+tEPJkt/rbTReR2Emsc6EsN7mlNBCk/GamYUvTPy70sqAcd9NrTj3aeWDX4cByTthkvlO2y4DgMBs4deVSi09Yv/czkwuFmVK6Bh2593SGhTSOJt1HUiE4TrnRlImPQ4iVCf288vtNquBRuU7fAckexrmZ7sU27IEqXJtmuuiC2HCuI57RNGYY1+Ybp5k4UgOTS/q2K9ZJVpP0HmlfAm1ed3od19Ksc/n5UgXvasg1B8j/4l/8C/T7fbz3ve8Nf7vttttw44034o/+6I/C3yaTCb74xS8GPvEb3/hGFEXRuubYsWM4ePBguOY7v/M7sbW1hfvuuy9cc99992E4HLZ4yS8mmQ4GaG+qs6JQZ2p4ftNwLkZBB+3VW5DSGvOAbDRS9laFnKCZB0FKiZsG8Id5UnBCe5BA6W6MV1N55KHBfqBVhwoAq+M1SYYF5n5lcFY3Cjjmoo1Ak9X1Gv9zoZktwoVgJeckB2sKiFvKSvJvutnTGseqbOuj2lv44nXG0sLf1r7Z32KNhA9gis9qjMMgy2A8MGJ6Np1s4Nxce74UMGUxzwNVp+cLFUxqG8Ctcz7vrxHLXZFpoYhkDMCSPhnVac5kkVyJtbanIwik0jHIshBkItkJ2haPTGlct9QLAU8MUl3s50k2hNRLAT83aKn0Skpi6QdEGdThWgHodVLRMM2+QQt4sIz7+aKhAiWiMULbybXC2Jhw30ltwnrhXGPp6RQACGjTwYpKC/PMyPNkzoVCNVCoTCyaoRCDCjmvGhvLjRvrs1m4aIGOwTxoHdosh71nsQgZQ+g5Sde38opj2veU3M8XlfSlrB8+kwoSA4BjOymO+xZi5hwGLjHryyDXuDCsQv8z37SUnZZn5lqHtG4MpiyTFI+pXCytWyrsl1Ay3LaDXzlLaX3kvkwgbf1aZsVPPn8WftUqzstWG1wMmkyFCm73bThPuvfYqQBVgh+nxFpR2rSSC1MvHT0F4SHh3jOUQTdtGKJhhvOqDY7bBiSmSeR+y/HgPWhtZYaVVgaVDmBNU67x/TnvshTAIrZ5KqezjSkTKVqroBSl16eBkzG1pgu/6xnjSKUoxQz8HvuFymgqDnHtzYISOylPLzRAfc2yWADSOb/xG7+B9773vVhZWQl/V0rhAx/4AH7xF38Rr33ta/HqV78av/ALv4Dl5WW8733vAwDs3r0b73//+/GhD30IBw4cwL59+/DBD34Q3/Ed34Hv+Z7vAQDccccd+N7v/V7cfffd+MQnPgHnHO6++268613vetFmsJiV+kcBgIsJ/LtysapGrKoGIBzmBIJA/DfPpPqYVgiW1p7WUEbA0bCMldv6np/Ninth40In6h50n8U2XZHLxQM8bk6yQcZ+IxCpjBxGmVY+Kl9czU0RrSjGivU4VwpjD0qVivSM81tSlY5V92hJZL/S0tP3lJZZVhv2STquPDBYDnu9rMPh5RxzzjpP+5i2wOeZ5BlWChg2YoHT4SCRaOxRI67uyqfjoiWP9BClFBbyDFt1E8ZrUMT8sIt5DmMnKGuhlxRa+nVcGUw87aDwIIOWXQqj9Tk+TBOWa4VBroNS0ctVSEfH8ZgabshcXBtW6PvncL7tW+5BQwXrX7BMerCeJXOS/UnJtOTDpndEKUhWDRsPoca5qYT78GNBKzdTs3GeFVqjVg5lY4L1b1JbDLJM6C6gy1aAaumVCefHX4rZxFR/1okitSvhBSIBDnIgCyjNtaQLjId3jKZnFhams3JOgGM3PRTzVDOzNsFH49fT/pV+WD+kv7TmppL2Ewjr5PMiU2HuUdEhlUCpaN3iv0GpC9by2Pfy/FjExzlgs6wxri2WihznPUDOvKIvGT2cn/N1yKjhEPcBZqNRyZzlfEo9Iq352dnLaIUPVSS9lZHjTjBF62OwOCYKLBCVM77D9CT0e5+bQWWEpwRY2Z96gYrkMOtWnENsv/YGju59p3+fvhefw/OA4IvrQwCrTe5BoDsDuLlojeWHeaaC8s3vtd/DAUoHRdS5aLHmvrvUz8Lv3EsEILvWvVrjmqyn2DY/PxIAy/U2i0po7HRWCr7aDhg03h/x/O5m/ACiB5FnDT9Ni8OkFu74bu1MS12h1T/lo+8k3Vs8X+gVwDUGyH/8x3+Mxx9/HL/927899dnP/MzPYDwe48d+7Mdw4cIFvPnNb8Yf/uEftoD0r/zKryDPc7znPe/BeDzGd3/3d+PTn/40siQ47nd+53fwkz/5kyHbxbvf/W786q/+6rP/cs+RtIp7dGZr17ocvrPD6kpzrAJpHksH56JbXHKC6rBp9Hz6mDxTQO2tqp6fbJ3w5QDvLiKA8vfOs5i2TKFtaRBtVqG4DF9Hegg5xENPK8/RcpEq0tNZONxzHatkkT8s4C22iFZJbio5AbUPTrBekeiHvolj4SDWkH4hr870V6nmDiSHv+9/HvBlI8rIVl17ykFiQXAxF69SyvN9Y7q9xtpQ0plC9zZd0gCCRZFAEBBXvgKwlOc4izJsfP0icqGXez4YxytMhQc2k9qibCQ9Xk8LZ7bIxIoTcoo6h0VvLSTApCdiIcsx8YUyFgvtXf4pwEotwH6MtMbmpAkp5nIVc3LzwOAdFOeEQuu+1onSFPpKKYxqg34uli4N5UGpC+01ziGnJZRsXJdY+hHBU55plE2DntYotUFlHPq5tHfUNFgucmzVMe0eFZmyZvtiUBTHnrzASW2xayE0PdAs2J5Jbfx6EM+JHNSRFxwUBO91SDmZAsLbwCCVNKd6phQujOqwlzTOovD5qTOl4FQ8zKlQpdLLYqo3WlXTAjmBguDaXNkusKNCYL3iStf5RlWjNA4rCzlOnhv7dsj4TLx7f6UosFnXgYdKRTdX2ueDj6kWOQ+VaKiBCpOKsS7mh0f0IpFPXRsXKvDB77MpaGSfK+758HEjLpaELjKFcec7Cghrrgs/nEdcBKNBAXUxTWNXUuWdefK7ko6B7PuzgY9z0QhDhYf3pjUzpVYACKD8YtIvstifmPZWOp4LQeGK4M94TSDnnu/kPejRSotb8fWpAMrvbXDJn1MlMez5mD6Xec52ASPXoJqa4wjvqKjNIVrN0+v99Aprp04KsrCSaPpeLeE+oabXf2zfjA/w/AK/lyLXFCD/uT/352YuJEA67p577sE999yz7fcHgwHuvfde3Hvvvdtes3fv3pkA/MUqxm9uXW2Th+qsGd6dvOPKhOtozVhQWbDaAH4jRxroozAoNMY+R2s/06Eam7TLhrLE1gGLXgvnhruQZ2GT73krIQOluHjT91Dq0hEyLUz8OVQ8St6H7rt+poP1jRxZHqCVcRgbg8IH5ijlMPCuQPZhL4sW560q5l8lV6zQOgBj5+ALJkT+cLCOJBsHD38eUJSqES7kqInueL4jfM5aYyUXKTfJTMuBSatXba1XCPiuYhnl/VjohG5EDeWziEjgm9pEUHZ6uQ5WlN39IigHWikMMrHejiuDsQcbuRburYZYYUoPKhorljrlgTXBRubBPfNKr/QKnB6WoT0WtBBF4AsIx3lcmbAeci33GZZNsKaQLwsXXZBFYjmz1rWCcgqtsWZqH9wndzY2zoN+prFZNdA+Xy55y+Re81Cj4kELWJ6LQlkai75fW5PG4PqlfihgkSowxjpoD7AaK7l2CWYZRFrWUhlSKSADpg7pcSWBnLlSgVdPRYnrwDihGlmHEEuQWsfTvKxaa7RLliDcZ2NUi7Kj2m5/4f7DBylGChYP7bKWiHqCL+4bDARMq5jxtqlnjPuI9LOgB+PEY0TKyrCWzA6L/RwbVYPMK0mF1hhWEgC6a1Dg3KRET0d6i5SjZj5323on3VHA2CJa1FKLYsjFbmPhpdorwVzbVJb5s/OIOMwHr4h0A7ciJzUaOnKtYHQ3sC32YWoZlDGMQdXp9emxwjy5lwJWt6OeUKEhPSmtTMq5yWYR5NPT1BXnJGNGfHPZD9N5lCqL7BsqIumz0oqBnEdKAYu9DGNfKAdgUGg8f/224j25VOIAgDEsSf+jHYfTjp9i7EL6Nn5vQfu8Vyp6HvPk/uT780xo9RViDv7KWCxkWfBiIBmDrqT7WnfkGZtwObSJ5zNkfk6yWMzl6klaLjMEeCTAabYC2P4rNxSAljMbFhwXFcPEBkXmLWHwwVOyuRUetAyKSKWYGBM2j/0+JVCuZaMmyAIi4KKFtN3Y9sF3KcF66RW0tPFrtCZPPC+2u2mk1uLaV2+LlbSAxUJ0Sm4QvSwL7rZRsJgjZK0YZBkKrVF6y2zjbDhImWUCaG8SSQHCYG2iJc9YeQ7BVtoflZXCJbnWQgXR8j7G+mArHSOM0z7arJtwPwbUpR4EKj1MF0iXY1oGlRYg+RnoZ5lYSX1RCcGjKlBxyJPkOyxkeaBfyHHgq5ZldH0CK0UBYyPXlHzmQmuvpMXCF6llvtAagyLD5rhB7pUGUgB4nzyLc5LUJAnKi8+RssvRlU6vgHNCIaKFMhTvsK51YDlEDqj1Shx5xdSTrHWYGIs9Sz30tEamdHgeXc48xFkshJkZyIltfIaJNHOLQrSQTbziKp6QSM9gQGahhWteMYtG3S4bHik43iqnVAC6qUUsU5LlpltJzjnnx0F5LrgoVLJ25PulzyRBZZJV6axXnorgEYj3bWdcQbC+Od8g66RQj/SRxbCWQjNnN0qMPXWl0DLnhpUBneLk5ZNjzVLVLbqJi9zhuL5jf6Slj+Xf8DU458IY0gOUqhtplouukNohylq0Kjq0wa7WklVoGiRFykTKPQW8J6zQrT4mOEoVtpT/mko30DrvPLvbjhSY8lkxyE3+ZcEdzovu8xwi9YFNyrxRQ6z37T5QKnqR4jsmAN22C/VkWoU+YXsrwwDJCHZbD0ja0gWO3AP5jq712ex+5d9mWWNpCQ7KAdesVi3KQ1Dg/L0a471VzrUUA7YDnd+l3dPgloanSwniDG15HiPkOUB+gUt7o40Uhe4CkJ/d1N+AePDymlDGNtmEnGtP5EzpEKCV+UMl0ypkCmD537F35zInJzck5rp0iCm3asPDoW3ZSNt7KYppd0GnQEHctFbK8oKV1Wxoc2olq41ENPezLLzjUp4LSPHv0vfUgNorBHw+793PNfpZFp7hXLRYWhctYqnE6nNtCw7BEV3/dHHR4pJaAAkoCq1DGeVBnsW+Sbpoq4wWwsq0yxjnncMkUwp7lnqwjqWN5TO6G/ncQS5psUrPiyZ/Ndc6BL84CJgGZA7QkkiLUpHJpm6tBOPl3goUN39Rrnq5jM3A58VNKw0Ccs9+oTGpjU8dpgK/mEpgpqMiQEBOigxzT5dG0vkR5PM663y7AQ/Yo8W4IWjW0WoIRH6h0F8i548enH3LvnqbipkcSm+1InAI/GBEcMV0fwQuMUVapCQwtyo9JeS/co72k4BawANE+PR8/lDME34wlV4FFfcgxUBEeX8GXfLoZgq3PBPuOa3nNF6l7mtAQA7XVaZjvt7U0ppSmjiu4XP/XKZzM9ZhWElWjvOj0qd2k/ca5ArjSpSGC5MKxkZPWK51YuEUN3zqBeL+Jp/HfZV7UMTTLswDXivp86i8RItg7SuUNr4aIfdHKQdPi2Vb0WZf8lnsh3R/M9aFfYAWzBZ9xiGkAI1/i6koaW2sk8w5qYS2+Lm+vQXZP9vGPT/lkXOvBGh4iNX0us9LOcQU7mGkt3SVhMwra1O2Gd8fTPsnZ6AP+PZ9oJSn/bjotWspBkm/0WPQDXzkedA960Rp2B4kp/cgFSnETXgQkFJsZt2Dn7XogC6dp9Pf497GtZsKlaVLh8fPb9rFHCC/CIQHUpeXlLrigDZtIZU0Ato5sXJGF33MAJFurilnkBalzLvv5MCWvKNMTn9usxQrlddU9ywWLTckD7hgsU429/amfTlLL1rE+W5aC2hjeq6JMRg3BpmS0sXRBS6b2aS2AewVWuG6QS8Ai0IrLOaZpDjzAKNrWSlyjb6nIoTDW/FAipt5Om4MILMQi5dzMUAqtQCy8xjtzuAjWu8KrTDIM4w8sFou8vRrkPyzwKiObWAaL1o1yLEGxNVO2gMQMxUACHl8aW3PM43C01dYjlUoJyoAMvjf0wA5HmYE+ZIdRQ6jrbpG48GT9iC8n2kMclFSFosstC+dzwt5FvirhRaLM62AfO8i08EF3ngrSPAS6AyLvQyVsSEtGDNniAU5zs3FPEemYzYFYwkQtX8vuZaBsAu9DJUVJVL5PqqNxdqwCkoZrdJVY1HaCJIbT8HgQU4ea1rGOX1HCtcDKRS1lfzXBMikOxAIVlbGvQgBTwJQmQmEfcqxgorWSq4TAdfRu5UGggI+ZZmLuYC7AJlFTegmX/LKecuCbKJlXNowAwx56pNzksfaWGC1rFB6a3yRKU/5ErrU2XGJysTsPf2Ma1kKnKSZghRihhwgBjs1xrZSO6aSZl0wNvUoST9zr+JcSi3xwzKWfO9ui9w36TWIWULiNamlkNbX1ABhnQs0l3jfmAWJ726M2xEQTZ1LHQltTQw4BHoOCU0GUdHjWdPqRwK8jtGBCrN1ooilmS3ocWVsyXTbfCGunNx52QcJIrWKaQVJSaQSme5rCO8xfYYFOtuM53etudInCbLlvXWMjeFHVGQdD9iO8Bzqnr0XO2M5TizglUoILr/EY/r5nMECmAPkF7xEWoUKQV1pSptUHKKWnX7f2mRzAlpBekA8eCTCXqyN/UyHnLdyH4TIYwUJ/qlt5HGuDWs4IFjx9i73wgKvvVsxRMYirq/0Z2C2RrudMMiDlhdutmIJlHaNG+PzHWtf4EMlm4ZwcvuZAK9BobHUz4KLKdMKy0WBXpYFFyfbTFqDtQ6L/SxYp2mVD5lBOhsE0wqRgrBrIY/5eHnwJgelQ4eH6A/MTMt/ix4gNw7YO+ghTffDLBsE3GwPOcAOvoiIH3/mg5VrXXAHA5KqTSkf0KeiRZap4xgQWIQCGNIGSZ/Vtlg4EHQJyKE1bL2swSAzABjkGstFjkEh9IjlIgeDR9NArYUsR+l50Jn/PIAp3xsp5YcgjVaVQa4x6GWS2cTYAJIAWhFJe2FRCRU5yM4FDwQQAVTtAdnKQh6qtqlkDDfGjU99JcUpcq/YMSCUAD5PrL2Scq4NNFJAGqgaVsaNgJgBq+wzgvlg9bKRaiOKl8ZCoVu/S4ClDmu1l+vA9+zpDD1PhWHukMgFlzFY6uet9VA11uellXYwMIrf5cGf7nC1H18tm1xIK0iwAACrW1W0DHrO9mbZoDEugJteFtNXrk1q4fb7Nb+QZ4EOwyBNLmHlHxQpMDZYw7tufwqBFffdlCaiIMrJpLFhzHXyMgLUmG4rAkjOS76nQ7Tepvsn+1OAPabEuhmUAEyfH01iiZ4ll7JnO9cG541XYKkQda/tgs/aSBvCfZKzr594aZRf/xSuO1GQZwBkf++Bz+etlPKKVQSuaR9xzdLSnyX9ziwkvC/HihbkEMyaWMDpLZpul5s637Vqp3BVyV64nX5CIB/mQqLgzRLS/HhNd95w3l3qMf38hsdzgPyiEAFEggDDmlGYsbFMa/LcRLuWA38L/7v8m+lY/KOfaYyqmKVCcrrqEBxEbiM3fOYvrRoLDdHKeX9yj9M2pHSQywHFqdBqQFcz+XqVNYHOURqDkecZD+sGxtqQk1Pch94C6DmqbKNk5hCr5aBTMCBYViwwrg1WBrkHsdq7oV3rIKNQSSgCuBAAxINWrkncYX7zNK4dmKGggttwMc+lgpgVHnjmT3HnoiJUeV4tE9CnClKR65BnduKtp+Ssl9YEawkVjl4CNJlvl+11iDxovrZYiWP/lZ73K7SENl9woxQQSkC/UGRYKvJgxd/dLwTkeGBGAFZ4wOP883qe5qGks8SyVLQBMseGQJ8gpzIWeaZaik1jHYaN5JfuF1mgKNAyRp50ClTopVnq5wGw8lWNVwIyLePY1xkypT1Qsz4XsWu10wGhWEdqpeLzlEKIZOeBGQByYr1LuZbyr4xbpiW+IFPyLsuDPFiQaB0OvGCIokBw2su0/EeKhlIhcwj5pCuegkV3fGNcsJBynoSMOUz9h0hFkH6IhYocYpo4tklByh+TGlMayWE9qm1r/WpFLwWwWRpMGheAKKs4At4CjwhCCdiDYu7HJ2So6FS7i9Zd+Z1UGYpSEhPAAjTWgyz48U6pMtYh7HG89yweaPqX1jxRUZFIU3xxj4/f6ZwVtp0FZ7tnbZfBgn2gVPt8SrOCcDx3ei96fWx4n+TZOmY/4e8MhkxTCpIeRgltMRa70mJFjQ1jTOWGfcYMPQTJpIVxP+oqAgTdvBaYfQ7Okm6PSuaK9vVp/EMqDnJOkO7Bc3KWopRKoHj532dW/9um3Zfr/X0+yBwgvwgkBREpl2qnoAiKSTZUQBYdk9Z3NWRJMxWBEHOyGivAt8i15EVGzPtKt+DYl0BmkNPqsA6Lk9Y0Lu6dQHHXRbidMDcq/2NXKA98SyPVyipjMakdlns5xpX1FkK5mCBXK6EsLOQZhklZ5FwrLPYzLOZ5sGqkATe1cVgvazkgPVAKBz0QuHY8mGSjagOV9VHtA85c2EzZJijhQnct/gAzL8TsIsa64CJvXRes/mku3Zj7VsrZere3L4BCritd9ZJDtB1gScuPzCXOSwFTTC0GwAeiqbDxMphxkItlmQeNdcDQl/4dNeK5WC4yLPdyDPIMg0Jj70IPCiocugTrSqnIkfYAj/m4Oc5pAEsYH38ALvQyDCeN8MzrGBgH+PRuFtiqGlj44h26XU6d4w54qoDnL/OZtS8YohCBRG1i0BdpFjaZV3S500OTBvR0gUl6Xx6Gmbcg031tLN36MZA0BMf5cVse5ML1zoWOstjLIkdaAX2f6lEBWO7nwXU8yLKQ4o/7kw5zuQ3kqUzVRoIO+U5B0YWM6ygpGBLGzcXgP2tj+eJAudAaG5WkSCwbof5oCNUijj08FUyCXTdLoYkZv4/Q++Gc7CHMkJH2d6qYA9EyXDZt8EtgyXnAtSdjKJkHCI5pAc2zCBZrT5FpnPMWxdiU7birrYDnpC0x5iSht2EGQE6+0x2XrjDgi/edJcHCrVRQAGicYCCcSx48CxxzLdCyybmVPrLLS65MVEq53zGdZaSjxDlJEc6xbVEZUiG1iHt1kWsfqxEzA3XnLbNypAos7z3rhJM+n354pqavD8HTnWdSKaGXh0adNMhf3rd9PyoGfIdZed+7wYY7ycURyrRcS1rGHCC/wEUhAcgqbrYK8dDpBjy0opKDFcovSr9AaZ0AYrBOGvzULzJxS3rAN/EpyMhlimWWZYMMWRz8xjSuTHBJBi6lb1PbyuGmNhTMuC6VlsXB/9Da0L11p9AalZG27xn0MKothqX1qbNiyrNM+6IVmcZaWYWqgYW3AC738pB2xwIhYM94y+L6qI4A2edP5RCkG36613Bj25w0LYoLN3RaypgOjlY8StGJ1rYOOHFhEmgevF/fW3l5LznvHQaFRPsz0T7BAfm7tJAJbQHhkCMQDTxZG/NF09roOHb+dwF/Mj8nvkz3Qi8LbeImTMvxuJG5s6ffw66FAv1MY7HQOLCrHxQgC4fFfh4O6Zg+SyUA2SuErUIEaB3YClINblwZz892oT9p9WHAl/MAp/Bpz9KxJPAQfrny9BWF9VGNyldso1LD/ktdsIUv5S10CG9F7oCuVGYddC7Mm5jKLRyQ3mVLjniuYoCgFMfR2Lvck4wgPuPE8iAPGUBkzkVgseQtzGx77rm97AsCZQKoUdmEvYfcZVr9ARblkPfoMy1kZwPgd9NUXul+mHlF3TqEHMhK0YMl483AU8kHrDCpZX/gOt2qa0m9heg1SQFcmH8JOAzKTDrPknlH5QhA2DOdk0Do2jrv2bGRmuWvJSCkRZzu8RAo1dk3G08VmZ4rCOszzYxjHUIu+yD+6/RaMj5gO4mga3soRAoNzwqOP5XULuVg1vdFqfE0IS0pBJWK51u3IFOTKKB8p34hNApum5mKHgF5tq9KapL8zJimGWShL2OgKv/OLkwt94114axOOez8eZb1nRlWUpnZx4rXT/cZ6Uicb+wjhe0VGu7rAEKRmFSCN2TGOHXbN8ujfSly7eDxHCC/4EWpmL6FgU2tz9EGYWkKGIAHvWptPHGzQQj4UUoAsvP3JFgOh5k1AQREC1rMqsDNS6xXPh1Nx4IXLGBdbTf5eTtXXSrMeZm6HGlV4CFR+ypZtZUcxiuDHJPGYlhZLBa6FTDDiHutJAcxo/kzrbHYz0KRDAK52jiURspOjxuDYSlp1IqQQzkeYI6DhPYGEg5sH2DnXORtys8I1iRjxXKW9kxPx+wadGWfn5Qtl3SmpTqdcx7oueiiXOpn4d60mDbWhWAxUTRs8AjQ0tuYJMLdRGCRZ7NTgZG/CkggIvnVy4M8zBseLASnlbd87uoX2OdB20KhA/jkgUq3fZVWhPNW3pSX1+WBs685PnuWekHhaUxqqVIhe8WEfeIVL0o6XdMMHHzGsGx8fl4VAgw5bxUSK7SvChizVCAAOc5tBpjygEt56vBrmn+n6zfTcT4wXZ6xcVzIHQ4WcK0DHSXPJA0dx4cWON6vX2SeLywBmxEgR8CUpnXjnCc1htYqxj5wTfeLTPYTPw5pJ5OfzO93PWrMNLNR17BWlJTaSj8YGzPEWCs5k6XsPNPrAaMmAvMYGxAtZtwPnYt7K5W0Vto9v1cqeGU2jBW9dyytLmuIpcR7uQ6TgvOWWTa4zkufBtKh7VFsUm5TMk40shDQURj42RWZX3EMaY3sCsF6BE3bQ5uFXhY8G8xcI0pdG9ym9LRU2EecPwxas0lfpd+SdRMNDiE4MnkvWnSdQyhFzlSDlvu3my7moVV7/dEbG8aiMwasRiv3Tz7zPwtFpK0Iz7Kkd4E6/LM41zp/ln3AF7TiXh/6ILShY1BzEVDPomR0PZk7CZW6y5VrSdWYA+QXuBC4AogbaCKu8zMXL4WHSDdKmKl7yC8GfKEI/z1uLD1/GDF/rnMuATxRS2ycj+K2DPyJgUnGulaQFN+r234A05HLO0iamofutDoBcEu93INZizVPZRhWBnsWcuFQ+01zUIiLuLEOo7pB3wdisADFrsVY1ld41g6jRtzD48Zgo2q89VAFF6wL16PVp9xU+ZoEo7SsZJqJ36O1h2ArgCQlwUSZFst9pkT5WK9qgU9+DvR8BggL4Vam3dkvMpAzXhCIO9nIGTxlHIuXSBovraJVjdbNxmfEyBXa1mP/LFISxNImh32mFHYtSJaTsjbBQskNvDRyzb6VHpYGkj95sciwulUFkOAcvJdCeOZUwmiRTtMtdV2oAALPmBasSZJCjdk7tJLqgjJO0c3LrBM8JINVD+10SpmWAMnaxICyfpFB++7hugnji+gxIABKXb3sRz6XaxRAWNP0htBjE6rVIabmc3CBMyw0nSyMQci80ViMK+NzVcvaLRJr7ahshIKhYwrIXi5AWfn5na7eyudvTa2JKf2i9IFR3OO2s4YSkAMCrHIdNcJcxRRt62WNxkqGGhkzGSd6KYxzUrnRe5icc56vHFM5MkA6Fe5n5MNmKlIn0rHnPsv9O+bCjcaJ3CsrslwiDSDdO9jW9J5VoN20AUhtbKvPlYp7Y5q1iOIwnTKN8zK1FBJszXJ9m6SPphXRNjWMmSjSgEwHD+xT4Jjco5V9ydig2KQZUuqGcyd+k94TWuTTtI/cQ1Iv3bBk9clUMYl7byohIJfnYGIt5juFd1G0ZqvWd9PrqXRt16/xXtOp6jg3pmgd/l3oDeX7hDYk59DUGPl3mAXSu4Vlnok8n7jKc4D8ApeUAyRRqwRA05qZ8KDarni6vzknlb+OKaAAz4eEFIhg5TJu4rQkM8IeiMUt2CZuMqnLvMWzchIk1d44VOvzy5XUHZlaR8jZbJwEEvEgPrE1Qm0ctiqL6waSK5XWzF2LBRbyzKeEs1gpCmQaAaTevHfB39MFagaLeQhYblqbCS3zXSEPjT+z78WaGFPpAWL5TV3Q3c1xpSjATAUCgl2r+IECMMg0FnuyBQxy3bJ6bI6FFiIA2feTf9ikjtkSWIq7l+lwQNPaVjU2WOfyLFIbgPYhkRaSqD2oGVUmUDYI9qRfBERrBexaKLDmLTtLeR5oO7TA0epDzi6r0ikVA9X4zFEZqwkq5SlEfm6c36pCKjbnYjltpRBygZvkoCaNAEDI3kEeetXYFnimh4BzacVbzoF4MIbsEjqlIUXXNi1YPU/h0cn9UxczC4v0krRz5EdnWpSqnl+7gyxDP8vQy7JWsFuupY3WCj81Vzoo5SygoJQAf+Es62DRC6nhWopgBE98Rr/IQl+zHzjXU7CV0mRisJUOVA++b6qM0RK7MZHxXOmLYpj7gjSTxs9tK/SixqSAk2A5Kv+zOJjp2g6eCA+S0+sJYJl6TKtIa+B+yQw1BHSppw1AUCzZD9ZbwdNr+CP3krRtFAZNpljPunYOefaBSsYNiBboWdt02hddkBct7MnvnWtTRQmJASDeI/JmuVYGvSwE3Mlc9FXv0u/ZmCqOSgn7kxbbdB2Xdaz0yr2Dz8sTigz5xED0lDo/l1NlNe331BLLwFaga81v96trv06UznzkftTte3jlpMhjlguOVaJTTtMiOvfuns1FfumQcsbSATCbRtNp+jWTOUB+gUtqUdUqcu4oqUvKgYUc4ufWumCVoIVDeLTTHOQ8sc6wQh4rU7E6FdNsdQtMcH9KF7Zz0RLdXYjpRr3TepiycLi4yOP7y8/kRqcHhnVywKxOKm8RNdg36IeKZEoBuxdyLBc5hpUE7Kz0c8nfm7RBIxafqJp4kNYmViRjJDWtT0EpmaGts83R7dUGkv1OdgsebvzeYi9DrmTsaOUchYp2ct1inmPFV8VbyDPkKoLkrVKCKhmQZ1wMqElz1FbGYpBlUloaCNxb0lhIkaDVsra25dplqjnOA+eEe7k1acQi3UTLYegTfyid36qwORHr/HIv967K6OIelpJlo3E2uGwb/wzjO0IpyWfLd6KiIS7faIlODzXhYsfUTBpROXLgARPH0QEYG8mrSytu6D/vIWA55v0rvXBIkp/IwzulbvAQoRuYZZLz8LuccryO1BBaITmPelqjp4XvvdDLfNo9FfJLFwHYklahsG+lD/ixKXQs0d3LowWb6zINzMu1agHm0H6ocJADiKkUEZX+wLNN3p9eKc5/pSKVR65xIaMJhfvBsJQ1uW9R1oZQjMSSGHJcu0hp4fiGlJGJgo+Ocsocuc61rYh8xxQ06qTN5KaPTczQwbY554L1PRWtEDxKfHZ3Twztsu19thvcTQAa+grTVkLn3zfdn9nvXcufUm2w0wU2qTWyu8Y41gSWCghxNek7sE/T4EggnoOZliw91smD0nzUzBKTZhwBUu5vVARY7j60TdEzIEoZ53w3536VjEXwHLp4ptFopJQYb9LiG126SyomOddS6Rizg6I1C1SG+7u4T/Hv/GgWhm1TLp45Wt2OXrFT3NG1ljlAfoFLuoh4uHenXQgOcDFPLcU4b711MYqVmRisY5CBLPKysYEKUYcDUHv+lw0AmxuPhnelOoTDjv8CbWBMwE1pRRLvsFi6wRfR2JBs/sm90kCZjUkNC8/PHYkFsawt9i325TC0Qi84tV5iZaHAsDIojQsprgBRME6uTaCUWBYBVhH0AToeFDHrQ+sQQLT8MPUVJUa2Sx8xbRuvGfiUc914YYKzpUHu+9thqZ8HGoxkw5B5srtfYLmXQwNY6uehml3mLZs8OFjspbE2vA8PMLFQSyYPftciumeNFTBP4M3ocbpTJcVZYkl0wguVoiQaY2OC1ZVuYGMFDG5NGrFmO4eVXiEudeX5485io6pDIBHTojErgPMHJvz418ZhUpmgpFy3WIRgK4JYDp1xzvNpYwYWHqjduUeZNNIXAip1oEsw1ZiMnefr6phLunFSHASIFe7EKCqN6eViDc619gC3bWUj0KS1K0TrU5HKc8lKoTQWveLHaxayXJSfIlplU0ty7SuM9XyRBQI4hbguUze2UqyY2AbNPJx5b5az570GRSbth2u9Vxp1TwoKAbhCJ2ODn8usyEhl8WUrS+EacswZoDzya8Bah7G/3te8CdbPYPFLAEbKSe7GTNBil1r/GeMg93WYNN6CDHF/s/w6vXWRDhf3Nj6HMSNdYTq2NrCddsmnezJpIek9QpBe99yZMecJ/tJ7t58Vf94c1y3qWUqxSCW16qafa4VW36TnYuPpgvTgpMob557p9BuBZWqocC6CXHrnmLdewSuhJtJrtFIhGFApWvDbFDOtYqAq10zwruh0Hbf7IT1Hw99cOz8+PRd5pmYC2S41hK9fZBEjdAG3Sv5LFfDWNdsA38sR01m7z5XMAfILXIqsO8k7Gr9rf9bP21aINHAodfVwEyenTik53HkQpa43C1oYY2RzptsZMxSAXE0vSALobjR+15K6nUy57Was2Jgk38V8ogAulFXYONcnBhpiQdYqpi8qtMLasMLepQJbvjRtYxwWPCVkUhtsjhtkWhLIa78RkhrAvrROMjRwEwxAPnnHWQGIxsVoawZYaigsFpJbWYAFDzsF7a2xYiUUsLx/V9/3VeSkaaWwe1Bglw8wvG6pCAVRGBwH+JR4Pu+xbLoxfy4tnIM8C5WoYi5cFQ6dQaFCxDQtyA4RMHOMGKSVK0khmGuFspHqdZkWq6b2fdLL5Jq6sV4JyEKlPnkuMPb0D75H5Uv2hsIPiGCOabhojRr0sjBWtPzTOgoAC4UUvZB8xX4sVXs9ce1lSnjQDEJkarvGCBjiHFRQOLNRop9JQJ7WEkDGPpqVhmqpn/siHWIBJoAgtcD5htACW2Q6VGcExPIu1AqNQaGFUqGFNsEy6Yu9LHALhTdtJD+3jbQIWkJDRyRCio4c1jrQtAABjGnxkFQIEFZ8eeh056J1l0KgTQOAVrFoAgFrZdOS6qKY3fGSFaFF+XUtfHPvOahjSrfNJCczm8kc3l2jhHUdC3NHgnVZxeDhntYSoOekGA3nGyDeHbryUwWfHFmNmB2my3UOz4Tf37uIp9Ow6TOgncXB+sbHOTg7OIzP2smCHC2yQtehlZd9mAZZp1lZ1Ix7ZFpNgVwKS0FTEebeliV7TpplJACyxHhBYNx0LML0UkAlWWZsYlxK+pxByyngk3ns3yXxFlLiXhK/o9U0fxtAa87w98jp73SKUi1vc3qvwp8dwGywy32wq4Smbb5SjLwTJr4K+PuSZQ6QX+DSncCNabvR0nlmrRShSL9ivIUQiFpzV1LtOeU0MisEDxFynEOgknfVCBjygBlx00kXfbe0LBfoLI5fKrMqPbV+D6A98hYBn0GgboKbbFxZby1P+sM6DAqNYWWwOqwxaawvYNBIRS2/sY8qD+aMC3lxJfevb6NvCzN5xLa1+3tWBDDbHw9T+fuuXh4Ph9ZBAqSZHLRS2LfcA4CWm1orYGWhwK5e4V2kUraZbnqCijTlXwhOccxGInmOi0wFZYdAisEfxrlWWWBWFORmzmpkfD/yNEtjJYuANSh9nuBeToUDoZpdnYBHAsDKW4lLEwP8xKLtLcI2HoQOkc9L+kPqFk85h2EMICXGlZIgTCoFXW4/AUaeKQE9TmgBDNasjZQRpmdFKwluGyRBt40Vty3fTQIexQLNpzHQcamftzLatKx3fuyKXPIZ87PlXo6Fnig4jU831/MAuedLeS/280CjyDONYSlAM81iQy8HrZLOxRRhhQ94lNzP0eqqlKRs42FLsJiuh0wrsSg7N+Pwj79nmQDtmC4srgnnRImnh4fWPKUUHjy+7mMoYnlurn+WSAekYIixcmASqDMYs4sI0n0txFokAI9UpTTmQDxxXpEz7RzPgzwLPwdlDaJAkD/O8uD0dPB56f5Ia2dLOn2a0jCIV5sAHNGiEfG9Wt6+5FnhS52+aD3QS9XY8B0WlVLJM9Kmqu5ESPpvFrBifzfG02WSvVGaGDOiELCq+PCWdTrNXMLqis5/kT/zWgLItAAI+4/glekA5TPXahef3+mqHSV81z/EAb7AVfsOCu06CTybw++J4kvhuorWZVKfOvdWs409lyNXQt24mjIHyC8y6VIOOHm5CLWatmowGTytGl2lMFgQEi3b+A0glCmGt4T4qmM8zKOFyadK0+18x/yZbnv4+3QjgbeTbltnuWN6uQ5plug27+eSso1Wh3EtIKw2Flt1He69VEiFvXNbJcaVBJ1tVDV2FeKC35o02KzrUJ428wUdqCS06Sw2RB/HzSZuxrMAslLTOY0BYN9CP9AEiiRwh1YRZlrItcKx1XHkZEMQMoNyFvzhe2FY+XRcKgRwAQIsZpXJjdw2AUmTJpaaBiJv0jpguZcF6kL6/lKsIs3CEZ85MQbLhZRhrqzx2RQicO1nWcgFLOOO8PxJE4srMD0fKRZCdZFgRRfeJXoMmOh/fVT7ghm+X1WkuRSZwkpRBAt4z1NICq8UEPgzMG9QZKhMrDqZe45+1bAMd5y3VWOxlOfhwJL3lzXWL3xp55BvOI45U7HRks/go3S8lJIyytct9YL1de9yLwTTTWqDns5CzuJersPPpFZJsaCYySH3ikrX9a0UgU5i3fMKSM9XZ1Te6p0ezVpFYJ1y7mVv6lrM0pzBEXCnninOW+cwxQfVCjiyOUJtJUtB413mzFrR2MhLl6C+mGdZK/gsH4kFOQHksd8JIlNqWQS4fCdmD6EVEojeozRGJOzvfi6mnHGOCQGsQjvYjXNvO7G2zcUNMSipt9DFnMvw7z1r34oBael4tSX9PRgPVExtSUUrNaqk0iRZObKw30zv/7wX56B1tL6nXOK4x3XTlykVLeEsgc3vMEUcAS+BeNrvpB6xeFX6/uE+Nu5Hs7Bl+lrCVZ+Wjp4W5v3AB72mwnnFL5JuEj+fVnq4xyrQOxy9oxQGMl7k2L6o7ASPrwaF41JlDpBfZDLLxQREysQszu6kigde3PjaC0OyFiChCMSKV/yuVpIZojHOR8pHoMuiAwGouUSVRtSsKeF7F1lpO/GT0k2HQJh81F4mRQCMlQ2tbMRV3hhx6dONtVTkmBiD1bJC6TfxUW1w3aAHYyXV1agxGPiUUP0ErPZySW/GRSZu/R0iyTuvqpVYq1h6OtXeX7p3IUA8Vlnjd1i8AhDL0takabmnlb+OAAYAtibCwc51Un0M8vx0sydQ5LO4yTO/bGppZIS6uIgTgMyxAwKvmbx1wFutjQ1lmK0TS36awnAhy7xFVqgJnIf9QqzOxgOcUObZxTXAfMpwPNTiAUoAxKCh1CJLYFRojesGPWS+DHPh53oaqBS4znDYtZCjMiwaEccoAOSkH6vGCmhUPJjlPagoKdVWYNZHdQiKrYxt9VF3ZSilWtx2ALhxzwD7lnvSbz6lH++X+5+dczH3ceLKti5mhkgzrPAAZeYJKh/MmS1FhuS9WY1PqWj5rBqh4eS+bO/muG5ZLTkXk2EUwN21ICfXOhepQbQU5lrj/KhB5fOf04JZekDIeZ9nylfuE68QM9j0szRbQtI2TB/iYmFHq+/TYCh6Xhpr0XAOmbimGeSbVjzlmsk0c4AntB7frnS9zTwbXGJEcdMeOYWkgISK+zRfj3OZ16Z9MAUId0A9nFOidPo843o2EKS0A+ui9bwrVFqtiwaSdC51y12HjCrURTrtDNf5ecWMTxxzeurYD9wTuRbC/VzkjBPEA+25kyo54W8zjkQC0+5H6RpIx4PGLArncRoU3pUUwNNKbJP5A/gKhbi8fMhdmbV2UrlS8H05MgfILzKZzjUZ/+6AkOYsfu5Ckn6KVrPdxam2KAEz7fQxmZYUUJW1khVBR3dq5kv8kqOcuprYDoocjtFitZN09/ztImxp1WUi/sUiR2UEoDTWovKW8MYIOGPg1Z6+WNs2qtrn0xRu697lHiojfx/VDZYKHfil0g5fLlnHqkph00w28la/b2NBHhQx8IhWAgJaeEsW+4EZI9gPi3mOsjbBmhye5YHIxEg6tVFtpHqYL2ZCigQtM/F78ryUz9wYGyolcrzIgU5TW5HqQpGobxmTkN3AW2Ura3Hr9YvhEFwoIi/OOWBXrwjjKoqacFSXBzKujeeaDzLh16bBjI21wQrD1UCAxv6rjVigU4u4lHwWCsLe5V60/nnraZrGrrLWlyIWKy3bxyDJItMYN0aq1mUxFWJjnOSAViy5a8M9i0xAVprNYlg2KHJZW3VjpRrY1CyK3iHmd+Y4nF6fyHroS07wQZYFsEu+cGPFCs5xNVZoRs4JZYuVMFPrpNYqxBUwE0njQcBCLwsp2OjJSIOCSH9gYZFhacKeMB2YJP9nPKdY65gSDRDlX/YZSX+mgRDsl2diGa4ai60yFuRJ9zTxSmQY+1LiokAIKGWKPFrVpD3RvU4gJftpO1ia782/kSJkXKQ5lMaEeekQOa9sF6k1hVaBqkKhRZ/VzkRBnDExEPciMR74n23k3aeAnnSCFMxlHY+G3BRBQdouq0Yq7HsGhaf7hgNaKJXtSUElgdqsV6TCREXNdsA3zzYqf0wBlwLC9Nm8F8eFeZapGHKcXNK3SWNaFBaeS42dTW/kGLb+hmkgzH1wxssHfneaujXXKqSoVIi84zR4tPvuqXDthmI9Xpjl5UryIfOc2/bzuQV5Ls9UuhbVCEDpZpzeRGrvjk+FYKQxrBAWLRq8HxC1cyDm6aw9QM6UDmlrWJUrZBWY4VKilpuKoro6812n/zalQSebKYG5cQ6LeRYCc+rGovYVsxor4Iy4fMVzfTcmxqeAckFLFrpFg2FtsFTknsMZLY6DQgVOL61kCu2KdammPVUF0SsqC0UMviKIPrtRhvddyLNwqGdaLIwxI4AOlrs0P7WGjOe4EWA7qg0mTUxfRothz1tflZLsFHSROxc5nY2JVtleLoF0tEQD8Gnu4F2TLhx4qcu4yHUI4pwYg0ljcH6rCmB2pa9DFgJAUoFRiWFAoFZSFrpKQOViIRk20rnC6oJ+gkDB55dFtMxxnggwj0CEB8PL9y+G8cm94kdrKiCeFQaFnbgwQWlc5EN7i+yoNqiMWLmFz20D35qg0VgEi6LwIZkVwgWLc8+nY2ustDfMn85cogIySfJhr25VWB3W2LtUtDmq3uOTZxomrS7ngdyktgHECjWlXWQiI9CFBOBKhohY3IN877I2QflziIFNCpFaNJmh4DnEPcohZghgO/nZhHQQxLgJiQ+Q7Buj2qJsDMZVE6yI6VpSSmG5p1F6kMGc32EuKPKpZZ8qk8I+8H/nnGL/RMt0XKdcb5EyojA2JnhwrIvubAII5hbvZ1LdMOa/9h4PFWk2aYaHVAjSutcwJiQLICgCw3Q/Jg+a75oKy3ZHw8A2CB0RpJKO41xMHTd1piXjzEneJIWqpu8dwT37nqnP6OWS5+mgIHVjZOIZFS369AZWJpYVD+2a8b4KMTA9/ZxrY6aBBNOeoFnYM7zjjO+OKsnhbJI82DoFyEp4/t3c1uwnSttQEvey1BBFL8DFqJE7iUoU5llBgNdS5gD5RSbTCmsbjJqE6yufx4Mj/T7XBQO0xLplY4371BzqhVqjsTFSn2mdaD2m25jR0AjP8wtihiZ8OUttFpamhi8av9AqBFQiBHo1xmKrsjD+9yJTgX+rlWSoiBzWWHlvVEuqsZ7nYjow1R2CFV3ePVqWGekMtA+BWfzAqN1HCxsArJV1uCYN4mFqPRZ/WR7knsLgLZ1ou55p+ZVgOIN+lnmrdbQYtvtXYdGnjSO4liwQtnV9Sk8YN5LBIaXnaChfiEPumymCarF01Nbi1NoExpc9XukVqBoe1PCgkJkVaKnzCpqJgX9LeY5BQV6qCgcibTAOkf5DSfmM5PMWWoeCGQSWMj5i1dUKXmny+a+tKA1KAWujOnDS5f3Fiirlq4UXzEqNpTHYnDTBEkXutFICVGg9opJZGxfyGjsXc7JyrgXw5t9TQcCpgvTFqDIYlU1I1xiqmLlIm2AgTm3EQk2rmYK0nc/tTJRQbKGsTSuPMBCLeAhXnhQLFwAZAXGuVQg8TgsyJDpDmIMUAi0AoXQ0v8Pvk0teNRa1rwpIRivvnfuS8nsW8gDyc63RzxUGnuJD6hJBK9NVptk9GFMRLcjT+16aeo95jUn7SpX71MLHNHNS/jvSctLnhX0/8Rp0pWtEkX5LALJLrOqJ9ZjvN5PXrJBQbGY/OL1PWvGN7xvpQAifIbkf1zSAkN/eYRqYOtcOlKPCQut+UNrRVhjSfkkzMpFaQCE4pxGD1ItWG5DQUjgPEPnNgdbR7SM1bS3m2k3FWtdSiPgl52LhmXSNdI0x9Nawv/j97c7e9B3Sd71oppRLkJTD/FwH680B8otQuhsE80ACCIddKrSIBv6xik4cbjws/CBct8g9ioBauLKjsgmcUlqgYrR1zI6Q8trSoLxZ60GpS3PTsR0U3nNYNkFJoIUAkMVXW7EgS75f0bQnSTGHc5MJCi2VwSSIRQ7dtUklFdgaI1Yobx2bJAdL31uaGEAlYEqFAK64Uc8eO9kI5WduOowaHzZNGKMQoINoOeP3WOUv0wr9vG2Bcy5WhWuspMAbZAKMdy1I+rfFfhaAFg+UvUuFZPDw1jlyOwEJktL+cGRg19DzN2mVMi5WCaPFwTgPSKBQWaFenBuXIaXb3kGvBXbIl439JH01qQ1qy3y3QhFYWShCH2T+QMqTDV4rFdoqQTUEp/AV/US5IMXCOhcAcisrCeDpHS70Z6401ssKxjoMkkAqQCzrxjr08wwLeSb5s40RzrgHj3TlEtjSE2Gc9Luxzuchlja0eJkd0J9lzAntXf4KGHoFD34+0CJsHYIl21gXaBKUUMXOK7xdRQpOvDN978FgzliCCWMd+kWWBPhJWwufBSdtN/P3piCScyjN/8vdyFjng4T9vuH7MB33XqZ8JhQpEsPy6cFQ4CSGQCuF5b5GVRvZ/7TCQq6xWGTBQ0BRKhZ+Ic2JCgu9azJnMCU9v69SgcuUwtjn/yZ3PnBV/RyAc96CnKHvAQ55zUq1K5rWxs60xtFibW3bEkhFJk3RB/j1kgDv7bimzNLCvpwls4wZ3ZzjDolF1l9Dizb3o8ZIdiEC01k0QxoZqHxReYjjHQF6ogsEZVQrtPZWodHI/GB2nLTEeXpv3ovPTDn3VAitmzZG8FndfqKimwrTzaVjyO+WYX0nANnnmk+F79eqnrgN1o0AdnoPvEJ87O+/PR64ljIHyC8iIfetK9ZFDda66cjiyppobUJ7UpBjRAsyAVA3elXBF2/w+UK5+LlhMwNAbE9MdcTvymezV8R21o+pzSNZndygysb6CmrR8jCshcPL/JfGOpSVgTEW48oGd/96WQuP10gJWucVhVEjoHtcWUwai7WJWJRLz+klMM58pHvutWIFAcgs/lBk7RLbXf4j/xY2Z/8Z+YncKskZBsR6KQU0vGXCt4cgEC7OCVqKGD2/VPjKYv5g3LvcC1Yp3p9R0aMqFkahcPjK2ga38aRxIQ+x9L+8j3ECZDMlRSd6msU3LMrGYb2q0Vihw+zuF8F9rZXCZtkkVrPI8ZxUxh+ULmSV2LNYiPKgI6BKFbLUMmxc5INa5zD01ly6rAk6hIMrdBDj21R5WkVpTIjK72cam1UTvBYcr61JEziBi3mGXb0CtRXaymbVhBzQDCol+IpA2IYKgbTeKiWBl3zHNIBMKAV+rvn7ZUpj1DSYNCYEwi30suCqZlCguICni0ZEvqhQecIcQKTPrAzy6MGBeGxYFGLJ55pm3wOxkAaBd54pX/ZZt6zU1gOUIkss6sn6ZmBUY1zrkC/8HBsUOvCxG2NDKeF03ZESNq6j0tPTGr1MY1evkPFDtFwqxHLOBEuDXhaUWu5xs7ayMIdVpK1NaskGZB1CpVKCNhWUSoWFPPMcZBXmMr0plDTFZKuAiv9v7CkkXUWLGTTSNqdhIdul4RTgmjxnxr4+i3NbdgpGOb9PpY2wDgHcMR938EpiVklryf+fAkitpsFXxTLiBOTOhTMzVeJSUSp6BGnsYFrI9HLr4yycB7JhvmeRcjirr7rjyGd2QSjnRfedqKhQQYz3iAA5pV2E/nPx++l3+Ft6znafeSUBeqHdevu1ci1lDpBfBNJ12bUtkm23XNdSAExHA0sEuIubEwTQNoZ154UvmVoWaDEWd47ck65rbhbclNLvwX+WVu/pLjhuOl0hqN+5b+RwCBZkD3JHTczlyuhwWllGdbQgb5QGK70icBxpxSmN9YDYoWocVscCmFkFi9Y3rWL1MB5AzNKg/Gfp+DFIBECopEVgyb7jpsx3r/24UGmprAmpsk6uTYI7OVqaEcG+jQAZAJZ67ZRAMfgkjsvZzVLAoQdwaYDJqJK8vszvC8SDp7Qm8PDyTMNa7/5UYsljWjzSEzY9L5SpA+ukYetlHWgkQDzAZKy9R0NrjGuDtVHt3aTwHGuETBDMQkEFUvjBLDPtMPb9KCAzAoKtugmUCM7N0rdx0kTlpJdrT6VwWC4KZL6AzrA0Pr+xKCVLg9znbrYYNU2gHwDxYJPsDpGmVPt4gtRSWHoQTXoDEF3KIfWbirSn0kieZQKTlUEe1kp6YDL3Ne9HGgO/1y9iwA8QQUPu81KHgE4rKRWNcxj0skBHcIjKCsfKIRYeKrI2r9E4seb2ch2QCOcC1w+/S9EKgT88oKLv1z9pOWkmn14uYPP8sIHxMQr9LEM/y7A8iBlW4rpUHqyJJ6Ub3Moc8TO5wE6U3bxVUU8AeePSeeVBm98nWL6bfdPLddhzU+lmVug+nKntSOVhG/tFB5yhDYB2siC3FKoZSCfMT6UCVaWmBRnt7Eppu411fp7Hced/Ss3O1sGYhbR9Lcun86lG0aZwsD/yLAYJ8/YhHiBZG42NCm3Lu+HiOlXhmS7J3zy7r2bpH6nnJLQfkcfNZ5CWxH2CfU0J/HzuoexPILk+aQsihacbxJ9ec6U5kJ9PMgfIL3ChVQGI3J2ZFgpEcNYG0G1uUmrNSe9jXNxkc93ORAEgEPMZyFdaM5Osz7XTWngqppyZpaXz8OxKygvbSazftOQ/+dswsbRxQyU4HVbW81qBYWWxd7nn87ZGS5VDuzITK20xRRGLZyjErANUOuh+BxCCw0JbXWwPARsBJt3+tL7y3UdN43PL+kIHjQ1u861JE6yrrNZFBaXx7QUi8F7s560D6fxmFRQRgpzNcSPv2vi8rc6Gdxx7SsIkKenKOcHsBAQi3FgLv4kv5Bk0PKfZOAzLGHV9dly2LFLDphFeqItgKHo2JFvBQp5hWDdYG1bB/c7MA6yw54DgauccGBQ6gMLNqglrRtEzkGlsVQ0aH+TINkx82rbSF3qwTsqSj2rht+4a5FLkQwnAr3x/7OoVWPSZHSojhVFIsZA5IfeX6owcfwQllXmwSYXI/DoMrnilgvWV98qVBHdVHiCnAbjk6yvE/WGWYl143n1LaIH0tIrG88mD18BKZcZYcCEqicwkwDs6Fw/tXq695VuF92D1QB7ctPhHK6EK7wHpBizkWaj8aB2Ce7zxRYCEnhH3lF6mcG5Ywxjh2a/0cvQzjZuuW0BtRRkjbYxZEJxrVy9TfHjSt10hZYQUHlZ2XMzzQMkaNU0EbZznfu/kmmJAb+CQhvGIZe5bAN3v4aQ2ZCpJW4YZ/OJkLgnA2wYg61hgByqCq+41yW2Dgsv2jTwvfDpziWt5U0ibYEo7Gde4/1AhJ1+eQHpqDGzcGwMPOlHQmDowFhqJHG0qZaT6kDboQOAd16nDdPDbThbkqb4NkQhRaIXu6gaLvSzEmbDNlO7+klacDUHkqjtGEUsACP2dXnOlHORUdgrsvBYyB8gvcElBKrBdqjAfuKGiCyj9fvo7LXHpvGTwSuPkMCVnNPK2EEoUNwnQ4OIyLgI/avFpLletEC3NmGEtdrOpI0yVBOwc7SoaMdPpyOY/aWyIBk4PDuPBLg/JUW3w0usG4X2MPxQzFTm0tQfVdCsbf3jTVdzzeYqtB5MOMesDLWZsPcE8AG+pj9YtApXUMgi0AXJtpLDE2EgarnGSv7XQUqDBIW6CgYrhZEx6vtACMw5sMp0colVwHLjHLqRDY8ERHlzGWZS1DSCF80x70C/AJPLPG2Ox6K2QdJlO/AY+qg3WysrTK+Q+o7rB1qRpWcZaabSUwmKeY9Q0WC9rb6UB+lmGQiduSydAj+CbSg/vOTFNcHEDwmte7GfYrBtv1YsKZulBYZVQTm7cMwhKyO7FIqyvoafoAGKl25o0PgBUvBMKBMQqHNil9zqkQYQAAjiovFKSZzqsQ66pQGGidVWJR6FxkR/sIAGFzJrBQ5cFGdqKm7SbFAtArH9p0JSxDuc2q1AwhR6sbkXJABySJazTExhy0KdeE+tkPjPGgQoc4w2AhCvr78UCL1KIBYG3ap3z+WilHxYLHUBLkSkMJzWsFQC9e+ALxDRMJRhjG7Is8knT/kolDZimhMwVGujpmN+7Mg7LvTxW8KwbNM62qHL0Qhk/Zwe9tqVUpc91se/CsxHHjhZNZjsgvSbsy9Z5S7gK99mx8EiiIBBcbSdMhcmAcQWENIGaDUDMqlQlcy0FnFQeCBaFW851loW9Lw2068a/WL+WaKF3jlUsEYqpRNqMbq1FKtMEz0DMsBINVDNKgbvZP8/CmkLF6SoN3hPMs8z/PfdKMIXKRuOVYs7XSWVCBpH0/G8rMWk2Jv5tBiXkKgLkWcrRtZQ5QH6BSzcNzsxIaf8fD4z2YoyAjBuNTjaz9OAyHtgQ/PHeAK25kS+but0ZmJNuqF2usMP2m6h1yYM6klqUthPl34OWLAsBM+RIpxq0tZI3khbGqnE4tjqWw9JbhRor3FKxHtEqFoNgGuu5aS6mqzLOeYtTu6xo94Ah6AYSi7U/3GgF0qq9cMdJRcDaWyFp2Rs1Yq3TaJeQdv5ZLH5inQTDjTzAoCVnq66D9ZTvy+wVDHI0zlt//YHKdGe0yobsAEjmhJ+3knVDDqtBkcFCUgpaFy3Pm1WNTV+4g5v3sLJYr6pQjIMbOyXTws0cNwZbVRM474t5HgphsB+KnIecjOXmpPEuSwliTCuMZUrhwK4+hnUTvAeB9mJcyMFMpZQFQQB5P8khLdQMURjjMxvf78bPU6GdKE/dEUusQrRMGT8uE8+RrRo59BhkyPWhFAIFwvgNgEFjxjoZC79GthILLOcqxyFVQpWS96HVLQAHzmM/L4ZltMCTBtR47i45kLSAUglMARWX9a6Fwo8xrZ0xM4FOrmXOV6CtdCsl9JrFvvDZjY1jmyohxjqs9KWvWPhnzDRZ1mHPUg8KCqtblVc2BQ2T50oAxMwBY5+HmS/SDTamwgC/DlgymgrGYiEWwDLxVsh+Fr9TeBAUrH4dKgHHw2E6GI/C+Z1nKlHQo5VRJeA1FiXZGaxwXXAtqM5nlAT/gnE0sp5s2HtCO00MWIwxLaTpUAGPFmAGqAEI6SmpWLAN6f1TWpih0uM8tdCfeyHDh1KxCEiifKSKP+ADJJFUJHXxzAv9sU0fbpfZYpZleZbyBaBVYp1CZZrxN2GvdtEIMev52iv4vFn3PdJsLVdDune6Unx8uQB7DpBf4NIdblqXpkSl5X8jCOOiSoGmBM6p1ibIiUpuYxrsAAC5YrCMd20iBpbVxqG0JgT5MZgEoDYfc08yGCzlwTnntg0G2ckqkfYJgFB+OFiHksWsPWAQq2vT0v43x8KF7ft8w8Y6rBRFJ6pfLBtFFq3oVBL6vohIrK4WUwF1tW1yCwFxpREwWxcDpbJkg3SQzBmjUg5i8ndJwSiNwdg0iRdADnQqPpNaDqHKWCwVuZTcddZnLUDIVAHEwCt6EeR7YpUXgBxd3xG0ynvwNVsWLURwQ75u2qfMV7xVNxj6gMDcXztpLDaqOuRYZjrCMOb+8CqNxbBp/PsK4Ch8dgt0DgGO7XDSBN517fueGSMyJfzhzdJTE/x7MNuCZGyIa+bY6hiNb9bGuJbCG0aoGNaP/7A0uFBWoQ21B7sTYzyoRAgKTdvLtTMsG7Fc+2C41AvAdrTe0TFXLoIF1TkHC1EOmaGCCgOBSpqeEECgogAIFjdanAiYJ3WkwaRUEOeEjiNAm0GRpOFEniXvLwVJZE6PfR5neh4YlOYggIjzoFvEg+nQdvUlpmDSxApm0avh8NJdPXkn49DLVYsLSyV1VEXuOZWLNr9TrL4hECqZ96lUPgc7M6z0EvoCaTITb+0jBxmgl0TukWcKpX9e3cQiR1x/BPe0jM46HsiT7XsjAPu/prYPegXjdy6F3pZKCuq6/UAgTfCajn26RZInzDSBFFq10+wHziHExLQCE5M+BGJRFd7OuSTrh/zP57L3e4+nUCnFzCoCEsVb126zQrQgp/xqCgs+bWfgmQmQMX1uUEkNf032HEk9OT3vGuPCmiZ4Z9zAdjhSq/Z4JNvozM+vVKYs7Vd4v8sF2HOA/EKXzoBv595QYM5d+Z2bj3VJ1C1icv+QTsq2S3MSJBBUZ6x4pxNemudlcbOqGwkCaqzDYj9D5i1acjDJfRqmmkN0/5OvaNxsyziwc0AAAQL5zbUv40pLaC+PXNRcq5D7d+yrasl3XMgmsNzPgsVdqXiYy7M8BzCXAC8BtgIkF/u5t+raoM3TktulxKQ8MlrFIniwwUKfRvSPa4utqgntaBIXf2mkdDYBDl3ClMq44NofFBprZSWW5cZb+YyJh7uLID/TCK7Oxm+q7IvAXkjeg4ArU7EErkvGldZDKjBUmjKtMGlM4FQTMJaNw7CWSnSkF7DvlBIqhPLvN6pN4AX2i1jkwSJam0hLqI2k+0uVKuOVAr7PqbUJxpVt8SUJ3I2vMJhpmVObPnhTQ4BwnmmUjQ1WqFwrbFQ1hg0PykiXKBspImJcYj1UyVqA/DwqTeCpGiueACqBYo1rA5PU2u4cWqBrs2qCFZfXEjga6zAqm6DIpsK5xbkt88wDMvK/i7a1rTFiaV/oRdc3AS/fM/VEce7TqlnkGiPvGub8StPRZVm7nYM8w3DSoPa8aILpWBZd3vFttx/we5LzfO5Y8OLCsJagOQa1IXplKM7F4ijdQMvUyg7Imq6bWE2RaQhl7slcnDQS0DnxSqvXcYOhggGdxgpwZ05rAm+uCyrCs8BY16PFWJSYjlO1FCBgW6de/DzMMQ8aE+NNio+7WzgDSnlNGheTGnZSQMsMPUER9Eofg0g5DkD0lDoIgOaZScs4EAO7uU65V7MPqUQMiliBTiqWqtCOxlOixBjg/DyKe4ZCO1Bu4quZzurD9t9mn/Npn/LH9VHdonxR+H70KDRJv3aDW1OhMkrpekC1vrwiIRdL33q5StjF5HIB9hwgv8ClO+DbBblF6yw3qPZhFoGeDdG55BpL4nodsirwCQLUIsB0iNxAaUu0kFRWDnFW7GEVH97HurYGD8QDz7nEMtV54Z2WD3mlC70svAu1ZuXbzgwTeaZ9gBpQNQZbVeRSWx9ct2ch84BKgsZqG0EeeYS7enkASrW3uOxZLFAZF8BoGJdE8aAYF612CmIhpoUvTSeUlhuuGostn7ausZEjnWmEwibMRRuCo/z4lA1BobzvsG6CG9xYBNcb+54carFiA40HWI2xEjziD/l0bJnhJB0zUh6CpdKJtY1WM7EgCdieGMmLzFRZpPow/ZZzogiw3wBxpzvfN8wqQfdrWgWKII7WUEn5JYAlcs6dn78yfufHVeCFcr2lVfKMB3W51oH+opQcgFpJajgpQCNZFUZNg7KJB7Xz8555qa3zaf0Qq3+xN5lJgoGfpBHNWitMt0ZwQcWL81y8EU1rb+D70HsxqW2wrqfu68jFjc8mmKBwzUeFKwaCpcFRDL5ljlilIvWDoNk6hEIfVLocXJgPgOxJ6foaZBk2ylrya1tpmyhHKtDPjHX4v46cD31ibCxjbeGw6VMPsqpjOpdSIa0sBED7NZJW+QMQ7lVkOsSIaBUD/oZ1I/uGFVoY1w0DAW1HeWZ+cFZOI9ihBbVmEEIiasZc4f7fTQnXom9cBAjxU94hPZq6AIy/cr8g6Ew9AECcM6RbhWf5n7WOOYaBBFB3nqdU9BqEYlZJyWx6CjjHOS8ljiR6UgZF5HzTuMT2RD6vXMu4i5aBwnOpLWS8WKp5JyqAUqoVwxP6MHkuRfbUWCiLEuawi0GNQFtZ3u7Z6bDTS0Ohknep0vUkdKVrQb9SDvKcYvEtLt2UOMD0ZqSSja+lpato4ciVagG/QuuwQfCAZgQ1AG+1knv1dNTmaZUbNzGtVaYUrlsqwo4ZA3IIsuNh2XUJTpei3r4vCEyWB3ng85IHzJKxtNz0Co3rlyQHcN1YbExM0P77mWR/uHGlCPc9tVWKWxkuWKEB4MbFBe+ii4FJCmLxLD0/lWPA/nedNlOjb0c6+yIU/tDrhcwYkmd4YgRgGRdTYMnvcUOXEsy2c08XKAvD0kggUNg4XSt/NIDwGVNg0aI+9lW/AAa0xI2zyFSLt56mZ+M7OweMPK+X42qd9C2tHZmWeWadKB+j2sL49yHoZOXDQgvoErqC3DPTKhSEMDaWrS5rg36R+XRfYnUaFBnId658+jXyaterKmTQCKW5M52AJQZcaUwaE/qA3G2W4FX+e+PGYGJsq9rXuBGFclevEOuS8ZlVPHUpBLtm2ntZJC+ysS4EN3XXPRUsHtzdYF0WuhElKKFYWFabdKHss1IqBFHynQm4U6BM3rRSwFI/R7LUAwAK9/BzgcG3tH5mWir+pZZ+IKb/4zxUkFzUfCuWcnYQULWrV2CtrHB+IoVb6ob3yQLX1Dng66e2PGCWOWZ9f2kojGrTAlsh64bje8kLpVZ3GgCEbhI9ZixwwTSTLJ4DSDAp3fnklvOefNxCLwv3oQW59lZ549oVUlNe+ZR0NlEaD8KaTfaAy+GXhrSCAfzG77b57ElMi1KhxPhMY4+LJa+72R/kGe0AtpT3235HFagUPPtoDQ1VLG20PHMeAilVr8255b0oLHCTgvUW99o/h4oGQSvpa9uJwvaeYq3ahcEmtQ1esO450zi/T9jYj1Gf2xmg8+lFrqeMVJdj9L0IPp757Gsp1xQgnzx5Ej/0Qz+E66+/HoPBAK973evwn//zfw6fO+dwzz334KabbsLCwgLe9ra34Zvf/GbrHmVZ4id+4iewf/9+LC0t4d3vfjeOHTvWuubChQu46667sHv3buzevRt33XUX1tbWrsUrXnPpTuTuhKM2HbR5Rwte/D4tA6n2GQPY5FBmeiyXbHaZVp5TjJCpAYgRvwy+Ko0JFcbKRoDAUj9vRcJqhWA1cB6cMYClC/a7m8x2kgKAXMVAIOe89dgX8FBK+MW3Xtf31AmLrdJAe4sdg5GWijyUTD47rH0VLuEpsh0M+KIVWUHh/FYVUkIx+0fIKEJTm4sWK/IB+WrsD27MWonCwjevfeaDQscqaOQ00vLcOFpZY//UPjJfLJYOF8oK44bu5KikzOrTfqYDzYKALtc6lDwlT5qWQII7zp3uZg2gBT64/+dagiFZUEKALyPNo0W+tp4T7FOh8QChJZ9zfKuOfF34dxwlJbNLazAxBoNeFu5B5U74wRajRmg/UqRDuIm9TN5ReWuQhkI/y1rWztKYkP7MehA9yLKQU7uf5Fod+fLMu/sFGBjEd6eVRoGcd3oXxMJf1p436pEh5wnnVgrauE6ppDArSaq4RU56BAxa+XLTLSverP3I+bYmlkeF4G3orl/OXaBNISAPmqm6tIp5hdNbdPmWKWDZvVBg1Bisk/fp50Wv0Oj5IFMAOLlehntulSasRaUIjmwYp8AZRvQQ8L0J4mjxpLufwD9Vhsf+u/TmrfTySDuistpZi0v9XChgtQ334lpqpepK9m1rk8OA49b+NXjU0iwRlLQC5cUk61ybYrr0VWjBZt/0ch3yDpNyQlDGsee+lnq4WNmOVA4qXDzzSOmJbXBBYUnBO+kdVA4VSMOSfmQcBvezlN9P5U4BrYxDfF63v1OqSHqPnUSpaes9+4dnOLt30pgQl5KuizTwuJWtJlHAZgnHiN1FDnb3HS9VLvf6ay3XDCCvra3hzjvvhHMO/+7f/TscPHgQ9957Lw4cOBCu+fCHP4yPfOQjuPfee/GVr3wFBw4cwNvf/nZsbm6Gaz7wgQ/gs5/9LH73d38XX/ziF7GxsYF3vetdMEmuv/e973144IEH8LnPfQ6f//zn8cADD+Cuu+66Vq96TaU7vbhhpMsnXRgECmHD9P/SVZICIm40xsb8sfxUASGyF0Ar7yeLiWgdI/DHTbRwZUqHwBeoCLbZZh4uKSc1vkv7nblP7EQtabx1TjZMcZUuFDqUv84zjYVehlftWQnW9XHVeIwR3babnudrHLA6Mqi9+36pFyu6HV4f+mviAbUxrkOhC7qiuzmYAbFkipUy2YgQLVtM80YLD9+ZrnW6462T4hu9JKKGlkVGwQMCDAM/zjps1jVGlY0puYjdXdt1nikptCBeBc+59BbsxjrkWiNLXIC5Ylo8+T218DiHUDRFCmowcI9ASIXrchWLnfC9bZjHngZBbq/SYD5g9rFWSkore4sbe37cGKyP6sA5rPx8YTvHjfFZJORAHnvuqihNGrmvrlZ4kOw8+F0uct+XAqSEJyw8eO3HcKnIQ97nQR7dtZLz1mH3ongtaiNFI4wTUM6CErMKcTBfMgea70kFkRZRWnBTV3rjyJ+P4832GetaFBgqa5yHBDogoPEgPKU6UGHqrvmguDvXso4RMNN6mlaeTC2Ixraz61BSZezW/YsYVgbrExYz8hZkv/751AtbFTIPELdK2ae0jsFYaUxEP8nowLSGfO9ulgSCfCongcJhHUalCRZkrRT2LvRb72ZctNCrxMJRWxtoUlSOgXawL3OtBwCe9I/yfxdwxT6LPNd0/Sl16RZk51wrEJvtmJV1SKlIgci0wqJXTjk/wpUq7unWIVASUmm10UUlSPu9ie9MYT+l/Ohcq6BIknLIecy201hhbCyzPgvsphQE7qVh7aFtme72S/e90vnUtSDTyESjFjtt0phY6j25NfcC3obKAB8fjDcdoVLdmkOp4jPjOzvJ5eLjS5t9O3z/Mi3Q+RU+75Llwx/+MF7ykpfg05/+dPjbbbfdFn52zuGjH/0ofvZnfxbf//3fDwD41Kc+hQMHDuAzn/kM7r77bqyvr+OTn/wkfvM3fxNvf/vbAQC/9Vu/hZe//OX4whe+gHe+8504ePAgPv/5z+NLX/oS3vKWtwAAPvaxj+Gtb30rHn30UbzmNa+5Vq98bcS1B727YUxd7qgJR0sD0Cbf8w6ZAhoISOzl0aIARFBb1mJp7XlLMi1S/JnAZZLwRXOtsD6ucT3ixtzLdcioAESqQXfTsR4hU0cO3LNt5r0CsDlpWtWlrAOWe7mnkci77xpkODWayOHmwSQDP05tSZq3M1t16LPhRCzI48pi974MudZolMOpYRme4ZzkA96qGp9+K4J90jJSgEwrnfOHJC2FtJg2LknlRIsBYsDFSi8uZwcJ1lLeheCc0DwEWMv3RnUTLbDGYVgJEHSIB0ZaSjdadSWFWmo5r61UpGuMlOlmgv0wDirOOdJO+P61tVjMM08Bac/LlKedUkvIUebBbRxaYBhILYwqHEajxoRiHHyvytoQ7c0CLsOykUA/D9zJY2aGCQA+Z24eKB0EyeSAL/UzrFcM5pEKgQxmU0rmwEovF/e5E2syl9g4qfQoYCqW1e37dHFUShh4lWmh29TGQqu8tV6lL6NFLfSpisUpAJ8bOG/3I62XaYowpQSg5JmGqm1UapK5Qutfz7cbfr7GjA0KZTJHtFYwTQcw2GhxbVsdY2AaP0spCuGeCuEUHpaNUIl8BgqCcgDYtdgLGSeGkxpFpjEoNM5slMFalwaUMm3eQi8DapnbpHukc519ZR1gPe88lDx2cUwmtQk89kwDr75xWTwUum3DIjjh3SsjZbJr64LHCP7ztL+4p7Cfk44Mykx8huw5mVLBmOLAfT0C5nSM0nsyA0c3K00q6feZgQTwwdI9FnLx2UlmjCmpXVT22M+8B+diakVnXEe3DbJefKA1xMDDs4oKCTnfgE93auOcikV44vUc84E/N7njtd5ExexNGj4ffBPXV/udVeusm0q/phSgvWcn8brS6NA1NPE9CKiD55J94/uuS6DgWNvO+IV7dtbpxeRyOcGXiW+nv3+Z118zC/K//tf/Gm9+85vxnve8BwcOHMAb3vAG/Oqv/mrooEOHDuHUqVN4xzveEb6zsLCA7/qu78KXv/xlAMD999+Puq5b19xyyy244447wjX33XcflpeXAzgGgDvvvBNLS0vhmheTdC0CdceNBMSDi5JmQKB0LbjdAzLPpIhE18rD0rbMSpE+i0E2tY35dvNMwNOktsnmrEIWBId4aKTcKEqiHAPY2YJM8D2pbeDFUnYVRQChuVZY6Wc4NSyD5bIx1hcgUDgzLuGcw9qY+X/FnVr7AMTdgzxQUs4Pm9ZhwZLJLNVLvl1Px6IY4bDzqbJoNdM65mm2rh1AkR7uBIpLRayCV1uLfpb5jCSxLcFaBLEgE4BaJ5b+qonAwTp4mokLluPMg8HFPEc/E3CllFjjhGYTKQDyfY5TnBe0UPEZlbEB/AXAawELsWjGrAaeWqJ4DUGXVzaSg4uW2ybZgGtjUTYGlYmVDNlXkzoGVTVWAgaZ7WLiLcii8AiYzZRQKZZyUbQKrTEoItjMtAR9Zr5y3mKehSwg1q+fQmss9fMA8lKeP/m9LNTCcTXOYvdiEcpj8zAHIo2ISnLX0sO5Y0Ofeg9KYu2n5yONLrfemsR9gWDLAUHhCkpPogRpr4D2sywAHSrDOtkzKJFXHTmmbCt/Lxsb1nVaYZJ0F1rogiQ/n1ovJZ9w3alQaCxu2NUP82pSGRS5xlIvw6QyIfBLa5/qy0nGFw20qGK0BqbvxP2EabjYNwSdDtH6zHleaIUTaxMY60LxHL4KS40DQnFpnMXYxGwu6TinGRPSrmC6T0o0ajCtW0znmZZH3g6cpHxuPjuk9MQ23r2OYsQ9LaXX0OiSSvor1024D9oKQKpk874ta2diHGDwJ68NmVgSxYKKRDDeOOvPlvg8Y2I5eAdRDuMZNf0O3GuV8hbqbQBjd051ATK/31XOGHNj3HR6P/Y393fnD18TfpkWrsf0+ar1+bNLm7hSDvLlVvm7ZgD5qaeewq//+q/j9ttvxx/8wR/gp37qp/CzP/uz+LVf+zUAwKlTpwAAN9xwQ+t7N9xwQ/js1KlTyLIM+/fv3/Ga66+/vtWRSikcOHAgXNOVj3/843jTm96EN73pTTh16iRWz5/DmdMncfLEcaytXcDhQ09iPB7jsUcehrUWD339gdkv2dHYT544jqqqUNc1jh55GsPhFp547BE0TYOHH/o6AODBr97f+veRhx9CVZY49OTj2NzYwPFjR3Du7BmcO3sGx48dwebGBg49+TiqssTBbz4E64BvfD3eozEO49EWnHN44rFHUE1GOH38CNZWz+PM6ZMYrp5GM97AyaNPYzweY/PUU4BzeOqRB6EUcPyJb8A6h7Vjj8A5i9NHHkdTT7B59ihsuYn186dQbp6Hnmxh9fQxbG5uojx3BAu5w1OPfgOZVjh7SHjjJ5/8hrjVzz8NU9fA+gnU4y24zbPYWD0L29QoywnGw00cevJx1FWJxw9+Aw7AY9/8GoyTewDAww99HVVV48hTj8Eag7Kc4Ny5czh75tS24/TEwQeRaYWnH3lQeG3nDkHD4ebmDHZnFnrjFBbsCLf1x7hRDzHZXMef3lthd97g9b119LTD67MzODes8ab+WQwrgzcPzsE64NuL88hsjVv1KvpmgpflG7ghGyObbOBl+Sb6ZoLdk7Oo6xLV2adgLPCS8VGhppx7Cv1MY+34Y6jrGnU5hrUGp04cxXBjFRvnT+Pc6RNoxhuoVk+gLifYOPkkjJVxsQ4YnnhUNsqmhLUWS5snYJsSL1Nr6NUjjNbOoF9uIK+20BueQ2FL7BmdhnYGfVcBCli+cBjOAW/IT8M5YGXrOJypgbUTGG5uYKW6gF61gXJzFfnwPAZ2Ard2AoUzyC4cwaDQuGF4ROgC5w+hl2lsnHgMyhlU54+gHA+xUq6iVw9RTNagh+ehqiHc+ilo59BHDWMt6tOPo5dr9M8fAgDs3TyKxljc5s6iLifYNTmHXZhgV70ONb6AJTPEjXYNPVthYesknDXQ55+GdQ4bxw7COmB84lEY63BzfQqZa/D/Z+9PYzVLsqtgeEXEOecZ7pRzZlVWdY1dc1XPr932JwZhGyMPSCDZYKllZEvdiAZkjG0hAaKFbYEwyEDDD4wAj4CwsBBGsuU2WJ+MKX/wuqfqmuesnIc7P8MZIuL7sWNFxDn3ZlZWu7tQQ0WpdPM+9zxniBPD2nuvvbbeuYT9vV1g/zrUYhf1/iZgW2jvoLYvYrlcYn7lVTE4r70iFQGvviq0jq230LYdjtdXoNsa6/UNnDRL3GHmKBdbUPUMevcyprBY3b8M7zwmW2+IysDVl6EVsL5zDs45zK++DnQN1hbXUXVzdPvXMG52MW5n6HYuo7Q11udXULctJtvnsNe0uGspORbX33wWnfN44blnUPgOaucimsU+2p0r0MtdqMU23N5VzGd7uHTuVdiuwXwulJ8vfeH/hVLAtTdkbl479wLgLKZ7l1HYGvvXL8IvdlEtd6Bnm5jv7eDq+TfQNUu019+AdQ7b51+AdR7nX/4KtAIuvvoVlAbYvfwamnqBi2+9DmstXNdguXsdfrELt3MVqlvAbr6Fumlx+Y3nMakM9i68gEll8MaLXwYAbJ5/Gcq12LnyJtrFDDvXLuLS5SvY376BrWsXsZztYf/aOezPF7jy5otQULjy2rNw3uP5Z74gkaorr8I7i/2rsta+de4N7G1vwtoWsC1ubN3A2uI60Na4x12Dgsf/Z20Li9riY9VVaKXwx49so21afPP6Hs5MHN5f7eKuicXDqzXu0HNgsYtqdg2VbzDau4SjUwPbzOEBvPHil6G1wo1zzwEAdi+9Atc1uPjmq5jP9rB19QJm2zeweeMarlx8C7P9XVy/8DrapsG1t15CVWjUl15CoTVee/6LAnivvw4Di3v9dYx9Db97BV3XwtkW58+/hXaxh/n1C2jrJRZXX4f3aX9648Uvo7Uez3zp8/DeY//K6+iaJS6cex2bm5u4dPECurZF13XYu34BXT3Hqy+/CNt1ePn5Z1AojSthLX/uy5+HViruTxfffDXuT9euXcWVq1fS/vTay1gslzj/2gtQSuGFr3yht8c9++Uvous6vPLSC5jN9rF77Ty6+Q5mO9ewde0Stre3cPXim9Cuwf4Veab5bD8+k/MIY9HhrddeRFMv8Obrr8Iu9rB34wquXrmEve1NXL5wDu1yjtm1N+Fsh1de+Eo8BwBcff1ZaK3w5ivPoWtbnHv9FTSLfWxeuYDF3iYWu5vYu3EJtp5h69KbaOoa2xdfEQPgysvonMdrz38RSinsXHwJtutw4Y1X4NsFtq6cx97WDVy/dhnb1y/DLvYwv3EBXbPEqy89D++B5Xwfzntcef1ZKAAvP/clWOfw0gvPYbmQZ9re3sKlixewdf0KNm9cx1vn3oCt59i+9HoPR7z07BdRGI0XnvkCnAfq5RydtfDbF2C6Bbrdq9jduh5xRD3fR7d1Aa5rcfXNF+Gcx4vPynt65ot/AA/ghWe/3HtPb517A1ubN7B1/QpuXLkY99ymlj23aTu8/NyX4JzHl78o7/qZL30eLjzTYvBMV69cws7W5tcMG3Vdh8Vijqau8cJzz8Tveu/jOZ575kvxmW6nvWsUC+ccPvrRj+Lv/b2/BwD40Ic+hJdffhn//J//c/zlv/yX43FDC4FZq7dqw2Nulf16WPvkJz+JT37ykwCAj3zkozh2vA/Ajxw5CgB46JHHAABPfuDDh99Iz3GhcMedZ1FVIjp/9/vuBQA8+NAjAIDHnvwAAOCpD32k9/ORx54EANz3wPsBAGvr6wcuw8/e/8jjmNUWT33oo/Ec5zcXmExXobXCgw89gjeuzXDq1FFJqCsNrrW7OHVyHdO1I5iMC6zf8QCube/h0Sc/BAA4++ATOH9+E+WZB6GUxun3vR83ruxi9dhRnNgYiwzW1hJd22J9YwpTGUxO3oOTG1OsPPIkLm4vsX7XI9hcNnjfQ08Jn3fjbsyvzdGt34EjR45gesRjNClgliVGpcFkZQ0nzxzH3rLDAw8/jrc2F7jvEfnuqfsej/3lnMf77n8I6rLGqBhj/cixGPY67D09+sQHcWl7idP3Py5eq1MPQO0tcLk8jW+aTqE27kCzOcMFZ/HY6lFs3ljiy7sjGKPxpcUUZ0YFnnOncHxhcW55EqPK4f9tT+LICvA/dtfhPfCV+RruNWNsmqPYVR32Oo3OjzAtxliMVzCGRr12Fm65wJXp3TirFZrj92FcGBRnH4JXBmU1gdYK6yfuxLJ1mFQGd5yYYnl1BleuQpcaq6fvx/b+HMff9yhevriJ6sz7JYxXjOGhMF+/Ey1KvIWjWKsmaCYVTq5McH1ZA9MNdNdnuKpO4pQp0JkRjFJ4a3QXlJrjWX8HxgCujO7AYtYBR+6EHq1grzqK45MCk/UNtF0JNBbTY6cxLQ2O3vMwLl/ZwuL4fSiUwuLovThqNCZ3vB9bdYO1U/fCaIXZ+Bha53F0MgKMaGB31QqU1miUKJm0x+/DtDKYH70HaqfB3pH3we62eF2dxD2uwHj9NOaLOYrSYLJ+FMv5DqxZwXLWYba6hhPawJy8T0pe3/kw3PVduJMPoG4dXlOnccwU0EfvhK4m2C2PorYemKwAupTNd/U0vC5RnboP+8sG/sQDaK3H9OzD2JsvcXl8J5qlxY3RaRwpDPZHx+GMw4UbHtX6STRtCz1dw7jt4EZ3we038Cfux7KxOHb3Y1AXNnH07kextzdHdeJe6LqBXT+NcVng7NkTmF8RCcBmZQo7r7EzOY3aenTH78Ws7XBxchdWlII/+QC6tsPZ+x7B7qU9dOt34MSxo/BrNVzbYf3oOm7oKYrRCu4+exLTcYFyugLngSc+8BEsGosT9z4O5zzO3v8YduYt3JE7sTJdwbTagFt2WC41ysqgmKzhzJGTuLS1RHHiHiilsH72EbTO4Y4HHgeUwtkHnsCkKnHs7IOYTKa46577oS8YaGhsbJzCcreGWT2KlWmJfV9CmwJn7n0U65MSx++ROXr/o7IOHr3r/VidjrBx+h6sra9hchRYPTLBQteYjgrM6w4TjGBR4Oz9j+CVa/tYv0vW0gcfk3l+9OzD2Fw2OHLmPqysrGJlZRWb+w1MXcJ7jTnGuFYcw263wGvVSXjM8fTsGBZNhwvjs1DqOv7b1hE07Ryv+BP4vpPH8OvPbmNSGVxaFoBfQTdaw9yPsbG+hnrtDihtUI1X0FiHsw8+AaOAk/fKmnXkzvdjNKqwcff92Jm3KMerWBsXmI5EMaUwCsfVGIvGYuX0A5hUBkfuehTbezM0x++HP38Zjzz+FJ555gIumJM4WRYYHd2AMQW00zhy8g60e9egRqswxmB88l4opfHoEx/EjX1Zf63zePIDH8YX39jGsbMPYDyucOr0A2g6J2vimyUKo3H8zN3onMfp08dgtMLdDz6OczfmePCJD2HZWjzxwY/Ae49HHnsSnXW4854HsDYtsba+jlndobMeKyMjcpmra9iZt3j08SdxY7/B4099uLfHPfTYU9ivu7gXHj9zNxZbC0ynFU4en0ArhTvuWsGRlQpH73wAWhtMV4Ryct8jTwk3/+wj8F7hzD0PYTwyOHnfA7j06g2srIxw6vQqZnWH9aPHsLw2x+TEPYAyePTxp/DG9Tnue+QD8N7jxL2Po9AKp+95GGVpcOf77sfs8j5WV4/COo9ZbaP849r6OqrRCEfufBC4so3yzPsx7yxO3fcErPPYuPMhaFPg2Nn7sdxe4MyZ03De48TaCGZa48rlXayNj6EoDe556FGoS8BosgrngRP3PIZFY/HkBz+Ma7s1HnrkMXjvcc99D8R9jUo7x46fwKtX9nFk40EURRFxxBNPfRhlofHQEx/EsnUYjadQSqFZO4PlTg2/OsXqkSM4cXQCADh3fQ515E5MJmOcuudh7C87PPzEh7C/7PDokx/C9rzFY098IOIIAFhZWcWisZhUBsvWYlwaHDlyFIvG4qFHHsOysbjv4SfhPPDUB+VdEytxT86fCRD5xtVx8TXBRsX5AkVRoBmN4rFPfegjsM7Hc/DcvNbbtXfNg3zHHXfgscce63326KOP4ty5cwCAM2fOAMABL+/Vq1ejV/nMmTOw1uL69eu3PObq1au9MIP3HteuXTvgnf4/peXPeoCS4Pu0h0j0D7/zZ9lL6HKZ3Jbw+lrrsT4pohQOFROs8zEjnedhqJxcuzzsO69TlTrGnLwPJVmz8IzzKfzYM374U6m3TQiIShxOFm9qXRYmlf8FJFyus76i1qMOvOxZ4CbaEHY0WkVN2c567DcWVSE0EVayIreThUZ8RlEAUsIHKRYeSQYo54XH8B36CZbDggOlloITOlARauswHRUotc6q3CHIkknX8x3nRgb5sUx2M1rHsFSpJUluVBqsTwpJbipM1BweaRMTWvKwJKklQu1QIVEw4yF7SUYTXVkJSzJcXFvhUnPMaKVQKGAUw5qUg8toAk6oFbkGsYKKSWZMTOT1Gf7OI4PkfxoVuMPeB5UKSTpcH4smNvWJFRTGxkQeaKmlRPGo1CgUcGxaRYqBgjxjGUKiHInzjHfcWTkHqxaWRhQ4Ouexs+hQKBVDwJReXBkX8ffDyHa5f6AwohRQaI0ycNU5NtivB+kZLEuewsKr4yImBPLZOHZNuG8q3XBtmlQmC3mneTwdJQ62c0mDln/3kHFJulSu2MDcCl6b8md5RJW87pw+opTkUbx8fRnD09Z6rE1KnF2foO0cJoHbb71IJTp47NdCfbmx3wRqmE/rRzg31w+G5KXfU4J0LmXWWIfVkayvpdZSoMd7XNmpRZNby/yjkhATFDsnXNxcUYFrgw99N1tKwnFh0lzOZdV4X4nOFagGSmFjWsZEPs7pYZ4LqXBDWh5wUIsaOLhHMWeFiWtNlxLKSGvJ3xf/xvEY1xokegHXWY6n1rqeJBnX2liW3UsPdt5HbeL+/fUfggmhHGdsLA6S76dyr1l/+aRlneYvbtl6+tNKHTg+8uMzesRQBi8mSAYeca4PxSTX/Lhb0RGGuvY8xzulWLwTwsOt+MpDOtHXqr1rAPlbv/Vb8eKLL/Y+e+mll3DPPfcAkIS9M2fO4HOf+1z8+3K5xO/+7u9GPvFHPvIRlGXZO+b8+fN4/vnn4zEf//jHsb+/j6effjoe8/TTT2M2m/V4yf8ntMTTS58dlhTBhJC8RT5U+Mnykt6TZ+moEiXhy85FHrL3PvIdCUCWQaKrDNn6UkwinY8i6vuhjC+ADKCEksfINmafAEsCxQMtzbeZEFz0PYCjK1VUJhgVAiblnAKYWycAiIuCgAe55qLJ6tRrARKs1GSdw7yVimejUMSCQveVEd4pi3BEmbLwb4/+Zn1g49CqB14B4Y/nGpb557Ouk40MSjR0JwXGxmClKGJhjyqAC40kZD8uVLxnG4A8C1mUAaSzn0alwbQyuPPoBKNw7sqYyGUuCxkX7MdoCyFVZ8w3BBpgXOBLIyCc/GWqN6gA8IuwWbGClRhSHmNjAueW0nYO89bCIZO8A2JxFwJ0pZIxljdRAlE9Q5AGTlVonJxWwhW2NoxLScgBpHhKZTSWweujlMKDZ1alPxB0t7WOoF6H+1iEsrhdMIAqLXNJhfew7KyMt7qLhsj2vI2A9ezRcX8ODVoyWhCUMFR8v2JYhQROgu9wLAtx5Hxano/JvQEjxxbnQKEjcM2NkMg31irqNo8zvi0lvGgARU3q4PlUqs8vpxEGBF62DUAnzDPvU9GS1rrexte2Dtd2l8JZD3zmM2slnr5wA9Y6rE8lX6HtZEx5D8xrqZq2v5R3AZ+DzsR7pZIPb5WJa977KBEHAI0TY6o0MjZYre3S/gLTUkdObql1NKhEWURk56g1TUWSmJjqRUKOfZ2rUuSNqhHEV1zr5HmC0yD8flD6sZ+3opASBKkSFI91B/NKqNbDa7FIB//WB4fJYOJphnsZEAqG8JrwyPXV45z3wDTkAPBcNKJ7HFuV1jExgoKDyPcNA55XQcWqfFGJJO9wn36wr4ec4uE2nv+9GIBvPi+/l381/3fsD99/Pu77w2TUw1ruvBmemGvGO1GyeDvDIG+cNzf7283aHwY4v2sA+a/9tb+G3//938dP//RP45VXXsGv/uqv4p/+03+KT3/60wBkYvzIj/wI/v7f//v4tV/7NXzlK1/BX/gLfwGrq6v4gR/4AQDAxsYGfviHfxg//uM/jt/+7d/GF77wBXziE5/AU089hW/7tm8DIF7p7/zO78SnPvUp/P7v/z6efvppfOpTn8J3f/d3/x+nYEHvaj4gh4PTg1Wy+B3JvM0tYv6N3gNmvQJBHicAAQAYl1QRSN47Al9K3hxMGBEvh1Ei+J9b/bwuK+axnG5vYmdgKp9QbzfsCepy+R6jRaJsFirPxWd0smFxkSAwVUpKzVLVQbLb+4VWZNNWqAoVgaJSCuNgdLSOJYL7VQaZ7Z08CekdAbLusGAFAQgTmPLkPkASoRadjRX0OiuZ9uPCiCeZ1aJCIhjXN6MUpqUBi3DIZ0n9gR5jACERTWNjWkrFLq2xXpWYmFQhbVKZCHgPJHNEgwlRroklmrdmDTTkHsbhfJT3ol41QFCWSssC0heTwkSQwA27caG4hEpjiN68CPp64yWpg8T7y0ADi6OMC1Hx4LvldwulY2GVSWGwsDYkbkl5asqjGSXeZvYnn5WJeT4Yh+NCR0mxcaGxCFJzy9ZFQ2N/2UmyXqYPzXvvzYXwP8em0QplAFzUMqUhkRcsif2SeQJdAAkJQKWkPJW9JxYS8h6hCqfc2/6yQ2F0jCa1mboAE8WiVnV4ZwoCdKxjglxWVVCpOIeUSiA0Ap1gRDU2lTBnQp/3Hl1nsbdoxdsbtGBPrZZ4/UYNax2OBam9urWYNeLdJKiv2yRXSfDERi9i7kGelCYZGNnc6JzH3rLDpDJSJCSsxZvLBuPCYGQ0xoUU0aC3U0pmU8tXzkMPtc7GPD3xZW6sDEBDWeioPMO/8PaGnkQ6B9goHZgDRap6DMEcvd55K0xa15VKSZeLRrShc4CdJ/vmIBpAT3GBxgANq3YQNcgVWZxPlfI6Lx5hkSoNwFH1Pch0NDCaEuUrdUpEVeFh8gp1PW9u9gz9RED5fAjq8usXwYFwWDsMKNJxkL/GIjNKfNaX/hCwnjeePamZJLk6Xvod4OMDSju3asMoRe++vnoMfMv2rgHkj33sY/hP/+k/4T/8h/+AJ554An/zb/5N/ORP/iT+0l/6S/GYn/iJn8CP/uiP4tOf/jQ++tGP4tKlS/it3/otrK2txWN+9md/Fn/mz/wZfP/3fz++9Vu/Faurq/j1X/91GJO8D7/yK7+CD3zgA/iO7/gO/Mk/+SfxgQ98AL/0S7/0bj3qu9bo4TkstDWkXfi4GKQNFhiGrMJi4X20bk3YiBvrsGxsnJz5eNQqSS7J5oS4ePA6nZNJyfBZYVQPtNNbxE0vP3c+iXqT9zYmxXBxNUphdSRgMg9LttZjtdIxY306KsJ3Uka3Chs+qwZqTb1MOcco0/nUSkCr9D9imNxk/Q0kDzI3a24A3FSFGkLPR+qL+J4hC/K0MGhsondY7yUb34jcGDV6mVWdL8iTSodQuHxWmgT0x6bA6ki4w+JtFIC8ud9AK2ClMlgpi/COA1UifLcIxUTy60koOnVAVYhHfdGIR25UiPSZVnIfUqlQxz5SKmx+yECv9xiHcuIaQlnwSFX/gLRB8Pd8A+X74lijR5RUCd7uuBCgPi4Mduo2hkd98Bo5JArCpDBSQbIRfdutWQOjkhe9CqWFWRCh1Aq19b17HAXPfKGAcWFQh8IoTQakhZokFf0ubS+jWgSbR7YWEPCoNB5LrSP4FQMq0YBogBdKD7yPfWCSPM9p4+c8IgDO27wReToCWDcADovWxiI20SsX1xEfvPL5s3Au+TimKE3HyAGNGV5vnBX06Tof1zYbzrFoHbbmHaz1MTJQtzZK6lEyTOT/hDLkkRQqZI0TMMsxohVpZ73ugA8G7/6yw8qoiPfmPbDXWEwLmb/jwvS06LtQrZN0CHr0aSDxXVDZqDLJYB0MCZRBopCf05DaXbQYOiz9YP3n8w6fq+1cz0sO9I2FWBbepDLbNEidT5XpCFZ5X8OWK1Tk9IB8PCbwnjzrfNac5mCdRK2oX8x7jR5kDA1nHzuT714jaYTbMHhzbfEUOk3PoLXqFTK5lUe0Mjd3isUoBlJfcM25lReae847xZncr3kPCre1LceW60+/XaMhc+h93OJ7fxjli3ctSQ8Avuu7vgvf9V3fddO/K6Xwmc98Bp/5zGduesx4PMZnP/tZfPazn73pMceOHcMv//Iv/2Fu9RujeUQwxHZw8T1odbWdgxqZ3jG7izYKpFPuxnmPspAqco2TzWEM8W7AJ4+gUggheY9xqaTsrUv0Cy4kpdahYEa/JGduXRNccaLlnirgcD7YrRrpAcvWxo1/vSoxaztMkECpdR5HJ4WERK3HidUS2wuLQstiOjEaSjlMS41R8BRTn9VosTSrQsAF6c1jhoKdj8BjCGC4KEWvTXjW1oohsT4psTVro3yUR5I/k3cnm8qRUYU3d+dgNbfO+Rjip/B+qXMPcvLwjguFptBRUmqkTfTWT0uD42sjaJWKdCwai1ndxdDgajAmWudwfLUK8mM6GgS90q8uGXAKwDiAchZZmJYGR0YVNBTKQqEORTu4WfG+CLmCg1D48XsqRDYObh5aJf621lLlTrtA/dAHvafU1OUGz74gPeK1vUX0VHv4qEecFw9oncOs6WC0UIgIMCmVxyaUEYXF3MU5BQidRPpSRQNoVBgsrUVpigiWPYBKG+wHSbieZ5x7skqUCPZ/Vej47JyrRuuoNS3h4iS51YVjuClyj9UB6Ft+ATktSji+vH7uWeysw8rIYN7I/UlkCz19Y1am1OGekp5y2vT5TIxyTSopmGOtg4cYGQQAfNb1sYkgzDmPpulQlVpkupTC5b0W+3ULG6pUAnJfdecxLhDAu1RHZMkZeg/z/rW+D874SnIPnIeMo7p1uPv4FBe3FnHOzFuHaVGgMjJmC6OANvGxaXuUWrzqlHAjGOfappC8xLxu/qJEd1iHQjDp/pYhKYst5UnkXFb0zsnvdu5gVbiYtxLWKKV8jG4BqaiJ98LDN1rJHFRyrzkYjgYz5yj6ADqPOOb0D6VwqAdZgLNI55E6lJ+L30/60L7399zpw4qxzicnUxuuYbJxwEbnEefUrbywo9Jgd5EioLleMdfkZAwnKcd8z80jQnyfjOLyOQ9tQ3wBRGpSNFbfgTtXZ+/x7Zq8r8MPvB0xh6+mvaulpt9rX9vmkbyY8TPvDwyhXADceRwIcXkIp44bPhdd5yWUnRcKAELpWWfjAkLeGz0rwmHOy57K/6XWsapPVeg4kXLL0Pu+pauzjRgYhPtUn8N7WKN2c5slXpycjGIVLSBVHzo2HkWL9qETkzjpvIckW2mN1ZGJE7EqAvUg3CATAHlPo5C0xWtIMlv+rvLnTkBOgYlaLm7q0TOcGRIEzEYrrE+kIluZhQabUOyE9JHCqOi5lPsX40G8UxrTwkCH5+AGMS2NeNCVQqWNlOFedlLeNpQgnoYNtHUON/abSLFYGRUxwY73JJzahKImRdKD1ko84evTEkoB41IF72ryIAOywXRWNlkCgjuPTvqgMxsDHO5lBnbHgVagVNrwCqVRaYNC6ajNyuIdRgstotIaI6NxY9b2Ntgy8IVJlRmXBtY7zLsOGiqWimaCIkH/td0aOvQDDSkZL4g5AKVRmBZFiMyw8qAKAE/uYVzoqBGsVeoAjrZI01GJa0pOfO5VLAMgUQGBKCVAfZwl1vG+iuj1SvMo8pEzYELPrgnzpAu61/SycuyzdDXD8DSWadQAiNx7pRCLK5AOteiEH7wyShENGhB0FOhw/ydXSngv+r3eezSNw9q4jKBva96hbqwkuTWJu8yKgrUVMCPvPI235H0Pa6fLKzni0OZcPzIwKlPZ62XrAg1GjKQ8J4FgU7zDekB7SUYwjZ8qJGbm44KN+SUI3mi+6yYUg+F9ci8hqM9b/hvXsGGjHryHFJpprYu62Af6JawjPQ+yzqov4mCIfvg757j3KYGORgPXX85ZevLpcIrOHaRIIq+hsveMMOZTInGKOjIfw4a1DxBDZXjPjGKSs34rOsHKyPT6nsexVDT7Uik6BmSu8j3mSY15G9JQhi3HEfE4ZJ5zrQ4YRG/XGPG4reZv7Vm/WXuHt9T/7lf/1ffa/+5GL2Y+ZlzYvZJVj8HfD2bsWy9KCy4uFInbPA2c0s73ExmawMsFEL0I5P35CLQDgAihZ4KIAx5klwpEAGnS0AC41aQbgv1h48bhPGLRi9Pr416f8F42RmXc4B4/sRESs+SYlUqjLDTWgkSTUgqjwB+dlDp6G8UTI31VqJT8Ri9JzvViXwLpfTFczcV7b9nFRBd64DRSBSbZRMTTDLCQBoGIj4odhRYPMD3IHhI6LrT0y7jUWCkLKJXCrVoJ1WR7LvzMUaHRWR9K24q3dL/t4r10zmN33sZF+uT6SDzXUYmDVd7kWRUQ6RnkpfN3oxVWAvCmF9chlIVVidddZgssn935RKcRQX/fe88EVUohglWjVeqj8OwOPlJSmLAnpYUVZo2L3j8P4aZb74XeEQwq60VNxGj0xn/ypiav6TRwmgnyS6OiMUHPP8d65100OBiyHhsjihqqz63ue7kQqS9U7sjBEO+RCY8EIEZL+d88mYreIhoqvZYcWJLlH+6bSXj0qvUAlRIQoRViEiqNQ16P9wgw2RG9uVEHDzLnnPNCi3DwB9bBI6MqGv5KCff41FoJG0DKsrUxkkYObxs44J2XpLoivBMaDDmQ90hUD1536MEDENdKrpc39mpMKhOURVhmWgzfSWF6lDHyPo3qJ+A5n3jj3B/o4RzyS/PfSN8oTMrd6EIEJ+97FW4830MODAF1eOjchT6FTyXN+f6G9+R94phzTA+VFvLr5omE8n1xImik/anfd/2qmATHfGdcb+lhpaFxoMwzUn/zPuj99j5TvHB9tYoc9BdBTaPIAPLNkt1oRMbnDD87SypPylmhkgzXN/bZYV7bXJ3kMGfsYUnx3J9pzLwTTjGf5XbbkMd9u+f5w3iW3wPI38CNli0HLq3hfDjEQc0f2YIsv/sY9qSHgODOOlq0CYhaJx7g2rK8bN/r2VpRsGCoWb6TPMgMQ6vs/pgYEkPQcfPwcRM8rN3MS5G3IbimlFg8h0qhptraCB4+f3lL7jmAu7WRwbhQOD4tI4d7ZSygdK0Svum4FE9sZ5kwlDx05P8NS+EOb3+4Ac5DVS+qDnif3jk35VLrmDREcMe+1Uo8E1IKmTxp+d5KpUEViZVSgFERFuuqEE/zxqTAInBGJ8YEL5qTqntBKWJWdzE8KWom6V1W4boxZBu80Xx/a2UZx0KhFNbKErNQGnx9VMQFXvoDMdzN9z4uxJtyfa/u8R2LTCXCOvITQ0hWJbCmlNxjopsYVDpFCUalDhQC6ddxYULp9BRxcd7HSEu6vgphVRe9WJNAk+Cze0g+QKEV1isZSzToKiNzRcCPjmF8o5Nx4ODj56R0GIWbblT8nKHfxvoerYQe80lBMJwA6MrIJK4xBuH73nziT76zQ6ph+gQq4/fCDQw59gSKjORYlxLjcoUErVUcG/zd+ySx6NFXEthv20jDUAroOoe7N0bidDAKdZAIpHcXkGNbKx7xZedQahWTMpVS8ZlkfvkenaEHoNDntJJm5bzH7qLD+qToRU0a6zAOkopMOsz7ksmQNC54DRqn3BPytWU4OnJjhN5k58mlTsCb75b3C6T1Pz/nzXwa1icOM/cbjqE0dvrnyYF2bjApHAQ/OXiloRD72qf1nvkJeUQuV8/I6TIE0/x+oVTvneswPovs3tif3ntApQqVOc2GHZYURISWw/sY7hV5c70xID9prOVAXdZB2YdiVUQ6VjIvuFKIz7hs7TsGuvAyVw9T2Hjbr97iOQeXuOmx6R3f3rlut70HkL+BW8S+4SdLrw4XjXxN5aQbep27wHl1wQvGDZ7fyRMraite4GHynPfJCu1CSV2fLUJGi1es8z5m/hKQR1mkzEKnNWxuMlmHlvTNGhdFblyXdpZxQunwdwdgp25jaP3VG0t4+Ago18cG00rj9HQkJZu1wsa4CB42jaYT5YJJEJZ3PoTHtYoliwlo4/tDRonJFm8ea51H3VpURsVEFm60fCfiqUpyU+OiD45oNAlQ7ZcLX6sKaMjCOi0LOCQtWSZCjUojHmilozqACx60zom6yW4j/PUuRBCY8LIzb+WaRsMo8dY2nYB1BQAKWKkKCfuHDaY0IvtVGIX1iv2bQBO9hC4YCqvB4zyrbaSXAAJ6h54v65LCCL3/VM4gQGYSJsdHGRIN6dFdLQssrUPduhi2tz55jLmg0vDgRkQ96sbZ+O5t2JSNUjg2kYJCo3Av41Kuxw2OofxSK5H1ojEZNunkrQoe8EMQCoE6vYNNKBOfh91HhcYoyIrR61iaJPunkZWWDht/vt7wX+znHITkje+P3yEIjsA7ACnmENCgcD5Jdmklhiev12QAuQwUjkixCNd04XqX9hp5f9ajCFSI1zaXcs1SJ+3l7NatdWgCSK6tRaUTv5ldkIMgGqJck41WUZuZ4IneSbZFY3F0pYpGm1Iy10qjManMgSQo58WAohJJngRXmKTiQMMmHwt5y5OkgUARCgCWx7oMyOZrGQ2mXnL14HcCl17+hU8qQENaHccXvbG8Z0Yr01jpPYZE8DLQS6oJD6PR11ofI5veJ+ohKVDWJ+91Poa5P3GtJlDmeVNUN0V3I8BGoj/AJ3pCWaTIF6lHomeMm7ahd5l0vBzYAynyVWndM5AkEtdX3eAl28H7uJ3GNSjSs74Oje/psPb1uuZ7APkbuHGD5pjhZpA35xFDIPJ7n3sF9HlhBKtUaqizUCMgAJgybj2PWaAW5F5j3pv89BEgk+bB++O/uRnmXEdmI98s3OScvyUPOXF7k2rB5rKOoJuLnPce885GTutm0JctjCgjTEuNlcrgzvVJyHLWWB+LF3LZWXReAPK0CtnxnuE4kfJi8hwXfcr75E8VF3GCD5cSlQjgyBlm/8IH/mkrkkjjUgetYDkXPf/iQTYYlxLKdxDvrQkRgtWyCJ5mFceGVojJeIVOkl0+gJQuRBL2mg5F4Nd67yO/e2/ZodImFKBQUblgJJ0Bys2ZANqo7dtYh0IJ/aLMvM/ep0QsgrWjIwGWbecix1grAZp85xw6ic8dFtqwCeaycqOQyJR7QI1SGBnxUE4qg7qzPY3efNxHXr5OIWYF6b9RoaMOs8++ZzRiNSmtRPpuWhi0zoXiEDrwjuU95tzcoREgRobuzaG8cQ44nzi/+XsdhzGSqEFSSGQeiuXEsZp51w4DXhHU+gQ68nvIgVfOl9Wq33dFZqx4LyA5Jb0lcC8SXelpqdfeZS5LPqNSCjfmXfy9LA2c8zi3uRDPb6C78LpFMFid82g6H2lilBr0SOH43AgjMOcYoBEjhofueS8J5hgJKrQAQFkzZQxK8qHvrWkOiAa4Vn01idL0t/feWjPAE53tr+d8t30w7uOcyk/A95djqvx3cnzlHNlXw/UIkEnLMLpv4B0WgeC6MQThxqRIDt8h9xA+NxUjvM/pHGkvpSNFniPnegdAqw8qAfG8QAK5dEyJ04BGYZqXXOdHYayyP3JazmGNa0f+O+8xfyYgcI/1QWpNbtTJc/b7+zCA7N/mngAEsH/z4w5r7wTc3uwW3iGev+32HkD+Bm7i+U1DZggUyfcqTZKqooRb5DllGwd8SliYmAIewH5tJTkIMjjrzvWy9dmYDMJF1IbNyXvh7AECgJuQxJcnp3FzYFY9RdZjNrZSvQUhX9Ro+d+ssUAJv6cB7DWdhG6zzF/rJMmHC8MsVMqi5xkANsaiKey8z8JVwO7SSqnVosBKZXqWbqlVVGqIfaXinh3OISY8PU65skBnw/sDYiZyoVXUhPUApqWOklYrpekpVTBZhAUIyoJAVgAoF5aNqkRtbeQZU3ZtVtu4adEzopQKHFHAOoeltaG4h4+AGxDjalwIMC+UxsgYtM5jXJj4TmKSUdDkra3I77F/yc1j1vuiE2oD7+fYqgDkzvmop6qUUCWAtGmRDkCaQd3aGBKfFoWATSOeZSbRaAhgYaJQbR3WJyUWXaqeZYNBsL/skjcpeJlyLxRBK4vopHknRhTHEt//SlmEYiGSsEXv6KQwfQpL2FypPlBoFbWVD2scy+KJFS5zrvk9KjSmgU7BQjWjUie9XySOIw3tA9cAvWzyO6UI4/czD1sClCk5tDQqbuCS+BroA9kaQFdADny4Fg65pvyNa4jRCnt18OR7j9FIPMGbe7X0v0lecqpR0BNbdzaAZB8SOJOhzesxAsQLRwCVASqC5Rx0GK0w7zpsz5qo/jIqZC0ttcb6pJQ1FQlwA6JgwveSA60kHYb4rAQyQy4vAWP+NjufVA34OLl8Gv/CuZiD2vz33BkDnzyu/D7l3BQSWI5UCX9QNzmf/zkw8iD9LH2WO1xySsNQWSTfB6mRHr3BYR1mJUKur4VK+Q40EpxPc5J5PEye4zvhu+BaNcqijuGRQWrGYW3R2J5jiWOTEcX8PRqle1G42Fde9pM82hHHsE/r7rDdDIfmR74TesY7oUQoLjqH/u3rg5DfA8jfwM2HxSMHG7nXijwrKhlQaYIWZ5JzS+fkv7lpUnKJ56VMWw5yc7BNj1uXfcaNa1yaLNPfx+vR2i6M7i+OSBPyMAzMj4ZzJp903CCs9zHst+xcpCt0PoXA2ixju41FCmTyNdZjpTS4tlsDEO/MXqimtVdbtFY8yCsZOJFFVEelBiBVJTsM8NMQoMXfZf3EBA6jgxqGT1JvK5UoIBgtoLcKtICY+BGS8wotwJClaenVByTzv3UOlVEx+18DQaJLnoMLr1YpHNk6j2VnpXAGyIWVzYFV8FitbSV4qakMoVRIYlMK41L4z8vOxcS5mjzPTCuaFcaqAGKoo+zCcyolGskjo6MyBoAog1Qo4fEy2qKVAEqPlLxHqoZS3LARQarwwl0vomG90HOkGE5KYCNPnACQc46VKlOUQWFeSwSgdQ6lEU4yk7MU5F1rRTCfwrejUvqdNJhS66jicLPGpNic+kTQUxU6ljzWYfNeGRW90uwqeMZoaB+2NyWuaPpjzh2md68Lyb46jAGGadkYeRjOGeLAnApBbna+scfvRCAtc6jOtOBXxyW8B2YLqa7JdSIaSuH9OSeqF52TJGWpzNmnGLCwi1JA7u1N0aPMwB/0GR0Is9pGED0pBWyVWvTHu8xLGOlQ9FgSdGfnZEKx9EX6fEjBiSA0Xztdn/7BE0f6Q3xHiFVK2Tiugf774PqRGxbRqAj/ZpKgAnoyefEcnuoW/eQ+VmzNx4lWfXUVANF7nxtukQKCABxDVxRhHelcogCSz8sqm7wODZBxmSIyjBL57H5SPyT98YPe+oNglOsgi0vlSZMRGPtBZDe8l+G8UKpvJOV95BwjyIdsujfBofmh7wSrvgN8fIBe9G609wDyN3AT8JkW+gOWNj3Iheh7MiOagJYhGXp9wYnqJVSvgCjbBgDwApwa2wfWwpV1ceM1AUzFrPsAlI+tVlEHlwsCF5XIqQzeujz8CnUTS9On58xb7p3mv5lVTBBGNQLKNok3NG10BMjL4NGYNw7jwuDGog7AwWA/gJpZI300MhqjAIa9T16jlbLo9TM9D/GRsk3W+UQ3SAaGk3B46B/yK+kxWCvLsNgL5WClLKAh99hZSSBjsYdZbWMITzzmAhinI4POe0wrHauY5dnY5BjTw5mHMZedx7Qo4LyoabAABL3XhZLrr4yE10jvvYIAXgKxUms0zooclVZYWCu62hkIYyLWOBRPuBG4pKQd8P9RmSgK3CTpqdYQZQ96s6ajIkZaSspdgddLCSuN9diet5i3buCldNhp2h7nkXOEm1BrJSGP3Hx68cm/XrYSvWicAK8j4zKOFw/h9ButcHRc9SIYXAdqZ4PxpLEyTgD5sL2K42YIPOgxXhkXEdwYrQSYBSPXIXnVDkvAY2N/x/K1isUT+lrTVMFQKmTz68QP5xrAyFJO1eh8KNgRQGsMg0P1ImkDfCwGklGxP5VSOLY6AgAsFl1cZ4QSI3O56ZIhSfUWrmlGUXWESXXJUOO1CawIuHqcbdWPBtRWEkABwBiNtUoMIPZZfDaVEhQnQau+77VHvF9em/Q66ft+ghrnmPNibFHFo2eU8J75P43PYLjnY1Jn9+d9HwjlHk3KmvFdOI/eHKRRmTeuIYwY0XBxXnI2kmc1N7ASrYHnUFBxfvF4uX6Klo0KHavrIXy/1LJOsOJhpB+GMbgyKiJdMfcMcx2it55e8KETin099MTyPNTIj2Ob4Bx8z+ll0UvNaA0b9xLeFxOR2U+HFbThu3u79o48yLi5V/oPc96vVXsPIH8Dt+jBCb8nJ0Ba+Ljg5RI2OUAWwJwlhtErOSriApgzN1orYvlAAqbiVbMR9NKjQTkqTkx6SPLkOk5qWtZ5SJVelwNN8XnTOWKfhGfmBp6D+CIACPFsipQVPQ55ggMTQbQSHdLCpDLAs7YTukKhY5W0JixYwmcdalyKV5f3clixED4ikzyYDMfFtw16oTyWskF8tlNT2eCNUjgyKWPp6PWJXHc6MnGz2GvauLguOhsWe1avEi85NyW+Oxb8iPrOpelphTZBY9p7jzNHxqlimU/v1GiF1XERNZLTmBWvK73NrfOBbqHQWItxxucDBKQCwFpZwGiFrWUTvUwRcAZAQm8sgSOLpRgdvDCQBXBjUsT7VAo9RQpJRkV4Bx7byyZVT1OpUM9e00aai1IhDIq0IS9ai3nXiUwYjdMANoVa4kLykFQfWx1zk/URVBstVREdkgoHK+k1Voy+oQTVsHEDjfMkPCe9WbGseJT5SnOcGyrfLQ3Qm12RmzCBCILRmOvAUvqK/VRkWr0qPP+41IGn2aeIEBxLcqiLc5xJfIcB0V4lzADg7zoq86cN4IrRiEkopjSru3hPnfXogqrPvOuCoZ2e1weAxXsnEJK+9/E46XPE/mSrQxKg9wKKKXtYaKlqF3my2fcZos8dC1xeOtfnk7JLCtNPRCTVySNUDOySooM8d7YJDO6bgLfIjAStUhSSc4VfjfkUSMmUOa2uNBJNoMPmMCOsjMm0cs8E9ExU531xvCkiv9BcNpbYB1zDCPa9B8YhOhfHFKgpLBrxYuwiRsyso3JKitTm755UMTYdjOP8OL6u4d7H3J18787fA8D9NHc+pe/3Pcgqu05KUJZ+6t9z3m62vPT2s3eIY2/3+Heqsfy1aO8B5G/klk1O+bUPGDlJ5nU3AMTJe0wQRuuRnpn1ABrUYEK31kc+ZPRSOB9kr0KIqTCR/qF1kja7tL2MIMJmi3NuLfcTd/q/s/FfBLE9y9unpBcCAIZnJSwmiS1V8GLWVO9AZulnC/+yEyWBppPiAEsrNIRJVUTuHBdG54NCQ7bwOA9MTKjsFTRwcz3K+EwqybhFSkzmmSCgEwqGbPDkYd5xZBw9sqNSeNJGKZxYGwnoHRWBf60wb22kVxBAVkY4ps4HMB88nPSilIF7Z51kfq+EZCGlqEyS1CXOby4iaEpJS/Kg4ilBBigSh69ubdgsfUhqDGDZiMRZVE0IL+nIqEKpFfbaDta5KHFELw2pQNR+NcEzWRHsexd5rmtBQ9qEDX4UEhkBMQ45Xq3z2G86LNtkEImnX6IIVHaREL7NDFVg3nVYWuHzW5+8YlqJQSk801S9j0CWnH0P8X6yTUcZQOa4COAyRU0OJq9yTQDQA0D0AhLUFCboOLcWy8ZGgE7ARw+qZycOGj2SNK5yjyMrTObJjTxDnBtInOzpqMA46LGbAGI6J+OXxoZ1kuvASAf7VimCSTGMxoWK7znnlColUm/ek66jYgGcRdP16AIsL7/sLEYZD5nPR2k6rj/0jmbpIqnfVQpvN9RZDu+tCNJunCOLJgGpvMtpUOeGZ/4eyszgyNdRrsu5ocO+TWWsEY7JThrW7JQg2Qcv+ZzPv9sFvUVSxZhw7H2iWCC7R3q5hwDZeaFYlVmBkcb6CJCj8Q5G3PoJg0BQcUBKJOUw9kgebOc9JiG/g0U+6EAptAr5AB42vK/OikLT3qKNRkdu3POZ8vvgWsU+ajrX23/yxr0tguPwHUYlhu+ex/NceaSVayLvqQhGyVClbejVPjx5r08Peaee3tvlD2t1+97mr1V7DyB/Azd6cZKHIvwh++k9MG8kiSznHhLQcRJPKhM5sM4LaEiKCQk8dsHDwSQGHcDGXtPFhYybrBRQSElbO/PkZZPscj7HwZKkMUQbPh7OS1rHw8nls37IQ4rOy32NjIB3Jlo0XT+0BQhQYoiwtaEsrvdYtBbWOUwrjbWxiRXBvE9hRCZsxHuEABcHRAWDXAeYl849a4XRPWqLdalCITcy5+Vho5cuGBOzZRcB5o39puepV0pUIHivAsZEG5kc02PjClzu6J0ZlzryjjUUVoJ30ygV9LKB3Ub4m5vhmjTAmIHvvMfeouvdT+xvJZxQJhAeXalCkpvwuiktRu+gUsDqqMCokOIQTTDaSNUptcIsgLpxoVEEoLY6LgTsK5V5wNMGRX3gpBbAsSjP4RCAboigEDQJD1vATaFU4G6TNy3ja9HZyGEmxYLApzK6N1fGRkfP8CIoZoiXTbjK3vtYGGavlX4nX7k0CnuBS5vzT+V315s3vAc+i9Epwc9oKZ5Rdy56Lgm0SqNDGWfShnrTp0ffoD6v1ioARzFUaDxynLDlWq18Lt4PPe6McLQu9Sd5mZWWe6NCB6ljKoyzSWGi1nRZCEC+sFODCVXesxiNiio1dWsjmM69gvPOxvLr9MASbCSlmlTN0w3GPj3YnPfz2sZnonFB1R/Sgvi+VLimRlICypPWciBYFvpQcJP3O8E83wn7lYcIvYXHHixikZ/a+YNeTXpOtRKKC+81UusG4Jj901l34FqMsvF4rUSCj5U9bd5JOEhr4TOYDHHl77UsdIzQsCImATINRCiFaahox2gbFZ5IY8vLzsvtZOs+eG+qx5vucoPmkD0vfzfOJ2NK4RBnEbLS7Kqf5EpHApD0xKswH3hhjz5vnfv9sA2TY/ue+YPvLm/vBPAWQf3oVu1rnaz3HkD+Bm9+YKEmzi6A4KXhouECKOIEA4LHGMDGpIyeIYJoALGSXvKoidQR9YN1AC1L20WvWqyc5lM1KQDYaVpYlxKo5Bgfn2GZSUkphZDwpA54PvJ/H1z084xphlbl10lloqSXAIK+diqroFFWrTTCRa5CuG3eCgialBrHpoVsSjkXFOS1hd99StQCUmKbCdnDvdAnEGWj+N0I7l1KPqEnOU/qeOvGIiahbdcCUI0Cru/WMZGP/M3aJl1YQDSUR8bERe5k4GNqpKQblhnuqQh4RI3jznnMWlH92K3bSAnxEIpCoeSY/aaLfcK7N1p4nCw5673HsdUqFkqYFkX0dpjg/afXpQrKEvyfm2VlFPbbFtYH2btA2zmxNoqFW3wwLpUC9pddHEsM8dJbziQXhlgXnY389CKoi1jnsWx9LMhCqoSofYT3FvS/ZQ72vbdUIRgXok4yMkbCtJDCKkubisAQELMtujRnJMFQYxnAOekLEeQ4gmNupvKZSOQFL3uRADI9cotWDAiC51GZz9+DESyONwB9ybgAlgsjutgp0pNC8Dm9gqA1jTkfE6MIQPjn2tloBFufSpdrLQaL0CtYjS49a2E0tmdNT1qOAPlI4HI3nYvz3GfPtuhs9FBbl+TdoiycT559lYGXXNFAK5n3CsB+2wnICmOt1Ar7rQ261ykJm33D7p7XXQJ8SACM2vZ8b7kObn4fPvy7CdSAVE66v5am7x1Mms7XZJbrzq+jdZL2o+Z5XhZ76IWX++3rOuetLPrjhO98qK7E/cioFJHgM2gVdMRpMBIgRw6yHGt9iB62SWLSe49Rycgg+dty7b2mjfPKOo9JmaIMuaHifCoMwnt1AVAP9zx+14W+556cA+DDoq2kOepsvAApYgQkCU/gMK/1wBA6xIPMfuPPPFlz6P0/LO/hdtthEZKvd3sPIH8Dt9wTkTcukPxJCgCQvATOc2GXSbAyLmJI3TqP7ZkkP61NSojMm+yszjNbXEWr1XqHRWejlyH3ovIaWonHxTofAFkOTOXe6i55C3gOTvzDQjvA4Zwoj7CBIA/nA2vjIhT+CKAbCkzOJ8CkR74sNMaFLJrkpJKHvFIZnFoVD16RUSpi/6tEB+AmifAeqDbBzTQqVyvx3vFcBJERxIRwMqss5cHzG8s6/nuv6SIneL/ueu9d7il5QhQk3D0N1ei0Ah44vQqFAEgzz1sR6A9KAVep5KFFQ9g6H8CCyFTlBlbk8LowRjLvMsI7YCiVi/SysdGjNC1Eik6H63kvxtnmskYVrt10Ho2zsU9LozHvxNM6LXWqVOWExjAsPEMwyg2U88V7xEgDn6fJ+OBFSPaSOeFiQqRWcg4d+t0hUZk4xvif8z5yKatgvI2NiR7x1rlYpKPUKvVzkCFsnYtjvCpEoo73N+QHxz4Pc8tD1DSWrY1GYR4257ui4gc9W9OKYf9EcwL6kpNs0xCZGs5fKi6QsiDfzyrhhcOtRwQmzksBGOsRDQ8CRr4v0flO1B4qYBglwGdkki53VUhJ50XTHQB01nkcmZjYj6nqGD3MApCZNMroRVQDUKnDk1Y1ej+BoFRRCYDiGkpvZWkU9psu8u7zeZP3PaN3anBuGtNRZ3fQ8k+cT3q9+We9Y+M7OQha8/MfBmiBBEpZnjgH9Hl/dFY8wZRj433k1zig8ew9utB3wyIv9NTnBoJHSkzjWRmFoKHM4xitoPIJDey2S5KNjIjQWWCdj4m6edKs8wEgezEkWJCF/eCy9ztsCsiq3aYiJ0DaI4d7ZS5tmPdfXmKe1ComVSv05+JhNQgOM4ajqobKjxt+7+BzvZP2DvD016S9B5C/wVuIIKZ/g94FH71+rLID9HlnDANaB8yWXTzewWMveNUAAgZSAlKYn4uF9SHEDQFQiQMoUl0ueC8bK4lLk8JENQuxitMGyVC/CgspQfiwcXMYVmzK1TDYF/QsjkojPE2VKAdRacGIp8l7OW5USGEQckMByWbXSoo4nF2dAEjhVIB86uQ9qa2Nz+a9R229qBQMPMgE8qPS9Iwd51P/MNQq4WXXW1R3mjZ6NeadRd0KQN6p26hIEbnf2cJfhOp661UZ7+G1q7O4eCYaiov8aACBY+dRGYNp4OvOWylzXAceHscIk4Qa62K0Ivd+M2kxB1w39hvR7wQCXSRlyXMz2qpbjAK9pbEiN8fkzkrr6FmdlDpcA7i8s4RRqSJh3Bi7pFPqvWhAt04A7Dh4ZdlvdefjmKnCOBYgKZKBkwBya2cjsCYl4GatDMVoVksjkneFQefJaxQ+qHjddIx40EucV7IrjY461vS85clJDJlTis4HT9SydZgET2/eeO/sH4458px1NtcARGAOn4z2cWX6YCh8ThBJjzrHOxsjR9Z5LBuLnXkrID1UvcuTVLUmJzrlTtDg47zWWhJomZRKTnpZaNStQ5FFb8Qz51AFfjHncJ4gZbTConGYtV2MyGiVeM/eJ7qXfB7KM7s+pavQCuuTIswdG8GYGGeinlN3Sb2D8zTnnO63bVxPnbhDobL38bZeOt/3IAO3Dn2z+mneX37w++D08SeTQYEE2uhd9z5pFDO/g17zIUjL105esyMnPRvv/BkjUD4BTALK3MhiW4ZKmVohUqJYxIXvksVz8sS6zidHQNv11W7yzuGYWR0X8Zjee1J9QCsfqZi/QHpU4hgnjm5+GkZSckOA14oeZKMxKWUekK4XVWv84QbP8P1n9mCffz743q3KZ99O+1pTKN6uvQeQv8FbPzzVH5gsEOJ9WiQ4PGnJ0huwNW8zDzKz4xOnlNxPD0QOMhdpKTmcpGvaoB1bah3PkwPnQgtvOfdIIJyHACDXrTxsUihwsVUHPs9/IVDOExLy8KRspKon7SNlXQscmZjEOUPS7J0UBg+eWA3PolEEahRBTaFlE1gGDwOvRY5a0r88+D6HCRoEJlwUbdgAondQAbOgpuEBNNbGAhCzrkPnPDb3m+hpZOQAAfhXRnRv2Z+b+030+DF5aRlKP8fQctgYKq2xUkiJajEeUklk58l7kwp3/Nw6MRLYKTTwWPgEQK9qG40GrZBRd4SuUQUaBqv60QM9KUz0tE4LUfQApBw1AXmhkgQVvVS877pz8V1OKhOq18k5qEKhwt8aKrr45H0CUnIUQRINUr7zvEgNvWEbVSWbWWaMtI7JZ6Ls0XnxTLNksfOIZbx18EbSK8vrsvGfJvOkubDxk0aTN4JBei6XWbEQJrJ5nziTpAbI2pPOpVWaQyr7jAY3byzfiOmxpdFMTva41BGw0MziemIdcGpjHJ+VsnV836PCRONIklMpXygAmZ5NAGhah61Fn87iPWIuR6kVlp0YpHzHeeIT3y2BUL5M5eCiMDqOcc6ROkjJGS1JwlxHYlN958C8s3G8JueFiv+2A89weqB0PiDpHh8WsVPZ8XYwrujNHJ52mCSazw9Axn3MZwnfo/EleReZ9/iQ2wf63k3uZTRCOP6HSYNMfB2qe+RUAY510qRaJ7z2XAOae5v3Cfh3zsfKqqy22btfn0VawpghDS7vchaTyptSuTpT6POhUanyPYQGlYq5MvH8WmU5BSJ1WXcuRW5cP9F62IbvXw/68mbtD4mPbxpJ/nq19wDyN3DLrUVasbk1zopVHkmmiWHynnUcALFWSZi9bsVjOau7CMy4yDBcHCeTF4CkgqeE2ralVjGrmOBc42BmMjdgAnE+GwH5zebEMCzKz9ImnDKjtZYENtnIqFrhI2+R8l/ei7U9KTWOTcro4eB9lkZjbAz2Fl3S/9RJZ5IbpVIKjWNoWO6N3NxhiJ8WOJAqEsb3ij7njBZ9vvcsQ+azePITmF6GkO3esgsefkRjBQjlp7XGkZUyUiq26iaGhAXoJ01ohvRISaAeqPMC5Aqd9JnZ/6zK1Hkfk+Ckmlz2HsPTN0HruekYjaD0kNwzPfmtk2Id5CmzcM0kJH+NC4NlmwprsL/rjENYZmOH4DZyW22KeqyOi3is9z4CpMJorAfvz2GFzjsnfNmet5Cbq+oXw6kKUeo4MikjgONxvLcyGCwxMdaleVyE0rfwPtAfEmAh8MhbGTj1lHhsM89YouSkzYznogeNn1XZBgtkHmQkubjc6yxFZxJwYqiaLZ8VuWpJlO8CEyjzcG4qlc13F9e50LcqAMoqqzBpglHMsLsAZJ2iP53F5T0ByIy8OOeDlzIVbFh0Sa3EBIBN3ELw5rK1U6m+IRD1plVSBrFeDDSjhZ7WWt/zvNE5we/Wlol9fa1bGql15hm+VSP3WBIq1aHrbi/HAyka1Pcoyi+RH8vP0X/HpFPQcM9VX5wTw43PM1RKAPoa/RwrHBuMRNKoye+5ZVJulitDiTfKtXEfkvtJ3OYIPrXQybiWklrjvDiLEsAPVUmR9rOhChQjPTmIp9GQNxPW0/Sc/b8r1efpcv1QSvIyeufSKVeIQLlz/WfODReej8333jcO3PvN2u2Mw1u1dxkfvweQv9FbBK2ur2YRFxvQEkz6pQQMBFXO+1gxjYuBLPwCnNsQwiYA7lzyvHpIaKsNgv8MpxstE4+Z15Tz0SpwkX1WATAD8XbgdWBix2GtCCE67/seklwmKBeCJyeXHjpWEhwXWpK5IjDUmFQaG1UZ+5NyXtOQBX9+bx43RHqMCVrKENZtXShc4FN2eOtSYRcgS2hQie4hSVPJw8mQoPzO502oetmxGICPPGcmljgvMn+Nc/HasTCB0RgZKWFLj/F+20ZZM6OYhOl6XmyCAuoG07gps/HHDUESjGTzHxcmJhzmy6RSApK5KXXBgwYgegD5Pr0XSsUy8+aQMzwdCV95pE2oyAesVUUcD3JdnzwqoT8JBiNAoaGjFO48OgnANAMrYa6dXC3QecQkMF7DeYkmTHoSYEmLmXrcbNSxff+ZVZB7HxOZwvdZJQ8IURobZKpU4lTbYBQTtPDdDBsTZ6PcXxaKj6AuAyT0hNLzRYBRBmBaGC06tFTKya7FxFujVaSFcHPnO0B8v2likDtMoEEKxbQyMcRP/jr51N4LP56GGEDJtaDQEfjHvJ849pRCWRoYo6Inuekcru+nynqch5aFhcL8WkYPso/gmw6E6MH1aWMnV5XNmFAkRulIC2mdrLcEXA0NNvYTSMkSw6jukseZCWPJCaKiJ3NWJ9qc3EzvR1xjpFiLgcrhbAB3OSe4s6GAhj+cp3qY5xGqD+yih/gQ0L1sxTN+M9mwPLeGnl6OvrzaXJ64x/UjT2rkXGGLz8XfXYre5Zz2paWXOUUP6CySqn4hIkBvdOYIYBM5yBRl4TgZcob5GXzSUM89K9yj8v0uPhvIT+73HyNuTHjs8Y59ok3wNnJwOqRd3K5n9w8Hj9/zIL/X3kFjOIUeY3ouublxgci1iBPni7JWnMxhUQ/nWgb+bNO5Xma1QtgosvN0YUEvlPBEWcGsLFKN+YrJcUoJb88nIJtnxOdWrHi5bvbsKsoX8bnyfgGSNc3Natk6NC55cGnJT0tJyMu9zYVSA6+NLAqrZQkFKVChs82WYV4CG1EBkMW9DtJqDj5xr/1BvdA6qAl0zodqesnTTX43nz1vNE4IPDrvYsUvD4/dpkVtXfDsh0mvVARdW7NGuNlaxcz81rqgP5wiCtTIbqzreU25WJZaZ0AgVdxjlauNURnBRf6eItAN0ly5x4wLO58PEH5g08mzlQEs5l6OzvPvwLQsIsWGnmagTwGgd4rVJtmPWolCQJRzs0larDQad2+Mo9EnahwqyOgFMFeaaChoJQlilMYbGRMBHst8X92tMyqQitxpABFU6wC0WQKbfwNkg1sGPevcK5YGsfwYh+x7/ilyIFV6l7mRTY4m/0bABqQNb9lQjs73UHkdwLRC8kCTSz+kPeXDmiFrevVTDkUK6eeJRi7Mr/1lJ97rwQbuEVRXsvLRLMhhdALGZSk/69Zid9HEMciwfRfWw2UrP5mIBSCqUlgaegGsIqzBfLwhB3nRJLk4GpX0UtMwZ6Imx5NSCMl9gWLkHUZlogLlThEq4OQqQcOWK5EUJlFTouc7HJeD3kiBUAcBE5BAc56jAd9/fn4vT0Dk34fRR/j+9anOtGxt5BDHSotBRcb7JE2a7lvWtrywSQ68clrRorEhjyeBaukjHSUso5Z1WO9qmxWfAsdBUjdpbXIO7dc2JmrToQMcDgRZwCrn4PN4Okw4VuN7BQtLHThdr2KonKMPYNVN3uthjc6SYTvw0W0i5Jt5mt8DyO+1d9SMynluSV4InNxOBq/NJiytzCIkHzmPkDWfrOU2ZOdTMJ7eISCF+KMHOdvwBBj66C3jRlsVXEiCFi/SBkvPiQcOTOTDPBN5O2wecQoxROS8LKZt50IlP/l7Ezah1bEJ5VpDn2pRl9iu23j+Iiy2a1WBxllsL22sV18GgMwFVPjMgVOnVQQU4p1M4JhUCgKQzgrwsi5fvBGpFaxI1lsifMpWp+dKQGwyamZtJ9zkYBwkBRIBW7Paxg1x2cliLkUt0uZFL1UXwr/Ri529gyqrKoYwvrqwgXkvVfbIHc2PS+WYXQxnEyDkL9gB8dm64BkijcMHAGC0GGAEspS4Yr9GMB9ekM8u0bmMvwh5lzf2m3h9JuMBslk9fnIjjjPKu7GqovMCzjkntBJ5Q6NlTIyD2oXRkqTVOY9ru3UEtUaJPjXfl9xzoAZoJk4G2TSVOMD7yy5GGeL8y/o5B2mcWgkgp7fiBp/RGB56pXtgJhgXHomnTtDskTxUXGd4tcTJT9cvVFIPsfGdiMeNv+ce9nyek4ZBcEJeqlEqFtVQSjyJ1olcFwFOWZoYNZnXXc/QEw+yjP1l53sFfOQ50jhiH3KNzL2DPQ+ypmRhoHroEEbPDDkaZjQWOR5WRkV8f86HEsc+8YgBoRHQ455TZID+OpnPxyj1lxktPJ8LE4YJY86lCOWwuQEYVoc8f+/Y8O+AuSOwj1QI0MEjRgU1kkkREjCN8G+eN0UgxABPYLzMzktjgM8S8yFC1DGC2DCnqkJH+T0xgBPnN09wy+cZDd6OGe9IHmSem57/W1XE5J4t9x36LIDlnLaUU93y+cZ2ACCHk3KeH5CGOwQB0+FWDNZ+tps4/9+2HRZ9ILXt3WzvAeRv8EYvJkGWygDzIvCIx6EkJgsF8Hgg8UpZWUxCUqmu/NJK+VUCEh5DDzIQQLQT0EHQHSkCkAk3LnTUNY6lmQF4yLm4OEVAHCd+f6K83e/AYKMPiziVHHLdY0o0HZ8WWCmLmIgoIVaPzbmEWOMmGZ5lr+mwV9sYmqLCAiASXfQoi9KDjtX66BHrvHiycw8A7zVq8AZvSPKyBi+lTtxDlfUvk7LoGVxm/L15Z7HsUoKgQup7oxWWjRW1CJXC4E3QFpb7klLJzKBOVIRE29FKYaRN9AZzE3HeY7fpwrviOE33ACQtUiZBMixKykju3XJePMgEBaVJPN95AMg7TYumkzHL/p2OQtWrMFzk3cmGQL5qDqC9l2eb1zYaGlSsoMdpd9GCiXfjUkVDlG1lJAl+Rdh8pRS0eO2ZmEWA1DqHzWWTDFwAY1OgCnQd55PkXKUNmk6iNDR0AAGHUqQgRIiyzPWcP8l36pGqWtZZUhKQAFquEhPBUugfApPZsotgk0CWALkLXlrnklfOOVmLOBcZts43U0Zh2J38ySqGrDhY9CIBcj16HAmYOS8k/C3fN1qK03TWxSJJBMjGaHSdw7Kx8fmjoeoY/nfRMEsAOXgvM8OSgMpoFTuwDxoFADPCllcKdN5Hqck2S0LNQTIjK7kSiI/nBvizFgABAABJREFUFqM1jxLmLX+vBERAXiEvGSD0XlMlQ6uMs6z6Yf18vtIYie8IB50eHgkQdcFRo5SK/6YuMJ9PIVH/rE/ymdaJYUUvqlbJGMsVkjj2cycE133eD19R3bFAUxpkzvtYTIjX4xjJ82iGibKRhhGeVSHkXSjENZQUKZa6HjaFvhJEiqAktYoou+YYZUlzNW892TvfT7RUSDlMcQ86BLQTmAOZNzt7v1+t6sThBtchH36d23sA+Ru8EWj0SP1hILVhcq+Mi55VnA+06GHxIYToXFz0XQCUlIlL8lFpQiuEKmNeKjYVWviAldZRYkZAuo5gossHuk/AMPzaawd+P2zRGEzC/FduzPRwMVMcSJrAJ8YjHBlVkddqlEJtPXaWsskXOpVE3Vw22G87LFoXqy1VhQpgRVQhmIyllcLEGDThmhqpClgdPLq5h8Z5ljn2MTyrM5BcKB3KZet+tjz6RROUEoAsm4nCsrMSEnZZMYF4TjFYGHZvCUydi9QQ7z3mXRdllGhUWe96HjlJ7EkgQSqBecy6DkopXNhciBcgAwtAWtRr6zLNWEl+awK/WqsE/lmRsPMyzvjc4oEWA6YN8mhNoG2sT8rAU/XxndKQ5AaZj2uA4elURSvnO2qt8NrOfuzLlUr4rbxvraQapSSDyZhgIo9ROhokVaGxuxCPN4utkOq0VknlP+E2ijxgoaXARW1tlCHjUGg7F0tcO+/jWEKY2wdoJT4l5tHrFb2cLm3qCmlzj2APibM9pzcvA2f0FucUiTz7nnOSGzGNR35XK8r69UPvNPKdl6S7XB2DhlU4GMiOpxTl1lJUeQql0HQiqzapigiQqqAHbUNC7XBtYYQhNx7h+2tQvs6yPyUJNt1afmxnXYzgMJmKIGd1ZOAQxnpWHIP3kjyIKVLDC6jQhz4AwqGqBM9zs7B+aVQfFAWLnEaZD9fNi6zkjcB3CJHy/YcRE3qi83FIOhbX2XgbKvGuuVYysZZGpEdKUuPYI9WBLa41SBJzyVOe5cU4Xlf1+cwgPSw34FNCO8c6nSN5kSIV+tM6ySWgg4te28jPH7RorIXf87wj0uTifEEycg7lg2ctGk/RIZPOe5jnOD4zcn49Yt+xHcDUt4mXD6XsvPv4+D2A/I3cOIYYomRCGzd+gpmV4D1jI9CY1Z0kNvgUViL4UKB8m40WNAEmOVD0PJDLNy513IQnhQlybyp4kPvh3ZxiYcNmni+0AvrTM+aLUq8P0PeoAAc3qy4AAAI/68WLSw3Ze4+u4PhKJVJlAQi01mPWyKJbGSVVzjywWTfYWXZYtg5rI1m4RyZU5dKirWq06NpKsp/pFZYQEOqih5fvK183nEeQauvLgpmwgZO+opA8ZfkCqJVC3RGoKcxbSkUFb23Wt1oJnUIrxKIU7LNlRg1ZBDBBbxTC+FiflBEQEkzp4P0hxWLRCUfwynwJ60L5aJU8kUWQgVvaDlXwQpMu0nQuq0Q2GAtezuV88sR1zmN3KTrG1kt5cKAvUZaPI4InbtSRox+OYBSF7wVgsqDHlVkb+3utMj1vpoLC8dUKY2MwDoVAyEPUYbwarTAujczD0E/clFvnsDYuAghk+FiMt2lRYNm5qLnM1loXS1z3NhOV9KPj84e/U8IuenMHpZNZ8UyrVG2Lz0mjepnRHsgxJRjJOaYJOCIBZJWASc/zqhKAyR8l54eycmD+TA4p5O4ReLLhXhfWYnPZwHrx0NWBdkXtZBaTIM/UWqmUmUfdfOhHe9Ahd8C4oDFBYzkHFcPnmVQmFDPRoDav88DRcRUiKe5A2H2RV3YDsBsiXnz3RmXv0/vevAnDIrt31TOgANJcEI5l2e5AJ8iAWOQIh5bW+QTS+LlCf2zmoEqpZBjQYeA9YiGVvI/zktLJAZKq4PF63NdyShvvjZX6vEd08MT+9Ol9E+hqhRiBoLFRBMNH1pFAA0NS7JExmFRbyCMmrYXOBRc2gf4+cLj+c54GmwN6AAfmQ6El1yRPumXL9wwmFOYqOjzmVrxfGkj5veTtgPPqpmcanPeQz97zIL/XbrvRy+vRD90oILrFaIHvzlu4bCBzYsyC/BcbOXXO+5h01tgEiJ2nBzaboOF8Dh6r4yJ4rYC1sozlg4EkGUYvHRdP/r8yMhE4AMk7zSvdjItMQJbP4fzfufcAQNCn9JHmAQCn1kd44PSq6P1qKUnrXKqcNy515LLu1kKvWHYOR6eikCBeJymZHMNMwYs+qUys+jUq5G/0zpLLC/Q3K4IkUiroeSyUwrQyGBkTCpTIe9YqaYBqJSoOTfD6y6IeZPiAGMLVSnjWSgk4WoQExi7wez0gMnHRY2YjOGYxGevlnZMzSxCgFKL3trUiN1cajZ1GON0rZQGD5CkrtAoA2WEcDA0Oy7pzGBW6J42Xl1BeKYvofbFOJJVmdVLd2G0ENGzP2pjAI/eXQBQBEw3FPCHQB/DIy+fh1N3A9wWAjVEZdaM5fuvWYlToKDXnvXgunRdvb6k1piMj3v1sbrVOxufZYxMpjRzAiBgVAmQaZ+OzyzxQcVzn+8jQ+PL55yqUffeuVyxF5LMQQ7b8SU9e7lHyPoGV3HNFI5vH0BPsfAq902vFdSnnbiqlenrNw9nvIJ5FgkZGGICgo63SWse1q7YW23UrdBUj1KLOOayPTRwXhaZmbJDzK7LEt2xt4mY9VMOQ++9zjxHeAWXNIr0tA27jQPOodH/837U6CWumj3QR9gU5tbxGLFwR/j4ENjmgzJ+H958f31nhRef3z2ekcs9Nm+r/k5dRAWDnQCdPstRKZcZFygWQPs/OEe4vl9FjknlhxEnDvYMgk2A154IDSZpQ8j9UNPS5L+WGOXWbnfOY1TbtPbpfBMa6YHgGz3QXkvLynBwFGlpC00gJjZnRkBmVeX9xbvXBtPwsDjFyIlj3fXpPLsvYBS59dHJkxmk+LnIHlvyeDFl+ditP71dLueC13u32HkD+Bm25hUue3DCznCB6b9lJ+L4Q7wT5xos2ZfcqxXBf8M5oEzytycNML0/fA5A4T3k1rkkl1IJJZeCRvpMS8uhxSgsbs3x5PzHp0CV+1GHTKwfWvCe23HsAJCOgDl5TrYBXr+zjtasztFbuI6pcUM5KS+jTeSnKMWtEJeL0SolCI5YvloQahpaB6UALlok4rUulow/brJB5Dgg6+Ywb01I81SbTex70SmmEQy0LaZ++oJSKHl+2zkmCW+tcVM0AUhKT/FuUKzyyJCTvcWl7ic4lTxlb41xIEpWkulJrzAOPeX1aJlAUwG7rxBgjQBDwLv25Nil65yeIBSRSweacqAssuwQSWVFv3tgsQVFFXV1uopGPCGaLJ/5k6xyKcL0yM0abLumunpqMo1cfkE1jVluMjQnlshO4sj6U0lUCOllxS6r3MRFRvMGV0RkIVPH5O+exUpnwHgIgdzZprA52k7ShJQAicncqqdiEY8iBBxA9qoURI5H9wvthSJkApAeOVKJ+8e+RvuWT0gDXjHZw7zkIY3Qs5wNPR8lrz3vREMOEEQp6zjyE475XJw5y01lYm/pRax295lxfix7vV+4lUWUkLwCK8zTN4/xYGghSlCS9lx71xPmQgKnjWPMeuPOoVOx0YQzT+ACCfByS5zeXDyMgdzQmM+OE389XDfZturfEA+fz0LtI7nzvebNz5QbUUAmD+Qa5B5bvnJ5Uj6FahutdR/jJaZ1ifg3vuSqSnjXnJ0FpXAMDcLU2SR0SeDKvwft+jkUZyjE7H5QzsnWZhguvxyJdeQEkeqzjeAKya/hI1clpE8PKc2+n4jAEoKVJxgz7NQL5jJNOR0gZql6ltaZ//Th2uBYjRSnS+nxzJPuHwMe3PO/XqxVvfwiwXC7x9NNP44033sBiscDJkyfx4Q9/GA888MDX+/7eazdpcTHxg0GOzOsaJusyJOuNguwUNYgp4QYwLJ5kyFbLAgvbJY4yED2V9EACLGwh12NFLkBKaG4tGoxCrflYZcsjFpTgosL7NUZDBR5lGcoGE7g7j7jY9/vhYNUnuQ4zrVPIelwWoArC0ooKgILC1cUyao+SgwgknWQHsfIlnOwxDxJPD2ys4kuXZsnTq1TcpKwTWbNZTZ1LhXGpsGhCVSbX1+cEsoxkMBlF9Twenu9QSQnlXGEgZfT7QOtIPGbrxItcaRNkyPpgy3qRBxOvc1IYWLZyn1Ol0NiUIU6FCes9tmdNGA99r2FtbSzZ7FoBvvNGvGf3nJjC7argvXUBRLtQyUnFzYWyaSujIvL3lPJh3CGOP44Dblykr+T0kbq14uEN/ZzGo3jCq0JH/i6rWHVWPm9C4pdWwKTSUS+YdBTvgVMbI5zfn4snHeJBovdbK4XdRjbmUutAZXFRJ5ybM+eR9ULruLKzRKVNCtPrVNbdeY+1SQlsoTdPLDwmkDnYWRc9ILlxwZ9Gh0TKJQFCMujoBSU4HmWeVI5xbry5kacG18vHrs8Q9LBcsXMHC67knFBew2iFNsyP46tV3Jxp1IpqjMfUaHhFjjCVXVyYj4mfbq0kO9ITyGvw/otIK9FRZaAIKjXaS+Ilx1Q+V41WcMFzyPlMRYn4zD6tbYtQDbMyYoRQNeH85iL2H9dxn/WpUkAV7r/pXCzQApVUZBjVYdKr8x4l+mBFqz4oVeBz5o4HyVmwmnr3Pnvfqvfd+A4HoJA0OklEC+oH2V4Sc2GysTFvLKa8zwh8PRDWx6iTjRTp6CXKgUa1jHcWImo6B1WmIhl1yFcYlTrKXOZKD+NSR2k7GrjD5+X8GhUa87YDvOqP3QD24ztBKq+d+jl7RgugzPozdxT0rnsQPCqVEnt5j9Z5qOBcyY214T6U5u2B0/baMOF0eF/Ddhif+Xbb/wZ8fGuA/Hu/93v4J//kn+DXf/3X0bYtNjY2MJlMsLm5ibqucf/99+OTn/wk/uJf/ItYW1t7t+75vQZarQetuzxJg3rFXBCALESjJETHAiCl1hHIeghveT7rYqjRBxDh4ePmCshCwIk2qztsTMv4fed9rF5H4O28eOGGQJ7nqtuQ1V0gaoemZAepGtbvh3427rDlpTlNABh1kHurArd1t+nE0xq8cqSjuFZubNE4+BLhOVwwLBw2piVGhY7AxvvksbTO48hKhQtbi7igjY1Go6kE4QJlpb8pDRMpizzxzQu/srUeK6WJi57RsrFyUduYlgLAbShUEsD/qNBRYo/SYFR2SLQTef9ascyxJMnV1mEa+r6x6R4phcfNjR4ioW2IzKBTUoyF/PZz1+d4X2aEtFbKTy9D4s0KBey1Cp5UGyrJKTRKvGmxOIZLQNd7kbTjGK6MJChOChNDqKSC5BQL56UKH4Efx0njHFaLAnXnMS4Vlp3C2sgEKS7ZkK2T8bu/7OKmp8N86kLyY2EU9EzFz+tWMvBXRjoWcXGDbaV1HrvLTrLQVSoc4iEJk9b7yJ0FJJS6CO+W423ZOkyRvG75uPJIUmre9zdI/pNerkIrTEcG8zrM5dB3LBRCnmJ+HUY+ykz+iZ62PMErXTPzbBIwGRXBJ4220ijUCtHgZ0vJTUkFII6L8LxC95F7n7cWTWsFIJtkgCRjJEg4Bg96GQCyMfJvUZvJJNHid9Pza5UZYU6KnCxDdU0mdHF9lWIhYkCx5DMAXJwt4jMmSbAAOEPfjAsT1w6CGx3GyzJ40zUCtSckQB6IMCjVC7kzYTH34tOIoFKIsn26UjpXNn5UlkcR/k3nSDqv/CyMUA2GxhN59XmjYUo6BB03TKAtTNo76IhhlJKRQVIAFWSdoU70uDTYX3bRE8x7nARnDz3/LNzDOQ+khL9JZbA5pyMrRWc6m94R9/DCpMhCDh/p4MobDRat0OvEIXZU4f9C9Uuo06mmwn6frpUDZHXbQPZQzHoLIPs2DvDePQzbsC/4vr+e7abI4k//6T+N7/u+78M999yD3/qt38Le3h5u3LiB8+fPYz6f4+WXX8bf+lt/C//1v/5XPPTQQ/jc5z73db3R99rBFsOaodFS5obABZiaxjvzNvM6hiIOAewUiuFSOe/apIzHsU0rE8NG3PaokCGhzcSvY0Ux6rKSH+29R2UMyDFjazJvGxfcfobw4X1ws+mRAwIWPymCFi45nhMjvL9FZwV0OI/1sYH1SSPTeWC/cZg3iTpBbeg3t+aoMlkdcrb5Pes89ts28ypxYxVPrYcA0LxR2kiiAT6Gbl0A51vzFrUV/ilbaRTGlYmgcS2UQG5d8uxa5zHSJvZlqr6WFnxuzN4nTis3oSboIysAdZfk3haBm1yGjVOpVFCjtjYCYPHAy/1uBa+zR9LQbq1DbT0WtkMZ6CwjY9A6hxv7TShrrbINIsnBAWm8L7qk3zwuDBobtJIdvcAqlvVls040ZTmWmEHeOhcK3wjAL7XC+qiIG7lGWrQ3503PYBkFL/i4MlgJFf74eeflvVeFjjJS8kyJs0lVCxfGgAkKJs4nkJfTowR0Un5R5k0MuavEf+Vje59Kz+cJXPybGNHUS1dYGxciG4nBseiHXTnWadyOyrTFpP7tAzSuD5FGFbydubesCRKAlMezTtYzNqHlSHjcOd/jz/JGvZdICgDMaoe2tWhbAmQBvzS4SVsrw5pUFumzwmhURsbDyOgIBHNDPedwci0Yyuxx8Sa/mHM9AUpgt5H1g3J8dHUQHBiV85aTXCYBv/N9jzj17DvbL1KUR1UA9IyC4TPRGOBnXeZJlvvur8o5YI4VLA85nvOekTV+TuA+XOuVSklpTCbmuOL7dz6NJ6NVjHAKrSLdRZ3JwE1H5gC9gUVpmNcjjp6kKsK10Xt5t+uTomf0cgwkj356GnLeD2tDDnL+Pm6GQ70s4DGikf/vBvMuv06eCHmYpNvXot0KeOfRlcMuP+iKd8WjfFMP8nd8x3fgV3/1V1FV1aF/v//++3H//ffjB3/wB/Hss8/i4sWLX7ebfK+lxpARM63zcUSvhGQX9L2RHh57yy5OavEQpkWxCBs6Ja2AtOFxYE5HRW+xYyNXs+lcsLxFYB0A9psuWvtcGCbGYNalsqfeiw7r2qQMWrLkVWaW+U1mw9tZkNIdsrGMMo9XYz2OjKqoebw0AkyPrxS4ut9GhQrvPWaN7U3GLsi2XVksMa10TBBZdq4HPLf2G8w7m0oEK0TvIxdf6zxg0oZHo8faPr/ceofGKszrDktrcdfqFD7gg5FROLpSRq/+jf0mRgPYPb3NFYGSEcJ/OUB2Pr1v8vzKUDWK46axDqWX0q6UgiuMQh3APekqdQb2881mp27hitSXLhzfWY95oNcAUpRlt+kwq8ULXBkVxz3Q5yryM0rqAcB6VWBr0QZKj8eoLCIdIR/nHsK9U8GYKE2SaKpb2TiPTyvMGofj4wql0VggFeABgO266QEbejCnlRFec/CmjgsTgf2kMlE6UUPBKQEthZJQ7sJarHi5Z5b/FQAhnq7ZUuaQAgvVJI6/9G0AnKGvWAiFUZ1K62gE9TL8keY+gUUR6CDe9zcq2YxVnNsETswVWhsXEUByLI6Kg36Zfog3SV3xnI0Tzuf6uMDuvIX3HruLViJWPlGgyqC9TSCUh31dGJtKKezXAo6t9ZFrW2gdcxBMoENQOWZamVhtTympvjnzDpNiUJIZpH3lNKYE/vPPfHZ/lMT0vh/63q9tOF/yLPOv9FjzHlxYL6g6AgRPe1auXST0xFFQZu9BKBp9pZc8euV8eqe5GgMrAfaANOfB4B3H34de0WDgFUZHSVHn6QXN6Ae5vRM+ivKgPjkCgFQ+mfJx+X25AH47mwp9MAcCEA+yUtQ0DuBcpXWM154UJu5rLNjFObgaHEdKJ09xZz0KM5RbTF5w3kv6m7/pvsfnOKyF7b9HXSlMihYd9n32N9AHx2/roB2sBUzEvFm7GfBmpPdWihhDI4I5B1/PdlMP8qc//embguNhe/zxx/Ht3/7tX7Obeq/dvOUJZ5ycw+azY/MhxVA1kBZqSlxxY7NOBuLeQrL+CfjiZBtMMgDRy0Uel4eExbRCDAdL+F2Op3h97xxc8AomSPi4EJMWcpj1+XaGbgyxefHmiQdM+ubEahW5d6QXrI8K4VJnm8eyS147gijvPXYWHdZGie/WOoGgRsvz3FjWWHQ2JucBohpAEMoEuvyd0YrmYkyvIoucNIEecmJtFN9DVWicWBtFIL636CJ9I98ol9kGWAVAGEXlkasQsJqibFSjUgcQlzzLyy5VqAKEPkJt51iSOZSmJpDm65t3XVbYRMYoK/8twnHWeRwdV+icUCymRSGFNjKDLUkNpiIudRbuPbMyEbpO6JdxKeFU0k74PvOxSE8UP9uvhbKxUZUYFwonp6PoFR0HXq6Mc9vbgMhdHJdCqVBKPhuHvvSQTZTXUyole1bBIGmCvJyCzJnVkYmebZHyI58xhdvpMcyjNjGaEoyhRWujZ7izMmYJrtqgTYzwPSbHAYjHHtboIY9eqDAxuTEzpEwvonwnrS25CgYBPc8LiCFvlESsCqPQ+VSMhAZ65xBBJiDjtudE9kmTdtkSILtYkbEIFJwi0CjYRqXB+lgAMp+PkpbTopBIwsD7RUNMxlQas3kf8Xd6TTkuWeFTK6C2PnDa+1EPflcrKVteGklsjVESerDDusd1PC/2NDzX0FuZtxyc5CDnsO8N96SIb+Oe08dQ9HDTyGMiGQHjze6LXm45d0p67F87yZT57DMeS/qS9a5nNAMsMJIcA4yakYI2KWj8Iurkc7/ZXXRxrtBz23RJeSM38vv9MOi723wn/c/7eyUTT4e5Oj2Kk0vOlB7v/KZXP/y67/Q78fq+70Q5NK/oba//dke883ZbKhY/9EM/hF/8xV888Pnu7i5+6Id+6Gt+U/83ttt9uT2AjFsDxDzb3HvZZIa8KaFU+Ligc6Nati6oJYTNDOIVzvlrSinMlh2sE05yLrfDBDF6ERkmNvogKPHZ89PL63zaXPNw3rC9Ew7StMqTkID3HZ/GDYq4atFZtJ3DpEqh09b2qSiALAbz1mG1KoLOKpMfk9dlrxUZvdWQHGg9emC57y2Qn6TF0LPLz1snUmCdFc/ssZUyLsDjQkoic4NZtjZuNGzOJ340VUOGBkcODPOw+zQk/blwz60VQ6iN49BjZIyEKZ3reYHY37VNpXKXQRFDrpMShJhIxUSYu45NInd0WprIB+V9WpdKskZqT1Z85eyxCRwQdJdV9Ax5+MhpJTczPb+Mc/HCKOzULVonKhWTSvpsHIDSpEr802VnY5lsoM+LF3AnYfq1SRkXegXSpFiuXMeiNKTIxOQzpXBkRTRxrWdSbR/M8n0WhkmwvjfIfLgeqVCSNJRC05J45SIHUasEZqhIMjhlfI6cawoknjGQ5q1CHxTn8zk35g8DcJ13MCr1tw+AA0DyrPoEaHiNPPTNcWK0KF10nXiQd5YWhVGRWqG1ih5I60RObm0kFfZSZTwxMKaFAZTq3a9CSppVIGVF/l6GEuM8PC+MQ09mbuSR7zsKyXsyftN3jZJQfx4ZzCkQ3gv3mWXGOdaHuw0ruOUtRiBdqpKYNzpo7OBk+ZjkPfS/dxCcR7k3l9Y+6b90jnzYyf6VohL0oB9w3mRg0VofedwxSqlTwprN3hPVnqKcXzDiSIkrjI7OHI6Z3Mib1bIv6pBISCWhpLyBmNszLOs+vP+b9d0tPciZcabQr/Z6WDKdzz7PJTVz4xrZeQ+DK3G+v4M9+dAT3KQd7Iuv7jLvpN0WQP75n/95fOpTn8Jf/+t/vfeCFosFfuEXfuG2LvSZz3wmLVjh/zNnzsS/e+/xmc98BnfeeScmkwn+2B/7Y3j22Wd756jrGn/lr/wVnDhxAisrK/je7/1enD9/vnfM1tYWPvGJT2BjYwMbGxv4xCc+ge3t7du6x/+d7VbWe25F5lw9YGDtDQZ+DDfptNjnAK3IPLnk+/JS807oGJVOGqF7IWkoXg9cCHwMS3Ojc8ErY7MFYGQSV87zpIN7p0pDTFI7xKrO29t5kNP5JXEi3ygvbi+jV5t9dXVPKsatVLq3OBAMVoWK51t2DhuVhHgdEMtvcyGat1KC9+ioihs4i2QAiIly3ETzzS9yp8O/JdHOgSocF7eW8dhpWWBrv0EVCkfUQSN0OKYWNumk1q2NYB/AgVBV5xJfdW1ShpCkj17vXCkCAKZFgdpaLLOCImzWiapFGTaSNmjB8j3rYIRQoYGFJ/ZCoox1EjJPlaiCvqj3mI6K8D5U8ES7eE+XthaSeFkWMRohz+ZhvYvGTNy0Qp/t19JPpdbYa1t01uP0xghrVYGtZYOVSsLwa4GrKMmAMresd5Gmoeh1snIt7z3uOjaJ/bK3TDQjo3VIRNSYjopocLHi31CLtFAHoyqcm6xu6D3D1KmJEZuSEXMOfGV0LO7DyE30OjeJ282+ZlMqhXHzeUsahM7ATJ5kxMQ+GSMJnDjne95S70NlRq2xM29DLkGih1mb6DxtplnN68gH6XwaMv6tFQ/y7tJGzyv7pSqSMb02JkCmxncASSqVQXaDDiEVg4B6uJn78F5GZdBchswtUbhxEQCKB1TKjsu9J3RdmLQ2VlqH4kR9Q8UjediVSgBruGzSuM4biyvlUbjeM9ALOvjD0JExPK8lauO1WS3SJc8uDTFG4/LGr1LBAkiRPUq+RTWhYBBxDM1q28vPodeW1V0J9ukx5qORJuGCE6SioYPAg/aZ2hLEoKSnmUpPoiUf+iRbI6OxPjAYEe6TyYPDvjzMu+zyOep93JOUQkxKH+6ZTdBA5+dDugxpnYe2npPHx+/fyvN96GkGRuahbWhovaMrfHXttnWQ//N//s/4tV/7NXzP93wP9vf3v6qLPfzww7h06VL8/5lnnol/+wf/4B/gH/2jf4TPfvaz+F//63/h1KlT+PZv/3bs7e3FY37kR34E//E//kf8u3/37/C7v/u72N3dxXd/93fD2jSAfuAHfgCf//zn8Ru/8Rv4zd/8TXz+85/HJz7xia/qft/NdqvxlA8cTlpan2XgbQm3LGxAmZUKpM3ae9lkqERBBYa0GCUvQhu4eRRPL7SK2cRcLJUSaTfnE/WCk9IDsYKPJEhJ0hSlu7hGcn71q5CluXC7uo+3mpA5iMgP25418fl4rRvzFtZ6rAVvcy49pFQqvyphYeD4uOp5ShRUpLEsO/E8T2JiCGLRCIblFFTwQKW+8D4ldBAMEhx7Lwva1qKJfbRWFli2NlIJ6AkZbmqS6IS4mAvvUvU8MWwsH86lURZ4Fzwpkuxkncc4eCsLrdA4J9rJwUOcJ7Y0QS3AhM2IAIELOGFa54T32zoxYPg8WiF4y9KNdtbjjiNjeU8qSa9xgb+wt4D3UoSmMFn2etCg5mbh4SNwbKzoN3sviXlUxVg0FqtlgZ1a+OlaqzhGpkFWamKKSEuJUoHBQ0sJwFlIWlVQMYHVezEeK2NQGY1jK2UcT6MySSLuZ4A610ZmqVqRdBIJQJf1cfKyyVqSJyflYc0yKNJQ3osAjcAzHjrYqFQ2nsn5jEZibXuVEAujMKtF8YPr0vCUpGSRhkODqwzfNVpFyhHHzNKKoU7AVLc2lqwGkvfc6KRXToC8V1sUmfFVaI1xZWIk58ikwLgIVfaCdJpopgeVDnVws6ZHn/zS/O86eyGRkgIV8kJkDHKc855Xy6IXTWNSoAnviIAt5x+zX/eWXQSCNKqGXj5SBPL30GZJnVzTcyMmGfM4tHHPGSaGuUGHMPk2TxIecraH59WqrzsvkSC+e6Flyb35+A66YHxLZCTkeKhEgWAxH3JpbXbvNLHo3F8dmZiszWRbRmK8ZySVfPSgNR4KAQ2jg7nOM1vu3MirgMb+931cwOayRd95xPXb+zQ2htdi5cmk1Z7+pvVtANd4bflp3sF3gD5P/J20w5RYvtbttgHyBz7wAfzP//k/sb29jY9//OM4d+7cO75YURQ4c+ZM/P/kyZMA5EH/8T/+x/gbf+Nv4M/+2T+LJ554Ar/wC7+Avb09/Nt/+28BADs7O/hX/+pf4Wd+5mfw7d/+7fjwhz+MX/qlX8KXv/xl/PZv/zYA4Pnnn8dv/uZv4ud+7ufwLd/yLfj4xz+Of/Ev/gX+y3/5L3jxxRff8f1+LdutPMTAzZPQgP7mEZUpMqklZv0ORdmZRZtz/mQzRfTK5UoAzATnolZmYXhqOA4nJikfpaF0Uxq41Bfls08KA6MRqn1x6sqiVBkdF4Ihx+122q2S+JTKssADIDNaYb9NGweP3a/FU7ZaUcWD55e/V2FTovdzUplMa1ZFDrJWqcLYrLaB4+sxDeF+pRABjQp9nm/m+TORT8wkhtZ57DUJLB0ZVaICkmnCRk9F/q58qvDlfAgTRm3gfj8zEdH74G1zUhiDoKm2olU6LcSztegsWptKVVMLmGOKihr0+ngkVZN8zDgvElyt9bi+rOP9NAMOOMI5D6ha2OQJ2WmkguTKqEg6xwg0jjAOmOm/t+wCfcXGzXVcGswDWL+yv8R6VWJpLY5OC5SFjtGYlaKIMnqdc9H4YP/TuGo6hyu7dXyOZZtAZxU8yJU2OLJSxb5Yn5QgZ5LA0mihKymVEqc86JFVmFQm4x/358Iwh2E4baxLRXuGdJY0jvqbk0LyIPNjJhQ2XSpQ4yHetmUjICWnofRBlFAqyJdlxGlsTFB7SMcAAjCkTDfntySO1a2LIXTvxQhjOJ9qDjK+XaxM6b1EiUYhfN5Zh42x6QHeXAUiGvbh2PgAoe+HFCB+zjHL90LQJ9Qm9OQsS61CKeq+d5h937ogV0bwk3v1AMzqVJKa1x96ecmZj2uP69MqePs5vc/5gxJvw3uLiZ0uo45l4Jol6fPIosuuySgb+4k/WRZ8SP2gXF1jQwl0nyUqZ+NxmCRpneQqOO+xv+wiiM4pO0CiwkxHhYy58Oc6K33tfFIh4j1F/rJPVeu4Xzp/0KubO3ya7B54Pa1uD1NEhaWoDNU/JscSh/HJ84jxYS3/61fLAXbeH0qfHDauBe9muy2AzEF08uRJ/M7v/A4+9rGP4WMf+xj++3//7+/oYq+99hrOnj2L++67D3/uz/05vPbaawCA119/HZcvX8Z3fMd3xGMnkwn+yB/5I/gf/+N/AAD+4A/+AG3b9o65++678eijj8Zjnn76aayuruJbvuVb4jHf+q3fipWVlXjMYe3nfu7n8NGPfhQf/ehHcfnyJWzeuI6rVy7h0sUL2N7ewpuvv4rFYoGXXngOzjk886XPH34in35673Hpwnk0TYO2bfHWm29gNtvHKy+9gK7r8NwzXwIAfPkLfwDvPZ7/8hcAAC889wyausbrr76Mvd1dXDh/DtevXcX1a1dx4fw57O/t4vybr2KxWOLquZcAAM99+fPwAM6/8ozogDYLAB6La29CtUssNi8Ciz0s965jvnMF3WIPO1ffgrI17nHX4J3HtTeeQ6EVHvGiRmKvvoLCAMurb2DFWNzpNjHf30GzexVnywVMs4fNy+dRL+a4219HoRz2Lr4koZwbr0MrYO/CCyi1wkenW1C2Q711HkW3hNu7BrPchetawDZQ7QLn33wV8/kCLzz3DLRSeOEZ6Y/nn5G+fu3Fr6DrOrzy0guw1mK5XPbf09bh70kBmF98EQoKX/zCH8A7j/txDZVvMb9+AUewxGqzjUmzgxN6gTv8FqZoMN69BOUs/p/pFrRSeAyXoBVwcnYOhVH40GgLxnXYuvwmpn6JjWYL5XIX3WwLa/UWKrvE2uIaYFtcuyDG2WTrDZRGY7r1hsjiXXkVyjt0zQLOWVy5eA67W5vY3byK/c0rcMs9bF15C8vlApOdi/DeY+ut5yW8fOVlKAWMfIONicHu5ddgbIu1+jqKZoazZh8n1T66+Q6OtptYVfJMxnuUrpZznXtOyjhffw1aAUdnF1H6DnbrIlSzwGm/AzvfwvmLl3Gs24ZqFnDbF2Bchwf9FQCAuf4qAKC5/JIog+ydh/YO473LKF2NY90mNvwcer6NSb2FE2WD0ewqvHNQXQPnPG6cex5KKdzXyNjbvfACus6hvfYGdNeg3bqInZ0t+P0bmDS7OIoFTtgt+GaJLz3zFRg4TLfPobMex/fPwXngA+YK9huLM/UlLOsae1dl7tjda7DzbbjZFtC18M4C2xexO1vgxvmXsLQWW2/J/Wyffx7LzuMhfwXXZ3PYzbfQ1nMcb7Zx2tRQ8y0cs7tYdTXWF9dhfAO9dR7WOZx7SaJjr73wZQDA/sUXUbcdLr7xEpRt0G5dwt7uNnZvXIafb6Js9mH2rsF0S3z5K8/CwGJ15y2c3hhhvPk6Wufx+gtfkrD89lsofIf9a+eg2yW63atY7m3KM+1fQ73Yx9Xzr8N2DZaLOZRS+PIX/gAKwM75F+Ccx+b5l9B1LZob56DaBeabsu5tXb+CSxcvYLG/g6sX3kCzXODKuZfhnMP2+edlvX5B1q5nvvR5eO+xfelVdE2NGxffRGc7eNvi6pVLWOxt4frlt+DaBTYvvIaubfHWK8+i7hyuvfEcxoXGWy9LP22efxld24R1bwfN9lVcuXIFs+3r2Lt+Eb6eodk8j3pZ48JrL8A6j8XFF+G9x6vPfwmLzuJxfRW2s9i8+Bp2dvdw/q03sNjbgrcttOtQNDO8D1uYqg7/z9oulPf4vgdbdM7hI6NrAICPjK5hbBSeHG1h1Tg8tTLHil+gWmzh/mmNuyct7iv3gHaJ9flleGfR1Qv40B9t5/D6i/LOL7/5IrxrcePiG1jO9uJavrd9A1cuvoX5/i5ef/Vl+K7B8sprwlO//poYdVtvwHmPO+uLGGmHxfU3gXaB5fZlONuhaWpcungBupmh3ryIwreYXXkN2ju88JUvyt7yxT8AvMebLz0D7x22L76Ktlni0ltvYLa7jUsXL6BparRti0sXzqGt59i8+BrqpsVzX/kSOuvjs7z4lS9AAXjxua+gqWu88erLmO/v4vxb57C7dR3bN67hwvlz2NuVZ2rqGm+8/Dys83j+mc+jcx7PPfMFdM7j4mvPoW1avPLSC9jb28Nb597AfG8bW9evYPfGZdSzXexcfQtts0R97Q3AO8xm+/GZtAJuvPkcKg28+eqLaOsl5pvnMbELLLav4Pq1K9jevI7z595EF57Jdi3eevlZtNbjrZefgfXAjTefhfcee5deBWyLZus8XD3HW2+dw2J3E36+gxtXLqDoFhjtX0FT12ivvR737VnbYXbxBQDAGy9+BbZrsbG4grFvsH/9Aux8F/XudexevwzTzOF3LqGpZT5577GcyzNtnXsOSik886XPwzmHl154DvPFHJfPv4HF/g6uX76Iq1cu4cb167jw1puyv29d6OGIV5+Tn1/50ucBpTCf7cM5h/rGedTzfVy+dB7Xr13F9mZ6T1fOv479+QKvvyzXP/fSl+Gcl3EDyLmdxWuvvIj5bB9vnXsDm5s3cPXKJVy5JNjo/Juvpz3XJmz07Jc/H9cIPtNiscCbr7+K7e0tXLp4AVevyJpz/tybmM328eZrLx3ARvnPt159HovlMmKjSxfe6mGjruuwWMzR1DVeeO6ZQ8/x3DNfijjidtptVdLLLYOyLPGv//W/xj/8h/8QP/ADP3BbFwGAb/qmb8LP//zP45FHHsHVq1fxUz/1U/iWb/kWPPvss7h8+TIA4PTp073vnD59GhcuXAAAXL58GcYYnDhx4sAx/P7ly5dx8uTJnqtdKYVTp07FYw5rn/zkJ/HJT34SAPCRj3wUx473r3HkyFEAwEOPPAYAePIDHz78RCr/qXDyzJ1RCeTUnXdjOirw4EOPAAAee/IDAICnPvQRdNbh4Sc+COc8HnnsSQDAfQ+8HwCwtr6OZWsxDqL4V3drHNnYgPPA6XseBgA8+NgHAQ888OgHMK8tTDWBUhrjE/fAz+Y4eedxbF3dw8bRKfZ3FlDeYzw6Bl2O8Zo6Ce89Tt77GAqj8Ky/A0CL8R3vR2kM1LH3YfHaeeyM1zGarqNbapxvajxSreLYmdOoW4dX3HE8oQ3WTj8k3ptj90ErheP3PIZr8xr/v/0NfNMpgwcfvA+vvnQZdTUVq9EUUNCw5QTvu+9u7C5a3PvgY7De4/HQx0996KNoOof7H34CRSH9Z84bGGN672nZWpw4cfzAezp3fY6Nux6F8x533P847POXcK06jfdVI/jpOmw7wzyoEiyLBq/MxNIvj9+N5q1L+EJ3HEemwDPuDIwGdjfuwbhZ4tn6OM7oAvrICcDtYabHOL06FX6uG6GtHTaNhP+vj+8Amhqzo/eKN+PUg1DLBmt3vB+NcxiZKazzOHv3PRL+HrcoGwt7dRsbp47Ae4/NyRkcUwp3v/9J/P5XLmJ57F5JnFQV1icVxqfuBQBsV8dx7PgxvNVuYb0soSbruFF4LNBgsXYcx4sCjR9hDOCOB56Q4XpKKmJurdyJtq1RHTuNbneOKwp4ZLKBcmUdF7GLo77A9MQZNFvX8ZXuBB4B8NATHwL+2yu4tno3nPOYr96F9sYO3JE7sTpdxWLSYWdZY68YYVQozPUcu+MJvNIoqzH8QgEnH4C+vodzo7M4o4H2+H1oL+7hcnUaZ6sx1taOYWvZopuWcJ3FFvawMqowVhp+4yTsxasYnX4AjXN4a3QX3KLBH7Sn8ETrsFndgUWncPe9D+Dqbg2sKcyXjfDhyxGgFOzGHbAwmJx6ADvzBaanHoRqW9z78FP4vS+exyv2JD7Uedx78l4013fwvrvvwP/3xgXMqik2TYXxyjquly3K0QSztTtg9zvc+/BTmNUd7nv4KezMWxy56xFJZj32Pvi9GSbrx7DoLDamFfS8xrQo0HmHybjCuFyHnl/H/MjdOL+5wO7GPTjmHO66/wlsX9sFTtyLqhphff1eLPYWWKmOSBVIo1GUqyjHqzhx9j4UWmEyXYnrzLzuML3zYTjvceLuh9Fah8mJe7C0Futrx3Hs+BpmmOKO41MpcrKyjq1Zi5N3vx9KKRx732PYXNS484EnsL/s8OQHPowvvbmNjTsewHhS4c4T98NcKKALhVOn78C1dhelOYq1lQqmmqDpHD7wwQ/hzetznH3wCYxKjfsekXVw484HUZQF7r3z/diaNVBrFpP1DYxQo3Aebnsfp07dAes87nrgUbjNN2FOvx9153D2wSfxpZcu44vNCXyTMTh29n4opXD09KqocrQl2q7DHiZYliOsVQa/t70K67fw7140+CMf9fhidxreN/gfs2N4fMPgpeUJ7LbX8QfbY9zrx1gfr+BiJ7qKWwuFNVSYrZ5BURSoxlLn7dEnPoTGOtz9/icB73HnvY9gdTLGybP3wmiFO4+eksVqr8bRlQpGKxw5cgS7b25j9cyDsN5jfvReoLEwpx+EvTLDW+UdWCkN3v/Q/Xjrxhzr6+vQswJVVeCOO8/iC1uXgMk6Th1bx6x7ANoYPPrEB+Wdf/AjuLZbY+Psw3AeOHb2QYzHJU6cvD9676vzIwDA3Xfdi/0LuxjfcR+UNnj/o0/ihYt7uPv9T0IrhQcf+yCUAu5/+HFUlcHd9z2InXmL6dEjmNcWq+MiUsnW1tcBAA88/Bis83j4iQ/J3vbEh2Ctx8l7HgGMwYMPPYJFY7Gxvo79uoOaSf/Olh2maxvC/z5zP5TSWF1dg3MeT33wI7iys8SZ+x9HVRU4e99D2F92qI7eif2dG1g7dgarU4m6rI4LnD+3jdWNDWitcO9Dj+Pqbo2PfPRjeO2Lb+Ho3Y/BeeDI2Qdx4foO7rj7Abz4xlVMj56UKpe7HtXGBtq9G2hW1lFWI+D4PfAeeOjxD+K/vXwVx+6UPfj4+x7GorG4MT6N+bzG+OgZ7C9rjCZjrK1VWFy7DLd+DEU1xvqZ++EbhWoic3PjrkehFfBE2PMeeuQx7C1a3HH3fVi2FsVkHSeOTWCdx8bRY7jyxjbU0bvglYk44oHH5OdjT30Ye8sO05VV1J1DeewsRtMJqmId6xvjXmXAM3dVMEWBs/c9gmXr8OBjH4TzHo8++eGIUZrO4f4HH0ZhNNbW1iL9hJ7/6eoGqkLjoUcew6KxERs9/tSH4x6c78n33Cd7DTEVAKysH8WoNLj3gYdRFOmZnvwgMcBHZIw+8CiKsojYqJysRFwEAMX5AkVRoBmNIo7id/mT5yYOe7t2WwD53/ybf4ONjY3eZz/2Yz+GD37wg/i93/u927rQn/pTf6r3+zd/8zfj/vvvxy/8wi/gm7/5mwEc5JBEXb1btOExN9PP+3rwU96u5dEAhoJudR+d86gOCzVk58kHqIqfAQjha2Zf52fRKpD0QyW1Qkm5W5L/WU+A2e/OA5WWZLkmaK5yYvX0Y326Jz6rDrwzHZJFxsbE8Hws/8kQWvZMy9bGilLjyvSoFU3XT7w5rN0quqOQ9Dqdl2SFioUcMqmucVYVcKcRrVXyaHMu6bgULqJWCvPWxnD0pDDYrtuQvSxVQpVS2KltTIJjKI/PT5oFj83TnxjKpqIBkIqA5Aly26FgAsN1ZzbGUfKJn5NKUmahW62kQpoC+YkHO9GHsGTnhNLAe3fOo1CIfNn9xmEUSvB6D1TGYFToqPkpoTFJbmHyjw6b9NJ2MfRtlHCZrRMpOaNUGLeSPMmQdVVoOAB7rTz7WlWKtJxLFB6GF/ebrheeq4NeNbmHgDxj7Swa51A4kWzbmbexNO9e7bDshCpzZFpiZSS8Q0B0naWATL+EOLm5pPQsW6ECMKReWysqBSpUyXPCq1w0FkbLWNuatRLqdWmOjYxBoajdKz9rm3iE8yaF1PN54z2ysG/itxqXqQh4SbxdCYmC/L5QANCjTMVqhF4k2PLNl597r2KFTN4/1UeYnLUY6IznFUDzkOrapMSNvVq46yF3wob3swwcUKVSmL2wqZyvh6xdpVYYF5mWdraG2UADYhVQoQY47CwtJpXQACiFl0qVh/4J16CutWefHbKek5LCPkxV94SOpFUqSQ4IxWJaGVSFPqAhTQ79atCb1qq/B5J2FN+h7hc0OaxJIlpKOmN56HyNINfWh7XzsOVZEnKFbkV6V9Rad+k8TUgMzWlmvFZvDGfUFHLJ+Q7ie1CJkqOQ6EHUWY7vbfA364Ui1Vq5nypU/mwH1ATSeHaXHeqQ+8TxkI+lRJ/wkd7DZp1PSTx8tMEGx2HPAj/k21ea6krSh7zXvMUz+ZznLFVYh8c6H5SEMkqVyt7xcDzFd8v3dOAvb99yClq4TTnXkGbiE4VseOy71W6LYvGDP/iDGI1GBz7/tm/7Nvydv/N3vqoLr66u4vHHH8fLL78c1SyGXt6rV69Gr/KZM2dgrcX169dveczVq1d7G733HteuXTvgnX432pCrmw+0w7g07U34XPmR5BbmuoXUcyy0QsURpXgPiZtI3hS/w+xV9ldehKHKqs5ppTAtZTNrXVoYmQiU8xpT5rVw9nieZeewNWsOPJsK97hsXVAhSKCUjVWmbtXeLimgMBp1K8lj01JHvu64VDHLe3VsQiU7jxuLJmZAk+8lWc8CpAWYAEsrOselUVgty6gDDIREGgXsL21MWFl2LipZtAHwUTpvyMWKkmtOeIlaKRxbDYoYEOUDQPizCqJIYJ3HhS1JTit10uXVWqEgQOai6XyvjKsbLFSKPLzAGxSueQD3oW9evzYHIOW4WyuJbeRaT0cG40JBAzF5bVqGktNI/LZFZ2Oy5CgoIXTOY9k6jI3B6rjAMujVkps5DXrCwgP0WBsVEcy2GbDSCthrumgcKahQCdD1VBo6K9zkOlxHhX5l1axZbSPn8OLWAkfGRXzPm3UT5xOBWx30hLnxUDFiGTZVo1SU9KIcGCAgU+QYZVxsLZv4XApy/2tlGcdloTRKo2NipiTT2rix5bOGUlbkMafEPhW/572P+sK5kkTiPiegm/+diatA2jSdz3j6KkmzkUsPJMM1n71MyhsC5FPro4gryAUl4Jo3LnKKFXDgu94jlLBXWBkUESFgs0G55cjYyFoRxv1ebbFXi8dsXFKLOq2B+dKUr4VswzyKfB+oW8of5onULAsdKraF5MRRabAy7vu0VMgpaYMm9nCdpMQitZXze7kZn5MKRM4f5JVyvecalMucDRuT3rhfAUwy91EtwgPR0MzVNghu+88qTStkfRaK+iAVOcoVKjxCwhzE8Omsw94iORQ4FmUMicHK/YaJdT1Hl5d1e9HYCFqXrUiD8rq8VybDJ4cGUh+Eh+fzDrsvKlBxHw4ayrGaYXhuJtjlXZUPAd57G9a1YeP+r1VSrOBxYnAevu+mgh6H/vmmDhfgYEJ9ngg5vLfeOfH2+/zXut3Sg/x3/+7ffdsTKKXwt//2337HF14ul3jhhRfwx//4H8d9992HM2fO4HOf+xw+9rGPxb//7u/+Ln7mZ34GAPCRj3wEZVnic5/7XKR2nD9/Hs8//3zkHH/84x/H/v4+nn766fjZ008/jdls1uMlv2stWwSGWpFDK4pe4bdrLluYcvWEXobqYGPkork6MjKpyyxT3KcFL2/0mnZBcmil1MF71PcgM/GNYEGrlAyTKynUlslqmVXm03maTlQOpBhBv3XW9UrWHtrCJndQYogLjcK8FgAwHRmMQ5npaWGwvbCooLAxMvG9bM67sBkHD6j3UCF5ZlJpVIWOIIcAY1KZIMcWAI6XTPdl54KyAGKZaJY7zkXsef8KaeGi9F7nxEvXdC4lX4bv7jUdpqUJnkvg2kwSwcalKJY4eBQaUUeY3pWmkyiCDwmELLYBpExx3hffcaxQ5SWZaXcpm40UBlEYB3mslbIQr5cxUWZJK5FEo/Y2NwFm7RudimR0YWOfFAZHpqUs8AE8KCVKDXu1jZ71SWWixFqXed6sEyNmSe1fJVq/1ommLUezC5thZz1sIUB81nZxg1l2qZDA9WWNo9MCOwtJlNytO9GodinrvW4tpqMCpQnV2bSLFRQVpG8p6UXQyYx4llU2WmHWddHzy810JRSnIfAujAqeLQHMrfUYlwd3rp7HT4VqdcELXZjk3aPRRO+mGDNJlzyOy2wjHYJAJmUxakDvFCNFPLwIHvO8MYmTURtG1faXXRy7Phg7NFwb65GrDhCU0FtKwJnrWNMz6pyMfUm88zgyKqNqhw/ge39pYUJJ991FG6M1zlMpJCXuOt8HLLmUIEEgWxv0wYEEEKQqpY1rqtFioE0rmQvD9VEpYHPWkNnXfw8+aYOzYETq55s7ZGgcH9ZSMl16vkPwcYxSqMHz0yDJ+0BR8jJ6kLP7yW6jCYWoYvI4vcpZ8rnjWhOig61zmMCIk8S6OG+TBzm857pD59M7si71gQIThGWdaDsXy9inBLwU5cn3DXqRGamzzkmekkrHHlbEg55y63wcu3xWjv0h6OXawveY7/HDYz0Q9xcaHC57hj9M5P1m3xqqmvA+kN33zU8a+tQdDqi/Hu2WAPlXf/VXe7+/8MILuP/++3sV9m4XIP/Yj/0Yvud7vgfve9/7cPXqVfzkT/4kZrMZfvAHfxBKKfzIj/wIfvqnfxqPPPIIHnroIfzUT/0UVldXIxje2NjAD//wD+PHf/zHcerUKRw/fhw/+qM/iqeeegrf9m3fBgB49NFH8Z3f+Z341Kc+hX/5L/8lvPf41Kc+he/+7u/Gww8//I475w/b+OI5cfM2/J1eygPnCIOJ4CkJqfc9NVFOiBM6ekd8zLQelSZ6rIZZ4/m9JqkaymEprJSSuU9AEiddKArRuvx8PnjngIUVLdtFY7HftgHM694i7yDnqYoihigBxIx1AYcHF5BhXzvfLz2ZV2ubjgpsBSrCtDQYGQmjTssCra2hlcLaqIigeHfZV9SwVqB9ZTSmpSgOjAKYKQNlY1ToGBoejQyUFoF/AmSKxR+byAbdOvFK+SBI0TmPKSvchU2bY0XAjMb1vVqAUADkmAlFYVqaKAW3uWzgvcdKpSPoMUqJVmq2KNetxX7bJW9O1qcmeMhjXwavzyiU8vVeJN5mbRfuUcbEhAC5Ek7iKHjXnRfvJsOYPmxcRos3ruh5kFnoBFitCqmyF+gT1OUeGZYNl16ih5jvHQAmlUbrRJuZKhiFTprLHBv0lrE8Nr21i6zy4LJL3qT9tsPRURk32r2gfJKXoW06h7WJgMPKKNQ6qGw4evqSN2pSlQG0s6y3g9FigM3bLm0ISjbGjWmJzf1GNta4iQJWCw9Z+IHqgAfIBqBNYO0hYKzodE8RgBW/bHgvBOOlUT3t7Hwu5pXnFHBgMy5M8iBTaYLjLI+cdWHN4fqSRy1u7DcRhMialzbxOkTD6Cltbd+TK+olaXM2muWkVVQeaa2EoI+OK7ThfM4BdWexvRTjbVyaSD+gIkOcM8HoGOrGGq1AuemcGgcg9nF8v0rWjFnbhYiJvONla3GMlT8H/U/JQPb98Pyto+Z3X05zuN1EFQyuB9lT9Ggbzsc9QmsFfYiBlPo9/PQ+rmv8nffLuZnvaSxuNbzHthMjVgVvJ2mBScVG3htUUFWB72l919ZhXneJEhOcFA4es+BB5j3mcoiMxnANpyOExi29yZz/WiVvdq6epJWor+SgkM6IvLEY0Lg0caz5eC+Ia9YQMwynJyNLw7Ea+5sGRvhJbMH2dhTWdwqgaXQOPwMOpyMd1nJv/Ne73RIg5zrFALC2tobf+I3fwP333/+OL3T+/Hn8+T//53H9+nWcPHkS3/zN34zf//3fxz333AMA+Imf+AksFgt8+tOfxtbWFr7pm74Jv/Vbv4W1tbV4jp/92Z9FURT4/u//fiwWC/yJP/En8Iu/+IswJhG1f+VXfgV/9a/+1ah28b3f+734Z//sn73j+/1aNL5Dj4Nht/x3Li43C3kxtECtR1rRHJv8FieSyv/mfW/yNVZoAn3vZQoN0drlBsfrHBlVUiY3G90CkKmT6uPG6Lx4bBsvIXBuPuQJlkbLpqjoDRfvDaV+WisWP8NHrCaVt8N6ath9lMdyHjgyLfH6DckangaKg1YKa7oI55fP2V/7jYsLGhcipQQUGi3PNy4E5FZGKBvc6JvOo5zKwjcuNJqOoTagCZJMORUlLy8dhesDTzffjCuto7eNmyaQtLHbANL2W/E6HpkUEbQZLfSKPAw+6zps1U1Pbgjh3xppXNKL4b3vefLHhYkbA++fAGpcCugaGxNDxiOTgX8vhT4KrTFvUzlu0ZHW8ZnHlcGNvTqGtHlc3HzCeNyru+hl5TxarwosmkCbCFqjI2OEL+x8LyQvYzdQJEL/Ni5oiyvRMKYHedlZnBiPYv9Qri03zuogJ1UVUnGLXnSPFCKm17rQCvNwfnqjIjAK0oosNAIID3171kZvEaekh/QnQWXdDqBUGAvk/gKI3m1qGAPi0VsEab9xadBZC62TJ5hceQIqAcgDD3JmLAAsHJKMvXw651JaOUCh0cHkr3nd9aJWefW4JqxDHI80OOIa7AWItdbHsuBFYWADN7NzIVw9AjZGZc+72rQO+8rCGDF26HVzYZ2MOtCFTjJlA2Oz70HuGy3khWol867SGpuLNuaGAOLVX7YWy9ZiDcmJwb5tusO9wakghRybGzI5YOJao8NkGAIZ3jL3Iq4ZLGRzGFCKXFsk8BvBdTiGFeiG96+1in3JnwryXtvglOB6ycgQEIokeaDMHERhq8HOvEXjJJrECEriQku+Tee8SECC61lWzCmcrwl6xqyQqZV8V4X9OfcIJ0M8eZCH/do73qU9Ia/Qx/WXmsFGp3mQj1WOxfgOfKpqOtwzScni89MJkvdJOBI389eqm/yb9zJscX4M7gM4SDM5AMYRDAPnod4lhHxbSXpfi/bv//2/v+XflVL4zGc+g8985jM3PWY8HuOzn/0sPvvZz970mGPHjuGXf/mXv9rb/Jo1lZvyHgestxwMKyUhTnptDiOwsznPkFTim3GA5WEU/s0hiPwjWcWl1mitjQszF/t4DQgfUyGU0oTCkXGJ1XGBPCpHAEqgrFTSvSyNRtO5mDDVBgDgPTDOwKRHAjv0NNJyZ7KT8ym0f6s29CpzM7bex7A0tYwJbFfLMobu2XdGSyKOUXmpUznfyJgIOMdl8qiPjIBXDQF+JrzTcSEegC48F0GWCcBbAHh/82Q0gRZ+54VWMTImGiQjoyOwYBiPHs5FK16645mGrtEsf4vY74vOYtZ2vcQ9F/pdEoUIoliJiv0sP6dFAeuTPrHzKYmz6QSUTgoTvVbTsoB1ddSEFr1X1fM2Ns4FQyW9Q6ni1g9PNzZ5mZVSmLXCw47JZs7jxGSEG4s2FnaoCgmvc1zI5uujF8cjC9+pkFiElKTJ4imtk76rCvnesDhI5KZH4HNwoWfxAOeFVtEtfUycdT4ZGom6lJLjtudtr3yzcBqTIeS9VGibN0NfozQWlSAgImDnW0h8ao9xKeNaIQFroWikSnjOS3QqPaCKgIKtNDrO9fw65DyyhzjngbSZbkzL6GlkGNj7UCFU5Um0oRgDEOkySqF37sb6wCdWKAqNthUPdhcK3CglkZncy905BzSSJMikSAARsMgjp/cxXE/l/uTfQyPeBwOAkTVAkjCXXV6CWJ59d9Gh0EoAcurqsJ4fdCKQFxtpAkr1DBmPvgeeYI20gfy5CEDJzUV4N6zaeFjL53UP6GYgkfr0PEfu4WeibaTqIUUGCpPmagLKKUGX84O3oJQknxJgcwyn/YdVL32MIlrve9ryspcA3rnedcuQ/KdU8r4WYbxz3+XzaoVIkWPf814AWbdoUCUnVz/fh5Ekgu+hs61Xkc+n8/beTTAkcr12zsc8iT5fi+K7dP5wDnL278NHBHrG0bANAfFBwJwi7Rq3rrD7tWq3XSjkvfbO25ALlLfD+F/WH0zU47dcNtDzogkAemAin4jyNx+4t8Deoo1KBNZ7rGUJH3lWt/dBqN/TSwQcW60wLk3vObiYeC8AUCsVEuFk0SeNgJsgkymmRRFDVjknaRyKC7SBG9uFxezQBXjw0XBD5iEEiDf2mwB4xJJn+Hx1LB7kUmvst6HCVyj4wApgQKCBhFBl3QngrIzCspXnXikLzFvxTHXWowrh6FFIoCINhcU0iqyi4fAd51WlgOSVX6uKeOzImLhRcdPihkQKw30bq3ER5caYSuOKd38WPKxcfMixS6oSiBs4E7gcZDFbq4oYumVC4DKAjL26w96yw2pZYBy8zsdGFZoubIQQAMrKfEyGW3Q2GhVKAbvLFnuh4AeNJe+BWdOn9iw6GygcKRv7/uOrkhRoJcyqIAL/LCvLviRNQcYnPcoEu+TnuhDGl/mx13YYx4TFsJHoFC5tbFLcyPnW9IKUmSe8KlJi4jyWqKVHSe6xNCyk4LG36HqAtu1kXObKJePSZDzg1JyX95mDKSbUOs9cCB+ByNqkjB5CVjzjd/NKeHlTOJikY0xfAUEhZf/nhg83aY5F60WhIY3rpAoghYwEnLOwTTTQwtphdLpHax3mrfCJq8JgPJby0Z31qDspPa1V4mUqRQUHoVnQ0MsVP/he2Z3kNedrFktCMyk6b94DK6Mi0l2oNLNsXQ8kzboOs2UXE9rg07rPROhhi04InzywNwMVnU1gjYA8f67Ik86+zvFyM1WMNvMKO5eSZ/O1ugjjurMsHITeetWjyXgfxwydSfmeR5Cb3y+NYEAiPY0LSjIIeM73z9NFo1nmXhmMSRYXcV4oFkyMLQuN1XERvc/eS5+x0Iz3dB6ktTofAnHcqP7zep+MEu4f3qNnTOagOX/7OR2R80KoZOkYeqQLk0qlR9qQT/jEZf0b3+Xwg9BuG64OjcSbHHaYBznPZ3k32nsA+atsN8vQzNtwQObfI383b1xEDruOy34KYb/PM85/ckOjV2/RSEWh3UUX6QoePlbs6l0PfZUKLqqLxqaQtFIxxENPG/9dh0z+lVHg6hFwZ8l366FKndxzWuh9eN4Y4vUhKe3tu/rQjZoXdJBn5yLhvMfSyn1OK/Esl0Zjt+6gwuLmnI9JbcnYSKVgNVRM+FIAVssyqDHoSCMpjUahdAzH0ctVtzZ6p/MFPg+ZRk9z+Dc3Ut7LOHCoPbKMZpdkt3xmALmw2HZOvHFQsnA21mHWCPUlVyhYWotS61gKm9QXQJKF+O+VsojeZwI43sPWssHeosO4MhgFfvHRaYVlJ30Hn+6LgMI6Ae25Z3e7brAfeM6dR6DpiBoI+d5ayXsZG4OVyqAIFbG2523wWvuYqEQVEL5PH/o79wrm3sCqEGUYAeU2jvP9pkMVAFpMwgkbaWFkXHCzzhUVtFIxukBvSjQMQ3a8HNffOCZBLhEAFkFakN8XuhTi+dkOS4bx8NiYFHEzEz5fGuAKaW3K553zDCenZGAV/53G73CqHvRApr81hxjAbnAOj0xVw7veZk0FmJWKkZWkjkA1mdLoSH3prKi27DcWo1JjPC5RFKJs0AXjRymFeS3jzYSy8lQLqEIiYxloVgB63ll5zvQcOc9aq7QGKtX36JVhfJHfzGqj/K5SIie5COWz2eHst1HGH1cqGU6xdDP8oWtovmR2wTjQSgUlFTphqHnbNw6At98DWyuTgu+F5Zhzrz6NkTYY6Xz/4pxQcMjHBuJ4IRWpppd84IGmcZq/HwHXrte3CM/HeU2nD50U0UAIVAtZNyXR2zpE45/RJe4xKyMTr09Q7BGSsA8zKjMDkc+htQoSm+n9Ub1KqVRJcvhu4zvyyLz9Ax65pzGSaGnJATEwWG75llN72yS7rB0w3G9nk0eqvjlU6Pl6tVsC5M3Nzd7/Silsb28f+Pz/xnYb+HiwWfX/RvCXN3qRhtfxSAOI1p0+ZIDknhgghYWEsyzeqcgt9jdf4MRCUz2Zs71Fh81Zk7ycivJoKlr9OnhJyK1VKoE155L3bzoyWajfx8k7q7toydLbwoU/9tEhXjHgJhNGJY8E+Zgit+Wx7KyEtEM5UqMUZo0AxaowIWysI3A0SigwTdh42c91J57DlZFB42wsV2qUeJC53Ut0QP497wSAGqUORAwAWQSsD+oTgQ7ivMfRlTIAcB/6Vo4XsMwsfMRx8vrmrMd1bpzD6Y2xhOW9eP2XrRPOtElKA42VstWUGqPnFABmTUoaq4oEokWXOBlKu02L/VpCwuMiGRq19UF1IXgtvI8/rRP+9m4oo10aKQfeBKUQ7z2WVqIhrSVlJRk909JgrTKoggTcW7szrBRFz7N0fLXqeeZkLOuY7MPEN/EaaYyMUGms85i3Dp0Xb/m8cfHYnD+oFFAo6d+6tbHkMf9GkEng472Pm6z1wLxjspXKIgSpdDMg3vKcF946FwwxRABWt/bAmsO5kHv8rOuHowlSXLY+MDGOHtW87/J/e48DCyP/zE/pAULmqaZBnu4xncP7QClRTNrycV2JWuuhtDbvmRGtpbUYB/Ud6V/xFDdWuNUr4wJFoMHY4JU0WqT1AEQOKCkHhVbCGQ7rAulIeWNkIOc/G5V4y/Rc5sYLo24EVd5nkQNNLrrFvOvSeVUAlWHu5WoLeWK3fKZ67yB/d/wspxYxiiD3HvJDSDXQ4WxhnaYxkTc6etosIdE5MU6Y49EfN4laGD2buq9TzuNYIpzJnAS3ddDr53qbe5DZL6TYkIbDYzrr0Xl62mWcRHm14FmnEd2GvYnryMqoCBHSRGNUKshxhneZ2Z+BZ54efshJznN8hJojaz/3TxpeGhJ5gz+oCpErI3HdESWjvvGc/p6cFDxVx+/5g/vtzbBPb104/JBD/6hw+yCczejDDY2vdbslB/nEiRM9q8N7H2XY+LtSCtYeznX7P7ndzguNXKBs0RevWQKB00xe2mUgCkAGKrMwkkt6uTktQjRMw+SIlqwK1AD5fRE8YNRDvbZbHwhVuLAJjY3B0troLdquWxxZlpEvVRlRSBgH7jQn1NIKX3Re2zh2uPAQFMU+9Ol3rYKMU5io4v056GGN4SQ18PapwzhMXCh8LDZShnB5YwXs7i26UATDYdEIrWJ1ZNB0FiuVxrKT+yiMxrK16DKdYxsWbKM0NqYluhs+escp/ZYMkuRdra0NesEpbKyQ7r806XujULzEe+D0xhhXd5YA0EuOW62E3sGsavL3Ls8XWK/KuDDX1uLVK/vYQNIjXXYOVSe8y1EooDDvLO5em0ZQK7QKuZ+9to1AXCmhegBJUo0GxV5jsblsMK0MxiFMub1o0XQuAkLv/YEkv9Z67NRiiE1KjVljpRy2FtCw6GwC1Q5xAwOEI3piOYqb1rV5gydObOBlzGLf39hvYh+zlSZxM3V4dwqi+jEuNdYCcJm3ksxWaI3GdoHLKFrX8ncr/RAoOovWweguclw5JuiFZUu5AOJBr4yGUvJ+5LnFAJP5Ie9eawXfpU2w1Bqd7YKHSUVZu7xxI6Uhyg2ceJnHdzRqgzHuPaI2Lr2MbMM5xytyI+efmSRJLjK8R+cSF5LXS99P52RBI9mws2tl8z83nL1PkZ5RadDSaAzArTHy+dGVEW5Ui/C3QCnQCpvLRqg1QZHFhDXOaAXfOUyqQoxH9BUJAMRcCZt5H+nx45pMzxwg83IWQOapjXF8dgLGcVDMWXQ2FumR72VrRGngFq30RWY4ExwpJeNaAGbSXc69wVRNiKAxAuZ0Hd4TAZX3QX5u1IcRy9bGccnjcxpDLmXJv7lguHXBAB7m4rBf2gAYSbOgVnQT1WeSXBmfiyDV+6QJ7bwYMwoISbxUypG9clwJhW3WdJFiMSrFa1xbH1VzTq6PcHVXkognfDdg0S2JhFElg//WmWVCY4n9kzzI6ZlzSdZoZKkQ7c3GUhwbWkUllc6nfswBcg6EdeZBBpLziw6T2239deH2juPvMnffDZ/wO2u3BMi/8zu/827dxzdce7vwUv5nLhbpeypO7rw51+euEVB65KGSkKSgk5XvfAo1cRHNFxjrJMS1DIUOllbC2P2KWwSzwctbGSwWXfB+CAdOsn/l3pjoNvKyEPBRmCQxb1KxAnp1CHC5uLjscwAxlMoQb2VMXLAYWsp5XpKsEYCNOqjFSRAHkLsl4M0DUZVgu27hnEj81IE3uj422JpL6NY64R6WJnnocu4stXrFu+SxVpXJa6sMmiDrJc8lxT1q67BWleL5yIxLrWQMjMpUyWt1XERAeGFzgbPHJvA+SJCF2XtkUqK2YvyQJ+oBbC4sjoyqWJ1r2Vlc3F3giEoJd8vOYdzpSDWQTc/h1NoY5vpujArIJqMiQOV7YhIL38c4eKL3aoudUYvjTYVxYWCU0CVa67A2StzdZeeinB35xHu1fLJaCUA2GkEJIxUGKYI3x7oEak+sVZgtO6yPpf+2lx1OrFVxXALAdihWU2aDRSgPOiarUWt5bDSmWfLZsnVYrYyM/aCGYHTwZjQi/1ZqDRs0j+tAhYhRFaVglE5JbmFc0JCmh1wk++SaAtw9Tq6PopSXyHYlaoeDvPeFTXOi6dyBjZMc5v1lF71REl3QIWkwD73K/czqg2CH95rm2MGNl95LrkFUuYlZ8wC8S15f/qShmN86oyyFSnx+gkjnPXYXbdS+BhDD76wCGhOWfQrNr40LrI8LvHnVRECBcH+7dSc88VKoVjnHt3PAxthEg8qxs0Krgsay8/1+ISgmxuU3tFYxR4SGAKNqRkuBpklhsDuvo4RifM5gqDJ6Q+90nJ8+GawEnXXnIkWkMKFokEqh+3TuvuHKz4xO9+C8VD4dVnOjylIcM+HYpnOxcA7VGZgAzLVrEfpm2doUbYj953v34nzyIHN+cx/orMfOXHIXcipC0yUpRyryNE40pxfWRq1ygkPJS5GxxyI+rfW4vtck2tmyi/kp9I7f2KsjqM1VT4wOWtRSOrVHraiDRvgwShoTV32icnGPOTQ/B2lckkLlPXqJ7pxrLvt7PsdzitCwDaNG/D1PDrxVAt1wnB3m3Dqsed53NDy//oD6lgD5j/7RP/p1v4H/W5r3SdcXOJxOMRzwXFjg+xSL3DvBFkNiWbiUi49UGRIw5pAqC9H7xkQr3icgXM2rszpuLrWVhZAesEprSeRzKVGPXM/O50ob/fu0zkdOKQtT8Jm4qdOa1dkCuWhFKD/vH1lg5d9DzxaQeGwKKmopE1B3XhaeWQhb7tSySBZG48ikwAUjCV9aCcePiyl5unRAttZjpSywu5AiBqtj4QnbAOLqjC/uvKhlMDu6hcfCdoLwgveG5ca5SUrxEVnQd+Ytzh4TP8XSWuhCFo37Tq7gxkwW7Cp4W7332F/amOzkvFAErsxrPF6JWL3IlwlNgcCRxx1dGfLEffBCu6AJ3U+gcaE/16sSZaGxaBz2mw7z4PnSSkB9Zz02RmUM785bqnqoOK4Xwft5dFLg0l6LVY8IxJuQ3U99XobcC61xdafGTt1itZIEtVntcPfxqSQdZXrJgJTC5mjJ6UqlCXJ4UJiYAtPCBKoJoo5uFaTUZrULiWoyJ5ZWOOhd2BhlM3VxPFdaKjDyarxmr2iCE2kpBZk/UhLdYSXz0uVh2Fg0Jhhw4qXUqVpX1ggsl60L4yI9P40zF0A0v9sGg9f5vEhMMpDy59BapQRInxISeR4V15iU48C8hl6IP7uGyu6zNApt65J6i0sGNyNLHgk81aHvc08kn3FcKDxycoI/eN3EvlNKQMSsEaN4VBiRFMu8wt57HJ8WmZGYzitcXR3B3HDtYx/lTXS5pW8Y3eD4qIzCSiVKO280C9Sl64ECekzzBDo6VdjPApA1oF3cg+ABZ0Rjl43vm8mEuUMnGQceo+x454UeUreZIlLm+EmAK3l/R9r8/9n782Dd07MsGL2e5ze801prrz327jlJpzsDIUwBRARBjegHRXk0DsBJWV9RJlooUoIUhUVJAaGsqKVVIFUakA8VPYdPKco65wtH4agkkqAQMpDO0Ek63b3nvdf0Dr/hGc8f930/z/OuvTvZCWlO/D5/XV1r7bXe9b6/4Rmu+7qv+7pToaecpwRqkzrfu8EGDjYK8qZ4TylEDpEzeTEHOAC4GDpsFS8DbIUZKChv61wfkusfilqeSPtemfGxDMY3bDl4uDbUSS9k6UitFXfhBKTgr3ze8l4yP+Q6pN7G+BzcUnh8N7Ncq+yDLGBXDpHhRGSphFJ3t4KXuSWWenk92M7U3AuIipPFveH5Zz7qItAWAH+/ULesmbjX/PpCHy+qQV6tVp/TG32ur/8f/TjNzny2QyLovCjc7WQR4vZmmTYHle1aTqci5RCgmvvTZ3Y1FXF50XuGxMTI55wuvhCro4oXKFlwqmIRcCEmzaTjRhEu5lSRKt4PoHO2gfS/ck8iaIGzPjcRyIyCTovVyN6VW8Uop26CbD7lfRW2LjLLJnpizwtl7zyzaj4V4Jyd1VzoBdYkE6sMbLdvrjQ9l71ZndKkF3dbKGZTZbEmb19inMkajVhiaVoBXiDKYrhygZI04do43FpSo5CRnwUi8MJhT7ZvkVowy98P4iMdWJ5gA+4UQBjIfrFX1z0DUypG++j17fkcIxLIFd2a9YVzRqDv9yctGm6OsuL2zOK/7JnxeWA2Te8r59jwvRDLKQA4O20xMIAW9mzgzXvCXRdl82q0ws31gOubngpFI8lHPn17g0orul9aMTikDorl8JGC1EYr7rJIc2mvbXBxNiXwx/NnUmluLEAdAKkNO2cTqoo3r8guLFkWRCldlVhnYWukRkBcXyQYUKDPqrXCzZMhbcAyb9KGBsUWiXnDu1cBsDDIltchV1j0yVyT+VcWE5dfy7EpBcVbjFLxVdYV8R/WKmvuE/vNnyMFeIr/LjdUySxbzffdsixDbLmkgJjkY4EAXqTA76SzCaSVrFulFV5/aR8tt40H6L5NarJYa2qNWVulYlsgu8Nc3m0L0BbT9Yyn2gHnzEAumpbOhXKIRRiQpRYieZk2GmcmLc7P29SoRqsisIpZOhBj1neXawjZkBFIJpaS3FiS93QRtMghAYdccxkQbcv+6FkkZw2+D9JgStZASaGXJE5T6W3Sh9dEedYCunM4SYNK/PtH7xOjKOMWyAC0DJzKBj7Wc9fFkLvgmUAAd8OZzVJSYriZEYDcFMtHznxRplRazItuWilpXFRYpkWZE9ukkYBMeV8pCC0DxHsVIYrrjqzFSuV9L2WPijmiXwyCKiJ75D6K3vqzZcjzdd39us9WcLcl7Qkv3qr89BEjZ01SQPjSI+QXBchPPvkkfuInfgJXrlx50T8OIeCd73wn3vjGN+Kf/JN/8pKc4BfrcVoY/9mOGDMbA9wtp6DXbAvuhXUUc2z6XNYkFQxRuaEl/8WIrYhW9FDyHiUzUGrP5H1eOOjgYkDD7J+PFDnXRWW3Y7CbivBC9kWWxbu8FoCAWtmERM5HNtHELMVtnahM/q0CnuLelRFp2XhAK5Vac5ZgKkZisMVPd82LY9tonGkbtLVCbzJ4uzAnBq9SOgUu05ocMF5xaYGOiwClcC1EZgL53rYsVD07oeKOKRf6SLpc/jaZtDPrv+qp+2AAsLEuFcU4LlwDgJvLgfVxETst6eRIb5eN320I2IwBdzqXgqzeBRgu5rqxGXHc0zX0NuCFdcfvkyN1xYyzsGedc9hYatARI2lKD4YR05oA8mYMqRW3HD5G7E2blHIufX5tIM2tSC0arVMR3rwurb6yTrvSdH610rjTj7i5sTjqSYs7cpq1rQl0C8tbaWCnyYxsKDbvlr2rhbnaaWo8uDdldl9AnEoBSF0pLBrNevmAeSOttcUfPEC0l6UvsjSLAZCCgGQRyK+jIkFisFe9ywwsttV6YhsnM7xkh/Mcy5Xwoj8vbQLFbut0gCbvk/+dWV9hurY2KsFdfP/qijo2SirVpDm+/f6iERdQ7GMuaJK1SezwSkbT+pAYzxiJBRTm2IaAzvi7LMpkDXn/rWNMmioBM6015q3G6MgjfT6pWV6V/a6B7bFT3h+yi8tZQrkr2/dZJ5YZoEJgx6440uJb1tx5o3FxNsEDZ6YY7N1seDkGIrirXIhb4KWuNCa64g6VREIYLqAr30OeSYwxFXjm+hW+jkB7gOw9kdftsthcALrsAVLUGWLO4ghoT3IZPmfJxsj7ynMpx71YUIp70F33l9dn54mFpkAp68RLwJxaq3MgO7AFpY8iz8hdXEOMOOldArIuUpAmtnPSX4DmokpBmpAb6ZkVjLgEkDKnUsOncv/SmSkupUDiRFXu4fK9FLhHgAthw9ZeTJ+d98PTY6rh+ph0vrj7SOvLPWDQ6cz46eO0m8b9MsFlMecf1PGiEot3vetd+Dt/5+/gFa94BV7/+tfjDW94Ax588EFMp1McHR3h6aefxnvf+17MZjP88A//MP7KX/krf2An/cVwfDZ4LNGt/EsG6/aGtf2gQ7FxpPeJuZlE7kJ0L3CNpCP12NbqTJpttqziDUhAp+jCyuNOZ6gIr6lSDO9iQM2A04YIpSNKPWpZTFCK7kuQJU0N0i/4GJiZbKJo5rIOTCFPus8y97Y2fiBXu9ZaIQaRTGQ/Z9n0BkdAbFJXmDdUWCZFWU2lcJEt8eTvyM+ZUvkvHPQYPXlrHm0sLaj82bWigGLeaBjncXbR4Pk1WbatB7dVfT5pKhhn8/OMGTwR4PVp8bSySQE4HA3OL8i+bK+tcSJaVR8hbXR9oA2qs9kX8/bapc3t9tpiNRKb3puAWxuLWuWK7sTk+1xoMzifOr0BNJ6ubwbMWo2jzqGzmQkBaOMPIeKoN7iEnDpMxWE+pusGwJpl8ozea5vEAItMyPuQgigbApajw3Ig/2UJQKVL33LwDNAIjCyaGrHYEIWJkZbhnVMpZT5tKi7MCynQjBGs5yTWsdEaAWT3dzAYcjiIuWOghsKkIRBbKY3daY2aMwcDF9iKjl06x9WK5B69pg5qdcEsC3DQoB1M5Ej0O5UYcTnkPpfBdAluRSdJ9yGzQDJvt5xk4vZ6Vi4dsu5VfG1NpRNjJ1X58ho5z4gsVQAyayYsuwDj0wxp5HEgkjEfiNUX4G58Bm9kV0hyFXneN1c2McTCYu1OqDirrXP3PkAcBehzT0abJWCI6bodIarsxiD3hL8p79MWK87ro4DWSUXAcN5oXN6b4ubJQKCf74E82JJ1k6BRAggJggWMKkWfI59xL5Ahz1gK4ADeIyJ1ZfQhkttHEXylZk4hbrGhIvNKxY1xu0nSpKlgB5eA5Ol7ZBlZigNI+XmJWFCy7+WxrlOmIHBwut1bQCQXqiJwK84UtiBWIpDqc2QfkiY+PnBBI6S4kMCyDzFlVyulUpAmjLrMR9nPaEzm6y0zGxJc0PXkxjiVVhh4fZTssDxjed4ArUsy9lwUaefdz5uyKkUxe6SfTZsqBWunHUfSWEE+7/IQQqA8XgzUlo5X5VFmYU5/pr/H61/K4zMyyL/0S7+ET37yk/iO7/gO3LhxA7/yK7+Cn//5n8e73/1uPP744/jn//yf49lnn8Vb3/rW1AXo/zLHZ0PIuLviuhw45UZVvuZeKQtZRMuJI6yUnIoM4tMWLxoKc95wxctRUijCJGmV2wnLcWKosQY19QDLGziNxClrWWwCL1I+5o3q9D0QGzZaSPTWLYyRtF6lz6kEC/Ee73mvo9z0y9fWFUXJUoAGkH8vQINf1k7LzM+s0Wi0xpS1iDKBnzxLLc83LCnxAZhW5LF7aznCsOShM559TUlz2lbELooTwhMP7AAA+RGjWGDSQinPNG5taAAxHfK8YkTaWJbGJkbk7GSSGTYvLAaBCGqS4JL2+/rSYLSkUz7oHFYDbQrGeRx1jp9BBiZAyXaS3GJtCNALy3JjaTGtqcvfwAu1LP5T7kJ4qx+2JAIAdz4LIfkcxwgccGObSaUx5+YWcs0bE7jBCy3gnXM4GT02I3kJyzjonceMW2I7T+nUVDgEuedZEjSpqgRQZZO7vRzThiT3XTIojVaYVVV65otJlQI8meOy8UhaNDGJWqU21gAHEBE4u2ip+KrS7DWtki+pHCUrKvuF56A4M/5Ik+z09JGNF/klOfODbOGYXQuK5gF8XbJ+3CvVWTPr2tY6bZrlGpM1rnLuIUmTKPVNGtRaKexO6yKdnj9DJDsSDAUGyALErKd0dc6uqcTCWR+xGj2aWpNtW6VRVQr7M1obJo3G7pT0yS6w9SIHD7c3tjhvBsJR3HdCcipIhAY/l3JjL++FgEjL97zhNWtnUuHS3gTXVn1qV791j/n9aiYSxApQWE7Rpra1Zi27BBThLpav/Je4HslzimAww9dXFl3LvDqtWQ4M5EwxZvyp8SKMtrgqiZ2cUsAYfMr6pNsm4JYB6Jb8JskbSs0zA9TiOaSsGFQCroYLnEuwJ+AtAMlmr3TQmFR6awyUc29S66Jt/DbDXn5O6SQSYllnlHGABOQhxqSZjshWjQLg6yJDYIsCXecj36tt6aFSRea4YOjB4yUWr/tMx+kxWXbClOPFJBdl8ffWe36Gz7oHPHpJj8/aavrRRx/F93//9+P7v//7/yDO54v+SOmlz+dvi6crAGF7wbj7b2QCCDNK1crbhWLAvU26ZaCSnjhLFsSaa2B5gTA1MoGUInawrXSy5BJdZS2SixAQUVY0b6ddcuonn49stNNaY2X5Z/w740nO4WNEDbpe0WzrezDmn+ko76uAkLrS8IZA3+6k5uvWEJhEmscK04YLtFqN8SQgxipp0JQCVsal6xs8McB3BtGHqsRKALQht+wnfHbW4OqJwcevr9KmFWLeYPMeIAtjCa6EJd2Onj0DgfXoEwspRYRizzQygAiR9Ie9cWnjPu5MAuAnHT2QpqYU82r0ODuvk6Zczk1YFpIrBKwMSWzamjb85eBxflHT/XRIDEsA6YhDJHeJON9+Zh0XX3UmpOe3HHwC1uIuIfdlbfyWc8HSOGxGj5FBkYAmEzzmLIXpLaXfAfKiLoMqAa5TBsgatCnSax3JRlhGI6lQF7IMouX08Jl5A324zexFnrPOx+SAYlxIgaJokMWpYz6pWLdOgZrMC1k/JOCTQ9KrVBBUpEsTM3S3dKuuss9yLL4K+xs4ECvlAGU2A7ibZU7vgbyBTxqdCpp0AQrldESnGeJ2mjjE3PFvj1uml9Ip+VsBH/K5aw5qJc0uAbxSNLZ9YO9vH1FrLtzVBJBrrj846CzaSmGnrZLFW81ssVKUjSDJVA4cI9+PqHLWqrzWu1LZSnHLYnoO4p+uFWvVFUm4PnVrg4PBbGXF5CilJxEk25K1qbTPIzkPaXJpjc+uHC/mQBLS86GvAnp9zBmMGJGs0XyMaJAzEXJPrAupq1y2jsvXIG5CkeUcpS0czZFtBlmCWR/jlsa71eIhnX19RWO/VdQa8zkQIEfKcJTHaQ1/CgQiBWLzSZ3Ot7xPAK37MqZ9zEBQQKqcjtwH+nfcYpnT+SYCiphdOc+6uHZpNGOc1D1k+YwLol0nMqeu8rwtP1/OoRxmMcZ74oryOD0uTwca8poGdx9ik1ke2cHj3gzyZ9NGf6GP/4vRvr+/Qxbh++36cvoRC0tVvle56H+mh19GmJKCjMXflZZu8hmS6pIiinlNDguLliQXkq6vVN6cJALvObKfNBVpJlnjqFkyYNO55E1YzkhAVbkQqByoYrdpciWvpNTYm9IXAUOyvSnA9xbgvsd9knsj95Xsu7g7VCD246Gz5AQhVl9ig1QxgxwRqUUx34NGKzx7vIZWCpsxF2rc7gxCiDgZyU6oZlDaJICsMWV28dJsgkor3FqPaQFP42hrAecfgdJjWwxhCNzCm37ueVHrbEDHKdA7w5Duk/chdX/zkVL5A2utYwRONiYxOJvBspd2hLGebPqQQYhojKUtdV1pGE+tqmOkMRVCxJrdQJKmDkjpS2GGNwyqY8ydwogRJu9gKSaVdtLzpsJgPfs007n3RrxL6YYtB4+B2ROXWC4633ldw/qIpbGJ0dpYVzDIGcTMmwo705pkHCEQM20s5hw4ge+JsKfSCKWtyRd3Z1KnwFVSrgCnR61PQPzOakwFeHK90pXw1smY5ty0qVK7crn2SqnkrBCjbPbEbpUFLJowHAUAxZolvt4SiJxmdYXdVEql8QZgq2GM3Ad5hgBSAJHnokqbeoQAhNzYRf5eZFdaZ1bPx4j9OclqVoNoP7dBi3SnFHlJiCQPCgJG4nbKt62rpNOV9UGAs2jCz09bksPUGjvTiv3es5NFUymst7odxsSWROR0shSAiWWdzJnySOCTn5tngFRzm/pKUUfKw86m5kRlsCr3cJcDCGlwE+SeRpr306YiXSkK8PwZ9rAtBjPk7opJ5occVArbXK7PwlwLY53XNL7nW88wOyH5EJk956YeDJC1kkJreo/RUpMncUNQzNoKc1xm2AAk1hh83kIICaM9ulzXoJUUrfH18HUMPC4Dn+d57shZVzoVfcuYn1SUbZV7JvUpsseWmunS0lDmsnwP3FvPW+73EXQO8nxDFKkaRTKe12HRMsvzLTFCGQykAAIZN5yGJfzWaXyUh9QiySGZnXsRXKcDXrmez3T8wcLj/wmQP6cjFgPsfo7TOhrZhOV7WXhOv395bAPQvEGePqSwx50anEopbFiTOmdmbIdbEAso1cXCCnDBlCfrHCmumXF3uUoV3bCAZOElm7dCZpBP6yAlJbY7q9M1pOK6SNXbwqIAFNknjVvMm7fcj/LN5dxToBDZh7YSLaRiC7q80Taa2F1h6GtNxvw2BCxa2hh9JJbwYDCUymcAN/rIqdaI5eiT0X6pt9KKIv1GK5ybtag06WorpbDss/64fOyn2TwB+HJNDf+bdM6S/iQpgQ0E2uVeO08pZ4DAxGh96hwYYsS6txiNx3r0WLMeMAQqNBrZx9oX94tYfdqIJ5VKld8AcIZ9nY3zLJMggC5pRhcijkaTNqQA2uwkqzHYwIw3/S9pcBlnJ6PFrM5OC6OnsTnYmAKXweUgTTIupgBca+uSCwZ15Mt3XgK4WV0lBkgY+I3x2Jnyz/kTpPhGK4VJVXG3QPZtVrnrWLYkYv00b+Cbkdw9aq1SFzDpsnfSWWpMUOmUHqcxzkGfVqmleWDWRxw2ZO6IbEoBaeOUuTZpchtcIKe+ZQ5Jyl6r7OsL0PMsl54MilTqlFaO53jq/eX77EaTMwwxZgAtWvQJFzyedDYF3bLWaIWU9haNcoxgWQ9luoT1FJA3rVXqkGZ8wJTXzGmt0Db0fC9wIFtp+nnF91k0yY1WXK+Qu+NFvmgJyuq7GOR76yYlSJY1jxjq7NxhQ8TGOhz3PsnlSpwx8ngS6ZF4B/sQt6591lYJuMa47UxRnotS25lIDQH3BStc/F2MSMVq8vNUN8JvI+u3ANZYjENZo8oCUlnfcl1A6Z2dbQqlwYWc7ayqts5dzrLMSgCi2c22kiHmJiMyHqQQW4rYyNpNNMl0HcedTQGNSKPkkPeR+yKZKGrmkwGy7DtpzUfRqZCPsm6pPOrq7vFEn1kw9cgZLPksuQZ5Bi5kDb/s24Oleg1/j3Ei5ym3+l5649P7Ga1P28GtfPY9psWLH/eJu8rjfsnMFzv+J0D+HI4IYQ3uzV5+5r/bZkxlkJVpzs/0KGNEmvWykZZHyx6SrkivBAbTwuzsTElPfJYLzuQTK/bhldRkWTm7GelvF03N0XUGbLTp5CEki4os0PSznCJTyIsiFfGoIl2XDctlM3E+YAw+aQqB3Mr19DOQyV921koFOqcW6+tHxLJOK9oUkx2eZuDnydvYF3ZAVORF1dM2UBpfXB869u2tlEpWTPLMiL0mcFQparSh+Zn44prlyGwLMR/iDSrXdbQxWc8Yc5pzYB3dYZ+LiqwnqQRAqc7Bso6OLfnG0cE5jxWzx57TpZKmq9kpQorN6LMItDfMkgyWTvjSbJp0hIMTvR9Z6Vm+78tR9NuZDRW23YYMiq3LhVTCwKysw5y14zEiAYuOF3MJXGQMyGtGH7CyDj4AHQNkF2MqcgTEClCl9LawLqRfpMLGc7Nqy0dUAEWtFI8bAru98SktLA0RALBu36dNcLQMkNl+S0CsVmTnJ61t60qh1dWWTVOlsl9sKpgL25tZ6d2adLD8u71ZTdkCyfj4bFEGiH963JrnSuXgW8asfFqlSXs/2nt3VC2lBgJyaayXoDnLgkRaddJZ1JVmaUAGTJY1lYOnoHDWVmkOWU5h11tAMSaWMbU5DxELblgzqYmpr7TC7ow8uivFLdL5Hkw5kzZtFDfMoHUzLcvFuq4LmYD87F6kBsA2i/HuVLZWCp0l68m1kS6p2wCV1pBsmzfYwJmBXCgdYkwOJZFfJ8TIvY5StlD6zQqAknWX2Nqss5esWPlVceBUZjvLQ96jTNM3hUtSIm+EkOH50TmXWHcKbFWSpcgh63FJ/MhBshqpZ8iB+KIlskfcKAAuzgxkDVeSVQebkTJq3BtA1jMKhvI5BAgAFyC9PU/TPS0+r/QXTvsotsGe+KmXo0YVf5MCGw4qhG2XIll5rbhcAEgZ7cHQXldawZ4+Mmmz/fPTrh3AtoNOKemRvVXu1Wc7fn9Q9/M7/idA/hwPpT4PhIztqmVJAcsCAtxdwHD673JBDfsGKqRNMkZheorFQOVNToADMQkqgS4gA1NhZshYPv/7xBjSVk5IRSQbt9hr7TZNOk+xUhNwHWKprZWiBODWZiCvV5UlBBE5xVxathEgzf6OU76G07Pl9OQR0CATXFgTHyNudyMA2hgbrdFWGchUmrSnZyctg0Xygh5s7p5H1kbEvALEaES+N5LCl+ppYSZu9QMmbH9WqaJA4dR5kzwkJJZ3d1rT8wE926POoj4VbFlPm571Ecc9tUZtag3jAtYjsUq9cehHB2vzew+DgzGBmOTRpfQftUYOqSq+Kj7PeWKxhWU1zCouJgRSAohJlA2D9H30mceDS+BVnlFTKS6WzKk+yylgxWNwaSw21uHspN1afH2I6LnpheFzFjlN+fuTkVj13lERoHE5LSxBm2w4DRcYypgLkYoNH5hPMa0zYHSBxmnDXehIa06yHGHFieml9620Sp7P4g1M2QWdfVcj/WxlLTUVqfJ7l1kbacEuzyvymCnngGy0ksKVgFwpYG/WUIe8KNmikHxbk0dtpNd2oyvWIPp6V7OLigKDkW4KPduY2X/5Owk8hGWUMSJdLmOk4Khnn/RlTx7GowtUoApaYzbOsSzHp4BUAhYJrlqdGXZZh6YspZD7dWlBbdhnjU5r46yt0hon2SWtgJ0JyTMWDMYbfrZRLgJ53RLGswwM7sUgC4je0ofzmFMKKbjtmZknFw56mEqRLZwLWc40sHew7CU5aMhNmAAkqdnp426dNJ3PaZs82XtCzARPuffIvJJrOd0ZTqvsIFFev1YiiZP3yay2gGzFtQEluBLCQCtsjVWxfCvvd4gxzVXZH4Tc3J+Qv/WUAymtKEM62IDRxa3rORxIXtcbjyl3Pk1jTUia4n4DRMiUEgsAW+tQjJG7HKqt34OfwYrXT4DWd1Vcb/m8SiAtQbdcTym/iDHLESWIlmBAZCbOb3dYTM/w1BiX416AOsQs21GnXltV2+/zOTHKfwDH/wTIn8NRTvIXYwTk2Ppt3LZLKQeDvGPafF7kbUvGRhZwea+49TrpjocE2mSCSupk2VNBVq0EkCJ9VVDJ+zOA2ukC5LqgkDfrRmtUSmMxrXP0q3JbUYmm6X3l9zTR7/Qjdyujz5O/kwYJpeezNLKQhgrA3Ru03GM5ZOF0zEZK8Zy4OZwYaTdMEotpo1Hr3DLZhIAL80kCIVI1XabejQ8YnbDKuT2ptI62zIa6EDFvNVbGYtZobvChOXUmDHI++ZL18uHuaz0YRogPqFZiq4TEbC8H8WOu4AMBZGpn6zAYD+dI1x1DhDEezgWseouRN+MQYmLORX8pFfDEppAeU0C6Yas0Alz0fVk8NzgB5NTCWhb1KJQUCs0gs4uuAOgAsDIea+NxYTFJY1yKAo0j/1G513WlmVEkaUdnC6bfkCRDPFRFkCGaXqWyZ7hom6nIJuKJ8ztYtEXnsRhRayp4FdZJiuyI8c3aVrlG8bxOVfha2oLTxjF6ute9o4580vSgSq+jezfR1VaHPiB7zMpRV6W3eeEmA4XbyzHZl0lHwj6xlCqNc6VUAmdyzQC74CADmKaiwk7jsjetuAAMRdMJ8S0u9ZMRlKaX4lLrAwZH8h7p+Ge4sYU8s411qBSSy8zRxqbn6APZIbaFy0Cg6BzTRiV9uI8RLz/DjjLTCrOW1rFVb1PQLuylVuRCI240UhAn0he6rxJsFdKWck26x5qVx/12gC/3azMyU87MvEg35LBMHlhPWRFZHyUgkPckH+p41/vfdT5abXV6q3nPygBZJcAsDKMcZXOJMhgr9y3wz1Ob6TQOMgiU95bPk3MJMWdixUFJboXQPVIlECNSYWWpYZZHILK3VPfCwfgju3NoAPOmJntTRZKr0WciQObSxlJ76cH61GU1BXyis5f7zfdlUuv0mvI5BBSWrOyjf/pZaaWS4xBAcsmyi6K8pnRHkd9USifgfZd7ScxOSbIGi72lBJKVVveUKpzWG8vP7nUIQVbOg1CMgXsxzF8Mx30B5C//8i/HT//0T+Po6OilPp//MQ71IiDtM/2JKvXE9H9ZtFGCyXIBk0/J4nnFsoDMGJd/W5qQK7D7BLhNMG92o8ttbE9dFi1SFbGqAJJFzDmWZQgQkChcAICkqKXgjc55W68kTTpORreltZJbKZrNsjLdsH5VYdvyDHjxlItsbqUeKzUnicCGHR80COjPG50q3GUTn08q/nvWsIaYNksBkdaFtNi7QI1BRk6nWV5UjafmERsbMOcqc63ywlefWjBCzJZInhmKXNQBrIxFpalIrdGU4xWW07CMQinFDQhi0hL3xsMYR7oyXtis9fA+sNQit/mWQhyxwZtPsv6SNrb8PCWAIH1xBikyBqVIJ0YkayZpvBCR252LBdq01im1J/IdKkIMSTsfIhdTRrAdWC64mVQKi2mTnnVvCplJiKkpQGn7J1kEOecQsdXgRHTlZ6YlQKZrnTfCKOqUAWkr0u22td7qDlbq6yVo1SqzPJ7ZLWnII5tfAg5gMM/SF2HwlMpBsKwtArC3TljG0OCSXWFbawzesz46W/rJnDO8VpQbu0gw5GgqxcWRcevjQiQ/WUn5O54P5R4qAXWynvSk2VQMjAGSUow+pg2eAgiFzhJoudONLCWgMTH4kIJ/ICf8Gp3dP2IEvuKxfQREnJnWmE9IYnHYmbR+yP2qK429aYVJpbDPY3BW6xTQy8CRPaGUgdFn3Xulyu4Mwq6plObWisa9j4Dh65TxJe8mQaE0/pD7H5j+LzOILrAD0ilgWx6JadS586CALgH/AnIksJPrOF2ASOtcHn8ErrP0qJSVyPg/rb8tGeHISFtqSeQS5HOEdZdAUqQl4ihSAq9KqSR3iMz8aqXwxKVFyoZJI6dFU8O43D5bih9FE985l+ZMWbeQ9rzieSUgjcxGn34UTb0deIVizpli3aLi+QycgaJDYRGoABwQcBHqafAMFJkO5H1HJBmyPt9rxJyWi4w2O8jkZ7itsz799/UpUuwzHeUadL/H54rT7vr7+3nRt37rt+Ltb387HnroIXzHd3wHfv3Xf/339aH/ZzjulTJ7sSMip4Dk38A2OCrfVzYGSZtK5yo56mLzK99BFjEgL07E9KoEMAWcaY6OBdiWEV5baUy5KEWsxIQREM3lvK4x5TQ+kBc4gCJnirazbETY6aZSOBnurnaXo9GkvZPrFbaA7kexAWN7ssh9knsowEOYpxStx+yO4Hlj3p1UmNaif6TF79ZqTBu2ZVAlG59E2Y4XEmK6PSaVJp1pzNKQ0QfsNDUBPLbbI5s+2hCTrATEFAl4FZ1sN7q0CIVIbKrcw3lLbJaPlI6VNGuliWFwnm3dIqXKx9HDMhASkB9CxDgSswxkViDy59sQcXFvgghqfRsYELtIbh0RJMGQluNtUyV5BAG3AhR6YRyZCYtiXZfB9y5LNSKQvKMHG9CbgKN1bpN9ftEkbZsEHjECba1wbl6laxkcOWMIWCcrpIiWm8WESIWC4lIQeGDJXAHoHD9xZ40L82YrrdzWCrsTsk8SgCwSDwVwE5E8ZrLmvPQgZxCsuDi0rolJTpIp9jktQIuwRJaDN60yoE2bcdFCORbjRyvKJkhl/d6soWyI9Sx50bnlO2gNks1c3kPGvMypptbJjUCmslK54EeCLsNSCfEcFwBEBbr0niNnQhqtEvNpA8lipk2F3lH78kmludW3xiFLaJpaWoBvry+yabcpLU0n+RufuA0AOD9tMa3p/t7uR15D8t83lcL+jAoxz00oizFvam7okddhyZBJNkKK8Mq1qTwEEKY0Oz9vIQI6G7CxLrHuqaCY/17GwLJ3HPhlWVByUtEUvIj0S34P3F04JQBLWFwBwgJiZAyK57DnsZf2tQRaY9JiA5w9BdJrGxZvE3lSZEZYqiCZiXKPjSBgOdFV4b1/NwFTyvMadpiot8gYsvUTiUVmLoFP3+kAAOd22iRj3Js07IeOrUBRnm3vqNW0yCtiJEmMfKJosrVC8ldXUEniIPet3Mtk/QBygalIM0WfPBifpVs2MOvLErFTKLLR1PxIAPAWiaZyga/UjdA6Ku3V7+5gK+eWsp38/8gF0FtBzmfASdvFk58j8v0DOu4LIL/tbW/Dc889h1/+5V+G9x7f+q3fipe97GX4sR/7MTz//PMv9Tl+0R2fT0wimxyQFxCJ6rY2ygIgy2AVuywZpE2lknZHqe3JlW2ekFjiVpiHmM9FAZg12yljBaDWFK1OKyoMkiVUOguJ/ni3rTGtKhb0I7ED6b2U2lp8ROfcVKwdLIoeKo0kf2gqjbW1EDss8ciMoMm67G0Gu8UE25K/FIu6pM/k/QS8ukgeubXSODOtEzAzrMe6vumJzQ0RvQtpE5eNTxhLqaA3nr6XjWh0zO4EjwuzCYwLOMubq5xXdYrFF5206MJIgx232W9DafjV6LFmf1njApaDh2X3iQkzXgKYR+Mxji5JKgQAe0+A3LkAz8FHqYUXx4eDFblPTOvcsMb5iEmdtao20HlPuVmBPAfphCfnX3PzlIo3RmFzpw0x+A/uNYmF3mPGVpqOHPQm3f9Xnp2lzfQMF58Sg6y3CkcHFzB6suDzDPh9jJiyzjbG0nQ/62TdFsMVcasbcHE2TUwRQJKg87sT3owp2BEgJtcf4rb7gFxbqd2MiGnDPjNpkr0ifXZmkIHsYJGlOLmQqPSLnbKHcJofPEcqZoV6T8Wi53ZaDN4Xpv0UqJGzRC6MK+ecbPqysU9Yt10WCFMQFVKLZB/oM00ggFuzQ4foQiVQ7B35WzdaY+McRpcDzb15g855DI4kNp0NmNUVljwPpg2tWWWzkLQe8TpTOotcWfcAgAd3ZpgwMDwcDN3TLcYR2GsbTBuNC/MWCgqLusa8rmgv4LWtfE6qGDvlmDl9KIWtsREikguMcR6HnU1yo1YzII95rg6OHBUGDj7k55nNzjpfOQUZeyVmVwwkxepM/t8ae+wwUVe66NxYSHlOXVtmb/MeUL5fWbBZujvJvdguiqWvba23JFyR55fcywQsY24SVdotyvMUFlteW2mFm2vys9+Z1BTEQeH8bpuCNAkKAmKax2W3xojIQWFMzYLKIwdoco4x/V1ZyFaCSpl3k6Qtp2sWmaQUY0ump3xfuq+0Ti0mVaqJKfXpp4vqk6RDS28EWafuRj0y/yWoG22WQ5ZHmdkuj3L83S88/oOG0fetQVZK4U//6T+NX/qlX8K1a9fw1re+FT/5kz+JV7ziFfiWb/kW/Oqv/upLeZ5fFMfvJ8iR1FJ5TDlSDDFXPpc6Ifk8KeqTQ9KnKQJF/pq8kiFpxbwRySIl/5aINhTvU2uFtlLMLudzJX1hBvE7bb0FCGVxEisehQxapY1riEBbKXQmJK2u6HDJhsti0mh0zqd7kjox8SQWTWMpnyjvgdyfxGYXQEe+StWy6Mp2mhr7sxoB2fvxeKQFyIWAzhCDXGYBZMNpeREeXcS0rWB4QZHztiHiws4EPgAXWUMrmtxKUyAih5j7y99JNyzjqdGGDcSATmqF9UhAI0aK3KVxhmX7qnOzGjESQN4U4Ni57EEMYQ189qrMUh5qv219xEln+XxRMIExpZglxQmQnrN87j7Q6xLLwwGWxAWkdVZYtMQCv/rsHmlgQ8SCQaLja8xdDCP+6CsvpazHGW5DLYfosDNrHFIa1AduUS1FXDEmECEbnFiNpbEVgaPeJX2yZyA5bTQu7U1S8w9JS8pXHwpdKIOBilv+UlpdJFJI0pJdbkCQzonZJwl4a8VODBGpEYI0iqiU6FpjmqdylAyaSH9qrXC0MeSCwlpx48RTO0t9hLFWqvDXFWY0xtRlrpyP4q8tjhQ+kOOI8fT+taYOn1oJ40lzS5w+pnWFjXXJO9o4mvtrQ3aEba0xsuxGfLVnbQWtFXoTYLgVMRVPcSGXyiwsgKRNf+0je7Q2anKriSkYpnOqtSKAXNPaKan3eV0ndlLWbnnvklUV5u5eB9URbBej9Y7WuNEGHPYuZaokmJZ3ElLheDAwLqZOm7L+AtmVJYNBcfW4W8qnT41fAsP5msgr+m77whfLpso9TF/L13LQJcGpBCSyNpIUa7tGJkLaaW9nNHRBwMgRwK3KFZJ8KhavFYlFuk+aimMB4NZyTMWk04aaDPmQO9oCwKQmQkWKoyWocpGCeZUvc4vVrrRKgF4CUvndFktb7DOa1xpZv0IkwqpkgG2xXp2W0IgkU4Jgmbfy+T7krEX5t1qVzjX5/crnIe8jmdZQXFN53GuEhFB0uvw8sdXv18btsx2fc5Hee9/7XvzQD/0Q/t7f+3t46KGH8Hf/7t/FE088gTe96U34vu/7vpfgFL/4jvsRkp9+iSwswLYmiSLx7JPZVAq+SJXJxlOO+YYBbmnnI+bvY1EooxTpIeeTOumLJWWrQNpSXbzY8aY5YR0UTWbWZPrsMasVWcbN2uou0b+XTR9ZHyaLI1UQE4gcvE+Dr9KUWl0Zh3M7LXv60rmI764UJUkaJ8RTJurFt1uFAAy0iUnIP/OBzN8VyKLr0oJ0q4MLqLXGce8TEFiNxM6enosCkrQiQNzWOrE4lnWENgScW5BH8IP70wQI5JlPag2oDKiEoaMOU8SoC6stKepKiWsA3QfxMvYM7JpKY2dSJXZ4M1hYG+BcgE0OE5lJkHRhWdEsmQwbIreyZtN/kJ+ycdSA4zQ7c3ZeJ2ah4sBnt2lSUZ8AVWk8Q+Cwwv60RojESqdUKzKQHBwVXwnj8f/52A1QoRxnSZhtGn3AMVvdSeMJ50nGESBV6zFtsiFS6lN+JptFqftWCjgZPG52Q2JMKq0wazSev9Ml6YQCkrxE88ZlXAZqBCZOVZkzeJk3JNWYNFUCp5azCCVYE9cMAl30HtQpM25ZMAJZKxxlsILAnosh2VPdXo6wgUCZiwHd6NE5R4Eu36uWGWJJ81J3ru2uX5Lul3Vq2Vti4hmMG7YiJEtChwhgf9FCCk1jJDDXew8Fcg9YGYcTDlSND7h60uNk8EmCMViP0VIACwDzSY2atckjr2XlOWlFTBwBJ5WkGJ++veF7o5NeXWQ/MmbPTBrSa1tKc09rjVlTJacEhW3p2906ZNz7KMZGzfNl8I4zRyF5IMuaLCwieG4YH3A0GKpBCD41VZHn0ohHNP9HbZ3z2KNzy5IomTeaA4a6uI5pkz2xtaLPLwvGT6fhJXiQr9sBhErMuEIuGJfsVqVU0uxuBXoqM79CwiRLRSXSNZHV0LyRZyGgula5XkCmS1NR91ggF7ErBQ4g8zyQoOJM25CtZShkCfx8hGSRfVDOXgL1BDBjfpanZRFyL0iyoLCY1CmLKoGs7K9SNyNHGh+R2HW5furYuV0IrkAFvj0XnLtY6Kc1PSMqXL0XAyyuHdlP+cUCwXtBphAjOuPTed3Xceo+3auRyhfyuC+AfOvWLfyDf/AP8CVf8iX4pm/6JhwfH+Pf/tt/i0996lP4kR/5EfzMz/wM/v2///f42Z/92Zf0ZP//fXy+j0KYrtOFDKWlDZCL5LaY0ZjZLPmpFLT4iNR3XTZ8aQebLIeUwvmdlot7GESwJ29Z5V4x21ZXKqWodfE+Y6ELFp/XBVd0A0gbXUob8cYsG3pdUXQ9q6sE9Er3i571dud32sQ01ZXC6ItCE46UxYXBF4uC6Aytyz8TNk0W5rLwhoopiMnqncfjuwsA5FjQVtTwQWz4NoZs3YThTYu85na0ms5vMB7GcdEUM87WB1w57OFixOHa0PPlhbHSioq40jUgLVqW2be9WZ0YipEXoJE1o5YZo9449jEmQNK73OHOcvc856ggT4rxTqf/JMiSFJnmazIuA5/eUhAmfsrl5qh4HO1PKwKiCWRHnJ+1iYmSZ1rTDgulgEVdY8ptqD9w+xj7MwLZUvBIz8WzFpM2jueOCay2tcatbkgWbIMj3bZsWI6Bhmhcpf2wCZkl3Z3WiREVBrlkqTSPT2nCEiMBtL1phaMNN2aByhtYyEWl1ucMRq2ozp4q8FXaWEKM2ONr3gyOsgLWp7FcrhsNZyxizA0m9ucU3DVabzUQKItrhMmqFQGmwQW0usJm9Klj4OgCjkfLmYm8ke4wqz1vq1QM6mIuUE0OMWwfFgGsBwcfKTgZvcfg6H/HgWk3OqwHl6Qxgyc3gJH1xT5GnIwOJ8agUgRMr216ClZlHjiPF5YdeVpH0qxP6irp/8Who/T5mTVU0S/jGwAO1lnDPNisS58UDObujBjkzjrUWvS6mW2F2pZ2tQWJIevTix0hZteRGClYGVn2tBmpNXzL5yMyFqlhkA6RIrFYM0AWyQ0F5CSFiFEae3AWoAS0Kut0hT3WCtlRId6dOpcxV0oh0t/zXFcKqaCcsh8Z9IpOWP7NH5OAn7xvU4z/LXkAv4dWSJ8VYyEzBLipUZWCX6Vo/zxd/1NXuTtsb7KLjHhwy7ovn31xPklzUJ7HtMoyvXwt2SZTgkwJpsv9spRPxOJncs6LaZ2wQIjbjHGJEVC8Z8IL/AxL6WYC9kCa/+IdXgYx1kesuNHYXWwtn2/KIPHad3qoS3bk9OEDtz8P27rlF5sqdL/ufo+X8qjv50WPPPIIXvnKV+K7v/u78Zf/8l/GhQsX7nrNG97wBnz1V3/1F/wE/0c+Tj+8soJajtPpqdIFQAaE2lriBSBzupsL+YTt9MFv5TOUYt9jlWUOPYO/8jzqSqMznhwqall4MjMw2rAFhgfjcWZWQ7yP5XXiyyopoyl3OBImY1ETUyjyBrkHZvToNPDs7Y4kDYEAtDQVMS6kQoMQI1Tcjh4DL6wu5L7vpa5bfG7l3wLAKqWwsg47U2oRbDydY2dC2lw6SyxYWpCLlOGs0SklvRkdF50p6sCnqGDisCeHh5OeHChcCCldmAs3MusOlSvUSw2nSEOWg88FfZE0o23R0vfOxqZCSJJPiHvF3QUXQN5QvI+IVUzjIUZgDMSyk94xJAA5a9lOq86VznLEiFRQIoFCUxF7qkApcDnXplI4P53g2eUaIURcX1o8uNfifTxGhEUZbcDAz8vHyKlwagl+dWnSRl56wza1Rj/6LfbCBSpooUYhdP/2Fy0606fNSdgVmnvEJm4MsXkhUhFqpUnasTIO04rkSNIoRaucwtYqT0eZ/9JBqtIKa0tNDx45N0N4TtqWIzkTxEj3aLSZKZMjFZnOaMRL5z1xq5FnoZA1pfLnEqSsrU0gFjy3Bh+waHLhX8NSqjPzBqMn1la04zYEnPQ2pftDReOr46JRAsTsF+4ItMIHrEaHmydDSvl2zsF50vs/tFPj+mbAegxoKofz0wmsD7i1sdiYkAr0rAu4Iaw+zwUZj87HZOUVi+c/bzSDKZUYeMqQIDmIhFiR/WOVLSzbmqwgh6IxRMXZC12sYwq07i8mWTolweM9Dw7ERLoRIrlwDI7Zdy6qbRhAS9t3yVRYT3NBJBaDpeDFp+LKbZBmOWDcBmR5/ZHz1Vo6kBbFq/c4ap2B7F17FIp0fMQWKSPXWmrrZfzJv6UhTVm0VrLjUiwq7yfZOX0KKE/Fsozfu610AtRybtM6Owz13pOtqUKqBRG5lJzf3ow8tMVuLkbJ5ORi8hBzYa78m3zfMw4QhthF2hNK32GRm5QHZQC2AxwB/0CeB/LsUTxDmrOZZJIxYHxA5zwV+IVcq6NAv+s50+JCRFusP6VuWrLd4sltXW7PDty7WE/WuRKUAy9ORFLwXXx+eHHG+gt13BdA/vVf/3V8wzd8w2d8zd7eHv7Tf/pPX5CT+mI9kp3afb6+fHgUaWUgKYdE0nKUPdMTaApxa5EV5smFnBKX1PPW3/Lie3M5pnRUjEgyDDkfmbjieThhK52qOJeedcGSIpLIb8umLGZNkg0RM5BThlRHh8gd6gKbkUs6UmtqLzwGHG0oXWiDsKQc1XuHWahQgauno9qKokVbV97LcvGVdF2IOXVKTSYUTnqHKyc9MQY24Py03eqcNDCbJwVOwkY3NVnELbmt7co4KjTUEp0TyFsaKjo8GS00srNDXWnssm1UBNICT2OH2PAbx0OyPZOF97jPkg/RGU+t2GlF3FxZrBkYCmMsrHsae2VwJE4LPiCiSjpEFwmgz1nyIAursOkno0VbaQzWpXu6Ljr3TSq6n1dXPSZVbqG7MZ5lI7QxPXZhjt+5eYwYgePe4Y8+fg7/PtxIQNsFYlRXIzcXKDIJi7bCtaXFhLWJY+HG0VQax85s6Y/lWcriLgGG3JJyDEuatq00jHPYsGWeBgGxB+ZT3O4H7DR1fkYhogql/CBveG2lud252N0JIMvNVZbGkmSnKLoS1k3x9zGtDVQAKZ7Gk4o8oHNVe96gtvSgUIlJ77ijY++oXXpZ3CaM0+3lmAB076RdecCkofNfsqTFhoCo6b4ujSV9ZgjJS52yRhpRRRwOY6quB8hX9qSzWJuA3abBh7sVVjyG27PUgOVgY9GNHotWoxeAvCTf4hAiTnqH+aRKjXYmNWdreCFVHNA2tTjm0iHnN2t0auZSa41ZTX7WWgHHG0P67eC3CqZa6boWs4RgM7jE+AHb+s3Th0iJ5m2V7uPoQprfI7P5KQBMhAhlLXyMWJvAXr3UzVD2BqUyoGyLsSb7RglwaALENA+EzS73iPIQYNdqnYu9i5c0bEsmly7AVfYLkQkJI97UeqsTo0gwRM4UVAaUKbOjFWv7s845xG2LPgXqAivzWiuqr2kqnQJ/gOazHCKRkPXYhYAAKkiXotvEqsZcaLk7q3kNyM2ifNhuRT05FUwY3lfGAvRWBYAOfJ8BpIymrE+iXSdXnHyfZd2KQdYPxV7iAaHWiD7XBQhZ1TuPaaOTxKIbPWf7fMpKJ+IugeKMZeT9RFYla2rDwY1WuAsIi5yt9ENO1xC2ZT9ylNipLC58qY77klicO3cOH/zgB+/6+Qc/+EE8/fTTX/CT+j/Lse2ykDe68pmWZuj5tTH9DsJkFeApAYcipVFXaruSnF9vA2mIpEKadKY0Kfdm2S9WBltTkaNAGUkCIOs15AG+cY5am+pcqVxem5xroymdKSzDtNappbAwwqI1HlzAwTByWp/SL9JGWQpXkn4USNcv97pcPIG8qdTM1EZQwc681QhA8n5djQG3+yEx5xf3JqnTmVaAEbspBmvSSa6pNGsawU1ViAWTyL9jgD/wM+k9WbD5kP2Az8ybdL5lmlEaAJDHKy+WvKye9G6rItlaZhv5fY57h2Vv0wbiiyLPxCIjBwCzmbRw3g4unKdOdDttne6zVEzHSIVr04YkQTsNAYK1CUkzPms1euNwfTNs2ZaJJV0ENVzYDA7HvYP3VCzWiT+zOIF4kpEcdY7cLli7GAK5GRxtRtxZm1T00VTZjs64gIFdU6yP6EcCeDlgJOlLOXbKGEIBPB+yXZxSJEPanzfkyStt3mNIIKSsYpeAasIpWGFfJ41mlxbg2jG1Pxe21frspzqpt4FuLM6z1RUON6SZbPmcJONTPlPRlcoYGx1JmgbvU5ZkYx3Wo0/gqfcOa+tSId+N4wG996kF8qwhOUM3OmgwGAWN07V1yX2is47tsPLzPBktjgaTtJNr43HUG/KtthZ3OgpIVqPHigvzTnoP42jDXo00Bw46R17vIeCkM1RJz9c8qbc9YTWITZT5K3uyBAXJYpCDaJFtaSjc2oy51iD5UEcGWtuslwAsGUdizXU6cyOv8ZEKfKWQc3QUhApQkEMKHSmQy4F0z4y+8TFlUEQqJWtmyzIHkcLkQnCuRUAGOaLtF2Jja07EmFg/GXNT1vCXx6TJ1wNIMd3d0oaR9afTJluGKoVERqR7mFjY7fsnzwj8fMXzH8hjfd7USesv51ZXlAGU5zgpGGUbAg5ZdiOgtNQWA8DxYIpzoPMoLR3la8B2MXPLVoQiTxBdcil3ke9U8ZzLf/uYnZlEZy1rH5BZbY+YihWFYJH1W/bOEKjXwMaIpSKvkyzZEznfhjutlofUQPE/tjKdUqSbzl2pLfmjnKcU8ZYMcw6Etp91jPn5C3HyRaFBfstb3oLf+73fu+vnTz/9NN7ylrd8wU/qi/Uo/QPvtdidPsrB/Zk0aOXgKFMjsvDKRAgMKiSdKWnqyOcmg0rxv0OkBX3gjV38lEXXVDLEHbtDUBMQlVNHfF4m5OpuWsRD6lJX2rgIiykTXtLAVGGfF7lysokFl3HUJUsswwZe+DvnMRYBQUBOhZNXKtmwndY/iVVWpanIQQDloiFmaHCkvdoYj+PBs41Z1kU1tU6FXlLAZhylQ+tKp6Icqay2IbLjAgcVDJhFw2sDgUfjSaZxWlvXsKyBmHBaBA4Hw5rpkDSz3ejY2YQXEy5Ek0xCNzpsBpvfr9gMT+evQoiYzZpk25TGoVJYG2ICDFvDTblYy1iPgIiTwdNG5gIe2p0RG8upNeMCzkwr9MbjxtKmtKd1ua0xGCw+d9RhY+gznI/4xPEa3kccdS41oBiMx8HGYs4A+dJOA+/JH3fZWRxvxtQme8qbc4wR/UhOCIMLCWhL8CML7npwW9mIHOwR0N2d6LTwpwLXRmM9OBgfUvGStPwGtjV3wpzLOPGRXDQWkzoVAAkLLNp8YV+V2k5hl5t/BAEf8USdNlWSxiT/UmSHBWn8IPNy41zSXQ4uojfUkCUgs8udc9iMNP+WvcXoPHUR48FiQ3alkGv3keasDVRwthppA5Z1y/qI5eixsjbd984GHI8GnfW4vhlYRhSwMRS8Gkee3qMj+YFs2KJj9j5i1VtsRpfWZtEyy32omO2VltMCfgVk7UyrtE63VYWVtenZHRtikF2kzphkg5ezcOXh+F7Jui1Bzel1T85L1pwUhAaWzhUAJEQaG9n9R1LwBNwc693JN55Bh8qytyl3XosgECRESgl8I3Kbd7FI08VckPMo3QqyRSL/PYOgVMBd7Asyt+Q1kikBgAXr3IUwUsj6fHnt6SNL+US3TM9TKZWafwA5UJJrXUyqNBekAF4cOpSigrnjziYNt+yrrrhu8RGPvMf6SN1EA5BYbak1mbDnujRhyQXIlJEptc1S0Bji3fLLcl2iYsVtWY+QWmWgH2J+RuIqI0A2AVoO/pe9TZlbkngReO6cRzfm8Skj2DPIt0VAaEMei6dfXxYSktd/DrRKW0XBD3fVyRTPXObSF4WLxQc/+EF8zdd8zV0//+qv/mp86EMf+oKf1P8IhzkVDd3rKJ/v9vd3P/ztv8sLmBxaIVUfW2aKrS8VOXdbxQTQgtl7B+nSJEpiBYWDFZniE+jKALjRxOyK3hNAYvxkspmQi8RSBK/yZBC9cudc8ntWyAuLj3FLK5nO1XERTiRG1gdgbRwG52FC1mWKI8HoqCJftE/lURaP1Mz6+ECepkpRQd7SWHSWuq0tWEN2cz2kFH3NhV5ShOACSQcmtSbWAXlyJxDNz07Aflmoo5RK3Qm1VtgwMIpgKx9kaYx1AceDRcNsrueNs+eOeEBMAFmKw0Qfvh5cYqVkA0kHRz6iZdyZNinAEbDgAwGO3nhc2/TwPuDiToPRkV0cgGSJZZz46FIAMZ/UMNbjsTNTbEaH2xubWK3B+gQGY4y4sTK42fXUNYyv42Dj4JzHteXIrH1APzqcdAb70xreR/zxl1+Ec8RGr3uLk41JYLrSKklLBkNFip0l5qRnyztic2mU9sZvpXcBFGNaYX/SJPAuUpLFROPGZsDgA/bnDQUxMaRNXgpZy4YLsuGRlk/j/E6b0rFr69J9pyxDhI8khSoLvmQz1RwAC/OmVO54uFXEU268CmmDtj5iZSykEdBgQwLJMVK2o3MOnfM4GWnj7EaPnplnYtRpTq6NS81CFIAQQPOV5/Nq9Kll9egpU3QyeHTOo/c0FjbGY2kcBhdxbWnImtDRZ15bWhguXJP0bT+SBl8KMp0LWPcWm8GmZzjlZyxrpLDC04bmblp7+H6eYeCkFDCrKpJEMZFwPLiUGVm0FW3gEIu97cMxcI9MVjSV3trcy7VdfnbSWQzeZ59sHxPIBa8JwvhHZiAlIBEgKWAn8Nwu5/S5RZPYW+MI+GhFPvcCpATs+JjdPvJ55vMtGeQyuwFke0sAnKnczvQBpYRBWGLK2sn1SpZG/s663J5cAm2ASJ3AMb/MO8lmxozNt/6tFHBhd1I0eRIJyjZAkzUKQAJrco+AbSmSNIeSrpE+ZN/1ELO+ecpdN9P7IabgUo6apYhSQwHkvZSuRaUC6BipeFPYZKn7kLEpY2LK4F901AJeaY2hwKszIWV0aD2k9dJw9lbsFstD9M6yh0nGWuRbpSRDssYA0r5dSiLLsXbPPeuuz80Z4/shKz/f474AclVVODk5uevnR0dHL+nJfbEd8gxJH/XZrzsW322lSopo6fTrBSCJ9Ym8UipFBRCJ1qds+3oaIFIkxh6+RcpXruW4y5uJpLrETF+uUxZaeq8sW0itbkP2MD3dQABAEv9Lyq9zxPCkCDNmixsfqEhOWC2xdFszgyX+rbJBEJsRs6Y0xMSUl4cPEZvRJ8Zlf0L2UqMPWDKjaHzAHnv4Ho9kazZtq+QYIs/H+cgMVG7EIKy6sB7GUTvmDTPgsnDLRpzGTqRiJsXPfNJUKXjygSLuk9GnFL+4SoxOJBPECEnba8tFUMZ5GOOxN2t5vBU3Q21r6L0nCYJkMeTeBQbIg/E4GAy8D3h4r4UxPrmHbAwxs4Px+J2bx2nReuRMC+cCHt9doDcOy46Kq6ynjac3Ll3zrZXBbWaKrQ2sbyXZyOFqpA07RBjjsewszrQNrA34fz9zE84R4zkMFpuNTUHC0WakIiUFGOMwjo7kOp7aalvr2WaONdwum/0rACXTqhVwYTbh559lQbttjeOR/GfP706S+4yA2roYEwKyZJz4GJOWWNaF0YWkKW04g1POZ12MHyCn7cWiTqygTjoqOEspdGTtsoxVmrdUeBj4vSXTJLKO3nlsLDlPbJxLjPNgA9cjUIA7esrCLCYVXLFWCGO/sQSOOxOy5MWSdIe06AzQHXl5GxdwZ2NhWEdtnMeBjA8OgKzLnf8kO+B9RM8Mssy3aVUxg043YloRsKX5m7OBGZTlubLXNlhxcZJWFAxK46LdNhfgtYWMo0ytjyzfEnlZjFnGdppFDrwOGM4eCIgOQQqC6Xl2zm8B0OQRHwuWM4EGpDXZxUBjVKnkfCGNLyBgivcWATaTpiqcX3JxWgTSnNRQmLbbzaYkkyX3QWuV9PVy1VJgXGuVXTlCTMWBsq6GiNTYJ2dvhZFGKkgUQknmm0KWkEXkvTQ1FOFrKImNlj2OxZPfpDUWaT/bIp+E9GBixwVsSRxI1kCvnTQVAoi5TsCO37fntupiZwlgi32Vz5drlwBB8edMi+ckfyI65Aia54tpnSwakxY5ZgbWsLRtaVyqO5EiYRtiKswteyyU4HQoiC5hsiWDJ+OiHPfOZ6JLApfT1qz30ryXRJPMp/AZgPQX4rgvgPxH/+gfxdve9jZ4n1kW5xze9ra34Ru/8RtfspP7YjmyrjdvTmW64H6Oz/YQS1ZZJnUIMXnkpo5IyODShZhcEAwXtuXFJaZNVoT3sZhECgrrIUfJAhCkehgQR42Sxci2PI7P13AaWCukzR+QKBnorMOkrjAy2722jlPAsQAHnsBByNemQCx1ACjVz0VLo8+LrTAeKSKO+VrKBSZEpJbNIQLnFi0qnSvAxY7rTEt64JUhJ4HFpKbWyTFfv/MBba0wa3VizKUyuU3pbW6/bEkWIR7Acow+R/KjC3dVfQrIcD5iPXgsmoqkCZbYY8OWe7LxAwR0R0v2RM5HDIPDyy/OACB5bQMU7JZD0VmHk9WQwIExnjfKgPVgCeAO5LH89K0O1no4x892dASQrcfTN3t2Q4h44twMxnh84M4xhsFh2Rsc9/TaDYPVSpNk6GA14mBDDKF4Ns+bigDyekxFSsPgiCk2Fs4FfODKilniiK5z6DqDkVmOm8c9nAvYnVQYBo9x9MmuSf490Vlv2rOEh+594QMrKVqdx4DIj85OWhwPlO24vRwpgI1ZH1ixpZVS200PJAXaVIq0z/y+LoaUrheWWjS9aUyEmJ6TrBdnF22SgmhFrBptjHlzQpq/IvOguUdWgLm7njSiqRQ1olmPZBfYiz0bd7EbXPZTFYbpzLzZ8n81jsb4emT2ntl30Zh3zFgPHNQMNnKHzYDl4FKgZFiuYH1IQM0yi6xA9pNrQ/aF40iZAAE+s7po7Qtg3hBAXrTUbVGWcJESUGErfX920bDVI/1+bTxarTG4iPNTAZuZFQRycClMXVmUJMDoNECOYLmLdUUnvAxUJfsGbI9TQGoaMmCUz9liHEHv9enbm6S7le6cUigXkT9PMlU70zrZVJYtmUPM3UYDsluHzKWSHRdP9rEYLyFSxmbZU1MokQlePeqT25BckzDi+V5tF3ONVkgPpMyR+O77QHtZ1rnmZ3G4MUn7W/qyC4FCFqDZYlIYyxKM5eYfuagspf591v3KXJcxESOxz8Ly9i7byMl+KBI/IEup0vNkAC9zuBH3k5D3U5F2RA4waIzT9+JElBhx0H41uIi1sTA+UP2AF117SJnbhB1UDpJorud5b0PYul9pjPP9sS5r5OU6TtOFIr8rt82trAuylFO+vlTHfQHkt7/97XjXu96FV77ylXjzm9+MN7/5zXjyySfx7ne/G3//7//9z+uDf/InfxJKKfz1v/7X089ijPjRH/1RPPTQQ5jNZvimb/omfPjDH976u3Ec8Tf+xt/AhQsXsFgs8O3f/u24cuXK1muOjo7w5je/GWfOnMGZM2fw5je/GcfHx5/XeQLZtqVMA5SaxRc7JIUr/8shk7J86GU6DMidqACkhVg2CFmwBu+xmFCB1WCpoK2pJB2LIp1Dm4S8n2ziHTsf0PXQucjmosCFfsiNClyMyQ1CmGIXYrJNkoUpIk/gwQXMpXWnAmvkaDOWq99YdsxAXkQbrZPGaRDmKJAZvtxPiYJFRybp1JFBm1TSSvc3uf4z8yZZsUkTkBiB81NiCjtLwGF/WmHOAYg8eh9JgzxrCm9aZnl2myaBpIYrhynFVd01dlKEnvRbpyLmSM+kswGLpt7SYObuRtnn1vsAY3yy0zPG48sv79LreAEFgLqp8yKvFZx1WK1MiuB7cSRwAV1vMVpqSGJtwDM31hhHYpBFS2w96cBvHvfEDLiAd336BMZ4fPLOSAC5szjqWD86OAyjS3PgZGNw1BEgci5g2Vk8tNfCWo/12sCyzd04OnSdxTN3ejjnceOIwPq01hgGi2Fw7NUdcXw8wLmAl5+fwBiSVPSG/GSFQZY0ZwQFYqPfllgIAPIRuNH16edtTRmA87MJAboQcbQhmzkXpHCS9K+ymSslDRuy/VVba/K45Y07gVyQxEka68hzk9dkX3KaRzvsgqKVwmb0kK6bW2uLjBEOqHPw6hPbKkGmOKxsTMBqpMC0F1Y/BJZiZC3mwPZixxuL0eUNy/J7dZZTti5g0WoYR+wxMcmkqXX8+o6dKTaFxl7GmXO5CNX5AGt9IipIchRSO3WZa+StjdTWfF6Tm8HupMKirajZiVIcXCgc9x6iGHj47AybsQCjbC9nXMDlnWlqEDJpssSiZJCFIZOjLCIu8DEzYSSf8PF0g6iAWVsnlptkK+xqoCi132hhFbfXj4gc4NkQcLA2mHJNhpATlUT4MSZWr0x7S+F3CIXWk1/Lf5aOElzKSwWEC0B1kYKc3lBDE8mKAsBJZ9PeUrMtW4zEXooDkpyTHAI4ZQ+oNGcB+B5KMCikSs37oozHRmtMKirYbrTOeyYDWB9iljzEbF0q7yWEDl1rXpeztjcmwsSHiDsrw012Qrq+3lJ3SBkXh2uD3lDm5nBtiPkN2/NZJFJy+/WptaJsdCRSOSHQpNhd3ofuI+1HK17PO+eSjNOwrl2kMPJ5AphjzB30hJSTNTCm882ZDdkTk4wCd2fUZfyUdRySgS7HdxmwvFTHfQHkV73qVfjgBz+I7/zO78Th4SEODg7wXd/1XfjABz6A17zmNZ/zh773ve/FO97xDrz+9a/f+vnb3/52/MN/+A/xUz/1U/jv//2/49KlS3jjG9+I1WqVXvN93/d9+Hf/7t/h3/ybf4N3vetdWC6X+LZv+7Ytdvs7v/M78b73vQ/vfOc78au/+qt43/vehze/+c2f83nKca9KyfutnpTCqNMOAREZeOfXgiInZB9cAFxAUieJhaQvRJMnBUIunAKwEMsXjiAZpBrP1jI+F0uUnyWbtZyTMFq06NBG72O2m8ssBgPfmBmJ0QdcmNdclU0Rs3VUXJUdMoiVFTlHjFT5G4sJbMN29XW56QdmIWTCSV/4zZi9XV2xoDgf0DCrOtjsOrFo2eidi+zOzWssmCkWZgLgavhaWhVnk//dSZ1+Ro4YFM0v6nqryMQHLmLiZ1YQwVvjRtJfAD27wXoYmyUOssFJgd1QZASs9fj/fuqYzlcrBAZOk0mFKABba3jn0RedkobBIvB97nsCHAAB8NsnA4zJ2s+BmWxjPI42I1cVBzx3ew3nAg47C2M8NhuD1WAJ7PQOw+AgLYvXa/rdwCBoszG4s7Gw1qPvSYtsPckvxtHh2omB9xHL5QjnAh7dJ9mHNQ7W0kLddRbeEZNouEnKaH1iyJ0LyfsWvKm7kMdH7oZHoPdOb9IYEGlOW2t0LKERn1Afc3pQmnbEiFRo53xAyy1u2zpX7ctcozbIpFkV20bZzERDKIWYogm8sxoT6zlw5XmMeZMpx5UPkfxbQdc32Mw8y99IgNpZz4xubmEsekU5jwl3ljM+EivHG3MGGiSdEBZyt61Jg2xDYiqtD8mFQQoWx4JBC4Hby/vcITRGGt9treF9JDmGI9DsOcPjQ5Y/6GKX0wrYaSss2gzO5H1XzCADwKdubdL6SIwi3bPRZ19vgJhH2aVTQWAxDuSQextP/VyYtMGHRAgkn1sfE6itmH0vpUCj5050ilLs0kTm9GFDxMEwYn/RJOAnsoUIAJJB8Pme071SaV5sSSx87lYnWUjRTJeFU8KayjnbEJi82PbWDTFibVzSJCsgraOjz23iI7YLy4l95vU75D1LcSZT2mwLYytA0npyaCEnGZIoNfy+Mg5p79xu8SyOLz7G1DVPWraXbLfz0q6d6y64APOoN8mGT66hs7wWcU3NmrMngyeWfdoQs532Mn52p7OkkfdkauJTsMmeCg4HGzLBFDMTLVlf6ymj4wMFXobnuXiK++KctVZp/c5rxj3AcZoPOTBM0gpkbXWZoU4Xc0p2wT9KY/8P6rgvH2QAePDBB/G2t73t9/2BJycn+K7v+i783M/9HH7sx34s/TzGiH/8j/8xfuiHfgh/7s/9OQDAL/zCL+DSpUv41//6X+Otb30rTk5O8HM/93P4+Z//ebzxjW8EAPzLf/kv8fjjj+PXfu3X8C3f8i34yEc+gl/91V/Fu9/9bvzhP/yHAQD/9J/+U3zDN3wDPvaxj+FVr3rV53zOpwvmXuxn9zrKCEcAYMO64XtphimiooHUBlp8FZDavea0BHly3l6ZXMUaA87vtMBq620hXbssA+PeecybKhUmVTpXoMtG3GjNXZeYNQvZjzbGfC0RuVpYJlTgxUTA5ivOT/HxW9TOdbBkYdTZkJjg3gTsToj5lgKlnaZJ9mg0WcH+x7G4rkJvFbOWbuR2sFstfaOAC2LfxFHAeNIvisaTPo+u7fy8wcaE1Bgk6eVAVnGkS2QrOyWfQ1/nTcVaYeDstN3SgKfWvj67gETeTGSchCjFdxHHo8FgPRqjE3AGaPFeIRdJjqPjIIiA4XO317ngxdFGNp+36TzatsKJdTCj5Z8TyI6RAPk4OlRi++cCTk4GWOtRVRqbwaJmJ4BxJNA5mdRwPuLOcQ9rPUbjMXInsGVncXbRYhgsmuLe9L3FsrOsQfboOosPXF3D8ticzWqyaTMOg1Y4WA3wnoC0tQ570wpmNAjMINpZg74zcNbhN59dpvfpjcf5XQ1rHYAaNzYDHmWFbjmGhI2S59o5jzsbbl3NG7hsZMZFTCoCk1P2ihamKQMX8jWdcjpZpBaTpmK9MHkZa6XQVlT5P600BXDIgWtd6a0OjIMlQHXS2QTejQu5sUMgp4dZsQ4IgyzXYjhQ7B1lcyogZYUGS5mbaU2sLxPVGJzYTipc3JuQa0mlcLsfUsAn4DDw/Ke0KvDAfArjTkgGwSlt44llliJIz4G/BClp8/Vxi3E0hq6V6jECd4kk+Y+AFwEX0uVwY6nQbqepUWud9LKypvY2pMzQ1VUP48Qfnq5hYFnUzfWAi4tJWjtjcX8lyycFTOX64wNS0FT+XLp6Tlgj7QMDHh/Yfoy86QcmFSi7pzC6gHmjU7Df1uTQMXq19f42kL77wu4EJoQ0jpwPqHgdFc2tmjcZDBdrTQq4Ym4CJMWINC7opAV8i7sQOcQQQB0cFV1ujEMINP4FgC+NJecIHvMu0hjYyuxELoqMkbJfPgccjkGuuIaESODVScCBgkThc5nsaJyZNzSeGXZJEakEqGcXbZKe9M7zOA2Y1zV8ID19y7aSnXOJHDoaTZKciQ/+7X7E+XGSAKxS5BO/so46zPqAztB9Gz0VWj96fs7ZFbF/pH2TwHqWj8i6M3IX2gSQAxFFDXuwi0OUBMVtrRMINi5Ac1Og7LyUA9cysJN7n4sX85wHsEX6hAgoBtSytiZNOTJT7HxEUyt+HtuHZL2FpFC4W5rxUhz3xSADQNd1+M3f/E38yq/8Cn75l3956//P5XjLW96CN73pTfhjf+yPbf382WefxY0bN/An/+SfTD+bzWb4xm/8Rvzmb/4mAOB3fud3YK3des2jjz6K17zmNek173nPe7Czs5PAMQB8/dd/PRaLRXrN53pIZ5jyOF1o8WJHiNhaQIFs9l++h2ixsuShSMfJAAp5IkRmHahPeo7SdmdNrt5lyxvpImdYo9w5x04V9FnU3S1HhKOn5hAy6HfaCp3zcCGQBy+nkgUUit4qd1ojaxhJtT61v0uFYCp35jEuL3wds0EauQhwf9Yk7a4LOe0ok1Tl25JTRgxurM9WNWVQGopzbdgHVe6z4hSmMPOaJRNn51XSqilOgRsGDlTglHVztzbkCqIVsGizZdv5nTaz7Hwuo/eJbZFMp3j3Zi0bnf+tNckCpJ20gIf9aZMGl7Cjm9FR21TrcLQcGBwHeL7fu7ttYpAXixbeeTibW4makTS+o/MsR6BNWNhdw5Xam43FOJLEwVqPzcbC8QayXLI0IpLUo+8t1r1FXWnSiY4ugRPRFo+WmN5hcLh+1MFZB8Ofvxks/ds4HHfEIA+Dg3ce//mZYzjj+Pd0j8xo4J3H83fWcNbR9XAhouN0/HPHY2Iysm4eMCEzXo2mTWU5sDZVKy4UjTgcx8SyDN4nzazM66bIgADArKmydaBiK0V+3q3WqJVGq8mjd1rVSdMsQZls+vIePTPIZVvcFGCBxt1gtmUjPkTcWo7cdp68xxdNjcHSsxDXQWKbyHHEMYgFKK1seG7UWuGkIwcYADgabfI5lkGZGCges/OmJh9Wny3MbCB2rNR4pgYRzHD6QBKftskd0Kz1ydIOALVS5/En9QVCKpCmkYDKpNKYVBXOTdvEdgkoHYs16XAYWYLB9o2B/JmND7gzjJAub/KEJbgS794IIItCkLJu8trymXguyCWio5Bq+JBccBJBEvJ8Hyx5jcuauWhqam7Cwbg8CeMDjnqHj19fobMuMa+l7/DgyN9a2NuObfRonVeJCZVsHNmYEfg6WI2pqZMwqevBkcPJ4BKIGz2tTytrsbI2+WvHSBrs443BmqVSssf0jt5fApFZW4ETfGndzrI2mnMT1ppLpkKCPnH4qLTC4D3O7bSsIY9cv0OOPL0NqaGTBAAuBGycIwtE1tMb1tMDBO7WNsvTToyFY0nS2tJ6dziYohYmprm2NlS4bgI57oyOuoauRseZWNozJZCRoEeYZFPsu73x3C49jy95T8nCRmRt86yp0pizngJl0ajL3JOg53RgJ+NLsIeso0TK5NduFTfy+4r8TIsmBjnrTO+xDX+FGND8v2TN7pEw+YIe9wWQf+3Xfg2PP/44/sgf+SP4s3/2z+JNb3pT+v/P//k/f98f9o53vAOf+MQn8OM//uN3/e7GjRsAgAceeGDr5w888ED63Y0bN1BV1V2trk+/5uLFi1s3WCmFS5cupdecPv7ZP/tneMMb3oA3vOENuHHjOg4P7uDWzeu4fu0qjo+PcOPKp7HabPDxjz6NEAI+9IH33RsgJzRGg+LOzWuw1iB4h+Xtq9is1/jExz8K5xxW155BjBEf/N3fAQB84Hd/Gz5GPPvM0wjO4vDas+g3K9y5cQXrozt44co1rO5cgx87HN94Dt4aqIPnMNiAg+eoWUu89UlcOexhho4m3MHzqN0ILG8i9ksMyzs4H5Zw/Qru+BqiG/FKdQeNUhhvfJxkBkfPEVNy8xm4ELC3vo6zjQeObyIOG9y5cQ0Ls4Tvl1gfXEM0PV6hDoDgsbr+cdgQ8VXtLSwHj+XVjyJG4JlPfhjaG6iT69CmxxPtBnt+DQQH5S0qO2Cnu4WJ8thfX0OMwPraR9FojdfiOmKMeHC4BgSP+uQaVAyI3sBsTrA5vo3lnRvoVie4efXT2HQdbjz3DIzzuPbJ34NSwPVPfhhKAfOjT6NRwMHVT2AKi0dwjJ3Y47Gmw/m4Rrc6xOPVEsqNeHVzjBg8Lm6uoak0vm5+AK2Ar53dxuACLvTXoYNFu7qJ2vbYt0c4Pr6Nc9jgIXWCPTXiAXcHdXTobn2SGrAcPosYI15ur5IZ/ZWPwXsHZwbE4HHt6nMY18c4vH0Tl7DEA63FY+oYXdfjD+9vYJ3HN+4dI4SIP31phbVxuDgN8C7gmy4OWGiHV09WeGjq8WXnHR6perxs1+PL90ecnwT8L08Akwq4tKBh+pdeSVKE//X1tLF888UOE1h87bkBZ5TBl5+3eNncoOpP8BXnLc5VBt/0sMO8jvjmCxuMo8NrcB3WevzfHuthbcCXT+7ADSPe+KjDfuXwNRctHp0ZPFx1eNmkw4MTg6+9aBFDwPlphDMGf/zsMaz1+L+/OsAahz+yOET0Ht/6co+FdnjNdI1HdwJef87hYb3By3c9vvqiwfnW4yF7C9pbfNeXVrDW40+cPYazDv/rl2ucnIz4s09GzCuPr9jdYOYHfPXlgKf2PcL6GHMdUCOiWl6HCg7t0QsYXMDRC08T+3vzGYwu4DF3HRUCXqkPEMYBu+MB+tURzoY19v0JbLfC8a0XoNwIffQCfIg4vvJRAqTPUg3FRz/8fozO4/jaJ6HciFtXn8OwOUHTHaIejqHHJer1bTTeQB1fgY4e82N6rw/+7u+gqRQ2Vz9G3eM+/VEM44B2eQOb9Qr98Q2EzTH65SGWd67BDmsc3XgOm36gtQDAB3/3dxBixMd/73dRKY2X+xuIwWG2ugE39ngIJzirelxUazT9MWa+w6M4QhMszg83oBGh7nwK1gdc6l5AozV+74O/i8F47HfXsd50OGdpHajhseuWmPkNHojHmMURT6gDXF+u8SX6FryP+MrmFgDgzMlz6G3Aq/Vt1NHh1e0J9rXBU7Mel+seDzY9npx2ON9YvG62wm4DvGF+DOcCvnZ2BzFG/KHZAWKI+IuvjqhVwIPuNmAHHNx4AWpYwTuLKnqM3RLt+jbGsYc+egExBnzV9DZGH/DIcAXWBTwZr9M6fngFdTC47A8xcR0eVCuMywPMXQd7fBN9t8bx9WcxjIbXW+ATT78fPkTc/jQ98+7mJ7HadHjm4x9Dv17izo0rWB7exsnRHVy98jxWyyVuvPApKG8xOblCbcOPP40QgW/eP4L3EU+EG6gQsNfdQO1p7MXg4K1FOxxj4XtcDodoYbG7vo5JrRBvfxIxAlee+RBiBCYHz1K30Gc/BjMOeMAfAuMaN69fhXcGwTlsDq9htV7hyqefQfAOH/3wB+FCxHMf+yC0Ag6e+zA643H1Ux/FOA64+twnYYcNju5cxY2bN3Fw5zZu37iCbr1Cd+cFnKx7rG98Ep3xuPXshylDefuT5Fxy85NYDSOuPfcJmGEDvboN1y1xePsm7ty8htXJMcbDaxj6Hs3xVRyuR6zXK4QY8fzHPwQfIs6tXkAIAfb2c3BmwHB4FRPboT++hVs3ryP2S9y48hy86RGOXoD3tOeGGHHw3NMYfcC1T/webp4MeBK30I8Ddja30Loes/4IrjvCjlvjhReexxlt8GR1jH4Y8GXtIawPuP3807A+4GX2Knrn8eWTO+iMwStwgIU2CMe3cCZ2mI4ncKvb2MMAHN/CyWaD+ugKsaR2wOACFkfPAQD66x9HZx1ObnwSZuyxvPMCrt24DbU5xNHtmxjXxzi5cxXRDLAHLyA4j0989EMwLuD4ykdgXMAnP/IBCuzcAMSAl+sjrDdLHN68irA5gupP0B/dgB3WGA+uQEWLy+N1hBDx2HgVALBz/Gm6Ty98DNE77HY34UyHg5tXEjY6uHUd/foE3cFVODPgxnPPwIcAdftTAGjPjRH40AfehxACjb1hwM2rz2F9coSj29cRNoew/QluXHkem80az37iYxiNxfPPfBhaIWEj+Xrt2Y/CW4Pnn/0ENqslDm5exfr4AAd3buHqlefhnEPfdzDjiI8+/aGtv5WvT3/oA3DO4RMf/+g9seDp474A8t/8m38T3/qt34orV64ghLD1vz9V3PJix8c+9jH88A//MH7xF38Rbdu+6Ovu1VrwxWzRXuw193r9Z3qft7zlLfjt3/5t/PZv/zYuX34Q585fwKUHHsSDDz2M/f2zOHf5MVTNFE+9+rXQWuNLv+wr7w2QM3VLKfoHHkJVN1C6xu6FhzFb7OCVT70aSleYXX4llFJ4/Vd8FQDgZa/6MsQIPPHUl6BpW8wvPIb5zh72LjyEsxcuolqcRXPmAcRmhjMPPA5UDY53HkJnHS69/EsAAOHiEzhcG0ymcyilMLvwOJrJHNOzD6FZnEG1cw5+cRYrNcW5y4+jaWZ4JlwgD9PzL4cPETfnj2BjAh54+ZfAxYij+YM4v7uDKziLtZphnO3jelhgiTn2Lz0C3c7xjD+HwQP+3MsQI/CfTs7iqHPYe/jVCDHivZuzODaA2n8IvZ7id25XuDJOoHQNq2rcsTWOJheh6gb+3GOIiHjkyS/FvKnwMfUQAODm7GFEXQFnHwGURlVPsHPmLHbPXsLi3AOYLPZw5tKjUNUEe5dfAeeBc4+RPv6RJ18HpRS6sy9D22ice/iVqNopbuizOA5TPGfm2DR7wPQMnnV7OHI1ngnn0IeI84+8Gk2t8VvDBSil8MFwmYqJzj6KIVRozj4MNVlgMzmHW2GGQyxwW+1jvtjDweQinKqx/9CTVMF/7uUIAJ5tHoYNEXsPPgWlKywWC0BXeNnjL8dkZx+LsxdxI+ziyqbCFXUWB0bj1661cD7iN5b7cC7g/7i5i84E3OwUjA3475s93F45/NfrNYZ6jv/2gsf7b0a80NX4zWsK108c3vkphaOVxY0VMUevet2XwTuPn32fhfcB/8fzLY7XDv/1VoubvcZvPu/x8WONZ4cpfuu6xnMHFv/hkwGdU/jlZzSM8fioehDOBfzChwBrA35rcxbLjcH/6xkPPVvgv3za4SM3LD50W6HeO49nblv8p+ciXATu9CQL+befmsAYj//tgwHOOvw/Pl7DuYB/92GLowH4rTsNPnHH4r9f9fjQHY1PHAO/8azH9aXHO5+lTnz/2+9QYd7//qkJnHX4Z/9txHo94v/5ew5ro/DuGw2eX0e8+9MWHz1Q+PiywsYpuKhgdi9j0k7Qn3kYg3fQl54EAOw98hqMLuJD9iI8NJ5TF7CKDa6rfXTNAjfDAofVHuJkAb/7AELVwu0/gqiAR175OlgfcfFlX4II4Eu/7CvhYsTu5VdANVM8+OjLoKa78Ivz2Nu/hNnOOZy58DCm0znOP/QKTCYtNmcewegDXv8VX4Wm0mgffBLWB7z+9V8Goyp0O5dg6ikuPfgIZnvn0SzO4twDD6OZ7mDv0mOIukE7nQMReP1XfBXJDi6/Ck2lcLB4GKNX+Iav+XIcuRo31T5Ms4PbcQc3sYOTOMVHhl0Y1eCF6iIqrdE+8CRJYc6/HPO6QnXxlRg8MOw9jENT4Zo6Cxs1TKywqvewVHPcVPs4cTU+hfO42lm831yA8wEf9JcBALcXj2JwAc/gEpyq8VFzBgeuwcf7GQ6wwJVxik+ZBa5vNK7qC2gmE3zEX4BzAb96m4pQ3+8uwXuPX/yghw0KT5uz6NBisv8g+noBrys4VWGtpzh36TGsosbFR59EhMJvdefR24BP1A/Bx4in42VAKTyvL6ELNW7V53ESp3jB7eBW3MExZril92H0BLOLjyOqCu1kjhAjHn/q9fAh4vzjr4VWwPyBJxBUg8uPvgLTxS72Lz6E8xcvYf/cRTz8yGPY3dvDuQdfBqNqrHYexrSqcGf3MYQY8a7VOTgX8NvdOZigsJxfxqAmOKzPQesak0mL29hFmOzgoD6Pja/wyle+Bi4AswefRIgRDz7xOkrt7zyK5RhwvHMZK1/hmjqH0O5gce4ydN2ibRuYxQWsVY3ZhcehqxoPvuK1MC7gZa96PZRS2Hv4NRisx8XHnoLTNfYvPw5XTzHMziFOzqCe72N+9jKqyQJq/yHYWCGcewwrYzF98FUwPuB47zGSUuw+go2P0GcfgaladPPzOFEzdO0e4uI8fEvzyagG15oHsBw8mskcMQIPPfE6CkIWj0JrjdmllyPWLdqzD6Gdn0GzdxGXHngQbrKDc5cfRRdb6LOPwkOjuvgK+Ah8xVe+AcZ7TB54Cgcbg4/4izhxCuPuA7hjalyNu1CzfdyJcwzTczjyDd6/2cHSabyvPwvnA24sHoa1Ae8zD2BpHH5rcxYnY8QnwjkcDBovhDO46SZ4wS0wTM/iwLV41p9BB43hzMPE8DZTjD7iufZh2r8vvAKDD9DnHkePGpv5BfR6hmVzBpifxdnz5+F2LiLUE8T9h+GUxsufeh1JCi89icEG7D/6GmKVdYuoFD42noGtp1icuww33YNpdzHdv4zd3TOYnH8EumrxXP0AAvJ53NmhPfjCo6+CjRWOp5dQtTOcvfRwwkZnzl/GfOcMZuceRt1OcfHRVyJEBXXpFai0wmNPfWla96A0Hn3Fq9FOpzj/4GPY2dvH4489impxHvPds7j8yGOYTOd4+GVPQukKjz35JdAFNpKvL3/ytZhOJ3j5E09ivrOLyw8/iv1zF3Dx4gN4+JHHUNc1ZrM52skEr37tl279rXx97Zd+Geq6xiufevU9seDp474A8qc//Wn8yI/8CB566KH7etN7He95z3tw584dvO51r0Nd16jrGv/lv/wX/MzP/Azqusb58+cB4C6W99atW4lVvnz5Mrz3uHPnzmd8za1bt7Zo/Rgjbt++fRc7fb+HFJOU/74fiYVodICcigBIDymWNcYFdgpgf1/W2YgMwAXSOI02pCIYOYfekGm//BugFphSfCF95ymLQdqdvUmNzlCRUVto+kQTuzaUUr65HpL2aF7XOO6pa9jJaKkd7Jh9EaUormdd1GA87nQuVZreOhkwjuSnW2uFcbzbYUL0ji1X1Nw8GTFv6qShrTSb7muVvHxrbhkrqdnkDOFz4wzwfchtR0kv1nChjaSDmkqlFHNvqMBrcB4XdyeY1NmfeN5W6EzWqE0Lo/wT1iRXWnSO9JnL3iZNKpCLSE4PluRFLClEHgPi8CA6TGspOJVGLcaQm4kU3O3OGjhH/r8AksSiqiqs1wZi/fWO9zwPePLC9j7CsFTB+wjv6W+8j7i1MvDewxqbpBpmpAK85UASBmu4sM542JFed2ZawRkHMxoMg6UW04akEaL5tcZiHOUzKU3edSZ9H0KEMQHBh6QzRgS89wg+YL0e4Z1H5DT8MLj02r6ngsMY6XdHqzGd/7K3aV66EDGryKuUujb61LbWsMa19HYVTaIPkTt3keWWHBqKHQDEXpG0gdK2VWoGRKY0bSpMa41JU2FaV5i1FReYIckRxEtXCqkkXWwCPXtJQZckgOO0fakFPBoNNBQ9Gx/w3k8eYGPCVuHZZgxJcy9FTZXWMIH0jfuTFnttgyPWxk9q0uOHmFOvkrYtJU231zYV9UwaTS2iI6WZ5bOBrD+UOdvWVXJOubTbYNbW5HLS0Vo3a2vEEBHYcnI1WNKMGr+1Vg+Wzmc1OnYQ4YJZLhIUpwmtFDYsT2m0SkVzGy4eHCw1WRm9Tx67sZBQgJ+DyLHkmcVIa5ZW25ZwyTKtcJjRSpG/uch4bHa4kIO8pkNK+/sQcbsbUavcQdOJhdfocXtjMbj895Z1w0qR5GA5Ohz3JqXyjQuo2D/XhZhcawbH2uJA0ogNN5YQOY1jec7oSV8r9nS9DVhb8kTfWI+lsdnf3kUsrcXKWHQssVgai43xOBjGJJWgtvBIz6nhoteAiDnLmGRetxVZ2pngU2dKHyJLpSKurXocjQYREce9S7Ki0trwxJh0rzYsMbE+4MaSJGXGsQtFiFiNooePOOFGNr1xbLdKzajWScZC5yl7H3WipHP1MSTbwxOWLq2Mw/mdNrWij5ACOnZs8lTcR/LFiBCknkAkTUiyCSC7gXRGaopk7cpYQimRsdxd/Bli9ujOHXJj2mtLtxGSb20TmOKeU7O+UMaNyGZOdxEEqHi5tDWsC8nFS3XcF0D++q//enzsYx/7fX3Qn/kzfwYf+tCH8P73vz/9/4Y3vAF/6S/9Jbz//e/HU089hcuXL+M//sf/mP5mGAa8613vSnrir/qqr0LTNFuvuXLlCj7ykY+k13zd130d1us13vOe96TXvOc978Fms9nSJX8uhyykcoh+7rMdYglz+nvxb5w0mjVDIdkaJcF6oCpxKayxPmx5tUoBQO+yBqpSVOxAn0ev22VvX6WAWmnM64oWDReS96MsemTpRBP52rpPOqer6x7rkRbHlaVGD6vRpwE9sD5W7F4G47DitpUxAsvOYBgcrhwbWrSMS561PpL2b7AB00YWPAL6c27UoRVV+leaAT+Qih0bLpCQiumyS1CJQcmrGEkHOal1qvoWcEAbS0wemb2j14lfJwDsTCp2C8iWXlL8J93CKk16QFkkSA8pEzt3WSo11KWWMVX9hohJRa2cxfO3Zc2v99mMfRzZMok1vM5H1vAaujcMGOum4iI8KvJ84doKcBZa03uOYwalAAh4RrIJCj4weOZiEQbExxtqIiJa324kkB18wPMHPf2c9cEfu06a4BiilDHDc1OTGCMB20BgGxGcpcrn772HZQs+ee3Qj8mhw3vPLhsMikeb9NbOkW1c8AFKK3S9TePD+JCatAzOp4LV0ZPFnYwvelbsfcplP4rHpvHZf1e07bKJC8CxgYLISklTEfr9rK1Ie9xoTKsKe7MmdYG0rImW6v3Re5x0Nm2wNlAxWrlHlGB+yxopRqwtdWzbm9TwMeKZozXrmNVWLUGtAWmtTo1vFHWG5AKmSU0FjIat9foE4Oi5Wm6N3takna61wmrMbZLnTd7srA+5sYrKrixyzvMJZRSONiOeujDH3rTiQMpBa4UzM3p2IVDx2GaghgcbLpqS4SaAbjV6rIx0cySAnp9vdqsAkAJwpRQGm4OTzvnk0AEgtRiWgwonkRw8pGBT1pzy8+TP5m32225qvdUxbGNCfsZKfHVjcgBxPuDDt09wp5fuqNklxLADzlFH9l1ybmWR+OipKdHBYEi37EJqipQcENg1yQSf2sV3zmNtbXInIr0qAczBeQbH1HFx9LlxzNqE1PhEXIrWxmFtXQK0G+fQGSJlXCR97Mlg6do92YuK13GIFOTK3A0xYn/RsgZ4GyC/cNDB+og7/ZgIpuXgsRopgBUXCdoXZX+l/TFGIhOOegrqR0dNcOgZ8T1gLbAP5LCSivyMR8/WijK+nRdNMzeDClmb39mQ2sF3jtb4wWWnFR9Iv985T5pl49Lry3oI8VMvIYvMvdINQxoZAblokTDJ3V7+MeY21+QbT5rmWulUlyPnKO+dOosWn1GzFZ/sZzS87wa9MUZUVdlEhsiiewHpL+RxXy4Wf/Wv/lX8wA/8AK5du4Yv/dIvRdM0W7//yq/8ys/6Hvv7+9jf39/62WKxwLlz5/C6170OAFm4ve1tb8OrX/1qPPXUU/iJn/gJ7Ozs4Du/8zsBAGfOnMF3f/d342//7b+NS5cu4fz58/hbf+tv4fWvfz3+xJ/4EwCA17zmNfhTf+pP4a1vfSve8Y53IMaIt771rfi2b/u2z8vBAsgelsKIhLi9GL7o3/HCfLqYTCr460pjsCbZugVkyy8bQvI+1lyxKx7AZOsWUlcrz5FvpTSO7JgKNADg3E6LF446TCuNilnMwQYc94bAaKB2vbsTjc4RG7AeHK6vLPamFUYX8anDAd3oYH2L5UCL45p7sw+e2r56XoC0orT5sjPcajlg0xNL+MLxgKcuzWG4Y5aTRZzB+cWdJgUIK+uSCXqjpQuZojbRvUoM8nxS4XDNUb6PiDGk4po6PYeYAMeZtiHAWmk0WqcNudEKE6aQR0euBJ2hhW53IpsVsD+r8eydDku+/s65dK8HLmCSdt1NMXnbKseiUsku1nFi97diVrNkkKc1+2AyQJ61NcbRYTqtCaCHiHEwCcSOw4ibJz28JbZW/s45h7atsF4NyTPn+LgDvEt+yCEEOOcSEyds65qt34SpBajBiLUeq55AqOdGH31PBXW60niBi+RCIAB942BDLLTPDHJg94EQBOBoOC5aCV5cPQgsI1JxloChGCLMYJgFbwgo86STz5SDGHi6R1Wlk99zjBG9Cyno2hiPWU0gsLPZxL9k/KWALMT8rG0gllUCLrF2mjYKzjH7FgIG55MbhrzPzrRG4EC4G6l46HhjiDHmDoqThlgj4wOONqZoAR+4cE5Bq2ydKOuNYrbSc/C6Nh5aWZybTBBCxHPHYyo6pRax5DixaKmIrWdHmEopHLNLyrVNj922hmEG9XZHQfPetEr2TQJ6zrVkfThtNA43Lm2Oe9MMBp2P3DJbQKkm5o3X3HM7LbwPON4Y7DQVzi9qOOswDBZnz05xbk4McuTrXTODPLg8foS1PxwMViO10ZbnTyws0mulAEsrhXkjDV5QWHpRUVurdXJ/iBAGjd5HCnupoI3ICwfJhnHHRGTrt0opXNqbpALIht0apG16Zz3OTGuA9wixntuYkIr8nj0aMK01HphnezoJcnrjcMLrvGQUSyem3gYc9w6HE4NHd8VaLWIxrXF82G8FajZQQZqPlMVcWwfFjZIqRf7yPQcQAHmCS6fGjab9p/Iq711MbKxHz9dP82l0Hp0JOOwd3Izu8+FoEEAB53xSp6Ya4p5CrY5prJ90lmoKeouzs4Y790UcbSw1+NlYLCZEyKxGT8XNnjqDSmFdz8+X9lsOanzASjJnXPwWQQ2tjOemNdwtUIp3qYCO9tcFB0KR56/15JV/OBgAAagqAq4636POebxw0GH0AQtuXmVDxLK31BLeOvZP3+4wR4XrIXXeazhDKzuTvFYyqYJvEiuMmMayHDLepamYFM+FCExrAr1E2GSf/7oSoivbt2mFlCmT/UAh276dPmqt0nnL2lG/2Iu/QMd9AeQ3velNAEire/pQSt23DvmzHT/4gz+Ivu/xPd/zPTg6OsLXfu3X4j/8h/+A3d3d9Jp/9I/+Eeq6xl/8i38Rfd/jj//xP45/8S/+Baoqt7z8xV/8RXzv935vcrv49m//dvz0T//0531eKRp3ARXbJJWpLjkitu1JhGFUKss0NmOu6gXIckx+H4VYi1RtKlEoIF2FOMICRfzC+hoX2ApIYz3m/vTGBzx8dopPHawxqyvq3tUbWN4odhpq4HHSO5yb1+icJ/lEb3FnY9FW5L15a2WwGbndrPHoRof1QPZSa2aUSyZkGMjD8cRY+IDkfXv7ZMC5ecOetT5VrYov8m5bJTs0kXyQLywxvJVSOLtooQYkmcXerIEPHd1L7wFUcDFAx/wkfIhYTGoopXBu2qKzHrOqQlvT5G4rnTYuIHcJotRrwN60Tn7FO63GaDxOBnZsMA7zugK10SWmuGa2aFLnBWRa6eSTO2E2WRhmqezN6a7sJVtXKgEcgPywTfL8jYkpXa5HYl9Hi9tHHZwjBnkcHbTWgCN7NWddSquO3QgEYiScJekDnCVpR0MsHbWK9VnWIF6f/PpucAk8iwuFd/T6o6OBvg/klHF8PCBYznCEDJCFtSbwSudIneNCYksELNNrsx2esw7wdA3BU1dCYcjlfURiIXUTbVslf+cI8iLtWFbT2wA7IWa39z7NuewNSwyyBDxNpTBli6bdtubnqpOEqK4UOiMAmeZ1q6uUMaqUoqwEy2SWvcN6cGku2bAt77KBrLIAJKC1GX3a3CTYEg9brRSl4EOWCQREPLG/A+cjbq8sRuexaDWOh+xtPd/XzFA5yqDw3xoX8PyRwZkJSbBG63FjSVKLuqJ0aYjgLpIRM5Y0zRuN6zyeFAggH/eemcyQ7CUBkpyse2o3HQI17PE+YLUe8b7rKzy2P4F3lPFoGJTJeADIdlDAEoAt8LsylhqV+Mx4iwRCxpp0PqsrjcWEfdC1gguUtidHhpBYxsgDSZ6ZzNvtbmo6ESsExGJ6LUCg/PzuhAL7SpFtYKCA2DlK+5+ZIq3/JE3zif22LuAGkxoE/icsjdBJ2rMZHRZtm8iGkuMZLEnrDjqHlbGY1zXEmUOaUPXOsx2Zx9qwj7wjlpVAcJX860dPVp5agVsxhxS0DAy0penRyIHRmqU+iyawnI/Y3OXgUzOoNWdIOxvw4P6UMliRxvfSWAbIdM9vngwYfcRh5zBrdMqYHo4jfIwsiaPr7Lh5kWO2fT365IQRmDUW4iUBX58bwsh9MjYkZlncQnojFqmhkLjkLKGPEbttgxA7+KhSB1vryTdamOzjDQH+/QkRlNZHnIwWHdumVsqi5cYiNJfiXdlJUT6UcqAQSSpWF8C1KewISY6YCR7pmNlUBIybgtltdUXSR61gkLMU8vdVRU49m5F8r8XnWwIcGZunDyEGZc+Ua/yiYJCfffbZl+TD//N//s9b/1ZK4Ud/9Efxoz/6oy/6N9PpFD/1Uz+Fn/qpn3rR15w7dw7/6l/9qy/QWYrHX6HNQV7YPtMReOUUI3fjI3zIrJS0UBVbHgBp43Qhkr7TZ3sd2lxJczV40hp1NnBHLBpcG8Pgm6P4p6+u0uIyaSrcXFP0fGJs0katRwvrJ+isI4/i0WE1eHQzivqXnWVJBLGkvXHoRrI/O2FbHudCAg/GOPS9xW2O1MfRYRwtTjqD22uT0vE+IEXntEjUiW0Xdqpi/XHDG+uZeQN1AAJsRfCgmOER+yWPvOn5QAyyAvvPjtTOeMITu2WNschVQhDjdAJo5+d1moyWF0Vh0E8Gh8VunfybAwNzwzIOpYBJrdFWFVksRWKFlcoelGljt9kYKiJ3GwJogQaomYnjAENAphkNNhtics1osFoZwFk4U8MYj7omgCx/I29KUoaQAa51CSDPJnViW0XWIMwsgARsx9ElRjd46uYnYHazMYA19Bk+YLMZAcsp4JDlJDFkGYWuNHzv0UyaxAjSpsQAmbXHiUWOMYF8AcZyeO9RN3U6V2HHZ7MGXUf2iIjkw300kj5eGsc0WmHkZi7SqABgEBoi5nWVsgXTuuKf1Ri8R60V1iNJmLRSeUMNBFjmdQZI0mSgrlSSFK3YWoqA7baGVfSd1HVPahF82lzKhj8i/YnITNHaUKpbGg+RXpfacl9bGhh+1jvTKgEHoOZUOTFht9cGtzcNZg0xqEedxWgDdSoDy35s3kRFm+g8ycrKTp/SQjs1aIhs5eXIapDWQXrmXedw9XjEy85OkiZ+2lZYjTmr4H2EtWIbx4xuzJ6pG0vXX7YwlvhDgPaUG4zUGthra1RKoeZsm1yPtME2jjIbQmyUdQ/ShQ2Q7nDUTXJSa8p0uexh21Yan7q1QVMR0SH2Y2fnDQEum0kVKNpbSGaX7b7EE3vNwZkPIg+itaUfPfQeEhgqsw3Gk9fuce9wMtr088O1IX1xoPVwVlMHQtHcjy6gdwHzhs6lZQtTaWssHvs+0M8qx3ZiEanzovGUwdgY0qITs0rAcnQeqzFbKC45OOxsSHuSCwFBa6ytZftSPveezn0J4Nw8JEZ1bR18IFnFDhNeA3dmFFZ4Yyg4E+/pUp8eOCART2TqFUM/sz6k3wNEtqxNSGz9YLl1N7bn5e60JtvQmFtTu5i7xPY2JD2ygGAByCO3gNeqyLgVWY3yOdfMIKfMBa9tWtM+KwTORFdbeuWmqLXxvGeJnl4kihG0t7WVYqOCLPMS4Ctk10lPmGU+qdK9jMBWAyU5Utc9/kz5mXEh+brLUV7rF+K4L4D8+OOPf0E/9H+0Qxa/1OJXq3syyKcpZGECZVIZTuWKdveks1v6QkqhMlCOgbR0gTrhgP9uWsnCSIxUzz6LWlFr1Y5TOxHAxjm8sOroM2PAYlLh1tqi0QonvUvaKMsAfMP6q81g0Y0OvW1gfMSyMwzkkQDvuqZ08GHH/rMjbdob/n6zsbixMgiRisjsaLFeGxwtDKfncy93CRguTKckWYjCnHHXKmZkfIy4fjzgEVBbautDMpuXhbgJ5O+sCqgkhTAAFeD5SN3t6oqkFbNWY/QRB1zgKGyAFA89OJ8lBnE1UoDTsc/vavRozmQtHEDAZvDEqmhFesJ5XVE72QDMWDNKzSWkdbawETmgIoaGASnLD7QiYEtaWx6XhtLNMUZ46xMwdZqaaCwWO4Az2DDLDBAoFTaZpBgusb0hRJzfIxBS1zqx1wjEDIv8IoSAcfQpvR0CNfuAt4AChn4sigA9xn4EPDHaAm6F1bWWQGzd1PDeY1pPEyiWRipQGZjLfJPXgEG0ZJKSRKMh1hmKv4aA/f0plsuRQCRos11bi3ldpbbmulbU3YzBKxXkUaBmlcL+hJx4Gq2wmFSwPuLMpMHQeUwajXHtk49viBGjpbk9rWmTTalHpbEZSXbR1FR02jG7Av7bMhXuIqVba2Z1LBfp+BAxnVTJ+3uLhWFgECAMnhQCB2wGCirPThv0dsMMcsS5WcXgm5i15eBTFmzZWRxsHJ44P8XoPJadhXG5xXOM5CdLWRVu+MBfNWsQD1LzFZqfy8En9ntv3qaCT+8D7qypaLPvLY7Whjp+cUC3mDZZ2xxikuDIUWnaqRWoNqDjNtfCIGslkpmc0ZHC21ornJ9OUOlN0gS33LCDAF/IRXpy3QU1J82I5HuA6k+m3J5aiqdCBGZ1heONQaMVpo3C7oR86F/34Bz/+QMBxnn4sF0QZZldDJEkRKveoqk11saxTMUnsGqcx8jdJcmHW9/FIHejw7LSWLFftILCktsUuxBhlAfQbBWLG8/6+glpk7VidjMEzqghdwP1EY2WzndI2RnrI3YnJL2QpifWR3TMyG44AIyRWqBXigqXrxz2qTOdjxEno8PehLqWxhhxNJhUZLsxdF6OtbouUHZkdCRvGm1ArUk/bBw1VnEsC4m8zpSSJan/kCxJjKw397nVe+TPk7kTI9UR9c4T8oqZfJtPMtCbVTWBYx9TvYM0HDE+YlpVWAfSGq+MxZDOM3uZSwAqAZvgFZERWkfFnS37+deVMNcEwEWSqEESskkBkBMOUhT4NcXrJ02FSVOB/QZSY5B0bQ0xzNaR1/RiUuPYmXR+p/XHosOPPE7qSq6P8NTu9L573X1ex303CnnnO9+Jb/u2b8NrX/tavPDCCwCAn/3Zn8Wv//qvv2Qn98VyJCcK/lp2T/pMR8kmlKbepOGJ6MbMJstBcgmk4jeRWsiGpqBSwZ7jxalzVClsWCcVQHqjtXG43Y2QrkLnd1rSqgJYjYE3pYCeN+TVSNXI4+hS4Zww2Mb4pF8aR49+dPj0aoPV6BkgO2xsoEIQBmwHGwJHlps39L3DZrDsjpAlAo4r8s8usgZZ2GXNG5fmazrqTGLHiAFzcDG3Mg3ILGKp/baegOfRYLJ8QdNmTYV3AUeDSZv8YDyzB8BrL++mc+24oHLkhbOzxKrUWiWdsuUAhlg+kiiUKct5Q1ISxXrDyDusaC4VMrvasQQn+JCKhyjAcMzqxlQERwDZYhRdrhngjMNkUgPOoFt3rOXNjC+A1FjDOw94Kj6ptUYMJLVwRUQvcyBpgI1LYDfyxgFPjhnOODqPSCyb/LuqK0jzBnlPY9wW41vVVSrS22KJGdgLIC/BUAzUYSvNV55YIgcR9nx31lDrYmY8B0dV9bttQ6nRSNpgwx3mUnpQK7Q1jZmLiwkUiA3ZnzfwIWJ/Rl3IJk2VmD0JAjfOJRasUjSH5fkPnAGSzxA3lhgpFVq2pJe5THpDChQFhM651TmALUeUiJwBGyyxY1J4KhrOi7MpRtZOWhdwhgOAnpuvHPe0RjhHMrHjweHMpMmFmafO0THbvDYEFATE1pWG1gp3OpdS1jEidVwDgHPzCtZSpsr7XCRqDK0fxoWkez+7aBMoDYEyGNQZM3dVE11jw/pX56nJkowTYbYqfs4in5nUGhcXE1Qa3NGOtNS5UxvXIPBYjvws5E5I1zf5HiBAKc9I7lmMwE7T4MQQA9pWmvTckXS5XlLtBesdoujFBSB79MbBWI81uxRZXkt8oBoG6rRI1zqvGVjwwLOB1nl6tlRcJ8V4iaX2WdssRZnC/BOTm8GQDzG1JfeBgFaIwooWDSh4baYOgHELNBsXUwAoBFJnKRAz1uO4s6QV5nt83NO5ilRGiko3oyNnDE/r+WYMqWjOeCnwpiJz7+MWMJbmV7Jc6WKdl5+dmdQ8/nJxeIhZK74e/ZYjTG9yUCWjZdXneokp695lnIRI46rjjFZTsMArdq2gLnxltim3gZb3UEphWlWpeDREyiQB2SHCBnr/svB3UmlMC6a2JAelSZa47MzaimoqYgQkq1cE68JEl0XqQgjJUYomZIwgbkvNAgckL6WDBXCfAPkXf/EX8Rf+wl/Ak08+iWeffRbWZlbo7W9/+0t6gl9MR/kQ75fJjyCAJ934SH9M7yXMT1nwJ8UhLrArQ6AFQgavViTcl+5OA08c+X9w0qWKWJnba5f0Y6uB3CUiM5/iRNGPDm1NANk4j753yX4mxIi+txgGl1uZjtQS+BMHPTrDRQmjw/NHI5a9SQU0R2uDSa1JUsGgeTA+W4lJBM0L68W9SdJBiX5bGCcpTDwaqSBPOvtI8RNpGek+1lqlyScLhfzuxBDA3liX0vf7sxobE3Bn4xKLRPo+WoSvHw/peUs7XGFQekNgoiqAmfUk16g1MYKb0WNnQim0EMHpeYWOC0PKMRViruLfbptNX3u+f46thRACAWEpSBt72NEC3gGmhzUsJfAOYzcySAwZXMYAO7BVmicG2XuPq4cbwFvUNW0ISm4WOH3P99MYn9wuklNL8Khq1jsHnyYL6YUdmrZJYDXdM2MRnUvXWlUV4AnsOBcAn9PoUvgXCsAgbHIG1iEX9hmbZBmIZPcWPGVuwJtPbwMu705hPG1itc5tpacMdKSopK4UHj43SwWk53cncJEKYkPktHgMcJxGF3cMGYOiTVXMzoiFl/zO8TnI+D3dkt6GgElVYVoRiCKNJ3VslAKastpbvkpr5954nN8hX+2RmbJFS6lOw240F6YTYkRZd7wcaKx6LjZaDQ7zuk6aTRdCAicS9IpMiQJZzwEBnduqt1sSqc1gE6u+P62JyWMGuTcUEFlj0bN1odgAPnVxlt6HAjb6G62oIEikWbKJy/ztTdhKLTeVypIoZk+ntcYrH9ghnTlLQ85MK9TMwoo2VJ6e4vW7fJYxgm2vCEA4n10DxAYwxIi9SYO1dWgqjUmtcHHRIEbg/VfXZMHIAC+NdV6LxJ7O2uzAsBk95m3F3eEUa2gpsJ83lAJfTKqi4IkY/t5kh6KBSZiNIaAsEr903TakbJvIxHykFDgrl1IAIFkYWUNlTZY1z0d65o4DAR9zi2Pr8hwCwBabdJ8PhpFcL/h5nwwOPd8HpRRWhseloWI/Wbc3hmt32F7Vx5jqTqQb6+ByxsWdCsTzs6XrfmA+TXVKEtAncBtiCvQ8v7d0nxSpplbAanDQoH1ud9ake1Xp7IojDjsCqqmwMUAcTQau5cn3Ne+hkgFbNHV6hj7kIK6tadxZTx0vF5M6yRlarTFvq3ROcm2lBli0xPO2SmNO8WtliyuB9ekMvBTole8PgB1K6Puym3FErh14KY/7Ashvf/vb8Y53vCMVyMnxh/7QH8L73//+l+rcvmiO8lmm3vT3wSHLg6WBEpM/rxzitRiKwWEcRf8+buvLGnYz0IpaM3tO+YyeovleLHVYxyrp/8PeYfDEMl8/GrAZHVwA1iPZ7YRAbXvnjcZmJABPrYADt1wm32LDBYPnF1QkNgwOLxyNyaN3HB2uHQ9YsYuBGQyWncHuhICSNZZbB/vEIKfqb75Rd1ZmKzUc+b4FnuyDz77PucjRJ4mFY+ZvUlXQyDpHYW5jjFhzMdaSgzypVO+4irutq8TiGetxsx/wqZP11jgQ8AoQw3Bup03pKa1AhSt8fU2lsBwtFpPspTypiHHe8GZfjiQXQ9KlxkiOGnQt5DtpfdYL06IdAWcSGwxnklQCjoKV9doAboQbeiqopQvIi/6wQXQMZgPpPQ8Pe9Ixu8IuTxXLBTO6hn2N5dBaAcGjaZv8WXx4BuCTSZVz0ukSHGBHOC4IjDEC3sNa9nP2NrHGYiOHJK+gQuEYIyaThq4tiEOGSwyyMBmHhz1KPZsAucfOz7O/sVJpcZ61OhWITGsCxc/e2qQA62A1woeImycjfASmbcUFmSybAViuQadbKYXRi75ebbVErzW1hPfFLuE8gQQBUy6SZ+6kqri2gcC4sDjiflAyMzFmSYD1AR+9tiIQy0H6yUj1EM7R//uzhoAup+ZXI60R5JdNzOK1TV8AWQKdsimKfMt50pdLEZSkULvURpfOlzx2A9cSxKwlDpF1nQHeelhuSy+2f1LwKkWdMi+UAipFYJC+p/beLhKIEZBSadb81vS/rD+VVli0GsuB3AFmDdlCnp02XIDHoMWzfz0Nwy0wJ3Nb3lNAo2SJBGDIy3uWQCgFXJxTsHPzmO6x3CuRBYHBtryfBJKin41AaksuRarOR+xMqDj5wf1pzjKEmKw/e+OxMWTRZnjfKJljgLJYSfoF8HkpuEBjUK7XMpMfIgUdAdmhQL5KNvDyYspSiezcQmMoZ1NiRJK3GBdwPNpUi9No8uIeLLW/VuDXepbLOZrL9OypqG101DbesoRE7oVoiGNECkBOH2Vx2LnZvRufSbBofM6EuYAMkIus0dpayngo4PKZSXoPsidVKbj17KACUGDRJR02gXofs745BFovGq3TmjZvK9pHXCiCZ5IVTWpyG1nUNXamdQoY24p+R+M3MLEBzsoiScAiYipOTtcXt/39/al72XOxdIhZbiVSQyDrqaHIu3pkS1kgf+5LedwXQH7mmWfwdV/3dXf9fGdnB8vl8gt+Ul+Mh+aF6zSb89kOWahczJOeImyOTuP2ZLEsPI8gsER2PgHTRrOTApm6+5gLBwZL0grjeZMBLVq9JTua5eCxNh63u5HkEpyOI70l6Uit5yp1S2DYMWtRV4okEsbjYOPwpRfOwBiPYbA4XI/Jo9cai4PVmBhOayw2vcWsIX/eYC0zf5HdELaj7EqrZG0l99swqPCBFhnxaybgnNk2FygCdoF8GFue2GXPe5lwA4P+NfugKmYjBkuM+rzRSSNlXMDJaHCny0UrbZ2ZYlocYmLlhQ2wzEhKsVfnXI6qlUpFP1QskscTVcqzLkwWVGESmcUNISK4ApTGCHibnWTk+xgAtjXbrAcCv2NPwJKZ1HSYHpC/Z3Z5vTZAIOlMYDpAs9uH9wRexR5OziVG8qpEJM9lYavpZjHrHEjyIWlp0jyHJO8Y+xGIbNHmOdgyBN5FJhGdQ3DZjQNKJ4u32axh1joAkR0yxLqOF+rNhpqlSCpTmLinry4pbR3JBkvWXymqJJ0/AaXb3Zh8Q487YkMPuhE2BM44sE6Vn5/h+6t4bAsbV4lOl8dUxc17SpAlUiLRj8q5z5m1sZxqP96YlLpt2FapfB+xw3I+4rllR2wZM2dHg0n/DiHiwt6EWBpL87tniQTZ5ZEV1vPHI/8+eyFr1kxQUV5IoGSwPoE1DZKV0H3IXuqOg4bV6LMuvZBPOOdgTCAnCZYI/d6NPgU+MUYOlLL9XsVWjjUDYZlvyVKO08ltrbdS21orzFtNumBmkButcHk+I5mCZnmL9ynCPV0kGYpgRQ5hGpUiO7S60giIOBkNZwaJBXxwMQMArDqbi8K21rKYsgI+UhDiGOgNXLDnI+0bEtCHSIXQE9aNivwkIsswyHKTwJiLJBWTbJkQFmIdl+RWkTIuESxBUSrZikkB27SqoAEOAGhsyv8hAg/uzhJpsuH9J8bsViCj2PnAcomA5ehYbsiZVeO5iNznvcFzUJhqfdh5g8dbGcRJsCLOErI2xLjdgEez/l98fQ97w6/JS6pWGUSTx2923pGxJ0WhjaassOZ9YdJUeb2pdBpLIjfonE9gUt7LM2AVNl+yyIHvvWVHoElTJQJGGuAAwLQhpyXjIvZass+TAjhpxiLZrDQOeC0RV4sQSSoltqtypGxWiEnTrpiA6EaX3htKYT04bp5WyvrYt5tJO+dzgPlSH/cFkB966CF8/OMfv+vnv/Ebv4EnnnjiC35SX4yHmGHnNMr9/62wgQLyZCLJ4lOyptYHnJk3aQBG0CJFTUMIWJuQZRrO02I2uJBSUhUPvoH1gUcdeWDeGUbSCo8uNSjxkfSfV08M6Q+th2E2abAee1OyxDLG49ZyxPFouAmFwwkX73lP9mIn6zGl3J1x6DqLo47ZPjtmGYCj1saJjeevB0MW61eaZBCjD9zhSLpCFZXfNVkYhUg2bj6Qxo7Sh2orYhWyUpiP5eDTxDvsHaXhRvJybWudNHuHvcdxnzWie9M6p2aZNbm+Gii6j1TgYH0gi7hAQKZ3PkXKsiE0mkD6aMNW57AQqVtfgGwQgb+XjZcYWueyZg3eZQ9gnzWRpCf2GLqBJBeWbddAwDUt+s4AwRFDHCP7KVsgUGFU5JunuZ2hMQ6IJGfw1m/5DVeVBoK/SxuWPmtr4sQknfCeGO+hI59m8TdO7x8K1tyRvlpAegLIMRI77Wxiw511gCVAXHGFx8jNFM4z8yPB2tV1nxg5AMkabd7oBGalgOXEmORzLbZsR6OB8wRUgVxgp5ALkkQyJDIOspNz6bY0lUpaU6WyC8tGGFi6a9iZ1pg3VZIWhUjFvASKs6ZQxr1WgI8hzbtrq4G7F9J6tjTkZiEAWRoIyGt643DcS4DL9m4rm/4dI0nGap21mi6w64MAZC4MU4oyP5XOTTqszU4cG7Y7lGr5imlTyTx5vqgYIm4cdSmAQ0TKpGiWSjQ6F6UlvT8/D6VI/rZoNaYsH1OKgF2tgZ225iJq8ndta4WXX5izNWSV2ME09vW2t7B8LzIqyWRJt7AgwXAEDgeDwVIafXC5Ol/mn4xJAaIAAyZef+W5iixr1ZNL0c4pfeyl2RRtpfDs7U0qHIy8j1hL5InUyohLhnRTk6Jh0R2XR8ss5R77DQshIMWA4lAkQaUAZVkXnj/u0jVuTPayl71BnpsL1LHOsuzHMkijWh2XALJCBteWZRJTzjYYRwGeeAR7rnUorcwkCyFuQoXCjFjVRqef3eL1RHN2pOwUJ88phMykijZcfPilY27De8rh2qTamwnbs9J6Qv931iVmfvSShciOJS6kxBxCoGyTyBBlzMk4HNnGrq00dpomvd8xNyOS+152pYx8HtYxC58AMjlvLXnMhkg3q2washk9FyGzA0/RpEeB1hAhrMpnIQGPuIBIb4iX+rgvgPyWt7wF3/u934v/+l//KwDghRdewC/8wi/gB3/wB/HX/tpfe0lP8IvhkIld6bzY3/cRs0xAuvnQRqe4XWwuVJGIWXTKAFIqo5MBGmNylJAoUTRhAAFs6S5nHOmLD3va3I56Rw4TA2nNxJLGGI8by4EGpwmpCYRxARfmNSwzwofrEe954YTaAw8j1htDG6knfeB6beCcTxZM4+hwbTkSmOPUf1UpTt2HrY0CAE649ShAAHJpLQYbUseowPdCmBMqRKGGIyJLaWuNR87NyBWCU9Wi+ZTqaOMpDSnHce+5KNFjd1JRipxTe+vBo2O2SyngkT1Kf4mZv/MRd4YRHVcRTxtKX0n3qVlDIF4AMnnXkoa0cy6PJZUZKPE+lucfGQykRdzZLKlgsCud5cQ1AgCDxEBgkyUXmUEuFhdniI2tayCGZBeH4DEONqft2e95HF2SUYj7hbAWFVFG5GYhGDllSYhdlhbYwn6LCwZ93kjpNP785K7hbfoceJtAvRKqha87cJCQGHHDBYsRaLirJOmyFQ4H0mdLMHI8mq0iG/le/D6pta1KjI9sXJIJkIDuZJA21hTMSvpZq6w7tCEkz2/DutTB+OSGklL9SuoVqDBPMzu3N2swa6tUaBgibWJKke/xpN7uMqU1MZY+kLby5tpmvWSIqdJefvbcwSb9LnAdxO2NyylozyCsSEELCBaAHkLEouW1yGZWTymaI5NKp+5k4j7RcOc2Cprody1bngVer457cVsJOO7MFkgVKZKGSiyywnbhj9bSyZIK83Ym5N8rUhoXSOa019aJPaw1Aeg7K3aaYOBXAsW6cIaQNYeeoSrOj/5X4PQ3a3OXI0kZVmPAZgy4vRl5+Eq2LRMHkSYTTZ+QpQPyOutJfhDjNnsXY8SDZ6ZoKo2DziTdqGjGpZ298xEuUqAgBXhSECost3yuBgHDWU1Zz91pjUrp1BF12tDn77VUgD3hIlfyiwdqnr7Przp4BuIb3utkv5W5JIBvMxCBs+LGIqMjC7TBeAoyrE8+vxGiv47Ym9TpnkkDjxAzSzznzJY8Ls1eSDSmdALzWhPTS7Ircg1RCqnTm6wVGTDTMxdJlYyLptLQrHUXKUSj2SMYtM7MGSAL2w4AvQup66uXILRYs0gGkccbkTYEyjejw3xCRdIR2R8dAM5MGrJtHCzWg8NJ4Z61GUuAnNcAAbQAjZcTY9CNeS1RyEXOPkTWyQfUbFU32pwtiEBijwXPyMypeW8ceZ0o7+NLedyXR8YP/uAP4uTkBG984xsxDAO++Zu/GZPJBD/wAz+A7/me73mpz/EP9Dh9y2NamFSKekLYTqe82JHwQQQPRgA6a9IkjVNXOrENNlCnrPJwkXRVVORFqS/xMwT/zAZiWnLhR14IVr1N6WHpftawjMD7CGc9jtcGE3YsEFcEKXYQzeu6t7jKzR9iiOh7lxhkZ8n7uG0r2sgcvccRt/eFpzR301TM7HlOzRFbaz25buw2xDRM6wpr49jfkdI4bVWlRS3ErD+OkVI3UnQgtj8+xlRQk34WQMC0CEI23CEsaFm8yaRf2otan6P/i7NJemZk12Vx1LsUCVPnu5BAz05bo2PgBFCjAR8pqr/RsddyMV4i4qmGIXlR8j5gZ1KRBixk1gwx26Uhkh0cDQxOi9usL6afRdaRxQRSAVBhXWRtuCfAag2zASGgbupULIUY0rOGNYhtmydPIFs/rfWWblnzQtn32yA+Fdt5C4wD0E7Z8cJl8BwjeSpjmthx1G3BgtN7DoNL153eMxBYn0xqQOmkR6bghIGoJmcXARkyfgIvxqINpbQ96WQFfHTcXGNwBC6k3TsBjMDsWgYrEcTmak1yFSmyG11IG4FStEGLpMI4eh+tgMhd0BaTeovhkPqFEHNbVnkktc7+vRpk21amfVdjSJ6rAHBt0xdjkN57WbTntlzUJb9XnAIlwEddAX2I2J1UaTMFKCMCEGiZNhp3NsRUORcZiOoEeOV9F8yClmAeINnFOJIsjKQ2dHNlrtYMbJVinXYBWAX0KUVFsx08pgzehPk+N5lsFdHOG42bmwFakS2bVnkNRwF+pJ20Y8C3xYRCXq4SE+cDtyn2EZ4Lr+/0Y2LRgSxjEBs0Adhyj7JXLD2bjXMUyFmRP9Hn7kypSOuEPaTliAyyPWuqhQEUYK4VOQmN3BylLDhVigDwrW7gIEmh8XSebaWxAsuJxM9ekZOGSC2UUrjJ2QgNKcTLhFSp0xbHCc8kh3TdkyY3NlCLcZE0CVALIaa1Wyzy0hLB13JuQeNMWGCtcwOMqlIQpzNddGClhie8jzNo1jo3tCgbUElrZGn3Lcy0BBET3lPE4WFSa8zrmrIgyO8zuhxYhUh7ihzSFCg/VwrcfSRp4to6PLXYxfXjYSvD6jztlc5TIxVqdEXyHxP8lqGAjAvqNEhBveVix46JJuMFHGcPZZnnTUWWsy4S+zxtYpZw+NwenacVACTWWxrziFc0nXtI9SRf6OO+3/Vtb3sb7ty5g//23/4b3vve9+L27dv48R//8ZfkpL6YjlAwCMIQWE8efvd7yOQWaYA8dFl85GEHZpDXg8upRXAEx5uRsEDtVjqIBvi8qWB9QF/Y4hhHTE/HxRfWUtrccIGgY/C7YrmEAOSBG4C8cDwmgNx1FkebMWmMB648F4sw6trGHc3MkMA4AWRqV7yYNjldzoGG97TonQw+GdDP6wrr0SctsLRx9iEz8sue9Uug78VW6+phn+QsLkp6JqSJ3bOFndz/gTVtJSuR9N088SVA+sQxFezVGpi3OhVDDlzwKBPZcMHEblNTAQyz/uJDOW/qVFxJXQFVsmxaD9vaZNlcnQt4+ExLLG8spDn8b3BRHEkhikXTuaTJFcu1PHhCQiKT6YTHE2vmYmTWlhjsuq5Jd2xI/yuOEwRCxc+YQLgZDZ2HpoAoxoi6oQ3IjjYDWx4XShO7DDvQ92bI1wUwAz7mc2YQrCQaZDDS9zYDZKWZPSYGaDZr+H7S57lC7lRplXTjAFIwFSNrJfn5C4tL7cq5dTuPWcMyJykkjVEyHvQZAg5EPiVgWNrjji47x2QGWaV05iRJPajqfT6pmFHm1K3PYCJG2pDBYEoyLJEB5GbMso4YyQFAPFyVUri1NuneRwYUG16XxOpq5MBAMcgp5SkXdqjIr2UXFMfMkKS7vaeUt2H2yPtAKeVGp3OQ53t+l8clB4qr0adxPI45CyMguWJdL0A+0wAxvRKkSttb8p3WmNVkuzhnCzcXCYCcXTRbjQgWE42jkVxwdtuG5S/0uYpvZEABimNMMexWrYFMWyA1u6CunVxP4khfS8A3BwvJTgvbjHgJIAEKQqTp0WA8M5j0gquHPUKMWBubCq/k/ETSIgSEPHsa9wT6qYA072niALI/p7m1GckOtNV032SXkoxLW2v2E8+dKButcDzkrrFUUEeSgxA4IxpjWrd6LgrtjMe8rmAcZRVGZjNXxmE1FlnWQM/lFed3cq2PzzUAcm9edo7GGTHEBHJb6Xpak0RHQ6GqcnONpsp2aHXBIAtgE7/yECg7Mqmy9dnI2aVdnsfzuk77OjUgUthparScDUoSER/S/Y2R2lSXh4B/yVYdDGNi/TfWpTEtjC0F95R1sD7goLPYOIeNJemYSAQpg533XxfI5nD0gYv/IzrrsHFuq3hezkkK8CRYpk6c2UZPGGqR+NBcycEFacZDWs9cyBrzex1l/cXne3xOsHs+n+MNb3gDvuZrvgY7Ozu/7w//YjxOw16J1sU/Etj28PuM71Xk9hRyKlQ23cg/Fx1ahBSsiMxAsw4KabAKYzOrKo7Ac/HgbtMk3Zg0y7DWYz049CNV+zoX0PdFH3lu0NB1okHMYNe5gFvLDJCHgVhk+bfhgj/vPaI1zBoqAiieUuMD++RKk4kzi3ZbTwraHEc2hO8YXOxPWqxNSNGk9TF5iQrQXQ423bOjwXCXsYBlT+lKE2hS1xUVQgn46bgrmMwfY3OxxnHv06Ih8hVAtKMKzx6M/GwVzrCHZG8Da/WQ3kc8N/cnbXYqUSotZnuzGp0NGLxLYIA8VCN7LOfJneQhNuDLHthL7K9ogsHpNpEV1E1NwBQAtEayWju1YMQYc0GbrjFdTBPQJHY5N+Xw3kNXGlrr3D5axG7BA+wHawy9nzWWHG84vxhDRDNpAEW2f7mLCz3vqqrSuCGLN7sNgiNlIbbYcaUzsI4Ees3IvsuKwTm/v640plM6nxhICpIaV3Cac3QhAQTZUKQ8SDpByQYWIjE8xKrlIhUfwM4GmUGWQlxheiSbUVcKLrLNFFfTj5z6JdDJTYYizenFpOakr0prhMgItCpbK8fkeSsH2YwRWJg0ehtUAqkzJA0ZhcPCl1Wp3II3RmLTKMMS02YvzZNGnjsvO0tFfse9T8zkwOlU0TW7mG3RQoiYNlXSdUtquqoUnjg/3Rq35YYo6xidA43PmtdTyrSpFHz27CkugGPCa7qAtVlNhWTOEwFxbqfF5TPTNBd32xob9qTfZfa+dCAqGXjZ2CW9LvNfnpkcEqhLQD16Si8fD0WNAR+NVlhwIaEq3l8AmBw+5MKpsnGJUgq3uhGjD2SBluRWOVuVAsJif1NQaHXFEjCWV2Bb5/3EA4QHRkcdFf9/7P1p0G3ZVR0KjtXuvU/z9bfLPpWpVIMkg6SiERTPtLYLCvuVg7JDBaEwbnC4ITCECfwPR5ggwOHAWLYrjMKFDZabqMfze5QJUWBbChRGLhASqMtMddnn7e/9mtPtZq1VP+aca+1zs9EVqVeF8dsRN+73ne80++y9mjHHHHPMhtc5+fxFN8Ab0nrL2BYSyBkK2MSCrxu54sSYWGJD+6NWDLYCZTBIX8sF5h3Ztp11PRMdEizSOVw52eSAcuDCPmlApRQVxAHIjS+s1phKoRo7OWhNspwEytJ4V9xPKkvWec6VxhrOajTeQmtqqyyAW+arVqR1d5qKbiu+zlZTA6uKi0OdUSVrESXYpnvqOHg3DOBzUTVf49ubPhfDroaAm2dtHrMyTlZ9xI1NiyFEHK9pH14xa7wZQmmdLQEUs8ltoGzpsg3ckIWKKFvuF5ALFRn8tkxcdYFtakPpeiktwskDm14vchV5D8nm1s6wBa4EltvrmTz/tR53JbH4nu/5nlf9+6/8yq+85hP5w3woJamkEUC+29fy/0YXWeTYA1BSKaUiWPwxVW4G0KWIlquz5Zj5kg6SheCw9myLk5hBUszcUNojgtnabsAw2Fy5PAykTc4plECpy4HTqsIQi5uFOAMMQ8gAGwM9zzmDsYNCCJIip4k4qWwGyJIWLOeYsjZ45i3JG4aYA4DaKpwxJZMScNr1efIsB+pSt+rJ95la/uqsa5PNi2y10kv8SGNKANvftaO0ZJIMglEYAnCLdVkpkeVdSmWRSYls5Ijp5021ttkNgSzo6J4+eDRB95mIDUfECrTwSyOY8dxO/N7DEPH4zTMeN4paSPMgIiaVNlXnXZY2aD3aPJUqwDm/OZ+ctdjdm+CmGhXPJGKSFV9zASEisWhZa0uMLskhhiFkYG2soc8biI2sOMUZhvASGYgU0CEGGGcwjMCxuE8ICM6yDQ4S5Ttk8E4oDtpoxBQBmNxhD0pn7WlMlFaUNGdYFYCTtZ0CeDSliGtjmOEVJpIa+MghIHFiSxpcJBMug2tmyNhVQZgQkQslYAS0mImOEed2KnzuxllmlMW6SdKtQypZkn60OY3HUUwERKWQUOQIawZMAnbP2qIbpyxPaZdrrcmNfmRYSeti0eRKpuTmcruwT2uV6xZON0N+jxgTAQne9I0paewxPyTSBDkCp1yVVvmf96SD7lhulpBy0bJWCrUlgAEn2kxigBu2eAwpobKKWzcXq7yZs7jJLcp3Jy4HTbIv3OnLqpXK7Kw1Ks/zzIiC7yODeQE/fSAdcrn+BQxPOAsjd9aydlr+Dsh4SQwE49brz/oe6z6yk0PEDFmltQXuSRqATMJIINHHmNdUo4hhdUZl5wLRDteKWzhz0LkOxCBbrTNbGHmP8kYxk1icniQwTKmMLbkWfSBip+1Cbp4hwXnXB9xeD1i0AXuNzewkADxztsx7eUzU0Ee6Jmqt8NwJfQfPln8hJuw19D1qZ9BwhkGKTZ2jluBzlgBV3CHRGA1nSUvsjMa8pvdovCkMsSJ5ldakda+tZk144ACOxqPn1s2em7vIucu1GE9xkbvI3iOZhZNNwG5F2S0M5O0vhX3ijtL2CbfX3GGwC1gPVEOTEgX8mxAwVTaTdDGRVEsAMlvzvMgAAQAASURBVPUj4E6d7KZlTWHSJXvV8ToikoxN3jsLoN2EABfIlWTeuDzYIz9Hiv6GRLghYTugo/dLPO/wmo67YpAPDw+3/u3s7OCpp57Cb/7mb+Lo6Oi1ncEf8iOL7VWJ/OTxuz2ECVJQ2cVAFmWj1FZxR0LKGiXRsgGFpZINi4oexE6GXiu923teFKaeOlJ13YCOC5zCELYKP4Yh5i5VkRmmMJD2VLpkiSl/3xMgjiECXDwVQswa42EYMGscRQKsLS3sMUW1XR+2UvdSHNL2VL0tHpEAMqsSEum3JYKWBf2MW2xL85SUxOMy5BajAjo6Bp3SAELkDAIoRAO16QMXO9E5SKpP3AdE/tKHhD1mkEOifwkEsOl19PrzO1XeNKwmFsBpjdvLPndAAmgNEBmGLEJyv2XhCCHi8avrDIgpVaYA4zKghVIEkDWBU2KTVQbHKgPFAoIBwDiHxx4+oLHNTDHALI8praG10VkT3LVdyeOxewb5E5OXsnU2O2MAwGxWAZoaeWSXC3bTcJXjXTrS+fNrtNFZmoGUCOjKzTGOWHR+rnWWxhtRj/Q6vibWW/R9hKAUO9oYrdGY+9KFTu772NpIK2QXCwm0RDIhDJTcuz6UcTsuzK0MMUzinOtY9iAMsqQXBSTnc+GC03G6XwpsjaKNk6ybwDIJ6cip8tgaH3uNyfpHy4xWy57Diq9Ny40gCKTqLDlSCqi82RqfZrwRxgQg4enblGk5WQ8soUj5M6Ru4XhdirFSAs7NXZ6jltk6azWevtVm+UTWhaoyPgU8GWNgrYVn8qDjNLrMR5Kg0LpYO82Ap1yXmXPkIsIM8ul6wLXTVoYQdrzLIPie/SYXTwnwHUZzmacYjwkKloQ5dexXrVBsQwXECZO24utvjM5zRSuF/crnsUHAVeNw4jL7Ox6/Qpzk+6QUVj37HPfbnvzjw2gqoBNbQasVKl3Y/ZgIOBhd/KOvnmzy/TdaZQZV1vM+RtSWugRGIEvXrFJsYRqzZZg0jhI/bEnpA8ht3yUj8eLZJpNC1H2RvP8XXfENF4Lg2pIynN7SexC4pTlljMaVMwr4K2cwYd/rCzOqc2gqi5mne+EsZWysNZhWFgeVJ9lNRUSXtRreEutdOYMLc0d/b1zRXmvaM5RSOKorTKzFtKbmHBNP11oCNsNWhHuVz+NV2GcJ6JQiEC01AArI92vJ3TKHSL7d1KBK52ADoPVEOusuulJkHhOw6VNuqCJjVcaVrG8bbmTT8p4mLjjZgYPxhmTmeqm7YOJvbH/Yc9Mh6dYo80kKEL3V1HCMM8aSYR4TjxKAvdbjrhjkX/iFX3jZx3/0R38U8/n8tZ/FH+JD6+3e4Bko3xmyAC/ZiUSbpkBauF7JopW2gLekLkRvOCRiFUtxUGGpLAO1ijs7ibsGAFxervNGlpBwMKGOVG1LG69RbKY/FH/RgTXEfV9SnWOGt+sJ7KQQijVb6FEaN6Scco8hkl6Qda1S/Tt2MVhsSicsAlQp+3d27P6glMJZS61oZdNOKWGv8riqKcpPSFj3AfsVad/WA2n5uhi4C1PxvQz8O0B2TUNijTFPqMwyKOQ0tzHFpqd2JZ21YTeKfsRAjzWT65E7RgbZIEmMVCkDwNWTDVrWncq1kQ39Tu3UWIpy/XSTpQU0FhVgbGFgtYH3Zgsgd9oQoDCugE1mg2OK9Dxv8eC5KaB0eS8+LGc4Yogw7CiAFDF0Q2FmYymcknPOWmi+/3t7dQY2ZqST1lqjmVSMIDR8XYz3jTXwLM2AUgV0KwVjCRBBvoOzDNo1rLVw3qFTFED4yqPnYi6tNTx3hrKaNr1dDjjloBQyMxXMMo4DVm9KY5iYkNO1KRWmQxuV5TVWKSrWS6UpiMQWiTeOGEsRigAeWeSHmHCFC2uAbdu4xhv0G0nVlxbXWx+UxxJZFcpmpPk2FIBMoEvYVwHAbVsAceMNVmuVGSspSlKquA5cPu2gAKzaIUs7+kANj6QJw2JTulmmlPC6gwqfuLyirl4VFQw7Z3Br0TI4pntVOTpppYVFI3BsrIF1JhefbUIgdwW5xoGcAma+OBJ0IWamdK92cFrAk8ayGzKzbxQBFnIYIYkKeSEXud1Yepcw7mZYmNg4+rtSYJauzHcqKC5EgXMafS/vk3B+ViGdlvVmUhk8uF/l7zh+L6NKkabcp80QS1e5mLb0zPIcbzUzlzpbj1lNMouNivx9WPJRkZxg1RUvdKVU3p82PRVkUeZCZTu4bmCpgNGYep1bPEvBpTUK3ZqlFG3g99VZTtL3DJBPOw5gSU64agfcWpH0jxh5lo1A4XhNXuLSGXPeOOwwu2u1wpIzYo23aLzGqtd4YD4BQMWNjSdgXLGkwlqNg8bihF1xZF55S2PsxUjt3x/YJYnQXlO60RFRQ3vy0bwidwlvsGpJI2wNtYW2bE9YW4X9icv7B7WbVxzQRRg+r1qCL6WyJHHTF+kCQHvl/sTnsQlwYScTZx1LEGV/7ELMmQMZu8LaUpMikUQUyz1pdiSBs4xDAd1ZThNj0ehzl036bjFncmWsD4lqv6zROGNJZTdEzu7GvIfL8f9zDfKdxw/+4A/in/7Tf/qaT+IP+yGsJYBRNH/3r89FfvwvJWRGiipHiyBdUqpSxUsgGaNFibRRHUsPjCoE4c11v2UJdO+Oz3o/SbnGUHSlgGiJqCtVZhwCg2JmfoQVlPbC2wxxyixxjBEXeTGQIhrndD55rTUNerYSSyiV07lXPX/GWd9DvBplnB82pao8JbADBAUhYpguLbi7UAKFmApTM/WkM3y5CFMsnsRnUe6BpOGUQo64Q0w44UIaoEyknlOasjneWtL3aLyB5/RiZQwFAKH4OiuULnpFv1i+q4CP5WYANMkHNh1bqVk/AsiW2FFtAGOZTZbfCSiKbnkLVFcev/PZ6/lxAbdKKVTcBTCEkTQiJQzDQO/BIHgszRAmRRhkpRTq2mVQnOUhoPT4hBdsKIVmUssfYJ3N2mH5HQz4jSVQRBPGwnlLn68NjDMEtFmLXHP7YqUUtCGADJDdlGFmzoyuN81H5DEFgO2U6OeKJQDyPPLKLY8J+yzslzM6yw7kOT3XCsQkG0cpcpNDfouJmoXIMSSq3DYKmFbU/pg800vKMjIKywAIHLjw7xT8c7OUWBwRrOizRwBYWHOtFRq+ztIsQXNDjrEcYbHpc+dHoKQ8U0Ju3Zs1zZzurbngauLo/jhu4LFuSaevNDGq80oDrDdWzMgqTcGTc4bPDzlIlusREjFas8pg6gmYkZ0WXYNZbcliMRHY2ISAJfuNjyV2AHCy6omx0+X6plScMYQEMbyg5ySOAOQkWv+ytpMNGDgDQFks7w0Fk6Dzn1SF01IK2K0Mzjf11rgFkPeafM85UyJe8iLDGx8ir5FukU6r7KygFNmFWZm/mq7b1Fk0liwrJdulQMwpsK2Bro1miRL598aUqI2xI8mJWJgCNL8GJkgWmz4DeQG3gWUWt1jCo7XKGc+zdY+2534AoQQgYi/WsI77wo7PMhmyF6R9sXaGCyIV7t1roBSw17hMYElxp7cal3YdnjvZwGiFg4acWzzLMUTO9MjeDEopTL3h7rTIe61SwANHE3KQYnDdBxqnFYNjq6h25fxOBceFgDK2PRe6agb+0uwGoEJ3ugdlz+pD6asgh3QNlbbwvYwPCLNbZBsynlISqzXkGoncHpwJqfFSJqyzrHFj4kqklpJ9GJgwGNcaSLdDWR9b1u73gbtJpm1AnBJwx/D+Ax2vCSA/+eSTX4FT+MN/jFm9DFpfBiHf+YiCROVlQZGq6tLpSXHzEJUN1pUqljFWFdZRolerySsysyeKIsnjdbFdAoBvfPAoA1ByWFBF9sDfK8aUrbTy94xD7syWHQ1iygttLuwCF+yEmH/fDKMSZwVyrQAApaFN6WQlLgnCTI6ZN6AwwmMpy7mdKgOTBFpkAXCqiFnWlHJXocS/C1usFbBTWe4uVTbs8X1NzC4btuQxmqrbx3plOn+ym9IQvZ7KaVYJaoQlS4k1bNag5RTRWddT68xQ2Gsyiy/+tcKuCShLiRw3wKlkOhcFuIqAL4NirVUBxLUnllUbwFWoJhW9RsAmM8tVU1F7aW3gvc1/I4DMzQZCzN30xHs5651TIpZvBKxlYxe2j7yRdWaYBPQaYzCfFzA7n1dZEuK84981/24BU8A/Ff4pwFo0jSPAZyx85VFPao4qPWazKjOklp8LRRuxNWqU/izXW+7/pmdQzL7bADIzCSDPPynA1ApZNysbi88exioD8fEGIM8TBrYER2Vcb7qQiwalUY5WCnO27iLgURjqohEucygm5AIwAcBj5lfYO8loCWgS4EwA2TCTa0oxnS6MFYBRN7PyHQUQyIZIbGGZ41+4uUEXIvYnFtPaZbDbB7IuNIZA88W5J3DMgL12BtZSFqSqqE2u5U1fAJ1slrVV2K0cZt6i5hR2ZUi6NfEmt66uDN1rsfCzauRrrNmX2hBZgdH1lWsm48cZ0qWKxdf4XhDxQu9peQ2phCEdSIZUVZa840Fr2s2zNjN4Silc2nV45qx4VsvnetYMS3AjzgwxlXbNcipyRlKAVnFBWmUMamPzdxJ5mOb7bbXC3FnUxlDGAYVF96bYomogF7E1bKEpTgu1MZg4m8mYgeWF3qq8b63YcUUrZL011c4EnG3IhtJqZIem5aanxiBOF/CVqDDMciMpAPj6+3ZpDVcK3prsx1s5IqCcVjheEqt8fu6w7IjR9tagtjT+H92b4cXTDlopnGtqhEj2aDXvGZPKYMXAuzIKyy5mUJ74unzh6oI6BLYDvNX0v6F9v3aau0By8R4D5IH384kzZPGq6drMvMn7RingL3NfgHDlyIdLYMw4eyVuNLL2SBZM7oEc44YjAogFUI/9lcdHSMi+8ymVZi7y/lII2sfSRp3GfsxBlLiViDQte9aPPmc0zfIxLmS92+OuJBY/9EM/tPV7SgmXL1/GBz7wAfzAD/zAl/2h/60dd/qJZmbgSxx0k1Q2CPdsCaMUMvAV70zN7LBOZcGkiV+q1I1SOVW/GqT1LLJemZpVIE+8T1855SIrKgiorc5gmDY8lRngGGPx/Ewps8VKqa0iO2KES+pD9KmyK18/3fCXJyB0xBZN0FQoJfrBYiEFDMOQWReZhH3+fOTPooWjMDZDKC4D0tZZolthMnIRUKLvfGnaZBAhE1oCjdIzntjPyhl4o/J1sqakrwDq+ERNCWjTFIAtGrwhJpy2tMC2Q0RtDW5vOlSWuutlzSkKo+C13vLQFDvBXCAaYpZKRKaejPeoG0/A0Xr6HsYArkZVs07XWMDXmO9MctTma4+lUoC2mM1rskhjiUbgHVRrjVltme1KsNbkHTUldqYQSyet6e/8s3OlMM4YQx7FzH4Tg8Fsrx3JQozDuaMJnmCwX1UW+7t1Bv91bQHjAOvhKpet2zSD3lNbAoOdnQqXtYG2Fru7FRaLllhIZzBrHNcAFIcab0eAAuCxVjrb1SPpQWNNZkgcp6Jn3MbVje5fiLyx83WRua/AOuFcl1AKk8brS0JJlfc8bhUHX95SweeSde9UjMZZFSW1DvT57QiM31qV+Zt4XoQRYyxjLTPIqgBRkZwZQ0DZmBIglk5kKjcsks8Zg0bZN4c7NqwXTqh1/b07FeaNQx8imorSztpomGRgrcZDOxMCzJZ+nzCIdN6haSxmtaO06yjFK0fjNXa9Qx8jzvqByQhaU5ZtIK/4kHIxpqxDllk70fIOgXypFUY+5grZDjAlIg/GTiKUISzrqjSM0rwWUxGbyjpkpRQmlcUpkwJ9SLi57vCwKoD/kd0ZPvj0LQAFABALbHL3wDhikMHjzrBlIC0+d8orFDdDMZg5m1sSC1DTqsyNHQ6eT7s+72VjAimmERmkyN9egA6ALFuR8xfnAiElxE5QvteMpVHDENF1BCqtdvBGYxgC1mvqFOssgcVxh8GYiHiacRHnrbbDrTV1qKyczu5B5EsdMa9ovU6JwO31ZY8uRDTeZuB6Y93iNhe9PbA7Id2t1bkQfF5pXF1t8hhYdiEz2DIPbi47GKUwqyymlUU7lKZAk4qCX891K5VoelOi5jbMVButMPPE6Mt827Dfu2QzIsBscGTyqRT2ZZCZpAX1dgZTxvcYeU58WQNzS/BUZC134uPxHi9vM8SY5YqKJWxS2Jwbg6BIMgBk/bycs5y3fN5XQlohx10B5E9+8pNbv2utce7cOfzsz/7sfzcAWVYkKRK5O4Bc2BVanIo1k2XALAwDMciATgUYA6UwSDZNbzU8VxOPwaM3mtsn08hUUPjC7SWzofSeE1eAqRTWjHVrVFhAYFjYYmNUBsfAHalxpQjY0BeAUgpn0gSCwdVX3cN2gMbBWEOm4aMNkz5ueyMrELikd7UCjld9vhZA8WPcuk98XjGN/ycAbZTCwcTj1oYKiGQiG62QTGkqACCn0CrulkcL3/b9bYfIwEDlbmsAAaaaX7foqRHCybqnzmEh0AKaixW4yAjltVJAIZtWSmC9JW+81rAWmK6z9RazGTPI1hNzyz/XApCth/YVjo4mxOYzQIaiv+3u1jg7XWeA3HWBivqYKSwAWW81AKlrBshqJF3g13nP2mf+GxXJ0bhIdKMzQE4J+ZzvPZgUZruyOJozQLb0u9IKyVbwtSdpBuuPZzOP60YDzsNXHvv7TR5353cbvPjiGYF4Z7HDvq0Dj4tuiOSDq0hXSowXBSuSnWgsWQuJdVhxbCDN4Nw7GF3s34Qplk5jxLLJOJPAeNulgAAxRu1lix96HykglCxUiAlGUbW8zKUhFX9mmde5zgG0eay7IY8vek4Za+O5PZ5nSiED4pRonE4qOwLV1H5XDpEVyWYo/8jFoIDyMaN6xhrQNx3u4EPNMRabHtPK4iba3GTGOYOvuX+PADMzyvsTlhWBAqhZZbLzwRZABd2HHe/QhsguOHJuCqsuZE/62hh0MeTGJo61s1aV4idv9Nb5i6tAbi6hRdZQ1v2Y+F6jMHw07wmUSgAReP31VsOY0uzorO+RnEg4gJ3K4fZK7n8B87UxOSOZEq3bUlw2hAS4cr/lG1hLUgNxrBAmdGwpWPF3lhT9TuUwxISTtjh+SAWDDCejOfDXRWIoKXqSHZV22Ik/Z8oe86Q3puZGlh9XimpYyB40AA3NOyk2F3/uHW8zOM4yRk2sKwD87vNLao9uiEFu2ct+0wcsjcLhxObg+MXTLre4ntfS/Q747I01VtwGfpeLJZVSuS371BssRpam6y7kwkCZW7c2bb7e1iisu8QtxdktR9HfNn3INnEAsezzSmPVRy7q09jxzPgDuXhYxkSem4lqDsRi9s7jTk18JpGwPdYbLtZ9JcOCMUyVj5fHjGb9flIjQJ2KLzeD33HzpJQIQQmgTkAOfMaHBGlfGqF96eOuAPIHP/jBr8BH/bd7EOtZfhcd0Jc6xi+jAp8ir5BFTLrMSNqF0g3Fb9VohRqkMSQgRqmvTRgYSNHn1E7j5mrY2myvcHciY6Q4xxR5hVZbk4Yqdc3W5CCfR34xF4ZlGzeWTMwbVzZi1kbTiwmYvPPiLoeqlLaf1iV1z4omxEAV+hLNikTB6rKhOq1w0vbwxmxVno99SKWIKoF8Oo0ADk0MnNMKl8/W2PU+g80++2EWYKqVgrEK08rCG5W7jI3BgNYqp+zGchkJoKaeOjwtuE317bbFuabmoiCVI+B+lBpSzCTl8aPHhVAFNBtruG0yoY+qrrC/30AZg+RrYvm1BqoGTcMFfLaCqxze8tBBljzMZhWuGge4CpeOpnj26ZuANmgai+Wyy6y/ZVeLEMIIIBMIm0wcYB3QE9AlwGxhjMF06rbGQowpM8hJEDKPi74nQA5f42DqiSXWBlVFKUNoA+U8msbSuXgC/yLNsM5if1bhOWtgnMNk4nDP4SSz7W+4MMUnPytj2OJwXkOkOSQFSJg6nR1lrFZouJJdpkRtLNpAnaO6SJ6+ABVg1lZjt3LsKkFSGgFSVitMnMWqbzNbaHiuU/MBOiRDYZTmNtLIa4BCyYaI5Io2Ztp0qWEOs5MoTKSMo7G2edOHvGGFEOmeKgqGM2hSheUhNlRjWjsYQ12znNWYVyYHzLRh2vzalBIqa1geUZoneCfjuMg4hCBYtwGV07i97tgzllwClAKMMRTUWY3LtzdckEeOFeemDtYaOM4M7NSU+Ykglr0EvQSQZ7WFaofcjpgCDeqs6I1CHzh13UZ2GmCAzKBOtNe1MTCqkAcCiO1o7SYmuzDyJqksn9C6FGFXHNTUrmTBROblXNF3b4YAuCKx+PzxGdZdCZCUIpC7WzlqYqFZamKJjBHXA559+SDpEUlajKL1rDZ0rfpQ2lYLE9w4KjjdmzqsOIMhWc+UCkGhOdibOMNytPKZQvhIoCDf22qd7exIb8zj3ijsVBR0Sdtx8aynMhnurMguRBcmDYaB9cqhuD40TARdPV7DO7ouldM4W9PnLTcD3wudZYhXTtpcXGaNRmUVuiHg+eMW6y5gWlvcXHRZPnJr2VHHVK+zN3gfKTj1ttqSL9xue9RG46Aunf5kvJ2uB9IXG8OBm84FxLXVmHuHVd9midfcuTy20mgP8aaA8pQSu9Qgkx9yP8p4oP+1os8ScwCMxk65x9uvuxMvZ795+RzebzXUaA+mdy32minfX+1M7vBI2akiy5BaD/le4POyd5zX1rncBXaT4zVpkP97OcTDsvyuR+nEVz60KghZXmNH/4R5VCh6NcePS6ccozmq15TGlUWeNvHCQkycfslnn7Uh689SSjioPUW4mqQRY9ZWa43KmhziCRhrPANi3qAyqGbm72BWJBRjjbH8/htfvJlZSmMN9pjxkwIbgPTI88aRPpMBoWNAKAURRlPHMqmqlkOibICAiETP9DuzTkbn1PWLizUWfSl2Gm96AlyUIjZ9Ulk4Q9cxRlq4i0eotJUtRu6W5RG1M5hWlKpds85y0QcsueV0YmA8Tg8ByN9/4MVca82dmkqBkjGUWiZdMJ2Lr4l1NYbAofd0fY1zRZfLOuW9xmYGeT73WXrx4LkpnQfLGsb3kE+O7ocz2YuYutOxvlmTLrquTR4bO1OfgyMj2YkxQFYKsJ4aOzB4ts6SVZ4xxAR7Q84nWgARfT6l0x1p3C2B4IN5RR2vPMkt9iYesATAv/mBA2q/bIghv3/Pc2oRWeIwcTYHKJaLh7wpFoy1pQYBTpOtoFTPzzx1wNqbUtHP3Dkq/JHxx1rCkMS3uAAeSaUKqJVxvDtxZXMy2wu6ZFE2fYRVGpuBKskF8BmNl7xGsi0JyI01UiqtjKUrGFAKyMaHtRq7NY2rIYoOU28BvXnFc5rHSuUNzSurcyeyypqcmRqz2BSsEJD4/PEC/UBa/alnxwBH99E7g2tLYpStt6icwSEzyE1jMW8c5pXJzLEUiykUZlXaLcu8Iy9kZO/00pSBga1CZvSEXRXJXO5oqkoNiXy2ECFlPVIZoMp7akUBknT3k0IwuScxkZ2Y4Z+l6C3xd7py1qEdWfpZJlH2ag9nRYNLAFmCeQEs0oVUQidrKTCTcaeVwqwu3ruSDSDAqxESZUumteXsgBQd8phCsUOcWpuLVOlyFcZc/MTlcWtISghIETd929oYzD13w2SAHEKpfRE70o7rc+a1hWizRdtsFHKx9OmqQ9dHeGfyXhFjwrId0PXUenzuiAA6XnZkeRojrKY5uO4Cbi9btD2Nm2U3ZM30yarPDHLPTk3Ha7IQpXWE7mI/RNxeDVh0YatgTTTvZ5shj5UQyX6wNpTpqh112rMcaNSGHFzG7KkA5NpQVkumdc/ZrMbpfL9dnpOlpoYIqzJWY8YHyM4lYzAqtoB6tA+LxEfgkFbYKhIcUsxjMMsl+HViFzeWY40L7Au5VGSwY3/28SFBw5dz3BWD/C3f8i0vWTBf6fjP//k/f5mn8If/GDsLANtd9V7tEI0ZQExGumOR0cwUtT2lESrWXclEkIhOK1mM6featYe04CIv6ACnzRQxsNIZzLCU4t5Zw88pG5uwY3q0OcrvSinsNB5chl+KrgDAUBHN/Qe1vAGMZdaLgY9zBi8ebzj/WsN7g/2JLcCLCGTEEPHQQYMrZ10Gm9KDvuJCAG9JA9hYlwGyMwohIYNm0dyFpHKKO6bElen0va4sei5qoPcYIrJFVZa18IJzOKXpseQ2m5XTo4lOC9asou5ISlF1c2WpgnnqLC4PPZZcrLTsB5waza4V2/6nJe1E/4uHrVhaKQbLhsG3gEPFQKSZVHjd0YSuvyZpg/gHT2pL19pP4GuPz15Z4P90nq3N5jVgHJTzGCJrzlyFScVuEOwzTGOIgicB3zD0vlnyYBysjBFmhS/sNRwcVXCuOExYO1p2qkkByMbBekuMGANirUl7Lg4cwt45TyyxFCS6yuHijs9a1MnEYd0FaLZ7u7FpyVOWZSBvPTeHOkPW7xktm42AWtI7eltaUssG4Y3Gkr22rVKYMkC+74C8cQ9qj7O+R83zwWtqAkByCQnE+Oubknq2prgF7DTkba1AAZ540iqWCaz6kLWKq2Fgf2aywrJsh0UaZzpEXqFQWBRJPws4HmeUjJIqewZe3LBAJBYNM/vi02uNwl7D+kcG+xNOwVJgQpr+WcXFRuIlywGI1io72bx4SmDEGJVBuGMCoHbkmGAd3dfaG0ydhXMak4nHTuOxU5OcRYMya6LJ9obu8U5jcfVkk7X/G3bwafl6CeAYF6QZpfP3qpjEqI0hPTmvY5JZpDUrZEAqWwfJHVjyYDSMjlniUVu91eoc4AJoYX8ZUPQx5c9TSuGYW4RDll1Dwdi5nYqaN3DQ4a3JbZFJ3rBdJArQHiUuGfI8uR6boRQ9O0OODEOMWLQB5+YeVmkkJZachUkkNwyNSWXy5ykFGChUVmVALNeI9roig5DUuwJpXg91hVw4zmNZwFoMEUM/IATKzCzbYUtiIWynUvS6dTugqSio8pZrAZjlnVYWU2exN3GIMeFs01OnPAarlVXYbHqcMvniuIA3JWCx7tGyz39lNE4incfVsw4bAci87rd9yEWzIrkDX/OBwbasPSkBnr3UZc/fqzyeV2tUpujDxYGJwCq1tx5npOWztEIeEzLXFM/9ypZaq1w/NVoftCLLU6MpyJfs7dgWUO6pZB/G4HvK64dWUpyOfD+BDA2yvDEHjapkGsbHVkY/vcxjf8DjrgDym970Jrz//e/HxYsX8XVf93UAgN/+7d/GlStX8O53v7t4of4RPcadjwBmg19Gu3PnMR4k3pD2UnSHEhlNvOG0DW0oHftByoDTDBhFrwwQKyIaSQGGM2fJ8o0jP9kAUyq64ecXayCBgSydmAw05wzbLiWMLcAu7REAloKYvIA7j6oqveMllZ3ZXWb/1l3IKXDP7IQwikopJEUM8pvOTXB92efvtFuRrmzqqUq34ntgtYLhsCOnsJW0jtXc7ak05mhH6ZghJXb6KAVIAhAk7ZO7GBqNc1OHm8sBa+6ON/Ems9QAgSthq2KiDaZx1NnKadKornoq9li2EbUZcvGGAORxJCza0oHT/lqTVMNo0vBKQZL1FpOJywvOdOqx6EJOO1eWpBG+8pgzg6yqCnVTYbHpIRZZk8pSIOMdTpYdvZ+1OVUOR6y/1sRgjwGxBESOtaAD3++UEuBqktNUFAwpSwyfUgCs4w53KeunrQRW7D4ROMthpeHDEABrsz+y6KcnvHlpo+G8w3275G7gK49JbQlksbvBC6cbOEfjWnSsNx8X1orm+Nw5ctcALfqG28iuU8yMG81lg2vLPvvqUsZHNiByW3lxuc6drxyvF4m1zVRcRxuTs+SEIBIrBarsP1n1ufpfZALSXrZ2zErxOjF0tMEI4PNGvGlVzmDdsZ/k+gOgFGcJqBHQMmZiKi6mkiC58ZZ/5yJko3E44U54mt5/p6ZMl3MmF73uNQUgG968AWTgDYCZtgGNt7lwzY/a9QLUFKaqLEtRCLjPG4eDqcXEFm2kYxmaAoHliaPM0FhyIrpyKcKrDNcfMFPvtHSVQ27g4Bm0mpig2DXTGA2rIyaVZT3ziCULrF0fFSiPMwaV0Vh2MTumULZGyAGdgQzAt5TBRem4V7IAjdNZxy5rV+3NVsZQGqLIoRVQM4EhbHUfE1ZdyM05xGPfG42ptVgNA1btgMnRJIMpxfNE5bFLqX+5bxkAGtLM5u+DMu7EQQOjx6GAZTtgZ2ozKz4+WgbIok22RuOk7TNAHgce4rDQtgFhRtZ5Y4vHrqNuqrvek7/vELHZDEgVzT3HY369HuieW8okUJvniPU6oKponTGK9oFhiLh5ukHbhy1ybdMHHK8DFRmmmLtuSnFw25fC3BDJFs9puj6NNZhWJDkUOZj0OzAaWc5VW533SINSk2CUzvpioyjokYy1ZKmsIvmP1yaPPxlvPY/pympukV06I44JvpBSNigwHMRRFkcKkMu9GRfNj+9VjIkLWrdBuvwu1/RO/fRrPe4KIFdVhfe85z34uZ/7uS0m+Yd/+IeRUsLP/dzPveYT+cN8OFsKLeTw5ksD5HGzCRl00pVr04sNjKU2r1FjWlmYPiDwwibRW8U92iU1JBW00jnHaeoEJoViEuXKIT62Tx2v+bx0Tm0CtAB5NilPAlzYJeGRI5JQWEeV4uScQECjaRw1BGC20XlHi7Ci9L5zpJsS5wDvCSjCVbDO5o0rxoj/+twptCoTfV5bZiqIdZXihLHYRQoMPDM6ApAVyiIkBulDJME/tdAdMigR/aFIYHpuR0uV4PTZG66k3astXuD7LgvuXkNTaN1TSrjxtLEmgHvKJzQzSr8te/JnpraqZZzIlHZaj5w1aPxMnIFhdwjvDdmRCYOs6d7NZh5nGwLIriJW1VjyAd6b+ixJqGvL6XWdq+3hyA2iHQLdJ2uy/lUZss/yDIIBYpCVUoCtctEl3V8H7y2lQ52HdZaKx1QZO4VBLgGnrzyDZwVYcp8wioLJqq5ykKeMQT2pM3j2tcesdli3A6Txx4z9b13lUDtDrY2NhvcWC3YcIXmKwadfPMUllJRf7Q2qLqDiVDd5vhIb17GOVoIar3X2km0sjfHKkC+10woXditU1whkaZ77RiFrmyV4M5p0jkZRpzIBdUqBU6vF4UCccBQUJhUFnmLEP3A7bdEuChuteX7lhjYYMcJaiqVITuLttgY/ywT4sysG5cKIziqWeTH4t1phv/ZQffGV3WssBf+cWamdwcHEEuBzBDLFt3XcLY66ckVMVKm091wg6Pl6kT+2Q+Mts6wG89rhYGKznaJIAwy/f21LURJJa8oaYZTCiq0tRasrvr+56I4Bd2NsZtyTVlCRNnnD5yodD0mWwWxYYhlFKnpwkcEYTSAypZ5tH2X+67zOeTeyf5Rxy0G4rFfG0PMmzuDWssespusfUwF2Ehc4zWQACkCt+P5QZi5mL1rPxIi4TzijMHUWZ/2QWWFxWzJaoRuk2I6Ycc9yOs/MugR9lS0dHSVj5jhTIfpUuRZKAV2kRlKRtULjQu+WO6lK8ypnqCA6jgAWrfX0PpFBa4wJu7XJwD0/nhLOTytcWWzISaMN5NjERYwhJbTtQKTFhAJrYXk3bO3pmMjqA0lBTlYdvzfKefcBy3bApjbkMBFL0duQUrY7Bc9jpzUFaJqu66y2mSQzSmHRDaNgW221Iteq+L7L/ZGx6CwFtBJk1U7l8Syttw3vGbJGyN5ZG5OlhrDF8z07mcQE7cr8lrWH1jTCNONiZa0K+M3FeDIntp5XzscZYgjGYdPLaY2/XMh8VxrkX/zFX8Tf+Bt/4yUyi7/21/4afumXfunL/Mj/No87o5G7ZpD5llRWo+YWp5OKtHOiw5FFofakj5vVNjMUjllJxykUgHTBTmtMvGbtkcZu5TPbQudbBog0RXiBe807LpTpWYKhlELNjBu92HLnsYinbpLjg/V2y9fWeov53ON0xa4VnhhlzRQS6UClaIcKyeraknexIZlA1mgn4JkbKwDA1FMK+vxOBW80DiYW84paf0qkG1h3XFu6uuTPqVAbmyvLPTNSCZRKjClxC82AZRdZDkEb23hxjqMp1gbqaNX1VAR1addlOYbYBx1OHCpLG3FtddaCtwN19GtDxJTBBdnTUJV07mTG318BkDahwnBrTbpOa4hxc87gYEpODjtNuX67M48hRiqSayqW/RpUtcf5uSc2ufbZEk38Y2MCtKV7DSA7PHgu3BD7Nc/SDessOxfoDIK9ZW063+9hiNC+gvMWy82QP1uCMm0tWwPyuJvUJZA0DnVDOl6lFaqmFLNorTGbeQwsP5lMPDGBKWUQnMdaZTl1n7j1MKXcie0h5vHmps1aWY3iPiBNYSpjiPmykjIs2raGG1oMMZEjQh/hDQFpoxSeu7lGbU2WZtXi+QzKEoikwhmSWIk1nLBHRkv6UjHTLKBVtIcms3qVLRsMnbcuhU98PcYpSVkXnC1uEpbXHrG5E9ZJxqGzFLwLQLZa5w5kwpDXTuOw9nnDqlkbTG2dKeia1wb7teOiKDPSGNOaJFkT6cgFIMsvmoayJhV78XpvMZlY1M7kIrRpbbHf2CzPkkJICYK8KUzmkGJm5GMCZ54iFwTrnKEjdwGWRSjO2DHbLnpjWcYkfSzjULJ59D1SdsaRraTYRgJTS63Ou6E4BogMpXJ03oXJLsXMIaYcfDpH92lekZeuSFYAMEtaxrBIh+QeKkVFyRdnHt4obvxAALnxZqRhT1wcRoHJmptOWZ474gIiWbBppXm+0PtI4WBtqZh13BxHMgTVKFNJxYMkb+lDyt1iRbqjFIHVbiCrUlk/pZ23BNgyllISu8RS/HduarcYyIGzu/ceNLixaanRVh8wDATua6ux6iK6jvTOKVENkNOKwfSAti11Lt1A77lYdOi51Xf5G1nVSaMrcWCQNvWbELL+u4vU9XHC87+xBhPe22fcaOSk7VnaI3IYqh0YUrGnFCBvlc4+1c5QV0Ai5OieGcVSIg4spQiVxnoJ+ipbHDhqZv/dCCDL9Zf9u3LkvCM6dKWKoUEukufHxvdPSAIJAATAa0WkYd65XwUFfzkFesBdAuSU0kus3oCX2r/9UT7uvLAvZ49y5yEuE0ApFpE0V+N0fkzAsPy9ciZ78HpTBqd06powQG6cJsNyQ6kWpwsLBBSWWz7nhMGs5RSkLBTCQrZc3ABNgHkYIp6+sQI0AVzNCykUsXsX9hrSizJLWNeckOD0fl073vQoJV5VVDRhHaXLZQOJMeLm2QZDBKbOsMaPJudh47BbG04bliITpYh10YqCD88LhqS6K6MxMDAYAmn7lm3gVtIRlSlgSHNkWluVF82UyAuz7Us76Ptnk5yy7dhqZsJAKERqSe1Zi7ZkMBwisFd5Wux44ZUiQfk+4/EiG6bhjaHxXNRpNSpvsNcQc7Yz8ZxW1TiYVbSRuCK9kJ8PGtIKiyRBuqfJeLbOwlUEPESqIHozKQasHDHIIpvIXcu8Iy2qLgx1SqD38MTgKk0gWAC/SEWEFWmmdR6vxhpMJj6D7umsKsGC0djbq3O76OnUo2arO9EVL9nXdjLxZdNl8NyHlL9T4w1Wg3gB07/FZkAC+eRq0NiSoMXoIqvRqti9DRHYn3kshwFemwxUzzYDJtaSbIYZRcmq5kIuTZXz1NRC5w5akqqmqvviRmGYlVWKU5tGZ1kPsZf0AbU1XJmODMrjiFkRwCtAkeQVtNFKIxBrNKa+aIzF0i0xY+wdbaZW0XNrzy4eteM0KAXxB5XH1NNnTSqLvcZixzsK+r2BdzSetSIHBcsBvtRhAJSFsUZj0jjMGodGsmeexsrEE9C3mjrkzbzlOamzNRsBZMowiYQmJLJy00rAs85d3MaMZ8V2acL+W9Yl54YYEoxwIFLqRjAaX9t7x3aRMRU57VUUvI6lH1LMWXPDFPEn1opkZpkAMaLTJtePndpgM2x3IqudycwdrY+cEVFlT5rWDvfNJtTRcOQzO+NAVM6tdornHjWdAKSYlMbxkGJutDF1FLC0fcREgjBFIG/u3JbuVmosaksuMbnxCafnQwJurru8RlPRsspeyWl07bSSLEnxyJXi6IHBcWBP88OJy4HHGFQ/c2OF03ZACDF3pFWKZH/LLqLvA1vQIVu3hZDQtQPZZPLR8uvX6wHDEHGWfcu5uUkXsmVkzACZnDf6GHMRm2icpRBvLEPZ9R6rYcBZP2wFh9Yo7Ncury0Ta/L480bncdx40jOLrE+awnjDntqMQSQglEyX4/qKxpvsy1zzPBMZ15auXhG+2fQxz0lhugUoi4uKZIBkuhhNkg+RrsqY00pljAN8+Szxqx13JbH4gR/4Afylv/SX8LnPfQ5f//VfDwD4r//1v+JnfuZn8Bf+wl/4Cp7OH73jlW5W4w0U+0uK1+74qKw0FSkRU2NsHgxWK8xZs9zwpp8lFqBNUTYDWbRXnPKWhXUIJVU1rR1un24KAK7Ieuv2ghjkqmEQRieFelLj3E6N524sMyBrGpslGr721IxBEWNZ1T6nHskOzOaq0pQS1useQ4iYOQdnWpysezitcL6p8+IsmqggjCszPWQRp7fa/9aWikgSpEMfVTqTMbmCt5Y8NSGMD8hYntmJIaZsSC6yC2802d6BnACMU1gNZJklDLLTlGKUVGCICUdNlc9hSAmrYSAbOmaEoErh5jACScboXHjoOGjSijICuxOXi48OZp7YPWswm3l6vSWbNc0guqorTGrqSqZ0AeY5VV0RKCWZDNtyWQp6SFVDOlBhkI1jW63K5QCoqSwWi44AtxT7aI1mUjGDTC4SxujM3O/sVJmN0EZjOnVoPD13d7fKLKfWGke7DZ6/egYA9D0FjGgN78kHXGuynuuGwGyVhnNk3G+4yGxSWaz7CBhk8LRsA7Ml5PtaWY1FS5uNMLyStnSGwGyMCQ8eTfCFGwtMuGLeaDLon7POVZwAxmyd1tQhkxwDVE45y2YlmQ+jCjBXqri0tH3Mbiciu5DMUWU1JiyDGTM9gh1EOjAdaXdrT8Vzx2tKI1eW2jnr0d/ndZENVNZgvyHZCrHHFMDu8HynTdbgqKnwwmKDxlPzjoOJzelYXVPNxR67JFBbafMSb3axwpty1k0KYisurpr40qluXnHqmesYRLIEqOxeULFcjlxL5DrR/eijzGHp9mjynJZrZxlESde1bMOoSlOMrfX/DnA8Xo/Hv8/qshXzEgvvSMJUe4OZ1/ncRJsu3VYb1mc7p7FXU9GisL9jdwulijWXANnxMa807ttvcLvtcKvvWFYBTGvLNRwM0ExpZtTFQM06VGm2M0QiX8RSrXY6B3xjG8ypp26gXRSZBt3DxksxM2c4WIKVUsLxZsikjvcUvA1s4yaPj/cAkRHJvchyo1S8mJUqjjPjhhOXF2us+7gl01CKsnpXzjqEIXBGiyxUE1ii0Q9bdT7kYhHQtkR6LLtRC+We9M5SNEduS6T/Fhuz/NwgAYrGKibeayIigMOpx9UbGyz7IQf14qV9cdLgpKPs8ZTt8yISKl1cp2ruykduNEJSsYbc0N7TD7G4wgiJo2l9EAaZNMsm7/XjbrUSyE68wdlmgFGUqZNOpEIw0LqnS00Qf3/RUcv3s8xwjw9hob9Sx10xyD/zMz+Dv/N3/g7e+9734lu/9Vvxrd/6rXjve9+LH//xH8fP/MzPfMVO5o/i8Ur3Sqntjlt32jJNfLFsERatsqX9sVHUmKCyGhNOm4juEKCJJqbqsjm3zL7JpimMiTShGAZqJUz+tyQjWK57QJGFklIUvUJpzOZVZqSVUvCVL/ZgSmMyrbEzcdyhS2fGDwC7DHja1BOABKzXA+kOmTnfMAjYaxx2vaOUtZLWrdJ5sAANaRksm490wpIFgFpslorm2krXoZLW2WsMhhDzQheSFNTRJL223nDgovIGeXPVI3AjwZqDmjakvMCHlLAzcUipsEOrIWRrJ2H5xwVF1qjMjmSrJI7SuyGhaSwOGpuDnf3GUiGGNdiZVbRQOYv5rEIbCBjWNQGK8SYlbH7TOOw1jopNap8bTRCjS2BTa83SDpvvt2dgpbRC3VTsWUvBUV2bXFy4u1tnbbwUe8qieXQ4IcDBY2829TiaUhvoi4fTzOhAAQ+fm1KzEQD7syq3qyWgp3FzSUUz5/cnWHE3LaVpUyIdO4HzaWVxa0U6QZl1xy1tICKRmTcEMgSgWkMbhQBV0Qt+9vIZ2Q+a0vijjxHTynJhFn3exN9ZYU6BzboLmVWWOgcJGgXkySEgR9wpYkKWZUgGalIZ7In/NET/WuaB1aVYTjFD3HiD3drkpkKeAbCAk8bbrE21hqRde5VHxanXSWUx8eScIMzOvDLYn3o4TQHJbmNwyADaWY157TD1GueaKmfNvNNZ5iEFqCEleEfa+92Jz9KPujbYnXhMvWih6TNFuiKaWBk7whJbo7HqQs7sWCUuRXQtzej3xpV0sVZixaaY9YzZOlL+JRRd8XiTljVGjq2GLPx3sVeT5yolqWuSV8xYZlbzWi/2aFaTHpzuo8W5mcPcOQaphdGWsZmLsjVLeiCuOcSCrtqAibXoQmFdZf0UwFyxzWgEZdLEq9dzZmKIJHnIraj5sVUXyMISwF5DWQvR2QJE6Ow1oiEPGZAKS58ScLIhSQM4SPKOvLYHkQsysdANERNbCvoInBXPa/leRmvcXvdb/tNyz261XdYPyzpktcKOd+iGhDAEZpUV9uvS7IScNEImq4aY2KOZ2mJv2PoTAPo+sgSwOFUkMOucyLoxJHZ7SBFdDFmaaTQ5rwwhYW/icNYOWHcxu1ylBGgo3Lff5HbRe5XPf5NgRisKaOU9D6c2M8i11ZhY6hyo1HZwJ04vE28wr8nGr7EGE/Yv9yJzGYF8pzWmXBNlWU8tOmfZlxyTXRk05yBG5bVCgLL8PN4L7og/X9NxVwBZa40f+7EfwwsvvIDj42McHx/jhRdewI/92I/9kXew+N/yGA+2cdptCDEvNiKF0LyxiDuFUsBBTRsQpWcj+xzS+8SE3PWoZ2eGgRccWfgCbx5KKSw3ZI9jDNmvBWbINpsBYACSEqXhoDSOjqa4IYwzSKOcxfIKmM8rBgn0GTs7tBGGSKBsPvd5U08poetI/tCHxEwq6a36kLDrfU4tirYsFyGMJk9ubQtpYSqV/ciLNsAboVbY9T6nipQCDiYug2payFXu5qSUws1Vj4YXipgSIsgVY9VHRKS8iHT8PWRdyDptcGEG309v2OqIx0LFOmvLWlNryRSedLW0UbYhFrs8iN6T2sNaq3F+tybtujPYm5K22BiNpnGY1dyWmZ0XEt+3ycTh3IwK6arKUhCgCSDPG9LYCsjeq0licSdLPJn43EiimdSoKsvjVePC0TSzt9qUds5QwEPnZwiB9HyaweQ7L+1CKYW33r9DZvH8t7dcmqBnp5XKGay5IEVQ7o1lD+81vvbhPazX/VbjilU7ZFaj8RbXFrRZRdC9lFa5NW/GO43jTlSSSlRblmES/FxbtASkNTcd4fk1Y+bdKhrLjnWUOgMwGrubPrxEVpA3b1VSjeNDNjsy/A9ZF6uVwv4oEB3npMaFYVNvcG7qOEtAwGqPWUJpmnBQV1xESHURh1PaAKVByH5NYNVbAjVTTp9LxmunJr28UsC8puKv802dA8F9ri24OG9Yi03yHSpALkRATOBzIIeK2hErXNcOBzOPeWVYP66x15j8HYVdyp68o2u54cYq53aqzKgnvq5Wi5sHbb7iWJBBKQNLYcbk1gjoFQnY+JaNPWFf7iBLsrDFjhlNPtIVy1fmFXmrV1kGQ9fRM3NujMK0ttipbM4myD4CIIOyIZXCt54zbFIP4YzC1cUGlpnJ8SEBfkzkpCDBXBcjVtyYozQiiQzOibGcVAUgC/Ex9w4NZ+w6kbZYCtwm1uROo1orromg81h2hSluPLmYDKHoiY2la9ENMQNeYYWp+13alpo4jevLnls2j+aeVrlDoey3NLY0DuuKGN4QEbiA91xTk61oJOAcmUGn8UKd/4aegvK2L9c2sEeyjAMpKu8jgWYKhItvdR+p2DzxuOoGAtLP3lzjpA3YDCkX/qZErZyfvrVEx/KMaVU0+NLpUitg5ikrppTCUVNRYMhAde5t1jpL229ApJ5UUF+L7JPlGLPa5nVIslcxIYNcgNa3hokvaqmNLNvwLNeR+UMBqi6SNQbSNdcuyBgC/v/AIMvx0Y9+FB/4wAcyKF4ulxiG4Uu86r/345VvlkzSgbVQsui0o8VJNFqyeArYA4CDiWdje/2SBU0GpTDDiiev1jprrEpKijwdxTNZKYWuGzKzB6U5iibXDWiFnanH2arjzyAwNQwRDbOI5w4n7GEYOT1e55SRdD1rbBHWS7ejRd/namutFM66nid80SAnAFpTwYjRCm0fyIZmtCvVxuTFUSbawAuAbGC74vjAIFs0WRI8WFOs8pSixbl2Jd0HkHvFuqfFrLYqM4nEBNBzjtsug3CliHWhhiI6e09qVWQ1ntNVGfArklXU3rDW2WCnNrmSXcaRMQr3HzTElFmNo3mNioFp05A8Ql7jOJUtWuXDCRXP1bXN3rPGUmcyscJrGosZN4uo6gpVZdAGKpKbzwmY0fMcmoo8hbXReOTiPKfexc85gWx7DiYuF8FoTenkqytyW5EgY70e8rwQgHyy6rLTC0Dj9HTVwXuLp25usNmQ9EWKcRabYavr4/Gyy6xQSAmrIWSwBFBb8y3mwyhm4EvaMKWE2y2loq0pbIziz5WN7XRdWs2ShIne89aiy9pA8fscfWQG0Y6DU2K8Fb/3didIGeO7k8Iejy2PBCAbBlTnJj6Dj3mlsVdTlkNkBRemdda/7tQGe5VDzV3H5pXBvLJoHEmOdmqDqdPkGgLa6Hdqkx17dmuLw4ml9UqJxzg19Hj9xRlpkitinRqnMxEgbOzEEWg/nLpsC9d4KgKc+cKo7lV+S/YgEguFkrpVPI5CSri4V9Pc0pprCuhnEV5J8G31tg/1kGLRdY+ZYhSQs8UYq1fLJJKbgLQrdhJIapKyTLxB7UiSMLEGEytAogTGRrOshUGGBOBDStklRLonjqV82WqS71MfEk66Hl2I2R1DhlACyc4CA0x5nyGmnJmUtU8yb8KCTyuLIVFb6LYn79y5c1vFaEpRq3LSkNvM0CteF2XtpA5wigEyBU4ir8j1Ld6gHQJW7EWcIrHA4rwic0OKSU83ATsVBYjjRlnLjmwUQ6B9MyUiqfa5xkGKAo1WuDiv834xDDTfaczROhtDROT9vQ9jgMwgmzMvMZF8r2PWetvLnwCvWPdRoE737YXlCsuWvNGleF3x/X72bIWW3TBkfYqJbEsTJINBnRGVAi5NanhdnFykhiAl5LbjALAzcWRzyWuPZ/u5XDPliluWWMhKAAkUv3GjFXa4FkEplb3h5b5rVZrujJ1fvC4ytfG4/goSyHcHkK9evYqv+7qvw9d+7dfi3e9+N65evQoA+JEf+RH86I/+6FfwdP5oHbRBpVf8u4Cxnq145CbLBBFwnPVbqqT4AODCbp3ZxyEQG5Y3xURpfqUUhiEUgKbV1sapNaWhW2kXyiyQpLIlRdlyVz6xebt9usFq1SOwfgwJaNsBR3PSKr/pvl0cL7useXvXo/s5lWSdxUPnZxRh8qmEQF2FTrueJjAv2otuyJu/PA7QwhESUGlqtCLgUiJiAb0RyJHywCnzgTdD8WIkIEKfJUxeTAkzXxhuSWfNcktsmoarPmLV07XxxnDDBmQ3DKUUTruhfI4iprEyBI6bUetdiYxFSiPNZbIeMhd1GtQizWBGqw9kdXX/HjlGOGfwwH6Fndpk4CvyAc3MdUyA9xbz2lGqy5BlUeN1LoxrvEUEAeSdqceM/9Y0tBFR21yNw70mN1KZzz15IPP4ev0Re2kbGms8PAEA1846DNL9isH+f3n6FADwhWtLMu5fEwP/qStr9D1tSsenG6zaIV+TzWbA2bpH7Q2efOEYm02P28uOx2XA2brH3tQjxoTFpsfJqiNdZQQ2fcKiDRkMxZRwe9GNtHMEkB9kv1fR/QHAWddzVypJ3xIwO2Pzf6vJsvF41SM74fA+fLYZcsq35/k+BlfEmpCtW0gEUBJSZvMSrxXjYs9uiDjl6xVHS4/Mm8oS03q+qXO6cre2OGCPacpcKTx0bsIWUSTnOag9FQQ7en3jyeWjsuR/XFvSFSo+57mzWLXEbu81VAB0z35NmmWrcWHqsFMZ3Fx0cEZjVjnSz3qSEkhXUa1KAdQ5tohLSGi8xYWZw4RTwUYrXGQbQNFlj1PpIlWigJrA1+euLHKaVjpcSuGT3CoF5HtKTWWKN+udh1Kl4G2LQR6tFy99Df1tOZDevbbEoFtm76ee09iOtMVTZ7N7RW11tqKUVuCbIWA1DHmfkKxJ11NGrOVC4Y5ZSsGECgqrPuKs67EcBoS4ndWMCRnMAmAAlzCwV698T9F39zHla77LEjPJrBlNhWMJgPjTa1BAUDEr3vGeqHWp+6AsaMz7mHdUizG2YK1rKhDu+pilG8NAxXGynrfsQCQs9KINONdUdO4MehWoZqW2RChJLwGrFQ6mbkt+4ozGIxemvM+Q1VxKKdsfCkiPdxBhiuelFOaRjzLt9+RmUqwCGwazUhszBvp9SLi+6rDsIre3NtlecNMHPH/c4YxtIUmeRXuQz+SMOIrQNb7vcJILZiujM+scM9BlSaEzW3a30lnSGb5mRsikwppbQ623hQGWzJeQKymlLIWSjJRkpawZsc/MRE+r0ulRRuuX61TxasddAeS/9bf+Fi5evIibN29iMpnkx7/3e78Xv/7rv/4VO5k/asedhXd3Hn2IbGnEvoyc2if/3IgNd0KSCnyJ9gQg3152uVWopP3yxAFFe8IwyiKtefACvGEYYvV6jswNFzZJ8QFAi1TfUVS82PSAUjg+3rChOssWhgFtG/D6I3IluHx7jdN1l8HkWRuwbgdKL2uF73zkAItRpa8UtJ1uAi0UzJKtucuVMI7S7Ur0dGR4H1GbMokloSmy7oOZ50iWPa0j2a9R1Ipc1HOTdalyfXZqw+xxKXpoXLHQ0qDAZNMTsCGruW1XAQ2gDfSdcvFE5GIqpzF1JoMrSjOVqNqNNtvG2+y6UXPUrBRdS9nwjFFYcQGItRrnZ+QaIOySFHHK4gSQVyc5Yqgso6itym2ZpXLfGHLL8KyDnUw8apEwaIWHz89IBqOpSG5aF4nC9WWPEBKcpNyE/gTIvYSZYaUU1t2AF2+R5d+N0w1CiGjZn/v5m0tKU8aExaJH1wXsTHwOzpbrHpUzuHVrjbYNuHmyQQgBbTtgtekpHRmIfT5d9QQ0OZBc9WVjTAm4vem2Uq5KKVw92ZBf7lDG7bKLuW24mNlXRmPVhswo9iFiwS1jpQA0xFLIKWBm4H+57kAVXae0XQVKoJhSYusnlcH1zQUx65u+uACUeUFp5v3G5nR44w1mlcZBQwC58RYTR0GnY33x0dRhr/JoPBXS7XiX7SUbp7Ffe9Kt8poh7gUS2AsAp45lxHoeNRUmzuJ01aNyGrsN6ZxnXmfGWLSUOzWl4qfOZvvGxpNlHLkkFP/WOMoY3WnNqUEFRZKWvr3qYBQ3aIp0T8cd3ETKIlKurON9BdJDmGzZ1OUYt5t+6WtojchZJatzdmkihXmGCp9EC2p5DRdbyWUbYa3Cbk1s6LIfiAhIMetVO86QiLa4G2K2tRM2ctmRT/yqH+g6svQkJWlJnXKgJintEJGDC8XBf0jI11PiiJjI+q2NxGQTaKY1XloRO6O5sJrWZxnrNs8H2lNlLxtCxG5lcoYLAGazCk1lswNESim3nxaniAWTPUIarbsBD+5PiWRiPTOBwYip1wghoOYiVWdJwy4SJ3nsc1cWmFakeRamuLLF7z2EgBhjlkjmeSlgWitEpHKdAj1WcSb0cOaz3GIzhHy9ASrou7kc2CWJXDYiNyVq+4Dryx6LloL6lufokCKTApyhNKURzWIz5CxmZQx22B5Uxo0ci82ASheJrTfkzWyNyllwBemIFzPR0A3kwuO4HiLjDP5fagisKZ0f5Xep2xp7tVtTJHtf6eOuAPJ/+k//CT/5kz+J/f39rccfeeQRPPvss3f1Qf/kn/wTvO1tb8POzg52dnbwDd/wDfjVX/3V/PeUEn7iJ34C99xzD5qmwR//438cn/70p7feo21b/M2/+TdxdHSE6XSK7/me78Hzzz+/9Zzbt2/j+7//+7G7u4vd3V18//d/P46Pj+/qHL/SxxDLUjqeFP1AzghS7StpKYnwQiQ2lQzzxcGhAGNhmU7XtJAJuLyT1GgFWPMCZLXK8hhK7enM6kWOzMnHGHkyEwjTnDYSJwxN7HGI1OUMQBjI8uaZ2+R68fz1BTabIWuSP/7MCdo+YIeLGT5+5ZQm0WhQi1cxUL6rMOm5wQp/npidO5ZFiB+sLHyS3k4pZTYzpUQFI4EM56Xa3zFoPGtD3gxiAia5iI+uFQBUVuViQAGnfUwZ0Ey4jbIzzGIxw0vpqjKpKy52arjaObfYVOJWgOxHDCADi5j4u/I1kzQo+aGyk4MiuYUcWqvcQtYyMEqgBclxAZRhsC3dy7QubYWFGb5nr86b/2TichGp1hr/w8N7GRzMasfaQHLMEMcHyRiEkT77eNGh7yPCQAB5sRlwsugoGFuQsX7fERt763SDwJvDZtOjbQecm3vEGNG2AZvNQMb7yw5912Ox6JAi+ZKu1wMB7iHgdNVn0E0WUTQeZMwNiVLNsrlJKvr6aUsMZAh54dyM5rEEsN5q3ohKxqftI3euok1mSLQGyH2ICWwdl3KaXu67rA+kqySwHnmcko9p0YxSUJ2wasOWRETYodpp7FYuW8VNK9IPH86L5ri2CreXHRVZsbyi8cQWTZzGjqf0eGUMJl5j17vcMEXA5MTa7Ok6cxYzb3G67nnT1TioPSpDtRPeKBxMLPYbx77JBMQbTxvixJUOpE4TQPWOgHptTC62PW677GgxBrF37ptyr846csrZmbgMnhprClCJRV4lWbpi96de8t6ywWtVgnOZc69AIANADr6tEi9hCjwm/P2NpqBj4oo7QAJ5GU8ralGttULjNFZ9xLKLeV2Q9aMbqKZD5CVt4KK7fO7ErG+GiE1gyZgR3WnxFxYWuWUJRURhlZFkH6JrF/laj2s/xLJwf+qzrjamwu5vAjG/Q26YwhZ6fK0Ds7kUTAcqhh4xvEcHTS6QFf/gGCL6PuLWigIH0THLftZxodwQqRNf3wcOIBK8MUgxoeb6DaNVLk4XByhvKWPUDcXxQiliuNdDyHuwSBiFH5BAF3wvx9lL8pHWJBUEskY3gvZAua8SlJy1IWdGJrZoi9uOsmcLYZBDzLKNBWe5tKLiXTmOlx35szMjPK2oiZjoo5Wi8bfYkGOGFMhJJkfcJ2ScyniQuSmZNpFYyL2ULJjsrbT3UqZY9Me5z4MuWTORjfxvcdwVQF6v1/Dev+Tx69evo67ru/qg++67Dz/90z+Nj33sY/joRz+Kb/3Wb8Wf+TN/Bp/4xCcAkFPGP/gH/wDvfe978Tu/8zs4f/48vuM7vgNnZ2f5PX74h38Yv/zLv4x/82/+DT784Q/j9PQU3/3d340QCqPz7ne/Gx/72MfwgQ98AL/2a7+Gj33sY/j+7//+uzrHr/QxhJglBFI0AJSCMZJPUMQtIFcAcR8SV6jGnK4oAJne87Tt80Ie47YljOLPF02xpFM1L9ZaU7rUciEVIPIKsN4qZScFpVWOitecCu/ajrWjvPj1AwFkbvhxctJisykp8Ou3Vui6gMfO1Ygx4fHLS2KpsV1YuOEFXBaKLlCg0DGA37BcRECEt2M/2MIgp4TMki42Q55YwkZ1IVHaG7Q4OcMLJ18/rUZtL3kyapSW1I4j7ITSqW+Ikbq5QeXOQ94Wprt25CsJADNnMXUGM+cyMyCHBDPSdlusxcRuaiJ6OTlPPmtjFMlqIM4NCWf9QLKHxmXLLGEctSJrqN2aii2sLY1npDNXAgUYWit89T2zAqQrKsLwlgDy1WWbwT+lhk1e/C/MHIYhkl1UFB0xj+HTFn3Xc/pRYbXqsFyStn216tH3IYPi09M2/9xuegxD5MAooe96tG3Act1js6bnrVYdbXgdGfffPGsRQsBi0XG3K5o33RCyR7WMvUU/ZAAhAcjxpodRtIkLaJI5LPNbgUDmhu3/aDNCruqPkec1ZzFkM00MPLpIrX0HBpsTb3C27vOaIWBCNlk6R/58XmdipFRoTNsCL6PImYF8uWkszBuHymicZweKWUUAdd0FWEMFeId1lZsT1Y4KrEQrOPWGini4Nb1mOYK4TThNgLrxBkuWsXh2vyCnGbKtOppa7FcODbvYiLOG+K5SIBpzoOoNvS+BdvZ55/XQj4rzxgWOSlEAIezkihs/HM58bjM97rQ3brQh52AVF1vqovMEigwLQF5vx8crSSxyNzAOpsVzdre2WVoibj2V0ZjXJdiXjnbtIPIgxZIvYmFHnAxCTNm1gMZ8ceKQ79cxcSDtroV9XnahED28JneRgsTEgZ1cMwncRIayGSKOeT6LTZxWlFVxlhqCaFXcP5YdMeB9LAWy2YlCrrMRUDXg1oraSQsB8PCFOaTZjFynoR/QdQNuLUnnveLsCnW367HpAz5/6yyDaWk1LSA9hJDlbgB5MdNFQyYVzroBp+s+A2HN+thlP8BqklggUUMcoNSnyHvWlltN8+9ZhsfFgzfO2kz4tKF0QJS1fNGGrG2uDXmwG021RIvNwEEB3QOtaH1ZtUXiNR6dJ12PvQnXHGiyvVxztlcKOgGSb9hR/ZN0z5OmR/J8WT+lHkjWPMe2iwBeCpCV1A7Q/RdGW5qV0ZjRo+er7NjzlTzuCiB/8zd/M/7Fv/gX+XelFEII+Omf/ml827d921190J/+038af+pP/Sk8+uijeOyxx/CTP/mTmM/n+MhHPoKUEv7hP/yH+PEf/3H82T/7Z/GWt7wF//Jf/kucnZ3hX//rfw0AODk5wT//5/8cf//v/318x3d8B97+9rfjl37pl/CJT3wC//E//kcAwOOPP45f+7Vfw8///M/jXe96F77hG74B/+yf/TP8h//wH/Dkk09+mZfmtR8SNaWELJUAkCO5ECKnHkqqSRZlklsUoCgpPoDeUAFYDwGBF3Kx4JH9QLQ/0qDBsaZHJBTSIMBazaBZZdZRMRNoDDVg0EYjRYocpeAvDGWRAZAtb24viUFerYgZdBwhLhYd2jbgrUe7iCHi+ukmG9WDWVqtwAt34iYfQBcSzrqBdZ4KmxCyvlBS0OJqkEbXICJlF4/TdZ+Zn/2J5Q2CFkelxO2j+EzK9Vt2AsZLkYh0JyKdYKl8DolSXTNms+YVpX2rPIlLEZ9WwMyRdZ2wX+NpLRtv5UyOjrUuXpHzyrAzCdvaoETV9Fl0z/tACyd15LOZyaaonLuiWTF3t5AmEdJ4QN7voKG/3TedZJP2ii25LK9kX7y54fS3WIWpzFrGRH6fzuoRQKYFc7nsMPQDYqRswmpVTPY3m4HYZQ6AKWvBusKedIWXT9q8CQ5DwGrVY+gGhIGkFSmmHLwtFh1iiNhshtwBKyYCrHLvh0hpykUbEBKnaDlgPe16KCh0IeQumYHt3tahgH6lkAGXYsFPH2IO6qSzI3W3KptTiGLbRlZxWpFOfs3M0Ia/u1j0AWAglF7C0vW8uYveGeAMh9OYOIuExACYgO/Jiopj5xV3MotUGHQwsbnBg1EkQSA3D7CfsuY2xjoXx4k8SHGAMHM2s0oxplxoR23hCRwc1B5z71BzGnXqqfjPc/EjrQWRO2xxK/ix1Ahq1PxF5eYEWQfJ1+B4RUVoCiQNsFpldmyEpdnJRkBMsdSzo+84xrwp3eFKNH6zVzlkXRFnE8/Bxf6Evr8E/9IUYVxoCgBzZ7OedogJ645ArgAUrRgkhgirgCHymOdCPGGZaU+nx6hAj+a4OKXIuUqmQwCsfHe5ZuMsZ0zAahiwaIvcQr7v7WXP3c/Y35413puBbN9CLNew5/S8bH+G15m2DSyVSiS1AnD59oq6CMZCdohsYtH28JZbYScqDF5uevRDxJVlm+UYfcfrTiSAnyI3Ikkk8TjuusJeavKwbgN1yMtrgCZ3h1PW4cv65tnOT85Nrn/tdJH08PyXrphUlNzDcgaqz9ld5LbXknmmsQcgAQYKXRex7obMLkvQmgAs+iH77gO0txEAD5g3DvPawmnqeteNsEsujA5F4rjpQ84CiAY537vRGBm7hRj+3jI+81xWGP1M91rsVUun4PLzmFn+CuPju/dBft/73ofv+I7vQNu2+NEf/VG8+c1vxn/5L/8FP/VTP/Vlf2gIAf/23/5bLBYLvOtd78JTTz2FK1eu4Du/8zvzc5qmwTd/8zfjt37rtwAAv/u7v4u+77eec//99+NNb3pTfs5HPvIRzGYzvOtd78rP+cZv/EZMp9P8nJc7fv7nfx7vfOc78c53vhNXrlzGrZs3cO3qZVx+8QUcH9/GM099Aev1Gp994jOIMeKTv/+xl3+j0d1JKeHalRfRdx26vsMLzz2D09MzfO7JJ9B1Pb74xKcwxITPP/77SAn4/Gd+DzEBz3z+cXRdh2vPP4Xl4gwnN17E4vgmlic3cHbzMjarBS4/90XE0KG//hRSSrj93OMIKeH+9nlopTBVPbRKeFTfwrlJwtfsd7i/6fFg1eIdFxIemEd8zXyNfR/xnfd2cM7gzz5M//9fHtzAGIP/25sivFP4tkstjmYW3/KQxn3TiNdPNnjn/R6P7CZ87fkBu2bAn/kqD6ci/uwjPdbrHn/tXVN0bY//8YE1+iHi//pVFqrv8PWHG/zHJ5/FO84POEwLeBUwdwkP7Ft86/0RjY54IFwlMPL8EwCAvZNncNr18LefgUXCcOt5aESk0EFvzrA4vo7NyTXEzSmOrz6Hvtsg3nwWKgG4/kUAwNNPfgLeKLzdX8elmcPX7pxBhw7XLj+DHWxwlE6xH8+wG1f4qukKe3bA10zOcLJu8c76Fiqn8Y3Tm1Rte/IMnNX4muYWZi7iEXMbM7Q4F4+RlscIq2Pcp8+wr3u8Tt/C1ATUJ89DKYXdk2dJf7l4FrPKorr9DLyOCB1pZZ979mksT2/jxrUrOIpnuOg6VMtrmKgBX+VuwSjgsXQZh1OL+tbTAIC57oGU8Ji+gV0fcU+6jUO7wZvmHab9CdL6DG8/6HDgBtwXb8CphCmoQO3/OL8FYxQe7F7AzFl82/kVZi5hsryGc1XAO88HnNdrvK7e4I8d9PjMlSuozq5i5oCvn5/CWY03xBehlMLr+hcwrQy+7WgBkyLuDTcw1z2+6X6FZ164htfPe5yLp3hwB/jaow4aCeemCpvVBt//FloEf+CrDTabHv/jAxtoBfyJ+zrMdI9veVDjdfsab97p8LbzCm84Z/CuexL2XcB94ToqA/z5N1Nh6f/5HtIp/4Wv1ui7Hn/+bQ61GvBNF3rsqg5feynhwabDw9MeUxthEPF6ewwVe5y8+Hn0MeHR8AJZ9137PGIC7uleRBwC+pvPoWuXwOk17GGNS2aJnf4Ypl9hdeMFdO0a8dazaPsBmyufhQKwevFJsox67gl4rXF65YtYrVZob72IfnWK5e2r2JzewLA6wXByBd1mhavPfh79MKC79gVMKounn/h9JH4vALj9/GcRhw6rm88ibJbY3L6KxekNqPUJFjcvo10vcP35p9B3HTabFZCAK1/4FKzWuGf9HBUOXvk8Ggu8Tt2CGVo898zTOMAaF8wS0/YY/foUj9hTHNiI0ytfhNNAdetpkl889zixsZc/h4lVOL3yRSC0OL76LFSKSKFHe3YD7eIYdnEdJra4+cIX0Pc9rj3zBKxRuP70p2E0/V87jenpC3AIcGdXUMUNHrRn2I8r7MQF7PImZmoDc3oZOg6IN56GVsCtZz8DBeDG0yTFc7eeAWLA0194ErFbY33rRbSLY6TQI4Ue/foUzz/7FNp2DX37OfQhoLr1NG6cdXA3noLRCtee/gxiTLj6zOewXq+xvPk80C6wOr6K9el1hPUJ4slV9Jslji8/hRgGLJcLJABPfOrjAIBPfPx34YzCE5/5JLq2xVNf+BzOTk/xwvPP4sb1a7hx/RpeeP5ZnJ2e4vTqM7ApADefoaD/+hfgrcK5s+cw9xb3tC+i1hHx9nMI3QpXX3wWXdcjDD2m3QnmqcVD5gRzG3C4voJ2CLi3fYGcKK5+DlopvKO6jhQj9tdX4GOHx/wZ6mEFu7pF1yYOuF8fo44dLvbXEcOAe9rLmFYWpy88QfKgG1+gNsHHz2Hoe6TjF2CHDZrNLYTVbbRnt3DjyvPYrBbQJ5cRhg7n1i9iNQQ8/7lPQCkav05r3Nu+iNPlBs984bNI3QZucR3n7BqHWMCvbqNfLrDX3sDMBHz7pRZdP2CmiSn+P9TXYYzG930VBclvsjcxMxFft7fG6w4Mdje3cV4tcNG1SKdXcVgnfM8bLXQc8DZ7A7XVeGR4ASkBf/7RHpsu4OvnJzg+2+Dt8xUuTRPecW7AfX6DQ7WEWtzAxUnEW6pTNCbizeYGbq56vM1cgVIK737DgItzj+H6F3HWbvDt9w24ONf4pvsU7vMtsLyNc+kUD+8pfPsjFkeNwtsnJ0ACJiAm+rsvLclm7ern0IeIsytfhAk93OIa+tUp7OoWbl2/CtWeolrewNCucHrlKSAGXH36CYQIfLW9iiFGPBpepOBo2ABI+PrDDaZocT4dY9IvMCxvozu5itQusbrxHDabDe7tL5Nc6+rnSaZ47fN44dYaz33+M0AMePHpz2O1XOD0xgtYn93G4vZ1rG5fxXpxguXNF7Ber/G5Jz8DrRJuPvs4aqfxhcd/HwDwxKd+DylFXHnmcwjdBrevPofF2TFuXLuM9uwGFqe3sbj5IpbLBa48+3kgBdx49kkoRfNJa4Wnn/wEtFZ48aknEHqaT5vlGc5uvogb16/h+PYN3LjyPFIM2GzW6NoWT3zmk3kujv//zCd/H8Mw4POffeIV8eD4uCuA/OY3vxmf/OQn8a53vQvf+Z3fic1mg+/93u/Fxz/+cTzyyCN39UEAtaaezWaoqgp/9a/+Vfz7f//v8da3vhVXrlwBAFy4cGHr+RcuXMh/u3LlCowxODo6etXnnDt3biudpZTC+fPn83Ne7vgrf+Wv4KMf/Sg++tGP4uLFSzg4PML5C5dw6Z57sbe3jwcffgRN0+CxN74ZWmu89Y+9/eWp/Ds+d+fwIox1MNbh4MJ9cPUED7zu9YA2uOeRN2MICfc9+lYoBTz65q9GSgkXH3oDPf/Sg7D1FJP9S5juHuLw6Dzq3QuYzXdw8f7XwbkK3f79VOF66Q1ICbjc3A+jFdagoquncIhFcnhyM8WJmuDMzfGZU4+rncNnuzlsVePDtybQxuL/9UKDyhn8z8/U0Ebj//kFD19ZfKLdx0mn8MFnIi5vLD67rPDxywFP3gj47WsWt3uD//XxHusu4t89QW4Y//ePrNB3Pf7d5x0Wmx7/7lM9jpcDPvSCwWduRfzWswGfvg6seoVFr/DCacJvXraIxuGz6Ry6kKDO07i6Mrkfy37A7dl9qJ1Dv3MJShs0TQPV7KDeOUKzdwE7ewfYOX8/lPNwRw9Ba4W9+94IDeDCw18FZzR+P1zATuXwW8czLAaN1eQIK92ga/ZxW89xM9V4fDXFMnl8utvFolP45HAOjbf4yIrG3fXpA6isxudxAcZ6PBX3sdY1Xog7ODUzNDsHuKJ2cXHvEC+oQ9R1hdXufbAKUOcfhVEKp3sPYqexmFx8PaZNBVc1UErj3MX70cz3sX90AbftDmI9hdq5iFY5fLo/gDEan1WXcGle4fbOA1AAzqKD0grPmfNYBItFc4TWTPG5dY2h2cNCT/CJ0xpr5fE0DjFAY5GoCvv/szkHrTVuzek7fejmDEFZHF54GLeDwyeOPU7NDG+6/wF86qTCsysDd3AvVkHhd1ekOf6MugdKKfxOew4HjcGvX51g0SV8NhxgmRw+/GzEx68M+P2rwO9e1/jCjQH/6Yukk722iFivWrzvt9dAAv7lJ4GuC/jXTxokKPzPjw+4uYz44NMRTx0n/M4LAR97oceT1wM+9FSP62uFD9+osekTfunjHWJMeP8TFmEIeN/vUKer939sg5NVwG88DTx3EvFfnhnwqWsRT9xSOOsVuqjwieUM62hx/sE3oAsRn0qX0A0J7cHDAIAv6otYR+B2cx4b5bGoD7GyExybOY7tLla6Qdy5AO1qqIP70Q4Azj2CBGB67xvIxuzSY/BWozn3MJL2wO5FoJpjtn8B9c4RJjv7SPPzGGyFybkHkZRGdYHmwPmHv4rYnXP0+32PvAnKelQH9yP5CfrpIUK1i1jvoNm/iMl0jp0LD8A6D19PkADc8+hbYBSwPqTvtHPPY4A28Ef3wVYNZkf3YGWnsLN92Pk51NNdXNb72J3OcOGB11N7+nOPoPEaD73hbQCA/fvfiMZZPPDIG1DVDe578HVQ2sBYj73DC5jvHcDvXcLuzhwX7n8U2lgc3P8GOKOwf/+bYZTCpUfegtoq3PvwG1H5Cv7gPkTXQO0cYX//HMx0D8duH2epwnJCc2528VFoBTz42Nsom3HpMQDAyfw+aGNx4f5HEWyNycE9OH/uCNo4aOPgmh34vXswaAdz+CBJ245eh2U7YH3wEOmR730DlFLYu+d10K7C7Oh+BD+Fn5+Dnh1gtnuA2eG9qJopDu99HYyxmE5nSCnhj33NOwEAb/uad8Aajde/8S3wVYWHH3k95js7uPe+B3B07jyOzp3Hvfc9gPnODnYvPgRlLfbveT0UgNm9byR51oXXY2INnnOX0HgPf/gAfD3F/Q88BGUstHW4pXdwdHCAz3c7OO01noyH6ELCZ9UlbEJAdfH1WHUBH92cQ4jAzfoiltHiic0Mp2iw8HtIxsIYiytqH6fJ4mkcIimDG9N7Sa9+35tIinH0CIzS6PfvR5sMNrOL0NUEXXMIM9lHNT/A/Oge2GqKtHsJMA4v+ktoQ8D0njeSU8E9j6EyBlebe3HSR+xdehjJVXB7F7E2M1weJrim5jhVNW64Q3TK4TderLDuI04Hanf9se48jFb4pU8ltF3Eh29PcTZoVEeX8MVbAR95NuCT1zWeXzss6gNcXwH/0++vsNoEfOj2HLXVeFLfg5QS/h+/T3rj/3x9ghst8LGzCZ652ePDT3X4/KnF1dDgtt3D8ycR/+8vAste4beXuzheBzzt7oVSCv/TUxUeO2qw3L0fi5Dw688aXDmL+O1rBm62i6tphhfTHF+8FfHBpxN0VeOT3T4xuMkjpYRfuz4nqdgRrRn3v+4NWCeLg/MPwE12sGn2YaYH8NM9bCZHGGyF8/c/AmMtHn7DWxBTwm8tD5ES8JS7lwoobY2QgA8+b3BlpfFMP8PCzuBm+9g/fw+Sn2A9Ow8Yh+sNXY/28GFic48ewe1lh9e98S1wzmJ+4SG4aoKdo3vhJrs4f+EiZgcX4Cc7uO+Bh+GqGvc89AZYY3DPI1+Fyhnc/xitEQ899lYACpceej2Mr/Hoo49iOt/D7uFFNLvnsLt3gMnBPfD1FA+87jHU3uHcg28EALz1j72d5jmvN/e97o2o6jrPp3MX78PRufM4d+48HnzoIRhj4asavqrwxje/Nc/F8f9vfusfg7UWjz72xlfEg+PjS7aa7vse3/RN34Rf/MVfxN/9u3/3rt70lY43vOEN+L3f+z0cHx/jl3/5l/Ge97wHH/rQh/Lf79RpjSs1X+m48zkv9/y7eZ8v5zOAUkT2akeMRTc1xAQTi1hdNMMqlUKPcRpJ0hBjIC5Si4GF8qLzEr9Io5ErP0krW3SljadiHGtJNuGtwcwbWGtgHT1eSzcdI8+zOJhVMKa0pZWiPaCkyxRrBETTCVBaK8aUtUvUXSjhZNlxV6EhF0qA36NiHWM7UKGGUlSUsBoC2kH0xsU+iNruktZTpB6JJRai7QOQU5daAQtOFw6xeN/WTiMsS4tnZ0ljvBmole6kslhs+lwoKWkvb1kfrKlIasOpequBBw4bOEOFM+K/3FiTz21ek6F/xS4WUtAiY0UrqkaW9Ffi760UcFh7HG96QJdUnXhGziuDM7HsE22WAtZdHI0p5IIyOXKql4syRIPsjTQwIdmB1+Zl55JS5EwQQsJy02PZDrk45fiYiuPOzlrEGFlSwSk41h8DlJYc+gGONa5hCEgm5fEh+mOtdbZS6jox84/ZMinGCAOTnxNCYC/UlNOoxmges8iFrpVoNJN0sioFdKTrjdgEqoY3ijxCxXGi588HwFXm5Vo33mBIEd46LLuQ099Zhwhkx5KBWwSHlOCU5nWC15CU0Ci+1/z6lKhZg5NCKUghzABvkbNakq4UuzLwHDqoKoRUtM1TL21muQmFc3l8GIUtA3/SIZNX72IzwBuNXtYpXiucUZhWJle1S8U+UDSUlaHGAserPrfTntTUjOTWpitpe5RCPbluALabBABba+KksmjlCwBY9wFDSpiOGlyJt6tov0W/S64kdIjkS5oyfSmHIhqT6UtKLRTIXUOuqehONyFQKjwhF/7KIeNqCIm7V9JjizZkmUQXKWW9bAd+DdV3bL9PSXqKnhgQHfm2jlQ050ZJMVlEYx15MPPYEnlgWbOQbee8ljnAuuaBtLExgaz62EO5GxLaQXTJ9Nxxml5kXzSvE7svAU9e39C9XHdoG4emsdiwlILmPhXe1VzICAChL62iV6KxDaXmISWS3cVAgfxk4tENEWdtwLmZzXvhn37rvfgXv/N0lvWIPBGgsSVFjkorHMwqLDey9/E8NBqWZUEhJRzOPYZIFn25JimmLKUTmYN4A9NYiPCamm70MQKWux+GiIE9kFPi5hy8r8g6JUXbYhigQHr+m2dd1isDRfIi/uBAwryxWIhdpS6Fc/L9xprlLD9BqblppaFLfv9x51C9JUFLKMWxYwlgkZVuDe98fV8L9vuSDLJzDk899dRr+hA5vPd49NFH8c53vhM/9VM/ha/+6q/Gz/7sz+LixYsA8BKW99q1a5lVvnjxIkIIuHHjxqs+59q1a1ugMqWE69evv4Sd/nKOl1sMZdC80pHSuKEAsg1U4JEqHdtk0svlHYNxea1S3DQBXDgx0uZIJbGCyh6EAsK8kRbF1CSiceSPW3GB1bSiIj3nDPnkcjGWcQbeG0xri9cdNTCWdMiOi/pEo0yduEwGzHLO4oKRUum8I5rl5WZggBy2FgkAuRGDVFJbBlhrttKqnEZgzZbYY236mP8noJkyOBa9rbNkYK6Vwm32iB1CZD9GYOo0QuQOXIY2K2+os1DlNPbZxzMmWnQq9oi0DD4bTxtZO5AFj3g0i52aaPpkozO86GjWYMkK0GfNI/0/cXQvZTxo1iouuSMT74z0Pqz1ri19F9GgS9voZUeLpPjn3pkAkc92hgq0jKICvonXeOLGGbRWWybx8l41FyFKW9FhiFiwjZphsd1i0XHRHIFh6ijF1e4djQf5zrI5KaWyuT5p5nXWH2tTCj2kSFTeT3xMy3ikDVIAdIqJP4P/jqL/F62xLOxScS81AVQANeRuj94W7VtI5bq2o6LhhISdmkz2s13bGNApsMMHgwHWM8vfVtwUgK55ytp00dkOiRrshFRsleS98joCcVZQGfB3XMB70Pi8ljitsq9w5dhejMcVEq0pAp4Vv2dt2AVlBHpTonXKGxr/u5Pyd2nYIYflIKzmsW4VFePsVQ57U4+GK/IVSpGs6NplbekjdbKUjTvla1V2TvnE1UB6Y2kLH1LCsicQ6bTOIEf0tPzVOaikcV45qQEo3+PldoNw5yR7hYMCU25WZDVqS3NcNNUzX0AwUOZuG8jzWub6qh1yYVnH6+e6C4hgvX9X2vHeeWzppxX5pMuaKqCptibXXYSUUJvi2SyOPvJ6mTddIB2vBD6NJ1uv9RAyeVIZk+sXxDIRKEFjCMX/244CPKmBUUrhyjE3F2rFoYbAaUoJiCHrkC3XgKREpI28/5qt39JA9Qt0nblHQYzoNiSHaHvSGj+81+R797988gWcbAJON0UDb4zC6SagCyk7PRlj8Oi5hmox8t6ucp2OWOgt+VxmtUXPwbIE0+KwIkXWSpW1WO7jkBKDUPpu0mVQrttOQ4XhUmxsFf2tjzFbcx63PVlT8n1ValQcDOR9qXbFhUkIJvCYES28BMJ3HqRvLx0DFUph6BhMl6CogOExGJdAalxrIOdwFzzmqx53JbF4z3veg/e9732v7ZNe5iB7phYPP/wwLl68iN/4jd/If9tsNvjwhz+c9cTveMc74Jzbes7zzz+Pxx9/PD/nG77hG7BYLPCRj3wkP+cjH/kIlsvlli75yz1eji2+KwaZBzYt2IWpAgr4TUBePORxGQQJwvSp7CNY8UaSfZH5s2RR8670NK+5kGpSWezWZMDvPTHFE7Z3MkZRl7bKYlpL+1mLuraY1Q7f/vARrLOw1sI5LtYxBIqtJSCttMonIt3SxkV9ADIIGoaYWcTMYDBDds+uJ5P4EdCMCdgMKUeoiSe/dHRaDQMseysyXsxMKPj67DSW2VtyqpBuPi1b3uxWLhvvS9vbyhn0MWHqNe7f86NqXPAiy8VzSmHmuZFDSFj1gVq2Hm9gtJir07k1zjBTp3G2HnL0LvddxpRsYMXzEflxoxWuLNu8qNDjQO3ofJZdyAzJqo+YV7SAjVuEIm07uaYRSLBG4cpqQ04d3FXt1rrjhZgKOMR1YQgJF2ZUNHQ0c/jc7RUFQcsep6sus6gtu0q0bT+693TzQ99vudCIm4U2BIhTok59AooBbFkVjjGInNf4GpZgswRjccS2ji+ENO4o85OsllKi4qZuSFhy8Y7nJg3WlM5UcgwCrHh8CyvprM62WDRlBOxRVyutikuAFKLe2SFTiv5kk6eiqpgDR60pOzFeRySIoqJCbiEfQgEsPJKMJns2aVJDbWFVZnwsd7NUCpmukQ1NrMogYJuBpNM6WzTJ80p7d8qwSIGfMJFWKRzWFXZ53o4zZGNrMAnYhKzwhgoJxzaGdM3yZcB6IPu72hgOZFNurCEFtUBpqzweU7JeTyuTA6mX2wbuBLKvdghWHQKta5UjBn/ZRZwy+7vjHTSKnaN48PYh4Xjd53Vx04UMyocYYZXeamss10uuZT5flG5/VPhMgVE/WlOloMrlQUWA2TGLKeAJKJkrgEiDLsZc1CpNJ9ZDyI08xOtZ5pwUEDvOigV2g6LC0mKJKUGvMRpnQnz0Q24mJNZ9SJEBMmfWeF0dhgHGKAxsqRpjAoaeg3J2nxGA3HZc+EzEyr2z0g/imeMN+U+Lr78iJ6jjNVm/CUtqncU33ntA1qSpjBPpakqF9oncdlLC0bzilts076mIjrKNXQb7JQhWCtkKVNYk6tSX8noRUsLuxHGb+23Wt+csWx8jFl2PdUd7mWRC5Dw7bvShFbgZU8pzUPGaJQGsrEPS8GTZDiXrDGx1TBQ/7DsPyprHEcu8PcZe7XitrhZfUmIBUEvp97///fiN3/gNvOMd78B0Ot36+z/6R//oS77Hj//4j+O7vuu7cP/992d3ig996EP41V/9VSil8MM//MP4yZ/8SbzxjW/EY489hr/39/4eZrMZ3v3udwMAdnd38Rf/4l/E3/7bfxvnz5/H4eEhfuRHfgRve9vb8O3f/u0AgDe96U34k3/yT+IHf/AH8b73vQ8pJfzgD/4gvvu7vxtveMMbvtxrk4+XYwLuBiADgFSRy2IqG5mA35S44wzKYklphVFnGFUYPkmVZmCsVWaGKm4qYHiTqfn3aWWxU5NnqePfZ5VB44gBqCqLaWWxWxOD7DwD5MYR08TSB8fd3ASwWEtWNgKYpY3wGJyUzYKZmUAAuaSxhPlLeOPRBJ++tsTNFZmeS+c3YexksVcg9sBq6sHuLVnN5AYBoEWbuhEp7DTklyrODuJNKwD1fFMjpGNMuc3ttLKoHDHIU2/wlnM7+NBnbzFIB6xS2CTxpAX2Gro+fUzYBALspx05Z3QhogspW8mJrVExmy9DRUCW1cWZQg6p7lUKOF4H7NbFD3UcYN1aD+hYnnLWBpyfUor8JVmQ0X0RRlE+56zrycaOrerywg9kdpPuS8TX33MAJOD+PY9PX1kT+NoMWG0GTGuXNxegsMNxZH+IYQCc32KASd5h0Hfc/pyzFJGdIayz6Lt+JPUZNU0J/LtW2Z1l/By5aOOsjazJZJu4fZnEtUA23E1PLIs3GsmyLy8HHPI+YjWomKGUznaStpW/U6aH0veOq7SFRap484t3rD1GKaz70jxnYEcBgOaFGOoL41PGD/0beBOmQGc7DSm2YTIWZPNUCpmxshwwyFtLowCRmigek9kJRdGmKOlSa8r7DoHSyGKdKOdoNTW2SUDO/FA6WWdQC5SmBQIcvNHZEvHlZHFDitmSjLzMSVKzZks+aTMtQFSr7WYjsulf2qvZ9aP4kWNrHpMc5c5790oHre8xr+GV1Thmj1qlgElFdmExkZvBnF8XEjkRSKOEbgh5DQyRgcVoQPejNPiWC0cq+4jRJPOo2FZUrNY0B1P1SJoyseRy4LXODSAAwCidfaDJwz6O3p/GBJEg9Hxx6ZBrByADb2HH5ZBMVb7sDKo2/UgiwYH1eI8WScaQwSJlkqw1aNkiLcYERHq92LG17GJBz9XMyEZ8/NpxzpIer4fMztM9o++yaANlqGJigGzw0Su3c9ZIQK1j6eAQEwYtHub0XaUPgNMKbShyq26I2GlcJlHouqvcTIoQBHJGzRgOzgP5HxtFmc1xcBoiZVbP2gFtIDnZofWZjMqORCHm+X66HsiBgwGsAnIrbOoQnKCUBEAp7+ESUMk+LGNV8zwYzxxn9JYvNiC+yHFr31c8luV4rewxcJcA+fHHH8fb3/52AMAXv/jFrb/drfTiypUr+L7v+z5cuXIFu7u7eNvb3oYPfOAD+BN/4k8AAH7sx34M6/Uaf/2v/3Xcvn0bX/d1X4df//Vfx3w+z+/xsz/7s7DW4s/9uT+H9XqNb/u2b8Mv/uIvZkYJAN7//vfjh37oh7Lbxfd8z/fgH//jf3xX5/hKR3yZK303ADm93Op5R5QkG1NKyIuR1QoDbxYK3J6xL2kfNfqbsC5Gk8a1cRpGs70Ss8W7jcFBYwlAe4t547BTG7ZforbB88bhcGrhnGZ5hcPBxOHxW2dw3A658QaT2sJYA2MNnNPYmXgCIgxIqsqObOIKOIlpm7ULIeQAQZjl47bH4dTi6lmPISTYShZ7AqaSkpPgQiuy3Gq84Wh3rF9SaAfaqFbtkBdm0UfKHbFa4eJejSGSftcZjf0JTYvjYcCMm3mkxIzzqHPQwBN2r3Z5QV4NAZUhDaHRCuueGIRZVdpuyiLSx7g1juTnSSVa7GJbVxgeWngFINP1LZf2eF26Gy7agMpQSnNg1lJAk9yNxIA9M08h4rSla0nWedRwhq6VxoqZ5gSg6wN+64VbiDHihZMON85aen47YL3usaxt1v8ZYyh1mZC1wYQWByBZiBQCIBsnPUqbOWcxWLaCM4D1FkM/cLc/tTXeQhDLQpPHpWgFc8tfJWk7uhYyh067HhHlGikl2nXWGYeU7Y6qSiElytqkVNhRgBbmku6nlCnAXuhIecMRK6MQSavvtDQFidCK9IQxjQIAnufrTpoPsM6Qb6ZRaksfPJ4PwiB3gbxWW7ZVWvEmLuNr4g2GTSrBIANbAYyWf5bvKo0Cxp8FgG0k6dqtu8BMNXIgMM7AWF02aaNIljHn9HJtafw6bjAi9yIx8yuNFFJK8GzHOGOv4DvJKLEnq/k7VUbjpKXghUChyRt3HyMUNCpXAqsEuk/kQ76dERwfFHTc3b4o7y33gxoK6eyvDZCOGouW/G43A2b8kX2gTIBc+z4DVJLdWaO21pchJG4hTABYgj+AGGXRg9fZo7pY31nNRMOZyY+Rr3tpC972MTeCEalbRGnaZDSRHEoR2Ou4q17lDIzeXsek6+iYNAJIdnZn8OMy202yrBRf2jRL9ph2iCUIGgKmjcPZWYueM5sIPRBj7vopDHLoe3iviZGNCV+4scnSrXUfqebijlvecZMQCZSqyuKJa+vcMVMOAsIJJpF95HIgbfYQItoQclvooU2cPaFOdY03bAVacIKQSgpFXibBY4g0rkXr3/F7OF2yRH2IuLqgv28YhF8+2aDi7LFYSlJAk1hPbXJdFI3LyOsltyBX4C6XFHBYTZhHMkGBScJ+1Agp3zdQ1jy3M+fgQjTIPQPkIURYvFTqdLdB6isdrwqQP/GJT+Atb3kLPvjBD76mDwGw5aP8codSCj/xEz+Bn/iJn3jF59R1jfe+971473vf+4rPOTg4wL/6V//qD3iWL3+8HBa+G4CsOBKiwUqPSZpAtmetuPNTSswiK/YWLAuEMwrrjjvj9CQLEPbTaZ3TmI0xmFcmR+qNJ7nAXmMxryyxyt5gb+qx11jMHLWcbSqLvanH+ZmDtaRRntYW52YWx+uBmEQuVms8AWTriGU+mFXMJltYqwlAG5JdUKORwuKNhfVinC6AKYaIT11Z4Vse3scnX1yxblfAHC0Ki34YpcyJKe5jxKy2uH7aonJlk64cFQ4ppXDjrMuLPWlHafGnrj8KV9lLd7+xcFbj/MzhrA24uaTnfOrmSS4gqUzKjTko8gUaLmIkOUhA7VSOiqVjlYwZGTarYSDt5GgCy4+iK+8kKlfcApy/uzAvSgEqlfS2UlSUM8QisRi3RQZYejJiZcRDVQqC2p6aZjjODoj3K0Dpu9WIxd/0Ab/3/BlijPj8tRVOV8QU912PzWbAmgsxwxBy8xmkbY0wrYiiO2MgbjUMdxgkgKzRmtLQxlce7bqF4+JSrUtGIwSSZBhn4LyD1gyStdrSzxsjaX4ubNXko5sLQHmOkvk9cgpQNrbKaiocNQpDlOtT7pFjbaZcU4XCsKVU9JUSnKzaQKx0KgB7LClSIHAqxv1Z+xxT7kwVoTCpDG4vO2JERT8MYUMJVBWtIXBr00G8aI2mxiFLZrCMVrn4U3SIku70ltqiJ4XM4oi0QbY3Wb+6geaoEjCkWLoxUHbCqMIEir/p3sRh0Q4ZKBlFBIDg8MRZD6t0ZuZF+/qyekdIV84Iy900J9bg+qpDSvQzvT8FNSEmdIiolcnfRzyzb561nHnZZviHEHktf8nHv+JBgQmtY6Lb9ZrATBdS7r4p42LJc0p0n0OMmTUUaY/RZTyuO2pzL1Iep6WVtSotsBVfO0PdOieOpC1yDwG67wczj+YWF2yr0uzFciHv2absSTK3JLsiwX1meiNlZKwq3dSExBAmVPzcM0iGwtSXAFCC3sqZHBxIFoqurbyQg7yQsO4jN7FJSCHgcKfC5auL7NGNlIBhgGfg2Q2c7eo71LVDy7KXW0tqQjSwnGDVDpxd4bU+RMpuQudrWNcW1083mTGW7+GsxrILLGui16WUcGvZc7EwZVrSsgTDXYjYnbg8jhTPqZkvxIkEjkpRA6CYSO6y6QiI94GK7ES6BND3vbHssVMb9JE+I/Lne6uzlHBSaWz6hEU3jIIs+kGY45KB4Oweg2vjNCpr8r6YQO9/cxEQU5FAyv20RuciypQKCDacOZiCgr+Xm3avER+/ugb5a77ma7aK4r7ru74Lly9ffm2f+N/gIUzBVg/1L/PCC+MrkZ4sIOMUsGxijhcHKTKrrM5ApmNhvTCokoqymlqRTgUgG9pQJpXFXmMwtbToNZ7Y5P3GYq/y5FpQO5ybOhw1ntwsaiq8OZo6kjdwYd+0Ihaa2GPSLd+363MRn7VkZK8ZzDhnMvssi5lE5ncWUg3DgGunLZuYF+ZUgDBAi4KkX1IioDow0A0x5a59ADKTZpTCqgs5bTxxOhvgk1wCeH6xQkrAQe1htMK5qWNmkNjTK6d9/nkYMXZSxNXlTlLEMDZOUtzgZi/0/IHZhwSwG0LMjLK8fnz0rEvUEM1VeXw8sKxCWTj7EoV3Q9ExyltLgZXIOwisKcw9sbjtQJo3Zyj7MGYGpt5kk32laHG6erxGigk3TjdYbmixlMYcmw2xvuJSQeert+49PVbYDgLEJssqNGuhtdF5nFUVyXo8S4YoGDN5vEkA572l1xmT9fIiBXK5jTdtUFYja4OdLu3HHaePhf1PiTb3iothhY1TEICMzIKK1rEPKVf/izhKQIRhhmnTB9Tc5higYjUZ14VppXMSDaCAdhrnJD/YmxDANbq0NYcqLOgQUk7bAsBp35emEqCiTgEqWlE2Y6uSXelRwxkKeoeYcr2DaMVKp8dtFtOzplk+Y9ORXKQPBcRrpTCtLTcr0dCgMTqxNktXgNIURcDf8Cq7oWSAqMjWYDNETB19hrC3UrgH0FiQ9UaPgqPVMOBsI/UT2xpkuUYZ/Lzi2Wwf4iBhFKWSpQMo6ZyRXU26EHPHRLn3CVQkDIyCXaO2nDGAUuhUs4ysZo25aNqFua6tznsFUIJFy0FsJRlKzqxI57+83vK4k/WK5ILIaxK1Ri8afwHOms/R8PlXttTaZJCsqBPqGHRp7sY23kvlsHeMf6o7oXEicopz84r2H2GdY6CsFshdIiVkZlkaYAgRIc2xZBxvWHObotTa0PhwhhxzvDc4XfVYsXtHPk+tcbKh2pGWNbmSVRIGWfY2yeSIVGi5GfI9ckbTHBmRSLJWUwdZHtcjadK0shSwZnAbcboesOlpbomuXe6vrH+SaVn21IREmprJOKR5UEhAgCVOHFA0vrTDlj2oH2JuqHTnkQmdVGpJFApRKZ36xsfdzr9XO14VIN/5gb/5m7+J9Xr9FfjY/7YOSReMAczLpdbuPAqTUTrEQJWNa1z1CRR9ce1MHvS0SdnMgFKPdmKWrFKojcltjyfWYpcBsrQmnlcaO95i4gwqQ44W52YWO95ihxnT3YnDvbsOFyYNAaPaYadxOKioO5H3BpOJw7QmzZP3NgPmS3NinZ138N7iaKfOYMYzg10YPENWcrKYKbm+xCCfLDt87vZya/EQpne8KAACkunvi82AgSexUsQ4j4t+2p7ayyqlsNuQW4dSxabr+ooY5qOmAkC2Q1JVvBhVJ0sKqM0pJprYZ12fF4F2SNitLLw22a1CUoxjoNCFyOdUNOnCMIs1kwArldlAeu34fWRzE/ZoGF2jPpAlkUh3AAq+6LoWXZ6AupQSup600ZWjjEEfU24bfDix3H2LPr/rAk7Yuu30rEXbDjBGUzeqPnK3upS1w2PNMP8AaAKtoldXHERZBsPGGM5EGFhvYR2NPcOZjpo18IadWLyngtKqcmgatyUHqiqbx6ZzJm+8ldVZz07FrWqrEJPSyGWepkR61ZgITIvTw8QbGEXvVbFERVKlIp+QwFiKlkhnjGxBJYdWRXsn41jOY+BxIylsADllXjmDtg95w5Rppvlz+7idmThpewrU+H1O1pQqlur0/anfStWLHZeAdQUChhWvWQK4ZKkkIIet3Kd0wFSKip7ErlEIgTL3kTtPektBnNn6Oxd0KSlY5KI9nuul4DJl9ixEKnpbDwFzLs7tBnpenYN3+k4yHrI2PKUt9wV5bznELUAeuRv54ZZUgK9tnecokQBrtgbsYsCqD5kcIYChuBCX2TYt7CvyPZFxrlUpipT/Zf2hsUOuNTueADKxkiyh0BqLzcByCgogY0q525uw0dbo/BoC1iKxSxxobBehS+GoaMwduwjlz+daCNk/92rHywbVu1AdDHVqlOyQXNNK6mE4ixQjaWC7gQFyCLh+1mbwrBSAFIGUsGnJtlCuK8KAlgv5SCoScuGfkAXdELhwULqF0mulDXYICasNFb+lmLIMQivg9nrAsg1Y91Sgm3jdoGAWufV85DETUsL10xa3ll0OtOW63XkYo3BuZrOEQiQewluI/SPALkSbPmcpr522+VzIlq/sZzFScfdyGLJF3FhSIlkhmYshEgGTi185cxUSydDkPaS9vMxFmif0vYdYgHhCqa15OVexfO9ew3FXLhb/vR+iLx1f67u57GPwm6NhJV7FbJN2x3NkoFve4MYgWhglcWigxbBE8N5ozCu7lebdrS2mzmYpxqSy2K8d5t7hcObhDAHkS9MG+1OHymlMawLa+8yoVpXFpCYnDGH46tpiZ0INSYzRsN7Ce4P79qrM4FUVaZsJ5JjMMMsiJt9cAPJy0+O543bE2pRNMssIUIqdxLNWJm431pcFKQwpaWUAuDipsdNQakpaTB+vCZC2IWAYFUIEBpiyWAwsidgMpYDHW4WztgDmPhLQzjZSd2Qd5N+QKMUoUTZdB2QrPHkvyQ7UVm8V7sXRwpELpHghkjQz+VDf4YKgJA2ZWHdHvqPPnC3pM4VNc4Z0oCHltOYDu3V2QegDtWxeLnsgActlj7YN8F4jhsggOYzQArY0wRkYmMIWA8iBlTEqjyPRGleVY2aYXtN4CtLkeU3jUFUEpOvaYjaj5wubPJ0WwFzXBlpL8ZHllqcExGqrUVkqdE0JuXqfrjXy3EuJ2L7GUjAk89lpmo+zitK0AwMXYglVfm6+dyDwtjelgFTun9EEIDWP48rQXG95Z6u0ySycFLPdPGuz5IEASLnxCirrVgU0n24okzGEiAjgZEWa3IOZz2OmFMkgA31xylHqpXIzpbazIVKhT3MoZcZK5gdpo9NWlmTZDls+wt7obBG2RVSkBM/XgUgMKhwCsLWRCjiISJhza+BpZTAkZPeASWU4VUvn20XS90qgK6xyP8qqbGl8MyAv1+FLHcSZcKCmKQ3eGLF1A6fvA7pIWbA1F7paHjdOaxxOCmtojUbjqfi6cWX/MIZIlHlFzjS1NVlfT3uSQm0VplzEXbPEwBmVM5ordiBwHAAOrI2tZKzJ89kuMxcEqkIIAcJKc3CvJCMi50A2d7UxJHcy29alh7UvHu2c9p/WJBXMcir+HLG+1JqCYsqQ0XWMMQIx4PKtVV4TtdCZkSwpG6ez/BGhZx/3ou0Wz+S2J+az7WPWJQ9cVJkSsMOa+M1mwHo9YNPR38DrSztEnG2o0G/DziEyX9bcQvps3VPb9VH28Payo6BF0/o4cTq3ix7PSGMU7ps1tGfy2j/OIo0ldsMQsWqHrDOWvXXVBfoZxf4wJgLIqz5ke75x/QaAXKzZDQTMxeEixlIkn0CFzOL5LPhG5q7MEyEIZZ/Mtrko2ZSt731HwP0HOV4VIG9tZKPH/ns7aIG947G7iEyy1lgVtlgWCdkcrdm2phqDYQGGcshkzQUyWmeAbHkBnFpb2EKtMas0ps7mjXlekfn/zNEi6KzG0dTh4qzG7sTBGY1Z7TCrDSbO0IbvdC7s0yBGWQr72iHmpiI1g2hrCZQ0lcX+1GfXC+c09qfV9kI2YpG7LuB4PeRiHXocqG3ZOEvBTEm3dMzsrruQv3s7FPZnrPV93eEM56aWCoZ4UZAK5BvrlmQQKXFFL2nW8oIQKeIV+yOAFuF1H/OkDjHh4qyGQrl3dO8lnVSi6z7GrJ1DSjk6l0KwlJBZ7gmnNjVeam+jVfHIpXEiRRfYSjsLuJUAQCq3b68GvJCZAtoAvFFZtzb3FiGkbG1EwHtA24bc8KVtSVbhvc2V5OMsizEEYkU2kSeGIdAq44G07MwacxMbSbMWhlhTAOaomJTGFrmuNA2B4snEYWdWZYBcVQa7U5/Z44oDSaWBiafUcuTrPXFs4cZB2cTp7HlstCoFSPx8KR7rh5gD0cppHM4pIyGFoQBJJwSUACX13ceI8ztVvr8CmkR6oECgpPGGAa0wLSrLA6xWOF0PfA+3XQhkxMSEzIwCwLKlwjWxLbvddhgiuSVoAMfLjrSHkYsLR8xsLkq8I6NBDht3HPyAMOKiqY+pyDD0aH0kHXTKm5wz0lSnZEvk9WQFR2M9pJgzMKUhCzk+SLMPo1UukBWZRB9pDm/YpSVyAFs+J2WQPIQSEOfpNQLuMsfvxoZK7o3Nlf6FNZf3X/YD+khSkC4WqzLJYBw1PjNs3tL4dZrqTYRBpsCNUu0NFx47rbO0wSpg4kiHPW8s24kSSSPSoY7JA3KuoLVByBkJZsRFxfDnOaNyzYwQRAKaJTNSfMWpScrEaUyY/bZsFyjZnIPaU1EnS69qbzCraB8jFyV2WeK9VSmVs0YAOI3PBcEp4uysK8GFsK+Jgv+d2mDG5ABiwHLZsXsSP8YAebHpMQykbycwHdiBh7KZkn1ar3t0HREHMmxSSli3A1YtOTdtemaKI13bVUdFtcsuoLEmNwdToALbTR+zPKZxGushbFnIyfe6OGsQUTThm1AaFmlFfuYE+tnyjoN/+plqn1reZ2n/oPdeD1RIOHCzIX+HNamsb0OIGFLk5iQkKYtIHGDTfB84wNVqtM+nseezyjaHwkjHlPLrtidkkfe8luNVi/RSSvi+7/s+VBUt9JvNBn/5L/9lTCaTref9yq/8yms8jT/8xx+kGtIxEFBAjqhl0RTQJJuPbKC5KMJoKLXdicmZ4jUJMEB2Ouu1rNGY+xGboBV2KirGE93gvCLgWzmDLkRUVuPinEz5tVLwjnTLu5UAb2LYqLDP4NpZTy4XjcO5qaVqaSniqy3O2sAsoMGsdrh/r8p2W3Vt8fBhnQFzZpKVYk/sgOWmx8GsgrfEmoWYSGPXkTapi0WDLFF2HygV2Q5RErzouNDMKp2N1jWA01WPe3c8fgfIPssrbjZyc91nKQ1VkUe0Q4BlCQDJW0p1rlKkab61HlDx/QscJa+GcfECAdsCmFkjHCIZ+eeNFTmdRUwzsUlOK0yrUuxozXbAIGyTbDgVg8ryWeW9W2YkoKmiPISI68sei64Uz9TsgzrzBssuYr8iG7ZP3TihuRATVisy5O+6gYObgQKpicuFl4VJU1kSIZuVYkbTsDzHWIMYYu7qSHaDjuQUhjb52cwzUw44p9FUBrO6AOC9iccQIsl/ph7ndxtYR/7dTeNwtFPDcWZjUtl8P3ZrmwOQ2mgMzFQaRcU0UwbMG1CBj9jeRdDGopXCou/RDpHszRRyWlVS4dZQpbXRCjaNgl7ZQBiUKoWcrg7M8oN1wN6SBWHgFKm3mosKWf/ck2OESCDEOkzGgdzfNkTMjCXtJFf2t7wRnvU9nNa4ftoCIG/ovWnxAZdsRfElL2tjHG244+VyDJhTStmWUsCh0aUZhbhzbLrAjL50mFM59Tow8BcWdeJM3kjbEDO4Fp9dqmlIOTt0e9ljSFQYKfOuj6S3XPXlNUOUzpiKgEeMiErlugfgDjb7DgZ5tHRvHXe6MIzlXsTC6gwIhaXrpEmOUki2gH+rNM4x6aA1OQ3NvOG9gQroxEavdhozR2N9Yk2W+GhFYHLqNWaOMosnqx6LNrA+v2SkhkBjvLEEqAjUGnZxKGBcMn+V1Tl9r/m7Gc1MMxeyynvWls6hsYYLyFk24E22spzyvLWWahGkCN2Z4pVuRSLHAY6sMSLpkY6lAIHWmhlesXYDkzUX5g6rsuFgve4xmfhMbiGQzOJ03ZP9G7PHCAFDP3DRpsIZN8XarFt4b9D3Jo+RlLjwElTA2AaDLtIcvrRXY8OgdNkPuDSvMYTi73za9bTeW2L555XBJgSW5hRZgmWXh5S2i/xkHgOsAY4Jw0DfPcSEmbNYsW/4IGsRimQJAFZdxMYX3XTjTZZpJRQ80/F5r4Yh70M0f5C1zgL+73Qk7YaYM1aytskaGJMUUr4CPnuZOfhyFpCvdLwqQH7Pe96z9fv3fd/33dWb/lE8/gD4mHR2KBqv0qKR5RSG01OpFCyMGWSJtmXhHRddyKJas/0KQBtrYw1Utn0i9rjxBmebgfxFPaXWKquzfcz5ScWpdgLMuzW3pTYaVpGg/nDqiIlmJm/eOFzcIQN70YnNG4dlF+Gczs95/eEkR+ZNZfHOS7s5Ja41ih4ZlN7ZcDUvaSrJLmjHW/Shh9cGKxSrN9EySROVgfWMPQg0T6vSoEBiyWdOl5g6CiKMokVBmowcrwMXEaRczFCFBGfo2kYkTnNJIRul37szKlKSArdnz1ZbG6dU7TdcYaz4sT4kBshlzEhaTitgSHTtrSHtoAYtelJIJe+VmB0TgDGrTB4/ngMRWcA2DMhVQmGQlx02DAoBKsZzeoDnVKLn4pQnrq2xU5vcDKTrQulGxZ0SD2bVKCNCJ6i1zhIIkThorRFUgPUWzhPrO6Qhp00poCKALIzyzqzKnfOqyqJiW0NhhM/vVFh3A+raYX/qcd9+De/pb7PG4YH9Oo/NWe1guCB0f2Iy0yUaviEm7oIYMfMOE0dNRKZe4/aqLK6VIZuk9RAymFIK2Js4shfki0qG+xwUp1LwUjny7g0p4uaC3CfkPfpQNgGtaP7vThxpCEOk7IwqjgJGqZHGD7nFuaxBcn87LgRTiqyc2kCp3RATzrqBfG039GRpLkHFpaUgTmy15G8r7l5mUZr0bI2DsnBluYkUWgljJt0ngRKENgx+c8EVgJAirKaxLZki0SNvhoBlS5pI0QunRCnrnhmnq+sNUirNcZQqae5NCKhNYao3XWCnDG4xrktdxHhLUEDe2OXxcap4fNy5ORsl0gRex43C+KWrIWRQZDN5yeQAZ8cEmM4rAsHjxiyWZRJi3zb1BhNr6X7yZziWN8y5SdK0orS6WHLlaxxJdyzzRIp5zzZDzlyRBIHY7ZozLLK3yTj1liRuItmpDLHGs4rOrXY0r4SwsUbldLc1Kvv5TyqLgwnV0gjpQoSNYrmC4poEm7vCjQu6ui5gPvecpRCATBrih3ZG/R5SRN/2Oa3vrQHigGEYsNj02f4tpQREKuDrQ0SVTGli0lGWrXQG5KY9HFz0A2WGVryWPntzjQ3P53UIlLENkbI+04guRtRGc/t3g/3GomUgTNpmlbMKtzfF410BuWD11qLL46QdpDU17Qvz2uL0tId4OZciVOSMwaov3uJDiiwfBWm+UwmihxAxxIgNkNcPADlju+iHnGkYwrbT0RAiKs5mS9vxYXQfpfD95Q5zx1z7co9XBci/8Au/8Jre/I/a8eVea0qtFN3x2CtU0obWUJOLkBfAsrAR8yTOFexmMWInnNbkWqHLwuSMzgDZamodO6kszjYDHKffZNGMkRoSHNUVt04FvDXUVMSazHRW3uDc1GHCNks1a4uPmgrLnmzgJhOXJReiUZ7VFnuVy4zgpGIm2xg4R8V7lOYuVcZ9iJnBdMxE7HqPBaeYbrfbU0EiVaCwWiput94UdlUp4OamyyyfWNYIE7LkyFlSziFGNrm32b6pdjpPTg2dgcxObbDhxeLqss2FbTIOrFIjf1ZKP0rnvfiK05t8aaXoqzxWOloRy4ScorZaYa+x2b9WfDEFJHQDFYgkJU1bSN8mUbVSwMxZAC0iCGQNkRbIa6ctlKq4GUhPOrtQ/EdjTJg3xXood1U0Cc5bzOdVZnM0pz+dd/A1uafEEOG9JTaUA7GmKQzy4U6FFW9GFW+aJAEiyc+9u548OyuDvVmFvYbkFDI2DyYk0ZhMHLdVBwCFXWZ7Y0rZKaGLkVkVUJGr19gMkdv+dvk7ktZcZVZDmjY03uDqySazHqLHpHtRbPamFTG5fUQG1LlgJsQsBRDJTmSgOsTSESum0hGvDSFLFsZrzfjohgirBIjSHGhD4FRnRG2GUtWemZ5t+cC4XfaYEbIoIFckHsKMAgQGRbKgUJrcCPgav9ZocrMAP0++UkzFKWSDkHWN6y4iWOC47dDxd2r7AJuAGEsR7EnbobYGay6w0qA5f9b16GLkAjHpghly/UNICWCySiQOW/rrO67R3R5SDCfvWVh2uhYtgwsAEJiYGbxhwOXlmjIuzCKSIw29t5WiuqxNJpZW1icdS5vxxppcqDitLW6xXaAenUtMgNcGldO5oAoobGFC2cO8UaiM2Wr2UrH8w0Hl4DImcAE5MdtTR8W3lhnoaUVZNCFFjCa53rR2mNUWc2GYuZ7BewqoN0NhkAUgj+3DAFoDydHmjqYwgeb/hVnN97Z0AB1iorU80lratmH7nnNrayFbpKhz6AcCxylRlo3v9WYzwDmT19pVPyCkhBdP1tmxqAskQegGahlONqHcAtyRfny/8riy3OT7Ift37UyW5gDFeQZgrT+fOkksUu5+e2G3wjMny+wcI4y8sLzWlEYmFORLBklBa6APTASxJCykhBiIEOpDgkaRTKyHkItTxy5NlKEqktN2EAa71CKNgf9L59bLPPhlHP97kd5dHjLY5PhSFL2kypRC1kOJ24QUBIwZ4cQTZpyGJyCrs7ULuS/I+dCmLKDLcDpqzLQQQLaYVuTlOfEmV9xbo9GHCG9VlnnEBO4kR1G8yEAab3F+5qlzkiGguz9xuNDUFL16g/nEZ19GASV7jcGtTZcZvnnj8NzZKqfERV8oLgaRwcCE263Whhb6c5MK3hD7Xa5XmYzjdJVW4EI92vitonsg6bzTTcDtlRTBxcy4Oa2wGWSBChk4iBZM3B9mnthU6UrVDWQdtNdYRNDkvrkcqPiJCwqkhXVh+um7DZw6yxOcU9Mij1DM3iuFDKKlar0ajR35HM339cLM5YCACnjoeVKYlxcWBr5LrqyWcXGuqTAk6honQCiEhFuLFreWPcthBgLIMXKFOHsvt+xVrcBOEZqL4iyOdmtqWe6JvVVawVceTeNQ18QuN42FtyQRmU4dJhNH1fhG4+JOjUlNqdLJxOWsgPcGde3wuv2GxvyEmtyEWBxYdiceyy6S9Kdx2GmKvdFu5dBYA2+IfdvxjlhUTYHUXuXRMAO3692WRl7mnGMPVJnz6y7k5h851clrwFYHNmx7kGpFwAFglofZYnmP03XPbGjEtKJUutEEImRMpyRepGVcGV26Mw48VjS401lCTs2u+oizLmDRUxMHYXKLIwSPOWaZACmA2+5cNn7NuNDYMYMoxUZj7+iBQYkEfeNDNmY5JOgEgNOOCvpONgFnbcBJ12PVE4O86WOWWLSc5j1eU5FiHyNJVBQVii26gbyVtcrSrOXAzBZIK0nMN63tUqhJ51cA/JebbBRrs5cUdTNo6zh46Zkpk6yRVsCyD7ixpjbIzmjs1TR+ZQyJ5Zp3GjNPoHjCHVGdpTko5zBzDo03+b4K4BXPbHGaqey2rZscwpiLltwbsh0TT2NrNBpnYDT54Na2FME1hvS+Uh9DLhtEzhw0BJDHc04kVQeNJXcTTR02fUVZp+wAo0nGNZk4GLPdeAeK1vKawXMfYkZUMUY8c7rER56/mb8fdQKlsX9uXlHdCDtW0D3ja8GPd1IE3dPaOgwDd/mTccItw3tibQeeu8uOdO6Xl+vssNJHkmC1gfTIy37AuqcCW29IDnd+UuVATvYDAKhH7eSVKl3rYgJ37Uu5xmBsZyt+xnKfYyRQKwxyZTW6oTQ+iomK7QwHa1I7ElOxSRRALYScfK4E6JT5ipnpB0qwXDkDpJLFknmWveJfBpO9Uhbnbo//HSDfxaHwUks2/dJ78dLXKa5FQmkMMJZYCMhRKIxAXmSULDJEkSpmIOVjNS84ZCXF9j65mEFs4GhTlzS7ME4KxOQMgdLnHaeiUiL9KWnUbI6qa2dwWHtMnMlOGHuNxd7EEfBkecV+Q6C6qshHeeoNtUK1Ohf1nbQBlgGzgCTxt5UgoRnp0ABgzhozYSflGiiFLT0jINIU6XwWM0Mlaev/L3t/GrNZll0Fg+tM995neoeYc6qszKrKqizbZRvbH7KREf3ZBrrbttRC3UiW/AvJlrDAxhKIf/gHCAkJgWSEBAghMNhSS0hIX6sxg9yWbOzm8+fCdrkGV1UOlUNEZEzv9Ax3Ouf0j733Oec+8UZmVBkMReeVQhHxvs9whzPsvfbaa7VDTE15pC1KC0VlFTf7RVx01Ogg1I2akQyANhfhMzpDJabRB6wqbnIIZPFMpafI8nMUQBHHlLjVS9Zg3XFgkiY7ppuOaFYOheHI8cwmRDlGZDUMRcjWlVmVEqyb81k2Z4lZ71MW6RC4wY55Xs5o3Fg16MeIdefRD54pFgHr3UBmIJHMQMQZT0xAlFI43fSJVlFVWb94NnN48foCxhnUjYO1XP5rKsznDrOZTZWHhjnUi3mFZeMITbKaKhss0Tdn44kQOQiuLZ5ZzKCUwqy2WFREIaprg4N5heO5xbr3qVlvydJYTiscVBIgU+Ag49zyHFzNiM7hjMKVpkoJF4AkySi0AUlQpStbpM+kSiGqAOXyIWO4Z0teoWL13NgiCE2M1DQqY/d0O3BTIM1tQZYBGrvykJWsRUoSSgnqkHiIMi7akZzBWkZXu70AeSz+FiqHlEVDBHfm52Ba8VonqOKM1yj5vNrpdL2ESOp0rek6iiNGsdPOd3A7Ev3lnAPkc2l4GkNqMgqRO+k9zX+RjBJkSviRYyDzEUGs2zEk5Rw5FLJSQ/7Z9By/nkOa4aQSCGSTFQoipo6JSokhi8KmDzhtfZL4O6iJUlclugZLpxmNhSNzhjnLbUrzHX2fpnlQmZQUyzoqTVLy2obniew1cv3SoCWSbE4TbUJMZAjlperZjBVZBIGeWZp3y4rQ49oZXncNjuc2JauGP6OqLI7n9GdubQqEpepUc6VP+h+ahlxitSrK7qx+Mq8trNboBw9ok35+92LA22cdTyCdbJsHH/Ctt6gPK4aYaF/JqTOGpIUMFNWXEHkv5xvGKKhQGrhAQbSKEHF/Q8mwVDDOugHDGLDuA85bn2gS0oskQS99DdNnFK1RdYorMgUGyBrbnfS9hJz43jvv0mdR9TpXeCKomirgjGNzm7b31OTNY0spJAlT2W8l+FUcbEfQ2ieUSel3kORcplNJK9xPoKFyleq/5vFhgPw0h8oOcPlHH/w0pMQI5A1C3jtZXC75KMm+BLlMby8C7LKLXCvSYc3BkGwkNLC1Ag7nrtgsKWOuLTmICRWB7ENzQGg0NaId1xUaplgI7+t44WAUUDmD40WF60vRSTY4WtSYOyrBSJPU1YWloJxRvcSztibZhSsFrGpGHpge0A0BldZ47rhJ+q3A1DlLI8tmiXZwz7aWgrYbrdLGKRuklIZFtgigMnPZBNhY0tqMMSa3Mymnb3qfvOml5LrtA4v6R0bE6TpEfkqeFTUV5SY9OUqazfmOuqH7MXfV35w3WLrcjCnNg/LZCxaLV1D41mcPUhOOZP4RuVGB6BJ8DUZhVhucbUkH83Q3Ytd7nHXUhLLZ9Djd9nRvBlKqAD8/GbObbkxKFfM5KUxYZ7FcVnj15ixxkZ1QQOYOq1WN1aomXmHjUFcGxigcLSoczBxmFW1uPkaWDVSpqRQgPvKyyWVl4hczYslj89rSoR9jcn88bExKXJeVRW0MGlaJSE1BvKmvGotKk5LFauaSvCKA5N5IBjeiNEMIcomIjtwQK0GBBD+CuGgJ2JRKvQsStEoFyTMaBWT9bypTs4JKzEHrPsVCvoM4tMWmDSlT0v/7UcYvfWfnPbbdyBx3hTHmgFnWN9kAZd+XUqwgj1AqJf7S9CWB9rziQIvf54qgrZwzJSJG6j06KbS0nkrcZyyVdbrz2PWBUOTeQ4yH+pHmeztm1zqtKDn2AcQjDxRwCALbs0Z0OUOVQq4ElNUffGOHUTmxisgotVCxZB0SWkoZRJPNsWd5N4PjuuKATxKOrACyqkgLtzE2VRPlnkp/yqLODWSGEfJS1g9g3rHLvGKAKX/ScwNaC2pDqhg1Nws6pnU4nXtjBDiaWaL1LSqb+i6kQe/6wiVp1NpR8N9UBrdWDjcWLpljkLqSw7yhqhP4PIw1aCqiVylFNA+tNcAOqIfziuyqBw8oDXH2PN15nO6YmlA4NoYQcWPW8LiMyTyk7DECiL5BY4OQMgmwpS8g8gP3BedWA6ka82g3YgzZ3n09MLe+H3HRhVTxNApYVBrvbVtolftYZAmo2CGSxlrmWoeYq1QtN7SmRlutcLLr01xczRzFFEUCHBicUYr6ASI3yjtDFS3p80l0lkCBuCDE8jtBl2UcCe1CeoMmGSfHYhk1zgnZ06jGpOfxlMeHAfJTHCUCUv7sgw7ZKABcEmCX/84I3/7RMD+qzNQB0VKmf8tEKDcX2qxVCtykPFt+f4gU/PW8kUcgOSyJ1iNt2CohDo7lvw44KCH0VePqwuLKzKHiAPn6qkLFbnRVRejvVaZg1LXFYuaSDI9IccmCu3CWOdB0MZuOAgEJZhXfM5HUypt/lhjKqhOFzJDCpBQcY5ZUa5xOTUhipxx4ojaONG3lPbQZEtq+7QWVYlMMAB03bHXczFcZkuY66wY+/xywimpGRHYeks3SaYWLbuTSVExySNdmNVZV5vq2Q7abJbQhc9pvn7SE7rAOaBocIFoOlfh8ssld1g5vnK+x7T3OdwPaweO1kw3GMWC3G7DbEQruPfHvAMA6ofkQCkOuisQDFs7xlVWDd896OMd6xIaqB4tFhaNFhascIK9mDvOKjD2uLGsczCvaMLmct6gtjKHfyZySisV6oO5pWcxdGos1rs8pOJhV5P4odB2nib/bGIOGkbVZlTmTVGpnaSsjDpeUUJWSi5PeASD1FUhTkjTENi7zPDUUBTeykYAkpMQUxsdsTS2SZsLP84Geu8h1bTsR8c/qLCjWDKmkSFIqQZfwC2XlGXis9SOtCe1IzlrSiENug7nZKfOq8xoX4j71abquiasgAJbwQlqnnGGzEQYQEn+TE9KIyAimTijUyEnfph2w6Uase58aD6VJL4Jl0jxRh4TDL+iqyCv6IPryOl2vJB50nnT+ldGTNb3cdCWolOODTKUkgZf3yquVQkJY071jlFnWicHTeTtO4g8ql4ASStBojZxVJq0ZRLGgIFPOXSyfl0zVKRsjJfmRdVYC7pJbLpTBDPqwnrjTyWWxMgzKMJVpXhPSKwmcgCILUW3h5uTrszoFQMvaoGIN9GeWNa7N6tz4Vxksl7SezCqiA4p7a+00Jd6aONhKKcAQXesK+wF4HwlBNiRHuR2oAqGUArRJ1xZixG/dPps+QwazynEwSpNgQpb5GZoyzZmOD5kHEcCauc1VcnWlJvJ+CNgOPvF6IyjJO+369Dwipgor7ejTPSwrH0MgfeLW0+/lXKzWWA8DjNKp/yFimhBtuWdHg5IOoVrJmJVESS6v7PmRpF/oEsKxd0ZPKj77h6wVMe4LGjx90Pv1HB8GyE9xKGQHMjme5oHIwnLZUb6/DGr3D9GxlNfI26TZRTpW5b3l56bNkAfjup3aDsvkGwIbC3AwKMGBbIDJdpfLY4vKYMkLJE1Og6tzh8PKoeYg4IWjOm9CzuBgRnwxa1QyGXG6DJCJr+q4Q1o40gB1cTdWp45buUIJkMVYxTIvUCbRmEqDooWc6Qhyr2QSVkY0WZEQJqEiNFbhypw2Dik/hkhB0o5F4s862og1sr20IMhWK3SjR+vH9BxFu1l4hQAm3D+ANsfzfkjNG/1IXOmTtseyyv217Rhw2GTk54JF6pUC3jrfQCmVMnq5gTHScwMEwaDvPZxZ3L7o0fWeuckjvnbaw3uS4WtbQo0Dox6JSsFUG++lCdPgRuIcW9w4bPBgPabqgSzWq1WNK6saV5Y1N94QPcJaUk45mjECxQ2qc240euGoTgFL4wxW3AAqVCJ5prU1uLFyWHJwMKsMXjyq0ZDFF9mzMuLWGEObcpWbdrRSbIfMDSe86ckzEpUHmXdGgcuwkelCmVJADTOa7XqZVsEqDELFsIqSUaVUQmAl1pXASwrxow+c0Gqc78aUBAoyY4o1IwU3WhXoqeLrzDSMrC9Kn9N5UoWQgE9MMuQ18l6heZVrj2zQ+9xkpaZBgahZSHNaeU6DF/oXeI2iebGsdAryBYXa9R5tT+jxwIHwZhwTKjtwkjmESBs/f5flhKIbYyojS+Au2uQRhcmLojK/XG2irBTXWl7f/vXvH0aRLrS8Vj7PcpBJAAkS913O22ha1ygooSTeGsX24Jm7aTStYauKXOhqDu4bVyC+SqXnoBhIkCpPiHkMCQghTpOlCYg0P0eeBzVTMWpG250lzq/TFJynnhgeEzPW9KeGUzrPeaVx3JBpjeb56ywjyPMZrszqxN+uKqJPHcwdKVw4zS6ctKfNWTJyUZlE7TNG4aih7/U+AsYC1kFxgpGqwNqk+w4Ady96LuvzvOfrE26zKoK4muczOCB0LruiyviRe5+ENCKZPEUGsQCwAx7tN4Iep2AT1F8zdZoEvy/grB9SgiyIK71G9L1j2vOkX6LlZEZiB0qackLTiqSkIRqmVFCTig1yFSL1GUQZ40iVIxr39Lf0aMkamppD+WIk4ZDPluTyaQDLr7d5FvgwQH6q4zJI/utFkB/7zL3Pl03gskNoAmXALdm7aHuOPnAzQH5fXuCkoSyk/6fyi6GNRigVjVUpQxME2fGgFXR2xhxl+YzaaRw1hpqbDOkmf+J4gcqQw1jtDK6uKqwqaraQMrc0NFW1Q9MQj6ypqNStFZImae8DZsZiw7ql1HlOC2hjRch+6uBkdS4Ha5VLSdQIBb7WLLxOWXpMQXNGxmgBuLlyfC6ZjyfayyNrr8pzkWxYFDFijDjv/ESX9YLNDKShohwvFHAQteVioPI2lcHIjvi9XYsDpssAFCA/d9Ckxfz+pkc3kJrBgx0lFTdXLidZ/L7SAlXQUKOBhxtCjtftiL73eHDeUVd2P7KdtEmLmNLktEgW0cx7ZLe7zzy7gGVe8bc+M0c7eKLfzCt+jsDhvMIzhzWO5/Seg5nDYWMT5/hoZtmMgOk9lUblDF69tkgbduPodQAhFjeXDoGfae0Mbi0rLLjpdFZZfPxoRc1zoKDraO6SAoxoyWpG+bN0Gi3ogw+wKgc9Im+W0ESVUbeIrFIhG9mMAwMJvpM2stJJmYF+j8kmYrnsG3hOynfUzC/c9R6ex29SbuFzkvVFq+xKKfNCKiyyxoTIEkoxouJNctN5tqOOaU5R8igbJq8DBYggnGwg28GqYm6VvHu19/pykx99ppeIcYtSCsuKZcoEXIjEf+yZQiFVl+2QKUyeE1L5LMXfVSpnyCNccMUoxIy2G40098vScYn4SsJdonfvFyAL3U407mXdleCqcbqgkmHS9Fmb3ABVOY2jmWGanEmBrTzjuTPcw0LjXJqs5LylyZTGhZrQgySASwEy/xEaoDzv8v9Gk/JO47IUaeMMASqGUGJXJKMxiqU7jX+lxLSH1oTI92r0VLmbVQbHC4fjhUvztmksrq5q3FhVZPJRE5IuVtWLxqIydJ+kedjyPUgN89ZBuQrWZsCB6Bg2qS0ZTQ5zRMdAdvpkwyPowhnUKKyawj1WK6Z6IHGE6TtUUiuSsdCPtJ8nK3GeD/0YEsASI0l8dp4oRUbvVW4i6SufswuiVmriUClzbAghBbNKUVA+hoiG9bJPt0MRlFJs0bKdtlQfRA4uBd+pUjvVTx957ksyBiCZL5V270OxDwu9TMYZeO0R5L68nicd30B8/GGA/DTHZfd+nzJx2UHj4yki5Ce/CgDSJlR22cr3S4llDISYCL9JITuqyQAtO9ElGKy5o17GztyJwxWrQGhavGWjMpqEyWuTu50ra7Bk9LiyNMg/feuAkWcwX6zCwlnUlpqobh4QXxmKKBdNQ3Jwi6agDnif6Ay11YTeIfOOnCGuoJg+iKOgdNHm0mhGWqR7FuBGOZYnk5Kw44Whsio9Q2cUXljOucwVknbrpgtJu1LsqBuX6RxSUtoM1DzU+2wAsh6ykQirYmb0iReSw5nFuh/TQtiyJeu99YBrqyo9t10fcHPeUIORBm6f90lc/XRHZbpPXp+ncSMJn1gbS4MIAJxsR5ztPPrRo21J6/h02yf71GHwiZqhFEkrkawSBcJK5QD540dLbrxz+KGP3aREpKKmOUGsjpcVXjii/ztnMOeNnkrDCoc1SUHVbNYhHLrvfO4IhhfyujL8Hgoknj2g67KccF2pK3bmooD1pRuLCZ9SuJCCgErgIPOuHyk4lKDVGsWBFyHIE25ojGl+AcT7l7knaGhZnhbExelsnHA4dxO+rVI5aJTxLFxi6hnQKTCTBjbZzMpDq2yjLWiYcFSJqjRdd4zWaEePi35IpVgJMIXnKOVjpVQq2QPSCJQ51OD7UyafcihF4zIiB5ZyfsmEJJKUnMyTg4qCPQoc6cT7kWTdBh8wBiRbbTnoGeTzlvVM7psUdGMEDmZucs/pNXmMRFDALcGdXF9CvIvrkwD7soPGDZtrhKmhiTMKC36+FY8RcW2UIEaO2hpcmdvHuv/puVPj88HMpvERYtH0pLJMoby+pAfFiMmeIoGyBMuA0AaK6l6h3FOzmVU6V5ODXtGGD1w9EIRTAuyZy4oZStEaOK9y0L1gmobVtI/cWFV4/rDC0cziuKZ+BcsB1KpxJGPKqhWucnCOzJBmHLTCuGQuJM9caQXYCpabAa3W6Edq6DOGguzKZv12aMOazBTkP3NQkaQpo9lzcfGUxFVz86IlKT4xnRJ51wNOsgFphp1SeHofkk11OYWpchKx62j/kfWRNN4zIDRyUpwajfk8QozJTTcBAbz3zipDmsugIFrWg1iMu9znUHDsY/55Of8A7nfi8SAxjaEvpLXHP16lSkn+0wTIH/iKx48PA+SnOC6jU3zw43h/SP9p3r9/DuWkKEsPUnrtOYCkUg6XJJGDYfleQZCtUah0boQDiC+rkInyTguHkn5PKEZuHlEgBHnGWpe1oYDloh2T2UftDG6uSHrIKEUOe4c1Kk38pqYhXqpzGlfmrqBDZLS34sAVQEoCXMGJlqxWkDCxbZWS8BCoLCVZaYwxoeDlpmIFXeEFLkQqXx3Ujp9pLjdueip3+RCSRI24epU6qWtWtWiZlhAiJhu3PFVZOKQ5a+Us1j0tiAHUPLXrqXkuZ9qk1fqFh+fwPqKxGvfXA4bBozYKZy2VmO9v+hR0KE3nepMDybKJ4mzbY9ePhMS1Hn1PTVohBPjRY2Sda3kOxDdmKTfmBzu2Hf/q6TpJ/n3x3hkFh8xdl4X2aOZwc17T4sf896PGsdUtWBZKpcYgzWjFWw93rNxCklHL2qDW9NqrTZXQ0NpqHNYk2ybVj9snuxRkSGApKAQFwPTsxcRH1EwkObNaJUco+VupzOuXzULmuHShC5IKYNL0JAu8BKryewDpvEueneUEDSC0UJreYkTi5MvryoM2bOJ2Wg5CyGRAMXqnJmuLUVQx2QzEgx9jTLrMMm4JlXp8PcuVKppbIlUnZf8nNcrIZ6b/8731MXKZl7iYB5VLAZXwwT1TkUaf18QhxDTBQpG4EDKfKQJGMyKu6bwP525SilZ8P8VVU9bd/Wsuq0DlNTxpL5D7J8lujEhVLWsU5s6m9dZqUSQSdSF2UNVcRWkcmaUMeW0R2lFjVQr6S1ROzkoC5OmzLQyJ+IIErU2NUU8YaxXTMByDFrYYW1YrHMws2TbvZ2VyPobsrGubK6cKRAebO5KIGxhNFenSeW1xc+lwa0Ea6NdnTTKxMlrheE7BtPDHbUWJ/HYIpBFtdTKxqpivPBO+ctXAOJMC2RgBWLG5J9pHQqGNGGEpVNbglWuzBCZYq5MSjwKSA6L4JMwdBacA2Naa7LWF2iPzqVxz+jEmWpFUDvLYI+R123NFALnBXJ7byJr/lOxFGKNSE7OAT/0Y2BpaccJlUl9CzQm6jCYx2CnjFWuyh4PEDeU6oEFVtFL6Vpp25Zyl2lYe5Rr6QceHFIv/Rsdla/nTcJDf73HsbxAy2IHLmzoEvdo/aEMWdCSw/A99vgy2ELM2pTTwiGZrZWgAyqJaG52aaDxnmsLnDTGXJA1PLMuLgIjrV4YUGk62PSpt0uJ9zEGKNaQE8MJqnigW87nD4ZKatG6tHHbsJDQGCk6N0qkJQOgV4ASg4gVHEGRpzBDEIhkn8MbRjSGJ06+HASLbs+kpeK2t5k0ciRfpY8Tt9TYlFhr0HRfsH18uBEu2hG64YXIMARcdBba7PmDk/XoIrLAB2h1F8gYQ1yG61nXrmfZBAfJ91liWhssQgV0/4iv3W3gfcDy3ONv0GAaPRa1x3tI5/v6dbeJ4ao5ojma0UMu48iHifDskO+q+9xgG0jyOIcJ7ei41L/DSjKcUoQ6LmhytSJfYJs7xYubw9nlLG0ZlklmNUsDx3OLGrIFIfAHA1aZCZdlBkA1rxAks8Li9t2thmYsqzotGTxtQAKpuzHmzs4o2PGmMk4X3YjdQsMEopkiLLWpDNBqfF3+hJAhdph2nKiT7m5c0PwrXb0yJ5jTgtYy2SYCcEG5G4kq0RZBmrQhBlqSO5i/x9xWmzpu0hijWnzUJkWwcuZ3NjOhCY4Ikk206USwG5j+WGsuBE4qyoqaLdUwSBuFqCwK+v59JafayNU7uk7hO9p4s5WtDVvJzsRbmDnmpbpA0Wig+h/5WCingkERK+iEEMW2ZomSKQFreI+OGELXiurVK1ajy55IUP+mgcRITl7oLnnscyOipNiRBWHHFTIIrctdUyWnzalMlqoni7/U+QgOJilaibZMARulU1qZz5p+bXAaPEN1q+n8ZlJSBrkJOALM7YEG/MVNKYaIY7t2Xmhv7ZC0EP6sZB5FCNZjXFkZRc+5BY/Dcco6jxuHGQc2ScFQhurpwmDuWb9Skwd40FsMYcNCQ1rqxBlVdJSOig4alKp1jxFkncAJsTOIYIZ9zwyEsodCGwZvjuk5uos4RT1pzxE/oMYFIs8rgoDY4KPpLrFa4tZrxWMxJnlS0tCIQaDswSFM8VwHHukKdRdY3otTQcxc6UkqsrcHVueW9XaPWJlVeysZkaRieWZPMejQnwbKHyHio9tZlSfLKOSnnJ3MshIiZy6ZJqVFXqkohI8p/WL3jJx0fBshPcVwaDH9wfMzH02ct8pH7sl8AeEHJP88uMtmyMnPoeCNlZIUGHVJjhZhONI6sRzUjaUrlEp404ThNQacIfJcb9egDay2X5H/SUd4O5HxnFPE+AV4MFJWQnz+cJTmr5bzCtVVNgZXTFCCnUisF7dKgI008SqnHBOvpGnUKqACwWxZltV1Pur41NyQ+2HV8HRGnOzLsqKxhR7+YEoVtH3B73aUFQobDpvfpvst9kaaaZZWRpk3v0fmIiy4kNGQMYi2eH7xsuqR5DNzfdlj3HkYD657kfR6sydTjZDOk577rPe5fdBjHgI8eNbjYDeg6TzrU7YhhCHjvbEcJjdHJZvjuxZB4YFor9AOhxQMvbsPgMTJqHGNkt7yApmEOHyMiMSJRJ+rkoki2qHVtcLSocNH5ZI0upVmlFK4tLBY1maxIcLtyDo6DXkmqXIFwOqvRB3KDmwmthtEVp9WEvlI7jYOZSxt2bYg2IImhaAuvGNWmDYWChKNFRQGL9wmxBZ+nWPxKtUPGoFReAFo3NlzalOcriLVWReMVj12hXshnKQ6ApalPAouK56jmjV4UaJTKxhBKPb5pKAXMDCl2zFjXmdA4aaRSqedAKZZB9LTBjpyAd174j7TuCFfVapWCq9ztn4Pkbsz0rxI9p7XscZ6uVo+DCGL6MYSAs77HrDKsiEDVHTE5kI06RNKVRbrXch8yWCD7duM0rBKHvIhtR42ZQnHZf73MX0Hd5JzluyfXh/dDkOl1wimVcRJAygQLZzGzhp+bTk1TAEl7yZozqzSuzevUF6GK89S8hgIUEMmYK2+506JCEB5D/srnKWMRuBy1KysAl5W+y3Ep30IVTkx46QBQawOrdUoq5ZMWFd0HH7KrnTOEkCulcHVV4cA5XFlUMIYSdjIcYWt6Rm3rxmE+I/3wI+57sM4mbfbKKFydO2oeFwMSZzCvNPOOCSmunUHl6LMJLGAzJKNxNLN4/WwDpRUbZFlcW7gUBAoFpGF62apyOKqr9IxrqynQ19nfQHHSRvNOYwgxWVJLYlgenk2vKls4Vqo9+UhP9IwYAec0bs1nqIzBph1RWc30wLjXhEffs7A2VSOkCleOI6VKpLforSiGhuwJIu2meDyI90Fyr+U9GYr7QYo1bn+O7QONT6pavd/xYYD8FMcfJj5+Unh82fvlAV5WktOKP0uyp5hLcvJ/6YCWzxZOkXyW40BCDhGUL+kblaagduQNUIwIxLAgG3Mokr8yKukVy8YwY7RXgu15bZLhgNUKV2Y2lVuVIk3b544bNM7g0XZEO+agXmgbxBHM16ZAgZLoXZaNR3kzo8BeStzdSAjyoqJM9eGWXN9GT8LrgUs6AZRRi6btRefxcDOm+0yPIbJEW+alapUVMA7Z/Uma60YfkpW1BGKCRjKYAMEpBZW+fd5j2wdoKOx60iRed6Qscb4lfWRxalq3I8Yx4KIfsevo3xumR4yjx9mmJ46yIVctrYBH6z6XS7WC9xF9P6ZxNI4B3sfUxCfjqKps6gJ3zsD7SMjInHjos5nFoiFU3zkKkPuRsv86yRbSn+PGcVNc3jilaXTG9AGrqKwZinEsz5zGB/29GykY7XxICGtlFG4e1ikgdYbGQmMMGLwnoxfeXGMkupEExD5Ou6l9iLAq6/hKEyaNPTXZKDQv+El3lBMvmespOJbg/RJ0btmQLmymWWQXOdmMjM7hu8hCXnZQ8krBsQTIM0eqMUJXEtkzDeTmUN4cBQVvvU8JtJS4nSlpWBJQCVc5wvuQ1g1VvGbTjul1Qn2SNU2emRyC1o+BTBMOZo6av+xUFUDWIZmrMr+ytvUUQQYoEEmOiKANnlQ/dDIOkWdWrl1TNSK2Wt5D1N/voHNTE/qY/LviBFGeV2MsG6nQMXcmKXrMncbVVQ0NquwJKivBZcVgSaaUZJURIFMkhKozCV5UBomcydrJT6qilr/fD5BjzNJ1kqDK50be0MqEQ3pD0rqvRKZOTVzfhEJBvRsOC0dW2YLONpwINgXFYjYjtYsQqZLlOECuG4flzGFeaVxfuOT42TTEWT7kZj+RsKyd4eZCXpesQVVTgHx1YXF/PaQgu2kMri1d4tYKBWRWGSwqooNdndUQjnJlVKKEyf2T8Z2ojnuJd4oLI9LckyqJj2IqxbQvrpCKYx9AfPbnD2eYGYN1N2JWGYyRKBby/Dpu0FMglFmQbQGsxqLKVAamieZXjKkIpPWsrLDJ8BS6lMQoI4NM0mw7OYrv2gcav/7w+MMA+amOSznIT5uNxCcEyY8912kpSwZXcpJShbg4kAKW8j25ZJW/oyT0i+SUfN+8tokXLMhmY3OTnmz0lSEhfcngJKgLIaLSxAdLWSFyB7ggxIccIMsCfWvlcLEbWWAduLKs8W03F5jXFg+3IzUbImeZ0pUNoDh/2tSE1L+PvIEnYOvJBKVn5GsYAw4bMv04bcdEH1m35FrkDJtnDCEFZRedx+kuq04AtIGOReAo1JSTLYn235w1ZEAQ6bPGQJ8TImCURgBNvmkpdroYPFiP5ASGiE07YteP2LYj2t7jwa5LTU1tR78bx4Dfub1F31Mz3bunHbbdiL4P2Gx65l9rPLOkBXjTDtmQxmiMo0fPnGcAqYExdevz38ZQcGzZwCNGMuC4OreYVWQEsmocSZA5jeePai7x5UYu2YRvzJqJ8ojRxO91VmPlclORWMcCmTvvGO1zRYBsDamIKEVBkPCIheMrCOHC2RwEh7whlwiy/G4IoQicMk9VqDsy7+Szxf3KaNZ9dRkxS9JREDQti9zLfcgqCwo3DxvmbKtkliCNqNZkNzhpHJ3XmR++fyhFaM/CkVthZXQy5UlasuykqRW4aoRkJ0tJptjC5r4H0Xa+TK1hsqlJUF+sDZtejE9yUCv/LueG4blMTck0d585ajCvzWOBqlIUOGhFc0yCxdpmRzf5Qz0WSAmDIK0CBpDOdOaGK2QuqNx3OWSz3tcufr9DTlu4ywSEcNDIfPI5o8hLZ1MVMAKYs7LLQUPo442DOgXvclpy32uj0Q0hAS1yrhKk5qpgTGoociS1Ad5v5JqflATIWy/bIkX5JH05H7XTKXjbr4SGIkLWSuQY9QRxtkrh1qpKc7GxdL3GKCwah1Wt2dmP7Ky1VkkzWSvgWkOqStZZzOcVDhekle64UlbPaiwWDo0zuL4k1FgQ4YaNUBYs52Yd9WBUVuPmosZFR1rKTeMwmzk0Njc3Wmu4L4PoIUdNhZuHNaRxclEbPNr1LEWYE3HRna4MyatJQldqjMu9KZMI4beHSMlFO5LFc++pahEjKePseo/D2uGsG3Bl4VJfReAgeNtnxSyhdPkYkwLPWCQvWlFDK43pHH/Qs0WizUnfjiSu8vkhinRqPm+lsjb60xwyv77e48MA+SmOy27s09zr9+Mpl7+RElPOEnNQMkFBVM6qBLksv0NKLFMkOgfOYjUtKDCQJeS4aoFKF2YjMYviA0iOQUbne1Jx89QYQ9r8lqxVK9nkQWOSz3xtNG7Ma6yHMfGlnz2s8H0vXsO8ttiwTaxSisuBudNZF001ChRcLGqTyj6xuOcKouNKGs/9GFOHu5TnLjpCVEOI3IiWS09DyNnwReux4QWh40x7kDIz3/sZlztPd1SSevF4jmVlUrkpxpg6gaXxUZAABcVNOtkq1IeIs12Plhss1i1RK+TP/V2XKBYDX5f3EbcfbdH3AeMYcO+sZQQ5oG3JhamyGve2hKy0g2edUFKJGMc4cX8SreMkUaRUli+yBhU34wHUQX40s6icxqpxOJ5brGqD2hp89LiB6DILN5wqHYRo9qzOIba4ZKphcFhTKVI4uiOPd2cUls7CaDDST4hqH+jZSoBVM7p477zLCCzPnZkg2fz/jg0BIjIPE2AEOWQjloH5ewHT8rpsaDIvRZs78L/ltcJDlnEjyZ8ENhKolFxPQbwkwBdZQ+EeS+CpFZIG9GUrj8gozZ3BvKYGqFXlsHQ2fXZjNRa15uA+N9nJuOw9NZtK4tBzaXfRZIMJICOssuGFmBFhkRhTiu67oE+yfoSYJSVlXTNaJSWNMUSc7jy+cneNZ44aUo6AVCX4OpzML6FIsOKJyYEyOebRvVxYyxxfncaEVsQBttyrQfcwX4MkdOn+MpK/n5w8Vb9KzIh0iLQxN/ydQiVrnE59GwASuEEW0RrSjF3yvCVYFqMlKdOXdueEeudkcV8GrETaY8zB9WXxsQAbuOQ+yHeVzaCyp60ay1o+7NB2iUmEnKckM3LsegJBrs4dAmIKuEQZYzVzJJUGGgOHc0J3V4sKV5fU0PvMkhJ1W1kslw5XljVWtSHzIaMxm1dYLsi06NqMzYs4EBab8Ir7X1KA7AxWjvXZNbuGNuToKe0B1mrUtcHhjNQ1DmYWNw8bqhRZjWWlse7HifukNTSOG0uW3TFmN1WiykzR+bIaPTIlTCgLu5GS3XbI1Knaabx1scWqsbgYBrKxj7Q/xUhrVs+VUlnXtM7NrRX38Uj1SKus0FJb7rtBph5Rr5NOVY0yCZNmPzlfiWdkbdnvs5jGVeW/46Xj8YOODwPkpzj+cBzkp/vMEkEuA+Gy3KRQIMjpc6anU35qyriKkSLob+pUlwBN0EGdO+TlENtVWnCEB8w8R00TNfAkAbj0xwYeERQgiyFGpQ2O6irzjJXCc4cVbp/ssGws2t5zSTuX6GTzBabd0kZnC9uy2zoFcwrJ+rJlXq33AeccqHZDgOWAT6yBZTJLB22M1LAjusI9Kxrsu/rVXJ7e9B6VpUawRZXLTfI5cg1TxCtzyiU5CjEmtHjdUVDcsa11P3o82Awpo+97Qnq9DzjddPzviPNNj74nikXXjbSIGhJ4d4Y4o9aS7apYaXufx0HgBidjppJE4xhSpzdJu5F036pmRYnG4WhmcdBQ6f4qC/3TZ2U0VSnSum4H4rEaXvQjIjUosUOfNXR/k9KIVjjizu4hEOXBaY0xhKTzaxWSQsO2J1TfFgidmBGAA4Y1c04BkepCeg4+RszYVKVn+oYkteW8FYoAQAu3s9ltT4HuX17k6e8Fb9xCz5BglxBWhfvnHXbcdCUBmejTCoKugPSzBWtbX7pkcbLZOMOWvZRo1C7zuOeObIAdV41EBipGacABeu/Rc9Ne50MyIErcxBh5LgFjDKnZtaSpSKOTBOFJMYHvtzTb0n3J1ypl4YvO4711m/iRVAkRhFhoF4wkM+q7qFiGknnrWT5NY1VZkhVjW94YaVzVTPMpEWQJ5CXQLtejJ20VTwqSy01bEmbN41SC8pqlzoRqk1R8+HoPa4eZNdjwGJbqDN13+uzGGEYZ83dLs24+9ylFSI5kxKBydQNPuCapIsr1lMfIpX4ZJ/L2iOx+CfCaxrSelIACQIzpeTmdqReSYJdgopTotSanvBVXGiqjcHVZQSngcFHh1kEFa3Syrq8qi8W8ws2lw7IyOG89tNZYFLb312cNocDOYsaggFyvUgQeNI1FbTWbNpFaxWpV42hRYcv7jgLxfWcVgQtLR5Wie+ddquod1Bat92l9A7hh2RF6LOuSrDM1U1XKR5MBs6zL7wVB9pSgio6yvP7+tseittiOHm8/3E0+r3aaZV/ph1JV85H2UWuyprYk/RQME+VN85pbNvFaTvhlDEgFacMOoTJ2smnP40Hv+wXAZbD89RwfBshPcVxWSnqa+PgJFSh6/yUDuERHSw1BeY2itJBKF3G6kMliWH6uID/AlH5Rlgbp/5kTKT8rEQNREijLHxLA6mJSymtq3nhmleFytknBHHFEaYOVBe6wcniw63A0s9nVRxNSLZzmtPgocStSEz5dycNUyPy1dgyESg8k8RZCxLtnfVqERe+4HXzK0GVSywbVjz5twu1Ai8vAOsPyXMRlsBvI9e+Ns3Wypyb0nKRv5PmIkoY8H8FLAmfHPlDzXT96bFoy6Oj7kRHjgIdbcjaKgSxNAaJErNc9LYCjx3rdJzR5GNj62FBAMXOUvFhLCPJy5hKdQmGPH+hMEsknt7zA6LFj7i5xZRtWnlg0Fkcz4bnq5D4o6FPalxVw1pOpiQQrUtasbK5yOK3Sc5Kk7MZBndBmQZXE3MIKishIi9gml1qcjbjl8X0XBFmev+aAVhZlqWIMIaQxmPjjxTiUOSguYTFmcw9B9ErNUJJ8ovdIYghkZGTdjql6kZQupOHKZKSGypw0/p50GK0Sp9lqhcoYHFaOdaCZHlUR6lWZbBqQ1gmluOM9oGc1i9Z7XLTU2DmrTNIvFV1VH7O+qtBHxhDRMN1LutO1Yh4qClc+Trpp3NIG3PnAqjMe93YdXr+3SdUrw8+4dlRKNwqpqU0roSIQf1X41jNj4bTGsrKoNNFNJFmxmhR5hNKjivUz8BiSwBK4vLEQwMRAY/+Qn8oaRtr1Ko1pGQuV1dRIWgbkPKYqTc2KI+vmps9TuXmzKihK5ftlrktzs4zNEqEVpQXFcyNpHl9ySaX5Q3kvpHqCOLUilt9JkkX/z1SP/bim5kY4qWLSvKHnf96P6XtLw5IXDissawPDY6wbQ7Krf25VwTFooJTiXooKt1aUdOyGAG00Dg8bHC1rzGqDoxlp+Fumk9WWaQ6c4Ap4UDmiR4RIF3vjaIabBzU1zPEcds5gUVtcmVkc1g7dSIZfRpPW8FFVJefHgWkCDcvcSUIniSM5L5oJICbAhtHiYkc/l/sricjgxbmPgtFHW5J23A0BjzZ9As0kNkhzFNQbIHv9Q3a7TfvaXkxSGZOqZUL3GEL2WyiBOqNVUsOQykYZDz3NITSPy4QPnub4MED+Bo+nKZvJYnHZK5/EEZS/0/MsnmuJwMiRuLfq8fMSNFI+a9ONCQFJgvdR3pe/V4GCDKWocWzhbEJVysYLscC2Zto5KzJUwg+WsiFAXdRnbDwgG7CgUUczk0wr5Dusyjw6hSl3rryFJeIhm5hS1DR3uh2oy5cn2YMtIcjehyR7NjI/WfP3iewTQOU+z1lyz7SDwRMKIIG48KGkW/jepk8lKM/8KZKOImUNCeiyEQL/jSx31Y8ew0jqFX1P/GBqnvM4a3Np2nPwHkJEyxtNCCTPNgwsmTeMzM1VCMUCXVU6dVuX9zKhfpoc8rTWSfM4BDL8mM0sDmZV4vk5vh+LytCY4UB1x1J7MhYE0VMg3vAYqPRmjMaqpkC75g1dNmvhhgrKduuoSWPScTBBJbfML6204WfClB0tclI5EFUc1IiGuAQBMrZo88GkmzqZI+hMV5J7FUFUoGVj0XASUqqc5I1jio5J5WKfSy/VC/mZSL7JvYhxSs3Y9k8OkJUiBRkJZB1vwoKSGk08yoPKpVJtea2OA/Kenbd8DOg8VTdOtyQ7KNcbQuTmHa7E8PlO1XYyBzGj5khc1N7nIFu4iy1LzrWDx8luwDn3BhgthhCkqkN0BBoDgk6vKktNiazEILSF2pBEYWVIrkuCcqM0lo1NdA9K7HLVCpgGkrZ4NuWx/7Oy5J0Sf51l0SRYmJnMPXdW42DuJp8lAWIfPDWd7n2eSuMk86bL/cGmQHfqpCg/K89REtsyMBIkUI7EnS8ShnzNHKwUwEZCNgGc74bUhC3BtAR+At5E5OpqaXEtJlbnLTutAulcjVZ49doSDSeQWilc7AYoBdxaVbg2q2EU7Y0ABawHc4eDmhKmwUdorXHtoMHRzGLOVtcA8YfnNY0p7wP6kZVNdNY1frQbeW3QeO7KDM8fVRij3CckXeRlZbCqXGq2U4qqOVdnVQKWIoMnjTOYVWwuVFAMCBTgHgTQQJBkgRrg8n4jCPLI8YEo1gCEAm+YyrcdAk67ftLc3zItShoo29FjNbPwMeJiN7LDXt7XUs8SryfCkxZ9edJFZhodrw+SLIqkZGrSi/n5XhpXlf9W33hgLMeHAfI3eDxNAkODavrCMkPaP0raw/5j1fxREdwopgrEtMiYS4RBEEo5V0EwZTEW9EmCZshnI3fGxwgsKluUGPN3yuYg2qEJrQZl6hJUDGFK87joB1oA5f/dCK0Urs5t4jwSj4nOg8o2Kgc5l9zr/YBfNrF2iLi/a8kumE/wYjdwphzTe4fBJzOD0ZMuZlJzKCgX7RBSw4CzIvKu0I60iAnX+uFmxLr33FUekkxWiKS/fFhV8AHp9cK9ooCQSlTDQGhZO5Ae8cAo5zAEbNohcfa8JxpJCBFdN3KwTAHyyPJRnrWlFQcp256CVufIjvXKPAfIk81RU/CrpWubVSuaxmExc7i6Iiml1cyxuYrCqiZJKtpMs8FL/vw8vgSNbCwhyEcVud5Zo5L+sCDIUnYzGnjn0S4lMbJRSLOkOJ6JAookEnmTZwMZ5GpICoo5SJA7QLy7iJsHdQrejCIus8iblaoaAM3V2pk0/qW5VZ7rY2o1kowWAYw05w4+B5QS1InSgASXMk4BsJX65YuTVkhBoSjUzFhaUdQJFtbioHFouGpE/G7uRWDt1M6HwsyHKh0SYIjdbARVFWJEorMYTSiwXJsEWNLUKAFbiNQo2fYetaMgJfDPNz2VgtvB49F2xKO248SMNJ5rR1WIGSNsogyiFRkurGr6PYDUXFgbsmFuTE4WJNi7xgijUkKvmK7dzky30Mvu/ftqtPLra6F9WOGz0r/FgpjUgszk82X8boYx6SPLOUjCk6hAeBzNKyXcXMGT378EaSCVikqiSGAK1kiSqIr3pd9BwJfH984YgW3n+T30Mx8YQZbz559vuzEDJio33SpFzqbpxJDnHbm66qSI03Lz3q0DR8mgoURdc8B6NHOTSoI2Gh+5Ose1heOGdDba4uB2VZvkppr6NUDj5Lz1iTqllMKVmUs0KwVat5YNNWEuaoOR+0QMr6O3jhpGh3VqyJ1X1FxrlJ4kaLXNiY48c611MmASLWNJhBIyC1pnhjEAke7xpickux0Czvsh3X/ZjxOFIpIrrDTpnnWUtKYmvJCpl9L4Kr0ZuceB1o3K6ry3cq+F6JqnyhuPn4gnNImqDAyWCd83GiZ/GCB/g8fTIMiXcdLC+zwpea1S6rHMZ/J98fHsqaQbFC+bbLo9B4TSVFBqFcqiJ+44smEKX1OExUt0IEnzQGyVCYEdWE5Mzns3+PTvIZAphyBoSpHhRmMMrjBXlZBADc+l034MLEeXdUn376WUOgVlAJA28we7PpVzlCLbTIDQWh+pa3ccw6SB79mDKnG+JACpWRBdELLaZGWBdgioOcvvxoAzVr6gLDig5yC3HQPO+xHXV3Wik0hZk56ZIG9IGsT9GFhyjZQ1vGe3LN51QiBOp9AvqsogBpZskwXG+/T8QiA1AmtUatITzmbadIJYSdMCblgUX5ry5nOiV9xaVbBW4/rCYm7pd8vGJNUHUWkoAwtpkFKKqCU+RraUVbg6q0ic3qrs1MQlZivomFJYtyOrPiDRMeT7AJa1QkxUAUElKPnMzm70RxWbVubzCZoDEKoiKJy8R9QNhKt+2RykuUGLeVOZFKREAkNSaVmQMVn0O05sRPVCqirSACNIrYxPOdcSTd4/0tzVmcMq5XtjCNlZVharxrJCAnG/6Xnlkv/IjnURpJ+6GUdsO4+L3QBIUs7fJ53titcLxIg+CEqGhF4pXnPA76HN2XMQBqw7z2uHRzuSpvlp63HeD1g4QnmFX72qDdscUxOTNPdemdWYO7q2wIH7vDbMSVap4VjAA9ELl8SMAiw9oXMJNSXf48fv+5OeB8BUMKhEe6lZp1ekLRP1Qqu0vsohoMBu9Mn5U85XzlnOqVRAuKx6WTYcmr3fi/GS0F7yxU7X4P29rQxghM9ffkTS8Ed2/xPamjR1+TAN5Le9h4+icpRpRhpIHNoE9vAa9n+8c0KybKwBPXLFjRw7aZwLDcwYMgcRDX9xj/tfXlhhWWejFflsazSOZtSEvuky316C+03vU0B/93SHi56ql70o7Wg2I1EqBZkzni8HjcHNw2byrLVSOGwsVpWduCICmbMu40CB0GxxIS0rN/JM8vPJYEDXjeh4r2rHgHWfdeCNVsl1N0aqrm6GEQ/XPXyMOOsHbLsxJ8TFehQgsQElGW2hhjMEkosUJ8wZJ68ypjz/PHGa4+UxmPzEh9w4SCf72EufKmj+MED+Bo+n0bkss2k5ykH52Ov3gmAABWSb/4oouqn3snK7tyh5yepVNqIQW92xQKeSfiH/XxAFQILh/LkyaEXuSqgC8lniIS/XJAuXVhSwdsx/kqP3ROM4ruv0M0KbYtJ5dLbgfaq8AOZ7h8f+LQ5eJ2wCIghHy0hsCKT/OKtM0vutLC2gnzheFq5SshhSY5tMOimxW+bZGr4fu4F4z6c7UokYPTsLeUoOLrqAj1yd0cLgc+d2jIIgK6ZSZAMYzyoVFXOA0yIFek/NAbL3Hs4ZhBDY2IPVBPjfgvaPIaCyWZO499n4QPO9F87xauaI38myRlorzBqLRePIrMBoXF86rNgQ5rDOChFaE/KoGX2TTdJO0KWY3N2EpiJ8V4CoAHZv8yeTmkynkKGgkcvAIyNIEkwaDmoBCvIUpPycA9Y8hqgUK8fZbqDSYMyBtDXk8ijNqGUC0Pa53Cso2LImG3LhhgKY6JeWf0t1Q0qg8nqZt9LkIkjy6KWe8OSATCd0BYDKaFNlMuK+dGQFPrdEqyIHNkoEJAEKkc5LQcGHgC07VF6wrbmUtgGhCoWEQgI5CZfDR0Kj00YaaV60A32mDxFnrCSz6QPaIaAbA7adx2bwOFo44h4zXSQFHIzKKlDQdzCzWFhqhooxpuRAko5KZyMbCpC5WU8qBKqgWvAtpqA+X8sH7wrTCo38u2ZN49qS9nFtTBrHErzu+syTh8pr/VAEDWlcFuCMBunaA5kWt3+UAfX+3iaB6OM/n/5/f28zl3yPrC30eko8AbBRRaGWAUqMAgqtWx5LMn5o7HL1ErTvaOSKjlCb3tt0E/fJECXB1UmWTNY7YwihbYz0KFB19uPHq9QoCmQuL4ETGsNIlQ1RCRFzjl2fK5ePLjrcX4+pIinXsOSKhtwTajpUOKgt3n64Ta+LkZ7tQUOSf0plYEuDlFvS5wKAAutAEyd/jGJOJfNsuldKtNJzM/hu9OTgOuQ9zxrNqkzUgDv4gM3guSoLbIaRx2kOkFOcECK2yaiLXG4lBumKpszBBywayxWomK5dgABBlt8PCNiXnPwQQf4f8Hg/5OCyYz8+nnLVVHrKEnhIkCcZI5CDKyAHXRLclh32VhOyOfBAkiakJFLPUlIKKnWmpnPjxUQaA6Uc5hkJ6lguZhgDjAJ2RWbfh9JhJ6Nl88rggPVegVx+sSZnoZKVym1KGtFAytzLzw2RAr8z5qbFSGWxoXCa6tkkQlQgnCHDjAe7biI1JJt7N+bykjRNEBovOqbUWLDrSH2icVQ265kLvO081q3H598553smnblZa1aem3CmhWccQsSsshw0hzRQSkQghgjnNCF5PrtzBeZ8S9k1hEgi+RxAt7y4a00BE5XGNHHy2GWqri3mDS3MS27QC5HtUBd1GkOrmjSGJZmpuGKRecQq0YQkYG+MRuNorAlXm5AiRXJWmgJsUaIgio9OyJaMBUGkK00VCEFmI5+nWJ6WC6jVKs03mbLWkAueHCWCnJIHRdc0r8xkrkpzCY1FURUgRQTZ5OSQxiV5rawZMg/LSpI8t/J3EWJAkoOG91t3tuz+qFVOcB3PdaNyQxjRqoiTnBsobUL9hVs4hIid99iOYwp2fKSk82TTIyLifDekEj2UlHrzdSX6EY93z2vKeT/gbEvc1JPtiEe7ERcdBcr94LHrqRR887CB1RrL2mFZE4daAZhX2eDDMBp8UDksnUvI1ehjQu6MVskpTv6/7Xzii7pJs55KKFV5t5VSk3Xpg44S3BDjI2sI+e7HkMAMazQnGvm9wvEW2o+MFaFpyDqoFCUllBBefh5aSfCsJiCLXBPAAXkZ3L/fReFxup98hvBPQ8yVj85nRFWSytQwWPBsB65eyFpFKCMDM+PjASAAkt402cY9gUYAri6palnG9o3VE0dKpYDP3j0hGoKnNTzpCA8eFx2hxBQgA5H3ElEcipy5bHYDTrj5TZwYAUKK6droXpxtSZ9+5SzW7ch6+Uj0lqOGlKDkfkqzfGNy30CqZhkaUwe1SWtgTl6zcUy5Lg0D9eO0fkwufWL0VVs9kX/s+fp3jJSfd2N6ptKzIJx+HyLOW58aLVsf0mvb0adqWmkqJolziFR5EqnCwcfJdaShp6bPPo+/x0Pk98Eq0/FhgPw/0LFf+pIyCZCRY4HmBMmImC5UogcMcMCEmGgAAKF10ogycrONUqRDSSVRWoTlNZaRiymCnN3gIpAaKiQzJ+e4iB1Lo7VDnjA9l1XkmhRowZJmmFL/MERCGsvSUClNVAY55X1KKFykCVhKeDWOymGpDOcDnjusUhDasRbwF+9vJ1y3yhp0vHDIpBf9TcPNBKOPybK5GynQW9Xsdc8c6F1P3OR317uEakuMJPdRFo2kKpGCvEylELcsGSe7fkzcKwquQwqoFA8eWQTlOw/mLilgSLCvNbvWBdLubBqyVtVaJdUKrakJ7ZB52s5qPLecJY7tYeWY98n0CiUcyixBJBu2ILqVIWmus37AZmSHQ0YfBM0R0xApOUspWqoMMiakPF427Ucg8YAVRB4tbyJpkZVgwGgO1LP8lQTSstim5i+mnZQ0nsGHSYKlFQXZcW9eC11CFd8rczeNbX7xwJWIfQvVzEPGnlrH4zuA6BYrTBFAsoHXqWRNLpvESa4NIWqSNNN30jMTh8p29Hnc8j244Aa6dUscxW6gud8HnxJrgMrNUmUh2hdd48Uw4EFLdvAX3YiT7Yht77EbJPgI2A0Br723hjUKq4boFTT+SGM7qRkoWlMWFSlZANRs1A4eCw4ehPsrSY2U3mWtqLnpM/LnDU8IhPfVIt7vKJd8SSSd0Zg7g533Se5OKiJpzgNJKi/Nef5a4TPLIQGGACnvx1FXahqQlkepnSznvp8c0AnJ5+XfyryQoEkacMVZktaDzCkGcrNmCfr4EDMarnLlU2hUCWxO05kqmDM2F9k/V3m2EggDRNlyHFDLvvfmSYfdEND7iIc7GpPeB+y6kVBh7hURoGZk91QJ6ABgtxtx1o7JeEeB5sqRrB8Msmw62lcOuGlPF8/MarIfP2iov6FU62isYUpI8XOjSEaupma/yuxpdxdJlPCrvQ/wMTKCTGo1faDkd86+A4L6dmPAReexHQgNph4Bem1J66D3IAXTSpGaFcm9ApuB5CKNJqOo002P0y31CjmmHPY+pIZl8RaQ+5aeK/+9v0Z+oxDyhwHyN9khAUcpCVeusjpF0plSUZlcbosRyRpapFaAvNBI+cvZrNCwGYUnifQaaWAAkGgCMmA7H1OAICgTIGoXfJ7AZLOdV2YihyWcNCkd0vcXEmGYBsjgyxYUV651DFTmkvs1q/JmKEnCi0cNBZ1jxCk7/L23Hia2l7PKkJrEmLNbmawadF0Dn79s3t1IG7Kg04ED5XaMOO36vKlFab7kxqckixbTd6VNEIX6gUL6e9ONjCYr9BwsS7lP/pZrkc++sXTcxBdT0G9ZRixGChyryqKxRKOYzy0HyKTduapNQrcqqxNqumD9YnpWxCU2GknjWMaQUln2xyoKkHcsqSf0IKt0skNXKst2Vdx4Is1JI284IwecYq0rHEcFmje1yZKFMpCcyYYFgk5XjJSIWY1QNELM8kRG0bOXgKLkLMtzFIoHgImUVRlcyPdK4B+4ErNPmZBxJQEoIBQOpLEkbpmCsuwHyUOxmexzTaXbfAwRC+bxLity25SmPaNp7sZI2tCeXbg6ln2TaxdDG6lAHc4dNh0pcgwhu0VKsjT4gG3PGzKvS5thxFk3QEMxZYndJPvMze/GgIdbskw/5KTtsKbgYWZNusfSc9E4k9a6fiSq0uHcpYoceP2QhKpcY1wRXAjKTM9yGgjuN6V+0KGgUnAFZDWCbsyW6fJ9Jbi7LCpu5bogCHL5XCWWV7icJ+0jJoHYk47y+2VO5uvYv658yHST5Fuarog/nAP4ki5V8qbLWyr3d7+ZPSLPC/k8gJBlobAA02D40YZk2Mq5ULFqSM1JoVIK99c9zlqPbgh42PaEhHPAdrobiCrgwzRAZqTcMYd6GDw5m3pJcmnNOaoqKOQESIClmTUTtFzoPjNrcDCzCTSRgFh40xIjIJLSxqK2uDFv+NpMAtfoXqh0j1csSyp7lRgCkXINDaCjuUvPrw+0x2+6gO04YozAridqxugj5rWdSKdK/9EpU9c6pnEAFDhvOvIQaD0pT8l6KVU/Uq+h85A+iIHv8/6g83vr3qUI8lNEzX9kAfLf/tt/G9/zPd+Dg4MDXL9+HT/yIz+C3//935+8JsaIn/u5n8Ozzz6L2WyGP/Wn/hQ+//nPT17TdR3+0l/6S7h27RoWiwV+9Ed/FO+8887kNScnJ/jxH/9xHB4e4vDwED/+4z+O09PT/9aX+FTHZQ0ST3uU1AYphwmnTD5VAgSAu9wR02tl0ZzXwiXkxgnkzVaQYLHvdVontx05qHFiGiDL+wDeeJK+qUobpyAZsoGXQXvgYFYkaXajT4lAQuxQZPyYNilFSKCRFT08Z8P96DMKxOVwo0ntICBP/hAiTrYDxjHgfNsntFMrhasLhx1zs6Tsl+RuePOSxjfPE7cfAuZOpwA5RiS769NdLt/LnRUEuQxilFKouDSvFLBtx5QwSMOZMRpty3JCRmO75YSGgy0JFOVZyb9vHTj0hdVvWmhZ5cAYjUVjyXpYKywWFa4uKmhNlsaLiprptCIzjl36rMgoLX3mbvSpAQrI5UIFleSXACqJk3xYxBhpQSR9aeGAKnZgY0c5bTDnIEjGSEr4uJIid1Ke48wYKHDiwL+rTEbGBPV2LA9XNmEZpZOKTLm0bnghl7Eh6IWMZ7nfpfyRBBfSkCvBiZTNk045BPWmhhgKkCXQUUlajsYRbUpybZeV+qe8/elalBDyEHEwI6m3w9phxgFy2eioVC5vdz4wCpwR5AcXHdqB6AnrISPJu96TKUHvJ+X10ZPT5LbzJM3Y9TjdeZy2IyqrsOs8LtoBXe/JXUtK2J4ag6zWOJ4bHM4sVjMLBbLVLoOs0RMynkrJnhJWUa5QfO2EINPfOZDP0l3AtEG5PEJ8PHF/mkN6CuSzrVHog0+Ib9a5lyBPYcXSjOUamd5/KUqYx9xj581j9YN6a8r3ylqdf7f/4uLfsQRYkLj8qRqJmPjDIssoQU6p0iJzXcCbXLVgTq18XZxytEnrW6eqpIAta15PhYPtPVWfDmZkltOw/vrJmsZjO3ictgMqS30dfU/UADKzyPM9cHBMtDhugB88dt1IdLtINyXEiFvLJiXhmtdLUXXxnIhLcO+Y7vTs8QwAksSdIMtCr5Axbq3G4czguSuzRGUrlVeMyr05x3Ob7p300ohiTm6sVYlO2XvW6e89tow2b4eAnWfHWkZ+5flIs+39XYfRU/Vny+Dbpvc47Xoo0PVf7CgRLqvHgiCfbYe0x0rVaX/IlQiymIx8I8cfWYD8q7/6q/iLf/Ev4jd+4zfwK7/yK7DW4gd/8Afx6NGj9Jq/83f+Dv7u3/27+Pmf/3n81m/9Fm7cuIEf+qEfwsXFRXrNz/zMz+Bf/+t/jV/6pV/Cr/3ar+H8/Bw//MM/DO9zwPFjP/Zj+OxnP4t/+2//LX75l38Zn/3sZ/HjP/7jf1SX+r7H04bH8rr9hg5BEySYEc6WLGxjEQClhZoXJ2v0ZKCEOEWDlcqe6aIPrBVtYH1RKgqIqbFFAQkhLoOwloNqQhAzsgQwCqWmC6vYXArXdDf6ZMks75ss7sW5ip6iTHRhg5BaAQXAJUUkRgrwRX3grdMuBTbSbCBSNhIQvHKtIbk15i83ziTjEbk20kA2aXEcPXUBl1QHHwJ1PPfTjmsFanzyxWvlmpeNTdcuChzyPMEBugS6zhm07cABrknfLe8RZF6GwTBk9QPwOJpXovNJDXrHM8uOVDWuLiybw7AtMTc1nfcDtkyNaItSO0DPsnEqPcvAzwoq225HkKGMbJzCa98vFVdGQwOsGqKzsgIHb57d32rNaEgROCgQul0MIUKlnSgAZASZEOCYtGiBAslHburxMWLd0XX3Y0gNgQq5TC8Ib4kwC2Ipw1IqGuVGKN8p5ydc3YQaqYzoUVCH9CwluCsPGeNJTlI9Xm6VZGrZkA7s4dxh7sj0xIfIVs20LoiMmw9IiiyK58K6HbEdaA6vh5FszzmJ6j0FFVI+7nijW7cj1v2I3RBwf9fhtKVG17nThBy3Y6JFeM826z6mgGLFJidXmFe6rGxaOyKPRzEoASjhGHwoZCSRknqhVkmVTYIQoRmIrOD+IdWYpz0k8S1RsNzMGNOaBkxRMK1yg5szOimBAJgEuroYY6p47/4hQecH9c1Mx8tewLwfIcfpP+WcyjVJ3lcm6GMaRwIYsDW7mmrui9JMrhjmsR1inNAvVo1NetylPbFUZGS9kCDy+qqG0SpJAp5ve1zsBvSjx+lOKoMUIO+6Ma9X6TuR1rHjGdMXWX2IgBCktaKpDIwiIMUazRW37CwniTNA484qcSONabxao7GqXLKo10rR+upI4/7KgvpFls4llaTy3jujcH3hJo+vHcIk2ReoIAfIIVVytsOYGvo675n+5CfPeeDrP2l7rIeRgunRIwDYdAFn/YCz3YjdQOo0YkO/G+gZ94FVNbhxt+cEt0yg5PARSbZOnvH7CSQ86bAf/JL/Ose/+3f/bvL/X/iFX8Dh4SH+03/6T/iRH/kRxBjx9//+38df/+t/HX/uz/05AMA//+f/HDdu3MAv/uIv4id/8idxdnaGf/pP/yn+2T/7Z/ihH/qh9Dkvvvgi/uN//I/4M3/mz+CLX/wifvmXfxm//uu/ju/7vu8DAPyjf/SP8P3f//34gz/4A3zyk5/8o7rkS48/BID8OG8wBcu5s7rMpmRwShBcBonyeVKKEqOEiQsPf9/AHEEJxn1AkmC5bCP2UbpSc+d8Wa4ULcRyvMoGoTUhhkMIWDiL7YjUDCHXLG8rg9MQY/pF2UG/H3Bu22ws0DiDbTfiISOuMRKKJZ20skkarfDJ4wP0w214/vmssjjfDcnBCKANTcrtPtLidVE0egnSnDUzKVlQxbNAeiZ5k14w30wpcnyTwF34u1qrZBFd1zaZhVhnMA4eHjn778VpLZKwvi/GS+RgW2xZnTM4mFV4ZjGD1gq3jmZY1cTrJF1iJBMZseDWIOMC4gDTOfU+Ysals/RdKDds2vToeXOjV8hubGNkWouiJimA+KRitZvuGaTxJMtvSQlX5khjNTqfI4byPmuVXyfd8qva5oYXQeL4eyipCdzAl5GuEjk2WqGToLoMgnRuOh1DTOX7mhvGakvIulFE7zln6k/SMtUqbaIyniNi4vnul6XlnkvApUL+/vKcysNpjRsHNR6te9SOKDQkh8bWzVKSlcpHyNSgTUf8wuOmwnbjcbIZqAFz9Oh9xKYbsRs95rUltYp+SMH0pgt4Dz0uugCnI545cJxA02cPhhRdJIDy3EdRGbLJPmD9aUG9ZXxEADOncaFy8DJwUly7fC1SkZNKhyCaUlkAByzdXgBQ3uNS3ur9Dnl3uXkLD3wMYcKjLw+lVLKWrjRVHdJcCEUFQuWqSHrv/jnw+ZYNXE86Jp+zt5kl9DkBFLnqCeT5I0mybEcCxMjeJlzciIz8yyF9DvK+fTUD+a4YgQWrIIyBqEcbXtulmVjQ/hizlbk8zy+8e47AwXKMEdt2THvDuvf46HGdqBSStBIo8fj9e/aAEjapeow+sKQaPat7F236fjLGCXCpUkP3rXG8JnNF7ZxpCjTOgNqoiRX54Gk/ryqq9N0+aRFixNLZtEcpRbbsPhA3WSp1gOz7Ma1hI88xugd57lDfjsdmoKrxwNXjzofUzFhKUBIC73FUD2hZSo64yx7rfsT5bsB2IOk4oddtuxFaUUVxx709hNgHjD5XV8ojRgrgFZASknLMPcZRfsLx342DfHFxgRACjo+PAQBvvPEG7t69iz/9p/90es1sNsOf/JN/Er/xG78BAPjt3/5tDMMwec0LL7yAV199Nb3mN3/zN7FcLlNwDAB/4k/8CSwWi/Sa/57H01AsyoBu+t5igYolfyg395SLidAnYswNDWVxmBahOGmEKxUV5BzGEJNuI20aEYdzVyDVUw6XD1SSkesYA71vZE6mM6JeENP5i4uY5eBrCDSZJdAUtESuXc5V7lcRH09QR+FLyeZ60dLCQpxF4mxdFNxQKoNnFE4Sj8/eO6VslRfkFTeoyUST+zJnGoF05Iu7k3wnwJu8j0kFAfwdpfyRfK9hpQYpp4vxh1IZmQeQAt353GEcqTQ7m9EzCrzBGzPV9r3oiMtZ0l3IzY51a53G9ZXDd794DKUUvvv5ZTovQX4bY5J00xhpjGSKRabYzJ1FO5TJl0qLniRLx9yZTYleligUC2ZpnNGK5IQE3ZdOfsvub5XJKKGPuaE00RV4My71BzSjVwp0b4krGyY8T8UBtSDhhq9NUCx5HGRHTeNRrq1sxgSQmq9ksxJ5MYB1om0OfBc1UQbEZCPy+YqBRBnonm2H1CEvaHd5hJg72aVpMd+DqUauMxSwV1Yzdz+yjbyBVZk6JcohaT4COO8HtJ4knXbM01wPA9bDiG6MuGhHbAYKOLZDwEnX46TrcdYPWPce710M2HRks10ZjYEdBQcOMtKcj/R9kuQkJzGVDWBkTgFTehmh3kT3kH6CpExRbKTSMU8I/9Qtb5/bKMjgU6NVxRoth/CNfXz/jZzs0ZFcOeVZTpFmxY6fRZB8yeYSIs39/SRp//ggjvL00qZoern+yU/lvGQ9EN3vkmJRoutNZRKfulQbocvKChwhRhzNMyK67T1LIWblCkFCx5DR5hAiTrsBb55tsOlHWA4adzvS96WKQ8BHDxasVhFTMy6tsVmzWdaLVU0IcoxIlQ/Zr0KIuLtt0RgCnKR6IHuhBv19yC6KjaU5v27JFVf6dpwh51par2itoDWcuNfdGNLP5BFrJQkAzfWzLu+NpfJEZRXTV6jhPoIaJUe+fs8Bbj8SsNSNhCILqEW9GCzFN3ictyMuBqoUkekPUSfOW48HO2qG3AwjIdGefu9YXo4+N6Q9WiTzLlvnREJu8LRQlHPyMk7yZcd/twD5p3/6p/Ed3/Ed+N7v/V4AwN27dwEAN2/enLzu5s2b6Xd3796FMQbXrl1739dcv379MWrCjRs30mv2j3/8j/8xvvu7vxvf/d3fjbt37+DRwwe4994d3Ln9Lk5PT/C1N17DbrfDl7/0BYQQ8Lnf/ezlF1Xc8xgj7tx+F33fYxgGvP3Wm9hs1vjql7+EcRzxhc/9LgDg9/7Lb0/+/tIXPoeu6/DO117Dxfk57r77Nh7cv4dHD+/j3p13sNte4I3XvoKu73D3zS8BAF77In3We69/nrhDuw1ijHh0+3X4fof33v0a1ucnOH90D/7iQbomP7SIj96GVsBXvvC7gFKwD14HAHz587+LGAPO7ryGMLTYPHwHw+4CWD9E1Z7h0cMHuPvuW/D9Dtf7e9Ax4Oz2lwEALw3vYggB73zlcwCAV3APNnqc3v0a3LjDQX8C057D+xE1POahw6M7b0KFEZ82DzB3Gur+V7GoLeyD1zGEgK9+6feB4HFy+w147zF0HTbnJ7j33h3cu/suzs5OcPutN7Db7fC1r36Jyl93vwIfIr5v8RAhRvxfn9mg3fX4E0drzNSIj5pTXHM9bsRzvHo04sWFx6uzLa5UHt85P0djge9dngIA7P3X4X3A/+XmGlopvKrvo8aIT1ZnODQDnlVnOPAb3NRbfKze4ood8ZnFBXzf409d20AphR95lv7+7vo+Qoz4yHgHlQpwoYdGhFnfR9ydY3f+AM/bDZ6bB/yxwx3i0OH//OIIZxT+7I01Yoz4/tUjDGPAzTkQfcAPPNPhqI74E7dGvLAM+J7nDL7jlsLLhxHf+0zAzaXG9x5toaPHjQWN0Rfad+B9wI88s4HVCv/r9S0WNuJq9wDXKo8/dn3ES02H3/zC6/iOKwM+PteoL97D3EQ8N9wBAAzvfZkW3fuvYQwRn4jvQYUA/+htqKHF8+oMrltj3p/D7U5wrFscdQ+hETDDgG70WN/+Awqw732FAst7r8GHgNnZu+jaHbqTd1GPW9S7E+jdCZpxg/XD2xjaLS7eewMheIz3XofTCjc2b2NmDE7f/iKUUlievwsVBjy88yYwbLE5uYOwPUW3foQ49hjHEW+89hX4ccDdN2g+3Xvj89RMeefLeP7KDObhmwh+RPfgLZixg17fg+vXsLtTDBf3sLk4w8WDd9C3O5zdeR2993jtS78HxXMzxIhHb30RIXic3Ka15OGdt9BvznD64C7OH93HxdkjnL73zmSN8PdfhzUKv/dffhtKAW/9we9h9BHnt78K+AEPbr+JoV2jPb2LcXOCsD3FnXffxubinH7Xd9htN5P15d2vfg7Oarz+B7+PGDzufO2r2GzWePutNxG2Z9id3cfJg7s4PT1BOL2Lk/M1Lu6+gZlVOH3nS6itxuLkTTit8caXfg+IEdd2d6F9j/7kNmLw0GHE9vw+hs0pto9uo9ttcXr3dWy6DsO919D7gAdvfQHrYcSd138f2yFgvP8mzrZb+EfvQvc7LNtHWI4XOPBrjKf3cKR7fOdygxoef3x5hhgjfuCY5uby5E2aow/fhIoBX/jCF4ChxcWDd9GuTxD8gHHoMWzP8bU3XsPQtXj07mvoRo/dnS+jHwNe++LvAQBdEyLW772BMHR4eOdrWJ+dYHvyHjYn99GuT/HgztvYbNZ4542vYBxHbDbrfI9jxBtf+l34EPHFz38Ofdfhjde+govzc7z7zlt4cP8eHty/h3ffeQsX5+e48/briL7HO699MX2GVsDpO19EjBHvvv4FjOOIr375S+h2G7x3+y0Mw4C+73D24C6qYQu3vocwdHj79T9AjAFf+L3/Qp/1O79NjbcPXodRwO03v4yha3H/3TdxenrC+1OHYRjw6O7bGNotbn/tK++7P7325c9/4DW9/cZX6TVf+QJCpPcqAJ/nffP261+EHwe8++ZX0Lcb7B7dgWov0F08xLvvvovNxSnuv/smMHQ43NyB9x7tdgMF4K0v/x4CIuqHb0KriHfe+DLi0OK4e4gj1cJtH+Hee3fQrk9x552vYaEGvIyHWG9b3H3zi5P9Ut9/DSECHw330PcdXq3Pca0asX14Dw8f3sfF2QPg4j5uzQO+53gHjD2+Z35Glsz3vwoA+HMfbeFjxP/pygWcCvi+KzvcXCh819UBz1Q9PlLtsHl0Dy8eBHz/sx5zDPiO2RkAYIGeguX3XkNtNc7e+RK0ilCP3sZCjzi//zbG9hxq8wgXJ/fQjGs8G8+AscXtN78KRI8Hb/8BnFH4ZLgDpYA7r32OAIZ2CwPgfznaYdxtcX7/Ng7DGicn93H73bdhxx2+ZXaBuYp4Rd0j+trDNwAA/4+XOxilcKu9DR0DnhnvQw8dhrO7OD15iOHiIdqze9DdBt95uEMVexxt7qL3Ad9u3yMpvNtfxugj7rz2eYyjx8N3XoMNPT5RnUO3G4xnDzHvz2G6Cxz0j2B9i8XmLs7bFte272LHc3MIAfff/Dxqp1GdvoN+6HBy9030uzVO79/G2aMHOHv0AHfeeQvjOKJtd2h3Ld557YsYfcAf/P7vwIeYnvkXPve7GMcRr33lDy4N4faPPzKKRXn87M/+LH79138dv/7rvw5jzOR3+whrWaJ50rH/mste/36f8xM/8RP4iZ/4CQDAd33Xd+PK1WkAfnREKPcrn/o0AODbvv2PXX4ie+WnZ559DlVF2eoLH/koAODjr3wKAPDpb/t2AMBnvvO7Jn9/6tPfhtEHfOSlj5Pn+mJJklNsu9oOATeuXsG2G/H8y6/SeX3LdwAAnv34txKHaraAUgoHN1/CeTfg5jM3MfqAq6saXzyzODo6xurgCKebHuH4BVij8dK3fDs2nUd/9SXMAXzklW/DxW7A7MZLGB6ewx4eoZnXUKPFdtzi4OgKUB/g7mmLd8w1PGMsDp99BY/ON/iyfhbfESNuvvwtePdshy+F6/hua7G49hHYiy36WMHMayhj0SFgsDNcffYZAMBX1Q18xmn0i5cxrw02xx/FKgQ8++Kn0A0e155/GXpHTm3zxTFuXJunctPq4AizmcMnX/00lFKobn0C8c238J/WV/DyHPh/3V5gHAN+/WSBZ69aDMsjXJyuca93+IPzHbRWODEVtsOA/7JdwhmN31wfYVYB/9/ddXh/gv/t9gIfuaVwsnwOHR7ic9sKV1Y13lML1Jrsst+4F/FwaLG+qHH9QOHXTlYwJuDfPTjA0VLht9rruFkDd5tn8ZJz8Kai0tryOqxzqJoKd+IOd9oW202DYwT8/tsOVaXx/77bIMYN/j+nR/iB5wPubgnB/I+3a5x2Iz57NsPXzrbodhGfvjbHVx5d4CsPga6N+J3tARaNxr0NMJtF/I6/Be/fxC8/OMT/elPjf7vT4MqxQXXleTwaX8ej0eL7l0e44wN+/7zC750NOHPX0IX7uFvfwPNKob/6MvSd+3C3PoHWB7xdPYPnrUV17QXEXYd3cYi5a3DlyhV89uwBzmOHk6qB0hqdrjDEiOMXXsX6YosXX/kMHt05gb7xcYR3z7BePYuoKwzLG4j9gGYxI9S2XyOsZtBVjdm1F+EfnUNffwkGCg+WL+B5Z3D40U/j/HSDi9VzqOoGi4OP4uGDC8xXc/huwGJeQa8rWGvx0kc/gTfvb3DjlU8jArj18rfgZDNA3fg4AMDd+BiMdWiuvYh126FZrjCcb+EWZAOr6yZVwg5uvYzTrsfHPvUZKKXw6W/7Ttw5bXH4/KeglMbxsx/DbDbDSy9/DO882uEjNxa4e9riylED1AdYLKq0RtgbL6OyGq9+53fhrQdbPP+Jb8ODiw4Hz34crjK4dePjaJzGnbXG1YMa98I55kcLVJXBs4eHsFphPl+k9eXdRzs88/K3AgBe/ZbP4Eu3L/ApXkMWiyUevnmKxYyUSmYzi8XV5wFT4fmXX8G8cTh6/lM4Pd+geeYVAKBrevchTue3cGgs1HKFqAxGROyqA+J7Hh1gffoA54slTABw/BEMJy02xy+iGz2u3vgE2q8+wNfmN1H1Cr2+iofjDm+1M4w+YF5bmHGGO5sL3O8MnFP4T2cHADb41bNjvLoEwvWPIa7P0B6/CKUNbn7k43j9zQdw8yNqcooOUEDVHODFF4/w5v0NFjdewnoYYW58HKOPuPbRT2P0AS9+8jPQSuHKcx9D5Qxc/QJ8IE52NwRcOaxxcHQFi7nDRz72CtkNL5bpHj+86PDyp74dEcArr34rjFZ46WOf4PXp4LEt45kXanztwRYf+cSn02ecbQfUz7yCuN7hmZdehbUWH3/lU3j74Rar40O4E1bpqG/Atye4fusY75zv8KlXvwVfeOcc38L702e+g85H3/g4KmPwkY99Cg/XPa4ffxRHqxpHR8eo3iGqwNHB8zhYVTg+/CSsNU/cnz756rfSfvE+11TPl6isxkuf+DRCjPi27/hj6MaQPuOZl16FsRYfefkVtIPH4Y0K6/Md5vMaV67N8Wgz4MqVK/jyG/exXj0DKI3ZfIF+DPiO7/wu/O7/8TUM116CNQa3XvwEFo3FWXMV5xc7qOVV3Lj5DO52Z2hmFhfhDK/jEGPUWD3zCTw83+DKRz4N/OffxXDtZYwx4EvhOj41Knxuu8KdzSN8abfAsbI4qhbozBx3Nrdx/22Na9cifv1shY/WAacHHwFwG//P1yo8+yzwqycHePbY4H8/X+BB1+JzFzVuVQ3OlMbBuMDba4M3zwKef97gs9sl/u8A1tEhhICvVc/hW6zG8tlPQikNffVFxO4ct55/AXdOWmx0gxs3b8K/1eHCz7BcLuHnC6zPW1x94ZMw7zzEnfnz8CHi27/zu/Fb//kNmGoGNY74ve0S88HBrK7jnh9xbud46fAI4ewBvtgd4P+2WuAL/hquR+DL+lkAZ/g378zx7Z9QeLd6FgPWwPFz8GNAc3wN89Ucrq8QI9B15/jP9yt89DmLN/UxBj/gf2+v4bt8hL/2MjUgvvwtiFB44eVXsHvnDbx2McfL8xqNrnEn9IhweBAcHnZbvIlDvDACb+ubeG4IOLr2MtHPbn2CdNUXz+JIGbjj51E3FnqxosDZUtOifYccX2NV4fmXPwUfgZc+9RkMPuKjn/p2aKXSuH7xY688Nm4vO/7IEeS/8lf+Cn7pl34Jv/Irv4KXX345/fzWrVsA8BjKe+/evYQq37p1C957PHjw4H1fc+/evQmcHmPE/fv3H0On/0c+ys5j+kcuGwLTpofkgLSXAEip2zJvLsbstjX6kKgIljtj5XMVstj9GMQ2k74/gkrF56xxSuXEvQY6ZGtIqY6RVTW5U0lDTFnxE6tNpxUWSac0UOcq87aEJxq5PhWBVBpV/EeML/I9yEoBIcTUzBYjOXWJq4/WREEQ/p7RZA0s1yLcK4AaJYSrGGNkEXp6zxHrOauCNmEMfba1YlzAzTNaJTqASGxJM4IcSlHDk9xfKZ2LrjJAjXbCgbu46NK42S/zkoWzSc/tYjfAe09W0UuXmsqWFZUE57XFEAIebKgJ7fZ5j34UKg59poi6z61Nz1cc1+Q8lFI4mrukuQ1wEyjY/UrJ8yDL3CT/pMhEhmgYOjXYEW0nogukiCB6qRWXN5eVnfASpXwqJUlRjChni9HEKxXO3RColPjOo12iMShFPGi5PnE780WJVimiGAlFRylMysngMbvvVAlgr5GU5m5lNTbdmD5HeM7S0Cc2vItatFRDusZ9QKA8Fzm38vtE7QZAkhgTTWTRUm+Mwco5NMYkypTRKm0kgVeYdqS5e9r2zDFmrVQueZ62Y+pc3w0Bj7Yk43beevTsRCkd6o82Y3KSlLUGoHK01Qor53hMMieZaSjyDPdJtyEimTUINWTf0VDoOzFm+bzI4zY/t8sBF8U3+qloFvyc9qkN8tZ94Ec+UfoUtJJzYyoJ9hrpdHabTOPrsXHB/Nc9hYPLjg+iWJTqMHIdsm5PvhMFZUnoBEql8S3XkhSWeMB2hYqLXI/MvaS6xA3W8jfAlC1etDbc6GyVwpYbr0Vv2/uAR+sODzcDeh+SwtEwEB1Nxtg75+3ePcz7sTEG1ho4S3Jxpzs/Wb+1Ao8P+nPRkRFX4L3VaZ3GttGkTz56kiptmO4knHEALKFJRjJn2+z+KQ50p63H3e0OvQ94tBuSAZJWCtdWVaJS7Lhx3LKspzy/G7OG5R2n+vHye7m/sseKpbT8LoKoMdLbM/jAuskhuQ32I1nIC1WjHXkux5DWooHlYzvv05iV+SljL804VdCU+ERKig+NwQ+mC/2RBsg//dM/jV/8xV/Er/zKr+BTn/rU5HcvvfQSbt26hf/wH/5D+lnbtvi1X/u1xCf+ru/6LjjnJq9555138MUvfjG95nu/93uxXq/xm7/5m+k1v/mbv4nNZjPhJf9RHN9I1yQwDYT3+h7yQhMLPrK8VrhzxdcqRcLxwJSf7ENMphEVT2Q5hLunFDVIyQAkni1xiVrmvwnP7LJLzQYimR9nlU5Nbar4PpG1UYo6bRUogOvZzGQseIDlV8k1SSB2GbdIAlIgc3VHH/FoN2LBvveiASxcXatVauaQ4E2eZ20N2iF3T0vDmlLAUeMKBRAKyGprUDmT/ja8WWlFRhly/eJi1fns/AfkJAAgnmAIER07oiECw5CD982mp2vWChcXfeqGE5mqOfPhEIHz3YDIAdCrV1api1psTJeNw3nrseakYtNlfqB8nzR5Ltlm2miVjBjKxqYry4rlATMHWGvSLxbd2Yt2RG1Msle2WqP1FFS54nOTfBPr78YofDoDoylgKBMEkZeT851sumkMstMd/3uM9LkXO2oWUYo2CKc1ZvwM55Z4g2OMqclLvkNUNQIHSpJ8KJXVLCSQyfq3+TxpfNHm3xZJncxFMZSgc5emRJUa5kqt08sOumfTRFIXQfMwhnReTXqewNwZzKtS9k3Gf9G9DySZx7N+QDsGbNjgQ9wiz1uyjT7vB3RjwDkrVqx73kBZDsuHyIlcXmMyV5sCievzOgVWkiyFGFNzpxyiNCKarD6GlPDvJ+AULE5l70qpMbkflx1P05yXzon/PBYgQ8xcpq9PQUcaT4oDQfn5dP2T5FscEqlh+vJz0So3Ej/p+CAZuDKBKefg/tu0rAGy9rONt2xR8nJpYiaeMsnhSW+DgDp1ESDXRqf7IaoyVtMzHDmAEiOL2hic9T0lYTtS/gkh4mzbk6QgJ98AN9gNEiADj3ZjCngt92PI8zBGoap4vRfDId67pJcEKnOQt0NISkwhEM9fJBclUO4GbpC1BDaUAbIGKQ/5ECd7hQIwBrJrv7shZ9jz1uO8G9I6cv+cFJyG1DiuUNc2fXaMER+7tkiJYYw5STRapd4h0TaX4Sc9TPIemj9IFtz9SGvkGLNnwuAjtj3roPvsLNsHcqUdOKGVvhUAE3WKGJFiH61yH1B5JNlGPHn+lscfGcXip37qp/ALv/AL+Df/5t/g+Pg4IcXL5RLL5RJKKfzMz/wM/tbf+lv41Kc+hVdeeQV/82/+TSyXS/zYj/0YAODw8BB/4S/8BfzVv/pXcePGDVy9ehU/+7M/i8985jP4wR/8QQDAq6++ij/7Z/8sfvInfxL/5J/8E8QY8ZM/+ZP44R/+4f/uChZfz1E2HgAz38P0AAEAAElEQVQloky/j8gLUBloTt2LWDFCGvhC3mAl0AH2A4icecrrZEGS75UmsxlyR/JlotujD2mTqooOWbG4LZFvwxmi1QqryqL1Hhf9mJq1ZNM3OsNgClneS358WaAu0nEAktqDD7RJX5lZaNCi5hwFy4aF4he1xUOVrVHl/ldWo2Ub2NFHMtLgc7gxa8geVqmUsJQSPTVn540E44oCGzKkoMVwU3THlxrKIZCMUAgB4+g5GKEmvBDoT7sboLSC1hrbLQXLJY3pcJan/MVuQAhktS020KKkAFCguR1CsnAdeEFTqlCNABhtzsGrjDfFn+e0wsmm50U9PxddjK8QyVp4Zk3SzbWa1DGou9tgXluctH0O4gQh5DEk2t30f6TnNasMtp1PneNaZVRBkPdS05USR3r/dsga2hKIzmuTOssj6LNqq7FR+TNkAxuLwM4alTYGIM9tCXLKICmPt9wMBxBCC25o0sUaISYtgkpZ3oT3k4BUfYiPNwLLBk+BZk5cBanTitDzec36x2NMgQGpchRGMAEAIrbDmDY+pRSWYBm43sNphYuObNhjlI581hEfPMD63+ISKc9TjBdqR5Wbj1yb0/xAVqsQdElaMSM/v5bnlmy+cgw+YlbRM2oHUhWhBMRPFCLk2Ql6/hhtrxgDT9OQLUlTCVCUAeYEQS7eJ8CGBjmv7RsjyCF7QsU21vufc9lB9/rpg/zy2FdBSv8ur0PlhlhA1gg90QyXQ4IxeX8ZhJVqDPK5TussCyf7hJoi7533PMYDHmypD+K8JVTSe1KsmFW2mKdA5GBL1pdtH6B4voj5iSSsxmg0zqCuaJ0gBQgFYxiIkc2IA/JuCBzM0zpYsQ625880SiW1pJpBjhjznqoUMGMJ18k5AxhHSjbfuxgweHK92wxjSoLeWxNy3hUIu2XHTLnX0oSs+P5RYJxVlARok/trVd6Xi8eQEGaJH1IFlM0+QiDpttFnL4DI17TtxlSRHhncS4JMvDfK90hVIsQIxeuhjDVJpJ9mbgJ/hAHyP/yH/xAA8AM/8AOTn/+Nv/E38HM/93MAgL/21/4adrsdfuqnfgonJyf443/8j+Pf//t/j9VqlV7/9/7e34O1Fn/+z/957HY7/MAP/AD+xb/4F5Mg4F/9q3+Fv/yX/3JSu/jRH/1R/IN/8A/+G1/h48c3CCAzkjN9gOWiWb6uTJAIJcyZH70m/182XdFilJLEIcsiySdL9koTIv9M8WQHGHGBoFp505fvTRsd/1y6yyOyDbCS7+HA44KpBMvK4mHbYzuS69DI5RopFcq5UXYa04QQ9Gr/sGxJLOenefJsuhHPHVaUpVuNqjJJxq1xBlfnFm/xZ0hCoRSwqAwGzxaYwbOxBr3uyqJioX+dNvJZbaEUaa3OKjIvWFS57C+Bl1GEsIuDUSj+AEAIjOpF0S/OP09ocj+gaipAIcm9GWsg0j9yxAhstz2CD7h1NMNv3D5JyZYERLUzaBlxu+wot9FyXIoSCEBBcGWy7bA4g0lgLZ3kEaRMcX1e4+62RYiE8IhxiGNEXyF3dousWIg5MNeKUKba6VSipeeQ9Z+p0oAUOE064ZHdvJQCtuOYrIu1InOSxhEtRpKCdK06B+iyubVDVkixRqfOamDaTd6PAXUjQv0xfb8gHuVaIuihHFqBpeZobkTw7/f2AAmoacPLCFAps1XOeVG5KJPzxpEzl9heO01IXsVKCQLaitTcRe/Redr46mLTa4cAb1WyjR7GAB9NkvEaCtteCWolsJrVpMXdOIPGaVy0YwoQE2KPTCNRIBiL1ElCUupJpkVgq2O+XnH0mldmUrIGsjtiKXtZHjJ+1OO3/9JDHmOpzasAlvjLslRy/+WIEViyHON5PxQJ3+XfI9Uw+pzHz0wSK2C6p3wjx76KA5CvU9YywzcoxgyQaDU9f4X8O/m8yOcnyfc+BaXmOSb7gufqkwThg8/ube9ctHhvPWAYA87aMaGOu92AXWOZ7qD4vENaH7USEyCdVIbGkCU+raUgds6ya2fbkHXPDZsd8QXFCHSjR8fqRCGKWg+de+10WnuIkpevt6wgNdakai74vgWeRzuWMhVzjs04UqMhgJOOAmRBsAXhpgoMzZHXH23SXiZrZYiK6Yms/c/PLUYayz5mrwRJBOT5y7ov1YwxkDqUmGRlih2vpTESFYbBBtHHVyok1Zjd4GEliUY28pHxJMNE0GNrHp+7lx1/ZAHy09ANlFL4uZ/7uRQwX3Y0TYOf//mfx8///M8/8TVXrlzBv/yX//IbOc3/IY7LFrC0Se39rMyGFDDxm6fX0N9ldtkN2UISIL1I+l56TlZp/tyMDFfMIZYSkwQ1Mgj3EQyjFEvB0I4pUmWibTuEOOH3WKNTplo7kpHqfCA+pyAGJgumo7guEUovs8jy+q1RaJwgFLmMOPAGb4yGZW5XO9AkrqzB9aXbQ0EIHVjUGhddQG3JLGReaWx7WmAebjqy6dZ0rkap5N5ntcbMaQwhYlWbpJGsQMGobrP02chBr/fZKjoEud9xcq0xZBk7zxJvSimMwwgo0sLcALRQbnqgoefatoSkPHvg8NYJLZQRwLbLFA8f8uLi5P6pHAjK5lXK8J11w+T3ldHYsui7jAMZX8LXjTGiDZHNJ+jK5taQkHxkF7sCRbRKo49jljzjEq1hNFXGidEihzWdU6GMkDGt2IjNuoJijrSgWHQPRK90VcwbCTqzqcPj5WpnFDpOaofCeEdz8lIu4nIkExxM11B5r3yOSOFJ0npZmV8S78GHZN/d+4BGm7Qxyhog1yX6rBri9EdyUu3gcbEjmkNtTC4Lh+ka1Y6Mko2BKi28cVM5l5qOhzEkSah03WNEVfH5CiXF0FxdNpYCDWcwdxoPLzrabOXZxhyg6+JstKIAdz/hI6pPSGh5CBFNbbBosqnMph2LwDgnVftLtaw38rkfdOwHefQZii2DL0Go+YgArq5qKAA774sEgcrsghbLlTbOTJ7rZZ/nY4TDN04NpO8HrCR+kglPfp8BDflepXK1AuC9rlg/9pPBy86P9oHs1irXSQGcSlVSsUUHgLdOeirdjxQ40h5C5h9SZZG+hvT9RRKstOJ9w6IdPBrL1QBHcmurmihfFy2NW5EJrKyZPINhzFxnCRodI8hz1mGXtQ1GJ6BLXDcB6gHhWDQl0D4AfU867euWENh2IP5vy4nieU8J/Bhi7kOKhXxaBB60HQ4qAtGkMhZCprhI/4Mc4sRK2tOe9hSmvYQgUqD0Wsc6zN5nr4QEOPC6K6i/zFsBVWQsSD/REgLqRXbxk3Urr0llj9HTHP/dZN7+/+F4wtr2DR2l8DuQF4lJxq3IFawsrWqVeXcywHoW5y5Lt5tunJS86PPyBUjAIW8pNYCltAnkUqYM/BJBFqRGK0Kiy2VuxqisUhRECUIoPGalkHh0gCDIOdDaX0jzPaHFacYBMm36jFIxx6y2FCAvG4faEoo1rw2eXdZpA9MqB9LiWT+vbQoANScEtzc7zB2hx7WjRo2jmUXFTRuzSqMyCkds/kEbG+nuGkYARV8yRqJXSGCf6RZSPs4HIc0B3udgUILlhr+rGzwecRNfjEDfj4gh4s1HHR5KqW0gLUogu+5JI+OiLl3tZDFX6X2Rx8HFMCR0jkTsKdDVHGBqZDpMiKSxHQG0o08mDwBwVFepVG4Ucy2RNxBBOBSPN7kf7ehTMmi1xrbPAX9ZCpTxSq/LbpI1N9DJGJRpIChONwRYTsoUKJCWRhLhksv3yGfKdxiGyUTIn8aoUE3o/1KeVKDAtwyO5SplqEuTo5T8yyTQmul8KI0YAA4MizVAxrpUS0rjEjnPeW1hOTgV+szcWjTWJKOB8ltHQYT4WQt9S3RZh0CbcT9mfWMyvqFxPnFO4yD86sLBGIWDxmJZG5x1w6T8LbQd4Y4LWidVrSlKqVIwIWvIhN/JnymNkhJgC5Xj8UofjYun3YAvRaGV6OBONZclYNh/f+994mLGyOh8quhRMmx0puFcdmaSdP9hD1mPgYwSy3kAUwRPfiHra2piK+6JmErJeVdm6gabv5f+Fj3yiOxi2ViN56/McDCz2LBZDQC8d97hbNeT61tPWrsxxNSQp5VKTc1yWK4OGqVgjEFVaSwai8rRvmCUIve6RYWjmcFBw/bPzEtunMGyNqlyAXDDaAwod0RaX8Gvpb3PatKBbwd2c+VeCwBYOjFFyeuaj2Rk0g0e226EDzTHNr04vFJfieZKUmXpeY0j0Z76kcbUyXZExeurZ6Tc6GzadGUhQAGdy9ySVvWVRZXeU1LABPmmSq3sbXwexb12nBRE0Do3yprKSaD0wiTudcwVQWmkT8mUrA3x63PU+zBA/m94PC3P5Rv//L0yN6aNPgAtNjtu6AqcdaVFnhf6e+cduoGgQglwpcFKxlLFQVJ2e5MyU7bflZ8DFLBQgx/9QCaFGH/IhimDtWIelywGKbMM2c2nYdHzdG1716+fsNlURmNR6VTmkqYjmrgRM0dZ/dGiSg2Li0rjmcUsBQqakWZnNI4aCw3gsDHUoKG5KchH3Fv3qCwFJ4vawhmNmytHFqFGEY/MahxWufMeioMipTk7DkmNIIQIxxl5jNRNXVwdX2O+6ljsHsEHaK0xn9MC1vc+uUlFXjxjjHj30Rbr3cAlaI+HLXGXtxwUSEIgVqRK0aYTkBHLIeTqQjt6Mg0BbVgza1KgWZZSIyKhHBwsisOaHAczmxAmcokLjGgT1UGCFI3sOqUUJWEDO0NKgwtVPMSsI6YyrRxWE1JpNFE5rNLJDbAsGVNyRzQhSWqMyu/Vqghexzz+gWLThpSW81Msxzo1S0owGyYLeolaShe4NANKAF7O4fKQ85OkwuisVgMgnTslJPn9OUAm9JjmECWFTlNT59zaRGOSOSN9BZKYlNfsi0BTOP6SyAunUzZTuXxrNSpn8NxhBWM0jmYGS0dKKxLUS7IQUDS+qVySl8pXKlsroW1l/rOMY7lnAAX08vt9Oll5pK98yrVfgsLJZ2haJ5xWE5SlXN9ijHjvrE19GD6SspAocgidShKCju25JXm6LBj+rxAfT0CPEm0t9welHt+nilh60mBqtZ68Vsr38nn7Ca/8TNxjfYiorcK98w79GLDuA7bcv/Fo3WG9GzCysoLYh49sCKUVMDMmUUW0prW75mY5ouVZHM8tamtwZU4KRlVlcHPpcNRYXJ1bNI6Albo2aCqDg8agfLQjV0pjFNCHq3WYUlCIcqNSMiymIACw4CZpaQAePdEPqLmQ7dlDdnGVJKodSR3Dh8gN6wqDGPLwgNj0gQAITuQrDpAlIf7ocU3Pm8/loHJJzUbeI+tMjJHXDqZLFXub7O1yX8iMKscNsg6FGJN7qawf0pAZIxLwt18pSsDS1xGXfRgg/89wvM/zLgNiCiazQ06ElNTJIShZf6rsKCZLkXT4Z+Q6O0yVRwqItU7Uixgzr5lsqD18mG7MQIHmmbzRyyHo8b481/slgxLQWEPcNOkknieuJwVn80qjdhq3VhWaihDkxmqsZg6irmE1ld4rZ7BkbtlBYyYo3eAjzlrPUnYaB41B7TSuLVzieAJIPDKtGEGO7GTFgTYh8hnVmVWZmypNhqpYYJUETdNkOf1uxqjsMAR0QoWISCj16bqjBUcr9L3HaTsgRmqOqo3GtQWhE8+umvS5jSxsxb2WBar1udNcEhQfc5OjLFByjcmSegy44O5wAHjmqJncJwk4NZDc7CjwyYFdei1zycntjpONWLoV5oEj5yn0HwnwGpZxU8XrAG6WZEROkGZJFgVBBpA2pVQqDJnzWqKPsimKi1iMIln3+PiWwFcCI2pYKWSuioaZx68TCSEu0dLpfaB5Z0xGjOQlkrxK4qE1zauGtUhz0xQ9E6GjyLMGpAQ63byESiQNPA035wlKJveIlGA05hxwXF1YLKylNS3GFHRIoJ1vAv1lGX0UGlnZjc95Ko8xeha73rOyjkprXXnul609HySDtn9cFmRLSb20/s2Ujvz5a6Z9SJPrric60sCSePL5PlIJWgJ7ec/0PPLa/YcFduSjy0A3VRvjXoPU3nfJ2BKamFFTvr2z9AwvczAsfy7JM/FygTcfbfD26Y7UVFjObL0j+/ORAzhpNhNgwmpK7rVWUAyQVM4QZYOrjnVlcHXhUFmNq3NHNApncHPlsKotjmuHxmo4p9E0FvPa4srcTugzAlRJdSzEmGQ/N72fVrAUKX0YrXBl4dJ4m1cmJULymVKB9J5QZElUBx9TD1I/ZjWr4zkpHPV9SI2DBHiE9ExipAqbUD6UUjhu2AEVNJ9mjLqfbPq03pTzsWxQF+fZGGPie8t62RiTJDZlXAXQZ4kSiczHshrejSHNhTTWYnzfCsqTjg8D5G/SQx58WeaWmaSQ/0soUR6gktGFmDk83UBIlKDBEnzRZKXPEg5XQP75MAbmKGKCbAA5aJDvlezcB/KyL22VjVK4fbKbNHyVmwOQA/TBZ5KjbOblUnkZGlNxR7rlRe1oXqVFd/ARRw1RID5+bYZZRShAbTNy7FjVorLcncwT92hm+LrA8jMx8YqtVri2dLSZqzzxAyNVotRAC3pMm3aJTskecDB3Gc1jTrKg4QpU6hPpoP3Od2NM0sodR1K/QEL0GCHYDOi5KarrPE53WUd0VmkcNyQM/9xilu57ZaYSZtIkEnhDGkOWk6q1YVUEWmBFEm9/0xxCxJo5cRLwKrClcyDu4FgE2pE3ErGDLYPO3ehT13eZEJbooGygEtwPpTa44iaUYkyJxKBSXCHx9Myk41yCY9k4ei5jlgoIokmuVEGbQpaGC5FpSlqSiDy/UzUjIU+RmwHpByLnReMHjx2CsAJcpTHTAFlQvBgjKpZcHP0UBZdmOfms2pC6iATJCrSpkCV1HoclYhaKsS0cZ+HUK1Vyu6kKI/OwdgazyuLhdoQ1GtdndQpiSkRUUOveT7VYJXmg9YX0ZU0xVwJvopH/3nZjspb2nIhIALUvN5mucw8w+KDjMtRW1u2maDyXtbY8uoHQP7H6JtpKtk+Wzx9DDg6Ax5u75f68H9jw9V1TOaZ43SrW+/IWyXiThAic5JV85FwJUGkP2U+8JPiTrx64qc7HiNPdiK+db/HOeotNTyiyNOO13ZhUTSQUk+DS6Uz90JqC3FllMHeGqoesdHR1bjGrDG7Om0StuzGrMbcG12cNFhXpIi8bh0VtcW3uIPJ1hufgGAlFliROgsS2z5S5VO2IMSVuAtAsG2r+3rL8qkjaxUjASJnUSUAZQRQnWTNeOpqlfcKHnFAJ9VES+8bpScXu9sVUE1qap9fc+FgGyLRXkPqKNQqNzY3OlVXp54bndWNMCqYpGKZr244jJUQhV6DAY6kfSdou85SJGpqbN596KH8YIH8zHzFOKQaXHdK0IEiWUZm3k4NE2gSNnnKAjM4Ict54c9PYwChdiFQKUwCX2jkQ5wVKMmPhE296n8o39NkKJ5uBu2cZodsbxfPKoO2puWDyG7kJT7p+XnAdl+qs1fjolTotQDEC1xYOjTN4+WDBpghZvN8k5MqgssQhM7zBzpivrFTOZNsxpi7bW8sKi8pgy5w3Sk7AUm7jJMCPoKBL0IPykp45bCbIq1LEc5Og2FhDiJ+SIJnfqKgsLY1cgoyI3JkcbTtiHAOc0+h7kjwSU5VlpXF/2yGEiNfP15m7G/Om52PE0dxNznksNpyycabsTpYhEDhJGjwt8BK4P2IEwmiNIQT0wU++H3zPSs1OjSwP57RGpc1EjzuA/iiJipER3BKFsIY2wxKFkIRSqAUSvDqjEzosZeWMRsYUNCUUEIWaR7Fgl7z+8qBkNWvGCpIoNBwJ4rQiCgTdU75Pe581aUY0OSGTn8m5zCqTStRyTkrRfZVAUfj3i9pgVpGiBDjwrwtTGkGbkgRegTBKpalsILuxdCmBuDLLAXLjKBh/uBlhtMLVpsZ2HHE0cxMQYPDE59yOI+lZ84ARvVzFz7fm3oFybA6c1IhKh1BJSM88o5dWP47Cyvl/PYdQQ/afkZyfHIMPiRtf/swWY2sYs05vyUUl+ldI/5e1oDwmDaBPOM+nOSjgzf/fR5BFCaK8VjkveX1VXGdpzELXTAm4vL6kWEjgrJRKHNsQIh5tB7x71uPdsx7b3mPDBiJtO2Lg9SaE3FCekzdNHH9NdArHCi6LiqqDVWWSRObcadxaNai42fuwqlBpg+NFhUVFwfXBzOFoZvAMO4KWnHKRs5Qkrtyby/slc9IajbPtwI16SL0r6yFXFRCzFnD5/GT/F0Cj4a7KFw/mCbgYfaZkSlVLQInamYnE5LtnPT9DWgOl8a/lxscMUGTwLTXEFusrfR5VnqxWzLtWE/GBgWXgWh9S8i7UEfmUYQxoe5/mliTgcg+etj8A+DBA/qY7SsWK/LP875JTCEhwQguIcIcAmiSCysoAluxUfi8TrUTByoMGa5ig2KJZrKHgOSuWzxfJLjIDiCm2rY3Gya5P3zvywFbIXEFrFHaD57L29B5ctlHR73MZuNI6ocivXFmkRpoQSbu4chrn/Zia+SRwsYZlrBzRMOrKkDuepkZDZySrz1wrQgIUbs0bLCqNTZefiZzrdvSJUiGHyIvJogBQkPDtzywK1BjcPW2gNI0HWbxJdigHy+TopNH3pGYhyQ3AixkHWsPg4X2AcwbDQKLsIUR0HWnYfu2ExOTfPuvS5rHpPXzISiqHc8eIMiHE0gAZ+XokmB4KZLl8agqUPHTepwCqGzKPeOD7OgamoPC7JYlJn8PBax88akFJYzaPiHGq4SznUKIQIn4vMm7y6bLYlw2hVqskKUeBbN7UhZ6gVQ7CBXkRupAPsUCLc8JbomHyHvleCRgl8C8bV0l5Ies470fIJZ+zdjrRCaZIsjj0TfNPhZxEyMtrQyha7Sh5pDlLG1rDc0xc/wQBlblF0n3TLchohVsrl5wtb6ws3SutUDmNZW2w7okPvBs9zrohPRcxJxHkeDtmOUsAEwqI5eCeOJ0xPS+5PuF3NxwMhBhzFS1OudHl8fVSLKRprTwEnS+l38YwNaOR8yCljszRDMg89vQdCSDh9xUILDClzcn92T8uS9wu52DnuS7XIue6f8jcls+SZj2RUaTXTMGCkrdefq7M6xDpc8ltjX5+uulxbz3g4XZEx4Y1IVAzHsll0tEPe3unUuiDLwJkCoznlcbcWVSVwcG8QoiEigI0LprKcD8AcOuwxqLOPS5HjcV1bv7WKlelet4bRY5PIdOhykOaiZ1R2HRj6qe52A1ovUfnZV9BWrgkAU1GYpNnmCkPr52uOXkKKYDOzy+7c2pe54RScbobE8VFKSQZvdGHVKUqm4F7Vtyha5mq91itGKGWKhfN0ZkhhLw0CxmLtUh6eSRREKdZVfw+9yl8GCD/z38Uz7jMwEY/RSSMzmWpxunU2R1ixIq1HmUS1i7rGQqi7GNeiOXQ6buI7B9j1oskYw+WruINJ0aSAduNFFS1oqLBumWVUXjYdugGn9AOhRwYKKWw6XziRRUVtxTkPAnhMJqlqZwhsfzaYjOOqJxOXeIfvTJHbQ0edR3dI63hA5eINDUSlAgyBcgkYVVxKVmCL6GVWK1xUDscNKQlXD4npUDcLz2drJbd9SqtE5pnjMJRXaWAwRgq94kIPRTJuDWNIZ6cNckRUBvNQS816wFFCTgiBdIDN/BYqzGOAbt+TM5Rt8973F+Ty9T99ZACiIuOsvcZO6q99WCbNszGaHJICvSa2ukUzEm5rhxjEkBSqTEmfrqg6Vap9FkR041ZyuQxZkoG6SdHLJ1NSG+eK9nlqQxCJ8ERB8HHiyq9B6AFWyofVuUqw6K2ie4hG4hcj2wyEpBL8iN0iZQQqYI7rJD5cirb8JJdMCd6OpuQNC6PFwlSH+eYcpBYmKnIeQ9ekNMoX7/33vzvslFGmofmjB4nnWqlMDMGC2eZhkFzsObKjKBGlVVY1bmxj65Ro+LEzmqNo9olxKq2Bsdzmyoi93YtHm5HvHO2RYgRu4E0biVQ3kmAzPe+4qBW+goqDuB9iClQFuSVxkNIkn8AsnRazFrq+8fXAU6l75GxWB6GETT5vDLAKANaGXM+SICYm9PkWaYAWefK3/6Zl19/WeB/mRHJpUGvesL7iypE+h4UahbAJGiUeyK0LDmxEHJDMJAD9zEKskgNadvRJ+T/fDvgdNvjbDvQ73pSqRiGkChrAOkRyzwii26NjhFkx/SeKzOLhTOoNDXjXV9Q4DarWD/bEQ1PLnNeWzQcNN9aORzPLckUpvVdc0BP69vhzKGkycn4kOTdKo3BU7LUDQGrhkxDTncDybf5wA1+08SrbJylRD7/dlFTT83b593jdsxprX5SE7xKlt4yL9rRp8Y/ae4vzZG2Q+7d6H2WS2xHbsa3mvt4qO9HgmZdzFGxrJZ7VCaa0nQpYJ3EP5KYp2t8fJg+dnwYIH+THkkDGcWGFuMTA8UQaYGXzRgQZYrMVQJyU13gjWQUgXS1j1orLumQpJeoCiRepBYdYwp4twMFyAHkvd4Vm1HvIx7uBpx0fUJiBeUThHbTjtSdPRalwnTdTw6QieekcVg7NJVBXRu8/qhF44RKQdc5c6TVK654g4842Q4pwJ4xgtxYCtaMVmiHwA0bGdkRhQRBvFcVmSrI0iKlcsmW5fkpZFRxbm0KsozR+Ny9C0YxDJwzSQM2qXI0Fk3jKDhmZEOC5bo2pDHJyKFzJp2LcwZQwrkj9GMcAzbdCO8j+n7Ee+c9zrc9QiAu38ALzUXnMXoKkEcfcXfTkuwaIhpr0HvS9vQBWM0cfKB/k/51DmjFIjnGLEwvTYrC6SW93pjGZ4iY6NtKGS1CqAP0jJZFM6bmZEpDpTLsPjI1FmU7ktmabgeL2mCMgfnV9Byt0jiaZ3UPrXKTa5l8ykZTVmI0J6oiF5cQY94IhJpkOJBzNnPhnVEp+BPZwhRfq6IEncYll0cZjS2v2zMqU74/39wCQVZlqZx+5rj5tTJ6woWeO4OFtaxdTnOwcTpxCWVeHlQ2JYKyIT7cDqgq4vdvBnI1MzxXby5dkmq6c9HjtB1xZ7PD6APOWgqMBjYW2vG/UZx/hJR3aT5bHjtJocJnndb9kux+EHtZIPj1NrjJZ+6vX6Q5nU1aLmsMpHGmJgmRJAC54a6YM/xZwo2fnMcHnPtl13oZgkwc2mnwiuL8dDGeELO6EcDJ296ck7Uy0WCiIOX5c4UCMPqA9TDgZDtgzU3HIURs2wHr3YBNO6AfPZXfPTWwCZ9c8ZyTZjxjNIzi9UqT/bLwjReO1pWmsnj2gJLoxlLPQW0pkC7lAZ2hoPm5gwoHlcO6HSnBRp7b3UgyZmLao/bur/QniPLMzOmUwAHASdtjM47ovSfaEjKPWf44vq7yPitOYK1RONmOjyHMZbWsVNBJtDM9NaDSyEFvqrQgq2poTapCcm5Dcf/7McBoYFbp5GYqCb0g6wRAZXlQGROSdAOylmctZxkfck++nuPDAPmb9BBkdT8jL7vuYzFoQiBHKkF9YsSlxhoUHOcSnY8RYyzpDEjyXkMIbOSQkcQxZikYoVT4SJm9cHE7L13VhGQ83I54tB1x1g9c8qVgKcvbqOT+V3ImoXJGu8+zovtBSG7jNDcSEYfsZEubruNA4/45Icc+xrR4hBhx1vfJha9hbWNn8oIgDm8Lmw0jANGBJp7xQeUSJcPq/NxCRNJPlrsrxiILZ5PihjEa99ZD0mCuKkLXpAypOUBezhyMMXCVRdNY+rczaNh4Qxr5yjJtXRMtQ1yiqOvZo2Md0HEMOGGFC4DUTkQyTXjkW0b9z/ohoVxzS0nBEEgq6PqqSqhP2uiZ3V5xAjSWv+ONYV7btKEOXtCkmO4nkFEzefKyv/oQcf2gJuQZ+b2a0Tb53BKNEyF9cEC9ZSkhOY4XFXFTuRFGgmjZpIRfXCJgMiQlaLa8YdB4ydFC3ngwMRgR5DiZDHAQWSpQlMHwrlApmc4FOohDX/w8Zo6hBCFlEG/2NpRSJaB8bdnAaBTNiZr5+g0rT1RGeiBoXs6dxmFVIWmMMzp+uhspQDYa9zdjQuRiBJ5dkrLJ6Emf9bz1eLilhpy12OhG7r4fBEFCSqKF3ylazoJQWqVTiV6qbvLshPNNG3teUy8LEL9OADkFpvsfJeOrHM9y3+WlZYVNYpQQRWFGPkclmokkYb1//LxLLvxlyPiTaGyXXlN8/D0hEjdUdLrl2oWzHyMmFMD0e5Wrc3IfhLYnn7tuR65OBZx0A+7tWmxEBiwEtO2ITTdixwYgSdWmGA9iYEM0NcXILidPhiTa5rXFsnJsyhHRVAZXZqT127D8XO1Ic1+QcWmkrJ3BtVmNlbM0jmggcUVQoRvjpfMv3b9AK6Ygs+IbABDd7LwfOCFkw49YKN4oQsMFjSVub67aCBDRDtnxTyh9ImMq51VSFCIiDBvrlAFz6qMp1taygjCGKeXQ8HeNPiZlC2nerazOJlA6J/oBSEBFRKYWyZgQzrPYU0fkCiPA8plPMZY/DJC/SQ/ZuPTeZlfGiGUAEGJMXaUiuXa+G9LCKYcEoUJ1kAxs8rn8mRIAhUj2y30IKXubVQY75nRJ88i6H+E0Bbu7IWBkt+S7Fz1OtiNOeaFrB0J+rNawHGySuUl4TLdVoO0y+CoPaxQWTie5tOXMYd15HM2IMlEZjdNu4M5aKgOTlA41PFjOrmeOpN+cUYlDFSJJ3hzWLisYcMbtDPHXrjQVWSPz5zqtktNUZXTSl1SKuHeV0VjVpKRhDKGF296z0DzxPa2lpih532LmcLyo4BxRSGYzx7qbFnM2CTEsV7RsLETtYj53UMUAGnxADKw37COGIeB8RwoXMQKbdiD6RYjYdiO2fcDdbYvRB2yGES3LAtVGox9pIxt8xO2TljdpNo5A1iNuLJX3hDcqjaQhRjxz1KQNcmAHM4C4yrJY0xjMHcxANqfYdlS1iHFaypUytFRPAO5yDqTcIfdVJJNoUZbXhaQ1KvzaloNSzVCNoMgAEg9OAl9pqinPRd6rVNY8Lbn/MmcdB3WpWUyS2DRHY3KjpPtQWotn9RNxnQRyUi3Xma6DjycBLoLIpKY/ZD6t5oBAkO55RdzhxprUeFY7cqQ8bqqEblVspLMbAlYzqvg83IwpOB59wGFVpbF6sh2x7T3OWnrGF53HRRdSQDiEmMwFIticJMTUfyBWwEDmwgr/XP6dnrNC6n8owYL94+sEqPh+Px6ACkWnbPDcsOKC3HtR0BGUVZKc40U1QWzLpEbW9VLFJn1ncV37DaOXxcdPKNql7yvBDAEwyuZGCVAlWV3UtuAkZ05rlkGTJr0cMAe+LzFSMHpvPeDuuiMDDA68u86jbcckuyh0okw7ygFtqtRxo6CPEdYSCHE4d5hbgxXLbs4qg5Wjc66ZK9tYxZxjCrCFbtc4Gv8LZ0lSla/TcWIo3NpH6z43s4ZMMZFrFpqBNOnS64CLnnpHBh+T+olJaLhiN1miQjU2m1tJH4zQxwSUMRwcW+4d0Arp7ySHFylABgCrM3WJ/i/yiLnxUe8l/3I9lqtQ0tPTWJWstqVRr1zX6L0xUeH2x2caLxEpGUqHYufCsej0fJ/jwwD5m/SQhbPMNsuyGjDlWMaY0SVBvHZDYNm2XDqhMnhInMyRP0OCglzO4CY9tkQ+nLvUOTyGgMYZtAPxoUZPWe3pzmNVOez6ERed5ywPeLTucdaOSSJt3Y/ULa+47Ko1e7QjvQeQYAqJ33lZI4nThMhuuhHL2uBwVmHwAdcXDg1bkLbep7KO/AHI8EIQzoazWg3iVieailFYVjadq+YguLKE3BzOqSO/4oWmZsMQo4mnWRtxY6MF1xmNg7lL7ktNRXbWVWVQVRYHswpVRWU8pRSUJgrD9VWNitHjg5lLwfLRokpNJsZoLJosGbeYucRNJi5yQAgZYfHeY7vt0yK3bkes25GsWXuPTR9w52xIroxbTog6H7jMRkHNyaYnhASYbG4xktalVZpKjCHCqMwV7QYPBVo4e6apRJSBGDW3dEWnd4j0/T5GPLjosBt9CsAAEEUihizTlc6FAgcxhCCkOo8tALh33lHVxPtESTFapQ1a5qSoWcicFDRwv1RfImOC3GiVG2tlfouck+Ug0nKSKfchJbIxUwQATDq7gRwACT1DuIMynyOPA0JzHi/Dl4ck3+V1ZtQbab4YrbCqKaiojUnd6I3VWDiiYChF47y2BjPmq19Z1qitxnk7JqOjfgx47eyCKChjwEU7YNeRri0lRCPWrU9rlMg6ySHmCIL8C/dSCWgQC8oLJ2YjK/VopVL/g1KPG7iUx38NRzpgqqriQ0TL2q6RI2RpQFVAqtDI2IY8H0bsyoYv+Vw5fUGwSzpHmTzKZ+0fT7r+MngtXyvqPumaOKEzJldg5PfCHSVKVP7M0TMog6zaIZq3/ehx72LAe+spxWIYPLrOU69FmAbYipM5xxKFxlAzXsk3J3tzh6tzDoa5x2NeW17bKfh1TBtaVCZRAiLIdGdeE+Ir40wqSrUzBUWKgn2pMiV+OsB0Knl+bAZSVBUuOo8tGynN2MpakFnHRliziubX3Gk0Lmttjz6mJsMyoK4dU7p4nRP9Y9k/xhC5jwVJlUP6Ixz39wwc2EZQU59h6oRSQqPL1A8ZA5UxyShsVtG/hX4h4IVi5HgKfCDdcxl5ApZIEgaQYshwSRXlsuPDAPmb9CjLa/KoY3x80ZJNWLJvIGsaJwUKHvSS0QvfaQyZy5P1eUUXUSVNWh8iXrg6T53DA5ex2jFgVhFXam4tztoRzy/n2HKgJY0fF7sB227EhgP4s25A7wMqnmxG6aRrKZNAoSj58OiXDV6OyJvI0jlc9CMOGoMbS0fl94XDvKJs2seIuSMqRW2mgTAtCqASsc3mChq5AVAaIBwjhGQnTfd41di0uFBjEKMNmhayyuQGK8nSj+cuSdJJ46S11OhxMHeoKp26/7VSWM0cbh1QUDyfOxwtKmoqmeUAmagZisvV9H2L2kIbncqKInkk3Dw/erQs+QYAXTdi15M00qYbcd4S6i8ls11PCRE1ygRy0GP+uTQqRsSEJgMcIGtq3JDmzrm1CADeO+tokQ2i25k5ZZIMDiFkZE/Q5kBI9lk3oOPNpOYxP5VTmnJ0hYNqOUBX6Xf0fRe7IakkAEhNVGXJOpdsM5VGur9LtEO6rFNZVWFqihAzl50oCVNlg3YIKfiOMZ9/yXme0JEwbTaUSo0ckhRoPo/Ri270+9MGBL2U5FUhI+WCUC0ri5VzqLQ0CVMZdWZzU/CsMpjVpDGrlcKtwxrGaGru7cdEEXvrtKdrG8k+txs9Op+NMrYDlU6lBFveATEQESRrVplU4i9VO+S5Ckgg11QqmIhz12XH10NHeL+uelHSkM/sfb4eCaB8DIzURW58psRQrpfWK3qPPKfLqHV0Mvl1wHQvuez1H3SZ5fArAQz5uciJlepJ5WfTeo4UPCJmdNsHSliFFqUVXe/pbsCjzYgdK+CEEBNdTNY1Se5SYysDE4ZBibrOcp4Arb3z2uLagkxpamdglcKssvCBmpLFHKrhADRV+ECNxHNHZkkSLOpiLoqaTORnpi95DqU7nPy89wRU+ECqQmUCCFDSJwpHtShwOJP2HUGHhxBTwCxUPjHLcnxNVtH+U47VkZMHzftgmcCLhvQYcv+SUkjzLF0/n4cg0bJ2ikqM6KCPPiZJT61yBd0yFeayKSRrIAEAee0tJSE/6PgwQP4mOZ6G7ybNR/k9WeJEEDIZdEBeMIU72Y2UnY8huwlJU4Qgt1LiogY+OqcxBLx31qL1tOEOrG6xHQKuzWr0g8eDXYfz1mNRGwqG2wFCRdp0I3bdiHYQHcUBQ6AAy/AmK2V0KVkDSGhb4kTFxyWTrFE4bhw673FtYfGR4woxRqycw9wZzB0hBzNHUnAVd7fLZikdtcvKJIpF4MDbaUIMusGjsrkZaVHppCzQscD/jAPweaWT/NjCWXJqAtJiMqtM6u62VnPDBzXUzWqLqwtLNAo+b60VDueEbtS1wXJepQB5MXN4/qguuMsmJRUi5SXcZGMIlZNxE2NEDNSoJ4nTbkfPqe8pOLloBxJkZ37wWefROI3dSIHKC8sF+oEoEKR2UmhWckYv2rQtBy9GKdyYN8QpbUde5OgzJLiVgFkVY03zIjyGbGxx0VNnt1FZH1ikvxpnUIYJEYRGD0VA4qxOQa5UYERiKCIL5pd8NkGSpSwvttGS/Mhnl+6W4OcoiaqcD41fzeNNpyA7yRgVqJ+gh2W3uN+LbgVZtMxR7IaMEldFUiDBoCgePIk2UKJ6UvoH8tgSZGnlLI6bihNDrl7UGnNrUpl40TjMK3IpKw0xusHTffeEoL63HgCQ+cGuG7nhjL67LROxYr2UKoAEyBKUyv0Up0wBGwQpk0RGKgCCLksT75P22K8jPk6I9H6QTGM7Tjr1R0+qP/Lx286n6knvA9YDNWlJmb4dQgqABFzYl3hL51z8ez+xKo8JKvyE15QVkvS+STLKwV5kfWeWSUwBNJ+jNI7G4ruoYkLj/9G6T0Gi0Qr94HG+HXCxG9CNlDiXAXJ57gKsGEPBL/GGNaw1aBrH/Q88lq3GsrG4OiM6UOOIGicKLHNrUekSQdZpXdOMpi4qsa3P10+fZbifhM4ro/tTcw2ZJ13w6ANR34aQDTHagWyjA4Rry5Q+RsNnlcXRjDScF84mtSYxfFpUhuiFhhoS68rQPmY1lhXtgavGTpoohZpRcTBdFwBQbczEQEnGuCQiGrwmagmq5eescFMYhTmd+4Ok+ipUHGn8Fc5zOYtExURACyCr07zfGC+PDwPkb5LjaRbd/ddIs11aZOLjVrsxZjRaNl3hqgn3U7rGQ4joGKUotW29j3hw0SceqQh1b/qAV66uMPiAN063WLcj/svdE/pdN6bAve2IH9Z7CnQueo8xUuOf0TTZyUp2Kq0kHb8yZxOaDFlkiWKxbCyGEHDUOHzscJW4qzNGsbQi0w9yyNOTTbpxNCnnlgJkW2S6taXFYOd9CpbnTuOgtmgsyZMJzUTKWnNn2GVMY8Y8TUEyhjFgXtvk4EXSQrm5TlycmsqmkpjWCsczkg0SSsXcUVPJaubw7AHxkWczC2s18xoBpaUpRbHDoEn2tGn8BNpY5Jb3vSdt5CGgbQdshNfHQeqmG3HYGJx3I7ZDwHNXZhi4EiD85BDITCXygDT8LHZ91uJ9+cYCgTfPGAlB7seYqBvSAAjQ70QeSGvih0ussRs9B89UDgWA7TBeamwilZOxCEjmlUnd5CGScUSI2aZVkjO5P4JOCcooaJHw/cqOfeFkynuFezyZz4hJQlBoUXJu0+oPUsVHAkCFx5HMScOdwgTdyU12GfkJ8RKaBn+G/CwhevJdgpoVScJB5bBsbKqqaEUbMknw0duuzEkSMfKcvX3aoR+oYbQfWJd78LjYkQ2652bJkmeduIXIKKUgVwAjsryOGa3S3xIky+2XUn+iWCDTXiqT789li3JZlbjs2Ac6pNH2siRk9GXCVihd8F+n3cC64grtQIpCrQ+kkmCItlQ7w/NFglLh/19+XgKMTOTVimMa9F5+pWWyuP/5Je1P5oBYi1+0ZDAhFSahZZSxjDVEGdkOAQ92HS76ERfDQFS+MWDdDth0I3qucsVI61hgZZMSzRQ6xbI2uQmbG7pnLKOpQcnpvDK40lSp4Y56RQxXFw2rtZADa8N7igYFclZnS2VgWuWcVZY+h38mag/AtLdAxkHvCSxYtyPGQLQiH2OiDcg6JoCBtRozvp4rM/quhbNwmpp9paFTgmHnCEyhhnaDWaUxszrRjvYpnaSqQ9rQlVVclRWEOssqyvrsOBgWBama0ffa6bQGKtDPlco9ATGC6ZbsjKuZ883Jhay1UNk/waoco5SGOvv8+vc7PgyQv4mPfVke4dqUKJQEuvLK/cyJOvxF0i2XsuWQcpZ8fj+G5N8uTXqjDzjZ9dhyQNKNAQ/bDtvO482TDYYh4PVHHbbdiC/d31GpPgXI5OTWDT5p5F50rIxRmcQ1kolWnn4pAxYxbViUMrgzCtdWNXwErjU1vvW5AxhNVs+NYzc8rVMA7HRuxjMqI79HdUXoL2+kFfOJRdKscYQOLxuD47qiYJpLsXnh0Ak1dprKcDV36Gsuk15dVuh9TAvusqagfVYZLBqHMUQsG8sINQU9V+YU/NXO4MqyhtFAXVsczKukKbuYV3DcaS1l5dFTk4WI4JdlR6UUIqMvsrn1/Zi4fLvdiHU7YODS5d2LgTZmrfBwM2LbjfjVN+6hHTxurhpseioXS0lUOI4KChf9mLSxFRTefrjNph2RNKMHH9F5n4Jlz+8XG93MzQ3Jprz1tJHaYj5sWHWjqcxjAYAEhcJpLN3kfCBdXR9zYNCNmcscY6ZelBuCBNJUXlQpYZWAJxQL+KSDn8/NWf3YYi7Upxjz+ySIF+RX7l25Qjir030lKTn6dzlvpPwpnzOGzDOOxedplcvmcn9Swx5/hqCyc2dwNHfpuWgFrCozCdifO6ywqg3WrI7y4LzFthuT3inpclPlYgz5/6PP39uNfuI8JhtnKf8kCY5W2Q5dUGF5nTjURWRETzbY2plEs5KErzz2t9393++XdmWclNxcuYdjjInvnxB6ldVCLoYBvafx3I4BZ92Adedx2g1Y1CY1jw48duWa3++QMbRvpX3Z/vFBoM1lAbRQd+j9MZkCBWTKj9wjkfNKiaQiS+XRR5y3Hvd3HS6GgddycgHddbT29GPAo5bNp4qASKobGRigNXbuyAyqqgwWDaGtsr9UzCs+biqiGjgCOA4a3jtqm5QWCEE1if4kLq6LvfHOl4NlbehzjEqNrlJZKv9NiZpK8pnbzmOMNDYGL2sir5fBp2qIc3Q9q5oUNxaVIX14Qwn7ggP3g9piUevUAL6oLQ75vkivADB14hRTl1lF10cAkcHcGswMXZMABqIAJZQSMQ4SSqM06SZgytLev+7GtH7WRrEaDlV7y0bbsllY1h8JrIFMTZPxRE2fHxwkfxgg/09wyLSTrlc5kmakoCmKqAqy2Io8kASZpaOWDKyhQLpkIhLSSzrH654y2ZOux6YLWPeE+Lyz3mHXj/j8/TXG0eM+b3j3LnoKiLkjO4AsjYeBAiStFLu0xYmOLcABBvJCp4vNIsaYG7EK7p7jTFUBmFuD33/3HFor0jw2GnNrURuNlaMNnOgUOqHFi4pUA45nFfG3eHLXhpzCGkNWxo0VvWWDG/Oau5oJsW0sZeGi+7pw9J11MlfIQYkgW1ZT49KqNmR7XFuseHNYzRxTQxQjyNR4N6stnj1kXU5ncDx3GEJAZQ0O51VaJIh3TPeM6BcWs8oyPUBPZcpCrh6IuP44BnTdiLYduZkv4u5Zi0074J3THu9dDFi3A7743g7d4JM4fzd6jIHGyBiFAhRxMQwUIAcKTL52vsUY6HnKgtZyE18/UlOe6OkOnn4nqgntGFEbCn47TubK8tq2J67ze2ftZIFUipwfhesqiKUCkgRdv9eYte2yDFws0FbLAY9WuWojcm1dwV31BZJXlg1lrspRxjRCZ0iBtcnSfdSkJ8Hx4yoFQBHwcflzXypSQZq2cgAoG7vMNblfck/ldfu63mUj8bVVlQxdAGDOWrLCPxWE7bz1ON2NuNj22HTUECqo5jgGUrgZxQmN+eTyfDkBkzVQFFEETSsbGaUaJYoz8rwUMq0iFqitjKEZb8hPblDLPxdN7fLYR6+EU7l/CEVm8AHb3iegI1XLIBQiCpjaweNkN2LTB1wMAxa1RTt4Qho9ocsRSH0jwHSMSfJTclwnNBWVK3OXUSguO/ZjcQWk6kv6fUKWi0bwAu2W5yUNh4vaYgwBp7sR9zYDTtsBF/2AmdNUVegIbOnHgLN+QKlWoThpq9gt1Tmyi547zes8SWMezCsczy0rDClqcHMaKw6a5xUZhRzU1Hh6OLNpD7Wa9gVKTonnbrm6aNTjSdCqNqyopNIzT2o8xd4re/sQaB0U2VOp+opfASBa80xhc9SYftAYXG0qLKxNqGvNwS8ALBwF0UQnoWrOqrZYVIQ4SwIn/HuZ43VlsKwNVhWhyELhqFiKVCEr1DjNShqWpdw07Z9OK9T8HJymOSteAO0QklGSUBiFwuFYuq6svklSXAbNANGmFIRy+mQFlv3DPt3LPjz+RzzKiU//x2McISqnxQl/URZchameaTt47orOVrki1UUoBXH8Wna02w0B5y2VOR/uelx0JDXTjwHvnvXY9R7vnPUYhoDTTY+OOWLDwB3GHCBIA4WUQ9pBNnENjTyYS+vV8holWxbupEjCAYSUbTrioW5Hj9OuR2U0ujFiWdFEk1LPwI0As0ok37JQ/9HcUXcwfSvJkymasO1IqOXMAYe1w5Vlhepcp81fmg2BgIOKLJnXmtBWQSlFP3LbUZnRGWoCWdQG563HvLZY1RoBFCA3LENktMJBZRlFIbemd8961M7gaEYBtbMaV1c17p1F5nRnNzPR+FxwR7bibD9TVQKXO6kxahyJUuE9If+Bn98JP993zjpsmH7x3jm5I/7OvVN0vU+d59s+W5muhxGPdgOhxCPRMR6d9/CejD6G84AxIrl//f/Y+7NY27LrOhAcq9t7n+Y2774mOpLBJhgMUiIpSiwhbaddKsCSnCpBWbaryoAKAgwYkD4MA4IAG/6yBZT9Y8CwDX3ZhmEbcgNkwahKOFEW3BQqLaeFLEtUQ4ptUMGIeBGvf7c7zW5WUx9zzrXWOe++CIoiaQoZiwi+e+/p9tl77bXGHHPMMYVB7qyBFK+MXrRwKuuRIxIGT+BZK4WL7QTPTFtMZKf0bCr3jrBrCaTNjSnhfOvzpuVV2gEXADPIqjQpmVgiJIuzzEsBXIDIRgoAkXVaXCpkKBTQXQMVYT+uuickmBCTfVobCvsrr5e/xwQ4/WT3N9lIhJWuXRHk/bIVWiqWSs5qTPweqfps+TylkIOSmTHsakDn9+2LEVNMnB4n71rpCCmfPU0R4xRyCl4ChcYW8CY1ClrmMgd8CEVaIEFESsVnOre3VylrleV8iTe6fBsCCU+XUsjzYnry3Ma0+zpxvtkfdMgpr2dy/Wrwvx4prb4x1GX0bEvStPXkcb6ZMEwR5xvqfrmePNbsHCTns76msn5K0Crnp1y/cvwynoaP1VOeINkY+XOS/6rsh2Qk5H6UrGXic3n3YkAItE6ebnxeX7VCrqEwJiBEsp7c+XwOXNuq26hkBBbsYtQ0tG4ez6gQzyia162ljKFkHLQm2Z0zCreOOrzxaEu1I5oYZHGgECInF5xrleefAnDYGRy3Dr0P3LSm0vbHBBuLLabVCmufoJIA45RrNwT00Xkr61LXUPfJw44t5mLMBcud1Vg6B6O3OHAWG+eJLe8sjjpq9DN3nsijyr5N6hKEQRbZxsx5LBpDbbhZvjEGciaKXOTeNYZcPpzGeoy5SK9j8knuB/HEpqJpOm+doRbfVpXMr2Q7hFyQdUZcNaSAO0vUnkIcPG28B5D/kIz9S1pr73J0XzEMAOvNYkLkxV0YuX4KDJCkNTUt1MMmZisapRSlcSLp14aJmImBCyTOtxMuB2J7Jh9x73LCWU8FNdMUcPdixHb0OF+PpA3bUDS/YQ2r1sWLUoooZKGUVLXY0iXQMWbrnFQqm+vNTs6LFBIKWBk9RaEX44T15NE6zQVhyFreWWMQek/FFw214G45uqWiLo2ls8xa++y+QE0xpqyvvNG1AJArbhUvjuDzv+zIKJ7ScGTRlpQY4iMXphFANlQgYRSn4ixWfWCLOp21kde7Fhsf0DqDZWPROc/ss842Oh+63uF8M3JzFEq1G04zti35Q1PRikHjTG5DDQjwiIghcgcq+n0cxfUi4WJN3fYeXvToR9KOnq0HTFPEV+5vsR48MwKkDZTU4b1Nj9MNMcuiQz8f6N/T9Zi9tSdmLYQxXrQGUtk/sCTl+kGbmebALc0Hnt8XW7IOHH1iBmrCM3JvMTvlUyn8iwlY954cHVKEimWOyXkZuQATee6lXMQpWjoFAtz5nqwQRqoYtH39sSCSYQo7975shAJsuqrxS0wlYBT7r/0RmBlvnSEwaXc769Fnl5qFlIq8QEAKwBKLVNK6SOylWn03AVUhiqVcOU6lgCEEAA4xJty5GKEVta2VQtBxDHDcMTIlIHBxTZ6PkTSOkiVKKe1kmFpO41qtMGDXnzckQqoSZIqln0iPaguthFJMJ5cmYVfffMWlg/hty5A1izZoBhystdwfuQFCIm21BBy5BsKw80sk+8TRB5wPARrAeox4cEEWh+vBY4oRZ33A+YZcWBTK9a2PzRmdGUlZi2VIFqGev+/kBLBvEwfwWrxT0EoXQIpfZU2goMdALEfl8ZiABxcDfCCCRjq/zR13QuTg0/H63k8lQyL+xuQyZDhzJm3iWUfMDOfJ3O5423f8WK3B1QqZKZ1yxiHlepYpxNztUwGcnRQpT8nUXJtb3Ji1eLAdyCMapYbCp4iYNHceJfKGrl/MVpZjDHk/1AwMc7F+IpniswcOR+wGQd0tubjQaVzrXG5O1Vla+49nVPS9dMQgU/Gs5vlaCu/IKpGCiYPGZvnGjJ+/aC3CdiLXD9YaL1rRQRusbOC6n0IGkSa5NObygQpjraYuhQtryQGKWXDxlHZWQw1FWiHzTYJlOe+/D2xM3/f39/T3xvfK2F+cRNxfb7S1xhHgAgdudJBlE1HSjDpbxoiH4WlPrZ+HiYoCLkbSdvVTwNvrLS76QH7GKeH+ivrcb0fa3B5fUgc2ZyZ4H7HZTDCGO+L5CK15w0yF+aFUEmlOlSoNGIS7mbniLSnfr9jP0b9S+S2FJkbT+zut8bgfsfUxp3MVR6oAadvWA7XpXFhL1m98M04h4bKnrnh0zmKOYFurYSdKrSUA1xcNLreezyGlTztDJuxGKVxbNDhdj2hNaclab6IDsyCibZux1GNpDI478pZ+ZslsNjNgRzOH2ytKmUm6urWilSOLnx9+7hhfvLNmwE3Pc6zBm7UWN5cCkGlDMIZW8ZxKDwJK6F8/kd1bTGQLt1qN0Frh3I7Z+UIpYJoC3j7rsR2pcGj0EZtKf377bMQ5M1ujj7i92pDOfYr4+vkqpxlFnzj6EuBFPl8TB0CPVyN6H3E5egLSnOkwmlqVU4tz8gp9PIyIKvF7MuucUg4apSiPZDKAqoCXXC0fIjpns5MC2ccZlEa44DlZ3EFqG7b6Dt6vJ5DbePBxh1mupRNq5/kq27IB2OluVQ8p+GldCahrbWT9/eT4hH2pXXKKewZ2nBXkPWJK0NX3FcZLzoG0gTabESElnK1HOKPRs0PKxOuEMRptFRjX8hIB4VkCUjGTVgGNVZwhUjvgVmQEok8WhhkoWSgBPfK+u2lcld9r/xzv/L63GTMmf2KTvpJBrlh7mT9aFT9v6XwGAFMgBnk9eFhNzNzFlhxcWkPz96IPON2OFOypIm+SUe8dKe2y1vXxyL4hgPCqUQdX9bBGYfB70g2UuVHP3c7prJ2+GCn7M4WI02nMAdeqn3LAIOyzSL5EEiUfIvZlLTOeRmRrM6rr6DiTOGsMri8sDp3LEp3GkkSgdkMwTI5Yo/FwNZZzqIhplnoaOR9aIVvBASHPk6PG4fq8xeU4UYvoVDySa7kFAC5qpfM0cKBRa8KVUln3S59CRYDPLdvcfrqxpUBu0RJhkzXCmo795tLhpCNJYWcM5q3JMi4JopRSsEpnBnzpHDozYOks5o3JbeOJsS8+ygdtwnFncNg4nDNjbbTCQUvyRJFOCLNPDlHMMhuSKAKlW6SAdfFTlyCmllmImwWd898fQn4PIP8hHfvBe4kiVWaXRLKgsCtOD1G8YmmzbCyB4/Xkswl7iAlnA1sqhYgH2wFn/UQLzxRwdzXgvA/sYpBwthmp+5onlvFiS1KK3mqEQJrVpjEspwgIoRTfZaeNlKrNC5zKUVwwQ6yPRNNyDnLKkM/DKMVeCrmCWClyEth4KmiYuaI3bNjZYdFaaDUQQHaWiuGc5XNIxYfzxpDdWAzZgq7hwj6jgKSoIPAbD9akmwLdoI028JHS9SfLBuvBozGlgr/eHydmIY2m9FtrKdXXOY2FM2itxzOLFkYpqImAwPWDBukBLV4+0veTTlBLZ2C1xsm8Ic0ZW2n5yJ372NT+2YMme2Z2jhgWrXdT3EhVtXsg1t+HlC2UjNHo+wl9z53ltMI4hiy/AICRgyhhqe6vyPNaAqI3TkcqAA0Rb5wNOJ4RkzRM5Ks9xYRxinjrYkMbeUgYfYAzGm882pC9oCe2uGc/bqNJZrOZYq7oX40TYkP3DTFUyC2sBch51jqTd7OAMfDfii5wJx1vdQnaULI01qgrwdHThkwJkkzs3+e7zX3qOSRMkqRb8+uq19fZp/rD5OlKFV3sDt5L9XPKmiOP1Z9D0oTS8ljs+eR8XY4Ts/+0XqzZuWX0IXtEex/RNImdXgoDW39nrYrDTc3cSkq2NbuyFcObJWXWSrW/vK9cf2ljW38nqdOoGcD9oYAnGfn6Glxx/a9ikCk+FclD+fzaAk+cKcjXlZyDGke6zbNhwhgDhsAuFiHgdBhzMCFzXEYduMVUAnUZujq3+TVXfBd5n6v0yQIO81zhf2unJNqr6Nz6kLAaA6ye4C3di+cjseBi/9c4aua0nYqNW10IS/aJpStp60gzawy5Gx3MqNOouBm1DbGhc1c8smeNQWM4y1BdrI4lF9sx5DmkQLpfcT/ps5yR94JKNqRADi83DxrcvbQ5S2GNeLoXcA0gZyITqKNnfQ6VIocHKfYTcmPWGDy/mHFzo7Tz+Z3VZAlaObg4q3FraXGtbUn2YKnFtmRanVEYpsIgH7RUlO64OPHAOZYN8jXXRd7QGAWjDZaNw0HjMLND1iYftKR5luZZHduY9mPpNtga2qtiokBGgjgB3zIEFIs0Q3MWWCsgKnXlffu08R5A/h4atcbvqsdqzugqhkgWBHmmbNRGU0HdeijCfvGP7DkafLwacTESAJZGHY/7EY5Z37vrHo/WZJvTTwFvnY9YM2COMeF8TVG0UmS3s95Qyn1qTO7KJp2NIjO8smPIxhcTLfoJiavs6fid1vCJNgBh3hSkGK+4HUjVe44qddHptsagn+hzxJ4HoBttPYTMJFNFrWWgaZi5pG52h3NHDLonyyppiNAYKpiz3Dlu4Cp4OfeN0dgGsX0LVxRk7bL+Us17MrfouMJ+5qigcOYmfOBogbPtCHgu0luQt3NniSWgymBKzZ10LZzV+OrjS9aL6dyQQgDysnN4/2EHYxT7LRPDoo3OnZL2q/FjJGAjNm/TlFjXRw1FSN9Mc+FiTZpiZ7jS3GjWggGPVwO0VjicOQxTwNsXAz58fcZ65hFKNRhCxDAFPFiTv2nPRaANW1kNPuLRasS91UDXJwT2BWVds9W4fb7Fmgv0Rs+WSMyiXnIhkwAr+aoimaCUfIRVOmtWhb2oi91SQk65ypwWQCidumqg+k7LtIDrfRapzJnd3/dZyJrtAt8vky8duMQTXdiq+n0Vv9/+59agR1jixAf65HPBTjcpg50hhNxq99HGM2Am6cRmIA29D8WzVuYcdSwrRymWU8IWZaKQGb8Ent+2dCnL3t9K53S+iaUJiLC7zihuk14cgXL6WpeWtxIsvdt1eVI6c9Vrnvyj0aqA2WodF0nGxHIhrUhKJJk9pWitv5ymLFcLMWE7RZz1E651joOkypoPpXhP/GSHKe7o2xUHB3nZxpNrAvBkEeJV3+uqwkXRgEstxrr3GHzE461HRIKfJ2hFuuIYyZ99O9KcGRvy1pesVbn3OKhl+7ZZQ+l/KXw+WjS4PieJxcIRQJ01FnNrskuCUcU5Yd9nV66tMKoAMqCWQtDBR3bcYfmFkDO8ic2twfWDltbuBGgwiAZLC1GcWOrgqJZQKQ7apVNrKbylve7mYYuzNZFdjaX1X0Nh0SgcdjbLR+hxg5uzDsczh3lrMNsaHHSlBXgu1uPg9HhmcNw1DGDJDk+kkPT8cswNW+AdNhaHnUO7Ntw9VuGwMzh0LlvQyTnIx6xJurJoaf0g206fr4O4Qcnvcq/Iz5JR1lfUXLzTeM/F4g/piHs3qywMQGF2pMtSYzVWk8c5m4uPPmLrAy65Ocf98x731z3OB2obfH8z4O6GAPHMUdrzrfMRjzY+F/Pdvxyp7TCD3RV3wyNNasR26zGOZaObGEjR8e2yFykV1koKDiybgytQpCvtiOvvHCoGGamk1IvFTvFKtFrllNthZzKzdDx3SCll4Gq04pacZI8jYDamlLVYM1usZcRejBYpTcbtKcGqkgptDC1KViusel+lfsDP4WuIwkIYpXBj4bJGq7Vkl9VZjfefzLBwNj9vOwZOn5UGCLSokOTDGY2zfsKciyAEQMzYRH7RWXzgcE4sC2vOtFYwlpgWARDCSogFXAikE/U+Yhw9u1wE9H1JkYdA8pqR5TKiLU38Xc83IzbcBnwYPB5fDjCatLePVwPOtiSN6KeAu5cTtlPMAZpV3DRjCnjrbIsH2x4Tu1xsJko7U4V/xPk4UsW/j+g92URJNmUzcDMKDk7kPgopodGG7zfu+qSpGl2UlM5QBqIGv1KIkzhglXuV9qxdBvRK+hCFNbxK5ylBXw2Ks+aZQWNCScfLa0ZmP6UQSv5ef4KAsn1bJ6BIBADRqFYMV0ULSvDaOZOB5sBrTmtJV/ho43G29Xi0FsAjLicpF4YKCXA4b7KcgYCCzo1VpCugAF05XscbqnQpUyjWc+SOgMwIZt1mdc7yhprvUQIgufgKVzPFu4WJe7/Lf++OmTN7WRMCtZWVZNpi4iJqJj48N7tZT5RFEb11PwU83nrygU4pe4zLEGcEKfAcqkJFGfvBmgDdGhBTc6nduVI/Zs2uVafYJlKXufI5pxvKMJxuaI6ILnzDsq5xpHt58IGtI8POviKMqthYtq3FsrM47KhZhtEKN5cNnj+kuTVngNU5g87YvD4LqJVGOldda2GLZb4Iy6nUrnxEaypSUzyB5Jr2U2A3BwLPi5Z87YV1lmOhrnFlvohzhjynk71JlfqHZUsuTAt2hModAzWyRal4gIdEMr1nFx2O5uRd3jFr6/aCJQkejlqHRUv7a2M05q1hP2h6vkgzALDLk8NR22DRGnRGY9GSvvu4czhqXe4NIKCXjlmkigbLzmLe2vy9tEIJDPhzbFUQKa2vBRMIOfTNssjvAeQ/JGN/nxSGSYZ03AJKgYQwNIczi7X3OBtG9CFimCKGEPC4H9D7iNurLXlKjlQcdfdiwr3LCRd9wLWZpR73K/a5NQrTFHGxoSI8qbIX6zalqFhiHAsgFtZYAMNuqpQXfd5Msq2SQk6fUNSrcotr8OJbb/RAkVfIhig31kFnmXWh1y9dSRnNuUhjOxL7Yo34E2sczmxhpVLRAIqDhLBK1pRuPtSCdtcT1jGo0krlgi1Z3IR9lOemVADQSdtkbZxRJNVojMaDy6G0MlXFYJ+8m4EQY7bLOVk2pP0L1BglJZo8JA+h4GHZEothrUbX0eKjFGC52ttyjl8zIy/XEAnF1cKT1Mb7Sp8cU7ZeosJMlS3iBFNteo9+DHj2sME4BlxsJ/RTynPscohYM6g+W4/EGE8Bj9YkU/GRNvPbqw0ebSZMgZ6/HgkcTz7i7mWP88FjYCvBzRR4oyULt+1IUiGfUl485VpI9XkC6RRpgS1SByn4rO9FcYsRRlquqQxhX8vsv+J+jylr75VSxce1+gx5T2GytZJiMgaJe64vYoEW09PdCOQ9syVgdeC1/lkKYeVY8nvxQcpj0nFuM3hsQ4A11Hr+vA+4HCJ5nsfEDikR+8GzUsCzh01uaas580FFV6X5imQsxG3CGi48coYZ5KIjFgIh8vpodlgunfXcArhlHZI1tu7C907jie54Fch/tyGZivq1wsZJtiKiSOfEDk0A6maK6EPM8qB+CtlfPsSUMyZyXaX5hDhaSGFgvq6pOCXIUdVyCpmfws7zi3a+03YKmYmVIRlAsXUEaM6smEG+6AMebzx8pPk7cJMhz7UHEwPQyZdGIBK4dHt2bsvOcUMMIjiePXC4OW+o2Jo757VGlSZMqjT5qDu7ZSad72+5/+sCvtoKT4IF2S+0KucwJioGFjmA0QrHc5fB9q6WVogkAs9yfGQrqagRFUtFJIhbNqSHpj1QZbccpahbnQ8JVkiPRNfgZNngeOFwPHc7DHA9F2X9OXAWi9ZyEw+dfYmvCh6dVjhqHGuUSTIheuXDxmYCSvZ7kVbJPeksAeo59w9wXGAsMg65rwQcGyXuQBzsK5XvaSIU3v0+fE9i8T003mnh3E9hSnq0HtmzNlEKh9ruAkdzh9XoMZqI1RCym0PgVNrbl312B5h8xP3VhMZSEcjNWUsem2vqe//MYYNpIiDjA3nsxpiyLZPldEYIIafMiA2izc9w1X8dRcuiJhNZK2TPSAWKqIcp5g0NqeiqY6o3Y2JMnCrAWimK2ulxSpkv7O60FyshYZjmbL12bdHgrcfb3HXOMxCR960jeCnoCAxsxIIGQJZ7UMFfhNEm36j77U8BucGB55czjOI2wd7LwkJfWzSZJRBfSqmU3vrA3QA1Vr3nQIGalQxcrm/4uOadxZEw5SzNOOro+JrGoGlsLpISLZ9S5ZinKZIRfyBtuTEKfvJlE2d20DliE8TiT+b0ZjNBa4WPnSwwjgHrzUhSisFjbTU1hmAN+8V2wiIlDCPZBR44x+nggNfPhmx5dLoh3+UYaeN8e73B2ZaCvxAi1oPhqnhytFixHZQUIMkGFpDQGQ3rSTvZOQ0z6JwdAIhxiglw1b3orMaWO75ZXYIgLRENuxPIRkZWRrtgdt/zVuyMhMUX4Cb3vSz4NA9LcClDQHtri7d0vW7UzwsxYc7FMPVGV3vkbjmYnmlijwRZC9s5+oizDXV620wePmhsJp+9jdf9lDdl0RtbWzeqEdCr8dHrXS4gNVrhoDOcNqeqezmPTqRFiu63pbOYtwa4LEBDawWwHj6lBM1FRML4dU7jQhXwQ7ZWJJFJKWE7Vo1f3g0g7z0uWbJvhrtSEI/k3Ta98lgmGfi8150ZQyR5EX1HLrqbyIJTJGhTiHkdDoG6s62HgBsHUhi4yxYXT94SDEqxnOGAWSR0AnrrHYuCpIAZZxXk8dFTutyn4ns/sNNN7xNW/QQf6X71seiug9RAVN9ZzrmsrTOuo5DueNfmZF/WMUB84bDD88s5vvZ4g4OOCrKdocwDXS8ulm6Klj0BuXGLSPnk2kpQWZMgMYFt2lLOLEkAJudwCgVoyxyVa18D58jriZAxVikK2jW4xTUXvw0T65DJ/SimhGsLhwcXQ9brGqW4DiZlkJ1AYPSFk1m+bs48yaFSAEr32ZI1x1Mgq1Nhqq8azhCDvOgsSQKNyXvjUdOwxzWve7L2qSIrckakFCq/n+iTJYNGfy8kR2NLF0ClCBdFLXrypx5qHu8B5D8ko94MZeHdX4ADs2Ed0wtjiFiPHl+7u8JZH9AaYm4e9QNOt549ZQPevhirgomIs82YF/+tJ/buYkMapmeWjoCMGonZmtOiOQwegM2dv0JIaBop1KG0KUAaJ8gGCJqxFOVT+lqskSTVq5kFPd9MT3irRgZgor0LvDg7QxFq50xOkQjLIoUMXTLoAwF9ANntwBpiE2Ii0JTZxFgKj6JDrnJXqqRuNYNCo4osAxBvTJ2PWdgEqTiWITjDMBB+3/UZ3ni4geWFWhbjwVPnvsSnwnORm9ECyJC7Am7HwOkvheg0VkNkoIasuTtodW5v3TqD63NiG5rGom0Na0ABw4xyCEVzR7ZvgQIg3qwELMt8lTm76GxmmRPP6WHwaFuDrzxe5w59j1YDxjFA6ylnKcaR2gyTjpm6+N2ck6XeMAbcuRjzHHiwnrKmdfQRb56RuwW1xCagIBuOjwmrOGULpdFLypFQpmjrLicK1OzmSd/amNITi60wdM5qxClQ0VX1nBpojP5JgLzro0r3toP4e5aukpItErZFAML+kHMjQaiAmLqYVzZxaSYiAF80vDEVD+HNGDAEAjwkZQr5PSTtf8EevI97cm25HCLeXm8x+oD1UPSMIZSGNEBpViNAISRpaEOfdXPp4FxpxS7tn6V1rlGUXp81pJ+k70nnxpmyriQUNlg+e95aGE31FEYTQJ9C4HuvyJNk434nT9WrGOansWv7Q45NGHGti+xFqQI+63UnpcrKLiT4CshOgdq5S6t242MGISlxt71RrmGRuskQZ4iUyhocE82Dg46AjeO/yRzZD8K2Y7F4BOjjhbSYQsTJssH9C3I/Oh+oSyd1TmR3ClVkHiHE7KqjVLkHRW9sDbd81godF+Ndm3NqnoHZ+5dz3DqkgmdrGHhqupekaYmsna0RJ5XScn6Mscq0FGmFFDjW97vsa6OP7JpC+58E6jKnjCbnBiE7RE5EDkAeloM/kvXVDTgUFk7jsHVYM0GhkDBnNwgBmXKfCKEiJE+uwdmbm1cxyMJcayg4S+dO5IyL9h0Asibrt8PO4jE7OflIAH3ZWiw6i8vtlBljOa8y5Biz5Rzfz/V9ATCoZyKtdSbLKuQaOKOh4tU2mPvjPYD8PTwmH3OatI44pdPZ/gUWgNxy1DoG6nDnU8SqDxitwkUf8Gg74bwPVEXuIx6vCQxaozBxsYd0A3vjfItpClj3xPR99GTBqVBKTYaY4D2lxI0hr0JhkFOyTxR6SPto+Q4AR/yGOsuNe4uL1WRFk9OLKN9bwIGA23pRt6ZYv5ytx/yY4JDWaCrmYn9WAb+iQRZbMblBk6LFn0BtadlLz1F5sVF8M9ZuBlrTYj0xi66wywjV50eKMZQCN73gzVgXhn0MtMgGfl1kUE5pJdZ+WUqhBV6AFqznOt0ETgHSa0VisR1Jf3g0d7jetVAKaFtDLavZI1naswKAYiospYTEqF9An4DlzDQF8qy9vmzZuksKvIo2/av3NzyHSjMZgNiYKZC2eRg8ppnDNNHGKe8/TQFnmxEtNw8530zYDh5zLuh4wPM7Jqoqt9pj1tJzQwS2MQCWNuvBR8waR5tJVXkOAMcLB3Va5BdKida/yGTknhUQ0FhNHflU1bwDReKgcHX735TAjDB2XlvAmUJMMb8PFbXUz3/yPUNM2Td5DEVLWwMZazTCUMCuzEPa/IutYj8Gsppi5tBZjYeXA0wi8D2myFrkhPNxQms01mPAg83IACrsnEM53MwUG01Fo1bjrfMpA2JnNZ5nxxVqc2sxb3SWXkhgCHBAw+wRmJGvA4nE7Fl9/9XnWILY/okzWfSjV1y6dxxXWbpdNeS8alXAvMxDkZkJoKoBt6TmfUzwqTgFeba/7H3EEANcLCREAllXitNMZoGrOSSNeuqvK57aRzOLIUQAJhfc7QNscUxaVc1KlKK1u3O0Nt4/73G2mXAxTricJgb1IbsvxVTY2jog2MmUGJKEGe7SlgFy53AyM+isyR7yNw5bzFsCkGsOmhESZbpYGkTyOJVt0lJCtkkdQ8zWo0qpzIDXwafmdSTx9xVNfr7OKFlGYWZXgwDkIjNwrA13mlstM7jMFmiWmmgczR0eboa8NjZsmSY+5PL3vKcwI925UqS+Q8JdMV+VQnZJEvZWmum80zC8/y86i0erMWdQrfy9NZzx1CV7pso1t0bvZNu0LjUJ9XOzLWUku0BINi1W9T7f3G34HkD+Xh5TiDsepABypF7/LT8/UlvSw5SgEnklPu5HrCePyyGgixoXvcfDlcYZd0GbfMT5ZuT0IqVK1v0Eayg6fftiwjhGhDBRAZe1ubFHkx0qImtRdWaQUwYIRaSvtcKyc9Ba73TJEnuxRaPzAiKLt1Fg7bPODGu9SqdEafRFZ3cqqFurccHPWw8htwu2WmfWgs5xynrm1hV9IPmMhkrQT2DAGgOlEjZDOQatS1QPIPsjCzDKcg9u7CTMc8OuE/l9VNE5G6Vwyt7CWtFCJxpI0fnVgYJsjIZBesfuGgAtDsdtAx8HTqlpeGb0l43GnBdQozVOFg2eW86glcJi0aB1BjcP2mK03xgOjky2gavBmDGameSUQUhkIHUysxksR95/qXU1FYp6HzBNCut+IulG4mp9LvgbBuraOE0R28Hj62crKEVWcufrMVs2nW9Gsrwy5Chxvh7R8AYggU/L38NH8lp1PC/6KcDZNl8nrYiFUCDJjcQ0wu5uhtKVEqDgRQBySpSy3wyl2Kqet3LahHGrR0IJeqTQT66lgKagSzGOFKzIRhufeMddICyOFlo9yfjVLWwBSnnPGlO5X6TMIHtmBg9nDl+7u8KJnNPoEZLBFKnQquPOWaOfOM1fAj8Zcq8oxWDYaTTW4NFmgrUGHWsUXzo+yOzxUce+tlqKa4nxTygpe/qeu1Ko2q6qPIf+lbVGinyuGhJcvFu75f1xFYi46h1iKppVYb/2swyih5eAWoC/1ExI8Cb65MkTQB5DxKBjDrjFa/lyJBmTgNwa4Iqvb32vi3e5NRo++vxePtBn1CSCDwSmjVZZJmG0Qu/JIm0MCXfOegwh4mL02Hi61/upAsgVuKwL0oUIkUxky/NEuijOW4uThcVRS24/jSaS5vnjDqfrEUaTRl7m4pxdMYRckII/8ToX8D8G2ncECNN1K9ILIULk78URpcwBYeTlbzQvA3eY0xm4WsM+xoaAf2cMvCLJVGs0Fg2wdBYvnMzwjcfrvC40RuNoZnHZ+yf2Gqt01u4uOi761mCSwGRLw/1R2N1yTzmrccXU3hlWF7mjsNnyPvPG5OBdZCVAIcMUn5va9lIe26+1kEDSh4hG6Xw9xJbTWLWzFr7jMX9Tz3pv/FcZO8xS3kwpUhfmyVQRlVTkSwX26BPWI7kmrJgVWvceD43ODJwPEZshZq3w5KnNqzEasTU4204MiOlm/u3757mYxnAFfwgJwQek5HIKTNKydWGJ1goHMwfFYCtvSNbklpXbMeabTikCmxfbqUqj7KZEE6dzW7bJSSjRpmhzJSUGMGOXInQUd4ICDgSgypiYmabPk5ahCiN2pR4Z1PKiaDTQNQaXvc/v2bliNyVpLceWYOV9VInGFRW1LFneQOk2YXxIO95BNjj2Ta0YsMaSPo2OC3h22eFsoNSxMMsAOV/MrSFrOqPw3FGDk2UDrRQO5w7OaHz0ZgdjqICv6ywV3BmdC6cAZpRBwY58TyO6PQaDt8+HLLWJkayPpPvV+XpE8AHeaAyDz3NMumZNk3Tuo8LAcQz4xllPz/GRC12Ixb/YkK3c0Yx8ty/7CQuQNd8wVT6sKHrNw4bSzBvvs32XaAiXHVWVn66lIUAJSPrq+tHxpp15NW8MzhSDVtJEcEq4zLN6DtYbg8wHsZUDirsB2csVYNQxiBcHi6dZcOW5HWLenKURhQCeEBPrhyNLmCIXJqVskXc5ThgjWeqdbyYsOT16zABh6wO8pp8verKTXHMKX4ATSVlEU5iydrRh3ahYDm5HCsbnrUVrDbrsvuJwPDO41jnKknSOu3FxG2tN3tpLVc5n4n8ljb5b+Ebnp2468DSdcQlOr3z4DzxK0KuyU8r+cIZ0pB1rt2Wu1HZgWZ6QSG8/eCrIm2LZN4RBXk8eq95ndrQG/xNbV6ZEQaY4lEjGT2Q5gdnqngti6+OgTF/AGGkedM6g9wHn2wn9FHFv0yOmhItxIqaZM0yUpQKSKpkaYUOFDBA5StdZtg7T+fHDucOzBw0W1mIIIbemFjBLZEjMUo3jucPpeszSteKPXnT4IdF5BMqe4QNbukl2SJVW4pEDFqjdpjUAsiOKkCZTSGiZoJq3lrObND8bQ04VjdXQMaFlOclCaRw2RBCIHSXV+CgujE2og3Lap6QAnrItUpCeA+WQdvY5GfInCeC0Ap/Td0bIVmk0O/s4/10rLNqKSFOFqKrfUuo5ZNSkwVUjZ4LqIFj2qas8Gq865m/qWe+N/yqjXmDkJwHNSqlcuesiTeSJ2/XKlj2GhHN2OOingNZpbEcPrVnnxCJ9+ZvViguiAoyhVHg/BnhPoEJrhbcvJmYBi25Q9GApkaZZ2GNdbezGGO5kpGEMsUPyuHQ4Op4ZnG19XugVqFivn0hzK6zpHonMUaWkwAqbl31f9yyNxFZon/3ZXwx8TLsAWYt0QuQXBZA6U1JARkuhXwH0HctHMsu3t0jK+coVtkph60OuaHZa78hVphDRVd+nOB4AVhG11LBsRYPaMKvH5XgB7DYySXTcLxw02W/6eEFM6mefvUZMzNyhawzW6wnWWU6F83sxm9w0Jn/n/fXywfk2z43sfc1gqe8n1i5Hylj4gBhVzlCEQPMQADtjkO3bxMU6fT+h40r1vidd+cncZo9dajFrMzOtFYDETBD7mEqhqtx2WhHQvLYgycWq91k3KJuQzC2ZScUZgH5vpVUy9ttMl/u4Dhpq95Msm9G7LL3ME2vKea6BXmSGy4eIpjr/NWgWjbRiBlmKjqQASdp+j+wzvWbAMnpKe19OZPG4mQIue4975z1OhxHvYwZ5EAebBKzGABcIhFDnRWEji+5epBVUxU7SnpYlFFMgreeyc2icxsMNubgsO4trM4vrHWU4jmfUmr2zGlOkFLSPCQcoG7IEwjNncmYKQC5qApBTvAp4Yg7LIE32twkdX/E+kpIvoOnJnIDYP/pQ0t3Olk5pcowCjAT4+pgyoJUxBgoOxSvfs3xnZB/xqQr8hqlY+MnIhXkp5UYe9TGHmLANAcaT3eYwBRzNHdmNbj2GkPCoH6EBrAYKqKR4k84HuQLbat3UXJfRsS2Y1gptSzZgjSv1LNcWLW4uHJbOYowkH9Saffb5AsvanBKRG6L5Var48ct9FTi4n2LM631KyCwtzQt634aBemaWK+ZURtkTqICun3x2c1h2NneTA0CNNBw9pgO3Yeb9Zd4YPF6NOYtYj9yMC3L+VNUKm/CAgObagaN+/b7sIkt8FBEy74SPJRApnSALc66g2NcYuQB1fyi+GeuH3u3229/Pv5X79T2A/B0csiEJoyNVvvtpNmLTCnDx4l8ZS4FTSgk967FkApWW0TpXqV+MU075ToHYm5QoTRqizW16Q4yIXIEvDhSjJeZlHAOs1Zgm6mpFhVjU9vV866u2wwxAfczAh7ROhUEUhkEbnfWrxii0reHIOqFpSLx/3Dq0htqHCgBxhkBIN3fcWe9JmUWuis6gg/4unfj22bqQAFX9kbFS/rd+X/GeTIlAe8dyBNk8ZVFpHfkVbyJt/oez4qWpQCzkhnVuwlDtD2GiafEioNFyz3mjkQ3YFVQ+r/k7KPJsVKBFKDHj07JW7B6zrfX5ktfJIq61woePlrky/fnjFpcDMUHGaBwvyVP5kdqiaUwunFKKPJOVVpjNLDEXevc7aq1wthoRY8z3ARLy730fyAUjmAyIdaKgJ4SYO/dZw1X3U8Cjy4GYMR/R9wHjnDar7dbnVPM0RfSDx9QSg0z2czG3Bo8JGNjqKMSEPoQcWElarnMmW/jl86eRN1kCeyWjIVpO+fo1+wRmnqWYTdhkSd+W66LyfKgL52SeWK2Qqs2mHpKSHnzEfO/vZ+txpwhLGOTLnoqh1gMF1OJSsRkDg2ICHGtPaXjpurnx5K/uQ8T5OCEqAle9D9lfeDPG3B1x8lXHs0T3lxF9pSFwvOwsZux3esQFPbPG4mjRUFOiYcKMXQmudQ2uz6lRwY25xYJ9VK1XO1pQOk+KnWj0E2uwAHaA7RLfhTmWa/0HHVJH8bShlELrNAa/J/Xg+7Zj8Gq5oKtlja3VBCZFjiUgWbrWlU5s9OmDT1hr8gP3KWYbv+1I4IwaXxBJIYV59V5UADSy1/7oyTpOyI3BR8xMQh8iHlyOePaoxTYEnmMJD9cTjFLsRkNfc5pKa+yUKi9oxR7HRpNjDztWSHc86SqqADx/6HDStpg1BqkvrG59jXsuKhYCqrUal9tEkoMqCJb7RhhkkZhIZ7/9DoVdY6Chsj/1/rySQEbqyhqWKLbOZHlF7SXcZO29yQXYVpObxKK1XLBe5nxI1HY8A/e0K8+TsRpCLgDOLH01P2JKGVAXoIwcbLzboOC/yCGosJQ2XVNdi/1tceceS7vNbb5ZmUR5/e/v6cB32Qf5P/7H/4if+qmfwgsvvAClFP7JP/knO4+nlPCLv/iLeP755zGbzfAjP/Ij+N3f/d2d5wzDgL/0l/4Sbty4gcVigZ/6qZ/C7du3d55zenqKn/mZn8HR0RGOjo7wMz/zMzg7O/sOf7snB02w3eriq6KY2j5Jfp8Y/NaWOP0Uss9vSikX2Y3clEDSZJEXXZJckLWStGXsp0CepGPIHb+GIVARlA+5qYdnYByTaIwJEI9+17FAbIIEFA+cEiMZhUZgEC1elCmlbNwuN0XT0GZ4vWvZz1Fn0X+rDYOUXQa1RMLlnApzKRGusEW17ivbBFUbk1KFsSnvhWyrU4oBeOFIRUMlco7OaU5T1UU+Kqd1DzrLOq1SRbw/JHUu30Wak8hnis7U7gEmmWMAAWmrygYQE73vo+2IwD9LapA+k7VhhkDgCyezrJf78EmHo87gG5draK1wsmxxtGjyNbPWwDlyJbHOQmuNjjXmxpi8KSs+h2R9RmA7pcIiW6tzkJWYYZRGJIA4YcS8caREQdnldsJ2CBkwC9s0TSTJuHs5ZU9uYiEVSzViboiQeMNoDDWmGQIVBcZUKp/PN1NmHxWDDjl3u6ww/Vuq2OlaihOENL6R/SSllEGkaOFlCHMs/sZPzpNixr/j7BJLId2+tjkmKpIS71gpxJIubNJdMzFz2Afa9IfcgAfEGG89Lgayiex9wNkw4vF2xMXgEQGEyKACcj5C9qCeqmwTgFyl75xGxw0J5swCzjuL4xlxOLPW4JmlQ2MVxkgayZMZBdXSrOdk7jBjuZaktfeDwZqlr89Z/be6il5ef5VkRdaMP8h4tz1eK5IiXAXYaU1UGdA7q6njJqfdpSmQFJEqJb7UBWhEJgammLAeyfUoJApyRAMMFN9rKcwT7+QpcIOSikEmZpXupVVPrHTk4JMCUirEffu0x+ADVhPJec62ARc9t4TnNUqylXS+i9RAKa5dMZqdDCjQWnQOJ3OHRWPg+XvfXDjMHRWBBQ7KlEK27pPvQscPnG8mzFuz08rb89rkU/HqFhKr4ZqDYYo5OC3rscwjZLZZPkf+pWwRF79xJnS215FORmPJSu1wZrO8QiuFg4Yaocj1lOH5uLQE4sAT2QilqOi2ti0FRGP/5Jys5+J+A5GnjbrdNlDWQJFS1u+xg4mrn2sbQyERfz/jW2GQv6sAebVa4fu///vx9/7e38NsNnvi8b/1t/4W/vbf/tv4pV/6JfyX//JfcOvWLfzoj/4oLi8v83N+/ud/Hv/qX/0r/Mt/+S/xq7/6q7i4uMBP/uRP5s0UAH76p38an/vc5/Bv/s2/wa/8yq/gc5/7HH7mZ37mu/Id90fi/+Xf05OL7Y65OjgK31vIZNOSlFlMJCGoFyefElYTdylDyk0QNoMnYJvIbaIfPUZOgaVELgDTRIBYwIeAYqNVxRgzG1ExB8ToFVA5BdEnGzSNzpt001DaNCbSHM9am23Ousbg2tzi5qKFM2TMLsyZM7TRdc7kimEJPOgzCejIOdCqRLilWpqKLIRBqm/j2nKodguQCLduwCCRfM0MEstHFcxHc5fTTkCx3JLgQTYyYXX3hzCG9dw5nrsMysi6BzseywplQdGKdF5WFyuwge3oVtOEECOMZvP6vXB6zkzwlhdKoxVOZg0OO4PLwcMYhRdPZnjuqIVSxBRbTgNqTUxybuJgNKwzeZ6Lf/I4BiDRXKg/v2lMlunQXGfGK5a5nzibcjinQhvRFkuLWQLIMsfp5weXAz/GLLhSucC03qimkDCzBiECYwj53rOs/VwPHmKlpbGb5pM0rsxLpdgCEAVAS/cwcaCR+RlTaVIRZPfi75/dKnSx8dqdJ6XgBSia7omLo+p7QoYEzAJ6hkDB9eipeZAAYtJlUzOhy8FjU6XL197jtB+xGugz1lPE2TDiYT/gbFscYXofs5ab1qkAH3d1qVoptI1h5wGSwHTO4LAzOOgcDjqH6wvSRi5ai/cdN5QFCBGL1uLGgrpvkQOLxo2upXbsjclFviHtpmwT6NwJU75/DYG6WJDAUUItbUP+d7/g6lsZtS50f9Q1BU8wj6AC25ml+9Yxs3jQGixajZZ90xV2A3phQmNKuNxO+bv7kLAeQ/YEp4LMYv02ebp2IbK+OBKoHCJZt00hsTSLgncfKXhaM0ETE7UaVwrofcBpP+J0PWLrqcPi6BM3jwnYjjE3dRJpAJ0sIgkSqBi4tSYX30rTiMOZw7MHDgetyYXIU6QM0c2DFlOMea0HBPiDNde0zm7GgBv8XIAyTAPL6jIjz/urUtRpT/TYotOvL2lEwlQFrnLd5bGUSmdMmVfL1mC5Z5mmFEmQThYO87Zora3WWDY2d4XNp4tJM6ltqC0AtVKoj3LwpZNhbYX4Tm3Da3u4b2bsA2HgSf3wfhy4IwsTAoWzEfvr23difFclFj/xEz+Bn/iJnwAA/Pk//+d3Hksp4e/+3b+Lv/pX/yr+7J/9swCAf/pP/ylu3bqFf/Ev/gV+7ud+Dufn5/hH/+gf4R//43+MH/3RHwUA/PIv/zJefPFF/Pt//+/x4z/+4/jSl76EX/mVX8F/+k//CX/0j/5RAMDf//t/H3/8j/9xfOUrX8HHPvax794Xxm6kCDDQ4Y1Wxs4igMICxQpMC2NcUrm0GcriZjiFufEBqQUgGxVXAUvr24lTMADgG2I8yXpLs1m/hveB/W4pvVwzxmTNEjMjIY+LpCLwMTqn0TQ235Qt39CG2aJl56gyGAmz1uL6wuLl55b4d6894BbI4mihM7CQNp2yyEsaWtLJBErqimJkoCJFG9mIHIU9rO3ZpEqfFipmpXkhkYheIm1dgRipmJfPo5QkMkgA2LUi7Uba9XVXVyw4WitO0aXsiiHNWJQqG3UCg3CtKz0y6dS1AvoQMcVSbJLnWqJjmLFmetV7tI5m58VI7alDovn10o0ZVZ0rYD53JM0xmpljdqhICYbdLmTukkuJzu2mZzO3Qw0sZw539xbiWg6SG+DEhOePiMEOIWZpkPhuTxOl8KnAT+F8M/F85G5bUYoCScIiW0lKVLgY+R4TpqK1GuuefYqr1uEStCrF5v4CkBlsDIG9Tpk1cqxnFKYyQnTtMbPAtfQqZy6qYG9/Tlyll5fAGgCcKZ6xMg+E5QIoKO0DZ5N8wDIQIF6NZLM0RmKUT/sRTmucpAZaAZejR6NHXA4Bh53J7buNVrgcCojofYLhYI2C5pI1kHOnNTUysAxuFp3NEoGjRYODVuOwtfRYa/HBgwVefdhjigkHrcG1tkFjNS621InsxrzFevRYsHzL6CelSCklOGvQj4VQoSzL7jmWAKXelIHCzinQFP5m0svvNJ4KjiGuNgwkrviYBXtQA7S+zRqq41g4C8CjMeJoQXPUGIXI7x0SyWgOeK4NPmbJzNJZkhBwFqDnAKmJ5KLjOSMgc23gIs7NSBaSUty58T53KE0gEGq1Qu8TzoaJJTzc8TJQ8Oat5oZF3AJc1gX+/nNLdoOGv++itblI2xiNa3OL5w5aWDPmgPXxhgLcnr+j57VTsqghEtgFwB37Snc/zYB/zHK9sj6MIVLjqc5iinS+QkrY+IBlKtBKMkRjqBhmfkzuUc37k/xdMgJiGyntrKUxBkASG+meOuf7ZD+YniJ9VucMf+/dolyRg9XF4vL+zuq8fz9tntbT/508wZ/QXfM+RIXtRMzMuEFX/cya9Q2xZMaprfrvjxH+/fPH32UG+Z3Ga6+9hrt37+LHfuzH8t9msxn+xJ/4E/jP//k/AwB+4zd+A9M07Tzn/e9/Pz7+8Y/n5/zar/0alstlBscA8Mf+2B/DYrHIz9kf/+Af/AN89rOfxWc/+1ncvXsHjx89xP17d3Dn7bdwdnaK11/7OrbbLb765S8ixojP//bnrv4SNVOREu7eeQvTNML7CW+9+TrW6xW+8epXMU4eX/z8bwMAfuc3fwMxAV/+wm8CAL78xc9jGHrceeP3sF1f4O7bt/HwwX2cPX6AR3dvY7O+xOu/9yr6YcDDN7+KKUS88dXfQecM2sevYTtGKE/OnS+Eh+jigJeaFZ5xA26qFT4663HDjPjMYY9OTfjhg0tEH/Dfv3+LGCN+/MYFUkz4v3xkhEoRn5mf4chF/O/fn/C+ZcSLzQbffyPhpWvAD98KuDUDfvzFiM4p/PcfHJFSwp//JDWZ+IlbxPz/6Zciri8NPnu4wTUz4DPXPT40H2FVxExFPDeL+EB6jHunK9zcvo3WaDz4xu/CGY3Hb3wJAPCF3/kteO9xfuc1eO8xjT3W54+xOX+I1eN7ODs9xcWDNxH9gDvf+CpijDi//WUopfDw9S+isRofnt4mf97TN6HDBHt5H+uLc6xP76G/eIjt5SlO793G2fkF3vy9r8EHj9e/+gUAwFuvfj5fL6MVHrzxFUQ/4c4bX0e/vsRbt9/AvXt3sbl4hIuHd7C6vMDp3dcR/IgHb3wVPkS8/pXfgdEKv/Obv4GUgN/9/G9hnCZsNxuEEHDvrddxcfoI9+7egds8RupXeP21r0OHEeHR61S88eg1NFbj7DadlzRukVIEHr8JF0eMp28Bwwp6/Rjb8wdYXzzGyXQKTFt0l3fQqAjte6QEvDi9RSzg21/GMEV8v3uE7bbH9tFtHJsJ6fwBFn6FdrzEJ49GmGmL2eoeFi7hT97awhiF/8PxKbTR+L9+hCzp/tvDc8w7gx9/MeJaE/FHnov46DXgEycR33c84cUj4L+5McIo4MaMMhA/fuMSKSX8hR8ktvBPvzhAK+D/9DGNGSZ89tqADx4Bn7kZcUut8ZGjhP/m2YB5HPDDh2s4HfFnPkLa+P92+RgxJvy5lyYMU8B/974BnY749GKFxm/xAycTPnLgcZhWmKkIi4Sb/iEQJnzA38PgEx5843cRkXD3976AmBLuvPYl6BRxdvc1xGmLdHEP0+YMq9MHuHh0D2F7icsHtzENPd78va/Ah4DbX/s8tFb44ud/E9YovPm1LyDEiNuvfQV+7PHozuvYrs5x987buHh8H6ePH+HObVojvv61L0PFgLPbX4UC8IXf+VyeewDw2le/iHEY8NrXv4bLiwu8dfsN3L9/D3F9ivMHb2O7vsTDt1/DOI7YbNZ0//z255AS8PCNL2LtPR6/+RUM04i7b7yKzWaF8/tvYVyf4/z0Ph4/uINhfQF9eQ8XmzX6B68hxoDp3qtYDxHh3qvYTBHHF29gOwTML9/Get3j2vgIJgWY6NEN59DDJZ7DGeYY8Yo7hUXED89PAQD/x2dWsFrhU/ourNH4kZM1rncKL9lTzDHg5XaF97kt3HCBF80lbtgR8/4eWuUxv7hN1m4Pvw5rNC5ufwlaKWzufg2NSrj35tcRxw0e37uNy/PHGMcRwzBgu7rAxYPbiH7A61//Sl7LY0r4xlc/j5QSfvs3fwMxRjy6/Sr82OOtN17DdnWOe3fewv17d3B5foo33/gG+u0G3/j6V+G9x3q92rk+8u+Xv/j5J67Twwf38fDBfbx1+w1cXlzgG6+9Cj+N+PIXP7/z2le/+NvQSuH2178I7z3eev1VrNcrvPnGNzBNE2KYsBjP0UwbHPUPcegivs8+wlFnsDh9HU4rLM9eh9MaPzx7BKOBT7dnaNMEc3kPqb/Eg3t3ME0jQvC4Nj0Gxh7p9DYsEtTD1+BDwr3XvoDzzYSz219CiAmnt7+GTd/j9d97FWO/wnh+D2ePH2B9/ghv334D43YNf/oW/DQgPPwG1mPAW69+nqwIH7+Gzhkszt/ERd9j/eB1xHGLdHkfi7jGtXiBG/Ec87DBM+ExFibgR58nG7YTS0BufvoNpAT86Rd7zBuDTzanwDTiQ+Yc71sEvKBXOA4r3FA9zOoBjozH0eYeNAK+8ru/Q37Lr9Ga/ju/9RsYfMS1zdvw04CT4QG6sMXje2/h9dtvY1o/Rn92F3baYnh0G9GPGO6/RsDyzlcxhYSvfOE30RiN1Z2vYZo8usu72GxXuHjwFvrVGd548y2M5w9gxzW2j9/CZrPBgzdfpcB16jHFiG985XeglcKDb3wRwQc8fuvrOL9c47Wvv4rTs8e48/ZbuHvnDvrVKU7v38Z6vcLXvvJlxODx1S9+HgoKD79BUtTbr34eEQnr9QoxRZjzOxi3K5w/fBv96hFWZw9x/+3bUOMG20dv4nK9RXr4OoH7e68CAH77c78OAHS+pgmvfvXL2G5o7tXYaNhc0P3B2Cilgo1+57doHn/+tz+HGCN+72tfAqYRX/va13B2dorTB3ewPX+Ax48eIpzfxenZBV796peRosdrvOcKNvqtz/06UgLuvPZlTOOAN157FRcXF3hw5zbu3buL+/fu4a3bb8B7j+12g3EYnrif5N8vfv634b3Hq1/98tUYbm98zxTp3b17FwDwzDPP7Pz9mWeewVtvvZWfY4zBjRs3nniOvP7u3bu4efPmDsOilMKtW7fyc/bHz/7sz+Jnf/ZnAQA/9EOfxcn13fc/Pr4GAHj5lU8AAD756R+8+kvsfeazz70A64jxeuH9L8JZjQ98+KMwWuETn/w0AOBTn/khXGwnvPSJHwAAvPKJT+JiO+HG8x9EiAnXD65j0Vro1YjQkLn2+164idP1hMPnXkKICc9++PsBAOeHL2KznhBMC6cUbusbeDA8xsOxQ0qADXN8/pQ2zLc2BgcHGv/L2QJTOMX/8/UOiwXwKw8OEOND/D++3qFpAHvzAzjtz/A/v6kwX2icu2P8zv07cI3Gg+Tw4x9e4H/4PSAljX/z9gyHh8A/+XzC8y9Y/K/bazA64H981eCVj3Z4U8/w8nyOL67O8L974QhJG2xiwGhneO6FF/Bok/Bo9jxeNAYf/NinEVPCix/7FM43Ez78yidhrcG15z8ENRhYp3F4fALVkS3RbNniGCTbef7GK1Sw8fzHcL7e4P0f/SRiAt5sX8CJUrDXX4TTGuuDWzCzAywOj7AZAq5fnyM1B3Bdh4989GN4tBrx4svfDx8iXnjpk/l69VPAMx98BV1rcPTBl2C1wo3r13CxnTBLAzqncXQ0w/XnHFzjcP39L8PHhE986gcxTAGf/IEfxBuPtnjplU8SezunUqqbz38A88aQVnPuYWYtXvzQLfzq49fhF+/DFIB448MwWuHofR8HtoBp51BKQ518APFyi8Nbz+LsYgOvO8yPjqg4rpkwMw6Xs2eo25XtkFLC7fZ9xIA+/1Gc9xO+MF3HZ5XFD37/x3H+G7+Bx+4a5o50jb97eYofTA4P4gn6uMVX0wm0vsR/OD2GMY/xP19cg9bn+A+PloAJ+I31Ac77Hm880lgsHFZdh4ePI84vBnzEXEdIwMMtkJSGe/4jUOor+Eef85gfNPh/vdEhYcD/+NWED7+kcO+ixe3zFe5OGidnDt9YGXzlUcTREfCrqcUYRvwPXwGOjiL+/ekRUnqIf/Ylgw9/OOB/ettBa+DXz+f4YGvx6/eJsXwhLrCJxA/cs9cRtcNr+hncignXX/wELgePj33fD+DVe2vc+MArWPUehy98GGebCerQwrUNlsuGdZoRnbsGZzXe9/LH8fBywEc+/mn4mPCx7/sBOKPx/o9+P6A0Xnr5E3TPvu+DWPUez91cIJ1usewsGnsDnTP44Ec+Bh8irr3/Y0gJ+Pj3fwaDj/jUZ34IAPDSK9+Hxhl86CMfRYgJB4eH1GnyDGjnM9jG4Ob1a6Tdny0QU8JHPvFp/N69NfyND2E9eXzkg6/g/v1zdIcvYDNN+MCN6+jvnmJUCrZ1SAl47DQwAXH5HKwxWD7/MVy+/ghvtC9ge9nj0cn7sbkY8ZVwAyoCl+MhgjKYUsIjLPGxxREuGuDcn+MLOIJSCv+/zTVovcW/Oz3CyVLj4uhFOPMQX5iu41PLDo/GBjOtcXxyAMtNOh4Yhee7Brfe9wLivTdxtngBs5Bw7blPUHbouY9Cnz7Ay5/4FN58tMFLH3kFv/36GT70/ufw9ukWbt0QCz0/gumWmM8c9PteApTGJz/9g9iOAR98+ZNYDwEffuVT0Frj2Q++TPZTz7+Ifgq4tmiw7CzONxOO5g7rwePwIy+TN/himdeG+t9XPkFrxoc+8lEAwMHh4RNbRjtf4vFqzM+V137kE5/GxdbjAy99AtZafPDDL2PRWSwWS7jbDj5pzI5uIaaEx2uNaNY4Wxzjha7F/OBlXK57qFsvoTEa/+vmOpz1eBU3cKAs0uF1xJSwuHYMc+ngnMEddYx1jDifH+LDjUN/7UUMIaJ79mNY9R761kcRU8LBcx/BaT/huWc+gLcfXACuw+LoCBfoMVs0uHFtBv9wgDINVgcvoJsmXH/+FSgFPFh8AD88s3jTPYflkOC7W1gNI/ziCA/vX+DOJmHeWcwaC22WGDDgf3mrwfGxwVkgn96T938C6Qtfwv/77gI/9HKD9cHzWA8Bj/U13B1G9LNrWBxegwmkjT8Pb+JL0wF+dNFhe+PDGB5f0Nr55jdw/L6PYzsG3GmexQe1xeP2Ji4ut1hefw5JK8RO4/hkict7b2M4OIF1DZqbH6Li6edexvjgEi/9wA9gNXi4Wx8GtMHl4hk43WB5ch0pJXQHLczQYrU+hz46hHYdbrzvJaQ1kFyHwUe88tInoRRw48VPIEDh+PmPIBmLWy98kAvANVa9x9YOWLQGpmnwwgdp7//oxz+J21+7j8/84Gdprr3yafzegxXabo7NGHA+u4WT4yMczG7g97YPcPPmNVxsPdR4CrU4RFQW+gZhDfPMS4j3LvH+lz8FAPjEJz+NL7x5jpdefgU+RBzuzd/Hty+w7E4wm83w8iufwO/evsDHvu8HEGPCp37gh/g9PgOtFT728e/D41cf4doz13F80AJugZXa4OT6MfTDCLgOL738Ch5cDPjwx8q98LW7K7z8fT+As82E6+9/GU3T4LkPfBiXW4+DG3McHZKDTWM17G0LYwymtn3ifvrUZ34Im8Fn3PXSy69cheCeGN8zDLKM/dShpAjfaew/56rnfzPv8+0e9afJRyc8SfWnhCqVwdokSUXm55TUjuhjpWhCnjux9q8eUmwHkPaotHVFttGpZRz095hTh5++eZTPnVJAaygPZLmN54vXyApMfHHlHC8WDrOmdLI6WbY4njk8f0Cb1cnMZt2lMxrvuzbDWV98ehPIm3HesOdzVZFeF+XV+k/R3dYeh0aR5dqys8VLGaV1aHaqUOJVvFtMgSs0gh07S0gbWKn2Hn2szhWnyyUNxKlM0eiJHdKOlQ7LHeQa1skm0b5d1YKTzkXpzkcOCdzq2Ih8RCNE6iBYa80k5Xg+TIiJWovfPy+9w8STU9xA7q0mCjh5YQJIR3u0aLL8pescjpZNPgdta3MaXV4rw1qDzVgM6Y0xLB1RUFphGEpVtlIK9862+XOpC18ld6g0aVQIVrtLiMxo9z6TkTWGcfd6RKSddLdIeOR4JU1YV2HHhFw4JvpQ/tBsw3WVv26ey5yCVcATcwQoTXTq7yESi5EL4Grv5JSKe8FqCtiyXd7gA06HARuWzWx9wMXg8bgfEVLEdoo423pcjoFcWrTCeqR29aOPGELCdiJ/49UQMHLTB9I+krZz0egs6aGWvlyUZzQap3F97uC48OjW0mWf1OeXHebWoA8RjSH/8bP1yOc3Ye5KExw579IVTc6l0bvpZrlHjNp1vhFnApHYAGUt2V+X8zxVT8pcvp1D5GzygfsfpQDyOde0ZpFNpsVx22DpHDG2RmNuiQNruHhRvpMUkiXQejeFxP7FCbPGIESS3Gw96dLHGPJ56gNJJ8RGD6DCO+m46CNJmrY+4nIiCY81GkNI2Urxcoi4HEIu5gwiUeD9SSwMAZJoyb1xMZKFozFUfPfCYbNTFJtSwmryeO6ww4w7SvRTwPVlg9NhQM+FdABwtpWOfbK2iuwg5uZS1Aab5BEkjwPLLWiOn20mrNgBRvbPrQ95voiEQfZpkQnItJzirlRgCrTejNzQBQq5QFb2mp7PvXT+VCjzVFqzhyQFeQkHM0cF/jHt2PNNMWbtce1Cctn7nbbjtRxpd46m7Folv29Yby6j1hBHFE07sOuSUfbO3fePsVgS0vnnfg1ca5F9vmN6Yk3fH9/K/fo9A5CfffZZAHiC5b1//35mlZ999lmEEPDw4cN3fM79+/d3CzNSwoMHD55gp7/T45u9HlJ0Rz/vv0cBgPKY6HdiKrYzstCPvgDrmJAdJgDQwlVpOqUQj4rqVAbNALIl2//nG4+yRkprhdUY8+NaKww8eWtvY6UUDuYNHFcZKwUsOrJlem4xg1LkWRpjWShun25xyYuf06S5Ougs5i0Bph0NYCrnV86xwq41VnmcNGJz1j/LazpbmliI7ZoU4YnmuQ5q9m+u2qHCx6L1lveUIZY6CcUM3lcaMHmmLAbS9YoKteSzkDcRwwB7v7iBrHJIsuBTKeQUbXRrqGK7MUWnZo3KC7fYHPXB49GKpDJWAdspZm/KZWOw7snR4cVrbf6euQGMoo1rsXA44PbUUtAnc0YphcvB58jPOYPffPMSlouN5DlKK2IDplBshbTCxXqEMQpa6+xaAb4+0iBHNkqldhdVMfGX90upBKBy7UphJ7LziwArpXieZf9Q0R0XzSpSmVPOlBCnLkoRv9p6LgkIl/kmE6MExeVa11NR1g3Rf08cGOQmEKk40YjLTe9prm49dy3jTbyfyBbyfKANf/AEYtZjxPUlZcJ6H7HijobrgUARFfmRZlnmKrkYkE5Zvr9l32zNrFhjqLmBMxrHMyq4kyY5zy5nsFpj9Kwv1TTvtaLgopHGCZY090opXGymK8+R3GPilUvnrVzvEAv5EPK9V567Q75c8f5/kPG0t5F5JeOJYkBex7ITkNU4mTm2omQNqda5sFkK+KjoOWWv70y0JNofRvacFhuzIYSsT5aAs2d/7AQqDJdGFAJyJgHSExXg9YHsyEYfcboauYEVeR2PvrJNy7alKXeuk++mNd18j/qR72GND1xrcNI1CAn5+0yBrAhTAmuxKRB8+7TH5Uh+y+JOcTZQl9na0ciHhG1l2RY52BsYjFmlqcmKorkp94C8R0y7Ljajj9BQCJFqHqTIXj5QOg5GXoez/pkDFqNUDuwl+J5CcXOY+J5bcb8DCYCkkH5ive7pesra65pQk3vKJwLatfNVX3mi789N8HclB5zieV4HIPS3Goch1wRIQCrnShoQ0T5eroWcE9mnaE0v96w0MBKr3Hca38o9+z0DkD/0oQ/h2Wefxb/7d/8u/63ve/zqr/5q1hP/0A/9EJxzO8+5ffs2vvSlL+Xn/JE/8kewWq3wa7/2a/k5v/Zrv4b1er2jS/5uDHEdoM3v6VdHLqzYSNWLsCySsdxT+TVyA1PkFviG2Z0mAniVQnajkGMTkCzWW/T8mJ0GAOC1R1sAVDVsjMbFhlnexsAYhTvnIz9O4EaAwrVFA6WAxulc7HLUGVyMZPU1a3QudppCxNvrLTaempxIxxxxRZDvL99DvmF9XqWLXV3opkDFLZ0zuZDI8gJSuxiI17Awd3IK5TqkRDduHQ0L0JabdfKlNW/9HGnRKt7U+VpKMFK9RlgdWWCkMEyOgYCSyt9FABpADVWk8Ye4n/gQceOA2FoqbmGgoqlEzTHoSKANIEZiGM+50UZMZOsl7Mmz8y5X/y8anQGpFFEBQGsNDg9aKg7kgOBo2ebW5MICC6jpOot751sOrnQOsrTWsM5imgIMBzDGKGw2U+7gF0LaYbHFBk4zSrOaggLp7ifnURptyEXWEDu8Ms80e00npMwQC0i21c8AgdFi50Rv0EoBFT+nBjviZCJD2Om6lXDesHnhz76h2F1LcjFjKmsCwNmQ/BxkFmw9xAxwViNZa61GdrFgQHy2DdQlz1MR1XakYsKND+gnchnwMeFyYCbZE4gKIWVLOx8JqBw0lotVFTUAsbRuzBqLxlJBmTUKN5eOOugxg/zsMcmApiBBXRW8awXDWaZlazOjfrYDkNUTrXLFV12AjEKx6pINWDq+STEsT5Gd95Vr+O0YT9sW5F59p+f5WGwCG6PwzKzDmptMJH6NFBbP2Te6MSpnJaSBjcwPIlyI9RRQ2IeAjfcUePFxjSHSesHB17wxGCM97/7FQJ6/MaJnIDyEwO4OCQ+2AxXn8XwLqbSRFgckAKUxlKJjN4qKuU63dI21VvjYtUOcj9POvreZKAi8e9ljzgB5nCLevtzifPAYPQVuKRFAXklfgFSK4s+HCSu2S5WW0z07RjWGAHJnDaZITYjENpGuW8JmKnuBrNUlS7FrZSYuE7Ju+Gq/CDFxY6oC/qSAX0gjcYXZjMV7PURxKqL3e3g5YNXT95FOifLZPkQiXWLplEjOV4HajjOIrYk7AaYpkVNJZps5qN5169ids6OPmQFPCbnZmVhAykSXNUSubSYHVWm6tBPYVkHH08a3csd+VzXIq9UKr75KQvAYI9544w381m/9Fk5OTvCBD3wAP//zP4+/+Tf/Jl555RW8/PLL+Bt/429guVzip3/6pwEAR0dH+At/4S/gL//lv4xbt27h+vXr+IVf+AV86lOfwp/8k38SAPDxj38cf+pP/Sn83M/9HP7hP/yHSCnh537u5/CTP/mT33UHi3roarHdv1DEitIiYap0Um0ZRk8pKQgBTAIyex/hq9+JQU7sdlBaSAqjppRILGhita3Z8Zyczx2mKWZATF3TdI5UxdbrbDtBHCyMEcaYNvsYE+mntcKaQdfbq35nQQYoBfZ4O6HjNknU0a/M9qeBA/D3kHSqAFZxo5AuPQDd9I4Bcu1CoBQwY8ZFnDDy3ahKmk9r6gDV6eJkIcxwyIuWeOuWQ5S/59RaQjb+2wfUO5E3djdhOVarFYYQcmvOyI/tWPOkwg5cbCekBBw1DUJa5Ra8CWATfAK5IUZEJFwMHhcNGcuf9R7rIeJioDTa6xebvBh+9UGPwABEs+1cSsDBzMEYAsFiYfbctRkePN5gzjZ455wqB4CDgxaXqwFdRw1GmobdQDQ1kyFnFZMfGwbPvrkG2+2YWeqmMZimiIOZoyY3o/icAk7S8cKcW2l5mqCgS0MXJddHgpvSMKTuIlUHY/K4YXRdbw7OFju+/QBZpEcDM+SF1U47gY/cj7LJWrNrzF9vnDSH6NhbZ/IxxkjezlOMWHMr98ET8O19RGc1ViOBh8uBbO42U8B2itiOHqtR49V7K5yPU/ZU9exAMPjSWCXGxNmbgJCA9RhwMmsyezxrNIwnecWiIx9XpynYubW0FIwohYFZNgpWU9VincacGxwpUGZK7pP1EDKoFVatBpnkC1zcNAR0CzgWAEOsGjJZIUASKGt3vSb9QcdV4FcCb1vNu53XgACO0xYh0uMfOJnjt+6cVRlFZDZ53ho8s3B4O5Jjg+ZzlBKQFHJW0ceEy94jRDr3Y4i5+54E3gNbACbQ+nY0dwSofcTllhrIUFdX8hsfAvlrTzHhfJwwes52Og0fd1lUuV4H7FmslMLhvOFGM8DlUFyYNt7j/ooa3wjzuh0jVmPAIzNgzhILHyIebAesR7oHVpNHSgmnW49ZU3uy03e+mKYs89twZnD0KQNkH0mGMnq6T+bgNZ3X/pG/i+F9rNGasnrgxl+qkhYwUyzrpzhn1NIqkX+IvDC74aTSvEPsXuv9BXx9LrbUByEkurbCSE/MzIo3fmcMW8V6LCebr7c4RrjqPcH3Ss/BsbTZFjvAPI+rOUtscNp5vqyX0kRIhrDjMe3KzFT1eA4s6nX7qXfZtxbUflcZ5F//9V/HZz7zGXzmM5/BdrvFX//rfx2f+cxn8Nf+2l8DAPyVv/JX8Au/8Av4i3/xL+Kzn/0s7ty5g3/7b/8tDg4O8nv8nb/zd/Bn/syfwZ/7c38Of+yP/TEsl0v863/9r2FM8QT95//8n+PTn/40fuzHfgw//uM/jk9/+tP45V/+5e/mVy1D7S6AtW62/htQ2B/Z9LUqqdInQrG9IampGnQJS1n78QqDllONPMFaBrIh0O8Hc9IKCyCylozYhynw86nYqZ8Cp8NLK2by06VI9YCbZ2wGj95HPFqT3dV6LFHpOEVc9CGnvqwiHW3dkUy+lmxWu6wOdjRrAHs9MtMnXZ2cUWhYo1sz7dnSiaP3xOdFodxUtW4RKK0yZXGVRQwooFmui6SHM4uJwlajeg0FL2UzdJpZ/VQkJBLt5znEgEqeC5TNcYoRDy8pwBET+TGU1qiJNxarNCJ/57Otx4Y1qo/WHuuRvElTAr54f8uNYIC3TnvuckXHcbmdEGPC0bxBaw0zvfTY84ctxjFQkxEFbDZT/t7PXJuh7wO6zjKjbDLons0cAlsYKkWAeeI50TSGHEn4fdrWIqWE54/b3JBGWNquszvSiqYxmDe60q0XH1I5f5qDGpkfGTApOtcCnuTxugtmPa9kThBLjJ2hZJ5WgXBKpQENXfsyD/cDqnokVOtHDrBFBsIbTow5I7D1AZsp5FT3+TARYzhRo4b1SOnvwRMT+Gg9YjVSa2/JKPRTyJ3xZJNveb0KkdjDzUSt443RWPB5t0bjcObQWU0tzpXC9a7dkZmVroUl6JP758C5fI2EAUsp5SZJEhzX3q4AsjQjn38lUrW621zKllpyHXYs1uR6fpsY5H1bKxkC+mR+XwWiczMNBhCN1VhPnrqmptKwQymgswo3Zx0W7E0fsbulFHkY6XzJy5gA5cSaYmF7+yodLtdkihFjDCw1A/skE7iaYsLFSF7J24n9sGPMjK2P/N6xSFsOKpvIk2WTg9LelzXnzcsNe28XALWdiJ2+HD3OWbLnI4Fh8VcWOdnlQEFiPt+RjmE1egz8nAyQA7GlM25AcjR38DFh60OROaXCeIqUQlhgWW/r7KVCacAiLLGcg3ovl8ZNMgWotkTvrAdTSGy9F/NnyXXtx4CePeJFAkHNYEoQRlkIOk7ypaasktwbInOQ9xTN9cDAVlrR+5h21sA6iJRzPPhiEVgfZ5lTJbMTY8rAP580yLlE7mvwzQSr34oG+bvKIP/Ij/zIO34RpRR+8Rd/Eb/4i7/41Od0XYdf+qVfwi/90i899TknJyf4Z//sn/1BDvXbNlT1/wDyRrvzHIWdP8pm+mRbSrXHKiIjRwFF9RDNpdW7/rpaq5x2lutxOHMYx4AYybfymeMZ7j5Y53bN1hIgrn8XPbMUUBmtMGuo5fCq9ziYOdw6IC3qMBHjtB5pQ73oA9JhiR43U8AylMIb2oBj1gXLtDFMeyhduogRg6qzvydQgKlWxcfTaTLPFxN7eT+5MesbO6a0cw2EwQPYM7K6XgROUIGcxC0/FSJr+modlVVlVtRXOCZarKRblM3vR6BMQJyk2OSzASpslPcQxnoIEWtOrUnKsp+KD+fAaS1h3kNMONuGXGRythlhlMJmIqB653SLkTslPrzsdwo8T9dj9mZ+dNlju/WYz2l5ee3RFtMUcbIkuccwBGL2FfB//syz+L9//RFrmBW6zmGaBmitcHTU4fR0mwPGw8MW5+c9nEuYzx1OHxfG6fCwxcXFgP/upZv4D791J8+NlBIOFw3OV2MGS21rcdAaIJV7amYMjJYUpbA8fL+oughP5XMtwYxIJIxW1MZ8515W+Z7bX/qUAnf2evK+zsEWR4OOg9H9Ia+q11XJoJTP5Y07kj/x4Glj733CdiSAuZqI2Rs4PXw5UGfNcaLiu4f9gLOeALEc6+BDZosEpNSaw94nnPXUZKa15FF70XtYrXB9buGZqVYMkO9tqThUNu3cGlqXDAwA3Jq3eLDtobXC26d9Xue2PmBuye9VPJDrNr3OatgE+Oh3zk1kQCGHLlkfOZcJ5dp9e2BxGU/bsyWIF6b6KvZrZJmDTwTgXr2/wmqkwCcmKpyT1HuIwBgDDluLi8HDGpN1tgYlqxYT+fiKLlmKeOUcU7dJ6ignnuDUKCRi0jqDH5+oAMxpyk5RoyIC1xJMyVwZfCkclwzkSddkmd0zSyo6hCqStZQS7q88VnsFZIMPlElQwEXDUjHeb3pfukGmRBmOujuqANj1SMfdWZKOiFa2DwFHc4f4MOGws7SPsHxEzp1PBfTK+TrgtZc0yMgSGKA0BJMAUAIdTLtZJLWH1BrevyV4q2UgNYMcEkmdpEhXCA7JDgiDHFORNm5Zdy7nRcDr5CPAWTHR/E6cndrwXBLw7EPM5J7sCwkpZwt8iNVRSsYzwnCGdj+zQ/dKuVYSgKS0uze/0/ieZ5D/tzhIa1l+r5kqGaUyXu08Z+eCVhtxee+ySUv6xVTpQJkzpViOmUmnc5EdQGzdyUG78/unnl9wMWDiTmgEquV3YaGVKv8qAAtuNTxMJPC/taTfp0BV8T1rjqSpgAIBzn5ijS3KRBYWSeQFAN3EIq0glqcEE7Jw0nevNlnWMDVGYW4tEpBZBKNV7l8vIFeYpVq6YDm6BrgIYw/tJI7q5Tg9p2nFSUJ0VKkCUPvXMyZKjcumLm4cEcTMObM7b8p15m5tkMIO1pzGwAyIFE+Iu0Apopk8afZClI3EY8sg6WIz5c5qMSY8Xg3ZFWW1magrXaAOeBdrKuw734x4fDFgHH0+RW89XmfmFwn5ZwWF/+/Xz0ifzEV6pvqONw673MERAJ69NkcI5Lwy565R9WMpJfzHNx5jxmBb2JQXb5INlyyiXWPQ8OKtNXVZbKwmlwVd2nPXQYjck5TV2QWzEogJmKmv0r40ox6SgbC6BuC7jHRC7W6BJ4bMpbJ20PH1U8kyJBQGWVo+S9e80QcMIWHNutORJRNbaboSaWN83FNzECmKAcBFVUU3ClBDGvq+NL/OtgFWa3RW4+bcouFGBy8cNZg1GmvvoRVyS/UImqO3jjo0LN0RNlKYzGVnseHi0fMNNZwAeLPm+W0Np7dNkUJ0zuRmBACy1Kg+fskcyJUyWj1x39XX/g86lKQlrhjiphPTbtAFoIATZolHH/HWessZAQJBPWcElFLYTBH31gMWjgITDWA9+J0i4Rz4hMDnMXJxmWS8BPwwMFFUfLYeAsbAsooQCkiKBN6pAQmz2qGw9QAHArEUADaO7sOTrs0ZNWt27yuRSp33Hn0uSudW2p6181PMJIhkMwb+7J41w70nEC9JWlnnthPNI5IeSBEjgTtrKCi4e97Dc5Yus6BVIBoZxElr68iMp8gOZchr6voWIbPkfWNCKfRWu4F2XYwrmVJ5sUKRQYwxZFcLkSZk9w5Qwy4ByiNrz4XlFQZ54v9iLEWeVOuSctZCgG3pPMlkzcRa4xTz5wISgFJAJZpz+e5RziM/dx/fClC2Fbb5djvLvAeQv8NDgJyMWs+48zdVp2PVbiERSoq9fi1ZFpUucEDpuFTvpVI1LzIEAbta68zAPnfUZnCieGGwlsG8Qi6M0oocBsT5wmV7N3rdyZwY48xg8TkQuxbRP2U2TNFGMFYbq2WwW+s55Vs7q6v0Z2GQ5XzsLh6kQRY5gzMaS0faKnlv6nK264agVdEoNiwZaatCL4p+iyZcgI7o/YCiJRM2TICFLPTCXNb3s7y/yCGk0ChEYG5tZtSoXXTFeAVhjWkxc1pn5oc2OyqMmBjMyAY18oL3qB+x4dQbtSKm59VtiWNMWG9Gdj0hmYRnXVtKwJoZ5IvNhPV6zO4oKQEXF9Ty+WxNco/afeLVuxfUBY+v/1gxQp53Z7Fym7cWMVIb9MaaDJBTSpmd/tr9TXZgGZjt/r998rl8TcT5QDpMUfEYAWQCsQUsUNCncjpf7sm6mC6DWaUyS3zVGl2zwjLk9zq7I/O5/oyyaTyJkMuawYV+Suc5Xbt1CBM0hgifODXK952AAin68Wz/JGnOMcTMwElxDXXUTHnuyT04hgQFkQIRQ9w6jc5p3Ji1ORh4/3KORaOx4dbGNjN59Jl3znpq/52KO48UdZ1tJmy53fHZMGLjfQYjUvTkuE24FKnVQ66trVxGAGSnmXqjFlnWt0tvfNW4aktPie5rSbdfNaRYTgoLH20m9BMX3CJhDMXSbzN4smgE4BPZPp5zwbTcp3I2cuFi2mV6BZAIu2iYQfahdKgTprIGYymB5xMdt7DFpY16AUyL1u4EJUopnG09kT2qdDAFSE7hOaOZi2QZhE+VW0ViMBwiSUsk6zF6eo7soUDRoMv6Ld9bJGuP2eHnYuuz84SMItUhUiPrimXtB92D4iwEoAQg1XWVwvQcvKAE37UeHgC7khS5XJYuoOyHEjgC2MlkUjEfcsvpUqgac1GvjHxtQwGtCsiWftJmW86BXE+lJBuyW5BZA+T63NXnMvH1TCj4Z/9+lbXo2wuLy3gPIH+Xx1URjgDCOh1Li8Rupbu4MMj7GK3Y3kvlG6VzpT1k5M26YQbZsnbSWoOGq8m1JsA8dzpHYtpovPqgz0V3ml9nuFpfa521zR27Bsj3euGItMuyeJxufU51T9UNIIJ8BY5CIzLYFFC6o/nVCpvB54I6vccgSxoHKBFnYzWqUwinNQ5au6PXFKszAcYCeGTTl5uya0rBhzCwMRVf1QQujOKDEC/PzC7E4n8pN/yOfy52i/ZkwTvfUnrsoLW5OGZuLVX/8sImRQ8TA82ZNbxBRAZCKft9GqUwMjMkurU75xMuekqRbQafwXLfUze6lgsuNxufZRV9P+WiTvqdGOPt6LHdThlIp5Sw2dBzL3vakAkgEyN1etrTe7M7xmYzZUD38Lzn5xPQvfN4Q5tpSOhHer60Nn/7dAMAeLwaiKFW7B8aE/7FF+7uzDmAinmQmHHVIhECtz8vrLDZuyf3GcXsboGSxbjqHpfHZUjbcJqDTy7D+b1QjuEqmFQX9MrrOqcL+xilNoE1hzx/xxAwTpQNKKwacrGUpEmljfcl21nJfVasJmmeC8AVzatkTXqf0FiDmdO43rX5XF6fN1g0JjOAEqQKOHnj0QaHrcuAq/cRG0+ZjgfbHuuB2mCfDRNLgkraeJhilhTVEgsZ0sbb7TBPdK4d37OKr1ljNbrGXKn//naxVU97GwJpTyk/YYZYHBkmH3G68RxEsEbcS4tkui/Ptp6zRZSRWk2etMjYZZABcLBd1jiAQR+v41aXbAtQfLZruYAwzREE2nNhJMrau//dT2Y2Z0CEXJe1SYHuz5JhZMmaBhrLmb9YMg6pOvbCllbWiFFkHWoneBVvYquKU1CIdP9cbmnduWT3jP1LIySFRnEIIhu48pk1ISNETV2Efsi2mDUBQEDzycLten4TARVzoCPfnc5H5OCoFFumRMyt7IU9zyUJBnzaLZorUpuUSYOQiptGvdcV1lfl4DxBQHliVrzgmQzWE3bwCxU/pkww1NlkYLc26Tsx3gPI3wPDcXq3vsh2byPWugA4oGy4wuoKCzV3emdB1cx4CYusNckrnKV/rVXsRhGyREBrhYvtCGN09qCU/5pKmmG1xtHMchEVLWbHndlJK59ti4+tAHZA/IHLoiaaW2FtBfSKSblWtGjOW1uiSSV2WypLKoDC3pIumQ5MgXS6hzOXz41sCpE3xMwQarUDaOobUhoyyCKh1C7AkZtYvo+w1bIox1Ts/HY3aJVZWxmbKeByO2GKxHqueo9tCFi2Fj3rDJVSWE0el6On1NgU4bTO1edjpGKr82FC7xPmjc7aRYD03w/WEy7ZJrCfWKsXE4aB0u2NpWs0jj4vfNO022BmZMN472N+TJgiegz5OWI1CACbDTEyA1/nnl1SUkq4vBzonPHnnF6wRjVErFZjeSwBD8+2kOLQLW9iMq9ef7DKcy4lYJgocJBhlMraWrmPhClWSgrnihSiLnIsFnAFaF+1Vu9nf0SC824YS+5HOilPPp5t7nSZ411DOlzH6eDMRFWgZWSmWJjCwRcXAwDwsfiQhpiwGWPeDK3R+V6N/LtjBj7bzLEca/QRnaW1rD7nD9YDOvbPjQm4vx4yqwUAb683FDxHsRskKdDgI1ZTwGoMOBtHnA8ksRCPWSkUI1B7NfMqmTIKxGuZCt2TCSJ9qFLYV7zPt2tPftrbTNV9sj8SyLe6D5FkKSHifGC7PQYa4lwAULOH1UAe1wKQpdYgSbBf7S0iFZCMl8gaEjOjUhQsbL08VzJKShVdMz2P7peGC9aUQm5AJEWWAPDsoYPTCpfTlNf2stYh6/WVKj0AjFLomFRJieaufEa93+xPB5kzIq+qWeSUkIOA/PxERANADhoJ6YlrJ+BPK2o+pKByJkvx45JJo/csIDKlUqAvx1oX3pbaiJSvk0gU5DuKphjYXVtiSvn+TCj3VUo0z4xSuUEVBUK0R9TnpNYeJxQNv3z27nkAHzdLvPbIn5J9rf9e9oxab1zXOEkguz++XbaL++M9gPw9MvYvsNW70aFoGEvqiRYLzRto5wxSAg47s7OYy6LvKrArN35rDaw1MEbjfOszaDZGYzsGWKux7FyWV1ityJPSFBBxc2l35BenW59dB7Qm7ZtsQpqZJQBs4UPHmKoFqV4EYyJNrHyWpPZyJbkqTJ9E10oV547WFV2pUkBjND5wY76zGNLnM9Dl7+jy95FzWECssAYS7Rq1WwApx5NQdMvCZEpOSBYxZ/XOJpsSsBrYpB6UPr7cki3Pegi46CdsJo8bhy2nRwEk4HKacDqM6KeE83FkNwLS/VExFskohiniuHPZZskZhXEKuNhMuGB/zH6ixhAhJUxTxDRRIUuMBHyFsZ1YYy4BzlRJMabJQ7oxEnj2GTzHGJFk9UxUsJeY2QSAYfAMShO27Hkqn3l5KaA45sfk+l1eknXcNEX0fclapJRwJkCbfx8mKS4rgGw7BS7MIaBpudGHzJWcsalZf763RLpk9Z7jAQ9JR9abrQRxdVe8/SEB4Dez+DdyDKasBQ0z/yWFSilRgAqjJh93NjjZuPJxpxIA9b4w0Y4Dbkn3OqMxa2wOVLUCjmcmM0eO7+eH/ZDvu7ubPt9PMSbc3WzR+5AdWu5cjri77lkLSjaNZ73PbgKbkQI7cr+JnBonj+ftGNCxFZzIoerhTGWliSJPUUpxN00p8H3n8/7t1jvuD9GJPm1sK52tDxEb1gJLUNP7IgEYPZ2Xsy2BzQPnqFgN5b4AyjockXLwIk2R5HGRfIl38LWF48K7AjqBEtjKiCmhs9LER6FzClZjR07x0vESzihsfcjZTZFEyPXJzYCQ8p4yy02qSrGb0yULSK+vA9py7eZOw2i987eYuNGKLXtwArCeaG2RbKgUKgJcLMafbQ0REUYp8vdn0Cw2evJ+QuwIcM2F2fKZqRBLEhDIkO8qwQBJOSgrJuC5Bri1BDGC5CYiSdFKUUGizL1UHGRE3rHfjEP2uTrbWzPG8ns+f3tTWaxn6+8k8j/NQDiiFMtbI4HMriRVzv134m58DyB/j4z9TXD/d81sRu4SB+SNqn7ujXnDkT6/ThMQE3asZpSbzCJrjD5kYGjZdaGxGkeLJhf0aa2w6Fz+3VmNGwuXPZCtUXi48bmoT3SImYFWyAuZfAe5fwTAWk2pKcfgcjP4vGFNPuJsPRYpiiqML0DnR4zE8/cV4KIVOq7cFq1mAnY0lCRFYWCtd+UPcg2kgCenmbTKOsf14LM8Q56fgF19Viqd+uh714syMeabkQrrzocJZ8OIKSTc22xxOoxYjxF3Trc4Hyd6TyRcjhMe9yM2U8DpMOFxP6D3pBu9GIh1u3sxoZ8CDp3LlnOLxmBi6cOWWd5poo2UiuECvI/Z5q3WFUdOmQojFHzI3yf4AKTKQYEfK5twyme1fkyAtzisiB5ZzhWBZ5WBtQRhKZHkQ6Q98jxpGLJmxkY+YxwFhHORTEq4HOnaNcbkay8McimirZxK+JpZ1uE/bfOV61qzkfK3d2OQBbx9M0N8j6W6PaaE1hV7KaDoIpUqxZoyZMMnzbyudPjsq832WvK+cv/TZ2scdbaSFCncWjbZSiwwG33aj1lT+3BN0git6LjuXk64HANGT4D6wXrC3XVP9oxc9Pt44zFw17J+Cni0mbI9ZEoJ64l8mevC0vOtx/6ogYOALVmfhJTYrw+Qk/h0uPoHGFdMAqWkoOlqFjmBiiB7H2FU6ebps9ShyB4o3R8xemKRUyIv6X6KO3uFBFONMVkqIJ9OzHqRWHROZxcEo9WO04WMen7J1O+syZmXGRMY0tVUa4UPXl+gsWRlqVTRhAN0P7SmtCsHwNlTBs5616+8s4bv45JpdEah5aypAt2vy4baqOeCbFWytUvndjKfWx+oux0HZZ0xOUBrdZHiOKOypaZoeRXoe4l1qtybjdUZGFpD1qqxAo5SQyPFcjWgHKosQX4PpXdApDTvsepJBlYK5KzmvRq1pCtxe3j6vfYiFgBO51rck56sl9AMXOvPrO89yVhptUtA0V5enif7fF5jq322vDG+7eM9gPw9Muwe9bR/7UuBUEGUAnzlTzElPDPrMhCg13E6VCYX6wWtIYZaWGMfuILY6Fzk1FiN5w9rAEwbYf5dK1hF7+k4Cl+PMRfv5erjzK4pfr2CRrlZBVwI0B2YtZRNQBZUAnO+nBu1m4IWTZuwdbmAUXx0jcaj1QirxA+56PwkAKkrYvclFnURVo7sq2vUT5HZqfK4pLXp+hR24ypWMDELNrD35vngcT5MVBzSj7gcJ6zHiNuXG1wOPh//RR9w0VNjh7N+wqMNFded9wFnW49xCvlvD7Y9Ai/oNxcW3kdsB49RmCj2wBTtqffkREC/h8wyBnYBmTUWIpuQAlBhiAXoymMCWAFAmgSGEHZYnhhiToEHH/J7IoHbTmsG0gSCnZPfS1GaZzAnhXzjGHYW7qlyeJDi0T54GA10HHBK4FkvxjIPZUidQC3JEVBdj/15Ite63tCvGvXcficbo5QSuzPQHK5b3XLSIqdTpfuhzEMAOzrXlOoMTglyphCh+fF5YwjYOMMpaoNnDx1lTEAb60vHxbte3AIu+sAMIvKctYaCmscbT2A3JHRW43wbcG81wQcCzP0U+PHiwXzRk9RCgMblELD15PE8TKRb3Y7hamlKdZGMetJRRtaPenwzVlLfzpESckvnqx4cQswBBbHNsWhF+b8EsLsNuZJs2NvWaIWBNbJ1ip6yYsWBQb6zWBvSfBLGkeQdb5/2XNyZIG4IgKx19D1aJi9qTf+ciQjJfigFvPpglb3qRXYogaSA4bymM8Btcm0M/SzvJYXN8pjlGoPWloDWKkXdHDXVq9A9xJlMpTHn+0rqDMTdIoGeO2NbwYQiH0mJAi3PQbAAaMWBjGiQEyggmbcmXy+lFNaDz6x+Wbfo3h2rrA9Q5kd9jzuts5zDKMW+7fRvnQ0Q8OcjSWZkPcgkQNoFwrKOifNKXXtB56Nq2FVN1ZpYECAs4F20yUoVAiolCjBUNVdyoKNV3q/1Htj/DuDj9wDy98rYj4ae+B20cNUsVOcK+AVoQi8aWzRCvJAIM+o0scPCFLeOI2xhgrhwT1pGt87gA8cdvcbR6w478kNuWMfc+8iPGzSWqueN0egYfBsGOI0zaKzCjYVlFrukROjmLYun+B9LOlwW9BBTZoDlnAC7RTdZl803rVEqg9bGamwGn1NnBF7jDutbByr7DLKwX7IgSGQvz5l8zOwzUHyVJUquK3zrdLsM8T4dueL6og+4ZAu2RxuPs54Kpe6uB5z10hQh4XKIOO+pBfCjtScwPBKAONuSJvN8M6EfA77+uM+G+AtHALkfAwaWwkxs7yUptRgTzjdc7R7rVCz9ezBztCkwM9kxYAaATuyMeHOwnK5U1SKdeFOQORhjzN30QqAmNPl3X+nZuXpdGoSEEHKKVZ4358dq1wx635QZrZjI17UP1EhmJqxTDXp1Wcyr2Cwv2jJnVN5c1U56WYLE/fFuEgug2pyuQtnyfTLDRsc6TLtG/VLoQt+XQML+6+rKc2c1FSum0vxGmELJPADknZ4SrTPfd+Mgz+mYkKUKALXB3U6UiVg0hoM/mp8C7i56KiIjdlJhxYGej6RhHqaIy8GT93JMGKeAS7YkFEAohYSbiYO8xE4m1bmQUZ/2Wj4Tq3OwH7zsSwa+XeOqyyoa3rrB0P4QpwYpopXCXQG3UpAlx16Ds7Fq1iCfJwBb/hxTcTYQqQHVVJAkSTTlZ5uJm06AfcDp9QTaCCQLSywSBAFuJL8pDPL9bZ/dgDKzrwkMa0Vzl7KCOsugZK6R37/JQPika3IQ27IbSedo7Rf3GmsUjhpuc66LzEbuzVa6cGq6X8cQs489ABy1LmvFa8cUYtVpb/GpOIX4SD7DQAGRtw5b1vvT7/1U2jUL8PWVW0kdzEqb6/r+FUmhNB1pDYH8hiUKRhNBRQCTs0LGZBZYADZA31kaLsk6lsEpg10JDIhtfhJS6oqFrkG06KoB5HokYcHrWg6Rlu5nimsrzu/UeA8g/yEZCbuVmgpkByMTbzN4RCQ82FAhk9xExmiK1HlS5wI9rdGyc0Xb2qxdpN8NHIPcmBKspZ8F/MnvjTWU4jMKbWPKjWIUZq3l92AwbskL9YXlLDPQApJIDkELpjTxmDeUipNORUYr9lssjQpkCOvb2F1phLBlAoAFwDf83SRtJQAa2NWJZlCjyG6ttGgu1nE57cTsQOeKz6psQLKx1mmzWrdc6/+kynniDV8quM976mjX+4gHK59lD/I86nwWcNYTczz6iPXgcdFTm9F1P2H0Afcupuww8sZ5n3XGIRbXA8/enlIwsWVPY1m4EkdgSimcLJv8PbRW2cJIabVTEKm1yk4gULtMrARrcr4XXQHWWuv8u0haCIBG+ow5fUaKKWvhRf98jY8tBJEH0Hvupi8p/V8aydA8tqZcawnmRCco95Zo1oukpgRjdYFYwhUZoWqTedqo9cdPKzgDKqDLzI1YX9XOKSFvuGmn66SAw5iksRAxwmR3V1fCk19sjKTtDCnh+UOXP/+5g442Rw6svvDgnL974nbV5K08twSQNwPNZw3FGnua0yM3l9iOIbfFBYDRB2y5aFQ6/G3H0rktJWrw0HsCICGVgFO+t98DhPW1kU28bsYi5z4w/ffd5I+1krn5FAYZxXpr1ugMkiirFLO2XjTnsraI9n3FbhYJyO2KxVJSXEHoNTQv5paDVJ4jj/uROyomrLlr6hR3s2MRUgBIwTjVpBT/efqv3AdaK6xGyjIIw5idlPjxxpgs73GG5BnLhoo9rdGYNToXuB/OHIErS/tQY0nWsbBkJdfxexx3Dm2VMZo7nY9pYgme4f9CKv76CrT+iX3moi0AWXyBRZYk5y4ktjRNBfyKJaF4AdP6H/M1Synlx6WxCFDmNxWnFh9h2e9iojVq4aiwfWYNrVmGzrsw7XU7d60o02ry+oAd73A5R7WMkNZusMVkKWLOc1kXkJ2Ze6lhEJyi1BPrpq6AvNRRyTHo6jiEiPpO1AS8B5C/B0dtxi+j3qwAZEG/gBrqZAM87llvmQsYNGauTFxifw0vGhRZOkegecaRs3MGjTPoGoPHmwnOURFOYw1JMRqNWWtzdK21xqyh1wD0fvPWouP3NEajcdRm9rglTbOkuQSEdFajNRohklG94yp4cVQASpvK+hwApVgR2LVOC2mX8ROtV8P6a4nqRav8tKFQiqoA5BtVUloAMmsoqW4BJaVwiSxx5DNrhxIBn8JKC7uznSLWo3R94uYNgdtBj2UBXTMDPDAo7idKMW9H+m+YAnW78hEX25HTd8CbZyNC4OI7Zhtqj8qs2d1L66VEbKY02VCKTpIxOnfEU0rh5KDdSZMtOsevo8BMLo4x5TEAOJw3EBcBrVVuUZ1SKo1EGDxfP+h2PiNrELXCNQHPqRS0yPGLm0NK4plKBTWN0Vk2gVQcG6CK36gwLSLJkblYb077eHZ/fsk5eqdFXamiH3ynkecgis2VQrFOk0BKjpOkUfXcZaYvM1B7748ClgDke/KDxzPK8viI37h7WmWyEt66GPLrx4mCt95HSCW9tLQWUDUw2BVGf/QBA2sxey4oFI3teqQsx8itrkf2WN2O5OIwMkMnHr05SEilDa6c9SxF4+spgKgeUmT53RxyDFe5LwAcCLFbQ1cxfPSakrUK1RolWSGlkP2RgaJ1F0nFtgoSxOVk5gwUVPbBlu5sQOlMJ2yzy/NA3hO41jbQCtkpQd7bqNKYx2oiMOauADTJgGpFGdSWJUxCuHRWY+4MA2SFZWvQcobziD35xWaQnkvP13nPoRoSaRykFLI2WgHZRUlqC4gp1Vka+P7r86wBrm1Zt7wfS2BN16J4ddeDmo6kPD+FLaZrnPK5FRtDIS8oGGLP6Vi0yLXMwWja36zWWYoi7klGF72x7IFakZymrvNZdnbHLUfrIuvUSmXcIFnnfWa3lp4JEKbzWfbwfUZZ3lv+LvilXIvdAv3v1Piutpr+39qYfERzxd/c3g4krgsyJAVejyf0b7yY5QIJTr2cDx6Y01OUouj5qDNIW/qbtTpHhHPHTTCc4S5TxJx1rcWsMZg3BpdDhHMGy44A8hDo94POlWI2Bjhz9gs1rFXuHEX3Ush20Brc3/QZtGfW1mjMG7qBp1gMykOkRhcxlV7w0gFPzltKu3ZpdYpHgBGdiwKQO0sgNoIWL2feWQuqFVCKzgq4lQ2nH0NOwcuHJekMhIpB5GvWWIq6c9qaj7X2NZ4CtQHuPUkfNkP53pshMMNJ31+6ZU0+YsvPI3DkEZ3J3Y/otR4pAlAJj1YD/z3ycZknNuP9CF0K4eTnM3aTkMLMxlKrcWM0nj9sobXOv9OGpbNdoILaeYzek6z4pImNMQq3DrsMJo2h9xNA/uEbs93Hqo01pQI06HukjIyGik2k9CTgOIvRsZyINOWS4uU5l1J+vzoY258v+2v2/tMkG/FuwEvmLG1YV+8ECTQHpCpcrNhGH2FRCnEkSDB6t6kN8CRbKYGAjBiLt+xFH6piVWCcAt44G/J3jAl4tPY5RT96CuCs1pm5HH3A6DXWXFAnDiqtNdTmeoroLQXK573PRWhaUYtgzy1u6e+klx99ZPu64gwQJKpJYgGWYA1yClqYNq0VDJCDi3rkAqR3uVbfziEALKanZw8kE5TXI3DBFMQDuIBmWQdFNjNWIC1bZUYqyltXmn3P57C1GmoE1y8kbFj6pZTiNbp4vZP7C7+e2f1lY+F07UiBzDaXgFPBJ2I6RUvsjMaC9xCjFToYaFDGcuZo31g4yyyoxsnMYj1GtIYiQNHKH7DOd+YMOi7EXbSa+wYAreHupSy/2ySqcRh4/c22hqno07VSePPRhlhlpXb8jTds7SbXBSAQ6zhbI2s+AFxsffYjlntBQLSQZTIPxhSQ4NDz+4uv8BgitCl2aJr3IOkSqpXKRbsifXRcvEjXrAK5xuS9SDJ21OwKLIkCIn8Po4obk1YkTxm4y+WTc1oyA/TZPpR19SqCipZ5+rvsl/m9VGHBv1PSJ+A9Bvk7OupONPlv/sm/DXt/C6H4kcoQfZg0O4gCjFAaPsRErCPAiyVo4l+b2Vzp21qDw47Y3wUD5VljsWg0DlpaOGaNwUFnsWgEEBOAmbcUqTfO4MbSYe4I6JIdnMVBa0jr7Ayuzek9Zw0Bp0VrcdhaPNgO6BpikzWHubQIGswttUGVxSHEkjoamCkaQnE9qFNKMmpmVphbGVKR31q9w67VQOeqvSinY/nBupAv8XXeScdil2kESiFDTAVc1YymsLpKKWrzGSnt30+0iQjIAOi6S3V7jAkj+w7T8wt4kNajIVChmuiNhcVebSfqjMTApz6PSpUUnJwDpUsraALEGpfbiYAty2Z6LqSzVmPgJgXGmJy5kMfkMhlDNoOtMwVMMwNSP5eAtc4gWB7bTnHn2EiGQc873Uz5OyhV0s2KNzNhWSIXyxgGwqLNB9grF7sAV8DH/t9k1NdW5t0+kK5baj9tKEXMi49XF3XWQzTkMo+M2g2qY0rQ1bY1l25d1XEKAyXNOmQOy3MG7rC4ZT/sb3Ajl34KeLwhz9fE73k5EGiSwqLRB4yBmlmIXpakFTH/Ltr31VDmcEqkxQ9cZBYTsBpjBsQxJm6nnjB4bnOcKJMjbg7lGpXsiFTQK754QhTUDYfqoVXxnP92j6veUjE4SCldGRftBzBSMKUVpaWFnaXnprzmAMWOTF4j90dK9Nzep8ze1euYSAwA8qVOiVwPiosCHQvVk0hNQYLnwMQxAJYhcgX6vpx2B7BwFp2htH3rDBV2M/N40FgoRfLCRUvA97ChzqPOatxcOMwa2pc2Y2ByRuO4M1i0GktnskTioDWYWZ2LwgGWcWidnVyGGMoawvePFL1prXJ9Rg2mlSoMfWFIVfbDL9eNghWRY4g3sUhhgMIgC6AWTbpokeXenCJ1T1T8HSRIl+yq433dMbsuGmtphmI5qDGaWHqqwSiZ2ezwUUlRpFjTs02c5X2+lnDVQ6vCWEumTc6rrE01qZHnYPV6GYrfw1xBRnw7x3sA+VsYtSD+nYYPT3baGStgk//mS7QIIPe7l0YH8l6+YldjStkUXvqkyw0k88hw9LhsXJY7NFbjZG4xdxoHLS0Cs5YWoQWD1nlrccy/p0TFe9fnLjchaazGraXDjAserNY4ZIBsFAHe45nJz7fMAiydxUUf0FiTwTlA77dwJLvwvDj0vOllj1PWZU0xZkBXyx5kuKcwyHLdIsimqlQScyqKn1eb28vQCoC6gsWvrrMs9KOPO2m1elOiY0pXeuXKImg0FYL4kHL6uDXkMjKyk8DoQ2Zi6JpHSMHhKCAhRAYM1JpZOuDVRR7b3Lhjt2JawACB1LKQGVM1gWG3k34Uv1ICwet+grH086M1Wa/J76MP+XWTBDf5sciPsRVffp3B6WaCNjq/VmuVf75zPkDpAphjTFCapESX2wlQu8y3MNj715JbyiCB2NUaICdIYSHynBHWrR6Zvd4LqLR6Uh9Xz9OnjczISobpHZYc6aAVq3kk3ccSwGwfv18iEFIfkjCqAAfjqTxXxsDa1H4in+6Hq4mZZwLNhaVE1vLKOib/EnAunfqka6OPBQBvxGawcqwQoBaZfZYCUmpGwvrbKMA+cWfRlHXjcn1Kh6/SsCdyQNHytd5fU2SjlgDquzGEIQPeWX+ulWJZSOUVy6+r09IC7kUWBYhf7pPfaOIiVq123Sys0kXbHMr6Jkcn860x4pxQjv1sGLk4bM8thPX9UkxttMLcWsytzQzyYWeyHGDhWD/sDJaNxsIZHDaOv6/GM/MOy4bkeiM3/1k0BsvGYeHK+5LWmJjq0ceceSSguNuASsu156BY/M4lmyH7h+zfWqkrm7zI3lLgMa07QxC7PfEaL+dNvIeFva6DWCFc9rMMwubKHIipOHJQ63Q6/rorobDOTuv8nxQmAtjJetfWspYDAwHNdR3QvjRMGOTyeSUrUy9vsu4pReenrtGpR62F/k6N9wDytzAEgLzbkMW63mSEAa4ZYkmBi6ZrYsA7MMsif/PMCgLgCu3SYliqYIWhpAiLIvCOJQyHHemKby0J/J6wRmvZOlyfE8NrNAHk6wsCvACBhOcOHQ5agwigsQbvP+ywaOm9rVE4mVscdgR6ndU4bC1mjcbgKfV11FkcNg6bKWLWGAbjyO8/dyTr8IEYoM1AVdKizRKdqI9l05NuZPXYKX7DbjQq57x1xIyTbVXK3cDyi/aGpIV2UjzV46F6/egjpzbpMbmJa23qPhuYF8xEvsJSfEMsGlX1ewa6jVXMvpWuR3VRVp4fMeU2wjGm7GFMCy6FBWOVBqTPZx2tpOoYhIqExVqNhgvtrDVwLN/QmuzWmsagnwKco8dWvaciG36s/G5Y7kCvc47cReTztqOH+HE7R0A3H4sTr24C1mfrMYNjAcjymLDZxpC+UYCmyC/kOmqovBmQz68pvrhW5wtUu6dctQHIkPOX9l6385zMnF35FjtDpt3TYJICaU1p3tGzpEmNYgpGNnqANtfD3NgDWTYkx1sXs9WBvKxdA1svXvSs9WVwC5RAT34X3aUUG20527GrqSxgt7x/ISFKOjnl4yiafZLLxPwZdKwXWyksrc6TKudSAiY6T2nH17mWW4lrTb7234H9+Kq3VLh63siQ7JhSpOsVcNwyOAXomjbMdtoMnksDHGcKQ1dni4R9lkAvJlrXnFHcuIGY4KJjLcclQHdmzU7GYjV5AmZ6V59qVXFdaLhWZulInifyiGvMIBulMG+pmPegNVg2tKcsO0ssqdV4/nCGuTPouBhUa4VFo3HYWMytyQVrSlExWmNoL5B9w2r5twouFGn2FVRpPAUKNIYQ8rUiKRTtuzXRQo9ffc2VKh0T5SUp0R6oUKxBSQqxW6C3Ox+QrVPlfQECwYHZe5JJ6gKGKzcIuhaV1Z3SsEoK6VhisxPYlPPkQ2Q3n/I3rUqRugzRONf7Mvi61utp3SOgniv73zkXDOI7N94DyN/E2AfDIe5WRL/T62SCy5gCtROu33P0EZuxpM3F6muoUume/zZVACin0KvNpY7KpOkFQCnVk7ZB5wxuzjoctAY3uhZGKxx0Bsedy5XGhzOH63OHZUtprq4xuDVvsWwpBdY1Bh84nGPZaARmiE/mFksGTy0X3M2twXYizfVhZzCzBmOgdtE7DLIzWFibvSMlhTSGSI4KSDnt5PPGmDI4q4HrjkyAz4fnVH+J8InJV9UGYLXaOY/1EHYmVoy0UuUGTolYaQGpwjwUPVgxPs8ssS+fD54jws6LIb9kKmZOc6eqhLkzOe0mIIx0laXATjNTVreCFtY9d/SDNP7YLQiiAgyVgaS1GrPWZK9rxxXLAmzlNU1j0TSGXEIaA+eIXTaGrNicE/BMYDmzTY1F21psR0/FoY0lpxJDz2tbYpQFWDtn8s9NYzBwYxH6TNJQO0fOLD5EBtamKiil70HXr8hdLKdVdy4/b9DC4MjGIvNh76l5yAaRGZH93bGan+80slfzOzCI+Y0yYKINo+64ufNURSnRmSnOIAAy4wrwPODnx2rTKql0up+EJa7dEWhwgwpV6gRERyna75wZi+U8RQb5dXMMrRUDYjn+3UyOMN8h3xP0HS+2ExEG8u6q3ONybosGtrD+xGaW85USdjTo3xmJxZPvKSDlaYNABjek8AlG6+wa1Flet61mxpTAY+O4WMsyQObvlfi8y70fwXUZsjzxGlMHdcLSOyP+uvRcqwmUz3mdkPO19YEK69yuA4E1pHm1huR/DRflzRqWWDQGx22TgZw4zCxbg6Wjx47mDhoE+J45ajG3pDMGmHVuDJbOYW4tWitdYanJR6M1phizy4K4QlkOIAg0lnVc7v2so43F5QKQYLs44GiFDADleOgkynUu3vryO53zXalP0ZkX3bwqb1PqXPbmlGXfeKdJxibyQLHZq2VDcn4loJLjH33MjYhklO+jcy3Njg2bVjv3cYyFiZdJJVm5ep4ohUp2s5up28/6iV/7dxIhv1ek9y5D0oNVx8mcynu3IawJIFGWzk4MNZALkfx+ZSJ4TrGPIUFr2Ujo3zGUTWwKETGpHeZEInQFulk7BlQza/DMvEPrDG7OWjzY9nhm2ZFLQGdx4ChNZY3GUUuA1Wma4I2lNNaiIYeM1mosWou5MxhCgNWK2GfedMRGzihKv8jjjl0qFg0xz3JDt7a09BQGSuQVco/FJHILekLijZI0UBFGVxeoGqL9EvBKXaV2N/TEx/w0RlDYxP1iALnhE4AZO4KQH6feeVwWD1oME1fLRzhexAtAYF01VK5QJ4/K4rhx2JksFcmLY+ICO34PYUhr/90aYPBPeREWUBHYHi3rzJi1XbYuM7HC4Aqw1Yqe17YEWENMDGwtHwuB1bY1dA9Yw97FzOLw60b2025bk19HYNpi4seahp5rjMrvKyDYcaHpMHgG0sVyUDy8AWTATGwHnQzHHqlWqR3mx6gCbjWzZUPOCOzNs+pna3QuYnu38W4uFnLd5TpfNerNRTacxrIGs3pMNtUpUtGeLEECpuR7CPihz0TeUH2M+X00SvFmmWt8nCgb4v6mJsxv/fu+tVNNHhilMO4A4j32X6nd1yvSVdZFrfJca3abIcirBMzI51/lUZ4BzVOCnW/3EJBylZQHKNeoNQrrkYp2Hbs6LLhBxsxpHLUEHhtr0FqyBe2MzsWoSkmxaGHyCGyWeQ8Qy3nAVm9ZSqTJW7dlvTBpQjWUJg247EVWIftZd0ZnECkgdGYNpMmHuFTI663ROGwcjC8uEqIfXjqHg5ZAL8kuNB6vJ8ytRVMVnS0a7pBqiuuMEoDI97wE0MIkOw44SrGgSBBKy2MplBZJRq41iAW8CpiWDnVZ950fp+tplcaAgguEZaU9ZVeSJZhQ1m35vQTUZZ6QCw5yVmFH862KbEjmm9Pic6zgQOe1tpHcH62hIkfLmWT5jBDxhONUzVbnTI4qhEw+LlmrlejqKWv0BEDOIP47d0++xyC/ywhXgOHaLuidRpY9oBLds0wiSyfYsWDwsXoOgV95TF4nhSy50jXQf6KlA6gVp+a7RxYHnxKWzuLassGioUVy7iyuLxtYTXrhztJiapTCtbmF0zqD5tZRumVui8RiOwaq9p2o0vyoIS/JkOhxqxQzxik/rjVtZgetQWPINggKWctc3wQJu9Y1spBlb9eEzKqKvnF/CGDwIeWiJSU3G7fXFAcEqZK9ajOS/u/yCfI8zYuKsEy1XksWcgGbOdpFOaYn7KQSsOo9VeBX30eKjSISnlk2lbZVcfocOOpKgNG5Eizs+PTKz6oU5RT3BzomAcBaUbFl11g8d0jWfF1nMWtsBsRtS3PJWo353GHGDT3mc4cZexc7ZzCb0etiBs/SMISeO2/pMXouB2pWYzaz6Bpq6NI09D7zlj6/6wh0h5Sqz+AMRmvzsQjonrGkwFqNtjHobNEUNhVoqMFWXZwpoLNkBHZTe/uL9H4q+arx7o+rXHwLPF1iUbN/sknbCiAkcCq0ChTX3IlQjlUyOnI/dLYEsAQuywYG/r0wtvQ8x4BBvlbDgV0O2Kvvq5R00ywgUCtkFl/moDUq37c5pSrAQNdNkuQ5BCa27HhRfx5QNubSFrvIKAAKiq4CyPKXdyuW/FbGVfNAqyI9uOrxCHq8c0Q6tNawW4PmBhmcNVw02YN81tA63/Bcby1lBMHfX7yFlUIGhoLLQiL5lwaxr9kSUeusCxZfcKc15i37FfO6J+2p546KuKi1Mx3LYeNgtcK80bkVtdxrBy0fpype5EYrHHYGS2ex7CxG1mA3hqRaUuRneH7M2XpMmG7RQpOlI+1JM2a8WwbCjdHo2P7NaiJxSJerK+ZclcBClboNYegF7NHr+DvrAtCBInMRu8zcaCjtMq61dLDUiNTgWFpk70q/RAtutarkf5y906Z0nOX5lO1gjRybwhVba/4OYo9XF7prPqh9SaJ8P63KWiYA11bfR9h8OZ9y7Ps4TPbW72TM+h5Afpdxld44pW+u7agwuymRM4X8TUAtgCyR8NXffAbApDvNx8H/iaPFyLrkGtgJKyATcsEA47BxuNxOWLTk9dkZjdP1CGsUjhnMzBg8X5uRbc61jsBKYw0Vt/HN0DqdGyv0nuybjtsmV107XkwaZtKsJvAtbNii1bkbkQIwZ3u53CIXDCJj4rQr3XwktyiblXQWEl3y/qi1w8I8UVFL5MKFcp7kul61GSklqWKxtirVwnVrYcP0XVPd4KL9q50MhNWuRwJtQqvB5/MGIFftyyJwvWsK4K2O9fq8JIMEHCpFYF2kIKUrFTJIFimFMAWWu0wpBTQNbRIv35zBGIWus+SdrRVmM0fdEpllnncuA9T5zGU/TOc0FjN6LAEZrMp5WMwcFq0tj3XEfhFALo85Z9B1pDeUx2ZNeW7XEXhWio6zdIkk2UbbiDTEoHUGS/5dKQIZc2vJwmiHjdydS+KJXFKu5QlXz5t3Xrnf7XGtpACTfn+a0kLmuQDKuvBGPsFpzcVXtOFtfcjA1DEQqUHooi1z1praPaQ0cADqIk6VWWgw8O2cyscnry31EQwMKtZJK7GiSnmuNpxZ0tU5z8xkdT3k+4ruVr7f/hDwsK8hlwBAgGI+twLA3/FK/cHGVce5k8nZezzxpkLsKzOelupMlq3BtSV1kFtYiw/dWsBoxXUfBp0jSYPhtuoyB5VCljhQdzoO9hlgCYspgMVoYmRbQ3IIq6Shzq7eWUBXSgR85sIWW3aLUAozTv0vG0MFybwfOg7cahAk13/pLDe6Uhg4GGosrWHSAMQaAvNzK/d6kfEYLVkjncE/QO9hNRUKLtvSDbZloGs1kSmNJr/l0iyoSCqk65vovKXgrTGGGfJKrqFIxmENlQmL5zNQ7sUEkfkwIM/3QnFUMiwFke8oow6ah6k4a+QAxxa5mVU668RLkF1kVvvrj4DqEsyVewh7GEkCeNkLZR7L+RPgLEGNvI8EGYJ56iFr3XeyUO89gPwuQ9haX10gKjD55l4roHCqgW4o0dDgpdCuvL98loDpndcJA80ShDFG8jgF3fgLTvXLOOCihsOZw4PNgEVj2I9R42w7wWpiHKYYseCo/1rbIKSIm4ctMZK2LJYpJTTCHkGh96R/PZ478luNHG1zJO4jM8idy+1fxVgcAKAowpcbWABxY3UuXrD8ewaVHAWLNEW03vtDAKBnBirxOZLzLG26ZYOVFqhXjX3NsmwU9aDNrPpsXixFzydPF03wzkiATxEX40TnGaU//aov6eLzYao2C+Ro4YPHswz2T+YF/LW8OQjgcFYDSu2AFpEgpEQMsgCRprE46ByeX8zQNIa8rlsL5zSWM/q5cQZNo3G8aLDsqHPVIQNbaxSaxuDassWyc1AQdleOCTheNFh0Nj92OHP8Oo3jeYNFfp3B4dzhaN6gaQyWMwLL8tjBzGHZUZZi3tn8+c5RU5t5Q5uwcyQPmjUlcFgIQH4ag4wCgIXZkop7Gd9K6v3dXiLBHWVMnr7gaN5gZAPaKaDheTazJgNkgHxwNTM6jaWMkswHaxRuLFyeM9ao3NhHmN3GlN8FDCwaygrJxi8tqesMipP31KWoTFfHLd7s0jlr1hRpTGNLi3tjiFkUIEYpYgrKO2Ow9SGzdfWQe99xaliGXGvHn7M/3uH0/4HHVUuOAEvRc+4fSwJrjB0Fm+L1e9Q63Dho4LTCYePw+sMNFaq1lp2FyE4zJWBubQYARlNwMm/o+4vkjTqcqhxsy5rWMsBttMaCM0nUAY/ey4eYNdENs6RUl2JhNUlBZpY7tjYGrSFWmKw+ya6SGGSTr29CAUVUyGdyd1VdBWgCGkUaNOfOeUDpMqlVaToiUraUkFnxZUvvL9mFjsEtAXppUlJcHwDkPU9YetnHZA+YCUAGcqAoTLTsEbOqo2gGyDtrEqr7kVleFJ2z0SX7qEB7tpyzfopVIT9psKUYUuacNNGq74OUnpQXyrHkBiN7c1SyvfUQ3Xb9XGcpSGnsbrBbXkOEnJCG9WfLGvwtLL3f9HgPIL/L8AyGJ5Y9AE8BOFeMYjFUJBYCfOX1Ahqz20AFjoU1Xg+eAbEY6jOojsXlAaBJc9BYCG+kFbBoyEf25kGD83HK1msAcDlNsEbhetfm47Na43rXICRye4iJKljrimZJC/lEkb4xGh+6ucid4hpmkKdA584ZjYOZxcU4IURiorUqTOyM9V+ryedjOOjsjl5wwdrUzOLyuRzegUGWBSMwEy2LnVQbS+qr2HLtssUyUir2bTKkIpfOu2yuu73oFcDFJ8IalHNYeyCLLjPEhI33vGALA0jtV7WmlPTd9cCaNrWTpvrA4TxH6beWLjPDbWOylrg4UhRpBTlDmMyaCUOsFBVjHs4dvvz4Es7Rz4uWGNxDllS0lrTA1w9azFmTfHLQFs/NxuCGPKYp1btgplcphesHHQ46Zn4bg+NlS0xWY3G8bHMXp7a1OJo3ePaAAPLxssG8tbCGPuNo3pAdlFE4nDdUWKjpsWVnuX0svc+is6y1kw2ttEoNKeXuWXK/IpVrLBZwAtRkXKlbfZfxbto5Koyjn9+tKNgZqfrXHMCWuQ4A89ZiiqRP14otEhmkzh0VK0mFfmMNnp13md1pLKXmLTNozurSdl7TedBa4dq8SGe0VjiZ2fwZjjdSSeHKazpbzqdlkATQ2tNwca+qjkua0Vit0DgCZk31nnO2ixxjZIkHduhf2ez3gUc+j1eAY+CbKJT8A4yr5oEECMLQ1SPwejFn60yl6OejzuBa2+DuWY/GKhx2DqerEVYrHM8MTuYWM6dx0FCGcO5MRucix5s57i7HzZTo+oi0guVohuZYa0xVYFcAqnTHc4aaUTWGslKdKS5Hc0fSDJE9NJakfQtH85Qs2oCDtgSiskYaBRy3DRpLFm3iP9za8l2EQDG6WMMBbL3K90YGgEhYD2SP2TLovXXY4qL32IyBjqPhgJ8DuY7npwRkIZasSMPvIZfNKgbdjd1hiOk60/0hpIGQBTIv9mGG4mJEydY11X1lec7Uc7XOeBHWIJxhGLx33CExJTDjrriYj9YSqS8YPWVv9/s4yH1rFHaiyKsK3sWVxCiSMqVU9uiOSbJ9gKz4NTUmyu+n32OQ/6sPmVD1xYnp3RfMWoYhetl+LC05s2URW7zJew4VYJb/tmNgB4fSq13kFlLYJbY/R01DAIiPo7OGmTFgM/msLfQxYespSj+cO/p9DAxGLVJKuHO65aiaIHdpqcksVKDjMkrh0WrM/eNbrv7tg+eiNHr+5ehJO2eKXytAIF50kQDpsVpnMjhwvCjJrVmnaESiclUOVDb8+nzT4skLjd5lAeX7DewqIsNH8iQWYEnHsPsz2SDpJ4pbhPWStDFQOk7Jz/JdphjR+4D15HOxn9HC0tN1e7T2+WdhNrVS+Mb5OqfFrs9cBiaNEVs0WjwFqGhdCtgaRwU8AFg2QYvOvLW4tXS4e0Htxg9nDZYtWagdzhq03KK8dQbPHTZYNnS8tw4aNNwNq3MGLxyVx6RluWYQ9b4jBraaPu/m0uX3fOag2Wlec/2gxbOHDl1rcW3RYsGgu2kMTpYNgThD7a47AU/MfGcgxk1wQkr53M0sMY6RbZTEnaHY4pWAJhezmN1F+VvRpr4b65yzESj6+acNCVpnvHGPniqFZJ26ddhmuZNS3KSBAdiiqRw+GLx86GSRQSeBgQJCHbNnhgtzpPjrxpzWHg3F0i0HsZNquTBSwGzHDRtm3CWtawwVA/NcEPmOXP98HMw6y++WNaGWAc+80bmgUDTRcv2kK1lusnPVmvGUa/LdZpDlWggredWxLBqTgeyyoXN3fd5g1fts60UkiMZxZ3HcSXMnyiLObQFjRlG2ccE6ZWFXO1e1kwdyECb7ysxSga3TKjefyWsfZwQ6Zvpmljq0tYYkPDOuVaE9g7TIkjkUD+OZNSwLYpvAkYrCFzwvpCESER4S9NKaPUwEbqWILyVg4GyjMJDirrIePHyi92iMxsmSzuP5MBGT7Sg7ZpVmVwfNchTNhWrFlaExmts1g4El26w1NkspcvdADkJnnH3J159ZWfECF2Aqsg0JAkqL6CJV2AGRqmS7JEsttnHOlC57AMuLtM7Zthm7DcVUvPZFpkHzVmXmd1+rvA9mqWiXvmedtaXvCswb0azvFsurvfcrBYPfQdq4Gu8B5HcZAlzri1NXlr/TYKkYAAakU8ipHNmIfUj55o+JPECp+xA3wwiRGOMkdm7IFmgyeUNKGAJF3IeckgZv/lIY8Gg1YjPFbOI+xogpks7riOURW66GFt3Tw01xrQBKkxOp/t1y4wCjFR5eDqztTWg41bZiyQRZEUWsBPgpldl1pUgW4kPCxpOWrDMmb2aaUyybwZfiOF7sYiqFkPuXI3ubGpWZeaBUskua2BmVPabFsaSfwg6LKCxFDWhI01xu1om9IFtX0soAffeOW3DXe2+eF6EqOowJfYi4nKgBg+PofGInEKMVLoeAxpUFXzRpty/6zNSJ9V5ji67UMXAST2NZOJuGJA+k0aWW4YZfs+wcPnpjhvMhkD3ggcPxjIDLjaWjttKggOqD17pcAPr+4yanweetxUsn8wxeF63NumijFD50jSwHRRrx/uMWjl/3wWstlm0Bzy8cEQCbtxbvO2qwaDRvLuUxoxWucVMbawhoH80daQsNvc+yNeinlDfTmTVYTVPOyAy+BK1UILnrZS7nth7fyoL9bqBaHleqNGF42hCpwYL111PVIREAb3bcZlaXlGrXGBzPDANmAmUHLRV8CQidt5QaprQracg73hgbS3PHGY0PHS4ofcwb3Y2uzeCXwKzIr4rlVGdFSkGa0pOZI6DPc/K4s8z2GZL3WJJdyO+y2cqGvmxsJg4oMC1yLEkxC9gQ2do3s5bXm/07yV2+lfG0TEJri0a0HrKHLBsCqUYpLDuDo7bBraMOmymgMdxNjrvE3Vg4nLQNZo4yKj6mvK4n0Dp1PDOYW5NdhbRS9DvLBWQOkhsF/b2z1ImuYX0xUNL9naOMQGsICM+tZb0vsbpdY3JL8M5pHLcuS+n6iUB3awyDJjrOzUBtsFsuqhPCSMAa3Su0VwnIztIDJGqLHWkPMlplZ6RV7+FDygzvV+9cYjN4XEwTyVXmLgfH68FnuZAQID7FnBVuRfYDkjVMkfbda8sma4/ludKs44C9nuX6ypwYmPXd8n4k2Rl6HhdTAtmOTua8DKXKPZ+z1wlZ4iTBhZZ9QqssXVu2NgPqXDMVyl6qVSGvZI0Cdm1FZUjR7KI1ObMqD1ujseDak8Zq9OyDLsdP77lLOn4LfMS3NN4DyO8yZCILk0w/v3vRRoJMmJI+H6o20BIVlpauFSNaAXACzaGAYV7UJ/YHlmMbQoBRdKMB2NECOq2x7j1GbiFKrGQgLTIDyJTIcN7p4l94PhJAFg3yGMX2jd77cqCb1xqF9RAyqJcK6PXk8008+ojVGPLNKX7HSiksncMQYma059bi4eWYWb5ZY7AawhMbmXTkukru4kOpzJYiSKB0FjKagH5jSQqyGaVdbcQwxawNB5BdR4pfJPLi7ENpDFKDJK2LF6a4Soj8ot5gPU+mBHLtmELFpBtNRu+J2ntrZpNFBpE4gHBW42wbsm7sYvAZzMhxU9FaSYdrTSnqtuGiNQaiB+wioRVtCj/w7DVyLGkIlB7PSHd8c2EzQ7foHD56vCSPU6U4PQ/euB0+fvMwp+9mLQElxefoo9cOKpbY4n0HHQVNrcWLh3PMHaV4Z43F+w5bnG0DDjqHFw4LY9w5gw8dz2juWY2bS5cryWetxcnMZqaE7AkJOAhAdlpj4wNLgkqGRmRPKe1q8GRz+U4P0dcVq7Z33hVqoCV1DjLXvvFgnQulrCrFtB17yfpIxbatJcB8+/E260OPWpMDDNKpknaxYamF/P7pF48zi9axpMXy/F+2hoET3QeHnWXAzN0+O9KJL9mLfdE5el9bGOaDjhnjCthbXTbqA24lPHInQAFFtBbzOhpTtsrcD3zqcZU9nYynveZbHU/b7BtLcpH9z5NDOeRgwGiFo9bgqHEUCATSXw+ealRao3C9a3DcNeiMxvHCIaSUNbYAgbrj1mWLNMfnee4sFfUpVVjdRmdmt7Hk0d5ZhYPG5axMY0hyccBdXJ3RWDAjSWwxNQMR1rSzpCu2WiGkiI33LOGhOSddEVcT/X3gTqvyfcmVgoFjJMJI9rM6k9uHkJ0wKJtA84P6EKTMQj9YDximiNVIn/e+k1leA7Zj4Gyr5oJGk4vngV3f42GiFuuNVXjuuMs2nnJNDXsRS9OOnvchkiCUGiTJahlV3FckcywuGllSKEAVdC2EQRcjgIQCqLcjBRzGSPtpnQGx47kXUjEcqOt9BEs0VrPDCP09picxUs86cWGahWAQuZMM6XKbqs/wIWY8VTPI34yT2B90vAeQ32UImM0XPV2td323EfkGKsB3180C/DnynAx+GdzJ32LVNAMoXXumkHLKRIboc5zWWHuPMaS86Q6cbjG6uEeMMWStEgBsfGCAStHewGCwZZZ5y4DfaIVt8MyGko5LAVgPzDhz2mfDDI7VeseR4rBxGGPIWrLOaawHYpsNp2UGbm8rt5Is7HUHrnpMgRZz2mBK5CxpNfFfbDkdPXLbbuliKNINaUhSu05IgYVUW4u1zm5qi/7NLa2rY6yPtr75RdO94fPqLJn6U2EkLWgxJswaKnRJfCzOaGy4IcusseXn1hDwMSo7lJTChqJlEwCjtcLJ3OSswLW5xRunG8REvqbPLlr8/9s79xgri/v/v+e5nusuCwvLRQW1JdpoDaBUQWhsIorxklSxjb2AsZraNmqstsZ/vPSvqrGtRmxtUzBYwWjbmKLV4g1obSIqfMUqWrHoT5Ev3rns5ZzzPPP74zOfmTnLArtbd/fL+nkZ4u6z5zxnzsw8M5/5XNsKlM+6tRjZ1HmVQoSp7SXrn9eaxvb7tRQjjK8mVqjkrASs7Z3UVrBpnApe2dhqMcaESoFM5kbIGpsm2N2ToVqMMbFc8PKfhpjWWkZDU9XGtlJo0y4VYjI9c85P9pOuNTQCr5RqdyNDpunA18hcLABbe/zxH4w7xWDgiG86kB08bZxv4eC5ya3e1UWHrkLk8pWS0BKgvZgaqwOtH2MKET6t1UxmBBJEw4BNshQMloasQaP+TcIA//PWJ3ZcC1GAvUaYKSahCRaG9X1sKYTWBYpL0xdNwFColC1Vz5aGQhxiTNFpjPl36/9v2k0+rK4SH2ueeL2l8XUaZF47/M2WD0ZNJmLvoe1PBqPPAl7P/cOZHx/RmiRomHSV5SRENYnwyd4aBUYb4Yc1tmMLFBfAbk+Z1igkLg97FCqMLSQoxaSVpswKyhbdCBSnCSO3h3Ic2XHJNRWiqCaxybMA619eMX7GlPotQpbT+t6SxNZnl8bTBAqD9rNuk19fQdn2agCdjQYCBesznGtSLATGxYLGSiPTud3PXJVZyvxE+x7se3OtsbvWQN2slQDwaa2OrkZGha6MTz8HxvfUc3TVOHNGYFwGnRImCji/NGnCe7IcaUhKKn4NxdKQ764CCcBKmTLu2gXo8ndk5RorZngu9DRY8ORMF87PXmvK+8/rpKs2qa0w3dOgEvW2UEpgtN5evBVbtwFXOh5w6w0pSpr3ZP93wFSYNUqdXLs86+wyw+PGlfkYpZr9nv2CaMPxHIqAfDB4kLUrbzyg9xn4AVLK86vxMlf4vjZc/YnNFvyQwHtNQ7u671xEgwVRvh8PbmQ0xo1c2xRL3Q12l3ATspHTxOXXddVzG+SgACPAKhuotMeYfeJAoZaRywYA6+e816QnS8LmMshxQHkx2Q+raLQ+fIJn0w9MW/0y3H5mAe5X7isffn3JmIlYmxYbEx6X0eQUMrWGK/fdyFzaPSrn3exiw3KIKzji3CwAV2ZXAdY05o+fAuch9tx24DRatQZrdZRNrceZP7Jco5q6ADH2VaQ8oxQA18hIUKyksdWkV9gfNHKRv4WEzNSFJERrgcydE6sJ5RaOAowvx3hr917kmvpxUrmIiaUi0pg2PoCmeUshxJgymQ+jkKLbAdro2ssx/vfTHtJ0hVTYgPsiCqloSwAWqpR1HRpbjlBOKeqeBHzj1lPLMaESY2wxJXegUCGJA7RXU6v1oDywygpnY4qhdc1pKVK7ezJXqjfTGt0NbQNe+XnLzO+8uQKwWjT67kO7QHNkO4/X/jKsMGGgrGsQz1crINfqAOiwy5tTIaYS8G2lxPozlk3lsu4sRxrRwWlsKba+mdyfpEF2gmohVvjfzm4r0BbjgLSAxo+4rRRaYT+JKWCMv1cS01wrJyQIhQEF+HGKyiBg//TIaoxLaWRTG+aafOfHlUjbydlveuqkP2aXOLbW1TNtNWE8hBz4TD9n+0Th+2P9WW/M+3Ox4Owefg59dq8AgLZSYoW9ckSZW7pqmdXScg7tQkSZJigFXojd3aR8KJnUiwDNhXHFFEXjDgHA5jguGD/nWiO3Kc/YBaNoigMVopD8gs0z1VPPUUoCtKWJ1Ua3VxNoGG1zGntaVCegscKjq5FZYbVgUv/BCLihUthtAr4zI7SyokB7z209I4GrOzOZjsDFpujZYkssAOxtNJDlsN99d62O7iwjZUOgsP3jbnJ3NJbOzjqVmOb8+Q3ta5BpjuYa6MoatlLfR3trzv/d9DvvZ9313Grp6zn9bJ9hzYIwWYZ5PpCbZt5UUIO/eyPXyAEbbM2aW+5z9pHm2JqKCYpnywPvn742mIXzXGu7DnLhK+3dO/MfLDRbWrvrTvFAMgaNM1d+5XWX301pWflQ4W4beJr0oUQE5IPAE4PxB/dg2ByTaC44wvlAM3PSU8ZkzxMw4IyHZhJw1gUFyl7AGzYHmgEmkXsYNC3eYeBO8z1Zc1lhFsKSyJVQpgdE2QWn1sgRKYUWU2Shp0Gmn5LxZ+2q5cbM0hy4yFkpOo3fEZsJeaKToJfbkzLg3AvYV4qze0RKYU9P1uT3xAPDZh2t9xUefI0fP6C5htUoc3S4C0Jw2iXf59z6eudO88Qph1jLaANDuKhLbtIAKtKy9zYFsQbaXwx8Yblu5gRpkGgelFOX53JsKUJqNo/Q9C8LOJwFIIkDtJUiGxxRNb6drImG0cyUC7HTsoYBOsqpsUaQ0PLhXtLYVNIQLcUYh48tkf+nSehPmyONN21IrK2guT25hQJAuxu59fnmZygxG+PeutP2dzbILaejEqOeabQkka2yVc9z9GQabaXIVn1KTAAYbfqkFW01hQeCgFxLipFL1zTG+F82stxq+Xm+abC/sbYaI02DYxd/1oTwz0OJKzJjDjUH0Fyzuw1bg3ztKAB0ZaShKpksBbmm57St5MzshYgOIi1JTFaDmITb1iS2c7GchGgrRiaLAfkDjzWFhvbWaa5w0YdabqpoFkIKHFXO5WhsMUYYuCj1CeUEJWNKDwKFcaXIWq7CQKGSmIOPMetW0wBtXm71UhJgQqlAgoXWZr3yXdrcgYEPwr5mloOjAdjDMh2Qs6b3wfv/Z8X+zj1sKmehylkSiY7WlA6zAQWAlVIKNgVIuOWYEU5NCNCa0lXLoAFUC5G14qWhwrhqYjMQATA+xi5ot54Zi54p3R4oWJe+JAhs9TuAFAMl4++sTHtaijG0JoG3WohsCfHYCNy+Mqhm8uxbSyqcG1qglF0nGsbqwy5zTktKFtcwoJzf3HesQY7NGlU3lszOesOuewApd8iPmZRGu7sbqOUkHPM/ZSyQXbWsaf1mtxEW9Os5HVi6ahl6bICothYVbcaYgkuNe0MQWOGYxj5vkhHoHrBafc4KlGnnDsrBeACMG6A7LEYm+LOe5eB8GxTEq2w6Wfd6J5ly7FC38W3nfda+Ds0HSG4HK2rYMsvW4p56TkHFZlx66pmXuSe3xcVYqcSwRnyoEQG5vyg36b1fDwitFe6FJAy76je+uwZPch5zNj2xZlEp5/vKJo9AkbaO52MaGVOH+dQw4EThLtiIK/ywu4WfR5ESlSuTmQJomAepvZDSadM8QKWIqjL1ZGZh8iL6c02ZMwASwiOjGfSd9iNFGk9O2cbuDQDdi/MhA7TZdpnsH+yxxmnR/KpB++Rh7G0yNcJcHCprluRKZRzhDvjuNO49/DsL+Pw9WSDmsbImMfN/1rr0LgrCGme+D1sn+G98kOHxCcyhhLWiYwrOf48DG1iz31aKTIqeEOPKEbmlKHKXUErZ6GulyLe7tUABV2VT4ao1ie0C2prExgqgUDHm2EZGEdw8xtxnmRGC2UwPM04dJl1YVy23Ffu0HesAraUYu7opjZ21LOQa40ox9nQ3MLaQmtycqskXmLKGuEwKPGdi4/eolKs0loQh6jkJXhUu1W0EMQ02tZqFHi7PbN50rVlYAbDPuA4FPAei0Ak5fcHuUn6+9Vw7V6167kzxPD7lJMTYQoLuurEMRa5YA0CCTDkx6biMT2kxoTRhhYj8kqkCZ0KBuFlugkZJ+M5ybfyNSSvN36cQKYxNE9KQKmpTezFFiXMeBwqVJKZqh6Dnq5JSCjN+1qppiLY0RSOnv5eSAFNaip6GibR3/DuPJ6+57Npk+88G6ebW9S3PSUNX9wRt4LMf9/35lvP8s1VXvTYrBbSVXZ+yBrlmBKlQBWY86ODDQmMcBFZZEJuDNb0m8CpFmnRlgctNSwoAmkPsf0xBvZRTOTWV63h/6a5n5Gts3GCiQOHD3T3GBY8q7fFcjSPKdAHAUxLkLltSw1WTzIwyp9sIcFxMigvEAM0ubKGiedmw93Xp3/LcWRZ7rOBM9+hu5KQVzsl/uLNOmuBalqE7y1DLSYMcBQqdRqhjRQ0LpQ3tFCyUCk5bjbXd53mstUnrmGtrRfF9pxuZdoJ37gRXHhMFT6YwB30NNBXksvNKOxcLnsrs+8wZr9iK6k1Sp7U1gjlrjrn9TEYbmFUk+Z/JmTTYp7pu8mVnRqnU03CCOVtnze1MX2g75/neQ2nJEwH5INACrazZxAkyB5aQWYDjUx8LWdZkGihrMuDfedDZnMomDP489pu1SdMDZZO3s6aW91BOIs6pzFgbwZrWekaRvOwOESqXT5EEaVM4IlQY35KSqS/jgBAq0lBrZDYXpL8wkDaAzNgUxBDYz48CWLN2biZ+V9awfZOGCnsb7vc4CGxqGTokuEOELzD0Fh56a5Bzs/AkEZVmZe26r3HjcWP8oACg2U/RaRi1NYX6DzaZlMyJOWtO0eWXyN0nV2TgTvxhAFPqNDAuFjDpgshfUym6l/UHDQNMqFAGh0IcYmIlQWCyXIwvk6Yn9QRYMn1HSCLa9Mg3nNpD6YtCdBrtbsFUT/x/n3SSz3LsKvd1N3Js/7gLe2t5U5YE1q4nUYCuem611zZQJFB4+4NOfNLVIIE2pPRcFKSi8FFXDYePLZEQrFxVxF3dGfbUGihEypSAVVboZR9rDh4pmL+T9YOCmdh8zotvoIAshw2e4XnWe2xYE+LPK74+VLAgwj8fCH5GqU10jX1CKZiLUioWzGGjmoaYUCzYSHYWiAFYN4lqQj6onN6rFAdoTRIqMhDRvByTxkZ7RX7dUUCuGho0X1vTCGMLiTk8G+G2QMId+0G3JLFXUpiKKnBwVxgotBZCjDGVPeNAYWwpQjVlCwnQUogwfVIVObRdi1iDyocefzwbnpABwGre2P+c12vOGER9Sq/tvS4MFfwR1sUid5U8AeD9XT0uY4QpJV3Pc8q7GyqrbS3FgbWQJYGzMvoWsUIUYE93w+4BCrSO876kzLMXB4EtNOJPx0LEVVOdUFsIKTUjQOv4J5118n02GVH8FGiFkN1ljGLBuNsBZJZnxQ9g0mp6boG0T1DGC4CfaVdBrp57RbhyJ/RqkBCrQWsYt00poKehzVpkSljXKYivu6FRy0mhE5h9mNNyAs4dir9LPc9tzulcm3ln/mPZQnnfi+ddbEqu87PPfevnv6cx1LaSHysfWMnDskW9l6Ur186qwBbsT7vqTePHgrrrT1htLkDyQxK63/3MXry2staar/Han2vSHPOcSuPAuliw5ZiVhWw1ZYUW98dg8s4PBhGQD4bRwHIFKXOpX5WzIqtZpf/zg+tX4eKTVe+SqRzAwnCZS1vLXNNkZt+tULl8k1rDaoVdDkgjyJmf6yaRPvu2psb8nRifN56QbIqKjb9oHCi0FRI0MsoNnIYcYKFsFDEvwo0sN9WeQpuRQpkNMMthHwQ+ZbP2kc2EAC1OPUYrwgcHwAWW7I/eATZsOo/CAJnObRYCThHEbeEH2/fZ4t8bve5pTWrKlZlWygVsUIAILZAcjcs+mnzgYvjOlG/WLPCgilVR6HLVssBcSQLTHzAaY7rZhGKKchxY7SAvnO2etok3npYC+YJGigSSOAqwxxSPYSG6blIfKUXf94OuHhKyYqdB7qzn+LSzTv56RhsQmEPQh901a5Jjs6zzC9X4aE8Nu7ozl7Na09zeXWvg01oNWmtTMY3mqIbGp90N7KrVkRghiuc8PXOBcQ0i3/ckovnG41GMKak/a3v4INvIeVNyVh5e1HmYfE0WP888F4ZKSD7YQdxvC6fM4sNC73fGgUI5DpEYQWJMIURHS2orcZbiAC1paF4bGIE4sptUyQjI1SQylcwo73A1cUGZAWDN8Jxmkg/UAFmXqmlo/CKBYhjaNH9pGCAJTHaEMDC/k6WkJQ3tPUpxgNaUXAr4MDWmEGLL9t22oEWo2FWsuY+4T/2Djuq1kfvBUfXMaZB9q89nPd593a+3yTrL3UFbAZTv2JQxZvcGXrvJSkeZSYpRaL9PFLpnhV0taOwjI7QAacAp3iKzHiorvMWmWiE/G0wakgDI1xq5dppmkNWQ0nfBujzVM5dyrGLmGR+qG7m2+0mtkdsFkpf8hhH+M50jVIH9nhzMyoGBgSIhmItjcJxBHDQHVtca1JY0DK3gxntGGgbozjKb4YZzAivTts6GU+CkkZMTSGNM6xznnObYIQ1P8cZ9ZPakXMNYhnWTnBCpfVP+Zbm2GSn8QF6ystL7u6yCidqW59oGF9L4K+O77gR8P5OWBqyMwpOPLIluD/DPi+zW1zyXnZWVExYo0/5CHFpLeT1rLtLF2T38gwdAOfyVd++hYlQLyEuXLsWRRx6JQqGAWbNmYf369QO+B5/y+KTun/YORhxyWUnPLcBoffnUB7hSrFyQgzXPvgDIkcWsHQNo0UmNgMtJ21mwYaGtGDq/MKXoPQBpzAphiLLJJ5mGVBEojZT1Z6YodYVP9taM5pUeuLZygr0mLzElleeqSi4SlnPKllOKeObIVRYM2b8qAJ+qYSs01XN3uk6C0GpC+AHXAKCdv1hfMoT108pdFC4bKDPtomjZRMU+nE0PozmO20Ujdw8v53r0T7WBYt8opwlh02YUKluNj8fQmlY9DWESBlbTSgtuYLQjbPYmIaiSuqAnNlNnucbYQoqCySzA96QCMk6IYa1iSyFEW8FU4jLBcN3mUMPagUaWW3/nLNfYVWugtRDZSk6Bok1iby1z/mTm0KE1sKungZ56hrpJuRR4YltDa3zSU0ePSe9HvuzUX3t6qGDKjk+6KdWXcq47XXVKA1WMQhO811zEhlNEpZ4/Zd2MVcFkMWGfZO1pa/iwGSjOl9188OFoeMafC0OlUexvCWs+MPrCG2+88A5SaRjaA1IliTGukth4h6IRiHk9SE0WA25CkVO7RaRFLETsA87PobKuQYXQWbZakthmjymENDfpkE/zrpySBimxQg6tTUlIn6MUUI4pDRy1I0RrQv6y/CxXkwifdlFRh8QIeNY/0jia8AgdyH/RD8rkcWXNLfeDry37rDjQ/PF9n+1aDhLek5Cq3BWT0FrJWJnC2SxYILUBVea+NSv4A6WIXB44nzBbjdi6GRgLAVstWXhjLTRnemBLWj3PrUaXlRt80GBtMacqDZT7LD64Zjns+s6uJQpknQiUsi5T3CZy5QvsGp6adVQpzmrBGkzOluBid3INEzQOW3iFs2ZoIzRztgsOLqfvZQqVZJk9aHPVWasoyV3sC1uNYe4bgNZiVo75CjE+yHCGCF6L/GIigNtn+FBPVmhtgwDZ75fnDGuBOSe+NoorPvxz9cZMNwuqfnEkFmz9jFn+85Sxxtnbs+k7cTCfS1jA2mzWejs/bvrHRVE4ow9vmX5f9VOHMChGrYD8wAMP4Morr8T111+PjRs3Ys6cOVi4cCHefvvtAd3Hai5DV2qTrh98VApxYCcuEyjaaNLY+UtxOWJOfs5CTRS6jYeDytLYCbxhQNHdCrQgVOIYRa+aUQA0BU5E3kOYa41yHNm0WoWYEsRH5gErGmE5DhU+7anTAmzMYe3VxKYQKsah1RKXPLM7J04fUwjRYkqbksnUmcpzAPCEm7JJQ1TPXaaAYkRFD6jUcnMwXmr6ty/4ea2Z4EQ/+ltrl4eRTTysgYtDZcvc8vhYc1SvPYx9w7kF3Le8sbJPGadpaxgNUGwWJx5bfr+COajEys6BqvH/TELnN5ppjWoSWU1zGChb7CEw2pOxpQidjQyheR+7RFC/u/5uTcgXtBxT6rhalpliIMpqEZLImcb29uQYV4oo+MY0vJ6RwFrLchQiCggNTD/s7qGcofUst1pu138UPV6r5zZwlX3oOus5Ous5PujuQdGkemNBrKdB0eTFkFOBwWrp40DZfNo83zS01b6xMJx7GuSC2fDLEfURFwJhFyMW9Py8wjw3eD4NpRajv/BBzzevur+ZnK1haIWDMWmMj/fWrcCchoGtGMY+peR/TH1WMIdm9ovmAC6u3hWAD+FkMue5WUnculCKIoxJY9tf1ThGNaFgsSQMjMsXCUzFKMSYlLKvVGIqcw5Q/t9xxcR+38RkLtlTr4PKG1Mxgkw7v01/gDg3OuMfcpsO1NpplP3XaN3sivVZ0Nf8cRprPth7+45ZQ+kwTS4mLEimxuWNhWVSUKDpEAi4oGmllAnMNGtQxFUvQ6scsIKJCpqUJeyixnuVVTzkpHmtm8MyH1g0aO0KjBKFvzeXjWf3AnbnIGujN3aBG4PACL+ctzn14jRKsV/ghF7PFiLWWvv9zut02sdaXww5zZxGlpMwHZh1mzMZUR84y0mgKLCQvfKKpigKxwRo8JyifSwyz5ECBxfS2mSze5hrLI/4e5kbIycz8CGO/H55nJ0Wl61yPJ84iJGrmPL9+e9cEIWv5d7n94Yzz/Cc4VgPdt/k/vaLbfH7fKssB1lz/nV74DfzbTDFmQbKqBWQb7/9dixZsgSXXnopjj32WNx5552YNGkS7r777gHdh08yfMpT3mntYHDmAH8gw0DZUrj2ZGUmQjl1Wj+ezCxAcdRpwVQIA2gjony0JCBXk4iCJqCtwFEtxp6g7Uota0315duL5CPGFbhi83fWFIWKBI5KGln/zF1dDRsFXjSVlyqFCC2JS/1FZmyNtkKCccWUNtjYaUZzo9KhBYHgRPEkeJJAzGU8uS98003Vq1vfG34QOW0QbWpucXJmHaoYxAeVJKII6yRympZSQmPV2wyaazSdamO7ODl3Gl5IYpPP1PpQeadxhjQfodW+AcD4YsG6F+TaleVmwZY/e2whQT1zie8nlBKqrmhewwI2+yLCCIucsaBapCC9eq4xpSVx8wS8YdF41jKNieUCxpRiqyFoZCZ9ktkUOVBIazJdctATa3P9MaJy5bSJRmZT4ffVGlRdsWRcM0rm+cgy8gtNTVoywPm9hQHMAcu5q2ht/DfN/LFjEgSAd1gqGxN+sybHlXLdn1ldo1mDMlLYimPa+XhbTUxAVrDE+HMDQFuBLEH8/eOQ/IlJQKY+L8dU4Y6sSiHCwB3gk8AJzDzfAZh0fs56xiVrec0ZXyzY/qoWI5SN+TkJQlvJrFKIUIoiVIt0EKvEkR2fCcUCxpQTa6VIQ4X2UoqejCwYlSSyh5/esPCttctGAzhLIWsNuQ9ZSPb3YnrNZzvefbeV/u+EEW1fy1o8VrQUjAWJtbhKwR46KnFsvw/nPqb7OmGkWoisNrFsqhe2FGMrcNqx9TSJpEF2GXc43oDvzQcnngfsXsBlxv1npqUY2SJOcRAgh5/X2PVJEoR2/6DYGjT5yLOwWDH7GfdbDm0+E1Zr7Qt69gBhKjz6w1syqdwAlyrQBr/nlOINoLWiZCwg/mGf9r5wH5dA1iBX0sgWebIHEaPdZbciPhD0HjsNF9AdKFcshZvPfsYArIslQN+T9yvKjKWtAqychnavZNKYfNw179kHmP+uf5r13f6hhF3A/Nvwc2f7R8EEWQdGXmqWpYZePB6lAnKtVsMLL7yABQsWNF1fsGABnn322YHfUDn/Hh70/gwOm6H7em0auYh+DijiUxE/YPw8OWHZne7pujsx8omfYXeQyWMK9sEKFKyTf24e2rEV8k1t8aqN8QmWy3E2tLbRyoGCLcULcD5FhXGVxGqjOQgBAMamCaaMLQKAqVIEa2bv/YixnxZrMgBjagKnufPMnADGGL/aA9HXc8xmHfq7djmFFQmyvLhyG6rF2AVVNt27+eY8Lkb232fc/YXed3thOKo/DNzp+LC2ojVXATB+uEBrGps+oeuslWto8o+bUCog8zTx/DGcLol/582uo7VgNRPHjmuln+ECKXlBbuQaXxhXMWZX1w+cnojN174fHrcpDPxoZHOQ0s2Lv01rpMnC0PBMeez3nJsDWBwESE2VRz8nQaYpVSIvqP5i728yvGDzRtFaipvHsdfc0X1c8/820rCmxv7ea24FCvbABJBw6vuShoqCvdisDpB2iwWNyNOi8j37UuK4zAf0R98US2XK6bmlg1lsD29+hcLJbUUUoxCT28za4QkX7S0pDjNrCrvKHDa2aE3HvA6ywNcb338egBXg6D3N48zzsek2urf48N/Tl8DRnz2GS8cDLl8tKxO01jZgj+/ua5CtlhDAuEritPoF0vCOb0mbrBD8Wg6UbsoiZOYCP0uAyzTg9y23gYVQ7sn2amrH3sb6wMXbMP7h1beMBgpNGuS2cmLnDI+nUl7+YfN/dqXhj2CLkU9iijJZYZoFbCj4gZ5RQBYazrbEQjfAWuJmcYsVbeVC5CnglOkDeg1ZiGH7JUDzM+h/F4Xm/ufP8A9CvI/5MU+AW4+j0I2Nb90E0NT+fdZGX9A1jfGbqdC8P3J7ev/sa66ta0WvPWyfLz6EKD2UIdgjxPbt2zFlyhSsXbsW8+fPt9dvvvlm/OEPf8Brr73W9Pp77rkH99xzDwBgy5YtOOaYY4a1vZ9n3n//fYwfP36km/G5Q/p9ZJB+Hxmk30cO6fuRQfr9wGzbtg0ffPDBAV8THfCvhzi9T1ocod6byy67DJdddtlwNUvwOPHEE/H888+PdDM+d0i/jwzS7yOD9PvIIX0/Mki///eMSheL9vZ2hGGIHTt2NF3fuXMnOjo6RqhVgiAIgiAIwqHAqBSQkyTBrFmzsGbNmqbra9aswZw5c0aoVYIgCIIgCMKhwKh1sbj66qvxne98B7Nnz8bcuXPx61//Gtu3b8f3v//9kW6a4CGuLSOD9PvIIP0+Mki/jxzS9yOD9Pt/z6gM0mOWLl2KW265Be+99x6OO+44/OIXv2gK2hMEQRAEQRCE3oxqAVkQBEEQBEEQBsqo9EEWBEEQBEEQhMEiArIgCIIgCIIgeIiALAwpS5cuxZFHHolCoYBZs2Zh/fr1+33tM888g/POOw+TJk1CqVTCl7/8Zfz+978fxtaOHgbS7z7//ve/Ua1WUalUhriFo5OB9rvWGr/85S9xzDHHIE1TTJo0Cdddd90wtXb0MNB+f/zxx3HKKaegWq2ivb0d5513Hl5//fVhau3oYN26dTj33HMxZcoUKKWwfPnyg75n8+bN+OpXv4pisYgpU6bg5ptv/szLdo92Btrvsq8OHhGQhSHjgQcewJVXXonrr78eGzduxJw5c7Bw4UK8/fbbfb7+2WefxfHHH4+HHnoIL7/8Mi6//HJcdtlluP/++4e55Yc2A+13plar4Zvf/KYEsg6SwfT7j3/8YyxduhQ///nP8eqrr+LRRx+V/h8gA+33//znPzjvvPMwb948bNy4EU888QS6urpw1llnDXPLD2327NmD4447Dr/61a9QLBYP+vpdu3bh9NNPR0dHBzZs2IA77rgDt956K26//fZhaO3oYaD98cq60QAACttJREFULvvqf4EWhCFi9uzZ+nvf+17TtS984Qv6uuuu6/c9Fi1apL/+9a9/1k0b1Qy236+66iq9ZMkSvWzZMl0ul4eyiaOSgfb7li1bdBRF+pVXXhmO5o1aBtrvDz74oA6CQDcaDXvtqaee0gD0+++/P6RtHa2Uy2W9bNmyA75m6dKlulqt6s7OTnvtZz/7mZ48ebLO83yIWzg66U+/94Xsq/1DNMjCkFCr1fDCCy9gwYIFTdcXLFiAZ599tt/32bVrF9ra2j7r5o1aBtvvjzzyCFavXo077rhjqJs4KhlMvz/88MM46qij8Nhjj+Goo47CtGnTsHjxYuzcuXM4mjwqGEy/n3jiiYjjGL/73e+QZRl2796Ne++9FyeddBLa29uHo9mfS/75z39i3rx5TVrPM844A9u3b8e2bdtGrmGfQ2Rf7R8iIAtDwgcffIAsy/Yp7d3R0bFPCfD9sXr1ajz55JOS8HwADKbf33vvPVx66aVYsWIFqtXqcDRz1DGYfn/zzTfx1ltvYdWqVVi+fDlWrFiBLVu24JxzzkGe58PR7EOewfT7tGnTsGbNGtxwww1I0xStra3YvHkzVq9ePRxN/tyyY8eOPseJ/yYMD7Kv9h8RkIUhRSnV9LvWep9rffGPf/wDF110Ee644w7Mnj17qJo3ahlIv3/729/G5ZdfjpNPPnk4mjaqGUi/53mOnp4erFixAvPnz8e8efOwYsUKPPfcc9iwYcNwNHfUMJB+37FjBy655BJ897vfxYYNG/DMM8+gWq3iwgsvlIPJENPXOPV1XRgaZF8dGCIgC0NCe3s7wjDcRzOwc+fOfbQIvfn73/+OhQsX4uabb8bll18+lM0cdQym35966incdNNNiKIIURThkksuwd69exFFEe65557haPYhz2D6fdKkSYiiCNOnT7fXvvjFLyKKooMGVArEYPr9rrvuQrlcxi233IIZM2Zg/vz5uO+++7B27doBuX8JA2PixIl9jhOAg+4Jwn+P7KsDRwRkYUhIkgSzZs3CmjVrmq6vWbMGc+bM2e/71q1bh4ULF+KGG27AVVddNcStHH0Mpt83b96MTZs22X8333wzisUiNm3ahEWLFg1Hsw95BtPvc+fORaPRwNatW+21N998E41GA1OnTh3S9o4WBtPvnZ2dCMOw6Rr/LhrkoeOUU07B+vXr0d3dba+tWbMGkydPxrRp00auYZ8DZF8dJCMaIiiMalatWqXjONa//e1v9SuvvKKvuOIKXS6X9bZt27TWWl933XX6a1/7mn39008/rUulkr7mmmv0e++9Z//t3LlzpL7CIclA+703ksVicAy037Ms0zNnztTz58/XL774on7xxRf1/Pnz9Ve+8hWdZdlIfY1DjoH2+5NPPqmVUvrGG2/Ur7/+un7hhRf0GWecoQ8//HC9Z8+ekfoahxy7d+/WGzdu1Bs3btTFYlHfdNNNeuPGjfqtt97SWu/b75988onu6OjQ3/jGN/TmzZv1H//4R12tVvVtt902Ul/hkGSg/S776uARAVkYUu666y49depUnSSJnjlzpl67dq392+LFi/XUqVObfgewzz//NUL/GEi/90YE5MEz0H7fvn27vuCCC3SlUtHjx4/XF110kd6xY8cwt/rQZ6D9vnLlSj1jxgxdLpd1e3u7Pvvss/W//vWvYW71oc3TTz/d53q9ePFirXXf/f7SSy/pefPm6TRN9cSJE/WNN94oKd4GyED7XfbVwaO0ljI2giAIgiAIgsCID7IgCIIgCIIgeIiALAiCIAiCIAgeIiALgiAIgiAIgocIyIIgCIIgCILgIQKyIAiCIAiCIHiIgCwIgiAIgiAIHiIgC4Ig/B9j+fLlqFQqI/b5H3/8MTo6Opqq/A0l11xzDa644oph+SxBEIT+IHmQBUEQhhGl1AH/vnjxYtx9993YvXs3JkyYMEytaubaa6/FBx98gGXLlg3L573//vs4+uijsWnTJhx11FHD8pmCIAgHQgRkQRCEYWTHjh3259WrV+PSSy/Fe++9Z68Vi0W0traORNMAAJ2dnZgyZQr+8pe/4NRTTx22z73gggtw5JFH4tZbbx22zxQEQdgf4mIhCIIwjEycONH+GzNmzD7XWltb93GxuPHGG3Hcccfh3nvvxbRp01CpVHDxxRejVqth6dKlOPzwwzFu3DhcffXVyPPcvq9Wq+GnP/0pDjvsMJTLZZx00kl4/PHHD9i+Rx99FEEQYO7cufZavV7HFVdcgcmTJyNNUxx++OG47rrrBvQ5W7ZswbnnnovW1lZUKhWccsop2Lx5s/37ueeei5UrVw6qTwVBED5ropFugCAIgnBwtm3bhocffhirV6/Gu+++i/PPPx87duzAxIkT8be//Q1btmzBhRdeiLlz5+L8888HAFx88cXYunUr7r//fhx22GF49NFHcc4552DDhg044YQT+vyc9evXY9asWU2uIHfccQf+/Oc/Y9WqVZg2bRreeecdvPbaa/bvB/uc7du349RTT8XcuXOxZs0ajBkzBs899xyyLLP3mD17Nt59911s3boVRx999BD1oiAIQv8QAVkQBOEQIMsyLFu2DK2trTjuuONw5plnYu3atXj33XeRJAmOPfZYzJ07F08//TTOP/98bN26FStXrsS2bdtwxBFHAAB+9KMf4YknnsBvfvMbLF26tM/PeeuttzBp0qR9rk2fPh3z5s2DUgpHHHEE5syZAwD9+py77roL5XIZDz74IJIkAQBMnz696TMmT54MgA4CIiALgjDSiIAsCIJwCHDEEUc0+SZ3dHRg+vTpVuDkazt37gQAvPjii9Ba40tf+lLTfXp6evC1r31tv5/T1dWFjo6OpmtLlizB6aefjunTp2PBggU466yzsHDhQgRB0K/P2bhxI0499dSmtvamWCzazxcEQRhpREAWBEE4BIjjuOl3pVSf19htIc9zKKWwYcOGfV7HwmhftLe34+OPP266NnPmTGzbtg2PPfYYnnrqKSxevBgnnHAC1qxZ06/P6U8s+EcffQQAGD9+/EFfKwiCMNSIgCwIgjAKmTFjBrTW2LFjB0477bQBvW/58uX7XK9Wq1i0aBEWLVqEJUuW4OSTT8Ybb7zRr8+ZOXMm7rvvPtRqtf1qkV9++WXEcYzjjz++320VBEEYKiSLhSAIwihk+vTp+Na3voUlS5bgoYcewptvvonnn38et912G/70pz/t931nnHEGXn31VXz44Yf22u23346VK1fi1VdfxRtvvIH7778fLS0tOOyww/r1OT/4wQ+wZ88eXHjhhdiwYQPeeOMNrFy5Eps2bbKfsX79esybNw+lUmnI+kQQBKG/iIAsCIIwSlm2bBkuvvhi/OQnP8ExxxyDs88+G+vWrcPUqVP3+57jjz8es2fPxqpVq+y1arWKW2+9FbNnz8bMmTOxadMm/PWvf7XC7ME+Z8qUKVi3bh1qtRpOO+00zJgxA3feeSeiyBkxV65ciUsvvXSIekIQBGFgSKEQQRAEoYnHHnsMV155JV555RWEYTjkn/fII4/g2muvxUsvvdQkNAuCIIwUokEWBEEQmjjzzDPxwx/+EO+8886wfN7evXuxbNkyEY4FQfg/g2iQBUEQBEEQBMFDNMiCIAiCIAiC4CECsiAIgiAIgiB4iIAsCIIgCIIgCB4iIAuCIAiCIAiChwjIgiAIgiAIguAhArIgCIIgCIIgePx/y+hyxPyvsvoAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:52.483886Z", + "start_time": "2025-09-17T18:06:52.480860Z" + } + }, + "cell_type": "code", + "source": [ + "labels = ctm.labelled_midpoints\n", + "fine_tuned_boundaries = fine_tuned_ctm.phone_boundaries\n", + "for i, b in enumerate(ctm.phone_boundaries):\n", + " if b != fine_tuned_boundaries[i]:\n", + " print(f\"Fine tuning moved the end of {labels[i][0]} from {b:.3f} to {fine_tuned_boundaries[i]:.3f}\" )" + ], + "id": "622602fbfa22d0e5", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fine tuning moved the end of m from 0.110 to 0.030\n", + "Fine tuning moved the end of ɑ from 0.200 to 0.035\n", + "Fine tuning moved the end of n from 0.230 to 0.050\n", + "Fine tuning moved the end of tʲ from 0.340 to 0.035\n", + "Fine tuning moved the end of ɹ from 0.370 to 0.033\n", + "Fine tuning moved the end of i from 0.400 to 0.043\n", + "Fine tuning moved the end of ɒ from 0.470 to 0.041\n", + "Fine tuning moved the end of ɫ from 0.540 to 0.030\n", + "Fine tuning moved the end of f from 0.660 to 0.030\n", + "Fine tuning moved the end of ɒ from 0.720 to 0.039\n", + "Fine tuning moved the end of ɹ from 0.800 to 0.030\n", + "Fine tuning moved the end of s from 0.850 to 0.032\n", + "Fine tuning moved the end of t from 0.910 to 0.039\n", + "Fine tuning moved the end of ə from 0.950 to 0.034\n", + "Fine tuning moved the end of l from 1.040 to 0.034\n", + "Fine tuning moved the end of aj from 1.150 to 0.036\n", + "Fine tuning moved the end of n from 1.200 to 0.030\n", + "Fine tuning moved the end of ɚ from 1.330 to 0.043\n" + ] + } + ], + "execution_count": 6 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:53.667216Z", + "start_time": "2025-09-17T18:06:53.664217Z" + } + }, + "cell_type": "code", + "source": [ + "from _kalpy.matrix import DoubleMatrix, FloatMatrix, FloatSubMatrix, FloatSubVector\n", + "from _kalpy.gmm import gmm_interpolate_boundary\n", + "from _kalpy.hmm import SplitToPhones" + ], + "id": "656738b6294454fc", + "outputs": [], + "execution_count": 7 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:06:54.494657Z", + "start_time": "2025-09-17T18:06:54.487342Z" + } + }, + "cell_type": "code", + "source": [ + "lexicon_compiler = lc\n", + "alignment = aligner._align_utterance(utterance)\n", + "split = SplitToPhones(am.transition_model, alignment.alignment)\n", + "phone_intervals = alignment.generate_ctm(\n", + " am.transition_model,\n", + " lexicon_compiler.phone_table,\n", + " am.frame_shift_seconds,\n", + ")\n", + "ctm = lexicon_compiler.phones_to_pronunciations(\n", + " alignment.words, phone_intervals, transcription=False, text=utterance.transcript\n", + ")\n", + "ctm.likelihood = alignment.likelihood\n", + "ctm.update_utterance_boundaries(utterance.segment.begin, utterance.segment.end)" + ], + "id": "a4f39cda87ef713a", + "outputs": [], + "execution_count": 8 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:13:12.031078Z", + "start_time": "2025-09-17T18:13:12.026876Z" + } + }, + "cell_type": "code", + "source": [ + "boundary_index = 0\n", + "boundary = phone_intervals[boundary_index].end\n", + "feature_padding = 0.04\n", + "boundary_tolerance = am.frame_shift_seconds * 2\n", + "feature_segment_begin = max(\n", + " round(\n", + " boundary - feature_padding, 4\n", + " ),\n", + " 0,\n", + ")\n", + "feature_segment_end = min(\n", + " round(boundary + feature_padding, 4),\n", + " utterance.segment.end,\n", + ")\n", + "duration = phone_intervals[boundary_index].end - phone_intervals[boundary_index].begin\n", + "following_phone_duration = phone_intervals[boundary_index+1].end - phone_intervals[boundary_index+1].begin\n", + "previous_phone_offset_window = min(boundary_tolerance, duration / 2) / 2\n", + "print(previous_phone_offset_window)\n", + "following_phone_offset_window = (\n", + " min(boundary_tolerance, following_phone_duration / 2) / 2\n", + ")\n", + "print(following_phone_offset_window)\n", + "begin_offset = round(max(boundary - previous_phone_offset_window - feature_segment_begin, 0.0), 4)\n", + "end_offset = round(min(boundary + following_phone_offset_window - feature_segment_begin, feature_segment_end - feature_segment_begin), 4)\n", + "print(phone_intervals[0])\n", + "print(f\"Boundary: {boundary} ({feature_segment_begin}, {feature_segment_end}): {begin_offset, end_offset}\")" + ], + "id": "4c62e23331bda685", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.01\n", + "0.01\n" + ] + } + ], + "execution_count": 22 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:07:10.351009Z", + "start_time": "2025-09-17T18:07:10.345348Z" + } + }, + "cell_type": "code", + "source": [ + "seg = Segment(\n", + " utterance.segment.file_path,\n", + " feature_segment_begin,\n", + " feature_segment_end\n", + ")\n", + "seg_feats = am.generate_features_for_fine_tune(seg, cmvn=None, fmllr_trans=None)\n", + "begin_index = int(round(begin_offset * 1000))\n", + "end_index = int(round(end_offset * 1000))\n", + "sub_matrix = FloatSubMatrix(\n", + " seg_feats, begin_index, end_index - begin_index, 0, seg_feats.NumCols()\n", + ")\n", + "feats = FloatMatrix(sub_matrix)\n", + "print(f\"Selected feature frames {begin_index}-{end_index} from {seg_feats.NumRows()} total frames\")" + ], + "id": "d172bc3ce58132cd", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected feature frames 0-80 from 80 total frames\n" + ] + } + ], + "execution_count": 15 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:07:10.933285Z", + "start_time": "2025-09-17T18:07:10.876749Z" + } + }, + "cell_type": "code", + "source": "plt.imshow(feats.numpy().T)", + "id": "422526e7d646137c", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:07:11.203469Z", + "start_time": "2025-09-17T18:07:11.134385Z" + } + }, + "cell_type": "code", + "source": [ + "previous_transition_id = split[boundary_index][-1]\n", + "following_transition_id = split[boundary_index+1][0]\n", + "previous_loglikes = []\n", + "following_loglikes = []\n", + "\n", + "previous_pdf_id = am.transition_model.TransitionIdToPdfFast(previous_transition_id)\n", + "following_pdf_id = am.transition_model.TransitionIdToPdfFast(following_transition_id)\n", + "\n", + "for i in range(feats.NumRows()):\n", + " feat_row = FloatSubVector(feats, i)\n", + " \n", + " previous_loglikes.append(aligner.ali_aligner.acoustic_model.LogLikelihood(previous_pdf_id, feat_row))\n", + " following_loglikes.append(aligner.ali_aligner.acoustic_model.LogLikelihood(following_pdf_id, feat_row))\n", + "plt.plot(previous_loglikes, label=\"previous\")\n", + "plt.plot(following_loglikes, label=\"following\")\n", + "plt.legend()" + ], + "id": "2656940f829968bd", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByWUlEQVR4nO3dd3xT9frA8U+atumegQ7oYm8KlI0CslQUx0VAUEEQJwICojguQxGvC9H7ExeyFVTQKyJKQUCRVcpeZZVSCm1pKd1N0+b8/jgQrJQOaJomfd6vV8zJyTcnz5fa5Ol3ahRFURBCCCGEsCMO1g5ACCGEEKKqSYIjhBBCCLsjCY4QQggh7I4kOEIIIYSwO5LgCCGEEMLuSIIjhBBCCLsjCY4QQggh7I4kOEIIIYSwO47WDsAaTCYT58+fx9PTE41GY+1whBBCCFEBiqKQnZ1NcHAwDg5lt9HUygTn/PnzhISEWDsMIYQQQtyExMRE6tevX2aZWpngeHp6Auo/kJeXl5WjEUIIIURFZGVlERISYv4eL0utTHCudkt5eXlJgiOEEELYmIoML5FBxkIIIYSwO5LgCCGEEMLuSIIjhBBCCLtTK8fgVISiKBQVFVFcXGztUEQlaLVaHB0dZfq/EELUcpLglKKwsJALFy6Ql5dn7VDETXBzcyMoKAhnZ2drhyKEEMJKJMH5B5PJRHx8PFqtluDgYJydnaU1wEYoikJhYSEXL14kPj6exo0bl7sQlBBCCPskCc4/FBYWYjKZCAkJwc3NzdrhiEpydXXFycmJhIQECgsLcXFxsXZIQgghrED+vL0B+cvfdsnPTgghhHwTCCGEEMLuSIIjbtmoUaO4//77rR2GEEIIYSZjcMQtmzdvHoqiWDsMIYQQwkwSnFqssLCwSqZSe3t7V0E0QgghRNWRLio70qtXL8aNG8e4cePw8fHB39+f1157zdy6Eh4ezptvvsmoUaPw9vZm7NixAGzbto3bb78dV1dXQkJCGD9+PLm5uQBMmzaNLl26XPdebdq0Yfr06cD1XVQGg4Hx48dTt25dXFxc6NGjBzExMebnFy1ahI+PT4nr/fjjjyWm4+/fv5/evXvj6emJl5cXHTp0YPfu3VXy7ySEPcoxFHE8JZtNcaks35nAu78d44Po43wfe46YM5dIzSqQllZRq0gLTgUoikK+0TorGrs6aSu1Ds/ixYsZM2YMO3fuZPfu3Tz55JOEhYWZk5l3332X119/nddeew2AgwcPMmDAAN544w0WLFjAxYsXzUnSwoULGTFiBG+//TanTp2iYcOGABw+fJiDBw/y/ffflxrD1KlTWbVqFYsXLyYsLIx33nmHAQMGcPLkSfz8/CpUjxEjRtCuXTvmz5+PVqtl3759ODk5VfjfQQh7pSgK5zLy2X/uMvsTL7M/MZNjyVlkFRSV+1oXJwfC/Nzp2tCf+yKDiQzxkXW+hN2SBKcC8o3FtPj3b1Z57yOzBuDmXPEfU0hICHPnzkWj0dC0aVMOHjzI3LlzzQnOHXfcwZQpU8zlH3vsMYYPH87EiRMBaNy4MR999BE9e/Zk/vz5tGrVijZt2vD111/z+uuvA7B8+XI6duxIkyZNrnv/3Nxc5s+fz6JFi7jrrrsA+OKLL4iOjmbBggW8+OKLFarH2bNnefHFF2nWrJk5LiFqI5NJIS4lm79OprHjdDr7Ei+TllNYallvVyeCfVwJ9nYhyMeFYhOcvZRLQnoe5y/nU2A0EZeSTVxKNou2nSHUz437IoO5LzKYRnU9q7lmQliWJDh2pkuXLiX+IuvatSvvv/++eU+tqKioEuVjY2M5efIky5cvN59TFMW8onPz5s0ZMWIEX331Fa+//jqKovDNN9+YE6J/OnXqFEajke7du5vPOTk50alTJ44ePVrhekyaNIknnniCpUuX0rdvXx566CFzC5IQ9i7pcj5/Hr/IX6fS2XYyjfTckgmNo4OGFsFetK3vQ9sQH1rV86K+rxseuht/pBcWmUi6nM/xlGzWHbzA+iMpnL2Ux8e/n+Tj30/SLNCTLg38aR/mS/tQH+r5uErrjrBpkuBUgKuTliOzBljtvauSu7t7iccmk4mnnnqK8ePHX1c2NDQUgOHDh/Pyyy+zZ88e8vPzSUxMZNiwYaVe/2of/z8/GBVFMZ9zcHC4biyA0Wgs8XjGjBkMHz6ctWvXsm7dOqZPn86KFSt44IEHKlFbIWzHpdxC1h68wP/2JrE7IaPEc65OWjo38KN7Qz0dwn1pEeSFSyU/G5wdHYjQuxOhd2dAy0DyCovYcDSVn/YlsTnuIseSszmWrLbsANT11NE+1JfODfy4s1UgQd6uVVVVIaqFJDgVoNFoKtVNZE07duy47nHjxo3Rakv/MGzfvj2HDx+mUaNGN7xm/fr1uf3221m+fDn5+fn07duXgICAUss2atQIZ2dntm7dyvDhwwE1edm9e7e51adOnTpkZ2eTm5trTrj27dt33bWaNGlCkyZNeOGFF3j44YdZuHChJDjCrlxNMv63N4ktxy9SZLr6BwK0C/GhR+M69GikJzLEB2fHqp0T4ubsyKC2wQxqG0xGbiF/nLjI3rOX2XM2gyPns0jNNvDr4WR+PZzMzDVHiArz5Z42QdzdOoi6XrIFiqj5bONbW1RYYmIikyZN4qmnnmLPnj18/PHHvP/++zcs/9JLL9GlSxeee+45xo4di7u7O0ePHiU6OpqPP/7YXG7EiBHMmDGDwsJC5s6de8Prubu788wzz/Diiy/i5+dHaGgo77zzDnl5eYwZMwaAzp074+bmxiuvvMLzzz/Prl27WLRokfka+fn5vPjiiwwePJiIiAjOnTtHTEwM//rXv279H0gIK0vLMbDxaArRR1L480QahiKT+bmWwV7cH1mPe9sGE+hdfUmEr7sz90XW477IegDkFxZzMCmT2IQMfj+WQsyZDHYnqLeZPx+hU7gfD7RT43Qvo1tMCGuS/zPtzGOPPUZ+fj6dOnVCq9Xy/PPP8+STT96wfJs2bdiyZQuvvvoqt912G4qi0LBhQ4YOHVqi3EMPPcTzzz+PVqstd9Xit99+G5PJxKOPPkp2djZRUVH89ttv+Pr6AuDn58eyZct48cUX+fzzz+nbty8zZswwx6nVaklPT+exxx4jJSUFvV7Pgw8+yMyZM2/tH0fUWoVFJi7nF5KZZyQz38jlPCN6Tx0tg71w0lp2tQxFUTieksOmuFSij6Sw52wGf++hDfFz5b629bi/Xc0Z6OvqrKVThB+dIvx4pldDLmTm88vBZH4+cJ69Zy+zM/4SO+Mv8ebao9wXGczwzqG0DJb1sETNolFq4cIIWVlZeHt7k5mZiZeXV4nnCgoKiI+PJyIiwuZ2ou7VqxeRkZF8+OGH1g7Fqmz5ZyhuTo6hiD+PXyTpcj4pWQUkZxlIySwgOauAtBwDeYWlL/Pg5qylQ5gvXRr40znCjzb1q6YrKCO3kD9PpvHH8Yv8eeIiKVmGEs+3rudNvxYB9GsRQLNAT5sazHsuI481+y+wMuYsZ9LzzOfbhvgwolMod7UOxNNFlnQQllHW9/c/SQuOEMJmJV7KY/G2M6yMSSTbUPY6MBoNeLk44evmhJerEwnpeWTmG/nzRBp/nkgDQOfoQJi/G0Herubp1sE+rgR4ueDqrMXVSXvt3klLtsHI2Ut5JF7KIyE9j7OX8jh9MZejyVklWmlcnBzoHOFP3+Z16dsiwKYH7Nb3deOZXg156vYGbD+dztc7z/Lb4eQra/Jc5rX/HaJ30zoMbBNMn2Z1pQtLWI38nyeEsCmKorA7IYOvtsbz2+FkrozLJdzfjVb1vAn0ciHAy4UAbxcCvVyo46nD180JTxcntA7XWkquri+z83S6ucvlUm4hx1NyOJ6Sc8txNg3w5PYmem5vUoeO4X6VnvVU0zk4aOjeSE/3RnouZhv4LjaR73ef43RaLr8dTuG3wynoHB24o1ld7m0bTN/mAVU+UFqIskgXlR11UQmV/Azt158nLvLe+uPsT7xsPndbYz2je0TQs3EdHBxuvqtHURTOpOdxLkNdFC/pcgEXLudzPjOfi9kG8o3FFBhNFBQWU1BUjLFYwUmrIcTXjRA/N8L83Qj1U4/b1vep1kHCNYWiKBy9kM3ag+f5+cAFEv7WhaX3cGZIVAgPdwolxM/NilEKW1aZLipJcCTBsTvyM7Q/B89l8p9fj7H1pNqV5OzowIPt6vF49wiaBlpnYK6x2IRWo7mlpMqeKYrC4fNZrDlwnh/2JJGarY5D0migV5M6jOgcRu9mdUu0qglRHhmDI4SwC2fT83hvfRw/7T8PgJNWw6Ndwnm2d0P0Hjqrxmbp2Ve2TqPR0KqeN63qeTOlf1M2Hk1h2Y6zbD2Zxqa4i2yKu4jew5leTevSp1ldejTWy+BkUaUkwRFC1Dgmk8L70XF8/sdpjMVqI/P9kcFM7t9UujdskJPWgTtbBXFnqyDi03L5ZtdZvt2dSFpOId/HnuP72HM4aTV0ivCjd9O63N06iGAf2x2ILWoG6aKSLiq7Iz9D21ZsUnhp1QG+jz0HwO1N6jB1QFNa1ZN1VuxJYZGJ3WcusfFYKr8fSyU+Ldf8nEYDXRv482D7+tzVKlBmYgkzGYNTDklw7Jv8DG2XsdjExJX7WHvgAloHDe8ObsOD7etbOyxRDU5fzOH3Y6msP5LCrvhL5vOuTlrubBXIg+3r0bWBP47SNViryRgcIYTNKTAWM+7rPWw4moqTVsPHD7fnzlaB1g5LVJMGdTxoUMeDJ25rQOKlPH7cm8TqvUnEp+Xyw94kftibhN7DmTtbBXJPm2A6hvvJAGVRpmpJhQ0GA5GRkWg0mus2VTx79iz33nsv7u7u6PV6xo8fT2FhYbnXe/7559Hr9bi7uzNo0CDOnTtnwRrYBkVRePLJJ/Hz8yv13/qfNm/ejEaj4fLlywAsWrQIHx8fi8U3atSocrd5ELVTXmERTyzezYajqegcHfjisShJbmqxED83nu/TmN8n92T1s914pEsoPm5OpOUUsmzHWYZ9voOuczYy46fD7Iq/RLGp1nVEiAqolhacqVOnEhwczP79+0ucLy4uZuDAgdSpU4etW7eSnp7OyJEjURSlxEaP/zRx4kTWrFnDihUr8Pf3Z/Lkydxzzz3ExsbecNfs2uDXX39l0aJFbN68mQYNGqDX660dUgnz5s2jFvaIinJkFxgZvSiGmDMZuDlrWTCyI10b+ls7LFEDaDQa2of60j7Ul+n3tmTbqXR+3n+e3w4nk5ptYNG2Myzadga9h47+LQMY0DKQrg38ZUFBAVRDgrNu3TrWr1/PqlWrWLduXYnn1q9fz5EjR0hMTCQ4OBiA999/n1GjRjF79uxS+9cyMzNZsGABS5cupW/fvgAsW7aMkJAQNmzYwIABAyxdpRrr1KlTBAUF0a1bN2uHUipvbxkkKkoyFpsYu2Q3MWcy8HRxZPHoTrQP9bV2WKIGctI60LNJHXo2qcPsB1qz9eRFft5/geijKaTlGPh651m+3nkWTxdH+jYPoH+LAG5vUkcGKNdiFk1zU1JSGDt2LEuXLsXN7fqpndu3b6dVq1bm5AZgwIABGAwGYmNjS71mbGwsRqOR/v37m88FBwfTqlUrtm3bVuprDAYDWVlZJW72ZtSoUTz//POcPXsWjUZDeHg4BoOB8ePHU7duXVxcXOjRowcxMTGVuu78+fNp2LAhzs7ONG3alKVLl5qfmzx5Mvfee6/58YcffohGo2Ht2rXmc02bNuWzzz4zx/j3LqpevXoxfvx4pk6dip+fH4GBgcyYMaPE+x87dowePXrg4uJCixYt2LBhAxqNhh9//LFS9RA106w1R9hx+hLuzlq+GdtFkhtRIc6ODtzRLIAPhkYS+1o/lozuxPDOoeg9dGQXFPHD3iSeWb6Hdm9E8/jCXXyz6yyp2QXWDltUM4ultoqiMGrUKJ5++mmioqI4c+bMdWWSk5MJCAgocc7X1xdnZ2eSk5NLvW5ycjLOzs74+pb8IAwICLjha+bMmcPMmTNvriIAigLGvPLLWYKTmzpnshzz5s2jYcOGfP7558TExKDVapk6dSqrVq1i8eLFhIWF8c477zBgwABOnjyJn59fudf84YcfmDBhAh9++CF9+/bl559/5vHHH6d+/fr07t2bXr16sWDBAkwmEw4ODmzZsgW9Xs+WLVsYOHAgycnJHD9+nJ49e97wPRYvXsykSZPYuXMn27dvZ9SoUXTv3p1+/fphMpm4//77CQ0NZefOnWRnZzN58uRK/fOJmmv5zgSW7khAo4F5w9rJNHBxU5wdHbi9SR1ub1KHN+5rxd6zGfx6KJn1R1I4eynPvKigRgORIT70aKSnawN/2of52t3+YKKkSic4M2bMKDdZiImJYdu2bWRlZTFt2rQyy2pK+fJWFKXU82Up6zXTpk1j0qRJ5sdZWVmEhIRU/OLGPHgruPxylvDKeXB2L7eYt7c3np6eaLVaAgMDyc3NZf78+SxatIi77roLgC+++ILo6GgWLFjAiy++WO4133vvPUaNGsWzzz4LwKRJk9ixYwfvvfcevXv35vbbbyc7O5u9e/fSvn17/vzzT6ZMmcLq1asB2LRpEwEBATRr1uyG79GmTRumT58OQOPGjfnvf//Lxo0b6devH+vXr+fUqVNs3ryZwEB1wOns2bPp169fubGLmm3n6XSm/+8wAFP6N6Vvi4ByXiFE+bQOGqLC/YgK9+PVgc05npJD9JFkoo+ksP9cJnvPXmbv2ct8/PtJnLUORIb60KWBP+1Dfcy7xnu5OFb6+0fUTJVOcMaNG8ewYcPKLBMeHs6bb77Jjh070OlKLqceFRXFiBEjWLx4MYGBgezcubPE8xkZGRiNxutadq4KDAyksLCQjIyMEq04qampNxx7otPprovD3p06dQqj0Uj37t3N55ycnOjUqRNHjx6t0DWOHj3Kk08+WeJc9+7dmTdvHqAmVZGRkWzevBknJyccHBx46qmnmD59OtnZ2WzevLnM1htQE5y/CwoKIjU1FYC4uDhCQkLMyQ1Ap06dKhS7qLkSL+XxzPI9FJkU7mkTxLO9Glo7JGGHNBoNTQM9aRroybg7GpOcWcCW46lsP5XO9tPppGQZ2BV/qcSaO6CuuxPo7UJdTx0hfm5E6N3Nt3B/d1ydpdXHVlQ6wdHr9RWanfPRRx/x5ptvmh+fP3+eAQMGsHLlSjp37gxA165dmT17NhcuXCAoKAhQBx7rdDo6dOhQ6nU7dOiAk5MT0dHRDBkyBIALFy5w6NAh3nnnncpWp2Kc3NSWFGtwurll6a/OVvrnXyKVbR0r7/W9evVi8+bNODs707NnT3x9fWnZsiV//fUXmzdvZuLEiWVe38mp5N4zGo0Gk8l0U7GKmi/XUMTYJbu5lFtIq3pevDu4rfyMRbUI9HZhaMdQhnYMRVEUEtLz2H46ne2n0olLziY5q4DMfCP5xmLi03KJT8tl5z+SH4Agbxfqermgd3fGz90Zfw8d/u7O1PHUEeavJkQ+bs5WqKH4J4uNwQkNDS3x2MPDA4CGDRtSv766Mmn//v1p0aIFjz76KO+++y6XLl1iypQpjB071jyDKikpiT59+rBkyRI6deqEt7c3Y8aMYfLkyfj7++Pn58eUKVNo3bq1eVZVldNoKtRNVJM0atQIZ2dntm7dyvDhwwEwGo3s3r273KTjqubNm7N161Yee+wx87lt27bRvHlz8+Or43AcHR3N//49e/ZkxYoV5Y6/KU+zZs04e/YsKSkp5ha9yg6SFjWHyaQw5bv9HEvORu+h4/NHo+SvYWEVGo2GcL074Xp3Hu507bsqv7CY1OwCkjMLSM4q4Gx6nprspOdy+mIumflGLmQWcCGz7AHLPm5OhPurrT6NAzyIrO9DmxAfPGRGV7Wy6r+2Vqtl7dq1PPvss3Tv3h1XV1eGDx/Oe++9Zy5jNBqJi4sjL+/aIN+5c+fi6OjIkCFDyM/Pp0+fPixatKhWr4HzT+7u7jzzzDO8+OKL+Pn5ERoayjvvvENeXh5jxoyp0DVefPFFhgwZQvv27enTpw9r1qxh9erVbNiwwVzm6jicNWvWmFvsevXqxb/+9S/q1KlDixYtbroO/fr1o2HDhowcOZJ33nmH7OxsXn31VaD0sVuiZvsg+jjrDiXjrHXgs0fby2aKosZxddYS5u9OmH/pf9Bm5BYSn55LWraBS7mFpOcWkp5TSHqugeTMAs6k55KSZeBynpF9eZfZl3jZ/FqNBhrX9SAyxIfIEF9ub6Knvq9sHGtJ1ZbghIeHl7rIW2hoKD///HOlXufi4sLHH39c5mKAAt5++21MJhOPPvoo2dnZREVF8dtvv103A+1G7r//fubNm8e7777L+PHjiYiIYOHChfTq1ctcxtvbm3bt2nH27FlzMnPbbbdhMpluqfUG1AT4xx9/5IknnqBjx440aNCAd999l3vvvVf2mLIxK3ad5b+bTgIw+4FWdAgrfxafEDWNr7szvu5ldz/lFRZxJi2PM+lqN9fh85nsT8wk6XI+x1NyOJ6Sw7e71ZX324X6cG+bYAa2CSLASz7TqppstimbbdqUv/76ix49enDy5EkaNix9cKr8DGuWLccvMnpRDMUmhfF9GjOpXxNrhyREtUvNKmBfotqqs/tMBjEJl7j67avRQKdwP+5tG8zgDvVl+noZZLNNYTd++OEHPDw8aNy4MSdPnmTChAl07979hsmNqFmOnM/iueV7KDYpPNiuHi/0bWztkISwirpeLvRvGUj/luqs0JSsAn45eIGfD1wgNiGDnfGX2Bl/ifmbT/HK3c25u3WgdMXfIklwRI2WnZ3N1KlTSUxMRK/X07dvX95//31rhyUq4EJmPqMXxZBjKKJrA3/e/lcb+cAW4ooALxce7x7B490jSLqcz8/7z7N42xmSLufz3Nd76NLAj+n3tqR5UNmtFOLGpItKuqjsjvwMrS+7wMhDn27nWHI2jep6sOrpbni7OZX/QiFqsfzCYuZvOcVnW05hKDLhoIERncOY1K9JuWN/aovKdFHJlqtCiCpVWGTiua/3mqeDLxzVUZIbISrA1VnLpH5N2Di5JwNbB2FSYOmOBO54fzO/HLxg7fBsjiQ4Qogqc3Wtmz+OX8TVSctXo6II8ZOpsEJURn1fN/5vRHu+GduFZoGeZOQZeXb5HiZ9u4+sAqO1w6uQ/+1LsnqskuDcQC3subMb8rOzDkVRmP7TYX7afx5HBw3zH2lPm/o+1g5LCJvVtaE/P43rwbjejXDQwOo9Sdz14Z/sOJ1u7dDKFJuQwYQV++jz/hYy862X5EiC8w9Xtw74+8KCwrZc/dn9cxsIYVkfRB837w7+wdBIejWta+2QhLB5zo4OTBnQlG+f6kqonxtJl/N5+IsdzPnlKIaiYmuHd51ik8L0nw4B0KtJHbxdrfc5LLOo/kGr1eLj42Pe8NHNzU1mftgIRVHIy8sjNTUVHx8fWdm6Gi3YGs/Hv6sL+b1xXysGtQ22ckRC2JeocD9+mXAbb6w5wsrdiXz2x2n+OpXGF49FEeRdc1YFXxmTyKGkLDx1jky9s5lVY5EEpxRXd6++muQI2+Lj41NiB3JhWatiz/HGz0cAmNK/CY90CbNyRELYJw+dI/8Z3IY+zevy0qoDHErKYtB//+LzRzvQLrRiK9Rb0uW8Qt797RgAE/s1oY6nzqrxSIJTCo1GQ1BQEHXr1sVotI0BXULl5OQkLTfVaP3hZKauOgDAmB4RPNe7kZUjEsL+9W8ZSPMgL55YvJu4lGyGfr6Ddwe34b7IelaN6/31x8nIM9IkwIPHulr/Dx1JcMqg1Wrly1KIG4g+ksJzX6urFP+rfX1evbu5dOcKUU1C/NxY9Ww3Jq7Yy4ajqUxYsY/jKdlM7tcUB4fq/z08cj6L5TsTAJgxqCVOWusP8bV+BEIIm7P+cDLPLo/FWKwwsHUQ//lXa6t8qApRm3noHPns0Sie6aVuXfN/m07x1LJYcg1F1RqHOoPyECYFBrYOoltDfbW+/41IgiOEqJRfDyXz7PI9GIsV7mkTxLxhkTjWgL/WhKiNtA4aXrqzGR8MaYuz1oHoIykM/2IH6TmGaovhf/vOE3MmA1cnLa8MbF5t71se+VQSQlTYr4cuMO7rPRSZFO5tG8yHQ20wuTHmQ2IMZJyxdiRCVJkH29fnmye74OvmxP5zmTz02XaSLudb/H1zDEW89ctRAJ7r3ZB6PjVnRpeMwRFCVMi6gxd4/pu9FJkU7osM5v2H2tb85EZR1ETmXIx6S9wFKYfAdKUJv1E/6PwUNOwDDjW8LkKUo0OYL9893Y3HFuzk9MVc/vXJNpaO6UTjAE+LvefHG0+Qmm0g1M+NJ25rYLH3uRmy2WY5m3UJIdRl1yd9u59ik8L9kcG8PyQSbU0fc5OTCt+PhjN/Xv+cmx7y0oErH39+DaHTWIgcDi7e1RqmEFXtQmY+jy7YxcnUHHzcnPhqVEfaW2Aa+dc7z/LKDwcBWDAyij7NA6r8Pf6pMt/fkuBIgiNEmb7aGs+sK+vcPNCuHu891LbmJzdJsbDyUchKAgcnCGoLIZ2gfhTU7wTe9SEjHnZ9CXuXgSFTfZ2zB9w2GbpPAAeZQSlsV0ZuIY8vimFf4mVcnbTMf6R9la4uvmLXWV5erSY3Y3pE8Po9Lars2mWRBKcckuAIUT5FUXjntzjmbz4FwKhu4fz7nhY1f7bUvq9hzUQoNoB/Y3j4G9A3vnF5Qw4cWAm7PoeL6iJlhN8GD34OXrIis7BdeYVFPL1sD38cv4ijg4ZX7m7O493Db3k5h29jEs3rXz3eXf1cqK4lIiTBKYckOEKUzVhsYtrqg3wfew6AFwc05dleDWv2OjfFRlj/Guz8VH3c5C548LOKdzkpCuxbDr9MBWMuuPrCff8HzQZaLmYhLKywyMTU7/fz477zANzZMpB3HmqDl8vN7RH17e5EXlp1AEVR/+iZfm/1JTcgCU65JMER4sbyC4t57us9/H4sFQcNzHmwNUM7hlo7rLLlXYJvH7s23qbnS9Dz5ZsbOJx2ElaNhgv71cdRY2DAbHCqObNDhKgMRVFYsj2BN9cewVisEOrnxicj2tOqXuXGm323W225sVZyA5LglEsSHCFKdym3kCcWx7Dn7GV0jg78d3h7+rWw/MDBW1JkgMWDIHGHOobmgc+g+T23eM1C2DgTtv9XfVynOQxZDHWa3nq8QljJ/sTLPPf1Hs5l5OOsdeD1e1vwSOfQMpMUk0kh9mwGP+07z7KdCSgKPNY1jJmDWlqlRVcSnHJIgiPE9c6m5zFy4S7i03LxdnViwcgoosL9rB1W2RQF1oyHPUtA5w2j10FAy6q7/smN8MPTkJuqJk/3z4cWg6ru+kJUs8w8I1O+30/0kRQAosJ8aV3fm0Z1PWhUx4NGdT3wc3dmb+Jl1h64wC8HL3Ahs8D8+ke7hDHrPuskNyAJTrkkwRGipP2JlxmzOIa0nELq+biy6PGOFl07o8rs/BzWvQhoYMR30Lhf1b9HTip89zgkbFUf93gB7ni9Zs+yKi6CQ6vUNX8Kc6Ew59q9MR+C20Hrh6BeB6jJ46qERSiKwoKt8by97hhFputTABcnBwqMJvNjT50j/VoGMKhtMD2b1LHqWDxJcMohCY4Q12w8msK4r/eSbyymRZAXCx/vSICXi7XDKt/pLbD0AVCKod8b0H285d6r2AgbZlzrsmrQG/61ANz9LfeeN8NkgsOrYdNbcOlU+eV9I9REp/VDUKeJ5eMTNcrpiznsir/EydQcTl7M4WRqDkmX81EUcHfW0rdFAPe0Cea2xnpcnGpGQi8JTjkkwRFCtXxnAq//qG6Sd1tjPfMf6YCHzgYWOL8UD1/0hvwMaDNUHXdTHX9VHvwefnoejHngHQpDl0JwpOXftzyKAifWw8Y3IEVdmwQ3fzVxcfEBZ3f1prvSKndiPRxbq9bjqsA20PQuaNxfbeGpyS1UwmLyC4tJupxHfV+3GpPU/J0kOOWQBEcImLfhBHM3HAfgoQ71eevB1jjV9K0XAAzZ8GU/uHgUgtvD479U7wynlMOwYoS6UKCDE9w+BXpMAkfn6ovhKkMOnNwAOz6BxJ3qOZ0XdHseujxzLaG50Wvj1sHB7+DUxmvbVwC4+kGjPmqy06gvuNXwsVii1pAEpxyS4IjablNcKo8vjAFgYt/GTOjTuGavcXOVyQQrH4G4teARCE9uss5ifPmX4X/PwbGf1cd1W8Cgj9WVki0tJ1VNTI6thdOb1QUNARxd1H21uk+sfEKSmw5xv8DJaDi1+drKzgBaZ2j5IHR5Wm3ZEcKKJMEphyQ4oja7lFvIgA//4GK2gZFdw5h5Xytrh1RxB76F1WNBq1NbbqojobgRRVEH8q57CfLSAA10eRbueFXtDqpKxnz1vfYsvdJS87ePbd8IdWZX52fAK+jW36vYqG5MemI9HF8PqYevPRfaVU2imt0LWhvoyhR2RxKcckiCI2orRVF4amks64+k0KiuBz8/36NG9rOXqtgI/41Sdwe/43W1a6gmyLsEv06DAyvUxz5h0PsVdQXksrqIKuLyWYhZoE6Dz7907Xxwe2h2NzS7B+o0s+z4o3OxsHM+HP7hWjeWV3247QXoMFp2YRfVShKcckiCI2qrq3vIOGk1/PBs90qvZGpVuxfCzxPBvQ5M2F/1rSS36sQGNb7MRPWxo4s6bb3Vv6DxAHB2K/8aigJZ5yH5gLoJaNwvoFyZrusdCh1HQ+sh4F3PYtW4oawLsPsr9ZaXpp4L7Qb3/Rf8G1Z/PKJWkgSnHJLgiNooIT2Xu+f9SW5hMS/d2YxnetnQl5KxAD5ur+4Ofufb6gDamsiQDdv/T+1K+/s0bSd3ddCuVzA4uanJjpO7el+Ypw6YTj0GF+NKjn8BiOipdgs1ubNmzGwyFsCexbBhprpnl6ML9H4Vuj5XM+ITdk0SnHJIgiNqm6JiE0M+286es5fpFO7HN092QVvTdwX/u+2fwG/TwKsePL8HnGr4Oj2KorbCHFqtrktz+WzFX6vRqi0iET2h09iauz1ERgKsmQCnN6mP63VQNyet29y6cQm7JglOOSTBEbXNxxtP8H70cTx1jvwy4TZC/CrQXVJTGHJgXlu1W+Tej6DDSGtHVDmKAkmxEP+H2sJjzFNXFTbmqa03Wkd1HE2dZmpy4N8IHHXWjrpiru7A/usrasuTgxP0naG25tjCrDxhcyrz/V0tw+ANBgOdO3dm//797N27l8jISAD279/P22+/zdatW0lLSyM8PJynn36aCRMmlHm9Xr16sWXLlhLnhg4dyooVKyxVBSFs1oFzl/lw4wkAZt7X0raSG1AHuOalgV8DiBxu7WgqT6NRZ3tZc8aXpWg00O4RaNgHfn4Bjq+D9a9Cwja4/xNw9bF2hKIWq5bh71OnTiU4+Pq1KmJjY6lTpw7Lli3j8OHDvPrqq0ybNo3//ve/5V5z7NixXLhwwXz77LPPLBG6EDZvzi/HKDYpDGwdxAPtrDA49VbkZ8BfH6vHvV4BrZN14xGl8wqCh7+Bge+r6+bErYXPbofze60dmajFLN6Cs27dOtavX8+qVatYt25diedGjx5d4nGDBg3Yvn07q1evZty4cWVe183NjcDAwCqPVwh7cvBcJttPp+PooOG1e5rbxmJ+f7ftY7Xro24LdTaSqLk0Guj4hDoW59uRcDkBFvSHO+dA1BjpshLVzqItOCkpKYwdO5alS5fi5laxZvHMzEz8/MpfhXP58uXo9XpatmzJlClTyM7OvtVwhbA7X/x5GoB72wYT5F2N2xlUhZxU2DFfPe79qqy3YiuC28FTW6DpQCguhLWTYdUT6lgqIaqRxVpwFEVh1KhRPP3000RFRXHmzJlyX7N9+3a+/fZb1q5dW2a5ESNGEBERQWBgIIcOHWLatGns37+f6OjoUssbDAYMBoP5cVZWVqXqIoQtOpeRx9qDFwB44rYIK0dzE/78QB2IG9xeXTRP2A5XXxi2XG2B2zADDn2vziobskRmWYlqU+k/iWbMmIFGoynztnv3bj7++GOysrKYNm1aha57+PBh7rvvPv7973/Tr1+/MsuOHTuWvn370qpVK4YNG8b333/Phg0b2LNnT6nl58yZg7e3t/kWEhJS2WoLYXMW/nWGYpNCj0Z6Wgbb0IJ+oLbe7P5KPb7jNenesEUaDXQfD6PWgmcQpB2HL+6A/SutHZmoJSo9TTwtLY20tLQyy4SHhzNs2DDWrFlTos+/uLgYrVbLiBEjWLx4sfn8kSNH6N27N0888QSzZ8+uZBXU1iKdTsfSpUsZOnTodc+X1oITEhIi08SF3crMN9JtzkZyC4tZ9HhHejWta+2QKuf3N+GPd9XxHE9slATH1uVchNVPqJuDAnQYBXf+p+avZyRqHItOE9fr9ej1+nLLffTRR7z55pvmx+fPn2fAgAGsXLmSzp07m88fPnyYO+64g5EjR95UcnP1GkajkaCg0jea0+l06HQ2sq6EEFVgxa6z5BYW0zTAk55N6lg7nMopzIWYL9XjbuMlubEHHnXgkdWw5R3Y8h+IXQRJe2DIYnX6vxAWYLExOKGhoSUee3h4ANCwYUPq168PqIlJ79696d+/P5MmTSI5ORkArVZLnTrqh3JSUhJ9+vRhyZIldOrUiVOnTrF8+XLuvvtu9Ho9R44cYfLkybRr147u3btbqjpC2IzCIhML/zoDqGNvbG7m1N5l6vRw3whofq+1oxFVxUELvadBSCd1R/jkA/BZL3jgU3XjUCGqmFWnJXz33XdcvHiR5cuXExQUZL517NjRXMZoNBIXF0deXh4Azs7ObNy4kQEDBtC0aVPGjx9P//792bBhA1qt7IMixM8HzpOcVUAdTx2DIq9ff6pGKy5S93IC2dvIXjXqA0/9CfU7qUsArHhY3dequMjakQk7I1s1yBgcYUcUReGueX9yLDmbFwc05bnejawdUuUcWg3fPw5u/jDxUMV24Ba2qagQov+trlQNEHE7/OsrtTtLiBuozPe3LCwhhB3ZejKNY8nZuDlrGdE5tPwX1CSKAts+Uo87jpXkxt45OsNdb8Pgr9Sd1eP/gM9ug7M7rR2ZsBOS4AhhRz7/Q13Yb0hUCD5uzlaOppLObFWX9nd0UXfRFrVDq3/Bk5tA3wSyL8Ciu+Gvj8BksnZkwsZJgiOEnYhLzubPE2k4aGBMDxtc2O9q603kCHAvf6amsCN1msLY36Hlg2AqgujXYen9kHXe2pEJGyYJjhB24tvdiQD0axFgezuGpx6FE+sBjTq4WNQ+Ok+1u+qeD8HJDeK3wCdd4fCP1o5M2ChJcISwA0XFJv63T/1rd3AHG1ype9t/1fvm94B/Q+vGIqxHo4Gox9VZVkGRUHAZvhsJPz4LBtlvUFSOJDhC2IGtJ9NIyzHg6+Zkewv7ZV2AA1eW7+82wbqxiJpB3wjGREOPSYAG9i2HT3vAhQPWjkzYEElwhLADP+xNAmBQ22CcHW3s13rnfDAZIbQrhHQsv7yoHRydoe90dS8r7xDIOAML+qtLCQhRATb2SSiE+KccQxG/HVZXAX+gfX0rR1NJ2Smw6wv1uPtEq4Yiaqjw7vD0n9CwDxTlq+skbXxDZlmJckmCI4SN+/VQMgVGEw307rStb2O7hm/9AIx5UC8KmgywdjSipnL1hRHfQddx6uM/34OVI6Agy7pxiRpNEhwhbNwPe88B8EC7era179TlRNj9lXrc53XZVFOUzUELA2bD/Z+CVgdxv8CCfnDptLUjEzWUJDhC2LALmflsO5UOwP3t6lk5mkra8h8oLoTw26BBL2tHI2xF5MPw+DrwCISLx+CznrDjU9nLSlxHEhwhbNj/9p1HUaBTuJ9trX2TdhL2fa0e9/m3dWMRtqd+B3hy85UNO7Pg15fg856QsM3akYkaRBIcIWyUoij8sEedPfVAextrvdn8FijF0OROCOlk7WiELfIKgtG/wj1zwcUHUg7Bwrtg9VPq4HVR60mCI4SNOnIhi7iUbJwdHbi7dZC1w6m45ENwaJV63PtV68YibJuDFqJGw/N7oP1IQAMHVsB/o9TZeTLTqlaTBEcIG7X6SutN3+Z18XZ1snI0lbBptnrf8kEIamPdWIR9cPeHQR/BExshuJ3abfXLFHU/q8uJ1o5OWIkkOELYoL9vzfBAOxta+yYxRp39onGA3q9YOxphb+p3UJOcu94BR1d1P6v53dTxXopi7ehENZMERwgbZLNbM/z+hnofORz0ja0bi7BPDlro/BQ8vRXqd1Rbc358BlaMgJxUa0cnqpEkOELYIJvamsFkglO/w8pH1b+oHZyg50vWjkrYO30jePxXdZaegxPErYVPusBf8yDvkrWjE9XA0doBCCEqJ7vAyPrD6iyRGr01Q3YK7FsGsYvhcsK187dPAZ9Q68Ulag+tI9w2GRr3hx+eVmdaRf8bNs2BNkPUlp6AltaOUliIJDhC2JifD1wg31hMwzo1ZGuGwlx1I8RL8eqqshnxkH5SXZPEdGXxNZ23+oXSYSQEtrZquKIWCmwNYzepM6x2fg4pB2HPYvUWfhu0f0wdnOwboSZF4tblXIRiA3hb748w+UkKYWNWxqizQoZ2DKn+rRnyL8OF/XBhH5zfq94yzty4fEhn6DAKWtwPzja0EKGwP47OaiLT7lE1+d71GRz9Gc78qd5A3QKiThOo2wLqNlcTHs9A8AhQ751cb/79FQUM2ZCXDvmXwFQMaK5sUaIBDaB1Bt9w0Hneen2tpdgIMQtg01sQ2gVGfGu1UCTBEcKGxCVnsy/xMo4OGh60ZPeUokDWebVJP/mAunZN8kG4dKr08i4+4NcA/CLUe98IqB8FdZpaLkYhboZGo+5QHt4dMs+p+6Gd+h0uxqkbvyYfVG+l0XmDR11w1KkzATUO6qDmq8fwt9lainpszFeTmrx0MBkrFqNnsDoIv05T0DdRk62gSNB53GrtLev0Flj3Elw8qj7OvgAFmeBinZZmSXCEsCFXW2/6NK+L3kNXtRcvyFT/oj38AyTthvyM0sv5hKrN+VdvgW3Aza9qYxGiOnjXVwch9/m3Ohj+cgKkHoXUI+p9ZiJkJ0NOChQVgCFTvd0KR1f198XBEbiSDClX/mPMUxOh7PPqLX7LtddptBDQQt2eIqSTOkPMr0HN2KT28ln47VU4+pP62M1f/Tdt96iaAFqJJDhC2AhDUbF55/ChHUOq5qLGfDj+Gxz6Ho6vV/vMr9Jo1b8eA1tDYCsIaKUmNJLMCHvk4HClBTICmt1d8jlFUf8AyElRp5qbjGpCpJjULUdMxerx1e4muHbsqAN3vfql7+pXfldtfgaknYC04+rt4nG1Wzj7/LXWpd0L1LIeARDeQx1HFH4b+Des3oQnMwlivoAd89UEUKOFjk9A72ng6lt9cdyAJDhC2IgNR1LJyDMS4KXj9sa3uPaNsUBdkyZ2MRRmXzuvbwqtH4JGfdRxCE4ut/Y+QtgDjQZcfdSbpbtdXX3VFpp/7tGWmQTndqmLZZ6LUcfB5aSo255c3frEM1hNeJreCY0HWKZLS1FKjmFSitXz4bfBXf+pUbPSJMERwkas3K12Tw3uUB9H7S2sfZN2Ar5//No4A+8QaPWgmtgEtKoZTd5CiJK864H3A9DyAfWxsUDtSo6/Mkj6XIzaynPwW/Xm6AIN+0CL+9SE51bHwRiy4dBqdY+vlL+NUQrrAV2fhaZ317jPDklwhLABSZfz+fPERQCGRN1C99S+b2DtZDDmqk3m936kfjA51PDFAoUQJTm5XOme6gFMU7ubE3fBqY1wdI26ZEPcWvXm4AQNeqldb03uUndir4icVHVrlWNr4fRmKC5Uzzu6qss+dHpS7b6uoSTBEcIGfL/7HIoCXRv4E+bvXvkLGHLUzQf3f6M+Dr8NHvyi4h90QoiazckVGvRUb31nqjMgj/wER/4HaXFwMlq98QIEt1f/sGl6lzpQOS8NctPUAc65aZB1Dk5EqwkTf9vDy7+Rumt7u0dsYiyeJDhC1HAmk8K3u6+tfVNpF+NgxXB18T2NA/Sapq7uasXZDUIIC9JorkwOaA13vAqpx6605qxTu7LO71Fvm94s/1r1OkCzgdDsHnXSQQ3rhiqLJDhC1HB/nUoj6XI+ni6O3NkqsHIvzs+A5Q+p0189g2HwAgjrZplAhRA1U91m6u22yeoWKid+U5OdU5ugKF9dYNBND+7+V+7rqIOcmw0Er2BrR3/TJMERooa7uvbN/ZH1cHGqRKuLyQQ/PKMmNz6h6lL17noLRSmEsAmeAeqKzu0fgyKDOr1b52VTLTMVJQmOEDVYRm6heWPNSndP/TUXjq9Tl58fslSSGyFESY469WanZOqEEDXYj/uSKCw20SLIi1b1KjHN8/QW+P1K//rd70JwpEXiE0KImkoSHCFqKEVRWLHrJgYXZ52H70erK6tGjlCbooUQopaRBEeIGio2IYO4lGxcnBy4v129ir2o2AjfjVKnfQa0hrvfs8u+dSGEKE+1JDgGg4HIyEg0Gg379u0r8ZxGo7nu9umnn5Z7veeffx69Xo+7uzuDBg3i3LlzFqyBENVv2Y4EAAa1Dcbb1aliL4r+NyTuVAcNDllc/r43Qghhp6olwZk6dSrBwTeearZw4UIuXLhgvo0cObLM602cOJEffviBFStWsHXrVnJycrjnnnsoLi6u6tCFsIpLuYX8cjAZgBGdwyr2olO/w45P1OMHPlU33hNCiFrK4rOo1q1bx/r161m1ahXr1q0rtYyPjw+BgRVb3yMzM5MFCxawdOlS+vbtC8CyZcsICQlhw4YNDBgwoMpiF8Javo9NpLDYROt63rQN8Sn/BSYTRE9XjzuOVdevEEKIWsyiLTgpKSmMHTuWpUuX4uZ246bycePGodfr6dixI59++ikmk+mGZWNjYzEajfTv3998Ljg4mFatWrFt27ZSX2MwGMjKyipxE6KmMpkUlu88C8CIzqEVe9HR/0HyAXD2gF4vWzA6IYSwDRZLcBRFYdSoUTz99NNERUXdsNwbb7zBd999x4YNGxg2bBiTJ0/mrbfeumH55ORknJ2d8fX1LXE+ICCA5OTkUl8zZ84cvL29zbeQkFvYrFAIC/vrVBoJ6Xl46hwZFFmBVUSLi+D32epx13Gy3o0QQnATXVQzZsxg5syZZZaJiYlh27ZtZGVlMW3atDLLvvbaa+bjyMhIAGbNmlXifEUoioLmBrNFpk2bxqRJk8yPs7KyJMkRNdbyHWrrzYPt6+HmXIFf0f1fQ/oJcPWDrs9ZODohhLANlU5wxo0bx7Bhw8osEx4ezptvvsmOHTvQ6UqukhgVFcWIESNYvHhxqa/t0qULWVlZpKSkEBAQcN3zgYGBFBYWkpGRUaIVJzU1lW7dSt9jR6fTXReHEDVRcmYB0UfVlYtHdKnA4GJjAWz+j3p822Rw8bJgdEIIYTsqneDo9Xr0+vKbwD/66CPefPPaTqXnz59nwIABrFy5ks6dO9/wdXv37sXFxQUfH59Sn+/QoQNOTk5ER0czZMgQAC5cuMChQ4d45513KlcZIWqYlTGJFJsUOoX70STAs/wX7P4Kss6pG2l2HGP5AIUQwkZYbBZVaGjJwZEeHh4ANGzYkPr16wOwZs0akpOT6dq1K66urmzatIlXX32VJ5980tzikpSURJ8+fViyZAmdOnXC29ubMWPGMHnyZPz9/fHz82PKlCm0bt3aPKtKCFtUVGzim11XBhd3qcDgYkM2/PmeetzrJXBytWB0QghhW6y62aaTkxOffPIJkyZNwmQy0aBBA2bNmsVzz10bR2A0GomLiyMvL898bu7cuTg6OjJkyBDy8/Pp06cPixYtQqutxE7LQtQwvx9LJTmrAD93Z+5sVYFlE3bMh7x08GsIkY9YPkAhhLAhGkVRFGsHUd2ysrLw9vYmMzMTLy8ZsyBqhpFf7WLL8Ys81bMB0+5qXnbhvEswry0YsmDwV9DqX9UTpBBCWFFlvr9lLyohaoCz6Xn8ceIiAMM7VaB7autcNbkJbA0tHrBwdEIIYXskwRGiBlh36AKKArc11hPm71524cJc2PWFenzHv8FBfo2FEOKf5JNRiBrg1MUcADqE+ZZTEnUzzaJ88A6Bxv0sHJkQQtgmSXCEqAHOpKmD6CP05bTeAJz5S70P6w43WNxSCCFqO0lwhKgBTqflAhVMcBKuJDjh3S0YkRBC2DZJcISwsuwCI2k5BgDCy0twjPmQFKseh0mCI4QQNyIJjhBWlpCudk/pPZzxcnEqu/C5GCguBM8g8GtQDdEJIYRtkgRHCCu72j0VXt7sKZDxN0IIUUGS4AhhZWeuJjgy/kYIIaqMJDhCWNmZig4wLjKoXVQAYT0sHJUQQtg2SXCEsLIKz6BKioWiAnCvC/rG1RCZEELYLklwhLCyM+kVHINjHn/TTcbfCCFEOSTBEcKKMnILuZxnBCBc71Z24YSt6n24dE8JIUR5JMERworir7TeBHq54ObseOOCxUZI3KUey/o3QghRLklwhLCiCg8wPr8XjHng6gd1mlVDZEIIYdskwRHCiio8RfzMle6psG6ye7gQQlSAfFIKYUXXZlCVN/7m6vo3Mv5GCCEqQhIcIazo6gyqCL3HjQsVF8HZHeqxjL8RQogKkQRHCCtRFIUzaeo+VGW24CTvh8IccPGGgJbVFJ0QQtg2SXCEsJKLOQZyDEU4aCDEr4wE5+r6N6HdwEFbPcEJIYSNkwRHCCu52npTz9cVnWMZiYvsPyWEEJUmCY4QVhKflgOUs4KxqRgStqvHYd2qISohhLAPkuAIYSXx5vE3ZSQ4KYfAkAnOnhDYtpoiE0II2ycJjhBWUqFF/szjbzqDtoyVjoUQQpQgCY4QVhJfkUX+ro6/kenhQghRKZLgCGEFJpNybQ2cssbgpBxS7+tHVUNUQghhPyTBEcIKkrMKMBSZcHTQUN/XtfRCxnzISFCP9U2rLzghhLADkuAIYQVXu6dC/dxw1N7g1zD9JKCoC/x51K2+4IQQwg5IgiOEFcRXZIBx2nH1Xt8UNJpqiEoIIeyHJDhCWEGFdhG/eCXBqdOkGiISQgj7IgmOEFZQoRlUaXHqvV4SHCGEqCxJcISwgvgrM6gaVKQFRwYYCyFEpUmCI0Q1Kyo2kXhJXcX4hi04puIrg4yRLiohhLgJkuAIUc2SLudjLFbQOToQ5OVSeqGMM1BsAK0OfMKqNT4hhLAH1ZLgGAwGIiMj0Wg07Nu3z3x+0aJFaDSaUm+pqak3vF6vXr2uKz9s2LBqqIkQt848/sbfHQeHG8yOMs+gagwOZew0LoQQolTVsrnN1KlTCQ4OZv/+/SXODx06lDvvvLPEuVGjRlFQUEDdumWv+zF27FhmzZplfuzqeoPF0oSoYa7NoHK7caGLMsBYCCFuhcUTnHXr1rF+/XpWrVrFunXrSjzn6upaIjG5ePEiv//+OwsWLCj3um5ubgQGBlZ5vEJYWsVmUF2dIi4DjIUQ4mZYtIsqJSWFsWPHsnTpUtzcyvhr9YolS5bg5ubG4MGDyy27fPly9Ho9LVu2ZMqUKWRnZ1dFyEJYXHy6OsC4zBlU5i4qacERQoibYbEWHEVRGDVqFE8//TRRUVGcOXOm3Nd89dVXDB8+vNzuphEjRhAREUFgYCCHDh1i2rRp7N+/n+jo6FLLGwwGDAaD+XFWVlal6iJEVYpPywHUMTilUpS/LfInLThCCHEzKp3gzJgxg5kzZ5ZZJiYmhm3btpGVlcW0adMqdN3t27dz5MgRlixZUm7ZsWPHmo9btWpF48aNiYqKYs+ePbRv3/668nPmzCk3ZiGqQ2GRiaSMfKCMbRpyUsCQCRoH8G9UjdEJIYT90CiKolTmBWlpaaSlpZVZJjw8nGHDhrFmzRo0f9tDp7i4GK1Wy4gRI1i8eHGJ14wZM4Y9e/awd+/eyoQDqK1FOp2OpUuXMnTo0OueL60FJyQkhMzMTLy8vCr9fkLcrJOpOfT9YAvuzloOzRxQ4vfD7PQWWDII/BrA+Mr/PgghhL3KysrC29u7Qt/flW7B0ev16PX6cst99NFHvPnmm+bH58+fZ8CAAaxcuZLOnTuXKJuTk8O3337LnDlzKhsOAIcPH8ZoNBIUFFTq8zqdDp1Od1PXFqIqXV3gL9TfvfTkBkpusimEEOKmWGwMTmhoaInHHh4eADRs2JD69euXeG7lypUUFRUxYsSI666TlJREnz59WLJkCZ06deLUqVMsX76cu+++G71ez5EjR5g8eTLt2rWje/fulqqOEFUi4coWDaF+ZYwzuzpFXFYwFkKIm1Yt6+CUZ8GCBTz44IP4+vpe95zRaCQuLo68PPUvX2dnZzZu3Mi8efPIyckhJCSEgQMHMn36dLRaWRBN1GxnL6njb8JuNMAYZJNNIYSoAtWW4ISHh3Oj4T7btm2r8OtCQkLYsmVLlccnRHU4e6WLKsSvrEX+pItKCCFulexFJUQ1Mo/BuVGCU5AJOcnqsXRRCSHETasRXVRC1CQXMvP5dPMpdE5aXr6z2Y33i6okRVHMLTg3THCutt54BIKLd5W8rxBC1EaS4AhxRXaBkc+2nOaLP09jKDIB0KWBH3c0C6iS61/MMZBvLMZBA/V8bjDI2LxFg7TeCCHErZAER9R6xmITK2IS+TD6OOm5hQD4uTtzKbeQL/+Mr7IE52r3VJC3K86ON+gdNg8wlvE3QghxKyTBEbWWoij8djiFd387xqmL6vTtBnp3Xr6rGS3reXP7O5vYdiqdw+czaRl8691F5XZPgWzRIIQQVUQSHFHrKIrCprhUPog+zqEkdV8yP3dnJvZtzMOdQnHSqq0rd7cOYs3+8yz4M54Phkbe8vueTVeniJeZ4MgUcSGEqBKS4IhaQ1EU/jqZzvvRcew9exkAd2cto3tEMPb2Bni5OJUoP6ZHBGv2n+en/eeZemczAr1dbun9Ey5dWeTP/wYJjrEAMs6ox9KCI4QQt0QSHGGXsguMnMvIv3LL41xGPvsSLxObkAGAi5MDI7uF89TtDfFzdy71GpEhPnQM9yXmTAZLtp9h6p3NbimmcqeIXzoFigl03uBRNeN+hBCitpIER9iV1OwCxizazcGkzFKfd9Y6MKJLKM/0akhdz/JbZJ64rQExZ2JZvvMs4+5ohJvzzf/KlD9F/G9bNNxonyohhBAVIgmOsBu5hiJGL4oxj6vxdXOivq8b9X1dqe/rSoifG/1aBBDkXcY+UP/Qt3kAYf5uJKTnsSr2HI92Db+p2AqMxaRkqTva3zDBkU02hRCiykiCI+xCUbGJ57/Zy6GkLPzcnfnu6a40rONxy9fVOmgY3T2C6T8dZsHWeIZ3DkN7Ewv/Xe2e8tQ54uPmVHoh2WRTCCGqjGzVIGyeoij8+6fD/H4sFRcnB74cGVUlyc1VgzvUx8vFkTPpeWw8mnJT1zB3T/m7oblR95O04AghRJWRBEfYvPlbTvH1zrNoNDBvWDvah16/K/2tcNc5MqJLGABfbo2/qWuUO/7GVAzpJ9VjfeObeg8hhBDXSIIjbNr/9iXxzq9q1870e1owoGWgRd5nZNdwHB007Iq/xIFzlyv9+nITnMtnoagAtDrwDb/5QIUQQgCS4AgbtuN0Oi9+dwCAJ3pEMKp7hMXeK9DbhXvbBgPw1U204pxNVxOckPIGGPs3AgftTcUohBDiGklwhE1KzS7gueV7KCw2cXfrQF65u7nF3/ORLqEAbD5+EZNJqdRrKzVFXAghxC2TBEfYHEVRePG7A6TnFtIs0JMPhkTicBMzmyqrTX0f3Jy1XM4zciI1p8KvUxTFnOCE3WgV49Qj6n3dFrcaphBCCCTBETZo8bYzbDl+EZ2jAx893A4Xp+rp0nHSOtAhTB3AvCs+vcKvu5htwFBkwkEDwT43WIMn5bB6LwmOEEJUCUlwhE05lpzFW+uOAfDqwOY0CfCs1vfvFO4HwM74SxV+TcKV1ptgH1fzRp4lFBdd66IKkARHCCGqgiQ4wmYUGIuZ8M0+CotM9G5ah0evTN2uTh0j1ARnV/wlFKVi43CuDjC+8R5Up6HYAE5u4BNeFWEKIUStJwmOsBn/+fUYcSnZ6D2ceWdw2xsvmGdBkSE+OGsdSM02kHAlcSlPhcff1GkGDvIrKYQQVUE+TYVN2ByXysK/zgDw7uC21PHUWSUOFyctbUO8Adh1pmLdVFe3abjhFPGrCY50TwkhRJWRBEfUeImX8phyZb2bUd3C6d2srlXj6fS3bqqKSChvirh5gHHLW45NCCGEShIcUSMpikLMmUs8t3wPvd7bTFqOgSYBHrx8VzNrh0anCH+g4glOuWvgSAuOEEJUOdlNXFSJxEt5zI0+TnpuIVoHjXrTqPceOkf+1aG+ueWjLAXGYtbsP8+ibWc4fD7LfL5rA3/eerB1tU0JL0uHMF8cNGriciEznyDvG0z9BvILi7mYbQBukOAU5sKlKysjyxRxIYSoMpLgiFt25HwWIxfuMn+Rl2bl7kSiwnx5pldD7mhWt8QAYZNJYc/ZDP637zw/HzhPRp4RAJ2jAw+2r8fIbuE0C/SyeD0qykPnSMtgbw4mZbIr/hL3Rda7YdnEDLX1xsvFER835+sLXIwDFHDTg4d1u96EEMKeSIIjbsm2U2k8tSSWbEMRzQI9GdMjAkWBIpNCsaJgMikcS85iVWwSuxMyGLN4N80CPXm6Z0OaBHiy5sB5ftp3nqTL+eZrBnu78GjXcIZ1DMHXvZSkoAboFOFXoQTHPEW8vBlU0j0lhBBVShIccdN+PnCeSSv3U1hsonOEH58/FoW3q1OpZV/o24QFW+NZtiOBY8nZTFy5r8TzHjpHBrQM5L7IYLo19MextAXxapBOEX4s2Bpf7jic8gcYX92iQQYYCyFEVZIER9yURX/FM/PnIygK3NUqkLlDI8scH1PXy4Vpdzfn2V6NWLrjDAv/OkN2QRG9mtbh/nb1uKNZ3RoxvqaiOl5Z0fhEag6Xcgvxu0FLU/lTxK/MoJIWHCGEqFKS4IhKURSF99cf57+bTgLwaJcwZgxqibaCm116uzkx7o7GPNOrEUUmEzpH20lq/s7P3ZkmAR4cT8kh5swlBrQMLLWceZE/P/fSL5Qim2wKIYQl1Ox+AFHjLN52xpzcTOnfhFn3VTy5+Tutg8Zmk5urKrIeTplTxHPTIDdVPa5j/envQghhTyTBERW2OS6VWT+rLQ4v39WMcXc0tsp2CTVFeevhmExK2QnO1QHGvuGg87BEiEIIUWtJgiMq5ERKNs9/vReTAg91qM9TtzewdkhWd3Vn8cPnM8kuMF73fGq2gcIiE1oHDUE+LtdfQAYYCyGExUiCI8p1KbeQ0YtjyDYU0Sncj9kPtK7VLTdXBXq7EOrnhkmB2ISM656/2noT7OOCU2mzwmSAsRBCWIwkOKJMhqJinl4aS+KlfEL8XPn00Q44O8r/NleVNQ6n4gOMm1skNiGEqM0s+k0VHh6ORqMpcXv55ZdLlDl79iz33nsv7u7u6PV6xo8fT2FhYZnXNRgMPP/88+j1etzd3Rk0aBDnzp2zZFVqJUVReO2HQ+w6cwlPnSNfjex4w+nQtVWZCU56LnCDKeImE1w8ph5LF5UQQlQ5i08TnzVrFmPHjjU/9vC4NpiyuLiYgQMHUqdOHbZu3Up6ejojR45EURQ+/vjjG15z4sSJrFmzhhUrVuDv78/kyZO55557iI2NRau17Zk5NclXf53hu9hzOGjg4+HtaBzgae2QapzOVxKc/ecuU2AsLrGWT5kDjDPPQmEOaJ3Bv2G1xCqEELWJxRMcT09PAgNLXyNk/fr1HDlyhMTERIKDgwF4//33GTVqFLNnz8bL6/r9hzIzM1mwYAFLly6lb9++ACxbtoyQkBA2bNjAgAEDLFeZWiTXUMSHG44D8NrAFvRqKvsklSbUz40ALx0pWQbe+y0ODxdHsguKyMo3svVkmrnMda52T+mbgrb01Z+FEELcPIsPpvjPf/6Dv78/kZGRzJ49u0T30/bt22nVqpU5uQEYMGAABoOB2NjYUq8XGxuL0Wikf//+5nPBwcG0atWKbdu2lfoag8FAVlZWiZso26o958guKCJC786obuHWDqfG0mg05uniX26N58MNJ1iwNZ7vYs+RlqP+v948qJSWLxlgLIQQFmXRFpwJEybQvn17fH192bVrF9OmTSM+Pp4vv/wSgOTkZAICAkq8xtfXF2dnZ5KTk0u9ZnJyMs7Ozvj6+pY4HxAQcMPXzJkzh5kzZ1ZBjWoHk0lh4V9nAHi8ezgON7GQX20yrncjik0mtA4OeLo44uXipN67OtE0wJMGdUpZ40ZWMBZCCIuqdIIzY8aMcpOFmJgYoqKieOGFF8zn2rRpg6+vL4MHDza36gClTjdWFKXS05DLes20adOYNGmS+XFWVhYhISGVun5tsikulfi0XDxdHPlX+/rWDqfGaxroyScjOlTuRalH1XtJcIQQwiIqneCMGzeOYcOGlVkmPDy81PNdunQB4OTJk/j7+xMYGMjOnTtLlMnIyMBoNF7XsnNVYGAghYWFZGRklGjFSU1NpVu3bqW+RqfTodPpyoxZXPPVX/EAPNwpFHedbFdW5YoKIf2EeixdVEIIYRGV/vbS6/Xo9fqberO9e/cCEBQUBEDXrl2ZPXs2Fy5cMJ9bv349Op2ODh1K/4u4Q4cOODk5ER0dzZAhQwC4cOEChw4d4p133rmpuMQ1x5Kz+OtkOg4aeKxrmLXDsU9px8FUBDpv8Kpn7WiEEMIuWWyQ8fbt25k7dy779u0jPj6eb7/9lqeeeopBgwYRGhoKQP/+/WnRogWPPvooe/fuZePGjUyZMoWxY8eaZ1AlJSXRrFkzdu3aBYC3tzdjxoxh8uTJbNy4kb179/LII4/QunVr86wqcfO+2qq23tzVKoj6vqXM/hG37uoeVAEtQFaEFkIIi7BY/4NOp2PlypXMnDkTg8FAWFgYY8eOZerUqeYyWq2WtWvX8uyzz9K9e3dcXV0ZPnw47733nrmM0WgkLi6OvLw887m5c+fi6OjIkCFDyM/Pp0+fPixatEjWwLlFaTkGftx3HoDRPcKtG4w9S7kyg0rG3wghhMVoFEVRrB1EdcvKysLb25vMzMxS19qprT7aeIIPoo/Ttr43Pz7XXfabspTlQ+DEb3D3e9BpbPnlhRBCAJX7/pZNhQSg7jm1ZHsCAKN7REhyY0nmLirZokEIISxFEhwBwM/7L5CWYyDAS8fdrYOsHY79KsiEzET1WDbZFEIIi5EER6Aoinlq+GNdw3HSyv8WFnPmL/XeJxRcfcsuK4QQ4qbJN5lgZ/wlDp/PwsXJgeGdQq0djn078j/1vulA68YhhBB2ThIcwZd/qq03D7Srj6+7s5WjsWNFhRC3Tj1ucZ91YxFCCDsnCU4td/piDhuPpQAwpkeElaOxc/FbwJAJHgEQ0tna0QghhF2TBKeW++qveBQF+jSrS6O6pWwKKarO1e6p5veCg/zqCSGEJcmnbC2WkVvI97HnABhzm7TeWFRxERxbqx43H2TdWIQQohaQBKcWW74zgQKjiZbBXnRt4G/tcOxbwlbIvwRu/hDW3drRCCGE3ZMEp5YyFBWz+MrCfk/cJgv7WdzV7qlmA0ErO7QLIYSlSYJTS/207zwXsw0EerkwsHWwtcOxb6ZiOPqzeiyzp4QQolpIglMLKYrCgiu7ho/sFo6zo/xvYFFnd0BuKrh4Q/jt1o5GCCFqBflmq4W2nkzjWHI2bs5aWdivOhz9Sb1vOhAcZZ0hIYSoDpLg1EJXF/YbEhWCt5uTlaOxcyYTHLmS4LSQ2VNCCFFdJMGpZY6nZLPl+EUcNDC6u0wNt7ikWMg+D86e0KC3taMRQohaQxKcWmbBldabAS0DCfV3s3I0tcCRH9X7JgPAycWqoQghRG0iCU4tci4jjx/2JQHq1HBhYYpybfyNzJ4SQohqJQlOLVFsUpi0cj+FRSY6RfjRIczP2iHZvwv74PJZcHKDRn2tHY0QQtQqkuDUEp9uOcWuM5dwd9by3uC21g6ndri6uF+jvuAs3YFCCFGdZEnVWmB/4mXmRh8HYOZ9rWTsjSXlX1bH3exfAWe3q+eke0oIIaqdJDh2LtdQxMSV+ygyKQxsE8S/2tezdki2LSMBMs+BRgNort3npsLB7yDuVyg2XCmsgZYPqLuHCyGEqFaS4FQhRVHILSzGQ1dz/lnf+PkI8Wm5BHm78Nb9rWXPqVtx4Fv44SlQTGWXq9sC2g6D1g+Bl2yDIYQQ1lBzvontwKXcQjq8uQG9hzNh/u6E+bsRfuW+gd6DlsFeODhUX4Lx66ELrIhJRKOBD4ZEyqJ+tyIxBv43Tk1uvEPVFYkVkzpTCgW0ztCon5rYBLa+0rIjhBDCWiTBqUJnL+UBkJZTSFpOIbEJGSWe7xTux7yHIwnydrV4LMmZBby8+iAAT93ekK4N/S3+nnbrciKsGK52PTUdCEOXgYOMzxdCiJpMoyiKYu0gqltWVhbe3t5kZmbi5eVVtdcuMHI2PY8z6bkkpOdxJk29P5iUSb6xGF83J957qC19mgdU6fv+ncmk8NhXu9h6Mo1W9bxY/Ux32VDzZhXmwlcDIPkgBLSC0b+BzsPaUQkhRK1Ume9vacGpYl4uTrSq502ret4lzp9Jy+X5b/ZyMCmTMYt380SPCKbe2cwiicfSHQlsPZmGi5MDHw5tJ8nNzTKZ1DE3yQfBvQ48/I0kN0IIYSPkm6+ahOvd+f6Zrub9n77cGs9Dn27jbHpelb7P6Ys5zFl3FIBpdzWnUV35Qr5pm9+Co2vU8TVDl4OP7LwuhBC2QhKcaqRz1PLve1vwxWNReLs6sf9cJgM/+pPdZy5VyfWLik1M+nY/BUYTPRrpebRLWJVct1Y6+D388a56fO9HENrZuvEIIYSoFElwrKBfiwDWTbiNDmG+ZBuKeHxRDIfPZ97ydT/dcop9iZfxdHHkncFtqnXGll1JO6HOmALoPgEiH7ZuPEIIISpNEhwrCfZxZdmYznQM9yW7oIiRX+0iPi33pq93KCmTDzecAGDmoJYE+1h+ppZdKjbC6iehKB8a9II+060dkRBCiJsgCY4VuTpr+XJkR1oEeZGWU8gjX+7kQmZ+pa9TYCxm8rf7KTIp3NkykAfayWrFN+2P9+D8HnDxgfvng4PW2hEJIYS4CZLgWJm3qxNLxnSigd6dpMv5PPLlTi7lFlbqGnOjjxOXko3ew5nZD7SS1Ypv1rnYa+NuBr4vqxALIYQNkwSnBtB76FgyphNB3i6cupjLqIW7yC4wlvkaRVE4lpzFJ5tP8vmfpwF464HW+HvoqiNk+1OYC6vHglIMrQZD68HWjkgIIcQtkHVwaoj6vm4sHdOZIZ9t58C5TO75eCut6nlT38eVer6u1PNxpa6nC0eTs/jrZBp/nUwnLcdgfv3gDvXp3zLQijWwcdH/hkunwDMYBr5n7WiEEELcIosmOOHh4SQkJJQ499JLL/H2228DsH//ft5++222bt1KWloa4eHhPP3000yYMKHM6/bq1YstW7aUODd06FBWrFhRtRWoZo3qerD48U4M/2IHCel5JJSzRo6LkwOdIvzp2aQOj3SRNVpu2okNEPOlenz//4Grr3XjEUIIccss3oIza9Ysxo4da37s4XFt4bnY2Fjq1KnDsmXLCAkJYdu2bTz55JNotVrGjRtX5nXHjh3LrFmzzI9dXe1j1lDr+t78PqUXsQmXOJeRT9LlfJIy8jmXkU9KVgGh/m70aKSneyM97UJ90DnKINhbkncJ/vecetz5aWh4h3XjEUIIUSUsnuB4enoSGFh618no0aNLPG7QoAHbt29n9erV5SY4bm5uN7yuravjqePOVkHWDsP+5abDyhGQkwz6JtB3hrUjEkIIUUUsPsj4P//5D/7+/kRGRjJ79mwKC8ueIZSZmYmfn1+5112+fDl6vZ6WLVsyZcoUsrOzqypkURukHoUvesPZ7eDsCQ9+AU720QoohBDCwi04EyZMoH379vj6+rJr1y6mTZtGfHw8X375Zanlt2/fzrfffsvatWvLvO6IESOIiIggMDCQQ4cOMW3aNPbv3090dHSp5Q0GAwbDtQG5WVlZN18pYftORMN3j0NhNviEwfCVULe5taMSQghRhTSKoiiVecGMGTOYOXNmmWViYmKIioq67vyqVasYPHgwaWlp+Pv7l3ju8OHD9O7dm/Hjx/Paa69VJiRiY2OJiooiNjaW9u3bVzjmimy3LuyIosCOT2D9a6CYIKw7DFkK7v7lv1YIIYTVZWVl4e3tXaHv70onOGlpaaSlpZVZJjw8HBcXl+vOJyUlUb9+fXbs2EHnztc2Lzxy5Ai9e/fmiSeeYPbs2ZUJB1DXhNHpdCxdupShQ4de93xpLTghISGS4NQmxUZYOwn2LFEft3sUBn4Ajs7WjUsIIUSFVSbBqXQXlV6vR6/X31Rge/fuBSAo6NoA2sOHD3PHHXcwcuTIm0purl7DaDSWuO7f6XQ6dDpZAK/WMpngh6fh0PegcYD+b0KXZ0FWfBZCCLtlsTE427dvZ8eOHfTu3Rtvb29iYmJ44YUXGDRoEKGh6potV7ul+vfvz6RJk0hOTgZAq9VSp04dQG316dOnD0uWLKFTp06cOnWK5cuXc/fdd6PX6zly5AiTJ0+mXbt2dO/e3VLVEbZKUeC3V9TkxsERhiyBZgOtHZUQQggLs1iCo9PpWLlyJTNnzsRgMBAWFsbYsWOZOnWqucx3333HxYsXWb58OcuXLzefDwsL48yZMwAYjUbi4uLIy1MXvXN2dmbjxo3MmzePnJwcQkJCGDhwINOnT0erlTVhxD9snQs756vH98+X5EYIIWqJSo/BsQeV6cMTNmzPUvjpynpKA96Crs9ZNx4hhBC3pDLf37LZprBPx36BNePV4+4TJbkRQohaRhIcYX8StsH3j6tTwSMfkRWKhRCiFpIER9iXjAT4ZhgUFUCTu+DeeTJbSgghaiFJcIT9KDbCqjFQkAn1omDwV6C1+HZrQgghaiBJcIT92DwHzsWAzltNbpzdrB2REEIIK5EER9iH01vgzw/U40HzwDfMuvEIIYSwKklwhO3LTYPVTwIKtB8JLR+wdkRCCCGsTBIcYdsUBX58FnKSQd8U7nzb2hEJIYSoASTBEbZtx3w48RtodfDQQhl3I4QQApAER9iy8/sg+t/q8YDZENDSquEIIYSoOSTBEbYp+SB8PRRMRmh2D3R8wtoRCSGEqEFkkRBhe05tgpWPQmE21GkOgz6WxfyEEEKUIC04wrbsXwnLB6vJTVgPGP0ruPlZOyohhBA1jLTgCNugKLB1LmycqT5u+SA88Ck46qwblxBCiBpJEhxR8xUb4deXIeZL9XHXcdDvDXCQBkghhBClkwRHWJaiQH4GuPpWbpyMosC53XBgJRxaBfmXAA3cOQe6PGOxcIUQQtgHSXCEZaSfUpOTAysh44y6P1Td5uotoKV671UPFJOazCgm9VaUD8d/U1936fS167nXhbvfhZb3W6tGQgghbIgkOKLq5F1SW1sOrFQ3vfw7QyYk7lBvFeXkpk4BbzsUInrJzuBCCCEqTL4xxK1TFNj1BUS/DkUF6jmNAzToDW2HQeN+kHUeUo9CymH1PvUw5KaDg1btutI4XLlpIbA1tBkKzQaCzsO6dRNCCGGTJMERt6YgE34aD0d+VB8HtFaTmtaDwTPwWjlXX7VrqvVgq4QphBCidpEER9y8Cwfgu5HqWBkHR3VmU5dnZNE9IYQQVicJjqg8RYHYhbDuZSg2gHcIDF4IIR2tHZkQQggBSIIjKstkgp/Gwb7l6uMmd8L982U1YSGEEDWKJDiicnZ9piY3Gi30+Td0Gy8L7gkhhKhxJMERFZd6DKKnq8d3/Qc6jbVuPEIIIcQNyJ/eomKKCmH1E+qYm0b9oOMT1o5ICCGEuCFJcETFbH4Lkg+Cqx/c91+ZKSWEEKJGkwRHlC9hO2z9UD2+d17J9W2EEEKIGkgSHFG2giz44UlAgcgR0GKQtSMSQgghyiUJjijbry/D5bPgEwp3vm3taIQQQogKkQRH3NiRn66sd6OBBz4HFy9rRySEEEJUiCQ4onTFRvjtFfW4x0QI62rVcIQQQojKkARHlO7At5CZCO51oefL1o5GCCGEqBRJcMT1TMWwda563G0cOLlYNx4hhBCikiTBEdc79jOknwAXb4gabe1ohBBCiEqzaIITHh6ORqMpcXv55ZLdHf98XqPR8Omnn5Z5XYPBwPPPP49er8fd3Z1BgwZx7tw5S1al9lAU+PN99bjTU6DztG48QgghxE2w+F5Us2bNYuzYa3sWeXh4XFdm4cKF3HnnnebH3t7eZV5z4sSJrFmzhhUrVuDv78/kyZO55557iI2NRavVVl3wtdGpjXBhPzi5QeenrR2NEEIIcVMsnuB4enoSGFj2yrc+Pj7llrkqMzOTBQsWsHTpUvr27QvAsmXLCAkJYcOGDQwYMOCWY67V/rwy9qbD4+Dub91YhBBCiJtk8TE4//nPf/D39ycyMpLZs2dTWFh4XZlx48ah1+vp2LEjn376KSaT6YbXi42NxWg00r9/f/O54OBgWrVqxbZt20p9jcFgICsrq8RNlOLsDkjYCg5O6uBiIYQQwkZZtAVnwoQJtG/fHl9fX3bt2sW0adOIj4/nyy+/NJd544036NOnD66urmzcuJHJkyeTlpbGa6+9Vuo1k5OTcXZ2xtfXt8T5gIAAkpOTS33NnDlzmDlzZtVVzF79+YF6H/kweAVbNxYhhBDiFmgURVEq84IZM2aUmyzExMQQFRV13flVq1YxePBg0tLS8Pcvvfvj/fffZ9asWWRmZpb6/Ndff83jjz+OwWAocb5fv340bNiw1AHKBoOhRPmsrCxCQkLIzMzEy0tW5wXUncI/7QEaBxi3G/wbWjsiIYQQooSsrCy8vb0r9P1d6RaccePGMWzYsDLLhIeHl3q+S5cuAJw8efKGCU6XLl3IysoiJSWFgICA654PDAyksLCQjIyMEq04qampdOvWrdRr6nQ6dDpdmTHXelfXvWn5gCQ3QgghbF6lExy9Xo9er7+pN9u7dy8AQUFBZZZxcXHBx8en1Oc7dOiAk5MT0dHRDBkyBIALFy5w6NAh3nnnnZuKq9ZLPwWHf1CPe0yybixCCCFEFbDYGJzt27ezY8cOevfujbe3NzExMbzwwgsMGjSI0NBQANasWUNycjJdu3bF1dWVTZs28eqrr/Lkk0+aW1ySkpLo06cPS5YsoVOnTnh7ezNmzBgmT56Mv78/fn5+TJkyhdatW5tnVYlK2vkZKCZoPAACW1k7GiGEEOKWWSzB0el0rFy5kpkzZ2IwGAgLC2Ps2LFMnTrVXMbJyYlPPvmESZMmYTKZaNCgAbNmzeK5554zlzEajcTFxZGXl2c+N3fuXBwdHRkyZAj5+fn06dOHRYsWyRo4N8NYAAdWqsednrRuLEIIIUQVqfQgY3tQmUFKdu/g97BqDHjVh4kHwEGSRCGEEDVTZb6/ZS+q2m7vMvU+crgkN0IIIeyGJDi12eWzcHqzetxuhFVDEUIIIaqSJDi12d7lgAIRPcE33NrRCCGEEFVGEpzaylQM+5arx+0fs24sQgghRBWTBKe2Or0ZMhPBxQea3WPtaIQQQogqJQlObbV3qXrfZgg4uVg3FiGEEKKKSYJTG+VdgmNr1eN2j1o3FiGEEMICJMGpjQ6shOJCCGoLQW2sHY0QQghR5STBqW0UBfZc6Z6S1hshhBB2ShKc2ub8Hkg9DI4u0Poha0cjhBBCWIQkOLXN1dab5oPA1ceqoQghhBCWIglObVKYC4dWqcftpXtKCCGE/ZIEpzbZ/gkYssA3AsJ6WDsaIYQQwmIkwaktslNg61z1uPer4CA/eiGEEPZLvuVqi81vgTEXgttDq39ZOxohhBDCoiTBqQ1SjsCeJerxgLek9UYIIYTdk2+62iD6dVBM0PxeCOtq7WiEEEIIi5MEx96d3AgnN4CDE/Sdae1ohBBCiGohCY49MxXD+tfV405jwb+hdeMRQgghqokkOPZs7zJ11WIXH7j9RWtHI4QQQlQbSXDslSEHNs1Wj3tOBTc/68YjhBBCVCNJcOzV1g8gJ0Vd1K/jWGtHI4QQQlQrR2sHIKpYUSFE/xt2zlcf95sJjs7WjUkIIYSoZpLg2JOs8/DdKEjcqT7uMUndVFMIIYSoZSTBsRfxf8D3oyH3Iui84IFPodlAa0clhBBCWIUkOLZOUeCvD2HjLHUxv4BWMGSJTAkXQghRq8kg46p24QAUGarv/TZMhw0z1OSm7cMwJlqSGyGEELWeJDhVKesCLBkEX9wByYcs/35n/oK/PlKP734P7p8Pzm6Wf18hhBCihpMEpyplnAGNA6Qcgi96w9YP1dWELcGQAz8+AyjQ7lF1pWKNxjLvJYQQQtgYSXCqUlhXeHYHNL0bigvV7qOFd8Ol+Kp/r+jX4XICeIeoO4QLIYQQwkwSnKrmUReGfQ33/R84e0LiDpjfHWIXqQOCq8LJjbD7K/X4vv8DF6+qua4QQghhJyTBsQSNBto9As/8BWE9wJgLaybAvLbw26uQuAtMppu7dv5l+Ol59bjTk9CgZ5WFLYQQQtgLjaJUVbOC7cjKysLb25vMzEy8vCzc+mEywY5P1H2hjHnXznsEQvN7oPm9ENYdtE4Vu94Pz8D+r8GvATy9FZzdLRO3EEIIUcNU5vtbEhxLJzhXFebCyQ1wdA0c/w0MWdee03lBoz7Q5C5o3O/GG2MeWwsrhgMaGP0rhHapltCFEEKImqDGJDjh4eEkJCSUOPfSSy/x9ttvA7Bo0SIef/zxUl+bkpJC3bp1S32uV69ebNmypcS5oUOHsmLFigrFZZUE5++KDOrKw0f+B3HrIC/t2nMaB6jfCQJbqeWKC6/dn90O+RnQbTz0f6P64xZCCCGsqEYlOGPGjGHs2Gu7WXt4eODh4QFAfn4+mZmZJV4zatQoCgoK2Lx58w2v26tXL5o0acKsWbPM51xdXfH29q5QXFZPcP7OZILze9RE5/hvkHKw7PJ1msGTW8DJpXriE0IIIWqIynx/W3yrBk9PTwIDA0t9ztXVFVdXV/Pjixcv8vvvv7NgwYJyr+vm5nbD69oUBweoH6Xe+rwOlxPhxHrITgZHnXrT6tQdwR1doWFvSW6EEEKIcli8BcdgMFBYWEhISAgPPfQQL774Is7OzqWWf//993njjTe4cOFCicTnn3r16sXhw4dRFIWAgADuuusupk+fjqenZ6nlDQYDBsO17ROysrIICQmpGS04QgghhKiQGtOCM2HCBNq3b4+vry+7du1i2rRpxMfH8+WXX5Za/quvvmL48OFlJjcAI0aMICIigsDAQA4dOsS0adPYv38/0dHRpZafM2cOM2fOvOX6CCGEEMI2VLoFZ8aMGeUmCzExMURFRV13ftWqVQwePJi0tDT8/f1LPLd9+3a6devG7t276dChQ2VCIjY2lqioKGJjY2nfvv11z0sLjhBCCGH7LNqCM27cOIYNG1ZmmfDw8FLPd+miTms+efLkdQnOl19+SWRkZKWTG4D27dvj5OTEiRMnSk1wdDodOp2u0tcVQgghhG2qdIKj1+vR6/U39WZ79+4FICgoqMT5nJwcvv32W+bMmXNT1z18+DBGo/G66wohhBCidrLYVg3bt29n7ty57Nu3j/j4eL799lueeuopBg0aRGhoaImyK1eupKioiBEjRlx3naSkJJo1a8auXbsAOHXqFLNmzWL37t2cOXOGX375hYceeoh27drRvXt3S1VHCCGEEDbEYoOMdTodK1euZObMmRgMBsLCwhg7dixTp069ruyCBQt48MEH8fX1ve45o9FIXFwceXnqNgfOzs5s3LiRefPmkZOTQ0hICAMHDmT69OlotVpLVUcIIYQQNkS2apBBxkIIIYRNqMz3t+wmLoQQQgi7IwmOEEIIIeyOJDhCCCGEsDuS4AghhBDC7kiCI4QQQgi7IwmOEEIIIeyORTfbrKmuzozPysqyciRCCCGEqKir39sVWeGmViY42dnZAISEhFg5EiGEEEJUVnZ2Nt7e3mWWqZUL/ZlMJs6fP4+npycajaZKr311p/LExES7XURQ6mgfpI72QepoH2pDHeHW66koCtnZ2QQHB+PgUPYom1rZguPg4ED9+vUt+h5eXl52/T8pSB3thdTRPkgd7UNtqCPcWj3La7m5SgYZCyGEEMLuSIIjhBBCCLsjCU4V0+l0TJ8+HZ1OZ+1QLEbqaB+kjvZB6mgfakMdoXrrWSsHGQshhBDCvkkLjhBCCCHsjiQ4QgghhLA7kuAIIYQQwu5IgiOEEEIIuyMJThX65JNPiIiIwMXFhQ4dOvDnn39aO6Rb8scff3DvvfcSHByMRqPhxx9/LPG8oijMmDGD4OBgXF1d6dWrF4cPH7ZOsDdhzpw5dOzYEU9PT+rWrcv9999PXFxciTK2Xsf58+fTpk0b86JaXbt2Zd26debnbb1+pZkzZw4ajYaJEyeaz9l6PWfMmIFGoylxCwwMND9v6/W7KikpiUceeQR/f3/c3NyIjIwkNjbW/Lw91DM8PPy6n6VGo+G5554D7KOORUVFvPbaa0RERODq6kqDBg2YNWsWJpPJXKZa6qmIKrFixQrFyclJ+eKLL5QjR44oEyZMUNzd3ZWEhARrh3bTfvnlF+XVV19VVq1apQDKDz/8UOL5t99+W/H09FRWrVqlHDx4UBk6dKgSFBSkZGVlWSfgShowYICycOFC5dChQ8q+ffuUgQMHKqGhoUpOTo65jK3X8aefflLWrl2rxMXFKXFxccorr7yiODk5KYcOHVIUxfbr90+7du1SwsPDlTZt2igTJkwwn7f1ek6fPl1p2bKlcuHCBfMtNTXV/Lyt109RFOXSpUtKWFiYMmrUKGXnzp1KfHy8smHDBuXkyZPmMvZQz9TU1BI/x+joaAVQNm3apCiKfdTxzTffVPz9/ZWff/5ZiY+PV7777jvFw8ND+fDDD81lqqOekuBUkU6dOilPP/10iXPNmjVTXn75ZStFVLX+meCYTCYlMDBQefvtt83nCgoKFG9vb+XTTz+1QoS3LjU1VQGULVu2KIpin3VUFEXx9fVVvvzyS7urX3Z2ttK4cWMlOjpa6dmzpznBsYd6Tp8+XWnbtm2pz9lD/RRFUV566SWlR48eN3zeXur5TxMmTFAaNmyomEwmu6njwIEDldGjR5c49+CDDyqPPPKIoijV97OULqoqUFhYSGxsLP379y9xvn///mzbts1KUVlWfHw8ycnJJeqs0+no2bOnzdY5MzMTAD8/P8D+6lhcXMyKFSvIzc2la9eudle/5557joEDB9K3b98S5+2lnidOnCA4OJiIiAiGDRvG6dOnAfup308//URUVBQPPfQQdevWpV27dnzxxRfm5+2lnn9XWFjIsmXLGD16NBqNxm7q2KNHDzZu3Mjx48cB2L9/P1u3buXuu+8Gqu9nWSs326xqaWlpFBcXExAQUOJ8QEAAycnJVorKsq7Wq7Q6JyQkWCOkW6IoCpMmTaJHjx60atUKsJ86Hjx4kK5du1JQUICHhwc//PADLVq0MH+Q2Hr9AFasWMGePXuIiYm57jl7+Dl27tyZJUuW0KRJE1JSUnjzzTfp1q0bhw8ftov6AZw+fZr58+czadIkXnnlFXbt2sX48ePR6XQ89thjdlPPv/vxxx+5fPkyo0aNAuzj/1WAl156iczMTJo1a4ZWq6W4uJjZs2fz8MMPA9VXT0lwqpBGoynxWFGU687ZG3up87hx4zhw4ABbt2697jlbr2PTpk3Zt28fly9fZtWqVYwcOZItW7aYn7f1+iUmJjJhwgTWr1+Pi4vLDcvZcj3vuusu83Hr1q3p2rUrDRs2ZPHixXTp0gWw7foBmEwmoqKieOuttwBo164dhw8fZv78+Tz22GPmcrZez79bsGABd911F8HBwSXO23odV65cybJly/j6669p2bIl+/btY+LEiQQHBzNy5EhzOUvXU7qoqoBer0er1V7XWpOamnpdhmovrs7gsIc6P//88/z0009s2rSJ+vXrm8/bSx2dnZ1p1KgRUVFRzJkzh7Zt2zJv3jy7qV9sbCypqal06NABR0dHHB0d2bJlCx999BGOjo7muth6Pf/O3d2d1q1bc+LECbv5OQYFBdGiRYsS55o3b87Zs2cB+/l9vCohIYENGzbwxBNPmM/ZSx1ffPFFXn75ZYYNG0br1q159NFHeeGFF5gzZw5QffWUBKcKODs706FDB6Kjo0ucj46Oplu3blaKyrIiIiIIDAwsUefCwkK2bNliM3VWFIVx48axevVqfv/9dyIiIko8bw91LI2iKBgMBrupX58+fTh48CD79u0z36KiohgxYgT79u2jQYMGdlHPvzMYDBw9epSgoCC7+Tl27979umUajh8/TlhYGGB/v48LFy6kbt26DBw40HzOXuqYl5eHg0PJ9EKr1ZqniVdbPatsuHItd3Wa+IIFC5QjR44oEydOVNzd3ZUzZ85YO7Sblp2drezdu1fZu3evAigffPCBsnfvXvPU97ffflvx9vZWVq9erRw8eFB5+OGHbWo64zPPPKN4e3srmzdvLjFtMy8vz1zG1us4bdo05Y8//lDi4+OVAwcOKK+88ori4OCgrF+/XlEU26/fjfx9FpWi2H49J0+erGzevFk5ffq0smPHDuWee+5RPD09zZ8vtl4/RVGn+Ds6OiqzZ89WTpw4oSxfvlxxc3NTli1bZi5jD/VUFEUpLi5WQkNDlZdeeum65+yhjiNHjlTq1atnnia+evVqRa/XK1OnTjWXqY56SoJThf7v//5PCQsLU5ydnZX27dubpxvbqk2bNinAdbeRI0cqiqJO9Zs+fboSGBio6HQ65fbbb1cOHjxo3aArobS6AcrChQvNZWy9jqNHjzb/P1mnTh2lT58+5uRGUWy/fjfyzwTH1ut5dY0QJycnJTg4WHnwwQeVw4cPm5+39fpdtWbNGqVVq1aKTqdTmjVrpnz++eclnreXev72228KoMTFxV33nD3UMSsrS5kwYYISGhqquLi4KA0aNFBeffVVxWAwmMtURz01iqIoVdceJIQQQghhfTIGRwghhBB2RxIcIYQQQtgdSXCEEEIIYXckwRFCCCGE3ZEERwghhBB2RxIcIYQQQtgdSXCEEEIIYXckwRFCCCGE3ZEERwghhBB2RxIcIYQQQtgdSXCEEEIIYXckwRFCCCGE3fl//XlSQtcB7x4AAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-17T18:07:11.774339Z", + "start_time": "2025-09-17T18:07:11.714325Z" + } + }, + "cell_type": "code", + "source": [ + "new_boundary_index, ratios = gmm_interpolate_boundary(aligner.ali_aligner.acoustic_model, am.transition_model, feats, previous_transition_id, following_transition_id)\n", + "print(round(feature_segment_begin + (new_boundary_index *0.001),3))\n", + "print(round(boundary,3))\n", + "plt.plot(ratios)\n", + "plt.axhline(0)" + ], + "id": "6a609e772e0361d9", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.149\n", + "0.11\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 18 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "2ac080a49ff341d3" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt index ac23bb3..fe2b4d4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,5 +2,6 @@ librosa numpy pysoundfile pynini +pyyaml dataclassy praatio>=6.0.0 diff --git a/rtd_environment.yml b/rtd_environment.yml index 416e6a4..acb7285 100644 --- a/rtd_environment.yml +++ b/rtd_environment.yml @@ -20,3 +20,4 @@ dependencies: - cmake - pybind11 - ninja + - pyyaml diff --git a/tests/conftest.py b/tests/conftest.py index 06e6bf3..e693400 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -34,6 +34,11 @@ def sat_am_dir(am_dir): return am_dir.joinpath("sat") +@pytest.fixture(scope="session") +def english_mfa_am_dir(am_dir): + return am_dir.joinpath("english_mfa") + + @pytest.fixture(scope="session") def temp_dir(test_dir): p = test_dir.joinpath("temp") @@ -499,6 +504,11 @@ def wav_path(wav_dir): return wav_dir.joinpath("acoustic_corpus.wav") +@pytest.fixture(scope="session") +def mfa_wav_path(wav_dir): + return wav_dir.joinpath("mfa_michael.flac") + + @pytest.fixture(scope="session") def lm_path(lm_dir): return lm_dir.joinpath("test_lm.arpa") @@ -544,6 +554,11 @@ def sat_dictionary_path(dictionaries_dir): return dictionaries_dir.joinpath("test_sat.txt") +@pytest.fixture(scope="session") +def mfa_dictionary_path(dictionaries_dir): + return dictionaries_dir.joinpath("test_mfa.txt") + + @pytest.fixture(scope="session") def reference_hello_intervals(): from _kalpy.util import Interval diff --git a/tests/data/acoustic_models/english_mfa/final.alimdl b/tests/data/acoustic_models/english_mfa/final.alimdl new file mode 100644 index 0000000..540c471 Binary files /dev/null and b/tests/data/acoustic_models/english_mfa/final.alimdl differ diff --git a/tests/data/acoustic_models/english_mfa/final.mdl b/tests/data/acoustic_models/english_mfa/final.mdl new file mode 100644 index 0000000..b9a1fe6 Binary files /dev/null and b/tests/data/acoustic_models/english_mfa/final.mdl differ diff --git a/tests/data/acoustic_models/english_mfa/lda.mat b/tests/data/acoustic_models/english_mfa/lda.mat new file mode 100644 index 0000000..d07edb4 Binary files /dev/null and b/tests/data/acoustic_models/english_mfa/lda.mat differ diff --git a/tests/data/acoustic_models/english_mfa/meta.json b/tests/data/acoustic_models/english_mfa/meta.json new file mode 100644 index 0000000..ddf1095 --- /dev/null +++ b/tests/data/acoustic_models/english_mfa/meta.json @@ -0,0 +1 @@ +{"phones": ["a", "aj", "aw", "aː", "b", "bʲ", "c", "cʰ", "cʷ", "d", "dʒ", "dʲ", "d̪", "e", "ej", "eː", "f", "fʲ", "fʷ", "h", "i", "iː", "j", "k", "kp", "kʰ", "kʷ", "l", "m", "mʲ", "m̩", "n", "n̩", "o", "ow", "oː", "p", "pʰ", "pʲ", "pʷ", "s", "t", "tʃ", "tʰ", "tʲ", "tʷ", "t̪", "u", "uː", "v", "vʲ", "vʷ", "w", "z", "æ", "ç", "ð", "ŋ", "ɐ", "ɑ", "ɑː", "ɒ", "ɒː", "ɔ", "ɔj", "ɖ", "ə", "əw", "ɚ", "ɛ", "ɛː", "ɜ", "ɜː", "ɝ", "ɟ", "ɟʷ", "ɡ", "ɡb", "ɡʷ", "ɪ", "ɫ", "ɫ̩", "ɱ", "ɲ", "ɹ", "ɾ", "ɾʲ", "ɾ̃", "ʃ", "ʈ", "ʈʲ", "ʈʷ", "ʉ", "ʉː", "ʊ", "ʋ", "ʎ", "ʒ", "ʔ", "θ"], "phone_mapping": {"": 0, "sil": 1, "spn": 2, "a": 3, "aj": 4, "aw": 5, "aː": 6, "b": 7, "bʲ": 8, "c": 9, "cʰ": 10, "cʷ": 11, "d": 12, "dʒ": 13, "dʲ": 14, "d̪": 15, "e": 16, "ej": 17, "eː": 18, "f": 19, "fʲ": 20, "fʷ": 21, "h": 22, "i": 23, "iː": 24, "j": 25, "k": 26, "kp": 27, "kʰ": 28, "kʷ": 29, "l": 30, "m": 31, "mʲ": 32, "m̩": 33, "n": 34, "n̩": 35, "o": 36, "ow": 37, "oː": 38, "p": 39, "pʰ": 40, "pʲ": 41, "pʷ": 42, "s": 43, "t": 44, "tʃ": 45, "tʰ": 46, "tʲ": 47, "tʷ": 48, "t̪": 49, "u": 50, "uː": 51, "v": 52, "vʲ": 53, "vʷ": 54, "w": 55, "z": 56, "æ": 57, "ç": 58, "ð": 59, "ŋ": 60, "ɐ": 61, "ɑ": 62, "ɑː": 63, "ɒ": 64, "ɒː": 65, "ɔ": 66, "ɔj": 67, "ɖ": 68, "ə": 69, "əw": 70, "ɚ": 71, "ɛ": 72, "ɛː": 73, "ɜ": 74, "ɜː": 75, "ɝ": 76, "ɟ": 77, "ɟʷ": 78, "ɡ": 79, "ɡb": 80, "ɡʷ": 81, "ɪ": 82, "ɫ": 83, "ɫ̩": 84, "ɱ": 85, "ɲ": 86, "ɹ": 87, "ɾ": 88, "ɾʲ": 89, "ɾ̃": 90, "ʃ": 91, "ʈ": 92, "ʈʲ": 93, "ʈʷ": 94, "ʉ": 95, "ʉː": 96, "ʊ": 97, "ʋ": 98, "ʎ": 99, "ʒ": 100, "ʔ": 101, "θ": 102}, "phone_groups": {"0": ["kp", "p", "pʰ", "pʲ", "pʷ"], "1": ["b", "bʲ", "ɡb"], "2": ["f", "fʲ", "fʷ"], "3": ["v", "vʲ", "vʷ"], "4": ["θ"], "5": ["t̪"], "6": ["ð"], "7": ["d̪"], "8": ["t", "tʰ", "tʲ", "tʷ", "ʈ", "ʈʲ", "ʈʷ"], "9": ["ʔ"], "10": ["d", "dʲ", "ɖ"], "11": ["ɾ", "ɾʲ"], "12": ["tʃ"], "13": ["dʒ"], "14": ["ʃ"], "15": ["ʒ"], "16": ["s"], "17": ["z"], "18": ["ɹ"], "19": ["m", "m̩"], "20": ["mʲ"], "21": ["ɱ"], "22": ["n", "n̩"], "23": ["ɲ"], "24": ["ɾ̃"], "25": ["ŋ"], "26": ["l"], "27": ["ɫ", "ɫ̩"], "28": ["ʎ"], "29": ["ɟ", "ɟʷ", "ɡ", "ɡʷ"], "30": ["c", "cʰ", "cʷ"], "31": ["k", "kʰ", "kʷ"], "32": ["ç"], "33": ["h"], "34": ["ɐ", "ə"], "35": ["ɜ", "ɜː"], "36": ["ɚ", "ɝ"], "37": ["ʊ"], "38": ["ɪ"], "39": ["ɑ", "ɑː"], "40": ["ɒ", "ɒː", "ɔ"], "41": ["a", "aː"], "42": ["æ"], "43": ["aj"], "44": ["aw"], "45": ["i", "iː"], "46": ["j"], "47": ["ɛ", "ɛː"], "48": ["e", "ej", "eː"], "49": ["ʉ", "ʉː"], "50": ["u", "uː"], "51": ["w"], "52": ["ʋ"], "53": ["ɔj"], "54": ["o", "ow", "oː", "əw"]}, "version": "3.1.0", "architecture": "gmm-hmm", "train_date": "2024-06-12 12:16:18.584033", "training": {"audio_duration": 12862940.052134357, "num_speakers": 75018, "num_utterances": 2374755, "num_oovs": 0, "average_log_likelihood": -0.08382050453507844}, "dictionaries": {"names": ["default", "english_india_mfa", "english_nigeria_mfa", "english_uk_mfa", "english_us_mfa", "nonnative"], "default": "default", "silence_word": "", "use_g2p": false, "oov_word": "", "bracketed_word": "[bracketed]", "laughter_word": "[laughter]", "clitic_marker": "'", "position_dependent_phones": false}, "language": "unknown", "features": {"type": "mfcc", "use_energy": true, "frame_shift": 10, "frame_length": 25, "snip_edges": false, "low_frequency": 20, "high_frequency": 7800, "sample_frequency": 16000, "dither": 0.0001, "energy_floor": 1.0, "num_coefficients": 13, "num_mel_bins": 23, "cepstral_lifter": 22, "preemphasis_coefficient": 0.97, "uses_cmvn": true, "uses_deltas": true, "uses_voiced": false, "uses_splices": false, "uses_speaker_adaptation": true, "use_pitch": false, "use_voicing": false, "min_f0": 50, "max_f0": 800, "delta_pitch": 0.005, "penalty_factor": 0.1, "silence_weight": 0.0, "splice_left_context": 3, "splice_right_context": 3}, "oov_phone": "spn", "optional_silence_phone": "sil", "phone_set_type": "UNKNOWN", "silence_probability": 0.17, "initial_silence_probability": 0.17, "final_silence_correction": 0.99, "final_non_silence_correction": 0.2966666666666667} diff --git a/tests/data/acoustic_models/english_mfa/phones.txt b/tests/data/acoustic_models/english_mfa/phones.txt new file mode 100644 index 0000000..1ad2c32 --- /dev/null +++ b/tests/data/acoustic_models/english_mfa/phones.txt @@ -0,0 +1,103 @@ + 0 +sil 1 +spn 2 +a 3 +aj 4 +aw 5 +aː 6 +b 7 +bʲ 8 +c 9 +cʰ 10 +cʷ 11 +d 12 +dʒ 13 +dʲ 14 +d̪ 15 +e 16 +ej 17 +eː 18 +f 19 +fʲ 20 +fʷ 21 +h 22 +i 23 +iː 24 +j 25 +k 26 +kp 27 +kʰ 28 +kʷ 29 +l 30 +m 31 +mʲ 32 +m̩ 33 +n 34 +n̩ 35 +o 36 +ow 37 +oː 38 +p 39 +pʰ 40 +pʲ 41 +pʷ 42 +s 43 +t 44 +tʃ 45 +tʰ 46 +tʲ 47 +tʷ 48 +t̪ 49 +u 50 +uː 51 +v 52 +vʲ 53 +vʷ 54 +w 55 +z 56 +æ 57 +ç 58 +ð 59 +ŋ 60 +ɐ 61 +ɑ 62 +ɑː 63 +ɒ 64 +ɒː 65 +ɔ 66 +ɔj 67 +ɖ 68 +ə 69 +əw 70 +ɚ 71 +ɛ 72 +ɛː 73 +ɜ 74 +ɜː 75 +ɝ 76 +ɟ 77 +ɟʷ 78 +ɡ 79 +ɡb 80 +ɡʷ 81 +ɪ 82 +ɫ 83 +ɫ̩ 84 +ɱ 85 +ɲ 86 +ɹ 87 +ɾ 88 +ɾʲ 89 +ɾ̃ 90 +ʃ 91 +ʈ 92 +ʈʲ 93 +ʈʷ 94 +ʉ 95 +ʉː 96 +ʊ 97 +ʋ 98 +ʎ 99 +ʒ 100 +ʔ 101 +θ 102 diff --git a/tests/data/acoustic_models/english_mfa/tree b/tests/data/acoustic_models/english_mfa/tree new file mode 100644 index 0000000..ce6e859 Binary files /dev/null and b/tests/data/acoustic_models/english_mfa/tree differ diff --git a/tests/data/dictionaries/test_mfa.txt b/tests/data/dictionaries/test_mfa.txt new file mode 100644 index 0000000..2c185a3 --- /dev/null +++ b/tests/data/dictionaries/test_mfa.txt @@ -0,0 +1,3 @@ +montreal 0.99 0.14 1.0 1.0 m ɑ n tʲ ɹ i ɒ ɫ +forced 0.99 0.04 0.85 1.05 f ɒ ɹ s t +aligner 0.99 0.14 1.0 1.0 ə l aj n ɚ diff --git a/tests/data/wav/mfa_michael.flac b/tests/data/wav/mfa_michael.flac new file mode 100644 index 0000000..132dc87 Binary files /dev/null and b/tests/data/wav/mfa_michael.flac differ diff --git a/tests/test_aligner.py b/tests/test_aligner.py new file mode 100644 index 0000000..b8f9276 --- /dev/null +++ b/tests/test_aligner.py @@ -0,0 +1,41 @@ +from kalpy.aligner import KalpyAligner +from kalpy.data import Segment +from kalpy.models import AcousticModel +from kalpy.utterance import Utterance + + +def test_aligner_align( + english_mfa_am_dir, + mfa_dictionary_path, + mfa_wav_path, +): + am = AcousticModel(english_mfa_am_dir) + lc = am.lexicon_compiler + lc.load_pronunciations(mfa_dictionary_path) + aligner = KalpyAligner(am, lc) + seg = Segment(mfa_wav_path) + utterance = Utterance(seg, "montreal forced aligner") + ctm = aligner.align_utterance(utterance) + assert len(ctm.word_intervals) == 3 + + +def test_aligner_fine_tune( + english_mfa_am_dir, + mfa_dictionary_path, + mfa_wav_path, +): + am = AcousticModel(english_mfa_am_dir) + lc = am.lexicon_compiler + lc.load_pronunciations(mfa_dictionary_path) + aligner = KalpyAligner(am, lc) + seg = Segment(mfa_wav_path) + utterance = Utterance(seg, "montreal forced aligner") + ctm = aligner.align_utterance(utterance) + assert len(ctm.word_intervals) == 3 + fine_tuned_ctm = aligner.fine_tune_alignments(utterance) + assert len(fine_tuned_ctm.word_intervals) == 3 + boundaries = ctm.phone_boundaries + fine_tuned_boundaries = fine_tuned_ctm.phone_boundaries + assert len(boundaries) == len(fine_tuned_boundaries) + for i, b in enumerate(boundaries): + assert abs(b - fine_tuned_boundaries[i]) < 0.01