diff --git a/CMakeLists.txt b/CMakeLists.txt index f5049e3..9fdd96b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -155,14 +155,10 @@ endif() if(AARE_FETCH_MINUIT2) # We are building Minuit2 from sources. - # Patch minuit2 to avoid messing with cmake policies - set(MINUIT2_PATCH_COMMAND git apply - ${CMAKE_CURRENT_SOURCE_DIR}/patches/minuit2.patch) FetchContent_Declare( Minuit2 GIT_REPOSITORY https://github.com/GooFit/Minuit2.git GIT_TAG master - PATCH_COMMAND ${MINUIT2_PATCH_COMMAND} UPDATE_DISCONNECTED 1) # Disable Minuit2 extras we don't need set(minuit2_mpi @@ -175,7 +171,7 @@ if(AARE_FETCH_MINUIT2) OFF CACHE BOOL "") set(MINUIT2_INSTALL - ON + OFF CACHE BOOL "") FetchContent_MakeAvailable(Minuit2) @@ -395,7 +391,6 @@ set(PUBLICHEADERS include/aare/Dtype.hpp include/aare/File.hpp include/aare/Fit.hpp - include/aare/Chi2.hpp include/aare/FitModel.hpp include/aare/Models.hpp include/aare/FileInterface.hpp @@ -460,8 +455,8 @@ target_link_libraries( aare_core PUBLIC fmt::fmt nlohmann_json::nlohmann_json ${STD_FS_LIB} # from # helpers.cmake - aare::Minuit2 - PRIVATE aare_compiler_flags Threads::Threads $) + PRIVATE aare_compiler_flags Threads::Threads $ + $) target_include_directories( aare_core SYSTEM diff --git a/RELEASE.md b/RELEASE.md index 1689a9d..1b51a49 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,6 +1,6 @@ # Release notes -## HEAD +## 2026.7.2 ### New Features: diff --git a/VERSION b/VERSION index a00b244..2398eb2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2026.3.17 \ No newline at end of file +2026.7.2 \ No newline at end of file diff --git a/benchmarks/fit_benchmark.cpp b/benchmarks/fit_benchmark.cpp index 8249bcd..81d5451 100644 --- a/benchmarks/fit_benchmark.cpp +++ b/benchmarks/fit_benchmark.cpp @@ -1,5 +1,4 @@ // SPDX-License-Identifier: MPL-2.0 -#include "aare/Chi2.hpp" #include "aare/Fit.hpp" #include "aare/FitModel.hpp" #include "aare/Models.hpp" @@ -108,9 +107,7 @@ static void BM_FitGausMinuitGrad(benchmark::State &state) { aare::NDArray result; for (auto _ : state) { - result = - aare::fit_pixel( - model, xv, yv); + result = aare::fit_pixel(model, xv, yv); benchmark::DoNotOptimize(result.data()); } @@ -132,9 +129,7 @@ static void BM_FitGausMinuitGradHesse(benchmark::State &state) { aare::NDArray result; for (auto _ : state) { - result = - aare::fit_pixel( - model, xv, yv, ev); + result = aare::fit_pixel(model, xv, yv, ev); benchmark::DoNotOptimize(result.data()); } diff --git a/include/aare/Fit.hpp b/include/aare/Fit.hpp index 441315e..a641e13 100644 --- a/include/aare/Fit.hpp +++ b/include/aare/Fit.hpp @@ -2,21 +2,13 @@ #pragma once #include -#include #include -#include "aare/Chi2.hpp" #include "aare/FitModel.hpp" #include "aare/NDArray.hpp" #include "aare/utils/par.hpp" #include "aare/utils/task.hpp" -#include "Minuit2/FunctionMinimum.h" -#include "Minuit2/MnHesse.h" -#include "Minuit2/MnMigrad.h" -#include "Minuit2/MnPrint.h" -#include "Minuit2/MnUserParameters.h" - namespace aare { namespace func { @@ -49,7 +41,6 @@ NDArray fit_gaus(NDView x, NDView y); * @param y y values, layout [row, col, values] * @param n_threads number of threads to use */ - NDArray fit_gaus(NDView x, NDView y, int n_threads = DEFAULT_NUM_THREADS); @@ -115,138 +106,43 @@ void fit_scurve2(NDView x, NDView y, NDView par_err_out, NDView chi2_out, int n_threads); -// Minuit2 fit_pixel / fit_3d object based API - -// _____________________________________________________________________ -// -// fit_pixel — single-pixel minimisation -// _____________________________________________________________________ +// --------------------------------------------------------------------------- +// Minuit2-based pixel fitting. +// Template bodies and explicit instantiations live in src/Fit.cpp. +// --------------------------------------------------------------------------- /** * @brief Fit a single pixel's data using Minuit2. * - * The caller provides a thread-local clone of MnUserParameters so that - * no heap allocation happens here (only SetValue/SetError stores). - * * User-precedence rules: - * - Fixed parameters: untouched (value and fixed flag preserved from clone). + * - Fixed parameters: untouched (value and fixed flag preserved from model). * - User-set start: value preserved, step size auto-filled. * - Neither: both value and step size auto-filled from data. * * @tparam Model Model struct (Gaussian, RisingScurve, …). - * @tparam FCN Chi2 functor type (Chi2Model1D or Chi2Model1DGrad - * instantiation). * - * @param model The FitModel configuration (read-only). - * @param upar_local Thread-local clone of model.upar(). Modified in place. - * @param x Scan points (shared across all pixels). - * @param y Measured values for this pixel. - * @param y_err Per-point uncertainties (empty view -> unweighted fit). + * @param model The FitModel configuration (read-only). + * @param x Scan points. + * @param y Measured values for this pixel. + * @param y_err Per-point uncertainties (empty view -> unweighted fit). * * @return NDArray of size: * - compute_errors: [p0..pN, err0..errN, chi2] -> 2*npar + 1 * - otherwise: [p0..pN, chi2] -> npar + 1 */ -template -NDArray fit_pixel(const FitModel &model, - ROOT::Minuit2::MnUserParameters &upar_local, - NDView x, NDView y, - NDView y_err) { - - constexpr std::size_t npar = Model::npar; - const bool want_errors = model.compute_errors(); - const ssize_t result_size = want_errors ? (2 * npar + 1) : (npar + 1); - - // ──── automatic parameter estimation ───────────── - auto start = Model::estimate_par(x, y); - - // dead / degenerate pixel guard - if (!Model::is_valid(std::vector(start.begin(), start.end()))) { - return NDArray({result_size}, 0.0); - } - - // ──── data-range statistics for step sizes ───────────── - double x_range, y_range, slope_scale; - model::compute_ranges(x, y, x_range, y_range, slope_scale); - - std::array steps{}; - Model::compute_steps(start, x_range, y_range, slope_scale, steps); - - // ── apply auto-estimates respecting user precedence ───────────── - for (std::size_t i = 0; i < npar; ++i) { - // fixed: do not touch at all - if (model.is_user_fixed(i)) { - continue; - } - - if (!model.is_user_start(i)) { - upar_local.SetValue(i, start[i]); - } - - upar_local.SetError(i, steps[i]); - } - - // ──── build functor ──────── - auto chi2 = (y_err.size() > 0) ? FCN(x, y, y_err) : FCN(x, y); - - // ──── run minimizer ──────── - ROOT::Minuit2::MnMigrad migrad(chi2, upar_local, model.strategy()); - ROOT::Minuit2::FunctionMinimum min = - migrad(model.max_calls(), model.tolerance()); - - if (!min.IsValid()) - return NDArray({result_size}, 0.0); - - // ──── pack results ──────── - if (want_errors) { - ROOT::Minuit2::MnHesse hesse; - hesse(chi2, min); - - const auto &values = min.UserState().Params(); - const auto &errors = min.UserState().Errors(); - - NDArray result({result_size}); - for (std::size_t k = 0; k < npar; ++k) { - result[k] = values[k]; - result[npar + k] = errors[k]; - } - result[2 * npar] = min.Fval(); - return result; - } - - const auto &values = min.UserState().Params(); - NDArray result({result_size}); - for (std::size_t k = 0; k < npar; ++k) - result[k] = values[k]; - result[npar] = min.Fval(); - return result; -} - -// ── self-contained for 1D / standalone use ───────── -template +template NDArray fit_pixel(const FitModel &model, NDView x, - NDView y, NDView y_err) { - auto upar_local = model.upar(); - return fit_pixel(model, upar_local, x, y, y_err); -} + NDView y, NDView y_err); // Overload: uncertainties not provided -template +template NDArray fit_pixel(const FitModel &model, NDView x, - NDView y) { - auto upar_local = model.upar(); - return fit_pixel(model, upar_local, x, y, NDView{}); -} + NDView y); -// _____________________________________________________________________ -// -// fit_3d — row-parallel fitting over (rows, cols) pixel grid -// _____________________________________________________________________ /** * @brief Fit all pixels in a 3D data cube (rows x cols x n_scan). * * @tparam Model Model struct. - * @tparam FCN Chi2 functor type. * * @param model Fit configuration shared by all pixels. * @param x Scan points, shape `(n_scan)`. @@ -259,78 +155,11 @@ NDArray fit_pixel(const FitModel &model, NDView x, * @param chi2_out Output chi-squared / objective values, shape `(rows, * cols)`. * @param n_threads Number of threads used to split rows. - * */ -template -void fit_3d( - const FitModel &model, NDView x, // (n_scan) - NDView y, // (rows, cols, n_scan) - NDView y_err, // (rows, cols, n_scan) or empty for unweighted fit - NDView par_out, NDView err_out, - NDView chi2_out, int n_threads) { - const std::size_t npar = Model::npar; +template +void fit_3d(const FitModel &model, NDView x, + NDView y, NDView y_err, + NDView par_out, NDView err_out, + NDView chi2_out, int n_threads); - // ──── checks ─────── - if (x.size() != y.shape(2)) - throw std::runtime_error("fit_3d: x.size() must match y.shape(2)."); - - if (par_out.shape(0) != y.shape(0) || par_out.shape(1) != y.shape(1) || - par_out.shape(2) != npar) - throw std::runtime_error("par_out must have shape [rows, cols, npar]."); - - if (chi2_out.shape(0) != y.shape(0) || chi2_out.shape(1) != y.shape(1)) - throw std::runtime_error("chi2_out must have shape [rows, cols]."); - - const bool has_errors = (y_err.size() > 0); - const bool want_par_errors = (err_out.size() > 0) && model.compute_errors(); - - if (has_errors) { - if (y.shape(0) != y_err.shape(0) || y.shape(1) != y_err.shape(1) || - y.shape(2) != y_err.shape(2)) - throw std::runtime_error( - "fit_3d: y and y_err must have identical shape."); - - if (err_out.shape(0) != y.shape(0) || err_out.shape(1) != y.shape(1) || - err_out.shape(2) != npar) - throw std::runtime_error( - "err_out must have shape [rows, cols, npar]."); - } - - // ──── parallel dispatch ─────── - auto process = [&](ssize_t first_row, ssize_t last_row) { - // one clone per thread - auto upar_local = model.upar(); - - for (ssize_t row = first_row; row < last_row; row++) { - for (ssize_t col = 0; col < y.shape(1); col++) { - - NDView values(&y(row, col, 0), {y.shape(2)}); - NDView errors = - has_errors ? NDView(&y_err(row, col, 0), - {y_err.shape(2)}) - : NDView{}; - - auto res = - fit_pixel(model, upar_local, x, values, errors); - - for (std::size_t k = 0; k < npar; ++k) { - par_out(row, col, k) = res(k); - } - - if (want_par_errors) { - for (std::size_t k = 0; k < npar; ++k) { - err_out(row, col, k) = res(npar + k); - } - chi2_out(row, col) = res(2 * npar); - } else { - chi2_out(row, col) = res(npar); - } - } - } - }; - - auto tasks = split_task(0, static_cast(y.shape(0)), n_threads); - RunInParallel(process, tasks); -} - -} // namespace aare \ No newline at end of file +} // namespace aare diff --git a/include/aare/FitModel.hpp b/include/aare/FitModel.hpp index dd187b3..a52ea9f 100644 --- a/include/aare/FitModel.hpp +++ b/include/aare/FitModel.hpp @@ -2,16 +2,21 @@ #pragma once #include "aare/Models.hpp" -#include - -#include "Minuit2/MnStrategy.h" -#include "Minuit2/MnUserParameters.h" +#include +#include +#include +#include +#include namespace aare { template class FitModel { - ROOT::Minuit2::MnUserParameters upar_; - ROOT::Minuit2::MnStrategy strategy_; + + // Forward declaration only — full definition lives in src/FitModelImpl.hpp + // and is never installed. Downstream code cannot dereference this pointer. + struct FitModelImpl; // stores Minuit2 user-set parameters + + std::unique_ptr impl_; unsigned int max_calls_; double tolerance_; bool compute_errors_; @@ -20,14 +25,7 @@ template class FitModel { std::array user_start_{}; /** @brief Safely resolve a parameter name to its index. */ - unsigned int checked_index(const std::string &name) const { - for (std::size_t i = 0; i < npar; ++i) { - if (upar_.Name(i) == name) - return static_cast(i); - } - throw std::runtime_error("FitModel: unknown parameter name '" + name + - "'"); - } + unsigned int checked_index(const std::string &name) const; public: static constexpr std::size_t npar = Model::npar; @@ -41,97 +39,64 @@ template class FitModel { * @param tolerance Minuit2 EDM tolerance. * @param compute_errors If true, run MnHesse after minimisation. */ - FitModel(unsigned int strategy = 0, unsigned int max_calls = 100, - double tolerance = 0.5, bool compute_errors = false) - : strategy_(strategy), max_calls_(max_calls), tolerance_(tolerance), - compute_errors_(compute_errors) { - for (std::size_t i = 0; i < npar; ++i) { - const auto pi = Model::param_info[i]; - const bool has_lo = std::isfinite(pi.default_lo); - const bool has_hi = std::isfinite(pi.default_hi); + explicit FitModel(unsigned int strategy = 0, unsigned int max_calls = 100, + double tolerance = 0.5, bool compute_errors = false); - // Add parameters and valid bounds - if (has_lo && has_hi) { - upar_.Add(pi.name, 0.0, 1.0, pi.default_lo, pi.default_hi); - } else if (has_lo) { - upar_.Add(pi.name, 0.0, 1.0, pi.default_lo, 1e6); - } else { - upar_.Add(pi.name, 0.0, 1.0); - } - } - } + // Destructor must be defined in Fit.cpp where FitModelImpl is complete. + ~FitModel(); + FitModel(const FitModel &); + FitModel &operator=(const FitModel &); + FitModel(FitModel &&) noexcept = default; + FitModel &operator=(FitModel &&) noexcept = default; /** @brief Set lower and upper bounds for parameter idx.*/ - void SetParLimits(unsigned int idx, double lo, double hi) { - upar_.SetLimits(idx, lo, hi); - } + void SetParLimits(unsigned int idx, double lo, double hi); /** * @brief Fix parameter idx at value val. * * Excluded from minimisation. Automatic estimates will not touch it. */ - void FixParameter(unsigned int idx, double val) { - SetParameter(idx, val); - upar_.Fix(idx); - user_fixed_[idx] = true; - } + void FixParameter(unsigned int idx, double val); /** @brief Release a previously fixed parameter, re-enabling auto estimates. */ - void ReleaseParameter(unsigned int idx) { - upar_.Release(idx); - user_fixed_[idx] = false; - } - - void ReleaseParameter(const std::string &name) { - ReleaseParameter(checked_index(name)); - } + void ReleaseParameter(unsigned int idx); + void ReleaseParameter(const std::string &name); /** @brief Set an explicit starting value for parameter idx.*/ - void SetParameter(unsigned int idx, double val) { - upar_.SetValue(idx, val); - user_start_[idx] = true; - } + void SetParameter(unsigned int idx, double val); + void SetParameter(const std::string &name, double val); + void FixParameter(const std::string &name, double val); + void SetParLimits(const std::string &name, double lo, double hi); + std::string GetParName(unsigned int idx) const; + std::vector GetParNames() const; - void SetParameter(const std::string &name, double val) { - // go through index to maintain user_start_ bookkeeping - SetParameter(checked_index(name), val); - } - - void FixParameter(const std::string &name, double val) { - // go through index to maintain user_fixed_ bookkeeping - FixParameter(checked_index(name), val); - } - - void SetParLimits(const std::string &name, double lo, double hi) { - SetParLimits(checked_index(name), lo, hi); - } - - std::string GetParName(unsigned int idx) const { - return upar_.GetName(idx); - } - - std::vector GetParNames() const { - std::vector names; - for (std::size_t i = 0; i < npar; ++i) - names.push_back(GetParName(i)); - return names; - } static constexpr std::size_t GetNpar() noexcept { return npar; } - void SetMaxCalls(unsigned int n) { max_calls_ = n; } void SetTolerance(double t) { tolerance_ = t; } void SetComputeErrors(bool b) { compute_errors_ = b; } - // accessors - const ROOT::Minuit2::MnUserParameters &upar() const { return upar_; } - const ROOT::Minuit2::MnStrategy &strategy() const { return strategy_; } unsigned int max_calls() const { return max_calls_; } double tolerance() const { return tolerance_; } bool compute_errors() const { return compute_errors_; } bool is_user_fixed(unsigned int idx) const { return user_fixed_[idx]; } bool is_user_start(unsigned int idx) const { return user_start_[idx]; } + + // Returns the internal Minuit2 state. FitModelImpl is an incomplete type + // here; only callers that include src/FitModelImpl.hpp can dereference it. + FitModelImpl *impl() const { return impl_.get(); } }; +// Suppress implicit instantiation for all supported model types. +// Definitions live in src/Fit.cpp. +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; +extern template class FitModel; + } // namespace aare diff --git a/include/aare/defs.hpp b/include/aare/defs.hpp index 0236b45..af73a84 100644 --- a/include/aare/defs.hpp +++ b/include/aare/defs.hpp @@ -219,6 +219,17 @@ struct Moench04 { constexpr static size_t superColumnWidth = 25; }; +/// @brief Chip specifications for Moench05 +struct Moench05 { + constexpr static size_t nRows = 160; + constexpr static size_t nCols = + 150; // TODO: should probably be seperated for each adc + + /// @brief used ADCs for moench given in relative numbers to the default + /// enabled blocks of 4 adcs in absolute adcs 9, 13, 1 are used + constexpr static std::array adcNumbers = {5, 9, 1}; +}; + enum ReadoutMode : uint8_t { ANALOG_ONLY = 0, DIGITAL_ONLY = 1, diff --git a/patches/minuit2.patch b/patches/minuit2.patch deleted file mode 100644 index b2752bf..0000000 --- a/patches/minuit2.patch +++ /dev/null @@ -1,39 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 4e72289..33dd58a 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -4,7 +4,7 @@ - # For the licensing terms see $ROOTSYS/LICENSE. - # For the list of contributors see $ROOTSYS/README/CREDITS. - --cmake_minimum_required(VERSION 3.1) -+cmake_minimum_required(VERSION 3.15) - - if(NOT CMAKE_PROJECT_NAME STREQUAL ROOT) - project(Minuit2 LANGUAGES CXX) -diff --git a/StandAlone.cmake b/StandAlone.cmake -index 0a662ba..b7a05ca 100644 ---- a/StandAlone.cmake -+++ b/StandAlone.cmake -@@ -1,12 +1,12 @@ --cmake_minimum_required(VERSION 3.1) -- --# Tested with and supporting policies up to the following CMake version. --# Not using ... syntax due to parser bug in MSVC's built-in CMake server mode. --if(${CMAKE_VERSION} VERSION_LESS 3.12) -- cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) --else() -- cmake_policy(VERSION 3.12) --endif() -+cmake_minimum_required(VERSION 3.15) -+ -+# # Tested with and supporting policies up to the following CMake version. -+# # Not using ... syntax due to parser bug in MSVC's built-in CMake server mode. -+# if(${CMAKE_VERSION} VERSION_LESS 3.12) -+# cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) -+# else() -+# cmake_policy(VERSION 3.12) -+# endif() - - include(FeatureSummary) - include(CMakeDependentOption) diff --git a/python/aare/transform.py b/python/aare/transform.py index 45cc780..6d14231 100644 --- a/python/aare/transform.py +++ b/python/aare/transform.py @@ -17,6 +17,15 @@ class AdcSar05060708Transform64to16: return _aare.adc_sar_05_06_07_08decode64to16(data) class Moench05Transform: + """ + Transforms Moench05 chip data from a buffer of bytes (uint8_t) + to a numpy array of uint16. Assumes data taken with analog samples and assumes adc 1, 9, 13 are enabled. + (e.g. for 10g mode adc 0,1,2,3 and 8,9,10,11 and 12,13,14,15 are enabled but only adc 1,9,13 contain relevant data) + + .. note:: + A moench05 chip has 160 rows and 50 cols per adc and has dynamic range 16 bit. Each adc sample is encoded in 16 bits. + The transformation thus requires 160*50*16/16 = 8000 analog samples per adc. + """ #Could be moved to C++ without changing the interface def __init__(self): self.pixel_map = _aare.GenerateMoench05PixelMap() diff --git a/python/src/bind_Defs.hpp b/python/src/bind_Defs.hpp index e048f1c..f091788 100644 --- a/python/src/bind_Defs.hpp +++ b/python/src/bind_Defs.hpp @@ -22,4 +22,9 @@ void define_defs_bindings(py::module &m) { moench04.attr("nPixelsPerSuperColumn") = Moench04::nPixelsPerSuperColumn; moench04.attr("superColumnWidth") = Moench04::superColumnWidth; moench04.attr("adcNumbers") = Moench04::adcNumbers; + + auto moench05 = py::class_(m, "Moench05"); + moench05.attr("nRows") = Moench05::nRows; + moench05.attr("nCols") = Moench05::nCols; + moench05.attr("adcNumbers") = Moench05::adcNumbers; } diff --git a/python/src/fit.hpp b/python/src/fit.hpp index f045d43..b07dadf 100644 --- a/python/src/fit.hpp +++ b/python/src/fit.hpp @@ -5,7 +5,6 @@ #include #include -#include "aare/Chi2.hpp" #include "aare/Fit.hpp" #include "aare/FitModel.hpp" #include "aare/Models.hpp" @@ -13,7 +12,7 @@ namespace py = pybind11; using namespace pybind11::literals; -template +template py::object fit_dispatch(const aare::FitModel &model, py::array_t x, @@ -22,7 +21,6 @@ fit_dispatch(const aare::FitModel &model, template void bind_fit_model(py::module &m, const char *name) { using FM = aare::FitModel; - using FCN = aare::func::Chi2Model1DGrad; py::class_(m, name) .def(py::init(), py::arg("strategy") = 0, py::arg("max_calls") = 100, @@ -85,8 +83,7 @@ template void bind_fit_model(py::module &m, const char *name) { py::array_t x, py::array_t y, py::object y_err_obj, int n_threads) -> py::object { - return fit_dispatch(self, x, y, y_err_obj, - n_threads); + return fit_dispatch(self, x, y, y_err_obj, n_threads); }, R"doc( Fit this model to 1D or 3D data using Minuit2. @@ -145,7 +142,7 @@ py::dict pack_1d_result_dict(const aare::NDArray &result, } // Helper: typed dispatch for one Model, handles 1D/3D + y_err logic -template +template py::object fit_dispatch(const aare::FitModel &model, py::array_t x, @@ -175,9 +172,9 @@ fit_dispatch(const aare::FitModel &model, new NDArray({y.shape(0), y.shape(1), npar}, 0.0); auto y_view_err = make_view_3d(y_err); - aare::fit_3d(model, x_view, y_view, y_view_err, - par_out->view(), err_out->view(), - chi2_out->view(), n_threads); + aare::fit_3d(model, x_view, y_view, y_view_err, + par_out->view(), err_out->view(), + chi2_out->view(), n_threads); if (model.compute_errors()) { return py::dict("par"_a = return_image_data(par_out), @@ -193,9 +190,9 @@ fit_dispatch(const aare::FitModel &model, NDView dummy_err{}; NDView dummy_err_out{}; - aare::fit_3d(model, x_view, y_view, dummy_err, - par_out->view(), dummy_err_out, - chi2_out->view(), n_threads); + aare::fit_3d(model, x_view, y_view, dummy_err, + par_out->view(), dummy_err_out, + chi2_out->view(), n_threads); return py::dict("par"_a = return_image_data(par_out), "chi2"_a = return_image_data(chi2_out)); @@ -217,10 +214,9 @@ fit_dispatch(const aare::FitModel &model, } auto y_view_err = make_view_1d(y_err); - result = - aare::fit_pixel(model, x_view, y_view, y_view_err); + result = aare::fit_pixel(model, x_view, y_view, y_view_err); } else { - result = aare::fit_pixel(model, x_view, y_view); + result = aare::fit_pixel(model, x_view, y_view); } return pack_1d_result_dict(result, model.compute_errors()); @@ -696,29 +692,26 @@ void define_fit_bindings(py::module &m) { py::array_t y, py::object y_err_obj, int n_threads) -> py::object { using namespace aare::model; - using namespace aare::func; // ── Polynomial of degree 1 ─────── if (py::isinstance>(model_obj)) { const auto &mdl = model_obj.cast &>(); - return fit_dispatch(mdl, x, y, y_err_obj, - n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, n_threads); } // ── Polynomial of degree 2 ─────── if (py::isinstance>(model_obj)) { const auto &mdl = model_obj.cast &>(); - return fit_dispatch(mdl, x, y, y_err_obj, - n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, n_threads); } + // ── Gaussian ─────── if (py::isinstance>(model_obj)) { const auto &mdl = model_obj.cast &>(); - return fit_dispatch( - mdl, x, y, y_err_obj, n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, n_threads); } // ── GaussianErfcPlateau ─────── @@ -727,9 +720,8 @@ void define_fit_bindings(py::module &m) { const auto &mdl = model_obj .cast &>(); - return fit_dispatch( - mdl, x, y, y_err_obj, n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, + n_threads); } // ── GaussianChargeSharing ─────── @@ -738,9 +730,8 @@ void define_fit_bindings(py::module &m) { const auto &mdl = model_obj .cast &>(); - return fit_dispatch( - mdl, x, y, y_err_obj, n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, + n_threads); } // ── GaussianChargeSharingKb ─────── @@ -748,8 +739,7 @@ void define_fit_bindings(py::module &m) { model_obj)) { const auto &mdl = model_obj.cast< const aare::FitModel &>(); - return fit_dispatch( + return fit_dispatch( mdl, x, y, y_err_obj, n_threads); } @@ -757,16 +747,16 @@ void define_fit_bindings(py::module &m) { if (py::isinstance>(model_obj)) { const auto &mdl = model_obj.cast &>(); - return fit_dispatch( - mdl, x, y, y_err_obj, n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, + n_threads); } // ── Falling Scurve ─────── if (py::isinstance>(model_obj)) { const auto &mdl = model_obj.cast &>(); - return fit_dispatch( - mdl, x, y, y_err_obj, n_threads); + return fit_dispatch(mdl, x, y, y_err_obj, + n_threads); } throw std::runtime_error( diff --git a/python/tests/GaussainErfcPlateau.ipynb b/python/tests/GaussainErfcPlateau.ipynb index c189e09..0397fea 100644 --- a/python/tests/GaussainErfcPlateau.ipynb +++ b/python/tests/GaussainErfcPlateau.ipynb @@ -46,18 +46,8 @@ "from pprint import pprint\n", "\n", "import sys\n", - "sys.path.insert(0, \"/home/ferjao_k/sw/aare/build\")\n", - "\n", - "try:\n", - " from aare import GaussianErfcPlateau\n", - "except ImportError:\n", - " import aare\n", - " print(\"Could not import GaussianErfcPlateau directly.\")\n", - " print(\"Available Gaussian/Erf/Plateau-like names:\")\n", - " pprint([name for name in dir(aare)\n", - " if any(token.lower() in name.lower()\n", - " for token in (\"gauss\", \"erf\", \"plateau\"))])\n", - " raise" + "sys.path.insert(0, \"/home/ferjao_k/aare/build\")\n", + "from aare import GaussianErfcPlateau" ] }, { @@ -85,7 +75,7 @@ { "data": { "image/png": - "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", + "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", "text/plain": [ "
" ] @@ -240,14 +230,14 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "id": "3f1f13e0", "metadata": {}, "outputs": [ { "data": { "image/png": - "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", + "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", "text/plain": [ "
" ] @@ -274,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 7, "id": "1359c6b6", "metadata": {}, "outputs": [ @@ -282,8 +272,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "SciPy curve_fit : 3.746 ms\n", - "Aare Minuit2 : 0.355 ms\n", + "SciPy curve_fit : 1.273 ms\n", + "Aare Minuit2 : 0.159 ms\n", "\n", "SciPy bench params: [1.19916 1.000479 1.005638 0.64249 ]\n", "Aare bench params : [1.199158 1.000478 1.00564 0.642494]\n" @@ -359,7 +349,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.5" + "version": "3.11.15" } }, "nbformat": 4, diff --git a/python/tests/GaussianChargeSharingKb.ipynb b/python/tests/GaussianChargeSharingKb.ipynb index 4ae15fc..2a4c820 100644 --- a/python/tests/GaussianChargeSharingKb.ipynb +++ b/python/tests/GaussianChargeSharingKb.ipynb @@ -396,7 +396,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.5" + "version": "3.11.15" } }, "nbformat": 4, diff --git a/python/tests/test_Minuit2_gauss.ipynb b/python/tests/test_Minuit2_gauss.ipynb index 0f35459..0a6bdd2 100644 --- a/python/tests/test_Minuit2_gauss.ipynb +++ b/python/tests/test_Minuit2_gauss.ipynb @@ -3,7 +3,7 @@ [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "efef8e20-6571-4561-8f0b-6048b57907de", "metadata": {}, "outputs": [], @@ -14,14 +14,14 @@ "import matplotlib.pyplot as plt\n", "from matplotlib.gridspec import GridSpec\n", "import sys\n", - "sys.path.insert(0, '/home/ferjao_k/sw/aare/build')\n", + "sys.path.insert(0, '/home/ferjao_k/aare/build')\n", "from aare import fit_gaus # lmfit\n", "from aare import Gaussian, fit # minuit2" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "35772e2c-37c6-4986-a9c0-7dca4a034827", "metadata": {}, "outputs": [], @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "06c8fddb-56d9-4f84-8b21-4ffd8b7bd26f", "metadata": {}, "outputs": [], @@ -95,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "dc0b52b6-9fc3-453d-b6eb-e325a2b8342e", "metadata": {}, "outputs": [], @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "9cc999b9-e0d8-4deb-ae29-e8bd0141534b", "metadata": {}, "outputs": [ @@ -190,14 +190,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "a98a41f3-fd2e-4bfc-9ec6-0d23dd38e896", "metadata": {}, "outputs": [ { "data": { "image/png": - "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", + "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", "text/plain": [ "
" ] @@ -228,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "1f6bc651-80c1-41dd-8a05-7f15aba006aa", "metadata": {}, "outputs": [ @@ -275,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "5a417145-ce42-4c3a-a7bf-05ff97ba0450", "metadata": {}, "outputs": [ @@ -285,8 +285,8 @@ "text": [ "Method time (ms) med|dA| med|dMu| med|dSig|\n", "--------------------------------------------------------------------------------\n", - "[lmfit (LM) ] 189.58 ms 6.272 0.0940 0.0949\n", - "[Minuit2 (obj API) ] 124.59 ms 6.272 0.0940 0.0949 chi2/ndf=880.9946\n" + "[lmfit (LM) ] 90.30 ms 6.272 0.0940 0.0949\n", + "[Minuit2 (obj API) ] 59.60 ms 6.272 0.0940 0.0949 chi2/ndf=880.9946\n" ] } ], @@ -336,39 +336,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "55ecc77c-0823-408d-a811-8e4f4900f332", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Minuit2 (obj API) n_threads= 1 456.26 ± 10.76 ms (45.6262 ± 1.0762 μs/pixel)\n", - " lmfit (LM) n_threads= 1 752.77 ± 108.16 ms (75.2771 ± 10.8165 μs/pixel)\n", - "\n", - "\n", - " Minuit2 (obj API) n_threads= 2 238.34 ± 26.57 ms (23.8345 ± 2.6566 μs/pixel)\n", - " lmfit (LM) n_threads= 2 410.95 ± 84.96 ms (41.0945 ± 8.4959 μs/pixel)\n", - "\n", - "\n", - " lmfit (LM) n_threads= 4 205.44 ± 35.26 ms (20.5445 ± 3.5259 μs/pixel)\n", - " Minuit2 (obj API) n_threads= 4 139.22 ± 14.06 ms (13.9224 ± 1.4060 μs/pixel)\n", - "\n", - "\n", - " Minuit2 (obj API) n_threads= 8 130.12 ± 3.27 ms (13.0118 ± 0.3269 μs/pixel)\n", - " lmfit (LM) n_threads= 8 199.97 ± 6.88 ms (19.9968 ± 0.6877 μs/pixel)\n", - "\n", - "\n", - " Minuit2 (obj API) n_threads=16 134.81 ± 10.13 ms (13.4807 ± 1.0130 μs/pixel)\n", - " lmfit (LM) n_threads=16 188.32 ± 9.86 ms (18.8322 ± 0.9860 μs/pixel)\n", - "\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# ===============\n", "# THREAD SCALING\n", @@ -402,33 +375,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "d5f3152d-be84-420e-8045-9c42ac5c24cb", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": - "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": - "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# =============================\n", "# FIGURE 1: Residual histograms\n", @@ -549,7 +499,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.5" + "version": "3.11.15" } }, "nbformat": 4, diff --git a/python/tests/test_Minuit2_scurve_3d.ipynb b/python/tests/test_Minuit2_scurve_3d.ipynb index 676560f..c7a4409 100644 --- a/python/tests/test_Minuit2_scurve_3d.ipynb +++ b/python/tests/test_Minuit2_scurve_3d.ipynb @@ -14,8 +14,7 @@ "import matplotlib.pyplot as plt\n", "from matplotlib.gridspec import GridSpec\n", "import sys\n", - "# sys.path.insert(0, '/home/ferjao_k/sw/aare/build')\n", - "sys.path.insert(0, '/home/kferjaoui/sw/aare/build')\n", + "sys.path.insert(0, '/home/ferjao_k/aare/build')\n", "\n", "from aare import fit_scurve2\n", "from aare import FallingScurve, fit" @@ -30,7 +29,7 @@ { "data": { "text/plain": [ - "'/home/kferjaoui/sw/aare/build/aare/__init__.py'" + "'/home/ferjao_k/aare/build/aare/__init__.py'" ] }, "execution_count": 2, @@ -45,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "id": "35772e2c-37c6-4986-a9c0-7dca4a034827", "metadata": {}, "outputs": [], @@ -72,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "id": "06c8fddb-56d9-4f84-8b21-4ffd8b7bd26f", "metadata": {}, "outputs": [], @@ -128,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "id": "dc0b52b6-9fc3-453d-b6eb-e325a2b8342e", "metadata": {}, "outputs": [], @@ -155,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "13bcd5a6-8f95-4300-a002-04023d0f9bab", "metadata": {}, "outputs": [ @@ -187,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "id": "1f6bc651-80c1-41dd-8a05-7f15aba006aa", "metadata": {}, "outputs": [], @@ -217,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "id": "5a417145-ce42-4c3a-a7bf-05ff97ba0450", "metadata": {}, "outputs": [ @@ -227,8 +226,8 @@ "text": [ "Method time (ms) med|dp0| med|dp1| med|dp2| med|dp3| med|dp4| med|dp5|\n", "--------------------------------------------------------------------------------------------------------------\n", - "[lmfit (LM) ] 1030.91 ms 22.1470 0.2336 0.2184 0.3132 14.3955 0.3997\n", - "[Minuit2 (analytic) ] 435.57 ms 17.1099 0.2147 0.2293 0.2664 11.9425 0.3518 chi2/ndf=596.8385\n" + "[lmfit (LM) ] 359.31 ms 18.6946 0.2249 0.2177 0.2663 11.9347 0.3635\n", + "[Minuit2 (analytic) ] 257.18 ms 17.1035 0.2147 0.2293 0.2668 11.9449 0.3518 chi2/ndf=596.8385\n" ] } ], @@ -289,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "id": "55ecc77c-0823-408d-a811-8e4f4900f332", "metadata": { "scrolled": true @@ -299,20 +298,20 @@ "name": "stdout", "output_type": "stream", "text": [ - " Minuit2 (analytic) n_threads= 1 1616.61 ± 22.09 ms (161.6606 ± 2.2089 µs/pixel)\n", - " lmfit (LM) n_threads= 1 2927.48 ± 36.18 ms (292.7479 ± 3.6182 µs/pixel)\n", + " lmfit (LM) n_threads= 1 1404.39 ± 11.48 ms (140.4392 ± 1.1478 µs/pixel)\n", + " Minuit2 (analytic) n_threads= 1 1022.42 ± 1.69 ms (102.2417 ± 0.1690 µs/pixel)\n", "\n", "\n", - " lmfit (LM) n_threads= 2 1471.15 ± 23.35 ms (147.1150 ± 2.3353 µs/pixel)\n", - " Minuit2 (analytic) n_threads= 2 825.64 ± 68.98 ms (82.5642 ± 6.8976 µs/pixel)\n", + " lmfit (LM) n_threads= 2 708.78 ± 6.14 ms (70.8775 ± 0.6142 µs/pixel)\n", + " Minuit2 (analytic) n_threads= 2 521.15 ± 0.96 ms (52.1151 ± 0.0962 µs/pixel)\n", "\n", "\n", - " Minuit2 (analytic) n_threads= 4 507.67 ± 93.00 ms (50.7666 ± 9.2997 µs/pixel)\n", - " lmfit (LM) n_threads= 4 965.44 ± 137.53 ms (96.5436 ± 13.7534 µs/pixel)\n", + " Minuit2 (analytic) n_threads= 4 256.73 ± 2.40 ms (25.6728 ± 0.2399 µs/pixel)\n", + " lmfit (LM) n_threads= 4 352.83 ± 0.77 ms (35.2833 ± 0.0767 µs/pixel)\n", "\n", "\n", - " Minuit2 (analytic) n_threads= 8 352.28 ± 41.26 ms (35.2275 ± 4.1260 µs/pixel)\n", - " lmfit (LM) n_threads= 8 555.64 ± 25.59 ms (55.5636 ± 2.5588 µs/pixel)\n", + " lmfit (LM) n_threads= 8 226.62 ± 1.48 ms (22.6616 ± 0.1479 µs/pixel)\n", + " Minuit2 (analytic) n_threads= 8 164.39 ± 0.51 ms (16.4386 ± 0.0509 µs/pixel)\n", "\n", "\n" ] @@ -356,14 +355,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "id": "d5f3152d-be84-420e-8045-9c42ac5c24cb", "metadata": {}, "outputs": [ { "data": { "image/png": - "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", + "iVBORw0KGgoAAAANSUhEUgAABjUAAAN2CAYAAACxdwtsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd0VNXWwPGdQioBQkjo3RCQoogIogKKFBXQh4oVbE95gigKYsGCigqIgB9gQyyAgKgPlfcUxQYqVREVxYCCCNIC0tOT+dY+vDvMnUxCyiRT8v+tdTOZO3fu3DYzZ84+Z58Qh8PhEAAAAAAAAAAAAD8X6usNAAAAAAAAAAAAKA6CGgAAAAAAAAAAICAQ1AAAAAAAAAAAAAGBoAYAAAAAAAAAAAgIBDUAAAAAAAAAAEBAIKgBAAAAAAAAAAACAkENAAAAAAAAAAAQEAhqAAAAAAAAAACAgEBQAwAAAAAAAAAABASCGgAAACjUjTfeKCEhIWbq3r17sY+ULms9T9fhC19++aVzG3T6448/fLIdQGFef/112zXqC66vr9sDBNr3DQAAqHwIagAA4KfcK2Rdp6pVq8qpp54qw4cPly1btvh6UwOCv1bcFXaew8LCpEaNGnLGGWfIfffdJ7t37/b1psLHli5dKnfddZd06dJFYmJiShSwWbhwofTs2VMSEhIkMjJSmjRpIrfccots3ry50Ofs2rXLvF5ycrJER0dLfHy8nHvuufLyyy9LXl5eOeyhyMyZM+Xmm2+Wtm3bSnh4uHP/dHuLkpmZKRMnTpQOHTpItWrVJDY2Vtq0aSMPPfSQHDp0qNDnffvtt3L11VdLvXr1zHGpXbu29O/fXz799NNy2Dt4cvDgQZkwYYJceeWV5jy7XtcnC4iW9hotzfsBgcn1mho7dqyvNwcAAHhJuLdWBAAAKs6xY8dk48aNZnr11Vfl/ffflwsvvJBTEETy8/NNZez3339vptmzZ8uaNWukYcOGFbodWuGrlcOqol8bdjNmzDDv9ZJwOBxy0003yRtvvGGbv23bNvPZMW/ePHn33Xfl4osvLlDZ37t3b/n7779tgYNvvvnGTP/+97/lvffek6ioKK+epnvvvbfIIIQn+/fvNxXU+j5x9fPPP5vpzTfflM8//1yaNm1qe/yVV16RIUOGmPeaZe/evbJ48WIzPfLII/LYY49JeerYsaM888wzUplpQO7+++8v8fNKc42W9v2AisH3DQAAKC6CGgAABIirrrpKzjzzTMnOzpaVK1fKf/7zHzM/PT1dBg0aZCqGtMWpt+Xm5kpOTo5pBYuS0Qo27XFRpUqVEp/nw4cPmwq5n376yczXnhpTpkyRyZMnV+hp6NOnj5nge9rSuEGDBub60FboWvFenECIawWuVhpqL68FCxbIL7/8Yq7Ra6+91vyvvRWsoOkVV1zhrCzWYJZWBOs1OGvWLPPaH3/8sTz88MMFKuR1ff/85z9lzJgx0qpVK4/bpM9r3769DBgwoMBj+n7R5+k+6rW/fv36k+6jBiasgIZ+Tul9rcjWXh8a8NDPxmuuuUZWrFghoaHHO6rrem+//XZnQKNz587St29fUxn+0UcfmXmPP/64nHXWWXLJJZdIeWndurWZKjs9X+3atTPnff78+XLgwIEily/tNVqa9wMqDt83AACg2BwAAMAvffHFFw79qram1157zfb4ddddZ3v8s88+M/OXLl3quOmmmxynn366o3bt2o6IiAhHdHS045RTTjHzf/zxxwKvdcMNNzjX061bN8fvv//uGDhwoCMhIcEREhJitkW9+OKLjiuuuMKRkpJiHgsPD3fExcWZ17rvvvscaWlpBdbduHFj57offfRRx4cffujo3Lmz2ab69es7xowZ48jOzjbLvvDCC45WrVo5IiMjHU2bNnU8+eSTjvz8/ALrzM3Ndbz++uuOHj16OGrVqmW2IzEx0dG/f3/H559/bltW98f1OLlPun2udu7cafalbdu2jqpVq5ptSU5Odtx9992OXbt2FdgW1/XrcVy3bp3joosuctSoUcPM27p1a6nP88GDB835sx7r3bt3oeu48sorHQ0aNDDLV6tWzXHuuec6XnnlFUdeXl6B5ZcvX+647LLLHPXq1XNUqVLFERsba45Dnz59zDnS1y3s2nD373//29GxY0dHVFSUIykpyXHzzTc79uzZU+C4FLa/7sensGOh6xw1apTj/PPPdzRq1MicG912fc2ePXs65syZU+BaKeq1jh496njssccc7du3N+uyrqHTTjvN8c9//tPx0UcfOfxNenq68389NkUdR+t9oufYWubaa691PrZ//37z3rUe02ve8vzzzzvn6/v/119/dT724IMPOh/Tc/7333/bXvOqq64yj9WpU8eRmppaYJseeugh87ieu5UrVxa5j67Xnvv71PLLL7/YjsPLL7/sfOyTTz6xPeZ6TvXzzZqvnzVZWVnOx8455xznY506dXIUh/u1pp+hU6ZMcX6e6WfdyJEjHUeOHLE9z/08WkaPHu2cFx8f7/jrr7+cj3366afmvFiPv/3227Z16mfQjTfeaPZLX1uv7zPPPNPx7LPPOjIyMgpse1HfM3pf38vW571+rrVo0cIcvxkzZji8QT//c3JyPH5nuH52uCrNNVra90NRdLv1POt3WvXq1R1hYWGOmjVrOk499VTHoEGDHPPnzy/wHP2e1M9Z/dzU5+hntn52X3zxxY7333/fudzmzZsdd955p7ke9fGYmBizrF5L/fr1cyxevLjAut2vJz3fY8eOdTRv3tw8V4+tfu55+l4ojPt3+KpVq8xnrh4vvbb0e0OvOU927NhhrvvWrVub7xm9Hps1a2a+J4pTFinqOtX383nnnWeOix7Hf/zjH44//vjD47oKmyz6vNtuu82Uk/Sa0e3Ua6VLly7mu18/ZwAAgH8hqAEAQIAGNaZPn257/M033zTzhw0bVuSPeK3Y0MCHK9cf/1qBrxXFrs+xghpaMVHUurWyxbXyzb1CRCuQXSvjXCuu7rrrLo/rfPjhh23rO3bsmKnYLmo7NBhSmqDG119/bSqkCltWj8v3339v2x7X9ev+aQXLySqbS3KeXbfHtRLOopVvRe3fJZdc4gwaWRWiWvFW1HM2btxYrEomDXJ5er5WpmqlnjeDGmvXrj1pBZUG7Yo6tq6v1b179yLXpZXz/qw4QQ2tfHRd5t1337U9rhWj1mNa+W7RSkprvgb3XH333Xe2db711lu2x7/99ltnQE8rBbVi1vLII484n6fBUdeKbE+KE9QYP368bXu0ctqiQS4N8FmP3X777c7Kba1gteYPHz7ctk6t/HddpwbUTsb9Wrvgggs8Xlda+Z2ZmXnSoIa+ZzUQ4fo+VhoUcf1MveWWW2zbMW3atCLf31qR7hq0LOo9pxXYRb1HNGheHooT1CjNNVra90NRTlZx7h4U021w/351nVz3V4NVJ/vM0wCFK/fryTVA5zpp4Kc050OD5RqQdF+ffu+tWLHC9rxly5Y5Pws8TboebZxQmqCGBhs8rVODN1bgrrhBDX1/a0C7qOW0wQUAAPAvpJ8CACBAaQoqV3Xq1DG3Ooj4+eefb1Ka1KxZ06Rj0RQs//3vf80YHJq+6s477zTpNTzRgVI1zY0O2qqD9WrqFh10V+kguqeccoo0a9bMrFuX++uvv8ygq/oa+v+4cePk+eef97huTRGj26VpZzTFi+ZEV1Y6kHPOOUcuuOACkwPfGgD9ueeeM4P9RkREmPsjRoyQL774wvyv6bY0VYhuj65bc6grTX2jaUx69eplUsxoWhnN1e+e4klVr17d3Goe/3/84x/OdCa6zoEDB5rUUbp/qampJt++brseR0+pvnQbdHkd3LZ58+Ymn39JUk+50vRTOqC5a7543R5Xmv9dB9i1aJocTaOj50GPaUZGhjnvjz76qDz11FNmGdcBdFu2bGnOsw7I/Oeff5qUPOvWrSvW9u3YscOcC0tcXJwZaFfT+2hu+q1bt4o36Xr12tExCPQ61EHUNVWMHnNNw6R1Xq+99pr861//MimDiqLnTwdot9Y7ePBgadGihezbt89st/VYoPvxxx9t9/WaLuy+Xt9ZWVnmunZ9XlHPsV7D9brUgbo17Y+OcbFz507zWbRs2TKZO3euSeek9D2kKYb0uvPmPup7WT+XLPr5pONo/PDDD7Zl9bNF0xeVZB9LOmaRjuFx6aWXymmnnWY+69auXWvmr1q1yqRD0s+0oujnhr6/NU2Xbqu+j/XzQD/3dfwHpdesfj5aNHWWfrYfr/8VM2C2brcOxK2fB5rSSbdDPxN13SfzwgsvOP/v0aOHOZe6Ldu3b5evv/7afL74Smmu0dK+Hwpz9OhRc11bLr/8cjnjjDPMd4meI73u3T/TdRB6/R6x6PtEP7P1HLl/7ug1oOvT91RiYqJUq1bNvKaeZ+s78IknnjCfu/Xr1/e4jbqsfsbr97am5bJee9q0aeZ7wfpeLS4973rd6Tr1O2DOnDkmhZumwbzhhhvk119/NZ+puj/6faq3SssQN998symP6HN0gHdNa6mp6nQftaxREppKTsd60vfYV199JcuXLzfzf//9d1m0aJFJN2eNz6HffVY6Mz3eWi5wpWOopKWlmf91oHlNY6YDyOvnl+6Prh8AAPghX0dVAABA8Vr+asvxZ555xvRCcG1RarWYdU0roqklVq9ebVpBTp061TzvnnvusT3nzz//dC7v3qJRU3sURntKaGt/TfMyefJks+5LL73U+VxNLVFYK09NYXLo0CEzX9OFuL5mmzZtnD0K/vvf/9oes9JUaCts11bI8+bNs73W1Vdf7XxM02MUpzWy5bnnnnM+ri1pXVszHzhwwKSkcO8V46kniKbXKst59jRpK1g9zu60Z4i1jKbOKKwXhaYIsdLraIoua76n1CiaYkvP8clazj799NO2bdRrwvLNN98U2vq4tD01LNu2bXO88847pqfSpEmTzHHRHkLWcx5//PGTvpamSnFtke2etkpb8rumMQnUnhru50hTInlKBWVNVno1Tb1izdMUOu7HxvU5Q4YM8bh9mlrKSuejqWGs5fX6c+05VNaeGpqSzVqmYcOGBR7XluXW45o2z9o2132YNWuW7Tl6Lbs+7ul94s79Wrv11ludj+n+uvZy01RCJ+upYdFtsx5z7V2irdy1V4wrTb9jPa7HxfW6XrJkifMx7S23ffv2k77nXHu5eEq95349VWRPjdJco6V9PxRG01pZy+qxck1hpvT4b9myxeN3jE7ay8id6/IWTeO2YMEC0wvH+sxz7RE4e/bsQq8nTdlnee+99zx+r5bkfGi6R9fvRi2PeEqDqSm5XOd//PHHzufocXft7aHp/kraU0O3SVMIWu8v194vWtYpbPu195E7LccU9Xmmr7N79+5iHSsAAFBx6KkBAECAeOutt8zkaYBVbYWrt2rp0qWm9aO2vC+KtrLUwVXdaUvn2267zeNzdJBqbd2prUULo70ECqM9JrS1qWrSpIntMR301erVoC1BXVmtLFevXu3sZaC0l4ZOhbXkLAlt0WrR1qzaE6Awum5Pr6utsi+66CLxNm3xqq2rXWnLWNdBlLUHhk6e6PnSVsraO+W8886TDz74wMzXHiUvvfSSOd4pKSmmp4z2ctAW7idj9bJR2nNCW3JbunTpYlrIe7O3hvYE0pbA2mL9ZNf1yehA1NoSV9epvTa0FbO2iNfjoIMVa+v2xo0bF2u7Jk2aJGWl10x5DBZttdgv7n1P5700z1Ha+lx7KOh1oS3XlbaQfvvtt0vde8kT1+1x3zb3eda2euO4nMygQYOc/+v+ak8B/ey0rlH9jElKSjrperR1u/Z80d5irr1LnnzySdOCv7DPMH2ONSi6O90/7TGin7lF0c8K6/2mLd47deokycnJ5lrVXhv6vvEHxT1/3j7v2qpfj4X2yNNeGPqZpz3J9BhpzwO99nWep/OjPdtGjRpVYJ2uy2svyeuuu+6k32VFfeYNGTLE+b9+xrs62WDsnmhPE6t3o7r++utNz0jX7wXtbem6zXqdu/aO0B4x2ovI6m1S0u9q63WtHqT6/tLjZvVCKel+6feenms9//odqr2ZdPB4PV76nanXun7HAQAA/0JQAwCAAKQpHLTSVSsP7r77bmflkqZLuOyyy0yF98loag1PNG1SWFhYgfnvvfeejBw5stTrVa4pMtzTerg+5p6WRtNbKNdUTCejFYCaHkWPVXGUZN1Wqgp37sGY0tDUWBoc0Yqe//znP2aepuPSChutqLQq2rTixlMl7sm2WVNGaYBD08/oudKUJ65pT7TyUgNjVjqzwlhpRZSnylmtBCpOUMN1H4q6djTFyskCGidbh0UDgFpJrGlGNPin6YisdGdKU7KMHz/evLdOxjWtWWnVqlWrXIIaGrhxdeTIEdt9rYi1aAW4FcjTwKamhznZc6xlC6OVuK7nQ1O56GeUe0DTW/vovq3u22tta0mOi+vzSsL9PeFeKarv3+IENdQdd9xhrlfX61ffD+XxGeaefkqDMRoA0QDghx9+aHtcH9M0YoUFT8pTaa7R0r4fiqKfo5rqSNM56rX9/vvv29Zx1113mcYA7udHGxR4+p51pd/lVuq00n7muQZn3b9zre9Vb1/XrreenuP+vNIEV9yDzq77VtL90kC+nqOHH37YNADQFIyuaRj181mDsd27dy/xdgIAgPJDUAMAgACh4wVoy/qi6NgCVkBDK78133e/fv1Mq1CtdClOxWlMTIzH+a69ROrVq2fyUGvrdq1M0DE0hg0bdtJ1F9VCuzj59bVlrHuFclEVgyXJ2e+67kaNGsnw4cMLXda9xevJjl1J9OnTx3medXwI7UmhNNCgwQ1toarcK9x0nIKzzz77pNusx2T27Nny7LPPmsCJ5o7XSfOQa+XShg0b5P777zf5+4vi+vquOeIte/bs8fg89wpQ17z8Op5LYQEqK8CjNFe6jkug16GuTyulrDELiksDghp00cor7fHy22+/meOh+dN13BltRa2tkjXIF6i014krzTd/+umn2+67BuSsikF9nlVh7LqMp/vur+Hag+W+++4z/2urbD3OGkDSikEda6C4PWFORl9fK9aV9gjRyner8lorN10Da9a26jnVVt5Wz4fS7mNR9D3h+jnh/n4oToW50nFj3Htp6byhQ4fKggULCnyGWcEKbV1+8cUXF7reoj4rXCvedQwPfW+sWbPGvD81IKo9vXJzc02gRXsZnex7qTyU5hot7fvhZNuhPTV++uknc43rMdJb7aWk19+UKVPM54he967BMR2XRHsdFhbY0M9k14CGBlj1c1nH1tDvdv3eK05gyvU7tzQ9jty5f9YXdl27fp+e7PvB/Xu9ONzLEmXdNw32aw9VDeDp+dTzuGTJEnOrYy3pNa49ZwAAgP8gqAEAQBDRCj2LpojQyl+rEtm9Aqws69a0J5peRmnFjbZirAia/kQrgawUVNoLw1MKDw3gaKtY14oPrczXijjlqSeLpkyy9kMrXHTQbU1T5Eqfr5XrWklbEbS3gJ43K33PY489ZloF6zHQSlnt0WFVfGlAQiu+3CvJtOJLW8xbg+BqZZlWVmrlmA6y6tpD45577jH/f/fddyfdNk3LoYEt63h99tlnzhRUGhworJeGe2WuphTTVB9KAxWe6P67ph3TQWobNGhg/tf0UcVpzexeKazbp+dX98MaNF57jWgFm76eXtca7DhZUKMkvWUqmu5X3bp1nZW/77zzjhnM2LouXHvoaMWrRQOh2itIaQWf9rDQQeWVe48BHXjXnbZ6tnqwaKW3Bsy0clzfUzqAshXY0OBhWel2P/DAA877uo9Wyh2tWHZNlWfto75HdLt0WSsYrEEYrcTW82nNVxowK03qGR0MWdM3KR0Q2fW46bVb3HXq55ueA6WBIK0g1kCgBpl1HzQlm+tnmNVTYPfu3SYYYqXoce2NoMfFtTK/MPq+0jRK2hPQNdWUfm5YKez0s8IKaowdO9Z8RlnbWp6VwKW5Rkv7fiiKfkbosdTj5DrYtX42WwOT6zHSa17THFnbpr1ENODh/v2l7w89dq7ft0qD2VYAXwehL05AozzoeddryEoj6TpQurI+S12/T/Wa/eSTT5wpqLRXnA44btFly5NrOcDTd7/2sNHPBH1ParBbJ/X999+bQcyt8+IaMAUAAL5HUAMAgCDi2jJY0wNppZdWrGmliqaPKuu6tbeA0jRAt956q0kZpf+7jq9QnrRCQSvQZs2aZe4//vjjpmWlBli04kJbgmsFvgY1NH+9a/BBt1UrJpT2UtAKCg2KaG8TrYzX9Y4bN87M13Qeuk5Nr6K5urUSUdeplV4aLNEK8dK0Li0pDQBoD5innnrK3NcW01qZaY3noRViVu5+zU+uFWk6bokGtLQiSc+LVibrcdBUJkor0rTC1cr3rhU5uk/ae8P1dU9Gc71rJaaV+kTH/dCxXLTF7Kuvvlro87TisWrVqs7KZt0/rWTVCtDCeltoZZ5uk5XySlO6aIWTrkN7lGjPipLQ9WggRXsuaaW19vjQa0Er2qwAUnGPQ0XSc28dI6ui26LXiFXRqJXZGozRQJ72ltBWyK6BTd137d1gVfDp81x7JmlF+YQJE0xrcq3k18pIHdtBK/+s9571Ou6pmaZOnepMU9e7d28T0NBggVbqakBQr08913pf30/ugQ3dDytNj+vnigbtXCuArbFMdF/02rY+3zSwp4E7rcx+8cUXbZWtuj0WDYTotmmwzAq06LZpTx3tlWBxHS+gJGbOnGkqnrUlv17frudLPzuLQz9bZ8yYYf7X4LSmOtLzb51PPWf63rYCb3rctdJZz5kG+zRQqT24NH2OHlOtgNf909RymubuZHQZfT9orw/9/NRzrb0ZXNNQeeM9oudWxwhxvW/Ra8A677qfVq+V0lyjpX0/FEW/J/TzQ79n9Vafq8EgK6Dheoz0O0b30+q5oIE//U7VdehnmZ4b3Rb9TNMgkp5zK5WSBjW0kYIGZE7Wi648aa8FHTdEA8s6lod+l1h0m/Vasc7PE0884Xwv63Wo50c/Z/U5Guizzklxj3Vp6bWr351Kj51+Nuh50utJv7eWL19uvs/0vaSBbj2P+rnw73//25aSsLipLAEAQAWpwEHJAQBACXzxxRfaBNw5vfbaayd9TnZ2tqNt27a251nTDTfcYLuv67e4PtatWzeP6968ebMjLi6uwHrDw8Md1113nW2eq8aNGzvnP/roo7bHCtu/rVu3FrqtR48edZx//vke99F1cn+tu+++2+Nyw4YNcy7z1VdfOWrWrHnSdev2WfR4uR5jb5/nvXv3OmJiYpyPt27d2pGfn+98/N577z3p9rqe0yFDhhS5bGhoqGPRokXFujamT5/ucR316tVzJCcnF3pcHnjgAY/P69WrV6HHYvz48R6f06ZNG0eHDh08vpb7sbXO265du056zM466yxHTk6Ow5+4v4cLm1zfL3l5eY7rr7++0GUjIyMdH3zwQYHXWr16taNGjRqFPu/CCy90pKenF3jes88+6zyXGRkZBR7//PPPzfXctGlTx7Zt2wo87vp5UdTkKi0tzdGuXbtCl23UqJHjt99+K/BaL774oiMkJKTQ5z344IPFPjfu19oll1zicZ0dO3a0HRe9xj3t1+7dux2JiYnO+aNHjzbz9b3v+vnXqVMn23X6f//3f46wsLAij50eY1eFvedSUlKKXI9+Vrp+FupnbmGvURT3z/vifI6V9hot7fuhMLp8Udus1/nBgwedy69atcqRlJRU6PKun1//+te/PC7To0cPR/369T1+1xV2PXk6zq6fE0VxfU/qa3va5+joaMfXX39d4L1evXr1QvdVyw6zZs2yPaeo75vCrtOTfQ8/99xzHl9f36Nq/vz5J7327rnnnmIdKwAAUHEqflQ3AABQbrS3gqam0Bah2qtBW0hra92XX37ZtKovC22FqS0atUWsjh2hre27detm0g5deOGFUlE0ncqnn35qehbotmgaJd1vbY2sPRV037UFtpXP36ItZO+8807TarOwPObaUlNbVGsrbu3BoWORaAtNbU2uqUN0IFHt9eLNgY5PRvdPe0BYdPt0/ywTJ040qXy0Fa9up55zbYWqPSI0TYy2GHdNx6IDDOux6dq1q0lDpa1WdR/1f219q+uyenWcjPay0BQumo5MX1fPgfYc0ZRS2tq1MNojRnvZaJoVPXfaYlbPj+u4Ge50m7XVuua61+doa3Nt8a7bq9diSWgvm+nTp5tUXtoyWlty6zWhx01b9GsLY72uSzImi7/S1t7aMlpbomsrat1363zre0VblWsqH3fag0XHV9FBqvX8WNeVjsWgA0hr7wNPLZc1hZleb5oGSa8td7oN2tJfexZ5I/2U0utOe2w9/fTT5n2rnxG6bXpu9b1cWBoxTVOlz9PrXq8n63NE02RpaiPX3gMlNW3aNHON6Tbo8db3g/Yi0evK03FxpfW3em6sFEPao0jfL0p7Qmlrc6tXjr7XXD/btdW79m7Q97l+Zutr6fFITk424/U899xz5nO8OPR46rg++v62jo9+9utni47p4f5Z6Dp2gqYKLG+luUZL+34ojL7OTTfdZHrk6Ge1fmbo55HeHz16tDk/2nPO9bjoNj/yyCPmuOr2Wp9n2pNIew64XkOun5P6ftHeHZouzVefTfodqb0h9VrS70fdV/0e1l4m+h3pSo+vjjWiPWO0B4SeCz1Hes3osdbrVHtvlDf9ntL3iKZg9HTcdJ/0va7ve72OdL90OT2f2qNR329WzzAAAOA/QjSy4euNAAAAAIBApam0rNQ7SlPUVWTw0x9oAEfTXmkQRce4sMa9QWDT69hK3ahpHcvaQAIAAMAb6KkBAAAAACg17VWiAQ2lPdoIaAAAAKA8EdQAAAAAAJSapoFTmppKU5ABAAAA5SnwEwUDAAAAAHzmiiuuMGOBAAAAABWBMTUAAAAAAAAAAEBAIP0UAAAAAAAAAAAICAQ1AAAAAAAAAABAQCCoAQAAAAAAAAAAAgJBDQAAAAAAAAAAEBAIagAAAAAAAAAAgIBAUAMAAAAAAAAAAAQEghoAAAAAAAAAACAgENQAAAAAAAAAAAABgaAGAAAAAAAAAAAICAQ1AAAAAAAAAABAQCCoAQAAAAAAAAAAAgJBDQAV7v/+7/8kJCRE2rRpU+Z1HT16VEaMGCH16tWTqKgoOf3002XBggVe2U4AABCcZYgjR47I6NGjpVevXpKYmGjWOXbsWK9tJwAACN5yxOeffy4333yztGzZUmJjY6V+/fpy6aWXynfffee1bQVQNIIaACrcq6++agoSP//8s6xevbpM6xowYIC88cYb8uijj8pHH30kHTt2lGuuuUbmzZvnte0FAADBVYbYv3+/vPzyy5KVlSWXXXaZV7cRAAAEdznihRdekD/++EPuuusu+fDDD+W5556TvXv3SufOnU3AA0D5I6gBoEJ9++238sMPP8i9994rERERMmvWrFKvSwsPS5culeeff16GDBki559/vsycOVN69uxp1p+Xl+fVbQcAAMFRhmjcuLEcOHBAli1bJk8//bRXtxMAAAR3OWLGjBkmeHH77bdLt27d5IorrjB1EwkJCfLUU095dbsBeEZQA0CF0oJDWFiY3H333dK3b1+TKio9Pd35uLZ20JYTEydOlCeffFIaNWpk0kqdeeaZ8tlnn9nWtWjRIqlatapceeWVtvk33XST7Ny5s8y9QAAAQHCWIXQ5nQAAQOXgzXJEUlJSgfVr3cSpp54q27dvr5D9ASo7ghoAKkxGRobMnz9fLrroIqlTp44JPmhO67fffrvAstOnT5clS5bI1KlTZe7cuRIaGmqet3LlSucyGzZskFatWkl4eLjtue3atXM+DgAAAp+3yxAAAKDyqIhyxKFDh2TdunXSunXrctwTABaCGgAqzDvvvGO+6LUAoawChadun5o6Srtv6pgZ2pVTW0bExcXJI488YsuHXbNmzQLPtebp4wAAIPB5uwwBAAAqj4ooRwwbNkyOHTsmY8aMKbf9AHACQQ0AFUYLDLVq1TJdPZV2/Rw0aJB89dVXsnnzZtuyWoDQrp4WLUT069dPli9fbhsro6jUEaSVAAAgOJRHGQIAAFQO5V2OePjhh+XNN9+UKVOmSIcOHcp5bwAoghoAKsRvv/1mCgHXXXedGZTLYrWUePXVV23La6sJdzovOztbjh49au7rIFyeemP8/fff5tZTLw4AABBYyqMMAQAAKofyLkc89thjMm7cODMOxx133FEu+wCgIIIaACqEFhQcDofceOONtvk6JkanTp3kjTfesLV62L17d4F16DwthOgAXKpt27ayceNGyc3NtS33008/mds2bdqU094AAIBALkMAAIDKoTzLERrQGDt2rJkefPDBctwLAO4IagAod1pA0IJC+/bt5fTTTy/wuLaQ2LVrl3z00UfOef/+978lMzPTeV8H8Vq8eLGcd955pquo+sc//mFaSrz77ru29elr1atXzxRQAABA4CqvMgQAAAh+5VmOeOKJJ0ww46GHHpJHH320AvYGgKtw2z0AKAdaQNi5c6d0795d3nvvvQKPW/kqNc+l5qBUWljo2bOn3HPPPZKfny8TJkyQw4cPm5YQFh3cS5e5/fbbzWOnnHKKzJ8/X5YsWSJz586l4gIAgABXXmUIa906oKdWVqhffvnFDCSqLr74YomJiamAPQQAAIFWjnj22WfNwOF9+vSRSy65RFatWmVbb+fOnTmpQDkLcWgfLAAoR9qjwlMBwl14eLh8/fXXpgCgBQdtHTFz5kzZu3evtG7dWsaPHy+9evWyPUd7aowZM0YWLlxoxtJo2bKlPPDAA3L11VeX4x4BAIBAL0M0adJEtm3b5nF9W7duNY8DAIDAVV7lCA2SLFu2rND1UdUKlD+CGgD8yh9//CFNmzaVZ555RkaNGuXrzQEAAAGCMgQAAKAcAVQOjKkBAAAAAAAAAAACAkENAAAAAAAAAAAQEEg/BQAAAAAAAAAAAgI9NQAAAAAAAAAAQEAgqAEAAAAAAAAAAAJCuK83IFDk5+fLzp07JS4uTkJCQny9OQAAlCuHwyFHjhyRevXqSWgobSDKgjIEAKAyoQzhXZQjAACViaOYdREENYpJAxoNGzb01vkBACAgbN++XRo0aODrzQholCEAAJURZQjvoBwBAKiMtp+kLoKgRjFpDw3rgFarVu2kLSnS0tIkMTGR1q0+sG/fPnnnnXfkiiuukFq1avliEyo1rn+Of2UWTNf/4cOHTTDf+v5DxZQhKsO1xb74p2A6L8FUFgym88K+VJ5zQxnC/8oRlen9WRYcB44B1wHvBz4TfF+2Lm45gqBGMVkpp7QQUZygRmZmplmuMhcIfKVq1aoyePBgSUpK4vj7ANe/b3H8Of7eRsrFii1DVIb3Nvvin4LpvARTWTCYzgv7UvnODWUI/ylHVKb3Z1lwHDgGXAe8H/hM8J+y9cnKEZX32wpBKyMjQzZu3GhuAQAAULlQFgQAAACCu2xNUANBmXP06aefNrcAAACoXCgLAgAAAMFdtib9FAAEuby8PMnJyfH1ZlSaLut6rLX7fqB03a9SpYqEhYX5ejMAAEFejgjE78jKsC9l3R/KEcHxHg22a7q0gu04aBk/PDycVHAAghJBDQAIYkePHpUdO3aIw+Hw9aZUCnqc9cfQkSNHAubHg25ngwYNTJ5MAADKqxwRiN+RlWFfyro/lCOC4z0abNd0aQXjcYiJiZG6detKRESErzcFALyKoAYABHGrLf2RowXZxMTEoCmY+/sPodzc3IBpEaXbm5aWZq6T5ORkemwAAMqtHBFo35GVZV/Ksj+UI4LnPRps13RpBdNx0H3Jzs42Zf2tW7easn4w9D4BAAtBDQQd7WIZHx9P5RwqPe06rYVZ/ZETHRUpkrm/Yo5JVIJISOUsMAfiDyG9Pv744w9zvZCGCkAwoCzo5XJErQSJlqMiDi98RzpyJdwRLiESEtDliED8vi+v/aEcERzv0WB6f5ZFsL23o6OjTYq4bdu2mQBHVFSUrzcJQAAK89N6VoIaCDpNmjSR5557TpKSkny9KYBfMAVyDWjMrqD3xOC9ItGJFfNaKLNg+MEGAK4oC3pXSPbfIm81Kvt6dPyF4ixIOSKgUI4Ijvco78/gRe8MAMFatg7eEDsAAAAAAAAAAAgqBDUQdDSNyl133WVuAQAAULlQFgQAAACCu2xNUANBOWDagQMHzC0A/0xTcPTo0RI/76WXXpKWLVvK6aefLn/99Zecf/75zsfGjh1r8sQWlR/3nHPOMflk1Y033ijTp08vsJyuR7fvvffesz23adOmUqtWLef98847zwy4BwDwP5QFgxdlCMC/BcN7VF+bcj4A+H/ZmjE1AKCyGviLSNTxAnypZe4TWXiqVISpU6fKnDlzpGPHjub+F1984Xzssccek1GjRklERITH57799tuSkpIijRs3PunrdOjQQWbNmiWXXXaZuf/ZZ5+ZHzpHjhwx9/XH0N13321e8/XXX/fS3gEAENxlCI8D8FZQOYIyBCqdEr5Hffn+9Lf36J133imPP/445XwA8HP01ACAykp/6OiA3mWZyhgU0QGnHnnkEenSpYs0atRI5s6dawagOuuss6R58+by5ZdfmuWuuOIK+f3332XQoEHmf+32aLWo+te//mVudR3aumvv3r0eW39dd911xdqmbt26yebNm2XXrl3m/quvvio333yzbZl+/frJhx9+6PwBBADwnWnfz5BRy+5zThPWPiObj/xmbq15ugz8rAxRxnIEZQignN+jlbSc37dvX8r5AConR75IRlrBKfNvkfzs47e6jJ8gqAEAlZW2vvL0hVWSSddRRhkZGbJixQp599135bbbbpMqVarImjVr5Omnn5YHH3zQLPPOO+9IvXr1zK1Orl588UVzq+tYv369JCUl2R7Pyckxj5199tnF2h5toXX99dfL7Nmz5eDBg7J27Vrp1auXbRndxjZt2sg333xTxr1HedIWhw899JBJKxAdHS3NmjUzLe/y8/NtLRM1HYFeX7pM9+7d5eeff7atJysrS4YPH25+YMfGxkr//v1lx44dnDzAT2w7/KekHtjknLYc+kPSc9PNrTVPl4GflSG8UI6gDAGU43uUcj6XF4DKJXO/yOykAlPo+50lcu8yc2uW8ROkn0LQ0YqpBx54wNwCKEIFdSc/mauuusrcnnHGGaZyYuDAgc7u4Vu2bCnz+vft22e6q8fExBT7OZqLVwMZVatWNdsTFhZWYJk6depQse3nJkyYYIJeb7zxhrRu3Vq+/fZbuemmm6R69epmoDM1ceJEmTx5skkx0KJFCxk3bpz07NlTUlNTJS4uziwzYsQIWbx4sSxYsEASEhJk5MiRphXfd9995/HaAOBbUTWjpOX1p5pb+E8ZQhPaVPHyZlCGALzzHi2P96fiPQoAga9edZGnLjt+608IaiDoaEvbVq1amVsA/i8q6nilk1U57HpfW9qXlQYzMjMzS/ScBg0amG7ymsNXe3l4ouvkc8a/rVy5Ui699FK55JJLnGkQ5s+fb4IbVi8NzeE8ZswYGTBggJmnAZDatWvLvHnzZMiQIXLo0CGTe1nzPF944YVmGU2f0LBhQ/n000+ld+/eBV5Xe3boZDl8+LC51R4irr1ESkKfp9tb2uf7E/bFPwXTeQmLDJOkprXl6pYDJfR/ueHjI+MDct98eV6s19apIpnXK+I1XbcpMjLS/B8aGlrgvpYhXLfdep41z9Nj7vR7Xr/vPT3mvh5rHfXr13eWIbRHp6fX03Vqeaeij21RPG1ncZ9nXaPWdRqI7zWUD8r5ABD4oiNE2tYXv0NQAwFPcyS7phTIOJQh+9bslel3TZPExESfbhuAiqEt6rXyWXtWuNNW+XXr1jW9PjT9UHFpi/1169bJKaecYnL7utu4caOcdtppZd52lJ9zzz3X9NTYtGmT6YXxww8/yNdff20CGWrr1q2ye/duW3oxrRDTfMsazNKghvbG0BRmrstoT0BNP6bLeApqaOo0rcxyl5aWVuIAm0UriPQad628C1Tsi38K5PNyW7NbJDc/z/yf68iVqd8+J3+s/EOaN20qdRLrOJfzlIvd3/nyvOhnn75+Xu7xY1tRTIOGIho16ONWowfX/13vuz5+sse0DLF//35n5asrTTmoZQj9HrHKEOaY5OWZSVmDKltBIF2vpjX8/vvvTTDdKkO4bssvv/wiDz/8sFcab3iDbrf7/hSX7oPuux5DTc+pGHMM3kQ5HwB8a/9Rkf/8JNK3rUiCH50MghoImjzKlmO7jsnWz36TgzccJKgBVBKaDuiCCy4wLSo/+eSTAuNqXH755fLRRx/JsGHDnPO0MmH8+PHO+1OmTLE958wzzzSTJ1YFhVZsw3/dd999pjKwZcuWpuePVtg8+eSTcs0115jHNaChtGeGK72/bds25zKaviw+Pr7AMtbz3WkKxHvuucfWU0N7dmigvVq1aqXaF60w0oomXUegVTi7Y1/8UyCflyQ58Zn/9qZ3JSQrRLau2CLLei2X4a3vkEDmy/OiQVitnA4Lr9g0e+Hh4fqnyMfNMm7/u953ffxkj+nntQaotQzx8ccfFyhDaE++pUuXOssQeh40cD1p0iTnMprGUOfrudL1durUyUyur2PdahlCl9NBj/2NFZQoCd0v3XdNz2gFhjwFiIDSopwPAL51MEPknXUi555CUAMod/mOfMnIyZD0nHRzPzQkVKLCKVyjEotKEBm8t+JeqwiuaQ3ce0C4PqatG3U8DE/Luj/26KOPmqkwd955p1xxxRVy++23mx/eOn6CJ1deeaXH+e6vp63/R40aVcRewh+89dZbJlWUppLSMTV0IHkdH0N7Wtxwww3O5dxbpep1eLKWqkUto709dHKn115ZKiX19cq6Dn/BvvinYDgvV7W8Us4IO122x22Ti5tdFND74uvzYlXSh0TV8koZwurFoJXgRX3Ghmg5opDHi1uGaNq0aaFlCPfHtFeFToXRMZi0DDF06FBnGaK4++Lp9V566SVThihpj4jy5PqdVtLtMteI2zUaDO+7gBJZ9nJ+sa/pSlDOf/nll00gBQDg33zaU2P58uXyzDPPmNQOu3btkkWLFslll11WIL2HtrRctmyZaamklRILFy40eUqV5qzWQqHmyNYBZnv06CHPP/+8yYduOXDggPmi++CDD8z9/v37y7Rp06RGjRoVvMeoKJl5mTJi2SiJ3RRr7qfEt5BJ3SZwAlB5hYSKRFfedGyNGzc23yU7d+60fT+UllaK64DT8G/33nuv3H///XL11Veb+23btjU9MDQ9lAY1dLB3pT0uNL2Ia4oaq/eGLpOdnW3KEq69NXSZLl26VPg+AYBPyhBRXihDaIWmplvSHgt+VKF/MpQhUCneowH6/lS8RwGgcvJpE4pjx46ZfOTTp0/3+Pjvv/9u8mFr2ogvv/zS5MLWdCGu3Vm1xaUGQxYsWGDyZB89elT69u3rzAmqrr32WtM6c8mSJWbS/wcNGlQh+wgA8A/agssbAQ2lgXJaIfq/9PT0AudJ01BZA5hq61kNWmhaEYsGMLQhhRWw6NChg0nH4bqMNsTYsGEDQQ0AqCQoQwCV5z16xx13UM4HgADg054aF110kZkKM2bMGLn44otl4sSJznmug7xqnuxZs2bJnDlz5MILLzTzNM2E5q3+9NNPTW5U7emhgYxVq1Y585rOnDlTzj77bElNTZWUlBSPr609QHRyzYettCLEqgwpjDVI3MmWg3c0ijvea8fy48GfJPG0JAmPtl/enI+KwfXvP8ff+t+a3M38aZZsOrDZNq92TG0ZdebdJ32de5ffX+hjjas1kjtOHyqVlXWsPR1zf2RdH+7fb8HwmdmvXz8zhob27tSenjpoq+Y9v/nmm83jml5BG0c89dRTkpycbCb9PyYmxjSIsAaav+WWW0waAs0XXrNmTdNDVHt9WGUPAP43qGzXrl3NLcrXzB9n2ca2U7Vja8u9Z54YV6gwo5bdV2g5Ynj7E2NgAfCP9ybvTwConOIiRXq2On7rT/x2oHCtTPnvf/8ro0ePNsEJrYjQFpU6+KaVokrTVuXk5EivXr1sKUF04NYVK1aY561cudJUSFgBDdW5c2czT5cpLKihqSl0ADh3aWlpZtC8k227Bly0koiWvOVvYL3Lbfefyp4okX3t7zS9TjRVCMof17//HH/tsab3NT+uTu62H95R4MeOjkPjaVl37s/zlJO3MrKOu/KnXNlF0XOl18n+/fttA4Tq4LCBTlNNag9PzYOu3wFaRhgyZIg88sgjzmW0nKHpK3UZTTGl5QUdbN61MlQHkdcc0wMHDnSmutR8zdrrA4D/0YGe//nPfxYY8Bnet/2oh7JEbkaxnltUWQJA2fDeBAB4S1I1kTsvEL/jt0ENrXzQVFLjx4+XcePGyYQJE0yPiwEDBsgXX3wh3bp1MzmwIyIibDmulebB1seU3nr6QaPzrGU80eDJPffcY+upoT1AEhMTpVq1akVuu1YOaWWWLktQo+KFSohkpKVLZI0oCa1yPO2IVtTxw7ZicP37z/HXNDpaMa2VsTq581jpHhLicdmSCPHCOgKda3DA3+m50u8q7YXgmt7R9f9ApYGJqVOnmqmo6/Vkg8TqsdAAiU4A/J9+/+3YscOMnxcMn2UAAACAr2Tniuw+LFKnmkiEH50Gv611stJeXHrppXL33cdToZx++ummd8WLL75oghpFtZR1razzVHHnvoy7yMhIM7nTip/iBCp03cVdFt7Vrkpb+Xz2p3LjmJukTuPjg8AmRCdwLioQ17//HH/935oKLlj480vi4qZ9pEroiUr8pJjEgOml4G2u3y2Bcgys68P9O4vvLwCBavG6/8r4B56WYY/dIfWb1DfzakRWl051z/L1pgFAQPFUzgcAVC7bD4iMWCgydaBIc/EfflvjXqtWLdN69NRTT7XNb9Wqlfz555/mfx3cU1tiaboI914e2lvDWmbPnj0e00hZyyC4nFf/HKkTXVv6Nb9Erm11tZl6N+np680CglZa+j654dRB8s+2N5upf/N+RS7fpEkT03NK08JZPv/8c1OxrmMVqA8++EDuvffeMm+bBsM1XZDS1vquaejeeustad++vUlZqOMjnKwVvvbeW7BggZQXPS46+HRRDh48aBtnSmmKla+++qrI5y1evNikXQKAYM0d/8iKx5zTCz+8JDvSd8jcjfNk+vrnzfT2pnd9vZk4ScXppc37malrg3MDogzRsWNHU36gDIFgRjnfOyjnA0AlCmpoWiktKOpg3q42bdokjRs3Nv936NDBpPhYunSp8/Fdu3aZSqEuXbqY+zoguOaXX7NmjXOZ1atXm3nWMgBQGTWs2kBS4lvYpqbVmxTrua7POZx9WBb99n6JXlsHbtZKB8urr74qZ555pvN+//795ZlnnpGyWr9+vURHR3uskGjQoIF89NFH5jvj66+/lueee06++eYbj+v566+/zLJXXXWV+JKnoMYrr7wi55133kkHzF67dq38/vvv5byFAFDxdGyG7/eud04IvLJEQlRCsRtH+EsZQhsM/PTTT5Qh4Jco51POB4Bg59Ogho6ZoYVFndTWrVvN/1ZPDG1ho61gZs6cKb/99ptMnz7dFB51ME+lg33fcsstMnLkSPnss8/MYOLXX3+9aS1z4YUXOnt29OnTR2699VZZtWqVmfT/vn37FjpIOABUBre2u0UmdZtgm+4988RYQkVxf97AlCtK9No333yzqYRQGmTWz2b9rLboIMxXXHF8nV9++aVpLamf/aeddpq0bt1avv32W/PYH3/8YXr2uX6vuKcf1HmPP/647Ny506xT16XfNeecc47pzWd9n7Rs2dJ8D3mi26rPtdat3zkaNLd6erz22mvOZfX757777jOBhubNm8u//vUv52Pz5s0zA1Hr83Q7PvzwwwKvpcEH/e7SVFYWfS0Nqui6NLChz7UqcLp37y7/+c9/nMdSe27o96AeKz3OFh3k2jrmAAD4U1miJOWIYC5D6Hc6ZQh4A+X80r9HtfeXNoDlPQoA/s2nQQ0tUOoXhU5Wag/9/5FHHjH3//GPf5jxM7RVqlbQaGvUd999V84990SX5ClTpshll11mKmu0cBkTE2MCH2FhYc5l3nzzTfP8Xr16maldu3YyZ84cH+wxKoIWRvT8B0o+e6Ay6tq1q2zZssX0gJg/f75ceeWVts9tdz///LOpxPjhhx9k+PDhMmbMmBK9nn6v1KtXT9555x1TGaGVEq5++eUXWblypVxwwQUen6+VIq69+8444wzTMlOD6cuXL5fHHnvM9BS06L7pc7QXyMcff2zWrXr37m0qX/R57733nglAuKbQUNpLsWbNmqbSQ61bt0727dtnKmz0O1EHvtV9sCplXI0YMcK0KtXjpNOECROcj+n2W+sEgKAWIhISFlro2FEomUNZh2Rfxj7bdDDroM8OY7CXIbRXpS/KENpQkDIEvCHQ36NaJ6WpXf3tPUo5H0B5++PIDvm1Srxt+iO8milSh/th0dqnA4VrSxTXlqie6Jeba0tTd1FRUSYPelG50PVLY+7cuWXaVgSOZs2amRZPmm8XQEGjlt1XYJ7mrz5Zuodf/06VV34q2NJfU0W0rFnynm+DBg2SN954wxT6NfisU2G0Z53VM0FbN06aNEm8ZceOHXLppZeaHxL6g6iwZazWXmr//v2mp6CmRNTxn/THiP4gs5bRNFX6400rB/SHlf740e3WFmLXXXedWZ/1vG3btskpp5xie7277rpLZsyYYXp96PebtjAtTqBWe2x89913zkG+ExNPDOao26avCwDBLrZOrHS8v5OvNyNoTFj3rGw+tLnAfE0bVdIyhP72c/0+owxxogxRt25dc0yuvvpqn5QhtPeoVqRShqjc5Xz3a6Wyvke1d7S/vUcp5wMob9N/niupNbvZ5qVk/y2TcpfLotv97/j7NKgBeENmbqbkO/Kd9/Pz8yUrL4uDC7jQFpW5+bnO3OPuivNjJT0n3eNzdX5p3Hjjjaa1YosWLSQ5ObnIZTWAbdEfEbm5x/dFfzDk5eU5H8vMzCzRNmg6Cf1B8dBDD5lWZIXRXoDWYKFKf+joOBXae1B/hOh+uL52YdurP4L0h5r2MLSC7p62ecCAASb9hLb00t6H2iuxrPR1rNzgABBMasfWlvTcE5/Re47tkaSoRLnvrFES8r8gb2RYhA+3MDhZZYLKXIbQltmUIeAPvamOOo6WrZyfmy6bDm4Ouvdoacr5d9xxB+V8AAgABDUQ8B765lFb4S1jX7rs++9eeX/qe85B5YHKbtyqpz3+yPElbS319NNPmxy3paWtqvSHT2pqqmnlNXv27EKXrVatmsm9bdFu5D169DDBgxtuuKHI19G0hb/++quza/qBAwfM54sGNLRbunaXLw59XpMmxwdQ1R6Eet8T/RE3ZMgQM9jp5ZdfbrqiW/uQnp5u9lmXcWcNjqqDnmtLy7S0NGdvjY0bN5p84gAQbNzHcNCWsU888YSEpIRI48aNfLZdCO4yhAY0Ro8eHTRlCB1zUssQ//d//0cZIkh6U1X29yjlfADwju1/i0xaKjKqp0hD8R8+HVMDKA/5OQ45tPuQZGdnc4CB/9FBOBdftshM/uSmm24y3bVLS3+U64/viy66yOTvzcoqvJfWnXfeaV7PGuRT8+/++eefJgCg83RyHazTlQ4eqAN1W8aPHy/33nuvdO7c2QxIqoN/F4e+lo4XpWNDaSVGo0aFV7ZpeivNRaytxSzas0O7tes4UVY3fVfao0MrLHTgUd2fBx980PnYkiVLTOUGAAQ7LQPq5ztlQe946uzHKUN4KENs377dlEGCpQyhPUkpQwQm3qPeLec/+eSTJmDpb+9RyvkAfCE1oqbMjG4lnx2sZm4XbvnQb05EiONkg1rAOHz4sFSvXt1E/7UVQFE0/dHevXvNmA5WTlKUb95Q1xbox3Ydk59f/VGem/KcNGjawMyLi4iT0xLbcRoqANe//xx/rczR3K5Nmza1devu994/Cjzv0ub9TM7coqzb8708uvLxAvMfO/sROaN2ewn246oD+73//vvSoMHxzxVP9CvVagFZnNy4RVm4cKG89NJLXhncW3P6amu1tWvXSkSEPQWLduX3dJ2U5HsPRfPGsQymz1b2xT8F03nZvHmzDBs2zOQsP1naE3/ny/Pi6fuBMkTJv++LW4bwppKWIYran6LKEIVdJ5QhvKuw4+nN9+h3e9bJ2JVPSGUv59evX99rZXl/KOcXVdavDOWB0uIYcBwq67Uw6ouRknpoS4H5Vj1r65vbyRkt28qk858t1+0objmC9FMIWi//NEti98U6BzI8rRtBDcB6P7hLijkxoHRhYqrEeHyuzg92WoDRHx5//PFHhVRI9OnTxwxOuGiRd3rW6ACGL7zwgscfOgAAVFQZwn2gcMoQ3kcZonIr9Xs0PEZa1EguUJFf2d6jGtQob7xHAfirQcmXypFPr3Hen1DjLPFnBDUAoBKmoioNHWSwtM8NBp66gZcXTRXlTcXtNg8AQHmVIZ7pOr5CWkD7I8oQCIT36PhznqyU70/X92hFJDKhnA/AX52W0Eoka6fz/nvZf5v0U/6KoAYCXs/GF8oZSSe6xM7JeFNO+UcLiawR6dPtAvwFWQbB9QGgMqldu7ZJP6W3KDvKEeD68G+8R3Gy9DkAUBZav+qP9awENRDwejfpabu/bu/3khp9YowNoLKqUqWKaWmVlpYmiYmJlbLVVUXz5pgaFbW9en3otur1AgDBoGrVqqaHmt7Cf8oRgfYdWVn2pSz7QzkieN6jwXZNl1YwHQfdFx1jUa8PTbFFGloAJRXpyJPo/ByRSJG4ljq2hUMiw/wnpTVBDQSdzCOZsnv1TkloU0uqxPrPmw2oaGFhYWb8hx07dpgcsaiYHw/aGkp/OATKDyHdTr1O9HoBgGBw8OBB+eijj+TSSy+VmjX9t8t8ZStHBOJ3ZGXYl7LuD+WI4HiPBts1XVrBeBxiYmKkUaNGlWKQYwDe9eTBb8ztwXSRLzeJdG8hUuOi18RfENRA0Lm8/j/k+9XfyYgBd0qT5o3NvKiwaF9vFuAT2ko1OTlZcnJyOAMVQH8E7d+/XxISEgLmh4O28iOgASCYzFr9qrwyc6b8XO1XqdUwwcyrV7WeDD71el9vWqUuRwTid2Rl2Jey7g/liOB4jwbbNV1awXYctIwfDL1OAPjW/mMis74RaVtfpIYfnQyCGgg6DarWl9jwGGleo5kk10z29eYAflGYpdK64n4I6Y/7qKiooPghBACBYNSy+yT1wInUo8d2HZODOYdMStLYsFgzLyW+hQ+3MLB5qxwRTN+RwbQvwbg/lY033qNcAxwHAAg0lFgAAAAAAAAAAEBAIKgBAAAAAAAAAAACAumnEHR0IKzTTz/d3AIAAKByCYsMkxrJ8eYWAAAAwMl9vOMr2R/b0jYvIT9D2kVsk7OaiMREiEjmPvuTohJEQnzTZ4KgBoJO3bp15Z577pGkpCRfbwoAAAAqWFTNKGkxsKUkRNUUkeODo1aPrM55AAAAAAqxdMc3klrVHtRIyf5belffJg9f8r8ZC0+1P2nwXpHoRPEFghoIeD+k/ShHso847+fk5MjRfUeld81eEhGhYUQAAAAEq64NzpWWNVOc93NzciX0aKjc2HkwZUEAAACgDHLzRI5li8RGiIT7UUdoghoIeHN+eVNSD2xy3j+265hsnf2bfDL7Y0lOTvbptgEAAKB89W/ez3Z/8+bNMuz+YXL+jG6UBQEAAIAy2Pa3yIiFIlMHijT3TacMjxgoHAAAAAAAAAAAOKVG1JR748+T9RGJ5vaJGp3EX9BTA0EpPTddZv8yVxKPHh9Xo05MbRmYcoWvNwsAAAAAAAAAAsLB0CjJDgk1t4dCjo9X5w8IaiBofbNzpcQ6Ys3/KfEtCGoAAAAAAAAAgJtxZ94t+fObOu+PqtlVtodXE39FUAMAAAAAAAAAgEoqKjxSxJHrvB+Tf+J/f0RQAwHvjtOHSmZehvP+qC/vlw6jOkpolTCfbhcAAAAqXtOmTeXFF1+URo0acfgBAACAMoipHXOinjU3S/wFQQ0EvCbVG9vut0xIkdQDm3y2PQAAAPCd0NBQiYmJMbcAAAAASq5ddprUanihOEIjJSsrSyLDRepvmS/+gpI+gk72gWz5fcFmkUMOiQ6PNlNkWKSvNwsAAAAVYOfOnTJx4kRzCwAAAKDkBh/bKPef/i8ZVP9aOfzeARmU1N/M8xf01EDQGd56qPz6988yucszkpyc7OvNAQD4SJMmTWTbtm0F5g8dOlRmzJghDodDHnvsMXn55ZflwIED0qlTJzO/devWzmW1RcqoUaNk/vz5kpGRIT169JDnn39eGjRoUMF7A6Awv/6dKuk56c77oxbfJz9/9aP82mqzVK0bZ+Yl1zhFnjz3cQ4iAAAAUAL6O3jDhg2SkZEp/oSgBgAACEpr166VvLw8530tiPXs2VOuvPJKc19bck+ePFlef/11adGihYwbN848npqaKnFxxytCR4wYIYsXL5YFCxZIQkKCjBw5Uvr27SvfffedhIUxdhPgD1756VWPqUczc7MkLPf4z52sPP/J/wsAAACgbEg/BQAAglJiYqLUqVPHOf3nP/+R5s2bS7du3UwvjalTp8qYMWNkwIAB0qZNG3njjTckPT1d5s2bZ55/6NAhmTVrljz77LNy4YUXSvv27WXu3Lny008/yaeffurr3QMAAAAAoFKipwYAAAh62dnZJiBxzz33SEhIiGzZskV2794tvXr1ci4TGRlpAh4rVqyQIUOGmN4YOTk5tmXq1atnAiC6TO/evT2+lqas0sly+PBhc5ufn2+m0tDnaSCmtM/3J+yLfwqm81KYQNy3YDov7EvlOTfBcL0CAAC7tIy/JSLseEYDS2R6mtSJThRfIKiBoFOrVi0ZPHiwuQUAQL333nty8OBBufHGG819DWio2rVr2w6Q3rfG4dBlIiIiJD4+vsAy1vM9efrpp81YHe7S0tIkMzOz1BVE2nNEK51CQwO7oy374p8C+bxo8NFVRLUIady7qbl1XWbv3r0SaAL5vLhjXyrPuTly5IhXtgsAAFScaRtmy7b4rrZ5jTfMlutPudnUs87f8x/5o1YP2+MpP86SSec/W/mCGsuXL5dnnnnGtITctWuXLFq0SC677DKPy2qLSR3Ic8qUKSa/dUkG8NTBP++880754IMPzP3+/fvLtGnTpEaNGhWwl6ho1atXN2lC9BYAAKVppC666CLT08KV9tpwpRU67vPcnWyZBx54wPQIce2p0bBhQ5MOq1q1aqWucNLX1HUEQ8Um++J/Avm8VKlSxX4/torUPrOOXNjwAn2Tm3l1YmpLUlKSBJpAPi/u2JfKc26ioqK8sl0AAKDibDu6U1IjatpnHt3prGddv3GdyCH/OSM+DWocO3ZMTjvtNLnpppvk8ssvL7J15erVqwtURBR3AM9rr71WduzYIUuWLDH3b7vtNhk0aJB5HgLfwtR3ZHf6Huf9jKMZsu+XvfLQ1WMIbAAATM8LHQPj3//+t/No6BgbSntc1K1b1zlfW3JbvTd0GU1bpY0jXHtr6DJdunQp9MhqGiud3GlFUVkqi7TCqazr8Bfsi38K1PPyz7Y3S3pOuq2V+I8rf5DBpwwOirJgoJ4XT9iXynFuAvFa1V6WDz74oNx1111mzC2rEYP2vNTGlVoW6NSpk8yYMUNat27tfB6NLAEAwe7IkSPyzTffSHZUtvgTn5Y2tMXkuHHjzACdhfnrr7/kjjvukDfffLNAK6ziDOC5ceNGE8x45ZVX5OyzzzbTzJkzzWChqamp5b6PKH9rdq+Vpds+dU4fb/hE3nn9nYBMMQAA8L7XXnvNtNC+5JJLnPOaNm1qghZLly51ztMAxrJly5wBiw4dOpiyh+sy2rN0w4YNRQY1AFSsljVT5Iza7Z1TPUddWTxnMWVBAMWydu1aE7ho166dbf7EiRNl8uTJMn36dLOMlht69uxpS6+ljSw144Q2svz666/l6NGjppFlXl6ecxltZLl+/XpTL6GT/q+NLAEACAR79+6Vl156SdIPnGhE5A/C/b0brH7Z33vvvbbWEJbiDOC5cuVK00JLW1VYOnfubObpMikpKV4f5DOYBsELZGUZkBVlO+5c/77D8fetYDr+wbAP1n5oUOOGG26Q8PBwW4tUrYh46qmnJDk52Uz6f0xMjKl8UFpWuOWWW0wvUO0NWrNmTZPysm3btqYxBQAACGwahLjuuutMw0dtcGnR8pz22BgzZoyzEeYbb7xhenPOmzfPpMe2GlnOmTPHWS7QRpaaclIbWWp9hNXIctWqVc46CX0tbWypjSw91UeUpS6itIKpDFsWHAeOAdcB74fK/Zng8DjPOg6eHrUe96birs+vgxoTJkwwFRA6HoYnxRnAU2895c/VeeU1yGcwDYIXiINDqvTcdLnvqwcl7vfjucsbxzaUO1KG+mDrKh+uf45/ZRZM13+wDPKplQp//vmn3HzzzQUeGz16tBmPa+jQoc60Ep988onExcU5l9GxvLQsMnDgQOfYXa+//rozxSUAAAhcw4YNMz05NSjhGtTYunWrqS9wbUCpqSW7detmGkdqUKO8GlmWpS6itIKpDFsWHAeOAdcB74fK/JmQFF5TJPs7t3kdZP/+/ZKbmyvnVG8v9Q+4DQre7Fqv944ubl2E3wY1tIDw3HPPybp16046YOfJBvD09PzyHOQzmAbBCwRVqni+jA/nHJG87OPRvdqxiQE5OGQg4vrn+FdmwXT9B8sgn1rRoN/5nui5Gjt2rJmKOg7Tpk0zEwAACB6aMkrrGzS1lDurAaQ1zpZF7+tYXeXZyLIsdRGlFUxl2LLgOHAMuA54P1Tmz4RRcbdK6NyHbfPyL1kom3ccNA39zml0pqTs3GZ/vHlXkehEn9RF+G1Q46uvvjKRnkaNGjnnaV5KTQGh3UD/+OOPYg3gqcvs2XNiEGnXVg7uBRRvDvIZTIPg+bvIkDCJzj/RWyMjIlSq1o+T0AiXY5+fx7moQFz/vsXx5/h7A99fAAKV/hBq3rx50ARnAXjf9u3bzaDg2kOzqM8K94aQJ2sc6Y1GlmWtiygtfkNwHLgWeD/wuVDJPxtDC+6j7remaD7llFMkJiba4+Oenle2zSje+vz2jOhYGj/++KMZRMuatCunjq/x8ccfF3sAT81VqV2F1qxZ41xm9erVZh6DfAaHJzveIwvT/uucTo/LkFNvbCPRCQXfbAAAAAhu9evXl0cffdTcAkBhmSG0MaTWKWjrU52WLVsm//d//2f+txpAuvem0OdYj7k2sixqmdI0sgQAwO/K1vXqij8J9/WgXL/99pstb6UGL3QgTu2hoYNyutIAhhYKrLyTxRnAs1WrVtKnTx+59dZbzUjt6rbbbpO+ffsWOkg4AAAAAAAITjpG1k8//WSbd9NNN0nLli3lvvvuk2bNmpm6B21A2b59e/O4BjA08KFjf7o3stSxt1wbWU6cOLFAI8uzzjrLzKORJQAAAR7U+Pbbb+X888933rfyRt5www1mEM7iKM4Anm+++aYZbNwawKt///4yffp0r+8P/EPt7X/Jf+f9IH0HN5KE2se7EtdrdpGvNwsAAAAVYNkPy+WhkQ/JwxMelibNG5t5UWHR0qT68f8BIC4uzgzo7So2NtY0lrTmjxgxQp566ilJTk42k/6vKTiuvfZa8ziNLAEAlcHvv/8uw4YNkxnPPiHJ4j98GtTo3r17oYN3eqLjaJRmAE/twTF37txSbycCy4CM32V5jsi/jvwkza30qMn/9fFWAQAAoDx88Pti2Zue5rw/b9UC+e3IbzLx22cl9q9YMy8lvoVM6na8dTUAFMfo0aNNw8mhQ4eaFFOdOnUyY3BoQMRCI0sAAHzDbwcKBwAAAICTWb7ja0k9sIkDBaBMvvzyywKDw44dO9ZMhaGRJQAAvuG3A4UDAAAAAAAAAAC4oqcGAAAAAAAAAACVVGZuluSH2EMFoblZzv/X7P1Rfo5pbns8ftca6dbsEvEFghoIOg3jRV6+XiTheAplAAAAVCLRtaKl3e3tJSIuwtebAgAAAASEh76dIqlJfW3zUr6dIuPOflKeeeYZeX3Pq/JbXFv749s+J6gBeEtEuEjd6hxPAACAyii0SqhE1YyS0WeONDnxVVzEiYF9AQAAABRPRESE1K5dW8L+DhN/Qk8NBLwn1k2X32v1dt7POJglh77cIm+0+1NqV/PppgEAAKCcTeo2wXZ/165d8tJLL8kpnZpL3bp1Of4AAABAKe3Zs8eUrY+1PSbiR3ENBgpHwDuUfVT2h0U7p7TsKrL5l6Ny9ETaNwAAAFQSR48elRUrVphbAAAAAGUvW+dk5Ig/oacGglJGSLj8FRor4WHH43aR6WlSJzrR15sFAAAAAAAAACgDghoISnkhITI2vovE1jo+WnjKj7Nk0vnP+nqzAAAAAAAAAMCv9Gxwjpzx14e2eQmtBzn/v/3U66Txd/aBxMO7bxBfIagBAAAAAAAAAEAl1bvBeSKf/2qf2eA82bzjoPm3WpWqUis/0/54pO8GMyaogYDXLiFFau35ynn/i6qJUv+8BlKlahWfbhcAAAAqXnx8vFx22WXmFgAAAIAXytY1qos/IaiBgDc4+R8iK4c47++L7yqpXRv6dJsAAADgGzVr1pQBAwaYWwAAAABeKFvHhYg/OT6KMhBEcrLy5NDvByUvK9fXmwIAAIAKlp6eLj/++KO5BQAAABB8ZWt6aiDodN2VKqvnH5Mrr42XerWPp6Cq0X6orzcLAAAAFWDht+/I1CemyI1jbpI6jeuYeQnRCdK7SU+OPwAAAFACu3btkkmTJsmMZ5+QZPEfBDUQcKZ9P0O2Hf7TeX9Umxvk+M/V407P3ieJeSJdszKkecb/ZiadXuHbCQAAgPL3zLeTZeuhP5z3f930q+zJ3CP/2fqhxGbGmnkp8S0IagAAAABBgqAGAo4GNFIPbHLez8rP8en2AAAAwHf2HNsj249s5xQAAAAAlQRjagAAAAAAAAAAgIBATw0EvJz8HFkY00IGph/vvVElTKRu9eO3AAAAqFxCw0MkKj7K3AIAAAA4uR/2b5QjkfVs8+L2b5TqVRpJUlKSvPvnEkmvcbbt8YYb35Jbz7hDfIGgBgLe+PUvSY3IOs6gRqOaIi9f7+utAgAAgC9EJ8ZIu6HtOfgAAABAMc3Z/L6k1jjLNi9l8/sysdszZqDwSRsnSmpObdvj6Ye2iq8Q1EDA25OxT2r4eiMAAADgEzoIeEyVGOf9zNxMqRkWL3ecOVRCQ49n2w0NIesuAAAAECwIaiDw5OcW+fAf+0TGvC/y5KUiTWpV2FYBAADAB25td4vt/pYtW2TUqFGyd9IV0qxZM84JAAAAUEp//PGHKVsnXBkvEi1+g6AGAs6VzfrIwWW32ubVyM9y/p/nEDmcefwWAAAAlUteXp4cPXrU3AIAAAAoe9m6Zp5/5ckhqIGA0ynpdJGMbYU+vjqytuwOOyKfRNWSujFVzLz4XWukW7NLKnArAQAAAAAAACDw1YqKl4hce31s7WjfpcghqIGg83lkI/kz/E95OzZFYuNizbyUbZ8T1AAAAAAAAAAAN3e0vl4y/9PDNi+qyyOSc+j4/7ekDJTkFZPtT7pkgfgKQQ0Eh4G/iET9Lzr4zigR+dPXWwQAAAAAAAAAfq9JXAORnAP2mXENZPOhg+KPQn29AYBXaEAjOtFMVZOqy6k3tJGohCgOLgBUcn/99Zdcf/31kpCQIDExMXL66afLd99953zc4XDI2LFjpV69ehIdHS3du3eXn3/+2baOrKwsGT58uNSqVUtiY2Olf//+smPHDh/sDYDiqF+/vjz88MPmFgAAAIAXytb16og/IaiBoBMeES5VG8RJWESYrzcFAOBDBw4ckHPOOUeqVKkiH330kfzyyy/y7LPPSo0aJwY4mzhxokyePFmmT58ua9eulTp16kjPnj3lyJEjzmVGjBghixYtkgULFsjXX39tBknr27cvgxADfioqKkqSk5PNLQAAAIDgK1sT1EDQST+UIX8u/UOyD2f5elMAAD40YcIEadiwobz22mty1llnSZMmTaRHjx7SvHlzZy+NqVOnypgxY2TAgAHSpk0beeONNyQ9PV3mzZtnljl06JDMmjXLBEMuvPBCad++vcydO1d++ukn+fTTTzm/gB/at2+fvPnmm+YWAAAAgDfK1vvFnzCmBoLOLY2ukN+/flnG1ftFmiYdj9uFd9/g680CAFSwDz74QHr37i1XXnmlLFu2zHSbHTp0qNx6663m8a1bt8ru3bulV69ezudERkZKt27dZMWKFTJkyBCTqionJ8e2jKaq0gCILqPrd6fpqnSyHD582Nzm5+ebqTT0eRqEKe3z/Qn74p8C+bwczDokufm5zvuPf/mkvL9wkfxS51eJb1DTzGsU10juOP12CTSBfF7csS+V59wEw/UKAADE2dDv448/lv69zpUk8R8+DWosX75cnnnmGVNhsGvXLpPa4bLLLjOPaQXCQw89JB9++KFs2bJFqlevblpIjh8/3lQmWLTSYNSoUTJ//nzJyMgwLTCff/55adCggS39xJ133mkqN5Tmwp42bZot/QSCR7UqVSXCkS81HdlSyypPR1bz8VYBACqalh9eeOEFueeee+TBBx+UNWvWmPKABi4GDx5sAhqqdu3atufp/W3btpn/dZmIiAiJj48vsIz1fHdPP/20PPbYYwXmp6WlSWZmZqkriLQwqZVOoaGB3dGWffFPgXxent4wUbYc3eq8f2z/McnOz5ath7fJ3gP7nL8t9u7dK4EmkM+LO/al8pwb1xSOAAAAQRfUOHbsmJx22mly0003yeWXX257TFM/rFu3zgxEostoYEJzWmtA4ttvv3Uup/MWL15s8lzrIKAjR440ea41UBIWdnxMhWuvvdYM6LlkyRJz/7bbbpNBgwaZ5yHwLNu1Rg7EHE8dYonftUa6NbvEZ9sEAPDPSpozzzxTnnrqKXNfU0fpIOAa6NCghiUkJMT2PK3UcZ/nrqhlHnjgARNIce2poWmwEhMTpVq1aqXeF309XUcwVGyyL/4nkM+LjptTnGWSkvypbVnwnxd37EvlOTf+lnMbAAAEH58GNS666CIzeaI9M5YuXWqbp70rNCf2n3/+KY0aNXLmuZ4zZ47pxaE0z7VWHGiea00JsXHjRhPMWLVqlXTq1MksM3PmTDn77LMlNTVVUlJSKmBP4U2Lt30uqXFtbfNStn1OUAMAYFO3bl059dRTbfNatWol7777rvlfBwVX2uNCl7Voa26r94Yuk52dbRpXuPbW0GW6dOni8YhrTxCd3GlFUVkqi7TCqazr8Bfsi38KpvPiSaDuVzCdF/alcpybYLhWAQCAfwuoMTU0iKGFLSttVHHyXK9cudIESKyAhurcubOZp8sUFtQoSz7sYMoX658cHudZx7tq1Vi5uI1INZcGQuYxzkeF4Pr3LY4/x9+b11KgO+ecc0wDBlebNm2Sxo0bm/+bNm1qghbaiEJ7cSgNYOj4GzrIuOrQoYNp4a3LDBw40MzTlJkbNmyQiRMnVvg+ATi58JhwSepQx9wCAAAAOLmFWz6U3dVOt82rs+VD6VarjxnuYcpvr8n22seHjbCkrBovk85/VnwhYEr6moP6/vvvN6mkrNQNxclzrbeeuprrvMJyYZc1H3Yw5Yv1Rzk5uR7nWXmSQ8Qht3ezP562L00ckZ6CIfA2rn/f4vhz/L0lGPJh33333aY3haaf0oCEjqnx8ssvm0lpQwlNY6mPJycnm0n/j4mJMeUNpY0gbrnlFpPeUtNc1qxZ04zl1bZtW2cvUQD+JbJ6pDTp01RS4ls45zWu1sin2wQAAAD4szV7f5TU6Ca2eSl7f5QrWg2SG264QSZtnChySPxGQAQ1tDfG1VdfbSrrdBDwk3HPc+0p5/XJ8mWXJR92MOWL9UdVqoR7nGcFrzL+zpTf00Qa1BCJ/F+K5cRaiSLRiRW9qZUS1z/HvzILpus/GPJhd+zYURYtWmS+0x9//HHTM2Pq1Kly3XXXOZcZPXq0ZGRkyNChQ02KKe3Z+cknn0hcXJxzmSlTpkh4eLgJjOiy2krl9ddfd47dBcC3+jXvK+dm/u28n52VLX//eUBuOGuQREdH+3TbAAAAgECWlZUlf/zxh+RmF2xk7kvhgRDQ0EqErVu3yueff24LKBQnz7Uus2fPHo89Lqx82eWRDzuY8sX6H0/BqOPHW+3ctUfuWSgydaBI8//FMcxjnIuKO0Nc/z7F8ef4e0OwfH/17dvXTEW9X8aOHWumogI8Oq6XTgD8T7cG59nub968WYZNGSY9Tjnf9MACAAAAUDo7duyQRx55RBoNbiBSVfxGeCAENPSHyRdffGHSPrgqTp5rHRBcU0FpygkdZFytXr3azCtsgE/4t4faD5Xct9vY5oV33+Bx2YUxLWRNZB2RVeOldlx9uffME71vAAAAAAAAAACBxadBjaNHj8pvv/3mvK+9MdavX2/yVeuA31dccYWsW7dO/vOf/0heXp5zDAx9XMfSKE6e61atWkmfPn3k1ltvlZdeesnMu+2220yrzcIGCYd/qxFZTSTfbVwTnfc/C7f8V1KrxMuUuCYSFxkrqRE1RQ5tkfT8nIrfWAAAAAAAAADwY5FhERLtVneq8yxnJraV8H2v2h5PanmVVMqgxrfffivnn3++8741hoUOPqJpID744ANz//TT7SOva6+N7t27FzvP9Ztvvil33nmn9OrVy9zv37+/TJ8+vUL2ERVv65Edcig0Qn6JqCWxEbGcAgAAAAAAAAAoxJMd7xGZfXy8YqeLXpPNOw6af3vU6yLJf7hlwGncQyplUEMDEzpgd2GKeqwkea61B8fcuXNLvZ0IMCEiYRFhBYfeyM8VyUg7/n9UgkhIcOSLBwAAgH2sHP2NoLcAAAAAgq9s7ddjagClUaNeDelw7/HxU2wOpZ6IOA7eKxL9v1HEAQAAEDSaNWsmL7/8siQlubU0AwAAAFC6snVciMg34jcIaiDoNKpaTyTtuwLza+cd88n2AAAAAAAAAAC8g/w7CDqXVrtA0mcsl7t+Xy6TDpyY7j1cMNABAACA4PLb1t9k1OhRsmnLJknPSTdTZm6mrzcLAAAACDjbt2+X+++/X7bv+Ev8CT01EHSys3Nk+wGR7DxfbwkAAADK2+pda+Rg1iHn/QmfPCM/b/xRdi7dK7F1Y828lPgWMqnbBE4GAAAAUALZ2dmyc+dOU9/qTwhqIPhE1pCspG6Sf+kEkVOaiWTuE1l4qq+3CgAAAOXg7U3vSuqBTUUvlJ8rkpF24n5UgkgIndYBAACAQERQAwFn5sa3ZHuNs23zGm58S249447jd/QHamiESFRNBgMHAACASNq3IrNdBg4fvJdyIgAAABCgCGog4KQe2iqpkbVt89IPbfXZ9gAAAAAAAABAsNpy+E85EuHSSEhEYg5ukZbRiT7ZHoIaCDp16tSRESNGmFsAAABULpHxkZJ8ZYq5BQAAAHByT6ybLr/X6m2b13zddBnRbpSpZ/3w0EeyJb6L7fGUXxfKpLqdxBcIaiDoxMbGyhlnnGFu1ahV4yW19mW2ZVJWjZdJ5z/roy0EAABAeQmPCpf4FjXlmqO/ihw9Pi8hP4MDDgAAABTiUPZR2R8WbZtXK/uos571842fimSL3yCogaBz4MABWbx4sQwYMEASEhJ8vTkAAAAoR6POvFuy8k78wjq4a6usmdJLLmqRLfHH27gAAAAAKEM9a2btTPEnob7eAKCkakfXkoa5h22TzrP8/fff8vbbb5tbAAAABLc6sXWkcbVGzikmO0o+WJEtf6f7essAAACAwPb3/+pZMw/7V1CDnhoIOPee9k+RHx60z7xkga82BwAAAAAAAABQQQhqAAAAAAhqP0TUkjmxpzrvN94wW4Z3HOnTbQIAAAD8RbuEFKm15yvbvHrNLnL+f2XTiyRx0x22x2M63S++QlADQa9r3Y7ScucntnlJLa/y2fYAAACgYh0JiZDUiJonZhzdySkAAAAA/mdw8j9EVg4Rm+T/yuYdB82/zao1kuTsvfbHazQTXyGogaATGxsrHTt2NLeqf+MeIsuusS+k8wAAABB0YmNj5JzmIrERvt4SAAAAIFjqWWPEnxDUQNCpU6eODB8+XJKSkny9KQAAAChvjnyRzP3Ou3Wqh8r9fU48vDCmhSTmM2o4AAAAUOp61rgQ8ScENRB0cnNzZf/+/VKzZk2JiKCJHgAAQDCZ9v0M2Xb4zxMz8nNF0r6Vs7J2y8D0TZKfJ/J3hkiNaJHwMJE1kXXsqacAAAAAlKyeNbqG+FMta6ivNwDwtm3btsndd99tbgEAABBcNKCRemDTienQFqnmyJZ/pP92/PG/RW564/gtAAAAAC/Us/65Q/wJPTUAAAAABLQQcciz1TuY//dnZsqOsK06GrivNwsAAABAOSCoAQAAACBgVI+sLglRCc77OXlZskbqOu8fizgmh0P/ct6/48h6yQwJs60jqssjFbS1AAAAALyN9FMIOKNWjZd+tS+zTToPAAAAwe/hzg/K631eMdPMni9ISo1mBZZxVImT/EtXiQzeK00GrJSWOQdsU5O4Bj7ZdgD+4YUXXpB27dpJtWrVzHT22WfLRx995Hzc4XDI2LFjpV69ehIdHS3du3eXn3/+2baOrKwsM3BqrVq1JDY2Vvr37y87dthTcxw4cEAGDRok1atXN5P+f/DgwQrbTwAAghVBDQAAAAABadFv78vh7KOSkv23c2qWc1CiwqJEomqKRCeKRCX6ejMB+JkGDRrI+PHj5dtvvzXTBRdcIJdeeqkzcDFx4kSZPHmyTJ8+XdauXSt16tSRnj17ypEjR5zrGDFihCxatEgWLFggX3/9tRw9elT69u0reXl5zmWuvfZaWb9+vSxZssRM+r8GNgAA8De709NkW1icbdJ5ls92rpBXqraxTR9s+8xn20v6KQSdZs2ayaxZs0yrGvXrwS2SHpFkWybm4BZpqT9yAQAAELAGplwhAxt1E5l9oqzniBD56411UrdpwR4cAKD69etnOxBPPvmk6b2xatUqOfXUU2Xq1KkyZswYGTBggHn8jTfekNq1a8u8efNkyJAhcujQIfObc86cOXLhhReaZebOnSsNGzaUTz/9VHr37i0bN240gQxdZ6dOncwyM2fONL1CUlNTJSUlhZMBAPAbk36cJam1etjmpfw4SyZ0nWi+86ZuniybYk+xP75rrfRvebX4AkENBJ2QkBCpUqWKuVWv/LpQUuO72JZJ+XWhTKp7vGAJAACA4KFFQNeyoEeZ++z3dYyOEDqxA5WR9qx4++235dixYybgsHXrVtm9e7f06tXLuUxkZKR069ZNVqxYYYIa3333neTk5NiW0UZ1bdq0MctoUGPlypUm5ZQV0FCdO3c283SZwoIamtZKJ8vhw4fNbX5+vpnKg65XU26V1/oDBceBY8B1wPuhcn8mODzO02MQHq4hBE9la+8fn+Kuj6AGgs5ff/1luguPHj3atJQBAABA5fHXAZEJE6bKvQ88WnhZcOGp9vuD9x5PVQWg0vjpp59MECMzM1OqVq1qUklpLw0NOCjtmeFK72/bts38r0GPiIgIiY+PL7CMPmYtk5RkzxigdJ61jCdPP/20PPbYYwXmp6WlmW0tD1qBpL1PtOIqNLTyBng5DhwDrgPeD5X5MyEnJ9fjvB9++EFefPFFyT8/VySm4ON79+716na4pnosCkENBJyudTtKy52f2OYltbzK+b8W9LQ7b3kV+AAAAOC/MnNFft30m8ey4MKYFrImsk6B+Y03zJbhHUdW0BYC8AfaU0LHuNCBu99991254YYbZNmyZc7H3Xt7aaVWkT3APCzjafmTreeBBx6Qe+65x9ZTQwO0iYmJZlDz8qq4023S16gMFXeF4ThwDLgOeD9U5s+EKlXCPc7TwP8ff/whjfIbenzcUwC/LKKiooq1XInPyOOPPy7p6ekF5mdkZJjHgPLWv3EP+efRDbZJ5wEAgoO3yhpjx441hVDXSQf6dK1U0GU0XUR0dLR0797dOUCoRdM/DB8+XGrVqiWxsbHSv39/2bFjRxn3EICv7A6PkdSImgWmbUd3clIAP+ftugjtaXHKKafImWeeaXpHnHbaafLcc885ywruvSm0JarVe0OXyc7OlgMHDhS5zJ49ezz2uHDvBeJKU11p8MJ1UlqhVp6TlpPK+zUCYeI4cAy4Dng/VNbPBPGYXur4/pvf0x6/tcrn+JRLUEO7QR49erTAfC1ceOoiCQAA4KuyRuvWrWXXrl3OSVNNWDRV4eTJk2X69Omydu1aU/nQs2dPW3fXESNGmHQUCxYskK+//tpsV9++fU3+bQA+4sgXyUg7MbmPjwEgKJV3XYQ2dtDGDE2bNjVlgqVLlzof0wCG9uLo0uX4WI0dOnQwY/e4LqPljA0bNjiX0dRWmrZkzZo1zmVWr15t5lnLAADgL65s1kfuOPy9bdJ5lvtOGyKL97xnmyZ1vt9n21vi9FOFdZXU/Fo1a9b01nYBXvPPlgMlfUl/27yYTr570wEAKq6soQOaufbOcH2NqVOnypgxY2TAgAFm3htvvGFaTs6bN88MAqqVDrNmzZI5c+bIhRdeaJaZO3euSQHx6aefmkFAAfhA5n6R2SXo5q6DgOuYGWrDbJG/vi63TQMQGOWDBx98UC666CLzna6NGbTxwpdffilLliwxr6GNGp566ilJTk42k/4fExMj1157rXm+DvZ9yy23yMiRIyUhIcG8/qhRo6Rt27bOMkOrVq2kT58+cuutt8pLL71k5t12222mcURhg4QDAOArnZJOF8k4PnaUU9LpsnnHQV9tkneCGjoAlpW6oUWLFrbChLZW1BYT//rXv8prO4Fi01x3N998s7lVLWs0E8l2G7RG5wEA/Ep5lDU2b95s0ktpKodOnTqZSolmzZrJ1q1bTVqJXr16OZfVZbp162YGCNWgxnfffSc5OTm2ZXRdbdq0McsUFtTQVp46uebCtnKy6lQa+jytzCnt8/0J++KfAum8PLz2WdmceIltXnLOQXny4Dfm/8SqIrcMvtZUNDr3JzLB3DjCIp3PCXfkSRXt9aEPh1Xxy30PpPNyMuxL5Tk33r5ey6N8oGmhBg0aZHpXaICiXbt2JqChPTbV6NGjTVqroUOHmhRTWob45JNPJC4uzrmOKVOmmMYTAwcONMv26NFDXn/9dQkLC3Mu8+abb8qdd97pLEtoGkvtIQoAQMDVs9Y6Xp4OuKCGtmbUgo7uhHbt1C9+11yUTZo0Md0rS2L58uXyzDPPmEoDLUxoeofLLrvM+bi+nr7Wyy+/7CxIzJgxw6SSsGilgbaImD9/vrMg8fzzz0uDBg2cy+hztSDxwQcfOAsS06ZNkxo1apRoexEYNOeo5kUvr0HUAADlw9tlDS03zJ4921SAaOXFuHHjTLoHHTfDypPtntNa72/bdrx1ii6jr6uVKe7LuOfZdqV5uT2lwdAc2p4GLi5uBZH2HNHjU9wco/6KffFPgXRejmamS0ZoFdu8rJATlYjVokXan9bavN80v72rqo5YaRbTUKoc/EHOytotA9M3mfl7OowvsKw/CKTzcjLsS+U5N65pHL2hPOoitCdmUTRwouNu6VTUQKZar6BTYbQHh/byBAAg4OtZ4zyPquH3QY0bbrjB3Gp+Sa0Q0PyRZXXs2DEzGNdNN90kl19+eYHHrVzX2tpBKyS0MkJbTqSmpjpbSGi30MWLF5vuotoaS7t/andODZRYLSS0i6gO6qktL6wun9oqQ5+H4KMtYrXrsHb1JXAFAIHD22UNTSth0XQQWuHRvHlzk2aqc+fOZr57GovCUluUZJkHHnhA7rnnHtv3kqa30BYupQ24a4WTvqauIxgqNtkX/xNI56VKlaJ/whzOEPn+h5+lZ99WBcqCNyXdIJJxsYTOtaelS6yVKBJ9vJevPwmk83Iy7EvlOTda2e9N5VEXAQAASljP2u1M8afuASUeU0PTMmihZ9OmTaY1k3vX0q5du5aossG1wqE8cl1v3LjRBDNWrVplWmyqmTNnmooNDY4UlsuyLKkjgqlrtV/Kzy8wwr051v873toaV6+L9u3bH688Osny8Pbp4fr3JY6/bwXT8fflPnizrOEqNjbWBDc0JZXVM1R7XNStW9e5jL6e1XtDx+LQgUG1x6drbw1dpqgBPjWNlU7utKKoLJVFWuFU1nX4C/bFP/ntedEUUTqOhiU/t+AyCaeJ9HvH/Lvnty0y656H5Iyzz/ecZ9/D/pl99rf99vfzUgrsS+U4N+V1rZZX+QAAABROMw68+uqr0qF108AOamhwQHs+aGoGrbhxLwhpTktv8Fau65UrV5ruqVZAQ2nrTJ2nyxQW1ChL6ohg6lrtj0Ky9ok9WYhI2r40cUQevx73798vubm55lbP88mWh3dx/fsWx5/j7y3eTh3hD2UNbaygjR3OO+8809pTgxZLly41QXClAYxly5bJhAkTzP0OHTqY1qC6jObLVpouc8OGDaY3KQAfDQwe31Ukwi1YoemorJ4WUQf1w4LTAwSZiqqLAAAA/q/EQQ0dgOvMM8+U//73v6Zl48lSNJSWt3Jd621SksuPoP/ReUXlwy5L6ohg6lrtj1J3bZW/IuznNDr8iKQknWr+14CSDtim6cjMuc8oeI36a4qBYMD1z/GvzILp+vd26ghflDV0zK1+/fpJo0aNTItOTWOp3+eaxkLXqSksdeDw5ORkM+n/MTExpsJEaWD8lltuMakt9TtFW3zrOrW3h9VDFEDF07EwGuUd70VtqZN8Ylw+AMGpouoiAABAEAY1NGXDO++8I6eccopUBG/kuva0/MnWU9bUEcHUtdrfzNr0jqTG29N+pGx6RybVPz44nB5z2/EPsBQDwYDrn+NfmQXL9e/L7fdWWUPH07rmmmtk3759JtCkPTW1lWfjxo3N46NHj5aMjAwZOnSoSTGlvTo/+eQT57hdasqUKSZQrj01dNkePXqYsb6scbsAVDxrcG+bZhdzKoAgV9F1EQAAIIiCGvqD/7fffiv3goSmhPBGrmtdRsdY8JRGyr0XCIKDti7WtGK+bGUMACg9b5U1FixYcNIA1NixY81UGP0umTZtmpkABAbKgkBwqqi6CAAAKqNlu9bIgZjmtnnxu9ZIs6h2pp71ja3/lr8TLrA93vSHV+Tezg9IQAQ1hg8fbtIwaLBB0y9ormlX7dq188qGeSvXtQ4IrumI1qxZI2eddZaZt3r1ajOvqEE+Ebjq169vBpi30o59sO0z2Vu1jW2ZpG2fSf+WV/toCwEA/lDWABDABv4iElXrxP2ohELLggCCA+UDAADKz+Jtn0tqXFvbvJRtn8vEbheZsvWkjRNl+yH7kAwxGft8dkpKHNS4/PLLze3NN99sa+lopXMqyeBcR48eNS0tXAcHX79+vclZrfmvvZHrulWrVtKnTx+59dZb5aWXXjLzbrvtNunbt2+hg4QjsOm1qAPIW4PHLd+1VlJj7a15UnatJagBAH7Km2UNAEFKAxqFjI/mXhYEEBwoHwAAUPEcflq2LnFQQwMP3vLtt9/K+eef77xvDcytA3hqvmpv5bp+88035c4775RevXqZ+/3795fp06d7bT/gX7Zs2SLDhg2TGTNmmGAYACCweLOsAaDyOVlZ8Il10+X3Wr1t85qvmy4Pn/NYBW4lgJKifAAAgO/K1o0GNxCpGsBBDWtwTW/o3r17kVEeb+W61h4cc+fOLfP2wj/8s+VASV/S3zYvptP9PtseAIB3ebOsASDwTdswW7bFd7XPXDVe7jjjTmlSveSfF4eyj8r+sGjbvFrZR8u6mQDKGeUDAABQ6qDG7Nmzi3x88ODBJV0lUCItazQTyd5rn6nzAABBgbIGAFfbju6U1Iia9oNyaItk5mVwoIBKhPIBAAC+0zSugdTL/NU2r2H1HoET1Ljrrrts9zWnVnp6ukRERJjxLghqAACAsqCsAQAAKB8AAFBxHmo/VHLfbmObF959g6Sl5Zv/Bza7RJJXPGF/Uqv3AyeooWNbuNu8ebPcfvvtcu+993pruwCvmdT5fpHZSfaZvd16egAA/AZlDQAAQPkAAICKUyOymkh+pn1mZDVJk4N+eRpKHNTwRAfgGz9+vFx//fXy66/2biiAL3Kt6gDy5FwFgOBBWQOAt8qC7RJSpNaer2zz6jW7iAMMBCDKBwAAVFDZukENkRUSXEENFRYWJjt37vTW6oBSCw8Pl4SEBHMLAAgelDWAymlQ8qVy5NNrzP9vx7aQLVVqmP+j3Ab7Lm5ZcHDyP0RWDrHPTP6vtzcbQAWhfAAAQPk5UbYOEX9S4lrfDz74wHbf4XDIrl27ZPr06XLOOed4c9uAUtm9e7fMmDFDhg0bJvXq1eMoAkCAoawBwNVpCa1Eso43njr3f7cyeK9IdKLHA0VZEAhOlA8AAKh4u6161luulnqBHNS47LLLbPdDQkIkMTFRLrjgAnn22We9uW1AqRw7dkzWrl1rbgEAgYeyBoCyoCwIBCfKBwAA+LBsfXV/vzr8JQ5q5OcfH/EcAACgPFDWAFDhMvcVnBeVIBISyskA/ATlAwAAYCnToAOaesrqrQFUlA+2fSZ7q7axzUva9pn0b3k1JwEAggxlDQAVYuGpBecVkeIKgG9RPgAAoHIrVdOj2bNnS9u2bSU6OtpM7dq1kzlz5nh/6wAPlu9aK+/HnmKbdB4AIHhQ1gAAAJQPAADwD4dzjsq+0CjbdDDrcOD01Jg8ebI8/PDDcscdd5iBwbWFxDfffCP/+te/ZN++fXL33XeXz5YCxVSzZk258sorzS0AIPBQ1gAqOUe+SOb+olNDFYGyIBCcKB8AAFB+Zm58S7bXONs2r+HGt2RA42tMPetrO96VbYl9bI+nfP+8TDr/2cAIakybNk1eeOEFGTx4sHPepZdeKq1bt5axY8cS1IDPxcfHS79+/cyteuaHV2RrwgW2ZZr+8Irc2/kBH20hAKAolDWASk4DGrOTvFYWLMrCmBayJrKO8/6V6ZukU9buUr82gPJD+QAAgPKTemirpEbWts1LP7TVWbZO3bhR5JD/nIESBzV27dolXbp0KTBf5+ljgK8dO3ZM1q1bJ+edd57ExcXJnox9sj28mm2ZmIyStfgDAFQcyhoAvFkWdLc7L0eyBqw3/5+RnyOfrH/JlBfVwcxIDj7gpygfAADgu7J1juQE9pgap5xyiixcuLDA/LfeekuSk5O9tV1Aqe3evVumTp1qbgEAgYeyBgBXH0c3lnmxLW3Txzu+KnVZcNJ3z8kd34w1090rn3QGNAD4N8oHAABUvN3/K1sf+/uYXx3+EvfUeOyxx+Sqq66S5cuXmzE1QkJC5Ouvv5bPPvvMY7AD8LZJne8vmJKg914ONAAECcoaAFwtjWosqRH2sdJSdnwjvZMHcKCASoTyAQAAKHVQ4/LLL5fVq1fLlClT5L333jMDhZ966qmyZs0aad++fUlXBwAAQFkDQMmElvhnDIAAR10EAADlp3Z0LUnfv77APMv5dc+W2J0TbI/Ht/unz05JqX4NdOjQQebOnev9rQHKQUr1phKzd6VtXsPqPTjWAODHKGsAKC+NqzUqODM/VyTtW6mRn8WBB/wY5QMAAMrHvaf9U+SHB+0zL1kgm3ccNP+eldROkn/73f543bMCJ6jx4YcfSlhYmPTu3ds2/+OPP5b8/Hy56KKLvLl9QIlFRERIvXr1zK26tdVVImuH2xdq9T5HFgD8FGUNAN4sC7ob3n5YwZkZaQXTmwLwK5QPAADwZdm6SmAPFH7//fdLXl5egfmahkofA3ytYcOGMn78eHMLAAg8lDUAlAVlQSA4UT4AAMCHZesG9f3q8Je4p8bmzZvNGBruWrZsKb/99pu3tgsAAFRSlDUAuBp34BvJv3aLSNSJnL6hISVumwUgwFE+AAAAlhL/Gqhevbps2bKlwHwNaMTGxpZ0dYDX6fV52223ebxOAQD+j7IGAFdRkicx4dESUyXGOUWFRxV6kCgLAsGJ8gEAABVvi1XPunVbYAc1+vfvLyNGjJDff//dFtAYOXKkeQzwNU2FlpmZaW4BAIGHsgaAsqAsCAQnygcAAFQ8h5/Ws5Y4qPHMM8+YHhmabqpp06ZmatWqlSQkJMikSZPKZysBAEClQVkDQEVbtmuNvBfT3DbpPAD+g/IBAAAo9Zga2uVzxYoVsnTpUvnhhx8kOjpa2rVrJ127di3pqoBSeeaHV2RrwgW2eU1/eEXu7fwARxQAggBlDQAVbfG2zyU1rq1tXsq2z6Vbs0s4GYCfoHwAAABKHdRQISEh0qtXLzMBFW1Pxj7ZHl7NNi8mY1/JVpLptnxUgggDTgKA36CsAVRe0zbMlm3x9gZTjTfMluEdR1bshuTniGSknbhPeRHwOcoHAAD4xvr9G2VLdGPbvBp710unxj0DJ6gBVChHvkjmfvsPzCI0aNBAHn/8cXOrDmYdltzQ44NJLoxtIWsj60j4Z3fJ9cd+kW6Zfx1/0uC9ItGJ5bgTAAAAKI5tR3dKakRN+8yjO4t98NzLgqW2/weR2Ukn7lNeBAAAQJAatWq8pNa+zDYvZdV4eaLzOFO2XnBonvxerb398S1LfBbUKPGYGkCF04CG/qC0pv0/SMes3dIm23PvjMjISGnSpIm5VeO+f15uSuxjpo9imsm+sBjZHR4rB/4X6AAAVA5PP/20aeE5YsQI5zwd7Gzs2LFSr149k1Kze/fu8vPPP9uel5WVJcOHD5datWqZccV0oNIdO3b4YA8AFId7WRAAAABA2crW4RH+1TeCoAYCzllZu+WBg2ukiiPP4+NpaWnyxhtvmFsAANTatWvl5ZdfNuOAuZo4caJMnjxZpk+fbpapU6eO9OzZU44cOeJcRoMgixYtkgULFsjXX38tR48elb59+0penufvIQC+RVkQAAAA8G7ZOv1guvgTghoIOAPTN0kVyS/08cOHD8tnn31mbgEA0CDEddddJzNnzpT4+HhbL42pU6fKmDFjZMCAAdKmTZvjhbX0dJk3b55Z5tChQzJr1ix59tln5cILL5T27dvL3Llz5aeffpJPP/2Ugwv4odKUBR9qP1ReS1timx46uKpctxMAAAAIlLJ19rFs8SfF6jdSkh8E1arZB3Aui9zcXJMS4s0335Tdu3dL3bp15cYbb5SHHnpIQkNDnRUSjz32mGl9eeDAAenUqZPMmDFDWrdubUsbMWrUKJk/f75kZGRIjx495Pnnny97nl0EhlD/6h4FAKjYssawYcPkkksuMUGJcePGOedv3brVlC969epl61rbrVs3WbFihQwZMkS+++47ycnJsS2jqao0AKLL9O7du8DrablDJ/d9y8/PN1Np6PO0zFPa5/sT9sU/+dN5aVS1rkjat27zzin2trnuS3GfUy2usci1f5yYkblPQt9pU2C9UsHHx5/OS1mxL5Xn3HjzevVVXQQAAPBvxartrVGjhslBXRQtBOky3kzFMGHCBHnxxRdNq0kNUnz77bdy0003SfXq1eWuu+6ypY14/fXXpUWLFqayQtNGpKamSlxcnDNtxOLFi03aiISEBBk5cqRJG6EVFWFhYV7bXlSggb9Iw62fSfqhreZu4xrNCl20cbVG9hn5ueaHcnx+ZnlvJQCgmMqrrKHf/evWrTOppdxpQEPVrl3bNl/vb9u2zblMRESErYeHtYz1fE9jd2iDC0/ddjMzM0tdQaS9RvQYWA07AhX74p98el4c+RKS/bfz7jU1zpLEA/faFtnTaYbs3bu3WKvbv3+/aRylt/q7oTRCshxi/2QQSduXJo5Ih1Qk3i/+KZjOS3nsj2sKx7LyVV0EAACVTde6HaXlzk9s85JaXuX8/+YWV0r9H0/cV5HnPSl+HdT44osvxBdWrlwpl156qWldqXRQEu1tocENT2kjlAZAtKJB00ZoC0srbcScOXNMC02laSMaNmxo0kZ4amGJABBVS249445iLTq8/TD7jIy04wOOAwD8RnmUNbZv324aQXzyyScSFRVV6HLulSVW5UhRilrmgQcekHvuucfWylTLHYmJiaVuRaoVTvp6uo5Ar0BjX/yTT89LRpqEzm1b5CKJtRJFohOLtTot/4eHh5vGTElJpSzzZYSUaRu8hfeLfwqm81Ie+1PUd25J+aouAgCAyqZ/4x4iy66xz2zcQzbvOGj+TYyuKY3z3BouxFRs2bjEQQ1Nw+AL5557rumpsWnTJtML44cffjADdGogozzTRpQ1dUQwda32C/n5BQZ/Kar7v/bQ0fOttx7PQQnXh5KeLq5/X+L4+1YwHf+K3ofyKGtoGUBbdnfo0ME5T1txLl++3AwMrr06lZXi0qLPsXpv6MDh2dnZJsWla28NXaZLly4eX1fLIjq504qislQWaYVTWdfhL9gX/+Sz81KM1zPbVMzt0vdqnz59zG2p98XD80qyDd7E+8U/BdN58fb+ePOY+KouAgAAHKc9n7X+vHq14xmR/EWpBhv46quv5KWXXpItW7bI22+/LfXr1zc9IZo2bWoCEd5y3333mZZWLVu2NGmitCLiySeflGuuuaZc00aUNXVEsHVH9rUjR/+Q+FB7a58Du7ZKXFVHocdfe/forac0BSFZ+/winUCw4vrn+FdmwXT9ezN1hK/KGjqGlg7o7UrTWGq5QssYzZo1M0GLpUuXmgHAlQYwli1bZlJgKg2IVKlSxSwzcOBAM2/Xrl2yYcMGkwITgP+pVauWXHfddea2tGZufEtS47va5jXeMFuGdxzphS0EUFoVVRcBAADcytZxRWcz8PugxrvvviuDBg0yO6M5qq3eDFr58dRTT8mHH37otY176623TKooTSWlY2qsX7/ejI+hPS1uuOGGcksbUdbUEcHWHdnXJm2cKKmJfWzzUrYvlIndJnlcPj09XX777TdzvmJiYvw2nUCw4vrn+FdmwXT9ezN1hK/KGtpjT3tmuoqNjTUpaaz5Wq7QdSYnJ5tJ/9fvjmuvvdbZKuWWW24x43Hp82rWrCmjRo2Stm3bOtNaAvAv2gBp8+bNpszusSxYDNuP7ZLUiJr2mUd3emcDAZRKRdZFAAAAt7L1qY2kdCVrPwlq6EDcmhJq8ODBZvBNi6ZgePzxx726cffee6/cf//9cvXVV5v7WoGgPTC0F4UGNbR1ZXmkjfBG6ohg647sW56CT8ePryfaglav0xkzZpgKKn9OJxCsuP45/pVZsFz/vtz+iixrjB49WjIyMmTo0KGmrNCpUyczBocGRCxTpkwx+fm1p4Yuqz1AXn/9ddOLFEA5GfiLGUPNKSqh2E/966+/5Iknnii8LAggIFVk+QAAALiVrZ99QpIDOaih+ae7drV3xVbaEurgweMDh3iLtrh3r1TRCgQrz7d2MSVtBEpq9d71cjC6sW1ejb3rpVPjnhxMAPAD5VnW+PLLLwsEocaOHWumonqtTJs2zUwAvG/ahtmyzS3Vk6x/Rc6qd7YMTLnCJ4f8+/2/+OR1AfhHXQQAAPBvJQ5qaI8ITe3TpEkT23wdwFtzU3tTv379zBgajRo1Mumnvv/+e5k8ebLcfPPNzooI0kagpN7eskRSqx3PnW5J2bKEoAYA+ImKLGsA8L1tR3cWSPXUMaKq/OOUS322TQD8D+UDAABQ6qDGkCFD5K677pJXX33VBBV27twpK1euNPmlH3nkEfEmbRH58MMPm5QQmi5Kx9LQ13d9HdJGAAAQXCqyrAHA/7TLTpO72twgOfk5ZlKhIaESFe6bsX4a5h42t7WjSz/wOICyo3wAAABKHdTQIMKhQ4fk/PPPNwOFaPdPHXtCKxruuOMO8SbNZz116lQzFYa0EcGvX+ML5Nxv3rfNi2/3z0KX1xRlVatWJdc5AASoiixrAPA/P0YkyvVfjLTNS4lvIZO6TSjW871RFlzc+2WR2Un2mZecyOEPoOJRPgAAoPz8enCLpEfYy78xB7dIRFiiKVu/v/1Tya3e0fZ4vc2LZHC72wIjqKE0JdSYMWPkl19+MeNbnHrqqWbngPLQre5ZIum/22fqvEJoupLnn39ekpLcfogCAAIGZQ2g8ujZ4Bw5468Pzf85IaHyTmyLMq2PsiAQvCgfAABQPl75daGkxnexzUv5daFM7PaMqWedtHGipGbXtz++P9Vnp8M+CncxzJo1y9zGxMTImWeeKWeddZYJaOTm5soDDzxQHtsIAAAqEcoaQOXSu8F5cu2xX80UnZ8rKdl/S0r1ZqZ3hjU1rtbI15sJwMcoHwAAgFIHNUaOHCmXX365/P333855v/76qwluLFy4sKSrA7zuzz//NClK9NaTUe1uken7PrNNOg8A4B8oawCV18D0TTLpwHKZ1Pl+k27Kmoa3H+a1siCAwET5AACAivfn/8rWh/ccH2cuYIMa33//vezZs0fatm0rS5culRkzZsgZZ5whbdq0kfXr15fPVgIlkJOTYwaW11tP6sQkSuO8I7ZJ5wEA/ANlDQDlWRYEEJgoHwAA4LuydX5uvl8d/hKPqdG0aVNZvny53H333dKnTx8zAN/s2bPl6quvLp8tBAAAlQplDQAAQPkAAAD/UbVKrOTm7bTNqx7huzG2SzVQ+H/+8x+ZP3++dOnSRVJTU2XmzJnStWtXqVevnve3EAAAVDqUNQAAAOUDAAAqxj9bDpT0Jf1t82I63S9y9Pj/w069XpJXdLY/6eI5gZN+asiQITJw4EAZPXq06bHx448/SmRkpElHxZgaAACgrChrAAAAygcAAFScljWayRnZe22TzvNXJe6p8c0338jq1avltNNOM/fr1KkjH374oRlb4+abbzYBD8CX6tatawaw0VsAQOChrAGgLCgLAsGJ8gEAAD4sW9dJCuygxnfffWd6ZrgbNmyYXHjhhd7aLsBp9d71cjC6se2I1Ni7Xjo17unxKMXExEi7du3MLQAg8FDWAFAW3igLjlo1XlJrX2abl7JqvEw6/1lODuAjlA8AAPBl2ToksIMangIalpSUlLJuD1DA21uWSGq19vZrbcuSQoMaf//9t/z73/82vYZq1arFEQWAAENZA6hcfti/UY5E2sfmi9u/UU5rkFiq9VEWBIIT5QMAACre31Y9a78LpFagBTXOOOMM+eyzzyQ+Pl7at28vISGFR2bWrVvnze0DSuzAgQPy3nvvSc+ePQlqAECAoKwBVF5zNr8vqTXOss1L2fy+nNaga6nWR1kQCB7lVT54+umnTQXNr7/+KtHR0dKlSxeZMGGCraGmw+GQxx57TF5++WXzudKpUyeTdrt169bOZbKyskxKjvnz50tGRob06NFDnn/+eWnQoIFzGX3unXfeKR988IG5379/f5k2bZrUqFGjFEcEAICK5Sxbn9ch8IIal156qbNVhP5fVEEC8HezNy+SndU72ubV27xIBre7zWfbBACVHWUNAABQUeWDZcuWmRTaHTt2lNzcXBkzZoz06tVLfvnlF4mNjTXLTJw4USZPniyvv/66tGjRQsaNG2cazqWmpkpcXJxZZsSIEbJ48WJZsGCBJCQkyMiRI6Vv374mVVZYWJhZ5tprr5UdO3bIkiVLzP3bbrtNBg0aZJ4HAADKMajx6KOPOv8fO3ZsKV8K8A8/7k+V1Kj6tnkp+1N9tj0AAMoaAACg4uoirACD5bXXXpOkpCQTjOjatavppTF16lQT7BgwYIBZ5o033pDatWvLvHnzZMiQIXLo0CGZNWuWzJkzxzm+6Ny5c6Vhw4by6aefSu/evWXjxo3mtVatWmV6eqiZM2fK2WefbYIjnlJ4a+8PnSyHDx82t/n5+WYqD7pe3efyWn+g4DhwDLgOeD9U6s+E/HwJLTArv8jjYOZ5+fgU93gXe0yN9PR0uffee013k5ycHPOl/X//93+k9wEAAF5BWQOAv+hat6O03PmJbV5Sy6t8tj1AZVYR5QMNUKiaNWua261bt8ru3btN7w2L9hjp1q2brFixwgQ1NACi2+O6TL169aRNmzZmGQ1qrFy5UqpXr+4MaKjOnTubebqMp6CGpsbStFfu0tLSJDMzU8qDViDpMdBKq9BQ9yqtyoPjwDHgOuD9UJk/E0Ky9kltt3lp+9Jk//7DplejpqESD487Ih1e3Y4jR454N6ihLSS02+V1110nUVFRJmfk7bffLm+//XZZthM4qVHtbpGsRZ1t8yLPe7LQ5atWrWpyouotACBwUNYA4A3eKAv2b9xDZNk19pk6D0DQlQ+0suqee+6Rc8891wQklAY0lPbMcKX3t23b5lwmIiLCjPfhvoz1fL3VHiDudJ61jLsHHnjAbI9rTw3t/ZGYmCjVqlWT8qq409Re+hqVoeKuMBwHjgHXAe+HyvyZsDj1c0mrevx70JKY/qOc2bib6cU4/8BHMjnxEtvjydvmyhPnPuXV7dDv+uIodlBDB9HSrpVXX321uX/99dfLOeecI3l5ec5ckUB5qBOTKJLnFqXTeYXQQuS//vUvj4VHAID/oqwBVE53tL5eMv9jDxhEdXmk1OujLAgEl/IuH9xxxx3y448/ytdff13gMfcxPDQAcrJxPdyX8bR8UevRHiHWOCKutEKtPCvVdHvK+zUCAceBY8B1wPuhsn4mfLX7O0mNPcU2L2X3d9Iv5WrTmGDSxomScaiK7fGsvByvH5virq/Yr7p9+3Y577zznPfPOussCQ8Pl507d5ZuC4Fykp2dLXv27DG3nlSPqCoJeRm2SecBAHyLsgZQOTWJayAtcw7YJp1XXmVBAIGlPMsHw4cPlw8++EC++OILadDgxOdOnTp1zK17b4q9e/c6e2/oMvo5456Ow30Z/TzylErKvRcIAAD+KPt/Zeu8nDzxJ8UOamgrCO1a6UoLEppTC/C3Qq/mXNVbTx4+4w55fd/HtknnAQB8i7IGgIooCwIILOVRPtCeEtpDQ3uBfP7559K0aVPb43pfAxJLly61VeosW7bMpLdTHTp0kCpVqtiW2bVrl2zYsMG5jA4IrvnY16xZ41xm9erVZp61DAAAgVC2PrK3eGNdVJTwknzp33jjjbZukDpIlab5iY2Ndc7TQgEAAEBJUdYAAAAVUT4YNmyYzJs3T95//32Ji4tz9sjQAbyjo6NNupERI0bIU089JcnJyWbS/2NiYuTaa691LnvLLbfIyJEjJSEhwQwyPmrUKGnbtq0ZzFy1atVK+vTpI7feequ89NJLZt5tt90mffv29ThIOAAA8HJQ44YbbigwT3NZAgAAeANlDQAAUBHlgxdeeMHcdu/e3Tb/tddeMwEUNXr0aMnIyJChQ4eaFFOdOnWSTz75xARBLFOmTDG9RgYOHGiW7dGjhxnU3HWsjzfffFPuvPNO6dWrl7nfv39/mT59OicaABBQ2ia0lHYH59vm1Um+zP+DGvrlDgAAUF4oawAAgIooH2jvj5PR3hpjx441U2GioqJk2rRpZiqM9uCYO3duqbcVAICKMKnz/SKzk+wze++VzTsOmn8vbtBNkv+8z/54s4v9P6gBAAAAAGXmyBfJ3H/ifuY+DioAAACAYiOogaDTvHlzmT17tiQluUUXAQAA4Hsa0HBvBeZnZcFfD26R9Aj782MObpGW0Yle2EIAAAAgMDS3ytZxISIrxG8Q1IDfm715keys3tE2r97mRTK43W0+2yYAAAAEr1d+XSip8V1s81J+XSiT6nby2TYBAAAAOC70f7eA3/pxf6p8E1XfNum8wvz111/y2GOPmVsAAAD4t4UxLeT/qp1umxZu+bDU66MsCAAAAHiHs2y9c5f4E3pqIOhkZmbK77//bm4BAADg39ZE1pHUiJq2eSl7f5SBrf2sLJifI5KRVvjjUQkiIbQZAwAAQPDIdJats8SfENRApTNm7WTZnHiJbV7y2snyZNenfbZNAAAAcBHqhz9T9v9Q9Fggg/eKMOYGAAAAUO5oSoRKJysvWzJCq9gmnQcACC4vvPCCtGvXTqpVq2ams88+Wz766CPn4w6HQ8aOHSv16tWT6Oho6d69u/z888+2dWRlZcnw4cOlVq1aEhsbK/3795cdO3b4YG+A4HVW1m4JD/HDIAYAAAAAv8SvB/i96hFVJSEvo8A8AACK0qBBAxk/fryccsop5v4bb7whl156qXz//ffSunVrmThxokyePFlef/11adGihYwbN0569uwpqampEhcXZ54zYsQIWbx4sSxYsEASEhJk5MiR0rdvX/nuu+8kLCyMEwB4wcD0TfJOjTMkNy/Xb47nP1sOlPQl/W3zYhw5PtseAAAAwJd2HNsteVXibfOijuyQJj7qqUxQA37v4TPuEJn9uH3mxXMKXT4pKUmGDBlibgEAlVe/fv1s95988knTe2PVqlVy6qmnytSpU2XMmDEyYMAAZ9Cjdu3aMm/ePPM9cujQIZk1a5bMmTNHLrzwQrPM3LlzpWHDhvLpp59K7969fbJfQMBx5Itk7j9xP3Nfub6cN8qCLWs0E8ne69XtAgAAAPzVMz+8IlsTLrDNa/rDK3Jbq6GmbL1o/1LZWrOb7fGUn+fKpKT24gvhgTDC+n333WfSRWRkZJiWlFrB0KFDB2fqCB2B/eWXX5YDBw5Ip06dZMaMGaYFpmvqiFGjRsn8+fPNOnr06CHPP/+8acGJ4KOta8855xxnK1sAAPLy8uTtt9+WY8eOmTRUW7duld27d0uvXr2cBycyMlK6desmK1asMIU27Y2Rk5NjW0ZTVbVp08YsU1hQQ8sdOlkOHz5sbvPz881UGvo8LfOU9vn+hH3xT+V6XjLSJHRunSIXSa7eWLIcDuf9RnGNSr0tmiquS5cu5rbU+5OfX+I8vea1vHz8eL/4p2A6L+WxP8FyXAAAqEz2ZOyT7eHVbPNiMvY561lXbvxG5JD4Db8OamiQQg/a+eefb4Ia2tpKR1uvUaOGcxlSR8CdtqzVFrSXXHKJxMfbu0Wps5LaSaPdn9vm1Um+jAMJAEHop59+MkGMzMxMqVq1qixatMj00tCghNKeGa70/rZt28z/GvSIiIgo8F2iy+hjhXn66adNgwt3aWlpZjtKW0Gk329a6RQaGthDorEvle+8hGTtE/s7raA7G18vjshatnl795aup8TBgwflyy+/NOPkuP5u8PY2u0vblyaOyBOBGW/g/eKfgum8lMf+HDlyxCvbBQAA/KeeNav6iYZ7/sCvgxoTJkwwKR5ee+0157wmTZo4/9dCV3mljihLK8tga7njcx5ayhXVEk5/AOt10LFjR6levXqBx69o0kdCv77Rvr4mfThfXjtdXP++xPH3rWA6/sGwDyolJUXWr19vKjnfffddueGGG2TZsmXOx0NCQmzL6/lzn+fuZMs88MADcs8999jKEFruSExMNAOWl/Z86GvqOgK9Ao19qYTnJaPo95RKrJUo4qV8vFr+1/e7NowqdQoqRy3Jv77w4KVkpknoO23LbR8svF/8UzCdl/LYn6ioKK9sFwAA8L19+/bJ7NmzpdHgBiJ+NMSxXwc1PvjgAxN0uPLKK00FRP369WXo0KFy6623msfLM3VEWVpZBlvLHV/z1FKuqJZw+/fvl9zcXHPrKahR0vWhZLj+fYvjz/H3lmBpZak9LayBws8880xZu3atPPfccya1pdJyRN26dW2Bcav3Rp06dSQ7O9v0HHXtraHLaGqbwmhZRCd3WiYoS7lAK5zKug5/wb5UsvNSjPWZ1/TS6+q6yr4voSKxJ0qM/d77R4ElUuK7yqQDy8tlH1zxfvFPwXRevL0/wXJMAACA//LroMaWLVvMgJ7a2vHBBx+UNWvWyJ133mkqCgYPHuxM/VAeqSPK0soy2Fru+JyH1n1FtYTTgFJ4eLgkJCR4bp1XwvWhZLj+fYvjz/H3lmBtZakNDrQnZtOmTU3QYunSpdK+/fGBzTSAoY0otKeo0vG7qlSpYpYZOHCgmbdr1y7ZsGGDSX8JoAwG/iIS5ZJuKiqBwwkAAAD4SEr1phKzd6VtXsPqPZz/9298odT8/V7b43Fn3i2+Eu7vlXPaqvKpp54y97XS4eeffzaBDg1qlGfqiLK2sgy2ljs+5eEYFtUS7qSt80q4PpQc179vcfw5/t4QDN9f2iDioosuMo0StOfJggULTJ79JUuWmPfJiBEjTBkjOTnZTPp/TEyMXHvtteb52tvvlltukZEjR5pAec2aNWXUqFHStm1bZ0pLACXXr/ZlIsseNP8n/C+Y0bxGM3m48/F5AAAAACrWra2uElk73D6z1fuyecfB4//WaC7JWTvtjye0El/x66CGpoPQwTxdtWrVyuTIVdrCsrxSR8B3pn0/Q7Yd/vPEjPxckfiuclbWbhmYvumkz4+OjjbpxfQWAFB57dmzRwYNGmR6V2iAol27diag0bNnT/P46NGjJSMjw6S21HJCp06d5JNPPpG4uDjnOqZMmWJ6/2lPDV22R48e8vrrr0tYWJgP9wwIHvsz95vbWlne66lRHmXBS5v3k/d/X+y19QEAAACBINpZtvavbA5+HdQ455xzJDU11TZv06ZN0rhxY/M/qSOCkwY0Ug/YgxcdHdnyj/TfivV8HTNFK6pKPTAkACAozJo1q8jHtbfG2LFjzVRUGq5p06aZCUAxOfJF/hesMDL3VeihoywIAAAAeLlsHVd0VqSK5tdBjbvvvtv0ptB0ENpCUsfUePnll82kSB0RpLRnhpvvIxLlusSLnPeT106WJ7s+7fnp+fmSnp5uboMhfQoAAEBA0YDG7MIbl5yT+Zd8E1W/3F6+PMqCSTGJkhLfwnlfG+CkRtSUoQkXOOc1/eEVubfzA155PQAAAMAf5Ftl69ho8adaVr8OanTs2FEWLVpkBu1+/PHHTc+MqVOnynXXXedchtQRweespHbSaPfnzvs5EiZfRjeU3JATqT6y8rILff7WrVtl2LBhMmPGDJMjHQAAABVn2obZsi2+q/l/1OFvpU5eeoUe/vIoC/Zv3s9MllFfjJTUQ1tke3g157yYjIrtkQIAAABUWNn62SfEn2pZ/Tqoofr27WumwpA6IvgMbHaxyNc3mv9zJFSernGWV9f/x5Edklnl+PgqC2NTZG1kHYn6dLg81PlBOS2xnVdfCwAAoLLZdnSn6cWgsqTg+DP1co9KSvVmIqEnfoo0rtaoQrcRAAAAQODy+6AGKrdFMafI4ZAIScn+2za/cdVzS73O6T/PldSa3WzzMvOy5Ej2kVKvEwAAAMUz+NhGkc7LRKITOWQAAAAASoygBvzawPRNZpKBv4hE1TrxQFSCLzcLAAAAxaQ9bxd1mi4DU64I7rJcfo5IRpp9H0P8KfMwAAAAEBwIaiAwaECjvFvzZR8+8UOUH6EAAABllhNyPJXo4QO/ycAg6pmRUr2pxOxdaZvX8NjvIrOnnZgxeC+9UQAAABAQDmYdltzQKNu88KzDzv+/2v2trI1taXs8YcdX0jt5gPgCQQ0EncaNG8v06dPNbYks+6dI1s7j//MjFAAAoMwmV+9gBtNOCYSyYAnc2uoqkbXDy239AAAAQEUa9/3zkprYxzYv5fvn5alznjZl6xf/fF42V7UHNVJ2fENQA/CW8PBwqVatmrn1pHHVeiJp3xaYH+fI5iQAAAB4kQY0/K0sCAAAAKBkZevQMP9Kq0pJH0Fn165d8txzz8ldd90l9evXL/D48DaDRdaN8sm2AQAAwLdlwQqTuc9+n/SmAAAACNCy9dGzjvpVJMGPNgXwjvT0dFm/fr25BQAAQMW6slkfObjsVtu8Gu2HBldZUAMUmq7UNYCx8FT7Mu73SW8KAACAAJP+v7J1o3YNRKqK3yCoAb/zx5Edklkl3jYv6sgOaeKtwSWL8yMUAAAApdIp6XSRjG32mTovmISE2gYB14EVx8V3LbBYv4zfpVvmXxW8cQAAAEBwI6gBvzP957mSWrObbV7Kz3NlUlL7cvkRCgAAAJRFriNPUiNqFph/bhYBDQAAAPi/fo0vkHO/ed82L77dP0Xyjv8/os1N0mzNBbbHQ3tsFV8hqAEAAAAAAAAAQCXVre5ZIum/22fWPUs27zho/o0Mi5AYR6798fDICtxCt5f22SsD5SQhIUGuueYac1scH+/4SvbHtrSvY8dX0jt5QDltIQAAAPylLOgVkfbUqQAAAEBQla1r+ld5l6AGgk6NGjXkoosuMrfFsXTHN5Ja1R7USNnxDUENAACASlAW9IqQkIp7LQAAAKCiy9Zx/lXeDfX1BgDedvToUVm9erW5BQAAQOXii7JgeGi4pMS3ODFVbyYp2X9LfH5mhW0DAAAAUH5l62PiT+ipAb8zKPlSOfLpNbZ5cWfeXezn79mzR2bMmCGnnnqqVKtWrRy2EAAAAP7KF2XBGpE1ZFK3CSdmZKSJzE6qkNcGAAAAyr1s3ewJ8adaVoIa8DunJbQSydppn6nzAAAA4H8c+SKZ+0/cz9zny60BAAAAEOQIagAAAAAoPQ1o/K9XwsGQCBmUdLFI7cskLj9LBh7bZObH71oj3ZpdwlEGAAAAUGYENVDpjTvzbsmf39R2HEJ7bK30xwUAAKCkckNODNl3JDRSZsW1Nf+nbPucoAYAAAAAryCogaATEREhjRo1MrfFERUeKeLItc/UeQAAAAj6siAAAABQ2a3eu14ORje2zauxd73UiWhhytbzti2WI/FdbY833jBbhnccKb5AUANBp2HDhjJu3DhJSmJwRgAAgMrGH8qChf0o7NS4p8+2CQAAACjM21uWSGq19rZ5KVuWyMRuPUzZetLGiZKaW9P+pKNuYyJXIIIaAAAAAMpXaOX62VHYj0KCGgAAAEDZnUh6CwSJLVu2yE033WRuAQAAUHHCHfmSkv23pFRvJinxLZxT42qNKmwbKAsCAAAA3i1bH9x5UPxJ5WoyhUrB4XBIXl6euQUAAEDFqeHIlkkHlov0e0ckOtEnh56yIAAAAODdsrX4WTUrQQ34nY93fCX7Y1va5iXs+Ep6Jw/w2TYBAAAAAAAAQGVULzZJamT/bpvXuOq5PtseghrwO0t3fCOpVe1BjZQd3xDUAAAAAAAAAAAvG9XuFsla1Nk2L/K8J+XI38f/H3TKPyR5xQT7k7R3to8Q1AAAAABQOEe+SOb+wh/PTOPoFfNHIQAAAOCP6sQkiuQdsc+MSZQjf/vXWBoWghrwvx/K+Tnmpl12mvwYUfJczA0bNpSnnnrK3BbHtA2zZVt8V9u8xhtmy/COI0v82gAAAEFHy2mzkyRQlLQsWJE/CgEAAIBA0tAqWzeoLf6EoAb874dyfFfp6MiWuw6tk+uTLi7x6iIiIqRBgwbmtji2Hd0pqRE17TOP7izx6wIAAFRGM6u2le3hVW3zGm58S2494w6fbE9Jy4IAAAAATla2DhF/EurrDQDcnZW1Wx44uEaqSH6pDs7evXvllVdeMbcAAAAoX6lV4uX7yNq2KfXQVp8ddsqCAAAAgLfL1v6VcpagBvzOwPRNpQ5oqCNHjsjy5cvNLQCg8nr66aelY8eOEhcXJ0lJSXLZZZdJamqqbRmHwyFjx46VevXqSXR0tHTv3l1+/vln2zJZWVkyfPhwqVWrlsTGxkr//v1lx44dFbw3AIqLsiAAAADg5bL10WPiT0IDrXIiJCRERowY4ZxHZQQAAPBk2bJlMmzYMFm1apUsXbpUcnNzpVevXnLs2InC2MSJE2Xy5Mkyffp0Wbt2rdSpU0d69uxpC4xruWPRokWyYMEC+frrr+Xo0aPSt29fycvL48ADAAAAAFDBAmZMDa1oePnll6Vdu3a2+VZlxOuvvy4tWrSQcePGmcoIbYmpLTOtyojFixebyoiEhAQZOXKkqYz47rvvJCwszEd7hCIN/EVCw+Mk5dsp5m7jGs3K7YA1rlpPJO1bt3nncoIAIMAtWbLEdv+1114zPTb0+79r166mYcTUqVNlzJgxMmDAALPMG2+8IbVr15Z58+bJkCFD5NChQzJr1iyZM2eOXHjhhWaZuXPnmsHSPv30U+ndu3eB19WeHTpZDh8+bG7z8/PNVBr6PN3e0j7fn7AvAXhe8vNL0RLKd9er67747D3j4ZiZbSnh9vB+8U/BdF7KY3+C5bgAAAD/FRBBDW0Red1118nMmTNN0MJSXpURZa2QCLZCrk9+9EXUlIjoRJnY7RmXxfLL5YfssFOvl9B1o+zr6PG85B/bc2JGVIJISEB1bPIZrn+Of2UWTNd/MOyDOy0TqJo1a5rbrVu3yu7du03vDUtkZKR069ZNVqxYYcoRGgDJycmxLaOpqtq0aWOW8VSO0J6ljz32WIH5aWlpkpmZWerzoduv11doaGB/H7EvgXdeQrL2Se0inls775ik59p/VlQPreqz8c32799vembpbfXq1X2yDZ6O2f6/fpX8yMJzETsiahYob/J+8U/BdF7KY39IAwwAQPDJysuW9BB7mT80N0uifLQ9ARHU0NQRl1xyiQlKuAY1yqsyoqwVEsFWyPXFj760fWniiHSUan16vi+44AJzW5wf055eP/SdNrb7e/r8JI7IWqXansqG65/jX5kF0/UfbBUSek7uueceOffcc00ZQGkZQmljCFd6f9u2bc5lIiIiJD4+vsAy1vPdPfDAA+a1XBtGaGOKxMREqVatWqmvLU3BqesI9GuLfQnA85IRYrv7a5V4SQ+p4rzfI3O7xGRskZY5B06s76J5ItGJ4gu6HzqGTvPmzc3++ITbMVOJX3Qv8in51+8ucMx4v/inYDov5bE/UVG+qt4AAAClNXvzItlZvaNtXr3Ni+Siuv8wGY9e+GOe/JnU1/a4ZtiZdP6z4gt+H9TQlFHr1q0z6afclVdlRFkrJIKtkFvepn83V/6M72qb12jvErmjw4njXxI6kKumGSv28ffwo9NdYq1En/0wDzRc/xz/yiyYrv9gq5C444475McffzRjYrjTc+YeAHGf566oZbSBhU7u9Jooy3Whr1fWdfgL9iXAzovb/VeqtpVU7VXgIiX7b5l0YLnLU0ILPK+i6GfwVVdd5dPP4tm/v1/wR2HuURl8bGOhzynsmPF+8U/BdF68vT/BckwAAKhMftyfKqlR9W3zUvanyvVtEmTgwIEyaeNEkePJD/yCXwc1tm/fLnfddZd88sknRVaueLsywhsVEsFWyC1P/8/efYBHUa19AP+nF5KQnlBDEQLSpQRQAaUrIDa8oqBe7IAiYMEKNhRRvB+I18IFARWxoGJBsYFKbyKIESmRnhDSe7L7Pe8Ju9nZbJJNsptt/9/zTHZndnYzc2Z258x5T/kn91SlG2Pknqpz2hUUFODPP/9UwadGjRrV/AYr/o8jb8xdEc9/pr8nc5fz39W339TUqVPx+eefY+PGjWjevLlxuQwKLqSSQ5MmTYzLpZWfocKErFNcXIyMjAxNBQlZp3///g26H0SO8nnK90gNqWjFWinf5mQkL3jgwAE1vp5VecGGuiksPgdUE9QgIiIiInLWvHVJUSmciVOXWEjXUVJo0LNnT/j6+qppw4YN+L//+z/13FDgYN7ioqrCiKrWIfdy8uRJ1X2YPNZFIXxUH3GmU2FpxfgqRETkGqQCg7TQ+OSTT/DDDz+gdevWmtdlXvIJ69evNy6TPIPkNQwBC8mD+Pn5adY5deoU9u3bx6AGeYyNp7bjs0YXGCd3zwsSEREREZE2b513NhfOxKlbagwePBi///67Ztltt92GDh064OGHH0abNm2MhRE9evTQFEa8+OKLlQojpKmMaWHEvHnzHLBX5HRkEPCJFWNvPL7pGSTnHHOaPuKIiKjuY3K99957+Oyzz1SNbUMlCBk4OCgoSLWqmTZtGp5//nm0a9dOTfI8ODgY48ePN647adIkzJgxQ3VtKIOMz5w5E126dFFjfRERWUtauPxfWHfjfHxpPsbl/8UEJCIiIiJyp6CGFEAYBvM0kCbkUqhgWM7CCKo3L2/teBneFQNfEhGR63r99dfV46BB2sF5ly5diltvvVU9f+ihh1Rz2nvvvVe16kxKSlLdXkoexGDBggWqhahUjpB1pdLFsmXL4OPj08B7RESubn1QK013VAxqEBEREZEzaOwfgqiygkrLDPrH9UTgmUWa16M6TYCjOHVQwxosjHB9CSFNgbQdZssucdj2EBGR+3Q/VRNprTF79mw1VUXG9Vq4cKGaiKjCnIxNxufB+hImTTU3hek+QUwfIiIiInJaT1w0BVj+tHbhFStw8HimenppfC+0O/yn9vXml8JRnHpMDUt++uknvPrqq5UKI6RLqcLCQtX1lHnrDkNhRHp6OvLz87F27Vq0aNHCAVtPlkztPBHzMzZqJllWV1JzVgZzZQ1aIiIiIvuQVgYXFacapw4l2vHrHMkZ8oJyU7js7DfGSQ0STkROY+PGjRg9ejSaNm2qyhQ+/fTTShUjpJxBXpcuK6XV5/79+zXrFBUVYerUqYiOjlY9SowZMwbHjx/XrCOtQCdMmKC6s5RJnmdmlhcOERERuQIfY97aucIIzrU1RDbQqlUr/Oc//1GPRERERFQ/8/s+grVnPtVMUgnFWblKXlDG2PjTL8I4Hc3RFoYSkf3k5eWhW7duWLRI242GgYy/+corr6jXt2/frsbyHDp0KHJycozrSFfYa9aswapVq/DLL78gNzcXo0aNQllZmXEdGaNrz549WLdunZrkuQQ2iIiIXEUrQ946oSWcict3P0Vka0ObX4yLTnzlNH3EERERETmzmREDVAG9qcQtL2D+ZS87bJucTYC+DEG6ii66Cs6P4fZg5EDjssT9KzE/todDto/I04wcOVJNlkgrDekd4rHHHsM111yjlr3zzjuIi4vDe++9h7vuugtZWVlYsmQJVqxYgSFDhqh1Vq5cqXqE+O677zB8+HAcOHBABTK2bNmixuwSb731Fvr164fk5GQkJiY24B4TERG5FwY1yO0cPXoUs2bNwty5c9GmTZtav3+49Af3g/P0EUdERETkdMbtBwJjyp9veQHIOqx93dvXZfOCNhEYBUxMNc4+Z/byzE3PIDnnWINvFhHV7MiRIzh9+jSGDRtmXBYQEICBAwdi06ZNKqixc+dOlJSUaNaRrqqkK2xZR4IamzdvVl1OGQIaom/fvmqZrFNVUEO6tZLJIDs7Wz3qdDo12YN8rgRz7PX5roLpwDTgecDvg0f/Juh0lbp0kn0/fPiwCvQ/98QMXGDhdXmfbTfDus9jUIPcjjT3lb5LTZv9EhEREZENSUAjKMbhAQynzQt6eVekjyXnW2oQkfORgIaQlhmmZD4lJcW4jr+/v+pj3Hwdw/vlMTY2ttLnyzLDOpZIQHbOnDmVlqelpalxRO1BCpCk9YkU3nl7e24v5UwHpgHPA34fPPk3wavoLLRXPiDtbBpSU7ORmpqKs2fPVgpqyOv6AL1Nt8O0q8fqONcdCBERERERuZQ+8b3RNrwNvjqyztGbQkRkMzKAuCkp1DJfZs58HUvr1/Q50tJs+vTpmpYa0q1VTEwMwsLCYK+CO9km+R+eUHBXFaYD04DnAb8PHv2bUFD52hQTHYPMQj/4+vpWCuQbXq+2Ik8dBAYGWrUegxpERERERFRn4xKvw9u//48pSERuQQYFF9KaokmTJsblUkvV0HpD1ikuLlatwkwLeWSd/v37G9c5c+aMxRYX5q1ATElXVzKZkwI1exaqScGdvf+HK2A6MA14HvD74LG/Cd6V99Gw74Z0sPS6pffVbzOs+zwGNYiIiIiIqIJeBxSmV8wXnmXq2NiEdlch57sbNctCez3AdCZyAq1bt1YBifXr16NHjx5qmQQwNmzYgBdffFHN9+zZE35+fmqdcePGqWWnTp3Cvn37MG/ePDUvA4JLtyXbtm1Dnz591LKtW7eqZYbABxERkas4kHkIZwKaapaFph9At+a2balhLQY1yOEKS4ug89Keit6lRbCusVFlMkCbNNmVRyIiIiKqbeYsHVheuR/46sQGxyAxor1xPiGspcOS3RXygt2iOgJFJ7ULZRkRNYjc3Fz8/fffmsHB9+zZg8jISLRs2RLTpk3D888/j3bt2qlJngcHB2P8+PFqfRnse9KkSZgxYwaioqLU+2bOnIkuXbpgyJAhap2OHTtixIgRuOOOO/DGG2+oZXfeeSdGjRpV5SDhREREjvLY9ldwMOZKzbJ221/Boz0fV3nrT/PW4HB4eZDeIPHgZ+jWfAAcgUENcrjHdyxAcuwozbLEHQsw/7KX6/R5QUFBKgMpj0RERERkf2PajlaTM2BekIhqsmPHDlx22WXGecMYFrfccguWLVuGhx56CAUFBbj33ntVF1NJSUn49ttvERoaanzPggULVB/j0lJD1h08eLB6r4+Pj3Gdd999F/fddx+GDRum5seMGYNFixbxABERkdMpKitGgbdfpWWGvPWXB9YChXAaDGqQ20lPT8fq1atx4403qsF8iIiIiKjuRseNNT5vUZqtHlv/9jYe7DvLKZPVZfOC5t18BUY5akuI3N6gQYPUgN1Vkb7DZ8+erabqBjJduHChmqoiLThWrlxZ7+0lIiJydN66oGWBUx0EDxjlhDxNZmYmvvjiC/VYF7+lH8AvAU01kywjIiIi8nTHfMPUdKbgrNvmBR1m9YXl3X4ZJtNxTYiIiIiIHJi3Lsotcqr0Z0sNIjMrDn6GZCfqI46IiIjI6XjzNoKIiIiIiByDdyNERERERFSlHkVnsDsgjilEREREROSm+sR2RcvTP2iWxber6Ib2pguuQpM/btO8Htj/STgKgxrkcEObX4yLTnylWRbVaQKcRaiuCNCVAAVp2j6Ovdh7GxERERHZcYwNnQ5eRWeBAi8gOIb5TyIiIiKyi3FtrgB+uVW7sM0VOHi8vEvX5o3i0a4kQ/t6aHM4CoMa5HDDm18K/PCndqEsq6PQ0FAMGDBAPdrCrMztOJB3CFhuMgDcxFQgyIUGniQiIiKqoxaluciP7afpciohrKXTpqet84J2IRVkJD8pQ2kc/grbTu8E0n/TrJLw9XhMzdkDYxsZ5j+JiIiIyFF565BGTpX2DGqQ24mNjcXtt9+uHm3BD2UYl/+XTT6LiIiIyNXckfs70Pd7l6nQYeu8oD18k/I90gvKBwIvgTeSc44B/pGO3iwiIiIiIst561AvOBMGNajBLdz9GlKy/1HPJ1x4E7qFNLHp5xcXF+P48eMIDw9HYGCgTT+biIiIiJybK+QF16d8h+QMVpohIiIiIhfJW7eNgzPlrDkoADU4CWjITZxMObknyvsLtqFjx47h0UcfVY91kRDSFInF54xToL7MpttHRERERPZT37ygI3SNTMTK1K/wQeoXxunZjF8dvVlERERE5OGOGfLWx0/CmbClBjU8XWnF8w23A0XO9aWY2usBoPPEigUSdFl9oSM3iYiIiIjc2N5zyfhPp0cwq/td8PP2Y/6TiIiIiKgaDGqQw0k/wmuCL3CecSu8vF2mz2giIiIiW8ssykapt7ZxuW9RNsKZP7IZSwOtZ5cWYs3xTRiXeJ3lN5m3bpbBxiXfSkRERETkYRjUIIcq8fLG3PA+yPbyd56gBhEREZEHe3b3YiTHjNAsS9y9GPMve9lh2+RupvaYXPs3mbccnpjKijhERERE5JEY1CCHei2sO4q8fNXYFbbi5eUFHx8f9WgLqw9/hdNh3TXL4g9/hXGdbrHJ5xMRERE5lF4HFKTBq+gsUOAF6Epc+oDYOi9IREREROTujuYcR6FfhGZZYM5xeHmFqrz118c34GsnKh9lUIMcSgIaSlQ3YPRH2ub0ddSmTRssXboUsbGxNthCYFvqXiQHtdIsS0zdi3GdbPLxRERERI5VmA7vlfGIM8xHDAD8I+GqbJ0XdISF+5YjRY4DgGSTY7H2zKcO3CoiIiIicleL9q9EcuRAzbLE/Ssxb+BLKm89/8A8pyofZVCDnIMMiMh+momIiIgapmVGYXrFfGEaU93JpOSe1AQziIiIiIioAoMa1OCmdLoZhV8M1iwL7P+kzT7/2LFjeOaZZ/DEE08gISHBZp9LRERE5BYkoLHcdVsxeERe0Ju3aURERETkPHlr76FeQACcBnPL1OBahTYHSjK0C2WZjRQXF+Off/5Rj0RERERUO6MLDuGSohOaZRFdb3eZZHTXvKAtx6AjIiIiIqpN3rplSXMGNYhcSYCPP4LMBsyUZURERESuPl6DwfX5fyGp6LR6PrDwBDBuPxAYY5PxzshOCs9q5+UYeXkzuYmIiIjI5vx9/JyqfJQtNYhq8Fzv6ZW7aBi5lOlGREREbjNeQ2ahWVtyCWhwvDOHSQhraXxeUlICPx8g4dRRzTqFq7vg8YiLK97Tegym9p7RoNtJRERERO5hQrurkPPdjZplob0eAArKnz/Q+d9ot6mv05SPMqhBdrdw92tIyTxsnO8TcQHGMd2JiIiInIa+5xycCemJmOgYeHt7s2WGg03tMVk96nQ6pKamIjbUC94rF2jW0Xl5aYNTuScbejOJiIiIyE10i+oIFJnlJ6M64uDxTDgjp26fPHfuXPTu3RuhoaGIjY3F2LFjkZycrFlHr9dj9uzZaNq0KYKCgjBo0CDs379fs05RURGmTp2K6OhoNGrUCGPGjMHx48cbeG88lwQ0krMqptMH3rTr/4uLi8PkyZPVIxERebaNGzdi9OjRKp/g5eWFTz/9VPM68xHkEfQ6oCCtYjJrNi4+Ov4L9AHR5a0zZHLhboyYFyQiIiIisnHeOtaka1on4NR3Kxs2bFCJtmXLFqxfvx6lpaUYNmwY8vLyjOvMmzcPr7zyChYtWoTt27cjPj4eQ4cORU5OjnGdadOmYc2aNVi1ahV++eUX5ObmYtSoUSgrK3PQnpE9hYSEICkpST0SEZFnkzxDt27dVD7BEuYjyCMUppd3pWmY0n+rtMqZArPxGVyYJ+QFVwe3R4lz38oRERERkVvlrRvBmTh191Pr1q3TzC9dulS12Ni5cycGDBigale++uqreOyxx3DNNdeodd555x0VQXrvvfdw1113ISsrC0uWLMGKFSswZMgQtc7KlSvRokULfPfddxg+fLhD9s2TlcBH3YiNy//LLp+fmZmJr7/+GldddRUiI7X9RRMRkWcZOXKkmiyxVz5CWojKZJCdnW3sRkamupD3yfbW9f3OhPvSQC0zJJBhUJhmVfG3u5xj586dw1dffaVaZ7t6XtD4fZFupm4uH8hdbNvyHHal7zZb27mPH7/78Jhj48znIREREdWxnHXYxXCmnLVTBzXMScGCMNycHDlyBKdPn1atNwwCAgIwcOBAbNq0SRVGSABEBtczXUe6oOjcubNap6qgRn0KJNwpw24bes3cT0EtkFh8ThPUUGllo/RKS0tThVH9+/dHeHh4/T9Qp6tUEKDLT628vYFRLt1Vg63w/Gf6ezJ3Ov/dYR9qYq98hHSfOWfOHIvXp8LCwjofD8kHyfmlxjtwYdwX+/MqOou4dV2qfH1m9g4UwUezLPuSteqGxR3OscOHD6tAZIcOHdCmTRu44/elpAxI9o/WrFtSUqrG33BW/O7DY46Naa8JRERE5NrS09Px/vvv45JeFzKoUReSwZo+fTouueQSVZAgpCBCmI+dIPMpKSnGdfz9/REREVFpHcP7LalPgYQ7ZdhtQW6wzJU27oQzSa8Z5/XZZUBOqs2+bNJVmTw2btzYNgUDZsu8Pyo/B02dGfF7eV/UHo7nP9Pfk7nT+e8JBRL2ykfMmjVL5VlMK0ZIy46YmBiEhYXV+dySMUHkM1z93OK+2N+inSvxT8QAzbKuxWmYmHdAPY8vy6/0ntJm7ZGWC7c4x+R32NfXF1FRUaqVtzt+X/z8KtdNk2XOvL/87sNjjk1gYKBNtouIiIjI5VtqTJkyBXv37lVjYpiTDJgpKUwyX2aupnXqUyDhThl2WwgJDEZQrnZAykZBYYhpcaFr3MgWVJwn0m3WtoB4iwUEMdHnB9b0cDz/mf6ezJ3Of08qkLB1PkJae8hkTs6J+pwX8v/q+xnOgvtiX//knkKydFdkIlpXoF1p3H4gsCLf4u0fAa+8s25xjsn2u/s5NrT5JbjoxNea9aI6TXD6/XX34+LKbLk/7pImRERE5LxcIqgxdepUfP7559i4cSOaN29uXC6DggupKdmkSRPjcml2bah1KesUFxcjIyNDU8tS1pHuiapS3wIJd8vk1sdzvWeUD0ppauRSSUzXuJE1+Yyr8//Gn/6R2H4+sGFaQKD+F4+3wvPfsZj+TH9b8ITrlz3zEUQOGz9D6LSVSSwKNKuM4QFdzrmT4c0vBX74U7tQlhERERERWWHh7teQknlYew8RMQB9ik7bbRxkjwlqSC1ICWisWbMGP/30E1q3bq15XealsGH9+vXo0aOHWiYFDxs2bMCLL76o5nv27Ak/Pz+1zrhx49SyU6dOYd++fZg3b54D9orsLTg4GN27d1ePtvDMrkU4FF3RZ3oJx80gInILzEeQS7IwCDhWd9KuI11PmbXU+DWwGXDVl9qxwNyUrfOCbhPsMsfx4IiIiIg8VkrmYSRnmQQ1hH8kupScxXuNOqjZqOM/o3Nwkspbv3noA6SZlI+KtrsW4YmLKw/fAE8PakyePFkN+PzZZ58hNDTU2He1jJMQFBSkaiNPmzYNzz//PNq1a6cmeS43MOPHjzeuO2nSJMyYMUN1RySDjM+cORNdunTBkCFDHLyHZA9S21a6DrNVn8JZpYVI9wmyyWcREVHDys3Nxd9//60ZHHzPnj0qP9CyZUvmI8j1SEG1eQtYa3lIN5m2zgu67XkyMdVjzgkiIiIiss5Hjdobnyce/xVDB45Veev5B+YhPUtbPhpdmAEUpDmk0oxTBzVef/119Tho0CDN8qVLl+LWW29Vzx966CEUFBTg3nvvVV1DJCUl4dtvv1VBEIMFCxaoMRakpYasO3jwYCxbtgw+Pj4NvEfUEGSQcBkDRQqsZHBXIiLyXDt27MBll11mnDeMl3XLLbeovADzEeRqFu5bjhSzQcBFgL4Mz2X+qp431hchqqy8i0xPrJjBvCARERERUfWe7fUAdO9X9IpUAm/MC++Nvf4xFvPWujIL3dWm/6atSNOAlWacvvupmkhrjdmzZ6upusFOFy5cqCZyfykpKWpg+ddee0213qmvhLCWlRfqSoG0HWhamlvvzyciIvuRihHV5SeYjyBXk5J7stIg4CLIZByNJzK3Vn6j3GB4CFvnBV2GdEVmfH7WivXN1mF3VEREREQeI9A3ANCXGgMa88N7VQpomOatW05sDoSUL+tTdAp6eCHby3GVyZ06qEHuM9BM4/AkyzfYLmBqj8mVF0rTqrp2/UBERERkT+P2lw8EbsqNx9AgYGFod6Ssv0eTFAHhFxtb71i0+kLtPLujIiIiIvJIa4IvUAGKxNAWgLefcXlCeBuL6/vpdZiRtVO9z1EY1KAGGWgmyjfcrVP6tE8w5m96ptIX32JAhIiIiMjW/EIrWmOwxr3HSfENq9SCx7T1zjPhSTh0Pj9u2iXZ2jOfNuBWEhEREZEzGpf/l5ow+qNK3UcdPHjQ4nv8oCt/j4MwqEFkA0XwQXLOMaYlERER2VWf2K5oefoH9bwEPvgpqEX5C15eHPSZqpTlFeCR46sQERERkY14m4xNnTAa6PBO5Za/DYhBDWoQvIkiIiIiqr9xba4AfrlVPV8d3B6JxeeAmF4I8GvE5PUgv6UfQE5AU+O8pXFWCkxaEBMRERER1UfTRs0QHl6e52zauDUQGA1HYlCD3E7r1q3x3//+Fy1bWhjg204+bNS+wf4XERERUU3NxD2ZI/KCDW3Fwc+QHN6n5hUNXZJtmQtkHdG8dHHhCTttHRERERG5Y97a19dXO96wAzGoQTbXNSoR0Wd+Vs9/DWxW+abKzoNVent7Izg4WD02lG0B8Q32v4iIiIjIufKCzmJowVGsD2pVscAQ7GKrDSIiIiJyo7w1gxpkcxPbXQ1svqt8Jmv7+YWpDVaD8OTJk3jllVcwffp0NG/e3D7/RIIyJkGagB8eQEFJnn3+FxERERE5V17QCUlXZPdl71GTYpJXTQgza7WiK0XT3OQG3kIiIiIicpe89en8NBT5hGrWDchPQ3wDlf8yqEH1p9cBhekV84VnHZqqBQUF2Ldvn3q0Gy9vTZBmSudbkLnhDs0q4T3utd//JyIiIiLH5QVdzNQek7ULpLuA5a84anOIiIiIyMEW7luOlIgBmmUJ+5Zjau8ZVuWt5+9dguTowZpliXuXYP5lL6MhMKhB9ScBjeWxHp2SSbHdgYIU7UJZRkREREREREREROREUnJPItm/fOBvo9yTcBUMahAREREREbmQKZ1uRuEX2ppxgfqyOn3W6uD25ePDbXpGM/ZGQkhTTO080eQfRJW3ViYiIiIicjAGNajeLPahhjLEl+V7fOpuOP4z1h76wtiXcaWm/0REREQu1M0nOYdWoc2BkgybfNbV+X/jT/9IbM85pn0hbQewa2bFfAOOkUdEREREVB0GNajeLPahVnwO8zM2OiR1o6OjMXHiRPXoaBmF55Cc8ZejN4OIiIjsGXSQ8Qm8q6nBXp8a7ibdfP7mH41nG/dFYdxY9C46jXF55QM9B+YcRysWNjtlXtBu5JwyGQi8ynWsrJQ0PvcATvsE45hvmC23koiIiIhcXLST5q0Z1CD7iOoGjP7IqpsqW2vcuDGGDBmiHh1KalKW5BlnJbiRWZSJ8IBwh24WERER2Y5X8Tl4r+xS/Uo2quGe4+WPQu/y7Pv2gHg1icT9KzE/tke9P99dOE1e0J4kSFaPc8pSpSQiIiIi8hwJIU3LW+Zqll1idd76+jYjkLnhDs2y8B73oqEwqEH2If3xOqjGYE5ODn799VeH3sxK38RXr+4MBLcGQisKOkrzUwFdSfkM+yUmIiLyDIVpVb60cN87apA+wEvND21+MYY3v9TkvexuyhXzgq7q7uzf4Audeh6uK3L05hARERGRnUyVsdNMuxoVphXUa8hbJ8V2BwpStCvLsgbCoAa5ndTUVLzxxhvo2rWrw25kZbBF6Zu4Y7FJH9jio26ArrD8OfslJiIi8gyrO1X5UkrEACT7RxrnLzrxFfDDnw20Ye7JGfKCzi4hvI3F5XntxmJcmyvKg2mrL9S+aE2AjZV2iIiIiNxKqpPmrRnUoPoPWGloeUAapt1CWFVrkzeBREREbkVabkpFB4OE0mxMzdlj+390vksqImtN7THZ6nU3BDbD2qC2wPq7Ncsfz9yCcH2xduVx+4HAKlpr63Tl9xFERERERPXEOyCq14CV4vqAeGR6BzisDzW3qbXJlhtERERu5er8v1XLzWorOZgp8fJWwZBx+X9Vei1UX4zE4nNATC9NICMhrKXNtpnIXIZ3oKY1kUGpjOuhr5hfGNodKevv0awTV5aHB7N3qufe0snaiN8BWP99ICIiIiKyhEENqtHC3a8hJfufigW6UowObIaBhSfUbFLR6cpvasA+1JyCtLKQoMR5Cb+9CfzzbaXVfFk7jYiIyH1arOp08JYgA8wKdn3DNEEKa3QtTsNe/xh81Ki9ClxYCmp0Kz6LbsUby/u6ddDYZURVkfPePPiRX8rbTSIiIiKyPeYyqUYS0EjO0N5YX+Id6LQpFxgYiLZt26rHBiMFFiaFC1OTZgHd7tR2NVVNf9pERETkGhbuWICUI59rF0YMQJ+i0yoQYalgtya9i07j/qxduDn2ivIFUd0sDtKnqUxBzpUXJCIiIiJyQ4FOmrdmUINqpit1qVRq1qwZnnrqKcTGVnSR1eDMghzm3grpgmO+IZplLQ58gDsumtIAG0dERER1lZJ7slLQolPxWQwvOIp8L1/kVze+hXQbNfR1TUUHCYZIN1WaFh3efmyJ4ep5QXdqhXx0PZD8YeV1Rv8IfNavUoCuwMsX+/yj1fwxk1ZLREREROR6mjlp3ppBDaqT1Y3aY2z+oYoF4/4AAstvXhTWIKy2e6rkTc8gOeeYZpX8rCM8G4mIiFzQfv/oilYW5yVGtK+0nhr7wmwQZUM3UyVqxAEiJ2FSQScitIXF89nX7Fw2BOieCU+y+JHSNduhP1+D7+Eg+QfG5QOa9MaYhMEVeWYru2wjIiIiIs/FoAZV31e00JVUWiXHbGBwFdBwkr6dDx06hMmTJ+O1115Du3bt4BTMW25IDUxzks4FaRXzvKkjIiJyunzR0LhuuOjEV8Z5aWEh42CYSmzcBvMHvmj580yv9eQ5eUEXNrD5pWqq6Vy2NA6MKema7VDBaaBAu7zDyW+BDTeWz0glICe5pyAiIiJyZ4WlRdB5aUMD3qVFCLQyb73h1DZkBLfVrBtxahsGtrkSDYFBDapMbtyXmzQpihgA1LJvaKqdJqW56HPyG2D5woqFvKkjIiJq+Moc5szGxRpu8pK0rpgb3qfye6rrgsqs9abxLaVFSNyxQD1PCG9j7dYTOU4V5zJ2vAqk/6GeyqD35t1TbQ+Ir/77ZuLPzMN4+8/Vxnn5bkztMbnem05ERETk6R7fsQDJsaM0y+R+ZP5lL1v1/rUpPyA5tIv2/Sk/MKhBDWfh7teQknm44gQMiccdJq8/nrkFpWbNwH3HbATC3qxYwO6m6sUXusq128xu6thyg4iIyDrL/1iJvWm/a7p9qrIg1Kwyx1HfMBR6+ajnqxslqgLYwJhReDxrC7oVn9W8dU3wBcj28kdi49aaVpiqm6lajrslNaKsvYEgcgpVnMstGrdBvozJpytFwqmjlbqnuiZuTNWfaRJAFPn+sUiO6G+cT846jKEJQ9AhMtFWe0FERERELogtNUgFNOQGwSA4dbMmVcL1xYDeLKHCWrFpuL2Z3dSx5QYREXki88oXYmbXSYgPrrqLmpNZR5CcUX1XOFVZFNq90kDghd6+yPHyr7SuVEiQSXflang3iqvT/yNyN3d0nVTRPdXyV6zunspa+XmngKDImrtrtdAK66Xf3saZgorgJFt+EBEREbkmBjU8vUuFKsbMIPtKCGkKpO0wzseV5VW57urg9tgmzfQ3PYMBzfpXDKRojmNwEBGRG+Zbvk35rtJqRWv6AmU5VX9O495AYLOK+dKCqseyMG8ZSUQNKrYsv8o8cEJZduUXvrsBKE6tubtW8y51ARyJuhzHfMOM81Kxa2qHcRbz0+YB1dEJl2Ngk/Pdzel08Co6C+ijpfM463eWiIiIiGyCQQ038/nfn2PjsQ3agEX6b5ifsbHqN5mNmVHi5aNuIjS1qcbtBwJjXKK7qRYtWuCll15Sj85qaq8HgM4Tq+yve2bEgEq1RJFzDB12PlcxkKK5cfvxZ2GOsd9h1jwjIiKXY6EQEnFja/URkoeRwbs10n+r/Ln1cT5fpNPpkHY2DTFOnC/yRK6QF/TEMTcM35fEw/+TvqvUfUrCmZ8xpkDbEstAKvW879eh+v9hEpT8POV7bDy1veI1+fzQ7pias6f6zzD9bTAJkpi3Zr/k18+A/EPqufzCSNss3XW/A8HVtNJipSMiIiJycS2cNG/NoIaLtKyoGCRPr2r5T+18i8W3p2b8pcl8KzUM8i3922Z7++OUb4ia3+cfrQa+1AQ1JKBRVS0oJ+Pv74+4uDj16Gp9ENfL6k7afocloFVVrVQLN38MghARkaWungzm932k+svQ4a+wLXVvpUGyqx3PwgpxpXk449tIs+zDRu0xM3tnlQWhphUDwnRFKq9TldEmQZOhBUcrVyowGPg2EN9LW1Cp00EfoK+6+xtyCJfIC3oC8/zu+e/LvIHz4e3tXXOL8k3PoDTnWPX/w6RSUGpIZyQ3ukD7ukmrDAl4ltbUqsIkSJJVlFntqgtDuyPl++p/2xJaj8HU3jNq/I1t7B+CJy6aUqcutSphIIWIiIisMLT5xbjoxFeaZVGdJlidt368x70o/bCzZpnvoH1oKAxqNLCqMrIDmvQu71bIrMa+gaawOm0nsOtBy/8gpDNgnpmvgQQvfgpqrl0Y1Q0Y/VHFvAvVQDxz5gzeeOMN3HXXXWjSpAlcsSab3MRJy4z6SM45hj/fT0SHkowq1zG9+ZNgmJybVRZaNfQNkjU3beZ4E+de3OHG3R32gVybyTlYUUFCyzSobV4zWaOGlg5Xwxt/hvdRA2tryIDBpkF2/wiL26cUagfiFtfn/4VFYT00y1S3jFby0+us7st/fVAr4/PEiPaa10JDmrlMBQ9P55J5QU9UQyWfhLCE8lZWZoL1des6V343DJW4DHoUndGuZHIfVho9DPAJNs5LpS/T1uwpvmFVB0ENslM0v38p55JVHt1cVFkBsPzpSi3kF+57Bym5J8tbtkhltIi2GLe1hiBxdV1ymf3mfnP8Z6w//quqOFdSUgo/P18khLetVyCaiIiIXKNsYnh0RyDvT+16zS+1Om8dHhAG6Aq1K8uyBsKgRgOrqrCgw8lvq+5WyIxknv/0i6i2sLrevP1c9sY9NzcXmzZtwk033QSXvamT9K8FucG6Ov/vSsvzvWr3OercrKrQ6vwNlvkAiyKxcWvc0fEGbR/DBV6A1MI7L7MoG8/uXqx5X3mrI5NuuEyZBfhUbbjzte1mZu9AvKX+l827SatJfWvC1Yd8vqiuMDsgAiiq5fe8ivSv8zY4UhVB3nodc3szT39H7AODJG5t0Z7F+CfriMXXjBUkTJmcg5oKEjbyUlhPHPFrbJy3WAtaxpAyvbZc9zu8ioAP/1iH7Wd2qUJLaUlRm0GEAwLCtZUBTNmgYkBi4zaYP/DFen0GOY5L5gWp1t21mvvMrGJXb2mN7lX31jry/q+D2xjnl4d2QmLxOc1vlazTs+gM/hvWzfKHmHd9FzEAvfXF8IIe2wKqCLiZ7GOKWZe0LU//YNU4fIZ7iQntrkK3qI5VpmF6ow5IDjHv4qs8gEJEREQuXqk++x9tRbO0HbW+73LmvLVHBTUWL16s+gA7deoUOnXqhFdffRWXXlo5AuVMbFVYXVMBWuvf3kawSUG11Nok5xlIvKaBFOUG5k//SAwvOFqv86r6N3WyOMCiCE7dDGyfqulj2FypdyCSY0ZolqnBGXfNrPbfbg2Ix4fB7TU3dEXwqXYblzfqiL3+2nO8sb4IT2RurfG78Nj2V1BUVmwcj0ZY86N/1DcMi0K7V1o+Ie8PdCuuXPPY1DdBCVgfmFBp+bP9nkDgV0Orfa9psMcgoTS7xv6jC+GDxyMurrR8aGEKhhekVPve3/yjsaLRhZWWT8nZg1alFgb0tHTDbSJAX4bnMqWWYPWeCU9ClleAZlnXL6/DxLwD1b7vtE8w5oed7zLGrPZ3UjVd0ogNgc2wNqhtpeWPZ25BuL640nLT8/+tkC5I9osoH7fovLiyPDxo3mWOhQIaGVfH3IDC41X2O251DU1y+XzEP1lSOcJyUKM2FSREY10RsrwDtN0VyvNaOOPTqNI1oXPxWfjpy4zzLUpzNa97f9RFfU+ugTdWxo1R3WQmFZ3Cp8Hl37UIXSEGFp4wrh/e7xUkqprE0OZTqjjPzWt3y+9/dYJ0JSioZWUCInL+7lpnZW7DmuALNPkj1Rrd8H3XlaBFXvkYGZaMy/tLE9QwJ/lDyU//EFTev3ST0ly0Kc3CjbkVNR4DUGbxPS837glbk8+V+4HtJkHdnO9uBIqkpQc5mjPkIUzN/LGiW7RyevQI6YgbQ8dUWTHK2M2kids7jEOHGsoOKo13Y2W3lqLGCnVVsFShToxOuBwDm/Sp+o06HX5L/RnrD2yuFOCb2XUS4oOr/01afnAN9qYnV929XDWM96Em+sR2xbg2V1T7vqM5x7Fo/8pKyysFNS2oaK1lSo/7Em6usZLcwn3Lz7cks7LS4nmFpUV4fMcCi93gDLdQQ9zUb+kHsOLgZ5WWT+l0M1qFmvU+YsX5G+Djj+d6T6+xotozuxYhq1ibn+0alYiJ7a6u9n+ezk/D/L1LKi2/vs0IJMVWLjswteHUNqxNqRzIlu5+VO34arx14INK9wtxQdF4sNvtqMnMLS+YzJW34ru8RV9c1ar6comqWoS7/G+EhUqjW1P34MPD6yq919l+I1LOV6qPDYpCakF5hV2pWFHrskAn5jFBjQ8++ADTpk1TmYmLL75YNZsZOXIk/vjjD7Rs2RLOqraF1VLoLTWINCTzPjy12lq8D/adZZPtJTvVTKuphv2mZ9QNzF9SgFqL8yqmiiCJM8n0Dqi5ab+Zk74hld6jmvWbs1CYfDDmyorCrfOf0bKs+oJ6UejlY3E7c/JrriGY7h1k8b26r0fW+F6ruj6wQOflZfF9FxVXUfPZRI6Xv8X3ShrU5LRvcKX3SoGiNQ75hiPdJ0izLFpn4biakSCYpe3NLNQGSCzJkGCchfeWyndPX/17j1k4D/NLrbvsWvqfHUrMftupQblqPqI6U7N345ugVsiWfMP5msQDgtqgw/nuVmSw7a+qKdCrSpC+VBUm+uH8tcpEppd/+ffHZAwL+W5LDWgDyceYBjWSml+KpHbX2O4aak0LKiJy/u5azX1zp2ZWfoNMK6WoCh9Xf1sRKJFg7vKFdd4c8wov0rWVTDOydlr8/bP0ntoqgY+mCyypVGOa/7o672+k+IYi1Uc7DlFVZHwi8sw8hOXeI9bDe5f2e1RTN5P568YANdw/WBzvxopuLa2pUFcVSxXqxCW/fgbkVx3MVDmUoAQkm3V7KYrW9AXKcqr9vycb90ZyYLOqu5erhuY+1LR11i+3Vvu+Qr8IJEcOrLTcmqCm5dZaQPR3SfDWl1b7XvOWZIpUzKyh0qLOyxfJsaMqLVf9+v9g1g2OmZyApkgOrxyUKvxiMFBDTyanw7oj2aSbUeN9qIXz0Lyi5qHo4ZXvQ8/8DGy+q9r/WeQTiuTowZXzwxvuAGqoSJgR3BbJoV0qLVfjF5h392PmWHg/JAdoq5rmp+8BfnsUNUk2GWvOoMuuH4GN1dfQr6pFuKv/RliqtJvpKr8REeWtQ68+9wsejbwEAfpSXFp4XFUcNgjVF9dYCdeZeUxQ45VXXsGkSZNw++3lkUmpGfHNN9/g9ddfx9y5cyutX1RUpCaDrKws9ZiZmQmdznIm1UBez87OVgOoqEHwTD83rxAl+ZUL8Aryy5BtoWyuKKAUm/yjsN83RPO+3AIdss8H6HRjNwMB0eq51O2tVL83MBKZRSbbUVRzAa0rk7QvKSlRj3K8XJf1tUaLCsrU+XFW/eTWfJ4UbZ+PTbnH5ecTMDsfLZ2HporzS1Hiq31PUVFpje97J6RtpXM/VFdU4/vyoKv0/3IK9Egv88La4Da4xkKmtNCvDCVmBeXFZTVvo5BtLDGrkFJYYPn7aSq3VG/xu50nx6D6SsLI9y5DiXfl92YX6FFaQ8G5/EaUlJodj+Ka9zXfy/L25luxr3k6HUr8K783t0CP7BriE4W+ZSgx6wvbV1di1bFR556P9r2FhTVvb45PNcemxnTSVfqf6jML9PCv/lKAIv9SlJSZnYel1p+H1l4nzOkys4Ci+tc6l99QodfXcBJ6iNrkI+qTh6gpb1GYW2Tx/LDmHMkt06EkoOK9RfmlmJy5Vf2WGt43yKQ10CfBbdFKbkIiuwDePsgcc7DSZ8b+sQxFx37ULEuDN971am3x9/mJ8F44qBlT4/xlq6Skyt+wup3T1a0fD5jsS8s9r1Wq9RTrE29VHqK6PJ+rcad9cZ+8oHsdF9vsS9Xf7Va+TXFQxrA4z9Lvoeb3RO+j+S0wl1ucg1a/v23y5jLEZh+q9LnmedWqfv+qy6s2KzprcXs7e53An42CUXo+cLEe8WhXFoARBeVBjZfDO2t/U4W6/JRYlQ8tKJCWJNrWJEW+hfX+3jAP4biyCGtZm9f8yy8c+V4VxUaXnDuM/aEh5S09ze43q1Ig9zpelu51at7Out575nhXda+jq9P9p/pMudfRfl0q4X0o70M99T7U/D7DuJy/EQ77jejsdQKj8w+rroLVewG86KftLrNdcQaeM2vpYuneq8q8dUEWvAtsXx5hdT5C7wGKior0Pj4++k8++USz/L777tMPGDDA4nueeuopSTlOTAOeAzwHeA7wHPDoc+DYsWN6T1fbfATzEI4/bzkxDXgO8BzgOeD4c4B5CJZFOPoc5MQ04DnAc4DnANw2H+ERLTXOnj2LsrIyxMVpGw3J/OnTlvtTnzVrFqZPr+hbT2pEnDt3DlFRUfDy8qoxotSiRQscO3YMYWENN+o7Mf2dAc9/pr8nc6fzX2pF5OTkoGnTpvB0tc1H1CcP4QnnFvfFOfG4OCceF+fkTsfFHvvDPITjyiLqyt3O6bpiOjANeB7w+8DfBMf/Nlqbj/CIoIaBeQZAEqmqTEFAQICaTIWHh9fq/8mB9uQMgaMx/Zn+noznP9PfFho3buzglHTNfIQt8hCe8N3mvjgnHhfnxOPinNzpuNh6f5iHcGxZRF252zldV0wHpgHPA34f+Jvg2N9Ga/IRrt0xq5Wio6Ph4+NTqSZEampqpRoTRERERMxHEBEREcsiiIiInJNHBDVkMLqePXti/fr1muUy379/f4dtFxERETk/5iOIiIiIeQgiIiLn4THdT0mflBMmTECvXr3Qr18/vPnmm/jnn39w99132/x/SVPRp556qlKTUWoYTH/HYvoz/T0Zz3/31ZD5CHc/t7gvzonHxTnxuDgndzou7rg/zsbReQhr8BxgOvBc4PeBvwv8bXS1a4SXjBYOD7F48WLMmzcPp06dQufOnbFgwQIMGDDA0ZtFRERELoD5CCIiImIegoiIyPE8KqhBRERERERERERERESuyyPG1CAiIiIiIiIiIiIiItfHoAYREREREREREREREbkEBjWIiIiIiIiIiIiIiMglMKhBREREREREREREREQugUGNejh69CgmTZqE1q1bIygoCG3btsVTTz2F4uJizXr//PMPRo8ejUaNGiE6Ohr33XdfpXV+//13DBw4UH1Os2bN8PTTT4NjuNfN4sWL1TEJDAxEz5498fPPP9fjKJOYO3cuevfujdDQUMTGxmLs2LFITk7WJI6cr7Nnz0bTpk3VeTxo0CDs379fs05RURGmTp2qvgfyfRgzZgyOHz/ORK7lsfDy8sK0adOY9g3kxIkTuPnmmxEVFYXg4GB0794dO3fuZPqTw/MX5qz5HXaE5557Dv3791ffn/DwcKvec+utt6rfOtOpb9++cMV9cdbjIjIyMjBhwgQ0btxYTfI8MzPTJY5NbfN7GzZsUOvJ+m3atMF///tfOIva7MtPP/1UKf1l+vPPP+FoGzduVPc8cq7LNn366ac1vsdZj0tt98WZj4s1+XhXOjZkH19++SWSkpLUdUru1a655ppal2m4slatWlX6/j7yyCMelQbm9+1yzyPpsGfPHo9KBymjaNmypfrta9KkicobnTx50qPSwJZlna7Mmny/u6eBs5exMqhRD5JJ1el0eOONN9TN6YIFC1Rm79FHHzWuU1ZWhiuvvBJ5eXn45ZdfsGrVKnz88ceYMWOGcZ3s7GwMHTpUZZq3b9+OhQsXYv78+XjllVfqd3Q90AcffKAKex977DHs3r0bl156KUaOHKl+aKju5KZm8uTJ2LJlC9avX4/S0lIMGzZMndcG8+bNU+fsokWL1HkcHx+vzuucnBzjOnJs1qxZo74H8n3Izc3FqFGj1PeEaibp+uabb6Jr166a5Ux7+xb4XXzxxfDz88PXX3+NP/74Ay+//LImU8P0J0fkLyyx5lx0BMnYX3/99bjnnntq9b4RI0bg1KlTxumrr76Co9VlX5z1uIjx48erwop169apSZ7LzbuzH5va5veOHDmCK664Qq0n68t3SW46JU/uqnlXKZQ2PQbt2rWDo0m+sFu3bupct4YzH5fa7oszHxdr8vGudGzI9uS4ym//bbfdht9++w2//vqruj7UpkzDHUjFUtPv7+OPP+5xaWDw0EMPqfIpc56QDpdddhlWr16tfs9l3w4dOoTrrrvOo9LAVmWdrq6mfL8npMEHzl7Gqiebmjdvnr5169bG+a+++krv7e2tP3HihHHZ+++/rw8ICNBnZWWp+cWLF+sbN26sLywsNK4zd+5cfdOmTfU6nY5HqBb69Omjv/vuuzXLOnTooH/kkUeYjjaUmpqql5+PDRs2qHk5T+Pj4/UvvPCCcR05n+W8/u9//6vmMzMz9X5+fvpVq1YZ15HvhXw/1q1bx+NTg5ycHH27du3069ev1w8cOFB///33M+0bwMMPP6y/5JJLqnyd5z45Kn9Rl3PR0ZYuXaq2xxq33HKL/qqrrtI7K2v3xZmPyx9//KGu5Vu2bDEu27x5s1r2559/OvWxqW1+76GHHlKvm7rrrrv0ffv21Ttabfflxx9/VMcoIyND78xkG9esWVPtOs58XGq7L65yXCzl41352FD9lZSU6Js1a6Z/++23q1zHmjINV5eQkKBfsGCBR6eB6b7K93///v3qt2L37t0emQ4Gn332md7Ly0tfXFzssWlQ17JOd1FVvt8T0qCPk5exsqWGjWVlZSEyMtI4v3nzZnTu3FkT5R4+fLhqzmfovkTWka6nAgICNOtIEzdp9kXWR1ElTaXmkSmZ37RpE5PRxue5MJzrUpvr9OnTmrSX81nOa0Pay7EpKSnRrCPfC/l+8PjUTGrYSS2AIUOGaJYz7e3r888/R69evVQNDemyoUePHnjrrbeY/uTw/IU5a34LXI105yLfu/bt2+OOO+5AamoqXI0zHxfJf0qXU9LdiIF0IyXLato2Rx6buuT3ZF/N15e89o4dO1TexBXzrnI9km4xBg8ejB9//BGuyFmPS324wnExz8d7yrEhy3bt2qW6WvX29jaev1IL17SbRGvKNNzBiy++qLqblW6XpNsZ0y5kPCUNzpw5o67rK1asUF3umPOUdDA4d+4c3n33XdUFkbTc98Q0qE9Zp7tz9zQodoEyVgY1bEiapUnXUXfffbdxmdzIxsXFadaLiIiAv7+/eq2qdQzzhnWoZmfPnlXNvyylJdPRdqTC2vTp03HJJZeoH3DT87S6tJdHOe/l/OfxqR1pxig3HNInsjmmvX0dPnwYr7/+uuo+4ptvvlG/79L9wvLly5n+5ND8RV1+C1yJFKjITeQPP/ygunyTbpsuv/xydZPgSpz5uMj/l8CEOVlW3bY5+tjUJb9XVV5buuGRz3OUuuyLFDhKV5TSvcEnn3yCxMREVYAuY0C4Gmc9LnXhKsfFUj7e3Y8N1ZzXFTL2k3S39MUXX6j7NQm+S4GutWUaru7+++9X91wSjJwyZQpeffVV3HvvvcbXPSEN5PdBxs2S/KZU6rLEE9JBPPzww2qMBAlySTc7n332mcelgS3KOt2du6fBWRcoY2VQwwK5oFsa6M10kloqpqRVhfQvLLV5b7/9ds1rsr6lC4bpcvN1DIOEW3ovVc9SWjIdbUcyeXv37sX7779vk7Tn8anesWPHVCZ75cqVamCmqjDt7UP6Er3ooovw/PPPq9prd911l6q9JIEOpj85On/hyGtgXfalNm644QbVOk0K3WTwPRnT5q+//lIDmbravjR03qQ2+2NNHtWRx8aWaerMee3a7IsUlst1SK5N/fr1U4M3yvGQ8fhckTMfl9pwleNSXT7eXY+Np7L2WiB5XSH9pV977bVqENilS5eq1z/88EPj59XleuFotbkePvDAAyqQI2MXSn5Lxg9YsmQJ0tPTXToNapMOUmgt473OmjWr2s9zxXSobV7vwQcfVOMHfPvtt/Dx8cHEiRONv4GumgaOKut0NrbO97tiGrhTGauvozfAGUlm71//+le167Rq1UrzJZfBhCQDKzV0TMlgkFu3bq008Kw02zVEu2Qd8yiXoRm/eUSMqhYdHa0uOJbSkuloG1OnTlXd8Uits+bNmxuXyzksJO2lppqltJd1pPmanP+mrTVkHWnOSZZJcz9JI7nBMJBouRwDGbxSBjBj2tuPnM8XXnihZlnHjh2NA2Xy3CdH5S/MWXMuOnJf6kv2KSEhAQcPHoQr7UtDH5fa7I8UbEo3E+bS0tJqtW32PDa2yu9Vldf29fVVtTBdPe8q3YZJ5QdX46zHxVac7bhUlY/3xGPjCay9FuTk5Kjnpvld6SaxTZs2xoFgrSnTcEb1ub7L91f8/fff6px31TSoTTo8++yz2LJli6ZbdCGtNm666Sa88847HnMuyPVZJulmU+79WrRoodJG8uSumgaOKOt0RrbM97tqGrhVGaujB/VwdcePH1eD9/7rX//Sl5aWVjlwzMmTJ43LZKBk84HCw8PD9UVFRcZ1ZEBJDhRet0Fs7rnnHs2yjh07Os0gNq5KBjqdPHmyOif/+uuvKgdCffHFF43L5Hy2NFD4Bx98YFxHvhccKLx62dnZ+t9//10z9erVS3/zzTer50x7+7rxxhsrDRQ+bdo0fb9+/dRzpj85Kn9hzppz0ZUGCjd39uxZlXd655139K44ULgzHhfDQOFbt241LpNBw2saKNwZjk1t83sy6LG8bkoGPXSGQY9tkXe99tpr9ZdddpneFQcKd9bjUtt9cebjUlM+3pWPDdWflEnIb7jpQOEyIHJsbKz+jTfesLpMw92sXbtWffdTUlI8Jg1kX03vOb/55huVBh999JH+2LFjHpMO5v755x+VDj/++KNHpYEtyjo9ZaBwd06DPk5exsqgRj3ICPcXXHCB/vLLL1df+FOnThknA/nyd+7cWT948GD9rl279N99952+efPm+ilTphjXkcLeuLg4VXgmF49PPvlEHxYWpp8/f379jq4Hkh8QKThfsmSJulmXwsdGjRrpjx496uhNc2nyIyY/4j/99JPmPM/Pz9cE4mQdOX/lPJbzuUmTJqpQ3vRmSM5/+R7I90G+O926dbOqwI4qDBw4UH///fcz7RvAtm3b9L6+vvrnnntOf/DgQf27776rDw4O1q9cuZLpTw7NX4jExET1m1ub32FH3STv3r1bP2fOHH1ISIh6LlNOTo7FfZHlM2bM0G/atEl/5MgRdRMpgcRmzZq53L4483ERI0aM0Hft2lW/efNmNXXp0kU/atQozTrOeGxqyu/JjdaECROM6x8+fFj9dj/wwANqfXmfvF8KahyttvuyYMECVcAuhdP79u1Tr0thy8cff6x3NDk/DN8J2aZXXnlFPTcUCrrScantvjjzcbEmH+9Kx4ZsT+4r5HdcCrElqD1p0iQV1Dh37pzVZRquTK5phu+4nPtSCU+CgGPGjDGu4+5pYIlc5+V3TNLFU9JBKnosXLhQ7bNch3/44QdVwa1t27b6wsJCj0gDW5Z1urqa8v2ekAarnLyMlUGNekbr5Efe0mT+Rbjyyiv1QUFB+sjISHWCG34QDfbu3au/9NJLVURPavTNnj1b1aqh2nvttdf0CQkJen9/f/1FF12k37BhA5Oxnqo6z+U7YCDn61NPPaXOXzmPBwwYoApvTBUUFKjzX74H8n2QghOp+UD1C2ow7e1fU0syK3Jed+jQQf/mm29qXmf6k6PyF3X5HXaEW265xeK+GGq8me+LFLQNGzZMHxMTozLRLVu2VJ/hDNeL2u6LMx8XkZ6err/pppv0oaGhapLnGRkZmnWc9dhUl9+TbZJrpSkp0O3Ro4dav1WrVvrXX39d7yxqsy/S6kcKVwIDA/URERGqsOXLL7/UOwP5Hlj6fsg+uNpxqe2+OPNxsSYf70rHhmxPWmZIwFoCGXItGDJkiArO1bZMw1Xt3LlTn5SUpIJ/8h2WYL5ct/Py8jwmDawNarh7Oki5nLSwk/2SPJv89knFTCnY95Q0sHVZpyuzJt/v7mng7GWsXvLH0V1gERERERERERERERER1cS7xjWIiIiIiIiIiIiIiIicAIMaRERERERERERERETkEhjUICIiIiIiIiIiIiIil8CgBhERERERERERERERuQQGNYiIiIiIiIiIiIiIyCUwqEFERERERERERERERC6BQQ0iIiIiIiIiIiIiInIJDGoQuahBgwZh2rRpDfb/li1bhvDw8Ab7f0RERGQ/zEcQERER8xBE5KoY1CByYrfeeiu8vLwqTX///Tc++eQTPPPMM8Z1W7VqhVdffdXpAxH//PMPRo8ejUaNGiE6Ohr33XcfiouL7fK/fvrpJ4vpZzpJGjmTjIwMTJgwAY0bN1aTPM/MzHT0ZhERkQtyx3zE/fffj549eyIgIADdu3e36/9yxXzEc889h/79+yM4ONjpjh0REbkOd8tD/Pbbb7jxxhvRokULBAUFoWPHjvjPf/5jt//nanmIo0ePYtKkSWjdurVKn7Zt2+Kpp56yW1kNkS342uRTiMhuRowYgaVLl2qWxcTEwMfHx+VSvaysDFdeeaXa/l9++QXp6em45ZZboNfrsXDhQpv/P7mpP3XqlKYgJDs7W5OeEjgw3T7JXHh7Oy7eO378eBw/fhzr1q1T83feeacKbKxdu9Zh20RERK7LnfIRQvIM//73v7F161bs3bvXrv/LFfMRUvhw/fXXo1+/fliyZInDtoOIiFyfO+Uhdu7cqbZ95cqVKrCxadMmda8t+zJlyhR4eh7izz//hE6nwxtvvIELLrgA+/btwx133IG8vDzMnz/fIdtEVBO21CByclITMT4+XjPJhde02wh5npKSggceeMAY9ZeaAbfddhuysrKMy2bPnm284X3ooYfQrFkz1WIiKSlJrW9Kag20bNlS1fS7+uqrVQCipsi+/I9Vq1apC3hgYCA6deqk+dxvv/0Wf/zxh8pI9OjRA0OGDMHLL7+Mt956S13gbc3f31+TblLjwDQ9JXDQpEkTfPHFF7jwwgvVa5KOlrrkGDt2rKqtYmBNGpqT9Hn99dcxcuRItS1SC+LDDz80vn7gwAG1TW+//bYqjJBJ0ka2Lzk52ebpQ0RE7s+d8hHi//7v/zB58mS0adMG9uZq+QgxZ84cdRy7dOli49QgIiJP4055CKkQIXmIgQMHqjzEzTffrLZRWp3Yg6vlIQwBrGHDhqn0GTNmDGbOnGm39CGyBQY1iNyAXGiaN2+Op59+WtUGkEku5tIENCwszLhMLkpCLt6//vqruuhLLUep0ScXsYMHD6rXpfajXPTvvfde7NmzB5dddhmeffZZq7blwQcfxIwZM7B79261DXIxNGRCNm/ejM6dO6Np06bG9YcPH46ioiJVc8IR8vPzMXfuXBVI2L9/P2JjY616X01pWJUnnngC1157rWr+KhkpaQIrwQxD+khtDcmUGPTt21ctk5okREREnpyPcEbOlI8gIiJqaK6ch5CgS2RkJBzF2fMQjk4fopowqEHk5CRyHxISYpzkgmVOLjRSYyI0NNQY+ZeaAVIYLhF5wzJ5/6FDh/D++++rqPyll16q+kqUDMYll1xibAopfUtKsOGRRx5B+/bt1bgXMm8NabopF0rpo1JqAsg2GLo/OH36NOLi4jTrR0REqG2V1xyhpKQEixcvVpmexMREVdOhJtakYVXk+N1+++0qXaUf0l69ehm73pI0sJSRkWWOSh8iInJt7pSPcEbOlI8gIiKyJXfOQ0iFwtWrV+Ouu+6CozhzHkL+j7x2991313n/iOyNY2oQOTmpmSAXZANrLnTV2bVrl+qPWi5kpqS1RFRUlHou0Xpp5mlKukIyjPNQHVnPwNfXV10oTaP/krExJ9tjabmBNMHcsGFDla9LmuTm5qIuJMPVtWtXm6ehNeljmJcaKPVJHyIiIk/JR9SFJ+UjiIiIbMVd8xDSKuKqq67Ck08+iaFDh1b7mZ6Yhzh58qRq+WEIghA5KwY1iJycXCRloCZbkcGfpCaFdPdkPsCX1J4QcpG0JUOBvNTQkOakpjIyMlQNBfMWHKaWL1+ummZWpT6DaUl/kuYBA/k88zSQbaxNGtY1fc6cOVPp9bS0tGrTh4iIyBPyEXXlKfkIIiIiW3LHPISM8Xn55ZerQbAff/zxGt/vaXkICWhIMEsCHm+++WatP4+oITGoQeQmJMpfVlZW4zIZoFuWpaamquaKlshAVVu2bNEsM5+viqw3YMAA9by0tFRdbKUZqJAL43PPPaf61JRBsQyDh8ugWD179qzyM2WQsIYUExOjttFA0mvfvn3q4m5tGlaXPhMnTtTMy+cZ0kf6rdy2bRv69OmjlkkQSJZJk1QiIiJPzkfUlafkI4iIiBzBVfIQ0kJDAhq33HKLKpewhiflIU6cOKH+j5TNSFdW9QnYEDUEBjWI3ESrVq2wceNG/Otf/1JBgujoaLVMmkJ+//336NatG4KDg1UzxZtuukldzF5++WV1ETt79ix++OEHdOnSBVdccYXqt1IK0efNm4exY8eqwIM1zT3Fa6+9hnbt2ql+LBcsWKBaYshAX2LYsGEqkzJhwgS89NJLOHfunOr/UWpJyCBizkIyOtOnT8eXX36p+qiU/cjMzDS+bk0aVkX6vpRmsNLn5bvvvqsCGIZ+PiXNpJmnpMcbb7yhlt15550YNWqU6mOTiIjIk/MR4u+//1bbJGNNFRQUGLtNkPyFFKB4cj5C/PPPPyp/JY9S6GFIH6lpW5canERERO6Qh5CAhhTYS5mEXKMNY1ZKawcJJDgLR+UhpIWGdLUlQZz58+er3iIMpEcJIqekJyKndcstt+ivuuoqi68NHDhQf//99xvnN2/erO/atas+ICBA2ioal9999936qKgoteypp55Sy4qLi/VPPvmkvlWrVno/Pz99fHy8/uqrr9bv3bvX+L4lS5bomzdvrg8KCtKPHj1aP3/+fH3jxo2r3NYjR46o//Hee+/pk5KS9P7+/vqOHTvqv//+e816KSkp+iuvvFJ9bmRkpH7KlCn6wsJCvSPSc+nSpRb3SdLnnnvuUdsXGxurnzt3rnqfvN90nZrS0Jykz2uvvaYfOnSoOk4JCQn6999/X7NOenq6/qabbtKHhoaqSZ5nZGTYLA2IiMhzuGM+QrZb1jOf5P325gr5CPkfltLnxx9/tFk6EBGR+3O3PIT8f0vXR7mWNgRnz0PI9lhKHxYbkzPzkj+ODqwQkes7evQoWrdujd27d6N79+6O3hynJP1VrlmzRtU4ISIiogrMRzAfQUREVBfMQzAPQZ6JHaQREREREREREREREZFLYFCDiIiIiIiIiIiIiIhcArufIiIiIiIiIiIiIiIil8CWGkRERERERERERERE5BIY1CAiIiIiIiIiIiIiIpfAoAYREREREREREREREbkEBjWIiIiIiIiIiIiIiMglMKhBREREREREREREREQugUENIiIiIiIiIiIiIiJyCQxqEBERERERERERERGRS2BQg4iIiIiIiIiIiIiIXAKDGkRERERERERERERE5BIY1CAiIiIiIiIiIiIiIpfAoAYREREREREREREREbkEBjWIiIiIiIiIiIiIiMglMKhBREREREREREREREQugUENIiIiIiIiIiIiIiJyCQxqEFGD+7//+z94eXmhc+fO9fqcPXv24Morr0TLli0RFBSEyMhI9OvXDytXrrTZthIREZH75SHMvf322+pzQ0JCbPq5RERE5H75iJ9++kl9jqVpy5YtNtteIqqabzWvERHZxf/+9z91sd+/fz+2bt2KpKSkOn1OZmYmWrRogRtvvBHNmjVDXl4e3n33XUyYMAFHjx7F448/bvNtJyIiItfPQ5g6ceIEZs6ciaZNmyIrK8sm20lERETun494/vnncdlll2mW2briBRFZxpYaRNSgduzYgd9++w0PPvgg/P39sWTJkjp/1qBBg/Df//4XN998s8pIjBo1Cu+//77KmLz55ps23W4iIiJynzyEqbvvvhsDBgzA0KFDbfJ5RERE5Bn5iHbt2qFv376aia0+iRoGgxpE1KAk4+Dj44MHHnhABSFWrVqF/Px84+vSwkJqTsybNw/PPfec6loqMDAQvXr1wvfff2/V/4iOjoavLxuiERERuRN75CGky8oNGzZg8eLFDbgnRERE5I5lEUTUcBjUIKIGU1BQoFpSjBw5EvHx8bjtttuQk5ODDz/8sNK6ixYtwrp16/Dqq6+qAgdvb2/1vs2bN1daV6fTobS0FGlpaapQ4ptvvsHDDz/cQHtFRERErpiHSE1NxbRp0/DCCy+gefPmPIhERERuyl5lEZMnT1YVKsPCwjB8+HD88ssvDbRHROSl1+v1TAYiaggrVqzAxIkT8fHHH+Oaa65BWVmZKkSQJpsbN2401o5o3bq16tf60KFDqmaEkAxHq1atcNFFF2H9+vWVuo1444031HNpRiqZj3vuuYcHlYiIyE3YIw9x3XXX4dSpU6oAQmpm3nrrrfjoo4+Qm5vrsP0kIiIi589H7N69G++8847qEjsqKgp///03XnrpJfz111/48ssvVYCDiOyLLTWIqEGbe0rXUNLUU0jTTxnU++eff8bBgwc160pGw5CJEKGhoRg9erTKcEgGxNSjjz6K7du3q8zDv//9b0yZMgXz589voL0iIiIiV8tDSKHG2rVr8dZbb6mABhEREbkvW+cjevTooSpTjh07Fpdeeqlq+bFp0yY0adIEDz30UAPvHZFnYlCDiBqE1FyQTMBNN92kWlMYyMVf/O9//9OsL01Czcmy4uLiSjUopa9L6efyiiuuwOuvv44777wTs2bNUt1RERERkWuzdR5CJukuYurUqao2ZmZmpprkdSHP8/Ly7L5fRERE5NplEabCw8NV0GTv3r2quysisi8GNYioQUhGQXq7k64dTHXs2BFJSUmq6aZpC4zTp09X+gxZJpmQkJCQav9Xnz591Bgbhw8ftuEeEBERkTvkIc6ePYszZ87g5ZdfRkREhHGSvrYlmCHPpeCDiIiIXF9DlkUYevhnK1Ai+2NQg4jsTjIIklGQJprdu3ev9LrUkJA+rb/++mvjsk8++QSFhYXGeenHUrqJkKad0lS0Oj/++KMazKtNmzY23hMiIiJy9TyE1LaUvIL5JP1fS3cT8vzZZ59tsH0kIiIi1y+LyMjIwBdffKH+j2n3VURkH752+lwiIiPJIJw8eVINovXpp59WShnDBV/6uVywYIF6LpmFoUOHYvr06dDpdHjxxReRnZ2NOXPmGN8n3UyFhYWplhlxcXGq5uWHH36IDz74AA8++CBiYmJ4FIiIiFyYPfIQ8h75PHPLli1T77X0GhEREbkee5VFjB8/3tgNtozVIeNySAtQaQkq+Qkisj8vvaFtFBGRnVx99dUWMxDmfH198csvv6Bv374q4yC1I2QAz9TUVHTq1AkvvPAChg0bZlx/6dKlajpw4IDq/1qagnbr1g233347br75Zh5PIiIiF2evPIQl0i3FRx99VG1/2UREROQ67JWPkHmpTHnkyBGVb4iMjMQll1yixvbs3bu3nfeKiASDGkTkVI4ePYrWrVvjpZdewsyZMx29OUREROQimIcgIiIi5iOIPAPH1CAiIiIiIiIiIiIiIpfAoAYREREREREREREREbkEdj9FREREREREREREREQugS01iIiIiIiIiIiIiIjIJTCoQURERERERERERERELoFBDSIiIiIiIiIiIiIicgm+jt4AV6HT6XDy5EmEhobCy8vL0ZtDRERkV3q9Hjk5OWjatCm8vVkHoj6YhyAiIk/CPIRtMR9BRESeRG9lWQSDGlaSgEaLFi1sdXyIiIhcwrFjx9C8eXNHb4ZLYx6CiIg8EfMQtsF8BBEReaJjNZRFMKhhJWmhYUjQsLAwOLKWRlpaGmJiYty+5iz31f3wmLonTzmuZ8+exUcffYTrrrsO0dHRcPdjeuTIEVx00UXG6x+5fh7CFjzl+y64r+6Hx9Q9edJxdZW8SHZ2tqoQyDyEZ+cjPOm76QhMX/tyld9bV8Xzl+lri3wEgxpWMnQ5JZkIRwc1CgsL1Ta4e8aA++p+eEzdk6cc15CQEEycOBGxsbFuvZ+GYyr7K9jlovvkIWzBU77vgvvqfnhM3ZMnHVdXy4swD+HZ+QhP+m46AtPXvlzt99bV8Pxl+toiH8FvJhERkRUKCgpw4MAB9UhERETU0JgXISLi7y0RlWNLDRspKytDSUkJGiKaKf9Hajy4e7TYXfbV39/fpbefiCr6M547dy5ee+01tGvXjslCNr3eFRcXu0SKusu12ZX2lfkIIjJgXsRxJA/46KOP4v7778err75qHMh0zpw5ePPNN5GRkYGkpCSVT+zUqZPxfUVFRZg5cybef/99FZQaPHgwFi9ezPHKiJwcf2/te6/jLPlsd6VzkfSt730Ogxr1JBmZ06dPIzMzs8H+n5ycMgq8uzfndZd9lS9o69at1ZeViIjIlGTwZfwSud65Ane5NrvSvjIfQUTkWNu3b1eBi65du2qWz5s3D6+88gqWLVuG9u3b49lnn8XQoUORnJxs7Ad82rRpWLt2LVatWoWoqCjMmDEDo0aNws6dO+Hj4+OgPSIicuy9jrPks92V3kXSt773OQxq1JMhoCH97AUHB9v9ZJETs7S0FL6+vk59YtqCO+yr/IhIhP/UqVNo2bKly+4HERHZ5zon1wcp1JCB0Jy5Fo07XZtdaV+ZjyAicqzc3FzcdNNNeOutt1TQwvQaIS02HnvsMVxzzTVq2TvvvIO4uDi89957uOuuu5CVlYUlS5ZgxYoVGDJkiFpn5cqV6pr/3XffYfjw4Q7bLyIiR97rOEM+253pXSB9bXGfw6BGPbucMgQ0oiIjgMJ0QA/7n5gBjeHr5++0J6YnfQmtERMTo76osi9+fn6O3hwiInIScl3Iz89H0ybxCPbKs3sewigwCvDy9uhrsyvtK/MRRESOM3nyZFx55ZUqKGEa1JCax1LBcdiwYcZlAQEBGDhwIDZt2qSCGtIaQ7r/MF2nadOm6Ny5s1qnqqCGdFklk0F2draxAMhVWnYK2VZDbWFi+roa0/OX53DdyO9fXl4emjVtgiDkAmY/BSX6Evjp/Wx7D1SP+xx3TH8/Jy+DlPucEydOqBY9pttq7XeOQY16MIyhIS00VEBjeSzsTd1S33gC8Gti9/9FtmFoRiVBMGf/QSGiqkkNk4iICHYVQDYj1wXhr88Blic0XMpOTAWCYhru/1G9MB9BRAbMizQs6TJq165dqvspcxLQENIyw5TMp6SkGNeR33DJP5qvY3h/VeN3yFgd5tLS0lT/6K5CCqWktYoUDLtCa1RXw/S1L6nAHBISoh5TU1Pt/N/ct8xUzlOfkkx4fdCm0uv26KC9RMpLeZ8D+d013Gs6c0U0uTbIOSLfMdPyUuk2yxoMatiAOkEaqnYluRxn/gEhIuu1atUK//nPf1TrPCJb4nWCeH4QEfMizuXYsWNqUPBvv/0WgYGBVl/DpSCpput6TevMmjUL06dP17TUkK5bpEZrWFgYXIUUVMl+ynYzqMH0dTXR0dFYvHgxz996kCCsFE77+Dbc+EHSwhoykeLsFavleMn1QcacMr3WVnfd1bzfjttGRERERERERORSpOsoqTnas2dP4zKp9bpx40YsWrRIDQYupMVFkyYVvSjIewytN+Lj41WXGhkZGZrWGrJO//79q/zf0o2VTOak4MfVggMS1HDF7XYVTF+mrzOT772cow1ZgUv9L1Yshmnw3Jkr0BnOD/PrhLXXDF5Z3JCcEDKgWW298cYb6NChA7p37676NLvsssuMr82ePVtlyKr7wlx88cXGpra33nqryuyZk8+R7fv0008175XR7iUSbpi/9NJLVT+lRETO4ujRo6rGnlKRPcwAANaKSURBVDwSuTPmI4iInBPzIg1n8ODB+P3337Fnzx7j1KtXLzVouDxv06aNClqsX7/e+B65X96wYYMxYCEBEakla7qODIi6b9++aoMaROR4/L11T7zPcS9sqWFP4/4AAssL6uus8Cyw+kI0hFdffRUrVqxA79691fyPP/5ofE369Jw5c6axX2dzH374IRITE5GQUHOf4JK5W7JkCcaOHavmv//+exXQMPSZJj8yDzzwAJ5++mm89dZbNto7IqL6kdp5UtPO0DclkdPnITw8HyH/c9myZTbaOyIix2NepOGEhoaqAb1NNWrUSHWRYVg+bdo0PP/882jXrp2a5LmMtzl+/Hj1euPGjTFp0iTMmDFDvS8yMlJdC7t06aIGHici58XfW/vSX78fpb7hqvuhOrck4H0OPB1batiTFEbIADX1mepZoCF9wD/55JOqJkjLli2xcuVK1Sd8nz590LZtW/z0009qveuuuw6HDh3ChAkT1HOJShtaTtx9993qUT5DWnFYGiRJWnlIrRVrDBw4EAcPHlS1VMT//vc//Pvf/9asM3r0aHz11VdWDw5DRGQPC3e/hpkbHlbTi9tfwqmCqgd1JHK6PISd8hELFy5EUlIS8xFERPam1wEFaRVT4TlAV1z+aFgm65BDPPTQQyqwce+996pWHNLbgYzBIQERgwULFqgg/Lhx41TPBhL0WLt2rRr0nYjIY7G81CKWl9YOgxoeoKCgAJs2bcLHH3+MO++8UzWB3bZtG+bOnYtHH31UrfPRRx+hadOm6lEmU//973/Vo3yGNLU1HyS3pKREvdavXz+rtkeisDfffDOWL1+OzMxMbN++HcOGDdOsI9soNWDkc4mIHCUl+x8kZ/ylpsNZR1FcVqAtSGBhAnlYPuKuu+5S1+itW7e6RD7i119/refeExE5zsIdCzBz7XXG6cUfp+JQxu9Y8MO9wPLY8qkwnYeogUiFQGmVaHo9ku6VpbKeDIgrXU+Zt+6QwU6lMkB6ejry8/NVQEMG/SYiIsdz5fLSX3mfw+6n7EqaQjnBZ9xwww3q8aKLLlJfWKklYui+4fDhw/X+/LNnz6ruJKTWibVkzA35YoaEhKjtsVRTRfooldouREQOoyvVzHoXpcH7s75AjMnCianlNeKJnC0PYad8hLTodJV8xPHjx+u9fUREjpKSexLJ/pHG+Ty/POR6++GoXxgPChERuS65RyktBXx96z6wt4eXlx7nfQ6DGnbVQH1Y10RqhwjDF8F0vlR+ROpJvpxSM6U2mjdvrrqxkP6uq2qNIZ9p2FYiIkcLjAzE4H+1xObIArQt/dvRm0PuzknyEK6ejwgKCqr39hEROVNepMPNFyIoIgDIdvTWEBG5L6mZP2vWLPVItuf1YSf4OUHC8j7HtXGgcLKK9AualZWlIoXmZAC0Jk2aqChmmzZtrE7RZ599Frt27cIFF1ygxvAwd+DAATzxxBM8QkTkFHwCfJDSri0Ci8/h5gwGNYhcIR/RrVs3Higicqu8SFhCY/joShy9KURELj1uonQzbCohrCWm9phsnJeKMR07dmQFGaoR73Mch2NqkFVmzJiByy+/vMqBwq+99lp8/fXXmmUSkJCalIbpww8/1Lwug6lJn3WWGAonzPskJSJylOLsYhz74R8U5LAggai2mI8gIqq9PrFdMbTgqJoGFRwz5kWKcoqZnERENhg30TCZBzlkHJzVq1erR6Lq8D7HQ1tqbNy4ES+99BJ27typBtdas2YNxo4da3FdGZjyzTffxIIFCzBt2jTj8qKiIsycORPvv/++6v9s8ODBWLx4sSpEN8jIyMB9992Hzz//XM2PGTNGDdYVHh4Od6TX643PzWsumr7WqlUr1b+bpXXNX3vqqafUVBVJX+lj+5577oG3tzeWLVtmcb3rr7/e4nLz/yeD7cgPAxGRIzX2D0GUDA4OIDsnH+mbjsG/bVOAPeORG6suH6HT6YxdTjl7PkLyh0RErmxcmyuAX25Vz1cHt0eLTG/8/etRNGsrfWY4euuIiNxHfmkB8kvyjfNnzp7BF198gZEjRyImhuMnugt3KS/lfY4TBDXy8vJUtwC33XabqulflU8//RRbt2612JedBDjWrl2LVatWISoqShWEjxo1SgVKDH0/jx8/Xg2gsm7dOjUvrQMmTJig3mczgVHlg8XamfqS+TaGs0lISMDDDz+MkydPagJKdSXHWs4LKTwhInKUJy6aAix/Wj0/lAFMKwam5KSxIIFsK6Bh8hCaPIuH5COIiNzFuPy/0DMbOFMCzMg5x7wIEZENHcs5hhu+vMk4H5fPQIY973WkbFMqSvn6+sKrrgOFW8L7HI/i0KCGRDxlqs6JEycwZcoUfPPNN7jyyis1r0nfzEuWLMGKFSswZMgQtWzlypVo0aIFvvvuOwwfPlz1pyzBjC1btiApKUmt89Zbb6Ffv35ITk5GYmKibXbGyxsIaoAfPQlq2GBQTnuQyKOtSCRTfuQY1CAiIrcneYhA3jjZOh9BREREREROeK9jKNv09QVsGdRwUrzP8cCBwqVAW1pUPPjgg+jUqVOl16U1RklJCYYNG6apmSfjMGzatEkFNTZv3qwGoDQENETfvn3VMlmnqqCGdGslk0F2drZxmwwF7fIoBe+GqaEY/ldD/k9HcYd9NZwfpueOOcO55O5BHE/ZT8F9dRM6nWbwqSIvb5zwDoKvT8VSv9wziJfaJ254/hIREREREbkTGRTclIypQUSux6mDGi+++KJqilRVbbvTp0/D398fERERmuVxcXHqNcM6sbGxld4rywzrWDJ37lzMmTOn0vK0tDQUFhaq5xJQMfQtbehf2mDJ/mU4mHlQu13BsXigx/2oySO/PlZp2SVNL8ao1leoQqaysjK1zKZNtJyQu+yrnBtynsgAU35+fhbXkdel5ZHss/Sx5648ZT8F99U9eBWdRdz556EBQOlFrfFs0/YICA8wrtNm95uY1fVRuOP5S4711t4llW6y4hrF4cFe02t878wND1d7Ize1x2SbbCMRETUcyYsM7Vj+SEREdWOeD5Z8s3me2z/YHwMGDEBoaCiT2U73OFIuZCjrq889zoDml2BM29E8Th7IaYMa0grjP//5D3bt2lXrAm3TL4aw9H7zdczNmjUL06dP17TUkG6tZICgsLAwtUyCGzk5OSrwIpOpk3kn8ZdZUKOgrLDSepaYv090jOqgeW9VhePuyNX3VY6bFODLmC+BgYFVFiDK+SjnlzsX9nvKfgruq5soqLhOxIYBF41shmR/bUmCn5+vxeC5q5+/ubm5jt4Mj3cs93ilGywZxNAarHFGROR+JC9y3+WO3goiIvcXHNEIt99+u7rPW7j7NaRk/6OWP953FsIDwh29eS7N1vc4HSJtNKwAuRynDWr8/PPPSE1NRcuWFc3CpNa+DAT+6quvqpHn4+PjUVxcjIyMDE1rDXlf//791XNZ58yZMxZbXEiLjqoEBASoyZwUxBoKY+VRCmgNk0YV8ZL6tDiQ95oGY1y59YI13GVfDeeH6blT1Xo1reMOPGU/BffVDZicp8WlQPbZQuhidPD2Mz1/y89pd+PKv7tERETuSPIip7OB+DDA32nv5ImIXMvQhCG4KLaHZlmodyiOHz+O8PBwFdAwFKaX6pxzjFsiT+S0pTAylsbevXuxZ88e4yTjZcj4GjJouOjZs6eqxb9+/Xrj+06dOoV9+/YZgxoyILh0obFt2zbjOlu3blXLDOu4m1atWqlosnSPZfDDDz+oAqqZM2eq+c8//1ylZX11794dBQXlEVUJNklAyeCDDz5Ajx491BgnXbp0wcKFC6v9LGkZs2rVKtgzXeTcqE5mZibmzZunWSbReQmyVWft2rW46667bLKdRORAeh1QkFYxFZ41vnQsA/h+yd8oOGtdLRKyr9dffx1du3ZVrSdlkuv9119/rQmMz549W+UdgoKCMGjQIOzfv1/zGTJ21tSpUxEdHY1GjRphzJgx6ubFlFSckDyJjMUlkzyXa4UruaL1CFzVdrRxkiba1WE+oup0YT6CiBzp4dJuuPjjGPwLl+LW6OFqembXIh4UIqJ63PMNj+uO8a0Ga6YOXhfg0UcfxbFjx5i2boT3Oe51n+PQ+h3StcXff/9tnD9y5IgKXkRGRqoWGtJdjykJYEjLC8Pg3lK4MGnSJNV6Q9aV90mhvRSgDxkyRK3TsWNHjBgxAnfccQfeeOMNtezOO+/EqFGjqhwk3B1I+kng4tprr1Xz//vf/9CrVy/j61JwI1N9yfEykKCGpLuhG5bmzZurAiY5ZhJEkiDURRddhIsvvrjS55w4cUKt+/LLL8ORDF/Shx56yLjs7bffrvF9o0ePxlNPPYVDhw6hbdu2dt5KIrKXhTsWIOXI59qFEQPQp+g0eoIDyDkTuca88MILuOCCC9T8O++8g6uuugq7d+9Gp06d1G/5K6+8gmXLlqF9+/Z49tlnMXToUCQnJxv7xp02bZrKZElAXfIRkp+Q/IF0genj46PWGT9+vAp0rFu3zpiHkMCGvM9VpOWfxaw+D8HPx8+m+QhJ7/piPqIc8xFEZMnRnOMo9KvokeA3XSyKvU4j0zsQJT5Ball0MbuLJCKqlcJ0YHkN3Qf331LlSyVlJVjz92cYl3gdE94FsbzUfcpLHdpSY8eOHaomv0yGmvry/Mknn7T6MxYsWICxY8di3LhxqrA8ODhYFTQYCiPEu+++qwIdw4YNU5PU7FyxYgXsqUVIcyRGtNdMrRu3suq95u+TKTY4plb//9///rcqgBASUNiyZYsK7hhIIc9115X/AP/000+qxcW9996Lbt26qcIgOTZCuvmSGqymgSjz8Upk2dNPP42TJ0+qz5TPkkIKOR4S0DAEoDp06KACV5bItsp7DZ/9/fffq5Y0vXv3Vsdu6dKlxnWltu3DDz+MSy+9VH0h7r77buNr7733HpKSktR5JNvx1VdfVfpf27dvV8EuqcVrYKjhK58lX1R5r6HwRv7fF198YUxLiUTKNklaSTobyDloSHMick0puSeR7B+pmcL0xbg6vzwA36QsDxNy92NK9m7jdH2bit9WajiSObriiitUwEKm5557DiEhIep6J7/vEmh/7LHHcM0116gWgxL0yM/PV9cJw+/5kiVLVDBdAvJy3Vi5ciV+//13fPfdd2qdAwcOqGCGZNbkOiHTW2+9pa4JEhypirQAkbG4TCfDWCXmk2xrVVPzkGaV8xJhrap9j2EyfU92cTY++ftTq95nuDbedttt6pom83JdlHQdPny4ek2WGfIR8vzHH39U18177rnHmI+Qa628Jtd9yUcYPlvGIjN0p2noZlKWzZkzR5OPkOCU5AOkq1BZT1rjSD7i8OHDFrdZjqUhACPzcgzleBlajBr2RSa5rktm3JCPkJpDhtckz2jIR8hkyEcY0kUepfWv5CNMj5/8L1nXPB9h+H+SNzWkpVTIMeQjJJ0Nn3H99der/ajquFg6f2w5NcT/cIbJU/aT++oe06L9K/Bg5EDjZJlzntNERO6oRFeCudvmYdvp7Y7eFJdlKC9tH96O5aV1LC81vc9ZaqG8VAa5l8909/JSh7bUkJ03TaiaSAG7ORl4Wbo1qq5rI2nBIQUVDemOrpPq/N75A1+s9/+XE1jSRFpAyI203CibBnrMSZccUmizePFi/Pe//1UFQYZuvqwhgSg5QT/66CP1pTL3xx9/YPPmzXjzzTctvl8CK4ausYS06JAmTHJ+SGGQtPKQoEyTJk3U6xLhk/fImCoXXnih+mz5okmBy4033qi+7HK+SIFISkqKZrBxCZTIOSE/BFKQJYPRnz17Vn2+fHnly2lac9SU1OqVQrPffvtN9aEvY7MYyP+SQhIpWCMi97HbPwY3xYxEblkeDvv+ge3+8VhcsKtihdjujtw8Oj/m1ocffoi8vDx1LZAM4enTp1VFBgMZJ2vgwIHYtGmTKsSW1hjSTaPpOtJVlVzDZB25nsi1RTKZkvkz6Nu3r1om61TV4nPu3LmqkN6cXDMKCwuN8/L/peCntLRUTeZu63iLxc+3tG6lbej/bJ3eZ3pNk3yEXEO//PJLFRySa6tsr6S3TIZtl+eSj5D8w//93/+pa73kI+R9hv9Z1aPhuTTvlwz5+++/b8xHmK5jyEe89tprFvdD8gQPPPCA8TWpwCLBFsn7nDt3Th1DueZLPkLyFtJSWLovlXyEZLp/+eUXdWwHDx6s8kyyr3IeyTkj7/P39zduk9wIyFhu3377rVpfAjCSj5D12rVrp85BuSEwrC//T9JInt9///0qHyGVRwz5CMM2yzbOmjWr0rkjr0tap6ena/IztiSfLzcisq3uOEaQp+2n4L66h5KSUqvWMe0C2BlIsJqIyB3N37EAf2UcVIXxVPfyUsmLSR7X19e3VmM5sry0vLxU7l18zt/nyLx5eancB0mFPrnPcefyUg4vZgczNzxcaZn0Xz2m7ehq3/fnuWS8/XvlyNXtXf6NDpG17ypLuseQmqmffvqpqnkoU1WkYMYQaZOTff78+bAV6bZDuqiQwg4pMKpqHUOrDiE37lKTUWrCyhdMvkRSYGL4kv7rX/9SX2DpJ12ihPKlNRRk3XTTTerz5MdR3idfUkP3JAZSqCAFI/IllUIbaaVizQ+pRCClIMxwIxwTU9GCRrbfvC92InItfWK7ouXpH4zzJfDBT0EtUOrlg0JvP+h8fVDsXXWAmBqWtKqQ334JFEgGas2aNSrQLQEHIbX8Tcm8XBOEBD2koFoKp83XkdcM6xi6VDQlywzrWCIF09L61ECC8y1atFDXDGlxYCDbLQU/cr2SSTy48ZFKn3dpM8lDjKoxD7FkX0UtHYNJnW+rUx5CtkfyEZJ3+Oyzz1TlEHku1z+5/sokz2U9eS75CEPwR1pqSkta0/2q6tHw3HS56WtCrq1SO0nGUZHm4pZIJY5mzZoZ3ysF11Kb6K+//jLmByRPIcdBrveSoZdAl0ySj5CM/SWXXKL6Tb711luN+QjJj0gLEkM+wrB9ko+Qbk3l5kC2S1qpSH7F0v7J/5M0kmVSI0oCGoYgiSFfI2T7ZT/M91/mJa2lizSpzGOvAnDZTjlH3bmw31P2U3Bf3YOfn9ntuhfg5eOtHk3XsXStciR7/VYRETUUQ/7NvJxIAhpkm/JSQ6ttlpfWrbz0L5P7HE8tL2VQww6SMyr3u25NgUJ+Sb7F98ryupCbconYSbccUnPQ2oynnPyGWoNyokvtQgPTGqbWkIIA+SI8/vjjquZjVaTbMMOA40IKIqRfc+nnXAoJpKWG6f+uanvlyysBGemSTEiE0dI2S41TaZIltSulJYsUvtSX/B/50SAi1zWuzRXAL7eq5yXwxtzwPsbXGsU3Qu9HkhBefA7IcOBGkpEUpEtNEWkG+/HHH+OWW27Bhg0bjK+bZ74MGefqmK9jaf2aPsdQWG5OMnimBanyXD5HuofKQ161eYiatrugtMDie2V5bWo/Gch7pGskQz5CJsPnmKePTHJdNiyXvINcl2VeruGSjzC8Jl1zVfUZ5s8N+QgZC0XyEdJsubp8hFyHDe+VIIN0USbnhSyT/ZD/bXhdrteG55KPMGyjBDsM+Qg5zhJIMP1cw/ZJV1ePPPKIOv8M+Qjz/TBPz6r20UC2z3S7zN9rfv7YWkP8D2fgKfspuK/uQPt7YMiLXFx4AijMVMuathnpdOezs20PEZGpwtIi6Ly0xaHeej0CUVH21aZ1gmpFrILGJ5h+tsLyUtuUl5rf5xR6aHkpgxpuTKJ80gWG9KNWVxJNky+A1G6UwqPly5dXua7UPpWakQanTp1S3TLIl0EKmqoj3UT8+eefqkmSyMjIQEJCgvqCbty4UTVfsoa8r1Wr8rFLpFapzFsiBS7S/YgMdCoFE+Hh4cZ9kCZahmZw5mT9l156Cf/5z3+MzakM0Ufpe12adhGRe1gTfAGyvfyR2LgN4F3+e1BSVICE/MpdIZJjSG13Q80SaW0oXf7I77Ncd4S0pjCtCS/dcxhab8j1TboekuuEaWsNWcdwLZJ1zpw5U+n/ym+/eSuQ+nhx18s4mOV8tb6Yj2A+goicT2LxOTySZdKXe7svHbk5REQu5/EdC5AcO6rSb+v8jI0W1x/ddhQuKTxnnF+yb5kqnH9y0xzNOBH16YaeGhbvc1a6RXkpq1C4OallKc2M6kpOVOkfe+TIkWqcDkMNS0vuu+8+9f8MA4XLOBv//POPOqFlmUymA9iYkm4lZOAZgxdeeEH1tyZdQchgpKb9mVdH/tfVV1+t3ieBkKq6qRDSXEu6eZgyZYpxmUQqpTmWDGxj6I7LlEQo5Uss/X3L/kgf4AYymKxhkFIicn3j8v9SGdv5fR9RfXdObXUv8t8/h7EplvuQJMeTmvVynWrdurUKSMiYCQYSwJBWHIaAhbQAlFYEputIMH7fvn3GdeT6KcF6GRjaYOvWrWqZYR1beL7f01g7do2anI0r5yMefPBBNU4G8xFE5KomtLsKD2duM063HtqMk29tw7GKsjUiIrKDY8dPqBr00jXpwOaXYuwFVxknw3gau1P3GCdLLRDIufE+p6XLl5d66WszUrcHk/6wZWBQKcgw9IctzWekTzIpPDFt3jP606srvf+qtqPV2BjV2XVmN57a/HSl5XP6PYmL4nqo53UdTMcV+v2VAWmk3+7mzZs3yL6uXr1a9YctA+DUl/RFJ61SpJawoZ9sg6rOE/P9l9rB0rTRnZtre8p+Cu6riypIA5ab9Us9MRUIisHBgwcx+Z478PqgDWgbU/l1dzt/pe9N6XLI9LrnTCSTJAXlMkaCjEsh3RVKQbZkmKS7ohdffFG1VpRCcOmC8fnnn1eDSUvLw9DQUGMXRdL3pxR6SyZt5syZqo9S6QtUmuoK+R/SNFiuF+LOO+9ULQmlKW598hBVXR/smYewBWfNh1jKR9h7X50pH1FfnnLN8pT9FNxXN2GWLzmUBkxbDbw6DhV5ESfMh1R13SPPSk9P+h1yBKZv3c38cQaSsw5XWi7BY4NzbV/ComeWqbEFzLtzl3EhzIMYEuiwxSDW7sQV73WcUV3uc/T1vGdz9H2Otdc9dj9lB4aoranY4JozmsF+wRbfK8vdnWRy5AsjA3XaqjCiOiNGjFCD6sigsrYghX8yUKj5F5SIiOxDuoWSgayldYVkeKQbQ0NAQ0hrP+l7VAY2k6a10uLv22+/NQY0hGEwaxmrQdaVzJYEOAwBDSGDY0sLgmHDhhmb1S5atMhuh5V5iLphPoKIiIiI6uNFk/EU41K+Y2La+V7HME4hy0urx/ucqjGoYQd1jc7KQKCeHNm11HzJXqTgy5as7R6LiIhsY8mSJdW+Lhnk2bNnq6kqUhtk4cKFaqqKtOCQMZoaCvMQdcd8BBERERGR8zLc69S2JQHLS1leagmDGkRERFbKLM7Gt4Et0STYz7gs4tQ2DGxzJdOQiIiIiIjIyQ1tfjEuOvGVcf79kA7G57FleUj1aVTt++MaxSG/tKDSMiJqWAxq2Kh/M6KqcNgaIvcQFxeHhLFt8HmTZvANqrh8Jqb8wKAG1QuvE8Tzg4isyouEAg8PL38kIqK6Gd78UuCHP43zu/xjkewfqZ5Py9qNNY0uwNnIZpg8ebK6BzT3YK/pTPpa4L0O2evcYFCjHmT8BOnbTAYQjYmJUfP2HjTTWQfotAd32FfZh7S0NLX9fn4VNbuJyDkdzTmOQr8IzbLAnONoFRSDkJAQNO3cFIfzjzls+8i9yHVBrg9ynZB8hCtc69zh2uxK+8p8BBGZCgkELrmAaUJEZC9+KMOszG34pNNdSIpOUveAZPt7HWfIZ7szvQukry3ucxjUqAcJaMgI7TJIqQQ2GuqgS8sQ+d/OemLairvsq2y7DH5uOvAsETmnRftXIjlyoGZZ4v6VmB/bA5mZmTi06RBK2wF+jfwdto3kPuS6INeH48eP4+jRo3AF7nJtdqV9ZT6CiAySi4KwIVmPvom+aBxc/rsUkJ+G+KAYJhIRkY34QYehEf3x2ddf46qrrlJj7JFt73WcJZ/trvQukr71vc9hUKOepHVGy5YtVQSsrKwM9iYnZXp6OqKiotTJ6c7cZV8l4siABpHrk9+j/ev+QOu4dgxqkM1I7a927dqhpKTEJVLVXa7NrrSvzEcQkcFL6Iy12/5Bp85d0Si6vM/3xL1LMP+yl5lIREQ2lH4uA++//z4uueQSHCz6G5lFWZrXwwMaI6lJH/V84e7XkJL9j+b1mb0eQHyjeI8/JlXd6zhLPttd6Vwkfet7n8Oghg0Ymso0RPdCcmLK/wkMDHTqE9MWPGlfiYjIc0lGzlWC3550bfakfSUi5/TN8Z+R3qhiANvDunAA2oIzIiKqn4TSbOPzQH3lysof/vUxkjP+0ixLjGhvDGpIQMP89aKyYh6Wau51mM+2L52H3McwqEFERGSl1sHN8OK5DWjtW5Ex8B20j+lHRERENrf++K9IDqkIaiAnj6lMRGRjU3P2ME2JXJD7hmuIiIhszNfbF5H6YkTrCo1TeEAY05mIiIiIiMhdFJ0DdMVAoTxa6CZWVwoUpJVP8txC6w4isi+21CAiIjpvQrurkPPdjZr0CO31gHoMDg5Gj26dEey/gelFREREDc4nwAfh7SLUIxER2cfq4PZI3vYg/CLSsernSUhu2q7ySmk7gOWx5c8jBgD+2sHEt53ezsNDZGcMahAREZ3XLaojUHRSmx6yDECTJk0w/b67EbfuNaYXERERNbjAyEC0H9cBU7J3A+e7gA/vcS+PBBFRLfyWfgA5AU01y0L1xehWfFY93xYQj+TQSHjf1A7b6piyAT7+PCZEdsagBhERkRVKS0uRnZ2DqDLAlxUkiYiIqIHpynRok3MWg/NTKvIisd15HOzk9ddfV9PRo0fVfKdOnfDkk09i5MiRav7WW2/FO++8o3lPUlIStmzZYpwvKirCzJkz8f7776OgoACDBw/G4sWL0bx5cx43IgdZcfAzJIeXD/JtkFh8Dt2KN2p+b8sKy+AT6ANvH28E6Urw0rny1x+MHIBk/0iMjhur+Ywp3SuCzOEBje2+H0SejkENIiIiK6SkpGDyA7Pw+iCgbQyTjIiIiOzr2V4PQPd+a+P84TQ9Hv6gDCnjmBdpCBJ4eOGFF3DBBReoeQlgXHXVVdi9e7cKcIgRI0Zg6dKlxvf4+2trZ0+bNg1r167FqlWrEBUVhRkzZmDUqFHYuXMnfHxYS4bIWRWkFmD///ai07+7olGTRmhZmoOEshz1mjyXoIapxMZtMLzVUAdtLZFnYlCDiIiIiIiIyMkE+gYA+ooBaIP0gLdDt8izjB49WjP/3HPPqZYb0hLDENQICAhAfHy8xfdnZWVhyZIlWLFiBYYMGaKWrVy5Ei1atMB3332H4cOHW3yftO6QySA7u7yvMZ1OpyZXIduq1+tdaptdCdPXeltPb0dWUZZxPjnrcOWVorpBd+Xq8udbngPS/6zlEeG5Xhs8f+1L5+K/v9ZuN4MaRERERERERERVKCsrw4cffoi8vDz069fPuPynn35CbGwswsPDMXDgQBX4kHkhrTFKSkowbNgw4/pNmzZF586dsWnTpiqDGnPnzsWcOXMqLU9LS0NhYaFLFUpJYEcK1ry9GY5j+jrOqj8+wOHcI9WuU1IGpObo1XMvvR8C9SXw0evVo3Q9FaAvq/79JaVITU216Xa7M/4+MH2rk5NT3iqqJgxqEBERERERERGZ+f3331UQQ4IJISEhWLNmDS688EL1moytcf311yMhIQFHjhzBE088gcsvv1wFM6QFx+nTp1V3VBEREZrPjIuLU69VZdasWZg+fbqmpYa07oiJiUFYWJhLFVp6eXmp7WZQg+nrSH5+flas42sMSL7Y7yEc2RKPacXAq+dS0daKnuJM37/iwLs4mXtK83rTkCaY0PGmuu6C2+HvA9O3OoGBgbAGgxpERERWOlmQigWhPRAZXnGRbXHgA9xx0RSmIREREZGbSUxMxJ49e5CZmYmPP/4Yt9xyCzZs2KACGzfccINxPWl90atXLxXg+PLLL3HNNddU+ZnSckEK+6siARGZzElgwNWCA7KfrrjdroLpWz8vndtgfB7Y/8mK87SG83VA4XF0KDmnWRbb4Qbj+38/uw/JGX9pXk+MaM/vgRmev/bl5cK/v9ZuM4MaREREVmjdujUGPDwQR0tPIcW74kY0P6v6psxEREREttA6CvjgDhlrg+nZUKSlhWGgcAlabN++Hf/5z3/wxhtvVFq3SZMmKqhx8OBBNS9jbRQXFyMjI0PTWkO6qOnfvz8PIpGdbDj+MzIKK4IO5gEGkVh8Dh1KMioWhDa3+vd2TIGFMTniugIFaeXPdRVjIRGR/TA7REREdN43x39GeqMOmvSIOv4zhre7RtUW8Av0g1d+1TXriIiIiOxFKi4G+zN9HUlaWZgO4m0qPT0dx44dU8EN0bNnT9Xtzfr16zFu3Di17NSpU9i3bx/mzZvXoNtN5EnWHvrCYiDDrr+3qztVPI8YAPhHal9noIPI5hjUICIiOm/98V+RHKINaiQe/1UFNU6ePIkt72xB2OBIBEYGMc2IiIioQX1cEI8PfirCiMvDEBlRfisfcWobBra5kkfCDh599FE1boaMZyGDlq5atUoNDL5u3Trk5uZi9uzZuPbaa1UQ4+jRo2r96OhoXH311er9jRs3xqRJkzBjxgxERUUhMjISM2fORJcuXTBkyBAeM6IGFOQbhJcGvFA+U5SBgM+qby11MhP470bg7gFA0/CG2UYiqh0GNYiIiKxQUFCA1ENpaHQJc7VERETU8L72boENJ/7BWb/2aBTaSC1LTPmBQQ07OXPmDCZMmKBaV0iAomvXriqgMXToUJUvlEHEly9frsbbkMDGZZddhg8++AChoaHGz1iwYAF8fX1VSw15z+DBg7Fs2TL4+Fgx8jAR2UzL0BZICGtZPlMQBJTlV71yYBTyrtiCLesfxoQrXsToQ+eDIQAujrsIKCtG06MfY2LeAbVsQ2AzZHhXjLmYfL6VRlRZgXFZY/8QHk0iG2NQg4iIyEr+3n5oUpaDxqVlxmVxQdFMPyIiIrK5hfuWI0W6MTnvcLoMHv0PU7qBLFmypMrXgoKC8M0339T4GYGBgVi4cKGaiMhFeHkDgZGAt3/5o4lfz+xSj4n+McD5oMbaoLbGQIbpmB3zMzZWLLhiRUNsOZFHYVCDiIjISgnBTfF05ga09TNZeOUqph8RERHZXEruSbOCsjymMhERERGDGkREREREREREROQOHu87C6VmA3P7ete9TndUYBTSC9NtsGVEZEtsqUFERHTes70egO791pr08B58RD3KwI8TbxqH6KwNTC8iIiJqcP5h/kgY3lo9EhHReXodYBJ0sDgCon9YrZJL3ftNnKgecYgpTeSMGNQgIiI6L9A3ANBra/VAlsngbo0bY+jlA9B4nVlyFZ7VzgdGlffDSkRERGRDfo380KlHGF469z1wfoxb30H7mMZE5NkkoLE8tvp1xu0HAmPU09XJH+J0WHfNy/GHv8K4TrcY5+Xeb8iQIeqxbXgbRBdFGV9LzvgL6T6B2OVf/j/Nx9MgoobBoAYREZEVcnJy8MumbRhWCIQGmryw+kLtihNTgaDyDDMRERFRXSWENAXSdhjniwtKof/rDAJiCyvyIgG1q31MROSRVncyPt0WMQDJQa00Lyem7sW4Ttp7v19//VUFNp7o+6hm3Zk/zkBy1mE8FdHfuCy6LB8vnasYGNxXWo8QkV0xqEFERGSF1NRUvLFkOboPMgtqEBEREdnB1M4TgV0zjfOH0oBpa4HUccyLEBHZ/d7vjTfQtWtX1VqjJlFlhYjWFfKgEDUgBjWIiIjqYGbEAIvLE/Ytx9TeM5imREREREREdvbWgQ9wLLyfZlmL0lzckfu7er68UUec9A0xvsbuoojcg0M7/d64cSNGjx6Npk2bwsvLC59++qnxtZKSEjz88MPo0qULGjVqpNaRQXpOnjyp+YyioiJMnTpVDd4j640ZMwbHjx/XrJORkYEJEyao6KpM8jwzM7PB9pOIiNyPZIYtTSm52usUERERERER2em+LOsIdgfEaaZkvwjj63v9Y/BrYDPjRETuwaFBjby8PHTr1g2LFi2q9Fp+fj527dqFJ554Qj1+8skn+Ouvv1TQwtS0adOwZs0arFq1Cr/88gtyc3MxatQolJWVGdcZP3489uzZg3Xr1qlJnktgg4iIqFa8/KC7akv5uBlERERERETkfKK6ld+zySTPLQjSlRinAB9/m/3rx8IvxriYKzXTY9tfsdnnE5ETdD81cuRINVkiLSrWr1+vWbZw4UL06dMH//zzD1q2bImsrCwsWbIEK1asUIP3iJUrV6JFixb47rvvMHz4cBw4cEAFMrZs2YKkpCS1zltvvYV+/fohOTkZiYmJDbCnRETk6gIDA9H2ggsQGN6UA4ETERFRw+dFfIHEuPJHIiKqhrdfxT2bPDeTWHwO8zMqBvbGyKWV7/3atlWP5m7vMA7567QVroP1JcbnRV4+KDD7n0VlxTxcRDbmUtkhCWJIN1Xh4eFqfufOnaqbqmHDhhnXkW6qOnfujE2bNqmgxubNm1WAxBDQEH379lXLZJ2qghrSrZVMBtnZ2epRp9OpyVHkf+v1eoduQ0PhvrofHlP35FbHVaer1IRR7ZdOhyZNmuDJJ59ETExMpX29Iv8w/PTly2ISr3f5tDAcUyIiInIezSKA+dc5eiuIiNxfs2bN8NRTTyE2NrbSax3C2wDFbLlP5GguE9QoLCzEI488orqSCgsLU8tOnz4Nf39/RERU9JUn4uLi1GuGdSz9CMkywzqWzJ07F3PmzKm0PC0tTW2LIwuaJLgjhU3e3g7tPczuuK/uh8fUPbnTcV1+8G2kmg0AHrvrLUxsd3ul/WwT0hrQlcIv8zdElRViXP5fav0zwV2RmuramVzDvhIRERERETmzuKBo5KfvqbTMoLF/CKLKCjSvN9ZXVGImItfkEkENaY3xr3/9SxWyLF68uMb1pcBJWnQYmD6vah1zs2bNwvTp0zUtNaRbK6mhawiqOIKkgWy3bIerFx7WhPvqfnhM3ZM7HdfUA+fUYN8apedUIPzgwYO477771DhQ7dq1w4LL5wMFafBeGa9ZPSY6xuW7p5JjKmNUERERkfN4Lq893nk3DcMmtkJkfHmXKC0OfIA7Lpri6E0jInKYB7vdDvz2qHbhlauMT5+Q38jlT9fqMw8dOoTJkyfjtddeU/d+ROR8fF0hoDFu3DgcOXIEP/zwgyagEB8fj+LiYmRkZGhaa0gN2f79+xvXOXPmjMUWF9KioyoBAQFqMicFdo4utJPCQ2fYjobAfXU/PKbuyX2Oq6Vgd8W+VdpPC/urXnP5dLBcIYCIiIgaTmFpEXReFbfsf/hHIss7C3/4R6NRQCO1LD/rCA8JEZEDvRXSBcd8Q4zzhkpyQwuOGpfFtxvrkG0jcme+rhDQkNqxP/74I6KiojSv9+zZE35+fmpAcVlPnDp1Cvv27cO8efPUvAwILl1obNu2TQ0yLrZu3aqWGQIfRERERERERM7k8R0LkBw7yjifdyrPodtDRESVJftFVGrtLwOR35dt0iVWmyuYdETuFNSQri3+/vtv47y0xtizZw8iIyPVgN/XXXcddu3ahS+++AJlZWXGMTDkdRlLQwb7njRpEmbMmKECHrJ85syZ6NKlC4YMGaLW7dixI0aMGIE77rgDb7zxhlp25513YtSoUVUOEk5ERERERERERERERM7HoUGNHTt24LLLLjPOG8awuOWWWzB79mx8/vnnar579+6a90mrjUGDBqnnCxYsgK+vr2qpUVBQgMGDB2PZsmXw8fExrv/uu++qftCHDRum5seMGaP6RCciIjKVENIUSNthtuwSJhIRERERERERkZNwaFBDAhMyYHdVqnvNIDAwEAsXLlRTVaQFx8qVK+u8nURE5Bmmdp4I7JqpXTj6I/XQokULvPTSS+qRiIiIqKEFRQeh6z090CaoED6l2WpZXFA0DwQRkY3x3o/I+Tn1mBpERETOQro9jIuLU49EREREDc3bzxvdQvIxP2NjxcIrV/FAEBFVJzAKmJha8zpW3vt9nvI9UkM6G+cN42m0OB9sFnFlFWMgHfUNQ2HmIaAgveLf+QShVeMEHjeiemBQg4iIyApnzpxRYzPdddddaNKkiVr2Z+Zh5PvHatYLzjyMDkExTFMiIiKql6HNL8ZFJ74yzmdllWL3L+k4cxEQF8bEJSKyipc3UMv7M0v3fgYbT21HcqMLKg0Mrgk4m1gU2h3JW1/Urh/RHvMHapcRUe0wqEFERGSF3NxcbNq0CTfddJNx2dt/rkZyRH/Neol/rsb8JklMUyIiIqqX4c0vBX740zh/KAP4aj+Q2wmIY9oSETXovR8RORdvR28AERERUW3NnTsXvXv3RmhoKGJjYzF27FgkJydr1rn11lvh5eWlmfr27atZp6ioCFOnTkV0dDQaNWqEMWPG4Pjx45p1MjIyMGHCBDRu3FhN8jwzM5MHjYiIiIjIwWZueQGj48ZqJllGRO6NQQ0iIiJyORs2bMDkyZOxZcsWrF+/HqWlpRg2bBjy8ir6rxUjRozAqVOnjNNXX1V04yGmTZuGNWvWYNWqVfjll19UraxRo0ahrKzMuM748eOxZ88erFu3Tk3yXAIbREREREREtaYrZaIR1RO7nyIiIiKXI8EFU0uXLlUtNnbu3IkBAwYYlwcEBCA+Pt7iZ2RlZWHJkiVYsWIFhgwZopatXLkSLVq0wHfffYfhw4fjwIED6n9J8CQpqbxbsbfeegv9+vVTLUMSExMrfa60/pDJIDu7fNBAnU6nJlcm26/X611+P6zBfXU/PKbuya2Pq05XYy1Etd9Otu9ueSyIiIjIqTCoQUREZIWIiAjVxZE8kvORAIWIjIzULP/pp59UsCM8PBwDBw7Ec889p+aFBEBKSkpUCw+Dpk2bonPnzqoPXQlqbN68WXU5ZQhoCOnCSpbJOpaCGtI11pw5cyotT0tLQ2FhIVyZFFRJWksBore3ezf45b66Hx5T9+TOx9Wr6Kxm7IyIYODG3uWPBmln06AP0MOZ5OTkOHoTiMjD9C46jZiyfHwV3Mbu937z+z4CLC+/n7DGhLw/kJPvr1kW2usBm2wnkSdjUIOIiOi8wtIi6Ly0l0bv0iIEni8sv+aaazSF5rd3GIf8dWM06wcnPcL0bGBSkDV9+nRccsklKiBhMHLkSFx//fVISEjAkSNH8MQTT+Dyyy9XwQxpwXH69Gn4+/tXulmJi4tTrwl5NARBTMkywzrmZs2apbbHtKWGtP6IiYlBWFgYXL3wUMYmkX1xt8JDc9xX98Nj6p7c+rgWeGlmIxsB4/toV4mJjgGCYuBMAgMl50RE1DD6xHbF1X+9indCLrTZZ1q696urbsVnKy+M6ljvzyXydAxqEBERnff4jgVIjh2lSY/EHQsw/7KXkZ+fj71796J///4ICQlRr3UIbwMUp2rTT5ZRg5oyZYo6NjImhqkbbrjB+FyCHb169VIBji+//FLdpFQXJJECMgPT51WtY0oCJjKZk8I2dyhwk/12l32pCffV/fCYuie3Pa5m+5NfDPx5GugQDwSfr/Sr9tnJ9tvtjgMRORe9DihMN86OayrRXtt2e2fp3s8oMAqYmFr99gmv87+FhWeB1bYLuBBROeY2iIiIrCCDTM+fP189kvOYOnUqPv/8c/z4449o3rx5tes2adJEBTUOHjyo5mWsjeLiYmRkZGjWS01NVa01DOucOXPGYldShnWIiIgawn363hj5bRxG+Q7F6Lixapq55QUmPhF5FgloSPdPhskOAYNq7/0kWCEt5KqaguPKJ8N8YLTNt4+IGNQgIiIiFyQtJaSFxieffIIffvgBrVu3rvE96enpOHbsmApuiJ49e8LPzw/r1683riM3Lvv27VO1soQMCC59tW/bts24ztatW9UywzpERET28Fv6AfwS0NQ4HfYLZ0ITEVUhtiwficXn1JQQ0pTpROTm2P0UERERuZzJkyfjvffew2effYbQ0FDj+BYygHdQUBByc3Mxe/ZsXHvttSqIcfToUTz66KOIjo7G1VdfbVx30qRJmDFjBqKiolSfuTNnzkSXLl0wZMgQtU7Hjh0xYsQI3HHHHXjjjTfUsjvvvBOjRo2yOEg4ERGRraw4+BmSw00G0SjIY+ISEVVhTMFhNSmjP2I6Ebk5BjWIiIjI5bz++uvqcdCgQZrlS5cuxa233gofHx/8/vvvWL58OTIzM1Vg47LLLsMHH3yggiAGCxYsgK+vL8aNG4eCggIMHjwYy5YtU+83ePfdd3Hfffdh2LBhan7MmDFYtGhRg+0rEREREREREVVgUIOIiOi8oc0vxkUnvtKkR1SnCepRuimKjY1Vj+Qc3U9VR1prfPPNNzV+TmBgIBYuXKimqkgLjpUrV9ZpO4mIiGzF29cLgRGB6pEapgKFTNLaU3Tq1AlPPvkkRo4cacyLzJkzB2+++aYanyspKQmvvfaaWs+gqKhItQJ9//33jZUnFi9eXOM4YERUtT8zDyPfP1azLPjy5egQe5F2MO964L0fkfNjUIOIiOi84c0vBX74U5sesgxAy5Yt1WBxEtggIiIiamhBMcHoem8PXJX3N3C+J6rYDjfwQNiJBB5eeOEFXHDBBWr+nXfewVVXXYXdu3erwMW8efPwyiuvqBae7du3x7PPPouhQ4ciOTnZ2Cp02rRpWLt2LVatWqW6upQuL6ULy507d2pahRKR9d7+czWSI7Rj2yUe/hbzE4bbLBl570fk/BjUICIiIiIiInIBMgDu7bn7KhYkDHbk5ri10aNHa+afe+451XJjy5YtuPDCC/Hqq6/isccewzXXXGMMesTFxakxv+666y5kZWVhyZIlWLFihXGsLmn52aJFC3z33XcYPtx2BbBE5Ly+Of4z0ht10CyLOv4zhrcr/+0gorphUIOIiDyXXgcUplfMF56tclXpekC6D5DWGm3atFHLPk/5HqkhnTXrxaZ8jzEd/mW/bSYiIiKPMKXTzSj8oiJoceJsGRZ+ko+jo4FW0Q7dNI9TVlaGDz/8EHl5eejXrx+OHDmC06dPG8fbEgEBARg4cCA2bdqkghrSGqOkpESzTtOmTdG5c2e1TlVBDemySiaD7Oxs9ajT6dTkKmRbpYsuV9pmV+LZ6WupG1rbpsXhw4fx0EMPqRZZhnu/ulp//Bckh2iDGonHf8HQtmPhqTz7/LU/nYunr7XbzaAGERF5LgloLI+1+mY2NzdXPRpsPLUdyY3KuyQwSDy1nUENIiIiqrdWoc2BkgzjvF8xUJYPlFU/rBTZ0O+//66CGIWFhQgJCcGaNWtUKw0JSghpmWFK5lNSUtRzCXr4+/sjIiKi0jryWlXmzp2rxuowl5aWprbDlQqlpLWKFKx5e3s7enPcjienb0lJqcVlqampNvsf8lkyVo48ynff2bfX1Xjy+dsQdC6evjk5OVatx6AGERF5rN/SDyAnoKlmWai+GN2Kq26xQURERESeITExEXv27EFmZiY+/vhj3HLLLdiwYYPxdS8v7aDtUoBkvsxcTevMmjUL06dP17TUkC6rYmJiEBYWBlcqVJP9lO12xUI1Z+fJ6evn52txmS3HPpQCYV9fXzUWTn0/tyG219V48vnbEHQunr6BgYFWrcegBhEReawVBz9DcnifSn1Vdyve6LBtIiIiIiLnIC0tDAOF9+rVC9u3b8d//vMfPPzww2qZtLho0qSJcX2peW1ovREfH4/i4mJV29u0tYas07+/dpBjU9KNlUzmpGDK1QqnpFDNFbfbVXhq+t7e4QbkrxujWRac9IhN00E+y3bpaymIWf7ZnsxTz9+G4uXC6WvtNrvenhERERERERERNTBpZSHjXbRu3VoFLdavX298TQIY0orDELDo2bMn/Pz8NOucOnUK+/btqzaoQUTV6xDeBhcVp2omWUZEnoUtNYiIiExFdQNGf1QxHxilHpo1a4YnnnhCPRIRERE1tGbhwEvXlj+S/T366KMYOXKk6vpJ+vdetWoVfvrpJ6xbt07VgJ02bRqef/55tGvXTk3yPDg4GOPHj1fvb9y4MSZNmoQZM2aoLmwiIyMxc+ZMdOnSBUOGDOEhJHJitrz3e7bXA9C931qzzHvwkXp/LpGnY1CDiIjIlLcfEBRjsV9HuWE17d9xft9HKg80PtxzB3wjIiIi+wn0AzrEM4UbypkzZzBhwgTVukICFF27dlUBjaFDh6rXH3roIRQUFODee+9VXUwlJSXh22+/RWhoqPEzFixYoPrlHzdunFp38ODBWLZsGXx8fHggiZyYpXu/On+WbwCgNxssXJYRUb0wqEFERGSFs2fP4t1331U3t548qBsRERE5xubCxvhqjw6DegQgIrS8J+ngzMPoYKEyBtXfkiVLqn1dWmvMnj1bTVWRAtGFCxeqiYhcB+/9iJwfgxpEROSxpnS6GYVfDNYsC+z/pMV1s7Ky8M0332DMmDEMahAREVGDW+LVHmv3/YNf+3RFo4hGalnin6sxv0kSjwYRkQ3x3o/I+TGoQUREHqtVaHOgJEO7UJYREREROdjqw1/hdFh34/zhTBlM4x+HbhMRERGRM2BQg4iIiIiIiMjJbEvdi+SgVhULMvMcuTlERA1i4e7XkJJdEcCNaxSHB3tNZ+oTkQaDGkRERERERERERORwEtBIzvjLOJ9fWuDQ7SEi58SgBhERkRXCwsIwePBg9UhERETU0HyDfRHbM149EhF5qs9TvkdqSGfNstiU7zGmw79s9j9470fk/JgbIiIiskJMTAxuueUW9UhERETU0AIaB6DViNaYk7EJOD8kWHDSIzwQROTWSnUlWJ38EcYlXqfmN57ajuRGF2jWSTy13aZBDd77ETk/BjWIiIisUFRUhKNHj6Jx48YICgpimhEREZFdBfj4I0hXYpwvKylD3OlUdPJJRYDf+YXhbXgUiMitnco7jW2ntxuDGq5277dw33KkRAzQLEvYtxxTe8+o51YSeTYGNYiIiKxw/PhxPPnkk3jttdfQrl07teyl397GkajLNeu1/u1tPNh3FtOUiIiI6uW53tOB5bHG+UNpwLTVwPFxQFs2HCUiD9a76DS2B8Q36L1fXaXknkSyf6R2Ye7J+m0gETGoQUREVFdnCs7imK92jI3ggrNMUCIiIiIiojpIjGiPYL9gzbIWIc2Nz/vEdsXVf72Ka+LGuG76Siu8grSqXw+MAry8G3KLiFwOW2oQEZHHWn34K5wO665ZFn/4K4zrdIvDtomIiIiIiMhT3dF1UrWvj2tzBfCLDq6oTUkmonSFyC4+p2mJV8nEVCCITfKIqsOgBhEReaxtqXuRHNRKsywxdS/GdXLYJhEREREREZEb8tPrMCtzG9YEVwx0Xggf6Ly8NOt5lxYh0AHbR+RKGNQgIiKygpeXFwIDA9UjERERUUOTHEiQX/kjEZGnS5TWDuclhFziMvd+ftBhXP5fxvnHIy6uPObG91Oxduwam/9vInfi0A7aNm7ciNGjR6Np06bqh+LTTz/VvK7X6zF79mz1elBQEAYNGoT9+/dr1ikqKsLUqVMRHR2NRo0aYcyYMWpAH1MZGRmYMGECGjdurCZ5npmZ2SD7SERE7qFNmzZ488031aNBYuPW6FF0RjPJMiIiIiKb50VigNV3nn8Mbo+ZEQMwc9MzmPnjDOO0cPdrTHgi8gjzMzYap6mdJ9r93o+InItDW2rk5eWhW7duuO2223DttddWen3evHl45ZVXsGzZMrRv3x7PPvsshg4diuTkZISGhqp1pk2bhrVr12LVqlWIiorCjBkzMGrUKOzcuRM+Pj5qnfHjx6tAx7p169T8nXfeqQIb8j4iIqK6uqPjDcD2qdqFHT9jghIREZFdXZ3/N/70j8T2nGNMaSJyb3odUJheMV94Fq4kIaQpkLaj/HlptlXv8fUqL88kIicNaowcOVJNlkgrjVdffRWPPfYYrrnmGrXsnXfeQVxcHN577z3cddddyMrKwpIlS7BixQoMGTJErbNy5Uq0aNEC3333HYYPH44DBw6oYMaWLVuQlJSk1nnrrbfQr18/FRxJTEy0+P+lBYhMBtnZ5T88Op1OTY4i/1vSxpHb0FC4r+6Hx9Q9ufJxDfDxQ5CupNIyS/uSkpKCOXPm4KmnnkJCQkL5Qp2uUpNH9V4XTAtLx5SIiIicx5L8llj5ZS5GjolGZJQ/YsryHb1JRET2JwGN6gbVtoNjx46p+z65/zPe+9WRakWya2at3nN9G8tlpUTkAmNqHDlyBKdPn8awYcOMywICAjBw4EBs2rRJBTWkNUZJSYlmHemqqnPnzmodCWps3rxZdTllCGiIvn37qmWyTlVBjblz56ofL3NpaWkoLCyEIwuaJJgjhU3e3g7tPczuuK/uh8fUPbnycb0v4WbEHeiiWXam5wtITU2ttO6pU6dUYEMepUtE4VV0FnFm66WdTYM+QO8Wx5SIiIicx2afOPyRVQQvvwTV9TIREdlHcXExTp48qR4dojQfKEjTLguMArxc636byCODGhLQENIyw5TMS6GSYR1/f39ERERUWsfwfnmMja0c0ZVlhnUsmTVrFqZPn65pqSEtQGJiYhAWFgZHFjTJ+COyHa5WeFhb3Ff3w2Pqnlz6uBZUHvgtJjoGCIqptFwK+X19fVVXh8brSi3e72rHNDc319GbQURE5NGe2bUIh6KHG+f/SZWWoP9o1ulddBqzMrepgWeV4ZUrZhARkfOy1CVV1O8vA9vu0y6cmOry95lEHhHUMJCCMlNSE9h8mTnzdSytX9PnSKsQmcxJgZ2jC+1ku51hOxoC99X98Ji6J5c9rha2V+1DFcsr7Wct3u9qarrWEhERkX1lFeci3ae8dWi5PPW3TWhzhDeOAHQlyC4+hzXBF2Bc/l88HETkFjKLMlGqK61YUJgBXy9/hOsd1GqivqSFhQQkqjC1MA1Y3alBN4nIHThtUCM+Pl49SmuKJk2aGJdLlyCG1huyjjQFy8jI0LTWkHX69+9vXOfMmTMWu5EybwVCRERERERE5KyCfYLwcNIstGvXrrxrkgbuZ56IyN6e3TIXyRnaQG1ieF/Mz9hYsWDcH0BgtDZw4Kykyyi2sCCyOaetStq6dWsVkFi/fr1xmQQwNmzYYAxY9OzZE35+fpp1pK/zffv2GdeRAcGly5Bt27YZ19m6dataZliHiIioJnJNmjZtmjHoTkRERNSQAiIC0Gd8b+ZFiMi9mbbSqIoENCRQYJhsPNYE7/2InJ9DW2pIf91///23ZnDwPXv2IDIyEi1btlSFR88//7yqhSKTPA8ODsb48ePV+jLY96RJkzBjxgzVx7m8b+bMmejSpQuGDBmi1unYsSNGjBiBO+64A2+88YZaduedd2LUqFFVDhJORERkTgbkvOiiizgwJxERETmEb6Av4jvEMy9CRORO934Wuqf67dQW5Gy8W7MsNP0AujXnmBpEThHU2LFjBy677DLjvGFg7ltuuQXLli3DQw89hIKCAtx7772qi6mkpCR8++23CA0NNb5nwYIFauDWcePGqXUHDx6s3uvj42Nc591338V9992HYcOGqfkxY8Zg0aJFDbqvRETk2uQ6tHbtWlxzzTUqkC4yi7JR6h2oWc+3KBvhbF5MRERE9dQ1KhHRZ342zhfkluLkmTBk9Mww5kWIiKhh7v0asnuqFSk/ITm8j2ZZ4sHP0K35APtuC5ELcWhQY9CgQWrA7uoGKZ09e7aaqhIYGIiFCxeqqSrSgmPlypX13l4iIvJc586dw4cffqiuXYaM7bO7FyM5ZoRmvcTdizH/spcdtJVERETkLia2uxrYfJdx/lAacM9PYTg37hyDGkREDXzvR0TOxWkHCiciIiIiIiIiIiLPMTrhclzy62eaZRF9ngVafuQaA4MTUYNgUIOIiDzWM7sW4VD0cM2ytrsW4YmL5zhsm4iIiIiIiDzVwCZ9gPxD2oUtB1fqoomIPBuDGkRE5LGyinOR7hOkWRZdnOuw7SEiIiKy1ku/vY0jUZdrlrX+7W082HcWE5GIiIjcGoMaREREVmjUqBF69+6tHomIiIgaWiN/oE/P7sa8yJmCszjmG6ZZJ7jgLA8MEZGL3/tN6XQzCr8YrFkW2P9Jh2wLkbNiUIOIiMgK8fHxmDp1KmJjY6vv77Xr7UxPIiIisrn4xsDUG25HTHw8U5eIqIHv/RpSq9DmQEmGdqEsIyIjBjWIiIisUFpaivT0dERGRsLf37/q/l5lGREREZGNlZYB6ecyENGk1JgXISKihrn3IyLn4u3oDSAiInKUrlGJuLjwhGaSZZakpKTggQceUI9EREREDS3lHDDtwSeYFyEisvfvLe/9iJweW2oQEZHHmtjuamDzXdqF7b501OYQERERGZ3OT0ORT6hx/oS3DsW6YuN8YuPWCE7drEmxFo21fbATERERuSO21CAiIiKXM3fuXDV4X2hoqOrrduzYsUhOTtaso9frMXv2bDRt2hRBQUEYNGgQ9u/fr1mnqKhI9ZcbHR2tBgIcM2YMjh8/rlknIyMDEyZMQOPGjdUkzzMzMxtkP4mIyHPN37sEU6IHG6fZEf2Rkn/K+PodHW/A05mbNZMso4bLa9x6663w8vLSTH379q11XoOIiIhqh0ENIiIicjkbNmzA5MmTsWXLFqxfv171ezts2DDk5eUZ15k3bx5eeeUVLFq0CNu3b1cD/g0dOhQ5OTnGdaZNm4Y1a9Zg1apV+OWXX5Cbm4tRo0ahrKzMuM748eOxZ88erFu3Tk3yXAIbRERE5Nl5DTFixAicOnXKOH311Vea163JaxBRha2pe/BNUIJmkmVERKbY/RQREZENbA2Ix4fB7YEtLwDeFZfXhLCWmNpjMtPYxiS4YGrp0qWqFuXOnTsxYMAA1Urj1VdfxWOPPYZrrrlGrfPOO+8gLi4O7733Hu666y5kZWVhyZIlWLFiBYYMGaLWWblyJVq0aIHvvvsOw4cPx4EDB9T/kgKNpKQktc5bb72Ffv36qdqaiYmWx2AhIiIi985rGAQEBKiKE5ZYk9cgIq0PD69DclgPzbLEw+uQlDCUSUVERgxqEBERWaFNmzbqplS6MrIk0zsAyf6RQNZhpqcDSKGBiIyMVI9HjhzB6dOnVY1K00KHgQMHYtOmTSqoIYUSJSUlmnXk+Hbu3FmtIwUNmzdvVl1OGQIaQrqVkGWyjqWghnQzIZNBdna2etTpdGpyZbL9EjBy9f2wBvfV/fCYuif3Pq56zVxwfDCufPIKtGrVqnx/dbpKXS8YljuSex6LynkNg59++kkFO8LDw1U+47nnnlPzwpq8hrvmI9z7u+l4nvTbZ1jWkPsqv7Nvv/02mjRp4pg0dtLfd1tx7/PX8XQunr7WbjeDGkRERFaQPpL9/PzUY+2uyKVMXzuTDNv06dNxySWXqEICIQENIS0zTMl8SkqKcR1/f39ERERUWsfwfnk0FEyYkmWGdSz1wT1nzpxKy9PS0lBYWAhXJhlMKdSRNPf2du9eTLmv7ofH1D2583EtKdHmIVQexEuvrieyr15FZ6G9ygFpZ9OgD7BUINhwTLt5dOe8hhg5ciSuv/56JCQkqAoVTzzxBC6//HIVzJDKFNbkNdw1H+HO301n4Em/fYZlqampDZq+0tWc4fe2oX2V8jFyw7prloXs+whXJFwLd+DO568z0Ll4+lqbj2BQg4iIyAonTpxQYzQ89NBDqssAch5TpkzB3r17VT/V5syDUJKxqykwZb6OpfWr+5xZs2apgg/TGpZyzsTExCAsLAyunkGW/ZZ9ccUMcm1wX90Pj6l7cufj+q92o5D9853G+bPnSvH5771RcmFJeV6koPJ1KCY6BgiKgSMFBgbCU/IaN9xQMTC7BDt69eqlAhxffvmlsftLSzwhH+HO301n4M7p6+fna3GZpYpG9nLs2DEsXrwYM2fOdMi93x8HDiE5qJVmWWL+IdzagGlgT+58/joDnYunr7X5iFoHNZ5++mn1pQ4ODtYsLygowEsvvYQnn3yyth9JRETk9KRmnIyh4Eo15JyRrfMRU6dOxeeff46NGzeiefPmxuWGvq2lFqQ0GzeQGl6G1huyTnFxMTIyMjQ1KGWd/v37G9c5c+ZMpf8rtbbMW4EYSM1MmcxJhtIVM5XmJIPsLvtSE+6r++ExdU/uelz7xfcACspbF4pDucA7KReoa5faVwv7W9XyhuTI42CP8oqq8hqWSJ5DghoHDx60Oq/hzvkId/1uOgv3TV9LAb/yfW0o8r2Vez/j760HpoG9ue/56xy8XDh9rd3mWu+ZNIPMzc2ttDw/P99iE0kiIiJndTr//9u7E/CmqvR/4N/uC3SjC7sFFAqyiYAgKotsMgIqjqg4gg4qyqIIyIi4gKIoIjA/Flf+IqAgOsMojqOAjqAisoNsFQQ67C2lpYXuTf7PeyBpbpK2aZs2uTffz/PcJjm5Sc69N70597xnSUNKQIRmkbTKiDblI7o4D2GmQvTIPY4F575Ty6R2I92ebz1zVzlCWjhKq8l//vOf+P7779G0aVPN8/JYKhLWrVtnTZOLkg0bNlgrETp27KiGFLNd5/Tp09i7d691HZkQXLrubtmyxbrOr7/+qtJKq4wgIiIiz3BnfUV5ZQ1n0tPTVQtvS4MKV8oaRKQl10+WayleUxGR23pqlNZNcvfu3Q4TZhEREXmz2XsWIzmutyYtac9izO71lmtvEBoLDL88tqtMI90l7xyw6lrtOuGeHQLC27irHDFmzBh88skn+OKLLxAREWEdl1om8A4LC1OfMX78eLz22mto3ry5WuS+tNwcNmyYdd2RI0di4sSJiI2NVZ8vrTvbtm2LPn36qHVatWqF2267DY8++ijeffddlfbYY49h4MCBTicJJyIiqimZ+Vko8tcO0RCYn4VoDw8/5UnurK8or6whwZNp06bh7rvvVkGMY8eO4bnnnkNcXBzuuusul8saRKRVT66fiu3G1Oc1FRFVNqghXSWlcCBLixYtNAWF4uJi9YP++OOPu/p2RERE+ufn7/Fxq/XC3eWIt99+W9327NlTk/7hhx/ioYceUvdl/hMZbmL06NFq2IcuXbpg7dq1qmLCYu7cuQgMDMTQoUPVur1798aSJUsQEBBgXefjjz/Gk08+iX79+qnHgwcPxoIFC6qwN4iIiKpuxs5FSI6/TZOWtHOR640zDKQ66ivKK2tIWeG3337D0qVLkZmZqQIbvXr1wqefflrhsgYRka2QgGA1AoB9GhFVIqgxb9481erhr3/9q+q2KS0OLIKDg9GkSRM1RAMREZERySRb8hsot1Rx7i5HyHuVRyo0pAWlLGVNQjZ//ny1lEZaVS5fvtzlvBEREVWH+NrAyBHDWBapofqK8soa0lvj22+/Lfd9XClrEJF38fS136udJwBL7SYFH/ChR/JCpPugxogRI9StjCMpYz/KuJBERES+IjIyUrXUk1uqOJYjiIiIqlgWCQN6du/GsgjLGURUzXjtR2TAOTV69OgBk8mE33//Hampqeq+re7du7szf0RERF4hKysLP/zwg5pfITo62tPZ0S2WI4iIiConKxf4YeMm9B/UiGURljOIqBrx2o/IgEGNzZs3qwk2U1JSHLpjyjAPMl4lERGRHtzT7DZkbnhUkxbdYbTTddPS0vD//t//Q8eOHVmRUAUsRxAREVVO2kVg8Vef4PquvVgWYTmDiKoRr/2IDBjUkMm1OnXqhH//+99qIizbCbiIiIj0pEvCdUBuijZR0qjasBxBRETkmg2ntyAj/Grr49OhhcgsyLI+HpR4K27++QvNa2LaPeLTu5flDCIiIt9Q4aDGoUOH8Pnnn+Oaa66pnhwRERGRYbEcQURE5Jo1Kd8jOaKt9fGli5eQVnDI+rhH/RuAnD+0L5I0H8ZyBpF+rUr+HFvObAVMRUiMuA7jsnd5OktEZKSgRpcuXXD48GEGNYiIiOwsPbQap6I6a9IaHFqN4e0e475iOYKIiIiqGesriPTrTM5ZJGf8ru4nhzfBJf8g63O8piKiKgc1xo0bh4kTJ+LMmTNo27YtgoJKTjKiXbt23MtERGQ4oaGhSEpKUrel2ZOejOTQhpq0pPTkGsidfrAcQUREVDn+wf6IbRJbZlnE17GcQWQcP9tcV9X0NZUr135EpLOgxt13361u//rXv1rTZF4NmTScE4UTEZFRNWzYEFOnTkVCQoKns6JrLEcQERFVTlhsGFr/tZsqkxDLGUR6MH/nQqRk/U+TNva60WgSlagZduqua+6AN+G1H5EBgxpHjx6tnpwQERF5MQneFxYWqluqPJYjiIiIKl8WKS4qZlmE5Qwi3ZCAhmVIKYu84lzNY5lH4+D5ZNQKqgVv4elrv1d2LMAfcf01aVfvWIAXbprukfwQGSKokZhYEk0lIiLyFUeOHMGYMWOwcOFCNG/e3NPZ0S2WI4iIiFzzfIfRKPqsjfXx0VQT/vZdZxxpfoRlEZYziPRLAgW5aSWPTUXYenYbvImnr/0uFFxEekCYJi2u4GKN54PIUEGNpUuXlvn88OHDq5IfIiIi3YoKro1Yu5ZHkkYlWI4gIiJyTXRIJGDKsz6+YAYC/St8Ce9TWM4g8n6rDq7Ei3tfLkmI6Q4E13FYz/a6itdURGSvwiWip556SvNYumPl5OQgODgY4eHhDGoQEZFubDi9BRnhV2vSYk5vQY9mt1fq/V64fiyw1KaALv60rCpZNByWI4iIiIjlDCLftTVtj+ZxiLkYYaZCTVrzwky8mvlzSQKvqYioqkGNjIwMh7RDhw7hiSeewDPPPFPRtyMiIvKYNSnfIzmirSYtKeX7Sgc1qHwsRxAREbnHr6m7kBmmHR46OnUXuiT29dldzHIGkfcLDQjRPNYEL4iIXOSWvqsyvtzrr7+Ov/zlLzh48KA73pKIiIh8BMsRREREFffZkW+QHNlBk5Z05BufDmo4w3IGkec8eO0DyC7I1qRFmIuBU596LE960C42CXFnf9SkNWg2wGP5IfJGbhuQMyAgAKdOnXLX2xEREXndBNdz587lRNfVhOUIIiLydfN3LkRK1v9KEkxFSKrdFo9e/E09TKwDzHvzFZZFKoHlDCLPaB/fzjHRdpJwi6H7gdC40t8oNBa+dO03vPldwC+jtInN/+2RvBAZJqjx5Zdfah6bzWacPn0aCxYswE033eTOvBEREXmNwMBAxMbGqluqPJYjiIiInJOARnLG75q08MDaJWWRACC2TgzLIixnEBmPBDTC4uEteO1H5P0qXDNz5513ah77+fkhPj4et956K9566y135g1FRUWYNm0aPv74Y5w5cwb169fHQw89hOeffx7+/v7WoMr06dPx3nvvqfEzu3TpgoULF6J169bW98nPz8ekSZOwYsUK5Obmonfv3li0aBEaNWrk1vwSEZFxye+Q/L6MGTMGDRo08HR2dKsmyxFERES6Yioq8+kzF4AFiz7A6KcmsyxSCpYziMgdeO1HZMCghslkQk1544038M477+Cjjz5SQYpt27bh4YcfRlRUFJ566im1zqxZszBnzhwsWbIELVq0wIwZM9C3b18kJycjIiJCrTN+/HisWbMGK1euVK1sJ06ciIEDB2L79u2qGyoREfmm5zuMRtFnbTRpgT33Ol330qVL2Lp1q7qlyqvJcgQREZHe7Qypa71/qQDYsn0XRrAsUiqWM4jIHXjtR+T9qjSGhvSSsLSyrA6//PIL7rjjDtx+++3qcZMmTVRvCwluWD5/3rx5mDp1KoYMGaLSJABSt25dfPLJJxg1ahQuXLiAxYsXY9myZejTp49aZ/ny5WjcuDHWr1+P/v37V0veiYjI+0WHRAKmPG2ipFGNqO5yBBERkZFNajcS+au7atJCbnnVY/nxNixnEBERGVelghpLly7Fm2++iUOHDqnH0kPimWeewYMPPujWzN18882qp8bvv/+uPmP37t346aefVCBDHD16VHUJ69evn/U1ISEh6NGjBzZt2qSCGtIbo7CwULOODBvSpk0btU5pQQ0ZskoWi6ysLGvLD0+2/pDPlsKZL7RA4bYaD4+pMen6uJpM8HdIMqn0sraz1G2twPt5M8u2VpeaKkcQERHpSd2wOOSk71L3jweW38iiXng8UJytTZQ0H8dyBhERkfFVOKghQz298MILGDt2rJoYXCo9fv75Zzz++OM4d+4cnn76abdl7m9/+5vqadGyZUs1TFRxcTFeffVV3H///ep5CWgI6ZlhSx6npKRY1wkODkZMTIzDOpbXOzNz5kw1V4e9tLQ05OXZteqt4Yom2Sey3y3zihgVt9V4eEyNSc/H1S//HLS/IEDauTSYQxwr9NPT09VcT3IrwyA689beN5ESf7l3oUXiL7Mwsc0z0OMxrQ41WY4gIiLSk2faPwLsfk6bOHQ/EPqeums6fATY8LxnMqcTLGcQeRmzCchL16blnfNUbojIl4Ma8+fPx9tvv43hw4db02SIKJnzQib1dmdlxKeffqqGipKhpOT9d+3apebHkJ4WI0aMsK5nP2yFVJCUN5RFeetMmTIFEyZM0PTUkCGrZDLTyMhIj1Y0WSZV1VvlYUVxW42Hx9SYdH1ccx1/B+Lj4oEwx1aOElyXoHrz5s3V/EzOmAPMyPUPckhLSEiA3o7pxYsXq+W9a7IcQUREpHuhcdZySZ0G/rhn6FDUqVPH07nyWixnEHkZCWgs1de1kJDz7D333MPzLZGRghqnT59Gt27dHNIlTZ5zJxmK4tlnn8V9992nHrdt21b1wJBeFBLUqFevnkqXHhf169e3vi41NdXae0PWKSgoQEZGhqa3hqzjbDtsh7GSxZ5U2Hm60k4qD70hHzWB22o8PKbGpNvj6iS/ahucpEsgY/Dgweq29O10Fiy/vG/0prrmuajJcgQREZGRyPXsoEGDHEYhoBIsZxB5l29P/Ij0Wi01abGmXPTPvTy6irfy9Pn2TE4a8gMiNGkhOWmo56TxHZGvqnAtyzXXXINVq1Y57VUhrVfdKScnx6EiSFrKWsYyb9q0qQparFu3zvq8BDA2bNhgrTDp2LEjgoKCNOtIQWfv3r1lBjWIiIhsXbp0CTt27FC3VHk1WY4gIiIyEpZFysdyBpF3WXfiZ6yo3VKzrAtNhLfz9Pl29p7FGBvXW7NIGhFVoaeGzDNx7733YuPGjWosbGnJKZN3f/fdd04rKapCoqIyh8ZVV12lhqXYuXOnGiPzr3/9q3pePluGo3rttddURYgscj88PBzDhg1T68i45yNHjsTEiRNV61rpQjZp0iTV66NPnz5uzS8RERmX9AqcN2+e+q2JiNC2miHvLEcQEREZCcsi5WM5g4h4viXyDRUOatx999349ddfMXfuXPzrX/9Sc1Nce+212LJlCzp06OD28TBlMtHRo0er4aJkLo1Ro0bhxRdftK4zefJk5ObmqnVkiKkuXbpg7dq1mgonyWtgYCCGDh2q1u3duzeWLFmien0QERG5yw0J7XDVme81afWa38kd7KFyBBEREfkWljOIdCC2PTDoc21aqPM5C8mGqRDITdPuMz/9DXNM5LGghmVIJ5nAu7pJYEJaxcpSGmnhKROLylKa0NBQFSCRhYiIyOL9A5/iePSNmh3S+MCnePT6sZXaSUOb/Qn46SFtoqSRR8oRRERE5HtYziDycv5BAOeGcNnjWbuxPaQusgrOayddH57K/Ug+rcJBja+//lr1cOjfv78m/dtvv1VzXQwYMMCd+SMiIqo2yReOIjmkriYt58JR7vFqxHIEERGReyw9tBqnojpr0hocWo3h7R7z2V3McgYRGU0gTJiSuQWrw6/xdFaIvEqF+yk9++yzKC4udkiX4SPkOSIiIiMKDg5WwyDKLVUeyxFERETuKYvsSU/Gz6ENNYuk+TKWM4i8y4xOT+PT1K80i6R5O2+79guCCUNzfvd0Noj03VPj0KFDauxrey1btsThw4fdlS8iIiKv0rhxY7z++utISLDp8ksVxnIEERGRc5M2v47kutq5uJI2v47Zvd5iWYTlDCJdCg0MAcxF2kRJ83K89iMyYE+NqKgoHDlyxCFdAhq1atVyV76IiIjIgFiOICIiIpYziIhKlxjdDElRl5foHu8DQ/dzdxFVNagxePBgjB8/Hn/88YcmoDFx4kT1HBERkV7UDYtD46IszSJpzkhA/7HHHnMa2CfXsRxBRERUOSyLsJxBRL5xvh3XYYzqpSdLl8S+QKjza1QiX1bhoMabb76pemTIcFNNmzZVS6tWrRAbG4vZs2dXTy6JiIiqwTPtH8Gi9O81i6Q5I3NH5eXlqVuqPJYjiIiIKse+LBIVXBuxxbmaRdJ8mTvLGTNnzkTnzp0RERGhhh+98847kZysnbNEjsW0adPU2PthYWHo2bMn9u3bp1knPz8f48aNQ1xcnMqbNPA4ceKEW7aXiKoHr/2IDDinhgwbsWnTJqxbtw67d+9WP9zt2rVD9+7dqyeHREREZBgsRxAREbnHC9ePBZa+rE380zKf3r3uLGds2LABY8aMUYGNoqIiTJ06Ff369cP+/futQ2/PmjULc+bMwZIlS9CiRQvMmDEDffv2VcEPCYYIGelizZo1WLlypQquyCgXAwcOxPbt2xEQEOD2fUBExrPh9BZkhF+tSYs5vQU9mt3usTwR6S6oIfz8/NSPuSxERER02bHsE8gLitHsjtDsE2gSFs9dxHIEERFRmbrX74yWp9Zq0hJa3su95qH6im+++Ubz+MMPP1Q9NiQYIUESack9b948FewYMmSIWuejjz5C3bp18cknn2DUqFG4cOECFi9ejGXLlqFPnz5qneXLl6tJiNevX4/+/fs7fK707JDFIisrS92aTCa16IXkVfaRnvKsJ7rZvyaTwxAxKs9enm/b/esN+3hNyndIjmirSUtK+Q63NBkAPdLN91enTDrfv67mu1JBDSIiInK0YN9yJNfpoUlL2rccsxM6cHcRERFRmQYn9gY23K9NlDTyChKgEHXq1FG3R48exZkzZzTBk5CQEPTo0UP1FpGghgRACgsLNevIUFVt2rRR6zgLasiwV9OnT3dIT0tLU8OP6alSSvaZVKz5+1d45HMyyP71yz+HunZpaefSYA7x7iF909PTVQ8tuZUeYJ5WWFjkNC01NRV6pJfvr16ZdL5/s7OzXVqPQQ0iIvIdZhOQl17yOO+cyy9t1KgRXn75ZXVLREREVNNYFvEcqRiaMGECbr75ZhWQEBLQENIzw5Y8TklJsa4THByMmJgYh3Usr7c3ZcoU9Vm2PTWkZ0d8fDwiIyOhp0o16TUj+dZjpZq3083+zfVzSIqPiwe8vCe7DB/32muvqeHrZBg7TwsKKqm+bVF4Hr8H1VFp0ntMj3Tz/dUpk873b2hoqEvrMahBREQ+Y/62uUg5+qU2MaY7ZmdsLPe10vKuSZMm6paIiIioprEs4jljx47Fnj178NNPPzk8JxVH9gEQ+zR7Za0jx9lZeVMqpvRWOSXbqMd864Ue9u/8/cuREqOd0yZx/3KM6zwR3kwCGU2bNlW33rF/S84Xky5sw/sR7ZCFZl6SN+N+f/XMT8f719U862/LiIiIKinl4ikkB9dxWFwhXf5lnGS5JSIiIqppLIt4xrhx4/Dll1/iv//9r6bHbr169dStfY8LGQ7G0ntD1ikoKEBGRkap6xD52vWXpHk7bz7fBplNmJK5BTcktPN0Vog8yqWghnR3dHUhIiIyIvmN++677/hbV8l9x3IEERERyyJ6KmdIbwrpofHPf/4T33//vWq1bUseS9Bi3bp11jQJYGzYsAHdunVTjzt27IigoCDNOqdPn8bevXut6xCR9/H2a78gmDC02Z88nQ0ij3Jp+Kno6GiXu08WFxe7K29ERES68mDzO5C9XjvBZ0Snp+HrWI4gIiIivZUzxowZg08++QRffPGFGl/f0iNDJg2WIWnk/caPH6/G3W/evLla5H54eDiGDRtmXXfkyJGYOHEiYmNj1STjkyZNQtu2bdGnT58qbjkREZHvcimoId0siYiIDGt4asn90NhKv0372FZAvl13aknzcSxHEBERkd7KGW+//ba67dmzpyb9ww8/xEMPPaTuT548Gbm5uRg9erQaYqpLly5Yu3atCoJYzJ07F4GBgRg6dKhat3fv3liyZAkCAgKqJd9EZDyJtRsAadvU/UCzydPZIdJPUKNHjx7VnxMiIqJq1r1+Z7Q8tVbd/6LWNSVPhMVz31ej6ipHbNy4EW+++Sa2b9+uhnJYvXo17rzzTuvzUuEgY+HaksqGzZs3Wx/n5+erFpMrVqywVjQsWrRIM2a2VFI8+eSTajxtMXjwYMyfP1+1DCUiIvKUqVvn4FD87Zq05lvn4NXuM+FLqqucIb07yiO9NaZNm6aW0oSGhqpygyxEvlwZX5J2s8fyo1fj2gwHdkzydDaI9BfUsPfjjz/i3XffxZEjR/DZZ5+hYcOGWLZsmRpT8uabeXIiIiLvNDixN7Dh8vBQj1zc69hLowwyfED//v3VLVWNu8oRly5dQvv27fHwww/j7rvvdrrObbfdplpUWgQHB2uel2Ej1qxZg5UrV6phIWR4iIEDB6pAiaUFpQwhceLECXzzzTfq8WOPPYYHH3xQvY6IiMhdDmYeQU5wgiYtPPMIWl5pfGFfFskvLkCuf5BmfUnzdayvIPLyyvhBn8Pb6eLaL++c9rGMOODn0tTJRL4Z1PjHP/6hLuQfeOAB7NixQ7VwFNnZ2Wr8yK+//ro68klERORRcXFx6rdPbqny3FmOGDBggFrKEhISoibxdObChQtYvHixCqhYxrVevnw5GjdujPXr16sLmQMHDqhghvTukF4e4v3338eNN96I5ORkJCUlVWDriYiISvfBwVVIjtFOHp10cBVm17/8+8OySPlYX0FE7uDt59v3a7fF8bUjNWmNmw/Do9eP9VieiLw+qDFjxgy88847GD58uGrVaNGtWze8/PLL7s4fERGRV8jLy8OhQ4cQGRmpJoCkyqnpcsQPP/yAhIQENVSUDE/x6quvqsdCemMUFhaiX79+1vUbNGiANm3aYNOmTSqo8csvv6gWWpaAhujatatKk3WcBTUkUGMJ1oisrCx1azKZ1KJnkn8ZjkPv2+EKbqvx8Jgak7GOq7Phjkq2LScnB7///jtq1659pSxS9vqe4snPZ30FEfnCtV9yUAySg+to0nIuHPVYfoh0EdSQVondu3d3SJd/9MzMTHfli4iIyKucPHkSr7zyChYuXIjmzZt7Oju6VZPlCOnFcc899yAxMRFHjx7FCy+8gFtvvVUFM6QHx5kzZ9RwVDExMZrX1a1bVz0n5NYSBLElaZZ17M2cORPTp093SE9LS1MXSHomFVXSw0UqEP39jd29ndtqPDymxmSk41pYWOQ0LTX18lCZMmzjSy+9pAL0zZo1K3d9T5Hel57C+goicgde+xEZMKhRv359HD58GE2aNNGk//TTT6pgRUREROQN5Yh7773Xel96X3Tq1EkFOP79739jyJAhpb5OKsZk4k8L2/ulrWNrypQpmDBhgqanhgxpFR8fr4I3eq88lO2WbdF75WF5uK3Gw2NqTEY6rkFBgU7TLMF1Cd4EBgaqOaAkrVuD63H1bz9q1q97zR1Og/E1SSbG9hTWVxAREfmGCgc1Ro0ahaeeegr/7//9P1V4PHXqlBqaYdKkSXjxxRerJ5dERERkCJ4sR0hFhwQ1pCu5kLk2CgoKkJGRoemtIS1cZTgsyzpnz5512utCenQ4I71AZLEnlW16r3ATctyMsi3l4bYaD4+pMRnnuDoLll/eNiG3ttt679W3Az8/rF1d0jy8Hzx5HFhfQUSGJJOAD7fphbfpFSD7uCdzRKS/oMbkyZNVC5FevXqpIRRkCAm5cJfKiLFjOSENERH5rm9P/Ij0Wi01abEnfkT/5qX3CvA1nixHpKen4/jx4yq4ITp27IigoCCsW7cOQ4cOVWmnT5/G3r17MWvWLPVYJgSX/G7ZsgU33HCDSvv1119VmiXwQURE5A6PtByKnG8Ga9LCuzzLnVsBrK8gIkPy8wfC4q0P69aqj5yMfZpV6oZ556TmRF4T1BAyhufUqVOxf/9+1d332muvVZOVERERGVVAQID6rZPb0qw78TOSa2uDGkknfmZQo5rKERcvXlRDWVnIvBm7du1CnTp11DJt2jTcfffdKohx7NgxPPfcc4iLi8Ndd92l1pfJvkeOHImJEyeqoTzkNRJcadu2Lfr06aPWadWqFW677TY8+uijePfdd1XaY489hoEDBzqdJJyIiKiyWkY3Awrs5sOQtAqURYj1FURUdd5+vn2m/SPA7ue0ib0XALlp2t4dEgwhMqgKf7sXL16sbsPDw9XY1NJqUf7Ri4qK1BjSRERE3upg5hHsCE7QLJLmCpkDYtGiRQ5zQZDnyhHbtm1Dhw4d1CJkHgu5L8NYyQXIb7/9hjvuuAMtWrTAiBEj1K0MdRUREWF9j7lz5+LOO+9UPTVuuukmla81a9ZoLmA+/vhjFejo16+fWtq1a4dly5bx0BMRUY1iWaR8rK8g8i55RfnI8QvULJLm7XR5vl11LbA0oWTJS/d0joi8q6eGtGb8+uuv8f7776sWjeLgwYMYNmyYGoph5syZ1ZFPIiKiKvvg4Cokx2iHDEo6uAqz63fh3q0h7ixH9OzZU03YXZpvv/3WpclM58+fr5bSSD6XL1/ucr6IiIjIM1hfQeRdnt82F8kJAzVpSdvmYnavtzyWJyLy0Z4aO3fuVBNmSotFGYN64cKFuP7669GmTRs15AMREZER/e9//1NDE8ktVR7LEURERCyLVBeWM4jIl6/9JsV0ty7z9y71dHaIvKunRtOmTbFx40Y8/fTTaoxpGZ5h6dKluO+++6onh0RERF6gsLAQqamp6pYqj+UIIiIilkWqC8sZROTL137JwZd7wisXT3kyK0TeOVH4V199hRUrVqBbt25ITk5WQ0h0794dDRo0cH8OiYiIdGJGp6dhWtFUk+bf+6jH8uOtWI4gIiIiljOIiCpJJgEfnlryOO/c5Tk1iHxIhYefGjVqlJpMc/LkyarHxp49exASEqKGo1q1alX15JKIiEgHQgNDEG4u0iySRiVYjiAiInKPY9kncDAoRrNImi9jOYOomplNQG5a2YusQ9XLzx8Ii7cuq05tQWHFq3iJfKunxs8//4xff/0V7du3V4/r1aunJvyUuTX++te/qoAHERGRN3qk5VDkfDNYkxbe5VmP5ccXsRxBRETkHgv2LUdynR6atKR9yzE7oYPP7mKWM4iqWV46sDSh7HWkB4FUtgPo2+gmXH/ya83Tsa0frM4c+qQtqXtwMPoGT2eDyLuDGtu3b1c9M+yNGTMGffr0cVe+iIiI3K5ldDOgwKabrpA0F9SvX19NFie3VHksRxARETn3Zcp3SK3dRpOWkPIdBre8PH8lyyIsZxDpTf9GtwDfH9QmSpqX0+P5dmtIPU9ngci7gxrOAhoWSUlJVc0PERGRVwoPD0e7du3ULVUeyxFERETObTy9Fcm1rtGkJZ3eag1qsCzCcgYR1Qyeb4kMEtS4/vrr8d133yEmJgYdOnSAn59fqevu2LHDnfkjIiLyCufPn8c///lPNcxiXFycp7OjKyxHEBERVR3LIixnEFHN0Nv5tnv9zmh5aq0mLaHlvR7LD5HXBDXuuOMOa8tKuV9WUIOIiMiIMjIy8K9//Qt9+/Z1qWA7P+I6pARGAptfB/xLfm4TI6/CuA5j4EtYjiAiIqr5soivYDmDiHz9fDs4sTew4X5toqQR+XpQ46WXXrLenzZtGmrSyZMn8be//Q3/+c9/kJubixYtWmDx4sXo2LGjet5sNmP69Ol477331EmnS5cuatLy1q1bW98jPz9fjYW3YsUK9R69e/fGokWL0KhRoxrdFiIi8h0S0EgOrgNcOAJf58lyBBERkVE92PwOZK/XVmJFdHoavoblDCIiIt/j7+qKOTk5ajLwhg0bIiEhAcOGDcO5c+eqNXMSpLjpppsQFBSkghr79+/HW2+9hejoaOs6s2bNwpw5c7BgwQJs3boV9erVU5HU7Oxs6zrjx4/H6tWrsXLlSvz000+4ePEiBg4ciOLi4mrNPxEREXmuHEFERGRk7WNb4eb8U5pF0nwRyxlE3kF6q0/a/Dombfjb5UXux3TH7mDv7+1ARAadKFxaPyxZsgQPPPAAQkNDVa+HJ554Ap999lm1Ze6NN95A48aN8eGHH1rTmjRpYr0vvTTmzZuHqVOnYsiQISrto48+Qt26dfHJJ59g1KhRuHDhgurZsWzZMvTp00ets3z5cvW+69evR//+/ast/0REROS5cgQREZGezO76LLA0QZvYP9VT2dEVljOIvKi3un1P9eA6yM4J9lSWiMjXgxoyQY4EB+677z71+C9/+YvqRSG9HQICAqolc19++aUKOtxzzz3YsGGDat05evRoPProo+r5o0eP4syZM+jXr5/1NTL3R48ePbBp0yYV1Ni+fTsKCws16zRo0ABt2rRR65QW1JAhq2SxyMrKUrcmk0ktniKfLcEcT+ahpnBbjYfH1Jh0dVxNJocuiirfLuQ9PDwcN954o7otdVudvL9oVpiJIPPl11wVHu/1+8pyTN3JE+UIIiIiI6lduza6deumbkmL5Qwi4vnWTl5a2bskNBbwc3kAHyL9BjWOHz+OW265xfr4hhtuQGBgIE6dOqV6PVSHI0eO4O2338aECRPw3HPPYcuWLXjyySdV4GL48OEqoCGkZ4YteZySkqLuyzrBwcGIiYlxWMfyemdmzpyp5uqwl5aWhry8PHiyokl6n0hlk7+/sU8+3Fbj4TE1Jj0d1++Or0Fu7TaatLD9X6J340HlvtbPz09VyMttaqrzVpN++edg+UVKLLocDBc35J/B0Jzf1f2zXRaW+npvO6bu5IlyBBERkZHINezjjz+uhnEkLZYziIjnWzurSuYadmp4KhAWzy8OGT+oIS0pJTigeXFgIIqKilCdlSqdOnXCa6+9ph536NAB+/btU4EOCWpYSAWTLalYs0+zV946U6ZMUcEU254aUukSHx+PyMhIeIrsE8m35MPbKw+rittqPDymxqSn47rzwAEk17pGk5Z08QDuTxhZ7msloC3BCJnXSYZPciq35HdlXPYup6vEx8V7feFRjqnMP+VOnihHEBERGUlBQQHOnj1bdlnER7GcQUTuxPMtkYGCGhIEeOihh1QvCdsKHmkpUqtWLU23T3epX78+rr32Wk1aq1at8I9//EPdl0nBhfS4kHUtpNLJ0ntD1pGTkUw6bttbQ9aRrrulke203VYLqbDzdKWdVB56Qz5qArfVeHhMjUk/x9VZMPty3stz8uRJTJ48GQsXLkTz5s2dr+TC+6jP8vr95NhgoKo8UY4gIiIyWm+EZ555puyyiI9iOYPIO4zN3oU8v8tDy66qlYStIfUQaipChLkAesLzLZGBghojRoxwSJPxsKuTjLWdnJysSfv999+RmJio7jdt2lQFLdatW6d6cQgJYMj8GzLJuOjYsSOCgoLUOkOHDlVpp0+fxt69ezFr1qxqzT8REfkYGZdUuvFa5J0DVmmD877KE+UIIiIi8g0sZxDVjA2ntyAj/Grr419D6sPfbEb3/BPWtGhTPrrkn8GLmZsvJwzdD4TGaa+ZyK0OZh5BTrB2aMJwcyFaFmZwT5NhuRzU+PDDD1HTnn76adWbQoafkoCEzKnx3nvvqcXSinT8+PHqeWmpIovcl0lchw0bptaJiorCyJEjMXHiRMTGxqJOnTqYNGkS2rZtiz59+tT4NhERkYHJRGtePrSUp3iiHEFERES+geUMopqxJuV7JEe0dUjfE1JyDZRUcF4FNawkoMFrpGr1wcFVSI7RjkYjx2F2xsbq/WAiPQQ1PKFz585YvXq1mt/i5ZdfVj0z5s2bhwceeMC6jgwFkpubi9GjR6shprp06YK1a9ciIiLCus7cuXPVuN0SGJF1e/fujSVLliAg4HKXOCIiIiIiIiI9+fbEj0iv1VKTFnviR/RvPsRjeSIiIu+QHFwHk2K6Wx8zwEFG49VBDTFw4EC1lEZ6a0ybNk0tpZFJ1ObPn68WIiLyXbO7Pgss1XbLRX+b4aKIiIiIdGLdiZ+RXFsb1Eg68TODGkREZA1sEBmV1wc1iIiIvMHVV1+NpUuXIiHBLihCRERE5AZv7v4AR2Nv1aQ13f0Bnuk6hWURIqIaxGs/Iu/n7+kMEBERGVVeUT5y/AI1i6QRERER2Tubew7HAyM1i6SRZ2zcuBGDBg1CgwYN1AgR//rXvzTPP/TQQyrddunatatmnfz8fIwbNw5xcXGoVasWBg8ejBMnSiZUJiJyC//y26yvCm/BnU2Gwp4aRERELjh58iRee+01PPfcc2jcuLFL++z5bXORnKAdQjFp21zM7vUW9zkRERFVe1mEKu/SpUto3749Hn74Ydx9991O17nttts0k5QHBwdrnh8/fjzWrFmDlStXIjY2FhMnTlTDa2/fvp1zfJIuPd9hNIo+a2N9fCagFkzwQ5SppOFWCIqhd3o73z7S9q/IKcyxPn7pl5cd1tkSUg9Dc36v4ZwRVR8GNYiIiFyQl5eHP/74Q90SERER1TSWRWrWgAED1FKWkJAQ1KtXz+lzFy5cwOLFi7Fs2TL06dNHpS1fvlxVkK5fvx79+/evlnwTVafokEjAVHI9FGdz30j0dr5tWSdJ8zgppgWSMxjAIGNjUIOIiIiIiIhIZ2Z0ehqmFU01af69j3osP77ohx9+UPOtRUdHo0ePHnj11Vet869Jb4zCwkL069fPur4MZdWmTRts2rSp1KCGDFkli0VWVpa6NZlMatELyavZbNZVnvXEY/vXZCpzHHsZ4uhMYLgmre4f/8Y91w6HXvevHr/DtzS8SQU2rIpyUXfvXM06ars8tG08P3D/lsXV/zkGNYiIiIiIiIg8LCmqKcJTf9GkNY7qXer6oYEhgLlImyhpVCOkF8c999yDxMREHD16FC+88AJuvfVWFcyQHhxnzpxRw1HFxMRoXle3bl31XGlmzpyJ6dOnO6SnpaXpptW4pVJKeqtIxbC/P6dzNcr+9cs/h7plPC9DHCUH19GkNTu1Az3iboOepKeno6ioSN1GRUVBb7rUvgGobXfccsdp1kk7lwZziLnmM8fzA/dvObKzs+EKBjWIiIiIiIiIPOzRVvcCW7WVTmj1haeyQ+W49957rfel90WnTp1UgOPf//43hgwZUurrpBJaJhUvzZQpUzBhwgRNTw0Zsio+Ph6RkZG6qnSX7ZR8M6hhoP2bW/p3tzRBQYHWHkx6IQGjwMBANReO3vLu6nGLj4sHwuI9kh2eH7h/yxIaGgpXMKhBRETkAinMjho1qkKF2r6NbsL1J7/WpMW2fpD7m4iIiGqkLEI1p379+iqocejQIfVY5tooKChARkaGprdGamoqunXrVur7SC8PWexJxbXeggNS6a7HfOuFR/ZvpT7rcj71RP5/H3/8cXWrt7w75WQb1HZ5cNt4fuD+LY2r/3MMahARkc94c/cHOBp7qyat6e4P8EzXKeW+NiIiAjfddJO6dVX/RrcA3x/UJkoaERERUQVVpixCNUeGqTl+/LgKboiOHTsiKCgI69atw9ChQ1Xa6dOnsXfvXsyaNYuHhoxj6D4g9EqL/82vAxeOaJ/311/Vo9HOt+VeB5tNQF562W8SGgv4GSDAQ4ahvzMLERFRJZ3NPYfjgdpu++G551zugrx+/XrcfvvtDmMjExEREVU3lkVq1sWLF3H48GHrY5k3Y9euXahTp45apk2bhrvvvlsFMY4dO4bnnnsOcXFxuOuuu9T6Mg7/yJEjMXHiRDWEjbxm0qRJaNu2Lfr06VPDW0NUjUJLhjEKCaqFsMAwzdMhAfqb68do59tyr4MloLG0nF6Aw1M9NlwVkTMMahAREbng3LlzWLp0Kbp06WKIgi0RERHpC8siNWvbtm3o1auX9bFlnosRI0bg7bffxm+//abKhpmZmSqwIet++umnmpbdc+fOVePyS0+N3Nxc9O7dG0uWLEFAQEANbw1RzXj15pcNsat5viXyfgxqEBERERERERHZ6Nmzp5rUuzTffvutS5Odzp8/Xy1ERvD+gU9xPPpG6+OdIXWBbx/DTQ1K0hrUboDh1/7FQzkkIl/BoAYRERERERERERGVKfnCUSRLIMPOz6d+sd5PimnBvUhE1Y5BDSIiMi67Cc+SatdDeGpJgVs0jurtgYwRERERVc38vUuREtNdk5a4dynGdZ7IXUtERFZJUU15HUyGw6AGEREZl92EZ486W6fVFy69VVhYGNq0aaNuiYiIiNwtMz8LRf6hmrTA/CxEX5mY1b4sknLxFJKD62jf5OIpHhgi8ojI4EjVSyOrIEv3R8Bo136PtroX2DrO5evgb8MSke6v3fbYEz+if/Mh1ZVFogpjUIOIiMgFDRo0wOTJk5GQUBIkISIiInKXGTsXITn+Nk1a0s5FmN3rLZZFiMjrBfkHYcoNk7H6sGuNxryZr1/7rQtNdAiaJ534mUEN8ioMahAREbnAZDIhJydH3fr7+7u0z3anH0B2SANNWkT6AbRvdLnFJREREVF1lkWIiNypblgcctJ3WR8fD4zUPB8UEIShSX/W/U7n+ZbI+7EkRERE5IKjR4/i8ccfV7euWnboC7wRfYNmkTQiIiKimiiLEBFVeE7C3LRSl2eS7sCi9O+tS1LBeUPuYJ843+adKzm2eWmezg1RhbGnBhER+dbY1IM3IjqySUlCaGzNZ4yIiIioihJrNwDSttml3cz9SkRum5Ow3PNQURYQ3wnwD0RUSBT3vJ6sutZ6d3dwnGaEAYf5moi8EIMaRETkW2NT719pHZuaiIiISK/GtRkO7JikTRz0uaeyQ0Q+aFz2LuCutUAYh9fVs2W1rmUgg3SHQQ0iIiIiIiIiDxuUeCtu/lk7TGVMu0c8lh8iIvJdjYuyMPv8Rutj/94GHoqLdIlBDSIiIiIiIiIP61H/BiDnD22ipBERVeccGjLklO08C2Roq8JbYEtIPU2as+Gmwk1FCDcXlSQEhtRE9ohcxonCiYiIXJCYmIgFCxaoW1eNbf0XvHl+g2aRNHKPjRs3YtCgQWjQoAH8/Pzwr3/9S/O82WzGtGnT1PNhYWHo2bMn9u3bp1knPz8f48aNQ1xcHGrVqoXBgwfjxIkTmnUyMjLw4IMPIioqSi1yPzMzk4eRiIi8vixCROTSHBqWxWaeBV9mtPNtpl8gzg1NVsstf/onCuu0VoEMy0KkR+ypQURE5MoPZmAgIiMj1a2rmkQ0AgoztImSRm5x6dIltG/fHg8//DDuvvtuh+dnzZqFOXPmYMmSJWjRogVmzJiBvn37Ijk5GREREWqd8ePHY82aNVi5ciViY2MxceJEDBw4ENu3b0dAQIBaZ9iwYSrQ8c0336jHjz32mApsyOuIiIi8uSxCREQ838749XUkZ/zOrwIZCktDRERkWO4cm/r06dP4+9//jqeeegoNGzZ0Uw6pKgYMGKAWZ6SXxrx58zB16lQMGTJEpX300UeoW7cuPvnkE4waNQoXLlzA4sWLsWzZMvTp00ets3z5cjRu3Bjr169H//79ceDAARXM2Lx5M7p06aLWef/993HjjTeq4EhSUhIPIhER1QiWRYjII4buA0LLmAg8NBZG4wvn2+HZ+xAEk7p/LDASYeYi9Mgr6bEeai72YO6IysegBhERGZY7x6bOycnBrl271C15v6NHj+LMmTPo16+fNS0kJAQ9evTApk2bVFBDemMUFhZq1pGhqtq0aaPWkaDGL7/8ooacsgQ0RNeuXVWarOMsqCFDWslikZWVpW5NJpNa9EzyLwEjvW+HK7itxsNjakyGOq4mk8P40Gq7rmzbxYsXsXPnTnVrSS9rfU8xxLEg8hHz9y5FSkx3h/Qb8s9gaM6Vlv0S0AiLx5d/rMHGEz9dfr5eZwxN+jOMyheu/Q4Ex2JK5hZrYINIbxjUICIiIsORgIaQnhm25HFKSop1neDgYMTExDisY3m93CYkJDi8v6RZ1rE3c+ZMTJ8+3SE9LS0NeXl50DOpqJIeLlKB6O9v7KnZuK3Gw2NqTEY6rn7556D91QLSzqXBHGJW99PT01FUVKRuJbhe3vqekp2d7dHPJyLXpVw85TCnQqBfAO7p8jx2+Aepx+E56WgZFo/UnDTrEEZyu+zAx+p+UkwLzO7xBne7F0uMvEqbYCpCVtp5rA6/piR4RaQzDGoQERGRYckE4rak0ss+zZ79Os7WL+t9pkyZggkTJmh6asiQVvHx8WosdL1XHsp2y7bovfKwPNxW4+ExNSZDHddcx9+V+LjLLaSFBG9kPg2ZA0qC63kXC5Djp72kj4iJRGhtx2B8TQoNDfXo5xNR1RSZizFj5yLrYwYt9G9chzHahNy0yxPDE+kYgxpERERkOPXq1VO30puifv361vTU1FRr7w1Zp6CgABkZGZreGrJOt27drOucPXvWaa8L+14gtsNcyWJPKtt0X+F2JchjlG0pD7fVeHhMjckwx9VJ/tU2XUmX+7bb+uL2vyM5YaBm/aTtf8fsXm/Bk3R/HIh8yCMthyLnm8HWx4V+/pif0BcXCtjjioi8G0sbRERELpBWkffff7+6Je/XtGlTFZBYt26dNU0CGBs2bLAGLDp27IigoCDNOjIp4N69e63ryITg0jJ2y5Yt1nV+/fVXlWZZh4iIyB1+Td2Fb8MSNYukWbAsQkTu1jK6Ga4vSFVL24Jz+DasCQMaPN9ifsR1mBTTXbPI/CtE3oQ9NYiIiFwQHR2NAQMGqFvyDjJR6uHDhzWTg8uEfnXq1MFVV12F8ePH47XXXkPz5s3VIvfDw8MxbNgwtb6MRz5y5EhMnDhRVRTJ6yZNmoS2bduiT58+ap1WrVrhtttuw6OPPop3331XpT322GMYOHCg00nCiYiIKuuzI98gObKDJi3pyDfokthX3WdZhIiqk8yvkOUXjKSoZoB/oMN8DAnh8WooqnLnazAAXz/fpgRGOsy1gounPJUdIqcY1CAiInKxAl1a6Pfq1cvleRFWHfkaZyKvU/fXhTW5nPjtY1jT/72SlUJjAT92nKyMbdu2qeNhYZnHYsSIEViyZAkmT56M3NxcjB49Wg0x1aVLF6xduxYRERHW18ydO1eNTz506FC1bu/evdVrAwICrOt8/PHHePLJJ9GvXz/1ePDgwViwYEGl8kxERFSTZREiIlfJhNFq0uhBn1vn8rE1+OpBavEFPN8SeT8GNYiIiFwg8yosXLgQ1157rcsVCVtS9yDZEsywZTsp2/BUpxcNVL6ePXuqCbtLI+OOT5s2TS1lTWY6f/58tZRGenAsX76ch4SIiLy/LGIqvDwBrAUbTxARVc/5log8ikENIiIyLBmHOjMsUZMWnbrLOowDERERkV71bXQTrj/5tSYtNmsnsNQmUM/GE0REVM518mfhLZDnH4gb8k+rxw5DTxF5IQY1iIjIZ8em9oQwaUFJREREVEX9G90CfH+Q+5GIiKp8nawZMvmKpILz1vuJtW/mXiavwqAGERERERERkYdNajcS+au7atJCbnnVY/khIiLfJQGN2RkbSxJkrhUiL6KrmUlnzpypxsceP368NU3G0paxshs0aICwsDA1vva+ffs0r8vPz8e4ceMQFxeHWrVqqQk+T5w44YEtICIivQoODsZVV12lbl2VGN0MSVE2S0RjNC/MrNZ8EhERkT7VC49HYnG2ZpG0qpRFiIio4ni+JfJ+uumpsXXrVrz33nto166dJn3WrFmYM2cOlixZghYtWmDGjBno27cvkpOTERERodaRIMiaNWuwcuVKxMbGYuLEiRg4cCC2b9+OgIAAD20RERHpSePGjdVvTEKCzSTf5RjXYYw2QSbutJ0knIiIiKiyZRGZBFzmzLDIOwesupb7k4hc9mXKd0it3UaTlpDyHQa3vM+n92Jlrv2IqGbpIqhx8eJFPPDAA3j//ffVScW2l8a8efMwdepUDBkyRKV99NFHqFu3Lj755BOMGjUKFy5cwOLFi7Fs2TL06dNHrbN8+XJ1glq/fj369+/v9DOld4csFllZWerWZDKpxVPks2W7PZmHmsJtNR4eU2Py7uNqdppWmby6ZTtNJocukur9vGzfWbaViIiIvJifPxBW0pNjd/oBZIc00KwSkX4A7RuVrENEZGvj6a1IrnWNJi3p9FafD2r4Ktv5H0PMxR7NC5EhghpjxozB7bffroIStkGNo0eP4syZM+jXr581LSQkBD169MCmTZtUUEN6YxQWFmrWkaGq2rRpo9YpLaghQ11Nnz7dIT0tLQ15eXnwZEWTBGqkssnfX1ejh1UYt9V4eEyNyZuP60MN70TEHwM1adnXfoXUVJtWjS6S35wXXngBr7zyCpo2bVqp/Pjln0Ndu7S0c2kwh5i98pgSERGR9zhy5IgaVnn+/Pm45hptJaRYdugLJEffoElLOvQF2jfqXoO5JCIy/vnWkHM4oRj1inM8liciwwU1ZMioHTt2qOGn7ElAQ0jPDFvyOCUlxbqOjIUXExPjsI7l9c5MmTIFEyZM0PTUkN4d8fHxiIyMhCcrmmReEcmHt1Ueuhu31Xh4TI3Jm49rQoQf/IuzNWmmhkmaVo2ukkp+2c46depUvhtyrp9DUnxcfKXyU93HVHpJEhERkfeQBiTFxcXsTUlExPNtlaj5muyuk4n0xquDGsePH8dTTz2FtWvXIjQ0tNT1pJLJvrBnn2avvHWkx4cs9qTCztOVdpJvb8hHTeC2Gg+PqTF57XF1kh+Vx0rkU15X5e10Y36qW3m/o0REREREROSDzCYgL73sdWTeJxkmkcgXgxoydJQMEdKxY0drmrRM2bhxIxYsWKAmAxfS46J+/frWdeQ1lt4b9erVQ0FBATIyMjS9NWSdbt261ej2EBGRb3tlxwL8Eacd9vDqHQvwwk2Owx0SEREREREReR0JaCwtZ/SC4aleNyIBGYtXBzV69+6N3377TZP28MMPo2XLlvjb3/6GZs2aqaDFunXr0KFDB/W8BDA2bNiAN954Qz2WgEhQUJBaZ+jQoSrt9OnT2Lt3L2bNmuWBrSIiIl91oeAi0gPCNGlxBRzmiYiIiIiIat7srs86Vk73r/j8g2QseQiAya7nvn9RPkofQ4eo5nl1UCMiIkJN6G2rVq1aiI2NtaaPHz8er732Gpo3b64WuR8eHo5hw4ap56OiojBy5EhMnDhRvU7GQp80aRLatm2rJh4nIiJyhcyrJL8xcktERETkbksPrcapqM6atAaHVmN4u8dcKouMbf0X5H3VW5MW2u1FHqhKkhEi3nzzTTWChDSMXL16Ne68807NkNbTp0/He++9p0aG6NKlCxYuXIjWrVtb18nPz1f1DytWrEBubq5quLlo0SI0atSIx4XIi/n6td/zMTchObiOJi1p21zM7vWWx/JEpKughismT56sCgejR4+2FiRkDg4JiFjMnTsXgYGBqqeGpSCxZMkSBAQEeDTvRESkH8HBweoCVG6JiIiI3G1PejKSQxtq0pLSk10uizSJaAQUZmgTJY0q5dKlS2jfvr0aLeLuu+92eF5GfpgzZ46qW2jRogVmzJiBvn37qmGyLfUR0ghzzZo1WLlypWpkKY0tBw4cqAIlrI8g8l6Gv/aT+S5keKjSbHoFyD5ekzkiMn5Q44cffnCYyHTatGlqKY1MMj5//ny1EBERVYbMxfTBBx/gkUceUUMfEhEREdUklkVq1oABA9TijPTSmDdvHqZOnYohQ4aotI8++kjN7fnJJ59g1KhRuHDhAhYvXoxly5ZZR4lYvny5avm9fv169O+vnWfNtneHLBZZWVnq1mQyqUUvJK+yn/SUZz1x2/41mWA/lbN6Tx8/bjJ3r/z/ysgvhr32C4lVN5/9/g9sPbtN3e9ctxPuaXE34O+sutjm++bke4MKfI94fqheJp2ff13Nt+6CGkRERJ6QnZ2thiG49957K12wbRebhLizP2rSGjRzfrFMRERE5O6yCLnH0aNHVaVnv379rGkhISHo0aMHNm3apIIa0hujsLBQs06DBg3UUNqyTmlBjZkzZ6phreylpaUhLy9PV5VSEtiRijV///KqP8lT+9cv/xzq2qWlnUuDOcTs0wfl2LFj+P7779VIL0b//naL7Io9Z36z3pcAemFhkcN6kibPiaWHPkBqTHeHddoVpGH4pQPlfo94fqheJp2ff6W84woGNYiIyGfHpq5pw5vfBfwySpvY/N8eyQsRERERVY4ENIT0zLAlj1NSUqzryNA1MTExDutYXu/MlClTMGHCBE1PDendER8fj8jISF1VqsnIGpJvPVaq+cz+zdVOBi3i4+KBsHj4MqkQlmHsZdi4hAS7idQNYNmBj3Hq4mnr4z2Zl4MaL+y5PApOet55h9cEBQVa90XqgfMOc26IOFOuS98jnh+ql0nn518ZcckVDGoQEZHPjk1NRERE5C2igmsjtjjXIY28l1Qa2ZJWsfZp9spbR3p8yGJPKqb0Vjkl26nHfPvU/nXyWvV+Pn7MZB8Y+fv727m9SM743SHdPphx/8WD1vuxrR+02Rdln+dc+R4Zef96Az8d719X88ygBhEREREREZGHvXD9WGDpy9rEPy3zVHaoDJbhv6THRf369a3pMjSLpfeGrFNQUICMjAxNbw1Zp1u3bty/ROTVkgrOY9ilkqAGGt3iyewQOWBQg4iIyAXR0dEYOHCguiUiIiKqaSyLeI+mTZuqoMW6devQoUMHlSYBjA0bNuCNN95Qjzt27IigoCC1ztChQ1Xa6dOnsXfvXsyaNcuj+ScfZjYBeeklj/POeTI3Xsvo59vEyKvKXsFUhMTTx1zqWVjo548sf8feZUTVjUENIiIiF8h4qnJBKrdERERENY1lkZp18eJFHD58WDM5+K5du1CnTh1cddVVGD9+PF577TU0b95cLXI/PDwcw4YNU+tHRUVh5MiRmDhxojp28rpJkyahbdu26NOnTw1vDdEVEtBYWjJHxJuRHXE09lbN7mm6+wM803WKT+8yo59vx3UYU/YKuWnA0jnaNJsA2AvX3gvsvdyzcFV4C2wJudx7rUHRxWrILZFzDGoQEZFhuXNs6tzcXBw4cAARERGoVauWm3JIRERE5J6yyKojX+NM5HWatHpHvsbQ1iO4iyth27Zt6NWrl/WxZfLuESNGYMmSJZg8ebI6JqNHj1ZDTHXp0gVr165Vx8di7ty5arJhqRyVdXv37q1eGxAQwGNCXuFsQC0cD9ROQB+ey94bvPZzYtW1Tr9DQ3N+VwtRTWNQg4iIDMudY1OfOnUKM2fOxMKFC1VrPCIiIqKaVF5ZZEvqHiSHNdGkJaXuwdDWNZhJA+nZs6ea1LusSVinTZumltKEhoZi/vz5aiEi/eC1H5H3098U6ERERERERERERERE5JPYU4OIiKiGnMlJQ35AyZAEIiQnDfXC4nkMiIiIiIjI8/xZVUglbOfMsJVYlIVx2bu4q8hjeKYiIiKqIbP3LEZyXG9NWtKexZjd6y0eAyIiIiIiqlFJhRkIr38zEBBsTWtcuxGPgq8LjQWGp6q7d5kKcXD7fGw9f9DTuSLSYFCDiIjIBTKhY0xMDCd2JCIiIq8si4QEBCPMVOiQRkRUmkcv/gZ0+g5gz/EKnW+Nbve5vcguyLY+vqVhN+xJ34t8P+fVyGcCwpEP7b7iiARU3RjUICIickGTJk3w97//HQkJCdxfRERE5HZTt87BofjbNWnNt87Bq91nulQWebXzBGCp3XMDPuSRIiKqIF+/9lu2/2MkZ/yuTSwloCFmR3ZCcnAdTRpHJKDqxqAGERERERERUU0zm4C8dOvD/MJLyPUP0qySX1zA40JERB4XYcrHlMytCEKxehxqvnxL5Cn+HvtkIiIiHTl27BieeuopdUtERERUZRLQkJ4VliV9N8siRERewNev/RIjr0JSTIuSJaoZGhRdwoGgOmhZmIFlta7F5JhbMDT+drXY99IgqgnsqUFEROSC4uJiZGRkqNvKuqfZbcjc8KgmLbrDaO5/IiIiwg35Z1C/+BJ+CGtcbWURIvJtmflZKPIP1aQF5mchmnNqaPj6+XZchzHahNw0zfCG+X4BDj0LHcgcT/I628nH/di2ntyHQQ0iIjKsQd8+BtS9U923TJxpOzZ1TeuScB2Qm6JNlDQiIiLyeUNzfsf/RbJcQETVN8zdgz9MAuJv06yStHMRZvd6i7ud3Et6H9rO8zQ8lRPSk1sxqEFERD7B0pKEY1MTEREREZFPDXNncaXBF1FVdc4/g1qmQk3vwrFZO633o035dt9Fm14bJtPlgBtRFTCoQUREhm2JRERERKQn9Vo9hqSMw9bHidHNPJofIjLeZM/Z/iGezgYZYLjEu3IO4+3Idta0pILz6G8/KoGtVa2td2UQKr/bfpNfverOKhkYgxpERGTYlkh9I6/DurAmbnnrBg0aYMqUKeqWiIiIqDoMTfozhpYytj3LIkRU4UZeeee055hLv2NxRFvuyHLwfFv+cIlEnsagBhERkQvCwsLQqlUrdUtERERU01gWIaLyzN82FylHv1T378n5HV3yz3Cn8XxbM2LbA4M+LxlqyqZnBlF1YFCDiIgMq15RjuoGayux9s2Veq/09HSsWrUK999/P+LjnbegJCIiIqou5ZVFXtmxAH/E9dekXb1jAV64aToPCpGRe2bklvTMSMlKQXJwHXU/M89xmKkYUx6SIhoDV+YbFBzmzhGv/Sp+vZ0YeTMnAqcaxaAGEREZulusQ9dYS+uRCsrMzMRXX32FAQMGuCWosSq8BbaE1AM2veJwUTGuw5gqvz8RERF5t2PZJ5AXFKNJC80+gSalDD9VXlnkQsFFpAdoe5TGFVx0c66JyKvIUFPLbeYliOkOXAlqONMj7yR6dHuBlc81fO2ne6GxwPBUh+ShVxbrOldsOLcfGd0/VvdXHfka2YWX1P1lqV8j2lxQM3kmw2NQg4iIjG3ofiA0ruSxTWHLk2RitYPBdbA1+7ins0JEREQesGDfciTX6aFJS9q3HLMTOvB4EFGlnA0I1zwuhD9Wh1/DORCoavz8KxQIW3PkayRnOM67USTvY+bBIPdgUIOIiIxNAhoVKIBVpw2ntyAj/Grr41YF6dgqvTWIiIiIiIiqKN8vwHq/CP6YGX0DsuI6Y2i3n7yukRcRUVUwqEFERFRD1qR8j+SIttzfRERERETk2pwZMsSUPZMJfvnngCA/TfIN+WewIayxuv9OZHt1myRD3XpJIy8iIndhUIOIiHx2bOqKiIiIQPfu3dWtOzUrzMSzF7YgSC5Y5Ie55163vj8REREZQ3llkXaxSYg7+6MmrUGzATWUOyKqFhLQWJrgkOwPoK6T1e+59Ls1qFGyMqv+vOXaj0r4ywTjuWmAv39JDyIZnorIRTyzERGRYVTn2NQJCQl45JFH1G1lySTgGqZCIP08fgxpVDLObUhkFXNKRERERlReWWR487uAX0ZpE5v/u2YyR0RkIO649vNliZFXaRNMRUDaNgReacgn4r/XXrericjZo4gqgEENIiIiFxQUFODEiROIjo5GaGhopfbZuA5jtAnSMsVJyytyj2nTpmH69OmatLp16+LMmTPqvtlsVs+/9957yMjIQJcuXbBw4UK0bt3aun5+fj4mTZqEFStWIDc3F71798aiRYvQqFEjHiYiIqqSB5vfgez192vSIjo9Xa1lESLS2XBTeeesd1+J7oILfiHWYaasjaJshKAYSVHNNL0zHCqYqVw831YNr3upJjCoQURE5ILjx4/jueeeU5XezZs35z7TCQlQrF+/3vo4IKBk8sRZs2Zhzpw5WLJkCVq0aIEZM2agb9++SE5OtnY1Hz9+PNasWYOVK1ciNjYWEydOxMCBA7F9+3bNexEREVVU+9hWQP4pbaKklYJlESLfHW5K/BEYjfSAMHU/ypyP14M6q/sNii5i+KUD6n694hzM7vosW7xXEc+31ev92m1xPLC2Jq3xgU/x6PVjq/mTyUgY1CAiIiLDCgwMRL169RzSpZfGvHnzMHXqVAwZMkSlffTRR6onxyeffIJRo0bhwoULWLx4MZYtW4Y+ffqodZYvX47GjRurQEn//v1rfHuIiIiIiLaE1LfuBNUzo+uGkp0icxMQebHkoBgkB9fRpOVcOOqx/JA+MahBREREhnXo0CE0aNAAISEhanip1157Dc2aNcPRo0fVMFT9+vWzrivr9OjRA5s2bVJBDemNUVhYqFlH3qtNmzZqndKCGjJklSwWWVlZ6tZkMqlFzyT/EhDS+3a4gttqPDymxqTr42oyqcl+tUkmlV7etjrd3gq+X3XR5bEg0jMZaopzEZA3k0CbzJlhsekVIPu4J3NEBsCgBhER+ezY1GRsEsRYunSpGlrq7Nmzanipbt26Yd++fdZ5NaRnhi15nJKSou7LOsHBwYiJiXFYx/J6Z2bOnOkwl4dIS0tDXl4e9EwqqqQHi1Sq+fvbV50ZC7fVeHhMjUnPx9Uv/xy0v0JA2rk0mEPMTtdPT09HUVGRuo2Kiqry+1WX7OzsGv08IiLycn7+2sCbzZwvRJXFbxEREfns2NQV4efnp+ZQkFvShwEDBljvt23bFjfeeCOuvvpqNcxU165dVbr98ZRKsfKOcXnrTJkyBRMmTND01JAhq+Lj4xEZGQm9Vx7Ktsu26K3ysKK4rcbDY2pMuj6uuY6/JfFx8aW2uJbfE5kgPC4uDgkJCVV+v+rCScyJ3GzofiA0DlfvWIC4govWCmHpURwUFMSJwKsBr/2IvB+DGkRERC6QIYs+/PBD55UIpAu1atVSwQ0ZkurOO+9UadLjon79kjGJU1NTrb03ZC6OgoICZGRkaHpryDrS46M0MoyVLPaksk13FW6lXOQZZVvKw201Hh5TY9LtcXWSX7UNpWzHNddcYy2LON3WCr5fddHdcSDydqFxKjj5wk3TNQFdKZOWej6gKuG1X/WqGxaHnPTd2rSQ2kBumnbIKunhQVQKr/52yPANnTt3RkREhDpRSwVEcnKyQ2vJadOmqTGuw8LC0LNnTzWshC0Z13rcuHGqRYtUaAwePBgnTpyo4a0hIiLSev/Ap3gx+kbNImlUPaQ8cODAARXEaNq0qQparFu3zvq8BDA2bNhgDVh07NhRtX6zXef06dPYu3dvmUENIiIiTziTk4aUgAjNImlERETeZGLbkViU/r1meea3l4GlCSVLXrqns0lezquDGlKxMGbMGGzevFlVKMj4oTJZ56VLl6zrzJo1C3PmzMGCBQuwdetWVUHRt29fzTie48ePx+rVq7Fy5Ur89NNPuHjxIgYOHIji4mIPbRkREenN8ePH8fzzz6tbd0m+cBQ7Q+pqFkkj95g0aZIqS8ik4L/++iv+/Oc/q6E7RowYoVr1SvlAJg6XMoIEKh566CGEh4dj2LBh6vUyXvnIkSMxceJEfPfdd9i5cyf+8pe/qN4effr04WEiIiKvKovM3rMYY+N6axZJIyL9mLp1DobG365ZJI30f+1HRD40/NQ333yjeWzpart9+3Z0795d9dKYN28epk6diiFDhqh1ZJxsGTbik08+wahRo9SkcYsXL8ayZcusFRDLly9XY1uvX78e/fv3L7U1pywWUgli6eIni6fIZ8t2ezIPNYXbajw8psbkVcfVZHKI1qt8uSFvMsGzTCAtt+7bVmcTd3p+X1qOqd5Jr8z7778f586dU2Otyzwa0lAiMTFRPT958mTk5uZi9OjRaogpmVh87dq1qoeoxdy5cxEYGIihQ4eqdXv37o0lS5ao+VWIiIiq4tsTPyK9VktNWuyJH9G/+eVrW3vSo/B///ufuiUiY8ovLkCuf5BDGtUsnm+9QN457WMOR0V6CmrYkwCFqFOnjrqVlpcyFrb03rCQMax79OiBTZs2qaCGBEBk8iTbdWSoqjZt2qh1SgtqyNBX06eXjFdokZaWpiq0PFnRJPtBKpuMPm4it9V4eEyNyZuOq1/+OVyeDaFE2rk0mEOqXkGfnp6uegzKrbTgd4fCwiKnaTI+rjccU72THpplkd4aMoSlLGVNdjp//ny1EBERudO6Ez8jubY2qJF04udSgxpERERGtyq8BbaE1APWPa5JT2w6GOM6T/RYvsj76CaoIZVlEyZMwM0336wCEkICGsIyoaeFPJbWtJZ1goODNRN8WtaxvN6ZKVOmqM+z7akhvTukpWdkZCQ8WdEklTCSD09XHlY3bqvx8Jgak1cd11w/h6T4uHg1sV5VSSW/tNiPjY1122ThQUGOP8NBAUBChJ9HW6TIMZWhGomIiIiodNIwwr4xpG1dg9RjyPPvvfeetVfowoUL0bp1a+5Wusxs0s4dYCrkniHjC43F2dt+U9fqqg5BemWsulY9dVfOYRwMroOtEtiwdfGUZ/JKXks3QY2xY8diz549ak4Me1KZZksKDvZp9spbR3p8yGJP/tk8XWkn+faGfNQEbqvx8Jgak6eO6/ydC5GS9b+SBFMRENMdN+SfwdCc31WSypMb8iXv4+7trBsWj5z03dq01E3wX25TgBue6pagTEWV9ztKRERERFABChna2sJ2iErLHKAydGWLFi0wY8YMNQdocnKyZrhL8mES0JBJkS1iugPBl0cnITIsP3+YQ+IuX+f6+2PS5teRXPdOT+eKdEYXQY1x48bhyy+/xMaNG9GoUSNrukwKLqQVRP369a3pMmyHpfeGrCNj4UmrCNveGrJOt27danQ7iIjIvSSgkZxxOXhhFVwHbQvP4ZMrY1SXNTZ1RcjvypgxYxx6B1bFM+0fAXY/57b3IyIiIuMqryxyT7PbkLnhUU1adIfRNZQ73yU9eS11E7ZcmQNUT/N76nrePW9mNyegNM66qvjyMbeoe80dDvuR+7d6ySgEMu+e3PI77H6O31/H4aL/lHMEQdKTyXJMku7hsaj0/tUXV/Pt1UENOQAS0Fi9ejV++OEHNG3aVPO8PJbCw7p169ChQweVJgGMDRs24I033lCPO3bsiKCgILWOTPIpTp8+jb1796pWE0REpGPSM8OJz2u1cPvY1LVr11ZDBsgtERERUU0rryzSJeE6IPfyMMxWkkbV6tChQ2reThnpQY7Pa6+9hmbNmrk0B6ie5vfU87x73sx+TkBLb3NbZyM6Ocy5x/1bvWT/JiUlIScnR1f/d3ph//0tLHZcJy0gHFMytyAIlyu4z4a38/jck3ph0vn5Nzs7W/9BDWmFIi0YvvjiC9U10zIupUzQGhYWpobGGD9+vCo0NG/eXC1yPzw8HMOGDbOuO3LkSEycOFGNgy6TjE+aNAlt27ZFnz59PLyFRERUFTM6PQ3TipKAdyH8MSu6M/YEu3+4pszMTPznP//BHXfcoX5LiIiIiNxZjhH+vY+6tywi45Tb8sBcXUYmQYylS5eqoaXOnj2rhpeSESH27dvn0hygeprfU9fz7nkzJ3MCujJHIPdv9Tp//jx++eUXDB48mNd+1cD++3t1natVg/SSFQqRlXYeq8OvsQb63DVXpi8w6fz8Gxoaqv+gxttvv61ue/bsqUn/8MMP8dBDD6n7kydPRm5uruoWZpl4a+3atZrxKefOnau6hEpPDVm3d+/eakxL27EuiYhIf0IDQwBzkTWgMTu6U7UENER6ejpWrFiBm2++2X0FW6lYkDkzLGwmSCMiIiLfKcdYSZo7yyL25QoPzdVlVAMGDLDel4aTN954I66++mo1zFTXrl0rNQeoN8/vWVG+NJ9ipTnbN0P3A6FxJauUEozk/q0+Ur+4cuVK3HLLLYiLKzkW5D62398nrx+jfTI3TTvXjBvnyvQVfjo+/7qaZ68OasiPvSsHadq0aWopK8Izf/58tRARkTFJK44sv2AkFZzXpCfWvhleSy5OWLFAREREZAi1atVSwQ0ZkurOO+8sdw5QIqckoMFrBCIi/QY1iIiIXCXdUlXXVLuWTao3hE5M2vw6kutevgC2SNr8Omb3estjeSIiIiJ92hDaEBn+2iEcYk5vQY9mt3ssT0YnE3wfOHBAte52ZQ5Q8gEy0XFeeqlPHzv3G/KCYjRpodkn0IRBDSKrg0ExyDm3DwiOupJiQripCC2jm5W9lzjkoqExqEFERMbClk1EREREWBN2NZKDtcNUJaV8z6CGG8l8nYMGDcJVV12lemDInBoyB8aIESNcmgOUfIAENOyG0bG1IKY7kuv00KQl7VuO2QmXA2FEBHxQuy2St/9d+39ScB6zMzaWvXs45KKhMahBRETkArkAve6669QtERERkdeVRezn6tr0CpB9vMby54tOnDiB+++/H+fOnVMTsso8Gps3b0ZiYqLLc4ASkffhtZ/+fBnWDBtDG2nSEvcuxbjOEz2WJ6peDGoQERG5QMZCnjBhAhISSm9pRUREROSxsoj9XF3+QTwY1UwmEq7qHKBE5H147ac/qQHhDr0TcfGUw3pvbpuDs5fOqvuJkVdhXAe7ScpJNxjUICIickFRUZEaTqBOnToIDg7mPiMiIqIaxbIIERHPt1QBpkIgN02TdDTjMI5fOs3daAAMahAREbkgJSUFY8eOxcKFC9WYyNWhe/3OaHlqrSYtoeW9PD5ERERUI2URIqo+8yOuQ0pgpCbNoWU5eQWeb/Xni1rXOCam73ac0yb2VsDyf2gqqpnMUbVgUIOIiHRr/t6lSInpbphxMwcn9gY23K9NlDQiIiIynOouxzzfYTSKPmujSQvsudct701EFScBjdKCGH/L3GK9H9Hpae5eIhuPXPwNOX7aIRXDzYUV2kerwlvgrpzD3K8GwqAGERHpVsrFUy6Nm0lERETka+WY6JBIwJSnTZQ0IvIqSQXncXO+zf9+bCtPZofI80JjgeGp1oct89KAVa2r9JZbQurhYHAdFMHfDRkkb8CgBhERERERERERERF5np8/EBZfoZes6fFquYGPrSH1qpgx8iYMahARERERERF5QOf8M0j3D8WRoGjufyIjMJuAvPSSx3nnnK7WrDATQbKuDDtXlFVTuSMyRM8Np0Jiyl5n0ytA9nG3Z408h0ENIiIiFzRt2hTvvPMOrrrqKu4vIiIiqnJl5w0x1+Cu3+dhSszNLr2cZREiHZD/cfuJia+wDV7ckH8GQ3N+r8GMUUXwfKvTnhtlrJMU0wLh57Zp0hrX7gbkpmmDJ/JZpAsMahARkW4l1m4ApGkLJom1XasYqCh/f3+Eh4er25pwMCgGH9RuC2x+HfAv+blOjLwK4zqMqZE8EBERUfVVdg718rIIEXy9l4Wz50VZlZ4y9n8pxmXvqkruqAbxfGs8j7a6F9g6Tpu44xdgx+SSx9LTo4LDXpHnMKhBRES6Na7NcGDHJG3ioM+r5bNOnTqFOXPmYMKECWjUqBGqW45f0OXJQy8cqfbPIiIiIu9X02URIp9TRi8Ll98CATD5aava/M1mhKK4JGHoPiC0jIpTaS1OHsXzLZH3Y1CDiIjIBbm5udi7d6+69ShTkWc/n4iIiNzKdkiasnqcek1ZhIhKdU/dQQ5pSQXnMTtjY0mCBDTYGtyr8XxL5P0Y1CAiIl2Yv3MhUjJLei3M6PQ0QouyPZonIiIioqrSDElTTT1OiciDYttr/7fZE4OIqMoY1CAiIl2QgEayzVBMphVNATN7LRAREZGODd0PhMZVS2Xn+wc+xfHoGzVpjQ98ikevH+u2zyDyFavCW2BLSL1yJ/kONJtQZD/nhn+Q054ZeUV5uOer+y+/zi8Q97S4W92PDYtF/yZ93b8RRL5Mfl9lzowrMrOOoejL7ur+qlotsDWkHgI3Poe/tB6OHo1u8WBGyVUMahAREXmhcHOh9X7rgnMYeunyhVN4l2c9mCsiIiKqrLyifMex9gMjEFpNw9AkXziK5JC6mrScC0er5bOIjO6unMNYVbsF8v0CcXvuEfwU0kClR3R5A+03Pmhd755Lv2NF7ZYuvafJMvE4gCJzEVYkf6ruJ8W0YFCDyN0k2Gjzeztj8+tIjr9Nu07uOWRkHwdy00oPjNgHLcljGNQgIiJdKoS/ajFVWispd4uLi8Pw4cPVbU20HpFLoTV554BV12rXiW5WfZ9PRERE1eb5bXORnDBQk5a0bS5m93rLe8oiRGR1LDASeX4B1sfXFqQjJTASc6I6WdOSTm1Be+4zw+H51odtexHY+IDz5+RanfPheA0GNYiISJdmRt+AIvjXWFAjKioKffr0Ubc11XqEiIiIqEbLIkRktSDiOiQH1yl7j/gHaoa0iT3xI5JO/KxZJZGNknSH51sql/S0yksvex327KhWDGoQEZEu7QuOQ1JEY8cJNatp4r3s7Gz8/PPPrEwgIiIij2BZhKh6KxVXHfkaZyKvsz4uN6Ch+GkaJfVvPkQtpG8831J55m+bi5SjX5a5TmLTwRjXeSJ3ZjVhUIOIiPSrlEn3qkNqaireffddtGvXji0kiYiIqMZVtCxSNywOOem7HNKIDEMCGksTyl5n6D4sPf4T9qQnq4eJtRtgXJvhTlfdcmY7ksOaOKQnRZU+/GtVemH4+/mr+TMc3jPyqkq/J7kHr/2MT84FSNvmkB5jyiv9RTI89BUpWSnlBz4vnqpSHqlsDGoQEZEuWl71rdse15/8WrNKbOuSSfmIiIiIqMQz7R8Bdj+n3SW9F2gnQOXQGGR0q1rjVFRnJIc2vPxYKjF3THK+bkx3wK6SUgIars57U1GhgaGY3eONanlvIirbuE5PA6UEOBVn81vaPnZyvqCaxaAGERHpouVVf2frNLqlJnNEREREVGl9G93k+QYa9hU0nPSUdGz+3qVIkYpFAJOytqFecU65rymvZXXn/DPYGRyPIpsJwonIgMqZz/LX1F3IDEvUpEWb8tEl/4y6364gDXGmXOtzP18JnMYWl6RFBdeuhoyTBYMaREREOrAqvAW2hNQDNr1yedgtmy7v4zqM8WjeiIiIqHz9pTHG9we1iWygQVRpKRdPWYMU+QhwWn6+K+ewy+93Q/4Ztf4D8QMY1CDycZ8d+QbJkR00adHFeeiS/426P/zSAWt6IfxRcCUQOiVzC4JguvzEn5bVZJZ9DoMaRERELggNDcXVV1+tbj1BLrAOBtfB1uzjHvl8IiIi8u2yCJHeSIMgKT/7wezS+kNzfq/2PJE+8HxLzuSX0oNrdfg1yPILtt7nuaRmMKhBRETkgoYNG+Kll15CQkI5kxG60Zcp3yG1dhvr43gXutQTERGRMXmiLELkTXPsOTAVah5Ka+nVXeZjaNI9lxM2v46tF45o1okNib487JrIS1NzbhDZ4/mW4B/otDeXMxLEcBrIsJlYvNx5rMo735X3eh/EoAYREXml3ekHkB3SQJMW0f0dtK/fVfujbmAbT29Fcq1rPJ0NIiIi0iMpJ1kqb2XOgU2vINmux2fS5terbRJkooqav3MhUjJLghCDGnRCjx+Glf4Cm4l6C/38MTP6BmRl/IGhlnHynVRKQlpaW563+x+xaL51DvKLC6xDvRIRiXsu/V61eayG7gNCHefxWHXka2w5sx1I361JTyzKwrjsXa7Ng2W2CYqYTPDLPwfk+gH+/oYNijCoQUREXmnZoS+QHH2DJi0p5Qe0bzbII/n5448/MGbMGCxcuBDNmzeHp8jkhZpxOvs7XogRERGRl1TQZv2vJMFUhAeD49C+wK7lZnWVRewnQbWZk4vI22TmZ2JtynpN2s0nvnD59XOiOuJ4YCSSbNISI69yWC8qJKrciYJf7T7T5c8lY/KWaz8y2PyY655QvT3se3XcBX8cjL4BW2WdyspLB5Ze7skpYYu6ztaxD6roPMjBoAYREZGXcmgZZipEVsF5jtNJRESkAxLQSM7QVlxkXxlzm0gXyhsORZ4XzirFLC2FzXFXqtjKfr+ivIwKZ08qB3vlHcc7ke1VQMPeuA5jKvyeRESlBUVDbnkVCC+lp4TdcHZTo2/CoaBoa0+yoivzcVxVnKVujwVGIs9mjo67Lh1GSmAEUgNqlX4A5DMq8xyAPATg+XVPaNISmw7GuM4ToVcMahAREXkphwux3DRr64tKjdNJRERENcdU5P17W+YkkPKFBcsRvs0+6FCFOScsLYVNf/4NCK9b/vv5hwLxtznMkSEtnEubdFfSvw1LrFT+iIjKUtWgqEwqnltGD8kFEdch+crweS6rwhxAJj8/x8+7eAp6xqAGERHpYuI/cnGczrLG2SQiIiKP+qxWC9yc70WVCDJ+t22DCZYjfNr8bXORcvRLbWJMdzxy8Te0LKx4T4o3Izvi7HfaisGk2m3x6MXfXHr90ojWSCo4rw1q2A+fcuJHYN+yksfO5tEgIqpu9nP0bHoFsJvHyhUTLmxD0JVecBHmy3P7WHpaSGDClr/ZjFAUq/uD6t5pTZfzptM5OQyGZ3siIh8ds3bG5plOu1haWiQ4jANtZ1Knp1GvlnvGfCxv4j8iIiIiIzhyZSgKT+hevzNanlqrSUsozvFYfsjLGhTJkGkXTzptOZzjd7m18ZdhzZAaEK7uf1HrGuvza87+y+n7HQ2KchgWKtxcwYZLse2BQZ+X2psounYjJMW0KHPIGCKiamc/R09gmPP1rvkL0GYtEvcuddpTIq35nRja7E8OPdvuqes4t2hSwXnMztjokO7sPL6qVsl5siq/E97Uo5NBDSIig3hz2xycvXS21CCFrSJTkcMYz66MA20rv7ik1UB1GJu9SzPGpAjt9iI8pXHjxnjzzTfVrbeQ1m9ysWir6e4P8EzXKR7LExEREXlnWWRwYm9gw/1uzxfpsxdG97wTGJx7RLvSNePKfI+NoY0qPlyKiwLNJmvrYluJkTeX2Qu5S/0b1EJk9Gs/0pfSAqz1IhPVOa1G5rKILQkKb/nxeSDHpieJC78TUifTpOjyHCCl9pbzYNCDQQ2iytBZ9NInVPSYlLP+/L1LkWJzwq9bqy6e6TSh9PVtejV0b3QzBja9vdTnbT3S9q9oWScJ7nD0wjEcr0T3Rk9ZdeRrnIm8TpNWryjH2r3c4cdTRDSCpwQHB6Nu3brq1lucDajl2Pot126ODSIiIqp+TsqWY68ZiLx1d2vSQvv+A4h7zyYhVtdlEdKPlIunNAGJloXnvWMemCsVZNKHabaz5yvwP0LkLjzfkqfn5HAW+C0qo44xqeC8Y9BZhuO7EhQOKGN+D7E7bQ/WnvxJM1qGfSNTxab3iMx5tCWknscmH2dQQ3djzJvgl38OyPUD/P0rXnnuSsVvee9Z0xX68nm5bvy88vJ/Zey6Mt/PlQnTbMejLeczF+z9CH9cOIWgoJKTzIybpiM0MNS1PJezD1SFemZJK5y+jW5C/0a3OH29nMiW7f/YoUA7tvVf0MRSoezKPrIXEqOOo8P3t7RtKGWbz+SkYfaexY6vNRUi8eyPTscL3BDaEGvCrr4cpbacyE2FeP6PdxFtM0ahrZSY7pofhJyiHO0kijYmbX4dyRdK9q+zIEVpvR5yCp13+f/yjzXYeOInh/TZPd5AdRh+7V9wIP0gsgpKAgn3tLgbmfkXrI+LTIV4Z8/7lf8Qu2O65cx2JIc10aziMGauFzl79izeffddjBo1CvXr19f1OJ1ERHpS3nCIZfVMfGXza7hg81tWWFioylulrV/aZ8pvIlsCU5nfSyk7p23DDflnShpoONtlcW0qPfdVlcsi9uWIvHOOc3ORb8vY53z41z6fAnGtXSt7XglSmEwmFG98Dsh3EjyxJS1+OR8ceRmvuPYjsnHPpd+xonbLSu+TgYm3Iv3XqZq02BZ3Weu5si+erPB7ngkM9+jk4z4V1Fi0aJHqPnb69Gm0bt0a8+bNwy232FXsVrfyKqfLqSyX6t669onldf2pwPu79J6uvEdF8lReACfzHPB5W/d9nqv7oKrkc1z8zHU2E/pYmHJTS8bgc/L6+RHXIcW2hXZseyRGJmJcm+HabBTlY23Kek3a9Se/Br4/6HQfyonMWeV73le9gTImh3MWoQ0xF+PVzJ8vPxj0A/zX9NR8f1+J7oILfiGabWgX3wbDm99V6j7LD4hAclxv55mwa7FukeEfevlEa1cAV1FuM1wjQy2VMv9Dsv3xK8pVPwyaAM6VIFFUcAQuFGSXe25ILW3op5yzpQaT7HtptIlpgQ5x1zoPxuRpj2VQcT6mtHsYq4+ts67fJbqpNdBUWFyImVtmoTxL9y/HnrSSif8SwxNKvpP2x9TZnBn2Y+Z6UUutixcvYtOmTXjggQe8Z5zOclpbkA+WI6rj84TlvOOscYU3qkDPvFK32Qx9bGsVqZ6JF0+isLAIQUFyaeCHxNr1Ma71g2U2cJHyxfPb/+7wlNOGE3Z2px/AskNfOKRrGlDYkIYZto0HnJLfWSe/d39kHEJ6fqaT9QtLbawgDSjsy06ZF08AuU1L/fgNp37Fmv99r/afrec7jEZ0iPPyicX7Bz5F8oWjmrS6YXF4pv0jJQmlNCiRhhXO5k0Y2LhXyWucOHg+GR/89v8q1YO0Mg0vnA2RKWPgP9puZIXm/hp09UD0KOf7VRn25RcRFRKFF7o+V5Jgdy5x+r0MroOrip30NPWWsoh9OYJ8qwxhp9DPX13D2TYokgnBLfNnyPjr+4Lj1P3wWvUvf3dKGyPeNlhm+Q02mdCodjNEhEZpzo2No3oDrWx+A9gTg7yQV1z7kW+zb4hw+Evgj6+068R3tNafaOfoMKuy/VVRzayrqvK5fT3gjyOAH6/cD2kARGuH8itEgMPvhDfxmaDGp59+ivHjx6vCxE033aQirgMGDMD+/ftx1VU1OJGUzcS4k6RCz44a17KctzgYFIMPattU8q97wloAaVlGpbNlYq+NTj7XYWIZJ5XJMna7DHWiXHmPpMIMPHpRewFg//pMv2DMiO7qsMqg3D/QI6/0SKBcsh0LqYc3w1tYP89iUtY21LOd1M5JfpfWaoU9wdpCe5Q5Hy9k/oryTI2+Cfl23axsW12V5lhgJBZEXKc5LuLBS/vRHhW04mrAXHr3XwloaCKiUqGdvhvYMUmznskvEEgYWP7nWfahkxNZZSO0YVJhYLGmp8Nr/giMRnqATcE4+zji0jYDv4yq0Gc/nrUb20PqIsuv+rriF2Udcf1kvv8dFG95EhvCrylZP6Y7OpsL0D9zs/b/oeDC5UoV+wr/2m0Am8n3rJaVMTG3XXAl6MyPGHpwFuBY74BA2VcJfypJ2PYigjb+gaFy/yfHYNfqI18jK+88kmx+FEMKL17Ou00l56kLRzXBGLk/zu47afs/9UdQFIps/9ekkp4X2+SFdFWOsB8fu7xyxBWulCO+knJEqGOls7MJ6sosR1xRajnCRqXKEVfOXb+m7sJnh9dc/n0sqxzhxHJPlyNsqHJEQdlDy30bloh1oYkO6TMyfkYoikt9nX3PRCVtG7DjmTI/T8oXyU7KF04bTtjJDmmAZCdljVIbUDgLgtuTPDtrfBDXH7Apa9yQfxpm+CEr7XypjRWkAQXsG1D8MgHITSn14zPCr0ZyhOP/VdFnbQBTXplZPx59I5JDtM2WctJ3AbttKtRL4dCwQnqMnloL/w33I6DXD0BkgNOgXM6l0857kF46DYSVva9LbXhRSpBIHM04jOPy3jbCZUiEUl5TlJfh9DNulvKu/WtsyiG/ntuDz458o3n6hoR2lyfcLIN9+UXEhkRrP8tJ4wwp2+0MjteWZXTkYOYR5ARr/w/CM4+gJctixixD2Pk6vJlDL2nbcsD1BakOIxCUOgl3Kd+ZR5uPREJCAvwN3DiAiKha2DVEiI24SjUIsZUo5+Qr69gO+SQ95VJTU9X5typmRndGg6JLpV7DrLMbeaOm+UxQY86cORg5ciQeeeRyiydpGfHtt9/i7bffxsyZjq2AaoKzCbacjmtpR1pOOHutpUVFWVIDnHQNcpFMRuswdrvZptK6FNIa3tln3pxfftemTP8Qp6/NR/kXDqcCazu8NrY4F644FBSNXLsW0K60upLx5pzlNzsnuMJj40nLmIcu7kdNtcrRs0CYMCVzC1aHOwkCVJJUPgXBhL1XWiedDqyteqK4ss9k/86MvkEFWSzry/vdlXMYv115P6v19wKWC4YaJMNuOR1z0d6Vi3cJdqiAh63f5zj2IIvqDIQ2dCkPsm8+r9VctxUB3iApqinCU3/RpKnWb+R2LEforBxx5dyVGZaI5MgODhXiRitHiHT/MKevNfn5ud4r0UvJb6jt/rNcQNk2npDeoa4IMpsw8cL2CpcZiqC/slP8fx0blFhJRXZMN8d0V8olpTW8KCVIpMTe6tij9tR/gaWvOV/fPxSIv80xfduLwEZtq1nbcoj1f/6KzlL++n0e8FPpvVZKLb/knC5zmyxluwfiB+i2LPPBwVVItvseJB1chdn1u3gsT0bkjWUIbxkjnoiIXNO/SV+11KRsfxlZ5RK8lU8ENQoKCrB9+3Y8++yzmvR+/fqp7mTO5Ofnq8XiwoXLY/FmZmaqiFel5V6A/5Xr4cIcxwv53JxiZJVzvXyx2ITCEMfXXsw1Icv59AAl7+9fjEI/x9eW95miIKcIhYHa1+bnF5X72mx/s9NtzZH8lvPaSzA5fKZ6z1wzssq5ds0LKkahbU8B2Ybi8vMrJL+Fdo1J8nJdODZFzrf1kmxrydfJwe3nDuDzWtqI60/FcRhSxuflhxShsMjueBQ4bl+On2OeVvg1RfPiDNyW63hhfslkQmGws++XGVll1D3lBRaj0K5yKtBUWOY+U9+pAO1r8vLK3s/ZAY7bI/s3N9ektsdZlVGOn8nhc9R75ZoRXMq/s7zX9qgozT52tn+FfX6+QGNIo9jmBRnW9eX9cp38/5pyCpzu18r8r95y7g8cD4ywPo4rvFDm+gkBGcgPvNwbKDgvB1llNyQt1z/Dr0Z2rsnh/66sPNj/r+UH5qnzrDfKyspSY7HLrbfk8Z76t8F/4zhNmqn70irnT37nsrMvD5NmNuu8NtQD5YhqK0MIliOsWI7QypHfDX9nvxtmFJmrXp6w56x8cfm4lF9eqmhZw7a8Ugg/nIm6fAkjwYkgm4hNlgtlDSlnlFVmKK2sMT/wWvW77qzsVNmyhkV+cJEa5lGT7yLXy6x6uJ6o6HVEZa8fbK8dGhVlY1DWfiSbw63Ph6AYdZ0EJytz3WAp29mXZWyvGUx3/gKE2DVoyQsAnA2J5oGySP6lPIf97I6ymORPsAzhXXURTo937VbIHOxkvkI3fGclr/JdkAmX2VPD/bh/fe/az0j4/fXA/s0tqY92xq84D03g2LAloXEvZN7i/Hei8L/jrfetjY1CTDVXjjD7gJMnT8peMP/888+a9FdffdXcokULp6956aWX1Gu4cB/wO8DvAL8D/A748nfg+PHjZl9X0XIEyxCe/95y4T7gd4DfAX4HPP8dYBmCdRGe/g5y4T7gd4DfAX4HYNhyhE/01LDwk+73NiTiY59mMWXKFEyYMEET5Tp//jxiY2NLfU1NkGhV48aNcfz4cURGlj3poN5xW42Hx9SYfOW4+sp22m6rjPXcoEEDT2dHd+UIby1DuIMv/h9wW42Dx9SYeFy9j/w+So9PliGMVRdRUb70v+kJ3L/cv3rG7y/3rzvKET4R1IiLi0NAQADOnDmjSZdJU+rW1U7KZxESEqIWW9HR0fAWUijwlYIBt9V4eEyNyVeOq69sp2jYsCGHC6hEOcLbyxDu4Ev/B9xW4+ExNSYeV+8SFRXl6Sx4BSPWRVSUL/1vegL3L/evnvH7y/1blXKE3awBxiRjiHXs2BHr1q3TpMvjbt2cTJBHRERExHIEERERsS6CiIjI6/hETw0h3TcffPBBdOrUCTfeeCPee+89/O9//8Pjjz/u6awRERGRl2M5goiIiFiGICIi8g4+E9S49957kZ6ejpdffhmnT59GmzZt8PXXXyMxMRF6It1QX3rpJYfuqEbEbTUeHlNj8pXj6ivb6Wvb6mvliKrype8Gt9V4eEyNiceVvJ2vliF86X/TE7h/uX/1jN9f7l938JPZwt3yTkRERERERERERERERNXIJ+bUICIiIiIiIiIiIiIi/WNQg4iIiIiIiIiIiIiIdIFBDSIiIiIiIiIiIiIi0gUGNYiIiIiIiIiIiIiISBcY1NCRV199Fd26dUN4eDiio6Mdnt+9ezfuv/9+NG7cGGFhYWjVqhX+/ve/w4jbKv73v/9h0KBBqFWrFuLi4vDkk0+ioKAAevf777/jjjvuUNsUGRmJm266Cf/9739hRP/+97/RpUsX9X2V7R0yZAiMLD8/H9dddx38/Pywa9cuGM2xY8cwcuRING3aVB3Tq6++Gi+99JIh/i/FokWL1LaFhoaiY8eO+PHHH2E0M2fOROfOnREREYGEhATceeedSE5O9nS2SEdljN9++w09evRQ6zRs2BAvv/wyzGazZp0NGzao/yH5X2rWrBneeecd6K184e3bWZUyhru2Xw/lDCNta3nlDCNsq6vlDCNsqy+XRch4jH6N4A1cKd+Q63iurT4bN25Uv9ENGjRQ5ZV//etf1fhpvmemj13PM6ihI/Kjf8899+CJJ55w+vz27dsRHx+P5cuXY9++fZg6dSqmTJmCBQsWwGjbWlxcjNtvvx2XLl3CTz/9hJUrV+If//gHJk6cCL2T7SoqKsL333+vjqlcnA4cOBBnzpyBkcjxevDBB/Hwww+ryrKff/4Zw4YNg5FNnjxZ/Xgb1cGDB2EymfDuu++qc9DcuXNVJd5zzz0Hvfv0008xfvx4dV7duXMnbrnlFgwYMEBVnBiJVMKOGTMGmzdvxrp169S5qF+/fupcS8bmjjJGVlYW+vbtq85zW7duxfz58zF79mzMmTPHus7Ro0fxpz/9Sf0Pyf+SnB+kwlF+E/RSvtDDdla2jOGu7ddDOcNI21peOcMo2+pKOcMo2+rLZREyHiNfI3iL8so35Dqea6uX/D63b99el/WUerDB167nzaQ7H374oTkqKsqldUePHm3u1auX2Wjb+vXXX5v9/f3NJ0+etKatWLHCHBISYr5w4YJZr9LS0qSJmHnjxo3WtKysLJW2fv16s1EUFhaaGzZsaP7ggw/MvkK+sy1btjTv27dPHc+dO3eafcGsWbPMTZs2NevdDTfcYH788cc1aXI8n332WbORpaamqu/rhg0bPJ0V0kEZY9GiReq1eXl51rSZM2eaGzRoYDaZTOrx5MmT1f+OrVGjRpm7du1q1kv5Qk/bWdEyhru2Xw/lDKNsqyvlDKNta1nlDCNvq6+WRciYjHKNoOdyHDnHc23NkfLK6tWr+VWsRqkGv55nTw2Du3DhAurUqQOj+eWXX9CmTRtNa7T+/furbvfS8lCvYmNj1ZAeS5cuVZFUiapKi5a6deuqLuZGsWPHDpw8eRL+/v7o0KED6tevr1qaScsdIzp79iweffRRLFu2THUJ9iVGOAdJyyc5r0gLB1vyeNOmTTD68RN6P4ZUM//f8tssw7mEhIRofptPnTqlhp6wrGP/vyTrbNu2DYWFhbooX+h1O10pY7hr+/VQzjDKtrpSzjDStrpyHjLitvpyWYSMyQjXCGQ8PNeS0Vww+PU8gxoGJgX2VatWYdSoUTAaGSZBLsJtxcTEIDg4WNfDNMmYgtJFTLqUyxh4Ml6udM/95ptvDDU25pEjR9TttGnT8Pzzz+Orr75Sx08uMM+fPw8jkQYIDz30EB5//HF06tQJvuSPP/5QQzrItuvZuXPn1HAW9ucceazn840r390JEybg5ptvVhVEROWVMZz9NlseW/5XSltHKtjlf00P5Qu9bqcrZQx3bb8eyhlG2VZXyhlG2VZXyhlG3VZfLYuQMRnlGoGMh+daMhKzD1zPM6jhYXKxJReZZS3Sqq+ipCWaTAT54osvqjFjjbitsr6zf1pn6XrZdsn/6NGj1YQ+MvHfli1b1HGU8a5Pnz4Nb+fqdsqYqkLGBL777rtVC9EPP/xQPf/ZZ59BD1zdVimwy9jNMva8XlXmf1daO952221qbNdHHnkERmB/bvHW8427jB07Fnv27MGKFSs8nRXSURnD2f+Jfbor63h7+cIT21lTZQx3bb8eyhlG2FZXyxlG2FZXyxnevK1V5WtlEfJuvEbwvv1L7sFzLRnBWB+4ng/0dAZ8nXzJ7rvvvjLXadKkSYXec//+/bj11ltVN3RpnWbEba1Xrx5+/fVXTVpGRoYa0sG+BZOetl0m7pTWhLItkZGRKn3RokWqZeVHH32EZ599Ft7M1e3Mzs5W96+99lprugwB0KxZM91Mdujqts6YMUNN0mQ7xIGQ1pQPPPCAOq7erqL/u1LR0KtXL9x444147733oHdxcXEICAhwaAmZmprqlecbdxg3bhy+/PJLbNy4EY0aNfJ0dkgnZQz5bXb2fyIs/yulrRMYGKiGR9JD+cJT21kad5Yx3LX9eihnGGVbXSlnGGVbXSlnePu2VpYvlkXI+/n6NYIey3FUNp5rySjG+cj1PIMaXnDSlMVdpPWkVDaMGDECr776Koy6rVIQku2TloUyTrJYu3atuqDzxrknXN32nJwcdStjQNuSx5ZWh97M1e2UYyTHKjk5WXWFE3KxKeMYJyYmQg9c3db/+7//UxUOtoV5Gbf5008/RZcuXaAHFfnflTHM5WLF0irW/rusRzJkhWyPVPzddddd1nR5LK2cjURafEoBaPXq1fjhhx/QtGlTT2eJdFTGkN/m5557To1HLP83lt9mGdvectEt66xZs0bzOllHKmCDgoJ0Ub7w1HbWRBnDXduvh3KGUbbVlXKGUbbVlXKGt29rZflSWYT0w9evEfRWjqPy8VxLemf2tet5T89UTq5LSUkx79y50zx9+nRz7dq11X1ZsrOz1fN79+41x8fHmx944AHz6dOnrYvMdm+0bS0qKjK3adPG3Lt3b/OOHTvM69evNzdq1Mg8duxYs56lpaWZY2NjzUOGDDHv2rXLnJycbJ40aZI5KChIPTaSp556ytywYUPzt99+az548KB55MiR5oSEBPP58+fNRnb06FEZ30B9n43m5MmT5muuucZ86623mk+cOKE5D+ndypUr1f/h4sWLzfv37zePHz/eXKtWLfOxY8fMRvLEE0+Yo6KizD/88IPm+OXk5Hg6a6SDMkZmZqa5bt265vvvv9/822+/mf/5z3+aIyMjzbNnz7auc+TIEXN4eLj56aefVv9L8j8l/1uff/65bsoXetjOypYx3LX9eihnGGlbyytnGGVbXSlnGGVbfbksQsZj5GsEb1Fe+YZcx3Nt9ZLvpOX7KeWVOXPmqPvyHaaqe8LHrucZ1NCRESNGqH96++W///2vev6ll15y+nxiYqLZaNsq5KR3++23m8PCwsx16tRRFyt5eXlmvdu6dau5X79+apsiIiLMXbt2NX/99ddmoykoKDBPnDhRVTDIdvbp00dVmhmdkYMaH374odP/W6PEzxcuXKjOp8HBwebrr7/evGHDBrPRlHb85NiSsbmrjLFnzx7zLbfcYg4JCTHXq1fPPG3aNLPJZNKsI4XsDh06qP+lJk2amN9++22v2U5Xyxfevp1VKWO4a/v1UM4wyra6Us4wwra6Ws4wwrb6clmEjMfo1wjewJXyDbmO59rqI99JZ99V+Q5T1cHHruf95I+ne4sQERERERERERERERGVhwMZEhERERERERERERGRLjCoQUREREREREREREREusCgBhERERERERERERER6QKDGkREREREREREREREpAsMahARERERERERERERkS4wqEFERERERERERERERLrAoAYREREREREREREREekCgxpERERERERERERERKQLDGoQ6VTPnj0xfvz4Gvu8JUuWIDo6usY+j4iIiKoPyxFERETEMgQR6RWDGkRe7KGHHoKfn5/DcvjwYfzzn//EK6+8Yl23SZMmmDdvnlcHItLT03HbbbehQYMGCAkJQePGjTF27FhkZWVVy+f98MMPTvef7SL7yJsMHjwYV111FUJDQ1G/fn08+OCDOHXqlKezRUREOmS0coR9maJRo0ZqezIzM6vlM/RYjrDIz8/Hddddp/K4a9cuT2eHiIh0xohlCGfb884771TLZ+mxDCHH0T6Pzz77rKezRVSqwNKfIiJvIEGADz/8UJMWHx+PgIAA6I2/vz/uuOMOzJgxQ22DFIjGjBmD8+fP45NPPnH753Xr1g2nT5+2Pn7qqadUAMV2f0ZFRVnvFxcXqx9uyaen9OrVC88995wKaJw8eRKTJk3Cn//8Z2zatMljeSIiIv0yUjnC1siRI9GuXTv1W1ld9FiOsJg8ebJqRLJ7925PZ4WIiHTKiGUI2R7ZLme/4+6k1zLEyy+/jEcffdT6uHbt2h7ND1FZPF/iJqIySY+GevXqaRYpRNgOGyH3U1JS8PTTT1sj6tIy4OGHH8aFCxesadOmTVPrFxQUqIvdhg0bolatWujSpYta35a0GpAeA+Hh4bjrrrtUi8iyHDt2TH3GypUr1Q+49DRo3bq15n1jYmLwxBNPoFOnTkhMTETv3r0xevRo/Pjjj9XyLQgODtbst7CwMM3+/Oabb1Tw4KuvvsK1116rnpP96GxIjjvvvFO1VrFwZR/ak/3z9ttvY8CAASovTZs2xWeffaZZR45h165d1f6R/SgtIzZv3ozCwkI37x0iIvIFRipHWMhvqfTOkMB/ddJjOUL85z//wdq1azF79mw37g0iIvI1RixDSO8R+9/26qDXMkRERIQm3wxqkDdjUIPIAKT7pwzBIFF1aQ0gi/yYSxfQyMhIa5rl4l8KGD///LP60d+zZw/uuece1Vrh0KFD6vlff/0Vf/3rX1XAQYYskN4D0rvCFc888wwmTpyInTt3qjzIcEqlFUJkWCXJe48ePeApOTk5mDlzJj744APs27cPCQkJLr2uvH1YmhdeeAF33323ajn5l7/8Bffffz8OHDjgdF3pwfLxxx+r/RgUFFSp7SMiIjJSOWL//v0qn0uXLvV4a0ZvLEecPXtWtbBctmyZqgwiIiKqTnoqQwgZ/jouLg6dO3dWQ0+ZTCZ4ireVIcQbb7yB2NhYNYTlq6++qgIoRF7LTERea8SIEeaAgABzrVq1rMuf//xn9VyPHj3MTz31lHXdxMRE89y5czWv//DDD81RUVGatMOHD5v9/PzMJ0+e1KT37t3bPGXKFHX//vvvN992222a5++9916H97J19OhRs5xSXn/9dWtaYWGhuVGjRuY33nhDs+59991nDgsLU+sPGjTInJuba66p/XnHHXdo9o/kYdeuXZr17PetkNfJ613dh87IZz3++OOatC5dupifeOIJTdrkyZPN4eHhav2uXbuaz507V4mtJSIiX2e0ckReXp65Xbt25mXLlqnH//3vf9VrMjIyzDXB28sRJpNJ7fdXXnlFs0937txZ6W0mIiLfZLQyhJDfx02bNqnfxdmzZ6trbstvpq+XIcScOXPMP/zwg3n37t3m999/3xwXF2ceOXJkJbeYqPpxTg0iLyctE6SboIV0L6yKHTt2SDATLVq0cJhQUiLyQqL10s3T1o033qi6SJZH1rMIDAxUQ03ZR//nzp2Ll156CcnJyWr+iAkTJmDRokWlvqd0wdywYUOpz8s+uXjxIirbLVTG5Hb3PnRl/1ge20/gKS1MZKxw6X46ffp0DB8+XHVLlS6jREREvlqOmDJlClq1aqVaF1aEr5Qj5s+fr8brlv1ERERUVUYqQ4jnn3/eel96IgjpYWKb7qtlCCFDiFlIvmT4cJnf09J7g8jbMKhB5OXkR/Kaa65x2/tJ90oZB3P79u0OE3xZxku8HMh3H/vKeMv4jC1btlQ/jrfccovqCiljSjojQ0xI18zSVGX4CRlP0j5/8n72+8B2TgtX9mFF2H++dIeVRQoqUnnTuHFjNa+GfSGEiIjIl8oR33//PX777Td8/vnnms+R38ypU6eqhgC+XI6Q/SPlBRmX25ZU6jzwwAP46KOPKvzeRETku4xUhnBG5rKUxgAydGPdunV9ugxR2v4Rhw8fZlCDvBKDGkQGIVH+4uLictM6dOig0lJTU1UwwRmZqEouim3ZPy6NrNe9e3d1v6ioSP3YyriVpbH8YEvLgtLIJGE1KT4+Xo37aSH7a+/evaqliqv7sKz9Iz0vbB/L+1Vl/xAREflCOeIf//gHcnNzretu3bpVjbv9448/4uqrr4avlyP+7//+TzPuuMxd1r9/f3z66adqElEiIiJfLUM4I3NvyKTiMnm4r5chSts/orTGp0SexqAGkUE0adIEGzduxH333ada6EmrRUmTrpDfffcd2rdvryaMlNb/0lpPfszeeust9SN27tw51bqvbdu2+NOf/oQnn3xSTaw1a9Ys3HnnnVi7dq1L3T3FwoUL0bx5c9XDQIaZysjIUBUO4uuvv1atIGRSLmlFIJN9Tp48GTfddJPKq7e49dZb1ZBY//73v1UliWxHZmam9XlX9mFpPvvsM9Vi8uabb1aTgG/ZsgWLFy9Wz8l9WeQ56ep55MgRvPjiiyoP7KVBRES+Xo6wD1zI5wpZt6wKCV8pR9hXvFhabEoeZBJXIiIiXy1DrFmzBmfOnFHX1dJD4r///a/q5fnYY4859HD0xTLEL7/8ooIcEjyJiopSDUdkOCqZbL2mAztELquBeTuIyE2TSZU1gdQvv/yiJs8MCQlRk0BZyGRQsbGxKu2ll15SaQUFBeYXX3zR3KRJE3NQUJC5Xr165rvuusu8Z88e6+sWL16sJtaSCb1lMm+ZSMuVybk++eQTNeFUcHCwuVWrVubvvvvOus73339vvvHGG9X7hIaGmps3b27+29/+5tEJPp1tk+wfmTCrTp065oSEBPPMmTM1k3O5ug/tyf5ZuHChuW/fvuo4yYRqK1assD4vr+3Vq5f6XHle3luO34kTJ9y6H4iIyDcYrRxhzxsmCvemcoQ9ThRORESVZbQyxH/+8x/zddddZ65du7aaILxNmzbmefPmqQnFa4K3lyG2b9+u9p2lriYpKUkds0uXLrl1PxC5k5/8cT0EQkTk3LFjx9C0aVPVRdEy6RY5jle5evVq1eKEiIiIWI6oCJYjiIiIWBdRGSxDkBFVfkYbIiIiIiIiIiIiIiKiGsSgBhERERERERERERER6QKHnyIiIiIiIiIiIiIiIl1gTw0iIiIiIiIiIiIiItIFBjWIiIiIiIiIiIiIiEgXGNQgIiIiIiIiIiIiIiJdYFCDiIiIiIiIiIiIiIh0gUENIiIiIiIiIiIiIiLSBQY1iIiIiIiIiIiIiIhIFxjUICIiIiIiIiIiIiIiXWBQg4iIiIiIiIiIiIiIoAf/HwMM3LMTfcmfAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -383,7 +382,7 @@ { "data": { "image/png": - "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", + "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", "text/plain": [ "
" ] @@ -503,7 +502,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.11.15" } }, "nbformat": 4, diff --git a/include/aare/Chi2.hpp b/src/Chi2.hpp similarity index 84% rename from include/aare/Chi2.hpp rename to src/Chi2.hpp index b07fdbb..2aeb0b9 100644 --- a/include/aare/Chi2.hpp +++ b/src/Chi2.hpp @@ -135,20 +135,6 @@ class Chi2Model1DGrad : public ROOT::Minuit2::FCNGradientBase { bool weighted_; }; -// ── Convenient aliases ────────────────────────────────────────────── - -using Chi2Gaussian = Chi2Model1DGrad; -using Chi2GaussianErfcPlateau = - Chi2Model1DGrad; -using Chi2GaussianChargeSharing = - Chi2Model1DGrad; -using Chi2GaussianChargeSharingKb = - Chi2Model1DGrad; -using Chi2RisingScurve = Chi2Model1DGrad; -using Chi2FallingScurve = Chi2Model1DGrad; -using Chi2Pol1 = Chi2Model1DGrad; -using Chi2Pol2 = Chi2Model1DGrad; - } // namespace func } // namespace aare \ No newline at end of file diff --git a/src/Fit.cpp b/src/Fit.cpp index 8e77731..3d04ecb 100644 --- a/src/Fit.cpp +++ b/src/Fit.cpp @@ -1,12 +1,21 @@ // SPDX-License-Identifier: MPL-2.0 #include "aare/Fit.hpp" -#include "aare/Chi2.hpp" +#include "Chi2.hpp" +#include "Minuit2/FunctionMinimum.h" +#include "Minuit2/MnHesse.h" +#include "Minuit2/MnMigrad.h" +#include "Minuit2/MnPrint.h" +#include "Minuit2/MnStrategy.h" +#include "Minuit2/MnUserParameters.h" #include "aare/Models.hpp" #include "aare/utils/par.hpp" #include "aare/utils/task.hpp" #include +#include #include #include +#include +#include #include #include @@ -458,4 +467,293 @@ void fit_scurve2(NDView x, NDView y, RunInParallel(process, tasks); } +// ============================================================================ +// FitModel — method definitions +// (constructor, destructor, copy, and all methods that touch Minuit2 state) +// ============================================================================ + +template struct FitModel::FitModelImpl { + ROOT::Minuit2::MnUserParameters upar; + ROOT::Minuit2::MnStrategy strategy; + + explicit FitModelImpl(unsigned int strategy_level) + : strategy(strategy_level) {} + + FitModelImpl(const FitModelImpl &) = default; + FitModelImpl &operator=(const FitModelImpl &) = default; +}; + +template +FitModel::FitModel(unsigned int strategy, unsigned int max_calls, + double tolerance, bool compute_errors) + : impl_(std::make_unique(strategy)), max_calls_(max_calls), + tolerance_(tolerance), compute_errors_(compute_errors) { + for (std::size_t i = 0; i < npar; ++i) { + const auto pi = Model::param_info[i]; + const bool has_lo = std::isfinite(pi.default_lo); + const bool has_hi = std::isfinite(pi.default_hi); + if (has_lo && has_hi) { + impl_->upar.Add(pi.name, 0.0, 1.0, pi.default_lo, pi.default_hi); + } else if (has_lo) { + impl_->upar.Add(pi.name, 0.0, 1.0, pi.default_lo, 1e6); + } else { + impl_->upar.Add(pi.name, 0.0, 1.0); + } + } +} + +template FitModel::~FitModel() = default; + +template +FitModel::FitModel(const FitModel &other) + : impl_(std::make_unique(*other.impl_)), + max_calls_(other.max_calls_), tolerance_(other.tolerance_), + compute_errors_(other.compute_errors_), user_fixed_(other.user_fixed_), + user_start_(other.user_start_) {} + +template +FitModel &FitModel::operator=(const FitModel &other) { + if (this != &other) { + impl_ = std::make_unique(*other.impl_); + max_calls_ = other.max_calls_; + tolerance_ = other.tolerance_; + compute_errors_ = other.compute_errors_; + user_fixed_ = other.user_fixed_; + user_start_ = other.user_start_; + } + return *this; +} + +template +unsigned int FitModel::checked_index(const std::string &name) const { + for (std::size_t i = 0; i < npar; ++i) { + if (impl_->upar.Name(i) == name) + return static_cast(i); + } + throw std::runtime_error("FitModel: unknown parameter name '" + name + "'"); +} + +template +void FitModel::SetParLimits(unsigned int idx, double lo, double hi) { + impl_->upar.SetLimits(idx, lo, hi); +} + +template +void FitModel::FixParameter(unsigned int idx, double val) { + SetParameter(idx, val); + impl_->upar.Fix(idx); + user_fixed_[idx] = true; +} + +template +void FitModel::ReleaseParameter(unsigned int idx) { + impl_->upar.Release(idx); + user_fixed_[idx] = false; +} + +template +void FitModel::ReleaseParameter(const std::string &name) { + ReleaseParameter(checked_index(name)); +} + +template +void FitModel::SetParameter(unsigned int idx, double val) { + impl_->upar.SetValue(idx, val); + user_start_[idx] = true; +} + +template +void FitModel::SetParameter(const std::string &name, double val) { + SetParameter(checked_index(name), val); +} + +template +void FitModel::FixParameter(const std::string &name, double val) { + FixParameter(checked_index(name), val); +} + +template +void FitModel::SetParLimits(const std::string &name, double lo, + double hi) { + SetParLimits(checked_index(name), lo, hi); +} + +template +std::string FitModel::GetParName(unsigned int idx) const { + return impl_->upar.GetName(idx); +} + +template +std::vector FitModel::GetParNames() const { + std::vector names; + for (std::size_t i = 0; i < npar; ++i) + names.push_back(GetParName(i)); + return names; +} + +// ============================================================================ +// fit_pixel / fit_3d — Minuit2 template implementations +// ============================================================================ + +template +NDArray fit_pixel(const FitModel &model, NDView x, + NDView y, NDView y_err) { + using FCN = func::Chi2Model1DGrad; + constexpr std::size_t npar = Model::npar; + const bool want_errors = model.compute_errors(); + const ssize_t result_size = want_errors ? (2 * npar + 1) : (npar + 1); + + auto start = Model::estimate_par(x, y); + + if (!Model::is_valid(std::vector(start.begin(), start.end()))) { + return NDArray({result_size}, 0.0); + } + + double x_range, y_range, slope_scale; + model::compute_ranges(x, y, x_range, y_range, slope_scale); + + std::array steps{}; + Model::compute_steps(start, x_range, y_range, slope_scale, steps); + + // thread-local copy of starting parameters + auto upar_local = model.impl()->upar; + + for (std::size_t i = 0; i < npar; ++i) { + if (model.is_user_fixed(i)) + continue; + if (!model.is_user_start(i)) + upar_local.SetValue(i, start[i]); + upar_local.SetError(i, steps[i]); + } + + auto chi2 = (y_err.size() > 0) ? FCN(x, y, y_err) : FCN(x, y); + + ROOT::Minuit2::MnMigrad migrad(chi2, upar_local, model.impl()->strategy); + ROOT::Minuit2::FunctionMinimum min = + migrad(model.max_calls(), model.tolerance()); + + if (!min.IsValid()) + return NDArray({result_size}, 0.0); + + if (want_errors) { + ROOT::Minuit2::MnHesse hesse; + hesse(chi2, min); + + const auto &values = min.UserState().Params(); + const auto &errors = min.UserState().Errors(); + + NDArray result({result_size}); + for (std::size_t k = 0; k < npar; ++k) { + result[k] = values[k]; + result[npar + k] = errors[k]; + } + result[2 * npar] = min.Fval(); + return result; + } + + const auto &values = min.UserState().Params(); + NDArray result({result_size}); + for (std::size_t k = 0; k < npar; ++k) + result[k] = values[k]; + result[npar] = min.Fval(); + return result; +} + +template +NDArray fit_pixel(const FitModel &model, NDView x, + NDView y) { + return fit_pixel(model, x, y, NDView{}); +} + +template +void fit_3d(const FitModel &model, NDView x, + NDView y, NDView y_err, + NDView par_out, NDView err_out, + NDView chi2_out, int n_threads) { + const std::size_t npar = Model::npar; + + if (x.size() != y.shape(2)) + throw std::runtime_error("fit_3d: x.size() must match y.shape(2)."); + + if (par_out.shape(0) != y.shape(0) || par_out.shape(1) != y.shape(1) || + par_out.shape(2) != npar) + throw std::runtime_error("par_out must have shape [rows, cols, npar]."); + + if (chi2_out.shape(0) != y.shape(0) || chi2_out.shape(1) != y.shape(1)) + throw std::runtime_error("chi2_out must have shape [rows, cols]."); + + const bool has_errors = (y_err.size() > 0); + const bool want_par_errors = (err_out.size() > 0) && model.compute_errors(); + + if (has_errors) { + if (y.shape(0) != y_err.shape(0) || y.shape(1) != y_err.shape(1) || + y.shape(2) != y_err.shape(2)) + throw std::runtime_error( + "fit_3d: y and y_err must have identical shape."); + + if (err_out.shape(0) != y.shape(0) || err_out.shape(1) != y.shape(1) || + err_out.shape(2) != npar) + throw std::runtime_error( + "err_out must have shape [rows, cols, npar]."); + } + + auto process = [&](ssize_t first_row, ssize_t last_row) { + for (ssize_t row = first_row; row < last_row; row++) { + for (ssize_t col = 0; col < y.shape(1); col++) { + + NDView values(&y(row, col, 0), {y.shape(2)}); + NDView errors = + has_errors ? NDView(&y_err(row, col, 0), + {y_err.shape(2)}) + : NDView{}; + + auto res = fit_pixel(model, x, values, errors); + + for (std::size_t k = 0; k < npar; ++k) + par_out(row, col, k) = res(k); + + if (want_par_errors) { + for (std::size_t k = 0; k < npar; ++k) + err_out(row, col, k) = res(npar + k); + chi2_out(row, col) = res(2 * npar); + } else { + chi2_out(row, col) = res(npar); + } + } + } + }; + + auto tasks = split_task(0, static_cast(y.shape(0)), n_threads); + RunInParallel(process, tasks); +} + +// ============================================================================ +// Explicit instantiations for all supported model types +// ============================================================================ + +// NOLINTBEGIN +#define AARE_INSTANTIATE_FIT(Model) \ + template class FitModel; \ + template NDArray fit_pixel( \ + const FitModel &, NDView, NDView, \ + NDView); \ + template NDArray fit_pixel( \ + const FitModel &, NDView, NDView); \ + template void fit_3d(const FitModel &, NDView, \ + NDView, NDView, \ + NDView, NDView, \ + NDView, int); + +AARE_INSTANTIATE_FIT(model::Gaussian) +AARE_INSTANTIATE_FIT(model::GaussianErfcPlateau) +AARE_INSTANTIATE_FIT(model::GaussianChargeSharing) +AARE_INSTANTIATE_FIT(model::GaussianChargeSharingKb) +AARE_INSTANTIATE_FIT(model::Pol1) +AARE_INSTANTIATE_FIT(model::Pol2) +AARE_INSTANTIATE_FIT(model::RisingScurve) +AARE_INSTANTIATE_FIT(model::FallingScurve) + +#undef AARE_INSTANTIATE_FIT +// NOLINTEND + } // namespace aare \ No newline at end of file diff --git a/src/PixelMap.cpp b/src/PixelMap.cpp index ab8d3ee..d77d233 100644 --- a/src/PixelMap.cpp +++ b/src/PixelMap.cpp @@ -56,16 +56,22 @@ NDArray GenerateMoench04AnalogPixelMap() { } NDArray GenerateMoench05PixelMap() { - std::array adc_numbers = {5, 9, 1}; - NDArray order_map({160, 150}); + constexpr size_t num_adcs = 3; // num adcs with relevant data + constexpr std::array adc_numbers = Moench05::adcNumbers; + NDArray order_map({Moench05::nRows, Moench05::nCols}); + constexpr size_t n_cols = Moench05::nCols / adc_numbers.size(); int n_pixel = 0; - for (int row = 0; row < 160; row++) { - for (int i_col = 0; i_col < 50; i_col++) { - n_pixel = row * 50 + i_col; - for (int i_sc = 0; i_sc < 3; i_sc++) { - int col = 50 * i_sc + i_col; + + constexpr size_t num_adcs_enabled = + 12; // number of adcs enabled -> for 10g adcs are enabled in blocks of 4 + + for (size_t row = 0; row < Moench05::nRows; row++) { + for (size_t i_col = 0; i_col < n_cols; i_col++) { + n_pixel = row * n_cols + i_col; + for (size_t i_sc = 0; i_sc < num_adcs; i_sc++) { + size_t col = n_cols * i_sc + i_col; int adc_nr = adc_numbers[i_sc]; - int i_analog = n_pixel * 12 + adc_nr; + int i_analog = n_pixel * num_adcs_enabled + adc_nr; // analog_frame[row * 150 + col] = analog_data[i_analog] & // 0x3FFF;