diff --git a/.gitignore b/.gitignore index 7ea9f34..eb3a6f8 100644 --- a/.gitignore +++ b/.gitignore @@ -188,4 +188,12 @@ cython_debug/ # PyPI configuration file .pypirc .idea/ -/docs/source/ + +# Dataset cached at runtime by the introductory notebook +mcycle.csv + +# Dataset cached at runtime by the SVGP notebook +housing.csv + +# California boundary cached at runtime by the SVGP notebook +california.geojson diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 787bcad..fef69fc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,7 +20,7 @@ repos: - id: ruff args: [ --fix, --unsafe-fixes, --exit-non-zero-on-fix ] - id: ruff-format - types_or: [ python, pyi, jupyter ] + types_or: [ python, pyi ] # notebooks are hand-formatted; keep ruff-format off them - repo: https://github.com/MarcoGorelli/madforhooks rev: 0.4.1 diff --git a/AGENTS.md b/AGENTS.md index 2b26822..be6a6db 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -63,9 +63,9 @@ ruff format ptgp/ tests/ python scripts/joint_graph_analysis.py # op-count tables per model, with/without ptgp rewrites python scripts/inplace_audit.py # which linalg ops are inplace and why others aren't -# execute the demo notebook in place +# execute the introduction notebook in place python -m jupyter nbconvert --to notebook --execute --inplace \ - notebooks/demo.ipynb --ExecutePreprocessor.kernel_name=ptgp + notebooks/introduction/introduction.ipynb --ExecutePreprocessor.kernel_name=ptgp # install the bundled agent-skill docs into a Claude Code skill dir (optional) python scripts/install_claude_skills.py --project . # ./.claude/skills/ @@ -73,7 +73,7 @@ python scripts/install_claude_skills.py --user # ~/.claude/skills/ ``` The reference usage example for all three models is -[`notebooks/demo.ipynb`](notebooks/demo.ipynb). +[`notebooks/introduction/introduction.ipynb`](notebooks/introduction/introduction.ipynb). ## Where things live diff --git a/README.md b/README.md index 2140769..4994911 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ with pm.Model() as model: mean, var = pg.predict(svgp, np.linspace(-3, 3, 100)[:, None], fit) ``` -`pg.fit` picks a default objective from the gp type (`Unapproximated` → `marginal_log_likelihood`, `VFE` → `collapsed_elbo`, `SVGP` → `elbo`) and returns a `FitResult` that `pg.predict` consumes. For stochastic mini-batch training, staged VFE, or per-group learning rates, drop down to `pg.optim.compile_training_step` / `pg.optim.compile_scipy_objective` — see [`notebooks/demo.ipynb`](notebooks/demo.ipynb): +`pg.fit` picks a default objective from the gp type (`Unapproximated` → `marginal_log_likelihood`, `VFE` → `collapsed_elbo`, `SVGP` → `elbo`) and returns a `FitResult` that `pg.predict` consumes. For stochastic mini-batch training, staged VFE, or per-group learning rates, drop down to `pg.optim.compile_training_step` / `pg.optim.compile_scipy_objective` — see [`notebooks/introduction/introduction.ipynb`](notebooks/introduction/introduction.ipynb): ```python X_var = pt.matrix("X") @@ -73,7 +73,7 @@ predict_fn = pg.optim.compile_predict( mean, var = predict_fn(np.linspace(-3, 3, 100)[:, None]) ``` -Training uses MAP by default: the PyMC log-prior is added to the objective. Pass `include_prior=False` for pure ELBO. For exact GPs and VFE, use `compile_scipy_objective` with L-BFGS-B instead. See [`notebooks/demo.ipynb`](notebooks/demo.ipynb) for end-to-end examples covering all three models. +Training uses MAP by default: the PyMC log-prior is added to the objective. Pass `include_prior=False` for pure ELBO. For exact GPs and VFE, use `compile_scipy_objective` with L-BFGS-B instead. See [`notebooks/introduction/introduction.ipynb`](notebooks/introduction/introduction.ipynb) for end-to-end examples covering all three models. ## How it works diff --git a/conda_envs/environment-docs.yaml b/conda_envs/environment-docs.yaml index 551bf8e..1d10cf2 100644 --- a/conda_envs/environment-docs.yaml +++ b/conda_envs/environment-docs.yaml @@ -28,7 +28,7 @@ dependencies: - sphinx-notfound-page - sphinx-autobuild - jupyter-sphinx - - sphinxcontrib-bibtex + - pybtex # .bib parsing for the simplebib extension (docs/sphinxext/simplebib.py) - pip - pip: - git+https://github.com/pymc-devs/pytensor@main diff --git a/docs/.gitignore b/docs/.gitignore index b4ccf7a..947b1c7 100644 --- a/docs/.gitignore +++ b/docs/.gitignore @@ -14,6 +14,8 @@ source/api/**/classmethods/ # Notebook gallery artifacts written by docs/sphinxext/generate_gallery.py source/examples/gallery.rst source/examples/examples/ +source/examples/introduction/ +source/examples/approximations/ source/examples/introductory/ source/examples/advanced/ source/examples/case_study/ diff --git a/docs/source/_static/custom.css b/docs/source/_static/custom.css new file mode 100644 index 0000000..fc4a93f --- /dev/null +++ b/docs/source/_static/custom.css @@ -0,0 +1,34 @@ +/* Per-page citations (simplebib): superscript [n] markers linking down to a + numbered reference list, with a subtle back-reference arrow on each entry. */ + +a.simplebib-cite { + vertical-align: super; + font-size: 0.7em; + line-height: 0; + padding: 0 0.1em; + font-weight: 500; + white-space: nowrap; + text-decoration: none; +} + +a.simplebib-cite:hover { + text-decoration: underline; +} + +a.simplebib-backref { + margin-left: 0.4em; + text-decoration: none; + opacity: 0.6; +} + +a.simplebib-backref:hover { + opacity: 1; +} + +.simplebib-references { + margin-top: 0.5em; +} + +.simplebib-references .simplebib-reference { + margin-bottom: 0.4em; +} diff --git a/docs/source/api/kernels.rst b/docs/source/api/kernels.rst index a76c23d..c37204c 100644 --- a/docs/source/api/kernels.rst +++ b/docs/source/api/kernels.rst @@ -28,6 +28,7 @@ Non-stationary .. autosummary:: :toctree: generated/ + Linear Gibbs RandomWalk WarpedInput diff --git a/docs/source/api/optim.rst b/docs/source/api/optim.rst index 4212168..595a733 100644 --- a/docs/source/api/optim.rst +++ b/docs/source/api/optim.rst @@ -3,6 +3,16 @@ Optimization .. currentmodule:: ptgp.optim +High-level API +-------------- + +.. autosummary:: + :toctree: generated/ + + fit + predict + FitResult + Training compilers ------------------ diff --git a/docs/source/conf.py b/docs/source/conf.py index d150396..ca9f186 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -48,16 +48,15 @@ "sphinx_sitemap", "notfound.extension", "jupyter_sphinx", - "sphinxcontrib.bibtex", + "simplebib", "generate_gallery", "generate_kernel_gallery", ] -# Bibliographic citations: drop new entries into docs/source/references.bib -# and cite from prose with `{cite:t}` (textual) or `{cite:p}` (parenthetical). -bibtex_bibfiles = ["references.bib"] -bibtex_default_style = "unsrt" -bibtex_reference_style = "author_year" +# Bibliographic citations: drop new entries into docs/source/references.bib and +# cite from prose with `{cite:t}` / `{cite:p}`. Each page renders its own numbered +# reference list via `{bibliography}` (see docs/sphinxext/simplebib.py). +simplebib_bibfiles = ["references.bib"] # Use the document path as prefix for autosectionlabel anchors so the same # section title in two files doesn't collide. @@ -155,6 +154,7 @@ html_sidebars = {"**": ["sidebar-nav-bs.html", "searchbox.html"]} html_static_path = ["_static"] +html_css_files = ["custom.css"] # -- MyST / MyST-NB config --------------------------------------------------- myst_enable_extensions = [ diff --git a/docs/source/dev/docs.rst b/docs/source/dev/docs.rst index 199d348..9be0765 100644 --- a/docs/source/dev/docs.rst +++ b/docs/source/dev/docs.rst @@ -62,7 +62,7 @@ commit anything under ``source/kernels/img/``, ``source/_thumbnails/``, ``source/examples//``, ``source/api/**/generated/``, or ``source/kernels/gallery.rst`` / ``source/examples/gallery.rst``. -The two custom Sphinx extensions live at ``docs/sphinxext/``: +The custom Sphinx extensions live at ``docs/sphinxext/``: * ``generate_gallery.py`` — discovers notebooks under ``notebooks/``, copies them into ``docs/source/examples//``, extracts thumbnails, and @@ -71,6 +71,12 @@ The two custom Sphinx extensions live at ``docs/sphinxext/``: ``KERNEL_RECIPES``, emits ``kernels/gallery.rst`` with grid cards. Cards link to per-kernel pages when a matching ``kernels/gallery/.md`` exists on disk. +* ``simplebib.py`` — per-page citations. Provides the ``{cite:t}`` / + ``{cite:p}`` roles and the ``{bibliography}`` directive, parsing + ``references.bib`` with :mod:`pybtex`. Each page is self-contained: its + citations render as numbered ``[n]`` footnotes that link down to a numbered + reference list on the same page, so numbering and anchors never collide + across pages. Adding a new kernel to the covariance gallery --------------------------------------------- @@ -145,26 +151,29 @@ Adding a citation ----------------- Append the BibTeX entry to ``docs/source/references.bib``, then cite from -prose with either textual or parenthetical form: +prose with ``{cite:t}`` or ``{cite:p}`` (both render as a numbered footnote +marker): .. code-block:: markdown The kernel ridge regression view is discussed by {cite:t}`somekey-2024`. This approach goes back decades {cite:p}`smith-1985`. -Each page that uses citations should also include a per-page bibliography: +End each page that cites anything with a ``{bibliography}`` directive, which +renders the numbered reference list for that page: .. code-block:: markdown + ## References + ```{bibliography} - :filter: docname in docnames ``` -The ``:filter: docname in docnames`` clause restricts the rendered -bibliography to entries cited on the current page. Sphinx will emit -"duplicate citation" warnings when the same key is rendered from multiple -pages — these are tolerated; we prefer per-page bibliographies for -readability. +Citations are handled by the ``simplebib`` extension and are page-local: +``{bibliography}`` lists only the works cited on that page, numbered in +citation order, and the in-text markers link down to it. There is no central +bibliography page and no cross-page numbering, so the same key can be cited on +any number of pages without collisions. Plot helpers ------------ diff --git a/docs/source/kernels/gallery/expquad.md b/docs/source/kernels/gallery/expquad.md index f050064..a8ac124 100644 --- a/docs/source/kernels/gallery/expquad.md +++ b/docs/source/kernels/gallery/expquad.md @@ -11,7 +11,7 @@ kernelspec: # Exponentiated Quadratic Kernel -[Stationary](../gallery_tags.rst#stationary), [Isotropic](../gallery_tags.rst#isotropic), [Smooth](../gallery_tags.rst#smooth), [Universal](../gallery_tags.rst#universal) +{ref}`Stationary `, {ref}`Isotropic `, {ref}`Smooth `, {ref}`Universal ` The exponentiated quadratic kernel — also known as the **squared exponential**, **RBF**, or **Gaussian** kernel — measures covariance with the squared Euclidean distance between inputs, decaying as a Gaussian in distance. It is the default first choice in most GP applications. @@ -126,5 +126,4 @@ The three lengthscales show the kernel's effect on prior beliefs: The exponentiated quadratic is the canonical GP covariance and is discussed across all standard treatments; {cite:t}`rasmussen-williams-2006` Chapter 4 is the standard reference. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery/linear.md b/docs/source/kernels/gallery/linear.md index cd51307..254901f 100644 --- a/docs/source/kernels/gallery/linear.md +++ b/docs/source/kernels/gallery/linear.md @@ -11,7 +11,7 @@ kernelspec: # Linear Kernel -[Non-stationary](../gallery_tags.rst#non-stationary), [Isotropic](../gallery_tags.rst#isotropic) +{ref}`Non-stationary `, {ref}`Isotropic ` The linear (dot-product) kernel produces sample functions that are straight lines through the center point $c$. It is the GP equivalent of Bayesian linear regression: the posterior mean is a linear function of the inputs and the posterior variance reflects uncertainty in the slope. @@ -109,5 +109,4 @@ The three centers show the kernel's effect on prior beliefs: The linear kernel and its connection to Bayesian linear regression are discussed in {cite:t}`rasmussen-williams-2006` Chapter 2. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery/matern12.md b/docs/source/kernels/gallery/matern12.md index 246f6ce..30a538b 100644 --- a/docs/source/kernels/gallery/matern12.md +++ b/docs/source/kernels/gallery/matern12.md @@ -11,7 +11,7 @@ kernelspec: # Matérn 1/2 (Exponential) Kernel -[Stationary](../gallery_tags.rst#stationary), [Isotropic](../gallery_tags.rst#isotropic), [Very Rough](../gallery_tags.rst#very-rough) +{ref}`Stationary `, {ref}`Isotropic `, {ref}`Very Rough ` The Matérn 1/2 kernel — also known as the **exponential kernel** — produces sample functions that are continuous but nowhere differentiable. The resulting GP is equivalent to an Ornstein–Uhlenbeck process: a mean-reverting random walk in continuous time. Sample paths look like noisy zig-zag trajectories rather than smooth curves. @@ -121,5 +121,4 @@ print(K.shape, K.diagonal()[:3]) The Matérn family and its smoothness-tuning role in GP modeling is discussed in {cite:t}`rasmussen-williams-2006` Chapter 4. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery/matern32.md b/docs/source/kernels/gallery/matern32.md index fe31f92..9082892 100644 --- a/docs/source/kernels/gallery/matern32.md +++ b/docs/source/kernels/gallery/matern32.md @@ -11,7 +11,7 @@ kernelspec: # Matérn 3/2 Kernel -[Stationary](../gallery_tags.rst#stationary), [Isotropic](../gallery_tags.rst#isotropic), [Rough](../gallery_tags.rst#rough) +{ref}`Stationary `, {ref}`Isotropic `, {ref}`Rough ` The Matérn 3/2 kernel produces sample functions that are once mean-square differentiable but no smoother — the function itself and its first derivative exist and are continuous, but the second derivative does not. This is the right kernel when the process you are modeling has a clearly defined velocity but acceleration is a meaningless concept (e.g. abrupt regime changes, piecewise-linear-ish behavior on small scales). @@ -121,5 +121,4 @@ print(K.shape, K.diagonal()[:3]) The Matérn family and its smoothness-tuning role in GP modeling is discussed in {cite:t}`rasmussen-williams-2006` Chapter 4. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery/matern52.md b/docs/source/kernels/gallery/matern52.md index 23cdb3c..4ac9634 100644 --- a/docs/source/kernels/gallery/matern52.md +++ b/docs/source/kernels/gallery/matern52.md @@ -11,7 +11,7 @@ kernelspec: # Matérn 5/2 Kernel -[Stationary](../gallery_tags.rst#stationary), [Isotropic](../gallery_tags.rst#isotropic), [Smooth](../gallery_tags.rst#smooth) +{ref}`Stationary `, {ref}`Isotropic `, {ref}`Smooth ` The Matérn 5/2 kernel is the smoothest member of the Matérn family that is *not* infinitely differentiable. Sample functions are twice mean-square differentiable — the function and its first derivative are well-defined and continuous, but the curvature can have jumps. This is enough smoothness for most real-world processes and avoids the overconfident extrapolation that the [exponentiated quadratic](expquad.md) tends to produce when the true function is not analytic. @@ -121,5 +121,4 @@ print(K.shape, K.diagonal()[:3]) The Matérn family and its smoothness-tuning role in GP modeling is discussed in {cite:t}`rasmussen-williams-2006` Chapter 4. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery/randomwalk.md b/docs/source/kernels/gallery/randomwalk.md index a5979cf..95c2f80 100644 --- a/docs/source/kernels/gallery/randomwalk.md +++ b/docs/source/kernels/gallery/randomwalk.md @@ -11,7 +11,7 @@ kernelspec: # Random Walk Kernel -[Non-stationary](../gallery_tags.rst#non-stationary), [1-D](../gallery_tags.rst#one-d), [Rough](../gallery_tags.rst#rough) +{ref}`Non-stationary `, {ref}`1-D `, {ref}`Rough ` The random walk kernel — the covariance function of standard Brownian motion (the Wiener process) — is the textbook example of a non-stationary GP kernel. Its covariance depends not just on the distance between inputs but on their actual locations: $k(x, y) = \min(x, y)$ means that variance grows linearly with the input value, and two points are correlated only via their shared "history" from the origin. @@ -99,5 +99,4 @@ Prior samples fan out from the origin; the posterior pinches around each observa The random walk kernel and the broader connection between GPs and stochastic processes are covered in {cite:t}`rasmussen-williams-2006` Chapter 4. ```{bibliography} -:filter: docname in docnames ``` diff --git a/docs/source/kernels/gallery_tags.md b/docs/source/kernels/gallery_tags.md new file mode 100644 index 0000000..7040a86 --- /dev/null +++ b/docs/source/kernels/gallery_tags.md @@ -0,0 +1,48 @@ +--- +orphan: true +--- + +(gallery-tags)= +# Kernel property tags + +The covariance gallery labels each kernel with the properties below. Follow a tag from any kernel page to its definition here. + +(stationary)= +## Stationary + +The covariance $k(x, y)$ depends only on the separation $x - y$, so it is invariant to shifting both inputs by the same amount. The prior variance $k(x, x)$ is then constant across the whole input space. + +(non-stationary)= +## Non-stationary + +The covariance depends on where the inputs sit, not just on their separation. The prior variance and correlation length can vary across the input space. + +(isotropic)= +## Isotropic + +The covariance depends only on the distance $\lVert x - y \rVert$ between inputs, so it is invariant to rotation as well as translation. A single lengthscale controls correlation in every direction. + +(smooth)= +## Smooth + +Sample functions are several times mean-square differentiable, giving very regular draws. The exponentiated quadratic is infinitely differentiable; the Matérn 5/2 kernel is twice differentiable. + +(rough)= +## Rough + +Sample functions are at most once mean-square differentiable, giving visibly jagged draws. Examples are the Matérn 3/2 kernel and the random walk. + +(very-rough)= +## Very Rough + +Sample functions are continuous but nowhere differentiable, as with the exponential (Matérn 1/2) kernel. + +(one-d)= +## 1-D + +Defined for a single input dimension only. + +(universal)= +## Universal + +The kernel's reproducing-kernel Hilbert space is dense in the continuous functions, so it can approximate any continuous target arbitrarily well. The exponentiated quadratic is the canonical example. diff --git a/docs/source/references.bib b/docs/source/references.bib index a05222f..2e7ea67 100644 --- a/docs/source/references.bib +++ b/docs/source/references.bib @@ -6,3 +6,45 @@ @book{rasmussen-williams-2006 isbn = {026218253X}, url = {http://www.gaussianprocess.org/gpml/}, } + +@inproceedings{titsias-2009, + author = {Titsias, Michalis K.}, + title = {Variational Learning of Inducing Variables in Sparse Gaussian Processes}, + booktitle = {Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS)}, + series = {Proceedings of Machine Learning Research}, + volume = {5}, + pages = {567--574}, + year = {2009}, + url = {https://proceedings.mlr.press/v5/titsias09a.html}, +} + +@article{burt-2020, + author = {Burt, David R. and Rasmussen, Carl Edward and van der Wilk, Mark}, + title = {Convergence of Sparse Variational Inference in Gaussian Processes Regression}, + journal = {Journal of Machine Learning Research}, + volume = {21}, + number = {131}, + pages = {1--63}, + year = {2020}, + url = {https://jmlr.org/papers/v21/19-1015.html}, +} + +@inproceedings{hensman-2013, + author = {Hensman, James and Fusi, Nicol\`o and Lawrence, Neil D.}, + title = {Gaussian Processes for Big Data}, + booktitle = {Proceedings of the Twenty-Ninth Conference on Uncertainty in Artificial Intelligence (UAI)}, + pages = {282--290}, + year = {2013}, + url = {https://arxiv.org/abs/1309.6835}, +} + +@article{pace-barry-1997, + author = {Pace, R. Kelley and Barry, Ronald}, + title = {Sparse Spatial Autoregressions}, + journal = {Statistics & Probability Letters}, + volume = {33}, + number = {3}, + pages = {291--297}, + year = {1997}, + url = {https://doi.org/10.1016/S0167-7152(96)00140-X}, +} diff --git a/docs/sphinxext/generate_gallery.py b/docs/sphinxext/generate_gallery.py index 4b1d181..6720ad4 100644 --- a/docs/sphinxext/generate_gallery.py +++ b/docs/sphinxext/generate_gallery.py @@ -43,12 +43,31 @@ # Pretty titles for known subfolders. Anything not listed is title-cased. CATEGORY_TITLES = { + "introduction": "Introduction", + "approximations": "Approximations", "examples": "Examples", "introductory": "Introductory", "advanced": "Advanced", "case_study": "Case Studies", } +# Order the sections appear in the gallery. Categories not listed here follow, +# sorted alphabetically. +CATEGORY_ORDER = [ + "introduction", + "approximations", + "examples", + "introductory", + "advanced", + "case_study", +] + + +def _category_sort_key(category): + rank = CATEGORY_ORDER.index(category) if category in CATEGORY_ORDER else len(CATEGORY_ORDER) + return rank, category + + DEFAULT_IMG_LOC = None TITLE = """ @@ -214,17 +233,11 @@ def main(app): toctree_entries: list[str] = [] section_lines: list[str] = [] - for category in sorted(grouped): + for category in sorted(grouped, key=_category_sort_key): nb_paths = grouped[category] title = CATEGORY_TITLES.get(category, category.replace("_", " ").title()) - section_lines.append( - SECTION_TEMPLATE.format( - section_title=title, - section_id=category, - underlines="-" * len(title), - ) - ) + item_lines: list[str] = [] for nb_path in nb_paths: if not is_tracked_by_git(nb_path): logger.info( @@ -248,7 +261,7 @@ def main(app): # Sphinx resolve it from the source root, matching gEconpy's # convention so users can drop in custom thumbnails too. img_path = f"/_thumbnails/{category}/{nbg.stripped_name}.png" - section_lines.append( + item_lines.append( ITEM_TEMPLATE.format( doc_name=doc_name, image=img_path, @@ -257,6 +270,19 @@ def main(app): ) ) + # A section with no tracked notebooks would emit a bare, cardless + # grid that sphinx-codeautolink chokes on, so skip it entirely. + if not item_lines: + continue + section_lines.append( + SECTION_TEMPLATE.format( + section_title=title, + section_id=category, + underlines="-" * len(title), + ) + ) + section_lines.extend(item_lines) + # Assemble: title, hidden toctree (so notebooks register with Sphinx), # then the visible grid-card sections. file_lines = [TITLE, TOCTREE_HEAD] diff --git a/docs/sphinxext/simplebib.py b/docs/sphinxext/simplebib.py new file mode 100644 index 0000000..894c18a --- /dev/null +++ b/docs/sphinxext/simplebib.py @@ -0,0 +1,170 @@ +import re + +from docutils import nodes +from docutils.parsers.rst import Directive, directives +from pybtex.database import parse_file +from sphinx.domains import Domain +from sphinx.util import logging + +logger = logging.getLogger(__name__) + + +class cite_ref(nodes.Inline, nodes.Element): + """Placeholder for one in-text citation; resolved to a numbered link.""" + + +class bibliography_node(nodes.General, nodes.Element): + """Placeholder for a page's reference list; resolved to a numbered list.""" + + +def _cite_role(name, rawtext, text, lineno, inliner, options=None, content=None): + result = [] + for i, key in enumerate(k.strip() for k in text.split(",") if k.strip()): + if i: + result.append(nodes.Text(", ")) + node = cite_ref("", key=key) + result.append(node) + return result, [] + + +class CiteDomain(Domain): + name = "cite" + label = "simplebib" + roles = {"t": _cite_role, "p": _cite_role} + + def get_objects(self): + return [] + + def resolve_xref(self, *args): + return None + + +class BibliographyDirective(Directive): + has_content = False + # Accept and ignore sphinxcontrib-bibtex's options so existing pages parse. + option_spec = {"filter": directives.unchanged, "keyprefix": directives.unchanged} + + def run(self): + return [bibliography_node("")] + + +def _load_bib(app): + entries = {} + for name in app.config.simplebib_bibfiles: + path = app.env.relfn2path(name, app.config.master_doc)[1] + for key, entry in parse_file(path).entries.items(): + entries[key.lower()] = entry + return entries + + +def _persons(entry): + return entry.persons.get("author") or entry.persons.get("editor") or [] + + +def _clean(value): + return re.sub(r"\s+", " ", value.replace("{", "").replace("}", "")).strip() + + +def _format_person(person): + last = _clean(" ".join(person.prelast_names + person.last_names)) + given = [_clean(n) for n in person.first_names + person.middle_names] + initials = " ".join(f"{n[0]}." for n in given if n) + return f"{last}, {initials}".rstrip(", ").strip() + + +def _format_authors(persons): + names = [_format_person(p) for p in persons] + if len(names) <= 1: + return names[0] if names else "" + return ", ".join(names[:-1]) + ", & " + names[-1] + + +def _format_entry(entry): + fields = entry.fields + authors = _format_authors(_persons(entry)) + year = fields.get("year", "n.d.") + title = _clean(fields.get("title", "")) + + head = " ".join(part for part in [authors, f"({year})."] if part) + text = f"{head} {title}." if title else head + + venue = _clean( + fields.get("journal") + or fields.get("booktitle") + or fields.get("publisher") + or fields.get("school") + or "" + ) + if venue: + detail = venue + if fields.get("volume"): + detail += f", {fields['volume']}" + if fields.get("number"): + detail += f"({fields['number']})" + if fields.get("pages"): + detail += f", {_clean(fields['pages']).replace('--', '–')}" + text += f" {detail}." + return text + + +def _anchor(key): + return nodes.make_id(f"ref-{key}") + + +def _resolve_page(app, doctree, docname): + bib = app.env.simplebib_data + numbers = {} # key -> citation number (first-seen order) + backrefs = {} # key -> [ids of the in-text markers] + + for node in list(doctree.findall(cite_ref)): + key = node["key"] + if key not in bib: + logger.warning(f"unknown citation key {key!r}", location=node, type="simplebib") + node.replace_self(nodes.Text("[?]")) + continue + number = numbers.setdefault(key, len(numbers) + 1) + ref_id = nodes.make_id(f"cite-{key}-{len(backrefs.get(key, []))}") + backrefs.setdefault(key, []).append(ref_id) + + marker = nodes.reference("", f"[{number}]", internal=True, refid=_anchor(key)) + marker["ids"].append(ref_id) + marker["classes"].append("simplebib-cite") + node.replace_self(marker) + + for node in list(doctree.findall(bibliography_node)): + if not numbers: + node.replace_self([]) + continue + listing = nodes.container(classes=["simplebib-references"]) + for key in sorted(numbers, key=numbers.get): + para = nodes.paragraph(ids=[_anchor(key)], classes=["simplebib-reference"]) + para += nodes.Text(f"[{numbers[key]}] {_format_entry(bib[key])}") + for ref_id in backrefs[key]: + para += nodes.Text(" ") + back = nodes.reference("", "↩", internal=True, refid=ref_id) + back["classes"].append("simplebib-backref") + para += back + listing += para + node.replace_self(listing) + + +def _noop(self, node): + raise nodes.SkipNode + + +def _init_bib(app): + app.env.simplebib_data = _load_bib(app) + + +def setup(app): + app.add_config_value("simplebib_bibfiles", ["references.bib"], "env") + app.add_domain(CiteDomain) + app.add_directive("bibliography", BibliographyDirective) + # These nodes are always replaced at doctree-resolved; the skip visitors + # are a safety net for any builder if one ever survives. + skip = (_noop, None) + for node in (cite_ref, bibliography_node): + app.add_node(node, html=skip, latex=skip, text=skip, man=skip, texinfo=skip) + app.connect("builder-inited", _init_bib) + app.connect("doctree-resolved", _resolve_page) + return {"version": "0.1", "parallel_read_safe": True, "parallel_write_safe": True} diff --git a/notebooks/approximations/gp-variational-stochastic.ipynb b/notebooks/approximations/gp-variational-stochastic.ipynb new file mode 100644 index 0000000..73bbe4c --- /dev/null +++ b/notebooks/approximations/gp-variational-stochastic.ipynb @@ -0,0 +1,831 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c306854", + "metadata": {}, + "source": [ + "(gp-variational-stochastic)=\n", + "# Stochastic Variational Gaussian Processes\n", + "\n", + "The {ref}`introduction ` fit an exact GP and a sparse VFE approximation, both with a Gaussian likelihood and full-batch training. Two walls appear as the data grows: exact inference factorizes an $N \\times N$ kernel matrix ($O(N^3)$), and even the sparse VFE bound sums over all $N$ points every step, so a single gradient needs the whole dataset in memory.\n", + "\n", + "Stochastic variational GPs (SVGP) remove both walls. Following {cite:t}`hensman-2013`, SVGP keeps an explicit variational distribution $q(\\mathbf u)$ over the inducing values and optimizes it directly. That \"uncollapsed\" bound is a sum over data points, so it can be estimated from a minibatch and trained by stochastic gradient ascent that scales to millions of observations. The same move lets SVGP handle non-Gaussian likelihoods, though we stay Gaussian here.\n", + "\n", + "This notebook builds the bound from the collapsed VFE bound of the intro, trains an SVGP on a 1D problem to expose its moving parts, then scales to a real 20,000-point spatial dataset. It assumes you have read the {ref}`introduction ` and are comfortable with variational inference. See the {doc}`kernel gallery ` and {doc}`user guide ` for the surrounding API." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "b040ac11", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import json\n", + "import urllib.request\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.path import Path as MplPath\n", + "import pymc as pm\n", + "import pytensor.tensor as pt\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "import ptgp as pg\n", + "\n", + "rng = np.random.default_rng(0)\n", + "\n", + "plt.rcParams.update(\n", + " {\n", + " \"figure.figsize\": (14, 5),\n", + " \"figure.dpi\": 144,\n", + " \"figure.constrained_layout.use\": True,\n", + " \"axes.grid\": True,\n", + " \"grid.linewidth\": 0.5,\n", + " \"grid.linestyle\": \"--\",\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9b9476ee", + "metadata": {}, + "source": [ + "## From the collapsed bound to the uncollapsed bound\n", + "\n", + "Both VFE and SVGP place $M$ inducing variables $\\mathbf u = f(Z)$ at locations $Z$ and reason about the posterior through them. They differ in what they do with the variational distribution $q(\\mathbf u)$.\n", + "\n", + "**VFE (collapsed).** Titsias' bound {cite:t}`titsias-2009` solves for the optimal Gaussian $q(\\mathbf u)$ in closed form and substitutes it back, leaving a bound in the kernel hyperparameters alone:\n", + "\n", + "$$\\mathcal L_{\\text{VFE}} = \\log \\mathcal N\\!\\big(\\mathbf y;\\, \\mathbf 0,\\, Q_{ff} + \\sigma^2 I\\big) - \\frac{1}{2\\sigma^2}\\operatorname{tr}(K_{ff} - Q_{ff}),\\qquad Q_{ff}=K_{fu}K_{uu}^{-1}K_{uf}.$$\n", + "\n", + "Elegant, but rigid: the closed form needs a Gaussian likelihood, and evaluating it touches all $N$ points at once, so every gradient step is $O(NM^2)$ over the full dataset.\n", + "\n", + "**SVGP (uncollapsed).** Following {cite:t}`hensman-2013`, keep $q(\\mathbf u) = \\mathcal N(\\mathbf m, S)$ explicit and optimize $\\mathbf m$, $S$, and the inducing locations $Z$ jointly with the hyperparameters. The evidence lower bound becomes\n", + "\n", + "$$\\mathcal L = \\sum_{i=1}^N \\mathbb E_{q(f_i)}\\!\\big[\\log p(y_i \\mid f_i)\\big] \\;-\\; \\mathrm{KL}\\!\\big[q(\\mathbf u)\\,\\|\\,p(\\mathbf u)\\big].$$\n", + "\n", + "The first term is a sum over data points; the second does not depend on the data at all. That structure is the whole point." + ] + }, + { + "cell_type": "markdown", + "id": "396927de", + "metadata": {}, + "source": [ + "### Minibatching\n", + "\n", + "Because the data term is a sum, an unbiased estimate comes from a random minibatch $B$:\n", + "\n", + "$$\\mathcal L \\approx \\frac{N}{\\lvert B\\rvert}\\sum_{i \\in B}\\mathbb E_{q(f_i)}\\!\\big[\\log p(y_i\\mid f_i)\\big] - \\mathrm{KL}\\!\\big[q(\\mathbf u)\\,\\|\\,p(\\mathbf u)\\big].$$\n", + "\n", + "The likelihood term is rescaled by $N/\\lvert B\\rvert$; the KL is left alone. PTGP applies exactly this scaling through `pg.objectives.elbo(svgp, X, y, n_data=N)`. Each step now costs $O(M^3 + \\lvert B\\rvert M^2)$ and never needs the full dataset in memory.\n", + "\n", + "Each marginal $q(f_i)=\\mathcal N(\\mu_i,\\sigma_i^2)$ follows from $q(\\mathbf u)$ by conditioning; at a test point,\n", + "\n", + "$$\\mu(x_*) = k_{*u}K_{uu}^{-1}\\mathbf m,\\qquad \\sigma^2(x_*) = k_{**} - k_{*u}K_{uu}^{-1}k_{u*} + k_{*u}K_{uu}^{-1}\\,S\\,K_{uu}^{-1}k_{u*}.$$\n", + "\n", + "### Whitening\n", + "\n", + "PTGP parameterizes $q$ over a whitened variable $\\mathbf v$ with $p(\\mathbf v)=\\mathcal N(0, I)$ and $\\mathbf u = R\\mathbf v$, $RR^\\top = K_{uu}$ (default `whiten=True`). This decorrelates the prior, improves conditioning, and collapses the KL to a form needing no kernel solve:\n", + "\n", + "$$\\mathrm{KL} = \\tfrac12\\big(\\operatorname{tr} S + \\mathbf m^\\top \\mathbf m - M - \\log\\lvert S\\rvert\\big).$$\n", + "\n", + "The three methods trade off cost, training mode, and likelihood:\n", + "\n", + "- **Exact GP**: $O(N^3)$ per step, full-batch, Gaussian likelihood only.\n", + "- **VFE**: $O(NM^2)$ per step, full-batch, Gaussian only.\n", + "- **SVGP**: $O(M^3 + \\lvert B\\rvert M^2)$ per step, minibatch, and any likelihood." + ] + }, + { + "cell_type": "markdown", + "id": "f5cab1a4", + "metadata": {}, + "source": [ + "## A worked 1D example\n", + "\n", + "To see the moving parts, start with a synthetic 1D regression: $N = 20{,}000$ noisy observations of $y = \\sin x + \\cos(0.75x)$. Small enough to plot, large enough that minibatching does real work. We standardize both axes so the priors below are sensibly scaled, and plot a random subsample." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "00aeca13", + "metadata": {}, + "outputs": [], + "source": [ + "N = 20_000\n", + "\n", + "x = rng.uniform(-5.5, 5.5, size = N)\n", + "y = np.sin(x) + np.cos(0.75 * x) + 0.2 * rng.standard_normal(size = N)\n", + "\n", + "x_scaler = StandardScaler().fit(x[:, None])\n", + "y_scaler = StandardScaler().fit(y[:, None])\n", + "\n", + "X = x_scaler.transform(x[:, None])\n", + "Y = y_scaler.transform(y[:, None]).ravel()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "e0bed9b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subsample = rng.choice(N, size = 2000, replace = False)\n", + "x_line = np.linspace(-5.5, 5.5, 400)\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "ax.scatter(\n", + " x[subsample],\n", + " y[subsample],\n", + " s = 6,\n", + " alpha = 0.3,\n", + " c = \"k\",\n", + " label = \"observations (subsample)\",\n", + ")\n", + "ax.plot(x_line, np.sin(x_line) + np.cos(0.75 * x_line), \"C3\", lw = 2, label = \"true function\")\n", + "\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_title(f\"1D data (N = {N:,})\")\n", + "ax.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "379d50d8", + "metadata": {}, + "source": [ + "### Building the model\n", + "\n", + "An SVGP needs a kernel, a likelihood, an inducing variable, and a variational distribution. We seed $M = 25$ inducing inputs with `greedy_variance_init` (the pivoted-Cholesky heuristic from the intro) and $q(\\mathbf u)$ with `init_variational_params`. Passing the inducing inputs as a trainable `Points` variable makes their locations variational parameters too: training jointly optimizes the kernel hyperparameters, the noise, $q(\\mathbf u)$, and the inducing locations $Z$." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "07016681", + "metadata": {}, + "outputs": [], + "source": [ + "M = 25\n", + "\n", + "inducing_kernel = pg.kernels.ExpQuad(input_dim = 1, ls = 0.5)\n", + "Z_init = pg.inducing.greedy_variance_init(X, M = M, kernel = inducing_kernel, rng = 0)[0].Z\n", + "\n", + "Z_var = pt.matrix(\"Z\", shape = (M, 1))\n", + "inducing = pg.inducing.Points(Z_var, Z_init = Z_init)\n", + "vp = pg.gp.init_variational_params(M = M)\n", + "\n", + "X_var = pt.matrix(\"X\", shape = (None, 1))\n", + "y_var = pt.vector(\"y\", shape = (None,))\n", + "\n", + "with pm.Model() as model_1d:\n", + " ls = pm.InverseGamma(\"ls\", alpha = 3.0, beta = 1.0)\n", + " eta = pm.Exponential(\"eta\", scale = 1.0)\n", + " sigma = pm.HalfNormal(\"sigma\", sigma = 1.0)\n", + "\n", + " kernel = eta**2 * pg.kernels.ExpQuad(input_dim = 1, ls = ls)\n", + " svgp = pg.gp.SVGP(\n", + " kernel = kernel,\n", + " likelihood = pg.likelihoods.Gaussian(sigma = sigma),\n", + " inducing_variable = inducing,\n", + " variational_params = vp,\n", + " whiten = True,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "a208fb52", + "metadata": {}, + "source": [ + "### Training\n", + "\n", + "`compile_training_step` compiles the minibatch-scaled ELBO and its gradient into a single Adam step that updates every trainable parameter in place. We wrap `pg.objectives.elbo` to bake in the `n_data = N` scaling, pass the variational parameters as `extra_vars`, and run 2,000 minibatch steps of size 256 under an exponentially decaying learning rate." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "046c9832", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "recovered: {'ls': 0.306, 'eta': 0.474, 'sigma': 0.192}\n" + ] + } + ], + "source": [ + "def elbo_objective(gp, X, y):\n", + " return pg.objectives.elbo(gp, X, y, n_data = N).elbo\n", + "\n", + "\n", + "train_step, shared_params, shared_extras = pg.optim.compile_training_step(\n", + " objective_fn = elbo_objective,\n", + " gp_model = svgp,\n", + " X_var = X_var,\n", + " y_var = y_var,\n", + " model = model_1d,\n", + " extra_vars = svgp.extra_vars,\n", + " extra_init = svgp.extra_init,\n", + " learning_rate = pg.optim.schedules.exponential_decay(1e-2, decay_rate = 0.3, decay_steps = 2000),\n", + ")\n", + "\n", + "batch_size = 256\n", + "n_steps = 2000\n", + "\n", + "losses = []\n", + "for step in range(n_steps):\n", + " batch = rng.choice(N, size = batch_size, replace = False)\n", + " losses.append(float(train_step(X[batch], Y[batch])))\n", + "\n", + "params = pg.optim.get_trained_params(model = model_1d, shared_params = shared_params)\n", + "print(\"recovered:\", {name: round(float(value), 3) for name, value in params.items()})" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "f36eb2f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(14, 3))\n", + "\n", + "ax.plot(losses, lw=0.8)\n", + "ax.set_yscale(\"symlog\")\n", + "\n", + "ax.set_xlabel(\"minibatch step\")\n", + "ax.set_ylabel(\"loss (-ELBO estimate)\")\n", + "ax.set_title(\"SVGP training loss\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "2f1a913e", + "metadata": {}, + "outputs": [], + "source": [ + "def to_y(values):\n", + " return y_scaler.inverse_transform(np.reshape(values, (-1, 1))).ravel()\n", + "\n", + "\n", + "X_new = pt.matrix(\"X_new\", shape = (None, 1))\n", + "predict = pg.optim.compile_predict(\n", + " gp_model = svgp,\n", + " X_new_var = X_new,\n", + " model = model_1d,\n", + " shared_params = shared_params,\n", + " shared_extras = shared_extras,\n", + ")\n", + "predict_y = pg.optim.compile_predict(\n", + " gp_model = svgp,\n", + " X_new_var = X_new,\n", + " model = model_1d,\n", + " shared_params = shared_params,\n", + " shared_extras = shared_extras,\n", + " incl_lik = True,\n", + ")\n", + "\n", + "grid = np.linspace(-6, 6, 300)[:, None]\n", + "grid_x = x_scaler.inverse_transform(grid).ravel()\n", + "\n", + "mu, var = predict(grid)\n", + "_, var_y = predict_y(grid)\n", + "sd = np.sqrt(var)\n", + "sd_y = np.sqrt(var_y)\n", + "\n", + "mean = to_y(mu)\n", + "f_lo = to_y(mu - 2 * sd)\n", + "f_hi = to_y(mu + 2 * sd)\n", + "y_lo = to_y(mu - 2 * sd_y)\n", + "y_hi = to_y(mu + 2 * sd_y)\n", + "\n", + "Z_final = shared_extras[-1].get_value()\n", + "z_init_x = x_scaler.inverse_transform(Z_init).ravel()\n", + "z_final_x = x_scaler.inverse_transform(Z_final).ravel()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "4c63900b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB/AAAALgCAYAAACDJ++jAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAWJQAAFiUBSVIk8AABAABJREFUeJzs3Qd4W+XVB/C/tbz3thPH2Ttk0CSMhBD2DHvvWcootJQCHy2bQls2bdmr7E3Ze4YkkL237STee2lL/p5zgoTs2CFb19L/9zx6pCtLV6+ufWz5nvecN6ajo6MDREREREREREREREREREREFFam8L48ERERERERERERERERERERCSbwiYiIiIiIiIiIiIiIiIiIDIAJfCIiIiIiIiIiIiIiIiIiIgNgAp+IiIiIiIiIiIiIiIiIiMgAmMAnIiIiIiIiIiIiIiIiIiIyACbwiYiIiIiIiIiIiIiIiIiIDIAJfCIiIiIiIiIiIiIiIiIiIgNgAp+IiIiIiIiIiIiIiIiIiMgAmMAnIiIiIiIiIiIiIiIiIiIyACbwiYiIiIiIiIiIiIiIiIiIDIAJfCIiIiIiIiIiIiIiIiIiIgNgAp+IiIiIiIiIiIiIiIiIiMgAmMAnIiIiIiIiIiIiIiIiIiIyACbwiYiIiIiIiIh20nnnnYeYmBjccsstPJZERERERES0w5jAJyIiIiIioqjk9Xrx7LPP4vDDD0d+fj5sNhvS09MxfPhwHHXUUbjnnnvw008/BR//1VdfaYJWLj/++OM2vUZjYyNiY2P1OY8++mi3j6mqqsJdd92F6dOno7CwEHFxcUhMTES/fv1w7LHH4oEHHkBFRUW3z/3666+DYwq9yD6Kiopw8skn4/PPP0ckk++hJM0XLlwY7qEQERERERER7TTLzu+CiIiIiIiIqHepra3FkUceiblz5wbvk6R3R0cHVq1ahZUrV+LDDz9Eamoqmpqa9OvTpk3TpHpZWRmef/55TJw48Vdf55VXXoHb7dYk/qmnntrpa/Jakri/88474XA4gvcnJSXBZDJhw4YNennvvfdw3XXX4dJLL8XDDz/c42tlZWXBbDbr7ebmZmzcuFEvb7zxBv7whz/g3nvvRaQm8L/55hsUFxdj7NixYRuHTAIZOnSofh+IiIiIiIiIdhQr8ImIiIiIiCjqnHXWWZq8T05Oxt///ndUVlZqEl2S9ZL8/uyzz/C73/0OaWlpwedIZfs555wTTMx7PJ5ffR1J9AuppJfq/lDnn38+brrpJn3dgw8+GO+//z5aWlrQ2tqqY7Db7fjiiy90HFarFf/973+3+lrSLUCq+eXS3t6uFen77beffu2+++7DO++8s0PHirbN3/72N534ccUVV/CQERERERER0Q5jAp+IiIiIiIiiiiRZP/30U7399NNP409/+hPy8vKCX5ekviTU//Wvf2HFihWdnhtI4NfX12uF/tasWbMGs2fP1tvnnntup6/Jvp977jm9LVX4MmFA2vbLawfEx8drW3157Pr163HiiSdu83uUCv699tpLq/cDFeH/+c9/tvn5RERERERERBQeTOATERERERFRVFmyZEnw9tFHH73Vx0oSPdSgQYOCVe2B6vqeBL6em5uLww47LHi/VNbLmu1CkvI33HDDr45Z9vHUU09he0nVf+C1582bt11t6aXjgCwbIGSyweTJk5GSkqLLChx00EH4+OOPt7oPl8ullf+TJk3S58ixlBbz0s5fugT0ZNGiRTpRQlriy9IDMqlhwIABOPzww/HAAw/o8Qsdo7TPD3Q0kO3ARZ7flSxn8Mgjj2DKlCnIyMjQ/cuyCBdccMEWkzUCzjvvPN2ffM/kPcmSB2PGjNFxyf2BJRZCH7erjkfX78OLL76IAw44AJmZmXo/uyoQERERERFFHku4B0BEREREREQULuXl5Rg4cOB2PUeq6WfOnKkt7xsbG7dojR9Y3/6FF17Q22eeeSYsll/+/X7rrbdQV1ent//v//4Pu1thYaFeS3v+HXHNNddo4lyq+iWBL+39v/zyS7384x//wLXXXrvFc2pra3XiwIIFC3RbEuU2mw2rV6/WiySmpYOBTAoIJfcdd9xxweUJ5HnyuiUlJXr55JNPNJE/bNgwTYDLxIaGhgZ9vIwtdMJFdnZ2p33LMglHHHGEThAQst/ExERs2LABzzzzDF5++WVNkJ9wwgndHgen04mpU6fixx9/1CUNEhIStvkY7ujxCHXVVVfh4Ycf1nHLBAC5JiIiIiIiosjD//aIiIiIiIgoqkyYMCF4+/LLL9fk6vY45ZRTEBcXp9Xcr776areP+fbbb1FaWtqp7X7A119/rdf5+fkYN24cdjdJUIu0tLTtfu7ChQs1ef/nP/9ZE+UyYUEmPcikBHHdddfh+++/3+J58p4lWS2TG1577TW0t7frBIKffvoJo0eP1v1Ioj4wkSHgyiuv1GS8dEZYtWqVJs1lwoBc5JhefPHFeuzFqaeeqpXr++67r24/+OCDuh24yGsFyD5nzJihyXtJwsu+HA6Hjkke+8c//lFf6+yzz8a6deu6PRaylIEk21955RW0tbVp5b18j2USwK/Z0eMRIN0TpHPArbfeqss3BL4XgfdOREREREREkYMJfCIiIiIiIooq0o49kFSXiu4+ffromvc33XQT3n333V9N6Ev1syRbt9ZGP3D/2LFjdS36UIFW7dKGfXeTqvMPPvhAb0vr9u0lifOLLroId999t77vwMSD//73vzjwwAO100DXlvHfffddsL3+Sy+9hJNPPhlms1m39957b3z22WeayK6ursZDDz0UfF5NTQ3Wr1+vt5988kkMGTIk+DWprpe2948//ni3rfF/jSwBIMny3/zmN/j00091X1IBL6SK/5///Ccuu+wybc9///33d7sPSdrLhA2ZOBB4rrTfl2r8rdnR49H1ta+//nr89a9/DU7EkGOSk5Oz3ceCiIiIiIiIjI0JfCIiIiIiIoo6TzzxhK49LolYqaT/4osvdG1zScxLUnTixInaTl0S1D210RezZs3C2rVrO31NKrvfeOONTo8LJdXTorvW+wFHHXUU8vLytrj0VPHflVRnS6L6kEMOQWtrq953xRVXYEfceOONW9wn66/fcMMNelta6Qfekwi8d0lOS7v7riRh/tvf/lZvSzV6gKwpH2gLLxMPdiVJ4Ac6Lkj7+u6cccYZei0J9e7IhItDDz10u197R49HKEn4y88rERERERERRT4m8ImIiIiIiCjqSOL+3nvvxcaNG/Hoo4/i9NNPx+DBgzUxLaRa+6yzztJqa7/fv8XzJTFeUFCgt6UaPdQ777yj7dFl3ftAUnh7SZt0qcjuepHJAT3p37+/jl8uGRkZuub6smXLNCl+11136fb2Kioq0v12Z//999fEskxykFb7AfPnz9drqdDvyfTp0/VaWtJLO3kh69cfcMABelvGescdd+h+fT4fdobX69V164UkwbubGCGX448/Xh8jPxPd2WeffXbo9Xf0eIQaNGgQsrKyduj1iYiIiIiIqHdhAp+IiIiIiIiillTbX3rppdraXJKnUvkt1fl9+/bVr7/++ut4+OGHt3ieJK4lwR9I4IdW6gfa50u1dXctziW5HqiS78ns2bN1n4FLYWHhr74XSfBKNbdcJPEuFd9ScT537txgtfz22trrSsI90EUgdNmBwO2tPVeWLRDy3kLXfZfW+cOHD9d2+n/5y18wbtw4bRkvHQleeOEFTcZvL+kOIF0WAre7mxghl8A4epokkZ2djR2xM8djZ1+biIiIiIiIeh8m8ImIiIiIiIh+JslvWfNdqqbltnj66ae7PT6B9vglJSX4/vvv9XZVVVWwBXt37fOFJKjF4sWLd+lxl64B8vpyKSsr0+1HHnlEk+C7S09LDAiXy7Xd+xswYIAel7fffhuXXHKJHitZ//3DDz/E2WefjUmTJun29gjtoLBo0aJOEyN6unQnsG79jtqR47GrXpuIiIiIiIh6DybwiYiIiIiIiLqpZp8xY4belsr87owYMUKr3EPb6L/44ova8l0q04855phunzdt2jS9lmr/BQsWGPrYV1RU9Pg1p9OJpqamLSrEA7dlEkFPNm3apNfS7r9ra3hZeuC4447DY489huXLl+tx+sc//oG4uDidWHHrrbdu13vIzMwMJsBlf3vazh4PIiIiIiIiii5M4BMRERERERF1IzExUa9tNluPxydQZf/aa69pQjvQPv+0005DbGxst8854YQTgknaO++809DHXpLOpaWl3X5Nug7IZAVJOo8dOzZ4//jx4/X6m2++6bGa/csvv9TrIUOGBI9zT2R9+muvvRZXX311cL+hTKbNpzZ6ei2r1RqcaPHWW29hT9vVx4OIiIiIiIgiGxP4REREREREFFWk5f26deu2+hi73Y533nlHb4cmp7s6/fTTNcHf3NyMO+64I9gWv6f2+SIhIQG33HKL3n7zzTfxt7/9DUbW3fgkEX333Xfr7YMOOggZGRnBr5100kl6vWzZMrz77rtbPFfWm3/00Uf19imnnBK83+PxbLUlf3x8fLet6FNSUvQ60A2gO+edd17weH/11VfYmsbGRuxKO3o8iIiIiIiIKDoxgU9ERERERERRRRKpQ4cO1Up4qZyXFu0B7e3teO+99zBlyhRN9Ivf//73W23PftRRR3VKdMu+Za32rbn88suDSf4bb7wRhxxyCD744AO0trZ2SmjPnTtXX1+SvOEgyfHHH39cxyiTFERVVZWO/YsvvtDq+5tvvrnTc+TYHX744Xr7ggsuwBtvvKGV+mLevHk49NBDNUmem5vb6djK92XUqFF44IEHdNmCQDJfjoMk3u+77z7dPuywwzq93siRI4PV9YExdnXhhRdi8uTJ8Pv9OProo/Hggw+ioaEh+PWamhq8/PLLuryBfG1X2tHjQURERERERNHJEu4BEBEREREREe1J0lJdEqhvv/22XgLV3YFK+gBZN/22227TRP/WSDJb9iPJ4cD2tnjmmWcwePBgrdz//PPP9SKSk5N1jDKWQKJXtq+88kpdG35PGjdunF5kcsLf//53TehLpXsguS737b///ls8T5YSkMT0woULcfLJJ+v69fIeAhMU0tPT9ZjJBIhQskb9NddcoxdZgkDaycvrBY6ttMK/6aabOj3n7LPPxj//+U9t6S9LE+Tk5Ohr9enTR+8Tsi3V7/K9nDlzprbjl9dIS0vTCQJtbW3B/R144IG7/Dju6PEgIiIiIiKi6MMEPhEREREREUUVqeBetWqVVtpLgnfp0qUoLy/XJK4kdAcMGICpU6fioosuClZ3b82RRx6J7Oxs1NbW6nrsZ5111jaNQ6rX/+///k+rsp9++mmtaF+5ciXq6+s1cV9YWIi99tpLq8Jln5KYDof7779flxH497//jRUrViApKUkT6dddd12wsrwrOR6zZs3S50hluxxvt9utExakY4E8Nz8/v9Nzhg8frtXpMpFhzpw5qKio0GMhkwakMv/UU0/FJZdcohMtQg0bNgyfffaZTjL46aeftENAIOEfSo6frEP/6quv4sUXX9Tqd6nCl/3JPvbbbz+ceOKJOPjgg3fxEdyx40FERERERETRKaZjawvMEREREREREVHUefbZZ3H++efjgAMOwNdffx3u4RARERERERFFDVO4B0BERERERERERERERERERERM4BMRERERERERERERERERERkCK/CJiIiIiIiIiIiIiIiIiIgMgAl8IiIiIiIiIiIiIiIiIiIiA4jp6OjoCPcgiIiIiIiIiIiIiIiIiIiIoh0r8ImIiIiIiIiIiIiIiIiIiAyACXwiIiIiIiIiIiIiIiIiIiIDYAKfiIiIiIiIiIiIiIiIiIjIAJjAJyIiIiIiIiIiIiIiIiIiMgAm8ImIiIiIiIiIiIiIiIiIiAzAEu4BRJri4mK0tLSgf//+4R4KERERERERERERERERERHtYSUlJUhJSUFpael2P5cV+LuYJO+dTieMzOjjI4pWjE0iY2JsEhkX45PImBibRMbF+CQyJsYmkXExPomMydkLcp0yRskb7whW4O9igcr7efPmwajeffddzJgxI9zDIKIuGJtExsTYJDIuxieRMTE2iYyL8UlkTIxNIuNifBIZ07u9INc5YcKEHX4uK/CjUG5ubriHQETdYGwSGRNjk8i4GJ9ExsTYJDIuxieRMTE2iYyL8UlkTLkRnuuM6ejo6Aj3ICJJYDaFkSvwiYiIiIiIiIiIiIiIiIjIeDljVuBHodmzZ4d7CETUDcYmkTExNomMi/FJZEyMTSLjYnwSGRNjk8i4GJ9ExjQ7wnOdTOBHoerq6nAPgYi6wdgkMibGJpFxMT6JjImxSWRcjE8iY2JsEhkX45PImKojPNfJBD4REREREREREREREREREZEBMIFPRERERERERERERERERERkADEdHR0d4R5EJJkwYYJez5s3L9xDISIiIiIiIiIiIiIiIiKiXpQztuyG8ZDBlZaWori4ONzDIKIuGJtExsTYJDIuxieRMTE2iYyL8UlkTIxNot3L7/ejoaEBra2tcLlc2J66Vnl8bGzsbh0fEW0/1x6OzZiYGH295ORkZGRkwGTavU3u2UI/Ci1atCjcQyCibjA2iYyJsUlkXIxPImNibBIZF+OTyJgYm0S7N3m/ceNG1NbWwul0blfyXlgsrIMlMiLLHo5N+d0hv0Pkd4n8TpHfLbsTf/MQERERERERERERERFRxJHKe7vdrsm+vLw8JCYmblflbFNTE9LS0nbrGIlo+zXt4diUhH17ezuqqqr0d4r8bsnKytptr8cKfCIiIiIiIiIiIiIiIoo40jZfSPJeWl/v7rbXRBSZTCaT/g6R3yWhv1t22+vt1r2TIU2aNCncQyCibjA2iYyJsUlkXIxPImNibBIZF+OTyJgYm0S7d51sIZX3O2JHn0dEu1dimGIz8LqB3y27CxP4USg1NTXcQyCibjA2iYyJsUlkXIxPImNibBIZF+OTyJgYm0S7T2DN+x2tvDebzbt4RES0K5jDFJsxMTGdfrfsLkzgR6FPP/003EMgom4wNomMibFJZFyMTyJjYmwSGRfjk8iYGJtExtXS0hLuIRCRgWIzkMDf3ZjAJyIiIiIiIiIiIiIiIiIiMgAm8ImIiIiIiIiIiIiIiIiIiAyACfwo1K9fv3APgYi6wdgkMibGJpFxMT6JjImxSWRcjE8iY2JsEhmXzWZDNCouLtYL8XgZlS3CY5MJ/Cg0duzYcA+BiLrB2CQyJsYmkXExPomMibFJZFyMTyJjYmwSGVdCQkK4h0AGMG3atD229jltm0iPTSbwo9DXX38d7iEQUTcYm0TGxNgkMi7GJ5ExMTaJjIvxSWRMjE0i42ptbQ33EKgX+OKLL/RCe05rhMemJdwDoD2vubmZh53IgBibRMbE2CQyLsYnkTExNomMi/FJZEyMTSLj8vl84R4C9QIDBw4M9xCiji/CY5MV+EREREREREREREREREQR7rXXXsPUqVORmpqK+Ph4jB49Gn/729/gcrl6nGB0xRVXoLCwEHFxcRgxYgQeeughdHR0bPHY//3vfzjooIOQn5+P2NhYFBQU4IADDsC///3vLR7b0NCAG264AcOHD9dxyHjkuZ9++ukWj3322We1fb1cf/zxx9rOXh4v95WXl8NsNmP8+PE9vufDDz9cH7t06dJO+zzxxBMxYMAAff2UlBTst99+eOGFFzo9t7S0VJ/7zTff6LbcDlxkHAHFxcV66UqO6913340xY8Zoy3d5nSlTpuj3oavAa5133nl6+7TTTkNWVpYe97333hvvv//+Fs9xu936/ZD3n56erq8h45gxYwY+//zzHo8JGR8r8KOQ/OIkIuNhbBIZE2OTyLgYn0TGxNgkMi7GJ5ExMTaJjCuS1j2/8cYbNVkvSeEzzjgDSUlJ+Oijj/T+Tz75BJ999hmsVmun5PDBBx+MpqYmTSbL9ptvvonf//73WLVqFf71r38FH/v444/j0ksvRV5eHo455hh9jZqaGixevBjPPPMMfve73wUfW1ZWpslvSVJLMlsS7O3t7ZqgltuPPfYYLr744i3G/8Ybb2gC/4gjjsBvf/tbfb5MLJAxSuJ/yZIlOiEhVGVlpSayJ0yYgFGjRgXvv+yyy3QygkxmkAkH9fX1+PDDD3H22Wfre7v99tv1cWlpabj55ps14S/jltsB3SXsQ8nxOuywwzT5P2zYMFx++eWw2+36Pk499VQsXLgQd9111xbPk9eZOHGiTi6Q8chkh1dffTWYlD/wwAODj5Vk/8svv6zv7ZxzztHJCBUVFfj+++/1WMmxiVQxERSb3Ynp6G6aDO0w+SUg5s2bx6NIREREREREREREREQUJitWrNBrqfTe3SQJXFJSolXXMjGnf//+yMzMhBHMmjUL++67L/r27Ysff/xRE+3C6/Xi+OOP1+T5nXfeqcn8QHJaEslSlS5ruwcmGkky+Te/+Q3Wr1+viWlJgAdyY1LhvnHjRuTk5HR67bq6Ok3oB0jy/ttvv8VLL72kEwMCZKKAfE0S6JKcz83N1fsleX7++edrwlaS7JLkDyUJbJmQ8Mc//hH//Oc/O33tH//4B6677jqtUr/yyiuD969bt26LtveScJfJATK2wOSA0DHL++0ppRpI5svzAmSyhBxP2ad0J7BYNtdUy8QGSdDL8Z05c6Z+XwLPlZ8Zccstt3SaLCATLOR9y77kGAS6I0jVvVTfz5kzRzsRdP15NMrPX7T+XpmwEzljttCPQitXrgz3EIioG4xNImNibBIZF+OTyJiMEptywmru3Ll6UkyuZZso2hklPomoM8YmkXE5HI5tepx81pw/fz4WLVrU6doon0Gffvppvb7pppuCyXshSeV7770XJpMJTz755BbPkyR0aJeQjIwM/OUvf9HbUlkfSvYVWsEfEJq8l+MiiXBpXx+avA9Uu996661wOp1a6d+VVKB3Td6L4447Tlvqv/jii1usi/7cc8/pmE4//fRfXbPeZrNplbxMapBJC7vimMukg/vuuy+YvBcywSFwDLs75v369dPvUyip5C8qKtLJFwGyb5lQIN8f+f51FenJe8c2xmZvxQR+FJLZS0RkPIxNImNibBIZF+OTyJiMEJtGP4FKFM3xSURbYmwSGVdPa8N3JZX3GzZs0PXKhw4dqteyLfcbgXwWFtOnT9/ia0OGDEGfPn10rFIFHyBJ50B1eKjA2u8LFiwI3nfmmWdqe/iRI0fimmuuwTvvvIPa2tpuOwEEqselyrzrRVrhh1Y4h5Kq9e5I2/hTTjkFVVVVWqkeIFXPy5Ytw9FHH91pEoGQ740k66W1vawbH1jXXiYWiPLycuyM1tZWrF27FgUFBfoaXQW+D6HHMGDs2LFbVNML6Z7Q2NgY3E5JSdHlCn744Qd9zm233YavvvpKvw/RwLWNsdlb/TLlg4iIiIiIiIgoAoSeQJUTXXLyULalxWSkV6IQERERUXiSiZI4lc+eUsmdnZ2tk3OMkmSUhLmQ9d67I/fL52V5nFTCC0l6d5dIDlTwB/Yp/vCHP+jj//3vf2u7+gceeEAT4gcccIC2sd977731cYEJtZ999pleetLW1tbj63ZH1oJ/4okntOL+yCOP1Pvktjj33HM7PVba/8tkAEmGT5kyBYceeqhW8Mt7lTb28ryd/b5ty/EWoRMmAgLHvyuZUOH3+zvd9+qrr+Kee+7R5QgCLfflf6CTTjpJlxMILENAvQ8r8ImIiIiIiIgoIk+gyonTwAlU2TbKCVQiIiIiiizSxlwquWXiqKylLteyHdp+PpwkQS2kSr07lZWVnR4XWLu+a0v60H2EPlacc845mD17tibpP/jgA1x44YW6nry0f5d130Of8+CDD2r7954uXdvzC5kQ0BPpFDB48GC8++67mhT3eDx4+eWXdVJBIKEfIC3tZYxPPfUUvv76a51wcPvtt2sHABlruI73jpDuAzLu1atX6wSMF154Afvvv79eSxKfei8m8KOQzHgiIuNhbBIZE2OTyLgYn0TGZITYNPoJVKJojk8i2hJjk8i4kpKStulx/fv31zXKZf12qbyXa9mW+41g3Lhxei0J666k1fumTZt0rKHV37IWvLRn7yqwj8A+u5J9SNJcKuKlMr6hoQHfffedfm3y5Ml6HdjelaTSXibsSlW6TCCQCQhnnHEGrFbrFu9XBNrlh/rmm2+63XegE0F3Exq6k5ycjIEDB2or/jVr1mzxdWl1L8aPH49dRbo/yFIGsoyATGb4/vvvI3oJsaRtjM3eigl8IiIiIiIiIoooRj+BSkRERESRRZZpkmTsXnvt1enaKMs3XXDBBXp9xx13dFqbXhLS1157rbZml4r5rm644YZOXawkGS/7EOeff37w/o8//lgT/l0FKu9lMq2QVvrStv6tt97C008/3e1YlyxZEnze9pAOACaTCc8//7xehEwg6Kq4uLjbyQyS+H7yySe73Xfg+yhV7ttzzKWbwJ/+9KdOiX+ZWCAV/4HH7Cj5Ps6ZM2eL+9vb29Ha2qot96UbGfVOlnAPgPY8mUE0Y8YMHnoig2FsEhkTY5PIuBifRMZkhNgMnECVNe/lhKNU3kvy3ignUImiOT6JaEuMTSLjkrXYe1qTvCv5rGnUz5vSYv66667D3//+d4waNUrbqycmJuKjjz7C0qVLte26JJq7rtMun6Xl8ccee6y2pX/jjTe0/fvvfvc7TJ06NfjY0047Tddel/1IglwS11Jl/9NPP2HChAk4+OCDg4+V9dqnT5+uEwakff2kSZP0GEsXgMWLF+t4Zs2ahZycnO2uQD/wwAPxxRdfaPJ69OjR3XYJkLFLi/6TTz5Zq/ALCwv1NWUSwimnnKIV/F0ddNBBeP3113HCCSdodwFpXd+vXz+cffbZPY5HJkbI8ZW2/jKhQ54ny3rJfmSCgnw/5HjtKKnul44Gw4cP1/995P23tLTg/fff19b9V111lXYCiFRt2xGbvRET+EREREREREQUcXb0BKq0mSwpKWHin4iIiIgiyj333KMJ7UceeUQr1CUhL23epaL+j3/84xbV2rL9+eef48Ybb8Qrr7yileMDBgzA9ddfjyuvvLLTY++++26tYJ8/fz4+/PBDTeZLglte87LLLuvUxr5Pnz6YN28eHn74Ybz55pt48cUXtUI9Ly8PI0aM0H1L8n1HSMW9JPClG4C01O/OmDFjtIX9TTfdpGOVx0qCXboCSEK4uwT+RRddhLKyMj0OMglCniPLn2wtgS/H77PPPsN9992nkxbk/crEAnmtBx54AKeffjp2hkyUuPXWW7WTgLwf+f5kZGRg6NCh+v2QSRXUe8V0yDQY2mVkJpGQXz5GJbN9ONuayHgYm0TGxNgkMi7GJ5Ex9ebYlOS9nHSU1phSHSOtPqX1vpHanxJFa3wSRTLGJtHus2LFCr2WKuUd0dTUFNFVvkS9VVMYY3Nbf6/sTM7YtINjo15MZt8QkfEwNomMibFJZFyMTyJj6s2xKZX3kryXiiF5H3It23I/USTozfFJFMkYm0TGJUsxEZHxxEZ4bDKBH4WGDRsW7iEQUTcYm0TGxNgkMi7GJ5Ex9ebYlDU+pfI+OztbW17KtWzL/USRoDfHJ1EkY2wSGZesdU5ExhMf4bHJBH4U+vjjj8M9BCLqBmOTyJgYm0TGxfgkMqbeHJtSxSFt82tra+F2u/VatiO9uoOiR2+OT6JIxtgkMq7m5uZwD4GIojA2mcCPQqwcIDImxiaRMTE2iYyL8UlkTL05Nvv3769r3judTqxatUqvZVvuJ4oEvTk+iSIZY5PIuDo6OsI9BCKKwti0hHsARERERERERERGkJmZifHjxyM9PV2TKVJ5L8l7uZ+IiIiIiIhoT2ACPwqlpqaGewhE1A3GJpExMTaJjIvxSWRMvT02JVnPhD1Fqt4en0SRirFJZFxmszncQyCiKIzNmI5I7zGwh02YMEGv582bF+6hEBERERERERERERERRa0VK1bo9fDhw8M9FCKKst8rE3YiZ2zawbFRL7Zw4cJwD4GIusHYJDImxiaRcTE+iYyJsUlkXIxPImNibBIZl91uD/cQiCgKY5MJ/ChUVlYW7iEQUTcYm0TGxNgkMi7GJ5ExMTaJjIvxSWRMjE0i43K73eEeAhFFYWxGXQK/vr4eTz75JI4//ngMGjQI8fHxusbQ/vvvj6eeegp+vz/cQyQiIiIiIiIiIiIiIiIioihkQZR5/fXXcdlllyE/Px8HHnggioqKUF1djbfeegsXXXQRPvroI31MTExMuIdKRERERERERERERERERERRJKajo6MDUeTLL79Ee3s7jjrqKJhMvzQgqKqqwsSJE7Fx40a88cYbOPHEE3do/xMmTNDrefPmwagcDod2HiAiY2FsEhkTY5PIuBifRMbE2CQyLsYnkTExNol2nxUrVuj18OHDd+j50rU5NJdERMbgD2NsbuvvlZ3JGUfdb53p06fjmGOO2eKbmpeXh9/+9rd6++uvv0Yka25uDvcQiKgbjE0iY2JsEhkX45PImBibRMbF+CQyJsYmkXH5fL5wD4GIojA2oy6BvzVWq1WvLZZfX1lAZk10dwnMujCyOXPmhHsIRNQNxiaRMTE2iYyL8UlkTNESm/X19Zg7dy5mzpyp17JNZHTREp9EvQ1jk8i4pKMzERlPe4TH5q9nqqOE1+vF888/r7cPP/zwndqX0+nEu+++G9w+4IAD9Pqbb74J3jd06FAMGzYMH3/8MVwul96XmpqKadOmYeHChSgrKws+9tBDD9VZmKEf5Pbaay8UFxd3ep3c3FxMnjwZs2fPRnV1dfD+GTNmoLS0FIsWLeq0ZIC83qeffhq8r1+/fhg7dqx2IAjM+oyNjdXjsXLlSqxatcrQ72nSpEl8T/w+9eqfPREYA+PJuN8n/t6Lvu9T1/iMhPcUid8nvqfo/T7J60bae4rE7xPfU3R9n0RgXJH4fTKbzYiLi0Nra2un7n6SwO/fv3+nif295T1F4veJ76n775Pg94k/e4wnY/6OkN9h/L3H3+X8m7vrP0c0NTUhOTlZr5OSkvTrbW1twefLY2XJYXluYMVp+bwnz7Hb7botzxUpKSla9RuaOJTnyj4CjwkUicpryetI7ikgLS1NP6vIshkBiYmJ+notLS3B+2w2GxISEvTzZqDKOCYmRt+7PDfweUdsz3uSfT766KN46aWXsHz5cn1Oenq6/k4bN26cHrMjjzxSny+fr2TJ6VmzZunnrJ7ekzw2Pz9fj9WyZcuQnZ0dfE+VlZV48cUX9fu1dOlSNDY2aiGtdMSW363yWuecc47uL/CeNmzYoF8LJfvKzMzE3nvvjfPPPx8HH3zwFt8nt9sdfHxv/z7xPW3b90mE6/sk+5HX+bXPEfI+5OdpR8R0BF4tyl177bW499579RfGBx98sMP72Zn1DPYU+bApf/yIyFgYm0TGxNgkMi7GJ5ExRWJsSnJ+/vz5ekJRThDW1NToCcEhQ4ZgwIABqK2t1cn8crJRTiwSGVUkxidRJGBsEoV/reqe7EwCzkgk4Xj00UfrZCF5P0cddRT69OmDhoYGrFu3ThP148ePx/fff6+Pv+WWW3DrrbfimmuuwX333dfjfp977jmcd955OOmkk/D6668H7//hhx9w6qmnYtOmTTpBQJa37tu3r65bLp+pZTKmTICSz84//fRT8HkyaUMmxUpy9eqrr9b75HO2TOSQsYsHH3wQV1111W48WtQbNIUxNrf198rO5IxZgQ/goYce0uS9zCL673//i0jXdfYSERkDY5PImBibRMbF+CQypt4Ymx6fHz7/5voGU0wMTDE/X8sNACUlJXqiUSrv5cRjXV2ddraT5L1UdEilkVSJh1ZvEBlRb4xPomjA2CQyLqm8jQQvv/yyJsDl940kzyVBHkomqYZ2gLjwwgtxxx13aM7s7rvv1s+83XnyySf1+pJLLgneJ5X4Us0vE17vvPNOLaDt+nyZUPD222/jX//6V7f7lcSsTCII9cwzz+CCCy7AjTfeiIsuukirqil6xUdIbPbkl15vUUp+Ofz+97/HiBEj8NVXXyEjIwORTlo+EZHxMDaJjImxSWRcjE8iY+oNsen1+dHu8qKh3Y3KZgcqGh0ob/r50vjLZVOjHVXNTjS0OdDWbtdEfSBhL6QSX9p1SgW+nECU9opERtYb4pMoGjE2iYwrUj7fSUW8kGr5rsl7IZ9lDzzwwOC2TFqVJLxMXJVEe3dkiQKp2JeK+UBbe3HFFVdou/Lrr79ek+3dJf+l/bhU7X/22Wfb/B5k7NIiXSYGyCSBbfndKhdphy6dBOQ9SdJXllx455139DHSkv2uu+7C4MGDdbLuwIED8cgjj/S4z08++UQ7eWdlZenPhjz+T3/6U6eW7wGSc5SJDZJ/lLb+8tqjRo3SzgbSVaArmbAgrd1lOYg33ngDEydO1O+L5C1PO+00lJeXb/OxigaxERKbPYnqBP4DDzygv0gkYCSQZN2NaBC6XhNFH7/TicZXXkXlX2/GxiuuQNObb27xGNf6ErR++SX8rB7ZoxibRMbE2CQyLsYnkTEZNTZlBcFWp0cT8hVNTlQ0O1DZ5NDt+nYX7C6vJvWbnW402N2oaXPq16paHGjzWeCxJmF9RR1a7C6YzRY9hyD7lMp7OQFXVFSkJy+JjMyo8Unh56mpQeXNt6Ds7HNQcvIpWHf00Vh70MFYvd/+WDV+AtYddTTq/vMfeCoqwj3UiMTYJDKu7hKzvZGsIS9Wr169zc+5+OKLO1XZdxW4X6rhJfEspB2/JKAlWX3dddf96mvI+uY7IvB6v8bj8eCQQw7Bhx9+qMsInX322TrGE088EV988YW2+f/3v/+NadOm6fuQZP+VV16JV199dYt93XbbbTqpQToVyBIE0sZ/0KBB+Oc//4n99tuv07rr4p577sGnn36qEwYuvfRS3b9MZpBE/RFHHBFcj70rGc9ZZ52lkw8uv/xyzWHKeGSSBDt+RV5s9iRqW+hL4MjsHwkcmeEjs2WIIj1x3/Tqq6h78kn4auuC91uys5F24omdHtv02mtoePZZmBISkHTggUg+7FAkTZ0KU1xcGEZORERERES0c5weH5rsHrS7vWhzeuD1d8BmMSHWbEJirBUWc8/1DW6vH3n5hahpbEFdVSWqGkqQkhCLcZP2Q15GSrDyXpL3gROjRES9jSk+Hi3vvw9/e3u3X3evW4faBx9C7UMPI2HyJGRfdRUSxo3b4+MkItqViq//oFcd0NK7j9rh555wwgmaF3v00Ue1Ov7444/X9bn79evX43OOPvpoFBQUaKJblpQKnawqXaief/55TcBLW/uAmTNn6rXsu7tK/50hLfSl+l6q8EeOHLlNz6moqMD48eN1UkGgYluS+FOnTsXJJ5+sFfRLly4NrqX+hz/8QZfblmUDJLkfIEXAN998M/bZZx+dDBC69vqzzz6L888/X79+//33d0rEyzHrOtngL3/5iy5PIFX2oa8RIEsd/PTTTxg9enTwvjPOOEOXQZAJX6eccsp2HTfqnaKyAv/222/X5L38ApFfPEzeU6Qn7huefx5rDzkE1X+7u1PyXvjq6jttSwVJy6efbH6u3Y6WDz5A+VW/1+e3fff9Hh07ERERERHRzq5tX9vq0kr6mlYnWh0eJMVakJsSh/QEGxJiLVtN3gtJ9BflZ2HfcaMwcvgwDBgyHHn9h2LY2IkYM2kKfjNpHz0xJyc15YTl3LlzUV/f+f8sIiIj6fB44OtStWZOTkbatiQEOjpgnzUb8Pt33wCJiGiXGzduHF544QXk5ubqtVSgS4W3TECVZP57773XbZt7Sc5LzuCpp57q9DVJJMsyUsccc0yn7tZVVVV6XVhY2GNnbKlAD72UlpZ2W10d+Lrk86Rt/YUXXqhfk5b327P+ubxmaLv1KVOm6Of3xsZGndQQmowfMGCAVtMvWbKkU4X8Qw89pNdPPPFEp8cHWvtLsfCLL77Y6X7ZV3edAq6++upgO/7uSGV/aPI+tBvCjz/+uM3vm3q3qKvAf+655/DXv/5Vf/FIkAaCLpT80pKAi1TyC5oin/xRbXrtddQ98gi8tbWdvmbJzUX6mWfCVlQEW7+izs9zuZB69DFo+eRjeMo2BO+XxP/Giy9G5kUXIvv3v0eM1brH3ku0YGwSGRNjk8i4GJ9ExmSE2PT7O9Di9KDV4UWrywOHx4fkWAvibeZtbrcpmhqbsHHjRrjcbsTabBjcvwhp6Wk6MaDZ7kFtixPVtfUoWb0MdRUbYbfbtSJfTgZKpQ8r8slojBCfFF6ybOKmyy9H/JjRKLjnnk5fyzjvPCT8Zm9YsrIQExenVfnajdFiQfsPP6D57XfQPnMmrLKG8PjxYXsPkYixSUR7glRuS7Jeqsll7foFCxbotawHL5dzzjlHq8lDPy9L23dJmEv1u6zdLrm1QCJbyBrvXfMSoqfP3JJMLysr63SftK+XvFyo5uZmfT0hrynrwEvbeVkWW5L520qS7VJl35V0FpAJuFLo25VMPpDkvUxGCExEmDVrFqxWK15//XW9dCUdCWRCg0zkDfwPIN0CHnzwQbz99tu6dIF0PggcH9HTmvZ77733Fvf17dtXr+X/DNq55Rd6i8h+d92QgBQSfPKLojsHHHBARCfwJ0+eHO4h0G7W4fej+o470fjSS53ut+TkIPPSS5B20kkwhcw4CyX/mOX84RpkX3M1XKtWoeWTT9D0+hvw1W2u3K9/8im0//QTCu+9F7Y+ffi93IUYm0TGxNgkMi7GJ5ExhTs2vT4/6tvdaHF4NIkfbzUjOzkWpu1I3AeS99JOs7yiHE6HE3HxcXoiUdaglCR+ZpINrU4vFq8tw6aScqQmxGPQ4D5oqK/Dhg0bkJ6ezgQ+GU6445PCyz53LjZefgX8zc1wb9yI7KuvhjU/P/h1a24OrLnTu31u6lFH6cVTVQVPRcUWiRnXmjVwb9yE5OkH7vb3EYkYm0S0p0gS+tBDD9VLIFf25ptvaqW9tMSXBP9xxx0XfLy02Jc15KVaXFrHS8W9VMx//vnn+rXAfgLyf/670lNyOrTaXtZ571q1Hvq63VXmb6+e2vgHkr/dfT3wNY/HE7xPEvNerzc4qaAnbW1t+j+APHf69OlaMS//P0ir/OzsbD3+QvbT03r2XSv8Q8cU2hUg2iUlJSGSRV0CP9ByI5rNnj2bHwojnL+lBW0zv++cuL/kEqSd3HPiviv5Ryxu2DC9ZJx1Fir+fD3av9+8T+eixSg5/gTk33EHUg7r/Aeadhxjk8iYGJtExsX4JDKmcMamrFdf3+5CU7sHLq8PmYm2YIv8rtX0UsUiifieyGMleS/tNgvyC1DfUK/bcpJPntfc1KyPWb9qKdZtrMK40SPR7rcgJSMLDWtX93hCjiic+LczejW//wEqb7hB2+eLGIsFrnXrOyXwt4U1L08voXytrdh05VVwl5Yi87LfIvuKKxDzc4UmbRvGJpFx15SXhGwkJwqlul0q86VlvKzL/uWXX3ZK4Aeq7CWBL1X3ksCXdvpSSS4t7U2mzstRSft5IctKtbS0ICUlBZFA/gfw+/1oaGjYpsfLEgOSvD/33HO1q0GoysrKX50IQL8u0mNz6wu9UUSqrq4O9xBoNzOnpaHoqadgzs5CypFHYOCnnyDjrDO3OXnflSUzE30ffww5f7pW26YJf2srvHWdW/PTzmFsEhkTY5PIuBifRMYUrth0enyobXWivtUFj9+PjKTOyXuppl++YjmW/Xwt23J/T+rq67Bu3TqttpFEvc0Wq5X4MgEgdH8VGzegqXIDvv7mW3z340J8O2chXN6OTutsEhkF/3ZGH0mw1D32OCquvTaYvDdnZaHff/+LpP03J1l2Vs1992nyXtT/51FsvORSeNnid7swNomMS6quo0FycrJeh7Z4Dzj22GN1nXupwJfPxZKQlsS/VO13Je3qpSW+w+HAP/7xD0QKmaAs7euXLVu2TY9fu3atXp944olbfO2bb77Z5eOLRt4Ij00m8IkilLS37//qqyj45z83r1e2k2JMJmReeCGKX/gvrIWFSD7kYKSfccYuGSsREREREdHOsLu9qG1xoa7dhY4YID3B2qllfmg1/YABA/RatuX+7gSq9RvqG7B8+XKsX78eS5Ys1qobqd4P3d/gwYPR0eHHpvWrMO+n2Vi3qQoNdg9iEzefBCUiChdJ2Ff99a+ovf/+4H22gQNR/MoriB89ape9TvZVVyFx332D2+0zZ6L0lFPh/Xk5RiIiCr+XX34Zn332mX6e7UrWeg+saT916tRu27fLstPSvv3MM8/Epk2bdB36wPrwXT388MNaGX3XXXfhnnvu6dSKPkDGIRX6vcU111yj1xdffDEqKiq2+Lqsdy/dVAKKi4v1+uuvv+70OPm/4s9//vNuHy/1flHXQp8oEnnKy+Favx5JU6Z0ut9aULDLXyt+7Fj0f/stmYq3xXpnREREREREu4tUwpeUlGhrekmc9+/fX9eXlHXuG9vcaHS4YbOYkBK3eV3JUFI1L9Xz0grfarMiMyNTT57J/d2RBL3P60N2TjbcLjcaGhtgijHpmp7Sen/tunXB/clj01LT9KRdUVERkjNy4LclYmNNIwYP8iHOyjbSRBSe5P3Gyy9H+7ffBe9LmDQJfR5+COZd3M7Ykp6Ovk88jtqHH0b9o4/pfZ6NG/X1+z333C4pLCEiop0zZ84cPPjgg1pJv//+++tnaSGfrz/44AOtmJ8xYwZOOumkbp8viWtJxn/33XfBtvo9kTXfpeX+ySefjOuvvx4PPPAADjzwQP2sLJMAZMLAV199hfLych2HfL42uoMOOgh33303brjhBp3AKxMYZOzSxr2srEyr6uW4fvzxx/p4WWpg0KBBuO+++3R5gnHjxmHDhg14//33cdRRR+ltoq1hAj8KyS9hihzehgaUnn02fHX16PvkE0icOHG3v2Z3/+hJax3XmjWIGzJkt79+pGJsEhkTY5PIuBifRNETm5K8nz9/vp7ostvtSEhI0BaWg0eOQYc1CY0OF5JsFiTEdn+aQ6rm4+LjdB17Sd7LtVT9bCgrC35dThzK2vZCEvuynufo0WPQ1NgIu8OOmpqa4GNC9+dwOvQyoP8AbRkqj1m+thR1rS7UtbmQlRTLJD4ZBv92Ro/qv/+jU/I+dcYM5N9+G2Jstt3yerLmfc7VVyNu2HCU/+EPUloJ56LFqLj+BhTed692dqSeMTaJjCstbfPnw97uj3/8oyaeP//8cyxevFgT7E6nUyfESsv7M844Qy89Fe1JFytJYsvz+/TpgyOOOGKrr7fvvvti9erVePrpp/Hee+/hyy+/1PXjrVarTordb7/9cPzxx+OEE06AbTf9bdrVpHJexv3QQw/h+++/13XuU1NTtROBTGiQ4xeQmJio71kmMEgVvkx8kGP4l7/8BX/4wx/w6quvhvW9RIK0CInNnsR0dLegBe2wCRMm6PW8efMMexRLS0uD7Tuod+vw+XRdMWlNJswZGRj0+WcwJSTs2XF4PKj8y1/R8uGHKHrmaST8HAe0fRibRMbE2CQyLsYnUfTE5ty5c7Fo0SLExcUhOzsbtbW1aLG70HfwCBQMGKJV91urdA+sWS9t76VyXpL3TpcTcbFxmqiXZHxhQaFWC0mCfsniJbq+vVT6BxL+Uvk/YvgIjB4zutP+1q1bp632pVpfEv5ut0sfWzRwGIYOH46MRBuyk2MRa2ElPoUf/3ZGB+fy5Sg54Zc1dzMvvgjZf/jDHuuk2PDCi6i+445fXv/SS5FzzdV75LV7K8Ym0e6zYsUKvR4+fPgOPT/Q/YmIjMUVxtjc1t8rO5Mz5tTHKCQnPSgy1D32WDB5L/LvvGOPJ+9F1Z13ovmdd9DhdmPj7y6Ha926PT6GSMDYJDImxiaRcTE+iaInNuXkjFTeS/JeKnTSMrNQ3+pEQ9vmyntnW6sm3efOnafXkmAPJUl5Sc5LAn7kqFFaKSPJ+/SMdK2EkRM/koyXdvhCqugloS+vq632XS7dDrT3DN3fPvvsgzF7jUFOdg5qa2qCjx0+sB9MMUBju1ur8d1ef7CbgExImDlzpl7LNtGewr+d0SFuxAgUPnA/YhISkHzIwXs0eS8yzjoT6WedFdyuf+wxNL319h57/d6IsUlkXNJanoiMxxHhsckW+kS9VPusWah7+JHgduZvL0XygQeGZSyZF16I1s8+h6++Hv7mZmy8+BL0e+VlWHNywjIeIiIiIiKKLJJgl7b5UnmfkZmF0sp6wJaIhFgb3Pa2TtX1Uk3f3NwcrKYPkNuh28uWLtXqeqvNqteaqHe7g48d9XOiX+7r2mK/6/5KS0q1xb+02rdarNpWNPC1Rrtbk/gmUwwsnnYsXLBgi6UAxo8fr+1LiYh2lZTDD0fs4MGw5Obu0eR9QO71f4Z74wa0f/Otbje//TZSj5vBVvpERERE24AJfKJeyFNdg/Jr/yQLz+t2wsSJyL7iirCNx9a3L/o++ijKzj0XHXY7PBUV2HTZ71D88ku7bW01IiIiIiKKHv3799dEd1nZBixcuQ5+awLy8vIxbGA/rZqX5L3X6wViYlAh/49s2qQJq/3236/b/YWuYR9okS/bcn9PCX8hlf3yeqFJfSGv5/F64PP69Fq2ZU1G3Ue8FQ3tbrQ4PNi0dr0m72UpAHmuTEiQ7fT0dCbwiWiXix04MGxHNcZiQeG996HszDN1HPl/u4vJeyIiIqJtxAR+FJo0aVK4h0A7ocPrRcUf/6jV7sKclYWCf/5D/zEKp/jRo9Dn/vu0hT58PjiXLUPdY48j+8rwTSzobRibRMbE2CQyLsYnUfTEplSnjxs3DjHxKUhqdaHDZMHIQf00Qb5W1qBvaEBHRweampq0lWJzc4smxUeOHLlFEl4kJydrq3tZc9jn8yE/Lx+DBw8OJuS7E7rufWilv0wUkPukS0BBfoFOBpBtqd6X15avpyZIEt+DpnYnmtocGN23ry4FIEsCrFq1SsfSHWmvX1JSElzfUSYysFKfdgb/dkaulg8/ROJ++8GcmgqjMCclot9zz8KUksLk/a9gbBIZV2JiYriHQERRGJtM4EchOYlAvVftgw/BPnfu5g2TCYX//KdhWtUnHXAAcq69FjX33KPbdY89huSDD0Lc8OHhHlqvwNgkMibGJpFxMT6Jois2zfEp6D90JDLsbmQk2WAxmfR+qYSXdvRSzS5V73Iix+12a8W+VMt3V0UvFfJSLS/Je7PZDLPF3KntfXcClf5dE/VCEvpyX6Ad/9JlS7F8xfJOlfopSclwyWkYWyIqq2uRn5utY5Y2+rLP7pL30paf7fZpV+LfzsjU+vXXKP/jtbD26YM+Dz+EuGHDYBTmtJ5/r9IvGJtExiWfFYnIeMwRHpub/9ulqPLpp5+Gewi0g1q/+gr1TzwR3M6+6kokTjZWR4WMc85G/PjxmzekW8ANN6LD4wn3sHoFxiaRMTE2iYyL8UkUPbHZ7vKiye7RS4zbjhVLl2Hu3HlYsniJVtNLtb3d7kB7ezv8fj+Ki4s1MR5Y0767RHx6Rjqm7D8FQ4cO1QR6a2vrVsdQV1+HdevWoa6uTvdhs8Vq4l4E2vF73B5s2LgB9XX1Oklg2dLNiXyp3He2taK4bx+k5hSg0e7GypWr4HQ6UVRUpJX1XUnlfaDdvoxRrmVb7ifaUfzbGXm8jY2o/PP1usyiZ+NG1N7/AIxMuqW0fPwxHEuXhXsohsLYJDKulpaWcA+BiKIwNlmBT9SLtH72efB24pQpyLzkEhhNjNmM/DvvQMlxx6PD5YJr5UrUPf44si+/PNxDIyIiIiIiA+upXbzX59eEd7PTjQ5nG1atWtGpjX1hQSEKCgq04l7a1WdmZsFiMcNisXRa0z5AkvpdK+bXr1/fbbI/tGpfkvYN9Q2awE9PS4ct1oakpCTEmGL05JEk160WKzxeD2xWG/oP6I+ivkWdWuqPGj0KHt8wNKanIi7Gg6zk+B7b4stxkM4Cfbex3T4RRafa++6Dr7lZb1vy8nSteaPy1NSg6rbb0Pb5F4gdOhT933gdMVZruIdFREREZDhM4BP1IgV33YmUIw5H/dNPo+Dv9xh2/bDY/v2RffXVwVb6jS++hMzzzoMpwtckISIiIiKiHbO1dvE+WyJaHV6YTTGorKroto19n8I+mDRxUjCxL8l7Sex3t6a9JPUDFfOSvJdr2e4u2R8gyXtpuZ+dk61V9o1NjXC73IhPiEesLRabyjdpBX9KSgoSExKBBCA9PWOLCQIywaBffiaSUlKQlWhDdkosEmzdn5qR9yjHQdrsS/J+a+32iSg6ORYuRNPrbwS38265GZaMDBhVh9OJ9u9n6m3XqlWof+opZP32t+EeFhEREZHhMIEfhfr16xfuIdBOSJoyRS9GJ630Wz/5BKbUFOTfdhuT99uAsUlkTIxNIuNifBJFTmyGtouXpLskq2U7NikVhYNGwOHxIis5Fut6qJ53e9xama6Jdp9PK/J7WtNe9t/c3KzJfnluoIo/kOwPVNtLwt3l3Nwiv6S0BJVVlRg8eLAm8B1OB2bPmq3j9Pl9cDgcmliXSnm59vv8WLt2LcaNHbvFBAGL2YTkWDOaHG5YzDGwmU16X1dSmS+TGOQ4SOW9JO97ardPtK34tzNydPh8qLrt9uB20vTpSJ42DUZmKypC9lVXoebvf9ftun/9G8mHHorYAQMQ7RibRMYln++IyHhsER6bTOBHobFjx4Z7CBQFpJV+3yceh0laSsbEhHs4vQJjk8iYGJtExsX4JIqc2OyuXfzylatQ3+ZEssOD1HgrTDEx3VbPy5r3q1au0tb2NbW1ur/Wlla0t7Vj6LChyMrMQnJyslbIS1Je9iHJfWlpH9iW15VkvyTvZb16Se43NDToWvayTr1U3Le327VTwOTJk9GBDk3iNzQ2BBP2FrNFnyOvJ231HQ57txMEREKsBS6fHy0OL2wWD7KTt6yql7b60oEgPT19i2UFiPZkfJIxNb32GpzLl+vtmNhY5N54A3oDKfho+fBDOJcuRYfHg8qb/oJ+L/zXsF0m9xTGJpFxySRKIjKehAiPTSbwo9DXX3+NaQafkUu/cK5aDVtRX5ji43vdYTEnJ4d7CL0KY5PImBibRMbF+CSKnNjs2i6+pqYWiE2CF1bEWkyItZp7rJ43W8yoq6hHa1srCgryNeFeWlKKisoKTbBLor66uhpms1mr8222WH3c0CFDMXLkyE5V+lJ5H2jRn5CQiNUNq3Xd+4TEBHi9Hu0UINX2BQWF+njpGCBt82VygIzLYrXA4/Vg2NBh+rpF/fp1miAQSiYl1La60O4yIynWgnjb5vcYSpL1TNjTrsS/nZHBW1+PmvsfCG5nXnoJbH36oDeIsViQf+cdKDnxJMDrhWP+fDS+/DIyzjwT0YyxSWRc8jlPJoMSkbG0RnhsMoEfheSkAvUOfrsdGy+9FDDFIPe665B82GG9vprdU10DS7ZUpET3zOruMDaJjImxSWRcjE+iyInNru3iY2ITkZFbiOy8fCTH/XLqQpLgo0aN6lQ9X1dfh7LSMq3cl3Xnq6oq4ZSKdZsNSUnJmuiXxLtMEEhKSoLD7sCmTRv19To6OnR/geS67FOq6GMQg4WLFmLN6jXw+ryagB82bLi2xZfXiYuLRWFhIRITk9De3gZTjAl2hx3JlmQkJ6doq/3Q/XZHOgokx1rQ4vQgzmpGnNXU6//fI+Pj387IUHPvffC3tOhta1ERMi+8EL1J3NChyLz4ItT/51Hdrr33PiQfeCCsBQWIVoxNIuOSCaBEZDy+CI9NJvCJDKzuiSfgrarS21W334HE/afAnJSI3sjX1KTvp/GFF1Hwt7uQcuSR4R4SEREREREZRGi7+Da7E21+CxIz8lCUl7VFUluS4qGJ8SWLl2iFfFtNGxobGzQBLy3nc3JydA17uS0ndxITEuF0uvQ5Pq9Pq+0rKiowe85sTbYnJyVj9erVWLx48eZ2/DU1aGhoRIffr0l7Sdb3KSzU15KEvrTwL9tQpo+RNv45lhwMHzYcB06bFqzsl5b88jpdW/WHttK3e1xodXkQ7zRrVT4R0dY4Fi9G81tvBbfzbvo/mGK3XIbD6LIuuwytn3wK9/r1WsBSddvt6Pvof8I9LCIiIiJDYAI/CkkrQDI+98aNaHjq6eB2zh/+0GuT96Lh+eeD76fmgQeRfMghiLHy5FQoxiaRMTE2iYyL8UkUWbEpSfyMjAxUt7hQ2+qExRwDm+XXO3dJUnzEiBFaWV9RUYmmxkYkJiYgIyNdW+y3t7cjPi5eK/WFtNi3WqxobWtDW1srNm3cpJX1sna9tL+vrKjU1vtSnR8fH6cTAKQysrqqCklJiRg4cCD6FPbRrwtJ7hcWFiA/Px9Tp0xFWlqaJu0XLFyg1zJZwGQy6VhkP10r81PirGhyuBFvNSPRZobFbEJ9fb12DZDXluMpHQrYSp92Bf7t7P3ihg9Hzp/+hLp//QsJ++6DpKlT0RuZbDbk33E7ys48C+joQNvXX6P9xx+ROHEiohFjk8i42CHJOFpaWnDTTTfhf//7HzZt2qSTdBcsWICxY8eitykuLtbr0tLScA+l14qJ8O5lTOBHocMPPzzcQ6BtUH33Pehwu/V23OjRSD3+uF593DLOOw8NL74Ef3MzPBs2oPH115FxxhnhHpahMDaJjImxSWRcjE+iyIvNFqdXq9F9HR1Ii932Cb8pySna0l6S5EOHDoHZZNZkSGVVpa55b2+3azK8qalJT/TFxcahAx1aRW/6OWEu1fmynr0k8d1utybmpYq/ob4BPr9PTxi6XW7k5edphb0IbeUvEwnE0qVLUV5RjmXLlumJRXnM0CFDYbFa9H7ZDk3gyyQFm9mEVqcX8VYP4GrD/PnzdTkBu92urf+l3b90KGASn3YW/3b2flIMkXnhBUg5+ij0dgnjxyP1uOPQ/Pbbul33yL+Q+Hx0JvAZm0TGJZ/dIoEkimVS6Lnnnotnn30WvdF1112Hxx57DEcffTTOPvtsmM1m5OXlwYimTZuGb775Jjjpl3a91AiJzZ4wgR+FVq5ciWHDhoV7GLQVbd99j7YvvujUDq23rxlvTklB1iWXoOYf/9Dtun/9G2kzZsCU2Hu7CuxqjE0iY2JsEhkX45MosmLT6/Oj1enRS1q8bZsqKqRFfSBhLlXukkQvLChEnz590NraqlX3sh+pa7HarEhKTEJ9Qz0cDocm8gsKC/Ra9tPa2qLt8jv8HZo4l8do+32vDzGmGMQnxOulu1b+gVb5y1cs16S9TATw+/xobGyC3e7QxwwePFjHIgn/ru+hbMMG1LS6kJ0cC5OrFZWbNiAuLk7fT21trSbzZXkBJvBpZ/FvZ+Sw5uYiEmRfcTlaPvoIKYcdhqwrr0C0YmwSGZd8JoyP/+UzIIXP+++/jyFDhuC9997r9d+GL0LyP7RjHBEem0zgR6FVq1YxgW9gcsKo5u/3BLdTTzgB8XvthUiQftaZaHjhBXgrK+Grr0f9c88h+3e/C/ewDIOxSWRMjE0i42J8EkVWbDY5PNhYVYdNm8phhbfbNeO7kqS5JO+l2r4gv0CT84Eq99FjRgcfJ5UvUk0v1/KcxYsWa0JfnieJfknUC2mD39rWqol2qcL3eDwwxZg0mS7V+tJmv6qySvcRmrwPTCJYvWo1auvqkJqagsamRqQkJ8Pr88Lv92sSPjs7W99X8D2HPLel3YXy2HjA1QKzux0TJozXLgDyHDmmgTES7Qz+7SSjsRYWYtCXX8CSkYFoxtgkMi75DBbJScLepKKiAlN76dIxXcmyXLRzXBEem727pJcoArV+9jlca9bqbVNCAnKuuRqRwhQbi+wrfplN3fDkU/A2NIR1TEREREREFH5Ojw8bq2qxaNkKlK5diWVLl2o1uyS3JcndE6lmdzqcmlyXhLxcy3Zolbsk3eUEmZzckWr6uro6bZMvFRuSMJG2+lIxn5CYoO3qJakvEwAkcS6XxKRE3bfT5dSTRCWlJVrZ390kgqJ+/ZCQEK8nF+WxySnJsJgtOhFAKvGlij7Qar/rc4cOLIYl1oaahmY0tTu18l4mEch1YFxEFJ387e2o/Mtf4Fq7+XxRpIn25D0R0e52yy23aPt88dxzz+lk1cAl0E7/66+/1m157I8//oijjjoKGRkZm7tZ/bxOu9yW1vDdOe+88zo9NtScOXNw0kknabt7maAqn4cvvfRS/cy8LeQ1Zd8yGVfa0gfGHhiLvIfQ99JVd+OW9yn3y/t+4403MHHiRP3MLe/5tNNOQ3l5ebf7amhowP/93/9h1KhR+nj5v2GvvfbC9ddfj/b2dn3/sl8ZZ+C1u45XFBcX66Ur+R/i7rvvxpgxY3T/8n/KlClT8Nprr23x2MBrybGX2zLurKwsnXy89957a8cC6r1YgU9kIPIHqO7RR4Pb6WedBUt2NiJJ6nEz0PDsMzpJwW+3o+4/jyLv/24M97CIiIiIiCiM/wc12T1YvX4jGmsqkRwfiz4Fnavpe6rCl2p2WfdeHivJe7mW7dAqdzlBuKl8E2Z+PxMrV60MrmkvCXFpl5+fl4+s7Cy0tbVr8t3pdOnJt/S0dPg7/KiurtYTaenpGXrtdDrR2NC4xSQC6QAg+5OTkoHnyAk0OQkol7S0NAwdMrTTewl9rkwSKMhMR1V1EhLiLLA7nDrBQE7cFRUVBU+6ElH0aXzlFTS9/gaa3ngTGeecg9wbrg/3kIiIqBeRxLFMWn3wwQc12XzccccFvzZ27NhOj501axb+9re/Yf/998cFF1ygk1/l8+2OeuaZZ3DxxRfrZ+9jjz1WP5uvWbMGTz75pLbCnz17tn7W3RpJUMt7uPXWW9GvXz/dFt0lwLfXv//9b/zvf//TsR1wwAE62eDVV1/FokWLsHDhwk6TaEtKSnDggQeirKwMEyZMwGWXXaadtlavXo37778fv/3tb/Uz/80336yTCeRxcjvg18Yrk3cPO+wwTf5LR7PLL79cl/aSCQannnqqjueuu+7a4nnyOjIBYcCAATj77LN1koG8hxkzZuDzzz/XMVPvwwR+FJJfQmRMbd98A9eKFXo7Ji4OGeedi0gTYzYj+5prsOl3lwf/Cc049xzY+vRBtGNsEhkTY5PIuBifRMaPzfr6ej3RJclsOfklSeiu67i3ubxod3vhdLvhczqQWZgfrKZfv379FmvGh5ITgM3NzZrol8dK8r6woLBTlbskzFOSU+D2uLVCRbYTExPh8/m0Il8S8jKmoUOHoqWlJViRH5hc4PP5ER8Xj+amJlitFj1JJ+MT0h1gxYrlWLxkMRYuWgir1aonzGS/fn+HtueXyv9YWyxGjBiBwsJCLFm8RN+TTDJwOZ2dJiC0NDcgMz0NRYUFKMpOgw2eHo8b0c7GJ/UOfocD9U89vXmjowO2gQMQyXzNzah/8inYiouRduIJiBaMTSLjSkpKQm8nyW9JHksCXxL2Un3ek08//RSPPvqoVsjvLElsy37ktSUpLZ+FA7788ksccsgh+P3vf4+33357q/sJJOwlgS/72tr4t9fHH3+Mn376CaNH/7L81hlnnIGXX34Z7777Lk455ZTg/WeddZYmyyWJfsMNN3Taj0x0kJ8VqX6X8Ullvzx2e8Z677336nE64ogjdFKBxbI5hSuTACRBLxMrjj76aOy7776dnievJa8TOllA3sPhhx+Of/zjHxGbwE+KgNjcGibwiQzEW1OjbfOlMj391FMitoVY0oEHIn78eDjmzwc8HtQ++BAK//H3cA+LiIiIiIh2IUnez58/X9d+l8oRqSRvbGzE+PHjg8lon78DzQ4PWhwepCXEoi5h69X0XUkyXtpXSpV+ICkeSN6HJsoleZ+clIyM9AxNyktb/NLSMrjdLmwqL0d2TrZWy8t+5KSgVNK3tLboxIPsrCzdnyT1pTI/KTFJ30dpSSlWrFyBVStXoby8AvX1dZq4T0pOQn5BPpKSkvV5JlMMautq8cPMHzBv7jzpo4nMzM1V+bJPucjEgcAEhAGFBSgYMASD++YgLyUOFjNXPySKZo2vvgrfz8sPWvLzkRZSNRlpHIsWYcPFl8Df0qIdKVOOPAKmCF7bloiMo/bhR1D3r39t02PTTj4Z+bff1um+yr/8FU2vv75Nz8+6/HJkX/nLMrNi428vQ9vXX2/Xc3YXSfDviuS9+M9//qNLScnEgdDkvZg+fbpWvUsVvkx6TU7e/Nl5T7vqqqs6Je+FdAyQBL4sJRBI4M+bNw8//PCDHp8///nPW+xH/pfYWU8//bROOL7vvvuCyXuRk5ODv/zlL7jooou0c0HXBL50Jbjppps63SeV/NLZQN4D9U5M4EchmcEjrTPIeNJPOQUphx6KhhdeRNrJJyFSyR+hnGv/iLIzztRt18qVOqM82v8pY2wSGRNjk8i4GJ9Exo5NqbyX5L1UoUhSXdZyl21ZBz6QwJfkvVTgW8wxGFhchJqqcixfvlyT77ImvVSth1bT95TED21LL1XxS5cu1ap8aU8vSXFJxEtLSqmu19ub3Jrcj4+P0xNi8fEJqKqsgtli1ur8gsICpNnTtF2oVNNI232pupe2+rZYmybqZXJCSWkJvD4vhg0bipL1NlRUVsAUY4LVYtX75P16PV4dS1lpGTrQgbTUNMTvNSaYuO9T2EcvoRMQmp1ezJm/CEkmLzKT41mBT7s8Pql38DudqH/qqeB21iUXI2Yn2hgbXeyQITDFxsIvRS61tWh86SVkXnghogFjk4iMQiq9dxVpxx/4HSdV7l3V1NRoVyyp1JeW9OEga8V3Ffj/QybtBkir/0Bi3GTa9RNsZRLD2rVrdaKDtM/vSiY8iAULFmzxNZlUYDabu30fge9BJGpra9MlCyIVE/hEBmNOS0P2FZvby0eyhPHjkXb6aYgfNRqpx83Q1vpERERERBQ5JFEulfdy4kgS4dnZ2bqmu9yvX/f60Ob0ot3lQ2aSFW2b795pGzdu1IS5tJ6XteU3bNygCf01q9fo2vQOp0NPFNpsscjPz8PAAQMwaNAgLFy4QE98SSv9USNH6fOqqqr0BJ3FatmcRM/IRFp6OmpramB32GFvt2vb/IKCAp2oLEl4eX+S7K8or4Dd7kB1VRX8HX6t7pdkv9i0aROysrI1uR8bF4fRY0Z3moBQunoF1myqgsXdjtyU2C06FxBRdJB17321dXrbkpuL1BNPRCSTwo6sy3+Hqltu1e36x59A2imnwBymqkwiomiUl5e3SztyCWnj/muJ2HDpLgEcqH6X/xkCZCKw6NpJYFeRZcFEfn5+t18P3B8YR6iektjyPmT5L+qdmMAnorDJD1mThYiIiIiIIosk0KVtvlTeS/JermVb7hfNdg9anB4k2EywmEyaeJeK9IEDBwZb6Mv2smXLtFo9tEI9tOK+K3mcVN5L8t7pcmoSfumSpdrG3uv16kksv88Pr9ej+/f5fdi0aaNW2bs9HqSmpGJD2QZN9suYpBOAtM2XyQgDBw7StvtS1S9V9vK19tp2XfdeWvPHyXvr6NDtttY2OF0ueLwe7Toglf5ywk1eUxL70nJfTgB2XSJAXrOqqgIJsXHIKsiFr7Vhi84FRBT5/C4X6p94IridedFFMEVw9X1A2oknov7pZ+DZsAG+5mbUP/00cn7/+3APi4ginLSn76lFvXx++7UqX2mp37Wt/vbo++h/YBQyKXVrX5PP093pLrEsE1gDyWn5PL+7BCriuxtbd+PaEYGfgfLycuwOgWMl/7t0p7KystPjKPJxIbUoJNUEZCzen2eiUXRjbBIZE2OTyLgYn0TGjk2pWJd1F51Op1bey7Vsy/12t1db57tlzfhYS6fEuyTvpYJdriURvmr1KixfsRzLli7Va6mmlyp1uUir/blz5+m1bAtJiEuCXSYAVFRU6hr1rW2tkldHfFx88ASftNSvq63TtSxnzZ6NFrtdHydtJn+YNQuLlyzWan052Zickozamlqt0m9saAxW2ScmJMJitujrNDQ0IjsnB0X9inQdyvSMdGRnZSE5KVmXEZCJC/La8roOu10T/oUFhVssERCcgJCVDl+MBUlpGWhrtwc7FxDtivgk42t+6y14a2r0tjk7K6KXWgwVY7Ui+8org9uNL7wIX1s7Ih1jk8i4ApNPe7tAi/XQqvLtJRNKZbJpV7LPhQsXbnH/5MmT9fq7777b4dfc1nGJ7sY2d+7cXfIagffyySefbFNV+/Ye7+TkZJ3ILBME1qxZs8XXv/rqK72WrlwUWbHZEybwo1B362dQ+DiXL8eaA6ah4oYb4VpfEvXfio4eZvBFA8YmkTExNomMi/FJZOzYlGpxOcEkyWypvA+t6GlxbE7gJ8VZgveFJt49bo9eS9W7tI+XkzMDBgzQa2mPL1X5ksjvmtgvLSnVCvf29nasW7cOa1av1oofqcaRinuphtcK/I4OWBJSkJhbBE9SHmpj0mEtGInYojFotGaixhcPb1IekgsHoyM+DdnZucjIzEBWVhbMFjN8Xp9W7Mt4+vTpg3Fjx2K//fbF6NGjMHzYcEyaNAknHH8CJu8zWRP00r5SEvxyAk/a7U+cNBGTJ03GqFGjgt0EAhMS1q1bi7r6OpSXb0SMz4uK2gaY4xIj/gQV7Rn829k7dMgEo8dDqu8vvBCmuDhEi5SjjoStf3+97W9tRfObbyDSMTaJjCs+Ph6RQJLc8rlbOjvtqIkTJ+rzP/30007333HHHSgrK9vi8VdccYUuN3XNNdfoOvddycTWXZHcl3XsZaLsSy+9pP8/BMhk4Ouuuw67woQJE7DvvvvqRIV77rmn2+UCZMJyQKBz1vYc7wsuuEAn+f7pT3/qlPivq6vD7bffHnwMRVZs9oQt9KPQxx9/jMMPPzzcw6Cf1T36mPR2QfPbb8PvdKDP/fdH3bGRP0rt336L+qeeRtzIkcj98675o9rbMDaJjImxSWRcjE+i3hGb8nlfyMk0ObHn8PhRMGgETLGJiLdurkwRkuiWZLsk6JcuW6qPb21t1YS7rFcfqMpfv349NpVv0udIUjs5OQVr167FypUrYbPZkJeb16la3WQ2wRRj0nE4/Rb4kjI1IW5LTkNMvxFItMbhkIoViF2zGnZLLFphQ1tKPpwWC3ymZFR3JKGj3YrivkORHBsDU4cHsSmxwTb/8lojho/QdeylG4BMKAh0ESjqW6QTCuJi47TdvuhT2AcjR47stAyAJO9lAoK8dznR6LA7ULK+BE3NLYhNzUJBUSH69iveI98/imz829k7NL3zDrw/t8o1Z2Yi/dRTEU1iTCZknHsuqm65Rbcbnnse6WeeiZif1ySORIxNIuOSz6eR0LY8KSlJJ5lKwvzMM8/EkCFDtEr82GOPxZgxY7ZpH9dee61WoM+YMQOnnnoqMjIytJtVSUkJpk2bhq+//nqLyUlPP/20Jp3l86/8jyCv6/F4NLEtY5GltuRz/M6Q9eHlPf33v//F2LFjcdRRR+ln8A8//BBTp07FggULsCu88MIL+j5vvPFGvPnmm3pb/seQinmZ1CDvo7h482f2gw46CK+//jpOOOEEHHnkkZpslonNZ5999laP70cffYR3330Xe+21lz5P/ieS/dTU1OhkhP3333+XvJdI0BwhsdmTyP3UQz1i2z3jcK1Zg9aQ2WpZl16KaNT+ww/YeOlv9bZz2TJk/e4ymJOTEW0Ym0TGxNgkMi7GJ5HxY1NO5snJOWkhLydXli9fgUVrypC3oRaHTpuKmORf1nSXhLZUpEtlkFTQy8kqSd7b2+1YsmQxRo8eE1x/XkibeUney/r1Lc3NWpUvlfZyYmzokKHIy8uDw+HU6v/YpBQ447PgSy1EbM5gWDIKYE7KgN1sgau9HieVPN3j+3GYbfim71gsG7Mf2gcUAs1VGNk/A2arJTihQNred+0iEEjwy4nNQIK/J9LuU5L3MiFh1MhR2LBxg65/mZWZgaKBQ1DUtxCxibtv3VCKHvzb2TtY8/IQP2ECHPPmIfOC82GK8Aqz7qQeNwO1Dz4IX2MjPBUVev4s5cgjEakYm0TGFZiMGgkkwS3V8DJp6OWXX9b3Jt2ktjWBL0npd955B7fddhteeeUVJCYm4pBDDsGrr76Km2++udvnnHXWWZqMvvfee7UNvCS65XnSleqkk07SiQC7whNPPIHc3Fx9X//617906a6rrrpKq9lfe+21XfIashTY/Pnz8fe//12PwyOPPKL/50jS/o9//CNycnKCj73ooot08rIcJ3m8/J9ywAEHbDWBL5ORP/vsM9x3333aTeDhhx/WTl5y/B544AGcfvrpu+R9RIqOCIrN7sR0RPo73MOkjYaYN28ejEpm78gMKQq/ij//Gc3v/k9vJx14IPr+59+IRh1+P9YffQzc69frds61f0TmRRch2jA2iYyJsUlkXIxPIuPH5syZM/Ukl1TFlJaWYtW6Uqwoq0JGbgEmjx2BqVOmorh/58pyaSMvLfElmS2V95K8l/XnpYW9rAsp68ZLkl+q8KurazR539zSgg1lZVqFkZaejvz8PAwePBjr1q1HdZsX7Yn5GNPiwNnrv8df97kQG1LyOr3m45/fg75ttb/63lam98Wjk06DNTMRhVY7bO3VsHR4tB3+fvvv16mSXiYYSDJfxhvaKj+UPF6S94sWL9KJDmPHjkNGRrq221+4cIGeeBw1agwSM/MwuG8O8lPjYTZtXnKAaGfjk4zPuWIFbEVFMCUmIhrVPvQw6v69+VxZ3KhRKH79teCyK5GGsUm0+6xYsUKvhw8fvkPPb2pqQlralp/jiCi8msIYm9v6e2VncsaswI9CkdxSojfx1tej+cOPgttZv43O6vtAazSZUV550190u+H5/yLjnHMQY7MhmjA2iYyJsUlkXIxPIuPHpiThpQJeTnCUV1RgY1UjYqxxaGusw+JFi/UxctIlNLkt1eyS/C7IL9A29FJ5P3v2LG3xKSR5U1hYqBUXMilAkuVWqw0Wq0WT/PJ1qdxfu7EK5d5kxCek4U+rv8fo+s0ThveuXrlFAv/ZEUeisK0WCV4nEjxOJMrF69T7QhP7hW11KLFmwN1uxQqfFSm1G5HbUQdgDlrbWvX9SkJeKmyksqindvnyGFnnXq59Xh8qqyrRUN+gkxUGDBigVf2yLWTd0LTsZiTYTEiKzUNaQnT9n0S7Fv929i5xO5hsihTpZ56B+iefhCUrC6nHHgP4/cDPfwsiDWOTyLgCn0GJyFjMER6bTOBHIVmXg8Kv6Y03AY9Hb8ePHYv4vfZCNEs59ljUSGu02jp4a2rQ/P4HSDvheEQTxiaRMTE2iYyL8Ulk/NiUNpONjY26LuSqtaXwx6YgLTMNg/rmoqKiApWVlZrEDk1wd21D39jYAJsk6C0WTexL5X2g3efgQYP1ObJufFZWFnw+H+rq67Gp1Q+PLRfHNazD8eveh6XDH9y/JPLfGrx5jHEmPxL8bdiYlw0UjIYfZrQ5XaiurUOMNRZ+czxyaypwZMlsTKlYhM+L9obbbNXn+syxaMwdD097ORpXLcLqdeuRmpQAv8+v6933L+6/RVvH0Ar9devWaZI+OydbuwWsN6/XTgPSOt9sMuv9gWUD6msqsC4pGYW5WUiOs7IKn3ZJfBIZnSUzE/1efBFxw4chxhLZp7EZm0TGlRyFS70S9QbJER6bpnAPgPa8hQsX8rCHWYfPh8ZXXwlup5/BtUtMNhsyzvpl/ZeGZ56O+DVMumJsEhkTY5PIuBifRMaPzczMTIwfPx7Dho9AVkFfxMTGoX+fPPj9HUhPS9eEe2D9eEluS/t8qUyXtYAbGxq1El0S2sETNDExmvif8+MclJeXY/r06dhv3/10vUn598Hf0QFv3mgMSuiH++e9hZPXfhNM3ntjTHh90DTcPfggJNSvxBhrLSaktKM4yY+cJBtsPjuy4jrQ0VSOjoaNSGivQpGlGXUWF+4fMBnnTP8DXhs8vfObjYnBlLpNyE7oh43+DLS4Y3QdTKmqX7t2LWb+MBNffvmlvreua93LGp0d6IDb5YbH7dFkvXQQkIkIcq3bGek6icHjdMLv9aDd5UWb07vnvpkUcfi309hc60t0mUH6RfzoURGfvBeMTSLjstvt4R4CEUVhbDKBH4XKysrCPYSo1/bNN/BWVOpxMKenI/mww6L+mIj0005FTEKC3natWYv2b7+NquPC2CQyJsYmkXExPol6R2xKEn/awYdh1NgJyEhLR3VlOVxOp7bHz8/L14r7QGX68hXLsaFsgybAzRYzivoVaaV9fEK8tqUvL9+k1fZlZRuwavUq3b+sLy9t6rOzs1EeNwBH1tXjpnkvI8exOWkulmb2x+8mX4THbKmwV66E2dmCeJtJJxPsP3owxvXPRqqnCdUr5qBu1Vy4KlbB0rwJLaVL0Fa2BI7VM+GpXor4jgbEuza3thcj6ktw+aK3cPePz+NQtx8VCQMRk1aAmtpaNLc0a4v/NWvX6HuT9xhYHsBmi9Xqe5mosL5kvXYNkEr7gQMHYviw4Xot25LYl04E0pEgNSEWdrcP7W5vcLJzfX095s6di5kzZ+q1bBNtT3yScfgdDpSefjrWHXY46p9+Bv6fJzdRdGBsEhmXm7+PiQzJHeGxGfnTF4kMqPGll4O30046EabY2LCOxyjMqalIP/lkNDz3nG7XP/U0kg44INzDIiIiIiKineDzd8CSkIxxEyfDFNOBmqpKrbzPyc7R1vF9+/btVJlekF+gSWtJbmdlZull06ZN2LBhA9LS0nRteTlZI6355XlSmV9ZVYMVKMJZ5bNweNmPwddusiXiyeGH46MOC8z1ZYDbCbPPgY6mdtjaEzEsaxCG9c+Hsz0J3zaUoqq1Gv7GCsRJJX+9C36/H57KKlh8MbDGAj44kWCOhSsmGf6Csfjd4rdh/rnC/8IVH2FUw3D8a8ShMCMRWT4nCvMLEB+foO9N1jeWyQqyT1nrvrWlFU1NTVo5snLlCiQnJenxkAkL8n7lOdKBQJL3hQWF6N+vCL4Y/JzE98HV1oz58+frcZF9JCQk6DGRjgcyaYKIepeWDz6Av7lZL40vv4yMc88J95AMybFkKax9CmFJTw/3UIiIiIh2GybwifYwd1kZ2r//fvNGTAzSTj2V34MQ8g9qwwsvAD4f7D/+qP+YSbs0IiIiIiLqfaQifMmqdahucQImKw6cOhWtra1aiS7JbEnep6WnYe26dVqZnpycokl5h9OB6upqbY0/buw4pKena9W91WpFfHw8iouLdf/Sbv+n+QvwdpkV0zeu6JS8n5M7HA8NnYaa6lJ0OO0w+RyIcbbA31oLt8mH9jQTqkuz4WioRFlpmVbKS0I9JTlZJxJU11RrBby0xLf4vHA3bEJ92QqY4xKRkFGARIsb9+x9Cq5e8DZGNGyuap5UvQLZjibcOO4k2KzVyMlN1/dYW1OjY7VZbdr6X6ruJeFe3K9Y32tKSoom+KWbgBwPmagg212Pk9MjyXtppW/BxpISTd7L+PQ1amt1W44VE/hEvYt01Wh48aXgdvrppyPGbA7rmIzG/tNPqH3wIdjnzkXWlVcg+/LLwz0kIiIiot2GCfwodOihh4Z7CFHNWliIwoce1NnUptg42Pr0CfeQDMVaUICUI49Ey3vv6XbDM8+g8L57EQ0Ym0TGxNgkMi7GJ5GxY1Pbu8+bh6XrylFndyM9wYYOZ2EwSR0qtDJdkuaNTY2IQYwm8yWBP3TIUK0uj4mJQWZmFiwWMywWCyprG/F2dRoa45Lx3oBMTKpagdH16/FZ3wl4tHg8zI56xHna4HU0wNNcBV9bIzweN+IyMpGenobm5mYsWbwEpWWlmrwPyMrK1iS+MJvNWvFfV1ennQMSTEBWrBc5sU54rPX4+4RjcHTJYpy0dvMSYANaKvF/Sz/Affudgb0y4+FyOfW9yXuRfTocDl0iIC01Df2K+6GwsI8m+Iv69QseF03idzlGIs5qRqvTC7vLh1a7UyvvJXlvs9l0CYFVq1Zp5wKiX4tPMhbHgoVwrViht2NiY5F2wvHhHpLheKqqNXkf6GyZedFFEdXRkrFJZFwy0ZKIjCclwmOTCfwoJCcopGKBwiPGYkHKoYfqpSPC1+jYUZkXnI/WTz9FyuGHIe200xAtGJtExsTYJDIuxieRsWOzpKQEa0s3IcYahwH98uFqbQi2ku+anJYk9IKFC1BbUwt/hx/paemwxdo00S2Jb1njXipU5flSqS/J+5SsfDy21IfGn/fhNltxy+TzcWjJbHyeWYD8WA8ALzpSpO28Aw0xXjT6vPD7/IgxmTSRLq3q161fB6/Xq636vT6vjr+mulqT7ZJ4l9eV+7xeafufjWHDh+nJoqqqKpgdrUiPTcc3g4ZhU3IOrl7who5FJhFc/NM7eNJ2CsZY6tBYthxOp1PfV2ZWJuwOO2pqan5O6DthNpuw4ee1yUMr7ruTYDOj3e2F32TTKn6pvJfkvVzLdmDiAdHW4pOMpfHFF4O3U445Gua07uM/msk5opp774W3qgq++no0/+9/ugxjpGBsEhmXTOA0mUzhHgYRRVlsRu47ox7NmTOHR8cgYmy2cA/BkOKGD8fg779DwT33IGHcOEQLxiaRMTE2iYyL8Ulk7Nh0OJ1oanciITUD8LrQ3NyCxYsW49PPPsVXX32lle9NjZur3iVZLUnrjMwMjBgxAgMHDsTo0WP0hIy0kZevS+X+iOEjMHLUKGTnFeKJpV7UOTu/tgMx+CIjB8XJfkzdazAmFmdgSEEWCvLydd/SWn7zdYae8JF29lLFLpMK8gvyNTFvMVsQY4rRRHhiYhKSk5O1tT86OjTpL4l7qcaXZIvD3o5Miwv9YttQVZSFp0ccERzLvpVLcfJPH+DH1lRsaHKjtKQUZRvKdF17SeZLi/5ly5dj7Zo1KCsrQ2VVJZYtXYrlK5Zj6dKlwWPTVbzNDJfXj6z8QhT06av7ksp7uS4qKkL//v1357eXejn+7TQeT00NWj75JLidccYZYR2PUcVYrcg455zgduMLL+oEq0jB2CQyrvb29nAPgYiiMDZZgU9EhmROTg73EIiIiIiIaCd0mG0wxyagsqIcnrZGrFmzBpWVVZqolnb1A/oP0CR4oKW+VMBL4l4S55kZmahvqEdcfJxWpIe2la+vb8SfX5mHaz5/HF/03Ruf9/uNft3itSOpaS2yrW6MHzAA3voNKCstQVtbG+x2hya3Zb8ms0kT91LZ7/F4ERcbp0l6eV2pTJYEv7Tqj4+L1y4ABQUFmDVrlnYGkMS9rFkv10lJScjLy0NOTo5W8rvtLnwTn430QVNw/NrvdExHlM1BY2wyXs4di9iWZtTV1qKyohJmi1mr8QcNHKgJqJaWFvh8fgwYMEDfd0+dCoRJxmY1IcaWjKEj90J2Zoa2zZfxS/JeJikQUe/R9PrrgNert+PHj0fciBHhHpJhpZ10ImofeggdTidcMnFpyRLEjxkT7mERERER7XJM4BPtIa61a+EqKUHygQdqG30iIiIiIqJIJUnprPw+yChvxNIFP2HThjI4HQ5NSkuVe4e/A8uWLcPSZUsxe85s7DN5HxQWFqKwoFCT13K/VManp6drcluq1yXpvql8E94r6cDxC77C2Lp1eilqq8arIw/G8BQHsrLzkW5yorWqVCcMSPJe1q+XFvlerwcZ6Rk6eUAS9JK8T0pKREZGBhITEtHQsLkZf//i/khNS9WW9NJuf/ny5WhrbdN2+rFxcfpYqdI3m81a9b5u3Tr9urTfT41zY+mEaUj3ODCtbPNazXZrHLyZA+F2tMGx6Q04m+s1+d+//wBtfS/t/BsaG5CYmACrzaqTDKRKXzoP9ETa6DfY3TrxYPz4CTCZYvbY95aIdp0OjwdNr7wa3E4/k9X3W2NOSUHKEUeg+e23dbvxtdeYwCciIqKIxCxiFNprr73CPYSoVP/U0/oPhiU3F3k3/xXJ06eHe0i9hq+tDY4FC5A0ZQoiGWOTyJgYm0TGxfgkMm5strt9iE1MwbBhw9BaVwGXfXN7Q1n7PSsrC0uWLNWEflt7G6qrq3Vd+wl7T8DwYcM1uS7tECWBL5Xlq1evxjfffqMV85tsfTHN7sahGzYnx3WfCckYk9SOcYP7Ytpeg1BfXaFt+iVxn59fgLy8XE3CS9W8TAawWCya+C7uV4zklGRNpsukAtvPlf4yyUCS9xUVFfqasla9jNHv70BSUixycnPg8XjgcXvQUN8Ap8sJk8mM3Nwc5OfnoyDZi4ozzsOcZx34Ln80vijaW/dr6rMXULMRHUs/Qaxt8zr169avh8Nuh8/vQ31dve4ztPOAtNGXMUgyX7ZlmQGpyreYTbCaTHC4fWh3e5EcZw3L95p6H/7tNJbWzz+Ht7ZWb5uzs5ByyCHhHpLhpZ1ycjCB3/LBh8i9/nqYk5LQ2zE2iYxLOjQRkfHER3hsMoEfhYqLi8M9hKjjbWxEy4cfbr5dXQ0LWxpukw6vF1W33Y7m999Hh8uFQV99CWtODiIVY5PImBibRMbF+CQybmxWNTvR5vKgICdD160X1dU1er127Vo0NjboGvSSOLdarSgpLUFLawtSklP0vsTEzZXxUo0u7etlbWB7Uh+MzEnDhUufDr7W50V7o+o3v0EfixMjcuJRkJupl0WLF+nr9O9fjLi4OIwYMQLz5s3TtewTEuK1Vb3sOy09HbU1NRg+fAT23nuCJsxl/Xlpcy/t/etq67QyX9dZ7uiA0+lCTc3mZJvVYkF8QjxysnOQkJgAk8mE3Jxc2MwxGJxrxY9nXYovVzs6HZuE0YfA4qhDiq9O99/W1oqkxCRNysvkAuk8IO9bOhHIJAMZi3QkkAkOktQPXXJAqvDbXF69JMVadOID0bbEJxmHVJAHpJ98CmJ+nkhEPYsfOxaxgwfDtWYNOhwOtLz/PtJPO63XHzLGJpFxyTJFRGQ8sREem6ZwD4D2vHfffZeHfQ9rfvsdTUALWcssjutzbRNZasC1fh067HbA50PzW28hkjE2iYyJsUlkXIxPImN67a13tSrc7wfirGatGteEdFISPF4PHHYHXE6XtqG3WW3ail6S11Lxvmr1KpSWlWpbeqmYl+pz+VqzPx5ZRfvg+rkvwowOfZ1l6f3w3oiJyLY4Ma5/Dor7FQXHkBCfoK3uK8ortM19Y0MjCvILMGL4cEyePFnHJBe32xWsdhfyepIwT89I11b6UhlvtVo0yS7JeofDrkn0uLhYrdRPSEiA5+e1q6VbQKB6Pjk+FvsVJ2GEqQLo8AfHFWOxIW6voxGb0Qc+n1cnERQUFmgrfbfHrW36rRarHqf58+frMgByYkomHMi1jE3GKGKtZplTALvbB4fHt4e/y9Rb8W+nseTffgeyrroStn79tLKcfp1MVko75ZTgduOrr22eZNXLMTaJjEuWX4oEpaWl+jv0vPPO262vI/uX15HX21OeffZZfU25NhIZ07Rp03Z6P7IPTtaN3NjsCRP4RLuZ/BPR9Nabwe2000/jL9vtkH7qqcHbTa+9jg4fT0wRERERERmZ0wfYXV4kxpp1W6rFpWp87733xoEHHohx48Zh0OBBmpCWpLVU4ksVvrSPXzB/Ab766itUVVZp23tJ5JdW1SNuzPG4+af/ItHr1H3WxKfhn/0nIivOhcLEGBT93Fo+YPz48Rg4aKAm75csWaLXsj3twGk6mUCS7brOvMul25LMF9KqXqrdJbEu/8tJgl5a7stz09LSEB+fgNSUFK2ULCoqQltrm7bA37BhI8rLy7XdvnQQkP1lp6diZJITiY1rdd8prnb834/P49jqFWgrmICY2ETk5OZqC38hExUClf8byjZgzdo12pnAZouF1WbVMcnYZIwBUoXv+LkKn4h6H1ufQmT/7ncY8PFHsOblhXs4vUbqsccg5ueqO9eKFXCtXhPuIREREe1RX3/9teaZbrnlFh75CMUW+kS7mXPZcrjXrtPbMfHxSD3ySB7z7ZB86KEw33kXfE1N8FRUoH3mTCRNncpjSERERERkQE6PDy4f4PH5kZbwy7rsklwPJNjHjR2HWbNn4YMPPtDKHGlxL+3nJZFdXVOtCXNpIy9V9FU11ajImYybl7yNwva6za9htuKuIQci3uZAUXIafD4PVqxcoQn02LjN1fSSQD/i8CO0it3usOu+JKlf3L9Y2+RL9XzXdeWFbEsFvVTSS8V9DGJ0okFrSysyMjJ1kkFKairS09I3t7Z3ObXVfW5eHkymGGRlZesyAGLTpk26Nv1A1zI0V/tw1/zXkOFqxcTqFVhwwNVwFYxBTe0ypKcmaxcCac9fUVmhSf1xY8eiuaUFtTW1uhSAbAeq+wPdAkS8zYxWlxcOlw/ueD9sFtZpEPVGrKrbPubUVKSddBI6/D6kn3wy4oYO2U3fGSKiyFFYWIgVK1bo5+BIc/zxx2uXrfz8fBiJHG+ZELyznn/+edilSzFFFSbwo1Bubm64hxBVmkOWLEg59BCYEhPDOp7exhQbi9Tjj0fDM8/oduMrr0ZsAp+xSWRMjE0i42J8EhlPi9ODpLQMJG5lTXZJlu8zeR9tkR9IjpvMJiQnJesJrsbGRni9XjQ2NaIqcSBm1KzF+NpfqisfHHkEnPEe7DesD4r79sHSJUu0rbwk3Pv376/J/8Ba8SeceEK3rx9arR9KkvnyXEnOt7a2amI+qb1NJwBsbp0fhw6/H5VVlXDLBIDYWOw1Zi89IZqWno7amhqdRBBoxW+LtWHUkAFYtK4aDbHJmsC3+b340/yXce2US9FYugJVFSv1fSclJaLDb0JiYoJW3A8aNAi1tTXatl+6BUjyPrRbgJBjLEl8u8eHdpcXNgvXz6at499OihR5f7kJkYSxSWRcMrl0ezkcDsTHx8NIpOPVsGHDEIlkUoIRJybsquMtnb9o18Rmb8Kp2VFIZiLRntHh8aDl/feD26nHHcdDvwNC14Fr+/preKqqIvI4MjaJjImxSWRcjE8i41XfSyX4kOEjtbV7T6QCXhLcffr0wV577YXCPoWaiLbZbFrhLic8S0tKsanZDU98Mc5e+Unwua8OmormoixMHFygyfs1q1dj6dKlWLZsmSa5pTJFkv+ha8Vvj0C7/xHDR2CfffbBfvvtq9d5+XlITEoMtscfO3YsivsVIzcnVxP2cp/b7QpWyAda8Xu9Pl2bsTg7Hq+M2Q9u0+aTTIOay3Ha6m/gHngAvHEpsNvbUVFeoZME6uvq9TjI/gb0H4DBgwZj5M9jkrF1nXyQYDXD4fFqEj8S1oGm3Yt/O42h9csv4S4rC/cwyEAYm0TGFVjuaFuVlJTgiy++0Gsjkc5X8plb1qjvac36xx57DKNHj9ZJqzKx6JJLLtHPp935/PPPMWXKFCQmJuoE2uOOOw4rV67coXbvsjyVXLrz6quv4qCDDtLXkHHJ404//XTMnTs3+Jhnn31W9y/X3e1X/kf405/+pIlwmYArE2Xvueeebj87y30PPvggRowYoa8nE3WvuOIKPQ5bG2d3ZEyyfn0oOQZyvxyTN954AxMnTtTJvPL+TjvtNO0q1pXsI3RytHzPZGkyceutt+rXAhfZb7RI2s7Y7G2YwI9Cs2fPDvcQokbbd9/D19ioty15eUiYODHcQ+qVYvv3R8KkSZs3/H40vfEmIhFjk8iYGJtExsX4JDIWWYddLmtXLuux+l6S95JwX75iua7z7vP6NHEv68tLO3qvz6trwTvcbjQUH4SGhHTc+ZtztHp9dVof/C8xCfGOOqTE2bTyfvmKFairr4e/ww+fz49169ZpRX/XteK7G8eSxUswd+48vZbtAEmQS1v8xoZGOBxOrcRPTk5BRnoGklOS9WSmnPgbO26sPjZQIe9yuYIV8oFW/A0N9TohQY5GUnoH3h49Pfg6J6/+EiN8bviKJsLl8Wmrf4/Xo+9/6bKlur/Bgwdj+vTp2HvvCRg9ZnS3nQMsZhPMMTFwuH2wu307/X2kyMa/neHndzpR8efrse6ww1F65lnw/nzeiKIbY5PIuNra2rb5sTKRdPXq1Xp7zZo1ut1bXHfddXqRCbaXX365Jq6feOIJbU/flSSeDzvsME2in3zyybj00ktRX1+vE1931cQFSaRLolqS2osXL8YJJ5yAa665RicNfPfdd3g/pHByazweDw499FC8+eabOOKII3DRRRfp5/Prr78et9122xaPl/d+9dVXa8JeJjDIZIFPP/0UhxxyiO5rV/n3v/+Ns846SycEyGvKRF2ZrHDwwQfr/wFbI5Mlzj33XL19wAEH4Oabbw5etmeCQTTFZm8U2f0FqFvV1dU8MmFon596zDGIMfdchUJbl37aqbDPmaO3m954A1m/vRQxEdYihbFJZEyMTSLjYnwSGYeseW93+eD0+tHe1NDtYyRJ/uWXX2LN2jWIj0/QyhepMhdOp1NjuqG+AVaLFZZRB6EtefPyb3PyR+K3mcXIq1sGVC1DtT0GKbFmrC9Zj8qKSm2dL23npUKmpqYG8+bNw6DBgzQJP2jgwC2S3oFJBLqGvcOpifZAy315rFT/f/TxR1i3dh3a7e16Ak0mGciamtKaU8ZaU12ja9ZLhbzcV9SvnybtJXkfeL1N5Zt0LBUVFdqCf+iwodhUnI3Fm/pjTH0JzOjAtfNeweXTroKjfBkSsAEF+QVIz0jXChypuA/dX6BzgUxM6Ppa0kbf4fai3e3V5QuIesK/neHX+sUX8Le26m1vbS3Mad0v6UHbTiZByDm4xH32RdzQIb3y0DE2iYxre5LwUsUeSPLKckuyLZ95e8tEoiVLlgTbtcv7lomkX331FX788UetFA8kTSVhbzKZNJG+9957B/chCfYHHnhgl4xHJg8899xz+M1vfoPPPvusU4t8n8+nn/u3hXwWl0kJso/AsgaS6B4yZAjuv/9+3Hjjjbq8gJD385///Ee/NmfOHJ1kLO666y5NrMu++vXrt0ve38cff4yffvpJOx4EnHHGGXj55Zfx7rvv4pRTTtlqAl/GJsdHqvN76mwQ6by9aILMjmAFPtFu4nc40Pbdd8Ht1BnH8ljvhOSDDoI5M1Nve6uq0PbttzyeREREREQG0ebcnDyOt5rQXfG9JJ9nzZ6FH374AQsWLMTatWu1/b3NFquV93KCU6rx4+LjYc7uj7a88Z2e3+5sRUPzBnTYGzWBLhdhMpuQlZml7fjlBE5tbS3qG+rR3t6uSXlJ1IdW14vA+vRSRT9gwAC9DrTcl8fKCbM5c35EW3ubnnCV6h+p7K+oqNRKfyGPl8r7X6uQT0lJRWJiknYWkORMjKsV748chzZLnH49316Pc1Z+ho5BByA2JV2T99JCc+DAQZ32F9q5YNnP16HvLd5qhtvnh9Pt18kURGRcze+EFHvMOLbHjiW0bRpfeQVrpx6AmrvvQeNLL/GwEVHYyGdR+cwYSro09ZYk41//+tdOa63L+uLnn3++3pYEfoB8Vm5oaNBkc2jyXkgieVetRf/www/rtbT177pPs9msk2u31UMPPRRM3oucnBzMmDFD/19YtWpV8H5JiIv/+7//CybvhUzm/dvf/oZd6aqrruqUvBcXX3zxFsebohcT+ES7K7ji4zHo00+Qe8P1SJ0xA7G9ZKadUcVIW80TfmnX0/y/98I6HiIiIiKiaCItMaVF5syZM/VatgP8/g5N3ss67Ak2c7ct6mfPmY15c+dpe3hRU12NFStXaBt8WZNSqmjyC/IxeNhwuAcfggTv5gS98jhh2zAHjipZ494Bi9WChMQEXY9eTixKor2ttQ3NTc1aPVNQUIDJk/fRZHggMR8qsD59ZkYmrDarXst2XX2dJsVLSkt0fLIkZllpGZqamtHY2IT169fp6zicDuTl5ena9N2tSS/kNeW9jho1Uk8Ojh07DpmZmUhLTcOgIQV4b9IRwcceU/IDimxxcGUNw+rVa3TtUNfPExS2ZdKBkASgJPHtHi/aXb3jJDFRNPJU16B95szgduqM48I6nkgg59s6fq52bXnvPfjb28M9JCKKUqHV9wGBKvzeoGsyXkjHJ9EYstzL/Pnzg63bu5JE+9ixY3d6LDIZVz6Xy9JV48aN26l9yZi664LQ3XtbsGCBXu+///5bPH7y5Mn6v8eePt4UvdhXLQrJyQPaMyxZWcj4eS0S2nlpJ54I57LlSD1uBpIPPjjiDiljk8iYGJtExsX4JNozJFkvJ+o2bNigyXapEJeTSuPHj9ekdJsk790+WE0mXY/9N3v/ZosW9WtWr9GW8gWFBUhsbkZZWRlWr1qtJzVlP3JyTqpivm9Ox0krZ+GgjfNw/7hTsDBnCJLrlyOpoxnNfh+8Xg8sZotW4EslTAxitHJGqvdlWxL7/fv3h9VqQXJS0ua16d3uTu8nsD69VOpL8l6uZVvWvJc16BMTEpGZlanr17e3taOhsUG7CkiSvLKqEhnpGfoaUnnfXfI+dJKAtMSXSQLjxo7VsWRkZuixq8yyYUlGMUY3lMLc4cdFS9/DzWNPhqN0AWIrq/R1ZBJEYP9d9yfjDn1v8tiSsg1oaHMhNzUOe48YiKysrD3w00G9Df92hlfL++/JrCe9nTBxImx9CsM8ot4vfsIE2AYMgHv9evjtdjR/8AHSt9J22KgYm0TGFVqJvT3V9wHymU3WJd+Vyd899T4DY5bJtgHy2VvI5/fuyETXndXUtLnLVGFh4W77/m3ve5Oqf/nfZ08fb9q52OzNWIEfhXrLjC+irmzFxSh6+imkHnssTAkJEXeAGJtExsTYJDIuxifRnlFSUqLJe1ljfujQoXot23K/tJeXim+724uE2M3V96tWr9qiWryxqREOuyO4T6luD5CEvCTFW2JzENfsximrv0SOowl/++FxTK1fiqkD0zFuxGDdl8ViRVNzk1blyESCtPR0TfwX9y/GpMmTtGpF1sOUdveBxLwk7EPJYwoLCnVte02Cu1y6LRX7kiQfO26stuT3uD3a9t7v92tLe3l9OUlktpg7rT/fHamgl4r+ufPmYtWq1dptYOOmTVi0cJFOZqjYUIrXc/vAj82ts20+L2KtcTANnorGlhZdf3PZsmXBTgbr1q3V/W3YuEHHFfreAu31V69agdWrVmLR0uWYPXd+py4JRAH82xk+8vuy+Z13gtupx7H6fleQyVVpp5wc3G5+93/ojRibRMYlnxV3pPq+N1bhb4tAO3v5nNydqqqqLe4zmTanIntaTiCQOO+amC0vL8eeJB2+enpvklTn5+veF5u9GRP4UWjRokXhHgIRdYOxSWRMjE0i42J8Eu25EyNSeZ+dna1V7nIt23K/w+OD3e3ThHysZXMCX1rHd21Rn5iYiOSUZFSUV6CyskoTz4OHDMGwocM0wQ+zGTNrE/DHea/AjM3Z/cWZ/VEd0wZTe52uNS/rXCYmJqCtrR3l5RWaqM/KzNSTiPJ1aUMp1w6HExvKyoKJ+UArygBJvEvr+z6FfTQJHkgA2aybK/OlDb90BZC1MSWpL/sYNHAgxowZo2OVqqKszJ6r2yWh3tLaohMWSkpKMWvWD5g9ezaWL1+G+QvmY9nyZXA4HGgzO/Byv71xy6TzccN+l8JliQX6joM9Ngtr167FD7NmYdbsWbrevawzqvtbX4Kly5Z2em+h7fUHD+gHky0O68rKdYIFUVf82xk+0lHQtWat3o6Jj0fyoYeGcTSRJfWYY/TviHDMmwf3pk3obRibRMYln9t2tPo+QCaN9pS87m3kc7L45ptvuk3EL1y4cIv709PT9brr0lZCPvcGKu4D5H8H+bwuifRAW/s9IdCu//vvv9/ia/J53kjfQ+kIEO3V+o5fic3ejgl8ol2sw+9H7SP/gnPlSh5bIiIiIiLq9SQxLNXutbW1WkEk17It97c5vbC7fqm+Dwi0qA9Ui/cv7o9RI0dpEl+y/Tm5uRgxfDhGjR6tFTnr/Dk4aO1sFLXV6PPt5lg8lj8EjaVLsGTJYnzyySeor6tHUVERBg8ehJTkZK3GF+lp6bDbHYiLjdNkfr9+RRgydAhGDB/R4xr1gWpYIZMNpL2/JN2l6kYnLLTbMXTYUEyeNFkr8uW9yslFadkvEwm6TgoIJScmZRJD/wH9MWHCBO1YINU6koCX12ptbdWEfHp6Gr5MMGFOzhCZQbD5yWYrTMOmw2+yYfWqVVi+fLm+thw72V98QjwyMjI6vbdAe32ZKJEQZ0VSajpa2p2wO5y76keAiHaB5rffDt5OOfQQmJMSeVx3EUtmJhL33++XY/2/3lmFT0S909aq7yOxCl+W/JCE/EsvvYS5c+d2+tott9yyRTW9GDZsmH7Ofvfdd3USbmgC9qqrrur2dQL3X3rppVvsUzpkVVZWYlc755xz9PrOO+/s9Jry/bvxxhthJIF2/tIZjSKTsRfdIOqFHPPno+6RR/Qi65kVPfesVnPQrtXh88E+Zw58bW1I4ax1IiIiIqLdRtZ7l3Xb5eTQqlWrNHkvifSCvv20+t7t8yMtwRqsPhfS4n7Tpk16Yk0SzlIZL23pc+bnYM3aNYiPT8CgQYPgdrvgtSZg+Ton/rPq8+BrvjRgEjwdrSjIzoDb5daTZuZkM6bsO0XHUl1VjYrKCmRmZmilvCTvpbJJJg5Mmjhpq4l7EVq1LuvKyySDqsoqWKwW7TIg+5G1ShMTElFdU42GxgZNxMuJRzlhGagekteQ9yzbkkiXzgLS6l4S6tJyXzoQSDcASf6nZWxOttfX18HldKGmphZDCgvRVLMU9vzN1T7Cn94Psf0nAI4NOpEg0MmgqG8RvB6vtvMfPWb0Fu36ZYwZGZnwxlhgi41Hh7nz0gFEFD4dbjdaPvgguM32+bueLLfY/s23ervlf+8h67LLeD6OiHY7qX7+ter7APmsKp+rA5XTvVVSUhIef/xxnHrqqZgyZYpeywRXqVqXZZ2mTp2Kb7/d/Ps4QDpc/f73v8ftt9+uVe7HH3+8VrN/9tlnKCgo0EtXF110ke7z+eef1/8lZOKAdAKrqKjAl19+iQsuuEAnDOxKBxxwAC655BJ9fyNHjsSJJ56oY3/vvfd0orCMM7AcQLjJ0maFhYV45ZVX9P8X+f9M8lBnn302+vXrF+7h0S7ABH4UmjRpUriHENGa3303eNs2cAD/WdgNXGvWYMNFF8NbXQ1rQQGSDz4YMQb5w7kzGJtExsTYJDIuxifRnqvukFaZkriW6nRJesvJR8QmoanFiQSbWf/vCazF3tbaFlyPUB4rJ7vk63X19cjNzdUqcqlQr62p0UT5Amcuzlz2MhK8m59TlpyDWQmxiHc2weeL0+dKlY2shSkn0Pr06Qun0wVbrA2DBw3Wscn6mFJFL3qaQB2aaJc15aUKXirbJTlus8WipLRE23Xm5ebp6zldTr2W15TXlhO0ksBvqG/QJQSkKkcmJchEBZkMIEl7eT/y3uV5MilAku9t7W16ola6D8S5Pfq+5bkyfpmAMNJai/nuNvhsSbD6vBjaWIY1uWNR1OpGQmJCcD+h6953166/prZWW/ZnZedg2F7jkV3QZ4/8fFDvwr+d4dE+axZ8P7cHtuTnI4Hn5na55OnTYUpMhL+9He7SUjiXLEH8mDHoLRibRMYlnw97IknobW1hLo+VS29P4IuTTjoJH3/8MW699Va89tpr+plfEvezZs3C3XffvUUCX8hjZSLwE088oQlyWZbqtNNO0yT8iBEjtni8fKZ/7rnncOihh+rj5XXkc7ZMFpCJA8cee+xueW//+c9/tGPAY489hkcffVT/F5IJB3fddZd+9h84cCCMQH6O3n77bVx//fV6bKTLl3QY23///aMmgZ+4ldiMBDEdgZ5xtEtIezwxb948wx5RaUsSHx8f7mFEJL/TiTX7T4G/rU23i195GfFjx4Z7WBHH73ZjzZSp8P/cxqbo+eeQOHEiejvGJpExMTaJjIvxSRQ+Xp8flU1O1LS5kJVkg9kUgyWLl+h67VKpnpGeoQnnxoZGmC1mPakXSHBLElxOyEkSu8JpxZIVrXjwm4eC+7552MFYXLUcNvi0Il5O1Mk+5YSZnNxLSkzS/cga8FJpL2TiQGgSPfC1QBV+YHJB4DFSsS5Jb2lLL5XtCxYu1Er5on79MG7s2F/dDrw3mYggif7QjgJd3/PGTZuwadNG/T/cKf8zrlmj96ekpmLQwIHoV9wPDXF94VldhQuXvY9sRxMuOeg6JCd5cUSxGR0d/k7HLiU5BbFxmxP58voycWHzCWGfVvfLaZ4RYyfhoAP2RX5qPOJtvf8kMe06/NsZHhKXzkWL0PT2O7D17YPMiy4K00giW8UNNwaXKkg/80zk/eUm9BaMTaLdZ8WKFXo9fPjwHXq+TMzcWtW1fFaVz3i/Rj7PyudD6p3kM/yQIUN00sHLL78c7uEQfj02jfB7ZWdyxr2/ZJW226effsqjtpu0fvFFMHlv69cPcXvtxWO9G5hsNqQccXjErW3G2CQyJsYmkXExPonCp83lRbvHizirSZP3QpLi0kJUKmuk0l2q2iurKrWNvpyslJbykmj+YeYP+PDDjzDnxx/x6SYzLlv8TnC/s/OGY72/Hc7WRjQ2NaK1pRUWi0Vb5EuCWhLWRf2KOq0BL68lJ9Sqq2vg8Xr0WrYDbe67tsyXcUjFj6iqqtJ2pg6HXTsDSBJeKvITExPQbm9HQkK8bsu1bMv9oRX7cpH1TJubmjRJL/fLSaS+ffvqGEeOGoUDp03DwQcfrBMQrFabVg2NHTcWRxxxOAYNHqyTHQ4fnY8z1n+FgvZ6WP0+TeSXIQtuaxL6FPbR/ci1kIT9sqVLdbLEqtWrtJOATEIYOnQIhg0brieRK8vLMG/hEmyqqt3jPxtkbPzbGR4yaUkKPPJvvYXJ+90o9dhjOnU96E11a4xNIuOSz59bE+g49WsXJu97B/n/QBLDoaT71tVXX623pRqfekds9nZsoU+0C7V88GHwdsqMY9k+fzdKnTEDTa+8qrdbP/4E/ptugikubne+JBERERERaaVDB9rdPtjdXsS47FiyplyT97Nnz9Z15IUkxSXR7fF4dFtawEulupwQW7BwgVYpmfpPwj7O1RjWuEEf4zGZMXufg3BAXDt+dNfrCRlp2y/ruvfrV6Rt8iU5npWZ1WkNeHltSaRbLVY0NNTDbDKjrq4Wxf2Lg4+RtvlSxS7r3QfWk5f9Z2Rk6JryycnJ2hFAKug9bg/a2+1ITEiE3e7QbbmWbblftmVNe1mfXu6T8cj7qa6q1tb+ubk5W4wx0L5/0eJF2LBhA8aOHYeMjHTdlxyr+IQEtJx6BvCvu/Xx+1cswTu1ZZiZlIfRA5Kx115jtMOBJO/l5K+8D+kCsGbNWrS0NGvlZkJ8Aqqqq3QJA0lZdZht8NhbkBpvQU52Fn92iSjiJUyciLSTT0LStGlImjKF5+WIiGi7PfDAA1phP23aNJ14K/+/fPHFF7ps1hFHHIGTTz6ZR5X2CCbwiXYRX1sb2r//PridetRRPLa7kcxct/Yrgqdsg3Y9aPvyS6QceSSPORERERHRbtbu9mryvr2lFSsXz8Xy5ctRVrYBTY2N2hpUNDQ2wBRjQmJSoib8586bq0nuVatWw+vxwpqQirbi/RG3cT4cZhvifW78r3gibAl+wOPRCnZpcS/rxMs6k5I4T09L1zVGJRkfSlrWSzJdXrugsAAl60s0uS1tCiWRLvuSdvPSgj50PXlJ3kuVvCTapZV9oMW+JNSTk5IwcNBArfzvbjtQsT9mzBg0NjaiprpGnyvjlfb98pqhpFNAoJ2/1WoNThSQcUiFj7Tnt8MFV+FwTC7f3I7xzFWf4a+ZF2LWklXoV1S0xSQEqfZvbW3RiqDS0jLtAuDz+zB48GCMGzsOTXY3NpRXYuXa9UzgE1FUiDGbkX/77eEeBhER9WKHHHIIFi1apJ1RpNOVdAOT1vlXXXWVVuFLVx2iPYEJ/CjUr1+/cA8hIrV99RU6fj6RFDt8uLbQp91H/lCmHnss6h5+RLeb3/1fr0/gMzaJjImxSWRcjE+i8Gh3ba6+L1u7CvPmzkNbe5u2bZdrWbO+orxCk+2bysv1c3tsrA81NTVaHS/JblkLvn3gNHRY4vBB/30xO28kTln1Od6x2JDy43dIS0tFSnIykAA0NzXjp59+QmJiYrD9vSTjQ6VnpGsyPdYWq9XtrW2tWjEvVe/SZl4q66V9vSTWAwl6SeaHJtoluS4t+aW9qSTK5TWkKr+1tbXbbbm9eXmAKsg5PKmAl7b8gwcN1v0IqZgPPFdeR15DrmU8gXFI8l46E6AZur/VeTn4TcUqmDv8GFe7BoMayzHTFI8RS5bAbDJ1moQgXQB8Xp92E8jNy8PSJZsr9GWSQ21NDbwwobndgRa7Kyw/J2RM/Nu5Z/na2tH62WdIPmg6zCkpe/jVqTdhbBIZl63LZ0+KbAcddJBeyPhsER6bTOBHobFjx4Z7CBGp5aOPg7dTDv9lfXbafUIT+G3ffw9vfT0smZm99pAzNomMibFJZFyMT6I9z+nxweH2QZaFrK4qR01tLQoK8rX63eV0oq6uDrNmz9JEuNPhgMNuD677KbebYprgjk+HPXtEcJ/18al4YcAExJV8A2u8GdlZWZqsd7vdaG9v18kBUv0i1fTSQl+S56Hk/gH9B6C1rU23G+obkJeXi8FDhuh+JFkur981QR9IqndXJf9rsjIz8dHHH2m1f7u9XVvp9+nbB+PHj9evSzX/mjVrNClvlorQ/HxMnTJV2/qHjkMq7yV5L5MQJAm/xLwYMzcNxNTqNbqf01Z9jrv2PR/LN1RhdHFBp0kIjY0NsDvsiIuPh9ViQX5BvibwZakBWfdZ9m9NykRLmwMenx9Ws2mX/AxQ78a/nXu+2KPyhhtQabUi44wzkHvD9Xt4BNRbMDaJjCshISHcQyCiKIxN/vcWhb7++utwDyHi2+enHH5YWMcTLWx9+yJ+woTNGz4fWj74AL0ZY5PImBibRMbF+CTa89pcm9vnJ9jMne6Xivuk5CStRJ/y87rD2dnZmnxvbGpEU3MT0tLS9P62vvsCMb+cjjD7XOjTUQ2b34XExCRtAy/Pq6is0ET3+AkTMH36dAwaPFhb2EsVfChJxEvbeFl7XhLXktAeOnSoTiyQSnVpOy/JbEnOS7v8vfeeoNfbmqzvjoxBxlLUrx8mTJig14GxyVr3kryvqa3RCvnq6mosXrQY3373rXYFCB2HPE8mJcg4MzLSMXr0GMzMSIEfm1tzTqpegT6NlZjfYIM1NlaT/9L2v6hfkVacmE1mrF69CrPnzMHcuXP19X0+vz7XFBMDM/xwdwB2l2+H3ytFFv7t3LNaPv652MPjgTk9fQ+/enTzu91o+ewz1D70MHoDxiaRcXX97ElExtAa4bHJCvwoJO36aNdqn/kD2+eHsQrfMW9esI1+xjnnoLdibBIZE2OTyLgYn0R7ltfnh8Plg9PrR3a8DX0K+2ir+/Xr1mtiXpLkmZlZyMnJwfDhI1BWWqprwre1tmmyubS0FE1IQl9bElztDahJzND9FviqkORrhcNi1op5eb604W9qatJW+AMHDkR8XDwKCgq1Nby8TqjQ9vciITEBKSkpmlCXdvPSdr5r2/1tIcl2ScZ3V7Ev90nifdzYsboevaxnL1XxgbFJ5b0k72UywaCsTKxbtw6VlZW6v9CJA7Lf0Lb4UlXfnhyPH7P7Y3Lten3Mqau/wL3pZ6LZYw52CZD2/Hm5edqlQPZbU1OBlpYW2Kw25ORko6CgAAkJiWhtt8NkiYXd40UqrDvx3adIwb+de46vtRXt334b3Gaxx57jt9ux9qCD4WtslDUYkXbySbDm58PIGJtExiXLExGR8fgiPDaZwCfaBZIPPQT933lb2+jb+vbhMd2D5B/g6jvv1AkUzuXL4Skvh7WwkN8DIiIiIqJdrN3l00RwnNWk1d2FhYXIyMzQSnlJtCckxKOoaPOa8qmpKdoW3u1ya5v3pvVNm9d633cGfrfoLYysL8XHxZPw1pCp+E3feKTHDMKKDg9SklNQU1Oj+/B6vXr5/vvvkZiYqMn9AQMGBJPxkmBftmyZto0XMqFg0sRJW13rflvJvqUNvuxHKvhlP5JckYkCkkDvmnjvOlFA2ubLcgKSvG9vt2uHAlkOYPmK5Z0mBMhF9isV+8uXL9f2/5KUn1dUGEzg71+xBC+01OGHyjQc1NGhxz4wgSA3J1cnOhQVFelxs5gter8k7+V7EBcXC6vVCqfbr8sfxFk7d04got2n7csv0eHx6O3YEcNhKy7m4d5DTAkJiBs+DO0/zAI6OtD8/vvIuvhiHn8iIiLqNZjAj0Jy0oN2Lak2iRs2TC+0Z5lTU5Fx7jl6nXL00bDm5fXabwFjk8iYGJtExsX4JNpzpDV9u1va5/uQlmANtiyUxPTYseOQmJigiWqz2QSPx6sV55KUlvb57W3tGq/xfUdiREwHxtat0+cfWTobJWMn4IDx42Ezb24ZL+vYy76kql+S9h6PR5P4UrkuSXG5Lzk5WRPss2bPwry581BTW6vPzcnOxoS9J2D4sOFbXet+W8jrSfJexl2QX6AJetmW/cq+Aon3wEQBv9+vbf+ljb2QZL335+Mgx0iWBfD7/Ni0adMWEwL69OmD9SXr9f21tbfp/dasbMzP7Ifx9WVwmy0Y2FSO70tysaK0GiP75wUnEDQ0NiApKUmPi3QdkO9Tc3MLNpSVYcjQITp5obiojybvHW4m8Il/O/ckKfIISDniCP747WEpxx67OYEv34v//Q+ZF12k5++Mip9riYzLyL87iKJZTITHJhP4Uejwww8P9xCIdqmcP/4xIo4oY5PImBibRMbF+CTacyRxLxdTDGA1m3psI7902VKsX78ODodTk++S2HZ73Igxm2AZPB3nLng9uM+visZj6JiBGFhcpNuBhLgkuFNSUzT5n5WZpe2PJWEureIlyS0TB+QiFeutba261r2QSnS5TyrxZY357SGJb5+/A7L0fKDCXcYhyXt5b1JlH9oiP7Rtf119HVatXKXJeqmCl2S9JGIkoS4XkxwvWY8+zqzbcru8vFyT+ZKwt7fb9b3FIEa/Xl9fj9WrV+Pt2ASsHTQNbw0+AM2xyYAP+M8nC3DOhGx4XC597Jo1a7GhbAMsVou2zZfjlZaWppMCRgwfocctKSUFDXY3HB4f0jo6Iv5EF20d/3buGb6WFrTNnBncTuG5uD0u5ZBDUHXrbehwOOBasxaulSsRN3w4jIqxSWRcgWWaiMhYUiM8NpnAj0IrV67EMFaKExkOY5PImBibRMbF+CTac9pdUn3vRYLtl9MI3bWRt9vteruyohLx8fHIyMhAh78DvswBGG9vxLDGDfpcj8mMFZOm4qIJI4PV8YGEuCTJpcre6XRqUn/QoEFa3W+KMWmSftHiRdoWXtrN22w2pKdnSE5cq94lGR5Isv9awt7j64DL64Pb64fX3wGzKUY6LcPf0YE2nxkeawJKqxuQmZ6OtpYGxMb90iJfhK5HP7P+B9T+3AlA9i3r0csYx40bhxEjRmLdurWatJduAvI4h8Oh1/oeYm2oqqqC1WqD3d6uFftyHJfaW7Bi+BC0S/L+Z8uaLZi9aCVyk606mUGWLUhOSUZrS6vuL9YWq10I9pm8T6euAzIpQRL4To8f8Ta20Y9m/Nu5Z7R+/gXwc/v8uFGjYNvOZTxo55mkY8tBB6Hl/fd1W9roGzmBz9gkMi753Cafa4nIWBwRHpubp81TVFm1alW4hxAxfG1taPjvC/BUb16jkWhnMDaJjImxSWRcjE+iPUOS3FJ97/X5EWf95TSCVHdLi3ZpHa/V6S6XJtQL+xSiuaUZtTW1m9u7JycBww/BOct/aSf95YBJGDKiCBvKSjQBLi3xJeEslfN77z0B06dPR//+/TVpL5XtzU1NaGpu0rb0GzZsCFavSyV+Y2MDGhoatOI/ITGhU5J9i/fi8aGx3Y3qVhdanR6gIwZJcVbkJMchLyUe+ambL2OHFGNo3zxYfU5UbCyFw+lGUnYBUrLydB+d9ul2a+W90+XSCQiyHr0ch7a2Nq3El/cj1fCS2C8tLdWuBdLyXlrqV1ZVwu1y63F0Ohw6QcHusOtj5GJZ9w1iOvzB1/LAgk3WPrDZYrFo4SKsWL5Cj1FmViays7MRnxCPlOSULZYMSLCatYW+LINA0Y1/O/eMlo8/Ct5m+/zwSTn6qODt1o8/0d/DRsXYJDIu+YxLRMbjivDYZAU+0U5o+/JLVN95J6rvugtpJ5+M/Ntu5fEMM9e6dWj7+htkXHA+W0MSEREREe0C7S5J4Hu1cju0/bokiaVVuySvm1zNmowuKyvTjm/l5RUwmWL0a+7MwZjcVIGBLRX6PKfZipL9pqGgoQLLKjuvBx9IPMv11ClT9ba0l5cKdWkx36dvH4wePUaT9o0NjWhpbUVFRaU+Lic7GyNGbG4b35VMPmhxerW6PjHWgjSzDTarCbEWuZj1WsYbUJAWj7wUG9aVZKDN7gLMNmTnFyIuKQVtbi+aHR4kxFqQaDPrhAGb1aonkKR9fntbOyxmS6dEkYwpPT0dZWUbYLO1a6VIVnYWqqurteW9JO2lal+q9CXpbzZbNKGPtnYk1K+GI2uY7ifW68LCWhtSajfgh1mz0Nraoq30k5NTUFTUV/clnQK6irWa0epyaRLf7+/o9F6JaNfyNTUF114XKYcfxkMcJkn77gtTcjL8ra3wlJfDuXQp4kdv3xIrREREROHACnyindDy8Sebb3R0wFpYyGMZRnJyrOyss7H+qKNR849/wLlkCb8fREREREQ7SdaFl/b50n69a+t1qZqXSnhJvkuL+KVLl6JkfYl+rbb2/9k7D/g2rivrH/TOAvYiFjWqF0u2JVe5xnaKE6dtEqd8STbJpve2G6e3TbLpvTrJpjjZ9GI77rIty1bvFCn2TqL3Nvh+94KAQIqUVUgCIO7fhjAzBGYGb/AGM+/ce+4Yi9Nenx/hpu149fHJeycAD6++BmZLEhaTAUuXLmXBenBoEP39/VPW39Laghc8/wW47dbbsGXLFtTV17F4b7eXo2lJE2f6b9q0EVdeeQU/rrvuujOs42n/vaEYHIEojDrNZKa9EfXlJtSUGFFm1vPnmknQrqysxOWXXoobrr0KN1x1Gda21qO2NJWpb7cYEIsrvN66hka2+bdYzBxMMDZppU+Z+I0NjTxN+9S2sg3NzU1cVqChoRFlpWUwm8wYGR1BLBrjkgEElQKIRMJQqVUwGo2wDT2NGt843n7g9/jFfZ+BLujHzh4/JibGOWggGo3C7/ex/TK5E8zkQEDlAfQaNcLkpjDNQUAQhLnF9+CDQDzldmHcuEHGi3KISq+H7cYbM/Pef552ghEEQSg2yAmKgnFf97rXzet2aP20HdreQvGzn/2Mt0nP+chdd93F1/XT73dyzSOPPMLt9olPfKLgv3fnCn1W2h/67GkoiJoCrD/2sY8hn5AM/CLk2muvzfUuLAoSPh8CO3dm5iWiOrfQSVfX1ATs2ZO5KTNt2IBCQvqmIOQn0jcFIX+R/ikI8w9ZrnPtdL8Px3tG2C6eBGLKKKcBKBLefX4/wuEI29uThT0NnJE9vMlshmH5ZbjM2YMmf6rsWEBrxMSOm2CMDqPC3gqdXsd28MeOHWMLfILWnZ2Jn56mmvLRaITFbofTwUI4WdOT7f5MAb5k+x+IJmDSalBtNcJm0qLEqLvg7HMSwen99AjHEhwQ4A3H4FPMuPaGm/k1nZ2diMZiqK6uxpYtl2Dt2rWZ99M07Re1WTgUZst7KgNAgRC0nNwFYvEYQsEQNFoNBwCQpb42FsQHn/4pVvpSbfjc7l34VeNm6M0lMOvVbKFPbc8OAInEjA4EBO1vOJpyU7AaZDioWJHfzvmHLPOp/jqNS1i2Xb4AWxTOfjxugeePf8yUNqj+wPvz0rFR+qYg5C9UEkoQLhS6Z/ryl7+MN73pTbNep8+neE5lyV772tfmbXBDPvTNhoYGvOUtb8FXvvKVnByn2ZA7NkG4QPwPP4zk5ACTYc1q6JubpS3z4absD3/gae+996ZuytRiNCIIgiAIgiAIFwKJypR9PzzuQF9nO8ZGhrjWfDAYZDt4srQPR8KceR6LRWGxWmBMmGA0GqA36KHV6RFvvByvfORbmXXu3HwzWpsr4R10sghP4v3hw4fgdDg5A52y9mndlK1OgndavKdBFMr07+joYLFfo9Ggrq4ONpvtjP0mm3x3MAaSZ+xmPaxGLUpNOug0c3dvkMrmV0OvVXNmu7a+Abfc/mJ4xoc5ECEd5JDtBkDTVCagtLSUAyEi4TACwQDcbg/Ky8q5vaORKLq6u2Avt6eClHV6LhfwcGnFFAH/npXXQ9OyEVZvN+LxOL9Xq9OitrZuyjan7rMannAM4ajCJQW0c9gegiCcRm02o+SWW/gh5B7Ltm1Ql5ZC8XgQHx1DtKsLhmXLcr1bgiAsZvbuBT7wAeBLXwK2bEG+QCLl8ePH+Vp0sfGiF70I27Zt4/uDfOPTn/40B9p+gL4TecZll13G3wlyHiv2790HPvABfPOb3+Tj9YMf/AD5gNytFSGPPvporndhcdnnk3D8HLkpy5ebMs3kD0F8eBihAwdRSEjfFIT8RPqmIOQv0j8FYX4JxxTOYh8aHELPqU709vRioH8A7Sfa8fTTT+P4ieNwTDj4QUIz1X5PKgpe/OIXszW8askmWGNxBLWpmuwevRnjV14FYyLAddtpIOvAgf0YHxuH1WblQZ2xsTEcOHAQT+1+ii35KTudIFG6sbGRM9NJvKdM80Q8wRb+6dcQcUWB0x+FVq1Cpc3AlveVVsOcivdpKJPfbtGjusTA26goL0dd60qs37SJXQFmEtJpGf1t+bJlLLpTGxAk5FMABAU+WCwWXk4Pr8fDz88oETgNqQwTe8SHK4cOAy2XwuX2cWADuRJQwMDWrbMPElNAgFErNvrFjvx2CsVoo1/5H29B7ac+iRWP78xb8V76piDkL36//9xfnEwCb3sb8PDDwNvfnprPE8jNatWqVXkpcl8sdB9Bny3fRGK6Tv/f//1f3HDDDXmT1Z2N2WzmdptPAX8+v3f+8+mbz0J9fT1uuukmPl503PIBEfAF4QIQ+/z8RKXTwXbzTZl5skYTBEEQBEEQBOHC8EfiCEXiCHhdnBU+MDiI7p5urrlOWeZUx5Egy3jKuqcMcMosJ2rqahFp2oYxix3vuO7d+Oylr8bdK3eg4/ge9Jzq4NdQfXiyibdX2FFbU8tCNWXfl5aWQK1Ws9V8dp1In88Hg8GAtrY2XH3V1Si3l095TSyREu/NBi0qrAZUWQ2cKT/fmPVa1JQYOWCg1KyHJxhH5FnqzKfLD9TW1mL16lUs5vf29nEm/saNG7F6zWp2F6BABxr08oXCeMRen3n/87ueQKKkEZqqFm4TGqyk7BZiz569OHzo8JTAhjQmnQahaBzByNn3TxAEYTFR8brXofxlL4O2vDzXuyIIwmLnvvuA3btT0089Bdx/P/KF2WqRZ9es//73v4/169fzdX5NTQ3bic8mZj7wwAO4+uqrOfiUSlu98IUvxIkTJy6o1npLSws/ZuK3v/0tC+C0Ddovet0rXvEK7JkspUuQPTytf7pNfHq95CBGGdZ070HXzsuXL8cXv/hFvgafDi37+te/jjVr1vD26Br77W9/O7fD2fZzJn7961/ztl/+8pfP+pp77rkH11xzDV/PUx12av/Pf/7zmUDfmT4P7QvtE+0b7SPt6ze+8Y0pn4famuzzibvvvpvbJ/1It9Nsx2XHjh28nO75PvWpT2HZsmW8HRLif/jDH2Ze973vfY/3l/abgq0//vGPQ1GUZ/3epY/X2R49PT1T1rN792685CUv4fsn/aTb2bvf/W4MDQ3N2K579+7FLbfckrmnuvHGG7Fr1y6cjX/7t3/j4/Wb3/wG+YBY6AvCBSD2+flda879u9/ztO/e+1Dz4Q+Ljb4gCIIgCIIgnCckhoeiCUQSSQTcLq7LHg6FOEuDst+p5joN4pDgToNpVPOdRGmycyfsa65CRyJlb59UqfF4/QZYux5C02gfjvjG0Nffh/Xr1qO1pZUF6sHBQYRCIc6up0wKvU6PU6dO8XpJiKZ1Hzx0EH19fdi0aTN0eh0q7BXo6upK2dHHEnCH4ig16dkuv8Kiv+Ba9xcC2dFX2SjTnwoLAK5gDGUqwKCdOYCA9jkcCmPp0qVchsBstqCvtxcr21bi8ssu52CFY8ePoaOjE0NDg3A6XdgZi+L5KjV0SQVrnT1Y5h2Cd8st2FHqQCQUwvj4OB566CHYrDaYLWYeyNu+bfsUJwCDTgNPKMbtFY0rXAJAEIS5QQkEEDp8GOYtWzjBQBAEQSgySDydLlDT/M03kxUS8p0PfvCDuO+++/D85z8fN998Mx5++GEWazs7O/kaM5vf//73LEqTkErPlF39+OOPY/v27diwYcOc7A+J0f/v//0/Fp8pQ/yOO+5AVVUVO3DRvlFQ79atW591PSRC0+choffWW2+FVqvFn/70J3z4wx/mEl4kOmfztre9Dd/97nc5I5sCGOgz/uUvf2EHMloX3bucKxTkQFx11VUz/v2jH/0oi/X0+V75yldyTfd//vOfvJyOxb/+9a8ztkfB1CRGu91uFpxp/v/+7//wrne9C+3t7fj2t7+dEeHpNRSMQAHCFGCRZtOmTee0/7R+Es5vu+023g867tQmNH3o0CE+Ns973vM4wILaiMR+ul/80Ic+dNb10vantztBgQm0v+wcZkwFixM//elP8e///u8cfPGCF7yAxXsqrfaLX/wC999/P5566ikOzkjz5JNPchtR29D3hgI2Dhw4wG1y/fXXz7pfV155JT9Tu7/5zW9GrhEBvwihE5twcfgeeDAzXXLzc6Q58wjzZZdBY7cj4XQiPjaG0L59MJ/DD3k+IH1TEPIT6ZuCkL9I/xSE+SMQiSNIIr1ODXtFOQvClGk/MkI13uMsjpPdfV1tHdasXsO28GkOHz6MjoNTM7zVvmGYY24Egx6E/F4W5L1eL2eFaDVaBIMpAZpEbYPRiFhsFEaDke36aWCNXkvivdPhxOHDh7B+/QZEoxEYTUYk1Vqu7V5u1qPMrEe5WceDPrmAtk9jt5T74g7SPqnOEMkpIIHE+pHREXi8Xh5QItcBEu+pLVtaW6aI/JUVFZxBMjo2iidstdjhTWWZvKDrCXx7y0uhKdHAO3qYSxpQUIOh2YDAeAB79+xFia0EV16VGohKQ64EoXiCAzREwC8+5Ldz/vDvfByD734311u333knqt7x9nncmrDYkL4pCPkLiYbnnX2fJp2F/5z81xBIBKXr+LQQSoG5JHaSWE7iNdVLJyjYlsRNcszauXPnFBH9Pe95D772ta/Nyf5Q8AAJxJdeeikLqtn2+BRQTPci5wIJ9yRg0zooU5wg8XjlypX46le/ymJ5WiSnz0PiPf2NhOuyslQg7Oc+9zkWhGldzc3N5/wZKKiBMsBpfdOhbHAS70mMpvalzHKClr3oRS/C3/72N3zpS1/i/ctmeHiYg4Cp3Fj6u/nJT36S2+k73/kOB1RQRj+J1ZStT4I4CeazuR+cDbr/ou2k2+F973sfZ+HTcaZlJOKnXcBo/XRf8+Uvf5lfR4ESs0H7Mz2IgIIjKMCCAjfouNROtsfJkyf5+0afhcrNpLdHULADBRBQ8MIf//hHXkbvf/3rX8/B4RSocfvtt2deT21BWfuzQftPn+uxxx5DPiCh1kUIdTDhwlEiEfgffzwzb7vxBmnOPEKl1U610f9H4djoS98UhPxE+qYg5C/SPwVhfqBBj2A0JfCa9RpUVlRypjwJyZQVEgmHOSOfRHWX28VW8Nm27cfGo0gEo1NqfqqHjiA42od4PAGf1wfKU6fnkyc7OPuexHglocAf8COpKGypX1VdhQmHA8eOHePBKcq8p2XjY+M4cGA/20pW1tSjvLoOFWYD2+ZTTfpcifdpyi36yWACHdyhGLsZpOnp7sFf/voXHD5yGL29vejs6MBTT+2Cy+lCQ33DlNqYBr2eAxTUGjWSSHJ7/zl42sJ0x8B+GCIhPN4XxJFjxzjDJqEkUFFRwQNPY+PjGBgcOGP/DDo1Z+CHnsXmX1icyG/n/OF7MJXsoeRJ3VRh5t+30MGDGCeb4WkWv7lG+qYg5C9p0fe8s+/T0PIZrNrzjbvuumtKFjMJsJQBT5DAnObPf/4znE4nZ4xPz4AnEXeu6tB/85vf5Gey9Z++TnLtOp+a6mQvn30cyeWLhF3K+Kas9TQUMED853/+Z0a0JigLn4T184Gyv0dHR1mInun+5Cc/+Qk//9d//VdGrE63+1e+8hUOkPjRj34047ppX7IDS8gR7WMf+1gmW32u+MIXvjClHShwgNwE6L6DtpctptPryL1hYmKC7+/Ol7e85S148MEH8Y53vIMF+TQUUEHiPonv2dsjSPCnjPy//vWv7GCWzr6nY0pBDNniPUFlB6gcwNmgY8GB5eEwck3RCfhk8UBfAKrNQXUPqOPceeedKCbuvffeXO9CQRPcvRvJYJCndc1N0D9LhxcWnpJbb8tMe++/H8lEYQxMSd8UhPxE+qYg5C/SPwVhfmDxPpYAOdDrNGoWlVesWAGL1cKDV1TfcPPmzZx9QhnxR48exdEjR9jynTI0/nTUhc8++UN885Gv4arBg9D5R6F290OdjMPlciIQDPAASzAU5HnKxifhn4Rqs8nM1pg1tTWcZU8CSzAQ5Mxyu72cl9kr7Dy4uHzlajQtb0NrXVWq/rwpfyyrKZCgzKRDiVEHZyCKeELhz/jYzsdw6OAhFuPt5XYuBUADkDQouW7duil299TuJOpTW1GwAw3SRZqb0Gmt5L/rlThu6dmNwWQ5wtBCp9VxzcnZ6pTS9inI4vCBAzh69DiGxyfYRl8oLuS3c35IxmLwP/poZt52w+z2rELuxPuel7wUPS//N0x857sIHTiQV4dC+qYg5C+zXVs9a/b99Cz8PGcmO/p0cKnL5cos27dvHz9fe+21Z7yermnP1Z79bAQCAb6vqKmp4fuOi4H2iTKrz+Wz7d+/f1bL+23btp01q3w6DoeDn6nk2Eyk23EmS3fK2Kd7ru7ubhbLs6F9uOKKK854D2XcZ3+G+fpOUGkBYsuWLWf8LS2wU5mD8+Gzn/0sBzRQAMB0B4ddk3XrKfueAkSyH1QGgZwYyJGBMvWf7ftJ912zlTPIDoYgKBAh1xSdhf5nPvMZHDx4kLMGqAOcOHECxQZlKQgXjvnyy7Hk+9+D78GHoGtoyHl2h3Am5q1boKmqRGJ8AomJCYT27y8IG33pm4KQn0jfFIT8RfqnIMwPgWgcwUgcJn2qfjuJyiQuU6Y9ielNzc2or6/D0NAwW7uTvT7V9SRLyWc6R1Dj0GGZJ2Xz/r59v8GbV99AajN0OhtC4RACgSCL97HRGOKxOL8/noijpbkFsdIYZ5Hr9QbOyud10wCY08EiPi2jrImVbatRv7SN7fLLrXpYDPk3vEEiPuVaUfY8ifhDvX1seakkFR5EpHYwhlMZ9tSm2eL99Hbv7e1DzWRmzq5YEsv9qQGl53Y/if9bfi1chlpoIgMYHhpmoZ8GKulWlY4XifZk3UkDabQusuWH3oRIyMdBBq0NNTlpHyE3yG/n/BDcsweK18vT2vo6GFavnqctCRcK19Ndswbho0d53vvPe2G+5JK8aVDpm4KQ3wFAF5x9n4b+fvPNfM2cr2RnWqdJC9YkkE4PaCBxfSays8kvlLRoPT3jeq4+14V8NhJ/yenqXEln/M+WyZ3e1mxOArScLOzpddmfobKykvdltnY/p4CTc2QmN4V0u53tb5Qxf678+te/5mx+CgigaXIemCkQ4ktf+tJZ10OlHebi+0nW++fsvDHPFF0GPtVOoEgMinYn6wVBOF/UBgOs116Luk99EpVvfpM0YB6i0mhgf9WrYH/969Hyu9/BNEM0mCAIgiAIgiAIZ0IZ2aFIAtGEApNu6sAQZXjrDXoeFInF4hgY6Mf4+BgPLJGlPYnTh0J2vOzkQ5n33NewCeGQA3WV5dh66aVc876srBRqlRqKkuT1kb0kQdn9VNswGAxxjXgSM9asWcMPmu7q6uLnurp62CpqOeOeas5Tlnu+ikUVnImvh82ow4Q/gngigfKychbvLRYzlyCgATiyy58JEvHXrF6DzZs2oaGhHoqSwEMhHzw6I46XN+Nna1LuY6rGzfBHElyCgDLtqZ1sVhvCkTA7I1Dmf0dHB4v7ZH1pMerRPziCk109C9wqgrA48T2Qss8nbDfcKMkeeUrJrbdkpn333pt3NvqCIBQoZ8u+L7As/HMhLdySPfxMjIyMnLEsLcrG4/EZ3zNddE4L1hdixX4xkGv3bJ+NhP60mHwu0Geg+5vZ3pNux5nai6B7q+zXpaHM8OyggzTp9cxVCYOFYOfOnVymgdwQyAbfYrGc8ZrSyc9D3xEKpsl+kHtCejqdcX8h389s6HhRIEI6Ez+XFJ2Af91117H1XzFnTRdSBxaEC6XyLW9BzQc/ANP6dQXT36VvCkJ+In1TEPIX6Z+CMPcEInEEYwnOvk9fR5MgTBaWNGhCdpYkrt933728jOoDdnZ28gCJI6pBaySK9Y5ufl9cpcaTratRYVRxncmmpiVc43dV2ypUVFawVb4KKs5uoEGXsvJyHjRrbm7CyraVLFxv37adHzS9dt06rFq1Go3LVqGu2s4CPmXg5zPUhpVWPUpMOhbN7dUNHLQQDoW43ejzU3ZN2sJzJtIlDKqrqqHT6WAtt+MDTZvw3mvfgUeWXAJFrYGmshmGuhXcliTSp50NzGYLD5TSAODwyDC7GJBtf01lBULhCPzBCCLxwig5JswN8ts599D5y/dgtoB/wzxsRZgLzJddBs2klXF8fByhSZvdfED6piDkLzNlO59X9n0aet2zZfMXAJdMupeQpfl06H7hwAwlStI28lQ6azp0TTzdJp6EXHKionuMubSEfzbSdv2PP/74GX976qmnZg1AmI3169fzdTglFM+2rUceeWTGNiH3rFTw81QHAdoHqvM+nfR6sksOpL+7Mwn+uYaCi1/0ohfxvcvf//73WZ0Itm3blhH7z6Vvnu37Se0w07FNQ/e6FDSyYcOGvNCUik7AF07XwhAEIb+QvikI+Yn0TUHIX6R/CsLcQhnxZJ8fIvE3K/ueBtrIer3cXo5t27azGE+ZCaFgiK3uFarv7vagz7gML+s4nX3/6JLNsJQbsaKpnoVngjIZyAp+5YqVnIlPtezJipLqwfv9Ps52uPyyy/Gcm5/DwjVtu/PUKX7v8mXL0LR8FSrKy1Bq0nN2ez4MrDwbtI9kp796WROaW5eivLIGGq2GbR03bNyAa66+5gz7/Gzob1QCkMSd1atXo21VG9TwQPFNTNmGYeUVKLdXsphIpQrI/nFwcCATeEEDXFSKIBaN8bPVpAe0OoSjkoFaTMhv59wTPnoM8clsLnVpKZf1E/ITlVYLG1lYT+K99z7kC9I3BSF/oVJEF5V9v8iy8G+//XYW5H/1q19hz549U/5GdclnsnCnIF4K1P3zn//MNcvT0PXqO9/5zhm3k17+5je/+Yx1KoqSyVCfS17zmtdkarJnb5Mcwz760Y9e0Lmd9vXpp58+42+vf/3rM2W/KSg6W2R+//vfz+97wxveMON6P/KRj0wpveJ0Onk9BGW0p6HjRPcJ5JiWT5CLwG233cZt/Pvf/56DNWbj7W9/O99Lvuc978nUuc/um3RsssX9K664Am1tbXjsscf4+5bNt771LZyavLecCTpO1P6UCJ4P5F+RuAKB6jHMxPHjx/mGOp+hCKhNmzblejcKEv8TT3B9LHUe1L8QFh/SNwUhP5G+KQj5i/RPQZhbKPM+HFOgVauh1ZyO949Eo1w3vb6uPpW9TXUDDx/ibJDqmmq2tg+rjKhVGXDZ6Al+jwIV7m9sQ1nEA4NBz9njjQ2NLC5TXfYJrQZWixUms4nrENLgCwn2lRWVmWx0yvBP12w3mowYnnBj5apVWNpQzVntanX+i/dpdBo115qPKUlYbDZsXL8OZqOBP+tM4j25HlDwArV9JByG1+dFLB6DQW+AVqvjNkx0PgH15ttPv6lyKZJj5UhEPCg1laYEe4eDjw9lMdHxS5cioPZsbqhHZU0dQrEESpHfTgbC3CG/nXOP/6Gs7Psd17JILOS3jb77t7/lad9996HmIx/mUoy5RvqmIOQvwWAQZrP54rLv09DrKZCoAIJQZ8NqteIHP/gBXv7yl+Pqq6/mZ8qepsxmun6/5pprWDzNhgTYd73rXfj0pz/NGeKUeU2Z5P/6179QX1/Pj+m88Y1v5HX+/Oc/ZzcqChwgB6+hoSE89NBDLIBTwMBcQjbsb3rTm/jzrV27Fi9+8Yt538nenYJpaT+n12g/G/T+r3zlK7jvvvtw4403TvkbCc0f/OAH8d///d8sYL/kJS/ha/Z//vOf3I5XXXUVPvCBD5yxTmpruqan97zgBS/gevMkglNAw1vf+lZu/+xjdfnll7PA/apXvQorV67kewR6H2WZ54q77rqLXQYoW/6JJ57gx3Te/e538/0mBX/85Cc/4eNNx+SWW27hz0Gfu7u7m90I6Htx4kTqPpQCFn784x/jpptu4va/4447sHz5chw8eBAPPPAAv//ee++dcb/unwywofflA3JFOQ+Ew+EpkR3p2gvZlg0UAUJfPPqipCNl6ARAETl0wdbb25t57c0338yRKLuzIrk2btzItQGzt0PR+2QnQVYe2fUd6MTW09PDX9A0NEBC20t/IYnm5mYW9slqIx1dRPYV9IWmL397e3tefyY6Ec3nZ1IGB9H6pS8jqdOh9OabMX7nq9CbFblUiJ9pMR6nmT7TwNGjsLS3w7t5M26+5Za8/UzU9un2L8bjJJ9JjlO+fvcI2r70JzlHyHkvP8/l6T4qv0/ym1tsv0/z8Zls1Y2oXLIMRw7sRSTo52VUt5Gy4yn7nuqp06O+vg6VlZUsuqcHiP7aq8ZN9/4qs66nGtZjzbaNqNf64XG5uL2CoSD/rXFJI5pbWuDzeacMhtLAHGWa00BeGsrUIeHZ6fPDHwrj5JEDGD0JvPhFhXmc/DFAb6vAsjXr0XfyKJ7Z80zmtTTIRFaZlBiQxuFwYmx0FKvXrJ5Sh1FREnjzrVvwy7EkYokktoy145i9BdUbr8fLNlVnxoR/+Ytf8iDW8573vMx7jQYjD4ZRFv6BAwfRceQgmqtLcNP118l1eRGcI+iz0LjVYvpMuT5O+gdOC/jHS0pw8pFHCv4zne04dfX0QkkCiSRw7Y7r4PZ4sXfvXqSlqHXr1rK7CgkQFGdFMkddbTWu2LYNTz+9O/efKRjEUqsVWr+fbfQP/fa36MmquZvL40R1eYu9P8lnkuM0H989smen61Z6JkGT8PtT17rp11IZonSNbYJETnoPifeU4UuP9LUpZeiSu5H2gQdg3b0b9I5zkeP5dU89hejf/47gVVdllpNoS9vLtlmna3C6Tvb5fBn7c7qmo89OWevZ2dfn+pnSfyfhPNuyPv132n56ebosU/o9dO1A07QteiYxmkTjL37xi7jnnnv4tdu3b2eh+mtf+xq/hzLIs7fzoQ99iD/T97//fRbIydWLhNLPf/7znBSb/fr0Z/r617+OK6+8EnfffTdvhz43navoe0BZ0tQ+dJzS7UHHi9aRPk60ToKWpT9Tehv0mdLQZ0rb49P+0Lnoe9/7Hj/oGvy5z30uvvCFL7ClPZ070+t4tuNEn4uE8l/+8pecIU/HOfs4UQACBTTQ56RABRKlaRv02v/4j//gz0OP9HePIMcyansKhvjNb37D2ey0TxQgQcEH2ceJPtO3v/1tdg+g34tf//rXfLzpM9FvdfozU1tkf6Y06WXZnyndF+j7kn5/9vckTfq7l/29Tven9Hr37dvHj5m44447MtMvfOEL+XeLjgEFh1D/p3YnnZOCQSggIb1O6k/0XfzHP/7B7UjXIwR9Z8iqn0R8aov0Pqf7E31X6BjQ8br00kunfHdn6k90vOl4PttvLq1nehmEc0WVTG+tCKETOnVyijyhDjSXmfl04Zqv0IUZ/fgJ54fjJz/F2H//N09br78eS77zbWnCAmDg3e+Bjy7oFAXNv/oVzJecrgGTb0jfFIT8RPqmIOQv0j8FYe6gOujD7jCcgQiqbIYp1vSUDZ6dDT/hmIDL6eJsfI1ag4FxJ5y2S/GDh74CDQ9NAne/5i60bWxCuV6BQa+fNdN8Nvbs2YujR45g6dKlUOu0cAZiGO/vxpVb1uOGa08PeBZimYIxXwTjvjA0GhVKjGdmvh8+dBjHjh/jgSKqWb9n7x50d/fweENb20oehHr88SdgNBpwSdlyvGr0BBoCE/jmxjvwUMMalJ/4M1yjA3ys0oN9rUtbuS23Xb4NV151ZWZb3nAMKqhQX2pCqVmy8IsB+e2cW6L9/Th1U8qSXaXXY+WuJ6HOEoMXy+8DldoIxxOIK0nE4wriySQSShKJRBKJyaHl9K9G+ueDfkc06slH1rRWrWJXEp1WzdN6jXrBHVWGP/EJuH+TysIvf82rUXsBtshzjfRNQZg/0sGRF+qcPKsAd9ttwKQ4eF7Q+/7+9wvaFyG3Ndsp8/vf/u3fWAg/V+i1r3zlK/GHP/yBxeaLgYR6ggJbBFyUOD4dclmgQIBf/OIXuPPOO+fsvHIxmrFk4AvCOeLLtkS74XpptwJBY7OyeE/4/vWvvBbwBUEQBEEQBCFXBCIJhKIJmPSaM+rKk/BOFo2UdZFt6U5W7GR96Chpw0s7d2bE+33VK7Huuu24Ynkl9Npzt5jMhkR/snmnLHG91Y6gxwkd4hjs7cITT6hY3KbslIqKChQSJFKVW3SIxRWMB8IwaNQw6KZaN08vWWC3V3DW4rFjRxGLRTEyMopIJIxQMIgq9LJ4T9zU9wz+0bIdSmkDbAEPZ/Ak4onU+sJh9Pb2cbsRBqOR27i2vgEqowXBWFxs9AXhQvq01coW7L4HH4LaZls04n0soSAYTf0uhGMJLrURnRTw6ReCyqykBXmDKnWeT07+BqSflMn1hGNJDl4i0T/1XhV0k6VaWMynaW1K1KffDBL051vUt910U0bA9z3wAGo+8pEzfvsEQRDOSYgfGEhZ6Z8rdK659VZp3DyG3FDIHSDbKp8yx8nSnThfEZ4Ef8qwp2x7yiSX35v8I5lM4uMf/zi2bt3KCd/5ggj4RQhZOAjnR9zpRGjf/tSMWg3rdddJExYIfFP2u99nbsqqP/iBvP2RlL4pCPmJ9E1ByF+kfwrC3EDCSjAaZxG3wnraMnG6iJ+dQd/T3YPx8XFU19bhZLQB1w38LPO3I9e+EDfbzRcs3hOUsU/Wg90DQ/A7e2FSxaCOBOByKWyzSJaJLpeL6ybmm4hPdeepHiNZMc4UaGDQalBq0SGqKPAEo6iYFMJmCl6gDHwS6wlq77QFpdFo5OlHon7cqdJAl0xglasfzb4R+GvXoFHtRyweY/cE2gd60OvJFrmvr4/3iawzqY1rW1eizKTnLFvaN2FxI7+dc4u2vBz2176WH8nJ5IFChsR6byiGcExBKBbnecq0N+o0sBl10GlUFzWmQuuKKwpn7pO4H4oqiClJztDXkZhPWfkk4KtTGfq0PfotIXHfoFXP2XiO5bLLoC4pgUL2v0PDiJw8CWNbG3KJ9E1ByF/S1uVn8Pa3px7CooJKAFDWPJUkoXrzJOg/+OCDXOrq1ltvxUtf+tLzWh/9dlHJAMrAHxoaQkNDw7zte7FRMlvfPE/oGFP2fb4FWIiAX4TQDTrVaxDOHf/Dj2SyuE2bN0ObVXtQyG/M27ZxBLwSCCDW349IezuMq1YhH5G+KQj5ifRNQchfpH8KwtzQPzKGfSe64A9FUWk1TrG7JwG4n66jo9EpVvhU55FE4VjNWnhGzXjrde/DC0/tRItvBFWXb0JDqfGi9om2sWrNWiQMVpgQh2u4B35PApWVlaiqqmIxm4To8vLyvBLwSbynAAPaN8rUmS3QgKzzIzEF0bjCNvblZv0ZwQtUsoBcDqitKysqeYCqorICgUCQs++p5mRIo8Oesjpsdw3we2/qfQY/XXsrVlTVw+YYS9VpnKwnSoEaXo8nE1RA76dtaM021FTaOdNWBPzFj/x2zh+qrEy9QiOeUOAJxeALx+ELxxBNKCzaW43aOT0vpLL2NWeMSNP2YyTqKwrC4RiL+pSdr1WnsvLTtvuZDP1JUf9CAwpUOh3sr30NVFTj+sYboV+2DLlG+qYg5C9U6zo7G1tY3Nx00004ePAg11l3Op1cc56s89/5zndyFv6F/O5QXXV6CPnZN+vq6tghId8QAb8I2b17N26//fZc70ZB4Xvoocy07Xqxzy8k1Ho9rDt2wDtZV8h3/7/yVsCXvikI+Yn0TUHIX6R/CsLcCM679x5Ee+8wlGgIY2YDiwhkmU8cOXKERV6ydKescPpbY2Mj12hvbz+Jp82X8+uGrZX47sYXYWmJCteN98FsOJ3JOFsQwLPZGMJgxmWb1qPSasCxAxoWxkm81+v1/Ey28pTlnk9Q5j2J95QhT5/zbIEGdksq633cF5mS/Z5dsmDCMcEPao+a2lrU19chFovj1KlORCet8R+OhLF9cp039O/Fz9behna3Bgmvl/fDVmLjddFref1lZRxUYDZbEI/FgUSMt08W2XNTQVLIZ+S3U8iGzi2+SJyz7km8J9t8q0GDMrNuQTPQ2E5fA5hwOliAMvTpQeJ+MKpw9n5ayM88SMjPEvfPR9SvetvbkE9I3xSE/CUQCMxZnW0h/7nhhhv4kY/09PTkehfyisAi75tFJ+D/6U9/4kfaFoHYtWsXXve61/E0RfN/+ctfzuk+CvmFEgoh8MQTmXnbDSLgF6KNfkbAf+ABVL3zHbneJUEQBEEQBEHIC9o7u9A7MAit3oiWJbVs206CPQm+BE1TxjbVY6e/dXR0oKu7C319/djf74J7uS5rbUlc0mCGXRebIt7PFARAAvXZRHx/JM6WymTZXGrS8T5QNjsJ4ukMfJpP13TPFyiggDLvSbx/tkADykQtMekQiSvwhWLQW0/bQ6fbhtqK8Pn9OH78GAIBPybGJzgrn7LxaRvBeAKOI2FUhH0oiwZw2chx7C1vRnlpFXTJCIv4JPbbbCXsxmez2Tgjn9ZNNvo0X1nfhFKj2OgLwvkQGx2Ftro6r6xWzweyx6ese/+kgE/Cd6VVP6WkRy5Ji/TZwQacpZ9QOOgoEIkjkUxCqyH7/dOiPs9nTesnp/PlcwmCIAiCIJwLRSfgHzhwAHffffeUZWRJRw+iublZBHxhCoFdu5CczFQgSy19S4u0UIFhvfoqqPR6JKNRrmsW7emR4ygIgiAIgiAIJBAHwvAGI1jaUgedXsc11+n+mLLlCRLdSbxP/+3YsWOIxWKcze2p2jilDU1xPxqsJTAnTi+jzPvpQQDpAIHZBHyylacs0CqrEeUWHdRqFVu+U9Y4ZbOTIE7ifVNTEy/PJ8430MBm0CIYSSAYSWW+xoL+jFtBX29vqkZ9bS2vgzJuDh06BL/fj3g8VU6AMk4ou/9kKILtR/fwOm/ufRpP1r0eVSs2wuDphcvpgtViRWNDAzRaDdfvHB4egdls4gAA2kZXRzuMWjXKLbVioy8I54ASDOLUzc+BrrYW1htvQDVZ6uqyA5ryGyrd4fJH+Zky20tM52eVT3XsqQwIBQGQ3T1J4xR0RbEMdM5Wq8gqX8XnFcqunwsoUEKvpcfp9Sks6lOWfnKqqM9W/alsfNo+Cfwk5rMtf1rkz1pWqEEYgiDMD+wElUgAGo2cHwRByBlFJ+BTHYN8rGWwkGzcOHWQRTg7vgcfzEyLfX5horZYYLnqKvgnSyFQFn7FG9+IfEP6piDMD8l4HOGjRxHp7uYAnmhPLz+X3fEi2F/zmimvdd1zD/wPPgRtdRXMl17K5w7pm4KQv0j/FISLg0SbpEYHjcEEn8cJo7YCff19bNlOFu06rQ6KorDoTuI9PWs0GhalAzCiTRPFpuP34m+tV8BlLIHO1YWxHh82XXVZZhupdZ1CdXU1goEgBwLQPAUBENPt9GnAlDJCS036VOb9pKBE9vNUR57EaspmT9dxn25Ln2vON9CARCOyqiYRrHt4HMNd7RgeHuLAiZHREbaF3LZtO7cfWd7v3bsXen0UVVWlnD1PkLCvaazD9qOpdW4da0d5xIdxfS1Wl/k42KKmpgbNLc1cx1On06GysgJNS5qwbv16RKMRTIwOoctiQ3N9ldjoL3Lkt3MOkz0iEUR7exF47DGoPvABFAquQBTuYAyuUARmvRZl+rMLVCTWO/yp99C5ih7kHJKyuE/y3wkS7WktJOCzoM/W9iS4a2DSaWDkh5qnrQYtTM+y3XOBtkm/E4asEW76HYkr2cJ+nKcJFuxVk8I9CfkqVWp/R4eRPHwQ1uc+D5pJUZ/WnQoEWBiBX/qmIOSW2PAwlFAYyViUx5FAIj6d1zRaGDRqRMkVSauFSqeHpsQGtdEoh0wQcozJZMpdkM8CUHQCvgC0SAb5OZNMJOB/+JHMvNjnF7aNfkbA/1d+CvjSNwVhbol0dMD9hz/C89e/IjExccbfw+3tZy47fhz+Rx/laffvfs83a8a1azF+zdWwXHU1TBvWQ6WVyydByBfkt1MQLo5gNI6q2gY0jnvgmRjCkaNH4Jhw8N9I6DUajAhHwpzB7XF72P6+rq6OBeETwVp84MTDuHSsHS/teBhfW/9CHFP74R2PIBzekLHPp2xyp8OJiYkJmE1muD1uqFWp7EkSkqfb6ZOVM9Uzthm1nBFKOBwOri2fFu5XrVqVd8J9mgsJNCBRy2rUwjE6jK6BYZSZU24FHq8X42Pj6OzsxOZNm1BaWoKGhnoW9Skrn2zwQ6EQQqEwtG1tGGpaifq+k9AkFdzQvxd/aLkc5jEvzAAaGhqwZvUazuwn4Z+O77q16zigIhaNwdPVhWg0xhm1lMV6Ppm4QmEhv51zg/+R02NF1usKo9QiDTY7AlEOkiIxnoKk6PwzW4CXKxjFhC/C7yGLfTo/p4V7+nu6Bj2J3DSMTWPZtA1+xqSIHlcmhfzJGvVqNQw6NYwk6us1MBtSYr7FoGVHEvMciPr0fgocyLbfT38melDAAe1bNBJHPBaH7t1vhqb9GL/Gu3I9NLU1vM8s4E8K/DTPoj5N0zJengpS4Gl+pAIK6DUXgvRNQZg/6LxA5ycKTFVR0BEL81PPf0ogAGXShTcDndPiMSAOJKaUQ0qKgC8IeYAhR+XU0gL+fAf4yQh0EfLnP/8Zt99+e653ozBIJFD93vfA9+BDLAQZN6QGooTCw3bdDgzThVkigdDBg1yrTldTg3xC+qYgXDwJquf6j3/A88c/IXz48FlfS5n401Em68xmSCYRPnKEHxPf+S40ZFP7ylei/NV3QlteLocsj+Gb82TKVjM5/XnSbnPqIOPp92XH0aYzieianC7M6ZkG7VJ2m1JLM9fIb6cgXByBSAJ6sxWbN6zF2HAZjh0/xvXbSRym7GzKuCfxnuzum5qbYdDruV56JKFCeQdYvCc0ioJODaAOezE2EuLM8fVYz+J9Ip5AVXUVi8Snuk6xYE+C9qZNmznzO9tOn0SVYFRBpUXPWel03iXxft++fZzRTvtGGe2U4U4ieT6L+Oe7b2UmHYIeJ0719KGxqozdCkpLShAMBdHVdQp+vw91tXUcQEFtqjfoYbFY4XQ62Ea/bWUbfE4X0HeS13dT3zP4/fId6I8Y0aYPYOXKlVi/YT3/jY4jHetsZwUKzrAa9QjHEwhHFRHwFzHy23nx0PWi/9HHMvPWHdci3yHh2uGPsHhPtvnlZv0UK/o0oWgCA64gJvwReMNxFu7pmTLnbUYdSs26VG3588hKT2XqK1wehTL2aftjsQgSiSSvN52ZT8/kCEABXKmHjsX9mfbzQiCxnR56ZK9Pj2CJDenKL5qnHoNy+0sQj6WCFOh+giz56ZOms/IzD/XpcgFqnBbwKUYtW9RP30Nk5uk/NT1P/m3yXuPvf/s7nv/85/F+8L0H/cfPKdKvzfxdbP8F4ZzRa7UIBwJwd3XBFIlw+RPttGs1Kr+KLAFfpVYjOekwcsb5pKTkjGWxkRGoS0qgMVPopCAIC4Hb7eZ7oYWGAqoXIoBABHyhoCCbLrrQnzKyPt/c/DwYbn4e9IkExv2pOpBCAaI2Qr/jeqgMBuivux5OtREq77SoyhzjiQJjebZPglBohP92LwKf+fQZy1WVldBt3AzNkiaom5qgaWrmx/Q+p3r162G77ibEydp315OIHzmUqnuWFSAw8Z3vYOKnP4X1Y5+A4aab5/0znR6mmeXvs/x5psXZgzyqs6xnyjZVM/397OubdV3PQlo6TztRTRfVeflkRg8NpiWzxHiayAj2tIxsoSdfw8vpXdPeM5OAn954el41i4CfysKZWkuTMn0oY3GuBhkFQRDm+96KhBo6R9ZU2flB2dlk3U7ifbrmPWXek3i/deuWzHsn9o3ghV0/z8zvql2Nvol+WLwD0IZsvKynuye1vkgYpSWlcLqcsFgscFMmv8GI8bExPrkGgwF+HeELx2ExaGDLss6nzHsS741GI9vtk30/zVOGe74K+BeCx+3C+FAf/M4xHCZR3qBht4JEQuHfHypdQPXryWJ5aGgIx44dY5HfbDFjzZo1WLt2LR7o6YLeVoWdDZfggaat3L6xyuUwJMF/T0PtSIEUFDzR1dXF4n1JSQnCQR+e3rMfNaVGbF2zfFG1ryDMJZHjxxGncxiJOKWlMOV5qUoSz8kCnzLq6dxfYdGfUZeero0HnCH0OgMY96WEfnpNiVGHpVWGM7LZzwfO1NeoYdZPXU4CedqS3xdJjbnRMhPZ7OtT2fg0nRL1dezKQs+0nMTwuUJ77Q4kntnN0+rHH4P15a844zUpMZ+yd5Ms6LOwP2nTnx00TH+jGwkW9zP3ESTwp24oZhPw6R9XBBh0h3h7/LezCPg0MeWe6yLvy861Oee/kIAgzC10vx97fCeCOx9G4pqrMVZbi0qtFmaXG0pp2dRAmHI7NKVlZBEFlU6X6siKgmQ8gYDHDYvRgGQsDsSiSGj1fI2W2U4slnJ+nJiAymKBurIKKhHyhQKDugONcwkzkxo/TLJ4PzIywssouH0+EQFfKCjIrovsu9K1qwThvPjwJ09PhxUgnLoxyhfcEWDYk1/7JAgFx6VXQWc0QhUOI6nTQdl+NZTnPBfJLZciopnhsmd6n6tsSD02bQNe/CrA78PxX/4c6wJeqJ/ZBZUjZcVP9S6d9S1nvn+hxfvz+du0UZnZBnambHfKoNBM75slIOACBXyC5fVzEPCniPGT71Gy/za5Gzxwls6GmRwA4wG/yWUkxvMA2OR+Tv+c09dJg3PxSdtQst4kUrUxU7agVBtPP2kLmrYHvVAbTUEQhPkkEIkjFIuzhXEayswmMXd6ZjYtT+NwuHDg5Dje1L83s+z/ypciPnQUqmSMs8OJx3Y+xnXbyZLfH/CzXb7fH5jMuh+CWqNGLBaD1WJFJBxm23aqVVxu1iIe9GLP8R62oD9x4gSL9suXL2cxnwZMhoeHORN9MUGfTZOIoq7KDl9Uhb7uTvjcDnYruOGGG7ndqD38Pv+s2Sc9I6O4u2UzXMtuOv2HskbEQqmyCJjhN5yOLzkg0G/q6PAgJvwxjFl0UIIeXLZ1i4j4gjAD6ZJbhOXqq8+wYc4naPyMBHmqex9TFNgteg5EzYaE/a7xAEa9YX6QnX1zhWXeg1JpP2hb9EhD19mhyQAzcgGg55T4r4VJr4ZJR6J+quwIiflku0/Ts5UCOBe0V+9A5Mtf5OnE/r1IetxQkYg3bV81dIdwDptJBxBnnjP3LpPL0q+hF1PQ8eQ9RlRJ/TanbXn538l7kCnLsv72rEHd53BfJuK9sGjp74X2u9/gsRy1Tod4hR1kgj9cWgo1JWpQWcVzvFUnsV6THcjkdk99AV3/ktU+QYGpLlcqAIBKMIogKhQI6cCyQiKRSPC9YS4gZzgqTTafiIBfhNTkmW34+UID5nRhfjHRv4KQjzTWVvANqCAI50ZyaAAwWaDKtrI3liF+5+ugstmgvvE5UJWUXlxzGu3QX7cD5o2bkIzHoTzyEBK//BnUzS0wLls6dX/IWi0WY6ePi2WqifusLzqvP6Wz2mfcxsyTU6cnVzAlhG5SwJ7pdWfdzbS6PgOzZpikl6XFdv5fzVksaTE+/be0VeVCkBL0U7U0aYDUH47xtg0k5us00GsogyhV2/NiBhaFxXldKwi5vKcKRhMskmhjIXS3D2DCMcGW916vl4ViGgihAYmG+gbO2E7zx6c7cc3JXdArcZ4/WdaIkzE/rJo4rCYrmluaMTY2NmUgJfPbQDbEWefnjCCRTMIXivO1cDzkw/GjhzKW+bSuiYkJXp9arWZLfXomwZumF0uWOLU5DQxfvnkD+sbdiCYSiIYDXBPZbi/nEgSULT8wOMCvX7ZsWSbIYmR4hIMcwuEIYv0HkWzYDpVxMhtErcFQshx/v/c+bFi7hrNEBgYGOPue3BZIwKc2psCLcns5llXWweN2oqt3AFUV9kXTvsJp5Lfz4vE/clrAt157bZ7b5kdZvKdrVsq8zz4HU+BU90QQw+4QJxPElCQayk0slucKyvq30WNybIR+HyJxKq+SQIBF/Shb76fFfLbf12tgTov6Bh07uVjO49pbXV0N9dp1UI4eYfe1+OM7oXvu8y/4M7BrSjqt/jxorqvkAIsLYbrAn1o27TUz3Zld3G1nXjL9cwvFRzLgR+JnP0bid7/OOCqqYjHo//AnJOsakaitR0yr4+z6cyUYDMFsNs3+glgcSUr48HjP7DVmC1S1tUBWQKwg5Bs0rkV6m15bWAJ+KBSC1WpdsO3xeJ/BwPdUdK9M96XziQj4Rci2bdtQ6FCm23xHAid9PsBqLbioI6FwuWzLJbneBUEoCMiaLPrLuxH92U+gvfEmmD72yam1zd7w7/PTN7V64JZbkHzOc4BgAKppv0PR3/8esd//FsaP3gXNhvy20RTmDgocoBucTC1Nky5T45MyaNyJJIv5Fs4aSg0s0gCjZOXPDYvhulYQckEgGmfL4tHBQRx45gkWw0dHR6FRazgznu6BqJYgDYY0NjZyfXrC7XLj/qNj+HL3E5l1/b1lK9TjPVBCPqgtFSy6d3d183pCoTCisShsVhvP07pIZGhsaIDJZIJep+e/+yMxPi9SsFN/b98Uy3zK3CfhmizfSUyurKyEXq9HPB7n/aZlJOTTNIngNKBCWeuFJjzTflMWB+IRrGhZgtEJFyL1TSxEkHifdkMgSHivr6vnMgd6vQGHDh/idrWX21FWUgLPwCFoll+ZWbdHX4kjHe2gSxdqo7RYT+ug9fb09HD2CrkcQKOFUmqHY7CLXyssPuS38+KIO50IHTqUmlGrYb36KuQjdE5wBCJwh1KZ99PFexL1j494MeaNwBmIwm7Vs3g8l9b0cwHtM4v0WWI8Bc5SZn44psAViiHsCXMgb0bQ12n4+pueScyn3xYzPSaF/unlAwjttdchSgI+rf+xhy9KwL9QNm/efMHvTR/b2VzRZlkgCIuO+K4nEP7sJ5F0ZLkPqVTQ3X4H9G/+D6jLshJA5pqlbVD6+xD52Y8Rv++fU8oxQm+A4S1vhe5lr8hr1xaheBnxhFFRakRjuTnXuyJkISnMRchTTz2V610oCEKfuguB229D+AufgdLfn+vdEeaYZDSKxPFjedWu+/fvz/UuCELeQ3aGoXe+FdEffBeIRhD/x98Q379vQfsmZ4FbpkZ3KsPDiHz3m1B6exB8yxsQ/uqXkAwG53W/hPyFopYp64cGQatseug0Kh48HfWF+KZoxBuGO5iq8SlcHHJdKwgXRjCSwNC4A3uefhKHDh5iAZcy70kkJzF8eGgYnZ2dOHz4MI6fOM7CPT3+sesQ1nYdQXkkZeM+birF05TBFHQjEPBzLcCJCQdWrFzBtuxOp4PrtLvcLihkixwOwWgy8TOJyLQ8EAiiq38IibAfZWYdotEoBwFUVVWxUL906VKuz06PTZs2oa2tDVu3buVsBxKYaX/37duHgwcPTnmm5YUEBR00NTUhHA5joOskym1mNLYug8Vi5QAG+qzkhtDY0Jgpc+B0unD48CG4nK6UU4HDgUg0Cv3QAV5nvX8ct3bvQkxvg6aqlYMEyMlgeGSYs/cpAICeSbzXaDS8zmQ8hgmXCzqDCVqdZIotRuS38+II7NyZSfE1bdoETdlUq/V8gUR5qmNPQne5eap4P+YN4/Cgh23zyYmltcqCSqsh78T72aD6vJShX2UzoMluxspaG1oqLSgx6dhpgD57tyOA48NeHBn0YH+fG3t7nNjd5cCTpybwTLeTl3eN+9l5gEoIJK64JrP++FNPIRla+PKGMiYkCBcfuBT9+U+niPeUXGH+6S9h/NBHL0q8P9f+qV7SxEkmll//H7TPfQGQFuupFNI3vorQW/8dyvj4Be+HIAjFdV0rGfhFCGVWCGeHahsn9jwNhMOI/fmP0L/qNdJki0i4D3/mE4g/8TgQj8P6zwegokyXPICsQQVBmB0Wx9//biQHTgdVqdtWzXsfPpe+qXR1np5JJhG75zeI73wMxg//F7SXXT6v+yfkNzQQmq7tSdmugUgMvnCMM4D8kTgPNFLtTnH8uTDkulYQzh86F5GgMzQ4hPGRIShJhTOx+/r7WMQnK3aTOZUdTxn5e/fsRYktJaDf3+nHu7sez6zrr0u2IuToQ7lZjUpLE2eKk/5DdoLp7G0S2qORKJwuJ/9dq9Xws9vj5ozxpN4EtRKHc2QIxuWNmUx02g8S8emZsu7pUV1dnVlGr6HXUuZ9dsY+/Y3my8vLCyoLn/b1kksu4f2mtgsndYhqTQj4/dAm4zDo9ZlSBjRATRb4x44dg9PhREVlBUxGEy9zu1xIRML4/CNfxyZ36pppf/VKDFltsJSYMmI9He94PAGHYwKKQtn7pbzdo8eOwhWIoKKsFGNO96IqUyCkkN/Oi8P/aP7b53uCMbhDdM0Zh92sm1LzftAVwslRH/qcQdiMWlSXpJw9FkMArc6k5mvrNPGEgnBc4d89fySBSCDKLlnUHlzuSpvK1Ndp1dBrrFjb0AzTYC8Lbf33PwxcvYP/Tg6g6ddnt+VcI2NCgjAHjh2f/SKCr381j/ka3vFuaG++dU7utc+3f6qXLIHpvz6OxL+9EuFPfRxKRzsvV5xOqGwLZ/ctCIud0UWudYqALwgzkNi/l8V7QrWkiaPnhMWBSq+H0nWK7a+J+O5d0F13Q653SxCEZyG+9xmEPvIBgMqbTKJ/81uhf/Xr8sJ+THvl1bD87z0If/FzSDz1JC9LDg8h9K63Qv+GN0H/+n+Hap7rIgkXDmXqUCIV14VM/c/LVFBBq1HNWTZS2tKTLPZJvA/6Imz9GTQkOOv0XOt0CoIgXAxU3iMYjQNKnMXc8rJyeH0+aLVaDA0PcQY42d2TxX1CSXDNdXrUqpfCODCEZZ4hXk9Yo8POynpUeXtw5fZrWECnrHoS0AkSm/t6+9DaupRF5WAoVc/eYrYgEAxwHW69wQSdrRxh5yi0yWgmE93lcrEI397ezkI9Zd4Tbrc7s4yy1SnL/7HHHsORI0e4JjxZ/pPAT68pRPt3EsrTYjmJTOTaMu6PoNJKwRSnf4vWrVvHnz0Wi/H8ihUrMm3m8/uh0agRS5z+/DsG9uOP1h3YdfAElyKitjl+7Dgfd6K6qgqVVZXcfoFAAJpACMFIDF29AzBqwIEFIuILQgr90mXQt7Yi2t0N6478E/DpGpMyyknELzVrM3bxFPjT4why1jmJ93aLARXWxe2yQZ/dSg/D6eFvaodYIolIPMHn2WAsgVg4hmg8CdOqrVhLAj451Tz4IE40beR7AQ4OUKt5msR8nqdpeqZ5NT2r2BmAXkNlP2maXkPnbgnUFYSFQ22vgOl/vglVWRlP5xrN8hUw/+RuRO/+KbsDGP/rE1AZTbneLUEQCgQR8AVhlno5mU6y/XTtQGFxoL36WkRPpbJl4zsfFQFfEPKc2F//jPAXP3u6fpjBAOMnPgPdjuuRT6hr62D6n28g/s+/I/y1rwA+Ly+P/vgHHG1tvOtTZ1jvCxcP2dBTHczUc5KfM9OJ1N9oOj45nf575pFMcuZhys0+ZYeaEvApez6VQU8DbxoViflqnqbBOq6hSQ+Dluttnk82Dg36kZUpDRz62No0VYvaatSizKSbsS6nIAjCXEDnPbLPD8cTQCzM5z+yTSfRnsR1EoRJaCDxnkQOEoXJ4p5E3Yd6gjDFIhg2V6Au6MAjjZtg1ISxvLmWxXqqxU62+3pDShCiDH6yeo9GI/x32o7NZoNOq0MsHuPseb3VDr/HiTKrEZbJ+u7TM9HTNe2J7Dr3JGCT9T89KPPC5/PB7/ejrKwsk51fyJBIZDZoYIqoEYjGUWI8nVWaRqfT8eeksgONjUs4E99mtUKt0WC/2YBLJ+MerxvYh9+svAHtjgiWqhP8I+fz+1BWVsrHe8IxgV27dnHwQ011DVYuWwqtzY64z4me3sJzMxCE+aTq7W/jR7SvD7pJV4x8ga4nnf4oC/iUXU8Z45gMTO0c86N3IoB+dwg1JUaUZmWqFxN0ztNrU0L8dDTX7gAe/D+erj7yDI7HoggktIgnYiz6U0Y/vZ8Eerr2Z6F+8v4gvYwedFugUZGYn76XSL0m81CpQLHdqedUsDA9JsLg4Ap6P22H/k5xxPQ3utOgaS7nRs+TTl80kfrb5Gv4Q9L/qddNzk7+k1qeaoesv01poOzJM+9vzjWuOdfFGCRoojig0qj00N/xkinLNUuXIZ9QaXUwvOFN0L3wDqgrKs/4O2Xlq+32nOybIAj5jQj4Rcjtt9+OQmXAFcTeHlcq4nWGi+05IZnEqkceRXq450TLevg7xdp8MWFq3YSVk9PhnTuxt330dE2iHGJq3YzH5bsmCKdRFNTd8xNU//13mUWxMju63/NJhBpXAgvUX867b67cBu3nvo+m7/03bEdTddLijz2Kide8Gt3v+QSitQ1nHdQ426DIsw2iqKYNWGT+lDVAM+Vv05afsSx74GfGgaCswaSsnUkvm/lzZi/hnPfU1GTmO02QeE7CUToTnv6WLbSnxXf6W/pZUeg1SubvmWUk2qeXpQX7rHXx+mdrm8m/E2khn54pm4ZtNHUp2016mPRaHiitsOhRZp6aKTkbNKiqt6oRjCbgDEbZ0poGXmlAlep6Cov7ulYQcgEJwaF4AmE/id0+PueSeO/xePhcSwK7VqPlTPpIMoJQMMSicCQcxdPuBHy1a7C3ZhW2jJ6AT69BucGH2gob12Dv7unmevdkvz/QP4Daulq23SdbfqrhTmI+13BvbMTAwAB6BgbhdfaiyqLHiqWNGZF+eiZ6NtnL9uzZwxnnDQ0NLNjTNg4dOsSZ+Ndcc82U9eU7ZFOfHZxA+06flUR7CrigLHyrIcm/QW6Xmx0HyC7f6XTyMeru6oa30sttGwqFOJhhXziMsFoLoxJHk28Mrd5h+EuXYP2q5Rg4dRzjE+N87Cnowel08fdheHiY17Fjx3XQ6XVQl9sx0ddZkG4GwuzIb+fcoG/KL6dGcnia8EfgCkVg1NG16WnxnmrB9zmCGPaEUV9umpKRLpwm0rICgZVrEWpeBs+WK1FVZgbUmhmDhyk4OB00nLbqTyh0C5talr5PoUdasE8L9SmBfnKeMvSRWmZsWI19va6M+xffTky+jjhDtE8vzL6Xm0GkT795yuys92pZbyhQ8f6cd1QoaGwHdqPlG5+BKh7D8YQRvs3bCmPM1jV1HSV7n0TTd76AgTe+F+7tOy5+/YJwgbgDUbRUWtBYnh+lhs+V2xf5mJBcsRUhlKHQ0tKCQsQdjGHAFUI0kapZNR/YxgexcWyYp2N6A/aUtkAZSmVRCosEfTUaS8ph9rqg9Xsx/tQejLeuzvVewef1wlZSkuvdEIS8YfPf7kb1zr9l5l31LXj0tR9GyFgBLOB5+cL6phaHX/UhbPzn/2L1zr/yEuNQHxo//xH8/f1fnzVo6HzF+6kZEmdfx3RxP70we6AnexAoPTn15acF/LR4n97mtJCBcxgUSpEt4KeXZAT8tK39ZEZ8WsxPi/Nsc0+DWpPCejrjJZM1P5nhoif7yqyBs7QQnz2QdjayBX8ahKMB0khcgTccQySm8Dxl1VOdexLxqaa93aJHhdWAcvPZM+rpeND7yD6fLE/HfRG286T1U5b+fNbZXAwU8nWtIOQCEoPJ9cMxOszCeuvSVq4tf6L9BGffWyxmzub2eX18HibxvmlJE4ZRDl8sdT5SVGo8U7Maa5PdqNEZ0LaqjQV8i8WCysoqLF++HIqS4PU3NjTyIxKNZmq4l5WXcZZ80mCFFnHUlhixZuWy887wJlE5GAyira2NRWsKPjh16hSfEwrJ8p3E+3379nEwAn0eCkYg54P0Z8hk4UfiHNzV39/P4j0J/evWruNa9iMjI7Db7diwfgOam5vxwAMP4OTQMHaZynFdYDyThf/z0tuQMBphNpkxOjqG3p5eDrigbVbYK1jQpxqvRw4fhr26DuNOF0yIcvsKiwf57Vx8sGNKIApvKMbXvNmBoB2jfvQ6glySY4ndnBH2hRlQqdD5sf85a9Ok7jEoiPfcWzAt5qfvY7KnM/c2ScDldKKkrIwDjtP3QfycPc0HfOp86j5q8q4p/ZrMd2NyYdZ9V3oi+3XTv0/ny/m+4wI2IQgZqk8dwbqffA7qeKqUUM1PvolnPrACilZXUGO2pcO9WPOdL0ITjaD5O5+H//gJHLr532iAY063IwjnAt1rUGlH+g0oJBeTnkU+JiQCfhFy8ODBgv9SN5abUG6Zn1pdlQcfyEwH112CVU2FMfAjnB/BrdthfugfPL2h9yCGr7w85014YLQLa1Y15no3BCFvUN98K2IHdkLn88CzeRsG3vphtOagVtjF9M3om96O3rWrseTHX4MqHsfoG9+FVY1lZ7wuOQeDHZlc9lkGZLLfl/3a6QM86eGd9OuzB3rS75vyt6zlZ/ztWfZ5ZveALAvIrKx/WpYW5zNWklkZKfMJi/ya09sxYerAJw26kejuD8cx5otg0BVKCflGyqTXotJqwBK7CWa99qyDgZR5H4kl2PaUghUpMIBEfBL3hcV7XSsICwU5fASj8VRAVCKGcCiMpUuXsiBM4i1lz6s1as7CTlmyN2L1mtVYs2YNftU79ffXnPABISeShghb5Tc1N3PWN62PMrdp2jHhgMFoxPoN68/YF4PFhjVrV6PGZkJNieGCBolIwCbheXx8nK3fyeadasNv3LixYMR7gjLvSbw3Go0c4ECfh+bTtvX0OxIIazERiMJiSHIwBB27+rp6bmsKsIjH4li2bDm2bt3CGfonTrTzcTym1WUE/GsHDuCna27Do8eGUDLamwmyCIVD0Gg0vO1EIrWMvhP9g4OIaYxosNvgcns40KCQ2lWYHfntXHx4Q3F4w3EOAM2ua9/vDKLPGWDxvqnCLNeUOWL6vcRs9HeMYHlT7YLskyAUKubO41h69xehmRTvI5U16Pvg57CqrqLgxmz1ajsSFZXQDQ/w/NqH/4hGzwj63vJBKKbCyoIWCp893U4UIgcX+ZiQCPiCMI2Sg7sz095Nl0n7LFK8l1yBykkBv3TfLgy/4t/FZksQ8oxQy3LOgKh45J8Yfvnrz7AvLBTcV96ASH0TTL2dCKzfMmNG+nnJFrO+uHAiZBfjoByJ7PSotBlYePeF43AEUmJ+uSWMES/VGzWhqdwE81lSdsiWv1KjhicU42z8WDyJUrMOJUZtQUVBC4KQf5DLB5XqMOs1nA1PlvZUlz4YCmJ0bBQqqtGr0XAmPdW8J4GcxPvRQAK+sAbISmpSjXfA4+uDwaLmWupklZ9eHwUDEDRP25kJzibnciEXfm4jm3nKVCexu729ncX8pqamgrLOz3YSIAFdr9dzMAJ9nrRtPZVbsZCIH41zu2UfO2prek63NYn3JL7rdFqUlZYh2tIM38QIbNEQqkNurHH0oMNsReWoG7U1tTCZzCzYk3BPQRtWqzW1TYMBdXV1MJZWwaxTY8Ll4UADEfCFYsZ1zz3w/u3vsF57LWzPuRn6xsa8Cc5yB6PwhKIc+JkObiU7/c5xP7tY1pUZRbwXBKHgMfZ1ofVL/wVNJMzzsfIKdH3ki4hW16EQofKKHR//OmfflxzakxmjXv7p96Lrg59FvEwCJwWh2BE/DkHI7hChICwnjmTmvRtFwF+s+FdvRMJg5GnD6BAMw/253iVBEGYgWteYCrApUPE+Tah1BZw7bj1judbtoDTInOyTMH+QnT5Z6DdXWLC02sLZrqfGAjg25MEzvU6cGPGxCHO2bHx6v16rxkQgzAOwVP+Y7DYFQRAuBKrPG4okuEYvBRuRWEz16EkkHhsbYwHZ5/OymF5aWsqCvJJU0NHRgV1jGnzuyR/iy499C9cO7Ic+4gU8Q0DYjWg0gqGhIbavT6+PatETNE/bmQ65AFDpE4tey8EEFwqJyWQzTxn32c+FJjJnOwmQiE7PNE/L01Cgg0WvRTCqoKGxcUpb0zPN0zE4cuQIjh0/xgEYCSWBrt4+7C2rzqznuoH9iJoq4Usa+Bi3tragpqaat+t2u2G1WLFixQoOgmhrWwUTlXcJR3D8ZCd/TwShmPE9+CCCTz+NsS99Cf5HHkU+QNeG5NzkCce4JBNdO6YDttpHfBhwhviaMttSXzi/MULDUJ80mSDkAfrhASz94kegDfp5Pm4rxakPfb5gxfs0isWK7vd9CmO33pFZZurvxvLPvB+6Cbn2EoRiRzLwi5DLL8+9VXi+Yj26H+pEakA91LQUcXtlrndJmCeSej1867egbM8TPF+ybxfG65ty2t5LlxZWtpAgzDW2A7sRq6hGeEl+9YX56ps65ziWffp9CLWuRN9bP4TkPNZrE3Ir5teWGtnO1OGPspA/4Y9ixBNCQ7kZrZVmaGepcWc1aKHTqOAhS/2YwoO0NAhL2ZhCCrmuFYRzIxBNIBRPwKCl2r0qrkNPdvMk1ldXVyMUDOH4ieOYmHCwuE7LKRu/1F4Fc28Aq129vJ6V7n68edurkdQoqKm0s+07ZcGTZT6tjwIABgYH4Pf5uc76dKimYiCS4JIhJaaLdxYhsb7QBPsLcRJIZ+GTKKfWWzPHjuz0KfOexPt9+/aho7ODs+rXr1/Px6+3txfPaIEdk+u5evAgvrfhdvjMdTjZsw8rW5pYtKdHS2sLtl2+jV938uRJHD58CNFoDKOeEIzJMLq6usVGf5Egv53njxIKIfjUabdG645rkQ84A5R5H8tcNxKReALHh7xsn2/QqVFhPR0MJJwb+tFBNNz9bViPH0K4qRUdn/zmgjSdjAkJwszoJkax7Isfhs7r5vmEycwZ6pGG5gVrsnntn2oNhl/5ZoQbW1LlFxWFk82Wf+Z9OPWRLyBa0zB/2xaEAufyRa51ioBfhNCNvjALajWCrStg7u4Q+/wiwLtle0bAL933FMaf9/Kc7o/JtPC1vQUhX7AcP4SWb3wais7A0cfBlWuRL8xH31QH/Bw9bpgY5Yf6qyH0vPNjSE46gwiLX8jvGg+wEEPi/MoaG0pMMwdwkGhTaVPDHYxhwhdBPJHkdZj1chlPyHWtIJwblPVOD8rkTkMiPj2Ik+0nWcBPJOKw26uQSCiIxaI47DXg1lOp62ViZ/0G+DxDsIW9UNtKM/UGSUhOC/SEP+BHdDDK8yQ2p7dDFv5ayr43UPa9lgVhsmanLHLKOCfRutAF+Qt1EqCa92drBzp2A6N+HO3shUkVh8lgQGVFBQYHB/HMnmdw9OhRzqJvbWmF0WhAS3MLzzsMBkw4JlAZCaAkFsTG8U48XdYEd98eDhqgAI5LL7sUL3j+C/g4kQ3/qa5TGB8bZxeGsrJqmA2lCMcTYqO/SJDfzvMnsHs3kpNlLfTLluWFfb4vHOMHuTpVTor0FOx5fNiHflcQcSXJpZuE8ydhLYHt2AGoEgmYu05C63IgXj7/v00yJiQIZ6L1uLHsCx+G3jGe6p96A7re/xmEWlYsaHMtRP90XfMcJCw2NH/rc1DHY9A7xrD80+/HqQ9/HpHGxVvjWxAuhtJFrnXKyF8Rcv/99+P222/P9W7kJd5LtvODLY2llvCih0okKDo9AqvWw7PlChpxBHJYX/jo0WPYtHlTzrYvCLnC2N+D1q9+HOpYjB+NP/smTn7mOxxUlQ/MR99UTGZ2ATEOpcp3UL2zpV/6T3S/91NQzJY53ZaQn0J+uVmHQXcIvlCchXyy22+uMGfqlmZDy+j1vnAcjkAEipJEmSXJGazFjlzXCsLspMVxbyAMv6JFaWUdKhurpryGxFoSfrt7TovoExMTUBSF/54MGHDt4IHM6x9s3oTS8BBqrSVsj+/z+pBEEn29vYiEwxgcGuR12O12tnGneRpUIWGYxHw635WbDSgx6nj/KGucRGSy8KfMc8pEL0Qb/IvlXJwE/B43Tp04ip6eIUTDYWiRQDgShsPhZHv7cCjEx62ru4vbNBaPcWY9XU89WFIJk3UjHm3cjOP2ZqihQkhXilAkJdLTsUwHWdAzzQ8MDLC4rzVYUFJWhpBzhL8jQuEjv53nj//R05b51mtzn30fjStwB2KcfV9m0rGzCtEx6sOAKwhvOI6WypmvK4VnhwQ0f9t6FvGJkv274bz+tnlvOhkTEoQzKX36Uc5GJxStDj3v/nhOEj4Wqn96t1yB7vd+Eq1f+yTU0Qh0Hicsp9pFwBeEIr2uFQFfEGYgXlZcA0bFSsJWiiPf/Z1kvApCDlGHAmj5xqegCQV5PlZmR8+7P5E34v28oVZj6FVvQcJkQe2f/pcXWduPYNkXPoRTH/oC10ETFjcGnQYtlRbOqu8eDyAYTXAN07YaG2emTodspilLPxiJYyIQQTyZ5JrW5WY9210LgiBkky2OT/jCiOssaKjzoMKiy2RZk3DffrIdJ06cQH9/P7QaLVvikwhMf7e2bMBVA4ehV1IlxtrLlsCyZjmugh0R5xA6OzsRDARhtphhtVrh9rhZ4F23dh0LyxX2ilSN9snsfDrP6TVqWAwamPQaHO3u5v2jbZJgTLXfaZ4y0YtNwD8XKBhjYqgfNpMJ+qpanDp2EP19vdBoNSgtLYHFYsapU6c4GMLpcPLy5uZmrFyxEg97POhpvRYqa6pd6VdDXbsKzvY+NKvUqKyYWjqO5pctW8bBGGVldvRPuGAwmqHX63P06QUhd3Dw0SP5I+DT/qSs86MwaNV8TUmMeMKceT/mjXBQ6GwlmoRzw3vJtoyAX7p/14II+IIgnInjptuhmCxo+Nk30feWD8G/fsuibyb6jFQioPXLd2HkjlfDee1zcr1LgiDkCLmaEwShqBG7akHIZQdMYsmPvgrDyOBpK7QPfBbR6triOCwqFUZf/BoMveLfM4uohMvSr3wM6nA4p7smLAyUFVVdYkSD3YwxXwQdo37s7XVh2BOa9T1mgxZlZh1nXNHg7bifbPVTmbKCIAjZYi+J4ZFoDN5gBPsPH8U///Zn/OWvf0FPdw+OHDmCp3Y/hQMHDrLYr9fpUVlZCY1awy4fao0awaq1eG73rsw67229FC0VJmzftAaxWIzFe/ots5fb4ff7MTQ0zOKxw0luZuBno8nINdrT2fdWoy5TMoTEfnp9VVUVC8P0TPOS5T0z1C7RcBC1VRUwGHQwWCwIBAPQaXWp9h8cYsv8cDjMNq/U5vFYnC3249EYYn0Hp/4GVS1FVG3kTH2v14s9e/bi8KHDHLxBARUN9Q28zd6ebkQjUVTX1aOhSexbheIj0tGB+PAwT6ttNpgv2ZzT/fGG4vBFYmyRny6LQuVJTo37MeQOs9NTWtQXLqKdN2/LTFuP7pf7M0HIIa6rbsTxr/4c3q1XFM1xCLStx4kv/QgTt96R610RBCGHSAZ+EUJR+IIg5B+SaSQUG5X/+gvKnt6ZmR94/bsRblqKYuub47e9BAmjCUt++g2et3QcQ8vXPo7u934aScl0KwrMeg2WVlk4Y6pr3I9YQkE4pqClwsyZ99MxaDWwm1VwB2OIJ5JQkklUWAzQa4svNleuawVhZkh4pYx2lz+MI12DcLo9CHkmECXRPBDkzGq1Ws2Z21qtBo4JBwxGA7Q6LT9UJiuWuB2oDrl5fW69BQcranDpyAD64g5+b0VlBWdpBwJBeNxuOF1OtlynLHDqm4lEgkVgEoMD0QSfu8wGDYyTwhLtA9nm036SeE/PNE/LhTNJt5ffNQGtrQKeQITFe3I+iMXiGBoegsvlRonNhpraGnY2IDF+fGKcj3l06CnoVl+X+V1RW8phqFkOq02LgcEBhENhDrjweDxYt24dP6j8ATkoxFVaNDY0wGJL2ewLhY38dp4fgZ2PZ6YtV1wBlS53JYwi8QQHcXpDMdgteu7PdB14ctSHYU+Yz6/pICnh4ohW1yHU2ALTQA+XebMe3cfW1vOJjAkJwtldVHNJLvrnTA7BqmgUOtc4ojUNC74/gpCPNC9yrbP4RvkEbNokNbano/F5sfwT70LNH34JU9dJ+ZYUK8kkVJHcZb0uaVqSs20LwkJj7jyBul/9IDM/cf1z4b7y+rw8EAvRN53XPxeDd74lM287egDN3/osEE/ZFgvFkY1PGVOVNgN6HUF0jvrQPurnQdmZ0GrUsFv1iCkKHL4Ixnxhzr4qNuS6VhBmF3v9/gAOHT8JXygCi1HLlvYk7JP1PdW8p0xtj8eL6KTFfSgUgk6nR2vrUqiXXoHn9TyVWd+9TZdC5RtGX/shjE9MsDhfXlbO4j2V8ejp7WGRmOz3CcrobmxoZBG4pKwUAcq+N2hRYjwtLLW2tqKpqYn3o729nZ9pnpYLZ5JuLyUaRn9PFywWC0rKy6FWqaHTaVFfV4+yslKo1GoOpLDZSri+vcftQbm9HK1VNsAzBGs0iJt7dsMWDcDSuhGm0kr+vlRVV2N0dAxPPPkEHnroId7m+g3rsXXrFlyycT1MVhtCseL7nVmMyG/n+eF//HTAsfWaq5EryFWDgje9oSgHf+o0qSHdAWeI7fN94ThfSwpza6OfpmTf6d/E+ULGhAQB7HZR9+sfQT1ZZjFfyIf+qQ6H0Po/H8PyT78f+tGUk6UgFDubFrnWKRn4RcgjjzyCHTt25Ho38grbkb2wnDrBD9vhPej8+NdyvUvCAqIfHkDlA39Fyb5d8K/bjIE3vCcn7d9+oh1tq9pysm1BWOigqeZvfQbqREqcDrYs53rw+cpC9c2J57wI6kgYdb/7Gc+X7n8K1f/4HcZe8Ip537aQP5SZ9SzO97tCiClJROMJrK4ryQzSThf9y806eMNxOPwRkG5WbtHBliWQLXbkulYQpkJ2+GSfPzY2Bm8wBI8vgLhGj9JSM4wlNvh9fq53r9PrUFJSwuI9ZVyTMNTQ0ICNGzdixfIV6HpoEJvHO3idCajwUO0y+EeOwqQOwOks48xssm2PhMM41ZWqu04C87Zt2xGNRlgQpvWXlZexeG/QqKdk36czmS655BKueU+BBfQeWodkIM5Mdns5/SEEElp0VZTj1PHDqKmp4eAJCs44ceJExga/rLQMRoMRK1eu5Oz9hj3347ahE9ApCWiSCh5qvRQGc4JLIhw8eJBdEJxOJwdTUBAABWDQMSSHl4SSRCSWYJ3K3xEAAQAASURBVJeYmX6ThMJBfjvPHSUYRGjP3sy85aqrkCvoeo9EerLOLzWnrvW84Rh6HAEMeUKoLzNBoz7TuUm4iDbfvB01f/kNT5fsfwpQEoB6/soTyJiQUPQkk2j8yVdRvusRlBx4Cj3vvAuRhqa8aJZ86J/N3/g0J3sQy77wEXR+7CuI2atyuk+CkGseWeRapwj4RQgN0AhTsR06fUPm3XipNE+RofV5UHX/n3havX83WAFRL/ygFGU9CcKiR1HQ9L3/ht4xzrNxsxW97/hYXlvFL2TfJLFeHQqh5m+/hXfjZRi/ReqdFSOUpdpUYUa/M8hCSSyRxJq6Epj0Zw4YknVqqUnHtaUdgQgLLPSgQIB8ExTnQ6CT61pBmNrX9u3bh76+PhbUEyotdGYbDMkENBoNAv4A262TOKuJaKDVaFFSWsoZ3NQ3t2zZghc8/wU4OB7FNZ1/yKz36drVcPnHUKZPorKsgoV5m83GfyPBOB6Ps1378uXL4Xa5EAqHOFN8wjHBgQEk4JebDVOy79PQuUAE+3Mn3V50nh9yhRCMJ6FEgjAZDeywQO0dCoWh1+lgtpixYuVKhEMhLnkQi8agqKMs3hPXDezHP1u3w60qwa6ndmFsdJS/G3QsyUGho6ODAzVIwCeopnYkoXAWvgj4hY38dp47ka5uqAwGJGMxGFauhK6mBrkgGlfgpez7cBRlppR1Pp0HOkap7n2IbfMtBhninWuCS1ciVloOnccFnc8D86l2BFeswXwhY0JCsUNlFkm8J4xD/TB3teeNgJ8P/XPs9lfA2n4E6mgE+olRLP3Ch3HqP7+CeKmUOBKKF88i1zrl6k4QkknYDp8W8H3rt0ibFBnB5asQs5XyDRndmJm7TvIyQRDmAUVBtKYuM9v/5vcjWl0rTZ3FyMv+HyJ1jXBfcR2S2uLJpBamQlmqLZUWFvGj8QAL+esaSlncnwlarlGp4ApGoSDJ2Vl2s56trfNJUKQMUJfLxVmkItoJwtxCgTLU10iArW9oRABGOMJAxOuAx+WCx+th2/vmpmb4fD4YjEa2XDfW1rD9fbr2/J/2D2GiaStMiSiu69+H++rXo8oUxdLaWqxbs5pfS1ngRG1t6jc8GAzh6NGjnPGdFvAp039k3AmjxXZG9r1wcVCWLZVFaF3SiEjAB9fYELq6ulhwv/XWW1BiK+HjSw4Jhw8f5kALstNXNy2B0tcJNZJY7+hCRciDIYMJaneQvxO1tXX8PTAZTRgeGUZksrwCYdCqEYwmEI4lZgzGEITFiGndWqzc9SRChw5BCeZGvKHAHLq+84RjfB4lRwyieyKAYU8I0YSC+nJTTvZt0aNWw7v5clQ8cm/GRn8+BXxBKGaopG39r76fmXdcdxtcV9+U033KNwJt69Hzro+h5X8+wY6WxuEBLP3SR9H5kf+GYrHmevcEQZgHRMAvQtIDM0IKY18XdB4nT8eprl/rCmmaYkOtgW/z5bA/dj/Plux7MicCvlYnp2ShCNBqMfiatyGwci0MQ/3wXrId+c6C900SYa+5eWG3KeQllOHYXGHBoDuEnokAD+BuaCybNcOKMvRJ1KFBXsrKiieSqLDqc5opmS0okp0z2TPTPIl/cyHgy3WtIJyGXC4oUIb6WkylQ03DEjR6/ChZ2sh9b3BwCGtWr4ZGq8HoyChGRkegJBTOWqCs7YGBAezccwh7exNQSuvxzU0vwY/XPg+VGEebNYJLVzayPb7RZMTQ4BBb5yeVJKxWKwv4Q0ND8PsDWLZ0KWd7J+IJdPb047JLNsBm1C64Q8diYqZ2spaWoaG6ApF4G2rtpYhShrBen7LOn8yaJ6KxKJwuJ7smkD3+yYp6rHKk6qZeOXQY95m2oUJt5L/Tupubm3hbFIhx6lRnZp2lZaVwh2KIRBX+jRGr7sJFfjvPDxU5WmzJXaKHLxJnpyUK5qw0pRyWnIEoB3mOeSPs2kRllYT5s9Eve+pR+NZvRWDl/Ir3MiYkFCuqWBRLfvBlqBIpl6Bg60oM3vkfyCfypX/6NlyKvrd+GM3f+hxUSQWm3lNo/Z+70PWhL+S1s6UgzBeGRa515seZR1hQbrnlFmnxLKjmfRrfui3zWs9KyF88m7dnCfhPYeRlr1/wfaAak4JQLLi3FU59onzpmxUP/BUJiw3u7YXTdsLFQwJJY7kJg64Qeh1Btkzd0FAK8ywiPmVlkWjvDsbYbjWuKKiwGGa0318IqA431WOuq6vjetkkzJGARCLU+TCbyCfXtYJwGuob5HIxNjYObUklRhwuVFeUYf2alODw2M7HOCs+nohz3wwFQ/B5fairr8OqVW3QarX4zTP9UDT1mXXGtBpYIx7YtFqMj42xeE927GSvfqL9BAcA6PSpbGwKMiLxd9myZRyMpqg0XFvdotfCrD/znCUOHRfvZGIyWFBpL4Ohxj5jGxOVFZV8TEZHx7hcwqnKioyAf9XQIfxl2VVQyhqgibr5HEs1XimogwKvDh86zIEda9aswfZt22HQmxFOpLLwxa67cJHfzsKBruU8gRg8oSiXTKLrwHhCQceoj63z6ZpP3E3mF++GrTj6nXuQ1OmL5r5TEBaamj/9L0yDvTydMBjR+/aP5p0YnU/903PZ1eh/47vR9MP/4XnryaNo+v5/o/dtH81JSVhByCW3LHKtU3p0EUKDqMJpbIfEPl8A/OsugTJ5Q0YXjfrRoQVvlpHhYTkUgpCH5LxvKgrqfvMjNN79LY5Ktxw/lNv9ERYcyqpqKDdBAVjEPzzoQTAan/X1WrUaFRb6TUvC4Y9gzBuGJxTDQpMW3Snz98CBA3wNumfPHiiKcl5R0mnx6uDBg1Oeablc1wrCaSiwhazrfaEITnR2w+vyIB6NcC36kx0ncfLkSRw/cZxFWQqkISHfaDKx7TrV9ezt70e/MrWGpsY7COdwHzzjI2hqbsKa1Wu4TjoFAJDYSw/qi4MDgwj4A7CYLZytTWXKVHoTSswGWGfJvs926Ghra+Nnmqflwrm1E5VPoYCuYCSVsTYTdDwa6hsQCgUxNDyEocYGKEhl6651dKM87IWmZiUsFTUIh0IIhoJQa9Sw2qxQqVV8rPfu2cslEgw6NSIxBaHY7NsT8h/57Swc3MEovGSdr9XAoE0FY/Y4ghjzRZAEYOfrPWFe0WoXRLzPi/tOQciRdX713+7JzA+//A2IVp8uu5gv5Fv/dF3zHAy+8k2Z+bKnd6Lutz/O6T4JQi44sci1ThHwi5D29vZc70LeoA6HYDl5NDPv25A7WzQhtyhGI/xrN2XmSw48veD7MDIyuuDbFISFwNTdgYaffh3qYKAgGzzXfVMdCaFk/+7UdDyGlq99EobJ6HShuER8ysQn2+JeZxBHBj0IRWcXUChDq8ycysqaCEQw4U89FIWGexcGEpfi8TjXyK6srGTBcGRkhLN8SWicC/FKrmsF4cy+H1VUiCaSUGIhtrHv6+3D7t272Tafylds3rwZ9fX10Gp1LNi63W6ukX5gLI4N7kFYo8HUypQENI4uRN3jLNLrdXqs37Cet+Hz+znjnuzZSUWKxWM8TXXUqRa7Sqvjvr9yaRMssziApC3/q6qqoNfr+Znmz9ehY7FztnYy6TQwU/uqgEh85t8EstOnrLEVy1egpaUF2uoaDNSnzsFqJHHF0GFMKCbUta7C8uXLUVtTy0EdJPw3Ni7h78zY+DgGBgdYQKTtUAY+HX+hMJHfznPDeffd8Pz974i7XMgFvnCM7fOpxn06EMobiqHfFcS4P4K6UiOfj4XFQ67vOwUhZ9b5CoWqA/5VG+C44Xl5eSDysX9O3HIHxm9+YWa++h+/h/2Rf+Z0nwRhoWlf5FqnCPhCUWM9dhDqRCqDLbSkFfEyqbdYzHg3XZ6ZLjm48AK+ICxGVPEYlvzwK6h86B9o+/CbYM4KmhLODcVkQdf7P41YqZ3ntUE/ln7pv6B1O6QJi1HEt5u4BmqvI8QiPokoZ4MsjsvMOs7g4mx8X+RZ3zNXkLhEVttbt25l4X3Tpk0sPJ1vjWsR+QTh3J0qunp64Q2E4XB74HaMQ2/QY+nSpVyr3uF0cPY81UMn0ScQ8LPwTtMU3KOULsfHdv8M/3vvp/C+vb+G3tkPJeCCRR2D1+NlAZcwm8zkkM/rIjt3ytImVw2tRguD0Yi169YhnAA2r1+DxtqqWQWmtOU/uXREo1F+pvnFXsfwfDlbO1Hb0nneoj97Fj6J+Ndffz2uvOJK1NRUo6/hdGYb2ehHklocH/UhTs4JWdar0w8dlXXRqlWIxBWEY6nBdkFYjCjRKMa+/g0Mve/96LjiSsQWOPOSbPLJPYkE+xKjlq8BlWQSneN+jHrCKDPpYNBJ+cecQEJjfHYnLEEQzp2aP/3qtHW+3oD+N75HLODPB5UKQ696EzxbruDZUENzqjywIAiLBhHwhaLGdmhPZtq3fmtO90XIPd6Nl2WmyaKaHBoEQbg4qv52D0z9KStcbcCHeOlUa17h3IhV1aL7/Z/ienCE3jGG1i/fBXVoMktSKLJMfDNnQFImPtnpz5Z1mYYyJqlGKlkej/vCPPDrCkTnPRs/LTqRAE+ifXV1NVatWsXPF7IeEfkE4dmdKlQ6ExqaW6FTJTE4OMDLKCOesuyprnlPdw9n2x8/dhx+n5+z6luaW6AuqcTVnmGY4xHolThWuvsRdPQg7nexaGu2mDPbotrr1I8VEpg8Hn4mZwwW3pNJNLe0sr5RX10B6yx12bMt/ykQgDIn6Jnmz8ehoxh4tnay6LUw6TWcpRufzGA7WyY+lUGIbNrIZVmI9RNdKI34MBI3Y3DCA+NkAMXo6Cj6+/v5u1NdVYXGhkZeTqJhJJbKwheExUpo3z4kg6nrbN2SJdDVLaydsysYgy8Uh06jygj1g64QxrwRhOMKKm0S6LTQWI4f5EzhNe94BcqefmzBty8Iiw4lAUv7kczsCFnn19TndJcKErUGvf/xIYw/50Xo/Nj/IFZ5fvfagiDkN7PfTQuLlmuvvTbXu5A3mHo7M9O+DSLgFzt0kUNODCQ2kk219ch+eLemohgXgra2lQu2LUFYCIz9PRxRnWb4Ja9FtKah4Bo/X/pmqGUFet/5X2j9yl1sMWfu7UTztz6H7vd+EtBIBk4xQWLaErsZ/c4g+pxBzoZc31AKrWb22FytWo0Kix6BaAITgSgiCQXheAJlJj0LP/MBiUsul4sFRBKdSIS/EHHubOshu2dBEFJOFYFAEFUtjQgoGpSYDHC7PYjFOrn/dPd0s/Cb0CZYbE9nxWu0GoyOjWJQuwRv7vlbpin/3ngJDKEJaCJeqG3lLN6mBdyW1hbcdNNNGB0dg9PpgE6nY5t1i9nCmUAd3f24attWWA06qNWz2zuTEwcFA9B7af8pAOB8HTqKgWdrJ/pNsOi1MOu0CEYTKDGqzyri0yMSjaK/egmax/qhYRv9I7hvyWbU1yTRVm1C8liqPAIFeJSVlWHNmjVYu3Ytr8OoVbO4SEFh5QvVCMKcImNCz45/587MtPWqKxf0GxiIxOEPxxGMxVFpTQn1VDap1xHEsCeE+jITB3QKC4ul/SjsO/+VKbnovuL6RXvfKQgLglqDUx/9Iirv+zNsh/dg4sbn53XD53P/TBqMGLrzLbneDUHICdcucq1TBHyhqKHINFNfF2yH9yKwck2ud0fIA7ybLmMBn4R8VVJsIQXhgkkksORHX8mUKQksW4WJ55yuzSVcGL4Nl2Lg/70LS378VZ4vOfQM6n/9Awzd+R/SpEUGCTZkp987EUS/MwSdRo019SVnHdAlwc5q0LL4QrasoVgckZgCm5Fs9vW8zrlkrsS5s62HMkMFQUg5VWhNFoyMO2ApscPv80Kr1SCRUOB0OhGLxbiZbCU22CvsKCstgz/gh0atQXvHKdTU1GCZd4hfE9bo8Li9EbZxD1RasA1/26q2jIBL3HD9DRgaGsKTTz5JSfcw6PWorqlmC/1gJMqBQemazc/Wv0Wwx0W3k9mg4TZ3BiKwGbRnrYvtdrlx/PgxKCU29Go3YGfDRuypWQVFa0DYWIn6Bju8Xi/sdjuWLVvOx3bJkiUs/BPpYDH6/SAHGHJ5EYTFRuDxJzLTlquuXrDtJpRkyjo/HEWJUZe5NjtF1vm+MMxUMsMgQ7m5wLfpMtT93908bTv0DN/vShC1IFwkag0mbr0DE7e86My6PcJFY+48jnB9ExQKshUEoSARC/0i5NFHH831LuQPajVCLcsx9vyXI6nT53pvhDxg4qbbceyrv8DJz30PnkuvWtBtt7efXNDtCcJ8UnXvH2DuSn2nFa0O/f/+Xr45K0TyrW86d9yC0Rf8W2a+6r4/wf7Q33O6T0JuoKx6ysR3BCKcid8x6keSlLRne59GjQqrASatBs5gFOP+CGd0OSkz/1ns+M8XEpy2bt3K1vnEiRMnsGfPHq7XnQ3tNw1axxIKonGFa79mf5b0eq688kp+TgtZcl0rCCkoqKWqrhH+UAxD/T1IIon6+no0NzfBbLagsrKSg2CsVivs9gpodVo01DfAZDYhVL4Ct/XvyzTlow0bEQ8Mo9ygQn19A1paWvl92ZCYu2LFClRVVcNiMcNitXCQgC8UAxIRHHhm95wHBQmzQyI6CfgaTao+/dnE+11P7UL7iXb8MxbHl1bdgMcbNiKsnbTNV6zoG3exeE9W+1u3bsH6Desz4n1mezo1IokEwlEJeC5E5Lfz7MRGxxBpb0/N6HSwXH661N58Q+K9LxzjgMy0Q9K4L4JRbxieYAw1JWKdnytCzcsQK09df2oDflg6jy/6+05BWDAKQLwvtP5Z/tj9WPaZ96P5259LBRwJwiLl0UWudUrYpiAIQhbxyRsyQRAuHP3YCGr/7+eZ+dEXvhKRhmZp0jlk5MWvhWGoH2V7UtlBDf/7fXi3XIF4qZjZFht6bUrE73MEoVOreL618twi7CmLS69TwxeO88Aw2S+b9SkRiLK7aPpsWZznCon1z+zZi56+fgSCIRhMZhzp7IXFWsLZujq9nq25S8vKoSSTnM1Luh9Zb/ODplUqFgPp8+k1ahi06jnZN0FYLFhLy7B81RrEtFaY1HH091lRXVUNt8cNhcqumFdAo9Gwi0V/Xx/XsN+wYQMSiQQGRkpwzb7T9vn/rF0Nc3wcW1atxMoVyxGNRjgjm+qhZwu5NquNa6P7TEbo9Xq2ZU9ADYOaBOUcNUQRQ+dsOo+T1bZxsmb2dOgYHjt2DPFEHKtWtUEVd6Mfp8sb9fuTOBEcxooKPR9zEvyni/cEnYPJ4ptKsZRCN6+fSxAWmsDjj2emzVu2QG1ZmMzFcCzBQVD+SAIV1lS/ooDGrnE/ht1hVJcYOHhTyBEqFbwbL0PFI//k2ZIDuxFoWyeHQxDOh2QStoNPs7MgJdUJ84Ox9xSafvgVni45tAf1v/6hWOwLQoEit9WCIAiCIMwpdb/5IdSxaCZTYey5L5MWnmvUavS/+YPQj78Pescoet75MRHvixgSaurLTeh3hVjwJmGF6qOeCzQQXG7WI64oLPpMBCLQh9Us7pt0Gl4XZeyTaK7VqKBVq2YVzhXKoFcoez6JuJLkQWd63ne0E0e7BqHVm1CxpAG9/YPYe+IgC/nl9nIYDEb0jrqxqq0NZWWlqXUlk6C8TtqSalLA16pU0GnVXC6AHrRvgViqLqxRJ4K+UNwEIgkYzSXYvHEtbEYdVixfjiNHjmD307vh8XhhMhmxYcNGuF0uFm9bW1px6y23Yu/Jflxx4AHolVTJm5NljRjVq2HyezEynMBgfx+qqqr4PST6Z0MBOBWVFVjS1MQDstGkmoN0Sq0mxHyhHLVE8WLWa/n3wBuOsaPJTA4IFGThdDhZnNfpdGjWejGQVJBUpQbRo9Ciz6ugXOWGZXCAnVDWrVt3Zga+VgO3EmMbfXJOoXOyICwW/I/vzExbr7pyQbZJ11CuYBSecAxWgyYj1Hc7ghj1RkBdlModCbnFu/nyjIBvO/A0hl/+BjkkgnAelD7zOFq++RkusTj4mrcitLRN2m8eCDcvw+jtr0TNn3/F81X3/RHhxmY4d9wq7S0IBYYI+EVIW5v8OBr7u2E+1Q7fhi2I2atyfUgEgamtrZGWEAoey7EDKHvmdNbKwGvfDmgL+3IjX/umYjSi572fgCoWRbTmdPacUJxQbfuaEiNb6asnM9Urredus0oDxTajmtcTjinwh2PwhmIsyqSEezWL9zSdFmooU54z5ict8JMKUsJ9MiXiU+3tRDKJEXcYjkAMrZV1UGt1UBJxuMZH0dK8BOuWNXN97oBjCCFXGZYvmSoQ0nqVye3QOkkoCsVS4hTtS1l9C4Y8oUzmKdWBFiFJKDaoPwSjcQRjcVRYUwIPCa4kvFLADVnnu1wumM1mrFixnK3z06LsLw668ZKepzLruq/5Uqh9w5jo68TgMQ/UGjUsFgtamlvQ2Ng4JSObaqOT1brBYIC93I7eMResJj3KLEbY6+Wec6EhwZ7OhUatBqFYgs/n04mEw3C6nOjt6eVsfK1WB+3aFiiWamyc6ER7WRO8+kqojG7E43EMDg2itLR01ix8ysCnrGE57xYWMiY0O8lEAoEnd2XmLVdfvSDHhAJvyNWCrnfSNe5p2YAriAl/BM2V5gXZD+Hs+NdshqLTQR2LwTTQA93EKGKVNYv+vlMQ5gJVJIz6X/2Apy2nTqD88QcLSsAvtP45cserYRjqy4zPNf7sm4jUNCCwekOud00Q5pS2Ra51FvaIunBBpGuQFjPlTz6E6r/dk/lBG33RnbneJSHPMAz0oHT/brZF63nHfyFeZp/3bdbW1c37NgRhvrE/dn9m2nnlDQiuWFPwjZ7PfVOC0IRsSs06Frj7nUEW2zc2lqHEdH7WxiT2kYU+PSiDPsbZ9JSdH2dxngaW01mdaQE/PU2Z8vQ32jY9G3QaFtnJ8tVp1SHqd8Kmr4DfPQE1FFRVVsJg0KOyogJdXV2cGTrT/mhovaDAAcAETUbYH59wIRwM4vHdezmTdGlzI+qrKjkbnxwEzDoNBzMIwmKHxHtyomCnjCw7UhJdr7zqSjQ0NGDfvn0IhoLQaXUsxNPfovEEvLv3ojEwwa/3a404VNeM0LHHEPK5EIvGoCQVKAkFgWAAiXhiio3+kiVL4PF4WOQ92dUDjd6E5S0NaFu+FBUVUpYqF6TKn2jhDkWnCPgUeEHHbv+B/RgfH+fzbTwY4/IKLz/0F9zhHoAtFsJXNr8cjzZtwph3BDaNwmJ/LBbLHO9sIZ+y/el7R8EC5PogFA4yJjQ74cOHoXg8PK2tqoJh5cp5Px4UBOMNxVmwt1v0meucU2N+jHkjKDPr2PVCyI8Aav/qjWxJTZQceBqOG59fFPedgnCxVP/999A7xng6bivF6ItfXVCNWnD9k1wb3/QBLnFp7u2EKpFAyzc+jY5PfgPR6gL7LIJQxNe14nNWhNx7770odmyTF9tEqHl5TvdFyE8af/5t1N3zE1hOHkXJwWcWZJtkcyoIhU7/m96H/je8B5HqOgy/7PVYDBRa36RMkKq//y7XuyHkiEqbgcUbEvGPDXtZXLlQyDqfhHwSZsotelTZDKi2GVBm0vGj3KLLLKstNbIDAGX9k8UrvYfeS1mZzU1NnPFLtbdJqCfBiOpma7UaFggdTgeMJiNn854rHrcHJ08cg3N8GAMdxzDQ1Y5jR4/j1OAYRr1hjHjCGPGG4QvHeBBcEBa7fT6J+JR9PR0SbgcGBhCLx1iAp2ea7+nuwY/u3YvLu07fFz3ctBVx7xAC4wNc016r08JmsyGhJGA2maFWq6cE2qSz/NesXoPWlauxfm0btm3ZxOK93HPmBhLV6dxLsUuReCLzHaBrmWPHj+HkyQ6Ew2EOnFqxYgWWti6FJuxk8Z64augQYiodhkIaHD95ku32+/r6+L20DlpXGnJ6iSaSbKNP9t9C4SD9c3b8Ox+fkn0/W9mguYKuUdzBGDyhKAfgpN0shj1hjPkiCEYTfG0n5A/eTZdnpkv27y7q+05BOJ8xiuq//TYzP/zS1yFhsRVUAxZi/2TXxvd8HLHScp7X+r1o/Z+7oA4Gcr1rgjBn3LvItU7JwC9CaPC0mNG6HTD1dfG0otHCv2ZjrndJyNObMuvxQzxtO7AbzmufM+/bjMdStUcFoaBRa+DccQuc19zE04uBQuqb5o5jaPnaJ6HzuvmGmI6FUHzUlBjQ7wqh3xnijNwNjaUsxs8FNJBNWfXnQ1rkIxtmEv/Iwtnr83INZhL0SbwngZ+yO88VyiSlrF+y7166dCkHAbjGh1BbUQpjTQUCkRj8kRiCUR38hjhKjLqMJa0gLCYoc5MCdUg/JdeL2foK2aGTTcbQ0BA6OjpZwL0/2ALXphfj6drVeG73k3i0aT0CQ4ehjgZgMBmgUWsQjoT5mUSmmQJtqH+bbDbUheMcxFNbYuTlxX7PmUtSLipa/l5Q1u6U7wDVuY9GodPpUVVVxefljlgU8Dn4b5eMnYQ5FsKYYoU6EMG6ZU1Yv34DotHIGXb6ahU5o6gQiStspU/BY0JhIP1zdsrvfBX0S1sR2Pk4bDfdOO/HwhOKwReJccmhsskgrGhcQa8jwMGItaUG7mtC/uDddBnw82/ztPX4AajDYRbJiu2+UxDOh/pf/RBqut4g56iW5QsyxjrXFGr/jFVUo+fdn8Cyz72fy38YB/vQ/J0voPu9n1g0Y3ZCcRNZ5PedcoclFB22w/sy04GVa6EYTTndHyF/b8rqf/1DnrYd2cc1ppO6c88MFISiR24EckLlA39l8Z5o+Nk3Ea5fguDKtUX/dSw2SGRvKDPx4O+AK8TZXGsbSnI6AEyCT7b1ctrOmQR9EgSnWzM/G/S+cCjM0zq9DhX2lA1/lGqSTpYAiMQSPCg+NDYB1/gINEoM5RYjVq0Qe29h8eCPxBGYzL6fqV/RtNPpTGV5ut0IhUJc/7y7cgkmatvYk+/J+vX8aAh2wpCMQGWzIhqLsnU6DYhQFn5tbe2sgTaUIUriLT3mO1tVeHYsdA7UauCbrKed/R1IJOIckDExMY6ODjUfT8vSZRjweNDoGoUumcC24WPYuWQ97LoWrF+/DnZ7ObulzFTqxKhV87k2HFNgllslYRGgLS9H6XOfy48Fs84Ppazz0+fPHkeAs+/J5ULKU+QfsapahBqaYRzqY0dPrceBqLEh17slCHmL5dgBlD2zMzM/+Oq3inC8wASXr0L/G9+L5u9+kedLDj6N2t/fjZFF4popCIsZEfCLEIqaL2Zsh0/bRPo2bMnpvgj5S6RuCVuAG8aGoQmHYDlxGP718/t9MZkkmEQoTDR+LxJmK9fYWowUUt8c+H/vhLG/G6b+bqgTcbR84zM4+alvIm6vzPWuCQsM1aBfYjejZyLAGfMGnRora/LHpnC6oH++kDhJ2cCJRGJWG37KRg75fejpaEf34AiikTDb+49MuHDV5Zegpkr6hVDYxBIKgpEEZ0Ar4SCOHT3KWdIU3EL9gerTkyDkIBv03l6YzCZotVokkUS/rnHKuvSJEKp0cUQsWiT19YhGolz/nMR7ctC45ZZbsHbt2jP6bVxROFu03KyfUnO92O85c4XD4UB3dzfGvCH4E1okljTyeTEYDGJ8fJyz7umcSWUUKJOMSpo0NjbCS1lxO0d5HVcPHcRDTVtgbViJcCRy1lInep0afgqoiiU4QEACOAoD6Z+5J9s6nwKw0tb5lJE/6ArB4Y+ipdKS690UZqH/LR9E1F6JRMmFX8sW+n2nIJwTiQQafvHdzKzzyhsKNsGg0Pun+4rrYezvQc3ffoukWo14WUWud0kQ5oTSRX7fKQJ+EbJjxw4ULUpiSga+b/3WnO6OkMeoVGyjX3X/n3i25MDT8y7gt61qm9f1C8K8kEyi6Ttf4Fpag3f+R8HejC2WvkmuMmSPtuLj7+BjovM40fr1T6LzP7+C5HnUFxcWBzQYTCJ+nyPINsdUG7nJbsZigLJGSZwksXJ0ZHRWG37KRh4fHYLdbICtvgbDEy6c6B2CyVaCa7aVTREc08IXZRwbDAa0trZyLW9ByFcCkTiGxifQ3z+IvlMn2Bpfr9OhorICo6NjCAaCqKuvQygYxNjYGLtVUC37pFqHYGnrlHXpfEMIRsdg1gAavQX19fVYu24t6urqcM3V16CltWXGfeDse10q+54Ch9IU9T1njqBz2L59+7hmvccfQlxngdvjxZqlS1BeXo7e3j4W7Ol70NTcxFb6NquNz3f9DQ1YM7kestE3xiNwqErhDo7D55m91IlWrYYaKkRiCgeS0O+MkP9I/8w9U6zzDTpeRo4Zp8b9GPWGUW7Rcwa+kJ+EWpaj2O87BeFcqHjobzAN9PB0wmDE8MvfULANtxj658hLXwudawKuq2+Gf+2mXO+OIMwJOxb5fadcDRYhBw4cQLFi6jnFggYRK7Uj3LQ017sk5Htts0lKDuxmoXI+6e/rn9f1C8J8YDv4NEoO74W5uwPLP/N+6CZS2VuLiULrm9HqWvS84z85qpowd51E40+/Pu/nMCE/ITGlrsyIAVcYp8b8GPOmbOcLHcoCpqxgEpTWrluHxoZGzvzsPHUKhw8dZivxbKt9qvdtNenRVF2OcDiCCV+E22LcF0E8oWSEr4MHD055puWCkK/Zm4OjEzhw+Di6O0/g0MFDOHLkCLq6u9DZ2Qmvx8PTw0PDUKvVLNIajUaoNWqMm5bgzo5HsH3oCNRKAsl4FP6uA/CO9cNsNqOqqhotLS246sqr8ILnv2BW8Z7EJqqzTtmj2cEwxX7PmSsoAInEezrOa1etgMVkwPDICFweL9pWtqG6uppFe41GCyWhwOlwYv+B/Xj0scdwYGwcg7ZUwJJeiWPLaDuGgmrUNi/nc+ya1Wv4nDuTcwpl4YfjCRbxhcJA+ufMhA4fRjIeX1Dr/FKTLuNcMexOXZeE4woqrBJ4W4wU2n2nIJwNTcCH2v/7eWZ+7PZXIl5euMHRi6J/qjXsICLivbCYOLDI7ztFwC9Cent7UaxQLfM0vnWbOctaEGYjsGo9EsaURRJZ6RuG5/diTUQCoeCIx9Hwv9/PzDquuwWxyhosNgqxbwbWbMLQq96Smbc//gAq7/tjTvdJyB1UP5UGgvtcQbSP+OAOTq1hXKiQkBQKh7B82TIWMwcGB3D0yBEcO36MhUwS8dNW+2T/TDbQLpcTZRY9Ss0GuIJRFvIp0+1Yx6mM8NXW1sbPNE+CmCDkI4FoAh3dfRgbHYHZaIDVZuX65vS9J5t8j9eLwcFB7N23F8Mjw7BYLVxywufzwWKswSvaH8BdT/8MP/3X52Fy9SIR8sCiUbBjx3VYt24tVFBhdHT0jKCYbMLRBAwaNcwG7RmZosV8z5kryD2ErPLJJp8CNuqrK5CIhOANRbn8QVPTEmhJvFcSiMVjcHvcGB4eRsfJk3hmzzN4SnX6GG4fPgJnKIGgtgRbtlyC9RvWz1r2xKjVIBpPIBRLLOCnFS4G6Z9nEu3rQ89LX4aT26/A4Ac/uODW+ZF4Ar3OAEY8YdSWGKGWsaqipBDvOwVhVhQF7suvRVKj4RKl47e8qKAbazH3T1U0wuN7glCI9C7y+06x0BeKCmuWgO8nAV8QzkJSp4dv3SUo2/MEz5fs343x+iZpM0GYxP7YfTCMDPJ0wmzByItfK22TR0zc9AIYe0+h4rH7eL7+Vz9EuLEF/nWX5HrXhBxgt+i5XnafMwitRoUNjWWwTMuYLVTIJp+s9FmwqqtnsZ7mqRZattV+V9dpG+hlLU2wWQ3whmMY90cw5gljwhfGxsZG6PV6FsDa29tZEBOEfLXP94UiUKIhVCypRVlZGX/n/f4Ai7KUZR0MhhAKhfh7bLVY+XvdMR7EHc5uqJFyZem11SDqGgRCHpSWtMJuL4fT6eLsfavVyoI/9RvqR9MzsCmIgLJHp2ffC+fHXJXvoPeSg0K61r3PNYESswFQa1FaljofDgwMcGkF+o7EY3G21CdXBpp+KBTEiyfXddnocWiUBJ7sGMGNG5agzKznIA4635KzCQVH0fro+0DBG3EliWhc4d+ZtCApCIVE4Mkn+Vnx+ZDweBbUOp/onghizBvh/mQ1yjm1IFASMJ9qZ7dGndOB/je/P9d7JAh5RcJWisH/906M3/ZiaL0eHmMV8g+dYwwtX/8UgktXYfB1b8/17giCMA25KhSKBlUkDEvHscy8b60IGMKz49t0+WkB/8DTGH/uS6XZBGEyQrfmT7/KtMXo81+ORMnMmVlCjlCp+AbMONQHS+dxqJIKmr/1WZz8zHcWpVOC8OxU2wwYdIfQ6wxx3eINS0ph0M5vveLpgo/NZmNBcLoAdDGkbfJJvKfazhX2ChbraXnaap+EzZm2WW7WswV4GFok9RZ0DzvQUlsBp2OChTASxAQh3yD7ZfreajQ6WE0GDloxmy3cv9QqNYwmE8KhEOrqamExW9DT24MkkiwUx2sux3P2/S6zrr/XrkdkpB2akBdqtYqdKsiCPxQMsZX+0qVLpwTFpPsO7QNVajHrtTDppe75XNStp+x5Ou+4XC5ccskl5y3ik/BP76V1UQASratlyRLULmlAOKagsqKSj+HJ9pO83UAwwNnAVGKBggdOJhWMG8yoigZhi4WwfuIUuixtcASiQCTIzib0PaDz7fSgDoM2ZaNP3wsR8IVCJPBESsAnrFdcMS/boPO2JxiDLxRHueW0db4rEMWQKwRnIIrWKsu8bFuYezSBAJZ/+n18j5VUqTD0ijfK/bAgzEC0poEfQv6hmxjDio+/Azqvm8tihpqXwnndbbneLUEQshABvwi5+eabUZSo1eh920fZRp+iywq57o6wcHg3XpqZNowMQBWLzlvU6Nq1a+ZlvYIwH1Q8+DfoXRM8HSu1Y+Km2xdtQxdy36TzVc+7PoaVd70DOpcDnsuuQbzMnuvdEnIEDRTXl5nQ5wiynb6GMvEbSqGdp2xJEu+zBR/K9AxHwjAajCwYzZbVez5cffXV6DjZkbHJJ/GenmmexHqC1j3T+rODC1ThEPQWG5x+H5zHT6HCauAsfRLEBCEfs++D0TiWtSyBOurnPhYMBvj7T49wOIxoNMKCPpEOnDGXlOHSaAhl0QAvHzeV4kmooIR8qCixsJj7yCOPcL+krOzly5efERSTJhhNsHhvMcws3hftPedF1K2n4CLKnqf58vLy8xbw6fUk/NN709n81Q1NiGhMXO6AvgdUFmFkZASBQIB/EzQaDQdtaHVaaFU67NKZ0FxSh11169BbUgtXKIneiQAC0dFZnU5SAr6GxXsKFLAZ5625hDlC+udUkokEArt3Z+Yt8yDgxxMKl+5xh6OwGk5b5yeUJE6N+zHiDXG5IwmAKRwSthIEVqyG9eRRqJJJlBx6Bq6rbira+05BWOwsxv4Zq6ji8rFlT+/k+Ya7v41wQzOCK9fmetcE4Zy5eZHfd4qAX4TQgIzJlKrrXUyQiOHdegU/BOFcIaFr4DVvRah1JYJLVwLq+cswIotT3aTYIAj5jDoURM1ff5uZH739FUgaFu9obaH3zXhZBbrfdRfMPZ1w3PC8XO+OkGOopuoSuxk9EwEMOEPQqdVY21AyL7VWp1vb7z9wAH29vWhqbsbmTZsyAhCJSCUlJReUpU+vm80mn5afa3ABvcdmK0EpZ/EbYLcasGLlhdlYC8J8QiJQMEL1xhXUVtlh0Z92mIiEw/ya9pPt8Pp88Hq9XBLC7XZzRr27fDVe2/1MZl3/XLIV8bEu6KJ+VNfVccZ9ctJSXa/Tw+Vywma1nhEUQ/sQVxSYdHpY9DMPKRTrPeeF1q2n89VclO+gc1b2eYvEwSF3CN5QDB6vlwX7yqpKftA5mr4jlIlPTg0UrPHDWBSJK1+OpPl0sN8zvS5sL53d6YQw6NRckoREfEWhrP65/00R5g7pn1MJHz0KxevlaW11NfTLl8/5180ZjLJ9vhoqmLPKjvQ7gxjzRbgMRbmlcO83itmxkQT8dMnFixXwC/2+UxCIsicehH/dFsRLF5dD46LsnyoV+v/9/Vwa09TXBXUijpZvfBodn/omYvaqXO+dIJwTi/26VgT8ImT37t24/fbFmykpCHONY4Eyi7u6urFp86YF2ZYgXAyV9/0RWl+qNmSksgbO625d1A26GPpmaNkqfggCoVGr0FSREvG1GhXXW11ZY81Yuc4V063tzWYTC0W0GRKOQuEQent7M/WaLyRL/8CBA7jpppvOapN/LsEFJFD6fF6saWxEa9tqzm5WdHo4/BHYLfo5bxtBuFACkQSCsTgMWhX35dkcJoYGh+AP+LlPpb+/dlM1Nji6eDqhUuPe0iUwBSZgNAD2CjvWrVvLwmxffx+6u7o5U5tqo08PiqHse5NOy+L9bEKt3HNeWN16ep7L8h30HaESB5Qh7wtFodPp0LayjQMENGoNTp06BZVaxQ4AWo2W9yGk8WMYpwX8fd0TiIaOwNF3AidPnuRrIlpPdlAHBYFR5nA0obCVPrkzCPmL9M+pBJ48bZ9v2b59zn/zKbjFF44jFI2zw0+aYCSOPmcQo94wGsrN8xJMKcwv3k2Xo+6en/C07fBeIB4HtNqivu8Uihtjfzeavv8lKHoDJm65AyN3vJodcRcDi7V/KkYjut/9caz8+Dt5nE/ncaHla59C5399GUm9lJMT8p/di1zrlLsqQRAEQRDOGY3fi+p//D4zP/qiO5HU6qQFC5FkEvqRQUTrGnO9J0IOIKGFMvHJTl+nTgkvS+e47ioJO2lre73ewIIgZXtSvWcSA0nAp3rNJNCT5TPV2p4tSz+79vZMzCZizmabf/DQQbap3rRpcyab9MjRIzh2/FjKUl+jg6eqFo3VFUgkk6i0GCSjVMg5ZHEfiJJ9fgKlptl/ew1GIyoqK7CkqQmDgwMIhyPw1pTghsEjmdfsql0LrTGBpspSJA0RXjf1A+oPTUuauK/a7XYsW7Z8SlCMkkwiFEugymqEJSuLVLgwZqpb39Q0t+U7zHoNi/jQ6FBXW4ex8TE+r46MjrDjSevSVg70GBgYQHNLM0zVWgyn4jSZIW8U+nEHwoODSCQSGB0bxebNm7Fxw8YpTicGrZqt+slG37zIEtSExU3giSwB/8q5dWyMxBNwB2LwhKIoNes4qIagc27nuB+j3ghsRh33U6HwCDc2I1pZA/3EKDShICwnjyCwZvEJfIJwrtT+/mdcUkJDAdm9pxaNeL/YiVXVoucd/4llX/gwVIoCc/dJNP7k6+h/8wc4S18QhNwhd9xCUaD1uJEwmZFcbFY3giAIC4z1+EGoIymL3nD9EriuvEGOQQGiioSx5If/g5KDT6Pj419DpLEl17sk5ACjToP6chP6XSEWp7WTmflzRdravqOjA9093Wx3T9m89ByNRtHa0oqQMYSxsTEW91VIDQ6wnbPFPGvt7Wwhnjh86PCzZtxPt80nsczpcOLw4UNYv34DW4U7JhxsZZ221K/1eqBCGxJVdop3QYVFD+1kzVpByAUk3JN4TuNo5JwxGyS4k/hOWdyxWDUmJiYQKlmOG/f8IPOa+5ZsQp1VgxpbFfp7U33zsZ2PsfMFCUv03g3rN2Dr1i1T1k0CrUGjhlGvPus+CBdet57E+7ks32HSafh8X1NXh0RoOYKhINxuD4vxpfZSWK1WBAIB/g50nOxASyIBraUMcY0JDYEJDFqrEC1pxJbLzejpbOeAEHrtdGcUEvAD5LwSS8jhFwoGJRBA8MCBKRn4c7ZuJQnXpHhP/ZCcMNKM+iKcee+LxLCsyjpn2xQWGJUK3o2XofLBv/JsyYGnRcAXihZzxzGU7nuKp5MqFUZe+rpc75JwHgRWb8TgnW9B48+/w/P2Jx5EqHkZJm59sbSjIOQQEfCLkI0bN6LYqLvnxyh76lEE2tZh5EV3IrhiTa53SShANF43Sg49g6RGB/f2HXO+/iVLJAtWyH88l16NE1/4IWr/8At4Lr0K0Cz+bJHF2DebvvffKNvzBE+3fvUT6PjkN5CwluR6t4QcYDVoUVtq5Ex8goRBysyfC0jYIYGHBHqLxYLKyioW2inLneap3jMJR2T13dnZye9xuV1s4xwIBBGLxqbU3k6L9hOOCX5OxBOwWC1wOp1n2OynX5ttqZ9tm0+Z9yTej4+N48CB/Rm76traWs4+pu2OjAyhrKwU4dJSOJUoZx5XWg3sViAIuaB/ZBwH23uARAzDZsOsgSvp4Bn6vlP/C8eBdSODsMZTAXiDlkoc1WhwqUEDE7QoLytnu/3Dh48gFArCZDJj+bJl8Pq83Jeyt0FBBDaTjs8ds+FwOFBWVoYnnnhiXgTpxcb0uvVzDdmBk3hYU1EOs24NHOPjaGxoQInNhvqGerbPp/MoBW+43W4c2n8Ad1pHcaVrAI2BCbzxxg8hWFIFQ4kKK1aswN69e/n7kg6iSn8/KMCJArEiMYWzjrPFSiG/KMYxodkI7tkDxGI8bVixAtqquav56+K696nrB6vhtGtKNK6gZ9yPYU8YNSXGTFa+UJh4N1+eJeDvxvAr33TB61qM951CkZBMou53P83MurftQLhpKRYTxdA/HTe+AKbeLlQ8ei/P1//6Rwg3tsC/fmpAryDkExsX+XWtCPhFSEtLkWXZ0c3SkX1QRyNck4oEfEE4XyzHDqSshMg2dEnrvAj4FZWVcmCEgoAs1/ve9hEUC4uxb1LpA9uhPdBEIzCMDaP5O19A1/s+XRQBGcKZlJh0SAJch5XEF6rB2lBumpOmImGH7PAp654s8llUj0TgdDlZVKJMfBL6Skgkdzk5q7PcXg6b1cqZ9+na22TznM6ep5rNlD1fVV2F9bUbEI1GptjsZ2fap7PpScyMxWM8TzXvKbufMu9JvCe7aqrnTAIWiff0N7L8P3bsGGKTg/ollXVIJMtSmfhWvQhTwoIzNDqOPQcOobN/BNpoEMmkgv0H9rNYX1lROUXMTwfPUJ+orq7G/z7VC/vJk4iqtdArcfyjaSuiIx04OeJFVakJGo2GA2fKy8tQWlLCFvwlJSVso099Nr1eEmXJKIMt2XWaWcV7KpNBLhfkaEGW8GQRT1nmIuLnDjpmlIUfNVv5nEw2+AQdG8q+p4Cp6poaVFZUwGqzYu2+/SzeE9uGj+APlmtZbBw+dIDPv+0n2nG/8X6sWbMG27dtz3xHDDo1IokEwlFFzpN5TNGNCZ2FwJNZ9vlXzJ19vj8ShzcURyCagN2i42ueND2OAMZ8UWjV6rOWQxEKA//qDVzvm8YcjcMD0I8OIlrTcEHrWoz3nUJxQOPu1uOHeDqp0WDkxa/BYqMo+qdKhcHXvg3GwV5YOo9DlVRQef+fRcAX8pqWRX5dK+kjRcif//xnFBOG4X7onanBB7LRDy5ty/UuCQVIaGkbkppUzJOpvxu6ibE538aB/aet+wRByB8WY9+kaPj+t3wgM08BbnX3/CSn+yTkFhpArrIZ0OsM4OSoD0Pu0JytmzLgSUSnrPay8nIWyNUqNcYnJthedv2G9Vi/fh0LQbV1tbj00kuxdetWrF23DmtWr2EhkgIA0tnzNTU1SCKJaCQKnU7LNvskzKdt9rMz7SlogJ5p3uV0ZfaDxCoS/pctW8Z1nGk7ZDlOf3M6XZydTyIViZAnThzHwKkTnJnq8Ecw7os8q0U0iZh79uzhDGR6pnlBuBiOd3ajd2AYVqMO1TXVXMf80MFD2LVrF7taUNAKBa+kIUGV+tamjZswqK3Hr1fdhFc/52P40drnYWdVC1TRAJwj/RgeGobP6+M+Ra4WK9tWwm4vh73CPqVfpbPvzXotP7LFqGy6u7u531RWVqKtrY2zu2melgu5g8R7k17DwVoarY7PdxSk0dDQyPb9VVVVqKagqA0buLxJcM3qzHu3Dx9FUqXGwUEfhkbHoDfoOdBqfHwce/fsxdGjR6fY6EdiCYQp2EPIW4ptTOhsGNpWwbxtG1Q6HSxXzo2AT9cILn8U7lAUJUYtC/Vp3MEoBl0hTPgj7IAkFD5JvQG+tZsz82Sjf6EsxvtOofiy7x3X3oJoTT0WG8XSP5M6PXre9THEyivguO429L7rY7neJUEo6utaycAXFj22I/sz0/7VGyW7ULggFKOJI6tLDu/leaob7bjhedKaQlHVTE8aZJBpsZVDGHnhK1H7p1/xfPU/fo9Q01K4r7wh17sm5Igys54zzCkzjKBM/LkYXM628/a4PWybrygKZ99T5idl169qW8XiOU23NLew8JhN56lTmez5YCDIlt+UsU/sP3CAbb/pvWT7TYJjdqY9CfyUzV/dXA2dVsf7kZ3dT/tHpPeRMu8zGf7rUxn+Q8NDnM1MGcqOQARJBai0GVgQS0MiPYmUZFlOz/F4nC2pJQNZuFjiCQXeQBj+UAQtDbUYHBjgIBQlqXCGPQWpdHR08HePsqvTZSOIPz9xGD4lleHpNVjwf8uvRfnIM6iwaOH3abmPlJaV8fecaqNTOQvuZ8EQampsvC4ioSTZ9rnMqD+rfT45bFDmPUFlMkgYbm9v5+VCbiHXBBLyq2rrEfB5+XxHricNDQ0wm8wYGBjA8ePH2JGkJxbFVnJkQRKrnb0oD3sRKV8CS3kt1i6t57II5FoyNDSMgcGBzDb0GjXiSpJt9Ol7S7b6gpDPlN3xIn4ooRBUc+BERd97ZyAKVyjKjhTU5zJ/UxR0jpF1fgh2ix56rfSPxYJ30+Uo3Z+q/W0+1Z7r3RGEBcV28BmYuzt4WtHpMfrCV8kRKHDiZRU4+envIF56ZqkuQRAWFhHwhUWP9ei+zLRv3SU53RehsPFtuvy0gH9gtwj4QtGgHxvGirvejombX4jxW++AYrLkepeEOWL0Ra+Gqa8LpftSA05LfvxVROqWILR0pbRxkVJu0XOGZi+J+JRgqwJqSy5OxM+2807XryexKBwJwzHhwNjoGBKJBGeEZgvqz5bFT8IT0dnRgXgijnA4zHWZSdBMv5bEe3qm+bTNOO0HifxpkTNt/Zzex7RtPon3lIlMQikJ/tFYjJ0KvOEYnMEItw25FtDgfLZt+IkTJzgztba2lp0ESLik5ZTlKhbiwoVaMSsaHSwmA1wuJ0LhEFxuFweyUF+ikg9d3V0cHENuFemyEZQl/2A3BeRk9WH/ONQBBwyJIFQ2G8pKy1BWVsrZ9/Q9Jit9KjdBZSyy+2MwGmcB2GzQnLVeMwUTUNAKQUE61BdonpYLuYUCjsw6DUJma+Z8lz4Xkpg/MTEBn9/Hr3UlFJy02bHK52AR//KRY7i/+VJUVNbyce3v6+eADwr8yIa+c5yFH6csfAVWEfCFAkFtuvjSQclkksV7yrKns2SJcao9fq8jiBFvmINc7NZUcJSwOPBuvhxDwdfDt/FyhBubc707grBwJJOo+XMqIYBwXP9cxMsr5AgsAkS8F4T8QAT8IoRsR4uGeBzWY6kaPIQI+MLF4N10GRp+8R2eth49MOcZyWRjKQj5SPXf7oE24EftH38JY383et91F4qJRd031Wr0veWDWPGJd8M41Ad1LIaWr38SHZ/8JuJl9lzvnZAjKCuMBqH7HEGQmk9Zt032lCB3oZBITo/Dhw5zlrChxMDiel9/H0ZGRli8b2xozGTbTxfXp2fxV1dVcxb/xPgEZyHTdNepLvT29mL58uWwl9vh8Xo4MKCutg4rVqyYMTBgpn0kKAOVhCkS79MBAOlMZBqQZxE/kBKuSMRP24aTXXh9fT1/RhLuSRClTFXJQBYuFCozQQK+vboOrT4vuk51sl2+a9Iun4JZKGs+FAyhqqqay0bQd5b6SiihQm+wIhWMM4na1YtE0I3SEitCGg0sVgtn3FOAClmjk6C/YeOGTMAL9Qk6H4S4jrMBlrNk3xP0fae66lRygvoEifdNTU28XFhY0q4gdC6iAAo6BgadhQMwTCbbFKcTEvLNFjPUGjUHc1Ag01NKAqsm/37F8BHc27INIzET3N17YNTroKUSJhUVHAiQjUGrYRt9+s6cza1ByB1FNSa0gJB47wnFEIkrqJgm0LuCUb6uGvNF+JqKXI6ExQMJluPPe/lFr2dR33cKixLrsQNcK51QtDqM3fYSLFaKvn8mkzw2GK5rhHfrlbk+HIJQNNe1cjdVhGzbtg3FgrmrHZpwysIxWlGNaG1DrndJKGCi1XUI1zdNilxRWI8f5Kz8uWLpsqVzti5BmCt0znGU7/xXZn7iphcUXeMu9r5Jjgrd7/kEVnz8ndAG/dA7J9Dyzc/g1Ee+iKR2auaQUDxUWA2cSdnjCLLlK4kxy6qtFz3gTBn4p06d4ix5tsIvt8Pr9fJ0+8l2Fv5I8CNBnwR7yhJNC+vTM0ZpXQ8//DBisTiL7SQm/X/2zgNOjrS69qe7q3NOk/NIGmmU82oTmxNhSQYTbIONMc8Bg8EJ/FjAJhg/jOGZYAPmgYkmLuyyOe9qldNII03OuXPO/X739nSrJymONKG/v9S/ztXV1V/VVNW559zJyUmeFgn2Wp0WCoWCxSty5h8/cZzd/yROUbR93qWc/4w8xcUC80XtF0T86LQTn4pEIzGODafXhEIhFrXIzUotAoodyPMJasKVL7gQ4USKhVC71QJlXS0GBvpgsVh4DFGByalTpyBJEouvVLxCgj458qkVRI+8Bl988d/RY67GI437MGxywoYQym0GOK0GZNIZLjrJIovy8jLs2L59zvpAkBhFUejk4C6Og54PGs87duzgcU7FLGKcLw3FqSC0bcq38li7cQu0Kh2iyTTURb9lPBbjbSc58Kn1wejIKIZDIbxnepO/baoLumQMEWMV1EotFFKWX0eMjo5ycVa+4INiw6nIiVz4VIAiv0Big2BpKKVzQtcLGvMk3gep4EqnnLG/NCM6X6e66HZUULqs9uNOwepDlkwg7qyAemocnlvvQcrmwGqllNdPMrDVfvNfYT34AtJqDbof+jJitQ1LPVsCQUns1woBvwQ5cODAqh/YeYynjxduBzdup0y/JZ0fwerobUYCPmE6fnBRBXxyDpbyDqFgeeL87c8gT+XipMNrNiC8YStKjVJYN6nAbfDP/h6N/+d/Q5bNQOmegtLj4sIlQWk78ZUKGYY8UaQzORFvfaURkvzSe7b6vD4WzUl0J4Go41wH95cncZviv8k9HwqG2K1LseCSpERZmZN7K1M/ZhLeSTyfL/KeBKOWlha0tZ1GVVUlUuQaTSQx7B2G0WjEm978Zo4b7+vtQzgSZsFzdm97EumpKKBYsJyvWKD4c/OYtOdF/GhWgkqjY7GeBEwStqhIYGxsjKdDDmS6nk9QI7FTiPiC+SDnO7nvKb6enMwjwSAL4lu3bmWRnp330Qg0ag27gmhMezxetLWdgtvtgRYWrPcO8uX24WN47773wKDMYm1dDbZv3w6VMifAqjUaXj8XSsCIJNLQqaSLuu/z0Hju6urCTTcJd85SUZwKQr8lbZvovslsQWXzRhYbaXxRoVYxFI9PbRioRYM3GkOvzYqmWBDKTBo7J8/hpbIW1LVshDwwzgVSlHJC+0m0LaM2IS3rWrBx40ZISi3/zaALFX4IlheldE5oIeJdXRj+8Iehv/FGGG+7ja+vlFgyDV84CV80AbNGyQVPxfS5Ipjwx5DOUoGkiM4XlPZxp2B1QedEz23eBeurzyHUsgmrmVJeP8nEpuvr5NuKeAwN//ZJdH3qK0gbRGqIYOk5sMr3a4WAX4JMTEygVDCeOVa4Hdq0Y0nnRbB6epuV/fanfNt04iBGstlFKwwhB6JAsJyQ/D7Yn3uscH/iwXeWZCFUqaybwS27MPb2P4TpxCH0/8XHkTbNFCsFpYmRTkTb5Bj2RpBMZ/jSWmXiiORLEe8p6ptE8lg0xo758bFxFtLJ8Us9u6PRGG9WyEEcDkeQSiXhcuX6x9NjJLhXVVexI57EosrKStx6y61oaGxgUWp8YhyZTJqj9GmaFPtMFyoGGB4eYofx5NQUGhrq2fVPhQMk8vu8Xn4/OexJpL9QnP6FIBGfHHcGewVM5X4EJoa5+IDmk6ZPDnv6XLpeSFAj0UsI+IL5IJc0iee0u0luaRqrtC5R5D057bdv28ZjuK6+DkpJyesaOe9pvYlb6nDPqfPHQs9VbwNCo1ApIoiE1Sze33TzTfOuq8XpFAaTid2j+f7pl0opHXMuR2g7m08FoYIip9PJrTxSyQQ0KjnUCjliydzvSr//8Mgw/+Yk3lNyCEHbz/3pNPKnqm8cPY2XqrdBbquDLJRrE2IwGCCTyzj9ZGBgkIV8KgxoXLcBSoWJhU0h4C8/xPoJhPfvR6K7hy+p8YkrFvBpv8gdisMbjXOhU3GyBeENJzDsyUXn19t1c4pmBKsP5dQ4H0+FNm5DvKrust5bKsedglWGQgHvzXdhtVPK6ycJ9f0f+iTWfOovWcBXT46h/t8/i96//gz//gLBUjKxyo87hYAvWLXIo2HopvvwEMGN25Z0fgSrg/DaVqR0hkLMtGawF7H65qWeLYHgmuB44heQJ3Lx0JH6NQhu3S2W9Cpn6oG3Yuq+N4uDMMEMSHypt+sx5Ikgkc4glc5iQ5Xpor2NyXlPgiA5hklwJIGor7+vELtMDnW/z8dR9yR4Ux97tyvCAnwqmYJcJsfg0CBi8Ri79SkSempyit9LEeJ5gZ3eOzgwiFgsxo5+eo4+c3JikuOgyZVMohLND4nmJDSZLWaOHC/ubX+lmLVKwGaFTNaCoNkMnSwFg04zJx7/3Llz8wpqJIIJBPMRiqUQiaegU+dOjNFYpTFLPe7tNjtf0/18v3pKeaD1h+jOOHHzyKnCtB6vbIUNLpjk4KIWWh8JEm+fffZZdHV3QavNxfAXp1PUr10PrVKCXqUQUegrCNoGUsoHbfNoW1PcyoNERo1KgVgijXg4yMUblHhCY4K2s1RkRK+jZIYX43G8e9pMvGviHBSZNEbiShhCMaiQ5rQTEiSpEEmlCvN2ncaO3miCSmdALJVe6kUhEMxLaP/+wu0rFe/TmSzcoQS8kSRH5s/eL0qli6LzDao54r5g9VHxk/9C+SM/4dvjb3o3Jt78e0s9SwKBQLAoUGT+4Af+Bo1f/jTfN545jqof/AdGf/9PxRIWCK4hl55/KRCsMKRgkN2E1JuFhCfhJBQsCgoFj6s85MIXCFYj8nAIjqd/U7g/+YbfLUn3fclBv/F8FdQZcQK+1FFJctQ7dNyLu8cVxvFBL7vyyWm5EHm3MAmN5BamaGZyBvt8fhaSSKRPpnKOeYr/1mq1OddoNMLxzXKFHKFQLvqehKTm5mYW6CmW/syZMxyhT5DISNNPZ9LsBnU4HLBZbSwiUU9nmn5PTw8L+OPj43w5dfIUvB7vnN72eUGTpn3kyFG+pvuXIuJbLRbUNq/Hui07sXX73Fj8YkGNlkWxoCYQzCY27b6nohnttOhDY5VbSsTjufSIeLwwhqmgha51Wh0SCg229rVDmc1tu89a6zGciiAT8iKdSs0Y6yTeknjf39+PgN/PyRUUz0/rbiwe5xQA/WXE5wuWB1RARK07qLCJCoXomu7T4zSeNJKCx9bA4CBvKyn1xGQyIxqNchoKbVepNUmfTIYJSYNBYxkea7wB6nQCYaUVFfVrsHbdOhb7838HaBtus9l57KRTuYj+eDKDRCqz1ItDIJhBNpFA5PCRwn39TZcv4NP4Zud9JIF0JgMLFfPNos8VxniAigsBu15E55cC0YY1hdviXJFgNaMe7l/qWRAsAYFdN3FxUh7nUw/D/tSvxW8hEFxDxFF4CfLggw+iFEiUVaDvI/8IWSoJyedZ6tkRrCJ8N7wGWZUKgW17EFzE1gzbtouUCMHywfHUr6GIRvh2rKoW/l2l28e21NdN05H9qPjF99Dz9/+MtNG81LMjWEIkuRx1dh0mA3F2lJGY7wknsK7cCM08rrLZbuF87CAJ1jLI+JpivPU6PYtLFG1PAj1F55NDnUWgdAo+nw+trToW/6nPPUXR02tp2qdPn4Hb7eJigJqaGi4EMOgN/P4GZwOfYB8YGODPps+jOHv6LLVGzQIVRYQXR+X39/XjxZde5CIB6u1cWVFZiBKfL1KfBFAqDMgVK0QRTgIarRoOowbb1zejzOkovJaEM0oCoNh8EtRIvM8LagLBbMLxFCKJFHQqRSFymcYgjUUauzTminvV09h9/PHHubilW2rAl/sPFKb1aO12xCZ64KEI/TIH1jQ3o6a6ppCSQc57SsmgdYOSK2KxOMrLywCFiqPWKXJdOaun88UolWPO5QoVEO3YsYOd8VwEpVbPSAWhZBX6bUPRXKFVU1MT/+YjI8M83mhbSsUgtM36sMkJ7y1/PqOQs3bjTuyp1uPgoYM8jibGJ+BwOjAxPs6Of97+U9uHVJpd+FQEJlg+lPr6GT15EtlI7jhHSak4swr5LgXa//HHklxsZdOr5kTjk7g/7I1iiqLzHSI6v1QIbt6JrEIBWToNXV8XJJ8bKcvMgs4LUerHnYKVgWaoDy0f+wBCLZsx8eA7ENq8E6WAWD9zTLzxXdCMDMBy6CW+X/39ryNRXjXD7CYQXE8eXOX7tULAL0HIXdHQ0IBSISspkXSUL/VsCFYRgZ038mWxcbtcsDvOn+gXCJYKeSwK5xO/KNyffP3bKeu6ZH+QUl43HY//AlU//E/Islk0fPkf0ft3n+O/q4LShSJiK8wajokd8UURjKcQiqfQ7DSg3KSZ8VoSFkn8JoGQ3MIKuQI2u42dnhSJT057SSmxSG61WVmop8cp2p7EeHLOxxNxFu3379/PIn0imYBCoWAXfzaTQUNjA86dO8tx+4lksuBsb6hvwJYtW9gdGgwE+cQ6CVdUHED9nY0GI+rq62eI8iTGk3hP7vwssjwvk1OT/Fxe0CoWTYl833Dqe+92uUE+VL2tDHarhd3Mt92wA87p7cfFBDWBoDh2ORJPI5rMwGGY6dqkMTu7mITGLon3L7/yMkLhKFpqm1EZyRUwB5VaHDE5off2QSHLwGw2YeeunaiurmbxtbOjkwVXGt9U6ELjmRItyNlvL6+EVi1dtF3GfJTaMedyhLYtC21f2IWvkgCFslBoRUUcg/ZBhCNhbvdB22Bqz2B32JBEFCHoCu8fS+qxZn0rQuEQF1eNjY9x/8lEPAGjycjR+mpJjnAizVH9Jo3Yd1hOlPr6OSM+f9++y36/P5KEL5pEMJaCTaeEQj5TvKfCla6JIO8n2Q1qqCURnV8qZHR6hNZtgvHsSb5vOnEYntvuu+T3l/Jxp2DlUPbrH/O1oaMNqWdNJSPgi/VzGrkcg+//KFSuCeh6OyHLZFD/759B10P/hnh1/dL+SIKSpH+V79cKAb8EOXny5Koe1ALBSmVoaFgcrAmWBbYXnoAUCvLtuKMc3htuRylTyutmwllRuE0H6DXf+QqG3vdXop2CAAaNhEaVHuP+2Aw3fpNTXzhRPdstLJPLWAgnUZ/60JM7nsT7m2+5mcXC8vJytLW1seguKSQW9yVJiWAwwK/3+/wwmc0ck0/3SQR/3x+/j8V9EjCDwSDC4RALVhTNT5DDn4oGUukU9Ho9P0YR0VQkQEJ8MeQiJec9pQBQH3CKkY7HYujr72NBn95PTtVMJoPjJ44jnUrD4/VwQYJOp0d/qJ+/X21tHRQqNboHRmGxmHHXTfaCM+9CgppAkIeKYsLJFDRK+RxhaD5o7HZ3d/O6pajZjAeGjhWee6puFzbUGGGwbUAyWIktW7dgw/oNuZ7nw8OYcrlYhKV0CioqoePEtWvWomVDK6DWs9Cbj/C/HMQx5/KGflMS2J0VlUhHA+jp7uZtHW0fOQ0lk+EkEyoyom1yHP4ZAv5AIIOMUsvbbtpelldUQK/X8XZTo9bw9rheksMbTXKMPvUKv5SxLLg+lPr6GS4W8G+88bK3zxSbTyK+WSdBmpVOQvs2HeNBjPljkMtlsOlF8UqpEdy2p0jAP3hZAn4pH3cKVgbqsSFYDr5QuD/5hnegVBDr53myag36PvxJrH3og1B5XJzeWf/Vz6Hzn75W0uYfwdJwcpXv1woBXyAQCAQCwQzct9+PrFyOskd/iqnXvQ2QxO5CqUJpI2Nv+0NU/eTbfN/24pOIVdbmxoWg5KFI/Rqrjk9iD7gj7ERzhxKosmhRY9VyZHLeKUwCIznPScSPxqJIJlPQ6bQsrldWVrLzt+NcB19I7KY+9gajAel0Bk6Hk4sAyHVPAhEJ9+TCD4VCPO0oierZDFKpFHRZHQuRJCrRNE1GE1pbWxGNRDE6OsavL3M6+bG8iz4PFRlQbD4570mEos8aHx/juH+KkbbZbDAaTWhrO4WpySl2/BMUhU+Q2EXIkEWN04oz3YPwhOJc2EAOPIHgUiChMzQdny9PRNHWNTwnLn82LrcLwyMjPObtqkrsGX+y8Nyz1Ruxt9KB5JgHMbkJSkmJkZGRQt9z6ltObR0GBgZRX1+HvXv2cuGNTKOHJJdBr5LmREMLVj4kLFKMfpnNgky0GkeOHOZxQcUccrkcaoUaFouFt6UqtQpTQwOAuTL33kwa42Fg1BcFEgl+/fZt2zi5gcR/Slzhoi2ZjGP64+kMx4zrryDJQSBYbNJ+P2Jtp3N3ZDLob9h7ye/lYsVQggV8o0aa11k/5ImyeE8O/UanXmw/S5DA9r2o+tE3+bbh9DHIkglklTOLRgWClUrZb37C6XxEYMtuRBvXLvUsCZYIag/S91efxpp//CukDSYMfuBvhHgvEFwDxBGUYFVS+aNvQhEJc39y6sGS0Z53CwgEi4kslYT+XBtC67cIkVOwasiq1HDf/Qa4b3+AhShBaTP12t+BZmyIxXui8n/+C4mySvj33LLUsyZYJph1ShaCJoMxdE0GWbAe80dZxNcjgXPtZ9DV1YUjR49wvBk51ysqK2Gz2tjl+er+V9kJfOzYMUxOTXGbZYpwJqc6Rd2Ti721dSP3ZiahiOLqFQqJxXaCXPLkeCOxiJ4nsV6r07JbXq3RYN/GjSzkD48M8+up9zfFh7NruaenIIzSNSUCUGw+9bMfGxvlaH4SsUikV6nUON3Wxu+jGH4StsjZT9+JCgwovp+FTpkMPq8HVr0SKZnEJ/HJeWrRiZO3gouTE+/TiASDGO7pYKGdxjLFnJPDnsT12a0faEzSmI1Ai3f6h6GY/tt93LkWAVkMvaePAGEv5Ao5F8+cajvF694NN+zjghe93oDBgQFuXUHTN1nMmAom4DSooVeL6OfVSj5Gv394FAMDA1wcRds72p5SgRRF4+cLPdbrgY3dz2LH2FlkIcPf3vKnONzvwT7L+Qh+u83O13Q/n3BCLn8S74WAL1guhA8dAjIZvq3ZtAkKy9yiqPlIpDJwh+PwRuK8z0OX2fgiCfS6QlzcQsWMVOgoKD3iFTWIl1VCPTkGRTyWO19UIhHjgtWN0jMF6/5nC/cnHiwd971gfmL1zej7q08hXlWHlMUmFpNAcA0QAn4JsnfvpVcYr0gyGVhffhrKgA/25x9D5z/+O6INoiJQsPhUfe9rsL30FBSxCLo/9gWEN2y9quk1NTUu2rwJBIuCJAn5XqybLEYOv/eDUE2MwtBxmivu677xz+g1WxFu2SRWNgFDbnty45NIMxWMwz1BJ7kTCE6OYqK3D56xXDw9XUhAdLlc7LLv6e1lgT4SjnB/exJ9yMlOQjjF35Ojk6LrJUnBDn4Sy2OxOAvufp8P3/zmN9npiWyWxUnq2xwIBvl1mzZu4umR2HnTzTfNEDzzveuLhVESL9euze0zUj9nivSndAASOMdGx9h5T0Jpb28flBTvr5BgtVnZ9UyuZio2ICKRMDQaNeqqq9HSVAdfJAk5ZCziG0UfaMEFyGSyCFN8fjwFz8QYj1GKtafe5CSM0n0qFikW8M+cOYPBwSGOOVet24UenQlnbA3Y6OnH47XbUWuQw65UQqEvg0JScPuJ8bFxvk1jevPmLTCbTVjXsg6tG1p52pF4ioVXEqhmx0NfKqv+mHMF43a70dfXh2gshmBKQmdvL1xuN297eXs3No5QMMRueiqUIlG/tbUKrY/8Axd2piGDOR7CyWE/7llTB9PYCNrb29F2qo3bkxQnnKiUcgTjCcRSmUKhlWDpKeX180ri8ykZhcR7XzjB20TDPGkSJPB3TeTEeyrYE4kTJYxMxi585xO/4rumE4cuWcAX54QEyxnHEw9DNl1AHWrZhMi6jSglxPo5P+HWbdf5lxAISmu/Vgj4JQid9FnNaIb7WbwnUkYzonXNSz1LglWKLJNm8Z4wHT941QI+RZgKBILlh1g3gaykRP9fPoQ1n/4wNOPDkCeTaPjSQ+j+xJe42logyKNRKlBr07GDeCoYw4A3jiFXDOGwEj65CdCakYpNIhuLYXRslEV6l0sLvU6PZDLJgj31mycxkiAxiUR0SZJYnCcByGazsqjp83pZdKICAHKOkrOfxKFEIs7CEwmUs2PySbx/9tln0dXdBa1Wx72b6fV5YZTcx3RdHFlO/Po3v+bYfJ/PxwkB8VgcXp8XyVQKJpMJTc1NaFnXwq8l139x3DkVNXijcRbwyY03n2tPICDCiRRfqFV4Jp3kAhMS72m9IHdzPpq8eDx3dHawKK/S6iCr34H9Si32V21Gg38UCXUae8pkcKoMLChQigUVwtB6RIkRNKZPnDiO5uZmTpTIj3daf41a5bwi1aWy2o85V7J4T2kn1DaBt6kqA6bGRpHKyqBRKLi4KhwOIZ1Jw+6wo76+gYuo9FXVCK/dAENXOyc87J44ixe0BhxuOwspHF7w82ibp5DJEE+mEU9l+G+EYOkp5fUzOTB4WQI+bS/dIRLvkyDfvlUjzfsaSiAa8UWRyQIOg0jcKXUCW/ecF/CPH8Douz/Af4cvhjjuFCxX5NEw7M89Wrg/9cDvoNQQ6+dlLKv+LtZnvDfffQ1/EYGgNPZrRZ5TCfLkk+d7Iq5GjKePFW4HqQpMxJYJrhGBbecrvEwnDl719M6cab/qaQgEV0w2i4r/+S/ous+JhTgLsW7mSBtN6Pvrf0LSlHN+SuEQGv/lHyD5PGLMCOagUylQb9ej3KBCSqGEJ61GxlwNmbMZ6trNkBz1UBkdSMkU7Kgn8Z5EfIr1JlGJRCaK0VfIFSzi00EZCY/kiqcLReWTQP/hD38IdXV17BAlsZzEdBYhZTIW9IshsfPVA6/ilf2v4Pix4+ju7kZXZydH45NQSsIoTWPzls3YtWsnX9N9utA0bXYbGuobcvNis3KxgEIhR5nTyeI9ufzpUvxeggQrnUri2F1y8JFLT1Aa0Dg+cuQIXnnlFb6m+wtBAtDQ+BSOHG9Dx5k2jrSn9YGc91SQMjg0yL3ue3q62emcj873er3QajVIlbUAyvPFoAPGMjgUYVhVyEWcu12IRqP8HK0v61vW85im9Yec9/lo/jitN7LcOqxRXvnpgtV+zLlSIec9ifdUJNXS0gKDVgVJloHRbONtmtvtgdfjhcFg4O0eFTnlt4/mO28vTGfveDuSGeC5tkGcPXuOY/Zvu+02LgahVBIam3nUSjmL91TMJFgelPL6Wfdf30bz00+h4tOfgnb7xV2D7nAC/mgSsVQaFp1y3hSJUV8Mo94otxCqtmpF0oQA4fWbkdbk/iarp8ahHj2/TbwQ4rhTsFyxPf84FNGcgSlWWYPAtj0oNcT6eWkYTx1B82f+GrX/+a8wHTtwjX8VgQCrfr9WOPAFqw5DkYAf2rR9SedFsLoJtW5FRqWGPBGHZmwYqokRJMqrl3q2BIIrQtfVjvLf/IQvwY3b0Ps3nxMFUII5JMoq0feRf0TzZz4KRSIOlXsShrMn4dt3/qS+QFBMTWUZ6ob64B7oQizgRUahAcxGyA12yDJJaJBh8UhnMiARDtBpTshkQWgNetjKqqDU6uDx+ZGMxyGDjMUhciIfP3ECqVSKP4NETop+Jkhcpzh7wuP1cFR+XpikqPGjR44iGAgW3MjkXO7r72OhKh6LLfjjOewO/uzR0VGO+qfPTqXSsFotfJ+mkS8eKI43z0NOZorgpfhdcuKXGTV8LSgdp7NOp2OxfceOHbDb7XNez+L9iTb0D49DkYzwuI7FYyymUusJtysn/g8PD/OFClpoujSGacyPKxpmTM8uj6LSoEGZ3cKfOzoyiqmpKRbtqVWE0WTkQhQS76nghKCigLM9A+z+95s0ULU0zzuvgpULpZXQuKFtFW03q8odcNqs0JrsiAdcXEhCLUAokYHGKiWU5Hvaq19zOyLf+CpPZ8dkJ5TpFFySAQq3D3V16QWTItSSAsFYEjFS/AWCZYCqpgaqt73toq/zR5Is3gfjKdj0SsjnEe8DsSR6pkIY9kVRadFAeYVtRwSri6xSBc+t9/JtEjoTZRVLPUsCwZWTSsH5xC8Ld6fuf4s4VySYn0wG5b/8PhSxXNFw/Vc/i56//wIia9aLJSYQXCFCwBesKmSJBPfnzRPctGNJ50ewusmq1JzyYJ5231NvM9e9b1rq2RIIroiy3/6scDvhqBAHZIIFiTatw8Bf/APq//0zGPqTj8K/+xaxtAQLojfo0djYiIGBQUxOjCPo9SEDOVS2aihsFZBrjaiSZKhDEjKrAsl0Bj5JBb/ejLjTjjGDHmOBKIJeF7TpOPaV24CkAgZnFbIKDUfVkjs077ana+rBTM5SEtQpGp/ccnT75VdeRldXF6qqq3i+yIFPgjw5k+l9lABQXV3N7mQS+4dHhnmaNdU1/DgJWiScUmIAOZ7psWAwiHAozCKtUqmE3+8vFAzMxqQhF36SY3gpUtpppGIFIeKXgtOZxFISz+k+Ce/zieJnu/swMDzO0fUVtU3svCfxnopSdCkdi65Go5GLR2g6NJajkShHnaf1TtjL5BjPZpCV5cQjbXAAPr8Lp0PjPP5pvTDGjUinM+zEp3kojs0n8f5UWxu6hsahSEQQMKmQCPsXLDgQrEyo/QgVk9B4dDqdcLtcqHDYoHdWw2Y2IXSTm93ztE2MhHOFJJR2QukP7dksrGY7zH43dKk4Nrt60F6xBlZ5LuEhmWjkcZsX/POoJDlSmSynj9A2XgicgpVAKJ6CN5JgEd+sk7gdxGxoTHeMBTHijcKkVcKoyRUQCgTE6O/9L7EgBKsCQ0cbVO4pvk1pfN6b7lrqWRIsV+Ry9H/oIaz51Ic4fYQMb43/+gl0feJLSFQIw5tAcCUIAb8Eqa+vx2pF193OfxyIeEU1ko7ypZ4lwSonsH3veQH/+MGrEvDFyVHBUqEaH4Hp2KuF+1P3v1n8GEWIdXMuwW17cPZL30PauLp7TQmurqhS19cJXfdZGDvPYcPIMPQBL45YG/D1HW+HTDov7tza8TT+4Ozjc6bhV+kxobNiUmfFhM6GDmstfpH2Qmk1QRGVIVmxCa90ubD+pvsQ9Y4jODUCg06L7dt3sGBJMc5n28+iq7OLxfaRkVEW2Ml5TM5TjsCXK1jMyiLLgv7jjz/OfZ87znVgcip3oooi8nfu2okN6zfwe0iAJUczTYsELmeZE5s3b2GnKhUMkOA6n4BP76X4XXcoF8crl8vgMKjFMCsRpzOJpR0dHfz4bCKJFAKROKKxONbUVhSczH6fH3X19RgbG+XiEepbHw5HUFlZweOJ3NKSQkLA1ISvv/AVBFU6PNZwAx6t2ozgcCdGE26EjCYYDHo0NDTAoDcgkUyipqaGC1OI7p4eFltpfRkYGYNeo0ZDQwXiftcFCw5K+ZhzJUMFVbT9ot+WxiNt/xrralHZvAEqnRE2varQnoFE+7yYP0hFWJOTaKqtYwGf2Dt+BsfKWyDZ6pDNBtl5T+J9cWFIHrVEMfppjtEXAv7SI9bPC0Pj1BtKsIBv0Cg4RWI2tP3tnMj1vU9ns1yUJxBcLeK4U7AcCW3cjo7PfgPOx36OWFUtskVFeqWEWD8vjZTZit6//gzWfvrDkEIBSEE/mv7l4+j+xJf4OYFgsalf5cedQsAvQbZtu3ifr5WKsSg+P7hRxOcLro+IlUd/rg3yaAQZre6KplVbN/NEl0BwvXA+/kvIslm+HdiyG/Hq1b3zc7mIdXN+5hPvZYk4R0ZSPLmgtFAE/dB3nIa+8wz0Xe3Q9nVBns5F3BczaYjMEO8vhDkR5ss6X84JT7TZG/E3t/wZACtgtWIinIXDVIYycz1kinZkZWl4YymEwmMYHOjH+Ng4u0dJEG1oqEfA78fExAQUCgmJeAJmixn19Q1Yv74FPT09LOL39vWyOFpVVcmf6fP50N7ezoIn9bjfuHEji1onT51kEYzEe5vNyn3KZ0dHz4bid616JTzhnICvlMth1gnHXik4nema7tPjswnGUsjIlDDqVOxgJvE+72R2uaZw+PBhDAwMwO8PkGqEaCQCg9HASRI6owX1oShMyQhfXtf3Cl4sr4RemYXTWs6fG4mEuXCgvKwcyVQyV7SSzXLBCSVY0OeEw2F4o2ls39QCk1YFqBYuOCj1Y86VfvKZUhWoMIN+WxqP9Q0NiMl1mAzGuNUHFSDRpe1UG4v2apO6MCYn6uux/vRxntbe8XZ8fcubkHU0YscGLYx6LReDzNdKhARQEkUpRt+oWaIvLyjp9TPe24fQiy9Af+ONUK9du2ACTiqdgTsUhycah0Yph041/2nTAXeExXsS+Rsc+nnj9QWCy0UcdwqWK7HaRgy9/6MoZcT6eekkKmvQ95FPo/lzf8tGS/XkGBq/+L/R8/f/jIxWfw1/JUEpsm2V79cKAb8Eef7553HbbbdhNWKcPplAiPh8wfUgaXMiWt8M7UAPCxVUROLfffMVTYvcfi3rWxZ9HgWCC6EIBmB76cnC/akH3ioW2CzEunlpKAI+NH3h4/DvugmTb3ynGEclhO2536LmO/8XsuzF+xuXRbxzHpvUWtFmbwKVEcmQhS0W5Ncps7lY/GJOOdbMuJ/OylA10AVdMoaOsi1Qp4PwDUxAEfXBTvH8NUoEAz4E/AEWqsiZPzY+xs57gsWr+jp2NVstVnbdZ+LU294Kq9XGtSgkbJLTPi/M58UtgmLzyXlP4j2JWxQ3PTgwwM/FY7HcZ2g0M0QtiuE1ayWO5aUofUkhg14tFfqmU/R6Xlgjt6xwe6wep3NdXR0/XgyJmpF4GuUVlchEAxgdG53hZKZ2DjQmSGyi1g2U/DAxOQFJKXE8/2Dago8M5NKgiMfr90Afd6GlroILVvgzYjHU1dbxuKLbvT29qKis4DFmNJq4cKVvYBBZpQZVFh0q1tVfsOCg1I85Vzq0TZm9XXGF4iyyk0s+L1jSNo8KPKoqqwqpEH2V1YipNNAkYiiP+tAYGIPL1ICWrTtQZdEu+JlqpZx7hdN4z2SyXMAkWDpKcf0MPv00pv71X/m25XffjspPfnLOa6iwyROeTsmRyRaMxKf1pc8Vxqg3iiqrVqRKCC4KGT3UY8PciuxCiONOgWD5ItbPyyOyZgMG/uxjaPi3T/F5Al1fFxq/+An0ffQzyGhENadg8Xh+le/XCgG/BKGTPqtVhNL2d/Ft6v0Y2rB1qWdJUCIEtu5hAZ8wnTh4xQI+9SMVCK439mceKbQeoWKUUKvYds5GrJsXR/J70fzZv4FmdBC6gW4+IHPdJ1oxrNbfujj6jk52nzNWo3Ye8X7Y4ES7rQE95mqOws/H4TPJGJSpCIxaFQY2bsP3d+6BpFAgmUxiwu1BNBKHPR2HLRKAPeJHdcSDjZ4hHHeunfM57zr3JDZ6+uFT6fF03S48Ub8X444mGIwZWOUhqBT96Os9C6NejynXFAuYWo2WBSkSRelkjEarZUGJBHuFQsFR5V6vJzerySQsFsuMns4ECfK0X029yMmhT69Lp9NcJHDi5Al4PB7I5QouEKDIcnrtpk2bWMQnocygycIXTUAhz4n4Ib8Px44dY8GXotdJPCUBWPQgXz1O5/kKMkjUDMeTqCyzwWHYzGONhFMab9Tz/ulnnuZxYLPaOC6fxicVpNC6l0qnoc8aefwTSZkCTxsrkBo+hsmYkZ3/VBBAn+0P+FFRXgGZXMbjnYRZEu+Hh4fg9/ngCYahUyUw2NuJdMjN752v4KDUjzlXK1qlAhqlgts56KY3dTQGqZCkOBVCbdAjvHELNMcPFVz4PzZX4Xu/eAyN+iQnlVBKyWwHPomhklyGRDqDeCoDrWpuJLng+lGK62d4//7Cbe3W+Z1aJNwHYikeo3bD/GlBtI5wdL43CptBXSjAEwjmQxEKoP5rn4f+7Ck+Pjrz1Z8A00Wk8yGOOwWC5YtYPy+fwI4bMPzev0Dtf32Z7xs6TqPhy59C34c/VbKtGASLj3+V79eKPU3BqkHX21GIgI40rUNGb1jqWRKUCIHte1H+6x/xbeOJQ0AmA8jlSz1bAsEl9ah2PPVw4f7k/W8V0eeCKyKt0yNpc7CAT1T/4D+Q0ejgue0+sURXA6kUF6jZn30UxjPH0f7l7yNusqFt2I8XOqcw5pNhk84On9qA045GnLE14pytHn71+X0xVToCWcgFTJ6FwjcGnSKD+sZmlDnq4I/4ERgPQa1IQ56MwxYLQ6PRQtKpkTUbcGzAgxNWB15aswHepBya4DCyaiOSSj1qgq6CeGlJhPHW7hf4QlH7P117O47UtEAvCyGqtCPgdSGbSECn1XH0OImaJNTTAR8JrFqdFg67g6+jkShGR8d4umVOJ1pbW+f0dCaBioR5itwnUTUXVR5l4Z6E/PHxCUiSAhaLGRUVFRxXbjabC8IWuVxT6Sx8kQQL+IO9vSzek6uaPoumdzU9yAXL0+k8n/s+ns5wKwWZ+ny6A0ER5lTModVq2XFvNBkxPj4Ou8POYy9jrsZtZ9oLr99ftQnx8AQUER98/jTSmTQMBiMMBj0aGhoofR9Gg4HHIUXpk/OexPtYPI6a2gaYVIBJSrN4v3Xr1oJ4f+TIEZEKURICvhz+aIZj9KmwKF+kRNuu4lQI6913A8cPwa/SFY6/D/R6MBI4jXKnA4FgAPtu2DdHxKcCgTjH6KeFgC+4rmSiUUSPHi3c19+4b15hnpJxAtEkt7qZLxI/lcng3DiJ9zFIknxBkV8gyJPWG6EZ7oc8lYQ8lISu+xwi6zaKBSRYEVT++Fs8ht13PMDXAsGV4Ln9AchjMVT/8D/4PiXXWg69CO/Nd4kFKhBcAkLAL0GuNAZxuRPcuhtn/u+PYDhzHFnV6vyOguUJFYwkbA7EqusR3LYXsnQKWfnlH8zTiVmB4Hpi3f8slAEf36Yx7Nt7q/gB5kGsmxeH+t73/+VDaPyXj8HQeYYfq/mvf2Onie+G1RtltdpRuiZgf+4x2F58Akpfzo1OuB57Ct+wbIMvksw9IJPhA3d+FAnFzKjZRoce22otyLj6cfzwUQSDAX48q5JBba2B3FiGaDSOTMQLUyaOuN+FkGcCOgmwkVM4o0TvwCAQCsFZUQ1DRgn38ChS8RTs5dVQ6U2ospfjR0034q6xM3BGz1deb3b38eWMrQHfaX0A3WvugMnfi9hYJ6r0csjTCRbxh4eHkc6mUVZWxuKUJElIpVL8XHNzM3R63YKOUiIYDPK+dUtLCxwOB15++WWEwyFIkhI2m5Xd/j6fH6lUGqlkqhDDn8eokeCNJHlZTgViHOVPoplKpWIR9UI9yEXc/sonGEshHCfHs2Lefsw0XsrLy/n2xPgE9yOn8bl502bsvWEvftORwB1DPym8/rHyVkjeTmhU5NSXWKinRAhy3svl8oIAS+L/2XNncejQIYwMj8BeUY0GZzm2r29G0DWG9evXY9euXTzGrjQVYrUec65WKIGEBHaO0U+moVNLvM2j1BAaR/lUCNo+mVQSfuyW8PUpHTLTTtKIxo5MRM1jhf4m0HZz9jZTLcl5exdLzW2PIri+lNr6GTl6DNlkbp9FtaYZyuntap5kOsPR+ZSKY1ArFozE75kMY9QXZbGf+t4LBBdFJuPERvvzj/Fd0/GDFxTwxXGnYLkged1wPP5LbhVa9vAP0fHP30TSXoZSRqyfV47r/jdDHo+i8uffw9hb/gDem+5cxF9GUOqoV/l+rVCLSpD77lu9briUxQaf+CMguN7IFTj7r9+jzN2rmgydIBMIrhuZDJyP/bxw13XPGwFJ7BbMh1g3L3FIaTTo+8g/ovlzfwNdfze78uq+8QVkVBqOThOsHPQdp+F89Kfsus+7K/NkIMNY9wB8rTNPPubF+wqzhkX7bbVmWKZzmF8eyRV1OBxOqDRa+FISMvEINAk3FNEYtBE/MvEw9EoJwUgAWb0BKkniMBu7UQN5MgotYpjsPoXA4CCiyQzkwQk4KuvRNtSFDpMV+1t/D2v9PuztOY6dY2chTUf6kzv//7z8NRwua8F3Wx+Ar7kaHl83bFkfkqkIRyEqJSUSyQRHjZPInkWWBfu1a9cWIu/z+Lw+DA0NFcQsl9tV6BEdCUeg1+v5eRJMaZoUeZ5KJeHxuFFVVTUnhp9EW4tOCXcogZRMCZlGz857Eu8v1IP8aoRVwfKAeo1H4ikWM53Gub8xjbXBgYFcQYlej4bGBh5jFIF/8y03w2ivRPMjv4YulSvwGDSU4VjYD8VYL9Ry+pOu5CQIGsMN9Q0zBNg8lBxBJyNpPpBKIuR1zRhzfX19V5wKsZqPOUsiRn96SNL2b77ipQ333orMD48X7kclI3wxIO71IBAM8jaMoHGTf780LYrGkxSjn+ZiAcHSUGrrZ3F8vv7GG+fvex9JcvIEFa/Mx5g/iiFvBJOBOOodOn6tQHCpiY0FAf/EQYy//Q8XfK047hQsFxxPPsziPRGrby558Z4Q6+fVMfngOxHesAXhls2LMEIFgtLZrxVn6kuQc+fOsatCIBAsIlcp3hPjY2OoqKxclNkRCC6GIhJCwlnBkedpjQ7u2x8QC02sm1dNRqdH7998Fms+81FoRgYhS6dR/3//CQN//jEEds48YSpYZmQyMB0/gLJHfwp91/lI7jxejQmP1+3G4/V7Mam3zXiOTmFvqjbh1nVO1Np0805eUiqht9iQ0Vhgj/kRjblRJpcjHguiq78LSqUSXo+XI7+pl/zmLZtZRD948CDGx8bR1dnFwmWanOyxCOLuUcTlCdy8Zy9OdfZDHzdh1KzHDzbvw0833oy7ek7izr7DUGZzTs/dkx2ISmp8bs/vY0pjQzzQB4OvE5JSA71ew58xNj7GkfrUd9w15eLe9iSwk4OZxM94LMbR0IFAgEV7cjOTOz6TyXBvaIvVysIniaLhSBh6vYHfQ8/ThZzPs2P4Cfm0iO91VMAa9MM/MQKPp4OF1HwP8tlue5/PJ+L2VziBaAqhaff97KhmEu9Pnz7N8eXhcJiFe2rtQK0c8oUlPz46htf1nhelflO3G6mRs9ArwP3Kk8kEXC4Xkonc+lQMRfPTOKaY/NqGJvQOjmB4sA8meRy33nprITqfxhsViFxqKkQx4phzZQr45JKnGP1MNjtvhHierTVm6JUyhJO5Iq+sTIGIvhKx0CkWRM+dO8vtQ2gMFxdC0fRJvI8lM0LAX0JKbf28kIBPqRCBWJJd+AtF4gdjSXRPhrjvPRUqiuITweUQat2OjFIJeTIJ7XA/J1wlHTNTIPKIc0KC5YAsHoP9uUcL9yfvf8uSzs9yQayfV4lMNq94T609s2QmEq1oBVfIuVW+XysE/BKETrqs5kEtEKxUqFeuEPAF14u0wYS+j/4j1CMD3JePhFeBWDcXZWwZzej5289jzT99BOrJMe752PB//wmDH/gbEae/jLEcfBH1X/vcnMfPVK3HL6v34EDlRqSno5LzSHIZdtZbcctaBxzzOIjz2Gx2aEwOeKIZ6GPjUCYCaDTLsG1zK44fP84x9CQSKpUqFh0p6pucvhQ/T9HzJFZ7fV7odXpkshnIZXJ2twf8AdywZzcOvrofMSnNDvZgWoKprBoH99yIIxtvwM0nX8CtgyeQlcnwvQ3TldlyBQKWNYhqnTBLBmgzXnSdPs5CE4nv0UgUPr8P5zrOsRuf3M8k2A8ND3OEeUVFOaqra/j1k5NTZN+Dx+thwb2pqYlfT9Mh97NKpUZVVSVa1rUsGMNPUFxvXYUdclkLQmYz9PIUjDoNC6kejwdPPvkkO/tpmhR/TgIZLR9y3F+usCpYeqgHeHgB9z2J988++yy6urug1eqwefNmjI2NIxqNcJQ5iaEGkwmDz/8CdaFJfk9EUuNFgw0OrRxWbRmPOxoftE5ZbdYFkyN4vFpj/DmuoW40NDTMSHGgYhEa15eSCjEbccy5MmP0tSoF1Ao5j1GdaubpotnjaGO5FoeGI4XnXdBDSgNWY25bSONkZHSEx22xgB9KpDimH9qZbVcE149SWj9TLhfi587l7kgS9Lt3F56j7TD1vKeCKrteOW8rk1Q6gw7uex+FXi3BJMat4ApSykIbtsF06jDfN504BPddr5/3teKckGA5YH3lWUjhEN+Ol1WKNL1pxPq5+MiSCTR+6SEkbE4M/9Ff8nG6QHC5dKzy/Voh4AtWBebDL/HGPtq4VmzsBUsPOVZiUWS087sQBYLlRLy6ni8CwWKSstrR8/dfQPPn/xbqiVF24td97Z+R1hkQ3LJLLOxliH/XjUha7VB63cgoJBxaswffrrkZw8a5vQ5Vkhw3Nttx0xo7jJoLCzDpTBZKSznKa2MwTA5CFYvBadewk/iGvTew276trY0FaYVcweI4ueA9bg/a29upUB9arRaRaCQXSS9JLEzKsnJ+L0FOYhKKjEYTVDE/rCkN1GE1tPYa/HbrXjzVuBU1Pi9GZn2XtNIAhbUVg5EJxFS9kMuDkMsVnAYwOjrGrykrK4PNZuNpHz9xHAMD/RyJT/MQjcbgdrtYJDUaDLBYLNi1exde+8BruSihOLJ8IeG+GIquLndYQam8Yfc4txegAoejR4/i7NmzvIxIPKXofBLqqVCAPpOEsssRVgVLD7k9yX1PYlCxyznvvG873cYnImjseb0eXl/IhV9XX89j6Zmzk7il/cXC+56q3QV9xgtJq+D3UAGJSqnMOeeVKp4mCamzkyOm3G4oSfi3mFBt2sCO/OJofCogodYMFJtP81OcCiFYndB2SK1SIJYgAR9zxmbxOGrJGqEfOovdE2fxRP0enLJUI6uhbaGR2y5QEkRvby9vC4v/fiSjWY7Rp78PIoZccK0Jv3qgcFu7bSvken1BmPdGcn3vjRpFocXDbLomQxj1xZBIZ1FlFX9jBVdGYNue8wL+8YMLCvgCwZKTzcLx5K8Kd113vUGcZxdcG1Ip1H/1czCePsZ35fEYmz5Ea0+BYCZCwBesfDJp1Hz737g6MKUzoPNz30DSluu5JxBcT1ST43A+/nMYTxxCrLYR/R/+pPgBBAJByZJ0lKH74/8HzZ//O27VEFq/mS+CJSaVgu2VZxCta8oVPk6TVaow8rrfxURHL75m241JjWnOW0lY3ttkx53ry2DQXPwwggTn7lEPQgE/qk1KGDR2VJc1w2F3FERt6s3d0tKC/v5+7iOfSCZZ9KYeyiRYKiQFC0U2q41Fx2AoyNOWJAVH2/NthcRienk5if9xZNMpyKNeaEKAUyHHUDaC7ppylMOLyawZWVnuJP2bel7Eu889ie+0PoCHd/4ulF3PQRceRioeRzQS4cIAivX3OwI83UwmywI/Od4p1ry3t48LDGpqajkZgJICyKFPhQnUr/xyIYHszJkzOHGuCwGfDza9CtmIH93dXbws161bh56eHhbraVlUVVWhs7OTP5fc0UJYXRmQszkST3OMuFk7Uwwid/PJUyd5fQiFQjwmqJ0DjcVNGzfxukH87OgQhre+CX3mStzffwBHN96ApvQQRrxyBANBmC0WHg87d+7g15PoSsUdtI5Ru4f8uhWKJhD19qPMqEJD41xhnsR8cuRTz/t8+wZ6TbHIL1h9MfoahQKBdGpGjD6NTWorEgyFoNfrMDExiRvansQ7T5/g50NKLU4610JftRaZ2CgXMR0/cYKTI6gtyZrmZt7mk8OZHf5pitFPcxGLQLAU8fkUnR+MpjhNaHbaRJ4RXxTD3gjc4Tjq7foLtpUQCC4m4ON7X+XbhrMnIKcWSxqNWGiCZYeh/QS0IwN8O63WwPOae5d6lgSrFWqPV5QEaj34AuSJOAb+/OPITh/zCASCEhbwh4eH8YlPfAKPP/4495SsrKzEG9/4Rjz00EN8gmI185rXvAarCW1fVyHahzbwSatjqWdJUKpk0nA89Wu+KQV8uT4+l7HT0dKy7hrOnECQQ0biFsVSUY8pwSUh1s2rc+J3f/xfUPnT72D0XR9AViWcS0tGOg3rq8+i/Jc/4NYGgS270PfXn+GnSBxuHw3gN+l18FXN76zdUmPGPRvL4TBc+m/YP+HDxPg4pKgHegSh1KmhlJQzHOl0mwRBEilHx0bZVZ7JpGE2maDT6zimPpVKIZVOIZlKwmTMifYkIJKA/euHf829wek1ExMTLOaPjY4hZouxO31NpQ2ymB9T/mGsr9FAmhzFuLoGFYk4fv/sE1BlUvhfbQ/jFnsj/mXbWxH2dEI7fIyXiVaj5UKC9vYzPF3qZ0+OfBKgQsEQi6oOux1lTidsdhuL69SnnuLPySld7L6fHT09+3GKNKfrwcEhTExOQtJboNdWIhbPtRAgV/XIyAg7/+lC352WGyUSkHhPzmkhrK4MKK45FEvCoJbmxDXTOKAiDhLYySEvk8u4KITEdu5XX1uLY12jaBsJABoTfrj+Hvy45S7cV5vFZosVh1NhXocoCr+muobbNnT39LBjmsR7pUrJrmi/z8/TUuisUMtSqLRo0bKmaV5hnh67EsF+tR1zlgrkiFer5FApZEikMuzIz4/N3r5eqFVqeDxu3iaeVKmxYfp9e8bP4mtbslDXboKsdxIdHZ2cTJLfjpN7n9o/0HZPrZSzA18I+EtHqayf9Le8WMA3TAv4FJ0fiqUQSaYW3K+hpJSeor73lB4hEFwpSWcFojUN0A73Q55MwtB+HIEd++a8Thx3CpaaYve995a7RavFIsT6ucjIFRh6318ho9EWzqWbjx9A47/+b/R/6JP8uEBwKaz2/dqSPHtPJ9duvPFGPhny4IMPco+EQ4cO4ctf/jIL+q+88opwFawgjGeOF24HN24HW6EEgiUgUVGNeEU11OMjUMRjMJw7JaKiBcsOx9O/gfPxX8B1x+vguf0BpMwXj3UWCK6GtMmC4T/68Nwnstnctfi7fW3JZmE+8goqfvb/oBkdKjxsOnUEus4zGKpai1+fHOX+rvPR6NDjgc0VqLVdXlsYXySB0Uk3EPGg1ixHjbORnb+z+yHTNQmT+WhmcpdTMS3tn5NTn6K7I5EIC/QkPJIAaTKbYTIa2XGfTCQhl8uRiCcQRpjj9g1GA7+WxMv1LbleaOGTpxAZbIMpq0bKOwa71o5RvR0NwQl+fpO7D1956av4553vQse6u+AYPYzWlmY4nLl5IHFdUkrsaq4or0Bffx/MZhPPDxUQ9PX1s6g/NpaL3if3KSUHkHBFPeupeLg4enr243R8Qm0DqFBBq1HDYtbB5Q9BJZOgMVr4O5Lrn15PhQkVFRXYuXMnfx4tq127RGuKlQAJluF4Gol0Bmbd3PYTlPhA4n06k0ZTUzMXwFAcPrVpIMGd+PZzZ2YcxisSAcTHRhGAhcd864ZWbN5yPu2ECkZozNH6R+sFXdN9k8WOhnUtqDBpUW4SLkDBLBe+UsHjNS/g09iMRqLIZrKoqq7C6MgoulQaRCUVtKkEyqNe1AfH4bM5YCqrgjKZa/mwZs0aTjAp3varJQWCsThiqQwLrPP1HRcIFouqf/kCi/jREyeh2bSJWzf4qe99LAGTRjlvG4d83/tRXxRGrfKi7YIEgkshsG0vC/j5GP35BHyBYClRTYzy2MzjuufBJZ0fQQkgl2Pk9/4UabUW5Y/8hB8ynjmBpi98DL0f+Udk9IalnkOBYMkpyRLSP/3TP2Xx/itf+Qp+9atf4fOf/zw7ZT784Q9zb7+Pf/zjWM288MILWE3ke6UQoU25mEiBYCkPyvKYTpzf8b0UyKkiEFxTMmnYn/4N97iu/Pl3YTr+qljgl4BYN68NFT//Hmr/84uQpXJ9zAWLj+HMcaz95AfR8JV/nCHep/QGDL/1PXgsrMeXnuqcV7w3aSS8Y08t3n9r42WL95FEGpOBOGwqwJwNo8ZpKzh/ScAu7odMkPBNfbpJsK+uqmbnOwlF0WgUTmcZ1q5di5aW9XCWOWG1WFFfX8dO+PHxcdx2+21QyBXsgK9vaGABs7q6GlqdDkaDkcVuei1dkwxlU6aw1ipBa1XgP29/C/6n5XakpiP1zYkI/unVb+H1nnFENrwOTVt282dv2NDK4mlTYxPq6+q5SICEfErwogKCF198EUODgxifGOfYc0oToHknx/zBQwfx4ksvFiLMqV89XdN96mWff5yKEbLIckx/MpmEHFmkokHEsxLKa5vgKK/k6H5yQtPnbtu2jSPNRd/7Fei+j8/vviesNis7lmmM0fGqTC5ngZNEeCoi+dVjT+KUZ+b7lO4e9Jw6wusDrT95oT8P3afHabxwP/J4nO/byys5Nlqnygm0i81qO+YsNQGfRPb4tMBO0DY8Eo3A5/ehvb2dH9MYDXA3n2/FQi58f0qCs349mtc0Y/u2bbDZrLzt93g8aD/bjiNHjqL99GmEg0HEk9RKIrNk37OUKZX1k7az+j17UPahD6H+/30HMkniAkNy11McvnaB7V/nRAhjvhiSmSycRpEeJVgcAtv3Iq3Rwbf7ZgS37Jz3NeK4U7DUZg/Z9N99SmuLV87cpyx1xPp5jZDJMP72P8TY77yn8JC+qx1rPvNRKF25YnvB4iOPhFfNYn1hle/XlpwDn05aPPnkkxwr+Gd/9mcznvvUpz6F//zP/8R///d/44tf/CLHDwqWN9Q3Std1tnA/uGn7ks6PQEACPrmbCSNVrv7enwp3qWDZYDpxCOqpcb6dMhjh3Xf7Us+SoESxvvwUyh/+Id9WuSbQ/5f/G2nD3J7rgitD29uJyv/5rxkpRURaq8PkA2/Fq9vuwi/O+eDunSvckxHtpjUO3LWhDOpp5+XlkExnMOKNoNqiRVamhj+sLDh/B4cGOYa5p6eb4+gJtUaDAwcP8ONNzU2wWm3wej0YHR2DP+BHbU0N9+D2eb0sHpGouXnzZiiVShw5fISnUVFZgUQiAZPJBLlCDqVcya87fuI4AsEAR93bHXZ2ypO7n+Lnia6hCZzKNOCMtQIfPPEo7LEAC+fvOfsY1nkH8Z/K38HrW3WwmE3YsnULR5LTZ+Tj7imy3uv1IuQOc0qAwWBkpykJXB2dHTAYDPD7A+zGJ4GeepjnCxnomCQpJZFOpTnanFzXVJxARQCULkDTjUZjqDRbsaZlJ6qsRujkSQz293MaARUKkHgv+t6vHKKJnPue1hHLPO57gopYqAjl7NmzGB0d5VZveQG17VQbxvVr8NbhNuyv2owRgxNKpFAp88Bo0nOiQz6ivBi6T4+T+znfwqGqugYppZaFWv0CvZ8FpYukkEOjlEOajtGPhoK8TaLYfGorYjDoEY1FcwVJNVVAB6VCAHvH2/HTdXcgaqyGVVLM2Pa7XW7eTuZTSGxlPqgUG2DTVxRc/gLB9dgOB2Mp3hbbDfNvh8cDMYz4cn3vGxyi771g8Yis2YAzX/8fZCWR6CBYniScFUhYHVB5XXDd88alnh1BiTH5hncgo9ai+vtf5/vaoT6sfeiD6P/wJ3n7KVgcJL8PZb/5EWzPP47Oz3wNifJqsWiXOSV3tE5Oe+Kee+7hKMpijEYjbrrpJhb4Dxw4gDvvvHOJ5lJwqeg72yCfdu5RP6mU5fL7MwoEi0m4ZSNXVStiEahdE1CPDiJeXS8WsmDZ9TPz3HY/smoRmStYGoqL76jdyNpPfYgj0qgVieDqKPv1j1H50+/MeCyjVMF194PouvON+GVPGGeOTs773gaHDm/cVs29Xq+ETDaLIU8UNr0K1VYtqqoa0J4Js8v89JnTLOAQFANPYiQJQdQjeWx8jEV2ioUvNiVTf3cSekgUJxcxiUDkVicRSCkp2WlPkJA90D+Avt4+dsxTIQAJ+hR9T27j5uZmFs9JTKL75MyfmJiAZ7Qf6Sk3XCkJf91yGz483IbN7j6e5o3jZ1D/9AQ+F/p9NDTocde6KhZWSQyleacCAYqGJuGdYv/JOR8KBTkNgIoPSLzniP9kkufX7fbg+IkT0Ot1CIcj/L2NWiOSqSTPl8VqZXFfo9ZwEUKZrYyLDVrWtaC6aR1sVgvsBjX27Q2hv7+fvwctC9H3fuVAjk9y36eiYZzu7yqI6TS286I73d66ZSvGx8YxMDAAvU7PhaBU6NHd24vyxib8Yftv+bK/chO+ueM+SFE/1AYNrxM+n4+LS2ZPO3/JE4wlocrK2IEvnyc+WiDQqBTQSAqOuacxRWOwuqYaZYkkvD4vZJDx+RPbrbci+/++xY699Z4BGBNhTCSduLWqCqP93ezWHxsd48In2qbRNpO2XcFQBBq9EQ1VZWJhC64L9HfaF825741qBaRZ5wMJSoXonQph1B9DmUkDpaIkQ0sF1wpK1Zln3AkEywWKzHfd8VqYTh5CcPP8KRECwTUdg/e+EWm9HjXf+jfI0ykoAz42JvT8/ReEOW4RHPfOx34G52O/4La/+VTMwT/9+8X46QTXkJIT8Ckin1i3bt28z9NJPxLwOzs7LyjgU8/J+SC3xIYNy7sqqKWlBasFQ3F8/kbhvhcsPVRNTTu6lsMv8X3qHzV1iQJ+RUX5NZ47QSmjHu7nXlJEViaH687XL/UsrRjEurn4jLznL5BwlqPqJ//F99XjI1j7qb9E/4ceQrjlfO9mweVDaUR5AZ9OEnpuvRcjD74Dz7lleGb/OJLpnJu3GIrzpj732+ssV9WLmOJm1ZKc3fctFUY+8Z13/lJ0MgnZJNIHA0EWwcORMFJOJ59Up8j5/v4BpNNpFr3LnE4WzA16w5wCAIpiJsGf+r+TK5+uQ+EQP0a96SmGnNK2erp7MDAwyPH5JBqRSE6vpV7yJLrTcQHdTiZT0Jkd+LSzEe8wVeDNfbn2ItVhFx7a/238se5vIelSMJsH+XESR8lFajSaeDqpZIrng+aVetuTQ56KB6hY2GK28Hy5XC5k0hkkkgl2WW9o3YAda3bwsqDv5/f5UeYs43h8El3pNXnxlQojPKEEx6/bDSbR734FEkmQ4zMFt9eHsd4OjI6NFpzINGbyzvm8W55aL9B6kysCSaGzowMTsOC9g0cL0wwotYj1HkLKPYKMzYoXXnwBjz32GBeCkEBKBSZUDDDblU+OfnKh2vRq6NXXzvm8mo45SxFKZyAB3xWOs/hOhVaUMiKXxXj7SskivI1qaMDkmg3QdrVDgSx2TXTgZY0ew4YwJifG+XX0XtpWej1e3hZS0gpN01HdwIIppVIIofT6UgrrZ8rr5TYkCrOZ75NwT+572gbq1POfCu2aDGHCH4NKIYdZK1zSguuPOO4ULDmShMDOG5d6LpYlYv28PnhvvhsJRwUavvxpZNQaDPzZx4R4fxXIEnE4nvo1yh75CaTQzARGlXsKsmQCWaUKK5mWVb5fW3ICPp0gIeiEyHzkHyf3wpUSi8Xw8MMPF+6/5jWvmdOPgQbW+vXr8fjjj7ODJv/Zt912G06cOMGOizyUFkDzffDg+X7aW7du5QPn4s+hEzw33HADpweQqyjPgw8+yE6dkydPFh6jE5n0eVSskKe+vp77aT7//POF5UQnf+677z6cO3euUPywlN+p3Qv0+GQo29YKt8uF2sPn+zdPNLUgmUjgzJlcTz6C+oTW1tWi41wHnxgmJKXEJ7LGx8YwPn5+ObW0rJvT04b+OFdUVuL06dN8cpagnpQt61swNDjEsZZ5Nm5s5c/o7c05t4ja2hrYHQ6cOJ4TzQiKXiVnWG9PL5/QzbNt+zb+TkNDw4XHmpoa+fPEd1pZv1PQVombp59T7n8eJ6rXXdLYo8fyjy+370SI9Wn5j70L/U73Hn6m8JqBNa04PDSKFp1hRX+n67ktJ1bbd1rq32nwjtejMxzHzY/9BFI6xQcTTZ//exy6603o2LCDD9JW2ne63r9TYmwECbUWGUk6/538UajWbuLl53r7H6HXUIGf7x9CIDlXmJchizWmLLaXpbCj3npV36msthHDo2NQJwLQu7PwdgG33HILO8wpFt5ms/GFxO0jR47gXe9+V2Ga1Lv7B9//AW666UbeF8yze9duFn0oqpneS4Ik7aPT/mF+X5Mgofz5557H+973x6iqquTH6HNo/7WhoZ5j5ov30+nkPcXy04V48YUX8corr+B//dmD8MqN+Mb+JvzBgZ9Cns3gn3e9G3GFCk8MZRFOTOI+dp4CVdW5GP43PPgGLnogwfXv/v7vCp9DxcAvvfQyfwdyreah/dzGpkb+LuTiJ1RKVU7st1gK866QFCy60j4wCWBUd5GAEvff8Rr09XRjuK9rWR9r7N27d0Uea1yL70QJ+P4EsHbzDkyODCIWj/F4JpKJJBdw8LhEtvD7RyNR3HLLrbxdYl7/OnzlkXO4+fB/Fz776KYbsTUzgpGMD+985zsLj3d1dWH//v08vmndOXzkMD9+9913c/rFqTNnEU8BZjVwzy3X7nei5Zd/7Ur4nVbj2Lva7+SL58ZuwDMBhUKBDRvWF95PhVT0vqeeegqVdbWo78r97dwz3o7nandgNK7BDbt28WP0fcgAcf/99xfeT9vdcNCPx556GlYVoJHE7yTG3uKuT/Ynn4L9uecgW7sWA3v2YHjNRgSTwE27tiImmfDSS7mCe4ISfWw1TXjpaBuGfTGUaQD/6PLZ31uN+7DiO1FFXQYOixU1TY0zfieX2y1+JzH2xPq0TLd7+WmI7d6135afetsH0FxThahSjY6ivyXi79Ol/c016/XYOdIFx0+/C21wps4ZqqzBoT13YqhpA3C6vfA7UeKhwjcIzegJPo8ijp+waMeEdB4rf77ncpFl8031SoT3v//9+OY3v8mX973vfXOe/9jHPobPfe5zfPm7vzt/Eu5SyTvzjx49745YbtAgowP7lcjzHZN4oWMKZSY1nKkwNv757/LjGYWEM9/4OTIaEQctWB79ZFr/4nc5SpLcj2e++pNL6u1MO4m0wyIQLDaKcBCtH3wX5IncDkb3x/8PwuuFy/lSEevmtUXXfQ4NX3qI49HyePfdhuH3fhAZrf4af/rKRB4Ooey3P4PjiV9i/Hfey1FzM0inEUhk8OipMZwczgk7s6m1aTkun6Lur5ZUOoPeqTDq7TpsqbHAaVTPeQ057km4n5yaRFtbGws6apUaZosZGo0GPq+P+9RTZDyJ43Sdj6wnjhw5ijOnT3PPZXIYezxefOtb38S73/VufP8H32cRXCaXsZOdTg5zf3qPl08GUKw9RT7LZXL+LIqodzqd6Ozo5HhncoKqVCqeBjn5JZMTmzbdBpvGhsMVM5O1NhkieH2jAkMD/SwUdPd0s+BKvaHVGg3C4RAXCFD0udli4ah8EuBT6RQfAJtMZsSiUS5sIAFCr9cXnNjVVdXz9jDPE0um2UHo0Gt4X1j0jV4ZUFz9RCCOUCyJ/o7TM8YxCfiULhEKhTE8nDsxSCkUNKYymQynPPi8XoyGUnhP3Wb83rmcgHvG1oAvb9oHR3QI1VWVGBkewfETxzlRgqZts9pYvKdx/q53vRu7dp1Pj/OEE9CqFKg0azl941qxko85BTn8kSSefvUIjh87Ab97nMdrPj6fttO0raN4fKN7Cn/VcZrfE1Rq8bv3fxL2rA/GzseQScW5bQgRj8WgN+ihUEh8suvNv/N27Nl3EyrM2nn/bgiuHaWwfva/452IHj/Ot/Wf+WcE9t4KhUIGo2aus56SII4OetmB7zCohftecE3Rn2uD7cUnYDx5GGNv/0N4b7238Jw47hQsBUrXBJIOkQh6McT6uTxwPPYLBDfvQLzmfOG/oIhsFpaDL3A8PiVdFhN3VmD8Lb8P377bAPncJLYjfR7sarDi7bvrriqZ8Xrz+ArYr70azbjkHPh5h32+Sn02+cqhhRz6q4Fix9JKxnA6dzBGRNa2CvFesGxImS2INLVA33MOMjr52nYUvn23X/x90xWeAsFiY3v+8YJ4H61rQrhFFIpcDmLdvLZE1qxH1ye/jMZ/fQja4X5+zPrq89D1dHCkfqx22oEqgCweOx9/Fg7xEil7+IfwvOZeZDQ5IT6dyeLVXi+eap9APJWZs9R0KgXu21TBB2byRTooI3HSolOyILiQCENRyyQwTk1O8X2qPg6FQixYUh/lisoKFr2pMpkEdhK2A8EATEYTC+ODAwMsaFK/eLvNDq/Xw25To8nI09DrDdzL22Q2s3hfU1MDnU6H+voGFkAp4p5i7SnGnuL0+0J9LObTNMhZSoIp7SNTaXPSP4mxgUNwbbyLD4ApzSDP1EQUP4jIUe8b4Xkh8Z1i8Sk+P5GIs6OApkXfieaT5j3X7znE4ipF5I+NjXIxgdfrZSd2VWUVT4uc2HQMspCAT4I9RU17o3FQW95ykwaS6M+7rKH1kVofkIhv0krcl56KNfLjmK7dbg9H5JPgTuOCxiqNUUphoBMnVOyhX3crHjj3eGG6j9XtgD2TS4Mg9z4lVdBYpNfTOKZ2EZOdk3A4HPyZeVKZDF+0ShV0ymsXn7+ajjlLGY1KTjtByMgU2Lx5C29LaZySw5nGKG2vaTvq3L0H3oE+WGNhaFNxNATGMWi0Q5GRIzg1BUmS+EJjn7bzSqWS/yZUOO1IpDNcnEStVGgbLrg+rPb1Mx0MInrqVO6OTIbElh1IZrIw6+aPxRfR+YLria7nHGwvPVVouVgs4IvjTsH1RjU2jPV/+z6EWrdi6t43Ibj9BvEjLIBYP5ce44lDqP7hfyCjVGH0ne+H+87XiXj9eXD+9uczxPuk2YqJB98Jz+33c+vf1UZ8le/XlpyAn++JQLGW80GRg8S6dbkoFcHyJdLcgrHfeQ+Mp48hsGX3Us+OQDCDwLa9LOBHaxvZhS8QLBmZNBxP/6Zw13XPG8UOrmDZkXRWoPuhL6Pq+1+H/YWcSKWIhJHW59o8lDypFOzPP4byh38Ipc8zY3GkLDYoPVOIV9WhayKER06NsqA+H7sbrCze6xfRdRuKpxBNpFBTbkSTc+HEBBKlSbChCO/6hnqMjo5y7B7F65OYT/G35JQn8bKsrIxF8KNHjkKr03I/eBLvKXqcXPXksifXvNPh5GmTGETCErntKyoqcNddd7EQSo7/7u5u6HRaRCJRqFS54gIS/fNOUnL9k4uUinsTiQSLpUaDEelYGJaB/UA8hEDVXmRlclSGXfjii/+OM7ZGfGPz3SivcLOIRSIsOffpfeTip+9CjnyrzcqCPEXl07RTqTR6enp43ug7U4EBibjkxKbr3t5exBOJCy5vcg56wwn4o0kW78uM6hVVHV9qkHBP64gkl0EtKXgdoLFGxRr0e5OgSUUiND4oBUKn1fE4z0cNNzc3wx9NwZmSwR7LFZp71EYMVlVhjz2OkZFh9Pf1s4BPKQ95Ab+rs5MLU2gs0mfmiSTS0EoS9CpJiKWCi0Jj1qBVQ6NRIxqP81ii7Z3BYOAUlXAkzIknJOKf2rELLydqcay8BRFlrqBMXd6IdMDFY5Jc+7QNpjFfU12DnTt3oL6uDhmFPCfip9LQqUru9JTgGhE5dIjTiAjFuhaENXoY1dK8fy/HAzG+eCPJC+7HCASLRWD7XlT9+Ft8m85nrob+w4KVCxWHU3qo8cwJZFQaIeALli+pFGq+++98U55M8G0yzA2978NIG1evEfeykclYL2v+wseQ0hkw9drf4fPAIrV65VJyR0i3355zwVL/ODoRSP0m81C8JfW/pJ4P1D9rtbJa0gUSFdWYfMM7+CIQLDeoqs17852XFUNF2x6BYLExHTsIlSvXQyplMHE0ueDyEOvm9YEOKIbf92GENm5HzXe+jMH3fwRJW06gLVVkqSSsLz+Dst/8GOrJsRnPxcsqMf7mXPyZK5zEo/v7cXYsOO90qiwajsuvs+sWdf4y2SzG/TF23tfZdBeMdKeIfBLfSVSk/t4U7e12uVl0rCivQFVVFQtCVouVRcxkKoXJqSk0NjZwJDiJRvR+2o+tq69HT083C6F0oSh6EsXpNTRduk0OeBJCyblPIhO5PskJT4L9+vUbCk5ScoVSsQAJ8OlYml9DIj65n4MBP0yyU9DIs4hYN+Gf9n8T1ngIN4+1wZwI4/Pb34CaVIJfGw6F+b0Go4Fdz2Tcp9505NRIpzNclEDFCJQsQC58uk/zXuzEJmGr2C29EOQg9IQS7OwmYdhuENHTyxFKSwhGUyzg2/WqQiELtUmgcUzFGvR7UxEIFZeTsEQFLElKZJLJeMy2tm7EQY8ab3riB4XpPtKwF/XaCG686WY888wzONdxjsV/miaNN0q2oGmtXbsWt9x8SyHRgQpVook0HHr1ohbxrPZjzlJnbVMDRl0+jI2NFYpOqN0HFZ1QosroyCjH6R/Q6HDMXFcQ74mAuhzr161FNp3hVIjqqiro9DoW8PMtUsLxFMeXx5IZ6IR+dd1Y7etn+JX9hduZnXv4er59FBp7vVMhjPqiKDeLVBvB9SFeWcv78bRvr4hFoe84jdCmHfycOO4UXE/ksRhsL+fSIAjX3W8QP8AFEOvnEiNJ6P3Ip1H/tc9DO5Tr/24+9ip0H+/E4J/8DUIbt6HU0He0wfb8E1zEAMX5/Rz6mzL03g/Cv/dWpPVGrHbMq3y/tuQEfHIx3HPPPSzgf/WrX8Vf/MVfFJ576KGHONryT/7kT/jk2mrlttuEeCMQXGtSZutlv6dlfS4hRCBYTMItGzH6u++D/dlH4dt7K7LTDlSBWDeXKyRIU0+ztME05znjqcMI0gmuefp1rTasLz+Nip/9P6jcucj5PEmLDRNvfBfcr7kP0YwMz5yewKvdbqRJMZ6FRinHPa3luKHZvmhx+cW4QwloJDnH5ldbtQsK92fOnEFHZwdGR8cwNTVZ6PNNDnQS3ElsPHfuXKFPMjnSyZlP2Ioc6uS8J/F+TXMzC/PU+uqRRx7F5s2bOH65Lhbj+H12sQeD0Kg1/Hq9XsfTpteTiEnx++SGHx8f5/hxco9SUS/NB90nFz0J8pQIYDDo0VKpRMgQxqGKDXhjz8s8X5vdvfjYsV/hM9sehCX6BEf4q5RKFud3bN/B0dIutxvZTAYyuRwOu53/zlOaQN4RTX0Ui53YJIoVu6UXgn5LalngiSShkMuglOQwzdPTV7C0UEpCMJ6EVqmY0eqARMviNgk0LimZYWhoCB63Bx6vhwV5ukRicUhjMaz15yIQ43IJL9gqUTs+gGeeifN7yN1MfcVpHFMBAEFFMa2trYV1kD6PBFKVQg6tSgGVdO3TocQx5+qgqtyBrZs3QqM3QitPc9EJbaeoTQkVi7SfaUdvXy+76+11tYiobYX3RjV2SJIZ6+qqsGvXLmzesnnO9NWSnJ3PFKMvuH6s9vUzvP+8gB/fugsGzfynPrunQpjwx6BUyEXfe8H1QybjxEbnk7/iu6YTBwsCvjgnJLieWA48B8X0vmO8opoL6QULI9bPpYf63nd98iuo/PG34HzqYX5M6XWj6Z//Du7bH8D4W9+DtHHueaRVRTYLQ/sJlP/qhzCcy7ULCm3cCu/Nd59/jUwGzx2vRalw2yrfry05AZ/42te+hhtvvBEf/OAH2bWwYcMGHDx4EM899xxH53/mM5/BaubEiRPYtq30qpIEguXO0OAQausufuJeILgcKEqKIpOm7n8Lu3kFYt1cCcwn3hvOHEfTv/wDIvVrMPKeP0dkzQasZiS/d4Z4n9IbMPm6t7MzIimpcLDPg2fPTiKcmF/02FFvwf2bKjhy/VqQSGU4yr3RqUdzmWHeAgESDkmkPnjoIAYGBjnKnlzqkqTkayqsJZcxiT/kmqfnKdr+1KlTUKs1KHM6IUkKfizvUI/HYjzNfOT99m3bcPjIYTTUN3A0fpmzjAUmEvFJlKfnqQCApnH6zGl22/f19rG73+/zIZ1Jc5x9fV09BgYH2MFMRQDksKALuen37dvH0zjptOE7T+jx3vYn+Ptt9PTj4ycexqdb74Np9EXo1LllTbH9dNBM6QF1tXU87ySy5sV7Fl0TCS4YICeqWpNz3ufF+7ZTbQV3dv6x/Hvyj5Ega9ZI8EUTkORyFmYvlIBwMaiooq+vj+eTfpvGxkbY7fYrnl4pMd+y05ssCMVSiKUyBff9QpATORAMYP8r+zktghIglJKSx+ZJVxZv6n6l8NrnanegypyCu3cSA/29/JlUdEJQuhzdt1ptPGYrKiu4QIQcCTReIokU9GrldXHfE+KYc3VAAjv1qodaB5tOVShGoTFF51SoWIlSSGh7Jsu6MVT03phkgieY5ecXKk7KTy+ezCCeSnNsv+Das5rXz+ToKBL9/bk7KjXkm7fMO6484QSnCFEBCe3LCATXk8C2PecF/OMHMfquD/C+ozgnJLiekMkjj4vEPtH+84KI9XN5kFWpMPr7f8qmj7pv/iukoJ/bQDiefRSWQy+yiO++/f7VZ/qgVhcnD3NbRX332RlPlT3yP/DedFfJtks9sYr3a0tWwKeThdQT8xOf+AQef/xx/Pa3v2W3DAn65MK32c5Xja9GBgYGVvyg5grBi5wMEwhW4glgIeALrhlyuXDfXyFi3Vx6qDdk9XS/M91AN9Z+6kNw33Y/xt72h6uiwlryupGyzhRL3Xe8FmWP/IR7r0898Ba473wdkmodjg548czZfnb3zke9XYfXbalErW1x4/JnQye9HQY1aizaBV1rJDqTgEjCjtls4oQrcuGTUE/iMDnO6SAz2wvuo9zSsp7F72g0wvvm5M4nd3KxQ52gaVJ/eWqNReL78RMnWPikfXyKDc+L5PSe4oh62scn0Z8uJK6Ty56c/maTmcVP+jyKM7fZbSzC0uvoPflpxMe7cNauxjc3vw5/3PZIQcT/RPvj+OzW10M3+SoGB4fgdrtYyA0E/NwmgCKjJycnOXEg3/88Fo0VvhMlCpAYli94KH5+eGSYP4eWQ/4xmgbFsNN7dJksvNE4SAMrM2nYRXgl27hjx45hcHAQkUiE59Pr9WLHjh1CxL/CZVe7bhOSCi1SkRDa+0bnFF8UQ/f33bCPW0tISol/a61Gi0QqiXZZOSzx860x9rfsggmjGI/HudiExhlBY5WKYKhAhZIgSDClMUvrDn12Kp3hlA6dSsGX68FqOOYU0CZaxsVBGknBBSmGom0MjTlqcUKGCBpvVEx1KhTA2sAkakJTeKxxH8L6qnnH/ewigXg6F6MvBPzrw2peP8Ovvlq4nd60BUbTXHGe0nj6XWFMBuLchuZK/nYKBFdDeP1mpDVajtCnKH312BDiVXXiuFNw3dD2dkDX18W3M0olvLcUuXcF8yLOCy0vgttvQMdnv47ab34JplOH+TEpFETN//u/7Moff+sfYLW0urC+8jQcT/4KmtHiUlkgq1DAc9NdmHz920tWvF/t+7UlK+ATdBD5ne98Z6lnQ3AFyNIp7PvEe5F0VnC8z9jb3ousUoj5guWJZqgfpuMHYDp5iHvyJMoqlnqWBAKBYOUhk8F7050of/hHkCcT/JD9+cdgPvIypu57M1x3vQEZvQErimwW+nOn4HjyYZiPvoruT3wJkTXrC09ntDr0fvSfEKtpQFqlxskhH55uH4Y7nPv+syER/YHNFdhSY2bB5VpCxQOpTAZlRhUaHAu71kg4JNHZbnewS5guLtcUu4RJfCTxOh/5TVH5NpuVHfMkOlLvbxK2SYh3uV3werzsTCYh3OPxYNPGTeyKDwaDWLduLerq6rB1y9YZQlFeLCfnPYmrVquV+9LT4/X19TwPFrOF58FqsbJLn9zKa9as4ekl4rn+9jS/NE9UWODUpGG/bx++o1DgvSceLoj4Hzv5G3yy5S5Ee36GRCzC0dJHj5KwOwSHw85x/iTOU7Q5FR9UVVZxYUCxQzpf8ECibP759vZ2/gwqTpjvPQa1xL3WfRynL0eZUQ25/PJ+f3KPkwBNEey0/Kampvg+LS/hwr/8ZdfdP4SIZITZUYGx3g6Mjo3OKb6YL1WBxjONb1p/acylbY3wKUz4yC1/jg2eAWxxdQPaBPxjLn7eZDLxa6nVA30+tYVQqVU8HXo8n1pB048k0tAqJRbvr/X2QbD6oDYQaqUCwViStzmzt/G0baJxZ5Er8N9Pfh6GdAJJuQLP12yHX2lDVnbhJBi1Uo5QPIWxSRe6pkZEEojgqgi/cj4+X7Zr74wWJnkmAnFMheKIpzOo1osWNILrD53DpLZgliOvFFz4U1V14qcQXDccz+SKkQnf3tfMm4AnECx3UhY7+j76jzAdfRVVP/gG1K4JpDU6uO56PVY6ilCAnfW25x6DFAnNeC4jKeG59R5Mvu5trI8JVjclK+ALVi72wS5IsSikoT524o++8/1LPUsCwYJQX558JaDx5EG4735QLC3BdUHXfRYZlRqxuiaxxAUrnqykxOSD74Rv3x2o+v7XYT5+oFBhXfmz76LskZ/CfedrWcxPWWzL/kDMcvBF2J95BNqhvsLjVFE9uObvZrw21NiCU8M+PN8xyCeb50OpkOG2FiduXee8Lg6ydCaLyUAMNVYtGpyGC34mCYckIJIrmETpzo5OFjBJQCTRnKLzTSbzvFH59N5iIZ7E+8GBQRbzyak8ODTI8fR5cbt1Q+uM/sr0XhJK6bPC4TAL+OSMJrGV3BNUBEDivc/vYxepwqBgUZ/fa7FAkiSO1ac+z1QkQEKV0WjkeTHL49C+4TX4VjaL9538dUHE/2TH0/iHzW9A+tgvIJNlEA6HoFDIUVZWBmeZkwsYxsbHuECAxK5ih3SxGGY0mljcpWVErQdMRiPsu+3zvofnV6vkwg5/NAGFXAaHQXVZIi2JwbR8SESmvuuURNDR0cGPCy5v2dkdDgyc7YE+HAey4yzeFxdk5BMpyP05O2nh8OHDGBsb49YPVPTSh/Lch8hkOGtvwJjVhvqxFxH0eKHX61BVXcXJEVREQOJ9eXkZj1sazzTOaaxSEQZdT7i8aK4ug04lDv8Fl49GmWvR4Ysk+G8AbWeKt/H5lBJXPA6PUsUCvjKTxvapLhyoWI9TnX1QS9PvKWoZkt/GUwsQt8eP8b4OhKeGEYuKJBDBlZHNZBAqcuDr9u2b8xoqQBxwhzERiOWK3kRRk2CJCG7be17AP3GI294JBNcDRTgIy4EXCvcp6U0gWLHIZAjsuhHBLTtR9uhPkTKY5pwTUk2MQAoGZxgmljvkrrc/8ygUsZzhgaDiBM9r7uWExqTNuaTzJ7h+iCP4EuSee+7BSqa861ThdnDT9pKOCBEsfwLb9xYEfDoou5CAv3Fj63WcM8Fqp+oH/8F9kcJrWzH83g8iVtu41LO0YhHr5vKBUkz6/+pTMB17FVXf/wbUU+P8OB3U0MEaieDuO1+P0Xf9CZYTskScnTXW/c9y3zJ5OjXnNYpImJpYc7uLaCKNQ30evNLjQiA697X8erkMexttuH2985r1uZ8PdygOg1qJcpMG5cZcfPdCkECTd8HTNfWWX7duHT9O7vcssgtG5Rf3fi92pVPEOPWwHx8f52lQPH3x64shcYhcyhTdT1H4fn8Aw8PDkBQS5HIFC+QyyFBZVYkbbrgBqulEp/kEJoISAQoR975+KG7ciG9ms/jjU78piPhvLluHH+9+G7LHfgqdVsnJAhUV5RwzvX//fhZuKfKfRPxEIl4oVuDPValYkG1rO8Xuf6/Pi1AoyLu6+YKF4gKHPCQIW3RKeEIJdhpSUYdFd+npVLRsKfqd3OP0W9A13c/HswsufdkNT7ghV+lYzM+mkzPcyfnii3xbhNlJC9RCQavVwmAwwpdWIqLPtYzIc9c6Kyqb9nCbByocoPd7vB7EYnFkMmke4+Xl5ezIT6VT/Bq69A2PIpjMosqshsp+bVtrrKZjTgFmbGMo5p7i7ePJNBKRUCEdhYtYwhH4fX7epg84HagbyrmE9oyfxf6qzXihfRDHX36akyLKK8rR2NA4oxUITd81PobBkTGUGTRoqRNJINea1bp+ZsJhSDfciPjBA5BlMpDWrZvzmhFvlN33JNybFmgBJBBcDwJbdxdu6ztPs6gqjjsF1wPry09DnsgV6kbrmxFpXjmi5lIi1s/lTValxsSb3j3vc+W//AFsrzyDUMtmTL72rQhu3cPnXZYF2Sy0fZ3IKiTE6psLD2e0ehbrnU/8EvGySrjueSM8t97NjwtKY782jxDwSxA6WKaTQyuV8q6ThdsUOSUQLGcC2/YA383dNrSfhDwWRUYz//pHsb7KohPyAsGVohnoYfGe0PZ2ImWyioV5FYh1c/kR2LEPgS27YT3wHMp+8z/QjA7y4/JkErLpiP3lgOT3ovIn34b5yCucGjQbisanfoOuu9+AeHU9POEEXul24XC/F4lUZt5pkvFxV4MNd6x3XpZIuxiQa42i2hsdejTY9Rd1eedd8BT3nkwmWbzZtm07R+WT2352VH5xnDjRdqoNJ0+dZDcxvY9EUBKxSewnsbK5eQ277ajv/UL9lYsjnklgMhgMUCqV7LInZzxFlpN4f/vtt/PrSUTNzwtd579H/nFKAlBKSpTVl8Fhd+CE1Y7/zGTx/tOP4MWqLfjxujuRkSsg3/RamMdeRWVlBWxWG39XKjhIZ9IYHBjgVgIkYtG80/el6dP3GhkZ4WQCEoUpbp+XXSJZKFiYXeCQR5LLeTxwlL5MxkJ+cdT1hWhsbCykE5Dznj6bWgjQ44JLX3bt5zqQUhpgcVahpbEW46MjM9zJ+eILYrawT2OdKjVoTNDY8xg3QZbNICvLnViqtWrx3gd2cquM2eM0HovNKDyhcURFAiTw07QHJj3wTIxiasyGlvrK6/aTrvRjTsHcGH1y4Y9PuTHc01FIkKCiI2o1QtskSilJZtLAUD+/Z/fEWR7Howktuo+fgFqlxIbWDVxUReRbgRBU8BKKxrCmrlIkgVwHVuv6mVDrIP/YpxALx2CL+SGbdXKeClCGPFFMBeOotl6/gibBeaiQMZ7KIJXOcqJHOjt9nckik81Ckss43Ukp5QoS6fZqTUkgh2ikaR20fV2INLVA8nkQNVjEOSHBtSWbhf3ZRwt3XXe8ThjjLhFxXmhlonRPwnrgeb5t6GjjS6yiBv69t8K/6yYuYrnu5tBMGrqeDhjbjsJy8AXube/bdRMG/vITM142dd+bEGrdhsC23YBccX3ncQXhX6X7tXmEgF+CHDx4EA8+uDJjvGXhEGxD3Xw7K5PxRkwgWM4kHeWI1jRAO9wPeSoJw5njCOy8cd7X9vb2Ydt2MaYFV0/xAZl/981ImecXtgSXhlg3lymSBO/Nd8N7450wHTuA8t/8CNr+bkw9MDd+suq/v454ZQ2nonDU2LU4QEunAZps0YFVRqmC9ZVn2AVWTLipBb6b7oTnpjsRU+vQPhrA0Zf60D0ZQnaBydOkt9VZcNeGMtgNS+OMJoc3udXKTOpLdq2ROJMXaEg4J9f5fFH5xQI8iZN5pzsJox63h13pmzdv4feTeJ+PzH/qqafmiPfF4iaJ5SQw0efR706FBFR4UF1dA7PZxIITCfGzP7e4ZznF6JNzv/hxEvHzIvqju9bhU4b34FDZBhbviUzdLqjtJtiUUxyjTg7VmtoaduKPjY0jGo2weJXvh1743FgM6VQaGrWG55u+K7m7qQhg46ZN8yYDFH9fyJUIlFVAISvjk+AkuF0M6nO/Y8cOjlvPO7tJmKbHBZe+7Mb9UUQyEupqquF02Fh0yCdQFKdL0Pjr7OzEq6++ikQigWAoyL+72WSCwWgA4lmsmXLh0+d+iF813Yyn63bh3k2NBfF+9no1myNHjhYKBGSSBIvFCvdwL5C6vi0RVvIxp2AutC1RK+QYGB7B2MgINJrzCRK03aDtKBWgvBgMIKRUw5CMwxYPYo1vBOdsdUhAiWQ4xNt0Kk5Kp9MzWoEYtCpIai3GJ90wKu1wuVwiCeQaslrXz0AsiVA8CYNGCck8tyfsgCcCVygOrUqCTiVOhF8rgZ7So0Z8UW5T4I8mEYylEIwlEYilEIqlkMostLc7P7Q/Q78XtYHRqRXQT9/WqxUwaZQwapUwaSTeN6XixXybj5XA0B99GEmLDWlT7m967/ET4pyQ4NqPuz/+CEdzG08dhu/GXBGz4OKI80IrlCzg3Xc7rK8+Bxmds6H92vFhaB7+Icof/iG720nIpwunUVwjZ77SMwXjqaMwth2B4fTxOX3tKbGR2i2mDaYZmgJdBKW5X5tHCPiCFYXq9AnIp0+CU4VU2mhe6lkSCC5KYNteFvDzMfoLCfgCwWIgj0Y4pjuP6GcmWPXI5dzzLLBzH9QjAxyzX4zkccH55K9yd77770iarYg2rkWksQWRprWINq5Dynx5KRWKYACa0QFohgegHhmEZmSAiwcGPvgPCG3cXnhdRqfng0B9Vzvi5VXw3ngHX+j2gDuCI+e8aBseYCfSQpD7aGe9FTevccBxkcj6a0kqnYE3kkCT04A62+W71orj9OeLyi+mODafnPck3k9NTuHEiePc736h95GQfebMGXR0drArmohGY4hGItDqdNBqNRyfT4JpV2cnrDYrWltb543rpz703d3d6O/vZzGdovjp9cW9zEmAp/fe7Pfj+Ywc8M+cnxH9OuxsXI/GxBCLVlSAQOkDJF7RMqirr2cRltzX+c9du24dR+fnXfhU9GDQGzhyn5IK5itWmF10YPX7oZADCkU59/clN/6lCNFCsL803G43950vLnZo2bQV1mAcgWgSDoNqTgJFcbqEz+fDgYMHcKrtFN+mMWmz2zgRghIizmaM+F+9v0JNaAp/fuqXKMtE0SRVsDA/XwHHbIr7kmuMNoT9Hpj1Gk7AEAiuFBLE1Co5MqkkwtE4qqtmtoagOH3axgfDYZxUaXBTMlcwsme8HV0b7oXSXoPESDvC4Qhv3/Y498xoBVJfV4dRlx/eyVGcOdcFs0ErkkAElwW1H4rE0ywOW+YR50PxFEZ9UU47anCI+NnFgpZrz2SIWxOM+mMY80URTuQEksWCflMS/+lyMUi6N5CYr5G4xRRfs8CvhEkrFa71amlZOPtjdU1LPQuCUkMmQ2TNBr5Qcl12uoWYQLBaSTrKMPQnf43xt/4BHE/8CvbnHpvRV149OYay3/6ML+Hm9ej+5JcX7bNl8Rga/v0z0Az1Q+WeXPB1aY0W/l03Qx6PzRDwBQJCCPiCFYXqxJHC7ZCIzxesEMjxWf7IT/i26cRBjqy67vE8gpKBxHtFLMq3Y9V1CLfk3J0CwapHJkO8pmHOw5ZDL864r/R7oTxxiAuq8mRUaqQMRkTWtmLgzz8+4/XWF5/g9UoejfKBHon3yuAspXYa4+ljMwR8YvxN70Zap0egfi36XBGcGw/i7PEOeCPJC34do0bCjc127Gm08UnGpcYdTsCiVaHcqOETopfLQmLmfEJkcew9CUQkfJN4T7Hu5Lyf7315IfvgoYMYGBiEXC7jGGZy3FPcoSmVZMc9CaUarZaj9xf6XBLvh4eH4Pf52D2fbxWwYcMGdtJbrFaO46fXF3+v8qEQ/vtMDGwsy2bxjo6nIOuQI/m2N6IykeSCAL1eB7fLjUQyyQ57jtN3u9htSsUKVChAwjBF+6vVGo7gp77SwWCQCwxmf+/iooN8cQEJYKMGE+xWK4tuToOal4dgccT7Y8eOcUFGJBLhIguX24OatRuRlHQsFBS3lpjPKU9FJvR++p1J/DSajJAkicdeXJeGNpBCq2eAX5uUK9C+diNkbcehUMgLqRD53uEXKpYZHhnBiHsAdr0KzU01oiWCYFFi9A0aFRTqua0hvB4vtxgJh8Jo02hwUzj3d3LPxFn8gAT8mk1IjZ/jFJVMOoPKysoZhVg0nrdsasXgsAlGRQoOo1YkgQguC3J4h+NJdmfP1+KnbyqMqWACZp0SKmmZ9L1doQ77UV8M58YDvE877IkumB61FNC85Bz/JPbnWszMB+0W5YR+Je9zzxT4px/TKtn5vxyEfoHgWiDEe0EpkbSXYeyd78f4W34fplNHuM2h6fiBGa0OE2Vz2405Hvs596FPa/Vs0KDrtE6HjFrLgrsiHIIikruMvf2PuN1jnqxKzVH50jznj5JWOwKbdyG4ZReCW/cgI4qtBQuw9GcDBdedrVu3rgoBPygEfMEKIbJmPQtDUigIpc8D7UA3og1r57yutrZmSeZPsMr6mT3zSOGuW/QzWxTEurmy8e27HVmFxAdout6OQoFLMfJEHCpPHPFgYM5zqqkJGM+cuKTP0gz2zjjBSf3IDxkacW4siO62c0ikF3ba56m2aLCv2YFtteZLck5fD5LpDPyRJJqcetTZr7xn7IVivxdyEJNARIIPOe/zsfnFkKheLGTL5XIW6sPhMCbGJ+BwOuB0OjninOLKiU2bNhaEJ+oXnhfG859LQjuJ93mBlaZLgihF+VNRAAnq5FYvryif8b02bwGs5UP4ytOd+MCpX+H1ffv5+W/8Wo/AhmpEBwbg8/s4Lp2m43JNsfs6Eo3wdZviFMwmMxLxBPeIbmhoZEGf5os+vzhueqFih7wbVokkjzdfJME1gyTizydoCC4Pct6T+E5udhIfqb1BZ/8IQgoj1m/YAPVFWhZQoQklRFAhAKHT69h1H4lEMTk1BZexCa/ternw+uert2K85xCMEQv27NnL60I+/WGhdSlfVKLWG1ERS6DCrMH2DWuue8LCSj7mFCwco9/UUIcJTwBh9+iMNBUS7wcHBnk7eyKVxfsgg4Qs1vmGYY0FkKxci5TWyNHmNEZpm0zbXiI/lsscVqh0Bh6zlebV28dyObDa1s9YMg3/t7+FbPtZSDfuQ+aWWyGfbo9DkOt+Mhhjkb+5zLCk87oSoX1aSo46NuDF2fHgtDh+5VC6FBVRKGQyLjTMX2g/hRKfkuksX9N+TCpNe12LDxVbUtQ/XS4EzaNRS27+aXFfQzH+Ehc0aVUKviaRP3+brqmFzpUijjsFguWLWD9XB1m1hluN0oVSKAztJ2E+/DJMx17ltOfZ6HvOQeWeoo70F5220ps7xisgkyFa2whj+wlklEqE121CcPNOBLfsRqymXpj7Fomtq2y/djZCwC9BGhrmutNWAsnRUUijuYP8tFKF8NqNSz1LAsGlIVfwH+d8rDn1tZlPwLc7zp9kEAiuBF1XO7RDfXw7rVJzf23B1SPWzZUNxeO7734DX5DJQD0+DG1fF3R9ndD1dUHT3w1FIhf1m9Yb57w/o5krIlBv+1hVHR90xaevgxW16FVaMNgxhUFPhC+XeoKT+nVur7NwVD4JF8sNdyjnWKswaXherzWXE7dP/emLhWybzc6OexLmSRhPpVLQarWw2x3sdidI5C4Wu/PCeP5zKTafnPf0melMml9H06O4c55mMoVgIMhO6vUt69HQeH7f+q27auELRFC9//wB/vuP/wJflN4BY1MLzOZxFq1yDvwsNNPR5tFYlNsEjIyMshBmtdqgVErcZ5raAZBLuzhueqFih7wbVqtWw6pTwR2KQyGXQ5LLYdOLiMyrhYo6yHlPY4WKMEw2B3omemGMJuZNpiDBnn7vfOoEjSP6PblwIx3B6GhOBCVxxGgyQ+tU4uaRk4X3/9bRiPDYEYwhhpGRYR5vp8+cRvvZ9gsmWdD9RknLscFVZi0LCteblXrMKVgYEqUqnHZs2NAC/6QZmXSyMAZpnFNyCBdGZdI4rVBhWzr3t3X3+Fk8UbcL9rq1qDcrsXHjRi6IonWpOFEiL3rFkxkkUhnhkr6GrLb1k/a3ks88Bam7E/GXnoXMZoP81tv4Odq+9rvD3I/dblCvqP7oS00kkcKxAR8O9XkwGcytz5cq0FMRTpVFw8s8F2d/PtL+YsVuxdDvR4I+zQtF80fiKUQSaYTjKY7vp1j9YDQ5HbFPKQyLG9+fni7IpQswtwh4PiS5bIagr1LIefumkmTT17n7+dtqWRZV472o7zyOte5xHPqDj+aKGmYVOMy4TD9HrZpl9E9GqQJibAsuQCYN24tPwrf3VmS0oo3IlSDOC63OFIrg1t18QfZDkKXnnr/RDJw3aVwMcuPPZuwd78OIpES8ogaQhBR7LWhYZfu1sxGjpgR5+OGH8eCDD2IlQfFcP/70d/H26ftnHU34txdzJ2Evl8Xap5Utp6kss/30RZmdZfU7Xf2Udqka8MfTt2MvvoCvW89H6uShyEm94frtSMuW0YTooHM5sZzWqcuZld97LteqgTjYuBM/PEo9liYX+fe++ikto8V7SV8pEAjCZDJen3lZlInk1ig6iZM/mZO7pqdk5+8jfz93nX9t8evoxJA0z0mj/GP0mgs9n7tNJ6hk7CbPT3vJkMtZcKeLL1/gks1CHotCEQ7OOxj8u29BtK6JhXzqTRaStBiVdJgKpziKdSoUh8sVh6vfi0w213f9UqBltKHShJ31FqwtNy7bE8rkvqe+3s1letTZrtx9f63i9p966incfffdBSGbBHuLxYL+vn52gkYjUXZ6SpKC3c7EbLE7L4znP5dEKEKrzb2eBCYSa0MIcSEACes6nR5jo2Mcp14s4BNv2VaGz73uvdD96utY7x2CHFl86OhP8GnNH6KmvhzlyQSGh4cxPj7GgnAwGOBiAa1OC6NCgWQywUKvy+XGwMAAFHIFLGZLrojA65uxHC5U7EBjyqpXwRNO8rpH983ay29/IDgPtSqg2Hxy3tNJvKEJN2QqHSy6uaJQvq0D/TZUXEK/DSVDUAKD2WIuiJ10n/vTV2/BW3sPQDHtNTzqXIu+yS4agPC4Xbx5ikz3D1dKSvT09KCyonLeSP14Ks1/UMgVqFEuTZLHSjzmFFwcjaRAucMGp93KbtQ8VOBE2zNaN+iY5hDS2Db93N6Js3iyYS/W7LsH241hVFdXF7bBsxMl1JKcx280mRYC/jVkNa2fNF7C41OQdXfmHlAoIO3YWXieWhaRAz+eyqLGJv4GXqrb/mCfB23Dfu4/fzFIqF9TZkC1hUR7LewG1aKJyXTcQMK3SlLBcgm7oalMBiES88ldH0tycUcgL/Dzde4xKgK4VtAyOx/jf3E0qTh+8ttPQ5XJvf4fnjiKSZ3tij67+Bgwd5l5XFg4NpxetvljwuJjoIV+uYV+0hnncua/uajTEFwZW4fa8JfP/gec3/0anln/Gvx85+r4G3A9oSJxKgwXlBaaOz4EfTwMXSIKbSIGbZKuo9Ak40iQwVSlQ4QvWngkC6JPd80zlSRwLme2Ws5EE2m80uNGIpXF79+4ckTxh1fRfu18CAFfsCKgDcioL4oxnQ2VEQ8O2Jox5l+4n5VAsNxw6xrxXpkcUjYDU9CLyXEPosrZLksZXPHzvXcEgsvBmAhje+/Rwv0fVe5Bz1RYLMRFQYbx6NxKWsGVLElAUuTcJ3xNzuD8fRL72Y2SE/1zzxc9Nuu54sKA3OvOT5dcKcVFCbmTVLl5oBT7TDbLJyjpnGQ6k3P2xFM6Pgkc7/Mgnsrw7fzJt1Dcwu6eYDyMZPrKxwK5jtZXGNFSacKaMj3U0vV3xV4urlAcFp0S5SYtR4ZeL/Kx9HkHc3dPzwWF/GIhm377uvp6lJWVcb97gnqM19XVcf/5jo4OpNNpFj/Xrl07pw/zHXfcwe+laZFIKqe/35IEnVaHqqpKduArJAWL8F3dXXNEdXp8m9GHb972bvzlU99GXWgSykwaf33gB/iE9AdQBvzweDwIBUOYmJhggZ5EXGoRQOI73SehmPrex2OxnPsslcTwyDDfLhZrL1bsQOuERSvBG6GiAD+CUyOQk2tWrRb9pa+AxsZGdtBTjP6ps91Iq/SooHHUWDev257GEC1ranFAYiWNDRqnNEZtdhv/rnqdHmqNBpKzFfe88h+Fz/qJYy1C7U8jnUpxdP6JEye4MIXGntNZxikOVAQwMjrK07vp5psK7yVhQqeS+CJaJwgWE41KDrVCAV80AUwfytDYp7GdTqW5JYTRaMRZOXAKKuyv3YVDFblWJ1l7E7RS34IpKHkBP5RIIZ5MA6LgSHAJ0H5a+MCBnAhJQmXrJsgM5wtvh70RuEIJTqERDuWFof2L7skQnj47yQL+hSBH+ZpyA+/T0oV6xS8X6PjAoiOxX3XRAtXcfn6yIPYXRP8iR38sefH2V1dLTFLjpKMZuyc7+P6e8bN4pOn83/TLITudGnC+78C1aEAgWIl84MwLfK1JJRCJJcU59StCBl9CaBGliR5Q6AE6tXChGg4Kaomu7DHiiyYvK3VHcO0RAr5gxUBV+3SpCLsRlUQEqGBlEVZp8dWtb0a/qRId1lpkZcujr7Fg9bB7/Fyhar/TUoNuSy5WWiBYTtApJBLLk+lr53pZTlCBQbVVi7VlRmyoNKLSrFlRYhpFGAejKXZV1dmuv9tgPgfzfG7jhYRsEpFIBHe5XSys5mLw/SyGUo95EkIpgj8/rWIBln6nmuoaFvLpsaNHj3Js/vj4OAuu4UiYxSrqZU7zWDxP9H6/z4OatB+f3f07+Oz+78EWD8KUjOBvDv0P/vfWNyCV7kMmkzspTLH8ND0W7ONxVFZVYr1jPfdKp/sEzScJwfP1P88XOywERdVmvD68cOAQBjvbkYn4YDbosG3bNtx2222F3uj0XajHO32mEPjnh5bVjh07oDdZ0D08iaEpH5RIcTuFQDDAY6zYbU/LctPGTQWxcmxsjB38sVgcSqWSXTz0e07AgjdPnC38He+w1OKVgdOQRSP8epVSiVQ6BY/Xw+MvY0vD43EjlUrD6/FyYQnFktM4oKIkWnctGtV1aXkhKC2o8IxEfDpBST2qqYiOtpFdXV0IhkJw2B3swnel0vjPdbvR47ix8N7BQAb7ynULpqAQFCedjGY5Rp/G8nJNpxEsD2hbF4mnkTlysCDgS3v2Fp4nx7UrmODYddoHE8wv3HdNhvDMRYR7WhUpOWp3g5X3C2ndX8lQgSMVdVysvRDvC8fOO/jz7n1KCYnOd51I5wT0y+RQRWtBwN873n7FAr5AMB9lYQ92TeTGF/FY4w1iQQkEAsEKQRzRlyDl5eVYyYzrcycZBYKVxuMNYidZcO14tm4n+syVeG3fqzhtbxSLWiBYAux6FersOo6ar7Xp+GTxShYfyH1v1SlRYdawk/d6Q6LQbAfzbAHb4XBcUMgmUZ5EfxKUBgYGodNp2YlP0yBXPYnmCxULkBt++7btfCEh/6UXX2JRnaZlMBrQ3NLMDv7Z80SueXL6D/T3IRJpxz/tfDs+e/C70KSTqAq78VfnnsMXN94Fw8CrcLtdHMcYjcbY2Z/vbW6zWTmGmhz6JOB2dnSioqKC563YrXqp9Haew5mTJxCMRKGXgPD4BMKvvMLzfdddd7F4T+0AyFlOfanpM8lpTmJ1XuAX5MeZDZbyOOJDHsgySYwMDXKRCLVraGxqRFNTU8FtTxSLlTabjYtHJGkIfp+PC0XGJyYg23wLXnfou4VF/OOyVsQPPcwuR41aA4vVyuOKij2oGGBicoLHvoJSR5QS/1a0vtAYJBGB+u7q1Iol3f6s9GNOwYVj9MkpH0tlYFDIefxTa4dsJou+/j4uKqGxmkgfhPzmvcjIcmkz0VQWMV054vGxOS0/8tA6oVbIEUunEUumoRdFKNeE1bJ+krAajiWhOH648Jhi93kBf8QXhTuc4CShlbw/ds2E+wly3E9g0LNwb3ebTondjTbsrLcuK6f99YKKiuwGNV8uBU5NSmcLoj5tx6gIIJHOsOufYonP3z5/HbTsBU79kqexzdWNFqMMEUnDcfxUzETpYYXbmfO3qVaAk8Wu8XIQrGzuH6CUkukWTWXrMKY/f/wkEAgEK53yVbJfuxBCwC9Bbrhh5YmILRVGPPIXN+PogAdH+72wGVQwXsnBwyLt1WaX01SW2Z76oszOov1Oy2fhrMrfadG+13JaoxZnQkv3czcihpuwBuBLYX6W0cJZRrOymJNZFOiEz6JMZ/o3z8XEnz+pk4+Mzz++0H16NT8+fWKIL9ncdf5k0ZzL9PPFr8mfXCKHXnL6+hLaaK4IVz25dZxGNZwGNRx0PX1bq1r+kfiXCp1MpB6i5LKqtV5C09FrAAnVJFiTeL9Q3PL27dsvqQiARCGz2cTiKfVq1usNLJjnp3WhYoHNWzbjvvvuw/qW9fjZz3+G/v5+VFVVYcOGVjjsc+cpD0fhZyNwu9rwL9vfjo8f+QGfPNvo6ccf9JrxH451SIyNQqFQ8LzRdSqV4nnxej3s5qb1kgR+Kho4cOAAu7mL3aqXCsXve6fG4aiqhcViRdQ3idGhXgwMDPDz5Lwn8Z56sZOYRp9H961WqxDwZ0HtCM72DGB8YgxWnQr26koeL5NTU6itq5vhtqfxRC78YrGS0hRefOlFTE5MIJ1JI26owr3+YRhSubjFYYMTrwYnoZIUXHBiNBnZgc9jSlLwWKaxQReb1cb9xKnggsYgjRdymtr06iUXPlfiMafg0tAoFZzsEYolOeWBt58jI1wsFQlHOC2CWo8gnYI+7kJQc/6k2gRMuHW9hVtALNQWRa2UswOfxK+lHserldWwfpLwSe77aH8/tJMTuQd1eig2buSbtC2cCMQQiCXQ7DQs7cwuMyYDMTxyagydE6ELnoO7eY0dzWUG0XrgMqC/0SqJLnKYcTnnLGsQfa4Z2oEeSJk0PmT2wL/31sv56BnHcrlju7mPnT/uO3/MV3wMOuNQrehO9jKPX+d7dKFD3eLzdgu/RnClyFJJ3PHM+VaLeMOb8Rdbi88WCQQCQY72ET9aq0x41966FbVIblgF+7UXQhwNlSB08m+lDWxyfW2qNrMTrN8VQZlJDetFoq4EgpVGb08vmpqblno2BALBLMS6uXjkBP4MUmkS9MmhkmGRn67JrVJ4LjN9v+jx5Kz3pIrey49Pv5fuUzJ5vnChuECBTqqRAYt6oPJFnrtNMZrkJqSTbSQcUEQw3SfhgPrWGzR0rYRRI/HjKykG/0rxhBMF9/1SFSaQuEOi54Xilo8fPz5DxJ/dh5ycoVQEYLc7uM88QYI4xY+TCJ+f1qUUCzQ0NuDee+5llzwJs7PnKf/Z5EBNJBNYv2E9FwtQbP8AvPjWptfi/acfKcSj/mjt7RjXdUDm6YPJZGKhnJz4RCgYgkpF/Xrl7PYnsZZc/STgFrtVLxeKe6eTtXEokVRoCkU1JDKT856mTZ/rdDrR0XE+wl+QI9crN4lAJAHEo7DXVObGi92B/v4BHlfJRLLgtqc2DPTb0jgkRz7FjFNhCCU/kGhJy/vJQAWeVlmgS8Xx+t5X8LPq7VAOHUVlZQUkRa6HPf0OOr0OZnM5C6VU6EEtHMoryrkggApNaAzGUxkoFDJeZ0lkXUpW4jGn4NLQKOU8vnyRBNxuL2+fIpEoPO5c4REVnTjLnLyN9cbGWMCvDk0hpNSgc0qDhvt3XdDJS3+Dg7E4j+f8327B4rIa1k8qMgwlUlCfPFJ4TLFjJ2SSsuC+94YTMGtVKz7ufbEgVzg57l/tcS9YVEs97e/cUMZJUoLri3/HPhbwCdPxA5ct4NO2UsGbS7HNFJzHcuAg1EE/305YHZBuvhXVitVTdH49EeeFBKudMW8U1RYtyk0rq+3QgVWwX3shhIBfglAUp0AgWDoUAR9MJw9DHovAffeDhcfphJdAIFh+iHVz8aD4UnYliz3QZV9o4Y8m0OQ08AHc9f5s+keFFSRukqOTBM+F4pZdLldBOM/3uidhUy6X8+tJ+KRe8yq1it3kJEpzvHMkwoK50Wi85GIBYqF5ounkI/g5hj4cYbf/5s2bMTY2jupoBF57K34d9uDm0TY8tO+PMGCpgfrGd0M68F1YDIppB34SiWknNV0oDk4GGcrLyqE36Od1q14KJCSXOZ3web3cmz2cBMzOKlgr63iZU0ECubjJeU/iPV3TfXpccD6VwhdJwh9NssPdozs/XiRJAZPRyK77559/nsX21tZW7ktPUOuFI0eOcKsC2gZqyVlvMCKkMCFqrKF24vjvDffhp2tvR+zEr6CXZGiob+DWDWqNhi1pNJYDwQCL9VRkodXm1k2lpCysF9SXlwqfl4NrWRxzrl445p4K3iQFjh07w9s80tgz2Qxvv6lYymq18RjdMXgMNx9+HDVhF7618bX4ufp2tPVPwJT0FgqtZm/XcvsKMo6eJhF/qYtRViMrff2kIk4S8COJFAzHDyMz/bi0JxefH0+lMR6IwRtJosGhR6lDxaxH+r144sw4wvH0gsL9Xa1lqFmi1CUBENhxAyp++X1eFKYTB4FUCpCW/u+5YGVjf+bRwm3PbfcDQry/YsR5IYFgeTKxwvdrL4bYExAIBILriHpkEC1//yeQZTNIGUxw3/E6sQMtuCpszz4KRTQCz633IG00i6UpEAgWJSKcEgeoLcC1EAJJMKaT65SYkG/BQC0XyA1GqQgkWHNyglyD8oZ1yKoNSCaT0KpVqK+tgd5kmjG9vHDe09PDDlByfm7evAWJRJyFdHKtU797ct6TKE7uUBLXSegnV7TFYmEBngRSisdPp9OorKjk/vaz3e4kMm3atIlF1GLxqTiCf9u27Th06CAXC4yMjKK+vg5btmzBvhv24T+ctfjzEwPwaqa/g9oA2e63I3j8h5CFQ8ikMxxjTw5rmh86GCWBmL4Txec77FfWs5KEZBJ/29vbeZlYzDrUrWtFTXML3KE46hsauI86CXE03yTe19XVobGx8cp/6FUEjU9KpfBHEixcNjfUIRoKFAo5qEjEZrexCzlLESAAF0qcOXMGnZ2dLOrTST8S9gm6TYUg3uaNQJHBIRLxQT7VRRZknt69997L44149tln0dXdhebmNezOp8KQaDTCY5FeYzCZ4IkkoFWqoBOCp+Aao1UqEAsHcLa7mwupYrE4tyWh7ScJ+KFQkK9tBg1qel38nr3jZ/Hztbfjt0e6sUU1waknVARF6wKN4WIRn0T7RDLDIr4Q8AWzCcVTiCRTUMsyyBwrcuDvzgn4o74YvOEkdGqJ05VKmRFvFL84NowRXy7hZzaNDj1eu6VCCPfLgGj9GoSMZhiCfkjhEPSdpxFu3bbUsyVY4ecfDedO8e2sXA73bfct9SwJBAKB4DIRAr5AIBBcR+KVNUhZrFB63ZBCAei72hFev1n8BoIrI51G+a9+CJXXhYqffxc9H/sXRNZsEEtTIBBcMSScU+RsnU2Haqt2Ud1y5KQkMYZaH6gVcqiUCu4TSm0NFNzSIOe6JPc9zQddyowaNFY5+TaJ/eSCJgc03abWB7E0cPzgISgVMha/Y/EYEvEEO83ZLe/z83Ve+CYBv6KiAnW1dYU+9+QmpcdJ0CfxiZzwJPpTNPl8bnd6bPbj3T09hQh+mgcqCKDpZTJpjsUf6B9gUd4wPAKZwj7jvUmdA9a9v4tm/zEEfD6OZK+oqERnRwd8fh8i0QjHsM9XUHAxilsKmIwm3LD3Bo73pxQCs0GDvoFhXt4NVU5uRUApBVQ4QIUIJN5TSoEA8EWTHJ+fymZh1ygh084s5BgcGODF1NTUxAUXg0ODOHf2HAYGBjAwMFgo7mgoa8hFjY96kFCaEDbM7C+oGm+DWi1xgQn95sWiZl19PUfv02fwGCmv4OIBepxeQ9H+WqUEvUridUkguJaQqD4xOgKvLwCFQoJGo+b0DhqbtA2mlAiDwQDz7t3InjoOGbJo9fTDkIjgnEvC9no1miqrCtthWpeKt6tUKEPb+mgyjcvPHBGs9oIqEvDDiRQsY8OIT7fHkZWVQ17fwPsbY/4o3OF4ScfAU0upp9sn8VLX1Lxx+RadEq/dXIlN1SbRpmK5IJNhuKkV60++ynfNxw4IAV9wVdiffXRGi4aU7coKgQUCgUCwdAgBvwR58MHzkd0CgeA6I5fDv30vHM/+lu+ajr1aEPC3bRfV1YLLw3T8IIv3RFqrR7RhjViE1wCxbgpKCRIBSTix6VWw6mbGx18uJIpTv9VwIhfXStM1aJR8TeIPXUtyObvuScAn8b641zG9n046k3jvcrnR3duHcDQOmVKFyqoaJONZDA+PoG9knAXzWCiARDKNickJVFZVFmLwSbzfvGVzoc89iffFfe6HR4b586w2K9asWcPvIxGbxNJLJR/BT8Itudi7u7tZsK2srITH4+H7OAjEolHIUhmot70TcVUuNaU6OIk/OPs42t70+7AMvopMKs3v3bptK6cLkLC1edPmOQ7V+UR6mg9aFjTv87UUIFGYSKaSGB4chEoziUAgCBla0Vhdhp07d4oT+bOgiGbuex9Lwa5XFpbP7EKOM6dP85iisZVKpTE5NYWGhno4HQ4uCiGHcldXF48titLX7r0F7+x4Gs/XbMeYwYFs2IvQ2ZcBlYx/Q7r4fOd/WyoSIKf/fG0eeF1LpuHQX5vUjCtBHHOubmh7jXQSetrGllUgHA7B7rBzuxKbzcZjdMvWLdh1191I/OZhqLvOQpHNYOdkB15SbYNCr5mxHaYxXgwVaJFQSy58KtwqdRf1YrOS108S7ml7R/sPqnXroHziOaSPH0U2HObtM4n3VIhILR5KNb2hzxXGz48OwxWauV4RVPB4W4sTt65z8nomWF4o7309MC3ga4b6lnp2BCuZTAamU4cLd913vHZJZ2c1IM4LCQTLkwdX8H7tpbA8ju4F1xWKBm1oaBBLXSBYIgI7biwI+OZjr2LsHX/M1dZulwt2h6iIFVw69mcfKdz2vOZeZCWlWHzXALFuCkoJigkvN2lQZbk69z057YOxFCS5DBatCmqlnCOX88L9pTiE6US8Qgb43B6cPnUi11s+EuF4d0T9SGVlMElpmFWAUaeCUm6BOxBGLJPG2KSLBdB8b/AL9bnn+Z12z19IULoQ9BnU5/yVV/ajv78P4VAYVdVVHFlPIiyJt/T5wVCQxXR7x6Nwt74F2129+LvDP4A+FYP8l9/F/jvugz40wEK/1+ctiGB33HHHguJ9voUAfQcSeCkBQKPWYGx8bE5LAZoform5mb8vLQO/axSdfUZ23xN2vWpRRXwSq/v6+laks58cjLRO+KIJGDUKSAuIHbPHlsfj5sftdgePQ+pl39PdA6/Xw8tBYXBgu9aI3z/xE7zr3JN4tnYnvqhzQCNPQyFX8+84MT6BF196kZdZ8W9L6QmULEGflx/fJGapFHJo1ZRqsTwEGXHMufox6tRw2CwIhUJwOJzshKb0kJrqatQ31KN1Qytvt+K3vQaJrrP8nr3j7XihZjuOj4Th0MpnFKLMRk0x/ak0X5bLuF4trOT1k3q4R+IpGKaLlWR6PaSbb+XbVPA35o/BNb0vU2rEk2k8fnocr/Z65n1+S40ZD2yugOUqCzQF145BZzV0b/tDNn3Eq+vFohZcOXI5Oj77DZgPvwzTiYMIbdwuluZVIs4LCQTLk/4VvF97KQgBvwQ5efLkqh7UAsFyJ7RhK9JqDRTxGNQTo1CPDSFeVYehoWEh4AsuGdXEKExtR/l2lgpAbn9ALL1rhFg3BaUCRdISNp0KTqP6igVPEu7pJLpJq+QT7CaNElrVlbvgSPwl8Z56w5NYOTU1heGhIRaN1jc1oLfjDPxjA1CodDBIGVRW12Hrrr2wWqxY01BbEL45Ut/vL/QtzwugJFaTC38+Z/Pl4Jpycd9nipM2GA1wu9w8rWQyyc73UDjBfdHJLW3wjsLU/SRsKgeL98RNo20YOlYJ/56NULgHUV5ezg7+W2+5dUHxPt8XXavVcXoAOf3JqU2x6iQaU2/qZCJZaCnQdqqN35t3itO1v7cXalkK/mgCWfqXBRyGxRHxSbw/duzYjOILr9eLHTt2LHsRn9o0uEJx+CJJLkTRqRY+dJ49tkhsL3M6IUkKOJ01nKKg0+uQzlAaggK63W/AOzqf5fcqkEVUJkOq7yCy0ykRSqWSl5mklLB169ZCsQW3PjCb+fel8UmfS2OD5tOoya1vywVxzLn6WdfciKFJL3yhGJJhHyJhJbQ6LUfpFxdPSTfdgsQ3v8G3d02cgzyTxrFhP7wnnkB5GSV/7Ji3PYhGknOCSyyR5r8jgsVjpa6flOpDqSiUzkMFHrOZDMS56EoG2bLaHl4POseD+MXxEf6bNRuzVok3ba/C+spcCo9g+TI4Ng7b69++1LMhWCVklSr4bryDL4KrR5wXEgiWJydX6H7tpVJae7QCgUCwDMiSA2/zTliOvFKI0Z+qmtkDVSC4GPbncikORHDLbiSdFWKhCQSCq8ITSrD7utKi4b7olwMJ9hQznkhnYFQrOcabBHy9SnHVQjA5lkn8JYGH+iqTOESi8OTkJB+okThNEeXZTAotNeW4/e7XYPe+WzhmNxRP5sRNtcRCZ3Hf8rwASpCoPlvYv5x+8xRz7g/4YbFYsHHjRnR2dqHt1Cl236uUKu4JTcRiMUiSxEKsOnwcz6+7FY1NN+ONvS/z87/b/iS+ZC5D3a41qLCZYDQY4XK7ORI/L9YWO+9JvKeKc5rf4eEhCvRBOBKGTqeFTqvjIgZy8kdjURaASUQmZhcr6DVq/u1J+ECW/mc5jv1qe6nPV3xB98ntfz0E/Ct1/1N0t5vE+3AS6UyGW0pciNlji5zIgWAAgUAAU5OTPGZJ1E8lUxjxRVGvNmCLu5ffm5LJ8UudDemwH8lkApJCQigcgtyl4EKQGcUWPj+L97t27Sx8NsWLU9EFJVzQRSC4XlSUObFj6xYoNEZEm2oR9Hm5FQm1LSneXsnXtSBhsUPlc8OYjGKDZwDtpgr0jUwglUxg/fqWeadPrntvNIl4MsN9zRdKwBCUDsF4kt33tG8xH6P+KG+77YbScZhTQcMjJ8dwbNA37/N7G224f3NFybYTEAgEAoFAIFjJCAFfIBAIloDAzn0FAd987ACmXieqrAWXjiyZgO3FJwv3XXeKfmYCgQBXHXkfT6Vh0elQcZmxs6lMBt5wEhpJgTKjigV8o0a6avE3Dwmv5Nwm8ZeEULomJ3u+MKCqqoqFWoqmb25qwo27d8Bu1iAcTyEQU3DcLp30p4QBo9GEzVs2z/mM+YT9+VzvC0HvS6fTLJiT+Gs2m7jPPIn1NP+ZbIZj9ak3ul6vR3lFBYu1Bn8Hnr3hHagPTmD7VBdP6wOH/gdfML4PoXIPC+v5/vXk8Kb5pPmiggEqOCDnPbmzqTBgcmIS0WgUep0ekUgUVVXV3I+anIgTExMwGAxobW3lzyBhOe8UV0gKuNwunD1zBpXVNQhSQcP097paEX++4ouOjg5+/Fpzpe5/KuZwc2x+ktcJ2yWmEdDvUjxmqMgi37+eYvTraut47I4G7Hj3yccKr3u6ZjvcE+f4tkFvYNe9JCl5Gcll8osmQ5B4QwUzdFnM1gcCwaVQWWYH1HrealAKRPH4p8SP/Da1eu9e4Ilc8emeibM442iCpmItoqEhnDvXgZZ1LXO2uTSeqeVKLE0x+hkYhIBf0lCxUjSeRjydgVmnRPLF5yFTqaDYth0yjZaLCL3hBD9P+yClQNuwHw+fGC0kKBVDRXlv3lmNZqdhSeZNIBAIBAKBQHD1lMZerWAGe+ngWSAQLCmBrXuQlckhy2ag6z4Lye9DU1Oj+FUElwT1MZOCfr6dsJchuHW3WHLXELFuCkoBEizJZVxp1lyWy5Ei8+mEuUGjhEWr5GkstkuSXNMkvJIQS+IvCbEkwJIQTs50rVbL4ju53enxvDhLgqZOpeAT2/GxADr7BhAIJ6BVq9DSVAe73TpHaJ1PvL/Y8wQ9XllRicmpSe5fT/3LyXmvMCpYUJcr5CyuKxRynm+VUgm9XsfO9Aea5Pge/gDlj34JVWE3tOkE/uTlH+Fzu9+ArZVJ7Ni+jcVbEuzpe3JP6emodYrNJ+c9fR49X1FRgZraGmjUGnZ+lznLOIaf5jnviiXo+5BoT9fpVBqDA4OcaECtBPQGIxIyNUw6FVrXNGBdbcUVi/jzFV/QfXr8WnOl7n+KHw7EkgjFkizeX24axXyCvsNu5372rjjQEEths7uv4L5/ee0W6E89gbROy8vF4XBwgQoVf1AbBRLyF0qGoJj/eCoDs0a1oCN1qRDHnKUBuXpJZCfx1Dhd+5VPCKFtksfj4QKa1ixw8/R79oy34zsbX4ukrRExdzdve2ibNh807TjF6CfTJReJfi1Ziesn/S2PJNLckoeKOxJf/3dk+vsApRK6b3wbE/Y6LryifZEr3W6vFGh9I+H+zGhgznP0zW9Z68BdreWcYiFYucedStcEmz3iZRUIblt566xgaZCHQ6j99pfgec19nPwJudgOLBbivJBAsDzZuwL3ay8HcQRUgtCJP4FAsLSkjWaE122EoaMNMuoTfOIgovtuFz+L4JKwP/NI4bb79vsB+fI6ab/aIHFQIFjNkAgfjqVQWWZAleXSx3s8mYYvmoJFp+L+qjadatFc98WQ2EquaRJe81HoJNafOXOGBX1yn5OjnGL0yXVNl7xAyyf5wwEMd53GaP8wvKEYZGodPP4Adm3dyD2W80ITCeKzne4kRL164FW0t7cjEo5wBD252PfdsG+GiJ/vgU6MjY+xWE3zFYvH2CUfjUZgMpl4/mneSHj3eD3s1h/q68VOqxOf3fNufOGlb0CXiqMi4sUfnnkJv61+UyE+nUTcvMhFBQM0r4lEHDU1tTyfVChALnsqeKDofbVGs2DBAd0ndywJZ2qTmqc/ODSIo0eOcg9rm82BjEoHfyAnDqypKb+iwoz5ii/q6ur48WvNlbj/SbgnAZ8uXIwyz0nPSynomP364eFhLpTol+rxV+f+p/Dcc4174LBmMSBXIJPO8JghwVOpVPJvSHHkSkmJsvqyObHkefc9xebr1IplFy8ujjlLAxLYScT3RRNwu70YHRlG+9l2HvOUPEGJFnT77OQU9sjkUGUzaAhOoDzshk9lgzyVhlIpzUmWOD99BYKxFAv4tL28Fn9jSpGVtn5SsRJt7yLJFMfjZyYncuI9IZMh09CIydEI/JEkGhyUCLE6ofXp6IAPj5waRSyZmfM8JSi9ZWc1am25djmClXvcaX35adT9x7/8f/b+AzyuNC3zxu/KOZeyrGhbzrnb7c5peronMIFhWJhlGHZnybDAZlh2h2+XD9g/Gz+WNCwMM7ADDMPk1Dl3u52jHCQrx4qqnOt/3U+5ypIsu93dslWS3t911aWKp95zqt6jOud+7vuR67FddykBX3HLeF97Du4jr8plbu89GP6131Jbb5nnp0KhqC9cq+x37TtFCfjrkKeffhof+chHVnoYCsW6J7bvHhHwiePkYTzvbMKevXvW/XZR3Bzz2DDsl87J9bJOJ5XVitvLuXPn1dxUrGnooKcA3+g033KPVPagTeQK8FpNcFsNcrmd8d3znfWEIj3F2AMHDuCrX/2qPEZhv1AoiPN6/nN5e3xsDG6bGT0dbRidDmEuMInLQw7oNBqMTUzAYjZJFP1ipzuLBChqxxNxEYETswmkU2k4HU7cd/99N+2BfubMGRH++Vq/3yfiNV/b1tZeE+WnZ6YRnYvCkErCWAT+f/t/DL95+C+hRRm7g1cw/sZruNzdBkchsiA+vVowwLFOTU0hl8vB7XbLe/B+RrFv7O29qbDMcVIstlpt0lt9cmpSHPibN2/Gxt4eBEIhjE5MS9sBl9stgjbFtPdafHGrfejfK+/U/c+WC5FEDpF0VhychiUE8fnO4hsVfCwW96vtDoo2H5pCU9geHpZl5TU6DDzwPswNvCYtFmibpPOe24lifWNjo7RPYCsGiviLxXsKOelcEV6bSdIm6g11zLk+qMXcJ+K4fPECgjOTuHTxEgLBoLQS4b4pn88jUSzinNECr9GOt5q2oqjVIWtwImtwSOERxf6l0Gk10Gs1kjTBC93XivU3P6vuezrKWViVP3K49phu1x4E8xrMpfMwGbRr1nUeTubwteMTuDybuO4x/pZ5ZGsDHu5rWLLwTLH6jjsTfTtq99nPn4Q2nULJogozFG9DubzA7BHfdUBtstswPxUKRX3x9Cr7XftOqb8jfYVCoVgnzO0/JGIs/yZ27AP6L670kBSrAEM4gJzHD2MkiLn996Lg9q70kBQKxSqGrja6jbv9NrS6r+Yfvw3xTF6cXz6K97aK+/5OQwGYQjCFoT179kgsPe+jmL3YYb3Yid3d6seZ/kuwaAtI58sIJ/PY0tSypNOdgvZsIIDW1hZ4PF5EImEMDw+LK3+xw31xD/S2tjZx7HNMxWIRzc0tEq9PJ77X58XQlSFYLVZZLh35ujOncSYGfHHrk/hMf6VH+geH3sTvvdCHzr0t2Np5LT59fsEA3a5cP8bns8/64iIEspSwzCKDUDCEi6GKK51ufIptFPC5LRp8PsSiV5DO5BCMZ+W7QhHfatS/p+KL5YJFHCzOuFFhwDtx/1O8D4t4n4PdqIfpBoUsVTGe77e44IMsJe5HohEMDg7ivHkHfunCD2rLerHnIEzaGCYmxkXAZGQ+W0IkE0n5jvAE4Y0+T8I5yCIDtom41cIbheJ2QFF9dnoKo5NT8FhN6OjsRCKZwOTkpLQOYQEKW1l8Y+cuvOV9BGXrtd+ueW8vSsU0+i/0SxHSUkVH/H4z8SWdr8SnK9YXLFbiPpqX6u+NwpG3ao/r7j6I6bkMoqkcPNalkxxWM6VyGW8MhvCDszPIFa933W/wWPDD+9vR7Lq133CK1UG+oRnpDd2wjA1BW8jDcfYY5u56YKWHpahzbBfOwDw5KteLZgsi9z220kNSKBQKxXtECfgKhUKxQuSa2jD2M/9SbX/FO4L97vv/+xfhPHEYeX+D2noKheI991GlAMhIWqfZcEsuuFyhBL/NJP3BV9L5S4fyxMSE9Am/mcN6KSe2225Bi8uCeK4Ej9WAqVAEfo8H6Vh4gdN9PgwYYMR5NDonovyRI2+JcE53ed/mPmzfvn2B+NTV3SWCVFU4p2Aei8ck7p8Cr9PlhFanFfHe6/Vg585dKJ48gRN7DqI7NoWHJk7ibzY/ipcbtqMva8IHNm1ZIMi/efhNSQigOEyheM/uPdBAA7fHI476ahHCjVzjFNhkfSJRZLJZEY4LxYIUMGzZslXi+S1WM3x2k8RWhxJZFItleOzlW/qu3E4o3h8/flwSDhjPzfYJLEq46667xLVeFfW7urre1v3PgpTBiVn0D4ygXCzAYzPdMBaf25TbkOL94oKPpcT9U6dPyeczGs2h1e3FtvCILCev1WH88Q8gFzgnqQyMymdxwczMjCyHhSYU75cqKqmSzBXgMBvq0n2vWF+YmcxRyCGVzqKnrVkKqlKpJKYmp5BIJKDT6WVOzUbCKOcvAt2Haq8tejsRTxyTpJPFySZV6PAPp3ISo08x93amvSjqDzrvWbzBj53uen4HivME/Nyu/VKIyKImu3lt7Q9nYxl89fgERkKp6x4z6DR4Ynsz7tvog1bNiTUJjR4U8Inz2BtKwFe8Lb7nv1O7Hrn3UZXaoFAoFGuAtfXrVnFLdHZ2qi2lUNQhdyJOVrFG0OkQO3DvSo9i3aDmpmItQ1GEPVMpZr8ddECyB63fZobfYVpxJyTF2OnpaRGhb+awrjqxKfaePHmyJvZ6PW5s9HqRjs/h0vAEhkeGYTRZ0LuhteZ0b29rR2NDA6LRqMSbz0zPQK/XweWsOK7pWh8ZGZXlU1SoRqlXWezKn++EZ2S0OLQjYSkqCIdDIv7+5B43/sb6T/H8uRN4q3mbvK4/mMdXzobx834vUvEYnn3uWTz77LMYGR6R11J4p5C9e9dutLW3obGhsRLjf/pMrR81Hfo9PT01RzdhAYHT5YJXr0NHxwZZXiKewMmTJ9Db24u21jbZpnQ90v0YSmVRLJdRoJB/m9sm3Aw67/l5spCCbRMofDMZob+/H5s2bRIRv/p9YIT/jfbj7Jd8ZXIGh0+cQyQwhVI2jalFsfjzYWEHCyC4DSms82+14GOxuG80mqTAgikHwc7H4NYacd7bKSL+0x0HcGh/L84emYbZYkG5VJbn8S+dyuyxeeLkSVitFqRSaTjs9gVFJSyiKZcBi0EnBTj1iDrmXD+wwMdmNcFmNmM2FEaz3ycpEpv7+mQfmUjEMTszI9cLlhz08wT8vKUBhYxFkk6YeLIUep0WWmiQzVdi9FXixPqanywc5P8f29X0l9LgAMrhkFzXuFyYaupEZDIGl9WwZoRs7uNfuDCLly8F5X/uYnoabPjhfW1SYKdYW8z/vRLbdy+av/5/5brz1FtAsSjnARSKpdDPReA68mrtdujRD6oNdRvnp0KhqB86V9Hv2neDEvDXIYwZVSgU9ceGjopYoFAo6gs1NxVrFZ4QJ16rURz4N6NQKmEuU4DbYoTbZlhx8b56EuXQoUM3jVGvPo9O7EuXLol4zzh7ir4UfL1eL+69ez/8Pg+CsQzyGj08DS2wXO3HTFc9XfMUi1PJFBxOh7il6f4PR8Li7jYakyIYLxVzvpj5gr7f58P3v/99HDt+DPFYHBarRQoGUskE/sX79+FfZMq0Wdde+w/HJ7DBa8VGXRhvvfWWFBNQuKdYnE3kxNlPsZ6FBCww4LgpiFX7UVMUzjRmao5uCs90yrIwgWJ9MpmSqOtUOiXC97at2xY40en0Zi/qSCpfEfFLJfnuUFy70/DzZlECP0cK9fw8Xn31VRHemchw8OBBKWxgfD4/o8XfCW4jrgcjl/sHRxENTMJhMcHX1oLRsVEcfuuwfJ6LtwGv8z34WHUbssih2ut+vrg/MDAg35m02YuCfxMuAPgXD/wi9s1eAqw5bC1lpF0BHfoUNjVaLYwaDXp6emGxmDE6MoJkKgmb1Ybejb0LeoSzkIbCvc2or1s3sjrmXF9s7unCZCCKscmp2tx4+KGHZJ956tQpPP/c81JsZS4HUMhnAIMZ+lIBBZ0BEZ0XPlzf13s+RoMWmUJRRHwl4K+f+cnUhXSuiEKxBLO1kvxSfOvN2uPa/XchkMhhLp1Hh29t9Ac/PxnDN09NSqrAUmkUH9zVgru6PHW771cs33FnumtjrXWePhGH7dJZJLfuVptYsSTel34AbbFybJfcuBWZzl61pZYZdV5IoahP9qyS37XvFiXgr0NefPFFPPzwwys9DIVCMQ9NPofoD76Dxr37kG1b25VjindJqUirpNp8K8DFCxfRt6VPbXvFmiOSysFnNaLJZb6pa439V6PJPOwmvTixVzo+fT5nzpy5pd+1FF3pbN65c2ctRr8q7h44cACHfD6USmVJJKAQMJfOwWYsi3B76J5DIqzTYU1RtdrXnL2dKYBTGPd6feK+XhxzfiPoxKcAHQyFRLzXG/QyLoq0LBaYnprGIy4vvp5yolA135VKuPCFv8HlPT0YGx+XVAC+jr3T7XZGVqfElV0ql0TY53IomLHQIBqJ4OSJk9BqtGhuaRZxTdYpm0VgNiBis8ftkVh/RvrTyb9z187rxs3e8F6tRoSFfKEkLkH2HL7TMe4s1mAxBp33FO8Z080+8sFgUD4TRtBzezKZgeu4WLwPJSufM9dDXy6gmM3A19aKTDYjny9TFSi+8/Laa69V2jDYrLLN2tvbpVCDnzVd8fMF/vnifjqdktdM+edFgms0OOFshPP81/DFL45g9+7d8Pq8SGfSyOcLsi4s7GB7g0g4ArvDjnwuj1KphHg8LosolsrIFspwmfWwmer3d4E65lxftDY1oKujHePTQej0OSkG4lxhK5HOjk7Z53KfZdQA95//NvbHZtGUCuMzT/wGwno/tjakZX7dLKaf7S4Ype5C/fwPWq2slvnJQkNerKZrxUqFtw7XHk/t3C/7coNOCxNbOaxiwskcvnVqEv1TlX39Yra2OPDRvW3yO0yxTo47NRrE9t0D/3PflpuuY68rAV+xNKUivC98t3Yz9NiH1Ja63fNToVDUDS+ukt+17xYl4K9DeGJJoVDUD56Xf4C2v/pj6NIpBMIfweSnf36lh6SoQzb8n/8BQyggB2Nze+8B9Opf+J2CIp1CsdbIF0tIZYtod1slQv9mVE+O86QxxdrV+LuWIi4FboqtNxJ3GQPtt5tkXfUaDaLpnGwnl/uaq35jb6/0k6dDe24uhnw+L251xupTSJ8fc34z6Na+fPky4vGYRKhTgM/lcgiGgiJ0UYhnbHqXaxMGTJthz6Xwb4/+FfbPXsKXog9jJJJDIhwS57/BYJDX6nV6FAp5EXxZAMBl0aFOhz2LC+gMp8v7HtNBiZlnukBbW5uMh1H0TCZg9D4fq7YQWApuHyY2xNJ5BBNZ5AtlOCxF+W7otHfGEcikBY6RLRQuXLggDnsWaFAA5/pye3A70p1P8b0KP8/IVfE+lsnLmOm8rzrn+ZmysIMOeH5HRkZHpLiBhQ9uj0faKew/sF+KOhYnLfA2Y/er4j6LMRLmJpzOtC54Xm7gDYTHBnEyOImRkRH4/X4pRuDnqNNpJVFhbnJOCkNYiMG/XE9+noQCpsWghdWkW5H0g1tFHXOuL2LRCGYmJ1AsFlDMF2Ew5KVIibD4xOvxoqW1BbFoFJ8YPQZHseIu7p2bwDiLWlxZ5PI5afsxvyimCnufS/FKvijzmPshxdqen4Wrv1MyhRL85sr/1nImg+KJ47XnTPftlmLEevtt8k7IFop45VIQL10KIF+8Pi7fadbjQ7tbsLPNpVz36/C4c27/vdcE/KOvY/JTPyvCvkIxH8fpYzAFZ+R6we5A9O4H1Qa6A/NToVDUB3Or4Hfte0Gd/VcoFIoVJu9rFPGeuI69hsmf+Dl1UKZYgC4Rg/uNF6HN5+A4dwKXPvc/ke7doraSQqF411DEpCDf4DCJMHKz3rN04HttRrlQ5F6NiIPaahVRt+rAXyzuVuF2Meq00OkqTnO64jxcd42mJtLSCUj3fiQSkesU76tR6rcCxdgrQ3RpZ0TEZ796xqVbzBYRoinq828PZpGBBw9cOSniPfmJyy9icOtTeCYSRDJY6WXP9WBhAuPW6bqPJ+IoFUsi5nM5HKOxYJRCAQrM1f7ucnG7paBgKUf5jZBtYTVKtHEknUO2WBHVKKLciXhrCvZPPPGEXOfYWXzQ19cnBQ0UvFmcwc+XxRUU+6vfZUbms/CAfbR9tkr8//xYfCYs0CXM78jk1CSGh4alNQGX0dLSIp83kw3oFF5qG81vkdDd3YMv/9VxPDp6DC+170FRq0MpFoBhph9tGzZI8QgTBBLxhPQKZ7EFizou9F+QFIXm5hZ0d3dhcmJSPlM68pkekMoW4LWZ7njqgUJxM9jKZHZqHFazBUanHeNDA1Jcw/1Sc1OzpFuwtQS5OOfGgUhArt893Y9B9/vQPxXD0OVvyv6I8+3BBx4U9/7iBJBssSRFLErAX/skc0Wk8gWY9JpacVjx1Akgd7XwrqMLAYsHmWQS7d7Vtz9kQcrR4TCeOT8r/58Ww1W+d6Mf79vaKN99xfoksXU3ClY79KkEjKFZWIYHkO7etNLDUtQZvqtFHiT8wBMo32JBsUKhUCjqn9X3K1fxnlnqRKVCoVg5En07UbDZoU8mYAwHYRm6hHSPimVSXMPz6rMi3pNU50b1/bjDMKJaoVhLSCR+Ko8unw0t7hu77+l0ZK9tv80M31Vn+mr9XUtBiOIr3dVLibuLsRh1aNKZoddqpdghnKiI+BQRKNDed/994mBfLHwTOkjfTgynGJtOpeU5bW3tGBsdlfEVHEV5DfvQa7QaTE1NwmcI41sdB7ErOIg9wQF5/b++/Dymtj2GkyefRjkdk6h1t8uN1rZWKQKw2+wSJT88PAwDDBIxLzH/mYwUD3DcpCbiv41gfyO4nQx6DWLpAmbjGcwEwwhPT0BfysFqMcv2Xdx/frlgUoDX6xXhkGI4vwssTqAYX73N93e5PQjEsxK/XUmT0EiCQLVtxHznPCPzuX3oGObnMzU9JVHg/L54PF5x9/M5i1slsCXC4u/C85fD2HXhCH7l5Ffwjy49i8/v+CGcmhuD122Rx9mGgcun+75UKsp7TExMSjGHVqeF1WqTZVotVrnt8XqQyZek6IDbvd77gKtjzvUF51w+k4LN48Lg+CTi0ajsa40GFn5p0dPTI+1C2C4iumkT8NZVAX/mPL685X0YzpjgCwSkuCoYqKRNUMyfv29i/+9Urih90euplctqpN7npxQr5Qryec+PjNdu3ATTv/q3KB5+E3PNHfJbxmkx3LQNUD2uG/vcf//sDAKJhS1eqnT6rPjo3la0uCx3fHyKOjvu1OslRt/76rNy03n8DSXgKxZSKqJktqCs00FTLCL06AfVFrpT81OhUNQFpjr/XfteUXuedciTTz650kNQKBSLD8r2HoL31WfkpuvIa0qgVVyjXIbv+e/UboYe+6BKaLjDUNhRKNYSdCCbDVp47cYbiiCFUglzmQLcFiPcNkPdioW3+ruWIvK+ffvENT9f3L2ZuMyCBSYUUBegc1uc+FZDLbZ8sfBNEZfx+nRyM7KesewUk6tu9/kib3QuKqKsw+4Q531jU5Ps2xv8fhkb49ynJqfkPkZS26JJ/O6ej+O/v/5naEmFYS1k8R9HD+Pn++5DPtCPvds3ixBMYYBR7OyrXiwU4XQ6RRCjQz0QmEUsZqo8R29YMLb3AoscmM4wORPC8bPnEZ6ZQimbgtvOWPowDuzfL9s5FAotENuXQ9zn62+2DPZOno5lEE8XkM4XROhZ6rtc/Szptp+YmJAe9Izh53ZijD0F/UgkLPdRVJzfKmGpz/3K6Dj+6hzwv/q/L8/ZkAhgR3QQY0UWBqTkucFgUFowMB0hHA6L89/pcCBvMUs7hHKpJOK9y+2Wdgp+n18ELbvZAPsqcN+rY871Bee0w2rB5SuXEYimUc7mpMCGRS8U7plcwVYUbGUy0tqKkkYLbbmELZExuDNxpB1tMEes0kaC849tPbi/XCzgz6ULyOZK4l6+Uy071iL1Pj+ZskDxnv9/56cEaX1+GD/+Iyh+9BMYGgohOh3HBq8VqwH+7x0MJPHM+RmMhCrpe4uxGXV4amcz9nV6VlVRguL2HndG7n0UJZMZc3fdL+YPhWIBWh1Gf+HfYTL603CcPYFcc6U9lmL5UeeFFIr65Mk6/137Xqn/I3/FssMouy1bVPSyQlFPzN113zUB/+hrmP7kTymRViHY+k/BPFXpIVo0WxE99IjaMneY6akpNLe0qO2uWDOEk3k0OUxocd3YfR/PFGA16kTwrGen4zv5Xft2Yu9SUCBqsFdEfK02j5CI+MYl2w5QbKIwSyGrtaVVRHhGos/Ozop7WqLeC0Vxo9JtT2cqn8u+0KlUGn19m6Vv+ujoGKLRORRLRXGFFwpFFAoplIMn8P/c9RP4b6/+ESzFHFqTIfwHywT+94774G00oJBOSA/33t4O9Pb2YnpqGsMjwyIaMOLfbDLL+5VKJVy4eAHhSFjEY6YJLAehmUnEA5PQG81wNjQjFQvj3JUJmB1ubN9UxokTJyQBgQIe3ebcBiyquB0OfTp02eM+mSliLpOTz5EpEm8n+JnMZvj8Pmzo6EAwGJAWBPzcmGTAAgSK6GxTwM/pZp/7N89H8P4LZ+DNxuU5QbMT/Zs2wXrhDUSzWVy5cgWFfEE+G4qaM9MzEjVOZ35Tc5Msi58laWpqlPYMza1tKJUBi0Enc7PeUcec64tqysnZgWEEZqbhdbuhgUaKYPov9Et8fmNj5busdbkQaGlH0+SovPaumX4803EAJl8rYpODst9j0dHipAtpBaLTIFOsuPBVG4m1Oz8ZKc92ITfa1wUTWSnmYKFdvRYYzk89ujAVxwsXZzEWXrp/MpNh7t/kx0ObG+p+fRR3/rgzsXO/XBSKm1Fw+xC5/3G1kW4j6ryQQlGfXKjz37XvFSXgr0MYZbeWv9QKxWokvmMf8gYjDPkczNPjME2OItvWudLDUtQB/nn9zCL3PybxaIo7y/T0jBLwFWsGOtooGrqtBvjtS0eNURihu9Fr1YtYvd5/12qvivh0w/ESSeXhtuiv60lLsYkObIq4BqMBRqNJ+tzb7XYRo8KhMBoaG7Bz5y6JYGREu07PCHoDmpocImy1t7fj8FuHkUmnYbUxtt2DdDot7lVTPoix2Cj+674fxb8/8iV5z33BAfyQqxkDW+6DIzkp7vC9e/bW4v3zhTxOnTolQjRd/4Ru73KpLA58jiGXz4kwfaO4/1uF65/LZNDT0wqNXg+d1osrIyOYnssgc34QA0NjcFjN6NuwQVIBKOZz/ZZLwK9ELhevCj9FJHMFZJlCYDZI5PytQGc9XcPsR2+xWKQ1AS8U21kEwc+E4vr4+Hgt3nvx5663eRFMlfAjl1+oLfeZA0/Cijj8fp84jPkZ0JXMZTc1NslnQwd+Lp9HV1eXvJfbHZfvw7at26Rg4PLQGMqlPGJOM0x9vbetNcFyoY451xfVlJORiSlJb5mLp2A2m6VVBFt4cF9DAb+xqRHt7RswOzRQE/Dvnu7HM5134+xsHoapKXHte9weaSexGJNBi2y+JA5tJeCvzfmZK5SQzhaRK5bkt8pSzMaykoxzo8frAf6OOjMxhxcvBCQJZilYUra/y4P3bWta0CpAsX5Rx50KRf2i5qdCUZ9crOPftcuBEvAVCoWiDigbTZjo6kPX5TM1F/6sEvDXPfpoCK5jr9e2Q+jRD637baJQKN4b7OdOUb7JaV7SjUwRlO57Ou9d1krPd0XF+emzVfqmc4tEUjm4gAVOOYq/jE+nA5tu04GBARGtGhoaYbVaMDk5KT3OKeaz773FahGBtrd3Y61vOgVhxrXL8kwmKQI4c+a0RKlT7N9jTuOCcQP+uu99+NTFSnLPRwZfxR95mqHZ14d9PQ0i3s+PhJ+dma053wOzARGN3S43sumsFBgwyp+O/fGJcTgdTnGhzx/PrbJ4/bPxsLRgKGsMmIllMBvPwd3UilRZD4fHj9DAJYnTv1VuFMFPkYTR8iLc54oSm18olkTcc1oqhRe3CteZhQ0sohgZGYXFYsa2bdsk7p4ivt1mRzyRkGQFuoS5fRav9zcH0vjUhWdhLuZlmcPOZgw3+xAdPC4ifXdXd0XYtERht9uwZesWcfWfOHlSbvO7xmVTuK9GdZ46cwaXx6ahzyURc5qQS87dtvQCheLdwu/jRz70AcxEUzh69iIKxSK6OrukrQfbT/D/C8X7XC6LKw2NqAZB7wtcgqFYQMa1AZnzz0pRUyAYwOTUpLSoWBijr0M8k5VCMy6P80WxtuA+PJUvStrI/M+3FAxA4/OLsB9JZaVIq8Vdf4XN/D90bCSCNwdDktpzI7Y0OyQun7/HFAqF4t2gKeRR1qviH4VCoVjLKAFfoVAo6oTRjdsXCvgf+fGVHpJihfG+9ANoikW5nti8HZkNXSs9JIVCsYqhqMkT44zOv1F8fjxbgJG92U36VdFn+05CIYG93nUi4tOJnxMxv+rEr4q/jFNnRHo6nRLH9saNGzExMY58voDZ2UkRoPk8h92B9rZ2HDiwMBZ1/nLovKdzv629TZz7FL42J/J4ueUpdM9N4t7pc/Kaf3r86/iTtl9GepsfwyOjKAwOirAcT1SKATgOEY3DkQUFAjqtTsYzMjwiYj+j/unGpyDNMVBAvlURf/H6cxmd7W3YsakTg8OjMJjNGJ2JwOf1IDkXRtFgR6ZsQDyTlxhkvVYDve761gRV8f748eNSiJBIpmC02DA2G8aWbTthd7gkUptxy+UyRLg3Ww0ecmsuAAEAAElEQVTvStjjunKduQ6pZAodnZ0Spc/ii0QiKYIiGR8fQxllcd/TJex0OqVlwRvnR5BMNuCJkbdqy/xq3yGkpgZFvKezeGp6Cn6/Xz4Lbi8KmyyguMd0UIR7vuf8Aoozp89geHwKdrMJ3V3NyMwFlz29QKFYLhr8fvR0bcCViRm0NPTAabVg957dOHPmDGw2GwKzs9LGYyidQcBsRUMmBWshix2hKzjh74SntQONTpukWly8eAlb+rYs2AexqIz7imyhhEy+dMvpGorVQalUFmE+nS/AOy8BqMx9/D/+UfY5QXbPASQ/+GnYTPVVZDgeSePNKyGcGosiXyzfVLh/ZEsDOn22Ozo+xdpAm07BcfoIkpu2o+D1r/RwFCsIUzs3/j+/isj970Po0Q8g29qhPg+FQqFYg6izcuuQhx56aKWHoFAolsDy/g+h9PTfQ1sswDo8AENgGvmGZrWt1iulInwvfK92M/SYct+vFOxLrVCsBRj97jAb0OAwXRf/TvLFEtK5IhrtZrjrPDp/JX/XuuZF9lLEL0fnMDs1IWIuRWOK8nSxM/a8ItBmRTQPBGYlGj8ej4kj/+1EZIq5+XzFxd3T04NoJIJ0Jo3ZmRk8tsOPv3z4M2j9zu+jKz6DKZsPJ5MGhPtn0KYJw12Kw2o1i2BMp//ejn0i2GcyGUkFYKR+Ip4QYZ/Cs0arkVj4np5e+P0NEiFPEbvqMr8V5o+b22K+CN0LIJ2IYXxiApOjw9CZzLDYnBiejSLwwhswm43o6tiABp8XBq2mJspQAqEof7J/AOeujMNossDf2YbZYBjnhyaR0dmxecsWKTphwclS3+t3CsdL9zvhNpucnEAoGJJ2BFy3kdERib8nLIBgoYJOp0Mmk0W/rgu/cu7voJORAycaN2POb4F+LippClOTU7LdI5GoLJsOYt5mEcWmTZtqjnu2Pxi4WoQxGwwikc6iq71ZUjEcxgaJCXwn6QUrgTrmXL+0NjVgY3cn9EYT2hu8kk7B5IlqgcroyAh0ej0G3B40TKdqMfqcL/rGTTCWgojF4zIPgqHgdctn8kk2X5QYfSXgr635WRHvi9BrtQsKukqXLqI8NwdgDtrDryPy5E/BbV951yl/N50amxPhngL+jeB/tF3tLjzU14DWOkwNUKyO487Gr/81mr75ZWjzeUz8+M8g+NTH7+jYFPWF7/nvQp9MoOEHX4MxMI3hX/3cSg9pzaPOCykU9clDdfq7drlQAr5CoVDUCUWLDYnte+A8fVRuMzo9+KQ6KFuvOE4dgTE0K9cLDhfm7rp/pYekUChWMaVyWfrFdnitN3Tfx9J56RfusOhh1C/thFZcE/HpwGZ/5yOnz2FudhKFbEbEXPay39jbC7/Ph5dfeVl60Pf3XxBHt9PlFLc2xX0K6xT6l6IagU8ottPRzr98P7r/WyNj+OSh+/F7c/8UP3z2B/ijXR9DymDG9EwJh3xmNLb4YcyFcfnygBQOzM7OSjEBhWany4VSqYhMNiMiMEV9usLpEGeUO9MC2N89na6IEYvF+Jsxf9w3E/fpWo8y3n96Eql0FkazCTPBOWzq64PP44JOqxXlXgR8AFPRDGYT/P62IF3Sw+7yIhodhgGFW44fHh4aFhd/iskIFqtE0Hd1d71tmgDFe24jtjDgtmQLhFw2J4kGLKwYHRvF66+/jqmyGx0GDe6auSDLKEKDlw88BG18BIlkQj6DZCopjnsWTFgsjWhoaJCEBhYM8D3J2bNn5X3pQOb3KZ7OQYsSEpEwGix+BAIBWK1WKQBQKOqRvt5ujM9GMDA2XUvjqBaoVPcPJ0+dRL/TjUPTE4gZrMjpKqemYpYW2GaGkEjEYTDoJaliMSaDFuFkTsXor0GS2aK0RLEZF56qLBx+o3Z9bttepItAu3nlTmcGE1kcvhLG0eGIFBzcCCb27Ot046HNDfA71D5b8d4ouH0i3hPX0VeVgL+O0WQz8LxSaaVFlNlDoVAo1i5KwF+HvPTSS/jIRz6y0sNQKBSLYExk68EHJTJ97sB9mDtwr9pG65i8vxnh+x+H+/BLCD/4BMqG1eGGXatzc8/ePSs9DIXiPZHIVKLxPTbjku56xo/TPW4360XEXy2s5O9abse5wCRis5Mo6c3Y0NKCWDQs4iu3Jd3VxUJRhHG68C1Wq0SlU8TmfYTC+M2gqHvi5AnpXV8ql+Bxe2A0GSVOuFUXx+OP7cN/M3mv+r2BEjQ4MWeBy5pDORzBhYsXEAmHZTwsIMjlc2hoaJQoa4rSLAqg855iPcfL96DAzB7vxWJJllkVkt9ppP7NxH3Gwo9PjMNhMaGrrUUcuonQJNJhFxwtfulrT8SIr+G2Nsn2zsXDcPl8GJ0YQywSwMjQIGxm09sWF1C8/973v4fBgUER0VmoMDM7g6eefGpJEX9+wQG3D5/LwgkmFoyOjlVEeI1GiiCmp6dx+cowEvs+jV9/8wu1ZbzcuRd5SxGRoRnZ9g67HbHYnEREl0tl2G12KfbYvHkzdu7aWdsu/P5QnG9taUUwFEImloXdqEE5nxbnPcX7jo4OdHd3o55Rx5zrl+bGBuzbvQtas0OKbBbPURbwlIolnCkBn9t0L45s+yhKmkrRWMHViqnTAdgsJmg1WhiM1/8/ojtby/mXL0qUPh35itU/P/l5MgWoVKqkLMynePjN2vWZvj1wmPXyHbiT8P/Shem49La/PJu46XPdVgMOdntxoMsjyUcKxXIcd87tuwftf66FplyC7fJ56KNhFNxetXHXITxHpE9V9kPZxhbEd+xb6SGtC9R5IYWiPnmpDn/XLidKwFcoFIo6IvLg++WiULDf/djP/CtM/vjPXPUfKhQKxbuHbkX2b1/Kfc+T0olcUfrNui1GaOuop2y9YyzngVwKbS0tyEEPp9uLseEhEacJe8pTCGYUfj5fENFcr9cjlUpLD/Oq6/pGUPDicygiNzY2inPc7fFIH2ltuYD3bW+W2N7vn5upvSZVAE4OzqEcnkQkWYYmn0dTYyMsFgtmZmaQTCZgsZhFsGcsvNFgRC6fF1f+8PCwjFGr1UpSAJMEoNFID3iOgaL1ffff9563G134LAygSE2Bzuf1VVIG8vkl0x96ujqQSsRE3D577qy44kk4HMb5/vNvW1xA5z3Fe3HN9/ZgcmJSbvP+G7nwqwUHjPCmez4anUMsFpP5wW1HJzyXcfHCRWQ67oXO5MSbLdvRlgzI65/e0IPNZmCaBXiaNIpskWS1SvGE3W4XEd7n9y1IYVi8Xfh9mo7E0dPZjs0bmiQxgeI+xXufz/eePweF4nbR0ugDjDZAU76hgFnQ6TBaSEjhUQ2rF82b98CWj0ihDYuMlqISo19p+6IE/LVBIlsQ9/3itgjlZBLFM6dqt0e6d8BpuXOiOL9jR4bDeH0whGhq6e9jlc1NdtzT48OWFscdLzBQrH2KTjeSW3bA3n8amnIZzuNvIPzoB1d6WIoVwPfcd2rXQ/wOMLlKoVAoFGsSJeArFAqFQlHHFB3OlR6CQqFY5dDVxj6tHqsBDUtEuMYyeVgMOnHfq37C7wyKqT6HGdlYGCanFxOBCAxXBdmqEEv3dXNTM6ZnpuH1eGGz2ySivm9z3y252f0+P1qaWxBPVJw2dGXrdFrpI012OYDhRisuzFZ6ST8+egQ/f+pr+O1dP4SYpwU2uwNOu0bSAJKJpIj2HDfFMfZfn0vNiTBM932pVMLExAS8Xi+MRqMUIlDApmA9NxeTooPt27e/axd+bbsZjeLqp/Oe4j3/8vaNEgnmO+Ip2KdSKTQ3N6NjQ4e8tpp6wKKDpSL/GZtP5z3Fe4r4rW2tOHPmjNw/n2gkKn23q8tgqwNGePMzjEYi8Pq8sm1YOMBCh/P9/YiWzchtOABotPirre/H97ruweaRI8jl52DUedDY0IByqSQx+hwj4bbn9uWy5q/z4u0yFYrAaTFiQ3MDDhw48J62uUJxJ6Gozqh7/n9xLHqMSSC8cL7qU0kE0yHkrf7a42lXFzYUNTJnuf9hMsX8+cx5OjQyinAii2aXGQe2b1QFLaucQrGEdLaITKEEv3nh/4Hi8aNAsRJTn+zoQcLmRMsikf92xeS/NhDCseEIclcTaZbCatThQKcHB3u88NlVTL7i9jJ34H4R8In7yKtKwF+HWIYvw3blolwv6Q0IP/C+lR6SQqFQKG4jSsBfh/T19a30EBQKxRI0Nzep7aJQ1CFqbirWgvue8ePsFc7o4fnkCiUUimV4rHq476Cjba38rqUTOhKJYHR0FFMjg9AarXA2tMJp1GBqakKEWDrm6aY2m8zSR72trU2i0ymE3woUkRnVTsGegpZBbxCRl8TjcSkYOOhtRiCuw31nX8LPnfm6PPavz34Xv7bjg4iUyphOxGErp+T9XW6XFBBQxKdATyGN0fAkkUigUCiIS9xms+Pypctwud1wuZziPj916pQ8Vu3Z/m6F/Pk95umopyDP4gC+B8W5pZZbdcRXXeoU76vufS4jmUxWWgMsEfnP5AKK5nTeU7znX97m/VX4vvP7z7OYgdudf1n0wCIHRufz8+PnzuVrdTqc8+0Q8b5KyGDCoLmMgy1e2cZ8PgsgwhfDKOQLcp2FA1xXCpjzUxjmb5fLg1cAoxV9nW3YuqkHq42VnpuKlcWk18Jk0KGYyknKi25esguLYhih73Q4YDabMBS4BHReE/CT1iYEho/BaXcgGAwuSNkg1XkaSuQxazOgmJrDwbv2KxF/Fc/PZK6IVL4Ak16z4LtCCvPi8wN9e+CyGGrFULeD4WASL10K4MJU/KYZaBu8FnHb72p3waBT7lfFnTnuZJvFti/9oVy395+CLhFD0a4K/tcTvue+Xbs+d/cDksyguDOo80IKRX3SV2e/a5cbJeCvQ7Zs2bLSQ1AoFEvQ3NKy8I5yGZaRQWSbWlGad4JZsbYxzkyg4HSjZLGt9FAUN5qbCsUqgsJJPJNHb4NdnIqL4WPS995igH4VnoBe6d+1jDHft2+fiM90ZGdhhLOhRcQItj+ZmprEXHQOjQ2NaGlpEYGWjvp3In5TpKf439HZCZvNiiuDV0T8ZY/6np4eKRKYCwyjM6fBm63b8MnLz8OXicGZT+E/XH4Rv9Z1P2bicRjTadg0Zeh0Oul5T0GsXIb0Y2cyAMVpnVYncfqM+SdMDaDYzOemUylZHwrZdKS/XWz9zag66inCUHingM/lsqCAAvfNlruUe5+v54WOdqYeVF35dOxzOfyM2Meekfd03lO8793YK/dXofN+fv/5EydPStEEWxdwOaMjo5gYrzzOz4/b7GTMgmx2Yf9Z6+w5dLj0cDmdUgDA7ygLJPj9aG9vF9Gey2ASgNPhXLCe85MGQokMbGYj9m7pgd9/TdxcLaz03FSsLJzbIuLrdcgWirAar516YmsRi9Ui+56hoSFYUsAhrRl3z/TjpbY9ONy0BTmdDW3tbdi5cxdyuWxtPpPqPN3Y0IJwJIIro+No9HuVgL9K56cUNeUYn18UcX4xhcNv1K6P9e6C8zb1lJ+JZfC9M9PS5/5G6LUa7Olwi3Df7rHclnEo1jdvd9yZ9zYg2bsFtsEL0BSLcJ48jMj9yoG9XtCmknC//kLtdvCxD63oeNYb6ryQQlGfbKmj37W3AyXgr0O+//3v48knn1zpYSgUikXQTVJ1lvif/gb83/sqTMEZjPzsv0H0vkfV9lonbPiz/wHL0CVE730UMx/9cTlIV9TP3FQoVhvs12o3GeC3mxYIKCSbL4q7zG7Sw77osdVCPfyupYhf7UcuvdETWUk90Gq2iODEvu6LI93fCXScsyf93j17xHFOjh49CqvVIreNRhOGLp1DMJJB2rYB//mun8DvvfYnMJYK6EgE8BtTp/Ef23fDnHWgEJ2UtADGt9OFT/drPp9DOpNGQ0MDpqenoSsVxR0biYTFfc4L4XN4neL9bGBW7qsK5Iuj5291XWdmZqSXvMViRWdn1wKh7kavn+9Sv3Llioj5LKBgEgJj/lkwAY0GqVRSxkPY5/6pJ5+SnvcsSKDznuI9779R/3lu3+hcVB7jX362LJwYGRkR8d7T2oVzKQ9+9dTf4iubHsG4oxGa2DTMkSswmuwYGh6Cw+6A0WDEtm3bRaxkwQWXzb7eHLvparuF+XC97S4nQomcpGa0uFanSFQPc1OxsliuxuhnchTwr93PIqae7h4MDAyIEP9UaAw/cuz/ymMlaHC4ZTsKvm64nDYEZmevm8/VearR65F3eRCaiEgBkGJ1zs90vijiPU31Rv3CQsISi7rGx+R60WhCsHsLepY5Pn8unccz52ckKv9GjnuHWY97e324u9sLm2l1/l5SrJ3jzrkD94mAT1xHXlMC/jrC89qz0OUq/+/SG7qR2rRtpYe0rlDnhRSK+uT7dfS79nagfnmuQ9TBrUJRnzBWtYo2kxLxnrjfelkJ+OsE08Qo7BcqPe28L30f0x/91EoPSbFobioUqwkKjpFUDm0uioBLue8LcFgMcJgN0C6KrF0t1NvvWrpO/TaTONtLXjfcbhc81vcW97vYcZ5MpsRBnkqlRQg+e+YMJicnUcjlYS5pMeC04r/t+1H826N/La/fGxrEz1vd+IdtBxHVAOlQEGYtZFkUohlPTWGe4jS/M3SGMzbfaDBInD7Hzsf0eoNEXjtdTnnfqekpEdTmR8+zN3w1Dr9vc5+0CVhKiB8eGsbLr7wsgvrs7KyIeSwmaG/fIAJ8Vahbivku9WrBAN+bsfj9/edhMBikaMJusyObyVx7nduNpqYmcfkzEn9iYkLuqxYg0G3PxIG5WAwbN25EOBRGNBqV5XL78/3MFgv0dBTncziSbcHHL7+IJ0aP4JGx4/jS1ifwrVIWlkIMiUTlu0nXfTwRF9f94tQA3ubYlyKVrTiWbUb9dXHSq4V6m5uKO4/ZoINZp8NcMS/7lup+sFqEw0Ig7m/G2zqAgfPy2IHZC9CWSwhpvXju+e/KvGMbEc4bzufFc4kOfIPJAq1h6bmkqP/5mcgWkM4WYDVcL8zPj88Pb9oBh2P5Uuky+SJeuhjAqwNB5ItLS/dtbjPu3+THznbXdS2IFIqVOu6kgN/6t/9HrjvOHIOWBZbm1Vnsp3gHlMvwz4vPDz36QSlwU9w51HkhhaI+ydbR79rbgRLwFQqFog6JHnwQLV/5glx3nD4qUVklq4pUX+v4nv9O7frcvkMoeFdfZK5CoagfktkidBoN3DYjvLaF4kaabjctRCC0LbObbb3DYgifzYhSuYxQPItoOg/PfPvpO2Sx49xht0v8O2P1eZsCeKFQRG9vDwplDc7PXMaLvp1o3fJ+fPrCD2QZT44dw6TNgx+4mmBp6YFFk4JOr4PFYkF7WztK5RI8Hq8si6Lyxt5eEfUpng0MDor4Rqc/I/zF7R6NSLQ8n1uNnqfYT7iMkZFRccTPj8OvuvSDoSDefPNNEcbjiYRE+rMYgGQyWTQ1VZZ7M7i8+YUBLDAgfL/5f6vwvd948w0cO3oMs4GA3NfY0IBYPIatW7ai/0I/zvf3y/iYSDA4OCDry5YCyVRSXPtMKOjq6pQCgaSzC6VIEj966XlZlqFcRCkbhTYeQNlUlm1HZzFPJrC4gu0TeH14eBjFYhEtzS3YtGmTfLZLtb1I50tosJukvYVCsVph8Qkd+AadBrlCCaarAm21CIf7CqIpA/HxYTgyKbhyKfSFR3He3oDJ6SDisTi8Pq8ULS21P4TRAn9rK1pYBKBYdeSLJWRyJWSKJTit10fja2xWaDf3oXTpIiY27oLTsjz7xEszcXzl6LgUMi5Fl8+KJ7Y3odtve08FeArF7SDX3Cbua8vYELT5HBynjmDu4INqY691yiUEnvw4fM99G6apcURUSqdCoVCsC5btjAAPvngSR1H/VHvHKRSK+oIn0avkmtqQ6toI6/AAtIU8XMffQOT+x1d0fIrbizaTgffVZxZWVCvqbm4qFKuJcCoHj80g7vv5J6ApbtLxxl6zPBm+mk9O1+vvWr1OC5/NhFKpjFAyh1g6D+cSvX1vxnzBm3+L7CNts4rg3tbWhng8Lg50Pp5IJioOcbMZsdQ4soGz+Pvu+9GWCOCx8eOyvM9ceA5Tuz6Mw64W5ApxTEdDsMcTIqY1+Bug0VZiqim8X7p0Cc0tzdAb9PB43Ein0zAZTRL5zsdZPEBRmmIaBX5GWtMFxMco8BuNSYn9n9+3uurSHxwcxKWLl1AoFrBly1Y5jmRc/5WhK3A4HWhrbVtS2L4ZHJfP78OGjg5xKFUjt6sR9dx+58+fFze81+uRbceIewr4Fy9elD7cCdrmGdlcLEmSgNfrlQQBCvHBUEiKJOjs15lt6Nf14HOnviBtCsglZwte0AFmZJDPaWG1WuXYmC0CTp06JcUKHBNbBNhsNimeaG9vXzKdgL2gLQYtrCYdDLrV6/is17mpuLNQtDcztWKegE/43X/00Udlnly+fBmX3B7sn07JY3fPnEe/7wMwbdgCY2ICep0eWp1W5vPiBA6tzgBXYzMsDvV9W43zM5ktIJWvuO+1S/wWMbz/A4jd9xhOnRnCTKqIDfr3VnBYKJXw9NkZvHw5uOTjDQ4TntzRjG0tjlX920ix9o87o4ceQa6hWYwf8V0Hbvu4FHWAVofww08h/NCTMIQCKFmUwedOo84LKRT1iatOftfWvYDPkywf/ehH8TM/8zNyIKaoXx5++OGVHoJCoViCvi19C27zYIwCPnEdflkJ+Gsc9+GXoEsl5Xq2qRWJ7XtXekiKG8xNhWI1QLcjXfYdHqv00Z4P79drNdLHlTHdq5nl/F0bCoVEyKVTmqJtd3d3rbf9u4G9fH12E0plIJzMilBxq71zq7H0FLYoNLPvvMVqkah5FmAw+r3av52x0pFwBFcGr0Cj1aJcKqHL14R0bhT/e+cH0ZSOYEdoCFqU8S/OfQ//fu/HMOVwoJw2oZgJS/omhW3GveevRrfOzM5gLjaH1tZWEcvoOmd/+aoATfH+wQceFDGtGvHPSHoK/XycJ7i8Xp8I+xTZqi59blcKdpcuXZb3oZO2s7NDHPTc1ps2bqo59t8JHAMFdy6fsdqjY6MS5U8nPR9jkQO3IbcdP18+xoh8Cuxnz56Tbej3+6UIQGvRIjAbkDqAA3fdJScE6NAfHx+X+9PeA7hv4hz2BirrUIQGf9zQBWM2ArPDIbH7bHPA92DbgfHxMfluseiiq6tLIsD1er0UESyGqQ3sBc02DOy5vJpRx5wKYjZoYdLrpJ3LYuY78S+LgD8h9x+c7sdfbvsA8p5emPJBEVK5X6kmc8xP4OCcno1nkckVxc29mote1tv8LF/d37FoyXuTlJpAPIuQwQ6r770J6lzO37w1holo+rrHuL99fGsTDnR5Vm3bEsX6Ou6c/fCP3vaxKOoUjQZ5vzJQrgTqvJBCUZ88XAe/a28ny3ZWYPPmzfjKV76Cv//7v0dvb68I+Z/5zGfe00kvxe3h5MmT2LNnj9q8CkWdMTY6hg0d1xxnc3c/iNa//fNabzNdMo6izbGCI1TcThiFViX0yAeYwaw2eJ3OTYViNUCxxG01oMlpWiBoUCCMZwviDqcDf7WzXL9rKbCyH/voaEX4pYOabvJ9+/a9p+MZ9oD22Y0VJ34qK4UT812oN4KCN8X7gYEBEdIZu053PSPnq672qoBFYdjj9WBkdETGzEh6dy4Pa4sZjuQwfufAj+P3X/ljtKRCMJSKaCrpEG/cAJehBaW5GeSCIyilUhJjr9VoxYHudrmRy+fF+Xrw7oPiROeYqj3nWbxdff9qpDUFbor8dKl3dHRIr/hcNie95RlBz227Z89eWC1MEWjD8Mgw5qJRBIMBcc2zPz239zsV7+ePgdvm7LmzCAVDUpDA+xhbz0j7XC4nhREU8NkygAkAyURSIvIpEFLALxZLIvRz3Q0GvRQsbNq8WV5j0BsQsW3AnKEB/+zsX9Te+1utOzBVSMJcyKKkNcrnVCjkxdHPwgS2FmAxAP9OTU3BarVJD01uy8WwuIZip8Wkk7+rGXXMqSD8HjNGnxSKJUknmQ/ne0dnJ464PMhrNDCUy+iOTaEhFcGMewNCF34AR6ejlvixGM5d7mezxRLS+aIS8FfR/EyKeF9p9bP4e1GF3xlJscnk0dNge9eFAsdGovjmyUnkiqUFj1Gqf6ivAY9uaZSiO4VipVHHnQpF/aLmp0JRn5ysg9+1t5Nl+4V65swZvPrqq/iJn/gJcV/8q3/1ryQW8FOf+hRefvnl5XobxTIwMjKitqNCUYdQPJhPrrEFqZ7Ncl1bLMB57I0VGpnidmO5cgnWoUtyvWQwIPzg+9VGr+O5qVDUOxTp51J5cbQ1uxa67+kCp6DCeG6KHqud5fpdS+c9BWaKr319ffKXt3n/e4UpBx67ER6LCdF0QVyibwcd43TeU7yn65tiNAX9yasR9Hy8Cp3cHC+d7XR40y0fjYaRmx1Ck6kEq3YOn7vnM5i2evCbhz6L5zv2Yww+mJx+lGx+aLztMLr8InJTAOd7UbBmv/tiqYhcPici285dO3HgwH75O19kr7po7zl4D/bs2S294imqUbzPZCsiOrclHe9nzpyGwWiQqHybzS7R/xS3bXabONNZBECR/Z1SHcO2rdvEic/x830ZhX/hwgUMD49IykAoHMLFSxfRf75fYu3zhbwUPDAxIDoXFSfw9PS0iPd2u12SDQKzs+js6kTfvnsw7tmHf37iK/BkK3H7AbMTXzGZkQ1PSNEAix9YCMDPgMvnhdu1VCoiGAhicnJSHPlMLKi6ieeLTJyfdpMeTvPqL65Rx5yKKozQN+m1EqO/FEzAmAxHcEp77Xt/90w/NI4GWBo6cPddd9cSPwj3EWdOn8HRo8fkb4YJIvmiuPAVq2d+phifnyvcNAmo2oKGSQ7vJl2Bkfl/d3Qcf39s/DrxnkWM/+zBHonMV+K9ol5Qx52K6yiVYLt4ttIiSrGiqPmpUNQnI3Xwu/Z2sqy5fPfee69c/uf//J/44he/iD/90z/Fl7/8ZfzN3/yNOPR/9md/Fp/+9KelL6JCoVAo3p7o3Q/CeuVSLWI98uATarOtQXzPf2fBZ150OFd0PAqFYnXDk90Wgw5emxGOeUJgscS42hL8NuOacN8vJ9VYdTo8jUajiNDsjc77lwMKsoViGcVyGZFkTqL1bxbTS+GYTnA679n3fmZmVtzgdI13d3WLG54iFgUtOrkZBc/4e46dEfJj4+Mw6bTw6jLQadO4Ui7gs4/9axR1lc+9DA2OBbXoLJbh9LYjHzOgoLOIS5yCPR397GFPBz7H8nZwHPfdf1/Nqc8Cg9OnToso7vF4sWnTJlzRXZFiBK5TS3NLzRXPxzdu3CjrtzhdoArX9UYJAPPHwAvfm0I93e8sJKDjPRqJIJk0VNz1uZx81oQFCozd1+n0IqAzEYDbkMUELIhgr3q+l8fjw1dfCeGxkcO4f+pM7T3/yN+LcjYivZtZlNDU3CTbwGQy49VXXpE4fZvVhqbmZoyNjkpRAQsM2lrbrnMT031PgcpqXBvFNQpFFX6fmTySyORv2EaERUjHNFpUOznfPX0e3+m+F55th9C3pVcKlarFPWwvIsVG6YwUw3CeNXX3wWNpXNLlr6g/soWi7PNY0OaxXv97pBQOIf2vfw25Hfuh2bATzo3vvJ0Vl/3Xb47iwvT17Up2tDnx8X3tsr9VKFY9xSLsF06L+UP1RV97MI2z5/f/PTJtHZj9wCcQUWYPhUKhWFfclsZ6POnyS7/0S3J5/fXX8fnPfx5/93d/h1/7tV/Dv/t3/w6f/OQn8Yu/+Is4cKB6eKZQKBSKpYgefBCtf/Nnct1x7gR08ZgSd9cY2mQC7jdeqN0OPfrBFR2PQqFY/YSTOel737KE+95i0MJm1q/6eO7lhiIuY/MDgYCI9/zL27x/uaBIQTcgL2xx4LMZRWBe8rlej/S8p6hF5z3Fbbq7Kc43NDagWCiKoC0CfiaD6alpidBnn+h0Kl3pLZxOodnrgKWoQzwVhzY7g6i1vfYeZY0WoaILznIaFv8GuHt2SXR8o8Msy2GMvlanlbHcKlVRnUI13fd0s+u0OpjNJvT09Ih4z3j93bt2i9A+OjIq99OVn8/lceXKleui5SnaUbDjdmDMPyP6KbLTcd/V2XWdmF8tfmDxRVdXt4j3HAuLCSjms2CA8P24nbgtM+k09AY93G63FBPcc8894qLnMvw+P14OWaCZ6cfPnvl67X2+07gFL0dmoU+F5PiX77VlyxZs3bJV1ofbgO/pdDmh02nR2NQky+PjHPviAgTGSbOwxm6+LYfoCsWKQfc9L9FSWRJiWPAyHxYNsaDnlNkCJDJy357AAEyFLKKGBowMj0o6BucU95kU77lvbm1plWKdyalJ6CxObGjySYy+Qwn4dU8yW4nPtxh1S/4fLL7xOkrnzsJ97iw2dW/D2H/8r+9o+blCCV98YwQDs5W0lCoGnQYf3t2Ku7o8N/z/q1CsJhq+8xU0fPfvYYhFMfoz/xKR+9+30kNSLDP+Z78pf80TozCPD6vtq1AoFOuM2352gD0j6bjnyad0Oi2OB7rzv/SlL+HDH/4w/vzP/1xcCIo7xxNPKAevQlGPbN++7br78v4mJHu3wDZ4AZpiEa5jryP88JMrMj7F7cHz+nPQ5SoOz/SGbqQ2Xf89UNTf3FQo6hWK9ExY9FiN8Duuic8UjdP5EhrspjURz73cv2u7u7ulfzyj3um8p3hPoZn3LxfSZ91mYhImQsUsoum8fE5LQdG4p7tHet7Tdc8LxXuKyzt27pRY96rQzWh4XigOM7aeznmKYYVCUVyrG3t6obfYcXkmBkMxhIDOV3mPdBT/+fXP47KnHS/c/yScrd1wOR1otZbhteqlKIDx8hTEq27/W+HcuXM4/NZhia83GIwiupFMJove3l6JuWcMP6OvKcpRgOO68e9S0fIsVKB4PxuYlZ71wyPDclzJ++86cJcsf74gzoIDphbQXT89PQWrxSrbg4UEpqvuepJKJWsJCxTyGZnP4g2K9ywKqBYUnJpK4csng3g8PAJDqRLRPWrz4Q9zeWSCozAaDFLoQC2I71NdH9Lc1Czv19Pbg2QyBYfdXiti5/pXEwUamlthtDkkSvpmcdKrCXXMqaii1WqkaMyo0yKbL4loe126RjaLqTIwojehs5CFtlxC79wkLvg60bTBjWwiIsI94b6FxThz0TnuWGUut3flJUZfBPw19D9uLc7PkqQBFZDKF+CzL/0/sPDGa7Xrwe373lGqQjZfxF+8PozhYCVppYrfbsSnD3Wi0bmwuFGhWNXHneWSiPfE/ebLSsBfYxhnp+E4daR2O/TYh1Z0POsddV5IoahPnljjWudtOTtAV8RXv/pV/Mmf/AlefvllOSHCCP3f/M3fxGc+8xmcPHkS/+W//Bd885vfxC/8wi9IzL7izsGTXOzzqFAo6guejDYsOmlNogcfgi6dkr+JrbtWZGyK20f44adQtDrgf+5bCN//uJyIVKyOualQ1Kv7ns7uZpd5gcsxlS3CatCJu3ct9Xpdrt+1LDret2+fFB5TSKK7k+I9719uIYuCRZFCL3v7ZvJLFlRQQOa6UbBKJOISm0/nPcV7uvEpdNN5TxH41KlTEn3f1NgEjVaLdDqFbCaLpqZGHDp0SIoBWqJzmJw9hlDwCjyeElAy4b++/AdoTEfRGZ9B/LgbI098ENlsI9LRaZy6dAqFWEiEcPZ0pwO+KpJXBTc66CnuUzDne1Qj4dljfmRkVFz3hUJetmc4EpbjwfnR8fPXkUI512mpaHmJ4z9zWo4xM5mMuO9ZFM5CBRY4LI7d51gYY9/f3y9954dnhyutCKxWicRHDjDo9VKcwGVR4G9vb5fIfDI1NS3CO4X4ktGCL59Py/3Pdt6FcUcjfvXE3+JPN2yBceISWptb5L1tdhvKpbLE9nN7cX0o1m/bvg1mk1nGys+D6+dwOK6LAHcEoti/azscDXasFdQxp2I+7GHOKH1Gp88X8LkvYQqG1+eV1JCvxzVIbvwojrXsQMpQ2bcPJHTY4/XJvJIimWAIw4nh2r7AYXeglMsgVywjmytJu5ibtShRrOz8TOYKEp/Pgg699vrfI+VCAYW33qzdTuy5G7eahUNX/1+8NoSxcGW/XaXJacJnH+hWxR2KNXfcOXf3Q2j92z+X646zx6BLxFC0q3Z8awXf89+GhpXZbJG26wByTW0rPaR1jTovpFDUJ3NrXOtcVgF/YGBA+t5/4QtfQCgUkpMiH/3oR/HzP//zeOyxx2rPe/jhh+XyiU98At///veXcwiKW+Dw4cP4yEc+oraVQlFnXLkyhD1791x3f/CJjyD45MeUsLtGKRuMiN73qFzENqtYNXNToag3GBnLk+IbPFY0z3OYUcyouu8dayyeezl/11KsX27BfinY59xnrzjxg8ks0tqFghahGE3BnOIwhWWKXDMzs3jmmaelOJqubjraKZJPTEyKW5zP8/l90t+dzvaGhkY4HJWTuG6XA/Z8FLnoHHKZHODpxImGzXj/6Fvy+McuPIcvWhzIvO99ODc1hXDBLEK30VgQ0YxwLKQaZ39l6IrE9VPkZ4FBNd6aSQYsVKBoThhhz7Ft2rhpgVN+/jreqLd9tViAhQKRaETE8GQqKU55YrVaRASfH7vPZTCWf3hoWJ7LcRgNRnHsUkgvl0oi+rElAWPyu7q7JNK/ta0Vp0+flgIIrrPJbMaLsSYkctf+N1/wduJPPvTPYI1chC8+iY7OThHtfT6vrDe/P0wYqK5PqVzC4MCgCJMGvUEKBZiKMD8CfDoYklYDwUY3rJvWzolZdcypmI/FoBMXPouWaq77XA6DgwPS4mJL3xYp0hmw2TFudSJzVbwnJ6fS2ICkFLtw7pJq/Hn1LwvWjHoNMsWKC99uWlv/69bS/JT4/HwB9hukjRTPnQXilb71KZcX2t6Nt7jcAv7slSFMzVXaMFRhOyGK9zb1nVCswePOXGMzkj19sF25WElsPKoSG9cKmlwO3pd+ULsdeuzDKzoehTovpFDUK4fXuNa5bEc1jz/+OF544QU5odTa2ipu+5/+6Z+W6zdi//79+NrXvrZcQ1AoFIq1iU71KV43KPe9QqF4j+579lmn02y+y54ntem+t5l0Ih4rVh46UT104pfL8rnpdZrrPpv5QvbM9AyGh4cQjUbleIvF0hTpmRqwbetWxObmROCmw5zCcFVsP3f2bMWtn83C47Chx5dDBDrMZYL4fN9DcGfjODjTL8/99Imv43+XgbTPg4LZDXuzBfG5SaRnZ8Vxsm1bJdaV4jOd7yajSVznFKarTviqoEZnLMdM4ZrFBSw44Fir6zRfwKPQvbG3d8mI/qo7l4UJjMSn85b9shOJhLjZU6k0mpoctdj96nIZ/89t5fV44d/sF9d7ddt1dXYhFo9JDDfh7U2bN0uyQXNzMwr5gmzHIzEHBucWFtb1WHPYYEwjmk1In/uJiXFx/1K8t1lt4v5newDCAoKXX3kZU1NTUkTQ0tyC8fFx5At5KTqgeM9l2JxezEWHoS3lVU9mxZqFEegmgxaJeAznBy5idnpS5gETNlgIxDnKIpvJySlkUscBf1/ttQPhPE6G+nFw/x5pzcj5v6Gjo1L4ejVCnwU3Zr0OmRx7qxeUgF+nSJuDXFEK2EyGpY9xi2++Xrse2LIXBian3EJs/udfGcL0IvF+g9eCn7qvG9ZFRXIKxVoies9DIuAT9+GXVMvFNYL7rZegT8Tkes7fhNieu1Z6SAqFQqFYAZbtDN7zzz8vrvqvfOUrGBkZwec+97mbivfkwx/+MP78zytRPwqFQqFQKBQKheLdQZf9XDoHt82IVrflOvc9nWdOi+oLXE/QIeq2GuCyGhBJ5uSzmg/FaLrdz/efl57yFIIpzrMImrHvvE0hv3djr4jGvK8aC08hubu7S5zofA2fGwwG4LPqYSsm4NblYU7P4H/t+wjOeztr7/lzJ7+BrbMhFPM5ZPR2mFt6ES8ZkEqmxAVPwZ2im81mRaFYENc6hfWqE55QJKdL1t/gR1tbm7jvLVarOM8Xr9e5q395m/cvhu9H1zz70m/cuFEc7HTTcx3Zd54x9dXY/fnLpVCezjCG1iCR9ixgoKjPS7W9G1skuF1uicrv7z8v68f3YrHB+ZgZh8Nm/PiFp9GQishYHNo8NunDsBZj0jaAQiIj/WcDAREUeZtpBBwHLxTvT586jZmZGSlCmA3MSnIB34dFFXzfdCaHUDQCp82Ecj6No0eP4rXXXpO//GwVirUEBfbg9BRGJyr7Mu6fWDRTKwyKxyS9wzg3DpQqCR6kqLdgeK5ym/Pf6/XC5XLK6/mXt1nEw5j+aox+oVhasfVU3BgWFLLAYnHqzHwKb7xWux7b9faCFffpXzk2fp143+234bP3K/FesfaZu/uB2nX7+ZPQxa7/PaVYffie+VbteujRDwJaVYikUCgU65Flc+Czx2Bf37Uq6VuBkYm8KO4su3fvVptcoahDNmxov6XnGYKzKFptKFltt31MituH+7XnpD9dfOd+NkVWm3oNzE2FYiWJpnKwmwwSkz8/Jnatu+9X++9al8WAXLGEfLEkn6HXZqy5sOkkr0atU1Smi9tgMIpbtbGpUR4Lh8ISK18VwShwE7rLOzZ0iIDt8/rkNh3huXwe2UwGBVsDyo4GmEsl/Je7fwy/8caXsGluAlqU8c/PfAulnT+EtzQpjCfL0Bm9KJpLIlqLSGYxS5y/XqfH5MSkjK/qhG9va0cymcTIyCgcDqv0onO73bJO1Zj7+etFFzqF7MV97KtU349R93fddTc8ngG0tbeJ8L5r9y4R88jA4CBGR0Ykxp/jZLQ93ycQCCAei4uYX3XgM1af6QUsLCijLIUF3Ka6Bh3MMGOmZMcrcS9+7OKz+IkLT+Ojg6/gf+/9Yfjv34s2nQXJaAYtTU1y7MuCAUbo87Ph+/L9eR/Xl0UTXD4LD5LJFDLpNKampySyn6kFXOeLV0Zgt5jQ6HMiHothbHRUWiBYrVZx9TO14E60dbgdrPa5qVh+6MAvF/NIpnPoaW+R/RP3U5xDvM40C5JIDKEUGsJWAL1zk/j6xgcxZ22V5zkdTina4fxhq4tSqSSJGXTynz1zFk5/MzJmr8ToO9bg/7zVPD9ZVJHKFpEpFOE3L93VvhQKonTxQuW6VofC3gNv6zp68WIAZycqLtUqGxvt+PShzgVpRArFWj3uzPsakdy8HbZL56ApleA+8ipCj33otoxPcWewXLlUS1Uo6Q0IPfR+tenrAHVeSKGoT3av8ePOZRPw36l4r1g5urq61OZXKOoQn99/08ddR15Bw3e/CttAP8Z/8hcRelz1wFqtaPI5tP71n8AQn0O2sQVX/s3vINfYstLDUrzLualQrDQUJcPJvETFLuW+p6i/Vt33q/13LYVen80kccLBQgaxTEFEfVJ1u1PkZjw7RfxQKAi/zydCvAjjWo2IWBS5D959UIqjKVzThU5h3Gg0YWBgAJOTkwgGg/J8Cu+ZwAhK2Ryg5eFgGb+1/5P43LG/w8arIv6vnvkmfn/Xx/BSLgmtwYGMUYPRaA57dreLSE1HfiAwK4Ianfjs9e52u8RxTyg+083u9fqg1+ug1+trMffz14u9r+fmYiK+Ezrp54v4vM33o1g3F51DU1Mj9u3dWysCp1jOx7i86ZlpccIfar4Xra0t6NvSh8mpSQSCARmL/ao4KEkC2SzMFou0BRgcHBTxkAUFg7Eknk568eD4SXz6QqXvqCOfxiPxy8g3HIRd68OV2JwUCBw4sF/i97mt+VoWSlSLEbh92NeePb2HhobR3NwkLQ6ampokHYHrZbU7EUlm0eg0QZeLi3hPFz8fY+HB6OgoPB7PqhXwV/vcVCwvTJQ4fvw4Xn/lTQxNRxALTmLXzp3SuoIO+qbGJmkvwf2XNpfHX7/xZ3CWCihBgxc27EXM4EcqFZGofLbcYMEPRftqm43RkVEpzGloiqKEPrgszXCY1+b/vdU6P5O5ItKFIkx6LXTaSqHazeLzw91boHVU9ts34uJ0HE+fm7mu570S7xXr7bgzevAhEfCrMfpKwF/d+J+75r6PHnwQRef1baYUdx51XkihqE+61vhxpypHXYd84xvfWOkhKBSKJTh54uRNt4s+Ghbxnrjfelltw1WM661XRLwnmmIBOV/jSg9J8R7mpkKx0sQzBRh0GnisRnishnXjvl8rv2spZNB5z/YHFYdiYYH7nKJwd0+3CFZ0mw4ND6FcKok7+9FHH8X2HTuwbes2EbUpflMApkOVQvUbb7yOgcuXxYEfT8RRKBRgd9ixaWMvjOkQcpFpRKbHMTN6Br++48MYdFZaoFHE/xenv4bdrhbo2WNaZ8W50SAuB1LYum07Dhw4gLvvvhstrS0iStMhTxGN0fUU8VlMIO3UymUR76sx9/PXa3RsVCLlGV8fCAbltUtF6VcTCfgaOvyr6znfyc8obQ00mJiYwEsvvSh9tNlTu7urWwRwuu15sdttEvkfiUSl+CAUDMHj9oiDPlHQ4rlkOzaFRvFrx/+29v4nHE34gsGEgTPHcOLkSfkMFhcjULyfn3bAcRTyBSlkmJqaxIkTJ+R2S0tLrUiha/MW3Hv3Ptx7937YrFZx3jc0NEh7AP7lbRYarFbWwtxULJ94/+KLL+J73/seBi5dwMzUOE6f68eLL74g+ynuH9gKhN/3RDKBaCaNEWhq+6KD0/3IGhxI6W0y9zh/2DaExTCc/0y/qLYLmZ2exOjYJDJ5FaNfT/OThYaMzn/7+PxrAn5054GbLjOUyOLLb41ifvMZ9rr/CeW8V6zD487o3fejfPX3ku3CGeijqg3PakWbycB1+Nr5PmXcqR/UeSGFoj75xho/7lw2B75CoVAobi9zd92Pti/9ETTlcu2grOBena6s9Y7/2UX9zHSqn5lCoXj3hJOV6PVWt7kmds533ysXYv3DmF9+hsViGcFkFjqdZoH7nCLx1q1bRRynq73B7xcBn3Hsi6G4RZGbblSK5xSW6d6nq5uiNQXrdDoNi8mAZHQCpUIRsDcgFR7Cf9jzUfynk19DT2wKx5r6cLaxD4VyCfrpkxiPpvD9149j64ZGbPJb4PV4a6LZfPc5Cw34/vxLgZuR/dWYe4pvFNYp2B1+67AI+BT++dypySk89/xzMm4WJix22FPApwhUZbGTnzHaXC+K5+l0Bo0NDdi+fTuampvF4U9xUKvRyiWfT+PChX5ksxls2bIFDS3t+E7ID08yhP94+C9gLFWKKMZtHvy+owGZ4fN4Iz4j70WhkeuwuMiiug0ovEOjQfuGdlkvjp/DZrHDgw88KJ9PtlCUOcp2Fw6TXrYhY/P5GVG851/e5v0KxWpnaGgIJ0+elHYVm7o74MuUMTEdQKlYkjnC1h8s4OG+gKkTTAt5MzGHnVdff2jqLJ7uvBsz2oZaIdDifUC1gIaJJIzpZ0x7Kl+Ec40Wr602WFCRyhUZ+AKTfunjHu7fi4MD116z7+ANl8d96BffGJHlVuGvnx+7u0P+lyoU6w2eF0pu2Ql7/2k5X+R+61UEn/jISg9L8S4omc24+Lt/Ct/z34FleACp3i1qOyoUCsU6Rgn4CoVCsVoPyt54CcGnPr7Sw1K8QyzDl2tJCuxnFn7oKbUNFQrFu4YnxOna9loNaHSYl3Tfqx6wqwOrUQ+3rYxCuYxoKgd9qbzAfc5e6hSkF/eJr0LnOl3pFLUoLNOVSmc8+8XTnU4XLEVyOvgpdNnsNvi9LiSzCWRKVkBrh7YQwn/Y/RF8fPI8vrDtA8jrKoeLiZb9SI8fQy6TxVwsjjG3GfbCHIq5DHZs37FAPOP7c4y8cEyLRXgWE3C9GHdPoY4EQyGUSkVotRVhh255OnHPnTtXi+JnekC1QIDLnu/kZ9w8WwWYjCZ0dHZIewGKQSxw6OzqxMz0tAiEjPvne9Plns/lMTM9g9a2DbiQaUdyLo3/9sb/gSuXlDHMGa34sy0HYAmMwmC3Y9OmTfD5/DCbzCJEEgr5LAwYHh4WF39Lc4sIkFZrFp2dXYhGIpKeMDMzg3vuuadWcJHIFGA36+Wi1WrQ3d0tbn2ux8WLF0W87+jokPsVitWOOOsTCZl3TX4frAU9siUt7PqytKPgfOLc5j7r4YcflrSK00NXgERYXr939hJMhSwuhA21QiAK+UsV0PC2w2JCJl9EJleEU8Xo1wWJbAHpXFEc8jeC++bsn3wJ/a8dh/bkMZS6epZ8Hvftf390AjOxhQklT+1sxqYm+7KPXaFYLUTueRiabBbRex5C9MB9Kz0cxXsg72/C9Cf/idqGCoVCoVAC/nqEMZcKhaL+4AnttyNy6BER8Inn9eeUgL8K8T1zzX0/d/cDKLhUP7O1MDcVipV135vQ7LLUesquJ/f9Wvtd67IYkC+WEApHcOzMecQCk+JgX+w+X8xSQjlFM/Zgp5vbYrHCbreL4Jyja/XqMimOm3VFlFMhJAtFhIsNQDmMP27og+6qeC/o9Ch13IVoeBD+og6BjAYzsTw8msx14lk1Xp5QgKfTnsIMxW8mCly+dBkWq0VE7Wg0KmNkoQFXz2w2IR6LizOfTvrZQAAul1Oc9RTlReDJ5WTZFPDGJ8Zx7OgxXLh4QZZFJy/HsmnzZgRmZ+H3N0i/bG6DZCqJ6alpeH1e2Gx2pNMp0BB6yrYP+Tjwn458ER2JWVl2TqvDn2+/G3O5OWQySenPbbPapIiCy+UYuM2rruFkMikXOorpoKfIz97eHCO3C7c9476rzlF+kjajHnZjZRsz5p+JChT/+bnReU/xnvevVtba3FS8e/h95hyYZiHN2CgC8Sxm4zkUPY5aQkfVSc8iJM6h4VQSE/kM2rIpmEoF7J+9hNd12/E3//BttPjs2LZtG7Zu2Sq/0c6fP48zp8/AarPK/T2dG5ArlsSdzf3pWm0hs1rmJz8DivfZQglOy83d8aF0AdONndA/2QX/1QK2xbx8KYgzE5VWZFV2tbvwwKZ31ztcoVgrx53hRz6AMNP9FArFbUGdF1Io6pOmNX7cqRz46xC6PxQKRf3R07u0y2A+0bsfRNuX/hDafB7W4QGYJkaQbeu8I+NTvHd0iRg8b7xQux18/MNqs66RualQrAQ8KZ7MFCQ6v8U1z33PHrMG7bpw36/F37VeqxHHZicRmJmCwWhGT0+ruMwphFOgZ7/7ah/1KvP7wVMEkyj3ZEocr4x0n5iYhNPhgLPPhVAoKO5zOtr5GIXpQjqF9MQllN1J6N0twPQllAtZ6Nt31d7jn577DlzZBL7gehLFQhKh2Rjy0WkcPnYCHosePT292L9/Xy3imgL3xUsXMTIyKiI8iwZ4YUT+5s2bJYKfoj2d69WTYhTDzWYzpqanRJC3WMyw2WzyON3pFPaqBQJcf6fDKcUA1dYCXH+6eenGb2pqrD23t6dX0gHCobAUAdjtNuitToxteB9KFg/++Ym/x97A5dq6/sOeBzGBHAIzk7KdKP6z/cCZM6fR2FBZbnWbG01GNDOmf3RUCg4Yn+/zeaW391x0Tooa2DKgul3ovpfo/Kvu+yoU61ezYL8e5qbi3cFilD179uDZZ5/FmTNnkMgWYXI3Qd/UgFg8BspVVSd9OpOWCwX/UxaLCPjknqlzeL11J4ayZugDASncqSaULIb3m/RaidFP54tKwF/h+clEoFS+ALOBLUyW/sxIqVyWosR4Jo9OX2W/v5jJaBo/ODe94L5mlxmf2N9+w++DQrFujjvVHFAobivqvJBCUZ/cs8aPO5WAvw5588031/wXW6FYjVwZvPK2PwhLNjtie+6B+8grctvz6nOY/lEVrbVa8L78NLT5inMw1bkRqY1bV3pIimWamwrFSsAT3W6rAU0OM0wG3TX3fW59uO/X6u9airpm5FHOpuBqbMZcKiPiMYVwivKETnb2ma/G1J/vP49LFy9JHDUFb7rQKR7zORTFL+QuSGS+CFumNpRLlb7B0zPTCEfCSKfSQD6LcngEJpsVBZMHudkhFBMRGDffj49deQ0/PPCSvMaTjeO3t38IiVnG3muAtB6BcBjxREIEdIrqjPqnwM1YeKvVUhPh6apnPDbd+BTzPRx/NCqvk37vJohYTgGPjnZG6bPIgOkDqVRaHOrze2CbzGZxtm/dug3j42MSiU9RvVgqwu12YXhkGCdOnpBtUCqVoDfo5Xq8qMd0zwdQNDpwcOoc3j/6Vm2Zz+84hNiWjbBeuSgiIrcZo/E5Jo65paVFxsAob7qGecKc68CEACYJcH3pwGfUPz+Patw3P6tsvuK+t5v0clnLrMW5qXh3sDCF0fhM3eB81hmMaO7ZCp3VJfs2Sda42oqCLn3OUc6towYTPnB1GXfPnIe2VETSvgFuS1meS/Gf+5ZcNofmlmYpCGLKBvc9m7duQyJXiW1XMforNz9l350ryufA3ys3Yy6VRzydlzShpYoPKfD/w/EJlOaF0VgMOvzEPZ1rvlhRsX5Qx53rF+PMJHzPfxfB931YIvQV9YeanwpFffLmGj/uXNtnDRRLwgNnhUJRf/AE1q0Quf+xawL+G89j+kc+w7P9t3l0ivdMqQTfc9+u3QzRfa+q5NfU3FQo7iQU6nmyu9tvEwf+enTfr+XftTaLGX6HCdl4GFORBIaHR0UYFkHYZKr1gieMzmeUeyAYlL7xqVRS3Ox0tHZ1donTnS51is8zM7MiqvO1vE1Rm/s4/i0WCzBoNdBGx6GxFaAxu1BKRZE5+R1sQKVwgDDK+r9k/xb/fv+PYS5wBTqLFYWoCbNZOtTPSgECRZt8IV/r5U6BmzH4dP7zvfV6nYzLbrOjWKwUE7A4geOggEcxnNBNT1Gcsf8sOuDnTUGeoj1FccZvB0NBce5aLVbZNnTDM3mArz1x4oQ44X1+H3bu2CktA86NhzHZ9STKBou8x+GW7fi7TY/gk5dfwJstvXjW5cKmcl6KECgscrkcM6P3+f4sIqBAODg4IO9N4ZHrRiHRYrFIcQKVRH5WBw7sX/C5xrMF2E0GEe/Xult0rc5NxbsX8Xfv3i2JG319fUiU9AjEcxi6dE6KdTTQyGOc+/zLeXWhWELEYIInn4Url8L28DDOeTuQyFxGNDon+y624OC8Z5sMFvwEArPo6u7CDr0WhXQZWRWjv6LzU8T7fBEMG7lZK4PCsSNI9g8i27IVDu/SUfivDYQwHkkvuO+H97fBZ795LL9CsS6PO8tlmEevoGi1Id/QvDzLVNxW/M98Ew0/+BoavvdVTH/iJzH7Q/9IbfE6Q50XUijqk5k1ftypBHyFQqFYZcR3HUDB7oQ+EYMxFIDtwmkkt+1Z6WEp3gbnybdgmp2S6wWrHZFDD6ttplAo3pP7ng77Bsc1p/16c9+v9chpCu0Xh8YQGB9BPFvCjk2daG1tEXc34+DZh70a407RmuIxY9z7+y+gs7MDB+8+WHOr06nKyOm5aFROPlHc1ml1SCQSIrYzJp7iOUWz8lwYhbkotL5OlG1+6E1W/NecHsGeB/DpK5UCwo1zE/iD1z+P373rH6OfNWr5Iu3wKLntKEKHU6dPSVEBhW29To/WtlYZn8lEx7wPer0eZZSlZ70lHKqM56q4w8co4vn9flm/0dExGAx6EemmJqfwwgsvoLurG+MT4yL8MT1AousBNDY0SL96OvC5bhT3ItGI3B4ZHYG5aw9mzTaUNQsPg/9266MoODQYbvIjPXoZMZcFiUQchUIR0bkounsq/ei1Gq18LsFAEBcuXsDk5CTisTgMRoOIh16vV5IA2Aag2tu7SiZfBCV7Ftesdfe9QrEUnMMs6qHYbnX7EZ+LIJHKIJtOobe3Fxs3bpRiHBbdcH/BeXXuShH3RwK1GP0z/l6cnEhBl05JoRKLcrjv0mi18lq2BOHrWSBjNuiQzhdERHZZ1n5BWz0i8fnZAizGSkrQjch97atwPfcMHgIw9JlfRuyxD173m+fpRdH5O9qc2NFWKWRTKBTXcJx8Cy1/9+ewjA0h8P6PYfIf/6zaPHWONp2C9+UfyHVNuYR0V+9KD0mhUCgUdYI6c6BQKBSrjLLegOg9D8H/7Lfktve155SAvwowTY2hpNNDWywg/PBTKJuuOWYVCoXinUChPpLMoctnwwavdd2679cyFIv37dsnbu9iWQPz6BSMDg9MRpOIVHTXM5qdIj6jpnt6epBpzMBms2N0ZESE8WrEPqn2iu/b0ifCOoVwuvXpLqfDvSroi/AdT1Qc77EELG2bofM2Q2N24v+koghtehy/PPA8dOUS/Jk5/N6rf4S/3PokvtJ5AAhfQcmhQ6Bkw7kzZ1CIB0VAZ3EARfC9e/firgN3ydj4fhz7rp0ZXBm6IkK4xWKVYBpGY3NcFOcoigeDQeh0ehlnLB4XNz+LEPov9MPpdIm4vqGjA+EwI/1LFaF/ekpiuLnM5uYWBCNRnMi1IDTjhKWQQV5bRl5XKXIx5+bQlh3C3LY+mIMTkkwwMjICj9eD2NwcCsWC3Gacvk6vk7FzTGxjwLEwOYDR/ISv5WfAQgIWTbC9QfUzSGQLUljDy1p33ysUNytMYqHRzOBllPQ22F1e6AopaftBwb7a/oMxmJxPseefBV59UV5/aOosPr/jw4jb2mDJnAKclYh2h90hznumYJRKZdnfcO5ZHA6ZdyyecVlUUdudJlcoSXR+rli6aXx+uVBA4fCbUuAkr9u8beHj5TK+fmIC+eK17HyzQYsf2t1628auUKxmyjqdiPfE/cYLmPxHn2V15EoPS3ETvK88I4VpJNPSjviOhQlOCoVCoVi/qP/g65CPfOQjKz0EhUKxBHv23rqLPnLf43IwFj34ECIPPKG25yog8MEfQeS+RyVGP/zQkys9HMVtmpsKxZ0gksrBZtKL+74qSqxX9/1a/l1LEZ+Xzq4uvPDGcVwamUT/4AjcNiPaWtvEXU+HOsV8ivoUvlwuJzb3bca2rdtqwvH8XvENjY0iioXDEYm4t9sdsNttshw638W1nsuLkM9I/fzMZehQhMaeAawefDudxNzWJ/CrAy9LpDWF/H9y/rvYGRzEf933j5AylzEam0KsYEZjQxd2t/swNHhZXPKFfGFBUcH8sZWKJSlC4Dgo3oUjYbQwbcBsFuGchEIhGRvF+7nYnBQGMIKfjv6m5ko8LIsXJL4/nxeBva2tDcGyDeHW9yFv9sKVjeO3X/88Ziwe/L93fxqtTh16kYEprYdDm0dOp5f3q6QFmETEZ1EAHf/cpozMf+ONNxAKhZHJZGvtASji832ZGrBt23ZpEcBxcn24vlX3vdWog+1tnKhrhbU8NxXvvTCJ+6HxSArRSyOYC8dw4uRJceDnclnZp1XbZIw1NWNkdBLfd27BGy3bpf1UyduFIsoYHxuXeZpMJKHVaZHL5kTEZ5EAW4twf1PUmZGhiFwoqcK2Ozw/xX2fK4r7/mZFS8VzZ6FJxOV6xu1Dpr1rweMnx6K4NJNYcN8HdrbAqYoyFGuQ5TjuTGzfg7zHB0MkBEMsCsfZY4jvObgs41PcBkol+J/5Ru1m8ImPqhaZdYo6L6RQ1CcfWePHnUrAX4fQ1dLVtfCgSKFQrDyhYBA+/9I9/xaT6u3D+f/vyygbVM+/1UTB7cPMD//kSg9DcRvnpkJxuymVywgncuj0WdHurfTwXs/u+/Xwu7bB78eDB/fC7nQiGM/CYTFiU3dnTQinUM0YfcbqU/iqivvzoVufQvSZM6eldzSj8g16g9wfDodFGKeAT4GNTndLhhHyCXlNauIi9K4maF3N0PvbcVyjwy+2HcC/jQxhe3RMln/X7EX8wYv/HZ+7559gxN4BvVcLq9+EtM2Inu12XDl3QvrQc8x0xlLYpgOfMfODVwYxPTONuVgMLS3N4sJlVP3s7KyIcxR+2NeO42EkP531HD/HxsKANw8fRmNjg6QG0H1L1z57aGcKZbwx58SMfw/KGi12BgbwL4//DRrTUfTOTeI/Xfo6yv/mN9Fm3450eEbGw772FoqH/gbpH0uxMBgMwGqzyuOM5pbigGhUXPdMLWBSQLFYkudv2rQJfX2bZXtW2xxQ2I9nCiI2rSf3/XqYm4p3X5jEgpyZN48BpQLmEmkEZwMy11gsw3nEfZjsL6Ie/OXuPXhGsx/QVopfyiYH8tYmZGOXkUqnpNCH0fnN3c0i2rtcLtkn8m/npi3IFCp92NfT/8aVnp/cF/N3SSpfeNse9YXXKq1ZSGzXAdnvVmGCwrdOVVqQVelpsOGuLs9tGLVCsUaOO7U6RO59FI3f+Yrc9Lz6nBLw6xjH6aMwTU/I9SLbwNz/+EoPSXED1HkhhaI+GV7jx51KwF+HnDp1ak1/qRWK1crY2PitH6xpNEq8VyjqcW4qFLeZSDIvLl6/wwSP1biu3ffr6Xdtc2MDHnZ7EIhlEUrmYL0aR0yBqypYUSymIF8VvubD+06cPIHAbAClUlFE7ng8JuI/8fq84jpnP3c62+mIpyidz+dQLpVRigegLWSgt5hh9TiRMjXifzQ24qORDnzw0muyDEouQYsLBb0FBd8m9OdTmA3NwZFOwORsg8FkFfGezliKaywcmBifkPQAxtLTkUsxnAUIdOIy7p9CPeP++ZfR/oz91+l0Ioq73W7Y7DYR06ORiKwTnTEmhxsDoRyGrX7ENDboSwV8+vx38cOXX4IWlQjmkkYD332HYHVokQhN17Zde1u7PM7CASYajI6NSpEA2w6wVQGLBlgcUCqXJMWAqQJ2h10ERK1Wg1QqLeL9/DYHdKDqtRrpe8/LemG9zE3Fu2NoaAgzk+Pwe1xoaDyIqeEBpNMp2ZfNT+p4+ZWX8dZrL6PY54GuaVPt9UlXF5yxSbjdLmi1Wimm4X6O4r/ZZK4V0JgMWiQyBYlyVzH6yz8/WYjBz5L7aO432SaBBRoU71k0YdBpodfevHAi9/JLtfj85P5DCx779qkp2YdW4b7043vb1k0hlGL9sVzHnUxsrAr4ruOvQ5tMoGSrJBop6ouGp79eux566P0oma8VaCvqC3VeSKGoT06t8ePO9XMGQaFQKBSKlaBUUhFoCoVi+dz3ySw6vFZs8Fix3t336w2rUQ+XtYRCuYxoKgef3QSdViNC12LBfjF8nOIWhWgK3RTA2Yf60sVLIppv3rxZXO7JZFIEfEboU+inQE1MOhPsJh0s6RnYCg2w+J3QuxrwUls7zuqM+OnBt/B7+38ccyZH7T0LeitmYEWwbEeXKQVdcx9ePTuE0NgkXFYTNNDIeOi8J3Tj02HvcDhwb9e92Ltn79UIeo+I+hTuOS464CmYu11uWKwWSRKgUNfY0YuUdxPeCOsxnC2jrNFgQ3wG//ro/8XGuYqziWTMNgz91C+j6fGHcP7UUZw/f14i8Omy7+zslO3B+HsKgIzMJ83NzfB4vBgYGJD353OsFqsUHVDQb29rk7h9h92+IAmhrb1dHKQ+27V2FwqFAiL45tNJNHW2IlXSY8/u3SIEd3ReSxchU1NTUvhTGj+zQMDXNfXBGjqB7du3S/HR1NS0CMgU7+cX0JjYzqJckDYWvJgN66OFxZ2A4v3x48flf0kqlYLVapX2BWyTkNfbkMoVYDPe/JRjaWIcmpFKr+6iwYj49r21xy5OxyU+fz6Pb2uUAkaFQnFzMhu6kOrcCOvIALT5PNxHXkH44afUZqszTBOjcJw5JteZFhV6fG3HQCsUCoXinaMEfIVCoVgD6JJx6CMhZBf1DFSsMIUC+n7j5xDfsQ/BJ34Iuaa2lR6RQqFYxURTeZj1OnhtRrmsd/f9eoQicL5YRr5YEhGf34NbdSKyp3Rvb2/NXc6Ieo1WC4vVKj3nA4GACNnsK89lVhz4BRHBKJSzN7zJZECPz4i2jc0IZ7W4MDKJAYsXQ3d/FOmGRlaZXIs/LpfxU+e/i5fbdmPQ2I6/OBaAR5OELRnDvk3tmIrEkZYo/CIsFis8HnfFwZ7P44UXXsDp06cl1p/QWc/bVSc+Y/YtNivMdjeMTi8K5hacNHUjOnL18LYMfGjoNXz27LdgKlWKEMiVlm68/tiHsWlDE8Knj+HY0WPi6mfbgGQgKW77A3cdkH731Uh9JgVQvB8fH6u4/aNREfSbGptkW1L4p3O/ra1NkgTmJyFozTY54LaZ9Eo4VCjmwbljt1kRi4Shs3kxGwvXRPf5cB/Awp3k0HG4930MGxKzMBbzGPC0Iauzo6WlBblsTp47OTGJVzKvoKW5pRbDT8wGrTjweVEC/vLBgguK9yyo4rbm/xDetjrdaO3ZJjXMb7e9C6++XLse27obZZO5cn+xhG+cuFZ4RVpcZjywqWEZ10ChWNtE7n9MBHziefVZJeDXIf5nvlG7Htt3D3KNzSs6HoVCoVDUH0rAX4ccPHhwpYegUCiWoKen+x1vF+PsNFr+5vNwnjiMTEc3Lv/W/6e2bR3hPvIqzJOjcmHV+/n/8aVa/07F2p6bCsXtcN+HEjm0e8zY4FXu+/X6u5bCOkX7QqmEYKFU661+K1BgYWQ+4+vpEud1vb7yP6lQKCIQDIrznL3q6YKnuE9x3Wg0itudPd8ZW9/Y0ACXvoB4YBrauRmYCjqYmzfCZcxDH+jHTNmJoqsdd8/045OXX8AnLr+IH3Tejb/d/CiGbT5A24OhK1k4Cy1IWtugQxgZTRGaAhAMhUQk1+l1sNsdsFot8v4cJwsNTFYHymY3XE1tyDrbEDV5kLU2Iqe3iWhP9s1exGfOfReb5rnu81o93jz0OBKPvg9N2ShCs5Pi/p8NBNDa2gKv1ytC/eTklGyXJ598Ul5HMfF8/3lx3s/OzIizl0kAFAwpQB44cAA7d+2U59IlTAG/SqFURjFfRIPdvC7d9+ttbireGYxap1v70tAYpkLDMJnN6N3QVhPdq9Bh/+1vfRvtgWn8p6d/G+3pKI43bMZv3PfTQNtOcX6z8MbpcECr08r85P6jvb295uS3GHQIp3IS6e4ul1X8+jLNTxZUcfvzM+N+uqGhARcvXsRcMgM3k4GMb3/Mk335moCf2HdP7frhoTDCqXztNsvCfnh/m6TOKBRrmeU87oweegStX/48NKUS7BfPyrkjJRDXlwnH88oztduBJ5T7vt5R54UUivrk4Bo/7lQC/jqEfeUUCkX9wfjHd0rRahXxXlvIw3rlEkxTY8i2LDzxpVg5/D/4Wu166JEPKPF+Hc1NhWK5iaXzMOk1EpvuU+77df27lgKGiPjFMkLJrMQUM17/7aCYxd7S3GZ0idPVSjKZLCYmxmE2m+QxXui2l1h5q1X2gQ6nQ/oas4CALldekqkkipEoiok0wsUszJ5GZEsG2JGG36nBT/d/R5bPvvNPjRzG+0fewvHGzfhe1z043LwN06Y2YHMrNIUMkImhnIqiZOpBKR6ABTlYm1sRLWsQS2UwOgUYLT1I9W1DweLDlMkJaJZuF+FNxxaI96GGVnz30PvRedcudNiNyOd8UsDAVgGV9c9ITDfFRBYPsI3A4qKHCxcu4NLlSyJSMTqfDA0Poau7qybenz17VoojMumMOIknglHs3L4VDr99Xba2WI9zU3HrcH/CqHW7043JaBo56LFjU9d17UDosHe6nAgGZkS8J7uCA7Dl0tC3bUN7e1aKcbp7utGxoUOKbCgszy+m0VPY12hEwOflVvaXa53lmJ+SQGK1ivOe4j3/mi1WlLUGZAol+M0L0xQWU07EUT51XMR5EttbEfDZ6uD5/tkFzz3Y40X7vNZBCsVaZTmPOwsuD+I7D8B56i257X79Ocx+9FPLtnzFe8MQCiDX0AzLxAjSG7qR3LpbbdI6R50XUijqE9caP+5cf2cSFHj66afVVlAo6pBz586/49cU7U7E9txdu+157fllHpXi3WId6Idt8IJcL+kNCD36QbUx19HcVCiWE/YrDyZy8NtN2OCx1tyDSTrcDFrYTLp1KRCu59+17OtMEd9tMSKeKUqk/q1AcYyO8QMH9uOuA3dh65atsFjMcNgdaG1tRVt7G7xen4jbXp8X27dtx+5du/Hggw9i27btsozhkWERx+jSJ5nEHFITF4DgEJzlBLobbGi0m/G3D34c/a3XelZTyD8wexG/+dZf4i+f/m18+vz30JQKo2ywoOxoApr6oN14H/R7P4r83k9isuV+zLbeh8zGxxBrPYigZzsynl4UzO6KeF8uoyM2DVc2sWAdT/XuRYyx+gYjxp/8BE7/8r+Hq6sB+UQY+Vy+1h9bhEGHA8NDw+jvv4CRkVEpaqC7noJ8dXvRyUuRn68tlUrSo5tzkAUOkXBEnjc2NibiPQWtnp4e6AwmTExNIzQzecsJCWuN9To3Fe9MxD908C659G3dArvTueBxzs3XX38dGmgQN1lwQVuZS/pyCQdmLyCuc6KhvUfag1C8Z2sNtgdhEQ2LlOZDFz4j9FO5SuHSemc55idTFDo6OmT/SOc9/za0boC/uVUKDt/OLV948w1oipXPI9G5EQWvX66/fCmI5LzPyajT4rGtje95vArFejzuZIx+Fe+rz8pvJ0V9kOnowaXf+RMM/tvfw+SP/bNrLagUdYs6L6RQ1CdPr/HjTlV6rFAoFKucyH2PwX30Nbnufu05TH/8JwDt+hRy6gn/D75eux499LBUwCsUCsW7IZYuQK+tuO/99oqjjRHq6VwJDXYTHOb1KRCud9hXPVcoSVR7JJmT78c7iReuusvDkTDS6YzE1VOQKRaKKKMMl7NSyT4XmxPBnpXtfIzCNa9PTk6iUMjDaDJKv+ne3l4RuHu3dMPkakIgkcXpvbtx+fRxbH7rBWyeHBARn/gyMfzYpefkEjI78csP/XOELTeonC+X5XW6UhE9c5PYERrC9tAQtoWH4Mql8Ae7Pobv9NwHezEBYyaIja0+DP/Cr8PS2YmmzhY8UMrg3Ll8rXUAxfu21jYR5rkuk1OTEpXf2NgIn88rIjwFeYr3FPLp7mWPZ7YQ0Gq1GB0ZkedarBZ4vJX/7RQLKRq2trSKiGhxehGNDsNQLqjIZ4XibWCfdLNeh2yhJG75KsePH8fgwKAUzXCfc3ToMrZcrVU6NHUOL7XvxblQGY0WsxTmULyvFuhwTi94D6MO8XgO6WwRRWtZzctlTFHweDySeiAJJf425HSWW0o5yB+8D5d/5begffNVGDdulPvimTxeuRxY8LwHNvvV7xyF4l0yt+8QMm0diO05iMh9jyuRuN7QaJDYvmelR6FQKBSKOkYJ+AqFQrHKie++CwWbHfpkAqbgDOz9p9VBwAqjDwel532VwPs/tqLjUSgUq5dSuSxCaKvLjHaP5Zr7PssYYB3sZv26dd8rALfVgHypJA78aConrvzqd4RQgKYYTYE5m8nIfew1TXGLAj4j9fl8CjCMkGccMvvBO686YaenplEsFqWvdCwWk97SNrtNUiEo1geDQRHWOjs6cWD/ARHI25sasLG3GyOjowjEs5jdtQ2vdnbhlalpbDl/FLsun4Irey2m3lLIImKuuPmrvG/kLfzSya9CWy5BV21ufwN2TZ3GS3YnnIYSjKUcms0ubHz4EBocJmhlW1gWtA6orrtsC5MJdrsDjQ0NaGpuQltbOwKzszX3btVZ7/F4sXnTZhEH9Xq9rH9vd684f2U5RqOIhnzc7qJ4H4HLZoLbZlJfU4XibTAbtDAZdLhweQiD508hlU5JqwrOP7bq2LlzJ5KJJAI6DXDhjLzmrpl+GIoFHJ1M4R91OmX/NL9ApzrHq3BfYNRrkGERUq6gBOFlFPF5IdyuU3MZ5DP5W/pdEiloMbllH5I9u9HmqcSGP9c/i3zx2j6fCUMPbqrsZxUKxTunbDTh4u/8qRLuFQqFQqFYpSgBfx3S2dm50kNQKBRLUD358U4pG4yIHnoE/me/Jbe9L35PCfgrjP+5b12LhOzbiUxn70oPSbECc1OhWA7CyRzMeq2IkY2OihhYKJakR2yj3QyneX3/nF/vv2spvvtsJhRLZQTjJcQzhVpk+/y+7OFwGKFgSO73+X0i0tN9T2H7vvvvw/bt22tCP8VoimHjE+PiMN+4caMI04xIprDP6PyZ6RlZPqP2KfqzF3zV+cpCgcX94Dc6nNA19KKwZyv+7sqD8F44i7snBtA8NohxdyN0gUso6C3QWxwoaE1AIQdD+e2jrud0RiSzKSTGziNXyqKrwQm/phmmYgZajbn2PLrp5/fWrm4bpg+QeCIOS8yCSPiMpA9wHTf29tac9dwGZrNJnPh07LMnN1MHqiJhNc1gfGICE6FReKwGbOppkzj99cp6n5uKpQmFQhgaGhLHNgtomPrBApnJsRE8/fzzmL5yEalUEjarDelMGqVSGUNDwzL/ZnQGzBrNaMxlYC1ksSdwCcd1W5EtAu1t7QuKk+bP9ypWgw6JXEFi9Nd7cs3tmJ+JbAGpbEGKC2+FYDKLWCYPt7WSlsCCr7eGKvvkKo9taZTiDoVivXBbjjtVNHtdoU0nUTJb1eeyClHnhRSK+qRzjR93ru8zfuuUPXtUPI9CUY9s6FjoFHknhB5+qibgu46+Bl18DkXHDaJoFbcVbSYD3/Pfqd0OPKnc9+t5bioU7wUK9eFEDl0+G7r8tpqzmiKt3aSHw6JfEDe8HlG/ayFR0HTeF4plhJJZcUEyvnh+X3ar1YaR5Ig4xzd0dMh9fIyu9Kq4PV/wOnr02IJIeEZT04lP4Z9ufV74WorW7IHMKPqq85VU35evp7CfSsTQ7nLC6bQgPVvCSJMLr+78EFKZIiYuXUZjahTZYgnlqBapTB6ITi74nCnllzUazJltGPG1YtDpxYDVjrFSGeHZSZSnL6GoKULr3oRSsSjiPIsTlhLxKN4///zzuDxwWXprd3Z2SEz+kSNHpY1AW1ubrBeXwTnH9crlsmhv34BMJltpGbBx04Ll8y9vG6wOtGRzaHSasW/bxnV9ok/NTcVS4j1j8UdHR5FKpaT4h8kfjGE/c/I4xoaHYDNb0dvbg8mJScQTCZnPU1OTiEajkgRy3GzBk7lKmsj9k6dxpHkbTkzn8IkOJ3bu2llLHRkYHLxOzKcrvJAuI5MrSvuR9Zxes9zzk9uT7QlyxZIkw7wd2UIRc6kc0vki2kyV05JPn5tBaV7gCv+v3d3jXdZxKhT1jjruXPts+LP/DtPkGAIf/ASi9zyMsn59F5StJtT8VCjqkz1rXOtUAv465MUXX8TDDz+80sNQKBSLuHjhIvq29L2r7UKHd7KnD7YrF6Et5OF59VkEn/phtY1XAO/LP4A+EZfr2YZmxPbdoz6HdTw3FYr3AqPzXRYDml1meK461Ko9zz0U8Ne5g5Co37UVTHodfHajuFVDyRz0Wu2Cvuxz0TkYDFe/L+WyCPKMm65GxS9mfiR8ta90S3OLROhTmDcZTeIupyPf6XAucL5SOFss/r915C1cvnRZbjMNgA5//fAQ8oW8vN+u9g0IhoKYDUYQmwniFYMRJ9q3wGyzI5vPS8KAQW+A0+XAhuZG5FNxRMJBtDid0NkMsDc3yLJ3794tqQHzixPmU3XeU7wfHh6WggOHySHrEQgE0NDQgEOH7hXBnsugq5fP4XVuw6amRrm9VHGA3elE16Y+NNjNaHKZ5DNZz6i5qVgMnfcU75lkwX0F5xxvsyAol04im4yjuakX4VAYpXIJ8XhMioaI3m+Al3M7nQROHpX7Dk2dw/8qFXEmUMDDoeCC1JFq+kc1aYTzlQU5uWQCRwcuwq4twOewSALAeiy0We75maT7PleExahb0MblRsy98hqSjnYpNmMR2lg4hTMTcwue8/7tTfK/TKFYT9zu405DOADHmeMIP/T+2/YeihtjnJ2C68hr0JRL6PiT30e6oxeZjvWb1rTaUOeFFIr65MU1rnUqAX8dwoNYhUJRf6TT6ff0+vAjHxABn/he+C6CT35cxXLdaYpFNHzvq7WbgQ98AtCu7xP4a4H3OjcVincDI/IT6QJ6G+3o8ltr98cz+Yr73myQk97rHfW79hoUQtzWMgrlMkanghgeHsH0zDTmYjEYDQbk83lx4DNKtRp3T9F9KaqR8BTCqn2lGRnf3t6OiYkJidcnFO8Zvz9fzF4s/o+OjWJkZBSJRFwct/l8QYQ5jsVisUgP+mKxAINODxRzaHBZUCqVUCqkEZuJiDBfyOWhM5sxExxHanZchH+j0SQifXtbG6JzUTQ3Ncv78XL23Fmc7z+/oOc9x1hNJbBYrFJgkMlUnLyM8/Z6fdi2bbuIhPlcXtabhQmM0uf7LF7Wdd/FdF7mpdOiX/fivZqbiqXgPKPznnPIaDRKwQxbc/B+l90Ko06LC5cHYSnnZP9R3Wdx/jW3NMv+Ipy2IWQww5fPwJFPY3dwACf9vRgeGYPRYLwu/WN+MQ8F/sFL/Rgcn4Y+n0STw1RLAFhvIv5y/u9k4ViSrQnyBSkke9vnj47A8uu/ikMGI0K7D2Lyl34d3zs7veA5bW4zdrarNDnF+uO2HXeWSuj8//4zXMfeEPE4uWkrsq0dt+e9FDeE54q4/Ul8534l3q8y1HkhhaI+mVvjWqcS8BUKhWKNEL3nIbT+9Z9Al0nBPDUO26WzSPbtXOlhrS80wNQnfwqN3/kKDOEgwg+8b6VHpFAoVimzsSx8dhPaPRYRZkk2XwTTZW0U8K9GzioU83FZDZgJBjE8eBEzkQQSySQCswFodVoRt+h8ZX9p9pOmk7zaw30x1Uj4xcI1Ydw8ocOVQj4FtvmO9Kr4f/nyZZw/fx5Tk1MinFOI5/snkwlx01ttVikIKJfKmJmZwczsjAhvdptd3vfS5Uvi+DebzCL20ZXLYgT2rddqtLDZbfI8nU4LvU4vy3d7PFIwEAqGRChc7MKtphK0tDQjEgmL8B8eCovo39TUBL1eJ+L9/AKHxe0FloJ9n/kbwGHWw6mSMRSKJam087DW0i74l7d5//33HsJrR09h7OIwotkkrCajCPhzczGUiiU0NzdDq9UiFo/jlM2GR6OV4pv7Js/geGMfhtJGWCfGr0v/mJ80wv3QzPQkTCYzWtubUIqHagkA603AX04o3jMKnwUYt+KYz778kvzV5XMwlgq4PJvElUBywXOe3NECrerbrVAsH1otNOVyTTz2vfA9TH7qZ9QWvoOwzaX35adrt2dp9lAoFAqF4m1YV2f+eAD4h3/4hzh58iROnDghJ5R43+c//3l89rOfxXqBB8gKhaL+0Bve2y65ZLYgct9jMIZmEHrkA0hu3LZsY1PcIlodoocekV5mhuAMyiaz2nRrgPc6NxWKdwpd9vliCY0OIzZ457vvC3BYDCISapX7XlC/a68nOjOOyOwkvF4XmpoOYXJ4AOl0Cq2trejp7lkQd38zYXop4frM6TPiaC0UKFhrKm788XGJTL7v/vtqr6MwzyhrivdXhq5I/DwFezptdVodNFqNiGoGg1Hi6tOpNPR6Pex2OzZu3IhIOCLXWRzg9zfg/PlziF9tT8MiAJ1OL6I+9R0K77ze2NCIwOysRPETCn4dGzoWuHC53nT3U9SjUJ9IJKWwwevzSmRt9TGK94zVZ9T/0aPHbrq9GO+fyBXhtRrhthjV3LyKmpuKxTCuno53iuZ03lO87+joqMXY33vwLoQTWRhNRmTjc4gnEpicnJDXzs7Oyj6Bbu+xrm7MXCripba9eLmt0vNyOGvHdiSva/0xP2mk1lakowXQGODw+DE5dEn2S+uN5ZyfyWwRqVwB9qvFhm9H9pWXUc0ni+09iB+cm1nw+KZGOzY12ZdtfArFauJ2HneGHv0AXMdel+ueV5/B1I/8FMo3SGJSLD/+Z78Fba7y/ybd2YvE9r1qM68y1HkhhaI+Ma1xrXNdnZFOJpP4lV/5FbnOEz08qcMq7PXGk08+udJDUCgUS0Bn2Htl4id/QcXm1wMaDfINzSs9CkUdzU2F4lYplcvivm92mrHBZ4NBV3Gz8eS4RgvYjHqJ0FdUUL9rryefy0GTTaC9swVp6OHcsRtTo0PYunUbDhzYv+RXh9HSPC5aHBO/+H6K4+xhTyjEMUqSDlk6WOdH6VeFfYpuFOcLxYI8t1gsIXs1tp4COdMA6KanKM8Db4pu8XhcblNw58Xj9mBqalJc9EwOYAFAW2uriHs8puvq7EJHZwf8Pr+MLxAMSDR+oVBEJptZ4ML1+3zSVoA9LFlEwPh9h9Mh4j9duxwTn8cxxuIxSRhYqpf2fGKZPCwGnRTWsP+zQs1NxdJQpGdcPfcXFM055+f3oN+yqReheBqjM2HkrWbZb1QLdPT6ShsQ7gOifj/+uPsA3ixvrC17Mm9Ba6ubQRgLWn/MTxqptveIz4VhsHsRS4SlncZaP+l3O/93st0Pf5+USoDJ8Pb7v3IsBu3ZU7XbJ9u2Y+L0wtjTJ3eoYyjF+uV2HnfGd+xHzt8EY3AG+kQcriOvInrfo7ft/RTX0OSy8D3zzYXue5UysupQ54UUivrkyTWuda6rs3+s8P7ud7+LPXv2oKWlBZ/73OfwW7/1W1hvXLhwAVu2bFnpYSgUikVMT02huaXlvW0XdRCgUNTn3FQobpFoKg+DTgO/w4QWVyXFgy5kOtxclkp/bbqdFRXU79rroRjloNs9FoLJ6cNoOAKdaWG/+/nCfFWsptt8vlhNFz1FeIph1fspuoVCYQSDAeh0OnHiZ9JpTF6Nya+K25cuXcLA4KA8X6PVwmK2IJVOiTBPMS6Xz8lvFq/HC7vDLk74YrEg33WKbclkCh6vBw6HQ9ZnZHQE8VgcZZTlvnQmDbvdhkK+IOOieF+N7uf8YMw2XfssEKAoL2PPZGR9crkckqmkLJdx/HTfU+hnMsHOXTtrSQMU72/US3u+eEUHvseqh9uqXGzzUXNTsRQU628UV7+5txtjsxFcHJnA9OQk/F4f3G63FO1MTU/BYrFIQQ7TPJKhMWjtXShpK6e0MiUtCu4OdNtLUjiU1+elVQf3Y4vbe3Auz46NwG4xobN7gxQRrDeWa34yGSiVK8J6i8VLuddfg4ZqP4BETx++P1lY8Pi2VifaPJb3PC6FYrVyW487tVqEHn4SLX//l3LT98J3lIB/h/C+8gwM8UqxUs7XiOjdD96pt1YsI+q8kEJRn1xY41rnuhLwebLoqaeewnqHcXVr+UutUKxWpqdnlEi4SjFNjMAYmEF8912qiGINouam4k5BITAYz6LTZ0WXz1rr/8qT43qtBjaTHtZbjKhdL6jftTePqQ4ND0BvtMHR2Irm1raaeM94+6owT9c6XfLdPd3o6empidUighXyC0TsVJJ95dPSs75c5rlgDRwOJ+LxWC26nvC5fB77UHu9HhHNdFmdCOAtzS3yXKfTJb3o6bBnzP7MzKwI61w2n7Np0yYR3+jIZyH2q6++ipHhEVkWhX6rxYrWttaaw5YFBBw3U9Yo9F2+fBlvvP6GvCefFwwGxZmvgUYERG6HcDiCC/0XJMa7mgywIGr7Br20q2kZsXQeLkbnW43QqbYWam4q3hN+vx/79+zC+YERRAIzsv+hA5+FOizaYdEQ91Mejxextw7DmhhHwtlVe/2z/TN4qiUrrysWivKXRTssAqi2BKF7jvuEWDoLaA3Y1Nd1w4KCtcy7/d8ZCoUwNDRUaYdiMMLia0UomUc6PC0JCW/XniX90ou1+PyxLfswFEwuePyRvoZ3tT4KxVrhdh93hh96P5q/9lfQFIuwXzwr5zGybZ237f0U/MFYRMP3vlrbFIEnPwbo1fHcakSdF1Io6pOLa1zrVP8x3iX79y8dP9nf34+tW7e+l89EoVAolodCAa4TbyDb1IZMR4/aqreRpq//X3jefBHp9i5M/OQvIrml4uBTKBSKd8JMLAOnxYAmpxk+u+laf+1sET6bURz4CsU7janOaQxw+ltRMlpRKJVqQndVmKcLfTYQwIaOjgViNR2sFMEo0PM1dNBT1CcUyPU6PZqam0ToZgHA4cOHa4+z5z2XZTAYRDQnfD8K83fdfRdGR8eQSFSi8hlpT0EolUqJiM73pDOf4n1Xd0WcoyDE5VC4n50NiLOeznm666sOWzr+ORYWIQQtQUxPT2NkZETWjxfG9xsMephNZkSiEel3Xy6VUbRZr9uG1ajtG/XSJolMASZ9JTpftbVQKJYHs16L5gYvRl1ezAUmMTw8gsaGBilMooDfsaFD9kd05TeXQxhAF1zZOLTlMo6OlrCzFJSY/RslZ1SFfNmXxLOw2EzIFUow6ivtahQ3F++PHz8uxWHcX8NkAyyjUsyVT8Xett1IuZCH5q03are/be0F5hnwNzbascF7/f5YoVAsHwW3D3N774H76Gty2/fCdzH5j39ObeLbiOvY6zDNTFa2v9WO8MPKWKhQKBSKW0cJ+LcBnlz6xje+Ubv90EMPyd+XXnqpdl9fX59Uhnz/+9+XE2uEB5YPP/wwTp48KSebqjzxxBNyEMSTYlV2796Nrq6uBe/D6vR77rkHb775pjhXqnzkIx/B8PAwTp261muMJ7T4fk8//XTtvs7OTmkv8OKLL8r7VU+0sY8EoyhYzbLS63Q+AgxGNWjcsw2hYBBjY+O15/b0dMvJxHPnzi84gbmhY4P0uWTfTaI36OWAktE3rJ67Nv7N8vfixUu1+5qbm6T6lS4lVv4Tvkfflj6MjY7JQWyV7du3yXtcuTJUu2/Dhnb4/H6cPHGydh9PNPb09uDK4BWJKq2yZ+8etU7r/HMi1TG813XaG5nC1n/4SxjmIhjYth8nn/yk+u7dpn1Eh04D1+HKvtAyPowr0zNo2rJzVX331uJ8Ws51qrKW1mktfk6rfZ06ejcjGImjFJ2COVDG1HlIUajN24jDr70MlxGwG97Z772DBw+uyt9773Sd+L5rbZ2W43M6cOBAbZ0mJqcAkx07du9DMByC1+uV5zE6nq5XijGtrS3ididOlwvlUkn6w5OGxgZMjE/g0qXLePTRR/DQw5X3lPd98SWZa/MLnCnc01n/I5/8kdp9nIeMvua6sZ0Z4bz6gz/4A+zduxePP/547bnHjh3D6NgoLg9crt3H9acr/8EHH6z1rI5Go3j+hefRNdQtEfx02nOdEsmEzLWf+7lrJ6W/+Y1v4o0338Tv/M7/W7uPQhQ/3+07dkiBwjPPPCP333XgLhH/6Cjl8mw2m7h4G5ua5DmFEpDKA33drdh0z3713VtiPpHqnFgL82kt7iPqcZ1y+Tx0GmDX3n1wGfehkM+j/0K/JG2w3QbnI/dHly5fwsPZKfz0q3+IbcEhfKP3AXx+5w9hLF7CHp+tNm+NBqMkZ5w/fx4TExO193rggQeQikXxndfOwG0EbIb19TmRd7tOvN3GFiuhJJJFHWwmQGN0w9pilf8hTEs4cvRI7fWEY3IMDmB7quK4T7v9eD7vAjQL3ffr4feeWif1Ob3dd4/fo9v53TvSsQXvuyrgu19+GlOf/Cc4ca5fzafbtI948qt/VXvswq6DON5f2e+rfcTq25eT6njVvrx+Pyf1P/fdzycef+uiozBPnkRXV33+hr1nid/lpN5/l/O8Bc8nvBs0ZZYer1M+97nP4bd+67fw+c9/Hp/97GeXZZnVE1c86VSvvJcvzErz4sVZvHQxgEanCR6b6jOpWFukUylYrMvjOrBcuYjN//GX5XrJaMK5//V/UbLZl2XZioW0ffF/w//MN+V6fMc+XPk3v6M20RpjOeemQrEUhWIJVwJJbPBasK3VhTZ3pf9rNl9ELFNAg8OEZqcZep1yCK6l37V3gmrccTqTQbpsgMPfgtGxCYwNXhCXKt3lPFAfujIEi9UiveTpoKRYRmf7y6+8jCNvHRHHehX2mLfb7eKm12q1IoLTee/2eLBlS1+tWJgHtexX77A7RLjftm0bDt1zSFyZjK8/d+4cXnjxRbz44gtycMuiAjryeXhK4e2jH/0ofvRHf1SWd/ToMRw58hYmJycxOjIqBdM8EcHnMwWAwj6Xn0wm5cCZ6zwxMSmiPp9Lt30gEEChUIBWo4XL7ZITAA0NDejp7kFnVye2bd2GnbuuJehwjHT6Mu4/Eo7A4/XI9qFwVTRYJS3DbzepZIwboOam4t3w2muv4ZUjp+Bt74HdbICmWJBEkI7ODulpT0f94OAgpqemsTEawk8NXJDXzVg8+MwTv45tljg+0FmuJWdw7vLEWkdn53Xx7kwkCSdzaHSY0eqySEuQ9cK7mZ/8bOjA58nLgsYgCQYvvvI6TMjLiUumruRzefm8WBR14MDC1Mro7/w2dN/8B7n++q5H8J96Plh7jL9/fv7hXvn/olCsZ+7IcWephC3/8qdgCkzLzdGf+ZeI3P++2/ue6xhDcBYNP/gaPK8+i4u/88eSgqBYnajzQoq1ztGhMA50efCjd3Wsqt9k0VVwTui9aMarzoHPyov51Qxvx6c+9Sn81V9dq3ZTKBSK9UC6ezPSHT2wjF6BNpeF5/XnEXrfD630sNYcuvgcvC/9oHZ79oPXnIYKhUJxq0zOZeCxGtDisqDVZZb7KGJSvKdIyOh8Jd4r3mvcsdlihTM6B4e/GZ7GVkQDkyK0ULDff2A/nA4nTGbzApFraHgIJ06ckANii8UqjgeK4xRpglddXXSus9c0HfsU1Pk8Cul2m10E8d7ejdcJZ/x73/33YXxiHEePHJEoezr2odFgZnpa3Bison/t1YpD7NKlS3KwSxGeMAa/VC7J81lEwBMMFPSqlfBarY4PIZlIIpvLIpPJSvx2LpeDVq8DyoDRaBRBv4yyFCxwfPOpjpXFBVw/Fg6wUGEiGMX2bVvR5mmE07zqDqcVirqGLhin1YxENAyt24tMPCz7KBbPcI5SjG9sbBTnzZViESm9AdZCHk3pCDZFxzGMBkTC09LGg4U7bJ8xMTkpBUOLC4n0Wq1c0vkikrkCHGbVpubtPhur1SptTAxOP6ZDETitRug0hpu2GyH8/4BXrjmYvuGoFHtVeaSvcVWdKFYoVjVarcS4t3zlL+Sm4+QRJeDfRvL+Rkx+6mcw9cmfQtmgjGgKhUKheGesujMOvb29cmLoVmltbb2t41mNMPqB8WgKhaK+YCQQo2yWBY0GoUc+gPa//INab7PQ4x+W+xXLB533LJAg6c5eJLbvVZt3DbKsc1OhWEQkmUOxWEazz4xNTfbaCexEtgCDViO9tVV/7RujftfeGArtFO957EThi+L33MwYHE4nNm/pw4zTCT0K14nr86Fo1tzcLMJ1d3cXkskUmhqbMDU9BaPBIJH1LS3Nsp9MJhPiWKernUI5RbbFrvbF7naK9IViQYQhxi7TLc/4e4p04XAYL7zwgtwXT8RlDFwHCu+M6Od6cQx6vQE+nx8TE+Mi0tMdunXrNjz33LM4fuy4OPVZICBFBgyfK5fl9SajSdZ708ZNS/ZrJhwjHb8cH3tqTwVDmJyaRpvfBe/mdiU4qbmpWGbY6z4QCuPclQkMDo/CbzfUCmyq/eurvFF+A2ORIPqGB+T2fZNn8AXPB3B5JopDOzaKG4cOfO5jOOeTgSSOHT0mxUosICJWo07E+1SuuK4E/Hfzv5OfTSQSkc9lZnYIMFqwc/tWeYz72WpB2FIFUaViUcQr7Ssvwjp6BWf9PbXHmpwmbGmptGtRKNY7d+q4M/zQ+2EZHUTo4aeQ2KaOc+8ESrxf/ajzQgpFffLSGtc6V52A/9xzz630EBQKhWJVELn3UbR++fMiMFvGhmC7cAbJrbtWelhrBm0qCf/TX1/ovlcFEgqF4h2QK5QQiGfR6bNiU6MDJjqDr0bqp3Mlied2Ww1KJFS8K+hGp/OeQgpFbwrr4YsXYdEU4LYYMEFRu1SG6SZmIL6W/eoDswEMDAyIS95oMkr8PAUx9opnr2ku/8iRo9KLLp8voLGhQZyu80Wc+ZH0/FssFGtOfYo/dPVzvBTLGWvf3dUtCQAU4MwWC9wutzjqKcRz3fh69upzu13Q63Ui3heLRXGBMsqZ/fEuX74sBQEsKDDrK0XgOq1O3PtanVYEqUcffXRJ8V62YS6HTDoj4r1Gr4fF6UVybggmFFQqhkJxG2Bf1LsP7IfW6sLMXAZuqwk9XR3XzVH2tue+4qTNhqqX+/7J0/jCtqdwOW3HlkhE9hHc39A1zv0V9wPj0XFJ/qhiNugQS+eRzhWRyRfltuLGn82+ffsAixP2uQxsZiM2dXfKY0w4qG7XpZz0sVwZ43c9gstdd+Erh0dQwrWWQA/3NUCrjqEUijtKweXByC/+htrqCoVCoVDUOatOwFcoFArFrVGy2hC+/3H4n/+O3G74/leVgL+M+J/+BvTJhFzPNrYgeveD6qupUChumVK5jIloWvrbt3us8DtMtccYnW8z6eAw62uivkLxbuOO6VqneM+/vF3MZTBy6RzGhyYQSuXgtJgkJn4pFzpvP/hA5f/b1NSUCOSNDY3Q6XUijlVjk+nS5+stFjPa29vR3taO7du315ZH8f7s2bO1/tXhUBgNjQ3o7ekVpz3d94y79ng8UgywZesWibbndQr20emoXOdzqtH37BHr9/vFra/X66XQYP6YKNjJmMwWidGORKIwGPTQQFMZY3v7DZMHatvQaBRHKdsFGB1eZGJhuO0mOG23nginUCjeuVB8z34nJufSsh9wLnLGc38Si8ekuOfN2RA+rNHBWi6iLRlEV2wK07ZmTE2dl2KiaHQO6VQaiXhCCn9YlJNKphYsz2rSI5UrIJktKAH/bXC4PNi8ZQe8ySwaHSYR6/l5SLoJIAVPFPJ5e/7/lGAyJ79tLk4nkJ8n3nutBuxqr++epQqFQvFOMY8Mwvfi9zD74R9F3tugNqBCoVAo3jVKwF+HMFZSoVDUH+wru9wEn/xYTcB3njgM49Q4ci3ty/4+6w1tOikFEVVmPvopQKdEtrXK7ZibCkUokYNOAzS7zOhtsNU2CF2APPHNKF+XZf3E+b5b1O/at487Zoz+xYsXRbzv6OiQx2YmxuC1mdHc0oKxQATD4xMihC8lZnd1d8HtdotrnuIXRW2Hw4Hx8XER5KuxyQ8/9NAtRdEzWj8YDCIei0s8Pp31jMeng56uWr1BL7cp1IdCISkuiMfj4p5lXL7NZpPX8H0OHDggcfmLx3T23Flx81stVnR2dYrIVCqVUSjk5XksFKDDny0CbgYFfr7/wNgkMpFhScXo626XbatQc1Nx+zAZtDDpteKOh/n6/cn01DSKpSIKOh3ehAaPXn3s/skz+Kut70e0aIQ+k0AmnZaED5vNKgVATO1gAdJ8LAYdgoksJmeCGOifRIH7OZNJ5jmLCdYi7/Z/J9v7sN2AxairOe0XtxphERVvV/+n8DdNOJHFbDyDM+PRBct7qK8BOu07b/FWKJWQzZfkOsfBJXA4vNDNb9BdKxJQKFYT6rhzbdD09b+G++hr8L74fUz85C8g/PBTKz0kxTKg5qdCUZ/0rXGtc90J+L/7u7+LCxcuyPWTJ0/K37/4i7/Aq6++Ktfvv/9+fPazn8VaZsuWLSs9BIVCsQQ8ib7cZFs2ILbnbjhPvgVNuYyGH3wdE5/5RbX9l9l9z3YFirXL7ZibivUNXX7RZA5dDTZsbnLUorjpyo9n8nBbjSLea9/FSe31hvpd+/ZxxxSr6TytClI8FqK43de3AUWtAWV4cG5gBPF09obLWtx7Wu5zu0WgoaifzWTkvoHBQRHTFzvb50fR0/3KKP4rQ1dqYnxzc4sIbVabVQR2ivUU8flcivoGvQGFfKGWKtDR2YHW1lYR7w8c2L9gTBRzGM3PdbRYLQgEA/KY31eJ1ieM65+emZZ47TOnz9zQic/7NvZt/f+z9x7QjeTXlfdFzgABMJPN0Oyc0+TRBCWPZEkjK1gOWgfJa1sOWnmdP8d12rXX2V6v12tba0u2bFnS7oxsa5QmSBpNj6bTdM7MmSBIIufvvEcCTbLZaaa7WQTu7xCnUIVC4Y8CH6pQ9737UHR44Tbn0RxwYWPP+qoV9W4njE3yehDxXuzsZ1JZFWutZnOlDcerx1/FocOHkEqlVJg/7HDijen58/I3jLyqAv6Esx0tiYgmBInQL+vKd4vE7vL+7CIgp+MxnDx/FvHJYRQzCf2ekQQo+Q6txnh/LfFZKJbUqSCZyyPstS/5PCRRbM+evfodKw4oktgl3/vC7MAw5pJmnBmNIVuYr9QXxGVoX2fwpl5bkgBSuaKeP8lNxHtJ8pCzJNmiGACIW4NMZZxyHHDbLZpoIFP5f1rJ2p8Qo7EavztNuSzqXnoOda98A70f+3UWJrxOnIO9Kt4L5nwOye5Nt+NjIgaA14UIMSZbqlzrrDkB/5lnnsELL7ywZNk3v/lNvZWpdgFf9sETTzyx2sMghCxDrGWlcu12M/nEe1XAF0Jf/xLG3vd9KHj93P+vA3M6jaLFCnMhj/Env4c/cqucOxWbpDaRHrvD0RTagi50hz1Lquyl0lAEC6/TCo+j5k7TXxM8r70+IjwtF5+WW+tn5qYRctuRM1mRyRduum1DWdRfbI8vIr1U4y+35C9b0UtlZp3Y5DvsKBVLap/f1NiEgNkEp9MxX8HZ2gq324OB/n4V3qRqtlgoYmh4WC36RYSRKtpQKKTbXT4mv9+viQHyuAhJUuUvVtviPiAJB0JvX68mCQz0D2iiwLVaCOQLRZhdXjywbzca/A54GZc3DWOTvB4kzuV46LBYVKyNJ+cq3zMiFktLD6msFyeNic4upM+fhrNUREdsAl2zoxgJNaDb5VKx3mw2a/sPSQhqaGhc0XkjMj6K/uEx1Hud2NzVrt+P8jqSAFWNAv5ric9y9b3dakZ8dunnIW1RTpw4jp07dyGbzej3vXw/i/Be+umfwJ5YHNGGbbi06S2YdXh1e2/YWH/DSnk5ZxLHInltm8Wk50bSeki+i+VcabGAL0mQMpMtFJHMFDTRIJUtIpqQJJCSivkBp02f91qq/gmpyt+dpRI2/upPwjXUp7OBQy9i9j62Bny91fdlZvc9gHRnz+v+mIgx4HUhQozJM1WuddbclcHnn38etY5U4BBCjIdUlt0J4tt2I9WxHq6ByyiZzXD1XkB855VqNXLrjH3gQ4i86R0IP/uviD70Ju7CKudOxSapPbL5IgYiSbQEnOgKe9AZdlcek6o2ucBc77Uj6F4qSpJrw/Pa22Otv7FrHTrWd2AmmUedS+yrb74tzI3skxdb0cvy2ZlZNDY0orilqCK6PC9fyKuYbzaZ0dbahkDAj02bN2nlfS6f0573be1t6OvrQyqV1ufIessraZdX+0s1aHv7OoyPTyBcH8aB/Qdw9NgxtdYPBkNYv379iuMVpIozmsxplajfZaV4f4swNsnrxWkzw2m3aMX18KLvGan0Pn/+gibfDI+MwOv14LDdhYcyCX3eo8NH8XeBt8MUaMbGUBAzMzNagS9tNFpbW6763pAkpAvnz+DSpT6gowUNfo8mN8n3Y7X+H9/q+xIhXqvvs3n9Tjx/cennIeL95MQkjh07ip6ensr3c+HyJViHB/XC42OJV/CX296h25OK+Pu6Q9d8PRHjRbgX8V1alzT6HfA7bahz2/QcSb6TxZXhWmOVdkRz6Tzm0jlNjpRxxzMFzCZzGJtLweOQNkXzyZJiuU9Izf7uNJkwe+DBioDf8O+fwey9b5jvR0FuGcdQHwKvzDv8CuPf8b3ci1UErwsRYkwyVXq+XrMCPiGE1BwmE8a+4z/AMT6MyGNvQ9EzX/VAXh+5+kaMfeeHuBsJITf3nVEooj+S1IvQ60JubGzyVuxcpco3li4g7LEj5LGzdytZFWt9i8uH6UQWM8kcxKdHql9vhuWC+XL7ZEGEcakoK1vul3vWnzl7BocPHcb4+Dji8QSsVota68uYNm7ciPb29kpfe6GxsVHHvXnTZmzfvn1F2/vF1f4yFtlmY0ODVvLLuFKppFr1b9iw4ZrjFQEomswik4xhamAU48jB6XRWdU9sQoyG02qB3WLGTKGIVCaz5Htm166dGB8bQyIRRyQyhc/nMtjjduLFtt041LRVn38u5cXDdQW0tbVjWtw/6ur0u2Px90bZQUS+Z2YiEziViiOXjKEt7NPkJvkuIkAiW0AiU9BdIS4ty7/3pfJexHtxOtm2dVulLcncp/9Jq+SFV5q2IGuZdx26pyt4zUQxEd9HZlNwWMzobvCgI+RGa8ClFfQ3g9rnO6x6aw44dZm4y0QTOUzE0phJZjGXymuCwMhMWpMBJCngZo95hFQbkTe/C43/9i8w53LwXD4Hz/lTSGym+9xroempT2nrSmF2z31IdW28zZ8WIYSQWoMCfg1Sto4khBgLsYO9U8wdePCObZuQaudOxiapDaR/78B0EiGPTcX7rS3+SsWXCIUqmLqsaqfvtvP0/Fbgee3ts9YvY4IJ08n5LPabETSWC+YyLdsnr2S5L5R7J4+NjmEuNqdiz57de9QSW/oYy+datrQX0W2x8H+tfvVlFlf7izAvY9l/YD/8Pj8cTqcmDsjjYvOcy+ZWHK/EZDI2h6FL5zA7Poi0iP5V3hP7dsPYJK+HSCSC3t5eTMylECtYkU2ml3zPNDU1ob6hHmfPnkUqmcKLJhPe17UL2PddlW2MFAMYH7+A+vqwtuaQqnBJ/FnJQaS5uRkulxvnB8dw6ux5FDub8dijj2jSTjVyq/EZT+eRyOYqTiTLv/fl+1Qq70W837lrZ+V5hReeq1x0fLF1l07l7OeBnvoVq+6nYhmtkm8KONHkd2JDo3dJq6HXiiQdNAfk5kQmV8BkPIPJWEa/62dSOQxOJzV5Muixq8MAq/JJLf3uzAeC6ioYfv6ZShU+BfxbxzEygLqXr7TsZfV99cHrQoQYk0CVa528QliDPPbYY6s9BELICmzespn7xcCY0ymYMxnkA9cWDUh1wtgkrwex4R6aTulFbxHvt7f4l/RenU3l9KJx2RqW3Bo8r7291LntWr0o+SUi4ksR0Y2qHlcSzK9lb7+44lXWl6rXdDqD7u4Qejb0wOlw6jY6OjsrIv1i4f+m3sMK1f6LRf8NPT2V119pvGK3rNOpMcyMD8LjcqKzY13V98S+3TA2yesR748cOaLxNhNPIWfzwun1we/3a5KPxK04athsNv2OslgtcLpcyI6fha2Qh8kyf5krbXKgdzqDWKxXK+nLrjeLKVeSSzuNdGNanUiGB/vR0tFd1ck6NxOf5SSK2UQa8aIVgfpmhNsbb/p7vzA4CGvvRb2fNVu1Al+QJMaw1351i6HppCaN9TR69XxJKu/vRK96qfxvD7r1Ju0ZxufSehMxX5xXxmfTej4mx0O7dWWbfkKq7Xfn5BPvrQj4/qMHYR8dQralfVXGslZpfPqfKtX3c7vuQWo9r+9VG7wuRIgxeazKtU4K+DXIsWPHsGfPntUeBiFkGYMDg1jXsfLF7juC/Lhgb7Obpv5LT6HxqX9E5M3vxOTb308hv4a467FJqgapJhuOprTyq1PE+1Y/rBbzin3vxTp/JXGBXB+e195+pNqx/K+oIj5K6gxRrppfLorfSDAXFj93oL9fhZ9gKKhCfSKZ0N72brcHgYB/xer9W+V6ov/1xitijrS7CHkciCCHTCqJro51sNvtVd8T+3bD2CSvFRGNRbyXthXb2tpxcSSCyFwczR0taG9rr3yPeD1euFxOWCxmPX5m4rMoDZ+Go2PXlW3l6zDT/2LFXURcb8ruHitVktfXeWG1b8L6zZsRDF67R3u1x+fiJIqJWAYFqwfr2mZR77Hf9Pd+4itfrtjnH2nchJRt3s7+oQ3hFVsMNXjtaA26tOpekhrvBh6HFesbvOgIuzEVy2J0NqVW+yLk900l4HZY9Hjgvkn7fkLW6u/OTFsH5vbcC/+xb6kI3fDM5zD8gx+96+NYq0jCQ/Cbz1XmWX1fnfC6ECHG5FiVa50U8GuQ/v7+qv6nJmStIhdK7saPNWf/Jf1BZs6k0f/RX7njr1cNmFNJNHzhM7BkM2j8988g3daB6CPfttrDIlUWm6S6EIvWoZkU3DYLOkIubG8NqJBfZnHfe+m9KlX45Nbhee2dQcQTEV7kNp3MYnp6Bn0Xzmq15fT0NJLJ5FW96Jfb41+8dKnS614q7S9cuIDRsVFMTEwgl8tppnxra4v2sD579pwKcps2b9IqTnnOieMnbto2/3YI/NJ3OZmVmHSg3uvAuNuptvlSeS/ivUzZE/vmYWyS14okych3jMS9JM80NYQxdr4PZruzYs8ei82hUCxoTCYSCeRyeeTzOZj7j6qA78hn4M5nEK3fiPTlZzE7Ozcfwx63is7l+F+xkry5FQ3NbYhn83dNSDZafJaTKCx2J9q72jA0EcXk2AgGQ1e+O8vTcnKWTBcvz7/wHMp778XW+c9NLOzXN3iWnAsNRJJ6LiQiupwr3Ymq+xthNZt1bHKbS+cwOpPGeCyNmYTcT+mYQgv2+ky2JNX6u3Pibe9VAV8Iff3LGHvv96Hgp/vgzdD8//4BplJR78d27kdyw9Y7+lmR1YHXhQgxJv1VrnVSwCeEkBrCFpnApl/58Yq11yit0W6K+i8/BWs8pvczjS2IPvimO/kxEULWONK/VexYG/0OtAZc2NLsW2JDXul775zvey8VYIQYDZ+I+CaT9gL+5tkzuDA4Alsxr/+/IoT19w9oT/jFFa2L7fHFllrEMBHjYrEY4vE4ioWiimVyO3jwIN70pjermNbZ2YH29nbtn1wW/BdvY2h4qNLD/k4I+iLex9J5FWiCHpvGq/S+lvcnIpZU3otQ2NHRUbU9sQkxCmJ3vzh5Zi4agdfpgNliW5IkZDFb4PF49PtEvmekYn9HvB/vf+UTeGDsNF5o24s/3vedCHbtRCw6oOvId4qIzWVWqiRvammD2eXRvu8+R20KtpJodfbsWQSa1qEQzSBUF8BcZGbJvit/35eTsywWC1paWvDIGx5Bh8cF27nTul7eZMbB5u16/6GecGV/SouhgemUJkmsC7mwbVmLodVCxuNvtqGr3o2x2bQK+NFkDtOJLMbnMnqcEIt9I4y11lytisUSCqWS/u/IrViEugSVkUsc5Tn5eMR1Q/7d5CbnMuWpfHYy1XVqML6vRWLrbiS7NsDddxHmXBb1X/1XjH/HB1d7WGuC6AOPaaGMa7gfY+/+3tUeDiGEkCqCVwsJIaSGyIUbMbfnPgSOHtR5WqPdGMvcDBo//+nK/MS7vhuw8vBJCFn54qJc7BUxsDM831+1p9GjlV1lROyUC8HSV9XvYt97Ymy8DiusZhOcpjyy6TRSMGN6ZgZ1dXXaf1oufIvQXq5oFVFN5kWAa21pVVtqsccfGxtTe2oR4EUsE2vmyFQEx44dRU9PD+67975KEoBU3i/exsDgAA4fOgyX24X6cL0K+iLYLbbBfj0kM3mttBWbZHHDkMQFQXpfSw9scRoQ4U/GI+J9tfbEJsQoLE+ecbjc6GhvR31Tiz4u3zOFfAFt7W3w+/2aGCSV+vX19XhsfTcef/F5Xe+hkeP4H7vfg6h/PfyRfsQT8RVbdKzkyBGJZ9SRI5Et6PdgrVUYSgX++GQE/ZEEXHWNmLSX0NTQuGTfnTp1Cs+/8AKmpiZVWC0WC5icmNTHnshm4VpY73j9BsTtbrWh39NRVzlfGpxOwmO3VCrvF7cYMgLa/ijs0XO5yVgGwyrkZzEVzyIykUHQM9/+iEL+7UNE+Wy+iGyhOD9ddF/On8vC+/wUsJjNOp33C7qCaPIi5sv/mTxPpkKxBE0A0P9XebxY0nV1e2YTLOVtL76v04V1liyrwgQAkwmTb3svOv/n7+ps+MtPY+LbvxOl19nWqBaI7bkPsV0H4Dt5FMlN8wlLhBBCyO2gtn6JEOWtb30r9wQhBmT79m135XUm3/aeioAf+vqXMPHkdyMXargrr70Waf6/n4QlndT76dZ1mH74zas9JFKlsUnWNnJxcSiahN1qUXvYjY0+tWJdTFm8lwt/cuFXLGOr6sLfKsDz2juP02ZBc8CFsNeB3qExzKaLqHNb4HK5EA7XL6lolanMi/Bus9tUtC8UCvP/+zNRFesTiSS6u7qRSCa0ol2q7hdX1C/fRj5fwMTkJLq6OrF+/XpNClicNHAjytW6K9nxx9I5pHNFhN0OhLxXxPsyItZTsH9tMDbJa2Wl5Bl3fSuyFpf2S5dYNpvN2LlzF2aiUf0uOHrsqCYW9bvcmHS40ZBJwptPY//EWXyrfj184iri82uLDvkOuBHijJPI5BBPW1VkrrZj9fXiU8T7fD6PUHMbZjMlzM5EkEEBrS0tlX0n36vnzp/DqVMn1WHFZrMjFAoim8lidHQU2ePHKgL+i607dHpfd0jbBYmYOhRNaSJjR8iNHa1+vW9URKiV87kmv0PP4QajSURiWUQSWVyaiCPgtqmQz1ZIt06+WEQyU0AqV0AiU0A2X9DECZvVDIfFBK/DArvVpv8fkgwrCYWS6GG1mObvlwX8hfgsR6nMlgV6Of8Q0V40/Er1fqGE/EI1f7FYRGFh3fkKf0kkKKJQnF9f2jxk81eq/svb0GSAYjmpABXRXyv7zfOV/uUq//nq//lEgHlno0VTXJmXcW/eulW3W3YLuNvM3PsIWj79t7AkEog+/GaYclkK+DeL2aIiPqleeF2IEGPy1irXOing1yBSsSIX3NYy0URWT/IJqSYS8Tg8Xu+df6Hmjajv3Ii6/gsw53Lw/MsncfoDP3rnX3cN4hkfxs5n/70yf/Kd34fJ2BXrSFIbvN7YvNG1F7lw83q2s3zx4ovMlXt6gejKkvIqZfdPHcPCOuXH9ELSwvxiC8rlF5pW4+KSkRAxIRLPYjaVRaPPidY6FzY3+66q2Cvb5sv+Cnvt2mPbaNVma5FqOK9dC2zoWY+ZmSgunD+H0b5ejDu9aG+uRyaTVvGsXJUpU6lwFZFdxHuZtjS36PeFVNxfvHgRwbogfH6fivm7d+2u9LQus3wb09MRXS7JAuWkAOlVvdjK+VqsZOlfrt43Oz0av9LzXmKSrSxuL4xN8npYnjwzk8xqX/J0rlD5jshmM6gLBjE4NKjfC+l0Gr19ffiW04Vvz8wn3z42dAwHW3agftN+tLVesW+/mcQlsdBPZPNIZq1V9/1wvfiUpImSyYytO/ZgKDKLdZk4piYnliQ/SVLUyMiofq/KfhfhU1qfhEIhbZdyom0rGqeT6JkZxkstO/S88f6esJ4LyecoZz8i3m9v88Nhu9JiyMjI/44I9XKbTeXUQWAynsF0PIveyYS6KsmxhEL+tZHPP7nQsiaRySNfKMFlN8Ntt6LF79D2NRJrLptF70scyn2Z3okkj7K4XxH0iyU9L9DpYqG/WNSpjDe/6H4lAaB4xeK/UuWv8wvLJYFA3QWWugLIuuoUII0AJNkAQDyegNvt0dYA8njlt9rC767y77nK/ZWWLfvdWP6dt7D6EpZ+Jc7PxH7w55FsaEHe5QHkVCubWvnJS55FSPVz167ZErJKXGlKs7aYrfJrQtX1K4TcFC+//DKefPLJNbm3JMtW+lLKCaJk5RJSTfSNDqPhLlX6Djz5QdT96a/p/XUvfQWjb38/MuHGu/Laa4lt//oJmIvzyUIzm3Yisfc+uGtcrKxFbjo2b/Fs91qrL7g83uQ2Slc9R++Wrjxenp+fLqy/5Dnz62jfyPLjuv58tUpp2XzFhnKh76TMSVTMV5zMXzwqV6CowL+CDWXZelKO62WryrWWCJDJF1S4j6XyqPPY0NPgRUvAhZ4Gz1XCfFm8l3dYFu95gff2sJbPa9cSIqSt7+5GR2MQ46MjmI7FMBGxwGJzoq19XaUqU6byA1oEcxHZRWTbuHEj9u3fh1dffVUrM6Uiv7GhUZevVAm7fBtycbyxoQFWqwW5bE6F/ZVssFdCLJ5f/tbLeuFbEgCkqnRoeBhmpw9btm1V2/wGn0PFAXJ7YWyS24nEqMNmxlwqt+Q74vTp05iOTKO+oR6JREKrx1+02vHtC8+7b+wUnPkMppztSGeiGBoe0mPyzbTgcDssKjLGM/mqE/CvF5/ieGBxehBLZ9HZ1op0bBo2iwXR6Siee+45nU5OTWF0dAQWqwUWi6Ui/E9NTaGusQ1/1fUIJsNvQF06hhmnD7vbAwi4bHreJAKpOBXtaAuocLsWkfcSaAvo/8bQdBLjsbRa64uQLxX54rDEJM2rRfu5dE7P/f1OG9qCLrhtFk18kHmfywqfU9r23L3rfHJuYJWbGXC81gSABeG/nABQmS9X6i/My++nSqV/pYp/wcp/QfyXn1iHDl/Ctg17KwK+vEb595nO6wtf+W1WGcvCeMozOr9ksFfmK+td4/doadOWioPG4ve6bHM1T/jYQZgKeUzte+jGGfukKrib12wJWQ0afWuzyOTlKr8mtDbPlknN0tPoVYtap80MOy+0kSojPVjCga7Q3Xmxzjeh8NXPwnLqOMyFPPZ/7f8i+1O/eHdee41gPnEMrmPzrQYEx0c/hgPd7Htbi9xUbN6yeF+6KfF+xbUWifPLn1daYZ3Fj83fXyTYLzx5sYAv9+erQxZVhVT6SF6Zli88XVVFUq5AUZG/XJ2ysg2lXtySCpZiaV7oXxD1560xzUvvW67cXy3kvUl/e+mBKpafYoO/scmLJr8T7UHXihf4VbxPzYv3Ia9Dq30p3pO1iAhm0mP6zY88qBfjhyejyBTNgNMHh0cMqq9cEE8mkpiOTqsFtsx3dnTqbbGVvc/n0/mLly4tsbaXm4hrUtkv62bSaczF5jA3N1dJCrgZG+yyxXN//wACAb9WiQbqgsiULGjuyKrAIm0BKN4TYnwcVrPG6kwqC2/AX/mOmJmZxeTkpCb3jI2OwWwyI9nUhOFkHG2pGJyFHO4fPYWvtWxDIjEMv99/VQuOa7XZkMpfsfVWi+9sQSuC11of+3ILgu7u7ptuB9LR2YULIxEcO9eLi+dOoZDLaeKV7Lu5V+f0+31mdgYTExP6verxePV7WigWioiaA5jMzp8PiXgvPLShfiHxMYPueg82N13tVLQWkfewpcWvbgID00mMzaU1SeHSZBx1bjnG2Ff1vHU1ket2cr4sbgVl0b4r5IHfZdVjrxyDvU7rmkvgvSoBQH+fvLYEgJWYuVjCAz1XYrVSwb9ItL/q/sLvjcVJ3OWE68W/DZeI/Cv8blx293WJ91Uv8GcycP3yX8M8OY7C5m3I/MKvodTavtqjItV0zZaQVWByLqNJltXWOmqts/bPmElNIRe8pUrGbZcM/LXzA5qQmyFgB5r9S/sl30nyH/kxpH5i3jrf9uUvoO5DPwTzTfSErAVK0o/vb/5CBUjB+m1vQ+P+Pas8KlIrsbnWKNtPlm0il/eIrFSlLLOhlAossZ/UaXl5Yb7vZG6RTWUqW0SukFt4znzCgGQF2xYJ+3J+UO6LOb98vtfk60Xej9j1ysV7sdFNZwva414qr9rr3NoTta3Odc2L+mXxXq5iidgvlfdG7vNKyPUQISiZTGLz5s2w2+3Ylsng1TMXUe91IpnNY2JqGv0Xz+LSxYu43HsZqWRKRX+xbi1XvJbt8q9nbV8W8RdXx16vj/21kPWj0Sjcbhc8Hg/yMOPi4BiawkE0+Jx6YzwSsjaQY7qI+A6LBZlcsRL/rmNHYTFbNN4laah87P+mxYr3Lzz3saGjeH7dPjx/egj7Y3Nobm6utOC40XeRxy4ifg6xzLyl91oR748cOYKBgQH9zna73fpduG/fvpsS8R2eAMJNrbBf7NfK+8jkJPK5vDocuJwumMxmdUaRfveyfbkvtqVerxfh+kak2vYAi7odrgu5sC7oQn8kqddyJOFRBNxqwr0g5K9bJuRfnkjo+Z/Y7kuSarUjx3qptBfXKTl/rnNfEe3lHFgSGnxO22oPc02hDmerLKQUB/pRHB6G9YEHV3UcRiLzyX9GdnJc71snxhBY1wKTh9cLqh1eFyJVTwlV5zpVDfATqUF279692kMghKzA1q1b7+p+se6/B5b9B1A4fAgoFJD52/8N16/9Bj8bOWeJTgOZ+UoS2O1w/MiPc7/UMHc7NtcaZftJbWj6Oi74lUV9Eelz+SIycj9fRFar9hdN8wvCvwr+C8kA+SKShcXLS3qhVCv6LeXKfrP2kdSLYPq3YPFvmq9iWWx/KYkDMlXXH6sFLodFK+fdQTO8ThtCbjta6pxwSMnNNZCxyQVMSSqQ9j8UC+8MPK+9e0gVpwhBUu3a0NCAyNQU6n1ONAacemH+4rkRnB8cw2wsCYfdof1cbVYbYvH4VRWvIrbJMtlma0ur2uIvX2cxywX961EW+189/uqCa0ADYtkCUuks8olZtG7qwN6tPRTv7zCMTXK70Z7YKqiLpf18i4yBgUHkC/l5NyA5fufnhfl/jycqAv6+ifPwZpOY9q3H6dNf0++lcsX4jb6L5DVjmbwm8qWdhRs6dryeyvfbhby+iPdOp1OTneQ7W+bFEaU8lmvFp5z7xDI5TM3E4HPZ0LR5szqvSKsCeU9yk+1I5X1jYyPMU2YUigWdr6urw64d+/B00bNkm1J9H0lk9XxLEmKlAr9akYveW1v8mqQgQv7EXAaT8QwuTcQ1aUHOB1dbjL0T5BbOeWeSWU2qlYSFgMuNRr8TzX4HRfs1+ruzNDeHzJ/9MXJf+FeY/AF4Pvs0TFXcY/hmKc3OIPt3f1uZt//QD8Pkqd7vNWLM+CSE1M7vTgr4NUhXV9dqD4EQsgLt7Xffcsv+Hz+C1OEP6/38l76A4g//KMwtrah1zOF6uP/+U8j92+eBuTmYW1pWe0ikxmKzFpMApHL+ZqzlRVwvC/mZ/FJxvzKfLyxY9l/dl3K+l+QVq8myK6QUxtulkt9+xcpfxiSCfZ3051zo0XkzFbvJTB6xTAF+p/TztOmFTFb63hl4Xnv3ECFKqjhFCDp37pyK+R0dHdi2sQcBvxMucx7mbBJ2lwdT0Vm0tLZhenJcK+ClsrVc8SrIfVkmglk6k8bs7BwG+vv1sZuprr8Wi6tpZZyxRBo5iwstDWEU0gnYAjbcu2srGhvqb9t+ISvD2CS3G0mok+P0TKGI6emotsgQG3en0wGf36f92GOxGKwWK6Y8KZzLWrA5l4KtVMDDI8fxhXX7URz75pJtLv4ustltsNsdKlbncrnK95HH7dWkAel3fj0B//VWvt9utxQZu7ilSMKVfGfL8hvFZyyd0/dazOeQS6cRbm1Vy/xgXVDbnXi9HkyMTyCbzcLsNCNQF1B7fXmfkhTxzi8+hbeYv4Dn2/fiX7sfgsntwqZGL4aiKRXuNzR672hvVTm3k0TQcjun/KLe4nK6J0kEmuBpmj/XK7dvut2iupz7bW8NYF0wh75IApOxjIr504ms9peVivRqsKfN5AqanBFP5/U8WVoJBN12NAWcaLoNfXQX95TXJJ1Fbb7UIn5RX/fl6N5dSNwt35epzi9aLp+D/F8snq4mhvrd6XAg/62DWuwhBQ7ZT38Kju//EGqdjIj38bjeN3V0wvaud6/2kEgtxichpGZ+d1LAr0GeeuopPPnkk6s9DELIMr785S/jLW95y13dL9bde2C57wEgnYL9hz9C8X4RJosFdv4YI6sUm+TaqG2+3Qy3/cYXcKUKXsR9EfJ1Wr4AuKh3pNwXbCLYW81Xphaz2vXeSr96ucA4l8rpRcV6j10vZop96GpfDKxmeF579xABSoQoqb5cqbq00e9Se+TkyASclhIGRydht7swl0ijrdmn1vdl5L5YVQ8MDmhv+76+PqRSabg9bhXgy/bVt0q5mtZic2Djjr3InjmDuYkxpGwF7Nrcg67ODuzdu/e27heyMoxNcrsRsVUEdIfFjIsXr7TIkMrvUCiEsbExFaubmppURD928Tw2T6cqNvrPdN0Pa+c+pNOzGBoe0oSf8neRVN6LeH/ixHFMR6b1OTabTV08tm3fjpzVrVX4WWfxmgl5N1P5vhpuKTKVeVl+vfiUc6ZYaj5Roc7twPjCd3RsLqb7p1DIa6W9WObLtJAv6PaFXDaH1kwGLfH5fdd87qt4av3DeKCzDmNzGTT6HWgXcddznZO314GMPSlOK7nCvPMS5sV588I5nUwFEfM1wbNY0qTP4sJ9EfTtC+d8Nuu8a9PtQM4Dd7XXqXAvQn4klsF4LIOpREaF/LVqJy9JHvKexCZfBPsNjR51mmoJOFF3vRP0ayCfQ9l1q9J2q1RSgV0Sai0LLlpyPi2flX6eZVetG2x3ce93mZZbfpVKRU0IKP8uKCcGyHYti0X+ZVPzCqJ/eSy3IxHESL87TQ4H7B/6IWT+22/rfPYf/h7297wfJp8PtUpxdAS5z3y6Mu/4yE/AZF2bcUzWdnwSQmrndycFfEIIqXFcv/27gNtNgYkQUjXIBTW7df5irPsuViHNpnJw2axaWRXyONZMv1xCbhYRoa4lRJUr9DOJGKITIyilcjCZfbB7WuCrb0VDc6teIJcL3CJuiTD28rdeRn//gIpwW7ZsVtvq61np34hYKoPpeBbrOlvUPePenVtx+lgcm9evw949u1fFzpoQcvuQ46rDZkE8nam4gMzMzCCVSqmoXB+ux6ZNm+Bxe9CbySIXncSrDZvw5Y579PkzvvWYm/wahoaGNFlIqunaWtv0e0cq70W8b2hswM6du5DNZirfR52btiCeyWEubdGWIa+18n013VJk+fWYS+cRz867DEiy0+joMA4fOoyJyUndF8FgCOva2+H3+9X9oLe3T4V9EcXlvb5xNgnMzPeEfqllB/J2J7a1B3W+Sa3zb/8ZmQjIItyLO5Ocf9UvnHuV2yiZF1XbC1rNXZoXiHW64NKUzRW1BZOcy8UyRVV85RxSWiU5bObXLcyKE1PQbcNELKPW+pF4FhOxNKbiWU18866BfrPl/vZScS+fufSzl4p7+Wzb6ly3dM6rCbYLgn3ZMUFdsCxmuGwWWOzzTlgWy8J04bZcOL/e51JO1C27L5SFeplRh4ZKQu8VAV9F/AWBX5eVn79ofXV1KJUdAa64AcyvJ2O7Uum/2AFAZxe5AVSWL8yXW3vlikAmX9D3UF5WXqe8TKeV+YXpHUoWtn37O5H95N+jNDQIxGLI/uMn4PiRH0OtkvnjPwAWHFrMO3bB+ujjqz0kQgghVY7xzxIJucaPS1M6z31DqopYFpiK3d0LPPNYgfgVW9taxnT0EEq79gAWHh7JdWLzLhZT3+ilVrpYY7rBgpUu9FTuLboYVH588cWllS4mVeaX9JWvnYpzuXisdrMlIOC2w+e0IuS231GLWEKMXqG/adNGTE5OwRcMw1NXj3BzKxxuHyZjWU2ucXl92L59u4pjYs/c0dmJ1tYWOB1OXL58eYnd/o2Qi+hSdSnVsUWTFT63A4X4NDzuMEqlNHZu2ah98Q4cOHBH3z8h5M7jXBBVTRabCspSFe7xeDE8PDRfYW4yqQgvfdnzAT9+eefDOL7+SkVOwhZE+8btaA55KuK8OH7ItGybL+J9KBTUqvLy95EIrCK2ilW43F/JSv9mKt+N4JayEiKmynsTMTzstcHqqoPf54fL7UJXVyfC4XpYrRZYrVa0t7Xr964kTkgLg1QypZXr+yJTle09t24vdrUHkM4X1Tp/o1jn36aq9vK5lzgeicDrtlvhstnhsVu1B/2ttiyS91JuxVRux1SuBhdBfy6dUxFZEkfk/++1nt/JebWI3SLYj82mMRS1YyqewfhsGlNmky6X8RsNSXKQ/vZScW+3mNRhShISWupcWnF/s05VuUJRP7dMTirfS3BYLBrLXoe4HphVwLcvTMutrMrOCXcTSU6oCPiL7PqvKfhX7i9U+c/nf1x5bMHkf7EbwGLB/0qSwfyCTEEcDgrz80IlAaE8O3+nPF9myfw1fvut8NCV5df57Wb+4Idh/2+/rvcz//SPiL3tO4BgCLWG+Ztfg+1rz1fm0x/+caR4Ha2mWL1rtoSQWsZ4Z4fkjiOWcmsVOYmX/rNlu1tCqomO5jACrjtjK0huTPH4MWR//qMwbd4K28//MswbN3O3kVWLzcpFm+uuc5PbWn6BZ9EFoeXbKttLVp5Xvmi0cHGp8vxy//hFjy25CLVgQVm2mbzKhnKhcmTeolIu0F15vLzMyKhgmC0gkS3o2D0OG9x2i4r3a9UOda2yls9ra6VCX+JFYiWZzSOTLSKdn6+YzFpd6OjZgmzRBJfDrvbVUs0pdtaL7favZbWbkcq9/Lzdrlzw94lV8eYuuItxTAwPYujy+ZuuPCW3H8YmuROIeOq0mbGuvRXFVAwT4yPI5/IqUjfUN6C7uwsd6zpw9NgxtXjfsr0HEyhiLLUgMppMiPrX44F1joo4L24fZccPsc2XanMR7xd/H8k5isculf85zNotKwr4r7Xy/W67pawUnyJSi8OAy26uCO0Op1MdDdavXw+b3VZJaJD2A7K/Ozs71flA3FTCsRzq0zF93qzdg6MNm/Dueo/axEuV9muxVb8WYvEv52CyTRHvPQ6LivevVeyVc06ttLdalojNIuTL60g1tNwXMT+anE/ykP9BqRR/LWK+/C+11rlUzB+dTWFIKvITWYzOpGC3WhDy2g1RkS/7QER7Ee9lPO1Bp7pLSbW9JBuUXQ2uhyREqGifL+o5vuxjaSsg8SO3smBvsxjn3F9bL7yObO1yAsC1hfpFdv0ruARsam9AS8B10wL+4t9wK/72u+p34NUsfu5KlN7+dqQ//QmULl+CKZ2C+7P/APtHfxq1gn4+yQQyf/FHlWWWd7wb/gP7V3Vc5O7Da7akFridCZd3i6YqvyZkKt3oSE1uif375w/ghw8f5p67gz8k+F9LyJ2hlM8j9vTTSB89iobf+A3D/JC+05SyWQy+773IXb6s8543vRnNf/Inqz0sUqPclHh/C2dvi9ddvO1rXfhZLuCXn1e+uFRet3wBavGFpXJP+dLiC1bXsaFc2nfyyn1hvpfk/IW0cr9LmS9boc7Pm+5qBZKcg8jFSKn2lR68bodVLx57nVa9sF8r35mEvFbENlfiR0SRdK6I8akIjp86jZGRMSTSae0d3dbcjO3btiJQF7iSVFS+6L1gf6wX/Bf6Fct9sTgWgUEElenpae1FfbOVp4QQYxOJRJbEdH3rOmTMLkSmZzA7Oaoi/KVLFzX2d2zfgXQmjYMvHcSp06exY/t2mNbfjy8MXRFngw7gQ52zKtRLNblYwss2Muk05mJzmJubQzqVVvFe7PWlQl8Efvk+kip8ESCb/c4Vq6WXj3UtfP+IQD02k8ZUIot6r70izJ44fgKnz5zW9xEOhTWhodwOQPaPiPcnTp7Q/f6elBlPjJ/Vxz7f/SCeeuS78eTeNmxq8mFPR91tuRgs+19aFckxIOhyIOix3ZWkSTnuZBaEaElAS2ev3Jc95dSEjiuJD7eK2P+PzEhFflIFc7nJ8U7cnAJu210915VzcHGVEtFeXG3q3Dattpe2Ea11IuDbb3iuK9tIa9KeVJHPt71wLrQicC0I9w6rmefMd5BrivmvUcAXYs8+i7Gf/Em9b7Lb0fmFL8Da3Ixqp7xrpv/sTxH9X/9L75tDIXR8/vOwBG691RMhhBgdIyXVVRP7X4dmvPppneSuc/DgQdx///1rds/frEUXIWuN1Y7NYjqN3u94D7K9vTrvf+Rh+N/2NtQCk//rbyrivdntRssv/38qDBBihNhcq5RWFOmvtqEUYbxyv7xuuTfpoudIv9KsPl6cny/OC3uWxUJ/WexftOxWq/pLi143t9CbU6p8F4uG2mPVYYHPYWOf+1WG8bm2kGpFn9ycNhXzg55mhDw2XO6rQyqdhdlqQ4sKaoH5JyxqzSFIVZzddsVqV0QAub+48vJGlafk7sDYJLcDEcSPHDmiVe3SX16q2lsj02jZsB0Ojxc7W3bqelIlL2LzwOCACvCDg4NIpZLo7+/HtlAjzNggSiw6Y+PoDbSif66AzY1+Feylorws2IuYL6K+VJ/LNqWffbk6X84jJFFIqvDn7BYVI5dXfa+V75/F8SmieCyTh9s+b11eRt67VNdLqwGpvC8nNMh+kH0mgn4oFEIo3ISHnv9S5XnPte/Dlla/Vml3hT23RbyXc75oMqvbEgv3sNexogvCnUA+YxGhyz3e0wtJaJKMpkJ+rqCiu5xr6nq2W0volPckLgWtAanIT6u9/nQyi2gii8lYRkX0oMd+R6+DibvATCqn/wtyTJXXbA+60OhzqnB/M4kSkuCqTjv5kh6bxRVH3KncNiuc9vnWF+TuHDuXtEm7qX/FG69U9+Y3YWbXLqSPH9fih+j/+B9o/Z3fRq3Q8EMfBuJxRP/xH9H8Cz8PV7j2WggQntsSYlQOVvk1Wwr4Ncj4+PhqD4EQYsDYNDud8Dz0UEXAH/+d/wrPG94Ai9eLaiZz+TIifzmfTS00/NRPwdbSsqpjIsZitWNzrSIXjyx6PejWs3fLVbbz4v7CtIirls0vLyFfTgpYWC9XEreeZT0sVfy7clFr+dBEsJfty6JyAoDFPC8SysXHxaKhVFrxQqQxYHxWgZjf3oye9uYlThcyFUzLBXyTaUlVgIh7J9dYtWutwNgktwOpZhfxXtw5RFCWvvIjQ4OwuANo6tqk1eNyPC6LzS9/62X09w/A4/VgU91m5PM5DJw5gR+fO4F7B0/Cm0vhe5/4VQyZW7DFNIdTp07p94n0eM/n8yr+i4C/c9d8YsByRKAVkVJs3N32PAIu25qOTxGfpdJa9qMI7ouRxAVxHwgEAupQUE5oEOQca2hoCLOzc2jJe+HLpXT5mDuIgaYuPN7kQ4PPibD39VvnyzFBxGxxPapziXh/Z8XsG1G2f6+TfuUqWs+L+SrqZ/OIpfMq4sv/yq2MU46J60JutAVdiMSzGJlJ6VQSFy5PJnRb0qpJkkjkPPT1VMcVy62gMnltcSMJdfK/3BXyqHgv9v7y/yDnvDdsKbXwPyQn0PK+A04R7C23ZZy1iFGPnfI5Nvynj2Lwwz+k87Of+xzq3vseuBcqCqsdi8+H5l/5ZQS/6wOwb9iw2sMhq4RR45OQWme8ymOTAj4hhJAK8qNs7ovPoDA5hfzkJKb+7M/Q9Iu/WLV7qFQsYvRXfxWl3EI/w127EPye717tYRFS85T7T96ouKpcwZ+/htBfrv7Xyn6dX9oqYLFjZLliv2LZrwK+ab4/50KVLy9CEnJnURcNs+U1V+ZK/+l9+/ZRxCekSpDkHIlvEY7tdjsaGhq0vzwKWThsFmRyRRXwy2KzVIsnE0l0dHbC7/NhLhbDQF8f7u19CfXpOd3mI8Ov4qu2ezD8zCcxNTGO1pZWdHZ1omUhgVfE6ush1cj9Y1O4cGYMPkseLqfTcMlDN2vlLxXXw+NTGB8dwWApf5XrgEzL92eiM+psIPtHzoe2b98Of10Q7V/4WmV7z7fvVdv8Zr8LnWH36z5vksSCmaQkStjhd1kR9txc7/W7gby3spgv55Yi5CeyebXYT+bmbejl7bsXxPyb3ReSqCbiudzm0jmMzqQRiWc0aUScEkZmU3qOKwK5VLiL8C+JbVLJv3zflM+TNTmuOG9tL2MU8V7GLe2fGn0O+J1WTbho9Mv9GyelyPbmhfv8fGJBudrePt9SSsZEqg/Pgw/C+8Y3Iv7ss3AfOABLsPaq0B0bN672EAghhNQYFPAJIYQsySxu+vlfwMjP/IzOT3/ikwi8+91wbt1alXtp5rOfRerQQv8ZqxUtv/kbMFlo70fIWkEuhlrloqXl1iz9y7q9CvqQqvsrgj1FekLWVmVuLiciiUnv9/X16f03v/nNqz08QshtQMRnSc6RynsR72Uq8z63U/tqTycy2pNeEKF529ZtledJ33aT2YRNWzaj5HUDn/mUPvaWgVfwTNf9uJRwIB+JIJ/L63KpvhfxWkTs65GMzeHS+XOYGBuFJZdAvc9pqOShm01uEicBEe9Pnj6L2NQIMun5NgLiZCDJEGXhvizenzx5UhMkyu0GxE7f174D94xecTL7+rp9eGtPgwrBQffrq74XkXg2mUOd267bCrpthj1Hk3F5HFa9iWOAVKSrUC6V+QvCu1SnlwX3m0XEdH+zDYWiF3OpnFrri11/PD3vAiFJA/lCTts95QslrYKX82JBWk9Jgqt1ocWUTEW0lyQId3C+lY0kRgRcVt3HN5MYIZX6UrGfzhXhtJoRkm1Jtb3TesutA8jaQz5fqUJPvOlNCLznO6r+85YiD5NtbbqsEEIIqR4o4NcgTz755GoPgRBi4Nj0f/vbMfOZzyB58KD2ihz7L7+Bzn/8B5huQ/9CIyEOAxP//fcr8+EPfQjOzZtXdUzEmBglNsnqWfoT48L4rF2kslTEPEnKmZ6eVqFKRCoRqPbu3WsIIa2WYWyS24FUjktcixgtlfciRnd0dGBTz3rkrPM96KX3dtnqu2ylf+HCBZw+fRoWi0Ur6y1vfguKn/s0zMUCtk33oz02gZHND8E624tEMoH+gX6t1q+rq1MhXwTrxQL2YqQKPToxApPNifb2ZuTnIjq+YDBoiO+dldoOLB/fO9/5LozH0jjfO4DpyVGYi3ntWTI8PKzW+HLO9NDDDy15zyLeS2KEOBZEpiM6/9URH5I9D+OxoaOI2dxI1IcRHbmMhD2EGXfnNffhzTCTnLfNFxE75Hn9Vvx3C6lID7jN6hggAr4I7alMAclcQQV4qZQX0VvE9JtFxPWgx663ngZo5Xs0mdMkAfn/Fyt/cSsQgV3E/PJzRLSXhAFxkRJhXxIMxCpfbrdi7y/blqSEXLGoVfYNXgfcjrJNPpPfa+nYKa0GxTq/Fhj+mZ9VAb/pF34e1vr61R4OMQBGj09CapUnqzw2KeDXIFKZ0tXVtdrDIIQYNDY1s/pXfwWXn3w3kMshdeyYVqoH3/9+VBNjv/M7KM7NW2naOjpQ/2MfWe0hEYNilNgkhFwN47N2ESEpkUhgbGwMoVAIXq9XRf2ydfRiIe1m7aTJ7YOxSW4HEqdSOS7i8/L4FYFX7PPT+YIK+GWLdxGgT5w8gXQ6revLd8PgXAzWvffAf/hgpQr/49veBqvHj2I8putKMWmxWMTQ8JAmBi2vQi8jFvLZdBotHS0owAZPsB6jved1fEZuO7B4fCfOX4Ir2IRsNof4TESXSaJEKpXSvvayv8Uiv/z+5T1L5b2I9za7DXa7Ay+eHsAZSyPObH8HPr7t7QilY3BGenExOgvvbANyydg19+GNEOt4sZIXoXktiffLf1OL2C23rKu40G9+vipfprF0Xq31pXL9VtsCSGKD3JYjAr6I+YII9iLSy358LUgMSKW9jFXw2K0I2u0q2ksiwK0kAJCbh8dOYzD35S8j9sUv6v3417+Oni/8O6yh2msZQJbC+CTEmPRV+TVbnnHVIK+++upqD4EQYvDYdKxfj/CHP1SZn/z9P0A+GkW1kDh4ELEvPFOZb/kvvw6z07mqYyLGxUixSQhZCuOzdimLeCLix+NxFd42bNgAj8ezRKgq20nL/8riqSwndw7GJrldSJwfOHAADz30kE7LyTfaf9xqQSZXrFi8Hzp0CF/7+tf0Qp5U0nvcHv1+kIr85H33Vbb5psHDMJdKmAtsQDqd0e8PsYS///4HVPSX6nJJBlgJsdgXC/nE7DQSmRxGJiKwOj36PKO1Hchms5W2A+XxpXMFvPLqKbVhFwt0Eftlf5nNZv3+dLtdKuYvfv/ynmUfHT12DK+88gq++tWv4EwmWHm8ZDIjYbeizpxC0JpHLB6/7j68HpmcWLQXUOeat843Ss/714MkmEj1fGvAhWa/E00+l74/sbmfimcQTWa1yv31ItX2ZSt/SW55LeJ9vlhELJ3DZCyjyQZitd8kYw44dfxit0/x/s6x1o6dYjMf+eu/xtwzV66trHVyw8MY/aVfrsz73vhGivdkTcYnIbXCq1UemxTwCSGErEj9j/wIbG1ter8wO4uJ379iN7/Wcd9zz3zFvVR2PPkkPA88sNpDIoQQQsgtICKeVHf29PTo/c7OTrW/lmrTxULaYjvpzZs361TmZTkhZO2iAr59/pJWb/+ACsYiHIsQLdb5It5L5Xgum0NvXy+OWm2Iu7y6fjg9h/0T52Hu3D8vyDudaG5pRigURDgU1mpzee5KSGW7iP0z0SiOvvJNrWaPJrLw+vwwSnKTtBkQVwGpvJepzMtyqaqeSeaQygN9F84iGo0glZSq+1lNhhKRXtYVwX/x+/f5fEhn0hjo78dLL72Ei0MTmHG1Lnldd2wIHfU+oJCFx+O+7j68nng8m86ruF3nsVWdPbu0fBBBvDngREudU6eNXqeK7VKRPxXLqOW+VNLfTeT/IpUtYDqRRSSelYwMTe4Q4b554SatDGT8hJTJ9vWh973vw8Tv/wHGfvO39JrRWkcSEoZ/+meuODW2tqqFPiGEELJa0EKfEELIiphdLjT98i9h6CM/pvOJl15CIR6HxTt/4WstY7JY0PDRj6qQ79y+fbWHQwghhJDXgPS6F+FBBHmpIrXZbBWh6lbspAkhaxOpwJdbLDVv8S7CsRAKhZFMJhCuD2NsfEyXnb90GeHWdtx76WzFRv+Ve78PzVv2oTQzrJXq09NRZLMZrbAXYX8lxBK+vb0dl3svw2ExIVkoIJkv4dSFPjTUh1e9Pcf12g7MJnMYGpuEdEm/fOEsMum0JjSLJb7L5UJbWzusVgusVuuS9z88PIxIZBoWq0VblkQtXWhMzmDCs2ApnU2iNHkZ0zkTggEfEokkmpoar7kPV6KcXOCxW+B32VTorvoEFJsFde6SivZJsdfPzrsPTCezWj0v9voOmxlW8+2vvZL9nc3PW+5Lpb1U1Yvdv9M2P3Xb58dHyLWw1NdXRPtCJIKJP/wjdTZcy0z+6Z9qC0nFYkHrH/w+LIHAag+LEEJIDUMBvwa5b5F1HCHEOBgxNn2PPw7fE0/A3t6G+o98BGaPB9UEK+/JWo1NQsg8jM/a5npC1Up20iLeL7eTJncGxia5G0gPcRE4TRariu7j4xOoC9RhdGxUHx8ZGdWqYYn3fD6Hsy2tFQH//rFT8GUTcG57HN7zX1TL/WPHjqqrh1TYS9LPtYjFYrpNcfUIBkMYmIji0sAwGsJ1eOSB1RXwBfkOXJ5IIGLtXCqHc32DKKbicDodaGtthdVmFTV3/juxVFLxfvH7l/YE586fw8TEBAIBP9LZPDaWHPjtL/8OjjRswtPrH8IxixmFuXFEixa4XXb4vN4b7sPlSAW6Vfve2xFyr82+968FaREQcNngd1pVTE8uiPgiqqezBcQzWV1HbPhtZjNsVtNrFvSlsl9eQ4X7QhE2i0mr/+s9Do0lt8MKt83CSvtVZC0dO6WwQwo+hn/yozo/88//jMC73gn3/v1Yi8S//g1E/vdfV+Ybf+pjcO/du6pjIsZiLcUnIbXEfVUemxTwa5AAswcJMSRGjc22P/pDmF5D/zyjkT57Fo6NG7X6npBqiE1CCOOTrCxULUYEfennLFX6Unkv4v3yKn1y++Gxk9wNHFazVgk3t7aimI4hmUhicnJC7fNFkG5qaoLFbEFkOoKxsTH0ZzJ4yFOHnsQMbMUCHh88is+vfwDrGpqQTcURDtdj29ZtKjxLpf21EGt4qfhvbWmFzW5DW30QZ3r7EYmnVRwVsdVISLW19FmfTedgKuSRSsbR1dmlY+9Y16HJC1JZ39OzQavmF79/6WMv36Futwsejwdj9ja8+9jL+ti+yfMY8DUgvrEHnnWNaG1pwv79+1Efrr/hPlze916E5XqvA0FPbVq1y+/tclW+fF7p3HxlvAr5ucK8+J4rIJYpQiwUbFapzDdppb5p4fm62+RWAgrFEvKlkk6Lcr9Y0nUlZlx2K+osZk1+cdgsWulvtP/ZWmWtHTt9b34zvG98I+LPPqvzYj/f/dnPwLrKTiS3Sm58AiM/f8Uq3/Pwwwh96EOrOiZiPNZafBJSKwSqPDZ5hlaDfOlLX1rtIRBC1lBsVoN4n7l8GX3f870Y+KEfQn5qarWHQ9YYRo1NQgjjk9x8lf7u3buXTFfb5rra4bGT3E3RsykcxMbN23DgwAG88Y1vxGOPPYb3v//9eM93vAcH7jmgwv7FixcxOjKKL+dzGHKH8Jc7n8RX1+1HyWTBybhLRexSsXhTwrOI3FLxL4kBuWwOc7PT8DodyMGmQrkIsEYilsmrTXuuUESd247m5ubK2GUq4r0kLhw4sB87d+1c8v4lWaGc+FQoFhHNB/HA6KnK40c27MXOrmbcd+8BfNtbvw2PP/74Vdu4HrKvpPpebPPr3DatCK915P9aKuJDHjtaA0601bnQUudCs9z8LoQ9Dv2/l/WKRag4X67eT2QKOpVlloX4kHYEDV4nmgNyc6G1zonWoAuNfqdW/1O8Nw5r7dgp/4PNv/LLMPv9Op8fG8PwT/1nlPJ5rBVKhQJGfu7nUJie1nlrQwNaf/e/wXQHWleQtc1ai09CaoUvVXlssgKfEELIrVdw/OM/wtGzAZ77jW9TU0ylMPyfPoZSMonkSwcx/LGfQucnP7HawyKEEEKIQar0CSFrl/k+4RbkPF4VjpcjwvxcbE5FfLPFjK/YHfh814Mo9ryhsk6qcQdmjh3BpUuXcOrUKTz08EPXfU0R+WdnZzE8MozLly+rmL++vRVNza0qRkuVswjlRkBE+9lkTu3z/S4rbB0dGJ8Y17Yj5bFfz+4+k04jmUzq+tOmAB4aPg1bqaCPnQl2wNHkRdBRvGXL/DLS910s4j12K7wOXqK8XmV+GanGzxaKKtKXtCC/hGIJKJZkOl9pL+K9xSJ2+ybdv2K7L1NCbje2lha0/f5/x+CP/Ki24Uh+61uY+IM/RNPP/9ya2NnTn/gEki/Pu4rAZELrf//va85BgBBCSPXCs2NCCCE3TSGewNiv/irm/v3fYamvR/fnPgtbY6Ohkw3GfvO3kLlwQedNdrv2aSOEEEIIIYSsfZy2eRv9mWRW7cKXi5TZXFb7uotdfLEofeCTyJ1/EY6Nj8BkWqiw9IRha9qA8fFxDA0P3fA1pbp8x44datkpFepl23mP34/pRBZ2i/kq0XU1EOv0SDyr4r1UWUt1u2OhMl4q7hePfaWK+ZnojCY/pJIpTExO4mKwEx/u/3zl8Ze3PIj7t3aiJ+y6Jcv8yvik+j6T14pyqQSvBue3u4HVYtYbIUbB+8gjqP/Jn8DUn/6Zzk9//ONw7dwB/9vfDqNT9973InXsVcSeeQb1P/Zja6JIhRBCSO1AAb8G6ezsXO0hEELWaGwWEwkkFrKTC1NTGPnPP42O//NxmKzGPJxM/cVfYPZzn6vMN/3KL8O5ZcuqjomsPdZCbBJSqzA+CTEmjE1yVyuUrWY4rRbtEe5eVsUdnY7CZrOhrq4OuVwec7OziEfHYR48CXvHrsp6k75NSA+dxYXzF/DiN16Ew+m8rrgty1Za7nFYMZPKwmY1odHnvKtVz5FIBL29vVotb7fb4W9sR8nhQa5YVDv2Mm1tbdi2bdsNtzc4OKgOBt3ru+EItSDbm8K6+KQ+lrQ6EHjHO3DvtkZExkdw8dKl6+6vlRBbf3FQkH0mlvGE1Dpr+dhZ/6M/ivTJU4g/+6zOj/zSL8O+YQOcmzbByFh8PrT90R8i9va3wfemN632cIiBWcvxSUg101nlsWlMxYXcUfbs2cM9TIgBWQuxaWtqVHu0gQ//kJR0IHnoECb/5E/Q+NM/DaMR+Zu/wdSf/XllPvDku1D3vvet6pjI2mQtxCYhtQrjkxBjwtgkdxMRf512CxKZPNyOpY8FQ0HU19cjmUwhviA+OxwOFHsPAh27sGFmCI3JKF5s3obpQ2kcPXZUq807OzvQ3t6uVvlSbX+tCnURuZdXskdyGcwkcmplXu913BURX8T7I0eOYGBgQC3vS3YP6pqm0dGzGd2tDTqWMjcj3gvyvtKpNBoaG/HcZArv6P9C5bEXO/ai1WfCq0e+hdOnT2uLArfHrdt+4P4Hbiji54tFpLNF3T9SfU8IWdvHTukZL73j+973fmT7++HYuFHF8bWSCOZ/61tXexjE4Kzl+CSkmtlT5bFJz6Ua5Pnnn1/tIRBC1nBseh54AA0f/cnKfOR//zVmn3oKRmL6k/+Aif/++5V5z0MPofk3f5O2jKSqY5OQWoTxSYgxYWySu4lU30vfeen3HolEceL4CRw6dFindpsdW7dsRXNzExrq61XMD9eHsc00hz987o/wZ8//MX7y2GdgLxVh3fiwCvajoyM6zefz2udeRPqVxPuTJ0/i9JnTOLUwlXlZHvTYkSkU1E5/Kp5Ra/87jVTei3jvdDrRvn4TilYneofGEJ8auyqB4ODBgze1TUlKcLqcOHPhMkbmLHh45HjlseMbduDFr3we//Zv/4azZ84iFo9hYmIChw8dxqlTp2647Vg6D4/DAp/Tqvb+hJC1f+wUwb79z/8MwQ9+EJ2f/ARsLS0wGunz5zH1l3+p7RYJqaX4JKRaeb7KY5MV+DWI/BAlhBiPtRSb4R/+YSSPHEHia1/X+ZFf+EUUs1kE3//+1R4aov/yLxj/rd+qzLvvvVd/RJrtV2wjCanW2CSk1mB8EmJMGJvkbmI2m7TffDoew8XzZzE1PqKV4yI++/1+NLc0Yzo6rT3h06mUVoomY3OoH+rX59dlE3jD8HE813kA/plTaj8/MyMCfgH5XF4r0Zcjor6I+1LN39rSish0ROcDgQB2BusQdNsRTWQRTWYh8rlUmss47xRimy+V9w0t7UiVrHD6Q5id7UU+n7tq3VgsdlPbFEcBieXn+lJ4bOg4HMW8Lr8UaMVIfg6RQ9/SFgWBujp4fV597+JeMDQ8dP2xyn4tlBB0W+Fn9T0hVXXslMr75l/+JRiR7MAABj78YRQmp5CfmETTL/+SHg8IqZX4JKQama3y2KSATwgh5JaRHzltv/d76P++70fm/HmgVMLYr/wqSpksQh/83lXbo7Fnn8PYr/5aZd61Zw/a/+IvYHa5Vm1MhBBCCCGEkDuL227B5MQo+ofHEPJcEdWlh3t7Wzvuv+9+BINBjIyMIhabQy6XxQu+Orxvekyf/87eb+DZjv1I+jrgK06r8D09HUFdoA4D/fNC/2KbfBH1p6en4XZ7MDszKx7MSCYTFbFfqt6lEl9FfMwvez0ifrm/vVS5T01NqZNAY2Mjuru7EQ6HNZHA5nSjfywCmy+E5Nw0vG6njnm51X8ZWS7V8mXBXfbT9u3bK/b3Mt22fTsGv5XCj/V/pvK8F7t2Ym74ElLJFIqlIlLJJIaHh5HL5WA2W26q+t7ntKl4fzfaCxBCVhepdp97+mn4nngCZseyPid3idz4BAY+NC/eC+IiGfqB74e9o2NVxkMIIYTcDBTwaxD5YUcIMR5rLTYtdXXo+Lv/g8Ef+o9IL9gkSuV7KZNG+MMfXpUxuQ/sh2vXLqRefRXObduw7q/+Fyxez6qMhVQPay02CaklGJ+EGBPGJlkNG33ks0im0+hpb4LNbkM4FMbly5fhcDpx4MB+FadFsD5//jx8Xh/6fD7kXpmArVTEluggNkUHcLl1L3J9zyCdTqOvr0/Xc7pcGJ8YRygkVe2z2LFjBzLpNCJTEfTF+7RiP5vN6rqyvExZxBcrfZMpBynFr/fcuohf7m8vveYvXLiAeDwOj8eDTZs2IRqNYt++fWhp70RgJIILA2MoRPvg9zjQ1toGn8+n1v7iDlB2JZD90tfbh0OHD+HrX/+6bt9itmhywlxsTnvYCyL6Hx5OYDZnwf/Y/R480XcQ94yfwQmfB6WZXrS3tyM6E0Vsbt4+X0S63bt2ayLAtUhm85LrMG+f7+AlSUJq4dgpbRcn//AP4f6//w/tf/7nd/0aTeZyL4Z+4ieQG5pPVjI5HFj3l/+T4j25Jao1PglZ6ziqPDZ5tlyDPPHEE6s9BEJIlcSmNRhEx8f/FoM//CNIHTumy6b//hOoe//7YfH77/p45DXX/c3fYOL3fg8NP/WxVRkDqT7WYmwSUiswPgkxJoxNcrcRUdzndsLncmBsahqtDWGtwBfBenHVuYjMbo9bxepBkwlHG1px78S8qPPOyy/iD/Z9F5yhFrQGXNrXfWR0BFaLVa33RahOJpJqFV/GJGr0ouly5kV8G6KJK1b2IbcdVov5htX2YosvFyVnZma0v724CdhsNrhcLl0u8/39A7B6Ali/aTva1m+G1eWHDfmKW8BKVv9yG/n6CA4dOozR0RFNQBCGhoZw+PAR+H1+3U/yvKeHA6J24VS4W291qUk0TByE5CCE68PweD3o7++fT2Dw+bB/IVFiJWSb8XQedW47Ai7bNfcZIbVKNR475TqRiPdC8uBBDPzgD2qhhVxLuhvMPfNFjP7SL6GYSMwvsFrR9id/DPc999yV1yfVQzXGJyHVwBNVHpsU8GuQs2fPYsuWLas9DEJIlcSmiuZ//dcY+shHkLl8GR0f//hdE85zY2OwhsMw2WxXxuP1oOU3/stdeX1SG6zV2CSkFmB8EmJMGJtkNdjc04XhySj6hsa08r5YLMJitWAqMoUTx0+o4C0V7LF4HG63S630Xwr4cO/E/PMfHT6Gv97xTuQ77kWdeRBDw8MYGx1FvpBXAb2hsUGF8GRqXsTP5rLo6uxSQb1soS/V/suxms0VEb9QKCGbL85byDutV4nY5Wp7eT3pae92u7VnvTgCSNX95OQkOjo6MDo6CpfHi8l4Br65NAKJLJrqQ1jf1rhkexcvXdLKexHvy64Esg1xF5AWASLeixW/uAlMTk0hncloe7RCsYDJvAsT3qUiV37sFKLj/ZD8g9GRUQTqAqgP12u1/z333qPV+2UL/uUkswXYLWZ4HVa47bwcSUgtHDudu3ej4WMfw+Qf/7HOp0+cQP8H/wM6/uavYWtuvmOvW8rlMPH7f4Dpv/u7yjKpvG/93f8G32OP3bHXJdVLNcYnIdXA2SqPzWun/JKq5dy5c6s9BEJIlcWmiOaSRd35yU/Asb77qkqLO8Hcl7+My+96EpN/8id3ZPuEVENsElLtMD4JMSaMTbIatDU1YN/unejZuBFtHR0q3hfyBQz0D+D0mdM4euwozpw9g9mZGa02T6XSOJUroL9uXvS2FQv4tv6XMVAM4psvfwuXLl3E6NgoxsfGdSri/6WLl/DywZfVhl+q8WfnZtHQ2IhAwK8W+4ur/ZeL+CGPHUWUMBFLYzKWwfhcBulcYcl6Unkv4r3T6cTmzZt1KqJ+IpHQm8Vi0cdLVgcm5rIo2twomqyaIOBZwZJexiMuBFJ1n8vmdOrz+2C1WmE2mfW32ujoGKamptQGf2hwEAdfPohDhw7hTH5pMoA5MQVfZgJOuw02qw3xRFzHJoL9o489ine9813XFO/ldRKZPDwOG/yuK8nXhJDqPnZKklL9j/4Imn/91zTRScheuoS+7/4exJ597o5cL8qNj6P/+39giXhvW7cOXf/0KfirvFKT3DmqMT4JqQbOVXlsUsAnhBByew4oYuXYvVS8F8Qubfy//lcU4guWZa+TYiaDsd/4TQz/5EdRnJtD5K//BvGvf+O2bJsQQgghhBCydoWi1sZ67N25Hf5ASKvlg6Eg1q9fr/dF+Bahei4WQ6FQ0Ar8VDKFg+FQZRvf3vsSiiUzhm3rtNe8JABIpb2I/VIFL7b22VxOK9qlIn9yYhLHjh3V5VKFLrb110Ls9MU6vs5lRzydw2QsjfHZNCLxDHKFoq4j25HK+4aGBq2Ol6lU3ofDYXh9fqRyRcxkipjLAmZPAC3NLdixoRO2a1jyy3hkXLJdcSWQqSA291LJL+9JbPRF2BfEtWAmOoPJtBlFXyveffFrcOdS848NHkOTz6H7QxILPG4P6urq0NTUpGO8HqlcQcfodljgtFlew6dLCFnLBL/ru9D2B78PLLgn5kdHMfRjP4bBH/qPyFy8eFtfa+xXfw2pI0cq8943vQndn/0MnFu33tbXIYQQQu409KwihBByx0ifO4fI334cKBS091jTL/4ifN/21tfU7zA3PoGZf/kXzHz608hPTFw5kLW2wOy9/gUjQgghhBBCSPXjslngsFkQS2evso6XqnGp9hQr/eHhOe3bLoL2kYYGvN3hhi+TRGNqBvePncaLGx9G6tRXKoK33SF96626LbPZpLb5HZ2dKt6LEL5t6zYVy69Vgb4Yu9WMsNeulvJTiSxS+QISmQKsFhOSJStMDg+GxibR1FiPickpeEKNaG5dB5fXB3/bBkxOz8AbqMO6xjB6ujqu+5ry2I4dO9TyP5PNakX+2PgYfF4fmlua0T/Qj+npae1fL+9PfqdNR6dR6n4Abxw8gh85+TT+w9kv4lNdD+Az0/0YiGS1cj+VSqGruwvbtm1X9wHZp4ODg9cci7w/qbz3OXkZkpBaxf/2t8Ps82P4Z34GxdlZXZZ48UVcfvLdCH73d6Pp534Wpmu4mNwKTb/yK0geO4ZiLIbG//xTCH34w6/pGhQhhBCy2vDMuQZ59NFHV3sIhJAaic3Z//eUivdCfnwcwx/7GFx798L72GPwPPgAnNu2wWS5dgWGXGBLHjyI6Kf+CbGvfrWyrTK+t7wZLb/1W7AEAnf8vZDapRpjk5BqgfFJiDFhbJLVwmkzq4hvs9lgF/v56YiK9zINhUNq+y5V9yJoi+isFeiRCA41tuDxwUu6jZ6ZYXyzdSfs6+9H8vhXYTabYYJJxXv5fSLV+FLNPzs3pxXwu3ftxs5dO29pnCImieW9w2ZGPJ3HVCYNMZJ2Bpvgrp/BxNgohqYuw+F0oqG5DY1dG7UCv3OjGQ6LGU67BeabFKREVJebVNafOnUKY2NjapcvtLS0qBuBOA1IVX1ffx+yFhc8Xfvwnuf+SNdx5zPIz40jFx1D2uuG3++H1+dFV1cXWltb4HQ456v7s9kVX1/aBJjNgMduhdvOy5CE1PKx0/uGh9HzzBcw9Wd/hug//bPYfuh1nuzly5Xq/JslH4kg+o+fgv9tT8CxYUNlub29DW1/8Acw2W3w3HvvHXgXpBaphfgkZC3yaJXHJs+cCSGE3DEaf+5nVaQf/93fRWFqSpeljh7V2+Qf/RHMgQA8990H9733ou5974XZ6aw8Nx+Nou8D34XcwMBV27XU16PhJ34cdR/4ADOpCSGEEEIIIRVhXCzau9a1I5uIITIxouKy9IHftm0bisUSThw/jmQqiWh0BhaLWcXrf7d6UWrYgH/e+W4M+Jt1W7Ztj8N04llYrBa14BcRX8T8UrGoQndwNoieDT1avf5asZrNqHPPV5wWiiXk3WE4LNvQ7/MjmcnCabeju6MdDfXBa9rk3wwi3p88eRIvf+tlzMzMIJfLqXPAhg0b1GVgeHgY0ZmoVuE7Nz2OeycvoCM+L/InrA4cdLuwc9sWtfRva5u35BchX8R7SY6Q/SvV/SsRz+Thc9rgZfU9IUS+94JBNP/qr6LuA9+F8d/5HSQPHULTL/7CVdd2hn7yJ2FrbYVr926U8nnkRseQGxtFfmQUubExZHt7UcpmdVnrb//2kud6H36I+5oQQsiahwJ+DfLCCy/gySefXO1hEEJqIDblB1jgne+A99FHMPnHf3wlw3oBsU2LfelLevM8+CAc67srj4mYv1y8d99zD4Lf893wvelNt8VajZBajU1CqgXGJyHGhLFJVhO33YLmhhByhS1oCtdVrONFaO/v60cJJUxHpjEXi6mAL8vzgQD+LmvBxIJ4L1j8TfBveQC2qfO6jgj9wVBQK+7b2tuQSCRVwI7FYkuEcrGSL7/mzdrqL3/e1p7Om3rezSLbHh4Z1t9njzzyCF588UVcuHBB3QkkOSEUDGlSg8nhRab7Xrz3m/+78twvN/Sgsd6L++/Zi0fe8Ij2vZdkANleOTmirbVN3+tyMrkCTAuficd+bec1QkjtHTudmzeh4/98HJnz5+HYuHHJY/nJScS+/JWb2s7c059H48c+BmtDwx0aKSG1F5+ErBVeqPLYpIBPCCHkjmPx+zXDOvyjP4rkSy8h8c1vIvHNl/RHWZnCTBTAIgHf5YJJbhYLAk8+ieB3feCqH3WEEEIIIYQQshiH1axV+L6AD50tYVgXKtdPHD+hYnVjY6Pa54tgLfbxdrsD8VgcDrMJjmgvMsErv0m8e96GnhErkomkCv5iMy/ivcvpQktLKyYnJirW8eUqdxG2pa98MplEMBjE5k2bsX379oqN/XKBXyg/L51KqyA+Ozurvetfi/i/UtKAPCbbDofrdX5qagpTUxFNZJCq+uaWZpSKJZwuNGHT3Ch2RS7renmTGd9qqEd9cD6B4czZM/D7/Mjlc7BZbWjsbER9uP6aiQqJbAFuhxVeh5XOaYSQlV1TNm++anny6NGb2lvOHTsQ+sEfgCUY5N4lhBBSdVDAJ4QQctewNTaqGC836R+ZvXhRxfzksWMw2R1Xrd/xN3+jWdlmj4efEiGEEEIIIeSmBCGXzQKX1YpUrgDfgoAvIrZY4EvvdhHsrVYrxsfHkctlMRWZ0sfctlcqAr6tkEPO14yhpA32RFxt48V6/vTp0yrgp9IptZGX6vwNPT2VKvd8Pq+/dSYnJ9HfP4BoNKrz7e3tGBoaukqol/HKMkkuaG1pVUt6mQ8EAiuK4osF+0w6jbnYnCYkXE/8F2FfHpOxCfK+8/kC6uoC6kgg7yuZyWOqfiN+8MinK8/7ZkMPmta349EH7sXA4AAOHzoMl9ulor1sT0T8a4n32XxR2wJ47Fa9EULIzeJ54AG0/+X/ROrIUaTPnNFrQrbmZthammFtaYFNbq2tsIbD3KmEEEKqFp5B1yCbV8hsJISsPrUWm3KhSirq5Rb6/u9fcR33vr13fVyE1HpsErKWYHwSYkwYm2S1cdktcNjMmEvl4HMuFbFn5+ZUdHY4nbDb7VqNnkgkYDFbYB7vhb/lMt4+eRnvvvQ1/Pr9H8al9Q+hcPDvkC/kdX0R73v7epFKpdDS0qKCuVTQS1W6VN5Lj/nR0THYbFY4nY6KQD8xMaHrLBfqBRHfZZnNblNbe7GmL1f2L2Zxlb88RxIPUskUutd3Y/369VeJ/2WxX9aTBASpou/t7YXb5dbKe3k9ed/yvIh/I8LpOB4efrXyel9vasHG+jpdTwT/iclJdHV1rvhay0lk8vA4rHozm5f2tiaEXA2PnVew+HzwPfaY3ggxAoxPQozJ5iq/ZksBvwbZsmXLag+BELICjE1CjAljkxDjwvgkxJgwNsndJhKJqDAtIrUI5N3d3XDZ3ZhN5ZArFGGzmFW0F7Fd7PAnJydgt81Xj5dKUDFeqsmLpSJ+6PCn8W2JKd3ud537Cn79/g+hrqkb8dGLaGlu0ap7scYXMV/+14OhoArZ2WwWkamIivtSES8iucfr0amI7TlrTgX05UK9JBXITQRxWSZTmZeEg+WUq/zLSQDT0WkV1dd1dFwl/i8X+4vFIizW+T70u3bv0rHI/pJbS2s7zlm34gdOfREWlHSd0w3dSAbcSCSSyGUlOSGiy8WG/0aJBrLPc8Uigna72ucTQm4Mj52EGBfGJyHGZEuVa53zPmKkpnjmmWdWewiEkBVgbBJiTBibhBgXxichxoSxSe62eH/kyBG8+uqrS6ap2BycNgvSuYKuJ1XiYi1/4MABvPGNb8SDDz6It73tbejoWAeH3aGieCgYwlcdVhQXtn3f+Bn0zI4g1/MGeL1emC1mhMIhFe971veoiC03EchFtBcxXaaSEBBPxHV64eIFjI2PqbgvIroI9CKIl4X69rZ2tLW2qZCugngmo/OSXLCcSi/7UFhF9FBo3j46Eplask0R/xeL/VIxL4kGcl+2e9+996l1/sjoCJxOJ+bqemDPF/FE38uV1zq1cz+2dLfD5/XquGTsjQ0NsFotV73WitX3dquK9xZW3xNyU/DYSYhxYXwSYkyeqXKtk2mwNYj8GCSEGA/GJiHGhLFJiHFhfBJiTBib5G4ilfcDAwMqRIs4Lb3nZd7jr0PL+m2YSWUrNvoi4i+3e5fnnzp1Cul0BtlcFiNWK77hCuKRVFQf/8D5r+J37vkgNnZtgc/nVyt8s8msAnpdMKhCtojb0ekostmMWspbLFbk8zm15y8VS3C73ZoAkM6kdb3ZmVkVv0Wo3759u76OPE8EehHEr9VXvtwGQF7TbndgfGwMxWIBY2NjOHnqJEKhUEX8v3jp0orW/CLci62/1WqFx+2B2e7E8UwDOuKDSNqccBWyGK5rRs87n0BnUxCxWEzHlUmnMReb0wSFsnPASokG+WIRmXwRASer7wm5FXjsJMS4MD4JMSaZKtc6KeATQgghhBBCCCGEkDV74S6ZTKqQLJXx0tv93LlzKOWzcNktmEsDmXwBjgX7+OVs3rQZHR0dKkqLsC5V9p+3mvHIwuMPjZxAR2wClq1vwuO7/SryS3W7WNBPTkyokK3W9CaTivBir59Op3Hm9BnYbDa0tbXhgQceVHFfxHtZp6Oz8yqhfiXBfjnlNgAXLlzA5d7LSCVT8Hg8mlgg1fVSzS8JAbKtxWJ/2ZpfEg2EoeEhTSqoq6vDmbQfSacZZ0Od+IG3/n94bOgo9nR68cimLoRCwSWvL7b88t6vl2iQzBbgtlnhcVphtdD4kxBCCCGEkNcCBfwaRH4sEkKMB2OTEGPC2CTEuDA+CTEmjE1yNxHhWsRoqbwX8V6mMi/LRcCft9EvXlPAF8H7/vvux8zMjD63WCxhpj6MU24vto/3w4wSPnD+WfxR3feidfNudDd4rxKypyJTSCQSCIdDiEajKBQKlQr9hx5+WIVwsZ2XBAER7w8c2P+a3mu5DYC4AEhFf0NDIzZs2IBodFqr8EWYLzMdndakhGw2q4kELc0tmmiQzWR13+zYvgMX+gfx5aH6ynPyZivObdyJ1voEhoeGrhLwV3IwWEyxVEIqW0C9x6H2+YSQm4fHTkKMC+OTEGMSqHKtk2fTNchjjz222kMghKwAY5MQY8LYJMS4MD4JMSaMTXI36e7uVtFcbPOl8l7Ee6mol+VuuwUumxUT8TT8Tqtaxy9HBGkRwbcP7UAsNgef16eV/MPFIrY/3a/rPDp0FP+w5S34s2cv4g8/sGeJkC1ivlTEi7W8CSaEgiEknUl1BvD7A1p5f6Oe8beCvK4kAYi1vfS2F1t+qcrv7x/QCv8L5y+oA0Aun9MK/Xwhj6amJhXvxR1AbP3leZJgcDbXgIL5yqVBc6mIDkwhNxdHJtt9y2NLZwtwWMxwOSywW1l9T8itwGMnIcaF8UmIMXmsyrVOnk3XIMeOHVvtIRBCVoCxSYgxYWwSYlwYn4QYE8YmuZuEw2Hs27cPu3fvXjKV5TaLGU67WUVlqcK/Fg6nE+va2/GOb38H3vyWN+OBBx5AvKUFw91b9HELSvjBU/+Ob/VF8fLlSOV5It6fPHlSBfR4PK6V8SOjIwjWBfH4449j//59KuRLJbyI63JfqvVPHD+hz32tLLbHHxkZ1eQFl8sJt8eNWDym40il0vD7/WhtaUUwGNKqe0kkCNfP2+lH4lm8PGlGx9wYUCrpdgPpUcSGziKdSr6mRIOE2Oc7rPA5bK/5vRFSq/DYSYhxYXwSYkyOVbnWSQG/Bunvn88gJ4QYC8YmIcaEsUmIcWF8EmJMGJvkbiNi/YEDB/DQQw/pVObLuO1WOO1io19Y8hwR0EVIP3ToMAb6+7U//MCgVPGfx6HDh+Zt8b/9bZX1Hx49gd2TF/AXz1+q9JIXG/3hkWEEQ0Hs2rVLRXKpxJfb1i1b8cD9D2Db1m3o6OzQCvhCvoCB/gEcOnQIT3/+aTz33HOvScyX3vNtrW2aECBjTyZT6Orq0gp7cQ8Qp4FcLovWtlatwPd43Ein0jpOGaM87/+dnkFLbAp/8dwf4r+++JfYNHUZpYEjiAxd1nXkNW6FTK4As2l+f0vrAkLIrcFjJyHGhfFJiDHpr3Ktkxb6hBBCCCGEEEIIIaQqcdvERt+CuVQOhWIJFrOpUjkv4vv09DQikWnMzsxo9bpgtzvQ2NCAiVAYofsfQ/3B53X5O3q/id9u2IjPHx/Fk3vakMlmVRj3+fxa9e50OjE+Ma7C/rPPPYvNmzZj+/btKuhPTk7CbDbD5XTpOrG5GIaGhrQ3/dFjR1Uwrw/X6/R6feYFeXzHjh3a9zOZSOq4pY2ACPdirV8qlWCz2TEyPKJjikxFNIFAqvZDoRBcoTac68vhF09/DpZSEXumLuEHj38Ov2l3weuxaeX+jcZwrep7j4PiPSGEEEIIIa8XCviEEEIIIYQQQgghpCoxm00q4Dut81X4Hoe1Ujmfz+dV7I7HYxgaHkIul0N7ezs6OjqQz+Vx/PhxFPfswq4Tr+Kf1j+Cf+1+ULf5V89fQH16BOPDg1qNf/HiRU0AmIvFYLVa1VL/2LFXVVSfi83p49KjPhDwq9V+KpXS9bxeHyYmJzA5Malifk9Pjz5XxPnFArokHMiYJWFArO0Xi/wy7uHhYYyNjSObzegyEe2TyQSmpib1PbrdHhXlBRHwvzSQx6bpfnUVKPO3Ng+S0RFY835NApDXvFkRP18oIl8swmWzw2PnpUZCCCGEEEJeLzyrrkHe+ta3rvYQCCErwNgkxJgwNgkxLoxPQowJY5MYDRHtxdZdqvDlfrlyHiYTZmZmUFdXpz3q0+k0vB6vCtgWs0VFfiH9U7+Ep08C853igdlMCZ96ZRj7PbNIZ9KIRqdVYJce87Lt+vownE6HVtyfPn0a4+Pj2qPe4/HotqVav719HTLptD6nWCqisbFRrevlNaWyviyeL3YLkDFLFX1Z5JfXlOr+7vXdWNfRgaGhQU0EyOayOn6x7Be7fEkYcLtdcLlcODs8g2OTIfzeqX+t7J8X6tZhsJhGVvZLOq12pPKayxMJrlt9b7fC67BqwgQh5NbhsZMQ48L4JMSYvLXKtU7zag+A3H3khx4hxHgwNgkxJoxNQowL45MQY8LYJKtFJBLR/vIvvviiTmVecFjNKuCLAJ8rFLWKXYTw6emICvhiby/CtVTj9/X3VeZbW1rhcrmRj0/gvjbHktc6nQ7A6gvC6XBq33mtek8lVZQXe3yptBe7fLG4t9vs2qNeqvVFUC8Wiip0yxiiM1EE64Jwu9wIh8Iq0ksSQBkR6S9cuIDx8Qnk8jmdyny5Il/W71jXgdbWFq2ul9eT15b3UhcMIhgMaWKAiPjiKPDsmBX3jp/Fzkivbj9vMuPvzTbMTY3pOAN1dZrQIAkD8ho3olgqIZ0rwmMT+3zWCRHyWuGxkxDjwvgkxJjMVrnWSQG/Bnn55ZdXewiEkBVgbBJiTBibhBgXxichxoSxSVYDEeuPHDmCV199dclUlktveLHRFxE/lS2oBX1baxsSiaSK1AMDAyp45wt5rWiXCnkRvZuam7BhwwYVyb+92wZb+Sqa9JhPp/CF/iJGx0bh8/nQ3NSsQrzD6VSRvlAo6rbcHjeCoaBa2Le1tatFf2dXJ+rrG7Qa3wQT7A67iu2R6YiK+pJgUGYqMoXevl616JfqepnKvCwvJyIMDA7glVde0aQFSSKQxAGX24VYbA5Wq0VF/ampKZydMSMCP37w1L9Vtv/F+m5M5RKwWW069vpwWMdZTiQQB4ATx0/g0KHDOpX5xSSzBTglQcJhgc3Cy4yEvFZ47CTEuDA+CTEmL1e51snUWEIIIYQQQgghhBCypunt7VUhXirhRaCXKnqZDwaDCIfDavHuslowlcigsS6g9vAihI+NjSKbyapV/Hx/+rT2p5cKfHmu2OOLWF4onkBX3orinBk/cuL/oWAy4xcf/GGUBiJodIxr9boI/rKddDqjPehLKGHbtm06PhHz87m8JgTs27cPfp9fre4lgUCs7icnJlSMl8QCGX8ZsfYXAV7eV2tbK0aGR3Rs8jx5TUk2uHjxIsZGx5BIJuD1+vR1C4UCisUSotGotgqYS2WRP/AEvq3/FXTFxnXbSYsdLzS1oD0dxbTdrIkOYuUvor/sA3ETuJZ9v7xPSXpIZvIIeRxqn08IIYQQQgi5PfDsmhBCCCGEEEIIIYSsaaTqPZlMqvgtlvYNDQ04d+6cLhfsVjOcdgusaRMy+eL8MrsdAX8AXp+3YoMv4rjNZtfnSUW7VKYLZ8+cRXxwEH8Zm4a9VNBlD46dxsHwPhQu/RucNitaWlvQ1NSkgryI6Bs3bMQD9z+g65Yt76VqXsZY7i3f19unTgFSOS+vJRX6i/vOS/W+VNM77A4V62WMIvxLQsDQ8JAmKkglv/S3l3XtdoeOPR5P6PNFZFcL/c3fhoZSAf/x5Ocr2366vgtwFNHZ3KnjFZt9sekX8V4SCQQR7+X50k5AHAJkPhAIzCcq5IqwWubbEzhtlrv0SRNCCCGEEFL9UMCvQXbv3r3aQyCErABjkxBjwtgkxLgwPgkxJoxNshqIyOx2u1XQFvFepjIvy8u47Ra4bVaMT05j8NI5taSPxeMoFAsq4IsoLhXoXZ1dyOZy6O/vU0Hf4/GoeH1pbBRPBRvx/sy0bu8/nnwah970cxgPbMWGfB+y2Sz6+wfQ2dmB++69r1Kpvtx2vowslzGIaC6iv0xlXnrQl0X8+nA91nev13F6PG61/ZeKehHp5b11dnYikUjA6XCqFb/FbEFff59a4Xd1d6mrwGjOhUnbDnzspf8Nbz6t2x1zBfCM3Y7C4CBiM1Gt2Jf91tHRgfa2dmzfvh0XL13SynsR7212G8KhMC5fvqyJCEIym4fXaWP1PSG3AR47CTEujE9CjMnuKtc6KeDXIF1dXas9BELICjA2CTEmjE1CjAvjkxBjwtgkq0F3d7faxYttvlTei3gvYrQsLyM2+k6rBX1DwxgdHkZzc7MuP3f2HMbGx2CxWPHwww+hZ0OPCuLSb35yakqr2VPJlFbI/9XkCN4aqkMgn0ZzMqoi/p/veBJTF6cQttngds1X0S8W769lQy9V+RcuXFBx3u12YXZ8Tu3yyxXuglTry/qy3ujYKCwWi5TV62MiqMv6wbqgvm+zxYxcLqdV9xs3bsQHPvABjE9N4z89dQnmXBEXA+3YM3EBJgB/37kNyfE+5LJpmMxmNDc36f7wuD3w+/36+uIWIOOV5AV5LZnKvCzP5osolgCXzaKJEYSQ1wePnYQYF8YnIcakq8q1TvNqD4DcfZ566inudkIMCGOTEGPC2CTEuDA+CTEmjE2yGkife+ktL5U4i6eyvIzFbILLYQHyOcSSGQSDIVgtVjhdLhSLRSls14r1XC6vYrUI2/F4DAP9/VodbzKbkLJa8afpeQt94R29L+HhsdOY6XwMkZk4QuEQtm3dVhHgRaQv29CvX79epzIvy6ciU+jt69VEAam8l6nMy/Iysh1JCLBYLSreS6W8DFQSCgYGB7QyXpMWzp/D0aNHcenSJUxHpnUb/QP9+PhLA4gXrCiaLfg/29+On3nkx/HpngO4XMrAVCqq5b64DkjbgFw2p0kC5Qp7SR4QK32p9tfK+0xG52V5IpuHx2HVm0l2HCHkdcFjJyHGhfFJiDF5qsq1TlbgE0IIIYQQQgghhJA1j4j1iwX7lZBqcY/bAYvDhYsXL6ptvt/nw57de5BKpxCbi+HYsaNoaW6BS6rNHQ7tTy995hcK3/HUXBQPNbfjjdl5a/yPHf00fvzx/4yh0G48WGdTgbuMiOEr2dCLwP7yyy9rdb7dZkdHZ4duv1QsIjodXTJmeW0Zx+bNm/X5Itz3Xu5Fb28fMpk0RkZHdB2bzaatAKSf/ZkzZxCz+PEN03ZAa+4XxtPRgYH6JFrGemHKp7TivlDIIxbLYHh4SMd++vQpZNJpOJxOFefFUl/uS+W9PO4N+BGJZ1HnstM+nxBCCCGEkDsABXxCCCGEEEIIIYQQUhOI5fvGrg6MT81ibKhXxW+pKm9sakQwGFSrerHed7vcuv7evXvh8/lw4vgJTE5OolgsaSX8b02OYFtDI5qzce0r//OH/wE/99BHkA45KtX3QtmGXkT3fL6ASGQKyWRKK/wvX7qMSCSifeslkaC5pRn19fUIhoJLxrw8CaBjXYeun0gkYLNZ4XK54PF4VNwXod9qsyI6O4eRbDvguCLeW0s53NdohiViQzQXgtPpxFwshlhsDv19/bptSR546aWX8K1vfQuhUAjdXd1qx7+hp6fyvubSObht89X34mpACCGEEEIIub1QwK9BmpqaVnsIhJAVYGwSYkwYm4QYF8YnIcaEsUmMjFaUNzVgz86tmJmeggUluFxutLevQzabQU9Pj1rgi2h+6uRJbN2yFd3d3Sp2Hz58WKvki4WCCui/UwD+yGSGpVTEtul+fPDcl/CU911472wKzQGXvp5UrA8ND+HwocOYmJxcGAPUjj6by6G1tRXZbBbFQhGJeALr1/egPly/ZMwr9aIXcV1uIuy3tLRieqFqX7Ypdv/pdfehMZvFDxz7P/iLXd+BaVcAxUsvIettxtGXv6HPdbvd6j4glfci3jc0NGjywPDwsCYbmM0WTExO6HYDgYAK+KVSCalsAfUeBzzSjoAQclvgsZMQ48L4JMSYNFW51mkqyZk3uW3s379fp/KjjhBCCCGEEEIIIYQYi3yhiNGZNC4MT2Cs9xxGR0dUCBeRXKrxpef8kSNHcOHiBRX3N2zYgLNnz6Cvrx/btm7Vqv3Tp0+riP8dTj8+ONmr2y3ChJ95w4/Dt38vfvd9u2CzmHX5i994EQdfPgiz2YxQKIyhoUG1uJekABHNZ2ZmMDU1pdXzb3zjG/Ge73jPkir+meiMWu0PjwwvGackI0hywNmzZ3HixAlEpiIoloqwde5Fdsu34w+//j+weWYQMZsLv7PhcXz11IsozY6grq5O36Pf79fX12SCbFbfp7zH6emIjk0eD9YFYbFa8Na3fhsOHNiPZCaPbL6IxoATjT7nqn2GhBBCCCGEVLNmzAr8GuTgwYO4//77V3sYhJBlMDYJMSaMTUKMC+OTEGPC2CRGx2oxw+WwoDEchNe+DcG6Oq24l0p3scsfGhrC7Oys2ttPTZ3DqVOn4HI5tVrd5/ehFa0YGx1Tm/0L4RBOoYStk/34p81vwrngOhT7ovivn/0W3tplhcfpQDaX1ar69evXa6W7cO7sOZ2KaK+V8H4/wuEwNm/avES8F2R+x44dWgVfHqdU9gtSl5NMJDE9Pa3zeV8rIpu+HR858bSK94Izn8Xw4ClkI4P48R/7CD77mc8in8sjl8uhsbFRbfLl/UZnosjlsrBarCgUCmrLL8ukukleU0hmC/C5bPA6eEmRkNsJj52EGBfGJyHG5GCVa508265BxsfHV3sIhJAVYGwSYkwYm4QYF8YnIcaEsUnWAh67FW67BTm3Fzt37awsl173Uulud9hVuJae8IlEHE6nQ+3ls5ksSiip8D0l/ezTafzftmb888Y34pXGbZXtfKk3icmJWTxQn0U+m0GxWKxY4FutFnR0dCAWj1Ws70VE339gP7Zv316puh8cHNTXkDHIa0sSwOJe9EJZ2O/q7sLlsVl8ajiAD554Bu/s/WZlnb8LduPs0EWx4cTOnTvx9NNPa+KAiPTyHqXqXyr8X/7Wy5oQIMjj0WgUTocTLS0tmjCQyRXU/l/2m8tG+3xCbic8dhJiXBifhBiT8SrXOingE0IIIYQQQgghhJCawiUitN2CuXQOmXwBDuu8IC0V7mJTL0q1WMv3bOhBIpHQnvF1gToVy3d27oLHcwrOARc8Hrfa4k8WnDg8WVIb/XlMOJaog8uZwkZTCg6bRbd3+fJltcB/6OGH1AJfKt+F9rZ2Fe9FnC9b5l+4cAFnzp5Re32bbb7qfv/+fXjg/gcqIr5M9TnJLP7i7w/jbee+iO85/5XK+3yurgN/PxNFMR1XK3xBRPnp6LS6DciFT0kUEEt9GU8wGMTIyCiy2YxW4Af8AU1WuHjpEjIlK9Z3tsPT4NV1CSGEEEIIIXcGCviEEEIIIYQQQgghpObwOKQK36q28GUBX6ziRWAfHh5GKpVSEdvlcqlIj1IJHZ2d2gs+FptTq32xvrdZrdjW4MNkahrfjIdQggmuXBofOP8s/nHLW5Bwu7Dbl4TDAd32YrF+JURQFxeAyclJzM3NqUU+TClNAJicnFD7/gMHDqigL9uQyvif+Zfj2HH8a/jhk5+vbOdIfTf+LtwC9+xRZK3WSnV9PBGH3WbXKnvh9JnTaGtt02p+GZe8viQyZNJpzMXmNMlgdHQcRbsbxfQcusIuwFl/Vz4jQgghhBBCahFTqXz2Tm4L+/fv1+nhw4e5RwkhhBBCCCGEEEIMSqFYwkg0hYl4GvVeByxmU6X6Xezk+/sH4Ha71O5eKu+tItRv3abC+dOffxrHXz2udvrBuqD2tm+ob8SZYiOOTFjwWy/9NXZEenG4cRN+657vx3r7FO5rKMJcKmglvGxDRHTB4XRW+tqLIH/o0GGcOnlShXQR16UqPpFIalW8iPmSRPDQQw+q6L5t+3b8t2cHga8/j//vW38PC+Yv850Nd+CTex9AarIPk+NjmJ6OwOl0qouAvL7NatNrWHv37lVrf0kOkPe2vJ2AvL4I/S5fCNGZKBzFFB7Yt0sTCAghhBBCCCF3RjNmBX4N0tfXh66urtUeBiFkGYxNQowJY5MQ48L4JMSYMDbJWkEEe7fDAlfGglSuAK/DqgK6VKKX7eSlD7zcF/FeBHOxnX/22WfR29ur4r3L6cLY+BiSySRy2RweO9CC3RePqHgv7J84j197+W/xG/d/CM0mM8wTJxGbGMHFixcrAn64PqwW/VLpLq9ddgGIxWMoFkvqBCDifSqVhslsRkN9vYrq5wdG8PFzgOvsafzGoU9WxPu+ulb88/43oBQbQTGfhdVqQXNTM7Zu24pH3vAIJqcmMT09jR3bd2jiQTgUxslTJ1Wsl8r7cjJBuZ1Ac3MLUiUrWhqCmOyfUrGfEHJ74bGTEOPC+CTEmPRVudZJAb8GefXVV6v6n5qQtQpjkxBjwtgkxLgwPgkxJoxNstZs9F02K6LJjAr4goj40qN+sZ28iNoi3ott/oWLFzA2NqbCd6FY0J7ysbmYCu3xuVlYD2zCF6OP4dtOPK/b2zN1Cf/lpb/Gf7n/Q/Cb2xCwpeGxmRGLzycHrOvoUEFebPPLveUTiYTa58/NzmJ2ZqayXNZtbmnGSDGIzw3nkC7l8LHBo7AVC/r4qK8BB7/nR+DuO4l8MV+xzTdbzLBabTpecROQ9/HKoVcQDtcjk0kjMhXRJAQR7IvFIo4eO4pCvoDp6DSKFhuaW9sRn5uGz+OuWO8TQm4fPHYSYlwYn4QYk1erXOukgE8IIYQQQgghhBBCahKnzaJV+HMZE9K5gs6XESF/cZ96sZQXkd3lcms1fjqdVmv7dCqFltYWbNq8Gfl8Hr2XL8C2qQ3/an4T3vHqV/W5OyO9+P2v/Tn+567vwOngHmQKIwg7zXAXE0CpVKmCF+He4/Fo5b+I7y63C9lsVkV1sb33BsM4UuzCiQsi2M+P9U/3vg8Fsxn3jp/Bi9/3n9BQ70Q+HoDTUtQK/rq6OlgsFng8bl2/r7cPqWQKE5OT6Ovr12V+nw/d67sRDIZw4sRxTE5Mwu1xw2azI9o3hERsDl2NAXR0daC7u/suf0qEEEIIIYTUFhTwCSGEEEIIIYQQQkjN4rZb4LZbkcouFfCXU7aU37BhA4aGBjExPoGLly6pRf2ejj1obW3ByMioCuPd3V1o+MA78DmY8Z5Xv6zP74qN43df/Et8o2Un/mbHO3DGWoe2whDCeTtKY9OIJrKwJlJqp19f34CJiQk4XB7UNbYgls6jL5LCUc8+uMdSgNNXGVfRZMbf7H03TpvuRQsSmJuYVMFfLPkz6TRsNi+cTidCobCuPzs3q2K9VPNPT0cwPDSsFfod6zrUcSCbyWp7gM7OTljsLgyPT6G5PogDe3eqeB8Oz2+HEEIIIYQQcmeggF+D3Hfffas9BELICjA2CTEmjE1CjAvjkxBjwtgkaw2PXWz0LZhL5ZAvFmE1m1dcr9ybXvrRt7evQzqdQXtbm4rfYksvVvqRyJSuK2K512VH5r7t+Mt4HD/QdwjOQk4fe3j0BO4bP41PbPk2fHbjo5gcn4E/koIz50XADoRMQUQyacRcTYh5fBi3N2LG4oSvOItfe+Wf0JCK4ice/8/IWmy6vWZHFrvr8tjY2A1ndhrDwzGMj49jcnISY6Njuo7Y//f29mo/e1m+fv169PSsw/R0FAMDA2rXf/TYMV03OhNFKBiCy+lCoKkdhXweO7dsxIEDB+7OB0JIDcJjJyHGhfFJiDG5r8q1Tgr4NYj8qCSEGA/GJiHGhLFJiHFhfBJiTBibxOhEIhEVszOZjPZzl6pyj9MHt82KZLYAv3NlAX/dunVa1S42+rMzs2hqasTGjRv0MRHAxQJ/bGwMxWIB42NjaGhoQGJmCkcsaVze+xa8a3wYDw++qutLz/qMxY6iyYKoNYyo9qkvoC4Zx6lzGVjMIdhKduyc6MWuqaPYNXUJbYn55ADhg2e/iH/c9U7sbrTAm5zEtpZmtPptyOfCOH36tFrmNzU16bhGR0Z1zPJeI5FpmEzACy+8gHsO3IOx8THtdZ8v5DHQ349kKgmL2QKb3QZPIKhivt/t0Bsh5M7BYychxoXxSYgxCVS51kkBvwb50pe+hCeffHK1h0EIWQZjkxBjwtgkxLgwPgkxJoxNYnTx/siRI1p1nkwm4Xa7td/8zt174HF4MBnPwOsowSwq9zLqgnXYsWOHXiwUO32pyJfK9uHhYa10j0xF4LDPC91if//SS9+Ew+FEY50HeXMGX9l3AC91bcW7TnwDrkIW/9b9wJLtd8TG8T+f+0PM2dxI2JxoSU6v+B6KMMFazOHhpiI2tXiRHjfBkppGtODAxYsX9bVzuRw8Hg9sNhtM5vn3YrVY8VM/9TH81V/9FUZGRvDc88+jPhxGW3ubVuSPjo4hGp2G3W5HY0MjRsan4Hfb0dM9/zgh5M7BYychxoXxSYgx+VKVa501JeBfuHABn/vc5/DFL35R74udWDAYxP3334+PfexjePzxx1d7iIQQQgghhBBCCCHkDiGV9yLeS094qagXO3mZl+tDXVt2wpk2axW+17HyJTMR8eUm9PX24Wtf/xpGR0d1G1Ld7nQ4UF9frz3krVYrOjs7sHnzJpw7ew7jI+cxa/Xh4w8+gaKtXnvXL6YzNq5Tfy6pt+VkzFacCnXis537MOm24n5THG/ctRsXz6X1OldvXy+SiSSy2SxisRhGhkdUjK+rq1O7f7fHrdtxu9xaWS8V+aFwCDt37kIoFERzUzMuX76Mjs4OBOrCiCYyaAo4cWBbD/veE0IIIYQQchepKQH/V37lV/DP//zP2LZtG97+9rcjFArh3LlzePrpp/X2J3/yJ/joRz+62sMkhBBCCCGEEEIIIXcAsc2XynsR70XcFpt7uTYky0W0jzusiCQy8NgtMK1QhV9mJjqj4v3xV4+rTX3/QL9W4FttVoQmw7r9fD6v0/b2dqQ6U2hta9WqeKsngPGkCaW+IQwkLIDNATi8COSSSFodcOcz82M1W3E21InTdS04avPhktMDE/JwlxKoy+Sxo9WH5sYwnLYduNx7WcV7i9WCDRs2aCW+FK7k8jm1yHc6HWr/L0jSgtPlhMfjRktzC7LZDHLZHCLTEV1eH65He89mbLVZ0Oh3IuCy8X+REEIIIYSQu0hNCfhPPPEEfv7nfx579+5dslz6fr3lLW/Bz/7sz+L9738/WlpaUM10dnau9hAIISvAB+SUqwAAeVRJREFU2CTEmDA2CTEujE9CjAljkxgZqToX23wRsUW8l6nMy3KnzQK3w4J42oxUtgD3NarwRbx/9tln1Yp/ampKe8aLOC5JAMVSESiVMDY2ChNMul15XITx9d3r1YJ/cHAQ2dOnsbXBgTpnFiOTo0jO5XCksQEXt/w0ms0WOJJxjDqcKJpNmBwdRCGVgGUugpDPiUJsEj6vA1OTEzhx/ITa+EuyQDaXQ8DtQjqdhtfrhd/vh8vlUhv95KUkCoUCDh06pMvrG+rR2tqqgr+MWyrvZYxtrW1oaWtHrlhE0G6/phMBIeT2wmMnIcaF8UmIMemscq3TVCqVSqs9CCPw1re+FV/+8pfxmc98Bu9973tf83b279+v08OHD9/G0RFCCCGEEEIIIYSQ10skElHhXSzvpRJfxPuOjg7s27dPbeJFuB+dTWE2lUO9135VFX7ZNl+2IaJ3sVhEKpVGOpVCIpnQPvNS2S/PE/H+4Tc8jLe8+S1a3S5CeXtbO4aGh3D+3Hl0dHbC7vZjcDyCk+cv6f3G1jY4PD6ks3mYSkXk00nMTQxjfOgy8vEoLKWibre5pRlbtmxRd0nZ7sDAIOLxmNrlC2NjY5BLfg0NjTCbTTrWiYkJrc6Xqvuu7i6t2Be7fKm4z2SzcNjt6hgAhxs2ixlNfifq3Hb+0xFCCCGEEHKXNWOm0S4g2ci6Q6zVv0uef/55PPbYY6s9DELIMhibhBgTxiYhxoXxSYgxYWwSIyMivYj10vNehG8Rw7u7uys93l12CzxipZ/JI50r6vxKtvkzM7PaS34qMoVkMqHV7SLei4W+VOEXC0U4nU59XjqTRjgUxslTJ5FIJBCNRjE5NaWCvyQPpCNTsMbHEHYVsMHfiqI5hUQxD5vVjHwxgeNTvSjGplDI5rQiP1/I67bdbo9W3o+OjqoNvmxrZmYGqVQKxWIJGzduwL69++BwOjHQ368uAS2tLfC4PUvs8nfu2ll5j/liEZF4FgEnq+8JuZvw2EmIcWF8EmJMnq9yrbP61eqboL+/H1/96lc16/qRRx65payJ5Zw5cwZbt26FkSn3PCOEGAvGJiHGhLFJiHFhfBJiTBibxOiIWF8W7FdCbOPjDitiqRwyiZha3kuFuojgct1HxO/6cFgr2m1Wm1rliyheQkmTAqQ4RCrhxdp+bm4OIyOjCAT8iESmMTc3q4/V1QX0sePHjyMejyOfL2jF/NjIkCYXSN37lg1bEJ12IRqZQlNjkz7v1KlTmjQQi8UwPDykyyQpwOPxIBAIwOPxYno6ostFvN++fbuOPxgKIp6Iw2KxLLHL14r7RSQzBbhtVnicVlgt5rvwaRBCBB47CTEujE9CjMlslWudNS/gyw+r7/3e79Xp7/3e7+mPpNeL9Bp76qmnKvOPPvqoTl944YXKss2bN6vV2TPPPKOvLcgPLckWOXbsmCYVLLb3l3/El19+ubJs9+7d6OrqWvI6TU1NuP/++3Hw4EGMj49Xlj/55JPo6+vDq6++WlkmVmryel/60peW9IvYs2ePZq2U//ElE/2JJ57A2bNnce7cOUO/p/vuu4/viZ/Tmv7fE8pjYDwZ93Pi917tfU7L47Ma3lM1fk58T7X7OcnrVtt7qsbPie+ptj4noTyuanlP1fg58T1d+3OSZpO2QD28DW24cOoELKaiLvf5fTh29Bh27d6FN7/5zZXnf/GZL8JsMeMtb3lLZdnkxCRGx0a1Kr5sa79nz27867/+KzZt2rSkZ+dnP/tZtcJ//PHHK8vkf0Oq46WS/8EHH9RluVweg0ND2Lt3L7Zt31ZZV/5vxBq/sbFR51tbW9Rpsq2tDa8ceqWyXnkcslySDVLplD4u4x4aGsLp02cwlwN8NuCtD98DlznI/z3GE7/37uJ3uXwv87ucxyeeRxjv3Egoxz/P93gOy/Ny4/zWEIz+nsQdq3wOfquYSpLeu4aQD27xzrgRIs5/8pOfXPExsTf77u/+bvzLv/wLPvCBD+BTn/rUVb3N7mY/g7tF+WSQEGIsGJuEGBPGJiHGhfFJiDFhbJJqIJbO4avfPIzjp8/BgaxWyz//3PNazW6z29DQ0IB8Lq/C/c6dO/HWt7xVe9uLEN7c3IyOdR0YGBzQAor29nat1D995gxisTm4XC5MTU3pBchcNgeX26WV8GKLL5fpZmfnsGnTRuzds3fJNsUaXy4SJpNJLR4Rm3zpe9/d1Y1HHn0ErS2tapdf7mUvYz195rReoBQLf7XNd85X3i+2zV/8notFoCngRL3XsSr7nZBahcdOQowL45MQY/LMGtA6X49mvOYq8Ht6eio9xG6G1tbWa4r3H/zgB1W8/87v/E4V+V+veL9WMPo/NCG1CmOTEGPC2CTEuDA+CTEmjE1SDYiNvrmYQyqTRslc0r71oXAIM7MzapGfzWbh9/u1+ubAgQN46OGHMBOdwcmTJzE8Mlyxqb/v3vuwY8cOXLx0CeMT4wiHQzh//jympiJqm9/c0qyCvmxPXCHlmpfD4YTVYlXxfnp6GqlkCr2XexGLxyrivQj9sq5U3Yud/8DAAIrFIrZt3abifV2wTl8znUqrsC9JByLiy7jq6xuuer/FUgmpXBFht13fOyHk7sJjJyHGhfFJiDF5osq1zjV3Ri696l8v+Xwe3/M936PivUz//u//XnuA1QpiCVG2NSSEGAfGJiHGhLFJiHFhfBJiTBibpBqQIo+A24GAy4GBkTGtfne73Wp1L8K53WZXkXzL5i3o6uzS58i8iPUi6mey2UolvCyX+/JcuSYVCoYwHZlW8b1n/XoV18+ePacV/a3rW9Was5AvaOX8ju07tJK/t7dPq/h9Ph8S8QQSyYQK/1arRd0BLl26hOh0VMchtp0yDnlNSSKQyvtyBX4wFNTly4ln8nBazfA4rXDaaucaGSFGgcdOQowL45MQY3K2yrVOM2oMyWh+3/vep+L9933f9+ETn/hETYn3wuJ+DoQQ48DYJMSYMDYJMS6MT0KMCWOTVAvbNq1HZ3sLiiUTorMxrXAXQV4EerGqFwF+48aNuqyMiPViT3/gwP6Kjf2hQ4dVZJeKfanet1gtasHf1taKjZs26fY6OzuwafOmSgW92WxW0V3EfbHjN5tN8Pl9uPfee7F7z25NApCemrL9EydPqB3/dHRaX0ccAGS5bEfs8iUhQCrvZSqi/+LxCoViCalsEV6HDX6nbRX2NCGEx05CjAvjkxBjcq7Ktc41V4H/epAfKu95z3vw7//+7/jwhz+Mv/qrv9IfRIQQQgghhBBCCCGELKahvh7379+DXNGEM3U+pGcjlcfE7n7zps3Yvn27zp84fmJJ1b1QttMXG3yxvpeKehHxd+7cqZb8UmU/OTGxxGpfEgBkWxMTE0sq53O5HCYnJxEOh+H1eGF32DEzNKOFKpIQ4PF4dZtipS/tJGUsKzkCjI2P6fLl1fduuwUehwV2K6+TEUIIIYQQstrUlID/oz/6oyre19fXo62tDb/xG79x1TqPPfaY3gghhBBCCCGEEEJIbdPR0og3PfowOno2YW5yDMVCbok1/uK+99JvXsR4sbAXC35ZJpb50q9exPdkMqWV9uu712Pnjp2IxWJXif4i3k9FprQIJZlIYnZmViv/C4WCWuwfO3YMuVweY2NjSKfTMFvMsNvt6gaQy2UxMjKCurp5y35BxrhYsB/78tiS95cvFJHOFdDodcLvYvU9IYQQQgghRqCmBPze3l6dTk1NrSjel6l2Af/RRx9d7SEQQlaAsUmIMWFsEmJcGJ+EGBPGJqkmLGJd77Khvake8UAA9T7HksfFql6Eeqmub21p1Wp5mRdE0IfJpFb3IqrbbLaKsC9V8WK1X2Z5IoCI9lJZL8K+9LZvamqCx+PB8PAIJiZGUCwUtZ+9bM/pdCIej8FqtanIL+4Ay23yy9x3331L5mOZPDwOK7xOK2wWVt8Tslrw2EmIcWF8EmJMHq1yrbOmBPznn39+tYdACCGEEEIIIYQQQtYQPocVSUcByWxeb277lctpUkEvgruI99KvXizvpd+8VOLLTSriU6mUiu/Sfz4crtf15Xk3SgSQKvz6cD18Pr9W63d3r0cikVB7fYvFrG0hzSYzYvGYivbiOFlf36DW/ivZ+i+3zs8VinoLuu2svieEEEIIIcRAMLW2BnnhhRdWewiEkBVgbBJiTBibhBgXxichxoSxSaoNqXL3u6zwOWyIp+ct8cuIOC5Cvfapz+Z0KvPtbe1oa23TSnqxz7986bJa4o+PjemyssX98kQASQAoJwKUhf7ya0Sj07puoZBHoVCEz+eD1WbVav6Ghgbs3rUbjz36qLaNlGr+02dO49TCVOalyv/ll1+uvGYsnYfXYdP3JU4DKxGJRHDo0CG8+OKLOpV5Qsjth8dOQowL45MQY/JClWudNVWBTwghhBBCCCGEEELIrSCitbRlHJtNIVm0Itvehvbmen1MKtuHhodw+vRprXh3e9zYtm0btm/fro/HE3G1wB8ZHcHY+Hzfep/fp+L7YhYnAoh4L1MR+gf6+9UqX6rxBwYGtfre4/bA4XTCZrPq/ZbWFtx///1arS/juZatvwj9ZTL5AgrFErwOK3xO6zXf95EjRzAwMIBkMgm3241oNIp9+/YhHA7zn4gQQgghhJA7BAV8QgghhBBCCCGEEEJuIGLPJZIo2LyYnp2Dy7YD4XDwuvtMLOulCr+npweN2sPejUQiCafDqZb4ixHhfXZ2VoV2seAX8T6dSQOz0HVlHqWSivTt7e2wWC3qDCCCvoj3jz/+eGVbFy9dWtHWf7FtvzgJSN97uZmvUX0vSQvyvp1Op45PnARkXuz6KeATQgghhBBy56CAX4Ns3jzfC40QYiwYm4QYE8YmIcaF8UmIMWFskmpiuYh98kIfTh49jKnxUezfsRVzc3N6E5G+XDk/NjqGZ599Fh2dnbh06aIK8Xv37FExXWz2l4vpZUSQF6QSXyrunXBq9X15u9PRabjcLjS3NFeWSSW/iPo3quaXeVm+fv16pHMFXU+r7x3XvjQoY5DKe3nfdrtdbfrPnTunywkhtxceOwkxLoxPQozJ5irXOing1yBbtmxZ7SEQQlaAsUmIMWFsEmJcGJ+EGBPGJqkmFovYqVQK6blpjAxcRiyZgd1cQjqZ0HV2bN+hAr3d7sDl3suwWq04e+6sVvDn83md37J5yxIxvYz0ppce9VJ9L5XzUm0/PDysr7dp82Z4PB4V4kdHR9UWX17v5KmTOi6phpcEAtmGVPyvVM0vrydOALLcXxdAJJ6F32WDz2mrJA2shLyW2OZL5b2I9zKVeVlOCLm98NhJiHFhfBJiTLZUudZpXu0BkLvPM888w91OiAFhbBJiTBibhBgXxichxoSxSaqJxSK29Ja/fOki/C47ute1oGR1ak94EdJFmJfq+osXL2J2ZlZF9UK+oGK7iPgi0IvoLvNlMb3M4p71bo9b13vl0Cs4dPgQvvqVr+BrX/uaJgOEQiFs3rQZ7W3tFRFdtjc0PKTbFxFfECF/x44d2LZ1G7YvTGVeln/x2Rdgt5i18l4q8K9Hd3c3Ojo6kE6ntfJepjIvywkhtxceOwkxLoxPQozJM1WudbICvwah1RkhxoSxSYgxYWwSYlwYn4QYE8YmqSZErBaRXmz0L126pGL9jh09aG1vQcbkwPSEBx6nXf/vpdo9lUoiX8jD7/TD6XJh27ZtOH36tFbgiwAvYrqI9+VqeUHs9KXy3ufz49VXX8Xw0DBmZubFeKnmF4FfhPN3vuud2L59u85LVb5sr2yRLwkAgUCgsl2Zyk1EfVn/4qVLMFtsSKZy8DttqHNfcQC4FtLnft++fVrlL+9PkgZkf8hyQsjthcdOQowL45MQY5Kp8rZOFPAJIYQQQgghhBBCCLmBiC14vV6EQkGEvE70jkbgCoSxsaMFdYGACvFmixlDg0MqmpvMJqRTKTQ3Nevynp4N2Llr51WvIXb6Ypv/4je+oYL92PgYbDYbSiXAYrYgm8siFo9hanJqieDf2tKqtv0i4kvygCxfzGJr/lQyjYLdjZZwHQrpGOxh902/fwr2hBBCCCGE3F0o4NcgkpFNCDEejE1CjAljkxDjwvgkxJgwNkm1URaxpfr8yJEjWo3ff+k8THYvOtta0b5+M7rbGlQwn5ycULFeetCfOnUKjY2NaGlpQVtb25K+94vx+XxIZ9Lo6+9Df18/srkcisUC/H4/CgWZBtTGf3ZuVhMDZDvS114q78sV+DK/fPuLrfmDDS2IRKOwIo/JkQF0tTXdpb1HCLkZeOwkxLgwPgkxJoEq1zop4Ncgjz322GoPgRCyAoxNQowJY5MQ48L4JMSYMDZJtbLcUt5qt8Nb34a8zYVkJq+C+dzcnPabF/F9ZGQEqWQKFosVGzduXNL3fjGxWEwr8O12O+qCQUxMTGi/ebHrF3Hf6XRqRX4ikdAq+w09PZogIOK8VN6LeN/W2nbV9suV+o1NLUjDitaGICb6LyDb0XyX9hgh5GbhsZMQ48L4JMSYPFblWqd5tQdA7j7Hjh3jbifEgDA2CTEmjE1CjAvjkxBjwtgk1S7iHzhwAA899BDuu+cerG9rQp3TjlimgGQ6o4L5ls1b8Mgjj+CRRx7Fhg0bsHHjBhX1F/e9Xy60iyAvIrys397WBrPJDLPZDJvVhrq6OpSKJdjtDq2yl+3I9rZt3YbtC9OVtl+u1B+eisJWyiM5M43WpkatyCeEGAseOwkxLoxPQozJsSrXOing1yD9/f2rPQRCyAowNgkxJoxNQowL45MQY8LYJLWEy26B32WD32lFDjY4nPPW9k6HE4GAH5s2b1KB/VrifVlot1gsSKVT6OzsQDAURHNLM5oam9DR0YGGhgYV4ltbWypV9rK9nbt24sCB/TpdafuybrixFblMFiMDl2HKpbSaX1oBEEKMBY+dhBgXxichxqS/yrVOWugTQgghhBBCCCGEEPIaqXPbkMkXsa69FcnEHKITI9e1tl+OPN7S0oLJiUkMDw/D5/Ojva0dbo9bHxPRXSz2N2/afN1EgOV4/X50bNiM+lAAHnMePrdTty8uAoQQQgghhBDjQgGfEEIIIYQQQgghhJDXiMlkQikdw8zkKJLZPExmGzo6G1EfrlcB/kaiuzz+yBse0fujo6Pa697v86lwL/b5oVBIEwG2b99eec5MdAaDg4Nqvy8V/Mtfp1gqYSaZw7qmMOp7WhH02HW5CPiEEEIIIYQQY2MqlUql1R5ENbF//36dHj58GEYllUrB5XKt9jAIIctgbBJiTBibhBgXxichxoSxSWqNSCSCI0eO4HzvICbjWZjsLmxc14xdO1e2tr+WAC+Ul2XSaZ0XS/7lAr089+TJkxgeGUY6la5U+u/YsUPXkUt90WQONrMZIa8dDV4HzGaTPpfxSYgxYWwSYlwYn4QYk9Qa0Dpfj2bMCvwaZHZ21vD/1ITUIoxNQowJY5MQ48L4JMSYMDZJrdHb24uBgQHUeZxobGnDwHgEFwbHEAgEVhTwVxLgJW5EgJd+9jdCRH55rsPhQGtLKyLTEZ0vv95sKgezVPZ7bAh77BXxXmB8EmJMGJuEGBfGJyHGZLbKtU45nyc1xssvv7zaQyCErABjkxBjwtgkxLgwPgkxJoxNUmtkMhkkk0k0NDQg7LWrbX0+k8JUPKNW9tcT4NevX69TmZflN/V62awK/+FQGDa7TacyL8tj6RymozMYuHQW548fxrGjR9QhoAzjkxBjwtgkxLgwPgkxJi9XudbJCnxCCCGEEEIIIYQQQl4jIsAXi0W9iOj1ejEXi8PpDcLjtGM6kUVIquBNpqsEeKmeLwvwly9f1uU3099elknVvlTey3NlKvMlsw3jU1GMXD6HuYkh5NJJuN1uRKNR7Nu3D+FwmJ8xIYQQQgghawAK+IQQQgghhBBCCCGEvEbEul56cF66dAnxeFxF/E2bt6CtPgC7xYzogohvWhDxryXAy/Lr2euXRXwR9GWZrCPCv6zT2NSKuoZmxCNjmJ0Yht/tREPnOkxOTqq9fzAYpIBPCCGEEELIGoECfg2ye/fu1R4CIWQFGJuEGBPGJiHGhfFJiDFhbJJa7b/Z09MDj8eDRCIBj9sFczaBkMeBSDyDaDKHoNumIv5KAnxba5suv1F/e0GmIujLMqnSN1ts8NY3o7OlHhenB5FPJ9DQ2Q673a62/ufOnVObf4HxSYgxYWwSYlwYn4QYk2qPTQr4NUhXV9dqD4EQsgKMTUKMCWOTEOPC+CTEmDA2Sa0h4rjZbMZ9992nonk2m1XRPJ/Lot5rRwklROJZFfEDLttVAvxim/yLly5d116/jKwbqAsglskjnSsg4LKjzm1HyOtS23ypvBfxXqYyLwkBAuOTEGPC2CTEuDA+CTEmXVWudZpXewDk7vPUU09xtxNiQBibhBgTxiYhxoXxSYgxYWySWkPE8bJoLuL9YtHcajGj3utA2GuHzWJGJJFFMpNXAX7nrp04cGC/TsvV9Yvt9XPZ3BJ7/cXkC0XdVrFQQoPHiQafQ236u7u70dHRgXQ6rUkEMpV5WS4wPgkxJoxNQowL45MQY/JUlWudrMAnhBBCCCGEEEIIIeQ1IuJ4NBrVXvMimot4v1g0F+G+weuA3WJGLJ3HXDqHZC6j1fjy2GKuZ69fRhIAYpkCfE4r/E4bgh4bHFaLPhYOh7Fv3z7teS/OAJJEIOOQ5YQQQgghhJC1AQV8QgghhBBCCCGEEEJeIzcjmkslftjrgNtuhdNmQSyTQzSZhdNqgddphdlk0vWuZa/vrwuoVX4qW0CxVELYY4df7PhdNpjNpqvGQ8GeEEIIIYSQtQsF/BqkqalptYdACFkBxiYhxoSxSYhxYXwSYkwYm6QWuVnR3GW3wGkzw5WywGmxaDX+ZCwDi8kEi8WkFfkurw9bd2xHoVhCNl/Um6wjFfwOmwUeuwVBj12TAW4VxichxoSxSYhxYXwSYkyaqlzrNJVKpdJqD6Ka2L9/v04PHz682kMhhBBCCCGEEEIIIQZFhPnZVA6ZfAH5Qgm5YhH5fAn5YlHvW8wm2C0W2K1mOPRmgcNmhttm0Yp+QgghhBBCSHVqxjzbr0EOHjy42kMghKwAY5MQY8LYJMS4MD4JMSaMTVLrRCIRHDp0CC+++CK+8pWv6E3uyzJ5rIwI8w0+B9rqXGitc1WmzQEXWgIuNPtdaA3ML3cWkug/dwInDn8Lx44eWbKdW4HxSYgxYWwSYlwYn4QYk4NVrnXSQr8GGR8fX+0hEEJWgLFJiDFhbBJiXBifhBgTxiapZURYP3LkCAYGBjA5OYmJiQld3tjYiIaGBkSjUezbt2+J3b7JZILdaoJd6mzsK2/z6NGjus1kMgm3273idm4GxichxoSxSYhxYXwSYkzGq1zrZAU+IYQQQgghhBBCCCG3gd7eXhXanU4nvN7/v707gZarqvM9voOQMAhhDiIQAiIgaIALhDCYgBgggklEBQUBaQe6W7vblu7XvXy2Q9sO/V6rz6EbX9uLQRkEFBLmIBBAQhgCCYMQIBhAJhFCQCAJw33ru+mTV7mpe28NZ9hV9f2slXUhubfq1Dnnf86t+u3/3m8NL7zwQnjxxRfjf/N3/Bvf0+pj7rzzzi0/jiRJkqTOYIAvSZIkSZIk5WDFihWxS55u+/7+/jBq1KgwcuTI+N/8Hf/G97T6mDxWq48jSZIkqTOM6OcdhHLT19cXv86fP9+9KkmSJEmS1ENY537hwoWxS55p7hcsWBCnyB8/fnzYZJNNwvLly+N/77333i09JuE9U/O38jiSJEmSOiMztgO/By1ZsqTqTZBUh7UppcnalNJlfUppsjbVy8aNGxe22267GLD/6U9/ChtttFHYcMMN43/zd/wb39PqYy5atKjlx4H1KaXJ2pTSZX1KaVrS5Vnn2lVvgMrHqO3tt9/eXS8lxtqU0mRtSumyPqU0WZvqZZtttlnYa6+9Yrc9U9y/8sor8e/XW2+9OJ0+oTvfM5hnn302rm3Pz9Z+f+1jNvI4g7E+pTRZm1K6rE8pTQu7POs0wJckSZIkSZJyQrDeSrhOeH/HHXeERx99NK5xv/7668dp+AnvW31MSZIkSZ3HAF+SJEmSJEkq2cBu++effz6G96x1v+2228a17vl/Ou8N7yVJkqTeYYDfgyZMmFD1Jkiqw9qU0mRtSumyPqU0WZtSa932L774Ylzfno77kSNHhi222CKueU/Ab31K3c17p5Qu61NK04QuzzrXqnoDVL7Ro0e726UEWZtSmqxNKV3Wp5Qma1MaHp33Wbf9zjvvHL8S6r/00kux837lypXxK8E+3fnWp9TdvHdK6bI+pTSN7vKs0wC/B82ePbvqTZBUh7UppcnalNJlfUppsjal4dFVT+c9XfZZt/0GG2wQp8qnC5/Oe75ut912Ydy4cdan1OW8d0rpsj6lNM3u8qzTKfQlSZIkSZKkEtFVT3c9XfaE99nXsWPHho033jgG/HwP4T2hviRJkqTeYYAvSZIkSZIklYhgfunSpXEafbrtCfPptt9zzz0N7CVJkqQeZ4DfgxjNLSk91qaUJmtTSpf1KaXJ2pSGR1f9XnvtFTbZZJNSu+2tTylN1qaULutTStPYLs86R/T39/dXvRHdpK+vL36dP39+1ZsiSZIkSZIkSZIkSeqgzHitArZHiZszZ07VmyCpDmtTSpO1KaXL+pTSZG1K6bI+pTRZm1K6rE8pTXO6POs0wO9By5Ytq3oTJNVhbUppsjaldFmfUpqsTSld1qeUJmtTSpf1KaVpWZdnnQb4kiRJkiRJkiRJkiQlwAC/B40aNarqTZBUh7UppcnalNJlfUppsjaldFmfUpqsTSld1qeUplFdnnWO6O/v7696I7pJX19f/Dp//vyqN0WSJEmSJEmSJEmS1EGZsR34Pej++++vehMk1WFtSmmyNqV0WZ9SmqxNKV3Wp5Qma1NKl/Uppen+Ls86DfB70KJFi6reBEl1WJtSmqxNKV3Wp5Qma1NKl/UppcnalNJlfUppWtTlWacBviRJkiRJkiRJkiRJCTDAlyRJkiRJkiRJkiQpASP6+/v7q96IbtLX1xe/zp8/P6Tq+eefDxtvvHHVmyFpAGtTSpO1KaXL+pTSZG1K6bI+pTRZm1K6rE8pTc93QNbZTmZsB74kSZIkSZIkSZIkSQkwwO9B119/fdWbIKkOa1NKk7Uppcv6lNJkbUrpsj6lNFmbUrqsTylN13d51mmAL0mSJEmSJEmSJElSAgzwJUmSJEmSJEmSJElKgAF+D9p5552r3gRJdVibUpqsTSld1qeUJmtTSpf1KaXJ2pTSZX1Kadq5y7POEf39/f1Vb0Q36evri1/nz59f9aZIkiRJkiRJkiRJkjooM7YDvwddeeWVVW+CpDqsTSlN1qaULutTSpO1KaXL+pTSZG1K6bI+pTRd2eVZpwF+D1qxYkXVmyCpDmtTSpO1KaXL+pTSZG1K6bI+pTRZm1K6rE8pTSu6POs0wJckSZIkSZIkSZIkKQEG+D1o9OjRVW+CpDqsTSlN1qaULutTSpO1KaXL+pTSZG1K6bI+pTSN7vKsc0R/f39/1RvRTfr6+uLX+fPnV70pkiRJkiRJkiRJkqQOyoztwO9BCxYsqHoTJNVhbUppsjaldFmfUpqsTSld1qeUJmtTSpf1KaVpQZdnnQb4PeiRRx6pehMk1WFtSmmyNqV0WZ9SmqxNKV3Wp5Qma1NKl/UppemRLs86DfAlSZIkSZIkSZIkSUqAAb4kSZIkSZIkSZIkSQkY0d/f31/1RnSTvr6++HX+/PkhVa+88kpYb731qt4MSQNYm1KarE0pXdanlCZrU0qX9SmlydqU0mV9Sml6pQOyznYyYzvwe9CyZcuq3gRJdVibUpqsTSld1qeUJmtTSpf1KaXJ2pTSZX1KaVrW5VmnAX4PuuWWW6reBEl1WJtSmqxNKV3Wp5Qma1NKl/UppcnalNJlfUppuqXLs04DfEmSJEmSJEmSJEmSEmCAL0mSJEmSJEmSJElSAgzwe9D48eOr3gRJdVibUpqsTSld1qeUJmtTSpf1KaXJ2pTSZX1KaRrf5VnniP7+/v6qN6Kb9PX1xa/z58+velMkSZIkSZIkSZIkSR2UGduB34NmzpxZ9SZIqsPalNJkbUrpsj6lNFmbUrqsTylN1qaULutTStPMLs86DfAlSZIkSZIkSZIkSUqAAb4kSZIkSZIkSZIkSQkwwO9BY8aMqXoTJNVhbUppsjbVE1iL65BD3vzaQdtWWX2mtL9a3Zbanxvsv1PSzHal+hpS3tact6PQ2kxlnxWpldeY934Z7PH4/332efNPvX/rpGPT6PZ22usa5nXssHRp6Fpl3CvaOR+65VxSIXzfKaXL+pTSNKbLs84R/f39/VVvRDfp6+uLX+f7y7gkSZI6AW8HJk4M4ZZbQthvvxDmzg1hxIiQhBS3LaVtanVbBv7cG2+EcOuta/53Cvu73vYOtV0pHZ/hpLKtqWxHt21rma8x7/0y2OPx9/w/1wgM/LdOOjaNbm+nva7BdMvrqPpe0c5+7IVjIEmSpNwyYzvwe9C8efOq3gRJdVibUpqsTXW9q65688Nk8Hvi7NmhU7atkvpMaX+1ui0Dfy4L4wb+dyrnQjOvM6XjM5xUtrWA7SisNlPZZ0Vq5TXmvV8Gezz+PrtG1Pu3Tjo2jW5vp72uwXTL66j6XtHOfuyFY6C2+L5TSpf1KaVpXpdnnQb4Pejpp5+uehMk1WFtSmmyNtXV6Ab76ldX/zv+P4VJuhrYttLrM6X91eq21Pu5waRwLjTzOlM6PsNJZVsL2o5CajOVfVakVl5j3vtlsMdjdo6vfGXN78/+rZOOTaP7rFvOuW55HVXfK9rZj71wDNQ233dK6bI+pTQ93eVZpwG+JEmS1Ktqu8EyqXSFpbhtKW1Tq9tS7+cGU/X+bvZ1pnR8hpPKtqayHd22rWW+xrz3y2CP961vrd59P/DfOunYNLrPuuWcG/A6+jv1dVR9r2jnfOiWc0mSJEmlMcCXJEmSetFQndhVd4WluG0pbVOr29JM930jj5fS60zp+AwnlW1NZTu6bVvLfI1575ehHo+QfjCD/VuKx6bRfdYt51yd1zGiE19H1feKds6HbjmXJEmSVCoD/B40bdq0qjdBUh3WppQma1Nda6hO7Kq7whrctlLrM6X91eq2NNN938jjpfQ6Uzo+w0llWwvcjtxrM5V9VqRWXmPe+2Wox3vppcF/brB/S/HYNLrPuuWc65bXUfW9op392AvHQLnwfaeULutTStO0Ls86eyrAf+yxx8Jf/MVfhAkTJoStttoqjBo1Kmy99dbhoIMOCqeffnp49dVXQy9YsmRJ1ZsgqQ5rU0qTtamu1Egndoqd7gO2rbT6TGl/tbotrXTfD/V4Kb3OlI7PcFLZ1oK3I9faTGWfFamV15j3fmnnGpHXNhSt0X32xhvdcc5ZO/ncK9rZj71wDJQb33dK6bI+pTQt6fKss6cC/MWLF4ezzz47jB49OkyfPj188YtfDEcddVR45JFHwsknnxymTJkSXnvttdDtFi5cWPUmSKrD2pTSZG2qKzXSiZ3S2u6DbFtp9ZnS/mp1W1rpvh/q8VJ6nSkdn+Gksq0Fb0eutZnKPitSK68x7/3SzjUir20oWqP7jCUBuuGcs3byuVe0sx974RgoN77vlNJlfUppWtjlWWdPBfj7779/WLp0aZg9e3Y47bTTwje/+c3wk5/8JAb7kydPDnPmzAm/+tWvqt5MSZIkqTjNdFmmtLZ7yh3vZW1Tq9uSR2dtKmuzD8T3feUrjX9vlV2OqZxLqWxHt21rma8x7/1SVPd9M9tQtGZe47e/3TmvazDWzuq4TxR9/2xllozBflaSJEk9r6cC/JEjR4a11lrzJa+zzjqxIx8PPvhgBVsmSZIklaSZLsuU1nYfaN68sMWCBb21v1rdljw6a1NZm73edt16a+PfW2WXYyrnUirb0W3bWuZrzHu/FNV938w2FK2Z1/inP3XO6xqMtbM6jn3R989WZskY7GclSZLU80b09zvE8/XXXw9Tp06NnfmzZs2K0+q3qq+vL36dP39+sifXU089FbbaaquqN0PSANamlCZrU12FX/0nTmwuqNlvvxDmzg1hxIjktm1lX18YedttxW1bSvur1W256SamIssnnCvjXGjldTajrPM51XOppO3I5d6Zyj4rCB/FxK1s9jVOmPDm17z2S9E118g2FK3I15jiOdcFtfPGG2+El19+OfzpT38KL774Yvz6/PPPh8ceeyy8973vDduPHVv8vaKF++cr48eHG7/znXDAAQeEDQ49tKOPgcrn+04pXdanlKanOiDrbCczXjv0oD/+8Y/hRz/6UXzD/Mwzz4Srr746PPTQQ+HjH/94OPLII5va6QPdd999Yddddw0pGz16dNWbIKkOa1NKk7WprtJKl2XWFXbYYSG1bRvJG6Ait62C/cV7lGXLloU//OEP4emnnw5PPvlkePzxx8OEpUvD/q1sSyNrOad0LpTVCVz0+Zxq7ZW0HbncO1PZZzlYsWJF/OyBuubP73//+1jnx2++eRjTxGtkgu0RrdTHUPul6JprZBuKVuRrTPGc69Daueeee+I6poT1L7300puDXEaMCBtssEFYe+21Y83wd295y1sKPaaxzubNCw9/+tNhhybrc72FC8MLv/xleOWZZ8IGHXgMVC3fd0rpsj6lNI3u8qyzZwP8r33ta6v+nzcEp556avjmN78Z/7tdy5cvDzNnzlz1/5MmTYpfr7/++lV/t/POO4dddtklXHnllfHNfHayTZ48OSxYsCA88sgjq753ypQp8Y3KLTW//I8fPz5sv/32qz3PmDFjwn777RfmzZsXP+zLTJs2LSxZsiS+EcpMmDAhPh+zDmTGjh0b9thjjzBnzpz4fBg1alQ4/PDDw/333x8WLVrka/I4ee5ZT14jvJb33P0p29Zuek3deJx8TY0dp4P/1/8KG4XmPfWlL4Vbli8v9Dgt/frXwyYtbNuyb3wjjD7ssELOvRe+8Y2W9ld8LYcd1lA97bPPPjHYu/322+Pz84fOw7e+9a0xqKADka/jLrmkhS0JYcW//msYFfLDa7th+fLCrhH7ff3rYUwoVnY+l3ndm/qjH4V12tjWvK57633pS63t3x/8INw/dmzD9VS7n1q9RrR6Lrz+ve+FS2vO0SruTzfeeGMMIVeuXBnrlzAye17+n7/nv9c57bSmXls7n1Zk5xK22Wab+FrY9x/66U/D2DYet5VtKPv3iFav5c28rjB+fDK/G7VaOy9/5zvh6praKfs4Pfvss+G1116L97+NN944HHLIIeGFF16ITTd03xPcc33Ydtttw9PTpxd2r8jqbPuaa2szP7fPzTeHEXfd1TH3J38v972G7wmtJ68Rfh7hZyzeczv194js+1P+3YjfY/ndtiem0OfA1e6M4Rx33HHh5z//+aBT59PNctFFF4V/+qd/Cu9617vCZZddFjbddNOunkKfE59f+iWlxdqU0mRtqqv86Ech/N//++b0ukMgQB6x1lpvfhjNANfPfCaEz30uiW2rtezFF8PoU08tbtta2KZm9xdTvl1xxRVhs802i29Kt9xyy7DFFluE3/72t+Gmm26K/03n4bF//GPT2/JGf39YOmZMGLFoUXzvs97LL4f1ly8Pa7GNr7/+5p/B0OH4lre82YnI+6PNNivnXGhmnz/7bAjPPffmf2fbOJyyzucKzqWUtiOPe+er3/9+ePl734vXoY02ajB+rer4DnDrrbeG3/3ud7Gesz98QHTVVVfFATt8DHPggQeG8TfeuNrxeP2NN8LKFSvCyldfDa+++mr8O+p/7be8JaxYuTJ+31v/O/yP53yjRowIy084IdwzeXL8gIoPvdZdd93YfDD98cfDjr/+9ZrnxLPPhv5nngnhtdfiz682eCD73noNEFw7tthiVT0+t3RpvOZsOHp0eMspp1RybF781rfCqz/+cezkHjVyZGPXlEavK4mcc83UOaH4GjWV2OugRu6+++5www03xPvg1ltvHTv0Tz755DfP/x/9KLz2H/8Rnud4jRgRa2TtddaJ9UJjDgNoYoNOf3/YhE7+mnvFig03jIPj4s9QX2uvHQcH8HfLV6wIb1lrrfhYG+69dwh8mDvE9ZJ764t/+lN4/bXXwqj/rqkNv/jFN7cxhWu+OorvO6V0WZ9SmmZ2QNbZTmbccQH++973vhi6N+qDH/xg+Nd//ddhv++8884LH/vYx8Jf/uVfxun1W2WAL6mbbzhSL7I21Yu++93vxg7ND33oQ/GD7SrQoXrbbbeF/ffff9BZssquT8IE3j695z3vKew5+PCfUd1MsX3wwQfHzsPp06fHgcyNYPAFA57vuuuu8PDDD8fByRtuuGF49NFHY0BxyimnhN/85jdxDeE4DfEQeK3f//7340hzRqbnMVtZq9iWe++9N+y2224Nbwej6NkPH/7whyvd9sEwKp/Z4XbcccdKnp+p3Olg4D1z3tqpTY41S9PRHfHKK6/E4I736p2Mer700kvDJptsErs/6BD5sz/7szWur3SJEK5vt9128fve/va3hyeeeCLMmjUr/v+DDz4YPvWpTzU8VST7j58htGftcAYKUc8MIuCawPXmM5/5TLxGDDwGbCNdJ3RE8zkMHStcUwh+N99884Zf+1lnnRWfj+sNM47wZ+RQIXqO6I6ZO3duuPPOO+NrOuKII2LjRivonGFJk9SXTBwMy0ay3zm3Uv/ddunSpfHeRy3QAbXDDjuE008/PXbkcw+ovd/xvXQ0Zfcz7tPXXHNN7MTi3N97773DXnvtNeTzMaCB+mSmDH7nYKDNSSedNGRzT22NUJvcr88///zw7ne/O3aHSa1IvTalXmZ9Smma2QH3znYy446bQp9fxIvAGznwIUG3482FpPRYm1KarE31Gj4Q54NpAqcLLrggvhlaf/31S98OQmw+fH/nO98Zu++qrk+m9iVQYGrfogJ8AtVLLrkkhiyf+MQnYujEa2/kdXLMGPBAoEAXIVO8HXPMMTEgvvbaa8O4ceNiiE14f8cdd8RQlO8ZCsEd5wNhKo/PVHBVDehgymBCFQK57A3wcDh/CCl5D0kAmVqI/6tf/SqG+J///OeHHUyRN4Jbnp/AivMl7xpvtTYJejlefKXWQIjdqbK6ZDYNgkSmcySIJMSuV0vUWC1m4uC8J1R88cUX40CeZtZ5JFBkMBShPQEjAT7XA+qCvyMgHRjecx369a9/HYNRtpEOYwL7bKlAQs0TTzyx4W3g+DGQgOsag2oIWA844IAYxK611lqhCNkgELq3eV7qi+sZr79VDK5gEATXzk5ba5M6597CsWYASKq/23KusZzMzTffHO9Zn/zkJ+N1gFlqOAcHDr7g/MmOKT/L53l06VNHXO+pHwL1oTBTxuWXXx6P64wZM2K9cW8cKrwn8Of7qJ/3v//9cVAHdc551+j9Saon1dqUZH1KqRrb5ffOYt4tdaCsq7+qD6TKxMh5SemxNqU0WZvqNdm0zXwQTeDBclQEOmWHtXQL8uE8IWzV9UlofPHFF6+aljfbR3ki1Dr33HNjdyTdxuuss04M4+nkayR45ljRHUowSJc9HfMEboSh/DcDEAidGBTA4xFEDYfQDdmADgJfHrMKbDcISXitjWD7ea107tNpnhLOcQJS9u0DDzxQ6nMTdNFtyn4k2OS8yVuztcl5RbD8s5/9LHZ4H3TQQTEkI7zLgvxOw2viusE5yywHvCZCZQbFDBcqcl6wZiIh4WGHHRb23HPP+LN0FTeDawmBLc9NAEq3MN34zErBcX/HO96x6nu5rvHvZ599dgwvCfiZZp9tYYAHg3/AtYRBH43iusPU9fwMr3vfffeNwTr3lmaWR2wUgz9+8YtfxGsf10NeSzYIbOBghUZRKyx3AgZyddJElmxrtv4nNcV1McXfbdm/nHtc6z/wgQ/EwYPUPvcezv2hBmExQIEBh4sXLw7HHnvsqkCd18m9tB7qkIE11CiDa5jphvs7s0ww0GawfcmsLmeeeWa8djKQhUEF7FPqlTob7PmkRqRYm5LeZH1Kadqjy++dPRXg8wt1vTea/JL+13/91/G/eaPQ7XphlgGpE1mbUpqsTfUaujXBlLVM90zHJ8tNDRWk54nf1+m+32qrrWLwMtTzllGffGBPdx4DffnAn6/NLOk1HEIzQjrCy0MPPTR28/EcdMmz/zkOjSA0IPDgDSxr7xLO0XHJVPl0FhIWE9zx3zwuQcdwIVQW1rN+90477RS3lUEGdI2XicCQLkmwzQsWLGjo55h9YMyYMfEc5r1gNgigagTo1113XQxUORZlbhf7j3ONfZp1rzJFe96aqU26ZOlKZ1DJRz/60dgpTgcuXdoEY50Y4NOZy2AEgsXjjz8+LpPAcb/11ltjqDxUyMd1hg54vpdlTAgIqV06yRu9HmT4GUJPjvuNN94Yu5MJ79dbb724jVmAT2h5xhlnxOvC0UcfHQNNgspsKnC6//l/Ho8wnkExzQT4fObC9Y3p7KlHlg9gsBKDgghQ2Td53Luoq2wQCN3bfGWwDFOoc77zulvB/snCY+qFQLlTcMyzAVu8fo5xSr/bcl9he84555zwtre9LU5dz/0mqwWuVwxc4T40WPDPYBCOD7XGNZ+BIdzzGPgy2O8ZnHuc05zvBPb8PAO9qIl6S0RQAxdddFEc5DJ58uTYrZ8NCOG8zga9SO1IqTYlrc76lNI0p8vvnT0V4H/rW9+KH1jxwRbTFP6P//E/wsc//vGw7bbbxjfITEv3j//4j6Hblf2Bm6TGWJtSmqxN9Zqsu5wPvgnPCXAOPPDA2LFLCFpk5yGPTXcjoQudn0y9TAjLB/FV1SdBImE4AQLB1TbbbBOnn84DayoTiDMggPcl2dq+BOeEuo123w/03HPPxaCBbWY6XwIsAsOsm5n3RASLw82swHbwc5wLTH1N0EFIQdBSRNf2YJhSmemU2Rb2ESFLNjvAYLKp4QljOIcYqM2b+xSCNwYgMKsD6zYTWBFAEaaWgXX3sm5W9iFTDhYR4Ddam4Su1BgBGstGUF8EZARjDEbhOHZSgJ+ti01dc87SDZxNt85+5/o6VBc9/8409QTGLIGRTQlJ0Ej3eqtTzhMwct4xIIDBUVzbGbxBPXM9mzVrVqytE044IX4+Qvc6ISoDTHhOOub5d44Xf8/2NHov4DznODL4gD8M0GIgACEoYS3bQVDbLvYZ19KPfOQjYerUqfF6weuYOHFivI5y/W51GQ0GLGShMoMbGCjQzCwEVeEew7ayD9jHXA+5lqfyuy33JgaOcOw4bgxg496f4dxk8AeDeQYbnMAAQ44NA1OypUDovud8rbc0COcIgzyoNQJ/BpKAQU3UxcDue85zBhnRdc9AE7ruqcXsXGJfUg+cz6kt06LOk0ptSlqT9SmlaVmX3zt7KsD/9Kc/HT+44Y3zWWedFb773e/G4J4PtX7yk5/EDwo66cMBSZIkqagAnw+16XgjjKJ7kW4zPhRnLdqiQnw+jKdzjvCF4IFwk20oq/t/IDoVGbRw5JFHxjeGBF/slzwCfF4TXYOEW8cdd9yqKZ6zf+N9SRYYNYOgjM5Cgr9JkybFv+MYEjzwXohwn9fB4Ahe33ABPmEK6wHz8xybo446KnYZsrZ2GceF8Ib3b4RmzEzAdhPu0p083DTahIRMpcy5REcl4RDhYdbNXwVCPwJrplpmWm4Gq9CdXUYXPstS0IXN+cx2ZDNsMIAgjw7oVnCM6MbOOqSpLY43a1hz/nGt6ZT36ITbXB/5XIFp7+k4r12ijxCY83iw7ntql6nfudYw9X3WcczxYbDNcNPuD4YBLwyCIbynfrJzIbu+8Hef+cxnYkMD20tYyfMRSHKe8HdMvU6wSQjMjAB0IzeyDAeyAQw8BgNHeH3cS8A5mNe041yXCGQZgADOdQJc9nk7A0H4Wa4Z73nPe+K06QwyYbsJxlPGseJ6xz2L+wv7mGNHjVVV7xkGD1ErDDTjGp0NHBmIbWeQR22oD7afznw+z+O6fsghh8RjkwXxnJsD16LnWsIAJu5d3NOY7aN2SQXOewbd0MFfe+wZUMPAQgYyMkiAa3YtZrzhd5astiRJkqS89FSAzwdWrKnFGoO8aeTDSd6Y8ks/b1hr31x3M95gSEqPtSmlydpUryGE4oN+wjQ+AKezjN+bCfroEqfDrIgP/+myJxDhg3g+VOf3dUISQqbBguIi65Ogm6nzCZcIEQjRGFDAf9MtPVwH+FChCgEfMxrQFUkgPvB1EETRfdtsNx/HjvCewIwAkZ/n/Q5/6GYmeOB10fFKaNxIgM+Uy1nnOwMBOC+Y4pz9koVwRaJrmO0l3GE7OPdYFoDAe6jR9rxmQiteM18J4HbfffcYwtBtnOcyCM1gzWXOa4I09i/HnmPDFOlFdvRyzl522WVxUAdd0KwrzT5lMAf7lFkK8tRKbXKdISjjukN4TXgGOqdTR2jIZw2cdwzIIZQciFpn+vx6qEu69hnQQNd+bUjIABTqr5X126lRBiGxvjfBMzjPOP7Z9PkEn1mnMtc1rk90PBN4c13muFBzWZc8g47e+c53xntDI3hNXEeoV56HwJVBLHmfc7V4fWwfz8XrY8BBqwE+tUnNcv3nMTgvGWDC50p0jqeKQRucV2wr+57jxuwr1BMzgFSBEJ0BOiyZwbYx4IJr8mCfxXG/GdhFz/l74YUXxt8LqJVs5poMx4jznWOW4fVyz2UmCgYwMTglC/wz++6772pLanLcmR2A6zRd91yn692TGVzg1PnKi+87pXRZn1KaRnV51tlTAb7edPjhh7srpARZm1KarE31aoAPwnM+WM/WO2a65SOOOCL3ga8EiITlDBLgw3jCBsIino9tIDyne7Os+uS56boj6CRM5P8JQAk7CYMJowiIWukmv+CCC2IwQPcfj10vEGD/15v6d7h9SDBNQPLBD34wHiOCN0ILQhAGCxAE8n1ZgE/YWG+/Zgjzss5Hpv2mq5GgEnRMM6Cj6HORQQOEnuwnXhNd65wndDsShg/VgZ/NakBXZdZ1z2Ox34fr4C8C59Ddd98dB0DwegiV+MCBQSGEa/xbETgnOJ8ZwMBx4/85lgS6hKvsp7wHNLRSm4S64FwFoSth48CgLTUEkoT3dO4S3lNf9VDT9eqdfU94T0BMl/zAbmPCQQbkNOuOO+6INcL1IJuKP5MNkhiI78+WL8heG9cjzh2uB1xLOGfpRidAbXTQCYOKuP6AgQN0QNOBXcRgMK4RDARh6Q/2KdrpwOf+x32JY8e+4TrOjB7MSEAzCNep1HD9I6wmvOe8YyAGgTavgcEX1H3ZuNfQcT979uy475hlonbmmUavocxcwzWM8J978kCcn9y7a/cF9ck+4GcGm9mGn2O/cE5fcskl4aqrrorL2DCYjuuzVAbfd0rpsj6lNB3e5VmnAX4P4gNDSemxNqU0WZvqNYS+2Yf7BGeEIARBRU2bDzox6XKjW5KAgc48QgeCrGydZqZ8Lqs+CewJOQg/su1hvxDQ8f90LjOdfDMITAkeCMBY6zvP6XY5NoQibCcBYDYKncCMAPSUU06J+5Lwnf9nAAJhDvt1qA7SbAp98P2EgHTEl4UlFTgXORbIAnyOAR3BHH8GITQS4LP/s+Uh6PikQ7NsTOlNZzZdsMgCfF4PgSmDFfJYC7wepnhm4AAYIEMImXVkE3I+8cQTuT5fs7XJcWR6a6adzwYQsX8GTledEs5FAlyCPjp6GdzU7FTwhOB0ExOIc4zyGhzFuUQnPV3/nP+1uLbWW6/7ySefjF3rHAOuUxwT6ohrFd9LsJkNQuDvCDWzwV3DoRaz+gPnIo/H7AB5Y3AOz1W7bjrXsmwq/2awD7g/ZTMqMAiA2sk6tjneZSx/0Syu08zykc2ywL0gC6EZPMH9q9VZZJrFNY3fIehm517FlPgMIOEcawZT3LPePYPPPvKRjzQ0Mwc/c84558RrLgMGarvyB6tH1rpn8BD36cEG2UlF8X2nlC7rU0rT/V2edRrg96BFixZVvQmS6rA2pTRZm+o1hLu1XXEES3yYXeS64QTjJ598cnxuZN2CGQLceustF1WfhGiEP1kYR7DF9mRhNkE2nYCNILAgUCKko4v16KOPbrq7fji/+c1vYhDPY9d2mXIc6R7M9itBVG13MOHOUDMJsB9qjwMhM4FIWR2nDDigGzsLerJZBbJzhung64VA7HNC6mwtYwJqfpa1nzNVhDKEgGxzhoA6O6cI2zDUsgCt4rUS1mf7iloizMumZCeMzXs682Zqk4CPASjsn9pOceqeADpFHCfCxCVLlsRgkOtks+cUoSYzZHBOsCRFXuckMzmwPjhThRN2NnoMGIzw7ne/e1XXOoMnGFTAuvUg8M2uJWwrg7vqXZfr4TEIvDOc9wyQIsBv9Fra6DWDx2QQQm2XOYPDOEbNIuhmAERWK7UBPtcUZlIZOIV7CliKhtecqQ3w6VpncF4Zy4hwXaFOmF2D7WGAWbMDKZilgeV1uEZwHvFnuFk5slkY+MO+oDNrqME1DPBgFiCWGSG0Z2p+BrhJZfN9p5Qu61NK06Iuzzp7Y9F3SZIkSQ0hQKsN0QhaCJ7pjq2dljZvteEVneS1H54zjW1Z3YL1MIV/FmqB/ZF1Lw+FUODKK6+MITnTWDcapjWD7k+CwA9/+MODTt1dG6Yw9XPtfmUbB1PbwQqOPx3jTKvNlPpFqw2gajvwMwQtg51LJ5xwwqrBB4Q9nNMMQiniGDSqNujjdfAnmy2BsPHTn/50KQMLOB9rz186cutNp14WzmEGCTEApRaBW7Md7WVYvHhxrGsGPlB3A6e8Hw4DTG644YbYJc0AhaxLOg8MsCGIZzaAwaYKr4dt4RjQ2ZzhdWWd58g68DNcA7gWNqJe4EowTk2wL1l6oN3ZB7KZSHjdA+9VWQDfLJacyJYTyB6nNvhupAu8CrX7m/1CgJ9dD7MBPQNnZsgT1zYGUjB4jesLM560MnCNc45BLgzqYzBa7X14qME1LCfDQDMG1wx3bWPwG0E/x5Ip9mvvkZIkSVKV7MCXJEmSNGyIQfcy0ymXgQC/tvObMKLV9YvzQAd+7Vq7dDIP153H1Musu5tNxVtEcMx0v3PmzIldso1MyU93am3ITzjaTLDF66aLlem5i1xSYTBsb22AP5SBUyUTVhHgV7Hd9WSzGGQBfpmzAtA1zTIQtcd1uMEfRSFsYwYJplTPurtTRZc6yyAQDtJNPm3atKbDe85funyZep7u7TzDe6aPZDr/ww47LOyyyy4N/xwd5TfddFOcCWCo10OYWnuMOF/bDd15TmaimDdvXmgX1yXuHdlSEXng3lM7iKS2A79TcA+ii712HXeO23Bd7O0MEDrrrLPiYJIZM2bE+1Mr4X223j11R7DeSHjP4Jqf/exncfYIBoUMFd5z3lEvM2fOjPc1wn7De0mSJKXEDvweVDtto6R0WJtSmqxN6c0wlI5GuvCZirZodNs1Mn1tGfXJlO10rjcSHgycwppp0QmT8lrXemBIQhDI4zfSaUuAw35tN6Bgim2mQ6YLtZFZCPJUO4V+swjwCWsI+KoKq2tlMx/UBvhlBeYEekUfu0Zqk8EUdItvt912sUs3ZYS21Bs1RJd6K/uPY05YyGM1sh53s4N5rrjiijh1fLYcQ6Ouv/76uNzGcD/HLCh5L//B+c895Ze//GUc5NTMdbYW5zSDK7geFtkVT4D/0ksvxVC52TXcq0L3PYMQavdLEfdOAnGOwV133RUH/e2///6rLWPQDGZ5YTYFZmjgmA432IDjwUAgfkc58MADw9577z3kgCiWRuB+wICV4YJ+qUy+75TSZX1KaZrU5VmnAb4kSZKkYTFd+a9+9au4VnORAQkhEX9SWX+WTnqCmkaCb8Jlgns6YQnSilobmQEFF198cQwpaqd3Hi7EIeRoN7zm2DNggG7XKgL8Rjvw6233mDFjYhd+CgE+YRcBU6sBVzsDP1iDmg7VqlEnDAQ56aSTSpt9oNUZC5jGm2sAs2m0cv174YUXYkhNYE14n2cQTtcx20fQyQCbZhBkPvDAA/F1DXcM6MAvokOZARx0QDOVPp3WrSybwHWXWVKKXo+eAJ/rKPuiyllhmsG1n+77ImvsoYceCtdcc00MxDm/Wx2Iwb7Nlpdg7XrOi+EwoCKbZn+4wTXMfMLjM8hun332CRMnTixsJgJJkiSpXZ0xZFi5YoS9pPRYm1KarE3pTUy5TahOcFskPoQnMCdkTKE+n3rqqdidOlwXPSHJueeeGwPJj3/844UFSXSaEgQy9fbANeqHC/0JnPLo+GbQAKEfwUmnBPi10+ingACfY1F2cE0YXcbAi+FqkwD0uuuui92yKQwmGGyGANbxvvDCC2OQePTRR7cU3jMV+DnnnBM77gkY8wzvlyxZEi655JLYedLoYJ4MtUToyuCsRoJ5BlYVtczBe9/73hjeMpV/K7MPsB8YNFV0PWXHv5Om0eeeWjt9fp73TvYD5x8BOudfo1PdD3Z+cW9jYA/LSzQS3jMgiSnzOe4MQhnq2pZN7c81kEEGXHsM75Ua33dK6bI+pTRd3+VZpx34kiRJkobFB+QEPbxBYv3nIqaFB1OcEzakMj3xk08+GTs7hwuQmI6XTlLWny5qWnSm4GYWBMK297///U2FVQT4eXXPvv3tb4+DOe65554wYcKEUBbOuWzq+VYD/FtvvXVVeF6lqraBEGu//fYLVeM6Qp03GzqXhTCRjvAnnngiTJ8+PZ47rSBYnjVrVpyeno7iPK9rjz76aJySn6nKmbK8WbfffnsM8elCbgSDLvKeQj9D1z3XzgsuuCAOTmp0kAnXAwYhcE7nuSTBYAh8CfE7KcBncFneM9owuIUudrrZGeB2wgkntPUczHTDucy+ZRDAcLMb8Py33XZbHPDBTDQMZhustpgZh+n16eqnTvjeon5/kSRJkvLkb62SJEmSGsI61Xxgz/q0zU7V3Ey3YBlBTDMd+ARkw627Swcp4UBRHaAEbQQcBEhHHXVU052Dzz77bG5Tx/MaCV7pTmYa4rIGWxDyEca0ioEYTFlP8MkyAL0W4DON+7Jly+JsGlUi1KbLlqAulYE6A2uermLCarp6W50hgAEuV199dQwMqZM8rw0MxLjoooviABoGVLUS6lK/U6dObWjKegJTBjUUFeCD0H7PPfeMg6EIhBvZLtZcZ5sIcctCuMxMKJ2Ce+oOO+yQ6+NxXhO6c9/jd4F2zm2uBRxzBrmwDMRw4TqDNhhcQw188IMfDDvuuOOg38sAHL4XdPUz+EySJEnqFAb4PfrBq6T0WJtSmqxN6f/jg3WC2zvuuCPsvvvuhYTVdOA32slXdH3ScUrgWa8Dnw7Myy67LAZhw6272y7CsyuuuCI+J1P/trJuOh34eYY4u+66axzM8fDDD8eO2U6YQp+wePvtt4/T6Fcd4BNClR3gE3htuOGGpUxZP1htMgDj17/+dQy06dxNCXVGly6zAzB9N9PStzLFNo9z8803x9keDj/88FgreSKUZCYOQutWZlNg+1gznhlDGq1dBpwwYKmoKfQzDHagPrm2vO997xv2fKYLnCVLypwKnQC/UzrwOdbcwwZOod/KvfP111+PszbMmzcvzkhx0kknDdspPxTOJwZg3HnnnTG4Hz9+fEPLUTC4Zt11142DawZbaof7xNy5c+P28jvLQQcd1NCAEKlqvu+U0mV9SmnaucuzTgP8HrTLLrtUvQmS6rA2pTRZm9Lq+JCdzk26mMeOHVtpt2DR9UlYQMg6cEYA1tBlzV+mpCdEKLIrlQBmzpw5q9btbeW5CDMYaJDXFPpgEAEdkwsXLiwtwCeAaSfAB+cW4SD7tez156vuwOccovu+jNc9WG0y5TUDKVKYxr/WypUrw+zZs+OAlCOOOKLlD4IIORmgwLIaRx99dO6zHTA7AOuEcx0ebGaQ4Tz00EPxXCCAbfRcYDATirzWZTXOoIfzzjsvDrJhkEE9XAfoAqdjf7glTno5wGemAPbVwHtYs/dOzjvqg/OAWRvaHQDFbA4MgGNgGQPghuuMz6bsZ+AJgwcnT548aKc+20rXPa+bx656xhGpGb7vlNJlfUpp2qXLs8705qtT4bIpxCSlxdqU0mRtSqsjwKGjlGnj80ZHHgF+ox34Rdfnk08+GcOhLOQiRKCr9sILL4zTBhPQFR1o0UF41113hQ996EMtLy3APmXb814HmRCR6dB5/E7owAeDTgjfCI6qVEWAT8dykTNFDFebDIih23bKlClJrUHNufDzn/88LjPBtP6thvcMArj44ovDI488Eo499tjcg0OmLOfaQ4DJ1OWtDMRgGwlBGUAxWPfyYIErXe6tzP7RrLe97W1xdgGmVadO6mEQGdcCOvbLxiwWnRLgM3CLWmNt+VbuncyYwQCyc845Jx4XBn20G94/88wz4eyzz47nIvU2XHjPNnAuXHfddfHaceihh9a9fjB4hgFC5557brzOsQyD4b06je87pXRZn1KaruzyrDOdd80qzWBvgiVVy9qU0mRtSmvq6+sLZ555Zq7rqoOpfgnxGw2ai65POvmy7s5m1t3Ny3333Rd+85vfhOnTp7fVZUpAybTpeYdvdPQTlNCFT0dkJwT4DLggiKLTusop3Dl3B4ZqRSJwJMwrK8AfWJuEa4Rwu+22W2nb0Ijf/va3sZP7ne98ZwwGW51mm/3LmvQMlGFK93amFh+shi+44ILYYUKttTqLAlP7cx1ods14Oq+ZPr+sWSsmTpwYa5TlDAhtB+4LBlJxXSxjQMFAHFs62zsBNc/Ar4HHrZF7J4OzqA0GbrB+fB51u2jRongf5TxmiYThBvKwpA5T5nP9OO644wadRYbBLTwu9+kZM2bEpVKkTuT7Tild1qeUphVdnnUa4EuSJElqCh+i08lMNy2hV17o5GZt26LXWW4EQRwd+KyFTThAiEBYNNS6u3mii5fA8/3vf39cb7gdDLTIc/r8WqwvzJThdMIWvcYwYQ/dmO1if7LO9oQJE0KVHzTkPSPCUJgyneBx4FrYZWHGDkJgOsdTwEAQOnrvvffecMghh8QZNVoNp6kv1qQnKD3qqKNyn1mBxye8Z6kKQs9Wt5PO5zvuuCPOHNLsmvF04Jd5XabWmUqfzm86vrNrINflbMBFu9fFdjvwq16Go9F7arM1T50ycOL+++8P++yzT5ytod0ZMxiYx2A0rgPZevfD7bsHHngg3gMJ4w877LC6gzV4XAZzMDCFJV0Y3FL2zCaSJElSUQzwe1AZHzhKap61KaXJ2pQG78KfNWtWDG7zCnbotmsm1CyyPpkNgG4+OhhZq5dwgOChjKm/GTDAviU4YbrsdtGxmudMCbUIFQlC6azMY1uL7sAHwR+BD8eXASNV4LnLDJqy6fPLChxra5MQkf3N2vJV7e9a1DQDcpjCm275Lbfcsq39OnPmzDgjB4Ntmg3Gh8O+I7wnxOTxWz1+hM0MtGF5gMHWlR8u1C16uZCBxowZEwfZsPb6iSeeGM8dZvvgPjFt2rRQFQbCMJCI8yf1sDjrwG/k3sk5QmjP9Zx/Z3r7PGYp4VrHPZT7GmvSD9fJT7f9jTfeGAcITpo0Key55551z3sGtlxxxRVxMAXnww477ND2tkpV832nlC7rU0rT6C7POg3we1AZ01tKap61KaXJ2pTqI1BiWnbWZ8+rk5mwqpl13ousz8cffzx2lLOmLsEZAX4ZGDhAN++uu+6a234l6KBjtQgElnQvE6wVHeBzPPII8AkGGXTCLAetrneeRwd+meEfHfjNTpvejqw2s+CYGTvaXTs7Dw899FCcapu1senwbucYMGiFAJEu5f333z/3wRFcC84///wYeNKBvNZaa7X8WMw0wHWA5T9aUUWAD66BixcvjqHygQceGINdBlJVsS2ZbHkEguNOCPDrzVQw8N75wgsvxDplQAqD8gjN2znfagePMcCFwRcMCGD2gqGwNMGll14avx5zzDFh6623rtt1Tyc/92bua8wokcKsPVIefN8ppcv6lNI0ucuzzvZ/I1fHWbBgQdWbIKkOa1NKk7Up1UdYtddee8UaoWOuig78ouqTgQRMIQw6dMsK75mm+pe//GVc755pvfMIBOkUJcQpqgMfLDPw9NNPh6eeeiqU0YFPKNwO9ms2jX5VygzwX3rppXhOl7n2fFabBMecF+1M/Z4HrlHUNJ33zGxBkN3q/uf8u/3228Pll18e65TAM+/XRqBKeM+1gJkL2glTua7w2tnODTbYoOXHqCIkZYAQr5/OcGYlYX/stttuoUpM5c65Q8icMs7TwTrws/okDGdZhTPOOCN+PzMdMLtOHuE9U+CzBMLb3/72GMYPF94zoOpnP/tZHKhF2F8vvOd3hPPOOy/cdttt4QMf+ECYOnWq4b26iu87pXRZn1KaFnR51mmA34N4YyQpPdamlCZrUxocwTaBKh/U54GQsZkAv4j6fPDBB8PPf/7zGGbQWZvHFMKNBu0XXXRRDCMIJvIIULLAg3CxyPXWCWaYQrzoN88E+ByXPAaMMIMEAX67gwHaCfDLmk6erlqC22Zmt2gXtcnAAYLjgw46aNjwrkh0SjMNPSHwRz/60TgTQauBO4En3eBz586N03YzeCVvBMNs7+abbx6OPPLItqflp2udqSVZd7xVVXXgg/1ApzUDQTiXUlh3ni58zquUsX3cnzfeeOO69fnMM8+Ec889N8ybNy/OMvOhD30olylIs/XumTaf48XsEUMtPcM1mG1g5pk99tgjbsfAc43vYaABAT/XkpNOOimJGT2kvPm+U0qX9Sml6ZEuzzoN8CVJkiS1hE45QiGms203CCXQJPArM2QcGDoQNjJ9Lx26BOpldSzz3IQd7IPp06fH/ZoXpjAmlMnzMesheGFKcTp1i5KFQHlMo0+Az7Yyc0DZGIDAayirA5/p8zmXyw4+CboZONJOcNyurKuXc+cTn/hE7AZuFdcErg+c53QUF7HmNtdAwntC16OOOqrt8P6JJ54I99xzTzj00EPb7uKvappy1lB/9NFHY3DLzAcp6IQAn+57zvtsyv8M1x6WU2CgGvVJGM6SLXlcHzhWF198cVxah/XuB1u/vva8YuAav0PMmDEjLkUx8DzldTAbxc033xwHA1AXVS6hIEmSJJXFAF+SJElSW8EtnXysGZ9Hp3i9bsGyO3S32267GKqzVnrRGPhwzTXXxO7SItbyJaihg7Vo7DMCNqZML0o2CCGPAJ/ud6ZormIafQZqoKwAnw78MqfPz4JoZrOYMmVKJR3TtV29DCCo19XbbAf6hRdeGAfEsKxGEdcGnoPrEHXEFP9DdS03gmsY65ozSwBTz7e7bVWFpswgwAwSBLyLFy+OAyiqRiie+hT6zGjD/bS2/rgWnHXWWXHb2Z8sT5DXceVew5T5nCtMgT/cNefJJ5+Mg2sI/Rlcw6CqgTW8cOHCuL1cKxlosMsuu+SyrZIkSVInaO8doToSH6JISo+1KaXJ2pSGDzJ23nnnOL1tOyFhFjY003GaR33SnUxXLSE3IQJhBqEBa8az1nHRbrnlljhwgI7ejTbaKPfHJ1QpYxkAQiKCUqbRZw3lIkLbPDvwMW7cuBgITpw4MXRrgE+Yxjmw7bbbhrKsXLkyBoQTJkyIdVQ2XvMVV1wRB8UQUg4MBptFBzADARhc87GPfayQTnQ6kRkgwMCSvGbhuPPOO+NAigMPPLCtxyFIZfuqCPC5Pt99991x0ATXsQMOOCAOSuBeQ6hfFQZZ/OEPfwgp47zNBsRxzbnhhhvivtxrr73inzzvNwzWoeZY6uB973vfkOdvFszPmTMn3jPe+973rnHff+GFF8Ls2bNjDfN4LNeTwtIJUtF83ymly/qU0jSly7NOO/B70LJly6reBEl1WJtSmqxNaXgEtg899FBb9UIHfrPT57fzfIQIt956awzN3v3ud8fu9yygIjRot2O1EUxtTZcw3bZbbrllIc9Bx3BZIepuu+0WZzMoah26LMBnKvO8Any6QAl8y0SYRhhVxgAROm4JnJkquyysf8002Pvuu28oG1PGMzU4+7heV2+zuBawTjgDfD784Q8XEt7TgfzLX/4ynt/MFJBHeM8AiptuuilMnjw5Dgpod/vo5i97Cn0G6lx99dUxbM6ux/w31zNC/HaXbemFKfS5pxKun3HGGfFax0AIzom8rnkcA84zBsExUIQp7oc6fxncc/nll8fBBHT/H3zwwauF9zwegwzOPPPMeI088cQT433F8F69wvedUrqsTylNy7o86zTA70F0+UhKj7UppcnalIbHdNKsLU0Xfjsd+M0G+K3WJ4HUzJkzw2233RamTZsWg4fadXfLCPAffvjhGE4ReIwdO7aQ5yAsoZOxjCn0QVDIFMd04RchC3ry6sCno5cgrqgBB0Odf3TflxFKEeDTfV9WAEZIyPGnQ7ndKeCbQfDH9ecXv/hF2GmnnXKZ0YLZGXg8zmnW3c4jWK9Xo3T3g0FEeQ3qoLuZa1geU47TfY+yO/C5vr/++utxXfQM1+nDDz88LFmyJNx3332hKp0whT4zb3Btu+yyy+JSN8cdd9yq+1oev9sySIb17ummZ3ALgyuGus6wPWeffXZccocp9pm5pxYDIng8zt1JkybFwSxcR6Re4vtOKV3Wp5SmW7o86zTAlyRJktQ2PrynozybHryVDvwyuoSZ9pgOXcIXQoQddthhjUCNrvUiA3wGCFxyySXhoIMOCrvuumthz0NgQqDS7MCIdhAUMTiBgQN547UQouYV4PN4dGizvWWiRsqYPj8L8NtZ2qIZhK1Me82a62V2a7M/6QCmE/gDH/jAGl29rSCUnDVrVhzcw+MVMQCCmSQI7zmfCe/zOicIt5kRhanH89huurXZn2XMGJHhGswMKYceeugaz8u08Ey7fu2111YWohPgM7Ahr2tRnrIp6rmnMnPCCSecEJezaLcm6oXxhO7cR4dbooPBFnw/91UGEtTe69le/p2ue/YnXfdcQ+y6lyRJUq8rb0i8JEmSpK614447xtCOEJ8p9ZtByMB0v0UH+EzNS+jDerqEcvU6hJ9++un490V1rTPTAKEdAUWz+6mVEIzwvsxOaGZjIKS566672l57ux5eS56hGQM4CJ05B2tnYeiGAJ+AkW7XsgJ8ZrRgdgEGplx55ZWlPCevj8EwnBcEie0OVsmmBL/99tvD1KlT1+gSzjO8v+iii+K58JGPfCS3AQ/UxjXXXBP23nvv3JbO4Dxi+8oKVKlFapL11FnmYrCBQgxSYBaTGTNmlB72Zp3hL730Uhg9enRIBaE9+4SBamDf5LnWPdjvrHfPPf/973//kDNTcD7SUc/vBYccckhcrqb2WDE4hO1l0AmDMjiuBveSJEnSm+zA70Hjx4+vehMk1WFtSmmyNqXGEH7Shc801gQwzSD0o3u32QC/0fokLCNQJLwncODPYKE2oTchdJ7dihnCHta6pluRdYiLDiroTmWa+LIRwhDgF9GdyjTeeQbt2223XZx1gSC47A7eojEYhWUNylhCgeBw3rx5seubwQll3DvvvffecM4558TlOz72sY+1Hd5zDSKYzKYELyq8py5YwoPrAc+T59T0dK1z/d1vv/1ye0z2S94h8FDY/wx0YpDVYLh2svzI448/HsPhsjGggfOca0cKOEZMH3rWWWfFbWPJB2YuGGwK+lbqk8Etc+fOjQNmWNaANeyHCu+ZhYUlKH73u9/F+hzYVf/AAw+EM844Iw4QYZaAPffc0/BePc/3nVK6rE8pTeO7POsc0c9v4cpN1kUzf/5896okSZJ6CmHG5ZdfHqexbna9aD7sLyIkIggicCA0I9QYLtBmMAGvI+9t4THPP//8GKqwtm8ZXfF09xLmlTmdeW0XMB2Xea8bzn7kMfMc/ED359Zbb13aFOEcEwK3ItZUH3j8mdmCASlFI5DmmHzwgx8s/LkYkMNgnPvvvz8OGNh9991z2VdMmc/+oj7z6l4fiOPO8zDg4Zhjjsl1IAf75cc//nG8ztEdnef5ymOXMWsE145///d/j8d1t912G/b7GSh0/fXXh0996lOlX+foHi9zZoKhlmRhxgK2h/220047xbCd6e3zWkOe+mBwCwMmOL8Y+DQUQnt+F+C6StDPQKIMgT33h8WLF8dZWgjuy5r9RJIkSeqkzNgAP6GDURY+XJk2bVrVmyFpAGtTSpO1KXVufT744IOx8551zqdMmVLauuP10B1J4EhoVxtmSN3giSeeiDNoZOd2UffO2gE5Rx55ZNhyyy3bfkw64S+88MIYIhLeb7DBBqEoDDx4+OGHw0c/+tHcBwkR2jKTRB77pCq8hkcffTQGxI0E43w/MzEwW0LRA2JSw6AKlntg1humpmfpikbvLc3UJ4NN+H5mpeFnhloygMEeN998c5wJgi79fffdd7XjmC17wGMwg0JRA2WkTuX7Tild1qeUppkdkHW2kxmXtxiiJEmSpJ6TrZ/c7vc0+/O///3vw6WXXhrX1WVq/0bCoHa3Y6jHYht441bmevR5vp52FblvO3GfFf08ZT8+nbZFPj4I7Zkyn3C31QE59R6X9cKZmePQQw/NdRaGes/1rne9K4aaeXXe1z4H17iiwvuyao7XMHbs2IZ/lu+vNwNDt9cx9zc64gnVGQyyzTbbtL1dg/0MnfScV9Rc7SCJet9PeM+ACpaGYKmY2oEWBPe//e1vw8SJE8M+++xj170kSZI0DOepkiRJklQIptFlqly+tvM9rTzHVlttFU4++eQYmjcS3re7HcM9FsFHmeF9nq8npW0p8nWVtc+Kfp5ufXzqhxks6LxvJbwf7HHHjRsXpk6dmmt4P9R1Ka/wvhvO1yIeuxv2y3CP/8gjj8TBIKwdPzC8b2W7hvoZao76qA3vB/v+zTffPA7mYbBNLQJ8avb4448PEyZMMLyXJEmSGmCA34PKWANRUvOsTSlN1qbUGj7Af+CBB1ZNZT/wA/1Gv2codAUO9vOEfUNN9ZvndhT1WJ28DUVsS5Gvq6x9VvTzpPL4rd47h3t8AsJW1hwvsybKeK5uOF+LeOxu2C+NPP4BBxwQ/wwcFNZKfQ73MwT3tTU32PfzdcmSJXUfh+UpJk2aFOtX0uB83ymly/qU0jSmy7NOA/wetN9++1W9CZLqsDalNFmbUmv4IJ81erFy5cpVH+w3+z1DYdrrdn4+r+0o6rE6eRuK2JYiX1dZ+6zo50nl8Vu9dxa1/WXWRBnP1Q3naxGP3Q37pZ3Hb6U+m32uwb4/pfuO1Kl83ymly/qU0rRfl2edBvg9aN68eVVvgqQ6rE0pTdam1Dw67xYvXrza3z388MOrdeQ18j3DPceiRYta/vm8tqOox2pVCttQxLYU+brK2mdFP09Kj9/KvbOo7S+zJsp4rm44X4t47G7YL+08fiv12exzDfb9y5cvT+a+I3Uy33dK6bI+pTTN6/Ks0wC/Bz399NNVb4KkOqxNKU3WptS82k68zMCOvEa+Z7jnYF3dVn8+r+0o6rFalcI2FLEtRb6usvZZ0c+T0uO3cu8savvLrIkynqsbztciHrsb9ks7j99KfTb7XIN9/8KFC5O570idzPedUrqsTylNT3d51mmAL0mSJCk39Tr0BnbkNfI97T5HXtvaqDwfq1UpbEMR21Lk6yprnxX9PD5+Nful7OfqhvO1iMfuhv3SzuO38nPN/sxQ3//MM880vc2SJEmShmaAL0mSJCk39Tr0BnbkNfI97T5HXtvaqDwfq1UpbEMR21Lk6yprnxX9PD5+Nful7OfqhvO1iMfuhv3SzuO38nPN/sxQ3z8Yu/AlSZKk1hng96Bp06ZVvQmS6rA2pTRZm1LjhurQy/Dvw31Pq52Gjfx83o+T92O1KoVtKGJbinxdZe2zop8nxcdv5t5Z1PaXWRNlPFc3nK9FPHY37Jd2Hr+Vn/vABz7Q1M808hzNbLOk+nzfKaXL+pTSNK3Ls04D/B7kOmRSmqxNKU3WptRcvQzXoce/D/c9rXYaNvLzeT9O3o/VqhS2oYhtKfJ1lbXPin6eFB8/rxkWBnv8Kh+3qufqhvO1iMfuhv3SzuO38nN33nlnUz/TSvf9UNssqT5rRUqX9SmlaUmX/55pgN+DFi5cWPUmSKrD2pTSZG1KjXn99ddb7tAbrGuPx2z1Oer9fN6Pk/djtSqFbShiW4p8XWXts6KfJ9XHb/TeWdT2l1kTZTxXN5yvRTx2N+yXdh6/lZ/jz1NPPdXwzxDAt3tvL/q+I3UL33dK6bI+pTQt7PKs0wBfkiRJUtuYIjfPD+h5vHpTBTf6HPV+Pu/HyfuxWpXCNhSxLUW+rrL2WdHP4+NXs1/Kfq5uOF+LeOxu2C/tPH4rP9fsMVuxYkXb9/ai7zuSJElSNxrR39/fX/VGdJO+vr74df78+SFVM2fO7Pq1IaROZG1KabI2pcbxQf/y5cuH/B66+TBy5Mghv2/dddcNo0aNGvI55syZEyZPntzUzzezrY08Tt6P1aoUtqGIbSnydZW1z4p+nhQfv5l7Z1HbX2ZNlPFc3XC+FvHY3bBf2nn8VutzsHtnvZ8Z7Dm4n2f39Oy+Xu/eXsZ9R+oGvu+U0mV9Smma2QFZZzuZsQF+QgejLEyXttVWW1W9GZIGsDalNFmbUrqsTylN1qaULutTSpO1KaXL+pTS9FQHZJ3tZMZOod+DRo8eXfUmSKrD2pTSZG1K6bI+pTRZm1K6rE8pTdamlC7rU0rT6C7POg3we9Ds2bOr3gRJdVibUpqsTSld1qeUJmtTSpf1KaXJ2pTSZX1KaZrd5VmnAb4kSZIkSZIkSZIkSQkwwJckSZIkSZIkSZIkKQEG+D1o7NixVW+CpDqsTSlN1qaULutTSpO1KaXL+pTSZG1K6bI+pTSN7fKsc0R/f39/1RvRTfr6+uLX+fPnV70pkiRJkiRJkiRJkqQOyoztwO9Bc+bMqXoTJNVhbUppsjaldFmfUpqsTSld1qeUJmtTSpf1KaWp22vTAL8HLVu2rOpNkFSHtSmlydqU0mV9SmmyNqV0WZ9SmqxNKV3Wp5SmZV2edRrgS5IkSZIkSZIkSZKUAAP8HjRq1KiqN0FSHdamlCZrU0qX9SmlydqU0mV9SmmyNqV0WZ9SmkZ1edY5or+/v7/qjegmfX198ev8+fOr3hRJkiRJkiRJkiRJUsnayYztwO9B999/f9WbIKkOa1NKk7Uppcv6lNJkbUrpsj6lNFmbUrqsTylN93d51mmA34MWLVpU9SZIqsPalNJkbUrpsj6lNFmbUrqsTylN1qaULutTStOiLs86DfAlSZIkSZIkSZIkSUqAAb4kSZIkSZIkSZIkSQkY0d/f31/1RnSTvr6++HX+/PkhVc8//3zYeOONq94MSQNYm1KarE0pXdanlCZrU0qX9SmlydqU0mV9Sml6vgOyznYyYzvwJUmSJEmSJEmSJElKgAF+D7r++uur3gRJdVibUpqsTSld1qeUJmtTSpf1KaXJ2pTSZX1Kabq+y7NOA3xJkiRJkiRJkiRJkhIwor+/v7/qjegmm266aVi+fHnYddddq96Ujl4XQupF1qaUJmtTSpf1KaXJ2pTSZX1KabI2pXRZn1Kanu+ArPO+++4L6667bnjuueea/tm1C9miHrbRRhuF1E8WpH5SS73G2pTSZG1K6bI+pTRZm1K6rE8pTdamlC7rU0rTfR2SdRLet5ob24HfY/r6+uLX+fPnV70pkmpYm1KarE0pXdanlCZrU0qX9SmlydqU0mV9Smnq64Gsc62qN0CSJEmSJEmSJEmSJBngS5IkSZIkSZIkSZKUBDvwJUmSJEmSJEmSJElKgAG+JEmSJEmSJEmSJEkJMMCXJEmSJEmSJEmSJCkBI/r7+/ur3ghJkiRJkiRJkiRJknqdHfiSJEmSJEmSJEmSJCXAAF+SJEmSJEmSJEmSpAQY4EuSJEmSJEmSJEmSlAADfEmSJEmSJEmSJEmSEmCAL0mSJEmSJEmSJElSAgzwJUmSJEmSJEmSJElKgAG+JEmSJEmSJEmSJEkJMMDvAQ8++GD4zne+Ew455JCw7bbbhpEjR4YxY8aEadOmheuuu27Inz3zzDPDvvvuG9761reG0aNHh8mTJ4dLL720tG2Xutmrr74a/s//+T/hk5/8ZNhjjz1ibY4YMSL89Kc/HfRnzjjjjPg9g/057bTTSn0NUjdqpTYz3jelaixZsmTI++Oxxx7roZEK9vvf/z6cfPLJYeuttw6jRo0K22+/ffibv/mbsHTpUve9VCFqcbD741ZbbeWxkQp24YUXhs9//vPhoIMOChtttFGsveOPP37In5k7d26YOnVq2HTTTcP6668f3vOe94Tvf//74fXXX/d4SRXUpu83pfI8++yz8TPYGTNmhHe84x1hvfXWi9nkgQceGP7rv/4rvPHGGz1z71y76g1Q8b785S+HX/ziF+Fd73rXqhN40aJFYdasWfEPIcVf/dVfrfFzp556avi3f/u3sM0224RPf/rTYeXKleG8884LRx11VPjhD38YPve5z3n4pDa89NJL8UNNMKiGD08ee+yxhn6WATgEiwPtvffeHhOpotr0vilVb/z48WH69Olr/P3uu+9eyfZIvWLx4sVh//33D3/4wx/i76m77LJLuPXWW+N7zSuvvDLcdNNNYbPNNqt6M6WexYee2e+3tWjWkFSsb3zjG2HhwoWx3viM9f777x/y+2fOnBmOPvrosO6664Zjjjkmfo57ySWXhC984QvxfnrBBRd4yKQKahO+35SKx33uz//8z8Pb3va2cPDBB4ftttsuPP300+FXv/pV+NSnPhWuuOKK+D0Muun6e2e/ut7pp5/ef8cdd6zx93PmzOlfZ511+keOHNn/xBNPrPZvN910Uz+nx4477tj/3HPPrfr73/3ud/2bbrpp/6hRo+J/S2rdihUr+i+//PJV9feVr3wl1t1//ud/DlnPfA9fJaVTm943pWrxeyl1euKJJ3oopApMmTIl1uAPfvCD1f7+C1/4Qvz7z372sx4XqSJjx46NfyRV49prr+1/4IEH+t94443+6667Lt4XjzvuuLrfu2zZsv4tttgiflZ72223rfr7V155pX/ixInxZ88999wSt17qXs3Upu83pfJcc801/bNmzep//fXXV/v7J598sn/bbbeNtXrhhRf2xL3TKfR7wEknnRT23HPPNf5+0qRJcUp8OuuZXqJWNg33l770pbDJJpusNvXaX/7lX4YVK1aE008/vYStl7oX03IfccQRcTSZpM6uTe+bkqRe9fDDD4fZs2eveq9Y62tf+1rYYIMNws9+9rM4w40kSb2G7sGddtpptU7Boab0fuaZZ+LyT7UzLNJRSLcw/uM//qPQ7ZV6RTO1Kak8LAXOLOBrrbV6fM0Mqaecckr87zlz5vTEvdMAv8ets8468evaa6++msK1114bvx5++OFr/AyhRu33SCrfggUL4hou3/72t+MHoqw5Kqk63jelNDzxxBPhJz/5SfjmN78Zv951111Vb5LUM/fAKVOmrPEhy4YbbhgOOOCA8PLLL4d58+ZVtIWSaML4+c9/Hu+PLG1x3XXXdfR6oFIvvq9873vfG9f0pQmLmpZUPt9vSunlmdd28b1z9dRWPeWRRx4J11xzTTyBOZEzdEY8/vjjcf2Xet2HjEzDAw88UOr2Svr/+NCl1lve8pa4BgyhPqPLJJXH+6aUjquvvjr+qcWMU2eeeWZcN01S/hYtWhS/vvOd76z777x/pEOf94/ve9/7PARSBZ566qnwiU98YrW/GzduXJxZkdkZJaV/TyWsoG7vvffeOPvNrrvuWsEWSr3N95tSdV577bVw1llnrRHWd/O90w78HsVok+OOOy5+/epXv7raNPnLli2LX0ePHl33Z7O/f/7550vaWkkZbjg//OEP442J0JCRn+eff36cspROw5NPPtmdJZXM+6ZUPQakfvnLXw7z588PS5cujX+uv/76OC0iU6sRGjp9t1QM74NS2j75yU/G5g1CfO6Fd999d/jsZz8blixZEmdYXLhwYdWbKOm/eU+V0uT7Tal6//AP/xDuueeeMHXq1HDYYYf1xL3TAL9DEM6xHkujf44//vhBH4tp0hh5fdNNN4VjjjkmnHrqqS1tk+vDSPnWZiPojvjc5z4XR5TxyyOzZHzkIx+JUyAyEOfcc8/1AxipgtpshPdNqbi63XLLLcPXv/71sNdee4WNN944/mGGKbp+J0yYEB566KHw05/+1EMgVaC/vz9+9T4oVeMrX/lKXEt0zJgx8T3k7rvvHk477bTwt3/7t+GVV16JTR2SOoP3VKkavt+UqvWDH/wg/Nu//VvYZZdd4nLCvXLvdAr9DrHjjjs2NS321ltvPWh4z4edF1xwQfjoRz8a10AbeOJmI1KykSsDDTeiReoledVmu7bddts4+uzss88ON9xwQxg/fnwhzyN1ijJr0/umlG7dMl0aS8zccsst8f7413/9121upaRm74MvvPDCat8nKQ2nnHJK/CCU+6OkNHhPlTqL7zel4v34xz+On+W8613virNKbbrppj1z7zTA7xCcmHmsEfHxj388hvd8Zb0I1s0eaIMNNghvf/vbw+OPPx6efPLJ2OFb68EHHxxyjUOpl+RRm3nZYost4lenCJbKrU3vm1Ladev9USrWzjvvHL+yxn09vn+U0u0mhO8fpbTuqbfffnu8p/b19a3xue7vfve7GBjusMMOlW2jpNX5flMqzve///3whS98Ic4gxWdG2e+vvXLvdAr9HrFy5crw4Q9/OIb3J5xwQpxmol54n2F6NVx55ZVr/NsVV1yx2vdISgPdhejEm5HU6bxvSumaN29e/Or9USrGwQcfHL+yZMUbb7yx2r+9+OKLcem29dZbL+y3334eAikhN998c/zq/VHqjPeVzJbx8ssvh/333z+MGjWqgq2TVI/vN6VifOc734nh/R577BGXD64X3nf7vdMAvwesWLEizJgxI8ycOTP82Z/9WTj99NPDWmutNexUaviXf/mXsHTp0lV/v2TJkjhlBSf7Jz/5ycK3XdLqbrzxxrrruHzrW9+KH8Bsvvnm4fDDD3e3SSXzvilVP4iNAasDXXvtteF73/te/G+WkZJUzPIXU6ZMWfVeceDa23T3MoicGWsklevee+8Nzz333Bp//8gjj4TPfe5z8b+9P0rpoPmKz3XOO++82E2YWb58efif//N/xv/+8z//8wq3UOpNvt+UyvXP//zP4R/+4R9iRz2d99wbe/HeOaKf5EddjaD9jDPOiCfxX/zFX6yx5j0mT54c/9T64he/GL773e+GbbbZJhYBH4r+4he/CM8++2z44Q9/uOrNnqTWffvb3w73339//O8FCxaEhQsXxhFhO+20U/y7Aw88MK7dm6F+Wb5in332iUtdsLYLXU333HNPWH/99cNFF10UP0CVVG5twvumVB1+jyWk4Cu/u+Kuu+6KAX725i974yYpf4sXL473yT/84Q9h2rRpYdddd40fdNIpwe+uc+fODZtttpm7XirZV7/61fh7LTNljBs3Lmy44YaxXi+77LL4oebUqVPje8iRI0d6bKSCXHzxxfEPnnrqqXDVVVfFmS8OOuig+Hd8Xvu///f/Xu37+Rx23XXXDccee2xc63fWrFlh0aJF8e/PP//8up/tSiquNn2/KZXnzDPPDCeddFKcQfzzn/983bXrt99++/g93X7vNMDvAdxgrr/++iG/h84I3tjVK5Yf/ehH4be//W3s2t9rr73C3/3d34UjjzyywC2Wesdw9XniiSfGATgZ6u/WW2+Na4nSSUFdbrfdduHQQw8Nf/u3f+v0h1JFtZnxvilV47/+679iAMGAtj/+8Y/h1VdfDWPGjAkTJ06Mg06zD2EkFeexxx4L//RP/xSnLmTQ99ve9rYwffr0+F6TD1AklY/fZ0877bRw5513xnCCGTE23njjOBXpJz7xifinEz/MlDoJn7d+7WtfG/Tfx44dG2exqUWjBrOiMtMig23e8Y53hJNPPjn81V/91ZBLokoqpjZ9vymlU5uYNGlSmDNnTuj2e6cBviRJkiRJkiRJkiRJCRh6IXRJkiRJkiRJkiRJklQKA3xJkiRJkiRJkiRJkhJggC9JkiRJkiRJkiRJUgIM8CVJkiRJkiRJkiRJSoABviRJkiRJkiRJkiRJCTDAlyRJkiRJkiRJkiQpAQb4kiRJkiRJkiRJkiQlwABfkiRJkiRJkiRJkqQEGOBLkiRJkiRJkiRJkpQAA3xJkiRJkiRJkiRJkhJggC9JkiRJkiRJkiRJUgIM8CVJkiRJkiRJkiRJSoABviRJkiRJkiRJkiRJCTDAlyRJkiRJkiRJkiQpAQb4kiRJkiRJkiRJkiQlwABfkiRJkiS1Zfr06WHEiBHhhz/84Rr/9uUvfzn+26c+9Sn3siRJkiRJwxjR39/fP9w3SZIkSZIkDea5554Le+65Z3j66afDzTffHP8b11xzTZgyZUrYZZddwm233RbWX399d6IkSZIkSUMwwJckSZIkSW2bO3dumDRpUhg3bly44447wssvvxzGjx8fli1bFsP73Xbbzb0sSZIkSdIwnEJfkiRJkiS1bf/99w///M//HB588MHw2c9+Nhx//PHhqaeeCj/4wQ8M7yVJkiRJapAd+JIkSZIkKRes0nfEEUeEq666Kv7/xz72sXDOOee4dyVJkiRJapAd+JIkSZIkKRcjRowIM2bMWPX/f/M3f+OelSRJkiSpCXbgS5IkSZKkXDB9/l577RXWWWedsGzZsjh1/q233hrWXXdd97AkSZIkSQ2wA1+SJEmSJLVtxYoV4ZhjjgkvvfRSOO+888I//uM/hrvvvtsufEmSJEmSmmCAL0mSJEmS2nbqqaeGO++8M/z93/99mDJlSvja174WDjjggPCTn/wknH/++e5hSZIkSZIa4BT6kiRJkiSpLRdffHGYMWNGmDBhQvjNb34T1l577fj3jz32WNhjjz3Ca6+9FsP9HXbYwT0tSZIkSdIQDPAlSZIkSVLLHn300RjSv/HGGzGkHzdu3Gr/PnPmzDB9+vSwzz77xHB/5MiR7m1JkiRJkgZhgC9JkiRJkiRJkiRJUgLWqnoDJEmSJEmSJEmSJEmSAb4kSZIkSZIkSZIkSUmwA1+SJEmSJEmSJEmSpAQY4EuSJEmSJEmSJEmSlAADfEmSJEmSJEmSJEmSEmCAL0mSJEmSJEmSJElSAgzwJUmSJEmSJEmSJElKgAG+JEmSJEmSJEmSJEkJMMCXJEmSJEmSJEmSJCkBBviSJEmSJEmSJEmSJCXAAF+SJEmSJEmSJEmSpAQY4EuSJEmSJEmSJEmSlAADfEmSJEmSJEmSJEmSEmCAL0mSJEmSJEmSJElSAgzwJUmSJEmSJEmSJElKgAG+JEmSJEmSJEmSJEkJMMCXJEmSJEmSJEmSJClU7/8BFzYx4pfMAywAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "ax.scatter(x[subsample], y[subsample], s = 6, alpha = 0.25, c = \"k\", zorder = 1, label = \"observations\")\n", + "ax.plot(grid_x, mean, \"C0\", lw = 2, zorder = 3, label = \"SVGP mean\")\n", + "ax.fill_between(grid_x, y_lo, y_hi, color = \"C0\", alpha = 0.12, zorder = 2)\n", + "ax.fill_between(grid_x, f_lo, f_hi, color = \"C0\", alpha = 0.30, zorder = 2)\n", + "ax.plot(\n", + " grid_x,\n", + " np.sin(grid_x) + np.cos(0.75 * grid_x),\n", + " \"C3\",\n", + " lw = 1.5,\n", + " ls = \"--\",\n", + " zorder = 4,\n", + " label = \"true function\",\n", + ")\n", + "\n", + "# inducing points migrate from their init (gray) to their optimized locations (red)\n", + "y_init = y.min() - 0.85\n", + "y_final = y.min() - 0.35\n", + "for x_from, x_to in zip(z_init_x, z_final_x):\n", + " ax.annotate(\n", + " \"\",\n", + " xy = (x_to, y_final),\n", + " xytext = (x_from, y_init),\n", + " arrowprops = dict(arrowstyle = \"->\", color = \"0.55\", lw = 0.6, shrinkA = 4, shrinkB = 4),\n", + " )\n", + "ax.scatter(\n", + " z_init_x,\n", + " np.full(M, y_init),\n", + " marker = \"^\",\n", + " c = \"0.7\",\n", + " s = 22,\n", + " zorder = 4,\n", + " label = \"inducing init\",\n", + ")\n", + "ax.scatter(\n", + " z_final_x,\n", + " np.full(M, y_final),\n", + " marker = \"^\",\n", + " c = \"r\",\n", + " s = 40,\n", + " zorder = 5,\n", + " label = \"inducing (optimized)\",\n", + ")\n", + "\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_title(\"SVGP posterior\")\n", + "ax.legend(loc = \"upper right\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bf7d8fbe", + "metadata": {}, + "source": [ + "### Looking inside: the variational posterior over $\\mathbf u$\n", + "\n", + "Because SVGP keeps $q(\\mathbf u)$ explicit, we can inspect what the model learned at the inducing inputs directly. Predicting the latent function at $Z$ gives the posterior over the inducing values in function space (whitening handled for us). The error bars are tight where data pins the function down and widen at the edges." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "4df17309", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu_z, var_z = predict(Z_final)\n", + "sd_z = np.sqrt(var_z)\n", + "\n", + "mean_z = to_y(mu_z)\n", + "lo_z = to_y(mu_z - 2 * sd_z)\n", + "hi_z = to_y(mu_z + 2 * sd_z)\n", + "order = np.argsort(z_final_x)\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "ax.plot(grid_x, mean, \"C0\", alpha = 0.4, zorder = 1, label = \"SVGP mean\")\n", + "ax.errorbar(\n", + " z_final_x[order],\n", + " mean_z[order],\n", + " yerr = [(mean_z - lo_z)[order], (hi_z - mean_z)[order]],\n", + " fmt = \"o\",\n", + " color = \"C1\",\n", + " capsize = 3,\n", + " zorder = 3,\n", + " label = r\"$q(\\mathbf{u})$ at inducing inputs\",\n", + ")\n", + "\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_title(r\"Variational posterior over the inducing values\")\n", + "ax.legend(loc = \"upper right\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "293cee6d", + "metadata": {}, + "source": [ + "## Scaling to real data: California housing\n", + "\n", + "The 1D example fit in seconds; its point was mechanics, not size. Here SVGP earns its keep. The California housing dataset {cite:p}`pace-barry-1997` records 20,640 census block groups; we model the spatial surface of log median house value from longitude and latitude alone.\n", + "\n", + "At $N = 20{,}640$ an exact GP would factorize a $20{,}640 \\times 20{,}640$ matrix, and VFE would revisit all 20,640 points every step. SVGP just draws a minibatch. We standardize the coordinates, take the log of the price (right-skewed and value-capped), and standardize that too." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "c78fef83", + "metadata": {}, + "outputs": [], + "source": [ + "housing_url = \"https://raw.githubusercontent.com/ageron/handson-ml2/master/datasets/housing/housing.csv\"\n", + "housing_csv = Path(\"housing.csv\")\n", + "if not housing_csv.exists():\n", + " pd.read_csv(housing_url).to_csv(housing_csv, index = False) # cache locally\n", + "housing = pd.read_csv(housing_csv)\n", + "\n", + "lonlat = housing[[\"longitude\", \"latitude\"]].to_numpy(float)\n", + "price = np.log(housing[\"median_house_value\"].to_numpy(float))\n", + "\n", + "xy_scaler = StandardScaler().fit(lonlat)\n", + "p_scaler = StandardScaler().fit(price[:, None])\n", + "\n", + "XY = xy_scaler.transform(lonlat)\n", + "P = p_scaler.transform(price[:, None]).ravel()\n", + "N2 = XY.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "7069af67", + "metadata": {}, + "outputs": [], + "source": [ + "# California outline (GeoJSON) to mask predictions and overlay the coastline\n", + "geojson_url = \"https://eric.clst.org/assets/wiki/uploads/Stuff/gz_2010_us_040_00_500k.json\"\n", + "geojson_cache = Path(\"california.geojson\")\n", + "if not geojson_cache.exists():\n", + " urllib.request.urlretrieve(geojson_url, geojson_cache)\n", + "\n", + "with open(geojson_cache) as f:\n", + " states = json.load(f)[\"features\"]\n", + "california = next(s[\"geometry\"] for s in states if s[\"properties\"][\"NAME\"] == \"California\")\n", + "\n", + "if california[\"type\"] == \"Polygon\":\n", + " ca_rings = [california[\"coordinates\"][0]]\n", + "else:\n", + " ca_rings = [polygon[0] for polygon in california[\"coordinates\"]]\n", + "ca_path = MplPath(np.array(max(ca_rings, key = len))[:, :2])\n", + "\n", + "\n", + "def draw_california(ax):\n", + " for ring in ca_rings:\n", + " lon = np.array(ring)[:, 0]\n", + " lat = np.array(ring)[:, 1]\n", + " ax.plot(lon, lat, color = \"0.25\", lw = 0.8, zorder = 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "e8ac8761", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (7, 7))\n", + "\n", + "scatter = ax.scatter(lonlat[:, 0], lonlat[:, 1], c = price, s = 6, cmap = \"viridis\")\n", + "draw_california(ax)\n", + "\n", + "ax.set_xlabel(\"longitude\")\n", + "ax.set_ylabel(\"latitude\")\n", + "ax.set_title(f\"California housing (N = {N2:,})\")\n", + "fig.colorbar(scatter, ax = ax, label = \"log median house value\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1b069bdf", + "metadata": {}, + "source": [ + "### Building and training\n", + "\n", + "Same shape as the 1D model, with a two-dimensional Matern 5/2 kernel and $M = 150$ inducing inputs. `greedy_variance_init` seeds them space-filling across the state; from there they are optimized along with everything else, migrating toward where the price surface has structure. We train for 5,000 minibatch steps of size 512 and plot the loss to confirm it settles." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "1174d6dd", + "metadata": {}, + "outputs": [], + "source": [ + "M2 = 150\n", + "\n", + "inducing_kernel_2d = pg.kernels.Matern52(input_dim = 2, ls = 0.5)\n", + "Z_init_2d = pg.inducing.greedy_variance_init(XY, M = M2, kernel = inducing_kernel_2d, rng = 0)[0].Z\n", + "\n", + "Z_var_2d = pt.matrix(\"Z2\", shape = (M2, 2))\n", + "inducing2 = pg.inducing.Points(Z_var_2d, Z_init = Z_init_2d)\n", + "vp2 = pg.gp.init_variational_params(M = M2)\n", + "\n", + "XY_var = pt.matrix(\"XY\", shape = (None, 2))\n", + "p_var = pt.vector(\"p\", shape = (None,))\n", + "\n", + "with pm.Model() as model_2d:\n", + " ls = pm.InverseGamma(\"ls\", alpha = 3.0, beta = 1.0)\n", + " eta = pm.Exponential(\"eta\", scale = 1.0)\n", + " sigma = pm.HalfNormal(\"sigma\", sigma = 1.0)\n", + "\n", + " kernel = eta**2 * pg.kernels.Matern52(input_dim = 2, ls = ls)\n", + " svgp2 = pg.gp.SVGP(\n", + " kernel = kernel,\n", + " likelihood = pg.likelihoods.Gaussian(sigma = sigma),\n", + " inducing_variable = inducing2,\n", + " variational_params = vp2,\n", + " whiten = True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "c79ff427", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "recovered: {'ls': 0.205, 'eta': 0.726, 'sigma': 0.583}\n" + ] + } + ], + "source": [ + "def elbo_objective_2d(gp, X, y):\n", + " return pg.objectives.elbo(gp, X, y, n_data = N2).elbo\n", + "\n", + "\n", + "train_step_2d, shared_params_2d, shared_extras_2d = pg.optim.compile_training_step(\n", + " objective_fn = elbo_objective_2d,\n", + " gp_model = svgp2,\n", + " X_var = XY_var,\n", + " y_var = p_var,\n", + " model = model_2d,\n", + " extra_vars = svgp2.extra_vars,\n", + " extra_init = svgp2.extra_init,\n", + " learning_rate = pg.optim.schedules.exponential_decay(1e-2, decay_rate = 0.3, decay_steps = 3000),\n", + ")\n", + "\n", + "batch_size_2d = 512\n", + "n_steps_2d = 5000\n", + "\n", + "losses_2d = []\n", + "for step in range(n_steps_2d):\n", + " batch = rng.choice(N2, size = batch_size_2d, replace = False)\n", + " losses_2d.append(float(train_step_2d(XY[batch], P[batch])))\n", + "\n", + "params_2d = pg.optim.get_trained_params(model = model_2d, shared_params = shared_params_2d)\n", + "print(\"recovered:\", {name: round(float(value), 3) for name, value in params_2d.items()})" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "643b514f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (14, 3))\n", + "\n", + "ax.plot(losses_2d, lw = 0.6)\n", + "ax.set_yscale(\"symlog\")\n", + "\n", + "ax.set_xlabel(\"minibatch step\")\n", + "ax.set_ylabel(\"loss (-ELBO estimate)\")\n", + "ax.set_title(\"SVGP training loss (2D)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "542bfd65", + "metadata": {}, + "outputs": [], + "source": [ + "XY_new = pt.matrix(\"XY_new\", shape = (None, 2))\n", + "predict_2d = pg.optim.compile_predict(\n", + " gp_model = svgp2,\n", + " X_new_var = XY_new,\n", + " model = model_2d,\n", + " shared_params = shared_params_2d,\n", + " shared_extras = shared_extras_2d,\n", + ")\n", + "\n", + "resolution = 200\n", + "grid_lon, grid_lat = np.meshgrid(\n", + " np.linspace(lonlat[:, 0].min(), lonlat[:, 0].max(), resolution),\n", + " np.linspace(lonlat[:, 1].min(), lonlat[:, 1].max(), resolution),\n", + ")\n", + "grid_lonlat = np.column_stack([grid_lon.ravel(), grid_lat.ravel()])\n", + "\n", + "mu_grid, _ = predict_2d(xy_scaler.transform(grid_lonlat))\n", + "mean_price = p_scaler.inverse_transform(mu_grid[:, None]).ravel()\n", + "mean_price[~ca_path.contains_points(grid_lonlat)] = np.nan # mask outside California\n", + "mean_price = mean_price.reshape(grid_lon.shape)\n", + "\n", + "z_init = xy_scaler.inverse_transform(Z_init_2d)\n", + "z_final = xy_scaler.inverse_transform(shared_extras_2d[-1].get_value())" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "934f7af3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (7, 7))\n", + "\n", + "mesh = ax.pcolormesh(grid_lon, grid_lat, mean_price, cmap = \"viridis\", shading = \"auto\")\n", + "draw_california(ax)\n", + "\n", + "ax.quiver(\n", + " z_init[:, 0],\n", + " z_init[:, 1],\n", + " z_final[:, 0] - z_init[:, 0],\n", + " z_final[:, 1] - z_init[:, 1],\n", + " angles = \"xy\",\n", + " scale_units = \"xy\",\n", + " scale = 1,\n", + " color = \"w\",\n", + " width = 0.002,\n", + " headwidth = 4,\n", + " headlength = 6,\n", + " alpha = 0.9,\n", + " zorder = 5,\n", + ")\n", + "ax.scatter(\n", + " z_init[:, 0],\n", + " z_init[:, 1],\n", + " s = 14,\n", + " facecolors = \"none\",\n", + " edgecolors = \"w\",\n", + " lw = 0.6,\n", + " zorder = 4,\n", + " label = \"inducing init\",\n", + ")\n", + "ax.scatter(\n", + " z_final[:, 0],\n", + " z_final[:, 1],\n", + " marker = \"x\",\n", + " c = \"r\",\n", + " s = 30,\n", + " lw = 1.0,\n", + " zorder = 6,\n", + " label = \"inducing (optimized)\",\n", + ")\n", + "\n", + "ax.set_xlabel(\"longitude\")\n", + "ax.set_ylabel(\"latitude\")\n", + "ax.set_title(\"SVGP predictive mean: log median house value\")\n", + "ax.legend(loc = \"upper right\")\n", + "fig.colorbar(mesh, ax = ax, label = \"log median house value\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3828041e", + "metadata": {}, + "source": [ + "## Next steps\n", + "\n", + "- {ref}`Introduction to PTGP `: exact GPs and the VFE bound this notebook builds on.\n", + "- {doc}`Kernel gallery ` and {doc}`user guide `: kernels, likelihoods, inducing-point strategies, and training in depth.\n", + "- Non-Gaussian likelihoods: the uncollapsed ELBO's data term is an expectation under $q(f_i)$, which PTGP evaluates by Gauss-Hermite quadrature for any `ptgp.likelihoods` member, so swapping `Gaussian` for `Bernoulli`, `Poisson`, or `StudentT` is a one-line change.\n", + "- Variational Fourier Features replace pseudo-input inducing points with a Fourier basis for 1D Matern kernels; a dedicated notebook is forthcoming.\n", + "\n", + "## References\n", + "\n", + "```{bibliography}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb deleted file mode 100644 index 99949ba..0000000 --- a/notebooks/demo.ipynb +++ /dev/null @@ -1,899 +0,0 @@ -{ - "cells": [ - { - "metadata": {}, - "cell_type": "markdown", - "source": "# PTGP VFF Demo\n", - "id": "fff54d16bc48672f" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "import numpy as np\n", - "import pymc as pm\n", - "import pytensor\n", - "import pytensor.tensor as pt\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import ptgp as pg" - ], - "id": "db0f87517989a0ed" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "## Generate data, student-t noise", - "id": "4e68756f34dd225e" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "rng = np.random.default_rng(600)\n", - "N = 200\n", - "noise_std = 0.2\n", - "nu_true = 6\n", - "\n", - "# True GP hyperparameters\n", - "eta_true = 1.3\n", - "ls_true = 1.0\n", - "\n", - "X_train = np.sort(rng.uniform(0, 10, N))[:, None]\n", - "X_test = np.linspace(-1, 11, 200)[:, None]\n", - "\n", - "# Draw from a GP prior with Matern-5/2 kernel\n", - "K = eta_true**2 * pg.kernels.Matern52(input_dim=1, ls=ls_true)\n", - "K = K(X_train, X_train).eval() + 1e-6 * np.eye(N)\n", - "\n", - "f_train = rng.multivariate_normal(np.zeros(N), K)\n", - "y_train = f_train + noise_std * rng.standard_t(df=nu_true, size=N)\n", - "\n", - "plt.scatter(X_train, y_train, s=10, label=\"data\")\n", - "plt.plot(X_train, f_train, \"k--\", alpha=0.5, label=\"true f\")\n", - "plt.legend()\n", - "plt.title(\"Training data\")" - ], - "id": "9f709e82cae94b7d" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "## Exact GP", - "id": "5279c6ca3c90a0cd" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "import time\n", - "import scipy.optimize\n", - "\n", - "# Data is 1-D (D=1); batch dim is None to allow any N.\n", - "X_var = pt.matrix(\"X\", shape=(None, 1))\n", - "y_var = pt.vector(\"y\", shape=(None,))\n", - "\n", - "with pm.Model() as gp_model:\n", - " ls = pm.HalfFlat(\"ls\")\n", - " eta = pm.Exponential(\"eta\", scale=2.0)\n", - " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", - "\n", - " kernel = eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls)\n", - " gp = pg.gp.Unapproximated(kernel=kernel, sigma=sigma)\n", - "\n", - " fun, theta0, unpack_to_shared, shared_params, shared_extras = pg.optim.compile_scipy_objective(\n", - " pg.objectives.marginal_log_likelihood,\n", - " gp,\n", - " X_var,\n", - " y_var,\n", - " )\n", - "\n", - "t0 = time.time()\n", - "result = scipy.optimize.minimize(\n", - " fun,\n", - " theta0,\n", - " args=(X_train, y_train),\n", - " jac=True,\n", - " method=\"L-BFGS-B\",\n", - ")\n", - "elapsed = time.time() - t0\n", - "unpack_to_shared(result.x)\n", - "print(f\"converged in {result.nit} iterations, loss = {result.fun:.4f}, time = {elapsed:.2f}s\")\n", - "\n", - "params = pg.optim.get_trained_params(gp_model, shared_params)\n", - "print(f\"\\nRecovered: {params}\")\n", - "print(f\"True: eta={eta_true}, ls={ls_true}, noise_std={noise_std}\")" - ], - "id": "9ede0cd1ca9eb66f" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "X_new_var = pt.matrix(\"X_new\", shape=(None, 1))\n", - "predict_gp = pg.optim.compile_predict(\n", - " gp,\n", - " X_new_var,\n", - " gp_model,\n", - " shared_params,\n", - " X_train=X_train,\n", - " y_train=y_train,\n", - ")\n", - "predict_gp_y = pg.optim.compile_predict(\n", - " gp,\n", - " X_new_var,\n", - " gp_model,\n", - " shared_params,\n", - " X_train=X_train,\n", - " y_train=y_train,\n", - " incl_lik=True,\n", - ")\n", - "\n", - "mu_gp, var_gp = predict_gp(X_test)\n", - "_, var_gp_y = predict_gp_y(X_test)\n", - "sd_gp = np.sqrt(var_gp)\n", - "sd_gp_y = np.sqrt(var_gp_y)\n", - "\n", - "plt.figure(figsize=(10, 4))\n", - "plt.scatter(X_train, y_train, s=10, c=\"k\", zorder=3, label=\"data\")\n", - "plt.plot(X_test, mu_gp, \"C0\", label=\"GP mean\")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_gp - 2 * sd_gp_y,\n", - " mu_gp + 2 * sd_gp_y,\n", - " alpha=0.1,\n", - " color=\"C0\",\n", - " label=\"y 2 sd\",\n", - ")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_gp - 2 * sd_gp,\n", - " mu_gp + 2 * sd_gp,\n", - " alpha=0.3,\n", - " color=\"C0\",\n", - " label=\"f 2 sd\",\n", - ")\n", - "plt.plot(X_train, f_train, \"k--\", alpha=0.3, label=\"true f\")\n", - "plt.legend()\n", - "plt.title(\"Exact GP\")" - ], - "id": "32952e9ee751681c" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "### One-liner alternative: `pg.fit` and `pg.predict`\n", - "\n", - "The cells above are the step-by-step API: build symbolic placeholders, compile a scipy objective, run the optimizer, unpack into shared vars, then compile a predictor. When you don't need that much control, the convenience API in `ptgp.optim.api` does the same thing in two lines. It picks a default objective from the gp type (`Unapproximated` → `marginal_log_likelihood`, `VFE` → `collapsed_elbo`, `SVGP` → `elbo`) and bundles the trained shared state into a `FitResult` that `pg.predict` consumes." - ], - "id": "86dee7b581771c5e" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "with pm.Model() as gp_model_easy:\n", - " ls = pm.HalfFlat(\"ls\")\n", - " eta = pm.Exponential(\"eta\", scale=2.0)\n", - " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", - " gp_easy = pg.gp.Unapproximated(\n", - " kernel=eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls), sigma=sigma\n", - " )\n", - " fit = pg.fit(gp_easy, X_train, y_train)\n", - "\n", - "mu_easy, var_easy = pg.predict(gp_easy, X_test, fit, X_train=X_train, y_train=y_train)\n", - "print(f\"Recovered: {fit.params}\")\n", - "print(f\"max |mu_easy - mu_gp| = {np.max(np.abs(mu_easy - mu_gp)):.2e}\")" - ], - "id": "27acaa10030a6fed" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "## VFE (Sparse GP -- collapsed bound)", - "id": "4954e963df915b20" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "M = 20\n", - "Z_init = np.linspace(-0.5, 10.5, M)[:, None]\n", - "\n", - "# Inducing points: M is known (20), D=1.\n", - "Z_var = pt.matrix(\"Z\", shape=(M, 1))\n", - "\n", - "with pm.Model() as vfe_model:\n", - " ls = pm.HalfFlat(\"ls\")\n", - " eta = pm.Exponential(\"eta\", lam=1.0)\n", - " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", - "\n", - " vfe = pg.gp.VFE(\n", - " kernel=eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls),\n", - " sigma=sigma,\n", - " inducing_variable=pg.inducing.Points(Z_var, Z_init=Z_init),\n", - " )\n", - "\n", - "fun_vfe, theta0_vfe, unpack_to_shared_vfe, shared_params_vfe, shared_extras_vfe = (\n", - " pg.optim.compile_scipy_objective(\n", - " pg.objectives.collapsed_elbo,\n", - " vfe,\n", - " X_var,\n", - " y_var,\n", - " model=vfe_model,\n", - " )\n", - ")\n", - "\n", - "t0 = time.time()\n", - "result_vfe = scipy.optimize.minimize(\n", - " fun_vfe,\n", - " theta0_vfe,\n", - " args=(X_train, y_train),\n", - " jac=True,\n", - " method=\"L-BFGS-B\",\n", - ")\n", - "elapsed = time.time() - t0\n", - "unpack_to_shared_vfe(result_vfe.x)\n", - "print(\n", - " f\"converged in {result_vfe.nit} iterations, loss = {result_vfe.fun:.4f}, time = {elapsed:.2f}s\"\n", - ")\n", - "\n", - "params_vfe = pg.optim.get_trained_params(vfe_model, shared_params_vfe)\n", - "print(f\"\\nRecovered: {params_vfe}\")\n", - "print(f\"True: eta={eta_true}, ls={ls_true}, noise_std={noise_std}\")" - ], - "id": "4a11ebce4ee3120c" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "predict_vfe = pg.optim.compile_predict(\n", - " vfe,\n", - " X_new_var,\n", - " vfe_model,\n", - " shared_params_vfe,\n", - " shared_extras=shared_extras_vfe,\n", - " X_train=X_train,\n", - " y_train=y_train,\n", - ")\n", - "predict_vfe_y = pg.optim.compile_predict(\n", - " vfe,\n", - " X_new_var,\n", - " vfe_model,\n", - " shared_params_vfe,\n", - " shared_extras=shared_extras_vfe,\n", - " X_train=X_train,\n", - " y_train=y_train,\n", - " incl_lik=True,\n", - ")\n", - "\n", - "mu_vfe, var_vfe = predict_vfe(X_test)\n", - "_, var_vfe_y = predict_vfe_y(X_test)\n", - "sd_vfe = np.sqrt(var_vfe)\n", - "sd_vfe_y = np.sqrt(var_vfe_y)\n", - "\n", - "Z_final = shared_extras_vfe[0].get_value()\n", - "\n", - "plt.figure(figsize=(10, 4))\n", - "plt.scatter(X_train, y_train, s=10, c=\"k\", zorder=3, label=\"data\")\n", - "plt.plot(X_test, mu_vfe, \"C0\", label=\"VFE mean\")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_vfe - 2 * sd_vfe_y,\n", - " mu_vfe + 2 * sd_vfe_y,\n", - " alpha=0.1,\n", - " color=\"C0\",\n", - " label=\"y 2 sd\",\n", - ")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_vfe - 2 * sd_vfe,\n", - " mu_vfe + 2 * sd_vfe,\n", - " alpha=0.3,\n", - " color=\"C0\",\n", - " label=\"f 2 sd\",\n", - ")\n", - "plt.scatter(Z_final, np.zeros(M) - 2, marker=\"^\", c=\"r\", s=40, label=\"inducing pts\")\n", - "plt.plot(X_train, f_train, \"k--\", alpha=0.3, label=\"true f\")\n", - "plt.legend(loc=\"upper right\")\n", - "plt.title(f\"VFE (M={M})\")" - ], - "id": "cb49e8eede8006fa" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "## SVGP (Stochastic Variational GP)\n", - "\n", - "Minibatch training with variational parameters." - ], - "id": "b6f690adb25232f6" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "M_svgp = 20\n", - "\n", - "Z_init_kernel = pg.kernels.Matern52(input_dim=1, ls=1.0)\n", - "Z_greedy = pg.inducing.greedy_variance_init(X_train, M_svgp, Z_init_kernel, rng=42)[0].Z\n", - "\n", - "vp = pg.gp.init_variational_params(M_svgp)\n", - "Z_var = pt.matrix(\"Z\", shape=(M_svgp, 1))\n", - "\n", - "with pm.Model() as svgp_model:\n", - " ls = pm.HalfFlat(\"ls\")\n", - " eta = pm.Exponential(\"eta\", lam=1.0)\n", - " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", - " nu = pm.Gamma(\"nu\", alpha=2, beta=0.1)\n", - "\n", - " kernel = eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls)\n", - " lik = pg.likelihoods.StudentT(sigma=sigma, nu=nu)\n", - "\n", - " svgp = pg.gp.SVGP(\n", - " kernel=kernel,\n", - " likelihood=lik,\n", - " inducing_variable=pg.inducing.Points(Z_var, Z_init=Z_greedy),\n", - " variational_params=vp,\n", - " )" - ], - "id": "70a681d58a11169f" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "### Training strategy\n", - "\n", - "**Inducing point init.** `greedy_variance_init` picks a space-filling subset of `X_train` via pivoted Cholesky (Burt et al. 2020). It's a strong enough starting point that `Z` often doesn't need further optimization — but here we still fine-tune it in phase 2 to demonstrate the mechanics.\n", - "\n", - "**Two-phase training.** `svgp` is built once with `Z_var` as a symbolic placeholder. Phase 1 pins `Z_var` to `Z_greedy` via `frozen_vars` and trains only the hyperparameters and variational parameters. Phase 2 moves `Z_var` into `extra_vars`, making `Z` trainable, and recompiles using the state carried over from phase 1.\n", - "\n", - "**Learning rates.** Phase 1 runs a single exponential-decay schedule from `1e-2` down to `5e-3` over `n_phase1` steps. Phase 2 uses per-group rates:\n", - "\n", - "- `hyp` — fixed at 50% of phase 1's final LR (gentle fine-tuning once hyperparameters are near optimum).\n", - "- `var` — continues phase 1's decay seamlessly, starting at `5e-3`.\n", - "- `Z` — its own small steady rate (`5e-3`) for the newly unfrozen inducing points." - ], - "id": "150f772638717b6f" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "X_batch_var = pt.matrix(\"X_batch\", shape=(None, 1))\n", - "y_batch_var = pt.vector(\"y_batch\", shape=(None,))\n", - "batch_size = 32\n", - "n_phase1 = 1000\n", - "n_phase2 = 1000\n", - "\n", - "\n", - "def elbo_scaled(model, X, y):\n", - " return pg.objectives.elbo(model, X, y, n_data=N).elbo\n", - "\n", - "\n", - "# ----- Phase 1: Z frozen -----\n", - "phase1_base_lr = 1e-2\n", - "phase1_decay_rate = 0.5\n", - "phase1_final_lr = phase1_base_lr * phase1_decay_rate # LR at t=n_phase1\n", - "\n", - "train_step_1, shared_params_1, shared_extras_1 = pg.optim.compile_training_step(\n", - " elbo_scaled,\n", - " svgp,\n", - " X_batch_var,\n", - " y_batch_var,\n", - " model=svgp_model,\n", - " extra_vars=vp.extra_vars,\n", - " extra_init=vp.extra_init,\n", - " frozen_vars={Z_var: Z_greedy},\n", - " learning_rate=pg.optim.schedules.exponential_decay(\n", - " phase1_base_lr,\n", - " decay_rate=phase1_decay_rate,\n", - " decay_steps=n_phase1,\n", - " ),\n", - ")\n", - "\n", - "losses = []\n", - "t0 = time.time()\n", - "for step in range(n_phase1):\n", - " idx = rng.choice(N, size=batch_size, replace=False)\n", - " loss = train_step_1(X_train[idx], y_train[idx])\n", - " losses.append(float(loss))\n", - " if step % 250 == 0:\n", - " print(f\"[phase 1, Z frozen] Step {step}: loss = {loss:.2f}\")\n", - "elapsed_1 = time.time() - t0\n", - "\n", - "# ----- Phase 2: Z trainable -----\n", - "hyp_value_vars = [svgp_model.rvs_to_values[rv] for rv in (ls, eta, sigma, nu)]\n", - "phase2_hyp_lr = 0.5 * phase1_final_lr\n", - "\n", - "train_step_2, shared_params_svgp, shared_extras_svgp = pg.optim.compile_training_step(\n", - " elbo_scaled,\n", - " svgp,\n", - " X_batch_var,\n", - " y_batch_var,\n", - " model=svgp_model,\n", - " param_groups={\n", - " \"hyp\": hyp_value_vars,\n", - " \"var\": vp.extra_vars,\n", - " \"Z\": [Z_var],\n", - " },\n", - " learning_rate={\n", - " \"hyp\": phase2_hyp_lr,\n", - " \"var\": pg.optim.schedules.exponential_decay(\n", - " phase1_final_lr,\n", - " decay_rate=phase1_decay_rate,\n", - " decay_steps=n_phase1,\n", - " ),\n", - " \"Z\": 5e-3,\n", - " },\n", - ")\n", - "\n", - "# Carry phase-1 state into phase 2 (q_mu, q_sqrt_flat shared values).\n", - "for vv, sh1 in shared_params_1.items():\n", - " shared_params_svgp[vv].set_value(sh1.get_value())\n", - "for sh2, sh1 in zip(shared_extras_svgp[: len(vp.extra_vars)], shared_extras_1):\n", - " sh2.set_value(sh1.get_value())\n", - "\n", - "t0 = time.time()\n", - "for step in range(n_phase2):\n", - " idx = rng.choice(N, size=batch_size, replace=False)\n", - " loss = train_step_2(X_train[idx], y_train[idx])\n", - " losses.append(float(loss))\n", - " if step % 250 == 0:\n", - " print(f\"[phase 2, Z trainable] Step {step}: loss = {loss:.2f}\")\n", - "elapsed_2 = time.time() - t0\n", - "\n", - "params_svgp = pg.optim.get_trained_params(svgp_model, shared_params_svgp)\n", - "print(f\"\\nRecovered: {params_svgp}\")\n", - "print(f\"True: eta={eta_true}, ls={ls_true}, noise_std={noise_std}, nu={nu_true}\")\n", - "print(\n", - " f\"\\ntraining time: phase 1 = {elapsed_1:.2f}s, phase 2 = {elapsed_2:.2f}s, total = {elapsed_1 + elapsed_2:.2f}s\"\n", - ")" - ], - "id": "7a94d7e90de5b1e9" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "plt.figure(figsize=(10, 3))\n", - "plt.plot(losses)\n", - "plt.axvline(n_phase1, color=\"k\", linestyle=\":\", alpha=0.5, label=\"phase 2 begins (Z trainable)\")\n", - "plt.xlabel(\"step\")\n", - "plt.ylabel(\"neg ELBO\")\n", - "plt.legend()\n", - "plt.title(\"SVGP training loss\")" - ], - "id": "a1a27f7ec806beea" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "predict_svgp = pg.optim.compile_predict(\n", - " svgp,\n", - " X_new_var,\n", - " svgp_model,\n", - " shared_params_svgp,\n", - " shared_extras=shared_extras_svgp,\n", - ")\n", - "predict_svgp_y = pg.optim.compile_predict(\n", - " svgp,\n", - " X_new_var,\n", - " svgp_model,\n", - " shared_params_svgp,\n", - " shared_extras=shared_extras_svgp,\n", - " incl_lik=True,\n", - ")\n", - "\n", - "mu_svgp, var_svgp = predict_svgp(X_test)\n", - "mu_svgp_y, var_svgp_y = predict_svgp_y(X_test)\n", - "sd_svgp = np.sqrt(var_svgp)\n", - "sd_svgp_y = np.sqrt(var_svgp_y)\n", - "\n", - "plt.figure(figsize=(10, 4))\n", - "plt.scatter(X_train, y_train, s=10, c=\"k\", zorder=3, label=\"data\")\n", - "plt.plot(X_test, mu_svgp, \"C0\", label=\"SVGP mean\")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_svgp_y - 2 * sd_svgp_y,\n", - " mu_svgp_y + 2 * sd_svgp_y,\n", - " alpha=0.1,\n", - " color=\"C0\",\n", - " label=\"y 2 sd\",\n", - ")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_svgp - 2 * sd_svgp,\n", - " mu_svgp + 2 * sd_svgp,\n", - " alpha=0.3,\n", - " color=\"C0\",\n", - " label=\"f 2 sd\",\n", - ")\n", - "Z_opt = shared_extras_svgp[len(vp.extra_vars)].get_value()\n", - "plt.scatter(\n", - " Z_greedy.ravel(),\n", - " np.zeros(M_svgp) - 2.4,\n", - " marker=\"^\",\n", - " c=\"C1\",\n", - " s=35,\n", - " alpha=0.6,\n", - " label=\"Z init (greedy)\",\n", - ")\n", - "plt.scatter(\n", - " Z_opt.ravel(),\n", - " np.zeros(M_svgp) - 2.0,\n", - " marker=\"^\",\n", - " c=\"r\",\n", - " s=40,\n", - " label=\"Z final (optimized)\",\n", - ")\n", - "plt.plot(X_train, f_train, \"k--\", alpha=0.3, label=\"true f\")\n", - "plt.legend(loc=\"upper right\")\n", - "plt.title(f\"SVGP (M={M_svgp})\")" - ], - "id": "d03374b240a0a533" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "## VFF (Variational Fourier Features)\n", - "\n", - "Inter-domain inducing variables: a Fourier basis defined on `[a, b]` instead of pseudo-inputs `Z`. For Matérn52 VFF the interval must cover the prediction range because reference edge covariances are not implemented; keep a buffer around the plotted range to avoid boundary artifacts. The structured `Kuu = diag(d) + UUᵀ` is solved analytically (Woodbury), so each step is O(M) instead of O(M³).\n" - ], - "id": "f3c76e6e08586c59" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "vff_pad = 1.0\n", - "f_vff = pg.FourierFeatures1D(\n", - " a=float(min(X_train.min(), X_test.min()) - vff_pad),\n", - " b=float(max(X_train.max(), X_test.max()) + vff_pad),\n", - " num_frequencies=15,\n", - ")\n", - "M_vff = f_vff.num_inducing # 2K+1\n", - "vp_vff = pg.gp.init_variational_params(M_vff)\n", - "\n", - "with pm.Model() as vff_model:\n", - " ls = pm.HalfFlat(\"ls\")\n", - " eta = pm.Exponential(\"eta\", lam=1.0)\n", - " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", - " nu = pm.Gamma(\"nu\", alpha=2, beta=0.1)\n", - "\n", - " kernel_vff = eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls)\n", - " lik_vff = pg.likelihoods.StudentT(sigma=sigma, nu=nu)\n", - "\n", - " svgp_vff = pg.gp.SVGP(\n", - " kernel=kernel_vff,\n", - " likelihood=lik_vff,\n", - " inducing_variable=f_vff,\n", - " variational_params=vp_vff,\n", - " )\n", - "\n", - "train_step_vff, shared_params_vff, shared_extras_vff = pg.optim.compile_training_step(\n", - " pg.objectives.elbo,\n", - " svgp_vff,\n", - " X_var,\n", - " y_var,\n", - " model=vff_model,\n", - " learning_rate=1e-2,\n", - ")\n", - "\n", - "t0 = time.time()\n", - "losses_vff = [float(train_step_vff(X_train, y_train)) for _ in range(800)]\n", - "elapsed_vff = time.time() - t0\n", - "\n", - "print(\n", - " f\"M = 2K+1 = {M_vff}, neg-ELBO: {losses_vff[0]:.1f} -> {losses_vff[-1]:.1f}, time = {elapsed_vff:.2f}s\"\n", - ")\n", - "print(f\"\\nRecovered: {pg.optim.get_trained_params(vff_model, shared_params_vff)}\")\n", - "print(f\"True: eta={eta_true}, ls={ls_true}, noise_std={noise_std}\")" - ], - "id": "9b72e99423193a39" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "predict_vff = pg.optim.compile_predict(\n", - " svgp_vff,\n", - " X_new_var,\n", - " vff_model,\n", - " shared_params_vff,\n", - " shared_extras=shared_extras_vff,\n", - ")\n", - "predict_vff_y = pg.optim.compile_predict(\n", - " svgp_vff,\n", - " X_new_var,\n", - " vff_model,\n", - " shared_params_vff,\n", - " shared_extras=shared_extras_vff,\n", - " incl_lik=True,\n", - ")\n", - "mu_vff, var_vff = predict_vff(X_test)\n", - "_, var_vff_y = predict_vff_y(X_test)\n", - "sd_vff = np.sqrt(var_vff)\n", - "sd_vff_y = np.sqrt(var_vff_y)\n", - "\n", - "plt.figure(figsize=(10, 4))\n", - "plt.axvspan(f_vff.a, f_vff.b, color=\"0.92\", label=\"VFF domain [a, b]\")\n", - "plt.scatter(X_train, y_train, s=10, c=\"k\", zorder=3, label=\"data\")\n", - "plt.plot(X_test, mu_vff, \"C0\", label=\"VFF mean\")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_vff - 2 * sd_vff_y,\n", - " mu_vff + 2 * sd_vff_y,\n", - " alpha=0.1,\n", - " color=\"C0\",\n", - " label=\"y 2 sd\",\n", - ")\n", - "plt.fill_between(\n", - " X_test.ravel(),\n", - " mu_vff - 2 * sd_vff,\n", - " mu_vff + 2 * sd_vff,\n", - " alpha=0.3,\n", - " color=\"C0\",\n", - " label=\"f 2 sd\",\n", - ")\n", - "plt.plot(X_train, f_train, \"k--\", alpha=0.3, label=\"true f\")\n", - "plt.legend(loc=\"upper right\")\n", - "plt.title(f\"VFF-SVGP (M = 2K+1 = {M_vff})\")" - ], - "id": "48a96ee33289b1b9" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "## Comparison\n", - "id": "7577593dc6dadcaf" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "fig, axes = plt.subplots(4, 1, figsize=(10, 12), sharex=True, sharey=True)\n", - "\n", - "for ax, (mu, sd_f, sd_y, title) in zip(\n", - " axes,\n", - " [\n", - " (mu_gp, sd_gp, sd_gp_y, \"Exact GP\"),\n", - " (mu_vfe, sd_vfe, sd_vfe_y, f\"VFE (M={M})\"),\n", - " (mu_svgp, sd_svgp, sd_svgp_y, f\"SVGP (M={M_svgp})\"),\n", - " (mu_vff, sd_vff, sd_vff_y, f\"VFF (M={M_vff})\"),\n", - " ],\n", - "):\n", - " ax.scatter(X_train, y_train, s=8, c=\"k\", zorder=3)\n", - " ax.plot(X_test, mu, \"C0\")\n", - " ax.fill_between(X_test.ravel(), mu - 2 * sd_y, mu + 2 * sd_y, alpha=0.1, color=\"C0\")\n", - " ax.fill_between(X_test.ravel(), mu - 2 * sd_f, mu + 2 * sd_f, alpha=0.3, color=\"C0\")\n", - " ax.plot(X_train, f_train, \"k--\", alpha=0.3)\n", - " ax.set_title(title)\n", - " ax.set_xlim(-1, 11)\n", - "\n", - "fig.tight_layout()" - ], - "id": "4920ebc21de0f13e" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "fig, ax = plt.subplots(figsize=(10, 3.5))\n", - "ax.axhline(0, color=\"k\", lw=0.5)\n", - "ax.plot(X_test, mu_vfe - mu_gp, label=f\"VFE (M={M}) - GP\")\n", - "ax.plot(X_test, mu_svgp - mu_gp, label=f\"SVGP (M={M_svgp}) - GP\")\n", - "ax.plot(X_test, mu_vff - mu_gp, label=f\"VFF (M={M_vff}) - GP\")\n", - "ax.set_xlim(-1, 11)\n", - "ax.set_xlabel(\"x\")\n", - "ax.set_ylabel(r\"$\\mu_{\\mathrm{approx}} - \\mu_{\\mathrm{GP}}$\")\n", - "ax.set_title(\"Posterior mean: deviation from exact GP\")\n", - "ax.legend()" - ], - "id": "9e01067ad6ebe3e1" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "## Wasserstein distance to the exact posterior\n", - "\n", - "Each approximation defines a multivariate-normal posterior over `f(X_test)`. We can quantify how close it is to the exact GP posterior with the [Wasserstein-2 distance between Gaussians](https://en.wikipedia.org/wiki/Wasserstein_metric#Normal_distributions):\n", - "\n", - "$$\n", - "W_2^2\\big(\\mathcal{N}(\\mu_a, \\Sigma_a),\\, \\mathcal{N}(\\mu_b, \\Sigma_b)\\big)\n", - "= \\|\\mu_a - \\mu_b\\|^2 + \\operatorname{tr}\\!\\Big(\\Sigma_a + \\Sigma_b - 2\\big(\\Sigma_a^{1/2} \\Sigma_b \\Sigma_a^{1/2}\\big)^{1/2}\\Big).\n", - "$$\n", - "\n", - "The mean term is the squared difference shown above; the Bures term penalises any difference in covariance structure (variances *and* off-diagonal correlations).\n", - "\n", - "Each model's `predict` only returns marginal variances, so we re-evaluate each posterior with full covariance using the trained shared parameters.\n" - ], - "id": "3f80860d933e8569" - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": [ - "from pytensor.graph.replace import graph_replace\n", - "from scipy.linalg import sqrtm\n", - "\n", - "\n", - "def _replace(outs, model, sp, extra_vars=None, shared_extras=None):\n", - " rep = model.replace_rvs_by_values(outs)\n", - " rmap = dict(sp)\n", - " if extra_vars is not None:\n", - " rmap.update(zip(extra_vars, shared_extras))\n", - " return [graph_replace(r, rmap, strict=False) for r in rep]\n", - "\n", - "\n", - "X_full = pt.matrix(\"X_full\", shape=(None, 1))\n", - "X_train_t = pt.as_tensor(X_train)\n", - "y_train_t = pt.as_tensor(y_train)\n", - "\n", - "# --- Exact GP: dense posterior on X_test ---\n", - "sigma2_gp = gp.likelihood.sigma**2\n", - "K_xx = gp.kernel(X_train_t) + sigma2_gp * pt.eye(N)\n", - "K_xs = gp.kernel(X_train_t, X_full)\n", - "K_ss = gp.kernel(X_full)\n", - "mu_gp_sym = K_xs.T @ pt.linalg.solve(K_xx, y_train_t)\n", - "cov_gp_sym = K_ss - K_xs.T @ pt.linalg.solve(K_xx, K_xs)\n", - "predict_gp_full = pytensor.function(\n", - " [X_full],\n", - " _replace([mu_gp_sym, cov_gp_sym], gp_model, shared_params),\n", - ")\n", - "\n", - "# --- VFE: collapsed q gives Sigma = Kuu + Kuf Kfu / sigma^2 ---\n", - "Z_v = vfe.inducing_variable.Z\n", - "sigma2_v = vfe.likelihood.sigma**2\n", - "Kuu_v = vfe.kernel(Z_v)\n", - "Kuf_v = vfe.kernel(Z_v, X_train_t)\n", - "Kus_v = vfe.kernel(Z_v, X_full)\n", - "Kss_v = vfe.kernel(X_full)\n", - "Sigma_v = Kuu_v + Kuf_v @ Kuf_v.T / sigma2_v\n", - "mu_vfe_sym = Kus_v.T @ pt.linalg.solve(Sigma_v, Kuf_v @ y_train_t / sigma2_v)\n", - "cov_vfe_sym = Kss_v - Kus_v.T @ (pt.linalg.inv(Kuu_v) - pt.linalg.inv(Sigma_v)) @ Kus_v\n", - "predict_vfe_full = pytensor.function(\n", - " [X_full],\n", - " _replace(\n", - " [mu_vfe_sym, cov_vfe_sym],\n", - " vfe_model,\n", - " shared_params_vfe,\n", - " extra_vars=[Z_v],\n", - " shared_extras=shared_extras_vfe,\n", - " ),\n", - ")\n", - "\n", - "# --- SVGP-Points (whitened): A = R^{-1} Kus, R R^T = Kuu ---\n", - "Z_s = svgp.inducing_variable.Z\n", - "Kuu_s = svgp.kernel(Z_s)\n", - "Kus_s = svgp.kernel(Z_s, X_full)\n", - "Kss_s = svgp.kernel(X_full)\n", - "L_s = pt.linalg.cholesky(Kuu_s)\n", - "A_s = pt.linalg.solve_triangular(L_s, Kus_s, lower=True)\n", - "B_s = A_s.T @ vp.q_sqrt\n", - "mu_svgp_sym = A_s.T @ vp.q_mu\n", - "cov_svgp_sym = Kss_s - A_s.T @ A_s + B_s @ B_s.T\n", - "predict_svgp_full = pytensor.function(\n", - " [X_full],\n", - " _replace(\n", - " [mu_svgp_sym, cov_svgp_sym],\n", - " svgp_model,\n", - " shared_params_svgp,\n", - " extra_vars=[*vp.extra_vars, Z_s],\n", - " shared_extras=shared_extras_svgp,\n", - " ),\n", - ")\n", - "\n", - "# --- VFF (whitened): structured Kuu_sqrt_solve handles R^{-1} without dense Cholesky ---\n", - "Kus_vff = f_vff.K_uf(svgp_vff.kernel, X_full)\n", - "Kss_vff = svgp_vff.kernel(X_full)\n", - "A_vff = f_vff.Kuu_sqrt_solve(svgp_vff.kernel, Kus_vff)\n", - "B_vff = A_vff.T @ vp_vff.q_sqrt\n", - "mu_vff_sym = A_vff.T @ vp_vff.q_mu\n", - "cov_vff_sym = Kss_vff - A_vff.T @ A_vff + B_vff @ B_vff.T\n", - "predict_vff_full = pytensor.function(\n", - " [X_full],\n", - " _replace(\n", - " [mu_vff_sym, cov_vff_sym],\n", - " vff_model,\n", - " shared_params_vff,\n", - " extra_vars=vp_vff.extra_vars,\n", - " shared_extras=shared_extras_vff,\n", - " ),\n", - ")\n", - "\n", - "mu_full_gp, Sigma_gp = predict_gp_full(X_test)\n", - "mu_full_vfe, Sigma_vfe = predict_vfe_full(X_test)\n", - "mu_full_svgp, Sigma_svgp = predict_svgp_full(X_test)\n", - "mu_full_vff, Sigma_vff = predict_vff_full(X_test)\n", - "\n", - "\n", - "def w2_gaussians(mu1, S1, mu2, S2, jitter=1e-6):\n", - " n = len(mu1)\n", - " S1j = S1 + jitter * np.eye(n)\n", - " S2j = S2 + jitter * np.eye(n)\n", - " S1_sqrt = sqrtm(S1j).real\n", - " inner = sqrtm(S1_sqrt @ S2j @ S1_sqrt).real\n", - " bures2 = max(0.0, float(np.trace(S1j) + np.trace(S2j) - 2 * np.trace(inner)))\n", - " return float(np.sqrt(np.sum((mu1 - mu2) ** 2) + bures2))\n", - "\n", - "\n", - "w2_vfe = w2_gaussians(mu_full_gp, Sigma_gp, mu_full_vfe, Sigma_vfe)\n", - "w2_svgp = w2_gaussians(mu_full_gp, Sigma_gp, mu_full_svgp, Sigma_svgp)\n", - "w2_vff = w2_gaussians(mu_full_gp, Sigma_gp, mu_full_vff, Sigma_vff)\n", - "\n", - "print(f\"W2(VFE || GP) = {w2_vfe:.4f}\")\n", - "print(f\"W2(SVGP || GP) = {w2_svgp:.4f}\")\n", - "print(f\"W2(VFF || GP) = {w2_vff:.4f}\")\n", - "\n", - "fig, ax = plt.subplots(figsize=(6, 3))\n", - "labels = [f\"VFE\\n(M={M})\", f\"SVGP\\n(M={M_svgp})\", f\"VFF\\n(M={M_vff})\"]\n", - "ax.bar(labels, [w2_vfe, w2_svgp, w2_vff], color=[\"C1\", \"C2\", \"C3\"])\n", - "ax.set_ylabel(r\"$W_2$ to exact GP posterior\")\n", - "ax.set_title(\"Wasserstein-2 distance from exact GP\")\n", - "fig.tight_layout()" - ], - "id": "ceca213c038a4c" - } - ], - "metadata": { - "kernelspec": { - "display_name": "ptgp", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.14.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/gp-variational-stochastic.ipynb b/notebooks/gp-variational-stochastic.ipynb deleted file mode 100644 index 929d1ee..0000000 --- a/notebooks/gp-variational-stochastic.ipynb +++ /dev/null @@ -1,570 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "0745825c-82ba-4f03-865f-212303bbec66", - "metadata": {}, - "source": [ - "# SSGP\n", - "\n", - "Port of GPJax's implementation: https://docs.jaxgaussianprocesses.com/_examples/uncollapsed_vi/\n", - "\n", - "From this paper: https://arxiv.org/abs/1309.6835" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "5f276caa-d505-4ffd-88ba-ee78b64d555d", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "import os\n", - "\n", - "# XLA_FLAGS=\"--xla_force_host_platform_device_count=8\"\n", - "\n", - "os.environ[\"XLA_FLAGS\"] = \"--xla_force_host_platform_device_count=24\"\n", - "import jax\n", - "\n", - "# jax.devices()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "0a5816de-d936-44e5-aa75-46e35ac9fce2", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "\n", - "sys.path.insert(0, \"..\")\n", - "\n", - "from pymc_experimental.gp import SVGP\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import optax\n", - "import numpy as np\n", - "\n", - "import pymc as pm\n", - "import pytensor\n", - "import pytensor.tensor as pt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "496ddf36-99f0-4b31-975b-aea85ff9fa61", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "2402e087-36d7-4fd3-a71d-24782604c2d5", - "metadata": {}, - "source": [ - "# Example data" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "755e24df-0f4c-46fd-b960-3a1764438b3c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_data = 50_000\n", - "noise = 0.2\n", - "\n", - "low, high = -5.5, 5.5\n", - "x = np.sort(np.random.uniform(low, high, n_data))\n", - "f = lambda x: np.sin(1 * x) + np.cos(0.75 * x)\n", - "signal = f(x)\n", - "y = signal + noise * np.random.randn(n_data)\n", - "\n", - "X, y = x[:, None], y[:, None]\n", - "\n", - "plt.plot(x, y, \".\")\n", - "plt.plot(x, signal, \".\");" - ] - }, - { - "cell_type": "markdown", - "id": "3c8a32f4-2f73-4a06-adc8-b3b598ece0b1", - "metadata": {}, - "source": [ - "# Model and fit" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "c27ffc9e-41a9-4423-a30a-ebd91bc56626", - "metadata": {}, - "outputs": [], - "source": [ - "with pm.Model() as model:\n", - " pm.Data(\"X\", np.asarray(X))\n", - " pm.Data(\"y\", np.asarray(y))\n", - "\n", - " eta = pm.Exponential(\"eta\", scale=5.0)\n", - " ell = pm.InverseGamma(\"ell\", mu=1.0, sigma=1.0, initval=0.25)\n", - " cov_func = eta**2 * pm.gp.cov.ExpQuad(1, ls=ell)\n", - "\n", - " c = pm.Exponential(\"c\", scale=5)\n", - " mean_func = pm.gp.mean.Constant(c)\n", - "\n", - " n_inducing = 50\n", - " # z_init = np.linspace(-5, 5, n_inducing)[:, None]\n", - " z_init = pm.gp.util.kmeans_inducing_points(n_inducing, np.asarray(X))\n", - " z_init = np.sort(z_init, axis=0)\n", - "\n", - " sigma = pm.Exponential(\"sigma\", scale=5.0)\n", - "\n", - " batch_size = 1024\n", - " svgp = SVGP(\n", - " input_dim=X.shape[1],\n", - " n_data=y.shape[0],\n", - " batch_size=batch_size,\n", - " mean_func=mean_func,\n", - " cov_func=cov_func,\n", - " sigma=sigma,\n", - " z_init=z_init,\n", - " variational_sd_dist=pm.HalfStudentT.dist(sigma=1, nu=6),\n", - " )\n", - "\n", - " initial_point = model.initial_point()\n", - " params = tuple(initial_point.values())" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "eaffbff2-cdc8-433a-b109-fd3a264ef6f5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration: 10000, Loss: -10885.61, finished." - ] - } - ], - "source": [ - "with model:\n", - " schedule = optax.warmup_cosine_decay_schedule(\n", - " init_value=0.0,\n", - " peak_value=0.025,\n", - " warmup_steps=300,\n", - " decay_steps=5000,\n", - " end_value=3e-4,\n", - " )\n", - "\n", - " n_steps = 10_000\n", - " plt.plot(schedule(np.arange(n_steps)))\n", - " plt.show()\n", - "\n", - " optimizer = optax.adam(learning_rate=schedule)\n", - "\n", - " # params, history = svgp.fit_scan(X, y, optimizer, num_iters=n_steps)\n", - " params, history = svgp.fit(X, y, optimizer, params=params, n_steps=n_steps)\n", - "\n", - "var_names = model.initial_point().keys()\n", - "result = dict(zip(var_names, params))" - ] - }, - { - "cell_type": "markdown", - "id": "948750e2-0ef7-4367-bc96-9dd67438c365", - "metadata": {}, - "source": [ - "# Prediction" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "702aa476-486d-46e0-80bb-f4b8bac1cf26", - "metadata": {}, - "outputs": [], - "source": [ - "str_value_transforms = {\n", - " value.name: (rv.name, model.rvs_to_transforms[rv]) for rv, value in model.rvs_to_values.items()\n", - "}\n", - "var_names = model.initial_point().keys()\n", - "results_dict = {name: np.asarray(param) for name, param in zip(var_names, params)}\n", - "results = {}\n", - "for name_tr, (name, transform) in str_value_transforms.items():\n", - " if transform is None:\n", - " results[name] = results_dict[name_tr]\n", - " else:\n", - " results[name] = transform.backward(pt.as_tensor(results_dict[name_tr])).eval()" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "fdf19edc-9e19-411a-ae67-f3e2fb6d65b6", - "metadata": {}, - "outputs": [], - "source": [ - "t = np.linspace(-6, 7, 200)[:, None]\n", - "\n", - "sigma = results[\"sigma\"] # or set sigma = None to not have likelihood noise\n", - "\n", - "with model:\n", - " f_predict = svgp.compile_pred_func(sigma=sigma, diag=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "8c9c837b-be42-4d14-89c9-323b334309a0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mu, var = f_predict(t, result)\n", - "mu = mu.squeeze()\n", - "sd = np.sqrt(var).squeeze()\n", - "\n", - "plt.plot(x, y, \".\", zorder=0, alpha=0.2)\n", - "plt.plot(t.flatten(), mu, color=\"k\")\n", - "plt.fill_between(t.flatten(), mu - 2 * sd, mu + 2 * sd, color=\"k\", alpha=0.4, zorder=1)\n", - "plt.xlim([-6, 7])\n", - "plt.ylim([-5, 5])\n", - "z = results[\"z\"].flatten()\n", - "for z_ in z:\n", - " plt.axvline(x=z_, color=\"c\", zorder=-2, alpha=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "7faf30af-3fdf-43c0-b393-4a235c283abc", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTTUlEQVR4nO3debzcdZ3n+9dvqb3q7HtysoeEEEIggYgCEZcIzWC7XKf7NjIXH7Z3oNHR4d5HO7RzH4i3x/Rt7R5ndGSaXmiVcZnWcUE0DbYaAggBQgghZE/Icva19uW33D/qnENCFhLIye9U8n4+HnnAqdSp+pxKUr93fZfP1/B930dEREQkAGbQBYiIiMjFS0FEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjB10AafjeR49PT2kUikMwwi6HBERETkDvu+TyWTo6urCNE8/5jGjg0hPTw/d3d1BlyEiIiJvweHDh5k9e/Zp7zOjg0gqlQKqP0hdXV3A1YiIiMiZSKfTdHd3T13HT2dGB5HJ6Zi6ujoFERERkRpzJssqtFhVREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDDnLYisX78ewzD43Oc+d76eUkRERGa48xJEnnvuOR588EFWrFhxPp5OREREasS0B5FsNsttt93G3/7t39LY2DjdTyciIiI1ZNqDyN13380tt9zC+973vul+KhEREakx9nQ++Pe//322bNnCc889d0b3L5VKlEqlqa/T6fR0lSYiIiIzwLSNiBw+fJjPfvazPPzww0Sj0TP6nvXr11NfXz/1q7u7e7rKExERkRnA8H3fn44H/slPfsKHP/xhLMuaus11XQzDwDRNSqXScb8HJx8R6e7uZnx8nLq6uukoU0RERM6xdDpNfX39GV2/p21q5r3vfS8vv/zycbd94hOfYOnSpXz+858/IYQARCIRIpHIdJUkIiIiM8y0BZFUKsXy5cuPuy2RSNDc3HzC7SIiInJxUmdVERERCcy07pp5o9/+9rfn8+lERERkhtOIiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhKYaQ0i69ev5+qrryaVStHW1saHPvQhdu3aNZ1PKSIiIjVkWoPIxo0bufvuu3nmmWd4/PHHcRyHdevWkcvlpvNpRUREpEYYvu/75+vJBgcHaWtrY+PGjdxwww1vev90Ok19fT3j4+PU1dWdhwpFRETk7Tqb6/d5XSMyPj4OQFNT0/l8WhEREZmh7PP1RL7vc88993DdddexfPnyk96nVCpRKpWmvk6n0+erPBEREQnAeRsR+fSnP822bdv43ve+d8r7rF+/nvr6+qlf3d3d56s8ERERCcB5WSPymc98hp/85Cc88cQTzJ8//5T3O9mISHd3t9aIiIiI1JCzWSMyrVMzvu/zmc98hh//+Mf89re/PW0IAYhEIkQikeksSURERGaQaQ0id999N9/97nf56U9/SiqVoq+vD4D6+npisdh0PrWIiIjUgGmdmjEM46S3P/TQQ9xxxx1v+v3avisiIlJ7ZtTUjIiIiMip6KwZERERCYyCiIiIiARGQUREREQCoyAiIiIigTlvLd5FRM4H1/PZfGCEgUyRtlSUa+Y3YZkn38EnIsFTEBGRmnKqoOH7Pr98uZf/9Mir9I+X8PDxTOisj3Lfrcu4aXln0KWLyEkoiIhIzfjlth7+4se7yI+4xBwTyzdoiIS5fkELnuPz21cHaSRMkx/BN3wKlks+53Lv379M/n9z+OCaWRimoRETkRnkvJw181apoZmIVCoeg/0lNvyul//5L4eJuBa2Z+AZ4OGDAR4QDpkUHRcfwPAxfAPbN7D8asgIh02uWtDIkz1D9LtFCpZLJuTQ0aARE5Fz7Wyu3woiIjJjTE679AzniRQtmvwwR18rkB6v8C87Bsg6DmXTwzWqAeSM+WBNBBPbMzB9A8/wyYVchqIlxsMVvnn7VQojIufIjOmsKiJypjZs7+XPf/wq7oBPcylMyDOJ2RYrFtSTSoYYpPTW37EMcA0fF5+SVb3J9CFRsUlWbHK2w1e/v5t3/z9tRCPWOfuZROTNKYiISOAe3drDFx96hdZilJhjUrI8crZDznD49YEBVnY3nPPn9AzIhRxMH+KOhdFn8A8PHeB9N7TTvSDO1qNjWkcich4oiIhIYDzP5+D+HH//0AG6c3Ecwycdco6bdjGAnX2Z6avBgFzIxfRheKjED354iK3DYxw08oyFK7imr503ItNIDc1EJBADfUV+vWGAH/7TEbwcZG2Hgu2esPbDBwoVl1jIev23/OrUiuVV13yEPYOkYRNxTaKOScyxiLomtmdgnOEqOM+AcsTnyZ4hnLzP3GychekEiYpF33iRux7ewobtvefwFRAR0IiIiJwHx/b+qDNDREdN9ryapVT08KM+uZDzpo+xpD3JjkNpwq6JgYEH+IaPTzWsvGNRE4YJm18bJV2uYPsGYc8kYdtc2pFiR1+ajOtQMTw8gxNGXRIRm+1Hx/EMyNsuhg8Jx2ZBOklvosBwpMz9j+zg/cs6NE0jcg4piIjItNqwvZf7H9lB31iRlmKEtkKEejPEysUNLJubwh099ZCF4UPIMwl7Js1EuX5BhGf6hjns5SnYLq7h01of4U9vXsIHVnRi2wY+sPnACH3jBVKEmJ9MkBmv0LA1zD8/10fMtTGphpei5U7twFk+q45n9o9MPbdvVEdpoq5JdzZO3LHo8YtsPjDCtQubp/11E7lYKIiIyLTZsL2Xux7eguUZzMnFaCpFcAyfIUr8am8/kbjJgtYkqYhNtuTgUw0fYc8k5FVnjh3Tw633+NCHuuiaHeP/Ti7huYOjp11IerKgsPLqRhasTvCXP91FZswhVbFpKIdI2DZXXtKAETrJD2BA0fawPZ/WQoSIa3HwcFZBROQcUhARkWnhej73P7KDmGMxOxsjWbHJ2y6uWR0BMYCNuwZZ0Jpk7ZJWHn2pl+hEACmZHkPREtmQQzbk8PV/cyVLL3u9F8FbDQK3XNnFTVd0svnACP3pAtGyTWTM5ND+PL3DBUKeQeUkPUoc0ycTqoaX/q0l9rRnWLQ0iWFoikbk7VIQEZFp8ez+YYoDLgtyCcKeSTbk4B9z3faBTMnh6GiBzniU6ztbeHlwnNfMPMPRMs7EbpX1t15+TnerWKZxXJDxfZ/B/hI7tqXZ2jNGuexRNF0q5hsCiQEkoCES4olfDfHsKyPE51p0NsW0vVfkbVAQEZFzrlL22LZ5jLmZBJ7hk7Gdk3ZCNT2DgZ4isTaTG69v4+6Vi9k1mjmv/TsMw6CtI0pre4ThWIn/8oM9NJTCRB2DolUNJJMVrF3ayjgVntw9hPuSTzpU4XCiQFNzWNt7Rd4iBREROacy4xV+98QwY/srlE2XinXiYlTDh5hrYfoGnd0x1q3roGNWFMMwuLYpmPUXhmHw0eu7iTdY/MX/2oU36NNUChNywUoYrF3aCsCj23rxAdOGukqIeVmDQ+S56+EtPPBxtYkXOVsKIiLytk1uz923P8PY7gqhksniBSk2D43gTCxCBcBnah1I3nZxWjz+j9vnEQ7NnJZGN1/exbrLOnl2/zB792QZ21Mh4pq0NkR4+NnXpn4Wz4CM7ZBybOZk47yWymt7r8hboCAiIm/Lhu293P+zHVQGPLpyMUzfwEzA2lhrdRHqtl4MwPAMEo5F2fI4Gi8wHC3zjT+8ckaFkEmWafDORS28c1ELo9eUeWbTMC9tH6NYcI9vAzmxxTfp2MzJxDlIXtt7Rc7SzHsHEJGasWF7L3d9Zwten8/sbBwfn5ztkC07PLqt2oX0lhWdNFghEo7FaKTCnvosZqfBN/7NlTUxjdHYHOa9N7dTNy9E2Kt2beWY2abJfiPJis3cbJwj/fngihWpQRoREZG3xPV87v/ZDtrzUToLUcqmR9nygOp12gA27hzk1iVd3HRpJ7FZFtHZJh2NtbfLJBwxWfmOBv7u+QN05aOkHJus/fouIN+AbMghVbYZ2VEme7lDMqW3V5EzoX8pIvKWPLN3GLMX2t4QQqb44OcgXalw6+91MX9Roqb7bqxZ0Eyk3eTAcI5Z2Ripib4ozkRfFAwwkkAanvjVIO9e10o8obdYkTejqRkROWuVisfW343SXohSstwTQojtGaQqNtmQQ/vKKAsW137zL8s0uO/WZeRtlwN1OQZjJaKuRcQ1p7b33rC0lY6uCIcP5Nn0q0EKeTfQmkVqgYKIiJyVcsnjqd8MkTnsUJjoszHFp3oCrmsxGCtxIJVj7uxEcMWeYzct7+SBj19FS2OEQ4kCRxMFbM+kwQxxy4pOFrUlsUMm7V0RDu7Ps+lfBqsLXEXklDRuKCJnrFhwefI3Q+zflWXRvCSbh0amzohh4rRaz/A5Ei8wFCvR0VBtSnYhuWl5J+9f1jHVJr7S65Pe5xAPv/65LhQyae+IcGBPDtM0uO69LUSjVoBVi8xcCiIickqT/UEGMkXq7RCFvS6H9udp64gQjphT23PNiRCSt1yOJgpkww4A9926rKYWpZ6pY9vE+yt9Xt4yzvNPj4JRoa6+enpeKGzS1hlh364sh0ZyNCwNqx28yEkoiIjISW3Y3sv9j+ygd7xI2DWZk43R7kdZdVkj4UgMgEVtSW5e1sFzr4wyaJc4lMpTsjw666MXTctzwzC4/Kp6PM/nhWdGMQyDVF31rfXQWJ4nDg7i74ChZ0ocThboaLh4XhuRM6EgIiIn2LC9l7se3oIPhFyDudk4qbLNUKjEhh19WLbBorYklbJH3LG5bd0c4ots0l7lvJ0RM5MYhsGKVQ14Hmx5dhTDgL5CcaodvGUZNJcilCyPPopqBy9yDAURETmO6/nc/8gOfKq7X+Zm49SVbTITp+cawMZdg8yuizPUX2L+4gTXvaflot+qapoGK69uwPN8Xtw8ypN7hqb6nrmmT9n36ChEKVoe6UhF7eBFJmjXjIgcZ/OBEXrHi9iewZxsnPpKeCqEQLVZWb7gsudAhsVLk9zwPvXLmGSaBletaSTebeMUfULe6yGjbHngw+x8jIhj0jteZPOBkQCrFZkZFERE5DgDmSKWZ9CdjdNYCpG1K1MhBKqjJHHHIjHL5rr3tRKNaTfIsUzTID7PYiBWJOpa2MeEkbztEnFNunNxLM9gIFMMsFKRmUEfY0TkOE3RMLNzsYkQ4nDMdZSQZxB1LQZiJa58ZyPhsD7LnExHfYyeeBF8g/ZihAITHVgnzqVJlW1m5aO0JCJBlyoSOAUREZlSqXi4h3xmuTFG7TLeMTkj7JqEPZP+WBGvE65drBNmT+Wa+U10NETppYABtBUiFCbawfsGFG2X2W6MxLhGk0T0cUZEAHAdn81PDrN7R4ZVSxtwTX+qdXnENQl5Bn2xIj3xIvd98MLsD3KuTLaD9w3oSVSbu8Vci4lBERzT54oFDWx7fpxDB3Rar1zcFEREBNf1ee7pEXa8lKGpOczS7jpuWdFJMmITdk1s36hONXTCA7dr2+mZmGwH394Q5Ui8wHi4QqJikwzb3LKik+UL6nEcn2c3DTM2Ug66XJHAGL7v+29+t2Ck02nq6+sZHx+nrq4u6HJELiiTXVP70wXyB12yrzk0NoWO2wGTTjsc6svTuDDE8qvqWbOgWSMhZ2nydT7cm6P/perISEdXBMMw8DyfviNFZs2L856b29QGXi4YZ3P9VhARuQhNdU0dK9JRiNKZj2JHDa67rIVFbUkAclmH9JjDymsauGpNI6YCyNt29FCB32zoBwMam8IAOBWPvp4SsVkWdYtt2uvVBl5q39lcv7VYVeQiM9U11YfWYoSOQoSy6ZFzPR7d1sstKzqZlYwxPupw+ap6hZBzaNacGKve0cTTG4fI5xziCZuDo3k2HRjC3eFz5OkCg7HSRdUiX0RrREQuIsd2TW0sh+jKR3EMn7LlTXUB3bRjkOGhMsuuSHH1tU0KIefYkuUpll1ex+hwhV09GR7d1su4U8ExPTrzUZIVm77xahv4Ddt7gy5XZNopiIhcRCa7ptaVbWZn4/hAyfKmft/0DLwCRDssrrmuGctWCDnXTNNg1bVNdM+P8/wro0xOjhdND8s36MpFsSaat9z/yA5cb8bOnoucEwoiIheRgUyRRMWiOxvH8qFguVO/Z3oQdyyGI2VSi2xCIb09TJdwxCQyz2LEL5Nw7GrffANytkOyYtORj+L7qA28XBT0TiNyEUm4NnOyccKeSc52mWwUYvqQdGxGIxWOJAp0NsWCLfQikKH6WnuGT9StvhVPNjtrKUZoKIcA1AZeLngKIiIXicx4hczuCo1GmJztTIUQw4ekE6qGkGSetsYI18xvCrbYi0BbKko27NCTKGD75tSZNBXTxzd8uvJRIq5JWyoacKUi00tBROQikM85bPqXIQb7Slx9eSMY1Rxi+JCq2IyHyhxO5nFMn/tuVdfU8+Ga+U101kcZjpQZjL7eeRUgb7lEHYslXopVcxqDLVRkmimIiFzgyiWPp387zOHX8rR3RrikI1Xtmhq2STo2mZDDoWSBlsYID3xcXVPPl8k28BjQGy8wNtF5FR8MAwq2yzUNTezZkQm6VJFppT4iIhegyW6efWMFxnc5lPpc2joj2BMLUBe2JoiXbUq2S+uKCHO6EmqiFYDJNvD3P7KDo36BiGuScCzMpMHaJa0022G2bh6jrSNKa7tO6pULk4KIyAXm2K6ps3Ix2gsRzDhcH2tlUVsS3/cZ6C1TV29z401dtHVoDUKQblreyfuXdbD5wAi7d2UY2FakuyNOKmXj+z69R4tsfnKE9/+rdsIRDWLLhacm/lZ72kcvckYmu6ZOtm5vK1aPn087Do9u62XvQJbhwTKRqMm7bmxRCJkhLNPg2oXN/Jub53L9O1tJj1ZwHA/DMGhrj3D0UJ6XXhhjBp/IIfKW1UQQ+e1jg/T3FvWPUOQ0prqmvqF1u2P6U11Tn94+hO/DtWubmT03Hmi9ciLDMFh5TQOds2MM9pXxfR87ZFLfEGLHS+McPlgIukSRc64mgsihAzn++ad9PPPECJnxStDliMxIk11T39i6fVLINSmVPVILQyy4JBlgpXI60ajFNe9qIhozGR9zAEjW2bgOPP+7EXJZJ+AKRc6tmggiHZ0RIlGTl7eM8eiPenl5yxjjYxVN2YgcYyBz6tbtIc8g7Jn0xopYbcHVKGemvSvKilUN5LMu5VL1z7GlPcxgX4kfPnKEn2w5wu/2Dav9u1wQamKxqmEYJFI2iaTF2EiF320cZutzY6TqQnTOjtLcGqGxOURDUxjL0qp/uThFiq+3bs/Zr7dutzyDqGPRHy/SHyvRXqeuqbVg2RV19PcUObA3R1d3lAPDOTYdGMTdAYeezTMcLeuUXrkg1EQQmWQYBo3NYeobfYoFl0y6wuALRcAgHDGIJ206OqO0dkRobA7T2BwmHK6JQR+Rt2V4sER6d4U6K8SwWXq9dbsHcddiKFqiN16ksyGqrqk1wrZNrr6uiZHhMi/vGec3hwbxgZhh0ZGPkg05U6f0qv+L1LKaCiKTTNMgnrCJJ6pf+75PqehRLLjseiXDqy+nCYVNYnGL1vYI7Z1RGpvDNLWEicWtYIsXOcfS4xU2/csQ4yNl1lzeyC9e7qvmEL96tsxouMLRRAHfQF1Ta0xDY5gr1zTyk68fxfIMHNOnYLmkKjaduSivpfJgVE/pff+yDv3ZSk2qySDyRoZhEI1ZRGMWDU3VYFKp+BTzLq/ty7Fvdw7ThIxTwbV9GurCXNKdIpm0q6dgRkwiUQs7ZLBjIM1YqUxHU4x3LGrCto4fUZlsFDWQKdKWiqoJlAQqn3PY9KtBBnqLdMyKYlkGtxgGG3cOQhbS4QqHk3naGjWEX6uG7BJHzQKtpQiZkINvQN52aSyHyZQchqPlqVN6r13YHHS5ImetpoKI58PR0QK5skMibDOrMcbJMoBhGITDBuGwSV1DiL0DWZ7YOUix4GH5BgaQsC0u7ayjoz4GPvSli+zoTZN3HDzAN3yiUYvrL21hxfwG4gmLHQPjfO+FwwwWSriGT8nyaGoMc98H9QYv51+x6PLkr4c4eqhAe1dkan3UgpYEsXkWTsyn5fII3R1xBeYaNpgr0RMvEnMs4o5NLuTgmj6u509N0ZQsT6f0Ss2qmSCydyDLxl2DZEqvb11LRWzWLql2izzd9z26rbfaR+GYWZkCLpt6h7iltRogNvUMAtVpHwMwfYNSweXXWwbIjjj4rs+WQ2MksUli4wOu4eOmPf6/b+6k971F1q5opa4+RKLOZuvRMY2ayDk31bp9tMDYzgqlAY+Ozgi2PXGMvO/T31uiuS3Ce25qo7E5HHDF8na1paI4pk9PvMiCTIKwa1K2vOOmaA6m8jqlV2pWTQSR/YM5/mVPhjduVMuWqt0ib1nRedIw4vmwcdfgCd8H4FNdz/fbXdUA4k/kBNfwj7lH9T7PD45Wny/kHPcAtm9g+QYN5RCPP95H5bDHUL7E1p5xRtwyeduhYLskmm3+44cu1aiJvC2Trdv7Jlq3txUimIkTW7en6myue0+LQsgFYvKU3r6xIv3REl2FKI7p4R0zRROyTS1CluP4vs+zm0bonBVl7sJE0OWcVk1sKXlyz9ApwwRUw8bJttMfHS0cN4Jysu/Plhyyb+U+BjhmdXomG3IZNMocKud54rWh6tSRU13ZPj+ToPFQiL94YCf/4xcHyaQr6hArZ+3Y1u1d+WNat1dO3rq9vVOfji8Ux57SOxgvMh6qkHCqp/R6po9n+KxrbiebVqMzeV1/T5F9u7Nka6ABXk0EkWz59EEhU3I4Onpi6+Pcab5vOrx0eBzXrHazzNsumbBDxq6uOWkshXn0kT5+8v2j/OrRAXZuTzM2WsZxPX63b5ifbj2qBkVyUse2bu/MR2krRCla7htatw/jo9btF6rJU3rbGqL0JIpUTJ+oa5KM2Nx4ZSv1Rogtz4yqyaMA1fPZXnkpzfhIbXQiPy9TM9/85jf5yle+Qm9vL5dddhlf+9rXuP7668/pc5wsdCTC53fmqei4J95oQNnyKFseWd9hpFCmcsDjwN4cw8USz/aPcNQrkAlVKFoenQ3a3SDH23xgpHqIXT5KRyFKyXSpmK9fcEKuSaniUbdArdsvZMee0rv9xTGGd5VZPD9FNGJSLLjs351l9twYiy9NBV2qBKz3SJFDB/JT/YRmumkfEfnBD37A5z73Ob7whS/w4osvcv3113PzzTdz6NChc/o8JwsdsxpjpCL2Kf8sDCAZsUmeg/tE7TPoT2KAY/u0d0XJhytsOjAIGZ/ubIxLxlPMy8QpDLr8yXe2sGF775s/nlwU+tMF2gsROgtRyqZHxTo2hEy0bo8XMNW6/YI3eUrvJz40nyuXNzAyUD0YLxqrth94cfMoaZ3HdVHzPJ8dL43jOn7NNPSc9ir/+q//mk9+8pP88R//MZdeeilf+9rX6O7u5oEHHjjjx0iGTx8CUpHqVt43Mg1Yu6R16n5v/D6AtZe0cMOiFmzPIOqaxB2LRMUiXrFIOBYxx2JNRxNrupqIuCYR1yTsmoQ8A9OHybWtK+fUn9HPkgjbeD48sXuIiumTC7lkQg4V06OxHGZ+OsEl40n++ru7yWT0hnKx832fSq8/FUKOPcTO9gyinkV/TK3bLza2bbLq2iZiCYvx0epocFNLmLGRiqZoLnJHDxU4/FqBxuZQ0KWcsWkNIuVymRdeeIF169Ydd/u6det4+umnT7h/qVQinU4f9wvgusUtwGnCxJLWk/YTAVjUluSWFZ3VEQ0fwq5JzLFoJsz1nS0kyiHq/BDXz28lGrHI2S6jkQrpcAWScOOVbSydV8firhQ3LGklHrYwAMsziTk2LUaEGzpbmBdN0GSGCHnGVDh5Y62TgemERbQTC1+zIYe87RBxLZIDNn//9wd4ZtMwjz3Xx09e1CFXFxvf99n5cobM/grhsEnlmBBieQaxidbtfWrdflFqaYuw4qp68jmXStnDNA2aW8Ps251l/+5c0OVJACZHQ3yvOkpWK6Z1EcXQ0BCu69Le3n7c7e3t7fT19Z1w//Xr13P//fefcPuC1gTRWPKEPiLJM+gj4vs+HbEoN8/rZKRQxjU9GurDLFtYR2NjmESyepheImUTjVm8cHj0lP0/Jju2Prt/mP7RIikzxPy6BPmsw/BgmavdJp54ZYjIRNM0AMfwqZgeruFPBabTLaKd3JKHD4eH82z+HyPkXIdMyGEoWiLRYquB2kViz44szz45TCRi8q7lLTy6rReD6ihcwrEYjpQ5Glfr9ovZpZfXcfRQgSOH8nTOilanaDIOLz47SntnhFR97Xwqlrfv8ME8Rw8Va2o0BM7TYlXDOP4N0vf9E24DuPfee7nnnnumvk6n03R3dwPVkY0Frckz6qwKUC55jI9VKJc84kmbxcuSzF+UoKMrSiR66qR4uhbJkx1br1/aetLfv/GmNhY/n+Jrj+5mfNwh4prUVWwazTCXtddR59rksg7x0JmtJ9k2NA6AbRrUl0PUlUNkihX+9B+24X/C5+bLu978caQm7d2Z5ZknhrEsg4amMA2EuWVFJ0+8Ooifg9FIhcPJglq3X+RCYZNV1zZWDz0cc6hvDNHQHObV3Wn+8UcHWXV9I2sWNiukXgRct7pTxsc/7TVuJprWINLS0oJlWSeMfgwMDJwwSgIQiUSIRCKnfDzTgO6mU8+De55PNu2QzbhYNrS0Rli4JEn3/Dh15+GTgWka/P41s/hXq7umzqNpSURYnEoy2Ffi0ME8wwMlzJxBC2EyrkPZ9KaaqR3LYKJPilEdVcmaDpZnUDcRSP77Q/tZ9pl6uufGMfUmc0GY7Jq6e1eaoR1lmhNhWlte//cwrzFOZF4HZgM0XRZmVotatwu0dURZfmU9m58aoa9Q5Ml9QxQKLpGDJv/w8gGibZbC6kXg0P48vYcLNLXUXiPDaQ0i4XCYVatW8fjjj/PhD3946vbHH3+c3//93z8nzzF58u74WAXH8UmmbJavrGPuwgTtXdGp8zfOp8mV7cdq64iy7Io60uMOA71F3AaPX/6uj6RT/SMomx5l0wOjGkBOthLENV8PJLG0xQ9+cJiVlzWwdHmKI06BwVxJLeVr1GTX1MKAS3c2jglYcYO1VKceHcejv7fEnPlx1r6/lUSyJpoiy3my7Ip6Nr4wyKbnh8jaDpgQ9qAjH2XfSJa7Ht7CAx+/SmHkAuU4Hq+8NF4dtY/Uxk6ZY037u9k999zD7bffzurVq7n22mt58MEHOXToEHfeeefbelzX8UmnK+RzLuGwScesGIsuSTJ7Xox4Yma+SRuGQX1DiPqGEIsvTdF9eZyv/XQPxVGPhkqIhGMTDZnM7oyxtXf8lI8zGUj8iM/mF4d56JcH6KfEYLREJuSoF0mN2bC9l7u+s4WmUpg5uTgGkLdcjDI8uq2Xmy/rIFGxmdUd44b3KYTIiSzb4Md9R6kzQoS96lk0ecsl5dh0FKIcThS4/5EdvH9Zhz6kXIBe25env6dIc2vtjYbAeQgif/AHf8Dw8DBf+tKX6O3tZfny5fziF79g7ty5b+nxKmWP4aEyvgd1DSGWLq9jzvw4LW2RmpuiuHX1LH7vquo0Ts9wHnPcxB4zeHVvmlQlR3GycdUpfqys4/Js7zCmZ1DvVqdsxsJlBp0Sd31nCw/crk9AM53r+dz/sx20FCLMysdwDZ+CXW2M5wOmD89tH+EP3zOHG97fSjKlECIn2nxghIPFPB2xKF35KJWJKd+C5dJUjJAOOfSOF9l8YOS06+Ck9lQqHq+8lMY0q2uGatF5eVf7kz/5E/7kT/7kbT2G6/qMDJVxKj5dc2IsvSzFrDmxmluU80ZT0zgTbw6u63PF4QY2fWMQe9wk6hhUDI+S9fpaEgNIRGy2Hx2vngI8MUJiewZN5TB1lRAjkTL/6X+9qk9AM9wz+4bxe2HWxEFmpWO26OJDwrEZssskLrG1A0JOaSBTrP43WiRVsUlWbLK2g2P6RFyfjnyUbMiZup9cOA7uzdHfW6S1vTZHQ6BGzpoZGy3Td7RIqj7E2nWtfODWDhZckqz5EHIylmUwZ16cu+9YxO76DD3xIq7pk3Rs4o7FZGfv5bPqTjiIzzF9MraDY3i0FSLUHwnxw0cPU8ifpPW8BM51fLZtHqOzEKUycYDiFB9Sjk3OdjiUzJNl5h9cJcFpS1UPOfRM6I0XcQ2fsFd9e8/ZLvGJQzhbk6feDCC1p1yujoaEbINQqCYu5ydVE5Wbpsma65u45SOdLL40hWVf+J/wb1reydfuWInRCbvqs7yWzFO0XJqNCO/ubqUucopPxwZULJ9MqHrh2vl8hkd/1MPO7WkqFe/k3yPnXaXs8bsnhhg/WKFkucd1TJ0MIXnLrf65297UhUbkZK6Z30RnfRQDqiMf0RIRz6w2VzSgaLt0ezE6DXXfvZAc2JNjsK9EY0ttj5bWxITzug920D2nMegyzrtjD7kayBRpioZpcSLsfDnD7v1p4o5FwXJPuv0XA0qWR2tXhFzWYdOvhti7M8uylXX0+kWGtMMmMKWiy+82DrN7R4YF3Uk2D47glJzqTikfko5NwXJ5LZWnZHt01qtrqpyeZRrcd+sy7np4CwYwGCtRV7GJOzb5UHWKZnlXPVs3j9HRGSUWv/BGky82paLLKy+NE44Y2HZNjCmcUk0EkfqG2k57b8fJtgIvvCTJkl0pnvvbUay8gWP4FN8QSCYP6+tujmMa1QVNL+0c43/8+jX6KDEQK5KzXe2wOU8me4QcHcoztrOCM+zT1h4mErVYu6S12jV1Yk1IaWokpDqlpq6pciZuWt7JAx+/ivsf2UHveJGeeJGFmQQNVoh3XdbC/OYEvUeLvPTCGGuuazppU0mpHft35xgaKNHReeJoqefD0dEC/WNFdvZmWHp53Yx+DzF835+xh5ek02nq6+sZHx+nrq4u6HJmnJ+/2MMXv/UKrcUIsYqFY1YDyeQum1tWdE61v987kOXRbb2YnkHctXANn+FImaFYiZLlqcfANJrsETI8UqY7G6O+HMJIwA2Xvn48we6+DM9tH2XEL/NaMk/BdumsV0iUszcZevvTBXIHXDIHHbpmV3sqZTMOhbzL+25pZ/bceNClyltULLj8/Ic95HMOza3Hr/vZO5CdOg4lWbE5kihgdxjn/b3kbK7fCiI1bsP2Xv7fn+6gNOjRUogQdy1CEYNrL2tmcXsKqKbjh5488Po5PT6EPIOoa1G2PIaiJaw2gyf+7D0zOjXXog3be7nr4S0kKjazczESFYtsyJkavbplRSfzmuL095Ro64ySvMQmZzqaNpNzolhw2fDTPoYHy3R0VS9YfT1FWtoifOCDHTV1MJq8bvvWcX73m2HaZ0WOa9o5+YFz8qI+GUSGYiWA8/qB82yu3zUxNSOnduw6kp7hPO6gj9MHmXSFTLpCMmVzdLR4wmm/FcunYjpEPJOufIz8YZef/bqHW9/dWfPzjTPFZI+Q5kKYznwMyzdIh5ypESsDeOLVQSLzOpgzL871723RFl05p6Ixi6vWNPLrX/aTyzokkjatbRH6eoq8vGWc1e9s1BRNjSnkXV59KU00bh4XQjwfNu4aPGlX7ok1yzO2qZ2CyAXgjb1IMukKO15Ks3tHht7DRcb98sm/cWJBa9n0iLkW254aI5I2uezKOo66BQazWtD6djy1cwi7x6CjGMcxPHK2e1xzOtMzIAdWo8G7P9A6YzsCS23rnhdjybIU27aME41ZWLZBXUOIV7elmTU3Rtds7aSpJXtezTA6UqZz9vFrQ46OFo7/wPkGPszYpnZ657sApepCrLm+mYVLkmx/cZznto6QrFS3g3rmiXnZNyBvu7S0RnjxlVG+86uD9BhFBmIlrVV4i0aGyjz/mxFaCxEKtovzhtfd9gxirsVwpEzTZSGFEJk2hmFwxdUN9BwtMjxYpq0jQqrOpi9TZMszo7TcGqnJ80kuRrmsw6svp4knrBM6iefKZ9ZraCY2tdPfvgtYS1uEteta+YM/mIOfgrhrkahY1d4CxzCAVMSmgsfGnkHG3ArNpTCLx5PMysYYHS5z18Nb2LC9N5Cfo5b4vs+BPTke/3kf5TGP7MTWyWPZnkHMsRiKljiUzNPVrEWDMr3iCZurrmnE9/2pBoct7WF6DhfZvvXU51rJzLJnR4bx0Qr1jSdO4SbCZ/ZhZib2JFIQucAZRrVT6//5ifm8lspRtF2SFZuYY8Exx9jccEkLT+yuzi9Odmh1DZ/2QoTF4yk6c1H+049fxfVm7NrmwDmOx5ZnR9n4+ACFvMuyS+pIRu3jjgoKuSZR16I/VuJIokB7o3qEyPkxd2GcxUtTjAyV8Twf2zZJ1Fn8ZtMA3/31a/xu37D+fc9g2YzDq9szJJInjoYAzGqMkYrYpzqaDANmbE8ijQdfJH5vRRfmJw2+9NMdDA9UaC1GqKvYWDGDdy5rJhqyT1jQWp5YPxLxTDryUUqHPX746GFufU+XphImTG6VPDKQJ72ngjvsU9dgk6qrfmI5tkdI2DMJeSa9sSID8SK+oR4hcv6YpsHKaxro6ykyMlRmjAobdw7i5yCzr8L+VI72Rk3DzlS7XkmTHqvQ1X3yEQ3TOOb9Bo5btDr5DjNT32+0ffciM9VYayBPuc/DHfQp5FxGvDL/snfg1N/oQ9Q1WdXVxLIFdVx2RR0LlyaJXoDn/ZypDdt7uf9nOygMunQUosQrFmYCrj+mPwjAnr4Mz74yQq7i0hsrMhgrqZGcBGbvzizf/+Ehnjo8hGP6mBON9HriRfrj1fUD6is0s6THK/z8n3oATjotcyz1ETnHFESm38hQme0vjvPslmGe3jN8ygWtkz68chYpbAoFl6aWMGabAU3Q2Ri7qHbXbNjeyz3/+BLt+Sj15eroUN4+sZlcpewx0FeisSVMYoFNJeFpJ5IEquJ4fOTzTxEaM6tnUhkQdk0s32B/XY5cyKGjPsqTn1dfoZniuadGeHHzKF3d0TPabj3VWbWnyPI19Xxo3azz/mepPiJyxppawlz/vhbmX5Lgqf8yTDxt4bs+efv0LeN392b49dMDlMseOdthKFom2mLy/3zowv+Un806/Jfv7GHReBLbN8hbLu4x4c2gup+/PRYlM+owb2GCNTc0X9RHFcjM8fxro+w2syyyksRci4LtUjY9ko5NVy7KvrrcjN3meTEaGy2ze0eGVJ19xj1fTAO6m2LYeYOlnakZHyi1WFUwDIPuuXH+zztOv6B17ZJWTKM69PfLV/oY9stkbYeoazE3E6f+cIgvPvgKP332SKA/z3RxXZ89r2Z46FsHiA1V2+RnbOe4EALg++DkfA735Vmxup5339SmECIzxkCmSMny6IsXsXwDyzPAgJztkHRs2goR8GfmNs+L0c5tGbIZh1T9hTtucOH+ZHLWTlzQGiZVsQlFqy3jF7UlT+jeN9mDxPAh4prMysX47rcP05KPsvjSJK3tkZrs3Di5lmYgU6QtFWVeNM7LW8Y5dCDPWKZ8XJv2Y00eXFcxPVoui3CNDheTGWZy++ZIpExdOURjOUTGqP59LpkebcUIuZAzI7d5XmxGhsrs3ZWhvvHMR0NqkYKIHOfYlvFHB/O4Qz5uP2TGK4yPVRh3Kyft3ucbULQ9ir5HuGKy6alB9u7MMmtOlFK9Tznu0lFfG+tIJg+p6x0vEnIN2ooRur04l7XXcdmiepyYj3+SQR9r4kDBrO1wJFFg6bK6C/rNQ2rTNfOb6KyP0jdepDdeIOFYRF2Tou1RtjzCFZvFbpLL2+uDLvWit3N7mnzOPeVOmQuFgoic4I0t47MZh13b0+x6JUP/0SJh16Rsepx0w/rEtl+7wWCwWOSff95HvuKQt13GIhVijRb/4SNLuHlF1/n9oc7Qhu293PWdLSQcm1nlKA2lMBHXJGM5bOoZoq41xILWJKmITbbkVEeGfIh4JmHPZDhSpidRoKUxMiP364tYZnUHxV0Pb6Fke/THSnTnYpR9b2KE0+G6phZefn6Md6xtVpgOyNBAiX27stQ3hi74PwOtEZE3lUzZrLq2iVs+2sWiy1OYvlGdsnENTnrCEjBecHhsdz+DlChYLjHXYnYuRuPREF/75h7+8X8dYKCviDeDGiil0xX++nu7WZROsmg8SXshigFkQg5lqxq8Nu4aBKrrZaA6CpJybEzf4Gi8wOFkHsf0Z+x+fRGojnw+8PGr6KiPMhQtMRaukHBskmGb37uikyXzUux8JcNr+/NBl3pR8n2fV7elKRRcEskLv0WCRkTkjNU3hvjfPzKHB1/ZB4PQUAoTdQwKlotjVFe1GkAiYrP96PhURvFMyJsu+GD5BlHX4rHH+vF7obE5zLyFcdq7ouzP5xjKTf9Be8eu/2iJR5gTiXP4QJ5ntwyT7Lfx8Cm+YScMVDNXpuRwdLTAgpYE757TyvZD4/RZJfpjRXIhncsjtePYadjXjuTo21KkKR6muSUMQC7j8sIzo7S0RUimdKk4nwb7SxzYk6PhIhgNAQUROUuWafBnH72Uu76zheFImZZimIZymJhvUDarnViXz6rjmf0jJ36zAa7hkzdd8r5L1ncwR+GRX4yxoz/NiFdmLFwhb7s0NIS490NL+b1zPIXzi209/MVPdjI+5hBxTRpKIZqNCMs667CiBhnbOfmU0yQfRkfLGFm4pLuOj3xwNsOhMkN5nVQstWdyGvbahc282pjmqd8MUSq6RKIWLe1heo9UD8a77r0tJ20rLuee7/vs2JamVPRoar04dtspiMhZu2l5Jw/cfhX3P7KD18YKDDllGkthZvkx1rTVYboGhs9Jd5VMMaBseIxRYVPvEKZvEPEsZuVtfMDN+Py3/7aXfatzvHN5M6n6EPGUxZ7RLONumfa6Uy98nRzx6BsrkDJCLKhLkBlzeGrbII8+20uDF6bFr25RdE2fUbPEpt5B1ixoOm0ImVyMGjZNrlrTyGVX1KnVvVwwLrksxdEjBfbvytLVHcU0DZpawuzdmaWrO8aipck3fxB52/p7S7y2L0dD84W9U+ZYeheVt+TYYd3JLa5LGlMc3JNj0zODJB0b16hOcXin+LcUD1k8vqMff2KkpGBWTwU1JqZwbN/g6S1DRLIm/ZkSO3rT5ByHiunhmD6piM0Ni1tZ2JbE933wYd9glk17hsiVHCzfIOSZJGyLpR11vNqXxvANKqZHwfCPCx0GsP1ommTEJje5CHXy93yIORYmBm6dz223zaWj88JexS4XH8syWH1tI8P9JUaGyjS3RojFLTIZh1881kvHUITuzoRG/aaR7/vs2DpOuezT0nbxXJ4vnp9Uzrmp3TXHaFoT5pLLUjz65V7MEYg71b9iBcvFPWYdSTJig8EptwI7ho+DT5Eyh50Cz/YOgw+2aWB71YDhOj6/2TpAYaHL7MYYR0YL/G7fMD4QxsI3fEqmR8F32dQ3NFH0yX8WH8iWHN6xoJln9w9XD406ZjdM3nbpjxX58h3LFULkgtXQGObKNY1s+tUgxYLLkUyhukA7CyM7y7yWytOhc5KmTe+RIq8dyNPYdHFMyUzSrhk555JJm3v+6BL21Gc5mMqRDlWIeCYpxybuWFiewQ2XtJAvu2f0eFsPjeFTDSgV06doexRsl7ztUrBdnusbob4pxHN9IxRsl+LEr5Ll4Zr+6aeI3qAhHuIDS9tpptrMDaAnViQzu8L6T14+Y7cdi5wri5YmWbgkyY59aR59qZdMubr9vrEcpqUYoW+8yF0Pb2HD9t6gS72geJ7PKy+lcRyfWPzC3ylzLI2IyLS4aXkn/21iHcm+sRxxxyLp2MwmxvXtLcRLNuPlCpZnTI2UnErROXVgmdzJ8tLhsZOOrpwpw4ewZ1IZ9ehoinLb++ZSqfNwUz6zWuMajpaLhmkarLymgW88upeYa5G3qzvIHM+jIx+lYLvkQg73P7KD9y/r0L+Lc6TncIEjB/M0NV9coyGgICLT6GTrSFbPbWRsuELf0QL79+R44bVRyqXqyEXZ9Ka2AUP1PxHbOm0QmTReqJx9gT7YE9uJDcCKGdz47jbmLUzQ2h7RLgG5aL06kmGflWUucWzPwDF9ilb1YLxZuSj7UzoY71yaHA3xPJ9o7OIaDQEFEZlmJ1tH0toeobU9wmUr63G6PP7yh7uoL4eIORZxz8A1wDOq4eSKWXU8e3D09FtqgfrYm3yKmMg3tmcQ8k1M38Cgukg2Ha4wGinzpY9fxppVelMVGcgUGQ1XSEXKtBQjZCfOosnZDiknRFc+xqFkXgfjnSNHXitw9LUCjRfhaAgoiEiATNPgo9d3k2i0uf9nOzg8UiBZqa4jabUirJ7VSGs8wn4jT7Hi4uHjGj6O6U/tajGARNhiSUuKlw6MkTtm3YkxsfPGmggdkZDFFQvr2dwzQr9bojixzqShKcSXP3i5Ft+JTGhLRcGA3liR+MTarlzIrYYRy6GpFKZguToY7xxwXZ/tW8fxfZ9I9OIbDQEFEZkBTjaFc/W8RspFj8y4Q3SRxTd+uZeoaxJ1LEKeedwAyaquRop5j1WzGvndvtcbqXmGT9F2ydkOJcvj8x9awr+6ZhahiMFzB0ennkvrP0SOd/zBeEXmpxOEPIOK6VfXi/ge890Es+1Y0KXWvEMH8vQeLtA00dH2XCmXPVxn5hyhcToKIjIjnGwKx06YxBM2t3XNpbk7zP2P7ODAWJ6QVx3laKuLcM/7L+HGpe1TUzfLdvXz1cd2058u4RrVEZTOhih/fuvy40Y8NK8tcmrHHoyXDlUYjJZoL0RwQtXOwyXT4x2d9Tz31AiNTWG1gH+LXKfaNwTDIBw5N5tYPc9nbKRCsegyZ2Gc2XPj5+Rxp5Ph+/6MjUzpdJr6+nrGx8epq6sLuhwJ2LFnxJxuJONM7ycip7dhey/3P7KDwdESC9IJEo6NkYC1S1tZ0JKg53CRxUuTrF3XhmXr39jZ2r87y683DNDSGiYUfvtBJJ9zGB2uUN8YYsWqBhZfmsS2g+nScTbXbwURERE5pclgf+C1LH0vFmlJRqYOxisVXYYHK1z9rkZWXt0YcKW1pVhweeyRPoYGyrR3Rt7WYzmOx9BAGdM0WLQ0ycrVDaTqg134ejbXb42niYjIKR13MF5rmqd/M0Qh7xKLW0SiFsmUx7bnx2lujdA9b+ZPA8wEjuvxw58fYe8rWdo6I3g+vJVBW9/3GR91yOUcOmfFWHl1A7PnxmrujBoFEREROSNLLksxNFDi1W1p2rsi2LZJXUOI/p4Szz45Qn1jiLqAP4nPdBu29/LVH+wi2RuibLlUBqrnZq1d0sqitjM/WLBYcBkeKpNI2qy5rplLL687Z+tMzrfarFpERM470zRYfW0TnbNjDPSWmJzZb+0IMzJY4tlNw1QqXsBVzlwbtvfyuW9tJTxg4hs+FbP6+mVLDo9u62XvQPZNH8N1fQb6SoyNOixakuTmD3VyxeqGmg0hoCAiIiJnIRa3eMcNzSRSIUaHqx2NTdOguS3CC1tH+Ycf7efpvUO43oxdfhgI1/O5/2c76MzFiDoWeev1nkeTr9TGXYOc6mXzfZ9MukLv0SL1DSFu/EAr7/5A2znf9hsETc2IiMhZaW2PsPodjWz69RD5nENPrsjGXYOU8h72awYPPLufWJulU3qPsfnACG6fT2M5RM52T+gWPXlu1tHRAt1Nx/dnKZc9hgZKRKMWV61pZPnK+gvqYDyNiIiIyFlbdGmSSy9PsfNAhl+81Eum5FC2qtMys3MxcoOOTuk9xv6DWToKUcqmh2eeerQoV3798E7P8xkeLDM0UGbOvDjrPtjB1e9suqBCCCiIiIjIWzB5Su+W0TESjj01v5C3XGzPpDsXJ16xuP+RHRf9NE0h7zK+t4LlG5TM06+hSYSrExX5nEPvkSKRqMn1723hfbd00N55YbbUVxAREZG35KXecXbaGUqmR8yd+JQ+cThe2DXpzsYZHS6z+cDI6R/oAub7Pi9uHsXMGRgJONXOWgNIRWzaUxH6eorksi7Lrqjj9z7SydLldRd0wzitERERkbdkIFOkYLv0JArMzSQIuQYVq3rUddZ2SDk2c7JxDvflLrpjFSYbwe16Nc3A9hJzO+OsjbXy6LZeDF5foAoTy0V8uKariaG+Eh2zYlx5TQOz5tReT5C3QkFERETeksnTd0fDFeKxIu2FKK7p4BlMhZFkxWZkR4X8Sod44uK45Ey2xh8fqjA/m8D2DJ7pM1i7pJVbVnSycdcgmdLra0HqbJsrWhqY0xRn+ZX1LL28jvA5aPleKy6OvxUiInLOHXdKb6xI1LGor4TI2NXD8TDASAIZePJfhrhhXSvRC/yo+w3be7nr4S3EKhbzsnHCrknWdjBK8Oi2Xm5Z0cknrpvP0dECmWIFPwdN8TALL0mw8upGGptrfzvu2bp4IpeIiJxTk6f0AvgmHE0UKFoeCcfCmJh7uGFpKx2dEQ7sy/H0b4aolC/chmeu53P/IzumQkjEtchOhLJje4UAtMXD1FVCLJqT5D03t7F2XdtFGUJAQURERN6Gm5Z38sDHr6KjPkrR9jiSyOMa0GSGuWVFJ4vakoTCJq1tYfbuzPHMpmFc58LcRbP5wAjjQ5UTQsikyV4hB3pyDA2WWXJZips/1MmCxUnMi/iEcE3NiIjI23LT8k7ev6yDzQdGGMgUYQRGd5YJHbPTIxK1aGqBnS9nCIVNrnlX0wV38T14KHvKEDIp7JqMjpb5wLs7WPXORkIhjQcoiIiIyNs2eUrvpFdb0vzuiWHS45Wpg/BicQvX9dm4aZCXeka5fFUDaxY0Y10AgWSgr8jQK+VThxAfoq6F5RssvSrFNddfeEHsrVIQERGRc27p5SnKZZfnnh7FsgwSSZu9A9mpVvChAwb/8NRBzA6D+z5Y263gB/qKPPH4IFHXqvYKKR+/PRcf4o6Fb0Cu3eGjvzdbIeQYGhMSEZFzzjAMLr+qgStWNTA+6vDqoTSPbnu9FXzF8OnKxwj3GHzm2y/WbCv4yRAyNlKhoyvC2qWtwDEDIj4kHRvX9DmUyvN//e+XYFu69B5LIyIiIjItTNPgqjWNFEsuD/zPfZi+gTtxzkrZ8vAMn5ZChIhrsf5HO3n/so6amKaZbFZ28FCWoVfKRF2Ljq4IpmmwqC051SskW3RIOjYFy6XQ6fIX/9vlNT3yM10UREREZNpYtoHRZXDUKtBcDJMLTTQ8AxzTJxOqNj0LHfX4+W97+OCNXTO6m+iG7b3c/7MdZIYcunOxqemYteFWFrUlAVjUlqS7Ic7uvRnsBoOV72rkxpVtNRGygqAgIiIi02q4WOJIooDlGzSWw2TsCv7ENdk3IGM7xFyLbU+N0RWNsfLqhhm5m2TD9l4+/e0XaS1EWFBMYPpGtVlZ+fVmZYvakpSKLoP9Za5c0cC73tNKMqVL7eno1RERkWnVlopW10gk85gZqCuHyIacqTCCAQXbpa4uxIubRxkbLvOOG5pJTey2mQkc1+Mv/+cuFqQTpCo2RcujYLtAdWGqQbVZWUc8yvhIhSWXpXjH2uYLvpPsuTDzIqeIiFxQJlvBV8NIgWyounZicmvJ5MmzC2YlaW2LcGBvjsd/3k/P4UKgdU8q5F2+/+PDpHpt4o5NJlRdcHssHyjlPQ4eyXP5VQ286z0tCiFnSEFERESm1bGt4CuWx6FknrzlknJsJtausnZJK6YB4YhJ5+woI8NlvveDQ/z9j/fz1J4hXO/8d2P1fZ/X9ufY8JNe9m3PUjE8cseO5Bwj6piEPJOGRTZrrm+akVNLM5WmZkREZNpNtoK//5Ed9I4XeS2VZ3Y2RisRVi1tmFroCbB/KMfGfYNUCh72TpPvPn4Ioxn+/Ucv4ZaVXeel3lzWYetzo+zekcX3obUjQqX/JGHIh7hr4QNHknkuX9WgHiFnSUFERETOize2gm8IhfGO+OzdmSU9VqGuIcTegSyPbuutztpYYBk+deUQ9MI3HtjL0M0lPvre7mlZAOp6Ps/sHWbvngzpgw6hkklzS4h4wsbzq9NH2ZLzerMyHxKOjWN6HEkUiLVZrFnQfLqnkJNQEBERkfPmja3g3aU+Tc1hXnpujP7eIhv3DB7XldQ1fbKmg+FDzLX45w39WIMmCy9JsnBJgtb2yNve7lspe/z4ySM89M8H8cer0yy+AVbcYG2slUWJJKZRnT56dFtvtVnZRKOyouVyeGLdy1/cerm26L4FCiIiIhIYyzK4YnUDjc1hfvLzo5AD02aq18gk34C87ZL3XQazJfJbHHbvSNMxK0a5zsNJenQ0xrhmftMJYWCyAdlApkhbKso185soFz0Geov0HCny5AuDPL1jmBgWjuFTsFw8kxO25U42K3vylSG8QrUHyuFkgYbmEF+5dYWalb1FCiIiIhK4OfPjtK+MkN5Roa4comC7OOZJ1mQY4IV9utqj7DySYcMv+yhWqltps7ZDXcLmY9d0c/XC6oLRFw6P8HdPH2AgW8IzfCKeyWwrxnXtLTSHI3i+z/P7Rsjbzonhh9e35S5oTeK7PknH5vcu7STUZhLtNpnVGj9p+JEzpyAiIiIzwpyuBAdSeTrzUVqLERzPo2h5J5xkmwjb7BvM8diufnyqIygR16LViWAU4ZFf9nB0TgHw2XJojAZC1BOq3pdqwNiUHuK9K9qIRWxGvMqJp+VO8IFM0WHf4SxxLDpmRbnymkZmz43N6A6wtWTa9hcdPHiQT37yk8yfP59YLMbChQu57777KJfL0/WUIiJSw66Z30RbY4SjiQKHE3kMDBIn6TfS1RBl467X15J4Ew3RsiGHTMghG3J4YWSUF0bGyIQcMrZDznYo2NX/z070Adm0d4hsyTltTebEWpBsweGqdzSy7oMddM+LK4ScQ9M2IrJz5048z+Nv/uZvWLRoEdu3b+dTn/oUuVyOr371q9P1tCIiUqMm+43c9fAWhmNlipbH7FyMlGPjGj4ly2XtklZ6xopkThMgfDg+YBjV2/w33CdTciiUT/E4PkQ8k7Brkgk7rH5PE6vf0XQOfkp5I8P3/fPWJeYrX/kKDzzwAPv37z+j+6fTaerr6xkfH6eurm6aqxMRkZlgw/beqX4jtmfQWAozhxhXtjTSWR9lyCnxq90Dp5xOORsfuKydp/cOH7ct1/Qg4dpUDJ+BWBGr3WDTve/ROpCzcDbX7/O6RmR8fJymplMnylKpRKlUmvo6nU6fj7JERGQGeWO/kbZUlCtnN9B3pMieHRlGXy2TcmxKpkfZPHENydlIRkKsXdLKL1/qJeSZ2F51xcJYuEJfvEjBdnng969SCJlG5y2I7Nu3j69//ev81V/91Snvs379eu6///7zVZKIiMxQb+w3AjBvYYK5C+IsX1XPb742iDkGKcfGMXyKljvVet0AEpHq5S13bAOyYxg+1IdCRMomZgWun93K1v4x+v0imZDDWLhCR0OUv771Cm3LnWZnPTXzxS9+8U3DwnPPPcfq1aunvu7p6WHt2rWsXbuWv/u7vzvl951sRKS7u1tTMyIicpwN23v57Le2Ul8O0VQME3Ot4wZGVs1rxDDhmQMj+IaPB/iGj+UbhCZGPa5Z3MTli+qZPTdOa0eExpYwW4+OHddvRCMhb83ZTM2cdRAZGhpiaGjotPeZN28e0WgUqIaQG2+8kTVr1vCP//iPmOaZb9TRGhERETmVybUk/WNF6sohwp5JcyzMR66YxeKmFMWCy47DaX63e5hCycXwDVzTw6wz+KP3zuFfXdtFqs7WDphpMK1B5GwcPXqUG2+8kVWrVvHwww9jWWd3JLKCiIiInM7Juqa+cRTDcT2e2TNC31iBjsYY1y5u1kjHNJsRQWRyOmbOnDl8+9vfPi6EdHR0nNFjKIiIiIjUnhmxa+axxx5j79697N27l9mzZx/3e+dxx7CIiIjMYNPWWfWOO+7A9/2T/hIRERGBaQwiIiIiIm9GQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhKY8xJESqUSK1euxDAMtm7dej6eUkRERGrAeQkif/qnf0pXV9f5eCoRERGpIdMeRH75y1/y2GOP8dWvfnW6n0pERERqjD2dD97f38+nPvUpfvKTnxCPx9/0/qVSiVKpNPV1Op2ezvJEREQkYNM2IuL7PnfccQd33nknq1evPqPvWb9+PfX19VO/uru7p6s8ERERmQHOOoh88YtfxDCM0/56/vnn+frXv046nebee+8948e+9957GR8fn/p1+PDhsy1PREREaojh+75/Nt8wNDTE0NDQae8zb948/vAP/5BHHnkEwzCmbnddF8uyuO222/jWt771ps+VTqepr69nfHycurq6sylTREREAnI21++zDiJn6tChQ8et8ejp6eEDH/gAP/zhD1mzZg2zZ89+08dQEBEREak9Z3P9nrbFqnPmzDnu62QyCcDChQvPKISIiIjIhU+dVUVERCQw07p991jz5s1jmmaBREREpEZpREREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHAKIiIiIhIYBREREREJDAKIiIiIhIYBREREREJjIKIiIiIBEZBRERERAKjICIiIiKBURARERGRwCiIiIiISGAURERERCQwCiIiIiISGAURERERCYyCiIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMHbQBZyO7/sApNPpgCsRERGRMzV53Z68jp/OjA4iw8PDAHR3dwdciYiIiJytTCZDfX39ae8zo4NIU1MTAIcOHXrTH0Sq0uk03d3dHD58mLq6uqDLmfH0ep0dvV5nR6/X2dNrdnZm6uvl+z6ZTIaurq43ve+MDiKmWV3CUl9fP6Ne4FpQV1en1+ws6PU6O3q9zo5er7On1+zszMTX60wHELRYVURERAKjICIiIiKBmdFBJBKJcN999xGJRIIupWboNTs7er3Ojl6vs6PX6+zpNTs7F8LrZfhnsrdGREREZBrM6BERERERubApiIiIiEhgFEREREQkMAoiIiIiEpiaCiKPPvooa9asIRaL0dLSwkc+8pGgS6oJpVKJlStXYhgGW7duDbqcGengwYN88pOfZP78+cRiMRYuXMh9991HuVwOurQZ5Zvf/Cbz588nGo2yatUqNm3aFHRJM9L69eu5+uqrSaVStLW18aEPfYhdu3YFXVbNWL9+PYZh8LnPfS7oUma0o0eP8vGPf5zm5mbi8TgrV67khRdeCLqss1YzQeRHP/oRt99+O5/4xCd46aWXeOqpp/ijP/qjoMuqCX/6p396Rm12L2Y7d+7E8zz+5m/+hldeeYX//J//M//9v/93/uzP/izo0maMH/zgB3zuc5/jC1/4Ai+++CLXX389N998M4cOHQq6tBln48aN3H333TzzzDM8/vjjOI7DunXryOVyQZc24z333HM8+OCDrFixIuhSZrTR0VHe9a53EQqF+OUvf8mOHTv4q7/6KxoaGoIu7ez5NaBSqfizZs3y/+7v/i7oUmrOL37xC3/p0qX+K6+84gP+iy++GHRJNeMv//Iv/fnz5wddxoxxzTXX+Hfeeedxty1dutT/D//hPwRUUe0YGBjwAX/jxo1BlzKjZTIZf/Hixf7jjz/ur1271v/sZz8bdEkz1uc//3n/uuuuC7qMc6ImRkS2bNnC0aNHMU2TK6+8ks7OTm6++WZeeeWVoEub0fr7+/nUpz7Fd77zHeLxeNDl1Jzx8fGpgxcvduVymRdeeIF169Ydd/u6det4+umnA6qqdoyPjwPo79ObuPvuu7nlllt43/veF3QpM97PfvYzVq9ezcc+9jHa2tq48sor+du//dugy3pLaiKI7N+/H4AvfvGL/Mf/+B/5+c9/TmNjI2vXrmVkZCTg6mYm3/e54447uPPOO1m9enXQ5dScffv28fWvf50777wz6FJmhKGhIVzXpb29/bjb29vb6evrC6iq2uD7Pvfccw/XXXcdy5cvD7qcGev73/8+W7ZsYf369UGXUhP279/PAw88wOLFi/nnf/5n7rzzTv7dv/t3fPvb3w66tLMWaBD54he/iGEYp/31/PPP43keAF/4whf46Ec/yqpVq3jooYcwDIN/+qd/CvJHOO/O9DX7+te/Tjqd5t577w265ECd6et1rJ6eHm666SY+9rGP8cd//McBVT4zGYZx3Ne+759wmxzv05/+NNu2beN73/te0KXMWIcPH+azn/0sDz/8MNFoNOhyaoLneVx11VV8+ctf5sorr+Tf/tt/y6c+9SkeeOCBoEs7a3aQT/7pT3+aP/zDPzztfebNm0cmkwFg2bJlU7dHIhEWLFhw0S2UO9PX7M///M955plnTjh/YPXq1dx2221861vfms4yZ4wzfb0m9fT0cOONN3Lttdfy4IMPTnN1taOlpQXLsk4Y/RgYGDhhlERe95nPfIaf/exnPPHEE8yePTvocmasF154gYGBAVatWjV1m+u6PPHEE3zjG9+gVCphWVaAFc48nZ2dx10TAS699FJ+9KMfBVTRWxdoEGlpaaGlpeVN77dq1SoikQi7du3iuuuuA6BSqXDw4EHmzp073WXOKGf6mv3X//pf+fM///Opr3t6evjABz7AD37wA9asWTOdJc4oZ/p6QXUr3I033jg14maaNTFzeV6Ew2FWrVrF448/zoc//OGp2x9//HF+//d/P8DKZibf9/nMZz7Dj3/8Y377298yf/78oEua0d773vfy8ssvH3fbJz7xCZYuXcrnP/95hZCTeNe73nXClvDdu3fX5DUx0CBypurq6rjzzju577776O7uZu7cuXzlK18B4GMf+1jA1c1Mc+bMOe7rZDIJwMKFC/XJ7CR6enp497vfzZw5c/jqV7/K4ODg1O91dHQEWNnMcc8993D77bezevXqqRGjQ4cOaR3NSdx9991897vf5ac//SmpVGpqJKm+vp5YLBZwdTNPKpU6Yf1MIpGgublZ62pO4d//+3/PO9/5Tr785S/zr//1v2bz5s08+OCDNTmSWxNBBOArX/kKtm1z++23UygUWLNmDb/+9a9pbGwMujS5ADz22GPs3buXvXv3nhDUfB1QDcAf/MEfMDw8zJe+9CV6e3tZvnw5v/jFL2ryE9h0m5ynf/e7333c7Q899BB33HHH+S9ILjhXX301P/7xj7n33nv50pe+xPz58/na177GbbfdFnRpZ83w9S4rIiIiAdEkuIiIiARGQUREREQCoyAiIiIigVEQERERkcAoiIiIiEhgFEREREQkMAoiIiIiEhgFEREREQmMgoiIiIgERkFEREREAqMgIiIiIoFREBEREZHA/P/AQcS54ADRoAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mu = results[\"variational_mean\"].flatten()\n", - "plt.scatter(z, mu)\n", - "L = pm.expand_packed_triangular(n=n_inducing, packed=pt.as_tensor(results[\"vrc\"])).eval()\n", - "Sigma = L.dot(L.T)\n", - "sd = np.sqrt(np.diag(Sigma))\n", - "plt.fill_between(z, mu - 2 * sd, mu + 2 * sd, color=\"slateblue\", alpha=0.5)\n", - "plt.xlim([-6, 7])\n", - "plt.ylim([-5, 5]);" - ] - }, - { - "cell_type": "markdown", - "id": "67c76e4c-9605-4ed7-8b08-1af3f94a8fe9", - "metadata": {}, - "source": [ - "# 2D example" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8d890992-6550-40e3-9039-c7cc0ded18a9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def simulate_2d(\n", - " beta0_true,\n", - " beta1_true,\n", - " ell_true,\n", - " eta_true,\n", - " sigma_true,\n", - "):\n", - " seed = sum(map(ord, \"hsgp\"))\n", - " rng = np.random.default_rng(seed)\n", - "\n", - " # Create the 2d X locations\n", - " from scipy.stats import qmc\n", - "\n", - " sampler = qmc.Sobol(d=2, scramble=False, optimization=\"lloyd\")\n", - " X = 20 * sampler.random_base2(m=11) - 10.0\n", - "\n", - " # Draw one sample from the underlying GP\n", - " n = X.shape[0]\n", - " cov_func = eta_true**2 * pm.gp.cov.Matern52(2, ell_true, active_dims=[0, 1])\n", - " gp_true = pm.MvNormal.dist(mu=np.zeros(n), cov=cov_func(X))\n", - " f_true = pm.draw(gp_true, draws=1, random_seed=rng)\n", - "\n", - " # Add the fixed effects\n", - " mu = f_true\n", - "\n", - " # The observed data is the latent function plus a small amount\n", - " # of Gaussian distributed noise.\n", - " noise_dist = pm.Normal.dist(mu=0.0, sigma=sigma_true)\n", - " y_obs = mu + pm.draw(noise_dist, draws=n, random_seed=rng)\n", - " return y_obs[:, None], f_true, mu, X\n", - "\n", - "\n", - "y_data, f_true, mu, X_data = simulate_2d(1, 1, 1.0, 1.0, 0.1)\n", - "plt.scatter(X_data[:, 0], X_data[:, 1], c=y_data)\n", - "with pm.Model() as model:\n", - " pm.Data(\"X\", np.asarray(X_data))\n", - " pm.Data(\"y\", np.asarray(y_data))\n", - "\n", - " eta = pm.Exponential(\"eta\", scale=1.0)\n", - " ell = pm.InverseGamma(\"ell\", mu=1.0, sigma=1.0)\n", - " cov_func = eta**2 * pm.gp.cov.ExpQuad(input_dim=2, ls=ell)\n", - "\n", - " c = pm.Exponential(\"c\", scale=10)\n", - " mean_func = pm.gp.mean.Constant(c)\n", - "\n", - " n_inducing = 200\n", - " z_init = pm.gp.util.kmeans_inducing_points(n_inducing, np.asarray(X_data))\n", - "\n", - " sigma = pm.Exponential(\"sigma\", scale=10)\n", - "\n", - " batch_size = 2048\n", - " svgp = SVGP(\n", - " input_dim=X_data.shape[1],\n", - " n_data=X_data.shape[0],\n", - " batch_size=batch_size,\n", - " mean_func=mean_func,\n", - " cov_func=cov_func,\n", - " sigma=sigma,\n", - " z_init=z_init,\n", - " variational_sd_dist=pm.HalfStudentT.dist(sigma=1, nu=6),\n", - " )\n", - "\n", - " initial_point = model.initial_point()\n", - " params = tuple(initial_point.values())" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "4c819af8-12b9-4888-9a68-01e9a4b7a36f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGdCAYAAADqsoKGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMK0lEQVR4nO3deViVZf4/8PfZOEcREEFBFBDcQHE9mGKRWYZb22S5TKM2ZRNTjilj49ZiZmHpFPnN5ZdL21Q6jVpWlGIpWaAmginijqAIIi4cFOEsPL8/8Dx6ApWDz+E5y/t1Xee6vj3ch+dzM/Pt/sy9fRSCIAggIiIicnFKuQMgIiIikgKTGiIiInILTGqIiIjILTCpISIiIrfApIaIiIjcApMaIiIicgtMaoiIiMgtMKkhIiIit6CWO4CmVFNTg9OnT8PHxwcKhULucIiIiKgBBEFARUUFQkJCoFTeeD7Go5Ka06dPIzQ0VO4wiIiIqBFOnjyJ9u3b3/DnHpXU+Pj4AKj9o/j6+socDRERETWEwWBAaGioOI7fiEclNdYlJ19fXyY1RERELuZWW0e4UZiIiIjcApMaIiIicgtMaoiIiMgtMKkhIiIit8CkhoiIiNwCkxoiIiJyC0xqiIiIyC0wqSEiIiK3wKSGiIiI3EKjkpqlS5ciIiICOp0Oer0e27dvv2n79PR06PV66HQ6REZGYvny5TY/X7FiBeLj4+Hv7w9/f38MGTIEu3btsmkzd+5cKBQKm09wcHBjwiciIiI3ZHdSs3btWkydOhVz5sxBdnY24uPjMXz4cBQWFtbbPj8/HyNGjEB8fDyys7Mxe/ZsTJkyBevWrRPbbNu2DePGjcPWrVuRmZmJsLAwJCQkoKioyOZ3de/eHcXFxeJn37599oZPREREbkohCIJgzxf69++Pvn37YtmyZeKz6OhoPPLII0hOTq7TfsaMGdi4cSPy8vLEZ4mJidi7dy8yMzPrfYfFYoG/vz/ef/99TJgwAUDtTM1XX32FnJwce8K1YTAY4Ofnh/LyctZ+IiIichENHb/tKmhpNBqRlZWFmTNn2jxPSEhARkZGvd/JzMxEQkKCzbOhQ4di1apVMJlM0Gg0db5TWVkJk8mEVq1a2Tw/cuQIQkJCoNVq0b9/f7z55puIjIy8YbzV1dWorq4W/9lgMNyyj1LaX1SOjXtPQ61UQKdRQadRopW3FkG+WrTx0SGkpQ4+urr9JyIiIvvZldSUlZXBYrEgKCjI5nlQUBBKSkrq/U5JSUm97c1mM8rKytC2bds635k5cybatWuHIUOGiM/69++PTz75BF26dMGZM2cwf/58DBw4ELm5uQgICKj33cnJyXjttdfs6aKk5n1zALtOnL9pm7Z+OnRq0wJdgnzQK7QlYsP9EdKyWRNFSERE5D7sSmqs/lj6WxCEm5YDr699fc8B4O2338YXX3yBbdu2QafTic+HDx8u/t89evRAXFwcOnbsiI8//hhJSUn1vnfWrFk2PzMYDAgNDb1Jz6RlqDIBABK6BSGghRZVJgvKLlWj1FCNMxVVuFhpQnF5FYrLq7D9SJn4vRA/HQZEBmBwVBvc3aU1/JpxNoeIiOhW7EpqAgMDoVKp6szKlJaW1pmNsQoODq63vVqtrjPDsmjRIrz55pvYsmULevbsedNYvL290aNHDxw5cuSGbbRaLbRa7U1/jyOZa2qTt7/eGYG4jnVnk8qvmHC09BKOllYgr7gCWQUXcKDYgNPlVVifXYT12UVQKRXo18EfD/QMwQM926Jlc6+m7gYREZFLsCup8fLygl6vR1paGv70pz+Jz9PS0vDwww/X+524uDh88803Ns82b96M2NhYm/00CxcuxPz587Fp0ybExsbeMpbq6mrk5eUhPj7eni40KbOlBgCgVtU/i+XXTAN9uD/04f7is8vVZuScvIifD5/FTwdLcaT0EnYcP48dx89j3jcHMDiqNR7Th+LeqDZQKW88O0ZERORp7F5+SkpKwvjx4xEbG4u4uDh88MEHKCwsRGJiIoDaJZ+ioiJ88sknAGpPOr3//vtISkrCM888g8zMTKxatQpffPGF+DvffvttvPzyy/j888/RoUMHcWanRYsWaNGiBQBg+vTpePDBBxEWFobS0lLMnz8fBoMBEydOvO0/gqOYLLUzNWo7kg9vrRp3dgrEnZ0CMWtENArPVeKH3GJsyD6NvGIDNuWewabcM2jv3wzjB4RjTL9Qzt4QERGhEUnNmDFjcO7cOcybNw/FxcWIiYlBamoqwsPDAQDFxcU2d9ZEREQgNTUV06ZNw5IlSxASEoLFixdj1KhRYpulS5fCaDTiscces3nXq6++irlz5wIATp06hXHjxqGsrAytW7fGgAEDsGPHDvG9zshydflJo2r8xc1hAc3xt7s74m93d8TBEgPW7ynCf3efxKkLV5D8/UG8u+UwxvYLQ+Kgjgj20936FxIREbkpu++pcWVNfU9N7Pw0lF0y4vsX4hHdVrr3VZks+DqnCB9lFCCvuPaYupdKibF3hCJxUEeeniIiIrfS0PGbtZ8cyLr8pLnBnprG0mlUGNMvDKlT7sKnT9+Bfh38YbTU4JPMAtyzcBuSv88TT14RERF5CiY1DmRdflIpHfNnVigUiO/cGv99Ng6fP9Mfd0S0gtFSg/+Xfhz3LNyGT3cUiJuViYiI3B2TGgcyWU8/OfiUkkKhwMCOgVj7twFY/WQsOrb2xvnLRrz81X6MXPwLsgpufgEgERGRO2BS40BmCTYK20OhUODeqCD8MPVuzHu4O/yba3DoTAUeW56JORv2ofwKl6SIiMh9MalxEEEQrlt+atr7ZDQqJSbEdcBP/7wHj+vbQxCAz3YWYsg76diUW385CyIiIlfHpMZBrLM0gPQbhRvK39sLCx/vhS+eGYDIQG+crajGs59m4cUv96KCG4mJiMjNMKlxEMt1SY26iZafbiSuYwC+nxqPv9/TEQoF8GXWKQx/bzt+u0WxTSIiIlfCpMZBTNedOnL0RuGG0KpVmDEsCv99Ng7t/Zvh1IUrGP3/MvFO2mGbBIyIiMhVMalxELPlupkaJ0hqrPp1aIXvX4gX99os/vEIJq7ehbJL1XKHRkREdFuY1DjI9XtqnK3wpI9Og4WP98J7Y3ujmUaFX46W4YHFv2A3l6OIiMiFMalxEHPNtTtqFArnSmqsHu7dDhsn34mOrb1RYqjC2A924KNf8+FBlTOIiMiNMKlxEOvyk1qmk08N1TnIBxsn34WHeoXAXCNg7jcHMOer/TZ7goiIiFwBkxoHES/ec1CJBCl5a9V4b2xvzB4RBYUC+HxnISau3oWLlUa5QyMiImow5x9xXZS15pLKyWdqrBQKBf52d0esnBALby8VMo6dwyNLfsWxs5fkDo2IiKhBmNQ4iLVCt9oFZmqud190ENY9NxDtWjbDiXOVGLUsA3sKL8gdFhER0S251ojrQixi3SfXmKm5XlSwL76efCd6hbbExUoT/rxiB7YeLJU7LCIioptiUuMgpqunn5ztOHdDBbbQ4otn+mNQl9aoMtVg0ie78b+sU3KHRUREdENMahzEevqpqSp0O0JzLzVWTozFo33awVIjYPqXe/H/0o/JHRYREVG9XHfEdXLX31PjyjQqJRY93gvP3h0JAEj+/iBSthzmXTZEROR0mNQ4iHWmxlWXn66nVCowa0Q0/jWsKwAgZcsRLNx0iIkNERE5FSY1DmKdqXHl5ac/eu6eTnhpZDQAYOm2Y3jjuzwmNkRE5DTcZ8R1Mq5yo7C9JsVHYt7D3QEAK3/Jx9yNuUxsiIjIKTCpcRDrjcKuvqemPhPiOiD50R5QKICPMwsw79sDTGyIiEh2TGocxFo7ydUu32uocXeE4a1RPQEAH/56Aos2H5I5IiIi8nTuOeI6Aevle+62/HS90bGheP3qUtSSrcewZOtRmSMiIiJPxqTGQcQ9NW64/HS98XEdMHtEFABg4aZDWPVLvswRERGRp2JS4yDinho3Ov10I3+7uyOmDekCAHj92wP4YlehzBEREZEncv8RVybucvleQ025rxOeHVR7Qd+cDfuwKbdE5oiIiMjTMKlxELFKtwfM1ACAQqHAzGFRGHdHKGoEYMoX2fjtxHm5wyIiIg/iGSOuDCzWy/c8ZKYGqE1sXn84BkOig1BtrsHTH/2Gw2cq5A6LiIg8BJMaBzG5UZkEe6hVSvzfuD7Qh/vDUGXGxNW7UFx+Re6wiIjIAzCpcRCzhy0/Xa+ZlwqrJsaiU5sWKC6vwsTVu1BeaZI7LCIicnOeN+I2EXH5yY3vqbmZls298PFTdyDIV4vDZy7h759liRcSEhEROQKTGgcx1Xjm8tP12rVsho/+ege8vVTIOHYOL3+1n+UUiIjIYZjUOIjZ4n5Vuhsjuq0v/u/PfaBUAGt+O4mV23k5HxEROYZnj7gO5M4FLe11b1QQXhrZDQDw5vd5SDtwRuaIiIjIHTGpcRBPKZPQUH+9swOe6B8GQQBeWJON3NPlcodERERuhkmNg4g3Cnv48pOVQqHA3Ie6I75zICqNFkz6eDdKDVVyh0VERG6EI66DXDvSzZkaK41Kiff/3Fc86v3cZ3tgNPNEFBERSYNJjYNwT039/JppsGJCLHx0auwuuIB53+bKHRIREbkJJjUOYr2TRa3kn/iPIgK98d7Y3lAogP/sKMTa31jVm4iIbh9HXAexXJ2p8dTL927l3qggJA3pAgB4+atcZBdekDkiIiJydUxqHORa7Sf+iW/k+cGdkNAtCEZLDf7+nz0oreDGYSIiajyOuA5iEU8/cabmRpRKBf49uhc6tvZGiaEKz3PjMBER3QYmNQ5i5vJTg/joNPhgQix8tGr8duIC3vrhoNwhERGRi2JS4yDWjcJcfrq1jq1b4N+jewEAVv2Sjx/2l8gcERERuSKOuA4ibhTmke4GSegejGfiIwAAL/5vLwrPVcocERERuRomNQ5ybaMwk5qG+tewKPQNa4mKKjOe+zwLVSaL3CEREZELYVLjINYyCZ5epdse1huH/ZtrsL/IgDe+y5M7JCIiciEccR2EZRIaJ6RlM7w7pjcA4NMdBdi497S8ARERkctgUuMg1tNPXH6y3z1d22Dy4E4AgFnrfsexs5dkjoiIiFwBkxoHMVu4/HQ7pg7pjAGRrXDZaME/Ps9GtZn7a4iI6OY44joIC1reHrVKicVj+6CVtxcOFBvw9g+H5A6JiIicHJMaBxH31PCemkZr46vDwsd6Aqi9v2bboVKZIyIiImfGEddBzCyTIIn7ooMwMS4cADD9y704W1Etc0REROSsmNQ4CMskSGfWiGh0DfJB2SUjpn+5FzVX/7ZERETXY1LjIGZW6ZaMTqPC4nF9oFUrkX74LD7MOCF3SERE5IQaNeIuXboUERER0Ol00Ov12L59+03bp6enQ6/XQ6fTITIyEsuXL7f5+YoVKxAfHw9/f3/4+/tjyJAh2LVr122/V07W2k/cKCyNrsE+eGlkNADgre8PIvd0ucwRERGRs7E7qVm7di2mTp2KOXPmIDs7G/Hx8Rg+fDgKCwvrbZ+fn48RI0YgPj4e2dnZmD17NqZMmYJ169aJbbZt24Zx48Zh69atyMzMRFhYGBISElBUVNTo98pNrP3EI92S+cuAcAyJDoLRUoMpX2TjipHHvImI6BqFIAh2bVDo378/+vbti2XLlonPoqOj8cgjjyA5OblO+xkzZmDjxo3Iy7t25X1iYiL27t2LzMzMet9hsVjg7++P999/HxMmTGjUe+tjMBjg5+eH8vJy+Pr6Nug7jSEIAiJmpQIAfpszBK19tA57l6c5f9mI4e/9jDOGajw5sAPmPtRd7pCIiMjBGjp+2zWNYDQakZWVhYSEBJvnCQkJyMjIqPc7mZmZddoPHToUu3fvhslkqvc7lZWVMJlMaNWqVaPfCwDV1dUwGAw2n6Zgvm4jKzcKS6uVtxfefqwXAOCjjBP49WiZzBEREZGzsCupKSsrg8ViQVBQkM3zoKAglJSU1PudkpKSetubzWaUldU/IM2cORPt2rXDkCFDGv1eAEhOToafn5/4CQ0NvWUfpWC5LqlRc/lJcoO6tMZfBoQBqD3mXX6l/uSYiIg8S6NGXIXCdvZBEIQ6z27Vvr7nAPD222/jiy++wPr166HT6W7rvbNmzUJ5ebn4OXny5A3bSsm6SRjgRmFHmT0iGuEBzVFcXoXXNubKHQ4RETkBu5KawMBAqFSqOrMjpaWldWZRrIKDg+ttr1arERAQYPN80aJFePPNN7F582b07Nnztt4LAFqtFr6+vjafpmAzU8OkxiGae6nxzuheUCqA9dlF+H5fsdwhERGRzOxKary8vKDX65GWlmbzPC0tDQMHDqz3O3FxcXXab968GbGxsdBoNOKzhQsX4vXXX8cPP/yA2NjY236vnEyWa0kNq3Q7jj68FRIHdQQAzN6wD6UVVTJHREREcrJ7+SkpKQkrV67E6tWrkZeXh2nTpqGwsBCJiYkAapd8rCeWgNqTTgUFBUhKSkJeXh5Wr16NVatWYfr06WKbt99+Gy+99BJWr16NDh06oKSkBCUlJbh06VKD3+tMxBIJSsVNl8fo9k0d0gXRbX1xodKE2ev3wc7DfERE5EbU9n5hzJgxOHfuHObNm4fi4mLExMQgNTUV4eG19XmKi4tt7o6JiIhAamoqpk2bhiVLliAkJASLFy/GqFGjxDZLly6F0WjEY489ZvOuV199FXPnzm3Qe52JWMySJ58czkutxDuje+Hh93/FlrxSfLn7FEb3a5oN4URE5FzsvqfGlTXVPTX5ZZcxeNE2+GjV2PfaUIe9h65Znn4MC74/iBZaNTZNuxvtWjaTOyQiIpKIQ+6poYYxXz39pOJMTZN5Jj4SfcNa4lK1GbO4DEVE5JGY1DiA9fI9NYtZNhmVUoG3H+sFL7USPx8+iy+zTskdEhERNTGOug4g7qnhyacm1alNC0wb0gUA8Pq3B3DGwNNQRESehEmNA5isp5+4/NTknomPQK/2fqioMmPOBi5DERF5EiY1DsAK3fJRq5R4+7Fe0KgU2JJXio17T8sdEhERNRGOug5gLZPAi/fk0TXYB1Pu7QwAeHVjLs5WVMscERERNQUmNQ7APTXyS7ynI7q19cXFShNe+Xq/3OEQEVETYFLjAFx+kp9GpcTCx3tCrVTg+/0lSGVtKCIit8dR1wG4/OQcuof44bl7amtDvfzVfly4bJQ5IiIiciQmNQ5gFmdqmNTIbfK9ndE1yAfnLhvxRmqe3OEQEZEDMalxAF6+5zy81Eq8+WgPKBTA/7JOIeNomdwhERGRg3DUdQBrmQTeU+Mc9OH+GD+gtvDp7A37UGWyyBwRERE5ApMaB+DpJ+fz4tCuCPbV4cS5Siz+8Yjc4RARkQMwqXEAcfmJp5+cho9Og9ce7g4A+ODn48grNsgcERERSY2jrgOYrWUSOFPjVIZ2D8bQ7kEw1wiYtX6fePSeiIjcA5MaBxCXnzhT43ReeygGPlo1ck5exH92FMgdDhERSYijrgNYZ2o0nKlxOsF+OvxreBQA4O0fDuL0xSsyR0RERFJhUuMApqszNbx8zzk9cUcY9OH+uGy04JWvc1nJm4jITTCpcQALNwo7NaVSgeRHe1yt5H0Gm3JL5A6JiIgkwFHXAaz31PBGYefVJcgHiYNqSyi88nUuKqpMMkdERES3i0mNA5hquPzkCp4f3AnhAc1RWlGNlC28u4aIyNUxqXEAVul2DTqNCvMejgEAfJRxAgdO8+4aIiJXxlHXAaxVunlPjfMb1KU1RvZoC0uNgJe+2oca3l1DROSymNQ4AMskuJaXH+gGby8V9hRexJdZJ+UOh4iIGolJjQOwTIJrCfbTYdr9XQAAyd8fxPnLRpkjIiKixuCo6wDW00/cKOw6nhzYAVHBPrhYacJb3x+UOxwiImoEJjUOYBY3CjOpcRVqlRLzH6ndNLx290lkFZyXOSIiIrIXkxoHEJeflPzzupLYDq0wOrY9AGDOhv3ijBsREbkGjroOYB0M1ZypcTkzh0ejZXMNDpZU4ONMFrwkInIlTGocwGThTI2rauXthZnDagtevrP5EErKq2SOiIiIGoqjrgNYajhT48pGx4aib1hLXDZa8Pp3B+QOh4iIGohJjQNc21PDpMYVKZUKzH+kB5QK4Lvfi/HLkTK5QyIiogZgUuMA4uV7vKfGZXUL8cWEuA4AgLnf5Iq3RBMRkfPiqOsA5qvLTxrO1Li0afd3QYC3F46WXsLHGSfkDoeIiG6BSY0DWDcK8/I91+bXTIMZVzcNp2w5gtIKbhomInJmTGocgFW63cdj+vboFdoSl6rNWMCbhomInBpHXQcw8Z4at6FUKvDaQ90BAOv3FPGmYSIiJ8akxgGsp5+4/OQeeoe2xJjYUADAK1/nijNxRETkXJjUOACXn9zPi8O6wkenRu5pA9b8Vih3OEREVA+Oug4gLj9xpsZtBLbQIun+LgCAhZsO4cJlo8wRERHRHzGpcQAzyyS4pfEDwtE1yAcXK034d9ohucMhIqI/4KjrAOKNwtwo7FbUKiVee7h20/DnOwuRe7pc5oiIiOh6TGocQLx8j0mN2xkQGYAHerZFjQC8+nUuBIGbhomInAWTGgcwi5fv8c/rjuaMjEYzjQq7Cy7gq5wiucMhIqKrOOo6gHWmhhuF3VNbv2aYfG8nAMCbqQdRUWWSOSIiIgKY1DiEdaaGR7rd16T4CHQIaI6zFdVYsvWY3OEQERGY1EhOEARevucBtGoVXhrZDQCw+pd8FJy7LHNERETEpEZi1982y43C7u2+6DaI7xwIo6UGb6bmyR0OEZHHY1IjMfN1SQ1natybQqHAyw90g0qpwKbcM8g4WiZ3SEREHo1JjcSstwkD3FPjCboE+eAv/cMAAPO+PQDzdf/5ExFR0+KoK7Hrl594+skzTB3SBX7NNDhYUoE1v52UOxwiIo/FpEZiJguXnzyNv7cXpg3pDAB4J+0wyq/wiDcRkRyY1EjMOlOjViqgUDCp8RRPDAhHpzYtcP6yEYt/PCJ3OEREHolJjcTECt08+eRRNColXn6g9oj3xxkncOzsJZkjIiLyPExqJCYWs2SJBI8zqEtr3BfVBuYaAfO/PSB3OEREHocjr8QsNZyp8WRzRkZDo1Jg66Gz2HaoVO5wiIg8SqOSmqVLlyIiIgI6nQ56vR7bt2+/afv09HTo9XrodDpERkZi+fLlNj/Pzc3FqFGj0KFDBygUCqSkpNT5HXPnzoVCobD5BAcHNyZ8h7JuFOZMjWeKbN0CE+M6AABe//aAzRF/IiJyLLtH3rVr12Lq1KmYM2cOsrOzER8fj+HDh6OwsLDe9vn5+RgxYgTi4+ORnZ2N2bNnY8qUKVi3bp3YprKyEpGRkViwYMFNE5Xu3bujuLhY/Ozbt8/e8B3ObLm2UZg80z/u64xW3l44dvYy/rOjQO5wiIg8ht1JzTvvvIOnn34akyZNQnR0NFJSUhAaGoply5bV23758uUICwtDSkoKoqOjMWnSJDz11FNYtGiR2KZfv35YuHAhxo4dC61We8N3q9VqBAcHi5/WrVvbG77Dmbn85PH8mmkwPaErACBlyxFcuGyUOSIiIs9gV1JjNBqRlZWFhIQEm+cJCQnIyMio9zuZmZl12g8dOhS7d++GyWTffR5HjhxBSEgIIiIiMHbsWBw/fvym7aurq2EwGGw+jmbdKMzbhD3bmH6hiG7ri/IrJry75bDc4RAReQS7Rt6ysjJYLBYEBQXZPA8KCkJJSUm93ykpKam3vdlsRllZw2vl9O/fH5988gk2bdqEFStWoKSkBAMHDsS5c+du+J3k5GT4+fmJn9DQ0Aa/r7Gseyh48Z5nUykVeOXqEe//7CjAoZIKmSMiInJ/jZpO+OOlcoIg3PSiufra1/f8ZoYPH45Ro0ahR48eGDJkCL777jsAwMcff3zD78yaNQvl5eXi5+RJx19hf/3le+TZ4joGYFj3YNQItZuGrf+9JyIix7ArqQkMDIRKpaozK1NaWlpnNsYqODi43vZqtRoBAQF2hnuNt7c3evTogSNHbnx7q1arha+vr83H0awbhbn8RAAwe0Q0vFRK/HK0DNsOnZU7HCIit2bXyOvl5QW9Xo+0tDSb52lpaRg4cGC934mLi6vTfvPmzYiNjYVGo7Ez3Guqq6uRl5eHtm3bNvp3OAKXn+h6YQHN8de7OgAA5n/HI95ERI5k93RCUlISVq5cidWrVyMvLw/Tpk1DYWEhEhMTAdQu+UyYMEFsn5iYiIKCAiQlJSEvLw+rV6/GqlWrMH36dLGN0WhETk4OcnJyYDQaUVRUhJycHBw9elRsM336dKSnpyM/Px87d+7EY489BoPBgIkTJ95O/yVnETcKM6mhWs8P7iQe8f5iV/1XHxAR0e1T2/uFMWPG4Ny5c5g3bx6Ki4sRExOD1NRUhIeHAwCKi4tt7qyJiIhAamoqpk2bhiVLliAkJASLFy/GqFGjxDanT59Gnz59xH9etGgRFi1ahEGDBmHbtm0AgFOnTmHcuHEoKytD69atMWDAAOzYsUN8r7MwsUwC/YGvToNp93fBy1/tx7tph/Fw73bwa9b4WUoiIqqfQvCg3YsGgwF+fn4oLy932P6a9XtOIem/exHfORCfPt3fIe8g12O21GDYe9txtPQS/nZ3JGaPiJY7JCIil9HQ8ZvTCRIz8/QT1UOtUmLOyNpE5qNfT6Dg3GWZIyIicj9MaiQmlkng6Sf6g3u6tEZ850AYLTV464eDcodDROR2OPJKTCyTwJka+gOFQoGXRnaDUgGk7ivBbyfOyx0SEZFbYVIjMc7U0M10DfbB2DvCAADzvz2AmhqP2dJGRORwHHklxpkaupVpQ7qghVaNvafK8fXeIrnDISJyG0xqJMaNwnQrrX20eG5wRwDA2z8cwhWjReaIiIjcA5MaiXH5iRriqTsj0K5lMxSXV2Hl9ptXmycioobhyCsxs4XLT3RrOo0KM4ZHAQCWpR9DqaFK5oiIiFwfkxqJictPLJNAt/Bgz7boE9YSlUYL/r35sNzhEBG5PCY1EjPXsEo3NYz1iDcA/DfrJA6cNsgcERGRa+PIKzFW6SZ76MP98UDPthCE2ireHlS1hIhIckxqJCZW6WZSQw00Y1gUvNRKZBw7h58OlsodDhGRy2JSIzETTz+RnUJbNcfTd0UAAN5IzRNn+4iIyD4ceSVm5vITNcJz93REgLcXjp+9jM92FMgdDhGRS2JSIzFx+Ymnn8gOPjoNkhK6AABSfjyC8kqTzBEREbkeJjUSM4k3CvNPS/YZExuKLkEtcLHShP/76Yjc4RARuRyOvBITL9/jTA3ZSa1SYs7VI94fZ57AibLLMkdERORamNRIzMyZGroNg7q0xqAurWGyCEj+Pk/ucIiIXApHXolxpoZu15yR0VAqgE25Z7Dz+Dm5wyEichlMaiTGKt10u7oE+WDcHWEAgPnf5aGmhhfyERE1BJMaibFKN0lh2v1d0EKrxr6icnyVUyR3OERELoEjr8TMNbXLT7xRmG5HYAstnh/cCQDw9g+HcMVokTkiIiLnx6RGYtYbhXn5Ht2uv97ZAe1aNkOJoQortx+XOxwiIqfHpEZiFlbpJonoNCrMHB4FAFiWfgylhiqZIyIicm4ceSXGKt0kpQd6tkWfsJaoNFrw782H5Q6HiMipMamRmHWmhke6SQoKhQIvXb2Q779ZJ3HgtEHmiIiInBeTGomZufxEEtOH++OBnm0hCMD87w5AEHjEm4ioPhx5JcblJ3KEGcOi4KVWIuPYOfx0sFTucIiInBKTGomJG4VZJoEkFNqqOZ66MwIA8EZqnpg8ExHRNRx5JWaycE8NOcZzgzsiwNsLx89exuc7C+UOh4jI6TCpkZj18j2WSSCp+eo0mHZ/FwBAypbDKL9ikjkiIiLnwqRGYhaWSSAHGtsvFJ3btMCFShOWbD0qdzhERE6FI6/ETJypIQdSq5SYPTIaAPDRrydQcO6yzBERETkPJjUSM3NPDTnYPV1aI75zIIyWGrz1w0G5wyEichpMaiQkCIJ4T42ap5/IQRQKBeaMjIZSAaTuK8FvJ87LHRIRkVPgyCsh63FuANBwpoYcKCrYF2P6hQEA5n97ADU1vJCPiIhJjYTM1w0svHyPHC3p/i7w9lJh76lybNx7Wu5wiIhkx6RGQmabmRr+acmxWvto8dzgTgCAt384iCqTReaIiIjkxZFXQubrbnnl6SdqCk/fFYF2LZvhdHkVVv2SL3c4RESyYlIjIettwgCXn6hp6DQq/GtYVwDA0q1HUVpRJXNERETyYVIjIYt48kkBhYJJDTWNB3uGoFdoS1w2WvBu2mG5wyEikg2TGglZiwzyjhpqSkqlAi9fvZBv7W8nkVdskDkiIiJ5MKmRkIV31JBMYju0wsgebVEjAG98lwdB4BFvIvI8HH0lJBaz5EwNyWDGsCh4qZT45WgZth06K3c4RERNjkmNhKwbhTlTQ3IIC2iOv97ZAQDwRmqezWk8IiJPwNFXQtdvFCaSw3ODO6GVtxeOll7CF7+dlDscIqImxaRGQtwoTHLza6bBtCGdAQDvph2Gocokc0RERE2HSY2EzJypIScw7o4wdGztjfOXjViy9ajc4RARNRkmNRIyW/fUsEQCyUitUmLO1SPeH/5yAifPV8ocERFR0+DoKyHx9BNnakhmg7u2wV2dAmG01GDBDwflDoeIqEkwqZHQtZkaJjUkL4VCgTkjo6FQAN/9XoysgvNyh0RE5HBMaiRk5uV75ESi2/piTGwoAOD1b3khHxG5P46+ErLeC6LhTA05iaSELmjupULOyYv45vdiucMhInIoJjUSMl2dqWGFbnIWbXx0eO6ejgCAt74/iCqTReaIiIgch0mNhCw11pka/lnJeUyKj0SInw5FF69g9a/5codDROQwHH0ldK1MAmdqyHnoNCq8OKwrAGDp1mM4W1Etc0RERI7RqKRm6dKliIiIgE6ng16vx/bt22/aPj09HXq9HjqdDpGRkVi+fLnNz3NzczFq1Ch06NABCoUCKSkpkry3qVlPP6m4UZiczMO92qFnez9cqjbj3S2H5Q6HiMgh7B59165di6lTp2LOnDnIzs5GfHw8hg8fjsLCwnrb5+fnY8SIEYiPj0d2djZmz56NKVOmYN26dWKbyspKREZGYsGCBQgODpbkvXK4tvzEmRpyLkqlAi+N7AYAWLOrEIdKKmSOiIhIenYnNe+88w6efvppTJo0CdHR0UhJSUFoaCiWLVtWb/vly5cjLCwMKSkpiI6OxqRJk/DUU09h0aJFYpt+/fph4cKFGDt2LLRarSTvlYOJNwqTE7sjohWGxwSjRqit4k1E5G7sGn2NRiOysrKQkJBg8zwhIQEZGRn1ficzM7NO+6FDh2L37t0wmRpWbK8x7wWA6upqGAwGm48j8UZhcnYzh0dBo1Lg58Nnse1QqdzhEBFJyq6kpqysDBaLBUFBQTbPg4KCUFJSUu93SkpK6m1vNptRVlbmsPcCQHJyMvz8/MRPaGhog97XWCxoSc4uPMAbTw7sAAB4MzVPvFuJiMgdNGqdRKGwHbQFQajz7Fbt63su9XtnzZqF8vJy8XPy5Em73mcvFrQkVzD53s7wb67B4TOXsOY3x/7/BBFRU7Jr9A0MDIRKpaozO1JaWlpnFsUqODi43vZqtRoBAQEOey8AaLVa+Pr62nwciTM15Ar8mmkwdUgXAMA7aYdRfqVhy8BERM7OrqTGy8sLer0eaWlpNs/T0tIwcODAer8TFxdXp/3mzZsRGxsLjUbjsPfKwTqVz4KW5Oz+3D8Mndq0wPnLRiz+8Yjc4RARScLudZKkpCSsXLkSq1evRl5eHqZNm4bCwkIkJiYCqF3ymTBhgtg+MTERBQUFSEpKQl5eHlavXo1Vq1Zh+vTpYhuj0YicnBzk5OTAaDSiqKgIOTk5OHr0aIPf6wysMzW8UZicnUalxCsP1B7x/jjjBI6W8og3Ebk+tb1fGDNmDM6dO4d58+ahuLgYMTExSE1NRXh4OACguLjY5u6YiIgIpKamYtq0aViyZAlCQkKwePFijBo1Smxz+vRp9OnTR/znRYsWYdGiRRg0aBC2bdvWoPc6g2uX73Gmhpzf3V1aY0h0ELbkncG8b/Pw8V/72b3PjYjImSgE665dD2AwGODn54fy8nKH7K955ev9+CSzAFPu7YSkhK6S/34iqZ0ou4z7302HySJg9ZOxuDfqxnvUiIjk0tDxm+skEuLle+RqOgR646m7IgAAr3+bB6OZR7yJyHVx9JWQtUwCl5/IlUwe3AmBLbTIL7uMjzJYxZuIXBeTGglZ99Sw9hO5Eh+dBjOuVvFe/ONRVvEmIpfFpEZCphpW6SbXNKpve7GK98JNB+UOh4ioUTj6SohVuslVKZUKvPpgdwDAl1mn8Pupi/IGRETUCExqJCRuFOZMDbkgfbg/HukdAkEAXvvmADzoYCQRuQmOvhISbxTmRmFyUTOHR6OZRoWsggvYuPe03OEQEdmFSY2ExNpPXH4iFxXsp8PzgzsCAJJTD6LSaJY5IiKihmNSIyFW6SZ3MCk+Eu39m6HEUIXl247JHQ4RUYNx9JWQuYbLT+T6dBoV5oyIBgD8v5+P4+T5SpkjIiJqGCY1EhKXn5jUkIsbFhOMuMgAVJtrkPx9ntzhEBE1CJMaCV27fI9/VnJtCoUCrzzYDUoFkLqvBBnHyuQOiYjoljj6SshkYZkEch/RbX3x5/5hAIC5G3PF/34TETkrJjUSsvD0E7mZ6Qld4d9cg8NnLuHjjBNyh0NEdFNMaiRk3VPD5SdyFy2be+Ffw6IAAClbjqDUUCVzREREN8bRV0JmVukmNzQmNhS9rtaFSv6edaGIyHkxqZGQuFGYZRLIjSiVCsx7OAYKBbAhuwi78s/LHRIRUb04+kpIrP3EPTXkZnqFtsTYfqEAgFe+3i+WBCEiciZMaiRk4eV75MZeHBqFls01OFhSgU93FMgdDhFRHUxqJMQyCeTOWnl7YXpCVwDAO5sP42xFtcwRERHZ4ugrIRNnasjNjbsjDDHtfFFRbcYCbhomIifDpEZCvKeG3J3q6qZhAFi35xSyCrhpmIicB5MaiQiCcG2jME8/kRvrG+aP0bHtAQCvfJ0rJvNERHLj6CuR6//FruFMDbm5GcOi4KtTI/e0AZ/v5KZhInIOTGokYr4uqeHle+TuAlpoMX1o7abhhZsO4dwlbhomIvkxqZGI2Wamhn9Wcn9P9A9Ht7a+MFRx0zAROQeOvhK5/jIyztSQJ1ApFXj9ke4AgC+zTvGmYSKSHZMaiVw/U8Mj3eQp9OGtMO6O2puG52zYB6OZNw0TkXyY1EhEvHhPqYBCwaSGPMeMYVEI8PbCkdJLWLH9uNzhEJEHY1IjEZOFFbrJM7Vs7oU5I6MBAIt/PILCc5UyR0REnopJjUSsR7q5SZg80Z/6tENcZACqzTV4ZeN+CALvriGipscRWCJma4kE3lFDHkihUGD+n2LgpVJi26Gz+H5/idwhEZEHYlIjEetGYW4SJk/VsXULJN7TEQDw2je5qKgyyRwREXkaJjUSMbNEAhGeu6cjOgQ0xxlDNf69+bDc4RCRh+EILBHrRmEuP5En02lUeP2R2oKXn2SewL5T5TJHRESehEmNRCxcfiICAMR3bo2HeoWgRgBmb9jHgpdE1GSY1EhErNDN009EeOmBaPjo1NhXVI5PM0/IHQ4ReQiOwBIRTz9xpoYIbXx0+NewKADAos2HcfriFZkjIiJPwKRGIuLpJ+6pIQIAPHFHGPqGtcSlajNe/op31xCR4zGpkQhPPxHZUioVWDCqJzQqBX48WIpvfy+WOyQicnMcgSVirdKt4UwNkahLkA+eH9wJADB3Yy4uXDbKHBERuTMmNRKxLj+x9hORrefu6YQuQS1w7rIRr393QO5wiMiNMamRiHWjMGs/EdnyUiuxYFRPKBTA+j1FSD98Vu6QiMhNcQSWiHikmzM1RHX0DfPHxLgOAIDZ6/fhcrVZ3oCIyC0xqZGIRVx+4p+UqD4vDu2Kdi2boejiFZZQICKH4AgsEW4UJro5b60abz7aAwDwYUY+sgsvyBwREbkbJjUS4Y3CRLc2qEtrPNqnHQQBmLluH4zmGrlDIiI3whFYIqz9RNQwLz/QDQHeXjh0pgJLtx2VOxwiciNMaiRiYpkEogbx9/bCqw91BwC8/9NR5J5mJW8ikgaTGomINwpzTw3RLT3Ysy2GdQ+GuUbA9C9/5zIUEUmCSY1ExNpPPP1EdEsKhQLz/xSDVt5eyCs24P2tXIYiotvHEVgi1tNPnKkhapjAFlq8/nAMAGDJ1qPYX8RlKCK6PUxqJMKNwkT2G9mzLUb2bAtLjYB//ncvqs0WuUMiIhfGpEYiPNJN1DivPxyDwBa1p6EW/3hE7nCIyIVxBJaIWPuJMzVEdmnl7YX5j9Reyrds2zHsPXlR3oCIyGUxqZGImWUSiBptWEwwHu4dghoB+OeXe1Fl4jIUEdmvUSPw0qVLERERAZ1OB71ej+3bt9+0fXp6OvR6PXQ6HSIjI7F8+fI6bdatW4du3bpBq9WiW7du2LBhg83P586dC4VCYfMJDg5uTPgOwY3CRLdn7oPd0dpHi6Oll/BuGmtDEZH97E5q1q5di6lTp2LOnDnIzs5GfHw8hg8fjsLCwnrb5+fnY8SIEYiPj0d2djZmz56NKVOmYN26dWKbzMxMjBkzBuPHj8fevXsxfvx4jB49Gjt37rT5Xd27d0dxcbH42bdvn73hO4z1nhrWfiJqHH9vL7z5p9plqA+2H8fO4+dkjoiIXI3dSc0777yDp59+GpMmTUJ0dDRSUlIQGhqKZcuW1dt++fLlCAsLQ0pKCqKjozFp0iQ89dRTWLRokdgmJSUF999/P2bNmoWoqCjMmjUL9913H1JSUmx+l1qtRnBwsPhp3bq1veE7DJefiG7f/d2CMDq2PQQBSPrvXpRfMckdEhG5ELtGYKPRiKysLCQkJNg8T0hIQEZGRr3fyczMrNN+6NCh2L17N0wm003b/PF3HjlyBCEhIYiIiMDYsWNx/Pjxm8ZbXV0Ng8Fg83EUcaMwZ2qIbssrD3ZHWKvmKLp4Ba9+vV/ucIjIhdiV1JSVlcFisSAoKMjmeVBQEEpKSur9TklJSb3tzWYzysrKbtrm+t/Zv39/fPLJJ9i0aRNWrFiBkpISDBw4EOfO3XiKOjk5GX5+fuInNDTUnu7aRTzSzZkaotvSQqvGu2N6Q6VU4Kuc0/g6p0jukIjIRTRqBFYobGcjBEGo8+xW7f/4/Fa/c/jw4Rg1ahR69OiBIUOG4LvvvgMAfPzxxzd876xZs1BeXi5+Tp48eYueNR4v3yOSjj7cH5MHdwIAvPTVfhRdvCJzRETkCuxKagIDA6FSqerMypSWltaZabEKDg6ut71arUZAQMBN29zodwKAt7c3evTogSNHbnxZl1arha+vr83HUUw8/UQkqcn3dkLv0JaoqDLjn//NQc3V/+FARHQjdiU1Xl5e0Ov1SEtLs3melpaGgQMH1vuduLi4Ou03b96M2NhYaDSam7a50e8EavfL5OXloW3btvZ0wWHMvFGYSFIalRLvjumN5l4q7Dh+Hiu233wPHRGR3SNwUlISVq5cidWrVyMvLw/Tpk1DYWEhEhMTAdQu+UyYMEFsn5iYiIKCAiQlJSEvLw+rV6/GqlWrMH36dLHNCy+8gM2bN+Ott97CwYMH8dZbb2HLli2YOnWq2Gb69OlIT09Hfn4+du7cicceewwGgwETJ068je5Lh8tPRNKLCPTGKw90AwAs2nwIuadZ9JKIbszupGbMmDFISUnBvHnz0Lt3b/z8889ITU1FeHg4AKC4uNjmzpqIiAikpqZi27Zt6N27N15//XUsXrwYo0aNEtsMHDgQa9aswYcffoiePXvio48+wtq1a9G/f3+xzalTpzBu3Dh07doVjz76KLy8vLBjxw7xvXIzXT39xKSGSFpj+oXi/m5BMFkETPkiG5VGs9whEZGTUgjWXbsewGAwwM/PD+Xl5ZLvr3nw/37BvqJyfPhkPwyOaiPp7ybydOcuVWPE4u04Y6jG4/r2WPh4L7lDIqIm1NDxmxtAJHLt8j3O1BBJLaCFFilj+kCpAL7MOoUN2afkDomInBCTGomw9hORY8V1DMCU+zoDAOZs2I/jZy/JHBERORsmNRKxztRoePqJyGH+cW9nDIhshUqjBZM/z2Y1byKywRFYItYyCVx+InIclVKB98b2QStvLxwoNuDN1Dy5QyIiJ8KkRiJilW6WSSByqCBfHf49unaj8CeZBfhhf7HMERGRs+AILBFuFCZqOoO7tsGzd0cCAP71v99x8nylzBERkTNgUiMR60ZhVukmahrTh3ZFn7CWMFSZ8ffPsri/hoiY1EiFZRKImpZGpcT7f+6LVt5e2F9kwMtf7YcHXbtFRPXgCCwRM8skEDW5di2b4f/GXbu/Zs1vJ+UOiYhkxKRGItbTT7ynhqhp3dkpEP9M6AoAePXrXOw9eVHegIhINkxqJCAIAkzW5SeefiJqcn8f1BH3dwuC0VKD5z7bg/OXjXKHREQy4AgsgZrrlvG5/ETU9JRKBf49uhc6BDRH0cUreGFNNiw13F9D5GmY1EjAdPXkE8DlJyK5+Oo0WD5eD51Gie1HyrBo8yG5QyKiJsakRgLm6/4XIcskEMknKtgXb43qCQBYtu0Yvs4pkjkiImpKHIElYLFcS2p4+R6RvB7u3Q6JgzoCqL2YjxuHiTwHkxoJmGquW35iUkMkuxeHdsV9UW1Qba7BM5/sRkl5ldwhEVETYFIjAfHiPaUCCgWTGiK5qZQKpIztjS5BLVBaUY2/fbqbNw4TeQAmNRJghW4i5+Oj02DlhH7wb67B76fK8a///c4bh4ncHJMaCYgVurlJmMiphAU0x9In9FArFdi49zTe/+mo3CERkQNxFJYAbxMmcl5xHQPw2sPdAQD/TjuMDdmnZI6IiByFSY0EWPeJyLk90T8cz94dCaD2RFTG0TKZIyIiR2BSIwEzSyQQOb0Zw6LwQM+2MFkEPPtpFg6VVMgdEhFJjKOwBKw3CnP5ich5KZUKLHq8F+7o0AoV1WY8+eEuHvUmcjNMaiRg4fITkUvQaVT4YIIeHVt7o7i8Ck9+uAsVVSa5wyIiiTCpkYBYoZunn4icXsvmXvjor3cgsIUWB0sq8MwnvMOGyF1wFJYAZ2qIXEtoq+b48Ml+aKFVY8fx85j8+R6bwrRE5JqY1EjAxCPdRC6nR3s/rJwYC61aiS15pXjxy72oqeHlfESujEmNBHj6icg1DYgMwLK/9IVaqcBXOafx6sZc3jpM5MI4CkvAYp2p4fITkcu5NyoI/x7dCwoF8OmOAizafEjukIiokZjUSODaRmEmNUSu6OHe7fD6wzEAgCVbjyFly2GZIyKixmBSIwFrmQTWfiJyXX8ZEI7ZI6IAAClbjuDdNCY2RK6Go7AErHtqWKWbyLX97e6OYmLz3o9MbIhcDZMaCVyr/cQ/J5GrY2JD5Lo4CkvAbLEuP3Gmhsgd/O3ujpgzIhpAbWLz9g8HeSqKyAUwqZGAdaaGy09E7uOZuyPx0sjaxGbptmN46av94kWbROScmNRIwLqnhhuFidzLpPhIvPmnHlAogM92FuKFNdkwmnnzMJGz4igsARPvqSFyW3/uH4b/G9cHGpUC3/5ejGc+2Y1Ko1nusIioHkxqJGDhPTVEbu2BniFYObEfmmlUSD98Fk+s3Ilzl6rlDouI/oBJjQRMPP1E5PYGdWmNz57pD79mGmQXXsQjS3/F0dIKucMioutwFJaA9fQTZ2qI3FvfMH+sf24gwlo1x8nzV/CnpRn49WiZ3GER0VVMaiRgEWdqmNQQubuOrVtgw3MDoQ/3R0WVGRNX78La3wrlDouIwKRGEtdqP/HPSeQJAlpo8dmk/nioVwjMNQJmrNuHV77ez5NRRDLjKCwBa5VuDWdqiDyGTqPCe2N7Y+qQzgCATzILMG7FDpwxVMkcGZHnYlIjAZN4+R7/nESeRKFQYOqQLlg5IRY+OjWyCi5g5OJfsPP4OblDI/JIHIUlwI3CRJ5tSLcgfDP5LnQN8kHZpWr8eeVOvP/TEd5ATNTEmNRIwFomgbWfiDxXh0BvbHh+IB7uHQJLjYBFmw9j3IodOH3xityhEXkMJjUSsJZJ4PITkWdr7qVGypjeWPR4L3h7qbAr/zyGpfyMb38/LXdoRB6Bo7AEzDWs0k1EtRQKBR7Tt8d3U+LRK7QlDFVmTP48G89/tgdnK3gLMZEjMamRgHWmhjcKE5FVh0Bv/C8xDv+4txNUSgW+21eMIe+k48vdJyEI3GtD5AgchSVg5uV7RFQPjUqJfyZ0xdfP34nuIb4ov2LCi//7HeNX7WKJBSIHYFIjARNPPxHRTcS088PXz9+JmcOjoFUr8cvRMgxL2Y7XvslFeaVJ7vCI3AaTGglYxHtqmNQQUf3UKiUSB3XE5ml34/5uQTDXCPjw1xO4Z9FWfJxxAtVmi9whErk8JjUSsO6p0bBMAhHdQniAN1ZMiMWnT9+Bzm1a4EKlCa9uzMXghdvw+c5Cllogug0chSVgunr6iXtqiKih4ju3xvcvxOP1R2IQ5KvF6fIqzN6wD/f+exs+3VGASqNZ7hCJXA6TGgmIVbq5p4aI7KBWKTF+QDjSXxyMVx/shsAWWpy6cAUvf7Ufcck/4a0fDqK4nJf3ETWUWu4A3IGJR7qJ6DboNCr89c4IjO0XhjW/FeLDX0+g8Hwllm07hg9+Po5BXVrjMX173BfdBlq1Su5wiZxWo0bhpUuXIiIiAjqdDnq9Htu3b79p+/T0dOj1euh0OkRGRmL58uV12qxbtw7dunWDVqtFt27dsGHDhtt+b1Nh7ScikkIzr9rkZuv0e/DBeD36R7SCpUbATwdL8dxne3DHGz9i5rrf8WPeGVSZuLGY6I/sTmrWrl2LqVOnYs6cOcjOzkZ8fDyGDx+OwsLCetvn5+djxIgRiI+PR3Z2NmbPno0pU6Zg3bp1YpvMzEyMGTMG48ePx969ezF+/HiMHj0aO3fubPR7m5K4/MSZGiKSgEqpQEL3YKx9Ng4//nMQnrunI9r66VB+xYQ1v53E0x/vRp95aXjmk91Y/Us+9heVs3gmEQCFYOfVlv3790ffvn2xbNky8Vl0dDQeeeQRJCcn12k/Y8YMbNy4EXl5eeKzxMRE7N27F5mZmQCAMWPGwGAw4PvvvxfbDBs2DP7+/vjiiy8a9d76GAwG+Pn5oby8HL6+vvZ0+6bi3/4JJ89fwfrnBqJvmL9kv5eIyMpSI2DH8XPYlFuCLQfO4HR5lc3PfbRq9Gjvhy5BPogK9kHnoBZo17I5Alt4Qc2TmeTiGjp+27Wnxmg0IisrCzNnzrR5npCQgIyMjHq/k5mZiYSEBJtnQ4cOxapVq2AymaDRaJCZmYlp06bVaZOSktLo9wJAdXU1qquv1VoxGAy37GNjiEe6OVNDRA6iUipwZ6dA3NkpEK891B0Hig3YdugsfjtxHrtPXEBFtRkZx84h49g5m+8pFUAbHx38mmnQzEsFb60KWrUKXCwnR3lndG/4NdfI8m67kpqysjJYLBYEBQXZPA8KCkJJSUm93ykpKam3vdlsRllZGdq2bXvDNtbf2Zj3AkBycjJee+21Bvevscy8fI+ImpBCoUD3ED90D/EDUDuLk1dswIFiAw6XVODQmQocP3sZZwxVMNcIKDFUocRQdYvfSiSNaosFgAskNVYKhe3gLQhCnWe3av/H5w35nfa+d9asWUhKShL/2WAwIDQ09IbtG+upOyNgqDIh0MdL8t9NRHQrKqUCMe38ENPOz+a5pUbAuUvVKDFUwXDFjEqjGVdMFlSbGn7BnwDu1SH7+GjlSWgAO5OawMBAqFSqOrMjpaWldWZRrIKDg+ttr1arERAQcNM21t/ZmPcCgFarhVarbVjnbsPf7+no8HcQEdlLpVSgja8ObXx1codC1CTs2gTi5eUFvV6PtLQ0m+dpaWkYOHBgvd+Ji4ur037z5s2IjY2FRqO5aRvr72zMe4mIiMjDCHZas2aNoNFohFWrVgkHDhwQpk6dKnh7ewsnTpwQBEEQZs6cKYwfP15sf/z4caF58+bCtGnThAMHDgirVq0SNBqN8L///U9s8+uvvwoqlUpYsGCBkJeXJyxYsEBQq9XCjh07GvzehigvLxcACOXl5fZ2m4iIiGTS0PHb7qRGEARhyZIlQnh4uODl5SX07dtXSE9PF382ceJEYdCgQTbtt23bJvTp00fw8vISOnToICxbtqzO7/zyyy+Frl27ChqNRoiKihLWrVtn13sbgkkNERGR62no+G33PTWuzFH31BAREZHjNHT85sUqRERE5BaY1BAREZFbYFJDREREboFJDREREbkFJjVERETkFpjUEBERkVtgUkNERERugUkNERERuQUmNUREROQW7KrS7eqslycbDAaZIyEiIqKGso7btyqC4FFJTUVFBQAgNDRU5kiIiIjIXhUVFfDz87vhzz2q9lNNTQ1Onz4NHx8fKBQKyX6vwWBAaGgoTp486RE1pdhf9+dpfWZ/3Rv76/oEQUBFRQVCQkKgVN5454xHzdQolUq0b9/eYb/f19fXbf4L1BDsr/vztD6zv+6N/XVtN5uhseJGYSIiInILTGqIiIjILTCpkYBWq8Wrr74KrVYrdyhNgv11f57WZ/bXvbG/nsOjNgoTERGR++JMDREREbkFJjVERETkFpjUEBERkVtgUkNERERugUmNBJYuXYqIiAjodDro9Xps375d7pBuKTk5Gf369YOPjw/atGmDRx55BIcOHbJpIwgC5s6di5CQEDRr1gz33HMPcnNzbdpUV1fjH//4BwIDA+Ht7Y2HHnoIp06dsmlz4cIFjB8/Hn5+fvDz88P48eNx8eJFR3fxhpKTk6FQKDB16lTxmTv2taioCH/5y18QEBCA5s2bo3fv3sjKyhJ/7k59NpvNeOmllxAREYFmzZohMjIS8+bNQ01NjdjGlfv7888/48EHH0RISAgUCgW++uorm583Zd8KCwvx4IMPwtvbG4GBgZgyZQqMRmOT9ddkMmHGjBno0aMHvL29ERISggkTJuD06dNu2d8/evbZZ6FQKJCSkmLz3JX661AC3ZY1a9YIGo1GWLFihXDgwAHhhRdeELy9vYWCggK5Q7upoUOHCh9++KGwf/9+IScnRxg5cqQQFhYmXLp0SWyzYMECwcfHR1i3bp2wb98+YcyYMULbtm0Fg8EgtklMTBTatWsnpKWlCXv27BEGDx4s9OrVSzCbzWKbYcOGCTExMUJGRoaQkZEhxMTECA888ECT9tdq165dQocOHYSePXsKL7zwgvjc3fp6/vx5ITw8XHjyySeFnTt3Cvn5+cKWLVuEo0ePim3cqc/z588XAgIChG+//VbIz88XvvzyS6FFixZCSkqKW/Q3NTVVmDNnjrBu3ToBgLBhwwabnzdV38xmsxATEyMMHjxY2LNnj5CWliaEhIQIkydPbrL+Xrx4URgyZIiwdu1a4eDBg0JmZqbQv39/Qa/X2/wOd+nv9TZs2CD06tVLCAkJEd59912X7a8jMam5TXfccYeQmJho8ywqKkqYOXOmTBE1TmlpqQBASE9PFwRBEGpqaoTg4GBhwYIFYpuqqirBz89PWL58uSAItf9y0Wg0wpo1a8Q2RUVFglKpFH744QdBEAThwIEDAgBhx44dYpvMzEwBgHDw4MGm6JqooqJC6Ny5s5CWliYMGjRITGrcsa8zZswQ7rrrrhv+3N36PHLkSOGpp56yefboo48Kf/nLXwRBcK/+/nHQa8q+paamCkqlUigqKhLbfPHFF4JWqxXKy8ubpL/12bVrlwBA/B+T7tjfU6dOCe3atRP2798vhIeH2yQ1rtxfqXH56TYYjUZkZWUhISHB5nlCQgIyMjJkiqpxysvLAQCtWrUCAOTn56OkpMSmb1qtFoMGDRL7lpWVBZPJZNMmJCQEMTExYpvMzEz4+fmhf//+YpsBAwbAz8+vyf9Gzz//PEaOHIkhQ4bYPHfHvm7cuBGxsbF4/PHH0aZNG/Tp0wcrVqwQf+5ufb7rrrvw448/4vDhwwCAvXv34pdffsGIESMAuF9/r9eUfcvMzERMTAxCQkLENkOHDkV1dbXN0mZTKy8vh0KhQMuWLQG4X39ramowfvx4vPjii+jevXudn7tbf2+HRxW0lFpZWRksFguCgoJsngcFBaGkpESmqOwnCAKSkpJw1113ISYmBgDE+OvrW0FBgdjGy8sL/v7+ddpYv19SUoI2bdrUeWebNm2a9G+0Zs0a7NmzB7/99ludn7lbXwHg+PHjWLZsGZKSkjB79mzs2rULU6ZMgVarxYQJE9yuzzNmzEB5eTmioqKgUqlgsVjwxhtvYNy4cWKc1tiv56r9vV5T9q2kpKTOe/z9/eHl5SVb/6uqqjBz5kz8+c9/Fos3ult/33rrLajVakyZMqXen7tbf28HkxoJKBQKm38WBKHOM2c2efJk/P777/jll1/q/Kwxfftjm/raN+Xf6OTJk3jhhRewefNm6HS6G7Zzh75a1dTUIDY2Fm+++SYAoE+fPsjNzcWyZcswYcIEsZ279Hnt2rX4z3/+g88//xzdu3dHTk4Opk6dipCQEEycOPGGsbpqf+vTVH1zpv6bTCaMHTsWNTU1WLp06S3bu2J/s7Ky8N5772HPnj12v9MV+3u7uPx0GwIDA6FSqepksKWlpXWyXWf1j3/8Axs3bsTWrVvRvn178XlwcDAA3LRvwcHBMBqNuHDhwk3bnDlzps57z54922R/o6ysLJSWlkKv10OtVkOtViM9PR2LFy+GWq0W43CHvlq1bdsW3bp1s3kWHR2NwsJCAO71ny8AvPjii5g5cybGjh2LHj16YPz48Zg2bRqSk5PFOAH36e/1mrJvwcHBdd5z4cIFmEymJu+/yWTC6NGjkZ+fj7S0NHGWxhqnu/R3+/btKC0tRVhYmPjvr4KCAvzzn/9Ehw4dxDjdpb+3i0nNbfDy8oJer0daWprN87S0NAwcOFCmqBpGEARMnjwZ69evx08//YSIiAibn0dERCA4ONimb0ajEenp6WLf9Ho9NBqNTZvi4mLs379fbBMXF4fy8nLs2rVLbLNz506Ul5c32d/ovvvuw759+5CTkyN+YmNj8cQTTyAnJweRkZFu01erO++8s84R/cOHDyM8PByAe/3nCwCVlZVQKm3/daZSqcQj3e7W3+s1Zd/i4uKwf/9+FBcXi202b94MrVYLvV7v0H5ez5rQHDlyBFu2bEFAQIDNz92pv+PHj8fvv/9u8++vkJAQvPjii9i0aRMA9+rvbWuyLcluynqke9WqVcKBAweEqVOnCt7e3sKJEyfkDu2m/v73vwt+fn7Ctm3bhOLiYvFTWVkptlmwYIHg5+cnrF+/Xti3b58wbty4eo+Jtm/fXtiyZYuwZ88e4d577633GGHPnj2FzMxMITMzU+jRo4dsR7qtrj/9JAju19ddu3YJarVaeOONN4QjR44In332mdC8eXPhP//5j9jGnfo8ceJEoV27duKR7vXr1wuBgYHCv/71L7fob0VFhZCdnS1kZ2cLAIR33nlHyM7OFk/7NFXfrEd+77vvPmHPnj3Cli1bhPbt20t+5Pdm/TWZTMJDDz0ktG/fXsjJybH591d1dbXb9bc+fzz95Gr9dSQmNRJYsmSJEB4eLnh5eQl9+/YVj0U7MwD1fj788EOxTU1NjfDqq68KwcHBglarFe6++25h3759Nr/nypUrwuTJk4VWrVoJzZo1Ex544AGhsLDQps25c+eEJ554QvDx8RF8fHyEJ554Qrhw4UIT9PLG/pjUuGNfv/nmGyEmJkbQarVCVFSU8MEHH9j83J36bDAYhBdeeEEICwsTdDqdEBkZKcyZM8dmkHPl/m7durXe/3+dOHFik/etoKBAGDlypNCsWTOhVatWwuTJk4Wqqqom629+fv4N//21detWt+tvfepLalypv46kEARBaIoZISIiIiJH4p4aIiIicgtMaoiIiMgtMKkhIiIit8CkhoiIiNwCkxoiIiJyC0xqiIiIyC0wqSEiIiK3wKSGiIiI3AKTGiIiInILTGqIiIjILTCpISIiIrfApIaIiIjcwv8HrgtkVrA6q/oAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 53min 33s, sys: 3min 18s, total: 56min 52s\n", - "Wall time: 3min 40s\n" - ] - } - ], - "source": [ - "%%time\n", - "\n", - "with model:\n", - " schedule = optax.warmup_cosine_decay_schedule(\n", - " init_value=0.0,\n", - " peak_value=0.025,\n", - " warmup_steps=200,\n", - " decay_steps=10_000,\n", - " end_value=1e-5,\n", - " )\n", - "\n", - " n_steps = 15_000\n", - " plt.plot(schedule(np.arange(n_steps)))\n", - " plt.show()\n", - "\n", - " optimizer = optax.adam(learning_rate=schedule)\n", - "\n", - " params, history = svgp.fit(X_data, y_data, optimizer, n_steps=n_steps)\n", - "\n", - "var_names = model.initial_point().keys()\n", - "result = dict(zip(var_names, params))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "022fcde7-852b-4319-bc1a-7b8c38a21ade", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c19ee5fd-7b3c-44bd-8f69-94a59db98638", - "metadata": {}, - "outputs": [], - "source": [ - "str_value_transforms = {\n", - " value.name: (rv.name, model.rvs_to_transforms[rv]) for rv, value in model.rvs_to_values.items()\n", - "}\n", - "var_names = model.initial_point().keys()\n", - "results_dict = {name: np.asarray(param) for name, param in zip(var_names, params)}\n", - "results = {}\n", - "for name_tr, (name, transform) in str_value_transforms.items():\n", - " if transform is None:\n", - " results[name] = results_dict[name_tr]\n", - " else:\n", - " results[name] = transform.backward(pt.as_tensor(results_dict[name_tr])).eval()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "e4284ceb-75cb-43c2-89e9-e74ecc22080f", - "metadata": {}, - "outputs": [], - "source": [ - "sigma = results[\"sigma\"] # or set sigma = None to not have likelihood noise\n", - "\n", - "with model:\n", - " f_predict = svgp.compile_pred_func(sigma=sigma, diag=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1df3dcf8-9799-4c9d-adf0-a1649cf26fa3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3jk1Pn2/zmSpno8xb2X7b33vuxSls7Se29LD6SQkB6SL0lI+RIgkBBIQiAQElJI6L2XpS1te/eu+9geT5V0fn/IHnvsGc3mhSS/N69vrr2wZx5Ltx4dHd06Ovd5hJRSMoIRjGAEIxjBCEbwXwTlP01gBCMYwQhGMIIRjOCzxojAGcEIRjCCEYxgBP91GBE4IxjBCEYwghGM4L8OIwJnBCMYwQhGMIIR/NdhROCMYAQjGMEIRjCC/zqMCJwRjGAEIxjBCEbwX4cRgTOCEYxgBCMYwQj+6zAicEYwghGMYAQjGMF/HbT/NIH/BEzTpKmpicLCQoQQ/2k6IxjBCEYwghGM4AAgpaSnp4eqqioUxX6M5v9JgdPU1ERtbe1/msYIRjCCEYxgBCP4P8Du3bupqamxjfl/UuAUFhYCVoL8fv9/mM0IRjCCEYxgBCM4EHR3d1NbW5u+j9vh/0mB0/9ayu/3jwicEYxgBCMYwQj+L8OBTC8ZmWQ8ghGMYAQjGMEI/uswInBGMIIRjGAEIxjBfx1GBM4IRjCCEYxgBCP4r8OIwBnBCEYwghGMYAT/dRgROCMYwQhGMIIRjOC/DiMCZwQjGMEIRjCCEfzXYUTgjGAEIxjBCEYwgv86jAicEYxgBCMYwQhG8F+H/ycX+vtXYU+0mU09u1CEyvTgGELO4YsIhpNdfNLzCYY0GV3QSIWnYlhMwojzSc8G4kaccncl9d7RwxY1MqTBxp6P6EqFCTiCjC+chCrUjBgpJZsjO9gba8GjupgenIBHdQ/b3/aedjZ07kUVCvNKGyh1+4bFtPX28trOPejSZFpFOaOKi4bFxBIpXtuwg2g8RV1FkCmjK4fz1k3eeWs7HW0RiooLmDl3FKqWqbOllGx8bzd7trfgKXAxa/E4PAWuYfvbs6ONjR/sQVEE0+eNoqhk+MqWHZ29vPP+LnTdZMK4Cupri7Pz/ngnkViCuvIQ0xqz8DZNXtuxm5aeCCW+AhY01OJQh+f7veb9bO3soMDhZEldPT6nc9j+tnd18E7rPlQhWFBZR7k3S75jvby6bxcp02RaSQVjgll46yle2LODnlSCBn+I2WVVWXm/um8X+3sjlHgKWFxdh0MZzvv99v1s6WrDqzlYWtWIzzE83zsj7bzXuQdVKMwtrqfMk619R3g3vJmUqTOusJb6gmztO8GGro+JGlHK3WWM8w1v36Y0+ah7Ix3JTvyOQqb4J6Ipmd2VlJJNPbvZFW3GrTqZFRpPgTa8fe/q7eC9jj0oQjCnuJ7yLLw74lFe3reTlGkwpaiccaHSYTFxPcWLu3fSlYhTHwgyp6I6ezvZu5v9kQjFHi+LautwDmknABta97Opox2v5mBxTT1+1/B87+oJ83bLXoQQzC+vpaJgePvuTER5ef9OkobO5KIKxgez835p/3a6knFqfUHmltZm5f16826aerspdntZXNmQlfcHrc1s7GjDo2ksqWnIynt3Vxfr9zchgHnVNVT6svCOxXh5zy6ShsGkklImlGTjrfPSnp2E4zHq/EHmVg7PtyklrzXtpqmnmyKPhyU12Xl/2NrMJ21teBwOltTW4XcNbyd7urpYv6cJIQRzaqqp8g/nHY7GeXXbTpKGwYTyUsZXDOedSOm8smUnXbE4NaEAs+qrUZQhvE3JW9v3sK+zm2CBh4Vj63Bqw2/Hn+xpYXNTGy6HxoLxdfi9w3nva+vm3c17EQJmjK2monh4++6OxHnr/Z0kEjpjGkoZ21g2LCaZ1Fn/9g66emJUlAeYNqU2K+/3P9jN/uYuAoUeZs9qwOkcznvzjha27GjF5dSYM60ev284738H/qUC54UXXuAHP/gB69evZ9++fTz88MMce+yx6e+llHzzm9/kzjvvpLOzk/nz53PrrbcyefJk2+3+8Y9/5Ktf/Spbt25l9OjR3HjjjRx33HH/ykOxRWu8k5s3/Y73wpvTnykorC6fy6VjTsCtOkkYCX6z83e80vYqJmY6brJ/EheMOo8iZwhTmjyx/y882fw3kmYiHVPpruH0+ouoLxgNwFsdr/Hg7nvp1rvSMX4twEm1ZzCnaAEAm3p28LPNv2V3bH86xqU4Ob7mEI6vORRFKOyPdnP9+r/wauv2dIwqFI6pm8pXpx+OR3MQS6X45pPP8vAHH2FImY5bWFfLTUccSpW/ECkl9zzyBvf87Q1iiVQ6prGqiK9ecChTRlcC8PyTH3L7jx+noy2SjgkVFXDJNYey8tApAGx8fzc//tKD7Nw0iLfHwYkXreTUy1ahKArtLd3c/NU/8varWwfyrQgOOnIGl3/5KNxeJ4lEip/+/Gkee3IDhjnAe+a0Oq7/3OGUl/mRUnL3429y12OZvBvKQ3z9rEOYPqoKgMc+2sSNjz9HS6Q3HVNc4OFLBy/n6KkTAdjQ0sznn3qMje1t6RiPpnHRrLlcOW8hihA0RyNc9+I/eGHvjgHeQnDsqEl8Z9HBFDicxHWdb77+FH/Y/AG6HGgn8ytquXnp4dT4Akgp+fn7b3DLe6/Sm0qmY0YFivj+0sOYW27VZ3l0+ya+/urTNEcH8l3s9nDD/JWsHWtdYx+07+e6V/7OJ52t6Ri3qnHR5HlcPX0pihC0xnv4ytt/4aWWLQO8ERxeM4WvTz+SAoeLpJHiti0P89j+1zEG8Z4aGMUXJpxOhacIKSV/3/cEf256hJgRT8dUuMu5sPEsJvjHAfBWxzvcs+M+OlPhdEyh5uO0uhNZVroIgK2Rvfzg4/vY2ts00E4UByfUruDMhsNQhUJbPMIN7/yZF5ozea+pnszXZxyJz+EmYeh8+81n+P3m99DNAd5zy2q4eckR1BUGkVJy13vr+cmbrxAZlO+GQIibVh7C/Cqrrt2T27bwteefZn9kIN9Fbg9fWryMEydZ7fvj9laue+ZRPmxrGeCtapw/bTbXzluMqii0xXr5wkuP8eyerfS3XAXB4Y3j+e6iQ/E7XSQMne++/TT3bX43o53MLq3m5oVHUV8Ystr3xjf56YYX6UkN9Cf1vhDfm384C8rrAXh69xZueO0J9kV70jEhl4cvzV7OyWOnA/BJeyvXPfsoHwzhfe7UWXx+3hJURaE9FuWLTz/OM9u3DfAWgjWjx/Ldgw7B73KRNAy+99Lz/O6D90gNyvfMikpuPngNjUGL9z0b3uHHb7xMd3KAd50/yP+sOIRFNXUAPLtzG1954UmaIgO8gy43X1ywjFMnTQNgU3sb1z31GBtamgfxVjln+iyuW7gETVHoiMb48qNP8PSWAd4COHT8WL572Gr8bjdJ3eAHT77A7996n5QxwHt6TQX/c+xhNJZYvO977T1uefIVuuMDvGtCAb5x3CoWjbHy/dInO/jWn56iqXOAt9/j4uo1SzhpocV76/52vnrv43y4e4C3Q1M5dekMrjpqCZqqEI7EuPGeJ3n+7S0DvAWsmDmGG849BH+BG103uO03L/DwY++S0o30tiaNreCGKw+nrtp6UP3z397mrnteIBIZ4F1REeDaKw9lzuxGAN5cv50f/fRx9jcP3HcKfW7OP2cZxxw1E4Cde9r5zi2P8vGWgf7boamsXTODS89YhqYNF5//SggpB921PmM8+uijvPzyy8yaNYvjjz9+mMC56aabuPHGG7nnnnsYN24c3/nOd3jhhRfYuHFjzjoTr776KkuXLuXb3/42xx13HA8//DBf+9rXeOmll5g/f/4B8eru7iYQCNDV1fWpSzV0p3q5/O3v057ozhAuYHVK04Pj+NaUi/jhxh/zSc9GJHJIjELIGeLbU77OU81/46nmvw3bh0CgCQfXjv8m++L7+OX2n+Xkc0Hj5ZS4avji+z9AN3VMhp/e46oP5uiqQ1n7zJ00x7ozhEs/73ml9fxy8Rmc/+DDvLprN+aQGFUIygt9/OWc07n/7+u5529vDNuPIgQOTeWur51K85Y2vv2lP+Tkff2319LYWMLVa/+XVFLHNIfzPv6C5Zy8bhVXnHwbLfu7MI0h+VYEU2Y3cOPPz+HL3/oTb769g6HNW1UERUU+fnnL2dz3/Lv88tHXs/LWVIW7P38yu3u7ufKhR7Jk0cIPjj2MidVlHPPAvSQMY1ieAM6fMZsr5y/kiL/cw95IlnwLwdyyan532Mlc9MzDPL93e9Z8l3gK+Mcx5/Cbj97mJ++8kp23UPjjkaexPxrhoif/DJCV+4+XH8600nKO/seviRt6Vt7nTpjNtTOXcsJzd7I3Gs4QLtDXvotquGfx2Xzro3t4vf2jrO076PTx8znX8Vzr8zy05y/D9iMQqELha5O+SFeqm5s35W7fF406h1EFY7ls/Y9IGMms7fuYqiWc23gkJz5/J7t7O7Lme1qwmnuWnMNlz/+Vp3dvGbYdVQhCLi//OPoc/vDRB/zg9ZeG7UcBVEXhweNOJRyLcf7fHgay5/t/DjqEedU1HPXQb4npqWGcAM6YNJ3rFy3n6L/9hh3dndl5F1fw4OGnctXLf+WJ3Zuy8g66PPzj8PP50/YNfP/dZ7PwFihC8PvVZ9CdTHLuU3/Iyft7Cw9lUXkDR/7xN0RTw3kL4JSJ0/jqopUc88C9bA8P560KweTSMh48/hSuffJR/rFl07B9qUIQdLt55JQz+evmT/juq88P5y0s3vcfcxJxXefsv/8RKYe2OAvfWbaaZTUNHPX7e+lNJbPyPnHSFL6x7CDW/uZ+trUPbyeqEEwsK+WBM07my39+gn98sDEr70K3iz9fcgaPb9jMTf8YzlsIi/vd55+Arptc9Is/5eT9lWNXsmxCIyf/4HdEE8mMh7N+3kfOm8gNJ67i3O/cz/am9mExiiIYW1PCXV85lZtufZwnX/yYoc1NVQQFXhe/uvksXnppE7f+/OmsvIUQ3Pw/pyCl5LrrH7B4ZyF++aWrWLx4HOdd9xsi0cSw/lsIOGTpJL561eFZjvqfwz9z//6XCpyMHQmRIXCklFRVVXH11VfzxS9+EYBEIkF5eTk33XQTF198cdbtnHzyyXR3d/Poo4+mPzvssMMIhULcf//9B8TlsxQ4v9v5GPftfCxrR9uP8xsP4W/7/pTze4HgiMpDebH1L8NuEP1QUJjsn8HW6A66Bj3ZDkXQEcKvTWJ954fDBNfg/S0JHMMvN71my/uK+lX8+KnhwiXNSQgumDGLP92/PqsgAetiWzilgZbndtLa3J1zW0UlPibVF/H6Mx8PEy5p3kJw/LpVPPTrl5A59gdw+ucO4ZcPvpabtyI4fu0cfr3+vWGdw+CYBRPq+FB2sK+rJ2eWigu8TJ9QyZPbtmS9aYHVKV28YA4/3/CGbb6vnbmEH707/Eaa5iQE506czT0fvp3x1D4YqhAsqqxjR3cXe3q6cu6tyO1hYW01j+/aZMv7yllz+eWWl3K2S4Brpyzl93seyc0bwbE1S3i14wkMaeSMmVA4jrZkBy2J1qwxAD6tgDr3LF5ofS9n+wY4uvwIfr7xJRvWsG7sKn741nCh2A9VCM4cN4vfvft+xmhDBm8hmFtRTWskyo5wZ879BVwulo9q5JEtn+TMN8Dl8+Zz6/uv2vL+3KzF/PiDF2x5nz52Fg9sfYekmSPfQjCruJqOaJKtXe059+d3uFhdMY6/bP7YlveVMxbyszdfs+V99bxF/OQN+3yfNmUaD2zcQMLIzXt6WQVRPcWmjrac+/M5nKypH8vDG+15XzVzIT97efhDzmBcuXABtz2Tuz9RheDEWVP461sfE0/pOXlPriojlTDYvL8tq0gA8LocHD55HH9946OcfRPAuoPm88u/5OYEcNERC/j172zyrQiOWDWFZx79gEQiO28hBGPHlCOlZMvWlmEPjP1wux2sOGwy/3jmA1ved//wrKyvx/4Z/F8hcLZt28bo0aN5++23mTlzZjrumGOOIRgM8utf/zrrdurq6rjmmmu45ppr0p/9+Mc/5ic/+Qk7d+7M+jeJRIJEYmDorb8a6WchcM56/Ru0Jjpzfq+g0Ohz0au323bIIYcLU3bb3kikFOjYFxgzJbQl/LYdjYKgKVxL56CcDIUqBMXhUppb47YdRFmvE3NXMusIQD+0qIFvZ8yWN6ZE6+rNeQGBJTq85QF6unJvS1EEhRPKaY3EbC80Z4WbDrdpuz/TCbESe9oSiRHEVrioQuALOuhM2vAWggqvj5ZYxDbfPs1JJJm0Pb/Wl/kK0UlUl7Q9b6oQVBQpdKZ6c8YoCMYXa/SaHcNGeAajyKngUHts2/eBQEpojxfa5ltBIR4voy0eyxmlIAjIIvb3xG15e6WTWNTIm29h2udbIlEdwvbcqkIQCrhoj0dteZf7vbQmIra8PZpGwkjZ8pYSpJ7nlYEENaHl5V2keWmP2vAWgjJvAa3RqC1vl6YSl9lvthnI37xxSDXjtWM23qWigLaIPe9yZwEd3b22/YlLqKQS2UXZYE5KvkOT4DIV9BwPeWCNGpYpbjrCvTmFkhBQ4fTS1daLYdj0gwhk7wHkOw8kIIIOUroNb1XhhDUzueLclZ9qX/+MwPmPuaj277fe0ZWXl2d8Xl5env4u19/9s3/zve99j0AgkP5XW1v7KZhnIpzssf3exCRm9NqKG4CEGUMR9qfjQG4OplTyRgmh0JNM2sYYUtITGz60OxTRaHLYRLRh+7Np9GlIaSs2ABRFIdabW5SBNQkuEk3YdkYAvUkddQhvIxEjGQkPbGvQ6Uh1hTHiWQSKYi9uwBL3Ed0+36aU9KQSefMdSSVRlc/msrUTN2CN9EX0PPlG0qvHbG9aAAkznrd9HwhMxAHkG3pS9iLQRNKTTOTlHU2lPrN85zu3ApFXvJr0txN73jE9hZov3weoNfPzJj9vaeXbzMM7buioB1AlOh8E2IqbfvQk8vOOxIe/chmKhG7k530A+VYEtuKmf0O90UROcQOWeI30JsiTbvSUkbf/PhAoirAVNxYnSXs498PSvwL/cZv40FnxUsq8ZdD/2b+5/vrr6erqSv/bvXv3/znhISjK4pQaDFUoeNUClDypdivevBe/OIDTpQgTkXeUxyTgHO5+GAxVCPweV96L1lfgyismcBxAM1MEIs+FZpom3jyz8RVVwV/gHiZehsLncmIM6gCNRIwt/7iTzX+9lWTEGpFT+r5OdXWy51e3svc3dw4XOab1lGfLW0r8DpftWVGFIOB05813odOVwfvTIN++TCSFmtuWtyIEPs2Lmq99qx7MHK+n/hkoyLw3bnmg+Xa5826rwOn8zPKt5RFKEkmh0563IgQBR37eXs2Z8zVmGgd4X8vPG/yu/Lz9LndekevVHHkF1YFAAo4DEKZ+9wHw9rjyigC3Q83P+wDybUprUm4+FBa4sbt8FSEo9NnHADhdWl7xdiAwTYnTYc9bAKVFwx2j/0r8xwRORYVlHx068tLS0jJshGbo3/2zf+NyufD7/Rn/PiscVrnQVlAY0mR12UrbERyBYGnpKuyuAAWFGcHZhBzD7dmDUeIqYX7RNFtBJRCc3Dg7D2/J6TOm2160ihCsXTYNu2tfVQSLFo+jvDJge7GVVgRYfOhUFNW+SR550lxbMWsaJsccMcNWdFm8p2Z0tkYqgR6LkOxuZ/Nfb8PoDbNifCNlGOz51W2kOtsxeiOYQ17rlft8HD5mXF6xcMaEGbbfG1Jy+oQZefN9+oTptjccVQhW1jbS6A8hozH0jnDWuEA0xcEldba8pZSc3DjblrcpJUdXLcKwad8KgtVlS1FFbtOmgsJU/ySq3BW27TLgKGRl6UzbG7yJ5OSGuRmfGb1xUm0Dc8AMKTlj3EwMaaJ3dGFG40M3gyIEp02cltV2PDhmcU0dY4uKbe9fxW4vx4yZaJtvU0rOnDAz74hCP+9cUIXg1NEzcKk2+RaCheV1TAiW2vIOutysHTvJlrchJWdMnZ6X95lTZ+TlffKkqbiz2KUH855fWcOkkjLbm5ff5eL4iZPz8j59Zn7ep86ZbtufqEJw/JwpeJwOW96zGqqYVFNm+0Dk8zg5dt4k2wc0w5ScsHK67QiOKSXHHZqHtyJYc/BUPB4b3opg0sQqJo6vtBV5BV4nRxw0NS/vNSvtHdKfNf5jAqexsZGKigqefPLJ9GfJZJLnn3+eRYsW5fy7hQsXZvwNwBNPPGH7N/9KHFm1hGJnIOf3s4LjObJqNZMKJ2UPkBByFnFYxWEcXH509hAJitA4svokTq49K/3Z0BiAk2rO4LT6o1GFmvMCWFtzCOeOXUyF2z9s2NS6EXSxqGQU50+fx9L6uvR3+uDXNBLKCwq4YPEczj0qh3tNSlRF4dITlrDuusMsPjmIX/q5Qzn7mkPRtNxN8oSLVnD8OUspq8qd7+nzRnHiqQuYP7cxZ0xRcQGnr53PhUcM8Hb6gow9eh1OfzHJ7nY2/uVWFlU72faLW0h1tuMIFVNz3jocgWDf4Vu8v3LoCj63YHHfTTB7wi+cOZuLps2ltjA37wUVtVw8ZR6rakfljCnxeLlk6nyumrk4Z4wiBF+cu5zrJs+l+ad30fLDnw8RORK9I0zrzXfwxtd/hDbIHj8U50+ay3njFlFbEMoZM7u4jtMal7K4ZErOmKDTx0l1qzmhJnv7BokiBKfUHc9ZDadi5XFoLq3fz6w/mbMaD8OpaFliLKytXsbZYxZT77PWDjJ64+z+1u/YecM9pNosi+uMohrOn7CAxe4imr93B803/2qYyClyebhk2gKunbck57EpQnD9ouV8fZn9vIIblq7g6rmLbG/eZ02ZyYVT5zI6kPshZkZpJRdOns8RdeNzxgRdHi6ZspDPT1+eI8LK9/WzVvG1eav6BGX2fH917iqunLMQj5b7JnjGpOlcOHMOY0K5eU8rK+eCmbM5amxu3n6Xm3Vz5vOFBUsHU8igpNCX78UrAZGLNjcsWsEVcxfgdThyvho6ddJULpg7m7HFw9eY6sfksjLOXzCbo6ZOyB4godDt4uKl87j20CU5eQvg82uW8aWjVwBgxGOkesLDeF97xFKOmFKDk9zzYo6dP5kzDpnNmJrcEwTH1ZVy+hFzOWx5jvsO4PW6OPvEhVx8QV/bzXHDuPTClVx68UE5js364KLzV3D2CQvweoav+9WPNSsmM6pu+LpB/0r8SwVOJBLh3Xff5d133wVg+/btvPvuu+zatQshBFdffTXf/e53efjhh/nggw8455xz8Hq9nHbaaeltnHXWWVx//fXp36+66iqeeOIJbrrpJj755BNuuukmnnrqKa6++up/5aHkRCQVpz2RxDRFRvuQEgxToSkaIWGm2BKJE9Mdw2ISpsbuXujVE7wfjtES92EMmbAYNzQ29/hojkX5KBxnU7iEpJn5VJk0VTaFS/moK8Ge7gQf7i4imsjslHRD0NQe5I3dJpFYivBmFXq1NCejN86eb/+W3Tfcw9ZXm4klU/R8HMHVBXpHJ3vvuJV9v7oTIxbDEQW5OUFvb5KOD1rwtKUQQyazqQkT145euvb30LK1GSXcA0PfL5smSjhCy9ZmOlq6ScYSWUWQME32bW8lFkvSpUukljnXSAI4VVp6EyQSOjtlFN03PMZwC9q8Bj2JBFtSYRJBkH1XgdMXSoucRHc7Jx97BE27d6GVFFF1waU4AgM3eqlCMqSzQ++kXe8hFewFx5BjExK1MMUe0UpUT5JwhdEcBgxh5XAZhLU2YkaKVtrRXPqwGEUzSLp66NHj7Im3ozhMhvU2QmI6k7QmImxrb8LsiaC3dmSIHL0jTMsPf87+XbtpaW0hmewGMbxHVjWTvfF2YkaSpOhGU4buT+JQTSJmBwkzRcLci1dLDYtxKjputYOo0UvS3EHIEUUZMtrjEAbFzk7iRhsxfS8lzh40kRmjIil2Rogbe4jo3XjU7mExAkmBliRi7CVmJIma3aiKiRlLoHf1kmruZOcNv8ZsD9NlhNmyYxt/vvor6K0dmN0RzHjm6FwklaA7GWdXVxciS7qR1sKVzZEIe7u7+wT88BiktfhdezxKXA7NkRUkFNgV6SSqJ+miG6EOz7dQTdplFzE9Radowe0enm9NMxDuLiJ6lDajGZ83jhiaS8XEWxChI9VJczKM6kkghrYBAQ53iqZkGx2JKDE1kbWdCM1kV7yD3mSKjmxz1PrQGo0S03X2dHbnzGU0nqIrFmdPezcilWUkQIKRkDT3RKw1ZGLWZ2Ysht4ZTseIuGBPezedkRixbe3Intiw7Wgxwb6mbmKJFL1NUdTEsFSiJiDSFCWeTNG6owtHbDhvJQVGc5LuSJx9e7vQosNjhAlKt6SlrYf97T2YXVF2/vFOtv/+VlLdnQPbSsJHH27mmMMP44Pf/2z463BpnYKm1i5iiRSdPdGc+e7ojhJPpNjX3GWN0GXRLolYkq6eGPt3dyBSWUbWTImM67S1dNO2rwvRm7LeoQ3hpCQMWnZ10BWOkuxMDLsPICVKStKyqyPvPMvPGv9SF9Vzzz3HypXDn2zOPvts7rnnnvRCf3fccUfGQn9Tpgw8Da5YsYKGhgbuueee9GcPPfQQN9xwQ9qJdeONN7J27doD5vVZ2sRv3fwX/rTnpb75MxKlrxMwpaD/ldMJtYt4ZJ9l6xRIHIo1F0E3FUyU9KKA/9j3ZjrGo6ZQhEnS1EiaGgqCif4G3mnvIqLHAYlPS+JQDVKGSkR3AoJCzU2p2cDbbXsxpcTtSOFy6BimoDfuQvZxOqVkFg+/12eh1ExwGeidXez56R3oHe1oRcV87n9u5ak3mkhGOtn099tI9rTjDBQz5qjLcLuDqIrgqNkTeOE364E+AeFRkAooKYmalCiKYMLESppe20ykq8/VoqmgKpbY0Q0E4C10M2piFR+9tX3gnXD/UO6gJnrwRQfx+GMbrBhTDggmTUnHrzlnPve99j59JwI1Ka2O0CGQmkBVBIcuncjvd35MP/H+Dk5q0LtvO3t+cUt6n+VfuhTX6AZESiAMSxBJp/VY5nM4mVVXzButuzCRSF0gdQEChNNMH8Ipo6fzp13vYEqJaYKpKwhA0Uz637ac3jiX3257K33Ipm59oahWjCoUjqqZykNbPiQ9GGb2PcUq1k1SQTA5VM6enh5amprY/91ford0oJUWUXzxibTf+Qf0lg4cZUUcdcvX+EBYri1pWi49AKHINO9zJk7hkb1vYiIxJZh94lsdFHPu6Fm81PF4f7pJ9YlvTZioikRBYWnJHLb3PoFEpoW9iUATJk7FQCCocDXQY3QQ0buQEpJSxZAKKn0xAhzChUebw4ddGzEx0U2BIa1cOvpiAKYXHsZDO9+xzomEeEs32778W5L7wzgrgtRfewxtP32czj370UqLKP/SRWjFwYELW1ivHo6qn8Rf39/Yp1Myu0rRN/YxvriEzt4YLdHerIMFAnBrGnMbq3lp7w7rmhskhsx4DDORQAsFOWP6FB7YPsBbb+lG8bhQCl0D+R4/k4f2vppuJ7qugBSoqomiWnOUDqmczDP73xvYjq5iSuu8aZo1T6+xoJT9EUlzvMdyVJkCaQqEkAjVOr9aTGeSUsX6ZN/6TYPEiR7usrh53ZzRMIv7P9iQc+K6AM6cMoPfvvuexbt/WMP6pW8tJMFhY8by6JbNmFIOxPQPMPWN4IwKhYgndJp6ejBiUfbf9UuMSITKSy9FCwQRCJyqymxnAQ9+9UuoBT6qzr4QpcBj7Usn/Rr0jKnTePDV963jF2D2PRMqKUtMCODU+dN58Ll+3n0xwtqOYlqveg6aNoZn392CYVqtRGrW9oQJwrBGEurKgiSlyY5du9j6p1tJdrfj9Bczau06nL4QqZ5Otv35NhJd1uejj7sMh29Qm2QgZacunMYfn3kvt4sKOHHpdP7613fSvId+ryqCJXPH8MaTH2MYfVP3h+RbAJVVQRRdsq8pbMUoIIVA9LUHAWiawtxVE3j51c1WDsTAg6MwBnj/5PunMmNaHZ8G/7+0if//CZ+lwFn74tfpTEVyfq8gKHV76NaHW2RTkQRGNIm7rBCX4iamp9IOkXhrD5rHieYbmAycNBQiSftJtqYpCHcW2MaoQlDQ4iOa5fVEKtzJ3l/cht7RjjtYQsOy09j27O8scVNYzLgjrIuxH0U9oDTFbCeqiXgSddD8h/9TKKqCNqqcaCz3axUhBI4pQVr1hK1LSCl10O0bvjBfqquTvXdZc276oZUWUfb5i9GKglm2JHH6c/MBS5gUuhRbR5KCIOQsoD0ZteXtkE7iKXt7d1r4AHp7OC1y0sdTVkTFl8/HVZl/gnxV0KDXyP1kLhBMDBkYdA6bZ5aMJNGjKbxlBYQcBoXawDXQ3RzF5XXgKsz96iMbTAm7Y/bz0BQU9kWqCScz851s7WbzlyyR0w+tLIu4GQSnrqFHxbBrNwMyy+DGsBAJnuFbMaMxmv/3LszuCNWfX0fR6BBdupVvvS1M07fuQg34qLz+bBSvNeG7yu+gV/bazmdxKgIwbHkbpiCayG02MHrj7PnOb9E7o5R/MTNHenuY5pvuRPH7qLr2fIJaEeF47vYtgGKXl3DUftkJTVhWett0Sks4AOjhME2335Z+KKu69FK0YAi9s5N9t98+8Hr53MvSr5fT+1IUgrqTrt7h868yeDs99PTE887DkYY9bwnQN/Ce7Olk68O3pUVO3cGnsevJ+9K/jz52Hc7C7K+GVUUhJJx0DR2ZGoJS1U20M2ZrE9dSJkokj01cSpT8DnhMv8P2PqCqCkeumc41lx9iv7E8+L/CJv7fgl4j98UB1oTHpJnKKm7e+vxfeP2qPxJr6SFppNKTXuMtPay/+iHe+eLD6IOWzu5/wrbDgchVBUEix4JUjmCI6gvXoRUVEw+38clf/zenuAFIJvT8NsMcjT5lJojr2W32cb2HlJnZYSqKIJm0v9KklMRT2Vfmzdi+oQ+b7DdY3DhCxVRddjlaaZH1mucHd2SfsHsAzggBJAz7TsREEjNSeXknDQPlQO0vgFYcpOTiEzM+K7n4xJw39MEQQNK0F28SSUoms4qbZ69+jKcufYTe5gimTKZdgN37o9x/3gs8uO4lEj322x8K8wCuAYEgniXfzlI/9dcek/FZ8UUn2+YiaRh5HXkHimxn1kwkMLsj6G0d7P3h7fS0WIsc9osbvaUToyuCGUukt5Ew9bw2cd008rr78vUnZjyB0dWL3tpB8013oreHrW33iZv+V3syniCu27dvCcQO4LrUpczLezC0YNASNUXF6B3tNN1+O/Ed22n6+WBxs26YuLE4yZz94GDeiQPgbZgyrwt0MJyFIUYfNzDnb8sfbzkgcZPmncy/dk0ikcp7PzANmb//PpB7iiLyurGklPTmWebjs8aIwPmUqPaU5LGjKoSc/mGuDyOaJBmOEmvq5o2r/oij08SQhiVurnmIWFMXyXAMPTawfoorj8MIQFFkXnukLk1KfN6cvB3BEFUnn57xWcOK04aJGwEEiwvyrtuguoY/pafMBG81P8zrzQ8R6xM5mtN6vInpPbze/BBvNT+cIXIM3SAU9Nq6sVRVUOovyHtTKvF4M9bJSHWFM8RN9fnrKKwbZY3c2IkcCU7F3h5pSJNil89WmKhCodRdaOsOEli1pPLZf7VBCdLbw7TdkVkio+2OP6C3h3Hl5S0JOQttXU2qUPBrwWGuPT2aItEZI7K3h6fX/R29VcXEsMTN+S8Q3tNLtCNBIjogcPItb2DtT+JU7Ed9TExK3QXD8p1s7WbnzX/J+Kz9zgfSN+5sKBrSTrLhQO/HniyuJi0UpPy6S9BKitBb29nzrV+S2LQrLW60shBVXzsfrTgA9JXscNm3E4CAw5tXBKl5hp0cxQFqvnkujrLitMiJb96ZFjdaaRHlX7wIpShAaUGBrTBRhaAsTwxAwO0+oHV3BkMLhjJFzq0/Q+9ox1lU0idusosFKaHEn4e3IvLGABR6nHlv8EM34SwMUXfwaRmf1a0+jVBpbkewRRyKg15bYaIqguJQfku21+fKbxM/EHu7KfF6c08w7kd1VTD/xj5DjAicT4mjq+3dW4Y0Oal29bDOxl1WyLyfHo+nyk+sqZvXr/oDkY9a0uLGUxVg9o9PwF1q1eRSUTisYiajfeU5b5QKgrH+co5rnGJrj3SqGufPm5NTmKfCnTQ98LuMz3Y8d196fZjBOPH4ebiyVJNNc1IFBx01g1ETqzIuSMNMkjRjxPQu3mh+iKJaFwefMI+E7OWN5oeI6V0kzRiGOSDwNKfGCactsH0qMQzJWUfOsx1OFsDZi2fhcQzwVlwuVJ8vLW7coSKOmTCRGWPHU/GFS9BKi1AKfSjugSF9RQhGBYo5oWG6bb41ReW8cQttF6gzpMlF4xbnvSmdN34BXhtHiyoER9ZPYnpxJWZH18AcnLIiKr56MVpZEXpLB23fu5tDvTX2vIXgrMYl9q85pMlx1YcOG8HxlhWw6rYj8FUXEtnbw98ueYKW9yNpcROsKeDUu5bhL/cCfTbxwCJqvWNzrvckEBS7yjmobKntMgiKUDizcVlGvge/nnJWBBn7g7Mpr6tBb+mg+Xt3ZhU5AsF5U2dR6HTm7ONVIVgzehyzK6ty5lIRgtrCAKdNzN5OtKI+kVNaRHx/G3u/dmemuCkJpmMNKTl/zFLbdiIQnNqwiMIsldUHeCscVDmROTZLBQgE9XW1XH3XrWmR3/zd2zPEjVYcRACXzJpnO8phSMnFc+flXQbhnBkzCbpzr72kCsGq0aNZUFubwVsLhig79dSM2Au+9k1cQfvXmectn2PP25Scu3qurQhQhODUlTMJ+jy5eSuCZZMbWTC+Lv3wlezpZNeT92XE7X3mfg6dWGErqCSSs9fYczJMyenHzbUtaaMogrXHzCZo89CoKIJ5C0YzZ/6onIJKCCgqKmDt0bNtRZeUkjWHTMv5/b8CIwLnU+LwqvnUeMpz2rZXl8/m0Mp5LC2enfE5gKeskLk/OZ7C6iKadzXx6mX3WeKmsk/clBWm/8apuDhn1OF8efIxw7Yz+PfrJx3DtdOXU6A4c1oor59+EKfNmMb4UPGwmFRnR3oOzqhRozj78z/AWVhMsqfdmmjcL3KkZFRZiJNWz+Ciy1ZlkhhEyu10cO5FK7j8xhMyYtxaIfPKT8CjBYjpXbyw/T7GLQ7xxv4/ENO78GgB5pWfgFsrTFM870tHcdTaOTSOLc91aCxbPYnDD5rKEUsmZXw+OK6uKsQpK2fypUOW930mUd0eqs66iOrzL0MLBHE7Na5ZsZjvLD4YR3GQss9fTNnV56F4PYO2JPne4kO4cvJyCh3OHHuD66au4JTGOUwMlOeMOax6IsfVT+eE+hlDjmgADb4izhwzl6/NOjhHjMSlanx++krWVU+h6cZfDIibL1+Ae1w9FV++AK2siHhzGw9f/nVcXblfsX5u6grW1s1jgr8qZ8zyskkcXDGPg0qXDuNUUO5j1W1HEKgJsn/nfu4+8/FMcVPhTf+NpjhYU3kGx1Zd2HeTyJ6ntdUXcVz1ERRonpwxJ9YcxbE1c5kcqAYg2TZE3PzPmRyxYjVvvPgywepK68b9vTvRO7oyNlXj83P+5Ll8felB1paz7M6pqnxp0VK+uWKVtT5TlhgpJd9euZrLZy4k6MouOrSiIJff9N2Mz8ouO3GQuLE2vLJyNMfVT+fUhnkZnw/eYbXXz5mjFvOFyUfljHEqCleOX8NXpx/WdzPNlkvJN2cczlcOPobRl5+V8W3xhSenR5WumL6IkydNZVZFZdZjA1hWV89JkyZzzoyZ2SkBlT4fF8yezTdW5s63pqh8edkyvr5qpcW7L0YPd9IypBbhP376Q3yJWM5+8JLF8zh+3hRm11dlfw0jYeGYOo6bP5kzVszq+2xoHwdl/gLOXjWHL5/cz3t4P6gpCp87fhlfOGEFilBIDJmDM/r4K3D6i4mF27j7xs/jJZ6zjzvvkLkcs2QqMyfUZCFtYc6kWo5aNpVT1s7N+NvB2yoqKuCIVeM59YwZ9M97H4xYogtTJll32WouvfJgVHX4Kvmy73Cv+NxhnHrifIpCued/nnLCfCrKAzm//1dgROB8SuyMtPNhR4SErmVMNTGlIJZ08kzTblrjPTy6az+dUW+GBdw0IeUvoeyK4zK2Oe7zh2eIm56oi4/2eHltfxOPfbSTrp1+9OiA5VxK0KMOunb6efyjXbyzpYnkB6CGFQY/WIu4wLPTybMvbqNpfxedr7TjaZNpW5/eFabpF7ejd7Tj8Zfwpz//negnKjPmXYjTN0jkdHfi7kjR/XITe3d38Mof30DrjEBq0PwYKRGxBIltzXz42hZef+IDzJQ+cEUAHq2QeaXH41H97Nm7mzVHHkJvMozHEWBu+Ql4tL6K8qoCgQJefHkze1rCfGz0kApoDJ5CIFVIFDt4uXk/bV0Rnu7cSbJIIAe9hZECUn74xNHF9o5O/t7+EUZZCumw+KhuD1oggOk16SyO8Hr7Ll7p+AhvKIK7wofiHbg5aU4DX1EvL3Z8wIfdO1Dd7bgdmfZuVTEJFcR5I/wOTdEOWvQ9uLRMm7gAPA6dj3s20p7o4bW2TTiU4d2IKkz2xdvZEWnjsb0fo2aJAYiZCV5v3cH6nlZUf0Fa3PTPM9GKg1R8+QJC1ZV4QgF6tOxPeArw+J6NNEU72drTnDVGAO90bKcj2cP74Q1ZOhOJr9zHgq8tzfj0yBtnZ4gbBYmQEXb0vs+2yOu4lRjqYLsOoGLiURJs6XmF7b3bSJphlH6rxyA+TsXgvfBb7IuF2dxtLQiqepxowYK0uHGV+nmnYwee0hCjrr/MGp3zD4zOWZO0YXe4m82dbTyxcQtKaoh46YuJ9+q8tmsPz23djh43GUKpz7UjeGrzVt5r3U97Diu10RHmzuu/mvFZy61/QG8Lp393aAYf9GynLd7NpshbFHliqIMs4AKJz5lEqLvYFW3io57XqPZ141IHz9eQ+BxJygpa2Bj5iPWdHxIo6MKlZbZdp2pQ7Ovlja53efKDN9l6268zuLX/4gH0jjAOl8HTLR/TFOnhw85my2EzaDsSCQq83dpES2+EZ7duI2vTlbCvu4eNbW088ckWFD17vpMxnVd27OKFTTswe00wQO/spOn229MTjWsvuoJgRSU7tm/nvZ/djNHWmbktExwxeP7trbR0RNj6UTOOOAzpwHHEYdOGJlo7I7z+ylZcvZIMx72UqAlJ145utuxs5bnXN+FIkNHnIiXCAKNH540Nu3jp4x1EutvZNljcHLeOgspGRh+/jmBZBTu2b+eNe39IIhbOFBQCTA88tWUb+7t6eLezGd0jMvtBAbpH8HZHMy1dPTyzcTt6oUg7mvpTabhgR7yNww5fw0WXnEpEi2T0lbF4mHfe+yVvvvsrnnn1Q95cv524IvvObyYn6VZ58bVNbNnWQltHdsONEIJXXt+KkbcMxWeLERfVp3RRff3dh/nb3nf7howlqrAu78E28UMrpvPIng/6/kKiKZZ9OGUopNq62XnDr0k1D7z+0cqKqP7qebhK/ei6gtlngx1TWMLu3dF0pV2hmiiqiWkoSMNqwW5VZXQiyPbWDkuVK9KyNBugpAZa+eGVjbyyflva0mc4wUjG2PzYL9ETESauupS18+fwwiMbAEvNr//wLpxOHzMnnoVDdaOqCvPn1PPGw+vT25Vqn13bMBHSsprWjCqjeUcryXj2CaWdiX283vZQ+vd5484l6K2xFKAQVoGWvjHUmafO5MX3t1uvoEyJolvN13RYMQJYtmYCf962sY+QtGyhEkwNUCyb+NKJ9Tzeu3GAhG4VTJSqBNU6c43+EDFXMzHD4m0aAtMUKIpEUa39OhSVScEgWyP7kfRbqRUEEmWQlXppyRRebP0EQ5qWBVwK9N44xBK4yvwIYEXZTB7Z/SFgvVJRPE6UAmu4XgjrtcLCkjE8uXv7QL4HXb1CWLzrCkLsj8SIdPdgxhJoRYOemvo7w84eJlZXsCXVY/vq7LjRo3ip7aOcr0QEcEL9ON7vtqqgD91StDnCk+v+QWTvwGTyUI2Xs361GH+FJ31sAEFHGSkzTNK0RIApQSKsXPbFKKikmMWO6E76Lef9+xy8rSrHKp7YtzH9SsTojWPEkjhL/H2xghXBWTz08Wb0jjCK25UhYOmzLS+taOSlj3elP01bl+WATbyqsJDuRJKeRCJrDFivViaNLuX9tv3DXonoHWGaf/hz9LYOAtXlFF9xBLt//DCp5k4c5SHqvn02ztJA3/kVnNg4lre6BtnETUvqaYqJIqzXfTNDY9kYeT+9j5SpYJoCTTHT4jjkCLG710Gkz7VlmAJTChQh0zGp1gjvXvMwvfta0cpDlF92As0/e8h6hVYeovrr5+MoCXBIaCqPbdkyYIEf0kgUITiyYQJ//3Bj1nYi+nK0oLaWV7YNlNLJlstyXwGpqEFXLE6qK8yeu28dMqE4hNEdpvnXPyfS1oIjUEzjSZf1WchJW5sBDh8/lmff3IzZb+/uW69T9MUoQnDwrLE889IAb6lYhPvtz6oimDGphjc27RngLdIHkN5XccBLtEDS3tHJ9r/ciR6NWBbxwlA6SI+E2fXXOzCcbupOugjV6bEEkxj0D1gzZRxPvmfZ6ftFFKKfm0ARgsMmjeXplwf1g33PDFK1YoxoF9se/zndHS24vUVMXXIJLleAZDTM+6/eQTzagdtbxJI111Ao/ITD0fS2kGRccELAlBl1bPhwr/XqbKis6Iu78evHsXjBWD4NRmziefBZCpwlj91Ij25vMyxQfYQTwysbp9q60uLGUV5E2cUn0/zzBzJeK2Q4PJIKoiePrdYAT7P9rDBVEQSbBcnE8Jn4ejKGoSdwe4NURBV6Wwcq1sYTXWiqC23Qu31XIokMRzHtlLlpDl/grw8xvYc32v5EzBiwkXucIeaOOwv3kBWiVVUhOilIXLd3UmnjPbRlGeIdDKVYkvSn7C2rDh1fYb5Z/5ICZ36buIojLZQA9N44G7/yIKmuKBO/fxquUj9u/HQkEiRaw2y/4TdoAS8NXz8dtWDQjddwkNTtq1JLE0wjXz0biTp0YcIh0IRCWSBF3LTPwcRQCkmYoXN1egeJm0CNj+O/N5OHr19P554ooRovZ9+9mECFJx0vkMMW7xsKQwq25ynxrqKyOVxLTyrPeYkU0xaxd8g4Eioirti7aA6gB5VIzMDwY9M7wzT/wBI3Wmkxk/7nfPRiD6nWLnak+4YQDTeeg6NPnI0NGUjRZStMXYqJU9WHnZPBSBoqHQlvzu/jrT28e82DxPd1ZYiZVFsXe795F3qzJXLqv3khHkc1PQn7grJFwkMkal/AVzEFmHlSaoLad2qNeIy9v70TozeSOaFYAns72f7gbWheHw1rL0J1eTI2oyoKgbhGb9S+fYccLmIR+wK+UhXW2jc2xE0VUj6rbzYSMYxkAmdhMHM7QDwVtuYEDuE7wFvgU530xOx5F0kX8R573kZ7B588cXtazIybfQqb1v8+/fvUJZfgdgbQ4vnrmpl5TDCqKjh09RS+cPUa+23lwYhN/N+IpJnfZqibRhZx0z1I3ISo+/r5eAbNkdBbOqwJokPmBeRDvvU4wBouNHJUftWcHlzeoMVbNzMuWLcrkCFuAEzdzFscNRcGixuPFmDeuHPxOEPEkp28uek3xJNdGfHWwFD+A0zJfPWmrcmx+Vw7B3JUBxoz1IljRJOkuqIk9oX5+Av3kWjtRjfNtLhJ7e9E74pixjJvGgfC+7OEcQAFMk05fL2V3pbetLjxVRey9o6DqJ9Rwtl3LyZU46VzT5Rfn/sy3fvt1/IYCnmAx34glaRT0sxv/5XmP2VbzolckzhdLhS/D62kiOrrLkXtEzGO0gAN3zkbR3kILViAMmgJfFPqeSuqm+RvJ/muEc3jxBH0ZogbAEdJgOqvn49WHkLte7V3IPnWjfz5NvnnbOKq20P1mRf1rXMz4JYSWC6lUSddllXcWJAYRv72bRhmrpUuBrYk8xeJzuDt8gwTN2D1cQ5/MKe46Uf+iuNgGEZem7jLG2Ta0ktxe4uIRzt4/8XbMsSNyzOcYzYcyLFLSd5lPj5rjAicT4lx/oq89t/agqJhtk7F40QLFOAoD9H4nXMY1VCPLs30HAmtrAjVX5Dh2vG6c7uV+iFVbIu+gXVxVJb789oMK2tCqGruGEURlNUWY+QZUXF5hy8mFjciA+JG9TO3+Dgqy0Yzd9xZQ0TOwMiOrptUFRfmtXXWBQK27iBFCGq8gbx2awf5bY8S8Kr2ldl1aVLlDWW0E1ep3xq5qQymRY57eyc7+sSNoyJE43fOSj+1g+WSqy7Iz9ttU2RxMAod+XlXuovytu8SZ9kwV5PD68AdcuOrLuSQ246gqrYRE4NAhSctcgqKXDgLtEHbyr/on4qJV7Xv/A0M6grs24AqFOr9Adu2JIAqvz/vzduhHsDKRBICzuETjBWvh/Irz6f885cgQn6qPaE0b0dpgIYbz6HuawOjeKpQKHOV2p4TARQ7i2wL/AK4FXsJpPlcTPveWibduC4tbvrhKAlQ843zqfrKWeB15r3mVCGoCwZtb4QCq3htPpu4qoqM86a6PcPWuZFAqMCDozC3WDClpKo8aLukhKoIqsoDtnkSQGmwIK/dWhPiANYmgqIC+/ZtSklNcSA/7zL7Cb0CCBUV4HQHGDf7lIzvxs0+JS1uFFXkXSvHNCVFodyjgWAd25hR/0W1qP5fwKkNC2yfpkxpcuXEg4bNYVAL3NR+7XTqv3MOaomfyyctIeC05ltoxUEqvnIh5Z8/Nz0vwKokPZM5VbntqKoQzKuu5uT503JeSEKA3+PivKMX2F6Qpik57/zltiMmpik57ZKVFAa8OTsuRRUccfoipi4Yk1EpXBUOnIoXj+pnQfkJzFkwjSNPnIvXHUyLHKfDi6o607wLfC7OPX5hXlvnlasXYUppFbTrCg/nLSUnVzXgN8h5o1CF4OTRs5hXPMo231ODtRxfuyjndqxXlC7OH71qWDsZKnKevuxmkoPEjbM0s4MykVwyfilFLq8t75NGz2BpRYMt72lFlZw1Zq4tb6/m5MKxK/Pa20+tO3rYCI7T5+SgnxzGwbcfgbe8gFVlx1GgWcvoByo8nHP3Yk7/+QLcfSsZCxRmhA5mtG+2jU1cocIzmtXlB9uOTrgUF+eNXmV7ozSkyedmLM/5PVg3yUtnz6PcZv0WVQiOnzKZlaPs28nE0lLOmzIra74VrwdHKIhL1bh84vIM3o4Sf8YrSkOanDPqcOzGDiVwbPWhFDlDOfOkoLC8bD6LSibntNwrKIyrqOfihYdm5a0VB9C8bpyqxtWzF+XJt+SaRYvyCsGL58+lyp/7IUYVgmMmT2TV+Nz5VoRgdGkRZy2flbNfEoBDVbnkqIX2r3BMycUnLM67iN+ZR8ylssSfm7ciOGzeBFZNH5NTmChC0FAa5Jxls3PatgXWCsyXH5qf96VHLbIXJgJOP3IuIZ/Jprd/n/HVpvW/JxELoyiCg5ZNZPmyCTm3pSiCmqoQJx8/L+8aZYetnpo74F+AEYHzKbGmeioTCquRQ+ZV9f98Yu1ClpWP46TaeRmfAyheN1qxn6n+Wo6qm8ZXZ65OF+zTigKWuOn7Pah6uHLqYr61fBWKFFl9f4oUfGP5QVy6ej4hh4tspKQJX1qznMMWT2JqXVnWGIDjl09lwZzRHHNMFntk39+MH1vO6jXTueTrx1pF1LLYIwsKPZx65cGsu/FExCCboUNxMafkaOaVHo/X6efSG0/ktPOX4SsuwOUMMGfc2cwaczoO1Z02plz4+cM5dPFEJk2q7D/kwYcPwNGHTGXp5FGcOG0Me39zJ3t+dSuprs6+GOu/Bq/C99ddQvJ/78eIZqmghyTgdnD1tMV8afIarEGs4TEK8OUpR3BW40qCTi/ZLDQSuGLckRxcMZ1pwYZhqXSW+Bn9+SMztlx79bEZT8z9qR1XWMlx9TP4xszD0jWGhqQbr+ri6inL+dqcg1FQsi8nIOFbcw/j4gmLKHIWZG0CUsKXpq7mkMppzAiMGsa7/+fDK+cwr2QSh5QfNizGUeDEW1pApbuO5WVLWVNxieWNkuCv8KTFjZSgCS8ry07j4IqLEKhZeUsEh1Wu4/CKwynUgjmvuROqT2J1xTRmh+x4z2B55VgumdJntx7amCSMD5Rw6oTpfOOgVX3tO5MTEryag2sXL+aGlcvRxFCLycC2vrVqFRdPm0e515etmSCBL81dxiHVk1hU2shwWH9wRM0UlpRN4OS6VWTdEJKGgjIOq1zMBY2nIIbFWHFeVeXUuuO4bOzRuFSRNUYIk89NWMt54xZQ4fVl3Z/EWgbhsMZxLKutz+A6+Ocjx4xnVeNo1i2Yn+XYrKjGohCnz5jONw8+KGdRRrdD4/PLl3D9IcvR1Bz5Br5x+EGcuWwmlYHc+b7ysMWsnDmGxVMactFm9eyxLJ0xmvOOXZA9RkJNRYjjD57BF89e1dfDDKfkdGisO3EJnztmGZpDzd5MhOSGk1dz5uJZVJb4h22r//fL1izioCljWDa9Mf354BiAlTNHs3LqGC44bmEu2lRWBlg8roS3n7+NeK/1Wmra0nXp11UbXvo5utHDJecs55KLVuJwa7maN1dedShrj55NRWUwa6sEOPvMJQSD9qM8nzUObCx7BDmxvnUvb+zpwOFw4nSlUPvcNYaukEo6uP+TjzilYT6/37CRpHDj8CRRndZojmkI9JiD19vbeWvSXu58/m20bhe6LwWevmn8JohejXDE4OEPPmbjx/tx75bgh1QhlkQ1wdED7m7J7556mxnBUoyPenEHBYmgNfkNKXFEJAVhyR9+9wZj3IXsfGobHr9GIuTAdFmTUtWYgbtT58V73+Kk1TN45tcvoZoSw+uE/hWJdROlN8GWFzby4VvbefDnTyNE/81TMvAL9HT28vSf3mLrjnaMwgLojSHjyb4nEReauxCjwMPD973OmGWjafKCI+TE1R1A6avtons1jCIXv3liPZXTyngtug+tBFxdgyYbuiAZgod2fMLJHbN4YNeb6PEe9M4O9vzqNmrOW4daEiCht/PMTXegt3bgqypmjLeduLuEWNwqVqooJgXeBC5vmMf2v0VzYg8lnm66kk6iKSf9rh6vI4nfmeRvTU8z0T+OHr0LVViFHy1IrMKqkgd2P01DQSVvtu1GEQqqYqafZOMt3Wz5/iMZbWr3j/9M/XfOxlXqT6fSMBTeb2vljZad3Pr+G8ikhlQNq8hmX4w0FDoTOg9u3sD2zjCpmADNcoalT4khMHSVO997k2W1DezvTCAcKopmWUKs7QjQNe547y2mFJXz/N4mNM2B26EPtG9TkEg6+OPWjZw9qpUHd61HlwUUOOK4+ope6lKhV3eyL9bJOx2bebzlUTqSPrxqDLeiW3OqpCBmOGhJCl5qe4FevZlO3YFLkTjRUfo4JaRG0nDxdMvfqfMupCkWxaFoOBTdMtlIMKSCbjj4095nqHCN5+V9exCKiqaZ6VV7TSnQUyp/3bmRcxvbuO/dDSi6gqmZ1rXU79jRBZv2dfDS7p388oU3ccQEKU1a11LfdanoEOtN8of1H9AW6UVGTBRtoBgj0opRdfjVS+tZNWMM+zojoAroyyPS2pZqKvzy7beZV1vJG23bEEL2lVIYeCRWhMnT+z5kR2Qpr3c8TsiZoFd3kDRVLNeXxKsliRpb+bj7Q97seIBaT5iOpJsew2W1b0wCjhhBRztvdz7OvrhOqbudcNJFT8qFxHIAFjgShJxJnm55hF3eFYRlGw6Hiq73i0+Jqpi4nCb373qRuUWNvNCyA6lJMER6LqAUltvzsb2b2NTRxm83vAsq9E/tSksrBbZ2dfLCzh3c+cabg7uQDPQmU9z/3vvEe1Mk+1+Ny8EbAiEld72ynmMnTGRfe4+1rf409sWoEn773HoWja7j9Xd3WH/ef/4ZOHcvvrGVbUe38dCj76CYgxzg/XEm7N7Tyavvbue3z72DdAhkylJQ/ZSkAr0yxZ9e3ECvx6DHo6MAatKaMykB0wmGB+587U2OYzJbHGE0P2i9IAyrFprhBrNQ8ouN61kysZ7HerYiysAZFqh9U/VMF6QCJv/o3sK6tlbu+uRdYlUCrVOixfo4aZD0w4bYThYvX8a+Pbtx+osZv/ISfASYuuQS3n/558R7O3jruVu5468zKPGUEC6QaChoMTPN23ALUj6N3zz+Jr2pFDu7u1FcIl3gWAJSBcOt8sCT73DSsXNsF4b9rDHiovqULqpLXvgjT+3ZMugVVH86rStAQbCkdDQv7No5aKg/M0YVgjmhat7evD+93cGqvN+OWlHgo3dbb3poMrsdFeojHlrbIwN7SscMYF5ZCZ+8uzu9LoEcEiOEYM70Wt5+5qP001Qma8vVNGFmLR++sc02R8WVQTqTcmANhKHeZkAoAs+8Klraeqz9ZLEiAow5uI71TU0Dw7P92+qLUYRg3pxqngtvJdUepvl7v0ivvFp88Um03/GgJW4qSxn/g+NxlflzUaLE5UOKjvRE26yUpMDvKGV/vDPndgDGeCfydsfujHaSbO1m6/X9C9CFOOzrV/DoN24h1dxvwT2vbySn/9wqTA1W82bTQDvJfFYSfby9hHuTpMyhbXIgRiCpCwbY3dOFzBEDsKShkvUdu2zb92H11XwQ2ZDxHJkZozAjVEGP8Z4tb5/mQxXdGFLPGYMUJMxxNMfb+q6R7LyDch6vtOzNzVsIFnjH89ym3YOuStkXMXBdTguV89GWlkGsM69LgKDHTSyVItF3w80WA5KqUUF2dHXm3B/AQdNLebtrW5r3kOaNguDo+nKakm8McBoWozCqoJpe/YOMmKFt160UsjPmJiVTOWMAuqIz2B5pT/Mduj+Aqc5JvLxnz8BrKmkVEjUTCbSioGW5L23kxa2W5V4Ph1GcLhSPJ33aFCGYVFzKR3tbBzac5fT6XU7MXpN4Xx2p7C0AJrqK2dHckX6lPbT/AlhSXcs7H+we1KdmxqiKYO6EOt58Z8cwSv0xiiIY1VjKh+1tg3gP7wgKPE4iZZJov7svB/GGsUVs7mwfeBWfhfiS+jpe2bsrI9+DY1QhWFLawKsbB5Y4SJ/gvldNMhGn/d676G0PD9jV+2KSkU62PXw7mtfH5BMvw9frJhpP5jw2gHFVpWzb1TaI9/CG8tXLDmPN8sl8GozYxPPgsxQ4Ux64mV7d3h7plwW2lXYBPHEHxITthEY1Bu6wPR+hS3xNeWrQqAq+pih6nhntfiSR9tyV0gE0TSBNM6crC0A6NMg3cU4T9DYU2saoqkL3BI2Eac/bPVqhU+mryDxI5KQ5lxYx/rtnU9Tgsl3yXlMMfA77c2tKiBv2k2NVoRBJ+DIKQCbbutn6pd+kV9cd/b0z8RXV0Lq3lT2DLLg13xioQwQgdA1DV215SxPQ8719log8TnJNKHj9OvE8BTdHFenoomfY8PVglLhiFLuithNfVWHiUe1diYYU7ImGbGNUobCltYpInsnvnp4AXd26LW8tLlA7E6Ti8awFG1NdfZZet337lkKSLLLvajVFIVQXJS7t+4qZpRGcWmeWlyED8KlJ/FoCaZPvuKHRlrKvV2SYgvfbqu15C4VYR4DIoAKQZjRGy49/hdkToewLF6MVBQkaXnpjKZIdHez72e2oPh8Vl1xoiZw+CN0azbJ1Wxmg2V+WIMEVtg9RFQV/RCEWs2/ffoeTWDRpO2dRd4H0qvbzA50Qt1/hAJAkiu3biSoEbpdGJGWfhFDKTbxXt5+03RFD60zg8AWHfZWMhFEdLhyKG1e3PScBiDx1c1VFcOjSSdxw2WH2gXkwYhP/NyK/IZm81kjAtrP6l+AAdncg2vffKY+zzRTIhsExWnGQ4otPyvi++OKThrlCcu3vs8LQXKp9Lrp+ceMsDSABbYgFV3gynU79T9j/LhxIu8w27+D/ZDufHUQe/5CFA2m7RjTGrt/ewe57BuZy9SPV1cnue25lz713YuRYofifxz/bwj9NzGe3laG5NOMJzJ6IVaT2+1aRWolE7xM3ens7RiSCmcgUcweyv39n+weyz7/6D+OArssDoK26s9vVAZy+/Hb1fwaSA7sXfpYYETifEnNL7QsW9g+75qu0O76sJK8dNRhw569crEHAn7tR6qkY0UgHDePKUYZYwOPJLlJ9ixYqiqBxSIHMoVBUQcP4StvRG4BAoTuvC0EYkpDffgKabpiMLy22tUcqQjAxUJbOt94epv2OBzNi2u98kPJeZ97Cll61IO9aIgIIOfM8BUuTcf7yjKUC1AI3o751KqP/x3JLKQgmBMtQEBkWXHXQ6rqqEIwPFue1iQecrgNaS6TMk7tuDFg28fFDeA+FKgSNBdW2eVIQVLhq89qWnYrXtoimtS1JsdNenBrSYFKwNK9teWKp/eO0IgT1fi96b4RUZzu777ktLXIscWNVnzejvYg8iwoioaqg0LY16abJWF9FnnwrVLnrbXdlFSWttR29AfBpDtQ8w3iqkFR57G3SujSZVFKSwVsrClojN31FOlu+fwcl7Z3s7RM3WnExlZdfihYMpv9GEYLRJaG8N0G3S8ORZ1E5gKoivy1vwzQZXV+a1249pr7U9mFPCEFDWX7eHqHiVPMtwCmo99vn25CSiUX52/f48hJbToqAurJgXqHvcGs4Hfa8JVBTEbS9P5mmZNr43HXt/hUYETifEudNmGs7BKgKha/MXWnbGA0p+dyCxbb2SAGcs2A2K6aMtrXrrZw6hlOOmpO1oempGB+9chcfv3wHa46ZgGkM8I4nu3hz4z28vfleUnocRRFc8IUjMqzdQ2EakrOuPYzymiLbSrPHnreMxQdNtOW9cNl4Tj16Ts4LW1EEZcU+rjx0sa09UhGC6xeuQBVKxusprbSI8husis16Swfvf/l2gt2KjU1acELtUpaUzrC10c4rnsTJdSty80ZQ7PRz2biDsy4VkC4dIARfmHowmqL0LRUQyBA3YLWTq6Yto6EwaFsB+pxJszlq1ARb2/LymkYumjov6/f9vEs9BXxu6kr712HA5eOOwKHknjhoIjmx9ijKXZU5cykQrCg9hBnBxbY28XGFUzm6+pCc+xIIAo5Crpx4sP1qz8D181fiUrWc586Uks8feThLPvdlHKHitMiJ7dqeFjeOUDFfuOXnrF2ywNbavKChjotnz835RK0gKHJ7uGbyavt8S8lZjWtxKLlfi0okh5YfT5mrziaXggXFh7KoeJGtlXyCfzznjl5myzvg8PCFmcPbyVCR8+z1X88UN6HMV42mlFw+fwETSktsLeCnzpjGcdMn2eZ7Vl0VFxw8Lyfv/uUyrjhxqf1SGFJy9jEzwOjN2qcmomFSySjnHj2f8XVlthbwE5ZMY+3Myba8Z9RUsm7u/Nz5FgK/08WXFi23FS+mlHxh+TJ8TmdO0WFKuHjlPCbXldvyXrt4KkevnJqTt6IIJo2q4Oy183OKJSGsOUiHLJ2Yk/O/AiMC51NiWeUoZgb73lEPPrl98x/PHD2LaaWVnD52RvqzjBhgbkkNK+pGce2SxVZ5+ywxxS4PZ8+eyRVrFqP228TloBgJqhRcvmYxJxw+k2D/nJdBLc5IxUkleujtaeOq686hbrT1BN8vbmKJTpJ6L4aZ4IjjZzN+ag1HnrMk57FPmNvI3BUTOfvLRw8pjTjws688wDHnLuPMK1ZDn81wCG2kS+XMqw5m7ZqZFJZ7s6bSQHLBOUtZMraBWROq+j6Xg2Ks/05YMoVpFZWcVF6VKW6uvxD32DrKr7+QgspS9u3azbvX/pZEW1dW5iUuB6fUL+HM+jVoymC2Az+rQnJ2wxEcW7WYgGP4ZGUprZv7+aMOZ0HpGGYFRmeNkRKOqZrL1FA1ZzUuYGgpl/6fJ/mqWV01ji9NX9lX72V4wgOKmwsmzuWamYvQpJK1nQhT8IXZyzhj3AzKNV/mCev72TQl101dyqLyRubb8F5bNYspoRqOLF+V07Zd7WxgcckUDq84lZSZPUZKP6vLjmB1+UkY0pmxrf6fdVPlkPLTWV22FJ9anJWTIeG46mOZV9rIwuIxOXkfXT2DaSVVXDhtTto6PzSXk4KlHDZ6LDesPYa6s9elRc6uX92SFjcTz7+G6449gsuXzcdJ9nwj4dqVizll8jSqPIXZ8y0l18xZxJzSBhaVjMvJe031DCYG6jikfE3WGIAqVzVzQnNZ7DmO7v29DCcF8RaDac6DOKbqaJyKmiVGIoTkhOq1HFs7i2qPP+Pv+382kawbt5J5FbUcVDtqWIxWFKD4gpMZjNIzTkULBYclfHRxiKPGjecLK5b0vfofePnZ/3+PU+PiBXO5dNl8HH1262HpFvC5gxdz9NxJVPY9QAzrmiVcvGYBM8ZVs2Tu6OwxwJJZNXxu3blsfuVOYr3hjJh4NMyHz93OttfvYf7UKq44cQmGkFmyDU6vxjmHz+WSFfNxeJR0f9V/bBKJqUquOXQxaydMYnS5d8gW+vNtcvXSOcyprOboyfVknrcB5munNjK7qopLVs1h+GR86+eG6kKOmTKRK49bgqH0R2VychSonH/oXM4+dj6aN3v/bQq45PSlHLZ0EpU1way5NCWcddICvO78i6d+lhixiX9KPLVzK2/vbQZFAYc5IBkNASmFe957l8NrJ3LfO+9b65I4pFXQESyraUrh7Z37eHLrFm5+7EUcMdC1vsKQAoQJSgq6ojHufvktNr6/HxE1UZT+4pGkLavCNPnfh15kZnEpPW1RFEViqgIU62bodgSZMe8SNrx5J9u2bWPfnu8ytfE4Nmx/mFiys68G1Nm4HX7+9uCbLF89mb/+4S2k1wUpHfonbSoKODU+/mQ/Lz/zEXfe+RxmRQh6YhBNgJRITcUscBNWNf5w/2t80N5BT40XJZzAGU4iDIlUBcmAEzPk4mf3v8j4BTXs9iXQEDi7JGoSpAKpQkEqoHDTUy/hqnLxUmwXSjloPQpK3MqT4ZHohSa/3vUOR7eO5ene9biK3QglRMX156MV+3E4UhSN0Sj7/gnsv+FvGH6TmuIEcaeD3pQTE4FDMfA5Eng0nb/te4zdvftwKZatPWUqfXXvJA7FxKUY/G7XH6nzTKc1HgUsC3j/1W1KgTRVfrbpUTwiyAtNe1AUBw6HYcVh2b9TKZV7N73H4VXT+cW7b6PjQHEaKH21oqQh0BMa73a18fftG7npuZdQex0YTgPp7FtOwACRVOlJ6fz8rTfZ1RqGToHiVDBd5kA7SSioSYVv/e0xZpcW074vjuJUMT0maFY7MfZ14xBefvjMy5QX+Hhx0z6Ew4Xi1VEcVlU/M6Fgxhzc3/Ixa0dN45YNb4MIUuiJ43UlEUIST2n0RN3sSPXwj90fc++ex2hNlBBwRgk4rUrYSVOjM+GlJ+XhNzueIWK0sCPip8ChEXDE0YSBIRW6U256Ul7u3PZnpvpnsbk7iUv1UOBIoilWSZGY7iCmu/jZxicopIJnd+1CKBqaw0DpKx5p9NnkH9j4ISfUzuRXL6/HYQoMp7SuJ0AYoKQEm3vaeeSjjdzx19co0EJUHXEaO++9JX3tVx9+GtL0cueTr9PW04vsMVBVazJp2iaeAk2X/OAvL7BywVia2yIoqsDUJPQXdtRBNRR+9PwrNFYEeKZpO0KoVvHMft6mwDBV/rT9A05pmME/9j2KIfvmowy6mxgSdsf38uT2J7n0hLMIt0U45+5F+MoLkFhLF/Q2R7j73Fd5pHw5l991OSoJHEKiS2udKoE14dspTB5uuo8698G0JTtwKALdFOndqcIqHPyLrU9Q46rg2X1brGMyRVpt6Z1h2n/5QEaf2fq7+6i4Yh1a/6RtAVIx2dzVzh83fsgv3noL6ZKYurQs0tI6UFM16RVJbnnjVaK9OnFFx9RAMfp2J6x6T2iS7z77AieMncTunm6Ew8pxP3GpWn3nLU+/yrjyEp79aBvCbZ2r/rd6UgHDAY+/9SGde5to3b+XrhduZ8LqS/E6giSiYT56/nYSve1IBf707Fv8dc8+kkUgoqDGrW2ZqmX/TrhT3Pbs6/QEk/QUJcEFakSxlsJQwCgwkT741lvPcq4cT4dvDz7FQTzswkhqCCFx+pK4A0l+tedxpleU8VbyLUprNSJhD4moNaLn8qbwBWO8Fn+D9e0zuWX7c8h6HcIOiKiW+nMZyKDONk8vD257h3tf/pBYBSgRiSMC0rSWQ0j5IObT+emrr+IIQ5fPQFEFWlRaOVesyuVmgeD7j7zAqfOnsb23C8UnUON9MaLPAu8W/PyJ1zn2oGkUeuxXUP8sMeKi+pQuqtMeeYDX9u3OOVyoCMGsUDXvNe3POWSuCsH4wmK2bm+33VfQ4SK5y95hIaSkslujpyd3AdB4LMzH639Bd2TA1uhxhpg7/ux0gUtFEUyYVMXG93bndA8oiqB2XAXb9nRk/b4f3qCHVvvpHkhAmeQlHMvNG6B+ThGfdLfa5nLpmCBbEltJ9sYxoglcpZnnWEFQlxAkPU04fbmfKDyKh6iRxG5Cn5TQm6wknIra8i4Vo/m40573lII63t7XbNuWxvqK2bK/03ZfBZqTRDR3EUkjFmPfr+6EaC8VF16KFhx4VaCHO9l7x22oPh+V513E5PG1fNxhz3tmYynvde/OOeFeEYKJRX7CYqctb6/qwKPZVzeXEqRZTkfS3t1XaoxjQ1ubLe9Zzlo2bG2xzfcoX5Dd2ztJ9nSy/Q+3keoauEYdgWIaT1xHoKiUpGnYF2MEChsLaO3tteU9bUaAj3v35XxNpQrBmvoCwuaGnO1SIAh1a9x9zu/ShU3Pv3sBwUoP4X0x7jr3NTr3RCmqKeCoOw/FW557zp6UsLdnEq0Je5dclRzHe60tGfnOeEVcVsSiz13GKz+81SosWlJE+dWXZozkKAjq/AF2Da6/lwUuVcWMCgy7OYsS6qWP5q6ILe+ZReVs3NGS89ypiqDer/G3275BsqcdZ2ExDStPY8ez96V/H3/UOurGNLBNt+ftcCr01uqDlm/ITnzKKMH+RDhnhABmhCrZFNlr004U6pyNvL6/JefxC6BKC7Fnm/09xSkUPPsFqTz1r+o8fva3d9vu7/Mnr+SUlTNst5MPIy6qfyPeaWnK+y50c3t73mXMt7V0oin2p6OnO19la8DAVtwA+HxFTK4/NuOzqY3HZVTvNk3Jrq0tecs57N7VjqrZ8+7OY5EHkBp5xY2mKGzuzp/LnbH9mEi0AtcwcQPWa6OeQBRPob1DIGrEbMWNtT+RV9xoQmFzV37eGWtfZIEpJVs6OvK2k95E0nY7MpHAiERItLWx947b0MOWYOoXN3qH5XBRUik2hzvy8+5uzVOuRLI71mI7eRYgKeN5XYkS8oobTShs7MzPe0tLu+3kUVNKtjd3YkTCaXHjCBQz6uQrcASKSXW1s/0Pt9HV0Zq/CKwgr7jRFIUtvS22c3AMKdmf2GO7HYlEFnVxwd2L0oVN7zr3NXa905EWN6EaL6f/arGtuLH2J2jJI25UobCxM7N96x1dma+Iv3Qh7WXFVF69Dq2kCL2tg+af3I7eGU7/jYlkRzhsO18RIJE07MUN1s10fx5xoyqCbU0deUsetMQEE466DGdhMcmedjb99Za0uBl35DocBSF2hbvyTuyPK0YecWPNVbETN2AJ7x1524nJpq4229pfEtjT0ZOXtx4384obBdhnI27AWuvsgx37bLfzWWNE4HxK5Ou0gQNytCiCPF37Z4dYLMx7W/6Y8dmG7Q8Pq96t5LmRgtVoPxPiB7iNAyhrmNf51B/zWQxeHohlVXJgvBWRn7kiPj1vLRik+uJ1aEXF6B3t7L3jNuI7tqfFjVZUTPXF63AEgwfUQSgHkHGFzPkiWfEZXQCSA73m8scYPV1sffDWtLhpPHEd3qpGGk9clyFyUj3hT0+cz659gyBY6eH8uxekRc6dZ76aOaJTkd8CfKCW7KG5VNwuFH9Bev6bVmxNjNeKgtbITUkRSqEvo5hw//7+Xd2JIH/xS7AMAM7CEA0rT8v4vGHlaTh9ob5tHcA+D4TUAR28OKDq3VZ/kidOkL8/OYBGcCBdksBae+jfiRGB8ymxorbR9olDAHOqq23biCoEs+qrbZ9KBFBZ7rfqr9hty6lQUR7IOXM+Hgvz9qu3E0104nGFmDf+vIHq3Rt/nRY5Qggmz6zLUzxNYcrUmoEVinMQryoqRMszyqOhUFuUx45qmswtq86b72mBxjz5VhjnG5vXtlziCqEJ+2lqmhDUeIrz2DrNvuUEcudAQTC3wn5BNVUI5lRV5a22XF7oy2tHdQRDLPji9QMi5/ZbMsSNFgxZ+a60z7ciBHNKavM84Qsm+xvz5jvgDODscwelIgliLcNHahQEZb1OjN7ci5wZ0mR+ef7lG2bXVeflPX1cParXlxY3zkLrhuYsDKVFjtvnx1Ng/w5WAcYVF9veUHXTZE5RvX07EYIxBRNsRxYVFKq8E5GYBCs9nPi96Rnfn/i96QQrPQS0ApyK/XwITYGxheW2wsuQJvMrMtuJ4nVTft15lH/5IrTiIIoQzK2sxpQSLWSJnPLLLshY5E8VgpmVlXnt1iGvmwKH/eKaQsCEKvvlOXTTZObYKvtlJxTBzLFVxLs72PHsfRnf7Xj2PpKRThRFMK26Iq9QKFLd+Bz2k2wlggmFVXnzPS3YYDlFexMkWnuG80YwURaQ7M09uqwIwbSqsryayudz5p03IwVMrC+3zbdhShZNasizt88WIwLnU+L8aXNyXpACKHS6+OqSFRQ4nTmbrASuXb6YCRW5L0gJXLRyHkcvnpy7Qq4QHLNkCmecsiCrok7Ew7z35h3EYx3U1tQzd/zZBH21zB1/dobISaS68RY4uei6w/D63Dn3Z5om565bxdjxFbnXy5Fw2hmLOfqgqbkr5ArBEcsnc9FBuW2dihCMqyzhiwtyW1YFUOBwcu3Uw/BpnpxPL6Y0ObvxcEYXNNh2JMdUrWFV2ZKc2xEIlpfN5+xRq3LzRtBYUM7npq6ymTMBbs3BDXNWEXC5bXhLPjd3MTMrKm07kkvnzeW0GdNyW9eFVZH52iMOp/zkzKfS8pNPQwuGrDVJiov44iL7fLtVja/MXUXIaZdvyRWTVjElYJ/v0+oOYk3FUvRIkteu+xsvX/EwseaBzlsgmGY08PrV9/Dhlx9E7x3+6lNBUOst4boZK3PuRwAuReMry1YQ8npy5tKQkuuOXM2x13yD0SddnhY3/XAWhhh14mXc9PO7OfOgBbb5PnT6OC5bPN92vk99MMgXZhyUczsCcCoqF4w5Dr/mz51vTA6vPJF671S69iX4w/XvZXz/h+vfI7wvxqLStawotbfczwzO5dxRq3PPr0JQ7SniC9NXDeOjeN1ofQ8tDkXlKwtWUuotQEGghYIZ4gb6Ko7PW8zi2jrb9n3B7DmcPWembb4PHjeGSw9aYJvv6pCfa45bZjsaoikKJy8czdZ/3D7wWuroKwZeVz1yG/HuDi49fCGLx9bb8j5n8RzOnzLbnnfdGC4ae5BtvivcAa4YdwRmb4KPvvwHPrjufhIt3RlxqdYIz1z1I9r+515kNPsUAVNKrpqxjBWNjba8z5s7hzOX2ed72cRGLjnSPt/lQR8HzRyTcz//CowInE+JaSUVTAqWZ7WHSglHNUykLhDkiLHjc94oppSVMaWsnNMXzcBI2/TI+L+/0M0hk8awduVUcJI1Bicct3Iqy5aOwzvEbi0BVXXhcPqoqKrhhZeeZ/ySaUjA5QykRY7TUYBQnCw8bgZVNcUsOnk2ZhbrowRqFzYwdko1h5+zgJSWnZOzzseSVRM58vBpmAVK1hijAI46Yhqrpo7BV+bq+05m/F9XTU5eNZ3JJWXMqQuRLeFSSI6b1Eidr4gT6iYgMLLGzS4OMjlYy9FVS1HE0LpH1v9LnSqLimdxcMViHMpQxtb/NSE5tGIpy0onEXBYT/BDy7CYUnJ87SImBSuY6q/Jan82JRxaOYl6f4i1DZMHVk4dkvAJvjJmlVdzzpSZyP41jIZQ8wsnR4wZz8lTpuAwlKwxig5nTp3OBKeDtgfuZzCaH7gPPdyJ1CVnT57OxOJS5vuqsrdvE46oGEuDP8Rx5TPS1vWMHEgYo1Ywo6iaI8uXk+grITE0T6QKWVk6k5WlS4j2CBKdMaJN3bx85Z+J7rdETrgpxj3n/i/7du7BCMcxoslhuUyZkqMrlzAxWMbsUG3O6/LgqnHUB0IcP3nSgOV+SNzoYIhZNVWce/AiHAWBrLkMFZVy4tI5rJ03BYfInm+k5NRF01k5ehTl/YsrDtmXaUrOmD6NsYFSZgbqc7aT5aXjqS0oZm7RCgwps8YFtFrG+sZR3ruQX577Svq11EW/XThoTs7r+LvGMb9oBaZ0Zz0nuqmyqPhQFpaMI+QIDouREnQpOaZ6IWODJcwvq8uZ75VVo2kMFHHSxCk5b94NwSDzq2o5c8bMdEw2m/hxEyZx/PTJaC4la4ypSE6fM43F4+spLfNlSzcGkhOWTqWxoogZ02uy9m8SmDSqgDNOPJZYVxtOfzFjj1xHQXkj445clxY5Wx//ORU+OHXZdAxHdt6OgMpRsydw8sRJBHzGoD0N/N/hTHHBjCksLB3NrCKRJUaiKSkuGjuZ+oJSVvj96OFeEvvCfPD535NosZa8SLaE2fKl37Nr+0480SRmIsrwEwOTit0sKqvnjLnTMFUzK2+nR2HtlIkcPX8SDo+WhbWV71OWT2fehDoqyv3DYiSWeD12xVQcWr6FDj9bjNjEPyUe3vgRHzW3AsIqUdsvGU0BBty34X2W1zbywIcbcm7j/eZm/vjRh3zv6RcwXViW3757s1TA0KDLSHDLS6/z4Sf7SBVITAeoCctGLhWrmrbilHz7z88wq6iCNkcKSlQcURMlZVkR9WABo4+4EJcqeX9LFx+0diBqC3D0pNDiRcycdh74CkgUFfLwyx8xf9FY/vjShzDaj7MriRbRQUoMj0Yy6OSDjjCPPPsBP/rri/SO9uDoNnB26QhDYrgVEiENWQB3/O013u1uJlIFoteygCu6ZdVMBgSyQPCtR55h6rRK2gpiyEqJ1iNQUqQtlIZX8u3Xn8XlT7EpsYPCEkEy5kRPqggBmkvH6Unxt+Y3WdPawIvtT1LvF/QkXfSmnEjAreoEXHHCejvPt7zI8633UOGKEjUcRA0HphQ4FJMCLYFHkTzR/ACbIq24lSSqgJSpYkqBIiQOxcAh4N5dvyakzqcrGeuzkA8WN9bvt2z6B2bSy/rmfYCKopnIvnLL0lSQhuAPmz9gdcU4frP+3WHLCQhTIFKCTb3t/P7997nlqVfRYlb+TAdWxea+5QSSps5Pn3uFXXs7UXtMHH1tQyp9MUnLtvzFXz3IW3d8n0RHG45gMRVrT2Pfw/ehd7TTdPttNJ64jh93v4jX6eC9TftwKwLdKzH7xLWaEGgx+HvzJxwyYQy/euNdEG6kxwB3n0xPKcioymaji/s2vM8t256jM1GI25XC606gCIluqPTGXBiGgx++/zwdsoUubxlj/+d0Nn7xPqJNXbx85V9ovO5Itvzg7yT3hymuqaT466eQ8PmQut5nzRckDZWUrvKDD57GYxbyRtNeQLHs7/3lrU0BhuCvmz/hiJrx3P3KeusrxcpRf48sDNjR0snv33yfu//6OophOYjTMVj25KShc8vfXqKlqxeZMlEkmIOqUiu61SV8+/6nWb5oDB1dUWs+Up9jF2mdF2HCj595mVCpm1f27063EzGonZiG4JEdGzmu8UMe3PUsUIBLTeFUrM7CkCoxw0FHIsxv1v+J69ZeSHhPlEBNAWfctZhQpZvT71rCb89/mc49vaw86CDOu+cKutwOFAFuNYUiJKYUJEwHhqnxi233MdaznH29UaTQLOt6HyfdVDBMwU8/fpqgCPFy0y7rwPtzDdZBSnhsx2Ye3b6R2999Y2BOx2CdI2Bnd5hff/A2v3xvPTgs0SeMQcJFlcTQ+d5rLxBJJEk6DEwhESnLli4FmA4ToQm+8vxTHN84mSajF+nv6ysNa5em06q6/eNXXqW6MMALe3chSqxaf/1VuQ0n6B54sbkZZ6EfR6iY6rPXIR0hjBgozhANJ69j+0O3Ib1eHtm0g/tbPiFRbiJiErVXsZbC0CS6zyThNvnu68/jK+nAX9yFo0Ah0uPGMFQUxaTAl8DrSXHzpj9xoTmWQtdWZpdo7Iv6iaRcqMKk2B2l3NPDC233UV8QIln0Iaf+chkPXvgcvU1hPvrC/Sz+2nI+/PYzdO3tpbqhmlE3HY5aLOlNRIkmHEgETs2g0B0nqkge2v0Ct7y+GbPQRKZAJETffUdiuAykQ/CdN5/F0aYSd+qYitWHyL7OznCCcMDX//E0p02dxp5ID9Ldv2xJ32nus+Xf/tRrHL9oKiX+PJbazxAjNvFPaRM/+oF7+bClJedTiSoE40IlfLJnD3o8nrE0eT/Mri5qgyXs77UvNOgRGmaHfQxSEujRSKTs4xq8fva1dOd8b6wqgsbaYrbvac/pMhBCUFrlZ3dk+DvgwXC4Vbr99oUPJRLqFWK6Pe/JYzSaEh02+VZYUuGmS9+ec86HQFDtKcSQu233JXDSnrJ/129K2NFdS8ywX6rfE6tnR3d3ziFcVSiMc5axZX9nzjk2Aqh2F9Lcau8icgoFM5J7vkuqO8yO+28lFe6bOHvSOpz+EMnuTrY/OOAWGn3yZTSOb2BXZ1du3oqgvqGIjT25XWICKC/2sl+zX07AqQpc3oE5A8nWLrZ92aq2no6pCDLhuxeSCuUu6yGACr2a7WEb3kIwUSll+277fFe4fHQ25XFtKQI9j4tKAlqNk0gi99whAdRMKWBHPLcDTBUKi+uchOX2nNeAAIoNwaNX3kesI8Fxd66isGLgptKzv5eHL3oaT5GbhTcfidOXe36FlNDUXUt3KrcTUiAoM2rYFg7b2vLH+ErY3N5h+0q/xOOlNWbvSlQRmAY5jr6fOBSbXrriuZ2ZihCM8YbY2Zq7DaiKoMbnZuu+/aj+wLDv+4utllQWsd9p304cmkl5Xbs9byTLKzqJGbn7VIGgyl1BW6IJE5Pu/VF+f8HzdO0ZcOkFawo46RcXsM2l2joTHXoRH++2nxekmAJPkwNTSoy4VSF+WOFZCf7OOBFd5qxfpQjBFWsWccHq3CuoHwhGbOL/Rmxqb7dtQIaU7Gxupun2O9l3y23onZ0Z3+udnez931t560c3I5L2dupEIo+4wVLN+cSNpio0t/XYToozTMn+1m77tT2kpLmzJ+/E57i0Fzdgqfx84sahKOxPhPPk26Qz2Wo7oVUi6Um1oWA/XJqvajlYT7H5xI0mVPZGeuwrDUuTvV09ecsLNHdH8trEU6k8lk6XC61/4myfuAFw+kM0nmRNnNW8PhxuD01deXibkj093fl5J7rR8jgODTLPv7M0QO3njsn4rOaaY2zFDVgiYG9PvnxLmjrz57u1M3++84kbAAS24gYsh8neuH0uDWnSlmyzXysISLmjHHvLKtb+YnWGuAEorChg7S9Wc9j/rrIVN9b+hK24AevGtSeSj7dkb0/uB6p+3q2xaF6buCGtMR0zFsuwmWfEdIbpGNLXDoUQ0BTOw9uUtCb1rJXkARyBIKrbQ2uiNy9vodlXrgdQBbbiBiyB05lsS/dx/govR3xnbkbM4d+ZS2S4HhuGlt54fidZkrS42XPvnVkLzxrdnbz765vZ8fCdGInchWe37Ldf6+2zxojA+ZTwaPZv+QQCNZXCiETQ29utSrp9F57e2ZlRWdewedo4UMgDsvTJvK4mIUBzqHntiJqq5rcZHkj/fwAxppRoeYoDWlZELa89UhEq+da4ORAoB0BcIvPeJAXgUJW8nY2qKp/a1qm6PNSdeBGjTr4sLW764fSHGHXyZTQcfxGKy5O3qKEAnKqal7cmlLxr3AxFsrWL3T/6S8Zne378F1JtXbZ/J+GAijE6tAPL97+jArIRj5HqCg/M4xkEvb0LMzrQN6hCy1uUVKDiLHTgK88uBn3lXlw2i1z240Dad//k53xwKPnbiSIEB6IXzViM5lt/SfNPbx8mcvTOMPv/93b2/epOjFjum61A4Mhb/BIcqpq3yLGCyNtO5AF0zgdy7CAyiqR274/y9xvezIj4+w1vkmqN5u2/1QOwicu+pmYmEhg5Cs/uvMca+dWjEcwcD+pCgNv5750VMyJwPiUOHzvOVrlLJIfOmmUVlysuTouc+PbtaXGjFRdz2g9+gJJlCLQfihBMqCnB7bBvIB63k3G1pbYN2zAli2ePsrVHSgmLZo6ybfyqIlg6rdF2lEcIGF9Wgtdp/6rHozqYUpLHZigly8rG29poJTAtMM1WvCgoTCicjV21ZYGgxlOFW3HnjLF4a0z01+S1da6uHZ2nncDKxkbbTlIVghVjGm2fOAUwqqwIn8v+5uXx+Zg1eULWfDsKg6guD4Zpsnz8qLxPpisbDoB35RjbGAHUe0sp1Kx8D3495awIMvr7Z+OsCJLcH2b/13+H0dadc1uGNFlVZ59vASwfN8qetyJYMtn+2ARQWxIg4LVvJw5FYXZtVdZ8G/EYe397JzvuuoV5WiCDt94eZv+Nv6D5+3djRuPWshOhKbYjlKpQmOSfnlfAV7qKKOyvRWbDe26xvTtIlyar6uzbiQAOqh+VpzCxVQTW7olIANWFhQQQmJEIelt7hsjRO8PW723tOOJxRDL3qJlumqwYb+8gUoRgxVj7Pk5VBMtqGnJ+349SR4gip32+BQpjCqbaClgTg4n+2QiUjNdTgZoCTrtnBYGaArr29PLs5X+mtzn3w4AqFJbV1Od9GCwLeCn1FeAIBKk9Z13OwrOFJeWMOekyHIXBrNsxTMmqqSMuqv+rcN70WTkXLxJAla+Q65cso6a2lqrBIuenP0uLm/qrLufrxx7L0sZ6m8qvkiuXLeKc5bNt+Zy9bBYXHbMwpzARAhZOrueikxbnrBQuBJQVF3L5GcspLynMyUlRFS4+YTGLpzTmjJESLjlqIectmWPPe9Esrpm7yMZmCEtq6rli0io0kV1OCKDMXch5o46hxFmc88JVhMIxNWuZ6J+TM0YiObTiJA6rONyW90LPEo7xTM06OpFo7cboTTA7NJprp6/Eoag5eZd7fFy/cDm1gdxrASlCcPWSRRw8fnTufAOXL1/ABSvmZg/owxmLZnDZoQtzz4cQgjmjqrn64EU4czgfBFDs8/LFlcuoDwRz25uF4Jp5izmsZrxNvuHKKUs5f8wykm3dGeJm1HfPpGBiLaO/eybFNRVEmlrZfsM9pLKIHIFgVlEd185aikvN/jAggCK3ly+uWEZ9UTD38gUIrli9kENmjrPN9yWHL+T8Q3LPKxDAyUunc8WK7Pke/GT81Be/g9rZi6Bf3PwSvaUDo7sXGUsQcnm5bPwaqj1ltjemk+qOYnZooW3MmqrjOa5mTc7vAVaXL+OScQfl7k8QTA1W8/kZK/BojpztO+hyc/385YwNFds+DFwzdxHHjp1ku6TGVXMWce0hayi/6lK0kuK0yIlv25EWN8GqSu77619RA9kfGhUhmFJexnWrluJ15ubtd7v4/OqljC0tzj2KI+GqpYs4ftxkW6lw5axFnDtqdc7vBXBk9VzWVJ6QU5xa8wcbOLzydBItRoa4OeWXy6meUcIpv1xBqMZH2+5WNlz7JxI55uxJKTl/zMGcOHaKLe+rZi7msuXzAXAEQhkip7/wbLCikgf/8jccQ5ZSSPMWgvFVJSwe32Czp88e/3GB09DQgBBi2L/LLrssa/xzzz2XNf6TTz75NzO3UFXop8bjz/QW9rVNKWF2aRVBl5vpVRUooSClZ5ya8felZ5xK/ag6KgsLWTixFkMbsOsN/s8dVJlYWcrsyTUYhXJYDIDhl8yeXMO40WWIWkc2SiQ9MGNxPWWlfgLTA5jK8BjdAQ1LKvH7XIxaVIU+yALe/89UwD/ZT3mpn1kL6ki6h8dIQFQ5qCh2UetXMHzDeae6wyTVKHMm1jC5rJRgUbatgNQMVoytpsLjZ1qxCyHMYTGqYrCkopiAw8e8ogo00T83ZiBOwWSCz0Gpq5hZgXG4lMSwGJCUO3TqCxqY6h9LgTp8OwBqby8/Pudmrj7uHDxd0YzvEy1dfPT5+/n4Kw8ww11GuddHnT/QfzSZx4Zkakk5RW4vsyuqBqzTQ9JQWVBIjT/Aovo6pJ49xis0plaWM7e+Bs0QWdulosOCxlrGlZcQFM6sMaQkixvqKPcXMsodSBchzGjfBkwNlhHyepgfrIYcnGoopLYwwOKi0Zh9qey3GfdbyV0pF9NCVcwMNSIcXtRAAc6KII03nomjxLpJiVCI2x5+gPrGRpzBQoTbmbkdrAeBBaWjKS8opD44cHMbWr15UmkpRW4Pc0ZVp18LDE1BSbCAmlCAeZPrMETWQ8PhUZnSUMHMsVUIh8iaSlOFuRNqGVtWjN/nHrYdRyBI9bnrKK6qYuf2Hez5zh3ENu5MixutrIiKr1yAWhRgYrCckLuA0d6J9E+1GpwDKcEpSqhwl1Llnk2P7sga050KUO0ZR6NnPN2JgmHfA/QkXYzyTmWUrxyXHswak9IFMwsnUOIpYLSrBJmtnZgwsaCCIreX+WU1A+VfhiSrzOmjIRBicU19zjEcp6oyq7yKOVVVuMqClF91SV/ph3aaf/Qz9LZ2tJIifvrgfSyeNgV/kWtYXwpgKCYLxtVS7PNS1xjC7HerDYoxFUnj6GKKfF5mT6nCULP0zULir3ZRXxJk5ZgqVHe2vkLiC6SYW1PB3KIqKjyxLC0J/I4YK8trqfRUUO+GbK3JIZLMDTRS6AjQWFpDQZGrT9wsw9+3MnWgws31953NqFGjKC4tQfVkHz0POn3UestYXJ073w5FYXZZFTNqqtJzLbVAiIrjMtfP+soPbmbhjKkU5Sh/I6Vk7tja3Oul/YvwH7eJv/nmmxjGwGTODz74gIMPPpgTTzzR9u82btyYMYO6tLT0X8bRDr/fsIGdHWFLASuk58D033//vnET8+treHT7JvSeMK2/y1wNs/V396GWBrh7w3p+9PbLGH4TUzcRCQUhQaoS0y2JqiY/fPNF3t23n0SxifSDIyIs66MKKZ+JcMANzz/FrGAl3T4dcww4u/psfQqk/GC44eaXX8Y0JJviYeQEgasLtKgEAUmfIFUIj27dwoK3N/D3zZthtMARAUevBGlVkE36oSvRxW9ef5ufvPYayUrLiumIWMduOCBVCFLvYdUhhxAOt1Ny1cWoFQG0qMU72RNm7/23oRb6+GK9n6XT6kg64zhLTYyYhtQVhCJRXAbCYfLjj58hWBClNbWHGj/0Jp0kDA2BxK3peB0p3g6/w0utz7Kx5zlqPRA1nESNPpu4ouPT4sTMDl5v+wsfhe+i3JEkKTV6DZdVTVwY+NQ4mlB4reUXbOptJ6DF8KpxYoYDQyqowsSjpIglo+zev5P23d00X/0bZv3oBNSSILHmHj7+wgMk9nWhILn3k7+DVs7m7ra+mgWDGkBfx/p00xbu//g9/vLxx9bnkmF22j1dXdz91nrueuJNVN0SGLLfkiwtG6yuGPz4iZfZs7MTJdlX3FkbiOm3LX/ngWdYMrqeRE8Kh+yzmysDMcKAO//6Gi6ngy0723HSZ6/t6zGUlPXvlfd38IdXN/CXtz/CgbWdfiu5ooOSgGbRwz2vvs2tW15H6g6kaiIcVhV0aQpkUiEJ/M9rL7BfacVw+qi8/myUZAy1qBBdF+iG5eO+tfld1t72DR5p3QQeJ6aU6TQZpvXTzz5+EY/p5aOO1mE57Lfnv7B3B/dteI8/vPchaNYNW/TdR6SwcrE/EuFXr63n3ifWW8duWtZwazvWdZcUJjf//UVauiMYmuVCF+bAnDJDBaHAt/70DMvnj6YnmbBy2B8jrL/RikP4z7wA5Xd30bpnL9Fv3wGAVlZE+ZcvQA1ZAuOlfTt4cNtb/Hnvm4Abh2LiSNvEFRKGRhe93LfjOR5rfpao4cel6Pi0BIow0U2Vbt2FlA5+se0v7OwxaYt56Eg4KHQk0BQTU1rLK6RMjf/58G8s9M2hPaJj4MXp1FFUq3q7ntIwdIXb3n+dEqWQ9/c3k7bl9w/6GYAueHXXbu7b8B73bXjfOiV9OU5fAia06r3cuf5NfrPxHYQYEFGDYUiT77z6HBEzjqmZqBV+is89heYf3JaOKb7gZH668wN2CknYjGH4JSJp9Tn0WcmlCne8/wYVBT7e7tgHJaAkJEpSpGNMF7zaspt7P3yXeza9DWWgJEyUuAApkA6J4TVpJsLPN7zO39pexlsUx0glSMUcSFOgqCYObwqHBj/48DHGBPdS6u6h0NlDOOEhZapowiTgiuNWdR7Y/RuS+hQ0Wql3SSKGm4TUUJB4lQQeJcWG8AMUOKro0rZx1u3ziPaaFJS7ARMVE02YxEK7uOmhb3HLnlfQckwkDycj3LfjaW57Y3vW78F6YPj268+itaqYfZO7U12d7H848z52w1VX0pVy0NEbG74MQN/v9774DqctnkFtSTDn/j5r/P/OJn711VfzyCOPsHnz5qzzSJ577jlWrlxJZ2cnwSyW6wPBZ2kTP/juu9ne0ZlTAatCUFVSyPbdO2n6yW3pSrrFZ59K+6/vT/8+6frP0V3ozLkdsOyReQw71tNwXLWfFwOUqQW0R6K5eSuCGn+AveGu3DZxIOj30pbKvR29K0zTnbeSareerMo/dylaURC9I0zzj24fqCx87SUExnvQbQrICQRzqxL06OGc+1NQmBMSGHI3JtbdKN6TItmrp59wAIodHlSa6dwfx12g4SkcrvVTpoM23X7Nhs59MX517mvEmrrwVAWYfP2hfPi9x9O/z/7xCXjK/PSG6621RHJsRxWCOrOEPa32zp4SxUOkLW7bThQTVHvHKkjwGAopPXe+FSEoKi6gtSuSs9aMqghK6/zs7rV33PmKnbS6c0/4BFA0iRrIV5hV4tJUkjYONwVBSC9iX6Q3/TQ+jLcQNMgi9rX02PIOKS56O+w59WnHPKxBlKokDBveQuBM7eGDr92c/qz8q5fgHlufwXtypYOwbLUtthhyOjFE7nlKAIap0B6zd6RJCdHOIuJGboejIgRVZpB9PRFbW351oZ+mbnvXks/tpFvmbwNSs7ahd4Rp+cEd6K0DSxBopUWUXXcx/uIyW2emKgQVbj/7bByOqhBUhXzsjXXZ8g75FEyvfb7daooZZU22MSCZWdiGIXMbTgQKUtTRmeog1zxCgUJHcgIfdOm287WMuJ/t++zbgNDBtb+vhEpXJ3vutubcOELW+ln7/3Qfqc52XMES6k+8dJhxoR+qIjhv5VyuXLPYdn/58H+tTTyZTHLvvfdy3nnn5Z39PXPmTCorK1m1ahXPPvusbWwikaC7uzvj32eFvV32FVQNKdm/rylD3JRffSnuUQ3ponN6Wwcffe/HEM7XIR2AFpX54zRFoTNqf5M0TElHb9TeJg6E4zFbh5AWCFJx6cBxNv/oduJbd2SKm89dilYcsBU3YHU2Ed2+srGJSdzszBA3v7vkNe4592W69g/cYJNmF+F9Oj85811uveD9/4+9tw6TpLr+/1+3qtp1psdd1t1dgcUXh+BuuwQNEuJOSEggggQNEAIR4iQhIQQJ7rKwsK4zs2M90t5V9/dH9fRM73RXTx5I8vk+P84+8+x095mq06dO3fuue8/7HGIDowfC4qR8cFX4TBBTEyC2t49XL/1lDrhxVvhQhUJ3vIi/paQ7Ei3aZ6ovEi/asG4MrHwAS3ADZh+e8GDMspGebki6I7GiMdebihdlkklhbc+QWIEbMCfc7ph1J/hUJErb7j157U71hdHjZqz0RRPF7R6DzQgswQ2A3hfmgx/fl/Ne909+Sbo7PKwjJeHUoCW4AYjo0aKNgNNG8e0CKYUluAETUHZHo0Vp+cV0AAZSiaJJ7UOr5CPBjdmxfB1aeSnpzh723fQTBvZ1WR4HoCc2Brvj0aLspogRL2q3XS0+oqhgCW6GZFDvLwhuACQG3ckIxaKzP5EuymwTafPzVF84B9zUnbMeV0MzdeeYOTmJcJdZR6tA41kpYXePNQPy45b/UwDnd7/7HeFwmLPPPrugTnV1NXfeeSePPvoov/nNb5g4cSIHHnggzzzzTMG/ueGGGwgEAtmf+vr6j81mv9OaPaEIgcfjRfX5suBGKwkCZJvOaWWl2PxeKMJ8GZOMYYvTkLIoG0sRApfdVjT4nZpWdFLWgiUmiBkCOd+9NRfclAYZC79dIos2BxQINOFCZEI7GUkT6UnQuzvK/SNATn+bwc1nvkrXrjgDPUnieYosKkjiAyn62/OvPPS3x0gPJnBW+Jh6/SE5n029/hCcFT7A9HexcgIKpr+LDpI2tThteYzb3MXU5BjjxG3TLBl5AE5FK273WGocMAa7AZeF3UY0Ruct97Ltxz/C6AvnfJYK97Ln7lvZe/+d6PEYDptaFEyMSaS13alwLzvv/DGpTM5N5RcvRqsoJb2vh44b7sqCHAE4FXtR8GITxf09Jgq4kGPqcO4q1vwScNuKjyeaMgZavhwNbiquuQjHuCYqrrkoC3I6vn9HwTo5pk2iYGL0SLtd2hjspvh9mTaKU9LNXbRi07IoOg6CwK3aii4U2FSK09szrWoUhwPV482CG1vAXKmxBUqoO3s99kz9LMWe3zYhIOCyni8/bvk/BXDuueceDjvsMGpqagrqTJw4kQsuuIA5c+awePFibrvtNo444ghuuummgn9z/fXX09fXl/3Ztcu6gu2/I8dOmWw5KRlSctzMOVRccl4OuBkSrSRIzZXrWffDW5AWF18RgsW19QQd1gFS4nKysL7O8oY0pGTttElF7T5y+kTL4FeE4Kgpkyyp5IoQLKyuo6KmmtA5uQnWoXNOMcENELC7WFxuTdnUpWRF+TzLAVcimR5YkX268Ve5OOu+pdkePPef8xy73uzlznNfo2tXnLJ6J1c8MIuSqly/ChTK0i38Yv3LPHDus/S151ZX7WuP8sC5z/Lop1+gsdvLhhsez/l8ww2PE99nFuwyMDimear1NUFy1MRJRWm0R84wO0nr8Rip/vAoHUUIxgftBO3Wt7bXZWfx1CZLYKIbksPm56eSZ+2WkiNmTCpKoz163CRLexQEM0tqqHT5LPU8moOVVeMsY1eXBse0TilotxFPoA8MkujqYufdt5IK9wIZcHOP+YSqDw4iUkkOnzXJkomkCJhSW0FV0Jr+67bbOGBcfip1ui/MnrtvI9XTTUltNdXXX4hzfCOV11+QC3J6+pDAwdWzLUGXKhRWVsyxtFsgmOirptoZtLTbpdo4qN7a32lpcMzEyUXuSzhqwuSi8X1U6yRL8CYQTC4pp6G8AsXnzYKboXFEKw1Scc1F2MpDlJaXYbMYU9PS4OiJkwt+PmT3Ma1TivhbcEjN1CJ2Q7WrlnJHheX5NGGnxbsCYVGEVKIzPbASa8gsObBybtE4OaJxEjaLFUoBNJeV0BwqQXO6qD3jQurOuSQLbobEEyrj7K9+j9YTLypYyVg3JEfMsR4HPm75PwNwduzYwRNPPMH555//b//tokWL2LRpU8HPHQ4Hfr8/5+fjkrNmz8Zjz7/yIoCpFRVctWgpU+sasO0HboakpLKS61YdxEkTplme6+r5y7l64TJrnYXLuWqZ9R7nCdOnccmKhXgKrBgJYFJlOZetXsLkqvKCt5HXYWf9ikWcNMPa7s+sWMq59ePpvi+3sWP3fQ+T7gmbds9fyhVTV1vessc0zODUxkPxaPn3jAXQ6K7hiJoTqHEO11sI7Ady7j3jWdp3dFPTGDLBTXW+QVAy2Xk8Rp9GeHeUB8/9Vxbk9LWbr8O7oyS7BX+58r7sttS8H52U3a567cpfE983wEGVc7lk6nIC9vyDrQAmBMq4Yv5SZlZVFfSBy2bj00sXc+zUVnY9cic7HryVVH9vjk6yr4dXb/8OHY/fZ1lRdP3hi1l39GKsBslD50/kwiMWEfA40RMxkoPhUXY3V5VyzNR6Jof8BY/ktNlYv3IxZ06dVfBcEsk1C5dz9fTVBXUALpu6gsunrLKmP9dN4YpZyyh1uvJq2UqDzPvadTS3tJDq7WbPPWY9jyFwYysJUXveenyhMtavWMjpyyzslnDF4cu48vDllnavW7OIy1Yszgu6hMOB5vHir6zimaeepqquBgFooWAW5Cg+D6rTQZOvhPWTVjEz2FzQA3ZF4+zmgzi2blUBo01/n9uylssmHZJ9L5+cP241V85ahlJg8hbAwfXjuXz+Esrc7oJ060Z/gKsWLWFhbV1hu1WVSxcs5vwZhUthSCTXLVrBF1YeSsUV5+aAmyHRSoN84cF7eOzPj2Fz58+hE8CBDS1cOX8JlR5vQbvr/QGumreUpTUNBe22KSqXzVrG2a2Fx10JXDH5YI6v+1RBHYDDq49kYfmZKAULmgoaPQtYXn4aflsZ+e9fQcBWwdqaY5hXMrHguVShcnbrGtbNWGhp9/XzV3H1gcuQgOp05a3qfMHSeVx3ylocrsL+XjKxkZmN1QXP9Z+Q/zMA57777qOiooIjjjji3/7bN954g+rq/67jhsSharjTWraxWA4/VAe/tKMpCl5b4QRiu6riUDVK/HawjeyAnfkLIbF5dDwOjbISDXsgMUz5GPoREnsgQSio4vFp2KqTkNMFO/PjSxGoVrDbVZQ6iRzR/TZLoXQaOOoUbKqKo1pDd4zWkZpEVArsdhVfqR3dYYyiYkohkX5JX88+vnnO+cPbUtesz8nJ0Qe7CHjseG0aXns6Q4/Mtdumpqn02LArKiFHGjWPwzWhU+E0WyOU2wX2EZ3CA1VOjr1hTo7fb7z9DOpq9vMPoGAQ0mKMa6jnkT//kFC9Kwtydr3ZnQU3wWonKoK9u/bgqfEz7+bjCU6rYe7Nx2dBzutX/gqtdwCHquJxKNnmiftfX79Tw6aoeJ22Ud8+Gyc2FYeqYpcG6cggqXA3Ox68jWQG5KT6e9n+s9vYs3Mn/eEedIsS+z6XA5fdhjYyQ3Y/HrDf7cCuqajpJFseu5PNv7+V5EDvMCNJApF+Dj14Dc/9+Dukh6rGjjRcmr2xHKpK0OHKx441mVsIPDY7Absz46M8P0ISsDlx22y47UbuATI/ijAoc9qwqQoer8hzDwCqQUVzGX//xxP4qipJ9Xaz+06znoeWATdaaRCC4LBruCucpNyjqcZSSFIl4PbZcQfspAImbXj/fymfxFNqx+W0QVBml/yHPlecTqouOp/Tf/wdmpsa8bqH7dZCASo/dwGV15yL4rUT8ChoiopLcaOPuA5y5DWRNhyKDWEEGUzkodIj6Iu50YQHu+FlcMA5qku4lBCN2HHoftzCjmPABiObYA/9xAXBlAebouKL20eXCgBIgz/pQFUUSqUL9mdSm0bhTGg4FRulNpd5nDxxoqYFXs2O3+5EdbtGgZshaa6vpyIUQnNAvjiRikHAa8emKrj8IntNRp5QqhK3T6CpCqGAhsgzNgtF4vHruG0aNR4Njz0xWgdJiStOiUPDpzlwqem8NtmVNEGbE0W4iBkejMyW7chrkjQUdEIoio3uVBkJXR0VA3FdpSdVjqrYSadKiSW1UTGgG4K+iA9NOAnizjbZHOXvmIpfceKzOVBTec1GpCFoc+KyaWgjK1qP0JES/A5n0S2zj1v+5zRxAMMwuO+++zjrrLPQ9stVuP7669mzZw8PPPAAALfccgtNTU1MnTo1m5T86KOP8uijj/4vTOehV9+iZzBmjkdDHYkxabZCCl7ZsYc7XnmFV9r3FDxGVyzK7W+9yL3bX0J1SaRDR6bNAjVCkaBJpCK4+Z2n+SC6C5s3heZOkehOY0ST2Mr8aK40QoEb332cCb5aEtEujDI7qvBASjEHTLeO0CQ/3fwi6Cqd6QhGjUQkBErCDDzDJZF2ycvdu7jtrRd4sWMXhECkGNaxSaTdpHXe/uaL3LXhNQyvxHBj0iyl6Qdpl8hwH8cechgD7R2Zeh7noQVKqfrsBbTfeBfpzh7av3MXX/a7OXBOC4qq43WmSBsKhiHMlhGqjiLgke3PU+OJMZDuxW+TpKVC2lARSDRFR1MkWyKbeLbzUdpirxHUIC0VkoZGb1uc33/utRy/X3PxbXz9oVaqqh3EDLPTriYMnCKFIhTe6/4RO+xdfOaB6Xz/zLfp2hXl/jOfBaCs3sn626bw0Be3ERJlLPnhYTgrbKSMBK5qF8t+eBTPX/Z7nCVOnou8gvLBePbFB1A0mbnhTV8KYSAUeLN3Dz95+0X+tWuXmWk4YqAZSk3pTcS54+WX+dXGHTScsZ6dD95GKtzNzgdvo/roU2n7/c9JhbvxlVcy8cRL6U1rBUH193//LAsbatF1IzPy5X4ugF//8y08bgft+8wS7MmBbjb/4TbGrV2P3VNCarCXxx66jeRAN7ZgCH88AXbX8ENlBoP2RxPc+ezL3LvzjdErBXL4v++88Az7nJ0mRTiPzULAje8+waqaRnTSOGxm5+shX6qKgRDwq52v4lF87I2FUVyAIZCZQjZCNRAqvBtu47G+vbhPP4GBm27NnqP89FOgwU9KM+g3Etz22ks88urbpP2Q9mS6UhtgaBLDAYoCNz7zDJ3RKLob0s4RnasVsywDCtz47LMs72okoabRS8wO2CJtOtqwS1AdPNbbzrj3n2dPrBfNgUmhNwRqpQ+hGiiKzvv97dy7+V8827kRUNGR2VwaaZiPBhGZ5L4tT/PLna+RMpxEUnYcWhpFSHRDIZ42Wz3c8t7j7OqGZMJGIqFhd6RRFANpCJJJG1IKvv36U6wJtpOMGygxDWwZBpMEkVQQhuDRdzdQY/eyu7sPDWF2Ss8M4yINii74YKCLu55/lb9/sAUVBZmQpo4AdNNfUZHijudf4hdb3kHRBVKX5iP4EAg3zIJx3372GQZs1om43371Gd7qbiMhU2CXmVbwJgUcRYKA32zZQJ0vwLbBHvAAuiBb8Eg1QIUP+ju5470XeLztfWwekDroadUE5aqB0CQxBHd88CyvDjyN15HCbUsRT2tIKVAVAzUewehNcdeW39PkbcOu6GgiTVoq9LfHsHs0vH6zHcRf2h8mnPyQhJEmhhMNAyXzMJeSKhKFDf1Po6ot7I7tAwLYRRpnplZXXLeRlBrQzi93/p0/734P8KAqBk4thRCQ0hUSaQ1VGNzx/rM8+sJWlLSKTGaurcj4Oi1QhMINzz6DrcdkZ8oEw6UpyMxzwA/+/jxb93QTT6YolPv81zc/4LwD5zGp1nqb7uOU/xM08b/97W8ccsghfPDBB0yYMCHns7PPPpvt27fz1FNPAfCd73yHO++8kz179uByuZg6dSrXX389hx9uXXF2pHycNPFVP7ibtv7CzdFUISipdtGeHLSmGQY0BrWoZb8eRTGw283HKD0SZ+fXHiIdjtD0jbOwlQcAc66Kdwyy+8v3ogY81Hz+TFRP7taIgsCZ9hJOFH7CV4WgUvPRMRixtNvvcDCQThbM1TGiMfb94B6MwUGqv3AeWiiY/SzdHabtG/eg+j1UX3cW5bVG9uk47/dHMKdigLhR2N8KCnMCaRS5m6E8nN62OLec+WY25+asGyfz4HUb2bcrRmWDnW881Ep5zejtuqSh0aObS65bXu/ju6e+lf3smp/PpHVOgIF+g2f2NuGqGL00G903iOa24fS62N7VTFe8sL8VISiPh+joiVn6O6DbSYRTSGlSNodAzpDYgiGaTl2PS81P1cyKlDji1v1zFEXg87noHYyRHOxl0x9NMGP3hWhcfSo7/vlzkgPduErKqD99Pao3WPBY9lKNPnfC4uqC0AxsoeIUYbdDL9oawq4H6I7HCp5PEQJfp+Sdr9xMumvYf1pZKZVXrsuuDHiwk4gUb5JYLA9XIhF+WTQHpaJCpSc1WNhuBI0BB/16n2V+hV3YiaR1S7vTaYXB/vz5EiMMx97jsM6xEoIy3PQMFC6DoAhBud9DZzRieSybSyGmWbONpJAY7mKJ3xKbTSFtWOeglLqcdMUjlv6uDrroSQ9Y0/JdOn73aIZQejDBG9f9lmQ4xuIfHM3s8cPArL89yi/P/yfuUifH37och88OSEJaEsOCw6mg0pNupDs5WHC8FAh6I81sCmOdhxN1EO20JreINDh6igY4zrRCSrc4lyI4dflsrj16pfWxisj/czTxgw8+GCnlKHAD8NOf/jQLbgCuvfZaNm/eTCwWo6enh2efffbfAjcft3RHopaf61LSn0oUZRoN6sniXV1HiBFLkg5HSHX0sv0L95PqNG+uVFcfu798L6mOXvS+CEaeSVUVgsGkdUEdXUr6k2OwO5W0TEBU3C4qrzqX6i+cnwNuwMwxqP7C+VRddzaq12EJbsAcJJOGdS0VA4O0MTAMbtpzwc0VD8yiZU6Az/9sElUNdjp2JvnCaVvoahvds2boVu1pi3PfdR/kfHbfdR/Q0xZH8zjyghsAd4UXu9eBEIKBlLW/DSnpjxf3dzSRyiYz2gIlVB+dW1G0+uhT0QqUS88RWZw9oQhBJG76xe4tYfza9dh9IZID3Wz6w4+yYGfC6ZdbghuASDpZlN6OOrZnrWJ2CwQDqaRlNCU7e3n3qzdnK99WXn3J8Lbpzbdnc8OiyTHYPRYRFL22AsFg2rqcgIEkko4XZXbF9FTBvJkhkWOgiSPHVp5iMG76e6hp6P5iSEl3RzupqPV4mdD1okzCsbAEBViCG1Mkgylr0G0gGUzFMYr4W5fJvP2j0rEkyXCM2N4+Xrz8d/Rn8viGwE3f7gjRnjjJaDpjt7AEN6bVkogetxwvJZL+VLJoI81E2ihOEx8DiVARWIIbMB++u/ojxQ/2Mcr/CYDz/7KU+6wLwamKIGh3Fr1pfZpjTAP3kNjK/ObKTWVJFuREN+5ixxfuJ9XRi62yhNqvnostFBh1HF1KfAUSo7N2C0FgLHbbrZ/uAHOvPI8dYOYYKG4n0hCWiaNgDpIOxboolYKCTfFnWQhOj4av1D7MlsokFFfUlvH1h8ZR2WAnGNJweUcn9SmY4MbcnjIB0jU/n0lZvZOuXeb7gx2DRWm0UhoE7HZLLVUIgq7i/vY47eiZgTvV10vb73Mrirb9/uekB3otjwGAoGjZdMOQeF3Ddtu9JTSuzgVUzQeeRkVlVVGauM/myNpd0CR9bAC/GEXaQOK3OQr6O93dR9vX7yXV2Y1WFqLyynU4W5vMlZuRIKc3jMdhL2r3mESaHdWtVSQ+W/7E6CFREPhsrqI+cKv2oiBIUcbwvQRF6wAB+F0OjEzT0N333ZrtND0ken+YrXf+kD0Z+n0hcanFy04UX04zVWxj6HDutzut/S0EfpuzKFjUhD1vQT1n+XCdrOjefn55/j/Z82ZXFtwE6jycdPdqfJmu7xKJKopT7r2qqyhLLmh3FM15cY6h7IQcA0owJAV71mVtElAZsGYbftzyCcD5iHLS7OnW1GZDcvq0WZY3rYLg1PFzLJ9MVCE4qHoSVa5htoqtPJALcj5rrtz4aypp+Np52R4++4sQgtMmzC7SAVtyxtQidgvBaZNmFm5CN2R33XjqPIWbSAqgyu3ngCprqiXAARWrLW9sA4PpwbXITEaky6dxyd0zuOLBYXAjUGj2H09FjYtv/ryVL93XgseXe3MKVBx9M7jlrA1ZcHPVAzNonRPgqgdmZEHOj856l0mpZsvuvxI4pcW6SaouJadOn1nU3yfPm46qKDnbU7ZgiIazLsUWDJEKd9P+qzsptxuWA3fI7+Hg+ROtO8ojOWHFjOzr5GAvO/6ZC6i2/eMhDm6utAS5ihCcMm2G5YSjCsGyqmZafCFrux0eDquZbt1RXkpOHVfY34rLgeL3UFZXS+WVF+dQjIdAjuLzormcnDJ9Bna1sN2KECypr2d8yNruUpebo8cVLylxasvcoisKJzQstAQvCoLjGubhUAqnWCoIFlY0MilYmCUJZpPMYydb261LyalzZ6CPaBq6+77bsiAn1dfLzntvJd7dhT44iFFga1wVgk9Nm47TomaUWXainimlFZbjl9/u5Phx04raffrE2db+lpJTWucVpYkfUbsQp5L/odFZ4WP+zScSqA3RtzvCI2c/mQNu/FXDD21Oxc2M4EGWtXAMDFZXHFh0BeekpvlF7T5x8nTcFjWMFCGYVVfNjLoqy3nO47Rz7IKpRctOHDV/SsHP/xPyCcD5iHLqvBlUeD0FnyqWNTdw/rx5LK1tKHiMaq+PC2csYN3kJQV1NEXlMzNW8fnphw/l+AMmyKm98tgc3bt+eg+u8hIKGXXRxCVcOHUhVZ7CaHpZdRMXTFvA8rqmgjqVbi8XzVzAp2ctKqijKgrXzFvOl+euMa3Jk2QqgS/OWcPF49dYPuWe2bKCI2oOIWQPFdSZ7JvMkrJjaHAPd3d2+bScOjdurZSZpacyseRCyqrto8ANmCBodsOl1FY2UVbv5MoHZlCaAUil1U6uvN8EOTVVjZw84Vg0i8nkyOo1nD1+CXWeYEGdBeUNXDBtAQc0NxfUKXO7uXD+fE6d1pILbs5Yj7u+mYYz1mMvCTHQ2cH7v/zhKFr3SLnu+FVcdNRibLbCk/epa+Zw5sHzqKsIjMrBGX/Updntqtu/eAXzKwvvhZd6XVywfD5XLigc34oQXLdkJV+ceWjmnfzZyJ+fcQjrJ67GYQGWTmtexPkTF9HkK81/LreTQ7/7WV7513McMTe3y71WGqTyqnVUXno+ZSWlXDx7AVcuK2S3RBGCz65cyRdXr848oBSwe+VKrpi7NDN5578vz5o6m/MmLqLVVzi+Z5bWcFbrUg6sKlyaIWB3c1bLSi6duKaQ2ShCcNWUQ/nS/IPMB4YCyd9fnHcgly5ebBbyKzDGnTZjBucumsek1pZsVdshkBPbuS1b/balpYUzb7wpL80YzM7dFy9ZwDVLlufYkGM3guuXreAriw4sqAPwxYUHcNnMJbi1wivVp0yYyQVTFzIhUFZQZ1ppJRdMXshR9dML6vhsTi6asIzzW9eaJuTxk7PCz633/iTnvcO+sTALbob+5siaM1hW/ilsiqtgBfEZgYM5qPIwap31eXWkhHpXI8fXH8jR9TPzH0SaNaUunrSc65evyL63v44APrdiJdcesaLgcQA+c+gyLlxTuPQIwNHzpjC+urCv/xPyCcD5iDIYTZJoT6CMpNBh/q7FoWf3IPFkin1dEZT0aB2hw0BfksFEkh0DvQWfSZJ6ms54hH3JLlz2ZJZunOrsY8/Nv83RverCdagDe1H3W4IWSDyOJD3pdiLpOHFtAEUdSbc1jVJtOt2ym1g6RVuiL0NZ3d9wSb+MMZhKsqM/bGG3Tmcswq7Bfgxd5B2PDF2we7CfrsQg0bQcddNKCYahsGOwl5gepy8ZQ0qRo2dSIAWd8T5SMkl/qquADsTSEZJ6hP7ErgwLZ/T5UjKN3ZPgh7/6HJc+MHtUIcCSaieXPjCbW35xNbpbEE3ro8q5S2n2+9kT6yaSTtITj2cpkyN1kNAeGTT9Pdif8eV+/gYGknH6Ewk6UymzomgG3IysKFp/1npq6hvw+IPgcuT3twa7wn10R2JEhT6qgLAEDJtgZ7iPaDJFW7iNTX8aAW7WrsdT1cy4Y9bjLiln69at/PobnyMVDY+yWirQJ5P0xRPsiPWCbf94A4QkZUuzLzZAe6IHuy01alVQAHZbirZEF33pAez2CKqyf+sDicuWoifdTkxPktZ6sGujbzqHLU3aH6GstpJOrRPNnXvzaiUBtICdpK+PAT3GTtkFwdQIynlGbJJ0KEZHuo82vQdRHjMbTY4UVSJCcfbQRZ8+gL20F82ea7cQErc/To+2l4SRQLV34rKNHlDc9hTYOojrCboSXagj7st0JE6y02zumpIRBtNRtvWHSacVEp396JHh5FZDQjQpaIsMsDc8gBErAHDiCjt7+ukZjJIKp81mlfvpqAnB3vZ+ookkA10xHB6zqu0QyNl1j0m/d5WU8ae/Ps6g7kDd/5JgjoOJgRR90Ti7u/sQqTwjigQ9Lunoj7Cnv9/sTJ8PBKSFGd+xKNFUapSO2VhVsLOvj1gqSU8ykveeE0B3IkIslWJvtDvDVss9mEAS1+P0pWLsjXYXBByDHX1ce+EVOe//5QsvZXNyDAR9SSc7o330JKN8MOgjqueCBV0KupI+3u5PEk2neKPLTn/SNWo86Uu6eKPTTiydYkt7hHRMG2WXnlbo7VboicXZva8PJZ7HlwYQkXSEB2jvHUSmZF5/Cx32dPXRG40R1VOjdiIkgGI2C/5vc5r+T7Co/tvycbKovvvbp3n42TfQDYlUYKgat5Im21H4xENmct+GNwFz6TBLfTTMG00VguNmTeZXXa/lO4V5PCGYE6qlR2wzExElxDoG2Hjdz0m2h3FUBxl3zRFs/e6fibX14qgOMuU7p6CGAuiGWX/FphrZiePAssX8Zsfb6FIiDRNAQIb6mNE5tWER9737BhnDh4NbmD+qEBzXOo1fbtxgaffs8mq2xDrpS+a7i8wD+mwO5jf6ebNnR4ZJNtwlWmZPCusmjuf57n9l9rvz63yqbgHbBx7J+WTkuQQKUwMH0BP9VUEdUAjap7IpPkhc78+cS2YZqzLjBLvipi1xABv6N1vaPd15KA9veSez353vfHBG/QIeePXtgiapQnDM+Mn86aWNpOMxjEQCmy84fAhhJvs1OVTCPToDI8t2jDyVMCvrzqqu4tXNu83tJUNm49WkgZo2Hbt8Gr9+5lW2/OYn6NFBWo5dj91XglTN4yQHetn3p7uJaXZqz7zQrGJqjDiXYuahHTFzIr/ufGd4FW8/HQXB5FA5cVc73cmICWoz4FMIs62AEOBUbSyprOL1HtPfuiHQh8oJKMOxe2jlEn676zUMJIYh0HUzvlVVZyil5Pi6Jdy/ybznpAFGyrwxFc1AqBJVKBxeO5XfbX1/2O6kYtquSrCb13pioJywPkhnPNOUNKmYdGNFgsPI2K2xoraGl7o3o0uJnlLQ0woIsDnSWbtPaZ7DY3tfzH63VKbOiV3VUTIA69jaJTy6+wXTbgmpwSTvf/5XpMIRpt90Mu7KICvLZ/Dols0kusLs/OJP0QJuGr50GorHhZTmJm+rr5zOvQrtkUHIjksSpMhcH4FD1VjlbeRfm3eYY4WQ5rWXQxRh0/BTZ8zg1y+a8S0FRPZuY8fPfpQNu5ZTL+Xck47hoVfeyob3yG7iQppxsmbaOP60Y3Omc7UcfgSXQyYKmktLGHQk2Ds4YOqMnFClaZNdUVne0sA/d2/NbPsWuOemzuTnm95AMvrBSmRY5WdOns0vdr6U9ff+OqoQHFwzkXejr2S2hHKV4vsGeOPKXxNr6yNQF2TRl5bx3FefZnDPAL5aL4fefiiOCj8g0ITK9OAM3uh9GwMDu0jjUNIYQFR3ZEeXuYHD+MX21zI5OzpuzSQxRNM2dKkigLUVS7nrjaGxWaLYzG1rQxdIQzHtrh/PM6/sIG1k6pipw9cEw/R3fTCAbRB2ZSppZ90nh3/VVIVVk1v453tbzPEkz3wBcN9FJzK/tY6PIv/O/P0JwPmIAGf1F35Cz2BhZoAiBK5GJ516zDKZyxMSxD3WFGG7liboMxP0Ep39vHfNwyTawlkw46jwk9jXz3vXjnj/u6fgKM/9jgqCWNxPJF2Y2aMg8BsBOiNxS7tdip1ESrdODBQSYS+SYCokgRJrhoUqFGaV9ZCUhZMUBYK5gSgaHVg1owuq4FH6LHXihkanHrC0KWUoPNc73lJHQWHbvnr6LJhrCoLSRIDuvoSlv91pDWNQWuqINGjWZDPz6Xs0cSxHVEXg9NgZiCfQEzGM5AhANXQuAXZHgn5FgkUbETUoiPtS1vRuWxpfSXHD/U5rKrkqFDC89KesOjIL3AToisetqdvSRjKVeTCxsEnVijN2fG5rZpcqFMrdgsF04ftAAH7NS386ls2vSHQO8O5nHibe1oezOsC0m05GLSmne3eUHV+8L0s6aPj62Tl5eUZSIdFTnCbu6lQt7dYUhYBupy9q+jvV38u2R24j1TeifEEgxKwLPkPM5bLM1xJOQdJexNuKRPcUYewgEQ7r66YJBb9HI5y0Gk+gwm9n0Iha5rP4HCl8rtHXLd45wOtX/Ip4Wx+uGj+H3n4YnkovkY5B/r7+zwzuGcBb62PN7UfgqfBkrFUs7VaFQleklq6EdS0gNVJGR5+RY7cRjWHEE9m8M1tURekzUWSqL2z2m3LmxoTQwTYG8pMirMtOqIrCCQun8cVjDyx+MAv5f44m/v+yRCxqm4CZpBbT00Uz1RMyXZRFNFwFF1S3A1vQnQNuABwVfvN1dRBb0I3qHt34TBFK0c7GBpJYqrjdST1dvDrlGJv6FdUB0tKabi2R6DJuCVxMvQTFwt8Yw+2RHgPFQAhB/GPyd2oMtE7L2eHfECEEiZRJWVUdrlHgBjLbfh6fJbgBSBrpomyzsVRJGBvPChJFOmBLJDE9VZSxkzLSHxttudhlEUBSLxbfkDDSOZOWo9zHtJtOxlkdIN7Wx7tXP0LPhp2W4AbIFkgsdsJidksk8UycjAQ3tkCI5lMvxRYIkerr5u17vk8i3GN5rLQhi8b3WMwWFAOl5ufF48T0d1GmEUbe+NZcduwlbpzVARbcchyeSjPv0VPpZc1th+Ot9eEscWJz2zJ2i+J2S4gVsRsglk7nHMuIxth3y71mk9JMGQQj4+9UXy977rmVvQ/kYbmNYTwRjKFpp5QMxoo8VX3M8gnA+YhSXxa0pv8qgkq3x3KQFEDI7ilO6xxReFrzOJj0zZPMFZqKXBTrqSxhyndPYdI3T0LzjAY4utQpc+bvG5O1WyhUeDxFG8iFXO6iNFrNonHckBiGwFaw/4opujTwagFLIKig4FTLsWpWB2BTSpFF6k3YxjCQ2hUdm7AuCG5IgwqXy3KCH/a3dZyUeFxF63uo2thgQDFap24YhHxuywlHVQQVXo8le0IApQ436SLxLYziw5EE7Io1jdaQkpDDU9zfTl9R1t5Y7B5Lt20JOIvYrUtJid1f1O4yx2i7HRX+HJCz6ZoHLMENgDqWukMCXHZru6WEMr8bfbAvF9ycvB53bTPNJ6/HHgyR6O1i+4O35W0SOyQBp7Mo6BwLu10CHq2I3UC50/qeU4WgzOGlSBUEXIo7b5FWzetg1rePZc4tJ+IoD+Z85qn0sub2IzjglkOxe+0ZmyROpXjH7QqndXwrQlDp8eRoGPEExsAg6c6eLMjxuuwkwj05TWZHsdzGgBIkWCYYD0l9AWbvf0o+ATgfUU5aNtPyc92QXLR4geVNK4HzpyzErhaeKFUhOLJ2Fi3eymxgax5HzvaTgqDVW8Vh1bNxVwTzghswm/GdO36JJTDXpcG6aYuLgq4Lps3HUcTuY1unMLmkouBEqQjB+EAZR9XNtpxwbIrGkTVrLJ9wDAwWhk5CYrViIpgYPA1VFB5IBCqtvkOocIwvSNkUKJQ56jigYrElTVwVCudNWGJZpVqXBhfPWVh0cD9n4VzcFhOOqggOmzGRafWVlv5uKA9y7JJplsBEVRTOPmCe5ZOZbkguWDa/aC2k82fMw2srXAtIFYJD66cwPVhXcOAWCOrcpRxVs9DS34oQnNm8oqi/L5iwzDK+BYKzJyzAZ1FTRxWCQ+omMSdUV9jfCGrdQY5vmG8JFhUhOK1pZVG7T2taldduR4Wf8dfl9vKrufzY/OBGCNbUT2BBdV3BCV4gqPH5OGXujKKrKuetnAc2O5rbmwU3Nn8m+d1fQtOn1lNZW4fm8aLY849LihCcOW8WQWfh2jSqEBzY2srimnoLu6Ha4+OMybOLrr5dNHURqUiMdE9f3s8T3WFOr55uXfEbwYmNSwnYPHnt1rwO3OUB5pVOZZp/Sk7seio8WXAjEJTYAhxctbpI2QnJaU2rLOPEkJKLpi3KsXuo07pWXpoFOctVjbb7bs9pMjuS5aYKwfLxTSyd0FhwrBBAyOvmtKWzLONEIjluvnVj5o9bPgE4H1GOXTSV5vLSPCwE8421cydz7KyprJ2Q6eo6Sg8mloY4feYsPjvjgJF/mnMot2rnqhkruXbysQV1AK6ZfAwXjj8Yl2ovqHPJ+MM5pXke433lo75Plq5YN43jW2ZwTPOUgnaPC4Q4c/IcvrBwVUEdl2bjmnkr+ObCAl2LM8lo31x4COsmHGBp92UTD2ZN5SrqXKPpkUOvF5TMZ27oACb4D815f6Se39bA9JLjmBa62jx9Hh0hXEwJXcKqqsvN9OI8OhJYXXkFJzccgVMdTescen1qw9Gc3DqXyYHKvIwOJBxaO4njx0/jpMnTCvqpKVDCWbNm8blDVuVVAXBoGlcduIzPH3tA3p5O5ukkXzrhQC46dBGeAkwrgE+vXcoJi6czuX5075ghnQNmtHLMnCmcNGda5v3RVtWXBjlz/hy+vOCAzKejz+hQNa6bt5LPTTsyM0jmt/wL047izOaD8NmcBXTgvJZDOLZ+PlMDtaNsGdJZWTGJo+tncWq2PtHoY9V5Apw9bhFfmrPGwm6VdU1zuahiRmYyzdVJdYfRIzG+Nudwzhu3ihJ7YbvXjV/F2tqFTAvUF/z+S8smcnj1fI6vWzzK7sS+fjbd+FjOX+39wW9JdYVHHcumqFwzbQ1fXX6g6e+8Jkm+sWINFy1fQIm78MPA+hULOX7BdOZMaKHxxAtpPuWSLLgZklXzZvHKC89zzfd/ZOZ45AneKr+Xc5bO5csHrR46/SibNFXh+lUr+OoyK7vhmyvWsH7GIkod7oI6n56xiEPLmxi8+SHav3kX6e5cP6W7w4S/fR93rLuOT1WY9aDy3eMVTh/njlvCZeOPLzieqELl4tajOL3xZARKgfFEclbT6RxZfShezV9wPDmi6nCOrJ3PrGBzQdbW3JJxHNM4mwunLcj5zvuDnNvOv4REd9cIcJN73VRF4XNrVnLdUStRFKXQ8M0Xjj2Ac1fNo8zvLjienLNqHjUlHy3n9d+VTwDOR5RdbWE63+/BFpWM5AkLA+wDkjee30ZXX4TX3tmFPSLISQ0xTCr5nq297OwK89imzci4lqMjJci0oLdP55X2Pfyz/QNiKTWH3jzEOImlVJ7q+JA3e3fQl0zkvdmQCv/o2MCOSC+b+3qQRh4dQ/B8+3b2RQd4bufO0RVmpWn71u4w2/t6+esHm1CTSu5AIgEdIv0pXtmzmye2bTHpqPuTDAww4oIntm3lte7d7BvU0fXR9O5USuPPOz+gLdbFxv4eEkYu9VEC8bSdl3q2E0728mr4Q8JpD/qIEDckDBpOPohE6Ezs5eXw6+xNhUhILedc/YaTTXE32yLv8VLPBjZFQwzojpzzDeoONkfLea57A2/07OKDXo1IKhecpQyFrqiXP+zcws7+MBv39iGT+w1uEmRS5fnte9kXjfDsph0oKTHKl0KHXfv62Nrdy1/f/3BUvsrQQBNJpnhpxy6e2rSNpCbNBrAjFQXoNvjHB1t4a3cbXcQxtP1Op4Duhr9+uIk94X7eH+xCd+Q5jhNeaN9N52CEJzu2YrhkTj6KRGLYJdv1Xjb3dvN420Y0h75fzooERRJXY7y4bwcvdG1EVRPIaIxk1/BTtSIkdjXNv7re5ZmNL9EX7kJkv/Ww2ITk+a63aI/1sjO6B02MZrXYFIP3+rfQnRzg5Z73cNr0/fxpMg57051sG9zHcz1v4XfHUFUjV0dLoxgdHH/UWk4+fC3e+I4ceneqq489X76Pjhvv47k9z7E9upWgaycBe5yRBRPsik6tp5/NsefpTnSTlO8TtMdRRgwEqpCUOuL0pt4inAzzbt+beLQUQ1NOYl8/7179CPG2Ptw1fn7+t1/jr60g1dHLzi/eTyrrS1M/rqd4sWsb/9yxdbjEfp6Z6W9bN/HO3g66I/kTcYWAJzZuoS08wPt796E6XGgjcrUkgIA3d7bh8Ad5cWfn6FWOzGVs6xtgU0cXf9u4efQ2VEYnkdB5fvtO/rljG6mkwagQkGZF7Mc3b+bdzg66BqKjxxzMBqB/37qFLfvaGOgJk97XQ/u37s6CnFRXmPZv3s1g2z7aOtr5++aNGJkmm9lTSZN9uqsvyvvhffx59wf0x5ykR2y1SglJXaUjovFc5zae7dzM9kEv0bQtZxyI6xptkQB/2fsh7/e18XqnSl/CmVN6ImWodET8/G7ndtqiA7ywu5d43M7IHWvDEMTjdp7f1U17dJAnN28bNTZrJUFCZ5+c44+qE08dBW4AkobOv7bt4NltO4jadbOR6kh3K6C74PHNm3l/Xyd7ZATDvp+7FTDc8PcdWz+equD/hnzCovqILKpv/uSv/OWZ90yaOAzT7EaM46sOmcwfPjB7GUlkthvrEM1SVQTLZzXzp/6hfkdymFqXoWsKYHxJiH7XbhJGOqs3/Mxons2uqDR7A2yPdGWepkde3uGhZZ5/Jk/u3WxJoTy8Yga//2CETUMfZUYtVQhW17Xyj81bs38ps1xj02oBtJaUsCvRR1wftnvkcQAcqsr4Bg+b+juzdpuJx0Ngx9Q7fWINr2UolJDppCzNOhJDOsfUTmbT4JPZc2kmH590htusoDDFP5Nd0eeydmukUYUkJdVMcrEgaKvhnQGFpGHuSWtCRxM6aalmjgWa0AhHZ7J5YB+GudaDpuhIKTIJyKZNC51zeXzblmF/K+Z3G3l9j6mdwp/e+TBj9QiwkPGlKgQrGpt4ZuO24Uu13+UVQH0wQG84SnSItTV0iUfQNW2qwvjyEBvbOs1BVJqgXIpcvYNmjOMfH2TsHtKBbKkDARw6dyK/3/b+8LmGxrCMjioEK1oaeWpguJ9XdodFDCcX13v9qK5O+vv72fj5X5IKR5n0nVNwlvuzOunOQT687hFEwM7Mbx+Lut827JDe4tLZPN35HoY0cpqlC4bov4JVFbP48553TXsk2TgTGUq6KhQWlbXyYtew3bphdi9XhIGiQKqrn02ffZjo3h5cNQHm3nwCtjI/kfZB3r76lxn2TIAFt5zEsknNbItsNyngUpDWFYQAmzIMsJaEZvN67+sYmHanDJOTbctQ4AWC2cHFPNHxZtbuSEeEl654lNjeftw1fpb+4Hjmjl/Ar1/5IKd1i5mLM+zLKqefrt02+pPWTXfn22t5e0+75TbNYeMn8MTbm0ydPMOJIgSHzJrAn9/5IO/fg7m9Or+1nmfbdmbfyzd6VXo9RBwpwhkW0chVw6H8PEUIZtdV8fq+tmHKec6xTL0jxk/gj2+8RNuNd5Du7EErLyV0wafovusX2den33Yjz6T3DVuUifuheFGFYFFlPW8PfpA9iyIMhJAYhsIQtbvM4cVhi9OXimZ1NGGgS4GeGU8UBJN9LbwdNmn5AolNNceTlDE8niwNzuWxnR9my06YNc/MkgnmGCc4rHIqf9ywadhHQ/dQT5iOH96R02TWVppnBSejH3K7IA090djwRTEynyvDqvOaa3lt196CYwXA7ScexYETWvko8glNvIh8nABnzXk/ZjBaeIAQArRWNz1FmuiJSkHUb83qsDlSeEusqYEgsavWKFkVCoMR7wjAkccewBW20dPTj1oSHPV5ujeM4nTgcvrQU9ZdkqUiwVYkzITEXlqc/ju5ooeUtM7EnxZIAj2jBrWR4lYkdiWBFdsqottpTwQtz5UyFN7pqrHUUYVCZF8JkZS1v8tSHvoGrJv/2Q0FivgbA7OYmpXkw7X7iaYoaC7VLJZmId5yB2E9Zslb07wG0mPNRrFpaUr80TGVQHBWB5hzy4k4y32jjqMKBWm4iOrWceIUPvqSCctcBk2AQFrnxXT3svG6h4ntNcHM1OsPYcMNj2dfz735BFwVXkLO4mUQPKpK3Chyj8tSwiPsTg0meOmaP5DsjbH4B8fiqvTRH3fTHXGT6Aqz4wv3owU81H/pNFTP8FaTnlBIdFv3dkOCs8s6GV1TFDxpjcG4tb/9XieDyYRlvpa0Y64WWsSmVCS62zp4JRKK5LxqQsHlVhlIJcxJ/8afkO4cZnlp5aVUXncR5Q3lRAzrcgJ2WxqHI2055ijCwG0vwtqSZGsfFRJVKKRiQcIJa3/7El4GB9M5dqd7w7T/8PZMk9kQFSefQufPHybV0z0McoL7reRkVpCLiSzCJVEVwbHTp/KtIwtU2B6jfEIT/y9KKm195c2nMKvh0ZS0NMZAt/73bCt8GFGUiZOOxtl04+2033RHllKY/awnTMdNd9Dxg3tIRiPF7R6TUcVxthGJE+nInwwY2zdIatAESIa0HmgAJIYlGwsYE43WGIOOwIwBa3sgrRePE90YQ5x8jFK8I7OpU0xLl/lptCNlqFSAo3y41EGiLcx71z7MwIbdueDm5vzgZuT5iokuDUvgYurIov52lPuzDRVje/t49dJf5oAbZ0VhO3NEjs3utNRz7LZ5HSz87lEs/uFxuCrNc+mGabetLEDjN84eBW7M840hjsb4+Jsu0kna1NGLUokNWZyVNlaaeDGRyGx8a6VBQhd8Kufz0AWfQisNks6sAhY7VrFzjsWmYmPSkBQbT4BM8b4Rr/cDN1WXrcPZ1ET9+ZdgKw2R6uk22VR5usEXtXssoSTNsiL/TfkE4HxEGddQnjdzPJ2MkYiGURVBQzCQk4Ge6g/n1BpQhKDBHSg6mTjIzz7YX1yq9aNLWurUewOWGe8inkREomZn5e8Ng5x0T9h83dWDMTBIlWovarfbgmWVFUPgsegbo0fi7PzGT3nh8t+Q6BjM+SzWMcALl/2Gl675A/pgiqC92pKFIBD4bZUYlkwr8KjFbw+7olvaDSZ4bQz4i9JR60sCljqKENQE/cXjxKK/1EjxFqF1pg2DumBxuxv8RWIJqHUFi9Ot5bA9I+s5JdrCbLjqoeyKzvIfnmEJGnRpUOMqsewArQqFOneJ5WQqgCpnsCjoULHhrPAx9fpDct6fev0hWTsl4FGtV0t0DModZdYMMRSqnaFRdtu8DlwV3qzdtR5f1m5bmX80uAEcjjFMugICLmvasm4Y1IUCRRh5gvrSoOUELoAqr7cok9AmleK1coBSp3URQ0NKGnxBVCFI94TpvusXOZ933/ULZE8/DZ7RuSn7213m8BcFywK1OHhDUmL3FLW70Re0ZJyqQtAQCOS8pzgdqF5vFtzYSoKEfG7UQNBcuSkNoXq8KI7ceUbJbDNb2wRlHuv4lkgmVYwmtvwn5ROA8xHlxENmj3oqSSdjbHz6bt77x+3EBnq59PAl2WXZVH8v239+Kzt/OVxQyZCSTy9cTMBemI6qCMGp4+cyu6ShYGCrQmFOaRPH1S+wpNr6NCfrJi2zrjpZ6ue+3z+KVlaaBTnxLduz4EYrK6XyMxfzmUMOI+CwpnWeOnUWCy3oqKoQzKus49SWuQUHLhlPYPRHGdjTy3OX/4ZYxwCQATeX/5bo3n6SvTGS0QSHV52I1ZqCRLK8/ERcqr/ggCtQmB86mEm+yQUnHAWFVm8rJzUuQkGgR+Iku/r3O47Z1O6UilZSkcJbFLqUXLVkieU1MaRk3bIFlLpdBf2kCsGJc6azZFxDwQlHVQTT6io5fcnsgscRmO0c1q9aZDnh6FLymWXLCn4O5mSzbsYiyixqd6hCcHzTbBaXTczGt6PCz7hrcmnPq79yNqfOPcLiuoFTsXNOyxoMC2CiS4N1462XyiVwTusKyh0+S7sPr53L5FQVG254POezDTc8TnzfAAqCFk8th1UdaDnB2xU7x9YebRm7BganNqzFCppI4MyWVVQ5C9fUUYXg6MYZHNTUanlfTgyVcfaiOZZxYtc0LlmzyHLrSTckl61ZUvRJ/4Kl86jx+yzj++ipk1nTXNhuRQjGl4Q4f8Zci3EQ7KrKVXOWkujuzW5PaeWlVH5uXZZltPfG2zm9bHxxmvz4pdS4gpb+PrRmBisrphUcvxUEDZ4yTm9ebhknmlC4bOpKS+CtS8lV85bm+Ehxuahcfz5Vl61Dy6QdXDh/Pg3BAI6SUmrPv4Sasy/MqWSsCsERUydx6JTxlv5uLA1y/qJ5lvBNEwrHzfikm/j/U7JmySSmNFaMzFJETydIxQdIRLrZ8eI9NPptnDx/RgbcmF2g09FMQSUJM2urWDtzMl9acGCWNpyVzOugzcnls5bw2WlrTebNfmPJUMLbdVOP5LzWA/DZ3CNNyupIJFdOOpKjG2cws6Q2//mAU1rmctKC5ay/40fDIOc7tw2Dm6suZs7ESRw3YRpfWZ6H1pk5rs/u4LIFi/na0jUU6losEHx16YGsm7ScoM01yiYpQQsF+MGvH6KlpYXo3n5euPy3dL/TlgU37ho/i39wLEdNP5SZJTNZWDq6s++QPyoc45lTsprVFesxCvhSCD/Lyk7jU3VnYEg1fwNQqXBy/Rmc17ISd1xj8xcfYdN1D5Ls7M853+neOXzrrAuI3vYgRjSW39/jZ7C6uZVz5s3JeX+kL6eUl3PC9Gl86bAD8idzSrPY1mWrFvO5I1ahiPzNTQG+uPYAzl8xj1KfK6+OBK45fAVHTJvI/ObavCYBHDtnCitbmzl/zjzyiUQysayMk6ZM56tzD86T+G5quTUbV0xfweUTj0TJJJYn9vWz+bu5tOd3b/gNSxlP0ObPH98Szm85igMqZzArMC77/kgdgDWVc1laMYkzmpfn1ZESmj2VHNswn2umHIVB/iawTsXOWtcU/nDR7dltqXk/Oim7XfXalb8mvm+AS8efwJE1hxCy+0d4ONebpzYcw/zSuUz3T9rPy8O/Lw3NZ07pDE5qOKiAjqTBXcGh1Uv44szDC/rbpdq4cupBfHHZajRVyasjgW+sPIhzFs+hwu9h/1TdoddXHrSENVPHs2RiYwGr4dBZE1g1uYULVy0YpTP0uqm8hJMXzOQrhxyAlKM3mSXgtGlcvWoZn1+2Ck1R8x9IwjdWHcS50+dS7fHldbcEPjNvGVMUF33fu3cY3Fx3Ec5xTVReO0yl/sKpZ3Na6YTR427mdaOnlNPHz+VzU48qOJ7YsHP5pIP59PgjUeTo5pfmeAKfmXgcpzQtocJeWjC+L2g9mDW1Ezmwenyuk0f8fnDNRA5qmMBlC3LLCSguF1pJEImkIRDgrBmz+fJhByCRaIFADriRSGw2lWtWL+Oag1Zgs6ujtv5l5t+Xj1jN6fNnUVfmz743Ugfg06sXUVpklefjlk8AzkeUDe/tZutre7AN6tlELIc7yLTlF+N0l9Ld2cay5Sv45cN/YsfPTHBjC4ZoOnU9dm8QLQob323nza17ufOlV9FiGqRHAAEJIqkQ7k7ym/ff594PXiKS0Ejrw3RjKSGtK0TiKvd9+BJ/2vMmnfEY+ojN6qEbSDc07t3yL97o2s2b3XvYf56UgDQEv9n2DpvDXTwR7qTsnFNyvnPonJPRSoK83dHOq227uePVV1ANkXcgCUfj/Pb997jnzdfQU+RSNqX5Wk/B3W+8xu+3v0tnJI40hifm7E2eVnk0vJ2f/P5nOKsDJsi55NEsuJl3y/HopWX8Yffb7Ip08Ie9r7Ev7iM+gk6ekgo9STev9HaxsX8TP9v5NJsGq+lNuYd1DIX2RIA3w16e7HyJB7e9wIe9pXTHPRmGgtnVtyfu5sNwiJ9ueZHfbXufrTvjpMJRku1hNn32QRL7+kkmNXq2prjiuLPZunUr/V29EE7mlgrQQY0o/PHND9jS1c2jr76LOsQ0HhkDadi4u5OXt+/izn+9PFynWeb+3x9L8OgbG7j/pTdIKUYOTVwCKKCrkntfeI3H3vuQjmQUqeXqSAVwwN0vv8rbbe282L4H3U7uooECuh3+sOkDtnR389CHb4INsxlj5mhSSKQG7/d38sKendz54XOomszkWw2fUQhJxIjx6PY3eXj7C8TSENs3kNNTbdL3TsdRFWT39p2sWLWSD7Z2Ek9rOXGSMhQiKSf3bnmODeG9PL13D5GELXvdANKGIBK387vtH7Clfx8PbX6TZNKGYeSWXUilVTZ09/B8x1bu2/IsYPZjGqkjga72Lg5cfQA7tu3AXeNn/s3HEZxWnZuTc+Wv+Olrv+KN8MskjXacSpoREY4mDHxqkqc7H2N3bDu7om/gVhO5NHEM3GqCjQPPsTe2h3/u+wduNYU6ggYvkNiVNN3JXbzT9z4PbH8al32oSeeI86kGuhLhN7te5v6Nr5G0pTJd0EdEgSbBqfOT917ib5s3sys1gGEjmys31JjRcMFdb7zG++2d/GvPDnQHubOKYpYTeHzbZjZ1dvHQG28h7eTGpQCpweb+Xv61dTs/efkVhgI8J3YFRNIpHn7rbX729pskk+lR9wnSZO/c+eqr/H3rFvb09pOzE53RUdOCe19/nb2pJCmn03xou/qibI8mLRik8op1aGUh/KWlPLp1CzKmgZ4bJzKhsKW9n6d2bePWt14h0u8mlRwecwwDEnEb+3o0fvbBW9z/4Rvs7nISiTmy9G4pIRa30d3r5dZ3XuFvuzaxoT2R0RFZnWRKZWDAze1vv8H7Pfv4x/atGMnRJTWMpOBv27awsWcfP33vdYSW8THD1w4FtkfC/GPnVm5/+2XSPgPDlnvvGg7JgDPBz95/iwc3vkm/P4HullmmrERiOCWpkMEdG17myV1b2GLrRvcbI66fRDokelmae7a9Qjz9383B+YRF9RFZVF/6ym944cXN6JkkuyFnCiAeD/PGa3cRjw1n5tv9IcatXY/dW5KdL1RFMGV6Nc8m9mT19qc+CqAq4KEn0Dliy2DkpTOPZu69OuiI9xfUAZjsHs9rnXtGLHPKHB0FwdLgeJ587W3abjZXboZEKyul8sp1OEIlzCmv4bWdbQXtBpPW2ZmMjsjBGG2TIqC2zkFbtD97G+az++CWEC+8+CxvXf5Q9r3pt5yCf2pd1u4Dqhr4cPDtEbbs/90UWr3NfDCwbcQ5TErmUJdwAL8W5P1eNcdukT2aqSOkQI3Ws2ewn1R3mI4b7hymm170Kbp/YtJNvZUVlF1wEUowmOOnkbTWFbWNPPfhjgJWm3Eyo7qKN3eN9PdoL4U8bvrj8fz1TUaAlLrSALvDmQ7BBXTmj6vjlT17hrcf9jNKEYIlE+p5un3b8CH201GFYFZ1Be8ktg/bPeJ8QyvfpQ4X2PqJdPby4bU/I9kexl4VZMKNp2EvD5Ds7OfD60a8/53TsZeNzMUZNnymfzyvdO0sHN9CsKRsHM92bMl51hypowrB9JIqPozuGHGOXEfpkTjbv/xL0n39LPzBsbgqfNnvFts3wMtX/AZ70M38765lUUOQzkT78CQic78/wDT/JLYMvpfdptpfR6DQ4J7DK70jKPf76SgoVDlaeKq9b5TOSD2f6qa9wznMpswTAwIYLyvZ2t1T8PoCLK9u5OVtu4bHpjwxsLi5gX9tHeHLPLE0ubqct7v3jdYZoed32ImrenayzDfmAIwrL2VLb09223f/ew5gaUMDz23+kFQsntm2yTVKhvtYPK6VF/tH2JQnTiaFytgw0JFHZ1jPp9mRWppotslx/ptuQqCCTeGuETk9ox2+rLyZ59t25pkLhm1aUtHEszuHKff5/D2xpIz3OzutzMZrsyFVQSSVtDKbyZUhPgh3DW+z54mT7y0/nOPHfbRqxp/QxIvIxwlwjjjq+8QsGoj1hXfw+qt3ZF+PP/pSvFXNo/T0aoVYibRMIBWuNGqZNZVaIHE5rWm9mlCIRFwkDeskW8feNJu+9cPstlTo7FPo/unDw9tUV67DHQxB2pqVNfQkbymKRC2xpj1qQqHU2MObn3mQeNvw4D3UQXmoJ1eL1yBFf6HDmKfDLJZole8QTdnojHktj6Prgs6uQPZ1egTIydpdUUrT+ksxvNaxVoqTgag1TVzLVG8t1hoBQI/HMBKJnNLrQ5LsC6O4RncOzjmXoiBcStGnLm+pjT7dugyCza2jua3LIKiqjtuZQo/E2fzFX5AKR5hw4+nYR7QjGQI5tqCHcV//VN7kWU0opFNOYkUaV3pVFwOpIrR8zcBus2b/KPEIfqMvm+Q7UmL7BtHcNuxeG3Wevjx/PeI4qHg0QbIITTxphOhLpdh/u2Ck9MbddMe8lomvqaRKf691QisGqD3WPZ00RcGd0obrLhUQn8NBJJm09KVUAZt1V2opJNLaJNM3RXLtNUXBblOJFCmD4HPbiOjWdqNKFI0iicYSpVjXeTn0GGVxKiFwSgeDqSI0ceEkmkgXLSmRKSVmLUV5CxLs1kdRheCY1ql8b/nhxQ5mKZ/QxP+LYoUP4/Ew7234Zc57O/75c5KDvaOP83EZNDaWoeXgCJDu7mPLDT/KATPO1iYqr1w3nJNz8+2k9qOQ/ycl1RXmzc/8jHhbH87qANNvOTWng3JiXyb3ZQzelIyN2vjvihYKErool25aedHJo2tL5LWpuOUjix5aiR6Psftnd7Lrp7eS6suNt1RfL7t/eit78nUOzn/CoipF7TY9XvRYAKrHybivf8pcoSnPHcDs5X4mfOf0guAm93zFbCouUsqi1F3N48gLbgBcFV5s3sLkgZEisB5PRlj1MWiM6dKOWcbm75H7SYV0/nsylrgd0huT/AfGk0IyJn+P8ft9HIaPld7+315P+QTgfESZPq0OJQ9bZeT2lL+kgonHXIbdHyLZ382mP96WA3JURTCppKwo/bdUzd/MLUckBG3WiVxpaTApWG5N/3U78ZWWoJWFTFAztDddGsyCHNXnY0JtTVG7SxzOoiwEYUDIUdjudHcfu752F/G2MM7qINNuOhn/1NqcDsrvXv0Iqc5B6t11ljecgkKDu6Yo/bfU4ShK61QUSblz2O50d5jun+TSTTvueIR6VRSlW0+szF9yYKTO+IqyouXOfU4HJJPokUFSvd3s+ultWZCT6us1X/d2QywyunPwCEkbBhPLy4raPbm0zNJLqhBM8FUU9bdbcWUZJqrHib0s/9NZXW0dmgW4SUuDSYHK4v4OVGI1uCsIWnyVRe12CFdBZsyQGAiCtpCljo5OjauhKE280V1neRyBYJy3rCht2e/U0JQiU4CAGr/P8vqmDYOJleXWNHEhmFRRbgkWFCFoLS0pWivHrdmwKcVLIdT5/JZ269JgcmmRcVAIJpeWW07MCoIWf2lRu52qhr2Y3QIavMEidksml1QUtztUXrRJaFMwWBQsOVQVh2pttwQafcXtnluRrz/cf04+ATgfUY4/bj7GftsF8XhfFty4XKX85veP4a9pYfza9fuBnDBgbjdcfsASanyF6ZECOGfGfA6smWhJ6zyoZhJntCwpTDdHUOUMcNW01daVOd0ufvfnP1F39SVZcDMkWmmQyqvWUXHpeVx3wBrq/H5Lu8+bM49DmsdZ2n1g0zjOm7SwMN3c7cRZ4qe2qZ5pN30qux3lqPBnQY4t6EZzOzir+ThUUfiGNDA4se4oKixqjggEa2tWs7pyWkGQoyBYWj6RC6YuQJC7PaWVl1L5hXVoFSYT493vfo9Eb0/e4wzJdQeuMLeFCnyuS8mlqxbRUBos3ElZwBkLZnH0kgU0nXMJtpJQFuTEdm7LghtfRSXfuOf+vNtXYE425V43n1m5rGhdks8tXYlD1SztvmzGMpp9ocJUUwSnty7g4Orphf0tBAtCrZzZsrzgkKwgKLV7uHzyQdbVtYHrpq3BrqgF7TaQrJuwimZvuWUMnNCwmFUV8yx0FGYEJnBo1RF5Pwcz3ryaj6NqTi5a4uDk+k9hVwrv0Zjdpg+h1VtpafdJTQs4rnVq4Xs3Fme65mbdggWj/J0OhzFiMRQBQaeTq1cvs9w2NaTk2oOW47LZCvtbSi5ZupBJFqBaEYJTZs7g+ClTLKnk82tqWT9vYcE4EUDA4eD6JSss48SQks8tWonbym4kn56xiKmlhUG1guDUCbM5saVwZ3ZVCGaHajmncTqp7vzbmUZ3P56UwWfnrSpaUuKzC1bitdmt7Z6ziBnlFnYLwSlTZnDyJGu7Z5ZX8emZiy397bXZOab1E5r4/1Myf14zUyZWmy8yAadpDuw2D05XKZ/73I84cPk8Tlg2HbunhPFHmiBHc3pRbWZBpdnNNSyd1szVi5eNpv9mfi91ujl79myunLp6mG49Mr9MmoPkFVNXc2rTIjNhc+QBMr9LJJdPOojlVS0sqKzJqwOS0yfMYlnLRM5ZuYLck5k6WkmQea3NrG5o5uplyzJPiyPTNc3fgx4nZ82axVWLlmZWukZk6mf+Rihw9eIlnDFuHqXZ1ZDc8wmXg9t/+RAvPvs888fPGuluHBV+pt50CpO/dSLHTljJRF8jB1YclJdmCdDgGseckhmcWHccaSnz6tiEj8OqDuSC1oMBNedYQ79LqXDhuEM4Y8Ic/AOpXHBz/YU4xzVSed2FVNbXsXfnTnruvIt0OJzP3Xxq+nRmVFdx5oLZBQeJadUVHDihlasPKgw6/A4H5yyey6dXLcZRUkr92euzIGfnvT8i1duNrSTEbx/7M5ccvoZyX/4cDENKLl+1hCWNDSxprC9gkeT4GVOZUVXNuTPmFLR7alk5BzeN4zNTD8j2qckeIfO7R3Nw3vhFXNR6EApaAX8LLhl/CMfVL6BUC+b8/dDvupRc0HIwC8ubWVQ6Pq+OlLC2eg7TS2s5q2XJKGrv0O/j3VUcXDOJT48/NKsz0iYAh3ByZstyTqk/DIEtr90GgjObjmJp2Sr8WllemwwpObzqeMb5pjDZN2vIvSNdjZQwr2Q5Td4W1tasId99CdDoqmZR6VyumLxmBGNN5uj4bBpntSzn8llLcGjKKB0jGqPte/fyxhdvYlEwQE2pN/OJJB3uZe/tt9F2912kozEuXbGI+Y11rJjclNUZtsj8d8Ssicysq+b85fMKWA0tFaUcMXUi164artGlx6LmPZPRctk0Llo0n0sXLET0DeSWXZDDfrp26TJOmDyVek+goC8vn7uEeTW1HFzfmlcHCUc1T2J2VQ2XTF1csKTGOHeIo8dN4bMzVyH1vO7GhY11UxdxydRlOAxb3vFb6rCuaS53XHw1Xd+6x2z8OeJ86a4we795J7GbH2G8w8chdRPyh4CEIxomM7eylkvmDoG80YY3lwQ5dvwUrl+23Gynk8col0PhknkLuWTOAjxOkVcHxeD6JUs5rnUKE8q8OefI/i4kV81bgMdWpH/GxyxjKDH7iVjJC89vYuM7exACpGoGgKY6mDnzHPRknGef3Mk7J+zh0SfeQpEShzvI+CPXo9odqJoTJSl5e+MennpjM995/lnUlEBX5DD0lGYfkN6BKHe//CrvyO25BcwycaRH4uiJBN99+wkWVJUTSQ9iU0xabKKrH81lx+Z1YFcMbt30Z5yqg/cGt+JyCpIpDUNXQJiJnjabzqN7XuCwuqk8sPVVcBuQUiCdMUqRYNd5Y2AXj+/6kG+98k9wGcgUkM7YpIBhM+iVUe585xXe7ekgbU8j00BamEu+AqQm0TWdb73yNAvrq+hJRDJZb8N8JTC7Sf9420s0VpXyavdOBCqKYmS7KdvK/BiGwq93vMIh1bN4ZOdzgAunmsKu6ggkKUMlrtt4Pd7Gs51vccsHf6En4cVlS+LWkggBaUMhkrKT0OGhHU/xZmc/vRE7mipw2NIoQmJIQSKtkU7b+fbb/2C+dzy9KQPF50UDKj97ocnISAts3hAlV1yEestddAuBojlGjzUG/OKNdzlm0hR++tLrBWPt3bZ9/PX9TXzn788gRE7z+qz0JRLc+dwr7OjpJS0NtGAJVceeyq57f5TVqT7hVO5/bytbUzqdg5H9XQ2AUOCmf/6LioCX53bvNONx/4UFBX757jscP30Kd73zav5sRQEbevbxp60f8P2NT4KhZJuSDolhCPoTSW7b+Dwd8V4G4wpC0dA0HQVpNhpMK0hD49tv/51VlRPZ3htH1ezYbWlUxTxiKqWSTmvc+NZTVNpLeXLbbhTVjmZPZ5M7jbRKKqHxyPvvcVzjbO544zXS2FHsOqrNTLo3dAU9qfJOX5jfb3ufH218msGIE82WwqbpmSaK5n0zkIZbNzxHUuukN6mhZbqeD9mdNFTShp0ffPAYR9ePoy3ejyo0NKEzVFUkLVV0Q+MXu35PjauSDf1vYz6u7AcGEbzU8y8WhQ7g8fbHsCtpdKmgSyVzOSSqotOe2MkL3S9w99anCTrixNIKCd0EjYowcGppNDXGz3f8je1hEK4YmirQk2qmBpREMaIYgwPs6ehl0fJl2C87E81Xgt7WR/sdd5Du6QZFknZEuemtZxkXLOWJtq0ILygJgZI2DTc0MByS325/n0/tnsGtr76M7pSINCZ9W4JUwLDBhwPd/Oa997jrpVfNezEape3eu9AHB6m9aB1asIRoKsWPn3+Rtj172fGDH6J4vVRdeAGK22WOlYY5PH3rH89w7LQp7O3sR1EFhpYZUzPjqaILfvDMC0wKlfHP97ahKgLDLnOaJatJwV/e/pDTps3g9qdfxmao6E4Dw26OXSINSlxhe3eYR9/ewH2vv47Wq5F26hgus0QDaVBiKsmE5MfPvUhC6iQ6FXBo4NZBlWAIiKkQ17jx8SfZtmcP8Y4u2r9+N1WfvQCtIkC6K0z7DXeT7uxhlyF46sMP+OuWLeaNqhrD84UB6Ap/2vQhp0/ayQ83PAcOHXRhjs2Z+xZNZ1usm19seouHd76MvTROKqqix1Uz8Vg1UFw6CaOPb/zzUcrqgmilYVxRjeSg3bxHwmEcpQJvhcb3P/wzp6bm02fbRbDURjTiIJ1SQUiczhQeT5IHdz/OSa1z8NqsK2N/nPIJi+ojsqiuufIh3npz56htqiFRFEHTskbe2ttRUEdVBHWTQrwpu/N+PiQBr53Bip5Rc4geibP3mw+g90eo+8o5tI4PMJA2k0cTnf28f+3PsQXcTPzmSdnchQZXLZsG9hVc5lSEYIKzhdc62guuFqhCMM5TzsZ91lsvfrudft2arQKS8lKNcNI66XV+dZDt0faCeREKgrll1Wwe3FowB0FBUOuq4sOBLstzOYWLXWHN0m4pwRcppScew4jFMOKJbJXQkTIuamd7fwSc+W9uVQhmVVTx9u7CXZsVIWgpK2XzPus48djtxNIpDCnNhOJ7Mzk3GbGVhKg9dz2VtTXDHYILyKT6cjZ2dVrGwIymSl7v2Wttd2mQbamOvJ9n7dZspJWENYNGQonmoysRsTzWZHcd7/Xss7R7ZqiGN/e1FY4TIWgOBtie6Mz7edZum0rA32dZORkks0t1+tLWTKpp/hr2xrYV3KZSUKh2T+DDgW0Uyp0QCAJaDe/2WftIw87O3sKtEVJdfez60n2kOnrNsgfnf4ruu4e7bFdcO1w3Zpavhg0dRfxdVs1be9oK3k+KgHp/gJ29po/S4TB77riNdE83WmmI2otNkKP097P9th+TGnr/okvQMuUXsiKh2uelfWDQ8v6dWVVp2m0xNk+vquStve0FjyOA2mCAXQNhizOBXVPQFes+UhJJmZHmzRu+S7q7Gy0UouyMU+h68OHs6+rL1jFn2kTe6eqwvi+rK3izd6+l3fU+H+16/vFk5Lwy+cazEGXDifTJzj62XP8gWsBDy9dOQfU4afb6aI/3Wp7vqklrObFxScHvPxb5hEX1X5T3NuwtCFwADEOyta3bUkc3JJt7e4sm/PXJSN7gMeIJ9P4IqY5edn/lPrrazIlkCNwk2sKk+qLoUZNWqAmFrQOdRfdwPwx3FS3TvzncU9zuZDFwAwiKghtNKOyIdlgmfRpIdkYKT1pDOjsinUUTQ/uSqeJ2G4KeDBNpqEroKLsVhb0GBcENZHzZ1V30mmzt7C7q7yEq7khwYysJUX/+pdntqj333kbH3r2Wx9EUhc093UVj4MPerqJ2bxvsQivi72gxKm5GioEbTShsChe3e1O4qyBIgIy/B7qLxkmKRBFwY65AFgM3Kgod8d1FWzXsie4p+DmYk+TOaJdlsjLAYMqw9JGtLEDdV87JVvTtuOH2vOBGEwqbusfg7+5uy8alhoQd4b5srocWDJqgpjREuqebPXfcTnz7NrblgJv1o8FNRtqKgBtVEWzu6inaYmJzV4+l3RLY1RcuSqRIpI2iTTIF0GXXzHYKoRDp7m7ab/lxFtxUXbYOe2kJm3rHcF/2dVvaJIHdsXDBPK2R88rGz/6UZKcZv0PgJtkeJt0XQY8lUYA2C3BjfjfBhr5dlt//45ZPAM5HFFUtTo8rFvimzhhOVqCNri0UoPYr52KrLCHV0cv71/6cgfd2Z8GNozrI5O+ciiNDuZUwpo7UxRqsZe3+L64BFhu0Acsmi0Myto7cY/hiY+iCjhxrDBTjbJk6Y6GIpvrCOeCm7tz1uBqaqTt3OCdnLJ2Dx2Z3cZKoueHy3wuUsdo9Np0ido/la41FR4gxxaUYQ3wrfDw3pq08QOj8/bpsn/+pUcSDsfhyLOPJ/hpasCQX5Nz24+EVnYvWo42h/ELhc43N32OL749XtJIgZWfkVpAvO+OUzAOUGFvsjpW6XSBORs4ryfYwW65/kMj7u7Lgxl4VpPWGM7Bn2jMUEyGEJfnjPyGfAJyPKAsWtlqCHCFg9rgay5orqiKYV1NrXeQPqHOUFHwKtpUNB2OiLcx7V/0sL7gBkx45p7TR8slUIJhXUVeE/qswv6rOsku0AOq8fmxFVh00FBo8JZbnS0uDGcHidk8NtFjbjcKMYFNR+m+tx1eU1qkqgqaANT0yLQ3m1dcU7RQ+t6Gm4OdD55rTUFO0yF+Fz4PT7Ub1eLPgxhYwJwJboCQLctzBIKqjcIf6tGEwr6a2qN3zK+usn5SFYG5ZXVE2VrnDh1OxTgtUELT6rGnpaWmwoKpwc9d/y+5QfVG7A5ofhwWrCUCiUuuqtSxfoEudFs8kSxAvUJjoHW85oSgoTA02FqWJV7icuFRru/XuPvrv/XXOe913/4L0iPpXaWkwv7a4v+fV1lo3+BWCWTVVo3S0YAmVJ+dO9o2nnWkJboSAyRXWZRfShsH8IvelKgTz6musC1QKwczq6qKrj0GHA6+9WJKtYFp5BUY4TNeDD+d80vXgw6R7w+jSYH6R+FaFYH6F9T2nCMH0khrLKLGVBZj0jYtxVpsgZ/M19+eCm/IAYOaHTfLXWoIqXRosKhtvcbaPXz4BOB9Rjj9pQcHtJyHA7XFw+VkH4HbaC4IcKeHyw5Za3pASWLdgIcc3zSo4SNrLgpz2rc/lvNd6zZE54EZBMMFXzaUTC3dbFoBHs/P5WWvw2QoXKTOkwdWzVzAtVGlp9yWzFnPyhBmW1PUTxk9n3eSlFvvzgkmBCi6ddHDBmhQCcKt2Lhm/Fo/mKugnA8l5zYcx2V9neUOe1bKak5pmFzyOguCYxhl8evYiS7snlIS4evkyy71pp6bxuQNX4nc6C8aJYUguX7WYWXVVlgP3RUsXcNrShdSdeSF1516SBTdD4giWct53b+a2n/0cpUAlY0UIWkOlXLuyMCV7yO4vLF1FicPC31LymdkrmVtWZ2n3hZMXc3JL4Y7ECoIj6qfy6amFfakIQbO3lGtnrSx4HgE4FI0vzj+AUoerYAzoUnLlrOXML6+3tPuCSUs4vt66NMMBldM5tvZIy7yZSkcFx9adjNV6gCY0Tqo/Fb/mt4hvg5Pqj2JmcJxlfH+qYTWnty4oTO/v6qfraw8R6+jMMAOHu2zv+85PSPeY2zINvgDXL15RcDVEADZF5fMrV1LucRf0pS4lVyxZypLGhhyddLiXjkdyJ/vwo78gHe7NexxFCNaMH8elSxdZ5oXVBvxct7qw3WBu03529QoqvB5Luy9btpjlTY2WcXLegnmcM3tO4TgRgoNaWjm5rom9P7h9eFvqik8Pb1f96HZCyRSfW7yySM0shc8vWE2V21t4C0pKrpi+nJVV46zHkyWH8unvfzXnvYbPHJ0FNwqC5RUTuGDcQZZ5jxWOAKsqpxY8z39CPgE4H1EmTKymeXJ1PvIchoSVh0ylpirIgYsnmlTTPHoTxlUwqamSM+fNHO5BkyX3mf8HPQ4OnTiOU8fNxqaOPMKI/3vD/OPrP86xb8t3/0Sisz+royppzmiZx5RgDcuqguSzSAiDT7W0Uu8t5ZTJLSY1IY/e4jo/M8qqOW/ODFD0EZ8N/18eVDiiZTynT5mBzZ7fbtVmcPqUGRxSN5EylyOvjsTgrIlzmeivYbI/f7EoCRxQNY1adxkry+dhZCjg+9N2G1x1TPQ3cFztMN16f/qvW3GzunwGJzXPtnxSOqVlLgc3jSPk3p+Wb/5vSIOzps9mSmUF0+srGdlpd+h3A8khU8fRUBrkqFmTTLthlN646hCz6mo4Y8HsEf11cs/qddo5bOoETpw9DbvbY9a52V8JuOiQg1g7ZyYhlzuf2RiG5LS5M5lUXs6cqpr8tFYJh7SOozFYwnHjp5rAM4/euGCI2ZXVnDF+XsEJx6vZWVs/hRObZlvm6pzaMp8DqidQZs/QlkdeN2nmTJzWOp/JpRXMDdWNsseIxEl197GmdjyN/hJOaJmeLc2Q7g4P044ltHpCzKuo5azWBRh6gTgRDtbWT+WImgXITP+A/XV0Q3BM7VJmBmfgVkOjdEx6O6woP5BqZx2NnsnZ9xMDSQbao9nXk/xzKXdWsqJ8KYMdAyQHE6McXuusYIJ3AifULUWI/PdlwKZyUOUcTmqegSfPfZnq7mPnl++lb08HzS0tzPjG5TjGNVFx7YU5ICfZ08uZ02cwvjTE/IbagvG9qrWJpmAJJ06dNvxAuN9pm4JBFtTXcebM2ciMv9O9vey54/bstlTLJVfQ2NRE99697P3JbSbI2e84Ii05Y8ZMljc1UpeJk/1j0tAlp0+ZTmuolCWVo+Nk6GdVbSNNpSWcPGmaGQN59JodARY11HHWtFmQzP/dvGmNYydO5sRJU3Gl8nUSBZGUHF5ayRfPOnsY3Fy6DmdLE1WXZnJyurrZ8f0f4xiMsqyysaDdK6qbaAmUcMqEoTllf0Wo9/lZUt3IWRPmoBYYv/0OWGgr4Vef+z4jZef3fp/NybGrKc5qmcv8UCuTA848x5EIkeb0lhnYiqzQftzyP6eJf+UrX+GrX81Fh5WVlbS3txf8m6effpqrrrqKDRs2UFNTw7XXXsvFF1/8nzY1r/ztyQ18sKMTXCpK2kAMDYSagqEJfv/Xt5m7pJXfvPAuOE1qoTAyl18BQ4V3d+/jDy++x9fffgppl0hDIvQMlVoBQzXoM+L84OUX2ax+gNORRNHNjsdSCoSQyN4etn3J3Bstb6hg1ucX8/xX/0lkb5iN1z7ErO+dRKjWjseW5OFdj6ApOr36RiaUqvTEXETTdgQSnz1B0Bnjpd4nebFrKn/veoaGSsFA1Ek0bi6vOuxp/O4Y7UYXf9n7MjdtfAJfeYJkzEYqriENgaIZ2N1JdIfktk1P8k53B3ZPAmEXpBMq0hAIRaI5dGw2ydfeeoz55fXEiOCwS9K6gmEIRIa6rimSmzb8FYcm2dC/u+D1+OOe11hRMYlf73oR0FCFgZqhLxsIdENh40A7f9rzCj/c+DdSadWkxSpGhuUs0HWFNCnu2PwEb3eFLRJIJV9548/M948jrEfNDsyGGJ69Mt28v/nqP3Gg8XrX3kwMDHO8pWr26fr1hxs4qKWV+998A+kAoUuEnpkkFJAqbOzt4pE33+aHT71gdmMeAhpD1igQTaf4wdPPs62zF8MwRg2i5v+SLz/2D5a3NhKOZCb0kRgu05/mu39/FrfLxmu7M8nII3Uy5/7dho0cPHEc977z6v6uycrm3m4eeu8tbt38dMHrFtNTfO+dp2lP9BTcOpRIvvzmn1hRNomueAxjKPaHzJYCIeHGt/6JX3Hx8t49ptGqBAFGNE7H9+/F6B/kN1cLDm+ayF1vvAoI0n1hOr7/ExSfl8rLzkVxuNna3ctD773Jj957HiOpgWIgVMPszGwIDF0hisF3X3+GAa2LaFIFATbVpJJLCSldRUqVr739R45vbqY9FgPhwKGYJQcAUoZK0lD56bY/Ue5w897AB4CGHonzl0ufItYTZ+0da3BW+Xi591Xm9b7K7976BX+9+G+4Sp2s+cFB2L12FEwaeHeyjac7n+CXu54kYEuSMBSSutkNXRESh6qjCfj5zt+yI6LjdUXRbIJY0uy8rgiJp9Sgs8SJXSnlrJ/cwMN9H2LTkyh2P5WfvYCOb9+FGvDgKBPc8v4/qbAFeK5jRza+5VB8KxI0+MuuD/nLlg+54+VX8sSj+f+O3jAPvv4mP/3Xa6hJQaK/lz33DoObunPXYQ+Usvz6r/KLL1xLf2cHe++4jdrzLjFzUySoSVB1+Orv/sHRMyfTvS+CTYDuIEsBV5OgJOHHj79ArT/Ai+/txCbAcJi0dgAlDUoC/vnWVv4+bTN3P/4yDszj6JldJkUHNQ7tRh8PPfsmDz3zBs5+QdohSbvM+1GkQYuC1HW+/8dnSeg6apeBU4OUx7RJGKaOLSH48d9fBafb3Fo+cx2KM4iRBLsnSO2569h79+1EFI0X2jt4essOc/VJNccRAJGhgz+5aRt/3vIhP3r3OZM3LyFbD0IAwmBvtI9733+Fx3ueJuCOE08rJFIaUgqznIA9DT39rDngIMK79+Gp8TPjc2t445tPEG8Ls/VzD7DwluOoqHVy7/aHOCy+FF3sptGn0JdwEtc1FAEeWwK/PcFjbb/j4KqlBO2BguPAxy3/c5r4V77yFX7961/zxBNPZN9TVZXy8vK8+tu2bWPatGlccMEFXHTRRTz33HOsX7+ehx9+mOOPP35M5/w4aeIXXv4AH27uKLhtoiqCqtmVfNhbOFtfEYKyFh+bbGHLc3ncAlvNaEp2squfTdcNJ34d+ZO12CucRDoGefKSPxHZM4Cn1seBtx2JO9Mzp9IZoivRTaElcwUFv9bMpoGughOOQBDUytlUhI5qExoR675wgMRr14gXaZA4LuCnLdZTcClUFQrj/WXssKCSCwTl9hJ2RawbcqrY6IlaPwNICbaYd0SH4PzSrIXY2ddXcAVDFYKJ/jI27yvMjhBAtcdHe++g5bnsikIqVaSpH+C22ywbJAqgripY1O6WuiAfDhZm3AmgKuhmnwxb2mNTFFCt/SglOAw3g+nCASWARq2C7X3hHLvTvWE6vnuH2V+tvJQlX/kcuxVIdPfSccvtOX3XtBIzr6rS76E9bR0ndg2cfut7ACSTQ3GieuFGmmb+mJfuZDsGBpGOCI9d9FcG9gziq/Vy+B2H4q/y4Q27uefs++nfM4i/1svaO9fgrfTkHMmllLI3bt20U0qN9ljhZqvpwQTpaBLD00J/KrelR6q7D8XpQPU4EQjqRBXbesOWtOUJzjK2tPcWjCUBlDvc9PSarEQ9HmPPg3eiRwapO2c4j0wVgvS+Hrb/7DY0j5f6T104ummshKDDSV/Mwt9C0FxWwo6uXkuaeEtZKdvaeyxzbEo9LnoGrFmgipK7jpJPJODySHr7+rD5g6M+T/WH0RxOmiZWs6W/19LfLXV+Niet2bJVPhs485fLSHT28941D5NoC+Op8bPyx0fhrvQS7Rjk6U//gcjefvP9W4/CXeGhzOFkMF14bBIITqg7lqNq/3vNNv9PAJzf/e53vPnmm2PSv+666/jDH/7A+++/n33v4osv5q233uKFF14Y0zE+ToCz5pjvk0xad1um1U1/kYk7XS1IFOkmbvMm8VSNHkj1SJzNX3qEdDjC5O+cwuTxw/YMgRxniYuVNx+G3WtHFSqKkOjSupt4LBWir0jH2njKSTxls0w0NgxBWi+WPS/RVOtQ1ISCy54mXcTuoF0jWqQjszQ0DEOxtDuVVogmCyfhmseB1KC1jqYoqBGNpG5tdwAHg3Frfyu6QJOKdf8vmdlV/IiiKQq4BAkLu/VYDIcrTTw4eqJM94ZRnA4UlwvVqaM5pXVCupBoRbotSwmppDXo1ISCiNrz2p3uCdNxkwlybOUhSs88me77Hx4GN1esy2UIaQaaQ1jardnSuH2Fe3qBubJSHyhCExcKVa4YaTkcA4PtEf588TDIWfnV5TzzlX/Rv3vABDc/WYO3anQ16phuI6k7LSnnCV2lJ2Hdt84wBPv6fZY6mlAw+t3EinSd9yedxKLWpRdECuxpJTtx6/EYRiKR21LEMHFwqj+MYneMBjdkyI1F7gFVEdgVlVjK2m6vzUY8kbZOIpZmnknRMgfFkkIEpAtjTiDDRgupRIvMKe6QIKYmLJPN3a4EQW9+nXQkwcbP/5J0OMIBt67FXTlcB2cI5DhKXCz//uE4vA7sRR5OBILFoQWsG3eB9RcsIv/O/P0/36IC2LRpEzU1NTgcDhYuXMi3vvUtWlpa8uq+8MILHHzwwTnvHXLIIdxzzz2kUilsttGsgEQiQWJEU8H+fusnsn9HHA7NEuAIIdBUFWGkLBvNaUIhLq1vtEJjrOpxMu5rJ6PHktjKPMBw4SZPpZcDbzsSzW3H7jXXVqWUqIpqCXAEApuiFKX32oRCkX7UH5tITD9ZARwzoVFDGNZ2q0IhXWww+pi4n1KaYMEK4AjApqoownqQtKkKRuq/80wiMVdVCgEcPRaj7d47kbEIlZ+5CKVkeOk53ROm43t3mFs+l5+H3eXEoMiDwMcoNlXNa7dWGqTy6ovpuOkOUp3ddHzvVvP9fOAGUBXFEiQAyALlG/5dHQBVaDkAx1vl4fA7Ds2CnD+d/xcAS3ADJlOwGHV3LBaJsZRBwIzLWJHLa1dVEiJdlJE0crJVna68AAbIu8IxJPvvuuYTgTk2UwTg2DJ2W7lTwMfSKTtT4N36yglzbMb6ecm8d4uMJyAKAiDN42DSN09CiUdxV+YiM3ell5W3HoXNbcPmdWSqk1uPuQKBXbF+GPy45X+eZLxw4UIeeOABHn/8ce666y7a29tZsmQJ3d35qyu2t7dTWVmZ815lZSXpdJqurvxLbTfccAOBQCD7U19fqLfOvy+rl020pIlLKVkxpdkS3KiK4MCmlqKUvoneWpwFaJ1D3ZftipNGd30Ow8Jd4c2CGzBZFrODMyzpqBLJ4tDkoiBhReVES7q1wGQ/uVVreqRTtTMlUF2UZri0fJIlTVwCi8smFbV7WcVEyycbgWBioAyPZtqtZ5JTR9mtaYzHDtHCK0a6NDigucUyWVkCq1qbi9JoV7Y2W8aJAFrLSvE6rP1tV1Vm1lqzsXTD4IDWwnbLRAJ9cJBkZxdtN92epQ4PgZt0Vw/GwCAikWRV1TjL7yaAZk8If5Ey7g5VZU5ZrTX9Vxoc2FDYbq00SNl5J+e8FzrrlNHgRggOqG0tanedK0TAZv3YrQqVyb7WovE9PTBr1H3prfKw8qvLc95b/bWlBcGNgsLs4NSiAKfWVULAlv8YQ6IpCgvKGixj1/R3q6WOAFa1NBUFN8vHNRUFEjVBH6WeIv5WBQtaranUacNg1eRmy1hShGDF5GbL0gyqIlg6qbEooqoKeAn5rFfMVCFY1NJg2ZldN8zxpJjdq2vHWa48qkKwoHS8ZUxqHgeVNQ2U2EbnzbgrvNi8JmARKEzxT7acUwwM5pXOLvj5f0L+5wDnsMMO4/jjj2f69OkcdNBBPPbYYwDcf//9Bf9mf1rfEHIuRPe7/vrr6evry/7s2vXxVVM84Zh5KAVqvAgBFeV+Ljt5BRVBb0H6r6ooXHrwUlY0NBWmCEvJ5QuWcEbzMkt7Tm9exgl1awsObgLBjMAUTqw7GrVAYTkBlNpLOKf5WCocwbxBIjAH0gvGHcLyigkFA0kiWTfxAM6dYF2e+6xxi1g/cXVB0CEQLC5vYf2EgwuybMw9fD+XjD+cKmeJJb37wnEHs7xiUkEdieSi8QdxwYQl2ZLle750L6muXJBztK+JDV+5mbab7zEZOHnOtaS6gWsWLcOm5u9cLYAKj4fPLl9BfSBQMAYUIbhixRLWTGgtXHIAuHTFIi5cOj+/QkbOXDCLS1cutqTRzm+s5aoVS7Br+bcXbcEg0678DE3NzaS7euj43h3Et2zPghutrJTKz1yMrbSEq+Yu55C6iRb+hkunreDCiUsL2iyA01rmc/m0FYXtRjCvrI6r5y4v2OFc7wnTc98vc97rvv/hnNouYI4nV85byhGNkwpOARK4ctYyzh+/wtLuk5sWcFrTYZbxPcnXzIl1x2FTcsHpYHuEp7/8bM57z3z5RSLt0YLnPLruWJaG5hf0N8CJDUdyRtOBlnYfXbuIS6estPT3jJIarpu7ApeWv+O2wMyHuX7pSsaFSi0n1MuWLWbt9MmW/v70qsVcvHqhpd0nzpvOJQdax/eU2gquOmw5bnuu3XoiRmogjAD8LgdXHbGccVUhhIDUQBg9Mfo+X3/IEo6aN8US41x8yCIuPmiRpd3HLZjKp1cvKvhArAiYXF3OtSuW4ynQ4VwAPrud6xasZFKwoqC/JXDZtJUcUTvX0u5zWg7ihPrCeTMCWF2xmOPrjracdxpcdUwP/P+cJu7xeJg+fTqbNm3K+3lVVdUohtW+ffvQNI1QKJT3bxwOB36/P+fn45LKCj8l44Ims4LcJDJdgfHza/F7nUyeUoWeiaKRelJARYOfqhIfS1vrMdRhmvgw5VLi9qtMqaxgWUU9PvvQEnbuGf32JMsq6pngq2GcO4bIPRMAXjXK6rIGyh0lLA2mUYXZ8U4w3ADRqSQ5pMyDT3OztsaNQzXPN6wjUYXOyvIEVc4AR9ZX4bXHR9kkkEwIRplZUsHyqjr8jkReu32OBHM8fgKDOqVOdX8Pkerqx4hGWF7VRIXTT5WzdESH6WHSkiFhcqCOoN3DRG9L9qlrf90SLUSls4R5JeNzaOIjf2zCwUR/LQsrGhCJBHqfWbJ8z5fvJdUVNs/XHea+86+jbedOGIxgxBOjvptUdJY31lPp9dJQ6UWKkVfW1DGEZHp9OaUuFzObqrKToNzvX0XIQ13Az+LWBkYybUfGnMOuMa2mkvkNdaj7B2VGSRiwqKmeSRVlBFV7Xh0jLVla30Clz0ejN5DLehk6t4S54yfx9FNPEaiuMkHOd27LATdaaZAqj496X4AVNY2IHDrq8I/XIZgZqmJxRR0eR3rU5wAOW4oVNQ1MLi2jKiDy6gg1zQGNdVR6fLRk/D3yfOmeMO3fu4Pkvi5aWlo49fbvopWVmrbfcjvpnt6sbkWJi4ZAgBV1jaOOM/TjtCnMLKtmbmkj+eGrqbkg1EKDuwaX6s0bu7qUTA9MImALUm6vzr4/sF8OzvqfX0JLSwu9u/v4w0V/Y7B9dE5ewBak3FHJrJIJiOy2YK7dblUwwdvI7GAjLnV/P5onV4XOwtA4xvvLCTkdeXUMDJZVNVHm8tDqKx2emPeLk8nBCkpdbhZV1GUp9/sfrkrz0BwsYXltAyLfUCHBnVCZU1XNvJoanPH88a3EYWl9A63lIcpx5dWRKcmy2gZKvW4m+Eqy2/96PMbOX97J9odvJRnuZXIgRKnHzaL6OhK9vWz9xa1sf/RO9PhwOYFyzU1TWZClzQ2I5Igvnf0BV0phdn0Nc+qrcSaH7M4NApGQLGlqoCVUSjnOAnbD0up6yjxuJnlDw2kLI3UMmOwro8zlZlFFY94xDgkhm4cWX4iFoVaE2P9AmfhWYWawnsm+JryaMepzAE2kmVMynhpXJZVOZ14dgc6sknFjqjL/ccr/iRyckZJIJHj//fdZvnx53s8XL17MH//4x5z3/va3vzFv3ry8+Tf/afntM++wI9yHLFdR4xI1JZECDLtAdwj+/vomZr/4Dn/buBkCoKTMH8h02rXD1nAvD7z8Ot/Z9gzSYyB1A5EyU+6lIpF2SUw1uOmNZ0i6XyPkiuKzx4ik7OiGgqoYeGxJ7KrkJ1sf4fBKF0FbF9N90J3yEtc1VCEpsUXwqEle6L4XlxpDZSPLAtCR9NOXdiGEJKRFKLMNsi+2hQ19c9gRfZIlIehKeulOeJAI/LYYVc5+EPBS1+/53d6/MaEkTSRlpyfuRpcCp5amzBnBocJvdv+al3t6KfHE8DjjRBJ2dKmgCgOPI4mIxTnhyONIh5O0fvsEPGVeUrqKIQWpzj62f/5n2IJubrvBQErBtkgnkv2YzZmb+58d7/Porlf4y953ABuKkKiKgQB0adLEd6T6+PnW5/nJpqdJG+bzzRBlV2LSjQ1p8MP3/8YH/d24Knw0fuMsdnzh/gzIuY+aK45l7y2/JdXRS7C2itIvnI4odWOkdJMCL0BoBkKR/HDD06iGxgeDneADUoIhtCs1CZrkibZNPLTxLX63+X1wDdHEMzqKSSXfGe3nnjdf4yfPvIrUzIFqaFySwvxJSp2bnn6OXbt7EbqZbCkVshv7wjCfAr/6hydZ1txILJpCNTCPl3GoogMG3P6PF3G4bHzY0W36WhnWGSqN9Mym7fxrUgvOM4+j78bbstcjdO7J2S2fvYP93P3OKzy49ynsdh3DMNB1AZg0b1U1kIrg5veeoF+243EksNsgnrRhSJO27LClsKlw08bfMK9kKmklSsBvkExq6JlraLOn0VSDe7Y8iRM3GwfbUX0gUwpSV0j39NHx/TvNfkqVJVx+3w/5/vZ3qLzepD2nO3vouOUOKq+9CK3CT3u8n7vfe5m7P3gRRTPMycEwJychAEWiC8m333ySAdGdxYD7iwC+8e4fObapmYFUAgMFBZldhTMM87Hh5zv/ToXTzrboTkAh2j7I4+seZ2DPIN5aHwfffiiDlTG+9etvceHa8+nfM8gfL/r7KBZVONXL39of46/t/8CppTGkTtpQkJi+VIWOIhR+sesX7IoY2JUUipCkjOGyE5pioAnJbZt/yRTPEgb1GJoqMaTI5omIzH11z6Z/EZRB3u7sGP7CQ5KZ417Yu4uH336LX7zyDhog1cyPwOzunYauaJS7//Uqv/nbWzhjoGsZerfIUKnjoGBw02+fJt6fRB0AxyDoTrJ0azVu0sS//dCTHLpwEpFwHIc0qd1DNHElaZ7vwcdfpSLoZcOWDuyYHc31aIJ0dJBUXzc7HrmNF9eu59fPTOTBPzzF9j/eRmqg27ynogkUXCgp6I1E+elfX+W3T76FPQpGQqLbTD8IA9SkWVvs5l88RTKpo0QkDqT53TIdztWERNHhuw8+yaGrpjLQG8cuzfnBUDMr5kmTdv6zJ16nqsrPmzvbTV9q5HRBF2l4bfteHn7rLe57/9XsZRh5XaSE7niU2999gRciT2JXdQypoxvK8H0pDBQhuHXzH6h1h3EoSVSbJGGoGFJBILEraTRF8siuB1kZW0pCDxPQDJKGana5F2ATOpoweKbzL6yqWEO5IzfF5D8p/3MW1dVXX83atWtpaGhg3759fOMb3+Dpp5/mnXfeobGxkeuvv549e/bwwAMPAMM08YsuuogLLriAF154gYsvvvh/RhM/4XP3sbO9cJMxVRGExgXYGe0ftY+rx2MYyQR2f5BAnZM2d3/2OOkek4apuIdzEvyuJK01hesDAagYLC7dgbTMQBPU2B3EC3SRNTVUDKWZrmQ3hsWx0rKaHbEhZJ9fUrqN9njhvf74vgFeueJRYnv7cFQHmfKdU3BU+Ens6+e9ax/OtpyY+t1TKa+upysxUNjfQqHaWcLeWNiCJg4Bm4eeRNTCanNfOaUPjwqpzj62Z0DOkNgqS2j4yvmIUOE4EghKRIB90cLN/1QhqLOVsru33zJPIaS66Q9bNy9VDFAL716YIsGBQkovvEevCEFJhYeOQQu7FUHQleTVG24k3TlcwkArK6Xy6ouzIKcsoBFzWLOINEXic1mnrEsJuuEkZRSOSQWBSy+nLTrIyCVzPRqn7VsPoPcPUv/l82moaWZX/wC6NEh3h+m44S4Uv4fKq8/N3ndBh4N+3domVZG4PNYsKpA0BGKkLIgECoIJfht9qR4kkuRgkicuf5x4b5xDbj8MT6XX7CbuDLJ71zZ+f9HjOEudHP6jA3B4c7e1HIqH/rS1Tbqh0J2wzsGREjoGKojrFnYLQSBayd7+iGU5gUYZpKNjwDKfJYCdRLc1k1AY5mRfTJwOjbgFAURRBBWlXjp6B3PsTg72sumPt5Hs78bhDzH3mAt47Xd3kejvxu4LMX7teuzekpxjee02YsVqYYxhppWArcRGzMJuVREEm33sjQxYbsFVNLrZTWEqOUC5z8AbKDwPAGhCp9nXa6kDEp+mkTQKx5yCwkGVa1lbe1KRY1nL/1M08ZNPPplnnnmGrq4uysvLWbRoEV//+teZMmUKAGeffTbbt2/nqaeeyv7N008/zZVXXpkt9Hfdddf9W4X+Pk6As/SiH5BMWaezK3UOBozc4NfjMXY9cifpyCCNZ6xHHR9ADxqksoPtnSh+b85gW+KN0FRpHYxOJcnc4E5re9AoUQeLgCAYNMqJWAQsQE/KT3/aY8nIiqZtRQfSaMcgr1zxaBbMjLvmCDZ/97Hs6ynfOQVPZQlJ3ZraDeBWnUSKDO5IgcD6WIYEw8jNP4lu3MX2z96bfd14w7nYWpstT6UJhXRcK9pJ2Jt2MRi3plqqCQVbWrXuW5Y2n3YtRY4oPl1ANEVB9wpL9leqr5c9P72NVFc3WlkpofNOpvueR4a3qTIgx+5J4vLqlv62qWm8TutJQkqIp61XajWhMBhx52VR6dE4MpZACwVwGi4GR9QByvdQgZDYNWuauKrquNzW100RBpU+6/pFqlCo3o8mnhxMkoqk8IxYofFrKikZY7Ajgs1jGwVuANJSIKWtKE28L2md9Kobgl19JZY6qlBIdfmIFRkHSwYdxAfSlvO8GgNnXFj3W9OLlksaE0VMVQSaTSWeh0U1EuQMSSFwA+aKq40ido9hphVCUOSSoCgCWaUStQCdALYaiNqTlknyfm+U8mDUknDhUpPUeayZxyZDqjhNfE7JIs5u/rSlXjH5d+bv/3kOziOPPMLevXtJJpPs2bOHRx99NAtuAH7605/mgBuAlStX8vrrr5NIJNi2bdv/rIoxgM9tzfpQhMBts43KeDeSCdKRQVLhbnY8eBtq3yAGMgtu0p09GP2DmbwOU9J68cuVlsXqzYDEQBXWdgsU7IoTUSREHIqtaO0HZQxUU2eF11y5qQ6SaAuz4aqHcsCNo8KPIY2CLLLsuRC4VFvRTroOtbjd+0uqs489N/825729t/x2VOLx/iKRuLTidrtttqIdl502tbjdY6S3F1Mz7S68i53qC5sdybu6zV5FV1+Ms7XJBDVDeS033UG6N4x9DHFijJFKXdxuCvpbdTvRQoG8/tZKA7ngBnCqWtGmrGOhgBtSWCb8Dsn+CcZ2rz0H3JgTiRMFBW+lJy+4AbO4ZjEW1VjuSyHkmLpSu2zW2Q4CcNptKBbsIMiUQSjSTHZM8S3H1uHc5cifqGv3ltC4+tSc9xpXn5oX3ACo2hjsHoMYUloyqMCMgWLjiQDcSvFxUEi1aFNWXRafd2Rm49XaJoFb81rqfNzyPwc4/6/LEUsmW960hpQcMWPiqMHd5g/SeMZ6bMEQqXA3bbf+hMiH27PgxmxudyFaaQDIdH4NTMCrWa+EuFQ/de6ZlsBEYtDiX1NUZ0pgJdLiCVCgsKB0cREdwXR/K/4idFS/zc3SSXMYf82ROe+Pu+YIHBUmSjeQHFY90/KmNZAcVjPT8qZVheDwmhmWE4CCYG5pA6V20+6R21O2yhKavm12bk919NLzjQcw8lDIh0SXkmNaploOuAaSo8dPKkqjXTtlkmW9DGunqwABAABJREFUDUUIZtdXU+6z9rfXaWfphKYidFTJ2mmTCtqtOByoXi+lNTXZhGIYrjWjlZWi+L3YnE6OqJ1maY+CYIq/gXKH9ROZR3OwtHyiJRDUpcFRDVOLxsnRzVOK+7txsmUzRgXB1EANVf8fe+8dJkd1pf9/blV17p7unpyTNDPSKOecCQIRTc4ZgUAEg3FYb3Bar+OuE5hg4wiOOK1twCaYnKMACYSyNEGamZ7Quaru74/q6ZnWdFdrv8jr3z4Px4/MTNeZqtO3zr33vfee9xy3vd0e1cmi0mm2k4AhTZaULbYFQhLJorIltjszCgoLS+3vIxC0+uqodNnvznhUJ2uq24u292ltU23bWwInz5hSlG59/NyOgqxUsGKf2urLqCsP2trtcmisnjOpqH+fsKAjL2BKjQyw+7H7cj7b/dh9pEYmHtWoiuDY+e2oqr3dLbWl1FeGititsm5WW1Ga+MkzCjP7RuXU1mlFaeJrqmaiicKLYgFUu2uoclXbPksTDmaFFhaniYft2bRHWz4EOB9QzjlmDj53/lWUENDRWMl1Jyylo7p8gkM6SsI0XbQJV7icge4uej5/Ry64KQvl6N8yeyUXNJ5sa88FTSezouISW53pweOZW3YpTqXwJFjqnMzSisuocrUWpCK6FC9rKs9hRfmqgvcRwEfqz+CylpMK6gBc2nwip7qn895X/jvn8+1f+SPJXmt79MSauVzZtpZAgZwjApjsr+KatrV0ltQWHAA8qour29ZwZuN8W5s2TzmWmzvXkT40lAtuPn8J3ikNNH/+Eiob6xg+0Mvef/seegGQc1rTdG6YsYygM/+umQDaQ+XcPG85syqrC9vtcHDDgiVcMGdWQZullNy8chkfPbYw3Rpg87olbD52CXbL4Q2zOrh+5WJCnvx2a24Py276OM89+SQLpuRSe7XSEFUfu4aqG67AV1LC5tnLOL9lYWG7kdzUuY6Nk0+wtfvy1mO5pm1dZvKeOFkK4Njq6WzuXEWp21PQd1sDpXx05irmVdQVbAG36uCGmcu5tL2wn0gkt85ew41TjyuoA3BN+xoubllvC3KXl8/ijPqTKXEUBktVrkpOqT2dyf6OgjoOxcFJtadxXFVhmySSsxrO4rKWU23tPrfxeK6bsqbgxCWAddVTuHHOcsq93oLt3VQS4qalS1nYVF+wvZ2qyqY1i7lo7dzCdku44ZQVbD7DPl3GFRsWsvHkJYVTeAArZraw8ZSlVARzdxXGH095QxU88ujjlJRVkRrusz4/DORoqsrVJy/hwvU2fiJh81kr2XxWfvLMqFy6YSEbT1yMamP38s5mrl+zmOqSQMH2rg2WcMOipayobSnY3pqicv2MlZzXtLaw3cBVk07iI/X2cTPrqzdwYu0ZqDZgaUpgBi2+Ntv7HG35EOB8QHE6NcwKjdFQjXFsPXQHaNVONEXBVeGwIuuxBpfR3QMtHGby5Zfl3LNs49loZcHsnYSQeH1p/C6NSreDoCM2gQIukAQdMSpcDvyqgzrHEGp2lTemF1Ri1DkFTqHR7hrEJdKH6UBASdDuiqGg0umOElDiE3RcIkWnuw+XotDqMQlrIznPAVAxaHRHCDlUKlxO/NrhNGrrn19LYhzq5/KTzx0LKP76Bdnjqrdvu59k7xABh9faek97MM0Mw2iU9gjohkA1/WiKhtBLSOvKBB3TFKQTXhyKA48IkNaVCZRdKSGdduJWXPg1D8LlRAv6cFSFafr8JWjlQaQEtSzIv//8ezQ0N+EI+RGeUaA79t0UxaDM48Slqfh9IBR5mA6gmoT8Cg5Fxe9zWAUKM35ixGPoAxErFsSt4NI0Qm6LQqpHIhjx+JjDSSuDrd/poMThtgIxJzY3SgpCmguv5sCVFORxE0QawooLp6rilVrOM7I/m1DqC9Lc2ETA5RqnYv1PC4dQvB4cqmV3jV/FrR1ulJV+IOROEnRq1HkV6rwRlJwKyJZ/V3uGaPRJSl2CzvAhHHko5+XuYWaEE7hUhfaKKE5ton97nCk6KuJoQlBfbuJ0TtRRVZOK0gQep0pliQOHMz3RbiHxedOE3BphlxOXlo/eLnGoOqUuy5/sJoCA5kUVGqb0YciJ/m2YAkkAFQ0pg6TNPP4tBQnDiyacOESQpKHl9e+E4cap+HCpXhK6NqG6uZRWjI5bCeBWXZi6M6+Obgg8wodDqPiTzrHsujkDIQRSTlRFoUx3T6SAY7F/vCMqblWjAhdaVDLBcFPiHoIS1UFIc+IcMcfok+N0tZhJqerE49Bw62Kc7443XBLW3Giqgts5dryWGolkwY2zpIw1l3+S5cuXcc7HvoizpCwLcpIjkezfaE7rHsGAJ2+6EAmgCnxeJ36vq2AOK4ASnxuPU8vN9TXuhlJCiduFQ9XwqGPvbfwDpQSvpuHUVIIOd5YWnmMU4EDFozrwqZa/5fMT01Twqh5cio+0md9P0qaCUwngEC5S0p3vlaCbCpoSst0N/XvIPzzI+B8hRzPI+PZHnuOOR57DNM0cCrjhAqlZL3PThiV87aVnACsAVMmMlaYD0sMDdN1+B/q4zM2OqjC1/3I5jrIQQjFRNRNNEayqaiPke4bB9ACmtOrNjNKtPWoaRUDQEeakCpXe2FOY0iBqukhJq/aUX0miCRNQmBs+i4PDdyKlSVS6iJnW5BxQEngyX6Ks5DbeHbBS2cdNB4OmB6TApyTxKwmEUKgNXM5fDv4FiUnaVBg23BhSwaXoBNQEilBo8s3n8b4k/SnL7qSpjdF/FZ34wSiPXPtnhvYXZ1FdMOt07nn3WUxMFMWigFvMGgWZOSu+fsoa/vPNJwBQFBNNtSZLw1QwDAVFKFzWvpAfbX8+c0QhLR0hkaZFJVeFwtLKFnbHeumKD6JH45jxFI7y8f4iKHP5mGJ4eD66F+lxWZRfKUBg0dOtH7mkdSV3b3sWQ1rPkIZ1Qagmo4u1ze1r+OqLlp9gghmN0/uN72MOj1B520ac5WEu75jHfU++Sby/j/333I7q81Nz2VixQU0IljQ10LUjwoH+IQsmqIzRxA3rx7DPw6Lmeh59fTu6KS3KbsYORbfo5QK45OQF3PXUi9agJcZ0RKbiOMCmExfz1bcziejyjCaqIrh8+mweH/krujQwTUHSsCjJqmLiVA1UIZgVnkTA+S6HUr2YUjCYcpM2VTTFIOhIoCoSn+pnSmA6r0ZewJAmkZSHuG6lAwi7YrhUa4ZdVnY2P9/zV0wpiacdxFPW6sLnSuF2WMGZZ9Wfwre3PQaAriukUtYA7nAYOByWTWc2Lubnu14mLQ1ME/S0ikRYfqWZqEIwJ9zEsDnAvtghzIwvmtLawdUyPhDQPKytaeVvva/aHi9d0ryOB/b/GYlEwaLqghUHYWbWo+c1bODX+39nvStMNCXj31LBkAoKKsdUreLB7mfRpY5AogmrwrkpFXSpoKDQ7m9hT1SyJ3YQiYkmTBQhkVKQlgr6SApXSjCvYS2/3/M2hjRQFIkQ0srq7fSgeC2/u75xFbc/9YJ1NJyhgIM13onMYuTm+Uu4+9fPWe6tWBRoxNiYqCmCM5fM4KH/fpNU2kCKDAU8QyVXk9axSufkahLRFDv3ZtrbKazK3TJDyZbg9ThZsbKdB59+x/JvZZx/G2O+e+nZi7nrT89n299Ixtn+p7vQEyPZgOKrT1rMnX9+jtTwANt/dzuax8+kE69GdXmsfq4KTl86nT8++Q7JtM5o7pusCFAUhalNlehJne37DuUk8tNTccx0EqcvhNftYO3SDv7w/NvopiQ1EkF1uKxnMbbfesUZi/n2U8/l7XKjOpuOXcTX3xtNEDmxY6pC4Zy2GbwQf4qEaU1KVq6zsWWFgkJboJZa7yC7Y3ux4jctPYnIAHGBS3GxrHw+Tx16ChMDFZmN8dKlkrkrfGbaZ2j0Nk6w5X8i/6dYVP8IOZoAZ91/3EP34HDB66oiCNX76EqNTDjv1wcG6PqOBW5clWXU3nwq+zK5VUZ3CxzjzprDrjhzq/bZ2qMJg9XBbeSdabKi0OjQkbbVnVUSNBI1+rArehIx69if0rCLwxnW3bwXqyx4PTWS4pGbHmKkL5UFN6MyCnIcIS+dXzgbxVHDQKowRUgRgnJHkO7YxPYeLyUOJ1EjhV0cjkCiFin+CBKnim3MjyIEbvwMpArTjRUhKDPDdA3Hsnbr/RF6v3xn9tiy8raNlAWqGd5xiH333I7e34dWWkb9VdehjStGqKTBaR/3DBIcun2dGkUReKrc9Mft7Q61uOmSw7btXR3W8QYHbNvbraZoLekveD37TOzrQykoDKdr6U8VrvCtINCo4kAsbhtE7BIuRnR75o9AZkFTYZGEXOmidld7nAzZVC8XCCpdAQbTEdt7acJFrEhxV91UGEjmP+7VR5Js+eSvSEdi1Hz6akTZ2DikH4pw4LPfQw36qfnkJTh8Xkr7Q/QNxwu2kyIEDUk/kZ6obRyOT1eQ/UXaUsqiDEAJiICGbpMGQVUEviovfSOxHMBhJOMY6SROf8jql2EffcOW3YcDjlFxKSrpRDGjJtqtp+K895e70RMjdKy/FocvjPCr6IZJamQcoNpwdfaZqqLgbfRwMB4t2N5CQKjRTa9i3y+Dfp1AkSKwDsWg3ld8QHGpCoZtGgSFY6qO4bzG84rcy17+T7Go/q9Lf9Q+4YhhSgbTyYngJhLJghutrIyGT16Jf2qTBWoywau7P/1D0ofGBjunWrxYoUOMbpMXFoGClPaUVTDQ5QjFKrolzXhRppVeJArf6Xey8msn0PmVXHAD4KosofMr5zHlC2fj9HsZ0e1pxKaUDKUmtvfhEjVSRRlLR8pGKsZCUBD/T3ZrpSEqb9uIVlGKfrCf3i/fSd/W99g/DtzUXbkpB9xkDDoyu4uy3wQjqSOwO49/Hy5JmSja3tZORHEpVvwSBFHdnidvIhlOJ4oypGJGyrb2GXBEBSkFxe0WAuJFcu5IJDEjXvReSbO43XasNSOeIh2JkegaZO9n7kHPZO8eBTd67wDG4Ahm3DpvGkmmbHuBKSUjsWRRplEyaRRlERXpboDVlnbgZlRGEqkJZRFUlwenPwRk7I4ns33F6Q9NADcAyfT/m91mOomeGCE53Me2B+8gHY3kgJvUUB96fAQjnRx3G8lIyj4XlpQwnLbXATBIF2VaqaJ4OyoIW3AzKoPpYkDp6MqHAOcDSjG2iqoIQk7XhMF9lIGilZVRc921lFZVY0qJozyYBTla0IfiGQtgTpvFE0+npUaxmVliIkSxnSsVh1KCwJ527la8FMun4xRFVjaAp8SBpyKY95qrogTN58KUJgGHfTVaVQiCTnfRydSvuYpOykcykAJFBwhTSgIOl62WKgRB10S7Dwc5B/7r26THgRtHKA8L5gh7dTHKrmlKAq7idoeOoL09iqcomNDN4ikOgKJ0VJD4NftijAqCEoenKAjwas6CdhvRBKlDQ3lp4smDQ+jR8ZMSRZ9lxU7kD9Qdb7dX9RZtA7fiKtreis3E5aoIMPNr5+CuCaL3DnDgs98jsW1PFtxolWFq/+WKbKxgicfeTxQhCPhctgwpALdHy7vDo6fjJGMR65fDHpSMR9DTucBQSnBoxTtCicc+JkYRghKvqyjl3O1Q7XPgQN5h2ekL0bH+WlyBMpLDfWx98HYSB/dkwY2zpIzJp27KAq7R25S43EXtDjrdRddoGs6iCzTdLN6OJhJNFK8kEHbas/aOtnwIcD6gnLlgRpGKzJILZs2aMJkqHg/VG6+i5vpNOEtLOad1XrYDWCDnUhr+5QJUn8VgUYVgXukcQo789bZGpcRRRbV3jS0wEQgq/Bdi//oN6gPnFgEvCtNCJ9veR6AwIzSPcqe93eWuEKurphedBM5tmW9LfzWk5IJJc+0rsyM4t3Wu7aSsCsGamnYafGHbQaLSXcJxtdOKTvDnt86zvW5IyYVT5uS1WysNUXblOTmfVZ11fl5wowrBio5mGstDtnaXl3g5fm6H7apTIjl3wYyidl/UOdu+vYXg1IZFtnRUBcGMkmlUuWps329AK2F+eElROuoJNfYsGxPJGQ2LbEGAguCMhgU4lIkLCyOaYMe/3M/7n/gxnXqYFl9V1upk7xBvf+x+tv7TL7IgJ+TwsbZynq1/m5isr1phvxOC5Ljq1UWPuo6pWo5TKTzhKCjMCk6m1VddsL1dlSUs/calhOqqLZDzr3flgpvykNUWUnL+rFlFd3DOXj4LwyZBpaoITlkzA5czt731dJx3nriHtx6/g3QiwuzOBtpaKhECkrEIW568g7efvicH5AR8Lk5cMa0oTfysVbMKFrYctfusFbOK0ttPXT4dj8umvYVgdlsdU5urJswXTl84C3JSw31s/dV/HQZucvu5YUrOWzCzqN0XTrHvl6oQnFI/D4+anwUMVh/oKGlhkq/Ftl96VA8rypcX7ZfLyuzZnUdbPgQ4H1DOXTyTipLCuzhL2xq5YtF8ljZODKxSPB60UIhqv58rZy/k6raxQdlRXpIFNwCaULlx6jrOarjY1p4z6i+is/R6hFALDjhtocupCV6NQ63OqzM8ZDLSN4+6kisp9eQ65MGuNNEhC/S41Eomhy5lYdm5Be1RhMryysu4qMk6dz28v43+fmHjuVw9+ThrAihg+IXNq7i8bSm1nmBBnUXlzVzRsYRV1ZPyK0iocPvZOHUJ100tQNmU1mr7lhlr+NSM9VbAXQG7PzVjPddPWZt3EhyVSyYt5fK2JdT7QgV1FpY3cdXURaxrmGi33h+h756f53zW88v7SEcGJugqQnDrmuV88vQ12e9y+HcD+MRpq7n2xCVWpfBC7b16LpetmE9Daf6dNYB5jbVcPm8+xzVOLqhT5vaycfoSLms9voCGRBEKV7dt4OyGi0kOJxnpOTx+xjJyhTiOlb5jM5N3fsPXVhzPqXXHUO+pQBTQ6Qw0c1bjatZUdea9DpKw08slk1ZyXfvEittGPIU+GCXVPcCTN32L8wPzAZETGJ+OxDBiFsC5oeMkLmxebws6Tqldwal1x1Drrir4Tib7mjm59hgWhvNTkqUEn+bj1Lr1nN9wSkEdgeCSljO4of3U7GeH6wB8bNmF/OCHP8y5VnndWVlwA3BB61yunDufSaWlBb/bjKoqLls2j/Xz2vMrSAh4XFxx/EKuOX9FjhFGOkk6OUIy2seWR+/gjGMmcePla0jGBtny1B0kov2kUyMY47KXb750NZefthi3u3B7n7pmBhceN4/W2sKLrymNlVx07DxOXDiloI7f4+KK9Quz1PV8XU4IuOnMlXz0vNVWsP5hOg5fmJYVubEpTevyJxY8bek0Lls+j/bKwnZPra7givkL+Ehr4erdfoeL62YsZVPbBgDSI0mSB8fFk2aMvL7tJNZqK0mNpAv6yTkNZ3Jy7cm4VU9B4LWsbBn13vqC9vw95EOA8wFlOJWiz5HEdOQ6rQRMF+wzR4jpaQ4YEXCM0cMtHQmqJKLGGEkn2Z84lGVEjBeBRCop+lIjHEodwpigYf1uAIdSh4jp/YwYYsIZu5SQNB30JbvRzRGG9TiGVHIccnjQ5PqLD3H+aQ+xe+97xNPdjNYQ7z2Q5tbz9vCpy/YyMmSQMobR5QiDqa6C7WPINFG9n57kQJbWerikTYWe5AC98SiDcSVLkR1vdyqt8f7gECOpFL0DOqaea7eUYKQU9h5KENPT7O+OQ0KdoCPTCoOHTIYSKXb2DmHENA5fxEtDEIso9AzH2DM0TCqh5e3YqaTGrqEhDiWixNJGXh3TFOwajhDVUwylYpk1UK6nCKA3MUTcSHNgeMjSyaiMDzR2VJTx64cfJFRVg55hUeWAHBPMpMnBoSjdPYMocfI6ihqHA92DRCIxjIiOMCYariWhe1+EeDLN8EACcbjTSYuNcuhQlIRusD86VHB9N5xOMphKMKh34XOkJoAOVZj4nFGG9AGGBt7mLzc+zO+v/ktOpWyHMAj07+OaUzZy9sln0Jh+F7+SW45DxaDB2U9YeQNdxqn3bCfkyG0EgaTCOUKVexu6TKFpuyh1xQ+zSeLV0pR5u0iaUSJGFwFnEjFu18RZXkL7ly7AXRNk767dXHXKeYy8szuH9df55fNwVQRQhUlPoo/+ZJRIUmKYE/07bajsGokQM1LsHIaEoU3w3bjuYPuwTlxP83p/mkjCi5lH590BD5Fkkjf7Y/RGfeiHPS9lqOwa9LFnJMrOwRi9g94JWdINU9A/5OW5t3dx/RVX51zr/c4v0Q9FrH4T1dh9IEosmSbalUAdzQQx1pSoSRg6ECOR0jm4M4KWkBMQlaJLjINJhoYT9O4ZQEuY2fu4vCGmrb4Wl6+URLSPi8/9CI8++jfefOJ2EtF+3L5Spi+/FpcnlOl0kq7uQfqjMUYUncOHHYnFvNozNEgslaZHi2G68ozfbuhWYyRSad6Xg+gBOPw00nBBXzBFJJVgR3qQZHiMrTUqpgbD5ZL9yWH2xYaJhiSHRxskYwO8//T9OZ/tfiQ3saAEDA/sSA0SS6fplTGr0OZhc4rUoMeMkkin2RcbyMSITRwI4maCgWScvSMREkNp3v7UL9lyy/3ZvGMmkNQV3tj+LuetP4+HbnyQ+HBuOQYTwXDaya7oIAOpOLtHnCQP+3KmhOGUm3cGE7ZJSv8e8iGL6gOyqL7wyN/40cuvWluBpkWxRVhOPTriX7hkJve++4r1yygSAQteKtZW4dlTpvJgJEP7G9//hVX9WUEwp7SekPcl4kaM/Es8gUf1cnwZ9CXetGJtMFEylD6r9q9l1NzgOg5Gfw0YiAwlFaCry+CGcw9wYI9OQ3OYf/9JGRW1Dg4eSHHb+Xvo2pOmptHBl+9vorLGTZn3IzzR/2zB9hEoVLqn8NeDCtGM3WOT/Oi0IvCobkjP5NW+PZhIFGFmOqbITAjWX20oX8Qv39titbeQKKo16Zi6ktW5pG0eP3zjtYwBEkaZUIYCpkAVgtPaO/n19i2MvhShWfeThgBTQUEws6KaPcYhBpLWJCkUqwK0lFhVpRH4NSfzast58dDuzFm2zE70o98N4Mymufx692uYUk4AQqM71uc2LObeUbvJgJuvjLGoam67hrPmLON3f3yOPT+4nfRAH45wGfWXXYcjGEJIy1c6qyoZeHeYgRGL1XJ4NXGBlaJ+dn01L2/dizmeRivHqOQAG06cwa9fesuyG8aWROaYztnrZ/K93S+P/9LjHQBVCM7qaOd9HrYGYGmd65sIVGGiKRKBoMVXS/XQU/zHBY9zaG+C0gYPV35/IeW1LpI9Q3zjktc4tDdBTVOQ237cRrjaQdxwEDctmniJmshSUyu85/HiwKNIrMrGMd3ahvdryWww87SS0/lt19PW15GCuO5ASnCpOg7VzGQEXsgf9r+VtduquA2qsFILJHtHeO2jDzC8f4z95a4JMv2r5+CqLLF6nLBKmswMtfJi/3ZMaVp9LmPrKNUW4NS6xfx+3wvZPmDl+hGkDAWZafyP1C/l57ufzzSviUfTEUKSNDR0U0UVCusqZ/DH/W9lfdKj6SjCJG2qpAwNgaDVX073EPTEhwGJQzNQFRPTVEjpKvqhQbo+933SPf1o5WWUX3Qeh358X7bOWPUN16KFrR2GS5tm8atntlh+IsYmcCvlgHW4ceGcWfz2969m3WR0jBRGpkCsIlgzv41nHt5q+STjUhyYkIxGeOOFO0nEx7W1t5Tpy6+xwM2Yy+FwqMxcNYmn39ppHS+ZktGQI+ueVnufvn4mP3vlDatPmmNpPkyH5esCOGfJLH7y2utZv1czqZxMB0jN8u9jOibzyDvbrWdlQB2mdd10WI9rKg1hxEwORIYsRlXa+u6p6AA7f3kH6UgfzlAZJ93wMf7wra9Y/TtURvM5m3AEw5ZNmU539oqZ/PTN163uZjL23ZQxu89fMIMf78lUE88z5qhCcHxjG6/EXiXeG2HrbT8l2W2B8ylfOh9nRQnJg8Ns/8T9xA7046ktYdE3zsBX5UUVVmV5PTO4aEJlfngGzxzagomJKoys7yYNLTsqfnX2dcwKFd7tPRL5kCZeRI4mwFn0rTvpixVmUilCEKxycihtX9CsLGyCp3A1XoCQK0ZnaY+tPQ6hsyiw01ZHoNDgiCFlfhptzwGdG887wIEMmPnY12r5yi0HxsDNfU1U1FpbvwNGFd1pF3Y08Ujaw9Zoja1Nuil4t68wlRysYyN9OJBTIPFwURCUKT76YgnbtvQ4NJJSt2cSKSbCU5wm7i5SaFEVCm7FyYhNAVAFgV8PcXBkzG4zFqf3vzJ5cD62Ea00hD/mRA5AMtLP3h9YeXDqLxzLgwOgJMFtX5PV2qUpUvxYVQTUOhlOFlYUArztLg6qUdvz/sbyKFXlh7CjiYe0GPOCuxnoSvBfF1tgprzBzSVfmsoPP/5O9vdP/qSTsprCweYClW69nphhx3AUjBgN9CRStvEsKcPDYMq+rtPAmwd4+YZfZH+f9Y3zKJlWl6NjNU2hAzNLVKHgVdwM6YWZVAIIaAEiKXsGmJAaSQNbuw1DEE/kb0e9b5ADn7nHirkpL8uAmRD6QITub96Bfqgv+7m7tJTyATdDI4WZawKoSbmJHYzbxrM406COTNwNHZXBgV289vwd2d9nrthESWnzBD0JxKsn7ryOF1VRcNY6GUja210S8hBJJ+zjcBBIo0j1r1FwNE7SQxF2//Q7pCMWmGm8YBOu0lKSkX72/Pj2sc8vvg5HSShrt6fCSX/SnnEXrnIQETFbP/G6dXx+6z7Jg0NsGwU51SFaPnYyO7/yB5LdETy1JSz8xhl4KgN572Mtyu3rWqlC4cSaJdzQfqat3cXkQ5r4/6KMpOyrVptSEjf0opHqKVMvysbRjoCudySUPlCQsrDdVbUa37i/lppGF1170nz0rN15wQ1AWqaL0sSPpFibeQQ6Akjq9owsE0lcLwJcgKShFy/GdwQ08SNJzCmApGlPobTsTufYrXg9VN50eRbcAKR0A0UIHMEwDZdeNwHcwNhq7oOKEKJoe0sJcSNdlJFmkEYpEkCuZdh24Ro3N/1oNuUNbg7tTfC181/NgpubfjTLFtyMStosgt6QJAz7vDTWfez9JNE7zFtffCjns23/8afsNn/uE4tL0rQHyxLLd4sxpNLSKOrfdkVCFY8LNehHqwxnwQ2AFg5Zv5eXofr9KG4XIEmm7P1bAslk8X5p6GZBuxPxCFvfyI1Fe/fln5GMRyboCmXirkU+qxL6Edh9BOOJYcri40meWyhOF5rXjyNURtMFm3AFwxabNhimMVOrUPX5UZzjfF4WtxsgYaRtAS6AFGZ23nFVlNDx5QtwVYdIdkfYesuPszs6duAGrAVasTlOSknUBrz/PeRDgPMBpSlkz1ZRhaDK47dl2Qig1OE/AhqtfQVwgJSpIbCnk0sMNKUCuxm8utbFv35jTs5nH/tabQ64AYFfDWJi39k8avEZV1MMnIo9TdiQJhUF6t2MiioEVb7i7V3u8aLbMDrAKntQTKTkiOwud/lsAawqFKq8E+1WvJ4suBFAqd+TtdsRDE0ANwCK8whQF+B0FLHbNCn3eW0HblURVLmLt7dPKcGQ9mApYY4N4uEaa+dmvFzypamEa9yowh7gSExKHEFb1oeCQqmzpCjdOuQs3C8TvcO8fPOvSHQN4q4JMusb5+GuCZLoGuSNW34+AeS4bAKMwVoMlToDRf2kzBUoyjYMOYrT8jWl8ISkeN3UfPISav7lSkoqK3L/LgNyqjZdieLxYALlweJ+Uhb2FQUBgRJP3p2SRDzC65njKbenlJkrNuH2lpKI9fPmU9+dAHKkCV4bVhNYfbfCb2+TKgQVPvu+CxBwO4uC/HyvTHV7aDjnapouuA5HSRhTgs9lHac6gmEaL76OhvNyFzESqPB6i7JAK1z+oms0j3DnABNXRQktH8utdzj5YxtswQ1YCzSvWnzhUespL6pzNOVDgPMB5XybwodgUSivnb3Q1vklcGnbUpw2TBxVKKyuXEitu77gwC0QVLubaAmcaEsTV4WThuAV2K0puw8k+eLNuUddX7nlAAcP5K4wZ5aejWYz4QgU5odX0OS1t7vRW8OpDbNtB26HonHltIW26wRDSq4p0t4AV8ycj0eza2/Baa3TmB6uKji4KQhaS8r4SNMcW7s1ReXytqW2KxxDmlwzY1FRuy9bMA+vs/DArSqC9bM7mJaHjpq1Wwgaq8KcunKGLY1WVRQuWzPfdvVqmJJr5xS3+4ymVVacVQFRUJgVWkKVuxOBwkBXgh9+/J0cnR9+/B3SB4O0l5xSJA2CwpKyM2xXryYmG2pOtN3BEQhOq12NL4/diYMWuIkfGCRcX8FZd91KaFp9NndMFuQcHEYgqPGEObV+ke1EqQjBBc2rivrJJS2r7I+nEFzQspSAo3AeFFUI1tVOYUFFY8GJUvV6aGps4ILpsybmZwqHUDxj5QOuWFHcTy7esMD2mEcRgjNPnktJILe9k4lx4MZbypXXfJHVq1Yyc8W1eUGOEFBZ6uesVbOK5nq6fGURu6XkqqUL7DN+C8HFC+cQ9uYv7gpWe69qb2HJ5MYJfU51e3CUhCy7Az4uWDQr23cdJRMXMRLJ1YsW2PY5Q0qumbG4qN3nty4i7PSNpTg4OMTOr/whR2/f1x6mLVlpW3A17AxwWt2KohXl19csKnj97yEfApwPKGfNnMakson0yNHB9bRpUzlz6nROaZ0yeuFwRTpC5Vw4ZS43TbFotPnYOB7FyXUdx3Buw+UWqymPjkRwbsNlzCrbiBA+Dh9LRv9mRukN1Jach0Obmvc+PQd0bj4/wu5dPdQ1hfj6L5uobnTQtSfNbefv5uABiy7o0tpoCZ7H8sqNBe1WhYdllZdxRcv5UMBugCtbzmdTxxq8qrOgzk1Tj+HC9rlMCVXkp5EBJzVN4ayOGZzZPi3n8/F6rcFSLpk+l39eXJhK7VEd3LpgBZ9bcLwVn1vApi8sWM/1U1fj0wrbffPUdZzbOo8pJdUTnjWqc3ztVM5onck5bTMK2tRSEubS6XP51PGrC+q4VI2PrlvOJ85bax2f5TFKIvmnC9Zx5amL8Xlcee5jfXDtGcs4c8kMOuvyxEZl/mbdtEmcPmMa53cUBvpNJSEunTqfy5vPzP3jcTdzKBoXNp3GysobGehK5sTg3HLfnOxx1dcvfplw7Fhcij9/AwBzyq5iTul66jz5ghktnY7AAhaWruKYylUFbIIKVxkn1KxjU9tHxjcLAJrHiSPkwVsb4uFH/8o/r7oMIRScFSVZkOMIebOJOm/pOINLmtcR0HwF/eTSlmM5pX4RUwON+fu3hEWlU9lQN48z6pdMsGn09ypXmPObl/OJzpNyCQvjdDQ0Pjp1Pf829zjEaIXICc0k+ezcE7hu3iLCLk/BPrd53mLOnD+D2Q01+ddMEpZPbuK0xdM55/g5OX87Xqey1M/5G+Zzw6ZjclRU1YXD6cftKWXBsk18/NYzuemqtXj9YaYvvwa3txSHy4+quTIh1XDLpuO4bP0CwiWeQmZz2YaFnLFgOnNbavMYbcmS9kbOmDuNS5eM7mZPvFtV0McVi+fzrxvWZJ4vD9OQaJrCJ45dyadOWo2iiLw6EviXU9dyxfL5lAY8eXUArlq1gLNnzmBhY26cV47dTQ2c1TmDqzsXZf/6cLsrPT6u7lzCJzpPtY7ienNjcKZ89SLcNWEG9x/kdxvvJtkbLTDvwHWTz+LsxnWEHMGC/n1m/Vqq3IVTCfw95EOA8wFlVyTCjqF+i4FzmBMJBZ7au4uD0SjP7N6DYhyGbiVgwo6+fnYPDvCHHdtJxp3ZStlgOYeuK3QPwou9+3i4ezvvRcoYTrtyKrsOp128GynjL93vs2VoJ48PVNGdCuaAnGHDxesjjfy+ZzuHkr38ecDJzlQF6XHxL3sPwLXn9rBv9yDNrc1ceu86PNOb+fxPWqnJgJyPnb+bLXu9PDUIB5NdPH7oTQ4kwjn0QClhyHCzLeZh6/B7PNG7lb64i5SZS91OmSp9cTeP927lxYP76Rky0Q+jgJumIJV08N87t7NnMML7+yOQOmxQlqAkFZ59fz+9IyM8+9YeHDElt2yBBDUpOLBniF39Azz05vtoIyoYYMbjVtVuCSIliB8yeHHPfh7ZuZPE3mHMoWRuxzUE5ojCX97fwcu9+zg4pGMauQDOoq5r/GnXu+wdGWBrf3+mGGeuG5iGwtMH9nEwHuWJHbtQ9Dx+YsDuQ4O8HxngL6+9m2VyHK6TGE7z4vt7eeaVHYiYacXjjHugMEFNSJ586X22vNfFSH/c4nHmGA6aDn979j0O9A/x/v5D5GOaKia8sn0fh0aiPLZ3R8G1256hCO9F+nix/5U8h6cWv0I3E7w9tI1Xtv83/3Xxy+NibmbTOjfITT+aSUWDmz0793Ps2uPpP7APNVtxPPPdkLiEQU/sLwylehhKbseRJ6mCUxj0xl9nWI/w+sAbeQZB68v2JQ+xP97FE71vYh7GNVZ9Lmb/x+nM/PqZ9PriPNHzHkNJBcMUFsj5+rlM/+KZCK+bWMrBI91beaO/ix0DkmQ6N/jVMAUjcQ9/2LWDAyODPLN7hGjMlTMOmKZgJObm0Z199MZG+P3b+xmOeDHG0btNE+JRJ1t2m2ztP8Qftuwi1uvHSI3tdkkJ6ZiDg/vcPLlrH49v241+wAHxw/JPJRXocfHXLTvYsreHkd1x1MPSDggDXIOCv720g+6+YXZs60XLsIfGjAItAe+81cWhyAjPvrAD9fCTSmn55aHuYXbsPsTfnn8P6RTZE3TN4WHG/MuZuXgj0hPgpTf28NRbu4j6rB2O6cuvYdqSK9AcHkwNUgGVR97Yzls9vexzx9C9h3UVFdKl8NC+9+mKDfOK4wDpsIEcd2QnVUm61OB5sZfu2AiP61tQapPgGN8AEsJpuiu72DbSzUODW6ApDuOICRIJAZ1E0xBPR97nsUPvM9SYwPCbOfOF6ZEkG9P8aWArWyI97CuNYJSYyHFlQKRDolfp/Hl4G13RIV439oJfz9VRJPh1XjP20B0b5sn+t3G59cPKiUhUh8mg6GPbUBePdr9F6uAQ2z4+Bm46vnQB/s562v/jfCoba9mzczdPbf4lQ925dbt0U2Eo7uGhA1t5J9LN24dMYilnzrxjmAqDcS9/2L2r6LHp0ZYPWVQfkEX18Qcf4jdvv21tFx7ekpkOetL0dn63YyswEd0LLNryukktPNK3NfOpVbFXCDKDnHW40xYsJeHcSyoTsKoJA00x0U0FPVO+16VoLK6E7kSXtXIQBm4ljS4VEuZYxsrV5VPYPvyiVZUbE69i1ZLpG1T4+aZniPan+Pdf3kyP/42sTYnuIe6+7AW8pS4u+O4SvAEXzb6FPNP/dva+mjBQMUlLFSt8TVDurOGFQ0o2gFLBqlpsSpGtkOxUNNT4JN4dHGXayCxNfJSBAnBsqJNH3t9hVeVGHkZbttrp1JYp/PGNd8faOzN2i4yOqghWtjbzyM6dABiJOF3fvwtjZITajdfiCJYigOZwiJ0Du9n91W+hBPxUbb7Cqp4sYTQhhlNRaWsIsC1ycIwmPoq9xtl9fEMHjxx4N1u9fJS2PeYFsKF6Br97e9uY3eP45qN+sqa6hWef351tb5mjY/1rLA0Sey9KPJkevTRGE8+oOzSFyVVlvLu7d6z48TibRvWWHtPOo++8j2FOPPAZpUCvW9PGr3vfppCoQrC+tY4+5xNjdo+fJzIPq3aV0ime5cuXv8xwX5qP/Wg64RpX9jn9XUm+fNEWyiv8fPx79XgDSnbncvT/R+/lcZ3KO0PPIzEL6AhqPOt5uPeNsTY67LspKHQEpvOX7t3jrsjDtKDSFaYrCiOZ+lci47tSjtZmto6YW9yNbBnowrT2YFEUEylH81VZesdUTuOhvWN+omXi16w8NZaHb6jv5Hfbt2XtUVUzU3tJAWn5yfLqJp7YsXfMUtVEKFYaBJkBazU+P8khnaGkRTiQigRVgikQxqjdgnmBGt7Y152lgEvVagYrnYCld1JLO4++/N4YvXt81XmsgPUTZrTx2GOj4+C4Jsz4paoI5k5r4OVXdo1r7oxzjnu55aU+hnwwFM2wnzIUcIsibekoimDSklpe299lHdOYlr0IxqjnwDFLJ/Gn/dssHQkicwIvM5RsBcHJbZN5sPfNrDmkBZgCnCYik+ZjQVkzz/XuGvteaQGGsFJUZFB9hctHLK5m0k4AOghdgCqt52E9b355PS/37s+mHhFpAYqV3yY7p7R28Od9W7N2o2cAoSrH7G5t5+GeN8aaMbNTN5ruQhWC+WWNvDX8Hulogvf++efokRgdX7oAZ8XYvOgdSPPird9DCXpo+9w5OHwuq+o8Y+QQgaAzMJlX+vdgSMu/VcUaEQ1zLIXHtxaey9qawkkTj0Q+pIkXkaMJcOZ8+zvZASKfCKAk5GIgVbjSLoDHLzCcafvKxo404RL74p6aMGgN2nOEFRTq3FEMmZ9pkhhOk4rp1NdVEDeHGD+oD3XHcfo03AGrR8aNAMO6ahvLMJJ2si8atrXJMAT7++x1VKHgiHiIpwsHNQugXHoZHEnYtrfDoaJLE0NK9MEI++/8zlgBy6s3oYXCpEb66fru7dm8H1U3j7FJxh4oUUqK08RdmkrcKKwngJJUgIER+wJ53hENbQD7FOwJiadYUW4prZxNNqKqCnqdg1ja/vs5pzjo0+K2sSON5UPUV/Tb+kmpY4QFJbuIDeskogal1RNju/q7E1SU6HgDdjE4KgfSdSRM+4KbB1NN9CSNCYuO8RJNexhMuWy/m24oRNNFAp8lxJOFU+IDaEJB0d2MpHP7pRlLYMaTmbpPUCJ8DCZSmFKi90dQ3C4LeI8T1VAgrdizfwzQkkXCUCU4h+x1NEUhOKIRjdkz18qli0TEnm6tmBJhTswVNV5MDVIl9gHyUsBIo73dqqKgNsGQYc+ELQ+pxIjZx5llwINd3zVNgZ4sUk9QYoEnG9GEgs+jMZS29+9yv0oC+3QCDsXE5dAtjBRNYMZTOMsnzompQ0MoHiear0AcnYRY2t6/VaFwWsMsPjvnVFu9YvIhTfx/UVJGERotkDaLEeggFR1B7xvMe03vG8SMJY6savER6QikDaPFHXBQUuXBYGJl8pJqTxbcAJjSQBRhRthVLR6VsfR4hUUIijKfJJA2ire3bppZu7VgyAI1pWVWhuC7biexeyddd9wxBm5uygNujlAEFN2alRmbitltGmbR9i56kyMUAba1g0YlLY3iFFFR3E/UDPjxBrS84AagrNplC24sEUUZWwC6NG3BDVjvrZjdR3OFeLh/m7EE3V/6AV2fvwe9L5LVkRlw0/vlO+n9z+9jxnLpt4ZZvEcV73Ec0ZeTHFnlbkM3itKtTclRae8jSd8AEv0Ijkx0WTgvz9id5P9av5RIdLO4fxvSLJo5WAqZ3YXTfO684AaszN0FwQ1jO3m2z5KyaLqMoy0fApwPKFMqKorSDJsCIftijIkEh77+I/Z+5q7sIDYqel+EA5+9h67/+AFK/rx8ufqmikuxX00a0iDoqMIuf42CQthZbUujFSiUu8qLTiaBInRkAFUx8Wn2KwDdNGkIlhRt78Zw0La9FSGoKynJmUy0UDgX5NzxLfS+vjFwk6FqTxAJ/mJ2S5N6n70PqELQGCxud01poCjIc3iKV50H8HmL2G2Y1IWLtLciaPKFbHUUIKQV95OE6be9DtYc4VDsKasSnVJnpa1/C1Sq3WVF/FtQ7Q4VBacu9ciG0aDDPs2DIU0a/bl+YsaTGENR9N5+uj7/Pcz+IRoDIYyBwWwJD3N4BDMxtgshgNpAoCizTVOLkZ+tmwW99nabpkldRbAII09QWx0qOhFWlPsxi1TldqAUB0EmhD32FeVNU9LoLdYvFRq89oGxAqh0+4uCN4cqiufKwardZiemlBk/Kex3qhDUe+13xAVQ6gwUXZwoFLfbRFLuKlyTEay+21FSbatztOVDgPMB5eI5s20d25SSWxcvtx1s9HgCTyKF3tvPgc9+b2yl1hexfu/txxiMsqFyCjNDzQUdWxUKs0KtrK5YbUPpE3hVL2urzsQu+7CJyTGVF9geKUhMjq06Da/qKzhwKSgcW7WKWaHWgjYpKMwINXNB29yCHUkAAYeLzfOXFKV13rRyadF3smnJQsIed87ztFCYqnPOz9FdfetNuMryDxSqEMyprOWi9vm2dvsdTjZPt/cBQ0puWbCiqN0bly+i1OexpYB/ZMkMFk6fSEfN2q0IprZWc9bxue2tp+IkYxHLbgEet4ON6y2qaXo4gpEnc6phSm5ZXKBo6ajdwAWtawk6Smz9ZHH5auq9iwtSwAUKZa4O2oLnUnjoEqjCw6Lyi2z9W2JwSu2Ztjs4EsnZjcdS5rS3+8Ta+ayo7LDpl4L2kmoummxPE3epGjfOWJHjJ1pZkJpPX4FWWYre28/+z93NCaaP7i99N1vCo/K2jRMA+LVzFlLj8xf0E1UITp/aydpJkwrTxIWgvaKMS5bY90unpnHNhsW2R0+GKbn6rGW2OytCwAWnLaSqPFCQ3q0qguNXTmX1nEkF/VtRBC01pVy2ZG5BIGTZrXLz/GVF+qXJzdNWF53gr2pfSp03aNveJzVOY31Du217t5SUctW0BQW9RGClnbh55kpb4G1IyQ2da4rafWnrcuq9pQX9UhUKx9XM5JjqGQX9W0HQ6CvjssnLbOGrKgSnNc62tedoy4cA5wPKyVOmMKOiapR4MSaZny+aOZvVzS1c1DE75/PszxIWTp7KC089TVVDfRbkJN7dnQU3WmUpU//tej695nQ+2n460lAmbJlKCdJQuKn9NE6pPQVVBidQRE0JhoQzai9idnglIW16Xh2AaYFTaCuZx/SS03I+zz5LQkibxuzwGs6ou2QiESfzuyYCnFhzKje0f4R8NPH0SJLEwRFuaD+d6zuXEXJkqtHKsaO50Ti6T885hlPbpzK3qiZ/WwLnTZvJmtZWLp4/p2B7T6+q5COzpvEv69aMBekBemSAnp/fl2Pftu9+H6M/MnF7WVpg8TMr1rFp2hLCDm/W7sPb4FOzj+Hkxk7mlTZkPx+vA3B282zW1E/iipnzC9rdWVrB2Z0z+PQpa3PsHq/ndzm5/tgl3HJhZnArwNm87ZJ1XHzKAsJBr3XEkIqz9W/38PYjd5CMRpASNl+wivVzOphS5mLHL7/Dzt/clQU5o3c9ZWEnqya3ctX0BeQXyZTSCs5um8XlzecyWtPpcJNcqouzGk5hYcUNSNT8/o1gceUtdAQvQVMqJ/iu9buks/RmOkpWUuOZW7C92wPHMjU4j/XVJ+TVkRKqXfWsqVzJ5rYzCtKtnYqLK1pP4NapJ6LI/P3SlIJPTjuZK9uWUu4syWs3Ej469VjWN0xheXnLaNMBoJWFqPmnMZBzw+nnjIGbcVmuR/2kzVfG+R2z+dzydUgzv594hYOPL17Bp9eswjEahX+YDiZ8dt0xXLpsLtU+f94xTkq4ed1S1s1uY8nUphy7x/983Lx2Vsxu5eIzFuVVkUBDXSmnHz+bm689dqz22WF6To+DjRet5KZzV6E61Lw6EvjEJeu4ZPEcqsN+y+fGaY7+dsMxSzmuuY1jmppyjR338ymTJ7O2YTI3T19K3gZA0hEq4fxJC/jC/OMRhzH7RvUCDsHHZqzl0/PX4nGIvDpCmPzH0mO5vHMBzSE/+Z4nkdy2YAnHNbazvqmloN0nNU/imPp2NneuKmh3kz/EBZMW8fEMTTyfOBSVzR3ruaHjBDSRv+iwBG7rPJXzWxdS6yot6N+b2tZQWmSX52jLke1lfygF5dU9B3hnRw+qAwwHjC4+hQFaWvC7F9/mojmz+cPz7+AQCrrHRDrHdNS44K1DPRxcrNJx/c30f/nfSff2ceBf7wJAqyyl9saNRIeD/GbLO7ze30X3rhDecBRvMIGiSExTEBt0ExvwcZf6GtPrK/jru+U0lKrUhQZwOQxMCQeHAuwbKONA95uEltXyg3cFjYE6JgUPEXRaW9x9CR/vRSp5cPd+lpQf5Dvv7sKvNdIcOESZywpwHtGd7B4pY1/MZFXlbr67/Vm6ExWUuYYIOhNWrIxU6E/4OJTw8McDr7Glv5eBuBOXlsal6QhhgZs3PvEAqUiMb5bMYtGkhRyKJkAR6AMDdH/+e6glPqpuuxTV7eOON19gkqeC1/Z1WUyl8Qt9aVW3/v2Wd7hy5lweeHELig7mqM4oW8OAt/b08tKufdzztxdxJEFXIT08wP67b0fvtwpYVp92PomHHmDvrl1oX7+D6uuvQa0Mjd0nDUKHe194hQWtdRzsS4FTBYeRLciJLiCt8d2XX6YjWMkLe7pAU1EcRtZPpCEw0woPvLONy9sX8ctXtqAaCoZmWsuP0efpgq37DvH8nr187y8voKVBzxTWG//dRgaT/Pb5t+je2Y+RNscaJ1slFKQh+el/v8iimc0cGoqCAF1Pkk6MkIz28fajdzDt2Gv5yZ9ewh9I89uv/gvpwT4cgJlKoro8IKy2/eOWbVzeN5/7t7+GojDueCFjlAJbB3t5tns3vz/4MKZUAeNwkxjWEzzW+wweZTsHdRdeBTykUDI6cekgZrh5+tBvaQssZHvcoET1UaLG0TJMqZjpZNAIMHDwD3gcc3imfw8+1U9Qi+PKlIFImhoR3cOexJssKOvi53teRjd9eB0JXIqR9d2o7qQrPsjL/e9y57ZnGIx7cTmSWd81TUFC1+iPKvxq9yscGErQP+TE4QKXU89+t1RKI51ycMeWFzm+Zip7upKobg3NrYOaAUApBZlwcOfLrzA32Mgzb3WBywE+PUtL1krCVF54Lge+fnvW5WvOOB/Va6X2R1j+qA0r7Nk7yLPv7+EHD72Er0shUWKi+zKvxADHMMihNL965k2GhhKo+00cfkj7M/5kghYD9wj86MGXOGF2B327htE8oLszY5wEJQWOBNz/x1dY2FTPi2/uRiAzxV0za/lMMPsTL77HjhMP8YvHXsd0CtDlWMHWjC/tONjPc2/u4gd/fYlUWEWJGqjJjCcJ0N2CAZfOr598k0FHmkhQR4uCI2YxtiWge8AMwN3PvsyJagc7XQOoJQI1qiAytblMl0QGTO7a/iIrp9axVX+VcKmDkWEP6bQ1JTocOoFAgteTL7FzZAmvDf+OaRU6+4cDRBIeQOBSdar9w5T49vDm4Js83f8g82r3sztSQm/Uj0RBUwxqAkM0lAzybP8jDKYFrTX76I746Rv2Y5gKQkhK/VGqQyM8dPCPJFiOKHmfMuFlcMiDbmiAxOtJUloS5+H+h1k70sq25CuUBzWGoh5SumW3U9Mp8SV4K/ESO4aX899djxPyJImmNNKGRR9ThMTjTDPMfp499DY/2/UC+SAXWOUefr33eWIpjUMjCg6HhlPTs/0ybaikdQff3foc5zaYvNsVR3M5cLh1hGotZoy0gpFwcvdrr3NJ2xLcNglWj7Z8yKL6gCyqzT/7PY++uyO7PTu6Uhjd0hZCsHxyE0/t2J09fjhcR1UEsxtreKHrAIndO9l/x7ey96+99no8Ta0IoKrET7c5PG5Lday69WjIoCKgotpNd2w4qzNKyR4fVriiqYrXBvZmtzmVLHk1cx8Ea2qbeGng3XH2yoz11safKhRmBBt4c2jnuBaR4zqLda9yZ5A9w6lxW6rW1fShIXZ86sekugdwVoeZ8W+30OfRSPdF6PniXdlVatWnNqKVBgFY4mnm5X0Hsm1weFsqQrCyuolntu0eyxOUeerot1cVwcy6al7d22XZMRRh7w+/k63O3XCxVb03oCd5/c6vku6z2FW111yLFgod9n6hqsbP/pEhZM7Txj8RFtXV82LPvpx3N15HEYJV5S089d5uxjQO8xMhmFtaw9tvdI1r7YlPK/N5Se+NoetmYYsE1FWGONA7aF2XkmQ0wjuP3EFypA+Xv4xJS89j7yu/ZPhQj1XV+LxNOALhnBspQrBwUT2PDr0/Znfmh9E5ThWCpXWlxNyvjLNkolVhh5d2/3sYMl1QB6DMUU0k3c3oSvRwfwPwaMt4Z/i9cUesue0tUKh1z+fx3lzfHa+joNDqbeSZnr48OmN6QYeHviFlXABlHrslNGmV7BocyNlLOPy7rSht5vk9+yb4tzEQ4cAdd6D3jdniCJfRcMkmtGAoc5cxP+msquSd98cK82bTDsgxvaDHRTpqkMywEvPpCGBSaSm7evoL9ieAJW0NvPzO3nHjYK6OoggWTWnk+dd3j2vKXEdRFEFbUwVvH+idqDNOz+91MhSWJEbZlPlyDgD1c4Jsj/SPxZjkMfykmWW8Mfxedmw63HcVobC2qo5d8VdzTJJkGekoKDR669if2JWjY0oLTIzey6V46E+6SWTqpI1St8U4HYAyRxO7oz1Zu02Zw5IHYE6og1cH3re1e254Mi/0vzehKbM6CJq9NbwVOYideFUXQ3E3UX2UJZe/X07S6tk2cGjcMfvEBv/aihM5Y/J02+cVkw9p4kXkaAKcuf/+bWI21a0BSrwuBhP2VETNpZIY6mfPd7+N3j82iI2nLUtVYrrtX5cUEkrsI9U1oeALJEkXCfqs8alETXtaulNRQJi258FpQyGRzl9eIHVwkJ3/ZIEcraKUso3n0Hfnz8fAzSevRisLZe12DjiLFoAsM9wMjRRpb8WCa4YpMRJx9v30LozYSBbcAJiqJJUcYP9370D1+6m54irUwwIXpZAYAft3oikKqiZIGPbvpTTtYTiaKrhdDOAeUXAOY0+1TUrcg0fQrfOczyejA7zzVwvkjEoW3JTkj0VytqtENPs0CHWlQ9SWDtrGdJVoMdr9vQWvWyJtijRYoqCyL1lJokjhykiyhkNFaOLxlItYymUfp2EIEgn7gG0pQUbtayNpQsGTcE4YT/SBgSy40crKmHTupey47wdjgPySMZ8dFTUNalrYB76alp694cV1NEXBjUI8UWQcdLqIxVK2NkkVcNjbbTggGbaPLZFCEm+2Hyc0odDUNEQCe7r1pEAaVRmyDcZVMNEUbH0pbSoMpe0Dn6W0krbaiYqCJlzEitDbvaqbWJGCsrqhoBuard26oRBNFqkzJSE1XMRuITht0jS+tuJE+3sVkQ9p4v+LciT48EggZCrSz94MuNFKy6i7dnMObVmPDBwFa8fZdNR0Phg+dlYEafnCRTiqwugH++n5/B15wU32eUfwuCPVya543R7qL7iahkuumzBRaKEwdddsygtu/idyJO2UL6wmr1IRJor9VXtx+cJMWnpezmd1G84vCG4sk47o2xWl7n4Quyc+7Ui1iiwYjqC9j+YS8fDxRI9EcsBN7bXX4mtqofGSTTjCZaQH+tj7w9tJD0Vy73P0TCpuM0fa5yZme893r6PqCEXEzho9miR5cJh8Vkd7oqRGilWs/5/LkdCt09Ek8YMTq9UDJA8Oo2cWdxN3lP9+ciR2w5HNl0dTPgQ4H1DmNdYVpfZ2VJXbRrObQ4N0fe8O0uMSzbmbWibkZgnEE8VzW0goddlPxLo0aQ9U2duNYJK/2r44IIJJvuqiNNpSp9v2Ps6KIA03n5rzWdnGcyaAG12atFeWFW3v9mr79laFoL2qPIduPVrwbryEXBbLSguFCoIbIa3K5HaimyZTwhVFaeJTKounHJhUW140N40v4C5aZBCgPDQx4C8ZHeD9Z+7P+ezAH+8jPZQfYKuKYGqw0naAU4Wg1lV/BLmAgrbU7lHxa2W2100MGr31thRwBYXJ/hrsZlMFQVtJRVG7S5xOtCLVvQFqfQHb/qtLk46K8hw/UVwuVL8/C25cpaVMqa7AEQxbOzfhMlSfH8U5tnpWhGBSVWlR2rLX5UA7Aop7dam93YZp0tZQXpQm3tZYUfA6WHa3VIeL0sS9ioajmN0SGnzBou3d6q3Nyw7So0ne/tQveevW+ykZDORAnGjPCA9d+yf+euNDpEZSWOkEaoqCN4+q4RBF4k+EpNZdVtBufSTJKx//Na/c/DPSB0dyriV6h3jtoz/njU/+GhlNM8lfY7vrJBA0+kqL262puGwKQYO1Y9ZcErL3EymZV1m4ftbfQz4EOB9QLlk81z6rrCK47diVthOXdDppqqvDXV5B/cbr0ELWanl8bhbV7+fixYs5tmWyLc3w+NY2rpi6sKCjKQhqfSXc2LnG1m5FCG6aeoJtrgUTyVWTj6XGHS4IYARwXvMK1tZMLdgG+qEhDn3rTzmf9d3585ycQIoQ1HgD3LrEnm6tCMEnjllpO9gaUrJ57RIawoVpnQK4ZNFc1re32bb36tZWrp5VmNapCEGV18/H5q8ompfkkytWoSmFoaAhJZvXLaGxvHDeGSHgvNWzOWZxR0GQoyiCxTObuWDD/JzPxx9PufxlLDn9Y9Q1NJKK9LHr/tvzghwp4ZNLV+NSVVu7r2hfR627yjZ9wbHV6+gMrioIcgQKzb45LCo7q8CTLB2vGuKkmnNst+YBLmv5CA5FK2i3ieSKSeto9ZfbVpQ/r3UBpzZPs6UIL6lq4ppZCwtOJQqCUreH25bl+oni8VBz1VXUbtqEFg4jgY8fsxK3Q8MZDNNw6XXUX3B1TsVpU0quXbOIturCiwFFCM5ZOpOTFxTul6oimNdWx+XrFxS0WwgI+txcf8YK22NTU0o2n7sSt9NRcCfPlJJz1k6jrkTJ67upaAQzneDMlbM4bW6nbXvPa6pj09xFhe0Ggk4XmzuPzwtgjViKdCRGoivCH675IXpvGoHIgJs/M7J/mMRAgnQ0jUSyoeYkGr1Ntv69umI1ayuX2PiSQnughfObjylotxFPo0fiDO0/xCsf/RmJXmsnJ9E7xOu3/IJE1yDpSIxULMk1kzfgVV0FFx8SySWt65garKNQ71UQfKRxPme1zLGhkgtmhGu5buYS2/b2O5ycNqmzgMbfRz4EOB9Qlk9uYm5lJnnR+Leb2f2+cPYsZtZVc8G0GRN3xDM/L62fxDOPP8YdP/oZmj+Uo6MFQ9RtvI6Zl9/ItatW8LH5y9BGC03K3GdpKcGt85ZxWcc8yg1fXpukIfnE1NUsr5rMbFeL9fE4nVGK3zlVi5kWqufkyuX5aX9Au2sSSyumcEXriRhmfh2PKOHMhmVc174OkaHRZoMVJSR7B3n/Uz9iaH8vLa2tdHz2JrSKUuu46oujiQ8lppR8bO4KVjQ3s6Ah/ypAIjl35gxm1FZz0eI5eXUAZtRXsaa9lY8es2wi3Trzc9Dt5pLFc7hp2VKr8+dpbyEFty5fzkWds6lw5m9v05TcOm85K+qbWVrRmFcHCedPmsWsqmounzV3At189OeZZVUcM2kSN21Ybm315tEpcbm4eNU8rvzIUlRVmWA2WJPStecs5/RjZlJabtmdjEVywM3UY6/l4zddxLNPP0Wgoop0FuRExpvNaYunMbO2hiunz0OS3/DpFeUc19DGhU2nMjE3jaXjU92cWnMMy8ovROKY4CdW0KbCiorLmRk+AVXUZK9l7yQtMLWg7DI6SqbR7M1PE5cSZgXXMCnQzOm16/KmOACod9ezomImN0w5Lqsz3iYAt3Bz2aTlbJ62AodUJ+pIwBTcNnMN506ZRa0rkPsyMj+bUnLz7GUsamhgTV1zjo7i8ViBxBJOnzyVmTXVXDl/PlKCIxAaAzcZ/Y5gGeuntXPLccuRRn7D/ULjilUL2HjcYlwoE3WkBANuPHE5py6dTm0wv93ShGtOXMzcjnqWzWohn0jg+MVTmD6phgtPW8DhzPXRn2sr3Xz1X2/kpV/9J4mR/hxvSo4MsO2Pt7P94bv5yLJ2rlm7CIdTzdctMRW4+YRlnNk2nfqSwGFPsX6WwI3zlzIr3MzKiqkTdFwVfqZ/5RzC9ZXs3bWHR6//Cz1vdGXBjb8uwPF3rMdX5aPOXcWSskWcXX8mZGniub3Oozo4sWYD5zQej1dV8uhIFGFwWdNJHFc1n1ZfyQSbQOKu8PGN33yH1tZWEl2DvH7LLxh8a38W3Lhrgsz62tmcOnMR00PNXNqyNtPnJrZ4k7eM46rmcH37ekZr8h7uAg7FwaWtq7mmfRnOQv3ShFs61/GRSdNodofzmY2UcMO0pfgc9rFqR1s+pIl/QPnbmzt4Z0s3TkeGopiJI1SToMXhlw+9xvqp7fzuj6/jUyWpAOjeMR3nELyzaz+vLT7Izx96j1AU4iFJqgSkAmoKfCNBZDf85E8v8cbebvzbQQkKUmGJ6QAlDc4BgXcQvvmLp5jSUUX87TSuEo10mYHplhZtPaLi6tf4zz1P4T3XyYuv9SO8PpRwErwWddcccWD2O/nxtrc5vmEad764BbQgvkAClycFAtIJjdiwmyeSAzzU9B6fe/Nx+pJ+3K4kbmcaIcAwFGJJJ70puHvbc2wd7CKRVkBYRdgAUgeH2PlPPybdM0CgtpJLv/sVftD9LlWfupKef78nC3KqPnU1zvIgX3zlMYLCy/Pd+0AlUyk78yIUq71++vbrnNI+hR+++KoVsHh431bgje4eHn5nO1/58xOo5kQVYcJwLMH3nnyJd/v7kHGJULCK3WEpCx2ElHzp4SdY2NZA/8E4iqZgujL0bgkiLdDSCl959Ckq3F5efHc/akZn9F4iLVATgl+8tIXTJ3XyoydewQEYTqvmDmTSCaRg61AvD215j2/+6gnUtFXLT+ZQySGaSnLvwy9yYO8AaUykFQOe/X5mhlr+Xz97gkXzmulORxFeEIYLzW1lEm4/8VqUslL+67+f4t82rqf0iquJ33k7qtePcLmQwvJzwwU/27qF0xZO5Qc7n8bpNS1KqK5a9qgmmsPgvfh+/rz/bR48+Cs0wMDEHLcaVDBJGDF+c+DPGHIfh1JunIpARKPosTSBKi9x00HKdPOb/T+hPbCIl3YMEQp4qAzruBQdUyoMGy6GdB/37f0dqtLAIz17cKtBShxxPJlI2ZjuZDDtYefIGywp28md257DlD7czpRFAccKih+JmOwf2cuf6rfwtVefJhFzomg6msMkfXAQ3C6k00fcMPn2W0/TG0mQjAqkqiIchlUEVYKpK6CrfO7Zx9hQO4We3qjlJ04zS7cWaYGaVvj6488wyVPKM6/vxqGB4QbTaekoaVDj8Mdn3+GcadP58R9exCMh7bX0JJaOIwZ7uvv40wtb+fEvn8PfK0l4JGmvAEUidHDGTEikuPc3zzE0FEft1XG6JLpHYKpW4UpHXOJKmnznB4+zbsUUeg8MoaqWT44W21R0UA3BXT9/muaaMp7csgsy/jZepAJ/fmEbp6+exd2Pvkg6YFHM1UwIi6mC6YJtfd30791Hz/59HPrTHbSedi0eZ5jU8ADv/ukOUsN9oMDtDz6JrAkSc+tIBZSkZY8UVnuZTskXHn+C0xZ1sC8ZAQdWToXRmVmVoEm+/uYTzKoO8WzfFlRhsZ6yiwAkvio/7V8+lf2fepB9u/by4FXWLvMouPFX+VCFwcHkfp7pe4rn+n9PiZYkYSqkTAt8KZg4VQOnSPLXnl8RNwzCjgEcisaI7sSQCoqQ+NQUAS3N7w/8mIVl6zDFLqo8DgZTLlKmhoLEp6UocaZ4Vfsbd//hHk497lRG9g/y2o0/A8BdE2TRN06nok7hzeFneGtwKT/b+2e8WpqUqWKY1oJHERKHonMw1cVD3c/x/XdfI21YPVNRrMFCYhXJHDFMbt/2GPERJ9FhgdQ0K82FYhWTNdMKZlrjc88/xsXN89izfwjFoWC6M0VGJYiUQEkofOuJ5zmvcxYBV5GA5aMo/3AW1Re/+EUeeOABtm7disfjYenSpXzpS1+io6Oj4N88/vjjrFmzZsLn77zzDlOmFK9UejRZVFd/41e8/N6+gufGihDMaqjmre1dBXVURdBaW8Z7ew/ZPivgcxFJFw9sc1e5GIrbR9i3tJfzXl9fwWMTVQimT67k1YEDtjptFWHeS3bbPivocBGVE1k2RjTBgS/8CGMwSu2/XU64rJ5IJpGc3heh+9/vsfLgfOwylEy6+KlaLe8esrd7XrCWN3Z3F4xBUIRgcmkp7x+wL0rqdzkZkvasJgkEwx4G4hOz/I6Xzqpy3t6zFz2RyFLNx4s5OMjs6ia2HRyytztYyp7t9nb7nE70SBG2ClBS7aV/ZMxuIxnHSCdx+sfsa5pTyTv9B0lGBhAuV85RCFjtPXtaKW8kdxc871eEYGapD5zv2trtVR2EnX1ITJLDKX5z3RPEBxKcefdaAtXWqkBKiPZ4+PmVv8Jd6mH9N4/B6Z+4KvQq03h3uLtg/IyCQoNrMi8e7JlgtxFNsOszP8UYjLH0KzezWxnjbel9Eboy+ZmqP34piteNW3GQHBFFijFCtVHCwah9vZW5vmq27u8teNyjKoI55dW8ta2rYGCvIgSN4RK6dg3YPsvl1EgOj5BKJXB5QxOuJ2MRFM1FVUMFhwaitv2go6OarXvt7Z46uZo39trZDWGXwZN3/4eVdylYRv2G89n3x/uyv7ecuwlfeTnRoLSNRZNIKie56I4P29p9zGQ/O+N7CvqJKhTq9o3w40vuyH52yj3rqZpVmf1dIKh0lxI39ts8CVQ0kqZqW7JESvA5qulL2ffxOncbzz/7Ag9d/fvsZ8fedTIVM6sAy79r3ZN5c3Cf7bFRSKtgS5/9nKKhMdzvI12k/lWjXsqBwSHb5/3L2jVcPLfw7vqRyP8pFtXf/vY3rrvuOp577jn+8pe/oOs6xx13HNEiAwHAtm3b6Orqyv5ra2v7X7A4V97cWRi4gLX1vHN/n62OYUp2dvUXDfgbLAJawFrFFAM3mqLwfn9/0dIB70UKA4lRnfeH+4oGWA7q+St7qz43tf90MXWfvRxHWTALbsDK3lr9T1flgBtNKGw/Aru3H+wrWvJgx8F+NMXe7uGUPbgZlWLgRlMUtu3bz7577mL/dycy4vTIAHvv+A4Pf/lzpOOFafmmlOzq6itqdyyWLBpgiiAH3ACoLk8OuNFUhe0Dlg9owdAEcAOZ9o722gYzmlLSk+xGLTLcGDKWPcJKxXTiAwkG90X51VWPMtxttctQd4yfX/krhvePkOiPk45OpCarQmXnSK9tcLCJyXvDh8gXYGnGU+iDMVLdAzx9639i9ltxDqPgRu/txxiKYmb6WTylF42vQlIU3GiKwvs9fUVLHuzYbz/5mVKytytiG4cGEB0eZsvf7uatx+7IlugYlWQswluP3cHWJ++hq+eQbT9QFYUdXcXtfr+7zzYY3ZRwUFdpPe86HMEy0oN97LzvWzngxlESJm4aRQPthYCuIuBGFQp74l22fhLtifDbT/0057PH/vUpRrrH3qVEMpDqKRogn5Z60XpsAlEU3CgobN31Lk9/5rGcz5/9zONEe6zAYxOT3bFu2/aWwN7ooC0BBCCRNouCG0UK9tuAG7Bywr3ebb8YPtryDwc4Dz74IJdeeinTpk1j1qxZ3HvvvezZs4eXX3656N9WVlZSXV2d/aeqxYs6Hm1Ri0w2QPEqs1irrqJz0lHaa5P/A5uK63wwW1SfG0dZMC+ZRSsNZsHN/8ym4qRFBZF3cvu7SSqFMTJiMeK+e0cW5OgRK8+O3t+HHh1BpuzBqSKU/z275RH6yRGQRIUQ/yOrA1Vezrx7LcF6XxbkHHjtEA9c/SjD+0cI1Pk58btWDMQEs+UR+omVPm3C547yElo+fzGO6jDpngH2f+5uEu/uzoIbrbLUqg9VFsx8uSP4QkfYT47EbqGIoi0uBEXb2xiXvXo8yBkFN8loH+nECGa6yMJK/A/GkyNoB2dJmPoNuTXh6selKjiSpjwSX7PefuHxezRwd3j/ECV1AU65Zz2BOj/D+0f472seygE5R/5UezmSvj3SPcKfr/ltNhbo2LtOxl8XYGT/MI9s+mMW5AjrxRyVZx6NewiwJa38PeQfDnAOl8HBQQBKS+0ruALMmTOHmpoa1q1bx2OPPVZQL5lMMjQ0lPPvaMmyac22KyUhYHZ7ra2fqYpgVltt0VVJXVlJ0V0eTRHUhUuK0joX1NXZ2w0sqKqzvY8qBPPLG9FtVkACqPMEcSj24FMTCo1+e5qhLk0W1NrT8gUwt9GeiqgqgrnNtbYrToDakgDOIqBZVaApVMRu02TJtE4arh1H+//uHSR27cyCG0dpGWd99osTqOqH2z1rUnG7y8v8OItUcFeEoKkybOuXulm8vRUhmFfaVGSlLJjsn1SU1eTTynCIseOmQHUuyPnFZY8wuC9KqD7Ehu+egL86f10bE4OZoRbbwVRBMK+sseDA7KwIMvkLl+KvrbAqeX/mrsPATSirW+714imSfl4IaC8vswUwumkyt8W+XypCMGdyne0OnaoIZrTXFqVbV1XXMPf4zbh8ZVmQM3xoVxbcuHxlTF97LZ1TJtvabRgmcycfgd2tdbY2qYpgVmM1ycF+9v0xtybcvnGpCkpdbnwO+6SJihR0hirt21uaTA+25vWT5MHhbOBuaUM5G757HFWzKjnpu8fngpyeqHXc6ZlcdJL3qT7cin0KDyGgydtUEMBGe6L89zV/Znj/EP66AOtu30DFzCrW3b4hB+TEe2NMD7Zi2ozNCgozwrVFoUnY46LEaR83IwXMqK6y9xMpWdHSVORpR1f+fwVwpJR89KMfZfny5UyfXjidc01NDXfddRe//vWveeCBB+jo6GDdunU88cQTefW/+MUvEgwGs/8aGhqOms0Xrp1bcLARAvxuF7ecsxqvy1lwEpQSrjtjOe2N9nlQLjtpEacsnVa4Qq4QnLZ0Olets6GjCsGU2go+umZZdrAxEnH0wcjYfbDiTz69fA3ukTiywBGMKSW3zlnJtHB1QbslcG3nMs5qnl2w0yoIPtI8i+umL7W3O1TJbYtX2J7x+pxOPrV2JQG3qzAd1ZTcuHYp0+vsO+RVKxdw1tzpBe+jCMFpMzq5bql9e7eVlXHrqhWZpIHXjoGc28cSO7ZefwNfOO9MSjxuW7s3H7+EmS2F2xvg8uMX8pE1M23tPmHJFK46YZFtHEdLdSm3rl1u295uTeOTC9YRdnoKvl9TSja2HU9HYJLtdvjJtcezrPzYnPsEqr0c/7nFOXpfvutL+Krz5x4SKFS5qrms5ZSCzxGAQ9G4acqJhJ3ewvTX8gD/dfftOZ9VXHvmhPxMGzsXc3HnHNtUARtaO7h+8WLb+KqmUIiPHbeiYDsKrArYt56+itKAt+D7NUzJxtOWMrezwdZPLjhpARedsZbpa67Ngpwtj347C25mrL2W9WsWcsXp9nbXVQa54ayV2O2tODSFW85YSXmJt6BNhik5Y3YzXb++a+xY6vzNY8dVP7NSFVy6ch6XzLdv72PbJ3PDrGWF7UZQ7wuyuePEvO2tepw4Ql48NSH+/NeHqW+oQyDwV/uyIMdT6sbpc2BisqH2DDoCs2x3hFZXnszqyvUFrwsEM4JzObn2tMLA2+fEXxagqaWJ4+84BV+VRQzwVfmzIMcV9uDyubis5SOUOYOF+yUml7Yex4rKNtt+efGkJVzeOR8BmLE4en8k57oiBGvrWzm/uRk9lv+IXRGCar+f4/+Xw0j+fwVwrr/+et544w3uv/9+W72Ojg6uuuoq5s6dy5IlS7j99tvZsGEDX/3qV/Pqf/KTn2RwcDD7b+/evUfN5s7GKqaVlufl2ElDcuK0NuoqQpw4bXKmsu9EvRll5UxpquKCpTMhZYxdG/ffCtPBujmTOXvxdFxxmVfHFZectXg6x02bTIXhyqtDyuSSubOYVl3JbH8lRjzOgXvvYt/d3yE9MJClfp7S1IEYHqb7q9+l+xvfw4zFJ/AxZ/iqmVlRzcWtCzANmfdxJYqXE+qmck7LXNRsH5I5/xUCzm2dw/rGdsq8rrw6JiaXTp3DtMoqptdVjBnB6PaoxERywpQ2msJhTprVka1ILMfpSSTtteXMrKvhgiWzx9UHy31qwOPi+OntnDN7BppU8pmEMOG8ebM4dtIkylVPXh1pSC6ZOYvOikrmhqrRgmGqzsnNFFx1znmcPnshjaUhTps6BWnkfL3sz1OC5cxqqOW8VXPGVsKHNXjA6eD4ue2cunoGiqbk/W5SgTOOmcWqma2Eyrx5dQwhOWvdLKZUVTCrtSrbduPb0USybkYrTcEwZ02aRn6KrGRaaYjZpfWcUL2KMZp47hN9qpNlZQtYWLoOQzqyX2m4O8ZD//xcTnt98fr/INXjnPD1pQTdlCwrO44WXy2TfZML0M1hQXg29b5yTq638ljl06sc0fj3zR/PefbBO36F3hfJ6vpUJ6c0T+Oc9hljsWgTGhwunjqXNa2tVHl9E3WkBV4vnDmLyVVlzK+vzfv+pYQ1bS00loc4bUFnfgq4lLSGQsyZXMc562YjM/XIDvcTn1BZv3QqJ62eTsBbStuiXJ9sW3QebleIM9bNYunMFirDvrz3MU2Tj6ydSWttKXM66/KZjQSWzG6hsSrMKcunM1oc43C9Mr/JR6+8MFv7rOXcTXjqWqzYmwzI2fWL25lbXcKZM6fhKLC7KqXkwjmzWFXTSo0WLNjeF7TOpclXySTXtAnNqPpcTP/iGZx7x+dY0Dabqb4TSBpWGIGvysdJdx7P+m8cg8PnxNAn0e7vZFbJKUQzRS9H7zXaTYdTYWYEVzM/vJpkJoXH4WNlwtBYWHoiUwPT8KlVE3Qsuxx8+f5v8OTfnmTe5EU5dnsr/ay7/SRW/+d6ZtfOo8ZdxfHVFsjLl+KgwlnO7GA7ZzcuxsjvJmg4Oal+NmdOmo5jRKfnP79Pz5futEDOqK4O6/3VfOKSi+n//vcx4xPnCtOQnD9lRtEd8aMt/7+hiW/evJnf//73PPHEE9TX1/+P/37x4sX85Cc/yXvN5XLh+jtR0x584m12vNODW8GiWToACWpKoiUkf/jT6yyb2sSDv30NvwJpn4LutnjEakriGDHYsW8/Dz38Bt/9xl8IJFKkvCppv5qhiUucQzq6nuDHP3iSt7YewLs/ieYWJEtUTE2g6BLXkIEzIfnmfz7E5LkNGHvj+DVJqkRgOKzJ2Bk1ccYk3777MXQN3t3WiyuWxBweQY/0ceCe22k+dxMeLcwv3n2Cu26+nEhXF1ppGaI/jai0JnGhC9SEwta+Q/zyjS18YctjmGkNVIlQTaTIUAh1hSGp85+vPc22xJ48w9rYfz/z6p+ZW9ZIlBiaS2LqCqYJQkgU1URRJV/c8heEqfF6pAu8QFrAKB7UJDgkv9jxBsc0TOLHr78OLhCGzFYRlgpIFd7uP8gv3niTb/zpaUZT3CDHWSQgmkrxzUefYXtXH6RMq8iyVYwXpFW5XJGSz/72ERZNamBkIIGWoalmabRpq47PV/70JG5F483t3YiRAXp/lgvge++/n18T5pjJk/j5I6/hFBmaeGYXXjGslAI7Iof49dNvctevnkZNS8wsTVxmbJIk02nu+O0z7OodwFAlBhbNHGl9L1MBRYN//8mjzF/UxEEZRwas+wuDLNVWOuErf3kSZ5nGC5F9EAIlqSDSGZDjtKoyP7D7LU7a18qv9z5B0AeptEbKsGjimmricugcSB3gt/ue49GDv8QhTAzIFH+1Gl4VBoY0+eW+3zCQ7mVE11CElSPpd1c/ytD+KIE6Pys/s5Kn/+0Zdu7YSc/VP2fFt06hrNaFppiYUpAyNRKGxr27/oBCiJf69iBw4VD1bGoCw1RJGyp/PvAmy8vf4vvvPotEyRRFzEwECJK9Qzz5Lz8g3TOAs6qMsqvP5OCdv7SOqz7/Par/6Qq00hBxqfOVVx+nZyBhHR3KMR8BwLTa9FNPPsyG6g76huPW61LGdESmW3z9b09TqXl56d19qGQo2ZlmUkzr/fzllfd4dNp73PfbF3BK610ZmgAhLZ9MSQ4M9/PAw6/y8x8/h3PIxHCA4bTiX4QpUZMGhmlw1/cfZ3AoTuLgIbY/n3sktP25+5i96Bq+/q2HWXn8VPr6o9asJ5gwe9/5i6cpqwzw3Pt7wW3Rx0dPRmQmvcJft2znL6+/x11Pv4jpt/qGks7Mf6pVX2p/Koni8eEuK6fu0msR3jAyDWooTNOFm9h93+2oPj/3vryFhHsrulE48PWfH3qEU+ZOoWcgDkIDpwlK5v3oCqQFX3/2GeqDAR7etR9VCeP3JHA7raD1RMrBcDxMlznMg/u28o2tzyKoo9wTJeyKoYRc9Ked9BwMkDQMfrrzOX7f9Tf6kzUEnVHK3VE0xSRpaPQm/MR0D99+709oSpz9cS9ORaPEEcehmBhSYTjtIm64+MZ7v2RDzQL2x0cQuHGpOmqGd58yVVKmxu8H/0ZLRSsv7X0H0FCFiZJxJmdFAEMqvND/Fk/3vcYPd/4VQ6qoQqKIUQq4wDAU9umD/HLvE9z11lukUg5QTDTVsMZECYaukgL+47W/YvS7SPUnMCNR9L5+ev7jTqpu2YjDX4p5aJBLPvUREgcP4giVoRxMolZ6rPFSWmOgkoTv/vV5zp43k4pA/qPlv4f8w2niUko2b97Mb37zGx5//PH/ZybUmWeeSX9/P48++mhR3aNJE7/i4z9m247egjU2VEUwuTzM3h2HMIz856GKIqguL6F7b7/ts1xujYRuH8cgAVHlIZmyL+wY6gxzIDKMKSWp4QHe/+3tpIb6cJaU0XjM+ez5632khqzYkLorNuHIZFfOsVsIqqt97GLA9lluh4L02hftlBI8qpO4YV+wr4ZK9g4XplKrQjDFUcn2rsJsK0VArbuEnt7hvNdHxamopFP27AEAj9NBPG1vd1MoxI5du9h533dIR/pwhMqo23A++/94H+lIH85QGeuu/TQ90cKFNIWAar+fgz32djs0hVSRbi0Bpd5hWyhWAJXTAuyORexp+c0eDhj7CjKpBNDsd6Oq+2xt0oQKwqKsRnuiPHjNgwzvHyZQF2B9JqB4pDvKn695mOiBQby1JSz71ul4Kv0Tnuehmd3R/oI2qUKh2lHL1shEP0n3DbL3n+8l3TOAu7qM8k9YMTejqQtGY3Gq/+kqtNIgGirpaPHSAeG4h5FkYUquADqUMPt6bNpbEXR4w+x9vzAzUwio8HoZ3Gcfa6iqgmg0wusv3Eki3o/bU8qUmeew9Y2fZ3+fuXAjgbZaRmKFA42FgOr2Mnb3R2xp4o0NpWwf6C98pA+UOAU9wwM4MhXSx0t6MILicuH0eklr9hEvEkmgzEUkWbiQpoJgUn2AnVG7tBMKUytK2JvotmUKVno8JIqMg6oQ+BzJIrE6kkq3ixG9MONOIKjzVHEg3lswrk1BodRRx/bhPlu7XTLE+/1FAtZNgdntxZQSfWCAru+M1UaruOA8Dv70fvS+PlzhchrOv7Zg3TpFCG44dilXr15o+7xi8n+KJn7dddfxk5/8hPvuu49AIEB3dzfd3d3Ex8V9fPKTn+Tiiy/O/v5f//Vf/Pa3v+W9997jrbfe4pOf/CS//vWvuf766//X7d+xp8+2gJhhSnq6BwuCG7C2Sw/2DqFp9q8jkbQHLQAoFAU3mqrQPTiSHWicgTCTTtuEs6SM1FAf2x/4lgV2SssLghuwYisOxIaL0pZTsljJYkuKgRtNKBwYGbavNCwl+yNDtrRdU0LP4BHYXaRq+agUAzeaorB7z94ccNN83ia89S1Wle5QGalIH4/e8QXiBWo+gQUCDw6MFA00TxUBwQAo2IIbsBiC+2P2bWlISU9qwHYQlcBQuh9V2G9PG3LMbx0+B+6wOwfcAHir/Cz95ql4a0twhT1o3onBpopQ6YpHbG0ypMn+2GDe76a4XahBH46qMFWfvgx3uUV40MpCVH/qSrTKUtQSH4rb2hVOH0l7S2zBDVjt3d0/bN/epqSnd8g2WFdK6Ds0glrET2KHgZtZCzcSDDcza+FG3J5SEvF+3njhTvoO9djeRxEKByLDRWniVo4Uez8ZMCTuAuONI5OqQJfFOTsCbMENWMCskA9k7ZYm3YlIkadBJD1clG4N9pXrwQIvduBmVOdgst82aN/kyOw+lIgXtdscV5VeC4epue5atLIy9L4+ur757SzYsQM3o7K9154Cf7TlH35EdccdVgKl1atX53x+7733cumllwLQ1dXFnj17stdSqRS33nor+/fvx+PxMG3aNP74xz9y4okfrAz7/4u4XRqpdGFAIYTA4VBJiLGd3cNF1xNI0jiZuHWXSA6iqS40zZ3nL/PIEezHSSnRFCWn2KQzEKbxmPPZ/sC3sp+1n3MpqXDYlr7uEAqJIrkdjpZIwKEopG3YZgJwaCqCtG1TaKqKTB3BxHQURCJxeTxoXmunofm8TdmBwFESpvm8Tey6/3acvgAOp/17VlUF80gm1OJGHZGKQ1FJ2hwFCMCBioGwL+wnVGSRopXjxel3cuw3jyUdTR9GBZd4qgIs+9bpaF4HDn++o2eJpqhQJHeHQ1FRhDEBMKs+N/WfvggzkcQRDJNOj10fzc+kuF1jKQyOIk1cUxWKZbvSHCqKImxBjqIKzKR9e6uqC4fT8kkL1IQAcHtCzFq4kddfuBOH04+qFTneF+BQFRJF1l8OVUWR9jmDFGHvR0cqR3IHIQQORSVuFltYqejYDOBYoOOIKqUXkSOiWwvQhEYSe8DsUFSEMG3tVsQRPPMw39XCYSouOI+ub347+1nl+efh9Idt7yQEeBz/u5DjH76DI6XM+28U3AD84Ac/4PHHH8/+ftttt7F9+3bi8Tj9/f08+eST/xBwA7BmSYctPVJKyaJFk2zBzRuv3svrr3+PaCx39Z5IRnjljXt4dcsPMcwkbZOrcLns6ZEel4O25grbvBSGKVk1rSXH7tTwAHv+ehg184GfkhoovKOgKoK19ZNsByyBoD1QhVe1r0Hi0RxMC9lXLzekydqGSba0ZQmsbm2x7WiqEKxqb7G3W8DkqjJ8Lnu7XZpalI1lmJJ1czppOWcjzeddN2GVY4Gc67j6M19F2AAcVREsm9liO7EJAS01pfg9RexWVWbW27OxDNNkXb19ewMsKZ9qOympQmF2cGbRiavKVY1XHWNHOf3OCXlunIrGlEALvspAAXBj+cmKyg5bXxLA6uq2wkedPjfu8jBr6iZN0Bmfn0kAzcEgIZc9MNVUhfn1tUVp4iuntdrqCAHL5rYWpVsvWjjJdmcZoKGhiuVrrmP2ojFwMypuT4jZizYyZ9GVLJjZZlud3jBMVnUWt3t1R4vtLo+qCFZOarZFAgKoCwQo89rTrTWhsKS2wdZ3ddNkba09BV5BsLKy3TYZoCoUFpZ2UAzFljvDhB0BWx0FhRnBKQWLdoLl3/NKpxfxb8GSsqlF7V5e1Vo0p1JViZdK31g/1AcGOPjTw+II77uf6WVe+yLHpmRd52TbZx1t+YcDnP/rcs5Jc1EKbAULAVXlATZdsYby8kBeWqeuJ0mlRxgY6OGtbT8imRwERsHN94gnBkinR0inE1x82UrOPsf+/PKssxdy+TnLCg5uQsDC2c1sOmVZNknh4TE4bWdsxhMqJ9LTRfe9352QeXdUVKFw87JlrKlvLUyBR3LznBVc0b7E1u5LJy/ihs5VNnEcgmWVLdw6d2XBnDoCqPL6+cTyVdSVFM4FpCgKN61aypqO1oJUWylh89olXLFifn6FjFy0bC7Xr1tiS6Nd1NrAjcctw+3z48yT50YAtXV1fOqc9dSVBQvaJIRg08lLWT1nkq3dG09dwiXrF9jafe7a2bZ2CyGY31zHrYuW41Tzr7oEUO7xcfOMY6n3lNnSmy9pPYH54bm2g+lH6k9hQ80GW7vXVa7jvMYTbf1kaqCVqyatx6XmXwwIIOT08dHO42nyldrafeO0VWxonGLj33DTrBVcN2dRQZsFcHHnbG5Ybu8nc+pquGn9MtzO/BXOBRDyerjhjBU01tjlMBJcefZS1q2eapvn6NILl3PZxWtxuUN5r7s9IT5y6hKuPGOpzXgi6JxUzebTluNxOgraXeJ189ENK5lUUVp48SXh+rWLOXnGVNv2vn7VEq5bat/e58yewU2LltrSxGdUVPGJeavxajZ2O93cOuMYJgcqbXxXck37WtbX2Pv3Za3HcH7T8bZ2H1e9mHMbNhTcVREIWrwNXNh4Gm61EKgWeFUPl7WcQquvpqBNUkqunHwsZ7TMsoU413euYPMiK1XD4TE4NTdcnz2ueuabXyQ1mH+uUISgo7qc5W3NNk86+vIhwPmAUlVeQk04kKEDyBzapjQlMybVEgi46Wyrtmid5Oq5XSVsWH8LLS2tRAZ7efn1e4gM7cmCG487zNwZV1DqL2NyWxWzZzahjPr+Yc9TJMye2UR7S6WVCCufTYZk4YwmqsIB6kIlpIYjOeBm0mmb8Fa1cOFtX7Iq1h46yL57bic9GMnlfUprJVVbUsLymmbMiV8NpFVfaFppJQvLmwt2IgEsrmhmaqiKEqfGhAcBYLK8upkaX4CGUCCvjkQyu6qKUreHWY01mGLs8/E05+pSP3UlJSyZ3Dhm92FPc7s0OusqWdBaP9ZJDlMSwOKWBjqqKihRnXnNNnXJsuZGqkr8NHuD2XYZryNNmFVRRdjnYW5dTV4/QUKdx09daZDFU5rIngoedj+PqtHZVMXcjnqEJvK2JArM72ygvaYcX8CZV8cQksUdjVT7ArSU+cddGdMy4jEmaYJSl5dZ4UbGU8CTB4fQowlAUuUJUOsJMyUwnfQ4Omqua3po9rUwyTeVlOHMcx2ShkabfwaN3jo0Anl10iZ0lkyjwl1Cg7eMfCKB9kAtIaeXxVX1kENdH/tX4/fS4A+zsqHZojHl0fG6BbMralhYW4eFp/L4pSpZ0thAW0UZJZldp8N90sBkaWsD5UEfzRX5t/ol0FFXTsjvZW57XUE/qQh4qa8KsWBGE7JAg7uFoLO9hpmddWiHjxOjjambzJ/ZSGt9GUHvuDQIOb4rWTCtibISL421oTxeYrVuW2O55d/tdVlwenhLhUu9NJWHWdraOOE+o787NJXZ9TXMr6nFaYj8Q4UOy+sbaQ+WUZX05tdJSVaFGilz+ZiSqCYb/jX+u+kwLVVDmcvHLDkVPaGMNaU59l9/XyVNnnKmO6YTHRpLXzD+X7w/yBTPZFrd7QwOl+Rt7sGomzb3LKrdNSSS1TkV7Ed14mmVOudsQs4SAqIZwxQ5zwMwTChRWwk6A0z1TyU9LvPI+H9OSqn3VLK4tBUjLfLqqGkHc8INzKusRTk4nAtuNl2Lu6WF2o3XUl3fwL49u9nzkzxzBSDTkiV1DbY7gX8P+YfH4Pxflz88/AYHDgxYDETBWCXpzGDz2FNbmTe1nqce32pN8ArIzEsWJmBKIofglhu/wsc+fiXx5AAvv34XAB5XmHlTL8dNgFQszQ/ueJR33u1B6BIhJXIssQzCMBFC8M2v/ZlJ8xtJJdIIU1rPE7k23f3jJ0m6YU/3AJoyVkV60imbcHnCoMNLuwa55eu3c9NlF6D6/Ciaa9wMad1vd1+EH7z4Ml/b9hSMdrAx9i8SSOg6X3npCbbr+2zPqf/11T+xsKKelEyjqRbtV8pMOnXFqj39zXcexUirvD98yKoQbIoxmxQTBDy8/13ue+d1/rB9Kzit9s1WNxZgqpLdwxG+/+rL3PnIC0iL0ZzVkcL6lzQNvv7IU+zY24+QmfP38X3TtHbDPvvbR1jUVE8ilkYxsaqEi9F3Yul958/P4pAKO/b1WWaPVmTGooALHZ54fQcPPPEmDz7zjlWEV5WWbWJUR9IVG+S+h17mh79/AdXIDLKCLC1ZmGCYBt/5xVO8PxKxqjSLjB2jZqsgFPjCzx5l3uImRsw0hseyQZjWvQzV8tNvPf0czlLBtuFeFA9IQ1g3BGQizsFv3ssDQ1HuqK/nwfjLmbIdkkTPMG/f9jMcIQ+d/34WPUqEX+x5ggd7/kTSdKKYJppiIpCYUqBLFQH8aPfv6In3E9OdgIpL1TPUbUHS1JBS5fb3f8b0klkMpnRMnDgUA0VIJALdVDCk4Ic7/4JT+Hh3uCuvrwE83/ceD+x5gd/uexmHA6QUmclCoAiJopgcSkb44ftPc/fWF3C4DUzTsKqDS4FQJIpmIhXBl9/8K/v7k0hHhoo8OvEKQDURCvzz8w+zvnQqw+kkpkNa/pPxXVOxfOs7L7xAufTw9r7egnY/9+5eHnjiDf7wlzct4C2s9AfWS7Fo4H2HRrj/ty/y+x89i5YykWkTU1OyNHFhSExhcuftf2VwOIFIGSij40mmxoMwDBTgG//5IEtOmc5wNDGGA0f7Qeb3n/zuBYLVPt7a35vpl+O+W2ZMfOH9ffzihTe4/5U3rfQN5phfjqZv6I3HuPvZl/jpy69b49Z4QJJpUkOafPGvfyMWTUEqU5BdJUu7V3TrFXzmvx/l5GlTiPYn8SDQvWBqEiFBTQiUFNz7xMtUlQR48/1enMKF6TcxPdaXUmIKyojCSxzgZ6+8wY9feAMIoPh0VH8aoUjMhIo+6CIp09z53Ev8ePtrDCVDDPen8QYSKKqJnlaJDXnA0PjcU4+Rcifpjfg4OOQi6Ivj0AwMQ2Eo5iaVdvAvzz/MuZ1T2DdiICmjxJXEpemYUjCSchJPO7h38DnqvCFeGTgABPBoaVyq1ZhJQyWuO+iO7uXXe57nxzufA9xoilXVHCExTIWUrjEoEnxv+xP88LVtGEkHRtpE0UzLBUwrzYdE4XMvPIbWq6LiRPP4oRRqr74Why+MMgJOVynhizeS/t7tJHDgTrgQjsxYg5UOQOhw/yOvct7K2TRUhAr699GWfzhN/B8hR5MmfuGm77F3f3+BadtiRtT7vfTui9gyqUqDXna//xYvvPO97GcLplxBKNCY/V3RFIwiCFgCRrnL9qxbCHC1ldA3HLP0U3GMVG4VaVURlLUFeb97N9LhzFtoUQDBChc9jpGC3x9A0yRaoFjopMStiSJlHwR+I0xvvHBlY1UIGihjrw0bRQDlipehvvxFQLP3kiDs62iCBKepoNu8WyEE1W4vhwajBWOxVEVQHyihu2fQ9t2FfR6GhiZWZs8RTZDMn+h3vNno9fYB24oQlLap9KQmFi3U+wbp+rxFmfbWlDH9a2fjqPCT7B1iy60/I9E1iLsmyPSvnYerIkCl24EUEVubhBQUC1eXEhK6l7RNYLuCwK+W0ZsYLgioVaFQ5ihlX2zINk7Bp3jpSxRhAZqCZMw+5gkJ3ojbNmBbEYLmWICD/SOFY4MUQSt+Du2295OgqpGcUCvpMBEgi8RXScBs9JG0IVIoiiDQXkLXiL3dlTUl7I0P2drtdzkZSdkHzwoJohgxU4JX0UjY2S0ElaV+uods7BaCqooA+6P27Dav18GQYj/GCSGhpLjh5WGThA2jVBWCpoCXg8nCTEEFQZmzlP2xYVv/duheDg0USb6ng6vLOu41EnHMZHIijV+Cf+8IaamiuvLHR6mK4NJjF3D9qcvsn1dE/k/RxP+vS3fvoO1kY5gmkf6oLbgB6Ok5wJs7Hsj5bMvOB0hkYnKsexXHolIprqeqCpHo2CSpOnOrSI8+qy8WQwkE84IbsAa//lS8KN3aFPbffVTswA1YHbs/aT+5G1JyKBa3HYwkEIkmihZKLULCyYoduAGrY0dG4rZsNMOUDAzGir67wZF4UfqvYQ9/AMtP7MANWBNAfzqW925aWdCqyVRZSqyrjzduuY+ht/bngpuvnourwgqqjOrRojTxI2HPSLAFN2AByoFUrCC4AWsnoD8ZtR38AQbTibEMxYXuZR7BtrvEFtyA1d4DwzH7NAimZCBS3E9GhhJF/eSIlrYCW3AD1oKpL1bc7r5YrGh9rJFkqmhQ+5HYLcAW3IBld380XjTtRH88XtQ3R9JHYLdS3HAFYQturBtBJB21tclE0p+MFg00H0mlixZ4FfrYddXtyZujSAFMp78guAHrve3vGyx4/e8hHwKcDyh+vz17QlEEbq/T9uwxkYzw0pbvE08O4HGFWTDlCjyuMPHkAC9tu3cM5BxBzz6SiuOmKXEVoespQuB1OIo6v0d12IIJgCOYtyaIEU2QPpSbqEwicasaet8gZix/jgsFgdehFbXb7VRtBzbgiKm9xURKiatYcUAh8LgdRc+oXU6t6CRxJD4gZPGvJ5F4lMJ2a2Uh6j59JZ6aUhJdg7x503254KZybHWlKU7bwn9HKqMncsXEUyDAeOw+Ao/mLFrd2KVoRf1bHFGDH0F7S4lm6qSHI3mvp4cjmKk4brfDlq0C4HBqmEUA7BGJpHhBainwFPFvAXgcxf1bU5Ti/fIIRHJkldm9BQKjR0VgMTyL3UsTR2C3BDOWQO/PP8nr/YPoseJ5aRACd1H/Bo/mLFrlXVNEcbuPAJiZUNQnhYCg7wjTnRwl+RDgfEA5fs00205rmpK166YVnJQSyUFeeeP7xOL9eFxh5ndcRijQyPyOy3JATio9xOy5zQRK7OmRwRIPc2bYB3OZpuTEBVPsdaTkpGkd9lWLheDUSVNtVwmKECwsbyLstD8zCTo8LC5vQUFgRBPs+exP2fVPPyB9cNwOlpSs9lbS/YW76fnyvXlBjonklPapRe0+adoUW7tlMsGUEhelvontnR6KYCSts6uAx8WS9kbb1Zsx2t42OqaUHL94SlH673GLp5BOxUhFI3l10rFBptYEKS+xT4cecDlZ0dpc1O5Tm+zpqEpZkCu+/E85n7V9fEMOuFGFwsryebb2CATt/iZKnUFbPa/mYlHZ1KI02uNrZtvaLZGcWDezKI12Q0PhYqtgAeqZpdXUeO3pv16Hg7WTWm3bOx2LceD332PHL79Dangg51pqeIAdv/wOOx64ixXzGorSrdes67Tt30LA5MmVVFXZb/G7XQ5WzptUhP5rctKcKbaTqQROnj7F3m4h2NDZYbuzKgS0V5VRH7b3E7dDY11nMbslJ83osEWeEjils6Noe580ud3ebqDF4WXgaz+m+wt3o/dFcq7rfRG6v3A3vV/5ISsCzbbA2/LvwsVGR+VI/PvE5ik4itldHqalLGz7PKemsm5OW9H2Xj9/ShGrj658CHA+oJx50ly8BXKOCAFtrZVcdtlKWidV5u1ImubC7Q7Q3NzMLdd/BbfL6rhuVzALcpyaD1V1cem1a7js6lW29lx21WquvGC5rc6Jx8zgylMW43cXsBtor6/g+uOXMrWqoqBj+1xOrl+2hHPbZ9o+79Z5K/notLW2Ojd2ruGGqWsRAsx4Cj0SJd0zwK5P/zALctY46vj9Df+K3tuPMRTFjOeeeQugI1jBzfOXM6OyqqDdXoeTzUuWcM68GXmvG4k4e390Jy9980tcNCc3b0N6aIBd93+HPb+4CyMZZ/OxS9h8wjLbQfLkeVPZeOJiSrz587YIYFJNGdecsoRpLdUFb+V2OTh7TScHX/wp7zx8O8lo7iSYjA7w9kPf4bU/fYcr1tq/k2s3LOHGVUtsl+cnTetg8+xlhAtsOwugPin4479+O+fz9770R5K9Y7tvLsXBJS3HcWJ1ft8dxZkXNp/Cxc2n2tp9XuOJXNa63hZ0rK6cxRWT1hFy5gd5Amj0lnNN2zHMDjcWbG+XorGxfTUXtxZOzSCRfHT6Wj4xd7Wt3TfOXMZNS5YWBLkCWFlTg5qKkxrsY+cvb8+CnNTwgPX7YB8iGePMFdOYNbWuoN1Op8al5yzljLMKU6kBrrxmLVdttO+XF128jCvPXFYQLAlg5fxJbDxhCeWBQhXeoaEsyOZ1S1jYVF/Ybk3l+pWLuWzR3IL2SAm3rl3Brcfaj3HXrFzI9euWFAQKAljd0cLmtUup9PsL0sQbQkFuWLWUpY0NBe12KCqbly3h6tkFUkpkCBcbp83Cl9DRe/utkh8ZkDO+BIgvoXNuzWzL7jyYSgArKtu4evJaKt2FQV61O8zVk9expHxSQR1NKFw7ZTXXzijsJxL4xPzV3Lpuue1G/FXL5nPNhiUFs6wL+P/Y++8wOapj/x9/nQ6T487mqF2lVc45SwiRRcYIk7NENg6Ac7i+wQEHRDbJxgHjeC+2wZhoMDkjQDmuNufZSd3n90fPzu7szvTs/aDr+72/h9KjR9qZ2u7q6jqn331OvatYOqWOWQ0VNkc58vIJwPmYojs1CDsY3nB6MBAMFfRiF6qqoFX6MHRllI7icLPk+Kt57M9PUDFtPCmPmvne6Qwyv/FC5jSei6gI4wy4cJf5iIc0i+0z7FhSQDyk4Srz4go4SRZpo2ySQNItcFW60XUNERqtA2Bo4Ijo6IqK1+sYJM5k6SBAd6k4NJWQ0z3CGDK/oEoFr+7Ar3kwksooGqKUYKQU/KoHt+rESGlokQDjvnk+elk4A3L63tvPw5d/hb27d+MsK7ZK5keCo7rkelUXuqLgdzjyDkinpuBUVQJet8XgGGG2GY9jRPs4uG8fX918EfFoJxJI9HSy5+dbSXa1k4r2kUrF8fucuF06Qh+a/kbeF7/fia6pOBzaKJ3B/3tcOpqq4vXqWZ8PvwbdoZKIDxDt6ybe184Hj99OrN+yLd7fyQeP3068r52uzg5UUhmG2Mi/poplt66jqHnsBgJuJw5FwyGHGHRZlOzWLl67+fvs3rUbf2Upjd/5NK6KoLVddeMviLf0YJiCaMyHJnQSyWI6BlyjqK+mFBzuCYL0oZhB2vq9oyiypoT2qAczFcYhnAwk3JmGncP14ikVTYbQFA1nnu01CXhUJ5pQKHZrVhPCER5XhCTgNHGrGqVeBw4tNcI7IJB4nSmCTgdBt47mGKlj/VX1FGGPbtWJcYnM7w+nihuqpLK+ij8//gTuopIMyOk/tJtdaXCjByOsuvoW6sbV4PU688aJqqk4nRp+rxOMEY5MO0w1wet24nM7UFJm1neDf0XKJOB14nLqaIMTzggdaUqCLhe6quLShm17DzNKYvVr0xSFoNuVd1zqmopT1wi7829jKELgczoIOJyog+4efj5pMXZCDiduVcMdVXJWARBxKJIuNKEQ7tUGW6Bl2S0SEO7T0BWF0qgLNToqBFBSEGhT8AiNkqQHvWe0DhLcHYIJZePY+otfoRUXZUBO7KO9Q/3Niou45Y57qKuqJ9HjxjRHx3cipqLHAlYl41iAVErJ0gFIphQSMT+6ouE0AiRHzLsApilIxjw4hIOQ8EBC5LRbxBQCqouA5kSL5fa3koCw6sKtabgSw/09PJYkYdVZcMvsSMsnLKqPyaK653cvcs/v/oFpmggDlJTlTlMXGRr3FSct4d6f/x0AkTJREiZCgqkrmLpAURTOPnE+v/zdq9bWimGiDhiWjiYwXSqKqrB0XgPvHmimrbMfTIk2YCIMi96ZciugCErCPsZPLef5d3djGiZqXFrdfRUwnJZNihCcfdI87nvuNUxTpu0mbTcZCvOW45bwvX+8aP0gs6nUCCu/6KKFc7hrxyuYcqimx3DRhMKq6no+jB+iKdoLSIQiLSqiBJmm5pa6fMwpKedvTdsxpImiSFLt3Rz4itX0cFCKqirxfuZ8lEj6vg2OFzn0ww3TV/D9F14c9nm2KIrgohlzeejFN638Ckk2BVaA2dNF60/upLelGT0coWLjJpp+93Cml1TNeVaProjXw/zySp7athPDkNkThGIdSwi4dOkC7v/rq8hcS93pa9hyzBLu/O0LQ3bL7O8VVfCpdXN48HdPse2/biPR247TF6F+xdnsev7n1s/+CGde+01anTqHOnqsCW34KnXaprDXzcx51Tz+0Y6h5ffh50vnjFy2dh5b3/sHEjP9uaWUau+h+dt3kWrtoLi6Ev+XPoVeHMTs6GTfl+4ncbgLvSxM9TcuwFkc5tyGBfxy78ukpIkqTHzOOIqQJA2VvoQDBYUFkToOx7o4EO0EJF5HAlUxMUxBf9KBlAoh3c2ysgaeOPwuhjQtmni6S3TCVJFpxH7FxBU8sPvpnDE5KJdNOIp7dz0OgGlCylTS8SFRhUQVglNrlvLrva+QlAamhGTKGhyKkGiqiSoEs8N17OpKsrevA1OCaaQneUGGdhvUXSz1TOU/d3xg+dscouVLhcyr5vUTl7D1N39hdxpID4oejDBuk9Xi47oVi7n/vr9n37NhoqqCk9fP5MmHXiGZNIaGxiC2kta2ypTp1fT2DLB/b5sFKBUxrOSARABen5O5J07niee3kTJldhKUOfTfTRcu4c6/vTzKHCM+gJmIo/tDXHn8Em4dNp8MNs8cJDGoiuCsOTP59ZvvksiTkK0IwczKMhKdSXY0t2OS9l/GbjDjA7gwOWnOAh572bJ7sDRDqrcLTTjRdOuclx2ziHv++JJlq251Zwfroa2mc30vO2kxd/z5H9Yla5ByWXOgmgQ1ZuWxnLxsOr99bxuxZAqpSFJuyy4lBeqAtR00taqUfq/Bu9u3c/DOraQ6hu6vVhSh6vLNBEtL2TBvPL/ebsW35jBQVBMpBamEikzH6PULF/Pjbc9av6sa6Ko1yJOGQsqwYvTqqSv5wTvPAyCEiaaZCCExDAXDUFCFwhn1s/jd69sZSKWssaLJoThJCVShMK2kFNdhwQeHWiy8nO5yL9JgUmAB2JMbJvNfz75LypRD1H0sHwymqT30jU8zqa40570dq/x3nt+fAJyPCXBOvP5umjvyd3dWFUG520N7W589rdPjor8/bt9ETwHDUSBTH0j5FdvlREUI9HIH3bH8tEZVEYQrvByO9dsmWfqCOj1azDbnRSgmwlOQAIyqjn4cxT7cx8Ev3535ecLXriU5Lv8ypyoE5QRp7rG3OyicRPtStnk4qfZODt67lWTnsAdNOA1uguFBs9ET9ol6ihBEhJOuPpvOxkJQ7vHS3mEfJ16Xg2gsQby3kw//dDuJ3iHbHP4Ik4+90uqf5CsQJwLiZfZ2q0Lgq1ZpT4zuBG9GYzR/7yeYPX3M/ddr6A2rmf3+ZFs3B758H2rQS9UXz0X1uvDpOnEzbhuXIClcB0yiq/aMK1UISlxOupNW+YJUfwwjmsBZMjTWFQSlbh9NBw+CW0fz5t4+dAgn0VTK1u6UIeiL2SdPSglmm8c2JlUhqOz00tk9QP+B3ez52VBfuHHnXI2nuh5FCOpibnoO9VmAOo/4UgLZEs0JgP47IoF4jadgDoo2yUfbQDbjzogPsOc3d5GK9jH+zC2UTq6mJdmPYUqSXdbYUr0+Ki+4LANynKpKvFCTWwP00SGZOee+X1nnnLLxKhRPMPNdoq+THb/fiub2Mf74y3C4PRS53HT0RPPyN4QQRCJe2vv6bX2guVWimr3dpgLJkPX/2J7dHLx96P5WXXk1rnH1SCSixLRlOGpCoTSi0xYfXb4hYzeCYqePtoEBe5p4QifRY7+RI5LgOVxgs0dKgu0KKZs+eaoiOHP9HK47Z7X9sQrIJzTxf6J09uYZaWkxTElff7wgrbN/IFEwU39Mc5UorKcogv4CnaQNU9KTSBRkkPSnxmD3GKNs5JlSbd003/brrM/23PbQqAS94WJISU88XtjueLIgrVMLhak4eVPWZxUnbxoCN2mjC7EQFCHoj9nX9jClpC9aOE6isQSqouDwhalfeXbWd/Ur0w3vxrAKLEVhu4UQ9CZzg2DF46Lshoso+8LlJELurElULw5S/Y0LM+AGIJpKFGQsjVUKUXYFgqgRy4CbD2/5Fds+9zDx1qG8IBNJ28Fm3vrMw7x/8yOk+nNf54BR2G45JodTmI2FoG8gQaKnk4P/ld0X7uB/PUyypxNTSvr747bgBiAeTRQsgzAmGUPZCQT0JkaDVzMRJxXtI9ndzs5f3UZ782HMYeAm2dGO0d+HGR/yfTxlFGbj2JhjxtPn7Grng9/+mESftfo7CG4SPe2kBvow0nHdP5CwJadKKekbiBccK3HDKDifDD5tU12dNP8y+/42//JhUl2dKIooWL5BIulL5q/hZURjJNu76EvER73AjWSgJlJmYZr4GMplKAhbcGPZDe3dBWozHWH5BOB8TCkO2rNVVEXg87kKDlqfx1FwIhkL7RFZmNZpmhJfgSaSqiIIOp0FB61fdxakLStjeQBAFusl1dbNwa/fS6q5E60sTNXXL0UvC5Nq6bC2RvKAHFUIgi5XYbtdDowCE0mqq5Om32VPRE2/e5jk8H4rovB9MaXE53bashBURRDwFo4Tr9uJYZok+jrZ/Wx2w7vdz/6cRF/n2GjiJgV9ZEpJQHfltVvxuHBGQgQc7lEgQI8EM+AGwKc5C9acGevufCHAYSLxada5jWiCZHeUeFNXFshJtvby5o0/Jd7URbIrihHNDUC9qqOw3WOkiReqFyWROBL9mTwvPRRh3DlXo4ciJLva2fPzraR6u/D5XQVr3Li8zoK1t8YkJnkTR4cZTsA5Ok50f4j6MzejByMWyPnJD4nt35sBN3pRhKqLN2fVVXHrWsF50G460QMhxp29GT0UIdHTzo7fb6X/8O4MuHEEIkzYuDlT98vvcdqz5IQg4HYWLjuhqoXLZZjWnDK4PaUVRai68mq0ogipjnYO3rmVREcHjjy99oaLNS5H22REYzT9y4Mc+tq9OLsHsq4t1d5F0zfu4fC/3p8BOU69cLkMWdgcTCQO3V5RACVhX+GDHUH5BOB8TNm4ekbBzt2nbphdoLKw4ORjZtsPNEWwcsEEyiL2dNSK4gCrZ0+wfVAKAWctnlnQ7nPmzLIdtIoQbJo6y9ZuVQiOqp5ItTeY9wEmgApPgA3VjahCkGofAW6+fDGuybVUfeViItWVpFrTICdHPQlDSs6ZXtjus2bNtH3DNbu7aH/oLpKd7ejhCLUXXo0ejpDsbGf/g1szIKc04GXDTHt6JMAZy2faPsENU3Laqpm2caIIwWmrZ5CKdme2pxz+CJOPvwqHP0Kit52P/nQ7syp81BaHbAFDsd/D8VMm23dml5JzGmfbXpchJZsa5tuCAEUIzhw3L2+TVLDiZGnJeOp9xTkn7kEpcvg4pmKGLciRUnJKzWIE4CwJMOXfN+GsCGVATu/7B3jvcz+j/1AHzooQ0/9jqCBhlt0ITq5ZhK7krxmlIFhS0sDEQH62IUCR08PGiVNs/Z3o6GTXg7cNgZuzN+Oprs88sJNd7ex++DZWz66wBS+KIjjupNk4nDZ2K4KZc+uoH19qO34DATcbVk4tSP89a9nMnCsKDn84A3Ji7W3su+MH2eAmNLQaqgrBGXOmZycrj7RbCBbUV9FYUZJ3O1MPhJl+wfWESytI9LSz/bc/GgFuwhm7T189y3YFx5SSM1bOKrhFd+rC6bgd+WvTKEIwxe+k9Z47h8DN5Ztxjaun6vLNGZBz+K472BAssy/fICXnTJifM79MDsQxevpINney9+t3EW+z5ikL3NybxUBVheDMxhl4bGoYKUIwu6aCGTXltiDP63Jy4srpBePk+BXT8n7/PyGfAJyPKaevnUVJOP8qzqIZdWw6fj7zZtbm1Skt9nP2SQv49Gm56XoS0DSVy85Zzg0XrM18NlIH4Prz17Dl5KWoav48nAuOXcCFq+ZTHsyPppdMrOWiJfNYXp/f7jK/l8sWzGfLnMV5dVSh8NkFK/jK3PWWPTkMl8CX5q7n+umr0YSKcDlRA74MuNGKrX30LcuO5bmnn8FVVowS8KG4RudNLC2r5bKZC1hdNy6vTaUeL1fMW8CWZbn9neruYv9dt9Hb3ExlTS01523GVVNv5d4MBzk9Xdxy7GquPnopupr/4X3Byrmcv3Y+lZFgXp15E6s4b/18ls+qz6tTFPSwbnoFB5+6dwjcHHslvrJ6Jh97JQ5/hHhvO3+9/1+4aEnuehOD7v/CKau5ZvkSHFp+uy9cMJfLZiyk1h/Kq7OgtJqLJy9kXfnk3HujEiIOL5dMWsaWyWtyH0SCQOH6aev5wvTjADnqoTP48+enH8OVk9fiULS8D6azxy3h0+NWUO0pBkaDnPdvsFZuGhoauOQnX86q2TNcgg4vn65fxRUT1+e9fkUIrmk8lltmDXaJzj0yb565nuvmL7V9eG+as4CG2mo8kRIL1ASsB7EeCGdATiAU5oLjl7NmyaS8xwn43Zx76iIuuiI/BVwogsuuXs+V12/ADnlffu16LjpzCS5n/ofgKUfP4rx182koLcr5vcMfZuX5V2V9Vnb6pixwAxBwObliyUI+s8aigOe6vULA59au5KYTV+e0e/B3vrhpIw888GDWd3XrNmXADcCpy2Zw7tHzGF+ZuykrQGNtKeeun8dxC/LXb/G5nVy8YSE3HLM824hhRgkBN5y4jvE11Ra4u2wzWvr6tVDY+rkoQl1VJVcvXo1Xc+TNNThr4gwublzE5MDoZF0tEqTqyxfjqSimbf8her79ELGP9mbAjVZaRMWXLkYrCuLTnGyZvpSbl63Mbzdwy/JVfPbElbmNSf/ODcct58KTFuUtmQJw/PKpjK8uzvv9/4R8AnA+pvQkEjT7E1Zm/bDPrWRf2Kv1MZBMsssbJRESWcurEkh64VBxkt5kgg+UbqLlCuaIu2K4oLVG0pyIsivVQ2+1wBwx35g69FYLdhs9NCeidJUZmCOe/6YC8Qhsp5veVIIWXwzTSdabgERieGCv2ks0leRQogc0OUoHVdLFAL3JBPvau61y3qM24SERN2ntj7K/ow+zV2Pki740wezTONDeR0tvlIF2DcXhpuLm86j6igVuLB2d3Yf6CZeVUXf91ZRdexHKcDqpBJEQHG4ZYCCZpKmrz9qqGXlTJPQOJOhNxNnT14mp52B/uRwofh+VtbXcePedUBUCRaIHwxmQo3p9mCEHewe6aY1F6fWnMLXs40ghSflgZ7KLvmSCFucAxuiepRhu2C/6GUim2Gf0Ybhz6Dig3ZVAOhw4/H4cgQiTjrsyM2E7fGEmnnAljmCEQLiILmmQcuZYzhfWsfZ1d9PRH7XK8OeZ2PZ3dhFNJOlpSyGSYpRRIqHQ0hIjZqTYvzeO7NOz7q+UIGMqnfsVugfi7NwXJdnuspp2DhMzodB/0MXhjgH2tvXT3+pGprJ1pCEYaHex63CUlv4B2to1jFT2QJEmxKIOPjzcT38qweH+BIZhUWSdJQHGf/aELP0777uHgdDgxuhIj8NAaoC+1ADN8RZ01WCkowQmipKgPdFFS7wDh54ctV0lAIee4nCinfZEPzE9kaMyrEQ4TFocCX75m98y+Yrr0MLZHcW1QJi6c7cw9fKrcXg8HOjrRTrE6PBWoUck6YnGOXC4C1MTo2+vsFjBrW29tBzuRprDaOIZJQlScvhgJ11dAyT6EhZXf4SOYsDhg11EYwm6ewZyjrlkTycvPHRb1q82P/Iwya7OrM+i8SRdsRj7erpy5u1JICkkzf19HOztIanJnNtVpgZv79jOlssvyfp875MPk+izyipIDfZ3dzEQT9IejY7KXZQAwmpBEUskOdjWbcVJDtAxEEvQ0x/jYGs3Ild3CAlmXBI1BDf/8A6qL9iCFswGd1owTPWFWzj/6/+GoTuI9ZiMaswmQUkoHGjpZSCZpKUziUxTwDMqEtRgmAm3XMe4+nq6Dx2m6at3ZYObSAhpCvr6TDpjMfa3d+fu7ZW2+3B3H82dfZhJmRt0GXCwrZuu3gFi0WTe+aSppbtg64gjLZ+wqD4mi+rfHnuGn774BoZpcf2VdKAYThhcQz1n8SwefuEtAIQhUQesG55ygtQFqhCcNG8qv3n9PeuXTYketfIkDAcYLovaPbu2gg862+mNx0FKtAGLpic1SLkBIQi4nIyviPDGoSZMKVESVjdXKawH6eBLz2lzp/Ho++9hSIsmPhjgpoMM7D1vzmweeOcN6weJRX2V6e8Va0n5lMapPPJh2u7BSB4Umba7rIKdXe10x9OFFFSZbl6C1XkZgd/hYEpRKa8ePmTtCasmQrUGlEwO8kDhU43T+fU2y24p0scCSInM1sb5M+bw4Ftvpi0a+cCx/L2xcQq/2fZ+9rWRPo0CMhZjss9Pq6rSGYtZl5buDp7q6UJ4nCgeNz6HgxmRMl4+cABTSos2aVjHMfUhf5/dOINH33wvXQYgm5Y/6O9z58zi58+/lYkBJV3nQ2ogVWFVTJ3VyO+ffx0jEUf3Ba3zSSuRW2qCVF8XU+qqacGgo38gc21CMtTtXlgl6qdNLOelfQcsX5Itg7fxjPnT+dX771plAIb72xBWl3XgvFmzefDtdJwIiXBaM7NMKmAoVnxPauR3H3yQPo9EcRmgSGuCTqrWEn5xMU3xXtoGrIIjisO0KLKGwEiogMCtacyvL+eFw3sxpNX1W9VMpIRUUs1YfsGMafx2/2uYSASSVHsXO29+iMThrsw1FlWX0/BvG3GWBkY934WwVh/Xlc3kyeY3kelVpcHaO0JYjC+BoMFbxv4+w2K1pHVk+q1dEVZJBKei0ahP4fmmPdb2qTks5obM5rzSuTzyajpOBqnkpPMg0joXTJ3Fb//4ZvoLmdWVG8WKk/VzJ/LCo+9YD5TBUghyML4FQkBdXTHR9n7aW/OzQB0OjWnrJvHSG3swTZl58KdvY+a/x3xqDr96+V2kzNZJ9HSy+1Er/yVcVoF34+kWuElv/Q7fplIVwdGTJ/CnHTus6x8OlsTQfakvCpPsTdHU3TukM3htwgJUBx7cSqKzHUcwQvWGTRz488OZbar60zfjSK+OfWrRTB599u2hzuXDzyesf85YNYtfPvtWXh+pimD1rAn89UOr5EKWj9J+UoDa4hADHpODXT2WjtWY3gKFacq9riosnTWOv+3ZNTTHKcPGXPrAm+bN4KcfvpE+lxyaK00B0tJanXTwwJXXZ8wou/kKnBPrrBbv0poH19dM4Ol39pIyTWuuTF/3oC8UBDXBIK4WwYH2YX0XB3XS/9VUhQ3V9Tz32s4hHwyTQXdsveUM5k6pyevLscgnNPECciQBzop/uZP2/vxMKkUIitxuOgs0dfM4dWKplH2TSIVRKzejdABZoLGxKgS6V6U/mZ9JpQhBkc9Fe8zebreuEzft7R4FfPKoFFJShcCj6PQl8zOSFCDi8loN8uzs1jTihmGfYDeWkTEIfGxEFQK/4aAvbmO3EJSobjp77O12qSqphGmrI5Wheh42ZpMqkO+nKgKXX6cnkb+cgAAiHjedMfsGp05FJWlKe7uFRGqFnC7BZ+9wVSiUFpn0GVY7jURrN7u/+CDJw53o5WFqrjuZA7f+jsThTlwVIaZ/56y821S6omBKM2e+w6CkTEE0kZtmnrFaQk+HzzakNKEQbvXSk4fRBZa/q/rdRFsGbPNCPP0mWps9QwhToibsfSmBRJnb9jiqqmBOdNMVz7Y70dvFrkdvywCLGZs/Q3/ATayjI1N+QQ9HqLpkSybRWNUEKVtvAwZoeVyU7Oli/wO3kUyDm/rTN+Pwh61q0L+2CiY6ghEaTt+CK1hESHHQbVO+QQAhv5vuaMw+j1ITpDR7u6VSeMxJJEaRffkGTVHwhlQ6EgN5dVIdXbR95y4SLcNq7ZQUUfrZy9GKQkOfJRToL0wTd7cWmMClxN8uCrSaUdi4Zgafu3Cd/bEKyCc08X+i9MXzT0ZgJanFU6nCNMOUUbDK48dBokZsgFR3F2A9TIfXmkh1dWEOZA8WU0piY7A7YaT+adUpFSGIGfYdgk0Yk91xwxgbK+0IiBCCeKqA3VISS47B30mjYMPCsRk1FhVBrIDdEgoCc4C4UZiOOiYZk92QMC3wnmzryQI39d88D8+UGsZ98zxcFWFiTV28e+MviOdZxUiaheNkLDRxKUdvFeWSQp27JRCPpwoyjVJJE6UQTXws77ZibGq54kR1ONE8PhyBCA2nbUb6/JimRA+FrZWbcATV50NxDoHDlCEL05ZtvlMcTlSPDz08BG4gnex8+mYcwQiq24ficAKSeGIM8T2GcWlIWXj+HkPsKqJw80sppe08mOroouU/7iTR0o5WUkTZF65EKyki1dpBy3/cSaqja8hucwz+HgMZT8Ee3Aza3Tdg/7w80vIJwPmYUhuxZ6uoiqDE77VnNQERn7sgbdkxxroWI+moRmyAQz+5iwN33Uayq5OUaVLs8VjbZJ2dNN22lcN33Z0FclQhKPX6bLP5BRBxewrarY2x/kkhemTKNCnxeO39LQSlXu+Y7E4VsLsQM2pQHDYJxmA1Iyz2eW2L2KmKoHgMcVLk95AqQP8tWI8DQFpF1ezEME1KPB7bCXDM/va4Cvt7LOhFgkvNn6gL1sMm4vChIFDcDrSgJwNuHCVBANylYdb+cAuuihB6yIPqyb3kFdK9BWni2lhAl5C4bRKMwQK5xX6vvb8VQSRsHycA/pC7IE1cjJgnkqkYsXh3tpK0eqDFB7pIJXOvGEgpKfGNtlt1uqnfeBkNp23BHSyi1Duko4fCVF2yhcrzh4r8AQTdrsJ0a7tx5HJTfc5l1Jy3hVBxdhKuwx+m4fQt1J9yGarTWpWKBAv7uzhgrwPgdzsK18MaA1A0pcSn2y+/SqDEnXvMDYKbVGsHrrJiKj53Bc4J46yVmxwgx+9yFu4mPiJsjfjAqI73JhKP20E82kUq38qSgJqykP25jrB8AnA+pnxq4Szb7w1TcsmqBbZvXBK4cPl8W0aLqghOmjmFiSWRvINNEYLJpcWcMj2bjirjcYz+PqvWwt1bEX29XDJ/HsnOTpq23k6qvR2jL7vgliElV85bUHCyuWT2fJw2E7cqBKdMmsKUSImt3ROLIpzeOM32QelQVS6ZM8/2TdiQkivmj8HuuXNtHziDeTrTS0tt7W4oCnP6dHu7NVXhosXzRuVoZtk9hjgBOG/FXDw2dFRVERw7azIzqsps7R4XCXHGrOn2disKl86fbzsBGlJy5fyFBf190ex5+ByOvM8mVQiOmziZOWUV+e0GagMhzp44y9ZuVQgunLgcE4nqdTHuK+fQ8K3zM+DGstvkisWnMP27n2Lqt8/IWclYIDizZgVeNX8tIFUorCmfzuxwrY3dgipPiE0TZ9sDQQGXLC7gb1NywTH2cSKE4IyT5+Pz2fR0UgTLVk5mxuxaq7hcKsYbHz7Eq9vuy4AcIQRlZQFWLark7Rfu4N2X7s0Lci5Yn9tu1enG4Q9Z8b0se1zqwVAWuFGE4Px5swm57PwtWDupgUX1NXl9qbncVFdXc9ayWaPuie4PoQ5rHnt+HrsHxTAlFx69wHZ1QhGCTSvnEPa689utCFY11rO0oTav3QIo9fk4d9ZsW0AlpeSKmYtyjjnF5UTx+9BKivjOL36Kku66rhWFMiBH8VsMVEUIzps1m0j6ZTen3UKwYsI4ljXWoSrCqk7927uyOt4LIBLwctTcSrY9sZUPn7o7J8iRUnLCqul5r+t/Qj4BOB9TTps/jfqyohyJ49YnJ86dwsnzpnHsnElZnw/pwYSKCJ9aPIvPHLcij47E7dK5dv1Svn7CUemM/9E6CPja8eu4buVSPE49o6MFQ1RdOlRrofP+u2no66ftzjtJtbejRSJUbL4SLRTK/M5JjZM5bep0Tp48JadNABOKijhv1my+uHTV0MWMuDi3pnPjkhV8a9X60QyLwd+R8K2VR3HdwqX4ctEj0z9/YfEKPj1jNlOKivPqnDB+EqdPnc5pU6bmtakhHOa8WXO4ZeWqnNcmkbh0jc8sWcbX16xL1wnJbfg31x3FtUuX4nU58ujAjSuXc/a8mTRWFI/SGTz3hmkTOGXOVE5ZOC2PTVBbGuKcZXP43Mmr89rt0DWuO245XzzR6syeS0ci+erGdVy1fDE+5+gH++DvXL9qGWdPn8n0krK89+3ohgmcOmUaZ0+dOfySs/TqAiFObRjP5omN1tcjdFKdXWjxJJ9ftoJvrDjKKviY4zgS+JeVR3P1zGUEdVfeGLhh1grOGDeXacEqi1XidaEXW3v1g8mkq0obOaFqDmfNPhrN68xJIip3FXFm3QqumbzRutwcOprQuGL8cXxh2vHpQpW5ZgLJLdNP4qoZSwk5XbmdBFw3axlnzZ7BzOpyRsrgPVk5cRwnL5jG6etnDb/krCOVl/g5+9j5XHXd0Xl1NIfK5VeuZctnjkVRFFJGnESyn4F4J69uu4+BeDcgOeuCudyz9QvEoh0k430YqdFbDOeftYRTls1glk0LlaWNdZw6fxrnLZg9/JKzpNzv46LF8/jK+jXp8Bodu5qqcNOalXzx2NUoisg9DwJfPXEdF69bQNjvzhcmXLJ+Iacsm86siZV57V44tZaNS6ex6ai5Oc2WWMXrzj9qPrectnZwWIzSUVWFG09ayS3HrkZRRpfwGPz5K8ev5fL58yl2e/LG95XzF/KpxpksKqsZpaN43JReexHHf+cbXLnqaC6bsTDzu4Mgp/S6i1DcbkrdXq6YuYivH7U270ujqih8cfVqPrdxFYqiYAyrTj3Y8V4Cly6bwj3/cSPxvnaSsew4GTz2OccvoKL44+W8/nflE4DzMWV3TycfONpJ+U0r4z0tUoVk2ORvfbtojfbxVHw3yWIzqyqkFJJU0OR9dyt7ezv5z85tJKtSmM5hx0Fi+E1ayvt4ueMAj7d9QKJyAOkeSnyUSKTbJFE1wBPtH/Jqx366i7vBa2R09FCYqs3WXmzrwQOsWbWKgZZWtOIiyrdciRa29qpRAK/B8707aYn28nzTHsSIhSWJBEWys6+DPd2d/OX97Whxkd3UUVrJtwM9CV7df5Cn39uF1iFQEmQNSpEEvVPw9Hu7eXPPIRIHEqgDI3RS4OpS+NsrO9nf0cW+XZ2oMbLPZ4LeL3jtvYO09vbx9x17UHLQLIUJ+1q72N3RyWN7PwKHzFrytq4NekWclw8f4G8tH2EEY+AYpJClRTcxQ3H+2vwBr3fupyfcBZ4RVGJdohQneLzzPfb1dbHNcRgjYGTFCSoY4RTPJ3bRMtDPX3t3kizKEScBkw9dHezs7uA/D3xEIpKdcC6RGG5oDyV48dB+/rZvFwM+02oyOMwmqUHCJ3l8z07ePNREV2IgA3qGi1DgL9u3c7Crh5172yx24HAVCWpC8PpHB2jt6+fF1/bg6BHZCdcmqFFoeq+ZDUcfw+c3fRptZ5cVA2lJdXTS9KOt7L11K0+/9j7Pvbsb7TAosezzKXFwtio8/eZO3jp0mK6mFMRHACEDtF6Nx9/ZxcG+Ht440E0yro2iridiOs/tOUxrrI/HD+wmlnBk2FEZnZTKR51Rdva28mTTNpKp7Lo7g2ypnrjJqx27eaHtI0wG8yKyfakIyTMt7/NO10F61S4ULTuWhJA4XCmeanufQ309vJ08jOGR2XEiwPCavNS/n5b+Pp44sJtkSIyIE0h5YJfSy/bmNv721k4SRTrmsD00CRhOhR6fwivb9vOP13Yz4FRwekPMm3IhbmeYgXgnr227j7ZkExdcehZ7du/G5Sli5tIrcLpD2XEi4LmXtnO4o5eP9rRY+Roj4kQx4N3tTbR29/H0h7tHP3TSqOBwdy8ftbTx593bwUHOcTmgpPj7gX08dWA3/T4DqY+O72QA/rxvO++2tnDAHSU1AitI1eoJ9afDOznc28friRYSAbKo6aYCiQC8PNBEc28ffz20i1SQbH9jMVP3qr182NLKn3dsx/CO1pEa9DsN/r5nH8/s3EM8zf8ehV9UeHz7Dt5rbqG1pz/jl+GimPDX7Ttp6u3lnUMtCEMZPS6dXrbHUhzu6+XJnbtQhpVc0IpCKG43mNDc1c/7bS385aMdeVdwEobBs3v38Pfte4ljoAdC1J8xVJ169yNbiTbv5qpzz2L37t04/REmb7gShyc0dBAB0gHPvLezYDrDkZZPWFQfk0X1uaf+zKMfvZehfooU1g3VyAzQkyY28odd26wf5BAlW2pk6Nbr6hp4/ND2IZ0UYAqLVaJah5oQjHAg3kF8MMEshUWzVmVmn9SpqNQGwuzsabPi3kjrCECXxD7ay6Gv3JWxv+yLV+CaUJfWkRkaMcBJ1dP4w0cfZmzKEpFeLq5u4Kn3d2c+zkzK0lriF0BDuIjm5t5MIqIUEqlYYGOQauxQVRqCYba3tFmsVmF1pB0ESoP0yLXTx/PUR7vSVMRhOubQ+Y6dM5k/fPRBttli0CbL7pUTxvFE886h6xnRTVwA44IhWkQnA0ZySMcQ1mZ6ehJzKCoTwkV82NVq9UgygZSw/KgOgaf1ZVN4Yv/2TPdykRTpOJGZ851YPY0/fDjkbzGMJj4YJ6uq63l6+56h2zCoo1o6AqgNhmjr6yeaHLJbmGR1rdYVhclFxWxrbbG2znLcX4BjGiby5Ac701RyOfRKNMzfJ0yezJ/e+DBttsxQmq1OwwKzr5umX9xBT2szejBC/Zmb0cIhkn2d7PnZ7SS729GDEZZe/nn6vR7602wzqVhxggmKaRmkKQoNjcW819IyRF1XpPV0N4fi5OjZDTx+8MP0Mr60Oo4DZrp7vQBOnTSJx1veYtDhSjp2LbBjdVJeWtLAq13bhjlGDlunsY5T7grRlYzTl7LYOMNn1MGdBlUojHPW8U5nEyYW5VyawqqbI4b0jgrO4s87dgzFySAFfNCnCE6paOQv//iIwZMJY3gMWDTxpbW1vP23oXEpDAmmRKoiU76itMiH0TxAX1/6bduUxAY6efONe4gNdGR+NxAsZcqiS3G4gnnjZMmxU/jruzuGqOQjVIQQrFs2iT/sHIyT0TqqIlhYX82zrfuGu9v6K4bOVeb1Ek8ZdMXT7Kcc8a0IwbxIZaZcBiaZ8g3DKffHT5jEX7Ztz9DSldQQKEFYxzmucRKPvTtsXA76O62jCsGCumpe2rN/6LoGgZ4YsqnE5yGBSedAbOjaRvhREYI54yt47dAh2/INx06bxGO7PrLGwODENmgfVnmO4yZM5D93Do3LzAHSOqoQLCyr5pWdB/Ou4AAUe9w42oRVdiJ9jmRPJ3t+sZVk9xBLy19URv2Gy9A9oWxwNuzeffeqjayaPd7mbIXlE5p4ATmSAGfmT35UkEYb8rjoig/YBpHLoZIUBdgoQqbf/uwlX05vqr2LQ1+3KloOilZSRNlNl6JFQqPsDuOjM5q/qRuAO6VhxqSt3cIANV4gE1MO1YbJJ6oiUJ0qMRumiQD8YRedCXt/a26FpMOw97dqongKGIUctcI16jBCQUs5iKby0/IFEJJeuqL2HbcdpopMFmjcKCncj2oMOpqi4DI0ogUas0YUF739MdscI9ndza6f/ZhEGszUHLuJ/X96OANurHL+4cL0diFJ5C6Ym2W3VmLSb9g3OK0Iq0Rlv23zTqcq0VTDVsd6ftrHt5TQH7OnkmtCQeny0xu393dZr4doZ8K+nEAPuNvtafkiKXH0jaaJd3ft5Y1Xbs/8PGv5ZgJF4/IeR1UVjFoXvQl7f7sqXXRj3whXOsFwFqCJj0UkKAn7e6IpCl40egs0wg05nPTH7BsPD8MXdiYV7OskkZhuex1VFC7fABB0OelL2vtbJEFN5K96P6jj7Brty+jB7I73k0+4Cl9ZfX67FcEJS6fxpQuOtrW7kHxCE/8nSsIoXEciZRoFB2xKmmOgW/+/D/vh4EYvK6LqS0PUweZv3z2qeaUEkkahvs0W08a2p9XAAKmurpzfJbu7MGL5azmMFIEoyAyx/F3Y7jH5u9DtGKOItE12Mla7DbMwHfVISiG7B3UKNZxWfUEmfOqqzNL2rl/8KAvcOALhI+ZvsO5vYR174AJWMvKR8PdYR26hTtIAhmEWrAgrDVmw6W4uq2KxLra9+8uszz58/RfEB7psjzQWu1NmgbpTWCyiI1FOYCxHkFIWZCTC2MalhCMSJ2M9xNjGZeHnjnXOwi+fIyWZo+P97md+nunenu8wiQJlEI60fAJwPqbYsYPAQtu1/pAte0IRghpvsGDQerQCr7eDemo2yybV3p0BN4PluifOnUXFzZdlg5xhzStVIagNBgvaXRUK5LXbGBig6d67OXjP1uwO3ECyu5P999/GgZ/elQE5Xht2EFiDujocLOjvmjHYXe3Lb/eguESBqopp8Ra4LylpUuO3t8nyd+E4qQr4C9rttGHjDRe/o4Ddpkl1KFDQ7poi+3siBFSEAyi+IDXHbsr6rubYTZmqsg5FKfxgkhDIkRg90u5ar70vVSGodhdhd0YBlLlCBWnidk1Ehx8rqOdnNYEFpgqNOVUIqouDtg8lAZSW+gsy8jSHlvVAjcW6ePPVu4gNdOByFzFnwZW43EXEoh28/fc78oIc0zSpKQraUtdVRVAbChW0u8LrK8jIU4UoXJsICLvtl0JMKakJF/C3IqgJh2yPI4ASv6cgeNOUMdgtITIGu+sCQduGs6oQ1AZCtscRQInXW5jerouse5vZnhre8T5oNfv98LHb84IcKSUTa0psz3Wk5ROA8zHl/OlzbAPElJIbF6ywHbSmlFw9eylBR356pCIEn540l/kl1XkHpCoEC0tqOHvC3KyBpLidqEEvWmkRVV++hKLycq6esQylKGhtT5UUoQS8Wc0rTSn57IIVBa9ty8LFBPPQOmU8jtnXR7K9nZaf3oXZ0wUMghurkqnR34dIJJhbW8mnFo2mdQ6KAHxOB1euWlSQtnz9yqWF7Z6/iLDLnfcBpwrB2ZNnsbSsztbfsyNVnDdxPnIgTqq9e5SOABzdUS4eZ9/h3JCSzyxYXtDuzQsWEXG78/pJFYKzZsxgeV02HdUctpKmCsGM8jLOmzcHRQhSXV0YIwo9CsCj61y1YnFBu69dvyzv92BN2peuXYDXjHHgT9lvffv/9DCJnk5UITh1wXSWTxqX90GpCsHUijLOnzPHNk48us61s5cVtnvaGnu7gYsmrKTE6beNkxOr5rKiZHLmgWP0x0i09WTpTAqUc96ERRjtPRj9uSvnOlWN6+aOwe61Swvaff6xCygt8uWnriuCDaunsnTxBBRFEIt1Z4Gb2fMvI1w0jhNP/gIlZZV5QY4Q4NA1Lj9xsS2gMkzJNeuWFlyhuGzhAir9ftv4PrlxCusbxucdl4oQTCgq4uIFc/MCKoGV93fNqqX2/jYl161ZWhCYXLJ0AVWhgK3dJ0xv5OjGCbZ21xeFuWT+/LzPAQFoqsr1i5bZAm9DSm5YuKxgTaxL582nNpT/BUUVguOnTuboGRNRFUGytysb3HxqM77qBpZuvonSiqohkNPfNfpYisKJyz7pJv5/Sk6aOIWZZaWMTnm3/n/ezNmsqW3g3Okzsz4f+r9kbkU5p0yYylcWrUl/O1qnyOXkmplL+fqCDekcwZGD0uqN89UFR3P1tGWEnc7M7yoeFxVfuIDKL1+MGgny5XnrOLlhGnNKKtAiQcpuvpSyGy9C8QxRWD/dOIfVNQ2cO31O3mufWVLOqZOn8aW1q63fGmG2FgzReM31jKuvp6+1mT333cbAvt0ZcKOHI9ScvxlHMMyXjlnD5asWWjTaHK6UEr5wzCpOnNHInMqK3K4Ezpozg9UTGjh/7px87mZ6aSmnTZ/OV5etSW9RjPalz+HguvlL+cq89ekH7mgdIeBrC45mU+U0Wv/1QQ597R5SbV1ZOsm2Ljq/9QA/uuI65gWC2cYO+/+nG6eztmY8l86dm0dHMr0swplTZvDVdWvz2u1161y/ZClfXrsGRbVotObAAE333M2h27daDQ4FfO2odVy+cAHe+AAH79hK0713Z0DOIKfqC2tWcvzUySysqyKfnDprKqsm1nPhsrl5/T25rJiFZUH2PXJ7Jgen4VNXDzExfrUVNdbHlg1L+MJxq1FRcl0aAF8+cQ2XL1hAicubN04+v2wFx49rZGlJXT53c2rddFZXTuT8+nTn6mE6Mn2cBk8Zp9XN5zNTTrKSOUfYJCU4hJMrJh3NZ6Ych4JCqi/Gji/9ko8+91MSrT2ZY9009SQ2uGo4+OX7OfjNhzD6hwNK68Cfnb6OY+snsbKuOtvYYf8/pXESaxrGc/H6BelP5TAN6099VZgzFs7khkvXYYrR+SwScHh1rty0gs1XrEV1qKiqE4fDlwE3TlcIKeCWWz7F359/Dq+/GN3pQ9GcWceREi45bwVr505kyZQ68snR8yaxaloDVyxbmFenPhLm7Pmz+PqademeVtmWD5Zv+OyyFdy8chWapuTUAck31q3jgnlzqAh7M59l+wmuX7OE9ZPGs7KxLqcvATbMmMCaSQ1csXZRXn/XlIbYtGAWXz5hbeazkTY5HCo3rFvGF45aia6pOXUkkq8ddxQXzJtLVSCQO76B65cs4eiGCRxVNz7z+XAdgGPqJ7C+fgLXzl+aW0daNaUumDGXrx+1Lr/dmsrnV67gxuMsu0W6OvUguNECYSSSf7nwdF78+/N4QiXoLh+Knh0nAJedsoSw38M/U+xLa34iBeX1tgO8GzuAcCvIuGI1MgPQJKrT4DeH3uT8ntn8Z8vrOPwmyQEVoyeBGY+jFwdQXSnej+/m9fb9PLT/adxGM3HpwdR8gMWycLqTJN39/OehN/mwZx+BQD/9Axqx+GA3R4nLmcTrTvHL/c/RGKgi5WjHJXXiCQ0pBYrHiTOg4XHFeHj/09T6wrzXtw/VISASZLCOuFAkqm7yh4NvcEH3PB796F2rnkqOl5y3Ww/zatMB7nnuVbSkIKXILBaWSEFMcXPtD27j65dcTGdLE/t+YiWlDYIbpzuM2m3y0N9eZ3ZtBX2HBlBdVgf1wYx/JQGOBDz02KuMLy7ivQ+aUHWrEekgm0kYoCbgTy9s4/ylc3j0jfdQDIE5mEkrhvTeO9jCq/sOcPv7/0BxmphJ0iyq9Ak1STdRfr3zHQ4ZB/B4+xFxjXhcy+g4HCncLoOf732eSYaTVE8XqZZumr5xr9WxtziI1tvKoW89SKypC11RSUXfIRwqorfPRSplDT2HI0XAF+fFvhfZ3beQP7T/A0/EIN6nY8QtuofQTBy+JHvUPbzatps7dj2PWpzA6FUhlna4IsFj0OPt4ZE9b7G7s4tEIIGMCozuGEZfH6n2dpru2ErlFy7nrg9fYqrh4d1bv0uqw0o6l/E40u2yEiGdkjvffYVpJaW8fOBghs00PJlSKPCfH3zIpYsX8MiL76AYQ+Gf8bcJ723bwbLvfpGmA/utZoenWQ0W68/czO5fWUyMdx+8lfsWzyauexA9Boqe7qc1GANJUJOSh554jWVzG+g41IfqzI4TkQRHQnD/U68xs7Kcl7Y3IXQV6TRhsMdVSqDEVR57ZyebZ7TzwDvvMWC60F0JVN1ECItplYxpvNXZw/MH97D1w5foi7rRHQkcmpHWgXhSoysh+OXON+kyuoklJclokmRXP4nDXXz0+Z8y/tvn4iwO8YO//4E/Xf3vxA634yCEjMXB6wYkmmLicRj8av8zzItU83bqfdxhjXifEzNpBbjqMHD64zzX/zo7e5Zw38HXiFUbaB0CNWrlp0kdkiGTd9wtPN+0hztfe5W+cQp6m4mj10oqN1WIB6GnKMkvXn+H2OEBuooEuuZhxtyLMFJxnK4gKa9CKqjywJOvsWHeZCauvRwdJxquzINWqhbl/GePv8asWbX8Y9vevPPkU2/uYOfhNh5+9a2c1YIAdrV38vzOPdz+3ktIh4QUSFNa14YEFfqI8/C2t4iKGDHvAMRUZFxByLSO08R0m9zx4YucmpzGAXcrBDXoUxFGWsdlQiDFvXtfZOm4Op4a2I4sFig9KiKdmCwdEiOQ4s992/iocwn37n6VmK8P0ZbA4QpbNqmQ8pl8qLXxyCsv8Oj2HSSDEhEFJZG2W0gMJ3S7Ejz8/tsk4yYDIglqOk9q8NoUkBrc9crLnBGbwYHOniz20aDDVFNw/6tvsKqhnqd37bJ8OWKZQhjw5M5dfNDayv1vvYEihfVCJLOPt7eriyf37uKnb75pIYGUtY003KYBkvzs3bdgAPocKYTfTc0ZlyETcTR/CKlZjaXvevlVzpk5k+qzrkCXThRpUdElVjkL0y144OU3OWfdPJz6Pw92fMKi+pgsqiuf/zVPHtyRWS4c9Obgip+CYFVVHS+07sREYvTHOPDNhzC6+6n5+oXoxdZe6tziKl7b+QY7b3oILeil/mtno3pdmWNZ+QABulPdo8418nxhR4CWeE9eHYApnom81nbQ1u4lgUk8s3v/UCLm4LHSOqoQzAtX8dYHTZnjDn8LGKTslnm9HH7lfbb/4geZ7xrOvBpPZX1mvClAhddPc0fvqBeX4Yunc6ZU8cbeQ5nl8BEmoQjBgtm1PHtgb+aaBm0atEcVghn1ZbwcH0FHHXHCMo8H6WvNJKzm9jdMCrnYu38vr1//CLGmblwVQabedAzvf/vPmZ/Puvtz7Hb12Pp7VmAKzxzenTFlpI4qFKYGqnmpqXnI7Bw2RRxeOvsTQ4mf0koyb/63u0i1dqCVFBG59Cy673mEWEsbWnERZdddiTaYazDM4cvDdby67+DQ9sMIhytCsKq8jhff3TNkNyMOk4xx+Hc/obezkwkbN+PwhTM6ib5Odv5+K5rbx9yzriWmqCRTo+uEiGH/KasPsb+jKx0no+MNYN6Mal46fCCz/TAyBhQhWD6hhmdadma9kw8/myoEM0rKeK9//zBLRlsVdrqRaj9x00qgTLR2sfsWq3O5ozxM9fUbOfD935E43IWzPMTkfz8HZ0lg1P0FmBOawCvte23jZK5vCn/dNcymwQGTftCpQjDDV8ZH77QP0xn2gEsfLOh0ou1LDfW/yqEDMD4SZm9Tx1Cs5TB8zoI6XtlxIO82laII5s+p5elD+UGQIgSN1SW8ERuaT3IFQcDpJOGMD/VjyjNZTA4XsbOnPe/8BbC0tJ4XD+8b2qbKMcctLa3n6Q8+oOUH92L29lH6mSushpVpHdnZTdt378J0eyi78hKrzkwOm3y6AxFjqHxDPrsjJWxvb89sV4+MXYCl42t58eC+vPGtCsGS2lqePbhn2EmyL04RgsnhCB+2to1WGWaTV9fRehX6E/Z2T/cWs+PwkN254uRbZ21g47ypfBz5P0cT37p1K//xH/9BU1MT06ZN49Zbb2XFihV59Z955hluuOEG3nvvPSorK/nc5z7HFVdcMebzHVGa+K+/Q3/KnmYY8ej0pKwl6WR7N/u/dB/J5k70snAG5GjdPWy/+SckDnfiKA8x/l/PwzGi6qNAoqsF2DiyMGVVFQrRqJuEac8A88aCdPbbX5t7QEPpF7aJr0ZrJ/sftDr5DsrwTr+W4dYKjJ1oqoJ0CxIpe7vd5U46c1RcHS4iZJLymbb72LojhT9oz/ISmITcVk5FrKU3A3IGxVURZMGtZ6IXF2cegPlENYJ0xhM5324HxUzpJJOard3SADM1OvE11d5F879aIGdQMuBmWIfhzHeKgrtPt6XlA0QSTvp77entSn8MonFUT3DUd4m+LlTdieJ0Z1bk8okUkBh9iFF2yxJBtEBjVn9Yo8e0Lyeg6ia607TN01AUE6cj+1yJ1u40yOnMfDYc3OS0WyhI00HUsKeJq9EwnX32DDBHt4KjS7PN6VJjEndb3q8tkbLguFRVBYr0guUEHJVOerCntxseE9OHfeKrIsFtPweARFHtH22aUNBxFJy//cJNd1MrTf9xe+YFofRGC+SkOrpo+c4d1ufFEcqvHvaiMFJMqzhmAbMpxAFThcDp1ehL2tvtdTmIGvb0dkyrXJetp1KgRQt0HJeg5+5XmxFVEZwwZwrfOmuDvWIB+T9FE//lL3/Jddddxy233MIbb7zBihUrOPbYY9m3b19O/d27d3PcccexYsUK3njjDW6++WauueYaHn300X+y5ZYUbFRG9lumHglaoKYsTLK5k/1fvo+BD/Zlg5tvnzsK3BxJESNsymv3WK6tgE6yu5N9D1ngxhGM0HDm1TiCERLd7ez+9dZMP5MxyxjgeCHKMlhAsMBUM7aTDRNXqZ9pNx2T9dm0m47BVRoY05FGrlzl1BmT3blFi4SIXHZW1meR88/OCW6GbBpLfBe2W3G4cfhyn8fhy+4PdCRkbP7+n3u3c5QEqb5+Y9Zn9Z89MS+4sewZm92Z4m428s9+bR37XHEk7C6sNJYxMnIFMK+elKhFIQvUDDas/M4dxHfsGQZuiqi8xgbcHGEZk7/HHOH/rzPKsCOM8RBjeV4eSflfBzjf+973uPjii7nkkkuYMmUKt956KzU1Ndx+++059e+44w5qa2u59dZbmTJlCpdccgkXXXQR3/nOd/7JllsyvyR/0zdILwMGshsf6sXZIGffLfdmg5thTQGHS8hh30kbrCXKkG6fyJWSJo3B0oJ2N0aKC1KyJ5UV5129SXZ3ceAnVsb94IqNt7LeWrkZBnKSvV0IrE7ZtnYbJhMrijNN30Z2tB20u0YVyHhupsqg3ZODJQVrpfgVry2N2BJBWPcD1grOe9/+c9a37337z/Q3dzPeV25L61QQTAqU2Z5PEYLJoeKCdgedzpz3LdXeRftd2TVO2h/4eaaz8Ch902RyaXFB2vKkymLbCU4RgoaqooK0ZZ/LUbiDu4Qyv8/2rqRMk8aikoJ2TwmV5v0e0k1gA8UFactu1Tnq3iZauznw/d9nfbbvu/9ForWHfGJIk0mBsgL0X4VpEXuqrSIE48uLCj5MXD4Hmlr4EVBe7Lf93jBMJlWWFKSJN5aW2AIYRQgmBAvb7VYcBan5Eqj2Bm3jxJAmU8IlBenWU4pKkVJavZyGgZzmf9uaWdGZ/9UvoIRCtja5dBWHWmCJUkBtqJDdksbiMcR3pMTWlwqCceFQQRjkdKoFS0+YQE1x0HYeMEzJnHH5+379T8j/KsBJJBK89tprHH10dmXDo48+mhdeeCHn77z44ouj9Dds2MCrr75KMpl7iTQej9PT05P190jJhZPtO1erQuHzM9ePenDpxUEqrjk167PZN52DqySU8zgC+HT9UlaWTrXtEr26bArn1C/PTzdHUO4Kcu20NfbL7ghuXrjWdvAbUnLd0mVUBXPTIxWnE9Xro7iyivO+9O+4AlYJWoc/nAE5qtuH5nSxanoD566ba0uTLwv5uOq4pSQGouwe0dF2UFK9Xbzyo3/j4P135i0iaEjJdYuWUevLT48UwPmNCzmqfJothXJZyWTOrF1NfNj2lKsiyLwfnoWrIkisqZu3bniUja7ZtttKQghumLIBzaYWjCklV09dTZ0vbNORWHD+5AWcOK4xS2f49pRWUsQx3/86JdVVpNo6aL719lEgRxGCEo+Xz6xYXvAB/7ljV+JQ8ycOmlKy+ZgljCsLo+R5CAohOHv1bI6ZNzm/vxXB4sm1XLxift4pWRGCiNfDZ1fY060Bbl68Gqeq2fr7mukrGO/PD/QVBJ8ev4Djq2Zmxvjw7SlHeZiJ/34h/soSooc6+OBzPyOeA+Qo6ReTayYfbb/9KCVfmLsOl6bb2n3VoiVMLI3YUpLPWjST45bazCeKYO7kGs47cVFee4SAgM/F1acutwWwppTcuGEFbr2A3YsX24JTRQjOmTqL0xum247L+SU1bJ62NG+cCCDocHHT3LW2/jal5OaFq/Ck/a0VhYhc9KksnchFn+LG9ccyrST/S6MiBJtmzOL06fbzyZzKCq5cvDC/3UIQcDr5wvKVBUtKfGHpSnwOR35/I7lq/mJmlJbZ2v2p6TM5Y/YMW7tnVJRx+dpFeQGsEFaZjxPmNOa1+X9C/lcBTltbG4ZhUFZWlvV5WVkZhw8fzvk7hw8fzqmfSqVoa8u9ofztb3+bYDCY+VtTU3NkLgBYWd7AnEh+VPrpCXOZUVTJWfXzstagk23dNP3wN1m6+777e2ItXaMoqwBB3cvZ45ZwxYT1CKlk6KeDOlKCkAqXT1jP2XWLCejerN8f/L+JZMukDawoG8/corQfhgdl2sazG+Yxs7iCc6fNznttc0srWFNXzw1rl40ebBJUl5tpl13L3599hpvO2WgNovTxHf4wDadtof7ky9BdHq46bilnrZpN2OfOaZMpJVedtIxljeOYVh7GiPZZK0CPDG1zJXo6afrDXRzYtxd3MokZz52HM7OijLUTGvjc3FU5Jgnr56DTxUVT53Pl5HVoYpD3IYfpSBTg6slHMU/W8eYNv86Am7nfP4Pg9Ermfv903BVB+g91cu0pFzLNCGadY/ixTq2Zx9RQDRdOXMBIWuvg/2dHSllTPpmb5qxCZprdZOsUuTUualzI9XOWYZEVJKmObHBT9cXL+O75l/D3Z5/FWVo8BHI6uzLHMjG5cclSlo6rZfGE6vSnctjZrD+nzp3KjKpyPr1mTh6rYXJtCWunjefqU5ant1dG63g9Ds5dP58rjl2SWVWQI3QArjlxGWfOn0G515fTlaYpuWbNEhbX1LKqoi6fuzltwlRmlVZw6aRFmQ7jI42a6i3jmLpJ3Dh1HabBqDEH4MHJpROXcPnE1ahoJFp72JUGN3p5mHHfPBd3Yy2//vN/0tDQQPxwFx9+7mckWruzTmhicsXEtcwvrufYqtocV24ZeVb9FGYUVXHd/JnpXhujDZ9b6eP4+snccPwyDNXM3CtLw/rXFVC5ZNV8Lt64GMWj5IhukCpccdZyTlw9ndLyQE6LTODiM5cyb2I1K2bUk0skcMyCRmaOq+DSpTnAafqD8ZEijp82mZsWWw9vc2BgWEym/a3pXDlnEadHxqHF48OszbKcz89dxWkNM6kL+LNPkvGC5NqZS5lfWs0x4xpy6oDklAmTmVNSxZa5i5BIUh2dtP/kF1k2dd//K+Y5/Xx+6YpMXpTMsglcusYVcxeyZckinHlWcSRw44rlnDJtCrXBYE6TpCnZsmQR86oqObphwuh9zfTPx02YxLzKSrbMW5QXLNWHQpwyaQqfX74iU3Yiq4EzEqeucuX8hVyxfAEOpzoqliQSU0g+s345J86dQnVFMKcnTQmXHLMIj3NsxWqPlPx/giY+shiTlPbl6HPp5/p8UG666SZuuOGGzM89PT1HDOQ8eWg7b7Qfyvv9g9tf49iaKfxs52uY0kKyydZuDnxlKNG47OrTMO7+C01799N+00+p/9a5uMrSE4oEwxC0JmPct+MF3u/eR9wQSASqIq2gBwxTYCD4/gePMy1YTftADITINBCEdBNBQ+G77z2OjotX2w4A6f3TEUDopzte49iq6Tzwzut5t7xfb27iL7u38+9PPGfl9eTACn0C/ry/mR0fvYNppnmD6fPp/lB60Jp8//fPMa+2is6e9KrLcJuklVf4g0efw+938mF7jPrTNrP70a0ZkFO9YRMH/vIwie52qmvrcJ19ASJTdyZb3m5q5i8f7uBb7/0NoaTjZ7jtQtKdiHHnuy/RLvagqUkkkDJFxnxNMXGoJrdt/y/muYtwhp1IAsz7/qk4SnwITIIVHlb++CReuOYPeIt8NIldhJ1uoimdpGF1UHUqBm49yXNtT7O+bC5/bPobRR7JQFInntKQgK4YeBxJDiV28kzLm9y243GKAlGicY1YQkdKUBUTtzOJ6ujjp7ufZmdPJ+5AH8RUYnEdNeC1lr+/egGBagff++BPLAw3Uv6VCzj4tZ+g+nwobgcoJorTRHMZfHfbXylz+3muYw/CD0pMYbBhttQlhsvk57vf4tSD07jntddI+SxKvzJItlAh5YB3ult5bNtH3PbHFzBdIJNWh+lBZxoa9Jhx7vnrSxxu6yU5rMT88H9NJN/53bOsmtVAW1sfigJmuhEp0qLHagb88D//TkVRgBff24eWprHKdFFqkQQ1Br9/+X3OmD6de597HQ0dw2NYdHKApEAZUPmouZM/bvuQ77/5d8xeJ9KVQnEaVhNQQ2AMaHQn4Eev/YN2tYu+mMDQ3GhBa6u1/hvnIsJFxGIq97S8z2cf/leuP+VS9JAb3asj0g8VXTVxqgYP7P0vJgWCNCX/wcSwTmvUS1/SqicScMQodvezrf+vfNA9nz93/BcTaiQd3T56+t2YUuB2JogE+4i7D/BUy6t8+93XSdXHoVNF6VYt2q5ukgobdAdj/Oi9v9O736C7xERxYVHJU9Z9S/rBCMC/PvUsGxsmsy/ei+ITqDGJYmD1NnWA6VL40Z9foK4qwjPbdluNgYdjbwFSgcde/4DTVs7kzudesRpjjpyqTdjZ2sHv3nqfrR++jBwYoPlH92D29lF2/VASfH8ywTce+z33X3sDcY9O2efPB6eHweQ0RTFRNfj2209w5vhptJmtuNwKyYSKYSoIJJpm4nAY3LnzSaaGS3mh6108PoVEXMNIWeBa1UycziRPtr3BK21z2PrRsxBro+U7P8liIrbf80tizW0sXrGcSV+4DnSQhgQjDXIEoEiiJPnh6y+S6jeJp/Ikv0vJvzz9DJ+aPoP97d1WeY7hfpJWN/EfPfsi08pLefyjHdbnSrYOJjz2wUecM3M/P3ztBQsIj5ybBezu7uSX297hwQ/eQLokZlJaVPq0L6UmGVCT3Pr6C0gD+j0JpApKTFiNWwWYTonpknzjxac4v3EOO5JdKAFQB9KNSwWYTqvr+g9feZGz5s/AX6AS+ZGU/1UWVSKRwOPx8Mgjj3DKKadkPr/22mt58803eeaZZ0b9zsqVK5kzZw4/+MEPMp/99re/5cwzzyQajaLrhcvrH0kW1af/9jNeat2Xd7lQEYK5xRW81XUAU0qS7d0c/MpPMuCm6qsX4SoJURNXePqG72Q+r/vmBegjEo2Duouo7Lc3SIJf99CTtGf/1Dmr+ai7Ne8yvioEM9x1vHGw2VZnsruYnXs6cn4/ZLeTxGF7lg0SijQX3XmqvA7KhPEl7DjchmFKEr2d7Hp0NDtrw01f4yMzaXtP6qtDbCP3KmHGbpeGP9SG/R61ZGIQOrraSUaTeEp9ozSiLX1MiIzjsNqBSe7lcAWFGvd43uk6kJcdoyCodFXwYU97zu8Hxa066YqZWccx+mMYA4lM8rqU4JFh2uNRUu3dCLcT1TO6lcBkrYZtbfZxMs9bxdu7m239PT4QZl+BOPHoOomBlO3SuwSKijy090VtjzV5fCnbWlrzbpuoimB6XTlvtBy2tbuuOMj2WAF/O1TMYDTjIyMaQw7E0SLDAbZkdqVB06GDaG4Hmi/3JL+kOMLBgT22cVLhmsTbXQfyxqVAEBSVvLjfnmnkQoddesHGrbUJL23d/bajYFpdGdsOtNj6u3FSOW+0NeXdxlAEVJYG2UEHqc4umr93O6k2K4F3EOSkOrpoufUOkq3taGVhqr5y8Qg/DxleH3bTEuuxtXt6qIpt3U15t6lUoTDJW8NL2z7k4NfuIdXSiVYapvLLF6MVh0i1Dfb467Ts/Ez+RGOHUFF7hX3fLgnVngBNPb157RbAtNoy3m2xn5unVZXyZkeT7XGqAgEORLvzaKTtVhRkUiFZgHVbp4U41J3f3wL40ro1nDdYhPX/Uf7PsKgcDgfz5s3jiSeeyPr8iSeeYOnS3OXIlyxZMkr/8ccfZ/78+WMCN0da3mw/VHAvdEdva0ZHcTlRA94MuNGLgxhS0uQxafimlXisBb3W2/QI6UnZT+pgPQAKgRtNKOzoaStYEn57e3tBnZ1tHWiKfRj19hUANwCSguBGUxV2NXdkJlGHP0zN0SN6Gx29iSYpCt6Tnb1taDb5RQBxGS0AbkARkt5UH7rPmRPcAPjLgrRqXXkfWgAmJnv6W2ypvyaSPf2ttnlRAH3JxKjjqF5XFjNPAu1xK560SDAnuNGEwvbOwjGwvaW9oL93N3egFoiTaDw/KB0uucDN8KRzTVHY0TYUJ8me0U1dDdOKb7v3O1NKdnZ3FCx3H5PZVFzV4xr10FWEpDPZg6vEnxfcqEKhKXZwDHFymLzLqlgrBzu6uwraHY8aBfOUkNBaANyoimDn4faCrRp2tLVn1XIZKaaEPb1W2w4tHLJATXGRtYX6/duJ7dxD8/dvHwI3X84HbqyHaXMBcKMKhZ29LQVaHphs725DcbtQg74scAOgFYesn0uKUP3+rHY3IyWRNAo2JRXAoWHgxogNkOzuytJRhGBHezvxzk7Mgfx5htu72m1JIhI40NtdkEiRSJkFwY2C4KANuAFrh+WtJvuXyiMt/+tbVDfccAPnnnsu8+fPZ8mSJdx1113s27cvU9fmpptu4uDBgzz44IMAXHHFFfz4xz/mhhtu4NJLL+XFF1/k3nvv5ec///n/iv2FJhEgK8hUr4vKW87DjMXRhw1OgUAvCVL3zQtQ3I5Mkb9sGbGX9P8oEsbADiJvQmiWjhCFLRoLhXCMvM7hJiV6O9n/+IjeRo8/jH/89Qi/p+Bg++ctXUqEyNF+YIQo6enfTm0Mt2RMMtbDjKWzs6KMxe4jE7u5xIgPsOfRu0hF+6g/czNaKJKxO9lt1WBSPT6qz7kM1TVERx/TtQlREOSORcZ6hDGNSyGGqs3a6ByRcTkGEYgxddJWBnPwCsigilZkgZzm71srOc3fuc36vKSIqi9fhFacG9wMP0Zhmwq/4ytCoHldVNx0PuaolTkL5FTcfBkKXnDbN1T974gRG+DQ/Xdh9PdRdbFV/RsAAamuLg7dvhXV56Pikkut4oI57B6bv49AfMvBzfv8Ym3t/3PXVP7XaeJnnXUWt956K1//+teZPXs2zz77LI899hh1dXUANDU1ZdXEqa+v57HHHuPpp59m9uzZfOMb3+CHP/whp5122v+K/asq8jd9A+umzovUZL25qF5XFrhRhcK8SC2GNK32DTnAjQCq3OGCqw6aEFS6QwXpkRa9Pf+xBIL5FVW2x1GFYF5tJYbNW4kAKiJ+9AJ0VFURVJfY0yNTpsmchipURWRtTzmCEcafMVRfZ9dPfmT1XLI514LimoJdoiNaEbqwp0cKVMpdJYXpqP4JKDbDTSCYEaov+MY5M1RX0O5ytx+HYv/uoiCo9xfZ+1uaLKyoKlhOYH5NVQG7BbPrKwvSxIuD3oJl3BUBDaVFWXRUMxEnFe3L9LWKdrUzr7YKs7eL/Q+mm7pG+zAT8WHHEcyvLmz3vLLKgqscxbofl1pg9Vgq1HnKbVcwDGkywT/ZNk4UBNMD421X+hQU5pdUFFwNCwecuAv4Wygwscq+XETKNJk7vsqWJq4IYd0TW8apYF5pZZaOVhQicsHZWXr1l55PsNyeKi8QTA6U2wJGQ5rMLaqzL9+QZmQZ0urpl2vFSBWC+Y2TC4KbkMeJz2GfZCsFTCsvRRECMx7H6O8j2dHOwXu3Zua0WEcHB26/jVR7O0ZfX04yhSoEC8qr7JmyQjCzpLwgvAm4nAQc9nkzUsD08jLbODGkZMW4ugJnO7Lyvw5wADZv3syePXuIx+O89tprrFy5MvPd/fffz9NPP52lv2rVKl5//XXi8Ti7d+/+b1UxPtJyUePCvINWAH7dyS2zj8ar5afrSSm5fupaGoP5B6QELpu0go01c/NOkgLBKbXzuHTiqrxBqyBoDJTzmelrMPM8KAVWWfEvLVyL3+G0pXV+ZtlyplWU5g1sCVy+ciGnLJmet0aCIgQbF03jomPz0yMVIZhYXcy1Jywn3tOVBW4aTrPq64w/bTPOUDE9Lc0c/MntpEYs7WbsNiU3LF7GrEiF7YC8YtpSTqpaaOvvDRXzOL36WJt9Z0GNu4Jz6jaS73VKIHAqDi5rOBm/5sl7PkOaXNJwDNODNbYT93n1qzijbkHe4ygIjq+eyZYpK2z9Pd5fzOfmr7bdU3epGjetWUXY7cp7f00pufaopcweV2nr74vXzufM5TNt4+SYuZO5fH02HVX3h6g/c3OmeeeBR+9gbdjBnvtvG2rqet5m9EAoY7dTU7npqJUU2XRmN6Tk+mXLWFhRbWv35bMXcu6E/B2gFQTH1UzlvPqj874tKwgq3cVsqj3NtpaIpuhcUH8qId2f9/6amFwycQOLS+ts7b5s2hLOXTDHtjTDhikTufyYxbZ5StWRINdvXGkzTkDXFD5/3EqKfR5bf1+zfCnLq2ozOqmOLtrvz16d73zwV5zkr7P19/qqyVwxabV9Pps7xGemHm0L8jWh8oUZ6ylz+/KOOUNKrp21gpXV42z9femsBVwwz74UxlETxnPVcsvfejBkrdwURTIgJ75vD4fvu4Pe5mb0SITKK69Ey1F/R1UUblm+mnJv/o7yppRcP38Za2oabO2+ZMZ8Lpo1z9butXUNXLt0iW2clPt9HD1pYt7z/E/I/ycAzv9lmRGuoNFdmZO2bZpwfPl0anxhNhTPwDRHU02lhEZXNdPCFZxdtYTUsLYww//1pQIcVT6VUysXYya0nDpmQuOUysWsK5uKxwzk1EkZcEbVUqaFK5jiq8ptt4RjyqdTGwhzYkMjRnTAqpMyGLvS+ju1qIyiRIpTpowf1jeFrH8DHhcbpkzktGUzEZrIqSNVOG3FDNbOmUAg5MqpYyA5c91sGqtLaZxYjer2ZcCN7rd6G2n+MJd/6/s0NDRQWloC6Wz9EWYzubyEmVUVnD95HubIHkvpfwO6kxPqGjmhahFSqjl9KaXCxsrFLAjPwiWCuf1twvqytdR7q6n3NuTxt2RBeB4VnhKOLp/LEAU82/IJvjKmhurYVL/YogzlMDzs0FhfMYMzx83Bq5s5dRyawacb5nNU5QTqgmpOHSFSXDp1JlMixSyuL85pjxSSE6eOY1wozImLGhkiJA/GQrq7dV2I2dUVnLV6NoaSO05cAZ1j5k3mlGXTUfTcNHGpwFmrZrF6agPFXk/Wlw5/OANyoh2tbDrphCFwc+5m9GA4cwlSwvr68dQVhTlj4lRMQ+a6PCa5w8yrquSixrmQzBMnhoON46dwRt1sVEPPGQPSEHy6fgGLIlMJ6aFROlJaD8kTKpdT7a5kdrAup78FkqWRKZS7yzirdjqqSOXUmxdyMT1Yz+XTZ6GryWHfDf1b5jc5bfxUTp03DcU7OC5l1r+mLjl7ySyWTR1HpNQ76igSa1yetmYm48uLmDuxKpcbMYHl0+qpLQlz2qzp1pjLoTguFGJBXTXnT5uLNNLlDb4/LNH4xi3oxRHaDhzkwcu+gGzrz+lv04Rzxi9gaclEShz5/X1q7ULqfSXMDY/POS6lhMWRSdT5IpxRNwdDypx6Na4wi0vrOH/qHGSe+cQtNE6ZMJXTpk/DMbgqPDLATcm5s2ezrL6OSr9Fb9eDYQvkhC2Qs+/OHxJra6WhoYGT/+Vf0Aa3rUbIiro66sNhzp42c9iLbPYJa4IBllTVct702RgD/WlKfraOy6GwxBvi6IoqnC4l53GkYnLerNksqaulssSf/iZ7DjAwOWPejMKFDo+w/K/n4Pxfl9989D7vHmoDRUc4DauxByCTCjKh8NO332FlRQM/f+c9EC4UVwrFka46kFIwBlTeNNv49Yfv8Y0XniGe9KC4UmiuFCgSM6WQiurEDckPXnuR19sO0dfpRug6DncCRZWYhiAx4EAmNb749yeYXVZBa6dEqm4cziSKZiJNQSqhkYprfO0fT2MYgrcOt4LQUXQDMfjgMRTMpMLD295hTcUEHnr1JZpvuwezr2+oZ1F6Qnrro49Y+Jmb6VM1ys+7FMXptiigEhBgKtCbivPD5//BB7uaSTkkppKmD6Z1DA0UTfL13/+N+dVVdBpxTLdFNRbmkA4a/Psfn0Hogg+6eqk96zIYiKN5Q5Y56W68f93fyjfuvZ9bnnkOxeW2qPlpdvogZfX9tlZ+9fY7/Ou2p4Ym2uEpIib0J5J8983nOWTuI5bu66QpRqazespUAYVvvftHVldU0xJLIIQDh2qgChMpBUlTIWmqbN3+R5yKxnvdewEVTTER6VnSlAqGFDzR/DILi2bwx6Zn0BWL0m9KyyghJKqQ7Bs4xGOHXuCBPX/C74iTMFWShoqUVhKrQ0uBInhgz584NNBM0NWPQxdEEw4MKVCFxKMncWsGP97xS2YFpyL0NspDCn0xJ4mUiiIkHmcCjzPBvbt/jy7cvDuwC1+pIBFNdzgXoDkNdHeSP7W+zvoDjdzz0SvIMlCjCkrMyg8xdYnhNfkg2crDH7zJbU++QiIEImFRtQe7WxsuSDpSfO+ZF2g+2ENKs9JsB5/fUlh0cKFKvvabJ1kzqYHO3oGh+5YWhy9MzYZN7PrVjzKf1azfhMsVxkwfS0l3nf/LKx9y9PSJPPTka7iwbDDS3cuVlEVzPdDaya9eeJut/3gJR1TBcEgMl0WPFQZoAwqGYfL9J5/ngKOHZJ+CqeoIhwGKRJpgJlSEoXLTs49z1twqWmP9SFRUYWayaEypYErBnTv+zHif4FDsTUqdgmjKQcLUAIlTNXCrCd4+9CRPRsfxlvwFs4LQlvDRmfAgEdDeQUU4jqYovNzxJ27f9Qq1pX30DjjoHXBhmAJdNQh6Y3gcBvfu+gPv7XURC6SQTlCjAmGAVCSGxwQX3PTCXzi1aCqHk1GkH9S4de1SpLtEO+D7T/2dUr+Pf+zcn6GJZ0BAutn9E+/u4Im3t3PPs68M3bcRY25fWxc/e+kN7nr/NczWHpp/dAep9jS4ueZK9ECYyi1X0nXnPezbswfta3dRfsul6CV+EBIpBaahIKTCLS/+hdMnT+FgXxQpNFTFRKRLZpimgmEKfvDuM1S6wzx7eA9g6SjKoI7AMBUeP7idvxz4gB+//SKmVBCKRKhpoGMKpCnYm+jh/m2vcv8rbyFSQ53PhyO8BAbffuFZjF4TI2F1Cxz0DelYFwi+/NiTnD5zGs3dfRk/6cEwZWds4sBdQ3F95Te/ye2HhjUlHSFP7trFYzs+4odvvJC2RVpIE5mhrh/s7+G+d1/l/nefp/mH92J091P22cvQisLW4NQMBrq6OWrtWtyhIO5rzwaPCxIKmZ4xuoHQ4Iuv/IlN9fPYn+rGDEiUuMi8g0mHxHRIfvD23zl72gxKPbnJGP8T8v+JZpv/bDmSNPGTfv0Q77bmZ7+oQjAxXMz2zvysJUUIqvwB9vfa0/VcmsoA9g0EQeJ2aEOddvNIjS/Igd4eW7sneUvZtn0nh27dSqqtHa04Qtm1Fg0y1dlF8w9utz4vilB96Ra0YCi33YqK0V2gOZ4ELxqxhL3dVeVBDnb25F0KVRVBXV2Ej7rzs38UAWUlXvaLTttzuXWBM1iggxySKl+KmGnf+K7eG6Y51mbjb4Vqdzl7o815WTQCQbEjRHO8y/ZculAxCsSJlKAJDwOGfVNSH7Xs7eu0tbtSVLGtpSuvvwVQqQZoPWTP7nOgQJd9fhESAoqD/vhofyd6O63+ZiPKBjScNqyp66DdiqC+IsLOlvzsHwEUR3wcSvTZmqTqgv4S+0aTIJk8sY9+Iz9TUCA4tjJFb2p/ehUvW+K9SX61+XkSnSnO/8liAuVDeRHdhwe478IX8BY5OfeOxSjecbzSaZ/vYaZ0tu8uzXNnM2ZT1uqldyB/nAgB471F7G/ttKWJ11UXsaOjw3ZLP1zkoUn0Yw4McPjOuzH6+qjYciVaeOj+mT1dHPzxbSgBH2U3XoSSgwEIkpKQRrcNo1QgaPBH2NOXf65QhUKds4SPOjpt84eKVR/tHfZjSZUCtbdA8reEsMtF18BQnCS7O62WN51Dce0uKaHs8ivytodQhaC+IsT2fnuGY5HHRWv7QQ5/625SLR1opUWU33IJWiREqr2Lw9+6Z9jnl6IVBXObLSEs/HTkqR4P1nPuxnnL2TJ7sZ0HCsr/GZr4/z/Ihx3ttgl/hpQc7O22TfYypaSprxe9QIb5QAHQMiiFwI2uKBzq6y1sd08PIhS0QE1xhFRbO80/uJ3Yrj0ZcKNHItRddlVecAMQjxfq/Ju2uwC40VSFw9299t2ITcnB3p4C/oamgd6CCdspUeihZa2cFAI3mlBpjecHCWDl17TEO20pwhJJa7wLtUDic1KOLU4KgRtVqByKdhe0+0ABf0ugubu/IIMimSwAbtJSCNw4ghEaz75uKOn80dFNXQ1TcqizxzbxWQLNvX0F7U4oheNbUaQtuAHrAdCbas4JbgDi0STRjjht+3v4yYXP033YepgMgpvOA1H6O+LE+5M0x/oKlhOIxhX7hy2AiS24AQsEHC7gS8OUHOrqwY6xI4GWaD+qEChuN+WXX0rFVZuzwA2AKApQdvPlNuDGAkt24AYsfx+K2s/NhjQ52NdDIUe1RaMFGbWmUZivJAR5wY0ejlBzydXo4QgDra0cuH0rqTxkCkNKDvQVbknUkYjiKA5ZoKa0iFRLB4e/dQ+xj/Zmg5ubL8kLbsDypR24GZSPOgu1rz+y8gnA+Zji1gqwEBDoqlqQkakryj+t06opZUEwJQBdtYjLWjiUDXK+9+PMik7d1VfbgpvMwY6ASCkLPmwEoCtj8LdQbCdb63xjsanwxUkkWkE2lgWERiZqJvvixFqGVpE0RUWm99RjLb0k++wfPh9PxhYnDlUtSLnW1P+5+E72dmWBmwlnXkW4doK1cpMFcrqyfk8fg93qWMblmOKksA6AYpM1ECjzcPa9Kymq8dF5IMp9F77Avjc7MuAmXO3hwvuWEix3oyn2taCAzHaMrYxx7GpjyK0Yk7/FkN2K250zgRZAKwrmBTcwpluSmSsKia6qBbtlK+LIdMoe3PmBYc2K0+Cm+qLNuGvrGXfxVTgixaTa2zl0++2kurpyHsuhqAXLDgjS82pkBMj5+p3Z4CYSKmC3LBgqAoFb++fWqvsE4HxMOW78ZFvkLpGsrWuwHXBqOgu9EKVvWqS0IKDyaA6mFpUWoEdK1tbY09slsGZcQwYEaOEQkfOy6Zql55/N0fPn2totBEyqKMbjsA9sl0NjanV+NhZYb4GrGhts6agSWDO+EN1asLZ6vL3dwHhvGV7Nnh7pUHQm+2tGAZMsu6XJgqJptvRfCSyMTM0CXcm+OK9+9ve8dO2jDLT0ogqFhUVTMZHEWnp55bpHef1zv8sCOQKodZfjUe0pqw5Fo9FfW5BGu6psUsE307U1420nd1UorBo/zlZHAONKQ/htCqUB6JrKrHHZ7DfF4cwkndefvhnVG2Tl1HpcgaIMyNHcPtRhVFcBrJxib5OqCFZNqC9sty9MyGnvb1VozAjWF/T3JP8ChE2cBMq9/MsjNxKu9tB5IMq95/59FLhRUFlYNKUggK8P+ilyjq6fMlw0VWHBOPtSASnTZNW0etuxKwSsnlxvu8qjKoJVdfW29gig2hMk4vLY6qlCYVHxOHu7pcnq8om2disUnitUIVhRa283QHnQN5Qcn+98imBxfa21ipVuVjwIbvSgtZIlAkHO/8530SIRq8VKjtYHihCsrW0gZVNSQhWC5eX1mblLi4QovuKMLJ3iK86gqrqKUrd93owiBMur6mz9bUiTDeM+YVH9n5KLZs7NW6FVAJU+PzcvWUW515d3atMUhRsXpmmG+aifaUrfZTMW2Npz6Yz5XDd7mS09cmVVPTfOW5F3CVsAFV4/tyxeRaXPjwBSnV20P5hN12x94Od8qnYcq8fX533DkRKuXbmEi1bMt7X7/GVz2bwhP81QCFgyqZZrjl6GluetSwgoDXj57LoVVAUC+WmNisL1S5ZxVM2EvMBEAtfNXsEFDctt7T6nfgnn1x+T92EiEMwJTeD8+hPyvi0KBEWOABfVb6TcFcnYZEQTJLqiDBzq4eVrHyXW3Md5445jWrKKV657lIFD3SS6BjCiQ1s2Evj0uGM4s+YoW7s3Vq3kgvpj8saJQDAzOJ4tk9fjUHJ33BZAkdPH52evYZw/lHcyEQJuWLicDZMn5I8T4OoVS7h0Tf74FsCmpbPYfEx2nKhON/WnXEbD6VtwBoqYU1/J1ccvw6lrWU1d1fTDXABhn5sbTlxJbXEor00CwVUblnDM1El5Y0kC16xewpY5+fMKBHDe1DlcMn69rb+nB+s4qfJMdCVf7ozAq/rZNPdaLvyPo7O+OfXbcwiWD4GVYyrOYHVJ/pISAOfWb+CqAnafM2UWF8yfRrw7z1ZIbzeNkQDXHbcctyN3p3ABBN0uPnPsSsaXFOUvCijh6tWL2dg4xd7fi5Zw9Yzcle4Hz3f2xNlcMzV/x20FwfRQBZ+dvhaPmruEhwACDhefn7WWSaFiW3B6/dxlnNo4zXYV45pFS9iy3N7fZ8yextWrFiOxmhVXnXcZ1RdtyYAbRcDU8hK+cfqpTLz22pxF/gTgdzj43JKVNBaV2JYeuX7uck4fP8Oa49u7aLvjkSydtjse4ZySiVwzY5mt3aePn8H1c5flb8OBYEpRCauqCwPBIymfAJyPKVXeAOPMIFnM3sGbnIKF3ipCTheLnFUwnLE5LMO+IRmi0utnbXAcIipH60gI9ziZHipjebgOvUcZrQPoPQrLw3VMD5UR7HeNOgaAjMGqYAOVHj91Sjin3dKAuWm75xZXkuwYllBcHKHs+qvQiiMk29o5/+STmex1ZHXRHU4Vdrs1ppaXMn9SNdKZ02ykExZMqmFydQnOIkcuszFUWDijjvKQj4qKQE4dE5g6vpwij5s51eV5baoI+qgKBFheWm81xsvhbzcOpheVMzs4ntQwWv5wmmgyoTE3OIFxniqMZDDr+0GdWEqh0TediCOEV1Ri5tBJmVDhmEhQ9zHRO/S26Czxs+DW03BXBhg41MNL1z7Krtc/5OeX3MrAoW7clUEW3HoqrlJfxnCPqjLZX8OcUD0eNTX6wgCXkmJ+0Xgm+sup9oz83tJxKAlWl9VR5g4wp9iJEMOpppaOqhisqAgQdnpZVl8C6kgdCUJSX6pTGwiwZHIthmaOuicSiR5QmFFdxvwJ1eAUOSyymFSLJtcysaKYgCf7rVV1utH9IaSULJ5cS2nQx7hAECQ4/CFUh3sovk2YWlpK2OdmUWUVpAa/GH5zoEL3UB0OsrKmFjGIIUcY5k2ozCwvZ1GkGkdMzTnmREywrLiOOk85JIpyxkk8qTDVPQ2/XoRgEkZ66zM7TgROZRodTd387PPPZ13/b256g66mASt5XCkl7KhgftFEBMPLCQz99agKUwJ1LKyowto1yGG4YjInGObzl13E/p9uJdHdmaWR7O5kz4M/5o27v49mJqmrDA2N6eH3DZhYW0zY62ZBXVU2lXqYYrHPQ10kzPKqOmRus3GaKnPLK1kQqUZL5Pa3TAiWFY9jvK8Ef55xmUrCQv9EIi4fdaKcwVqlw3VMAxqUKiIuL0uC9ZipHHZLKJEBGvxFrKyoyz3HS3CmVOaVVTGvugIdJbfdJiytq6UhUkQ4XTRQdbnRh6UAmBIWj6uh2ONh6qQJGXCTNZ8CE0sjFHs8LKmpxhw1dq2/EZ+b8aEiVlTVYXR2ZOfcfPmyzHbVf5x/JZUJicuRO06EarKiuo7xoSKKA86cOqYwWVpbNabq4UdSPmFRfUwW1YP/eJ1v//kZTNIU0vROjBIXKAnrzexrx63j6799EonEcIPhkhYdNQ5aVKBIwXUblnPbX14gYRiYTkh5JVKx6NJ6r0BD4bjZk3n7UDN72ztJqZKU30Sqacpqr4JmCOqKw0xvKOeP73xASpgYHhOpS4QpUAYEIiFwqhpXrVvCfzz3nFW7xCGRWjpYk8L6i+AbR6/jC795lKYfbyXV3o4WiVh0zaDV9O7wbbeTarcSjcs3b0YLhobKswiQqrXsfMLkyWw71Mqujk7MlERNYMW9sKi5QoW6cIgFFZX87p1tGIbMpqM6QGrWcvn1q5bynaeet/aqUxbtV2KdS2rWMb923Fq++OST2SOeIbuEgOuXL+OH77xI3EharyDqsMnLEKhC4biGSeyIH2Z7dxtSMXCk6fTSFCSTKtJUqfEFWVFdxe/2v4VJCo+eRFNNTCmIJTWShoomVD47Yw0//PBPgMSlpdAVq2N2wtBIGCoguGX6Sdz60a8BiZKmhiMk0cP9vH7DI8Sahlh2nsoAi35wCs4SK36FAAWJKhSWFs+iJ7Wf/dEDpCTEDA1TWp3lnUoKXYGIo4hZ4Sk81/ocSSnpTzpImhZN3K0lcCoGqlDYWHk29+35LaaEvoSTeMoCe249iVdPIARcWHcOX3zjzxZ9PqGSSqhIBJpmoLtSKEJw5cQ1/PCFN4mmkhYlNq5YTY5ViemUqKpg/biJtOzpY1tzK6Yhra7k6TgxdauqbnnAz1FV9Tz64jt5tzsUIfjscSv53q+eGYqN9DuBMK24EsBNm9bxrw/91dLRwBgcu4bVFV0VgotPXMQDz71u9clSrc7kpGniatyqHL5iegMH1D7ePdxCIt6PQQy1yAJXakxBMQSlfh8LJrj4fct2hEfH7UyiqwZSCmIJ3aLoo/C95Uv46b5fIpB4tThOxUoYHzB0ooaDaHM/r133N5r2NhGs9nLCNxfwX198ma4DUULVXs64ZzXBch9rSk/lwT0vM2DEMCUYaQcIrLhShcLc8FTeOODhrfZDGIYEQ1g5ZcJ6aCkKBKNJ9n7lDjqbmiy25AUWIy3Z08n++7eS6mxHL4rwnXt/yp0vbbPul5ku8UDa72k69Bc3ruUbf/zb0HAcfNalP1CF4JJVC3jwnbfoi8cxhUSqZOjkImX1R1tWX0ePGuf1w4cwMMEhQZEWkkoqKKYg4vFw0pRG7n/3dQxMFKeB0Kx6EWZCRSat/MKvLF3LV//+N2vMOQ1EunaUTCqYcevk31h2FF95ypq/0SRStx7cwhCQUFCFwuVzF/CLl9+hJxZHKhJTs+Z4YQrLbhSWjqslGTN4bd9B6yVGkOkWLkzLTWGPm42zp/LAS6/bshJvOmE1X3v2qdFvAWLo71fXruHLbzw+9L0prH8VCYo1N18ydQG/evuvvHfT7SSbhxqJ6sVBjM5ODn71PpLNnfgqSyj/6nmIcADTUJCmACFRNBNVgaDDzcmV87jng5etcWlYFHqwyjugSISAp0+6groRjMb/rvx3nt+fAJyPCXCO/dH97GnvJJ8TVUVQ4w1yqKPblo4a8Xro6I3aJiMqqiAl7G+XBIRX2O51CyAU8dAWzd9ETxWC6qIge5oPc+iOu3LSNY3OTpq33gFeL+WX5e6HAqAikIVZtDikQsqu7YOAEq+X1j57uyuLLcq93QQRDrhoM6N5jwOgqBI8hQ33eQ3bvW6BoNbvpD2RvxmdKhTG+fy0JtpztmLofu8gb177i8zPS287jaIZFTmPpQmJT7dn7IDEpSqkbBhXAoFKedru0ZYn++IYUQNfZCo7evqz7E629WT1VPOkAhxutY9dJSXQ2wskfUrw9aokU/mZS4oQVDi8tHb25R1PqiKoDAdoass/LgH8QSedSXuWHBpEi9O9gx6wxkpW7yAg0dXBoYe2ogS8VNx0fs4EWUUIVo8boNfI3cE+2tLHU5v/SP+hHoLVXs68Zw2Bcg89h6P86pKn6D7QT7Day1n3rsFVXM2eqL0v40mNDw+V2V+bBMe2JLvu+CGpDqskRNkZm2h+5OHMzzWXbqGhqIbmrj7b8g0V4QCHuu3ZVh6fg24K+FtIUt5C86DE7dEYSOWPb1UIyj1+mvrzMzNVIah2BzjU3Wubh+NXHER77dmLQlovrPZ2g9upMZC0t7u4wschG7sVIago9XIomb98A4DfqTKQ6ODgNx/C6O6n+usXog/r8ZVs6+bAl+9DDXqp+uK5eXokWqteespDNJX/AlUhuHzqEj47e1VenbHIf+f5/Umhv48phTqoGqakoy9akI7a1T+AqiikjNEPNyM+gJmIowVCVtGmYZLs6bKSLAebCAoK9vxRFYXOgQF7u6WkLRoFl4vyyy/FjMdHMRrUcJiKLZtRXS7MHIlumWOZckxNBO3ADVggoCNa2O72gWhB2nJHfADNqdh29zWFLLiHKwS24MayW9CVtO/IbEiTrmRfTnATa+nhg3/9U9Znb37rCZb84BTcZf7RNtlQzYeLHbgBqxFhd6IvL7h54TP/SbxzgJn/HsIIDNmRaO1m9y0PoQY91H91E6rXRedAHE1x2d/jsbDbJbbgxrJb0NU7YPuyYJiSjp7+gmOluz+O5lJt7TbSY9KMxzH6+kh2WmX1B0FOsqvTah3S0YEmJeZAPDfAQdBvdOf0N4Dm0XGFXWiK5Mx7VhEotxJWA+UezrxnDb+65Ck8RS4cHo3eVAxV+G37liVSY6gqa4Lp81N1yWYO3rOVVEc7B++0Cs5pRRGqLtmMIxymo2+gYPmGjv7oUOXwPNIbT6C6hH2ZhzEkVgiwBTeD0hGL2tstJe0DAxQwm75Ywqo/ZTfvjGEpQRHYgptB6Riwt9uUko54f2blMp9EzTgOn5uqL547qgE0gF4cpPobF6K4nHnBjWW3sAU3YF3/gb4ue4OOsHySg/MxJViA9aEIgduhF9x7dOl6zsFvxAfY+8hd7P75bSR7OrO+S/Z0svdnt7H/l3dhDNYgGMMgklLiKsDGUoTAo1t229E1fcXF4DpyHXTtREqJq2AzRouKWNDfqlawieKgL81ojFR7d06VZFs3Rr/9aolE4lLsWWQKApfqGAUEYy09vPWZXxFr6sZVEWTpbZvwVAaIHurhxWt/y0Dz6EKEY4M3hUVKiVPNnfCaiiaJdw4QPdTD2599AKPNsmMQ3CQOd2J0RzEHrLdxl6YWpNHKMdKWC0FlicRVgLUnhMDtctgy8gAculqwuemgwzO9g8KRDMgZ2Lebg/dawGBw+T9Xw0bLbtBF/rHk8DlZ+f3j2fSTUwmVZ7NaAuUezrp3DafdtgKn34FDKexvVRlDpCgWiNdDVjXd4VJ2xqb0KpXA7ShULgPcuo5SwN9jKZdRYBEbSO/EFJgDBmnLdloC0vOJ9bM5MJCTlq2pCvGuzqF5+P9RTElB1iKiMN1aAO4c88lIUbDiZGQD6OGiR4K24AYsQFXIbiEEwQJswyMtnwCcjykbZ021vbGmlBw/u9F20CpCcPyc3DrDOyUf/vVduBJRYBDcbCXZ1U5qWKfksMfFojr75oCmlJw0pbGg3SdNtrdbFYKTGhux2+VUhGBhTRXhPNtXgxJ0O1kyrqZgN9oTpzWO6doK2b1x4pSCds8vriaYEhz+t/tp+uY9pNq7snRS7V00f+sndH771xDNX4/GkJJjKmfbTjYmknVlc7JYNvHW3ixwM+d7n+KUNRtZ+oNTs0FOy1ClXYFgoncCIT33ZDUobtXDjMAMW+q6icmqkvk5mTjuUh/Lf7TRsqOpkx03P0D/tv0ZcOMoD1P/rXPRiwOoQuHE8VNs7VEQzKoqp8xvT0f1OnVWTK23BSaGKTlmkX2cSCnZsKixIG352HmNtkwkIWBGeSkVActuPRTOAjkH7voRyc52HEXFnHHbN3GW5M8/MKTJsuL8zV0BdJ+DNY0bchaE9Jd5cPodKCgsL5lnbzeCaeFSqrz2S/xuTWfdxPGY3V00P/Jw1nfNjzxMsqsTwzQ5YU5jfnYUFuA4flZhfx8/dXJeVipY/m6MFFMTKBDfms7R4yYUpIlvnGgflxI4aXIjhpRWdeU77qHph7en+zal7RaCFZEwB+++jUP33ZUT5AhgQkkRteGgLeRwaipHT5lYIL5NNjY2FgT6G+unFqSJH1s9xbYWkADqvUXU+yL2dqsqx9baP1MMabJx3LQCVh9Z+QTgfEw5d9EcvM7cb7kCmFpeytXrljC5vDgvFdHvcnLlukWcMn/0zdf9IerP2owjFKG3rZmDv7iD6IHdGXCjhyLUnTPUKfna9cu4dk2aQplnLjl19jSuXroYnyO/3VNKSrh+6VKmlpTkDWyfw8E1i5dw5vTpeTQs+cyy5XxmZX6aIcD1K5Zx/apltoPolBlTuWr5YgJ5Vs0EMLmkmGuXL2VGWVneY3kcDq5etIRNU2blP5mEzy5cwWUN8zB6+km1dND0zXszICfV3kXTN+8l0dyOsz9prVTk8fdJNTO5dOJaAnp+kNfgK+WS8UfTGKjJfKa6HeghD66KILO+eybh8mLOqz+a02Yfy5IfnIKnMoAj7EbzZL/NnVt/AmfWnJr/2oDTqjdySvUptjqLihZxRs3xBHRvzu+9ZX7OuPtS6hvqSRzuZNfn788CN44S6yHkUnU2T1nFeVPn5D2XRPLZhSu5Ya19nFy9agmbj1li+/DeMHsSl5+wmJA/t78FUFcW5sqNS5k5viLvkZy6xiUnLGbTqtn5DZJw9UnLuXHNiszPuVY7rv/2v/LFdadaIDdHnAjgmOrJbKo7lqAeGMo+zTqXoNxZyokVp1DvaSTXWpbVgsPBseWnclLVmtwmS8vf59Vv5Auzc+sMytUzlnFmQy37774tk3NTdfnVaEURUh3tHLpnK4vDATavXUKxL3eNFwHUFAW5+qglLKivzutvXVXZvGYxFy6cm9ceKeHG1Sv4/NIVtnZvmb+I6+cvtS2Fsa62gevnL6MsTwkPAdT6g9ywcClLq2uR8ThGbx+p9naafjQM5PT08MRXvkayox2jvw8ZH/2yI4HPrlnBjetX2C6yX758IVetXGxr98oJ47hm8RIq/P68dlf5A1w3fykrKsfl9bemqFwzczmXTspPuZfAjTPWc+P0dbZ2XzppGdfNWJG/hAewsqKeucVVNkc58vIJwPmY4lRUfH2q1RgQsjLaRQKK4jqaolDcr6MM7mQM4yKKJAS7FZyqRmnSid4rR3EaHb4QMzZsoaa2jpaDB9j70I+GwM2mK9H9ITAlzk5JRDrxCweeTkEudqDWByVJJw5Fw9+v57U7HHOgKypBnIximgKY4DY0HIpKyG2zN6sIfA4HQa8TUx/eb3roj6mbBLwO3E4d6RaZuT1LR5P4Aw4cmoruVjNz+3D6tynA7dPQFQW/7hja8x5utwSnUHGqGkXCjYhn+2fw2vSYgld1UF9eT8X1l2cok03fvJfYh3stsNPSQVlNDT/9wx/AWZapajz89iUHNFyJILrQiMd8GIYyMgRIplRkIogmVBQZIJXWUb1OZnz7NGZ/7ywcxUEShhtd6LgUH3pJgMU/OJWF/34SmteZOWbK1HAqLtyqF0OKURRZKcGQArfiwak4R1Qqlll//ZoXh9AIahZDa6QzFUxqa8Lc/8D9Wfe8+vqTcKTZXYowCbtTuFSVcMABupHD4RLVY+Jz6QR8LkxHriiRGLrE53PidukIlxhlkcTKz/AHnOiaitM5tG0yIgRwu3VUVRBwufLGiUOoOHWNsMOFSIwel0iJHge/7iCkOHH0Wr+X7Ooctdpx/9e+SteBVrQ2Dxgi+3wSZJ9KqC+IQGd3czX9iaHO5IOn64052NdagyI0dnaPpyXqHaUzYOi82VaHKT2kEhE6ou5RZptS0NwbQJF+fJoLUkOgKytWUoJUaw8XnHoKyUFwc8lmXHXjqLrkSrQiq8P1f37tS7Q0NaH7tUzOR9ZwUsAR0FFVBV/QlclZynK3ANWT9rfbNSISh0QoAp/LQVB3oQyze7iySEFYc+FWdJwxdWjPdvgBExCWHnRFwTfgHMr/Gn7CFPjiTjRFpch0o3lCVFx1JVokkgE58Z172Pf929i3Zw8llVVUX7jZypUcEUtqyooTv9OZhUtHXmfQ7cTl0FBcYpjOsHlQkfj9ThyaitOrZLZ1h8+DUpG4fAq6qhLx6qDkqAUiJG6XxKNrFDmd6e3K0eNSV02CDgcBhxNdNcnlcEWYFDmduDUNZ6bkwMibYhJ2O21X+f4n5BMW1cdkUd352D+467F/WEuYerrrMRbNdLBFzZZjlnD3Iy8AVmfsQaqpmhiio55z7Dx+8btXMaXEVCHlJkMT1wZAUwS14TgP335z5twTT7oKb1U9wgA9au1Nl4R9jJ9Sxt/f3U3KlBiutE3S6pCsmNb2y6YT53Hfc69hSBOpWTRcpHU+JT0Bbzl2Cd9/4UUApJCZ7rfCBEwr6ffChXO5593XrC2hHJGkKoKVdePY1tFKU1+vFeuDzzhBhgZa6vEyu7SCv+3ehWFKS8ccpqNYfr18zgLufvVVK19J5qCjAtcvWcqtz6ftRuagoypcMG8OD7xuUTGlkBmKOeYwOmpdLdv7OjjU20Oys++XjLkAAQAASURBVJOmH99Oqq0jc21aJMLUz13P4rnTeGLvDgxpojoMFNXqJm4kVKRpbUxtnj+fuz98ERMTTTXRVAOJIJVSMdJZkzfOWsbdu/4KWMBAS+dIGKbAkAoKCufUL+YvLX9L54WkqeSQbhYsUFCYE5pIVO6nNd4GZJdQT8NqApqPOaHxvN71WibHZPD2CcgUv9tQdhJ/PPQnKy4RGbqxKkxUIelv7uPvVz9Dy77DmXM4y0NM/vdNeMp8aIqJKgQnV65g61vvkZIm0gRS6VogigRNoiqCRSW1HNoTY393t1UGYHgMpO9P2OVidWgcj7/7kUVtNtM5GYKs7sxXLlvIfX96GTn84Za5uLTOcUu4+9EXhr4eGSeK4PS1s/nNM2+RTJlWyYJ0vA7SzVUhmD2pkiYjyr7WLmK9nez6zdDqas3Rmzjwl4dJdLcTLC+n6P/H3n/Gx3Fcad/wv7p78gwwyDkyJzDnTFFUzjlniUHRktdp12HtXXvvtddJEpUtWbZsy5ZztpUlK1GRlChRYiYBIs4AmMHE7no+9GCAIWa64Vuy93neV8c/WMT0QfWZ6lNVV1ed65wrr0UUF4PHAEemzP2QisiA2k3r53PHzueRSHyuJAF3HBAMxNwMJc0d10/OXc7de/4CgFdLUuaOogjJYNJFX8KLKhTOaVzET/a+TtIwq9v7nElUxSClq0STTgQKc0rrOdIDu/t7zXEyOgbKMDvKlzIIffMherq7qdm4Ca24JNs/6YEQ7XdtRfX7+cIdd/Pg6++Yz20UTdxQyBIjbly1lO88+0LmAiMpJRTz2amK4Lx5bTy6YwdJXc87nyiKoK2miqie5P2eTB3A4ecuM+1ivlQdP3Eiv3xnp+lzmnmfYQAkMi8j1y9ewh3Pv2SapI6ky1DSwqSBAzcuX8LtT79ouoYiSUZCHL5nK+m+keKXJdU1VF+8EcMXMJf0UTYJw/STGTWVJKTOrs6e/AHHAnxOB8fNmczPd7xtHucN+ze5c9yWNYv59hum76IPPy/MZ5jp75sXLuWO958y/9Ywq6gjMSuiKxJNEZzTPIc/db1GXE+Zc0jmpUgIMqkqBFOLazAkvNd/xFznRu0uKsKkf3tUB+sr5/DYvjdJZ+bm4Rc+kaGIA/z62KuZXlKd58uPXz6midvIR0oT/9f7OBIqXHFaVUzKam9vxPL8udjtYmggUTB2JDEU5u0nt5KIjgwql7+Maes34fKNnOtLIO23rlirCIGzykl/vHDciKoISqt8HIlFrWmGficDMmkTGChto/nN+dXe7mLVRTheOKhXFYIqb4CuwYgNPdJJJJW0jMNBSIxRp3jxvfvo+Nbt2d9rbr4eV0sTeLEsSKkKQWmJSig1VFBHEYKWEhehdL9lUGuZW0Eo+ZlNw6IJnaDLnibu19KW7SgoOEQRA+n81bSjnRH+svn3RA4P4q4JMuXTJ/De136fjRlq+8Z5uCrN8WUkiujoVy2fL0mB6LUO2keCt8c6EFVVBBW6m/BAYcadIgRVXi99fUPoFgwpj8tBLJWyZMAYCqQDguRgmD2P3ZGtiTVcxTw5GDJrYfUPH/FsyRu0rwpBUZNCrwXjTkHQVOYkrFv7iVM4GUrplv1tpAXxQevYOCSoR9KkY/G8NqfDYTS3mypfGb2RwmkXFCGo8PvoGbJmrjkdKnFpzZKTjCziVnY7FOu0E6oiKHN66bGxu9LjozeSa3fswF4O3vfd7O+t196Mo6bRziTbMxOJRPVZsztVRSFY6aQrXthPBIKaMhd9xqCln3g0AZp1PTuZg/4L6+gpNymj8LNThcKlkxbyuTnHWrZlJx9XE/8nSt9g4UULzIDHyFDClo46FEsWZBiMBjcufxnTN1yPy19GItLLzr9uJRENjSjnP+LPEUURRJPWlD7dkAwkk7ZMo0gqactWGC+CtpyMYzGMcD+R5NgcGelwGCNmBvbpUjKYSNjaHU0mbaP+R4dBpENhuh8+qlTFwz8y723zDYUQRNLWk4ghJZF03JaxE9cTtlWilXHQTMyXS3u7YwUqYEe7ollw460N0vaNcymaUUfbN87DXVNMvKOft279CYluE/xHUilbu7NvoZY69kUNBYJoLGntT3J4XFr391AiZRn0CmRnUdXpQsvUxBoGNwDOQAkt52xGKzVrB4kCKRWG/cTSbsbnJzHdvr/HUygWCbjchYteBoOoHg+DCfv+HkwkbGniibRuzyIahwjs004gGZfdkaPsTvWHOPJY7hHkwZ8+jDEQ/r+2d1gUISzBDQBSMpCytlsiGUzFrV/ggJRMjyuFh50oCEtwM2xTTzz/y9I/Sj4GOB9SyovzB2AOi6oIAj6XLR3V73XlBUE54MZn7tgEKlrMnZvRIGcobP6BpGBtnWExDIm/QGD0aLuLXS7bySbgyG/3aBlveu5CeiZ74V4Ofud2XEPRnGvpcIj2rXfScd+9GLEYqhAUu+3t9rtctovbME5Ih8JmUGEmm3PNzddnz+GPfGcrRqjfsh1DSgIOl+U0ogpBQPPYLkoe1W27uBnjqnCOJYPKbEfi1Tx5A3odmZws/roAx915Bd6qIACuyqIsyHEEvage08+KnA5bu8V4aOKZoww7u/1e6/5WhKDI57Zty+t2oOfJTZV7Q/M/qstDy+nX0nrWliy4GRanr4TGTTdQc+W1qAUYhVJKijS3rd3j8ROv5rTNzyTGw7cWZq08Oyly2/d3sduFYtOWxzGO9A3jEAk41HHY7RqHn7hd2ZfPVH8op8J3w9U3ZBlz+x68g1SBml3jFUNKnOOozF7scFkG2itCUOT02Ma8OBXN9gUNQI/GSfUM5L2W6hkgFY3hsqnMLhBUecbm7fpHyscA50PKmctm2VbAPuuY2daZhYXgjGNn5wUmqubC4fbj9pVx9S1fo7HB3AZ1+UqyIMfh9qNmql7XlBexdvZEy4lbCDhvcZul8+uG5MJ5s20rnF/Y1obVGqEKwbEtE6gPFC5+KYCaQIDjJ+SndQ4nUEv39tJ+553oYXMSMcGNCTz0SMTUk5IL57TZ2n3B7DbLN3NVCNa1TKBK13PBzQ2bcLc0U3PDcLBhHwPfvB9pA3Iumjjf8rouJec0LbQEAQqCU2qXWi5uZgzOTKrdlZYTYLGjmIWli2xAjmRd5Rry7a05/U7Wfet4jt16EhfOOz7HbldlEW3/cz4zv3o2mt+FguC8CfMs6aiqEKxobGZCaanlglPm9XDi7CnWFeWl5JyVbRatmAvJWeusx6WiCM5Y04bDUdhuRREsntLAhOoyhDBBjjMQHKNX4vNw1tIlOL2Fq0kbUnLRlLm2OwrnNS+y9hMhOKdxHi6lcG4aBcGSqkamlhRmSQIE3W7OmD7Nhv4ruXB+m63dFy6YbflSoQrBubNnWuboUoRgTlkpLZqa13OHd3OL3C7OnDHD1u6L5s+2tfuC+aafpPrDOeCm/srNeBpbaLpqCyXVNaRCvRx86E5SeXZyFCGY31jLzJpKy/Ui4HJx1kx7uy+ZMddyB9aQkosmzLP0E1UIzmich7dArisw/WS6s4yur/yUvZ97iGR37jyX7O5nz+ce4tCXf8TJFZNsaeJnNluPy49aPgY4H1LOXdVGhcUuztKpjVy8YQELpxc+n60q9XPRiQu49LRFY65pTg/TVl7NnA03cNvGM7j1sgytU0oT5By7mSlrr0FzmEymT1yyhs2nLTMX7wL+f8VxC7lizQKqiwrnHFk6sZErl85nRYuF3X4f1yxewOaFi/MrSPO8+NZlK/jCqnUFh6MEPr9yDZ9YtjzvIqgFTfZCaW0tve3tdN51N/F9e7PgRisro3bTJrRgkKUNDVy9cAGrW5oL2l3h83Ht4gVcv9TCbqFw26oVfGbdBtSAPwtutJLgiE03bKK6oYEJ9fW4vN6C/X3tzIVcPXUx9b5gQZ3F5Y1cMXE5KyumFLSp1Onn0tZVXNx8XH4VaU6kV084mcuazzd5FXKsDsBlTedzau0ZaMJRML5kfeVxnFhzHBWuyrzXnX4nc1rncEbdMawoz01x4KoIoPlN0B10+rm4ZQ03zypM7VWE4FNz1vH5tYVoy6aR/7Z2LVvWL8VpsQhevHwul65fQENlsKBOW2sNF2+Yz5r5EwvqBP0eLjtxIRvPKEyjVYTgpvNW86kz14yl/IyYzSdPX82NK5aYi3eB/r5k7hyumbGYCf6y/DoS5pTUcuXkpRxbPbOgTrHm5cpJq7h5+jH5b5Txk0/OOo7PL15nAuECdv/bonXcsHQpHkfhxHIXzW7jqsULmFBeWlBnVm0VVy6ez0kzJhfUKfK42LhsEbetXpExYaxRRjzGB1tv591v/g+p/nDO1dG7uTfPn8eWpUvwWiR8PK9tFlctms+k8rKCOjOqKrlqyXxOnTUVxeVC9fmz4Ga4wndpVTWPP/EElXX1qD4/inPsEaQQ8C/HruIzx63Je5/hb/qp9SvZvHQx3gIpPADOmTWDq2cvYEppeUGd6WUVXD1jMWc0zSqo49dcbJq2gk9MH65Mn8ehBFxZtwTPkE7ySIi9//r9LMhJdvez91+/T+pICO+Qwfm1M/FrhWPozmxuY3Jx/rnkHyUfA5wPKZGhJLGeuEm3Hr1SSImagr6OCPFkitCBMOow1XSUjpKSJDqHiEYTdO7pRYsZHJ0X3KG4ccU8hHuidB4I4RhIZ1kKLm8QzelBGODoT9N1MEyoN4rSl0boRzmsIXEMSTr3hYgOJYl3J0YKGmZtMtldfYcHiSdTdB+JoObREWkY6ksQiSc52NOfS9kcpZce0umJRDk8MDBSufwoHQw4NDBIdzRKIp3Oq+MIlnDKV75MU3ML8Z5u2m+/PRfcFJeg6NDVFyGWStHdMThS1HNUO0oK4r0JIrEE7fv7cQwyJvWvSIPo1ekJRYlEoeGca6jdPAJuwGSAeI0Sbv3GVv7nge+jDHoQR4c1GWaF9/YDA0QTKfqOGJBUjnYBiKl0dCSJpVO835UkEXeM0UmlVNp7FfoTCXb2RgkPedCPillJ6QodAx7ao0PsHojSHikidVRe+7RUOBINsGsgSndiiD2DHuJ6LljQpaAv7mV7aIghPcmBqCSha2NsiqUd7IkkSOhJOmJhQIz9bhIGUwkGUzEOxXtRtWEK3egOl0g1SXdigINDYdJuHXnU8YkUkJIR3tj7Hj3xGBGXWfwy+90HwqQTMXQ37ImFiSaTdIs4hmOMC2A4oT0dJZ5Kczg6iMyjIxUIk2QgnuBwV7+5y5HPv9MGXaEInR0DaAMy/5gblBw5FCbcF0Pbk0Y9OqxJB3cv9OwME4uniG9Po/Uf9YJigCOkEtmeIp5MsW+Hjt7tZvQLupSgRxyE3nHTH0my50CMVLcbqef6iZFUiB520947REc4ghwSY9NfSxAxwcGeAXpjQ0RFcuwzQYIG+6NhoukEXe4IhkvmABOJxHBLOhyDxNJp9ip9GH5jTFuG0yBUFCOUjrMv3YfuT4+Ja5UqxJ0Runq6OHzgAIe3jhwJZXdz+3rRo4N80NtBX2wob/kAiQk4Dg6EGUqm6BscMo+jj57jpBljGU+lONTbj+byUHfJtdRfuSULbpAQiyfxl5VzxX/9D/UXX4vi9oy5XxrJkcFB2iODpBwyb5ojwwEHogP0JWIMaokxmb0lZqHPffEQsXSKkBxEqEdPqhKhGvTJQWLpJJ3JnqPo3aYowkBXYvSnhuiI96IpY+NnBBJVSaGUe/jqo/firA6SyoCcoZ0Hs+DGWR1k0/e+iqeyhJjMF2soUQS0D4VsY4I+avmYRfUhWVTffOQpHv3L6+iG6bTZqsX6yPg8f/Vsfvmr14DMBJtZTxTdHESKIjhhzQz++Lu3sjpSM/PBCF2a1G5FMH1aHXsPdBOJJkZ0lAwtM23Sgf1+F/XTqtixqyNLOZcZeqQyas44/uRZ/Oald7J2Dy8Wo3XO2TCHh7e9MWJTRkdkqIuqEJwyfxqP7nonoyNHILM0qZiKEMyuqeaDaC/9iUTebVWBIOB0Mq2sgm3t7ZZBpCt1wfc/+Yns73Ubr8fT1JKlhwJcOmcOj/xtlN3aqGcizRiOU9qm8euXRuw2HJhU9LRJk1eEYEZDFQf6woSH4pnJJdMHBtlK8T6Xk6kTq3jlwCGzv7UM1dQAJSmyNp25bAY/fXeHeXSmSNAyK0pKyUYzXzavjYf2bMsYK9E0HQHouoJhKCbdunU6f+h8LdOLEpemI4QkrSukDdXcUi6upl/2EEpGTR01jaYY6IaSATMCj+pkQXk1b4Q+wEDiUNI4Fd2sgq47GCaXn1a3iD8deREDicIIdT1lqFmdk2pW8+iBF0Ye/FFPVxUK6yrn8qP33zOfh8wEuEozDkQo5lb41OIqDran6IkNZYGvuRqBkYjR+Z37kZEop33hP9g+GDP7Uod0KMTh792J4vdTe8W1qG4PF06dxc9f2mH6kjGSssHIpBwAuHjRbB59/M2M2dJ8aZCZ8aIIVEVw3LzJ/PXZd8mXBWGYTj+hrpxwf4zecDTrbyPj0tRzOTVmtzXw0s796IZEd5hAC2mmgRhe70/bMIufvbIj60uG1+xvNapkacvnr57N99/M2K1IFF/KJBfEVGRKRVUEx0+bzG/2vpcZSxLFrYMikWkFmVQRwMTSUgbSCTqjkZGxm5kr0E3/dqkqSxsbeebAPrO/Rz2T0ZT7C9va+NHOt8x4DoMs2JfD4wq4ZOYcHnrvtcyDMMcHYFbe1jKZdZsn8/t9u7JpJ0RKZJ6JqSME1Cbhtc//N4nuHrTyUsouvoDeh39EurcPrbyUqps34S0rY3V1C0/v2Wvane/hARfPmM2PX32r8PMFLpw/mx+9/GYB7zbtXj9tIn/Z9YF55JlvI0RAU2mQuGqYL3vDgOqovnQoCiunN/H4/t3Z/s6mwhiurA5cMn8WP/zgtex4yuZWUk1KtgAumzabnx0yKfBSgjFc3VsxAYcqFNZWT+aF3rfNdCGZcWkCQJn173pPKbpU2HNgH+9/+mGSR8LZ7+WsDjLpa5fgrQyyKDiLxzt2Zds6+vsD/GDVpSyqaBrbQX+HfEwTt5GPEuAcf8Nd9A1Y038rFRcDfdbF0XyaRjKasmQZSLCnGQpIBWzqNSkCqpwMWTCpFCHw13joSVgX0XP5HQypaesic4pEWsc059/eP0qMcJiOO7aS7O3JfuYoLcup3KwIqFC9hAat7fYqGsm4bqkzrv4GdOvqAqiKQCtXGbSoSq0IQVmZg149ammT3y2QWsKalq4YeJx2BfskPqd11WZVKBQ5NKJ64fo6AoFHCdKbGLK0KZ3y0B+zDmg0Ugqp/vxb3OlQmM6v30W6py+bcC5byDJTBFIrLaP+mi24SkoIxp0MWpTPEAIqVS8D/THLOByXVJBx3bpQohxZhCxUMDzWaRBURcFR6bBM3yCAokovfamY5ZhTnYKkahc+Km3p1hIQhU+7ATNnlM/rIJwsnJpAAKU+NyEbuzVhFtq0tNsAvXOAzm8dlZcqA260kqAJHBOK5XPTFIVi6SI8ZGO328NALG4br2XkfX0bESnISTuRVweJDEjLOUATCkVl1mknAGqKHQzJqGUcjkORqKr1XGHiLHMijLxziPc/+VD22qT/vgz/9HpzRzfhtimRo3Bey1y+OPdEy/vZycc08X+iRGP29N9EMm1LbU0mddtCdOOScTShCEHCpiKzISWxtL3dCT39T8lOmQ6FaL/jTpK9PThKy6i/9gYcmUyqh++/k1Qm8NiQEE+Nw+6UPm52l6WMowmBIK5bTyKGlMT0cfiJkf5I7B5PCwJIGjYVgpHE9ZQtEyOp2/e3FelHKwlSdetGtPJSs6L1fXcS2783B9zUXb0ZrTiIQJCwqcgsJcSTaVsGYCqt2zJ/xivjeZNM2FTAlkA8nbJlGqUMw56WP06xt1va+reEcfl3Wkp7/5amP5RddkHOx2WXXZA9RhZgDUoBKSVxOz/BfCZ2duvGOOwehyhC2BelzYw5O0noKdsjIQNj3DTxZPcA+7/xq5zP9n/jVyS7B1AYh91SMpiyXi8/avkY4HxIqasMWtN/FUFZqR9VtWY1lZR4bemomjaOx2WYlW2tRNcNyvweSzq5qggq/T5rNhZQ5vXa0q21cU60heiR6XCYjju3kurtxV1eTv1Vm/E0tZg7N6NBTn8YVQgqiuztLg14bfNkaOMBnLKw3cOiGwYVHp/lRKIKQaXbb8lCEECp02dL/7Wjf4M5cTssWDZgsjWCzoAlG0tFodwVsFxMh9+C7ezWNOv+1kqDVH1iI45MHaTDd383B9wM7+Lp0qA84LNccFRFUF5s7ScAwYDHdlyOF0e4bSpuG1JS7rO3u8Lns02DUDKO/h7vi4nXpnK1AaZ/W9mdSZhnBwKCTrcteBPC3NHrfSg3L1XvQz/K1oeSgNciMHpYp8Jvb3e533rsAhS5nfZ2jwPhGlLid1hv80iwnStUISh3BWzfZHyq2z6PFya4GT6eclYHmfTfl+GsDpI8Eub9Tz9MvLsfv2azPSWg0V9irfMRy8cA50PK2cfMtryuG5KLz1hkppUvIFLCuWctxOEoPAGqqmDDMTNoaS4vuNOjKIIJzRWcsHq65cTtdGpcumGB5RuObkiuXrPQ9g33ykXzcVkwWlQhOH3aNKaVVxScSBQhmFhWxlnT81dmV1wuVL8fR1kZ//HAQ2iZhSxbubm0zGQvuFzoUnL1igW2dl+2ci5uq/5WzArv0+sK0zoVIWipKOGsOda0Tk1VuGbeAsuJRJeSjTMX206Sl09eYknrVIXCcbWzmF5cX3BSVhA0eMs5qWaxJRhShcI5DessN951DC5qXmeT40Zw6YRl+LXCOUdUoXBi01TmVtYU7m8Erc1NXP5vX8j5vOqcC7PgZritK1fPt3yj1A3JlRus/VsIuPDYefg9zsJ2K4J1CybRNqm24LgUQlBbXsSZq9osd2kVAVesXWBr97XLF9qmQbh83lzLHC+qEGyYMJFFtfUFfVcAdYEAF82abQu8N85daG23lGxqs/ZvRQgunz6foKtwLiBVCJZ4g4S/e695XFleStWtW8ydvZ4+Or+1FT0Uptrv5+I5s20B1TVLbfpbSq5Zbv3dFCG4ZNFcSrweS7vXTGpheVOjZX9X+vxcOmuupd1SSq6bscSyL3UpuWrScssdHAXB+c1LKHH6LMflLKOcg5/78Qi4+dol+KfXM+lrl2RBzt7P/pBTfM22dp/dNKfg9X+EfAxwPqScumomTbVj6ZHDbnXCsmmcuHYmx6ycmvP5aGlpKueME+dx3TVr8upIwO12ctXlq/jEDccV1AG45YYNXHPecjxux9g92szvWy5aydmr2phQk0tH1RMxkoPmUc/xC6Zw2sIZnDLbtDvVH0aPj4rFkNBaUcpFS2bzmbWrco0YpeNxOPjEquV8ed0xBZkoSPjK2mO4eekyfA7nGB3F7aH62mv46sMPc/2JxzGlvDyr4wiWUHf1FmovM4NLT5w6mTPnzuT02dML2tRSVsJFS+byqZNX5/TL6H5yaxo3Hr+cfzt9XcbuPH0p4YtnHMMNq5eab11j7mV+cOuaFVw0czYzSisKfv8TWyZz9uRZnNsyu6DdDXg4xlvNp2cebwZejtJJ9QyQjsRxCo1bpq/nX6adytGsplFm8+npp3NZywa8qqcglfyKlhM5qWYZrd7G/O1IWFzaxnHVCzildnGhrqTWXcZ5jSv4bNuGglDJqajcOvMYvrzi2MwkObYDJJKbJszkL9/5Zs6Vzp8+QiocygKxm1Yt5ZyFbcxsqBpzn+FW18xo5bSF0zl7VVvO56P1asuKuPCYeXziorV5Q8Qk4NBUrj93JZ+8dF2mUnj+jvrUFcdw1YmLzMK0BTr8upOWcPaSWcyurcrvSxJWT2rmjLkzuGTO7Jy/HW1UnS/AFYvm86U1mdQMeQx3KCqfWbmKL65ZZ/Z3gQnly2vWs2X+4kxBXXmUivn7DQuXcP7UNubXVOe5mam5prGJc6fM4uqZc3NvMEqnzu/j2lkL+fLS9ZmrY3VE/wAvfO6rRDu70MrLqLp5I+7WZjP2JgNyjnxrKzdPnsHGRYso9XoK2r15ySLOmTOT+Y21eWw2ZVlrI2fPmcFlS+fltQigssjPlcsW8IUT1mX8ZOz9NFXh08eu4t+OWYOiiLw6AP++YR3XzV1IuWdsvqSs3fMXc96k2SyqbChsd3UTZ7fO4fKJy7N/fbSUuwNcMXEFn55xWsFxqQqFm+eexoTaRlzVJUz86iXZQrrOiiLz9+ogzbX1XDtnLRWufAGJZutXT15KnS9Y0OZ/hHwMcD6kHOgKs783hMwXiKfBi+/tpzcc5ZWdB5FHbcFLzMj4vV0hDh0J8/RL74NTydlWlAAKDKaSvLXzMM+/9EF2J0CO1sFM4/63l3fz1s7DRCKZs86jJkAFeOrF9znU1c/Bg70Iw5yA9USMD35/D+//5k70/hCvbt9PdzjCKzsOYPSG2P/DOzj4k3tMkCNNttWhQyH2d4f5y5vv44iTSzWVJoMkHkry6r7DPLVzD2JQZuj0I2pCByUiefLdPbx2oJ2hvsQYHQxw4eXVzkEO9oQ5sK8XJTGi4ygOoro8aHF49e2DdPdH2LZtH87oUTYZJmPlyPth9neGePbpXXhC0qTKZ+2WqDGQBxK8+fYhXnhxD+523aT2jupLNQ6eIzrPP/8B23e1k94dR4vmog4lBd4eeO7p9znU28/h7SEcA7k2CR1cYcFbrxyiezDK3149hNbnGKngnrGbziQvf/ZbrFuzlkcf30a624tMmsM31dPP/n99kINfeoTe93Re3H+YP32wn+52P8lYLuU8Gdfo6wjw+/f2s62zg7cPuokMuXLBUlqlu7eIn75zgEPRMM8ejNF/FC1dNwThqI8/7e2lOx7hz4f2E0u6crIoSwmJtMbOvhi7B7v5c/u7Bd8UY3qKl7r38UT7B6QdqczMNMooBVKRXq4582z27d2LVl5K7Zbr0YaPq+67k/RACMNn8PvD73F4YIAdiW50D7mUXAG6F14MHaY7MsST+/eie8mplSYBwwX70gPs7urliTc+QDryjF0BUSPNtvcO8eIrexCDqTHpIoQO2pDB88+/z66dHaTeCeMYzE0FoaQkvu40L/9hJ11dA3Q/dQRvt4FIj2onDb5OnX1/3k9PX4TX/rwbf/tRvmtI3H2S6Kv97DnQw1MvfYC3W6CMjiWXmaK7B9O8vPMgT32wl/SQHJvCwQCRUPjru7t5s6+DHmUQ6cilgKOA8Bj8sfM9jsT7aXfuxlOUQCgjDi4UA29xnD3Ke/TEB3nfeJnqin4c2oiDC2EQLBrCVbab/UPtvBrdRk1lGFdOoLzE601Q3jCAp9RHRUMtTV++FFdNAJBmjNbNm9AqStFKvGxLHWRH3xG6nP0YLmOM3QR0/tT9Hh2RCG8NdmK4coGJFBLDBa+F2zkSifD4/j0mUeKoudlQ4XBikPe6u/njB7vy6Jh1+IaUNM/tP8BTB/aSUNNmgdGciRCkU/Knve/zdm8nXelB9MQQqVAoR0c4JH8+tItX39/JW+27UZSjobdEUSTbQ4foHBrg6c538yRiNf+mO97PuwNHePLI2wXHZdJI806qk033fpXWr12Ms6IoZ65wVhQx6WuXcvz/fIJ2YnTFB7LtjxZFwJNHdtlmM/+o5WMW1YdkUf379/7E7154Jz89MOM1J86ZwuNPv2v+MtzdkizPVFUEK+a28vzz7xfUEQKaGspobw+TTKZz9SDLw3M6VSqbStl/uHcM9XG0Ey9dNZHn3tpr0sSB5FCY935/J8nBXlyBMqYcv4kTT1jKL55/kb0/MwsFOorLaD1nCw6/GXekKoIVM1v465492XblMOXRGGE/tlSUcig6QDwTQCmFzEQBkq3q61RVmktLeL+7J2O3HKGsyhEK+HEtE3jqnT1Zu7MQfdT9Tp4+hT+/8F62C7P09gx1X1UEK6Y188KLu7N2G6pp+zB1XwD11SX09EaIJ8xVxFDMtoQOw3O4Q1Opm1DKB4d7kTJDuc9UbxejKPcrlk/iyXd3Z+w2Kedkdcxvd9ziKfz6vWG7JWgZQ9KCdLifw/ffQaovk1H5+k1oJSWkB/ro+I7JJtHKyqi9YTOtTc106oPZHCBCMVBVA8NQMDJVqx2KwuSaEnb2dWEgEcJA0wykIUjrI2W5T544kcc73s1sh0scqrkwpXSTsyqAUxqn84eO7cMekK2FZWScQRUKS8tbeerIiJ/kk3pvkM5wmsgw22x4nhSQDvXT+Z/3kO7qw1tVSdmN16KUFJPuC2fZNFp5KVW3mCyak+qm8Nf3dmcpwsOVq4eptgI4dcIU/vDqe9l75VSmF6afLG9u5JWX9o8YedSYE0B1aYD0wSGiGdaWFOaPkCNxF6oimF5Xwa5dRzCGUzNo5o7P6NQMq9ZM5Zm/vZ/V0TOnkWpieCoQrD52Gn/cNuLfhtO8n5okmwZh3uxGnm4/mDXVUM2FVtFBZIBqddBPT1GKgURixOeGx2XGIlUIZsws443ejix1e7jC+2ia+NnTm3mqa4fJJJKgp80DUkUzMrRlwSn103i+75VsN6bSKlIKHJqOokhUodBWPImXez/I2p1OK+iGgqbqqKrZmcVJJ4e6IV5sdo7UzUrZQpHooX4UjxOH38MUbQKvdbeP2K1n7B1Vdf7k6un8cdcHud+NER1FCE6aMJnfvb0r1ycZ+f6qECxqqOfFgwdG5ttRvjt8rwqfl6RmEBreCc+jowjB3JZqXtn3AR3fvB9jMELlrdehlQWz90z3hYl86wESPic1n7kM4XEzWoTIZD1vnsxfu97K9vfROqpQmF/awFv9uwvu4ACUOnykpEpfcrhMzthVRQAzAxN4tfegyYLLcz+AO5ecxzG1BZKZjlM+ponbyEcJcNbeeIctHbUcN4PhwpWNATyKghHXrWNH8iVrOFoF0D3WG3OqIjBKHGOYJslIiPf+uJVEBuRMO+1y3vnNg9nqyC1nbx5TY0fzqiQ1w9JuKTAXdDvDbURVBJ6ESjxZmPkggArcDAzELWOM3LqCsO1v+8BACaR91uf8qqJglGvEUoWZDwLwVbgJpeIFuyIVNvO9pDIJDisuvoDuH/xopIxEBvSYtHy7DpXgsWbSaULB75cM6dZ08nKPi8F0zDLGSEElbVMo09AFqXh+RzGG4nT+9wMYA1GqbtqEVhrMXhsGOUrAT9X1V+P0+vAlnEQT1kyTcsNNZDBhnQYhLtAi1nYrSQN3v32BRMeQtY6qKji8ToZi1v3tqfHSn0pappTQfQqpgDWzRXdAonDyYdNsIdGrrftREwrVFQmGDOsK9nU+haSMYozJKjjqftIENFZxXyldIRwrXPLCbAeGwtaV0jWh4It7GIxb93dQdRONWRceFpnzd6tRJ4V9ugyJxPAZpPvCdP333aS7+9AqSqn85HVopcHczytLqP3C1WhlxXnbqvBpJIjZlGswcNikEzAk6NI+n0AsaT3Jq0LhjMbZ/Mf8U6zbspH/T9DE9+3bx1VXXUVLSwsej4cJEybwhS98gWSeatGj5fLLL0cIkfOzZMmSf5LVYyWZsqmgKiGd1m3Xb12XHw3dehxNCCHyMkOc/hKmHL8JV6CMxGAvb/zgG5bgBkyGkBXL5qMUgSBtw2iRQCo9NtHU0WIYxj+xv7FlmknM6sdWZjuCJdRu3IwjU+iz49u3jwE3H7XYMXFMHd2WiZE27OmoVs9M8bqp+uSVVH3m2hxwAxl21S2bqLr+ahSPx3zLtSuQickmNKREj8fy1g8CiIdD6CnrhXs84Hy8YlvYE/O72VXlNjBsi+5+lMNWl9bzIJh+YlfB3pDSdj4ZTxX08TCWJHJcfmI3Lk2bPpr5e7gFrTRogpqKUtLdfXT9990kPtiXBTeOqlJqP39VQXAD5jMZz/7FRzF/j6cNKSUJwy4/10cr/2sA591338UwDO6++27efvttvvnNb3LXXXfx2c9+1vZvjz/+eDo6OrI/v//97/8JFueXSQ2F2UFg7jrUVgctWU2KEFRXFdsONrfbbhsE88XcZa2X1g1qy4vy2u30l9CyMje/RP1xF+YFN4oQ1AWLbenWXgu20mjxWdSNAXOiqS8ttu3v+spi+/6uKLLtb5cNrRcACT639WtZWjeoLymypnUqgoZgsaWOIgQtDU2UX5z7fCouviAH3Lht6N/DEnAUrhsDJrip9wZt6aj13lLLZyKAOm+xLVhya6rlNKl43WhlxRTlqfWjlQRNcEPGT2z6UhWC+rJiZCLOwZ/cw/4f3kFqIJSjkx4Isf+XW9n1+7vQk4WTHWrucfZ3wG15XdcNaqqLLZlWqiqoq7DWEUBNUZEtk9A5ngwo0qRuW4kuDWrdZZapAlShUOMut71fhavIcocHwKViD5aFmZrASgwpbcecKgSNwcIgAobZTz7bPDCaUOxzQQFlbnN36miQ0/m1rdkdneX/9S+4Kgpvv6lCUOe13p4TmPXt7OCbJhTbtAQGknJX4ZqMYH63qcVjA///kfK/BnCOP/54vve977FhwwZaW1s59dRTue222/j5z39u+7cul4vq6ursT2mpzT7rP1DOWzfHetvdkFx33grLycaQksvOXYLf7yr41qUogtNPnMus6XWWNPE5M+s5fcNsC8oqBHwurjxlSV67k5EQe5/NzS9x6E+PZNlVR9t97dpFFHvche0WgvMWtLGoqTAdVRWCeQ21XLCgMK1TAAGXk43HLLal0W45eZnlG64hJZefsohiv7vgW5eiCE4/po0FMxoKgiVVEcycWMO56+ZY2u1zO9l4rA2t05DcvHaZtS9JyTlNjfT98Mc5n3f/4EekM8GIqhCcN2MWK+ubLPu7raKay6fOt7Zbc3D99JW2dNSbpq+13MWQwHVTVlDuKpxPRBWCs1vmsLq21dLuGWVVXD5rnqXdXs3BjcvsabQ3HbMMI5kgPRQhFe5l/w/vzIKc1ECIfT+8k1ioGyMRRRbIQq0qgpNXzmDZggkF/URRBBNaKjnzjAWWb/kul8blFy+3PnrSzfnESiRw+XELqSr2Z/tJT8RIDYZz7D51zjTWTWzF6O/PZUgO6wjBlPJyrpq+sOBzE4BL1dg4da3lUYguDa5sPd7y+wvg/KZjqHQFC/sJCsfVzGVdzZSCfqIgmBAo52obu52qyi2Ll9n6yS3Ll9sCk2sXL6SuKP9LI2TK2kydynETClfcVoWgNVjKtbMW5uzklF11Xo5e1TUX8tl1p9v0t+SGaWtt7b6sdaX5glJwXCpsqJnF+uqZBQGsgqDRV8pVk5ZZwk5NCM5smm1pz0ct/69iUfX3948LrDz11FNUVlYyefJkrrnmGrq6uiz1E4kEAwMDOT8flRy3aCpTW6vGxI0P//vs9XNYNqeF006cnfM5QCoVIz4UZtq0Go5bNZ0t167LtpOIhUmnYtnf/cVuLj1/KTdvORahjk35LgGhCm7ctJ4rzlmKP+DOa5OUcMOVazlh6TRmtFbnXE9GQrybicEprazh+eefp7SqhmR/rxloPAxyMg3PbKji1AXT+ewJq7OFFXNvBkUuF5vXLOHfjl9LoarFAsHnj1/LppWLKHG5xwbhZ0KPPnPsak6eM5W5DTW5nTzq3+cumMXKGa1cuGZu5vNRShnK7vS6Ck5dOpNbL1lnbuHmoe0GnE6uPnMpt1y6FkWSV0dIuO3ydVxx4iJK3e5s+6N1pIRPnLmKE+ZOYWFdbX6bgHPnzGD1lFaumjsv/3eTkhYE39iykURPj3ksdeP1aMPHVbdvJd0XIiCc3LJ4GV9Yug7VyEPtk2Yw7ZeXrWfTzCWUq778/S3hc3OO4aSGGSwsaS5kNmfUzWF19WQubV1eqLuZ6K/mzKZ5/NvsE7JBqEd1JR7VxY3TVvP5BceYE2k+Bwe+vGgDm+YupMLrzXPcYX7y6aWrOHHKZJY01ef+cVYDTp85jTWTWrnulPU0XbQZR7AsC3KGDu01wU64l9bWVh740c/RfMV5TXK7HGw+fRk3XLUWVVHy+gkSbr32WM4/dzHlJd68foKEa69YzeoVU1g4qyG3k0f9e/2KKSxdOIHLT1w4MqCP6vDWqhJOX9fG5840/VuPx9j7i3vY89M7zDEswa1p3HTyCq6YPIFDd99OxwP3HAVyzJ769w3ruGb6Qmr8PvI5igT+Zd5K1ldPZ21V05j+Hv73qfVTWVE5jataVgESMdbBmRIo5tTaZXxq+mkowuDoWU4gKXLCdRNP5FMzN+DRjr6X+bsiDL4090SunL6A+qJCdkv+ZcEKNrROZHVrYbtPmDKRYya0smX54lHfeHQrkqbSIBfNnc2XNhyT/SzXIonLofHJVSv47IrVOFQ1ry9JKfny2mO4csYC6v3FICHdG6b3/p/k6Ca+/wum4uWYmkmFzGZD7VSOqZ3CxknrsuM5q5L5vdZdxgWtS/iXaaeNcaVhPU1oXD/leG6ZdhyaUAumnfjsjFO5eOIi6r0lY9aC4b+5ftoaSm12eT5q+X8NwNm9ezff/e532bhxo6XeCSecwA9/+EOeeOIJvvGNb/DKK6+wbt06EonCgb5f/epXKS4uzv40NBTOH/D3yusH2nm9v5OUH0bHYRkOSBYLfvbOO+zr6uOxnTuJl4ksKyKdirHzufvY8exW/nZoJ2/sbef+Z14lVqURlf28+cJdbH/pflJ6jGSRwmFPkt++vJOHn3iNSJlKyqdk6a9SQMqnEClX+cGTr/PbF9+hmzi6W2QPdWXGpnSRwoN/3cZbe9rZfuAIUjWvJaNh3vvjVpKDvTgDZbScuIna1ik0n7oJZ1FZFuQMvwUKA97e28kbew7zvb9uw5HIMFWGHVuaNOnBvji/3vYODz/9GiJqmEX4RumIFIiowUNPv8bvXn2Xga4YauIonTS4huDBv2xj+54O3nm7wyxQeBTd2jEEf3puJ/vae/nD77fjytLSZVZHG5Ls3t7JGzsP8ehDf8Pbl0aNj5oBdIkjYpDcH+Hnj73Ag1t/h+twDMegPkLtNSRGdx/agRA/f/gFnvjL2yR3hHD1pbNsHaREixgEDid57IHn2bmrg91PHcB3RDernGdEi0kC7TrP/vJt9h7q5Y+/2k7gkGnnsE1KUqLtDvP0177Cnj178JVWMvn0zQTKWqjZsikLco58ZyuJbZ38+vm3eeSJ13HtBUdYjFDODXD0Czz7FB7+82v8bscuwnuSqGF1REeCMqTg6nTyvSde463OI7yws5N02AnpkfczmVLQQ05+9cZudod6+f6OHSQiLvT0SP0faQiScQdvHg7zQsd+tu54ESOpIY2R/DxSmsHFoUiKn+55i++9+yopXc/aMvq/Ukrufftlfrt3F0cSkRyqrcRkHQkN7t7xMtu7Onmh6yCGwxhDEzecBr/Z9y4f9PbyozffQqsoofGSUSDn4e+SCvfiKCnjvx58mN9tPwQO829zTMqkb/j58zv4+a9eIx3TM3Tr0V8OREry48de4tm/vENoVw/KUHrEl6REJA0cgwl+fv+z7N7ZzvY/v4OjL4ZIjaJbJ3WcfUO8+PPXOLC3m9//eBueUBolIXP82zmgc+SNTl57dS8P/e4VHENgxBLoQxFzDP/0TtK9IZK9Ke776V858bjjSPX1okciyER89LcDIbn3lW08fmQn/WoXLncKIUZ6QNV0/IE4jxx8lgNDB4jxLBOLu/FpIw7udySYFOyiV/8rnbGDDCYeYGXpHipdg9n7+NQkbUWHmeJ7moNDL7Nn8H7WVrxPg6cPJXNc5VTSTPJ3sqzsLd4b/CXP9/6ZaWUHqPUPoGYGnYJBpTdCW2UHz/b+kme63mHIfRifP56hU5t2O51pSkqGeKzjSd4Nd/F0+AMMXxqpjgIvqkT6U/y59112hXr43s5XMTxGZr4c7h8wnJIPEr08dWAvd7/+MtJJJmXIKL9UISKSPPL2W/xg+xsjbNLc3kYKuPu1bfxl3wccDA+Q7umn6+sjgcZVnzJz/fQcOszyVSv507bXMZK59bakYVaL//Oe3bwb6uLet18jEXei66PGpRQkkxrv9UR44vAH3PXui0TiLlL6CIAxpJnioTui8Mie13hk9zb6Y2ZR39HurRuCRFLjnvf+xpPt77N/MMxwwc5hHbNBhYd2vULCpqTHRy0fOYvqi1/8Il/60pcsdV555RUWLFiQ/b29vZ3Vq1ezevVq7rvvvr/rfh0dHTQ1NfHjH/+YM888M69OIpHIAUADAwM0NDR8JCyqmx7+NU/u3DNyBDXcnZmtQSEEK1uaeHHn/pHjBylJDobZ8/M7s0G8p930JT7oSpKMhHj/13eSHOjFWVTGpFPM4F4BVAb99PZFc+8lyVLJIVNssthHVyiSa88omwDmTKnnzT3t2bb0xBAf/OFe0rEIk07ZjDtQyuJZjfztvQMkBvrY/Ys70Tx+Wk69Fs1lnm2rimBWaw2vHmjPtjvamYbvVlnsozsWywba5tNRgJpAgCPhwTHvW6PXp8V1dbz5wYjd8igdRQiWtzSwbdu+HLb9aB1VEcxsrua9Vw4UtDudjvP2joeIDQ0wf8aVuF2ZN3gB8Xg/r+24H6fDz9yZl1HbVM2RI/0j7QjzH6PtnrmshbfePZzNaC2P0lGEYO7iFl54d3+u3cIMmEwnY+x64l5EOkbjSdfhzKQ8l0iS0RAf/GormsfPxBOvpaKijD4ZJ6UbWZ2j6b8IqGoq5lC4P9PfeXSA+dPrePnIoVHb+Lm9qQjBygkNPN21J+fddrSOKgSzy6t5I3RoVI+MfcKlLi8DsRRJwyJgVUKTp4z9A2GzhQKOsry8iZcPjbL7KCdQhGB1VTN/e3d/9lJs/14O3v/dbBtN19zI4nmL2fVWp5XZBD1utN1DJJN6IRWQkgkuD+0H+rKBn0f7JcDcBc1s37Y3G2w8xr8Vwey1U3n5zbG+O1qnZWYNr0ZHClEmIiHe/92d2ReY5jUXcuCZHxHv7zFLXWzchFY8Ks5uxE2YNs/JvmjPyKKdO8UBcMmkIg7E3szGzwxPUcOndgoKS0tb6E88k/0bM7OGQM2AJoFCmWsiHfGR9A1Sgi5NneH7aSLA29EKkkYyq2NIgTJKByASm82eiLXd010zea79IKloDCOeQCspzvn+qhDMkUW80tWTjfE6usNVIZhaWsE7Xd0jDedxAr/DiYFkaJhNWcB3J1eVsXPvbjq+fmc2/UHlJzbiKC0xGYP/k0mLUFFK1aevQystHmOUKgTL6xp5rnt0aoajxi6CKcFy3h86kkdnRM+nOhGKJJpOFtQBmOyvZld/96iYnrEe/n8WnsoZzW18GPlfpYn39PTQ09NjqdPc3IzbbQautbe3s3btWhYvXsyDDz74f1XYbtKkSVx99dV86lOfGpf+R0kTX/j52y2rcgOUqC4Go2N3mJKDIfY8ZoIcV3EZLesuZs/jPxgBN6duzi5kgPk2aBf0L6VtIJ+qKOBQSB1VcFNPxtCTCZz+IACBYhf9mWKiyUgY1eFCdeUG7qlOBV2xZglJkbu7lV9pJLdMIdEUBVdc2DLXynUnkbA188WdkKgxoyBrJR7v5/XX7iEe78PjKmH+zKtwu4qJJ/p5dcf9xBIhPK4S5s28CpdNfRVVVZAlLtsCkO5KD/2JwizCdDKGoaTQSoJjYrpGPx9DAd06LtTc9Su21tEUBVlqFkm0kqKgxoBRmN5uDMURyQTOisCYeId0bz+Kx4XidSMNkIb1+JcSSFk7kyYUXCmNmE1/l6Y9RCMJJJDqD3HogTtJhXqz1x0lZbScvxm/UmoZF6PGDHydNiwiQ+LutK7+rGoKTlUQH7JmkrrriokkrRkyiRKNRLkjx+5kJMSuDMgZliy4CRbwYUXimWR9pK8JheV1hzEo/P0Sg0kaZISqmgTyqCDi0JE4bp+GJ6ChS4FEG6MzWiK6k72xSkubdCnY0VNjqaMKhWh/kP5wxExBMBil6jPXjOScwTwi6vrP+1D8fiq3XDUCco4Ww4wPsgs0theTSm7EYnR+5z6MwQhVn8hNiyBD/XR8cysi4KPqE1eiePMP9iKPg5hMWNPbFQNNyz16y2eTLUFMmrmIrEQVglMbZ/F/Fp1q05i1/D3r9/jC//8OKS8vp7y8fFy6hw8fZu3atcyfP5/vfe97/1fgpre3l4MHD1JTY+3M/yixoz3C2LPNYXEGSmg9azN7HruTRH8v7/7i2+bn+cDNRyhCkHdyVJ0eVOfIAB6tMgx6jpbhDaR/loxn/hgPZrfTcLuLmTv7Kt544z5iiRCv7rifGZPO5u33f5YFN/NnXoXLNTY2I//9PrxNmtODdHmRw1stoyTn+YzjgeiJGKn+BI7i4Jhrqf4wisuF5vWN87sVtt0YitP59QcwBiPU/ds1KKUjE1K6N0zHV+5HLfJR/anLEW4bVDZeEX+fn4wGN46SMqrPupAjjz1CKtTL3h/dydRTt6D+k1LMj8t3x2xdFVTKEae/hOY1F7LrNyO7VFXnX1AY3PxdYgG2BpP87oYnSYdj3PL9NkpqRlhwoY4437r0DQKlTrbc14bTPx6m6DgcfJw4Q0ow4gmMwSjprj46v3pvFuSke8N0fvVe84goo1cQ4HzEong8VN14dWZXKZhzTSsN0vy5LcQ1pSC4AfJEA9mLHo1jxBM48tDPU739KG4Xqm/sPcdLNf/7Lfpw8r8Wg9Pe3s6aNWtoaGjg61//Ot3d3Rw5coQjR47k6E2dOpVf/OIXAEQiEW677TZeeOEF9u3bx1NPPcUpp5xCeXk5Z5xxxv/G12BeU50tJXlyXXnBaHZnoISm4y/K+axp3YV5wU0wUJitNCxCQNBvPQjTusHEunJbuyfVFrYbzKOeSdVltjTxoNdtG80vgFK/dfKutGEwsd7e7glN1tR9RRG0tJTb5hypqKphwayr8LhKiCVCbNtxbw64cbvMSaCkxDpwTtcNJjTa2K0IJtVXWLJMFEUwsabcNqdOsctl+f31RIz9j91Dx4N3kuoP5VwzF/s7OPz9e0gMRZlaUm5Lo50WrCg4wZmLR4R0Vx+Hv3wv6d4wMAJu0l196ANRjFiCgNNlS0cFqPb6LafTtGEwtaLC1u4pVeWkBsI54Kb+ys14Gluov3IzjhIzJue9X95BMhIu2JYn4EJVbaZSARXVxZbgU08btEyutmxLURUmtFrvXiiKoLW6bMyuUzISYt9Tj+R81vWTH5EO5/pAjhhQ4y627m9pUOVsKVi4NTWUJtYXp/dglG9d+jqhDnN3dRjc9ByMM9iXJBE1KHU2Wu7eAAQ0FU1Yv5srQlLnCVrarUuD6aUVuMpKTFBTWZoFOfH395vgpqsPX3Ul1TdvHAM0Ru5lsp/sdm/cqopTtdvKFjQFzP5WPJ6899SlpK11Eg5f4XleFYKpwSrrBJUImn2lWdChR+O0/8f3Ofz5B0j19Gf1XIqG6Itw6N++x+GvPIweHbs7LoWkyV9i09+SeWX1FhofvfyvAZw///nPfPDBBzzxxBPU19dTU1OT/Rkt7733Hv39Zmerqsr27ds57bTTmDx5MpdddhmTJ0/mhRdeIBAI/G98DS5ZMc+SAq4qgltPXVWQtp0cDLH/jz/M+Wz/E4+QjOROOkLAxevns3r2BEua+Jq5E7low3xL2nZ1aYAtpy+ztFtRBJ84c5XloqwbkutPWE5tSWF6pAAuXTWPY2ZMsKzKvWZ6K5etnldwgChCUFXsZ8spNnYLwY0XrbZcJAxDcsXFK6mpCVrS6c86ayEbjl/KrCnn5FybMels3C4zF8nipRM597zFlvT+snI/11y6yrpyNXDDRavRbOy+7vSlNFQEC/e3gPPXzOH4OZMLg5x0EkcqTry3x1zcMyBn9E6GHo1QoinctnyFbYXzzy1ai0vNn8NGKy2m6tPXUt3YQLqrj46v3E981/4suNEqS6n516twlgW5bMp8Tmmebkm1XVnbzMa2RQVtURCUu738yxJ7uz+zbhVurw/V58+CG0cmDsVRXEL9lZupbmjAVxTE4cr/pqwIwTnr5nDs2umW43Lu7CbOvXx5wZ0FoQiKS7xcedMGS+AtpeS6LetxuRwFfc4wJFecs5QJdWVZm0YfTzkDZUw59UbKqmpJ9fbSftfWvCBHFYJF9Q1cPXllwfduBUGxw8O5TWcVzF/jr/Jy2j3H0tjSQM9BE9Tsea0/C27KG9zc/P05BKudLCy7mHJXK6LA0iQQzCk5kWVlywuCagWFSYFJXDZhbUG7BYKA5uFf5q5DlwZaWTAX5Hz5rqx//vQPv6WosqLg3GRIyfULFjOjorIwdV0ILpw1m3OmzbT077nVNWyZt8Syv4ucLj69cI1tSolPz12D3+Es/PKBZPP0FcwqqUEVAiOeQO+PkuoMcfgLJshREBznaaDrSw+T6gyh90cx4rnhFqoQzCqpZdO0FZb97ddcnNo0q6DN/wj5XwM4l19+uVm7J8/PaJFScvnllwPg8Xj405/+RFdXF8lkkv379/Pggw9+pKyov1dWTG5i5qRq09acMEvzf+euns3MhmrOWDcr+9mwJAb7sjE4ra2t/Nf3fmAylgZ6zUDjyEiFZH+5h/PXzWXTWcvBKXKOBbL/dgo2nrmc89bPIVDqyV5jlJ4uJJvOW8HS6c20Ta3NqyOBs45pY0ZTNeesnl3Qadtaa1gxo5mbT1pecLAFfR4uWjmHGzYsMwd/HsMVIbhxwzIuWDaHEt9RgXyZfxtScuMJy1k2vZl5E+vy6iDhzBWzmN5SzdnHzylgNUyfUM2K+a1cc9Uq8y03Dx034HNz9lkLOfaECWzf9dOcv3/7/Z8Rj4cREq68ZjWnnT6f0uFt26PaMtIGV1+6kgVzmlkwoSavDlJy6soZTJtYzcWrZmc/O9qmWZVlrJo7gVtOWg56fp2g4uSSdfPYcuxSHFLktpX5t8sb5Je//j0tra2kQr0ceuBOYvv35u5kXLGZT518EssbmlhR3Viwv8+dNJO2yhqunLQwf6oAYE7zFF585llqhkHOl+4ZATefuwqtLIhfuLlm6mJuaVuJw1Dz+gmG4JOzV3Ph1NlUOwN5bTKk5NY5K1ha38iq2uaCdp81eQZtNTVcs3o5dZdcS/0VW7LgZlh/5sRJvPTcczz845+hZJLdHe3lXreTyzYs4LILl6FpSo5OVlfAtVes4oQzFpi7OHlEGpJLNq6lbUELC1ZOzq8DrDt5DlNm1HHOeYsLHsM1tVawevVUbjh7hZk9NhrOATeTT9pMZfNknnrqKZqam0n19XL4rq2kMiBneJ6SAm5bvZwzGufR5PePsmLEIonBjdNXMSUwhcUl0/LqgOSUmSt57unnaWgup+dgnG9c+PoocDObkho3Te5KJgbWcUzV5WjZiru5vVmsKiwuO5fTak+mSJN5dCQOkeaC+jM4pW4urYH8doPBlqmrWFDRwPHNrQBoZcWUXXduTl+e+eXbOGHOQjYvWJyZi8c6+ITSIKdNnsanlq0sOA96NI2N8xZxw8LFuJT8/i0l/MuSlZw5aTpNnmBesw0puXH2UhZU1XN89dSx58OZ30+uncb8ynq2TFqRSYUxxmxanGWc3jyTW6etx9AFWmkxtV+8EkdVCanOEIe+8ACpd9v52eYvEDp0BGdVKXVfuiIT1DwytRi64NZp6zm9cRYN7tLsteztpLmOb5qyAp9mU6viI5aPPAbn/9/kr/t283KsHaUctIhASUoQZpBn2i954P3XOG7mJB7c+wayQeLsF2hRSWowzJ6fbyXVb6ba/9KDD3L7u+9Qc+Nm2m+/k2TYBDkt525GNgTpD8S497VtbD9whMFaA2UAnAMmhVpqkCwCo8jgv559ltkVVXR4Y6iANmhW/kZA2gfpgOBrTz2L2+Pgla52RMCsjK1k4jENJ+gu+MGrb7Jh/mQeeeENDIdJQc0GOAuzoOTrhzt4fMcHfP23z2biesb2T3goxoNPvcrOw11I3UBIsgwiyKRU1w3+53fPMq+pjtBgLHuP0ROAIuGbv36WoNPF6+8dHtFhRAcJjz39FifMn8JPf/eaSdM4+uVFws73O3jqxV3cc8fjqLr53pmtJi1B6AaR/iHuvP1X/Od/3kAsHsLjLGHGxDN5e/fPMzE5D7B4wsXc9/U/MGd+C4Pvd6G5VHSfC6mZ+VCUWApHLMUD//kbgkEv7/xpJy63SrrYhe7RzG3oaApHf4I/f+95Nqydwa/vew6/IkkGHaR8GggziNUVTnFg136eeXwndz30NIG+FHG/IOVXkapJJXcO6sihFD/6yUvsGejH2aUjXZK0V2AoEmGAIyZxJQx+9sQHbP7Kt/ncpstJhnqz7CFHSRlNF27GSwnf+dVzVJb4eem9Q6iqwHBKZGbGEGlQE4LHXnmbs6bP4P6XX0VBxXAZ4Mg8uDSIpMI74V7emh6j8pIL6fiP/8o+ivLrzkYtLkEOqgykDO7Y9jLt4UH0kIJwqki3YT54A0RCRSRU/vOpZzi2eQI9nVFUh2JWilYzPpIUaEmFbzz5PA3eIv72/gGz7ppDZp+v0EFJC37x2jucO20mDzz3KprDg3R5chccA3Z19PBGOMq9f33dpKRnKm6PBi6RRIL7/vgS0b2DJMnYoo9qKlOg9fYHnmT97Fa6ewZMatHo3TwBaAoP3vUkdY1lvPK33aAocPRRpKLw19+/xfHnLORHP3sJQxMIQ44UiBQgFcHeAz389Yl3uPNv25AuUFIuNI+50E86eTNacQkRPcnvdxxm/X98kYduuhXV50PxuBhm0xkOCQ6DL7/wFJcsbmCIDordGkMpB2nDTAvndqTwOtL8YP9vWVTmJpr8K61uB70pP1HDjLPxK3HKHFG6Y7/G1biGL/yPl6tHkV2v/K8pNNcZVGpHKGYvvdHH6By8hzbXIbrSPrr1AGmp4hYpKrUBytUoHQPfZm/CzST3fnpSXrpSRSSlhiZ0yh2DVDqGeLX327wbuQCpHKDK52Ag4SKhayhIfM4kxa4kv+n4BY2eep7tewe3VxDriNB796M5Xf6Lz/83v1m0mu/ueAHchpkqYTgdhgI4dHbHevnZB9t5YNvrBefBoXSK72x7gVTCIJXQzelt1PaCyLj6fz79NOfPmMWhIwMomoLhNGC4WHBKoCYE33n6RWaWVfGXt/agahqGR8/WnhNJgRJT+UP3bl6cepDvPPMySCd4dXBnAuFTCsRU9iYiPLpjOw+98wbpkBvpMQkMtZ+/ksNfeoB0Z4g9/7oVgGBtDYGbr0B4/Eg9DYpEGgI9qULSwZf+9hSXzpjDnt4BhKqiaAao5mAxdAWZUvjWay9w/sR5eTOR/6Pk42KbH5JFddEvH+XFw4cKIndFCOZU1vBmZ0fOlrkRi9G59T70wQh1N21ieusk3u022WfpUIiOO7ai+v1UX3dNNrCt2OkiOpC0DNMSEoKKi4F44bxAANNKyvngSK+l3bPrqtm+74ilzoSqUt4/0pv3+rAUuV0MxhOWduvxGH4BcW3suXJqMIziNBlC00sr2HO4p+Bxj6II5lZXsfOd9oLMF0URtJYHObzjSN7rAPFEP69vv5+hWB8eR5CFLRfjcRYRSw7wyt4fEEuF8TiCLGq5iKpgJQOhaMG2AFpn1bP3/U4MvYBNqmDKgmZ2vtthaXfdxEr2dIYt7+X2OQl7x+6GjhYJeFp9HNz1DnseHQk6bT33Bny1LdnfJ0yv5N3u7oLHPaoQzGyp4vWeDks/qdElL37lq6R7RzF4ysqovnFTNs7AqzlIJHTrWAYJlS4vPUPWjKRZFVXs7LS2e05FNW8dsPbvlkCQw3tDlvfyqhrOA4kxzy2diqGnE7g8QZCS2pRKqMdM3xBP9qMqLhxa7tHX5CnV7H73SMFjKkVVmLioibf3dBV8vkIIKieW8i6D2c/0RAw9lcgJRne6NXonJEn0hVDcrgIBtJKFbUP0pfrzXBuRSxp1Yum3keRnkwlUqgaKuPHs33D4wAi7ra5R466fVFFVqwEKLrWBWPpA3jaGxcDD9nh1wXuBCTJ2RJfSnQxbtuXSZ/NGXzfxrhD7/vUhUp0hHFUl1N1yBoe/+QtSnSF8NRWU3HoV6ih2Ve53gwZvCQe7BvNeHxanoiCSgpRVDJ2EOl8RHQODFsc90FZTzY4jndbjsraKN7o6LNupLS7iYGzss43v2Ufn/9ye/b3uM9ejtjYWthtoCAY4HOm3vN8XF6/nsmnzLduxk4+ridvIRwlwpt/1bWJpGxqtw8lAniKiRiyWjZJ3YG5bDgfspsMmk2X0pCN0UFI2QZiSnERy+URTFNSEfUHCYs3FYMwaKGmKAIRtoLGV6IkY+x67B30oMqaoZ3IwxN6f3Ynq8TPp7I14dO8YevvRUprWGBqwttsVM3AM6QUXknQ6zhvbHySZiGTBzbAMgxyn5mN+07k4dZsqupqCcDlIJa3t9lQGiNpUkpZeB9KtWcZp6E5Bssg6mNFQYMDVb2ao7h8BHaMLq2qKQqpCkNCt7fYGHQzohfs7HQrT8d2t2cKg5ZdcQM/DI1XQsyDHAGHY+7diw8jWFAWHVLMJ1QpJMU6iMesXBi1mVhS3jLOLGfh6cp9HOhVjx4v3k0pEaFu+EZezGE+nuTsZT/bzynsP4tR8zJt0cRbkqKqCJgSJuHXaCWdtEVE9bckUi5cqJCsclnanfJJok/W4VRSDlimFXwTApFufWv0uiigM8kMdce647HU6DiSoa9T40jfL+MItvRw+kM4BOeZpigYW4GVQd7E7ZV3TKC1VngnlP+rLfjcU9oZq6evoY9/nHsyCm+avXIajophUd38W9OTmnMkjSYGa0qzBuWHuHlqJuaNtraMKgUvTRvLpFBCvx8GQnrK0SSoS4citOp8Ohen89lbSPaNeRipKqbxt45hCt1m7BaDa+JIQnNYynW+uOtlSz07+P1FN/P9XxKrA3LAohWp4jIqSPzo+UQsGx7xRfZRI1I7VBFgW9BsWIcaWjfh7Zbge0NElIYbBTbK/Fz0WQU8k7PMxjNNuOxVNczN3ysUsas0FNwAeZxGLWi9mfvN5ONTxUZvH2992arlRHgVkHA8kGQln+9ZZXEbruTfgLC4b8wzGZbcoTBJNh0eBm3ITzLhbm01QMyoDczoUtjf675Bx+7ctK3Ec/p2nDT2dIJWIEB/q463n7yIRDwMj4CaWCJFMR9GNXGA4Lt9VhG3laoGwBEDAuPxkvGNbWMyDoSNmYPEwuLnrJ1W0LXBz10+qqGvUOHwgzcbzOunsyJyl29x1PHOAsGFiDbejCFA8TrSgLwfcADgqimn+ymU4q8pQi/wo7sJHKwJbsz86ER9+XI4WWQDcaOVlVH3ierTyTEXzr99Fui9cqJHxmG1JWvlHyMcA50PKmqYWSzqqABbU1lk6mioEC+vqLHdBBFAfLEKzyRWkKoK6YJEtjXZeszW9XQiY21JrOZmoimBuS60lbVkANcEADgt2kCMQZOJ5W/CUVGQX2Gj73pwFuOXszSi+IuZMsre7bVq9rd0zZjfY0sSrm2oIeEvyXnM7inCoboSqUNtUZnk/PW0wY16TJbNLKIKZbQ2Wc6SqKsycUZfNhlxIKot9OB2Fd3ASQ2He/evWnL711baYOzejQE6sv48FdfZpEBbW1BW0W3G5UAN+fFWVVN8wchyllQSzIEcNmItHhd+HW7Oj/8KEslJb/17QUGtbmX1eY53lvKwqgjmtNZZJ/gCCZX5crly7XZ4gbcs34vaWmiDnhbtxFw9mwY3HVcLCKZfjdo7sCOi6wcy51n6iKIK2GfWWNimKYHZTjS1tuULz4NFs8s4YCi3eWsvq3bo0KHfNRZDf59w+jUCpk7qmolHHUVBVq2VBTkmZgs/nwO+cC3Y0cdWHQ1inwlCFpMVXZ5mfRZcGC8sacfq9NH7+Ipr/4/IsuBkWV2WQs2//dyotEuqpQjC7usa2KnfQ48LvtA6ylQJmVFVap3kwJAvq62zTICysrbNkEipCMLtypB7hGHBzk/kyMuGTN+GoKLMEORLBrLJqS5t0KVk16vj7nyEfA5wPKVfOmV9wIhFAwOni8yvX4HM6Cw41Cdy2dAXTKwrnb5HAlsWLOattRsG3NyEE58yeycaViwovOEIwrbqCmzcUZj4JwOdy8i+nrMHvKlzh3JCSm05YwbS6wgNSAtesX8SZi2ZaUtfPPWYF337wkewCu+fR7+YswO6iUibXlnPjGSsKLkoC8Lqc3HjxGvxea7uvvmQVU6bWWL4xX3DJco4/e2Hh/lYE60+dy/mbjilok6IImiZVccUnjrOImQC328F1nziOQKBwhXNdN7jiqtVMn1ZrafdF5y7hjGNmF/z+DoebiooKqusaco4EnYGSLMjRvH5a66u5bb11f7s0jc+uWU2J253XvxWPh5qNV/Oj3/yWxdNzKeDDIKdq09UoHg+b5i/iorbZlqkCTp4yleuXWtBohaClpITbVheuuG3arfKZDaso8XoK+q5uSK7fsIx5E+osF5zLNyzgzBPnjunvo0HOrx//RkFwoyiC2oZSrrr52IL3QYDDqbJpyzGUBL0F/cQwJNecv4KFk+qt7V63kMtnzbXs7xMmTObSlmMLLt4Kghp3GeurryjYjiegceP98/nLE3+hvr6G0ctOVa3GXY9W8Z3vV+EvktQFb6HIvRyrpam++GpmlpxNoe03gUKLfyVn1p1MocRyAkGFq4ybph1v7iz43DjKxx53aELlK8edS015eUGQp0vJzfOWs6qx2bK/r567kCvmWafCWD9hAjcsW2IZF1ZbFOAza1fa5ChT+MyaVVT7/QX1DCm5aclS1ja1oAhhxmH5/VlwM/wysnntsXzmwXvQKkpRAmN3shQhWNfQyi1zCqdmUBDUeAMc3zSloM3/CPkY4HxIaauqYlZzCfl4f1JITps9gYbiIGfMbUEKmVdv7oQgM6uquGLpTKSWHnVt5L8VFQrHT57ABYtmoHr1vDqqV+f8RTM4dvpEAuWOzBWZ819dNbhgVRvT6yqZPKmS0dT14X8bQnLsosk0lBWzYckUjLxWw8TWCmY0VHHBmjnoQuaxyKyCfmzbJM5e1obQRF4dqcHZy2dx3rErmHLW5Tn9W3/chTgDJehIzls9hykNlUyeWJnXHgNYu3gSDVVBjlk3PVPrZqxey6RKpk2q4bRzF6GT325viYfV66ZxwtkLURz56b9CEZx8/mKWrp9OcWkmSeFoSjbmYnPKxUuZMLWGKdNqRriVwzpSIg3JinXTqG0oY/36mUjDyKvX2lTGtJn1nHXq/JFg5aPu5/M4Wbt6KqeunZXdCTjabs3l4SeP/YKnnnyS6rq6nGuOQAmtZ2+h+fRrufjYpUypqmBuXc3YjszccsPkCTSVlHDWxJlZltHRHT61ooHj583jiinzIClz2hg+ii1OOzl1whQumDITd1zJNTjzXzUGl0+bzTEtrdSlfWN1JMik5IrJc5haWcGiYG1ee6QBx9dMoKm0hLNmTDf7Mo/epKIS5jXWcsHqOaPqyOXa5HU5OGHBVE7a0IbiUseouDxBpiy8gNEyq+UMXBlwM3zbNHDiRYtpnlDJlFUT8vqtBBacMIPahjKOOX02upB59aqmljNrZj3nrp+Lrub3b1eRgxMXTeXcGTNxOJWjrmb+q0gunT2HxWXTqPUcTbfOzHEYnFG/hFJXE/XeWeTtSCTTa5YzrXURFf5zyansClTVqPiLFNxaMwH3YmoCl4w6Ysq1SRNuyn2nM634BJwiv90KBrNKTmd2cDo17kAeHXO2OKF6OS3+CpZWNhW0e3V1K83+Ms6bPLsgyGssCrK0ppFLZ84ZeYk5qis9qsYZk6dx1vQZuIZ3uo5+KLrk0rY5rGhuosEdGKsjwdAlF05vo7W0lFWVjYXMZm1VEy0lJVw8YRYynce/gRalmGX1jVw+eQ4iIc3syZuvNsFNMAiAP6lx9sQZXLvsGJpuvoHKm64aU5NLJOHySfNYXtNEo5abaiFrtyG5oGnuOBIdfrTyMU38Q8qvDrzFe8lDOCsF+pCGkTQ5q4pbR/WmefTwK6xub+aXnS/jrxekIg7SMQ2kQHWncfiT7EoP8KuDr/P19/6Irz5BKuogHXEiDYHi1HEUJUm6De7a9RTbujqQNTGIKjCoQVoBzYBAGukz+NIbf2C6r5E+/xCGBmpEQUkJpAK6V0f6DP79tceRBrwxeARRAerQCL3dcEnSXnjk/bdYPamFH25/C4KgJkDJxL9KzaTBbw9387M3d/Dff36WtA9ECpRUxqcVk3LeT4LvPv0i7xzuJO2SGGpGR2LS6R2gaJIv/u4JJrkcvPvzB3P69+CfHqH5gs04Skv4rz8+jYbgrSOd4AM1RbZ6t6GZ1dJ//trbrJnZyk+eeROKBGoSlJS5EBgq6C7Bzs4efvXMdh649yl0nwYpiZIyzMlJFegOhUFD5/6Hn+PwG4fQVQXpAPSMjhBIRcHQFL7z1d8xd2Ydg6GhMWADafbpfV/7HU6nxrvb9mYOolWTBgwmFTit89efvsyS9dP51Q//ZgYaagpSVTBnB4lI6+zb2cHvH9vG/T9+AWFkYOnw4b8EdEk8muR733uWXfEBdDL0aGPUfKOYAcZ3PvYK85Y10xePYWgmTVUaZntqMIgQ8I3fP4vb7+DVgyPFVI+eJH+14102TJ3IQ397DRVh1tHRzItCN6nbuwf7+Mlrb3HXH1/CPSRIuyHtkaCYdHMtKjB0nW//+W90HR7A3S5RXJAoMn3NrJINzhj8xw8fZ/X0Vob2xfA7IFlspjUQBjgi4ByE2w8/R5HLxVvbD+NRzfQIeuZkQE2AIwp/bn+P42ZM4uEnXsUhTd8xMqc1Qjd968BgiEeff4sHfv+SGRly9IIkIZlM891fP0e4PULSCYZQUFKGmVJBQDQ9wLuv/jjHp9/a/0vmzboSj1oECuhuDd2tcvcjz1Fc5ufV3R1Q60WLpFASpoMbbo20X+Ovr+5m1Uu7ePDxbchqDceQgRYzn7/hFCR9Cruj/Tz61BtsfXMbqRIgbn5vYWTGgAdSjhTfePw5OosGSLtSJhU5Jcy3BCHBYSAd8NmX/sg1c2qJ6n34NEgaKkYmz4NDMXAoBj8++CtmFMGR2DYcgI6SfWlSkChIDkSe4nDkcToH7shclQyXHDFpCgap9F66Bx6kJ3IPTgwMJDpmDJRZoUpHyBgd4f9kb9KJS8RRhSRlqBhm1BEORccBvNL9VRTHJcT0bvwaJA2zzpUAU0fo/LbjZzhFLS/3vY9TMytjG5kyEIqQqIrkme53+Ev7O9yx/W8jG0ajcY6Ag5EwD+58lYdefsNMg5GZ27J6BiRlmq8+/wx6xECPG2amAJVsm0oaFCn4/O8f55zpM+juiuAQpt9m0yCkzTn4zr+8QHNRMX97ax9uBdJuc64F87oWh2e69/Dnmbu45w8v4ZGQ9kLaY95PSZpjoFsf5AfPvMaPtr2Fp18h5ZakvR6k14MYAkdUINIG//37Z0g7JQ6jGBGTpDGQmjTHSVxBSyh88bePc+7iNtq7oiiKhnSZOkiTui4SCrc//yIXzGyjwmed+f2jlI9ZVB+SRXX2E/fyTvhIQXSvCoWpwVL2RLvQZQHqJ4JaT5BDsZDlvZzCwYB1DUmkBDXuJW5TILFJlHJ4YLDgVqgqBFP85XzQ2Vd421EI6vwBDvdZF+NzqiopmwKZqXCIQ9+/k2SoF0ewjNrTLqT9V4+QCpu/N12yGUdRCU2+Ytp7BwrbrQimFJWy70BvYSq5gDqPn749YUubXEIgjljTv5ESb0onbsN+qm0o5ciB3oKxE6qq0DCjjv37ezEKxAYJIShtKqUjT+HWnLY8GgOlNkUrARqdloViBVDTGORAf79lf08sK+ODnt6CfiKAGo+f7u6IpU1OFBi0CQ6VENCcROOF+1sA9XUlHOgNF+5vRdBSW8bu7sJ+IoDKgJ+eXmu7HQiU/rF2J6Ihdv51K4lILy5/GXMWX8KbL3yf+FAfbm8pbcs2mhTy4fsJaKgr5VBHyMJPBLWTK3i/t6+gjhAQrPZx0GFNpVccEGuwTt8AkuWT+hjSC7clEJxeFSVl7KFQmQWByjRvMW7jTQrH2AgcSjmG0WVpUUo62ZWqAAvLpYRXI/OI2Ng9GJ/F+4NhC7q1QpWo5Z3uwnMOQLnqo6/XZlxKgRKxCVqXUC7chIcKT/SKEEwIlrC/K1TQd1VF0FJRwp7OkKXdwYCbvoT1oiIE6F5hzcZCUlTqIRSPWdr9ieXL2bS4cCby8cjHLKp/orw/0G0ZXKZLg/ZYuCC4ATNl9pF4P5oNI8uOjg6AxBbcOBSFjsGIpcPqUnK4f9AySM2Qko6BQdvA56QNrTs1EObgKHDTdMlmvPUtJqgJmvWA9j98JzI6wJFQYVAGZtxER8+gJT3WkNDdPWhZFgEgFbOmYQIgpS240TSVrvbCixaY8TVdHeGC4Ma8laS7J5LNmFtIEtKGR425k2MFbsA8x+8YtO/vwwMDln4iga7+iK2fpNLjSzVgBW7ABIsdoQHr/jYk7aEBSz+RQFfY3m49lQfcDIVzwM20dZtwemtpWzYq8Phvd5GIhbN/oygKnd02duuS9j5rHSmhMxq1ZaykNLuwWFAVwxLcgLlwJYz2guAGQKKT1g9iBUpAkja6oECw8rAkJDbtmDRxK3ADJsA5NGTtu7o0OBQZtLsdPdEhW2aToduXmlQEluAGTODd0Wc9x5n+bZ2XByAUjdvbLbANWFeEsAQ3w/J+b4+tzkcpHwOcDylu1ZqFIBA4FNUymh/MYLZ/1laaIaXtpC0Ah6rYUjIdqjquCshWojhdqF5/zk4NYO7YZECO5vMjHE5LNlbWbs3ebk1TbAftuPio4yBiSinRNOtJWwjQHCrCZlHSVMWW1SPG8TjGo2OelNn3t1NVbSdJVR1Hf39EIiVo4zjrd2j2dmvjsDtfcWtVc+Fw+01ws34TrkyCPZcnmAU5DpcfVcsN2LQDr2COOTvwogrFlrk7Hh8wxlO5GxDYp+AXwon9kpM5lrXUsDdcEeMAy0LgtPFvyCTos+kGRQjbeXA8XZkv+foYEQLHOP3ENp3AOMDLeERKaWu3ANx2rL2PWD4GOB9Sjq+fbpkLRyJZWTkZK+yuCoXVVZMtd3kUBNOD1XhsAJXX4WB6aaUNrVOyrqXVktIngTUTW2xptKsntVi+AQkBU6rK8ToL2626PUy8YjPrb/s8ruLSnGsmyNlCw/nXgtPNqumtlpO7BJa32du9ZNEES6AgBDROrMTrs564nR4Hk2bVWwITXTdYtG46igU4S+oJJs8uR+axKZ4aIKXHUVWFxYtbbe1uqS7F57G226WptDVU29BRDdZOtPYTgNUTWywnSVURrJrabKkjgKaqIAGPdRp3h0OlbUKNrd2rZrZYMs0EsHKatU2qIlgx3fq7CaC+OkiRL5dCrDk9TFl7DdOO3YzLV4KmqcyaXoeiiCzImbn4KjTHCN1Z1w2WLihcTBfM57uyrcW2wO+qCU2WC64AmjxBSl02dGs0pgcmFawUDuYuR613OYUKZA7fMeA+BqsEfqAScK3FGuAIirRKXGqJpd2aUJgamGpptyF1VldNtpwrFQTr6idYznGqEKxsara0B6Cm2E+5z2upoyiCxRMabYocG6ya1mo5BhQhWNRcSby/L+/11GAYUnGWTmyyBfmVPh+Vfuu4GUUoLG9stKWJb5g00bKdj1o+BjgfUi6buLjgQzVjD4q4bcYGqtz5c9MIzMF4/dT1LKuYWHCnx0Cyeeparpy8xNKeKycv4eY5KyxonbCqtoVPLFmOWuDtRQio8Qf49OrV1BYFCr69qELhltXLWD2xpaCOlHDjmqVctWyBpd1XrVnOv5x1ct7FxFEURPN4WDahkRtPWF7w7VwIMwfMLWeuoqasyKLCt8J1Zy9n2eIJBd9wpIQrL1nBOZcst7T7jAuWcMlNG/ICEzCZVrOXTODy207A4VDzvp6lZZI3en/JD37/fwiUiRywFEsO8PKeh3l1749JywSXbVzHiuWTLO2+/NIVXHqy9Tn3ucfOZcuGpYVTBQjBgtY6blm3DGeB3SchoMzn5VPHrKSxpLjgMiEQ3Lh2OcfOnFjYT4DNxy7lyuMWFrRZAOevms11pxS2WxEwZ2It15+6HJemFRxzJX4PnzhtFY3lwYI2CQSbT1zKhnmTLe3eeNJSLjttbH9rTg8ubxCAs9bP5soLlmfBqcsTzAE3QghmTq3luktW4nJqef1ECCgOeLj+wlU0VZdY7CoINp28nBNnTrG0e8vqpWyZtaxQIwjgoslzuaDpRIvYGsEkfxOrqq5EE27y7z8IXEqAKaW34tYmYbXs1ARvocR7RoF2TMtrgrcws+TKgm2AYGLRaZxce0bBF0uBoNHbzHUTT8Kj5U/hIYCAw81tbccwOViYJg5wy7zlnDlthuUuxo2LlrJlReH5WwDnzJnB9ccsoRB+FQKm1VRwy4kr8LocBe12o/PM3f/FocfuMsHMKEkOhtjz6B3s+dndXLp0BqfPn25p9+ZjlrB51WJLu8+cPZ2bli8rCE0VBNMqKljV3Gxxp49ePgY4H1JqvUVMLPEwUt97+AeEMFhaXUWxw8Py6nIUZTQ9cuRnWqmLGm8RG+rqcWnJvDr1AZ2ZJVWsqa2n2J3IowPF7gRrautpq6igskQf0waA6kxx7IRaaosCNDZ4MOJDpMOhHB2pGMyZWEakp5vJ9V4MJfP56P8JSVWDl9riAEtmNKBreXSQuEpUptZVsGBSHTLLLhz5H4DhhkWTGphSV4Gr1JGxJFcnrUkWzWykKuinqr4IKY7+ZmaG82lTqgn6PUxrq0UfxTbO/ggobQhQXV7EnCUtpB1yrA6glDuZNKWamUsmYPgcY3QAdK9G2/IJtEyvxV1TnKe3QVcVZq+fQVl1MZUz6pBHeQpASiYx1CT79u3libfuI5qp+2OWhHiYWDJMUo/iawxQVVdC28oJpJz5vAREhYtJ02uYPase3Z/PK01Gxdy5DUyqK8dd4SzQ3wYL2xqpKgpQX1mc/duc54ZkWmMlJV4PC6vryG5AHnXTWref+uIiVtU0ogxlWhqmwWd+iqMqbdVVLK6twdebHrk2qtq7qy/N8ro6JleWUR1i5NooHWUwzeqKGiqL/EzBb1ZdH30/QKQkczxllPg9LK6tg3Q+m6DG4aW+tJjF0xqzC87Rfel0qsxormb2jDqkN39/606YN6eR5pZynI3evDoph2TWihZKy/yUt5UzXLEipx0F6hZUUxzwMmNBPWk1V2fYvwMtPuqrilk8tXGUf+f+Tw0ozGqsZnFVHS7n0RZl+kk1WFnXQIO3Br+W/w1eImkrnoJHK0XVJo/000h3o0twOWbgVoNIx2pSebrbkBClCaejFc21lrhU87kJESOA07mQUtdcktI95jpA0lAo9Syhxl2HQxTn1UlLmOifRanLR6OnKq/dhoRWbw2lLh9LKhpzUwWM+ilz+mgJlLKivimXaTfqxyFU5tXUMa++ZiTW8ignkBKWNjfSWl5Kqdud75EgDVjS0kBZwMukstKx98u00+T3EOrtJdrXxd5H7zAzk0tIDoTY++idpPp7kbEoZS6V5Y2NiPzLDu6kwty6GuZX1+JJKHltEglYUdtIa7CUSunNb3dasry8YVwZmD9K+Zgm/iHlV4de5kiii2IfJNMqaV1FCImmGjhUnSe73+R3HU28FHqdKj/E0xqJtIaUAqeWxuNI0Z0a4FeHnuLHB39LtV8noWtEk04MCU7VwO9M4FAEP9j3a3b0H6YsECXgGSKScJE2FDTFwO9K4NQk333/Uepck1BcQ5RVSOIxB3paRSgSlyuF5tDZ+sGfiKcVdocOcuS+76OHo9Teei1aWRDh0sFl8Lu3X+RnF99E2KlSdcuVqKoHkVAQErOqtNtgb6KXB97ZxrdefpFU0ECkQYkLkyqpgu6R6GqKr7/0HO90dpP2S6RbmjoGJmXZbVbL/dzTf2FhVT0RNYVeKlHjGQq4AN1lVrH+xgvPI3T4YKAPWQJKgpwq6IYD/rx7N49u287vtr8HQZOSriYBaV7XXbA/0s/3n3mNhx97iURQRUmDGjepvYYmSLsFqkNyx8+eo317F6mAE9wqajxtztaqQHdr4FD5xh1/YcGEWoYAo9yPiKcQaQOEQHeZOg/d/wyaprLvUAgqAoh4CjKsMsOp4XQVMbP0Et7v+DFHjhzmldgPmTH5bN7Z91NiyTBudwmz519LOOHkZ798hXsff5VEuYNU0kCLGSYNXBOkvQqKA+549Dne08MkigXSK3EMke3vlAdwCr70yydYNLeRASWJXi7R4iZle7i/DQd8+4UXcDs13g31gCfzPDIgxlAkqPDU/r38+PXt/Oq1d1AhWz0bzHsKHY4kBvn+c6/x6A9fxpuQ6E5JyiMyNHGJIwqCNHf8+FkG3urG157C2ZUiXqJhOARKWuIKpXEkJd/57z+weNEE9EMRSg5JEqUOdLeCMMAZTqNFdR7Z8zSeIg/73umkSEDKr5B2mxOrNmTgiEpe27+HX/35TX7z9A6cmNR2w2F+f5EGNSnpFRF++MdtPPj8a6BkFr7hBSUDsNOGwTd/9Szd/RGSHoF0SNRkpr+F6W+ogq88+gTrZk0gpKTQ61ScUWmmL1Ag7VHQXXDvX14mUOxme083NKo4ohItngGcHkHKJ3h+30EeffktHn1zB1SDGjd/hDSBVNoLsVSU+1/Yxr3vv0aqSJJOS9SEMP1EleguSGs6//m3p4n4QiiONE5VoqcVpDTLhSiagapIvvTmH7hsaj3RdOEA0p8f/gsT/SoHY7sBHy6RxpHJ35AyVBJSoy+6g7fDv2bv4M+AAC6Rxi1SCCAlVYakE0mYD0Lfoz3yQ9KGFw1TRwF0BDHpQKLyXt9/sT/pImZoxHDjFDoKBhJB0tAwUHmm89s4HOfRn45j4EATRjZ2J20oGAh+2/FnhFHLW6HDgIIQMrvjJQ2QUvBy735+vPs1vv/u6yNfePQaLaEnNsTd21/ikVd2mA89kx5i+DqYeWC+8sxT6IOGCZQkuZL5k3//45OcNWU6/dF45o1llE5m7D307GvUB4p4a88RM2JJYWSrwjB9b1dPgk987Q4+cdXFJPt72feTO2k49kIO/uURUgO9OANlTDppM3/e3s4vn38bR9SkrRtO8ysIw5w3BZJv/PQZdIdERCWuqOnTUjXvpSZA1eFrjz3JKStn0N8XM8eTy2xPSJOWLtLw8HOvc9HiOTQWKFr6j5CPaeIfkiZ+/nPf4MBQ9xh/HRZVKEwI+OhN9VjG2JQ5/UTSA9m34wKtEbcpxCYlDMT9lvcSgCNdQfvhdg598X7SnSG0qhLqvnAVjvJiUj39tH/pAVKdfZZF5gRQ5vDROxi3tloKDDtijwSHVG3LVVQrfnoiUYv+FjS5imnv7rek/1aoHqJHhizt1nRw9tgw16TEG9VJWzCAhBCUlfjo6x0sGBukqgqeCsEf//QNYrGRc3O3p5Q5C67F7Q4C4Kv20YN1gUjpFETLbcxGYlQqlpWNFSGoDPjojEQs+7tZLaaj25qRVKG7SBy0ZlmoaYn3sDXVFilxIizTDiiKoGhCKd190YJxKKoiKJ1UyqFBazaKP+iiT7dmbQlhV1wAkOBSVUtGoSIE5eV+uvoLMxxVRVBZW8ShqHV/+4qd9Dpt2DiqgbPSjvkimV0dIiULM+4UBCvK4yT0joLzl0BhiseFQ+7Bqgq4U/GB7Le0KCk1DqbKrK2W8OrgNBKGld0KoehEDkaiFmk+BKWykv19Ucs4HD8uhvqtJzlhmDnHrA2HopRGLFl43lEVQZ0zQGdfYYajoghqAwEO7jvAu7++g+TgqIK6gTImn7wZp78Ej8thy6aUwgQsNmbjLLFuS1UEV61ayM0brI/97eRjmvg/UTriIcvFRpcG/alBS8ABMJiOFizKmW1rHBW7DSls76UKlb5EDK2smLovXIVWVUK6M8ThL91P7L0DHP7S/aQ6+3BUllH1qWsLVtCVQCget6fRjhND21Uk1xSF0FDMpr8lfYNDtvTf/sGYZc0fAJmH/jtGDCzBDZi5S/r7hywDn3XdIJl2M3XmeTmfT5t5XhbcAPRH47Z268o4+lvBEtyAueD2xcbR3xHr/gYYGIzZ0vJJHlWROx0nnhi72KVSOvFkP6l0/gVcKILwQMwyyFY37P0EoH8oYevfNk1kxS5dgiIEociQLS2/NzoOu1MJ27QTaPb+rQppCW7ABPAJvc/y5UxikDJ6saKSA6SNQQrVtMrqSPtlS5eqJbgZlp54zCbNh6QnNmT7jCOJZDYW04jFSIfDY5UMSPWH0S1zxWAJbgCQ2PqJYUhCgzGcvhKa116Yc6157YU4/WaQ9lAiZX9sNI5TJUXYp52QEg73WYPXj1o+BjgfUgKaNQtBQeBWXZYBagBOxYGUklQkQawrf2KxWHeEVMT6DVeMg/tpSCNb1NBRfhTI+bd7SXeGcFSVMP2LN+Ist2YruDVt3ADmw4ohJW6HXTFGgdvpsB20LqdmS7cexzw6rsFvSDmmGOOYZhSBNCLs3PGTnM937vgJ8UwlagCXw97u8TBkh7fELVWkHEfxS4HH5bClLbucDttFeXSJ93Q6zuvvPMSrO+4jngjnqCWS/Wx793u8vuvh/CBHgttp099C4HHa2+3UVNsXhvGK3ToikXgs2IbDbXjHY7cyDrsNe+c1pLBNcQGg2hS/BIEqPDZMKxDCYQuC1ALXY4NpQkdMf1CEnjPnDnVFSUbG7sT5CgSij1gNXs1+PnEoZjoBIxbjyN330nH7naRDoRydVH+Iw/ffQfv37ykIcgw5jorbGd+1VAE8TgfJaIh9Tz6Sc23fk4+QjJi2qYp1Aj9g7HFaHhmP3UJAcYGCpf8o+RjgfEg5oXaeJXgxkKyumGf5lqAgWF2xgEQkxou3/Ybnb/gFsc7cJE3xzgiv3fwb3vzUry1BTtDhY35pi61NpzbOyL5xOMqLqbr+7BydyuvP5pxFhQtygrl9e9rEaZZvyooQLKqrp9RtPQEWu10sa2i0pv9KySkzplrqGFJy0twptvTf4xdPtbV71vR6SoqtaZ3+gJv5i6wpyYYuWXfcLEudWCzMyy/fRTzWh9tTytyFm3B7SonH+nhj2z3E42EURbBh6RTLN2VFCOY01lARsKZ1BpwuVjY329I6T5s6zb6/26ba0paPXTrFciFRhGDKjFrKK8waPGk9QTIVIRYP8eqO+0dAjhrjrX0/IJYIkUxH0Y2xY0HXDdavnW5pt5SS45bY233C/KkYiTjJSDivTioaZlK5n+qgP+/1YfG4HKyaaZ3iQDckJ86z9m8p4ZRZ+e3W4zFSA2FURXDqpCk57aRDYYzYyKIqgGnF1dR68+/ODotLdbKwpM2WJj69eC2JwTT9R/Iv3P1Hhig21lkeTwlUqr0n2OzgCEqdrRQ5anI+jQ2muePqt/jWJW8Q6ojjUFwsLJmDgkK0M8JfN/2WJ2/+Yw7IMTA4qb4NK6gvgdNap1mCRVUITpw0GVVRMBIJ9EiEdG8vHXdszYIcPRSi5+67SYV60SMRjET+OdypqayfMcmWJn7Cgqm2sHPJhJLs8ZQzUMbkU2/AGSgjOdjLrt/eSXoozLHzJ1vmFhNAc2WQ5soSy/s5NZUNtnZLTpo91cbqj1Y+BjgfUs5pXIZXy39AKYDJgVquaDmBFl9twTZ8mocLG49niXcWiVCMofYBnr/xl1mQE+sc5Lkbf0H4UC/OCOhDhWMCLm85kU2TN1jafGrdfLZMW4Vfc5lBfj39dN7+sxyd0J2/4NzSFmaUVhakIvodTm6au4zzps6yvN8nF63gtqWFqzsD3LpkBbcuW2Y5iM6cNp3rVyyhyF24v6dUlHPDumXMqK8q2JbX6eC6DUs4Y02bpU2bz1rBNZevstS58uIVXH7NGsvtkPXHzeLiK1fhL/Lk1Ysn+3nj/Yfo6emgqKiCOQuvpTjYZMbejAI5kiiXX7Ccs9bNLngviWTj2cu5+Xjrc+7rj13KLSuWWW4rnDJ1KjcsXUKJO/9blwAmlJZy4+qlzG6oLtgFboeDjccu5ewNcyzt3nTuCq68bq35N65i5s+8Co+7JAtywgMH2P7eQ4T7u/C4SlhwVEXuYVm9fjqXXbqS4uL8oFoADfWlXH3+Ctom1hS02+XUOGfNNMJP/YDdP88wUUZJcjDEB4/dwbu/2MrV6wp/N4CNJyxh00lLLROvHTNnIpuOX0ppID+oFkBjeZAt65cxv7Eux249HuPQD+/h4IN3ICKDbFm5hKtmzwdMcNP57a103nFfDsj51NJVfHLmeku7t0xdyQVNJ1mCrkWlbcx3H89DG1/n3stfItyRC3LCHXHuv/xV/vXin+FK5gcUEnP3ZkrpRpqKLst7H5n5/yllt7Ck4tpRn0E8mmawL0nPwTjfuvQN6uIncEb9acS6hnh88++IHB4kEYqRHho5RpkbbOOaSeupzBbkzBUB1HtLuHHmapbVNBb0E4eictO85VwzfwFaMEjNlk1oZWVZkBPfu5f2O7YS6+6mpqGBuqs24ygO5m1r4/JFbF6/pHAKD2DllGY2Hb+EqpL8dgMEtTSP/J9Pj4Cbkzfjr2oxY28yIOe939zByfMauPz4wqkZJHDTmau46ZQVlhs5Vx6zgC3HLC14nCuA5ZOamNNYk/f6P0o+BjgfUpyKAwx3NuNnDhXREDjwoSoKwgiQzvCWcyiUhiCV9qIpDqprm1j07TPw1hZlQU7f9g6ev/GXDLUP0NjSxHd/eS/eSh9juXgSBYMih4eAw0GxO8VI1ZMRHZeaosqn4dZUqouTGH19HP7SqEDjL1+Do6qEoY4ejl9/LH69B82ZPqodUFSD8rIkLk2lvExDcaeOsgcQEncwScCjUVLkRPiO1jF/hC9NcZEDr9uB8BvZFKs5xFanTnHQgVNT0QIq8ijqOoChStzFGg5VwVvkMIvZ5VpEOhkjnR7A6dTwlXjQHSPXE9Ew6WTMDKrzCjxeB95SD0mfksdqSHkVvGUeXEVuUhXu7JFWro6KqyGAw62hN/nQHWKMTfg8eIqDtLa2ctrN/45aYh4LutxBZmdAjsPlR7YUo3k0nPUesxDlUe0YCsSrFVzFTrwlLpIlBlIcTRCWJIsNvOUuvG4HSpGRqXKf29+Gy6Co1Oxvp3vkjTqn+rwAr0fDoaoEFVdukeisUeBJK7g1lXLDgTY4igI+io/r6dMJqA6KhEQc6QXDwO0sZv6Mq/C4TJCzbfs9dHYdprGhieUVp+NWM7smo9sLDxKIx3CoCoHBFGI4GHk0TTyRpngohaYIgqrLLOV9tI4B7pRCOhZnaLCf5EAvu39xJ4lBM+YuORhi9y/uJDnQS3+oD5QUaU8+7zaLIfqKXbg9DowyJa+fpN3grXKjORREhYqhje1K3QFalQNNFXjLneijKOB6Mo4ejZAK9fL+975DT/cRiv0u0gN9dH77TtI9vRiRQYx4whxzbonf7SDgcI1KXJBrlUBS7HDjVFykDefRxe2R0pzjnMJPdDDOQG+SvoMx7rviJULtMfNxdMS49/KX6Dk4SHd3D72DxcQzXy7XBRQGjCDgISWqiGbuN1pHShjQfUhRjBDFRNLu7LVglZubHppDeYObnoNxNp72NV5/6U3+uPE3RA4P4q8LsO6Ok/BU+JASkrqCkEE0oaJKVzbFQY5NBmiGG4eiUqx5MsyqXB0kaKh4NAclXjdSSNSSINWjQc53bifd20tdUyO3P/ooalXJyBgaPeackkCRC7dbQxYX8BMn+MpcOBwaSpmWd44zNHBV+6msrKS4opqJp23G4S9BAg5/SRbkOHwBysqDFHkLRxALAX6Pk4DLhZrO6yaINARdbjyahjuljkTc5xgOpYrbNrPyRy0fs6g+JIvq7vef5O5dT2JgoAiJIjKVqw2F4eTVN0xZywN7/wSYKcQ1xfQA3VDQpUBB4YLmlfzy8ONIJImuAbbd8jNi7SNFLD21xVzzvc/SVzRIX7J/OFVHVgSZxGvOYpp9jbzStxNdGqR0NVtF16nqKIpEIDitdj0Pbvsdb976CImOfpzVQSb+5yUEar3ovWF23PZj4pnPJ/3XJajBIKmkaqbBdxhoDh1VCC5qXs69772CISVSBz2hmU6vSRSnjqYIVlRO4O3eXjqGBs2JJKmY5/+KBKeBUKDC7aetqJ7HD35gbr+nhZnYRgAOw6QUAxsnL+We17ZhGGY12+F4E0MlW8Lm1nnL+O7jL2YuZOjNEvRUjEOP3IMejXDrt7fyp9cOm/cyJOlwiA9+vRXN46fltGtweH0sndzIoff7ONI7AFKiJmSWbq07BSiC0iIvc5tqeW7bB+i6gRo3UNIGUgh0j4pUTdrtRWcs4uHfvoI0DNSEqQeQ9qoYToV0Msa5J7Txo227TT9JShxDZhnwWLofGXDj8Pg4/5i5PLT9DdKGYVKsh8zvaDhMirCiKCxtaWCX6OPQ4ADSADUGim7anfYCCpR6PCxpruNPB3aZfZASCB2MeAw9HUerCCKAzVOXsnXby+ZiFgqjOF0oHo/5apSZq25rW87dv3wBMEHPME18mLKqCsGFS2fzxF0vkU4bGAroHgWpmBRwNWagKoK2OY30PvsOR/Z3YyCQAS9oKuHoQV5pfzTr69edeCsH/hZC1w3we8DpNFejyBAiE8h7/r+fz08eeMZMkeNUMZymUUo8jZIJCr/wtuO4+7evZO0eru487FeqIjjzhDk88Ldn2PXo7ST7e3EWlVF/3IUc+tMjJAd6cRaXcdqt/85gkYf9vWGkNFMTkKkmbjjM/i7yuFg5tZnfv232t5I0UxwMM1SG+2zjqsVs/dtLJtM4bVY1BxPcyEzYxU2rl/I/257PXMjcT0IqEqZ961bSvb2U1Nbgu+IsjtzzCOnuPrTyUqpu3YhWVgyqybKZV1FLzBVm72BP3iBaISDgcHH2hAae6n4VXermHJeZeXQ5ao6btJxfb/8+j179JP2HogTrvZz2n/P51WdfI3woSnG9j/t+/VXCPvM5qug4RRoBpFFISg2BytTiU9k3+CsMmURg4BJpFCQ6ComMTplrOvsSHroTB2BYRxgYUtDdkeaBK14gdGikDpW3tojl3zkNf7UPKUWGJm6ihxMrTufbbz+f+b7m/A1m7JHMvLRumbyG/3k5M58gx1DAVaFw/pQ2frFjJ/F0Oruox/fu48i3bs/asfLf/w1/60Te6+nJPt9hP5GZFAU+h4OTW6bw8x3vmH6SMv1RDvtSxk9uWrSEO540bRLpjA9g6sgMOL5q3kwe+M1zOAJBMMw5AGnOA8mhMA6Pm7NXLuCPz79LPJnOXVAyoiiCKQ0VSAnvHewyx9OosS/0kXifDcun8KuX3iZtSKSa0ZPmfYdDQ3/yyYuYWl859kZ/h/w96/fHAOdDApzjH/86R+KFI8NVIaj3eQkl+9EtgudKXS6SRiQbqxPe0c62G0Ym9QXfPZfSmTVZcFRIpISRjA/5RUEgKKIvHOadz/yUVHiImV8/H1flSF+kuiLsuO0niGIPE/79fFRf/mMKN17Ccd0yxkgakE5bB31KCTJhXY9LEYLipI9wvDD9VRWCWgL0hMbSOlP9YQ597w5SoV5cJeW0nrEZhz9oZvZ8zHwbdxaV0XrWFpyBIEpa4rAuJA1S4khY16FRFIGv2E1/xII9oQiCtQG6olHLuBBX0Em/M2nJyDI0SbLUblhLFJ/MiVUyhmJ0fvMBjIEIVZ+6DldZCcG0j75YjHQozJHvbEUN+KnadLUJcjCfSdNQgFCntd1lAwJttzWTjKEE2t6OnI9ieoRXBn5LzBiJSfMoARZ6jsej5I8zUlSFwIwW+gdieSdtMPvbO6uarnTKBEoFRC1z0u9JkxgMsfdnd5LsH0W3LS6j5ezNOIpLSFuHPCEBxSlsU/4XBzz0DhVOX6AIQXmpl65EJG9b6VCYju+aIGdYtIpSqj51HVppMEdXqAbugA0tH0lz6QCGxdylCoV5JTHiRh8DR4ayIGdYiut9nHffOua3+lFlO1ZxOA6hoWBNXU8aKoctaOIH3ujj/kuez/6+9I6zKZk59mhEFQr9g/UcsWBmKghKZJCugQRpizgcl1RJJUZaGR4v6Z5Rz6GsjJrrN6GVWBA3JLjSqiXDUVUUKoWHnsFowfEkBFRrPsIha8adEwUjZhOMPg6EIAHVp5CyGkuK4IJVc/nkGavtG7SQj2ni/0TpS0Ytr+tSEk3HLMENQEyPZ2ni8a5B3v7qn3Kuv/3VPxHvGsj3p2PEzh8VoRBNJ9B8LqZ/9RxmfuOCHHAD4Kj0M+vrl1uCG4Bo2p5mKMdTZU7a260KQSRpnZNEl5JIPJF38ncUB6m/YjOOkjISoR52P3YH0Y69R4GbzTgDQfMPxslGsntHUIRgKGa9kBiGZDCesGUaRVNJy9pnwLjZX0cHYhvxBMZAhHR3H53/dTd6Xz+RZHJksu7tRR+MZI45Mn8jJZEhe7vj0aRlLS4gu/syLKPBjUcJsKjoVDxKgJgxyCtDfyRm5B97QgiGhpKWDmUYkkg8aQluAIaSSVRFwRkoof64XLpt/XEX4gyUjKuIItinS/h/2Hvv8EiqK//7cyt07la3WjmNpAmanHNkhjzkzJDTADMEw9p47TXG2D/b6921jQPBxhgHFuMc1hEnMGByjjPA5BmNpFFopc5V9/2jWi211F2l/YF3n/d9OX5kRlVHVadPn7r3W/ee7zlCCAbTKdvnwJSSwXTx+AbQImEqL95ScCy69bwJ4Ma6n/PMpQhpC25GJJ37LkI1Pk78bGFZ/xM/u4JgjZesOYgTQ8qUKUeauGEzbfV3JPj5x18qOPbK5/5IomtiZ20pYSBtX1PKRDKYTjsy0lKGkU/YHwtutIooNTdfj1aR2666854J7KqxogjhWL6B3BhnF05SwlDC/kUIIJMx35fqworAFtyM2NQzYD9fvt/yAcB5j1LhtmdPqEIhoPkcJyWf6sGQJsmuQV64+ack2vvx1pWx9Ovn4q0rI9Hez3M3/7zogzpenGidhjQJaBZo0fxu3JUTk9VUoVBZV40rYM8iCupux4HbifUIgMCRSm9ISdBt30RSFYKQ11Mym18vi9Bw+XbckQrS/T3s+snXx4GbMW9Xzg2pLbsdPqApJQGf255FpAjKbOwekaDb7VgPyWGRzxLJBAaVVh623vQry8ke6eXQF+5BOXAwD260aJSaG7ehRcL5v1GFIOR3O9rtDboxnQZAfdThyXHgZlnoZCJ6NcuCJ1kgR1ogJ1kE5EgpCQTctonfiiII+ZztDrhcGKZJerCPgw8X0m0PPvwD0oN9k+rKDc6d2aWUhNwOcSIEZW5PyfEk2xfjyAMPFRzr+daPyPbGJt5vkjRxVdg/CFKCWwkAgoGOOL+/9ZmC87+/9RkGOxLoSsiRJq4Kr+0KD5Smifd3JPjO5U/SdzBOpMHHurvOzeczPvOhImOngDInfyMIud2OIMCbK5cxAdzcuA1Pa7P13ETHgJxidXKwxgpXiV57YyXo9diWHVCEFd9O2MXlUt+XbuKmpGTPuhERAqoc2Ibvt3wAcN6jnNm01KFzt8mZjSsdKgsLTqlbTepIIbhZcsfZhOfWseSOs0dBzk2/KlknB6DaE2F1xTxbWqcQgtMbVtoCIUOanNO0wrHD+XnNS2wfflUIjqmfQYPfrhkj1PmDnDBlhmPn6ovmLbAdkAwp2bJkvsM2Tzlbb/tMwbHG3Nt43m5FsG5+K/VVZbaDREUkwKaVM+wnSglnHrPAdsI1Tck56+3tVoTg3GXzSjIswPL3huYWmsvCtn6q9Pk5uWWWI8jZ8YUvlQQ3YPn7vNULHO0+ZfNCNJsBUFEES9fPpHF6DUIIVOHCpXjz4MabSyiuranjpvP+BZ8SxCU8qGJiPRDTNDnp3NLNAS0dyRknLLS3WxGctWYeMj6Q355ylUVpPfcGXGVR0v097Pnp3cwt9zKtKmrr73Kfl1PmzrSNb1NKLli8wHEF58L5C4o+l2O3pyJ1tTTeen3+e+z8t28WgBxFCFZUTmFGqDhLckTKdB9HVy21fUEzMVldcSwDHcP57amyBj/nf3cTZQ1++g8O86Or/kp0eK0teBEoTC87FVXYJL2i0OCbT7WnpWD8Gg9urv3u0ZxzzOms+urZ40DO6NhpSpMLWpc6ruBcPHOR49biubPmWfVyPG7UQCAPbkaeF1d5hOM+92l8VVWowQCKu/hnDLpdnDV3tmP5hguWzbffpp7Ec6kqgtNXz8XnLl1TRxGCmXVltJQXrwWUHophpBMEPC5OXznHkSZ+yrLZpY3+B8gHAOc9yrlTllPhDpZcDl8ZncaFzWtZEplWXEdClTvMlikbOHfGcbjC3jy48VRZKyvuyiArv3I+TS1TaK5tRPPpE4J75Pdrpp7FZc2bbQek8xuPZsuUDVR5ykrqLCu37F5VMbWkTpUnyGXT1nJtWykKuEQVCjfN2cRti4/N8wbG60jgk4uO5cOL16ErpSfBa+euYOuiZdQHS++7rmpo5KrlS1k/tbmkTiiT4jdf+4+CYwdyb+MjogiFG05ey4cv3Gg7kHz4wo1sPW8Nml7a7i2nLOWCk5ZRW1na34tmNXDR8UtZN6+lpE55yMflxyzj+o2lOxIriuDDx67l9nWbckcm+hvgU2s3cfOiNbjUiblRWnmY6NbCisoVF2+ZAG4AltbWc/nKJWycWzpOygNeLj9uOZdevq64gpQoiuCqazax7V/PByS60FkSPJHlI+Am9yVc8/nzuOFzV7A2eipLfMeii4kreqdfeyxnX7Ge+qbSeRqzFjRxzrkr2bB8WkmdsqCXjUvq6fj1t/LgpuXs7fjrWmg5e3se5Pz93i9w1cI2WwD7sRM3cP2GlbhtClVeuGwhV65YQmu0dI7Ggroarlq2lM3TZhQcz8ZGwY27ooJHHnmUT51/aQFYHQtyFASfWL6Rf5l/AvnGWmNkJOY/Nu94Lmo+HrdSeuX0pNo1zMws4GdbH8+Dm3Pv20j9wgrOvW9jHuTcctYXCQ6UpiS71CALyi9mUXR7SR0QLKm8nhNqtxYcdfs1/OVuIg0+Lv/Oas5ZdAPnN51ApDbKiq+eia8uhCvsQ/ONTuYn1Kzm0mlrmB6qLHm3OeEarpq9gjOmlp6YQy431y1ayT+vXofi9VK9/coJLwMC+OxpZ/Cj3/yG2muvRvGO3/a3HP7xdevZvnpFDnQUH3jOmT+HK1YtYUaNTXzXVnLZuiWcsmxWSR2/x8XWY5fzobPWjbGgUIx0gjd+eRfPPvhF0sOFW2vpoT7e+fVdvPu7e7nquAVsPW4FfpsV9lOXz2Z6nUMPmfdZPgA471EGUmkO90ImqxZMhFJCOqWxpztNIpvlrQ6DeNI1QSeZ1tjdpTKQzvBuQqHltgtY+OVz8uAGrCaeR7Qa7vz5Q9xw338woEQwxm38G1LQE/exa3CYnvQQ8aycwIyQ0mJuHRjuy+X8xHJN8cYqStxKloTZRcpMY4h2/Hp6go5HzeLWu0kYCWJmO0FPasKevqaaBHyD9Gf76Uz34nanJ+gIIXG703SmeziSHCZNhmKTslAk+4d7GU6n6U+kCnmRlgpCQufAMIlMhs7eQWurZpxOpq+Pl+/8Inv37CFcWcO0s27AFYqSHuixcnFyXXezGYPu/mHa+wYwtOIwwdDgUN8A3cNxhrxmntqb1xGQ9Qn2DvcznE7T4U1heCaYRNYH+9U4iWyWvcog2cBEHcMD3cEU/ekku9N9ZAOj9O4RMTVJPJilIzXMwUQM6TYmTroCcBvsT/TRk4iTzE4sr57tjdHzrcKKyt0PPFS4zSEtFlB3T5xkxqD7YD9aGsYHuJKFVHeKwaEkHe92ocTTE3sbGCayL05vR4yOdw6THRhGmia64spTwaWUGEPDtO84SF9nDNGfRTMLQaWUEplJc+it/STiKQa6Bgs6jY/YhCnpa+8jlcrQcaR/9PhYHSAeTyJUF+5gCFdZlOazR7cwXcGI9XtZlGCknJg0yWpMyMeRWLTd/QP99CTixJXMhO9NYjWT3TfURzyToSebsJp7jokCiQQFOtNDJDIZDg70F3y1ituNGgygRaM0fmg7wcoK9sViaGVhqj9qgRwlFEDxuHPxbXJ4aJCDQ4Ok00pRFlU2o7JvoJ++9DCxlMQYt6UlJWQMlb1D/eg+HU/EbYGbb20kVGNtbQerfZxz7yYiDSEqKisw3KXzTzJGgpQxwHD2EKPFFAo9JciSyB4hlj6CMcZDnqDOxd9YwWXfWU2wxktfpou+zDADGRN3ZYgVXz2LZf9xKnrAnaO3K+wf7iOeSXMknsjl0o0LAQld8QSJbIYDw325ldyJjho20vSnkuxL9YLHQPi8BeBGKpKsN8Ph1ABmtRe1HtDGXUeRiHCKQ7KbmDFMqqYfvONWu4REKU9zyHeYeDZDZzSGGTQmxIkZNOiI9pEw0ryrxciEmRBzhgd6KtL0ZhLsjfeTtnYYC8RUYdidpKv7CAcP7GPnf91FKgdyLHBzN+nBHrLJIXZ3dBAbShBPFWnXIK1LH+rud8xXfL/lAxbVe2RRffaFP/Pdnc9jSIkQJqpmtRHOZke5dJe2LeH7bz8PWBO6S7cKb2SyKqapoArBWa3z+PmBkeQ4iUfPIoQkayhkDA0FwaJoPQfT7Qxmk4DEpVi0b9MUpHMc16DmYWFFiDf79+X6644NfvI2nd6whL92PoOJRa/M5gYvTTHzOTMn1a7n1+2PA9Y8kTZy7R0UA1WRKChsrFrOLw9Zdo8MeKYUaIqJppooCGaFmnitZ5CBjFUbwzRFrmuxtGjrAgKam0Z1Cs8fOWhRzscCGDFaj+782sX89I03MaQseLAtNUvp8pkL+cETr4x+5tzfZvpjHPj+XWRiPYSra6k9/ipcwQipwT52/3I00XjqGdfhCUaYPaWa9oOxXGffcVnQOV6+3+NiZms1L75j2S2yMt8F3epObd381I1z+cVzb1g6hszTOg0X+SSl845awPdftuzGLOyCLjVrKfyUBTP56d43LFMkiAz57u1Ss95Y5lZWc1D20ZOM52ZYrJlXyDy926fpLKqo5+mO/QXL79nemPWmf8RqtHrBxz/JQ5/9LJneHrTyKHXbtqGFIxYFPOfYK2Ys5Oe/finv7xGaqsjRQ1VFsHnRDJ7+5lN5N0pNASEQpokwJEIRtE6v4cjfX6GvMwc6VNXyjSnBsAZ7t8/N3NXTeemvr1s5PULAyJadMTohnPKxc3j45y9imrkoGQlqU+bH8RO3H8WPnniDUqIqgo3rZ/HTt1/GSKXQA+FCBQHZoRjTG+roCQqODA2PAm85EiPWj0fTWNpaz9/37bP8PRZ8j6Hdnr9wHj96/fXRjtPmRJ2LFy3k+6+NjBWjYiYSmKkU7kiEzdNn8OuDO3L5FVZuiOLJUfxz39z0cJQh1xCdiSFAWi8fgtxkbxnuVjVOmlbBsz1vY1jk/TyV2pAib9Q10+bwxL7fko5nCFR78zxOM+eAoc44J7WsJ6b8vKS/BSotgQ10xv+IxCy6ciqEIKg18W4qSH+mGyiihEAVOmnzBJ7u3oGZs1uMswlgQ/hovv/2K7mxZPy1LD9d0LKU772eey4nqqAKwfFTZvDHQzut71ZilbiQWKUwrFCnORhBulIciltlPsgolt5IuQxhFQ08qq6VRzvewZAmMi0gnWvL7TUYWZg/r3E5/7nzJcucLChJ64TpMUGzPt1FLUv4z+dfJ/ehUa1pw+oYrlt2H9sylSee22P1AZSjJQekav0IARXC4Pm7/p143xFcoWi+K/nY3EVfOMqGOa08+tou222xb99wDkunN5Q8Pxn5gCbuIO8nwFn2s6/SnYyXPK8giHq99CbjtlTqoFsjTdp2r1dRTDxu+0ZsAknYa0+zVFAod0uSRcrcj7U7qAXpzwzZ2q3gYzBj2upkDIXhlH07WtOE4UH7dg6qEPgG/QwVe0vI2wPVWT+x/sSE5DkjmeDAQ1YdnFkX3ogqQnmd9GAfu355N5o3QOspV6O6vdag4NCvTwLYM+BRFYEW1hlKlWaAKUIQrPLSnZ5o91jR/QpJl2GrI1UTvJOhfha+so0HN3X/fC3leh19HZ0c+ubdZHMgp/6a69DCYcAaABtjXoa6ErY9ssp6Mrj2DiHtmqAOJzD3HnSwu9hEVCiqphCYM4Ph4dL+FkLgWlhDjzRs7ZblGkNl0j7fQYWMwzAikeCyt1xTFHwenf4SZfzB+sbKA176UgnbsUJzCTKqYe8pxUT12yf0gqSuYmDCy8RYUYXC0vJ+0tKe5TnLn8UtOm3zcHQh0MX4FeNCSZoa+9P2Wx2mhCe7pznaHeuvoSdp7+8ygvTFSzPXwHrGpWI3CgJConscGmki0VRsx1NNKHiMAL02TTsBotkg/QMZW7v1lEB1IucaIDtHS2mMSAExQ1pjmH2LHIWzVs/lE+ce7XBDe/mAJv4/KIMZe9qyiSSZzdoGLEDKzDqynyZD65wc9VOQcei0ayJJmZlJ2e3UBT0zlCbTXfwpynQPYAwnJ67tFxEFQTJjPyCbQCqTLfqgqR4vjVuupumS68AbKmA/uYIRpp5x3Si4Aad5dNIihCCVtR/YTJmLE4f3jbRpvC+0zmKieNwooUC+bopeESGVNdDCEeqv2Y5WHkUNBBBjEiSlhFQq69gANJvMOrLNxq7AvCcRgrRDR2YppRUnDnanDcOZlj/Jr2My4ZRy6DgugWQ268hczJimo90Ow42lIiaulBaTrHSqpwOmTOJEE5cy68i0MibZTdzJbikhaTjECZaOU59YQzrTrSc1NiMcx1yJLLq1PF6SGQeAi9Unz9FuaY2PjePKJIwlZggxsezEBLulZChhP1++3/K/CnCam5sRQhT8fOxjH7P9Gyklt99+O3V1dXi9Xo466ijeeKP0MvM/WqYE7NkqqhBUeQO2g40Aoi6/Y60F1WmpAIvWqTnQOrPSoMwVsgVUqlAod4dQ7dhYQLnLjyFLD8rZoRRv3/pjdv/L90mP5DvkJH2kn93/8n323P4DzEQCl02CsWW3SaXf5+jvipC/ZDa/6vHiCoWJhHxkx9GWXYHwKLgBVG1yM5cTPdIwTSoCflu6vKoIKv2l7YZcnHh81nKyjWiTfKzd4+iois9L9c1X5IvCWXb7UITIgZzrqL3ialTvGB8JQUXE2e5QpR8j60Bv99qv8o2Iy2tfKsA0TCLlfoSNTaqq2MbJiJT7vI7+VicJhL0OndlNKanw+xxZiZV+vyPbMOLy2BamA1AmARSkFHhsEowtHYlfi9iOJwoKHrXCEby4lJDtCg+ALhxWJwFNGPhUe7tBUu31O/q7ymv/7AKEXB5H0DkZJGwi8WsO/sZiQdrFgCoElQH7sRLA73U508QVa4X7wLgyCWOJGVJaSctO0mhDtPhHyP/6Cs5nPvMZDh8+nP+59dZbbfX//d//nS9/+cvceeedPPfcc9TU1HDssccyOOhcH+YfIRfNWGx73pCSa2evsgUvEriybSUupfQAqArBqQ3zmRaoKklLVxBMD9ZwXM0SW0DlUjTObNhk+4ZjSJNzGo9xLFB4TuMGqx9XCZHJLPpglnRHH3s+8UAe5KSP9Fu/d/Rh9MdpVAOc1TrP9qF1KSpXLbandRpSsnXtUsfCc5cctQiPy8bfimDzspnMbKoqOQAqQtBcHeHUVfb0SE1RuPSoJbZvgYYpuXrtMke7r1y8BJ9e2t+qEJwydRYLKmpL242guSzCedPnT/C34vPmi8JpisLWZUvzA6AWDheAG7D8ffnxy+3tFnDWuavw+UvXplFUhfWnLGbWiuklCwIKRVA7tZqTth5jWzRQURXOvmaj7XaYYZhceM5KW7uFEFywcREBj6vkRKEqguPmTGdxQ51tnDSUlXH+gon+LrgfcPWyZbYTjiEl25Yst9/KFoLL5y8h5Cpd40UVgmObprOssrGkTQJBna+MMxpWOdaoOr7mZNvxxMRkcXSLLXgRKLSFz8OllN52EKi0BFfT7J9nA5YEIT3KqfVrHO2+qm2Vo7+vnbfSVkcRgstnLqbc7bX196b6aayparHxN1R6glw0dZljR/lrZ62yjQFDSq5ZvNzR7ouXLaTcb2O3IlhYEaD91/eO5iieU0jMyAz2EQ352LJ+ob3dSE5fObfk+X+E/K8DnGAwSE1NTf4nEChdCEhKyVe+8hU+8YlPcOaZZzJ37ly+973vEY/H+cEPflDy7/6Rcu7UBUwNRiesP4/E1RnNczl76nxOaZxdcHxUEWaEKrlo+lI+Ou/oojpSgk91c9Pcjdw677SSOgCfmHsqV7SeiEdxldS5ZuopbK5dyxRf6c6u6yuWcEz1SjZWLRk1dJw0+qo5tX4d100/uYSOJFxdzl8f+SsNzU2kO/rY/YkHGH7rQB7c6DURpn7uEj5/9CXcvGCd9fZSwu5/XrSRC+ctYGa0ojitCThp2gzOmj+XMxbMLmUSLdEIF65cxEdGSoYXcZRH17j+lDV87MJNVp5wCWd+4uKjufbkVfg8rlImcf3pazl39Xza6ifSUUd0jl0wndMXzeashXNyxyf6e0o0zMVLF3Hb2o0Tzo2IW9O4ZdVaPrPiWOuNuohREvj8yuP50KI1BDV3SV/esnA958+fx9zKquI6Eo6bOpXTlszmzHW5jvIT/AQNFWHOP34x1350c8l9GpdL5YqbjuOGO6+wXXm56RtXc+GtZxEsLz1OXPrp89l8/kqmz2+ccG7k9iuOns3xmxdyxvELCo6PldqqEOeftJSPnX5U0RRUAF1VufmktXzqhI3W4F7M31LymRM3sX3VCso8npL+vnH1Ks6fN4+F1TUldY5qbuasOXO4eN7Cwg80Rq8+EOTKRUv59Opj8sno43V0ReUTKzZw++LjEYgS4S35zJITuLhlIyHdX3I8ubTlGNZVbqDZX5pyPys4j0WRo5kbPrvwA40xKqBVMr/8PJZV3lJSRxEqi6I3srnm6tzWePHAPLluG+c3HU3YVSxOrL+5YMoxnN28mKUVpZNe11Q3c+7U+Vw1d2lJm2r8Aa6ev5zPrihdCkNXFD6xZCO3LjwOTREl7Ib/s+QErpq+hhqvp4AgMlbnupkrOXfaQtbU1he5jqW3oa6Rc2fM5+plpcZvSVXQx9VLl3HbqUfnvCbHaUiMoQGe+NrnGejutMoknLUdf22LlXuTAzm7fnY3W9fP5vKjl1IRmlgYduSql21aSl35e8t5/e/K/zrA+bd/+zei0SgLFy7kc5/7HGmbUvx79uyho6OD4447Ln/M7XazYcMGnnzyyZJ/l0qlGBgYKPh5v2Rvfx+7ugeQ2XGDhAQyCo/t3c+R4SGeeKcd4oV8Y2mCTKm8e2CQff0xfvvWHowBF9IYHeClBDOl0NMJz7W384d97zI46CKbVQq67GazCoODLh7ev4uXevfRFTfJmkqBTaYUpDIu/tj+FocT3RyMdxb9TALBq7G36U31s3PgTVyKOQ7hSzRh0Js+zOFEF3/vfrmojoIkI4fpC6W54r5/Ra+OkOnoY/c/f5d0Rx+umggtn70YJVrGIx1v81zHIWJDmXzX3vG+/O2udzjQG2Pf/l6Uicx1tKTg+Z0HOTIwxLMv7UVPUNhuQYKagsO7Y+zr6uPRp95GT0LBireUiCyke9K8tOMgT7y8GzMzptXwWDFM/vbiLl7e106fmbKYB4WORLrhT2++y4G+fnbGezDG4wkBpgee7DzAkeFhHu3Yg/RQsNIhkZi6ZE86xu5YL7/f9XbJBzeeyfD0oYM8smsP5qCwOmWPvaEBYkjhz+/s4pUDhxk+mEUkxk3MWXD1afzppV209w6w/61utOFxvjTBNQSvvnyQ7v5hnn9yF66EnOBLNS3p2dXHvoO9PPGXN0sWTUwmMrzy3B6e/cubSLcHxm/nqCqKz8dTD7/Kzhf3MZRVC3KBRnS0UIin/vIWnYdj7D7Ui3RpE/yNR+O1He309Azx99f2gDY+ckEq0B4bYM+hHv78+rsTRsoRwJPIZnl290EefWfv6JZnkTnnzzt389rhTnqHEqN/PEYUU/Cnnbto7x/g7UPd+caIBTpZwct7D9M1NMxjb+xBS4kJz4CSgY6OId7p6uaPb76LGlcoWDSRQBbSMZMn9x7gr/t3kxwWSKMwvKUJRkLl4d3v8kbsEO3DqQnjiZSQyer8qX0nvekjHE7sRUz4cBZrbV/8bQYzfXTHH8UjsuMmb4mOgTQO0J96l574H/ArqXEViy0dn4jRl3yS3cPPopCYcD+BxCWyvDv4BO8OHaQ/01/EJusrf6b3VToSA7w10I6iTLRbUSSvxw7SmRjk0e6daBPKLkiEZtJl9rIj1sXjfa9QVhZH0wod7nJl8ZTFeD72Dm/HX2JG1QHC3njB/QLuFDOrOnkn8SRd6XdZUPU8U0K9KGMeKL+eZmnVQdLK7+lL9+AJPU1ztBdNHb2frmZpjvaih56iN9XHU+mX8VXFEfoYXwqJHkoxXH6It4cO89tDb5MulxbrM2+1xHRDvFJBLwtSWVdP40Xb0SNWV3JXMELrWdvRy6y8vKcOd7Kj/Qidw8NWw13GiQqP7NjtWIX9/Zb/VRbVHXfcweLFi4lEIjz77LN8/OMf57TTTuO+++4rqv/kk0+yZs0aDh06RF1dXf741Vdfzb59+3j44YeL/t3tt9/Opz/96QnH3w8W1S2P/Z6fvfNGbrlQjj4AEkZ+Oa15Fv+1c+foCSXnctOiK6pCcHTzVP64/50CHSGwyqnnuoFPi5RzkG5SucQ4ISxqpxzT+dajqsytdbN3+Agj1EdlRGfM03lKYwsv9L1u22dmU9Vinux51rJIjgatIMfORWFBeB6PdO3M/82I3oiOAOo91bx6JEvvm3vY+7H787rNX7gc38wmwNo2q8rUsbOvJ283BS86lu0nl83kkZ27Mcxc8uPIxJOjLQvgtNY2Hn5qZ/5rGEk1EKZ1FVURrGtr5slnd4/abbk5ryOAxuoInYNDJHOsrbEPyogndU2lbkY57x7uGaX2FjjK+ueGFdP4yzu78jRSYebUcvRfAZy4qI1f7drBqOG5n5yOKgTrm5v56/5Ru8eLAJrKwnQPDRPP5OweQ/8VuTjRFYVZ3kp2dB2xSsUIqwOwkFggKGf45oZpPPrqrpy/sSjgknwXYSHg1OkzePRPb9n6e8WsRl795asl7QaoqQsz8NY+4oNWM1Vp5pCuEIgcFVzVFKYuaGbXq/stCrhpWhS8HF1c5BDUmkvW8/fH38Y0JCO1bwCLLp7L91t99iJ+/+q7OX+PvC2Q/2CqIliyqJm/dO4bNXJcEAigJhykV08xaMOSUxXBnPpqXuvotMogjLmQkUxAKo1WFubEGdP5085382UQsgMxhNuN6vZa8S3gpFlt/ObNkfiWo3GWewZUIVjZ2sRjB/eOmj0SA2Po/bXBAP3eBAPpkQTh3PMkYSRfRBWCdW0h3ug/mEt+zdHJ5QhEsfS2Tq/l7aEnMYvQu61xQHBMxVyGU7/Iu3uEuK0gczoqNd7FDKUfy/+tmRu3BKPlK1xKNa8lKkjmGrCOH3MsqxSOpI7hzQGrXEYxmwDm+lbz2wNvj5amGKejIDihfja/3vdW/l5jn2+Rey5XVTfyRnxH/pRhWGOyosgceIJKd4Dmsi4Gs1Y15YyhkDFUNMXElQNFAsHq8hr2x3diYr2kxjM6iiLxa+m83VMDG3m656VcmQ9IpF2AxOvKWCGOYIZ/LT/as2vURxkLoCq6iVCsPMsFwRb+9mrPaDQaubFJJT+2hiWo7WmGc+19MK1xQgqrg73icqN5vKyoqeelPe3Wtu94VJGz+2tXnGpbFHQy8r9KEy8FJsbKc889x9KlSycc/9nPfsbZZ59Nd3c30ejEKo0jAKe9vZ3a2tHtla1bt3LgwAH+8Ic/FL1fKpUiNYZ6OTAwQGNj4/sCcOZ9/2tjBoiJIoCI4iOWSBZdTBwRj66SkYZ9oppmovjss/4VYRIJl6atgxXYdYE4GVk6E18AUZeXYWNowtLlWDFMD3FDsc0xSmY0Ovdl2Xvr98h09uWP69URmj97KXplGaYJ8V77vleqUAgecZO0YcgIoCrlYbA/aUvt9RoKJE3bHAwJjv2opIB0mf0+v6ooEFWJ55gPRtKqV6KXhQvsDkTdHDnSgXC78926x4umKZiY9nEice6PJEEbtl/A1RSFQL9KwoaWD1AXdxHvTtj7uz+N3m1PJSeZgu6Y7b0AhEOvHlVT0FrrSCTt7dZmRYlhz6TKhhRSZfb0V1NlUt3Ei3EEjGSC9vut0gVTrrmeUHllvqFsJtbHoW/fjeoPUHfZ1ageKybCXg8DyZStTUKzCgzalxOQGEEH5pqQRGvs8xtVobCu5jAGpVvIACzwDxNQurDLw3EJA7dSrNjnqAwbLt5N19jey5CCx7unO9rd3V9FLG0fJ0HVm2u4Wdomt57F583YjpUeNUNzWV/J85ZI6j39thoKKoNGlKFs0lavZ7iO9rj92JwecJPq9drOTSID7l6HRrkSVPtpB1URnLZsDp8+71h7RQf57wAcZ1rOf1Ouv/56zj//fFud5ubmosdXrrRK0L/77rtFAU5NjRXUHR0dBQCnq6uL6urqkvdzu924S/T+eK+SdqC2SiBrOhH/LB2hiInbIBOu5iDOifoIhCNjSwJZmbV9YGGkQ7L9TZNdA+y99SdkOvvQqyPU33wGh+74BZnOPvbe+j2aP3spapFux+NFEUxgPhW12yheJKzAbtNEE8X2wt9/EYJ8h2AjmeDQ960JreGK7ehlEchZEe/pof3rd6MGAtRcu7UoyDFME0V1ipNJyCT/fDJLytmss79NIxffdgDnffsqhGOXcLA+m9OTaUoTITR7f0/imSslMpXCGB4i29vD/m/eSes1N0IgmAc3mV6r7oiZSuUBTsYwHSvCGlI6JtiOr25bTCbmgRQXE6f6LiDJ4EQTt8rwKbYgaPxmeFGdSTDEAOfO3eTGbyc3CInTaKJMkibuLHJSz2VGmvmV/ZJXklYyvW08TWbamYTZUlolPP4n5X3PwamoqGDmzJm2Px7P+D4clrz00ksABeBlrLS0tFBTU8Of/vSn/LF0Os3f/vY3Vq9e/X5/lEnJrPJKR5phU1mZLXtCEYLGUJkjHdWnOIM00xR4HeiRWWlQ5Y7aPkwKCtWeSvumnQhqPBFbmnjyyCBvfPTHeXDT/NlL8c1stFZuqiN5kJPt7cdvww4CazBqKA85+ruhssyW1aQIQU1lyBEs2bGs8iKx7b8CFuBqDIdQhcDMTWiZvh4O3n83mX7rjc4ciLHv63eS7enBGBrCLFLsTRGChmDIMU7cDrR1AAQEnOw2TeqjDv5WBHW1YdsaN0JAWZWH4USs6PlkZoCMkUS3YVmNFX+ZfUFII2tQU1tmAcFSdqsK9RUhR7try0KOk4lLTG5aKvNMfH61sjD1W60aQ5neHvZ/605S+/fmwY1eHqX+yu351T5VETRFyvJbcUXtBuqCQUfasgvN0W4pBSHNfmXVlCZhrdZ2rFBQ8GqNOH3BbrXGFtwAeBVpS0kHiyYe1p3sljQHww50a4WmQMT2OtZqd8gRLGdN3dFuE4lfLbPVkUiqPRWO/p7iD9teRwDVQa8jTVzRhWNZAlNCNGjvb4mkra50369/hPyvJRk/9dRT3HHHHbz88svs2bOHH//4x1xzzTWceuqpNDU15fVmzpzJL35h7dsKIbjpppv4/Oc/zy9+8Qtef/11LrvsMnw+HxdccEGpW/1D5dI5i+2Xr6XkIyvW2g42ppRcMX0O3uF40fDP9sUgmeSiWQtZWtlQMthUIVhe2cSZTctLgheB1c7h/CnH2z6QJiZbmk61zdGRSM5vOo6g5iv54OpeNzVV1QTqKmn93GXouToIemVZHuRoYT+L6lu4eOaikpOpAIK6m+vW2FM2DSm5/sTVttsOppRccdIKygKekhOFogjOOGoey2Y1lq6powjmtdZy/toFtnb7PS62r1+JISV6WdhauYlE8yAnsX8P+759F/EjXWjRKLXXb8tXCh5v9/alK4h6vSXvpwrBebPnsbZpim2czKuu5pKl9v72uXSuPdbB36bk2nPW2r7lZdIJ3nztAZ7f+yCpbGGCfyI9wLO7H+DFvT9k/clzWHr03JIUcEVVmDq/idO2birJtBICPD43F127ycq/KWaPkWQ4EeOqC9ZNsDsVj5FNWxVipYQrjltGVah0rRRVEZyxeA5HTS9N/1WFYGZVBZeW8LcejlC/dTt6eZRE9xH2f/NrheAmPDrBGqbkpvWrHYHJNSuWURMI2MbJGTNnc0zTNFu72yKVXNRSmiYusPLnTq0/w3asMDFZWnGVwwQvmFZ2GR61llJTk0BlSvBEpgdXUYomLlCocDdyRv1G2/vpisp1Mzc60K1Nbp67wbEY3hXT1lLnDZf0kyoUjq1ZxLLyxSWBiYJCjaeGDZWnlLQ7NZhhqCvFaUX8Pdw5THrI2t40Mblq2nGORVivmLOSplCZbZyc3NbG8XOnlxwHFSFoioa5fONS229XVRROW/7/k27ibrebH/3oRxx11FHMnj2b2267ja1bt/LQQw8V6O3cuZP+/tE9yY9+9KPcdNNNbN++naVLl3Lo0CH++Mc/EgwGx9/if0ROmzqL+ZVVTKRGWP++dM5CNja1cuHcBQXHR/8tmRss4+4bb6bvq98i0xsrUMn2xuj88j0cufPbXDptNp9ZegKlaJ0Cwe1Lj+eqqZsI6j4rsUwW6kgk/zTrZDZWLWVGYMqEFksj+ifWrmNJ+RyOrzmq4Hj+OhKm+pvZULWCbdPOQI5L5BvRCYcjPP6nR/jtnx/GXRku0NEry5jy2ctoue1ibl91NjcsXEVE9xZ1pQRuW76JU+bOZHFdbXFXAuctnMf6Wa1csH5RCXdLZtdXceqKOXzkwo3W0mwRZwbcLraevooPX7DRAkHjx8Dc77dctJGrjl5OODBxH3vkY3zk1PWcNLeNJVOsxHitLFIAcg7c93UyfT20trZy0zfuRosUe2OUzK6o5Jw5c/nMuqNHE5rH3TCgufinFWv41LqNqFIpbreE/7PhGK5etZQKVwl/S/j4+vWcuLCN5VPq834Z6yOAMxbNZs38Fs4/ZWlxHSlpqPKTSQ0xnOzlmV0PkEhbICeRHuC5PQ+QSMfImHE2n7+Eaz9/Psp45tOIeYrg+i9dyDk3HEekLlL8o0m44jNns/64ucxf2Tr6tzlJG0lefPdBXj/0EA31Hi7M2S2B1HCMN/9yDzsevY9MOkFLY5TTNs3nX07flIuTiTf06jo3Hr+afznmKCvXqoiOBG4/cRNbVyylyu8v6m89HOGf//2LBX9affYFo+Amp3/KrDY2Tm/l6pXLig85EqZGyjlv0Xw+vcnGblXnlnVr+eSKjVZh0GJ2S/jcqmO5qGUNFe5QifEErptxHIsiS2kLzM8fH6sDsDC8ihmh5cyOXE4pCepTmBY+mznRW6FIYrCUoAgPbZGbOLp6K6ootcIqOb72es5oOIoqd5jijoLLmjdzdO1MjqqZWnB87L83N85kU90MPjRvTYnrSKaWhblo+hJunXsKQozv8Gvp+TXBDW3HcVHT2fjVwh6BYG0FKsLgmtYtrK3cTIMnOOF+6cE0P7nucX619RkqhypZE52Vv/5w5xAPb/sdf/7Qw6SH0qyPzmF5dAE3zFxf0u6WYBkXtKzk/xx1tDV+j7NJInFpKh9bvZ5bjl+PrqklhhPJbadu4oK1C6mPlpV819l+/ErKA/arPO+3vO85OJOVxYsX8/TTTzvqjd8bFEJw++23c/vtt/+DLPvvyQtHDvL60CGESyAzYwYKRaLqJj878AqXzF7Mz3e9ZpU8HR//quTl9j1wuJ3OAwfR7riH6pu2oZWHyfbF6LzjHrLdvQD85JUXOeDJks1iUZCx3lhHMvuzWbjvzedYWh+lO5VAQeT3ffMEH6lx/64naAmGeXNwPwKBYqEjSw9r//pPHc9xSu0G/tTxLFlTQRGjO9+WjuCtwf281b+bB/Y8RsbQESKLiszvx2ZNha5kiqfiu3lhqJdkWkEoow02pQS1vIysqXL/zmdZ6J1CX18SoQukJkdZVAZoGZV7n32OGd4or+08jKrlGlXmdmOEYfWN+t3Tb3H5skX89i+vo2chq1vsoFwtcdQMvLOjk5d2HuTBnz2LKynJaCBVmddRspJ4d4LfPfIG73b1YI5U4JUUMLukKfnBH15k/qIGjiTiViM8c1RFCivZ89uPP8/Upgqe7TwEutWFWy+LUHPWBRy47+v5UPjXO+/ks/vezflmJEhGb/hmdxfPHDzAN594Dj2ukNVNi9U0wo7JwNBQmp++8gaHDvahtUvMYC4BNmebNgyuIcH3/vIC66ZMIb4zjitk9VIaYUhpw+AZhB/88nnmlVfy1lMH8HghHRB5KqmSBveQyWMPv8XejUv5zW9eRk1LDNWKfXKgUBiSrsNZvnrnA1x43ukMDB7huT3/ybyGU3nt4K9IpGN43REWzruS11/t4ciBd8hWR6FvEDkwjJASKQQEfZiRID/90XOsWD/AEdWNiARhYBhh5NYifR5keZAf//wlZqyaxvO7OhBBF2o8g8it5mRFhpQRJ9nXx9q162nYcCVS95Hq7+Otv95DasjKeTHMFO929PDsG/u4/5HnUMixrcfFwFAizc+eeZ3O9DBGegyNOB8EoGQl9//9BY6dPY3O3iGEghWTjOqYvX188Yv/WjC2dP7kB9RflVvBMUHNwp9ffodda3r4yeOvoGcgq+eulbufkoa9+3t56p39fPvx59GHBRldIvXROFEykBpM8+PnXqNHSZAdkqALq8P1iN1ZgWIo3PvCC5y2oJX9g0OoioKmmvnxxJQgDZX7336addX1vDH4JuQyaMaOFYZUeDH2IiclDvBO/08KHThGBjN76Yg/zZ7+72BKFchaMSRGx6+0mWDf4E85lHaRlcVZaxJ4puen1HhOpTfdjSpErjGodVYAupD8V/tfmVc2ixdib+HWhdX8OKen5JoiP9nzGrsG1/Prjr9RHkgylHSRzloOVxSJz52mXxzg6e6dPNP7K2aFuzgcD9Cb8iERqMKg0jNMjW+Ip3r+whT3IVaHXmNXopJ9qSgZqaFg0uDuZbq3h8MD3yCqnMBS9yOEqWJXuoq46QYkZaleZN8Qhw6kWb9hDf/03UrmR6O8ttfDw9seZejQIAom0+U+vOYuupOn8WTf72kOpehOeBjKuACBrphEPAl0vZuX+l7lGzt3QCALSQWZsV6UpZDgMkm4EvznOy8hYgpxkbXGW2NMeCsgdfjW088Tj6c50NdvzU2y8FsWKvzn31/mkg1LcOv/c7Djg2ab75FFte2xn/LnQ+/mk3ZHvDkyySsI1kan8di+faNbQmPnLnJL2MLNHz9+O9nuXrSKcqKXbqHnew/lf6+5aRsNTQ100T9mSXXsVydy14KptSpdqYGSOgBH11Wxc3D3mErFhUYJBMvKZ/BK7K0xyL5QR0GhNTCVZ7oPjbnHxPtF9TLePiLGlI6fqCMQVA1VcnhwMP9WMKoxavc6TyMv727Ps5/GuRJFCNbXN/Hci3sLmL9jdVRFMLe5hjdfG7W7mJeiET/dZiqfq1NMRwhBWVuI9r4B63xxd7NwQT3PHT6U/+6yfX20f+Mesr2jzeuC1dVEtm1FjYSLGq4KwcKKWl7e2zHG7ol+qvD6SHYkyeTtHh1tRN7f0KKX0X6kf/T9Lq8zKiub6nn1zYO2/l45u4nnn91d0t+KIpg1tZpXn3qNF1/9NolkX/76Xk+ExfOvxOMOEy7zkuweJjPSb2xkyUCIsfxfahujHD7UlwP2chR0jFlmn7thGq+8eRBjZJtqzIOZTMR45bl7SSZ6cQeitKzbwp7HHyI11IM7EKXthG24/REURdA2rZoXe0frRRX7esv8Hgb1TL6PVIkQoLkyzN6e2ISnKdvfx8Hv3E2mr4dgZTWVJ53HgV8+SCbWgx6O0nTxdlyhSN7fq1ub+Pvb+ybYlI9vIZjZUMWrnWPtnhgnIa+bwVAm34+pmI4AZs9ys2eoe8zZ8XeES9uCHEi8MmbbZOJYcVS0ASMzmj85VuKDWZJDMG3KHJLZseUEJN2HM3gDCv6glvNBiDeTlY79rw4lVrM/3pX/XOPHZoBmz0Ke7t5XcvyW8RQLPdXscHWPWpTTSXcPoPrcuPwe5oYrkMqrBTpWptDoC59fdbMmtANDjm6BjqRUj7Vppq+CZOZtRgpPGXJUp7M9y/bzOzi0P0tVo5ttX2zlno/sputAiqpGN7c+OJNorRuBSlocx++6OsbZRJ5uLxBUqM38ZueYiC0SvAHVjX5IZ3iEbVYiwOd6K3i3o2d0S3timPC5847ntKXvbZvqg27iDvJ+Apx5P/4iw1n7BmIhI0AsYf8wuoRK+kgfh+64O79iA6BVlOdXdFBN8NgnPArFpCxi32VWEwq1wSGy0j6jPaJ7GDaGbXXShod4VrOniac1+ocdEtAMgdlVPPl8RDRFIXBYJe3QcLMy5WY4Zk+hdBkCJSNt2TamCobXfhfXVCBRab8/rykK2SqRn0iysT7a77kn3527assWuh56yPo9GqX2hm1oIyBnnOhZFZHBlt6upEG3Z+yCCW6HepeaquCLW8007SSs6sQH7Gn5ekaiZgx6+vbxwiv35o8vWXA14VAu584wUVPOrEQU++9EVRVkpde2nEAyEePVl+4jMTg6cY0FNyNi+ASGX9jn0Klg2Oc95+yeeDzTH+Pgd+4i09eDHonSdvmHMLwBMgN97Hvg7jzImXLxdeihMAAhl5vhZMqekKYCmgO9XZdkyhyGfyHxNtgHkyYU1jcexMSeJ7w4ECOoHIFxuSPxwSz/esU79Pdk+cyD06ir1/I6R9rTfOLCPZRFVW7/Tgv+oMqw6WJPusr2XoYUPNPbaqujCoXeeDlDJRpXGsNJ3r3th5j9ceb8+xb0qtE0iFTXAG9+9CH0sI+ZnzuX6vIs9f7BCds8Y6VMjbM0uNfWJgFM0bttdTrbJVef30nn/tExbiy4GZHXhmazN+G1zY3qiAXZ3x21sRpESqB32hMShAS931YFVRGcvGgWnzv/eHtFB/mgm/j/oDg2KpukjpSgRSNEL91ScDx66ZZ8b6DJiFPyYf5+tiH939B5v+DxJK8zqfs5KGXTCZLxvqLnUvEY2Yw9QPy/kZH3iGwsVgBu6rZtw9PcQt22bbgqKsj29HD46/eQjcVKXseJifH+2j0ZJWc9E0ky2c+bO39ScPzNnT8hmYr9X9tXVIqkTI0XjzfMnPUXFRxrWbelANzAmJWtf5AobjeqP4AeidJ85fV5tpQeijDl4u3o4SiaP4DiGtvBfTJP5j/U7CIyCYsKquSNSmLIpL8nS9eBFJ+68B2OtFsvjCPgpmN/mv4eg8TQyCrL+/fJ7Kw2EmmysWGSh/t4/aM/INVlvRGMgJvU4RiZWBwjnppUp/DJUu6dpLpO44YvthUc2/bF1gJwA5MeUnGMlElcaDI0cZjcXPh+ygcA5z3K0qrSzerAWlKeFXWmkrdFK0h299LzvcIk657vPUS2NwZAudvvTOs0hSM9MitNpvjqHWiGgim+Okcq+dRAtWNNnQqPx7G+g1AlUZ+D3abJ9LqoIwV8alNpf2fTCd75y7fY+cg3iA/2FpxLxWO8/tg9vPnEfWQzCUJejyN7QphQ4ZA4lzVNZlZUoAphTWiBQB7caLkkUneknOM/cztaNIoaDKAUqdukCsGMqqgjTTzodzvajYCKsH11uqxhMnVKhb2/FUFrS6UtbVlRBBVVKs+9/C0SyT68nghLFlyN1xMhkezjxVe/TTIVwx/02FK7R6SiMmg7JhtZk6nNlag210qn+nn7ycL+dXsef4jU8CjwVYRgWlW5YwPUgK5bCcYOUhsKTDBb9Xipv/hqGi6/DhEso626Mu9vC+RcR+P5o0X+VEVYVFsbkxQhmFpZ7kgT9ysuNCe7JdR6ymyf3qw0qXa1ONKWg662oueitS5ue7CNqkY3nQfSfOLCXbz1wnAe3NQ0ufjcgy1U1FoJYH5Vs0kwHrmfpMYTsbXbkCYzQ9UlGxO7KkLM/LdLCNZXkDoc482PPsTgGwfz4MZdG2b2v2/BU1lGhavO8YUwJUMowrlTuEudgl2Ad7anuOsjhdXM7/nIbnoOj+4SCFRa/bW2qzcCwfRwmaPdLq/qWHrCBBorymyBjmFKFjXXlVb4B8gHAOc9yhVty2wHElUofGL5RlsQZEjJJfWtdH/tm/mcm+oPX4dWUU62u5fOr9yD0RvjynlLObZxui2t87jGNi5uLU4jNYaTZLsHqfGUcXnL5oLgT3YNkhkafUAUoXBF65m2NEMTk8tbT6TGE7GlkW5pWcOx9W22dm+qm85Vi5aUfKwVIagJBPjQcWvst2eE4Oaz15ec3MxMikxiiKHYEXb8/Ztkkta66gi4SQ33kkkNYWZTnHfSYjYtm16yVoqiCNbOb+Gy9fZ2V4X8/NN6q1SA4vVSe9VW6rZtz4ObEfnsGWfSdNP11F57VfEif1LyodWrmRIpXbtDCLh4+UJOWDijNMjJJFlQFeCS4yZWE08PxzDSCRQhiJb52HbeWscJ/rrLj0LXSw+AieE+/v7I13PgppzF868kHGpi8fwrx4Cc+1m3qZmjjptX2t+qYPHyVs65ZHXJCV5RBOFyP1uv2DCafzNOkokYLz3zTQb6uvAEo8w68XrcgSipoR52/uGePMgxpeSazStprSq37RS+ZfVCTpk305Zqu7K5ka1rlhU1W/V4cYcjRHxe/um4Qn/roXAe3IC1CHLLievx6KVr2JhSsv2oFUyvipaME0UILlg6nzNnzra1e0VdI1vb1pacAhUEYd3LuVPOciwpsbrqGjQxrtFaTipyIKepuYaO/Wn++dzdBeCmsm4EGChMLTuLeWXH2NLEG32zObvh+JJ2CwQBzct1M06wfUHTKkL87Pe/xlMbIXU4xhv/9GABuHFXhZBIzm08gSbflJIgTyBYXXE0LcFTbOxWibrnUR/eTqkA72w32H5+F4f3D1LV6OZTP5pFVaObrgMpPnvhjjzIkZicUn8hXtVTcsVXIrl46tHMj9bYxsmWGQs4Z+E82ziZV1vNNZtWlFzJFcKqu3Xy4pnFFf5B8gHAeY+yvraVtfUVud/GfrvWcuzVc+cyv7KWSxbMzR8r1IEFPp2PX3gpqa7uXM7NtXimNlu5NzmQ0/W1b3BceRW3LF6PVSZk7LWsf6sqfGTxOi5oXkm521twD2M4ye7bHuKdj32PC0JzWRKZyZxQCwCJrkGe+dDPeP6WX+VBzubaNcwINnFizfqi9FCAGYEWlkTmcPXUEyf0chn5d1ALcE7jWm6as8FKpxtzrXwOqRTcPOcoLp6/iHKvr6grTSm5ZdU61sxoZklLfcnv4+yV85jTXMO5xy4qet7lD3Pq1k/R2trK8EA3rz56NwM9e/Pgxu0vZ+76bVRU1XDeSUu45ozVKKoo4m0QimDbOWs5f9UCyst8xczGRHLDiatZ2zyFFc1W12LF6y2ocyORnLtwHvNratl61CZEiTYN86qqOaZ1KrdsWGvV+ZkYSpRpbq5YvoTrj16FLgXjHW4kE+z58Td5/K7PsaI1THXe35L0UB9v/+Yu3v39vWQTw1y/eRVL501h2azGvM7o/azrnrJuDrOm13L2mUtLRDdMb2ukqameurpGFi+8Erfb+uwed5hFOZDj9gY5/8J1XLT9KIRPK+pvqStc9qFj2HzGEiKN4aL+NpBcdP0mFi2cwpIiNPFksj+fYNza2sqtX7yXQFWLlXszBuSkh2NMa6pg49Lp3HTS2lFW27gMYb/bxeVHLeW6o1agj9DExxsO/NMxazhn0Txqg4HC6+T+bUrJjRtWsaylgXXTm4vqIOGUBTOZ11DD5WuXTtzxyf17emWU4+fN4CPHrJ3YHy33X5+uc9XaZdy4bBUuRS1ut4RbVq3jrCmLqfXk/D0uBEwp2d62kbZgG23BJUV1pISF4bU0+ttoLruy5FhR0zCXBx8o3MK86YsNVNa58jpZQrSWXcmqiguQuIuOJ4ZUWFd1JZuqV1DlLqeYSCTnN57IwvJmjq2dnj863uEnN8zi2Hkr+Zc7P1nw99NuOQl3LidndlmI42oXcEHj6WgiQzGHl+uSk+s2M7/8cvz5buKFDtdFlmWV11LhO5OQ1jjBpq7DGbaff5hD+9O0trZyz88vY8biALfmVr/GgpzmwCZqfXM4ve5EipXwAKh2V7O2YjkfW7TRyucqEgMeRWP73FVsW70Mt1o8TqSUfGTjWk5ZPIumaFlxf0u45pgV+ByKi77f8r9GE///ijzb+zp9yms0V7roGfIRT7kQAoKeJOXBOI/H/shxsTn84sjfCVYJUsMuMgnL7arLwBNIszs7jDsSxF0Tpe6Tl4M/gJky0aJl1NxyNR1fuhelzMcvOt9kV3sM3ZdCpgXZjJojmUg03UB3Sb70xp9YVl1F3BhEV8EwFUwJZiJFtn+YdEeMbadfQNnvfshbA7tJdg3y7Id+TqLd2l824mlcARe/a3+cDZWL+K/2x60sfjE6oUqsislvDuzjyZ5X+eqOP5A1NIRioOSUpLTu3ZNN8p97Hue59l6yGYvyK8QYXpYpyEr4wsuPsNTXTG881215HJNUSMG/Pv4YEenmhT1jWVuF8uOnXuXkeW386E8vldTZ25vhs1+9n6suPJv4QDevP3oXAG5/OXM2bEMPhBlIpfjP3zzHzt5eMrpVYF7J5gYHYfX5yeqSO37+GAuXNNJlxMEDIo21XitAaiBd8B+PPEGk3MeTnQfABSJLvuu2VC29H+x8ldNnzeL+V17I+3i8vHqkk9+98zZ3/PZx9ARkc/2GRui/agbi8RTfeuw5unb2oXebmG7IekCqEmGA0pfEGBriwGAPa9asp3nOJXjCEYYY4O0/3UN6sAdhStydce771t+oCgV4+dm9qCqYusjTm0VWomYkv//tK2w+ag4P/fYFTLdAZGW+e7VUwNQEu48M88+3f5Vv/uRR+uMq6YEsetwAU+IKRpiz/lpEyMcv/raTjp5B+us9qDEFVyyDyEqkKkiX6RgRF1/58eOsX9jKQTWNUuVGH8igpE1QBFm/hlGmc/cvnqSqMcyTb+9HBFXUpImStTwqvG40bwC3Krj72w9x+4+extRBD0ZoO2EbO/9wD5o3AB43Ow/38Idnd3LXI09b4TgOJCBhKJni3j8/Q2dqmGzWmBi70vrDf/v9Yxw3ZzodsVzCrlKoo0j4yp//Tks4zBM79uacPObLz00mv37hLc5ZMpdvP/IcwoCCjgQWouadwz385sUdfPOxZ1GzYIicXu4awoBENs03/voMh5LdJDt7EOGygmsJE4y+GJ/5/e85a/08DgwNIISSq/OSu50USFPhjjceZV40yNM9b6EKN24li65YQZAxVVKmzl+7XuCoyh389cgvQJZTpibwKSkEkpTUGch6OLzvED+46tyCmL/jwwf5Pw9OpazWSyzrY9D08WT3D2hPqnQkvXhUgU+1Oo+bUhA33CQNDz858ANmh46lK1W4DT1WfrD/d0zx1/PywEuEPQqJjE7aVC0auWLg1TM83fcsf36jgS/e+KmCv931H79h6R1nUdeogtLBkz1P0Bf/JksCBzicDtKZCZGRKl4lQ40rRrU+xOu999GiHaZNP0iP4eaI4SclNTRhUqEOU6kmGey/FS1wESH5Li5FYdBUyKAgkFQFJFUVAk1o/OIPX+Vd5ZO4pKCyVufWB9v47IU7KYtqhAKSjuHfc2j4XH588PcYUkFgFo7fUnAo2cVfup7ky8+9YzXPLBK7iWyWr7zyBGqPSjqTLRrfAvjCnx7jovnz2d9dPNNYCLjnj09z9op5BL3/mLZJRe/7AYvqvbGoPvHq13m9/92Sy7MKgmrXTJ7v7ihZOVgVgjqjjNcPH0YvgoAzPf0oHjfl4TDDRtx2x1QgaSgTDGYnJsqOTY4L1Zcz91+O5uXPPUy8fQBfXYgVXz0Tb+6tREHQFmpm58DeknYrCKrdDbza12djEfgUHwe6FVu7kRAeDBNL2rOfFipV7GrvLrltogjBkmgNb711uGRCm6IIWqrLee3553njz3fmj8855nqClc2jdvtcxFxZ2wRaCbineulL2CcmT5tWwY6+IyW3M1UhWFhVw8sdHaXtFoIZvnL27bb3d0BzoexNl7xOariPnQ9bNV88vnLaFpzHzld+RDLei8dXzvwV1+DxhgGY0VrNrj1dJf2tKoK2uXW8vsvGbkXQ0FDOns7Skw2A16OTSts3v0RaOU+9/faMnbapVbyz/0hRu7PpBJhp5i+exSv7OwtqbaWHY6i6G9VlVYtuqAvz7qC9vz0ujYTLvlGuBCqDfo4M2bMS51dVs6Pd3t/z6mp4dd/hknGp5NqV7O2L2d5LkxneeehuskNDVj7YmAKT2T6L6acGAiz8wjX0aVnb5/e0qW7aU7ttxkGFleUVDGVfohh8jx1OcN/lz9J7IE55o5ctX5jHQx97jd4DCcobvWz77jLCtRbLUuBmf6LMfktMQtxo5YhDAnurv4V3hg6W3KZKHxnm5Zt/TuxgL8H6ABs+vY6/fepxBg8NEawPsPkbJxCsCdDq89OgP297L5dQWeY5ANg39/RpjZjGIYr5aWDAZGgIMnWb6Ei+zdi2Fj2H03gCKv6gikCl09jEn7uHbLfpvGYtj++yb5Hjlip6u54vO1FKmtUQh3sHbO4HHzt9IxesXWh7HSf5gCbuIO8nwDn77x8mZdrTxIeTlfQ6dKyVhotMVhlTK2aiCKwieXaiCJOQrzQlPdU1wFsffYjk4Vj+2HhwMyJ+1cuwYT9xJzNeElnd1u5UWmVwyIFHawjosUf2mqLg71DIZO2pxBVJF/EBe1q+MdTHmw/fQ3JotA6NOxBl9qZtuHM9XAwNsv5J0MTtGxtbNPFyScq0tzukuxks0oNqrLiHFVxxxTbRWE1IvPZMU1IDfbz9x7tJxkdBx3hwo6oKqqKQtqFbA3gjHgZT9s8AmgCXMqkmmLYiQXFogK2pCopLIeVgtzviYTBtb7fhBrzCNg/JVMG0r3BgDfoO+dOaouA2FJIODQkDuot4Im0LOKRi9RCyszuV6GP/A3eT7bHKE4yAnBFwM3K84XOXFX3xytstFBbXd2Jg/3LSFojjUfoYn9Ta35HgW5c9kwcz27+7nLJaN7HDSe657LlRkPO9ZYRrPCQMna50aXvAKkK4P158e2pEVKEgcZM0isdAsmuQ5276GYn2foL1QTZ/43gCNX6GOob53bV/yIOck755Am2NSaZ5e7BrJhpSksxzd5Y8b4nA45hnr/JyuoGkae/vZwYXsDvut23J09kXpL07aqsjkgJXlz0IUgDNgSauCMHmRW386wUn2is6yAc08f9BcWSrTFqn+LbEWJkMEnXScVeFmP7RUwqOLfjEcRPAjWXT5D7b+4OQJ3eVydAR7RoogrWC8UYO3LgDUeYcM5pk+uZf7yE1HJuULf8dsWMZjYginAngQogJE8T/jbgDYdoWnFdwrG3BeXlwM2qT87WEIhy/F8eOxe+jSCYfu05qipjYFqXoDd8ncYpdGLHbgd0HjnbrobAFaqJRsj09tN9zD8k9ewrATd32bbbgZvR+zlOJRUSYaLfbr+Evd1Pe6OXq7ywnXGu9DIVrPWz77jLKG70Eyl24/WruXu+fw+3YnarPhSvsJVgf4uRvnECgxmIdBmr81spNfQBPuRfdr2M1X7C36/2zWkyqVEQpfxdcSeA8nkxiDJjMoy0Ek2Ibvp/yAcB5j7I0MgfVoeP24miTbUCqQmFJtNE2m18ADb4wmkPzNBWVWht6ZKprgLf//dcFx1753B9JdA1OsHt2qNXR7oWRJke7mwJBKwHTzm5VoanMgY5qmixurbelLQsBC2bUl7xOejiW354ZWbEJVjZbKzdjQU48Rm04iO5Aj9SAKZGwo93La+odywksrbWnUKpCsKi51pHVVFEZwGXDagLIJGPsev2nBcd2vvIjkmM6fhuGybw5DY60/AUz620HOFURzJ9RZ7/1BETDftwOHdwVAc315fZ0VMNkQZt9nChCsGh6naPdC6fUOtbuqPD78DiUn1eA6VVRW+CVNU0WNzvbvaSl3tYmVQgWNtU52l3u8hKsrCoEOXfeWbCio4cjtIWqbYFAVppMD8xwLDtR55tXdIXDE9S5/JtLufq7q5jVuqhAJ1zrYdv3lnHVvYvxBq1VhDLdh1uxXzJTBLT6623tNqTJ3LLWkkxRPeBm6b+fwXUP3IKvprAURKDGz0nfPIETvnYMnoCHsHseThAmQyVCOPVMlGj6POyn5izV3oUISj/jAoV5Za2223gKCourqh2BV9DvIuixX12XAmY3VtvGt2FK1rQ1O9zt/ZUPAM57lNPqN05Y3ssMpUh0DSEAn+rhpraT8WkuBFZ5b2O4cGlRSslNs45hVlnpAJHAtTPXceaURSUfWgXBWVMWc1nrxqJBOzYHp7G5iVV3nYOvLkS8fYBnPvTzPMgRgFd1s3XqmfhsaIamlFzZupmZodL1ciRwxfSjOG/qwpLXURCcPXU+25evKPmwKUIws6KCm49fWzApGakEmcFY3m6fy8U/nbOBgM9NZkxn6Px1dDeaJ0BD4xROvfw2vMFcHRp/OA9ydHcAVXNz6SnLOXPN3JKTqSIEJ6+YzbZ1y23tnl4Z5aNr1tnuTXs1jVvXbiTk9tjSf29eu4YFjTW2A8lVRy3nzI3zS9qdicfY9+h9DA0eweMrZ8GqbXh85STjvbz6zDdJJmIoimBKY5RrLt9Q2m4BLrfG9VdspCzoLbmqYJiSq89by/wZdbYrFJecspwzj15Q0m4hBMeunsllZ60snX+iCBprI2zfsq7kfQTg0lVuPn8D4YC93dtPWc2S1npbf1+xcSkXLF9gWyrghLkz2L5hhW1+VVN5mI+csK7kcyIAl6by0VM2EA34Sq6uGVJyw/GrWN7aYGv3leuWcemiheiRCFVbCguMVm3Zgqu8nBNmzOD62ets8/Aa/WEubzndFnSqQuOU2kvxaxGKLQl4gjqhGjfrKi+mybeoYEUoXOPJgxuA5dGzOaqqdDVcgWBB2VLObzqxpN0CQZW7nK1TT7MFQZ6gj+tXXE1YD0/4XvzVflwBFyYmx9acR51vpe1K1szIhZQFtlJ6SUTB5zmeUPCfGF/teayOotYzvfwW23sJVDbXXUq5a6LdI2JicsnU49hY32o/nsxdxmXLF9nG91HTWrju2JW28V1dFuCYedNK3ucfIR8AnPcoM4KNbK6ystwFksxQimdu+S+euvHnpLtiXD6lkTpflK3T6zG6+9j1se+z+7aHMIaT+b85qcHF7HAt182Zh0sd2Q8upGxMixhsbpjBxdMW4ndliur4XRkumraQTdVzqPHqBedSR0bBTe2Ueh7/22OsXr2EFV89YwLIkUg2VS+g1lvBUVUjb1Ry3P0k0wJ1TA81cd6UlWPeugptCrs8bKqew5bpC9HUIjQUQFElF8xYyPHTphEOuHNnZMF/TUwuXryQWfVVzGytQgLZVIJ9P7mXPQ/dRXqgDxM4Zsl0GivDLJsT5a0/3M3bf/4WmRzIkYDq8nLcNR/n8ccf45ILjiE70owUC+TMOnobM4+6imB1hE2r2jh9/TxwKUWsBlOHszYu4OiZUwmHPUXtNoTJBasWMLuiioUN1UX9KJGcOHMazeEwZ8yalR+UC68lmVFZwaLaOi5atWhiv5fcfwNuFyfOncFpG+aNFjAbo5MejvHWH+6mr7uDlpYW1h97E2WRZiv3ZgzISQz3cfpJi5jaUsWsefVFrLbyHNaun0FDbYRjTpiLmbe0UK+hrZI5bbWcccpisqocbxIAeoWLY9a0ccqx85C5rYjxOoYbTt+8kLVLpxKq9U/QkUBWSE4/dSHTmiqZPaeE3cCaldNpqI5wyprZeV+Ov19zbYQF0+q4YN3CkgO3z62zeeFMzl4yF00tHicSyQUrFrBhRiuVZRPtBguUbFkxn2nVURZOrStp9/rZLTRFw5y2Yg75Nlvj9KZUh1nUXM8FqxeNiaVCXa9H55RFMzln3lzkYD9dDxUWGO166CEyfb1ctHAB62umUe2xch3GUrLBAt1bWpfS4KulyTO3KG3blNAWWEy1t5pG3xlkTFFUL2POpME3n6nB8xjMusbdx/pvLF3JtOBxLIlsIp4NFLUpntVZGjmJRZFZlGnRCToWlVxybPV6Gr3VLI82j/HeWE9K1lZOo85byUk1y1DIFtVr8/uZGZzJwvCpuEXx8TuiwvTgsYR856JSfDVEQRIOXI7LvYGEaCpht4nivYSA3gz60VbD0wn+Fij68ZS5Glkd2UjGZIK/AdzUMzfUxiXTl5Dv2jMuULymzlmtczlj/mw8I8UVx+lIU3LhkgWsmN5EXSQ0UUeCaUrOXjHPcUX8/ZYPaOLvUfYN/pao9jinV7l5O17N3piCERsm3j7ESzf/hN0Pvsyu0CJe2f0QB259knTHMKqQhIw+6kIqzcEeVDXDi32P8ONDv2JOdZLeuJ/ehA/DFHj1DJX+IYIug1+0/5pX+w5QF+pnKKPSn/CQNVU0xaDMmySgG9y7+4fMCE5BUWJEPdbDnjUVlICKJ+JBFSGWfXUzu9wHOJDYQ7TOw9qvncYTN/4KV8SLL6Dg0zI8euRxFkfm8nDnE6hiZEKz+IECq9vunvgB/tzxFF9752F01cCQAtO0cL4QEkUxGBrs5ctPPsROFBTdQFXANKwBzuiNoQZcqB4Pn37pdyzwttIvE5geicgKRna+TM1EqJLPPvNX9IzCy0c6IQBmMkU2MUSmv4e9P7qb+iu285PX32BO0Msdn7ie9GAPUkBWplA0L1KzJsl3h+M8d6iPr/3y76TDAiUFakqCBC0SJusW9GsZ7vrtk+zo7yEdMJEuUJNWzxUprOsIl+TT//UXFi9ooEckMAMSJS2sztUCDN36u889+TdcfoUXYwfBD2QU8rOTKkGX/HTvaxzbNI3vvvEiaNaggcyBmxzNd0fsCA+98Sp3/9dThavhYwaTRDrD1/78JF1v9IJhIkzL3pHzquJG9wTQNZWrrvsCf3p0HyDxeMPMX3ENrz7zTXSXtYL1je88ijfo5pV3D4NXQclKZM5uqQqkLvjD33ewbt0MHnj8RWSlgpaQqCmJkGDogqxPsLO/l58+8Sp3Pv4Mw3UCdRj0YYkwLZp7JijAa/CVPz3Job4Bhisk+ASuIZmnQmcCAtMnuP2//sKm1lY6SUJUoMWlRd8XYHgEhhfu+N3fCfk8vLCnHXwCNWNdx4olganB71/cyaYXp/PAX14AhXxNGQmWvwXs7erjp397lW889syEsgUjkspm+dofnuBwZpgspkW1Nsd8JYp1vU/95i8cM3saRxJxTM2iYecn75zOlx/9O1Gfj2f2H7TKCRjkX+RlrgP573e8w4lvvsO3//4c0gXStPQkWJ9Dgb2xGD985mW++czzSDdII6eTi11TgwQZvviXJ9jTs4/9X78rvy1VuWULRx56iGxPD4fuvocPl5dx7jHL6EqMsnHGT5Rffv1RmkIenuzeiyIC+LQ0LtVyeNrQiGd0/hR/i/VVr/Dg/kcQNBB1DRHW4yhIhg03R9JB0maK3x9+lJ8dfJRYuoly1yDV7gF0xSBh6BxOhhnK+vjOnl/RkzLYOxjCo7mIuOK4FIOsVIilfQxlPPzHjp9xXM0S2uPDIHR0xbBKXQBZUyVjKty36480+MrYMfgaYZcgZahkTGsC1hUDt5rllf4XeSn2LK/0PsB0n6Q/62Ug60Ei8CgZyvU4Gh280vtLXKkv0ap3M2C66De8ZFFwCYOIGscnDNr7P09ExHGRwYQ8XAJrIlYRDMb+mYz3QnqzXWjo+IWBnntxSEiFhFSg/6v0Mp8X+negiQYq1CECqvUSN2h46ckGyCZep87/LF/f8QSmjBB0p/DraRQhSRka/Uk3WTPFg7uf4v4ndqAMq5iqiZGNY6ZSaOEwIq2QMSWff/xvaDFB4kg3UncjAt7886AYVomDz/zqL5y/aD6HewetDzW+VALwjT8+zdkr51ERsq+g/n7KByyq98ii+vPBi+lL7WDskmJ3e5pPX/g2nQfSVDe6uepLJ3D3P/2JvoNxIg0+Lv3OGspqRllFAoEQTewcsmcsqbjptydjARKPqpM2JypmhlJk4xm8VQEavBGOpHryqwTxriE0n44rt4KioFDjqWfvcGfJfVyBIKRVsnuoeDO+7HCKNz/+EzKxBLW3X4FeUTZqS3c/B2/7DmqZn/pbL0bxeVD7gySy9gySqUaUQ70D+TfqTH8fh759d75ZYe05F9Lzsx8y3NOFqyxKyznbcQUjBddQBNSEgnR0Dxa7RV50l8qwx6n5o0Rp0IiXaNg3IlPqguyPx0quBKhCYbqvkne6e0rSjQXQIEL07LenGntMBdeB0nZn0wmMTJJqtZxEotDuVCKGqrnRdC8CqGmNcqirv2T+jKoI6mZV8E5vb8ncICGgoiLAoZR900ZdUcg4tKFAQth0MZwszX4SQEtZhINdMVu7W+qi7OroKakjgGhFgMNJe7tVTZD02g+jEvD7XAzl2GZGMoGZSuV7T43crzUcYdfuvUiXq6CC8Vi7p5WXs6uzt2QsCSAa8tOZtI8TY6ifffeP5tzU3Gg1ec32xej42kiicTlt/7qNVLh0zotAsKzOzeFkV8mxQhUKbaEIR9IHbRk7IS1Ed8reboHCYFq3uYolQc1btFzGWLsXlPs5kuqwpbcvi3jA3IEdQ6rBpTFVf93WHgWFGnWkEGBxkRI6qCJrxmyv9Gr6WPYnum3t7k0u5InOjK2/g9ky2vdbb0BmIkHHN+7DGBwqaPirmAJ1dz97HrgLzR+g8byrJ8amhKjqJTZc2t+KENxw4mquOma5zWdzlg9YVP+D0p/exfj90oo6F596cAbVjS46D6T43Lm/KgluwJoku1MxVGG/fJcsAlqKSTFwA1bSnLcqgCpUetKFdE1fVSAPbsDaEupK9jmWX+9K9pdMfDbiaTKxOMnDMQ7e9h0yuSJQI+Am09mH0T+MmUyBKRzBja4oHI4NFgzselmE+iu3o0eiZPp62H/v12zBDVjL3Z2xofyWQilxonWD9cbsBG40RaE9PmCb9GlIk0OD/Y61VLr6hxz7B2WT9nZrLi9ub3gCuAFwe8Noeq7vkarQ2T1omxxsmJL23gHbxGcpoWPQ2W5HcAMgsQU3YDE1OnoGHO0+3GuvM1l/Zyb5jjgW3LR//14OffsuMv19BXbv27efvd+9k4MP3ouRnDhZGKakPTZoy0iTQNfQsG2yMoDp0VGDgQJwA9YqZs2N2/J90eIOxWdVIehK9dqOFYY06U73OIKSvvSgbbIyQMacHI/QDtyANeH2pnts7TYxGc50YAdKAJCdYJP0C6AVrNmUuAyKA7gBEHSn7f1tYnJg2P4FDqBnKJnPvzFTKYzBodGGv7k6SpnuPvY8cBeZWA/Z4SHM9MRSForAFtyMyLsdPY4676d8AHDeo2ii+H5qRZ2L67/UXHDsjH9dPAHcjF5HdaTRToKtNymRUjqCKYFAU1RHOqKmqCUfWXdlkLlfPB93TZhMZx8Hb/sOiR378+BGr47Q8JnLLRrqJLrxmlKiFwElelmE6rMvKDjWeOIFRcFN3m5Vce5sO4lRdBJmI6V0nCQFoCuqY1NSTXG2+/1qtiwBTXMeIlya6kjL1kWh3UYyQWYgVlQ3MxArOrkDk6OswqT2+jXV2W51MnHy3xQzlcIYGiLT12OtPuZATibWx677v06mrwejxEQCoKuKo92a4kxvVz1eqrddVQBu8n+fAznV265C9TkU+QE0h+aXALrQHMcTRSg4wZf3axwEHJt2AihCx2mqNKVK6cRgS+QkLBcjZdAdtDSH8RvApSrO5QQU8vOOFg5bKzc5Rt3hr99Dcs9e2r9xD5lYD3o4ypSLtqOHwhOuI+UkrBZWUcz/SfkA4LxHaQgcW5Su192e5s4P7y049ouPv0h/x8SBW0FhUWS+Y+fX1kA9bsX+dcqtuGn2N9gOJCYmi8PzbN+UJJKlkTm2g40iFFZXzLSliXuqyjjpnhtwVZeT6ezjwCe+XQhucttWXl1nboUDzVBKjprROoFunenvo/OnhZ2hD/z+B6RLVKBVFcH6OS22b+9CWLRev0PvFI+qMb/K2e6j66fZ0sQlsHFKq+1ysioE62e22E64AmhujOL32tvtcmvMaqu1ZTUZhsmaxa22OgJYO9veJlURrJ/RnNcxkgkO/Ohe9j14F5mBvvx1plSEcafi7HvwLg78qPgKhq6pLGipdaCjmqyd3+Js97xmR7vXtTn7e0q4jDKvPQjQFYUljXUoQqCXhQtWHQ99+24S+/ew7747Sfd2o0eiNF5afCIRwIa2VvsGv4pg3bRm2xcmAUwJlhGNlE8ANyOiRcK4/AGWVTTZxm5WmqyMzrYF5wLB4shcZ9pyZJYjwKnxhAnrAVsdVSgsCk91pIkvDM93tLvZv5KxFYMn6qgEPUfZ2mMZVYeiVNqqCKEScq/GfjUoy+xQIdNsok2Co6pn2I7NqlBY19RUAIK0yDiQ8xVrC9NTXpEDN8VfGoUiWDmjyXbV0DAlR3/Aovp/l0wv24IYh6bH5uDUNPn469/+QLQxSN/BON+7/O8TQI4iVDbXnsf8sjklgYlEcnbDqZxef7StPafXH835jZtLDhICwaLwLM5rOnWUZVNEJ+qKcGnzmVS4IyVtUlG4pPkkVkVn2tr9odXnct2XP1NwvObGMwtyci6btoKbl6wpTTME1tZP4Z/Wr0FTR/09Pgdn/oc+SnNLC+n+Hvb85O6iIEcRCtdtXs2Gua0lqa1SwrbNq7hy3cSO22Pl4tWLuXmFjd1CsKqhkVuWrEdX1KJeEkC1N8C/LN9AU7B0LSBFCG5evYZjZk8tbTew/ZiVXHKK/T73ucct4ooL15bOPxGCBXMbufqCtSVr6ggBkbCPD527nsbKMlt693Wb13DsnGkIAWY6RTY+RCbWw74H7yYz0IcEzpvTzKEfWm+L2fjEFQwBXLhqAdtOWFU6/0QIFrXWcf1pa3CXqE0jBISDXm46cz1NVWFbu7efsorjF8yw9/fxq7hmbWl/C+CCZQu4cf2o3eO3Vg9+y1q5mdLczIyrPoSrbOJEIoCwz8tHjltLS0XElpZ9w6bVbJ7bZmv39etXcf2yFfZ2z53Ph+ast3kuBQvK69g24wQ8anFQLYCg7uWK1tNo8NbYvnyd33QSG6uW2epcMGUzl7QcY2v3yXUruKz1ONtxcEawgYunnIFbLV3jxa/5OLHuQqKuZhubJIsrrqDcfxZ26xi1ZTcRCN5c8jwIvL4t1IVvhpKWK/j0OaypvAqXUrwzOwjcio8LW05nRrC69NgsJdfN2cjZs+YUaGiRMJUXF5YN+PgXvlga3ABnLJ7N9hNW2XQTF7TVVXxQB+f/bRLUa1juC6DlqNS9h1NjwI2Lh399DhvWHssPfnkW5Q3ePMgZ6IgDEo0s64IpIq5yjqmoo0yzEhpHKOTk/jvbP0hboI7l5c1E9BGAJMf8QERPsLy8menBeird48/nBlaRYUX5VCrcEZp8IUQRHYHBnFA9Ac3H4kgdYoSCMkZPIGkJ+KjyRNhQPQWXkilik6TaYxIaMPnJJ/6twG8dX/s5me4YAAF3mg21DcypqsBqhzPRJnSDjdPrqQ4FqG30I4Uk09/HwTHgpu6qbaw8fhV/e/RRyqprxoCc2OjVBESbgtSWh1i6sInsGObj2B8tojGzuYol0xuQ7hGd0f8BmG5Y3tbIzMoKAkFtnEZutUIxWNvahCdjUGtkkUU+W6Yvxiy/n3KPj8UNtcj8vlehbm3YT0MwxIq2JgxR3G6XT2NOQzULZjcg3cW+XYvevnh+I61TK3FXeYvqZFXJwlUtVEaDVLRF8o0Yx+oYCjQvrCEc9DJnYT2GWsQmAeHmAHWVIZbPbyLjluihME0XbkMPR/MgJzm4j09dewVH2g+hR6I0XbgdLVRW4MusB5bPamRafQWBiLuo3YaQLJ/XRGU4QENtGeM9CVYO1ozmKiJBLwvb6vMU5PHXikb81FeUsbKtqaAIwlgdl1tlXlMNS5vrELooqmMqsHJqI9OrooRCo2UQtLIwVWcXTiTf//73mTardcL9AEwBbY0VRPw+Fk2vL2qTBMqjfhqjZayc3oSRa+0yPjI1n8r8xhqWNdShuotpgNRM1jQ3Mb2sknKPu8idrNXgNTXNRFxBqtx1o76U5Cc7Q0KDp4ky3U+NtoBEVinQGaGSp9N1VLuraXEvoD/hmqAjJcSGymjxTaPNP43huH/CeYChhIvZ/tk0+WpQzUhRnbQhmB2YRZkrSIN3bK+VsR6HJm8dIT1EW6ANlWyBTmIwQ6wjQbXLQ7mrnohnLWpupafzcIbBASOv6xIaQfcS0JcRl3pRm5JSIl3r0LXpHDamWs1Mc74Z8euwqRHXTsCvR0gYC0jnWKtjddKmQtJcREALM9/XRjYrivrSmylniq+StbVTRttjScj2xjjyQGHZgPs+9ynkYH/RoVmasKq1iZaqciJB74SYtOyTLJveOKlK3e+nfEATf4+SjT9EuXyHTV7JYcPNwZBCZYWKW2g8/NMKGisfYTD+Ayoq/sL3fhxm63lZ/OUKU8MD1HuOUKf3oQHtA9/jxZ6fMM+fYdDwcCQTxJAKXiVNtWsAtwLPHvkWLwx0Ue0ZJOwaZiDjIStVNGEQ0pO4FZNfHPoWFe6ZaGKISrckYehkpYKCxK1m0YXBrw//GIlJT7qdoCbJSJWsqSAEaMJAEyav9D/H492P8lLsGcpdkDZV0qaKtf9r4FGzxDJx/tTxRx7a/weiniwZUyWR1TARaMLEp2dIdw1zzAXH0HPgCN7aMmb884m89YU/kO7o49CnvsPCL51DMBLkK2//lEbXbLKuBN4Kk2xSw8xaNqmeLIpm8tW3/kI2qfFOvAdZCWg6aigAClTfeC3UhHj44DtsqG8hfNlWhr91N4ovgAy5MdzWxG54YO9wjO8++yL3/O0Z0mUgsqCmchRw1ZpIM6rBl//yBDsGe8j6wXRL1HSO3quA6ZKgwSf//GeWz6wjLlJIv4SssGYiQGoGqPAfT/6RL31zK/s7DlH3yStRI2FkLlHG6Ouj8/Pf5odlAdbUtPDLPW+AC2s7P3cdBKBKDsT7uf/157n3zy9gusE0c32ZpAUkpAYpDL7017/TtaMPwy0wNUmeuCGs/lpCE3z+ob+yZloTgyKLEVXRknKU3u5WMDX41n89hRbS2dHTAzUCLQ5q2tLJugWGBx57Zy8/fu41fvbWm1BtUenVXB1LU4esDw6kB7n/uRe5541nSFeYZNOgBsLUX7WNg/ffQ6a3hz13fhUAX1UVlduuQQbDGImcHxQwPJa/b/3rXziuspUBM40RACWT+06wPr9U4e5HniEo3Oxo7wbdOj8y0o5Qsp/cuY+fPPEav3zqDVCtAX8EV8ocTbyzf4jv//UF7n/mBevacvRaMkfdz2Dyxd8/Trs5ZPWkEjl6d87fpmLlOdz28F85ZvZUBowUhlcispDt7aPzZ4UTydlbtuC75Aq0sgjCIN913szRxJ84cIAfvvwqP3r1dfBa9xJGjpWrWBTwjsQw9z39PN95/SUMHxiGtPyU+2ymLpGqwecfe4xefRDTbSA1CZncBxdW7AoVPvn0Hzlt5lSGjASqKvOTLoCiWMbd9/YT1Pi9vBZrB1xoiomaM9yQCllT4ZmePfx0/3P8YM+LQASfnsHvSiEEpLIagyk3yDTfeefv3L/jJYYyEboHM4R8SVRhkjFUYnEvUmp87qU/M5RO0zfkITas4fem0VQDw1SIJ1xkDY1PPvdHzp7RRncygyl9uLUsqmJtAKezGllT4f53n2JG2MWu4T35FYyRCXmkHcSOobd5uvtP7B38MeUapKVGSmokBgy+ffWrDPWm+eSDs3mr7Hv4knfhESYHD2W4+rweyqMK93w/SiRkbSZ1xT5FRmYYlpBA4MEqtyGBpCkwUIjHbmVAv4aOdJYuGihXh/AqGUwEMcPLkOmB1E/pyczh+b52BA1EXHFCmvXQDWQ99KV9SA7wi31P8+03XgS8qLqB7jIQQmJkFdIpnWHS3P3qU/zisR2oCQWZkqSH+zj8jXvI9vagRaLUnXMhvb/8EQf27cP1wJ00nb8dvSwyunBkWKskn/vVI5y5ZA698cRo5/oRn+Z0H3jiJbasWUhTRXjiRPoPkg9o4u+RJh7v2oQ0djP2G+0fMBkaMqmvs6obdMgG+rMHAIPOw1l8foVgaOzimaBXtrIrWfj2MF5SppuDDk3mpIRhw+eYzxPQwvRn+kvqKCiUuyvpTpWmIgJ4lHK6U8U7nMe7hnhk+68Zbh/AU1vG4jvOwVMVJNk1yIs3/4Tk4X7r+FfOwVURpGcw7NBsVBCIV9A1PHo/M27RbUfyCFQhaBblHOoZINXXh3C7J1AaBVDu9hIbTNh4G4QKGbf94yGRKJWmrd1mbz9d/3EvqY4etOoI9bddiVZRRra7n0Of+TbZzj706nKWfPYjdOmqbX5FRdbPYEfG1m41A94uW7NBSrxZhUzWxt9CUNYYoGtwqOTSs6oIKppD7E/aM6lCIRc9TMypSe7eS+eX7sr/Xnvj9XhaWmzshmBMI2OUzolQhKBO+DnSZ293bbnV/djO7kDITZ+0b4CKCmn7lBAkEpdXJZWze3xDy6otW+jK1Z/Ry6PUXbMdLTxxS0AVgoZgiEP99nYHfS5ipoPdisQss2cugiQcMUiZpfUUIZgS8nIk1V8yh0wVCpWucg4ND9jmhXiFl564A3tRghwB/zZK0ZC0ZZ4qQrC6NsOQccSmUrPC2kiKkDKxc/dnL3yLrgMpqhrdfPmHs1ja2MnhdoNLzu3hwH6DxiaVB34SpaZ2pHClIOOQiislPJ+cTcYm5gQKLw2uZu9w3LbCtIg3sbMrYzueBDJu0p3W+Ux/zGL25VbE66+0wEymr49D99+dTzRu3nIdejA8znDw6zpxm6bSqiK44qhlfOjENaUdMAn5gCb+PyjSOMh4UFIWUnLgBsAgbfZA7uGortXGgRsAyXB2EMWBZpieBBQ1EbaABKwclMGMPYXQxGQwM+B4rcHMEEqJjH7Np+OJePDVhfLgBsBTFbR+ry3DFfGheV2YprAFCWAN7r2JZIG3FZ+3IEnSkJKe4TiGaW0BFKslIoFYIuHY+M2whREjBuBot6siQsNtV6JVR8h29nHoM98muXN/Htxo1RHqbruCIb/bdjACiMVTzg3rnOYsAIktuAFrQOobTtiycQxT0hNPOPbH6kslJzDJsn0xer5XuIJx5MGHyPb1lb6QiS24AWviig2WtttIJUgM9NE3GJ9gd3oohpEaBWL9yZQjA85xrs1JHtzEYoUNLbdtw9PSQuN116FHo2R6ezj0zbvJxmITbZeSnvhEu8dLfyrl2LdOKpOIb4EtuLFUBLHMsG2CvCFNelPDmA7PykA6ZZvQDHavgGNtci6rIRAMG6VBGVjjYMac2CU8Wuvi1gdnUtXoputAilu2vMGLz2cLwM33fzwKbiy7nS03UG3BzYh0pxIOdku6E/YvcADxZCafsK+43aiBQAG4AXAFIzSfvx09HEXzBVBcE3OWhMAW3IAF3g71ln6p/kfIBwDnPYpQnFaAFFThw8nVLsU14SEaL6UJ2WPsmYSOlBKXAxtLoOBW3I60TpeqI0sMWq6Am3V3bGbd10/Lg5sR8VQFWfyVc1j4hTPQAu5Jda2WSOemhkLgdemONFqPpr0vNPHJ6EgpCVZXWis3IyDntm/lwU39bVfiqgjj03THwd2jq8408ck81cKZ1inl5Pzt0zVnu9VCf2f7YnR+5R6y3b1oFeVUf/g6tIpyi7lx1z2lQY4yCbuReFx60XNGKsHuX9/Lrl/chUgNFrA+0oN97PrFXez+9b15kOPWVNsVh9wNJyUjdxqZSEbAjWYlnqGFw8y88Wa08ihqIIBwF5lIsBiHTjVuXOr7ZLfEcQwAcCvF/T0iAvCqesnGliOiq87xPRmR2HcKz9/PoWkngCJ8RRlL0Vp3HuQc3p/hgjOPFICb2rr/flsCBcOWHWWJwKfaP5cC8Om6ow/GlkFQPV7qLrma+iuvy4MbsLaY9FCE5i3X0XTO1ajuIi+NEseYFALKJlFy4P2UDwDOexTNexb2lD6Tcv9p2NdIUJkaPNYW4AgUpgbm4lPt18IDWpAZgVmONPEV0VUONHGT5eWrbN86FBTWVCy3fZPwBDysmLGAMn1ieW5PZRAtV1ywzOVhZWWLA61Tctq0WbbgxZSSU2bPdOy2fPLcmbY0WkUIltXXE/X5SuqM2L2urtl2gjek5NQpc3BVhKm+7uyCc9XXnY1WUYaJ5NTW2fb0XyE4eU6bo90LWmupKLMvhx7wulk5r9mR1rl5yUxHf588e6aj3adOn5n/fQK4uWkbvtYWNv2f23BXVIyCnCIrGH6Xzvq2Fnt/m5LNy4rbbWSs9h7pgR52/PROEv29QA7c/PJu0gM9ZBNDGJkUqiLYvKA0QxCsAmfzqquoDdo/lz7dxabWqahCoHi91G7dSt327XlwA1acnL1mNQ3XXk/tFVejeouvPp46Z6btCo4qBKe0tdl+bwKYU15Nvd/+Bc2r6myqneEQ3yYn1i209ZMENjfMd6Qtn9Q4u4DdacaTZHtG3/oFgplllTT6w2R7+jHjyWKXwqPqbKqdVZIpOmL3mugKRwDXHDieUjTxaK2b7V+cXnDs374SLgJuBG51Bi61GTuIrgo3rcH12HUKlxhsql5ia7UETmuZbbu6rArBiTOnF9QWUz3eCdW1WyrDNFdGcAXDRcENWLWwjp033Xk8WTSz5Pl/hHwAcN6jaP7LQZSaTARCm0t56MN49VmUCmxVCdIS2U5b6ETbey2vvJLja7bY6pxQu4VT688ueS+A1dH1nFR7Oh61eLACNHqbOK3+DBq9TSWv5FE9nF53Kpuq7PdUtzSdxpWtm211Lm/dzIdmbbKlvp7WuIAbF66mzOUuSbeeWV7BTatWM7emqqTdPpfOdWtXct6SebY23bxpDbesW2urc9Oa1Xx4UenO1QBntM7hxjnr8Q4k6bzrpwXnOu/6KdnufqaHKrl5/joWVNSWtNur6dy4ZA0XLFlQ8l4Syc0b13DDafbfybWnrOKaM1djFyfHr5zJNSeuJOwv/tYlBLRUl3Pj0atYWFdTOk50nRtWr+KSuQsBUDxulGAgD260SBiJ5LaTT+frP/qhVUE3EEApsoLxoVWrueHoVbYFzE6YO4NrT1hJJDAxvl2BMNNO344vUklPZzsHfvtN4of35MGNKxRl6unbcQXCuHWNa45fwUWrF5a8l5Rw0wlr+chR9jFww9qV3LR61eh2gNeLFg7nzwvghGnTuHH1Kmrq6tCKgBsBNEfCfGjtapY21Jf0t1vTuH7NSq5YvNjWpo+uXcfHlh5lb/eCNdwwa2PJlRcBHF3bxrUzNlHhLg7yBNDgLWf7jE0sjTaXtFtXVLa3beCKNou6bsaTHP7X79H+6fvIdses3BsktyzYxBXVMzn82fvo+LfvFgU5181Zw/a2o0oCMwFsqJ7B+U0nEdHDJT9/lbuCjdUXUO1dRrFnpedwirs/8m7BsX++Kcbh9lFAJHP/XxX5BDXhfwFkye3TytD1LIlejiLUEjqCRt8Kzmo4lQp3abur3eVc3baJdXWl/a0pKjcuXsPVq5aVvI4Ebjl6Pf904lrbBb8rj1rK9uNWldzOFcCaGVNYOKXW5irvv3wAcN6jCOHGLQJF3wIUBG4lAmiEVS96EfKniiSiqqjCTbnuxiPSY85bOgKTsJrEq7gI6T5cIjtOx/pxiSxBzYtXdeNWxiYsj+oomIQ0H7qi4dfGbmmN6iuYBDUNVajUuCW6yE7QUTGpdGVwKRqtfpOIPjTBblUYTPHGCOsqTX5Bk68XpaAzuWVPo6+PKT5JxKPQEulHUybS0su9cWZGsng0lfLKNEIbrwOqK0tllYGuKngrNAyXmdMYQ31VJUoU3C6VYNiD4SpCjxUg/eD16gS9bqRWqDPyP1OVhHxu/LrL9k0x7PbQdaidnZ+8ZzTn5tNb0apGc3JE7xC6ohJ0u0oOJC5Nxa1qhIJuTLWI3YBwC3weHV+Zh4yvWJRAxgv+sBu3XydToUyggI/ouGvc6LqKrNEwx9HpAbI6qLU6mqriq1Yx3SX8XWnicqlEIjp4siheD9XXXUn1Tdda+VNCooUMAl6N1qnN1Nx8LdXXXIXwegr9rZuEfC48Lh1FH33eCj6fgJDfja6puEtUTdWDEY6+9lZaWlsZ6uninZ9/PQ9uWk8fbe+h6dY1gkGvxWIa9/klIHWB3+si6HNhlooTTRL0uaytU9dYu8foCEnI70FXFdweNc88GR+XXq+GpgiCAdeY721UBwGqR8GjW3EidXNCnIAEj8Tv1Snz6miesS0ERj+l6spSHtDx6xohj1FkrJBoqkG1X0MXKl5lrL9HPSUBv6ajCQWPDJAZRxMHixFoZty4FJ2wGcBMqBjxFEb/ENmuPto/822rrMSwznB7L/9y3uVku3oxBoYxE6lCynlCJSR9uBUXRtqdb9o7VieTVfDKYK6SsTfXSHicTVIg8FkV3UUYQxZeo+dwis9euIOuA0laWqfwy4f/mYYmlQP7rUTj9kNG/prDpgtThEiLcrqzAUaqGhdQ4A0Pw7IGEz8HUlVkpTpRJ+uh12hEUzTiqTIyxkRfZgyVRKoMTdEoEz7kKFu94GvWsxpeVafMW7oOkBAQ9LgIeN2gF4sSkCqEgh48Lg3hHxu7oz+GCv6wx7Gy8vstH7Co3iOLSg7daf1IAxOJiYnA2r4ZeetJ+q+jZ+ALAGQlpHMjkyYkOhIhFNz+63ii52eAiSEFaakhEaiYuEQWRahUe9fyzECMwWwvUkJWKkgEAokmTCsYtSh+fTZvDbyMIS1rJORskghhLfNuqjqZv3b9BlNKKzFZWhBNETLfdfeU2rN4pOsHObsVUrlZThcGujBQhGBNxSk83/tLJCYZU2Ew68GQCm4lS1BLogiFqf7F7Eseoj/TgyEFfWkfGVNFFwYRVxxVkQS1CG5lMS/0vYYhTQZTblKGhiJMQu4UumoiEKyJnM797/4dQ0qMjIqRtgYBzZ1F1a2R7Orm4/j3Z56yvqAsKOncIKBJpC5RFMGVs5fwvWdfsbZWTItuDFhdmzVrP3lNYxPv9vfSPjhgDR4j2MxyJgio8PpYMrWGPx14p/i2gQCjt5/4l79L78HDaFUR6sawqNo/822yXX1oVRE++Z/3cf/hd3KGTLyUoggun7GE/3zyNbKmxY0eoSRLxbJJVQSrGhtp39tPe59lt5LOUaAFGC7rv+V+L8tbGvjzG+9iGCZqijFduUGqVjxcfvwyvvHsc/nrqJncgOUGmUu7+NDGFXzpzcdH/Z2y0IDUJdIlURXBJbMW84M9z5GVJtIEmVZACoQiwWWiKoIVFU0c6EqwfyBm+dsQo/5WJQiIuD1s9E/l4Tfetvw91k+C/Ev2dcuWc//Dz1J0hT6nc1yLn//48DX5w1PPugF/7SiDS1UF565fwIOvv0rGyPl7ZLLM3UtRBEua6mhXhtkb6yugkoM1+COgzO1mQ2szv3ln56jdI7YrozZdv2Qldz/zTL67eTGdm1et5itPPmn9YjK6+53TURXBBQvm84Pdr5A2c63GszlfKhJUy+7FVXUMe/vZPdht1VHJKox0ClD03Hiiuzm1uZk/drxC1jTJmgpmLqtaVw1GXtgva9nE/bseKbrJPjKlXdFyLF98xbJbCImqmBaV3hSYpkAVCltaFvPDl9+yErKFxBjspePf7yV7xNrOrLz8Avq//2PinV25FcBr0apC1meXQMaKq4DuYvO8Fn6573UMaaIoJopiBZNhKPkyDbevWMgvD/8mZ6eZH/vM3NgKsLV5I+1DX83pWC9lvR0p/vWiNzlyIEVlo4dv/fIm6ip+yeFDQ2w/v4ND+7M0NKnc+6MqymtdgIpPn0evqTGQfgeBiU+kUYWJKQVx6cLM5WsOqJfzTM9jmBgElBTuHE18yPCQkdYYPD94OV/bYT1zmmKM6d6uks11RN/afAxffOK53Jcgre9+JHhNa0vw3La5/O7Zt0lksiXHnNnVlYg07OjowhyJt3HjoFfXOWlBGz9/+Q0MQ1rjUi6WpEp+KeUX11zIrNqqIlEyefnvzN8fAJz3CHDMrg1gHrbRUOkhSNJoB5ty351GPfszI7NocRkyPOxN25f6NiX0Ze3zLwQCr+ojbpTu2qugUOUOEM/aN6Pzq14MOTTm7XCiGFIhJe2T4kwp2B+vsL2OgkLHYD296eL77paOIJCu4lAsYZsXEsJDfMiwvR9Ix4RdiUQJmbZ5SCKR5Mgd3yEVG8iBm3D+XLY7Rvtnvo1aFmD+J2+kB9PW7mDWQ6LPnt+lZEAfcHhTktYevF2ukiIE3hoPvaX6QuV0Kuo8dBoD9nRUj0aSpL23swJz2D5ZFRN8nbpjjlVV2kNsoDSLJDsUY/ev7ibR150/5gpFaT2zsEGrK6gzpNnT8k1VknUYRiQSVROOuUrluo+eePGyC2D5u9rn58jwsO213B6VhJa2tVuoJnrYvnEpSCqDKcfcmaDqpzc9VNpuBF5ZQftQ0vZarqybxDiCZ7Y3RucdVs7WiIzd3ixltztqOOSgKKycMkjcjJUcBwSCtZEhytS9jM3DiQ9mueOqNxnsyfDRB+YyrUGhVrNqM3S2Z9l+fgeRqMpXvldNIMeazUqFXtN+bDYlPDY4n6y0KYOAytt9szgUT9naHUhWcrgnbR8nGRU5YGuSBYYc+jxLQNcV60WghKiK4KLli/j4CRscbmgv/535+4NCf+9VTKfuqAamOYAduAFIyzgCP3aJxtlJ0GMm09BNEQpJw77zq4lJyog70sTTZgJNKNj1apkMgjakcAAbVl2Wwaz9gGwi6U+mHOnWw+kMmqKSdegm7SgCW3ADoPp91H78MtLxOFq0rOCcVhGm7lNXoXjdJHQFI20fJ/FUBk3RrBWcUjKJptyAI1tFEYKhtIO/pWQwk8Rw6Doaz6bQdcWeUj8Zh0tnu4UQDCdKT+4WW2o056bxuAs48McfkB7oYffP7y4AOfFMBtWl2Pt7kqvuTjEphGAwnbIHU1IymHaO74SRQXXy9yRo4gKc2VjAUNYevJpIBjMpR5p4MpNFFXrB59PKw0Qv20LnF0frJUUv3WIDbqytFafyDQBJM2477kgkhjmIVAuv5Qtq3HzfbJLDBuU1bgSDWGQTg+o6jXt+VIPPr+TBDZBb27cXE80W3IxY1Z9JO9o9kEo5zgeZrIlLvHfmmiKwBTdgbaF1D5V+qf5HyAc5OO9VFKflNhVVCWPPtAK3Yg9uAHRR+nxyMEN/RwKR27QaK4OdcVKDoxOVKU28qj07SEHBo/ptmVYAbtXZ7skEmSom2j1eTGkS0kvvF1vXUQh7PI605aDbhWE3aTHJeUviSEk3pSRcVmZ1TS99dxoAAACdAUlEQVQiWrQM3e+lzO1sd8DjbPdkn2qne5lSEnIXT+gee40yl9fZbs3tOFFOantecaajSikJ+IrbnR6K5cGNN1LJ9LOvw1/bYoGaUDQPctJDMctuXXf29yTnBqd6OnIS/laEIDSJOPHrLucJfhIFfCRMqnN1SPfa242gzOV2pIn7dG0CeMv2xuj5bmG9pJ7vPUS2L1byOlJaScv2IvEqfnuWHAJVKStK3fYFNcprRlpv+Bj7EltVqxWAG+tazoGikkW36XCeGkwz2Bkn4ppYwiPdPYAxnMzbHfbYxxKAexJlJyYjprRyBO1ECKgOOVTEfJ/lfw3gPProowghiv4899xzJf/usssum6C/cuXK/0HLC0X4zsHejQZ+/6XYr+AoNAXPtQ1Ggcq04BpCesWEc8nBDA9c+wzfufxJ6PEyr2xpHpgMdgzzs61/4VfX/y0PcgSC1RXHTIJKfoJjReSl5cfbXkegMCu0jIheiR1kiLjKWVG+yBZQCQTnTLFvxGdIk4tmLrJ9w1WEYMuc+bYF81QhOLplKk1lpZtfAtT4A5w0pc1+wpFw4TR7RoshJRfNmITdc53tXj+9mSnRsK3dFUEfJ8xvswULEsmWhfZMM0NKLpq50NHu86ctsp1wVCFYV9/M1HC5rd1Rr4+T5trbbUrJOWvnF7+P7kbzBnCFonzm6/ej+sOAVcxsBORovgCq7kYRgnOXzUO3GbgVIVjT1MT0aNTW7nKvj9NmzLSNE1NKLpq/wHEF56KFCxy3urbMnIfbplaKIgQrqqYwI1SabQgQdvk4oW6RI936rKYVjis4F05d4rDVJThv1nw8Y+weuz2lVZRTe8v1+KuryHb3WqUGSoCckNvDmc3zHMs3/D/s/XV8JMfV9g9/q2mYxLzSMpOXmcxeMzPHXmOYOQ7DfSe37ZjjOHEccBI7nBgTJ2ZmWvCStFpJIxju7nr/6NFII8307P3ayfM8n59PPop3ps90X1NTXX1V1bnOObxhjetKiI1kdvQY1xVqgUJj6EQU4TZpVIh6FxIxZuL2vNCVIEuq1pYcBzODWe65/GF+edHf2KB3FOHOdvez9ZM/Ztvnf4aVSDvtPcP9vlSF4MS5s/Hr5beFFSGY39rI3JYG14lc0GNwwvxZFdM3HDtvZtnj/w77P0ZwVqxYwd69e4v+LrzwQtrb21m0yL2C82GHHVb0uT/+8Y//IdQlzH8GtlJXUtInAWmsxBO4GMNYXfI2khIUtYnq8AeYGr2g5CWkBCE0ZldfxmENFxfeG7ZMwiTRm6FvV5Jbz/sn863VKEJlYG+Cuy9+gIFdCZJ9abJJRw21sf4YNtZvJqJXlf1aU4OzWVO7mcnBeWV9wnoVq2qPY1XtSWU8JKpQ2VB/FpubLhhukXE+AJsbz+OUtqPzs9zSN+UxzQdzVsdqmvzl912X1nRwwfSlrGsZCRa1kynM3njhdZ0/wKXzl3L5kqWY8Th2avx2naoofGTFKj6/er3rwP251ev50ILVGIpadiZ/0azFXDh9GS35h2lJ3LVtXDRjKRubJ5X1qfEGuGTuUq5cvrysjyIEH12zmk9tXl/y+DDETx21jss2LXeddZ29ciEXLl1EW6z0yhPAopYmLpy3iENaJ7vg9nPprOVcNXuNK+6PzdvAF1ZsLOsD8PkVG7hi3XLXh/dZSxdw7vpFtNVGxx1TPT4mHn0xm6/6Ilefejgb547gNkIxJp5wGR1HO8nMokEf521czFUbVrji/uiha/jc2tLtPWyfWbOWq5euwKuVx3323AVceNAiJo3KjTPW5jc0cOFBizh8ytSyPlGvlw8sWcrHFpeXritC8Oll6/jMvOEJSun78pNzD+aCSRvwqnoJH8eOb13KGR2r6QiUjw+cGWnmnMkrOaqt/AMurHvZMnMFH1vq4Db7+orITf0HL8U/qYNf/fEPNE9oK01y8hA/s2Idl89ahV8rn9D01InzOb5tPS2+8tLljkAr6+o3MzF0SMnjzkpRiDlV59Aa/XjhvbE+IGiLfYpZNR9z8YEZ1R/ikIbj8pXCiy2bNEn2pRnYleAH53yG5nxB0mx3P1s/dQfZzjhmfwIrlWV6uJHzpy/n+Knl2ztoGFx+0DI+vtFp73JE7xOb1vDxQ0vfu8Of+MjBq7hkzVIC3vLtfdz8mUytHz9B/3fa/zGCYxgGDQ0Nhb/q6mruvfdezj///IpSMo/HU/TZqqryD+p/t+XsAbZlOxmSVlECNltK+iyT7ZkdSFK8nRkibnkYHfIhJQxJnbczNlk7wfZUnD4ziCXHLD1Kjd3ZAPHcALvTcXpy/iKfSIOPs25ZSbglwM7tuzn2kBN45alefn3xgwzsShBuCXDCjRsI1PlJmB62J/pJWSl6cyaWVIpuNinBtFX2pofIyQwJszu/tDq68zvVxHP2IBkrCdbbRNQkYsxqjy4sqtQecnY3qtxKu6cbQ1jjfCYYznHL3sfUwA4CanGqchWLVm8vfuUVMnaaqG8vQX1YTu+YQBLxpDGMd0jbOfaLHjSPhZ1Mse+/bmXft27A7O1D0W0ynkEGzTQvbX2Dvf9zLZ0/vKmI5EghySg59qWG2DXoHoG3c3CA/Ykk6YQcH/siQeQUduwfIJHL0hPPIU0xrr1lTmF3T4qUmWNPfAgxrB4adR5sGEzkGMhkeGcg7qgTSuDJYbMvkWDnUD85H8ixt5KADCme2/YG+zNJ+gMmtjZyptxAHDOTxAzA1lychJmlxzeI9NhFA6BEIn0We/U4acukR3RjeEbLjR0vVbPIefsZMJPszexH1yzGIhfCRtGy7M8OsGuo35VQvjMYp3coRTadK9neigW7uuMkM1kG+tJFiqZhH13zkc55SWdNuvYPMDqjghGMoho+kJBMZBhMZdjpkl7etG26BobYPTjgintnfz89ySSZnFWSSwgp2NkXJ5nLER8ojVvYsD+eJJXLsad3oKQPNiSSOQZSaXYMxF1x700M0pXpQ9WKKyRZiTS5nn501WRvuochcxCf3o+u2GS6BzDz2yACSUDPMmTtJm2lkWoPHnXs7+sU+TVFN2krS2e6F1UZO544qqqsSNGfTbFzKA5CFudL+uClaFURTCyIhfncbbei1VShBIMo3jHb1jbs7B+gN50kkTHHKekcRaRgx0CclJlhTypDzho/DuYslT2JDGkry/bkIEOWl7Ehe1mpsTerkTAT7M30sN8MYY1ZE8uhstcMEs/10pvtYb/pxxzz6LUR9Jl+ujK9DJpDDJj2uOdAsM7PMT88mOrWKrZt3cpDV/0Xqdd2FsiN0RBl4lfPwlcbYtAcIG3m2JntRehjOwqgSFJamr5skm2ZPky/PW6B3VYkmaDJnvQAu9ODpAM29ti4LSHJ+SXb0/30ZVIM6FnkmDmTRCI9sD0Td01S+u+w/2tUVHfffTcnn3wy27dvp7W1tazfueeey29/+1sMwyAajbJ27VquueYa6urKx8JkMhkymZGH5sDAAK2tre+Jiqqz7wv0Dt0KWGgIvMKhAylpFcZfj/9itg7cBTg5ZnzCySmRllq+o6tUB07k4Z689BOJV+QQSExUclJDoFDvm8kT8QQpKwlIdGGhCoklBTmpMtSZ5PeX3Ef/rhEZQrA5xOHXH4a/PkBuWLMKbKpbzqM9jzAsJFfyaK1RetSjGtbwXPweB5EcuUUE5OXmCotia+hK3F3wyeTl7Ro2uuKkHa/1zCRtvUXWHkRKSNpGoQq6X8kiBOhKAEtZyO7Uy0hsUpZOytJRhZ2XmzvXjhhn8NeuJ7BxJKtpU0UAXs3MD5ywInooN7z6AgC5/f3s+tytjhS7PkbLF8/HWxtlndbIzRd8rCibrhaNFqSPCoK5dfW809NPX7q8aiuoG8xurOPxvbucvWwhRySr9nBrwamzZ/OLt150loyFdOTRgLRGtM3nTl/I7S8/W+gDhTEwfx5VCI6dNJPfPv+a81uMvXOF85FZdXV0dg/Rm0yNSJvzkk0zl2LPj25EJhIc+ZUv81LKUZsJE8yePnbfcj1qMEjjRReh+HycvHQmP3/7Bee7WSDMfP4OfQTf+XPn8fOdjxX6gGU6MnFFlSiqRBUKRzTP5ve7XnCosqQgNRZCouTbe1q4nu27LfankqXZmwCfprGSNh5/eyeWzFOu4YFZjvzz9JlzuOfvL2EP+4xqy2GfkzfM465/PD/80bGXQlUEBy+exm/ffq0seRECptbV0KUn2ZcoH0Dp1TSWtrTwyDs78rjHPODzqE6fMZdfPDeMW475bs6LsxbO445nhnGP91EVweEzpnLv3lfKxlcIYEqsGjvaw770YD6PisBMpHnnSz/F7E8y8ZqzCNVXc+SEOp7te5VEVz//uuo3GFE/C79xLP6wVoibOqRhNX/Y8ygSiS3BtPLpG1SrcO8eXLOem1/P45YjqxZCOH+qUDikYQb3vLTNwS3BTqWw0yPFdIWAiZEY6ZTNOzt3IrwGim9sMV2Boaqsnt7MQ3vezm/TFLfT8IsrFk7jz/seQeYnbaOroA9HBZ7dvpAdiZ/nzy0LechMqWKhIlCYFV5KJvO7/FaWM34reZ8sjk46qLUStzSGzE4K43d+BM5KDWdE1TDVzTwff74wNg/nH3KClAVDnQn+uuURenZ2Fb6z0RBl6tfPwFsXzo/NsLlhJTe/+OLId7byDaA4964qBAc3T+G+17ePpJ0YnqPkq9cLAW3hCCKr8E5/v+OTr3IvBeRhoykKmzomct/bbxdSbwzPZYd9AO486SSWujzfD8T+n5SJH3GEk+m20nbTz3/+c4LBIBMmTGDbtm189rOfxTRNnn76aTwlMp8CfOELX+CLX/ziuPffC4Lz+u55WPZ+Fw+FftnKkNWPm7ylx2qgM+dxDdgdsgx2Z8ovXwPsfa6bey/8S+H1wTdupnZu/RhECmFdkLHLP7gFgnafgil7XTHVaJKAEkdikxw0C6qC4uvZDHal8AUV/KHSS/SWFHSZ5bdCHEwKLwxMY8gqr+wRCPqHWtk5aBbUTbn9/ez+/K3kuvrQ62PUX3ECXd//Nbl9vaNmh9HxJ7NxVlNcTCIrahFVIfAFVAZz5XErCKo9fnpTKdegP5+tk0tL98BAC9Rsadxmf5xdN12L2TtS6FGLxjDjfWMKQG7BE4vhrRMMmG6VjQXN1Rr99qCrmsxQVEzbXU5vZRXS8fLZtQFHJv6Oe4OriqBqyGAo4YJbQDTqJ16hUKgIKqR8tmvB0QORiQ9f022w1RSFkG3Qny6N20qnIJOhrrGJeKo4DYLZH0d4PIXisqofsh7T9XqqbhGoSRa9l9s/wNZP/ZhsZx9GQ4yJ15zJlCmQ7Brg0at+Q3LPAP6mMMu/fzy+OidgVBUKmggwaCZLXcb57oCZqWdvwnIPNk8bZIYqVN2zQZiVNh8kImq6xtdoQmFmS4KkdC88vCSWJKh1YrvE4UTVDDVa3PU8phQM2e79W0p4dqjDFbeCwguPKjx65a2F96Z/5yxCM1uK/NRMNfsG3dtbySnY6QptaTt+7sArp53QFIVT5szhSxvdt6Er2f/RauJf+MIXygYPD/899dRTRZ/ZtWsXf/nLX7jggtIxKKPtlFNO4cgjj2T27Nls3ryZP/3pT7zxxhv84Q9/KPuZT37yk/T39xf+du7c+a6/57DZtvvNATamTFNJu2tKs2SkftGZKsjEhzoTPPj5fxa99+gXHyLRNVT0nhCCXIVKuxKJJTOu5MbBlEGgFPJCfPPMl+jdWzxAOxk/X+Ub579OcrB0ZeIDkbcLlIqVjSWSpGkWPUj1mgjNXzwfvT5GrquPXZ+5OU9uqsuTm/fQhBCkK1TAtpGkTbOioiFjWhVVW26mRaI0X7gFraoas6eHPddfT3r7tnHVrbVoNI+7cnun7VxFqXzWroxbjttPG28uQsIRHwTZXAXcEtJZs2JV7qxluwbY5i94QHYgM8m0WRq3lU6x99Yb2XXDtQx07ysmN/E+dt9wLXtvvdEhQUDOPgDcJWTiek2YjmvOwmiIke3sY+un76DnxT3F5Oa/jyuQm2HLVhxPIGWZFWXipm2/q/5dMFE+pmQEkyQnK+UBAkumK46DUHn8PpAxzkapiHuoM8GzX/t10XvbvvU7Mt3F2+lp053ggRNK8V60txCV0zfYUjKYqVwp/b2095zgXH755bz66quuf7Nnzy76zG233UZ1dTVHH330//p6jY2NTJgwgTfffLOsj8fjIRwOF/29V2Zo7biPcCo+tRa34mkgCGph1xkCgNfl1xrqTPC7D/yNwd1DBJvDHHzjZoLNIYZ2D3L/lj8UkRxLWoT1cAV5pEJAq0KpgNujVmFjkU5YDPbk6N6Z5ptnjZCc3r0ZvnHWK+zbmWGgxyQ1VHqgULDzadPLm41FlVG6LMZo3A3+wLjBXa+JUH/FCUXvVZ97qiu5qSRHHjZDdZdHWrZNrdfvWkhUFYI6f8BVhSCA6oDPPScLTgZeN9OjMZovvBS9Ok9y/ud/xpCb2CjcgYq4azwh14epAKoMf0XZskv8bcGkCp4KFc4taVMVCbgO3KoiqI0EKv7GVf7K7a0cADEDZ3vNzWwpqQ2Wxi0zGayhIczeHnZc/wPs/jiQJzc3XofZ24M1NITMP0BiHl9lmbhVut8atZFRJCfOvy67u5jc1IeKsUlJlRFy7ScKCvXeYMWHadTrOYB8Qa6H86Ag4BJgnHchokUq4vZp1VRisYqIVCRBB1JbXMHGp5avuD3UmeB3l/yZ9N44noYo079zFp6GKJnOOK9/7KcFkqPkx5NKTRUyPAeQV8rZKixV/BbAjMexkimChnt7A0wYVX/tP2HvOcGpqalh+vTprn9e78gPKKXktttu4+yzz0Z3kauVs56eHnbu3Elj43+2iNewxYJnV/CwaItejJvMECTzYqeiivLfX6CyILqWJm/LuAf8UJdDbgZ2DxFrjfKZn32e+rmNbLzuyCKSk9znxAjoQufQ+sNd2b2Nzera4yuQLsnc2MmowqCqwcPH7phNbau3QHLeemaAb571Et070zS0BfnsT2dS3VjqJlCIGR3MihziOgtShcZRTQdXxH3+lNXjlmVz+/vp+sHdRe/13n5Xkbqq+FqCY6fOZHZtXdlBWRGCSdEqTp4225WYaIrKxXPcq65bUnLp3KUVB/cLFixylXWqQnDU9GnMbax3xT2lYyJnfe7zRe/XnXZagdw4uBUunrO0Iu6Lpq6smOPm7EnLCWjl83KoQuHwthksqGssjxtBWzjCSYtmuxITVSicc8hBrgO3ZUvOO2Sx+/aUgLNXLCDoMcrjVgSHTpvCQU1NZfuAIgQt4TCnzZlbkcBetGRRSdxaJErzxc7KW2p/NztvuJb0jm0FcqNVVTvHI1EUIThv7kLCZYrSgtNPNrVM5aCqCSXb26iN0PrBY4vem//pg8eRm2HkJ7VudO0nzn250j2dAIJzZy4i6vG6426fxPLmVtdCmg2BEGdOXehOqCSc1r6+Iu41tce5kheBYFb0RDxKlHJESKDSHFhBs3+RyxgnCGjVrKvdVFImPtSV4PeX/IWB3YM0TGhm2jfPIDSzhWnfPKOI5GS7B7Cl5AMzl1fMVH727AVU+/yu7b28po7k7T9m77XXYfb1FR03+/rYe+117L/lFk6aMsW1vaWUnDRmcePfbf/HE/098MADbNu2rez21PTp0/nNb34DwNDQEB/5yEd49NFH2b59Ow899BCbN2+mpqaG44477j8Ju2DR4GmgTisr+/P5TqEueAJV/qOL3h/tZ2jTmRA5hZW14yXgw69V4WdF3bmc3naeE3Y2ykcP6HirvISbg9zzl99y8dLzMRQv/rpggeR4Yj5Un/NgPLX1RNbVrafB01oW96LocpZUr2NWeF1ZTNVGG4urj2Jx7eUAxMaQnK+d9iLdO9N0TGznT/f9mupGD6UkJALJ4rqPs7L2LDyKt6QPwNq68zm4fi0dgcayPquqF3Bk8yJOmDC38P7YGJyl3/0wHRMnkuvuoet715Pr7Rt3Lq+m85Elq/jyuo3OzV/6clyz/mCuXryCoG6U9fnY0tWcOWM+M2N1pX0kHDFhKidOnc3JU+cUfXa0X0c4xrmzFvC5tevK+ng0jY+uXM3nD9mQj/mQY1yc/102dwYP/Nf3io7t+9nPMON9hc98aNVKTp8+jzk1xTFcoy9+6ITJHN8xl5PbFxa9P9qvLRDjrEnL+MTsw/JHx/sYisqHZm7iyysPdmbUJb6bRPLVVYdw6fplhD2esu19xcblHL9qLrPa6kv4OMGra+dOZPPymSP5csZ1cGiuCnPGhoV85vB1zmlKXM9QVD568Cq+uG6DM/EohVtKvrJhI5ctXkrU4y2L+6olyzl13hzmNzSU9NEiMU740teYOHEiZm8Pu6//QTG5icYc3KEQ5y86iC+u3FQWt66ofHrpWj45+wiUMeMJQGZfPzu/99ui95675m+kukZvyTsfOrXtUA5rXM6s8IQSF3P8FldN48jmxZwzeXHRZ0f7NPpDnDd1OV9atalsP9FVhU8vW88X1mxAUcZnPx9+/ZX1m7h01jKqPaVy0zg+l81ZzpHNS5gVnljCx7EF0amsq1vF4irn+VJqHAxoNSytOZ4FtZ9wEJQcUzXmV1/NyrorEIyvFD78emX9Bzm04QjCemjc9zcCGr4qL/Vt9Tz293+yctocQOKpDRdIjhb1o/h1llZ3cGzbAi6ZvaToO49ug3p/gEtmLeMra8u3t6YqbJm1AG82i9nTw97rri+QHLOvz3nd00PINDlx8mRqA+Pbe/g3uWjxIprfw92TA7H/4wTnlltuYcWKFcyYMaPk8ddff53+fkemqaoqL774IscccwxTp07lnHPOYerUqTz66KOEQqVmFv9+25/Zy+/7fLyZrSM3KkYmJXWeT7Vyb083g7k+fre/l1dTzWTkyOw7JxW2ZWv5c5+XfZl9/L7zLd4YaiRpjaxy2BL254I8Ho/x4sB2/tb1JtsGYyRMo3BTGAGDtd89jHnfO5mX9QTP9O7ktT4PgzkP/rogm64/ivX/dRj4fHQmIty78y12p3p4Yn+a/qy3SI5oSYWeVJC/de6hNxPnn73b6csGinxsCQOmlxcGknSmu3il/1GSlhcbQVWjhwu/OaWoja754YfRql5DJzNOci6Q6GTpSjxEb/o5qpTd+EWxBFzHokZN0Jf8E72ZTgSvEdHTRbJ0VdhUG0niuSfpy8Z5fuBl/EYOszdeRG46rjkLZnj50e9/TrDBSRi273s/LOTSkEikgCHSPN61kwe2bsPKScbAdh5cOcl9b73NM7v3MhjPwliVtA1aRuFvr7zFzng/W3fFEVkx7jxqRuGJt/bQnUjwjzd3OMVBx/gIU/BO1wBb+/r40xtvjg+fyL9OZnI8vnMnD+zYSlazHTXE6JMJyCR6Of/E49m+bRtaTRUNV12OVj0Sk2P2x8Er+dOuN9idiLM1uwfVGCP/FaB5LJ4d3Mr+9BDPxF/Gr5sIUQzcUC367S52JPbxQNdLaMp4bbdAkpVpnuzZygPbtmJmy7W34K9b3+bF7XsZ7E6PKD5GtbeegQefeovO7n52vLoPNSMpzs0AWkby8jM76YknePzxrejpsdeSqFlJ944Btu/q4YFn3kJPURxGJx3FSS5u8uSbu/j7G9thyB6HSVigJQX3v7KVl3Z1MdCZYkz3dnAnBQ88/zZ7+wbY9no32tjr2aAnYUdXlu//8IaiFqw/5fQCuVHTsH/7AG917uevr76FmlLG4caE7IDNv3bs5OGut0ibTg8ZHk+y3f1s+8wdZDv7iLU0cPuf7yDQFCK5xwk0HiY5AolPNXm+/yl6MvsZsl4jpGWL7ksFm7CeoTf7En3ZOC8OPkvUl3YKbY4C5TeymNputif28Ld9r6CHck6B1VE+Qrcx/Un+tX8rD+59m6wnC+oYRZrqpC/4y+7XeSneSY85CCVk6aoK9+19g33pfl7q78S0ikmHlI4S7Lm+PezP9PNIz2v0ZQNF5XJsCUOWh9eHcuxM7eLZ/ifZm4sV1d2T0qkkviMb4M3EC7w99DQDtsCkWJZuIUjaOq8PPsae9DZsuRdDKe5M3qDOCf+zhotu30ygPsiQ/QoxTxpF2Hhqw0z/5hlMv+Zk6qpgwH6Z3kw/zyafJRZJoapj2tuXRfp389bQbu7rfhkjmkFoxT7CsLHDCbZ6Ulx58w/QaqsKJCe9bVuB3Gi1VRzx3S/Q7zPYaw5ij/1NBGBI/rb7rcpZwd9j+79GRfWftPey2Obvd/83L8TvR2KjYBNQnPofQ7aH4eXKycGNPLLz72STJqF6HwElg8CRS9soJLrSTK9byr9S7+TPKvEoJio2GalhSRWBoNHbyIvxFNl8oK0qLDRhY0oFK598wBAatUYd2xPdSCSKsNGEIzgcrjILsLFhKo/3voIlHSmirlhIBDl7RCZ+bMtMnut/pIBJE46vKVUkAgWFpVUzSGT/WjhvfG+Sa899hp6dI3llaltDfPXOSVTldxGdSbRTBX14RVMRBl5tIv3ZtwGJLZ1BQEGiYhf8TO1Enu9/DhvbkaNKFZDoYsSn0Ticn+94A4DcUJo3P/sLcvEE079xBp66MKpQWByZwd2PvMy+b96AEgpSd/X5jtw0r9oWQHsoRndnmpSZy7fAaGLmXMxQVSZHYry+v8dV2nvItMnct/XtEYlwkWzZ8do8bRr3vvH6yLXGyn+FYM2Edh56e1sBx+ibNw+dtmiUfckEyVxuxEk6B83+uLPU3NODv76W6qsuRqmKYvYUZ4yt/7BTyPCo2e3c3/Wag1uCtJ3fDYWCHPX4jmk8tP+Zwm9r58mwImRB/rsoNoUHO7eO4B49/uW/Z5M3xs6tOkMFtVm+DeTwt3O2zRYn63lt575iCbgccQc4omMS/3jsLWw7//DOt7ewR9IcbFw1nb88Mdze5MngiI+qCBbNm8CDu3aM4B5uZBvsTAqZzdDa1kqvJ8NgJpv3keQG4iiGBy2/gqAqgtl19by0p6vQT6SSx2uP9JMjJk/h/hffwhrGnb9lheX45gb76PrNTfTv6yxg0qPVTDh9C0YgVsC9ZFobD/RtH4VbFnAPX6sxFMRs6mUgN6ymlOT2D7DjM7ePTAi+ch4nL63lha0vcv9lvyOxe5BAU4j11x1FoC5Y+O1W1cznmb6nsXEUZ8NEQMvflwLBzNAqfr/7lcLvb9nOdEdVbJR8P5kdnsoft418N2njlJRQJMNhXvXeIENDgvhw0d3hNC+Cwn2lCMGipnqe7d3ttPeYp9ww7lOmdfDI/ufz21Ry9C3H8J15bMtU3kw8VDjijIPOdxweB2eGpzCY+1fh/CpOCg9TKth5UAE1hiqypKyB/Nkdci/z/xq+YkBfzPbEG4W2HK5hpYwaL9v8G/lnHreUkLPz46Ay0t7zIsu4d9erI+2dz/WjqjaKAioKsyMdPLizszCOSCt/j6sj7V3t8ZNNGHTt3kPXN5zK7sOm1VZR//GL0aujLIlN4Km9u51tyNGccvieAW467FgO7iifFPRA7P9Jmfh/0t5LgvPtV08hY7sVEBMkBiP86AN/Jtmb5uSb1xNuGFnGG+hM8osLH8QbC7DyO0ehBcvHV6RNjb5sZZlhzqogoxUKQcNyVT4IYHLYxpT945aBR1uLJ0W13o/Eom9vmuvOfYqenSmqW32c/vXZ3PmJl+jZmaK+1eBLP51MTVPpQDQpwaygtxaovJCaTLqCYmP7wBR2JkZmEWYijZ3MYtSO/NbZRICBAYNMT5+TUMxfol1zAjVZITRQVlb2qIqCYagkTff2jvq8xNPuRQt1oSAt6RrLMIoPjDM7laLzxpuwhoao//AlRUHWZm+cru9ejxIKUn/lhRj+AMHaHEnbXWnSGlFI2e4V5aWtkzGFa7yDmdJI7KtQq8aCyNvuC8+qohDrU0gl3XGHYj4GUhnXOAU7oJANjFeIWJkU239zI2ZyiPZTtyCaR2KXcv197Lr1OtRAkOazL3ak2wfQTzRFIZDTSKRL484N9LHt59eR6+/BiFbTfMTp7PrDneT6e9Aj1XScugU97OCwg5ALuStbhNfEaCqWdluJNDu/9FPM/gQTvnIOntoQc+odwpHoGuKBy36PN+Zj7fcOxwg697KKQkhXSNvuBXyT2Xq6M7arkiqR9tKf9Ln2JdsSWJlKEekS1esu2tCEQltNmlQF3DMiWXSlz7VsTUhNU2U4+cnKmciTI1fUErpzlaTPKj3ZBgbM8mk+ADK5GvZnbNf4uHRWJ5k2XMcc2xKYKee5lH5zB11fvb5wrP5Tl+KdMsH52mn3sVIVghOnzeYb6w919atk/0dl4v9fM0tWqCOPJDWUJtmbpn9Xgl9c+CADnc6gMkxu+nclSPamsFKVJLnvjQkEVoWKtRKwZWWZoczn7Yx3FpObLT9aRMeCKFt+tIiaVi9dO7N87oy36NlbWZbphvxAKgRn7eKsu1rAW0RuAExbIoRAq4qWJjfvoQmoqMSReZ9Kv7Fl2xUzfbuZ4vPRcPFFNFw+Xh6vVUWp//Cl1F95YWE160Da27Ktiv1krPzXSqTJ7i+WtQ4/i82+0uUzACoULXd8AKuCLB/AtOyKChJLlm5vO5vBTA6R6+9h+13Xket34hKGyU2urwcrMYT9v5TFmmUqMucG4wVy44nW0H7KFvzNHQ6piVST6+9h213XkRuM53EfgCi5hIMa8NL6uTOY8JVz0WuK67AF6oNsvO6oInIzfJ5K4wk4fanSfNqRLVc8VUU7QKHVAeE+kHFQHECx4AOxA5GSgzyAiuOQG5Ndv+SZ5IHjNnvi9Nz086L3em76OWZP/IDHpEyFtBPvtb1PcN6l1Xk7XDuIQGHihA5OvXkDkZZAgeTsfm5/gdxEWgKcd9vpeGrdH7TBA9HRAj7VXa5nSosGb7W7PFIo1HjqKxa/DGiN2Fh4AirBKqNAbmKNjlIu1ujl6h8vo77VIFKt4Q2WZ/maa7E6kJjUGtUuKgRH1jkhEK2gVhG0hkMVSYfPOBBhJwQqyCNN26Y1EnbFpApBWyTi6qMIQXM4XBG3t4JsXfH50CJRQvp43FosWsgMa9o2LX73tlSFoMnn3pcEgmZ/pECWrESabZ//GVs/+WOy3f0FP59HYPXF6frv6+m69uaSJEeqEPK5V5Q3bZvG+iiKm9JKETTXRlx9hICmSKhk3IAeitJx0gi52HXrdaTe2VYgN3qsmpbzt6BHooXPRMaWFBhjlm3TUh0pqRBTDA+aP4gRrWbDFZ/BE3HK0+jhWIHkaP4gSl451RwIVVTk6ZZe8ldTA170GmdCYElBQA0UjvnrgsXkBrClTa2nznWsUFBo9rkXUgVo9Acr41aEa38Dh7zEDPfxxJY2jd4a1xQHqlCoMkoF2RebT62hkkxc5LMeu/tIgpr7qoRE0uitrtjerf4qV1omgDpfoGIOK00RyN7+wvaUVltF/acudWJyunvp+saN5Hr6qPVXam+YUV2+Xtm/w94nOO/SFlcd5b40j80h9acRbPBx8s3rCyTnrnMfKJCbk29ez1kLzyCg+suSJQXBEY2rmRNpRylzQypCYX6sg+Nal5YdAASCkObjrPZN7vJIaXNyy7Guy7ISyZq6E/EqIXwhg4tvXMBlt4+QG+d6CqtmnMr/3H08n71tKoHQ+IevQKXaN5/JkRNdBgCBrgRZX3+S60BiY3PexMNdZ+YSySUzVxHz+Mq2kyoEp82Yx4rW8nJUVQjmNzZy9oL5ZeWRAqeo3RVLl2FJWTafhCUlZ7ZPxEyWzwZrS8mWJUup8vnKXk8VgpPnzGFVW5sr7rn1DZw7p7yMVgABXefymatdHziWlFw6dVPZ4+C093mT11LtCaIgsFJZzP4E2c64U0enux9VCDb4W4hfexPm/h7soSHsMRl9VSGYVVvH6Wvc29tn6FxwwnJsFwm4ZUs+cNJK12VRKeG8QxdTGy6dm8YIxZh88mXE6hvJ9fWw8+YfjCE3sQLuafU1nLVsgauM1qNrXHbwspLSddXjY8KJF9N+ymV8/LTNRcf0cIyO0y5jwklOkVAJXLRiMQ3B8nlnVCE4Zuos1jVMc5W3TwnVc2TjprLjkgB0RefY5mNcxwobm3M6jnCd6QvgvMlOMV23+/KY9tkc3DbZtX9PjtRwwbQlLuMgGIrGRZM3uW7hWNLmxJbjyo65w7am9lgien3Z8UugMDOyjimhla4+VZ5m1tQc7TppVoTK8S2V2/u8iYdWTPZ4zuSVtAVirv1kjbeO+HduGyE3H78Y75QJ1H/84gLJ6fnWzZzU0OZKOzVFcOL0/4/JxP9ft1mRtYS1WUW1VWBEuDEjfBzTwguZHzmCcIOfw7+8tOjzh395KZNaF3FQ1SpObztlXEDc8HkNEeaEliO4eurxYI+XdUoJ2IIrpxzH+RM3EFAC4zA5ryVXTt3MwQ0LmexvL+kDcET9KhZWzWZ19aFF74/G1OSZwvLqVaysuxwpnSj/aIO3yEeICEurz2Dj3K/gC+klcdsozK3+BDNi56MrkTKYJPOqP8iC6Go6/MNBaqNP5vx7efUGFlbN4bT25WV8JDMjjWxuWcAXl20sBBeOQUXIMLh6wUo+t369c/OPdwHgi+vXc+nSJVTl4yzGXk4Cn1q7ls3TpjMvEqPzhpvY+z+j8knk/Q+vqeNTZ52NdcedzsrFeNjMrKnlpFmz+cLGjSMBtmPcAobBB1es4PPr1rvKaL+0YSOXzl9Ctc9HKeAS+NTytRzZOoultW1l2hJObJ/L6vppnNG+uoyPZEqons3Ni/nkrCOxkejVYSZ+9SyMhmiB5ORe7+JXH/gKQ51d6DXV1F95aaH+0Og2+MqajZy3cTE1Qf9wtPooH+fe+eBRq9i4bCqLprcU3h/tA3DEihmsXDiRsw87qLSPlExuqOLY9XP59LHrnaX+Ep03Gqvjzp/8pOjthhNOL5CbYdxfOHwDF65cRL0vULKfIOEj61dx8JwprOxoK4lJ9fg4bvlS1s6YyMVrFhedRw8NFwmVTK6q4qSlc/ni+g1Ie0wb5a/nU3Q+umoVn5h9KGoZ2bKU8Ll5R3FE48HEjFjp8QQ4pfU4FsUOYl5k5sgFir4cLK9exEFVczmvYx3lGmBisIp1oZlc3jAvvxdZDMrsiePN5vjonPV8dtEGdFUZ5+P0Xck1yw/mvKlLaAqEKHU9CXx47hrW1s1iadX0Us0NwLq6uSytmc1K36EMdiZKjoNab4gFnsUc3HA5dulugsDLurrzWFt3MUIYpdsb2Fh/Fatqj6DKqC7TTnBYw8ksqlrA8qry7b2yeg5Lq+fygcnry5xHMiEQ5ZS2lXxx4WElfBw/j6ry0UWHMaWlFb2umvqPX4RWHQVAq446r2urmNTcynmLV9AaipSDzdWLVlDtc1/lea/twPY83rey9kL/Dn6+06bF10h7oIeQ7sSY9Gb9bE/U8NC+bRwU28f1b2xD7Q3x3GeKa23d++mneOlrMzi04R2+9+LTdKbrqA4MEPWmEQJMW2F/MsD+hI9f73iJZ/d1sqcnRMCfIuDNoChg25BIe0gkfdz48lPMjjXx1l4Ff8CD35dFVZ2BP53WSKW8fP+Zp2j01vDAtgECvgAhXxpDd/Z0M1mNgaSf23ve4oTWbm5763VUpZoa3yAhw/luGUtjfyrAiz1DnNC8g5/vfpi+TCN1njgxLYkiHAl8dzZEVzbI9P2PI+3n2ZmNElGHCClpFOEU5Ru0ffRbQR7ruYeJgckMWIOoKGj52cmwisCSOi/03YlHm8r+9It4hUpWagWFgYqNoVi80X8fe6s380D3PwnqJilTxZKOMkwRTmXjXemtvBjfyvWvPIqqSSwrf6FhyY4iiZspfvX2i7y9qw9rOC5ilAsAtuSWp59hWWMLvX1JhAoFhajEkYlbgpv/+RTTamt47vVtWINONtq9115P42WXooVj2Pv7uOnLXyXX24NRXUNjMgOe/Hbl8JTIhlf2dvP4Ozv54RNPODlu5HhI/ZkMv3z5JbYN9JFTnAJ60h7WrElQnNpJNz33JKsntdFtD4AmoFDbx/n+im5z42uPMa+hhhcH3sbQBTlTKZRTUIRE10zu2/ccFw8t5497/4mhWOTs4dKAIq/osXknuYtne9/klrceQaAgsdFrIkz86lmFSsgvffhGAGKNjYQvuAARjhb9JMJyKoXf/OTTHB6bSHznEKoHLI9kuDFEDows3HnvU8xvqOeVv2/F8AhyfhWp53HnJHrS5J+/f5Edxy7hz3c9jd/MkQkoWB5HGiZMiZ6w2LtnL888tY2f/v4J/L2StA8sb/56lkRPQXJ7J2ff/rWie7rz7judFZxQDC0FnqTkjj8+zaZ5k+l/awg9CKY/31ekI+32JOGue59mUWMTLz6yA69Pkg0K7PxukJIFz6DNv+57nW2blnLvvc/jNyETkFgeHNyWRB+CvXt7ePKlHdz2z6fwxgUZr8T2UlBRqSkwk1l++eiLdEeGGBjUUA2JpluFfmXmVOycxvUvPsE5s9vYl44j8vfQ8H0pAWmr3Lv7fuZFJtGZepKwppC0jLy6ETRhEVBz7Ej8g8700Tzb/zvagll60n4SpoGzMmsR8ySxU7vYcOg6duzZw/Rvnkg6WEsi4/hYPX3s+eKt9MZ8/GrWXBJ6AD04iJ3WyGZ0HHmbRPeY+HwmP97+d47Mzafb7EHTFMxR/VtRJIZm8ZPt/2J14wQe7X4TKUa+27BZlsJDna/xfPUbXHnSR0j3DXHYDw+lutGT7wIK+3bnuP+yn/Jw0z859fpj6FIihLQEATWb9xEMmV4GTC8PdT+EIZL0ZVU8io6h5FDy7Z2VKlnTy0P77mFp9SA5aydeRSNjq/m4HImGjVe1eLbv10wLLWR/+u/Ue3TiOT8Z2wkC9igmUT3JvtRD7EkdxT97/0hzIE1fxkvS1AGBJmwinjRC7eXZ+PPcueNZwv4siYxCzlTz967E0E10I8N9g69y9Lc+R9ezj6BGo0VjpVYTpekzFzNzwmSe7uvhnXh/kWpqeGBSbcGPnn+WC+ctwnOAoRbvhb2vonqXKqpPPf9j/rn/lcIyp4LNWNnfwuh0HnzlWV7/+EhZ+46PbGbbt39HttNJuX30dZ/kBTk6Kl6OenA5D4t6b5jd/aOL7BX7ONcX1BhhOpODBZ8RG1lAXNrUzDP7d49anpVFPgqCTe0tPBV/fdQqwPD18qRCKCytqafXen4Mbpn3cfxqjTBt3ldHZUUej1sgmOD1kTD3MX4KMIJb0VazI/F6YXl2uCmGV1gFAo+6nvu63ingHuujCoU2fTJ/fWsk/qOUbLnOE6B/j1WIeSmFSEHQYoTZ0z+QRy1H+YzgXtzRwtO7dpPu7WX3zSPZZ+tPOp2uX96J2dtDqL6eqgsvQs1nE5ZjrqUKwbzGRp7u2jO6uceBqvH7iVspcrZd1gckrU1Bdg7FncOlm5uNk+p5rn97oZ+MbUsFwbrGCTwXf2Wkl4zzUZgUmMBj+/aNuojjlHh1J1s/fnvh3bYrr0Jra8t7jG9LIWHuvii798XHLeCMXh5fVdvAy8+8UyCnY9tSUQQLl3Tw5JPbxiAq9pk8u4lnu7vH+QBkE3Fevf96MkM9eMLVtG08nR3330l2oAcjXM2kY7bgCcYKuNtroryTx13qegDL21t47uWdhW2qUpgWz53AYy/ucMc9pY6nE/tG+Yxvy3DAQ9+k5Kh6Y+NbUwBHz8qyN91ZNA6MRb6xroV3ks+73JcKbf4FPN//ygim/O83HHKU7Erx+w88QN+uPryNERZ+7yQ8tSFS+wZ57kO/JL23H29jhFXfP4t+fx1pK1d0rdHXA2gP1LNtcH9hK34sJoD1jW08G3+77DioCsE8Geb28782qlzFsfjqQ6S6hgo1uiItMY66YR3B+kDhPGPHOJ/qI6oNkbXTY65V3JYT/E3sz+woO34BNPsW8fbQS2XbW0GhzreIx3rfLtveAkG90cY/upJFPmPb0qd66OkJkjCzZX0ApmtNvNHTUwgPkIVvP+L07U2HccL0Wbwbe18mXsHeS4Jz8IOfJWW5KyVkt81TH7qlQG6mfuNMjNow2e4B3vj4T/Lvx2j/0gWI6vIJC21LYObcA0ilBGm57zxqQkEzJFnbPRK/JQYJ6SaBh0Z/mirfkOs+dkRLMtHvVnHdIYbVmvu1BCq7s3XkKijX3h6awp60e8Bff3+YnoGAe4mBjEAdqFA+RIKadg941BQFRVfI5Asp5uJ9BZJT8KmqZtqVV5MO+MctFI82VRVIgbtMXMiKa7NSSAi5Kxo0oVBdnSZTob0b/YKMTLjiTucM0jlPUXtnu/vZ9mknoVzhmmPqYY01YULVKyUPFUxVFar25sgk3XEHwl4Sycy47YLRZoZUcmFtXDxPJhnn1fvy5CZYzaTjtmAEY2SH+njrnusKJGfyMZdhBKPOwlgF4YumKvjTgnTaHXcw6GUo7Y47FxZkI+7Vna2ATbrd/VqKsDloontxYlUoTA4OYEp3ubUtowyaWdxiFne/Y3P/ZX8glSczsz55GC9/7c8FcrPweyehVEfoT1UQJMjKxYlVoVDts0nZ7uN3ox8SXZ3886pfF0jO/E8fzHPX/K3weuO1R9Dcqrt+N01YRDR3aTdI/GqF3wQVUwYryvIHzTr6ctI1Viee9rI/FXbFncspxPsDZY/nYUO/u9hCFYJjp83k25sOcz9XBXtfJv4ftAPhh4rfQI8GisgNgFEbdl43RNEiAZQK6pD30g6E1VaSRo6cqZI24r2y8TElpezAfP5zqJ0LjmDSozHqTzq96HD9Saejx2IVkUt4VzLx/60d6OznfztLGk1ujIYYE79xLnpdbCSbcryv8knKmGB8HEQpeze9W9U86J4gnmA10w69FCO/UmMEY0w+ZgtGuBrNF0TV/5f39AHhPoD+/R7NWw+0sOV7NZ746wMc9L2T8TZGSO/t5+krf15Ebrx1ofx21HtjBzrG+epDLP/v4/A3hUnuGRhXgDRQXyF/0wHagUi2h8utHIhfZZ8DacvKPgcqNa+UluG9tvcJzru0udHyqiZwlvBnNrYz5cunMvWbZ47Lx2LUhpnxzbM57LsfQvrdGXCVt3xRtGETQJXHXW5uSptpkdqKkuRJwcYKlXYFTb6WirkkFFFV8QawEXjV0rP2YZOYNHjbKkjXFSZXxK0wo6q6Yo6XaMBTsfqxAGpK1F8ZbaZtM622ptDeuXgfXb+8s8hn3y/vpFUR7hWwhWBqVU1FmXjE8FbEjYQ6n/ugbEqbycGGCjJaQUewyV31gWByqLawepPbP1BEbjquOYvAjFZmff3CkQrn119fUm0mVaitCrr2JtOy6Zhc51pVXVEEkya6S1YVRTCxqbqkqkkzfExbfyEzNl1KVbQWVRlpI4fkXMakIx1V07DVxyrjnjShxr2QqCKY0lYBtxBMrq2u+DAJ2h60CiobyxZU61XuPtjUe9orypZbfG2uj1yBoCNQi1EXZNYni2f5sz55mENugJChoiuVUzg0+6Ku7W1Jm8nBxooy8Qn+Fuw8yZn/6YOLjs//9MH468PUGs0VCYUivK4FlcEhilG9ETdSIbFp9E6o2N7t/hbX1RuBoCMYq4jbryt4KqSekEIyIRKp0N6SRY1Nrud5r+19gvMu7eS21a6ZOVWhcNW0wzGCfoya0stpak2QDy0+kkZfeXmkAM6bupRNLVNd5ZGHtE7lgplLynY0BUFTIMyH56513eZQheDDs9xlhjaSs9uPyOemKYdbsKn+MCZXkEdOCi5nVvQ0yt3YAgW/VsfaurMr3rRnt5/oSjptbC6dsYG2YNRVbnzerEUcPnWKa3uvm9jBBcsOKt/eQlAXDPChdU4l5dHbU1pVNc0fuAKtqppcbw/PfvubyP7+sueypOTqlcuZEC2fm0YA58xfwFGTy8t/VSFY29bBxbOWlDw+jLvWF+DKGRtdt/EkcPnUI9GV8ntiNpKLJ2+iPVCDIgSKz0CN+AvkxqiNIBCcv/wQzvnOd9Gqq1GDQRRP8eqHKgQrJ7Rx9uGLyg7JihBUhf1ceMFaLMt94P7AJRvRda3sKoVtS847dQXtTVUl8+Vohg9fIMZJmxZwxOLpRX3JCEYL5EZVBIuntXLuYYtdcUeDPracutq1wrmUcMXpa/AYWtl+YkvJRYcvZUp9tasE/NTFczl+4mxXifDSujaOby2feVYgCGoBjmw8rWJKiWObT8ejGGXHConk+JYjqRvy8crX/lx07OWv/Zn0vkEEgs3Nyzm6Zb6rlHxhVRsXTV1dtr0FENa9XD7tMNf+bUvJxZOPxqt6SHcN8dw1fys6/tw1fyPZNcCxLUfQ6itPOgSCVTUbOCi2wXUcbPVPZWXtSZRbExMIPEqAQxrPqdjeJ7ScjE/1urb3KW2HMiPcXLYtFQTHtS3ilMnlUzOoQjC3upHLFy1zbe+gYXDM1NI1J/9d9j7BeZe2tHoqk4xJQPGy+LCE8IjaNcyMtHJ03fKykuyZvkmsrJ3K1dM2YdulfSKEOGviUj4yex3CUorjcPP/FpbCh2ev49zpB1GlBEaOMeJn25KPz1nHmsaJHBRuK+mDhNPbDmJOrJljG1aWxT3RbGBCJsDRjSdjjpGuJ7oSZIeyCBnjkLpNLK0+n4ztKTrX8L8ztsGSmguYGjkBSV3JtjQlzIpdxqTQQpp8c0v6pAZyNKeW0R7s4Njm1UXfK909iDno7LVPC7WxrHoWH1u4tuwsN2J4OX/mYq5avmLkxh4TYykQfHjVSk5fNK/sKo4tJR9cv4KVHROYE/AVk5sLt+Cb0EHzBVuINTSya8cO+m65iVyJlQuA2Q11bJo0iY+tWjWOnA7PwsJeDxcctJCrl65AUUXRcrYsdBT42IpVnDl1AfWBkaDI0WezpeTDC1azrHYSy2s6SvqA5LjWhcyMtHJS62rGm+M/NdjEyprZXDljE7aUqH4vHV84nYlfPRu9JgJAUPNwzsSVfOboo2m/7AoaL7gIxesbfSkAPrJqFceun0t9aLh/F3cC25ZccsxyFixoZ/G80nJrpOSQDTOZPqOJk487KC+lHt/BJ7dUsXr1NC4/cZXTAcd2XiCoapx55CI+cPhSDCnG+0iJsOCqo1Zy7Ko5NPnL4LZsthy+lIUzWlk1vTzuI5ZMY+akRs7atHC8dD3/7ym1MTYuncqHD1k1IhMf03cDis6FaxZz1ZyVGFIrOZ5gCz42fx3r61YQ1WpKQrKl5PjmzUwKzWRGaCGlTTI/uooJgSlsbjwMWSgeNXIcoN1XR/1QM49c+eNCDM5B3x/Zrnrmg7/E6Bvi9LYNXDJtDX59OIy3GLgibD40ayPHts2nLRAuusbwvyWSy6avYX5VOytrZpZrbjbUz2NmpI3V8iD+NSoGZ8W1JxS2q564+ndMTNdxZOMZjopwfDfBlgEOqd/M2rqTsPGWHAdNKdhQfw5zIhsJqM1l23tZzelMCExnenh5Ydwb6EoVnWtmZCXtwWmskEvIDGZKdRPqPfWsrF7KZVMPc36REph0oXPuxHVsmbUCD3pRc8v8v20bPj5vPcdNm0mHP1qquZESrpy/rGJS1Pfa3peJv0u7b+dbPPRWPx5PmGAojceTQ0pBOmUwOOjl+l0vsaFuLrc+/TKoIbyhDLo3hxCQy6ikh7z8I9PDX9vf5KsPPUIu40P4cyg+pzKzNBXMhM6+tM1Nzz7J87s7sXt08AjwWU7FXUtASsXOaHz97/9gXl0D8a4swlCRPhs06RTZyyioaY2v3/8P/IrB02/sA92AgAl6fjaQUSGp8pN9L3Fk+0xufPpFB3cgg+HLIYBcViWxT/LSt77NI+a36LjmHFKReqr8Q8S8SdL7Bnnw8j+ghAO0fvZsbo3+iySv8PJAA1XGALXGILpikpMq3ZkQvdkIt2/7LcurG3krJQioEaJqEkMxsaXCoOWl3wzStednoFTx2tCbqBgYwilICjA0YHPnlidI9v6DiX9Zzt37/oGNo15J7xvkmQ/+Cj3mY/7Xj+NVuZN/dL/ANU8/UpDFjrX+bJobXnqct3b0OZlsxzwgkM5K0Nce/jsrG9vYn0iWnHQpAr593yNUBwI8v78XNeBsCzVfkE8EJ52YnNjZF+G/63Z6BIR9nmHV66gTwYvd+/jjm2/w1cf+DgbYlvPwBECArUj67QzXP/Mk25I95HQTKUCYwnkYCrA1CZrFl594kPUdE9ifG0DRwLaUQkMIVaKqkm+/+ACtYR9P972FpjjbFbJwOYmqSH6/+0mOaZ3P3bseRBU2thTFsIXN1uQuHu5+jm+99A+krSCRKH4vit/JmWTbgoFslhvf/Ac738yh+MKoYlQ+KIlTANOEr9//d44KdtC3ZxBNA0sXyHxpdSUHuiW54cf/oMXn47n7XkHVFGyfjtSdJXaRtVBTOR646wkOP3Iev7n+QXTbxvIZ2F5nOBQ5CzWZ453OQR7+4wvcetdj+LpzZH0C06cgFVBMiZa0sDM5fnrHv9iXTqF3mUgP5PwCW5UIG/SUxJu2uPaWB1m3ZAoDb8XxegS5gIKlO/1TS9l4EpJbb/477bEIz97/Bl5DkAto2B5nDqqkLfSExYO/fo6jN8zlV7f/C59lkQuoWF4VKUDN2mhJi917Ornvvpf54d+fxtsPWQMsD05fsEDLgJnNcvPvH2d3dZLcAKCpYFgjhUuzCuRUrvn7w5y5vIWtiSF0xcCjmmjYSCnI2ioZS+Omt//CtHCMNwafQmGkOORI15W8EH+YpVWbeLr3ThoNi0HLIGXpSASGYhJUM/Ts2cOqi5aza/teQs1B1vzgCMyqGhb91wk8/cFfkdrTzz+vvJOfNM8gHa0l6utH01QSGQNLKijCqUoeMkxu3f5rVlWtYH9uPx5NkLNUbOcWQFNtdNXmlq1/Y2q4nvs730Cgoik2Sr732lJg2gp/3P0SK9VWPnbSZWT2DuBtjLD4v47DXxdi4XdP5MkP3s3g7l6WrVnF6h+cQzxUQ0hPEDFSqMImZ6vEs34Gsz5+tPV+fPogO5IBAqpCSEujKxaWVBg0PSRMPz/afjdHNi5lRzqOIbx4lRwaTiHkjK2RsQ1+v/c3NHgn83z/U2QHbe6+7F8kezOccfMqgg0BLBSeiT9OS/J+rjrucjxRL2v/63A8+TqHErBthd2pbh7c90+uf+0lsjkdIcxClXdbgmWrZHOS615/kFSfl/SgRKr5fpIfn6SpIHIqX37kIc6dtIBdu/vRdIHlkeTrIKPkQMsIrnvgcU6dO5dQhYze76W9r6J6lyqq0/50F4937iy73aMIwYLqJp7v2lvWRxWCqZEaXtvXU/L4sEUMD4OJrPs+tnT8+tPuyoDp9bW80bPfFdPcCfU827unpI/ZG2fft3+I2d2LXh+j/SvnoNdGyHX3s31UNeL2a86lobmKxsguVzwgmRNOk7IGXb2qPZPpTO8ctzw72JXk5xc4pS+iLVXM/vYJGHXBPLkZkZgu/K+T8NeGqVbaeOwddxVCUDFI7y23WFyATa3ipy9ZoWBfYy2vd+8nm0piZzJFKfzBae+JQZ1XhvoRXm/JcyhCMKk6xusD7v0kYOgklUyFFOyS+mqDnkz5zMkAy5qjbE2U7gMOboWFVQ28mdhadi9fQVCrN/Hs/iHXa/mkh8HXfO6xI1Iy/S0vfXF33PM9Aba9tBu7TG0nRVWYNqeF117Y6axylDChCBqn1LG9wrU8Pp2ET7hmTkZKaoJ+evvclYKzWmp4+43OsttriiqYPrOZV17bWzaQWAhB/eQqXnMtAgyGT6N7Wq5CaQTJ4vkJenL9Lj5wVKOX3uwbZbdNFBTaAxPpTL9KuTsqM2jy40ueo29/gs03HEywYUS5M9SZ4Hcf+BveKi9H/eAwupQa961TCbpsZF96wPUumBZq45X+vWXPpQqFqVqU3131HXLxRJFIBCgoYQNVYWZ+9Wi0YPmHt0dRqPUPVohZlEwPeYjn3FWn7f5J7E5tpb9rqDDuDWfFDzf4GepM8cuLHqF3Zx+BpjDrr9uMv6445k4gCCj1PNHlTgE0NIb2BkbSTpSxiWaMPfHy7S2Azxy2njMXz3c9TyV7XyZewd5LgjP9x98lZbrLbcOKh8Gse5FJQ6pIS7gHkNogrMrBowdStRiVih02GNXpt8rLGs3eON3f+SG5fQ7Jaf7gcez+3m9GyE2e9IQ9adoicXdMwqLd7/7gVlDJYmDJ0u09unhpOYnpcKBifCBE/2DAPdA4LVD7K8jEbWd24vrdFAWhCbIVCkD6QwYDpjsxFRoIzb2fSEWCUaETCIkWqCwTr42kyVaQidf5BBnpTgKGMl4SGZ/rQynXZZLbqqKNIX8AZn8c4fGgq15qn3P/bqqqEN3WT7aCTNwf9JJMpF0ZrBUwIOIbSfZYwmxNYAYr6fIlSs59qFVVBV/aJlNBJu4Pe0mmsq5KsXRMJVdjuMbz5IKSwUnumBTFpn3GXnfcQmFJ1V4k7iQ/rOlYMuka1Nrdp9A7YOCvHy+UGOpKoAd0bJ+ffekK9Zok9Kbcpc2qUBDSIGm5t3dI1xkaGMBMZUrGUWb3D+AJqIQjuuukwlBMqn3u94kC1HkHKvgoeFS9kE9n9LgXaQlw+FeW8qfPPE7/roRDbq7djL+Myqsn6ac7EXbFbWZUUvvdhRQKAn2/e8SLIgRHzZ7Gt4493NWvkr0vE/8PWqVaH0CRwqKcCUSFpYL31g5EalxJiaNVRWn/3EUYDTFyXX1s/8St48gNlN4CGmsH+tXd1FHhBj8n37yeYJOLxHT4PEJUvuZ7o6AsXO9AfCp5KYj3TAJ8IHZg/USpqJJTGLvnVmxWIs3Ob/2YXTddS26MRDwX72PXTdey57YbMTPuD9FhM+0s6VzpB0U6N0DOSqMooiJuIf7D7X0ApbSFEBV/F8H4ci7j7D28LysVkRzxccftDRkE6ks/TIP1ATxB4z1N73BA/RsFLegtKxIxasLoAU/FtjqQtqxU+HLYRvfb4XFvbJ3DcHOYDdceU5bcAE4YRIVrHsBIeUD3iCA/uf4P2vsE513aupaJFSpXw6KGZtebUhWCxU3NrqsJAmiJhCt2EFURtITD7nJU22ZxU3Nl3PWVcS+ZMpemq48rer/5g8cVyI0Aolotmqgk69SIGQ2uHjYWHYHprvLISEOAs751YdF7oyWmDm6FJXXN7kn+cCpJGxXkkaoQTKhyl6Oats2iliZX+a8iBIub3CWUqhAsamyuWG25wReqKOtUEHSE3Ks7m9JmXqTdlcQrCGZFJroOkioKC6tbXXHbqSwMJTF7e9h983UFkjNadWYlhpBWlgmtVa75WTLpBM/v+SVP7PgpqTEkJ5Ub4PEdP+Xpnb9g0uxa14FZURVmz2p233oCqkI+PB73FRyhCDom1Lg+UC3LZs68VlTVaW/TTJPOFG8NKYpgzpxWksk4pll6dVVRBPM7GivKxGtVHz6t0gqlQoe/yXViYUmbVv+siukbWvyzcCuUK1CYFJhU8YFbZfjwqe5xHELAtJB7ughL2iysmlCxf8+PTXBtSwXB9PCEirh9agifWnr7eRRymn0drsTbxqYjMKOovcMNfg7/SnGdw/O/cw6+MmTRwa0wL9ZYkb5E/QZhw729pYDZTXWuEzlLSlZNbK9wtffW3ic479IunLWobOcXQMjw8LllGwjo5WceEvjo0tXMrKkt20EkcNmipZw0a5arpO+U2XPYsmxpodOOrV6tCMHMulo+smol2b4+p7BjCdxBw+BzK9YRMjyuctQzaqbQ/f17i97f/b3fkOvuL+A+f8paNtStdJWSr61dwbq6E8pcyRn8GrwTOLzhdJeBRJDeZ/HHz/yq6N1hielo3JdO38S86kbXG/LSucs4Zc4cVwn4cbNmcumqJWURKUIwpbaaD29YVXZGLQCvrvGp9esIe72u7f2hZStYUO+Oe8vCJZwxfb4r7mMnzeLymatccU8OV3PFjEPLx3oAHlXnsimbCWuBsr+vhc3Fkw9hQVVrWdx6TZiv/eIWqhqbCiQntWNbkeqs9aLLOHb5Us49cXnZtlQUQX21F8UwSebiRSQnlRvIv46TtZKceNEKIjF/2VUT27I559INzJ3bWlImPmynnrqc4w9fUJZ0KUKwfsU0zj5tRdm2VBRBc2OUiz+wAXDIzbMv3c4zL9xMOhMHnIe2rqscc9x0nn/hZp57/raSJMe2JRecvopF01pc+8k5hyzm3LkLXPvJ4ZOncnbHwWVXFhQEjd5qjmk+HbfVGVVoHNpwPgEt5iJbttnYcCrTQ7NcH/CHNBzOMU1rXVNhrKiey/mTN7jj9kX54PTDXEm+pqh8aMbh1HpCZcddG8lFkzexuGqaK6E6uW0dhzdsKntcIDgoNo/DGk4oO8YJFGJ6DUc3nYkYRcwGOpP86TOPF/n+5pP3YvSWX121sTmj/XBW101xxX325OWcP9c9FcaGCRO5Ys3yss9CRQgawkEOnjG55PF/l71PcN6lza1pYI6nsaTMUtpwbP0s2sJRjm6agbQp6TfP18DsmnrOm74QacqRY6P+W42PwzumcMasuajDcThjfFRLcPqsORw2eTJVihc7lWLvzTex5/qR6tXSlJwzewGRTJb9199A5403YQ8HyA7jlrC5fRptkRjHNM8si3tyWufyk04lsWe/sy319fPR6/PbVZ+5nVx3P34ryCENs1hds45UzpkFjJVQpnIGq2vWMT20nIxdX9InYwlmR46j2d9OUJ1dUtLYvzfJXRc+zI5tO6hqqWfB908pkpimugaREpo8bUwPt3HOlEXYVun2DqtejmqbzqlzZqMN3yZjfISE0+fNY9O0SVT5SydXtKXkzEXzmFFfx5yWesbKtiUSG8mhM6YwIRbl2FnTCxXOx/pNqa9mQVMT5y6YPyqYsxhUyK9z1JSpnDptLpomSvoIITl75nw2Nk2hplDdt9jHljZnTTmIKaF65kSHq4kXmwTW1c2kxV/DxvolToXzEr9Li6+RGeF2TmtfWlgNGfv7+hUPZy3eyG//+Cf0qmqH5NzwgyJJvR6JccbCeaxcNInqqL/kb2LbkjNP3MAjj/ydSLCGVJ7k9CV3FciNT49y5TlfZtHSuWw6egHSsktqZFsnVDNzwQSOO3ah41MCuN/Q2LBhJps3zEYfzrA7XiPM8YfOZ/miidSG/eN9pMQ2bY47bD7tHbXMmdGEaabJ5YZIpft45oVbSKfjSFsyc3qEU089lkSih2w2gZlLjztXW0OU2XNaOW3tfKQlS2IKqBpHLJnOyTNmY6CWbEssOHvmfBZXzyCkVpeCjWnDYQ2rqfO20uyfU/L3lxI6goup9jYxP7pp1CpO8YBSZTQyITCbTXUbUYRVwseR5S+rWsFhjUvxqUpJH0XYHNu8kuU1U2jwjpWJ5/s3Nie0LqEjWMuCyOSyuJfEptEWqOaIumWYpbsJNaKeg6omckT9GjI5pXQXyAXYWLuI5VWrSGZDJX2SOZ3VVYcwJTiPrNlRsr0zlmB68ChqPU1E1GXYEgb2FsfgnHLbBqpaa9ixbQd/ufS3xPckSkrXNbuVmeHpnNyyDLMMbjXrZXPzAk6aPAtfTi/VlIgsnDttAcvb25hghEv9tNim5LSZcyquiL/X9r5M/F3aPS++yuvb9mOoGpbfxjYkSFAyAjWp8PPOF1nb2s7dj7+MIVQsn8T22CBAyQrUlMIrXd38+rlX+MZfHsbICKxClWRHGqumBSk7y7UPP87zO/eiDUpQR0k/JagZ0CzJl373AHObG0jFs4ihjFO9uq+HPT+8npZzL8Xrj/Hln/2Wrp/dQLJ7H3qsGgYzCN15QCumU7n4V0+8xLrJHdz11ItoQsX2SKRu5zEJ7M4BHv6hM7vWa6up+9DFKI0hWj53Pru+5MTibPvUj2n86KV895l/sl1uZedgCK/mIeJJoSk2pq3Qn/GSMj185YU/sLG5lreHdAylhiojiUfJYUmFAdNHf87HD9++B0vqPBPvRBNVRPQUXtUJlN23J8efLnmY5J4Bmia0EP78cdi1YaZ943Re//idDsn50K+Y9LUz6anez693PM1X/vWYI4dVpCO3F4AtwBIkMPnO0/9k67Y+yElH/jocQiBBsZ3ZwRf+fD/L2lqJp8oHY3/9vn+gezWe7dwLmhMEPjyTlwJQ4O5XXmbDtIn86OVnkB6QlhNQPlwBXKqS1/q7+dkrz/OdF//upAiwBJj52C0hQbdIKhbfefYRtiX2I1XL2WO3RnyEYiNUwaef+DPr29rpNxMoqkTaI7EmQrFRBHzzpfuIelWej+8o+93+tPc5NjTM5Ofv/AOJiiqcPCROzg6BJRXeHurmnl2P8a0XHsWyhdOHhCyQacsWJGyT7738ILtezdJ44um8c+MPCteoP/F09FAMbMnn/3g/m/3txPtT4x/I+Z/whjv+QdUZa5lfexJPZH5GKhfn8R13AODToyxpOY3nHt7JP//6Ir+++WEHhKJQKO3sgGLXW5384c5H+eldj6NkLGwFpJrXUUtQLItc1uS26+9nXzKDTFkoSKQuCjJ/xbRQpeC7//0X1i6fTH/XIKqU2LriBINLUCyJMCW33vggVQEPLz6+Fb/wc9D083j61dsKJGf2hGO59sbvksr24fPEOGj6uXjUUF4FJhG2RJg2e7Z187u7n+LWh59FT0ssRWJr+YHCBtW0schx7c/+wTu1aeykRBECW5cj/dsUKLbgs3+5n+PXtrJrKA3Ci0czUfMqhqylkbVUfvDa/UwJ67w6+CoCA11YKHkSY0kFU6o8G3+Kg+KP8ljPL/IxHcMFefN9Dkk8t4cne37HA/v+REjNkpWCrK05P4+QeBQLXWT4c+cd7Ejo6CKDX5VkbRUpBUJIdMVGF5Kbt/2UuaF17M8MMFLgZeRaADe+dR81eg0P792OQEfV7IJM2rKdCuR/3fUmf2l+je8//xgWfjyGiW44KTwsUyWd1onbCX702lPc/uaT7EtG8HiyBLwZFEViWgqJlAfT1Pnqsw8gtTRb+0J4NYMqfxJDNTFtlb6Uj6GMj88++0dOnzyb5/skHrWROu8Qfi2LLQV9WT896QAv9j1MrbeBv3buwOoJ8ewH/0RiT8KR1n//KHoiDUz5xiTe+eSf2LtjFw9e/jvmf/sUaloMBJK0qdGX9pOzcvzk7ce45amXSQ35UDwmmi+HUCTSUsgldTBVvvLoQ+g9CvTZGKqC6beRqjOOqSkFLSv4wj33c+asuXTvGsSjgOkHqTlNrmZATcNNv3uME5fOoSZcoa7Ve2jvq6jepYrq+Fvu5JXOLspt06tCMKWmmre6e8oqGhQhaI6E2NXrHj3v1TQyWXflCxI8mjZS2LG/j3fuuI5cvAc9Wk3jMaez9547ndexalrPzudjGYtbEUxsruaN3p6SsRNWOkXnrTdCKknVRy5Cq4oWjg1LyJVQkLqrLiAY82PE3GWmIJlWlSRju6vNGrw17Ev3jFt6zg1leOwjvyPTl+LQH1zNdg+FGJtsdz9bP3UHWiRAxxdPQw/4qKKGt/e6K5Y8UkO6qzVBgl/VSeXclRit9RHeGegvu4SrCsHEpireGCgv3RdAYyTInqx7WxqqSk644wFJJKiStMq3twCmehV29Xai144vApvtHkAPeJnR2Mw7yc6yEmEBBJVq3upz/231nEbiqTS7b7mOXN+Iok6PVY/KGyTpeE0jmXTBLWBKVqHz7W56Ejt5fOdPC8eWtp5BzNeCqiq0TqzhnTc7R1bxSpwn1lpNt8u1ABRDJeOtrKIKGTqJRPk+JwRMqA6z5539BUzpbD9PvvFjUtm+gl8oWMOCqefg0UuPXUJAqDXCbs19rBBehe5p4P4AkDTNTzLkoqYUCI5szTJo7nKViU8KVDNkbnWNwzGUGrqz7koj29Z4J+VeYkBK6E830Z8rH5QuEFQpLWwd6HVNg9Duq+WNvl7XOJwar5+erLssXxVg+NzTfIBkQkRhwCzfBgLBpGA1u5LdZIZSvPDJu8nFk8z7zsl468IF3P5eH3+94geoET/tnz8DNTA+/ickQ+ypIBNXbIG3U6uQvgEasj7iQ+XbWxGCy45awQWHls+gfiD2vky8gr2XBGfO179PxnSX/4Z0g6FMhcFdONmJXWXi0pmEuVqJ46NJTuF6LuRm2HwRg8FcedxWOgVqGqUpMg632RtH8XpQ/D50T45AzF39oikWLWF3gqcKFQGYZfJI5IYymMkcZqiDnkzx4J7dP4DqMwo3eXbQRy7pcW1vkRHoAxWWVOWByfKll4rV2/0RnYEKlekVXaLouMvbhUSolTuK7nPHI5JZ9nz1NnLxBNO+eQaeUfk/Mt0DvP6xn6JF/Sz55hmYfvfrJdIe0lmvK+7s9kF2f+U2cn0O+a4/8XS6fnVn4XXzBVvw+KPUvuDe4JqqEHqrj4GBHp7Y5azgDNvwCo5PD+P36yQH3as7S7+BCFWSiStY/kpV5yVKrrK83ZM2yY6RiceHdvLEG7cVXq9e8AG8hntAeiaqY9V4XGXi2RD0T3SPUrCzCfwT9pWVR6s+AyPoZ2XDTiTubVnvsREM4Uap0rZGzva6liFIWTqd6cgIjvx9PzrPiy0FOwejZLoHUP0GWomHuyoUEskgyQppPrzSRyJjVswrparu1dsVxcbwViCdQDTgPlaqKPg1QTo/GTSHMlipLJ4xkxDLDLN/dxzh00uSG4BsQic35HXFLeMptL0Wejg67lhuII5ieNC9Pgz3LB8oQnDYoml89Zz3ZeL/z5i3ggpBCNBVtaK0UVMU1xnJuzE9EqPxmOLq1RNOPMuV3AgBhqK6qlVUrw9vVXXJwEmtKoqSj0s5kG9lH0CFYIlEdVFj6UEP/roQujI+sM6oCRfd5LpyAPLf90iPKpFoqvutJgBdUVyD/cDJTfPv6idjzUpnMPuTZDrjvP6xn5LpdgjoMLnJdMYx40lE2qyMW1FcHxC5nn52f/2WIjLja3PKWOixanJ9Pey+5Tqyg/GKuCWQlUMFcuPToyxtPQOfHnVicnb9jFRuAE3XXIOHARRFqdxP3sM5oqYX9+90tp8Xt/+26L1nXvslmTIS+MJ5hCi7qlywCsTcSqfYc/PNvPnxO8h2F18v2z3Amx+/g7c+dxdmIo1CBYIHqEI/gHQClfv3aNlydijDPz74Rx7c8juSXUNFPpnuAV792J28/ulfYCZKk68DKdqpK0rFqurKAaQTOJBeckD3tnCCn4dNC3rGkRtwJs2e2khZcgPkM7mXv6adStF1/S3svP1acv19Rcdy/X3svP1adv30RsxUqmIbCeGIKf6T9j7BeZd2+MzyxRjBGfvWTeko6rZWOkWuP154rSqCddM6sGxJbiDurIyMMUUIZjTUVOwgPkNnekOxGivX38fee4qrV3ffexe2y8NCSlg3scN17FaFYGPrRFf5r0AwJdCIX3WvQWIoHiYFWt3lkdJmcdVsVzmqRLKmfqrrQKEKhY0TJlXADVPqqirWTvHoKnMa693lkbZk/UT3dAIS2NA2qSQJsFMpzL44qhBsaC3Gbfb2YydHBm8BTA7XENLdZZ2GojEvVr7IHoBSFeLCW76MpzFaIDmDr+wqkBtPQ5Tp3zyD9TOWuZIXVSisa5jsOktUvR781RGMqpqR7Sgccj5MctRgEE8owOzpTa7EJDnUy5PvjJCbJS2nEfO15FduRkjO1INqXSXgqqqwZMXkijLxlsYooZC7/FfTVWbPcVdjWZbN0tVTCz6jt6d8RowlU8/DZ8RIpHp58uVbx0nIR+NeNq+94gN3QjBMzFc6OB5AZjLYQ0NkO+O8+YkRkpPtHnBed8Yx4wlyyTQzwge55sIRCCYFlrhuTwkUpoXmV3zIN3iihDXngW4mc6T70iT2DPDgZSMkJ70vydZP/ILM3ji5/iRWiW1GS9psaJzseu8qCDY0T65YmHh1w0RXzAAN3gg1nvI5acDJKXVQbLLrGGdJm2U1M13vXYFgbcNU11QYqlBY3TLBNXWBnc5AMkmur4edP76uQHJy/X3O674erOQQ0syydFqbayoMy5ZsmPe+iur/KTtnycKyifwE0BgO8bFNa2gIBRE45Gb3HTey67YRRqwpClevX8n8aICdP3IY8ViSY0vJFetXcP7Kg1zxnLdyIZdvGJHrjY3BmXDuFYRq6+nv6mTHj8az8mHcDeEgH9+0hqZwqOxtpCoKH1qxkvWtE10k8JIPLlzFOZNWueI+q2MFp004ouzgJhDMj07nzAmbi2YvY32qjAhbph5Jky9aliwpCK6YtY5NbZNcpfsfXLSSi5YtcsV9zuKFXLHOXR65rL2VD69ZWXYlTwB1gQCfWLWGtlCkyMdOpej6n5vp+t71WH1xPrRoFYe2ObJOsydO19dvoOu7txZIjgSunr+SS2Ytc8V97vRFXDlzbVliIhAsqZnAJ9aexrxvnYOnwSE5r334jlHk5kwam5u4bOoRNPvcKsrDxVMO5pCm6eV/k4CXG351J1++5bZxK4sOybmM5rMv5pxVyzj/lBVlSYcQgrkzO+iY2IrfiLGk1dmOAvDp4QLJ8XuCXPjxY2hqrymfXE/A2VcczJqNM10fAmdduI4zT1te9jjAMZsXcO55q11xz5zVzPlbNuLx6qRzA0XkZvHUs4mFWtmw+AO0t3eQyvTx1Ku3lSU55523loNXTHedVV943Aq2LC8fD6FHolz+/Wtpbm8rkJyhV3YVyI3REGXq189i4aSZnNhyIoZSjlQL/GqAQxvPodpow21pdG3d6SyIrnH12dRwMse3HAGAvy7I+ms3E2gKF0hOz4udPHbVXxjYvR9PY5QZ3zy9aHvVQSSYHm7mQ7M24VdLp/AQQNjw8rH5G5gaqXElFFfPW83xHeVTSgBcOXs1l05bU/a4AE6YsJALJx/sOg5ODTVxyaQj8Gml29up8O7lsmmHMjVcX16WLyWXz1zHiVNnl8WtxaJ88847qGtuKZCc1M5tBXKjx6ppO3sLJ69ZwaVHLC+7aqgIwdTmGlbMaC/7/f8d9j7BeZfWFA7RpocKcrjCH44SZnFVI1GfhwXVDUgL7EwGKzFErq+HXbddR66vjzYjjNkf54FvfclhxIkh7Eym6HwhqTOzvo6lE1pRRisoR11PsWDphFZmNNQSUHVy/fEictN21hZ8TR18/rpb6Jg4kWyBlceLcUuY19BA1OthQV1jUdHD0X8tgRBN4TBr6tqRpTBJCEqD2VX1LIhMwsxohfOPli3mMhoLI5No9bWRSFcVHR/2SWQ12r3zqDKiiNwEp/DjGJ+sJYiJmUT1ANM8kxjeWi86nw0Ru45GX4zVte0UqhCMxZ0zmFPVwNLWFlSX9l7R2sr0ulpCulGyD9i2ZGV7G/XBIK1VkVIu2MDspnqqfD4WtjQiC4FWEjudxh4cwtzfS9d//RDi/axqmUC2t5eub9yI2d2LPTCEnU4DEr9HZW5tA0sbWtHUEl8MEIpkZWMb0yJ1hLTSKw8SyYq6Duq8YdpaJtPxkc1Fxzs+uhm9JsSkQKvT3sHJjFZSj/4LqdU0eqtYXjOpEBMy1sfAYGnbNA5ZfFBhBWM0aj0SRfH5WNbRxsT2WvxV3pJtaQnJspUz+fNf/sJxR34Mb57cDPv49DBL2k7n7NM/R9uEJmatnYEtxl9PCohOqqOhrZoFKyeTkU7SvbHXVCMewtXQPjECXrX076sJ5i9qZ0JHLYHaQGkfIVmwbBJVtSEap9ajqAaG7sdnxFg09Wy8RgQbmLl4Ng899BDVVQ0YegBV9Yw7X7QxQmNLFYvnTCg8cMZeT/dozJrSyOLmJjREyb6LDYcvOog//e2veBqqHJLz0dsL5GbK189CqY6wMDqFkB7Br7YXtppH35eWhJA+lYAWos67gEImjDF9QIgGokYzHYF5WGV8pPTQ6p/GtOAkwFFY+eqCrPufEZJz/wfuofudfbR3dLDwmxdh1ITHjRWmLZkfnUK1N8gEowF7TN8Fp0r2RE8T1Z4Ay0ITsYfDZ8a0VY0ZYWKwilWRycikUtLHGPKwMNrKvGA7DPhKjnHmkMZS/1RavfXQX4e0x/tk0ipTxWxiRohQcgqWqYzDnTMF4dQUYnqI+dp0zEzxbzI8DgYGa2j317I21o6SECVx+wc1Dpt1EL+8+16MiLNV/M5tPyiQm9azt+DVo6xuaqWjLkYD3vE/GiCzNiuaWypuCb/X9r5M/F3a3Y+/yK7OOAZgG2DnFxeUnCO5/stzb7BkYiv3P/cWOqBpUdrO2MI7P7muQHLEYaez4rufoXvvbvRINe0nbUHzRZE5J4BVMSEnTL7/p0d4YVcXag7I4VRrzSsthQUq8OVf38/stgayGRNV8aD5nSXRtjO2YPhjYMJPnnmbS77+33zm4nNRfUFU1VPo0CL/37+9/Ba/eOZF/vzKGw4LFiBHpZ0QNryzP87tTzzN9557FMUSBTnzsNxamJBKD/H5e37DO9Es6ZQHMlpBZpndP4CtBhBeg08/8RdWtjawL6khk1WEPWl01UJKwVDWQ9rU+K9XHsSWCi/3xYEqQp4MXt2p3p7M6SSyBtv73mRx7Bl++/brgB9Nt9AMC4HENFVyGY1BBrnlpSe5/uGnUE2nLtewRFYmUsjBLLloFd/++yNs29GLkhPInCQ75AROqx4fIl94+Qu/u58lE1tIZXMOUylafnH+8/0HH0XxKrzR0zNSrXm4KfP+92/dyp0vP89vt72C05kk2AKtJkr9Rz5A13duIL1vPyvWriF48TF0/c/PMbt70eqqqP/Eheg1YVBtciLHt557iO3J/QjVRlHyMvG8CdVGEYLPPv0n1jRNJOkS1PyDV/9OQFd48e032fbt3xUd2/qt39FxzVn83XyTX+14knt3PQfoqIojtRXkpba2QjI7yE+2/osfvPAktqVi2xJF5NtbgrQFGWHzzRceZM/raaSSb6Ix7SQEfP4v93NEoINBM4cVECg5EPky0bYmkArccu9jxGyVrn0WVAcRGRORc1iqbajoRpAXX97H73/7DH/+4/MQC0DOQmTybFdTkR6d7niKX/3sMX7820d45rWfkMsOsXDO+Xg9EaQisA2VRLafQw49GMMbYtLic1D8HhTTqSQuBdi6QKiC79xwH2sXTWYwm8MOaoic7eBGYGkCVMEdv3yMiN/DG2/vQwmHmT/rHKxsCo8ngqUqSE3h6Wd38PzzM5g27Rw01UBRPE6uG0dLjdQU9scT/PyXj/GTR19Eak5syHAgvBTOX07afP9nf2dnVRqs/H0vRvrjcP/+4p8f4PB1bTRceTw7PnVz4fdoufpYrHAVuazghtf/xZSoyutDu4AAHsXEUCwkkLNVMrZGT/ZNHu5+kH/13Af40ISFLiyEAFMqZG0NwSAP7buXh7vvy7+WqMLOy7wFpnQ2bn6z6w7eSRqYNtj5qB1vfYjFn9vAQ5f8toDxiC9dxr+iA1g526kULpzzWLbAloLb3voXMap5tqsTMFA0G6E6DSUtBdtUeCyxi5++/Bx3PPc8oIMunTpvQoKpQEZhP2lueOpJfvb0iygZD3LQRvotUCTCFJDUkLbCVx94mLQwyfUaWHEVNZRDaDZYAmtIh5zK5x54gOPmzmBvj8TurcYfzKB7TKQtSCUNsimdG3c/S1MgymM79wE1BIJpvF6n76bTBokhD7vo4qcvP89tTz0HBFG8FlogB0JiZ1XMQYMMOa5/8gnuefhlPCkVu19iBmykAoolUIcEqi34+h//jqfXZuLa03nt3pH0Da2HnEY4HUUdgm/d+SDHL5rFYHcSn5SYXud+dFKY2Cg5+MXvn+HEQxbQ0hAtO+a81/a+iupdqqiO/saP2N7dV3bXWFUEzdEIu3v7ixQN2cE+tv3yOnL9I6HnRqSa9pO3YIRKB/8qisCqsD8tAVUThWtZmRR2NoMeihZ8hICqsJ/OPXsQhgfVO34fXlUETXURdg72l1ViCCAa89FtJ0qislMpOn94M9bQEA2fuQCtegSD2ROn86s3o4YD1H/0PBS/h3DYrFCuQlBtBNifGSrf3kKhVtSyIz5Udv9ZANUySH93pug8VirF3ltuwhoaovmSS/GEq1DycYvDW31qIEjraRcX2kwCmq64q7GEIFbvY1+ydDs5uAVNjSF2pvvKVm/v+sYNmN29hfe0uioaP1vcruCkc0GpEEGKxKOr5FyUXQqCmlSaJz96HdnOPoyGGC0fPIZd37un8HryV89hYnsrnem4636/jxCdg+4KEiWrwK4KqextSf3bKrmcC24hmJDS6O0cLBuHoqgKDXVh9u2NuyqkAtUBOof289wTN5BO9eL1VTFv8cV4fVHSqTjPP3mj836gitmrL8Xji5Y+kZT4hErWDbciqPd62b/PBbciaGiM0rVvwBW3p85Pj+GukrMN6O+oNKOWqPWdvP2Zm8l19RXe1etjtHzpPPSaCIoQrGnJMGh1l91aUVCYHPSRsfa4KqR0EWCogpIwZyvsTUeL3kt2DfLIFfeQ3DMSDO1piNF+zVkY+bIx4zAJQSjTwO7BIdf0DS1qlD29Q65xOEHNIFmhuCtI7Hwstp1KYWcyaNHoGA+JmhsiqysoZeKjVCFoDAXZkxh03Rpv8UTY2+eOO2Tr5HoqKLssibq9j9f/eD3ZwVHPq1A10464FCPopG+I5HRSLoViVUVwxjFLuOQ093CFSva+iuo/aLv7ypeHByewqmcoOY4kGKEYrYeNUTYdeWZZcjN8rgOx0X6qx1dEbsCJnelLptHC0ZLkZvgc+5PjcY82CfSlU2XrY9mZfKLB/T10fvVmzJ44MEJuzH29WAMJ7HQmP5OrIKMVgr5s0r29pc3+VNL1YSuBeDI9LnZKZjJYQ0NOFt0fXk+mxyETo+OYrMQQdrZ4AHaV9udx96ZTFXBLetKJsoORVhWl+qJTit6r3XLiOHIDVKxBNGxu5AbA6h0oIjcd15xFYEYrHdechdEQI9vZx1ufup3OXXsq1vXqy6TRKhSmtXOVl6+FhSu5AYcEDPQm3dUhlk28b8iVJAAMDKXwB2J5UlNFOtXL80/eSH/fjhFy46ti9ioXcpM3N3IDDhHuj1fAbUv64omKuAdTmYpFfq0DWL/PDfYVyI1eH6P1mgsK2cp3fe42cvv7EQgSVn9ZcgNO5uCk2V+xmGTKTroG2IKz4jPaRpMbf1OY1dcfh78pTKazj22fvoNsd+k4JYGgJ5V0vV8sKelJpireU0OZrKuIAEZWx+xUis4bb2LvtSMZ5ofNjsfZ8a3v0/WDm0uW0Rm2nrQ7JltKehLuYw5AMp2rWAjY7BshN0aommlHXY4RqiY72OO8P9SHIoQruQFnkXHvvkr50N5be5/gvEsL+9zVKooQ+A19XCfKDvax88/FyqYdf/gJ2cHiDv/vMGnLimosRQj8+njcY82raeUfytEojVdcilZThbmvl86v3kz6jR0FcqPVVdHwqQvRqiIHpLSVSLyquxxVQeDXDgC3ro4bILRolOZLLkUbLhVwy/Ukd24bF8dUKh+EK24pKxY1VISDu9wgafbG6bnp50XvdV/3qwJp/P/HKtEJ4fVgRIMFcjM8EzZqIwWSo0X8BMMh14KFAF51fHuPs4q5e5xt2YprDlLi8VVK3yDw+oxCYctyZugatm3j9UWLSM5zT1xfIDdzl16Mxx+tiP0AClfj8VZOO+H1HgBuVcGuQDor5W/K9cfZfdP1BXLT8qXz8E1vc1ZuxpAcXVQofolAVzwVyYuGVpEEqaOSgaX2DRWRm1U/OIbqOY2s+v4xBRK+7dN3kNtfWlbv03TX/iQAn65VHE90Rancv4dje4YnUj097L3u+gLJMfv62HPt9Zj7e7EHhxwFU0lMouJ4IsAZv90RVczdkxuIs+3no8jNEZcSrO9wVm5GkZz0UJ+rggqcvhsOVio2+t7a+wTnXdrmg2a6MndbSo5YOL2oE43entIj1Uw69Upi9Y1k+3vY9ovrSpIcRQiWTm4l4nfvIDG/lyUT3Yvs2VJy1LzpFXEfNWuau7RXCI6eNt11xmlUxTj8y1/CqK92SM6XbygmN/kViIjhY1lNR4Xqv5KjWua4fzckx0ycWRn3jBml8/dEYzRfcmmhHtI7t/+gmNyMUfhEvB5WTmxzbUtLSo6ePr3ib3L0xBkVt6eiTQ00feFitDqHNO798i1FJEdBsLC6hVqvuxw1qHtZXT/JfdbpN/jgzd9m0lfPGbfMb9RGmPjVs2n/wukcNXlJRTnq5gmzXPEoCOY11lMfdMcd8BqsmN9RWY56yKzy6igcErThkNmuKyGqqrBx/YiCyuuLMn1O8SrajLmnMG/2NOpqxuchGW1er8GKxZPccVs2mw6e7arYkhI2bZpVAbfg4OXu/U0ImFlfS1OkPG7F40EPhgg31THhy+ej1zh9QK+JFEiOGgkgvTora5a6pniQSOZHV2PjtiWqsCC2vEJVcsEEXxP1Hqc2lubX8cR8BXLjr3e+T7SpinNu+hJGQww14kfxjU/3YEmbYyfNLHstBzccPX16RZn4EdOnuq6YCWBKdTUTIlH0aJTGLZeiVVcXSE562zaH7PT0EG5soOlDW9Bi0ZLnMqXNsZNnVCT6R0+fhlkB96GzpqK7kGXV8BCIRglEa5k+vB0FGMFYgeTo3iAeX4B1y6ZWvC8PWTW9Aur31v6tBOeaa65hxYoV+P1+omP2GoftnXfeYfPmzQQCAWpqarjyyivJZt2z/mYyGa644gpqamoIBAIcffTR7Nq169/wDSrbGasX4PeWzpUigBnNdVx22HKmNtUggNxgvIjcdJy0hYZJ03nggQeI1TWSy5OcXIkcNVcctoIrD1vhiufKw1ZyxaHuPsctmsWWDUsJuOCe3ljLlRtXMKO+tuyNFPAYXL5qOSfPmuN6vc8efQyf+u9vF71X84GTirZXPjxvDVfO2OA6yz2mdR6XTl9LuIzyRwBTQ3VcNWcNc6oayuL2awZXLFjOqfPmljyuRWPUn1a8fdh4zOklEyNesXE5V21YWR40cPTcGVyxYjkRb3ncU6qr+eCilcyraSzCPZrc6HXV/PX++7nwiOOc2JsikuMs/UokH563lo/OXe+K6epZa7lq1jrc1kOOapnN1YuOpK6poeRxoybMlPpWtkzbyJxoa9nzeBWdD0xdx1lTyqc4cHCv5yPr3NvyytXLufiEFa4kYNPSqZxzzmoiUX/pryegpa2Kcy5cx8w5LWV9DI/GGeeu4oRjHNzpVJzXXixeRXv1hZ9z9OFTuOTM8vJfgPNPWc55Z6x0JV1rV0zh7LNXEasKlMXU3BLjnHNXM2duGdyAbmicfcZKTj1sYXlAEi47aTUf3bC6rIvq9XHNTbdwz9/+jKd2jHS/JkLLl8+j5TNncejkeZw64QgiZUpHANR5ajm66XgmBmZRDrgqdA5uOJH1dUeUhiydfrK5+TTOaj/WwRHwsOI7R7H6f44tkBuAE1sO46NrTmLa18+l4wunj0t2J4C1ddO4at5q6v3BsjLxtmCEDy1ayYrWtrJ3iq6qXLFsORctKdO/pUOUPrZ2NR9fvdqJ24vGiknOD/4Hs6eH6uYmfveXP+OtqaLUQpYA1rV2cPVBK2gMlE7hIYDmYJirF69kdduE8hJwReXKFcu5cM3isrgVr48f/fxX3Pazu9GDxX3ACMaYduQWphx2ERceu4YLTlpedmVRAEvnTWD2VPcM3O+1/VsJTjab5aSTTuLSSy8tedyyLI488kgSiQSPPPIId911F3fffTcf/vCHXc979dVX85vf/Ia77rqLRx55hKGhIY466igsy32P+99hHk3FizrSGYcldjhSvKCmoykKYc0AGxTDg+YLFsiNEYzhRWViezuXXfPf6JFqNH8QRfcUnVNH4PfoFVdwwn4PAa+Boo906yLln4BI0IOuaRherTDWjIKNFOAL6OiKSsBnlPpqABiGiqGqRD3e0jJTnFnZ4L79/PBjnyvCuf+GX5LbH3eKMuYUwpofr/CSTXoYXgwYrTTMZRR8VghD6MhEENscL0c1swpaOoQuVCJpP2RLfDkTfIMePEKnGh9KZjxus7ePrjuLtw/33nOnkzNolK+ShYjmwW/oTiXpsQ0lARuiHg+GquLRRvL3FLU3EDAMdFUl5NVHNZ90yl2Eg2i1VUz93JVMbG8n6vWiVUdo/Oz5aHUx1HAAxecBJJoKQd0grHtdZ3gRw4NPNVAKkqXxMtKw7sVQNIQ1/jcBp0imZvvRhIpuBzGt8ZJV2xaYphdD6ITVALY1XvoqJWBpBFQPYb8XqQ7XTy/+n61KQj4PHr+OFVMKqr7RzW16wFvnRTU0rPYAll4sAQcwPQp0BFE1gTIlQs6vjvOxNUGm3Y/hNzBaggxoA0UxN/OXXFrYrrr00jMYyPaSjjlFNsfeCpmwwFPnwxMwyNbpBaXlaJ+cT6C3BNAMFbvZ7xTHHIPJMhRoDaBpCnpzENMz3sdWwazzYPh0AjEf5pjsBeDc32ZAwRc0CHk9RXxj7FjRUFtDR2s7wtLHVbbWqiLg9RFUAqhCI5mLkCvRB7KWSioXRREqCauehKmP8zFthZ5sDAUvUtYwmPOM7ycI4tkAighhiCBDWQ82TgZzb22w4JvI6WiE8SgGSrgOxecd179zpoKXILpQ8Oc849NcANICv+lBU1WqTS8iy7jGFBb4kip+RaPG9qENjfdBgmcAwsIgKj14e51OosVi1J52GqPt8k9dw6TmdoL7NMRYTBKUIagb8mEoGrH9XkRmjA+gpCG234uhqNQlvaiJErhNCPeo+IVGte1BG5KUujE9/dAcqWZS8wSM5JibVkoMfwTD8hJTPfh0Ha8txvkgJViSqOFxnZj8O+w/oqL60Y9+xNVXX008Hi96/09/+hNHHXUUO3fupKnJYXZ33XUX5557Lvv27SsZId3f309tbS133HEHp5ziLBfv2bOH1tZW/vjHP3LooYdWxPNeqqh++OfHuOHPjzlLmIKRwcIe+eeWw5dz/R8eBfKDcM5RNhnBKEhnqfDsDQdx+8NPkx7oQxmtbMr/OpoiWD2zgxf2dtE9UL6oW104yIz2Ov7++jYnQHj0r5vHpwjBuWsP4tZ/Pe0kHht9MwoKtPfKjcv5r388OoJjtA9OMOd5Sxdy00tP57eExnclO95P7/U3MtjVhVZbRfX5p9Bza17iXFtF3Uc+gFYVo84XYEFTPffvegtL2qhaXuIMWLl8tWDgAzOWccMLT2Jjo2iOX8EnP7h+ZM4q/uvvjzmwVYk0nKezMAXkBKpQOH/BAu588DksWyJFXt0gnH3wnT+6nly8h1BtPdOPPZfnf3Ez2fyKW/tpW9BDMYSVV2MF/cyb1sQDr77tLAePvn9HdYlzDlnEjc88VTrRW/4zV69Zxndf/se49rZTaex0BqMmynnTF/LT7U9gSqdit7m/H8XnQcnPUDVFsLy2nR3JPnYn4iUTbwkBVR4/S2om8Nfdr41sLw1jl84LAVwyYwU3vv4vJDZCSBTFOaFtK8h81OSVs9by/Vcezp/bkeQiHB/LFihC4cyJi/nRy8/nA7IlIn8emWcEilBYVtfK3ndS7Ozvd8bI0bsw+UruMa+XDaF2/vb8G1iWjZJ18hFJ4aiCpOpgunTVEm6/93GkLVEzNmraOZnpU7E9Tj+5+PgV3Pjrfzmnz9poCYd9WV4Vy6egqAonbprPT/72d1757Q/IDvTgCVYxY/2l6JEYSTvOm7+/nuxAD/5YLROOvRTdH0FLSxQzTzZ8AhRB2O9hzZR2/vq0g1vNSNRcnmx4BTJPaC4+eAk/usfBrWQd7AiwPAq2MYL7pl/9M9+nHR8hwdIFtiFQVYXjDp7Hz595mZxpge3gERKkArbmlKCY19HI3lCarT29jLt98x035PGwYVkL977zCpZ0qtMXJkX2yID3iYMO4mc7/4okX9E7n6wra6mY0mF0F008mHv2/tbpp8LCp2YRQNZWSds6Ciqb6ldzf9e/yEkTBRuvmkMRElMqpC0dgcLkYDu7EhrbEp1IJB7VylewF2QsDYnAr3qY71/Cb3e86IwnyvB4IrCskb57ecdavv/44873UeRIHJglELbj88GFK7jur48VfIaVUMJyiIImFE5aOJs//OtV0jkTKcDyOr+tsPLVtIVgZksdWdPizb37sZGkc32885PriwrLeqI1XPy17/HQjv2Yto3lA9uQjtw6KVDyE7tLNy3j+vsdTJZHYnsd3EpKoOYndls2LOOGPzs+tioxfc7PpeSc6t6aonDc4ln89aFXSWdH4VbyuNMO7mltdeiDFm9u2+dkr9AdHySojvIcr0fn0OXT+NN9L2Ha0kn1kPdR8qp6gJv/+2ymTKzn3dj/dcU2yxGcz33uc9xzzz08//zzhff6+vqoqqrigQceYP368cvsDzzwABs3bqS3t5dYbGTJbN68eRx77LF88YtfHPeZTCZDJjMSsDUwMEBra+t7QnAO/cLNdPYNlj2uKoK6UIDu/oSrIikc8DCYyboXPVNG8uyU9QEwSlGNEVOEIBA06C8TxAZOx66JBdiXKK/sAQgGDQYojduMx9n7g+swe3ryZOYStKpoodr4CMm5BK0qgmK4hxcqQhASPuKZ8kX9VCFokhH2xd1xR6WHdH+uKA4nNxBnx0+uLcTctJ++BY835sRM/WJkW3HiyZcVlGkSwF+hyJ4QeBo99GXcK+3W1XvpMgddcYe9GinSuClWROH/ypuTNsUdtyoEUY+XPpfqzooQ1PtC7EuXl+UDeKWHwVSF8NGcQO2rUNPIhlCn4l5iQRHUZT3095dXkSiKoCYaoCeexHJRwXkCOgPpQd78442Y6SGmbN5SiEMAyA718ebvrkPzB+k4+mJUT5nSBxIMS7iOAaoiqFa99MXd27sm6qe3z3080UI6Cc09qYSlQ7rCs0YiUTqyFWOsZjRkGbT6y7c3gglBL2mrF8tFJq4JnaztLlvO2Qr70wF33BL2x2OuCkdVKMQSUbqHyiszFSFokkF6e90VpV6pYiUq7CCM+vjYOMzWw05n55/vJNffgxGtZsKpW9DD47fEwVHBVgV97B9KlBVnCAH1vgC9A+64PZaCHKqg7rMknsEKNEFKPFLBNN1j2o4/agGXX7jB/VwV7P8ZmXhnZyf19cV3WCwWwzAMOjs7y37GMIwicgNQX19f9jNf+9rXiEQihb/W1vLxAv9b6x0sPxiBE1g1mMpWlHgnMtmKWR4PlIpWclMUwVDWXdJnSclgJuv6sAVI5LJlgxkVjwc1GESrGSE34Eie6z5yCVptFUooiOL1HBBuVQiGXKqbD+MeSGcq4k6mx8s6FcODFgg6JS3O3IKWl+wboRgdJ28Z2T40RilGRGVZtiIEQzn33B62lAzkKuNOmJnKclTXo8XXdDOBIGEeCO50RZl4ImdWVFpVKv4IzkywUm0ogSCZyrq2g21LhpIZV3IDkMzkMPwBJh9xMVM2X1ZEbsCJQ5h89GXu5CZvldM8CBIlaiYV4ZaSRLLyeJLO5VAqyMTlgYz+ChV/W4CU7S5JtpGkrKQruQHI2bmKSqsDKcyLFBXTNwAMZjLuuKVkMO0+8QQnBUAlFdGwlYrD9Dd1OCELkWqy8R6231U6DhMAKRlKZ1yfB1LCUDpb8ZmRM62KCrFKajtwnilu5MbBJOntc39evtf2vyY4X/jCFxBCuP499dRTB3y+UntyUsr/9V6d22c++clP0t/fX/jbuXPn/+rcblYTdp9JqPnl6UqdP+T1VBy4D/THqtR0ti0JedyLSKpCEPF6Kj5Mg4an7GCr+Hw0XHIRjVdeViA3wzZMcuquuqBQdbxSRWpLSsKGuxxVFYKIrzLugM8YN3CrXh+tp1zMhDMvQw/HitrRCMWYePJltB8/5kGWXwlxMzuP281LFYKo4avc3rq34gPnQO+cSteykYQqxPKoQhDRvRXJS8gY395jrRL/AeehXOlesqUkGKiQvkERhAPeiucKeHVnS8njc7aUS5gRjFYkN0DFivIgCfnd+4miCEIBT8UcN37DqEjeKuaCBLCpmL8IJAHV744bgV/1o1Q4l0cxXBMBAk4W7EomJEaFNgJJ2FuhvYUg7PVUvMc9hnrAecoUw8kwX4jDHDWRaj9pC0a0xERqtAkI+byu47wiBCGfp+KzwDAqp284ECJs2xJDd99eEAJqq91Vku+1/a8JzuWXX86rr77q+jd79uwDOldDQ8O4VZe+vj5yudy4lZ3Rn8lms/SNSZC0b9++sp/xeDyEw+Giv/fKTljuLlu2bMnJq+e5dn4hBCeuLK3oGTZVEWycM5mGaOmIf8hHz8dCbJwx2XXgFgJOXTTXlURaUnL6QfNcVxQUITh97lzcnhG6388R8w+iJRgeh1uriqL4fQigMRDmsLapFR+6Z06f7zogWVJyxrzKuE9ZNLfkQ1n1+tDDUVQhWDujg9bqkeKXemj8g6wu/P9r78yjmrzyPv59npCEECDshLCLGkQWMYiAsitI3W1dp4hvq61W3Oq0tdoZbDu+Vbs479TpOJ3joe20M7YdxLGtpwoKqFVbiqn7zia7LAKCEAj3/SMliHkSlgKF9H7OyTlwn9998r33d3Pzy33uIka8r+ET5QHgd/4BBq+rCcHv5BN61L3Ua6LBYILHMIiQesHD3MZgPdmLxJjpOt7wCeeEYOkow4e7qgnBslFBBoMXlmGwdMwE8PUcktqpO9zNHV42hnXbikVICJQbbN+EECyICTB4n44OgidjDX8uWZbBgnB/8E3062YZBpPHusJLamvwy8TKXISESd4GdXd0ECyI9e9x5OnJaRMMBi8sy2DBFD8IDXzhsAyDYA8XyO3tDNaTtakI8z18e9wGYa5zaI8jOPHSSIN787BgEeM4BQJW/2NKFgz8rbwwxlxmcFm6BV+E+R7+Pep+2m9CjyM4yyb5G360yDBYMMkXIoEB3QyDwFEy+Lg4gG9qBo/5z2HUwrU6G7va2Dti7e734bnoeb1Bs7qDYGmIv8HRmQ5CsHiK4fbNYxnMneIHkdCwbt+xMviMcTL4PWdmJsQT0/162AaBID7W8HYRA02fAxw7Ozt4e3sbfJnqWQ77OKGhobh8+TLKy8u1aceOHYNQKIRCwd2xKhQK8Pl8ZGRkaNPKy8tx+fJlhIUZXh49GCya6g9nW0tOxzIMg8jxo7A8WoHw8Z6cHSCPZeBmL0FSbBCej5/M+R4sy0DIN8G6mVOwbZ7m+eXjt+qcd/Hq3GhsmB4GoYn+zalWR03Gs1OC4GYt0aMbiBrriWcmKxAzZhRnIMRjGLhaSbBqchDWT+Y+SZllGAhNTLA5bCreCJumXzeA7aEx2BwYAVOe/s3ukv1C8ZxfMDwlNpw2LBhEuXhiVeAkTB/NfVI4j2HgbGmJ50ImYW2sft0CEx42xU/FlvnRAMOtmwHw6vxorIsNg0igX/fKiElYOSkIXjZ6dDMMwt3d8VzAJCS4jdWrW2ZmidXjJ2OTbxS3bjDgszy85B+DPwTGgzHwFfDHCfFYPz4CZiYCvbpXeYfhWXkoRlva663vMAdPPDM2BE+4+OjRzUIqssRz8jD8fgL3UmqWYWDC8vDKxGj8MTpaMxKsR/cfoqPxwoxQiIUCvZ3p8mgFnp4RBC9XO87HvizDQDHOFcsSFJgeItf7ubS3MsfymZOQPI97a3mWYWDCY7HxyQi88mSUpr71CH95QSSenxUCsal+3b+bNhFPJwRhjJu9Xt2BchcseyIIM6aM06vbzkqM5bODsWEu9xLwTt0vzo/Aa9OiwBqo723TIrHONxyWfFO97WTFmCAs9YjEaHNnzlFYFgz8JJ5Y4BKDSHvuU+5ZsJDwLTDfOQFPuy/gtGHAgGV4SHRfgA3yOT/r5ta0fuxsJI8Ph8TAqGjiaAVWBUyCr72D3s/lRKkMz04KwpOB47nbN8vARmyG5yODsXm2/vrmsQw2z47AK/M09c031d1hHgBemhOJlxfOgo21td52sjjEHysiFPB1ceTs41mGQYCbE5IiFFgwmXuwgccysBKLsGp6MDYtjtSrm2UZbFwUieQVUWBZ/e177fJIJC4KhaWlSO9Ui9nx/hjlbs99g0FiUCcZFxcXo7a2FocPH8bbb7+NU6c0K0RGjx4Nc3NzqNVqTJgwAY6Ojnj77bdRW1uLFStWYN68eXj/fc2hXqWlpYiNjcUnn3yC4OBgAMCaNWvw9ddf46OPPoKNjQ1+//vfo6amBnl5eeDxepiFi4FdRQUANQ1NePOL48i+fEcbVQtMeFg4xR+b5oSDb8KDqq0d7x06hbQzlzQrG/BzIOHnhT8smQYbCzMQQvBZjhJ/P3YODc1dcx/83KVIWTwdY2R2AIDsq3fw1n+zUVrbtTuns40lXp0bjSifUQCAGxX3kJKeiYslXSNkliIhXogOQWJYIBiGQc2DZvzx60ycuH5H+ytGwONhkcIPL8eFQ2BiAlV7O3afOIUDyktQ/bwMnwEQM9YLb86IhZ25GIQQfHxBib98fw73W7omAPs7OuKt2DiMs9c06uPFd7D97HEUN9ZrbVwtJEgJicF099EAgOt1VXj17LdQVpd16RYIsd5/Cp4dN0mj+2Eztp45hqOFN7t0szwslftja3A0TE1MoFKr8fbJU/j0pwvddXt5YUfcNNiLNbo/O/cTPjhxDvebu3SPd3bA6/Omw0fmAAA4ea0AO9OzcLemS7fM2hIvz41ErJ9G963KaqQcysRPd7uCdUtTIZ6LCsb/TFGAYRjUPnyI1zIzcezObe2wMJ9lsdjXD9siIyH8WfduZQ7+eUOJVnW7Vne0ixd2hsyAg5m5RvedPPzf5RzUqbomLo+3lmJH0Ez4WjtpdFfcwRvKb1H0oGu0U2Zmia0BcYh30Wy4dbuhGttyv0ZeTdc+UhZ8IdaMm4JV8lAwDIO61mZsVx7B0ZLr2l1m+SwPT3lMwKsB02HK46OtQ433Lmfhs/xctDyiO1I6Gm9OnAVHkWaPkn/eOI89F06h9pEJ1+NtHPFWyAz422p0nyosxPbjJ1D4yKIEJwsLbIuKRMLYsQCAgspabP88A8qCrnZibirAymnB+J+YIM2xBw8eYvfHx3Hih1va+jbhsZgdMR4bl0XBVMhHe7sa+9K+wxcZP6FV1TW5NdTfA1ufmQ4HG43utFMX8cF/z6DuQZduuas9ti2bBl9PzT5B524U4X+/OIGie126Ha3MsXleBOInygEAhRW1ePPTTChvl3bTnRQ/Cc/M0LTvhqYW7P7oOI7/cFP72NqEx2LmVB+8mBit0a3uwIdffocvjp5HyyO6Q/w9sHVlHBxsNboPnrmEvV99h9rGLt1jne3w2pJp8PfU1PfZwmKkHDuBgtqudiK1MMcr0RGY5aPRXdBYi1d/+Aa597oe75ubCPDcuFCs8Qn7eZ7ZQ/z5Rhqyqn7SthMewyJOGoR1Y+dBxBNCTdT48u5XOFJ+Aq0dXfON/CXj8LxXIuyENgCAE5Vn8K/iQ6hv61rA4WbmjOe8lkFuoenjztfexrvXD6GouUprYy+0xJoxMxEnDdTUd2MttuZ+g+/vFWttxCYCrPIOwVqfqWAZBg2trUjJOY6vbl7XjqCasCzmy8chJSIG4p8f9+3NOoePzp7Hw7au+Ytho9zw5tzpcLbSfI+k/3AFfzlyGtWPzM0cLbVFylPTMMFTs1I493YJ/pR2HPmVXefK2VuKsWlWOGYHjQMA3K25jz+mZeKHO131bSbgY0WEAmtiQzTzKFta8af/ZuHIhevakRoTlsXMCd7YNjcaYqFG976j5/DPnPNofmTe5eQxrti+eDqcbSQAgK+/u4K9aadRXd+1QneUzBZbl0/DhDHOAIALV0vwzocZKLjbterL1lqM1U9HICFKMzJTXnEfu98/ivMXu+pbZMrHonlBSFoS1uMO3L1h2KyiWrFiBT7++GOd9KysLERFRQHQBEEvvPACTpw4AZFIhGXLluGdd96BUKh5/lhYWAhPT89ueVpaWvDSSy/hX//6Fx4+fIjY2Fh88MEHvZ48PNABTifltQ24VlIFEx6LwFHOsOA4xqGhuQU/5ZehXd0BHzdHSK11dxJVtbcj704pmlpU8HCwxmgnOx2bjg6CC8XlqG5ogp2lGAFuTpyR863KahRW10EsFCDIwxkCE90jGsrrG3GlrBI8loXCTQZLke4IXENLC/LulqG9owO+To5wsuTQrVbjh9ISPFCp4GllDbmdrm5CCM5XlaGy+QEczMwx0UHG+Svk5v17yK+vhZgvQLCjK4Q8Dt1Njbh4rwImLIMgRxdIhLq6G1tb8WNJKdo6OuDr6AAZh79V7Wr8WFiCplYV3G2tMVbKrfticQWq6h/AzsIMAe4yzvq+XVWDgnu1MBNo6lvIcSRGxYNGXKz4ub5lTrDiOA+sQdWKH6tKoOpQw9fGES7mEl3dajV+rC5GY1sr3M2t4W2l+4iWEIILtWWoeNgAO1MxJtq6ctb37YZq3GmohpkJH8H27pz1XfGwAZdqy8BjWEy0c4WVQFf3g7ZW5FYXo61DDR8rKVzEVjo2bR1q5FbeRUNbK9zMreBjo0d3RQUqGhthZybGRGfudlJQWYs7lTUQCfhQjHKBqUBX9726B7iaXwGWZeA/WgaJha7upocq/HSzBG1taox1d4CM44DGNrUaylulaHzYChc7CeSuDpy6LxdXorKuETYWIgR4yjjnyxRU1KKgvBamAhNMHMOtu/r+A1y5UwGWYeA3RgYrPbov3CiBqlO3gx7dtzW6ne0k8Hbh1n2pohJl9Y2wMRNB4cKtO7+hBrcaqiHi8RFs7wpTjiMDalsbcLWhGAwAX4kHJALdeRct6hZca7iNto42uItd4Giq+8teTdS41nAbD9qb4Ci0h4fYRWc0mRCC6w0lqGy5DyuBGH5WHpyPcAsaa3Cz/h5MeXwE27txHnVwr6kJyspyMAAmOslgKzLTsWlqVSGvuBSt7WrIHe3g9tjcQgBoV3dAWVCK+80tcLaxxDhnB07dV0sqUV7XCImZCBNHcdd3UXUdblXUQMg3QZCnM+djsOrGJlwsrgAYIMDNCbbmurqbW9uQl69pJ2Oc7OBmz637p1ulqH/wEDI7CbzduXXfyK9E5b0GWFqI4OftzDm3rKSsDvlF9yDgmyDA1wUiPZvK9odhE+AMVwYrwKFQKBQKhTJ4jJhl4hQKhUKhUCiDAQ1wKBQKhUKhGB00wKFQKBQKhWJ00ACHQqFQKBSK0UEDHAqFQqFQKEYHDXAoFAqFQqEYHTTAoVAoFAqFYnTQAIdCoVAoFIrRQQMcCoVCoVAoRofu/uC/ATo3b25oaOjBkkKhUCgUynCh83u7N4cw/CYDnMZGzQFuvT27ikKhUCgUyvChsbEREonu2WuP8ps8i6qjowNlZWWwsLDQOUzsl9LQ0ABXV1fcvXvXKM+5MvbyAcZfRlq+kY+xl5GWb+QzWGUkhKCxsREymQwsxwGlj/KbHMFhWRYuLi6D+h6WlpZG23AB4y8fYPxlpOUb+Rh7GWn5Rj6DUcaeRm46oZOMKRQKhUKhGB00wKFQKBQKhWJ00ABngBEKhUhJSYFQKPy1pQwKxl4+wPjLSMs38jH2MtLyjXyGQxl/k5OMKRQKhUKhGDd0BIdCoVAoFIrRQQMcCoVCoVAoRgcNcCgUCoVCoRgdNMChUCgUCoVidNAAp4/s2LEDYWFhMDMzg5WVFadNcXExZs+eDbFYDDs7O6xfvx4qlcrgfVtbW7Fu3TrY2dlBLBZjzpw5KCkpGYQS9I3s7GwwDMP5ys3N1ZtvxYoVOvYhISFDqLz3eHh46GjdsmWLwTyEEGzfvh0ymQwikQhRUVG4cuXKECnuG4WFhXj22Wfh6ekJkUgELy8vpKSk9Ngmh7MPP/jgA3h6esLU1BQKhQKnTp0yaJ+TkwOFQgFTU1OMGjUK+/btGyKlfeett97CpEmTYGFhAQcHB8ybNw83btwwmEff5/T69etDpLr3bN++XUenVCo1mGck+Q/g7lMYhsHatWs57Ye7/06ePInZs2dDJpOBYRgcOnSo2/X+9odpaWnw8fGBUCiEj48P0tPTB1Q3DXD6iEqlwsKFC7FmzRrO62q1GjNnzkRTUxNOnz6NAwcOIC0tDZs3bzZ4340bNyI9PR0HDhzA6dOn8eDBA8yaNQtqtXowitFrwsLCUF5e3u21cuVKeHh4ICgoyGDeGTNmdMt35MiRIVLdd954441uWl977TWD9rt378Z7772HvXv3Ijc3F1KpFNOnT9eeczacuH79Ojo6OvD3v/8dV65cwZ49e7Bv3z5s3bq1x7zD0Yeff/45Nm7ciG3btkGpVCI8PBwJCQkoLi7mtC8oKMATTzyB8PBwKJVKbN26FevXr0daWtoQK+8dOTk5WLt2Lc6dO4eMjAy0t7cjLi4OTU1NPea9ceNGN3+NGTNmCBT3nfHjx3fTeenSJb22I81/AJCbm9utfBkZGQCAhQsXGsw3XP3X1NSEgIAA7N27l/N6f/rDs2fPYvHixUhMTMSFCxeQmJiIRYsW4fvvvx844YTSL1JTU4lEItFJP3LkCGFZlpSWlmrT/v3vfxOhUEjq6+s573X//n3C5/PJgQMHtGmlpaWEZVny7bffDrj2X4JKpSIODg7kjTfeMGiXlJRE5s6dOzSifiHu7u5kz549vbbv6OggUqmU7Ny5U5vW0tJCJBIJ2bdv3yAoHHh2795NPD09DdoMVx8GBweT1atXd0vz9vYmW7Zs4bR/+eWXibe3d7e0559/noSEhAyaxoGkqqqKACA5OTl6bbKysggAUldXN3TC+klKSgoJCAjotf1I9x8hhGzYsIF4eXmRjo4OzusjyX8ASHp6uvb//vaHixYtIjNmzOiWFh8fT5YsWTJgWukIzgBz9uxZ+Pr6QiaTadPi4+PR2tqKvLw8zjx5eXloa2tDXFycNk0mk8HX1xdnzpwZdM194fDhw6iursaKFSt6tM3OzoaDgwPGjh2LVatWoaqqavAF9pNdu3bB1tYWEyZMwI4dOww+vikoKEBFRUU3fwmFQkRGRg47f+mjvr4eNjY2PdoNNx+qVCrk5eV1q3sAiIuL01v3Z8+e1bGPj4/Hjz/+iLa2tkHTOlDU19cDQK/8FRgYCCcnJ8TGxiIrK2uwpfWbW7duQSaTwdPTE0uWLEF+fr5e25HuP5VKhU8//RTPPPNMj4c7jxT/PUp/+0N9fh3IPpQGOANMRUUFHB0du6VZW1tDIBCgoqJCbx6BQABra+tu6Y6Ojnrz/Frs378f8fHxcHV1NWiXkJCAzz77DCdOnMC7776L3NxcxMTEoLW1dYiU9p4NGzbgwIEDyMrKQnJyMv785z/jhRde0Gvf6ZPH/Twc/cXFnTt38P7772P16tUG7YajD6urq6FWq/tU91yfSUdHR7S3t6O6unrQtA4EhBC8+OKLmDp1Knx9ffXaOTk54cMPP0RaWhoOHjwIuVyO2NhYnDx5cgjV9o7Jkyfjk08+wdGjR/GPf/wDFRUVCAsLQ01NDaf9SPYfABw6dAj37983+KNwJPnvcfrbH+rz60D2ob/J08QfZ/v27Xj99dcN2uTm5vY456QTriidENJj9D4QeXpLf8pcUlKCo0eP4osvvujx/osXL9b+7evri6CgILi7u+Obb77BggUL+i+8l/SlfJs2bdKm+fv7w9raGk899ZR2VEcfj/tmMP3FRX98WFZWhhkzZmDhwoVYuXKlwby/tg8N0de657LnSh9uJCcn4+LFizh9+rRBO7lcDrlcrv0/NDQUd+/exTvvvIOIiIjBltknEhIStH/7+fkhNDQUXl5e+Pjjj/Hiiy9y5hmp/gM0PwoTEhK6jeo/zkjynz760x8Odh9KAxxoOpElS5YYtPHw8OjVvaRSqc4kqbq6OrS1telEq4/mUalUqKur6zaKU1VVhbCwsF69b1/pT5lTU1Nha2uLOXPm9Pn9nJyc4O7ujlu3bvU5b3/4JT7tXCl0+/ZtzgCnc8VHRUUFnJyctOlVVVV6fTwY9LWMZWVliI6ORmhoKD788MM+v99Q+5ALOzs78Hg8nV95hupeKpVy2puYmBgMYH9t1q1bh8OHD+PkyZNwcXHpc/6QkBB8+umng6BsYBGLxfDz89Pbrkaq/wCgqKgImZmZOHjwYJ/zjhT/9bc/1OfXgexDaYADTadpZ2c3IPcKDQ3Fjh07UF5ernX2sWPHIBQKoVAoOPMoFArw+XxkZGRg0aJFAIDy8nJcvnwZu3fvHhBdj9PXMhNCkJqaiuXLl4PP5/f5/WpqanD37t1uH4DB5Jf4VKlUAoBerZ6enpBKpcjIyEBgYCAAzXP2nJwc7Nq1q3+C+0FfylhaWoro6GgoFAqkpqaCZfv+dHqofciFQCCAQqFARkYG5s+fr03PyMjA3LlzOfOEhobiq6++6pZ27NgxBAUF9astDzaEEKxbtw7p6enIzs6Gp6dnv+6jVCp/VV/1ltbWVly7dg3h4eGc10ea/x4lNTUVDg4OmDlzZp/zjhT/9bc/DA0NRUZGRrcR9GPHjg3sj/oBm678G6GoqIgolUry+uuvE3Nzc6JUKolSqSSNjY2EEELa29uJr68viY2NJefPnyeZmZnExcWFJCcna+9RUlJC5HI5+f7777Vpq1evJi4uLiQzM5OcP3+exMTEkICAANLe3j7kZeQiMzOTACBXr17lvC6Xy8nBgwcJIYQ0NjaSzZs3kzNnzpCCggKSlZVFQkNDibOzM2loaBhK2T1y5swZ8t577xGlUkny8/PJ559/TmQyGZkzZ043u0fLRwghO3fuJBKJhBw8eJBcunSJLF26lDg5OQ278hGiWZE3evRoEhMTQ0pKSkh5ebn29SgjxYcHDhwgfD6f7N+/n1y9epVs3LiRiMViUlhYSAghZMuWLSQxMVFrn5+fT8zMzMimTZvI1atXyf79+wmfzyf/+c9/fq0iGGTNmjVEIpGQ7Ozsbr5qbm7W2jxexj179pD09HRy8+ZNcvnyZbJlyxYCgKSlpf0aRTDI5s2bSXZ2NsnPzyfnzp0js2bNIhYWFkbjv07UajVxc3Mjr7zyis61kea/xsZG7XcdAG2fWVRURAjpXX+YmJjYbaXjd999R3g8Htm5cye5du0a2blzJzExMSHnzp0bMN00wOkjSUlJBIDOKysrS2tTVFREZs6cSUQiEbGxsSHJycmkpaVFe72goEAnz8OHD0lycjKxsbEhIpGIzJo1ixQXFw9hyQyzdOlSEhYWpvc6AJKamkoIIaS5uZnExcURe3t7wufziZubG0lKShpW5ekkLy+PTJ48mUgkEmJqakrkcjlJSUkhTU1N3eweLR8hmqWRKSkpRCqVEqFQSCIiIsilS5eGWH3vSE1N5Wyzj/++GUk+/Otf/0rc3d2JQCAgEydO7LaEOikpiURGRnazz87OJoGBgUQgEBAPDw/yt7/9bYgV9x59vnq0/T1exl27dhEvLy9iampKrK2tydSpU8k333wz9OJ7weLFi4mTkxPh8/lEJpORBQsWkCtXrmivj3T/dXL06FECgNy4cUPn2kjzX+cy9sdfSUlJhJDe9YeRkZFa+06+/PJLIpfLCZ/PJ97e3gMe0DGE/Dxbi0KhUCgUCsVIoMvEKRQKhUKhGB00wKFQKBQKhWJ00ACHQqFQKBSK0UEDHAqFQqFQKEYHDXAoFAqFQqEYHTTAoVAoFAqFYnTQAIdCoVAoFIrRQQMcCoVCoVAoRgcNcCgUCoVCoRgdNMChUCgUCoVidNAAh0KhUCgUitFBAxwKhUKhUChGx/8Dia22QCOtdngAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xx1, xx2 = np.meshgrid(np.linspace(-10, 10, 50), np.linspace(-10, 10, 50))\n", - "X_pred = np.concatenate((xx1.flatten()[:, None], xx2.flatten()[:, None]), axis=1)\n", - "\n", - "\n", - "mu, var = f_predict(X_pred, result)\n", - "mu = mu.squeeze()\n", - "sd = np.sqrt(var).squeeze()\n", - "\n", - "z = results[\"z\"]\n", - "\n", - "plt.scatter(X_pred[:, 0], X_pred[:, 1], c=mu)\n", - "plt.scatter(z[:, 0], z[:, 1], marker=\"x\", color=\"k\");" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2756dca6-4378-4bb9-a501-5cf284ba81bf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(z[:, 0], z[:, 1], c=results[\"variational_mean\"])\n", - "plt.contour(X_pred[:, 0].reshape(50, 50), X_pred[:, 1].reshape(50, 50), mu.reshape(50, 50));" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "37278efb-c895-4519-92f4-d74ace7de68a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ssvi", - "language": "python", - "name": "ssvi" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/introduction/introduction.ipynb b/notebooks/introduction/introduction.ipynb new file mode 100644 index 0000000..dfc215c --- /dev/null +++ b/notebooks/introduction/introduction.ipynb @@ -0,0 +1,476 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dc79244", + "metadata": {}, + "source": [ + "(introduction)=\n", + "# Introduction to PTGP\n", + "\n", + "PTGP builds Gaussian process models on [PyTensor](https://pytensor.readthedocs.io) and [PyMC](https://www.pymc.io): you define a kernel, put PyMC priors on its hyperparameters, and PTGP compiles the linear algebra into a function you fit and predict with in two calls.\n", + "\n", + "This guide fits an exact GP to a small regression dataset, shows what {func}`pg.fit ` and {func}`pg.predict ` do underneath, and swaps in a sparse VFE approximation. SVGP and minibatch training at scale are covered in the {ref}`companion notebook `. See the {doc}`kernel gallery ` for covariance functions and the {doc}`user guide ` for the full API.\n", + "\n", + "It assumes you know Gaussian processes and are comfortable with PyMC." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e0a505c5", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pymc as pm\n", + "import pytensor.tensor as pt\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "import ptgp as pg\n", + "\n", + "\n", + "plt.rcParams.update(\n", + " {\n", + " \"figure.figsize\": (14, 5),\n", + " \"figure.dpi\": 144,\n", + " \"figure.constrained_layout.use\": True,\n", + " \"axes.grid\": True,\n", + " \"grid.linewidth\": 0.5,\n", + " \"grid.linestyle\": \"--\",\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "165d8eca", + "metadata": {}, + "source": [ + "## The data\n", + "\n", + "The Silverman motorcycle dataset: 133 accelerometer readings from a crash-test dummy's head during a simulated impact, pairing time since impact (ms) with head acceleration (g). The response is smooth but sharply varying, and the noise grows after impact.\n", + "\n", + "We standardize both axes so the priors below are sensibly scaled, and de-standardize when plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a4156e7b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "url = \"https://raw.githubusercontent.com/vincentarelbundock/Rdatasets/master/csv/MASS/mcycle.csv\"\n", + "csv_path = Path(\"mcycle.csv\")\n", + "if not csv_path.exists():\n", + " pd.read_csv(url).to_csv(csv_path, index=False) # cache locally; don't refetch each run\n", + "mcycle = pd.read_csv(csv_path)\n", + "\n", + "t = mcycle[\"times\"].to_numpy(float) # time since impact (ms)\n", + "a = mcycle[\"accel\"].to_numpy(float) # head acceleration (g)\n", + "\n", + "x_scaler = StandardScaler().fit(t[:, None])\n", + "y_scaler = StandardScaler().fit(a[:, None])\n", + "X = x_scaler.transform(t[:, None])\n", + "y = y_scaler.transform(a[:, None]).ravel()\n", + "N = X.shape[0]\n", + "\n", + "# Dense prediction grid in standardized space, plus its physical-unit times.\n", + "X_grid = np.linspace(X.min() - 0.2, X.max() + 0.2, 200)[:, None]\n", + "t_grid = x_scaler.inverse_transform(X_grid).ravel()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(t, a, s=15, c=\"k\", label=\"observations\")\n", + "ax.set_xlabel(\"time since impact (ms)\")\n", + "ax.set_ylabel(\"head acceleration (g)\")\n", + "ax.set_title(f\"Silverman motorcycle dataset (N = {N})\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d478456d", + "metadata": {}, + "outputs": [], + "source": [ + "def to_g(y_std):\n", + " \"\"\"Map standardized acceleration values back to g (physical units).\"\"\"\n", + " return y_scaler.inverse_transform(np.reshape(y_std, (-1, 1))).ravel()\n", + "\n", + "\n", + "def plot_gp(\n", + " mean,\n", + " f_band,\n", + " y_band=None,\n", + " *,\n", + " ax=None,\n", + " color=\"C0\",\n", + " ls=\"-\",\n", + " label=\"posterior mean\",\n", + " inducing=None,\n", + " title=None,\n", + " band_labels=True,\n", + "):\n", + " \"\"\"Plot a GP posterior over the data: mean, function band, and optional noise band.\"\"\"\n", + " if ax is None:\n", + " _, ax = plt.subplots()\n", + " ax.scatter(t, a, s=15, c=\"k\", zorder=3, label=\"observations\")\n", + " ax.set_xlabel(\"time since impact (ms)\")\n", + " ax.set_ylabel(\"head acceleration (g)\")\n", + " ax.plot(t_grid, mean, color=color, ls=ls, lw=2, label=label)\n", + " if y_band is not None:\n", + " ax.fill_between(\n", + " t_grid,\n", + " *y_band,\n", + " color=color,\n", + " alpha=0.12,\n", + " label=\"observation ±2 sd\" if band_labels else None,\n", + " )\n", + " ax.fill_between(\n", + " t_grid, *f_band, color=color, alpha=0.25, label=\"function ±2 sd\" if band_labels else None\n", + " )\n", + " if inducing is not None:\n", + " ax.scatter(\n", + " inducing,\n", + " np.full(len(inducing), a.min() - 5),\n", + " marker=\"^\",\n", + " c=\"r\",\n", + " s=45,\n", + " zorder=4,\n", + " label=f\"inducing inputs (M = {len(inducing)})\",\n", + " )\n", + " if title:\n", + " ax.set_title(title)\n", + " ax.legend(loc=\"lower right\")\n", + " return ax" + ] + }, + { + "cell_type": "markdown", + "id": "1e576b55", + "metadata": {}, + "source": [ + "## Exact GP\n", + "\n", + "The model is a zero mean, a {class}`Matérn 5/2 ` kernel scaled by an amplitude $\\eta^2$, and Gaussian observation noise $\\sigma$. The hyperparameters are PyMC random variables, so priors go on them the usual way.\n", + "\n", + "{class}`pg.gp.Unapproximated ` is the exact GP. {func}`pg.fit ` optimizes the hyperparameters to their MAP values (marginal likelihood plus PyMC log-prior, L-BFGS-B) and returns a {class}`FitResult ` that {func}`pg.predict ` consumes." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "476a0e15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ls = 0.475\n", + " eta = 0.909\n", + " sigma = 0.471\n" + ] + } + ], + "source": [ + "with pm.Model() as exact_model:\n", + " ls = pm.InverseGamma(\"ls\", alpha=3.0, beta=1.0)\n", + " eta = pm.Exponential(\"eta\", scale=1.0)\n", + " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", + "\n", + " kernel = eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls)\n", + " gp = pg.gp.Unapproximated(kernel=kernel, sigma=sigma)\n", + "\n", + " fit = pg.fit(gp, X, y)\n", + "\n", + "for name, value in fit.params.items():\n", + " print(f\"{name:>6} = {value:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "139b5728", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu, var = pg.predict(gp, X_grid, fit, X_train=X, y_train=y)\n", + "_, var_y = pg.predict(gp, X_grid, fit, X_train=X, y_train=y, incl_lik=True)\n", + "\n", + "sd, sd_y = np.sqrt(var), np.sqrt(var_y)\n", + "mean = to_g(mu)\n", + "f_band = to_g(mu - 2 * sd), to_g(mu + 2 * sd) # latent function f\n", + "y_band = to_g(mu - 2 * sd_y), to_g(mu + 2 * sd_y) # predictive, for a new observation y\n", + "\n", + "plot_gp(mean, f_band, y_band, title=\"Exact GP posterior\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4d09ebf1", + "metadata": {}, + "source": [ + "The inner band is the posterior over the latent function $f$; the outer band adds observation noise and predicts a new $y$. The function band is tight where data is dense and widens past the edges.\n", + "\n", + "The Gaussian likelihood assumes constant noise, but this data is heteroscedastic (quiet before impact, noisy after), so the noise band runs too wide early and too narrow late. Input-dependent noise needs a non-Gaussian likelihood or a kernel like {class}`Gibbs `; see the companion notebook." + ] + }, + { + "cell_type": "markdown", + "id": "e76f8a51", + "metadata": {}, + "source": [ + "## Under the hood\n", + "\n", + "{func}`pg.fit ` and {func}`pg.predict ` wrap a lower-level API. For a custom optimizer, frozen variables, or staged training, call the pieces directly: {func}`~ptgp.optim.compile_scipy_objective` builds the loss and gradient, you run any optimizer, and {func}`~ptgp.optim.get_trained_params` reads the result back. This reproduces the fit above." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "2cb37ac4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'ls': 0.475, 'eta': 0.909, 'sigma': 0.471}\n" + ] + } + ], + "source": [ + "import scipy.optimize\n", + "\n", + "X_var = pt.matrix(\"X\", shape=(None, 1))\n", + "y_var = pt.vector(\"y\", shape=(None,))\n", + "\n", + "with pm.Model() as manual_model:\n", + " ls = pm.InverseGamma(\"ls\", alpha=3.0, beta=1.0)\n", + " eta = pm.Exponential(\"eta\", scale=1.0)\n", + " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", + " gp_manual = pg.gp.Unapproximated(\n", + " kernel=eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls), sigma=sigma\n", + " )\n", + " fun, theta0, unpack, shared_params, _ = pg.optim.compile_scipy_objective(\n", + " pg.objectives.marginal_log_likelihood, gp_manual, X_var, y_var\n", + " )\n", + "\n", + "result = scipy.optimize.minimize(fun, theta0, args=(X, y), jac=True, method=\"L-BFGS-B\")\n", + "unpack(result.x)\n", + "\n", + "params = pg.optim.get_trained_params(manual_model, shared_params)\n", + "print({name: round(float(v), 3) for name, v in params.items()})" + ] + }, + { + "cell_type": "markdown", + "id": "1e602a3b", + "metadata": {}, + "source": [ + "## Sparse GP (VFE)\n", + "\n", + "Exact inference factorizes an $N \\times N$ matrix: $O(N^3)$ time, $O(N^2)$ memory. Sparse GPs summarize the data with $M \\ll N$ inducing points; the VFE bound {cite:p}`titsias-2009` fits them at $O(N M^2)$ while staying close to exact inference.\n", + "\n", + "{class}`pg.gp.VFE ` takes an `inducing_variable`. {func}`~ptgp.inducing.greedy_variance_init` places the inducing inputs by pivoted Cholesky {cite:p}`burt-2020`, and {func}`pg.fit ` refines them along with the hyperparameters. Everything else matches the exact GP." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "6bed98f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ls = 0.520\n", + " eta = 0.931\n", + " sigma = 0.474\n" + ] + } + ], + "source": [ + "M = 15\n", + "Z_init = pg.inducing.greedy_variance_init(X, M, pg.kernels.Matern52(input_dim=1, ls=0.5), rng=0)[\n", + " 0\n", + "].Z\n", + "Z_var = pt.matrix(\"Z\", shape=(M, 1))\n", + "\n", + "with pm.Model() as vfe_model:\n", + " ls = pm.InverseGamma(\"ls\", alpha=3.0, beta=1.0)\n", + " eta = pm.Exponential(\"eta\", scale=1.0)\n", + " sigma = pm.HalfNormal(\"sigma\", sigma=1.0)\n", + "\n", + " kernel = eta**2 * pg.kernels.Matern52(input_dim=1, ls=ls)\n", + " vfe = pg.gp.VFE(\n", + " kernel=kernel,\n", + " sigma=sigma,\n", + " inducing_variable=pg.inducing.Points(Z_var, Z_init=Z_init),\n", + " )\n", + " fit_vfe = pg.fit(vfe, X, y)\n", + "\n", + "for name, value in fit_vfe.params.items():\n", + " print(f\"{name:>6} = {value:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f7ee94a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu_v, var_v = pg.predict(vfe, X_grid, fit_vfe, X_train=X, y_train=y)\n", + "_, var_v_y = pg.predict(vfe, X_grid, fit_vfe, X_train=X, y_train=y, incl_lik=True)\n", + "\n", + "sd_v, sd_v_y = np.sqrt(var_v), np.sqrt(var_v_y)\n", + "mean_v = to_g(mu_v)\n", + "f_band_v = to_g(mu_v - 2 * sd_v), to_g(mu_v + 2 * sd_v)\n", + "y_band_v = to_g(mu_v - 2 * sd_v_y), to_g(mu_v + 2 * sd_v_y)\n", + "\n", + "Z_final = fit_vfe.shared_extras[0].get_value() # inducing inputs after optimization\n", + "z_ms = x_scaler.inverse_transform(Z_final).ravel()\n", + "\n", + "plot_gp(\n", + " mean_v,\n", + " f_band_v,\n", + " y_band_v,\n", + " color=\"C1\",\n", + " inducing=z_ms,\n", + " title=f\"VFE sparse GP posterior (M = {M})\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "582f4503", + "metadata": {}, + "source": [ + "## Accuracy\n", + "\n", + "With 15 inducing points against all 133 observations, the sparse posterior mean sits almost on top of the exact one." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "e202fc57", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max |mean_VFE - mean_exact| = 1.50 g (M = 15 inducing points vs all N = 133 observations)\n" + ] + } + ], + "source": [ + "ax = plot_gp(\n", + " mean, f_band, label=\"exact GP\", band_labels=False, title=\"Exact GP vs VFE sparse approximation\"\n", + ")\n", + "plot_gp(mean_v, f_band_v, ax=ax, color=\"C1\", ls=\"--\", label=f\"VFE (M = {M})\", band_labels=False)\n", + "plt.show()\n", + "\n", + "max_dev = np.max(np.abs(mean_v - mean))\n", + "print(\n", + " f\"max |mean_VFE - mean_exact| = {max_dev:.2f} g \"\n", + " f\"(M = {M} inducing points vs all N = {N} observations)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "949e4399", + "metadata": {}, + "source": [ + "## Next steps\n", + "\n", + "- {doc}`Kernel gallery `: covariance functions and what they encode.\n", + "- {doc}`User guide `: models, likelihoods, inducing points, and training.\n", + "- {ref}`Stochastic variational GPs `: SVGP and minibatch training at scale.\n", + "\n", + "## References\n", + "\n", + "```{bibliography}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 0351f64..8c7b8c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -104,6 +104,10 @@ ignore = [ [tool.ruff.lint.isort] lines-between-types = 1 +[tool.ruff.lint.per-file-ignores] +# Notebooks are hand-formatted for teaching; don't reorganize their imports. +"*.ipynb" = ["I001", "E402"] + [tool.mypy] python_version = "3.12" ignore_missing_imports = true