diff --git a/.gitignore b/.gitignore index 4b6ad014..19a672a6 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,198 @@ -gitignore +spinnaker_python +spinnaker_python/* +spinnaker_sdk +spinnaker_sdk/* +spinnaker_python*.tar.gz +spinnaker-*.tar.gz +spinnaker.tar.gz +*.csv +*.zip +*.json +*.record +*.deb +Python-3.10.0 +Python-3.10.0/* +Python-3.9.0 +Python-3.9.0/* +Python-3.10.0.tar.xz +Python-3.9.0.tar.xz +spinnaker_sdk.tar.gz +models +models/* +my-models +my-models/* +label-studio +label-studio/* +dataset +dataset/* + +**utils/__pycache__ +**old/.venv* +.venv* +.venv*/* +.mypy_cache +.mypy_cache/* +label_map.pbtxt + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ \ No newline at end of file diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..44677e5c --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.10.20 diff --git a/3d-files/3mf/Case.3mf b/3d-files/3mf/Case.3mf new file mode 100644 index 00000000..bee4c44d Binary files /dev/null and b/3d-files/3mf/Case.3mf differ diff --git a/3d-files/3mf/Display/Bildschirmhalterung.3mf b/3d-files/3mf/Display/Bildschirmhalterung.3mf new file mode 100644 index 00000000..e18ed673 Binary files /dev/null and b/3d-files/3mf/Display/Bildschirmhalterung.3mf differ diff --git a/3d-files/3mf/Display/MOSFET_Halterung.3mf b/3d-files/3mf/Display/MOSFET_Halterung.3mf new file mode 100644 index 00000000..581c3513 Binary files /dev/null and b/3d-files/3mf/Display/MOSFET_Halterung.3mf differ diff --git a/3d-files/3mf/Display/MotorController_Halterung.3mf b/3d-files/3mf/Display/MotorController_Halterung.3mf new file mode 100644 index 00000000..78881909 Binary files /dev/null and b/3d-files/3mf/Display/MotorController_Halterung.3mf differ diff --git a/3d-files/3mf/Display/RaspberryPI_Halterung.3mf b/3d-files/3mf/Display/RaspberryPI_Halterung.3mf new file mode 100644 index 00000000..a952e4b3 Binary files /dev/null and b/3d-files/3mf/Display/RaspberryPI_Halterung.3mf differ diff --git a/3d-files/3mf/Kamera/Deckel.3mf b/3d-files/3mf/Kamera/Deckel.3mf new file mode 100644 index 00000000..1491aedb Binary files /dev/null and b/3d-files/3mf/Kamera/Deckel.3mf differ diff --git a/3d-files/3mf/Kamera/Kameraholder.3mf b/3d-files/3mf/Kamera/Kameraholder.3mf new file mode 100644 index 00000000..e911a70d Binary files /dev/null and b/3d-files/3mf/Kamera/Kameraholder.3mf differ diff --git a/3d-files/3mf/Kamera/MCP3008_Halter.3mf b/3d-files/3mf/Kamera/MCP3008_Halter.3mf new file mode 100644 index 00000000..26f686f4 Binary files /dev/null and b/3d-files/3mf/Kamera/MCP3008_Halter.3mf differ diff --git a/3d-files/3mf/Kamera/Unterteil.3mf b/3d-files/3mf/Kamera/Unterteil.3mf new file mode 100644 index 00000000..b23960b5 Binary files /dev/null and b/3d-files/3mf/Kamera/Unterteil.3mf differ diff --git a/3d-files/3mf/Kamera/main_chamber.3mf b/3d-files/3mf/Kamera/main_chamber.3mf new file mode 100644 index 00000000..71b95eb6 Binary files /dev/null and b/3d-files/3mf/Kamera/main_chamber.3mf differ diff --git a/3d-files/3mf/Tippything/Box.3mf b/3d-files/3mf/Tippything/Box.3mf new file mode 100644 index 00000000..8c4a2719 Binary files /dev/null and b/3d-files/3mf/Tippything/Box.3mf differ diff --git a/3d-files/3mf/Tippything/Kurbelschleife.3mf b/3d-files/3mf/Tippything/Kurbelschleife.3mf new file mode 100644 index 00000000..50611f22 Binary files /dev/null and b/3d-files/3mf/Tippything/Kurbelschleife.3mf differ diff --git a/3d-files/3mf/Tippything/Kurbelschleifen_Funktionstester.3mf b/3d-files/3mf/Tippything/Kurbelschleifen_Funktionstester.3mf new file mode 100644 index 00000000..b3ae58d6 Binary files /dev/null and b/3d-files/3mf/Tippything/Kurbelschleifen_Funktionstester.3mf differ diff --git a/3d-files/3mf/Tippything/Plexiglashalter.3mf b/3d-files/3mf/Tippything/Plexiglashalter.3mf new file mode 100644 index 00000000..228bef5b Binary files /dev/null and b/3d-files/3mf/Tippything/Plexiglashalter.3mf differ diff --git a/3d-files/3mf/Tippything/Rohr.3mf b/3d-files/3mf/Tippything/Rohr.3mf new file mode 100644 index 00000000..9a88fd98 Binary files /dev/null and b/3d-files/3mf/Tippything/Rohr.3mf differ diff --git a/3d-files/3mf/Tippything/Tippything_Case.3mf b/3d-files/3mf/Tippything/Tippything_Case.3mf new file mode 100644 index 00000000..cc2e081f Binary files /dev/null and b/3d-files/3mf/Tippything/Tippything_Case.3mf differ diff --git a/3d-files/3mf/Tippything/Track.3mf b/3d-files/3mf/Tippything/Track.3mf new file mode 100644 index 00000000..5cb43af6 Binary files /dev/null and b/3d-files/3mf/Tippything/Track.3mf differ diff --git a/3d-files/3mf/Tippything/Trichter.3mf b/3d-files/3mf/Tippything/Trichter.3mf new file mode 100644 index 00000000..cc1ea05d Binary files /dev/null and b/3d-files/3mf/Tippything/Trichter.3mf differ diff --git a/3d-files/3mf/Transporter/Archimedes_Screw.3mf b/3d-files/3mf/Transporter/Archimedes_Screw.3mf new file mode 100644 index 00000000..bdec7892 Binary files /dev/null and b/3d-files/3mf/Transporter/Archimedes_Screw.3mf differ diff --git a/3d-files/3mf/Transporter/Motor_Holder.3mf b/3d-files/3mf/Transporter/Motor_Holder.3mf new file mode 100644 index 00000000..08e45fe9 Binary files /dev/null and b/3d-files/3mf/Transporter/Motor_Holder.3mf differ diff --git a/3d-files/3mf/Transporter/Transporter_Adapter.3mf b/3d-files/3mf/Transporter/Transporter_Adapter.3mf new file mode 100644 index 00000000..f4487c91 Binary files /dev/null and b/3d-files/3mf/Transporter/Transporter_Adapter.3mf differ diff --git a/3d-files/3mf/Transporter/Transporter_Case.3mf b/3d-files/3mf/Transporter/Transporter_Case.3mf new file mode 100644 index 00000000..8c01ffdb Binary files /dev/null and b/3d-files/3mf/Transporter/Transporter_Case.3mf differ diff --git a/3d-files/3mf/Transporter/Transporter_Case_Wall.3mf b/3d-files/3mf/Transporter/Transporter_Case_Wall.3mf new file mode 100644 index 00000000..7fc82cc0 Binary files /dev/null and b/3d-files/3mf/Transporter/Transporter_Case_Wall.3mf differ diff --git "a/3d-files/3mf/Transporter/Tube_Curved_67.5\302\260.3mf" "b/3d-files/3mf/Transporter/Tube_Curved_67.5\302\260.3mf" new file mode 100644 index 00000000..a55089db Binary files /dev/null and "b/3d-files/3mf/Transporter/Tube_Curved_67.5\302\260.3mf" differ diff --git "a/3d-files/3mf/Transporter/Tube_Curved_90\302\260.3mf" "b/3d-files/3mf/Transporter/Tube_Curved_90\302\260.3mf" new file mode 100644 index 00000000..93b7e3c7 Binary files /dev/null and "b/3d-files/3mf/Transporter/Tube_Curved_90\302\260.3mf" differ diff --git a/3d-files/3mf/Transporter/Tube_Straight.3mf b/3d-files/3mf/Transporter/Tube_Straight.3mf new file mode 100644 index 00000000..0aa8e022 Binary files /dev/null and b/3d-files/3mf/Transporter/Tube_Straight.3mf differ diff --git a/3d-files/f3d/Case.f3d b/3d-files/f3d/Case.f3d new file mode 100644 index 00000000..4e0876cb Binary files /dev/null and b/3d-files/f3d/Case.f3d differ diff --git a/3d-files/f3d/Display/Bildschirmhalterung.f3d b/3d-files/f3d/Display/Bildschirmhalterung.f3d new file mode 100644 index 00000000..25a03e55 Binary files /dev/null and b/3d-files/f3d/Display/Bildschirmhalterung.f3d differ diff --git a/3d-files/f3d/Display/MOSFET_Halterung.f3d b/3d-files/f3d/Display/MOSFET_Halterung.f3d new file mode 100644 index 00000000..b1b4b74d Binary files /dev/null and b/3d-files/f3d/Display/MOSFET_Halterung.f3d differ diff --git a/3d-files/f3d/Display/MotorController_Halterung.f3d b/3d-files/f3d/Display/MotorController_Halterung.f3d new file mode 100644 index 00000000..c21b9548 Binary files /dev/null and b/3d-files/f3d/Display/MotorController_Halterung.f3d differ diff --git a/3d-files/f3d/Display/RaspberryPI_Halterung.f3d b/3d-files/f3d/Display/RaspberryPI_Halterung.f3d new file mode 100644 index 00000000..aefafbc0 Binary files /dev/null and b/3d-files/f3d/Display/RaspberryPI_Halterung.f3d differ diff --git a/3d-files/f3d/Kamera/Deckel.f3d b/3d-files/f3d/Kamera/Deckel.f3d new file mode 100644 index 00000000..b9e24c60 Binary files /dev/null and b/3d-files/f3d/Kamera/Deckel.f3d differ diff --git a/3d-files/f3d/Kamera/Kameraholder.f3d b/3d-files/f3d/Kamera/Kameraholder.f3d new file mode 100644 index 00000000..dddcfb10 Binary files /dev/null and b/3d-files/f3d/Kamera/Kameraholder.f3d differ diff --git a/3d-files/f3d/Kamera/MCP3008_Halter.f3d b/3d-files/f3d/Kamera/MCP3008_Halter.f3d new file mode 100644 index 00000000..fd50cccc Binary files /dev/null and b/3d-files/f3d/Kamera/MCP3008_Halter.f3d differ diff --git a/3d-files/f3d/Kamera/Unterteil.f3d b/3d-files/f3d/Kamera/Unterteil.f3d new file mode 100644 index 00000000..91066941 Binary files /dev/null and b/3d-files/f3d/Kamera/Unterteil.f3d differ diff --git a/3d-files/f3d/Kamera/main_chamber.f3d b/3d-files/f3d/Kamera/main_chamber.f3d new file mode 100644 index 00000000..19cb9984 Binary files /dev/null and b/3d-files/f3d/Kamera/main_chamber.f3d differ diff --git a/3d-files/f3d/Tippything/Box.f3d b/3d-files/f3d/Tippything/Box.f3d new file mode 100644 index 00000000..ff7a6ff6 Binary files /dev/null and b/3d-files/f3d/Tippything/Box.f3d differ diff --git a/3d-files/f3d/Tippything/Kurbelschleife.f3d b/3d-files/f3d/Tippything/Kurbelschleife.f3d new file mode 100644 index 00000000..c19de8cf Binary files /dev/null and b/3d-files/f3d/Tippything/Kurbelschleife.f3d differ diff --git a/3d-files/f3d/Tippything/Kurbelschleifen_Funktionstester.f3d b/3d-files/f3d/Tippything/Kurbelschleifen_Funktionstester.f3d new file mode 100644 index 00000000..99f44ea7 Binary files /dev/null and b/3d-files/f3d/Tippything/Kurbelschleifen_Funktionstester.f3d differ diff --git a/3d-files/f3d/Tippything/Plexiglashalter.f3d b/3d-files/f3d/Tippything/Plexiglashalter.f3d new file mode 100644 index 00000000..50b5b53e Binary files /dev/null and b/3d-files/f3d/Tippything/Plexiglashalter.f3d differ diff --git a/3d-files/f3d/Tippything/Rohr.f3d b/3d-files/f3d/Tippything/Rohr.f3d new file mode 100644 index 00000000..dfd0344d Binary files /dev/null and b/3d-files/f3d/Tippything/Rohr.f3d differ diff --git a/3d-files/f3d/Tippything/Tippything_Case.f3d b/3d-files/f3d/Tippything/Tippything_Case.f3d new file mode 100644 index 00000000..7df4a802 Binary files /dev/null and b/3d-files/f3d/Tippything/Tippything_Case.f3d differ diff --git a/3d-files/f3d/Tippything/Track.f3d b/3d-files/f3d/Tippything/Track.f3d new file mode 100644 index 00000000..aa1029e8 Binary files /dev/null and b/3d-files/f3d/Tippything/Track.f3d differ diff --git a/3d-files/f3d/Tippything/Trichter.f3d b/3d-files/f3d/Tippything/Trichter.f3d new file mode 100644 index 00000000..9fc321de Binary files /dev/null and b/3d-files/f3d/Tippything/Trichter.f3d differ diff --git a/3d-files/f3d/Transporter/Archimedes_Screw.f3d b/3d-files/f3d/Transporter/Archimedes_Screw.f3d new file mode 100644 index 00000000..76c70543 Binary files /dev/null and b/3d-files/f3d/Transporter/Archimedes_Screw.f3d differ diff --git a/3d-files/f3d/Transporter/Motor_Holder.f3d b/3d-files/f3d/Transporter/Motor_Holder.f3d new file mode 100644 index 00000000..e17ad88a Binary files /dev/null and b/3d-files/f3d/Transporter/Motor_Holder.f3d differ diff --git a/3d-files/f3d/Transporter/Transporter_Adapter.f3d b/3d-files/f3d/Transporter/Transporter_Adapter.f3d new file mode 100644 index 00000000..3e60290b Binary files /dev/null and b/3d-files/f3d/Transporter/Transporter_Adapter.f3d differ diff --git a/3d-files/f3d/Transporter/Transporter_Case.f3d b/3d-files/f3d/Transporter/Transporter_Case.f3d new file mode 100644 index 00000000..21049770 Binary files /dev/null and b/3d-files/f3d/Transporter/Transporter_Case.f3d differ diff --git a/3d-files/f3d/Transporter/Transporter_Case_Wall.f3d b/3d-files/f3d/Transporter/Transporter_Case_Wall.f3d new file mode 100644 index 00000000..814d76d9 Binary files /dev/null and b/3d-files/f3d/Transporter/Transporter_Case_Wall.f3d differ diff --git "a/3d-files/f3d/Transporter/Tube_Curved_67.5\302\260.f3d" "b/3d-files/f3d/Transporter/Tube_Curved_67.5\302\260.f3d" new file mode 100644 index 00000000..bc668cb0 Binary files /dev/null and "b/3d-files/f3d/Transporter/Tube_Curved_67.5\302\260.f3d" differ diff --git "a/3d-files/f3d/Transporter/Tube_Curved_90\302\260.f3d" "b/3d-files/f3d/Transporter/Tube_Curved_90\302\260.f3d" new file mode 100644 index 00000000..2cb49e22 Binary files /dev/null and "b/3d-files/f3d/Transporter/Tube_Curved_90\302\260.f3d" differ diff --git a/3d-files/f3d/Transporter/Tube_Straight.f3d b/3d-files/f3d/Transporter/Tube_Straight.f3d new file mode 100644 index 00000000..37776fe2 Binary files /dev/null and b/3d-files/f3d/Transporter/Tube_Straight.f3d differ diff --git a/Dockerfile.train b/Dockerfile.train new file mode 100644 index 00000000..b948bcf1 --- /dev/null +++ b/Dockerfile.train @@ -0,0 +1,75 @@ +# ============================================================================= +# Sorter end-to-end training image. +# +# A single `docker run` performs: +# 1. TFRecord generation from Label Studio JSONs +# 2. SSD MobileNet V2 fine-tuning (TF Object Detection API, TF 2.11) +# 3. TFLite-friendly graph export +# 4. Full INT8 quantization with a representative dataset +# 5. Edge TPU compilation +# +# Required mounts: +# -v /dataset:/dataset # input (read-write; nothing is written here) +# -v /my-models:/my-models # output (all artifacts land here) +# +# Optional: append `--gpus all` to use the host GPU via the NVIDIA Container Toolkit. +# ============================================================================= +# NOTE: the `devel` (not `runtime`) CUDA image is required because TensorFlow's +# XLA JIT needs `libdevice.10.bc`, `ptxas` and friends, which are only present +# in -devel-. Without them training fails with: +# error: Can't find libdevice directory ${CUDA_DIR}/nvvm/libdevice +# UNKNOWN: JIT compilation failed. +FROM nvidia/cuda:11.8.0-cudnn8-devel-ubuntu20.04 + +ENV DEBIAN_FRONTEND=noninteractive \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + XLA_FLAGS=--xla_gpu_cuda_data_dir=/usr/local/cuda + +# ---- System packages --------------------------------------------------------- +# libgl1 + libglib2.0-0 are required by opencv-python, which is pulled in by the +# Object Detection API via the `lvis` evaluator. +RUN apt-get update && apt-get install -y \ + python3 python3-pip python3-dev \ + git curl gnupg protobuf-compiler ca-certificates \ + libgl1 libglib2.0-0 \ + && rm -rf /var/lib/apt/lists/* + +# ---- Edge TPU compiler ------------------------------------------------------- +RUN curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg \ + | gpg --dearmor -o /usr/share/keyrings/coral-edgetpu-archive-keyring.gpg && \ + echo "deb [signed-by=/usr/share/keyrings/coral-edgetpu-archive-keyring.gpg] https://packages.cloud.google.com/apt coral-edgetpu-stable main" \ + > /etc/apt/sources.list.d/coral-edgetpu.list && \ + apt-get update && apt-get install -y edgetpu-compiler && rm -rf /var/lib/apt/lists/* + +# ---- Python base ------------------------------------------------------------- +RUN python3 -m pip install --upgrade pip && \ + python3 -m pip install "tensorflow==2.11.0" "numpy<2" pillow + +# ---- TensorFlow Object Detection API ----------------------------------------- +# The OD API setup tends to drag in conflicting TF/Keras pins, so we re-pin +# tensorflow==2.11.0 and numpy<2 right after installing it. +RUN git clone --depth 1 https://github.com/tensorflow/models.git /opt/models && \ + cd /opt/models/research && \ + protoc object_detection/protos/*.proto --python_out=. && \ + cp object_detection/packages/tf2/setup.py . && \ + python3 -m pip install . && \ + python3 -m pip install --force-reinstall "tensorflow==2.11.0" "numpy<2" + +# ---- Pretrained SSD MobileNet V2 checkpoint ---------------------------------- +RUN mkdir -p /opt/sorter/pretrained && \ + curl -fsSL http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz \ + | tar -xz -C /opt/sorter/pretrained + +# ---- Repo-level config + helper scripts -------------------------------------- +COPY pipeline.config /opt/sorter/pipeline.config +COPY label_map.pbtxt /opt/sorter/label_map.pbtxt +COPY docker/build_tfrecords.py /opt/sorter/build_tfrecords.py +COPY docker/quantize.py /opt/sorter/quantize.py +COPY docker/entrypoint.sh /usr/local/bin/sorter-train +RUN chmod +x /usr/local/bin/sorter-train + +VOLUME ["/dataset", "/my-models"] +WORKDIR /my-models + +ENTRYPOINT ["/usr/local/bin/sorter-train"] \ No newline at end of file diff --git a/FLIR/FLIR.py b/FLIR/FLIR.py deleted file mode 100644 index 612ac718..00000000 --- a/FLIR/FLIR.py +++ /dev/null @@ -1,80 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -import PySpin -import cv2 -class FlirBFS(object): - # takes in a mode, a path to a model, and a callback function that gets called each new frame - def __init__(self, on_new_frame=None, frame_rate=120, display=False): - self.system = PySpin.System.GetInstance() - self.cam_list = self.system.GetCameras() - self.frame_rate = frame_rate - self.display = display - self.on_new_frame = on_new_frame - if len(self.cam_list) == 0: - raise Exception('No FLIR camera connected!') - - self.cam = self.cam_list[0] - - # This function pre configures camera settings on the flir. - def run_cam(self): - try: - self.cam.Init() - - # self.nodemap_tldevice = cam.GetTLdeviceNodeMap() - nodemap = self.cam.GetNodeMap() - stream_nodemap = self.cam.GetTLStreamNodeMap() - - # Configure Camera Settings - self.cam.TriggerMode.SetValue(PySpin.TriggerMode_Off) - self.cam.AcquisitionFrameRateEnable.SetValue(True) - self.cam.AcquisitionFrameRate.SetValue(self.frame_rate) - - handling_mode = PySpin.CEnumerationPtr( - stream_nodemap.GetNode('StreamBufferHandlingMode')) - handling_mode_entry = handling_mode.GetEntryByName( - 'NewestOnly') - handling_mode.SetIntValue(handling_mode_entry.GetValue()) - - self.acquire_images(nodemap, stream_nodemap) - except PySpin.SpinnakerException as ex: - print('Error {}'.format(ex)) - - def acquire_images(self, nodemap, stream_nodemap): - - self.cam.BeginAcquisition() - - while True: - try: - image_result = self.cam.GetNextImage() - if image_result.IsIncomplete(): - print('Image incomplete with image status {} ...'.format(image_result.GetImageStatus())) - else: - color_image = image_result.Convert(PySpin.PixelFormat_BGR8, PySpin.HQ_LINEAR) - open_cv_mat = color_image.GetNDArray() - open_cv_mat = cv2.cvtColor(open_cv_mat, cv2.COLOR_BGR2RGB) - if (self.on_new_frame != None): - self.on_new_frame(cv_mat=open_cv_mat) - - if (self.display == True): - cv2.imshow('sorter_camera', open_cv_mat) - cv2.waitKey(1) - except PySpin.SpinnakerException as ex: - print('Error {}'.format(ex)) - del self.cam - - # Clear camera list before releasing system - self.cam_list.Clear() - - # Release system instance - self.system.ReleaseInstance() diff --git a/FLIR/__init__.py b/FLIR/__init__.py deleted file mode 100644 index 7f0a8a79..00000000 --- a/FLIR/__init__.py +++ /dev/null @@ -1,19 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import PySpin -import cv2 -from .flir import FlirBFS - - diff --git a/README.md b/README.md new file mode 100644 index 00000000..5d97d0ec --- /dev/null +++ b/README.md @@ -0,0 +1,100 @@ +# AI-Sorter + +An AI-powered marble sorting machine. A camera detects falling marbles, a neural network classifies them by color, and a solenoid actuator sorts them into the correct bin — all in real time on a Raspberry Pi with a Coral Edge TPU. + +## What You Need + +This project requires **two machines**: + +### Raspberry Pi (runs the sorter) + +| Component | Description | +|---|---| +| **Raspberry Pi** | Runs the sorting software (tested on Pi 4/5, Ubuntu 22.04 ARM64) | +| **FLIR Machine Vision Camera** | Captures images of marbles (uses the Spinnaker SDK) | +| **Coral USB Accelerator** | Runs the trained model for real-time inference (~6 ms/frame) | +| **Elevator motor** | Feeds marbles into the sorting area | +| **Solenoid actuator** | Diverts marbles into the correct bin | +| **NeoPixel LED strip** | Illuminates the sorting area for consistent images | +| **Light-beam sensor** | Detects when a marble passes through | + +### Training PC (trains the AI model) + +| Component | Description | +|---|---| +| **PC with NVIDIA GPU** | Trains the SSD MobileNet V2 model (fine-tuning ~50 000 steps) | +| **Docker + NVIDIA Container Toolkit** | The training pipeline runs inside a Docker container with GPU access | + +> The training PC can be a local desktop, a cloud VM (AWS EC2, Google Cloud, etc.), or Google Colab. **Do not attempt training on the Raspberry Pi.** + +## Step-by-Step Guide + +Follow the guides below in order: + +| Step | Guide | Machine | +|---|---|---| +| 0 | [Build the Sorter](docs/00-build-the-sorter.md) *(TODO)* | Workbench | +| 1 | [Raspberry Pi Setup](docs/01-raspberry-pi-setup.md) | Raspberry Pi | +| 2 | [Training PC Setup](docs/02-training-pc-setup.md) | Training PC | +| 3 | [Create a Dataset](docs/03-create-dataset.md) | Raspberry Pi | +| 4 | [Train the Model](docs/04-train-model.md) | Training PC | +| 5 | [Run the Sorter](docs/05-run-sorter.md) | Raspberry Pi | + +## Project Structure + +``` +. +├── actuator/ # Motor, solenoid and LED control +├── sensor/ # Camera and light-beam sensor +├── dataset/ # Training images (created in step 3) +├── my-models/ # Trained models (created in step 4) +├── docs/ # Step-by-step setup guides +├── create_unlabeled_dataset.py +├── label_dataset.py +├── label_map.pbtxt # Single source of truth for class labels +├── main.py # Entry point for the sorter +├── Dockerfile.train # Docker image for training +└── pipeline.config # SSD MobileNet V2 training config +``` + +## Label Map (`label_map.pbtxt`) + +`label_map.pbtxt` is the **single source of truth** for all class labels used throughout the project. Every script — labeling, TFRecord generation, training, and inference — reads its labels from this file. Never hardcode label names or IDs elsewhere. + +The file uses the [TensorFlow Object Detection API label map format](https://github.com/tensorflow/models/blob/master/research/object_detection/data/kitti_label_map.pbtxt). Each class gets an `item` block with a unique `id` (starting at 1) and a `name`: + +```protobuf +item { + id: 1 + name: 'black' +} + +item { + id: 2 + name: 'green' +} + +item { + id: 3 + name: 'orange' +} + +item { + id: 4 + name: 'red' +} + +``` + +To add or change marble colors: + +1. Edit `label_map.pbtxt` — add, remove, or rename entries. +2. Make sure a matching `dataset//` folder with images exists for each label (see [Step 3](docs/03-create-dataset.md)). +3. Update `num_classes` in `pipeline.config` to match the number of items in `label_map.pbtxt`. +4. Re-run the labeling and training pipeline as usual — all scripts pick up the changes automatically. + +## Sources + +- **Model:** [SSD MobileNet V2 320x320 (COCO17 TPU-8)](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz) +- **Framework:** [TensorFlow Object Detection API](https://github.com/tensorflow/models/tree/master/research/object_detection) +- **Edge TPU compiler:** [coral.ai/docs/edgetpu/compiler](https://coral.ai/docs/edgetpu/compiler/) \ No newline at end of file diff --git a/actuator/.python-version b/actuator/.python-version new file mode 100644 index 00000000..44677e5c --- /dev/null +++ b/actuator/.python-version @@ -0,0 +1 @@ +3.10.20 diff --git a/actuator/README.md b/actuator/README.md new file mode 100644 index 00000000..8b775ac2 --- /dev/null +++ b/actuator/README.md @@ -0,0 +1,19 @@ +# Information about the Actuator module. +This folder contains the code for the Actuator module, which is responsible for controlling the physical components of the system. It includes code for: +- Motor elevator for marbles +- Solenoid motor for a marble switch to change the path of the marbles +- LED neopixel ring to make a picture of the marbles falling down + +# Installation + +```bash +python3 -m venv .venv-3.10 +source .venv-3.10/bin/activate +pip install -r requirements-3.10.txt +``` + +# Usage + +```bash +sudo .venv-3.10/bin/python [script].py +``` \ No newline at end of file diff --git a/actuator/elevator_motor.py b/actuator/elevator_motor.py new file mode 100644 index 00000000..4b136384 --- /dev/null +++ b/actuator/elevator_motor.py @@ -0,0 +1,68 @@ +import RPi.GPIO as GPIO +import time + +class ElevatorMotorController: + """A class to control a stepper motor for an elevator.""" + + def __init__(self, enable_pin: int = 17, dir_pin: int = 27, step_pin: int = 22): + self.enable_pin = enable_pin + self.dir_pin = dir_pin + self.step_pin = step_pin + + # Initialize the hardware within the object + GPIO.setmode(GPIO.BCM) + GPIO.setwarnings(False) + + GPIO.setup(self.enable_pin, GPIO.OUT) + GPIO.setup(self.dir_pin, GPIO.OUT) + GPIO.setup(self.step_pin, GPIO.OUT) + + def enable(self) -> None: + """Enables the motor by setting the ENABLE pin to LOW.""" + GPIO.output(self.enable_pin, GPIO.LOW) + + def disable(self) -> None: + """Disables the motor by setting the ENABLE pin to HIGH.""" + GPIO.output(self.enable_pin, GPIO.HIGH) + + def rotate(self, steps: int, pause_seconds: float, direction_val: int = GPIO.LOW) -> None: + """Sets the direction and rotates the motor a given number of steps.""" + GPIO.output(self.dir_pin, direction_val) + + for _ in range(steps): + GPIO.output(self.step_pin, GPIO.HIGH) + time.sleep(pause_seconds) + GPIO.output(self.step_pin, GPIO.LOW) + time.sleep(pause_seconds) + + def cleanup(self) -> None: + """Disables the motor and safely releases the GPIO pins.""" + self.disable() + GPIO.cleanup([self.step_pin, self.dir_pin]) + + +if __name__ == '__main__': + # 1. Instantiate the controller (uses the default values defined in __init__) + motor = ElevatorMotorController() + + steps = 400 + pause_seconds = 0.002 + + print("Motor test started...") + time.sleep(1) + print("Motor rotates one full 360° turn to the left") + + try: + # Enable the hardware + motor.enable() + + # Run the rotation sequence + motor.rotate(steps=steps, pause_seconds=pause_seconds, direction_val=GPIO.LOW) + + except KeyboardInterrupt: + print("\nTest cancelled by user") + + finally: + # Ensure hardware turns off when the script ends or is interrupted + print("Motor test finished") + motor.cleanup() \ No newline at end of file diff --git a/actuator/led_neopixel.py b/actuator/led_neopixel.py new file mode 100644 index 00000000..ea603445 --- /dev/null +++ b/actuator/led_neopixel.py @@ -0,0 +1,53 @@ +import board +import neopixel +import time + +class NeoPixelController: + """A class to control a NeoPixel LED strip or ring.""" + + def __init__(self, pin=board.D18, count: int = 24, brightness: float = 0.5): + self.pin = pin + self.count = count + self.brightness = brightness + + # Initialize the hardware within the object + self.pixels = neopixel.NeoPixel( + self.pin, + self.count, + brightness=self.brightness, + auto_write=False + ) + + def set_color(self, color: tuple) -> None: + """Fills the entire strip with a specific RGB color.""" + self.pixels.fill(color) + self.pixels.show() + + def turn_off(self) -> None: + """Clears all LEDs (turns them off).""" + self.set_color((0, 0, 0)) + +if __name__ == "__main__": + # 1. Instantiate the controller (uses the default values defined in __init__) + led_ring = NeoPixelController() + + """Runs a test sequence, turning LEDs white for a set duration.""" + duration = 5 # Duration in seconds for the test + try: + print("NeoPixel test started...") + time.sleep(1) + + print(f"Turning NeoPixel rings on for {duration} seconds") + led_ring.set_color((255, 255, 255)) + + # Replaced the commented-out loop with a simple sleep + # for the specified duration + time.sleep(duration) + + except KeyboardInterrupt: + print("\nTest cancelled by user") + + finally: + # Uncommented the cleanup so the LEDs turn off when the script ends + led_ring.turn_off() + print("NeoPixel test finished") \ No newline at end of file diff --git a/actuator/requirements-3.10.txt b/actuator/requirements-3.10.txt new file mode 100644 index 00000000..6ef21c91 --- /dev/null +++ b/actuator/requirements-3.10.txt @@ -0,0 +1,5 @@ +mypy +RPi.GPIO +Adafruit-Blinka +adafruit-circuitpython-neopixel +gpiozero \ No newline at end of file diff --git a/actuator/switch_solenoid_motor.py b/actuator/switch_solenoid_motor.py new file mode 100644 index 00000000..89adccab --- /dev/null +++ b/actuator/switch_solenoid_motor.py @@ -0,0 +1,48 @@ +from gpiozero import OutputDevice +from time import sleep + +class SolenoidController: + """A class to control a solenoid valve or actuator.""" + + def __init__(self, pin: int = 16): + self.pin = pin + + # Initialize the hardware within the object + self.solenoid = OutputDevice(self.pin) + + def turn_on(self) -> None: + """Activates the solenoid.""" + self.solenoid.on() + + def turn_off(self) -> None: + """Deactivates the solenoid.""" + self.solenoid.off() + +if __name__ == "__main__": + # 1. Instantiate the controller (uses the default values defined in __init__) + my_solenoid = SolenoidController() + + """Runs a test sequence, turning the solenoid on and off at set intervals.""" + # Test intervals in seconds + intervals = [1.0, 1.0, 0.5, 0.5, 0.1, 0.1] + + try: + print(f"Solenoid test started on GPIO pin {my_solenoid.pin}...") + sleep(1) + + for duration in intervals: + print(f"Solenoid ON ({duration}s)") + my_solenoid.turn_on() + sleep(duration) + + print("Solenoid OFF") + my_solenoid.turn_off() + sleep(duration) + + except KeyboardInterrupt: + print("\nTest cancelled by user") + + finally: + # Cleanup so the solenoid safely turns off when the script ends + my_solenoid.turn_off() + print("Solenoid test finished and pin safely disabled") \ No newline at end of file diff --git a/capture_process.py b/capture_process.py deleted file mode 100644 index 0ee97859..00000000 --- a/capture_process.py +++ /dev/null @@ -1,155 +0,0 @@ -import sys -import os -import numpy as np -import cv2 -import PySpin -import time -from rpi_ws281x import PixelStrip, Color -import socket - -# NeoPixel-Setup für zwei Streifen -LED_COUNT_1 = 24 # Anzahl der NeoPixel für den ersten Streifen -LED_COUNT_2 = 24 # Anzahl der NeoPixel für den zweiten Streifen -LED_PIN_1 = 18 # GPIO Pin für den ersten Streifen (GPIO 18 - Kanal 0) -LED_PIN_2 = 13 # GPIO Pin für den zweiten Streifen (GPIO 13 - Kanal 1) -LED_FREQ_HZ = 800000 # LED Signalfrequenz in Hz -LED_DMA = 10 # DMA-Kanal für die Ausgabe -LED_BRIGHTNESS = 255 # Helligkeit der LEDs (0-255) -LED_INVERT = False # Invertiere das Signal bei True -LED_CHANNEL_1 = 0 # Kanal für den ersten Streifen -LED_CHANNEL_2 = 1 # Kanal für den zweiten Streifen - -#Socket Verbindung - -client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -client_socket.connect(('localhost', 65432)) - -# Daten an Server senden (z. B. an Arduino senden) -client_socket.sendall(b'Hello Arduino') - -# Daten vom Server empfangen (z. B. von Arduino empfangen) -while True: - response = client_socket.recv(1024).decode('utf-8') - print(f"Received from Arduino: {response}") - -# Funktion zum Setzen der NeoPixel-Farben für beide Streifen -def set_neopixel_color(strip, color): - for i in range(strip.numPixels()): - strip.setPixelColor(i, color) - strip.show() - -def init_neopixel(pin, led_count, channel): - strip = PixelStrip(led_count, pin, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, channel) - strip.begin() - return strip - -def capture_flir_camera(mean, sliding_window, strip1, strip2): - system = PySpin.System.GetInstance() - cam_list = system.GetCameras() - - if cam_list.GetSize() == 0: - print("No cameras detected.") - system.ReleaseInstance() - return - - camera = cam_list.GetByIndex(0) - camera.Init() - - try: - # Setze die Bildrate - camera.AcquisitionFrameRateEnable.SetValue(True) - camera.AcquisitionFrameRate.SetValue(30.0) # Setzen Sie die Framerate auf 30 fps - - # Setze das Pixelformat auf BayerRG8 (falls RGB8 nicht funktioniert) - supported_formats = get_supported_pixel_formats(camera) - if 'BayerRG8' in supported_formats: - pixel_format_enum = PySpin.CEnumerationPtr(camera.GetNodeMap().GetNode("PixelFormat")) - pixel_format_bayerrg8 = pixel_format_enum.GetEntryByName("BayerRG8") - if pixel_format_bayerrg8 is not None and PySpin.IsAvailable(pixel_format_bayerrg8) and PySpin.IsWritable(pixel_format_bayerrg8): - pixel_format_enum.SetIntValue(pixel_format_bayerrg8.GetValue()) - print("Pixelformat auf BayerRG8 gesetzt.") - else: - print("BayerRG8 format not writable, using default format.") - else: - print("BayerRG8 format not supported, using default format.") - - # Überprüfe das aktuelle Bildformat - current_pixel_format = PySpin.CEnumerationPtr(camera.GetNodeMap().GetNode("PixelFormat")).GetCurrentEntry() - print("Aktuelles Bildformat:", current_pixel_format.GetSymbolic()) - - camera.AcquisitionMode.SetValue(PySpin.AcquisitionMode_Continuous) - camera.BeginAcquisition() - - # Setze die NeoPixel auf weiß (beide Streifen) - print("Setting NeoPixels to white.") - set_neopixel_color(strip1, Color(255, 255, 255)) - set_neopixel_color(strip2, Color(255, 255, 255)) - - while True: - try: - image_result = camera.GetNextImage() - if image_result.IsIncomplete(): - print("Image incomplete.") - continue - - if image_result.IsValid(): - # Manuelle Konvertierung des Bayer-Bildes zu RGB mit OpenCV - print("Konvertiere BayerRG8 zu RGB mit OpenCV") - image_data = image_result.GetNDArray() - - # BayerRG8 -> RGB konvertieren - image_rgb = cv2.cvtColor(image_data, cv2.COLOR_BAYER_RG2RGB) - - # Speichern Sie das Bild mit Zeitstempel - timestamp = time.strftime("%Y%m%d-%H%M%S") + str(int(time.time() * 1000) % 1000) - filename = f"/tmp/current_image_{timestamp}.jpg" - cv2.imwrite(filename, image_rgb) - - print(f"Bild gespeichert: {filename}") - - image_result.Release() - else: - print("Image result is not readable or available.") - break - - except Exception as ex: - print("Error during image acquisition: %s" % ex) - break - - finally: - camera.EndAcquisition() - camera.DeInit() - cam_list.Clear() - system.ReleaseInstance() - - # Schalte die NeoPixel-LEDs aus (beide Streifen) - print("Turning off NeoPixels.") - set_neopixel_color(strip1, Color(0, 0, 0)) - set_neopixel_color(strip2, Color(0, 0, 0)) - print("FLIR Camera deinitialized") - -def get_supported_pixel_formats(camera): - supported_formats = [] - try: - node_pixel_format = PySpin.CEnumerationPtr(camera.GetNodeMap().GetNode("PixelFormat")) - if node_pixel_format is not None and PySpin.IsAvailable(node_pixel_format) and PySpin.IsReadable(node_pixel_format): - entries = node_pixel_format.GetEntries() - for entry in entries: - entry_symbolic = PySpin.CEnumEntryPtr(entry) - if entry_symbolic is not None and PySpin.IsAvailable(entry_symbolic) and PySpin.IsReadable(entry_symbolic): - supported_formats.append(entry_symbolic.GetSymbolic()) - except Exception as e: - print(f"Fehler beim Abrufen der unterstützten Pixelformate: {e}") - - return supported_formats - -if __name__ == '__main__': - mean = [None] - sliding_window = [] - - print("Initializing FLIR Camera and NeoPixels") - # Initialisiere die beiden NeoPixel-Streifen - strip1 = init_neopixel(LED_PIN_1, LED_COUNT_1, LED_CHANNEL_1) - strip2 = init_neopixel(LED_PIN_2, LED_COUNT_2, LED_CHANNEL_2) - - capture_flir_camera(mean, sliding_window, strip1, strip2) diff --git a/classify_mixed.py b/classify_mixed.py new file mode 100644 index 00000000..a96612af --- /dev/null +++ b/classify_mixed.py @@ -0,0 +1,102 @@ +"""Classify all images in dataset/mixed-not-labeled/ using the Coral Edge TPU. + +Usage: + sudo .venv-3.10/bin/python classify_mixed.py + +Output format per image: + filename: 97.3% - red +""" + +import os +import re +import sys +import time +from pathlib import Path + +from PIL import Image +from pycoral.adapters import common, detect +from pycoral.utils.edgetpu import make_interpreter + +MODEL_PATH = "my-models/marbel_coral.tflite" +LABEL_MAP_PATH = "label_map.pbtxt" +IMAGE_DIR = "dataset/mixed-not-labeled" +THRESHOLD = 0.4 + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{id: name}`` dict (0-indexed for TFLite).""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[int(id_match.group(1)) - 1] = name_match.group(1) + return label_map + + +def main(): + if not os.path.exists(MODEL_PATH): + sys.exit(f"Modell nicht gefunden: {MODEL_PATH}") + + labels = parse_label_map(LABEL_MAP_PATH) + if not labels: + sys.exit(f"No labels found in {LABEL_MAP_PATH}") + + image_dir = Path(IMAGE_DIR) + if not image_dir.is_dir(): + sys.exit(f"Bildverzeichnis nicht gefunden: {IMAGE_DIR}") + + image_files = sorted( + p for p in image_dir.iterdir() + if p.suffix.lower() in (".png", ".jpg", ".jpeg", ".bmp") + ) + if not image_files: + sys.exit(f"Keine Bilder in {IMAGE_DIR} gefunden.") + + print(f"Lade Modell: {MODEL_PATH}") + try: + interpreter = make_interpreter(MODEL_PATH) + interpreter.allocate_tensors() + except Exception as e: + sys.exit( + f"Fehler beim Laden des Modells: {e}\n" + "Stelle sicher, dass der Coral USB Accelerator eingesteckt ist " + "und die Treiber installiert sind." + ) + + input_size = common.input_size(interpreter) + print(f"Modell geladen. Input-Groesse: {input_size}") + print(f"Verarbeite {len(image_files)} Bilder aus {IMAGE_DIR} ...\n") + + inference_times = [] + + for img_path in image_files: + image = Image.open(img_path).convert("RGB") + image_resized = image.resize(input_size, Image.LANCZOS) + common.set_input(interpreter, image_resized) + + t_start = time.perf_counter() + interpreter.invoke() + objs = detect.get_objects(interpreter, THRESHOLD) + t_end = time.perf_counter() + + elapsed_ms = (t_end - t_start) * 1000 + inference_times.append(elapsed_ms) + + if objs: + best = max(objs, key=lambda o: o.score) + label = labels.get(best.id, f"unknown_{best.id}") + pct = best.score * 100 + print(f"{img_path.name}: {pct:.1f}% - {label} ({elapsed_ms:.2f} ms)") + else: + print(f"{img_path.name}: keine Erkennung ({elapsed_ms:.2f} ms)") + + avg_ms = sum(inference_times) / len(inference_times) + print(f"\n--- Durchschnittliche Inferenzzeit: {avg_ms:.2f} ms " + f"(ueber {len(inference_times)} Bilder) ---") + + +if __name__ == "__main__": + main() diff --git a/convert_dataset.py b/convert_dataset.py new file mode 100644 index 00000000..9b84b070 --- /dev/null +++ b/convert_dataset.py @@ -0,0 +1,133 @@ +import os +import json +import random +import re +import tensorflow as tf #v2.11 +from PIL import Image +import io + +# Konfiguration +DATASET_DIR = 'dataset' +LABEL_MAP_PATH = 'label_map.pbtxt' +OUTPUT_TRAIN = 'dataset/train.record' +OUTPUT_VAL = 'dataset/val.record' + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{name: id}`` dict.""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[name_match.group(1)] = int(id_match.group(1)) + return label_map + +def create_tf_example(data_item, label_map): + # Pfad zum Bild auflösen (URL zu lokalem Pfad) + # Beispiel: http://127.0.0.1:1000/black/frame_0000.png -> dataset/black/frame_0000.png + url = data_item['data']['image'] + path_parts = url.split('/')[-2:] # Nimmt "black/frame_0000.png" + img_path = os.path.join(DATASET_DIR, *path_parts) + + if not os.path.exists(img_path): + print(f"Warnung: Bild nicht gefunden: {img_path}") + return None + + # Bild laden für Dimensionen und Daten + with tf.io.gfile.GFile(img_path, 'rb') as fid: + encoded_jpg = fid.read() + + image = Image.open(io.BytesIO(encoded_jpg)) + width, height = image.size + filename = os.path.basename(img_path).encode('utf8') + image_format = b'png' # Deine Bilder sind .png + + xmins = [] + xmaxs = [] + ymins = [] + ymaxs = [] + classes_text = [] + classes = [] + + # Bounding Boxes aus "predictions" oder "annotations" lesen + results = [] + if 'annotations' in data_item and data_item['annotations']: + results = data_item['annotations'][0]['result'] + elif 'predictions' in data_item and data_item['predictions']: + results = data_item['predictions'][0]['result'] + + for res in results: + if res['type'] != 'rectanglelabels': + continue + + val = res['value'] + label = val['rectanglelabels'][0] + + # Label Studio nutzt Prozentwerte (0-100) + # Für TFRecord brauchen wir normalisierte Werte (0.0-1.0) + xmin = val['x'] / 100.0 + ymin = val['y'] / 100.0 + xmax = (val['x'] + val['width']) / 100.0 + ymax = (val['y'] + val['height']) / 100.0 + + xmins.append(xmin) + xmaxs.append(xmax) + ymins.append(ymin) + ymaxs.append(ymax) + classes_text.append(label.encode('utf8')) + classes.append(label_map[label]) + + tf_example = tf.train.Example(features=tf.train.Features(feature={ + 'image/height': tf.train.Feature(int64_list=tf.train.Int64List(value=[height])), + 'image/width': tf.train.Feature(int64_list=tf.train.Int64List(value=[width])), + 'image/filename': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + 'image/source_id': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + 'image/encoded': tf.train.Feature(bytes_list=tf.train.BytesList(value=[encoded_jpg])), + 'image/format': tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_format])), + 'image/object/bbox/xmin': tf.train.Feature(float_list=tf.train.FloatList(value=xmins)), + 'image/object/bbox/xmax': tf.train.Feature(float_list=tf.train.FloatList(value=xmaxs)), + 'image/object/bbox/ymin': tf.train.Feature(float_list=tf.train.FloatList(value=ymins)), + 'image/object/bbox/ymax': tf.train.Feature(float_list=tf.train.FloatList(value=ymaxs)), + 'image/object/class/text': tf.train.Feature(bytes_list=tf.train.BytesList(value=classes_text)), + 'image/object/class/label': tf.train.Feature(int64_list=tf.train.Int64List(value=classes)), + })) + return tf_example + +def main(): + label_map = parse_label_map(LABEL_MAP_PATH) + if not label_map: + raise SystemExit(f"No labels found in {LABEL_MAP_PATH}") + json_files = [f'dataset-{name}.json' for name in sorted(label_map.keys())] + + all_items = [] + for json_file in json_files: + path = os.path.join(DATASET_DIR, json_file) + if not os.path.exists(path): + print(f"Warning: {path} not found, skipping.") + continue + with open(path, 'r') as f: + all_items.extend(json.load(f)) + + random.shuffle(all_items) + + # 90% Training, 10% Validierung + split = int(0.9 * len(all_items)) + train_items = all_items[:split] + val_items = all_items[split:] + + for output_file, items in [(OUTPUT_TRAIN, train_items), (OUTPUT_VAL, val_items)]: + writer = tf.io.TFRecordWriter(output_file) + count = 0 + for item in items: + example = create_tf_example(item, label_map) + if example: + writer.write(example.SerializeToString()) + count += 1 + writer.close() + print(f"Erfolgreich {count} Beispiele in {output_file} geschrieben.") + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/create_tfrecords.py b/create_tfrecords.py new file mode 100644 index 00000000..fb581e20 --- /dev/null +++ b/create_tfrecords.py @@ -0,0 +1,133 @@ +import os +import json +import random +import re +import tensorflow as tf +from PIL import Image +import io + +# Konfiguration +DATASET_DIR = 'dataset' +LABEL_MAP_PATH = 'label_map.pbtxt' +OUTPUT_TRAIN = 'dataset/train.record' +OUTPUT_VAL = 'dataset/val.record' + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{name: id}`` dict.""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[name_match.group(1)] = int(id_match.group(1)) + return label_map + +def create_tf_example(data_item, label_map): + # Pfad zum Bild auflösen (URL zu lokalem Pfad) + # Beispiel: http://127.0.0.1:1000/black/frame_0000.png -> dataset/black/frame_0000.png + url = data_item['data']['image'] + path_parts = url.split('/')[-2:] # Nimmt "black/frame_0000.png" + img_path = os.path.join(DATASET_DIR, *path_parts) + + if not os.path.exists(img_path): + print(f"Warnung: Bild nicht gefunden: {img_path}") + return None + + # Bild laden für Dimensionen und Daten + with tf.io.gfile.GFile(img_path, 'rb') as fid: + encoded_jpg = fid.read() + + image = Image.open(io.BytesIO(encoded_jpg)) + width, height = image.size + filename = os.path.basename(img_path).encode('utf8') + image_format = b'png' # Deine Bilder sind .png + + xmins = [] + xmaxs = [] + ymins = [] + ymaxs = [] + classes_text = [] + classes = [] + + # Bounding Boxes aus "predictions" oder "annotations" lesen + results = [] + if 'annotations' in data_item and data_item['annotations']: + results = data_item['annotations'][0]['result'] + elif 'predictions' in data_item and data_item['predictions']: + results = data_item['predictions'][0]['result'] + + for res in results: + if res['type'] != 'rectanglelabels': + continue + + val = res['value'] + label = val['rectanglelabels'][0] + + # Label Studio nutzt Prozentwerte (0-100) + # Für TFRecord brauchen wir normalisierte Werte (0.0-1.0) + xmin = val['x'] / 100.0 + ymin = val['y'] / 100.0 + xmax = (val['x'] + val['width']) / 100.0 + ymax = (val['y'] + val['height']) / 100.0 + + xmins.append(xmin) + xmaxs.append(xmax) + ymins.append(ymin) + ymaxs.append(ymax) + classes_text.append(label.encode('utf8')) + classes.append(label_map[label]) + + tf_example = tf.train.Example(features=tf.train.Features(feature={ + 'image/height': tf.train.Feature(int64_list=tf.train.Int64List(value=[height])), + 'image/width': tf.train.Feature(int64_list=tf.train.Int64List(value=[width])), + 'image/filename': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + 'image/source_id': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + 'image/encoded': tf.train.Feature(bytes_list=tf.train.BytesList(value=[encoded_jpg])), + 'image/format': tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_format])), + 'image/object/bbox/xmin': tf.train.Feature(float_list=tf.train.FloatList(value=xmins)), + 'image/object/bbox/xmax': tf.train.Feature(float_list=tf.train.FloatList(value=xmaxs)), + 'image/object/bbox/ymin': tf.train.Feature(float_list=tf.train.FloatList(value=ymins)), + 'image/object/bbox/ymax': tf.train.Feature(float_list=tf.train.FloatList(value=ymaxs)), + 'image/object/class/text': tf.train.Feature(bytes_list=tf.train.BytesList(value=classes_text)), + 'image/object/class/label': tf.train.Feature(int64_list=tf.train.Int64List(value=classes)), + })) + return tf_example + +def main(): + label_map = parse_label_map(LABEL_MAP_PATH) + if not label_map: + raise SystemExit(f"No labels found in {LABEL_MAP_PATH}") + json_files = [f'dataset-{name}.json' for name in sorted(label_map.keys())] + + all_items = [] + for json_file in json_files: + path = os.path.join(DATASET_DIR, json_file) + if not os.path.exists(path): + print(f"Warning: {path} not found, skipping.") + continue + with open(path, 'r') as f: + all_items.extend(json.load(f)) + + random.shuffle(all_items) + + # 90% Training, 10% Validierung + split = int(0.9 * len(all_items)) + train_items = all_items[:split] + val_items = all_items[split:] + + for output_file, items in [(OUTPUT_TRAIN, train_items), (OUTPUT_VAL, val_items)]: + writer = tf.io.TFRecordWriter(output_file) + count = 0 + for item in items: + example = create_tf_example(item, label_map) + if example: + writer.write(example.SerializeToString()) + count += 1 + writer.close() + print(f"Erfolgreich {count} Beispiele in {output_file} geschrieben.") + +if __name__ == '__main__': + main() diff --git a/create_unlabeled_dataset.py b/create_unlabeled_dataset.py new file mode 100644 index 00000000..fd557dcb --- /dev/null +++ b/create_unlabeled_dataset.py @@ -0,0 +1,223 @@ +import threading +import time +from typing import List +import os +import glob +import re + +import numpy as np +import cv2 + +from actuator.elevator_motor import ElevatorMotorController +from actuator.led_neopixel import NeoPixelController +from sensor.camera import Camera + +LABEL_MAP_PATH = "label_map.pbtxt" + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{name: id}`` dict.""" + if not os.path.exists(path): + return {} + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[name_match.group(1)] = int(id_match.group(1)) + return label_map + + +def add_label_to_map(path, label_name): + """Add a label to label_map.pbtxt if it doesn't exist yet. Returns the assigned ID.""" + label_map = parse_label_map(path) + if label_name in label_map: + print(f"Label '{label_name}' already exists in {path} with id {label_map[label_name]}") + return label_map[label_name] + + next_id = max(label_map.values(), default=0) + 1 + with open(path, "a") as f: + f.write(f"\nitem {{\n id: {next_id}\n name: '{label_name}'\n}}\n") + print(f"Added label '{label_name}' with id {next_id} to {path}") + return next_id + + +def run_motor_until_stopped( + motor: ElevatorMotorController, + stop_event: threading.Event, + pause_seconds: float = 0.002, + steps_per_batch: int = 200, +) -> None: + """Continuously rotate the elevator motor until stop_event is set.""" + try: + motor.enable() + while not stop_event.is_set(): + motor.rotate(steps=steps_per_batch, pause_seconds=pause_seconds) + except Exception as exc: + print(f"Motor thread error: {exc}") + +def contains_marble(frame_bayer, crop_size=300, min_area=2000, max_area=100000, thresh_val=100): + """ + Detects if a marble is present in the center of the given image. + + Args: + frame_bayer (np.ndarray): The input bayer image. + crop_size (int): Size of the center square crop. + min_area (int): Minimum contour area to be considered a marble. + max_area (int): Maximum contour area to be considered a marble. + thresh_val (int): Threshold value for binarization. + + Returns: + bool: True if a marble is detected, False otherwise. + """ + # 1. Check Image + if frame_bayer is None: + print("Warning: Could not load image") + return False + + height, width = frame_bayer.shape[:2] + + # 2. Fast Cropping + start_x = max(0, width // 2 - crop_size // 2) + start_y = max(0, height // 2 - crop_size // 2) + + # Slice the numpy array + center_crop = frame_bayer[start_y:start_y+crop_size, start_x:start_x+crop_size] + + # 3. Optimized Processing (Grayscale -> Blur -> Threshold -> Invert) + frame_gray = cv2.cvtColor(center_crop, cv2.COLOR_BAYER_RG2GRAY) + blurred = cv2.GaussianBlur(frame_gray, (5, 5), 0) + + _, thresh = cv2.threshold(blurred, thresh_val, 255, cv2.THRESH_BINARY) + inv_thresh = cv2.bitwise_not(thresh) + + # 4. Contour Detection + contours, _ = cv2.findContours(inv_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + # 5. Validation + # If any contour matches the area criteria, a marble is present + for c in contours: + area = cv2.contourArea(c) + if min_area <= area <= max_area: + return True + + return False + + +def main() -> None: + + # Ask the label name + label_name = input("Enter the label name: ").strip().lower() + if not label_name: + print("Label name cannot be empty.") + return + + # Add label to label_map.pbtxt (skips if already present) + add_label_to_map(LABEL_MAP_PATH, label_name) + + # Ask how long it should run + capture_seconds = int(input("Enter the capture time in seconds: ")) + + # Create label folder + out_dir = os.path.join("dataset", label_name) + os.makedirs(out_dir, exist_ok=True) + + led_color = (255, 255, 255) + + leds = NeoPixelController() + motor = ElevatorMotorController() + camera = Camera() + + stop_motor_event = threading.Event() + motor_thread = threading.Thread( + target=run_motor_until_stopped, + args=(motor, stop_motor_event), + daemon=True, + ) + + frames_to_save: List[np.ndarray] = [] + frames_processed = 0 + + try: + print("Turning LEDs on...") + leds.set_color(led_color) + + print("Starting elevator motor...") + motor_thread.start() + + print(f"Capturing and processing images live for {capture_seconds} seconds...") + camera.print_camera_info() + camera.unlock_max_framerate() + + # Initialize background subtractor BEFORE the loop + backSub = cv2.createBackgroundSubtractorMOG2(history=20, varThreshold=50, detectShadows=False) + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) + + # Consume the camera stream live + for frame_ref in camera.stream_for_duration(capture_seconds): + frames_processed += 1 + + # analyse image with contains_marble + if contains_marble(frame_ref): + frames_to_save.append(frame_ref.copy()) + print(f"Marble detected in frame {frames_processed}. Total kept frames: {len(frames_to_save)}") + + + except KeyboardInterrupt: + print("Interrupted by user.") + + finally: + print("Stopping elevator motor...") + stop_motor_event.set() + motor_thread.join(timeout=2.0) + motor.cleanup() + + print("Turning LEDs off...") + time.sleep(1) + leds.turn_off() + + print("Releasing camera...") + camera.release_camera() + + # --- Save only centered frames to disk --- + if frames_to_save: + # 1. Find all existing frame images in the output folder + search_pattern = os.path.join(out_dir, "frame_*.png") + existing_files = glob.glob(search_pattern) + + # 2. Extract the numbers and find the highest one + highest_idx = -1 + for filepath in existing_files: + filename = os.path.basename(filepath) # e.g., 'frame_0042.png' + try: + # Split by '_' and '.' to extract '0042', then convert to integer + num = int(filename.split('_')[1].split('.')[0]) + if num > highest_idx: + highest_idx = num + except (IndexError, ValueError): + # Ignore any files that happen to match the glob but don't parse cleanly + pass + + # 3. Set the new starting index (if no files exist, highest_idx is -1, so start_idx becomes 0) + start_idx = highest_idx + 1 + + print(f"Writing kept frames to disk, continuing from frame_{start_idx:04d}...") + + # 4. Use the 'start' argument in enumerate to offset the index + for idx, frame_bayer in enumerate(frames_to_save, start=start_idx): + # Convert Bayer to BGR right before saving to disk + frame_bgr = cv2.cvtColor(frame_bayer, cv2.COLOR_BAYER_BG2BGR) + + # Create the filename using the offset index + filename = os.path.join(out_dir, f"frame_{idx:04d}.png") + cv2.imwrite(filename, frame_bgr) + + print(f"Total centered frames successfully saved: {len(frames_to_save)}") + else: + print("No frames met the condition. Nothing saved.") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/diagnoseserial.py b/diagnoseserial.py deleted file mode 100644 index b6c1d108..00000000 --- a/diagnoseserial.py +++ /dev/null @@ -1,34 +0,0 @@ -import serial -import sys -import argparse -import time - -# Argumente parsen -parser = argparse.ArgumentParser(description="Sendet Text an Arduino über die serielle Schnittstelle.") -parser.add_argument("-t", "--text", type=str, required=True, help="Text, der an den Arduino gesendet werden soll.") -args = parser.parse_args() - -# Serielle Verbindung konfigurieren (Passe die Portnummer und Baudrate an, falls notwendig) -try: - ser = serial.Serial('/dev/serial0', 9600, timeout=1) # '/dev/serial0' ist der Standardport für Raspberry Pi. - time.sleep(2) # Warte, bis die serielle Verbindung initialisiert ist. -except serial.SerialException as e: - print(f"Fehler beim Öffnen der seriellen Verbindung: {e}") - sys.exit(1) - -# Text senden -try: - text = args.text - ser.write(text.encode('utf-8')) - print(f"Gesendeter Text: {text}") - - # Warten und Antwort lesen - time.sleep(1) - if ser.in_waiting > 0: - response = ser.readline().decode('utf-8').strip() - print(f"Antwort vom Arduino: {response}") - else: - print("Keine Antwort vom Arduino erhalten.") - -finally: - ser.close() diff --git a/display.py b/display.py new file mode 100644 index 00000000..5f2d95f8 --- /dev/null +++ b/display.py @@ -0,0 +1,205 @@ +"""Marble Sorter – Raspberry Pi display frontend (pure Python / tkinter). + +Runs in its own daemon thread. Call ``update_detection()`` whenever a marble +is classified. The last detected marble stays on screen until the next one +arrives. The window is fullscreen and uses only tkinter + Pillow. +""" + +import glob +import os +import queue +import threading +import tkinter as tk +from typing import Optional, Tuple + +import cv2 +import numpy as np +from PIL import Image, ImageTk + + +# --------------------------------------------------------------------------- +# Colour map: label → BGR border colour + hex label colour +# --------------------------------------------------------------------------- +_COLOUR_MAP: dict[str, Tuple[Tuple[int, int, int], str]] = { + "red": ((0, 0, 220), "#FF3333"), + "green": ((0, 200, 0), "#33FF33"), +} +_DEFAULT_BGR = (0, 200, 255) +_DEFAULT_HEX = "#FFDD00" + +_BORDER_THICKNESS = 8 # px, border drawn around the image + + +class MarbleDisplay: + """Fullscreen tkinter display for the marble sorter. + + Only ``update_detection()`` and ``close()`` are needed. + All Tk calls happen inside the dedicated daemon thread – the sorting + loop is never blocked and never touches Tk objects directly. + """ + + def __init__(self, preview_width: int = 640, preview_height: int = 480) -> None: + self._pw = preview_width + self._ph = preview_height + self._queue: queue.Queue = queue.Queue(maxsize=2) + self._thread = threading.Thread(target=self._run, daemon=True) + self._thread.start() + + # ------------------------------------------------------------------ + # Public API + # ------------------------------------------------------------------ + + def update_detection( + self, + frame_bgr: np.ndarray, + label: str, + confidence: float, + bbox: Optional[Tuple[int, int, int, int]] = None, + ) -> None: + """Push a new detection to the display. + + Args: + frame_bgr: OpenCV BGR image. + label: Class label, e.g. ``"red"`` or ``"green"``. + confidence: Confidence 0–100. + bbox: Optional ``(x, y, w, h)`` bounding box in image + coordinates. When *None* a border wraps the whole image. + """ + self._post({ + "state": "detection", + "frame": frame_bgr.copy(), + "label": label, + "confidence": confidence, + "bbox": bbox, + }) + + def close(self) -> None: + """Destroy the window (called on shutdown).""" + self._post({"state": "quit"}) + + # ------------------------------------------------------------------ + # Internal + # ------------------------------------------------------------------ + + def _post(self, msg: dict) -> None: + try: + self._queue.put_nowait(msg) + except queue.Full: + try: + self._queue.get_nowait() + except queue.Empty: + pass + try: + self._queue.put_nowait(msg) + except queue.Full: + pass + + def _run(self) -> None: + if not os.environ.get("DISPLAY"): + os.environ["DISPLAY"] = ":0" + if not os.environ.get("XAUTHORITY"): + candidates = ( + glob.glob("/home/*/.Xauthority") + + glob.glob("/run/user/*/gdm/Xauthority") + + ["/root/.Xauthority"] + ) + for path in candidates: + if os.path.exists(path): + os.environ["XAUTHORITY"] = path + break + + root = tk.Tk() + root.title("Marble Sorter") + root.configure(bg="black") + root.attributes("-fullscreen", True) + root.bind("", lambda _e: root.attributes("-fullscreen", False)) + + # ── Layout ──────────────────────────────────────────────────── + # Top: label + confidence banner + # Center: marble image + # Bottom: running counters + + banner = tk.Label( + root, + text="Waiting for marble…", + font=("DejaVu Sans", 32, "bold"), + fg="white", + bg="black", + pady=12, + ) + banner.pack(fill="x") + + canvas = tk.Canvas( + root, + width=self._pw, + height=self._ph, + bg="#111111", + highlightthickness=0, + ) + canvas.pack(expand=True) + + stats_label = tk.Label( + root, + text="Red: 0 Green: 0 Other: 0", + font=("DejaVu Sans", 18), + fg="#AAAAAA", + bg="black", + pady=8, + ) + stats_label.pack(fill="x", side="bottom") + + _img_ref: list = [None] + _counts: dict = {"red": 0, "green": 0, "other": 0} + + def _make_photo(frame_bgr: np.ndarray, bgr_col: Tuple[int, int, int], + bbox: Optional[Tuple[int, int, int, int]]) -> ImageTk.PhotoImage: + img = frame_bgr.copy() + t = _BORDER_THICKNESS + if bbox is not None: + x, y, w, h = bbox + cv2.rectangle(img, (x, y), (x + w, y + h), bgr_col, t) + else: + cv2.rectangle(img, (t, t), (img.shape[1] - t, img.shape[0] - t), bgr_col, t * 2) + img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + pil = Image.fromarray(img_rgb).resize((self._pw, self._ph), Image.LANCZOS) + return ImageTk.PhotoImage(pil) + + def _poll() -> None: + try: + msg = self._queue.get_nowait() + except queue.Empty: + root.after(50, _poll) + return + + if msg["state"] == "quit": + root.destroy() + return + + if msg["state"] == "detection": + label = msg["label"] + confidence = msg["confidence"] + frame = msg["frame"] + bbox = msg.get("bbox") + + bgr_col, hex_col = _COLOUR_MAP.get(label, (_DEFAULT_BGR, _DEFAULT_HEX)) + + photo = _make_photo(frame, bgr_col, bbox) + canvas.delete("all") + canvas.create_image(self._pw // 2, self._ph // 2, image=photo, anchor="center") + _img_ref[0] = photo + + banner.config( + text=f"Detected: {label.upper()} {confidence:.1f}%", + fg=hex_col, + ) + + key = label if label in _counts else "other" + _counts[key] += 1 + stats_label.config( + text=f"Red: {_counts['red']} Green: {_counts['green']} Other: {_counts['other']}" + ) + + root.after(50, _poll) + + root.after(50, _poll) + root.mainloop() diff --git a/docker/build_tfrecords.py b/docker/build_tfrecords.py new file mode 100755 index 00000000..d5eebc1b --- /dev/null +++ b/docker/build_tfrecords.py @@ -0,0 +1,143 @@ +"""Convert Label Studio JSON exports to TFRecord files. + +This is a parameterized version of `convert_dataset.py` that reads its +inputs and writes its outputs to paths supplied on the command line, so +it is suitable for use inside the training Docker image where the +dataset directory and the output directory are mounted volumes. +""" + +import argparse +import io +import json +import os +import random +import re +import sys + +import tensorflow as tf +from PIL import Image + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{name: id}`` dict.""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[name_match.group(1)] = int(id_match.group(1)) + return label_map + + +def create_tf_example(data_item, dataset_dir, label_map): + url = data_item["data"]["image"] + # e.g. http://127.0.0.1:1000/black/frame_0000.png -> /black/frame_0000.png + path_parts = url.split("/")[-2:] + img_path = os.path.join(dataset_dir, *path_parts) + + if not os.path.exists(img_path): + print(f"Warning: image not found: {img_path}", file=sys.stderr) + return None + + with tf.io.gfile.GFile(img_path, "rb") as fid: + encoded = fid.read() + + image = Image.open(io.BytesIO(encoded)) + width, height = image.size + filename = os.path.basename(img_path).encode("utf8") + image_format = b"png" + + xmins, xmaxs, ymins, ymaxs = [], [], [], [] + classes_text, classes = [], [] + + results = [] + if data_item.get("annotations"): + results = data_item["annotations"][0]["result"] + elif data_item.get("predictions"): + results = data_item["predictions"][0]["result"] + + for res in results: + if res["type"] != "rectanglelabels": + continue + val = res["value"] + label = val["rectanglelabels"][0] + xmins.append(val["x"] / 100.0) + ymins.append(val["y"] / 100.0) + xmaxs.append((val["x"] + val["width"]) / 100.0) + ymaxs.append((val["y"] + val["height"]) / 100.0) + classes_text.append(label.encode("utf8")) + classes.append(label_map[label]) + + return tf.train.Example(features=tf.train.Features(feature={ + "image/height": tf.train.Feature(int64_list=tf.train.Int64List(value=[height])), + "image/width": tf.train.Feature(int64_list=tf.train.Int64List(value=[width])), + "image/filename": tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + "image/source_id": tf.train.Feature(bytes_list=tf.train.BytesList(value=[filename])), + "image/encoded": tf.train.Feature(bytes_list=tf.train.BytesList(value=[encoded])), + "image/format": tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_format])), + "image/object/bbox/xmin": tf.train.Feature(float_list=tf.train.FloatList(value=xmins)), + "image/object/bbox/xmax": tf.train.Feature(float_list=tf.train.FloatList(value=xmaxs)), + "image/object/bbox/ymin": tf.train.Feature(float_list=tf.train.FloatList(value=ymins)), + "image/object/bbox/ymax": tf.train.Feature(float_list=tf.train.FloatList(value=ymaxs)), + "image/object/class/text": tf.train.Feature(bytes_list=tf.train.BytesList(value=classes_text)), + "image/object/class/label": tf.train.Feature(int64_list=tf.train.Int64List(value=classes)), + })) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--dataset-dir", required=True, + help="Directory containing dataset-*.json and the per-color image folders.") + parser.add_argument("--label-map", required=True, + help="Path to label_map.pbtxt.") + parser.add_argument("--train-out", required=True, help="Path of train.record to write.") + parser.add_argument("--val-out", required=True, help="Path of val.record to write.") + parser.add_argument("--val-split", type=float, default=0.1, + help="Fraction of items used for validation (default: 0.1).") + parser.add_argument("--seed", type=int, default=42) + args = parser.parse_args() + + label_map = parse_label_map(args.label_map) + if not label_map: + sys.exit(f"No labels found in {args.label_map}") + print(f"Labels from {args.label_map}: {label_map}") + + json_files = [f"dataset-{name}.json" for name in sorted(label_map.keys())] + + random.seed(args.seed) + + all_items = [] + for json_file in json_files: + path = os.path.join(args.dataset_dir, json_file) + if not os.path.exists(path): + print(f"Warning: {path} not found, skipping.", file=sys.stderr) + continue + with open(path, "r") as f: + all_items.extend(json.load(f)) + + if not all_items: + sys.exit(f"No items found in {args.dataset_dir}. " + f"Expected one or more of: {json_files}") + + random.shuffle(all_items) + split = int((1.0 - args.val_split) * len(all_items)) + train_items = all_items[:split] + val_items = all_items[split:] + + for output_file, items in [(args.train_out, train_items), (args.val_out, val_items)]: + os.makedirs(os.path.dirname(output_file), exist_ok=True) + writer = tf.io.TFRecordWriter(output_file) + count = 0 + for item in items: + example = create_tf_example(item, args.dataset_dir, label_map) + if example is not None: + writer.write(example.SerializeToString()) + count += 1 + writer.close() + print(f"Wrote {count} examples to {output_file}") + + +if __name__ == "__main__": + main() diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh new file mode 100755 index 00000000..20bccafa --- /dev/null +++ b/docker/entrypoint.sh @@ -0,0 +1,72 @@ +#!/usr/bin/env bash +# End-to-end pipeline: TFRecords -> training -> TFLite export -> INT8 -> Edge TPU. +# Inputs (mounted volumes): +# /dataset -- the labeled dataset (dataset-*.json + per-color image folders) +# Outputs (mounted volume): +# /my-models -- all artifacts, including the final marbel_coral.tflite +set -euo pipefail + +DATASET_DIR="${DATASET_DIR:-/dataset}" +OUT_DIR="${OUT_DIR:-/my-models}" +ASSETS=/opt/sorter +OD_API=/opt/models + +if [[ ! -d "$DATASET_DIR" ]]; then + echo "ERROR: dataset directory $DATASET_DIR not found. Mount it with -v :/dataset" >&2 + exit 1 +fi +mkdir -p "$OUT_DIR" + +RECORDS_DIR="$OUT_DIR/records" +CKPT_DIR="$OUT_DIR/checkpoints" +EXPORT_DIR="$OUT_DIR/tflite_export" +PIPELINE="$OUT_DIR/pipeline.config" + +mkdir -p "$RECORDS_DIR" "$CKPT_DIR" "$EXPORT_DIR" + +echo "==> [1/6] Building TFRecords from $DATASET_DIR" +python3 "$ASSETS/build_tfrecords.py" \ + --dataset-dir "$DATASET_DIR" \ + --label-map "$ASSETS/label_map.pbtxt" \ + --train-out "$RECORDS_DIR/train.record" \ + --val-out "$RECORDS_DIR/val.record" + +echo "==> [2/6] Rendering pipeline.config with container paths" +sed \ + -e "s|dataset/train\.record|$RECORDS_DIR/train.record|g" \ + -e "s|dataset/val\.record|$RECORDS_DIR/val.record|g" \ + -e "s|label_map\.pbtxt|$ASSETS/label_map.pbtxt|g" \ + -e "s|models/pretrained/ssd_mobilenet_v2_320x320_coco17_tpu-8/checkpoint/ckpt-0|$ASSETS/pretrained/ssd_mobilenet_v2_320x320_coco17_tpu-8/checkpoint/ckpt-0|g" \ + "$ASSETS/pipeline.config" > "$PIPELINE" + +echo "==> [3/6] Training (this is the long step)" +python3 "$OD_API/research/object_detection/model_main_tf2.py" \ + --pipeline_config_path="$PIPELINE" \ + --model_dir="$CKPT_DIR" \ + --alsologtostderr + +echo "==> [4/6] Exporting TFLite-friendly graph" +python3 "$OD_API/research/object_detection/export_tflite_graph_tf2.py" \ + --pipeline_config_path "$PIPELINE" \ + --trained_checkpoint_dir "$CKPT_DIR" \ + --output_directory "$EXPORT_DIR" + +echo "==> [5/6] Quantizing to INT8 TFLite" +python3 "$ASSETS/quantize.py" \ + --saved-model "$EXPORT_DIR/saved_model" \ + --dataset-dir "$DATASET_DIR" \ + --out "$OUT_DIR/ssd_mobilenet_v2_quant.tflite" + +echo "==> [6/6] Compiling for Edge TPU" +edgetpu_compiler -o "$OUT_DIR" "$OUT_DIR/ssd_mobilenet_v2_quant.tflite" + +cp "$OUT_DIR/ssd_mobilenet_v2_quant_edgetpu.tflite" "$OUT_DIR/marbel_coral.tflite" +awk '{gsub(/\r/,"")} /id:/{n=$2} /name:/{gsub(/\047/,"",$2); print n, $2}' "$ASSETS/label_map.pbtxt" > "$OUT_DIR/labels.txt" + +echo +echo "Done. Final artifacts in $OUT_DIR:" +echo " - marbel_coral.tflite (Edge TPU model, use this with test_coral.py / main.py)" +echo " - ssd_mobilenet_v2_quant.tflite (INT8 CPU model)" +echo " - tflite_export/saved_model/ (pre-quantization SavedModel)" +echo " - checkpoints/ (training checkpoints + tensorboard events)" +echo " - labels.txt (id-to-name map)" diff --git a/docker/quantize.py b/docker/quantize.py new file mode 100755 index 00000000..bbbd88a3 --- /dev/null +++ b/docker/quantize.py @@ -0,0 +1,58 @@ +"""Convert a SavedModel to an INT8-quantized TFLite model. + +Uses a representative dataset sampled from the per-color image folders so +the resulting graph is suitable for the Edge TPU compiler. +""" + +import argparse +from pathlib import Path + +import tensorflow as tf + + +def make_representative_dataset(dataset_dir: Path, num_samples: int): + image_files = sorted(dataset_dir.rglob("*.png")) + if not image_files: + raise SystemExit(f"No PNG images found under {dataset_dir}") + image_files = image_files[:num_samples] + + def gen(): + for img_path in image_files: + img = tf.io.read_file(str(img_path)) + img = tf.image.decode_image(img, channels=3, expand_animations=False) + img = tf.image.resize(img, [300, 300]) + img = tf.cast(img, tf.float32) / 127.5 - 1.0 # MobileNet V2 scaling + yield [tf.expand_dims(img, axis=0)] + + return gen + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--saved-model", required=True, + help="Path to the saved_model/ directory produced by export_tflite_graph_tf2.py.") + parser.add_argument("--dataset-dir", required=True, + help="Directory containing the calibration images (PNGs are sampled recursively).") + parser.add_argument("--out", required=True, help="Output .tflite path.") + parser.add_argument("--num-samples", type=int, default=100, + help="Number of images to use for calibration (default: 100).") + args = parser.parse_args() + + converter = tf.lite.TFLiteConverter.from_saved_model(args.saved_model) + converter.optimizations = [tf.lite.Optimize.DEFAULT] + converter.representative_dataset = make_representative_dataset( + Path(args.dataset_dir), args.num_samples + ) + converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8] + converter.inference_input_type = tf.uint8 + converter.inference_output_type = tf.float32 + + tflite_model = converter.convert() + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_bytes(tflite_model) + print(f"Wrote {out}") + + +if __name__ == "__main__": + main() diff --git a/docs/00-build-the-sorter.md b/docs/00-build-the-sorter.md new file mode 100644 index 00000000..5a34bb90 --- /dev/null +++ b/docs/00-build-the-sorter.md @@ -0,0 +1,57 @@ +# Step 0 — Build the Sorter + +> **TODO:** This guide is not yet written. + +## Shopping List + + + +- [ ] Raspberry Pi 4/5 +- [ ] FLIR Machine Vision Camera +- [ ] Coral USB Accelerator +- [ ] Elevator motor +- [ ] Solenoid actuator +- [ ] NeoPixel LED strip +- [ ] Light-beam sensor +- [ ] Power supply +- [ ] Wires, connectors, screws, etc. + +## 3D-Printed Parts + + + +- [ ] Add 3D model files to a `models/` or `stl/` folder +- [ ] Document print settings for each part + +## Sensors & Actuators + + + +- [ ] FLIR camera — model, mounting position +- [ ] Light-beam sensor — wiring, GPIO pin +- [ ] Coral USB Accelerator — USB port + +## Wiring Documentation + + + +- [ ] GPIO pin mapping table +- [ ] Wiring diagram (Fritzing / schematic image) +- [ ] Power distribution layout + +## Assembly Instructions + + + +- [ ] Mount the camera +- [ ] Install the elevator motor +- [ ] Install the solenoid actuator +- [ ] Wire the light-beam sensor +- [ ] Connect the NeoPixel LED strip +- [ ] Final assembly and cable management + +--- + +**Next:** [Step 1 — Raspberry Pi Setup](01-raspberry-pi-setup.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/01-raspberry-pi-setup.md b/docs/01-raspberry-pi-setup.md new file mode 100644 index 00000000..207d6a75 --- /dev/null +++ b/docs/01-raspberry-pi-setup.md @@ -0,0 +1,130 @@ +# Step 1 — Raspberry Pi Setup + +This guide covers everything needed to get the Raspberry Pi ready to run the sorter. + +> **Machine:** Raspberry Pi (Raspbian ARM64) + +### 1.1 Clone the repository + +```bash +git clone https://github.com/ITLab-CC/Sorter +cd Sorter +``` + +## 1.1 Install system dependencies + +```bash +sudo apt update +sudo apt install -y \ + udev \ + ethtool \ + libusb-1.0-0 \ + iproute2 \ + iputils-ping \ + net-tools \ + build-essential \ + libssl-dev \ + zlib1g-dev \ + libbz2-dev \ + libreadline-dev \ + libsqlite3-dev \ + curl \ + git \ + libncursesw5-dev \ + xz-utils \ + tk-dev \ + libxml2-dev \ + libxmlsec1-dev \ + libffi-dev \ + liblzma-dev \ + libgl1 \ + libglib2.0-0 \ + ffmpeg \ + protobuf-compiler \ + libedgetpu1-max +``` + +## 1.2 Install pyenv and Python 3.10 + +```bash +curl https://pyenv.run | bash + +LINE1='export PYENV_ROOT="$HOME/.pyenv"' +LINE2='command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' +LINE3='eval "$(pyenv init -)"' +grep -qF "$LINE1" ~/.bashrc || echo "$LINE1" >> ~/.bashrc +grep -qF "$LINE2" ~/.bashrc || echo "$LINE2" >> ~/.bashrc +grep -qF "$LINE3" ~/.bashrc || echo "$LINE3" >> ~/.bashrc +export PYENV_ROOT="$HOME/.pyenv" +command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH" +eval "$(pyenv init -)" + +pyenv install 3.10.20 +pyenv local 3.10.20 +``` + +## 1.3 Create a virtual environment and install Python packages + +```bash +python3.10 -m venv .venv-3.10 +export SPINNAKER_GENTL64_CTI=/opt/spinnaker/lib/spinnaker-gentl/Spinnaker_GenTL.cti +.venv-3.10/bin/pip install --upgrade pip setuptools wheel +.venv-3.10/bin/pip install -r ./actuator/requirements-3.10.txt +.venv-3.10/bin/pip install -r ./sensor/requirements-3.10.txt +.venv-3.10/bin/pip install -r requirements-3.10.txt +``` + +## 1.4 Install Coral Edge TPU runtime (ARM64) + +```bash +mkdir -p ~/coral-wheels +wget -O ~/coral-wheels/tflite_runtime-2.12.0-cp310-cp310-linux_aarch64.whl \ + "https://github.com/oberluz/pycoral/releases/download/2.12.0/tflite_runtime-2.12.0-cp310-cp310-linux_aarch64.whl" + +wget -O ~/coral-wheels/pycoral-2.12.0-cp310-cp310-linux_aarch64.whl \ + "https://github.com/oberluz/pycoral/releases/download/2.12.0/pycoral-2.12.0-cp310-cp310-linux_aarch64.whl" + +.venv-3.10/bin/pip install ~/coral-wheels/tflite_runtime-2.12.0-cp310-cp310-linux_aarch64.whl +.venv-3.10/bin/pip install ~/coral-wheels/pycoral-2.12.0-cp310-cp310-linux_aarch64.whl +``` + +## 1.5 Install the Spinnaker SDK (camera driver) + +Download both the SDK and the Python bindings from the [Spinnaker SDK download page](https://www.teledynevisionsolutions.com/support/support-center/software-firmware-downloads/iis/spinnaker-sdk-download/spinnaker-sdk--download-files/?pn=Spinnaker+SDK&vn=Spinnaker+SDK) and place them in the `sensor/` folder. + +You need these two files (ARM64): + +- `spinnaker-4.3.0.189-Ubuntu22.04-arm64-pkg.tar.gz` (Linux Ubuntu 22.04 --ARM64) +- `spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.tar.gz` (Linux Ubuntu 22.04 -- ARM64 Python 3.10) + +### Extract and install the SDK + +```bash +mkdir -p sensor/spinnaker_sdk sensor/spinnaker_python +tar -xzvf sensor/spinnaker-4.3.0.189-Ubuntu22.04-arm64-pkg.tar.gz -C sensor/spinnaker_sdk +tar -xzvf sensor/spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.tar.gz -C sensor/spinnaker_python + +cd sensor/spinnaker_sdk/spinnaker-4.3.0.189-arm64/ +./install_spinnaker_arm.sh +``` + +### Install the Python bindings + +```bash +cd ../../spinnaker_python +../../.venv-3.10/bin/pip install spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.whl +``` + +### Clean up + +```bash +cd ../.. +rm -rf sensor/spinnaker_python sensor/spinnaker_sdk +``` + +--- + +**Previous:** [Step 0 — Build the Sorter](00-build-the-sorter.md) +**Next:** [Step 2 — Training PC Setup](02-training-pc-setup.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/02-training-pc-setup.md b/docs/02-training-pc-setup.md new file mode 100644 index 00000000..a9fd601a --- /dev/null +++ b/docs/02-training-pc-setup.md @@ -0,0 +1,126 @@ +# Step 2 — Training PC Setup + +This guide sets up the PC you will use to train the AI model. You only need to do this once. + +> **Machine:** PC with an NVIDIA GPU (Linux recommended) + +## Requirements +Setup a PC which will be used for training the AI model. It should have an NVIDIA GPU and be running Linux. We tested this setup using ubuntu 24. It is also required to install the NVIDIA driver in a advance. + +## 2.1 Clone the repository + +```bash +git clone https://github.com/ITLab-CC/Sorter +cd Sorter +``` + +## 2.2 Install Docker + +```bash +curl -sSL https://get.docker.com | sudo sh +``` + +## 2.3 Install the NVIDIA Container Toolkit + +This lets Docker containers access the GPU. + +```bash +sudo apt-get update && sudo apt-get install -y --no-install-recommends \ + ca-certificates \ + curl \ + gnupg2 + +curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \ + && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \ + sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \ + sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list + +sudo apt-get update + +export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.19.0-1 +sudo apt-get install -y \ + nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \ + nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \ + libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \ + libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION} + +sudo nvidia-ctk runtime configure --runtime=docker +sudo systemctl restart docker +``` + +## 2.4 Build the training Docker image + +```bash +sudo docker build -f Dockerfile.train -t sorter-train:latest . +``` + +This image contains TensorFlow 2.11, the TF Object Detection API, the pretrained SSD MobileNet V2 checkpoint, and the Edge TPU compiler. You only need to build it once. + +## 2.5 (Optional) Setup for test your AI model on a x86_64 PC (later) + +If you also want to run inference tests on the training PC (e.g. with a Coral USB Accelerator plugged in): + +```bash +sudo apt update +sudo apt install -y \ + udev \ + ethtool \ + libusb-1.0-0 \ + iproute2 \ + iputils-ping \ + net-tools \ + build-essential \ + libssl-dev \ + zlib1g-dev \ + libbz2-dev \ + libreadline-dev \ + libsqlite3-dev \ + curl \ + git \ + libncursesw5-dev \ + xz-utils \ + tk-dev \ + libxml2-dev \ + libxmlsec1-dev \ + libffi-dev \ + liblzma-dev \ + libgl1 \ + libglib2.0-0 \ + ffmpeg \ + protobuf-compiler \ + libedgetpu1-max + +curl https://pyenv.run | bash + +LINE1='export PYENV_ROOT="$HOME/.pyenv"' +LINE2='command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' +LINE3='eval "$(pyenv init -)"' +grep -qF "$LINE1" ~/.bashrc || echo "$LINE1" >> ~/.bashrc +grep -qF "$LINE2" ~/.bashrc || echo "$LINE2" >> ~/.bashrc +grep -qF "$LINE3" ~/.bashrc || echo "$LINE3" >> ~/.bashrc +export PYENV_ROOT="$HOME/.pyenv" +command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH" +eval "$(pyenv init -)" + +pyenv install 3.10.20 +pyenv local 3.10.20 + +python3.10 -m venv .venv-3.10 +.venv-3.10/bin/pip install --upgrade pip setuptools wheel +.venv-3.10/bin/pip install -r requirements-3.10.txt + +mkdir -p ~/coral-wheels +wget -O ~/coral-wheels/tflite_runtime-2.5.0.post1-cp310-cp310-linux_x86_64.whl \ + "https://github.com/cappittall/pycoral_whl_4_python3.10/raw/main/tools/tflite_runtime-2.5.0.post1-cp310-cp310-linux_x86_64.whl" +wget -O ~/coral-wheels/pycoral-2.0.0-cp310-cp310-linux_x86_64.whl \ + "https://github.com/cappittall/pycoral_whl_4_python3.10/raw/main/tools/pycoral-2.0.0-cp310-cp310-linux_x86_64.whl" +.venv-3.10/bin/pip install ~/coral-wheels/tflite_runtime-2.5.0.post1-cp310-cp310-linux_x86_64.whl +.venv-3.10/bin/pip install ~/coral-wheels/pycoral-2.0.0-cp310-cp310-linux_x86_64.whl +``` + +--- + +**Previous:** [Step 1 — Raspberry Pi Setup](01-raspberry-pi-setup.md) +**Next:** [Step 3 — Create a Dataset](03-create-dataset.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/03-create-dataset.md b/docs/03-create-dataset.md new file mode 100644 index 00000000..652af098 --- /dev/null +++ b/docs/03-create-dataset.md @@ -0,0 +1,128 @@ +# Step 3 — Create a Dataset + +This guide walks you through capturing marble images and labeling them for training. + +> **Machine:** Raspberry Pi + +## 3.1 Capture images + +Put only **one color** of marbles in the sorter at a time. Aim for at least **200 images per color**. + +```bash +sudo .venv-3.10/bin/python create_unlabeled_dataset.py +``` + +The script will ask you for: +1. **Label name** — the marble color (e.g. `red`). The label is automatically added to `label_map.pbtxt` (skipped if it already exists) and the matching `dataset//` folder is created. +2. **Capture time** — how many seconds to run the camera. + +To lift the elevator motor so you can swap marbles more easily: + +```bash +sudo .venv-3.10/bin/python actuator/elevator_motor.py +``` + +Repeat for every color. You should end up with a folder structure like this: + +``` +dataset/ +├── black/ +│ ├── frame_0000.png +│ ├── frame_0001.png +│ └── ... +├── orange/ +│ ├── frame_0000.png +│ └── ... +├── green/ +│ └── ... +├── red/ +│ └── ... +└── ... +``` + +## 3.2 Auto-label the images + +This script uses OpenCV to detect marbles and generate bounding-box labels automatically. It reads the class names from `label_map.pbtxt` and processes only `dataset/` subfolders that match those names. The results are saved as `dataset-.json` files inside the `dataset/` folder. + +```bash +sudo .venv-3.10/bin/python label_dataset.py +``` + +Result should look like this: +``` +dataset/ +├── black +├── green +├── mixed-not-labeled +├── orange +├── red +├── white +├── dataset-black.json +├── dataset-green.json +├── dataset-orange.json +├── dataset-red.json +└── dataset-white.json +``` + +> The auto-labeler is not perfect — you **must** review and correct the labels in the next step. + +## 3.3 Review labels with Label Studio + +### Start Label Studio + +```bash +curl -sSL https://get.docker.com | sudo sh +``` + +```bash +mkdir -p label-studio +sudo chown :0 label-studio +sudo docker run --network host \ + -v $(pwd)/label-studio:/label-studio/data \ + --name label-studio -d heartexlabs/label-studio:latest + +echo "Label Studio is starting up. Please wait a moment (1min)..." +sleep 60 +echo "Label Studio should now be running at http://localhost:8080 (oder über die IP-Adresse des Hosts)" +``` + +Open in your browser. + +### Serve images locally + +Label Studio needs HTTP access to the images. Start the included server on port 1000: + +```bash +sudo python3 http-server.py +``` + +![alt text](img/create-dataset/http-server.png) + +### Import and review + +![alt text](img/create-dataset/1-LabelStudio.png) + +1. Click **Import** in Label Studio. +2. Upload the `dataset-.json` files from the `dataset/` folder. +3. Review each image and correct any wrong bounding boxes. + +![alt text](img/create-dataset/2-LabelStudio.png) +![alt text](img/create-dataset/3-LabelStudio.png) +![alt text](img/create-dataset/4-LabelStudio.png) +![alt text](img/create-dataset/5-LabelStudio.png) +![alt text](img/create-dataset/6-LabelStudio.png) +![alt text](img/create-dataset/7-LabelStudio.png) +![alt text](img/create-dataset/8-LabelStudio.png) +![alt text](img/create-dataset/9-LabelStudio.png) +![alt text](img/create-dataset/10-LabelStudio.png) +![alt text](img/create-dataset/11-LabelStudio.png) +![alt text](img/create-dataset/12-LabelStudio.png) + +Once you are happy with the labels, you are ready to train the model. + +--- + +**Previous:** [Step 2 — Training PC Setup](02-training-pc-setup.md) +**Next:** [Step 4 — Train the Model](04-train-model.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/04-train-model.md b/docs/04-train-model.md new file mode 100644 index 00000000..8a1a44df --- /dev/null +++ b/docs/04-train-model.md @@ -0,0 +1,81 @@ +# Step 4 — Train the Model + +A single Docker container performs the complete training pipeline — TFRecord generation, SSD MobileNet V2 fine-tuning, TFLite export, INT8 quantization, and Edge TPU compilation. + +> **Machine:** Training PC with NVIDIA GPU +> Make sure you have completed [Step 2 — Training PC Setup](02-training-pc-setup.md) first. + +## 4.1 Copy the dataset to the training PC + +Transfer the `dataset/` folder (with both the per-color image folders **and** the `dataset-*.json` files from Label Studio) to the project root on your training PC. + +## 4.2 Run the full training pipeline + +```bash +sudo docker build -f Dockerfile.train -t sorter-train:latest . +``` + +```bash +mkdir -p my-models + +sudo docker run --rm \ + -v "$(pwd)/dataset:/dataset" \ + -v "$(pwd)/my-models:/my-models" \ + --gpus all \ + sorter-train:latest +``` + +The container will, in order: + +1. Generate `train.record` / `val.record` (90/10 split) into `my-models/records/`. +2. Render a container-friendly `pipeline.config` into `my-models/pipeline.config`. +3. Fine-tune SSD MobileNet V2 (`num_steps: 50000`) — checkpoints land in `my-models/checkpoints/`. +4. Export a TFLite-friendly `saved_model/` into `my-models/tflite_export/`. +5. Quantize to INT8 using ~100 calibration images from the dataset, producing `my-models/ssd_mobilenet_v2_quant.tflite`. +6. Compile for the Edge TPU, producing `my-models/ssd_mobilenet_v2_quant_edgetpu.tflite`. + +## 4.3 Output files + +When training finishes you will find in `my-models/`: + +| File | Description | +|---|---| +| `marbel_coral.tflite` | Edge TPU model — use this on the Raspberry Pi | +| `ssd_mobilenet_v2_quant.tflite` | INT8 CPU fallback | +| `tflite_export/saved_model/` | Pre-quantization SavedModel | +| `checkpoints/` | Training checkpoints + TensorBoard event files | +| `labels.txt` | Class id-to-name map matching `label_map.pbtxt` | + +## 4.4 Quick smoke test + +To sanity-check the pipeline without waiting for 50 000 steps, edit `num_steps` in `pipeline.config` (e.g. to `1000`) and rebuild the image. + +```bash +sudo docker build -f Dockerfile.train -t sorter-train:latest . +``` + +## 4.5 Test on the Coral USB Accelerator + +With the coral plugged in you can also test the compiled model on the training PC, not only on the Raspberry Pi. This is a good way to verify that the model works before deploying it. + +```bash +sudo .venv-3.10/bin/python test_coral.py \ + --model my-models/marbel_coral.tflite \ + --labels my-models/labels.txt \ + --image dataset/red/frame_0000.png +``` + +To classify all images in `dataset/mixed-not-labeled/` at once: + +```bash +sudo .venv-3.10/bin/python classify_mixed.py +``` + +Typical inference time on the Edge TPU is ~6 ms per frame. + +--- + +**Previous:** [Step 3 — Create a Dataset](03-create-dataset.md) +**Next:** [Step 5 — Run the Sorter](05-run-sorter.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/05-run-sorter.md b/docs/05-run-sorter.md new file mode 100644 index 00000000..5967b9b2 --- /dev/null +++ b/docs/05-run-sorter.md @@ -0,0 +1,26 @@ +# Step 5 — Run the Sorter + +You now have a trained Edge TPU model. Time to sort some marbles. + +> **Machine:** Raspberry Pi + +## 5.1 Copy the model to the Raspberry Pi + +Transfer `my-models/marbel_coral.tflite` and `my-models/labels.txt` from the training PC to the Raspberry Pi project directory (inside `my-models/`). + +## 5.2 Start the sorter + +Make sure the camera, Coral USB Accelerator, motors, and sensors are all connected, then run: + +```bash +sudo .venv-3.10/bin/python main.py +``` + +Enjoy your sorted marbles! + +--- + +**Previous:** [Step 4 — Train the Model](04-train-model.md) +**Back to:** [README](../README.md) + +[**Home**](../README.md) \ No newline at end of file diff --git a/docs/img/create-dataset/1-LabelStudio.png b/docs/img/create-dataset/1-LabelStudio.png new file mode 100644 index 00000000..f643d1ce Binary files /dev/null and b/docs/img/create-dataset/1-LabelStudio.png differ diff --git a/docs/img/create-dataset/10-LabelStudio.png b/docs/img/create-dataset/10-LabelStudio.png new file mode 100644 index 00000000..f8b8e48d Binary files /dev/null and b/docs/img/create-dataset/10-LabelStudio.png differ diff --git a/docs/img/create-dataset/11-LabelStudio.png b/docs/img/create-dataset/11-LabelStudio.png new file mode 100644 index 00000000..199c255b Binary files /dev/null and b/docs/img/create-dataset/11-LabelStudio.png differ diff --git a/docs/img/create-dataset/12-LabelStudio.png b/docs/img/create-dataset/12-LabelStudio.png new file mode 100644 index 00000000..addbf4e7 Binary files /dev/null and b/docs/img/create-dataset/12-LabelStudio.png differ diff --git a/docs/img/create-dataset/2-LabelStudio.png b/docs/img/create-dataset/2-LabelStudio.png new file mode 100644 index 00000000..40c0f6ba Binary files /dev/null and b/docs/img/create-dataset/2-LabelStudio.png differ diff --git a/docs/img/create-dataset/3-LabelStudio.png b/docs/img/create-dataset/3-LabelStudio.png new file mode 100644 index 00000000..9fe9752e Binary files /dev/null and b/docs/img/create-dataset/3-LabelStudio.png differ diff --git a/docs/img/create-dataset/4-LabelStudio.png b/docs/img/create-dataset/4-LabelStudio.png new file mode 100644 index 00000000..2ef41400 Binary files /dev/null and b/docs/img/create-dataset/4-LabelStudio.png differ diff --git a/docs/img/create-dataset/5-LabelStudio.png b/docs/img/create-dataset/5-LabelStudio.png new file mode 100644 index 00000000..3b0bc30d Binary files /dev/null and b/docs/img/create-dataset/5-LabelStudio.png differ diff --git a/docs/img/create-dataset/6-LabelStudio.png b/docs/img/create-dataset/6-LabelStudio.png new file mode 100644 index 00000000..03ca695d Binary files /dev/null and b/docs/img/create-dataset/6-LabelStudio.png differ diff --git a/docs/img/create-dataset/7-LabelStudio.png b/docs/img/create-dataset/7-LabelStudio.png new file mode 100644 index 00000000..ee9fb98e Binary files /dev/null and b/docs/img/create-dataset/7-LabelStudio.png differ diff --git a/docs/img/create-dataset/8-LabelStudio.png b/docs/img/create-dataset/8-LabelStudio.png new file mode 100644 index 00000000..abea9280 Binary files /dev/null and b/docs/img/create-dataset/8-LabelStudio.png differ diff --git a/docs/img/create-dataset/9-LabelStudio.png b/docs/img/create-dataset/9-LabelStudio.png new file mode 100644 index 00000000..8346c111 Binary files /dev/null and b/docs/img/create-dataset/9-LabelStudio.png differ diff --git a/docs/img/create-dataset/http-server.png b/docs/img/create-dataset/http-server.png new file mode 100644 index 00000000..f3da9076 Binary files /dev/null and b/docs/img/create-dataset/http-server.png differ diff --git a/http-server.py b/http-server.py new file mode 100644 index 00000000..5814f74d --- /dev/null +++ b/http-server.py @@ -0,0 +1,14 @@ +from http.server import HTTPServer, SimpleHTTPRequestHandler +from functools import partial +from pathlib import Path +import os + +class CORSRequestHandler(SimpleHTTPRequestHandler): + def end_headers(self): + self.send_header('Access-Control-Allow-Origin', '*') + super().end_headers() + +dataset_dir = Path(__file__).parent / "dataset" +os.chdir(dataset_dir) + +HTTPServer(('0.0.0.0', 1000), CORSRequestHandler).serve_forever() diff --git a/inference_process.py b/inference_process.py deleted file mode 100644 index 651925d3..00000000 --- a/inference_process.py +++ /dev/null @@ -1,108 +0,0 @@ -import sys -import os -import time -import numpy as np -from PIL import Image -from pycoral.adapters import classify -from pycoral.utils.edgetpu import make_interpreter -import RPi.GPIO as GPIO -import socket - -# Debugging -print("Python Executable:", sys.executable) -print("Python Path:", sys.path) - -model_path = '../test.tflite' -SORT_PIN = 7 - -#Socket Verbindung -client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -client_socket.connect(('localhost', 65432)) - -# Daten an Server senden (z. B. an Arduino senden) -client_socket.sendall(b'Hello Arduino') - -# Daten vom Server empfangen (z. B. von Arduino empfangen) -while True: - response = client_socket.recv(1024).decode('utf-8') - print(f"Received from Arduino: {response}") - -# Setup GPIO -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(SORT_PIN, GPIO.OUT, initial=GPIO.LOW) - -# Angepasster Schwellenwert für die Dateigröße -MIN_FILE_SIZE = 5000 # Reduzierter Wert, um auch kleinere Bilder zu berücksichtigen - -def load_and_infer_image(): - interpreter = make_interpreter(model_path) - interpreter.allocate_tensors() - - # Get input and output tensor details - input_details = interpreter.get_input_details()[0] - output_details = interpreter.get_output_details()[0] - - input_index = input_details['index'] - output_index = output_details['index'] - - input_dtype = input_details['dtype'] - input_scale, input_zero_point = input_details['quantization'] - input_shape = input_details['shape'] - - while True: - image_files = [f for f in os.listdir('/tmp') if f.startswith('current_image_') and f.endswith('.jpg')] - if image_files: - latest_image = max(image_files, key=lambda x: os.path.getctime(os.path.join('/tmp', x))) - img_path = os.path.join('/tmp', latest_image) - - # Überprüfen der Dateigröße - file_size = os.path.getsize(img_path) - if file_size < MIN_FILE_SIZE: - print(f"Überspringe Bild {latest_image}, da die Dateigröße zu klein ist ({file_size} Bytes).") - os.remove(img_path) - continue - - img_pil = Image.open(img_path) - img_pil = img_pil.resize((224, 224)) - - img_array = np.array(img_pil) - img_array = np.expand_dims(img_array, axis=0) - - # Normalize and convert to the correct type if needed - if input_dtype == np.uint8: - img_array = np.array(img_pil, dtype=np.float32) - img_array = (img_array / 255.0 - input_zero_point) / input_scale - img_array = np.clip(img_array, 0, 255).astype(np.uint8) - elif input_dtype == np.int8: - # Convert to int8, adjusting scaling as needed - img_array = np.array(img_pil, dtype=np.float32) - img_array = (img_array - input_zero_point) / input_scale - img_array = np.clip(img_array * 255, 0, 255).astype(np.int8) - else: - img_array = np.array(img_pil, dtype=np.float32) - - img_array = np.resize(img_array, input_shape) - - interpreter.set_tensor(input_index, img_array) - interpreter.invoke() - - output_array = interpreter.get_tensor(output_index) - classes = classify.get_classes(interpreter, top_k=1) - - print("Erkannte Klassen:", classes) - - if classes and classes[0].id == 0 and classes[0].score > 0.7: - print("Objekt mit ausreichender Zuversicht erkannt. Sortierung aktivieren.") - GPIO.output(SORT_PIN, GPIO.HIGH) - time.sleep(1) - GPIO.output(SORT_PIN, GPIO.LOW) - else: - print("Kein Objekt erkannt oder geringe Zuversicht.") - - os.remove(img_path) - - time.sleep(1) - -if __name__ == '__main__': - load_and_infer_image() diff --git a/label_dataset.py b/label_dataset.py new file mode 100644 index 00000000..b80e53af --- /dev/null +++ b/label_dataset.py @@ -0,0 +1,235 @@ +"""Build a marble detection/classification dataset as Label Studio JSON. + +For each color subfolder under ``dataset/`` this script: + 1. Crops a 300x300 region around each image's center. + 2. Thresholds + finds contours to locate a marble. + 3. Uses the folder name as the ground-truth class label. + 4. Writes one Label Studio task per image to ``dataset/dataset-.json``. +""" + +import json +import os +import datetime +import re + +import cv2 +import numpy as np + +DATASET_ROOT = "dataset" +LABEL_MAP_PATH = "label_map.pbtxt" +SKIP_FOLDERS = {"mixed-not-labeled", "out"} +CROP_SIZE_X = 300 +CROP_SIZE_Y = 540 +MIN_AREA = 2000 +MAX_AREA = 100000 +THRESH_VAL = 100 + +IMAGE_URL_TEMPLATE = "http://127.0.0.1:1000/{folder}/{filename}" + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{name: id}`` dict.""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[name_match.group(1)] = int(id_match.group(1)) + return label_map + + +def classify_color(bgr_roi, mask=None): + """Return one of: 'red', 'green', 'orange', 'black', 'white', 'unknown'.""" + if bgr_roi.size == 0: + return "unknown" + + hsv = cv2.cvtColor(bgr_roi, cv2.COLOR_BGR2HSV) + + if mask is None: + mask = np.full(bgr_roi.shape[:2], 255, dtype=np.uint8) + + if cv2.countNonZero(mask) == 0: + return "unknown" + + m = mask > 0 + h_med = float(np.median(hsv[:, :, 0][m])) + s_med = float(np.median(hsv[:, :, 1][m])) + v_med = float(np.median(hsv[:, :, 2][m])) + + # Achromatic checks first. + if s_med < 60 and v_med < 70: + return "black" + if s_med < 50 and v_med > 170: + return "white" + + # Chromatic: decide by hue (OpenCV hue range 0..179). + if h_med < 10 or h_med >= 160: + return "red" + if 35 <= h_med <= 85: + return "green" + if 90 <= h_med <= 135: + return "orange" + + if v_med < 80: + return "black" + if s_med < 60: + return "white" + return "red" if (h_med < 20 or h_med > 150) else "unknown" + + +def process_image(image_path, forced_label=None): + """Detect marble in ``image_path`` and return a result dict or None.""" + frame_bgr = cv2.imread(image_path) + if frame_bgr is None: + print(f"Warning: could not load {image_path}") + return None + + height, width = frame_bgr.shape[:2] + + # Center crop. + start_x = max(0, width // 2 - CROP_SIZE_X // 2) + start_y = max(0, height // 2 - CROP_SIZE_Y // 2) + center_crop = frame_bgr[start_y:start_y + CROP_SIZE_Y, start_x:start_x + CROP_SIZE_X] + + # Grayscale -> Blur -> Threshold -> Invert. + frame_gray = cv2.cvtColor(center_crop, cv2.COLOR_BGR2GRAY) + blurred = cv2.GaussianBlur(frame_gray, (5, 5), 0) + _, thresh = cv2.threshold(blurred, THRESH_VAL, 255, cv2.THRESH_BINARY) + inv_thresh = cv2.bitwise_not(thresh) + + # Contour detection. + contours, _ = cv2.findContours(inv_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + valid_contours = [c for c in contours if MIN_AREA <= cv2.contourArea(c) <= MAX_AREA] + if not valid_contours: + label = "unknown" + xmin = ymin = xmax = ymax = 0 + else: + largest_contour = max(valid_contours, key=cv2.contourArea) + x, y, w, h = cv2.boundingRect(largest_contour) + + # Mask for the marble inside the crop. + contour_mask = np.zeros(inv_thresh.shape, dtype=np.uint8) + cv2.drawContours(contour_mask, [largest_contour], -1, 255, thickness=cv2.FILLED) + roi = center_crop[y:y + h, x:x + w] + roi_mask = contour_mask[y:y + h, x:x + w] + label = forced_label if forced_label is not None else classify_color(roi, roi_mask) + + # Convert crop-relative bbox to absolute image coordinates. + xmin = max(0, start_x + x) + ymin = max(0, start_y + y) + xmax = min(width, start_x + x + w) + ymax = min(height, start_y + y + h) + + return { + "filename": os.path.basename(image_path), + "width": width, + "height": height, + "class": label, + "xmin": xmin, + "ymin": ymin, + "xmax": xmax, + "ymax": ymax, + } + + +def to_label_studio_task(result, folder_name, task_id): + """Convert a ``process_image`` result dict into a valid Label Studio Import format.""" + img_width = float(result["width"]) + img_height = float(result["height"]) + xmin = float(result["xmin"]) + ymin = float(result["ymin"]) + xmax = float(result["xmax"]) + ymax = float(result["ymax"]) + + # Convert absolute pixel coords to percentages for Label Studio. + x = (xmin / img_width) * 100 if img_width else 0 + y = (ymin / img_height) * 100 if img_height else 0 + box_width = ((xmax - xmin) / img_width) * 100 if img_width else 0 + box_height = ((ymax - ymin) / img_height) * 100 if img_height else 0 + + return { + "id": task_id, + "data": { + "image": IMAGE_URL_TEMPLATE.format( + folder=folder_name, filename=result["filename"] + ) + }, + "annotations": [ + { + "result": [ + { + "from_name": "label", + "to_name": "image", + "type": "rectanglelabels", + "original_width": int(img_width), + "original_height": int(img_height), + "value": { + "x": x, + "y": y, + "width": box_width, + "height": box_height, + "rotation": 0, + "rectanglelabels": [result["class"]] + } + } + ] + } + ] + } + + +def process_folder(folder_path, label): + """Process every image in ``folder_path`` and write a Label Studio JSON file.""" + filenames = sorted( + f for f in os.listdir(folder_path) + if f.lower().endswith((".png", ".jpg", ".jpeg")) + ) + if not filenames: + print(f"Skipping {folder_path}: no images found") + return + + tasks = [] + folder_name = os.path.basename(folder_path.rstrip(os.sep)) + task_id = 1 + + for filename in filenames: + path = os.path.join(folder_path, filename) + result = process_image(path, forced_label=label) + if result is None: + continue + + tasks.append(to_label_studio_task(result, folder_name, task_id)) + print( + f"[{label}] {filename}: " + f"bbox=({result['xmin']},{result['ymin']},{result['xmax']},{result['ymax']})" + ) + task_id += 1 + + json_path = os.path.join(DATASET_ROOT, f"dataset-{label}.json") + with open(json_path, "w") as f: + json.dump(tasks, f, indent=2) + + print(f"Wrote {len(tasks)} tasks to {json_path}\n") + + +def main(): + label_map = parse_label_map(LABEL_MAP_PATH) + if not label_map: + raise SystemExit(f"No labels found in {LABEL_MAP_PATH}. " + "Create a label_map.pbtxt first (see README).") + + print(f"Labels from {LABEL_MAP_PATH}: {list(label_map.keys())}") + + for name in sorted(label_map.keys()): + folder = os.path.join(DATASET_ROOT, name) + if not os.path.isdir(folder): + print(f"Skipping label '{name}': folder {folder} not found") + continue + process_folder(folder, label=name) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 00000000..14fd79f5 --- /dev/null +++ b/main.py @@ -0,0 +1,320 @@ +"""Marble Sorter – Main control loop. + +Runs the full sorting pipeline for a configurable duration: +1. Verify the Coral Edge TPU model file exists. +2. Start the elevator motor (background thread). +3. Turn on the LED ring for camera illumination. +4. Stream camera frames for SORT_DURATION seconds. +5. For each frame, detect marble presence via OpenCV contours. +6. If detected, classify with the Coral Edge TPU model. +7. Trigger the solenoid to sort left/right based on color. +8. Shut everything down cleanly. + +Usage: + sudo .venv-3.10/bin/python main.py +""" + +import os +import re +import sys +import time +import threading + +import cv2 +import numpy as np +from PIL import Image +from pycoral.adapters import common, detect +from pycoral.utils.edgetpu import make_interpreter + +from actuator.elevator_motor import ElevatorMotorController +from actuator.led_neopixel import NeoPixelController +from actuator.switch_solenoid_motor import SolenoidController +from sensor.camera import Camera +from display import MarbleDisplay + +# --------------------------------------------------------------------------- +# Paths +# --------------------------------------------------------------------------- +MODEL_PATH = "my-models/marbel_coral.tflite" +LABELS_PATH = "my-models/labels.txt" +LABEL_MAP_PATH = "label_map.pbtxt" + +# --------------------------------------------------------------------------- +# Sorting parameters +# --------------------------------------------------------------------------- +SORT_DURATION = 30 # seconds +DETECTION_THRESHOLD = 0.4 # minimum confidence for a detection +COOLDOWN_SECONDS = 0.5 # pause after sorting a marble to avoid re-detecting + +# --------------------------------------------------------------------------- +# OpenCV marble-presence detection (mirrored from label_dataset.py) +# --------------------------------------------------------------------------- +CROP_SIZE_X = 300 +CROP_SIZE_Y = 540 +MIN_AREA = 2000 +MAX_AREA = 100000 +THRESH_VAL = 100 + +# --------------------------------------------------------------------------- +# Elevator motor +# --------------------------------------------------------------------------- +ELEVATOR_STEPS = 400 +ELEVATOR_PAUSE = 0.002 + + +# ═══════════════════════════════════════════════════════════════════════════ +# Helpers +# ═══════════════════════════════════════════════════════════════════════════ + +def load_labels(): + """Load class labels from labels.txt or label_map.pbtxt. + + Returns a ``{id: name}`` dict (0-indexed as expected by pycoral). + """ + labels = {} + + # Prefer my-models/labels.txt (format: "id name") + if os.path.exists(LABELS_PATH): + with open(LABELS_PATH, "r") as fh: + for line in fh: + pair = line.strip().split(maxsplit=1) + if len(pair) == 2: + labels[int(pair[0])] = pair[1] + return labels + + # Fall back to label_map.pbtxt (1-indexed, so subtract 1) + if os.path.exists(LABEL_MAP_PATH): + text = open(LABEL_MAP_PATH).read() + for block in re.finditer(r"item\s*\{(.*?)\}", text, re.DOTALL): + body = block.group(1) + id_match = re.search(r"id:\s*(\d+)", body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + labels[int(id_match.group(1)) - 1] = name_match.group(1) + return labels + + print("Warning: No label file found. Using numeric class IDs.") + return labels + + +def detect_marble_present(frame_bayer, crop_size=300, min_area=2000, max_area=100000, thresh_val=100): + """ + Detects if a marble is present in the center of the given image. + + Args: + frame_bayer (np.ndarray): The input bayer image. + crop_size (int): Size of the center square crop. + min_area (int): Minimum contour area to be considered a marble. + max_area (int): Maximum contour area to be considered a marble. + thresh_val (int): Threshold value for binarization. + + Returns: + bool: True if a marble is detected, False otherwise. + """ + # 1. Check Image + if frame_bayer is None: + print("Warning: Could not load image") + return False + + height, width = frame_bayer.shape[:2] + + # 2. Fast Cropping + start_x = max(0, width // 2 - crop_size // 2) + start_y = max(0, height // 2 - crop_size // 2) + + # Slice the numpy array + center_crop = frame_bayer[start_y:start_y+crop_size, start_x:start_x+crop_size] + + # 3. Optimized Processing (Grayscale -> Blur -> Threshold -> Invert) + frame_gray = cv2.cvtColor(center_crop, cv2.COLOR_BAYER_RG2GRAY) + blurred = cv2.GaussianBlur(frame_gray, (5, 5), 0) + + _, thresh = cv2.threshold(blurred, thresh_val, 255, cv2.THRESH_BINARY) + inv_thresh = cv2.bitwise_not(thresh) + + # 4. Contour Detection + contours, _ = cv2.findContours(inv_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + + # 5. Validation + # If any contour matches the area criteria, a marble is present + for c in contours: + area = cv2.contourArea(c) + if min_area <= area <= max_area: + return True + + return False + + +def run_elevator(motor, stop_event): + """Continuously rotate the elevator motor until *stop_event* is set.""" + motor.enable() + while not stop_event.is_set(): + motor.rotate(steps=ELEVATOR_STEPS, pause_seconds=ELEVATOR_PAUSE) + + +# ═══════════════════════════════════════════════════════════════════════════ +# Main +# ═══════════════════════════════════════════════════════════════════════════ + +def main(): + # ------------------------------------------------------------------ + # 1. Check that the Coral model is present + # ------------------------------------------------------------------ + if not os.path.isfile(MODEL_PATH): + sys.exit( + f"Model not found: {MODEL_PATH}\n" + "Copy marbel_coral.tflite into my-models/ first " + "(see docs/05-run-sorter.md)." + ) + print(f"[OK] Model found: {MODEL_PATH}") + + # ------------------------------------------------------------------ + # 2. Load labels & Coral interpreter + # ------------------------------------------------------------------ + labels = load_labels() + print(f"[OK] Labels: {labels}") + + try: + interpreter = make_interpreter(MODEL_PATH) + interpreter.allocate_tensors() + except Exception as exc: + sys.exit( + f"Failed to load Coral model: {exc}\n" + "Make sure the Coral USB Accelerator is connected and drivers " + "are installed." + ) + input_size = common.input_size(interpreter) + print(f"[OK] Coral interpreter ready – input size {input_size}") + + # ------------------------------------------------------------------ + # 3. Initialise hardware + # ------------------------------------------------------------------ + elevator = ElevatorMotorController() + leds = NeoPixelController() + solenoid = SolenoidController() + cam = Camera() + display = MarbleDisplay() + + if cam.camera is None: + sys.exit("No camera detected. Exiting.") + cam.print_camera_info() + + # ------------------------------------------------------------------ + # 4. Start elevator (background thread) + # ------------------------------------------------------------------ + stop_elevator = threading.Event() + elevator_thread = threading.Thread( + target=run_elevator, + args=(elevator, stop_elevator), + daemon=True, + ) + elevator_thread.start() + print("[OK] Elevator motor running.") + + # ------------------------------------------------------------------ + # 5. Turn on LEDs + # ------------------------------------------------------------------ + leds.set_color((255, 255, 255)) + print("[OK] LEDs on.") + + # ------------------------------------------------------------------ + # 6. Sorting loop + # ------------------------------------------------------------------ + frame_count = 0 + sorted_count = 0 + sort_stats = {"red": 0, "green": 0, "other": 0} + + print(f"\n--- Sorting for {SORT_DURATION} seconds ---\n") + + try: + for raw_frame in cam.stream_for_duration(SORT_DURATION): + frame_count += 1 + + # Convert raw Bayer to BGR + frame_bgr = cv2.cvtColor(raw_frame, cv2.COLOR_BAYER_BG2BGR) #cv2.COLOR_BAYER_BG2BGR + + # Fast check: is there a marble in the frame? + is_marbel = detect_marble_present(raw_frame) + if is_marbel is False: + continue + + print("OPENCV erkannt") + start_time = time.perf_counter() + + # Classify the detected marble with the Coral TPU + pil_img = Image.fromarray(cv2.cvtColor(raw_frame, cv2.COLOR_BAYER_RG2BGR)) + pil_img = pil_img.resize(input_size, Image.LANCZOS) + common.set_input(interpreter, pil_img) + interpreter.invoke() + objs = detect.get_objects(interpreter, DETECTION_THRESHOLD) + + inference_time = time.perf_counter() - start_time + + if not objs: + continue + + best = max(objs, key=lambda o: o.score) + label = labels.get(best.id, f"unknown_{best.id}") + confidence = best.score * 100 + sorted_count += 1 + + # Solenoid ON → deflect to GREEN side (left) + # Solenoid OFF → marble falls to RED side (right, default) + display.update_detection(frame_bgr, label, confidence) + marble_shown = True + + if label == "green": + solenoid.turn_on() + sort_stats["green"] += 1 + print(f" Frame {frame_count}: {label} ({confidence:.1f}%) -> LEFT ({inference_time*1000:.2f}ms)") + elif label == "red": + solenoid.turn_off() + sort_stats["red"] += 1 + print(f" Frame {frame_count}: {label} ({confidence:.1f}%) -> RIGHT ({inference_time*1000:.2f}ms)") + else: + sort_stats["other"] += 1 + print(f" Frame {frame_count}: {label} ({confidence:.1f}%) -> SKIP ({inference_time*1000:.2f}ms)") + + # Cooldown so we don't re-classify the same marble + time.sleep(COOLDOWN_SECONDS) + + cam.flush_image_queue() + + except KeyboardInterrupt: + print("\nSorting interrupted by user.") + + finally: + # -------------------------------------------------------------- + # 7. Shutdown + # -------------------------------------------------------------- + print("\nShutting down...") + + display.close() + stop_elevator.set() + elevator_thread.join(timeout=5) + elevator.cleanup() + print("[OK] Elevator stopped.") + + solenoid.turn_off() + print("[OK] Solenoid off.") + + leds.turn_off() + print("[OK] LEDs off.") + + cam.release_camera() + print("[OK] Camera released.") + + # Summary + print(f"\n{'=' * 30}") + print(" SORTING RESULTS") + print(f"{'=' * 30}") + print(f" Frames processed : {frame_count}") + print(f" Marbles sorted : {sorted_count}") + print(f" Red (right) : {sort_stats['red']}") + print(f" Green (left) : {sort_stats['green']}") + print(f" Other (skipped) : {sort_stats['other']}") + print(f"{'=' * 30}") + + +if __name__ == "__main__": + main() diff --git a/mypy.ini b/mypy.ini new file mode 100644 index 00000000..4b3281c4 --- /dev/null +++ b/mypy.ini @@ -0,0 +1,4 @@ +[mypy] +ignore_missing_imports = True +check_untyped_defs = True +disallow_untyped_defs = True diff --git a/newcoral.py b/newcoral.py deleted file mode 100644 index 7a3c4ce8..00000000 --- a/newcoral.py +++ /dev/null @@ -1,56 +0,0 @@ -import os -from PIL import Image -from pycoral.adapters import common, detect -from pycoral.utils.edgetpu import make_interpreter -import numpy as np - -# Ordner, in dem die Bilder gespeichert sind -image_dir = '/tmp' - -# Nur Bilder, die mit 'current_image' beginnen -image_files = [f for f in os.listdir(image_dir) if f.startswith('current_image') and f.endswith(('.jpg', '.png'))] - -# Wenn es keine passenden Bilder gibt -if not image_files: - raise FileNotFoundError("Keine Bilder gefunden, die mit 'current_image' beginnen.") - -# Nimm das erste gefundene Bild (du kannst hier auch erweitern, um alle zu verarbeiten) -image_path = os.path.join(image_dir, image_files[0]) -print(f'Verwende Bild: {image_path}') - -# Lade das Bild -image = Image.open(image_path).convert('RGB') - -# Lade das TensorFlow Lite Modell (Mobilenet SSD für Objekt-Erkennung) -model_path = '../best-object_int8.tflite' -interpreter = make_interpreter(model_path) -interpreter.allocate_tensors() - -# Setze das Bild als Eingabe für das Modell -_, scale = common.set_resized_input(interpreter, image.size, lambda size: image.resize(size, Image.Resampling.LANCZOS)) - -# Führe die Vorhersage durch -interpreter.invoke() - -# Ergebnisse aus dem Interpreter extrahieren -objects = detect.get_objects(interpreter, score_threshold=0.5, image_scale=scale) - -# Labels für das COCO-Dataset -LABELS = { - 0: 'background', 1: 'person', 2: 'bicycle', 3: 'car', 17: 'cat', 18: 'dog' -} - -# Ergebnisse anzeigen und Aktionen ausführen -for obj in objects: - object_id = obj.id - score = obj.score - bbox = obj.bbox # Begrenzungsrahmen (Bounding Box) - - print(f'Erkanntes Objekt: {LABELS.get(object_id, object_id)} mit {score:.2f} Konfidenz') - - if object_id == 1: # Person erkannt - print("Aktion: Person erkannt, starte Alarmsystem.") - elif object_id == 17: # Katze erkannt - print("Aktion: Katze erkannt, starte Fütterungssystem.") - elif object_id == 18: # Hund erkannt - print("Aktion: Hund erkannt, starte Türöffner.") diff --git a/old/sorter.py b/old/sorter.py deleted file mode 100644 index 22832da2..00000000 --- a/old/sorter.py +++ /dev/null @@ -1,184 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -# this file will contain the main sorter class -# this will handle grabbing the flir images, determining - -from utils import CameraWebsocketHandler -from utils.BiQuad import BiQuadFilter -from functools import partial -from PIL import Image -from scipy import ndimage -import edgetpu.classification.engine -import threading -import asyncio -import base64 -import utils -import cv2 -import argparse -import sys -import RPi.GPIO as GPIO -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# NOTE: can either be 'train' to classify images using edgetpu or 'sort' to just send images to TM2 -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' -# biquad params : type, Fc, Q, peakGainDB -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - - -# this is the logic that determines if there is a sorting target in the center of the frame -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - if (filter_type == 'zone'): - detection_zone_avg = img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3].mean() - if (filter_type == 'biquad2d'): - detection_zone_avg = abs(bq.process(img.mean)) - if (filter_type == 'biquad'): - detection_zone_avg = abs(bq.process(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3].mean())) - if (filter_type == 'center_of_mass'): - center = scipy.ndimage.measurements.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - - if len(sliding_window) > 30: - mean[0] = utils.mean_arr(sliding_window) - sliding_window.clear() - - else: - sliding_window.append(detection_zone_avg) - # print(detection_zone_avg) - if mean[0] != None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -# call each time you have a new frame -def on_new_frame(cv_mat, engine, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - - width, height = img_pil.size - - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if (is_good_frame): - # NOTE: Teachable Machine 2 works on images of size 224x224 and will resize all inputs - # to that size. so we have to make sure our edgetpu converted model is fed similar images. - if (width, height) != (224, 224): - img_pil.resize((224, 224)) - - if (mode == 'train'): - message = dict() - message['image'] = format_img_tm2(cv_mat) - message['shouldTakePicture'] = True - send_over_ws(message, cam_sockets) - # time.sleep(0.25) NOTE: debounce this at a rate depending on your singulation rate - - - elif (mode == 'sort'): - classification_result = engine.ClassifyWithImage(img_pil) - print(classification_result) - if classification_result [0][0] == 0 and classification_result[0][1] > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - # Here you can actuate the sorting end-effector through GPIO, etc. - - - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - # Start the tornado websocket server - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=CameraWebsocketHandler.start_server, args=(new_loop, cam_sockets, )) - server_thread.start() - - if args.will_sort: - engine = edgetpu.classification.engine.ClassificationEngine(model_path) - mode = "sort" - else: - mode = "train" - - # parse filter type - if args.zone: filter_type = 'zone' - elif args.biquad: filter_type = 'biquad' - elif args.biquad2d: filter_type = 'biquad2d' - elif args.center_of_mass: filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if (args.flir): - import FLIR - print("Initializing Flir Camera") - cam = FLIR.FlirBFS(on_new_frame=partial(on_new_frame, engine=engine, mean=mean, sliding_window=sliding_window, - send_over_ws=send_over_ws, cam_sockets=cam_sockets), - display=True, frame_rate=120) - cam.run_cam(); - elif (args.arducam): - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(0) - while cap.isOpened(): - ret,frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromArray(cv2_im) - pil_im.resize(224, 224) - pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(engine, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xff == ord('q'): - break - cap.release() - cv2.destroyAllWindows() - print('Initializing opencv Video Stream') - - diff --git a/old/test.py b/old/test.py deleted file mode 100644 index a7a8f06c..00000000 --- a/old/test.py +++ /dev/null @@ -1,22 +0,0 @@ -import ctypes - -# Load the shared library -lib = ctypes.CDLL('./spinnaker_wrapper.so') - -# Define function prototypes -lib.initSystem.argtypes = [] -lib.initSystem.restype = None - -lib.releaseSystem.argtypes = [] -lib.releaseSystem.restype = None - -lib.getCameraList.argtypes = [] -lib.getCameraList.restype = ctypes.c_void_p - -# Use the functions -lib.initSystem() - -camera_list = lib.getCameraList() -print("Camera List:", camera_list) - -lib.releaseSystem() diff --git a/old/try.py b/old/try.py deleted file mode 100644 index b447e4d7..00000000 --- a/old/try.py +++ /dev/null @@ -1,5 +0,0 @@ -try: - import tornado - print("Tornado module imported successfully") -except ImportError as e: - print(f"Import error: {e}") diff --git a/old/update4_camera.py b/old/update4_camera.py deleted file mode 100644 index 838012ca..00000000 --- a/old/update4_camera.py +++ /dev/null @@ -1,206 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from utils import CameraWebsocketHandler -from utils.FLIR import FlirBFS -from utils.BiQuad import BiQuadFilter -from functools import partial -from PIL import Image -from scipy import ndimage -import threading -import asyncio -import base64 -import utils -import cv2 -import argparse -import sys - -# Debugging -import sys -print("Python Executable:", sys.executable) -print("Python Path:", sys.path) - -try: - import tornado - print("Tornado module imported successfully") -except ImportError as e: - print(f"Import error: {e}") - -# Ensure required packages are imported correctly -try: - from pycoral.adapters import classify - from pycoral.utils.edgetpu import make_interpreter - from pycoral.adapters.common import input_size -except ImportError: - print("Error: pycoral module not found. Ensure you have installed pycoral correctly.") - sys.exit(1) - -try: - import RPi.GPIO as GPIO -except ImportError: - print("Error: RPi.GPIO module not found. Ensure you have installed RPi.GPIO correctly.") - sys.exit(1) - -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# NOTE: can either be 'train' to classify images using edgetpu or 'sort' to just send images to TM2 -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' -# biquad params: type, Fc, Q, peakGainDB -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) - -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - - if filter_type == 'zone': - detection_zone_avg = img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3].mean() - elif filter_type == 'biquad2d': - detection_zone_avg = abs(bq.process(img.mean())) - elif filter_type == 'biquad': - detection_zone_avg = abs(bq.process(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3].mean())) - elif filter_type == 'center_of_mass': - center = ndimage.measurements.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - if len(sliding_window) > 30: - mean[0] = utils.mean_arr(sliding_window) - sliding_window.clear() - else: - sliding_window.append(detection_zone_avg) - - if mean[0] is not None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -def on_new_frame(cv_mat, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - width, height = img_pil.size - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if is_good_frame: - # NOTE: Teachable Machine 2 works on images of size 224x224 and will resize all inputs - # to that size. so we have to make sure our edgetpu converted model is fed similar images. - if (width, height) != (224, 224): - img_pil = img_pil.resize((224, 224)) - - if mode == 'train': - message = dict() - message['image'] = format_img_tm2(cv_mat) - message['shouldTakePicture'] = True - send_over_ws(message, cam_sockets) - # time.sleep(0.25) NOTE: debounce this at a rate depending on your singulation rate - - elif mode == 'sort': - classify.set_input(interpreter, img_pil) - interpreter.invoke() - classes = classify.get_classes(interpreter, top_k=1) - print(classes) - if classes and classes[0].id == 0 and classes[0].score > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - # Here you can actuate the sorting end-effector through GPIO, etc. - -def capture_flir_camera(on_new_frame, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - from utils import FLIR - print("Initializing FLIR Camera") - cam = FLIR.FlirBFS(on_new_frame=on_new_frame, - display=True, frame_rate=120) - cam.run_cam() - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - # Start the tornado websocket server - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=CameraWebsocketHandler.start_server, args=(new_loop, cam_sockets, )) - server_thread.start() - - interpreter = make_interpreter(model_path) - interpreter.allocate_tensors() - - if args.will_sort: - mode = "sort" - else: - mode = "train" - - # Parse filter type - if args.zone: filter_type = 'zone' - elif args.biquad: filter_type = 'biquad' - elif args.biquad2d: filter_type = 'biquad2d' - elif args.center_of_mass: filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if args.flir: - capture_flir_camera( - partial(on_new_frame, interpreter=interpreter, mean=mean, sliding_window=sliding_window, - send_over_ws=send_over_ws, cam_sockets=cam_sockets), - interpreter, mean, sliding_window, send_over_ws, cam_sockets - ) - elif args.arducam: - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(0) - while cap.isOpened(): - ret, frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromarray(cv2_im) - pil_im = pil_im.resize((224, 224)) - pil_im = pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(cv2_im, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xff == ord('q'): - break - cap.release() - cv2.destroyAllWindows() - print('Initializing opencv Video Stream') diff --git a/old/update5_help.py b/old/update5_help.py deleted file mode 100644 index 6595c16c..00000000 --- a/old/update5_help.py +++ /dev/null @@ -1,206 +0,0 @@ -import sys -import os -import numpy as np -from PIL import Image -import cv2 -import base64 -from scipy import ndimage -from functools import partial -from pycoral.adapters import classify -from pycoral.utils.edgetpu import make_interpreter -import RPi.GPIO as GPIO -import asyncio -import threading -import argparse - -# Import the Spinnaker Python module -import PySpin - -# Debugging -print("Python Executable:", sys.executable) -print("Python Path:", sys.path) - -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# Mode configuration -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' - -# Define any required filters -class BiQuadFilter: - # Define your filter parameters here - def __init__(self, type, Fc, Q, peakGainDB): - self.type = type - self.Fc = Fc - self.Q = Q - self.peakGainDB = peakGainDB - - def process(self, value): - # Implement your filter processing here - return value # Placeholder - -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) - -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - - if filter_type == 'zone': - detection_zone_avg = np.mean(img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3]) - elif filter_type == 'biquad2d': - detection_zone_avg = abs(bq.process(np.mean(img))) - elif filter_type == 'biquad': - detection_zone_avg = abs(bq.process(np.mean(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3]))) - elif filter_type == 'center_of_mass': - center = ndimage.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - if len(sliding_window) > 30: - mean[0] = np.mean(sliding_window) - sliding_window.clear() - else: - sliding_window.append(detection_zone_avg) - - if mean[0] is not None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -def on_new_frame(cv_mat, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - width, height = img_pil.size - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if is_good_frame: - if (width, height) != (224, 224): - img_pil = img_pil.resize((224, 224)) - - if mode == 'train': - message = {'image': format_img_tm2(cv_mat), 'shouldTakePicture': True} - send_over_ws(message, cam_sockets) - - elif mode == 'sort': - classify.set_input(interpreter, img_pil) - interpreter.invoke() - classes = classify.get_classes(interpreter, top_k=1) - print(classes) - if classes and classes[0].id == 0 and classes[0].score > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - -def capture_flir_camera(on_new_frame, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - system = PySpin.System.GetInstance() - cam_list = system.GetCameras() - - if cam_list.GetSize() == 0: - print("No cameras detected.") - system.ReleaseInstance() - return - - camera = cam_list.GetByIndex(0) - camera.Init() - - try: - camera.AcquisitionMode.SetValue(PySpin.AcquisitionMode_Continuous) - camera.BeginAcquisition() - - while True: - try: - image_result = camera.GetNextImage() - if image_result.IsIncomplete(): - print("Image incomplete.") - continue - - image_data = image_result.GetNDArray() - on_new_frame(image_data, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - image_result.Release() - - except Exception as ex: - print("Error: %s" % ex) - break - - finally: - camera.EndAcquisition() - camera.DeInit() - cam_list.Clear() - system.ReleaseInstance() - print("FLIR Camera deinitialized") - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=lambda: CameraWebsocketHandler.start_server(new_loop, cam_sockets)) - server_thread.start() - - interpreter = make_interpreter(model_path) - interpreter.allocate_tensors() - - if args.will_sort: - mode = "sort" - else: - mode = "train" - - if args.zone: filter_type = 'zone' - elif args.biquad: filter_type = 'biquad' - elif args.biquad2d: filter_type = 'biquad2d' - elif args.center_of_mass: filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if args.flir: - print("Initializing FLIR Camera") - capture_flir_camera(on_new_frame, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - elif args.arducam: - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(0) - while cap.isOpened(): - ret, frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromarray(cv2_im) - pil_im = pil_im.resize((224, 224)) - pil_im = pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(cv2_im, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xFF == ord('q'): - break - cap.release() - cv2.destroyAllWindows() diff --git a/old/updatet.py b/old/updatet.py deleted file mode 100644 index 97db6ec1..00000000 --- a/old/updatet.py +++ /dev/null @@ -1,164 +0,0 @@ -import argparse -import asyncio -import base64 -import threading -import sys - -from PIL import Image -from functools import partial -from scipy import ndimage -import cv2 -import RPi.GPIO as GPIO -import utils - -# Ensure required packages are imported correctly -try: - import edgetpu.classification.engine as engine -except ImportError: - print("Error: edgetpu module not found. Ensure you have installed pycoral and libedgetpu correctly.") - sys.exit(1) - -from utils import CameraWebsocketHandler -from utils.BiQuad import BiQuadFilter - -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# NOTE: can either be 'train' to classify images using edgetpu or 'sort' to just send images to TM2 -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' -# biquad params: type, Fc, Q, peakGainDB -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) - -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - - if filter_type == 'zone': - detection_zone_avg = img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3].mean() - elif filter_type == 'biquad2d': - detection_zone_avg = abs(bq.process(img.mean)) - elif filter_type == 'biquad': - detection_zone_avg = abs(bq.process(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3].mean())) - elif filter_type == 'center_of_mass': - center = ndimage.measurements.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - if len(sliding_window) > 30: - mean[0] = utils.mean_arr(sliding_window) - sliding_window.clear() - else: - sliding_window.append(detection_zone_avg) - - if mean[0] is not None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -def on_new_frame(cv_mat, engine, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - width, height = img_pil.size - - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if is_good_frame: - if (width, height) != (224, 224): - img_pil.resize((224, 224)) - - if mode == 'train': - message = dict() - message['image'] = format_img_tm2(cv_mat) - message['shouldTakePicture'] = True - send_over_ws(message, cam_sockets) - elif mode == 'sort': - classification_result = engine.ClassifyWithImage(img_pil) - print(classification_result) - if classification_result[0][0] == 0 and classification_result[0][1] > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=CameraWebsocketHandler.start_server, args=(new_loop, cam_sockets,)) - server_thread.start() - - if args.will_sort: - engine = edgetpu.classification.engine.ClassificationEngine(model_path) - mode = "sort" - else: - mode = "train" - - if args.zone: - filter_type = 'zone' - elif args.biquad: - filter_type = 'biquad' - elif args.biquad2d: - filter_type = 'biquad2d' - elif args.center_of_mass: - filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if args.flir: - import FLIR - print("Initializing Flir Camera") - cam = FLIR.FlirBFS( - on_new_frame=partial(on_new_frame, engine=engine, mean=mean, sliding_window=sliding_window, send_over_ws=send_over_ws, cam_sockets=cam_sockets), - display=True, frame_rate=120 - ) - cam.run_cam() - elif args.arducam: - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(0) - print('Initializing opencv Video Stream') - while cap.isOpened(): - ret, frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromarray(cv2_im) - pil_im.resize((224, 224)) - pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(cv2_im, engine, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xff == ord('q'): - break - cap.release() - cv2.destroyAllWindows() diff --git a/old/updatet2.py b/old/updatet2.py deleted file mode 100644 index 7a4b70b3..00000000 --- a/old/updatet2.py +++ /dev/null @@ -1,188 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from utils import CameraWebsocketHandler -from utils.BiQuad import BiQuadFilter -from functools import partial -from PIL import Image -from scipy import ndimage -import threading -import asyncio -import base64 -import utils -import cv2 -import argparse -import sys - -# Ensure required packages are imported correctly -try: - from pycoral.adapters import classify - from pycoral.utils.edgetpu import make_interpreter - from pycoral.adapters.common import input_size -except ImportError: - print("Error: pycoral module not found. Ensure you have installed pycoral correctly.") - sys.exit(1) - -try: - import RPi.GPIO as GPIO -except ImportError: - print("Error: RPi.GPIO module not found. Ensure you have installed RPi.GPIO correctly.") - sys.exit(1) - -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# NOTE: can either be 'train' to classify images using edgetpu or 'sort' to just send images to TM2 -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' -# biquad params: type, Fc, Q, peakGainDB -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) - -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - - if filter_type == 'zone': - detection_zone_avg = img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3].mean() - elif filter_type == 'biquad2d': - detection_zone_avg = abs(bq.process(img.mean)) - elif filter_type == 'biquad': - detection_zone_avg = abs(bq.process(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3].mean())) - elif filter_type == 'center_of_mass': - center = ndimage.measurements.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - if len(sliding_window) > 30: - mean[0] = utils.mean_arr(sliding_window) - sliding_window.clear() - else: - sliding_window.append(detection_zone_avg) - - if mean[0] is not None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -def on_new_frame(cv_mat, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - width, height = img_pil.size - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if is_good_frame: - # NOTE: Teachable Machine 2 works on images of size 224x224 and will resize all inputs - # to that size. so we have to make sure our edgetpu converted model is fed similar images. - if (width, height) != (224, 224): - img_pil = img_pil.resize((224, 224)) - - if mode == 'train': - message = dict() - message['image'] = format_img_tm2(cv_mat) - message['shouldTakePicture'] = True - send_over_ws(message, cam_sockets) - # time.sleep(0.25) NOTE: debounce this at a rate depending on your singulation rate - - elif mode == 'sort': - classify.set_input(interpreter, img_pil) - interpreter.invoke() - classes = classify.get_classes(interpreter, top_k=1) - print(classes) - if classes and classes[0].id == 0 and classes[0].score > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - # Here you can actuate the sorting end-effector through GPIO, etc. - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - # Start the tornado websocket server - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=CameraWebsocketHandler.start_server, args=(new_loop, cam_sockets, )) - server_thread.start() - - interpreter = make_interpreter(model_path) - interpreter.allocate_tensors() - - if args.will_sort: - mode = "sort" - else: - mode = "train" - - # Parse filter type - if args.zone: filter_type = 'zone' - elif args.biquad: filter_type = 'biquad' - elif args.biquad2d: filter_type = 'biquad2d' - elif args.center_of_mass: filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if args.flir: - import FLIR - print("Initializing Flir Camera") - cam = FLIR.FlirBFS(on_new_frame=partial(on_new_frame, interpreter=interpreter, mean=mean, sliding_window=sliding_window, - send_over_ws=send_over_ws, cam_sockets=cam_sockets), - display=True, frame_rate=120) - cam.run_cam() - elif args.arducam: - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(0) - while cap.isOpened(): - ret, frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromarray(cv2_im) - pil_im = pil_im.resize((224, 224)) - pil_im = pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(cv2_im, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xff == ord('q'): - break - cap.release() - cv2.destroyAllWindows() - print('Initializing opencv Video Stream') diff --git a/old/updatet3.py b/old/updatet3.py deleted file mode 100644 index 49b82bc4..00000000 --- a/old/updatet3.py +++ /dev/null @@ -1,199 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from utils import CameraWebsocketHandler -from utils.BiQuad import BiQuadFilter -from functools import partial -from PIL import Image -from scipy import ndimage -import threading -import asyncio -import base64 -import utils -import cv2 -import argparse -import sys - -# Debugging -import sys -print("Python Executable:", sys.executable) -print("Python Path:", sys.path) - -try: - import tornado - print("Tornado module imported successfully") -except ImportError as e: - print(f"Import error: {e}") - -# Ensure required packages are imported correctly -try: - from pycoral.adapters import classify - from pycoral.utils.edgetpu import make_interpreter - from pycoral.adapters.common import input_size -except ImportError: - print("Error: pycoral module not found. Ensure you have installed pycoral correctly.") - sys.exit(1) - -try: - import RPi.GPIO as GPIO -except ImportError: - print("Error: RPi.GPIO module not found. Ensure you have installed RPi.GPIO correctly.") - sys.exit(1) - -# Path to edgetpu compatible model -model_path = '../model.tflite' - -# NOTE: can either be 'train' to classify images using edgetpu or 'sort' to just send images to TM2 -mode = "sort" -sendPin = 7 -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(sendPin, GPIO.OUT, initial=GPIO.LOW) -filter_type = 'zone' -# biquad params: type, Fc, Q, peakGainDB -bq = BiQuadFilter('band', 0.1, 0.707, 0.0) - -def send_over_ws(msg, cam_sockets): - for ws in cam_sockets: - ws.write_message(msg) - -def format_img_tm2(cv_mat): - ret, buf = cv2.imencode('.jpg', cv_mat) - encoded = base64.b64encode(buf) - return encoded.decode('ascii') - -def is_good_photo(img, width, height, mean, sliding_window): - detection_zone_height = 20 - detection_zone_interval = 5 - threshold = 4.5 - - if filter_type == 'zone': - detection_zone_avg = img[height // 2 : (height // 2) + detection_zone_height : detection_zone_interval, 0:-1:3].mean() - elif filter_type == 'biquad2d': - detection_zone_avg = abs(bq.process(img.mean())) - elif filter_type == 'biquad': - detection_zone_avg = abs(bq.process(img[height // 2: (height // 2) + detection_zone_height: detection_zone_interval, 0:-1:3].mean())) - elif filter_type == 'center_of_mass': - center = ndimage.measurements.center_of_mass(img) - detection_zone_avg = (center[0] + center[1]) / 2 - - if len(sliding_window) > 30: - mean[0] = utils.mean_arr(sliding_window) - sliding_window.clear() - else: - sliding_window.append(detection_zone_avg) - - if mean[0] is not None and abs(detection_zone_avg - mean[0]) > threshold: - print("Target Detected Taking Picture") - return True - - return False - -def on_new_frame(cv_mat, interpreter, mean, sliding_window, send_over_ws, cam_sockets): - img_pil = Image.fromarray(cv_mat) - width, height = img_pil.size - is_good_frame = is_good_photo(cv_mat, width, height, mean, sliding_window) - if is_good_frame: - # NOTE: Teachable Machine 2 works on images of size 224x224 and will resize all inputs - # to that size. so we have to make sure our edgetpu converted model is fed similar images. - if (width, height) != (224, 224): - img_pil = img_pil.resize((224, 224)) - - if mode == 'train': - message = dict() - message['image'] = format_img_tm2(cv_mat) - message['shouldTakePicture'] = True - send_over_ws(message, cam_sockets) - # time.sleep(0.25) NOTE: debounce this at a rate depending on your singulation rate - - elif mode == 'sort': - classify.set_input(interpreter, img_pil) - interpreter.invoke() - classes = classify.get_classes(interpreter, top_k=1) - print(classes) - if classes and classes[0].id == 0 and classes[0].score > 0.95: - GPIO.output(sendPin, GPIO.HIGH) - else: - GPIO.output(sendPin, GPIO.LOW) - # Here you can actuate the sorting end-effector through GPIO, etc. - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - mode_parser = parser.add_mutually_exclusive_group(required=False) - mode_parser.add_argument('--train', dest='will_sort', action='store_false') - mode_parser.add_argument('--sort', dest='will_sort', action='store_true') - - filter_parse = parser.add_mutually_exclusive_group(required=False) - filter_parse.add_argument('--zone-activation', dest='zone', action='store_true') - filter_parse.add_argument('--biquad', dest='biquad', action='store_true') - filter_parse.add_argument('--biquad2d', dest='biquad2d', action='store_true') - filter_parse.add_argument('--center-of-mass', dest='center_of_mass', action='store_true') - - camera_parse = parser.add_mutually_exclusive_group(required=False) - camera_parse.add_argument('--flir', dest='flir', action='store_true') - camera_parse.add_argument('--opencv', dest='opencv', action='store_true') - camera_parse.add_argument('--arducam', dest='arducam', action='store_true') - - parser.set_defaults(will_sort=True) - args = parser.parse_args() - - # Start the tornado websocket server - cam_sockets = [] - new_loop = asyncio.new_event_loop() - server_thread = threading.Thread(target=CameraWebsocketHandler.start_server, args=(new_loop, cam_sockets, )) - server_thread.start() - - interpreter = make_interpreter(model_path) - interpreter.allocate_tensors() - - if args.will_sort: - mode = "sort" - else: - mode = "train" - - # Parse filter type - if args.zone: filter_type = 'zone' - elif args.biquad: filter_type = 'biquad' - elif args.biquad2d: filter_type = 'biquad2d' - elif args.center_of_mass: filter_type = 'center_of_mass' - - mean = [None] - sliding_window = [] - - if args.flir: - import FLIR - print("Initializing Flir Camera") - cam = FLIR.FlirBFS(on_new_frame=partial(on_new_frame, interpreter=interpreter, mean=mean, sliding_window=sliding_window, - send_over_ws=send_over_ws, cam_sockets=cam_sockets), - display=True, frame_rate=120) - cam.run_cam() - elif args.arducam: - raise Exception("Arducam Support Coming") - else: - cap = cv2.VideoCapture(20) - while cap.isOpened(): - ret, frame = cap.read() - if not ret: - break - cv2_im = frame - pil_im = Image.fromarray(cv2_im) - pil_im = pil_im.resize((224, 224)) - pil_im = pil_im.transpose(Image.FLIP_LEFT_RIGHT) - cv2.imshow('frame', cv2_im) - on_new_frame(cv2_im, interpreter, mean, sliding_window, send_over_ws, cam_sockets) - if cv2.waitKey(1) & 0xff == ord('q'): - break - cap.release() - cv2.destroyAllWindows() - print('Initializing opencv Video Stream') diff --git a/pipeline.config b/pipeline.config new file mode 100644 index 00000000..5693ee49 --- /dev/null +++ b/pipeline.config @@ -0,0 +1,185 @@ +model { + ssd { + num_classes: 4 + image_resizer { + fixed_shape_resizer { + height: 300 + width: 300 + } + } + feature_extractor { + type: "ssd_mobilenet_v2_keras" + depth_multiplier: 1.0 + min_depth: 16 + conv_hyperparams { + regularizer { + l2_regularizer { + weight: 4e-05 + } + } + initializer { + truncated_normal_initializer { + mean: 0.0 + stddev: 0.03 + } + } + activation: RELU_6 + batch_norm { + decay: 0.97 + center: true + scale: true + epsilon: 0.001 + } + } + override_base_feature_extractor_hyperparams: true + } + box_coder { + faster_rcnn_box_coder { + y_scale: 10.0 + x_scale: 10.0 + height_scale: 5.0 + width_scale: 5.0 + } + } + matcher { + argmax_matcher { + matched_threshold: 0.5 + unmatched_threshold: 0.5 + ignore_thresholds: false + negatives_lower_than_unmatched: true + force_match_for_each_row: true + use_matmul_gather: true + } + } + similarity_calculator { + iou_similarity { + } + } + box_predictor { + convolutional_box_predictor { + conv_hyperparams { + regularizer { + l2_regularizer { + weight: 4e-05 + } + } + initializer { + random_normal_initializer { + mean: 0.0 + stddev: 0.01 + } + } + activation: RELU_6 + batch_norm { + decay: 0.97 + center: true + scale: true + epsilon: 0.001 + } + } + min_depth: 0 + max_depth: 0 + num_layers_before_predictor: 0 + use_dropout: false + dropout_keep_probability: 0.8 + kernel_size: 1 + box_code_size: 4 + apply_sigmoid_to_scores: false + class_prediction_bias_init: -4.6 + } + } + anchor_generator { + ssd_anchor_generator { + num_layers: 6 + min_scale: 0.2 + max_scale: 0.95 + aspect_ratios: 1.0 + aspect_ratios: 2.0 + aspect_ratios: 0.5 + aspect_ratios: 3.0 + aspect_ratios: 0.3333 + } + } + post_processing { + batch_non_max_suppression { + score_threshold: 0.3 + iou_threshold: 0.6 + max_detections_per_class: 100 + max_total_detections: 100 + } + score_converter: SIGMOID + } + normalize_loss_by_num_matches: true + loss { + localization_loss { + weighted_smooth_l1 { + } + } + classification_loss { + weighted_sigmoid_focal { + gamma: 2.0 + alpha: 0.75 + } + } + classification_weight: 1.0 + localization_weight: 1.0 + } + encode_background_as_zeros: true + normalize_loc_loss_by_codesize: true + inplace_batchnorm_update: true + freeze_batchnorm: false + } +} +train_config { + batch_size: 16 + data_augmentation_options { + random_horizontal_flip { + } + } + data_augmentation_options { + ssd_random_crop { + } + } + sync_replicas: true + optimizer { + momentum_optimizer { + learning_rate { + cosine_decay_learning_rate { + learning_rate_base: 0.05 + total_steps: 50000 + warmup_learning_rate: 0.01 + warmup_steps: 2000 + } + } + momentum_optimizer_value: 0.9 + } + use_moving_average: false + } + fine_tune_checkpoint: "models/pretrained/ssd_mobilenet_v2_320x320_coco17_tpu-8/checkpoint/ckpt-0" + num_steps: 50000 + startup_delay_steps: 0.0 + replicas_to_aggregate: 8 + max_number_of_boxes: 100 + unpad_groundtruth_tensors: false + fine_tune_checkpoint_type: "detection" + fine_tune_checkpoint_version: V2 +} +train_input_reader { + label_map_path: "label_map.pbtxt" + tf_record_input_reader { + input_path: "dataset/train.record" + } +} +eval_config { + num_examples: 100 + metrics_set: "coco_detection_metrics" + use_moving_averages: false +} +eval_input_reader { + label_map_path: "label_map.pbtxt" + shuffle: false + num_readers: 1 + tf_record_input_reader { + input_path: "dataset/val.record" + } +} diff --git a/python3.10.sh b/python3.10.sh deleted file mode 100644 index 40f57492..00000000 --- a/python3.10.sh +++ /dev/null @@ -1,12 +0,0 @@ -#bin/bash! -screen -mds python10 -cd /home/pi/project-teachable-sorter - -export SPINNAKER_GENTL64_CTI=/opt/spinnaker/lib/spinnaker-gentl/Spinnaker_GenTL.cti - -source py3.10/bin/activate - -cd Sorter - -python capture_process.py - diff --git a/requirements-3.10.txt b/requirements-3.10.txt new file mode 100644 index 00000000..27509c39 --- /dev/null +++ b/requirements-3.10.txt @@ -0,0 +1,7 @@ +numpy<2 +Pillow +opencv-python +# Wheels from https://github.com/cappittall/pycoral_whl_4_python3.10/tree/main/tools +# Install manually: +# pip install ./tflite_runtime-2.5.0.post1-cp310-cp310-linux_x86_64.whl +# pip install ./pycoral-2.0.0-cp310-cp310-linux_x86_64.whl diff --git a/requiremetns_freeze.txt b/requiremetns_freeze.txt deleted file mode 100644 index 1ef73d68..00000000 --- a/requiremetns_freeze.txt +++ /dev/null @@ -1,43 +0,0 @@ -anyjson==0.3.3 -area==1.1.1 -attrs==24.1.0 -certifi==2024.7.4 -charset-normalizer==3.3.2 -click==8.1.7 -click-plugins==1.1.1 -cligj==0.7.2 -fiona==1.9.6 -futures==3.0.5 -geopandas==1.0.1 -httplib2==0.22.0 -idna==3.7 -importlib_metadata==8.2.0 -lgpio==0.2.2.0 -numpy==1.26.4 -opencv-python==4.10.0.84 -opencv-python-headless==4.10.0.84 -packaging==24.1 -pandas==2.2.2 -pillow==10.4.0 -progressbar2==4.4.2 -pycoral==2.0.0 -pyogrio==0.9.0 -pyparsing==3.1.4 -pypin==0.1a1 -pyproj==3.6.1 -python-dateutil==2.9.0.post0 -python-utils==3.8.2 -pytz==2024.1 -requests==2.32.3 -rpi-lgpio==0.6 -RPi.GPIO==0.7.1 -scipy==1.13.1 -shapely==2.0.5 -six==1.16.0 -tenacity==9.0.0 -tflite-runtime==2.5.0.post1 -tornado==6.4.1 -typing_extensions==4.12.2 -tzdata==2024.1 -urllib3==2.2.2 -zipp==3.19.2 diff --git a/sensor/.dockerignore b/sensor/.dockerignore new file mode 100644 index 00000000..e8ef23b4 --- /dev/null +++ b/sensor/.dockerignore @@ -0,0 +1,10 @@ +*.jpg +*.png +spinnaker_sdk +spinnaker_sdk/* +spinnaker_python +spinnaker_python/* +out +out/* +.venv* +__pycache__/ \ No newline at end of file diff --git a/sensor/.gitignore b/sensor/.gitignore new file mode 100644 index 00000000..8f03246a --- /dev/null +++ b/sensor/.gitignore @@ -0,0 +1,7 @@ +*.jpg +*.png +spinnaker_sdk +spinnaker_sdk/* +spinnaker_python +spinnaker_python/* +*.tar.gz \ No newline at end of file diff --git a/sensor/.python-version b/sensor/.python-version new file mode 100644 index 00000000..44677e5c --- /dev/null +++ b/sensor/.python-version @@ -0,0 +1 @@ +3.10.20 diff --git a/sensor/README.md b/sensor/README.md new file mode 100644 index 00000000..52b972e9 --- /dev/null +++ b/sensor/README.md @@ -0,0 +1,128 @@ +# Information about the Actuator module. +This folder contains the code for the Sensors. The sensors are responsible for collecting data from the sorter. It includes code for: +- FLIR camera (500FPS) +- Light beam sensor + +# Installation + +## Docker +Downloade the python and the sdk version of the Spinnaker SDK from the following link: + +https://www.teledynevisionsolutions.com/support/support-center/software-firmware-downloads/iis/spinnaker-sdk-download/spinnaker-sdk--download-files/?pn=Spinnaker+SDK&vn=Spinnaker+SDK + +There should be two files: +- For x64 (PCs): +- - (Linux Ubuntu 22.04 -- 64-bit) 'spinnaker-4.3.0.189-Ubuntu22.04-amd64-pkg.tar.gz' +- - (Linux Ubuntu 22.04 -- 64-bit Python 3.10) 'spinnaker_python-4.3.0.189-cp310-cp310-linux_x86_64.tar.gz' + +```bash +sudo docker build -t sorter-actuator . +sudo docker run -it --rm \ + --privileged \ + -v /dev/bus/usb:/dev/bus/usb \ + -v $(pwd)/out:/app/out \ + --shm-size=2g \ + sorter-actuator +``` + +## DEV +```bash +sudo apt update +sudo apt install -y \ + udev \ + ethtool \ + libusb-1.0-0 \ + iproute2 \ + iputils-ping \ + net-tools \ + build-essential \ + libssl-dev \ + zlib1g-dev \ + libbz2-dev \ + libreadline-dev \ + libsqlite3-dev \ + curl \ + git \ + libncursesw5-dev \ + xz-utils \ + tk-dev \ + libxml2-dev \ + libxmlsec1-dev \ + libffi-dev \ + liblzma-dev \ + libgl1 \ + libglib2.0-0 \ + ffmpeg + +curl https://pyenv.run | bash + +echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc +echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc +echo 'eval "$(pyenv init -)"' >> ~/.bashrc +export PYENV_ROOT="$HOME/.pyenv" +command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH" +eval "$(pyenv init -)" + +pyenv install 3.10.20 + +pyenv local 3.10.20 +``` + +```bash +python3.10 -m venv .venv-3.10 +source .venv-3.10/bin/activate +export SPINNAKER_GENTL64_CTI=/opt/spinnaker/lib/spinnaker-gentl/Spinnaker_GenTL.cti +pip install -r requirements-3.10.txt +``` +--- + +Downloade the python and the sdk version of the Spinnaker SDK from the following link: + +https://www.teledynevisionsolutions.com/support/support-center/software-firmware-downloads/iis/spinnaker-sdk-download/spinnaker-sdk--download-files/?pn=Spinnaker+SDK&vn=Spinnaker+SDK + +There should be two files: +- For ARM (Raspberry PIs): +- - (Linux Ubuntu 22.04 --ARM64) 'spinnaker-4.3.0.189-Ubuntu22.04-arm64-pkg.tar.gz' +- - (Linux Ubuntu 22.04 -- ARM64 Python 3.10) 'spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.tar.gz' + +```bash +mkdir -p spinnaker_sdk spinnaker_python +tar -xzvf spinnaker-4.3.0.189-Ubuntu22.04-arm64-pkg.tar.gz -C spinnaker_sdk +tar -xzvf spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.tar.gz -C spinnaker_python + +cd spinnaker_sdk/spinnaker-4.3.0.189-arm64/ +./install_spinnaker_arm.sh + +cd ../../spinnaker_python +pip3 install spinnaker_python-4.3.0.189-cp310-cp310-linux_aarch64.whl + +cd .. +rm -rf spinnaker_python spinnaker_sdk +``` + +--- + +- For x64 (PCs): +- - (Linux Ubuntu 22.04 -- 64-bit) 'spinnaker-4.3.0.189-Ubuntu22.04-amd64-pkg.tar.gz' +- - (Linux Ubuntu 22.04 -- 64-bit Python 3.10) 'spinnaker_python-4.3.0.189-cp310-cp310-linux_x86_64.tar.gz' + +```bash +mkdir -p spinnaker_sdk spinnaker_python +tar -xzvf spinnaker-4.3.0.189-Ubuntu22.04-amd64-pkg.tar.gz -C spinnaker_sdk +tar -xzvf spinnaker_python-4.3.0.189-cp310-cp310-linux_x86_64.tar.gz -C spinnaker_python + +cd spinnaker_sdk/spinnaker-4.3.0.189-amd64/ +./install_spinnaker.sh + +cd ../../spinnaker_python +pip3 install spinnaker_python-4.3.0.189-cp310-cp310-linux_x86_64.whl + +cd .. +rm -rf spinnaker_python spinnaker_sdk +``` + +# Usage + +```bash +sudo .venv-3.10/bin/python [script].py +``` \ No newline at end of file diff --git a/sensor/camera.py b/sensor/camera.py new file mode 100644 index 00000000..daa5755a --- /dev/null +++ b/sensor/camera.py @@ -0,0 +1,187 @@ +import cv2 +import PySpin # type: ignore +import numpy as np +import time +import psutil +import os +from typing import Optional + +class Camera: + def __init__(self, index: int = 0) -> None: + self.system = PySpin.System.GetInstance() + self.cam_list = self.system.GetCameras() + self.camera: Optional[PySpin.CameraPtr] = None + + if self.cam_list.GetSize() == 0: + print("No cameras detected.") + self.release_system() + return + + self.camera = self.cam_list.GetByIndex(index) + self.camera.Init() + self.camera.AcquisitionMode.SetValue(PySpin.AcquisitionMode_Continuous) + + def flush_image_queue(self, timeout_ms: int = 1, max_images: int = 256) -> int: + """Discard all currently buffered images from the active acquisition stream.""" + if not self.camera: + return 0 + + flushed_count = 0 + + while flushed_count < max_images: + try: + image_result = self.camera.GetNextImage(timeout_ms) + except PySpin.SpinnakerException: + break + + image_result.Release() + flushed_count += 1 + + return flushed_count + + def stream_for_duration(self, duration_sec: int): + """Yields raw frames sequentially as fast as possible for a set duration.""" + if not self.camera: + print("Camera not initialized.") + return + + try: + # Only keep the most recent frame; the SDK drops older buffered + # images automatically. This prevents processing stale frames of a + # marble that has already been classified. + s_node_map = self.camera.GetTLStreamNodeMap() + handling_mode = PySpin.CEnumerationPtr( + s_node_map.GetNode("StreamBufferHandlingMode") + ) + if PySpin.IsAvailable(handling_mode) and PySpin.IsWritable(handling_mode): + newest_only = handling_mode.GetEntryByName("NewestOnly") + handling_mode.SetIntValue(newest_only.GetValue()) + + self.camera.BeginAcquisition() + + start_time = time.perf_counter() + end_time = start_time + duration_sec + + while time.perf_counter() < end_time: + try: + # Grab image + image_result = self.camera.GetNextImage(1000) + + if not image_result.IsIncomplete(): + # Yield the reference directly to save memory. + # The caller MUST process it or copy it before the loop continues. + yield image_result.GetNDArray() + + # Release the buffer immediately so the camera can capture the next frame + image_result.Release() + + except PySpin.SpinnakerException as ex: + print(f"Spinnaker Exception during capture: {ex}") + break + + except Exception as e: + print(f"Error capturing sequence: {e}") + + finally: + self.camera.EndAcquisition() + + def release_camera(self) -> None: + """Releases the camera resources.""" + if self.camera: + self.camera.DeInit() + del self.camera + self.camera = None + + self.cam_list.Clear() + self.release_system() + + def release_system(self) -> None: + """Releases the PySpin system instance.""" + self.system.ReleaseInstance() + + def unlock_max_framerate(self) -> None: + """Configures the camera to shoot as fast as possible.""" + if not self.camera: + return + + try: + if self.camera.ExposureAuto.GetAccessMode() == PySpin.RW: + self.camera.ExposureAuto.SetValue(PySpin.ExposureAuto_Off) + + if self.camera.ExposureTime.GetAccessMode() == PySpin.RW: + exposure_time = min(1000.0, self.camera.ExposureTime.GetMax()) + self.camera.ExposureTime.SetValue(exposure_time) + + if self.camera.AcquisitionFrameRateEnable.GetAccessMode() == PySpin.RW: + self.camera.AcquisitionFrameRateEnable.SetValue(False) + + try: + throughput_node = self.camera.DeviceLinkThroughputLimit + if throughput_node.GetAccessMode() == PySpin.RW: + max_bandwidth = throughput_node.GetMax() + throughput_node.SetValue(max_bandwidth) + except PySpin.SpinnakerException: + pass + + print(f"Exposure set to {self.camera.ExposureTime.GetValue()} us. Framerate unlocked.") + + except PySpin.SpinnakerException as ex: + print(f"Error unlocking framerate: {ex}") + + def print_camera_info(self) -> None: + """Prints the model and serial number of the initialized camera.""" + if not self.camera: + return + + try: + nodemap_tldevice = self.camera.GetTLDeviceNodeMap() + vendor_node = PySpin.CStringPtr(nodemap_tldevice.GetNode("DeviceVendorName")) + vendor = vendor_node.GetValue() if PySpin.IsReadable(vendor_node) else "Unknown Vendor" + model_node = PySpin.CStringPtr(nodemap_tldevice.GetNode("DeviceModelName")) + model = model_node.GetValue() if PySpin.IsReadable(model_node) else "Unknown Model" + print(f"Camera detected: {vendor} {model}") + except PySpin.SpinnakerException as ex: + print(f"Error reading camera info: {ex}") + + +if __name__ == "__main__": + cam = Camera() + cam.print_camera_info() + cam.unlock_max_framerate() + + test_duration = 5 + + print(f"Starting {test_duration}-second capture stress test...") + process = psutil.Process(os.getpid()) + mem_before = process.memory_info().rss / (1024 * 1024) + + start_time = time.perf_counter() + video_frames = [] + + # Updated to consume the generator + for frame in cam.stream_for_duration(test_duration): + video_frames.append(frame.copy()) + + actual_duration = time.perf_counter() - start_time + mem_after = process.memory_info().rss / (1024 * 1024) + + frame_count = len(video_frames) + fps = frame_count / actual_duration if actual_duration > 0 else 0 + mem_used = mem_after - mem_before + + print("\n" + "="*30) + print(" TEST RESULTS") + print("="*30) + print(f"Actual Duration : {actual_duration:.3f} seconds") + print(f"Frames Captured : {frame_count} frames") + print(f"Actual FPS : {fps:.2f} FPS") + print(f"Total RAM Used : ~{mem_used:.2f} MB") + print("="*30 + "\n") + + if frame_count > 0: + first_frame_rgb = cv2.cvtColor(video_frames[0], cv2.COLOR_BAYER_RG2RGB) + last_frame_rgb = cv2.cvtColor(video_frames[-1], cv2.COLOR_BAYER_RG2RGB) + cv2.imwrite("./out/first_frame.png", first_frame_rgb) + cv2.imwrite("./out/last_frame.png", last_frame_rgb) + + cam.release_camera() \ No newline at end of file diff --git a/sensor/dockerfile b/sensor/dockerfile new file mode 100644 index 00000000..c2ac8d5a --- /dev/null +++ b/sensor/dockerfile @@ -0,0 +1,136 @@ +# Use Ubuntu 22.04 as the base image +FROM ubuntu:22.04 + +# Expose the architecture argument provided by Docker +ARG TARGETARCH + +# Prevent interactive prompts from apt +ENV DEBIAN_FRONTEND=noninteractive + +# Install prerequisite system packages +RUN apt-get update && apt-get install -y \ + python3.10 \ + python3.10-venv \ + python3.10-dev \ + python3-pip \ + sudo \ + udev \ + ethtool \ + libusb-1.0-0 \ + libswscale5 \ + libavcodec58 \ + libavformat58 \ + iproute2 \ + iputils-ping \ + net-tools \ + build-essential \ + libssl-dev \ + zlib1g-dev \ + libbz2-dev \ + libreadline-dev \ + libsqlite3-dev \ + curl \ + git \ + libncursesw5-dev \ + xz-utils \ + tk-dev \ + libxml2-dev \ + libxmlsec1-dev \ + libffi-dev \ + liblzma-dev \ + libgl1 \ + libglib2.0-0 \ + ffmpeg \ + && rm -rf /var/lib/apt/lists/* + +# --- DOCKER WORKAROUNDS FOR HARDWARE SDKS --- + +# 1. logname: Spinnaker post-install scripts use this to find the home directory. +RUN echo '#!/bin/sh\necho root' > /usr/bin/logname && chmod +x /usr/bin/logname + +# 2. udevadm & systemctl: Docker doesn't run udevd or systemd. +RUN dpkg-divert --local --rename --add /sbin/udevadm && ln -s /bin/true /sbin/udevadm +RUN dpkg-divert --local --rename --add /bin/udevadm && ln -s /bin/true /bin/udevadm +RUN dpkg-divert --local --rename --add /bin/systemctl && ln -s /bin/true /bin/systemctl + +# -------------------------------------------- + +# Set up a temporary working directory for the installation +WORKDIR /tmp/spinnaker_install + +# Copy ALL tarballs using wildcards. +# Wildcards prevent Docker from failing if you only have one architecture's files downloaded. +COPY spinnaker-4.3.0.189-Ubuntu22.04-*-pkg.tar.gz ./ +COPY spinnaker_python-4.3.0.189-cp310-cp310-linux_*.tar.gz ./ + +# Detect architecture, map to Spinnaker's naming conventions, and extract the correct files +RUN if [ "$TARGETARCH" = "amd64" ]; then \ + SDK_ARCH="amd64"; \ + PY_ARCH="x86_64"; \ + elif [ "$TARGETARCH" = "arm64" ]; then \ + SDK_ARCH="arm64"; \ + PY_ARCH="aarch64"; \ + else \ + echo "Unsupported architecture: $TARGETARCH"; \ + exit 1; \ + fi && \ + echo "Building for architecture: $TARGETARCH (SDK: $SDK_ARCH, Python: $PY_ARCH)" && \ + mkdir spinnaker_sdk spinnaker_python && \ + tar -xzvf spinnaker-4.3.0.189-Ubuntu22.04-${SDK_ARCH}-pkg.tar.gz -C spinnaker_sdk --strip-components=1 && \ + tar -xzvf spinnaker_python-4.3.0.189-cp310-cp310-linux_${PY_ARCH}.tar.gz -C spinnaker_python && \ + # Clean up the original tarballs immediately so they don't permanently bloat the Docker image layer + rm -f *.tar.gz + +WORKDIR /tmp/spinnaker_install/spinnaker_sdk + +# 3. The FLIR EULA Exit 30 Fix +RUN for deb in ./*.deb; do \ + echo "Patching $deb..." && \ + dpkg-deb -R "$deb" tmp_dir && \ + if [ -f tmp_dir/DEBIAN/preinst ]; then \ + echo '#!/bin/sh' > tmp_dir/DEBIAN/preinst && \ + echo 'exit 0' >> tmp_dir/DEBIAN/preinst && \ + chmod +x tmp_dir/DEBIAN/preinst; \ + fi && \ + dpkg-deb -b tmp_dir "$deb" && \ + rm -rf tmp_dir; \ + done + +# Install the patched Spinnaker C/C++ SDK packages. +RUN apt-get update && apt-get install -y ./*.deb && rm -rf /var/lib/apt/lists/* + +# Run the post-installation configuration scripts. +RUN sh configure_spinnaker_paths.sh && \ + sh configure_gentl_paths.sh 64 + +# --- PYTHON APPLICATION SETUP --- + +# Set a clean working directory for your application code +WORKDIR /app + +# Create and activate the Python 3.10 virtual environment +ENV VIRTUAL_ENV=/app/.venv-3.10 +RUN python3.10 -m venv $VIRTUAL_ENV +ENV PATH="$VIRTUAL_ENV/bin:$PATH" + +# Install the Spinnaker Python SDK Wheel inside the venv +WORKDIR /tmp/spinnaker_install/spinnaker_python +RUN pip install --no-cache-dir spinnaker_python*.whl + +# Clean up the temporary installation files to keep the image size small +WORKDIR / +RUN rm -rf /tmp/spinnaker_install + +# Copy requirements file and install Python dependencies +WORKDIR /app +COPY requirements-3.10.txt . +RUN pip install --no-cache-dir -r requirements-3.10.txt + +# Restore the GenTL path required by the Python SDK +ENV SPINNAKER_GENTL64_CTI=/opt/spinnaker/lib/spinnaker-gentl/Spinnaker_GenTL.cti + +# Copy the rest of the application code +COPY . . + +# Default command +CMD ["python3.10", "camera.py"] \ No newline at end of file diff --git a/sensor/light_beam.py b/sensor/light_beam.py new file mode 100644 index 00000000..93ec6439 --- /dev/null +++ b/sensor/light_beam.py @@ -0,0 +1,60 @@ +from gpiozero import MCP3008 +import time +from datetime import datetime + +sensor = MCP3008(channel=0) + +THRESHOLD_ON = 0.610 +THRESHOLD_OFF = 0.580 +REQUIRED_HITS = 2 + +def light_beam_test() -> None: + print("Light beam test started... (press Ctrl+C to stop)") + print("Hold your hand in front of the sensor!") + time.sleep(1) + + object_detected = False + hit_count = 0 + + log_file = open("detection_log.txt", "w") + start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + log_file.write(f"--- New test started at {start_time} ---\n") + + try: + while True: + sensor_value = sensor.value + timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3] + + if sensor_value < THRESHOLD_OFF: + hit_count = 0 + + if object_detected: + message = f"[{timestamp}] Sensor value: {sensor_value:.3f} Object left" + print(message) + log_file.write(message + "\n") + log_file.flush() + object_detected = False + + elif sensor_value > THRESHOLD_ON: + hit_count += 1 + + if hit_count >= REQUIRED_HITS and not object_detected: + message = f"[{timestamp}] Sensor value: {sensor_value:.3f} Real object detected" + print(message) + log_file.write(message + "\n") + log_file.flush() + object_detected = True + + time.sleep(0.001) + + except KeyboardInterrupt: + abort_time = datetime.now().strftime("%H:%M:%S.%f")[:-3] + print(f"\n[{abort_time}] Test cancelled by user.") + + finally: + log_file.write("--- Test finished ---\n") + log_file.close() + print("Log file saved and closed successfully.") + +if __name__ == "__main__": + light_beam_test() diff --git a/sensor/light_beam_2.py b/sensor/light_beam_2.py new file mode 100644 index 00000000..5a9b9e70 --- /dev/null +++ b/sensor/light_beam_2.py @@ -0,0 +1,88 @@ +from gpiozero import MCP3008 +import time +from datetime import datetime + +sensor = MCP3008(channel=0) + +def light_beam_test() -> None: + print("Light beam test started...") + time.sleep(1) + + safe_log_file = open("safe_detection_log.txt", "w") + unsafe_log_file = open("unsafe_detection_log.txt", "w") + start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + safe_log_file.write(f"--- New test started at {start_time} ---\n") + unsafe_log_file.write(f"--- New test started at {start_time} ---\n") + + lower_threshold = 0.550 + upper_threshold = 0.625 + + detection_limit = 5 + + unsafe_detections_below = 0 + unsafe_detections_above = 0 + + safe_detections_below = 0 + safe_detections_above = 0 + + object_is_below = False + object_is_above = False + + try: + while True: + sensor_value = sensor.value + timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3] + + if sensor_value < lower_threshold: + unsafe_detections_below += 1 + + message = f"[{timestamp}] Sensor value: {sensor_value:.3f} - Unsafe below: {unsafe_detections_below}" + unsafe_log_file.write(message + "\n") + unsafe_log_file.flush() + + if unsafe_detections_below >= detection_limit: + safe_detections_below += 1 + unsafe_detections_below = 0 + safe_message = f"[{timestamp}] Sensor value: {sensor_value:.3f} - Unsafe below: {unsafe_detections_below} - Safe below: {safe_detections_below}x" + print(safe_message) + safe_log_file.write(safe_message + "\n") + safe_log_file.flush() + + elif sensor_value > upper_threshold: + unsafe_detections_above += 1 + + message = f"[{timestamp}] Sensor value: {sensor_value:.3f} - Unsafe above: {unsafe_detections_above}" + unsafe_log_file.write(message + "\n") + unsafe_log_file.flush() + + if unsafe_detections_above >= detection_limit: + safe_detections_above += 1 + unsafe_detections_above = 0 + + safe_message = f"[{timestamp}] Sensor value: {sensor_value:.3f} - Unsafe above: {unsafe_detections_above} - Safe above: {safe_detections_above}x" + print(safe_message) + safe_log_file.write(safe_message + "\n") + safe_log_file.flush() + + else: + unsafe_detections_below = 0 + unsafe_detections_above = 0 + + message = f"[{timestamp}] Sensor value: {sensor_value:.3f} - NONE - Unsafe below: {unsafe_detections_below} - Safe below: {safe_detections_below}x - Unsafe above: {unsafe_detections_above} - Safe above: {safe_detections_above}x" + print(message) + + time.sleep(0.001) + + except KeyboardInterrupt: + abort_time = datetime.now().strftime("%H:%M:%S.%f")[:-3] + print(f"\n[{abort_time}] Test cancelled by user.") + + finally: + safe_log_file.write("--- Test finished ---\n") + safe_log_file.close() + unsafe_log_file.write("--- Test finished ---\n") + unsafe_log_file.close() + print("Log files saved and closed successfully.") + +if __name__ == "__main__": + light_beam_test() diff --git a/sensor/out/.gitignore b/sensor/out/.gitignore new file mode 100644 index 00000000..f399bdec --- /dev/null +++ b/sensor/out/.gitignore @@ -0,0 +1,2 @@ +*.png +*.jpg \ No newline at end of file diff --git a/sensor/requirements-3.10.txt b/sensor/requirements-3.10.txt new file mode 100644 index 00000000..559c2065 --- /dev/null +++ b/sensor/requirements-3.10.txt @@ -0,0 +1,6 @@ +mypy +opencv-python +numpy==1.26.4 +gpiozero +spidev +psutil \ No newline at end of file diff --git a/socketserial.py b/socketserial.py deleted file mode 100644 index b2813cee..00000000 --- a/socketserial.py +++ /dev/null @@ -1,31 +0,0 @@ -import serial -import socket -import threading - -# Serial-Port einrichten -ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) - -# Socket-Server einrichten -server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -server_socket.bind(('localhost', 65432)) -server_socket.listen() - -def handle_client(client_socket): - while True: - # Lesen von seriellen Daten und an den Client weiterleiten - if ser.in_waiting > 0: - data = ser.readline().decode('utf-8').strip() - client_socket.sendall(data.encode('utf-8')) - # Daten vom Client empfangen und an die serielle Schnittstelle senden - try: - client_data = client_socket.recv(1024).decode('utf-8') - ser.write(client_data.encode('utf-8')) - except ConnectionResetError: - break - -print("Server läuft...") -while True: - client_sock, addr = server_socket.accept() - print(f"Verbindung mit {addr}") - client_thread = threading.Thread(target=handle_client, args=(client_sock,)) - client_thread.start() diff --git a/spinnaker_wrapper.cpp b/spinnaker_wrapper.cpp deleted file mode 100644 index bd6c7ff9..00000000 --- a/spinnaker_wrapper.cpp +++ /dev/null @@ -1,56 +0,0 @@ -// spinnaker_wrapper.cpp -#include -#include - -extern "C" { - Spinnaker::SystemPtr systemInstance = nullptr; - - void initSystem() { - try { - // Initialize the Spinnaker system - systemInstance = Spinnaker::System::GetInstance(); - std::cout << "Spinnaker System Initialized" << std::endl; - } catch (const Spinnaker::Exception& e) { - std::cerr << "Error initializing Spinnaker System: " << e.what() << std::endl; - } - } - - void releaseSystem() { - if (systemInstance) { - try { - systemInstance->ReleaseInstance(); - systemInstance = nullptr; - std::cout << "Spinnaker System Released" << std::endl; - } catch (const Spinnaker::Exception& e) { - std::cerr << "Error releasing Spinnaker System: " << e.what() << std::endl; - } - } - } - - void* getCameraList() { - if (systemInstance) { - try { - Spinnaker::CameraList* cameraList = new Spinnaker::CameraList(systemInstance->GetCameras()); - return static_cast(cameraList); - } catch (const Spinnaker::Exception& e) { - std::cerr << "Error getting CameraList: " << e.what() << std::endl; - return nullptr; - } - } else { - std::cerr << "Spinnaker System not initialized" << std::endl; - return nullptr; - } - } - - void releaseCameraList(void* cameraListPtr) { - Spinnaker::CameraList* cameraList = static_cast(cameraListPtr); - if (cameraList) { - delete cameraList; - std::cout << "CameraList Released" << std::endl; - } else { - std::cerr << "Invalid CameraList pointer" << std::endl; - } - } - - // Add more wrapper functions as needed -} diff --git a/spinnaker_wrapper.so b/spinnaker_wrapper.so deleted file mode 100755 index 89867fda..00000000 Binary files a/spinnaker_wrapper.so and /dev/null differ diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 00000000..f31022bc --- /dev/null +++ b/test.ipynb @@ -0,0 +1,643 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "216aea24", + "metadata": {}, + "source": [ + "# Requirements\n", + "\n", + "This notebook uses the following third-party packages:\n", + "\n", + "- opencv-python\n", + "- numpy\n", + "- matplotlib\n", + "\n", + "Standard library modules used here:\n", + "\n", + "- csv\n", + "- os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eeebb90f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple\n", + "Requirement already satisfied: pip in ./.venv-3.10/lib/python3.10/site-packages (26.0.1)\n", + "Note: you may need to restart the kernel to use updated packages.\n", + "Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple\n", + "Requirement already satisfied: opencv-python in ./.venv-3.10/lib/python3.10/site-packages (4.11.0.86)\n", + "Requirement already satisfied: numpy in ./.venv-3.10/lib/python3.10/site-packages (1.26.4)\n", + "Requirement already satisfied: matplotlib in ./.venv-3.10/lib/python3.10/site-packages (3.10.8)\n", + "Requirement already satisfied: pandas in ./.venv-3.10/lib/python3.10/site-packages (2.3.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (1.3.2)\n", + "Requirement already satisfied: cycler>=0.10 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (26.1)\n", + "Requirement already satisfied: pillow>=8 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (12.2.0)\n", + "Requirement already satisfied: pyparsing>=3 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in ./.venv-3.10/lib/python3.10/site-packages (from matplotlib) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in ./.venv-3.10/lib/python3.10/site-packages (from pandas) (2026.1.post1)\n", + "Requirement already satisfied: tzdata>=2022.7 in ./.venv-3.10/lib/python3.10/site-packages (from pandas) (2026.1)\n", + "Requirement already satisfied: six>=1.5 in ./.venv-3.10/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install --upgrade pip\n", + "%pip install opencv-python numpy matplotlib pandas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4832cb06", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import os\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "683cdde1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAGKCAYAAACLuTc4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Xu0dllV34l/5lr7ec4577WqqEIugcISAqKkVYjdclFBaYYRA4wWjGhZZRAQxcYxBEPSjdKtA5UOo3EwUEtF0KEmAUQkkmAyImoItNqtrWnyQy6CUcQS6va+7znnefZea87fH3OutZ9TVUBJ0KJkf/VQ73nOfvZ1rbXnd16+U8zMWLBgwYIFCxYsWLBgwYJPI9LdfQILFixYsGDBggULFiz424eFaCxYsGDBggULFixYsODTjoVoLFiwYMGCBQsWLFiw4NOOhWgsWLBgwYIFCxYsWLDg046FaCxYsGDBggULFixYsODTjoVoLFiwYMGCBQsWLFiw4NOOhWgsWLBgwYIFCxYsWLDg046FaCxYsGDBggULFixYsODTjoVoLFiwYMGCBQsWLFiw4NOOhWgsWLBgwYIFCxbcjfjQhz6EiPC6173u7j6VBQs+rViIxoIFCxYsWLDgbscHPvABnvvc53LNNdewv7/PuXPneMxjHsOP/uiPcnx8fHef3mcEfuM3fgMR4Y1vfOPdfSoLFtwlDHf3CSxYsGDBggULPrvx1re+lac//ens7e3xLd/yLXzhF34h4zjyjne8gxe96EW8+93v5id/8ifv7tNcsGDBXxEL0ViwYMGCBQsW3G344Ac/yD/6R/+Iq6++ml//9V/nvve9b//bd37nd/L+97+ft771rR/3+6rKOI7s7+//TZzuggUL/gpYUqcWLFiwYMGCBXcbXv7yl3Pp0iVe85rXnCAZDQ9+8IN5wQte0H8XEZ7//OfzC7/wC3zBF3wBe3t7vO1tbwPg93//9/mar/kazp07x5kzZ/iqr/oq/q//6/86sb/Xve51iAi/9Vu/xXOf+1zuda97ce7cOb7lW76FW2655cS2D3rQg3jyk5/Mv/t3/44v+qIvYn9/n4c//OG86U1vusN53nrrrXz3d383D3jAA9jb2+PBD34wP/IjP4Kq3mG766+/nvPnz3PZZZdx3XXXceutt36qt4+XvvSliAjvfe97+eZv/mbOnz/PVVddxUte8hLMjD/90z/lKU95CufOneM+97kPr3jFK058fxxHvu/7vo9HPvKRnD9/ntOnT/O4xz2Ot7/97Xc41k033cS1117LuXPn+rn/wR/8wZ3Wl7znPe/h67/+67niiivY39/nUY96FG95y1s+5etccM/EEtFYsGDBggULFtxt+Nf/+l9zzTXX8OhHP/ouf+fXf/3Xef3rX8/zn/98rrzySh70oAfx7ne/m8c97nGcO3eO7/3e72W1WnHDDTfwlV/5lfzmb/4m//1//9+f2Mfzn/98LrvsMl760pfyR3/0R/z4j/84f/Inf9LrIBre97738Q3f8A18+7d/O9dddx2vfe1refrTn87b3vY2nvjEJwJwdHTEV3zFV/DhD3+Y5z73uTzwgQ/kne98J//0n/5TPvKRj/DKV74SADPjKU95Cu94xzv49m//dj7/8z+fX/7lX+a66677b76P3/AN38Dnf/7n88M//MO89a1v5Qd/8Ae54ooruOGGG3jCE57Aj/zIj/ALv/ALvPCFL+Tv//2/z5d/+ZcDcOHCBX76p3+ab/zGb+TZz342Fy9e5DWveQ1PetKT+J3f+R2+6Iu+CPDI0dd93dfxO7/zOzzvec/jYQ97GL/yK79yp+f+7ne/m8c85jHc//7358UvfjGnT5/m9a9/PU996lP5pV/6JZ72tKf9N1/vgnsIbMGCBQsWLFiw4G7AbbfdZoA95SlPucvfASylZO9+97tPfP7Upz7V1uu1feADH+if/fmf/7mdPXvWvvzLv7x/9trXvtYAe+QjH2njOPbPX/7ylxtgv/Irv9I/u/rqqw2wX/qlXzpxzve9733ti7/4i/tnP/ADP2CnT5+29773vSfO6cUvfrHlnO2//tf/amZmb37zmw2wl7/85X2bUoo97nGPM8Be+9rXfsJrf/vb326AveENb+ifff/3f78B9pznPOfEPv/O3/k7JiL2wz/8w/3zW265xQ4ODuy66647se12uz1xnFtuucU+53M+x/7xP/7H/bNf+qVfMsBe+cpX9s9qrfaEJzzhDuf+VV/1VfaIRzzCNptN/0xV7dGPfrQ95CEP+YTXuOBvF5bUqQULFixYsGDB3YILFy4AcPbs2b/S977iK76Chz/84f33Wiv/7t/9O5761KdyzTXX9M/ve9/78sxnPpN3vOMd/VgNz3nOc1itVv335z3veQzDwL/5N//mxHb3u9/9TnjgW5rV7//+7/MXf/EXALzhDW/gcY97HJdffjkf+9jH+s9Xf/VXU2vlt37rtwD4N//m3zAMA8973vP6/nLOfNd3fddf6frvDN/2bd92Yp+PetSjMDOe9axn9c8vu+wyHvrQh/LHf/zHJ7Zdr9eARy1uvvlmSik86lGP4vd+7/f6dm9729tYrVY8+9nP7p+llPjO7/zOE+dx88038+u//us84xnP4OLFi/1e3HTTTTzpSU/ife97Hx/+8If/m693wT0DS+rUggULFixYsOBuwblz5wC4ePHiX+l7n/u5n3vi949+9KMcHR3x0Ic+9A7bfv7nfz6qyp/+6Z/yBV/wBf3zhzzkISe2O3PmDPe973350Ic+dOLzBz/4wSdSqQD+7t/9u4D3v7jPfe7D+973Pv7wD/+Qq6666k7P9y//8i8B+JM/+RPue9/7cubMmRN/v7Pz/qvigQ984Infz58/z/7+PldeeeUdPr/ppptOfPazP/uzvOIVr+A973kP0zT1z3fvczv3U6dOnfjugx/84BO/v//978fMeMlLXsJLXvKSOz3Xv/zLv+T+97//Xb+4BfdYLERjwYIFCxYsWHC34Ny5c9zvfvfj//v//r+/0vcODg7+ms7oU4Oq8sQnPpHv/d7vvdO/N2Ly14mc8136DLxWpOHnf/7nuf7663nqU5/Ki170Iu5973uTc+aHfuiH+MAHPvBXPo9W/P7CF76QJz3pSXe6ze3JyYK/vViIxoIFCxYsWLDgbsOTn/xkfvInf5J3vetdfNmXfdmntI+rrrqKU6dO8Ud/9Ed3+Nt73vMeUko84AEPOPH5+973Ph7/+Mf33y9dusRHPvIR/sE/+Acntmse+t2oxnvf+17AVakAPu/zPo9Lly7x1V/91Z/wPK+++mr+w3/4D1y6dOlEVOPOzvtvCm984xu55ppreNOb3nTiGr//+7//xHZXX301b3/72zk6OjoR1Xj/+99/YruWurZarT7p/Vjwtx9LjcaCBQsWLFiw4G7D937v93L69Gm+7du+jRtvvPEOf//ABz7Aj/7oj37CfeSc+R//x/+RX/mVXzmR+nTjjTfyi7/4izz2sY/taVoNP/mTP3kiTejHf/zHKaXwNV/zNSe2+/M//3N++Zd/uf9+4cIFfu7nfo4v+qIv4j73uQ8Az3jGM3jXu97Fr/3ar93h3G699VZKKQD8g3/wDyil8OM//uP977VWXvWqV33C6/vrRIt67EY5fvu3f5t3vetdJ7Z70pOexDRN/NRP/VT/TFV59atffWK7e9/73nzlV34lN9xwAx/5yEfucLyPfvSjn87TX/AZjiWisWDBggULFiy42/B5n/d5/OIv/mKXZ93tDP7Od76TN7zhDVx//fWfdD8/+IM/yL//9/+exz72sXzHd3wHwzBwww03sN1uefnLX36H7cdx5Ku+6qt4xjOewR/90R/xYz/2Yzz2sY/lH/7Df3hiu7/7d/8uz3rWs/jd3/1dPudzPoef+Zmf4cYbb+S1r31t3+ZFL3oRb3nLW3jyk5/M9ddfzyMf+UgODw/5z//5P/PGN76RD33oQ1x55ZV83dd9HY95zGN48YtfzIc+9KHek+O22277b76Pnyqe/OQn86Y3vYmnPe1pfO3Xfi0f/OAH+Ymf+Ake/vCHc+nSpb7dU5/6VL70S7+U7/me7+H9738/D3vYw3jLW97CzTffDHAiGvLqV7+axz72sTziEY/g2c9+Ntdccw033ngj73rXu/izP/sz/uAP/uBv/DoX3E24WzWvFixYsGDBggULzOy9732vPfvZz7YHPehBtl6v7ezZs/aYxzzGXvWqV52QSQXsO7/zO+90H7/3e79nT3rSk+zMmTN26tQpe/zjH2/vfOc7T2zT5G1/8zd/057znOfY5ZdfbmfOnLFv+qZvsptuuunEtldffbV97dd+rf3ar/2a/b2/9/dsb2/PHvawh52Ql224ePGi/dN/+k/twQ9+sK3Xa7vyyivt0Y9+tP3zf/7PT8jo3nTTTXbttdfauXPn7Pz583bttdfa7//+7/83y9t+9KMfPbHtddddZ6dPn77DPr7iK77CvuALvqD/rqr2spe9zK6++mrb29uzL/7iL7Zf/dVfteuuu86uvvrqE9/96Ec/as985jPt7Nmzdv78ebv++uvtP/2n/2SA/ct/+S9PbPuBD3zAvuVbvsXuc5/72Gq1svvf//725Cc/2d74xjd+wmtc8LcLYrYTK1uwYMGCBQsWLPhbjNe97nV867d+K7/7u7/Lox71qE+47YMe9CC+8Au/kF/91V/9Gzq7ex7e/OY387SnPY13vOMdPOYxj7m7T2fBZxiWGo0FCxYsWLBgwYIFnxTHx8cnfm/1JefOneNLvuRL7qazWvCZjKVGY8GCBQsWLFiwYMEnxXd913dxfHzMl33Zl7HdbnnTm97EO9/5Tl72spd9xkkOL/jMwEI0FixYsGDBggULFnxSPOEJT+AVr3gFv/qrv8pms+HBD34wr3rVq3j+859/d5/ags9QLDUaCxYsWLBgwYIFCxYs+LRjqdFYsGDBggULFixYsGDBpx0L0ViwYMGCBQsWLFiwYMGnHQvRWLBgwYIFCxYsWLBgwacdSzH4ggULFiy4x+Knf+KnMAEVMAERIIFUgwIIIApURJTEgFpCq8TfQGhfNMAwDBGLvyVMBZMoZzT17dRAQRKQEpBBwBDUwMxIQM6CKagZiO9XMMRAkmAkrMbFJD+lZCCr2D/zYa0YJUOVhCBkEZIAJkjyczIsrtcAwUx8h2qI+QUbcwdnUETUvyJxH/xU2z99nxgqhg2JVIWEINZumd8fU4WV+k1V+gMxxK8xAdkwNf8egphgK8VKxcywatRqqBlWFWpFrVJFUcX/3i5REmaCpYLZhJYJNUVrxSahmlBNfT8oaX2eU3vnOH22wKag24lSRo5t5OjwmKkcMU2VUpWpKlUNVUPj+/3+JUGSsE7C3mrF3zm94r5AXRsfWRsfuQgjwnjrMaZbrChaBQWqzffTwJ8LhmRIac1q2GMYTjGkA3Jas84rTh9kzpYL3FoucGGqTKYxSjNZhMHU7xcCkkki3qU7g0gikUg5k/PAkDOrYcVqf8VeEvZWwrr6qJhWUBiQtELE0OrPShE0gzIwMLBKkAYjDYmcVmQGVoMPXLHkkyIJpISYjxNLgrY5Zfj4QRD8GD67JOaA+DGpZJScBCGjMc5EDQYD1L9ngtQ2mg3NkFRIJoj5vlWNlGM+WYx/2Z0HMfnaNJfqY4m4npi3hkHyOSBV2vCf/5uUXM0vP5YYpK0JCZPsY1EUn/0S89v8/rUpZfjc7WsUSKwzvh4pWYwU26nEiGqXhiBtTtq8E4t5LZpiLQATxUTB4rlVv/sJ7/ZeEarfOKT6IXLysaUG3/qsb+UTYSEaCxYsWLDgHguJlyVhPjdeoZpQMTeiY0ssU/EXsibCcMRf8Mm6cY36C7Z9T0WouCHQeIYIkP3dHBajG71OU8LMh2RG1W5Whv2fEI0Xv38TUxA1UorrqW6QmVi3/yUJ2cJ+DyNfie3iXgjWDQ8136cAUtOOEWKzFdRsk3aQ5MTIksXf/D6YAep/awfsf8NQhRpGYr+v8T1N/rdEkKj27FRRg1oUUycEWpRa1e9ZNdCKaqWiqKob/gZJnQRiCU2KiQX38/8ahapGnRQt1Y3ZckydMsdjwY4rWguVibKdGJlQVWpR6lQpqlRT1Px8UCcahmDixqdKpqRT/MX2HEfDiB4fc+HSlouTMm2VaZyQMkFVUL9HJqD4eIq9+aNQf75JhJQHyAN5GFjvCZddseZzjhPToXJLUcaiTsowUhUmUQwFko93SbFPQSSRJZHNEA3jdRBkWCN5nyntMdmETcfUaUtJhYTGfHBD2LJQs1CLYVbRLAwI2ZKPfzEkDYhm59y0eaJkpNvzQowthII/w5RmQ71b+Sep2Gz8I6gZKUg+ba6YoDEpnKzKzj4lxqbEVDewvuc+hn2H7Vjz0TV+FRPmYW1orBdmToransTcwE/EfI6LF0lxToqZE3v3EewcR2NdCYeFxbyVwfr1SHgBGmFSYj7GetPuC/iw69fT1pAgftKPF9eqhiX1tU6MXOPupMbHnHQbOJEFMuqOlk+ChWgsWLBgwYJ7LEzAumfSZk86CQtaASCW4p1r7sHLycMg/kf81S4nDGjZ8f67sW3sWCjNHgmLvlEL6caCML+kG6loIRclkUzD8LCdnSU3MmyOPVg7C/GwTQqro3+tGR79xPxbbkQopu4/bl7Z7n6dqVncQ+lWX/uz4dEL6+fXbJf53lgzVsLAmV28EfiR+dsWxxZt3vKKToaaYlqptVJLkLMqmFYnABRUK1bVDc4qpJqQnDyakwjD08+15koZC9NYqaP6gcsRtSr5WNmrykFScqpcpHBUKopRVamqlFIpFscOouHjJYhGWpEGYSVnId8HTh2C3gyHE6IFLSNFC5SKaYUgUWqCJjeYRYJkzBwPxNA8QBlAVqxUKLKiXp4ox8ZUjVIMM7dUawVJGlalE6AkHnFJVUiSsCzuMW8RDkusWTOcugy182g5otrN1M2IVkVtjMgb7s3XFFHAGnMiY6T4MVIyTDJryaySoSjFlGKp3TKfdz3CNU+jsLZ3xr9fhkfg5r9b+3eLKuxG4No4tp1omrRwgo8LyW1caicw1uZO6gOz2+X9bCyIvsU++7ZxLIkoTl87mM/FLI6RIIs/J1V2l5F+zHadO/fGJCEiWPMRCLFfd4T4/VcQ7XSpnUHnSzuzVtoy1S/eiUabv8T467c35rLKzr1oR7JYD/N8JR8PC9FYsGDBggX3WGjq78z5xW6CZsHq7V/+hBHtHvCWqtA9oY144AZ2e3fPNo51W4b2wlVP5Wi2RsPsCcS9w+0chEj3Sc1kopkXIubEY6d8UnZ222yqZM3TGtfboyonjdZmwFgzksLgE9yDDkCSIANO2Fq6CepGlUGkTTTPbDdb/MzFz6FlXcxWiV8nZh6d6d8DIlohqpgUtJob9FbRWqnViYaq+O/m6VNWK1bCc28JVRhWkCXuwUqwYtRU0VKYppHttlKmSFOpiTwITMbZwbjvoBysKv91r3DrrRWlUrUy1cJUCqX6+aiqG3ga7nfJpCGT1sa+DJzfP+DKgwnVjFRjnAo1bdnqRLXJ91GDRNUUUaN5/Pnpe/pbxSgyUItQxozVPYaDguxP3DZObLfKVCLdTfBIkFrkZPnDF0ke/RIhk7BB0BQeaUlYrRxMxipndNinjgWp2Z/3WDCdnKwJqCSsZKT4YChZSBKkhoz76EFE2d8TzhqMKhxWKOrpdjXGbJsPuxxX+gcnZl6Qb5lJhs3e/z4fd+aHxBjVRjTmKeGELqVIdQpDvKWa4Slds4nv1+NjN1IE2TGwG/XX5sCII/X9zXPOZnbk0aWEj2PzxaHxK+F2kZ2duUz2eShqMS9j8qfUp5qYxS1sZ9ip1Mmb1RhORF799jpJN8UfUpu74lGn5nUwcVoDQuoEJlKzPgkWorFgwYIFC+6x6EkWO441S2A5jPg6G+3Ng4klrACo20vitKFxCLGe14C/haUbym7U9zf37OWU2SHY3u4pEXUW0nfne9HwGuqcFtWcs0T6T9t9eC9n28wi5kFEEOJHleay9H05WVBSGDTaDbDuwGwGmXoOfvNsJpijPclTkTAjmSJVkBxpIN1idO+t1Pk5mAiWnLxJpKugimJRQmJgFc0VLZVSK1XVPeqRHlUqFApWq9cLTOp1N6uM2B6sBvJeJklBhglbVbg0YbqhbkamTWE7KVM1skHaG1jnM4hVTuXKffcmLj9VuTAU7HCi1pEyFabtxFgqU63YpChONEwF0YQkr40QE1b1Zs5k4fLNhmoX2QwbLq42bI432DRSS6FM1SMkqhRNJE1OTqUNSo9jpbyiqJEmKHmirEZqOcbSbUw3XeS2C5c4Ht0j7/nz7bZaPH8JhuuG7Cr7SFFLSCqkMlC1hoFaGVaFetUlr2+ZDhHdIihW3PguYhSqpyuVRE7+zNUM09RrbdaaYJzYO7fhrK7YjAOjCkfiUagIppBT/KNHzjxaIq1eqk0dm2s4SGGwW3VjOM+btbSfNk9IntZT20RraX6o12y5xe4GcnjuW1Sg1Rw1uqEkUkQUGpFp8TIQ1AYnKNZUlSIqh6dhmojXZAQZz6qkyee9JcV62pcb4sn8nrd57wtK7C+uRRrrV7CVUyIV62mREguQBfGRvujMtMwSBIOgR4YMRMKrMDhx8TloqAnJjBR5WDlIFzgBbITrE2EhGgsWLFiw4B4LCfe+zBYuZvhLXfDUGsLrh6dvCMJQFBl0TreJF26PMJgbbm5k5LAHbU5bEuKVaz11y8R69ELCs9rsnZY+5FzA999f0c0pGLxG2DUSmPMYwmZonka3R9xASlFXoaaIhuGkbih5RtOcotHtr3BNykDPrXfyEYafRrRClFZgnjWHA9eLot0I3M1fj2vEetqHVol9VTAv9rbqpKJSqKVSdKJUT10y3BOu1dCkUAtSI2KyTlgaIB1AWqHTQJEtNipbVTbjRNkcUUp1slAi1SgJg63YHp2jMPLRvYn12ji9D3/+kYnDWzZM05bpaPKIhidrwVQ9amBKrSmiBQNZhdssMY03sd1e5KODIblyPEwcrjdcvHjIxdsKRSe/zqphuOU2OvrDd4+7klWhKPl4RFaCpIQdZo63me2RckjhuBiWDBl8bFuRndS9FA9SEMlo9kLelHBylDMwIUzcqkfUzUX0wh4a498EbBWu9WpUq5TqBm0evE5DVEhqDJq6wMBEIl+cuDAo9fJMyQObkoNoFoisM6k4M0qGpNxmGpLa/WipSzLXZsf4N6uQzQ1iBNQLwC3mqiUFBlAht1qaEBeQIcY5tUcNW0qQxBzSRm7Ms4GSJE+RiwHdIh4qHhUipxjjXn+DRSJZYyrN+RDzNhVFil97y75qZ9VqJlpgzoIstGCENUGF2K8lv24XhMCjHr0+zD0IooqEk6SvH1laEMrXu7YOmGBB4CgEcfNC84QiLQrKzom2f35ynrEQjQULFixYcE+GdkcuodJi1QtvJbuR3WIakppBYWQRGLLb+BX34ub2DpVua/sLfS4od++idavAwojfDWl4Tnekl6hik6EhQ9M8o511NFQ813vlhgSVEykgUoGVG2xNdalFLiTyzA2hWtpJ98CjDM24aJk/IhCGu9tDiRw1Ez0VK8wgq1E4n4WUIVeoUefS8rNNd1JJmoJWxr2qWt1DarXXK2j1KEPRiqHUUty4nzzFyCJFzSaw9cBQD0gDTgzFQCY03YYVQytMdaLWieMyclg36G0VXU2MZWKalDrFddWPwsGGaVI+elg5vm1ilTbcfLjhqBbGS4VRfV81akOkGFApopQKbo5WUspsxzUX9oyP3SLk/YmVHLOuG1Z5w8WbtlyQEoXoGuo/M2PsTuuo00hJqElJg8CwQlgj6xV2sMfhsGa7upXx4obRPM2vBy+0BTBiDKYgG5JQMqpRpDwIgwygA8I+t21PcyEp3FQRqUhSUlJSFgZ1A7bGMDSEVCBXV68SrZhmBB8TJWemtOa2W/a5NBpih06mhwqDX7NZjFtzskKqbhanNo59vLh4gLnSVAtYZOK6cENYpYs2EIS/WcpSceM/JSc6kVLWayzwSJSaxwYpjdBIJC0KGU+ZKnG4ZoPTAnNYJ+9k61M/Hmmfb1ibA0IieeoU8zrVdnqyNmyeS0iotVlTrZPubKDGtWZgkE4eTAVVYSjhhOmpmPFACZLT1sy+wsyfm+HnbDYvnsS60cOh1s/5k2EhGgsWLFiw4J6LCEUYYbG0fITkFrOEcYNFdCLqKSpu8PQCyTDUWvSjpRS0l6p4dXakX7WUp/BztoKIeOdabOspWIpkRTw3yV/u2aDobFyRomYjcsJbahH+ou9GZUuhwFNEMu0Y4WV1H2YzVzytIqkbsa14ezcNwxqpaknaGnJO7T7OhrCEIdOEVd14nMmVky43/N06DUtQvb5CTbvRXYpLyBZV/1utTFNlGidUCxYKXoIgdQ9ZH7BaG1jUTsiIbDdILTBOUJ3MZJS1VjbrypgntpuRzaZSRmPAyNsR2d6KTMIqCxVlqIU0FFZiTGKoFkqdPN2puhKWqaLiSljuRVayrMinCkM1DlbCfqqIbKh6yPGlkYkxVLS8RsRqkxANL3xtXnuXovWidiWdhtVqxbDa58y5U+ydP+BC3WfDMXpU0FFnb3QTEgijXNpASYKkjE2VijDkRJbsjzZl8t4+51ZnOH/mmEsXNlzcTGzHiSoFQSgCOUexdxi3WsCI2pTVEDZ/JSU4SJmDs2uEA9L2mFqP4h4mWCVk7V711CJCuaWOVQbF5WibCpo0HbmQ1WX26Et1EQFgjsbNMk0xXZwsqCktKOhGeBSEy05lddQ2xXQ9oSBl5mpb1FhL2oSBiFSq1yy0iF4zucXJn8W6YdrmiZC7AEUsFOEksBruDBOPtrQUyIhQtWiqtdCHQgv5mAaBaLl0cU9siFRQM6+psRTpXE2lL84xhWhEdUJkbemJZ5Fa9GLWGvAVoPFa++SyUwvRWLBgwYIF91i0Am5pnj52PPeRgjR7G92o67XO1b2VHpwIb2f7t6WWyNG+jIoX1YqmXifBjv3RFZvwVKLUiqslI11UP6IZLfrihzqZgmA7Ds/2QZIoPHdvrqe7OwmoCWqoIqUojjf8fHOL6Ih7RWeHpIWB4jnqrU+IzPEfIHLQw/1u5tKXvTSDcIG2Wmmhp2+0lBZUPU9fKzr5v0stlOrqTlrUjfsyMZVQlkLBshvHg5LWxqATNm4Zp5GRidU0MqjBGERvqKRUWVllk5RpU9luJrajMk3GYJCzeQpL3md/tYeKghyT0siqKiIV1YlaRkqpHg2pGhGcimkocAnYXmW98n2eOjDOrgUdBi6UFZupUMaZZFVVao3IRrs3kbfTukkgCVZb1kUoG8imnJ4qp21ie9kWbj3Exi1aQr3JB7/n0tP4oafKkRLkSk2JKimKjxPDkEAHUh25/MzEA6zykWxsxDjWJl+qLjs7hJJRKFi50a4MwcBrKBBl25JSZn/vNFyxj3y0sL2QqVrYmJJKRaqQkiCWSCmTmqJVBqik6gZ+6//hqUXWvfMWRvTJDjCNQdCE3LDoXyFA0uSpjDCnNmoM/jrXPLUJ3MqIet+Nnvpkfat+ZJsdD206txMRA6se1bDkCmNU376py1kwoCYOTaXXZwQn8chPu+KIZrQMOZfQjXWuOUTal82Q7GITak0fzNfCahrF8l4/JaY9yNZ5VKRByk5UU1KsAXEcr2+RvsZ8MixEY8GCBQsW3IPhFdc9PQA5Edjojfaa4Rz/7oqaO0yhGX3SPKjMKS6zhRNRiRY3iHSPtt9Z9jXK1C03//8OcYlt0qyS1VOwbp+O0AypFt2o7KSa9E1oKV6NNrXohXsxm4f0dpfSzj80/vtVnOBXJw0J7d+ka/K3fC4jCkipIePpP1pdlrYUpWqh1kKtXhxtk6JlZKoTxdwgbwaPpkxWZZoKabvFxkPGsqGYQq0Ye+S6ZlgXGBTT4qpNtTIdFqbjwjhFypMIDAmtGRlOMaVzTOtKFmPaHjFpZSoT0zgyTaNHWIJolIgaoZ5Ww+Bu5aKGZoNBGU4nyrBHPTaO1xPjJaMUv+YpFKfQSBeKiM0OzejjabupDNPEcdlwJGskrzlOKzYXLzBuNkx4kbE/BAs5WlyVqBUvRw1BSpmaUlfLSgJjhlUaKKf2qFJdtRev5VD19CGprqSW8Dqb1t/Dso80j6T5IMkDlAJTugKRPZCJwpaJEvU3xYvfByGJN81LQZCdz0eqUjRaSVHX02qtWq0FYdx2SzxmlbTIX8wRn9Jzfw2/tRpzMQjC7NLfmf/t81mzqRORNsFFZsLQ9qHzYZoHwyKC0g8vnkLYzzOl/k/fVZe06P8rzQvBXKTuZzNHTkzavG/zdO6vYSn5/GsT3vyZuhxdMIseDZZObBrrMKyLDUhbL1VP3CMTmdXrPgEWorFgwYIFC+6xSOF+s3jztlQod9iHEhIzEfBsCel1Dc2+2BWSaj0lmgmyKyvbZDTBSUwrCic8jS1Fy9KsROlSmV702yiMJfe49tqGfkWzp7R9fjJX3Zv6EfvWMGpSVM1au8K4IJXo2WDmL/xd3pCtp4Eo3ksjtRSznhvhhpL1exVdjiUapxlzqleNk410KDWPTni3bk+VKnWiTk40aqRT6Tgy6cSIN+VDI49/SKSxMG1GDqct2DFmx6hKNH1fs79K5MGJ0nZULppyPKqTjO3EVJRqiWFwqVfFKDYwss9xKmhOXDpSbpsKR4dbNtuJqUyUUqjFIrUrLlIjxS0lbCqkowk5mDgYM/vJqAjHJXGsMI6VcVtjPzUiNdWL4t2c3xmVbswlNbZWUSlomTjSDesxc/SXiYuXttRx68ShV+6aS/6GVJEwEw2pmZQqKQ1ONCqYelf1qa5Y2ZrtlcLhRjia4vxMo07H08V6EbAkcvYGfZDc0Favo0nA4SXI24J82Egj1OrPx0QxKroNtbKUvKO4JnKIMCRRzCpZtKcYzdZxm60xH8ycZKWZ/hpEsfhM+j1qYPQC6j6dfP5ZapOZHuXwio3GDGLnZZ6EjXR4LXtbNNriMK8Dvv84a/Xfk3l6UsIic6qxLJ8vlhuBnx0e8287J9SuJRjAXETentMsBawtVIp6880UNCb7FE3R06Ojp3/uiOPGzdO+7vka1x7PzjL1CbEQjQULFixYcI+Fkwrp9ZXecdeZhkXEQJvUIwQhiFd3sBKLEIjt1kaEt7Dvt3v7Lbz33mNArb3Pg0TU5vTz71bCEEiEx5lOiDQUXizYRM+NhniRSzey2t8E36nnk+Ne4F7FmXqBrMR1qXhKzMpCXjQIhTUjKeyLGjdg18iZ8/792vrtKZ5Xj2kvIke9QNxa9+gx+l8kr8OoESGYykQdixMRFJ0qOk1MdWK0LuwLWsEm2FbqNFFzIQkMMjAko45GZYvIxN7FCZu2bMaRC2KMCmMdmTYbpqqoZEwzuVYqW4oa2+ESQ1WmcokLxxtuPdoy3rJlK6UXgquqS+s2w1Kqp5uYYfUijIVaLnJQ1+yNRtlTDmvh8OYjpluPKOokRc2bAXrNShjFzClQIpARbCUcTyuOV/scbg64SQUZC3ZpwvKEbYrLj7aRIe2+tzHrNRBJkreEDMPe6oCuMwVhVGFTCuOlQ266VEhWXSkt+1jyNB5xchWGZkqR268Zs0yK5ncmCalwdEuiygWS/ClJJhKTSw6LK21Vq8hoyJBIZLJlbBBsSqQ2T5N3MHenwRzFE9GZbEMQhDkiBM2z7/9oJHhuvd2enc+PJgGLzF/sgg8hC2wptSp4364NfLldvEPM0+Gk1WGYN0fEn3FqawJdhMp3qjEO+ictctqiFXEMddLeLPvdqCdIF4NIQPJGOFFbskMC1CMbCF0hjlCO21Wj6imT1irGta8BVr0vkdhASp3dzOHNT4KFaCxYsGDBgnssWopy8172FINk5ATU1gcixHjCY6fh+UxNLTOMCoOoF92JNDSDo0UWsH7MWdaqpSbQDXgkxJfEIs89ogUpakzDbNnZ3JFmJZp2El4n4caAtTqNOPeWfsXud7r70yL6YV0sqxsZO0hxN6X/JieIj4WXuKd9iHfyLtEwzhNlWoSkUqRSqZ4qNRZsNLalhkJUQWtBTalTQbeFUUcvvm7V7gorgWwjw96a1oROVitIhe22cHi8pRxPHNuI6MRWJ5gGNCem7ZZJj5hGo+gazQNjqhFNuIgeQ03GoMbGDC6NMGxdZcqcPNUSEZZu28UAqAWZRnK6QD7KfGwzcHjoe740Kke3FSdb1T9rjuPdaJgbedofmSWJzoOe2nWwd5azp4z1+iKXOOS2wwlkxEpTLmo8oD1wDaLhmkmJTFolLwZew8CKnBIHKXFQJjiYsJuO2Q4biggmAzIMCAPiWse9PiGJUDMMw4qkA3klpAH21plTp4XL14l73XYbt6xu5tYxU4eErDMyDGHUKslGsrmmU5aBdc0wZCiGJaWkAU2eZjg0CVuUnFrtxkly4FXJqZO1VkPQ1FybcU2K+pV4APXktOqRDqWGonXacUTE2BdPKaOlcDX1pabq1FKcUmr8AzNPSHOCkKKWofWmiNXD5vPqk7/zijZJw5Mh2TuLR88asxxSv37uquLhitQIQyNn0o/tP0HmQmTCnRKdqSEYuVonMIJEvYogQ4oosPaI1l3BQjQWLFiwYME9FrWlIoSXGHHDIEc+teed02P/CS8pKJHSEPbZbL9Al4BtjlGiuHPO/d4xvJsz2W1EuvA/EckghURlqAshiGh0957Tt0TdwGEwWIFMMncqTxERsZDJRRFTz5VXV5SqcXVdPhe6F9bPSKg2F4YKc2dhMFJX2YoceSw0+1vxMt0YoboHuIbRVNXrFUotsC0gSsFrJWopaKQPbbeVUb1rtxeIewrVVCfqNIU3uj3PzCCJ4fRZhjPnGGwDdkTVDWVUplG5NCqbIlxKmSSQTZA8UVcbJtsy1cpYYSqV7Zg4zIksA8MqUY4zZWXkdaVYhX2DqSJWwZonnoiI0cdX/NNTxyZIqbK5oEj2iFQpxqSK1OjcbTMpTYZ7hGOM0bzj5jKmNk2kAVI1TrHhiglOly222nIbxYujsTCmrUdazCzS+qKvAx4lyJP7qYdirNYr0qAcnMmc3z9gc/kZjj9yM5sLsNHiY8MmUi7klBhSRAEjFSvnRK1e/J4F1mrktObgzMCV9z/N1R8zys3GR1NhM00wbWHYkpKQVBlUGdYDeYCcMuvVgMoBugI9dgIgyXAd3dyNZKkhdSuN1Id3n/mZ+Mj38+29MUx6t2vB60AqKbKhItLQ8qpaTCMbySoZRcyL6C07+W08oBObJL1wvKcSCdHBu23s6ZG9Y47R16PebLBHDOM8kjCnghJkRkL9rf3NnQ1NRELJXobTxgBejyOCpy02R4v6PMFFqIKYxrmFupZg5JDoTnH4Gn+WFo2JyvmWKvrJsBCNBQsWLFhwj0XeiWSINMPj5Iu6qbR0HfjuCe7u/xMeTG+AFdGDZkTMm4bx7V5Cj45EpEJabriF1r5FPnmKtIi2M/CmWnEKkfZA6xZcLfK76aGOOVBhYIpJ7eTCmuxOCs9vzyG3HQMIeq8AcbevZVefoRGu5lnN7q203VtkhPymodVrDSqNaJirR5WC1RFUqWqUqkylUG0KQuFF0bUoVSvVitdrlOhdUeM+SSZZQvdW6PosurqCym1oOWaqIyPGVBQ5FmwF1YtXEBGGNFIvHTEej4xjpUyCqpJEkWnFsL9ivVqxtxrY24O8KhxvJ7ZS0TpRJdR5FDf+aansNqefzFYnVryDttUYh2GEeW3KiSEGsiMt2m5uGGomUEvBtKDTyGE9JGe4JMaFZExbuoEYDuWolfBq5B6tag1WogOfiTCJkUplVYxRE+XUGabtVUy5oMMGGRXREvUooEko0ohGIkkmDwNVIa+UvHHJ3NVk7G1XHB0dcHQVTIeCbL3DuOnWVcZSdaM9In9a3DoeTg9ctt7nsrVxUzY+tqlsa/EmiQIyuTGvyTube4QtdaLR6LM/Fm++5zUQhkpCbJZ6FgxVry9JFg6CPqFb7ZQ/T5HqBrTgRfBZo34FupxdS1vcfbTNU1Fb5I+uLgWRVhg1Lo1UBGPtEVSPmkQ/EEvRb0Tb0IlzDIeEetRBzLvmJOuVFX3XXmMzP8cm3rArSiFBumj1YqJzXYt4Gl0f1+LiDtL1lUN44JNgIRoLFixYsOAei0yztdyL2/PWmw2XQlHlhNVMNyzCeuxpTS7VapGh4MaDtFBHGATdG63S0q29b1cwg12bpNkz3e/XIy9hEErLvfYtJFykzUZpqlmtVqRt1FNEoIvwNC+mdUmtJtc7X3or5m7KWtZSOBoHapkXkSfeU9211bt4Ybdq1Fioy9TWqaK1YHWC0ohGZSqVYqE0VQq1qPeo0MpkBZsmrBSXvFVPB8mCR1xqQnWk7I/odqJuC+NxZVOMMqqnquxlqIrVAjZCGSkXJ7ajNwCsmt0IHYRUjJUY66Gyf1Y4NRi5TpQ8oZsgQFXRGkZXBHJa6XYjG8Q9azEOl5jdER0w60IAc8GuG2v9ue48k2ZkiiviIqJcqoVtqDCNAlONaFgUPJu17zRi0zTS2jgKY7gKEwabLSuOGC0zrQamvUwZL2G2RZhIoiiVWoM4xnmJJFIayOoEbJBEJjNsE/loYtg/4tKFC1wcE+M2Qd3gR6xQCzpWNJoISkrUKWOlMlC593nj82zgfduBi2XLRiu1uFGfMVh72k+17E8g0nV6/cbJmRXPyn+8q7VEBDPujDkZcQ4eClstcsL8LFpUcJ4hUZ/EXMKv1iR5m3x0RFqak78vN3MapDIr0vn/z3O+S1D3YdYrN7qzoK8P7DgFrFVXtFHUFKPm+9KJU9yP2uov+v2z3R37UcXjOC1KpNair3PKV+d8nwQL0ViwYMGCBfdYNBUnaHabe/wRsBQ56xoGQmcfOy/yiChI03IMT7bn6TtJMRpRad7AE25qZi/iXNlh7eXd0p/a2UWetxcDx7bSFfXp7sQ0/3M3Bcq/EXnfYaykMAjaefi+ZjOiB3E6EdqR7Y3/2o4xY1Fg3AlQU/RRDW+/ep0FkQJVQj1KPU1KizKpMhWPYpTqvTO0FGwqlMk/n3TC6ogVpWj13gyuf4oI1FEZjy4xTIl8dEw5nhi3xriJvhSDW3l1qlA2GMfYtEG3hVKq98AghfHX7nDBNYInl+DdFuo0UY62lNEb9WkxLwSfH9vOI9x5jjuqPDU+TzHOdp/vHcaItDrckx7mXmsjbuxvm9EK7pHGlal6wlA8l93TayPQU7XE09NUMTtmU5TjceKwHrE5fyvbww3o2NWaqnk/lqqeOjYTDa9lUVFMMkZBpwzHG7hwK8erLTePA4dTZlKjhudbTZ1YZk9TklI9grUt1M1ElpFTqzXr4YA8GExbTKurxeEefe9HFylFlpDCbLmadHIf+qu0Qup+V9qYl/Dwy3yvGiuQ9iykz1yfk9aIXCOHQUy61T8fpFF6C71X051t+3OUnnrF/FU/G2lOjZ19i821KY2hwg45mqmliXZStLNQzPsL8kLr2ZPb/pojI84T6c4NYojP5V87xKevKbsT5M6xEI0FCxYsWHCPhbY0pggSGLjll2djZSYZ/j7P4hEIf89aGBtumrdGXe61NkTdUK1zsj6IhpHYjAJPQaqt66+4EpSoBYmZ92kyG+2mQ/vD/PI23B0bRmdvqCWzZ9SgNx1rxEJa7j90l7nseB81gc5tBuO04zu70ZceJoGUPbJRzQVw1RQlSEEpqI2uLFUrVrw4fKoeSZhqZSoaBr+TjVontHh376kUpjq5oTsqkykVIyXDshcIqxamW4/YM2OvFiwV73hcjTpUSk1waLCtqI5I3pBtRFPx+9vSmMyjXqUom1zQEaZb4NgqlInDbWFzOFFsohb33po2UthUvXbvr4+DbtBKK9ZvZMJmLzX0sIYb862Iduc5QDf2Z7vt9ipkBklO1Iu0Zx87IP7UjW8NIgOuorWpE7eWY8ZNohwmqiavh8gZyJgmrHVyjz4aSZKrlQ0KMjCIkvLAXlpxzgrnjo4Y05Y/u5g4GhLHeYWlVXT6blESoaBISWxz4mhbWN028ZGPbln9ndN8jIFimQze26MqGpHIUoQ6iDdvRMnVvfIpBRvdlYqN62215FVC3iDaoFjSHjFocz6Z185Ilvk5xHfNtD9PL1poBM/t9LzzeJriU6sXk5hQ4tlSUVAep1ujXkta2hLdaUAjnuZzr5OjlmJnM51MVTq50Bgj1pwlxbrKXWu4CE1e10hZWl15Hzce7WxEo/VIb+uZrw27DgkgCts/MRaisWDBggUL7rGoqmFMNasr+ZvN2JGHpHsLZRAkQ6rJDVBp3ku6gW1RryDRrsBaN1z874lebUFzWrqXuhWBx487Od0AibRmNzgSxjpqQSJCEecvqVlFO8XgEpcW3lU3Wv2ExbxgVlY7R26nKiHbGakTbmSkMJaU3a7Hqr6BNGJTBTFFMZd7LU4oqlbKWClaPGIQzfiYKqITkxWOpxbFUE+XmpxkVPW+EmVSJyR1ipqE6qlWVskpYSljuqbYPnZOYDMwnBuwc2t0XdDVJeqtx5RDw0aPpGQyyfYYxNBUnGxUw6xgsqEyueLPBm/gFwZktUrZViYKWHTHjrHQUuRORLPaM2j3rQ299lyE7rVuxl2PZOz83g7gNuROoTkz2eikpnvaZzECrKX1tA2lj69mFzeSqniReEXYVriQK9wmMHgaVEpe35JIINFLA0hi8TwUswFDWZHhYJ+9MwPnLzvL+b3LuHFzno8MN6OXbkaHkTwUVgkGlCpKlYxYRgaXHj6eDKaR9JFLHB0boxxTaiGVES30qAY6UMmwUvKqsMpGJoNmZFDIqZO2ZhC7qIJE4bxbyE4InPlpIxlBxFsReUouEasqVHUHhgjeyLBm7/SdvZ6CIDuDiRdis6NKFfvrRdzxJDV+JEWvmlazFTUjFsoM0ub+LovsS492UqEkBlzcQdWcGKXkynoxMDVDJnXJ79ZrBAyp3jlE+9kFycLXxdScKElmYlHZUdVrhHkhGgsWLFiw4G8z1NDkMpLN2JIU/EKhZ9g3GZUwwFzeNnWFJVOPiJDmaIcRyi7ZPZPe0fmE0z/qNvwDqUS0A2Z24P9uRqSJYJL9WNmQYp3kNCUaUwVyJEGHeaoWaVxuBM2aqW7Y5ORGi+L57N2gUCVZXEds40Xokc0eXuGEzFK9IjB5nYGV6l24S6FaYcL7Y5Qo7C4lSMhUsamwrRPjWOdiby2U4rn6U516t+xSopmdTtTRe22YejFvYWBAOHtun7N7mXOXDZw9P6D7mUsUVue2XLrgvTm0GUWrxHh6n2lQNtuRkoWaDJu8dkObl1+EaTMTNzOjhBfZmPsbNCN/Lpy9cy3PLjwWdmbU+/bNdzNLTqTtnPhXS7OKf7cxYye/R91hILZDTZr8UCvkaeS5bdsjYj4prOCG8CgUSaTW6C95zUEbHinhKXpJyaZkHUiisIWUBi673znufb+/w9F7H8CNF96D5pu8lmasTMnmMTWsyHuwSsreHpw7gPPrEdWRWz98zHiQmPZWKCso2RW7VpVSpPcEwSYkFZKssZWgKSGi4bU3l3AVek3WCclYne/zTkOLiEL5x1qboJIb1sMO8WNIXUq6iTQYQonamNbg09XgbH7o4WjoHglAVJEpnRgMMsQAijXKYr9OnNrzBtQpjWQjSfazaNKzGmGYdioZJCdXp9I2VnZ2dqLoqw1iISWNdcKvVRt/AidbsXuxlrj1ybEQjQULFixYcI+FJUEHJxZSrReB9qLQE69Df4F6f7nIwa7zO18jRSATko7ixnZGyFj08PI3ect+yUR6Usj+zCos7aWe/RwJYzbSG3IQkxbA6MZIVIV6+kTtmvrNaLQm19vSowBR8SZ24d42jWLk5IaatRSaCin6QiDe38Fle/2I3TCNwl9XQapY8YLtOhXvlzE5wSjqsrUuY1spZaJMrau2qxhVdUIyTRPTOMW2GhGPiaIT01TdAAvj2iQx7cH5JFy2v+Lyswec34d6oAxi2C2ZMu6xOajIccFWhp41xrOV6aMTm3GkjJ7O1dLd1CwUdOK+9fvuHuIapbotWtSJoX8b0Rat2skb2Ukb6eq/umuMzVEFJI7XKvOtDcc5atXEfGz3f9rhutW7c/hGQrFeHNyKxTEliY/+plI0R1xonST96qSGnLN0MQETH5smPodqdUInG4GDY/LhbZz7M+Hel5SP6SGJjwLmql1VqZN735MZaU9ZV0XWmfXZgbMHK64YznILZ7lpe8h4eMy0GSEXViKscsJyxiZjpYVBBbFEzYlpGD2tq2Qyrojl5Rue8pOSz0WJ59oZYPxTNVSeYr5Z8Tmg2eemVCGbBxuLQJW54FtCKKIVR7dH22ZsikiG7DKYkC5u9SRCmo/fno2lmP4W49N/WlF7j5A48wsnRSvtjr/neXxYXxd8sVPmtUka6WpywW1shFCBy0RHsXtztpjtUBTpaYGpy/J+YixEY8GCBQsW3HMh4gaRNcsR1FxvJu84+FoKQ2+uZTvF4IHu7Ay5oF5o7k0v3BhTf7mnHsbQnnvdy0qtOZgVI7vHs+fj+L5mI8UbksXeaGRIugeSfgUJl/uUZL3IXBAsi9eq1FAkaoYF0UEgjKpZeatddxyrebybYVyr5+pX73NhxaMSpU6U4kpSdXQ1qaLaicbUpGqLN+Wr0dCvTMo0TZQyzvK2sc+pTkxFox7A0zkMQytMltiuVlD32ddKGUdkVKZtxvb3GdZbptaFfGNULUyXvLi7jnWWAJVWyN68yPGcpI0Jvye7hbTdrm8ksuswOUPo0YaWVmc9DtK9xRbj4oQ1ZsFy4pl6gfFJc81rjRrJaEbyiZ3MxnO/hjlff6eqf2ebvqeZLNl8RWYSYzqiAa1oPYqbU7DhNCSGzYZLF5T/ahOHt2z4s+FWLl5StHidTVWXQFZVslRyNaakTMcD28OJ4wPj8NQpttt7U7mRqofUqWDJPLVxtceqDKxrxaiYCUWjaV31GgpRRS33vh7S5kJ44kkWXazDs4DP3WRE5C7EDrpfwKN7loxq3gnbiFSpJlGL7UQrjF4M0hcR834qzHVj7vFIfcy53HWLJhJpm95Mx9eLRvlbGmPXqfLPJUVU1NOnSE5+mkStj8MmHbebXhcEpiYnJbuDvJ++R3YrPnCb6p0pMEFa7YxRif+580DfCXxyAdwFC+4CXvrSl56QU/ur4HWvex0iwoc+9KFP70nt4EMf+hAiwute97q/tmMsWLDgbx7uuWtylv6BhnHYCjabElBTkHE513idBytIyT2SzaToHj7aZ92UIbFTDBp2TKv16N/YkY9FtBvyRJGxWfOyh5oP7nn0JnFysjDbIDWjOerHTxCoFPaM0Y3m22/Ta2bjZzcjgxq2r7q+qtWKdTna0tWjphLRjKkwlcmjFGWklImpTB7RKKX/Pk0T43Ziu53YThNj/05sP8ZPKRSdqFpQ859aCuPRxNGmosfKalNZH07YpYltVSwnchOPqkadlHJUqaN3ItdavSg7yENUq/RaiXa/tStENZJGLyKXNm5opI1u47ftWlShjZ0uEiSzvd/QjcX2/Wbkxwfzs/o4nuLdYzeDdMdIPOHS3v0V91DbzvfjAua8/d3GKbZblzKPVxMhrzLrYcXFuscHjjO/f9uWD37kFm67eJHDzTHjuKGULaVO1DJSyxTjRdmWwvHhxMVbR2473HBcN1gtPhdUvVZnmii1MGjlFJWVem3Q1JTLtFC0MGlx2WT1qJlVdRWxOnfebuS6m+4GWX0umcZca7dJZweBGpS4jS0a1O/Bzo1txn1bQ9qcM41WOHhJtd/71Kllc2LQxkMMGEsRRZCdNaPtn5b8JF0m14j0Rq9675GG3juDznlnztqiIzCPnbiaFn1Ra6IDnLiHSWLdk+hUdOL7Hx8L0fgsx7vf/W6++Zu/mfvf//7s7e1xv/vdj2/6pm/i3e9+9919ancLfuM3fgMR4Y1vfOPdfSoLFiy4C4i6xCjQTljImWJGajnNLS2mGVREIXSKH2kGg0JSjw5IRDCCNzSnpCTrajGeBZMwOUkuvHDDqYhCSF725JqZhEgovEjzZjrxaBaBmOdeSxh+gs1pFy3iErZmrdaVa5qZ2ovBWzeIyKmw5EZNZx5qWFWshkxtmSMTpRTGUhinylTMDb5ykixM40iZxv7ZNBWmqTCOhXE7MY4j49RIRvH/BlkpU2Gq3mej1EpVr9uwukU3x9TbjuF4w7A5Jm+PkfEY0xFTRS6CHNOjR6pKtVDEUpdYddImJAZyzqSUvf9GFE2r0XtmAHOmTftvH2RzT/VugwlzF3WCjLQx06nC7UMabXy0z+YEqMjB68arG7C7328ndjIy489xJks0AtKUkJpiUTv/Ti52/ntiVtmJU27ExFIir1fsXXYWPXMVt+7fi7/I+9xyqXB0eMzm+ALb40tM4zFl2lCm0YnkVqlVUPHI1vFtR1z4y5s53vwZZbrgYxcwFKo3D0wykqWAKbXaTl1P9bFiTjiqOvlQLVipmMb8bYRJ6XLD/XbGg28phkQkR+J+mYmrg5nR2sNbIxttPDRJiBN1PHHPNXkHcGvrQhTuJHqupO2MNYNgCCnWg0qUobdT83HSSAgWY9vnrKjNqYBdCW9eR06sM9mL0cx0JtjsjA9NkVrqBNOdMxpNBaO7vUUtimknTJ8IS+rUZzHe9KY38Y3f+I1cccUVPOtZz+JzP/dz+dCHPsRrXvMa3vjGN/Iv/+W/5GlPe9pd2tf/+r/+r7z4xS/+lM7j2muv5R/9o3/E3t7ep/T9BQsWfPaiGdretVpmDyN0VRTbdalZeJIz3XPbUoY6HYh0CcMi99u/mLq3WsNA8DQGL7+WbmjOqQ1uoFDrib/vNrpqtR2EAeSyl+E97wYC4fUNozi1dJ+4PmlG0ryvVttROWnUeNK99LxvCXKjZmhVKF7UPTIx7qhHleIpUN6EzwmFpz/NReFTS7GKqEadPAIyaWWqI7WO3qOi7hiMWihqWDKyGCnFPUojB6c2XLbdsseGOhQ0b1jVDWdUuU2V7WjYylivnCSWyb3bqhWbcJlcEVIa2M+JYYCSYRorZVKqeZrPiahAIxw7aSNB2+InajVOBg04sYlE2gueijP/MQZgqxySk8frsYoegtqNSoU0afMyt2hZOwc5eZTdDAMDeudqaQTKdr4gnb/MZmfs40QfiMTeauDclWc5dcVV7AvIhZu48fgiH7lpS8nHlNtJzuYkDLpHPg8H+8YqF0rdcOnmSjm+SE0HkNZYNtbJWIty2lxJ7AKZUWFssqo46U4xx3UyarZIH8JFFlIj3ymM/p1y/qjfMNFZbS44n89XF01AXNqZMhfpz3EwJ+pOXnfmlsxbkaKeRYOOhKa2N/3WiLjIHHiS8PrX2ENTq6gZy7EG2O0jXRaqWYKlFOexM0Di2P3cYg0RM6y0IvbUIyO7Q2G3hqWnX5n1/kKNxPQo3yfBQjQ+S/GBD3yAa6+9lmuuuYbf+q3f4qqrrup/e8ELXsDjHvc4rr32Wv7wD/+Qa6655uPu5/DwkNOnTzMMA8PwqQ2nnDM550++4YIFCxbcDlb8R0OhyVrBRHgAMUGjALI7n7UZZzJb4Iq/1AnSohapUPQXLjRDYCctKjylLiup3evZvKqWBDQ0bFrR5YogFoLURGvKJWbh8Yyz1TTnk2fzFAnMpTA1jAtp+v+RPpGbZzwK3gmxouTpXTs+cD+MevHuGEXbaAEmRkamqK8o024a1UipHpHwou9WCF4Zy0QZK2MZnUT0vxUmnbynQpk7cJc4ZjU/rIqSU2IYEmn/gFN7V3Cvs+fYP3WGun9MXY2sMpzZVC6OExs19sYVe7UyDMqxjNRtwUawwWVyNe8x5H0OVmvOnDrmeP+Y41sHxmqMtaIUTMtMRk/ISM0G+Dzg4tGxQ1B2x0KLJvS/7PzavefEdnnHG26zxbvzazul+EaPLoAbhLZ7Do2gyFx/cuIsum6uMfMO6cfS3WOe2F6iqLiwPx5zPh1z1ecfcUXNDH+gaMp8ZD9RLiWm5KX1AkgSVkmw/Yl8auIg7zEMpxnzHofbynSLUvaOWa03DFlYZ2Fvf83Z0+e5cHAlt164gI2XMIr3fagJLJMnyCbUZsCvvHmjhXRsLuq9YfqddRIuUiG3xxvF1p1VRcqVSaQStlS6qKFqURDzjtmp3RcTVCyOF0pbtGnb3AueqIdp1IDEMwAQ9W7dilefN3W4pjhn6gZ+nEePViLkmPuKC1W0U0JadtSOSp7FZ8FstDlC6L6HWIPip6n0hQqbf7m1pbR5XMquF+fOsaROfZbi//g//g+Ojo74yZ/8yRMkA+DKK6/khhtu4PDwkJe//OX981aH8V/+y3/hmc98JpdffjmPfexjT/xtF8fHx/zP//P/zJVXXsnZs2f5h//wH/LhD38YEeGlL31p3+7OajQe9KAH8eQnP5l3vOMdfOmXfin7+/tcc801/NzP/dyJY9x888288IUv5BGPeARnzpzh3LlzfM3XfA1/8Ad/8Gm6U/O1vfe97+Wbv/mbOX/+PFdddRUveclLMDP+9E//lKc85SmcO3eO+9znPrziFa848f1xHPm+7/s+HvnIR3L+/HlOnz7N4x73ON7+9rff4Vg33XQT1157LefOneOyyy7juuuu4w/+4A/utL7kPe95D1//9V/PFVdcwf7+Po961KN4y1ve8mm77gUL7jHI3vNCshv8OV6cmW53zV7ZhBsFIWebuqztXHidgSHDMBi56dJXvEA6JDC7MarqUrA1ejBQMalIREAGIKcURa4gK+vKmwJIFsipRxmSRbqTEEXeCbWEFfHE8QqpNrOzXYz0bC23Lw2K+fYt91xnI9LMDRut+HZWMPMu3XUcmbYj0/HEZoraimlkHDdsxyPGzZbtuGW7HRnHiXGc2I4Tm2lkWyaOpy2bcWSzHdmOW8Zpy1i2lKlQxoJO3iG81oKW6kX8zYBr9zEJmk6xyVdwce8yLp46w8Wr9rl4JnNhhNu2ynGZKJeMo3HgtjFx21Fhc9sWu1QAI8lAHvYY0mlyvhzbv4py5gwcCbkm0rBChpU3q+uW0K5pShSozx50YzbQb494Gi1578S4SymIaLP327MXT/frEawdztH2eXuPcfM6k+54HvJxvuN/DCvzdnlhzaveAzvtz5FO1/JozAzbFm4ZN/zpXxzzvv94xLt/e8O7P1a5sWZYCewJqKJlopQt0+jpdOWwcHShcFsauDScYcrnSAd72KBMlzZsLl3g+OIR23Gi7gn53udJ8gCGo7PIVLFpS91O1O3EtKmUop7CZ9W7mEdXek8l8nqdWqoTZSIGpWBWIXpGeE1T1E8AVuPCW0rlzl21VukVxEaiIMeSIFnISaJeq6mcgddcJK+7yL4uUM2PE5FHXwc0/s8jLb6mRKpVBkvVz1VSSwDtGaBzQuacMNk5Sjt7UW906DGeOVpFZI6qkWo8+OyOjs6rVJwytj+Zp7Z5HYfTyconxxLR+CzFv/7X/5oHPehBPO5xj7vTv3/5l385D3rQg3jrW996h789/elP5yEPeQgve9nLdsL3d8T111/P61//eq699lr+h//hf+A3f/M3+dqv/dq7fI7vf//7+fqv/3qe9axncd111/EzP/MzXH/99TzykY/kC77gCwD44z/+Y9785jfz9Kc/nc/93M/lxhtv5IYbbuArvuIr+C//5b9wv/vd7y4f75PhG77hG/j8z/98fviHf5i3vvWt/OAP/iBXXHEFN9xwA094whP4kR/5EX7hF36BF77whfz9v//3+fIv/3IALly4wE//9E/zjd/4jTz72c/m4sWLvOY1r+FJT3oSv/M7v8MXfdEXAaCqfN3XfR2/8zu/w/Oe9zwe9rCH8Su/8itcd911dziXd7/73TzmMY/h/ve/Py9+8Ys5ffo0r3/963nqU5/KL/3SL93llLcFC+7pUNewdQPL2v/0QED3M/eIf1RyW3tDioSoVA453B2lyF4U2RpySdceag3CSKGjLzsaUYZL7RbIK7zhWXgPW6pXT6FWdyPOaREyN8sKRSON6EduLu1uSEQER6O5oMx/8vSvOb3BUKSGzG7k8nuha7QSKxWdQrGpVMbJ2GoQg2nyIt0SaVNMjKVFJ5p61FzLMU6Tk4ha0IhaFG3Ful5LoTVSSKwFcFKIfRk2FbRsGPUSl+SMRzhuM8px4eLRlgt54vhAKUOhHm3Q1ZaalckyDAnZQFoJaS8xJCPLCCJMFyfsNiGvjDxUxGoQrSYn3Iw/6c8CSZB0roHpxeEn73f7Vuv43Az3XeOuFeHvkoFGPtyvbe2odEW0pv4z5/D0MdQN1n4ujd30r544vzZmejqU9SP5nGHmIQjem8GVFCLwV7nt0Dj+2EXWtwn7eWCQiToVkOLdwyfFijoBaJXVw8TxzSMX0yHl/MDeesu6FgyjJEW2yjQU9raCXhyRWzYMV2wYjkb0FqUWRZP70y2BTS457Q04q6f6GOg0+VowON1LJDTS8XK/bz57VSJq2SIXRWDYsdLFaE0658iSReqV4Y0vW62Wde7W0pxacX3vuSl+c00l6r/otV5ekeFRmjY4GvH0c20Px6Mj4mGM1mavy2P3tjsWhKatizsjrmdXxVhwkttSwMzLQzBXacPXriROtRQ8/SvGn8JJVvNxsBCNz0Lcdttt/Pmf/zlPecpTPuF2f+/v/T3e8pa3cPHiRc6ePds//+/+u/+OX/zFX/yE3/293/s9Xv/61/Pd3/3d/J//5/8JwHd8x3fwrd/6rXc52vBHf/RH/NZv/VYnQ894xjN4wAMewGtf+1r++T//5wA84hGP4L3vfS8pzcG5a6+9loc97GG85jWv4SUvecldOtZdwZd+6Zdyww03APCc5zyHBz3oQXzP93wPP/RDP8Q/+Sf/BIBv/MZv5H73ux8/8zM/04nG5Zdfzoc+9CHW63Xf17Of/Wwe9rCH8apXvYrXvOY1ALz5zW/mXe96F6985St5wQteAMDznvc8nvjEJ97hXF7wghfwwAc+kN/93d/ttS3f8R3fwWMf+1j+yT/5JwvRWPDZA4Xd3GU3usJDHnKpsiPBaNaKomcDyyTcwym8t2G5tW694X4GZHZ+99yWJgNJ9xK3N3lLp2jqQL6JRFOvOEY/r5nAtALeVsCadqyPboCInjAYGnuZ/y+Ob+7VdCN/Pl8MSvW6jGLhBZ6ahK0xFfVi22lLnby7dymVaapMWhi3XmPhKVITU/WajinqMrS6epVqRc3Jhanf+6q604E7YgctD0jUe3eMG0q5yLbci80xrEdcUapMrlS0URi3DKsteV+pg2GSGFeCDXFrOokbSVrJWqh7QDasuEGsVbtx7b0k+iDyaENO5JVgo5JK66HcxsPOmLP4V2O4zXN9ko10CtO+14hwZ8o74++ECXcnJJPdX4NkdIIUeUHtdzv55ZPXYCcjKhb8auejGKnqY+bSJUreUlJmaH1fsqcyaQkiGYX4eTD2UyHlEb14yFgNPbVhTCsmW1GTkaoiXh7EZjtydOsGPXXI/tkJPVLGqpTiBdApAcmJhKd9RcQuPmElpJz7nBdxSTbtBFLm6/XQjc+3HnKK+ZHEe6c0srWjODWX3XhK1Cxy1eZskNe+fPjRUjuHzuYcKZk7CnSXgoKEY0PDGeLrnESnbw0y00hlI8uNjMwC2v1wQRpntSihy6TF731YN2Us82tUS76eZl/T5kZ+H9/Z3K/vk26x4G8dLl68CHCCPNwZ2t8vXLhw4vNv//Zv/6THeNvb3ga48buL7/qu77rL5/nwhz/8RMTlqquu4qEPfSh//Md/3D/b29vrJKPWyk033cSZM2d46EMfyu/93u/d5WPdFXzbt31b/3fOmUc96lGYGc961rP655dddtkdzjHn3EmGqnLzzTdTSuFRj3rUiXN829vexmq14tnPfnb/LKXEd37nd544j5tvvplf//Vf5xnPeAYXL17kYx/7GB/72Me46aabeNKTnsT73vc+PvzhD39ar33Bgs9UNC+y/xsvxA6zyHVbYqteVyG71tPO9jvypcxpCa043BJRyC2kjKc84R7M9qPMyj9enxHF2I3c6Lz/XgjajhNkpSkh1agdaR7THWdl5FE3o8S8w3gwmb7vHQ9rc7B2Y8ncmK+1so0i7hp1GK1PxlRDxrYpSJXK2P4dUYtxcsWpaRqZRleVKlP00Cjeg6OqRoF21GVU9T4L1oiH7qgg0UkWCmUytmqMI0xbpY6K1YrUimwqmLG/SpzdE87tw95p8Zz9dq8qvS4mAcO+IOcyNohHVIp6KhwJEW+klrKQckKGDKuBPKxYpcwgrXHbHQtgLcZdbx8dNRK3TyfuaVfSxt7tx/L8uQpBlHdMOZm3maMnzAICjRB3o/rk3mdqsmNsz5yX200Nmpu+q1mZe73rNFLHI6btIePmmO24YbMdmTZes9NIJWasgFP7idW5AbJQjguHt2255XDD8bjB6ojpBFqpCptqXBi31O0FDtgyJDfgi1kIE5RZRnlqwgPeJb4W7/9CVaTMP1ZCxrhHJuiNOUUiHW7F3BZD6CIM7T40zTiRObIh5hFFz5ia15EmBNFqIOaGeczPK8a44QRkhZBTewbST6RFY1FPX8pqkV7pD6SPdQvesVP8Pq+KLeVKdj6VnaPQJcJbut+ODgCG9KhLq8DpaVx8ciwRjc9CNALRCMfHw8cjJJ/7uZ/7SY/xJ3/yJ6SU7rDtgx/84Lt8ng984APv8Nnll1/OLbfc0n9XVX70R3+UH/uxH+ODH/ygFzMG7nWve93lY30q53P+/Hn29/e58sor7/D5TTfddOKzn/3Zn+UVr3gF73nPe5imqX++e3/+5E/+hPve976cOnXqxHdvf8/e//73Y2a85CUv+bgRm7/8y7/k/ve//12/uAUL7qnIqYUKdqQfe0ID0F6t7pCY0z095cl7bhBeyDCqwotpzQgJXUyxKMiUIBLtmM0xDD1/SrIbGF3bPnLBmxE66/LPvumIZ3SPYVesCbhqTBi1pMY48MSuOUmndZjufbuQKB5v9yeaqxWPTtQ6K0g50XAFp6nUkBXdabBXJsbqPTFqmXq9xTQVpmjcV2tECqJmxUmF90oozQiN6Mbu1beaE2EFwz7U0ygDFVe+sgK14ORhmrC8JqdTHMhEzccMTGiNovmB8FaDyEBa7zFcZUwbxbbVjU9VL+xNiZTVn1VOnoM/ZMgrhrIi1w2ZeqLLfIs6zNZ6GHBGpJ80T3J77vHT3LvhDb6joXbngqGSZI68GO1/Op2wdpA4pZ42JTOp7cS0sdb2SdN93WUmUWvQZJ6dKLeCcyih6FbFO7Br9loACflow1N8MsLe6T3yZedIRwPlYmJzBNtxZL1/yJ4Ygxqyd4CRGVlzlEaGchNpLDB5hUEV71KfMCgaRr+CDO7pl+zPriSgIskdAiHl1CWdjZ3ohzjJtCSkAajWi8CJ80/SFJriW6beULt6wTkaBreEylU4GFp3cAsnByKuiIVL0bqMbnuewlBg2n3wu/9udVZtdLSpElLeojKfM75voelxx7m3qValOyVmbYCIcuyS/Z3omGFeeG9O3m1nXZG7UAy+EI3PQpw/f5773ve+/OEf/uEn3O4P//APuf/978+5c+dOfH5wcPDXeXodH0+Jarcu5GUvexkveclL+Mf/+B/zAz/wA1xxxRWklPju7/5uVPVOv//pPJ+7co4///M/z/XXX89Tn/pUXvSiF3Hve9+bnDM/9EM/xAc+8IG/8nm063rhC1/Ik570pDvd5q9C6BYsuCfDs2MSKbo3a5CAZtO11CV/jyYM7YXiaJOYbG9h6XnZaLO9/OXbDD1PYZYeIfDGWm7cN4OCdg7mylWt9qMbhhKyuuKFog3eM0M9LSo8o97zIXlut7lvVSyDSKRUaRAk34f1awjjIRK3W6G5kwD3AJfoWTGNE2VbnFxUl7SdIsIxjTUISPG+CFNhWybGMqJljL4bHh3RqfU1cClebZEcq3RLR0N9p5Wxdle5YrKCnJD1wHp/jzNnTnHVKrMqlWSVbVHGamxyZbudmDanOd4/B+mIOk4c3WKMF/xaB9EgB0AekHN7cLXCeytatlj0AMgk8iozDN5hXlJmWCdWByvyek05XDNeqigjrfu287wWvYi0vdw8wwKTRyMamdgZXjtxhh3TP8hKGwltrLRNB4EhCVXDwG/5XZ1A9F9PEAjnntIjaf6HHQtT5l8bX3ICHbUk0lS00pya04mNUWMcmwFFqK00ODpcZwHdF8rZfYZyhtWepzRNZUQuHjJNt1JWmYOcOVjvkVcDewcrTsuW8bZjPnp6n42sUclkmTBcvhhxz73USkqehlcrFHVPe5LwuouXjSCG1Gixma0rUkmoQjVp2dalLmMR8RGXn27dQKXV4Tjbc+lkwdTnp7Z7PT/EICIJzUKRKBZvi5NKy37ywJu0YRImvhiDeCTDC9B3VjMLaVrBI3GxAMyRsIQUooaMntppLaWu+SqaFLjd7rzbWtLv00xQXUrYnRe3C9rdKRai8VmKJz/5yfzUT/0U73jHO7py1C7+43/8j3zoQx/iuc997qe0/6uvvhpV5YMf/CAPechD+ufvf//7P+VzvjO88Y1v5PGPf3yvc2i49dZb7xBpuLvwxje+kWuuuYY3velNJ7yT3//9339iu6uvvpq3v/3tHB0dnYhq3P6eNbnh1WrFV3/1V/81nvmCBZ/5sJCE6tGMZvS3DcSNc0WjaNtf5fGepznyUrxFjdSJgcCsOBXGoitNam8C1qQ/3bCLtz6x87DuLLvh7ekW6rnfYSWmlCLyEepG2Q2NXqgbeVvNqPAcLk9mcLIyEynfvlmVNhsUFU8nsQLmdROT1kiXmnra0zSNPS2lbqvXa2w9guG1G77tOFU2ZcTq5E3SIoKh1RumVXPjTy3y6q3V0DgZ7NbVTirHnGSiJKsMbDmXD7n3sGLcT0wXLlJvucR06ZBNHRlv2TKm21DZMupELcccXiiMGGtLDCmTJZOSgYxwyeD/p+jxQNGMVn/4eSUMK2EwLx5O68zBXub0sGLNPrcd7LPZbLHJPdVub7U+J3TCJzIg68EJyPGIjWNjujFQm/W+MzDbeOwhhwg/zLcFQRgM9oARQVMLNpyMe8Sdnb+aYOdgJ6E7X5JZ9nlX2yXKW2I3Mc7jXIUopu71ESGzal7Y3NNu1CiXlPHGI/avuJUVaxID21MGkzIeCtNayVnZ26sMB4n9y1ac2k7cdKPysb0tmYkBTxeqlkKOWFEVRF04IVkUhqewgjFW1VwSWn0stAJqzDy9LozxwXbrEtwiT7s3J+PzW9u9klBAlvn+NdUJjNr2pW0fQQCqeJNJMyL44XLaKv3Z9UqztoAl70OSxFewJg7V6kwwib4fduJJa3sAySLC1NI7iTUqCETrz+HsBAtpbaGlgXp0I1t7pjNJ8itT0l2owFhqND5L8aIXvYiDgwOe+9zn3iHN5+abb+bbv/3bOXXqFC960Ys+pf03T/uP/diPnfj8Va961ad2wh8HOec7KF+94Q1v+IyqUWhRj93z/O3f/m3e9a53ndjuSU96EtM08VM/9VP9M1Xl1a9+9Ynt7n3ve/OVX/mV3HDDDXzkIx+5w/E++tGPfjpPf8GCz2wkJVkhqasIiXeV6gTCDe9KkkJKU7wso+pBd4ypJO5Nl0yWtKOvH+/sbr+HLqwqqbSXdEJUyPFSzkQ6DplBE7mkSKdRLFUsKWqVWlzO9UROTHaykkgIyVMsNDyv2VO33NNcEKmc9IG6ZzOhSJOpVEHNKETjvMhtr6N35R4byRhHppCi3U5bNvWIbTlmWzaM04ZxOmYcj5nGLdO0pY6jK1RFQXgtBa3aG+apFf9R7c0A/SdkgNU8r91S1KXMnb0nChu2XJRDbjp9iY/depEbb77ITYeXOBwP0UtHGMek8QKn5GPcK9/KvYZjTq0qaTJSFvJ+gpV3Wra6pRwdMX2kUjfZPdBhcGl1I1BTwtYZWQ1YHpjSmnHYp+gBVoaIfliXD211EWklpFUi5xXZ9kl6gKQ1MiR/VjmRBvwnzZG2LIk8ZNKQyVmawjEpRR0Qs4qVJpgi9SeJkDPz9p2QuE2cBbJ4j4UWuUtJov6gCQXIHX4cEa1pKmg7hMekFUM3omjdDW8+BSISp7N9beaKazcfc/jRW7n5wkVuubRhs5mwtcG+IEWpTIxbZXtbYjocqOcSdlqRW0bKxUM2my1Hk7KdEnVr6Dii41wvtBkLm3FiU0amuqVW7/UylvjRCbWKUjGiV4xWWrLigBMV1RTqc9mfdvCrPvk1xkpN7gCIPVSMIr7v1gLPm8NoELMgGOrfSGYuK6sWRnjCyIhlskISRVKsY9ZqxVrVR5ASz+ua6/mjjgyJYnWVvuaIVBKVTGGQqK4wr3fyFEZ66pc3MFWyFZL593w99eNLOFmkGlJcneqTYYlofJbiIQ95CD/7sz/LN33TN/GIRzziDp3BP/axj/Ev/sW/4PM+7/M+pf0/8pGP5H/6n/4nXvnKV3LTTTd1edv3vve9AHcokvtU8eQnP5n//X//3/nWb/1WHv3oR/Of//N/5hd+4Rc+YZPBv2k8+clP5k1vehNPe9rT+Nqv/Vo++MEP8hM/8RM8/OEP59KlS327pz71qXzpl34p3/M938P73/9+Hvawh/GWt7yFm2++GTh5z1796lfz2Mc+lkc84hE8+9nP5pprruHGG2/kXe96F3/2Z3/2ae0jsmDBZzKk+o+rP4aHr6Uj4AEGaV7InVSTSkQYcCOsOYlFm2JLq8/wv0ud0w+a/eUpC3NqVMsAb4GOjBuC1Wwu9pbUMtix7N2Fk87exZbT7SI0ngoCbuskZk0p6QET6YXhrbEbJl4InTxVqkZdhIZ6T436jLKdmOroRKOMTCUkasNAm8aJafS6jNJrODzFqlYv5KaRh+ryozU09ttPK1JtMp6t4D38vLR8jGab1mpMU2W72XLp4iG3/jkcTRPH04aCQl5h+4aViuzvc3Cwz2XDhNZjLp2akEMjqyGTgihk70NSU2I6a9RUvEbDopJAzEmfDiTJUL1fgUupFureFssVNkR9jvRnLJEul3Jy6eHkNR+eox/PTUDaoIy0lkQUm+9FyKMIti2eniTJu7+3QSxQ43MRIa3ByP6M1ftAiBWPVgX5ySJRF2Q9qtICSAY07V3paX6EJ3uHtsoufW1cOL6X5lhJmze3L2xHgEGw/UxFGI+gThMi6uc3FGQAqRm1xERmrJXpqFBPGXqQYa9QjgpTKdhQyCmRdSLVSloV71MRdVZqUDWxTolBEi1TyiTSDGtxr3y1KPw3SD73srhogzf9TD0aYwo2RJBSW8TH71Kba6pQZfb854TXgpgxi0tHdCGIqoA35+s33dcHyT7HOxs1681GPV2p3fAURDCiLxrRth4lDeM/2bz+QY/qGN5ih1hfpDXa6Y4XdwDkIFIq/pPVeqi3EVc90XPkzrEQjc9iPP3pT+dhD3sYP/RDP9TJxb3udS8e//jH88/+2T/jC7/wC/+b9v9zP/dz3Oc+9+Ff/It/wS//8i/z1V/91fyrf/WveOhDH8r+/v6n5Rr+2T/7ZxweHvKLv/iL/Kt/9a/4ki/5Et761rfy4he/+NOy/08Hrr/+ev7iL/6CG264gV/7tV/j4Q9/OD//8z/PG97wBn7jN36jb5dz5q1vfSsveMEL+Nmf/VlSSjztaU/j+7//+3nMYx5z4p49/OEP5//+v/9v/rf/7X/jda97HTfddBP3vve9+eIv/mK+7/u+7264ygUL7h5YbS/D9kGkP8e/adr0zTRS6N3rZDatdtywXSt/VqhK/W+2mw5DqM3sKtrEH1u2iUqT08VTFqIItGcNtQZfc/ZFtwjnzKLoWhzWrfRjzSlW3RFh4CpKOqtg4X0gSjFKNW94VgpjndiWSIkqbtC5ypR/VkZXkSqTq/3U4jnyTbrWWpG3tdSPIEu1XUs7p7nAdr517V/afzM1NEUNyXbLdkgc3lzZDhtGAc2GrFZuII6VFadI+RyWj6lW0HLshcLixEqSe2+HDAcHiVOXKRduq4zquXCeah8SoYqnPal4WAAFm0KxqHg+e5IeZQInh8lSFBa759oNRU/lk4gq+DBLnkZGIqdEWg2sDjLrrEgxNqZsSsZy9nQ0Ne9DgXjEIydkSLAKglETVjPJMkk37qFOTcA1zsfceG3KSJ4SM0+FE5K38U/pskNtjO08qkgz8gaX1jKN6AIH7dHGNXtmf6LuJcqYKJuCiPc8yZYgJZIM7A+Zs6vEmUEZ8sgkgtoAskWZmCZD1RvjDWqkrGSpkApNocxZaqKus5OKmBNeFpGoiEc98QhP42AqLgpgybyeAUJMwu+/4c4EzEllm5MWln8XYWhLSPM6pOTrSLslQqQ5xg1K7bxjXmt8Fiq783yxef87z6rV0KTe78NoaU/t/DTOXdrCciKHyS/E+ZJFNHgnhLUrP2USN2teI605Ym6XUXJnELsrWy1Y8GnC//v//r988Rd/MT//8z/PN33TN93dp3OPwJvf/Gae9rSn8Y53vIPHPOYxd/fpLFjwGYVXv/onumBO/294z6s25RjcKAgPu7vtmh59GI1uSYC6pn+LZrj30L1+NVlvQiZBQDzH2kjJurpU5xBAjTxpiRe2Wor94gazqctKRpoEMhuy3agBD8EkyKLhFbW4piZ+G9cRdREmiopLytZSmcbKOHpjvVImpm10+J62lHGkTh65mKbCdhwp0zYiGpOrT0UNRjGXrS1T65UQmvqhMFWn2pvxNbPKvei+vbaH0FS+msGi4UXNiVUe2Fvtcf7MPpetBmwvU1cZW2V0jRdm37gBu5xT589zkA6Zjm/ixptu5S9urayHympvTc4rhmHF/qkVV5wfuPJM4c8/UviLWzZstxumolQT79ou+6yHPVarxHovsbfydKaLW+PCbZdgOiRlCcLg91xS5OxnvGg/pajpiQiRRhRCDFEnZaSBYcjk9RnO3usUZ3MhHx9yy81H3FwytjdgxyNaJ79XKbHeE/Yko1nQnNAq1JKpNZMYSHqE6tGsjISzgYynkWnPdArFMTOsejHzbjG4D+k23n2InlC68uEZMqieyuXpOxEZiaaGIuLRhzywt7fi4OwarSt0UzEdvRZgtWKQgdVqzX1Prfmcs+c4e9l58uVnSKcyh5cShzdd4OjwIselEHXNZIS8gmG1ZlivWKWBnFYMq4EhJdYHifVqzZBX5DwwrFcM+yuG9cBKMivJpJwhZyT7Z2szSjKqh6WcPGrUKaRw4qsglqIEq417QSX1SIPXjERtSEQkWt2+BDFDLYQlJMQoInGtCjI0jQEnrUg8s0Ye+3f8vqeIgJhGTUcnHIlqUIun4HlX8AhXSKLgHb+baIZISGgXoUXF5rUnFKuSR2wS8xhS8TXrec872cbg9lgiGgv+2nB8fHwHhapXvvKVpJR6M7sFJ3H7e1Zr5VWvehXnzp3jS77kS+7GM1uw4DMTXYLWxI0QvE5BJV6+JrPhDrPXtwcSmh6+0ZpUWWq5C7gPuG8b+2qEpe0Tuke3vevBqAaTWNRt0JKtQ3qVYDM7uS3tY50jJxLbmeJpDjm7Kk5LsehNu0JqMnLn3YCP3Oqoo5h0OvEzlonNNKHTiO4QjSnUpfzHVahKiQZ8eA2GRW63mnXy0Dstz3erG2HWbpq7jNtdo+dSzRfrH+eBiX2OcyJrDtlRl+UtFyrDxsinttR8kePxmO3hyLRRSKCaqRbfI7FKcDoZl99auXkzQfWIRvJiCTwVKWMMWBogr5yg1hHKhmrV00YawQNImTSsSFL9GUS+fLP3euF/UyJqtmBODMPAcOoqTl92Py7nmKF8hJGRW1cDnB4wrcimuAd5SKzWA3thHNYqTDVkmVFyLgyDUieJHoGzApkbjZlhGJAUxdqTuTJYKS5ZKqEoZBpFzk6aWipfmyMx2U7UbTAfJiIH/kyFqDNJBmOlHE1w4JNAVag1ewpZMvIZOL2Ge+0PnDq1z3Z9iuNjpZbYtuANJMM0TklY4alk5NbVxOsRRBKqGZ0qWjNppWiuqCbq5FEhTRZxHfHahQFKEHa0a1DNfSKMiE4RURx3UHg6WxCCdg6AJTf8W6yoCdH5Tp0o9KqGkBU2C7Iaz66nQIKzK3PlOdl5tirNsaFQY71I/YEBCU1z4XpPfZO2FloP+1qoaiVp03OOxBjueOnyVgRJbeuk3m4w3AkWorHgrw0vf/nL+X/+n/+Hxz/+8QzDwL/9t/+Wf/tv/y3Pec5zeMADHnB3n95nJL7ru76L4+NjvuzLvoztdsub3vQm3vnOd/Kyl73sb0xWeMGCexIGsbmJVKQ3YIaJkiXyEFpqRdqJOEiQFIsSS1EvnswtfSR1A1ipmGU3FhPx0m9Gp+9DNOq4mTMoyJGF097HLe2qpZ/gUZNi7vVOKFkMHbxGoBut4oZPkz1Vz40II8cNJyW7xGUYAWqhVBNStVMZKXWkTJMTijIxjiNl69GLWgvTWBjHwrh1j3zVSJmaQr5WI3WqqUop0eE7DA/THUNlR/qrE4uI3DAbTLvRn3iA0bBwoNg+4yDYKFALeuy9PPSwsloZ67phuFQYypZatmiqTjX3XSLXbEA1MR7DrVqBwq1lYjsVzJTVSkhDZioDpWYkZyTtI7KHJCUxgY5Q1aNZcfchIZZJaY+8Kr5NkF2tobaFN1dz4uhPqTUDTDIwlHtTLj2UwzMXSWdHNhduQo8y6XBg0OxdthGsZmodGNcgxbOFhmY4qjKsCqt982OXNrw82rVawXo9sH9qj71BqMU43CiXjkCG2u++G8OJJOoe8CH6xTTiWOcp1NLhWtpOT7Uyi+iIp3qt1rBaGTZWpmNIg5Isk3MiR9Tl7Gk4ewpWK2G7HkD20e0p0tHEeDRyaQvH1dhWpWohSSXJ7mRK2EqwoREmpYxKGhI6ZGrxehUVYRjE62IGL6YXXDbWC9Y9lNBrUtoctTaEbVadk/nvXoYTKVSSsKGPbl83wvuwU6kR6Xexz4gYSC9wmbvh9D4bzl4wzUTYBCKq2QrFLQcxaPVjwX0korK+vs3rXgR0ISISRDmThEOgz9ZWu4EhmtEkVFGIlMSU8h1I551hIRoL/trw6Ec/mn//7/89P/ADP8ClS5d44AMfyEtf+lL+l//lf7m7T+0zFk94whN4xStewa/+6q+y2Wx48IMfzKte9Sqe//zn392ntmDBZyQyzAXgzUmHS18SBaFA984S5dXJ5mJrS9ZTlCJz4UQ+iTa/pRmpyq6sPq3zdpYoovQsfSzUXRKRU9+LKC3UYNzb6B13/Vtr854JU7zqxaKxmG/e7SttKRlAT58SV6ZJKQx+q2gpFIt6i+1InaKL9zQxbt2YG8uWaRx7F/BxnNiWQt0WJgo2lV5IrqqUMLq0RTA6yZgjGv0ZhAfW5rBG3NI5wtTsFPf+RtSiFup4zCTCpoj3SEhNyMcJ1EEVlAPWdhqTQ4pMmG2QPUH2BYp59/MEm5op28zFdeKCJjZJWE+wnowVFRGhDCArQdZG2lNS8u7jYl5vYcVL8T0VT0l5QkgM1bqX2lsxGEWEJBlZB+lUgwKpglQjJWVIH6Pq+zi8cIwe3czxcUFx43fw8BXVhCJGVWWahJUJwynvYm4VmJQBYThW6laoKUUDy0TCGAZj/+yayz5nj7MKZWPIsbJRo07qEYZmRIuRJHkK0joxkKFkVw3LE2UsTECrBJck5CG5Ua+CUkJcwchirExYF2GUzHT6FMNlB8hWyaUyiLJKwrnTwhXpPMP2Mo71LGV/xep0IW22jLdtuLA9YtpeotiEmjcETDnBkBGm7qk3c0s5S6ZMGZEa8R8nTE7MMxINfS3DEJXRVgRdGdIKqPs6EdE2iX+npvbki0xzKvTIqBgq0ZyyxYDC0CecBCmiUO5vSK0mn1ZXISRPvWq9LXbELag11qSgAUFOWplHLyYX8UrvRqKIZ4xFPw76+mcRjWh9XBp6rVWL4pl/SZNHaQUnu5kdOd9PgIVoLPhrwxOf+ESe+MQn3t2ncY/CM5/5TJ75zGfe3aexYME9Bi1towutYP6ybalPTXGzuSSNkH7NYYi44avR9XjOMLC+f0/HYk5JoRkgsc8WNOkVsUJSoQ5tWze6Pf9Joaae6+4FoBapKl706saAexO7ypGmyIwIM31HpQo8N5xe+O2dvcvk6VLb7ch2HNlOI+PoP9M0MdUt0zS6xG1Pm5ooWqPxXqFq9MnQuejUQubHCY32vg4WHtGeM9Lc4NL+5uje2jDIuic1jBbVQpmO2TJ5NCMBZEQGt6YskVfCwXofyedgAE2H2AbYAFu3CiUXssAqZ1anhb3TiaOtPxtF2IoxYZToa5IV1hipGtWMKkqp6i2bW2SMiNhYoWRDhgGxIQaNkrK5dK0MpMGYSsj5Eqls1cirypqPYdMxYy3U7SUShVPFU/6KKDUKd7MpKwp7OnBwkDi4LDGOiaMj0CJUVXRyIptTJqWV3yNV8lBJec267HFmHwqVS5vKYBXZWyFZ0WJeywSe87/OpDyQTq1J2xXJKqZwbJVpSqQkZEnsr4VTB4n1fmJbEtuLsJ20k81iobyVMwOnyNvLyHVLYgMydl1eO30WyZ9DPrUiV0GOJtJ6pA7HbG85pNRDqjqpEIFUUm9YaZG+RMrIpIitom5EyZTeX6OaULWSSVT1yFBYy3T3gGr0XAkvQs5IybPiVNOPMHc4NP7Rum5bpDCmNk9EwpD3HwGSKpKKPx/wcWgaC0FGLaNW5/RLk1AvM8jai7ElVrpGgLDwp9gcHTF0zoVqy5V2WuMkrQVt2Y1g2MnC/q7zDaKu0tVuhLbI5SfBQjQWLFiwYME9Fh76T70/Wdjt9AZ34hGP3sQvDAnBuk3RPPAacpDWskogyEiGSImpMhOSpvrkNkGklLT0h3i5VwMqc55285Ja8yxa5yuYUIPguJJR7ukqLe1hN1UhzP5IlzC0KEaNfhaFopEiNU2MWyca0zYiGpE+VcaJaTuGnG3UZZh3+1aNlKlWhxE33BrJIAqLd4jGSctlPtF+iTtpIvEt5yRB5LrADcpUqxvQCMOu51SEQVfsVaOuJupUsOMK02xGkQSxwQuCDwbWpzN7JbHCuznXCTc6I3dEhkqqyqCVZK6wVcZKKYplgTQgNSxODE0uxet9C4yU8aLynMljZQijU8Uo0rzG0QuDxLASplPCtBHqkZA0cWqAY5RtkDeThKwyq2FgPwunRTizNY6LUjSxSQM1JUoxhjoxpAQrV66iGtmcVK2B09WYFNbJosGc90Oo/Wl4/4VUnbTLRhlKZW0VU2HCi9GHDDknDtaZ8+vMwakVh6uBS9tDdLul4IIH1TxtMa8gU8lpdGlamzxKZBnbZkxPI6evJA2VVA9J0wbZjlQtjFK9P4vWeOyGpoxMTi5s1z2fcAI/JSTXpjPr4k4Jr2GJOoTaGtSZIFlJJdLhWkSgzf3oc7HbKiK1uRljdVZc8+ftPSwIBauQQ5Y5AirRUV6MEIPw6BCGpyRG870k0aFcWu2HzPK2LUBoEpGoXSHimexbOFK69LbQI4wmhuW2fvrYbFJcrS6sfdTXqy7W12Se7cQ0/3hYiMaCBQsWLLjnwjwD2hLs+Mw7wQBmWcf20pRoUtY2F+m1EO3l6Z52Ca8ikTw11x0YXnzrf5FZXWauBu8H7Uq6/Y0tvVYE9GTxZ69nSPQ0LCMa8XU7t5vpSDMM/HuqjWRE8XfxZnzj1Lp6h5JUnaImY2SctoxR/F2nEp2955/ayEQYQe7Rtx4lsjjv9lsraG1eUtsNZ9wZGtvb5ShmM4lRem8ANcEYqDlTilK2G8q4ZdwUalW6mzYlSCtsNWDDgGmiTq4S1omPGYRN6l3WK6Too6GVGjKzPgAyIiWevEWtjqC974rQG7JoSBrXuPZmyCWJYnBhb29AZQ2WUBvIKZMHQ5pil0TjwdVAWq1JK4+GlC1o9ePlNKDsYTJFLr6TmJQ8vSrVSt4aueDNAqu6/G9pPVBoN2KnYNmLg21bUGvP3jC8y7okvBnhkEnrFWm9h7CH2bZL2jYSoJbIZqQyIdOxd5Jn9PslgsrAVE9j6V6k4RDhkDJuqJvJx6NVP36NZnHgqYfE8xW3oq1EkbZV7wY/VUSTN+HDZZ5rhpoh1VDJSgJVqFSy5VBeEi+gbusBFlN+p6lhTE+T6NKunprUMNd5tEkf1vocAmmss0sDzzuOYolOFOJrzeifJ7sLP8T+2logMW+6QhhNr2r+bJ6KFouJ9C21h3Tbuc5n1uIkbe2UtuTcBSxEY8GCBQsW3GPRmov1vOaWl5z6+9y3S80jF+b9zncgPJlhFO7QFX9Bq0TxpL+SrR/H4kXfcrC7qe0koSkN9SgKXaWlvd7v0OhMowg3vN/dmdpOqoZhI9b30UmGKEqQjDoxlsK0bb0wogN4NOcbo05ju3XiUerU+2TUqMdQ8/oAtfnwfptmorETl+il6RYbyonohvV0tH7XLcig7NhbO/vzVDMvZi3m31cTTJStwsVpQkelTlvqWClmIU+sMSYSKplSBY6EUmEsvg9JMhNJc0rXJIEtiFaTCRbzwWTm9TlZnJxoaraa4ulK4eHWKMY3T63XaPYoyXtBrIbEfs4UzaQgR5bFi3pr2KUJL6qOAnLNxvGkbM1TnYrgXcTJJJwcqUGuMHgZA0MScnWDsRpMxSgbL5jW6LvRPPJAtBFxmVUpxmjKGNdUkzBojHHxCohJvI/H5jizqckjBmRYuXwsGBSQWrHNiFGAimS/iXUvM5oTrpSPoSqbMnJpO3I8jl6rE2S35UB62pR5H5GS5v41JmQSRTIpRR8NIFnyXhkm1CQk9Q7cqJKqk7OiNYhL6h3VTxDj5oCwiLy1uNlOpKpt7yQoPmvpYTbPC4kUyN3vt3IwESW3w7GzfpkrcLVuFE1OuBGZRh7E5iitq+uGbO3OEmJtzhk9FcvrRbzvR5/kbb2Lj5Tg8H1HbY7ffgG7I+4y0Th9Zj9u4gkSBNbyYUN6z5zrnDx2FMQxX0P/tMVlhBNMTSyRcubg9CmuuOJyLjt/OWfPnGV/b0VeZXJasVqtWOcVq709zpw9z+lz57js3GlOHZwir1ZIXrPKQpY5NF7x/Mkm8+WE2HW0SdEJ0dxDIRpdJys+MUKGLEejFUvqkmjgn1NQVuTkD1d3BqsF8xQJKcVYBK0qaTCsCoQmclGfHJKSe9Ga/nv2mH6SgpLJ1Tm+JkiTIjm6mYp3usQKqC+0qng81KS/3KpGvmUtKCmKnFwZAowiGp6acBCF11A0UUNjWkRJaohFYVM8Q8WbXg1EV1zUCxxDpSRHsZslda9gTGCtld79Npi6mnfTTDEpNcJ3rknvL/GkhJxlJofX0BIkiTigJNfBJqKaBoVCVunnrY3FixcAurPHlVxMwzslOxmJEeMXqfN3w++ZVMiivmjH5LdwsVruPlC/PvGupEhij4EsGRN12fxaqTFmCL3+FoM1f6ikbD0/vWV8uHiLYRLNpKzlXUp/Rv568sZINoS0YffeGpbcP5YtY2Rf3Ibq4VzT8OIY2OBeJxVI1dMCUH9WNXRxBn9+WvAUlPAgVowhFkmtnlOaRJmqUcznrqE0mXCLQjoNz5N3L/XzTRLeX4VsngaDtlC0uXoOSjGNVJuMUalR8BYZ+0BByFjK7k+O5FzJPoa8kjdhDAxZu0fJUnTkjYXcFY8ir94/wJKS+1jIWErkMGyampHFWEoiVPO8YTXhu5/73LuwUn/2wZfYxg6CZITXzazVPuBFuECbfQo+L2LeihgDXnisrYg8jOk29tooNK1RghAvasuusd9+pynKZJefFO0vcQmvYYue+C90LyG59cawuVBXff43ISxr+2HHE03FpM7RjFoYJ1eSao33pnFkOlGrMXnPjNF7Y9Ta0q7iv924su6U9eJ3i3sj/YTadnF28Thk54TbpTarih6dCWZywiDy+6r9/jfryAwYtmwL1GPBLKN1xEqJNYh4SRQoEzZBwdcoKZ4mZiaQ1742a3Wve/JnXSo+DwlSowqUeP5u8Ca8ToFQNvKIlbYnRjW3H5RKjfd0i2pJSqwss94qw8FESqOfq1Z0iusRXxcHhIGKyIhuhW1JlBT2kQlpVUj5CDke0aJUq6AjQ81BhjLD+QE5PVBroUzqqXHJsHEIIhVdqZOgKZHWA7a3RkeYRqGgqFSGVBgw0IqVRJXMdFSgGFtGjqUgtkLWK2QvVJxaAffphI6Dv+sVkgl2ao+yPmDMx+jqwyQbYRo53iRuORo5OrpA3W7QqXpn+0j1YogC7hzl91ELlBRKvH28GF+iXisjqqSUnGRoRbT4+y5qcRi8R4a/ONUJByHlkOYx6VxH0By2TLE+l8XaMmRRMNbYs5xYl5qNaRprRGpRQiGF8lcsTXO6nVRAu5JsapOp0RfztUgMsko/dGopl21eiYXwhTQ1DGZG4euetHBkJ0kS77hmA1uv9ZAkO7P24+OuRzQ6jWk7npmPL0AS3goJT8u85OZ+ImHkhnHofoq2Pf077eZpLRwdXsKqkVixHvbIqWknm8v2AbaFw3QBETjIiWzC3p6hewArNPQFM7sFdy4bkCX7umRurInMi3vWHEVBLcE2gVQv/k/4widuKJoaYm5ImFow+3hQQuQkSnhY2jUrq8grVFGKubG0jlbyxZPpSHhlv3erFUyGNhdwu9NDrEYYpJKCACkmGRNhSJXmeXNRgsSQEwNz59IpXiCiCUvKAN6ARhIl+WLpz0tdpk8TloQhKUbGqoXB514wS6FOgSLVDf6VGazMQ5YiaCqu/qDiRmny0HaigijFkje0wpUstMbEtNbh1I1Dk+JGfAqCh4XqSwvxRXpCyqQk4ZbwZ1ExJ48VXxgluZEf3UKTCYWYfDG2nY+Y56FaJiVFwtuFX56/pFohVfse0YwrtXnui0omeehcBLEchGBCB1/QiKZACYO47yn5fBss5OsIab0o0Mw40RAS2grDEJK5oVxJ0VPAvNg1JV902zxBkGDpauYkziCZnjDCqhimrgYi0pRmYuXNmUGgJkWrUSMj2JDoLeBFrAr9/Iomsjipq9F9lWaUWfMRiJNLYoFPTSe8Yuaygr4u+YKvBkk8d3lQRZJ7rqoll0wkzd1f/dUI4muXmIBkLKmPzwiJiwI5NOMNLA0hcGQ9DJ+SK9AMeGGgkN3oxK/BmzLVUC+KFSP19kwM4dRId8Fr9NkKt2NnouH3NnvEwsDUSJNvaBlaxrKEDExrt9HeXV2lqmcwaLyvpK+3pBqeeAuFlyCpkedjQhSCdtfhPIyxGGNBVBqRhUgOIYiHr0ciRK8Hej59+zt977giVCneXK+lR00T4zQybgvH25FNFIWP45ZxmthuN4zbSq1T1GS4p9ujGNX3Hc6hOCx9EgY5mBWkZjIyP5z5fNsHthMx8o9udzGyu0d/OO648rls4iECrSO1hLNGDbMa2SqGmiK1IOst67UyrIxaM3U7ITJC2YO854twnkBG0gpkpd5MTb1ouOC1IlR367ece83uHbeaejBDRBErUBSmRF4lksIkbucYmSROUDYkbt0Yx+PIuB2p4wjhqFQSUrM7A82gVoZtxdKa9X7m1OAN+yYzikzo0TGMhUGMPQrJKlkT6Jq9gzXnz2ZODSv2hkrZV1J2rVoZ2kB381xSJq0yab1G0po8RDGzFnTyGhQLi16qklZKKhN53CI4+ZBhhaxWiKwQhCEVzuwZ5+6dOLx54GgjWHXHrqR9KKexcshQ/pSD84IOILcJ9XBkGm+lbCpqBXdJOSmSsBxT9ehdpamzmUdTpDQW3wYvJhlNGavZHbZ1tk9X5mlXWtMshy0JSxlNqTsWm5PP0jycPXARaXThENbqc1oaMY7h7V3GW4TS15rU5hIEgREsz87JZE3AGsxqHHjeR3cyNMnccHrFKXQ1Kc/GMsjNMRHXEv9saZwpSFXrueKcQmZnQFueGhkiz2vSJ8BfMXVqfuHHejB/tHPzdgmDIOiOndA260tJOJzbQ28hJZHmyamM44bjw4tszp5mOFiTi6JDRScoYeywrUgSN5bUNcOzHcB6j9VqhaQgDQxudCRn82rKFEbKGrfehTB8UzBEobEFf3lhYXw0tpfIquHZNtRyfygmzqRFk4dZ8ZdHDoO23U1tL5PQJg+tRDdmacYn7k2pTjxUfF/WRr4JpBJdOz3KUC0WRhncuNUai938WlsP/oxcZnGFoO5JtrWHkRO9AZYkz3sUNTdSI09QRKIHlRuQ3fMWNn1KiUEgiXt8BEEz5DS4EoMkNINZnlOURbBqwBrRGgaa+5zFKtI67JbaCYdU0CE8l+ZddEXbZK2Rhz24+Sk1DEp/UYlJkE7fWoIkaORQzynE7fp9H2KQNIfShE/AFM/eIwHJF2KbFyt/YRok97Z4NC0OkNzrUTXN6RlI1yxvhVgWHYQrzAVcuFsiYUEc4lbG2EthWBnii4r5sbGQ/JQcGa1uEKPuYU9ikApAiAaK5zKniqqnnaSe55uc7LSVLM1rgkdFCEdUROrCFSThNfGFUj2iYu5BSaZe4BhJsSpOusXUF0Ifee44CBaewqs9tLTpmLcpa1+PXI9ee5TRH4/n9Vp4xCyaJcHgL7Tkz9yGzJBbqDphkn1+JsBySKf6WEwS4wUf5yJCqhGdkfauEbBoxtbWdsVJ5UI0Pi4smL3Ey0MMJCJNFbcldwlGWK6Ar9ldocokyEDM0dweQngFd162PrboaVAWDpW2PrT3mXSXfeqRRCeYPoerhTPHxMlye78EQRb878T602IqjjBkqBSJpnqbQplGxu3WC7y3W7abLdvthu12y2a7cQWq7ci2eHRjjEZ83oAvemTEuhF2WleVShFdkKZxKTtjVdrzmO9A+32XR/SC1l3EYznxeSMy5i9hNYk1Ip660fPvlfZe8fkqktH1mrzaY71esTpYMeWEyoAcCwwV8taPUxWpAmQk78WyN6E2eSFyUyjSuCqLgEkyZOXX33oQSCOxe4N3ot6ClUqJ550skVJmmwamdaWUQqGikmA6QFcVzRWyYgVKSZH5MDAcrDl1ap+zxRiLcjhVTwM7BpXEOu+xn/B3Uwz8valynsyp0/vsXVS2RxvyVqIoRXqkTFKkYSWPwOZTRj40WPsa68pjNebECg5OIecPyFnI24JcdKIExeeiQMrCYJWzk3LvW5WPURkpFCvegVpHGDbYXmJYwf7hmjp5rcqUoW7dMWXm3vxGZL342TAtnlLXZx1ImrDqmSLklb9bVZ0oyYB7Kv0cdcAdxEnIyce+KVh252xLOmr2SNj44ayOd06rs6p+Xpo8Wp8ijY5ILWwS2Lu1HJ7e5PdKZZ4ttTrBGPD3huKRRYjUpmYvt1qSdv1t/iW3Sy2CPSmcdtLez43bGPPv7LoMkhNRtS7QsDuLe25SOMybCMYnwl0mGq05SMOJgEmv+vKTtH5CO1Xy7eUZi4dfYPM+xY1pz49OZXx+l8rFixdY7+2R12taM0LLeMjTBC1CGSeONscglakq+zIbN8NKUMs0fuqe3OZtEgYVZIWvGBa6yyg5GJ6GQW+Sgep60UNEKYJpiuVo4uhNl5CE1CgWS5EHauqpnC0c5a5WUvHrLxiDuXemavOWWmgpGx7I9IhGzwM0Q4OxJdZOkGL0evadr+JiTYnB79v/n71/abYtXbIDoeH+zbXPOfG4N7NUyio9TMJKIOgUPTp0MMN4mPE/6dPGaBSNwqAFDephVshECUqlVKby3htxzt5rzfm5O40x/Jtz7ThxMy6mXsYMO7H3Xo/5+B7uw92Hu5c7UlzPgiFAqgyjLiXFTSPEwzCczz9AT38ZleC0xNYaMIMdK02JRVkYNoANuC0DLoEovJQBtgEeiiLRz0cDk0ZMtYb1jZ4UO5Uul5Kh/Ebl0l73zKX46XV3mDfkK9QR2jYEkpxbIHEqMTiNWCtDwDGcYzCT3gvepwE25EWTMaLNOyxPrwIc5b5oZuRXB0KdPtsTShvDcPM2Qlm9I2VsWHH1+tpIGylW2QJLwBiMJoUUM0TJoWCU4WqGrSkPAMo11m1kaQdUGRIhkpUvOtsGVvmpZJUcdtZNAAfA2CENzGqOtyKbZYgu3yeDhAIgkTUwIUUJIAXAXDIjQ1LBA2k3OMbSl2UyOs2xgRGF8oGOvqapuof2de+ZRbkqinMroJI7ZkiJpAS3Df4xTKaIkR09Lh6X9A3Vz+q5kpFTNDcM0OnRtLsWrkHDaMAp2+TkMCmaXH61X4/3R0GRCnkVm75gFdi0Fq8JjAoSIUFaBxT+rwIwumSjkWqVjFyVy/HU0Y+lIyBlzzuRwiHQ8kLmbCsEqx1YGw1GTn57V2lUgHvbxRkvGvrVCLeNJjl8aKBTpsUReMyJ/Thw33fcHw887ipl+/bAftwZydgf2I+dEY+5k9ojHnx1XgKM2zkaYvD/KZTSoKTWY2ssGghkCoRoTtBOEx0rN8YWP/1c4Qt1LWOjLSwysRQ5yQIq6Axr1FFGw+xlwPyG2j4gP70gvtkQ04DfbMg/APk5Vh5HU6cNG5AviAqE7aRjRcAGZVBWiTrZa62AGbDpePnG8O0nAOW4P4D7fkPOFxw+yagIyZ7hqOH4/sOGP/t+x+fPD/zhYXiFM2kdD9S8wyebym3DMMaGGi+o+oT9/hGfR9CTXyANaBSQG/X5h6RTrmmCYyI3x+fXF3x+O/BjDLyurvcDjKYW0Wka6nDkQUdeHIzqxExkBtwnfNzgtmFsH/HRvsW3Hx0fPj7w+jBgl+E+qR9pPBe+eOGvZuDzMbHvwWtuwG0e8PsDsIH7Z8Mf3BDHhi+vjqMMc2Pls1KUmnsNwBSFyJcHCQEyL47jINaywrTCwA1jAeOJtA0J6UYw72Q6I0A2td+0p32QKt+NI1JGjnmJJnlh8bTDexDPUYfU8k60YxoqHEB97ed+qEYeuQyFaENFzksjbEDjkyo6oK2Ix7LZWi4se9hi8PA8tXJCKlummBxlAi6Sk9z37URLOUWBldBz5j9gdSP/I8cvNjR6v7cZ9GTD6PWTLtXfILhuJQxNINDczvN8jlqCu8WaGycoLfGYO/7md3+NQgJ//y/w7fffwTGYl5AcqHns8DfDHRMViZGJDYG9EoVP2MYNNga7SCLI7Vb0gYM/yIdHCbTRGx6mWU4ZNcZ/tPiygx18zpR/pfM5QHAZl2Form6I9z2gaEFbZQYgDaNMwMSQkXymbciTC0BgB8OAo73dA247LFq+U4muhW5cfBV8bvdz7ZDPR5CaxvyK0Ylm22QRDxjq4H3zSHiiyTkANDa8NCaKHHRnGNaHYVTQ2GgUZsBmE6OAVGTArGDurEldU557xxgFpCNxW5GAGF31JZG1kbZSDDubrjHz4BRKq1nSAHEprfYNtsJsi16ykmvTOefoaJtW+yjTo3TmhSiCyvIwiwUUSMEYSAz9zbXV3srhrlrebPFaob1m8rznWLRPcjtVZz8FbvQwnXcAeahIESoA9OD2Z6PDp7r3MCILlsS7rXurQfOBERIXlarENz0dBIGNzcfMgArSs6pkUEAROHopA0Xvf8qgrUQpp8ZAY2YYcDgAG9is52fDC4a6kjo2P2kGg14LKoMxWJ7Qm/q1NbNFQJFzAgvSEYNzTDtXzbnKsJWjufhjcKxIgurQteCVU0GXGiQUAO7uky5Vik0TExvvKxIYQWoXOKadM2Wqbz/+dln+d/ZoqmSrJ+EBAh1bTtsFhTsxuwSAWw9VtQL2ZZRQjpm85temfDwISmrNZ1OHOnZCnU1nz2i4Lnruiu2eIX3dYf+/I5c4wb1OmklqhpX6FsxCzMCxT9z3ifuceMyD5WxVVWo+Hpg7Ix3HvuOYrKqUQWdAqFJSrSRMGj7tRT5zM4RJACCx9kY/t7bX0ncFMFJ/UW84H3d9D/3d6/tPQEOvGx1/rQPbgOHYS5g7o0kVgbgfMCM4zdcDtcsoCUWth2S72TLy2WW+qa+uyCaoP90XN70SwGb48DLwvdNQSy/cLZB1YCYdQehINAyFDd/7B/yjGfirMNxReBtOmXOAPTuc1KuXbWAbA8eL4TgSj8fEHKnOhfTsM9IdYL6ZYipOQyIfA5mGN0vcK/E5E6+ZmkcaasQ/MicrWXXpAT5LFiKZn9JOn20DNk98tMA3kfh4TLzMKZ095EBR5NwMr9Nx34FjBg4r3G4GezFso+BHAN8ZHnbDDwcQrw+8vU4c+13J+N2DhMeKDmdJx7WMTMwIOW0PuDN3lW37QMM8ApkHQrTbSMCCmGSGcS2YwdIxolDOyPgycLXoib+MzRetx64XpxwA2TpBBrl0PXGlkb1wjXLUufmrDHk55fn7hSqFHmPmrwZWkPZkFijqxj3DhyjJwrIT95Ah0vcCLJ9hthQ6I61ro/Z41NMN/uzxp+VotOR8d5wBDUEWwyXEiYv34noenI6LoiBvTv0Fa68vZCTu9wd+98NnjI/fYLvdsH3cmLNxM8wCEAzJ2VsBB6MOicKRhY9l+PARBOLpqjtMQVNlqEGoXAnYMCU9gUk/EBpv1RBAUyC6vJ8LHFkO0YNE6fDSYqRxkJnY1Lad4ddAJ/k56jTMqjdsrsUzjZ7QAsi1aw2aiRqFFEVnSHlZnwcm6kxb7KEutU5OaRGkE7zSsBm1oaX3MEY/UIFRkxQWyMiCw8QfRpGO41byZjNR2YrgOeOkkAx5jZm8bkDdlPDt2OnX5uuKqgxnhQigkN70rGDCbgEuJEFBxHFgfXqasJ6GqE3gWFQpGRyWG2FEseLDBL2IJuMyBxPGRiWXgjnzhGoSQJqzB9dlcc9VnqHXWSvbkwqlva8kdX7OM5Aq9k3Kgsy3EPrXnmAolGPMCIEhkiX6zFLGzybBSW88v8pyg1VBU1tDHDKNhg1FdijguX6dc5ntdczF2zSEcjIGsmhYzmLEjBSEpOFSk2O0lG3BLVBJqbZJybsijazsQqnGELI8zgaYb9xnNxosm/KHtlKKnNHBscGQw9tRcwJKu8mApPFWRbMhNpH/XM9oMlBCTpRigmUL3apiXsU1gpHMEXMJODdykof3HizSKNywWSFjiLrTeRtSAD12VvBybL9aGn/L0YraGv2fjgy9vXanKFKpRP0VqZe86Eg3IWadRShkYHS33GUdyCNsJodD742SSbqMHH6nBGYhI9JgC2G3IQGMtd4J2k8wz0+UaLbKCZzAPGI13+O/iX2ffG0+8NgfpFSpC/gMUkoiAlGJyDYypMd73Kp9Af2s5/ruSOyysHSD7dc6V22DhH61P/iEHM5P2+V7P/k+dN049+EalfOmqybyeGC+TuRhLG/6eUfMi0XXeBtOg9ESfgOqnM6gMQAfqGRXZnZIHvKa93M7YBuQTOhGBgF7HoiYBJna/4zIb7D6BMwDiIfuVcMpL7YNhzkp3za0hipQ+UBEr5uL8YeJqkTMDcxD3AC7YYwXvGyOVxx4ywNvOXFkYHEKM9e6M0uMEdhuAKZxfGsqwiUKaRKUek5UPBAP4Hg8EPGgLtkGtluxQEyCUXgfiAmEKjv5GLi9OD68GEYG/NuB8k94HBPH4w2P+xfMxxti0fmIvK5Lortzd4lZGhuBcOZ+hk9Mp97w4cwfVaGE4YoWhAHm8OE0Ptzk3AxEOJsXFiMPS4l0Hl3r4RJnrhd/6/3ibrVeyxcHNtLFZGk8IKNB69vXmsQqrrBkSP/PW6ep/ItdcHiCOksV2wipef/N/GDuU53ba8kz3f5FZ7bMhPZ/tUGmDVRLgP788adFNKpDRdoM9v4zPWSydlo4tAzquegbBM6bvZyFuqJpTdBmJng9Xj/jD39t+Ga74eXlBRtbwYCEJgARsDR2MkXiqMT3ohINJ3fzxaCEch6uBWNGr9OaHOOmshKXv7/hbIqEOukspcjLtMSGRAb9XlUOeNA4sWKb+yL4SIXmEky8zutqylqKikVyCiMZKUERODPyG7AcHK+NBg8UmXEzgsqNijCTVJthzs6YfqCTjDtJ1VXyL8DNbKPD38yRDCnUBY2GQD+4McMMI9s+0HgqfOdaoHTwuBrSgOAdLfAcA4OGqqWEyQYzen2hKkPDDJGGMGeFpzGXJ87MMGsDb09CfLzQGNH6GiHyhDliSzB3p2hs9E5LUq4mDmAy5wGwM5rRUYIkODYLPlfKyw8KkkwKrP6+iTKUhSUwGGZ1HDDMKgyFmda1LLinovOEwBlIA8a2QrwGemZShnQnMHoUec5+Ac5LmBSQISUoIRaGMJaJbAA1lShqo1TJzKSoOwGb4GfUSRNcrs26STYo90E5O1byEBrwERuibPFSSRsyvBQYabCN57SEbUPv8z0aDXz20UaYyRATV7iY4YZsHqiek6S+WtEXJpaeyYXm/G6QtyHngK+oHqvkmTBY0bhJGeiQkSxhaQA2JcyYJdzisiaKyZdEFXzNVB+py438evz0WNaClKGKf6xGetJDS1EXqBzdkCt+RIDdJgZlDCMRKzFTQLCUv9ens6ue632nd606t9xWXhEjtics7iIEVIhNC6LTpqvINchvDduBwIhkUZSZOI7AnAfiOBCPiXlnhaXH46Gu4A/c9x3HsWNOFjXJLFJjap6RgR4v7SPSvDTE1UN4ec5FzcA55gth1TJCfM0HcKIAE1g+vbjLDLlaKgsgaNz19zKLGqgbVuNCh4rFxARelU58HEwebqDYxBo931aJlxtwJOkv01V5Uo4QVMt6h7t6ZZRhT8ePMNQE7lPdtovRDOJTU0dtw5YDn+eGf70N/FCGtyjmgThIrR0ybssxi8VRchaTvLfAODr6nAh0GV6WJeb4D4zhuN1e8Ok33+DPvhl4PAI/CrjT41NArWw76koHPtwKHz8W5l6Yj1Dfi9LzO46gLvEIvD6YIzFix+faYdgwXjbcXhI+gykbNjA+vGDsid0TBwwv5vi4Ob79QHwwvh3Y5gssJ/K4Y+6fZbykwpHCEMKOix1QIMWnCuksGFPCRRGGOalbMAM3S3gF5jDJYjq8EjRERpn6+w2kB2Y4bBo2S2xdWWkBWK3cdv50nqyUuWlPFHDmjgnaDTFdZmr9qRM5owqMtJTXWtMl8dbSv6VOAYw8gPqKqxJrPk2yZAUbrDNCXE5lUUlNWSNtLAhHNKPZ0Lq192pvFhk3hEl/6/HLczT0mNW7UiCgKSetRimkWkL0sDSAfjKfeMYitaFLaK1PGVazxxavsELkgfvrZ/zw+Qd8+v5bbGMDxoB3hj8K4SxParNQ91fcjeDKVep1mJG7OwZWo51irkXKC99GkNWZR0E+t8BEDoEhfo5lAAl0XNWPeMsJlsqkZe5hMigIqEipKITyLtILFoGty1wW4Y6bAc4yb1tnzA8AaYjSfYELhGUOWyAWQ6Aa1JEQhQakHxVgSIQLMGnRUYAOpE0aFRLEYzPUHEquTOaTCDiN5hcbGG2o3lwAYlNeTWDkphh7au5r3ZPZwM1I/XEbcIG8aU5PABhBIAWIJYARhs03cTcLNW6srJTMQwgbLB08sQCkvRgrWiW92sydAGzbYKWSu1FaURts49g1lkkZpJZAbDS2tnAVVy8B74FRKh1opGmluoUqfgnHUCMqR0f2OgbqxVLDJUAuyYWCwxTaTXPyQSsF0Nsjq1wX53cTqjalezfnXrVsaNUgwwBLVr4woNpAaLBfQxQAgaYiULNhsNyUCH16YLZKGG40lBzyCHJ33UQWNWNH1lF+8Rx3TTpyYYcBFaonDyrsggMmTyRY153KoJMWjbkxnvDkZ/WVxT2H6IArN6uM9wqNqypUtQzMLK07US2wxBYFdxGkmpFwEU2VU9nCYY5UhC6VF+OSHU2BcxDkldHwpXL9BdL87/RxOoJa1RAgQXuWaxxmq0kZt7PyDiDAnwWLpCN72XxcjQC4RuTZXBFnsHoblbTuQCqQivpSha4E0APtIMSKePacryZqTbfR8y2kz1K5TZfa48ARO/bjjjl3zP2BeX/geDxwHG947He8Ph647wfu82CZ5whksLM1S6JeKEj6T9gO3Z9BRC8sjW9ryBdtDBp7WH+KY37W2m8M0bmcqma45BtOK6JOI2LZHHrraoOsz63fE3FQ5iYcEwnMQMzENDrmzDuEVOq4TEC/zcLHR8FHYVZgP4L5LxVcG4r4s/iFDKctsY/EnIXaDbEPzAKNDUsMkBZt5hhuGL7jx/kDfny8sWFiAmEkWWKUEu0DVTtmbnxvDPjHjUyOnV3L40jEzjwGjIHEjfpA1C5sN3zcvsWfH4YfzFg+dg5gmqoGDvSWsGHYbjIAfMN9u6FmIHdnVN1YTjydkeOx3fCGD/gSidwn4tiBl8L2kniREZA+UC8f8fLbb/Hx8xv8uANWeNkSH2H4ZndstWH7UqjvDsRLIIwJ8HvSiF6GqvQNABXVMK5Z61gw5ao7M6+msFWXuDGbEIRCHJSzWdQjI6hfxi65DJW8dVKdtw2rCA7XZi4mC+9LlOxKlZnvBWkL15o3nZgG6KSQp64uurEXzV2RxdB+tDD4ZjJ4ddkszqPR6eFG2rC1V8ClH/3c0aaiJ9Y6B5DB8W5HFc7eNlyKNBrd0JHWlg229vMfP/7/a9jXXOlqeSjhIysKDYz6TttdgA4jXyIY/ZHrs7Zdgp7K9s5SYHtM/PDDj/j43ffYtoFtGGoTmJKXM+CsPHJM7LhLwNN6udn3GPaRSZyxAXCWf1VuAu+BPSayCunktW/usOACME9Sc6Kgurg0dsJhxpKtoQ1cKHQihIUht1I9ZS0AG8jS4s7CZmC40k10m8RNnmwX6ItWgGUIB7ICHgRh1IPiAS9NC8BZscoa0NqZFL3AphXcBwF4e5rAkrBDtadzBD2tZvQg1AAGE8K7RDBzlgxbATZ4v5v3pnR5lRywUNUgltsFmHqM0sakBYVhQc+ab+p3UItTWeKG2lAYFYWPvi1FR+89SwBDYWCzgSpStEYxwmCDORJkkSkBSh5PAKQgKXJlVRibqrOUclKETrq2fBarkDHXBYCxlnvIm0pPN5gsX6y0tJWLUuUSDKKpKRF1FmlQbqR6TafgG+VwYyKxJ2C3ISAlQYeC4abiBqQoNnVkFKlTDZwcjnCnXKmNuSBGg3mkr7LFqGCDqfoIt8IN8jBmOzyK7GbxVs0D1rVDnWujKgjglfg63JZRbKOYEyvQMnyg9Npwx9FGo+TNaG+SOsaq3hM2M9jQvNpJXbHg/F4DLxbqe6EyMuW01krVrKoAHybuuqtLrWCTbRJf3EdMUOQKokdahhGAqgGISugVnW8IYFKh1EDXM3dXTsyvx88e7SQxtFw8jQyhETRIhxw3N/VNkCo7vX+Dxl0GqXmGYs1+5d6gvZdudCzMbER+9piC1MiJk9Yiox8uL4k3klPtBbU2LYzuQvOLvmVn6rREWODAgT0euL89cP/ywH2/43G/474/cD/uuD/ecH/7gsfrTurUMUnnSZWbllOEUckFndb/NbqXh6rzwawNDBl49u6jbZxRe+OnkKYpt/3aVes//7ogwgUPrV8NTwfPGnSIMQTFCkV1kKpptsp2F0A+fdCQf/PCrMRxD+yvB+bbRNTUiTmZVNME3T0mNif8KIK8wSjJAbBbH0QfLq0Z3+EfD2zfTFRMzMNhM5k76vRQR014JcYMWNxo3NwGqj4ibw/S3ZJ9T5jftQH+EUiWfcUAoj7g9fYt/uZ74Id/W3h9e8MejrzR4VkhT/VW8I1OsukD9282zB82lG1In6vyWFObXz46vv3tDZkfcbwG5mNnwYwAjtfEuFHnVA7g/hGw7xGWyLzDI5BIvG0FbBs++Q0fJ1C/P1A5cWyi1z6ApqqX1wK3is+fvmxVfbRyyn0QS1lwf9BBRz1vLhKHDMRBwc38jI0d1U3rxaowgt3EH0nsN0zurwu9sBcn2VUXh4R6FXZVqitzx7wwUg5HvdOk5JIgKZMnQk4MGvbK36xaORTsyWVyimovbEAnypt6NNH52TmkeLr3tuVs06CWzm2nFGBeM/FeqcLWol79+zQ0SqYvIctVgNSS5f2cz3Ng9ARIAJ2iFegKQuT/ifah8HDTYBuw4PJMswpv9y/4w9/8Dt++fMDL9oLbYHIc6QeySg+WsjzmRL7tQN0BZ4QgsvDp0415YL6hihWY0Px7kEfn7VUqViwoZU+7DKccimQ0CV6ULQIWekRTfQ9ghbrxmROTCdta7aZ0HgJGW/TirjPEIwnYzRVqo52zDImigWJQxKZKFJqBzogsC0ViNnLkBTJpWDgcDL+SatybJFRFwWXMkdGPaLoXV2oOniNLoUAj+AsnIN8AmMKLXNhcRwOFGEy4NW3OmwfMWKPZvYBgNGMDS5LCNUcQ7cohvj+VDIGqGp5dks5ZsUzg2ww+aNyFxjyrE9ZF3Spgs0HDTE16qtQELwfMCx8KrLy0yRBMhsABQ9oAvOtlMzR6Q29i9k9YYEKCkbQIW3lEdIqUerVQUCE3Gq561tHNHsvUkwOI6gZWhhuKieVjoDFvqmEPK+kU0geGQqa04ZTf4RwLRjVcoV2DdR6Ps6nUQCJ8Q1QwitPcsKRh5PYCxQFP+aSLSZyB/VJckR8mHgK2Km8N6z407JpbaJqB4Yahks8MCU83sBJc8+eZ9GqgUnA1xAxnJAiRXA/yhIY8kezPonW0uQwLR22xaJOrpGAxZ4R4TNXKWkAbqWcuShTKVIBh8DPWkUSNhJEUWgATE389vnp0xMG0Zl16xSYApimtCNtS+6komZKUGQnEAvlVgEUtby+9v9XIlHtvN9IXLhzi8rWysWiPks+rIzm45VlcQ/eke27KhUv2DpzGivQ/zzELMQvHEWy6F3e85QOPx6FGfHc8Hnfc7w889gP3Y8f+ODBTFJtkPmJ2QZM8C28u9d2PlSUQ9TTqfbv6zkVXNghMW7hgnVdfWPTwdo2WLTrT010YsDjg9u7t6khQ32q1YOVfFiiVMO3nS5HlEHl+zkvrYMdxP/B6qArXVJfw2LCy4g2oZJXEqVu3lxvGxw+kzhYbBw4U5kaZhSINzrYCXgw1vsX26Xu87D8i40fsg153VCpK5Zhjw4YN7kONQgGfO/Cx2Ak9wIqEyp+zYbAPtSjXRBg7XvMVf/P7xI+fC2/7HXtM5kqCzr9o6m4A9kjMHah5oPYkbWoyuh9GIO5m+FAbvokXxDcfyDh4vMJF55qPgb11lBVgd8T+ezzwhm0mtm9fULcXvOUNj1cgcgeOV+nWHcf+hqg7atuVtF84c3AkV414q1+VvUCILiMhSl5psTuwl3JdlHPReQZumNMBGyx7bpO4ZUAJ5+yXgn6c3ouiB3PNqpdK97K47AuVquJr49wMblz71Sg/BQNU1q46pNB6RTtuqQE7918VgIdRRI1z/pdTS86NjkeiSkYToyTV+9ehqnc9qLrvPI2ggj3JuH/vhkYfvIfT89ALwKqn+ysKUXzjZdFZK2Wg7brr2YCr0LHzVfFX0wyIwJcvf8APP3zEx48f8LJtwO0FI4EcrM7DjpaJsMINBt8Nr58TqQo9L9t3BM2bi2qh67X3y6fU0sABgYQiAGYTwolwx4TjlqfnMkDPNulAhfBkxSUDYpBvzWZwBJ7wSaOmN5IbKhheuxUB6dHlcWHKGQGF8+o1wAiKQx7xDJRNMIGVTWrInNnUXC7XOVjqlgYT3MUiYRM8B/mLs1I5FzROvNicbFqJbuJLG5JSx5wNgPPllguUuRX8BiAH/95krs7qio5onjpKynZjsh3pazJ1s1b3ZXb3ZBIyu/4QnDvAPgply0BwFOZgZSovZy7CRuBhTW1oD0lw44bCpTWArUDgawNbJW5OP+N0cl6ZnNa0h01e/4DnUFKv8ixyaK4L5QMvoOc/KpW/4BTkEhTws5pWCgDR6GSFolRUwTv5nqY7HKQNMs+B63yohG7Yee70gRFAJ86YsbstParNNZJ3Hq4E9zYWWQHKDUBua32ZeMlMni94Dik5k9d5yKtfNIINpMwVSGVQ3s+mfhmbOXIkhjOUTtjgEtI4ua5ceTSQTEalXNakQA0KzCKPaqsN5ZM5Ij7WOoc4rB7iyjYmNPZ14Z53eYCGKpXIaSKaWFkixLUGoHK4vtYowGgVG3My96ST/AYKB3Cp8vbr8f5gvpnKwUqj0IkAYBR78UiJdApMudOLv4ZV9KDluYUED7hvwlWmRtELEfu4yE8AYUoOLRRLaBq9wF09qsE2q00LHNSp4wDAgvs0pPW17SBYgkyWep4zmQC+H9gf7PZ9P1hp6u3xwON+x35nQ7jjOHDEgVni9IfAdSf6Ip/pS238SA+foK5dizLAUcsPVuJqdoQDRsch0AZ0o5LLWKyQj1/OXngaEd2DnX+01SgbTvPb1BZroyyAWcqr0TNobnov9hyGJwzshp4H75PrwBA+5NBrThubxwHMAXBsqOMjZh2gpmATucoppwdOI2kagG8R+19gR2H6HRgBQ6IO5pbAGeUe/oJtUyGILMR+AHXA5kDGIJMAai4KYERhDOWWVWI7dvh4A74J4IdEzju7pyPRXecYuCVzgnog4fvEUZMVszTuQ7rEMJBjYGLDfHvB8TYRk4Vrbm4YgzJvGFRv744jHziyYJ8S4y8G3D4Bn1+Qrw88cIf/8IbYJrIm7pPGcUyO4UqGxokEGd0TdbWw8qKqmNuYHqwOSvoEEBPuiTkHhg844/fnGvUBN5ZJjpiIQ+klN8BdHcK9VKKeVF5XvpWUgTYA1pi2U4D+5dIY631ZCIlaFKXzDTm0OgGd1WloQ/fn+3A7nfgbVPa69xqdaD161+3BMwWals/35OxXAZZVOUtYSzUiaQDlZR+9cz/83PEnVJ26bHAtueqSjegUlNNQuMqDJUCkqE8ZUsvK6rG+ypf2VJQcFcvrYeSbHY8Hfvf7P+DTt9/h5eUDxrjhGARaw9pTQ+PHsKMOdnguGMYwbBvwEd8BZrhVYQxxyakrVDbM0FQTJA0CoDDHJkBUioAX66GbkmqdeQYLdLutHhmoYnM+5TZ0iNDypOXQ609PO7p2skqTZg0tKHpFSSMCCuTpW5GjmS7jIlMNfAhSUaKFSfBuordRCXFsWGq0S/XeWKI3NQ4GwJLNABlPYIWfImWETmgCUZY6Jx0stNBZLpYbiVGfkvJPmE+wUgUV1vAgfWh5y2iJJFx9Pqgkzdld200cfwe6oZuVkuOVgN3yYWuwbBvPkxQebkzgHijQmUVvXclDX0NVncDYUanE8QZGhsKxGoRtZVh5CA4Zr6rBrxKqtY31fWDAVIO7DHBcciJgrHwlQ8hcRKRgScLmlHuSR+6uspqzGD0qU+8UwG3DtgQcx96dgvX04APYeodfKp6hZPSQ0hGKeJgVffPGAr70RG0waENZdT9DbOpHs0maOBxRLroLO9a3h2eAQG0zSR4jrcgiVSWtGLGxQjcJDH22+eAENzRAvBy2sellTXU3MJfzQG6dpNHO0HUx4glf3iIWc2MESOQawALsNC/Bqo7A1t7yDnMne6mOcsQo4axFdDuTFStPKuev1KmfPZaq63GSPHOnwuwOtz2CK0K4vsw1XmZK3m1PpWRdgjlRhgW+qwF4mUpeY9GFJZFEQ4X6IDUYEWDXOdsVu3IeykhP7R2vqnOkiIrKi0QGy3kec5Lnf2ck43F/4O3O5nyPB3to7MeBY07MDMzulZGSd9VGhH5vRNKaeQGbOv8vpSy34Xr+rva2AJcGux2E1xW8KGvVMqEkR6/AUnv45yZcYOL9ude9FmDRdd57d9Upx5YRxT4Rc06WkU86qIargIcKSi00I8cFI5LAyEDOiYwDmROZZA1kPpPBKks0u4k5d0ROzCNQkatUflrBh/JIvXAzep9DWMQmgCxkd8ruZ83CmKEcEOaybS+O8VEOFguUswQustAVPr291u7I28D2YrBpyDRMumoVzRJcddJcjxmY847jMTGTDtnb5vCPLCk+KvEBVB8VhoeMwZEOf9mQHzfkY8eBRO0TxwHSAI8Dj/1Q76U2zC9rQZCpowlWjXvPXidcEHToQmvYE/A5EaZeTQ1G3eEzMDyQg9GegCjKNrCNhI95cRLIeWemqoQN3teCPecb14iemD860bn+nlCzIiNYD15xnr8jKes6pX1S502s815onGtL6z277JmSUVTXfX7Cd8mElhB9k8+Ryl9y/GJD4zTcFlkKuG6ja8i53+uP2GVzXyWCAVatjAEsL8NFKazPncIJwt6ZgS+vn/GHP/wO3376FuP2gm0zjCjMQe91ihbCMqoTmMDxAF63AjYBEzfUtgG+CeyBgD8JcNikZwI2YDhIDQmWAt0GqxSlGev9g3UsKggexbCXUAoC8BxLqIY5RoflQdBdipcvypxDdic7XhK+1VKWBikzMK+hmks6ZRi4MXekUt41gtWxLNYhSAWCJe1mh5LKMuCWCiE6bNDPkQCs2OuAKQMJ91BHalUFqloGAvEboz2WgfJaFVun1oHnBtzUCToGvHMULC4bwEQpG0gEbAzxKxWVMYMn80bCWO2FVPuAh0KnZkzQlzCyzVERclDSOOVyG6QYWTE/QR7MVoCJriaiCMlgo7eEozIFlAHI2GEvB3rsMbr+fq28lDIwByC49sYoGZCDTU3TMKyJHgqNburKrp4ZZYXhiu4Y37ccIN+fiqhBrBUpSImNSX8KSlqH7TnlDK0rwYzhXVIV0zocTS8JjVwad9UeT3PQ4nVgUxKlycCzgtXArUrGRgGuPVWCOzJQCuQK16hlHFQxx2bzxGEyCM1EIeTzD6iAQBrgY9EyBwosIzwATz5zJVIUTHjBkhEjuDomy3hxVzUYJrIwMiOHxK3GEsbUAatVJP+vRHIrwGexGhgop650UlLc6MzoyNGvx08PAtzT1ddNIFkBjsq57KKvjECk5NDpgAQ9hnXOAxp462tfUbLtTb8yn0tGBqNzlNMnn9mWR7ORVIMYk6Ij0BDwRneXkuex1PMiJuacOI6Jx35gfxzY9wcej1c83u5s1PegkTEPllmNyEWb6oIV67nrorM7so9SxGa9tMD6Wq9rHDRe58Cc0eH3eKGVel1eO0fu+TNNKev7EeiF2btvXk5VWON9XkH/r8YYPbEULJXF5OOOxOo8nezfi4B5gWfH6MoCYidVe07kZK5Bl181LZwqyq6MRPor8vh3qP0zct9RFWs9tJec7J5AN3eDk7ZZx0Camtgp0ZkRGlFCc8DHwLZtuL1ssO2FoD1VPQpa+yb94WBOybYBtw32MjDcgN0UxWHVO96WOFdw4HigjgM5A4EHk6pvDrttsCMwqrA5cPMbHrmJhnWgvvhy2qSxwmJ44jEDe0wcc3IcK9YMnVu3N8q5TrsIAbsPkOJHh+H5rEimyrgFAgeaMAF32HSET0aIQqyQYvM/y4B37lLR+HI5M+nwui6+y8+1B7S57fKmlv0pVgr2hNpNr0G5ongyYHqXiB4iv4eM/logff1+xdILpxvO9du0tDrvZ33BhLlLzlvhnpaD7Wz4JTbHLzY0mj8PQaxcg8KHOo2QtrIaJZ+bfd2UBL+hlEyLlfB5flgDIutsiar+XauvHgf+8Lsf8d13P2L78EKP/m3DkaTMQI2NsoigciiJ7m3HHa8YYLhvfPoWuzE/wYaToyekwKRe7fV1U4EKlbwU7xzGijQE1+TTsafEICdXAMddggi94BxIlpct22G2Kd/ktD57uE3VqEKVsFwCnQKYIjJE2yG4ZJKx29VA7P+nFovQpPp7oApj9YGQx8mVFyL+ekJUKsPp0TOC7hoJmwGLcXKQtTYBNjRSesaKVNGzonK4evYosIt6Fsoct16LRp47YpGcF8BGbVQGtJpElwnJJlP/HWNESRzsIa/yuIDmLuEr+iRHzFxgPYFpuFlXtyi4F+xgsnLXWC9RoRwuY5EVtGgHkjZlNalIZNxY3riWXgI+CV4JWIw5J67zlTiWqQT2wapLloCNgqn79qomFkPySlxs2xgVS1sVc3yYmv2ocpUkcqUDY3JtS9i70dvngxsjlGxmRk99VgMtZ6nOGqSCeGGDYwYpRCmqRTloXFqPBTiuIC2rBkhLiktTxBFngp4ZvG40aiuxwTBhjDLpNRomAgxcCPx91FJejgGIUmPKR0HdWJEIAY8GrpJ58p6FUcGPytWnheFozb2zFLMBMlZJ6ezkYi+wIWElJsA94K6KcbX4sr8ePz3ac2gy0KioBhyMNptkU4NYc1a0WV2e0aC5JKNryQtAWEHGbWn992eW91GfT1z0vVUHB1aTVuAEGTYKcIHVBn6CDQSYCSzyCrgPMxFH4DgCj8eO+2PH4ziwzx1zv2PfX7HfFc04dhzzUMnbeOr+3QDsZEvpri7IRKP1BPpLFQ+b6HQioSuo0vet9xoWMMEaP6z3+pzrVP39xhVtHLSRgeWaPK99GVy7/gFcgoF+GokCqgZGjUwR2G6wBnmsC0CGKijqOUoRx5AVWnkglM9Q2ZGGvjcXEKalwf5Fr7DcCdbzwEmMB/e9aJ2Rk3lkNrAN4OOHgX3csD8Yzao8mJOAgmeyMIXRwTpqYKsNMTe8fTA8ohCHQHgnV1uyiMpm6tuxwXGjs/ZhsAhUHaphUauwxc0GPtUBw45duSW5GTAcW7j6VyUb5r0M5HxBPVjd7Nj5uBmFuovm5YGwQhYT9gPzQpk6gXGzGpo/0/hdU8m5aqvD2BOltHy4k6ILNTFw7YZhjvBAjIl5qJmeGZ1NGZz7NMQR8M1ZlKV3pEpQY2FXE82pRJlsfLYWNGDMv0zUygFzI2YAilTP61omXaQZvnzy3qMJ+MjV2qH6821EeK99RRoByiScp3iiYrXjWXrYSk52itNlkMBsUe7IVvjbnWC/3NBQeLMneHU1BSk+KzIMDfppzgsULT/BeccSIit4K25zewF7YJYhI7B8Gjz0ELy9fsEPv/sDvv30LW7bDT5YuSE3ejJj0TYSmXNdm7WwHe4b3DbcPgywT0PRk+4C+rovs0Qk79eVeFrZ4KiU9M2IRhNrMsUVTfWrsANRZzQAXiyB6SzEh3JYOFCGHPQMtCnj4D2NAi3w6aqINcnrLYLRhGMwlKMEJZKNm2/HYd1QavTmDmTXbk49Jz8FkngSi+ZcVHyrW3YmWvDXMBQGSwQba1tXKGrE9SlgCECAO1Eo1Y0ldUwdmbkDwX7giTLODTmvjG6sxQ9f0QlzlhGF1qFtBhz0zLPrq6Efhl3UmxIFbO6Y1mMdcNCrw2pDA2UO3w54DpV/7cyjKwdbW9hIUyIWNaTT4PUCm0OqE7yzqxAjMkbgPjNpkGysbMbyqmwK14Zs5x5A9Kgwx209t2H4kIRlbxQfvc8c002lo+kRms4IGRP1HZ0rF0VHwGa4zAurKZnL2BFntYyRjIGkUbOVBBLzVuiVk8KCuqmXYSgqFWW4uTMpriM7fq7AzgGjo1ldD4yRjIWDkp3LrZjLQcOG+6yM3OSiy4pd5ZWa3vjHnZFFF32Su/+Sn6KGVTTwFZ00Ur5GN6gy7WcAAKN6Xg2MaCKNlqRVFPSi5M2U4PbuuK7GUgsM/np87aD8AEGHKI2UfZzYpz4VvT1hZ6Y1v7hm2wAq2LycCzjxNEoUUMkpFfWooozpppzVcLyKUS0p+S4VWwVRYWS4tjNKFyOo8JPelIGKiYxg9GJ/w/3xirf7G/MxXu843nY89l05G5NVpg52/c5I0YlPg+IENW0IvDOIWtdeGAutx9vY4ut6rV/oeui2Hug8VISCXxCQvGKVBeZrOTDXvXZEyK87wk57Y+0VW1PbRtJ6NhPWWO9L9/n5bCX5h2js028Vo5swIJK5lOnoanoNbU49QJqwqRt3VGEiSI+NxAgaCKcjoVAZiElnz0zKmE9j4DtzfPmo/hBtK5ph2EYf4SzUARjYeO/2MlHjwJe/2vH48YGZE+EAQmVtCyyWMNqQCIybYbyJSSDMhCo5zAbG7RNePv0GH/NNXcgfcgZP5D6Bj8qBmIEKJnunJ7AlIhz744AdP9Bo3h/wvMMHtXwUaWeVHW3M0+hDq/wuAUM533PezIl0qAKT8I/mIqtwgDgLYqmMYDRjzIHDAwMbprO0sWdiRJAOd3A2A77yeZ/WeWJFVpqpADAv0qur4WlFiLIYRnrZMGAMF+DXOs9zP1jLqOS1DLUKINToQvCMwlClyDHd+1X3qW227kQIXRjXVoSkR7nHexWYdJ6bFRBqUSRtPMuMnzt+edWp5RZQFMIAdFePwioNuCKduunmmj/dS/Nj9fVlVEAC+OJ1sP5lKRGVJatag3HMic+ff8Dr62/w8dMLXgZBbyZgFjB3NmirDeVGPmYY7ADsHixrehsCU5/w4kGFU/REWtLiZCEDY5KqgaC+BpurqSoFlQIrTfGYrFQVYCky0T0qXIBHXmQ+GQyktISzu2blQDA0AityB4cAVNo5HyZ6yAh66FPhd1YNCmyW6MwjAmNStxxGithIbKPQnTgpjAl46f1X15ShB4HBKjG96VikapHHzlKotKzUORoQXYRJSllt/NGyn17oEG3BYMkeHQzvisplylR2h1XI2Nl4DYBeFRjrTkOAWJxXSzb0gZFj2hzVQqI2YEzT9YtN3MQ3dgE+wkTAQLqPd+k8AW2DozaW/LUozBY+qTEwGacoVvDSfJqiSDQ0GN1gdI+fcXm0y5if4wUcXWnEDCZhs6GwlWOC+QlMYAPGtiEL6ufhp8J2wNQY8eZzhYQzmFidNlFlSiKXcFYWA3AwotTKqGzNcdfuNgSGsUZY3ehJ9cEGSJY0wgpDhlAnpdGTS3HRSmQAaRgW8iC204GUuNWzonMlSj8xMFTMgLhEJZWRMhYYmSO9cSqHSbkz2dU6BmBsCZpOJ0DZgNXBeRpApvJvDACCYwz+zjXLcSukaKIcszIqh+wSk+pd4pKLTKlSEyrt+1+PnzvaAba0hRKdlWNXvS7AKB7eqUbJbdgZ82XD0pMctJz1RgkK6/44WJ73lKI3FfYwNXW0TMrNLlwlve6SETaefLSLroT1VEQfUckk3f1APu6Yj1cc+yv2xxvu9zte7w+87Xc159uxHxP7nMvLnkXw976Tb4NjdMI0REFtL6ue0VDS2Q1qGuBJj/f9P83EBcNcANAy2qqNl/7qZRw0N8s+aHshL5hoXfFrcOdn9kz1/f70E32bTVtpgAjJFgLvvvnkzeRGRKZLns8jOLee2wAE6gBwdYwpAp9TerKSwNFZtXDGwJucW4+7sWKulfpTDdgNsBfmjWUwKmo24TWRrwfqDw/E4448pvq3qGS7y5M+gXokYgSOSXk+p6OmwL6VOMEbHJ8w88/w9t3AoxJzT1GmE34kYDvKC9OTzRKPxB4H4tjw4cPAJ9uR8YbHPbA/kvorHTOBmIVIJmWvheENjw1NW7yyg+Tj5d+KNjTdkEu65DAIuA0cRzLMXw5gUq856exH95nIojMyAn4clCNdjVS6uytXrsRIYQQuml4bTXfs+xWgdTovfdEisdgZVV1cp6lZF4NYlzyjtpRbzEm1MzqRJyC3drwsw74Xfeed2rkXrg6BDYvu1+XCBwwYouiVHGspOPi3HL/c0JDwa9GX9cwtk096bar24XVIqT1DPJne/YkcKFmF/fmLASILRjYGzrAtkBV4ff2CP/zwI7799hNexmCitviNlgOHF27N+xNnr0BAb28PvPirwBsw/AbfXoBRKklcy8ggFNlO3q0OKxcQ5oRlJsHi0Mc8WIg0N3mtzr4fpi4sXsA0eedFL5sK6XoWpoE9AZLALoeuV+DoW5100lJkgwkC9KUWAW+BZWMZLOqcjCLYgp0zl8Wa8qlQOc11OZME58q0AVNg+QyrwVnD2ZylgglAubgzgz0dmpPW4fFS6WCTB6EGuuIBu2bSwAmBXK+GArZAtIvmdRTHdBiArStU8KNeNPB2l6FH7hVWoh+MUSYbMAxS5ELVKhxg/wVWd1qUQHd07cDhg0ZGBcGGIjgOKDfFgGGYcHhORW0KmE4PBxoY8em6uhZmLaHg3eyxRJ8qwDd58jJgkGA0rl3W4U5+T5Q5AvRtGdZDIJjwmPkYpbGhoRbYJIUYJeK6lIkB9sygbGC0b8Aq5apV4nWdhQLYW0V844KifbwXG046EYyvu8C55m95fjWvvf7CGEVc/F0DRraBQ0lfSFQeWnaJcWMJaMuJtH6GFuz0HLIKGA0V3iMVwlYiS5ihyoGRyBqoyXhNWqpR5hAvGWCPNEpN9yGjeSpBl17wsmRTxvgaJPr16OO5Vj0n7KT6AsCzcbG85NqQJW9hw9VylQ23TiS+6q8Gvs3RZ9JqimpY4B73Yi7Uqdh10lKUm5whuMAqK421q7IWrclgqqDDfI05J+Z8IOYDcTxwPO7Y72+439/wer/j/mAy7b7TyDhi6rrsm9GJ8Qv36nEaz68x0lMDdnLfdS9qNIOmOq8+QirOwahzrfO8s2vezcPza+u+eoref7GA0xy8nqjpbiB4qh4/4HqWZQo9GTfPz/1Tg4UryLQvr5/vc9bqb3CutfdsRzpROb/WuYEAjbcsJeZqDAeAQUfIzES97dhrAEeiatJBg4IJA1QYMDYasQXYpJM0v98wPxviB+riUs7F8kqLu14DSDcc01HOXIn0QzTfjsolrO6I+Xu8/Y4GbsQOOvqYp2jBIvRpbFo4YyL3A2kTA4mPOzvRP47EI0mxxsaKgiUjoY2JZbi+G8ezF8T5vimKmEV3GClidHxCeKRT58sCFTtsV6clc4wxMf14Dr4ZsJXj5oU4sBxoDqBsoGpT0RUyFaiHmrGhGc9azwVVGkWCdDVRJa0MNQ012NA3VY7dgAXmDW2wy/AtUN8IT3H+cfLztcbpKm3ZpHsrW/jbJGiIKYosG0VpUMqxBXXrkz0hld4y7287/qTytr29V8a/Xj8Nz3oKrV5lBvSAWCZID8SVk3ZahevVtuTq7KxYl3PLrsEREz/+8CNef/sdbh8+4uM2kX7lpZs6TQIPc2yV2NKBmXhgYtgdZjeggK0+YHwkrjvqBUNcNCvlPNhEgpEMV9p+Kp5lSvJOPaDXTRGghGUg8yBlx52JRglA/SLK2SdjJE5wpoRhr4Kp5CXLlDalhPfCpaCwuAwVA+BzoJz0MXrSQYVmO6oGAg6vCfYT4GSOMpQPXq+MDeXMZf3yeTtXwzwvCerk0E9cFE0NVuwwZ/O+SKSn8gHY62C4Y1tiQIrVCVqJsegTjqIX+xZKem/KkpsqZ7k8XUzoG2AUYTUWtGOB2TacDEbqixZSl7cskJ7DcKUhEMtjwnW+wUcibWPBINEDu7mOWW/MG0FwJcrk5VY+illhVMiwMkzl8pBrCyBK47TBhiMmDZ2bGabodlY3WJfzE2BxdNUpesyHPJNhiXLX+qJQw0h4QA0eGSc1Z6EDS0WGzDSHCcNNOQ+TSfLloiEMDJ/oBmcwcuRJEYOMNXZ8NTkaXA0jzQBMX4C+KVofjMZ6GFYt920URpjWIJZHWdIHuJR7BrpEqBLfncK988JEHgOrjily1TjKCx2VYHK4qeLgClazeJRRornuOwB4uhwv1D7s+MxmfiEqWRMwm++NmrBSpA+O4UXPJTS+Py+Wfz1CfNKlPPmnNcr1kgNBgLoIGGBQhcHOvRBKayOkaq0jGpqQQaA568g8uIfKhjwJp29/pWY0T6EYXbMi9x4l0voK+6+WXzJ+mBeWBcRMRASOY8d9qgHf44798aZ/u4yMQxWUJmVzhiI8tary8Ep85k6e7WM5+RaiAZ50erV+lhzrqlPg3u7vMqK77DJcENjTeev9y3W1MORQkPG1rA8zXO/42Qi8Yg9b123Tx644xZ4uta6/brffqp5EO0/eYC/lBX8yV4R0Lg406xM1jVogrcFcW3vWkYbFkVFE6tGUoinKZ1f2A5A32AtzBBOF3YsNfH/ckDfDHEkKN1hNsplkBmBsBb8ZfKPOsDGBx04M0vMI5qTMuKMexu7z+UDkVGSBvScSLO9f+Ki1/obCA4jCsQe+OJBZOFZvk2C1TtCx2iO3rEYGBmRMnBN1cS+e894Rb72axahwXhygLNLAYj7T5JQcG7aY8BjKqyCdfKSxO1RJHWSBSfhkBxgcI0wR/b7vkoe/10lHLWQxdFLH6NwdrUgDchqpbKs5nh6/tK+8VgrBCqGqKMl1/Tdtn2rMgS6Zbox2dW+tpliZvpcmKuhgxcpV9qvU08su681tybYr6/Hnjl9edUrzeObPtQXQ73eQ8bSOSnSGruDBRX7SLHrzr+jE2pTA8qtfXRMXmdcT21SbrML98YrPr1/wzXff4rYNOco3+Ag1pGMJV1JrmCSNKhw48DgG7O0VNia2zeB2Q4wbPriMm8HSopR1Bkxu3GFsARQFAnZzABsCTe3hNehho6edyig0Irb6CAw9h4vWNNQxnDKRiYCzuf0MmGnS9Uy2yTvM6TcrIMUnzbkEdknKEcCoIo8XIxsOWLEzeMpLXih60o3e2ihTwxmsaAgg42ow4sLnLRkKbVcLTF4aObFko60VBD0rQXqIlsLJTytW7DL2mUgAORhEiALg8u4UBfWQOzrNkB6KYp+8d0YBuuqZyanZ+QOMZKQxnMsKRZz7qIvkSyZ4Q0nPVYZQMja7XHedagMERKiAJkYaBpiUnaJWQWHKhPoAGJPYIKCwGRTy5tj7MBg2CSWWQizXSHuvN1XEgsZpKOxlhoqB4fK01NCamPCWMWo45J6rIVG1V1N7doPLsHSwYaMoZD1kzmIMrkhcoJT/yHs0kN6X1QndgGPKu0kPy0DBlZiWa++nvGxcCFSyyVyH3rdFgzMLTHwUBYTRPyb6VdIgqcH8ktZbLtllvrFaWSdcAoCM4AYgtsaigFJ4edCQ8aJyqyXnOJfuXXrVMI3jH8nnQqpJpg94TXUY/vX42rHwsNzhHUhYQPQCUtI0j/0dsTSWiiqgC5mUTlx4f1wBZS0ljgVxGkDqn+QLzQYW0HAp9lynkyZsrOygnSvPc1apx8PEse+470wE3x9sxMeqUweOfeKYgciJ6FK2/f1aovoJVNe7p3r/B3XsGSHqry9FXKdt0JH+9+Cjns5ZC8yvEbuO/wXEX8d0GSrNJemxsud7t8v/uunsmq33k6mHsXcvn2aM8MuT8XO5lX5hGWuNbOy8v37WdWONndptxRup67OiAFMhgGSVKSs5LcAyvKloGqrXSa6I755APSYq76g8MEOGidChijnCwepQL6Pgm/RpJiznsjUL6lYOGq0+D/hkPkWc4WQ03+Mo4r9hEP2Z6+8xC1NwIRS9MbEahA7X4F7ncM2HcGCPF1kTOMF1nrZZT3Q7fJqezig7cWxkYM7A8Il4GcypCOZBDnfkxpymyMCIWJFPUoqoi8daWPrnvS4NLe6Jh680zEbQdnYu6K8nnvZZre++25+mNaax/8naXL8wN6z72TQea6cYZVJfTPQr1QQy5R0C7WSxs2qwcjd6PP6245dTpy4TzG2ih6xagqifjRu6FTqWgm153J+sllPyJJq9G8y1108LrSFpKwpbVwTmPPDlx1c8fvPAtn2EbdxAqVicD4IIT0OXhYt0FHY2lLMA3r6B2w3wF7z4K7Y0jNsGrw2FEIB1eKQS/xoxa0kbeXOjR6tM/DYBTHkwdXXWbQcwvPBS9LaHOT1kXuLdkVPIxcvlUbUtWiijGFPjOJUfwopL1rkZYbANQA7RSlLJ1xAYYr4CypBF+s+EqZEY8zPKgEpx+HFSbUIZjEMJgN7zW6DHXHzFUP6HlzNh0liWdjqV+4ZSs7tkGdNS3xFlJLkVoMpFGfTgV/rqrzC1TjclYCmfc3GPO6diDLY4ctC42uTRrArFhtjPJIHO0yVVR5QHUscmudhygdPjQMDuir4xH6VUFrjkxXQw7nhbyouGS6mykaJGegDu/8StAmkbDaZiv44cDGmvqlVGHkiCHVwHyHkLI1WI+R8CHWZsRth7uaDeIC51wTmNARlurGZCI5XG2VanNOiQf3tnOreJpXEF+q1EfWMSnqnyVIGepSqNrQwtJmHmqllOIxBUZFqbMaCGk7FC/IwkDqzKUCxdRovUNkZ4yljS3iSnkMDk/tuqYB0hXBE8rMptIeP3JUvNE1ly0i7hZBoQXSJZ1ETQAKthKFWycRvkzRsdEy5PUynhfSS9kCN+gTT/u3p0QQApdjqD6cBoI6IhK5U+ZOi2gFgwvwMIjQpX8EKwSFhHclXqn0ZrA5m+D/HJE5Rp1X4KNYJTnyLm7eACOnUNA8MyxbWUSuaOx4HjseN+3/F4HHg8Jvb9wP5g4vexB44I9YOI5TUN7asFgxvrop+Px5m/YQus9SvrrzYCLgnZJ7YjZLwM3IqWrE8vI+PZUqDB1md7b2QsTvB5N9pr53FFA9cHs/Pz66wdnV6Tv+b8J1YHsHhQ9e7tQo+DqMZPxsR5+ue764F/Ni34IQHVZDS1yki5yUK6eqiUGgsW84R4yqDOTF+0pdjvtDiON8z7RLalKfk6JPkcpBd3Sk7stQqmsEwvsUHTl1cBkDqNgKbwZLEIh9cDbBx4AFrjRwB7Xse8BStEGcXCiddp62E5EXi/SDm+5u66b694UUYY3/BleEdQ7m82MQ9W32KuoiPmYARRpaQDhpEbkDdVai9gU/VL2KqSxbnjBs4yOViJPVLRBwPL5JeidIRHpryIWk4+QHjDsIwTCrRcjBGCsLWc1n5aqYKiSa+PO0iHR6BKtKoes+SY0sjQP02RFgNWqfAe+rLnQg4/c/zJ1KkzwnpGJghhztBgR4HbyOAaOQXP8l33uRowE12hV9j6jJ3v9ie5Iq+CspAZeH19xduXV3z88Al5M4TdgBqkhghYhLyxW5USYA3zSJRN3OtO4OaGqg/wdFh9wMtmzLcwJmOXKBrUBMDmBjbDMcBDxkyuagIDBB6s+NOzJG9uUOkc4pAnsBKOCPrZg4OAT+BwdCSZ52DH8h1ZL/Tsq0JByQvdnnRYrrygRffo5mwAmiPcieJMWQpsVuteSK2S9yTPSu/hudx4NQj2h5B6AphBipPpHz19uYwxGkcGL5UVlQHRvNcVQs0uLcgOzi7aj6cha2Iay6laFDbVl8uktd7ULwdx51JUlQoXdooWdztDhqVQK7fL5qJAgZ56bvpUCVspTQk+0qRCgFZeqbEI2GB1jG5BLEPLhgx1CpSbk3aWBnadr1bsvGYlMCpUnYoAmZ54LCpTGXtUfLDCVGWzaimyFZAJm4Xh2xJkXcoWNjk+TbVTFCKqYBY6vwy3YJOyrUo0MtBoMymr6jUwgMGqaUPraDktjOWbbxiiHVFom+VqODkcOr9ogZBgtLHWspmwWtiiPbInBfnIS06FxkHGmXshU3k5BXkSu4hBUkB3AYIhHnCBktAU+UvFva1pgMbouSdq0nXYFaeqZASpGg8NYFsepJKs+/X4+rEqdzWzRQJvER3r8uEGVNJ83UCro+qNdReQkvdv6arQtRR1vkBHLkAVkoAJOIsKCWG85lmHjNBV0bDkPnNpx6ZKBAAwMhFHYO4Tx+OB2ZWlHjse+2S/jMdE1ESl/kUt+kXXw29w3bill9VpJPSPeh43nGNU/c06x/wE2BqDdnledHePFedE6MRa9q8/1y08w/XLmw3oJBuen+Pdt+qMnj8/y+X20HTsK8I4yTnvkccKbvQYGpZToQonyLtci7dcJ83GzmfsgAn1rgoRzAkTN9NSPXsBnLZC02h0IlUUC2yMWFtizAfmfEU8Dq6LHlOJky4MtjdFJwt5EIRPL/ZtkqW6onzqtG5toBf3zDHpVIp0VAXCdmIaMPISDUafgB9WPaFlYNQ5Jv3ZNtqfZkN6YCXCaMm9W7Ia8+6vJGZJO5eqEAgcw2AHz+W3AcfAtIAfgWMPbOOAeykFYtBB5gUYCwmt9XFZtF0ynvBQxgVpF4oY8PoWnIgajCYt407A9qzmajIClFMh42HZFujoQ1/WlnxJVRctI7ZMp75ht3dhFuM9lMZ24a2FC0FM7HLmqTQvYBdK288ff0JncKzdpXyWxqSaTt6RQ4r5FGmXEzzft/UAXt7ztfWxZJldf++Bb5BgtazdqsLj8cAf/vAjvvn2E15eNqQPJpwKJG1erFN9FELJM74FZhYwDbsB49F5CSd3NlEYdcOLMfyUTrBk5Y36YOWkUakeHnUFN+kEBUwnRReSxogPbCANhk0/SYMqVWMwG7AwQf6il9gAxESXgM0ayjMM0mwwSAUtlpeFG8ybm35dIJyFLaGIBik86UpTMgkfFA4DDOQWz+K9jGZ91sBmVIYntdfWqmAZWHrVuzSr5Vi8P5PBN/MU/BasZmWD9xkolLI0y0jlQclHJKMOTipQ774cFDCssnHARgK5oWuaMyEzL3Q2Z6UqQBQ/zh+rOpR4uEpwV+5AoTCmYrbDtEk1COaKBACoABOj1ZRQFLhZE26BHAOZ7Hit+kssLuAFwwvv1YONF9NgfiwDa/R8Ni0rWxjzfDeB6simNYExWtAgymjBwnWJNoSLmMEx4BUCynVhERiyttOAWjFXPz1ULo8KHGm+aCOA6ETLkyUesPaFVRcxlC2YRYpTV22qIrVIZSN7TXOVcgFUQh0zOZ70Qnf0RZE+Y8WrrOBeMxYRAFKeJSptp/bgFbRmmnrJhovsJFxrrUi2OaWHGaNcU4nwjE4mQg0dRzFimEUvNyuryehwPtWvx88d0iZGZdrKcnnkW/Fbj6KMgaTjodeZuS0vHm0XKe8+p5xG1hxsnBGTMoCNfpYAhCb0gkq7YqPWo+5lWPHaauRIQFLMr6hCzgO5PxDHHcfjjnl/4Pjyhv3LG+6vd7y93bHvDxy5izIVMjLyOgxAE5oWID5B+tkhvBXsFbLZehz080LRujJ0SxpfzIMT/jyZAcWBpdGj579GMa7o/QL1zzm+/KzeQ31/l8+eVsfl23WhLvGnoaOZAveXE6wGkEK8z6bS+XTn06rS4+Xs68rdZ6pftfNT7b6+jho97j00GlOJrL52XU8jOZPBUuXAZDL4LMwo7L0m67x4gTIUB/DYC8dB2Y6YgE9E05ElE4EU9tgVYWHErF9PAw5LWMVaTwdKEeG+8bowV0zjrN/zpE43xXtZHAsAar6993sPki39sdDjEwbF6mdhMtzXuFngmI7c2RxxVJC2a4PFSI6B3Q0jhnRXYdyKjlAHy7uOklOvzwlFWY1BdEBMFl96Fgn1cANssOR8qVVA6T6lSvFsLBtxheTXWgtrG9lyPhb0c5KmKVqN+nEM5or5WNTA7rF1ii1FN3qvdl9JSE6a1sy/T0OjhTf9epeDiGZ5EZ82c103mISLFtmTGXKdoPU9iajLAJ+LSCN7ecJurhc48OPnH/Dd52/w4eMn+MYKVOaBTRSkYeqv0TMVBBOB0Dp2jHrQMxAb3A1zK7wMYMQnmO/IOYAbPd6AkpMl2AYGmD1LYJwW9ASjAHd2AyfxB0hbPSy6moIbhZMVk1jdOYK5TFha516AT0fVJNVEXtfSxid1hNGmobJ8lsr9EEhGUSEFgHTHWXmAv7OL+BAAFc8cQERhF11laOEl2HNhFBjizU3zFLDiCLRne6DDvgSfqREo0BnM8qTkJRMo0JDISeHbtaoP3d3mBIhlN1Ybq5AhkGvjsFsP7z97LbkL8A1sWSjl2dDLUrBp6iuxwm7QJIsToU1s5EhYb4LOZ+jvyPOUbqscMBpkt8IsQAU5l2AKeU8d9HpWqdqUmjJu6i2yOxPLCxA1AzBMMNFjwLKweSGKTQAn2D3cIcqRMZwbRcWBrdC14VmK97Z66aRK3m5rxuzcltYCnv/Rg7TBamArNncKNz6TmkK6de6Tq8+GhJ0iIaSNJSIdmyuC6oUIJsG7MaSfMJhxF1tx7cUsCuauFpWkLZpC0og4IyINtpIGBtdnaF9TYZqp+WU1wYzhZ4sWVgGfKr0t5TMKOK4AWJQxlHjTJkd5kHZXKoHNXDxGR44zlPzr8ZXDys8GfAYsvrwKHbAkq0qLT86NaT1bUVaea1jywU8jwnTOrh+PWqKERwHYwYZdbam4aFKmIhXtzOEdn/ip4W5XIsoEkLBJfvjcDzweD7y+veHL/Y4f3+74fH/gy+ONPTTe3rAfd9ScrPsfvbbagJCs79jzxSBzYEU9n+TV147e6nWlNK3/ras0/F5GRl2+nxcaxxNA4TeXh/t6/jrPDZzjzrd6wq/3c/21/ujjSJv85FO1vv18f9egylosqKsN8s4kOY0JSZHTvCmg4t0dtHF0eZ7Lk59q4noPjmWkIhM5JyZY3j3XbPzcCDAyxyaOk4t9luZPukMXSgRQDyDvwkxXo4D4rmpq7GTSp+inwBUNw3ow5Jw7rfWLudu/9AZso+MEjWstLiODAI5Tsr7GOejeLIZaEaiUTrA5kE5HbXjAxgGbLPM7bo4DzPPw5L+R/O6RYOO9BuWAIiW8mXLuNTMZOXEC8yXfIWp7Zivu07DQT+YcYjXQo+q8zGqP59PSUK6sCy4pwtmFTRCD+MABIBbFUUxQ9I20o2ZV4zSuRDPQ6TK/uriejl8e0dACeSqucL68Jl+V39eNLrglwWa9cNZXqqXd8oafnNrLfuv3ltCSIJAx0wstUdj3B374/AXff/9bvGw3BAY24+RACtyr55SLLrHBlHCZNim47/Q0+Q58uG3YcGB3xzZY5pLc6o0gpgzltHoNQUCpSUJfzyhZ9oJqqAOoiciCg5WPwprTr54LVSrPSf44w2cKp1Yw0ZZInVy+eVLYhhsmxAF3WtPmZ98N9rIQz3DIkwqB7KaaAQBC4ApIshUFDDnjXZWCPMQCjReBrtbLUlABypaQpu6KSymjaCgPJvNMvGcLIJVvLXoeDIz0BIqJtJLkrkWSQz1CCqw2tYRfrMZ9FIUUkCSIifZSBg8JpbbY7UxwN3G7HcIGGAIHrSRt0QnZkbqVK8+fXoosjVPpJxZsbQ8RVvNBWxU0+iLppu7aZzEBiG5jhmXIsaLMIYNY/FRTR4zCAtYM6NQJPuDYEOju8isBHIw7kO5AJFZK8iY7iOup1KsEBWRNCSZxPKt1Dq8XiuXfQKHfkMhqB8qRNdizwlkLjFNMUl9Zs2CxlAeUG0Pqa0l5UwmHHraie9bwO8MBeOj6BasJ2A2LBO2TIAm2FBSXTjFZG8rqKKiMdRsuAnsaa/b+kNGYjLCuvQAo6sG5y2JVO6Ng+/X4mYN84i6v3PJGvSzs1DNl9DqHA1suuHcaJ/o9DTIoBFha26/f64IEuDeq37/chCXEaV9FRYk7oX130aO85kWBG9fuYeyo/JgH7seOL/sDX+4PfL4/8Hrf8bbveMwD8whEBOkuAhNALUpO9nUFFhZOXpD6itHr8n+c+8eur53j1gCvS+Bzv5gqJ526+6rQ7RzV5agGsBwVT5cuRi0L51ycP/E0jrY84SdW6Nv/2pF9Uyf+QxsBeX1R516YpS/eBmq/VLhEeTp6amu+SwjbrN3L53hy3drzrdYVg9eag5Wka1je5Y7eRohqZZfxAJbOPs9vrbAWAw5OehSVba41iZIzMuqyTm3N/7KPguC6C7C1A5J7y/qR+J5flsR1DeCnv585Gu3dv6yfoowl5b10T3TarM8lKazDgK5zn9obMRNw7p8Ykz3WwuAxMI/EdgvM24ERjjEdwwcyAtMTGIbhdYnUC4wvfCfc6xqzca61RWk0NdU1zn/VOQAF7YlS+4Aes8KlMBNOOYbL3reSLac8EZ0vWsCMwmpG67kmsqtCMjrfy06uw6adXUpOjcsy/rnjT6s6tR7I8P7cpU9ZdcBqPTXa6l9CoZultQQQ8mib8KSePJ//ukH672XPyqJGARGJt9c33F/f8OnDR4wtkXVbFRkIFnNtaib5ssV81cARCdgBPFghxNQ9fKTBPhjG2PQYN7gfqqW+8U7U6ITWgcEiVrh8lmGkEnslQdzGAiE9dlGDnQ2MCTvB7Gt0rWhSXBzlg4nuyU6Wy8gAJVOmobbCNrTblxuPSUmuij4F+S2sG9GQHjbUVA7o8K+R7lKABcvmdlLk4i0mm0fCVO2gaPDeikDQGxgmqUN04gUsHMNcfPz2iXAnsXJTABXAUPJtgUZJC+KCwHigowsJw/ApUCgPTBaGk5qCZPfXAuljlN0lWmC1Px/dhGuMwhxMes8CanDNunJtyK0HoyJCFJTXzlKyUeqM3mVMlejsFCQGelynKDMVqqDjsfaQL+qSYZOBmVJqo2llSjRtPZIwlKIHyEIMJtADio5o/ELbVa0g0G6YlS+CIEB3fidrIpNFhLlKRJ1rwW8O82DyNEShknJmRID7NzMV2lZOkoHRGgH3mQG403hKalaHihVApXzrkAE9ZE7W6ujrVVA5Fd57Qz2V63MUIyKlBOIlvYMVilSXP2GY0bKHPUJIJztgOZBOZbwJTITuJiScu0N0J7EXOhHYlyRrLnYVjUVkMdL4RGX59bgeJp2Scng0TE7tL4oj4/w3kJOSzhI1sgGCtXEINC236R0lg7g9eryKPH3WSOkdeHxCSieYLKNn1NAoss92frFQiEwcGdhzYj92HMeOx/Fg9+99xzwOzNlGRiJXP4YenAbrWHRQvnyFc3gatwviPgHPshY4lotZVE9P/HTWE+PyRNfPdX5BRwjavbBQ9ZqEWg9gkPWwxvoy0Fd0bpdrrJt5HuMFXO3ydbEpn496+vF+jqsFp72/hStGudyMQNCZ2YjFhEA7sa7GhvXY17r21RRZRlkXi1hzfz58O3cFP/U5k2fy/Gg/WvV1MoFFLaxevOfT9/CZ7uM6Rq0/tK/k9UGbkatkd6+xaz5A369h7bnzqerdJFWr9nOM1ppVGfvL/qazsm++HblJnDYmu50nHY0jNvZDOyZyYxGQaQNjDMxkf6hhnT/I5215AdDQPodXGHVwvTT1Ce0g7HPoHnvYzETfLJCOdfHCn3urFwrWXFmB7IAem56faocDiLkr1npa+2vRimvdx/nFvmRprVxpXT9//HJDox++J9TeC6sG/NoK6/OiEVzuuQeIQvo6uJc7lrxZa0wSrVrWQKB7mfv98ByN437H5y9f8M2338JvN3ryg/kYNJQKli66UaFGYiawYRKkpQMHAHlNfQAvbphjgzlw21i9qORpJwxxJrVq0qxoqSbai0uQ6MNQSeJJSsgESP8xODxD4UbRNzLO6CG4UaKCnt4ieCUlS8A7AViymlGCnl4EkBs2AGaJ2VEIO5Vo0zTCsML4CUe6YysZGLKNV2MagMJH4TeG2pxhRk/C02ByN6tQpNbos8FDwyIwk6B0SEOmk2JmMkzozXdkTtGZTklVziTLARoU5sz7AOjJyCIkZsUqCisCbdG5CmjQHOj+IDQSNjPW+x4qcbq6h0ON14AOOBc2wJb+Wd2JzRNZu9YrjaqAA5NGLjCQ5IYBtknxGYr1tFBwrSGJTm8aTzHiM0QNMV8CriuJmJNSN8Ck8Oj3knPRet1FJas2xKt1u3ipUpK9GFdvlyDlMACUvDYBFgMgpZ35FxSw2vvp4qcPjbgMiErmc8jrPNyxsw4Bm98VcLSHKmVcgoYpO6AXuv8BEopaHErSdDn+gvlIZgxpF5BOw8HlFcusMzQv4MfkOij6dypDJqp3dMpUmpZ7JXUtgLQohrHlpY1TzJ88eY559rhXaOx/Pb52GEqV8HiceqVBkz0DqAa4UpQkKsmpp8ovBXoCO5pECSrHU13ObWcU8YJxdB9YzoZ+rwQcS4jHl7zGk8Ju6tzMxB7B5nvHgePYMR8PHPuDf89JT2wmIuUQksK9Ymy73Fw/+xLgdlnfl5efnuOiexdOa6ur9fP1+QuKptq6l/N7a0oa763cL750GUW9eBok7+5rAdDra+fF2vt9cew/Hc+v8SG7qs4F3767Jk5w/jSu9pPPnzDv2dBaTpdeG1XLhmpY85PnkSzq9xihuMzYql98vlR4/mnXgdJXz69Ibq7Bqp9Eg3ru1vj2sD0/LlC15ufJR7IW43vkeJ1zra0FYq/r8oxUlBbTGst1W7aAZn9vSdnejEZctIYik+V60zGKRV66qEKGocKQc0OMQFTgyIDnVEVTX/d60pZ7rNrRUWsTnhi41wyNCVN66dU+61+9dY+cGi7dXNYU23dzBMkWCaEeK6yxugoFDoilPdH8zvPVEmJ2mbTSPP+Swuu/2NC4ht2aTfDOLngyO97Jsct2w+md6yiEfcWgRVu8J5cU+vt60eu+acMnUTjmgS+fv2D/zRs+fPiIGoEc4pdjA4Ya4xkQ7qJFEGRvCVQYoiYOcAX4cGw28HFswLjB/QVWgboBrPJvDIulNMYoRE1VrlGYwwnCKSxyAQuWPG3wy9g3vf6hqEGdAhoNIpmMXVKWNuSgSM5WAbAh46fa2BNnEKzew0o8psSlQtf/p3dd92PsMJ1NT4FKtpHnhSr2ILAiJQHGqlGMzHCShhlzTta0FVCO9IEhL06hcCjbiF5HQnSkclsKKAvAb/BKJuvXufm82DU9jJEcPqXK6ZojwPAmRO/KSrizKZ2JptVVGQrMaUkZShwTgkS70OGGwO+8bGBDIYv3NgCCaoc4sAXfDGUDFeT7Q9GO0d52NaljydZikljJsGO5jx4ZDDV+6l4zXXqWvViMFWtoPfA+Eip7W2eBHIEdVIe62YW9WoDDFFlj/5H2RDoS7PvAyMkwemWGGcjTdbDsrwRYccVagYguuvlUUx7lKTNFsmQ8mZuMRYKzSq7lsEIVDXEveq4D8khHiirGuYxlJA2gElM17x0qE1yieaGW4K+qbvLOylK2cb9rLcCc1dFQJzWglJ9kLRtZvjoZ1lpUvgYyW3KPufOespJ70NhVnoFtW+Px6/H1o/sLZDtBANAj6jjBcVsCkl0NgxRVpfF4IsduBEo913Lm1EN1ATOth55niGv7mvvRXsQ2NAyMarR3uWvtsxoQ539m4jhCfTJ2HHd2At8fO46d0YyZjGSE1m3TVJ/hHPAeVjf4agNsjUq1psYJqPsPO182vF+WC3HzfCXWgvezX86l8W49v5LuCRB+gvIbxDdPvBr8PD1jo80LWLoYME9oodHcetZaFSKfz/WMzNtweXrwbir1flzs8gS2/vc8Xtex1Wu2LI6+rD6k6zRWOrHYuZ7X5cqevn4+ts7bFL+1cBdyvDyPnhmnU9guw9Ifb3BSS2/33qpzrHs+Hego4LJn3s/180iu+6zr2X8y972CfUWmvB+r5zjP0657r84OpaEewZK2o2h4ZB3IcmQM5AhkJmYmPCa2cNQcqE342KlP+/48hzCFXsseKt7L+TRkAnXUB1qHpnns5cCWAOczeBLvdB8SsoJ6TuXsT0VzTNWnwPxk03ydw6dxVt+stQt6oNRAoxs19JxdI51/7PgTytueQmR5YFArcrFEhgBXddTgsgAuW0mDgidj43lLcyK0dC77oS4f0oJt7t5FOGQW7vc3fHl9w8dvvsPthaCyYBiD/RMAMMkYLqoI/zW/js2/Cj53HHfD63DY7UUhsYEPN8eW4qyzg5rAs8pQm6usbQA1sLlhogBLVhqKpiqlKgeBABiGCnqsX1hoCM137+Txjn+xW3F1xUVA3mAuGnZ4NBi6cdRRk1zwtl55UZ5bvMrEQNdLrizcVtmzbnRF8MbcDi5OB1aHSgdpUwmVobVkE0LI815DRhFntTnua7HXwNS6MHXEqQWk+dwnjcHJF9Q67CizrbVII2hwQtR74uTus8IHx4wcf17T1JW5c0xCG4q5G3GJ7lOgaL/zbyTLV2rMUIMGhLFnRq976g+OI8u7HvSmwBBGkH4LUnAYASjk2OStZ8nAclYsGpZ6XgIuJNYcUBic172BRtOUwCsDK2eEseldFXxSq7DLqepglTO6NoDsbAk7+2+gQKNTJVptpBo2J/baEAVsyYhitiwBgCCtqj34NCD5jLdrFLeTZdWsgDkylDeHKrukqp6gmEcRxWiYu4HJSrWep/VgVnBPeGGC/Vk8mONkyV55ZZNh5tqUyA2U8kQYMaGXqel4A4mknUwDI04BXqYKoMaqU82p9zKVo6aydxjlSCoH59fjq4cVjU3uJ1v0qPUTWBEuW2BS3sEh7yA6X4yfHwWVNgflXlMpKa4FrHRuRU/Rp25duYxsSFaxWk87Tka1ruk8N19yhc38EvMIHI8Dx/3A4/7A/XHHfX/D/X7HPg9WmEoCoNWM7QLgf7JsTkx83m4DoQY318+eah+nVl5DKF3f+uM8cZf8PgE7TpAEO+V0lRpt8s2Wqf0lW7K8B9+eWUg/d7QuyOvzNLLQuLynEwlbXHFIR61/enrql7q8AuAJeFWd43vF26cJADpAqke+R7iWO/EChvhOLbKBxhly3LZMugJYiGZ9QncUzj3Qa/YSlaJ6lYe+EoveuT7SY9SLH+ezPT13F4m3E/yej42qy2WBMxyJOpks17Gq3tOXk1xWwPLYn4tSxrqdAw9Rm/t8SWcEHRWJsMAE6eCOxKiJYxi2MeCTOnx4oLaAbY7KA5k3eDvwZEgkuleOIjFyOCz7GaXeGeDr1hGby4AUln6CmaL0eNrXmZyn0xg4l0v1H7R+QBYCzj3QjATvyNDFoARoqF5CoSa8R/VJ3d8OjV/iBPsTqk5duIHvFg3nzZYH9BqnPJvxPQ9El24EtHG0IKtB1XXrrXiiLt4rfw0OzsHuDQngmAc+v37Bb/ffAB9usLGRhtPdhM1QtQkMEXyxhjTR15YGBCsOmB+o+wNjfMFmjoGB9KFqD5vyC/LS6CRhmwwNK3qFU6CsGDlhlCGl4OinGC1Ms5iILuOEFXXaEaFEJo15CwVa1ZcKYGDZThcdqSwRUcDo5mtc7VYhSstg7w6QQ2AKo+ZkZGWu6JN1qw6M7FAmKTAFlks1179OaleOiYlQNA0gjYWeOHOOtYkCkVmrIWEm0abDgBkobBilvAWNQVgiciCTNaOp9AwZLIeKhJKfSFcpd2Sy0oJhEFA6AaKxmQUrwMrjiaQwMu/u7S0baazwb0oJ+b1hofwEgXNuYCrPsE65DqDUpT1ZMjc7h8ldgt6A5PyPDo/LS19uiOjijImoDQPArQLhhum+6mWHsSLIDVyrW9Kr32sxPbGlY/WuIGeEBqUMJSbqF/MOvBQdcYQX0icBVM/LwbykLlFsoni4Q8C82LBSEYUWomnyhBpwQM2Q6uzrkfI0V7HqFFxRHEU4MmmMsNAz6C2uToKDOOzqveI0VCISvH1W5Wp2b5gMB1H80qCoJ2VEqoRRAjQuDOLMPYMyGwMAwWCkCgtI8aUqh6EKUWceGRs1Zi/dX48/ctBL50tHPYG6BjEOUQNasfIT3p85Q1Hnd/VL+2phaHYugBMMUP2kvvsOAj8Bp15Z0lVu6Cg1/8nD6lD+xRuO/RX7/Qser694fb3jft9xj4k9A1N7qim7ws+nbv4jx4LdjVwu9/v0+xXs9ufq+TOroRi09K90sHp/Ow3AsNzOZ7fky/XrK2P5/uLrRO9v6ucOW9e/vvLTT3zlWvZzn75+TpGhd8PUQ8eI7vXee+3UuUyvN3cdkOua6/NecOMC22uhdpTqYmrY5e1+7Ykl8h7jneO1PtV/9L+8zFO9H93rd66j+o6p8jRWz89rEH7s+3lvZ6xx7BeamSFzzZJOzXH5ap7ndSVFR9OgpqlaHPNx9xHwLTAwEZhADdikQo8ENogWbiK0ECSRlYA42wr0fZqT5HKZe2IDvtBUXgAqy63PamGUnTO6uoEaH6qqc0xNUa0g9tRKcN0bICp6O9zLzvVwXeO6Z28cH1pJrpzO5p3+LcefkAzeQpgAY5XJ0I30ba4AbHsl3+3D6xrt9X3dv6bN2GVjz/COie/a+QH1xBc7vRGnmJgRrDN+f+DjNx9heaOXK1nNx91W2N3au832jMxJsIHpYAnMWfDHHXcb2OzGUrluSNzgW2GKizKyubwFjyKdCM2xY84A6xCrktAgyB9miAx1oCQXOApIBPNIppEBY8o10IKKai6xLUMnyfyHfKmrYlTH9+hUlnHTBmLRw20o5jdYl/WEGuAVtlU2t5UtIw00EF2VjzgfaWwAByV/dzqFI5GuBKQOW5Yjp6gE5ZhpgE9kqrmhch5SScBWBw2iNNaBLpXoKyUd31yRBl9Rk7DE6Tcz8ZkN2Eqeh8JZmpVjlW0wZ3sdWokkRjnObG8mbVImb6dR7aWRkWdcitOMpX5Rpb0k3uRw1MwFiEg5I/BtT1nrfDdjlbR0dc4WXSjYcC4GTXV65mWsWIfdQx5eV38S0rVgpvEyNTeUYXSuYCh2QThUYDK4MxI3SobvKPXmIH3Owxk5lBBONG1sQ5d3raKBdhiVwDA2KTwqMatYbxyMOoSR0jbamxMEaHQcDFiXCE4jZZK+mJXjVlCzSSj5z53NpkLebVNZYX1hU3nhkqxA0ACMwbXBnjIc7yjg1uTYovOiKhEyPjpRd1h3QTccVqRlKYrFqlSJ6PwXGI6v4a1fDwBAzJN21zyDJyebIk3sL8O5yUrkRmRgVarmUqDndBD6d1lOGMRqYw6H1HwHlhNc/4CaZpahU31Nl6dK5Gtsn2QCGI7q0i7qS1AAchZmiCr19ob72xve7q94fX3gvu+Y+0TMQCiacdG85z3X+1ekZpen8gow64oDL6ANp55/erVzOnrMrlfRoLTnfPFt3gHQRYPSx9bXT2DQ/SSud3Ze7HKPXQ7z6blkHjYkaWrEV4yFvodCMcrbH7Na7/0ElPdLuq/Ts3wCQkmt61XOcRBIXxO3bltNe3ulibnRH16AsI3iNT11rrULJkJjogvzYyUf2/n2ctz142afvymfl9M13urvXa9TOMHv9XVcaGy67sUnrdPY5Xwarr4ftD46QSX1mv5MjYGDOGDpG1uA0xqA97wV9TkdrUEHm9OAmDFwzMCYpC+OERhj4jgGht1gm7EDAlSuvKMOOWDmmEXHKoMDlElncns/mDCX1aKT5TIGeuSIP5DKuzA5YY05rH3CavAsbFcTLC+cSYMFiqwsICFGja7BSKjBMYRJkvmWBlaWdEMNO6mZfZqrtfgzxy83NKxDUVx4afW0lrgPW+jYkmUc1zNa0aLlSqzqbdgy6dzLdl4bS4fgukJNAmB5cYz317y8fX/gy9sXfDq+xfYy4W5K2hz6DAGQ20mTYYTAMR3o5lwZTHp5+B1jsPKAuwM+4A4Md2wXsFPtceYDIEQrmrdkdaBSXkE4bAAzJkKKLWzDkQzFHQBgijjo/hKd6GOwBqHN1fMBC5nrNUVV0gbvrt5Qcmkxk2FzrJK3fd5Zpe7fZ2E088Im3n8NzlNqt2ZHVOR6HQUtboVfRSHwJRVZPjVkkC6aQxUXZQ31DakFwDi8zGMpoyUfVRjFhHOzwuZU3OWFUbTaY+VJ8PpuNAzdSUcyxddzQqF8Lq8xbFUu6gjc1HpLbbbDGKVyUzgRpMJYcXObumibKmTlAo/a1BmAOabRc78NglokK23NBA2FcsBzlTIMO0vbwpo/znhRb6AVGVE1qmGO8BSXm4omNS83JTNDVDsKTBlfRreFSVNb5VmK1pg47tXZLEkPPcAKTkjm6ojWV2DjQBgNPPOOoPFamww8imiC9CGFN02BqlnYquihGr2XXJEmJpVTEIQoZBwTc0apqstlKjK4WWGmL6dGGWgIGTBRbCAo5wZlVCy8Ut0RR5QsAJig0YUqepqbJ55SlEYjN6gPMOTq7EZI1D/MHwE4t/M9Nvr1WMd0rOZzPOSBDbs0k5P+SChqyr29otuty4pGn3XiEk6Fmk1/kOwegJrUteqhJ6hpnl0AgxSeZ2pvWDs91i3TMC4DFHmO+8TxtmN/2/G4P/D29sDrcWB/BCJy0aW66/d5qgaWrVMXNNUzXgDPFeCet3LiZX3sPZZc67VBZ3/u8qWOSv4USJ8XeqoYpFMtLoM+p/SN00aw8zT9PHyhQdDzAy38el5GH6/LtWU2XYfyYg+s+70MNM93Un0ao6DPKZFwvY6w5RPVqE/eAPqMhvQNLKtNkXWC8Z6nSwX287t1xVF1Gbzn44Ratj66olPvMF7mOV8GPHuyS/dZz68tat0av8v4JHV6U8HsckeMzjBzr20xyAd37s0GLsKbxjFcOFG04EXFM9KZVmH7Pk1HoEN08RCNKia22DHnwHYMxBaIbeKIgRETYwZux0TaZCERc5SLAQHilnYmAZQfgZ6vWtPSa8GhiDZ7IWjqhZWTOZnukmV6IMIiPshJa+s5VaQ0sajK0uBAdMVP6h46Ulg2f41vr6ckFqgLzlvz6Ib6BVbEn0CdOndqWYPc0nuSItWLRN+ReU0v6Eq5IqjjMNELqx2zLGwNl+kz7DnwfpOcCStrH+l1LMOmEHHg7fULjv2O/PiCGhsaritVGoYNmc5OzJaodKQSNSwJIJk8nYgxcT8ObPcHttuAxYYtbnCfCHWBdlO7lgRBr5FDnE4KRnPNc/C8CMN0I5AzcuQ7zOcqt1agB86iMEY3O0uCmGCZteHKDYGzo7e85RDUraYbsWPEUpIzseg/nLciLxyhZNQeY11zpDqdc6M7xIHnb4y2FFCmrtFIFG4Y1l5/eqbZLEdzX47cRD7qviQpb7LRY8hApKInXmqwV2yCoA7RWQCyWHELBIxlpd4dkitlWJWVkt3H25wiCHQaMpnwZFNAuLFRDyhtWbHo7IQ+zYFSw0PrKMnpJUASDPEeSB+yHAqr0qOiPnY0SEZyhY5CmKMiscUZtTqpIX7pbVO4iXaUafCNwi1lOHe/jZTHlQykRgDdh6CVdfD9Eocz1LNCpWgj+RlzVnFKGRKuHA/SgYLUwQTYs6J7j+qKg5XMmjc7Auu+EoWZiryI3uSopWygvZEyQmhkKWo16wQcVqcmy+yq09x3afBhiK5oJrXWTfkiNnkIN0ROdqOXNAsU11wR0NJLra64yQiRVddWM1HeuKOoHQzT6AQYmoNUrk21N85KIlXV2n49vnp0eecuW1nAdYOgK4QtnA+BfqG+/nwr+7UJL0iTkciLhxx2OpMymcsUBpQvh1wJfNVy+a0b0o0kuua9SVc0zTgjsM/Avh8sZ3s8sB+sNLWMjGs5W6HXddcdqcYZ3bFGfgsqXhSnvtjffQKE1qDoWb+3t3+BfcnyK/enevz6l6e/60Tnl2uvK9T5/TV86+p2uZH+8wlAXNA/v/eezlTrWnIQrVNfzt0OTVxlZZ+nIzr9GLaMsz5H9XOuhzkfaJ1zvbW+LMxzfUCVyzi9rVg3JmtgjV9dIfvlOa6YqbfD+lBR51avpctlnm+DxtN1LKtHRuOxIlXPc3TGw2oNSYNlTtE5yry/Z7PuefU1cfmMtHPYe/zOa61oTBu+1tru+gz6TNJBlwlEHJjTMLYbKYpzIuZAbsFo4o0VqFj0p++RetZ6TuTI64qZrkVxzvQFsXY0ogEyQEDn8o6g85wva7AAdn28GnmaPJW0513xTeJT9S2DjBOxFspOI8P65PpXwju1llfv5aZo/fHjT6BOaSk1UHyapA5d1wrJcePVGrO6CKvr8uG9KjRkDRo4pLSEfVnEDUp6Ljg4+rkEQwsAXiszcb/fcX+749tP32Lb6Gl1FLbmnSlkdgqmWtQtqyA1CYUjCx6J3B/YDXjcwLKkihTkjQnfVURDgSFPeEh+CnYoNDqKUZBUWCuMfL+BNhiw+HhtJQ99No2J1ilP7MjEBBA44OWLgpIy0ty0WHqvlZ3jKuOm7JKy7zRGyCMPJS2yqzkmSAexxNbKtpXZ5ASlG25g2M5MpRrNFmVo5TMYsMKcqSRyCSFGmNgNPByLqz+sdH02XaukgvYyzFDiZgP9BGwEx12gtESbaq+1ic4WKxyscrZGj3Z7uhIDLxWoTEz14dgQOMBNuiVYRhl8BoY5o1UEDIr0CLhE0WBk2V+g2F4aaUNUGpwK0AwrjCQQ0UrF1IQQJXkkDwY9qYlMQzJUQI+GqRFcOIYSq9NkwBXHEcUIB1lc7T1jkc9QKIvdStlgsopRox2Ap6KAWUjzi8HSlCvug1HKR0hTY7puzKU9IqPJg+siTEow8VQ2mvPTK4r7Y1y8rDNTY0ZD+0CdYxHamxAtEEU+aoPDC92morrt/crRcQNyUGBngIpGai+lkc9aZox+TYEDVlxj8WJU4qY1OwqiMZquEUom//X42tE6qVrZtw70WmCqPYjZYNw65+IEgOaAZzFKpjXS4IVV3+QxlYxcrBcrUuTUefxKewADsFj464Ka6S3sSFnfD2V1ZmA/Ju5zx/3Ycd937Af7ZpwJ4CVZ1uCsk12fQUx7txegWwOkccmL/lx7Cgvo9vla1y/azJoA/sHrLATJuajrX1/7eUEDjfhOZH9ew9YHTvC+bupyPIGe5/tcd1bPfzdAbpDa79b5gfNS12u+u/aZxH5C4tINLzy03raf3vr15s4Bf3fGfuvC+X8CY7ja2E9j2894xaPPz1FPY9RtNq7AsnMMrye/Dvn74f85DNo2nl0muFfC0zBoubWRzPXcb9YlWnKOTaKX6Qmg+yO9X4ks+jpXl/nJgrAwzJwYQYrizMQWgZjJClQVmBUYGSzyUqTQeu+rJ4NA1QO1R9Owmjra2jeQvtADZN90rTWzsFs/58K6l7ns+SqdX4vBjM5kdkoHRMuQjAMDRMA7H4tWm4rywJu5ACyG0r/XzuAAVizqvA/diiauJ1LjsgyOiwFyvfmrRCQ3GkquZgnOTrJEnbWCWVe+zo1TbcueS6UFnGks9/3A6+sdv/nuwMtHkuUDg0mqaQLvqZ4OnNiZzIkYVYhBgGResAzMadgdsLtjjBu2we7jruoZ23A2ceku2WXYARkkUirqDr1bYrjBw+WssDWWMGAMoGZTQIpg2bpqjWErwyFPba7KKwRWnmyaVqkGfFnk2Cmx2mUEAPIqNBBf4WBS5FyGg2GKsqTFM2o13ruBcZKownCOQ0YpOd0BOzTng9WHpgCa5pDdx6Wo26vuBLsUnIkXkPqDNQ7G7uhgUroZ6USdkMWuvImZ2vbiHWadz9HUo/aAlDVw5XndjKXuitQ5M6gChMC0ERRvBX6nzmhamaOSuS+b5iNoRjIanrk4kiGkVDKsG5zDB5OUa9AQ0liwShNbCnbycJqMKd0fnfbOzqWiZRyuEC0SWxFsTxPVIyH6FyuD0WgCy/86v+VrjZju11itCk4grv4tHDt6dtrYpRiToErHRAKD4JwrgMLDLol7q9KPXDw2TgPD17MzPsk55rOkAF9UUji2Nm4D1AarhPgZUemSo+kyDUIOCMa0VKGO1LE2wg3VVZhh5cynQSLMZGRTNtLU5TzVUkS5ijq0s4YeTtFq1ONntlH36/HVo4KLoctr0gaXbEn68xZFAKIItnPr4qFyA9ydleki+2UehlX0otsd0/FFAFSh1dB6TIqdWZPPc2eKaGW51nHJk0gHQlUg8sBjf+CxP3B/PPB4PHA8dhxxsDmfuNcrIlPAewrVZYR4j/CrnfCEZU9+wvWZL0CJiA1fX4UnrGqwXJDDQrr46Yt5Oc+FsrPA/brHrzzM9SbtGQRfcQAur5y3qfs8B0xyekE4fkzy4DKR787eKFkvvEPG3Yi4sdDixV+fwbAcSF3u+OncV3hkLRc0bh2pukQ8+FtbuHKiPC3hHiPhtC5h29RgjUM/ji8L4fxe6WYuq+L5ecwu26nB3jOg5wNdowkNEs/x7DXU3+ucCsjp+pPrXq+nl1PPuUqKr2hJST6IByb8mJascKnXuiW2B5sh3/LsVdOlpCMScSTCAxEDQ/kMrD7YikXP5XJUFK9fbssA6vzg0p17090hg0CZlbb6fnTkqceNOGF54oHTSGmqlTW25HsF3gPlY8LAyqDo3FPrMS10yd1qitlVDlTB/70aGpeF4qJTLOvnstnFftMmU3RjeUTXnm3HLL9jwG0zvNwcL7fBZnhGiouhEFmYwVbxeySrtmSKAnJer3d2bwgUvT0zDry9veGYE0cEtjEE+H3pgeu+40bkTmcSqYTRBJMBrRBH4s0fcH+DbzeUO17CALwAAncV5H+HgNLIwihWFjLx5q2MyaVOIJwF3MBeBkxUtNOzLBCaYBjrFlwkm6kpHGisdBO35V3SogwvNb6TGHQm6y6uXjDaYwDGBnp9zRVBkGdWYBit1FEY8qKHIhUzlCgL5ih047MBUWXcMMF+JQSKgUOlgPUU5IMOwxBIDFHB3FjxKqBkevel4KbRMz+KPMyUMdFhzRrk2zvUhVyywI1riVEOo8HmogOlKBkblKPBc76AG7cKOCRL4EAmaWwcLXnHlYA8y5R3wtZ0pGJMVA71IvHVLM4OQw3Sg0og1moiirv6hLkyDAS1vUhLI3VrrCTmDOWMNIUvgKMNrWKO0uoCm8F7FrUjDKtqWBuwpf3p4jIVsKJXVWM1NiT9jAskrOREMEwPZBrGQeODQ12rYS3XqCpHbQVM5tO0I2EWUDkZ6YAtHjftz2BOVHNO26CAjB15ceA0vC0YUekcm5zOO9JaT/W2AGxVJ1OQRFE3lbdFyAilgppgGevOm4lSSWDJqYFSHhgjcgEgEDLgBYSRKkX9iyX137ljBNdjOvcUs6ICVgnLsTx4ZQ3Ox2lopKiIxX02AVRQCsGCcxULdwCm6KsLyEiRjWJN+xV4akXN5U1FP8577gapWnH6inr82MT98cDr44HXO4uZ3B8P7POBeOyiarCK4PVSDZWvHv/WsycwOKkqVcBFRawPnZBb59H/L6yc9VbhzIOh7rUV7exvEh400CNAXk41LvG+6Wuw5fl4ihYsdP/uLtfVLp+8fk/bqE9h+fTpM4emLj9NTo/n7zfY+ynolZHROOR6c+sqtsBe2ytAj63GQRPybriX8XFe8HKCBvJ1PsITn97OnJpFAeyvG1YEoMMIy269DHdPV1eE7O+fj2hPjua1HqtvzxZQXadtZmPjwcvjLDAtR0tdnncZzHrIcjns+ly2RrMLwp2ORGuiXYPooszIUslrAEG2Ru6B2II9azYyW0YVI4sRQAQ8krmxXqibdHvrzEGsZZfI5gCp1q39zqIr/CwkX3pOy0in7qioiAjsnwajTEOJiaIFIMMnATmqSg5OrYXB5+/806xUzcVzva9+LEdQOG58pkLrJ8gb+MePX56jcVlNHWBrelNb3G2ddljaqm+4Lueo01EARhO+/TjwH/+9T/gn/+A7/MV/+C2+//4FLy8DRxbimHh9m/jy+wf+3R8e+N2PD/zw+cCP94nHHtijFpAtrTC77B5esrDfH7i/3vHNN98gxw3bICiuIlXBluQ1lBLDmTijcqd0R5ICFNQcL3Eg9wfu9wc2Vfmpj4xmuDlmOTyTPQoMSkQtQF7w3gQoct/JbeelpmvdgMCwLdglUItGs3fY2xi2o8c30E2+EoYcRNQmSkyFIW4qdZYpTzgjOqwqYPB0gn30eu0QP9ebW2CUVHqkKG3OjVYGCxpYt8nNf0tDdKWV5BpJVYkCZLNXp/HmmS/QRgIAywDqxpVmBc/AlhyrssHcGgTcEkcmXJ2yIW8jATGrSvAceaHuFCZKhQJUhliN/GaphG+pu7WUJAGKclS03qbW/TAgMwAbqjDUIKQ9+gn3DQhGaXrjVgUqWGZ4S+6vMGArdgc3Se9K0e9OZEERkbyHgY7ocFzLxc0E4BOwZOSpACbL41r6jnkEA1D54VyVNCCQBcgAM0MZvT1juDxhyXWWfuYWKAm+ATWqmNdjJaFJOtcGjn+XCE4HxsFI4AR7WnhHwjyF5WQkAszvmTJSpCxF2Fu1ywMs/4sCjoORm5E02g4Z/y7FVZAjAkU5ULlyW7JUnhdQkqGdryk5viZWLlTIcFEU25EAAQAASURBVPKkkd5Gx+p7IK8Xe+IkQpRMlGH+Sp362cOkWOnMc8pX8HcG0lLr1lgyWk4SpMND3+9I6HWYvTML7amk7QIDBSBN5rzWhEtmVXv1uQc7mkWvrHSoATFMhjhPnpGYjx2Pxxte7/r3uOPtceCxs5lYTOX28XQnUJXMf49v3xsNPwHr9u4tbeEndAmc1Kvr2Rp5LlCncakSEDm/1O83+cLW/T+v7Z8YGV89nuHtHzua7r5wvJDvT57l8ktBeKVB+U+u+jPj9/zO5eVaOtSEla4xjJ7L53X2lft7/yzvB+tiwHSE4v3zt7P3ea45T36ehi9Lxy22iq7XjpZ1+R63vr7VWvvo7/nTQlg3372Q+hU737pQ/hr8vJ81XsTa2dVr72nx19M3+t57fiupZyypW5B0ZnakKYqJ4UcGRk54HRiH48MYZJsMnL23BvOrmkIF1DkBPcyG5ZTqnrrberLBMc/T6lpGoxybJvGDS/BhbbuO3tblxY40WVPwtaKlp1yYRrX2UGDRG5vSe0NKbsPZK6fz3n7hbv0TIxr61doSkpQrWyDm6lmx6yT3QjKFlozr7tMHx//wH36P/93/4h/jf/2//B/gH/6zv4/bn38PGx9RtQE5kY83HH/9Gf/qv/8d/qt/+e/wX/43f4N/8d/8Hv/t/+cH/Nvf3fHlMVfuRod4eyP1LRxzx+v9Fb+Z3wP5AVWshjOwqejA1UChh5ugiICSOQ4DmSkaEjCPGx4WGI9X7MPw4ht8c2QOlWg96FVPevanuN3M7ZHBJXpP8w7NgJkCsSg0F38l6ZiapqSxkdhNia3F6ks1bBl4qaYUFuqB0J4EB2YUNie1w0P3Ig9bl3N1efgOlcM1AXXOq2MPVnYqGKYVYXY53FRmVkm4wylMPBmdYRJ+9xKgRT7EMy4nmB8JCoAxuJEnaQq5hRQzAGPTusRAWTBi5ATGmczfsGJUId0kBG1FdkYGy7MWm/SYE/SuiIq6qNdIjBrqv0H6YCpiZpZYDXdMCdah0sPG0KSr3wU7vXPfuAOIgtmGskOVL0h1YlAjEIM5GewVodB2bosrDiuEBayYTpwBDGfuEQTWu/9CG/YuT9v0lkW2HABVYL5L0VgBBqwmIwHFksTu8n7k6YFJS2y+anlwrySfZYEqxfKzDfss7PIUDgM8Sj0qOvmfZWIJ3g1mrtBurcZ2WnHMe2lgl02d438j+xw0PlCA5YZgsS8+pYygbOMMRaNZVsRqJKjCEJYmbaV8oaSH7LANrBZ20nJMvVAyeb3lpYLomRJQVQVL7pHl2Uz6u6eiX78eXz+mMfQ/apxl0SVZoo2C1o+rxmkrcj/1MgguFlApMNpcAG6GlTzX4EEoLmlFIjcw0gHJ9Sx+p0F4z7WAHameQCf8VCZmJY46sD9esd9f8Xh7xeP1jsfjwDEDEfQ8lmgZ7Yg5we5J3cT1PZwyg+Nw/rwCyIVq+u93QO0a0rgwd7Dc2AI0tgZQ35HRcYJ0yc8r2L4YJetJGik38xFtIlxR7Hmprjx0Bfvvx4FK8XzvJ7jeLuMAoKnI5zo5dXXjuWVAilLK856WAHdyyXDR3cljXnbSaK4miK1n5RguD/Ll3p+B3mlS5PmB5cFewy7HTkfYmu4HM1YalP4gnSr1LGuGznHR2lnUJi0B5ka15Hd0eMEa4Pb6NDYGPq0Y/dBXzsDSGR36CbRt5G2GqnPdlS84jacNfpnaVUnwNH3XusmiA84nMyxjC8Q8WIFqHwgMxMuOwAccKYdvFrZMbIQIOONldnJ81/MYSjq1x6XdGs11aopfau+Y9NM5WHbux+WFNtHi9FxScqZ7uLJFzUnz7QaD3ROjTA0jGzw4Lo7xNSkiK7N9wd92/GJDY1m6LbP1v7VGqie2FpjthbM2v8k46Uc34NOHgX/+T77D//Z/9U/xn/5v/lPcPv1TGP5DAH8O4Le68oH6Z1/wH9W/xf/0/q/x+lf/Cv/qv/5/4z/7z/5b/J/+8/8e/8X/6/f44fOOaBf82pxY0ZWIicfbHcf+QH76SMBmtBisWOo2jCDK16bnEIbWiUfAB8VAzAnA4ccDMQr75rhvN3waA3iRv7JKwMnXfihn6VhfNBN6SROKDBmjISFjxDthKFUrqqAKT2ADugC7QoO19j1V7lXRDo7FhCeUPE3KxihwvJQT46a+HQVy0EtGjYl6gESG8hqQKAxW5pLAd4FuTi97K3gVaqSSZCVvnIKpAgif2GDIZN7CahQCGhXmwECwvHwpYbmb9xV4fxtfqywcUDUuNOvfmMhuPI+Co0hVkypTrSl1QLXkeVNkhi4t5wYcApUJGp0bCrun+JWXxF8ZhQpcwWyiMJiQDCcAV6Rik8kF22A2oZ7BpAApeYBDpu9Zkl4n4F7qaN2Z55t+L2fVo0LhUJ8NpARWG0VowCWjrk4q+SYdbhlSfM5nUs4R51L3XoWhRncxpOg4iKRsqUqWaswyWsGSZB3kWA6KNK5Zpd8I09XK1SEgUqnoJVe17ltxq6lemcsgDeWgsJACu2zTqGTeRAHhmCbTxJWTA0VK4SwsYPzddU+eVNSkwOSah7JB2mcKRJTB0hmpypOa6OA+pmGvOJ4xN427SvkeWoO/IDr9d/Y4DHhxGqxmGvf0lf8EPNMQFm2EwkwA6QKBVyRMRp+Ap2mh1gUcmAzeHIww99GOmqp2p+jkTadS6etRJwBNByIK83Fg3h847g8cbw/s+45jTla+qVyR5j7q8lezC57c2HX5HQ00DGcPm/P2rkBu+esaRC6Adrn4e0MEGks56jqoUT/92LrQ0ynWvcrvr81y2jcN1gSyBCz7vvsfO5Jc7lkR6Q4Brfup8/fOebhC6lrnKNQ7QA078XvjvEUT0omvUYsy7n+0vFrf1afKniiSa7iqTg/2eu8Skbny2exyL3i+T+hafe6OSC+0s9bBOSh934vapi93zuo61zltnH+Bf1yA7TqfXlgVCK/r7zo3ea7B3q5Dn+/pXGMLGUZPg6cx6g1ji7iGppFRv9caJxrvJz09ImAeiMMRWyJuqQaZLEGdkzkaRwRQG+BkE3TRieu8LJDVzr3LSjOspYmVkAwOrA8+gle7gts8wul0vB6aH88CRrINQ2kPpGh9rdNkxMVlvfekNJmQVFFRkNPXGHWFyqcGkz9z/PKIhnj4PSgrGqQBMzR9qRop8W1rZcwHvXpOsgxHFH7/NvGXf7jjP3l7w29eAmPcAHwP2F8A+A7ADWYHXvA3ePnmL/HdP/3H+A/+8T/AP/pP/hwv3w38zY8H7o+J/aCHW6c/NzQAZOLxUPWpb7/FuCVunuIfUciklAayO0Nelm/YGS5HMgRfhT0DPgN53+HjjnEb+OAOd0fcVFUHhZtcmiGQclYnIdj3RakpUeFOUOd5bmjy+bitE0aqyFURFFjFSj0EAIUmAUAJznNQSBs2WDCU3QYZw4jdDI1c56MKBpXQlQWcVahK1qRXyVMYy75GBbYqTKNRkQA2Ex85Gf0qPw269FJSEhb/Dyrviih1ZO7Fp5o+latRWxMl6kqChilixWoQs5mHYdgsBUhbKrM8ZTcNnqBgz0UB7HMFNtG5qmgXtaJOT3mgz0ZsW+cyWHdtd9yCYvnQXGwebN6oGSbgZ4lg9lwg5QYq7zvAhPcKlVAWYIgCtgF4AEcCZYmbNL1p3bCqF2BKQrWhKBF3GHNVoMhCFm5KDAvl6dhUY8BiZCcRQA3mGCAgNtICdRMTI7jMI02NLKGO57yvIa55iI6VODvNN3Wu81va6J6uvh2KPvk1GVg0twIdB2nOymjpiAkAgSrmNbVRc3R0qhLAkEGrCIlxHioNaRMX9Q1obcNdUZ9CxaRhs74n2oHLsMsEVIg3ALygMOUNriRNj08sJSwj/3gix/96PB3SMY3clqe9TuihwPBCJ0vPa64obrmxSQfW5qbm57/UHDb1aoG3Pu1poCzkUHUBTLa+317eDo0QhNLQOI7Avu943Hfsjx3H8ZwEvtDxE4jj9fux6skD3yCiTs51SXZcEP4VYF8QMwBbY9pGxAler2bO+fU2yBa/ps63mv65rrrmBieYXw+C57/Xc/Z8X0Di05cut4/+aMdCtFd7DNdnzj86KnJ++XptnF98uu55FE5AjV4PjYOwCHkaP3u611OGPt/T9bF6KZvOt4B0XT94nSe9buf7Z/CqnsehP1FcRxCu66+eaKQun7+M2AL178fm3VpBRw5r3e55+71O6/oAuEaJei9znbW8vD6AnXsQXFsGX1jn/Px1vVCANI07C8icyHBkBGoWGQtBeZ2RyJiIuJGVUaZnPzlw6xIr+gCCdt1s91lZjJx3z7mGQ+Nquq9rhTfS23oH9+tqWVCJswStMIHkEnB1plykQOvgy3tWfhnzZVquaNwfO365oZHPv/aC7rDZcp73grtM5tM+qXMQqwpv98R/8S9/xP/+//Av8Fe/2/E//5/9Ff7eP/8nePntP8SH8R9h8/8Ahu/A9NsdwCuAwvBv8eHvf4/v/t5HfPjk2IbhOGyF3GwZCediPOaB1/uO3+6J20vgmI6XYTBFBBy+okWLuy8jhFw+IyAF1JuA3t+YicN2PO5vGNtAjQ0vw3DLG8yGVhU7/yJslZJl9ScoApGMMthYkxwFVBbLxGp43X0ZI+WkhrAuMj1uA4VQ6daCMfQZJtDkp1e6BGYT8Js8FBAHMNtLV6gMUb244tpDPcBqRTMMWxG4A6BFX2fYDzJQppwKA4WyiSZO0cE3YWDlrUVzKJ7MLJk0m8YIjsquMuh4GlNNyGrKmytbaq/2EtNtv2hFDQCbXpX8lI3zFsyabsXnTW/ACRzV3aeLgmLSQ5lqMkQhTWPUBPALLSAmk8RFFGXnb0ZaCgYr5hcMMI8lEXjR8xxGw2eYKDV67k3GTLihrZ9O4J6i3XVPi7IC2rMvT/3DNhj4mhfL3h7aq4EizatK52MkLrPrc6fug68XDJWJ4ayqFWfga1GYqEw7LJxSZswDKSQONf0j2+kUxEN7Z8hY7QZW3WunhN2sCiPJn+Warst5aJ4OlDyMSSNDtDY6VAyBwAxXAiifvVKGHRyDrh5k7kDRKBmt86spjYwubYpECVaqoSXHgzw6GvMMcNaSpxtYDCOeEeWvx+Vow54RaTqXurfLhVEA4DQ2mkqIlsUCooUGAfrwNWTfL/t5wpJTzfojAgCFWjQsoOjhFMCm59JW9LbXOPN7Esec2A92AN/njmMeiDmZ8yXv7JVe079c1f0CohcMu8RqXb7zflldlLV95Zx/9NA5e/1fWR3eY/8zl+vPnRd7d2MLVC+8dXqA1wQ/e5H7vWXTKVJ1hbvn4zZge77eeaIFb3BB25f1pbyuxkJrEH76oFU/vb5O8fwC3k/OeUONbrrK4Tmxz8/fy/hpsfSYNJjsT17ut863n0+9oj7CEctIalCqQVig9TRSzxKuHNAm1vK9fmTDdYa+8ljrW0+jWHi3Pu26OLgfq+Usr1P1tXOUFpaMjYKqeQZ7SUWwsEqwIEiG3qtgtCIKGGJKGOfmXKfnQlptkaSv+gHOCE6Pg0k+vNtT0nn8JN84e3eJom8cY/pP6jK21GWOUyb1ui09/iI8yPHbz9B435f4svcD/9XjT2jY1z85eI6FZ9ZGb5pJf7Yrba01ehFCXfL2mIm//ps7/vP/27/Bv/iXP+L/+H/+7/DP/sf/Nf5H//zP8T/5R3+G//gf/Aa3334Pf/kEVguZqOOO19/9iP/Hf/Xf4f/yf/03+Ou/fsN+xIqQnVvnGmAsRATu9wf2eeBDfpCTqmeazb9YTcEXxYs+zIEhIGUJVarhjAQ5LfAJ7Hng9njAbze8DEP4oMc2p9KzSZ/ZHAzvK/wSMp1D/PcVkhIkmxC4N4bPmJyqxWqGuaIPTWcVhUk8N5MHOfTaAFZCbbk6ORe/Rz+56vOEeI+Dm3Bm4IOUZLVnG4XwZE+SKlQAie66LmXHDNgV6tt0fysx05h47NDG7nWmZno7GF3YVBmi7MYuz6LjTAmmocpNMBliq1kWV+wg2R5NH1sVgIDFs88oVA28oFAj18YFCohWvpz7UQOrspuxk7tJsvsAy/uqv0OZAxVI9c0wc1bfSlPxgBZGQS6lbxQOTordLOh1JrNTWXDdlihcXY3LDcqhYO7MppKvE7F4vm6JQCwPYikiYV7Yq/gsILXiRQlQpptk51RKp3I2Deu8isrCZuzQPSUbhihCpbwIk+DrXA4zxoabTQoDNjdljSuvQ3MVaoqI5qoDqroGoFyGFPdXLu8te5KkkvWGgXx4tLBmJGckDd1sYe8DHhyL0vPCaLQOsGx0l0EuK1gGbDhqDilhVQIZJc4vcID7r4q9b7LOfiGGft6uStKgqimBvx5fO3wmo0pjQRt0c9sSfSk7imAn8Omwd8rAOL15ixgldW9YzQqyngDzeyDUZ6rq6IZLWXO9AqWoW56KX78GAodNPPYd98cd933H4zFxHIkZLZtqwTBb6OqidC9IkfJXADJbd+NEOU8A7uoYLCwFj8slliJvHXCCF5xIdp1jxUtO1/vTUc9X1E23jEb7H3i9HvS+duoDF2Ry/e28mxN08F7q/OyzC/1iIfTPpshdaUrnGHRUqF+zRcPr57d366Oe/q7r3An4rxyDp+vZ+fsyEEQDsstYX6agZ9P0jGfsqteAxqSt0ctr1+ME4/29jiA974/Sg/c9QZjkedJ7PC57SB+xHsv1HL2BDc/3fGXT8ObOdWnr82u92YnvVunWPtfaKjSSfA2F5iBV3MMZxahMVE1UHUjckBloGhJQMFP9QwptGYG6/+sDAHLwnWN95pNgVcU91xZ/pqjuPY7cVjKeLkafaywcwl5P8/g8d0v+AOju31DOblPNKo1OtbVGbeEofvcShfiZ40/qo9FDU5A12qE5ocpeiIQoXD3t2bZLyEevoA2WfQZ+/2Pgy9uBf/1vP+P//v/8S/z2+xf8+W8/4s/+7AO++c0N335zU83Vwrwf+N3vD/zlX37G//ff/Ii/+Xd3HKJNtdg77/m8WmTg8XjD4/GGb/IbeVi7LOgGwlhSSEzp/AYllA4wOlDyUhuACmAacFM5zePAYW+4PQb2beA2NgJiU18CWZ1WhrqdPE2Y/MErybkUcT8TX9lXgWVKu0KCKdHKkBjDUFOiVwKvN06aISNFs1IsQXSbRCqXg5GU4cZGa00KJQ4DYNg89WeR6ydQRjqRyoOW6DVJr/OEckAAgcXA1PbIJJ+xazgHSg0Izw0fDMjAkDjYAhgDKeudn63ZQo6Ac5QKvmZnPbD61OxEada0RYahO2rOojLzQUkWYI5Jak1sPRcCx25q0GMUADZ8cfBd1JtsYeOnYhsWAsBF0KKKV9wuA37Lk65j9HICjKJME6hORdOMawXBOWZt7pZShUN9HyLPXJ/27hvDAgiV8vRRFBiTQjAGjZHu/j7LMFJlX5EYaUiSzEQdoUAqZ0KrJ5O+YVgFKkhJMUXquPagqE/355iWSsin8RTyvGSX3kXBgldW0FLRKZc6kfFSlC1MK2LfEPL8pKSvWpmbjs+v/CRST4bAGjQPKoXKlYlU5kRCVePgYkJy/tKp3NopYcV167K22Nuy0P07mJcBQI0LocTwBRB/Pb56tIeudaEVupGuQHavY32+vSCNFltPdrlHY17U4lKbUEgVapwgvJX3FdhuitBR8Z/Gobdhve6ZFftg1qXjUHtgfjlwfzxwf7zh/vrA4zgwZ6AmQc1Vpz+D2HevLwxfF0DdOKwEPp/XP38syP8E7vojDb/75xUUWxse69r9fUUd+2Qae1tGiu5LZG+7AladZxW5ySdo++7x3w1GP4B0mOEC7qoB+uUe1+PWGtzWsesK7yOLfW4lzDauPfsM4R0oOQG5Tnjipsvn7DIXPfCXv3B+vS5A+3ldX+f3NHw66nPKz1rvX0fU+lYv1zqn1oHTSJFcX1fK0zx7imLllap3Dt/z2C4gCRUtR+cTroCLXelyFwP5ItML1qmCMDjO3mv9PuRorhWVBIp5J9YyolQ+ks7MIwM+D2yHI9UtfEaSIl3UHZYThhuQifJBp2uPb53rjetZMsvPe+pO4sC5D/q9VEEYA2HLVnZJ6Ceea+PAhF1SWHI93zhZP0+luKHntaITHAaW1Oc4tjwt9YorOfWQgS6z/ceOP8nQMGAt0yVi6rKY6yJ0cAZ/1mLQQnU9FIE9lW0kMA+Wq/3yuuOvf3fHbfyIMRy3YdiGreS+jMJjTxwzsc/AnIXjQs9YwquMlqMt7IV9Hni77/huTtgx4S9DNBwuh/aRuHa2eXPG9a4VoCo/lskwWbEJnE1gL8NtvGFsNwzfYHBs46bOimBVJXE1SyH4zQq3YmWcQ5qkuzEnismqgKghpGJ088CCryaDLu9ZNki1Bkql3g7FSlWqjELaiKsjLpCmmIZk60oST9DLVwS8aczhcCI6Rh5aYLkWp6gmNxk2pWfCcOYFCLwVghSeSszelIPVrLYqUaEKvgE9iFYTOaEeCYXN+5lpUOQ02DAaIE5PosNltCleY4yI8F4492Fn2BFmOKowlKjLetgDUbm8L+wzQeOtFE7LYqNClkMVpa0KqMlqRV5weboje29Qepglm/NZIRQDM1RX58QGhwuEd1O3DhFUsUcLS3SmhKurQ3bAZqHckO5q/OiMrhiFVOfddPfQLkiQcaqhQJ7V7YaeN5tSxPgbjTNKppQSymSfCeaO0xgNMK7UVZeGJ7KGaImMHg5L5GBJ297EbqdibYEq+QquNIZNmuIWRaHQ5aoZQjcJ7Em5kIVhg4Z8e9CK+zszpNx4fe1Ode5W/TQjPa45ChHscu4MTrHPSkFPbGzP4F3AF+r90mDiVPZ1AYO/xGv0d/YwyEjAhfbUYHQpBR4LlQlmNu1YXn46v+zs+QPJaQHIRmciSC6KWxXplWdX+QaUPHovN3xa86x7xzxQueOIO+6PB97edrzOHfs+MWd3Ab88xrvnr/WiPYOxd7h4bZb3byx+S3/mMrbvDmmgHsHL92wl16MdHtfvLwrE5cQNpopa90QMevNyq1c83V/vwEYHrK5P1U7x8wUswL6mss98OWePpV2+c33M52Gp9Rk6FCiTvGo5Vc+JqHUOexrkd8fTW+c4/WTSgYss1KsdVce5xs45qnO8dQpbn+R/y1bpm7iuAzun1C6nXPf2NFd2MQauz3QxSPTbhTn0bhiaXnx5r89vwBO+1R6tPOey6nrG63W7CuG5Rvp8BtBpe1kMdPAWjmCFzltQxmcmjph4icmcyQxYBjwGsi0AE9aRycG+Vrqe23lnhoWl62nMi/Inz3XruHYg5wcztxWJX+KqCgeRihpi29M4LvbWUqBGObj2JIvqeH+46BwOFJ+1jbFfcPxp5W3ttHm9F07LCAk52CkIKHsuD2fcYFV2DpAm3AsIgZIA4DPw0LMPDVJqlYe8GilNEGWqCFRr0VC/NCjpqxVqTjz2O+Zx4PbyEeT8DzV544O6gVQfea0NBGZdwhcoKSgXEOS2skwcNvF2PwB7Y1URJ6jZxoD5ANScS8gSmWwQF4AALz32GxxH2SoxC93HSjEyU+dmeU9LlCm1ivf23pnRo6cqOFYbPJOeeTOgBsNfVUiXp1iA3VGrk/m09t/SSzcNTOBO5g0AUHDARIshNQVQDoIDs1zKGAs8d7edqTqQ5oAHoxtLeXNxyEuQrC5lJi8yMDPVVLCrxNYJCifn0qUeu5Qtgp5105xm+6fLVKWJ/MUQlaWKHgUkGBHwxETKkGBehafBPdEpw51dPsIAc4SJ2198ptY/hQJmYjqYKJ/qrdFSXJGw4WBSuwy5gKkcKqMnpmuVcY11GdnD6JiRzcE53ICktQdYKvJGMBQF1GS+R/cWUMVvlKJuKYOBQluNFJGkd5lxNCsa9shgFsRyzXMyCsKCAfbEkw/LlW+BMkR21IuEpCU3zFclHkbOi/NrpANuWaihfYBChUrUrmirvlehyJsjLxUlEjRgB3qdAErgwiqfnJfy1ABzPZRr0RHdSmf5aQdmtdJhnlODNjgjJtUNctRgEkkZ8+vx9aMMLERgl3+gE0Pwac0/0CCvSz9qXQgYV5n6FlVvPZzRh+QG8k3eWaDdhW7y0HfPnl6HTwaiX+6ZGTsFyIA4kLnjeDzweOw49h2xT6RAzAJQuALzCzK+griFnvq1+goK73P0CRr+Gq6vrlGrPu8aMWEje9Kxz7+d5+2TNpmk562BebslO0pyPt8Ten33+3k9e/fa18Zhvb0iQyfPva5fr3fPrVOdfVbqabz726loeZfXPtfb1et+Hds1KLqX673jadyePr/wTGOc61i9exCkcErrZqzI0ZX2dR6XdXV9VNTVp7yerqzXVp0DZna5m36ABrJPN/h0zvfP3lR13vzVrBXOgxzEX7EwzwCL7qTDnb0eDM/jXlDfpLOXma151OtZyIn/H3t/tiRLkmSJgYdF1NxvLLlUdaGxEQhEQ3iY//+PeQLNA4YADEDo6e6qroy7uruZqQrzPJzDLKLmNzIzhuatQjNvuLuZLqKysBxmPsyMcTDb1HEcGMdQNrgDA0O1ktjSHqm+QfKEYxHZrJDPM4ChWMKVbWYI1e8K0PMvtocAfmQqdVHQeZ3LAMqx31IZMAOsz7cpkN7mMwO1/iwp56Yiw07cEWLQoOnN2kPf/8rx9ysadv41aRDpnuJ4G8pdGLkQNN7r1TmR9P6ISPozANFAUjM3pXWtIcfJfVkLd5UU6+LMSah2jBi4XW+473c8x6AFSlSZSz2pa4IwNS1fJkjDSGqMrPKkUslaNVxegh12v2J767C+4SKF5PLEaI/oGylKSOoNrfNN/N/mMwXSCKUIZVYxLoDDgUZPzGZzAjgCkUHN4ehwZsBBFKe+9SUDgQByROCIroVr2AT4miUw7LBsIxib4QLoWXUZxpSvAwM95Y4HmjQeKjOkmFkIKJrLMkggNwKIEXgCLbzemHbUAsoARvqAKa7B4YzT6MA4eL9em7eEkOo7hA3VXGB/mbEdDRnIbshJx6rTjt5I/zmClDk/hlySEDh0AntgcsSD9CwGfTdYiFJjnDf00DClclbldvWDxajsRO3IBL2iPQUz0rjqrxy5SQRzBzeTh8U66Xk95MULWWoMGSzdwKqmzTm21DUC1qY1dsi3qmRahCDdFJTctTqoaHYNMJcdLfXdHRAdboD9EAgc8sA0d9GMqNSNbqysytvXxuCe9DFtLgYEHBsCh22TTtc4L4ezr5lekDEpbXR6icJgGFrTqA0q4Bji4DN/VJKwOL8yt3xr9Lw2KVaaaKSRNVDxCmcfSNtkXBVg4ueHm7jc6eXNa2RECMW0eIO3A0fIu/qbfM//to4KOehSuBGSMTYL6OVmAv5oMembBUQEplzgpWzrwTFsoiVAwBW8Qt/xI1/owgkzARRNPHEOLBM96Kzh8P3Acb/hfr3juN4ZAD4EGrR+ptqybJjr3pdPjPmwFXemvhW2nKv2xfJqp6005uPsdFGdMQHj8gzqQ/NBCYzt1BEL7lsvfATNMe/x2AWFsRbAhIfzKEIEjvI9lr5JI0feppQn3c/1WZ2fLpFYnpF9EUm1zCbF+WFrA2suCZAmSF9xjX6J5T1NykW1de2Y9TkBJlFJNaXOs/o6C7sW8Nb3jzrAarxO5kc+az03V0bdI9t30qR0bg15SCZqcj54Ide5OZ8po1W+SMzLFtUOpZDAyNaIub5PLUo6ZCoISz+GkxnhPuDHYAa4GBg+MA4V0VQdnJFZDfV0T3ngoNFLremSN2byvluuj1xr6YXQfrSsF0AsQjEKFk1hwVTAFsSk0wBz7sdiJQVKqSsvuqhUvtwekm/Vhii99a8ev0nRmAsxhcDU21NIcK6uAnCx8KwLInJRJry1UmCI6+zk+ix94dTbNhd4rAILdU4Fw2kAIwL7vmO/34FxYERXlWR1YgoQKRUYJp63IUZDa0O8fyoo0Rxmyn7vtIa5H/C94X67o19u6K3hjmeg0aK5KWtPLsimOA4IlATAbE/LyjYpRIZAU/XviNwo2V8RWQMheXSs9g1T0HVoChpImwnm6j9a0rWAlGYBFdczB6No27T+mMGWOpItmH505GzMcvd0AyhOw9EaQdpQHQzYkCWwycDESuoDAWsKzI1RFbLdHehdQjEAJ32L3hheaxGshC4KmTvjLgwdW9A2OdBFZ3EgBqw5umIADiIN3MPxwYGBphTFB7pDikvjxq9+Zls48agwGBUGC1gGcMYALCoQPCnjOW/ICg8gZrrTpnEd5mjN6YGIVjvLpYUUGuNuwWh/Lg0PWc55DLDwX1PfeTSg1Yix74YhNiYwyIqlCPHOm/xpJgU8OCcQSluste+i9jUclQXDQt6INJ0MF+in18wABndT86AscMOh+bXYIkVRaoAKZ1pTcaEhK02loIa8DUmTCgF6owLVEjjIM9NzLDLuQsqkNjl6G7VmlVo3TPnUg4p4FqpybS7WrPjKrfniDeNbpbc2wrT5kX7mCl7PtZhUy9+PXzk05KkQcxXIA6WioaTRUjbmZlKW5kRZZtAgqb9T0mPuN+uODcnluk9aCh82rWrmBLp8Vk5CxiXFceC433G73bDfd4xxYLgslAmWT1SFXL2/NjsSKJ9B2wkp1H2W29jDz/xOG6stHz4CNQSq4NrsPDuBR6vnR43LfKDN9q7UjAk01gHRc84NrTadaDd5n/kOUVesV00FMeH/+2JlOP8ECsxOgPp+TOoeCbo1p2bMEGoun0D68twyyK4vUDD61MpJKz3hLuBxvM9vjBq31YOwelMeJHJhufq7QMzyvg+9gFjgf55XmG5tsNpx6tPHiflwLN7L9XURwnTnzptzVJ/OfUEyJRRfkYrGODAGlY0BpzHYlaxB/9DmeNjyoDSKrHaP6vZFCar42OCCOo1N3jkxLUTIzG7TnkJDstgPNh9VqF33r3NTktlsexo2cgyS9XAel9MAf/f4TdSpcqvgcfuvNzh5JmquWYoQTkqvl556Z/I+c156BNYpkbU4anpqhkZabpaGhCyOmWawVXs5YcZx4HbbcYyhQB6112m1TSBmMERz2du57bRJdNAkJJCCCWuKp3mY4+0YsNsN1juadbgZjs1g24AN3VeegZYzL5wxB94qtRr0XHL9AogBC6DHBjQFz0ZISQsVkWrw7uL2kVrG6o+GYSQYmTEVrrspYLkz65ZlHALTxWZxwYHUwEM8+rRrM/6B27SxQJ8EFVP+aWLIcwQ0WpgFrDqYhWqEY4MBtklehdYDAXbYKKBpIVpXG7DRYaD3o0eDKTbDLGNFIO6/YUhhcnPR5WT5d8OuOd0QuORaFM+rB2T1s4V7KwUppEQ3Yn0LRzsYfG6IqupO7yNzcA9nStsmoeaNRSiyKvjRqLRsyugEiGKzyJuqXp5eHgtmR+uG3a3eWU2Dw8n8aAFDx+FUHLpBll/S0WDMquQGHM2VXUneAMxn0UXNtM1l7Qx6PW4IXITbck/lPCDHxQyK8TEEK9xRsZb88OSKOmlGg1wk0Y06zKhwHjGwVdqMiTkaFHNkyBvCuqNFL6u1qyIzAK4Jl6seMRMpZBxNm+PuQb9Ng1ExSbd3zSd6/jwq6S9GsOAjuqgiwbWQNB9a16O8jUnlcQA9GmPQfj++e7TcCxCy/bHPU9koylJE4dTzHm9U/hP0AbVZn638WkluRU1M/OMCFml8CXEvcl1ULLo2xyYlnckHaBQafuC43XG7Ma3tcQxlVpsUDL1I7cUAVufF8mI2qYF5WQGupJasPXHGogly7XxKUbnzvNw8ay+PqD5NE+KqCExMsFiMc86XpMp+W9/6e8q2WmqnV5vnCbPM+hkLnlAb8mSrfWp5f7E2VnxhCVASB9X+NPswlj9SLqw9XPgFc8w0hbH2VLU3gFKavG6zWKgniyS/yy23rl+OTN6zPp99N2dVBkPX/C14siBWQxl+q0/nVzUeE8Kff8/3yT24em6ZYHMsdX2+0+zs2jOsLl3VxilvASCTCVQcauRZQAY9ZH+mzTnTupOiPjDCSJfaVUATznV6OHA42hZznhiQaeyzIw1WmKDGHkaaU8yXDJhqhQELy3PeqyaMy/g711rT7xFAiJmS7KHZpZO+nWvd1Edhq/+0FQOkOl5919Rtf+v4DQ75qd8CXJTpFs3G1itYWuhsmVj5oqtAm2U/gKRgqVhePEy6FKrz1/ef1+OtzsuiexXxb8AYA7f7geNwaa0u6ylTTsbGBdAUq8AWK2Rc1ve1QqNsvBStERii09jYsd8Baw1mG9AMTw3ALl5d1jyQtyHM4J2usgYALUNxAmEZ4GtoQb6ed2eAsQXMuSERvLQaFxPlCGjUtNGA1rS5KW2o817sb1W7dijAssE2lhijV8W0gc8aDu4soBaWlhXF3ljH0ekl4nSgN6O3AIu9NTSXVwABGw278XlbhEB406YdAvqqoq6CiaFFkHPggNff3oDNDTbkATJTsUTAjLUqwoDmDW5D1KZWlLacQxahuhmNKYmNBQgNVKyUokoW9BCt7OCzK1tNV+FFgUfMFMRZ8IaV2ZuCvRrQueAHApsCyCOoSDYwyPgysj4DAXnIik6AL6FmQGAgq60zS5WKEgYLLCaCiBAv1EL0LnZCY0oLBZQPDCUAMJAO1GKo8J0K60WbSQmCSizgVPDQpps2RE1rojFq3TcjbSuiMQjdOV5ujWs0SEMERFMw8kqz9swWgdEdXYBnREc/lHxCY2JyyrhxjrBNnJfRAmNEzfGVtOKRNLPA6I2CPEKUQraZnFqH4RCtTfFDUsQuABCML0EMHFJKugRkxq24Auj7yWr7+3E6lDc5Y4bS+h8RylgnwCSFc0WTlO6UnUn9TZ6qi3ZQ8Cg3+pbAA4AzVop7vzGzn3gloRANa4zvmn6SBFiiMYbD7wfG9Y77fsf1vuN+PXA4g8CzRh8b8Qjp1l+XXXDxuizQYoK0WLbWh6MszOvF1VcCMPXZvAkTZqDAGlN4zusod2XYsu+8Q1A6rgX9VrSQ/7VTP6wtiHlJNn9RMs7fTXBLmXNCEOWhLkVr6ZOy6cfy8UNnludK32XrLYFiXiuFa6qOU4Eph9ijdlzNObd6fca8/vT2GttC2LzC1u+qg4lzqh/yrWPOnfQOVnY83azM4PIGpfV5UeL5Y87lk/IAq3PrnaRFmNo+z5/zvJaAQc9sNRY1izLlP93UAASUW2L39bmkaEPJaiwGkxYdwYxT9wN+P+CXg8X8xgAOMTkaaczEcJgiJ6y6DZn2PVyefVN5gCjOLY2ITqwIeihqXvXFz6SHlGdDX2Tcb9aHmr29IG8l1UnTQM2MvE9DZZ2yOfgoQ8r/XxUNwxQwasQ6J/L32T6BR+SisvKeVqdEMefYKVjdlFNZMJz6Lt+dE6Xl3Aq1ZVZ1bo9tVlvdB/b9juM4kDSUltbEjQNiYUzog8WuIi6dgxV9uxFkyVwM2ICbIMkWGDs3uqNvuG87+tYxWsfobHumrEXjNGMAtLjvyNrBDZsmqUvLdHRYUypXWc0TK8K4mAyO3hppTZgW2J7xBmaiv7AzWWWZC9QbPTnhXv3bQ4AcgR6H6GJQUBAUjMsOdvX7RYXGhpnqGhDMDxUL7BaVXSuF3zB6a9yZzad1gTfFYJgWf1plIghgLQM/Q3PDAPMmTj0I5gM4LKrSes6lEUqhCgdwaF6KUhOEqt0WaphmBNPXetFfYsjyX9bvgPmAK91dzu0Q/a6JMmXuSvMbFftkotK5M4aaAWqsi0HPGkTfQS34EUH6E5hYYQt6HjYFLsOJo01AqmMqArTuBP1LDoQdtFa4qbYJ128LeteGd7gPtJb1YRaLZvBdTLELaf3luA1ukG5w48KJnu8iqhM4XkdQKRhDmj+8cn578koRCpSXRy0YLh6WqY3ZR6MfsGH6Y0odcxVeNC2EoCTCQYoc+4S0NSq19AihATHo1XPnOqD7XHE/iktxgZgmPgmt5oYdzExVLh/V8GlA1R9BMK0yYnK+fz++dwSYL9mAI40/HNMLZ8sEZhND5lkKtNZGMxrwlOs8/VHaafMam2mn0eTdSKpto1IauR8ha7zMrX3iq0A4PRl7O3C3O27XG24vB44YiCPjM3DeAPOdebe/2TWnUwQ8yni6fH0CGN+59YRg9nBCvDuLnhrtCWYypnRkkdq1Le+b/P0GWN4/gcHSnvprvcTnhevZ57au/+bFZjJwx8THs81FPinqcj6I/bpc8PcM03fwE5UNfvEdVarAfkGPWN5dBjRa85fH2zznNCV8MSJb4jbN1xSJqXzlwymEkWisaFCPr5rW91RuTl299qV972p9E5Wh6TSADx9JDKtveK9p/M+O4MNPHpD1kfUSkdCQtNzOmlMOMkKODPv2A+4HDj+w+8CIgYgB9wHbFGcpvJK4xEE6LEWJFF0bCHQqGKvAYB7bwt+1vOw8F3oA1rQfxTLo+W7pERnzDxsydlsgmtdED2O8iEQdr/Hs4KXz1dd/jw3sN1CnatvmWIj+kIORwrP6YwH5huleCWgBwd5pEFQMpEnn/Ewhou/4q7T/hToVy6LjrWdnR2QqsChgud+v2PcbjmPH07bRm1Bggxl4BjRBDAKfhuYN0RlYymJzAkcCH5VCbNC/MIbB9h1bv+FQ5inrBGBPrZdm7Y3pPIFAjFQhuUXuhHlIfqFhMK4DhnEMCRZa9ntSmaD6GMlR7owfoctD3hOkWbnJKsHUtl2F3wLkopelNQ6gMY/kSkdLy4DD+H7KAuVGCgFBJhDeGFxrg3NH4HI0Ur4I1maFcMe0OhsarfywcgEeoHeHcfMDXbmkh6Ubkt4gBG3SzJRF/rwbreY22IYjjJnFwEWWVUzDnCl+jVmD3NUnWsS8n1V7u4CnBZUCA63jaalumR63dr6oDSWM8651AMNxDK4VUpdozTdzwBk8DnkNKLyMXgREBX87svL35GGORu+Tax34Ukm86qqYrPvBrFo06pjiOlzuUu46FocUYJRFOYML5wblBe4MAs1d21PwHZVFt7wTVZPFG5qRQpJra2S+UcWlNKhoJQIxuAYyG5jr+awozvFtWGJbEDDfSBmr8u3kxFtjIUF6qzLZgmTtGPRYGNM5x6CS103vHoOGbc3VMEfXWkow0oLK8QjDrOfSSnkv62FQafn9+P6RwM5aILagUcNZQHNrXM+pY+YG3eV9ixoPeb87gKdgamxt+GUZ1g4cZd0FYNxEuzzEyOxQuQFL2TenvOYXVPBDG/ywwP5tx/3LDffXN9zHFcf1YKxOgbnHQ3J9/eQRLy/A8gyjUYAnY6TSCzTdNt87HhBF7ccP50RihOWjbEPVFEKB0O/hlMQJCbLTe/rdpjWBQg1kYViwEflsvmPSRdZ7RbWj+kmyxrRWV32hdL8aZ+0VkuWpZNpy/8V4X7K/+kF/nZ6xNC0dAtlPLot+S7A8u7Lun+9bjJsVfC69vP75OA4W2qPBfTyJBbPxuQlyollwP0xaEh/s1bjqAgHs/D1YwnoqRYusy9vYY58tEzr/JF3WlpXhWDvVTqh4TqQT2c8gCGiaO2QcpIc0nAVqj+FMzhI0ph7uOJwB4SMAa6S+N0sjHD30rRnuZqpANfOeuIxyratodHHWZnNt2esd8qynoTxQ3oWcDzUImV1SrlZLhkuPufBt9nc5pTSmrQYhu489bsIsyaD5a8dvUDTmYsxRzuwcgnPIGAsK7XwHQp4U6ljev+6VlJsae/ZwWQcMC8he+n+ZMyUktCnUsg1gRuXPv8e+436/K3sAg1WDVfkK6NA9fsCwpWoDyKpumnwwg/clvSdIh9jCJLMHjnHH7ejox4bNO+s8bAZ34KJKz1lUxgAWB4TBhtzPlnEp5Jh3OMzbdEm2+fJMOypakEBbRKs0qBFAO9jZZvQauCcPmILiGHw/xgRI2BuDb1ngryumRGMkhcHClQWC7+0GuFM9CK9YZXAlORprU0syUmC1FmjDi2aXG05y3vVUFvcLU/vpszGwJkiXNPLY6YVpWiwOBBjEPRxcIAa1xcqjZgK+ZnQpAmzejkBvIlsrpWrX6qNHx6nMIIeEFKihIOQOVZKPBt4mik4DiPNvSp8XrGZMpUGV2v2ASnGgxGubWa7o8RGFJ0xZWBn47C7fJwAzZs/aQcpQM6iKOZCJ2A2Aq85I8lpDPNRjY4xNE+iCqp4zeLrLcqO0wEcUfe9AZ+wHSB/KigKInN9AKIUtIIHrLtogj2ahTGSi6ylGhYUaG1oL7BaANSnHiyKXm4VxbGj5aTImqBilidY4OFfkdFFw/OS0hjJD5cZkg5tlKq8MvjPWNoHDm5fS0YKFCKGkECEePt/JCgA2eXCA+LusRv9WD7eozTlBZG20Wo+2/C1IgYTZuVcQwK2CyjUKuTdRXjSbAD+XYmWfzW0nEV4pGPLYQ8YppbdFH/A3x7EP7Mcdx37F2Hc4jpoXp2MxSc9vThB5OVeAztbz9DO7IvD4hPOp9fuyaVtIBkYi8ZLf1Y6F7lMts6QiLu1YQM5pQz+91/z0+5SrBVAGTpenl5vxNpLlsQzW6q4QUCvaUVKnCthGKX5rn1neszxjMV+87r10xoJNAJR3LRW9YhotYGdipbxXjuuCEHEmSq3g3HD64zv9bPNWkU+Lpb+zrQY8To58D5+3WulK3HgzTir/zj+XfqkxAfuxpaKp9Vpj8SgMDfbwN28e51fMXpDy2Qp3LB0WNLrWPFfR23KXRAA+gMNVliBU44ZAqHgog3v84gaC99w3lha32cCiJeb7I+eiTbdVm5c10BPikYwY9o8nngbNs2XVhYOJLmxqqZ7PtFLSgEIKy5gtv65ac6ZD/RvHb6BOnSdlLANHLGaLS3qZD3qZnN+zD/nXygmra5bJtK7zJhBIQKihiXXR592WpfW4qAS2Dx+437WRB0A0yvNCVihSi2b+/Nai4kdgtM4nBMrid4BrPjZC6QHABtq4Y983tH0DbCNA7mLWSxnzMAJZo9CyxsxQkK1cOwc3PxEoe2wYQUpVx7QQ8/1zEgQMx5R/WUwGLjoMsy21AFojLSvMZVmgZyOzBHXwfQCUpm+NHh0bDX0A0QkWhzHNaWjj2UqgJrmgqSguC+oVFc7oNUjqjMrbAbGxCJwfAAybqE5Ho8XQxCViAeh8d1clbSpWrvfOKqV0fASiN7Rh0x3cG9ogILTg9R3csEir46bpALw7g9AVP7JFVzIDUdCCms7QXmTaqMMCNpSxzDr700UPCodbJ00NA24bgED3ro2obKocoZhr1NAFikdOaXgcMFBlDu2oZg04FBvSGoVRYyzLMYDwhg2Mz3EYWuunfYp1WaDMZIGNHaQ6BDyPa4SJjzPVb8oAplxWwUmu8FIGzNjfu3ew/Cn9t7t4ftzcGymBzsxtpAsLzIUEuoU8ckDW6DgC9EwZhXg0KZaaLxaG3pmK16XoUezxuTYA8846Kj5En2l1f2teciRM9dhCWdCgD8BOaM7VGd7Kwo1wUeVCsmWO9e/H+yOhq8G4rsVBiw1pxCu4Mj2JXH9ppKmMeoFZ/T0W2Q/RFXVBFnGFRMbIvW4FzaFkFFHNQIDGCRPfnA7KwL4P3G/MOjUGOd9e3oy56k7YdfnlBLRy/4z3X6zXn5r7gE7f865PCPWhEWssgz18Pe3FZ4j6nXt9530KOgtwzT19Ae3pzXx4lcSsWo0L+Mg4iEcElfearxsAMof/uxWooTG9ty8tRsSsZl6wcoHfmhdrg9ceOeklerdsl8naXUpyaRdLXz229R34P30FZNfY+nkaGt+/+3xkesv1u51fhl2juRiT8lxPqIcvT3nHV5vDs07D0g/m5GVP2/vztbpPb1x6Ucy4mEDGKqwPxpxIeact4Ept6+I2E9c4hgd6FnpKpaVB7AHQO5T9UMtUc8TzcflWUXguPfqGKIaOqluVfKGRnKbTLibH7CHut2kEsfk6gOjfDsLYLnzCy+Y8q8+yJwOpAPzV4+9WNGL2CAFaDsUyrzLF5VnY5KcxXxZ2XuS5PuoRc0q0ul/SMzABLtZFkvUSrCbLnEjr5OPv7oFjv8P3XTx+UhvMelE6TLpH5pmq3OtNQMdl7rRQMb4p8DwcLRp56GEYh+Nod9j9gu2yYUQnAG7AhSZncvsRtEIj5ClgCle3rM0QiOjojW68YUxLYBEYol61CiIfBIixvLc6ouJXRpQrNjxYsK91WtxEN+kNDCAOpe/NitLkH7Fg3uDiGfAKGEdjbQ0GNMvTkJmAIj1gVJFYuZvCv2mOoTW6KrveS+9X2a8CwDgU/wG0rGMCkv4tHHs4oHiP3UxZlUglSzWxyxTQpGxFM4S4jOx7Gja2FrgrA1O4PHkGNGXBGio+FxgI5kuW/GWAcVKr4LIeBACMooL5GPStRKhgHxDO710gNq306ECAAeYeuq/6fEC8Tqci66JY9RbY3aVwBpqxBsfQwqMBplctgp6LszGrGHN2i8anucn5RUWJyh0LUFoQzBOdNS1uKqDmYHyTMdt3Vx8n3amRe0ZrcGON9BEN20KPMzQpKqHXHggbADqsOZXGlql+sxbPupnJIhSzHghLfFAxNDgLRwaYKMKUICC8at70YDaskAu7lHxLJ1BuWQFEh2Nk5ucKHB+N86nlfPBAD2Congq9HKMMgr8f749MbFGuy0hPW3qDWfAyEgxpc42kBdZ+w7WVFAsCjxQ06e00WXlXK7pNg36CbSGdWRgyEWkq07zAnN7QfQ/s9wPHzrS2tJJ6Ka+PaPQ9DJsI7Gy+m5etQKvadDoDE4Cst0YqHgIti1flfP1ysfoaMJxPtzM+sOXL7+CV1XSImJAd+T65bla8nTeKByiSAGLpiSJWxXxaGsbyoeWdqjtPwGyRjU8soJ6PxzHJF8rPs8FWz167Jpb+fhz7/KOUp+opO+Nzs/MldY8oPEAZVW+FOU/nrzWU2aI6LSarYnbw+qCz16VYMVyX2cbZpuUZ6QA5v9DDy8Ty6Um6n3q97hDLs7KzbVW+5pivT1vZMZH/3BE+MI7BWjc+9Jkzo+SpJTmHT09a+uthViuej8OTnggxEiLpT/IF1XncT6O+hWRYwLTPc6x7KY+LdqKBIk5oNiNmwsC0uzUWaaxZvX3fWbgPx9+taPChObnnZKzBsKUQnATMXIQ4LdzsWPLH+ZIpyEyXl0YfcwKtGvcU+NAclStx8Tca0s2dbZ0D6z5w3G/YxwGPA2ENHl0KRlr6aWVm+teFNygL9UlYx0A408NWjYQ2Cui4G459h13u8PsF0Tt88D7eyNXuWflRd/W0pTnTtzaMUsaataoYzrfvDFINS4cIF7OzIjU1ZQM2TbygBTUfmBtfiwAG4z6GgRXF3YBkFUYDvCm7jtdkL++JsUAbqzeHPDoA7EDuxmbMBuVyS2b8jnW9u9MbQj68wYbK4w3AY7BWQ1N2LwVgHUaloMcGbwDijgrK8oabccPbsGF7esYf8IRbH3i77QRzCj+BkWs/lOK3q/rgAADn+LgQRXlTh9TaBrRMRzfAQObc4kegt14zs7mDFI8Z87Kr/1pj5i/4kGW7KVMSaURMZ8w7HRaVVKBLJYYPmLnyckvYyIvjYJakbknuklAU2B2SpF26gXtwvAOAqD2RE6yLdjQoeJl9h+/VEHx/aWmV+EFeEFpzHWiqIB9UeJsNyYU+K86n33AwxgSYcTYp5MRc4so5VN2ck5MbmxRxk5ZbWe2aMaNTKB+6lIae8S8d6EqCwH7qtF7JGp6F+5Lfu0uuHcH6MpapqmGKC2AMD2NQvOp5HAE8pXLVFUMSRoofnTi/H792cFFqrBfZPHJ/WfapyL0kKaMZm0crZDIl6KBObyqkYIuGIAoFlQDKzw7IqqmLQxIiqOw2eVShPc9TRoPidj8c93HgHky7PhCi70UpPO9g3LK/F9TTfCzFZz3NUBbTlZqa39l63vKwE+ZdzklL7HwGTzpDQyn4MTF2OYNqq54PWt8rlYxCADJunJ64IiJgAb2874qBSW8CalARJ5ZTeSTtdAtR6bJF2Tn62bLhApQLrel0n+W/+X32bb5z6Rz5NyhLaKV/GICoV6gbreNRXoGH5ySnf+LDjPfINs/3WxWZWPqJ56OeM9u3jl/eY5mE6xzL7wPLtXH69rH35gOWP5cBzD62pNbYvF7OapziaJf3S89/pjheVE5oFRa1egDoHqTdH4MGwuEI/XR3+BjA1suhgWDsYha4dtdeCDJleNIMITDRNFlKQBkL83/hKntAWdcRFUuZA5vp2ROAVlIGMTkwUlHhc03G04iAH5mmO9eXGCNQrZCc71pTD0Py3eM31ZvNl7aMGcCUSQkk3s0EzMmZGkSg3pDfNzZ+ZWeZ/vZlklUowrpzIIVrzJcmwbLaljzSVaFl4b479mMHnN4Ha0RXKfc8HNY2Tbjk2po2/SwyJ0qONTRjlpkWDZkyL98rDlpOYz8w+gHvg96ItiOsK31ZyGrcGX+gucQJpMDeYLYmT00VOldEcuq/3FFYaXyQM2hW1xPguiypKj6GIWGVGymQcTEM+JGXZxAMDk81d5Bqgl4FZxoCR1CeD+MypZehwewAABy2aTFTCWpKoxXN5Vo0FX8zjAE4BuCq6YDAgYFjZ3VOHwfgDQ0NTz90bB8Cb1/vuN8GxrjBR+bUb/iwPeNPTz/j3/27f8Av7YrX//ivuO8HLI5ajNYNXXz7QEML5oQaSYNoWWcllIZVCkjloczq8UqJa4wnaUdgdALeBiioPDNvDXRjdiVaaJm9JuuAALKsIargWwcI1iGSVIOyI3Fohjw4HbqH854ZS3PIg0DL76CHLjiPY5D2lR4albGAD4NduEhN8McV/4MIdNVo8VBWLsw5Z2hoQ+8HwNDlUXPG7QQQ3rUGgLRMW7CiO6udS4a0pkBwKCc5apNnU/S70lL3YF4yT0liY1qspSSm9EoPDekNUV6mznRcCn6XhdsGPKigbVqsBs8wJMBNfkWk5NI95AlSbMwGyYdmrJ6uDSK6wOvfJc7/jR4CsdapUJeF26E1aBNpCc1lXFkEHSEQVa+p8GnaZVqCjnUMBg0rAzTC9DAkGzXZTrkPRXQEAn0I33bgUOpkTsCBcdlxx47b/cB+oxd2DMqZKhFTng3gu3Mh22eJuU1rboJAvhAW3GbvfvzVZxRo/B4gXJBo/iU0XVS0fE4auOJ8r7KQTxh4PpbaA/VlUjzWEIBsw6rE5JHRt6lxrq+m+86dW1B5AdXrO85HpRUgSVqx3PCxf6aScWpZBckv777oNKcMnYb5vj7vOxU27d/L9RMyCXDqq9CtQqD2hOqERG3pzzyD2/9KM5vtSw/99BQu3ZevuI5NDVq9IdJLuDT53I/zrksPc16ZLUOVHkwggzeXS608nu+fG7B66KJohAyocLJUnNQp/gv4QeNcJnGxrrTWQaNpE8aKpA17oOj/lnTrkCdbBkhsem3tI9Hh3oSTmNjCWhqvUEqhwcsbkU5YrhdkKCbHF/LehmI4LIpZw2Ep5IvpLcln/H2k3t+kaKCGQy7pmBPzr+k1dU1O9UU7Lw08knGoe2mhTKtGlLa5PkoQowR7LpK0fEQJCt4zld0I4DgG9tuBcQDjGLBumDm8DSwK1krseJZ7t40ToaneQWT+fPodmjWYD+XsBz0CmybAsaMfV7RjY/qzZvDe4NHQNXNIYQkJXgXehiZpes9yoyzTAoOCzEEefipX0UglsSaq0gHP+iAB0WJYCG9Eg28NHYdoYZzArIQsa1wjEGMdCkNTWk4VZxDwzMBXB2xDjiI1aa8+hSY8dO4hBDDSgxEDYQ6/G+Jw9G7YLs8YvuO4veJ+u2PfDxzuCDdslz/gz//4j7j8+zteXj/j9X7F8Xbj+IK0n+PyjDgO/IfbF1ztwJeXNzhYoI/AfEO/GLbLht460DueEKxv0hpaa0VVSvqOmzMDnTTZVDIbOr0+AizDRqWkJS0taoFzvPoCyhXYrQrp4U0bN8Gn2QAG3wsGKQ0MIoc1BqPluhE4R3Ns5oid9/em1aVKplQKXCC8VbA0Fw5V/ujGQofRENHlhaAlZEjQUZ4PJC2pTbSEsCxpBtDSghLKTTVFvHH8O0CFOOcSAHjD0SBvCAXz8CZvnrb6LotSgs6VQ2pTDrnWdGIxKhlpdYY8ggYTE5bxJbTuRBYy7Cgv0NCbjaBHpUBryg1EBQI2BGDMJOYRVdjdEZM+VV7j0077+/Gdo6gDxh2kyZQYIyBOLBL8ZRYVinkVUkzPIDrl9Qkjtro2UR73fcnY9MTmZl6ntSp2OTYosQJKKQcAtAPj5Y77tzsVjTgwdskDrMC50O5s10kzWNDrr02VR0SwALn34PnhNt9BE/b4cXzv4dr9E2X6AuAM55+nG/+Vl9B+fsKev/J7yZpHzL+8gPJznE6YQesr+P4rXRv+oGX+lWPRB77b7nxOTGUhe7YYDxX/kRdzbzgD73mfVe5953HTpG8p823pvAnc/8YrJR4uGs/yNrPbT/darnxsVJyH6ldm5vvL8jpHKQ38wk6dnh6CzCJXbctfVpdgEHibzX+wAI6BMZiO+sg9oIRByDCqfbgB3pqIH/l0PoDxpa2eaWBhW08alQess14QmrCAGAG5T6AS8cyBm9hb33eWRJh4fGHmpIXGh96fhkiyhxSbZlblFr4jEn71+E2KRuKVsxCQQI85gerbVAyWRToXb74s5kIyK9dS8mtz3GqfLdIgCtTNm6/uvseVsfAqE+b4wH4MHOrYiME2rDH3zswzTZoyB4yW9mRTVXrPlks9Ft4+0HsAwU1njMB9H9j6jrZ19K3DdwMu7bz4elJedg1yFygNWYSV/SoUmBiN+feRvhYulIGDc8co4Em94YuE0ULNrsoq10qdCkPvnOAhbSAEZg/BaKt3n4HXPI+gdI+ZThSi1jH5KD/zEYr/5iT2Qb+Du3PxHgfzUu9A+MDl6WeYBe73z/j27Stut8DtvsPHgRHAtr3hD+0OvDk+/8tnfHu9Y7/TnZkpSuPHwIenn/FydHy+v+Hbl29AJKjtuDS+9+XpZ/zpjz/hZzR88zeMI4BLR2+NipIxFqCPhsNYoZqgXhNTQq1hYIjzz2J7itkB61F0tPLcRRwc1wK+TfQZChUzhxtTsUbwXyuB4LWGWPOCKY45XxjU7bKgRwkrlOW/j4A3FJ0NWdQO+V6iT3UC7pZrNJhpi2uV68jRYH5Bj52gPHFyHEz75xuBhx30/vlAQTlLShSpTENZMTaDCiESxF+q3xwh4c3MYgEcmOucnUIrE9iPYWmICMkPzdIUcME1ztuZMqxJ8fL0BvJcc9FmGpXhbGMqE+UVkox0U/pd7YIGo/KEnV4TY3IIn7tk1eL4/fi1I72Auf1R9kVq+LBikZTf3bgXkbZpnKeYlkZu/pM6geVnjURyPvtCzcjNGpjjV0qNVduqMvB1YMQdt9hxOw7sdyUNqG1swvkVM51Q/uq9z3Nqv4x67EkJyqY84Lycp3kkZiqHyYLVHnfYSKy7Xqxf0hKaeL72UkxMVwAxlpdcrfTLSxoCSEqhSYmL+ciaCScIEsB33vd06H7ZRSnKac0Wc2Dto+yL5dbzlhP4LTDoPI7Zhoc+t/VLm7Nw9lvICJJfxHLjaXXOa7D096oP2umzBVtlP6endxU/hb/m2kIUMwlJWc0GrOMcFtW/Rbta+mMdv8KV+mB6GCD3oM37L1/xNaLeq55i2bjca3JRZL5Q9rUJHOWYahXXdxaQkYFPcVFcD3f4wcyM9RbVR005bGxpg6hTAJRvf3a/MAF6AN3QjhyLqE4xQ9HMWxja4H5W9vh6aSWxNhOTomF4JNt0dr5weZZyMC1M0rjY7qwHku+dOP5vHX9/MLgG2kKCc133C+Fw8TahXNYgoKn3hizcJ76lfitXnWlyLVIOmB1Q/bOsmPWZNWL5fSyAhxeEB459Z/YAicHmxkFrfOloBISBQVBkjZPM2PlMg0rolVrqGLR0dtFmIgazyxioiR4Hxn7F2BuOrWPblCe/GbbIgYWyDgkQikLRBjAi079mdWbA2wbLYjEWxUU38/KKeAAWrA3QLDn0qJogad3rUOJRWaIDzPtMD3XSVsgVhPjkuWlbCLCOSflJG3ZV7hXHfbihGfPFIwjWfdzhR2DsA/s+sIMBV7Hf8eEp4Hvg1S94eTvw+vqG6+sVEQNhDc8f/oTnn/6E8eMbXsYv+Pb2ivvbneMBWgyO+x3tGLjgB9yOG15eX2HR5GkxPPUN6B3PPwX+0P6AP//xB3z7fMN+XBHHHa1dsPUG3y546hsyOBrNmG0CDlNsT8AwElRL3JUnAwBUrRvp4QkgegKmJqVbfafgcAYrT25x8U3lEaSDS+A2FGsEzDidCBwsCQ5znpeCilBcsRuRtbypZHRrAsVDqXOphDQAw1UJHUBTxfcUaiEvGN+3AUeg24E9OqJ1eYIaRovKuBfhnOdGYdYlTOkBicqclbKorMSWhdmMm3BrleKXwYeiNoQDwUxWzLTm8KFq9y1Q3pOgMhmgx8EgD4RQW6AjK66aOYY8MfQQMhscjRKp1LELfIguZzRKkbaYMoT1YQDRsrSDV/zb78d3Dpf3GSXnGadFOmGDF2Aq1Gx15YOSYeJxJ4JZ9xoCh4IH+iwyBA7puZLSH0m5AgrpTYuZ4joHxv2Ocdsx9sFA0iMKNM/tKynHs0kTnS1z43HPTxCa563T6OGyArBx/jy9/N+fgQvSWwDe+s6OqZOdb5znTGRUOGxRNrjaVy2JN7DZ4vosh4liUG9l53O0fCmjF8t1WdqzDTbBbas2yUOcDTXT4MfSQbb8F1jjFBaohMeuWv8u6mjdxeb7TeCVnaWPfPlyIisAxWDINSKk9PAv22mnawowx5RDkd2hNhSwR5wwlmn+1RQ5vfj7yfgOstra0uWEZCk/Tkybc+B8/XrKnKtcrl54LrS+DZixHhlXGKJEhYqzuuLt1n/6rsSMlCmDwRoZM1MMEOxH436VNPt13ee7LjoRkirI4Vn6pf7pvcgFRbhSdLv0mZJ/GbSe4xuwscS4NUhucq7HUL8tHiC+6HgctXfHb0hvOwF7ygdaUiLF6nkBlGA9y0FeGtPCZAnBtGACRSmpnM0ZZ5xTptaSCWBBsSNTpq58vXyqvpiDHI792HEcA8cI9M2AYJD1FkrlmmYaA7LaQrMmfrwmSVFAmJUpBLpDtBKvfJYDfRi8A7s3bMeOcTwRdO9UZLwDaPydtHXleo+s5KwJKbupi4rhIsK2ENVDWYAaJhWEWy5n7AjARkfVjihrHCtS0EoOFlgKWsl7ufEcaOS427CTdTvC0JXkwI3vkfQRVcdDkuQAWqTHwXiLMXbsx4Hj4NgNv2I/dux3x9gH0H5Cj8+43b7h66ePeHm94nrfEc4ihcf9wOv/OfDlhzv+5eMr7h+/4n5z1UBw9N5wjD/iPoCxv+Hjy1/wNgYuoPWi9Y7WO7btCY6Gv/yXf8X+8S+4aT4eHnC74MOl4+lpwJ4usNZgTYqFZV5+YAYWMvDaw4DOYOTwWKrWB0yeNHUa7d0GxXI0FT1u6GC9l/JYSDi4vFy+CIFm4vwj6ThzB21S9CivQgXNgnEMUjptZJ5w+beahPECLIa8OBZgnAoCoxEgAzIINHr3fEC0KMCUA4qWIEq0LJxYQdAJ9ARCuJcHes96M+O80QQQQ2sCAOlfpriThIZWtYu6JYRxDE9VeLC6uziKpmxvlBba6C1jahSs50aLturacM1vEhmqoGB86ICUO1XibQHsoQ1I1tKwoc28s3gl5D08UTt+P06H9hxD0OOEmGK7yzDyCGFq2mSqAav9COVcXkBLYq6VgqL9xp1KMe/ynkRc2G6ieSnfLAA6joP/xkAMVwKGKOw6aR1RVJAzmIrzw5bvYv3azkvmV7vyAfTWbbPP8t62fBcagVNbZiNIK55IuzLfnJs7PzPt+TYVirrnryjd8Su/zzbE6UE1HDHf4f1h5dkK7fF1qk3cUo2Ped30HKSypKYsp//VYzkhll9Oc7POk1cttSXhnLWrcuzKq6f/5OwvWbU+rEB5nj9t2Mntt/prOdKwnPtFPUdfzyjp5VOb+DLx3EOX1Lxf+iHrUK1n5RuuGDMh43oq7ydEEtPTXUrk8n6ilFDRCDEynPukK+NU7vvz+VbGwCrbVZ5NyFsm+ha3S62TAqrqjzi3W03MOmfrsqvu0L/yr1hiLl2r56zkQFuHIscs31dy9XR/4Nz1v3L8BurUIrmQIMrKyr0+j8MSc4DnXJsLznBSAlKRcAGAx311gtnQ/M/oDUxPAQKwUHrO/NuqzXzOnAIjFBC+77TAO4NhrPcFQECGMaN1MqBAbAVYI2klGQAMwAiiEOL/Zty0Gz0OBxWSfR+wdke3jt6yEvkG8w5vBD7soyagYkB0PTsFZ1riAoiGARbUC7CeQRcw6kbrWvpu2G56AnozBUw3RDQgDm5qzURtCmzBmgLegufDVKcA6OrToerkhyRaxYmAiwmisTpE9zoO3H3Hfrvjdncc+4F9vyGGYbMN9uTY447Xtxdcvx54eR34r5vD7Yqvb294fXnD9X6D7wPABvcf8S9/+ie8/OV/x5d//Yy3l2/YrwdrgJij9479Z8ZyfPj5GddPV7xcD5kiqGhcesfz0zMulx/Qn/8JX/Y7bl/+IzOT9Q60jv3pgh/9GU+XP+InNHw9hrLPNfanAGwK6nxnzhYVaCs5YjBZBOh9cvEyxfHPfBPBjFXwQN8a41ecgDyQrs4M9lYVdJvPD1Nu7+icpxY4IPenK1hdEWLhXNfDWlkXOdUGRqgIkI9ay6OTRhgqHMRhp7ekQV6xNt2sHg0tqGxR/3HYgLJeESEyyHHD5o7W81lTMHafay1dumEdkdaVYMLfCMPWTP2armHQmtw2RGNsUehDFuLsCJHboD6nUUF9XXFU4nE744nkPqGiwmIuqHotUJV1Z5IBN5LFOtIibjiMLvZW+hy9PGED+98hof/NHpEWSMra9JhaWp+aNIKybqXayPnqSsTRArReNshyxXvTmJTR/Wfklga9rHvy6MWPQvfZ1rkZBhqLc46BMQaGMtaE9rkC9bFclzv89zb3tFTWecvPMw7THhzLRyf4ub7idxSTesETRjyfsgJh0xNQ+0LC0EdwmuCwSAyPfacP37e1drXlT5vehnrv9YZWn52oQQWJZ7uztQXcE8S0FTCvfYPTz5gNeHzred3j++qaOP+5/K55YnPsTkqMxuesGNeZsy0JhJc28quC8jURJ2TjvrGgMCRHK4DTeYj8NCe+Cbcsa3KdSDZZK5Zz2ZauKw/UuZNtwRunGfY4RxcqGj+27E4V6H2c8Fb9KF1DngtnMhofiMF/Hq6dn4lVUEwXYeKwdI8RF0WuPeKCpECflWnKNQIrfRJzP2T7Vuq9LXS8qGfV7wWuHSergdk0aElOpuyJ8Ew4Wiut8PyjJ+E7x28PBi+Xspp/krtsAjUhUWVyzPTiD/IOhsXrEPPTnPlWAjanjS3yNPBoVSj3kwRNpKU+wfg6YREYx4Hj2JFVHbPydbRMt8mUhln52kx0CVmW0zXIvhHYU/VwCDjAG02o4AQ93BkUbqztsLUOuxjiCMRmiJ7+CoCFzsA50QE08s37IfCWQM1luc6Z4oOVk0F6lLcErNnrPLrRQ+Pp8g/x/CCoPBaFygALg8dBWs2i/maAbI6xm+PiAHMeBcG8zsXB+Itjv+O2X3G97diHY4wB7A70P8C2Z9j4jLdvX/D1ywve3oBn+0dsPx5o/QVfv3zGt6+vuN1Y4ArxDMMFL3/53zG2j7h++ws+fX7F/Z6AMbA1w/56AN+uuH7c8OnlK8YMCoL1DR/6htvlgoDjuQ1E7xjHHWN33APYLh2XY0ML4A9PV9jPf4QfbHvvB3rvMDxJoHBOuB+ysBosdph1rdgD1jOLUUdTdfNmXQGr/NxY1QtBxhr6QYXYGwOzGHIjEK2K1qFA5DDSg0wFKZ1aB9eK0avX3BkbMJJ/TKqdWVR2ikAHxiGDIuOGmgeOsElqMMA8Q6KjXLtmAxG95n8T5c/dZbUH3KjsRJp1DACUZtmpPHhLuor8cpZza0f6LDpYr2JIiLbRCoBV9igj8GfthYm3whmI3qXUp6c1gtQ15JwPvVNat0NWaDPF4BB0Hkr1a1LALYy1OPRQQ6APwy29SA3QMqUSdmR6ZMwN4ffju0fSpcyUfMFYO4cZAPk703oHMoVnes2bRGZWjZcDewGLC21peV5iJgtgGzExpxTUQFo/tScuCiQApuu2wLgNHNeB4z4wZB31TPpxAp/lL+WfsoLWNrxgOZ1+fo/ldu+MwJbwAbV/FolhPn7+Et/5vLwUuWdPMGKVw3xV1pYH1CV8cP7+vVmf2DSyPMDyQid8VY3UID1YhdPTOUH27L9Y2h+Bio+2SBCbgHl93+yGU8dOmKc+NYGQQHb2fPYJCmEdUoF6y53ZdXdbu396AbINy7Z7+nmCnkt/P0z00PtUu3LIIrFX7j15/1VhWBqWnZfPS0y13i/mSDyO+6ynkeM8eyrmGyCxzepfWZWvurvGIadHvufa7mTepJG0aT+TPUMJQZy1vMagkSAyaxOUbEXxH6kULv1UyY2Cvm9iYfVDE76T0cOAxdOabQmEOdw7jb500yMp0/XOSQVeZQeiaHScgra8eo7VpIpFz9XA5DQgBJZcWwTjrxy/qY4G1NHZoECuXQrv5GTnkEYuqpwY6pzC/UhBrYanppoDj+mmrrtaWi+t+sOAk4fD1I6pb6fbjMrPmp53DMd9P+DjgPsTd3pjt9gIoKdVf2qm0GSrKpdETbWTMMUi4zkGxAF3Q1PmIvYb8y4P3xHjBtwbjosBdiC6YUNHc4IrBxBtkPox+pS0ZMgDGKTwDJdSYBjGyJIYUkY8gPRmsECF6DcOBC3I1hqszulKeytqGui5sEaLuwg8ssKy2m2LjDWYEzoaa3/4COaF9x3H/Y79dsPb7Y7b/Ya3tzeEG56e/4inbeB+/AJ/veEYV7y+veHzt6+4fh24fHvF/9Y7Gr7h5fWGz19fcLvuOPyA4YbDf0QcHRb/ir/88hmfX28Y970ARb884/Knn/DzTz/gUxv49PUrqTvBTFhtu+C6bfjxx5/x4x8v8PuOf/nyCwZ2bNYQrWHrHc/HBzxfPuC4/ICPX97wdtxgT4a+b9i2Aev0jtQc742JA7RjNecqHZEuz40CzQ09USZcoQIca8WQiyLIXa8hpuUVDnjDyOA9N8V78F4tHOFKQdyctMqgALASLCITmdXcyWwYwwYBM6ysxdwwvMQ80/eRxuduJRvcuR4yX3NkuxuYS9wZDeJxwKLpvU1elyHqggK2BQKOAAw+Y0skW7q6jO7hBt+0/p3Kb1NRRRgw+fTM4lDstTJODCmEDaMx51SLwHDHMP7OQO9N1c2VMldKd9IoLw4ElJnMOo7Y+K6Sm90Yq9MG6VO0ljFGZ4j6mHnNfz++d8iopaQs1sBq8RGleGScSwsAm87Xxtu0zoY8ewAA7We1+3go3iaWTZjru8nDlalwE7jk7DrxvhNsucDIbeDYd6brNlYV9kzXjAmd5+gvsPhxSiz7cp5ZG+d6JL+9z48in2LndtbeuZx3uqosiXhoacHxd3SVd41eGnsuALd81goWIvv+dNvlD+oU+iP3ojRFnzrjPc2thIfJaCahkN77uj9Qke2nV6vn4DQAdc67MVPDTb/6CvJXS/S8R8YSnQy08zbLvd+9XLV/WszzwTafd7ou5o/Fcr228kS3SmymufEYTxv1ezZWKyxaYcX1seeHxeMH83qzWuenfk/DagHI+VzLtr97YK5W+ihH0Q+0IotuJPOeZwIH1qAYB2lGPnxmMoV4Oi3xsK43trFDdGok3pMylpntYo55ehMaDEOGcKU9ZQfEmtbWgFF/8D59YuouHGfJZnjo2+gSF+nQDaa+T85ROXv/xvGbPRrr4kztflUGclBjzjWdK8ia8xq09CX9YYpPO9271qGp05BKRf4dy1XZihxYnBZH3W99G3cc48ARnDDmDJYendmn0sWYHHgLeSty7mWmADMcqZlaBmkTYPVQRW3n85sPFpzzDWM49p30kG0baKMhhnj0m+gX0cQzBlrm/zcgyuRFyk7GSbQgmApAAKjBVBEyTN6HBEmx0aoPkLqDptoOAbiVZT03UmbfYMVpWgxVJT2caUkjN2gqWSHayTgc+7hjHHfcr3dc3664XW+4XV/xtt+BeMJ9XNHvn3EcN/zQPgCXO17vN3z+yzfsB/B8MTz98b/FNj7j27cv+Pr1G67XHcMd2/YB24cbnn58xpe44Mt/uuH19Q37/aY0rYbersB+4Cd7wefu+PL1G8f1oBm59wsuT0/wfeCHpw/499vAfd9x2++AO7oZnp42+DFwuTS82X8Liw2vty/Aq2N7vuDpqeO4BJ59w4aGQFfWsq6pKeEUXfuZF/CNIJ2pLdU/meVI9UgyC0McEhZUCwvGiCbV0lrkmZAAaJvjCFp04YEZsC7agFPBwABaG4mvqzAgrVpZsI8xMZ6uYYF8UvNSSIdmAYVhrvMAqjgUPOcns1G12BAxco/X1JZiABMtSvLGpsIQMgJ4M+wqrtWNnre5B0fVkvHFgu0ULOgwmHVZtQfry7SLYkggi1ODOT2A1JL2WhsRDbH5stExXfUAlPXMpCiSYjmsKYaOG0yP9EzlODoy8xUOVW///fgrBwFE1D9a+wDQMaY5E52zQXm/gMgaJ1gqQJsoWLn5yNO3/J7axMTEK5i04kCbMT8f10+CKu41cCCeBsLS0CV6nQr16f+1h75TINa3N81zivvERN8/2gKW13v+Wr+u3+ZGndTFh2tXJHA6f1FcHm/57nkrf3+i6+9fE+9fMzMbrUavhVR1btsJ10Z14vIVCtM8vmN+Nvlt0FMf4ZqMsMunsfy0Bf9+5/1y3yiz6fex8V8bRB4l99ZTKU99+ev87dqG79/2jMK+c/JjO/O6Es6aJIkVv3NZYc6He59uHUt7c09KN+OiKH7vPaZ9IeVILO1pcx2muy9TpruUCuO/gcBxD8QRaE9eWMiSGbOB9cJybjr3w7JqpPExA7+Xl0v2zxyTppiOhUVkMRkBsXgSSz4FjWetA6rTYyoe7H0QH+Z+u/SvuSjH4awrlkyiCGDk7Pn147elt11XtVF4GyA6AApi5Jwpi66uLrfhvOHinhWgWV9uOX8usOxEPShMheLWc6cFKS+sbSAWDigUeLsfiHGwurExQ0wXvzaWNkIupCycktlkiOWzajRPbTwNrYXyHFMJgENVnoHhgTYC934HjgYcGzbQ2rxvhnY09BYIVeIz63qdQAbT0fo6/TaV5k8LzcVZzglqyck3KlFcMwE0Q7MuA7mA7gbMFHri62tSWnMcAC4aO4Iop0VekjNk/Y39wO3Ycew7rvsVt9cbXl6v2K9vuL6+4jp29Gh4ugzYZWA/Dnx8+Yin8Q2f9h3fvn7C/b7htr1iv35GjDd8+vwFr9c77vcDHoHb7Y777X/FeHnCm+/4/MsrjjFy2BAIbBvwZd/wzy+Gr6+fcH17kwGK3PzennB5fkZvT3j58ob/59evuPsN1i5ojUrX8/MTfoTjH+wn4P/8D/hndYL5wA++4WI/YA/Au+PZL+hbYAtDdCd9SBaK0cec8SbggQMNT2BAeEyhtxaQc1e2MHLpsko5tzeiXA8qRRxMKjh7rbJG6wUCbbANbttMDQtT1WzeL3JC95DAdQCbuKhsX3PO0YwFaTApd3o/zV2o2KNBNTesCbSTGpZZnzJds5sx/bIEP40uUsBk+Rwx5C0J2KFsWAEwFXBXet1AWBfWOUhnTAGl+i8AFWj2M6lOkRyaKW1h1mQQ8nKpBwBvzgriwfMm9SKARk+KW8BxcGPQuuVyslIIEUodYY2pfSVr2snK+/vx7kgai7YoN0C2l4nizJThJRCHEhPk3CrLq3b8BNKikYY2k0hZG5TvueyixwmMBiDqJNAO0FvVCDbpsOPGETdH+IAby0mG6sPEkSCW90uizMQkaVOFvlkVnfM+/QjYcv97xFvJLn68Lmv/rPSqxBgrOLT559IWqz4rIHhaU/j1YwWl8/H19mcmVJyvMSir1/K+J+0hilaUY5uOTH443zUL2a1KZT1qsW7zmIwFxvxg4qFY8NDy3o80tbWJ5+4R2NSL8zmLtT7fJd6Pw6NX6dz9gVlSdBqobb121W4e+oG/nb02EWA72+mx9bwFUhV2SYy3YshYzl0h89qPacAGpqcrX7e8jhq8OU9zD+EPz/dWI2q+agzLMWaJL6Eq246IAXem4j+aY2wDuBBTrCE87lO8pFxJBQHhc+21GSth2RAYMilBrSF3VhuXsRstvUk5llMmJtUNEPE4mN0uUrYZjdUjUG2it4bt6KqXZgTAU5mvPNx//fj7qVM1+vPGJx4YPymwPz2CoUljtZFK4s6bLDOjAptt5eHV2LAT1GGhWWV1XT73vefCFi551EhFpbgdxwFCp1g0ukV/Di+XJd+U92i1yg92pyghQ99lTIupDXDAe8Nw8obhA35vjAk5HDsObFow6ICB8R3J7+W7JJ0ps1sRumX2lAA3T5d3AzrHBm8SjQpJl9XPWsDiIm8EM0NZxlZobBiUzJSerakQXVCZ7cZNu4cDnQoUPHAcjnHs9Apc33Dcrvh2u+F6veLt9Ybr/Q2311ccw/Dh8hN++Kd/BI5/xsvnN3x7MTybYb9+xrfXN9z2H/Dj0w/48PMFvh0YW8Phgf2IGrf7/RXfXl9EPaHnp6fkCmDsO8z/C3bfcPOB+0FFCPIqWHccfuD5ww+4/PgjXveBl49fMMYLzIDeNzz/8AGHGf7rbcPPf3jC//Ufv+D29RuaAZf2B/z7/+7P+Bk/4n/9/IbwwFN0tMsTojOLUQuo8qfiMLwjbMAwtBR2NHS4DfggMDJAaWsp4I4Q7xuDXP4wQB4mgivFQBi9D6TgAH1w02cRSUcDgbODmTMMpo0hylIjHZQ0lExLLD+KYUMWlaR1hHVQWEl0IND1vMZkCwJaEcCmahKGwSCzILXpEsz2NlqgHah0sk1LdlX8zQwjupIRBFqbXlOezgtYT0HCU4UPU/B2NGXtclHGOtCpNKfbPTdGk4IdaPLUaR1aaPNPihiL77E7M/OUo42AdylZDdiGnWqGMOUcygPXUia29q6o7e/HelDmuc+4byskkr9M2l16HDRVJyhBaE+RsosEdKn0t0QaeXPuU8XfTWQJydygoUbrDutzIDopFAA+SKVNjyNPWN8wV/93wHVtnvr0pBzZesFpzy5U+nCn04n1jurnQvd2Asfz5woOpNiBK6hoy2X1wsNh588SIhTYtKVdOcizreWz8PlqcxosiA/5XZy65zG2osZ5XrIAbtFM63wt+CmckMVa4/SyD+9Y/bkC6um5SPYCACWleW89rtey9DIVMecRQS39ufQjbL77O+C0NrUWEOd17a38zLLRCCTij4ebRH1SyOo9ywTfYeOE0KVlX0X1q0GUoPUJK80rX01/5LpIGXHyQRXGm/8yQ1YW00XWIdtIyQ0/ED5oJAgXrkuXhN43vWTZz6vybjJyIU33IWonCORFOS4qIhJTznWJtdlg4WbU82JO5RSQyn5YyomJZj0C1F4mbs0YVsSDMpkczL/DCPabPBo1lN+ZGHY6Y85HKgJCB5ENXid1DkBefhZ5FPJTooWun4JvbhOPkm+6dpeptE5A0KOxjx334eLrD2TSb0vLapAjT09CsqWX+5imSGj2GLntDAJqGmABHzBnP3pDJ0sLAw4fB477zoxWipdoHbLEGuwwcZeCNCqDKCZKgQpuWmibYgBQ9CcgivdtPQPJurRVeTYgF2DIYp0dGNJeAYFbjooFi6iN1nCA7xuyoocFxuG473fcrm+4399wXG94fbvh29sV1+sV17c3vL69YL/dMHBBbAH85b+gbze83nbs3mD3L7i/vOB22zHwjDHecLtSOXn98objdmBmXyC3faQbUBMq+ZUWgOPAcQz8h/uddKIy4UmayzLx6V//Bf/n9QX+zAiGMYAxBi59ww9jx4enjuM//wv+l//0EV9BSk8Y8HzZcHt5xT/+w5+BeMXt+gpmMDJcALROqwFrncy+hzO+pVvGFhD4R2sqFCnnu2ge9FJJUYUXhZA1IOSFU/xOOAF0N1aIR4L61qio1paEEsKheUWFJT1auSa6ZI4hosNwsPJ85NYhih8aa18EY0ccwWxLwZDtsjZLiLWIyYmXm7grUxVrrjVkrQzSj6S4CegZqEylS5fUQCYCyCqqRX1RYPrAQPMhmmGnKu07RkyqIKdPyMvUK5lUySPJDEPoOyltttjdrMPRgL4ofcH+gDNDXbSAHUO6RjDrnQEQzXFr7wHG74eOSP+blNwQ1S/pEmbTI7HQb3P3nXgyLaIxQR5Q+LHFhDjliQwwPXGBurQqgmtxTJQjfIJiaCsXfyitLTJerCzWBZPnblN728Pnanfuowt0muBgucUKZL/fp++f+fDr6c629BXbdz45ln/rfU5ejvcPOF+X58byDgAyHT7xbei6xVpbN4r6ffWGhNr/8GidiKJyrV1lS2OS6XFiZwj0JSvie+/2vUcV3sUZZ53aWic83HIZ+/Wa741Z9R2EE1YFaTlhfdZ6z9kP+lkTL+d7rqvpAcuL17Gbc+w8Ydbvc6wCUkAKNz68y+mFz+vjFOGzuPN+zZuUz55wMTHC7PQQXsrUtgneWzhseOGnpDWbvO2odbruEXqexiIU4+hrG3Kf19NzDiaTphSN4PsKHcx+yHO0AKbakuwdEwsi3usOU1wuvb6u6L9+/KaCfacG62dajx6Vj1oohkXbPN0RgL17ITt9bTWDal/Qw+fL6joJ2iSgru1LXaRhuV8kxjG4siAxqIeDY7qBpQYcfA9aPRvMVPugBCW9AMkEYaJ+Y/2D4MaWm56Fw8YBg8MvzEB0HDuidSk0TF3aRoc3Q/MG61HtrX7TpDmypoC1qiVA5ayz4XLlRBOHDxmkRU3aAHgqF7igeVBxkC3ZFLiICFxkqSZgZIDw3LBp8fNjx3G74nq74u3tiuvbFffXN3x7e8P19obr6xve3m54fXvF7Xpl+35o+Kd/6vjpv/tHvB0vePv6grcPG17uDcc4MI5f8OVu+PqNAfyHH3DVnAgpF+kqT5pBWbOr8ODckMxYP6KKOjGUGRGOW9zwnz/vVPbahiaq29O2wWPgv/mnP+F/+O//B/w//rcv+PbtP6E1x9OHJ/zDn3/El88v+NeP/2+8tY6GwL4/YXx4BZ4+4PLhCeiNWqubKFHTHR5mwGA8j7UNBgjAUwCYUm+OkDArbyCzJHUHDEO1KprqoXTNU1HwYIr3QCkwFRsaBFCcLp2xReFMiBAh5Sgh1RDykrXFAmiGoeQDXUo6bDAIO4WbAfAmqlhKeQaKp5v6PkhdbGZsk6mCjYFenmDFdVJflBChGWxAHpZgHQ4Degt4rQ8KJQagM5XgcFZnR5PgdfVAAFnMKxNQMOCPQDYphInW5AvlxmFpvRWwlRLuAC4jiS+OoynvumqNoFPWbAEEVAcEHd789/S2f+UIZbQLVbOnc1/ehyzEleemRVhervNhWeOv5Ozq1c0YQcrL9EvY4kGxxaoI2ODOHpnIAShgEZoz4z7gYyDSg+bVEuRGt6g2qJ0vgd/ETFMOB6Zx7hF1Yl0K8XjxqS9OvweQm/WpeKTlTmynn2s8ALuzNkr1gs2GVKNyY5/wMIFToEbjBBInuC4/URZ2r5PijJDOfRGzGdmyOmVF2aF3SxbFaqRSW1NJXVCJHmLlCFtriZyQ9srwWP5cwVV5N6pdaloNR0LlqaKevAVL9+aZC6oq48gsmjxvmQHQCZDNZl8R8OZ8XcZOL2KnpxTyqzbxK8PScbVm8wouL1socDkWC93e5guvBoNSMnRSzJNRaXQLsM7mmPbWOQG1QQH0BCSXImaPZywDhBcDNrFfQElUlhmn+9aICcfBmRWRqWhb9VcqKnw3q37hO0d9l/u0gzHDVbdmwb9mNg3nNSfTO//geZQ3J87dhKJn/Y3jN1GnYu1vS3GxNmaei+WjMCSBoMRBW8Dyw5wu/SLFVlkFbC4iq38pwHKS82dW8pwuVJ4X0So1WGaf8uGIY4D5BkWjAK3hBNLkx1PAKJuJrNFVtt5suqlEi+nBwW+NMRGsMS5ffXOMcGA0WD9weAPGjs0bhj0BYMl67zOgm30bCBxwPT0L8imtDgNe9WfIamowTvAEU5H+C6igHoPTnWWKYSk0A4ANZRIiOEbje7JWiVx0wQJz3Ry+D+z3K65vr3h9fcXr2xVvtxveXl9xfX3B2/XKit5vb3h7fcV939FaR78E/nD5Af/VPvDP9ozLh1d8HXd8/XbF2AccA3eHAtm9NmYqQAJlgVoQU9AFgZ7eOxdLbR65OMWr71DdCadVYrSBrlQ2EYG2dbx+/oL/1//8P+OX24Z93DCOO37an3H/4w+4/+P/iI9fvuI2vuAPP/+IizmuOAAMHDbwfAm0bUNroi4dzARFfKEaDF1+AXcqQ2bojcDAvQFjg/UUsl0KU8pqzjO3tGnwPT0CKjPJPmHUOC0hyfM0TXML2FC/asWl38uDoN+aSajqeXHM9YTAQQIYkt7Y8rFmrF2hZRsDQMtMZwAG5yjZI4NeOPEGw130GAmIofS3yKQEpmVgy3xgvEuvDVJzQ7FSFBOh2Ap6R7oqlXOT3NmnSj7ucVC+SGhFc/ghwR4dndw4ePMK1Bsq1tcPrhNvyrxlg56X0cqFLbUIRRZpwfiVSlH4+/F4jN1hW9AgcwKz2Y8zG14ao+ZmeaaXdGj/6lB8kmZ0aI3W5rNAp0iZKnmktKurTgPMNQCglFWmdR7wXV6NCPHu9Kx8i8j9djYhwWS9cT5n/SLbuB7LVrliVltuXFhsvVd+vsLGNJAYltatz47FWzCB7Lsj++Xho/XU0PMKAGZ7XP0JR9XoyHbH0vwVIJ36Z86XPD8BfdJyCr0UfSRUN0sYw6yyNE7GzARCdnpmzOc+vjBiAd1zbrINsWCtBYLbcmn2cgLs5ZlJK03cmPfOWlmpoC54PbVjKTkr5WrBX7mn1ksmKE4gvbxjfpfbc1vuteLHZQnUHF8nRI3ryi9cwXhC7WzjY7tzzuj8/thOLG0/N4bzg/tRHAF/ZisYFK70tjFbl802EDt6AV8lDZKFdJiMiR0IYxHb5stY2NKMfImMB8h9vQKTuGP3yBc7L2brvIkl4wZUMJoHDV4hD4elJ0YyyHyZvVKg/o6t6TcpGhS5VpO0FoHecfKop1hZ8V6tO+MkrPkU3xMoWIqHxBytXHDTVKL5IJSUYiCmwEltNQVEpHKg54xw7Mcouk0aLAGDOWkd3glCLRF4Aiwn6CIO8An8hykYkM/dFGheUj6sMqAMRQm1HvBjoLUD3i8YTwPdAe8brbUthYqqI8vC3QaYAUiW7toGkmplCfD4vJ7jaEC0XmCdmXtAEA9gwxSwrBAeONQ/aNLnY6LI277jeLvi9faG11cqFK+v3/D6xt/f3l7x+vKG19sr7tcbrm9X7GPHU9/wh8sLnr+94PLjDW2/A1eg4Y772xXugeenH/DhyfH6smPfZwVO/qdJ2EkJbYaTF83aAjtCwtaqpsQ6f+k9IF2M6WPZJwTigX7Z8Of/23+H16vj43/4Z+zYGZ+x/Rn32xX/1//xv+LYnvHDxXGJZ7yNwDEY//OkZAAXPONy2Ypm5no4q8gbzL2sJKYYBRZIbKwL0A1hh/Lza1Uq9ilkfTcFCRRlxDCL/GEpIiSA3svS0nLEeZ4Fmqp6EyTwXi3jE9DAXFld6UTBrFltqH4dM6hZ2woBebBC+vSNSDjIc9TCSMeLgDfHJZq8V5j0MCRDlHSwGBzEaIHwrkJ3rK5uy+bNwn3st5EmQqV4howBnCWJFjdRpXgNFcAU2Q4bjHFpCDQV8Asb6Fm4aVDJgKk9KvrJPqdCkn+7wApDnNi7Jm/cd8zvvx86fNvQGmPZ6EmmYmgA3AeV8oK6CYpTDiSWaNOgfgJnmIqovivPNMD9SDfhmuGGXKVg8liflUcHjiMwggYlT7nVNVlaoprz+xbOLPxTEn85Yfn9e8cKAOPh7/Wa74Gv0zMM33mz0+Wl/KlzfeX3A+nQfH9t4lSb2z0AApv2rlswYzdRoPtEnXp8p8cxCjt1d4qH1UESwkERMoZkvy3/Htv1N8fisV0PDZswkf9NR2p++e55wIL3F3T68Pz8iN42AUdfcNd67uPcWOZYmbQKBKIYJtXuWKbLr7Tn3NHavyC8Ve8V2WBe31ZMtbw/AKtJ8lc6PuMPDLWO54vNeZ0GuDJ26xRmE2WV8OHgPuXyFCQtVlN9W+QGcYrows405qrMxlpKKZ8SVGtmnrpHckacYUw3ImNls6A2cUAqxHNuWLionZQ1DcRO3rrkHSd4GIkYbEarrif1+Vcm4MPx2yqDW3LdeW9a9jFnYU2+UrNQ0zA9AstKLgtMfRRz0taAW/0oflu6a1epYHNa5wXLfkEraDUy/5tUkcDhOyKOAhgNElw+YJmxRvLfTSnIRRtpFvXEpFq5FhoNnEljYU0ARNeGqMxTHWzFOBhS3gzHfmeQNVTteQMaNlmmp3ciwXIxAWTBBTDTqBm9OCNAqzAye5DB204BYw3RXMGUBoSjtcCBjT05gEzJ2sxLEfNGMN7GwPX2htvbC76+XfH27RWvr9/w8vaGt9c3fHt9w8vLq2I2btjvO273O70oR4P94x9x/9M/4NOH/4yrX/HtJXDzG/zmaM8/48NP/4TN/hVjN+z7gYxXMBCoeo0uZ1DR9lzgArNfcv82LUDT/KnVY1xg9YSAKDWB+/UNv/zLJ/wJTxjN8fbtDYHA8w8f8GofYLeB10//iv/mH37E5b//v+Pzv/wneLzJU2borSvgJ+B9Q8OBgS6BEQVYqEyOKZg8tDkbEFnfnd63NghOBoKACZjUOM1TLsvsA6/UtQ5gU3wL0xMLQgcVUwaBG7xrI9HO62gIZw2XWrktkBl4M4VyBmKH8xmtKYVnb8AANvD+VFvBPkpLYTS0xvaiGXmrojbR4iLKlSt9LlzlbBQ+Lm9W1yZk4VqHCRxzk5I8GCyCmKlIqx5ONFEJ2fdNz/YOmAd6xpuYs/6Fy6VuqHEidkwJNdh2yaWRoHUw4UIZT5wbgDzpvx+/dvQLrHcWSxQorVTkTsUviyZ60ggt/QOmNSYvVcSk3lgCG1p8e1KjAGWcqRWmZB1Mk4zE0EUrAopCEsw0NsJwHCz2OyLgGnrt+UisMfdwzZ1lS0zaSO21ApYVCPodfDWt6CvFh9/E6V6xPN9OGGblG5WneLnPO0Ab1TSeYfPcwgOxfFHAciLeygqW1zZjMZ3lTWIdn3q44KqAYvkIopAJahSFutnPsVjWJ/Cc2Xse1bsF1DxSNfIZ6f1YO0j1D2hUWr57BMilOQi5xByGdZ6cWhPvhgLf/UQ0WgJSlHd8xWPfvXRpb+6hs7DeSnPTbltYOPdULEOcnqqFvZL3Wr1YalU92216yJaXnwSieX8u9Yf5n7IXwm+aFzlp6+2q66PWXTYz7xVpJFKtpibPd67V2cimEjauYHLSO+m9CHJnkbWTJm4JZTA1GapN9TuYqp4JhQD2actJIVZM9lHF0mRT+qjJQ89WR9CdiyyYy/IKxACuj1bjwXfEzLvj71c0IgUo89FPITvd0bmoa8I+yIa6x6KHnNedOsNQnZk80tQoy32NXByQgI75iNwkZuMxNxQ9ZhEC4QE/lMfcnYG2m2LCzVQhPCUtJ7Y3Vp2FGeDsk6wW1hAI+r+QZD9H8u2JMwX3COydgb+HO8wP2NZwPzqsGVrruFwYuMvGU0moIGiR0gxB+oU3cuBblk1lMbTqe/EFme8HMA9syl9oopt4KJR4aLDkhuMKlhUeonTtgSMC47bj9nbFt5crvry+4u3bN7y+MAvU9e0F317f8PZ2x3G/YVfg+3EMAKzbcb294F+vgZ/3G663K5q94enHII2oGbpd0TZQGXQqRtYatr7hOHbc/Ki+NhW8M8YhL4IkRYImQMmP/K8IcbVnWM0eBEH97b7jf/tf/g/8sF3gvWOownvHHR//P/+C+OEHWOz4+s1wf/2ID893/OXTFUMF7hoMzQ3NnkkJ6ik4hviSs3ZL027ikXXiHTDHZqa55OgbQT+CTrQNFCZDAckWgayQnEZS8pZzEYgm2HOOKlAZBwIbh9xMub6dFcaHPF8pkAEw8JyF69xlnREFkaqqPBLp8hct5dBodAvECAo0KXnMjgVmdQJFbraHH9BqxMxWSrLQ1FPyeG1OL6ODBRKjJRFslMWHXSFqnA80eQwzAxEAuBS9FgZvY9nkB5q3Alyp4HmQWjGa3N9ixTRVqQ5rOBxoMZQEIOiWFh1tM8XEWMqUv0ec/9s8rIe8va5xVOpaKYCpBAaSJoAHEKiiVYCyuEHUw8l2bqEsfR2IQcXPwbmZ+1PDGUdxCxP1xkJzgOv5sIGjDRzDMUYmFMfcuH3+fcKcC8BMUFQArWCz+qXmtv4GJmDPExd8PGHctLqWtFysetmex3a9n6EL2NTGXJjwhKFXr9ByozRs5EPXfVs35jqdWKQKMdq0Oq/NfDyKdaH7UQ+dtOpT/8c0ip5YHIhzwfMzwj2/6+kdVirWr7dzHU8T1Fo74zRO5zc7NWVt3qldCUJzHmmCmcaj7lntTvlbQKxwuFc6cdQcqV10fQ6gBDlxfu+IQpTZV4tuwLFua59GKd+tLpp7TX6Uc6wIKcveniloLc9dQWlgzk39m9jVqtOTqs7SAcQtvQesByuIZ7vCMhqUe6KBMXqNtKWgUFn6NMqBkw6awizSYggT5BmnWwIhAi665CLmu9ccPLkJ+efIcS2+I1/WCRVmxzfiiqTi/63jt1UGRy7ox799TjqcZfhZr2TnLh6p0yIuDl4Jv7OkWBfIiVmbeKctFpK6v623qGXDmApZKCIq84eNAbuwGkRD9u4mdU+5kZeIE/JCs4G9Fg5jEUnP6MO5EBot1WRZBdurIN8eA5neKo5AXAKHg7Ug9oZLNHRriM5EtuVdBxBCZCFTnCsQ0iB6iJpncN4fgKqFgWG1oaw/8gYooN0V7J2gtIl65fJ4AADcWeX7+oaXry94eXmhgvHygpeXb/j6+oL72yuu1ytu9wNjHPAxcBy7YkIG4nLBj88/4Ee/4/pyw/XzG/b4CeN6xXEATxdH++kJ9vwD/L98Q3+64KkHfvz5GYgf8PmXX9CNVu/WqYSM+/5AHZxCMWB4MmDIwp+8YQNkOZ/CjYtSES0BwA37ccCPgzPEAj88X/D0h59h8QEf/+UveHo+8E//8Gdcv/wzXqLjGAPj+hWwIQ4/oc0HB7bnJ7SuyuQN8qBxdjVlXbJoHFPFkQxVdI9osGOugYvWmwE4RGUazWTV1Qaaipe8DRGcD6R6EIC7flcqgdKX04rPmjOd8xfpHeBYYoiy0rQIgx40ZjQbtfYAV+E+0cUERAKhoF7VEmmMcUhroLfMTW7AQXV5SGGgLYDxOi06x9YNR3pg0vMArmGEPHIhL60Zttw1EriptgjX+EE5gF6VwdF7bTCR00yeIRsAmpO3GxyZTbLCB6qWxmEJ5JhJK7NlsUsUO/W7R+NXD9NGak1VfJIWCANrnyS3fLUo577gyGKUYY7oJupaR9ZJSte5J5ANKYa6Q8iFkpkFJ+jV/pHJ8yMpeo6wQY+gUtmunn6+0xLx8IhEH5BirpczZ0inJAgvpLbsuevPuenmRoz1srmnEoQXPIz8DA83XC4KzHs+dD/lbJyvPbkl4vz+68f5CFm80/BBD0YGrVkBTnZNzEfEesP1UfnlBJJ4aP77gQkUANdFJwVjfT9b+roGan3DtQ/nJxPfywB7hkc18+ZbLtZ+3c9OL/H947xEoq48I+2Hzlu8UdnO+hmz+9Zm17if8JouyG9z7dp8ni29GQ/9nHMnPRfloYBJgYyHO8wHs57O9IpVG0MyZVmnIUNbxQIiSo5wtUsepNcxYwKr6xYGjjHCI6nD4a0K7YWsf2s/AobKrqg+gjtWOmKUa8pzicx1BSlnzj2v5nf2fT6v2qdb1dhLZqbWl4E2f+X4bdQpdeoqqGwVIPlC+f1pxs6NOAEylnc0gT3od8w+Y6fZ+bO1WY9r56FFAATIVx9upMBh29wdh+ckzMBnAN4IzhI45YJL6pDVlobmEP0kF5T475hWZ8L3wU3RWS0yrSEBWqKb07qLHjjCgeFozdH7wKbJQZ1EkysOkFWubc7uAHqBKkb+zGDZCJ5JOnNDS+pKG/VeJo+NVxVIWqhD1SjDAmMEjvsN19dXvL68sFr361d8/faKb9++4eXlFS/XK8bthvt9Z2XwwfcZLrchArsfuPknfP72H/D5L3/B9fNXbJcbNn9DA7BthvHyiuOtFb++X57wfPkB9/gRsL+gd6OH43IB2gfAvxKwjYBZh10Mft+LV2sdvCZorQ55CiggpjVsXUIBMBjaA8M6YAMxCIS//edPePvBMeyO63Xg2DsOH/j4z98wtobN7mDxw4ZjDBycdfixcw11e+L6yrRl8gzAZNEvsBkCTy4FpDPgvynGJgLGaCKEJhZt+PT4HKH5DUNTXA6Mc8Gd8Qti7FAxMAODwkNonN46ekeo4PJZyoZlrO3RrMnPyvTNFHJScp3CKq2oFqJcYSodjPNgELfnCgsquy2YOas3UlBoTc6sbK0Ef5MFugaz8ot6uZdZ+SMknxxH9U7KhxnfA8/QK0NrDnjSqFTp21k755C86grMM28l+FnkkEGArQV2PZmetAxmTle8+p2N/f34laOs7ZabZFT9oEIbAFaLeqa45KzUKmn0QLnTI5ZKpuE8dVB/J1AKAQTOjwWf6au0/OkL46zjmo53BsTcz1c72yPY5kfrOz6cX4huAR/5n3yXta3rvr1i32U+JuZ4aATP/Q5wjYc/VqgQumbdq7Pm1LwwSn8qaJhtF45ALBgX87v14fXr3Pbr+QkcvRqJGoAQukt8Vu8YCfe+84yY+OX9CYZzryyNr+9WFPP+m1LMNK/WMbHv3CXxVs6PFWbPTpkXTGXl3PS1D/Mzmk1P6O6vO6CWV7f3r1nYMsewSCRLLzxet8679GwYMAv0acKsuPX09g9zshxTNe8XalU1zk5tze/4XMWVVxxfTCVluXfF9+iz2Y5UiqeyaPK4jsWjwGdZee6nZ05z97SefZE/09MVK3UtMJUaX/po6eDViG8jn7cMxl85/m5Fw2U1SK0pB/U0bU8T9mGV2TrxJpcvF/ua17wsNaUYnAd87cP8NrIjgOlSWtqx8jgzVVuuvkBgHAOHDwGPRq728r66WB4BAtEO1g9guluT9TFvy1Ekbz3pSnK0em5sjt6MmqW0wx0BxI7YReTpDa3R5eZhrFwORViMDm9UIbrRHcfxn2DLAG5oACAeHxcyCSXkk6sPnQXWugJmI2ixDw/0noJKz/HAcex4ud3x9e0NX16+4vXlG75+/UYl49sbrvcrjvsdxzEw3OE7u9A9Ofh89jgOfPn8Bf/ZHMdPDfHDM562P+P29U355R1//hnAfsUnuQjdLwh0jOMFZoGtb7DW0ZvBbK8Ur2bA049/wH/9737GL//8r/g2gHG/4fnDBmwd9/sFNgY83mBgdqcOqM2ao41KTEoiM8C2hRZgDa/uGB9/QXvq+G/+8DP+6UPghg33+xXfXm542kyB9AYEM1ndLoZtN8AMfeuSEx20yllRalx8z1K2m+JHAiy8t3FuUg9RliXFNjSYwHir9cq4BcDQy13OytwuyohrzQNhjuYteYS1tsMHPIZysIPB3p6UJa6PZul9KDWAqUiNtUUio0BtAEGFlxXRVYfCIe9ZJimg/8205qJxHvYwxl4IJLJaqpe3JkJZ6CAKmnEFjbJ4Qu/sWl/pYTEq13Jlk9pkCzjj+nBJ4N653vpByh6a5AfSY0Z6ZO+Obswu1UGL0JAUC/A5Sj4G9ybDwt8W5v9mj7S0DsnsjpkVTP1uBnmZwUJVcFQBuSYDgymw00SdiqTaWq0twJiaeeGW544UnvtJZq8XmujreUaDg2tTcbbHDFWUVeqp6riEnB7aPR+mQWjjW/fW80a87sOTx73sgAVQ5lU5x+P8yOzEBKPfQZ+lfNnyuT2cI8vy6Vp9OWFUAvwoS+8JAFskfZxr2LIzNEyL9TbPP/VLAoYFDdclRQkptDJxCxbAuHZB3SgwofryNieAa6cfBaiK9pUXzdiRd9fiIQpheY+1bUWw1hKZ3h1DxmXMQ3ihzc++50hdJJX6zWqepOxf8V+emRguYyEekVxgMWQLp7Q6z7Dw65ahXD6rj2PSqArQL8+q12ZfT0ZKU9u1HsH5fnI8ZU2VzvyAhl6GDgMqLgMOxGHkyTfJGcmTaafWrApDRF+aaIg2PSsdnZ5un8whbts0YxdsXgzWtGu1Mk6elWT1dxlmIL5oaM9DvT8JP7PeVjIPZvOj9va/dvyGrFM50DlwhhnctBylJ6QgO0/m6TUsZ/acJ/kOkTn7UXQqukOzDZw9kQIGtnh7A2lhLSGZCzX7eJEvqem5H4gxBMoV/680tQmmvkdFy1oGYQJWuQxtcjyHyrdHC/TW0AYDTBEMAII2Eo+C/LQCw9GPnQvZNnh3uDVcLAPQKaDMgCMaegxaknOhGytktwDQOrMORUMTxYt7pZHaUf3PbEMXOKKxtoFy6lAxiAFz4DgO3K6veHn9gq8vX/Hlyxe8fPuKL19e8Pb2itvbFfedSgZ5yJmiU2R1TfgWfNvr0fDxLXC83YH7gfj5Bde3G+LS4bHh9hLYbzd0OPrlCdg+oF9+Al7/Mw53NDM8XZ7Ru+MYLKDG2JmOD5d/wvb8P8K2b3jCgbvtaNsTLoqR2DbH7c53/MMfn/CnPzzjn//LFa9vNwQcl63hctng94F9kM5z2TrGQXfnU3PcfWC7dPz01PDvfv4J249/xNePgU8vN7zdv+L50uECsVtzmF0QfUOLDcCOBsPWnk8brWuubwj41uAYxfXsQTDURL8LNERTcbqWqX8pcN06jmC2sSx9YQGNOz0jh4RRRomgGWMmDPBNAN0pSCkPULunGUnrzojxRSmZwCTy9JjlJcu62DZkzFFoBbcCXJzTRxAQMimB1rdR8EXS3QbA8OtckF4BevQgMAOWCzDSan2UddTQwXS9zHaVFMSAVQrgBrmM00ljBsRWFEx2XWjDpAcObUhJkgAP1nCJoABmLRi+n8umRlGQnpAHkPX7cTqYklabyCB9IQPDASAVhUzRCIGJ3E8CCyCJTAnOIzENYPWMriKoWR9jZpgKkDqScpzzzBCK/cu1I5LqYDyzym3wXzPSsGDI9N0iA5VMB+Y+moD0rId+3/hXF0TufAtMbla6k255gorVT7VZx+mW6+PmRzb/MlQ/V4ap5Nov+/LpsjJu8qu8bPVE5MZVOMLS/2iAR41CnDuISkrkGj69DedC4dEJ7E54F3O+nI8ggINkMSaVqG6wXFPzNjsg5o+1a7IRpYgUuJkDlR7imstzxKZiawsuO9086r2nC2fpr6XtBojhod9rPmGh92Dtudl/dcM4Pzqs+qvyeFQfYRptXO+wfGmaX1l9G5hjE/pjUshSwVq9dFb9VwrQghG59c3+apYeE9bworGJCRx8mec9GI9ZCVrkRZ9eH8mQRgo0MaTjovYzUyjEvuS+mWunajRp3XoDfGhsezaee7h1jpcBwFi8HSXHAtgUp7a673SP8rYYuKd2jbnmqp9cqd8//v6CfYW0I8drneM1eDUlNfA1+zSSJmH8OMHnPeaxukTfCc/Tr3Plv8vRvWiRpr95VZufGzeCcQgMu8Ni8n0ruCkCAOkSaB1pqbUQgAF9TqYgJ3PjJFKbmjLmsMIwrc4MbM6BU/SHCiNYd8Ab3AeGH7BhMOvMOBUBb4fAE7eIhqa6CKSwWHS4GYYJZJope5FiOoy9Ss2V5uAWUV4PMy6ELjeNgxv1GDtu1yu+ff2Gr5++4uuXz/j25Qu+fPmGby+vzCq17xjBiudjDHkx2OEuwRICZ46B19ePGPcvQH/G89MPsP5HHO0v2rsD/qHjPjruA2h24AcLRByMl0BHuOM4brC4wLaGp6cNt4Nchuf2CV9fd/TjzkJt3fChAf/4U8Nf3ja8XYGtN9jlgp9+vOB//PMHfPsS8EHF4um548PTD9j6jo/XO3583vBf/bsP+PjLFd+uO7x39MufcGkHPjwbnv74P8Hjgvv1X/Hp8y8YxxuOpwuFYmeWsbjcYNeOzTpab2ito20DfRto2Cb9Bxm0PzQ2jUGnzZH1XQ5ZHGi1YhaJckIwIKj2t0hBKDBEb0Z6Z5Rq1zrHXFXFI8D0sQaYHaQCWat6FU2FIoGANS+FxdGwY2CTd8zagBlI8QsK7wZRB8sTwvUQ4cX+8M7sQXQTRFnQWLiwYYA0JCpQnVmtJB0dqi0jelxoDdNb1+R+MGStjgaHu/HdxcPNvjUYmjn4BswwRRbY4ObYG+xgpw9wkyEE6qSCMfiFaa4dsBhwG0rHG0UxK7pNtKJsttpZfz8ejwZUXRlobq07Q9leY1pUAVC+5oa8KAVJM3WBs2hW3oZuge0CpokOeZ8aWJzP6aFLWtVsBlEIvVx8ThuB2IJZp8xYW8XoBmP+juD882lPx+mNsNyfxyNO///5qK08QfFUSRYY/+5hj2Ad3znn9Pd6jp53/krAcqXQ1D6uW9m8TVpfC1yuJz9iIZsfn/B2fmf6Jda3/zuPAmu/4brvnPquXQCo8D1ctJxYythyyvo69bG85rbQCfN9C1nqx0R9kkWYgdcn/IUFtP+tF32cH4knvzNU1ZaHSxef3Luurj/TPL9+UfwoTa88ZbnHiVKV+2azCrea9DrDcODwwAhS3wMB2ygzLMtYDKAd/BwQKx9iDXiUt6OZYQM/Gw4cybiXotBLSQHCkjrPZwzJqBb06gd4gXXFFOeWnxkNFL9ArMEMjwYoOt4Ug5kDBNKlgnihOHP+18Z6Hr9B0VgEdH0ylYCUAjX4y0Cd0srZ6YaYGwNqwoXcT6kc5KkNQHImi2MbOeEWQSvhkO7wkje2TkiJTOcEYuiAV0XhBOXoA9FIkejiVk9yefKkZHHSpA65ulhdgKtnROc9YwrTMagZtwABGhLCNDwDwDjgyms8NvoVLgnQTNtnzvzc4JqUFlMcBxo8WPitOyuajxAdx43WaGXCSfZ+jmwE8ztvClhkZw8cxw3frt/w9Qs9GZ+/fMGXz1/w7ds33K437MeBffC9Q5m8RikagdVckXrfMQ5EDPQRiHjCp48fcX2587z+hPux4X4NKmkjAOy4H4x3gDFLDw3QBJzjCPgR2C4bfn7a8C06Wmc64Kenjv58wcuVq877E+IY+Glr+BAdfQ+M28F4EgBhDccxcD+A3hr6ZYP1HzAw0J4bwjr6/gbHwPHDH7Ff/gHH/hH/+vkT3m5XHPsb9nHAe5MFoqPZhg2Om2hTzRqadTxjQ895FIGjMStXd9ZxSetmuPJWmMHMqx89N+sA3FlZu2v1TX+ZYXiCJ2ZVizCYN9aMEb3CjSbbDkAx5/IGZH0jnxxn69OFLqoXZRXd0VkQirQSUra2iALVnKs2Xbmg15kWY77TGADpH1wLm9bxEGIIEAhyt20q+k4vUFaB70YvIsHjVGxcYLCD/WFh2JxyYU1KUdQwKSBZsduCdLSRaYvYUhhEkbJWWaSyiB/VmoHoB+wArV9af0lVhQE+ju96U38/eNASF2g9KlMgd1QHavYvGMO4J2EDmPyec5+bJ88KeTupnEx5H2CCBbc2KU3BIo/osxDgOzpBXzahVHh2V4Y31sdpSZWFVe2VE6LXWsstKAuOrcSpx555/xFvkjTYZTsUuJqbMbd0q/OBuRYoe/IZKyJ9eOaKeHVOLAoFYr1ERoeUZ+U64HgxzvIBNGYLYralfDXLuj37b/LD9/c64ZN655UINE8o6lD9nU9/6IMVPCcta/nuDK7PCHxVMu2xbbE8XcCXsj/3V6nPNYZWd13VBwgvEGTJE5iFY2p8Jo2LfZKX6p5lAc9p/tihs61rKwAUNQ4LBSnys4cjlp+crrPzkklzanfOo8WutmoR1aWhvbTaZjpfmm661kzI0QFrjIbsjcmdug9Se5dJndRGdBoVrBB6SNnT3LSUTzQshnFfY8ZHQ6adL4CWwgyqSaXmcQ+2hKVsu2Sb9SAlrQPYNQIGZaoyZLarVNgVOMn7eCDGZAqZZ8Wpk5D61eM3ZJ2a4KeGKOVvnpSZHjTSFdtVrol4uKe+L3SrRhcPiqA07YLp/VsD+bIFJcOztWHIiPvkms3zcx5MQQYEhig+I5xpMbdejQwnfYRubwILmACLhGDmG2hQMKKsV6Sp5GKmhRXC2xzjrAcMQIqB+0A7DNE24BJMmzYC0Q5g0OpFbbaJ985J6QPoDm6UxtSeOWdgg+7FtnNyZmaeMH6X7xBMt0urqisUicOxjx2vb6/0Znz5ik+fP+OXT5/w7dsL7rcb9mPHcbgyBS1W6VQwUjiuXi5ZmYdTMRnxCccODD/QekfbDvTtgjHuQHtCawdsMxwjMMaBGAe8dWwgpQw+YG3DETdsreE6gPvtBYcrasEd+xF4/vABdjtgxxXPGLiMHf/4pz9g66o5gg7bAPvhGYZnjP0NZjtgHfFyxe6O/vSEny6BP//U8PGlwdsTDP8Hul/w+fMn3N9e4TioALxd0WFotpFC14I1ALYNzYwUrQ04tlb9Q/1JFCb129EC3ZnxOiLgzbAF68UzrR3nGfeXVgK5rFchJcMSvAMGV/V6rhv3VoK5uTNtrRRlh2IhkPxMuqMJwltFZDgYOO8mQRdWhSz5RMhFjAL8BnnicjVEuoiBHkP7BSlJW9MzJDvO+wq9GEUIsVCxP9B7oflJGhaTI6QYcqRXxpFpFIajPJUAFaMeUrgUQwXXOm+Brrk+wJiio2G6wenOgEGB46DhoMnDGdmfuhZhzDz1+/HdI6Csedr8ARU/lDWe+z7nUADITDA2+G8Fu6HNvIBbblK0ZyC0whyT/mZGsKGaqaWATMqM7huQTCUFglRbKhbNxONG8rlxAtKoPxew8bDBT6C1bMxxvj7xSgLShMsLLb9unYrMfJJAYCkbmPtwAcy1rfPZJzgSWCpCTyNkKjpFZ1ranrgiU7AnFXHeMl+WFxYM8XoZbT+JRVBg+sycyBsKDM5urBNskTenzJgLDskt7jRMBf6W/jvd+PRCagZ7qNWNpylwnrrSgM73yee9Y4sASgldUrNgYwJZiZ7Zzjw9PUzxoKjmO65ts5WOs7aJN48aZ+Koes5yXo3BhAw6TXSrbNcCRklF1KzVHlqsG3GkEuBrZs3253U492f1sz5oTo98R0O3jEk0ejG2GWNR3VfdEMs/USu5fcz6OTENg0gl2xuy6O0cV46jcduWm2S2PWsD5ZozdaQh6V8p6zA9gsu4EmLGZD1oYVqOWcN3Czw+Hr8tRmMRCjkZUtsNnbNq67NAlRp4uqGEcU6q7N1lIeYCofyZTrl5z2Vm2RQKM0ZjmeCLkrR4zqYQHo6hLC8ezA7TNTuyU6Mpyw1UK0PTJCsHu83BY3Xq+eyOpDcRhAwF5t1hBJ3awJJvO0R/GhhofnBT3Bt5/peBHqytkdl5LIAMQA/rcil7Fu0u4UiZqyDd5Ela5qtiQZgWVml3k+IUsgrc3u74+OUFHz99wedPn/D500d8+fwVb9craUzuzHIatOZyXqvflbLFc26kpdqshI1b0JODdEE+Af0CfzKMFohxhW1PCFxw+B0wEwmuASPw5x8b9qPh5cYUcdaf8O8/XPAvX1/wiz3B/A3PH54R7Udc9wtiF1C+bDDrMGz4j9fAnrtvALgGRtwRfsfT1vDzh5/w5w3452872rhhHB2fX3Z4Mzz5G+73V/zy+Rlvxw372BEIbHbg3g391tC3b7gwFh2tX7BZR+8d261j255gXbPcAl2BotyYC6lytCQ0HOR6E8RQwJoCjAnw+Rpu9OhsESyY54opaqLsIABzZZyi0mY+cCBKKbAsHAgnHa4JzGeGpZIRhsquBGXMCIC1L0T961brlktVmahSuQgqIcMdzRxd84QUpMARKgYdDSOa2gpabeJQP9CDsA0qZMKMD1t1qwxRMFqXI+OJtICiyQPY6OlMD415IFqnSqKy3iNYiNBhCHl0QoqCBamMralej1MIq/Yg0luSGwJGKpPnFv9+zKNqKcjOVYlFlh0wQVXNtZKJCWyjNlk7WfM4R2sBQMpg0X+TTBRaY/VEPl7IgTEhuTLSA0mXHTd9zWU2JWHsaZ3rbZc3F0QqYBso7rsA90oljofLzfKa+XHt34Xq9J8Tgp33TJyde3IlcCEgEDV5ufOC3Ktpi4X59JonlD7lWD4wJU0UWrQao/MbzTW1AuN5awG1xzacH3+60B6/K5aDPZy7nFjPPD8gaZ5z3B6fmzhG6EZK0683cung03nzOXa6dPkkEmHNtto6DvFACVyecVIMl65414WP7wrkpJ9Nf5DQ9Yz1jvG9B6yf5f0joQ+fbPmYB++SGc6dw9+TPZJfWa3j5X+FE8FF3EAjNHI+mfoWp2e0vMhrEaNSSdicyfX0UF8h5Vmut6gMiHwEZV+kxtIwB2iRXcivdH/uuw9z2AMRA6h7ai1a/v6396bf5NFYPWzABAPERBQqFfqZwvLkdlznljqkVNFl7uptUtimBlotSXliqRNOz0XTjSaX1BahZvUuj5M/EMDhNGVr8U9NuPFfBDIjTt1NgTrJCw9ZiY4Bcd4a3AnsXa4petGd1Ayj1tmtkcal50QL8f8ClyMwWqAdBz0cnWlHCXyi6ACzJgLHZlinNVpUFUNgeAp/AWxYVYiORjJHacHObD8wpra9Xw98+/bGeIxPn/HL54/49PkzXl/fcL8dOI4DqffKro7NFJORHR7p6Up7+OLmlubNegsch7EfePv6DW9fHPf7AdoSDU/maN3wBmbl6f2C3gxvvuG4veJ6d1gzbNbxcd/wwmLiaC3graM1BrWP2OF+x/XY8OEPf8I//PAT/svLJ4zjDgvH5UPHH390XF937Bg4fMPt2PGf3u6wS+CHZ0NrP6AHcHlq+KcfDR+envHlXz7h7eUVPmi99mHw3bHjjltveO0dvV/Qtlf01mBbx6U3XLZntK3jcnmi5T0GY39iY/rUltmIwKxloGV9eLDuhbwHISpPG6JGWZOCqTgFZfzaguHfrvnBudTmGpR8a5Cl1pJeBVlIKJgoa4ZGjQqGBWSxl1LSO5rsNB6mSug5HzN2h/cxMJbBoqE3xSpNyUMw2NJgqQxCLaWPuMclT10ektzFaCEakPJrKetpTOiDsmMq/qbkCwDjqNT/cKBHiowU1bw2DNQ9rBASZXWwGF800ctIAzsCCHN4bHJbB4MHrSFsnCkjvx+nIw1HuXda0LqYe48hitoRy3ZigLwcViA5ANhIgoOVdT2DXxMMGMqwy7mzXA9on7SkROQ12udM8l2WQzPysjfjPpFMhjOlRi8HINPuPnJprJBMvpzgVAGcBQw9TKeos4GCmgtO/h6UyODddzPz3ck2+x32jjY/181sPu+P2cnLU9Zz56NinrY+384flkckwWcsl59w60TNpzGNBcMI90ww+fDseYtTM/Lcd3rAQ7NPsGfpgTS1ru/P+wdOVCZ9Vida9t3aKpuYCzbfI+XZY3/Clvm3dAxQgDYe2pz/qr2R10w8Bjzg2+8dAYjNe8bLNj97/G9RoiJKJtT7nToPpRRH3ttSllSjz++0xA5lnSR6TmszqHtN4xG4p+ieuf6tySO7MIZyHqbHP6OCEZARa2m+My5jfkCjMffzWMZAnaa88Zb9A1NSFb7DKeNrekSEB1ZDiLbPv3n8/TEaaQaqeUtT6SyxzkZnVhyZEs/SQIJ+lXRmEMDOB51ndmhCT3Fms8MCBMzZgEABJtNKLRtrro3qJKonLS81ZmjyCNVVUnXZUDB05ztnXqlM3RkRaOHMKKXqy0wqGhUzsWlyNT15gCDCDHgy0k0GrIrA9AAtoN3BoG1ZW0dg+IHt2ICe2qs4vrIU56xryp5zaBu0YdosAWDy6T1E80CDj17BvCnjzQ0jGtx3vN5e8PnrJ3z5/BmfPn/Ex4+f8PXbC+6q8u0+lvHN4RSTL9MC5ygGCvydua45j/hJjB23nQoHBQ1B++vbFYcfGPchugIpOrvY+9EGlcSL4XY5MDAQcBzhaMeB7ekCXBqOV4f1jtYvGLbhK57w8pqW647WaC0Pd3g0PPcNP/z8B3z7+A3j2HH0htafEe2Op9bw9a0Bf3nB637FceyIYBYkuj4PhDN17vV6R+uv6FtDbx3tsuFyueDyfEe7P8F6EGBnhW9TdVFngHBS/6qGQAsgOov8ZbYVB6JrznkS+zKOI3e7LCanNRLBvst1oNihA/KeweSNqiXNwmNwek+cbTV0WZijNqzhh84JoDGY3JyLnx5ER2+bUjxHyYUNjXFF5Ufk511g3yG3OwDPKqiDSRq82ZxPUp7RouKW6PUY2E2KTLluOgLOte1tmaGO0WSF9F7jYc52eMoFNNZbCcqjpRoH3EmPOeSJjJHOMwNiSMFk76ZytyVn+vfj3VG+U+O4tDYVZLiUAm3CNbyFKrVHhIm+EOzrnGQDKCNIj0IOacHMhUDaVJTx0ILPdHC9wTot0TmTHFQgtav01tAbs8ihG2xPKsm0UtYGNjdLnFEuBXeCrpzzAcw4g+RIlfaB+hm2gs68dz53eU4a2uoh7wZkOQT21vsk4FufJwSae0LGo044EBNj1Plz56A4XN5pNn75e5477zFftc5cQOD5sPM7L16ftavqeXOKTUCM5ZelrYEJ4rJpM0JjeoNC1uzT5acmPmzAy/vY/OOEwda2ThiN07theW0rVP/QvzleiKI05XrJCVnjVfPBlnvPuf1uVlWzRIk04F0Nt+X1EMseF7YoGfq3XLo+K2KuX0NioLmeLGh0bt34ZUbGbwCzvHS+5wW1V2WIB+nBUR7YnL9LqC+SE5T7sSdWjYDF0PJVKema74bup+gPZOraEYY2WjkALAwsqSVcqP0pU+aHUrQXjTGAGHrRXsMMLEutssj9leM3FOybQzK1x+XBy6Qr4RAJCjR5Yjk/1fX8zLLxCQomx/a0QMo1BAn8+fFpsdecXS2b62ScHM/MfhRxEDTF0lCptjN/8IHApkBTE70Ixc9Oa24TbcTlcTIoS05D5WivgTRggyk/u56HqL93N1wA7Cqod8ETegi+jgaTOttaB1x5142aKffJwNbAoKBkAo5Uerwsyumr881g3nAwJQLcAvd94NvXN3z8/Al/+fgRnz5+wtdv3/B6vWIkZSpdF212XxhIYSpgqsxGOVEFlKd4CfGsCYAdjjhu8p4RKO7HHfvxSmt+awxSigGLhkMB4hEDaA0xOu63nxH4hOE7Wr/g6bIB48C+O0YA7oEPT46ny8C9f8N9f0EEq3V76/ADuI0gaO4d4w04jsDlmV6U53jFWwQ+/Pkf8OXTHd8+/wVfrt9wH7uCepmNwqJhuOMYB7DvsOsbtk5lpm0XPG0XXHtH3zouz8BmTxURXYqZ+q68XkEPVmZNqiEI6Ht+QMP6qLmRtMChGBwYFkCj5dsZ7NyileXdwrFnNqSyoCWFockqn4BAuafkqdswWHCxgVl2nMoQYy0ax5oOIGUo5/obql3humMCPSjDRzQVq1SwWpgzWM3oCapNStHY5Hdzs2bQrergiC3FdLhMkpAoNWsaRDB4eLNQEgl6FsMUnRJMd8h14+jWlGKYnrcs4unOuKysjg50xmFFAOakakVI4c20t78f3z0cKFMnoHnBlJEp+GnJ4zbeF2CdlkgDEwlkzHadE1pDjd4rHFIO5emC8dFJTVigG2plWD5LMEtrOZzGEzSDdWOmms1QVb+OVSritIEW9j6Zx2N2QcxGrAA298WVgPwdp8FkDSzHAwSdQCP/yL39hBJjtiG/XJSMVR+IeRvkzn/2OMTJyFHGg+V5Z9CoO5Wld75QOz/o3bXvXzB/t/ldJKzj51MtOLcmLcGnI//WQNrD59Wnp+ZEXZIKR32gdyFoXUhB6/1qcsZURt/N2IS/yKGr/9QYCtuR4cJnrR6dJKvV9S3nXCxNnu9S8HiZynpiNS3ne92zxm0ZpPW8h7GIZL8sbJRHzxqy1wxTiVgmfTJ0mHFRhG1XfBgMvRm2reOpNbRbwJ9QWaeYhn5SnSLnj3Oe2pbPWhc3dI0+toHROliUllkcaeQzxJb1NMgTCaPhrrXOvVVz31QglJjUEEbDWbKy2Q2uwqQh7EEaBcfeqz8TxI2Hefq94zfEaFCwrqIv4jxSloMl4Y3TxAlk1ZiaYkVvyJFMWo1NoZSgOab7B5aUKFtmEr88WU5ysq8CVC3NRcLJJqVG3HETgKFviQPVQ/Sn88xDtT74XcPaJrm6LNem+N2dvHHWt+BE7RG4ABiWWXQ4mXwA1hn3kBvUGAcB2vYEa7LEBoFVl6LjyeVPgIiuTUj5mMH2egazV5VoegyYGWgwXuVwvL684uPnT/j88SM+/vIXfP7yFde3N+z3HT4G7+3JleaCtG7YggHpaKIvLAOWWnYKgQjAwuu8kl1y1Ua6v467NHawUxqB9P1+B/YdMXaByA2vr1/Qby8wv9Xidj/whx9/wNsO+NsOQ6B54MO24eXNcT8OeDjs0tAuF1y2DwgHuh24bB/wHK/4HG9o7YJupASNO3D9yw1xvcH9wMv9FcMVaa1q6nBWU7djwOzA/Qa82gv61nDZLrhuFzxfLni6X7HfOi4fNrRGjr8rGNXUB0cA2wiYPFs2XEkV6LvuoDVDs5iKSqvwBlpfNVUdUCpWnuieZHdCkBlvo5kTAfMm4ZeRZzNIMakJDQMDTPWKgALnqETEkJKgNWUAPUeqek6+aRONhK6NbkPygUL1kIcHR5uBvgAFo0nRMNYTsajYT1SCA1lam5SAjHFyO5iKugVGZPwJpMDx7wjQ1azgCsZeMOOIhyvDHDCCRQC3mCJwGHFrBuczLsCrsGeHY3gHnPIgDLi8Q0G/H6dD0fns5gQ+JtDFI/EDUDGTSGQeoB5hXek7QaWyAjIzUf6OuY9RTKOL6UnlXxg6CCzy0lx4YTRIeQNw6dzAL1IyuqG4kd+1Gv+Voyz9E/haLD9zL8XEyNp+lntgQcn8JWWELZ/92nFytrz/dvmxnPhw/vew/bsvoT4ukD+/z7aeHIB2vhZ/7bu/0fzqwBNQ/tvHqWsfvjhtiw+Pqz9sXrA8/v3PJVY8gMXBkTfQ3IItykZ+E/O/+cy1zx9eYn4dD+Oe3rPzfFidaEsL8eu9GEi/RLXxb43X976z5eOiCr0fj/QmWD1ova8lZAUQNCL1rtoYM5nHxRyXCDIL9M+qI/SEZcwKQqdXoxrz0MIgYhqRykICQptul0gKKJk1jF80HO7YQUNdhNg0dVtR9iM9IoElL5GwNvssANbhSCUMQBx/Yzx0/P2Khmal56gbajDKSWXTTvJeMGUHRwmkdK+V/r1aC1Bjgxl8o8/VKakZxvrlskIMQDxMmLmtYOkgLbAgEPQgImOQv6oKt4A37iIGyKJLyo6hVUaa0RzdugY8at0fUOrNFiq2xsrF2fh9OLZOq6qZMvW4Vz9fogN9w+iqUusBhpRn/zccg5Y7lywJmobFAAhAVcWJecnh6w5064AdpQyRByjeewD3/Yq3ly/4+vlf8cvHj/j85Su+vb5i33fGZeQG5gJ1RstBQ8NgehXIAK4c87PXI4c9Joe5qiDnAtQKLEqc3oHZZwlTw+U16BsyKDL8wOGOcQBbN5ABZ9i949vN4Ycg66VpnR94/eY49jsy3sfvA9dxh8cuT8sT3sLhEdjuO+6XJ9zvN8bZfL3i09sd3oB9kKplZlXlk/3upDENLn0Y0F86LpcLtqdnXG7PeHq74Wl7wn65o9sTa2xIynkokiL7bVBZbI25+UcjhcnT2hrM4sT5zZnCNdCok3hwXipDmBuT6NJTYhV1werVhgaf2Ze0/tzpckUYmnd67Xzw3fgoeU4652cMmNErkLEZWaiuKTbhAFQrJN3GUbER3ljjoiUnGEEPRqTspeHAkfFQFKYJHnMjZXE+yorkmjZ5WV1FMXumuG2iPuo7D8Dc0DFO3lQ39gGTRjiYAS1jX6SwgMHdVgnCqIy4OLNhDZsB98aNgDVz8PvxK4d5oG30UnGM5K3uADaISljmrErYkemEa4NvAFT80UH5ecL7zbRj5mKGNveADdEVIA+Uo7wKtJ77xNYG2GZo0bBFQ3dKm2Zcxx0NhwpxPuKwAlwngBn6LOZeWrSe9gCa2KiSA3L3W1K0EvjAZpbHfKol2IqlUzCxQH5cA3NWG844NeVK1Klhk/6xWn/z2QnVlhbVnUuZmi9wfobN5+CxOzD3ovn5A9C09YK1PxZck32SX7caGV4p730pt0m7ifWc5Vk59gEamNKYIttO6D/2eP7Jsqr21YsvYCl/zO6RQXDpu/l6ABYP0wKMiVeSKGTpEl5uerrdcr9cROuInvvjrL3GeqvzjfOFHuhzSwtmXy23LBqY/k36oM1bn5SEHP+5Z5YXQlVjrUsOZBbH0L+61yx7UDJnGIv2dUxcnNNZ52RfwzJa0cRkAODCk2jI8IXMEBnqEwMZNVunrKq4kjAZh5NAEfK05KsrdhdG/Nk4AUgpe1z03z/+/hgNVQohp1qDqqGcYnx5Yi26xwWbgg6Y3o11upynkWReCaIUcuV6spV2s/D9l4m9iiZLIGI8KQBFVKAswGRShVqS1t2AucGbz/oDlRMwn+1iPsmC2hKQANPvKCuzBa23ULpcY2A4z2DKQ3omQEDSBlp0Bqp2x44NDQb3pGoF6Vfgfuhzt1Tf0Z3GecMFTmqKMZWrN2xocpnv0/oQgfvbDZ8/f8Knjx/x6eNnfKlUtkxJa9lnSKoOaSU2gOgNPhiYXRl48oLstxorCbbIVMaLQAey3llZJLiwG2ZjIUu5xicCmQf7cJAOBYP7jvvLDQ5gP7i6+9OGL287HIGRmaLQ8NMPhmPcAew43PBy+4K3V0fYALDhNja0seO237FbYHdWC3W1M+dyBqxC9Jt9yJW7H3i7XXF5ecLlifSp2/MTfrg/Yxwdl/6MJkAabXrIzBoON3laMnzakITJUFHGnEcGYEcoJodroEdUIbhDCy0pY+H8fdNmEa3DPbLutrxgHLPWlMnJWVGb/jCtxvDpRTF6RtKDUDQ/hGpjoDxiTe9ygEqrp0IpQWiecsQzrg1N9CtaablujwjANhjAhAqRVlzDARWhLAcOFWUqvRTAzGIFbGpBcvwDxngfZDppfj6arFsq4kfOIlMxm+Rh0xrJejgjBZOx+OHwwGFcow1UBI/xO3Xq146s1FuUaZjSLpr6GdrwK0pJmyePhRWNzLBnCQQAylCYij7WR7pVLPIKsg5CdBlS31qmQo/QfiDF2cC6LvqfWUezrrS3tuxmwN/ez7VfFXDKBkVxwPNetWstn8W7+yczIZZPUFt6dk3hOnnnJk1JPbsAtWIqlFiMU6NaAyrBzAIqgcQZC1bzpQ2nVj+CyKi00qdOTLyYP5a+yGMF8BO1CERn261Oeei98+f5Nrb8Rbloc6gwY+Ui98Olq2bDzs85PbveXd/I0hmZ4AO59VoB2jIY5xaS9wmtiYf3svXcd++fbzivsuz2VJSWG054aHgcgXdOvcR9mO20h54nVTFOU4unJy4kg6NanPOgv+/ik7JxfsjEn9kJrQGtI6wT51xsebfz6MtGvWAsYhYWd26nc03Gadg0rtccqjVIQ1lpjCn3BNV9MTB2yPidKdlrvYFhlsb9tSqcZ+uNFG1ixXk+58Lf3pv+/hiNHCCbrqzMe5wTrzquOuPkjFsWq/pJgDxnawQEu6Ok4BT60MSfgTRrp+dHJaTmankvQKolVkIksue0wViWdgeFgas6bLTpQyClpAvoEyBBm0xyfVOjbDYEhJrAjTFLjjR/axTsTJFrQAxJIlo0Dwe2A7ALEOG4eKAdAVwGAk0LaFIGqGywEV1u/lE9MTRojBuQPoJduwQ3vQbEgWO/4+3LN3z55RM+/qKifPcbjv1QrIXqi4CxDsi+dLoXQy6wEtrpcktLlibPOn5pGZy7+hzFJhqd2+RbZmA756DP2RYaqZw7EbgfB/oY0vZ11wHcbzvMv+K+74w3geF+OPCyE2CTB4M97nrWgTGAwFdEHHAfk+6H1WKYU0rm9zbTnQ4LtAPY7w2vb1dslwsu7QOePzzjw9MTnm/PsG1UNdGi7alqfXdgdCybUweC5b4809SaVZC+96TWqXp2JMWAc6BbIJRxKdfcAOcPVOW6K2bAwmm5NdBrlZuaOXwE0Jidil4YAQWjotPQte5DCn2TdYV9lKA9i3Ym+G/myO0yRqOnDFY668g7GFRJXOvXBpXywSKaYTnHuU7hiv6IQMsK510xGmECrLWDS3I4EIq7kAXrEoOJIwyk8QTzHLpS53rruMgL5xboGs8WJo8LYHBsCswbkZvOowT7/ViPigG0xTO+uvqNSiNnYRa6nMC1ujdQtAF6WheUkdQpbcSB3NRRFtx3oMwCHTO5Bj90yky5PFoDWmOhPusd1jpMMUO5v03Z+AjGYjlh7q0Ti+UN4h1gsuW/eS9uxUtj0wuw3lSfPALGuYtanfPu93j4xpZLc3mlYeP0JijUmdbZczzEcqMEo49dtWKD9cPcYt4tsZht0vPnszTeec/1PU7NWV9seUBqZysVY2lv1Cm2zJ1pyo2Hxs55/J0O1f5X1Jc8Wn5ry6nrfHh4wOOftkD8mqdqYSnoK+7DMl3zmbm2gPmiCSjXR699N/vi3N/rfFuXij2eWO85TdQ2O73Os7T96HOt9+yjpI3k85oBvcPaBa33Wr/vO3HZX/V3Ej7jVNQz+0UGC8zPQ7KAdaJieU4qNzG9ZwBysHNtwU0x61Z9NNdkXpsDsMxfKfdW12Tb/vb+9PcrGja5n+k+Kn5ZPMzFBBEnQbOs85yPAGkFOSH03ukShDwYq3crWXu1+UYy6+ZntnTdSQ6oA0/eNZ0QgCpYD2TQZ6BxULTxs0KjAQqy7U4gkpbQXNCAKhEH2P5YBBNc9Ir5+aa2hxuYE5Mg+GIqwOaNoMlJ2Tk8sClIuyVNIAzeRnlSYggMWlP2LKV3QwCeLj0A4djAbDlJzWMqVGbb+nZ9w18+f8S//PIRHz99wvXtFcd+YCRVSe/dBSZzLnCdBCyUDlUc6gZDpsdLq4gMvJg5RxY3pTbK2juW9RpBC3fLZ+uZLdIKvljgI6bXUxybVCJbB9wPvF3zHjyGO+63e8WIAMBxvIFW/IDHASTVSDExTa7LWVQyNwvL7gbgGosuD8rA7X7H7e2G6/Mrrm/PePvhAz7cDjw/Dzx3WjwRgYxvbcEYBdOiIsBWgUYorkCu02GMleGkVIcJNbkxnsE0Vzfwvs0BZOrVzrHo1f8Mvk4+XFdWCgeVS4Q8akFgp9qRpShJenBNdY5Fc2N2qUari4eUiJSswcfRbRsM0IZVXZva/LiQ5ehlAPrhhmE5qzSB5DGYE4sWmwAU65JGh03zM6UKaU+ZAtrkBXUEtqChJAPbuT4JKJ9y6UlAdbeKXRkBZrcKY70MN3h0yqCWa/xvC/N/qwcNJZUqAEVXGFzflQkR/J3FHHWxAZmZCjG9HClsyhBiYJxcWj5jbvLWtCuVoSfKy1xgSwaSnCucPiGAMpUMZjujEp3MnJOFNre9evuVs38GNxRBcfosv3hgo5yAXcGwwFIobh5VgE1PT9BXuC6xSf53AbBFg877ru1d+j7fae7l8/OCUAUvEpPMLaP6KbeQPLeMr8IbuU/nNUuMw3KmrMk29x/dfNmO8Nil61/Ta/8I/85jOZGS1X63OMbnverClVOyMDokN0+6w0pnWqiYnCM5J6weWvNg6a8zK82q49hHC85bf6bcW+da4SPMAdXzE0fM8V3buk6x9Qs7PS9O5z38XN4hgflEjMtcWCdkToKcim7EhrmWjAa83pmmfnOgdY1OCLdKaVi7IhtCxkldNOepKL8d3CeGejvT3AJRxXfLABL83ZKev8RkCH4ghihQsRjyGyqOM/LkxVOZBsOelcYJHSrQ/K8dvyG9bWSXn1dLALEAHqQHIsWD5q3ig09KIxtuD5P3vVxcaXqUKcs1i1CaF+hWJdglP043Ngb8ahWnQuDi30eM6smAw4NaalM/eJD2wHaQ7mDicbM5SRMBBpTyTEqTN1aSTMekS4HJCsiZRpScePad+8AYjQpGNBzu6EO0rz4wWtIGABtcwR6kRTWL6QkA4xRakwXOkyPJzXoT6AtrOCLw9XrF5y+kTX17ecHtvmMcXlbmdOllP8+FxX4xnyzMpLmVDAkuIl8Ei639pz6ihTsJbjknRFfweQ41bqtJyrYsW3tkSmIQVBjBb3pi5qack0rfBaAQfb7bMv9n1pecKxAIgbxFBIqZFjnKEq5kxx7wMTDGjtv9hvv9iv32hvvbE94+/IDn/Ympb1swZbE1mB16LmsxuLxvLRy+MfuRe1Z2Dxa6k4chmpdSQQw0NCamjEcg+MmNWgFh4RnnE/IiUMmcmyXHYIMBxjBwBmewb6wd9IxIsA0EujV4ZH2amF6mABCOvZEWhjCmLRYYv8A07vI2aP70Zhgx50KiSTPSYfh5U5B3AB5onWuvJeVFfu2AAQPo6UWtquKRcXdoLTCcs97GVFLC2afd6fXpF9bSMQQ2BI40EoCWax+QJ9Ph6QJvg+tYHkH/NWvj74cKrJKi5JojlOkJjrKui2SB0YvGQTRkBp8ObVTSP1tasRu9pEUnCEOI55qBlek59ZhgkdSUVvNi2PSoMIkAqRbYOlrvaK0zDfiWu/g65vHu14CUqFgjUCYIJ1B9mDeJXgupP0CxFMwr+DYgQfb5bo8nPf6WH6woO/duPXs5Ld+J7VgwRDYszw0B63cYYMoCAPWcmBsSTm+wKkArwrSlHSEPqcb3rKBJGRComdW8Ts1Yejjbt7Yhzr8vYCbNa6d3VftqnxOInWO+3vv8uucPH/1fsx2VCjnboxeqpDmGSsVf6yzvuMyVAn/Qj7LMo/qg/l41/3xmTbj52emVyuO2KhlRz0wr+Kqo5sAEct3keVgnb+0Z82kNM97JZA825UsRtjEakC5u2MD417LtmvYyvQtrJWXuQ3o50bgzIgwmbzY69+/NOb8q5sJYzDccDGiUlwIW9X2kMST/af6OJrl0kILc9BwYMGTsDoTqXKEMHsyxYmjdmbjCUEbjv3X83YqGV+CHzbVQMiFkwa2lJKCl3y0D8Ky4h5W6NuKhmez65Gvno0KglE3ICRAF3vsibLJrmyZqtgnIuZufm+7HiTfcBSy1SbhMseggFzyUqjWt8dREXYuNWaQcHT1JINUnqV2Sf8vYAhGOGHgaTaBJCoboGiMUINsPPFlDxIYOUi38oAY8rUQ2O1zacdbIIA2Mvq/EYKGK4EAC1VkXxTFwHztevnzGx18+4tOXz7je7xjKFvSY1sNTOC5r2iTg3ZJ9GgXUOZ4VRgKYKlvmHVPQ1BOixjdtyOl6Pm2zqVDpWm4SmT1GYy+td7rYM37FNG70WORcjWayXlByTMqg6D6WSo1pE4jF46i5tPQPs0QFBpxKwgjYMNz3O95er/jw9IYPP3zAj/cbxr7rVQmETCiI01OgilIf3gHW7QjAG1ypZqnbxCwgaT7jIODoznl5KLitlzeSKiTrJ4bAsTaXRsXEPZHWDnhDZV2LTuuIDWzA5LBL2R1maO5iuWSlbY5JB9dVk0ckRAOLRk/hRXU4CFqSmgX4oAfAvanAXmjTNIJFH2jYKNODiptLgDNWQjLFjevTAntz2HC06HBzDHCNjFkCWng1qg4Da5MAvaUs9pJJSTRkrIeobDB0Z1HOizUZ4xUwHqBXcuD349eOCCWiaGhZULU3pFs5ZzIDXaeFzkT9O2HxtNYoeQQ3jJR3bRrNOrgX9AbbeV5zVOICA4Cm+h4OYKBqG/E5DsNAR0fDxtiM3rBtDc+tIbphv0tWrDgZOG9o9QHmh1rzOH96Ouzdd+8/ifr8r5AjTtrHtEYX6yyBtAWgzIfcLwuTzlfKRaIPEpetj3qElo8Q58Quy98jvQMPb1F7//mN1+cBUCwV5n6Rt18x8Xpt4rrv4a939LflogJWjz/TlJ59Oe9VCrS974vvPZ+GXau/srH2cPVJ/3n87LuTweZ3ObArgHu8GR46c+2wdb9cL/vOJTnHVmXj3TnZhbq11YKSSXxO1tPFOf9CVHIzJV1pQNvY9x1A78AmDNqeDP3ZKkM1MEVI2jbQADs6lH4UNPYpfVMWj4p6eGUcBUL1rQIr1AtQHrVMUJTKRkh+FFNkeqeK0bIoJtlBWVMIm7wlLaQHplHGUIHwj+P7K8ff79EAKvY2Jyg3QWm6jycjNcL52ePEzz9d9ysQA1RHeSRYfJhMJzE4hcCJLFXgxornZpZGwuTzUkgkGPRgbYlhKpwX2aplxmpnyrSctrQngikpM5tOppslxLPyzhxBC+wGAUVAQA5K7amNLAJ9OKxtGEHFs7nDt4PZb7zDWyvA1UHFxI3/eoBcvkbw42F4AsE3DaZNVlrunt4cGA0xDtxer/j8yy/4yy8f8e3lin3fZT1kR9qimNSYBFWCpHp4ejHCyIVPvvu6weseA0DyrDMQsQSN5hpMYDW0gM1RVIlSQJZFuGxeEcy0xWB9LZqYm57r3knDqFh/CEz6aXadFApugtUoCSlZQgOyY7YqkBjmrKsSBkRHDIcfB273K17fnvDh7Qdcr1fc9gMffAe2J4Soci5lv6lWxAED5G3bgoLwsCyi1xAHAVDXnASsMjNR71J/Kq1mK5BrCDc8RWIlR3jGdxiCZeOpOLODMNAI4MACfazlwhS3hkCX5y0VRlOfpeVns8AOA6yxlkFlw2AgWoN+Shg25zrBEN3RlCmqk7Zn1d7cpJUjPFgAkWPaSDvM1WxSKiVUQv0dmoNDiifVMGUAUfXyLiEzBu/fGz2nR2Tl55jrTvSskOPHzWDJeqs9umGPtIb9fnzvsKYxTHqcZ9FEz+E871HyYGU2QRpAll2zU/6GvGaIZZ+BvMRNQOKICfga0AYVmMIuvQyDMrZFGcz6xdA27QvN0FvH1jc8bR17WBme0rJdtJjHjX3BoGl1P2EtS0OhcE1+XzeyM7LMe9Zt4+QZKa53Wqu/0xyo5dkYWxq1yvQcn3mTfNdH6JsiXidbyo98Vu7lJiqHbuize9IrUW1ckeki2GutAzRU6L5rCm9xRlK4Yx2f930hOfLwdazn5PMe+pBZkKweOW+hdkV6mPOe/1/2/m1LkiNXEgUFUDOPyAur+6wz8///No9zerr37iqSmeGmwDyIAKrmmawqrtVvm16VjAh3czO9QAHBPfszAaJ+9r4v7X3QyLdIqn5GgDIPBjW8Q4n4dUFdX+u37eUPLKufVxufC5Ctw9nbAaDH7a83ua3lRlv97HqYCTxzAQuL9G5Z7lt/e3Bvt0KeqkmzG8N4S+EYPuDHgXE+cBwPFu15w61TNx0tpD8/6tlqC5DVOE9RLSKEBGmr6IIFPG8+it5fg3L9hDHDAggh61z41bX+c6PvoncFL0CtomS4TpQOxA99A9ySvfHDTv/w+vfL22pQzHsrCzVQ1oLmAdt+2e37i/nWxIphQPfphnc7g+qN2mwYuXf0LgBQ9lfr8d5YVYHb3K9oLAEgCETlNocs2olkzwCXm1odttMTVvbIrDAIlYTVWlFguZQxPcOgOdIVd4EJqdOpFZuIwhV4V4qLlxA1JpZj0ovwMRi/N5JW+ALkVIKmtHAgZT0eOWjtd2Dm2OL3uGIxJzwYm/+P337D//zP/8D//vv/xsfHd8QVkHEb1aO53IsVirPO6R4Sl6zEJPXbbaOZKoXXknIpJ4vBZnPZyECXUWnxwS8SHPI2pbwyN0WWeUDJyBT6pWxUWB+t6rxF9AHeLOYl40DeWID7dki0ZzyXUkUd8rBYVyiKVOiWxhHTcTlzNX7//g2/f/+Ob98/8O3jOz5dHzjfHhoN9/tKMMwiA5aKxbSE+eimfZS3BrOB06JXqiLZa+dDHrYR3LOn1sGVwP5hCvxSjVVOs0LPFGqo0KZiZOlBQDKLqfKzCkshIzVZZxxP5w6dYCWeCah4c8h7KEVF65k5eV0ansHiTmXdK8UzIhFD3eqD360kOUOFQFnzUNff1wYmSKsORCjmnp6ca7MAkQcYYMHyw2nAGFQAtTYsfpbil4bTDKEGjlWcwbJAkvf6V2+OBnd/vX58dcc8hhZWMylD3BWM8oSXyIkEongzD22KJ2Rd3xaszR6Y6EplzXv0k6S6GaBiu6atHnymp2EchnECx3CM4RhO76INWp7NBYrE8qQWaUIVilqysqINavwCGFljLQTXKsuGzJpZ12Ldl3hZ8lDlw+uZfXmTaIHFPeRn4dBeG4AgsP9QGOIL6v/Rk1C8fV2zs7TbTH5MhODzNyyyHmXbjbZVqLnUzbe1qPtbzaXua/cVrPCqnx7jtVk/bEPv2b7Mt7nIINdDt7bQW1+xsJS97q/WckmH+71LGVhDsLXVVh5cnpOKQrgribW4eZtH/+0v1zXKu6uRuK3nthh1pHOnq30E62zsSuq6ofZ7s+pbLcvaBnnidZbolmPpbPEcywHDgbQHYoy7B7oWK41NZWEqXR3bc8vQzqIkHTquMz/9Hh5Xsl1gBpjCPFnhlNzrioJOeWfDK1fX1uSgOVnilpdR26R7WVYUjhbbk4bjHyjnx9ef6Ayei5k0wdRojO4VABUfWwzJNk5Tnug++zvxS3OvmHfSoK0DutOhLbaea85lW1y0VNfzDh3es91I49TnQkCZYLiI81tQ8kt5GWqKULfnul9VeUoFcZdV3pOZNAGCvkObGhkYUq5mMt7+QKrKjUCom7oDB2ZOzGmwcapiTTL8JIA8ivgUQgNnBRyAJUJRpWUpgD1cgJdTGU7h9FSoyvP6wH/85//C//hf/4Fff/0NHxdLvvJcrIPQwrg03BJh2/qnCByy4Gd5X6Txt/VFa9/fzyK3pYBWLH9RAGuvS+3NEsQVwkCFIqtZVj0lmQi1aI/DD6w8E+sYCaj5ndZ2EQxuXbGtrCQLcEPguUktSQOZodCjwTj8ZIWjsAvmjufHhW/fv+P353c8v39HfJ+I92gwXSD/glHB7DU3dSAHfBiY2s2FDjPNhx1DLQ2XrLoJoMoAR0gJBmBDCTZqJgdbJfYiVVHMlXyucCP+j8oHotgS9yBz8+pBYZTmMDtAhSLwlKAatZOujYHhkYbL2ECwuAiVj6ITAyDlOQM+qMR4gmVuOVFEGtfAhs7qFC+RIh+xgIJcqm6Mq6efKFVeF6008shrTEkPziimnYZxqDBBmIwjNEqkuq5HoMv0Mv8l+ruwf6/76n/VV+1dRSQDPKID6N4qZRmsF8l1AxaSBcEbLjimA0LRQKbGRroq75wqIylJanY3sNgsYV/CPRtbFEY4hve/MRx2sAoVw/d841FVLgM9bpF08zJhvVqYmtldXG88tj/LHyMQNtF5A14Skz/gtZtnyKgoFeRtTLgboGzdaz2qvpH9Wa192aNS9y9sUNBkx5abJOr71zU/wKJSLvf1egGavQ6ip6aPelYpd9saNRnY9rfdbvcC9vCCsayAEHXp2L5n67tKKxJMrRnUetcv23iwfunxb/e76+ML4O5jtm1euQFT0t8KxbpFsZTcFMHWfVtvNSzlsUKd9tXa6UXj3g0w5RWw/Tvg2WvHkPl+uzWx23sv7zemKMrkelXD47QBGwdsnMA4EHBcU+HvfTd5RAD2NkOuifsW3ola05or6TJK8Io4DWDbAyz49bpPZdAFSk4JxBYf6n1YB6vWqfZXordL8vZZU47O/sx/9voTHg2dsn0lbDvOffKUqFWj1o+KkafrNlGekGb1PznYO3M3SGvX/etg3UoQbouV25jK5crnrf/2uGuTArRwaedGsJynWVlaaDWmi8kVe82k8Yki8mL2s+Ory+I0aj/NUJ30ooNqOJA5Ukw6pJQNCkww72BOxYx74gomEQ0A7wgEDmndBjMHvBigEpC3YC9CGa1DMlTM0jF8YCLx7ft3/O//+f/Df/6v/8Dv3z8wY+U9tDhv4YJW4jhFAqQbY81srwcZRYpxS1lsKSD6kUCubSnuW06Lpu1ULkXS8l11novtz23tUl4nAN2ZeQVls/RpdXSOrMZ0toRn8mhFhXchq0kwdz+zhd8uJNlzQqJztwRGqFwyS9JmAnMGPlSB6vvvH/j4/oHfPy48IgmctYM5uYsDoEA3KV3JikfFeRKpvg5OsG8MH+OaT4FyZ+gW0FYpmCPywACVpkiTtbi6c9vyAhlwyfqf5bUzWuenPDfjMsxKwjaVALBl2SHPTeWTLBGBENZ3djclQGNOU9hkeGDo1BUQsxRj5cnx1ClrS44a4JVHysHO3QbkrJgajR9UIgYUs48qe00B4cmGfvQcisaLVgwwGRgQ7C1CRh24LHEY80SmjBKRBprCskNcPKCze4M8f732V4Mpq19Q3NhkFaqcRdtAUMUKNLgxW+uc6GouMLQAK0HMr2Ybd4qvWUEGAwB5GyHQ/eKhNRkMzA0+FP89DF5eDauk8NR9KDsIypYMxealr+HeLOvLvamprfCLXou2DNUaFOrUfwpl9FU/EdhawwbJ2H72yHy9vX9UY7D97YoqKGPKAkR3V8nLIOrPzYNU//rehvZGL5Cda/1qRQvblfzZJ3yLZdrudX9rDUtyb8mu++f93Jpi0Szw44U9hxoXpQiEkdqDtcllu80EjVUKuG6DLFHc873JaN2xV6S8Gbj5ol5oZqe4yp1b4LjCue7obB3r2523/erTLHnX3hsrCaI71nrYdhYas67V2Z66fm9S14qVUdwMMBZx8HFgHAcbBqtbRWHU24Y7ZffONKxSElrxwMIdSW9mltKS3sYMVr4UINpdaMIpNdQeN0jzrAaK5Y2zmp0GkoP8RjyKbSh0z+IrolNM/Fve9j8VOrWpWT247A9RI8C+bUUkK9OhLPv1xWW5qL0opbNuRsNgqy/biLIXuHKTt7VuS3cfmKKvZvjFOqoRWoLIRp8lEwyhZjfU8HifwwADPR1efjvw3rlthil+bbjBIhDOBFDAlMXfLAr1kNTvozRO02EOIDzZ62BcBFWXw5wlbA8zTJtI9Skg6ShWp0Bd0kMStUgipFYUJvMIfv32Df/zP/4Df//1V1zPC6UoLPZgHZ7TFoxm1j9IkN4T5ijwkPZBRIqRLQa3eHj9lwczm/llM8jdK+HmrBAUpdSoXpQV9SwKarGrQ1XW9uItqVwXWHa89qoyVWB2UTsPMFXONU7OsAAwh0rXRCIJrAXKWTVn4rouXB8fuD6+4/m82EBwBuI4FKwni7rx8NPKzmceWaWYA95lhBOZE9V5dyYQ6sCdMAwYzA7MZII6gdRsN2+kMfm1Fa6gq9gDkILiyW7WmROXer/kVIPAIYtzknm6s2rZgPMeAIE2gI6vAsOiAGMJ7AaEYn5gs0jvOHaoeSUVK1ZyS8apWvY1lUNBVYejyGC4WPUJMvG3CMAsYBjcu8E8Ck8Vhijxl4Z01gRJA+AOm1XxrTLCVdVrRHthLzBfx8G85RhMKD5STTQ1Rph6mfz1+vkrUVXBGxg6mcHCElIayqyQQNkXhFM32RLleUWJNIa+KczKjvXctKQrqgWVI7fn8oyLjou/FbAyhh6kyzI6HO6O0+jZcHk0iiFa0tO33JCbTOMU0GKsXy9I1bbrcKep4uzELTwjt2tKeW45T2a98+m2HKP4+WZVhS3lrVfc1vgrIqBhkfZS15UMblkrAbQMX3d5U/vca7NPd7FmooRctFOi+AYmbBmccptnbmv9s2UGftyPxiJYz7nZS0WX/TUBut6g/pWzE2taXoH62svWrxHYRhbLIGgUYnztz69FqYXc/q55NhfOArb7cDfVQRM1LeJNV6srta5lyNsnskdMZNy/X3u99s5uY1wOBoWb9fxNuZJ1OBcRL4Wt7qPr4RgAHnA8fODhBw4/MMYJP0bnc1Seh2k+IWuTTZ5/Rk8Y+UuyvHmsCXBeQ0OTVdNi7UF7HUbR2RYVApCvYBlc6ImI9qKUwTSFfUM5ncjioTVOkYWrh1lufPb/pKJR4Bmy5m7cYxG/5rIcH/2lvhQAqkoC7ysXTjEHuVt/OIjSIBkSs1SOesY6FHWvFSq1h9bwSxIi22Ehcaeq0NBVNQF4JIYnrJp3ZQI+NuYlzTXVERgpsDR6/PToGFSgH6kKVKWVGlaSblU3sLAunVbdt1cNzoPjNWMFIVMykbeGhMzqLiWrWQaTWG0ikl6LShyHAQehGxIX0i784x//G//rP/83vv3+gZzLrUzDntY/1i7UGsa2nquVn5hO+/iyD3W0oNiynmSZ7qZashJnLuUhSsv2gYppJAPLFW2DzZXfVJLNyIppRq7YYFoKnYnGRZ9Fx7boqRS1apRYNLXCB3S/LHpbh6Qs41U9LSKFlQSSPfH9mvj+/Tu+f3xgXh+w+QGbJ+ZYVD8AFgTgoQKMeVtHGDwHZVMGnvJkse+EmLRzjB4UoDM5bpbdJl1xzifSJqodaCVPV0haWuDAQBrDmkLPZBU2gqgpj+2AS5cPKugJhbzw2fScsEv5ABUvGgGA6iA+jUwrU73VZsIr8cU5vqVbUwliq0zeP4P8I0xrkSGvART+Uh6jbIOHm7qZZ3k7ee4RDJHKwaT83CtRAar6Jeq2ZO+cBra8eSjGrsprT9FVhBN4giVbVyzzX68fXhUGmVTAqyM32QzRV+VUOFY0Xk6DTRmKPLqJpaFCLcTfQrzLEzZZwhKlIJRBoxKjREw89vTawZOd4iMbpED5cQkpJj4AP2D+huP4huEny0helyZp2383YL4j5p9c06B9B8QlkiWHb+AsCzK+3Ld42g1TbHyx0c0rQCsgS35f4ynAVmu1JlUD3Pn2Pivra03ez7vXZMHOjmwQf75D0l6gvraB6W3B7sqWoiE19TWDOx7enpPrvgunaEbbEmf9XSFDVjMqPJT9gPvq8O8BvLyz/6zfbS1VrX9uCK2W6Ye7r+8XBixFoD7qrxV4ExaADD/cgwp3Nexj20dZU+W6Z3tpovbP6jOon+pawN0w8AoiCz9uSHPR/mZ4vntFt9lb8QTxEaex+RzA6YbHYTjfHONNFUS11kMGOnsmQlXuOnoreV/fLCRpKpaHipxJrB48BsPKAy5PAqN7hTdCPd0o5IWDvL222WvIha59Y4SOqek0K4sOU/GhpMiO8vQnlTYrA8iNXn7++hMN+8hQuptB7XSxpBsBol3FuR2QZn0yBVgPdjGwPnB1ta0D2fdqAqima9kb219Ew18t9gJ71bK9WVxZmvpb2YQbTm5mYRgCZyp6z2slzCpRfiTA5KDiFGzONhNqeEYlhaUsDV0SdWMgxCEM7xgQISZBi4XhmQlMdiJOd+Tk/ZCBmdWpnLOf5qwWpDAPS8bqOWuWLgUyuScThnk98Y//+A/8+vd/4Ho+V26LhFPJgbwvNgGjPDplXamwGIQt7R5VTX5jOr0VJbhe1qMVFCowFZ61nq2xQSFeWU7TxRQ74U17745WYpY1BqgSbjNSZZM3RoRuHiy6zCV8Rfzr4LnoiMRUPRjKis+Qiqylp8cq6Q69romPb0wG//79iee88C4LPRPwmGPz1GaMdFazSub2lCI34TgzMR2r+tJ0DFlKo9ea4xjGBntZ8UtBID6LRllZAOxjYrA4mnEN0GjQTYycfSgsVulYGCuPdSnjZE5LWDK5bopwau0raB6KiQWVqWHLEuTtsWHSnCctLWZUWhAVQqf7ORX9SqSfBQZBb9iMYNUtyEgR9GQEiQ9TFbFGeoeOueyuM9DJFgQk+p0L1PQ8kg0KnzoLkcla6eIxxKEhL9K4WU7/et1f5aUwocCokuTl5UBCTTBWPHt9CVBI6KSHywjZUrTVeKXZVGBWoQ5gAZ9YhoWsL1Zte3BwJT5SZxcJHMkCt8MHhj9w6N8YBw6/cLnDfYV+LV63LcANT9r2mTj0hi3+JSbQM/Z48f32P/v7X79etOSaQ8l/PXgv6vQ6qMICwIYPrOTH+rvy5upGpdBsNtk/GPnCFrXAS3/RrOvvzu+rtRW2yNf7/dEm/XSKP/y51mjN+XZtvlxs29+bJ6k86DWXquz4z57/+mFdv4cR3waQ+9U1nP0aLJS+v/Zxb+es4OL21oY3tLf2Mgt7/X0ntJ/McRt+pUBUmFFW5Rdfw24+U7eSomMHizoccIw54DbAiodAXtGk0HJ5An5BbiioR9LCqilMkYGVNKZoBAtQ2TBVKoTGnFDc+JQX/uDaReVQ8j5+pDSHhXcgScff+FCDYJiZmvgVEyFYqf/94JL6g9e/HzqVK0xqNziU+5ADu5+Asv6lmH1/P0GXsK6skAxDWczXnHpuNQ7L1uhuhx8CblnBUDtlkTjrE+iv2nfuUqVRaQEDDSa6nhmlBDCoBLg8KwQtGmMYDhtwOGPSsRSXol2Gq8j6bzSCjbHOBgEGGUSoXwF8NcZjkiOB84zAEYHJQD6FsXC1ytiT5t3UCjBaXwVyy1ofSoz06fh4PvH3//w7fvv1d8wIrVrbbfizFb4iOL7nJQVNIK0tXGLwWWoGRLAcpNn2d8qOXUrARsj0TJWwsGZ4DIWBxsYxR38pV5hWFq/j4YzI9kRYLsHFAkE1Hs2+hLhAbtWD5xx2ml9WCBQt9oVabyiUTavqTtqODDZjjCe+P7/j+7dveD4/kB8X8DnY1EugCZ7sLZ5bYr9APkslR9MMwayhrUpZeTUSImJk1T0+wxDuyl3QOXbAam2LBHQe6wQ5WGaUpWZJH2yiNjCM4UUWagiEqhDEczwDqCpumYYnUi7eZNPLAI4MPC1VZtCQwxSqBWCyylB5AqPOpTFcbyQZ5iWF1HM1KbQEYjKUZQA42HkP6cuIAGMFt5nAjAkz7wqXVGYUbqLmfVARByooB0K9U9youJXbe0LelgR3TApaGtjozxzXv8HM/6u+6AkM8VlS/QRLIQxe0DJrig8fLsXTIK/DoAKQzsOokEaKDsoDAot1jIt3eYcSLItplhKPCrdzgRYqQnMC5mzUd/jAYQOHKyH8dIzjgB8O/5Dns0IEVRXgFkkn+VvW6PR1wU8wXMvSG3aoi5BY3dTXdfXNmx6zf15yvZ+6fX8Hti3YbX0XWB4Qq/GsQXE9K0yxDAA/7kWtO7IkOVAFKSiytgsXdMbra+OKKHiQRhm8hMrr2u2GzHWf5b/ZvrPdoJ/+OoxtPRcWovDK20WomfbU1nc2FLRpjjejbH0xAPjdx2SLqFrU3uTxq9KAte5en2eBZ1QEIPbFeIGMr5BOH2V91LLGsCqPboO9f7npdv2rx/caljcDW5RLja2/xzBG98qPII9IP5HjgNkJHyfG48B4G1jIFpq/BqUIADeDHVBEyv3sBVJ9q9Z6QGtu6uGBRBse9kIAlM/qZZVAThquzEJ1beiRdwBzWPWCJQ5sObgp2GFtRO8GohXWl9ZscfwbsunfD51avOH+PpqeuC3axX0je/+MQKgrUTVD2E5UL3DeFrvKpToStQ8/i0FcRokUmNqu0f2m3qRCae0OrdK3h2dXDKCdU99Twz1gxahlAmbG2G91DeSMGOPu5sghQG8kArd14DzBKlG24vSSpva27negjJ4ZEcg5cQw2PYPEqiVwWuJS7D0rIBGsMWOVSUqJcrWVmmDL6moXfv/+O/7+H/+B79+/o0vGNoPYvU8SpFhK0HrZKgdbLvqkNaXdz7W3cgdWcz0S0UoQJh/MFXolQMHLSoEMMUKBXO2LUm5EToshF0tt2uhxyT3ZdGvN9FuBzf4K4CsmEvUMdXcybAJWTC/7GW072TgF5xaRiJh4Xhee1xPfryeek4FtpuT/LjlbjEFW1FKOIrKt7XJRAJgwG834JtQRuySAucKJVPs/VggbTJ2XtQoMY1Pp5pwdTpaZMA/V7ScNlgcow3Fpv30yJ8FsUtGG+s3o7+rzkckk+FQS3CHPEHM96Keo8GV6cAwjq1cF85aqB9Kls/AwNcSDEtjNkOk46FJCOl3fYcrjyFJCA+yfodAcThhD65OR6pUA7WMgZuIYpthc4CjFVmFdHhVDS35HAEUwarJ8W52hv14/fUUVMpCpmWkxZaHDajosgNWx2u16BWCucIPi75swMpAfQ1610JkoXlD7BKzYUX2H9DBQhUS6upEMM2YO94FjOM7DME7DeHOMc2C4YwxTX44CShyFJrDwTPI/BNNb8YAb2RQwrT/t9QJdlT8KV+v/vLxeEWJD28VthTytL7mDieazuGOF7HtYLecPQynwWdZzA1aoVA8l+/Mf5ls3E+9cz96+L9nIsMvttna/ZWEIyrq1Fjuwz7oQtfwbkuzvYH2+7UXWw/b5NQ0CSxBZ/7dNsnm76csaVJTJGsq+yLWP3ccqcMNwa4g/C6Kp529CErss3ca/DW0ZF/lhro3BndbqZ673S1bbur6s/muaqcuXt6YNgj19A01f5cF0wJgT6zYw7ICBSsZxnDjGoEEBAD0LvsZmaEUUSOVxrXDrtZDy1O/VsegOua1pgsbAHJSHZXwl3ZrmGUjlCLKSbvE7yn1ZJhduwZ0c+xwo1Jh0Ha0wVsj4v9FG40+ETtU+6hA1LepUMZ5ev+t6VvlZh6P5u4isLQCoECuFXvRi8toK+Wni3pl83XNjmrtevrwbBULRBzL0lD7Q9X1myyKO6lgMsD6UKw+DFq9wMJREhASsDWF+4F6hSGsiYJpG8bMs0UECzsSlg3y6LyCIoKUtEzMDI4Nx5Kc6iacj5RUZmt90rV8UCA8c5gAuRBpDRsCGazyP3L/ff33i11//juv57NjA3A5g0WttweabQoUSGZrt994nIOtWSZ5FW1Z7s7KaKDiTSkZ36U0BP6SsCqWALF7dQnejhtqiAuJDu99VumZZvnijVNgTl6XucZ9Lj3MlhZCicqdetFBYthjud+VW1Pg8K0ZpIueBuCaeHx+Yzyee14V5BcYZmIPN3soFXqU9A6yudCAwDXiCwOgUF88qlSlvzGHLmxMA49truF7eQeZxmCz7rfjVmlggHYhZ9b14nwPefUasODynhnQq3PR2MIdjRGCmdSM7nklVdlNli1G1SiXQMyj8Y7BwglkAGbDL2ADNEjZ4EKreu8nTZDAgLu6drFQs3HCpV85YQihpiWJsKktae8grZ47EJYWM14clELK4DXGgjC4aEeCcYIbZiqJCSYO7UV6dYUZe9O+Yjf6Lvq42zZHMhrF5JZO3lyyAbYE0O2YxUMmQ0tdlKNtKbUt+bRblAnL1dxjDMaHrejwVUw0sflC8xenBOI6BYwwch8PH0D/nv8kz2JbRl1fNA7mBqNu1dxBWrxtWu93sfo/8w2u27zdCqQW9X9o48kWB2Ye0W7t/GH1u79l9mMvQWYtgOmdo/toyq8Bkr9U2x3pQLrywj72jMl4HeFuOwkArBsC2hd5t6nequN2992ZhKd3d9IxNdu5f6ns2rdu2iPq1vMg/zEPerG3Ou+H2j+bcawgs+Wgvc6l13yaXtTZFKw0Sbl+8vQV5D2GLlGybXGGBopF9qvt31oDReKz2pHUx3859jUeywo0SzN0xjsHzezDMkfxeN97WpoyU5clel4hXRCr8U5yl9/++yQlFEXiNuZHWbUvSE8mOthx65gpfn8rx3NZdkkelbGu/TBUnyyCf/Xlu+/CvXn/Ko7H2f1HErhjcGFeZ4gpk7ORbMV4b7/uBl73StS0Wun9SmjQ9Ojwo+wkpELzZrtfBb5C37NvdgM365gB8qwLDyj7DZaKRtbQ6dLobTCCD7wfDr9ZN1XXcGT7j6t5ttLIig0qDgYLyIDmEKizEIKALmeYStHh5JGwqG8WVcJyX8hAIsA5RRa0FO5/zMLHjNL0lv37/hl+/fcczpsrCbocEBTLvjCT3A7o2qq+qdfUKQQAIlHduVjuVaOsJANxKisn6H5noRN5iXDcv2HIo0+pertECvjWuTZCZ/onZBpgLgPJwJGnM1yNJyzocr2XeKhmuGyiZ6FrdZFPqQQUdVVUmQKWMI/D8/sTz+weez4kIdhM/gmDXstaQyvhTXoE5B1xZXLTmMqgnROeepnAd+qI0DY7Z2OPE5zrfsyYjx4hSxRjCF8a8BjUELKFQHbqp/iRCydQxuOB3L1OI8TK3KUDvBRw6S7TQxlSzxSTzrOfYpaIsQ2s+NCEX3SV7bUwzTHVkPzTzKZoKBTm63HDdfX64wiazYx2ZoBgKnVtheZ1wrJ+XGUIxZiOo+COBdHGsBJUjs+71QWWF+SMwqFHbv8HJ/wu/QsYHoHI16H2zTBlqoPKQPPde3oEungFUWfP03QJdoA1AOsyLX2XdaknCAOywDZgB5qTnqliVo/jT4hd2GPw4cOjfGAfzNRRC5R8FahT4apJRBYg30sgec42AP5c1WePreKX9up/RWDY+vMvdvD9vR983ZLc9xzZv8P7IYorYsMKGBHUagQJvxr838932/IoCKHnzimC3OW4f75BlrSnH1GHawhklH9aDsz97HXW/Z4SHyA1f3Na71mB99robpr27AWGt2YIs1uuyVud1f22tRy+LbUuVPzz7PsYXwV4EYvaywhWpkku/uNHn9qvrP/k63m2TsO3gTVHKAlq40+J2C9vnWrfcaYdrWMHzVnRsYK8dhTxSeBJLVYfwcRiOY+A8Dedp8EMk1DFN9/mUspvlfQR6zyqCgzSsiI2SLmPtT9F2G22387wrDWnyzrfhVnOWZ47TLK+KCVOt5atwxXpEinfyDCwGeEc9P3/9CY9GrLAnW86em6Whlqytyc2SepHL66d14c9cjKutAHWgdrrOG3tZH1h5HdbM+UQpQo1+sJ0vAZ7iK32IrQe5k7gpRi+DYRCkPx3KSg4078mlmKh10oktHqaGfiGGVp4N1GZ2YeVYVZx8dGjPI6EO04k0WZKNpTonmHQ4jPHytMopsCUABYxQ2w3F79XYkUBc+O0f/8C3b897yeDdLdu/5tpMtPzt9SQ98JqqQJWppPmNV7dbtNeTwrEIv5shRdFd0VK5fEtQmSpIoemtakaXgF1llteaWx1K8CCFmKS3ICyCVbhS0VgqSmoX6tgEka3gKdNhhqnS1sbsdu9HFt9IVnqKOfH9YnJ4ZaGsvBfRfFZOhpO23HElQ4g8+Xcky/HRgh5Q7dWuplQJyUjDYcCoPAej8lkJP5kHoPAmGME7khb7ZVlRMJs5jmDSOHPPDEeypC1LKgPsuE1yr5wRh3Xz94yhYgbGClZANyoqA4Mi1WR5If1L1UcGmBuSAeRAVXGa8ppYavzGa8NdlbhC3ePBPhdIKm5uwJUIN7AS3QWetBLrCWZZKRE+HReMfUYk0Cxd5YxN+hArkow0VGW5KLJ2eiPvVWX+eu0vQwXQKXfHbTNioMEpsJ3N4qvUnPuMFncoA0wLb6NVD8YcOIuVMGkBug8HkB0+C8AGw2fnZPlj3WcEDRhxJJ5w4PsBswPuh5LAGUp1HFI4nCWoOZbyXnISJYMlYW/gMsvQV6+8G9w6+mAHoc1l1noUluyv2fYVrantt9nlRn0fGz7shWsGzK95EtjVmdTXfRvXboHcdYkFlNErUbIk9UHeL9rmtRlMrdapFmH7l3bj28tnXstsbV/dlvO+B7dXYYUlQVaDY/GcXU6YY32ajRfW9E17Ucry/bnLg7Kt2at1sOTUNm2+2US9PU1npWTpGghusf5b+MPaH13zB6uy0+UWOLWu3xTC/tR0FreM7TYe1vQ2DFiYbL8x6ZRei26+qRsM0GBVvW+OB3C643E43t4Y+uiJVY621kqedJv8l0Yjh+XcDK00BGLMkoC31WiEIDrm/QO0KOtayezsA6xA+ajvbds4hItkgE0Hx3fzRG0ersw22ofWtHKA/4+GTpWxYe/8yYO1XJO6si5EHWC+uza1SbUOJ3KBpt6ebAa2qxc8yLuTEU04N8WAt75d96pzA+hu3kV45tx0RzBpOl0AQ44ldyoGKhfLMp5q3JbVHSDxNOVz+OobMmQ1hXInXMBuCTZQWCUtq9OJO9yZBMvqBAMpax0mw7dGJhBMMBzHgQpKnh2zXEzJpJgMRFAIVYM6JIAArivx7bff8fHxlOYr7buZ3rbGemvF91nP50Y3vdVUakY9TPtPEF7iUwypDlfWIYlNUOh5IHhmsq6ov07ZbbgbF1k8D5UDsMenhhFIVA15l+TIxVKL5FCKRMXVGwoAYDGpGr8AZZeyMV8nFcZSsaBFtTjCnIHnNXF9PHHNyeA90VUaLeaZxg7wg8DaJlDljpcyy/WdxhAgTOXoWCJzsocDqm5+KedDQ5uk/S6fQ0XFpJgOhZklnCU8MVgJK9jp+9JBDEx0I6CU9QRsiJkgmA/xAZe2FQJG43ays0FKdBiVogqNZX2H2M8V5BvPBOPcnbWv4EyyvsgAcAI4YGriJ94NjoOPqDVR13cPYA4EpqpbGaB8EWQihrHGuy0PaClWPG8pRh8SAt7JesUTyhrmFrjSVbXrr9fPXuYGN3aYsTSsmvGbsG5wmc3rKJsO7W/xQ16WHTmZWACd/5blM+WMTGqCJ5CTkpdVq8RHjsXPTF8ZnvhAIj/EAg6DnwrDGAdOe+C07zhx4LKJOZgftAo4bOPDXaotMAZUOON26QKXm5GoZWXxdHu9z23F++2bQbDFazZ4c51/l9xDj97u1xegig3Ml1VZR6LD2OrjxhqSPWbrdrXVO8qsMXaURf348WzZppjcQKowzzJSLWm3wotW6BQKqC7Ac1tc8gXhntf1267bzavtGfrZy9o+viFsrNW3tQxr5vbjOtnrA/Y5rFnX9OIu9bVeKUfFdg51H0sIa9V2LPVm9ybW0v1Ii5s6tI7mom3UGa3cT2trTYnl/vqm3FXtWRPt1icu2TvEYzAY4vh4O/B2vOGBE2cyXHc/Q61dp3CYhZ6fQCox3CmbmTS8m0I5zwqZzPJe5b6JtjY2tJeLIGGXK6m7MIrOkQmKTCkmw27rWbmfZgmf4mvJQirTVZ0StjVx+Oevf1/RAEu01nCIkQoErvCatYHbYdjH8aIkFJPabS358rM8AOIovRiWS5tLVDjIildrj9F+T8td1mw0ym8lgvXvvYg/ZbUix7NI2DCYK9HathAZALb1r9ifT8A+IL1FhawkkARKy6BJAJttwUhnc69Kbs4RuPKCx9FEm5k4MFVyc0s8RDKJHUAFvaRddPtpA6JyNJC45mSlo2DX5fIElGZb27kqha0KCK9bvW+iS5CvxCUKhmwhvtzh1YG8hULmUi4ze84s9WqtpFbYEa9Zg6JleLHHOkT93FxFOTqSSUJqWdFkZfc10dyewcskFcVYljd8o0nRZepZ5ZrlnofoyTAxVOp2Ys4LzyswpYzMsp8H1drq5VK9KMqib0FaLvCaSmQbNpsJTlnQLemxQ1aHcHUiBis3ce5VcgIgTHfMqTNlwLQD6cABKjNTwsRzwDCVXO3sXYBUEQSSg03gUCNJVrhlorkne3yUcTbBMr4eiXlQKQjxJeZyy+Kb0d4m09DZVM/ZP0Elak15H4Hynk2Ej9ZZeW+us3gtMkxKyCWewnPMDJhJsATnd7VkTDJfRpURRuGSqptuUBUya9nJvhvkTI8/AhZ/vQAwtwep0FVb0XOXcS8ckJU1i/WIh4tXsiPKAni7idboGbTrQAx5j5sNbMBiZofKWRpsBuYQr2F0JJAs1JAqL3kkc0qO4fJeOI5xYDxOHI8T4+3AuC6My5n4GcXn1vDu1uZ6+98kmJswvv34w+triSpU8KdfKsGKMhLewWa/cxP2toG+l/HlelZboXvuBZEWHN8xe3k1yvCTxYRvvPtnk62HrD93O6vsKQuW7NcHBKQXffz09v3DhHEXwGxG8IevNdt9hW+Ltb1ex2D7b3V9GCrhsCO+b4L/xxvdPCAlAv3nFPhCpisYAfuQF8ZbYWj1rD+exf3l+MP1q+OCMhMCVuG6LyvJpTEycnOGTh2UT8MPHPaAn2+wtxP+GHBjX3Bsc+lfWXcdmOUt5x7f/IqipaVevCz3TQHUYg9bDR0B3mCa8oclT9prFg2IY9aYgK6oRrGOqf5UrhixijZCTgwbwlu+QpX/xetPKBqlpUOCmQ3qKgHyx3ApqJdDQb46obgTLoC2RGyEUfHbFXrD+27k9urzwqax3wD+Yoxlcay5KMqbILp8agAtl0Yr7W5JGAakK4Y9GH5UrtdMV9+LQpjUJG3I66M5+OTGVelDT2PNfI2vCpIOCaH2xcGQ01gHGUAF+FTOQ8hqCkykHWo8mArFKLZFgN8xw5pxJT5OJGJOXPMDERMhmiyFrNYNWBad/SzvNv/CV/Wha8+q2gLldzGT3q1NfmSHTC3LkkJy6voMzNgUtdqLerrOYeF/bxoqCL0A/27cW4qzOkyrtDCbgPGGiylmyUhAzKEsWb5uybFb7UBugo73K2ud9Cc1AkvkTFzzAxeeQF7wPIlbkQrQYfJqSOi6KV8HU5WOaoG1kpPhQQWgMSFlhV66yNUnBKD3IbOseBOe8vKEFJESBup7gajyt/LwBDBtiu1PShMfMACRk4aBjQ4MCn/hdJRHIe+meVPITOAKXeNKQnc2zbt2QdKECCZJqEyfJ7tyxDRMc7gHLIgGB4xceAMkIWWHQlQ5VKhQLFJu5AqnYSNNR0bK6+Zi9jwdzGipwgbFpxiYl1IO0xSiBWP56r9eP30lkpXOdFZN3oR09lE5XD63DahyLxM5Gca3OuBWrhRa6BNnMBQRNrUX5POZVDDKA0Kv3OKRmQRs3g/neQkR+BjG6lJmGMZ+Gn4MHGflbQzmakyHpcMU8rCL075v0ao+WaE3uF9sL9/VH7sFv0DPGjMaj+5hSX1RgjJ53B9TgLy/5bg/o5+9zuyKsao51WULdOb23Z+NuflwoQbfvvADUK6fFBLlDV58c8GWMqoY0L2AKgS6AlzWQO6qT89xn7zVn3dhatt/1voBLXhaFr2uZS94P6+wVdj62/YLsNHULpay7veyUNsilyxHWcA13i5W6etZP9vz3vsbTRZNlQDPNfdtkw22eLuJVlrphBS3QiUvNF3fNxqh9nEVaEzhiqrQCSN+gQ2YDwyUMeCEj4PKhzH0eA4aHVYUVxmzWImOzg2FURlWIRZhuaa9mnKAVaaKTHovHbgAk4KAIWPKWPTbESNt+SYtzmORi8QZDAyvngPKa1NosleU1vK4dGj/Dp7+4PXv52hgHRVvF+VSIsq6X5uHVCt10craw42lJDe1jBIVLrXofV1bI1h3Wpo/b8Pn5vpy32ExJ/5VhulyrSbljFhznTLmSQzNNUti1FjL6mWs2o5MYDo3pQJ3M4FQbkeWHZrAuBrJmjwsE6aKNtAoGE4DVQqaWttrBtxZNenKYKOvOeHDYHGygR9U1qy013ZfVhI6+w2gCDqoJGUkrueF+fHBxPLyJtTKNRPKG5OxtSXb/iqmT0QdRdGlkNrKn+jwodu+K8mzDqikXVuUJFgt0Z0qi5ZqqPkyth6aoT0he6zn1odRte9VurRocFOm6eni/qza3vtnYkxJBWMY0GqGVZiSzpBosQWK1pgdu+nRgDoLVwIyv+pgwoIhp1fCCCCQW51TKoQOCDgGIhzI2Zp5RFJpFnd2RAO1iPKsJV2wSDXwGSue2mV9qQRmzQtSogGGRMDlXanUa41xuf4Ws7jEK82AM51hYlX9Ssm/Q+emlLgZxq7h2vPKB0pZXofCvfhMem4uJ9Mf0zv8jgYUR+Tk/ioRPhCsIBT0COUwPCf32HOigldpgDB4THxAIWEyGJT7OuaEuTqOAyrGQEWQjeYS2efFN/vWX68fXhFITAKDlCcw6sC/yBCHKpGl+k246Ef/UuaCXPKCfK74ZbRRLcU3sjzuuxcEWPIQ4kUbUEh3Flw4xlI2BkOnxjkYQuWDysZgRao5HB5qSJgFodD87fZsSEYh11svVu4d4L1ail+lru2f3Kyq+fL+zgU1f7LJZrV2Gy+vLZ63f5g/GURFTfSj6vL84aa6fvc7W895N4sWjlhft21dt/tatXwtYFMfJfZnl8ypHITUtXuY1TZz/qz597OEFXrktutf2zyWKsO1tds+96cvCkNvYVvbSliuhV2G3Xp/H+MyGEJgtgvx9Py3cfUm7ObibZ21RnnbB2z4w/qy3qtcC7JK3/dibrJ9p41UeHIpcOt9Grx32ltRJbRPWffTcOM5PR8HjvOAnwfsUD+ronntf+U2WMZm0K5wtTKSRi+tbcrTis7wnlfln5kbKpmP41MOpwHpCVwQcsr71mo84yWWztigjTyu8jwIlgh909sjnBsYu9PJz1//fsO+/q02gtvvTRfNUpcbMncAtWb6etgAEUotZN6ZjNXnAAX5etIiWlH1prShDs+L4aWZ1TYdrC6TFBwWtIqFBWCD3VmRMAxiK4Tc4RzsEk5QaIus+xJQbnTOL+s4xzWl3XoOxZkvxetpiQO0kLH2FD+bCTzl3TjdEPYAfKhxWLUNI7oaVJFZ6jZEIAYkGMPFSC8FLSVwReAZgdyE5lqX2pBiftsOhdCcYwlTlZe830tgNdFu8p2RVGhJloafd2/ZdhWWT0aGjcByEeayuvXOSjFppg25BMtiUiFGvlhTZDUhbMoXTa1k/k4Qt32e2TRoYAhMWQhM4yvmRmZim5KJHjurTyWo9zEZupqNIcGmdM68gbKUZpiiDQfcJhvVuSrXsCYsPQWJtn5kQhWXgHD1j2BkKsdv9FBWSVkqr8m64Ql4Bi4nKF7d1slgLl0/NKeUR7S9QxCIxwCSab1TvBVI5LTuaj4C9BK6lLV0NvqzCVjigrVCYaV4OHBNhihVhbcyglToZxymBN/RCXYWPOtM3JZKY7T4lLl87wwOVRUysIJcoirIGWymrN28gDKCyqyJP0QaQ90QeDoYGhlgguByM/31enlZAnElcpBOpjah2DOk7FOPFPgYBXKW3KAfEBsyKqxSRpAEizSY5JCudV24Ca11hnXvWDioBAWPnmOMsf6d4/73GKpG9WRctEV7TOo5d5i7RlCnsEKccceaPwD5BeSw8c+6un7k/Xv7PPsie/mxFKzqSlAD34HyEtT2wzPqosTCkbdh7QCxjJ6Fheq7/eW60bpBbWOkgKLtD9vWQPNp74qt27wO1354ZwuSWVu45mPrOpQ8kbzaFYUCyNU/ZN01X8KPtj3ur+8Py37kK2TMWi/cHt3foxd7YbnKscj9LrZ7a7f71v3yx/tyzC8Luv9ZCoLCTmE3p0bfdw9tXMqh+ICYQ6ORWu5t2bevSMFgWCZzG50ejfPE4zxxnKdyY30pGfOmki7dR56ybCrSPhXGKbubbeeiNJBxv1+nc5rBPRcmAD25qCiXPS6w5pRQKd5tTExQ5VkQ7SGWsa45jkn5EfH8sF8/ef0JRWNTEGqP5Q0o4q4Cl3vVncpzyObK24EphmsClKizZR2S1MRbE8fO0OrnYh47I8rtstz+tcUYEh4FeM3U/XFAOFxMxzEEFMtCkxbKO1Z8vAm8QaXP5Gb32kRDe04SBEOpuv8MbK/qT0RYxUDYpI2qi5uzpfwF2AhZ3wA/gNXZtnwArkRVxePHwXARq7h6Nn4zM1m+DRMXPuLCvHr7+pWwVgya6oqZ9/6j963zVwDslQxaOTDc9nvf0gKhVNSm6KHCTu40ubY/e2g7ly8a3em0vxI1ohqBQOHO9JtRV9UTXwdY9wpZhYquimaj3Mkp4bxZWLqpVD13lzzZlMl/iul2NwxVJGPlIoLSymJOZ/+M4fSGNVOtBPSUWzbK+L4pZVWeNgwW1l2uKxRwlgu7LPAwhRyqRK5Cg+jcC6QzOReqbGbpCmkyhbGF1k11u82lfJN6H0j4ZMd6xtdz7pWYTmuaKlqpNJs5kAhclrBQqEkGPRgKnZjJvBcLQ441l3JKwlJFF5JhOLG8n1CzvQIiVDyk1Bfdw3HAkMF9mkbFi2URo0iJu52mLuUkWLfJ2klpyG5nDVXO+tfM/L/uy4BJz2KU9B2QRZHnrHsHpPbaWECil9UqRLAAW3+wuE7FztVZLsBQVQezzMMFmJZMA7YTnTJ4SNsdNuB2wNUpfByDJW6PgeM8cRxPHGPgcuZY8bzdDXqvy7EEnfhrASjswMPwh68CJLjL/hfMt2SyzgM/WCDE+l6LKRc+KEiwQ+VmzivM4f7kltW5fbYrJjXo4qV2//4+P6zPqmRpm9X28NgsHvqzEJxcnvHXVxZwW0FpN6fSbni63WJbK9v37mX4uC0BAL9FCNRtuM4U1H0masyxbY2U5xurWQBsE/YVELTmtDwva1+7Ghm2cdT63i7kTHbDYZ8h6Izd5q3/+kpCTyR7Dt1oOteDy9PTuLA8BbVW25xKRqMSq1zYcP0zFW14PE4c54NcP4d4vmFEJaHXow3AYB6ebR6aUIRCSnq4vChF54WDDCyvnVxXJ7xUyPzK+UWqtUEYVGhxrUUpL2ZqiaD1laG8dBKrsMEijMYqubBEkQGAqkf1z15/KnRqDTk3zQyKJ5Zwrv/adsBkNewTKiJ/9VoUf1n0t1mS/nAs/c2NysvCvN8/Uf3ea/3qUFl/Q2mD3vV3wMOrfI6E4rArTEWVkNxpObMCXAR/rDqjERqbb1HAOcGDgxZhU4gKimEDma5YeBJLZI2NMd8I4JqJMRNjAH7IFVaMqUChHSwPmhAo094k0WbaJWITILpyyQUJ4lp9KhJ3LpS21q72kWtsd37fH6KouwnVdViyJfK+q4YuuChilyFch0YHKHc6IXy87X/RXFMNleCM7Zj0ODhYguJsC+LCJMUSZZUXnXp1hm7lsyxGtgSAiK4hiZTxBDo/x2Ck1UD3CBgAS2WGy4DKeWcMWuKG6GXG6nYdClmLZKUkJW+ZOmAzpM9QpWlLqXNTNYxQimwabD4Jqo2gGZM0STYTmOm4JsdO+qyTyypZ0kGawXPVyqlMa/5I5qJxvak0JQbcAyOL59CzOA0wn4jpwDikDFDB/UDbG1X3W/SQBvjFim4DoGeHlaQiEzYSGQpGNdD9bIEKyCqaW6kvCmGxKqZAvjG1r7t7XqynaT2wgO1A4gOOAw63UIK7lJIxtI9/KRp/9DJjvlw5VbspFSo6kKCB3kkqyCFy4J4ABBM8yVb5MBuSXqyE9F+KQu1ltAiyG49sqzDYlLJNliYXX1Ys1wBysLJNKRvjxPCTvTWOAVeuhg818LMFYVEj3cVgz6E+Ly9xvf1CUwUg9q9u4rXXe/9Z2GzHbFr4xrt+/2JXjxKurHr9DRNzWeaz/4NlLHrBNS1WCmIUMDF0QnZ/lms/952t/1YExuoqXRiU/PimMO332SzQfd8N5N2MV6+Dl3Bsufvy+auS8bPPCzbvpc+BbV+aOHqFsHvlSlZtw2kLOQqAWvHSTZ7Zfe4VxtM78RMSayj4MrFFAxt+q+dqhdqb14aDl3sZbvaARQhrDmMnKpg6fe/Eu/kbpIBUewMfhjHYTPl8e2C8PTD8gWEn643qPua9dDLqyfNf7+7nDMR4Fpz70bRPDBrydvssH0zxm3X6Q0pg8bQGt9rEXo/a3FHYBShjXwm2UBGSOsQGhQOLfbmlqrAC6b5cSv/k9acUjSJCbtgCWFFLItB8q8W7E/pm/t6rP+0H7MZYfjh02yEpDbs4537trkmvVdccci02FnzsED9OSJvIGGpYIEYRnLTLTPkdrEFVMTK2HWDDsqhDLIBkmepKzedFstRhABijpJ/WEYEwhpMA0Z6NhCEOdgc3JC29oOWY1xuTWxEEosUj4RheagG7iU9pqEzcVjKqD1ZkkXXX5KJdhG3baqb4ernEa/PqnmuLCLyKlVi5O2700d4sQ3ekbNc78EOsegmGugfHsxjLK1/PXfLrS7XtsNX1ElpPmLxMonkev6QiaKUI7/RmYna5rdMCigWt2amaykHjmY2pFxBC0moRCApNA63lXneS4iFLydGeB+DSnnQSdY3LjYntRjrLyRGZGZ7ayUNCNYGVi2EKBYo6O5PnAUxWJjWsBnbMHQt4ZFvuXX00puiGCg7DE2dyrT3L9cuu9QGGM2ZCTScpUMMMA5ca4Ykx5oTJTDcsWBY6+XzmodCT4dVNOicChunMyTBMdkwH0CV9Q8nZHv0eQSZzAyr3woPKe4zlTq6u6Mw3otfoqsPfpJo9TwfgNnBB1Q6T/sb5V+jUH7/GQE7HPBI2DD6M5WKxMOkqjq0SlMHaAK3aFzipfQO6WWLFUlNJPqgrxLLWU/4uC2bLuLqPeNRQTHUGkGrshQDyzZlj9XT4d8fAwOEMxxhDSeHniXGdsBE0WLkBk80tY5vdhp/++euVN/4EEP4gWv/w3nb/EuTxtE3b2O/9wrNvj5dYv41vu0VbXF++z8vKOEhlrr7+MrUde77OYDM8bu/L8NWOS7sN6V+8JM9vo3hZ+D+60b8wFBfAbjiTK/90e0vz3d7cgFzJ09uct0uBhcNuV9ofDLuQ7i2K4f5RTe1FkqPwRIWAlcHvhudw/+KNNlM3LvHoQOXgomhO5rwejxUE2QmO3nBGtxi9AqzHAzdn7tTbgeEnDlejTZehD+iQ6QQQFe6ksraIbcxWYzBVjgoMOA5Fw0ygDX20D4thWVXDrPtkGzZhNC7mBcnJ3DzyoNYzykACVTokFjFZS2xWwJm14cYUEu+XY4xEXmSYMf4J/W6vP6Fo3B1bfDFcqKzfu2Kw+g9sp3q7oOjwfuREyh3SAVkWtIE7P/OdMLIJKSEN8maN2g4jSmCsL9Tb/Ce3eRGqJEnqPU8QxEv4FAimoWPFvrNaTgEnhcbo/gydMtb595oLMIPPJtjgDg91EaAXtsJ3uCZHMPSqYt1nquzYoFV1KNyoNHkXYA1TuVt1SuOwJkFaOk5zHMbofK5iaAsNlfBbTKHWb2LFCDb4r72unbB9z4AV27f8SYvSXr+rPcwKa7AGarXHZeyASVvfzDrLFV6M0m7S7pbIBnkxOllK3ymPSrGlfBU4JejEiEXHd2/Guo4MSDTa40ErNFRKZel2ghMyFFK06/6XQqGGxlodQ0cmkC5vVsIOlX82Q8RQv4hLYMIwHDilOKSuK4WJTfSYSZGQhwUuAA1V5QGmBTJW1+42mmh/WKiAdOPVCHDQ5U+gvY+fZUTDDJkDYYFLZ4v1zMn9xqwaXKnvBrgaISUNoAuGYPCqECaNK+W9MQ+x1wqFiRYalzLirLyBOh2qmwWPqdKmiZw8l6VURwZyOguBWHZIV2I1kDwyVe3L2tmXohQ3o+Xor9dPX+M44J44dYTGAMYhHjeW6DHx6HQAs+h7hX7IYIeqCbbCF3TKcwB9+hdQoeJBuTDcOv8jLeWi47doJFyyqNjfmIbDDcfDME/HOQ6M88TxfuC8Bq5r4LgGzjHwMMdHe66Lgm2BYL02ybhezX+2UKX9oh0B/eS1GfO351j/Vr+aQbHspWwAlavYF+i5dh9hf774/suzhAdajVhi/sfx7/vTfDlLdKB+uX3NK4Rq82AXcNym0H1W+vvbIHataR9kptxnu0yGrQM0AAEAAElEQVQpWVRXirYSVGZL1ul7tt97+46JhwtiKMzGtp3WTmUuOWxYE6o55Lr3bWlve789u5VqvVG6JSTHy6Bc49vk9X3jVqHZxnMll3s8hUBfnhkKf1URjRWapFlbbRTRdtbZtuVxrkbUcAecIVDlPXPnfasM9fk28P5+4u3zifNxwu0AMFCJ3jvddO9lGWk70qMuSIN6KQBGTzZVjJCsH3CFbrF/x5pzRQ6x+Agb1VoSU7orD/EArXZypLbOK29oeqx1yFqvpKHRNm6nNfZTWEWy0Wat6z9//QlFow7qxpwUSmHpDaiKTvNGRPy5vBsFuvKmLa/vL2tRvXYcuO6c62xoMfqA1HCxNriYse033xHxMJiNdWhTG2hM9GGsfSLCcYzFgIpyVP8HrnCREDgtj4I3dBCoYKkkAg9TeJSjFQebCYxAOKuSBE23agpDq/BAYqaxzwaYPO4qm8acDylHssCahUriMjejQgu4lwxTOg7HOJ0x6nMDnjsTrEMiUF9EvLMP0uza6/1TkyBCyi24Mc0EuoFZEdQmWjY3vYB8KaNbGFOxMtLFIjJHq74LDGSpDzvP595UONdSg6yFQ26CivtHb8CivWIoUnXXG+RpZpB6cLMiVRKrmbMCkQOHH/19Lwv5FFMBFakLicPoqcgMnMY8jgkgwti/QoLWnIpIqLcLlORdhSxmuugXopfqG3OBWQlixqJsWlXUGdVWmBNvnMxbcEMEQdwQjbNPRKrHxrLGDQyYs9leKTZc+pA3KTBguOSSFvaHm2FGEaIhk40O4eVVMNX/J61zW1gSeuRoSzcD+YG0oz3Q/AbnOdq7RwZ/RHkAJSR1/rjdzvDH6QJhQObBZnyRuMygJiCo0gJF+pcR+L6GIPz1Wq9hgB1S/Zx8xQtc4O4Vbc91SMHY5FAmjUOIyheCzqs80EAhpv57OUjZ2MoK0Eg2pORke2XT+ntDnhFPw5GOww5c54lxPHEcg9bSceA4ThyD/87jwnyy4ptFeZt7dDeZeXt/ceVWoG6yc//eC/jd895KPr98Zd3EsEG8FfJCCLawQBkeSka/DPp1yLte1Xtl2ovdUr5/vSI6zMWzN08TvVgLaC7wzYeUF//12C1ly24zqtqxrdDuExAt5bbeTXubtFnG2lx71J+h92CtJwCF9lbBkooYbg+27uD9rZdxbEPd127XRUrGZ6K9LK8U0L9p/RbO6qXC/lTDfRBFbqukPbHDzbyyiRQUgNdalVJQ49qW4wbxVkxBr9JSOlw/6w6VN+gDrpK2Pg6c48TjOHGOB44xMOh6LqRJOZbl1av1NTalNTaC9vuOrPk4MFelEo14YzixMHOtc+hZBSSqGGUmILcIvzwAjKT3VJK7cZjwFOZaswRLhmegFZhSmmp4Nq2VzX/2+rcVjeoQUDy0gX+ueLF67SFR0HFdrcy1QLau7WWzRXnZ98m2OFW4VOWEbGfv5WX67rZhRcBZxFQ6L/i3KX7XFU9NoyjH7Qx5Yjgaawfv9yY0UAlQlUus8qltTcYmo5yTczDBl3yOFtUAE8VDoMUzgRh8ilHJCGe+Roi4XaFallDybFk+WG7X3TrunHH6xvqhqhKk1SevdJVYPAaBbvck1mQaBNG9yLKQsgdqU9kjmYKg9m+FVe2ceAs6WsTRB30XUks87Btu2+8SCgYphHVfAevNK1Yel/b27IxdzL6sQZaoIG50c8VIVJfzPqS1REhU48AqcRtQSNZN2eK5cXkF29qj+1VnWjNatE92l0OBFq8DGEBiCNwqjyAVqmdA2sCRgWcmDg+k0ZN2aJzmwEjHHEBcKdpWsDusu8rHBMIGzKoIgSm0h5WZMgwzEwOGxEToN9emsKcE+L4UDxvAJS8aFblQDhTP+qVE8xJ0ngbHUHndVOld7XxbCoE0U1jhwDUOjiv5BFMImIHAngWmBgYCaaotC+v8k6ZDr8pyagQYk+uRyWpVyneZYEOjKkudql5XXkGYDohc4zx3ITmQZDw0nCtZb6k3f71+/irv3s2KDp5RuPeyN9AUqZTyWHaKEmwlWyqGx0p+FK0VVaShip24Hlngj2dE8kz3hHjyDZD02R8YfmDYgeEHzuF4GOn3eZyrr8YY8OGwa1WgMuStuVpRbluvb+Gi/MXq4vpvs+QSUptU3Vj0bd13dtarvAGe28XLanrfu43123rv9mH9kdszaqK2jayEbG5f7tCJkiT6byxr95puWf3LW7/k1D6ktVQtGXt4a8jlWd2+sa1r0d0ad0m7tV77Q2+rWcYM3CTo8jrse1KKaC0fJJN7HFKAtQH7Wuw00OT74vmvsdF7YSWmNw+IDJG1N4s6ey9u62vbCLNHiIUM0DJyheAt4LtyVDYaL4Oo5remoEV5+bxWtSJLaDjmuTzGgXEcOPzE+Xjg8WA4upW3ZLt3GWABo2EDUo49cNss8RA6zW2jO9GqSSwlFCJda69Q7lz7mNt+c2+yWkexz5Q2p+n71pUxiXtRcn/jdTdyXDiwONi/ev3JZHBrw/FN06wYxuYaNXQteQntVy29f9kGqtAPQGCxFJS+tW1CAVhVmoDO+7Bsa/k+9vvPxZwqtMVQPUJ4v6EFL6LP7kbkiiDiGMMGhsJcskqG2QY0k67xLpcrsGUIVtbZOEEEASHBFanFdW2XEMiyCjssBsEoJCDDEBgYPpvHBoxhIQppgYcMPAwPoRoDIALDgOM4MY5Hd9k1bXopjGs3poTtWldTTGA2k0CHwsj5xuuKsZUrryxO2vsKoSka57OLJooWKlxrMz+WYoEVLlWhY0t4yGpROGCnClk22Otip8/NR+f1mbelpxmXONn6WgnEzbqNpeD0QW6iVuWQobGGA8PhJ/ejqnmx83GoB50Dk43JaBAIhapyv2eWp0DW3eT6s+Smuh6HiRFx/N1gsZTLqq5UYYSgZwEIzKjzwlwKWLX8Fthr4NWqvQyApjJ6dCOEWVsnvZR7mVNDoUVUstTL3oEhK/RTzzJ5lapF4JXMr3DWb0P5jitmNocUmcmO68MGRjwBM0w7UEG1Rq0Qkd4dvKsDewxW1GJDQzb7dO39JevSkFmTZZuDR0clevPSIVAXVuBJAYIVDul247h/vbaXVZPIUYrGkuP0TCyaB9DAony10PVmFfJbMkgGHORmaV3ywJqvZclcJNDhegFWCyMpbLKoz6KKLaiSzbCBgQPDBw53PHzgOQ6cx4HrOPEcAjpjsGhAaTcFmsUY60nliS7m1tjvdf16TRZgu8llW7yvMFDH2PfzZHSBtUm0rPs7f/05Jilw2IGn6/3GErssL2SxZvrDa017gT8NZnkS7L4muQPftbMuHGL4MW2in2y2lk7Kzm5MLWNprttvS2G4TXzTQHJbvx+gUmPOtRr2sr43tGPre9Dsa112wF+GnvWdJYcLd93GsT/HNrBb49GkSwfcFaxXVFaDW54jAt42VNeXvFNj+3653euVzPL2+WbItuUd2it8WT+Ght/DXUrGiXHy33GeeDsZ3dKRAsXHAeU+Fg4s42ttaN5olDIGWxlsnu0uy61ZLE9Q9nmtPLMoJWv39kDnqoy4obNUeCuLX1a6guSc3PjFtxj6yQiazg/JMsT+9FDfXn8qR6Nbpje1VPw/NcB2sXZoyU3f5j1qY3O7bw18vbW+Un8byPBePuvY+t2jAgkEK2LaDteu/do+Pqh87WCLdXeFcgTMGCfeFlolb1dXdMZjJ8wHXU3bVOSNQ8gSOmEYqSArZ3nL4dbdIAt4JyD8XFJTY0xjwqk6lMMCM/mvwnGcg1SvANmWE0hMzKRV3M2VkKvmbgkAA+YnxvnG5MPhtZICilV2d2OaKC/X4hp227z9YKficIrAbWM+3IkK92r+1qFNJYwWUZChSTFoDLGClYsJG5Zbsw+vRIabs0QccLPCeDGdbRZeB7KUFf1MAd+y2HlzP973NfFNbSW0t2tsLIyqgdhgE0ZnlYv348DDTH0VgLTBsB57IpNJ2UcA38v6nUaPVTFAqyQxUzJ29YXh84cU5KtoPEtJJCOKYKCeWeUclY/+kHVQ/QVAcD7AztqWh7pkBzBXYYIwY1K7NsuH1AhVP2Oy60SV6GVZz4lEdOnaShCvxmReTHATUCNNlcDoPZpuqpUv7wwRP88fyJCzqshl6H5SNmpNBjDk9ox1QsiYnya+MlkJTOMxiHnHCvcrQV+ezAiD+eznTDPEnHCLOwH99bq9cs7mEZYTNsrr5wqTy/ZeUCCjFZISlnX+K++pzigfwOtK6AfIxoofeIYMTvxeJG3ZpRiPUrh3cFYhEAbkMFiQJw9nJ/DzGDjPgcfleA7H0w8c44HjfGI8T/hJhbUD9KZ4YIFcVNRAMbVdKv1sEbF48g8fFjiq2xQSy02wkucZXegLuBaYshVmxFss63I9og5KR57h/tmCPHWT7cL9Zi3f0WveNiys8bzen8/ONfZ+btI5lorCtVyyop7Z916e9b1k6vaIOx3U2vbYrX+87kPJvsKpa/jZ20zlY3vA5ioq41/nKOR2T0MrCOXNL7kkacf7lGEQQHnn1hZyHGUkt5pbE06v7Br/i2bU2NDW1etbteTFUPex1NqscKvGZyX3awNygf8NaLQy2DkRzhzZMVQJ7lTu1OMN43Hi8TjwSKd8qdje8kj4Qh3iTLxnOjJliBP/qLO0DJ9lZK71cSZfR3m1S6bXmBNTYcFZRpWiWZ07E6DMHVyB4ZfgIwAz5MCiD/HC7Op6CUAVKdObHrI7DP7x68817KtN2hjXvfrU0q5+LhfF5Ot+WESFBnD6tgAi+nAldk2Zz0Yf0OX0qu39yUnFncAXbIZAvmNrGS5e5oDi3EeO5SKr42dFSq79L2hJyz4tw6r3X9emauTbvm7GHggwdm42BzzxROBAlemcAiwD0wdOZ9ZPqlHMmSQCVwUBAikKnChQXCxDoWCeKyRkADgPx+Nx4P2N8YemqluQBbjON1CKXO3ZYge7Epkbo6vXsgrpuy/bZWV1h20JvonqULPsXiVMNcYKGao7b4e3rBf1XLuNAVjMwJdFw17oDQuUdKU1lLKZIq5yi5bAsXUmbJ//4sgEOcWIY50DA2w4xvEGf3xCJZJGVbwydZvPso7Kt5djMTwA9IYxDKksH6rADESyqaMsGA6XNcSBqJok5Y0cQE6CclN/Ezg8p04dPW45K3RQsfI5MAJIKT6l+IaZmlvyHHqw6V44ELPMMuz0PFAA/MQ0yMsnUG+AY8Anv+vFiRxIBHJW80GTEGU1tj4NKY9fAQ3lSlDpV4SspfrqTGSyVrqpFAdpbBJwjgOoDrCZ8hhpKxTqZbp30Tcs6XZKwMIRLiEwmbMF8w5g/Ov142teE3ZgeTEA9qSos4zQ0ZRVNQ7YQ1xg3MMyeAyysAeACkEE6SQVMjhU6U/8vY7/LZ66JGUAQCzPb1k11eDRJwAzxGBu3MiB8c3hh8EP76pTxzkxrieOxwfOj8mcwnTMZOPX4nkL9KJ/30zL+/BuOK1DVV5Ira6pUJUCkGmAOUMaGx8UP6pvliV157N9f25W7oOQAtGwtAyDNZCb12H97HWv+9m6X039dr/E5mWqOW9gtobPreuoYd/wTi/rT76zo6QUDcl3XYPr6xMQP7gv+L5mG+RaithPWELrPWtqKCt4jauX2WzlsdQ/256sARIv2JLlhtvcOoQHaniJbXztqV/f26a4xr151DoiBeVRjx7TCqmSId3X/WyjXfNlyKl1cRGtWCphg0LNHcqrsDL+sGcNBlsWjOEsxnCcePgD7+OBY5ysTLWvReWDRkm1KnFSm1HFdyCjFv+wWfeoNbXGGwiwitSIfZO4VlMQNQNHWn+XxFqEkCzbDs7JZYwMgDxI39n3JGHdtNoSiKOiKFKyD0te/hvO9j8VOlWejAWjirz4dx3WWizvk3c/ETv0LKbFng8cOGyRVYOw2I93HbZFueRB2cyo+ardH3xTZFEeElqwRzdEQgN21XESULmAPAkUDG0NMKMl3quzos0GMCVTUqaw4b4OhDo0p7RDV332Aime7GacM4FDYS+gAnOAGncLNAFaUzmMAq6WBHUuq78lkycjafVmHeQJVrhKHAM4HgOPB5MQzQ9AoSRVH76aDlZ1DiYBL0tgadm1w2vTrI50kwQBeNlPFpBvJaEAeB3MurNopgWEnttWGdHrTdmo5+U+JK011rg3trA4qhEUjqKcLQzDPOXHXYe8Evy3B+tM1HWVGOybMmairRJJtHC+PT7Bz0+YOTCG6DFZTpXd5DnXS+t7uLpXg+fJzBB5dgNBtyyHB8oqSfpNVUYiQ6mE8QwB+Az5K5h4zo1SQzyhENOaXpnIPEHFqUJU5Alp24g63jsUUiSrU1tlWKDAjVeaAzP4XXdWaSuvpEmYH8Gze+kJVLQlckRnI4DE1ByNlQXTZIk2PifnoqvQmOXlTFH9iMBhA0CwNG8ebYKoxo4dumOJmdn0Do0zYZhhLPyg8UZQwaCCCGQ6G9H99frpKwzyXLCELL0ZsiBGnWue7IQhToOPMgI1lAJQ55+Vq8IJxDKTh+UCbEKKbZ3vF7QD8uCVk4YSEM1HAKhFPb/O611VbYxV5jDgBy2o4wocz8AxJo7zwDkPnG8HMg+5UIoPq9z0qLO5LdImC18/0iBvYLbeqr9zu2TdTIYGKc1pRtAxKuyy+IH24idP3V+vw+2B/iGQ2Rj7Jm+a92NhLrwen+bJ6xE3A2rNO/c7t5lOf+V6/H5fvCylFVT+44j221jrVQ6RV4fmDjZ/CMnbn7tm9PrM1H/LA2C3a0pGlWFE7+V+l/V7GLqT9Nrl/MmVP3/ly09sI9qlcXH6vm/TZmGj7XkFdjSxCueupWPeQvsvGCKV4rteFn39GwPuJ87zgcf5wNv5wOONVeFcxum1nlp3p/yCzkEUfvXKqdCExReSVkJ6RW0bp2FVOPNK1KC3AgngCeSD3tsyYFbY5loM9fcw9tOygJrSap1+oOQdczkwVKQogJxGo4awq7v9n1U0EgUkSITWhMC/HVLmZPVplGaCD/sB3DZ9vz+/UkCwQlwWeOyrNvDYjEHcpTvA9jOpFe9W83Vesg+sG0vOHg16ZVnOOkAEXgV8+Tgmc9MjkE0gFdPZzc3S4ankbW1sKI57pJhQRaLA2uVroI04bchD4XJ0sIUYJEDdAMzAtMHEpGny3hnSL9C0O0igRqUpjVVSwiamsZQobMDsAT8eeJxf8Hi8wfz3u0UIa30zl8X77gLf9tc2Rq4T3omRVnV5FjvscLfia8pHSR/6vVQN0WISEBjQVhfDfgO7yXeOx5hjo5yHofdQVmqXolmip+mlQgLk3RGdRqYU1I0N2mKNxOBc32VByrb4q7c2CgyZDvBwwzkcn94OPM5TJYeZBO0ieoJ+SEFPWLKIwDSWP2an7ZN3HyxFQfctQz5Yjt86nhzJBOlypbPCE5WMSJYxbgWbdZ+4vmLcpXCMAuMKaIpMpDwWCQPc4VNeBEy4JcJd3ouQQ8IQSjCpuFKfUOhYeRB5T8/oni9oBs9MjeoCnTHoVWFkPHuYZGC2Z2V2fCz3dyKNSgiPPf0KGQrHgrfyu6yMvvhX0cLQ++QqmAkMpzgYIf/LcCAGAkFFMCemJ0xeVI+/Gmn80YscTgUXpBMQ3Rk/PAQe3MX7uPYhYFS+rQS6CR5D2dBhlW1t7bBU5fOpyIECAm+wjcp1SgbainxwKfrM/iRPLA3/ctgY8MeBY54Yx4VxXjjeBo7nwBkHjo+BczA3aE4iFxsGn47ogK2iwF1W1itffi05jTZyvcLhlt8tm/S304hlsI6Zb3lp2Pia/SAjFo/ehiShYbXmt4Hex3SbVuOLXKE121XFh7XwEtQtzntODVjpvuzlabnScxC375yCWGPfsf9N4bFNELUUvU3gZpNtLedFqKpa5b4Atn28vi/AXOP2ko3AUpkWMKJBaA18TwvLLM/dULVEnSkBK0soDIcGyTbECaAS5CyPToUGLaWofujsdNxbYTRrKdnupSIJQ8ukIkCC9PKELCPrbXm04CkgngM8RxUVZJLD48DxOHE8TjzeTjzeTzweJxwHIonNXEEqjZMTMhg6y56H1n8D9rnzCE96KIN5h22sTfIwCykzyr3QkUU+AJwAnobuM1r/MQDDWZ1S+ZhzKNd3qGKkLWM75Jnt8Hado722hm4Jeol1iOa/1jT+dGfwXhyYCEcDhIAe1mEpcNCHYqed+uW26/UtHfadMHRQac29XX67aN1V4GSjrhVOmqhT1IfNFBdu9Q7B0IQ8G75Co+Tt6ucXwbbFvTmqkoURSgr0FjpXAKdV/4kLiYEqE5xZLlqAFiNZvzW39MB0x6kO4/NSL4RxsIexOkeFBRInAJcWzVwCWrYpoNxUKSEIDd1PfHo88OnzA2/vbzgOx/NatqgVmrbWu/ca8nYUoxfz4iIrStrUPbvXX0IKDcubKbNSD9fdESuOtHiNLWZpRXfNg2wxn02w7Z1FyxpepFmKRcdvb+RVulEUdd6Y9XrwzVO8n/jysmF5uXYaBMRcLAE74ObwccCPd7y9f8Z5HCwmAAMyWC61FkKhF1W2tRrflbIJhR0NY5hnVP4EgIkhgJ6Irk9MTcPkLiFT8e4sbyNQ+THM10gYAlk9NUCFaGJimsJWzHQPVcqJCkUCMA+CeAuFWnEnuos9JOR4pNgI03v5VqUqt+WNkUrnVgV42YyPnjh2+44hc3canw0qIzOTuRJKgHcAOQbMJnUGlR+clkhcqMZkWb0zwjoXJGfAPHGl4TAwcVnGmKiQKAt5dIbWPBqApVNB+TfCYP/Lvi4khhpWmoRlh8UINJgE547TItlrqHjrFCCJ8kRLfO0Wu2x6kqSqsBoD4L4BpO0oaQwpU2aqkpslhfasXCNzYAwqGscBPwZzNgb/HcfAMQbOceI5Llw+afxyyjTPZDNN8R2rQy7+WJj6py8VeagO0SWF+XXJorJaW7F02wqGQL5KNMhi6HDx983K+vJqWboVXqn1s1d0WDx07UjDi/qzlLvu0N6GEVtRD7U02H5fyyX5s/BDhc4VAKvrek1NK17hqg2q0asJ0VeWYUyjfoU5r3/U/dUgTGuW6w66bgXx3Bbj/udGm4KJNd312G396xl1jY7ZFuol81gDW8jaXkJ65ax0yejEer+HJSSQa2x0CvM+Ld+3wdNLsBmhzZbXov5b4n5fCmEweth1YweGFcCncGHH8MFzOE6WmVYS+Hkc8MNZq0W5EKWA7Z5M5nrlapWhgZSHa8eRSMCrNPty13Rz0Chlo3bNeAZR6w3xFs8ua1s2/+qfEWAEwUgZolXGPvdxrw7PeiuaVj0pu3W4KbfiXwunf1/R0AG+WTo6BrwAqN6uzTa7EXAxhL6H9X9QzHAd3lyXYDGNHoE0sfVtbFaDfgdtnUnds89i9jXdxdeNVaNE9CPAJmdK+CEBQmkbDleVn6qm05b/PRFFpywUy8q4wqVFRjIoiwyaTc9YzCfUPVYxdfKYIBw4BPpMCd9xkehUPSgHoR7BpxJZzekVMIcH3WelWB0VGgKDPwzn+zve39/x/v7A4zjwNMfTulij1jx6r/ZdZJI8P0irvavNKSG19r9K35HBSI0pgVbs2Bbw6j2u8mvyPJRUNyvgm82ct23YhKVL6WgzYyeAr7yHNbdSSIrAKbSge20u0zVIVKUrTr9Yup7vxXRqYAqWcq9+QQqbGvj65YFxrOdbDnlkQhYmSBEKUXXAko3JZiYBjHIdaPGrnhgp0Kw5eoW+0ZfmSMSYtBhPNsBzkPFx6Z8wuGLYZSGpnjoKKUps8dNOQSxDU0UXAVF0Q6vstMCQ1wjKP3JPVVTTHgnRXBqrwZS0Fj2nMicaVDgBgM3kubWJ6iPjsuJeqd4yAwRtOeTtSqVQmOgtcYUElZ0KJZw8txeVeINKV8tLAYDjKxpCqsAE1xOyAnYYTyl9oS7pfxw/8ter88e2IKgKdxIP6nW3F8CCvmSTC/Vf62uQoq/mZ7mUmTrQ9ZwNPSywy7+LN7UsGryGRgKHu5SL42gFg/8YJ350p/AD4zpwRDBMMmcrsJbL80/+tIZ5k7lbSM6yse4XVryClA7xButF3IX7vqYL/t2E+k1abwNbjFW3tZ8r1jfcbLfHk+Vu4AwFBew+5/1eL+PuqIqNWHqvokyMN7F+W1PbblY00jIOWCGc/ZXt9wY+671K3G2lpTTknkMu3IE1/7u82znOPsIX8F6Pzg1LlXXth7lq72x5t9eibuPn5HG/CW77va/z8n2t1Sy82BWhdJvsP3J/mkSp6NOWIlbVnqy+u+1EFTNqmpb3s0r9H8eB8zxwPhg+dZ4nDh8MmzKdei3a6imRlEXCjB35uu15kWzrFFHjynVk6oxKSWtDZm/ICn6raq23s1XQqaM7DbUti1tKCHe5KsVqyaKfGaWZYMVx1TDKF/zPX3+q6tQC8QXesn9r5tBm5SKZ/dDv1+s+NWjb1i/KbbeA2i3e6uVgL+IpRl5nNtfGdzxOPeTu/TBjaUuG+CSg8oEHDIYnOoEbU6Uus8fvg/fOagJ1pAAW0Dbz8sYAsHAMaZXp7GtRiZ8+hmg2JSvpVk8PrQk7L8P9Vje+YEiY00qHBJOClUAuAecpk4Ms3piq6z4ooIYB53ng7fGGT++f8fb2hm/fvmHGqoy1KGIHv1jCs2nden/qJ2Obq9PlFpOPF9e68XSwXK4sAFnx9ou11JruwmT5RqB51jcWcyyBmSgrBjdsMbRiYC4QWDSXG1ApW52YYTPSYsDbvWtMxmvdRitYALSXUhrcBDYcb2/v+PTpM06df4MBBxUJzyqNLMpPVZJK3oP8Y4jZUQ3JpOfO0jAzMFyWUJhKJU+kBVxejLq32VTJO6Py5tF7bpaqtiYmFrSAuNsqp2cDiakkdtFLGCYC5lfLoBDCyGSv75mJaY5MV2iXrIIZSkQN7bjyOEJrULkvc6JQS4JAjoO8OD9jIm3IC2MIWqHBPgUXuxxSGQqDOy1AwwzAJeFQfI3FGKgFrdMxqxyuUZFjU0VD5a6EGLjlxMyE26BRYNJzxYR9/PX6g9cY5KUDilLT+4YqgIDuWVI/LNY57pLZBaRtyZC6UwbAENji57mErABPN1tEQXSejW5umvpElsYyOmHLL4EP2DjwLE/GMTDmYPjGceA8BpWMeeC4DpwxkTHxnI70ZEPMGs8N3G/ztwWEizNWoZIfEfiP+L5A3OJsvNcNFNa61WrYJrqxrOR1z5YkvSfbcPeRbcOzRpG1qfs1Sy3ok3iTXfelyQKhtw+EDnLjqWU8tbUuLXrCtu9u9/AduizcUSHlth71+uj7utcvP6zLTqnFb2vO28VmjfvbuLfg2v7Ydf9N2SjPn/WqtvRFGbkzCiSXfK/VX2fsNt3UvTYFq7waiMqdLJl8XwzbabZxAWVubuvV+6O9bQ+7PmNV8VKgXQq/KsAdA+d54HhjF/DjIc/GOGiAVuGONGEsjSPLxbOdscwyqFHW6P+3fzteqM9tVGTC8lIyjK3e03zKGC92AzWVTsicqjVxS9mJbVu3bVduhzOBmUgPloKX3N6J3/5PVp2qOIViJs0cRFS1Sn1O6/TU6tU36/rbbHor1gTECGuHshYTaKDSt9WG7lFad6YihtEMbo2DSUJkjlWpxFEN0XRQ1CRNLdqYVyFw5lBMdlat+2xFqcbKzxKWU+Ep7Lg4jACDYJd230hKHRPQrsjumTyMDsYUH6C7cgCIOTGRuILg7DEIdkhwiUxvRur5xASBWsyt7lYCAVrM3s8Tb5/e8P7pHZ8+veG33w48r4nyp5VyoC1ppglguVA3IbM21Dfa4TUVIrZ34F6au1z5SfLLUFPETrlddGRWfddpAvCoAhC74CsakqLTHEgHuRNlpDRv8ZD7uatnlyLZh73mKi5ON3MpNpw/MrvqIRWP+o7W0nm9j4FxPPDp8xc8vnxWWAZ7VUTnxhg9XyDT5ToxORPhGAhcnmT+FZxWzGckcioO3RzmiUiWj60DNj06TDCT1ZRg6p+R204ktaBUeBIH5x3jHM5z5JUQJ8Vk+QKBEdVfZNHjlBnoEH0xKZfznYhWqKeeZxdBnavpJpIhVshVYc6SSR5mldbPs4jJUCnzCndkHlWEy+vBszSV3zH8gMXAxIWZRytmZgyHTJ1XCKRUfo/LfZOWMA8WkMhV/YWNN+NWfcq1X3+9fv46xslCFjjgY8CGCxGVEsr8OFiFvXJPurcMKAMQxsZYAI99u8G28I+ECkJQUUxlZdJDOFf8kGTCSoJOfYfGE97CgWexHWVnOfN1zsFwjXFcOK7AcQTOY2KeJ47niTGeOM4DMSfyYrPJabxHtFwsvvwjimzPcPHtHvYN0dXVtx+Awfxgj6nY0KOmpAQyPrLk63633D9fCp8RrfUw20C04ENz2j1O3/a8i23ubWwqA9n23I7h6XXAPW9AYy6w3G5jIcGFMTa5pXvtj0GtrsZVPa962ayG/fI926di61lm2704j02HRSm+2ULUeq51r6y1FgLlpdu+a0MIRXIt16aE17CwYYEy59zCsGpTTDwcC381qfWWvHhoeigbDSOxsIet9zuvYV3W86hft3Xrf07jURlAi4DdrD2I5+PAeZ70apyqAHc4hqsMvkpVp1VvJes9t9gidcIo30esvSVcFLsg7+8lUaNgGywQUohj0WspaOJB4nG953pIKTjIdUyQ6EbS7QDIsRapzrBoI+FMWM/JAkKmMNFsoPRPX3/So8Edy23DdstDkcMrsOOQa0rrWl3ARaqDg6UlF3NYjxDIraQX07NqfevzHsv9eaWYLJKtJmC8DxshKZhOca8ma6d1mI5j+aIE4HMrXaiZRiQme9MrxpfJvfvzq/YO644nlNcHROIyYBgTXOuZGcmEpZRXYAykO/IaeJrh0EGdMVCdoenB2HxLpnh7WXat4h8zAdWDH+cbHo83vL9/wqdPn3A+TozvTyYJFyn0vpYyVu9jhTKt7dUao63ytx4ai2tjMe7as43RFSUZ60FHWSFywl6J0kRtm9ArelweDe2DAeiSsXp2+TqpF/K9BKr0bim9u8Wn7NrFVEsw1pMShpaJpahaqSs6vFIlj+E4Hwc+f/mCt/MLmF7NwTkO7mkCsMBptKbOAithS9CEISzEs1wRZ1LYFf6DDHavdmdDOhiuSECKBnJIgE2UFzMdMGqsCA/S2qQ1PkbAZu0gK5oxTdUwFM9J8lGluSk3cyloSHgYnjAcVop9dIjybiCoZo2pHJ6qxuw+1D3cZXGR1yUNZgo3QaJClFipNoA84TbJYmKuOFZZpu2icJoIDMYfcn9l8Z4cLCwNOVx7ERildJSCqxLUTJiHSg1v1iVHJ1emp4Ir/3r97PV2PGAIeA55BZ29R0hJS7L2nm/Khdg5e2SIVhLAVVKZ59gka5iDs7BrtLxK8lLVoUdZ/WiSxQ7GodwfZKqvDZr3xADsdPiT4VPn8UCcSWPSeWF8P3GMB85xYY4LcUzEMTHPAX9OjGHIuR5/C12u180zXWpQzaJFNhYC3IZuDCU2d4wzkXMiJm5hzCsAvfjhNndtRXH4Ja3rwRt43F/yAHL4td7b7WrwKAn8+jz88Vhq0vvXNgtx4YvKSWkAdlsbMfa0+5w0mt1Tkj1F64Urz/qOjNY36r++pmnbhAs7lbF1n3BvYW7PvnuUMiXFb9ZtjS137LDfDwrryZe12+R4Y6Idv6HHsesJZXnnVqyNWMu7Rbb03Uq2rnGvdgPWuK79jO0ZWUqJZ/s1YD5gGF2B9BwH3t5OvD1OvD0OnOcDx3hgjBN2Hjz/LiOx5EPts1V49/ZeG0/nipAoRa8NHIgVwWQgn5hAFfApf5hNwKbBygBlUwrn5r27wx7+XWJksMeUZSzWiBXHQZ5Xm0LsWXhjKXjez/5Xrz/RR8PqfDXTLKLeVAOsi2rEgvy5kdmuiPR3NpWgUetGMMACgfXs/TlNMNuhakbWt1t/AARroPAY5iwd6gZgbCDGUE29XBVCCOCj1cPybUis0eJrYGMxn4hIrNKeC+SGNpFWfXoY4Kx8NfuuCQsqKaRbQw5DqDv18IHj/YAN4HFoj4oJVThLVi0jA6opHAheTM0Cx2afP84Db28PvH/6xH9vb/j2+zdc07F6K/TWrm3G2h/0fi1gf1Rt6lznoPhvWfepOOzcLNc+NcwtZsQTUiV1ufbWh9iQDbgrCavoY1cMRzEeA4GjLANVTUw+EAJdsy5ZSuEgMb0LM5CGahTVSOEWh9qAk1b9LqvnTDIbx8Dnz2/48vULjnHqu9HMxCQYWHfuAnDBcAJmyico6dhLCMAwjSVxLamYhgPDqIDMKfp12d/TWyFsmSYG5GWVNwDKzzCB4nLJ0nLvHScaA4CZPBs8V0PhcBXkMuVVCiP/CgcuC3oCkXCVwa3EUbKgQ0Ix5I2w7rOhx7NylPY1QzkqCCVmGgwHzKaUhARssgjDVFEF3Y/5VdzPacqtUjcvi02wqAlgpQlYlkThHMOSDQvltQOkOKupEvf30r0MHSP31+uH1wMOPAYwqbwRPPiWwrhVt+vM7iUlyIeDlsmhUKcDS1DXMWq5xzMxpZxAnMkj4Vd9LxU+se6hx97OJg2Yg2WvvQw21oavYxyIcSGOA9fbgY+PgfGh3hrHiXkF/AiMZ2AMzSEnLKITsJfc3cbRY0Hz4xvEfcHjvN541g/HeAwcCLXQ5LO8wtFq3Vpwv4jq7ffbYCrcs3hN7lg1GybUJYwS4B1378Dttenn23aud+z+vZYSUhoqRj4VVrvrKY1FfnzqJgfW0u0ekzVN19R+Qiu+/rbtjvmyW8KvL09/XYz9+1jhX5IVd/m13fCHqW1qXG9k9vvt4d9wQaOxCtdJreOoexTDB9De6Ao9r/vYEvKxD2BTMu5ThUE9b+Qx7pw4bA6wMgQ44AfF6bCBw+m5OM8H3lXW9nEcOI6hKmt8RUifKE9XJhQvLPyt2VehElVNX3IDMDiqfqxPRTx43Y/NlLlfuWhhAObZhrVKhO+mP2NZQ6yGpM/jhKJiihZyo4HyeGmCpUuYKyRaSpTROJj/pgHsz3UGbzJdYVRrVDs45C9mdM8wZGFZe/uHvlu0lgID9CQUUW6a9gvzM52wZXiorsw1uDvo3a0uDYJ1H/a+U+iEJVKKQbuaHAKMHCzntFTPiQKSIhwBSat0f4Dxs67kVoNyD4r0A24spuwKo2IccQButAdbwuzACFlDM4AInIfBx6k5WIPK6peQNYa8OqNgKLm74servwUQDJ96fMbX93d8/fwF//j0Gf/49Xf4xWZt2a6IIrwf5VJZTmospgxngr9ihFovKza72EVudJNIVVfgIaruvfXcdlqUJyPRFvJyq1uBDK1Ju9sTHbLQ7EPj8VJa9LcVseh5BQoq+L4UiOL8Yatvhs5mUc4mQ6phnXdPh9MHHuc7Pn/+Bb98/YzjSNHeXtVmwmxVokqoLN9Ul3qkqjbxTPigFT/UqA6ZsJGkIYfWmuWTyzMCY+x7hV9xWqrUkVQM3ZyeD619wPvaSthnrxioMRkb3jEJlmMLMbmQZ8bKWzVYnpeNn1nq+Wp5xM7eV8FJMYjyFM0wWV+1T0HrTTF8rzUvRdK25nkGVDnoBM9fKZZkrVJOIjD8QiSrR9nh8OC+j7HoO3MiXcn1xdSD3pYhSXw4VUWSWGL6RMZQlas+Fn+9fvKKHHApGc2rR4HEBDVdGomyBSVPHUMKyiubfWl7NKc1k2n5U95tp9EnxW/SAjOhkKvsZ1f5zOI3JQeZZ3QCORBRjSUlaQetqqNixX3g8IFzHDgfA0cOHHFgxsTMiTknRjJfY2Qq3lDWykAr4C2rZa2+yWvknc4abJLnmOLXGRY5GM5X3mF5/5GKeZf3sFh6OYqKj64O3BtUTPFlLHDaP9qDjuWlqfH3G/XdF20A65pl2eczqcgnq3f17TQWiYzqQtd7I964rxy2IWwj3dbSeg7tkZHcLU/GHslhtfwvsGrdMV8kid4rr9tuzF2wZa2B3mvwj0Ua+7PaS99rV/IntwPxooCVB683vD/oHw3OE4DwUg3KLAWcywj7wvwqyiGMYNu20dm2EVhzw4ZwWkZ78QFT3zTmSR2H4/EYeDtPPM6TYVOPA+fbwOPhOE7DOLQuFR6pJV8J2bP5TM87obIlEHZUclYSB9AVz35NPWJ5ukum7p4pGrwpFxmKR5lGHUVeqtpTjbGiazJZOr7DraoxRy7DCT/jue9wgd7Xwm4b3f6T17/v0VhaBZj8iaa55gNFe17XFsNZhL7cnbYOkx6wu71q7BXjmvWQje4W41owNdSRsf+uz3WxwRZf6qsMsAM2XBZjJtZhsKqPuePmzjNqklRD1A35B1DPTVqx1yQ4Gq6YNug4UJ1VoTh5Qn1N3h1jDIE6LXAA02U9tsScH7jCcbhj+IN2vDDkGOh+fmg7AxCGYVQWWM5RSqNKhAZU7ejtxKf3Bz5/esenz1/x6dOveD4/EDMwq6a/BMniJ8WlrNfaTLHQ7l1GdWtajTo6RR/FhLkL1bei1Gq+nxtTQtrqvNyKTergllKi8ZRGUsMsQXijpbptib8tvn+jF3a4Jg7p2MmNnrPvKyVbwIUN6GwxO0C16MmEmIB24tP7O75+/gWf398xqm+E01th8A6JQ4LhTma0jqoCD89i5bIEEFRgKwejGvaYMd+BjerEXIKlPh1Ba74F0k+CiGZGqvAVslR5YgzRXo6murRy9xPWkUYclqrFlEfv68yEjWBoRiRzFCSQhgPqGgjGalycgzHK5ZjyjMgbk5PPy2SZb/Mq48w1D5ChHzOZ9+KTHaOxwvBmKbST1O0ecLDSVeVKlQHFAFShwEzDM8D+SvJEtlunwqeQGHbBYZhmK9+KkZSIHMtdXUaOv14/fYXKCrvkS4Z1TXlDKQJl6CpA0gKm5CYPA5vFrHBlWVCXfaGEr4SsjBEJQzqFtyXUZVjCf6AjPko2eUoplmWQHq4NGKjKlI8DPiZ8qLTtOXDMg/+OE/MIzBm4zgmf/Be+ieDNy1e0uUPxHSBSCduhbC9R88KCMJiB8gJV+C3E703GrsaRKT64odglxndAvP1uCyLy+ORd/O8RENvYcnvvdvsb2NCYTCth2/jqK8LKFRWQWLKuxloY0rb7bRdsz23iuQ3b21rMNzKzo84S+72s4MR6jgHW2MpuG7lBs/XANubtn628ipoTit80riujXoHlDfBt61EYqwDubQ16GuKXuq5Ympa5EGGDgaapm0K8LdAiJ1TEQr5cEkAnetdxLlzCCAIp0MrTGK4qU8eJx+PA41HlbE88qhjDMVbyOCA9SXQog5UJa/XJsfsamYH9oIA2iKQ2tvLFYACGIR2INByRK8QSwol9LsrMza05QI/7JcPZiugQzYTSBpqAC5/UFixFqrAdL6vzVjtn9735g9e/37BvI9RF9fXagFhJxqLkHkhpZHW42URrVwKKcH9kdeh77B0gF/3Jm7C4VwPXWqxOmrEXoQFugh8GH+zOquwFsCRoHTDCXpe3A3A1aqM1l8U869lEtUxCZAIvYE0kDNWp5Fejux7GkA65zMpqzw7Gsq5aImzIO6DP0/CRQbd1cJ7uB5URHud2oYdfGuFAlSlj0VKFCZkUoDFwPE6c7+94+/wJnz5/wudP7/j992+4rikC79QvEadSe3O5z8vDcqjDbjXB6/PXVias6NMS/E1LG1EU+C+mZKmDJKs5CHhN+8Gv0WKUkuCeyzVbB3RRcikARRcoadOd1SNpLO0yj5mL8evyMCqhq2fHVuF8AykteFlujPR3OMZ54v3zF/zyt684Hm9sIiyCjqBpdXlLyieiPXBnFSl5MphtUO7XVAGlsobJihNQtSdX6AXP5eCmYaQjcZE2wxDae1a9ov+jSjAzz0D9WnQqyptIdZu+5rSTIR5NCgx58SoNDcBDISkmZcYSh7Io60zswTGHAVeUpSeWAEswNDAUWmL0g1jIA5PG8MaI5YLWhrmKv3PvB4DJEBlXyenJ0rtedBqk88uSsbiV+KfE7+qVQ4OHs6KHTE1DzQfL404lkAPZAeBfr/trxlz9exSKAnXa7aRFa0oT/yhvNFAcCPpvZCwaMKBqUyqdCSXLkEbvhcohh98wJZV/CXYAHX5nAHOiLGGYbTns+1o1CvNV3vYY8Mm8jeM4mRh+TMQRCCkaY07EdTGsEajigujKVlmSevHahYcXRCs+Viy65mLie0Sozy4ygcxWLKoEaxtBm9dk78Ey2twgMRpkNnrED8pBM1rDAr/7x+uL2+2tAfruSdFSoyTFnlx8g8qNHxYQK+PnDQbdblwLayhlhX+uCe4VDtvAtpD7Av73G99/Crx3v6q6ttZqR4GNtXrTl63tZS3XHF435HZBTzxrPrfn778YygS8QfS1Ftt/Uo9eovhlhwsD9vr/iDMb51nRcmEHu9GyeXkz1C9tHDiGlAspGOc4cB4HjqGS0+7twYfVnjbV6c2xwu96CdbYskK2tj3uEKjtXhv0adB/X4/s+6To0vSFxCrQYpK/tR61rAlbeKrvLVovYLMNiGHL27XZK/5PX38qR+Nu1X35fCOI/lQH3PZPmvlooXZtfyfS3pFa6CIyAaFSUmohtvv3OUoBeWiBihD7dFk/z81x2AHDQUZf35dpiMBwlSRNTLQFzB1MCgVQ/SZEMMPQigvPeHYjRXcprmlIHwqjsC6jZ0nD0WGyIPtQrGjigGPYgfPIBvEEdaxW46iwjZoz+LCgVZsEQ1dYgfzM1PlIvD3elaPxjs+fP+Hzly/47bdvuJ5PzGA35ToMxRRCm8XSpNB6OYqJuw54UW0aFJts0gGpzS/ZcBdQBeprP0kHwUPd517/rdCrogloMQTASyCWN8SLURv6Lmy0Q+sogaHu7rv1yxhrbwuEMKVbYV+ytNaZdTG4LOsOyPhctbvHceD90zu+/vIVX758wTmOdb4sWSBAXDRjy7tEwIbCjnR9VRLJVJIpIDpleBUCyAgCpAomMsflwIiEO4FuIGEqqRzGkquezO2Zxvwm7h3pz1DgmSB7BGA+cSWRmqUjBpVpR2AGz4DX2S25kYHEIbMUs5aq503K7Ww5pBAxcRvpSgZnDxFYYviFZVYGAF8RUqUoyiq7jHos9cyP2DmcyoahAr5KkIR4CxPPqWwzqiQVoZJAOKY5DkvSMYwJ8+Jh09hhKUthhzxAAgZ/pYL/8WtmMB7aBobR0+Zq6pgoq2UJ1FT+TgG7ApEC95aAeNYtKKAYXYBFFLx4KsQr+CreZWb9ZmJ5OQpyuva0aqitEAxrPpg+WLpXJW6df2CMA49xII4TcQYTxeeBeR7ANVi0Q7RfPZvIJySvUABtmxvuUv0Vdpi+RGVCIYUT9Mg0/pOhpm6Z68u53Y+O5VrbO5ZoEISFw3hVNpYosFpgvhvkFubS7/wpPl17t036Fu6j/1QehgJJFkgtS7zWYCmPdyhhyF7b1AfZCeTlzdSzfPOmaU2s/4flIdkXrzHSkj83rNRycDOhGTYDbfb6FK3uv+/ekfKK1eNvoXA1FFt7ZhVqs6Dawh8bFoTJt13zq3H0NCXDJabT8kYThDp3ZWPdarsp9vNImVX7V8pFKRrDKipEPWzUmI9K/YlDfW3cBj3u8JV3kXUGxEfMOpkbpQTm4vvVuNOSOYB0LWjMw2XsMEWKc3ErVzywrBkMvxe/StGEDB4G9lnrwOoAqj1AYa/VWFoRM9sceJUteVz4oWnIes7bMfrD17/v0dh/tzWU9ekKb/H9wn6JzDfCvZ2mIlpYW3stl+C/xQqKKksRWHYibKeWD7g/Yh28Hr8BMIeNg21aPRUicaAKUBV4gE8CKcsuY8beEmoapxA2G4VpQ8AvYTZlwXCkOWvpq2uwexKABcEmbMWaM2yC99F+ExK6wQ7DeT7gw3DYKcUlYTm7ezJDx7guZPAGdi5mLwbowPN5LGHmZjjPwNvbGz5/+orPn3/Dp/cv+PzpN3x8/47JoHkG3BTfe5VWZvBx4Hg45vNazy4+JlNzMe1AxclzrHtceoGtElg6ZtobliV1WDP2asRXQymm1rGjsnwuixtuXglDKrRIzFH76i+MtMLlSgnPopU6fHX/YrJWyqiEl1y3wxSPfZx4HA/88uUzvv7yBW/vn1hZzModC7ADt7MRo5RtKmsVQsJeEmaBagBXJgLNmowxlmBABj02MCCoxBrU46IWfGSvaYWMRHmvkqF0rv4A00CwX9LDACTzFwDljgRjVMOT60CCwkRihMKcDAyh0oKfUeFVWCUBs4Sig3k5VECmueLrk2WcrapfOaYNhKlbetVBD2e1KS4BQjSFDPawUXhOZqo7KoU3LVCJGKnqIJUzImVS9B4wHDkFAB0RVGTgwIGJCJbzrTwDHs0hz+YAe3P89frZa4LlgKtyyxC6sOIJUYBDICAB2FhWe6dXajjgF/ljWiK15jnF/zOX5VhxWtZdnuWxzop17titflUFnOaFDR+y6cQTzOMbD+R4Yo7EdIZQ2XHCzonjOhHnRMyJiAs5HXE55hiY48B1QGFYpVANGUdWSMcKT15IuYDbwrUF3Yp/1rwrl3FCVpgFASRrouU4FoARUK0VA9CGA2C7R4Eb24xl1lqbDH2b2bOqgdRaFzNvUC4gKD65Ayqk9XkttGu+gWB5reys/BTywQJbTWPa0jrzVUGwPBVtx0ooj5LgIiSTIqLX0gqc796X3GRs3WtDYc0z2pNUwnLJon0rUM1D+177Ntjt7/peycplc69xrWXX0dtepTjrzlqjFKf0LUSuF1FntqxovcZ1dmWgg60cvDLeVQ4qb7VC3rtyvZeSweI+nqps6I4D5T08WsF4PB54vB04304qIF5lcG0ptbUUGrMdIM0VyzZhhQqNMk0t5UmpsVUjILGQCOCyxIm2xZLXgd7/keIhIeVUHtdMYFqoMEtS9joWFpXim1rLjPvaLiBUmMt6TzNlHS/z9NIm/+nrTySDL2Is8r4TpCw1WAd2D0GoBJ+bFSEFnOqil3jCV0dRfadAyHp+3hmkNDcd8Y5jXIx0MbwCfMOVhF3vy5zi0haLgZSiNJShMTfrZtXNZw+HsmjXImwWERC0XuqZIPgFG0MHn1ZmS9WCkhWVQAbwY7CWe1II+jg7VId6j/fqJYIubvHI8mSYD8yc8MlQllBJSAMThjMN5+PE++MNnz+94/PXT/jt9y/47fsHntdE4gNzAldEg73aK/K3wb4kuazuvnYL++5Jzm332UVdtsCx7QkFEDIWVXqffBTXb6BtW34CoOXYmSTQVpdSQCY2Zq59vCmoomvZnmFg3H4ndtWBxbpuuee5pw5aUl3x11++vOOXr1/xy5fP+PR+tJWwwixg7FLvmcBIMDmbzeoSBERMZUhEOg6o5wQIdqsqRtYOSOhZJis0eYET0rIFq7FlUMicyRozEwoXbA6EruDEUq6l6LGsbAxTPhKV+cBU/pnhgLErtzkbA9lEVDStl9zJ3oOysjhYzKDOcedY6LnpCl8yg8UQLU0MBEJhWZDliIwZsFmeDetqZgnmjCS2AgNWLeBofT6CiksYlPskJSwAepFE9WnATNhQ/47mQYkJVyLtJG3nAjGdt/XX64fXMP5jQOviE6zcZH0Myf+NZ8ZWfHpLikikDdJx83Pt0DBq0pHIi7yD5U6xulgLaVHA896A1Ak9UOTQeQzlOwmgIheRJnPSEfDrwuGG0xxv40AcVDjiuDCPA2cMRAzMaXhejsd5IGfCj8DTHFcw1wdS3lNVE2ld/RlNFcNan21BBzAAhw/AVUI9Lylh67tpYNnNWr/iq1qSKCBsL89vXrneukUEaZ1LZ+jIt4qTfUHHC6eQn98i5baJFR8sOmlLvp43TmAcBuBg0n5w7WJ7JhVN/m1ugB/IOWA5YWD1uAHgbQCPwdLd0wYmaHSwKhHaxlMptVrXAvGLskoObpOucByUIrkRvnhmL+Dra/dEbT9t/482sEPv6jnba41uYbkSl/2LoYF6Jdr3BmZ9lutAY4vWQc2Pa56eVedhm5d2MeW9WLfhd0fJFvbQsGGAOcb7wPl24PHG3Iy344HH44G3N3UDPw42dZYXNPk10oIZQygrUWxfkTJYT6NNzsDnliGql1iHQ951emHWefCxVpte9qqwJ9U9y8shL8ZEl7UHhGEcwGGwaympTfdZZ0Zh/ftOb2ureqU6Pv9eWO+/HzplQNVbbgUgVyhDVT/YlqKJjPRjzTSqklApFNWUrRSAsjrfHCLbvTvsAWji6mioom+sRayxloZSJUlri4cZY2CHAe5IG4zFr2vMEKY47GIooAfAxnbUNd3Y3OA6N4sryt8eseUtiDarIznXxzHSWaWMcVwKFxOzccAQuK4nCfw4MYL5G0xU4k65DVgmrgK+qo40JtpyE8b3vYSPPXG44e184P39HY/Pn/Dl8xd8+/IN379/w/XxVGPBRFypnI2lyLFpmgEeqpZgbKJVhGkbkdd2V+KvtklSEbXSTQHFPFxAEJXknA3uXAK1DFjsEg3MGU2TRX+A6ZmscAR5rLJCDLDY+ZIrZc2vOaca/pUQXR65FYfrXWmjaMIcqtc9cI6Bt+OBz19+wS9ff8GXL59xjlMVHxW6NEqxClzD4FMMxh1P8LmZZX0ksKF7t/pXMNTJjJI5k/erJofV5RqAvHAETZhab6g7OBxVwWsk4JG4IOuSwrACA5YXfHD3OmReezEmu2hPCwSqDnnguGotNf6WUlzzAEhrOiuegGMg1cuD9D14jueFYWqgJ/Qww5V4PSTcuU/DQ6UKlW/CTDmEhaIjmctRipolmJhfoVeBLp9IT53GGNWcaSCkME7Rh6sqVylVnqCno3hGUqHraJ6/Xj99jaQRg2eNIB0KlyqeDQCwbC9kDMc1QT44wZ4lkDAuYb9bW7PoEZgkL74tPmKFCSFFRgr/SFNRuuzeFhUCehoVpFTVjpgmbxpUNctpVDoHzjwYtnidCL9w+YHwE+GBHIE5Js4HEDOQZ7YiEcU/AACVe2I7bl8ylMPfJHijQpQn3qCGoO8AvpXcAqqvUkcX5HZDneH2BJcoBte5X4slNwyocVndqsKlNodRam83VNyfoWTJ9neWESqXtb/Cm23/KTZ0JPAAcD0AXEBehmQVEH1/wEHDWodBgN7VLq/uVNDeh+PLYfgdht+TIC0QlCegTL4AzCpTCrSBdgG/GuH+6kXtOdLwVGusULEkjpNbjXcRNFDaZgPd1B7IjHNTPlLCrre54VXe9r7lX5YXfO3RPoOihx/mlWsfJKk2A5DGve2a6WalfFABXFgP4cgYquy0mvTZ44SfbzgeD5yPk16M94HHOfCoRn1jYMDXGCtGGcJQaSyvfVDeyGlP0iwaVJQJcnlDa55IUwioVjjvyrEdxIMxWRSmZYMBCEkRI571XDyn+BYjlxN4YuE1eSSMq9E5nH1mIXopGsnE9BXCnqlczn/x+vN9NAqkafIoUF3rg7Yh/+Qe+7m3Hz7U15vIu639y+WLqS/mDqjRVz9FiacK0cksa/ICjq3MmK+u4MnQqWEHFYqgP7LKxvrYglCM9+baWMdxQrGXoYPvMIKLCseAYWa2cOzYueTkRnkkpK0Xo0r3xdDTMGcCduEELd8sz2sCSAMZwLB6btEyKwkdCiMJW9XmLwMOWVXDHOPxwNvbiS/vn/D9/TO+f/4N335/x/Pbd8y4YB+peGCOmzKMChjMcBwnLANxKZ9FVsKMWncpFw2iFIKUJZWKgfATWAFjlzIFHEfCzgPz+aQr1k/4MZg3MSd+OR1zOL5PVYmKwIxoOnZJQKpfsoeGlLSyUG5kmrnsoKEwwSpH3EnuSDCoMWXlklBr8wQZ3DCjYugHjuPA++dP+Pr1M3755Qs+ffqEAwcBiEOekhQjlxBSt/ACFUOl/iLIRAfhrZi1ynGqKtsALZtkeq5+1wFXiFD1AcqeK6XQtESq30vXkzL6Zhh7W70+uJYzSjwaMgcmKHzdXf0+RtO+CwRZNagzKijMi9C0SxkEhZeNVBW27C6sF5cEw5PKU1VUS4Wh7fX+84KbIzwwgms6TedmTlX0AhBjRd0ZgUGdTfJFAkyqLlNlF7XG8vpV6A5BHj1OjlBUFEeeCRZ8SDCBPMsb9yM//evFVyhdBkONTM2F96yRa3V4TssOquwG4gJjjY8QpL9buKZpb2zZjCTlYwdmgBCOSj+LT2RnZuu7/ZO8YRepiuaTwu3IMRAjMWZgjGv10DgDR7AK4HEGzkzMOTGT5/5AIi96ykhvK2xLUTY3OVohO5qcPnEZjbbqiwHkBxaA2faCxobi9T95QOJOybZds6Gu4hkEq/X9BW7aAr/rF+XqnNYx5dlAW4A3jAZFkK8qIu42oBWvThqKVIntK8UwTUC1AJljOPfEhhqwxHdMe2L2/NlMEsegkvaEKndNWLAHC60mKtPcY27zKufjxQ8LpG4TMLTH3Pa/d+9VmdB1FeVqgUpDobssxaQ3pQQCsV1Hrpik9sKmPd4amvkKMe1VLuBtW83GnTB8KVe9vWY3cvLe+F1IC3NpmqZryArUEHcI77nD3XEcxuZ8jwfejxNvx4nHeeDxODDOAT8OmB0oAxZDtxj2XqH7vbYqeR25RXLIaFHXWK/VFqkhd0TWwaGQoAHEScc2bSnYxdoqesCqoiPHM2VQwQA9sMAKcxINW9GcPGc5cK9+V+OtBU1WoByGhR16D/75698PnepYrJbQa8IFJPR3X9Ybveigw9ZeAByje/jF0N3qXq33VeiEBDvqqQJ0VSGKw4v1nQpByNxccPWi9f04H8A4wNhd7/CsJgYvN5dp8TWbScKqsqWu2PTwJaB6SM3IeSIfyXmXXy+dh67m76au5M0QAhiVICiCumSvOgYPJ0xWO5VCUzz8qRC1pxWz0lD8EBFOlNJU7UIePjDfHvj09o73T+/49PkLvnz7ju/PC9cM/JZBZQe5CBSmAzxo5U2QEWN5NPbYW8qfbBqp8qq8OLbVc5zHiTwcc15rQc1gOGBOj8Tb2xse72/4/vs/MHPg+PQGhOOID3awTmfCqMrtIi/WnncmWzLBuph1xVtzrZseFb5UBZKi8kVQzLuOyfJ88GzIioKViDbGwHE+8On9HX/72y/42y9f8enzZxzHm9yrDLFhKE+VQU0lWKeagin/IcQQHEAEhtGDAaO1HhPyWgHBjnsYpkaTpu7eaXBpTLPEvYXMM2roZ1TYYDV3KV+VRKtEcigsIAT6jlm0vUL7WF+fRoErEz54dKtkLnmF9iDAMoR1ztMFdnQ+EoBNWc8YgpVw5PAN5yTg1cCtxp7wSdQRsufMXEKQHh8enKtOtTlG1rPKTc/xuuY1ZehwOzAbMFApGsXOEFJeBSoG86QCE8OSCqYHrr9SNP7wFaACICMtmtWAZ7QrAxvBCmW3kv2b3gRikp45X9hUfJsKdPHnDVFh+fiX78BgAqkCxkLEVWKbUQy2brOwIqdg9CKmO8IHFWH11fDhbOoZQ/8OxpXrp8/AUNlpDp6Krk8qPIlNzrSMRRtYajgLtNZp4eAigXxyTpEFtBg2elhZuXnjhRQ0v13+JrDpWGuxN3nQ1/X6iidkNlhdmkgNXCDZCjhbCWMadoaXGZLGDnl7ewx9Lz3VHJcNIA4oiLOvqem4G/tZPZwa7HfHczpixkKcw5BHNZJ0pF09/srnXaZiFvbYsTTzYko7qiSGtUD3/VJIEFxyuAx41soi9eRYk8jan1rtzTvV8nZdfkOCG0Tr22k8a3/ttrwwa4WAHiYId5EX0lO87eEa5vbXQli7+nVTxW64TaXJTU2Qh+MYDDl8vFPZeDuZK3kcTAZnx/CKz5JxuIzMuQwQ9QqFuFP5Wl6fklG7h7owZpnJGwsCZa/YuMv6DVZeXJ6XrvaJLTd3W2uOZ+M3NZA+Ux1Ait7y2q82xG5sr4wwZj/B1D++/kQyuDZ+i3PXyejmRq0sl3UbW7hUU6cAUS3mNki6xDSdXCRUAqCFB9AlPBtASDhU3Fh7TTTGGkMpELwVASdrJw8l+6Itp1nEVdp1DsamO0fBfC5afJo/KFTE44BtFuYhwhyu9UqTK1rhNmrKAlmdg9mmeJgjhqzrSBxIHO44xoGUZX+MgYqom/IoWKbKd3JM2g01AOvTrVjDS/kRjjBHGDNPPBPH48CnTw98+vKO7893fPv+Gd+vC9eVuGLimgFcwIVoC7+54RgOH0BMemiMjRDaW1HMP1WGlLRDtYrkUYlctB67Of726RP8beA//v47cj5hbvgyTuDxBb/++kRpuDYM7g+EfcfEwDlO/PcvwP/6fbKR2+Mdb4fjiQfm9/+F75l4OwYejwPPD8XOO8uv4vpYh1Z0FZatTKdQTergQ2S3zoILbFKh7WoXg3kZxzHweJz49OUzvn79is9f/hveP32Cj4EYYDf1ADADp6wnlwCoA13x6jB0TwtRJyTrMUvAAEBlnkgZxSzGTLESOUSf3JtCIqFzX+doJJPSp7wPno5poRA8ekfMim5DXjvHkSr9mklq9kTGhA+wX0UEJqquOS0oCwNIcFW/jwlAjRkjF7CBGddM4TOMA45OqCu+0FbTBFhFSBXYmkmU54JFon0YRkZ3iGfO1IA7iwj6lcBIXIkODw1El8zOOpOq9sbQqgPwZOfyTFgShlxQ3ko4LDuQ+a/Xz15d1af2NBvELlADwHwVD0nm0hV6VrTUTV4A62wggRyATWtna1WNS1iHz8F2yKOcN1ThDQ1F3u/O0ChQlQtOMdaaRpsxDPMwjDCWvz4cIyq01nHEwHEd/Hc8MCbkyeNcApO5TDorBbJ3fL5Nd8OBi2/UeLqEaZaCDF3jKm6hG+TtRtjv3LcAXjapLKk7clkDXGHa22dt2q2/799pKKxrzAcTfYdjpuEZgetiX54CXVVJqzMBbMDPA4k3IJ+wmnuucZtCpXwk7AQAx/XtAF0X21AMiHRkHmAY2oQ7DSLzeeFq14CjwtHNFXM/3hD2BsQTyA8grzZSFJj2Chl0hx0uBTphU80qTY1zGaep/RKAylrjjRBsH/z2ns7LZqhfIDhtQ9LbvhRuvCM7LE/K2kcr4FuG4gLMhVv00OV10T9D51C0sNLP8rwPgWM3JYGPg7kZjxPn48R5vuE43niWxsHwcxtNawXC29pfCiG4lhnLALjiMbbzX9jWepZoXF3RN5qWm5SIpbks6t7k80bpvJuwNPta1dqtPSTOJl3VEpZxYJ0r/ZrgfLJ43ir41EVz/sXrTygapCTBxb55Dd7rnVyAvpSMWuIhYqulqo7BfbciiFYQ6ujbLe+Az+VnnmvDbvrP5hg2FFhSDwStLJUUhzsZz+F7CVYSuI2UZulSaBPT5OWUD6b6GVxN7I5StgB0wlCFJBUhMXmf4HAoSZabGK0hh5QBJGThHkg/WSpzGN7Gg9Z4A5uEYYv9bpAkJqIVTFM8fapGTtYqpazASZdbqHLU2zs+v33g+6dv+Pr1ies5Ma8L1/XEvAJm3wF7sgKX7jQEotmNmrTAOH9ZhNTYcJW9S3x9f+C/nSf+v789cUXi/f3/xvDf8Otvv5ER24F4fiAnk6LNwJyD8VCZOsfnT2/wYfhuBjsG7NNAfg/8XXklLBk58OmRmM/AVBK8D286sXFgHG/I+YGZF9wGhgHX9dSaoXgaysXcuTbg8TXbFA9yDFTdbisGdzoejwOfv3zB11/+RkXj8ye8v73hVE5B5KB1uxLBUl24nQplDkdEwKV0lhI3Uc2fVOpTo20rKyp8L1FxxSOqUBMFUBRwMldfioSZgrgKXBsBU2LiyEQm8yVMeRvpTAZ3Yxz0hMlbQQjEsBMpgFYlaFenjwgVSLCp8EXDM3nfE2jrDWSZs6zwGajvRcKcLpJIeZPK3R0F8pYiz2etwFh66qbWUmsY9J5W/5DZMbDiGbvcCxBk6p6Xrb1w1eH1MK4dyFtG0gMYORGY7P76r3n5f9nXcSi0VWA9o/oCgcBO7okUKHAjfWbFwZcwldjJkc1/W6h7toXRL4GL6hlRMqWSlApIiW5HJlSmrDp8AulUOFE9ZzgIg5LHJ6jw07VBJXcY5dTJzuCRijefA9cxVP9/4tEl2YCMxMiJoZ4uWSgE0JpQVlAuCIxrBtYADW3dNCiKwpjHxMdIAXE1ut1CeeoHQeO2oI1Ms99bih6avxaA6NATrM830KARl2dCfNCA6p9UzzQfeB8nvr4NfIfhtyuQeAIRNNpktlw2MMfmMQxv7yee84FrJmY+kbk82oyyC5bTvhiJwPCsAYuqX5r0LEwgBr3nZzgePvA4LlgC/0Dg+SSvchzAOLT2EwMXxvmGiS+Y83dkTCBYDvsC+ephDAvzavZ4OuZ38flIsAulQuCQyKG1UxXJAvtF+e0daI10w14uOmqc9pPNMRSqvhHCD16tfb/725s3rAGyjDEF0De8WPRq241KB3VXVIg8R97eDCpkR+dgnFQuzjcc5wPH+aCncAxVA/U2qrMpJuVRvQcQU5kSEm0be4VaJwAfOw4Fz1/LiLiRdfERqGdNlRgu3TBQrQq2NVUoaeY66q1kFGqRAqMGVSie1Ty0BpGQ269IxPR5bmf0XwunP9cZvM6w2S08ipi8tDNpU0gpEQ3H+mDuvGbxj+wFrE6Qd3bYnGVp0bDCq/y655ZstEi/iLU2jb0rUkzUMY6BQzkaRSAkopI+stT4KmtLL0cqfq4Ohuap51ZGRoVqlCux4roZS6v1tIDBgTCEU9Ad0la9CKnDtxKYZIhxQoyjDHvsdFxjBEzVVFT6NA0esiarQk/A1RkZ8FCDu1K4AjjOA2+f3/D+8QnfP098+XjiOZ/4uJ6YcyK/UVCFkq2HsdmU+rrRVe0OxhJSgcmkWrZ34H483vDp01c8Pv4OXBP/15df8OVz4v9zfceMB94e/x3z+/9DZSsDMRPXARz51DopZAuJnLIkxQM4HG9+4Xld8AwgLhwALeaDHoMBw6ehEqN+wh5vmB8TmAfMD1qrXAJDFvIs6vKlVHDdFRqkM8GkNCatu7w7ruSy9/fP+OWXX/C3r3/D11/+hk9fPsN9oOpX0fk0UInFLKm6zp7BwFREw6xQI60FQBojXVZei68GkiH2kion645TIT8ibSq5zvwHpKmbaCjMYjWFhBSbKvlKhSdgOHTWGLKRYmwuwHcBeIJJbjZStbN0TkElm14uwxOlGNUsUuWlA3BDuMK+ss4A2XYowT9CJ9KjMrnFZ1jBY5jB1FcEEV2GMpMeFsZTVw6KETjo/Lot4XGlypgGMItB5SrTa5YYxj1KAz4U+mnB5PpwWZ8nvR8WwYaCf71++jqrOZYt+ssGIRLyskL5FFvMkkogwBe/66IC4v0FpEcAdsmSN8oju5SDFjcRVGAMwJi0KiaQKmVb4yLthcIT82att0hWS3PxRzfYGBjHiTwSZwDPGYgxkUcgzsTjItCdHlt8Nc9y5QG5YIlNg6ucagC9IIX7e4h1mzbAuSzlgvU2YaGSzZ4M5bzJX1vaQ2FFhRpa1fQsK5SAzYp+roGkqko17MX+o3AI4+/ZAws55SnX7tVXdO27A//tnPjtYZgfgeecKv6R8gDIUOT03L5n4osZfn878e37hbhcHimN0Q1hJy4cyDAczwLng2FUl0CqMR9nCjSeR+DLMfE1J2xOTA/8XR5cGwY7lHsZiTMc58PwHAb7TqdGYRnkRt9w9tgKgz9DGJVzG0cCB++Ny5F2IIJhyDa4DyUrDA6MWLimIxG2dU/t9y12xvT/pYTc9my5Pvr9onzbL6swrb5+A8rayCoMY7blZPStsz1sjedUJc4Pg58D4zwxHlQqzvFgv4yqLnWcNJY+Tgy39gAkB0UacXrOTQV20khrdqTIIlA9NqaR/08YDm+SXlpbHMjD5NEWImoF3BYe9gpjWhg3QZnR2LlPoCrMacy9DUa+Vc8vKG/y6qPu6vK6tydKY6nqRZsC9K9efyIZHJ2UsiZSiL82YtN7mzHk/R77L1nX626liNjL9Zxh0TAK1ls3WxBL0YYwzCnbndgMVAChwAqk2R7nwdApH6jjakINaQe8GJDuRwLXYFIJ1XqvZktvB2c3kgc1ZL1sotEaOUr5MdV0N1prqT0pydhgOQi1LGBxIT4G4gSqIsgQQbnyHDp5Sgwucs09bQo88nNXFaGSkTMV+zwMB068nZ/w5dOF+RGIzx/4mBMzLnQddTPM58UwJ2e1q9MC38GY1ID2RTUBO0ktE7CB4zBcV+DXK/H184m//+74wK/4+PaN1aIAHG8H7/HtgNsTOA98egQivmFG4jhOXPPEEd/BXtaBZ1x42Bs+DMoBcNjxwP91PPH7R+BbGIaKFf/2pHHn69sFyye+2wDGG+x84MQTTwUdfOBJ65UO9qqi5qjQBBazULiRLYufu+EYA+dx4O39Ez7/8gVfvr7jyy9f8eXzL3icb7CDidIGKDmb8ngY4TxDk1ix6UgHk7mrkR8PdUVFVY+WB7jHVyrvA6l+jeyu7qiKILKQxMaASqAZ80OIwQjKMwcyJ+TYQPoUsxzK9WCPibKPGZE0pnVtKqQNetAQuEZ2y4iRBC8RhryAw1mGdszyYhCYJ3jNYdyfROI7VI1IZ5RnP3EZYBM6XzwToxowZtL6nVOGBlqQLJeHI0vOucoKbzG4z9BY1M+EeWdUTEJeD1Pn+ikDhlc8eULXV8I4g6jNFCrWAuCv148vGVqENjKYZ0vhaVAHKwBSLmrDLnQeUBqQ8hpW2CkALGudAerpEruFN3IVs8hkJQKrcVR4jcBJYW6rkdRAKqCvZEMCXoYMo2FCxT1sJA4Hzpj0KpxSqCMwU1b5QUDZQCATOWlgwTRMV9huTCCu9tYVpmuwIdlQ1mBayw1+GuIyeTk178iF5E1gNpJej8YqS8BnFLBcAEh/rbVoBQT4cgJfJPe/peHblZvXFjIyPdgHARee+cHCH3OuMrQ6ux8O/ONT4tv3iY9fA/F7rEQehUOzAAOQduFjXPBPA8+PByIvFHp1AQvDwON84P1Bz1MgEZMPTBuwwdLXbgZ71yBmIP3Cb88L3+Wd+DYnedyRmDngeZKUPDAegfOLYf5uqyHjohDaIR3qxcAgZMRUURTtzeBPyqyBMEZCYJSSOYEJGAYVW0xkzi5t/sNrQ/a1lTsobfLeoqhKMSj4FC8Y9aYsJG600V/aaWn/l9tNFPXe3b+lZBwjcRyO8zhUXeqBx+Mdx3jDeTzwOE88HkwGP8appsgO+FQBAJ0HZk5jJo24ISWNk9I5lrEtgzLHDw7OK0qq5+jI01BVOpkytEVF7EaI4mM6UykaXHl+igjSvVdhdWLA5gkjtiWTDOtIm6ruGKuvk2kjh5VLkwrWVA+pf/H6E8ngzXc0ydYSFEa0lI2+vg5iMWZxsnU80K6aesdQnTW4wEVnmVuyEGpx6xvozajSZ7XAr0vAzbXF38wwqlmfuj4yUdO4rlBSta+5VGO8LJ+FuazDmpBV3D43PhKszW4EpEPqTmmbDA3D5vFQvslYa+5mOIbBjxPAiQsTbsChjXd9b04qB2PIzZh0uZRACGNnhQRBnAfjOKfykEbKeSeGMZzrk4/A26dPeHxMfJ4f+JiBKyYta6pS8HSGNaUs5w4lmGutV4gW6JUwEvtjDHx6O/Hf/9+f8bfh+B+/nvgFD/y3//6O//E//o4IMofffv+f+P77d9FQIp8Cbo+konV+wqdPnzG//4qIifPtwPtxYn77hm/PD0QaZlDt+X+ehitTQIR9RIY7YJOWCHsi4kJM4O3xBmDAT8f7MPiH4/vzOyImikLntk9whq9RQHsnH7qSz8Z54O3xhs+/fMbXv33F1y+/4OvXT/j8+YG308UseLBNwB1g8jrjy23js4HLWe3oMMX2g8qtz4AfJptmWT1oyaweDbYJrBSDcbD62tApigz1eChLu7xTUOgRALMDyMoxoOeC5zME9LKrpWQyvGBKeadizPARU1xaNUZLAy6bLPs4QOu+kR88k/O0XAqVW+KCyooCuIIhIz5VhQqcc9okjVL73dzQCl409SoRo2C4RJUO3JUtsASuKrtVLgpp1Nm1GiHDA5Uzg/CoB64wHMICGBVWSs/pNEPmXIUb/nr99JWu/IVJnjmNPXB8ko/blep0mm1sAhYmElsiXMsqBcFPSIYL/pZawDDC1HecSimAPLAMPFXWqBQL/eT9bQMK1mKDjyGtVAi2BcNzwxJ2ODwc57shPxzxHAhPHCPxeFChiIfKqloAeZCG4kTOQJ4XMCciGH5aZarbyAeUUNZYyMldsm6kdVnt6VB3cMq54ikVDZBa48S6XfFuxRuhGVmvOZa3oP57nPj8duD/dQ6kOf7zAq5vT+B6soIcAPMHxuMXPB7veNhv8OtXfHw81cCMsppy+cTH8w3/+M8nrmvieioPLND9Uxyg1zMT8wo8n0D+BsQjme94AR2jb4CdA4+3gc8Pens+MvHtWyDtIp+xhJ0D/ssB++UB+xXIJzCn4eOD/Drg8AmczjDNaRdgH1rLiXEB57cnPuJ3JC5WAbQDaRPAJW+1GKYKgsTlLFZjV1kNYeNNocaJMRL5kUh5TAvg4gD84RgXw0JDuKXi88lDyd+sTwWWYsFNvBmM7XaKFmZEko76UyHpDoHaFBUkNg/KfjdZ+Pt5xB9l/K2QKRZTODDGA8d4w2O84XE8cL6fON4eON4eeLxJyTgOHI+B8+E4zBXyvj+TJzlBDx17VCQVnNnDXW7uCmvHeuUNxC+TQ2yYOmVsIvLP1uXrzIaUbSaQiaelsEc5BSZoUFE+WmHRMrjwR51XQ2C0brqHf9eskeKrsL7nv3r9ufK2AMpdfBN8K9hMIFMctIBzMQ0pXZWMtjymuRQQrnwTNvrOwEZLmwKS93mWIrSN2Rx3rXy73sxxnCd8qJK2XLoJVvgpl7xvjI8MVXHTUn4gzTm3crEMgyIwWa41bmtkYrh1Mz0+KlDdoy0HHiJghkMyvOLzcNjjgIfDj7O9MFaAnu4c9l0QcXYDKU82A6t5zER4wH0sr4kaj7mELqdhwDnwng88P96R1xdcz4mcF/tkSHH7/pvh+8fFUOQMxATD0QxQOrGoQSAasiabYYYD52dc+Q3PGax4dXwgT1pq3t7f8OnrO+zjV8QMXAngPGFHIJ9PAMEE6utCqoj1fCa+wBGf3nCND3x8n/h0MjTt89sDzyeTAG0oNwFBj9JBRjXGgcQTkRMeAfcD7ieOkwzy+/M7ZrJ0r5usSihF1yu8mns6HIcPHOeB97c3/PL1M/7bL1/xf335ir99/QWfv3zF8XYCfsCMQNxKsZ0Ho7VSVZ+GrFJqhWwInM1cZZ805oFUutdIWlculAeNJWzNkiF6BfrhqLwhS1oNYWUMozcNYt50ozI/Y2ZgZMqrRowFQ5d4ZiwW8yQAwNXvouurG0u5ZjBPgwV3pyA673FF4gSrasxppP0ELC+skrPMTzkmheKh5lik7aSVrijQpSjK20DvxoBPUzy79dkq8AekCjVMmBliEM/RAWELQDaAMjb1LMxJmcNCCbWfZjjaUKJY3vT2ftzB7l+v15epLGQBeRb1IFAPS4whxV+8UVU8ekMaoIUI1xXy0JyS128qAgxVTtKQ4rXpwdCUBLr7tu4RNtv5q/oNVEgZe9cyNIEuxsBjI4KJoGVWRqTjHJjBylMeaiqHiXEdOGdI0R+IGZgxcMSBuGKFXQpJZCr/KjalSnQLJIsymJKMKz79Vv6ysOHSlDid7Zp6tTwvM3bNeQOXUkRu8CYPjPMN/rcDyAP+K+Afv8Ptkgcw4f7A6V/x+fyKX94Mf//4QCY7bjN0yDFMeSz+huM5ETOp+KdC13px5AHKVNgxgO8Ckrc5KSIhmTuJB4FXfoRC6C651ohG8hrA9wNdCm0axsEw0kxXD5UE8oLHhNkHOrZ+AI6L42W8G7pEnweYmyYreCYNIqfhGUYvNuhlNrzB/A3mTyCf4oXymDbe2RSWpAHZpF003Ezb9gg3DIiiW9GFFR5dmgCqp0Ya+jk/ADnUMwWFTQoeloH5pm7Y9q474N5hVfxHmX4cJ87zgfN8UNFQOdvzPHA8DozHgfGgYZGGMacHY5sfknuSsqISs+ncSt4luD0r3Aqkh5Hr3MiZVjYJr/dqK4oeE6syWa+5/iOlobz23E9rvpKSiyWKSxEDove2wtBqH5jymL3SXSZaFnXi8Vbp8K9efyIZfNvUWusG/rUcL14HhS+1EqYv5QbcdVnfo/MzborMrlis93LXTsSrbaMDQNbSXFVFliOJhHk4m6V1gy1ZaNNXcg7SYF71/q1jcDkndcZ2Q+JA9yRIehsMKaNRhddwnbpHiNbCUjkiSUEzPYERCHcckRjJRlSXGY4M5Djg50ErPED3HajFmkJpzBl6o5g3xie7QmxgKu8q+D9rDvSuzJyAQ0mqbC6FkxWSnp8/4fO8KMQS6qYcKhf5gedkx/HMlFcmMVXdqFqF+xi0qATweJzwcWJeiX8EMI7x/2fv75okSXIkQZABiKqZu0dmVXfv7N7uw/3/33RE93BHtHM7Mz09VZWZ4e6mKsA9MEPUPKuqO4to3yatOyoi3c3U9EMEYAAMBnb8gPzpF/zy86mNPvF4fMfnZHZGlXmMgOQJOTn39Z54/05vb3Xil/c/48yBx/HANMdUduIn9biEMZvTgBfFzMdHGU4BgvswHDOA7YYcgd3V5TAPqI1Tw2lFMTBIvtaVSQlgONwHbtsNr68/4Nu3H/HD2yu+/fAHvH37Aa8vr9iCTcCeU5kFNa26r7VOl9GUBYJSAzgDoriWXMEbRCWySpXurwZGU79HUzrKrk6LlFEbZZTIbfuie56UdALn1DhcnRaF0LNSn5IdcHecfV5JurJQOSeLry3cFMeS/KgAnHiwZZx9Xqp+cDdQQasMwDRJ9vqqpHKQJCsZYY7TnH1RVvBMzHJl01iN2HUO5ROVzDS6le4t1bJkVJYtWgDNE+kGy+DeAdWmoLXR1EgY78/MWvMSwoATKkV3+brobVxT22s58t9fv341+LgcKRBGitDCZLKzHTrog1dG7slv9ODKau/d79WzCYGyqyJCCt7yP09fsvqVjMmp9l/cg+0TLw8KYPkLQ134rSkg6bSdIxDngEfB06jalgM+BsZIViGrMCbVASMTY3uWZlVm2ptKltd16lrdgDU9WaCioHW/quQmWqhxdkU+3bILa/K6Ggj0QXD94GpWvd7Sz9IMl1QrguBGkqNutRI6WwDfNuCfb4bcHB+n4Tw5/C7RCkMb9tsLbnmi6gOHAefqF8EFEMsEEqFKR8HsJJWoLu59Q9tKIDtDLT9S6oNBA/kJilCVczozEmMvjARwTrwn8F48j7hum2xpA35WYtGN3KoAPyuEBYAtQZVCAx4Cg53ZZ3GH9rWsKz36OW82kL78Q1durkfZNECtUWGrp0LUdfJ/6z/r2iILK+oLCvY3P7NgnhYUt6bOy54Cjz5nzRRb/hiA+UDEpmrFwLYPytqGAo8nSdsYg/2eRZy0gPiTHS60zwdWXgmNS1eIwGeox9VVSuLVWs+Mf/gQWlHSILhk9PN/BYJN9wBtL7QkSsksKEh7rsA/PUM+8PqCxVsRj5jUFhtFm/26ol4Qy3b9+6/fTp16NlEmk9OgBW1IcV0Ynk6k74CeSIP9Wqbr6R4+GXT+N9CloK8HvKyZtdVfBu0p8sYTHQGdbcQKFGJwYMviN1obTl5HiEJVAnmloCX07/JcAAJ6AAEFNl2dALA4oAk0l58/5mNOiFKlMmVPOXYYpklxxB2WhXmyo9GGozAWZ78AUBXI1lCV6kBJ9qNKHOMETBmtQlFuFVqQBZhRDvRMLr69gPTAuG+4ITHnA/s88VY0ohnMosA/4B+fOOuB0x0+WL2xAnxqCrID+9hwuyU+P4DY2QPyw+uGx88PHHbDP317wx9++MR//jODkn96eQXOn/F+MkyakyN9vx+B8yg4dtz2f8asX/D9k30dbzfHy7eB+UGKyuNMHPPELQLpG1V/OvOiqkS5YaTjBYaJQNqJMycyDTsS923D69sNxyfw+HjHrHMZ5JVRcoOpbwbu5A3HwG3f8O3tDd9+/IYfvn3Dt7dvePn2I15fX7BvA0lIKoqS1kUxCw+4qOaGmk5wagDKMaD72pkz7dZTaxSQOpSxajaB1Rug2VYL4JpoU3jK8NFB8TmbFywVBBknK6cQ81VZJsViqgTbTo5VQn+a0k1Z1wIw0ijII3WeMlPiWQ3wMOxlqjxx34cA4glWVRicNO1I96KKMwUwl+2aSFgEMMEm3yJ14UQ3myef22nXDAZZqwSwJd3aUQAmKYyRqlqY9rSX+mxktJGaLs7z9wTSv9qmqUxv6TqjEgMBG+w3+v31t1/Pth5QNrB41yesFcrhdekSQTaPstuNB1n9RT45U+0bgs/CGp1YxnXqYJLHk1U60bUaDFz+xqTkBwUpJiWxwtVEoGtQNXGhNmWZDex9CzeUT0RQjW4kK2txBEYEsA0kSB+blRjFwX415goQuibDrH1/VSMg3gtPVTQkNnIFT7WO09BlAdh2z71vFvC8rnG9yN28jtunsAIUAWcvVJ44vzOJhgwMB9KcwzoBuE2Ef8cehfv4wGaJcAVLuiRzQ4w7tvuP2MYD86dA5JStdVSSeNoUg9K1WhTinqh4AHiA0lGXfXT1XMwPwIatgOoLLqxE1YmqAHADfIdtrGjsyemHn4/CnLSvsTvKoy0SHIXde/ZLyR5L/7Mc3cBtIFCMZBXbdQIGQ0SykmEOTGD6gPlcdn09hwoxK9qnGb6I3zBrIp+hdfr8vOVPtTkvZkozV9YDwYo4LoyItQCuMLQ/r/NZa6r9Lq5zfXrgrUR5yUQzgBi3wHZzbDcqTu2jKxs3bH5D+Aa3seD+KraINaKSJdYFwpapgDCULWCu/WK6d02h7/2zKGa2rqHv7fI9+lyJ5s0EhJKJ/V0dfCja6wSo4LjOtOlvOtmu6K5rwgo8cj0inY+O+nRZ62W//sHfeP32isazneiNZFglFXsuq/HbV6Xx+phMnBbbr0+P9u1aXqwuNEjpYKItd9OQ1hmio8g+1q/tHT968d7cHDGYTffuzyiq4XhycmSXC7v8NdrxNBcv+5x4wVwnUpTRjeA1TDk7nk30flBQ5qKPDAUKVraaG48gzx/hsAg4gE0/cwMiBJaMUCjtogY0oadLasFoQ9KkzFpMnQMLM7XmWDwtNZxywLcI2L4B9ztODXFT3xsGAvANwxzfe4Oe7IuAA9MTXgSfZybwKPjYMcoW9echC/OvP/+C//b9HecxWRYeBbsZxnfDfEwMd/gIYN9gnx+UqYsNM5XJrMLnkThn4qjCcZzwAv5423HaRAYlVbuka3MqMHN8t0DZxsZLJL6NHd9r4nVzDB94Gxs+ckr21thg3HcsHKbhfwYpmsXAvu94e6HC1Ou3N9x/fMPtxze8vtyw326srqHWGu2NT3UlKpJtMnAzgEoqixhKw+BI+zI4qlJrYa5KWLlUn4zN4KGHxuLERCRQTqUrGqCggZQTYS7Ul3LTwMQEs/xW2itpK7AF2lBKQliu0GTEoIC3Uw2J5px234R49jBsdknaBni/Z6nvBapu+XJ5C1yUnu0KgIrNbeQ9s+o0YUBNrnuYAnFWZoaxk5XBTZeRm8uq69OXPRAIK+DkxFjonZ51zdspa6FLrpVCh0f847YawhlQQjLCjqsh/ffXX70apDw9eM4SstW7uPofJn41jE8JMq25MFAF9AlHlPFZZEIJGFOVUZnGmhKau5JxBhNFRv+dSmTYlb1fLC6/yENlVw+Io9VqGhM4B+K5I2NDjMTe/jILsMEAOsi3n8XKGLPpE7ZPAUc2OwMUV6hpKFG7LlBX6EnVugm0cU5RhhNMEnyhlc2FXRYwaaSz4qYClpBKBxl2vb+DMuu97cDIxOP9wJ/NMaKAKLwNA+6O4wP01zgx8x0/5YncT/z058RxFH2bKpIVhsQOjG+If/mJdJjDUZ8DlQM1Cx4nwgw5QrTFxLZN3F8m3r9/4Hwc6s1LUFWKay5RmEctadNed9AetlnIOTHnidPusLqRmpqFD5uoOHAYKWw+CrY7gIE6OYz1Pgp/fE18PBI/HWC/jUouTA41fZc25BOFhxUeUzTYMMQohJ/ELCenmM8aC+wue1mGMUCJ7WmYSpCY9tE8ABT7L7tHbwEvFwZ7ok49xyH9swawTz+8sJsxmFqbaf0GKwjtpM4zRjElC000v6b8uQ8qSMWGsW/Y7uy/iEEq87jt2LY7tu3O+RkxSKFVzw4M8guXn+cWSbjmayyMmk3LfQ42RE9SEqIVZUtDclnlZnIEon0DVKRDdcKYNmkh7CVgom1k9Kd0vZz31KoqvploZAU/VSVJULCgyz0olIlamQpQFfSgmFjM3u6/Au6/ZcrTb+/R6Bu5bjSJFtcJtbHQonkyILoMfaoHskFr0Fbp5lpTHZ3JATTQb8hvtf7bteWfQfvT45Aj0Bc+8w0BZi3HjtD0R7ihNCfAwGwVmzy7JKpmWZW23V3UFUX26bDQ9HFxxVe1p6hwRUfCT8T6LM84YRwDL1nNWYYBThAf7rBB+pYZG7RHDJQPfrpH1YOArNxJXwLI6dcE77MDPCsN7qvleHluAU7ZBjeA5VUiNiDGwG5A1gveCD2BWaJ9ODoLVWbwj8IDxoFsWRgCUlaB+/2O8ANugT++3WDbjxh5oKbhNoD48Q0f//VPMv6OPz3ecXx84OODpWt3B44TsXFWx8xPzPz/YN4CjykFJQ98fA4cn++AKEH5eODznHh8Jt6G4aE+ltdb4lGGRxlm7Nim4+N8YB8EtjDOPXi7Bbb7DZ+f74Cy7dHywpLxDQ2BtAhsMfCy77i/veLt2ze8/fAN3358w9vbN7y+fcP9fsNQ8Eij3eVaKsi4dUBYUmqRJLK3eWWTaKiL7IQMrZWalmUoxMVOu2YMDOP+OdFr2TE1k0M2c1kVg6Gb/BMTVcHsrk2qlhzca8w4KaMSAh2V115ArsnfGKRDIWkEK2uVgueT/ZhGGtehXd2UEx6XNiRV7fOuiBTUQEuP1EaUa5RTw5F8Vo3hvY06kSGb0FVKRpXuH6/T1dOS1oBWAZpDlcLCgKOCYKBOptXbSblPMBTU3i/SJUMAUaVPzGa0XK7699evXtWwVEGDHjEMkIy1qQ/HFli6PtyUSaM95DwzdpRVLudOyqCrSl1P/2eXuudSJuSLyoX6dwEhieJUkF1goNMs5072zK5QO/2N4IJoQhz6Oo09XxgbgSYMNk/g2HjcLPZSbAxbvEqZ8EP3oGA28DhKVExVZwBlWy+ZTbj6F4vVzzA2kifqyvYCX+kZ+kUJpPEmfPnrCmrWs7D1LM0MNjgcN9zxOQe+3wdum+NHc/zggXMf+CUF4MaG6Tf8+fvAn86JepyYjxN5qMnZSuD8J1j+X4j/9mf4Xz6Ax8lgzCYw2FQ9HMhQkDITeybuH4FjOt7dKdIgypFhAH5Hxg84IhH1gOeBkKgAOEwctQG5A3MANh8I/ISRnzjxwJxUczynFm4CfgJ5MyAMNhMvduKPvyT+fJTska/gj9L1gLsSnNPxCcOBiTon7WgCY5YCNX4BhTpOWJ0KbgOduYz7wPah4Fp2lNTuE6iJGqT0VMluP2E29POvp7VhoIF9ysL/mnJjT3ulMVoD5xVMoIExlCB43mMc7Mu+HVLRTXOzxsbei23bsTn/jNgZeHSFYw+MjYlblx2w4Xx+SWXDxqIhcG8+YTgXlawSEvWAIDJxV2mXq/1Koyls+djRGLJ4n7rIOFewAgVs2h/VaBgr4OvciIeqPkaFMgeVrryUWAweLGMdFJS4VzrtmYOqYCZLTfuux9i0wid4/e+9/iHqVH9vw/gvX/IUea5zVBhcXeaRYerZRes4HTjhWmANVkvH6WwQf3mVz3Q/GVQ8fT+PVV/PA33sLsk69uEYvb9UCDATv09OQBgeiwhVT4vA6BCoKsSvmmZLuSobgJRTKmxF4oxcuVhtbZoqB6aOJQpNaOAMypAz8XAefzdH6BxWo55L/WYyY5vFEms4aVJnAvBEOBtqE2pWNzq9AivDVF9i+TUBILUA3TBiYOzQYCj2fpQTSIWxKdg6QLMP4HggsxBqvIMNBBKTvBpMH/inf/oXfLv9BX/+fEfME4/6BUewrJtZOH3izMQ5J69p8rs5TZqDzf6v//E/YP9jYH5230zBR8LOieORmOeJfz0KcGaAPtJJ6zLg/XFgpgEDOD4fsGHYN8eLH9jmA9OA+82x7QM/vO74fA+Y6w/Y1E6KVGD4wPBAxIb9vuP19QXffvyG19c3vL1+w7eXN/z4+oK31xfs+8ZMmwxq9/LQkPgKcGcV+fqu7LZShw5mFk+dg+VlTKpM2XWoL0FBQzKTDgUBGVx3mYQs5VO9ooFAEFCXqbYyl0FMKCEyjdk4DTaE1jerBbX6O8zADH1yX3kmp5xbYSro8QZ3nZ0zNUz7Jbt7Sf7ll4TDahS0AqCKTAHmU2IKwf3oPR9d5txM3zll44zSz6rD0FHweGG+nEcW7yvsAnaNLVsoey7b2RPD9VnjTwc6GHREdhKkwKFdDEyOzgj//vr7rwVwLyDLZ8RqxOzfu5L0635mOxtcqKhXFN9UC+gQZJzoEXv6/dNHvfsUTizg0X6rJauZtLgqcIDepyNaietl3A8mEEOQn0iQUldjKBNtONNg24aoE5uyzOlAHaoUikozpgIJSwAbbf48mVSTr+A1C/SCU5FN/s0MnHz9Pi8gqT+LNpVPIEjX98VhX48MWIE9/WqA/m4MJ+iDYdsHbi+B+0twsO3DcSBQj4E4DS83w9sPHLR2PALHzx94zweOR6JSPQ1g0sweP+Hj/QO5feKjHnhUUqrRHS1VfRaYOJnchxUTtW/sGUP/KSYlIzC2F+z7N+z3T1ieOD8mztnzTDi/InYgNs5jic8Hyj9wPh5I+0ROQ54hxgLx0jGB+hTIQ+IvMfGfo+dsDBikMtTwssHwMIJrGHwChyWnjUeSJmhauXZizsLMEzknEyEG+ObwMWDzLilnCWbYBt8Cwz9x2ifMgJmOOXOJY/Sj7mf6V4+cJnWxdtZLVQPGDL8OP9umYyUJTBjSn3/eFCCA99FDgwsDMTj5e7tt2O+bJGx33G4b9n1gG4F9D8rebs5AQ9hrBU7WbBTZgTNhO2CD0sRYlCTOXYKTzvhFOKE3fAPUvvSmZGpUQlcwWGEXlRpXtTMVaV23UIneqfMcUHWcP2NCTNWOwXvF8RelhSOMKoomDNCs29UUvkrw9fR8ZJd+9cD+5uu3BxpPAcBaSMsu9937+u/uQ2gO2NLxNZmhVY7qSKONk4719J2LoVzXc1rPrJ7Nmunnz5EIjWvbxDLGl+GObVPTz2gQrYpEkZa01oQRuEPRKX+WK0jA+g1fwinXgyiIAMOspQsINjULpcWtc7RZ8CGw7oFtBBNLUusZoZkMZkutwkS0gRzGVMnLQXoU0KxDu/om0KQQrOyzqWG8m6E7ejZc9BazDfe7qjIzcRSQk07wbsZBeMboGu/ATG6GA7wnpxnCbrjdX+HmOE7DBwqVgY/HA9///K/4eBykXc0HPv504jzZfL7WRRXyPNZzf3xPsCmZT+Pnnz/w/n6gkhSqNnxRXFyPQ1N5O7oyZh0rExUHsgKxHZhSXjE37Nsr3v0bPs4/wQwYFhihZxsDI0iX2saO/X5nkPH2htfXV7y8Kdh4+4bXl1fs24bQEMUecmk1FdgGwgnXZwEu+TpLloMLysAXA/UQWPHq8qfmplgCmIv3D1hjGBSSgF4gp6tbKZDb68BLDc0CaKkAph1pS0dWU/QMUKGDFQduLf4uTfM1kjQWUVCsjaHsRgEwVXQSlF/mCWA11iW65CwVMmUDl+PqQErVrMBkk3BxgsfqRclkRVN7g/Y2AfM14bwbAkd1QiNxM9K7UvZn4VcZgZmsuERzmiXnbNY696XrkXRiOqomJTTDULM4+6V6mvjvr7/1SrNFHyULgIFwTSw1lxKtlVO6m+4jOtwTKHpC/+COFL86mS0FVIV6AkqVQEUhkByGV75svp2AbaJMhez8ssOXj++AATo2JTJ5MmSEkQYWZhjuKAvaqZMVEHMAMRC+8drDkIP2Yaoa5zMRW2dLHcC5ZjJMKTBxboyCX6iC0368e0cOoOfs9FkCC6Nw/6nvpKsZa+QV5Euu4SNoRUIOBQRVtdywFfsdx77hh3++4Y8O4L3wyzzwsxXyFvB74W7Ajw5sL8DHK/DdDMdPjveQjTKH+QaLHTUGPo7A+5k4P06cJ9ePc9Q1E4VTKlzdx/hw1KM4gNEnTPaEMtYbIoA9Jl5mUl54kkaVJ7lkXoZRgWE3xH5HVOI4Jo5hqKSIRW28F071YVZT8wFHYJrj53nH4/OB4zjIFhhNNy1YsaesKkjoGovRhSzgaIq3Kr2VtGdzkjWRs+unlESPPIE4kMeJrEmGxXDE3bCdhp7yBcnXL+o4BGp7JWsPXMUNw0X+f7ZnttbYr81cv3X1ivTHtV7Wouu/h4u+TMGAGIGxD4zbhq3/bDu22LDFpTo1xsA2KK4ztEOfk6+GLyxCpPM+K2Wtlfx0HW0XFl9HV9Mn/3TK3jfIcQUT1jie/j6qMNuWZYnyedkRQFR7XLRDeKh/UnRMZiz4fl1UJ6i7R43P0JHZSQ7t38Zc87oM3otn4/n3X7850HAFF71O1s18/j3qV+HrFTh041B3PPD/lSN6slirUUiv/ie197GqFw2O8Vd/1wIZpTev0UcL8PA7wgNj7LAYaJ3whgwtqbkiQbiyrljUNb6FfQerCUncxP6nL4cGpF9Us2JkAdhYFRNTcMMSlmMDh8ltGLAxGOxI2nAMKVw5iDiLDnOAHN6JQk1DiI/Le5NSmgpYUrIVEbITvKvpl9rzboajo17xOKccxmbBYKISeedAuHbwHwV0Uo6MNH7/pxX8YfDYcN83nI8TEYZvm+PtD9/w8vln/Hl7QcLw+HwAtebp4vw8FSzh8tCm/EdnifXeVvOZxWnlK2OGyyZakv9cT9O9rIoDniYw/UQBeDy4Tn647/hfvt0wfnjBD//0ip//jZJ4D7D/JDxwGwNjC+y3HS/3F9xfXnF7fcPr2yve7q94e3nlv99ecN9vMA9Nsy4NuFJlzYAmk88iT9ZkTBsEXJWBgGmFd5MZDQmz616UN2xw3r9jqZRUsU1Zfpuk1g0MuNW63230pioeXG5Tzpk84+4xaUtZmhS8GgGT+zeh6p1D9CPSgzJJ7Sgh9RAd4NRzGm2BwaodZZ/JlZ5mqCnBPpVGPQle0g1R3RxLsz+MICKrBBprLSkAsClFtiD/24oAlZLozuXifAY5wYphsZm7FBix34ZT2y1Apbjk/Aw47dmSUC05sWnss6la80Qo9JBqbv/99bdey2XIg7YfMO+EjpJLTVVN3me9bYGwy65gHbCej9mO+smeXGlbUa1aXAPeiW+uS5goenq+SgY1BaEbSTzbmwlENh1R55NgvxXC6R2Cakszij1qg5nlMZjcyWyFpInaxgX8FdxXphIOGoyZDbKVMJAzo79iwMXfPd2HJ9uy5mcU1l7+6wfmgDLy3dhh+nG7UdI9SUtFbTC/w15PFB7I7yfOw5FSZLNRwA7ULrz7owEfDju6J8thsSG2O/Z7YGIgHxNlD1U3dQFlOh/9tytLrfk2dZ6oOdGzVgD2THI44kQyJcHfz6l72UCbTeADr7jtE1SwcpzTWVE6T9Tk3CZ3w+4TwAOFDY4bIm7YrVDORFTSwTFJAiZFyB4hXQai/9SpZxAObAYLZebN5JcFyqsj7ETOEzgMHD+eCsSbkcFrtjo1u6gYeLX7r8aAvY9ca+Oi85jWtz0tnN5y1snXsstXQ2wpwxX0uv6tbPBSmApVxIwiP9vgcNx97LiNHfvY+GfbsG2aBL7tGGOQ+hziTD3v/dLxn5awLxos0b8Jf8mTLCzU+7ZkqLrv0VT1sz7/sp7Iq1vXNuepgv+lNNLfZfjavycMm9f5Nybn8drgXBXVrgJXbwHZqPUccWFnt4tNxOdRy6b8e6/fHGg8CWOsVx+/+WT96+aurlLqCjCeP1dadMstrCCC96aWwYE9Zar6pqMWuPoVf2vdhPWe6mDGVgk9DAjx9mqEGmHlZ4L0i1LWJZRN6mwtQIUlc8OalC4D60VQPWVaOgBIJDbjoljVGW30kerjMGbLhmRmp4kvOCQ9OgsIh28b4IHpOq+CKDKT8yj8Ai9c0LkK/aZMFRSQmIlelaLeaIP3/XYzcuhFMTCTpKpRztZjQ+6JHwp4V3YsHGpUD8ACYUN+1OH+iapATYP5DeE3fC/gnh/45fsDx5HYth331w2/fP+A6eyvewZ0/apW8Ao9hw5uCTJQuHj/uuxqx6lZEV/2kxFgho4JgXvfDOPlhkrD5/eJOd7x8XlyiN3YMNwQ4bhtHPyz3294fXvD68sbXl5f8Xp/xevrK759e8HLyx37fkdsDG6n5GstlV0lTwiGk069qGpCFSNb2gNRCXNnVt8NOQlKwxwQVchEqSo3zrkwmmxXObbAKhqXTjX1ldWPtmsFzrgAsBWVr9jUb4uDMpxzycuc/SzQGoAmjiuDhqIz0Jz4ZeE8oLkaBotCJhv1zTvo6qxdl41JA2F1LzERMNOeNH7fWgkZOB2iQpUMbdNieDRql8/VnI4Q0J9tm2RQjUMe4QzvXIHKqbdS6tpgFQSWWaJKcvYGpZU7EG4QKRtXz8COzmuKVpknaR+/v/72yxrZPjtWAyykWNT+RPaiq+kAVpa+/UOBz4uP5PLQ1tkLtM1p/3P5vp4NYHLABkiW9RlYod+9HObyO7hA1TNW61c++1sj6AsB7ZmO8wwgNlZ6s7CNROUgRTcGagj8XBAPVfQNbpxmPU+jNK63777cK6vZur8B2Klr64O1/632vLWuoZ4vXX8voNT3uPdfSTQhG3sFpg0csllHJc6E9hrvx4FC1sThhdN75O8VoLkbxnDse6B2R/3FcJxUjjuLVaHV1GqmQE73qVHSyb65UpLLTA4arIIcUMV/ZZqbtsYqxTiZ5HgZgG1Ov7o58FBVIalUdwvHFqZECJNQ9xfHj9Pxk6tXbdY6l07sV2htCPCz4qF7wKIzE5lJv54eCPWK5XpckjOfsoG9XsqAqeb3AFAOr8H1WoUzOzH1a+rT0yN/Wu+Gr2u7mRbcm9f67HyAtW0se6L4iDrlXcFgryFHFgxsW0jCdsM+Bu5j4DbGCja2raVsN8QIsi9clXlVqdc+xtPeEZZYP0tf1P+1Xxr7ti3qNd/+bP0QCkCu93cI0LhlDbDUs75wfi0DtGyLPVUae4/I55gq+BxIew2Mb3vTFCs+06fno1ON3k91PbkC2Nv2H7z+gYF9bayxosrrhl7Um3WiuBZ9n2g1KDYsPuSy5TpX1xN7Djj4+69LsyFAR5EE+faUaXlyFP0Bu74PcJbLQpUDHYdD7Uor/Cq3h/s631IgAAUIqzldN4GMqSKg6X3hTb8ojOICqCLtYxLVsznXDJ4kEo/g5skoZJ6IBPsjLLC1ckhRbShFTeN0ZYM3tSVKoPFqRLX+ftTqUSAfXk9NiznL4ZYIK1XLC0PNr3AamHLHbd+5OkrgzUIKSDRQLdUNdxwWOIso4Dwdr283jPMTv/zlT/h8HCjf8Xi84zgK27ZrJoepXNgAuXewFpVC7N7sXclqJNCbvDc9h0jnNXF57VFb/TDGJYL7y4Z/+XbD4xj4JYAf3hL//IeBP20bbiMwK3DbqAB2v901WPAVb693vL6w2ft+v+Ht5Y10qZcd2xgCnzQeTdUpUWSY+ef2z0xNFr+KsLTneZVORZfuUYyruRVcmzBWumAGn3JeYBS6ErKl++GOCq75nL1hiz/PhLt478Wm0LSL1pMTgHopqljpgHEtJkwiGD0kj8c2ZxUlgvzl1D4kTTGp+GQq7UsKeqyp5LxPCTIfS4CRQwNFy5TTJYfYBWIKA0w6AKwamZEuhmTW0ORMkewhQUqyGhxoOQXM2q2GdT2tDX3Bw9QnRWpXoJQDyBXUBBynMStpGnJC9ZiuVBFozCfj/vvr64u+W2t//fdXx22918F1hYKGjfJn1Q5Mf6+8RQ88MltJG/T3WYNdW8cjLZdrqYfX8pC1ehe+PElVskxlbUet817+Na9/r+4Q57G8mKUeAxjDgUmbNCpRNTjLIYOqSuOi+XbVLKsW9XYa1/bZfkQ+M6Fr66ihz8uX6UUb0n4K9XTvn4OO9XCe7iNtUVPK5NmLdiZR9GEGPH4G6mfDcRhmFFAnfDjqNJzfE+kHzhtw/nyQQ98BpCXcTgw/OFvim6E+EzhqUaRKghXMbgwFbKzY20g4xMWHqHSNa8w466iSPX42AN9hcQJKPuYE5nmgzu9wn9gtMD0wcWCOA+d50p6nmq7DsA9n0hAB3ID95cTr98IHaMO7Ks3CkNaUZlbBUsJFtai1nC4t4Krytnc1Q/6yK1AVjtLgWILZgNkdhhtQB4CD4L4ps8XBsBMTNmuJa/BwheetxW+wRflvsNHB0toxdi016/MXslwJmcYY6EZrTv4ewUrFph6Mfdtw08yM27bhtj3Nzdh2jG1DRCzlOBp6p30IeTdVb5AcZ7BWenHvmq61FnbkHVi2iaBXvVHdL2PoHWLaY23QmkbvXdIBqecmYLLuUXFeGrIrQLVwNgA0i9MgXNvsDwU3C2ubfFfpu62fktZPlcSDOs7gUX8jc+of6NHQw30eHLWwW//IrPH5WmDPrw46nsHdel8DxnXhdi1E7YIF5vVhW8eRketjLRyqEpDp+F2Wg8GMTU8jBnYzbC5VKDkdTvtURh8s4xK3FiwpIciNoWqENjuxCTOepVOjZjozGG5Sl3k6/5D7oq/RIDlF7eGDms6iOMW2YVcAwuCABtuS8w9Y8nLMUkeIggqUXTKKktdhlEsePhsVU86MJx4K3Og2U/Q5HmuqEdwqYUYK2rwBdwBskjNOJ3WDbUZ9d3c8JB2HTPzlp0+ceSJuO97++Ybjvxi22wvi8R0/i/Kz+4DdAp/vn6SdrL1YVxkSCvaK929qc17tnDSrBWV07FqCJcmtKClWDDYVeiXOeSI8MJXe++XnibTvOFH4PD8pAehUsrjfd7y8vOLlvuH+wkDjdnvF/fWOl5cXvN5fcbvf4OFIM9zkECbUV2PaxFU46uTzrYt3WWAzJsFyIi3gCEhamz0IPvlc4ZgGrY0rb9jzL0prbYEuGW3kFaR5Gp9tTzFV0FYFDAED0gyAAmkMZRMxHVBmjc0rBvPkpFvX9Nti7wgNVrJSUsBndtbEUK3oVXVlimUZG6gHGIBtMi5nB23FamSB+2yyc5A/dzZxdF9FTRcNKjirIpM9FUG1sQoG1C1NXTYxLThoUhuYE82BAyzZV1cU68pCe1ctQMtsMuwoJgnPom1xAB1WnpkMgNyxdSbm99ffeCn7KN+dTPk3hqFd1M8YLJJKBGGKtvHLDwF6Pnp483LWsIbTENS44BPcGIgusm7I5ynp0zSaBmIFNmdCtqhqsbjQ7KKv2H5xsiNE65XnN1CZsLZBFToI9KSy8GmYNpGD52NVsGkaHMeKADnwHNTK4KYWm6iH2arUDTxM19aJNjzRZtpDNwq5/HcDf6DUk8FrSMGaoU+mcfP4BvhZmD8VPqpQ05A3g2OSGoUNMRz+WcBx4NgmPj8OSpufpVMoYE7MfOBI4PxJVRtLTFfg1lLnBiA2oO6o01F1wm8Hbi+JOAocnsN9b0XlvlsAYxTiYajc8HBgjs9VGbUwGA7UTHwen/jJ7/h43PA5DxzfD5zHxDxT1zwwLTBfAvNwzMNQB/D+fuLPUfhwR52T6RUn5Q2nsMkk06Cz8DVlb5RxjsGg9JzAmYYDVOurqc+LIbGNQGLjfYmE2QYbL8jtjrO+AzgwKmjzEchgAsfxwETPatE+whXkNyOt9+WzYlTf+kvQo/fvRR/sjCXvJz/QoiHhTZnS5O9xwxZM6u2bq+F70+92bPuO7a4/Y8eme+NBpopN5xT2BUu1xk37uYNnBBvwBYIXW+cJpyyFplUVzWsvyNa0PVn+WhKzq7fJwGfbhC3hm2V9VukHFz2ybUdhVfRNpQrPxWv5co4rmekG9mcBnZhZ9qsTKP38/m8NNBY0uy7oCcUBoHGgLWprKelZGXEzXGU9t9XF38doQb2+SW3Sq4/ZwP761BUNt9lv49sPQeCo3++dSXTDvm+I2ADJFjK34qKAuJTpCFhaM58LPxfXfKSKfiZXlTKck0Z6Bbe4DCpK2WzrHgSHE58xy2BNFXOYmpS2cccIyq8VHI/MVRJzaSHPIujOCZgcGLl6BTeqb5QxG4swxCRvuGlHfLqOq/Cs83ZWWfpxXRSTJKe4gArHZhtGAad1gy8bsgYcH0Uq1fcxcB6J4/MDL2+vuJmxffsv36lDXg9UTmwR2AeU0S/MoYpLPq0PKzaLa1+TAiZNBut18rSmTAFmZ+e1aUrrIraB+9sLfrzfcX584uf3CR8bYhsw7Ijbhi0H7nNg2+6424EYG+73Hbcb52SwP+MVLy+vuL/ccbvdcH+5437bEBsbzVybuDTXIb1Wqbalj4GEpyvrLkU0qAejDGWBguG0SRDbz1pqaaG+ndNIJWI1oVQ9A9rYlWQqBzeH1JiU7Qj2j9Ra+w3HGjRIlrYKm5xHGjhwyhmcT6TkDxlg5MrQaL9PZU28wNGDheZts2nd1OjNYLwrpUCHSD1phBTHwqV3nhIMn1JMC1VJepiRFRRIsZwMGBsJi/ueE9pB9RmXDpGkeMMlHWj8nkogiv0rU8DvtCRNDY4HLirZyoIV39PdRW6GObkfzQvjyQnH73HGf/Bqx12yUbgATcYC72VQEqZkcBXEZnFBtf5k4lpoNC4C/p1VtCcH2/9Qiqau31U76VlNjldSsbCGqvSWKEqxnq6c5VSlC8wuEugIrCTBxQQHTzqAGCcSUjpsf1hqUN6AbRoz/V7wzeA4YY+C2YBh4lAW08yBWRL36CGW7UQNOMQB9w48BMYKy98LGV33p55umW3w2BFhcDsxH6zFhlFitIIN0JkOH4a4OaZPvFdyHlAZPDf669sbYnuFjwN5vmO+v+N9npgHcBabvCMGLDbkueNxJA5/x+PjAXxMFGUYJUuqIYXHB9J4LxGUE96PxJgdN3UUODBqw30Ytj8m4r0wH4nMiccjVw6n6S95Oj7OwGMWjvPEAxP1YMIlw6ncmIk8EufPkwNPjbTu72dQcXFiyYa7+rFz0n5S3pXnRTR5MNB0wCcHkJobZgAfWahZmDnRqi8Rjs0Ld5x4xCc+41T/4gS2T9Q3YL4n4twlqMLxhmVgdM9y9NoNXIF+BQVfMKR9/eevAo7+9TWdXFmEJ0ofM29crx7Bntt9x3a7MZDYd07+3gL7CIxxw357w7Zv/DMGNgS2CGhW87LLjoRFPp3QE6NFV8c9m1/waD3fAJ6k4iNiXgbj9N0rGHmiO61m6MVK8Ovf5YuW6U8MlWV6DAzEDID6Fy2fjKFdAZGLM7GoYctescqX6/6CNoQnqv4gmjL6tt8UZ/wDA/v09zPAF4V5ZVnaFvXwrQ4u1gdXcPJ0k391/H6TrZ92IHIRZkpgfS3E5/PMNsbge5rm9SU6ATwCY9tgg6VKhdiAB0GnAdY0oY6q2ynIoq4SlaHjQpV/BV7Mn4INgiDPp8ybs2w9vK/livpnGHY1NsFJzckITAMclBEtq9XIRlfBJlkLozH0UkYcF01Hyjw95cPKMSoxq3sw+lzBrDKcz9qvoMgCGAmU6nJlhUg2edeLA8PxcMPnZoggzctHANuG9IEZDwz1Iuz7Hb+8P5D+Ha/f3hD7P+H9v30H6sTYB5va8xOASeIYsGHMsmmCp89PnPPEWXPReJZUsB5ULz+AgG6737Df7vj+/YGZBzyMPRaxUY1qFsI5aG9sgZmB27bjRXK0477B8Q232PD6csP2suF1u2O/3bHf7/j2+orX+45xv2HfN/g21iTrFChaIZACN8rA+tKpTlUTOH+FO7wSLBF3hpFpCF7fCWSqytXrMi/D3Q3FAfJ/4QwakZycHqABGQp8TppbAKRbzaIqVws/mIUiiyngoUbVEse6UlUzgSufCDjmDGXqDRmOTHlMdMVBKlodkHeW2UkvCuf3z2IZu5XXWkiCMZbUmio5z0IOy8tR1nUdX8CBzedUbcnAKmOHJSlQqSTD4D0W+4+MrMZ1UoUDCmcH+AVOIldVk21W3UfCe18GjNJ8EgWGnBUDeDIQzC6N/P7665d8SilQWGAcgIFAbfmjYlBdlldDuHUQoLVm/gSgmR5CQE66SBWxa8o4cUhvTvmEvAIfBu3VfbEXtfcpeqQqFW10SBDAK0XpuZAYQVDBTwPCkA7YCNhu8GlwO1g9tg6geZwww7ATlRus+7AdKE/kJ/PXDiYm3B3miemJOSflXdOu6emFNcenujrX+Eo3hSIGy+HrmbR/3DHiBdurYdw+8PjLRH4GbDjsdQNsg52hwMPw8mLASNTJXr0Jw/SBaRvm+SN++OGP+N/+l3fADP/nfzvw8387mGQ4AB+OsQVu24Y33/F2fODP8x3nO2Vde/ryNKZ5sk5YHgRamlD2uDl++sHw+Z1JBBQTVoEB3zaEF/I9MT8Sx5H4nBPH7OkkhhjA/mKUTk3nPIvxwHZOHFvhBHAikKch54E5PvGYpC6F1jBlfZmAiM04CHdVlS68Q+A9BDgng9VT62Mw2bIrY3MggaNnyBtskm3xiRPnyaRdUzr9YYiPQqhiMOT3qVgGfGTi/UEU9Aw+rQEungGhrX1rXmstXcwYBeRPUchFqZIvdyaFhnFm1YjAtg3J194wtp2UqW3gtgXGFtj2F4ztBXEbGIN9HLsNCubIfszJnkgE+5asipG/ElCAfFJy79ikw1nJhwVtKfduoD+H7ic0hyfgS2XxhF/VhSpJo/NPqx2iVncZzZQCF088sb184R8GGpPOTLUP0/a0SGDm6hVc99psRa8ujC1Txm/uIbliB5DK1Vbw33/9AxWN/mItI7u4pA1MsW7P9T80zgy3unGaYB3P8cYF4Ds7i+v3z3vp4tw7WrnF9PO+mReAuxjT3aDV5VEfAzG0wEyZfRgME5bOLD66EfeKyvv7e6BRCuRTok/nbsy+r6pEGRdlN2SVw5IAnhJtbKRtxYUwzvjYglSrpqpsjhYn0ewBxzD2UpyVaG6xS/0Es4eUcXgYHKiz1C8Bce44zI0gycQTBqDrEYMWUQGzkwPdevHr/jQ1tcqRNbBLErGCQ34ew5AfAd8eCDc8huMMR86EbYG3+x9Qx0A+fsaGwva64Rx3/PLLSTnGKhwnM7/u4HEdlHI0wz4CH2filwflS+GOMXZ43IE6cB4ncj743OG47wM//vMf8cc//AH/v//z3/D+/hPXizu5m/uGORz5OBB+R8bAdrshbccZA5aF/TawxYaX28bMyf2O1/2G++2G/X7Hy+2G223HGJTSMw828zuzCQEqfKVNtCY6g7nk6F3R1gqJWb7mMog+Ck655n5JDW8oacE7Sj0XXMNq9+N3Sk7XLKVFLmOifUYQr6A3C+WUMPbJMnK4Kl5ZKJs0pov+IFqScQcHejinKIOYmCrtc0/LUCkImGOyigNVdyrQkyjcFeAknetR3KsA5WcdNI+ZWpMKcEyVq9P4jioayihDVcBiQnRm9UgYqnoOOisPBVvPSV0Ta4L3NexP1yAeLFWxFCSoiaaMAUvW1dS/gZQxunoOywzRxpaEqP/Hhvz3l6pwLipr89G1Fjsh5bAlFzx7oQtkwsF+p7LVv9G+BaqW8dkS4BcMNfU+BRhXz4ahq6olu7OgE7er9hiD1ZaJJLRlEOsnk0ez7bA7PE8GG671VEzsufM8ghroqDBW3yI4GXnItVYt0FdcYhjVPsXh5wRsIp2ZbAMz5mm1Ek/VmcWnUGKROCxhnd1YHDAsIEagkhhxYi/DeJAGebQ/ehRsTCbn3LCZ42UM5G1waNjnhB2FCgYcuR34tv2C/x0P+Djw8x8S//mnIpVqaK+7Yx8Db/uGf8KJx+fAz56gyiPpJKmeMlKdOldMdsPjMPz8U+Hz8wr4Sb2+I/Z/gtsHTn/gtAce88Tj8cDjnKLwATGBPYF9UDEyDmAcVAr7zMTHLORJdcTywnRWa0YmtijE3eDfBqwOXtfJKtXUANZnRaQC5enNCjjUBBxGSlDqXKYoQrZhDvWHCJDNSX9SSTprFDSTYiBix1bAQGIbA74NWA3MDyA/Cu/+qR4GBt185Fey14QhV7Cx4CADN2bclTCqBr6GHs7EuRl8L/8Oqkt5YFNzN5u8pf44BnYxQsYYFP/ZYs3WGCMwNodvvH/TfBUZ1+kpGGLv4fW7lAJX4TLPjT5bNZS0zBJcLqoKBinpoT10gkyUghJ9Ol6VCkTC2d6GQ7So6oBf31pWnO9TYn2YyYiI2tvbsXpIIAm6af09T6HdmilDO5koyofLz6J7n9ry/irZ/7de/0CggRUMPMULuE6vT6KNigxQ8aL7d8tArShFMx36UXWWdn3HZZxRUPOy/sOuxctYHoqH+smbMi0Xl61AcM9G8IFoMG8E7wFTHwUdy0CSnGEEZwQddvV+eKrp1PRIlqbOKrMT6jGb2VPfWQXkf6yoNdjQ5DAMBMKphoBBVaM0Aq5C4iHVp7Sh6Y8gcDSgScXMKrGyAVGMbAFDZvSWgkZxyVbR8JIiwuuMJCgmiGQD8ZRR4A2/SuxuiQrHHdt6iJ/O+3NEYLPA5xb4iMD5OEGSykS6448/vOLj8xOfseHlzo18frzjcbzjfmO5OWDKRDpu+w0ZA+f7T8jzhPtA2cTwgdt+w77f8TgSyIlpzv4FcTnnUfjlLx+onNhvAwXg7b5h30ht8rEh3PHyT2942Xe4D/zwwytu2x1eySzZCGZNbju2+yvu+4bX+wtu2464DcT+Ah9E7k0/giUCwEhRggQkGHzQ84c3A9S1ZnMZHrivilmWr4F8SJMh6NV+Bd1WDaBlCLUnIePSVJ3QoU7YslOcMdF7TZWBYjMZ15rydpasFiAR1WXmpDSkAWjqXTlMvSSsOLHEiyRHtrmrE8DQHhOxCPUEGK3mamTspEWgr4f3OnMqkAdBX1OdUtcRhVHdJBdUq6mLQghXWDFl+J17yroB0hjmRDIRkSeRxVVIM4LXdhoFuF9VQkCMnGKIFkqHGybODKQHr7PwlKn6/fXrF5kVpr1g3G+iFi2H2KXndRttoYZLia/WnntObK1qAtHI+v1zYgzaM97H7n3W05DRf+TftIfXuTz/q3/V+xXcK2v/Gvf49WkG7OGmTIGrushkT47BeS5WQDLi6IrMUFa6BSgMJyvxU+tuqQlJLAJJ4JpK9Ol6GuyUjv01NF6RiV4TlQfyYN9IpQCxGXsg6oSplyp8IO4DwI60RNmDioEO1DRgEtT/UicsH/g8m4pY6/lyjsZAbDv2lxPx5w04Ej4m50AFcD5I8RwwjOD+nqV7aIb8nJJKV1hlDvcXOP6IqJ9wnoWZB2ZNZB2oqV6FvJgLWc4k2eaY34HaSk3pk7JUlTBw4Otm7GuLIEPBnIpP5UoAZfe5ABdFguu88tR/EzYbmEyUiruSVQHEgNumTHsKzqjyqj40MyBsIGyH1x2GB0Yc2Db2Mxr47OK9AEs4yVRMXllvpItGBmEKo1aqtoYpyNDfHQU/4UyzDkiEkZxD+YZmofEPZ2JsY3AS+AgyCcZAbBvGNjgI0kMDdak0tbAnTGq5nbzmRixlLMrW2WhPx0qkX3vzOh5ZMV3tEB4OW7MNGyC3ZVjmofFC+zKrHiHVYQUaJNMn9h3n/qRNM5A/34mF6m6Gay8qyc1zqfX8uV+wqrLet0LHX60mvbf/bw80+hY+nWzfkOdnQO73dfK0x3bZ9nWcK7O3jK9+f91KrGOYAP2vzwe43vwFjOh/alFn9O1miNgpa/Y0kIgXxqAiqqPITvRfwLyDlS4jUZEj1gbqEti0CzQSGtOhpS6YgQCAJL+cYIsNTRFU4kE4PNgMzs/W2nCWnN/RFI2WqkU4KZNWVMORhGrBsKFgmTidQVsHS5b8O7MXmzEzAVJ1ABZYhzbeWcDWINnEIS5mv7PABtZ9sPHZCN4/joHhDj8MMQIfnycwT2yTE8u3fcMfvw3897845vzAL++GYx94fAAjAsdxCrAxG7WPDbgNGO6wnIAlsia2feDbtzds9x8x3gfgHzge77weD8S+4fUPP2B/fcP75yfmVNZr2/F6f0Pc7qjjQM4Dt/0Vb/sdY9/gYEbHwpk92TZsO/sv9vsd933DfruTJxrU5V59Pakso0B0D8ZiEE5ureWkghg6+9A8DDAQMK6g7sXpErV35tuozoJpyGh8ndhMvR9my/hXcf119aCqw+FS1U1mzCXX7sGfaQia29C+ZmUlVUY2FNJLx7UFQtImWlmris3q0V22JXiXhkcH+5KMSmPm0suk2MQATTRyVGcfsyj5qGqFV19zB+GTz6GTD7K6EwrIJeFLNTCeN2lfCkoE7eak+HELK/Qk95awbWqJ636dOv5m6r9w0RgBZCn4h0nprkh/bI6/vp9G/yt0+/11vRzQ1GoDqiRsYatygLxaN5dCmm5x+7K/4o/rJVh5gR2D6Ap6hrjiiGd6RzmrItBaXdX8DlAWjuoFyn83cK8nP9fVY6rbcB9PM1WcS/dAlIYwblD5EstAbsCpq4cqG+MUxXny+3rwJMES17wVpBynhVyq/C23wbuzWmN1nVSLQl/dtU8EdqqAc17pg0zQmrERjZzwrEX4oHy34yzD6VRZXcnOc+LPHxP/3/cTFSf+7S+J85GrmsAEjTjnBvjdgA8D3g0WhuHMOh9FG7gF8BqOsxyfZTjdETfD9pH47OBFz5p15g2OAA6nRK0DGAV/dHBBG/Mo2ic/gbqzf+ThjDFO9cNw9w/c94FX0bemsWrRAycvkilBrD/FUwAYNJwCvNWVY66Vh5EwncYm8CxSe0iz5jK8wXCLwIewxrDE5kaRC5DZ78ZKk4tpUSNI31MCxRVsqk7IU9M+uEB976dfBRmaYWEdpOh3BtesDLIkPAb7MsKxaS7G2Dh4b2wKNLYB2wawbfAbAw3SrJxslvbP9WRH0IntUtBQ1wU8GQUTmPelNnhhW9e1uejqMKwqYDopWgk+TId1PAMfoqJxE6zvgUHBRPvqp1OxZiNcAUvvN14NxSl4Dh3J+NVo0dcIUPSkuftaTy5bRIicF4Z++t8rjf/3X/+YvO2vFvUKkVaggKeN+LeP0e/5EhT1B/rny2jjijDQUZsysHoQHdQ06Kp+Kgo6vqyTNhDGTDSnbSsic9GZonNFbf0N5NVdmcWZpvdJAg0txwllm/iFq6+nGwx11DQWGDY9fGaU2dQUCCCC08qd2Y1wDloiyHdspcXlEvf8MjWa97PsyoKzv0TynVpncNP0WfWUuJqTlX1pKTQzNWv3H3eM6qCJHHm4UfXKeH/YP6JBhjfHNhxxGMwnwjf42DHGB8Z44DjYK3KeO+o8MA/DtxdlUXbH8XniYw+M8cGMsRtmHoBTD/vx+MSHbfD9BTc/UTU5DXQM/OFlwy9nIG8DI+7APBEx8Pp6w487RQBe7zeUDZgH3l7ueP3hG3y7A58HUCfu//wH3OMFW01MGPYd5KjuN2ZJxo63fce472sQ0Bg7RvMlRSMoC2reQyy1IYOSAEKZA6kycQ9wjQ81ZmUxoDBIzg4sHbsVG64BLNk95xpHzlXdCwET2GojYAWMo67VeM4Io0qZfe29kZzHIcsIYMgIU24YBswMIFpxpFixaDBg55cm6W4QNAVbkuPnragWidA9yMSwkt1VVUMgnzNklIctlndJCZQxdJUWkAyWjRfPUWfs3wCMTZgLzJemfwMMhVQ5MgZFFgRCDaSWMyiD6z2sSahfqER9Ubo7jZiNlVJcvNqnpsIsUhtqGcn5W5JG/9O+qBRTi3LgRcDHAC31Q4EisChRAhgtGWnKxpdzX1wBKVaVq71Ct3Z88WFy7FdyiqDakjQugMeB9sdS11Gp/0qONV9a0T6KNlY0RyYuotWhlbDwVc2ndjpr4n3Erph2pbsnpg9Q1cyUuJh0DABOVU6dIktTdDTLVenwyjVHijV27QhVr8Xpul7t2B0CrIP0RztlhwZ83OBD+7WMu/Q02C8TtX3gzANncj/WVAZ6BH56D/x8AhMPfH6eDDROgFVMo5T5/EROQ358AnEANuFViJOBn52EasMcLygcmntzDsBfAyMn4oFFmzAUzN8R/m/w8Q48Plm58A3lL7DPBI5PlAHnNNhRMJ8YODEfwPlh+MwD5+PkJHKVcW0DbnfD22E4JvCehdMO+P4Oy4k8nb12oq94JUVQCgouG2pqScruzHAcTrpgVqvuAXYWcDLB5R7YMfBijjkCjzwRldjiQGwP5HDM6fC6Y0uDgf52Hg9YHYCxeXypW8KE3Rxq8OQSsQ7JhR363WJJmPW+YCDgziqGKWHJACPgoYne28C2bYhtQ+xDwcaG2Hf4tsE20rxGBCsaIzQ3I1a2oQAE8trb2lsFDTTW/l2Y0hrQXxiuGhfJnYSC3WwKJbT3sLSj0IP+XLRqqnw+JZONfpB0J/l/nd8VgPSaBNflCuBo7Hq6efcpmiSd21c1LrYCGSlgT5al7IqXkgS69t7Len6/7pP+W69/qBm8m6xXaWv9Buj5Gdaovq4F1CECKzXd3YAruLAOXq0DQH5PdSNKrqpE6Wb2UbmMu2qgiE9our+zK9xN+9vGwP2+Y3OWzlbzTfdl9Pf3g665vItrejfXk6mioEWme9CVsagemlNY+ZlkVB4GZaUSm4WUiAC4IYaRPzg2hG9LKtaE9WYVeZhyDh2Tzs5wFJtep8vJqpEVcQU9UxSQDafoU7qD1pEzwOqOyrPVztJxiu9PPmigtLOsKHs7UMqo617GwO6kzOxj4hgbHhF4xMBjHPg8k5M74wX5+I7//r7B88SPe+BzP7B/GG4xcJ4MbM48UQb84fWGT9zwp21g/9johOZEjA0vP76yjPq44cUMeW4wFPmctxvs9Q3hN3z79kB4IWLgdt9x+/aGiDtyJzv6ZeyIcOzbBpQjhmG77Ri3O7YRuO+sjG3bjvsYqBjkbjaVSM3Ha+UaQTEb6ZUZL5o5SKVoGmBSOpowIAItHWmC6dxmfG4Ors+eIM79xO/MsEv/Goxwuy+iNbZhpsbj1nJXltKYsdF4B2YWIZABBbtdTREw6GA14lQwY0g3ZVQBoGWSpYcuit5EU/u4s9NZ5aDyC428T0piBuhoA67mTMp5IvV9pd1mwcxdz7sB92gW6QyoQNMubarHSrQPZqr5bNymKolOT6EqJsoxLNnMrsoHcy/UqrNiaT1N/TJKkHBmQlNgUnbCFeukqqVqJPf57E1+f/2dF6U8gfYeBnTjC0sQIVqUVAIX3eDCZeu/K/SztFW5gOhKE51BVFXEatFODSZZWMliPlcyFgDQZ+kAtE5rCYY89zWgd1nhibJsWJQNBQg92ZKV00JYiFwPVDgGDHdLnHZinrrkBCwKR6bkQl3r01hZONU7lr0bWKN0M5xnUsI66Uc6yVFTtA3XLBude1NwPBl/hInzr0nV+SiUDdy2Hfcbm1bOE8jpGHeqY+EzUR+JOumDkY6IQg32Dvj7xPwgfak+mdxh70zB6kTOT/ycE4UDP/104vwlMYuUFDPgVGx0mOGXrTDnxPEo1DEwd8djOOZqGaPfnvM7qv4V9sME3hP1YZifO/IYmPVg9bgUM86EPSamHfgEcJyF+TE1s4f0zVlAPgzzuyFfgDmA85g4/vwJ+5jApwbDOsU5zrNwltGeF6szQ8mWBDCTCpSQfC0Gbe2YAVTgPArHowDn7CvEwDl2fL4A84N7JH0it0JsnxgT2OcrxnaH1QnUgcoH6nyg5gM2T9Q4tT9MK1XBq+y6NW98VSraLmtdmq33tKTtMEeYUy4/ngIF37Dvu1SkBmIPjBeyCSjiomTgzkbxbd8UbATXIERDfkoZsPLVkcVFRm77UJjc3061N/YBdgWGdqJx7HMRuilmQwlEqFGcWLqExNvv8jOsIfnCvmS/2zIN/Ky+E8bktxIjRYIHt6B3BaVxA5RQhMSTOtholMJQyFRFIyUylxsqYeUVaCzE/vdf/zh1qqkcVqvYsErLetcamof+nS+H3mC8+rn0G+2if6CPZZ1AMKzwons4YAuUQGVeXJ/E0wms72Hmx7HtO263DTakzjAC3YxE59ESs2qwQxt6WiNicl8G1p5Ks1ahc9Z1OKj8VFDZhRWTcghQuO4h+ZnmhuEB+AbzQaAIg/lgybsU4Rq5lK16E4oqTwBOLV7OJKipMj7B6ioQFXm9DFSK0beZytgGRKrk6oBy5t3U7pp7MKtgUYiullip/MdjNbCi+xm4bYZHgE3LDhqG48B4nMgTcJyw/Y5vtcNw4nEmYjgb4rYb5qRueuUnIoDNA/PzA9/eCnMzfCbpCrdxw8u3N+z3Vw7pef/E+TjhlrCx4eX1DX/83/8ZMe/4S02cYJPe633Hj//8DWGveP94wOvEfQtUMGNyd4cNg293jP2G++BasjGweyBicP2kwzGRNQHXgMacbCQ3IzXAQtmPBNJROal2ZE6g2lmCSlg6miHUASvMCOoBZns6s9LeDeDE7JKymRmOIo3OncaL06vZ6zMBBR5UqeHxleUN7blK9sE08EGJwueUeEXzRTnoyitFfQr21liuadlmGiblrMww6Wwq+bKZcWrPjVLjp9MUB9jcfaikW8ljQH1LEICAZH07K+0BNW/3QDJbKIhl7kRVaCCnhhlaAqYJzMnMoy0bVkvtamqVU/LWGHhEUM1tlVxlk5yBTkjVxnEug9hB3cyC+ann7SvT9vvr771UgZiqBLVnM0PNWIpUTWuCG+oQdai5QGnIcfkkZu7oWkv2u91M/4o+4On9hkV79oQGppkSyzxWgvT56EyYu/o9LsDDtCjtqxF7f60Q5NNbVwBCIBfDiVJVhdiGKfjdceJE9/1YAjYLx2hR686idiIwUdgU+5wwn5hxAjaQB/cxh93VAivwhE3efnk6NcUCGY7hTgrLy8AIwM8TBwoPm9j9wDcFOp9j4MArxssrfPsA3j+RdogmnPBNzINXx/afbth+OXH8a+DjT47ySUdobIa3sWF64KfHwF/+7cTjz4UHR3HjMXWcolU4ZmF+57pIAHU7cYbh8T5xHkxmcJjgicx31EfBfgHqxTAPYEqY5cxTWWMCZ7vtwHjB6TfMfOCsB+bGZ+6qSE8vnHVQIvecmEfirMLDi6pFY+BtAPtMHDNxZOIo2pEIDjK9m6EGp4fXZ8KzkDuAu1JUSTWvmIXzPPDpiVHyH3XizALeHWcqyJysPpXdMLYX3F4N28sJ8w3lb6jjQM2fgHkA4ai5LfnoDhwWjRBXXG/GRcG/HD56ACCDizUEWsFtCBdFBGK7Khb7rubvoSnfMXC7UW0qRsBHrERgBNWpwtmM3Uu2/7esw2n9n5JYCai6mIu7VqMWjX9NTVtZf0OPOUD7EVirW6ta80QuVIDCLJ66LJPYktS4ZP9U4YkO3PBeCYfMNSuoqvsh+V0VTpo8nvoYZYeW2Vnxi1E8AljJdcsn+1omTC9b2rj8P3j9Q4GGTNnVp2O1LrcXxdVM2a9a7y/gqZn7OqpZf645hf1JrIrEsqp6aCtQKfSn9Ht9U9WSQ/2ia252DWVzDcFTOaoXehMueK0MPrzYKDQxUeYIfRWDJ2aoS+Cdg/+uV0FNRn0+Uu+gv2OzF8xgW6iEPLCrUT1UZYksNYPpfmtDhqlh1ZkppZKAFE6sRNmRlKNByjreTwY98KZ5tiYwx+ycwZyZXpNcniPQZMsAaSy9ByfY5MzKkIJMqYNBBmVYIJA4x46RoRkhiTxOfJ7kHu+Y8Njx4ne8f37iI/6MGAdmJrbxDTj/ghob/nh/xfdf/ox/+77jeOy4J0OiGBvub2/Yx448XxDYcN4POBI2gs3bs4DzgZe3N2wxUAN4vd1x9zvKNrzeHW6c52HbgI8Ne2zw3TFi5+DEAYzYqOwCKKigROBUVoTSrgSbBvUapKoc5hwUpVJb99XADVEsk8Kcg+hysnHPHM3O7s0+rVYmtZR5L61ZVDdzXwHwCVYFAldGkmsqkZXKBPJ7AJMKGygSUNcQHyZh2gwyaCIdhcmFkgHeFEZXMUPTGX2fALWiuI5Y/TNKQJutuRgoHu3UOiUFUKs2qdKWYFawDOyFsRaZ6KpnPwtTtcd4RGPloczVgKpeEwcrEeI7uXjMiYC3nr6qLrDEkQJuJjtorPycK1nBz1d1SZ37/wQDUxOQdZ9UgTO7HI3P3wONf+dVaBUa+Rn5bGZkL9+EXg1lwOmISRU7elVVo0xgX8kh07NuWjOAnn+GTmBBoL2/D2h/00BSP+vPLVemXoYkIOH7ZStE4TU1SpfVorw+saD6JLTvVdtWPx5ZBpPN22fCvTBU4bRJNhl2+cen9cV8WsFq0h8VefEnDp7ToK2fZ7HBvHJd0wTUD3VleZtFxXkHBINWgbRCboZ8JHBOnHXisQ365blhwyte3/6IP/74F8w/Jd5/TtoaK2wbMI/EPB3n5wbsG84fB/LdYA8mEkgs5lwObEoqHsYIcDJ6W8kUo9+rAvsolBitD84XqZyqRHeCoXAc7/h5f8Aq8P4/Ap8/G86HYZ6JepzoBmELh79s8P0VPl/g8zukEYR5UB42a1LRah74rAf+Yhzi+QDlrk03cdqGhyWHL6ITfHx+aYlH0MadJ9kFZQU7AbyrIdydqoY+ge3EnlSkHCiMOhF5YuRAVuGcBQ/DZoENO3y7oW5UDHt5eUPiRxzjQNYB//4z8BiASYCjpKBRtii9YZTbNxlkEybycnjGqnAs2+dMxEZoIF9wzsp22xDbjtgGtqFqhQINzsfYsMVYlY8hmvUuxSkLVZMt6ecSq5+lgXoHGdUGRaqe5Bf1RtFek/pH4RTtWP0rKO3NxqaXvWDfbD7Zpgsjty1KJchMvSptV5r9s5Lewf1TqtYymCmWQICr76Io2ctQZpJFo2PWWtvBvalgBwrCE2QmmAwE3ys795wA+Tuvf2yOhoII1AXCYZdtbrD6FB49f/qKgp5CqFIJuB8y1v3seO0qzDzbQ3s6LhR9XvrpAmH1NenD6gIbeYeHeH+BWZr8K8it3CQzrXZ9MQMevotyZ84gpQCZ0iX3mumiGJocFWdoNAhvwxxNxQ3K2Y4Y8BjciOGADTYI94jIYkN2JgBJhaY0+M0YWzOwKNIwcpAusgypkT6jSeOkaDiuRLiyu4wMVN0hpy90n6cx+5xl4jjbanZi30HXyHkvXZxnTux2WJB6FTkxYmKLwhyBbQaOeWKe5OKaORyBqBv2sWneQmCOO3zs1Ei/3fHNA8cxcExDYeJ22/Htxz8g54bNgMfjE+d5sjE+Bva3N/zL//GfUO+Bn//1v2hjBt5ebvjDv7xh1ivO909kfcBg6sWg8cLOZ7T5hqHGfyamXQkPlYKV2GAmIOBBQMxqhssgc5ic+p7V8Cc0igYcHTCoSuBD2XgA6bBpyCj1Dug5rFQr0BOyLbVnPCgioGCl+x2sOCNjerDROinP6C2AkAQGLaLTbWFeWgsCOaF9mWY4w4FMbJPXlgLfEMUKxfWV3ccCU8VOgyU5C15SwH1DuRGHvud8ClDY6J5tadhnxIYhGBKHkc5ooh7SSKrqpmwNUJQQxVDSgT/raaiOUlaV95SN48wTmVOR4zQBQ8nluh5pkxwtiHNSlok0sVwzcTqBkwiEKJJnV0N+f/3VK8HHvIA3aG/SGOD6CjZqRQ0mB+7NHS/QD3V1IuXgtX4aBWRCHOpioEmTdjnjuo4nLLCYGPy5QEX7y3ZZC0HwikTw4nkWVuZx0RifPlaA+iJAkIbkRHvjdfoAbAYit7XXTesxUyIFDfBOQ03uE8+Ex9SF6L6WwXDSPI3J5uOOkVAKkqGgWrTQop/iAFf1i+SBetBHzdOR7pin43E4xiaKzD7w8ocbfvSBX24Gf5CaFgnE5Kyj9A8+o/MD5+NBUI7GFJSBrcnBm/aSpDDpFBsf6dGv+znRgCYBmzg+1Qc3s3/DZP+c+Pmj8PgfhfmZnINxAkgO7VsPeiZwnPDxgRjAmJ/ImDiPCSTVrGby+FaFzzNxuD9RVbgePTig9oHikL6ipXNVZudk0qcAzlMSfdYsUXYqPp0gF9XgsWHDgeFU1xzJ6nt4sVnfExGFbSts9wl7OZEVGHPHSwLz9oDhwJknsY2pWi0c0Ulp7/P0rphd1YuuYlNN6olO5VSWcg/EZggxBrZtYN82xM6ejC0CW2z0ybFh87GUp7ahBvFtYLs5Nnf27dmqt/DeGhSwPS2I3mReK6PPIES+t99chaq5kG/iYhuG1XqGQF8bn+gKPrSRPSXRrv1NcRYGJmwhpCHhYNHSFHgduzXvFYxYG4cGmY0x1Tvi2u9Vi4RN/5mFqQRLWTGhJlSfWchN90l+swBeR/cK/Duv3xxotB5w91NURxz5K/T/7A87EOvH0sb6C9XpKR5ZN4gfvh6L7Nxytl+9Sgcdz/SpFZTU+h9YGYZvuN026icHLWKXjJl9MpW6mz+rm1m9dWyxIEwc60T04FiVkqmH34EJFW2YYRoyxENgKsVlGs4GvjGoiuD7QA3TYDa7BrxYqamWjejidS0HFNbcO2UKdL87YLNgpgdlqFk4FSyGHlbBpIY1kUY5PlODVyqIkOAvwhh0TAUShSQ9ydjgah1Be28AlrXHBB7lGOGwGjh94tw3jGPilgeO3HB+HjiqAB+42xu2baIqEPsPwPFviP2Gcf+G+u//ivn5jtgD+8lAcd8GXvc7MO7w8x37YHbHjI1k++sL3mzg4cDb6wtqBNw5X8PS4XVi2w3hb4A7xs6siEUgwvj3orxxbRFIdtb6ZDAHzqxo2k+AvUYElm3kxI1uxyawawJJHNxFPfdSqpbrRmvfJjwLoQZRTypPeaRk9NhAl0ZQAe0qZnQEokCp2FmhmWNqGt2az86/PRleJAyHgZl+KNgwo/Y6pgwj+xkMzISgexPKSQespsszPClIZrbVsjTDowxL4IDim9rw2fuA4C6sg2sD2ghLDx4ouDmrghCtqtpqyDE4lF0rQLNCuGMmjNHbU/DQkta+kibRz6znNzgVyL165BZpalwvXBcp/XpOCiedMBXMwHhdE6JqLa7/769fv0zGb7kOQDSEfgMWHWoh83py1Aowqn8HAU8TqDC7quIFmKh9DFx4/OpKQ13gpRQ82zqxpyCjLvrdxYNqWyK/YrgmlpeCgXo6Tn9i/U9ffdfkscB9DFbimOlXtcSAeQon1HUDOUMjEMkJxul5+UA1YkM+BlNCBdnVTjl9RV9FzhpWKqKAYuMAz2UWDBI/sUCdkpT1Hjy34Zow2I+Qia+cE+f8BfbLJ+bjgfP7B+Y5r32WzDLnUcgjYVuibK6grZ9pJ0gvm/p0T2sCM9d8HP5U8KuA4zExfypg+qJVXdGjwGcW5vHAEUDFgTpOnHUij4l5JuZM+id9dlYpsXApGHV0ODWBW4J18gVMQtXUNTcGgIA/JmqenOcDo2yX31G1Edl6StHJeOytgGSl2QLAlrDtgGHAZ8DsRmrZfEeeD+TxaOCDhvDoCqPZSnKx/8LFjvDr996Mj2Y3Uobegw3bY3Dqd8vWbqMbvzdsHhi+iTql4CI2/iyuysYIZ1XZel7ZhS0Nyx1cdMnl25tlY4KdbVRKCeNEJ8q5NZvjXBdGXkbCrj2rFBbvy3WMX+/zy+zbev+VedBNK+E5W4vli21iQlFHWCZOPsWu61nHR9Ogaz3Tq6Whz03nt87s33/9duqUUt5t4p7/69nGGbBKsbYuif9TDdb7Zj59poOKfhJ2RQm4/nVFD09H5u+Nx+jvJH5/NuZELNt+w32/UbVAEIdnxQAgjWC9qxueV+WmB653kbojW1NpeTqdUxQVLWYDfOOyLGXZOOiLBiKiWBY0DhXagipTO4KgV41ibo4oqkawoVv3Ig0WCVNjK4qZ1ZoEKImkSgdoyALgTIzqCZRySK67XIlTmeNS6ax60QMaDKV2oSqCOocqSnwQVETRklVmsLXNXTrtTFALSBonn7o5MgM+DwzfsefJ+ZZb4jhYKh6eqPECH4Hb24A9vgHbQJ4PTWAOvNxfcP/2huM44PMVx3FiJshjNce4vWLff+Q8DDzg4ShVuOASLdw2hO8sez+rgEHDFUHQ2XKZBJrS0xZo5L0rNretDaDFnRNlUobRfBZYLGnABKWRe0yQ5xTt7uT60TNNOFyNCGcVwougNUkfoJpR8DlprRMT0Yg4lOUwIKcCAgTMQln7QgTBjpvWdCW6bSMEHmYvogmcnqyuCeyV9hXBdYnSweNw5xlmtfQtRFHi/fMq1HQ2rFZyOGZ11obGNByrCTxBKmJJ9crqhFnofmiNm1/AquainfhJfZ6zDNMBm9Y2HNfMBH9yLMbyezGIynBVXnrisMGXmpRsosrSrMwTGGxuGhbVYMyASkQZjuJnvfk6v7/+6qVh8hq6qpfuW1xeqtElnit+2etCP281KPLwa1VDSmvX22TatZfziTpwVTLR2ALNQFiU4RWwlKrH1wEa52QWxQSt51PZWrL2/GZg+aELGtE+oHooHZlDlDVlIzElfynjHspvVKgKAE4WtxxwTIz25+0X1FBOm0B51k4UuGiWVUpoGUQT5RquBE6nXeqb5FIJHNtgRTeBOoEZhs/3wM8vhs+j1KdionsmHjNxvJ/A+Q7UxDwmm6yn7EBNXudZmO/FWRXO3/fX9/3uv7spmUuCz7jy1/daz0+BR37qGQop1rUKgQQOAHmc6mV8EBvMUoBBKd5U5cqq1jH8KfBpPFSTnyVWEdqp53XFc2l8xEBlAgcuBoqrb+U0TKlz+SY/7QULUq1DVb9eM/sjsZsj44aPmjg+TzweJx4zabvqwmUG3svwZ3qggK3+6HSYiOxKh5nmZHCoXvjANsgiGOqVjMEKRmxDqpz8b0raSuJWgUYEgxQrBTmqnlzYlc6r2OInW1IrUCgprq2eEbsWiENCHlL4bMpVqALY8Wbjf3tKsK+Bx2ic1o/vgu7ee73ssiEN+pWg6gXyTM9aOBp6pnVdajPASmpfz4GMd8zRJ63P97mU1nMvuf4ee1IU+3uv3xxodJl/bQQ5ci5kAmoa6r7D1zkTcPVF2SopdyMlnoxzS2rqMvW/gkh9o5cp6MqFZFbtigoVr0BBOr/TDfttx+12Q4wB83EFOclN0frD6Oyl97k1HSsEDPt+XBr41hkSIbfRFqJ8LTYabJ6zm3GKtrtk2jSgLxxQFF/LyuTSfge4yKvrYUx9yagbfA6VSwkuo7AkNlkZY7XC5Dx4bw3l9DgDzEL3gCYoOGrJUjf2bXC+SMgRc9hR91YGUpuHVY9Kyd6WNOCD/SWmi4oCagRGUh97q8SjBjwLY0yMW4rDWqhxRzpwvk+MbeCHuOGcoY3nuO07fri/4Ljd8UDh83HitInNSCfYbjd825M65vGNTFdVj8yMDWOxIcHJ65x/4UuWb7LNGgBVh3pTEoCy+sAWXmEST2CqFdS6TMvyNalUejZaHOVXKXXRFU37Qd9BKkKrGxUqEz70BZbKkDM0PlMhiTHoBHitZxFsTFUBusejQDUnS0k0t1LcyqxPVq2qSH1qXdGSs1gUlFKvda3y+Qyw9CunSlBEXm+YkR6XrAB2T0XB0MJd7J0oCQ0Az6o/UQaf1Ig3UT9K979mcz+6GGxdKtF7+bPDixVJI6c9l/OuawPrM2XnGt7ZFIAh5nQ6qLAn+3QWUPDFxElVT09jWbq8r4Ps3unKoiYDF1uZp99fv36Z1AwSdCymNDAljbsc8FSV6GBB9qzHmlGwh6FvIpeQAJ261oyBA92ggKCp6BAN1XpNQwPlgAzRR/TG0oetoAnBAuSiF5bO9ZyAR9Mbey3gQsN1eUio2gklJ1LUFBu0ReYUXGYyZgJOAYYxBrn8h+ocFmvWjg3KTVf2vBvQuT0lIVbFB5RM9ZgEZ8GAQSJNVxa5gHMEzDc0OyAAjLEj9hs8kkkYTJw+8TEP/PzLxOMhzJGBOQ3TDzZDO1Dv9DWzKMc7PZfSHsCgLY+JOmk78lDGVt5Uu/taTxff5cLuWLf8+vdT5eACMP2eWm7hTOCogh0pfFNoR/n8ecnLLAyj5bb+MJahKiBUgcv+fPJm16LP6T0TMMzL7/R9Gd9xYpL2dE6EbPJEgUO2ODUdDtRpqGOHxxv2tztqG/i4v+I4Bx7HOz4NmPgZtjnsCAClJB4TUdMMORosdjWjWSMKfGD8W/QmDzV47wPbFmu699gUVNiGMFUv4mkon3AUG8RbBtcREbwvCfUo8N5nGXBi7TEmsOxaDx196hm4wCWr1cRwTNmqkl2s0DBZWGv+k2u9oFUmjZh1BZclO9RYs0x+s4OQlqHu/WYrcU9bdmF0LwCjiC1WYNAYHaQaOliN6WWrRBYTh6RRdVnWeu0UOLxWCXVVDH7T6x9oBidtpy1OO3g+i1ogt5tXnsspZVeg0OdVumGuX8hGXkFGG3iFGXr+T5So6+HzHzq3evrvamDHB+Lu2G87fBuq7kpR331lrhaNxejAUo7BdJettW21ma0uatIwBl0pagtt8MXpCzCjTrUF8hTNAu7cRBaBcjamloEKT+oT4SAvUmJ8NRwR3FCCWcGIcxFzAoAja4N7YYOqu5UwDILqouwmfNVoVtRdpobjqiUnyMx0YvgVnNUAm2eHt3tbk5EBqIFY98ULPmVoFIg0i6U51l0VMQuEO3wQiI5MCeCTL5tJ8I7NMdIx847uUagq2HlQIWrsuI8NicTmiho98Pngue23FzYLOjCsdbQd4ZQIsCwM4xwJLjE2erUsZTopSQZlHayzlE+DqLojtQBYqHHUEDYB4/eUqhrVIN1M1MdEu5qmYejotBdF0Hq6eNXG9XD6ZaxCxjIt2KNnPVPFqFAWxZkqT2vd7QJsLNNP+SjHNPaJuKoblnzuKZk/Q6s+8bu0mSnbWxQ2KCsGYBbUZgenzqeCo7UOq6SiZhp0qbWn4P7qjeH1une1oPeYgI9ql0iDx4nyiTknkwta9wBEHeOQw7NkE7yuzAgIeDrooL2QZHCBMznOpq00ZaR5/VN+y/WsDTDXs0+knA/tZRIkF5Xo5jPX9PfXl1cNqJfi+ad8Plftnc8sezs2ICwjmDeIk8xfOrqfQO8FILegdRhYyTX5J1fwcKFDgw1cTuopyOZCaHqzLVBKkErbvmtPciI2B156xapGWJcjDagTa0AgBOF1CvSFHnCbTCYhVyX/xITfEgMn7HDeAzOORHBDDVYHmyNp7rCjMG3AHrWy0v1dTbHN6ZgTXLuU4oPBEAOIbQNsl0Nnb0JiR8QdL28PVm+PiaoD38YDP54nTiQ+C5wxtTmpoceJPAunOvFTPtG/kMYVRqSCxaeM7Fop1nYPC+C3DXleVP1o1/LCFXgwIddr7vkTevNM2Y2uLEN29bqBpWTpdXKqUC27Clw9rZpSXnXhKpoTfmNd31+TSToG0Ib0iVkPFL6jEjhmJw0Jkm12yG34MQpvAby+3BCv3+DfbrjFhvuPf8DH+4/4pX5G/fIdj4208FkBOynvjFHIcJQGJVGaXFULN3jo72GUmzWpSgUrXN6BhYIMBg8Du2+ILbDtuyoXolTtQ3K3A9vLQOj/TBuljEH/wnNg8jlvff8TSwLWGhdxj5nM8apkgt0wnEkSzZpcz950vd3LB4H/8gbo2sN5PSfPjgOJ4Rj4P+HcmjyZ1VvRqVwAbmv+lHtxHkazBOypcrHKJFq8K9hwNJ2sr6DAWV+zXP6xWP70Ph/5RL8+9fdev31gn7URpYO85LUUeKC3mLK6wBWhdwBh/Znq0OHCX4QPjUmgJ49L/hbLZqgk8PTf138s8lSXyJ72OucecAw9o2fjA5I3mXoAkV1ee4rcADALTVoIDRsbsxtVr5kWVkvpJxowqfAwS41N5jT+ERhjh+9U4xh+cRIHWmeZWYHyQuVg9M3xtOi8DPmYtoAKcmAaa9vVumqVpPUIzE8rIMQ6LKAqGFQYpfmGHKqbIwOAq19ABtGhIFMbkf6EsxvKsZRRKOPLMv4Mg+Up2TZSwwjubHEM3U2866HN5gRylODBsJMc1jJgGgw7NjNYqqkOyYpNFW4v97VcXHQ1DhSS4oMz78L0ntZ4XlF8RquOqSlZAUZNGvWUeospq9ccfmbMaRu6ulQztIcIngmYJ7yH3Z20VCtkU/Bg2UFGib6UCgDoYRgws2o4oeqL0xS2g4n2Xwa4FF/QkV2ZzKYvYNJDvJidLwXthUBygB9LWyRaGNdBKXCw04WpCi07S0W0phcAAAfZxTQMvfeEqkbFtEmCZXsrrS9XAVdBPLIpZEDWRCjon5hwTzgGpg1x0HHRFicXrK+ta5jOZxZIuEbqOVq5Jq9nYF2tkdqIQfx8Zza5g4c5cTorfqiAq/qUkEOZPa8EIClTtlIVEpa4jc6pndXvr7/5yqqlugcwiK9ZiEztM39CwrJZ0KPXfXbHkl6HghIGoMIcKPHZL5/CCgl9mJWC9ea6wy67A26zVCMn9yxty8yLvtgesVw0zxM4J+1qOhUIr+zMIgQv1k7qEgGJFQj5cH9gZV9ZquAHwwPG+adwcHaQ1YQFp4mfxqoGekAeHGETh2uA5QQ8nLTDk3IGc9JGmRlmXv4SseG+7di9n8NEHhOPI/G4HxjmeH0kYjpm3JB//BGv/8//FT/+1w98fPwbfgmgfMMIQ0xOqZ7bByonKidkgWlnrvzMKkh25anjPPT9w1Mwif7b0InOrjw8v+zpzdlvB+HZAmHtdqvETKj1uf71Or8vB8cVRILFCk+DB4HyvFLfurCnAKirTF+upYMmnl9OJc10fjPrCVYVBUgS8N3xhyPwrQI/3oDjLXHOwtvm+Cd84Oc/JFC/4PjpE59TSyrovfqe53oO6rtwBYPma8+5h6hRCjJEk/KNA/eaVhdd1eiG79gwoEF8CjTGCCpMYcCFXWC+aGZF6VC4ztdN2KyA1X8hO7AqDryx14R2h+ZHqbJ55rX3EsAmG1DEBWi3JVzfe3LxpYzy9c/y170Q2mcTXI0roLRL6a2fdH+Vg8qW52wMq+8t2Y9x2RrL0eGovjIXsk8IdyYwSgpzfT4SnzHQLP5Hr39oMjgrD3VFNx3xKzDom3CBCbtObN0PhRVGcLxUeq7t3S5XQU09fY14qnXd2HWPTIGODC3LX30LGUlv44b9fsc2Ni744srINMBDClBCNQ3yDagwmBrgJk8L4TQeKUqYlSG1YEz3qAEDzHVaNPKGYHNwGNyGJNgYdNjgZmQErqy6yXgu68k7lekLoKQTzJju0yGAFkgB0qa7qeJkDquOYk2Aric7A1aUJu2FVkaVj2mOzeZTYEww1oHo6ZLvhMLPBDzakLMSE+7KfuseAXCjU7PJPpKqwJAiGB+Pw1LNbBZXydENUUOb+VRGi2+jc3VqTBsNiRWzy+UTVoWwwaCrck1Rr1BxNXkv0zqr3oOoHLlxjogLaCRYdu6Men+3OzR7onCGKkRP68XsFF2AICB7QRebr1uWOFBqKvfLSWhuRliKpnCBI1fVpMvUZ5cY9NH6VaBR3prdMkFFWGyVzEJlYLrm/w7DmLkqOKZVEO4srSpoYS9GrmSAGVaVyGUlzSHn2GVoZcXQwQ0f7QwZXTVQO2u/fLZwbH1sBZDRPSzGn1ppCFGQEpllS32mdexZYSVU6YqICwVo+1MJJGhPcCYrNhretzK0Xc0sjuGb4PqdM6WElKhI/b6DC1OZXDQwcM+5DN4/OPDof6pXlQxzKshzYEWnSowBve71ITlvc8lLSzUH4Lpwob1EI8JaFbbmm7fkcHZgKMosN6B8kQYJ0ubwO1ggY5DMVdvBio5pWNPtoeqx95rK1J6zhY6voYLaI9pTqH4fWq0X5o6MwT6HSoyauG0UVkg7QWls9Xdp73hRXnka7U92Rc7AIeKSPTdQmOLYkhGSnD9lugHEjrIXNSUfKCQyJnyb2HBgTsN7cA6I+46Y35Dv/4Lj5b/iiMQ5HbOoyuh3R5yGGzhrZn5MQCpOVp2E40WngMkXQPX0Wv2Fdt1zDdTCmp+1cAX/bnvRWKQDkwv4WxuXxc4AalXR+nk9wadrXa51rdNpDPUMGPuNvc4bvWqNfgk2mgLT1/+lasIvWhUQgWKPYgL0zYA/OOoVyPfC+QF8hOHPeOD9lw+8//Qdj+MTpwE5xXppoA4staMyQ4RhhGFN+R5SmvJBetMWiwq1jQ0+Nvi+M6AYoabuwSbvfcN2HxgWKzk7wrFJtdOcfYZd02Syl5ipk6PVoF6BHPuDCr21FpBX8tCangiA0HkAPmFxTRSH6GGcUYULAvfjSQBBX0jHZqJwOpORnpfv0x8mO7qqkNefPmhCiW1TUsGQFWu9r+vUeXRC3xArscVshfpsrECk01ygDuC1RrQ3mKC+cPa/9/oH5G2fDqY644K9dRnxXsxdEYACiudtbk/HgF3/7L1yRSy4StzAoms9w+0SOPrShLcCjuvlHrjdX0mdonKlpqcy67p02K0Ad85BgPTve7JycTInQDBp7RQEDdgwnCqzKTMPZtJdUTWj+FrVjJ5YGWODDQ7pa4YPzfxETyb3Yr61uifDFaqpodGSVJEpikd4V3XkyMStMwMiCZLSjFUObbDsHVP6naoDdFSGgSKNykUpkVReGSUP3SiPe6I3R6m6xgbberaeyYGBAQP8ZIQtqVQkUHUACrSIAWItd/pyratyUXUGdgH5NLB6YQaPFJWNvOJrzbRjbgOiygm/FdMJ/VPnXakm+GfL4dyENGSTWUQBHmj2gqGDGIf5RCJW9gjG6kI3OHsv5CKYrpqUH4ajBzgwq6ghcc1VM8AkceyrclSr1A4Xx9NZCemABKqAuZSVAMAqtL+5ziwvGhWXSeo8CyiGQLUspwEhkUXdo0WkVFDZIMwSyhDVUsRyKAgQ//U0gTGbSFXc1E4tjniqyqDvMvX+GHAKzJkBNpKZWqlzUcWLGdgEs7Zs0i4FcGDfi+xaT5kelnB3ylc6m+9RwYnRBSQGQs1xDCR0LybXVKg53D1Q5diLOvo2HKmekplAT2l2yR9//oby9P+srwJUzRA6aBOGS6zh67ux/PQCFErBFkRhzsRUyJzG9WHr2Ha5GLtsRR/v6qHQFhEIY/KhM4+2+pYa3K3ieWPB66vWaZf2jfX+Q9OSDWoEecrW8+K0hdB9Egw2eJyRCffA6dcg9Z5Y72chMHGue2Xyi6bqIc9zwkXKcSarJGvAUnXCTs7V6JRvShKXvSQbJzzHhpwbvmvY380Lwz8w/U94vH/geE+cBzBtwieFMtwdeznOzeGHAYcpI2AL7GYu/L2eSb8aDF9wgf+bbZv7fb2EGq3Vl8NggZinYyx88Ktlh6e3PT/Xa1ZCv80Wg2QFLAtoXdjpin1KoA+L4MH4gtjAVQW7TnkhMT3zviGOClYfxgj4vgMI5IchH+zz+X4UjvfC5wfw/gE8JulXc91M9WCA9Foo4RVGHBTdh+GkjtsgdvIYq9F7jI3zziRpu4lOFWoSH6FZY83+aEEBKVXBnUkEGKvRpaAwLx/Ukv6Wq3ikkoD2cjEhyoTbU6AGBXNPC+H5HopTQX+yAgUsf2jV6XXBhHpiz/SAzrxsR7Ot1urSsUo4tEtqQjgLiy87aB1s0/74quz2WjF0k7wVUBxMpSUmrKslt+bPKsH4qy31d1+/PVGmdblutxYtT+LiavJuCLAoGuoSLrcP1gZakRsuo3XdnD5G778r1FksSBnqxnz29NtFwdINGWPg5WUn909ExkQizNWIWrqJVyF71TXoyZi10XwHW/eCT8TE708Z1AaDzWs3OAbASF4NSvsY2G4DY9ywBedCOFoOtuB20qDDMLNleAs9Z+CSjcMTn9SYcc2rutEVqM6fdfZiWpAO40Al6S5sYBWXWRkxDn/pZsmJ2dFzDykk90lZcRO4VuYOzmY8o+MJRdilOSQMTmplsc0gyV+BhzDNXlA1C+w5qKYweAGpidOKSk+YNs+Eq+maz7KWtnwZyKdPUqkQlCB17dJeQ4zmu+yaOK047K+2p5Jhzy9xdOuWmy8PN4uZHi+DibqV2jcQqLc+vynnYL7mu1BA5mQ1BECG9uBUJbCPZXzK6QTgzf81kIdOBapryrQDgCfpeKY9Lf53ZsIUOLn2qnU1UuC37726hdho3j059bQvlWHtzFqaMaAzUscI7ly0NrChlJEzKYZgZeGUdGy4cw0mGBRV7zOZhWIzm6vBb6bu7lNQtgEoo4BA5YUgCuBsEnR2Lrj2q9ewAsjkJF+XzqQJVTa4DdZc9Mz489a96t42BjYts62+GGVQ01zfzWAI53KFv79+/Vq2AMvmc89QOeryXde/e8+Rbqpnp6oGsVzbKawq+gU0RC6wzpdCe69BH3/UleRVVVF1+wqGnqIJfaix5oVb5TPNLv+oakT/gIqJRl42El+a3v36KgYjomSCdEMr0f0idO3idWdgKesu0KKTS5qtKmNCwxzTJjjdcAhksQKtdIiSNAXHwapyAcXmGs5zuAUqBxITVSeqTmT+BY9Pw/c//wWPz4l5FtIP5Jmct0fESLAanFWUK1rre/CrqMB+9XNrnHI9t1Uhkj96giX9lH71kPoeP0HR5w+sgxueP7789a/+G30s6wo110ezDfB8SFWkv57I038/n8gTOJSHu4orAFkewxHDMSrgvgHYkQ/STxMT2NgbUoehTj6zKvV0qFemTHV/h0QyuM/CoF6Ma0aGxwC2rkpw5kUHGjEojrMNNYMH+1lbpWwbpFNRoaqrGpSq5z4T3VVqU+wTmkJC2hzXA+L6VyKgrJ9BPO379aBpL2rKLnQFpxZGMa2xgnDJU1Xs8qUAdH+qsXLblnXEfsZab03T7vNAXbN+ev1Zz4LrJSADhsIa7GN+VWwWn8+e1gb906qE9lvTrmSxff34v/f6ByoaF0Dt7GU/gLVvF4AxLTj+sK9TbFk6fOh3AuvVG+qJKrUcQgOcp7N5ss3XNffus6dgQ9WEse/Y7hxD773YJeNpRk17E2WJgVMrWcnTGAioEeIGXdkDGgouXoet9ZvFzRv6tZsjBOwtNox9x9jJOfVwDMQCR7woNopaR+FGSsxpnGhrXgJFPQdj3UmYVEUgRR8Yh6QxMV2M+FGafWAwyc5aZ9f6+uCir60j637r+VsR8UrNaPU+gLKPFSD/t4wTkEEH5TVJFfHmAqrpHN1Yq8wxRCTpTSoDTOfv/I50rcLJKdm4pq4jWfIPreFu0g9RHWxRE5iV5x7KlYHp0VmcOk2DJTEyAQA5UaeRcivNMOF64eA51bzE7bwaiG1lGkwPOKsb4/taRLEINjlydgMIZw2i9jgNFgqZ1LUPge+VJq0ihae/Tx40jQ6ky6BdijdXY3JnW9BdWXmdb0LUn5ZXTjD6Da0RUu1YhWkXl5hmGApKs8b6TKtqkFp4oiAKGJ8In6f1fSpVn54AmNlqqOvGcTrXiaoBT5Wca7lZoJ+x9lLh4No28f5rCvTzmZ9P+8R0fjOUzChVyYp7bGYhPDnZHazsDQ9kJek2VbI7A1aFOVUFZRMH15qC/O23WPP/SV/ekbPWe/tcijHU8iMQAGBvXvteOWADxB3ELPHWWXKg/dSaQ2ENKe3kSldHAFyVNWAF2aRi4WndiTFRhW7r7OpDU0/SsRqXXc6s7U3KzjenoNUEL9lqLGDDv2Q3db5WTGhtYUqWkEYcJ21oB9IneIw4+07bOqHSF1pQmpm9KQBsI921HDZZraZC4WSlzighbWGwDFTdMLYb9pdQZf1BOmROnO+/4P2/PHD85Rd8dCBYE+nAlMztHN336BjDkZsDn4UOmhZmeAJzvGLe76taofslK7cSqcCKC1th+hl49dK58EqDw7reA/t6oOe7+Zw/+BIQCcCa/HXRXjWOqnzCQ0/Bk/V/27XeXMfoatn68sZXBpjx/r3cHPcROI+BEwNzDhwzcACoeyKQeNsT3/YNvyCAz4HTB47hGGfTCGnHIvin7w3FjphojeGqYAzEbWjeBSd9N3VqSN52DJeC1JCKVCtRbaRJRSCCAi7DmzalxwqgKcRYNUol/IwV9PKSdLLgnrBpoZNsT5UCPUYUUJmkr8f1LDrBukSR9MxJV+Luf6YT0+0TLDoKdl50x9I6rcaSVhebYrnTC5c8/ejJV/LwgQ6iiN8NuvYnW8WiFxk8rYzFBe5Pi77kk3NVhH6LZ/qHAg2FG/pvnUM90aRwAZl1kV8+I76qwKKbNrRdlQPyKp8hzfWtbaT75l1DhPrm8dWTk00eJ2Lgdn/Bbb8jhib+9uKrxshXZplnI3ioDGjql249HdTBjOt1bc+GheBckb6y9YnCNgwIx01TwDlsZqeahoIRw5TTcA0RqqU13TKlqqXy+DIkK9JMoDx4J5raA4LNrATcFfS1QQZQmtbcG8IGAU+lQDavy8GqCh1Ic/o42M8bdDdgVzjMsqUWrigI3lWuHn6WGkqI0PMpZRuBVT/MZBYaeKrmsCpTJcld58yEawI3qXGUIJ5qvlS2w9irwaZihiLZTbs1n66ZwKArVfS8pMFFOdJJieFOjStB4Pz0YJmC62tADeJQrK1nUDT2cPZ+kMGj4NudDY9GHjQwgGJlZ6qe0Cnd0IKuuCTqRrpmqZxw66qSnG4JyKDUvwAFMNwflLxNaddzzbOK1dPklQEW5cgKK4AsJGIyiEwrGFjW5jR6ziiYmtI89Tlzija51Lw6o6KWb1UccTn4ZQ86U8x1btEBEK+/2pw6NDCMgdHK2CQI+o3BfsJQNVBZrIoFB1iNGqvSFVUwUSm7WujRFRLO5+ihglXM6NnE4tO60uVZE4HkxHC0phmDe68CKlHxe6Dx915+aj13ETHbj1zPncDMldDrdaJtIzvYDjxhONX2FYUFHMqNNklBZhU0JE372Z7AoAEVaqR+omkBPH77C2tqk74DK1BxTCslHa4wvwFICqFe+LbYSyW65hdAa3RvmKp2qNruCqSqODsKwVocK8sJm4V6mGZJOeCTGVWtaZlvaZO3n1O1wg7EaZRGNcc5Az70ng5wNFdjiwe22hAvG+ITyM/CPCmD+zjvOLdPZDryvsFwR/nAkR+Yj3ccjwM4J3wCoxynD9igP6CCCVZFcZYoquDDI0bABfa0xXifyZlvCgnjkua6l973dJOXj1x3/RmbfX0gX97V2God9ulDtaZSrwADwkUrI65F3OCogwqzxbpYykW2DvtljRjAQba3wNvrwB/M8dPh+KkKOU883BEvA+NHRzwMby+Ff34DxovjmI6PvwA7gD0M53ScQfs9XDMlQsEwwGBhY1UizDlwLzZst51N3eH8ewxs+44ww9joN8JJu4ptYI8b9hiwGMBwmCox0SW83ou6qY6pgC1ULOr5ZJR8vvpw+YdM6p7zJNwKJjhXir0KGQUbdj3LxmsFtIRvrcfVdqc3sWmdueiQLv9wrZcq0tBTgSIftWwXTGvclvlavqiXlHUyks9gVWe7et5VeK2ZCiU3n3BJZV1+a+FlBXFfAuq///oHmsEvR/ecXGuAb51WtJVn+RIYoCNq6xv1FJWhgeh1/NZYfuah8sJXoXNRNK4AoflkzxEmMGLg9e2O29hExQiExQoizBgBlqoZoX+XtRlQ03Vz93Qus7PbHmp6alUZGWIvlE1lnHzRtkYEbtuGbXCeB0ZLvhYoiWCNUlfQ5CigTvZQFA3IynQVUJUqcTNDa3UVBrOuSBbVpUCprWuxW3VbOUOIUtSdKGy0sugKSBXnuiZo3BuolYPZhEnVCQs1o3Pp8v8o8cWAqVIthEZ0YFNGQEFVFpuf3RS587y7WZySj6AMcBvz6nUX698cnk4HCwNqmhhLXQasNR2aayDR/EeHvr9KlSWVhwtAtOPmKrEnlQctToJqB+okCvI42dTdDc9t9Y3BTICGrmQIsxJeJ1p9Lft+W2EEm9ugwGDtERkbFgjb1Gr662Sq1Id2aKVUNBzsta/rT/K+5iqzkvwQ9lSNUZCVAKxI1+PEepE5zdDUQcZ67KnIUpO9JZWyZhH7625mGXpuRys2WbIRlVWAQqtOWVdI0wE/UdXDrmwBUFSt6k8WqR4GPlOXEaCWOgUREpviEt6jRGeLu8n95CpW1ifR8sTUMy1ncFvav+1jYOAgTmdzP59loof9uGR03XqGhyDd7LTL76+/ejVwksHzduLLVqZkyQXXa9LeXP3KF2LvLLD7mvEjl3oB6yeeHj9a7fQuXxhA7QZ8YgU0FU/n+3Tylc8gtUAdNlpiqsAUpgE+r6SdCQIZaNuIXXz9rKfO93czo6mKfIOxDUzwFIF5zUTZgBswRqI+E9sgX38Wh576UfAhEBsBC958y0AeQD2MNj446yKVPPItAdsQsSF2w/kAHh8Tx/GJsg880uCPgahCjMJw4LYNPF7v8Pd3HGcAtsPiFZsPjPzE9+Md5yNxFquk00P9hAz0TSA3s3htaKrL9eT+9mLqf8q2r0oBvvaCXpDlWn+4YoB1NNPS/C2IbEUnWhv9xc+/LmCJeXy5lK4IP1c7ZMNcfsOvoFX1YHgwADDfcEbg4584Md6/J/L+wLE7PIDzJ7Iz/vRjYv4/gPf/6vjl3fF4GM411NUwsqsoOr7k/GNzhO9s+B4DwwHfDDF27LFj2x1jqDrlQ7L/jrEpiAhDuHFI374jbqpehCnhQ71Aqp6zv9K0ackcCDFcwBkY8gldubRxScSmcEUmrmfQeFNrAtHYoljle3reFybtg+EpC08M0vQuPgPjXlKzetUVnJhBtHstrurgyVcyPl3HV3D8xUAt/2NiKQjLHYXyXCueySwlIP3p+3XrAADjCVjOX6/Xv//6zYHGUkh9+pmtbDjWLupySr/3uUJRWni0f9eO/bKN6Hn1mQs88R5bY8lrj63slF1f+rw53TBuA/fbhhiioHhrOUMltboyjg4BxG5o6uu/go8Gtez560EqApKolaVamQVJw4YVOYcx4Htg7IYxNKSmI1YAqMGMVRWbfqvEWZdR133qJtwrK+NrnZldD4MN3hzWxv1oytQqC1wABwAaZxmkgfNMGZRM4/cHIG78VUHiHjJlpyXHarbuS6eNPMGekLTr/qCzMwB56Q3seJ1VBlvUL1+g3nxDE4Uru7HKRBnqZdXBFYAqgWXtHgeBBhyhDGCFInrybgA/nnPLqlzpm8qB0RkOX+Mczl7xBZh3EGJL4s8Fhpn9pq63d/O5dRZdwNQMBdHfjKC2CqL3cZibp8qfCQFeAOmIwV6P6QxaSAtKVl0CqOkMGP2EbhVcVK6poLinbLuqNN7iAKp0MIOqKd9p2ACkhc6jhQLZL+Nm8GRmZpmLEtfXSR6hJKVc5DKkdW12AxAFb3RYBOtK+OMMlpWjVOFahvbKLpWR8sGM91jBG2uIrFyUaB+s8iSqAqmKFGfkBKpOrIrs7KGAtgCew7kXvODJtUdVsaaddiaJ1ckqYCrRYMUpvJqrjNOk/oXfX3/v1RS6yqYEyC8oieAF2Cx09XR+WVdPd7a99gk6/UlAkc4GypVgk48w+R1rNT/I1yePgao1eZxDL+UT0P7s8pGd8DAFRi0jmwJJqxKhvXE1pmPt4VzXkKBQCOljzGCQliE5On7nLFZ/jRVz6svVVREOXoiXsZgxmdBwgXibun/pMJvyR4malL49y3HihI2JqKR8+xiImjg8YYOzJeYc+BxAYMLdcfMbbpvj/ocB/z8K9f9O5OdERiJuwL47bu+OMwMf4ZiZeCQnZncfW5TBt4G8B+aZmJ8H/Eg8aV6g66RoP98zTp7oTD1ZucHmqhIA60ANN/qZLtcLfEmuNgb61er9EhT07zsbvug1z99pT8u2vzy1/jrMeE7yxEBFrF4Fpn0mcJ7qtRPuqUQ+gM9/deTD4HugMnD87MAx4XjA7wX8aeLz//XA433Dx/snPvFQYkhJUWfiFBasFLhj2wJjD03x3jAisAXgO+CxMdAIx9BwPffB6sceGJtkb71nbOxsVHdfQjsQfjjKsMOklUOqugVwmoYmFoUMOi60JUcNBSCCCMWqWk5gbgzUXU+LVQFTMtzW/V8xQPTz0c1Vost6rwMcaGn9tGhbGGckcoLqWABKgiOjSj1T9H2G9mkX3mnzZU9rfNms58Cnfz160dVaUCvoKH5PW6iF6UVX7xO++q///ddvp06ZgoMnpE9QvIrACw9cp9vsNv3rKUppjngfu0OOjgpXZNjhWP9LG7k/07/pjWd9X+REwh37/oJtuylqp6RXQtQUyXqaVlkp0CE/26/stKY/AgRcra7E7KZoDhY02Po9LNSdz3+PseG23bHdNkTslLOFyvHoBc/Awlrn35uepMmWTdwFG+5gyfOYBiQQmtnAa+GwmoTD5sl8VxjMgvQmuxZRKtqulurkfHA+PYMy2A04qfhhKMxsyhSbVmvRpepp3RhBb6+XKkSyX4IALy+FCAR5nihmAFcTA8j9NAO5R0maWUDKEDLAaSvm7OmbgvDMfuRQj01htvpDOYFyEbCzLWdblInumyg8B5DOqb9+OS+XR2piRGodUroUUphwwBPVw3dAtS1KbWpoHTSRHH3+zEQQaANWIVUt3WOHjkFDn+p1mbDVe5oBDlbUFk5PzMkSt/eaN0NTowrcD7NSUpvtEJ2T0Us0sjovOhMUdHK8IdDBupUyaaIAKMBwVX2+Ovcp+prmV5TJuAWmM+hcGLGAxIkKNoRyVzwHd+w1KSnsNGUFxsRMV7B76IutjC/PfrqIu0+0m2pVuQKQgcSJrKZ4MbCAn7KLoQAqFwXSVK3qpLir0lMuqt7JPWQClVXA9Cfk8/vrr1/LsXCFUhJctE+g1SlRlcigrXum9Hbc0T6tdLvN8wvlCfJZTScUUmF2UqaU+0v7srqOC+2vXu9PNAgJXqh8Lyqyoudkz1PbKMBZ+bOnwaiOy0cpeOWAStnDBjoGAgMdu6sgGfI/WZL4DO7hpI2aAJu6la1mNN8JQKifQnMtKjBjYoOTcqR5Aik1RNJcr8GcsCSX3wfuxZkbaQEfO3wLhA/UvwHzMzHtRM6EfXJ/1O7ATv8a5RjnBPJccMvcqD5UGyj5llQFzLVM0NWr6h/1M4r6VVbZ1uNfQUZBweVTpfFyVWIb9EerDc2ih/f3rZP5+hcu2/nl0OAT5YGv88ACkvZ0ro1/LAJj3xDG2RJ88wNHFQ6BblbqCjgn7B2wEbBw9o+dZHpgf8A+Ex4T41Py+seByE/OftEke7jBnP0UTXcaGkq8xVi9FiOoQRBjwzaoLBXBxm43BSax6f3dJK7BfT2Tw69+ObOSspWuv657BOBiumi7doqSQg2lWWd8M9uBlKjs7H63LEAMAidtumEUMcaTrzRfX0b1T35jVx9tbcyW2VXVcfry06ii/2j8bRKa7T7BklR8Y+m2Y2uNX5j4eslOiiq9bsjzenxa901NbyEUW0P6miKP//D1mwON7DBDJ9COviO0FROAJ9yEDUMbZ97Qvp51H3E9mOdABIbrZi9z8OuAo67719EHtJGL3zMi8HK/Y9s3bh4BRTg53ATSWhhNU1B1otbZFdjJWwI6Us5Zl7wQJfqtUtpnExMGYNR4Hntgu1FdAXH1F7iCER4w9W9OkY5uvOmSt7LKMGWcs4SPBO6SnPpeyqM01bkNVyvlOAFZT+9e0MfzepYFZrCrlqMiRahBrmYBoIMmAlMXdx0mrjuUNVdAk1k41TtRNpkxqCC4hF1DBlUOHw64bUimCmEgoGaQ58wyq1/CGyxr0l6DBTOGZ9zwOg/jOhhJGldaS7j2zIpTa11t7qVM/hN518AhcQlQtq9cMJ+OP1ujvzeQm4BPAcU+iKVBiWsj0EBwXXFS9BD4ptMvL2YTK5djMdSSo7yMGL8/rdYQyFTgRdWp3t+k0lFe2FmmoVC+nrHuXQfgAuFlwGmkKw0rpIQIDMzGkG1C6lNnCFj0dXGQecK044Pf0eevzG1B685dIXbiRKGcet+R3ddwyuhzXs2cAOzEmlPhJodEShglbntSOmmD6/tw8XkNk5U+8dwDpqqew80vQ2w8M1YnUtUJgx64nEwIuBUm4qmJtzTLR8GSsQpl6Qzgf3/9zVeLFshso7nZ0b4RtkCjCpn8XPuYJyd9sQ6e5lvAVmKsg9Nn371A6lP1LQVOFvvqCYTy7fYFDPEc7fo++Vb0vKHObuflV69c3QWgAGitPJGdG4h2Qquezt11Lt40LKzezxY5AGz1y7VZRn9uTlYEa1L6ts3+oI1yJ2+/oGRBsSZ5Fqt7vgV2d9wK+KzCQyqQDgCPE/l94jwobZ1lsHNifpyYg7wNL2C4MUNcgcyi1HAGup9QbhHptmaGt/nqdQA9o06MKGR7DiO0XjoiaGTwV5GAPMITHS6vny9Icx1i/WQFb1ofimyEueppDTUeejr5J/bFMp0hhct94P46cEPAk32fOXnsTneZOQOLTRVmM6lQhShyDt8chsA4B25hgBsOB46YiDzpSzwBZ5P2UJO2myNiYN+vQMNHwM2whUltalsD+3wMBicbG8PDhwYb888WGuwadq1fYR236wZwEF+jTAnj93/rfSshiK4qXkHIVZUq+WDtAZjWvOaq6R5eCerr+a5l0RWNribCVqBLe6GKZ10VlnUdyZ7H9cOm6PWaFC4BFIQ7LnncPuZaOwvR/lUi5Mvi/LIgNbgXrOw8V1Ohqsp/9PrtFY02xl9CI3v636eoahlBXdRy3LoZethd3qvqaM0WPZwbrqslX8IRbT67vnddKN/lfSwY9u2Gl5cbfOwwJ1WmE0iG5sjxKlwPLWUELcn1azWsvhEGh9VkRIEAtfy7XGgCWGCsUEAMcMjQbQBjwIPnE06lpc4IFxJSuhTwEBjrtDSEU72pF7yXbiDARxJ4+mD5W8+mHaChYLPU2MxKCLmFVPwpgJQBAXgkgVnfdm8RZQEjc6O+fIEleYHY6oqOskJeMu89V6LBXp1s2lWZrowD/VzPd5ZhZQWgJmYNtiPVp1ByHa7dl+I0wwk0cjowUhno+bSOuUaJ/zhFfdOa5H1lValsKGiRGpbT+Wf2rjR9Jkgp0HNEx6ZIIDiIbyqAca21VH+EKUjrPcB7x/vI2FLZzA6EQ2BBgNyyx11OvucpO5oKSpty4YPBQpxGSp+54oXJ7RNrQ+tekaaWok5ZmKosABAKuFnZWEMKS3vaDwZ7GBxQZ6bhjTRqWamp3aSgmcD2WDxYY0VPBn66s5dKFrZmAc5KRNZYQg0E/7Weta99fgG4bFEHRp8oSNVKlRSUKprQGgaDQTqUFJXRMMwxk1giXLQcGEIli0xH6H6dXiIjkpdPLy+hAJd967K0EF/3jXWm7ffXX7+aVrTwYgcV7dTNFvAXilDf1RPwW4C/qYu5vM9VEpD/6mBDLk9MKjS4WWaB//PVPaGxofZy+8nqfd5+DmvN9lRpWKG2gp32BaAaGifY+t4GRejkjkNJCZ5cJy95WNqcBl+t4nWCVeN+v8ySbGkfx5CY8E5uhL69uSlugAdmTeBkkYYVaCXKYsO+bXhFAo+p9EMB80B9kIaVmQA2KQCdqDMxzwN1nrBSHdwNFeTgJwz+aDg1Yd2PtewpH95VqUK7mKcqgl17vS78cYVv/WGXDPy1RP4Kq/X9fvrUQolPrwai1s9+JTOvdbdwNH59wK/vNzfNp2Dz9dgHNpAClycnfAckNmBQkLHB7xtin6hP2msbDn8Z8G0gMOB1w4gbtj8E5iPgecLPLum3dBMVohgosPJtW2DbHHu4KOwMXgYcm6Z/xxhSpBpL1nZ4z9igUtXQ0D8GRrYii0UJa99lvffraeMzI99qStkBHL7up/V5JQTxlJgEsIKBAp4o7bqPdoF6oJaRaHhvC8/49X3a2wnSvZ4rWXQitvwNFh5Lytu7/PhcoBZ9tXj6u9d86euqIe3Cv32el5Fq+8WWAfogz7wMztfl++++/oE5GmvLrIsRXPv6fQY1sfZ/P/Glv2yR60RJYXuuvzxb5Ks2AlzGodaP7MvdfD6XcKPa1O3OKNpCpbVelDzmXFKmJcBDi5pW2Izc79P86diibygQaeWaVBCAYHTsZdoM3fy9Y78NbEPGuwwmQh/3ArPGrFLYolmspj4504KAL0BpNhgsh7L1JrBKj0oSCjPT60kVFn0sYOL409JaB4FGNaumsLCSQwBvyWDLRWXqAWhN3SmQImLJz0ZXjsLQSjCc7tw0B0ZkqeNz/w/AT6lTTT3mXM3D2c5Pz6KzV5BaUWmDUzmL/RmnFSpSNGVqLyWKYDY5m4GTsDll2wWwUegRVOjoxC0UCNGYTADDNrjTMZqCFhNIMNGZOLBrMEAiF4fXtcAGWPEwISNRLVCuwJD5FDdOyi0vNnQtA1eLQxpQXNTuySazWQmqeSi7mJ4L4swKRHLtnF3ZU+9PYKKm1pQC6uZmMWAuOV0GQBN+VdCWZB5lX7skfUV+WmOq0rHGMCXzGVx3lfDQPkjAIy4Kkp+wWcrMus7hRNVAd9rwe7SemtMs+mODU1eFMWtTlU3PRc2GWQWck0MWAUTGWstuBczCDAMsJJige6v6vikFxuuX4bDElryXU8IGrDJx7cZ6hr+//taLFEFfQyRbCZHA11heaIBc1zqoLhDrOB0wdMBR6o9gRpDZcyptF7pfsIGdoNbF5S9IUru/7qti0QIbWaTq9OdM59V4Qsi4OtnlUHbzCpwXCFrYhY3srnNDJ0iqe754HqR8GnNEgCqYBgN7PEYa9mQmM5VVzRNLuhZ1bWFpGSwaJBNglJCnLHcgM5E2aT82p0hGbRjjhrhNxDgRjwnLicyJ0w5UfGKYA7edQYVrFsL3E3NOzBJ2KGbO00PPsYCaqHOiMtf+V7viAqHW903PhPuSldeu05fovguWCKR2siqq2RHXvZVn4nr69fH1lr+Nnfg36Tyuc2NSLWCrF4wWurQ+ddNb/MAKMQyxK9CwwDwCj6ANzalhvd4YhnOMhu+IsWOMAzkfwHTK7t8D28vAeOwY84bx7QX1nzbUnwbwOGAj4XHKj56w4jyLbbAP1cCAZduoMhWuIX1bIIpD+lyBxjYumVv3IRlcDkr2cMQwYFMUG1eV7Tkk4za36/4q8XXtVz1KUYTdrr3fAcfqdTEsm9JDVClZr+clzGPLdkh63bGStx3nUFTySn70UMMOApbK5NclsSo2iYa7dfVeNasltL46thEA/xuomnPNnpB/71ueKze1Bb4ma8C+nmzlUJhEj76WHv7e67cHGuv6a0U6BntqPCEAQ33dTM/0WWaLFGZc+1Y3kw74ea7AAtjEzisa4/PXJmuAtQyzGJBu8LHhdn/B2G4IqQ3wyzpTqSbfVT9ng6gbKwOMigPk05f6MprHF+jmazYPB3mhRgoQT8ElX7vhdrshtjtGDHgoaAmXglLz7eXYnIEPF9UFRqghzqoMh74xsFhAEpy+bX5q89HKTVC9aVQuAFvgEEAXyO0MQDsMllMbVANtlehMW4KAajw9PM+c935zDXtSGizRWV3KyHkWztMxYLBBWlcmKUeMHUs86I6iXcosLjoT0HMoaP8TRKA07FFsYP//s/d3TZIcObIoqADMIzKziuyZe0Wu3Pv/f93unpVz5qObrAw3YB9UAfdkf1Jk3w5jhk1WVkaEu7kZoAAUinQBAIGKgOFEoCdsYwbscefkVGBI+Sk5BhZ5OMEbadjVFaiaTc4MR0orvgO6UsZPe15AwGoTTJRd2T1RsvifBcML1bMlig4mrYNaTZsOOcvs0jA/y2UYcwAQQUoGFKAG1aq8n6cCSqM5kRsWrY3nMhapRC81oPdMD5imemeDM1d1RMYIXUHD0Kl6mKBhgZLFymLq4CcRPJrLjmKQ7EZlLOp/q5dD/G+q1rGPYhtnUAQcbi9ZTa11Z2oUfqeqba40VLJBB268v4Sxv6RCDdsMPssXzDYg22BVOBV4Wiag6cWcocMJsya53t2a/aVaVTnK9Dl50W3SjUmbySz/8fpbrxPAYYUocJhkaUA0wDKipMq/ZKn6DAtsTpWhTFS/tl0AEuqZKj03Bf+3JvCOp1tMwUAQ0g4wdZY6Nz4+Z6HRA8FRFnDUzUGy4tuJLRXbsNWnMR1FnfEMXrAr0dAKb/W65eKrkzkTlzCoNmMiQ4MsH2WwXchNW5oWoj1hJD3hjrKTYhumjDEolV7JhvIyR+XJoZxJWex0gy9arWMVIh5YH29YcaJ+vJB14vNxoJ5PLCTWTsR6Rz0+cJrjVf8D+T9/xakhVRZMNLkD9avBbA3KUlIaTV/hrTewAMztUgTLEkhtJgFBrdkGzpd8ZwvAXJWM+wTyq/LRwMUH2KLZBTdA2f/VVSag7W7Nz60ceDzg9oAHGCzsZORXWxUM2pQoEkdXOWzJRu/E51nAWSg1xRckimPOgXdvheNjI/674BnAor1aL+BhhuMwHJbw/IH8f7+Qn4w8bX3KfzncH3DJ1j4icLgDawGH4bEMhy2EHaxSWMBtwXqqtwKNx1p4Ll4bwhFvlMJ1TgBEszzaftqsbSdM++jktb7Jga225Y2DFYt71dF2KVC7sGQJ35mt61lbYiSDHYiQ1+SjHlq9q6cDnRgw/l5UIbGvqkVxL1rjPFeQqT8P1O+g30xKWfLvr77ji/pdII7pazbo2gKipfNrXYFrq1E1VoAIDt0bYrq0cjJNfKuK5Nc+/Uevf13etmb1B+2X1WTAp7io35mo0WoOXgcgM+9BPx8g1usOoClIuL1n+KFzX1oUbZayvk6+aR0H3t4ONhkZAwGCOgYGCTqn5vIamNm+OHLKeHclwUxgA+xjyC4pyyglDbsZs60WC34ceDzeRo5t+QGoabw3gCZLafCLMYBZQJ0YviyUhU7V5snr76CtUDiZ1QOA0qSEMq1HwWuR7uXMjqwq/p4qEh01F04B5oNGGzwYnfZKtRMEO9WxE6pwGByaIaFG8VZ+Kd1bKfPvMBzB8m43XW9Jpo5RBisPqSCos5FedYFBdLs675GTrbkvGOC7nhEDuJCuvWw9f6dcwW2iVWly5issfnbgGnQHBkEo9qGkUhuH2fRiEIMshPfwQe5qOoxEZT9DoocYAqb9htqlZyMjlGVXxYeq+eg4KY1UorgSW1S6MZNSTMulUjWi5aiZ7csZnGhSQcIMsIRAg/obFAxBczTKNpAMUpLSYriFDaxMVCuQQU8/Z55BTxW2Su3b/rmh8pB9EZXJOMnYwYAa4HnwMpzYCJ+8MgNp0DnwmTIJsLSfElKMDdfcC+6jLDkwA+Cn9rsyXMr28Jy2PeJ/s8vIYJ4KTAXwxlxxKCLXrFTcY/N4eVcs2KHENyg4TzGsLlzyx+s3L1YoE1ubv7nHnQjRzgZP7y1gY6QJoJ8+XwZmeL/0Q/STnCnyHSxc7siiECbuYRrq3MxSgFXH/iw03vQaem1jzFb/ARL50jycRlPyF2bAClUOtVeqh4hsBs3eZQozSu4UbfyV/YT8calBWojIAtNNezoiUucueAxPkBp5JlbYJH8QG7E25w+dJ55V8Ej4ayNOZVF3SbkOSKdaVBUQkcDjgO8PrMcLOD4R9YJnwnZi4xOIT+D9OyL+T6zXA8+3F/z7/xfYhnMD+yxSSTbptZxwHZwmvmURjGdYTEVRTG0qXhSPUIYYrmDlCeABrF+wvLDOxE7DDyv80LycXuaWvrV+zlbwFUAt0jwlYoLLJVxQ5iv6gUPUJifd9AjDej7x9u07HlH48evGn/984i+//AD8V4iJNveUcOztWGmIADw2/ORzrkchT+B0wM4F80W/+0vhzBP+4nM90mEb2D+Az9NQT4Nh68AlcjOpErXRiPYYhShXz8UBxII/HIcbDlVYepq3ucMemv4dVOQ81oIfDTMDkYsVjQ7chLeInepazCiID4z2Qn2mtmhW1YksJRKcJX/6wVVTJfmCYZWg6u8pLz5sBfe7KZiDUTr4uYLPWzpCeEtZA+E9SHYekaIAomMHUqy3qvKNOVVZBRoCX/ia2Ka+kn3EeLo8JDgbQ+vTtK9Scq/tzKzBLtgJ1AJGTRNGavS/MOPpX69o9Fd2iNQXbP0/uC2l3jE46KqCAPfDdX0yFxQYLiVq/q7ZPPO+amD8V1eHll0Ndzzfnni8P7AeOmwIZnmcg2Q6ECoBIPJalf2KAhAq12L0hodatJsPSFpOSVaoJ0qHB4448DieWG8H7Mlyoi+fygjQ7BkCbO8+ADPJ5vf2NA3gK6Sx6ZkPO673YFPBCYDtYFXNMHr9luTm35/TlsISmhpAti2/r5+HScM9jbNhHFIa4WcDygD1wTeMvGGEis96dkoqYSNgzqx8O3MJ6U5zGp8Jhw7CIe4ihy6lbUSG/hsjD5ySAk1VC3p4TxngLuDQg/UuNjC6NF1FgLE1zTQSms7NfRlyHj3vzcBgw+fmck5y1zFKQNmMTcvC+vy+Lc6mFq6b0NtCeBvw4lpXhpr8gRmBLWvgAKewdz8MBCpQgG1USR0GwKdvSRW4VL8wvQqMfTrjSePNShf3KGeMnACWjNJilSDIl65gxo/30IOPbOwBBI7aqM2ONKov9eDJ2sxQmpxm5WZJuhgouDkDOwfOMvWFqFmi6FSsKU0wvEQHyRu3nFxwOqddHIhI/1HYSHiq8yaB7Tx3lIsMWCZSAT1UzXIhwZSRT4NoF0YHBv25s8zjiaidzqou12oln++eujz+eP2dF3sKAmeq0oDqHINOedMKgfHeBcq9tl8xgDRFjLytd+XJr/AVL1xiMjwS/NQCkJK7dJ7FlqJkmZXX0NWJvhQraCBeEeiiL8+Ri7t3/KkiVSvH6EeYAA+aRmMDdAYwyai6guP5+jYfwTe0wl1JBtyrBtR0JaVUZcNKoF6SyIVks429X2bIvWFq7D4dyG3YsTXAj76FlWqZ40p4fFL0Yx04LBCfn9j7E7/+AOwXAPiBePtPDnmzXyXbavh1C0CeDEw8Egscplse8MXeKZP8bQMpLqpd2e3iwFMqKkqjVNLilieeATwN+Cxgb+AT1XEGk0HaE1DSzs3hfgB2oFZTSjfspB/bO2HJSmYNeLreS7UmwwrHMwJvP33g+//9Ez7+8sJf7BOVwCtP1KsrJtBe4LbbQe3IWAfi40DsAs4khe11Ik/5ulVMuMQDpy3gSHhtrPWAHU/sRXlcmMHWQtkB2GblOpJUKPm4x9P57FzN5a6G8G4O98Ayx3JHrAVbi/0by7E8SK0yR3Tydkm5ylphSgcyfIZlsiezfUyDzK4EiKIkfwOIZgz50SxV2HReRiaYzIQ6oPlSfcj1rFRBIROXc1zMJSBXV/WQMvFkVAymutE3x3jsHOBTLR4DyMeHYmH+vstIGIghKmRXtAcot09619n+HfTrtsEktgOdHh40bwpe9NWXDZGNCZBydXLNS776X6m1/45A43p1WNHXMFHS/QDrIs3mcYOKLh1wNNdwioyYUiT6XksH73IGY4j1JtND71IWAIL99cDH+weO4wFrjl9L2CrT7i4qhfirBpV5/aI/XVGQ/mji36kx1NpBJctIHgZfwfLf8cDxeOLt8WBzlFONuVnkvA8CHvPCN9bFywABAABJREFUi+1WwAaWceoz6S8qnRmDGgCc5GpARXu8YOZaZb3RWJ6HkjSoyqDCGhfzkNbJgGJDEnHSW3cYXsUZIK4AZPWzh1168/JgzEIoOCmbHomqDtTI5XcrINUP4a7n6QiBuwI0vwDk7LrLcS/SduY0FJCcJ9IAlDMaQnzbNkZcBq+WE4VoRApsHchyLPOhsZlteDbFovme0NBBwM7EUpb/dACC76kejkYU5gqoxEvrfR6dTekzESVCj00GlGBd/TICIgGphZWeqxWOcvWMcOpdFZs5YwJ2OkJicwVgmvFAvMIVIo1OA/mshljGoHXzrKHVmZj5smITYGFJuYscYEtKT2YZMuhcvRxLgIculvfpCvhNe4XBLmsFBe4XK1WUi1roYmMrOHdpJ5ysjrTRkK1w66ZqB7BVpcgBfSbD2f0aLd/bMwxdhH4OlzxFnXFkaC+KWD/7HGpIh2x0UZkn4Njm2EXaI+WmE3XyPB1l2n+G6l4vu5zMH6+/flFMoymuFMUoOUZKtxI4M2lPG29pI18NtH9hIqEn4MLsyur18ncVGcClHCXA0Q3mjSM6zQyMc2wb0o6b8bi8oIAMethg9wrIudJuMPiQARYIYHCfmtHjc4X6HYdKsn2huF1TXjfYSNkEtVqxz0XRkhOupJ2Kg5SqXQVTFqo2aZ5e9Pe2oCo0JJogapqq1QmCM6uE2yeWHeAkBBDEnp94AkQq5yfq1//E6Yban8gV8IPTqlcVKI1tyJOMAwspKCUr8BRLYZXwsmm83g0CMw6a9nnOtFIvYNNvvhaDjO7x6kDvsrL8YNKCAuEPmD0FgJXCWAqIcBKLyA8x2HBVoIlX7HDYsYA4kG/vOF/f8IpfcTpQtZUI7coz97O7qvfBhKrnAa837uvF4Kbxy5JvXxaIeCKeT0S9YPkDfhyI46k5FmyNOGxhPZ6IOIFzy86z9zDgMwuDQZYxEdeBxjoYOLmp4rHYm9Gyts6gwhWgmMdtmLGwT3bJXoGd8nTTB2OlQXwK2jsBDNESrROM1YVD2KrrHHeEgBr8+ttcT0sfd8RK1U6dfQ7qaSVYDDWroMTXLYjQ+ayODsKus32lF7ivbtdwDwyYKNdPv4BwgbzM6+xP5KCPt06uX2uHZo/k18CtmsY35+eyZ7/tK/lbr98xR6MjHRmQBke6xwaYl0Xun3ekz4djVV8+917t8Lpn0i/n2g9pPhS3Va+vn9b3fKwn3p/vWPEG80MBCwHgfJLR8BGIbFF+pH0PgcvOSMO1YTtL2gDVOBMAzJq7UZLteTzw9vbEcSw8oiXiMIEAaXk8iF31aQ7nVmNPb5oGKlCGqZ/CTgBuCJA765UoO7Bzw5xqVqVmXXO2hbd/Ghm1LfCljiiTfrsZUKEsc276vOyp49RBp8xvN+jR2ZgxkyI+FGoDOxIHADuZGbdgBUL90RBhbA7vHrodM2Kw3eUuFDYNiQJETz7PF9S4aynOOz+LvEYFbEr1sf+S+y7kYAwsV9aWGpf2JQcRkk63k8GpWEfskxHlCm6IupqOCzR25T3qhz0n1zDDxhtXGM5gSXMaDIAtVihKE+ghtgfA51u8vzZspsCgjYULLPRTb6k/yR1ge0v+se9lzXyBwJbtK0U0UxaW7Uqtf+3uB5IULBKR095Ow8/DBAdV1SxD15c6s4w6zJxOsIcdVhsRrstUT41BQRs9qOfDLVjNAz2QuhtEU2mj2HMJOlB2ZrG0ZuRab1INvfnYAo9FEGpJjqzheubWvAXzKdmz36rgCQqyuHOEiypo0POfdUVXQtpCqSqGpu788fpbL/rle1ZYPqODyPnvQedjc74mvmRclcEHLnChcttVblUs0Pzl2af6Gmb82n/0RfZnykZUXVv8eqP8oeyzEBDpqTUuj79+7YseREjbZEoIXEHFjSRw3ZiAKZSssrm2Vu6TjxKK69pK73czxwaHU546PBV1s1EMi3axonG6YZtmc3TF0rj3W4RBZR8o/49Vhvfl2LFwnkDWxj4Tn1XMvruxcn4UzF0N5/KdTgqZeyFCVQp0JpZ/Wm4UbCmob0TgXI3xLcaSPzZObJxgUNLVZ/rYuhbZaHe7IhFSTQrhn7PV+xo8BqaafAW3AsaubLzW4jwLP/6bErI/PjdOVeSaEpcgfde9sMLxCN6Ps52UQFhpYXPnmlRhAVSI+rawfn5g/aWQ5waOhcdz4XEEjgXEMqwMxDM4mFf2ytKxnMku1wRvh+5/uWR2F9axNNn7CjRWkNpuXQGJW6CxDlWmhQXLhrYzrCO77GNXqgLqjSsQozTGnvNu8/NCYV1HgC1dNcdmPrNtOtBWmYeok0n349V4nzTZCw87mCDu3o9OsvN59Je2DbnZqPYCeSVFmdS68O70HM3v36zN3c70Bd5+p4MN0qLtZo/0vUoCUjJXV+QYLPzPw4zfVdG4RULey8qvmCBqLP11z2a3RbDrpq9PsOvTv8YuqNt39L970BD/G1qUy0RyEQLv75S1PZa4/HbVS9y60egKGCp5ONQ1RiMr3mt5AM7G6UDBYo1RKKMqDGXYyEt8OClTcTzweHtQWjeansRybhWwBYwJwRbCCbIL1Lk2gcNQZgtG+ssWoKN1NGz4KIgUpLrrl5QrD0qvjXFTp+RS/aXqQqBnIrgcnIJ/mIUqK9JMV9CV1o6R6+RhOIWwRpGqClYMMMpJz6rgJ6GssRkyez4F1QxQxkFsEFXAKRza06lTdLVT4N0dpNVA09nq1tNjhqjEgnGy+Ra/sFGzSYUsyZGn2OzGzp4EXyhjFryHswF0UFkJWPBZKbWlr7yCAfQeFUDmopLu7QozrSs/+mywlO+qJGWKC9xUjU2j0P2XZxZ8k8p1Aji8EJrGvdsaKZMHVTJSBrnYCKLgR0FRQUXVdkw1z1AXDpyEA32+0BK5dTnIEhE0lOmH6FLpi0U2gZ3T1EdiBt+ahyKbkbUvWpFzrkxtlqNJmef6W54oSwbl6rexSg2L7KwTppSd8J7dOKCIzeuq+CCn8pIe8OSEY1OfTLoUtJJ7gVPamXgok5bnSfpDBmUyt3VgK5URPSOTrHNhsw+sDMs4fM1uPUJ/vP76xYRF8/64Z03UBtu0C5TCZgqzzxidjByrdfjNqKSclKBSIMgvatc/qRHZHBqaC1Tc0g0KjNF2QACzfV2Kgmq6kQ6D+JH9J/7D5s68Ko19/W0T4ha8CCTDr4CK55HXNf+I2jd9Gt1Aa5jgzSCFKAGkrrJ7Ba89kwvtQK3uUTNksnoU8hxujlOKevvFrL7JJxhq1O4KLwKxZAUwng+c9oBvztT4/Nx4eQB5wDOxHLAj4EG+fOITdUp21072E5b67YxN6lm084vjqpBpOLsKAMqpIgKwhe0B4Bfsz1+x8+SZbwl4M1bJunotio+bkQK0KMcaYCBVe2NvUp2ZiLIJXjtItN6eDfjOInX0L7/gFQ7UJ14/XsjzNQnE6CnPyYrGCsPRMzCOAuIFe0EF8FJFxpEOLHPO9vq2cPzkWOci5ScCxwE8HobHCsRjwV8BfxT8swNRJoiPMBzlrMCI+kR6FK/Bj4MULjMsB9ZyrLXwwMGG8XDUkh0N9sfYYqPGrIPoyROI44aZ7baX4RPY0b13IMLIbioACi4aK4ySZfW5Mp07YPoGYVeSHaa9nw0Hx3bwu69kQSNU7hlVVRoT30KOQcB1XaMsBVpNb0L+upDdVMQaC/MX0AHYFZHYZR/aFkE2jACr+V9TFKiOPNq89cxHQAmQf/7615vB++P0dFUpwjWlsq5FaxuG2w3OD/pD5qcwKLN3+x4T6Lz5AgCQMo4pAMAs3PgYAMex8P7tDetxMEIWZ9BVBvNetJIBQMEsNChLtDiVFOEC3lUIS/RgIzYWAeGJZc6sRTiOR+B4PuDvb/DnAxYHyh2rNO1ZKPQMgqzofQXRemCqKKh6oQdJ7NSBEkFpuAINB3xzDoVbSX0CI8FH1Sg5Gtck6ubyu3C5dO5csy56k1YRxpkIiJ6FVz+nwmQNPSDnzsPQ0o4uBaqtn6ccoEN9HsqKpfUkdAVR2dUBmz4MZDdpX4fT9aywe69cQKCCQDOS70nQQcChidfATDtHwkJgOnoTgJQnLwJBuBTl1NSImpkRaZCQADNjUQr+kkCbFA4O+SFY7uzkkIP07MmY6PWxMFG1UntXtGDynViBKid1YDHH0DOyWwazikHuBPVxilvZEsY1z7IgSpNRXaZVdbgPHDAqFGxxJtnIXhc9KQGu5ubeUyokM6eBO1RlgLNBtDSTZOs8sxEysQ04y3GY4yztmTakBlZoLBBaQ0oS92ECq3k9JXmMdNsbAtPdxiVlRxzgfBBeaTeym3VVD6JTMYikSo92XG1RBTnd3vSsog29dR+Q4WSkI3NY6MGJYYZDFC6DIRu4/Uvm/H/TlwGILVvAcwbFwk0nMYHonJRJ3YrvCjKmigbATFKOuLkuAUhlRHnuU+AH1/NEZxuAUqNkO+Q+S+h/qx9q6K5om9pWTtcvexFqaqANv/KshmKDePU9gxVHiey52f0TdYklW286L5044P1v+SoIvFHVqSRryX1uRppStO0OqoDtAhtYjUCYVWxnj4tRpvzcBdvsiXQQFbI/7EU84AU8HUDgiUDgxPn4xJ8P4C+/LDbOIrFr47RA2IGdjjwcGaRXnWjpaanl5GZT+klqTx0GRMFewNqkWbk7HItMiOMN7m9IAAdO4CycVfjhhc+unGOjit9kRvpteOB4Eg+YhtdWFtZnAq+NHZuN6r2BTUm3MvH5r+qYqRJ87E8cz0L82Eg7EZGs7ofBFsUj3ERzXs7J6VhYBuD1Al4D2phwWYb0hRXOCdyvhfiPwNoADgN8KenmqDqAz4OJmR819JkAK0ChCo7f/pkp305RnOUHFgy+gHg4/HHA6uD5CyNu8e5tWTALtBop8YkqzKQZcNeHjYoSQBu/gbH1HbpakRWS6XPuTRQzO3V0G89IUOJ+nDvOaX/aTRf8rKbL4kvlfEReGswXz0YbJ/oMG/YFKws1icz5cl1Yhpg1ebGAqJxVGNbBhdS/VGGqP1NBVP9NBxgmSn1tMR6Eb+h7ZFdltO4hEfM5A+z/7uv39WiIGnV97P0LJBTaNrbv6WYKr0fF5dASdmzVlz7G2DqiASaKaHDWzp1R2fVJbo7n2zve39/hx8EI2VnOJAxRic0h3rWuwEysDB4cCEyGeHUlmbusgCPI+TSVWSVZG2vhOB54PB/896IONECZ1t0l0QY95UMTItHjij7NSU9b7bRgsCgBRhJ+rArmxjnEruFtytgPZUUPxNQP0ACoy/wlnX5YDx5UaU+Nw91vXDBs9aEAhr3ZbAdxXxdsZgt48rCnAZ6SWXWC7GUFnMZhdgZJ9KaoNEBJCSuk+7tBQLkScCyUnTpYwhcIpKUoSAoiIZCgnHyvE/FHwopZNlrLPSVO/TZq835DRuelvRqZrC65wbElZatAxxpwOlZxH52q2TII1vPRdiZGNVSxyY7JGoIg67GeVkN9G+OTXREp7hF2HMOLoDmrp17TAIlBcAUM2ncumkKL1bJSITBv3FPMmmp/JuC2sTMEsjaawkQ+J/lbaTGlaiCZObNkI58BPZARosDBWHGJshasQtf4YOReswVDdAMZ2Q7cUOSJVzfOGxuomQ3lHmBw6oAysJmqeqDkeBIo7l8+Q8rmFnIydg5waCFCQYohirQoAoyujCk8rkDYHvWpFJBNFDnnE6xyr8wgKds328d9xUfzz435/84vLzVB9zJJ+rkjZwKSQFmgtvq0VOFzEw8DABEYJmtHmusldOEAloLCngczT6bpWxi3Mh85ibAGTtlO+gosFJJc14CCBPa0xzBnpnOgHYh4NZWLsCe3UW0pCwc6yJWPk7e1Lo8CqAFg4rgb7W4JhLhugGImxSADxkKGgn9HYPkLXsBniqRjrO7ZZn+EPw6kn3iFATtxblaSgcJqdTvNQSLJilXSDwd+csfpB1Ya0h31iwOx8coTsQ3nNsRmzx/qSRU+FF5Q/2Ql9naULWyJXJQpkHNgHSwwm4eSZQWLF+p7ov4jsWohovApP3feYv9OBrgZVgTWsfB8PvBY78jjHbs2Mh+I+IQFJ0Glv2D7JGUMV8ULAKuiyvTDHOELx7//Cevf/h3rL39G/vefEb/8gH+e8DyBIthn9bM4xHVzCvdaByweoOGhzcT5Qr5elJtfzoF8thB5YC0GWv48gGAgkEoojTCAGwwLCyANy4K9sMuxfDFQUL/FAhOxjxVYrr60CBjYCF5QL4f5FWgwyzpHaHIyMJWYieF6onYmhPDYAF1psFNvWpBdpy8qsIJH5oRjTt+Zl9ADSRoSmiANMquDbmFgu6qZE9aIzu4Wl3xu30PTrEwDlfO6ppz3X8myAi7ZZVqqa0USY3u6ykKfKLvR+4mQQdLuN5tkonYq6CxvW2ayATyHCQri3Ob48kplENMMjn/++p3N4Kb/H6vJn8o2DlXlupeJ5ub9818C+IVbydnmX52zhjV/TH5XnsTs9o7qLDkQa+Hj7QOP5xvLls6mbkb54AaYzwd6Vi86MlOJ3WyR+mPXUBznZBsFVI6HyoMIRunH44HH8YbneoPHgfAHVhBcmXT/4SzhLutWONPh7WxWfQHsVKXi/fq22xL5ZOxcz6PgwHmV5pmt9qGvwAqeBz9gOIFU0KHCkesgYrLLBh261Ja2kNytsfQLBmyUnNWkUacUoqOA4CYjaN2trAhPx6fKc13863K9gwYE7Vg3MzRhhROksJUi85lYTcQAZvkoNurgADqsrTNsogsRJJbbVSGwW+ibMnQqsawypJ1w01BB7VlSukQ3k4wu82+JFyhNSIoZDUkYgAyUnzM/g/0tYObcOiCQ4ahi8OECB+WaJi6qGJolSavLwKurI6KUmQFnayIRdYX19JSkMZHFCuf6oDidu7NqhaL8bYGKYwCWGV5Q5tIAqzXOgI5ChjXo9EgDbADdwM6h5oypVDFuKZyqrllQMcurAzoFhZv3tmVUA6x4lReWsrEUQtgTQDZtppACF0V+tnXvBPtxUKksGSsoZlfFlj0aosyEnomqJuGGrpGmA1GOqES6AJuqIKfLS459TFZCjOu507HkxHr4qVmrif3x+quX7GXKFrrOUNPesUyAgbxsZsuBgeVd+Uv5l6jmnwqU+422oaqIC2Q05epyUBgdFmeG3vKiKEzUwSmMaE+YnTE0KDMgly8AZaKLvqrnJ2Eyof1PAws3II/bUDnUJJq++uCmezl6EBw6KEFNYIVoiiIY+B5AnQYsDpf1onGg4AOQu/AQxTd3ztwBPyW7/gCwT9ipZahA7WSCxcmwzwJ8fyLzEyV64Z+dktXnJphdHwvH84UfPxy//lBwFPy8rEBFwlYBvzr8ZJW0YslngOuhWScZlK1dC1hSCEQV8OsLOz+BH8C2QD5KQBYXUAQmIWGqLvjjAPwAjnc8Ht+xPJH7E58/fuCHFepz41i/Iv1XJM6JPEee3wPrcMq+Hgtvbw98/N//J1D/D+ztfyI9cOz/wj4/SZ8qByW7uKYLjsMWjkfg+fEBPD+4pwvAmcD+FfnjV1ZYV8308PVcOF7Bnz2eyHqwKF8b60hE9P5lz4upiuPukvR3wB9wX1grsBaTf3EsqlMZm9cDjtiLgxtX8M8TKjhQG4YTKt2jlcsr7UbVB3wTD7bS0oifGORw+Wr73ZWykkqVN/cYJ5vCh1XCYJcuxFDrBqoKMFGZFH6RQj0geKE1pDvxMRPK6/qM8sZU+gdMYhauJMScWANEhZAtqqG2A0A3b/fdjm0Lg6UP9ZaBTikekgMqfaYwVykJ18qu0e/UZ5hBA2VpOwr//PWvN4PfFq2d5HTk2+Uzv+RlFDxPtWKCk4vD2p/RCburqKTv5cpMSekqX13X5reg5FhPfLw/8VghaggPQI2dVfYRfPguZY3qaocW2tT4PVknWfFmWlg/fePhOfzA23Hg7fnE8fZUQ5PuU2VxuiCqgyBCIU7KyJiOFIAMVTQ0AC6BbSdgzBKY9McZG+hwGVACbVTFOkT7MBpdZfw4TXnrTFwRfANVgECnKwCm2lmahtgZYGl4GIFWloxuMQvjxeyytaIXCj3VdjVoM5qQMIcJ9JG7f6M/NdgvZoV385ULKuM50k7S14xAIHtSZfZzLpifegZ8ZpHaj1baEFeA9BL1h5xLlbVlQMKcmRF9/tJbu4rnzom3JiDQ2cdsIGl0oDz4UIb8/FL6rJRqWDcYoytt4pxPxclY4jStf2cVTGeyBLJd9KJQ/0tybgwrSVxjwOkEqxRJ8Dk8dF4KVymaTZQUTfBUb4aLhgagefDWzxxAVYcCNODEUDrzbSvqNwEcuMdKRsUEulK9GJkdJBY8NTVePVbSE6HRNg7v86019T63bYtUGSpIGpjrWiWKSjshVRmqLqNKqpx2iWiDfV4aWKazOsbeKuear2SGqEKpJtCGIBFbWVEvnKVMYFPgRlblj9dvX5bc1IUr09b7DIACDxA4a/83aaVOYFSeqgN9MHZvypW8W6GArecK2SnZFQMu6eS+LsYhk9knh7yGzw9c19WKlrQlGP9v1n6XleEtVsEVsIPbWOfNHaN83VpwDtrMOgWE+hyUUS3qjlF45ePnOjF0337eSYgG1cl12TuBIm/XTn5nQj1S3j19haqT/tU25dcT2J7wTVpMSSBlfy74D8M+Emfyn0SSAhWGt3R8w8KfDz33l6G2qW+KvSw4DIUNeyUqKSrSstpWjQUS5944ETge7NEg/ZFVTDs30jcrRC/DmcQTTRc242dXkKIVcD3LQlnieCbeK4E88WdjU3nFBo5EJr9nAq1OMjUNewUeHngvw/svn6hv/438yy/YP04cBezDYcUeUMBQao4/ulc0Hng8AvhJG+IE9/rnQq0H0os9E+9PxM9vWD+9Yf2vxMoTEY6dVJAsgxrLhfk8YMI+rv5UX05/pmF8hzuOaUgP2FpghdlH4tYW+1/DaO9aLbPnhQ3+zQspk1baPTIY3EQPy4PTMXVT/NsWVCr49saiQDNnWrioX12dLMn6F4CmsptRFZhJUQyVsilN88/uQ30xSfSlfA64KhvQZ2XdztsGugLZFdgG2xWQ4livjYIZ0b1LyYtJ5tqdPnnjF1l9dS/7une3Yu+XYeSErQAkq/QUm/srA/JXr99V0WjwwyvQofIrsw4B4Jyb7vfJ2KLDjOtmITB/PfSrytH5VAKX69mZMkdzex3wuOPt/Q3v7294rAOHa1pAXc7ARB1yLNFrNBShHFUnQZQZYJtZJilJdUnPsrC8JJXL0uZxLDwe7zjePnC8PbFWlz1ZWgo1B1VRLtOlsU4uP1DpmkwA0XsMUZRr7FkVbuxzcCOgY7Ms12vDmQ+w5KGoPVWbU+sDNDg7xfmVIhUIWFkhLJbuXCGR1RQ+whjQpUp2rets5TJyar4um2yw2ipQFaTAKGqnYQYMBw+E6Eal5wxl7TMLZQHYhhWuVnQTaFMGxEHj4xostdpRdaFRCXSrHn611ZfCgNIFPMyY1WffBWlt2WsvsGgqTRTYr8LBWHreGgx1B9ZWGiS3+R1hHOBkzvXZKNGLHNGZSt4QyhejyZ1ap6vq1Wek9NwoS6z3VhBYtCkxNWYCOM2nQnihGBndIntdmAicuG0sb01Zkd+/CyBZgpWwmiwA0ZWDPR46oKRqFZ/L6aQukfvbBMgaHjUAVE9E7a+lBBZLujr5Gwbzg4FtFM4tB5SpcyEHoIqeK0hB2QTYJtnhUZ9zgk0g4SXFMNuaNh8XQC2Dh6hTdTmb7GqH8b8BB05g50YEmN1NZkVhVPoqkEJnYKXoTObNi/gNC5h1+eP1t17kOvUKFTh9vax9oAIFZRQ9OVyy6AiGUmDgG5itpt3tigBg11GpG7qxy0sBQLOwzHCbdWHj164Bt0AroCXurz401iWa+f26TTpuudQreddAijYaHSh0UCPJ6stn6n+UDbTLKAir8He7ok7AVuOEO9FmFprDwfPLnqhUdc+QTklrz6UkGxuxSblQm7jz90uHsuXX7bFQcIQnaS1qxIYx2LNw5GJgdUjTNU/DeSYqT1VQA4YT2zZqn6TFFn2OmatR+oT/cgJbWfjQ1GoH4Cd+/HLi1798orAJgHlQSVNWFaJCOQkjBA4A7om1i0kZUxdZvYBzw20jrNhDmhcQ5rRlrutC6P8Eun/5gbL/hfrlV9h+UV1qOcIP+AKz/aDS0+MIPB4HFh6IRYYBzppsOGDA40AZB3evtyfieEPkB5a/2HexQFuqxx4dNMBgvuCuRu9er8P6FxlIGKVuqSbVv9dzxhigmKZ9d5q1q3TW0qvNk+oz7KCv2a61b694P0E6YwLQ/H1r8MhzrqTngPMCYH5RieZEz9HiGXGun8G03nckKx5OA3yJG/C59jHldxko12sCttbGQ7Ogrpy8yTXrs3IuRkGZguX2a4OVmyGC+4HlXQkb3vtYvpif+d6SLetD3+vXYi2ii/8Lvul3NIN3ZlpG1JwzI4h8MWoXMuR98a6IqWk4veh1X0iil5sRbuOHxj8yrlfEWb1sMnhewFoL394/sJ5vKH+MsXBrUFzkTWOhHJrXkNek5NZr9gY+DCSaPuEwxSQLtqgwtWLh8XjD4/3BJvB1AAhOTe2yUpkCm66YFMo2CoHtrNR7ypF5U6G4Kdgs3Q06l5V3GXBI9hANzEDjiq1gRFUGoKlDXEdkV2z6EJOFl33vnS0DAfB2BhWRzD4XVCVEKelLcBT6rAIP2mOy+qLHNBUNBq8XM+5OSgOcqlDHVt+A1oEzEPLK3ItOcivqgdUcSSfKkLgW1IO9Hsxa6LN6I9oGinxKsyuQYlOdzzAer6Ff8jvN2BejYEpudQA4nEEK19cHlDAAS3E+FeTYeR0Il7Mx0Ypg6iciwCZtyqbCE+UciKWAhJXVjUjgvDezljYXRKXr46+9EaI5MTkpZwLytknrsYs/kVzLpmctGewsUazAqk+Ww3CIHsH7j9oD35q4zu3BYJtBMJsfSxPH2xBUbWSR/FYKaprgkpbw6PPRgHLrHPlkfgKJMzHDDFl1S/J1FTw3EGFvBYNvVgcplNxV16XAtXAO5zfhCuhvs0Aq4dJbDE0u3h38l7JrpSqJ/s0suFztVz/6x+s3r7ZF7Qt2H6XCpT5zc7ZdFU3DLbuP+btG/hfF1tCqM1fcYgNAqih56tbsA3Gk9Vn3QOYKIwrwzmbquuZjOxGn4KgrJyjNp9D7bUIWNH24zXn/jgk0XRn4XjPDhQ+62i5qWZGSuLryClz0skEi13U0R9ydUhStumNGimqWI3yjrHDuPfM0dilFVhvpDL637JEXSCl+srq/jsQ6DecL+G8w6ZZueC1HvTi/wSOw3VldPi+73EqJaRKcUALAnIFGhQGnIW1JKenggLwFxOH474PDQfNM5GmUzM1SEFdAkqXQgQbXInA8OSGbORj6wQF6Bg6108ozmSainpHj7xZMTFkgEXiloX5NVdVIOToKWAFRtBVoRGA9qCTlttgPcTLY4L7DKAvB+/0LUQvxEq3JOTvD5PgKTML1hG4PThT3CPhidcMX4BuIpZkYxuF7CCcVLALLbCjFHLQrkQBQBdEazFYfQOEi2PRNdJUCOsfjywHV08ftfbER126//7CBu+iFwBW8WH+OsRIUNb9e6MqDfEBeP69Z2rroSHPKZQvuF9nlQ2BYKBdYvgIngnrag5KxGJZRuz1A1Re7/mLszi0gaOYDLtbOJPz7jCjIaHMHA1rFzsvm+2x4lX//9bsqGldc0EDkq4HcHRWgD9QVcPTi1s1gTwW5/9yfpTd08E0bp8/Vs/YvC1cwdzyeb3h+vJFv6IA5o2pFRqSaOE0P2khIRco1PlUt2Rrk0xSWYjk1HFS6DRzmOGLh+XzD29sb3p5PxOMA1rrWJcCmJB2SaGegWQ/dRMfH5JInlIa5sUGKlGHOzEgHVrazI8+UkrFavTJmvWxPdohBAS0FM+fNKT25lhqEl2U4JOnYDeCQhF/BSAdBS7gyeGEjOwfTlbLzXCseQIJF3uN2R9bmPI2WxbK8ONMGqnJpvXpGhVcouwHVCJYcaamSxnt0BxYWXrgGnnUgwuZ0UXqKGRTuLa38TH1uLShjdQupprfbJnZm/WHBGSKVU01gUEBAe2itPp2N1NoFaFWR7FLsLiAYwLFcb2glt42CBXXOUwpjLnrWMoKOE4AlcBirKluZj9ScBwMmC1dWcvxd7SCfvYoVmzIAmz04KQPEwJvcdN6aOM7R/TkJV/aJ5TmdVRlF0geburixzLA094VBDCnDtG18pl6aJq8Ga1aeZGBxVUdL8Q/PlJTOhhahAFfgMlGaM6MKnoKYkixnFuU6q1I9SezPQtLBUjGNWTKvnOZZUmGUre19q0wbxRPa9alSaT6g7LSCM7pC9/fAQFBWzJhZX+cfwcY/eNHW0a4VG/AB+Mm/6epGO0nrMkZyfwLyK61isFmV7YSntbPvoKSnOAKkEBgDR9otdj+ZcQ/wlOTdsc11tvNuMI/+2M5WTjCM8Z/EYW1N+Gk9LIx0iRITTFn1Ii0y0eBuQpAL4LTtKgxlMU3+YphVd8qX7BlLNMJLPoIPmlYBZQ7oUyvo9ww4N5eQ1E81gO8EFq/VEhOA+WIA9zyA5/HCZzjOH44fqvSfzrG2hxmWBc4HEzNphdwgNcs0jNZ5zbaFQYj8UZtrUws46ObxDMO3ZXgcC/kw/PoJ7E9Dnhtxntib552Uks1/7ALQfiwcHwcexwH3xWnKm3NG7G3BNmlc7Dcs+VRcMtvGCoB5wMOBWNjfP2DnN2D9Cn/9wspDJZYlDhe/R7gl3LGw4Mdi8jOfVHWSzcKRsNpMFIE9HZEb5j/giwksMgNU4efxofiNGWKpotFVDacC2WFgRSj6741vdM0X095OVbAcmjgupMFqBs/OIMKaMgN34gZ6pPy4ertoQbTJci5N9alG4jVnaU6jaNbwmqqP6TDOr219vyqU0EcVSFejKAoxWOrsmXiHXRwoXMnkoT7Kv/HM5/hMLQsAV/DPMziUL2VHTIEumlqmqku1XcwaGzagu/+QiWuBgKZHz8P+EqzwRhpTjE24Lu4fvn5Hj8YtlLMOxAxdqbgFVnKKbZhkNOdi+3f5rlIlo+4fDoyRv7L7EMC8/4f+wgzhC9/fP/D29oYITps0u+YeuKTSGrQ029qqM+08gG4gGLWlagAz0Cl51whHODmQx3pivb9hfbwBzzc2QMkyuxWjfC9kpVyhK0i7R5zQxktlUosNZaD0pznPS5RKjtVVwMmFcLOZaEEZ/Jwb20XpW9JiFCTuArmULl54ApbJieQqZeYZgJ/M3PfuNRqOVJYtjJO03RIrg428IObcSc/M53ht6EBhgQOc1lniTfIaY0OUM1VgPMF5A0wbtKISH/0JwxoGUGcNzBjocHBfArtE/TJNP1emUAOLXJSEncnsikHqYgbH5lqZ9hGY7RZyRln3ZwmIKFA8xbeNgnjaBasQxYbBGR0KA4Et40oHCEnzBsGKDNPhGtykqdIhAxkG9Wxcczs6LGuGn8NwluHSySdiSnFOswwHpOaSF13RkLIjNvKu5JHSaRcCmc7hf2R4qUrVOSpodXyyyK1DzrjmMpCUGWalp9fCBRormUmzrqaBwCGN2WSLlFqYK7OXN/siGWKQogRr6iwBPh1dXf0ucgCRV3DT3M30a91Tn8mKZ8AjNf2cz2SrkJWS/2QzOKsvVsBK2r6zoCwfg8srw0XaAaprhH+8/tbLOgKQiQmwnwwGvDp6a9ugc2uS6ga28lA1hcdaIGDIakwxNqU2qKA0g1dJm6Hfl3eqrmReftEylayxebytMK6ciUDCELXkixj0QEEv0OyJL+HJRTcK3IaVEWSnJeUxqqgUqOCkAYMpwSTH1Z84AVsDal6iUjEFAYwGBDQ0PD+BwzfyoKJgJm0KgWVOYjid4hasfG4ccc661Algu7L7BO/1DNhB//t8QdKuJyXbtyFBifrlArKvgu8Nx2LmfFEOdoBRS8eXAwjYThzHxuGcffFajjMM568cbuePANYLuR37TErpGhNoSDYuuzmWB+Igw+H4brDT4C8mizwMaxf2TuwfJ1q9b3apN5hraVjOonj+tPD2f30Dzj/BPg+8/mz4/MsPnK8N8w34EoODCT7SkwKPx8Lj/QGLJ/smC9ivwj7310DDAMfJhbeDMzPeFmKvSTK2/K4dBnuEMJWk/ddCECLheCwKwggtE38tHNYjBkwAO77s9yhWjiGa7TgJV/8saMu7klTCInX3KVXKIXQAQR/GRFUJ8fZAWAYxpkig8nYmdfnMKdbYFg5rvQ7tBKwdvdyeZeNTg24nO6HRhqFnS/nVuG6ioMv3zJ/bmHzph+jgCVNFbCqXuXPWlPAme5El1tD3ngWzrWGFPvS9YYwIZ5KidmGsxuqdYrgu8O+//nXqlKKJLuOgCrUTpwEOp0GRckKbn16MdtSlkliXY/rZ/Pa/mXm+/azjD1Om6suF8dqOxwPv37/jcbzhiIUIxV4mcNJBhmhS5r29tSmKfzqKBqENKsJR6kNgsymVrI71wPPtDc/nE8fxBosDttbQiVwRa+lADf0JwGTgXAPBBNqaagGwaZnqIqIHiY6Rqim7HMMEedmKUfx7Blk1GSY+P2aVqqDeD6k3iV+WolOZuHdlie1UziGfmAAcRplacuz5pLeHGo319CuxQSNGHSgCAp4fw8uKmSSQctQIlg2DCWzeL2+O1Z8wE7UHytyFAgXyHVOSw7ZpLToLsK1kIOi0Q5nLSh9AR12mIKVN1BuUsf9k36gZ2RmYzQoTQjzkwnLSZBKOLRpNWB9N11kgcFxdr1RjRQnckv/KHb60ZzuY5JRzOhFTs1cqSDVvZSsXJjF4kt7Vh9ENE1ijoGxTjSHZwX3HjCb3h5W+r/2z9Z4yUBmkQT2DsabJMQSxSSxMcF8MrErPkIPqEqex/2JplUyVB3JpuScSJhoba2cwZT/NSVvih6JgOB1UaSupxaVNxnpXoWpTkrEWk1gOKbapEpRSKOsMcG3AkvahXEptiZfFBVSr0DTLdl58EqqkbmB4+cVHvxf3oyEpprBresMAYGMrOfK37fIfLwzgrc4GbzYov07O/OmAfp7TofI/DNzJvekxsraZihRBID7sgKITN+/sqTxcgsCN70CVDwWOvqUrz6J2pAISwcoOdO59EA5InQ5SnrsQhzQG+Inae7VoYz25JgUfYNH0DjaHS3ZDPg8aaqhyCu+hky/onErf2U2qRY7F0HTDC2SFOTLo2yrZY4EEsDgl21PXVRoA644DjjhZBUoAuWxWzHCiTpbb11p4JquBAcd5BM6gPwmtqz+K4PsFCquI6rQzFQQGKrvVfcPyRKDwdOCIQGbgdQKv3DhfJ7x7NLfTnzsTHKcZzjMkgc2qysMDxxGIMKx8gx1vsHgh169Y6weOvfFpG68VvCdRdaZPxgyIB1Wg1sKxHN+/Bb6/fQf+j38D/l/Aj88f+Ms68YsxuZfO4YCBwIKG5T0d70/Hx8cb4v0dfhr2Wfg8Ej9+PYHXCxaGwwxHEOOkG3apKlOBw1uSlhSzGr9xMICLgB+OYzmiWm9poSLQg4lZbWLviE8CjL6iAsA5MbYCv0aNTP6wQnjb65LMz+KzaFwejpmbtD0VdJsqDbiAHrjGBe7NxoQIINUoy3ORqmRYxzugtx1UC6TmxAym5IG5MPB1zmY2ipLd1ZeWEMYC8QVuwbxEeRxAvZTg7GpDf58BJPVq73cgU8nKYSmRrM9iH6EGAGcI2/C+qMbGBF73gDKpifFBXwoYPVfun7z+9YpG3gw1oEyFaeE3OvjQul58L/2vKzrqygH/5nqI0PJagzzo4WjRcf1YZTHcPtvx8f6Ot7d30qbC0dK0JYToJlAjy9+NMMzGLzZSm5rUrAHYSXDuVxPTOhbWsWCPA4/nG47HE8c66HyqlRAKZk4VJFEUuyrvuv6O43cDMwGxCoHOkZ/lRtlW84DdQNqO6B1bC7SgkmuyJH22oxNgBQwmNY6ubDQVjTQCm/6JDUzkHk3OcvVgcPAEEhtpRsoTnP1ZKEQyuJqZHN5OkROgD1CDPCp5uAE2BKopurmPcZklScRy+pQbUNkyolel4TRmzpcvvNTbUgkGADrk7dxdZeamKVlnE40VRZLCNEHWuN9L8yB2v8s5hwHF34VxRocreAupJDXYH7WMtXnTRgftWKyEmIh7pv4gBclS/kYYpVtzqBOk4FU6ecY6K7tC19ANrwyAwhlcda41VPYqTdfdfZ6670pu3gSUCNLb4DODCO0v73uDqiHVEE7Vo6YDlYuCxPVYwjcPuKoVNhURQACnHG6b4LHVO+BwbFRoWBi45ykWIFinTFgHtx0At/FMMMhhxfCy3z3fYlVPxWAgluaqzpGimHad48QWHcZFzWhnobWU83TZzwUlAiSn2L0tDlb79iYlbW+KSdiX7Mofr/vLNxGOLUyQ2MDEW/ffSv0+BMvI9iHaK3VR3AAp2a3uUSrykHvvAwIThh6mN7W7VmRo+oX8AbeRYLMZbQUa1o9jm/3BNzCguYLMnH+TpuWKDZgVt5bVlBoaP4lN8lGk7UixQ4GR0IN3coHrZCAFxnbXzXWdkqZpH+erg4XGcf2bSmYYK8rVwcg26fmTcsHYigA1zXFuxw4OnaXNpC3I/ULWi43uBVQFQekBwJPAuiive+6CvwoVhZK0PV5MNFEyN5lMqgfCD83J+sRrf+JE4LEMjweTNPZK1An85XHiz6eenzkymeiLYsX6gLE5HAHzxeRktEjKG/z4CR4v2Ok4fwGwN9brhVhMaqboriZqGSPjB2I9GWgcDhyB8/076n/+Cfj8xPb/hh2fONylAFWU8rXFmRshBa0HUB9P5PmOOoHcG5W0Lf4EKyZGmrZLftbL2G/hF0HejOcL1rTyBbND1C71gmo7GYlYFEiZRJkqzd2XAVaO80zky4HV9MPe/tzDrQrWJ48Kl4mWySj5vz4zLjsbAOe/oM+njpQVfX+ZYukEnDOgugLQdKbGPDQads20aNB0KjkqaXIosettSVxYVXmMmoVs8q/6apUxKEboc86EtHle4rq2+ctqWjyxZ38qf4NN9AEfQYpiRALbCTN2YsKc/YIThFnfLvpjrEyS36zo9uPomVwtFfyPXr+jonEn+9BpD0VK13gvH3cJi9d9q1DoRhTaCfR1QHF9x3TEy0l/KS/qodDIGtZ64v3jA8/HgbW4SuksEzNA7cUobLiAIyCuC9rFM3J2zsgBwVpAnGoLrOVYx8Lj+cTbxzccb2/wdeBQ2Y5AFIA46RVdroc+ywAQoExzcX97g6cyUEd8z722MlHARn2HINm0jqT8TOO9MqCRQ2JHNxilg5nx5vPqh6ubwHHx88N4WNv6WZYS/aKYJdTVwCx9U06gje3FAC9vGYXO6/PmYjLXpXkYlczWm3oSsnr9+50C38Y9xkqZ9lbvxwJWKiGZATizDtAeDjfsLQAJqX9BmbckNSa7f6S68VrlYysctlGbFIE9AXCgm9kKvL4ohiuFQCuaWZc6bcGgqeG5oVYXaBfIGPFEm6Wy3KS6WW71h0AHnj0zy3pdGGRNY6I5dgJnFVbTA53Sk5UlpTLAReFyBYsJ17MkvYHhJK8vU3TE2uqJ4D+7NPUeRunlotjCKSpaB11V5LEuPYOdYN+HAl1XtYzl3hrqUCgCSVWpYEa6n2Hkl89N2lZXWkuBK+0sq0xsDGW1wCWqf3rBbKHyhBmrGZ8FWFINirx1kwIZAFdQLeUo09/TxuWUqrswZyhgO8pK6xyaFp+AMRPtbWsVYJICxFTOH6+//aI6kP7Qh0g2129MjE62AO15ZB71kyshxc18iw1IZ232Z/sf1CQwTI6/Kx9TpejPvn1W5/4bmHUxBfocB1C7z15XROvyhYipSl5+sSsRbWRtvtludq7695taS/cnJaiat/Pzfe7VZVdHMjgx3P26vq7dzwVOwd+DsTq8jbNqyqSMN1hAPr+DEM23OBOgYIsAl2x8hJJYxobrJSnqzw1gnZQ+f72AfMGQsI0Rq+D1LjyOBx5IrHPjBxy/huN5BB5r4eELz2fCXz/wv341nH6iciM9kHnCkzK7sQ3wRIaq1UaFpYpAxcFm9g+KQNinkQIMUoR98YyTCitamShwiMBaRulZB7CB878+UX/5L1R+ki66DgnSBA4UdiS2BSKWZHHZi4bPQJ41dtdK1QVN/u5Aw4K9HYDBlny+ggILgz1M0uwGj4NBlXNQn0dTdOS/RPvquMnAfUbYpQCgz5PkU7P3bx/H6n3Nh3YPwckMaL7g7cyVIdKvjzHtqyQUiO1oCfjGj408m2SgLx4Bk97v1Y5O94LtV3JS599VqbCmjeNrct368+vCswxiZEeaYpU6GEWUwu8esWqdLbvoTgmMWFKfcdko91sKxUSjEgRL1FQtp4G90XBd1RvrGW7FB9pKdMgcFs4/ev3rzeAFGakJBTAZjPuP0RQg3IKkW4iiaDB11bSJV9G1n+M0no3hvPkSXAbfzPH2/o73b9/gj0WOojMb6e6ABQFz6eGUaCcCyzaRuIysdr7LMJYCj3UYHmvh7fHE4/0b3t4+KB9npGmlcwP39OssRv4zqEUgHeXX7I4kkG8qGScwGk7nzAmgw7jSDlRlQTrJRIjMK5c5MhOwje0b7oYDVG+i4oWyrEVj2M29IX59VWF7jQPyKljxs88K0ViYoVrG4C2iKV9yZpIT/hRPvdfcVUI1TZjpOZjbegOWDiWofOSBp6o6ZzqnnW41fSNnb3HmVYqmoMbtJGWhm+pjFZs7M1Xqd8X6arwqrulp3LkrWDpeBtSoi0ASwq4du9UgTTB6atcH+PxTQtRZxgBOMpVMiMzRhVCHAitc4MgMiZdKnJ3VpIFJ8HcLFANwBYK1GUiMsZchPQugXr2CABnGEMAIcNZEua5Fhm03CIL2TILUHpAiuc01NNDHaLGrm1zbLOBT19oG21zNY+qDgfZlaVd4cf22sUHUGq1AFIxQyV0cXdJXaBoDzEKx+pNa6VJT7JXGmAqEFVCkJp5deC6I/kkbcxbvr/LEawFIGW2X5WI03x6IPRvKVlcb8BQY6UwtWspxAxrm1wMoWdlQL0uk5BOTTu6Pisbff5n+RyB0shpynvQvN6cMTNKAh85UZeazQ4rGUBMe6k11VYAVmEBfOQFL0ywM02MxF6kK7zg5AGpq+s3NSI0oAUy2FPq+hm7MSvIdhgk1qkF/Z4cHPeljmh4INnrv/q2+Tv1+AyUrSAv8ug7596lW1u36dc9DLykbQGfoo0971iCMghhUYSpnFdo2zyc7uhdyKyBX0oFehFx7DyCOA7ADxytQ+cLen+wRXMXsrWxPDpN0YcWBZQn31/SCRATcVE2IwnpzHAAevzL5l7GRO7A1R4iN5Im0PRlnD4fHQbbDwappTz8/lov2xqB2gypDTTWdHlz1gi4xIlYUjs9fmSDED0nkH0iwyfoAe0n7Ho4VOILiuKsMFSnAano+AfO2Rpf4jU1TnwPOmnyrUDEDq37HYDWj39PD8vhWJcr6mffWBTD6z7czZCE/0zjwC3AV7ijuh6a2NhF99r71mZYNrquqDCXc5tzePrtugUoByv7qnDau7X1fbVt0mtzliwut3tmehhjVFDz3B/Psmz7b7l/AaASKqdoRzymGGBP8y3uANY6a2Bp37NxXo6BD9HwLg+32hW3QvA8vDKkzS0xbbVuz10/YTme/Zbf/0etfp07pYuz6g/5VNwNYk7FuUK/f4M/lCJpWZYDoIl/Mq8pMvYXaSdy2yO0/Vhx4+/aB9/c3Upgs0NlFB+C1kQgGFhOsEBRal3RF2+AgJhMHnuXACDY6rfXE8bbwePvA8XjHWgc8guWkUUpiltvrheU0jD1pGUYASVtkfJjOjIwX5yC4sx/ksIuilNpYLxeY7UggebCHUqXyW4DC4pkELciCh6hiO1GSQgizeU7eTU9FKtEeB2PslYAyyCqzwvSsUrMqzHC45AMTADZncAjytXznC50xlKHVMci04WdyRsOto8ULVY6tgQWmWSRZGE5oV7fiHgggVJgkwGuuIznMBLuldfSEms6dw6BsT1MvoTipO1BgxBJv6LCxqjPNWEZgCGVQ2U3AhtPcbQgdpE6ILCMqXdilAmVyPN0st0CQ/epqCtrRz/a6gu/5gaOSqlgwzjKREAyBtprLTXu0O2na8JTToHDon4hSFqzAyJgXVA5PpuPdSiVpGlVOpu8ggMpul6qI7Kk4oW1wrat+gO7SkaPNWdN7ZMUKhYHBd0LN/wiCeADUi5PRlgNLJKsajNTAiesEhiHbUwCwjQGlyy6NuMF1nhmAClRt7jV34JVcw4WiVn87KFUZrUgp9KbGGWjIk1VXVig138MMsf+5Mf/f9VWgnbLm4aEI+vxKgo3LKNq2ljDvQLf3nkzVZP7bEd/CFwUUcurWAcr1lw7oLIOZ1P74692DEb7gHn1d0x2tZeLr+j2FMUNx8gYjylRfQdH1XU0VHEyhj3MDlQ7n3M0yYJ+GaTyt602sqCtLOwDMGrLpfKgKnANlAAuBt1SwHpjeSQV00aD7hJ4h7WY4EyTW/RV0PJw/l8ym4wiYHVh2wLfhBeDlm32ThpFlz91VFDZuw0HbUq2AtABfAA5UABkb/uPEOtlpmLkpLaueMdJBOawVSqytFVjHA8fHE490ZDorwhF42CKgVuDjuVULp/R2YwQ4JWI9HGsFnu+BdzjyvVB/NpwWeJ2Bs9g0HiiY7wkKjmCfCCszgTT6wyzSP3MLIGUHxjYKUeahSoVmYZQjLFAWyFVwL/a3+SKWmQZ0ZstdPM/qxunGxVcWeU5BtvjANObz5534+pKQm91vc568Hd+c8T4osgXeVX2b81m3fQ5wDehsGqjrWsuuckxTUPoMhXUmoV3dsHYAKIiDcExNAqrf3189YYvGG2xcePhLVea6OuDuL0qgxOevpko62KCTwX3DYpz0QNL2i1zfHpMg9spc5O3memnBCkj+/1Pe1u5f0j8sXPNDvphR6IHOnyayuiysoj5cPPm+nw4yABnpEkD7cq9sMHq+v+On79/weDzwWGyCgjNLD5QUf3qjFidymvouwtTsT0OwTEAJgEnDmlmFhefzgY/3D7y/f8PxXBy0I/6sBRr1KPCT6ZA1N2WOGw3uMoQoQawSnOTaV2d2ARSbzcKorWTG7LXaIxBdbkyXKpSAKdpxgPx/KxD1kuLkYEars62MWzjsz4rUIQ9M1qVssSKSUn+yYOUlJQdsHY9wk7J/RA1NVuqzkAz1VnDjpKJ4Amc1h7CnS1N7HcbrbzGGOh3lG2WUX3VnVK7ORy5/sUpiYCN5gBzdCgY3wfQD4a6y4dv0WbJUDvAQmibQTgKm999GlOGVwGGFFVQNaofqLhBp3AXdC7L7hIwdTFiogb4KZ/V5kAOW2lCrXBWkaLQ6UAfWFgXOmIDKMnJGTcGPghfK5hJceZVmbBiOUn8P9VxVGeN5CxQn7DoD7y1KGwBm287sY84GPBlmhr+qiZdx7efY9hoUs1g7WTUIWgFKK3OXTqWjK5Bap0ThYZSuBIBDDBNS2BjkHC6++cZkSNmiz2Bru6hoquwlgGVxJU5ulqsk6DDBAPrz+PLiGtVUXMDgvj/P+Ky7UlVm2M7zD4hJnxdIC3BKMkzUKRMomHruH6/fvsoA6+yD354g4/lxpCL4q5x3QwcK8GyXMsVO6sLd0aH4sx520mN6GwV0pl6nlUGrlFyUIeWeuYATAEl19t6aL5Td4gdPxb+3wc5GQ8JA9CN9pdxzt9DIfJSrDDWzOPraO3CipO6lKMg1wwW4+gwYz8AMPYbiO9gN4OjEd8YPpGpODtr4jKY3LVgdDiqNUwFO+x9iB1ixam+esEi8BHBMz998qyH4hMVGLcK8bTGPPoM0RWQLmTCRBRyUZLXFxJudyE9ld81xPOlX82RfRfRk5O6jUqIkzElben/g8W8PHL8ceP048LIXbAXi/MTCxhmJ/UrkXlpkVlVdyc6KnlFxYL0fePv5iW/v35BvH8j/8d/4/M//hn9+EuwFqbPhjirilsNJ9X47Au8/P7HrDVuV5spEvl4oc+wtCpMBTbW1WDAsIDgj6ZCyVC36y3Cwx0NVIDMmbsNvoDgLrOxy/wEQ4wCDk3ou22DKIhj+gvN6n2gPUZULk9u+GrA7kFH6sqtL1ciyLhql3TBmYRgHvEZAVJcr8GmxCWPibZyD58QzM5tMWMBUhu6eq35bJwgsZEvm/mswDH9XYvt9fzP0p/+lyl/Khtjtn17zgmjhusamqjXQ9qaRKVluwrPd42bXfdfYKJmnutQVv9itv/P6HXM0FAzcAotb+DEPrbHU8NIE/HpgkvWD1wU2AOkAso1nhy03yq1usIEktZx/+v4Nz/d3eCwurjiGHYBmMTPYOrFXyUtAH8yuupMSRPULDabRQL63tyfeP97weHtHPJ6ctGkMRlylxNSNV54YWgUctjdsBbP2tTlrxK4mcEaZoVkMkm9NQ5UrIJDjmuhaG8M1t8KLG9woP7qTm8I7GxUu+VhWM5oXjEwcK+ToANbR6UQbbFOmtr+DzdjbSoPQCseiwaWDEXtQUr5pPhFvZyeiUhOOxQRcfTYKLhoYwTopWK+egmOFHUZOqbOBbBuAtVTNaLqLvrOYicZQUpjhZomTDnXruTdlqSdzN62hlZG2GQ4rGg1eHbYBbgmECYwXdgWdXPXEbzpiLwZr3bCZ2jOAT/mxm/ajZ3l4wfIlzWyfBn2vAk7uDRidLQMCySyqSqbTJvDP+RrILUpYojxZIZFRPu0kQ0NZjjTHqXRnVeLVoIwnC64K1KneEVklnvOiZkwJZROU89pb1jABTc2mwe2K5erkAESF0tYMFF6luQAgiLkDqumhaSOOxMxJLODlJqDP+RdepQFLVIzy2QN1XS8KcAb2Wdw3y0ChBbvTt3hGC4U1dW8RujbDRCXXeWaLWUXXYCZzg0XBNmkSL+pMsTkdgDSr/2gG/wcvKsbYgBJUSXKyZlYRzY7Q5q1aQfqkbNAExW0kZZ+qKREGxK0C2CDk0AHedPqcz8Kkx5UpyXZw7SYvvGIYbr4SpKCD77BFe824J/uMtO/tiiH03lQwYAD3V7pSX9ksPwa8dfnzKf00hQyiIBZmLS6UIr/e4G9zzUzZtFL1vcFk9w8e8n9bN88+KtCWQSDYS1lz2eAyVDpWUeWt6lK4NCRWltSoClUnKUzYgCfWAWwpRaXmg3BdN/snjWpUth1nPLCNCk+PN8DzBXwW9g8u2Iqg5Hkw0NhlQAa8HJEu0CbMsALhT6wfTxzrCX88EXlivxbOH7/izBd8n1SLSsna10V9ghnKF3wFPJ54rHe8fXzDx//17/jxH/+O1/E/EG+GZf+NETEQPrAiA+M4AsfhiG8G+38+4P/xnY/ulchfN9w+AXPEEvLvQMPZf8HGcJtggv11nCPWYiXe9wz2Y17Z1ERLH3HGkrZR2eA3btzSnq/eetrP2m5dkezjA86J2mhfVAoU+Fk5e7k/xAZhNzWVDqSvg39djcShoD2v02VdsTAmWgEmw9B2Q8GRu0vCllipKPdGAQbpTTOnoWTr0nFLBl9eBbVsIpYoTu2bspdLAdu+26PG3jW2ZbC1B4VEktV7g0YgaHnSHJmLVa1JwHDqN9+TTFB4tb7F9czQ6p/Q8Nl//PodPRo2z+2+Kb58xfyBkV83iTSV6bKwnVHhASl8/bzLCN/N8c24msHC8Xz7wLdv3/H98WSg4cyELm3AZdcnuAErjFMyo+UDZAjd1byaKnk7bDniWDiONzzfPvB4fOB4PrEO8h4RwCEQSHCsG2jZUd2UmegRReB2WIMXAqINEy8wRaMQvcpJ+0FxM5aJypUmGuFWQOGAU82pkmXmFDWlHSElT2N8BjPHDEBmYBUYjHhSNYmKEU0x4LMoAbvuZyH+7IwuT922W6Bn1B16ZR8aKvKwajQFOkTTV9i6j73ZzF8aAMXsMx11boLjEGjYCRgC8FJTryHipBqUvqfpOs2PXsZsfUIyvhrAtp3ZGjo3hkPuqd8TCDVy6g1BEFgnATwMCxsvdOaSBvZcULYjho5WqnQUOHUcRaWhEGgmpYbULGbbOaUaOIdzvu2i1QHAhQmIaNNK+04OPYEXmnqtAEcH0lL3PPvGxvE4mk5CI53FXMuOxC6H774ER23RORr4bF5/QAEMREQrRzqnobPptYMLEMAZwVEG9+TOC69xU7sCGzqRlBMs31Qg0h4sURDdwT4dKPiSDWKDnmFldVL7AmlFWqOVzlRdgL8zbnQcjuhg46w5Mz0NPHdJEp7Pvf9u1ybtryRZ7HRCpixcQQHUixXZm8n64/W3XskkwWQOHVOhsyYjCFOhAUcasMVTt1bH4auAoXPA2x5DZ1/PrUAaJECv+5IDhypc3sRLgYjRm7+CDX48ZVm5Q5h4gGwjgw3+JpMBNUdggAUKlRuQYt/O6zy19C0MX4DGX5EdVDkctUPRRDoIrwKmmV7N2lc/AUGMu3FqNRSmeFO5eA4XGIidysNRyZHgTvkyTvw2ApwNUllrb6wsuLJiZyVOgdn6TM61CNlEY3DBQIY+tyu5AJ9R4kAdT8R6ImrDX79gv37BKw68OYfs7TjwehZy/QL85Re4bbRIwNaaW6p06kyLdK+ChyPMsQp4PBz5c+D4ZeP8j8LnNIkY6uCzZfUmvuAbrIV4BOIIHE/g7e3E23/+Wbb/zwhswB3hC42NKfLEQOdYjgcAfwH4/5yw16+0zclBgRkJS4cvn70EYQwLw1rOqqv3qWDvHZzVaDgHCjqMQ0c3mKXvz4LPvQwsvoE7nitRtMVomCi7MAZ/GEHGM0V8pEq9DabmeqZdQYNfgPgWTd+C5maJaL9WnwrHjROo3+2EuX5aJc0r3cvGzL5Kl7pZobUU6Jvt+sQeYjxJdedh5R5NxFZ1oW/Auudj7oLFkK4ytg1oPqOYKoI7XBufI02qdhDjoCufHVAkvygDc3678gcUY1LHSB1zllTbtb//+h0D+3Ths+B2/YXpRnFVKPh89JvznuprlQSwnL/+21Si6ZLXKGTIaA/XzIC1Dvz80zd8fHwA68DSQ5umbwCFzjIYQtMyzZyGwQyOPWDKzKXqU7A4EMfC4/HA8/nA2/s3vH074PGgERFApfIN39PEF9I+epMQSBaAA6JgbHK+s0xDcrbKdYVTxjGU6d4FmLkG6EkK1AAxk8BMPQBoEJEcHx2nQGuBoNY768MDYVslNXBqNkBgWfQVABIPdM9CITy01Zo+RdAZauobZ26BSlYPSPXiM2uZ2AhqmdNlq3Kx2VgcmozZa/bQnnqBJVySGGnEdrKXog1R2ym44bNYZndtLio1Bcw4H1xlj+Hmd4k+YUhlFdw4EE7Fc5h14lLtxnfjDMocEqg6pQF3TZMbrAbIlC40ShPZdahYhgfLy0ISNK7aF+I2w4wVEFGZdmmSvRWWngXXXLMmUGh1sQY6XqJCGQ2bGw206b2XBVd1S8FTpsvZ5vTueGcjEYCdMDBwRwcuHcjVVq8Oey1SUtCuWjPpEgJgCqwNwHJSHE7sGRboGvIVeanIsMfHhxbVg/Vyn5cKSXX/jQPBKkuVmvm195jtkt3ydrEQfYp7m3Qv2hoXkGsqFwFeyslx751peFVqXa4qX6n83M8vm6qn/eVZpJUVh3f+8foHL/VndJYTADeFqoxdjchuwlDxks+XDjrbBhhQCxyCOcEJwCeaTGiVmv/LhjpECiswtIt+TyphoxkdnRRowJlTtUidFZ6dMr8Ss7gBAyvSqrJ7NW4X2XNd5vM70BLQUNA76MqgSiMTH8iNmSUjOefW09ft6Dzos0s+t6uMgwfYZuzWYccL0DyqmGqR/EUxTpzemU5cwTWotgfiGaqSld8k6XH7hh8pKgd7Y7Z6LlCFvYJV1uRzKHesZajHd4R/R+CEH4bX6wXzB3sxPz5wxAceu7CP/8Svlvjl1xPbXsgiZzmKn1Wi+tiivWB1irTuddAP4ZdA/eDZj1U4TqAeTmC6rwSZNy3IAbVgw3dgfQL4rxNn/gW5PmGvT7hv2HLAFmrxmTMReFUgeAZY8cn6oYAmOfnbg5RpSdCySq7G+sWKrmMx4RgNfK/KGyvyot4sBgsm5cRm+XfVr2lBhrat7YO1p1qAIS8GC9Uie5/2htPGNgUoUJUP2sM6odAlWr+v+ru4SHYq6Gn4VKRNQqqHvDwmsjSZjEemL85squJUg+w14XeGHkbFxAn83kki3c+TkXq8gb0TFhuoJsGzWpjB4DxQVOLtO+y4yQrIjWmIsdvfuymrraBmA0hDWQeCeStU3gIK88FQY7+geWruuNdUW0j7H71+R0Wj0I2pQrTXX/V9Va8dN1n/dtv+ur/DMA/VwI2T+iAmm3o5r8Ch0+huhve3N/z8/TuezwfpQdDQk2IJtznYcQsiQnJsbSnLGh4rq+VOvuN6Yh0PvL1/4P39HevtDSvYr+HuiAqg9uz9NLAZUZSc4f859ZwrDacyIV35cJCi0lG+i0riolWFAUcKjFo3aau0WuCUZ3ATdam7wsYIMwyp2dTk326V6nq9beglBOx+OzQ9qVzBhagvDpOBISLPpG67OR2mdZRbiagNc+BhrFBsgNG2DKENmNMh3ATE4RwsuPNklB4KLFCIYNbLDcw4OiUQ+dFsDV5QGXMT6BU07A+t9MHgy9DSbqxYOKAm/tJ6Ab6Z0V8sAzEoENgOeHtuTmtnOoVOUmoxrqDR0AOGNHNCaY8AwUqrPLk1x5vDtmgbL5pNwjGzQErSrK2A1fdUlOa9ywvWwryPwJa9JehMR4pOZSVaAhSMDRQbWejMk85cgUhporpHTbamrLADaJlr07WU10XJUxC2XfvKC61iVUniaU/Njgo27IOfFx3MIxFR0jQXFckKDzmY3eG0k9re/Oyuck9ma8xaB2AEKqnrJAWgy/OdAGFAhy3ZXR2kUjqpjPS4UhOPRjqQQmhUMjuKg8TS1JMhpEZ6WKi5XjK3f7z+9kub3NoY93NtNadS5TJo6/O8KBmjRqPqXzYFKScmGNBeKGYvlwISdGB890+Yim9d20h/dX3vIHYA2VRHRcx245LPr91/BlyT9PQv66/vL7755/abpfu6oAp9gTuQ68IZLLzaBBidCKy55BI4VdUXvN/ONrP4JzqOwAkdA7/TZ+1lj9RUO/RAZa8hO8W6eNeSKDHiO3GezCD3QL72V4lOQBR9SrIPZCORD9oT80LEyUrFNkBCMhxeB/g3guPMAJ4HXgKpyC3aI890GrCDmMNh6ul0HMcB//aA5cH1X8aGdSzEYmJSBQLR+vhe/ierxu4BiwX3AzgPnI8DWYvBWm7ANhABX/KmjitgUAKmEzgdQEM9d2EOs3UFGu2D3aQmyGCH095dQZTmRXW6Hj6BpdnVyE9RnfY1pIEOO6nPRm/D3lPbLhxoGFyGPhf3427Xnp/365eu/t77h9tURKzP55xpTB9XKrl3VTtsqkXwyyaMR6yuQvMcMOiuOWtZxaniBVLcjMnNKid1+BagZIIDR0P+r6mPxb87JV7RE9CnV0w2okYIQsGaXb9rwym7LWbnhbVGBqB7IHv9mpLe+Fvbp63eLTa5ff7fef3+yeB6yH7nhAGTBbyso0o50OKPg/6yDeaz2xhfhhhogNPv62aVOJ749tNPeL5/4PClYTGMMN03CgFzwwrAF4OHFZxiaeY4UUp2dQZBGQgntzGOA8+3dzzfv+Hx/ob1iAFKJqUKfl9nlFwHm7o6nE4tCkwq8wUfDjoE9gLcjNukKw72aCBJN9mq8LRYoPWpqN7oajYuglFm+illajIGzJmT5pIILEtJmtqIimwLBUQ85AuGnU4qGR8DTJNbzwJ2iF62aWANxjKunDWXiF7jU38H34iTxutlpEIdcoxZ3D/pnZejvOQOxyrDA4UtaokDWHYiLZhNVFYxbRMIAzQoVjA1A6YoSc6yGAThhl5UygJY5ZQaUQYvqgb1HBM+6zX0l0ROliKKDnM32CyDbTrKwlbTHNCDDE89s6VJ6412I30ONVCAQDipO5szHYL7Ljr7bpS2TR4ALBOXtQxwSe4W1CDPw1ZG+ldCiV9VS9gPRCd9iqYXDVDCUKFp4dj8XGeVx2tLH5/AmP0vyhxpEi8rbYk0BylyXVyifahygXEC8VA1x0DxgN2gQ0BoB/dbtCdwSPkJAzxX99FUskJVdOik0PEeKEELtNJTKVtNJbLm1iY0PAOh9e3mQDPN8NgMand1vxLPIPt0IA16nuXubepqYhaDWSYtXM8klbkFzvZIf7z++uWNOgChHvWVQQaBz7tVji7HM/+DRh0NcBWFCjBdwKRtQ/9ggHh20HJ5tvkquwU0jQzGYdPBN2uEYEsfkfK7F7fjluW1y512MqABY1+UwD8zyQVt5AuEWGeY9fkToPAeK/paaEAuqU5eYNvEkuNu/INShVvgqvvjuraBui2OXWukv0Unnqxkm0w+pCXizYFS47eeLWkf/B4r5hPrUciTc5y6iTw7keMn3H9h7xgK5QcKkp6vDcsXk0QGDs1LJdi2qj7qjUgv2FKiBI0hFo63B/ztSVuYSqBgAfGkLdo5tOvSLXk37k6g4VTNWk8cxxvWtyfw65MMBduo/KTNXvRVFYYZA2kNqgG4kyYFBQsBLFswW2hVptmjpmQNJG2qZu/p10j6s2q033uHqJvnJy8wZ7d9Oj2RNxx4PXxRiwWou5JeTVkQyObX/mbPztEvQNfNJEPqU2K+jxX3rv71UaafbAF6A9D9JJNcr5rg0p3X35UbmzW4AtBJtFcT7XD77Ruu1f2X7utSsavb+kBJhmKypCMxLbvdkns0LbfKkFgOyiaiA722bZ3Ib5s0TKXfBGq3Rb6wfM2K4p+9fkczuN0in98EMV+Cg5rfAYC67hhCE+hsyHzWF4vDH9JoyhBrAcIA84WPj3d8/+kb4rEoMQMnGrJumjb2XXgg3OHGMlwCMGW9XeGkBTnwcQSOtfB4e+LxfMfHtw883x7wxcE07pqioFkSezsPMJQ1cUae16HgXuHQMqNRroRLNjCjjxedwKnqQskJlFEdqPcUAFzzDJg9cPDzN1hi55RPKt6givK2JdoRknLlyk5Ug+EyrN4svmf4WDgH30ATKVlGZ+a6pRttDJvuFYmnk/u/jc2Gz2KJm824nLBObK2MPZRxF53pKEnzFpWAyBFm5t90v4Ap+6fhSaAB7cwYTHxNBLPLvuXo5IgSeBkTM6ZAp/nxJ7rK1WVOPs8CVTZ674e7+IzWNnZuZrb8QcrLOFfXLzgzIJ0Rato4QQbpSVs/a+ZuyYjWQeDaMniQQtEML3Rn83b2EMrGJTIsBlRK4hhtmPllaXuymak17Rvzg4PzskiHKJlvBgmBc3PvwngWvjoYUVcqOMyvjM1pmaSAmH5W7DVK4z5335xnktxTpFwyI9RuwTLk4vWU3FDO2RirQDWiotITZaiLGVawXB4AqmJUeXhODSNqANMZZrWGc0wMfhJkne44GB2oQkpnHKpSwdhkXNrXFtfwQhPfKp3n8NSzmv3Rko9m1/764/VXL7v5Fcy0bKD75Rq0drNlJ2RZ4ezPoOvtBBqpVDXr7klVpB5MNvheXiqLnzVqT1VANj1B12j8bcYByoCKehcluolAn/QeCK6hj1QGU+1zX9xuwxeO5eB6jF0xfVapci6uV1cQqkpTlC+nTgU7iBaM3/h4va956Q2jVDG16iCqtD43+olPsWPwROOWK8valXPAtt3OoAuQEXBFXRRUDnxNJtxahWepUpi0W7n5OwMI8bpslK2pLuxM5F9OArizUL6wglSSkKAEJHphsgecixFYceB4Hng8nwh/ItbGuV94wZG2SPHbhc/PTcpmV5KMtK9lmMgjVsCPhfU48Px44O3jiR/+hpd/Yr9+Re2L6mPG6kOIItQJEP6dKORVMDV0uy1AuMj6HPTGdsluiMEwT0QAmnLkCky0j+u2H2dfA3MN/EPezoHOjwIWSjq38iTGnncR2uaDAUCqcL0PqwaYt9hN779hA92TAH1ujfQ3qts2jtHv6QLn7erDuFRJge4+7+/rSsQ9sJrzi1tF0OWvFGlWX/M98L9XHkuJbZ2fLmpYMZHtRUF/s1QylAFE5xW44KRsN9WZ96XNdrvetofV69OBkM4jCF+vvMRvy01/5/WvBxp9AHqRx/rYXNiX3+vyZ1uRamPbG6D/rt82nzCLNAsKqcCY43E88afvP+H9/Q3rCPZmmGJWNzhaf5o60JA6Qvil30EJZF6HO5UdjmPh+bbw9njD2/s3rLd3rOcBEnFc/1uwSJxVwFKWCIHyFH+Pj9BdU67vzqG1aSI0iyIHuDHfCw7ps2QTTldviud+pynrb8rkkO6TxYpN7C2p2qZZsQTq1k4TKvGbSpvi1usAegEWarRWVri8qUAKfExN2soYFGqANXsRmfWhzyhK2PY2NaAWgVolM+/uxjK0NoJX9yzwv8O1D0ITJ6RCtTMAqUCksguBYBOlsYlQ3ejsDQmDb050Btjo73NSOGDxLAjg+uwNFGCqlEDZHGb46eBeTZERsPCuPnQeMZkJd2XjAIg+0AGlyymSkdtONPUMSXWgk/UyDjMElO2HqhWiUAFwc2Sl5JAZELa08vAo5SR2sVnRzVG1YdgzI+UUTe2E5J+NgZbVPStcBOiyPtXgpSX9rLA07T2TeusVpaZsNnsytmblhY6xM1CGWKYsnLKhrmxa8awHgNOdNMCqoVrCgk4xgV05jtetpwdvzjNxgzn51uacN5LA0BTNeP814ViOHaJ0I6/TRUugGg7PI1tD2RXb4KepCxxKaGgz765rRam6YxR6MMM259Rgx9fy9x+vLy8Toua+FIk5GsiUFGu0x8oYVKLnD9Wcd6vOpMq9mehAym7KrWkuS+f+iBK6CfXqPTQ1tHbGUE5Z50SygwL/V6Z26LwCaJdXFGrwWxKr2scq1M4CsNG0bBSuQa0OuCpl7Xd7+jADDWVq7er4oModJPHdQcMtkRI8913FICT4CnJLEQXbwZW59c6QX/RJAEBK6L6fyTZkAhmk+rRQRxqQKbsOiIZo+h4KVLStIo2qRLelzG95IU/tG1ViXGDVChz0d2Kod6xqMNDJIpMhO5FVhQyDK/G4DsexgAeAIzhT4wxKznZCAb8kwgK/hsCcnvECGVZIQwUDjXUsHE/g/X3j4/MH1pH4dZ84LbD3QyIhAOBMwvXeAK6EImjro5WiwgDNxaiCkoAQq/TCBNC+JwhWECAqECVSMMG1CHTa76Q0myoaTaECAFMPEs/TDQPWFay71qLleOmH9XmGoRF2IK0QQ58P9bAqKduVO237r0pqJrvhE/zybAmRROObmuqiDabivbhwmve1aI9eh4xX15WKGuvQSSTuR5qq35z1G72KDDcbcG9eQzfrok9DDGublKJ5KwNuSqa1zyXrQmyOtoG4FUvqBvNBXMIg+wpCau7qH79+VzN4y8H2nzsKrFm+urI9dYsxrIOGBuMY49u/c/ejbWi/xDMOLA98+/Yd3376Ccd6YvmDkXrw2hxODehQY1UI/EY3fDMj2soQy4xydMeB4/GgwtT7O473B454w6MNuHiLbP7RsDurMYwpIeopm00JjJtiGXAGZxmEQEmUDq/x3kh1WigrHGBg0YFCVXHCtPNzwxY59pZqJJOcbeV8p3urovRCGh5mNGLpM7CvtfrpVQWUrQ2gejFWEDS7wyoRqYOoB8QGSVYUXrgqBS8rHCb1lyoFLEAsGfHs0jhGtq4H4aWxAuOxYA7EVvVc2umsaBSsFgG4sSG796MLULBieDnjAYtwciJrExxobQt0cqcCL2zTobLJej9QEwhCmUAaPQdMQCeXVCdUbTDpCJt6LMxRpzTtuzKWdNy0U8mh0418TEaqCM4dpDYZLp39FAVjBedyoIG2ghHI2KVdAUS4BvqVgWW2sexYwDSTncX7c6Ux006ChmwJV1Nrfz+cHCoUlssenDDr4ZmTdyGFDnXRkbyrUaKMOTOx7UDTtkA4sJBKvokkqEqE+S2ZYSUKEtcaRsKSg3Q9hb8MFhzUlmcYgECy6Rx0Cm60246kEEIp1Cw62CMUhGXN9N8zgQgqxgUS25Iitq4EAkCKnpR8Uju1ZPw40LM3wh+vv3rxYTb6luMT8Omfp4FakApoi9KoMIGnDh7aWROzTwBg8pR0wG05AcimKCWj37EJVAZsywQo1/HFfjb1qxNrX1+l368rc4p+fwngy/4UwRgr/yYQWpjBvU7VvgZSpFhoFkB0P9tlYy5T0IFDKaGmeuzcZN/jQDlcJBEw+QAC3in6Y3LOHGLZKam6UdXM2Ig8KM4u4LAae2AemMHhmahVg7zMawKa2sJcgHoRlTTROszXLIOdgGnGxAbxBOV3GeRkVz47oJR8blebKIJmON4D+blgJzuDS7159lZY2KRAKUseJvZBAQgmTGCOPAuf//WCnRuv+CHcGHALWVCtiQoRmiQx2Wk+emIdSvLzHFxMidmqED+EaysK1OzqPl/Z+4MN+k3N6udjXTXSk+xnlOOgC01zGkAunNCXLG0NhPokbMBkzVlx2cfqraEqup0NeSSoArIAQs+5OvgxQ6uJaFvPuUx9ZgrT+lIyVo+nk6y8HbuqdB3ElM3eQgdUM+tGWOdur0o4See8sUuWqnd+3RvvuSDZESZ6204ZA5auHAFAWaqCymveer+lT8IPqAny5j5uz6P/u4cvs2c3tY/uv/W3X7+rGbxwZWdw20D9w2sQ0O33b79r6I1rE+k5uEj9ezafzptt7WI3x9vbB/70p5/x8f6Gx1oId2YTJPdgHgJ7JuqUs1RoAldg6ft4HFgrBEgCb2+B98cbjrcPPN8+cByqiMCHG77tMiKAwU/Ny/CEYYNOTEQVBT3Vyja3Q58qE5KPaViuRi1VY9IoT5iRqg4EEidL2MbsUnYkOTXGSZPrkGhwj2NAMoqygO7MYpi3nKhPyRpRohcEgyc53ghSpmBG3n4x8/tAl9X5vQwakgIIylrs4M9cxreSv5huWElTNJJqJsUMA0k/BmUTDOAqIC3VAxLK7gfSN46yq4wMDsjzSlWJ+sGxxO6FGUbHgITvMd2EgdUYq6s34FVtOjdle3PwAY0ZOQsMzmAqgRteZgA2jgps1997wbZhS+WiKxF9UujoXUMQMZPGOU0doKY3Of07CeZ3oxZjJWW14ZEZOAUYNgBsVgC6YuRuOPkF8OTzMjPUdg7cMzVwZoozW7CiWTTDVGDaWSVIjWKz/Ib7ZiN8GuAbfVXWlR4B6RTQWF0fVpM5qzzJTBUR/4BzWE8RNykaMoMZ2wXoTVzrwjb2uKScSlWyItKG3sBnGDRKk4trMAj1IOGWAKFxkvNVNVGBVyox0zasLPEyYFWq0d9wDaBSXuq2H1xnwsrY3P7H6++85PxSexjgUp6FfABTAqgtMKzW4gCz8i1dJtvegCu2qKurKaydJQco/ADKUoI017af3ZDeUskDqS5GCgCa3vpUACKhpJGYlM1DKhAY4K7/+pI11dweo1Jfzw6xGy7voDtX25emQjgQpaGZmKxqz4UaUKc1hrydFZQQqGF5TMJR1Us3NgJb0nZ1pjlRVEF0Be2iQlayF89uz2DSqp38SmZqmawZ1HeB5aRj22Hsy9jKtXsxIXWyut2DTxNdDaUdSmtFPOOUa2cfZNaeWQ7p3bBsTB4Yqy7Z/goUnrC/nDiOwvm2gb1RZ8K2cYZH0veXKtnmJol0ACdBcocMuxx1Gk4FS1xl4ppWAMpAlxe0dpSANQU/ExD0+/T7qeC318+Te3FmrDSYH+teY5eH5hOlWUCYxCkVubTvTqAWgBXYXW3S/tL4LGg7AOqjSSU9/b5/k/6iVTeJ3Tuot4kCeAk+ILzUvB9m2BXYKsUUwM8TbriO0yV33ii3IYQVpuI3h09f2nLppuO7q5Ob3NPtM5pMyERyB0z6tK4UTPDQkvC6RClZlTnndgZQr9ul6LtIveU9ldlUeIdKpfXnvfAeDuHtNpNDWbtVD2wlcLJd4Pd4pN8RaOBaEWuDdPsqBRZTyZh6x+23emPe/sVPUZih6KJ/3k0/BsOKAz/99A3vP33D8XzgWAEEswChMLyl8UiVsumtiCXaiwEWnNeMKqxjwR9veDzf8PbtG47HE8fz4CA70zE3Gy1xgAYFRXUiNnMbwhdlE3eop0HKASBlK6vmrryTxkofdYYlmp6kDbmUSch2iNWPiso72zpQIyjMYuByqlxJnOYInKLwQFl7Zo5DdccABHqC2txR81mkvznO5HwRQ41iTjs8B2+7QGdC9Qw6+w3e324KlCJp36bCa01zWFqw1FmmqZk8Ja4SIcvOOuzpmporedtaM38CZVi3aLs3G6kTvI9tgRWJT+UrqCwkRSiw6Y1x1pYB4dT4nIDRR9WkzOBZWEikstbGQRj6fe6hSgFIgCVP72CAFDiTty5Nd00IaKLUBK3eGOQoKLm19CtgnpxPUQymeEgXMrcqOhcA9lC5XFUaAxSs8HNWAS+JgFvR6EvZAK0wc9pFpeJe4Zlq2kO5hgR1abkc24GNTVqE6F4KrbSuiYEZUpEJ5bZ2dqYUV2VVTX3WguWOnhPFeQJNletAKDW3pEGbApBW7OiuluzqkUZD1Tg2ugvaOTb1WzBYOUFlEJedM5hUtIwiC9QmxSqD1+LgRF3DBhtDD6dzUvQJE2isssnw/fH669fEYFK0I9hKgp9wAdOGS3n9I8pElTPYMJ5La7nyrjSM/S9YbVbNKxhAWsKax2H9DRgQA69RSBvQr+uxsmsOjXxfqYpJCNqQpverw7fC367WybOEA1glKqpIwr3XBSRLvsyKFT5I5lkDXQiS+z47IehXpZTV0HHwSnLJn4lKZjIV5ZQ3tw68nKAQ2+DZ8Ka0uEJxgWEyDNe+0WJzV/pZJN9Khix/2W4l8oDDDw7uG0qKKv02gaeqnwJR5MxzvgQkMGN6vl6GrHOq/q5nMI/OtG9KxscKhROvTOSvBnvRdmK5qK4cjEakz30bxrkiTU+++GcON2dPl+sewfeYMRnpo9qiagagxnY9E+2Xe8DKBMy1j6rpSapQMHigrbYuK1jpjDiBf5+J3MRYE3DdQJ4Ze1Nhs7/6eXSFjza71y7BiLMVHvuzTHQ9gfuN6ZOc69N2mYQuo1wyM3xhSpMQhtXMFnTgVFfQyaIBK9Ot3tWiNSVfZ52kxe32OuBxnfH+SChpZaqONESBzRniGbzupSlNrNp2FdAkU1vXOe9gRVX5sqQ4gvlX22NCTSzNwYQzOkAtCaZYRzqdtemXEh+6KtwrVv/o9Tt6NK6goudZ8LzblJu11n3HAmn48pd9kVeQcft9/aBNq6PLZobH44lvH9/w9niyQXuFaBAQncjFw26DZ5LrbLApwKMAwiPgxwPP5xvePj7weDyx3g5SdY51UXVcTVRmok25hqu4MkMMKGoLggxFhUbrNMVnxuxIZzNQNr0ElolAIj1U1uNClLLRCUrSubI6aX3ATRuJ1Y6eRJ3ozUVueIhGQsUdYHk/Dq65BzNEdFEJ2KbqFDjAroF3ryN0hbs45+AB4IcCz11FibakClVksnFadwJvTnvO5u5SfhkAJ9jfwcMcBbioLifYHO3ehkyAMIsBSZlKeyq/JytRCVY2urHRIHAuJzVKRgpGrKZ1AmmOQ78PsILiWZNA8S6fl7MKI89VHRht0ZMi4XjA94lTZf9VAKAeCb84/ghVFgrcsAFgi2Yn2dusRCYD7cMN2x35YkXNFDCxPEw6XkpBjLvqkhemDeM68u8dGzbZwuozZPq9AswXg0IkFdwCdPLTHFdYWdiLGTh+Ji2vl4QEBMK7EsMBYDRwe7S6/TIYoSxYcYK4QRQG633sjAhMVDcpbPHspYRQXHbAxj6xiTvZFFiXfaBdSVgFrHLoINC+YcVt6xqYMWV8bJN53QCOaqesBIA3JUoTyg2IZDm7B44pDoMieoK7JuD+8fqr16X0WOOb7sXe9tODj5VpbJ/W6j9WNNbZnOl5R9spMKjV1nHZDNf09pLdGMCBYbO0pZJIhc5VGsI6v4nu11SSq0GhbK4xE+1l2NtU/biu0JVgcutv638uq2114SiAPzAZ3u7XGJAl31vQsUoQ2HWa2/uLMVVGZsPrcu4d4Lkx81oEpew/40MhtqvJhHdF907n6SfQ/7RZMC4Bqi/j0selZK0UIrsqYgrg+Z0+Mu9ddeKtuaoJWvveR1KUq2me7rVvZwGC1qEF0Q9/pqiYqWdjbX9cCoBK6Dj9R89aqV4PgVvKvys1o2CqiPj5Gb2dC1+obqbVsR7HPi/RaXttL5iEBr4XxY42vZ8V36SQWul3zjChrSLWkD+2fn8/SzrOlI00ZcbrBpr7focSdV2WbHvhLvTA670Ab4P5Rgj8buEW06a7UehqJc+eKpHTDzLfyY2W914q+U8Vurkvbz6Sc6Zmx8pmiLURqhzVZWfmydS847ppBVNcepuKx+1RclmLX9TxWnb1q6AeD2g2W39V2xetj5Xo9uiDyb0dht9+XRMceWmGf/b61+VtMednHppuexbhOvgXN++qUtiXz7reXbef6nW9EQbKy337/oHntw/EcWC5OGshmkoYwmKyIB10eIebxDhYseAeeKwD78cTz+c7nh/f8P7xwBEH4jgww27Ce2yCmn9UnQDVi6wWd0uBTXYAYGzEhXH6NIpDkEyZVgYtQKf7m2gRAqdMgOXFPQSUEZMzKoIvAp1SoOcAzlvQA6nJsv0unVUY08bvoXKGHO6u6d62G1ALSzKCk3ESrceNTUSOq3EZRqUgGnpegO0aZ7A70wIGZDTuidYK36Bzt1JAg41zWH+JwgLihKccgNGqRyZa9+OSzJNRBabxD0UgblC2HwCqv5/3kCDbMY3XkwAlCc1V/mxgwedJSto1y8QNgPj1VQIqplItpBBV/NzljgMYg2dezKCl1jOaLsRn030bS430mzuG1RAw81VbGU4nYAjthFJfAisfBmALbHOv9kEs4/c4xDVV1qpgYB8Sn4t3v4SMKgs3BdhG7ULVQht9CVvBQBWXDn1gzPCPspVz+N5pzVGFnDtL6G0pq/T3XkMHLNhweH2MaDdoQxLTl4ncrqygKj+m++YzIKIo0EpbugIE/t6p57jMUbHFybWhldGh8US21W/RhlJQZmDlA957TpmjwgQgTFRwtgYsp6pbcd3HH6/fvBpBD2BUpbS5Bzd/0nwQrqbsqs/bCWCYgfjikuagzD/0cHeZz0TznU14yq63CjA0iGCCyLmrjMB70ncTyBigJurZ5I3amtBu1sgKv228vb5Nv1s2cTvAe0XhIsRP5Waw+azTfFdzRjqCQYPavmaFUXX1V6XS/pa0hmqQAAYwdWUbV0Cgz70GsfW63sCr0JZplpTr77/edGg9amw+la+MVQsUOIdoo6WAc3UysD/DUMnm6Q4UWIe5gkR+nbEKXkBz4TpJYAYm4ACJpthcnwk49Qwwc1bA4RfIZvVUAcPQpEx4gFXxK0PRz0QPq3kwQgy9PFeoVBNolNk88xaPcetNnHMMOlzuZ8ggTF+XXQFT4NBlIz2e0mYrXJV83M8OQv4H1/mSPYQqwbDbnrj/S1nv0v3PHqrQ1mUJ0cYftd3uDa+n2aUqvb/Q640L6HZj8bUBwAr2b0xHn5/bmZmjXtcH9Lr0vRua9n6zG/M3/LOJadB+Eqo+TsaigURnWuar6wriZBcax1ff/02wwm7rPYkR7pLZR//o9TuawWkIpwT7mw/v8sxlnK5DMmXeut2k7mVuvBeqfwDeuLvj7f0DP/38syTj2AvhAI3BkpKGQ0DUSD9Ro6YZp4Ivp5JNrIXj+Y73jw+8v39gfTzxeD5w+ANQX0fZBSBgl8QaQOOmLYqJPruZ0NqfXfMkCpeigYNZHyrR0CF6AUXJHngmWt8cAMzF0U4Cz1aYmL3aDbKSte1TYM2xL00tr2tdx8FWZ+1tplybnBWc5nkjsElQJ7gGYJI25VclNhxWgbBEVHHGBkQXCznQnvfhygSZJEpV+Sl32G7uOr/IQ5vAC4mAhXo6KuQU+GxaKcm2Qq8CEoEOJmLScjomVqLPdJWd0sJnBQKkfYmMgNMSxwZOFyB0Dp/yZMC3/GpqdkvSqwqoEywbOStIlYtf75yZEnUyY2+8nkrxSbV3CVqZFXLv5yYAkQlXBj5SjcJTOi4Y2MfSVAeAtDrXXIEZyFNqgS5RK7BJEXKBd5hklAFpgdEgNy8k1LxuB9D3I+pBq8B4Z2I2By0KPnDtcSXpwwKok/M6TEpiux0m3xWuzL8qSJzmzb879IgdGspX4B4DzxkVvZomYZdDNmYF00QpSb7PBf6yNKtDaj1qz6STss5eNTwBaRXmOHcHDUA3t3M2Bsv+tVVVtW4pbgBYN6DLawyh4Bok9sfrt6/OhnevV3lJPUf7woTLVNXNuhIphc1z46yG9DymTCU+ulyffba6+toAs6tQ1nh/wIkrYBk+9/y9/Gc6h8lFXfFLn9qpKiiJUMyowkp8968gJZNJpyjlR00Dwu5++hZ0TyKjClaOaxZGqbqtz28fw4u6AJNkO8njNoFnrunQqqN9WSkYKMBPsLuKkZIBcO+kDHBzVeiKQj/kDrimIrqv3/UpAZiCm+YD9Br0gWQe1tWvcFlWBRndR5M2AhQplgDCZ3o3A41EZl4D3QDc6lVg43VyHk8aYFSGkm4LoAqGXcsEC9Hjqm9bAFvrfHG1oMqFKhrQgF3Rl/UbwgoGqGJOQH8DtsTgs8YJXLMrbniNlaZUEsmu7xMY2ca9unvPoCZoEljSeeznqO/uex9aTN/ctVcbUJooaSItTBWjz3Kf86ZWcb/Jzm/6A5RmSenzLQt23sLFur6zeJv8723oYa4GqFfCvhaajWdg6ZrSgMtKXGuVadeaArik4E2qVrJNzfToKnhd19hBydDwRL/t74IZbA2UHGGI6yM6sSGfVtd3THJO+6B7cQy4lKwUxA6j45+8fsfAPp+NdR1MGZu2Wn37dWW3J1LuK8X1LGH93ssg3Gw1zAzreOLnP/2Mj2/fsdbBg+6BcscjjCDQGUwYlL12UkpchzossNzhx8Lz+Y739294fvuG4+0Dj6fjWAsLjjx4WbFpkFLN5E2d8CyUL5xgtpJwlMvcJUPq/IOTH1cPSIurJNr3WaQp0Zl0/edGG3MAXTadqLY0lM7Qk61NJdQswCMnSVXBg+VgU3nzbMNrmue1HxkE3DN9oSecwKMPzGTnNE8EnLqciesAOR3eQ6XyMx1HOzCV/rvHI6U+FCCo2ga8jIHIMVk6ZXskZ4vuPZDxeLU2dIauTzrSqhT0oLQ0Ss5qWDdB8SZcZRN+Amuhs8+tn9qcU3d+D9WwFtRzimPTwFLdhMAzDbBFg32WqBGiCZlAQ0s9XlJ7/GeVGhgF0stZlenJ5+EGb4RhQK7igDqeOjUObzQtpPsvslQNMDYUpgFL5KnUidzWPROiZhqvLbWhDFCvT0lSmNxWGjlKwJazp8XFd3fxozNi1swygSWu92ZQGJUcdthZrtqyM4L1VSg7cVrSZJmhTj5McypsVTv3sUk1e7y6YoYSlVEzA+q2X+LEC4yGlssB1SYg6SBVAcwY1oIqMwKVQknNeW0jfc66skTvChwK5H+Tps7qCROWCnKGwtHcjD9ef+tFCqkBIaCsCpiwEp2//rBROEXjyboy4U296qUuFGW4Z+/70Da+9Mt4w0vTAFcBQBCsilXElyZf9veVzlItKRr1L4p/1W1/xbdBuQJex26wwPs64QTqok6OFOiAkquCqRSfaD5gUFLGzywmJrZjqm2eAvdaM6rolo6i3UQxcDnvKgbNKNJItsGWA1hstu4su0luvoozOW5AgSBLn2FgJVSJkZDq09xC0xlgpHjBcElM0RYQU6huJLoW81RMYNlqMIWhArmoqjicFGOoElq85u0Ge/B5JuiLmdBQRbTog1lBFf1NAXGW2Ae6xEHdyyYobHn8in6QnfB1JT5aXc3Vl4YLwPf+R92Au9/2QYrKd6MdcWOge/Fmg4HJLzhx1c6rIzuVFDz7yekr5gDqRfadbKn2k3XQHwqEbrODpoLWPtJVvemPJoOXwLfUc4JLfAO9p82vng1Ye6u5LmN3OFAU8Cj7shpcz21T5LwJ+c7zgeyHhzQhSv12Fn0p4w+q2LfaQ6A9jUGzAoPu/eiiREItCgpkrr3Ca4mm9RnXskNo9B5wkxCPOoBvdmF6dPScs/cdJuVxO9z8Y94rbb2//snrd1U0MF9+RYDNkRuQCtzKb5iSTF9rd/LzcAvpTmQs+6SKQsTCTz994Oc/fcfz+SD1KQwePd2XcnCBbpYliIyequnUjfZYWMfC8/HE4+MDj/cPPN8/8PZ8YjmpV5zgWxpoxyxFiDufW+BfzYMOw3ZF0F2qSp97ZdWJ2QV3GcsMwDeaKhm2EeY4U0bFGC2WgwPAzHEi4HtjB27lLVz7PwDDCZgjguA19nVIUruJEqrKbGOzaS0vPntvIBd45E5yZZd7c7Pfg6loBlPTiG5AtyAuRd8zV8Osm0e4R0QneXhhbxrzT1Pw5JxRwdhDSlcwVXY0N8MKZaygrHKckkChVGnBt48SRcGxlX0xM/ipCpGVDjklL0wNUG6p6gBXLwQe2hi6XTkwtG3SWgOkUXiGKHf7ek7F32X2QSotaaCiWGcGDQzdaF2ahwqjMIDprJkHKVG5OZzOQo7vMgQ9fbwrwqHnY8FgppQVTDBTv3PDLNADg0oNirsKMAd7fSDgQADVzfPIPQEBPDQUEtekbVPuptRE5z0YjMCHAzA59/pAl26dnG7N3IDsxlmkjLklFiMnznORsU9V4ypLzp2/s/1Krgbmq7lWnQE+pRSmvZiRsC2qHzq505RBkIKVjh2qOGQI6jEg3Fma5ip/qVkwmZ0s4DM7EZN5LrRD4xmgWIBsw79op/+3fA0tgIvd2UI+Mb46ONgu0KY5Cm4EBtyRtJlmUiDT2RzKZYK9Qn3UppqqDzf/8pxYdcWNkkSUUHlDTwVWQKuhC68LoWCpQUS7c2Wl5XQUGHCDS7dNNp0gu1NSBGyb9NspUdyBqC6vs6pRsBMjjz3cbQDD021fJDvV1fxGMVrNmTBOO7vUe2S6OkxQmCcDqDs1aTeFJkHZUjqeWQZMBr/pWF0NEC3HrzlNowpZvDfqd5N+lD6bQNLz6iUzgkAmJq6KFgyjVuXLRE1mdtfzwsiQxXddo8mfoRIhGVa7MQrmZdfzZgUgtWGZKGQySf8MW9MuKW7926cQKi5WRwEtv1f65t4P3s+Qr7Jrvw8VcZPtQXUxJhVNzcn3ysS874bbbSSlucZYUP8O1KPEz/CKAdO2igwHc4kD8GQymZ2zFU12ks//vpp2qfsFZn90YGzMfKIsxIaqa/8ET0jEZSe6KN6VrC46tb/VjFgdj4669F4d+7AbkNfQ2rZbt4ISH7th2AG997qqhwS2BCVCC36n4wJGP9o0LwfYe8j+1w7Wu5rOa9YzVyzZfW5WkMoeJsj48nz/wet3TAbHbEbcYhguXN2M1f2wcFU5er4Nac77Df3Q+ZOmDZmx5+Lt/R1/+tO/4f3tHXEsPA5VL2BYRjoUswwCxYuVC7jBF8H3ioDHgfX2ho/v3/D4+MDH+zc8Hg+stUitcS5F1GbWGaEKRd6AOwuxHgUT1cVESkzvBMRFKYrkwc9GNTqjUYZWLABKVA2tp9EUSbSIwCcCnP4tTj9cm4Myq0KwWtdA+b7K/Vg8kOhGYkNhwUstuN5OD5OpJWuYkqlhmiehLAPM6KD1XE8ncI4quIWy9cxOV2oongEeV7nNoBkOmTiKmTj27EmJYYv6410SLh6MvHx1x6cBQy3OJyGlLWHSvksNG1w6TFd/hg6asxrhZbA6cAL4LKqJtYa8Bal0n6rpb+Pk8i3aV/GBMshJNdf5ie5hAZIZMdNnWnH9baMHbaG2VGkYIEASj6gmF0iVqhjIpDLnYaxXbZ0dZkk7DaLckjk8SprvohBVXRrhCtLMSRNojfzw1uWnAtUGkB5w8Y+HclWqXqhXqhI4PJWJMU3SJgULxbkaJkRCx3xVqRj4CMC0fKWCBSrY9HtLdA7RCU0Ndg2EVMotgAGSaFI9QNKSwwoNyf2payrPgXPZh3qCilJmtQNoVnKWUpG2qe5RZlRzq41T3wkFN6Z5I0HuJPGOE/ikqSdDIVgn87woQnCvNv3x+usXKYUyF3Y5wKm070Q/3ZZQbp7B0KrAgOIE5xgtEJqdDRgFYpqVQtDQlJKLriSrzmRLcZ+bBrO10+zAoWmRA/LbGSpBQ/oE7VUrK3kn6Q2oYh9hmn1x/jUIiL4knJPqs5x7bsrrzJVC4OqWc6JENouPOIuZ6A7CIGDaEpoFdD/ywDtmhmVHdnWbHz98kuECc8nKQNqVNQZIqdpW7ONLu6l/6Vx2cr6gmQ818RsABoVL3yP7UFIms0PgzmRris+ll8MHSZWUumyyyr0XAJ8meb8eHSsh2jun6ffku1G8LleMMJ8lhDxVhK7KmfD7aTCpZ7pDwV2JutkLI8q07G6adr2hs033QyOsde1jJh6//tqFeNsY2gV4JU1uCip65le5SdVMH6FgybQtCY5wHawERTW0phyrYmPvm2JteqZ4QVUBZe8FuqmoyfcNjU+boStXkN/o20Jd18X+SkzVy2bDdhWjQwPTpqsRyWoKUZb8XV+v0W+XtTDEdVZ7z5b2Yc/stl5rXM/Z+r9TflfXnasTK30NpfPBf+ecDV0LdGAS03679ft+u2dtW93mVSiwUCA9f6nP/yev3xVo9Bm+buf6i+oQvo2WvLTh+hmZDHNKrxvq/y4GM6RMLfz883d8fP+O4/HEWgtua+TpyglgmSFwchtVwTicgPlhgfAHnu9vePvpA28fP+F4e8PxeCCWo0JNoSVNY4jyMgCUfG0Dh2ydKFYulKkJpErANGZdkUg4DphUjrpyk7BwrK0zZoHTmVEm4Da4McA5M/FAUi0qY7iVZ/U96xl707UYSJCCxcBlG2U3zTYQ6+r3y86gJvJkKXe3VS37sqktDQ/kHHbIeYSOxAvEY5FARl6RrwGxMFmVrlodYAkvF9Dyao6Cn6QInC7ZYGc7Mw17KSugWSWgwtSZpKk1H5LGLJSytstZlCleSWZeYAgsZZuNe6o2DSWclaok+H4ZKyxdls86h0McUZotwetyD11rV3cchhMk+3A/Uea3wTyB9AkBhbRxCrwT7oetZp+UvEVUKUN4qKn61MRyESeMk+q9erqq8mgd9LoNVc9DD0xVIEgJrAAgSxQiTqqPTgTICar6D/gxjiRHfEEZzChVLAy7yIV3OIH7VCQ4U6IL2tnTViGgoeoZSVZt+EjeK6Qa8WmkVzm21qG051q2MODUoQeGj1+q+nBSfSK1Lzox0pzVmbXgYA/Pbv5sJ1FIuXOUFB9dAz5tKk1pRZC4XdcA9MRqApzNvdZZypXIfQWke3+xuH+8bi+Xul77GSZF6SfcEt1sjQ7XdqH72DqDD9jMQkEHm9bZ7Qtrjb9qJGIlig4nwJeqxAWBMkB05h7w16AHQFcFFZDWZFF8vg+6Ts48AlRKHuDYxQVv0N5+WEFMBw/phqLThIkiqL/hnt09UwaSDmf1Obsx+VpeWTeniiJygoNU0r1EMcpW8ZH/6v6BKb4WV5oDxchXjQE8Yk2oK5rPySZrPECxdblF55yzr88f6k0VM8AwAHFJ4hbGh3ck2YyLDvi7mZvS4CZ/A1yh1ZxioDDcfMZ7rIoOclKcZ1VQXomJw94Xzv00Raf+C/XPVUnYow1wfylapiYuZSxI5jZvj7s6VrDpQfNJNmpNlMxR64eKQFevUe85guALC0pnQ1lzXZ5oQA3RC4lqoKBfdPlizDlkIgk6myWanA72+CAb6M/dYCg0BZXff69u9VqpBIHO3veJ5vOO7u8wrfvGBNP9ftJ770kGQ0eNndQ02zcsfAXxLAlcC9t9ZBOIwUaZ7v5s+exqnh0KqgxScGAqIfK9av69QHvzxiXVXM4gBTlkEzRY793a9qVmc/IsYOt59drfer/+3ut3qE4pu4zLxvJQYwKK3lx9saXrKH2CuWtow/V4+xOnxmGF8IVv377j55//hPfnG57H0jRvZoHCHeELBXL6u8mYErDqzXgcWMcDz7cPvH//jm/fPnA83xFvmq1hZKmT/s/yaIlmw8ApsKLgWKhNQFPBzU71DBLq0jRdu81jUX6zp4WGqiMuKUzAr4FACTYj804AS3jmTCH/TFVnFMExuN2AC7gYBFCXSmHtNLmRS3XG6Bqq+KIAOPUaJk6nzbTv6si+bDI5fFC6KBjYWMaAA1JIko1QoxYNeIaNkzmCVRnrPghL7AVVARKOwJmFiq1g1NR4x8g5RWGjKljh1fdZ1GGqOMbguQLEgoIxcEYIqc82TszkPbdkpA4UVgIFZ0a6gDNZtk0UhwJGoPvU2ZtJPX1zAolM9sMcDrgtVhkMlPtleMfmwq6JmrKMgs5tPqtLOAFSPRLDE2cmS5kMLXyhA0s6+8OY8cmt+20jXlyfqBMvqHroYLbTtnjY6g70EIATMC8DxQC6kR/Sl29AQEAXCpUIlrhPScFTFWhqsFvnQMG0X9TMHv55WA3d0Mfh07hGijYy2WKladpgGoNwBhsN4kr1OmWO0BRDlz2pRniIanoEt9qZDLQbYHqx+bydpMmAVyZ6Zi+qsKMb7iAhghq5aNO1lzsyW6jALrlfaIBYy3j98fqrl2JWVeHkmeT/Omvcr4Y7dgPh43pgotjVTcBjimz6/MuvDQ5onrndZmj0NunvGTBZolDe+zdsQEHBLrqdrrht65fP7Ypi0cbRF2ASz/fXZOvHF/MmrK4eD1xQmcdI8wqEs25rh4F3tFM28c/8TGB7iiXXlUy1s7ESoCqT1jmA8RmpqvH0vKBU6elrxvz3BSRvzwaYylX7JF0W7uNL5jl2RUx4diCofmmqrjdg1sHA/L53bCOsUMBIwmpDNNWm494sCEMQD3WOpN/Tn1u6mGQp96oQaCNvZcUv22e4z/zo/ctzwT+nHtxlXRqAX9dQWqDe2zFAv2b/9nDSrsL0us4z1c00BXCeW4lKa9f32iys8Eev4awBr9n77/XZdnvw8x2yr/398192YevSInsV/PqhKh9XIDXnz+xS7MR1Hvps1e06JsjQOpURSrXLylIyMAtYfdauYLmDol6X7pMBLsrTXGfVdZ0FPf/+PMj3Qb6c72k2oc1z1vrP0+K1dxWolbbmHufe/vHrd1Q0eMP3DD5w24z377sZxTkvdn1O/c3f5+K5GR7PN/z8b3/C+7fveHs8cUQAHpStdccRVG9gD4DDPKZkucIR68BxPPDx9o7Hx3e8ffuO4/0NEQeWL/Z6iE7EoJxZr42E2YGVEEyyoWagTA1g+iJBdlf0Wi4sX1KTKeAFw7K6mqdKU0idxtbBLEtK8cgUdMwU1+J1rAoZOFqJKuO07mTwxk222ccgg7kVuKxc87wGnMrJ5TJOTtXD2PPdJuDFn3nx/krN2d2Nw4mp3LSZgLuJxtTl6ILbQhkn6xCgLmYTEZPxgFO2L6yUnefRDTkcet0Wc0/sCkX2VJ/aO+ArcRTL7NsNsRWembLOW/0CxmfE+SLOuR+65e3KfCgtE1msDsio7Q6qrGAtd+hbpcNijBoO38lqzkiKXBQeA+AuYUQdfKgBvArYVWyaLPZITNZcxjCTnFS3wknkymDBFswKGyfKipS0tHEKYksjzDnsxwnuTcaeE48VRHnL8m6CglKWVtVSAmDOmEC7NoEH0/PfCrASXGNiLa4Ts7MMErZheLC2DQvqWinTjBO9txweiUxSwdwumca2GwSAm7apADPX+eaZW9lUMxmkKqBe4NBEViGzGyv6muEI8ZnNoAbtTSqK7FZTnxLF38O1hye7Te4ar0t6+HRaNYbSwKbls0FPxjSM2r+QNfrf9dW9RRMjAkKUDOi+DD9rIIlqVgKu9ZdjdhPdvG7Vh/Z1t2r+RB56Dy5xhXbQrAZDtk9/p+919IT4/mV9jyqGrmsaoOKlZBcINKes2NQO2be4f6SCe71HqHwAsJaJ9mWqJHZlMX+z7RqqdZA2647rV2tS8aXnc8E1nu1umu9PJLMgoCbkebex0lENei5k08la9POp23fLX7PCXNfviW7CS6i53oG+ZZOd7eGF1hFEp33ni/vNszsGx6RB/ZCdnVeSxv1L4Nl7qmZtrhW+go3+Pl2fWAXspbs/IiVYuioBJuW4h005Frue2XyhzQq0/Ybk0L+EBQKbaQXfuji7XRMCZRudc+JTvR5Q72Obv/m6b1vFdCqB9+d6CzaahgRVSi6gqfVNuz1z602q0pGPHegj9fXf19m8HrHNc63e/Lje2FRK0hyv/cZKjqoZ/Z2GkWfXZtX7bAQIID8rp6crTZSTeFXaw91LUya56D6z9TfuXavewZxFoU6d/wnib3sM8wjQwhKsTlLxtalhvW+vYO/vv35XoNGRHw9rl3eu49HOsm4X3D6zN0p/VgOnrmX05z6kMvXt5+94ey74WuSQOxBhCPHmyx0RBneWotzYPO7PA8/jwPPtHW/fv7Mf4+2J47Gw7EH+ufEwmVMGldkBbvcS8ITrz/4Jk1Qur5GQbVQ9tsFqsdJgGsKVIs8YUEHgYg3yDQNQlqRUp08kAfZQEKAsYwVid6DjLClG6XfNkBzQMZr8PJOFVUUj7dB8Djq2soVU+ZIqJwuc9cGpxTObQoPreBNL1Bwoc9YgEuhJlFAJcZdLSrXVqWicuXFZyXmA9JM044Rp8d4DAFyTWc2wU8VRFzcVnDtSVZwevmk8KPHH6ctlmNKjaewuHU6gVUgsmA0vHWTvphgzEZ7YsIvlaoKUAXEDQ8Fgid1J0/E2zpE4kKgIVW1YVfFSQ7VkHFPUrENGM08qK50eEwC3qWbMKXWTqpFxtCoseNsj7jkzGA4aK6QMvxxXUo2mm2EDjsMUuBhQ5qSQOX835ETa7fN38iax7JpXEQy0C6TxwVCLga8Vq4bYmqciA940F6/iPtYenXIv2MBdCu4LDM7486RyVTGIKV0b92PN0L3ul2ha0gTKzuqPZ4HVMJOogkr/fUb1CKa913ABOwVTVg5X0/+Ahc7AFiRcoCZzBVBWzut00CmWM7hSZrGKZ7EreVMlH9v5x+u3L551ZfSrsVZR5lZ2sitRE6/Jhn6RfNU/d8qAZibeqg+TiAYgvzf8qt4tOdnmoinExbuya86A1exRHmtVNp3AaCg13BhfgY6Ky12hVXr6Sgg0UECr/YkGhRLds4MhG0W6XiP1HOPL1zVwGSCDoTLR5/WfFYAL3A327TIQCmU3oQ+YBtGV9j0GU5S7lLBKCnpywgqQlHHhe9WBS58IeZoODBp0YdbwC7gyVR7ywrV6UtdDtpYDly8oMPnRQKyz1I3LJ0ItWG1YObGCrvsOXGnjkv4dge79NIA0025wEar17l+4X56edffRXhU7H1t2JXv5IoFDG1XA8are3HhTenICEUz2lPbordFksvy3jZMyprOuaUqQCsRCyleKdAbgao17lhl7YayZO2BvKDondPk52ckv96pn9CUgnrOlZ9S78xZkWF5Bfvc19i9VYoaMzzVovaKrZ/WbzxZtufdc418vsNlcDrIrSGOkutrTqnZjshJeKbPhXxq+G4z3WWXLqhLAqoKZ7gM5bve2v/qszqnV77jEDIBRiPjtxvobr9+pOqXbKx3k2esMQrrEax29oQMPbYJe8onwrqdqMKxY+P79O/7t3/4N7+/vGrAHStcqomsOs8uSu3MRjwg8jgPH44Hnxzd8//YNb+8fOB5veMQbHAtL2mNsXu7GS157Yen6Pq/DAwAZcmJqMpYlJsBppSJH1QLylAgEM9UHyCM/jQFRIZlZLQKL0CTwtnKlA950lWMDBRcIo2FggADcCOtS9uHvegYQBLimzDOK/QNUoCDgzd5oougYOF261cdDnpsGgRHs7k3fz72u5+3GZt9sL2xdQBZXWhmhrCQFqeri9lo7LB37yagB7uK2997xmEzkdmNzrnVVhlQwKyjqBrqp0lfBTsnKweC2KTtqiw6xDEj2KoR6RwgaGSR0M3ICokBBAWFg+wkqrRusero7v7vLu4ZQxYfrSfWok9cSNLakVYcMbI1jsUysVBUvVO7WmWl6cmVwsCGAOlnx2Vt45Laeu7rxOBHhOK1pZKK1gd/L02VXfwuKijCd9aseQpiAVKno01170i7HG914rbK/cW2yo270DBbjHAzQmbkTtER7sR1YMMATaUuKYBscksVhhF1ejlKfjxdydx+IArVx3FJeQ5e7KdXrFij7ZFCQgK1rgGRnwMsoqeyeiLNwmlNpDpLWBilfnoAnBRYMbOqV4uEERW7AqUE1XoWl3z7NsLCxuxH+j9fffGUBOHi+ew5lo689TrvtVCd9qGzG5w9tVKVI5TsrfcQIGgHQdTG5YPcvMgCZAgLGqmENZMLsHdMDVxnZ7Yp5rhvi59b989v+daWt1Q8azwIM8NEKW0rS6OtU1COhtNFw++wUNayDi7oqC3OPKcA/AKovq9iL1XzSUH/eacD2C1jPeyhrjtAavgrYnHE12WElijKhmSekrNL98AImK6zJ0uTy6zpVgqZNjwFb17NoEH/DMbfoMRWRMFDJAZgFNftqLVhE6GciA9uIevGa7M7m7K145/1DuLDn5KRxmK/2bQPv7svg8/zyACYZEoCoog28b+s+z5NJUrTtcUwjdgNwk4KmCWGnAjoqSPIzz7rujYAh+SwGjWspNu+pwW1X20YcpbmJjH21TxkUZNYoMlnYtS+MFRB3BvHX0eUzmBivm5T72gWI+7x3wvxuW1u62Qtjpy2aedKPt4B1VSoyNU+jgtRuNbvzePT+s2t/zAnV2bTCSs1US7sFZwY7jBX3KlRuDb+0OafsP9S1d6GcG2YogpcCZWlG0HUG0BBcOO7e23WnRXJpKTRU2sMtyHLb3X/39bsmg4+x0yrWdYX8Q/8nrkwML7grGMqaTIb7BsjM8fb2gX/79/8D3759wzOeiOWI5fAIhHMWhasSscI4xC0M5oHjOHA8nnh/62nfP+PxfMM6FiIWzAK+mHWmneMJKQDQ5idrIsYwFlu0Rd3c2J7ICvTQr6abjJyv4wI7YBMt507woLlxU9L4FmU4xdTwAn4YCPhk+bYAsRvL8rsLjKLMjF40SAlxgRj2WADmGw5HRAnAmjabnEwtNj8peLm0yDl128t1fWxs4gTrTeOva4lNB/eZgf8fe/+2JUlyI4miAqh5ROStimT3zD5r//8/zrDCFNgPIgK1rGaTxfPa5VyszIxwdzPTC1QACASraQTXoqG9dw4obhfBBpV0YplmwELdkhPj3hduJpiiBhF4t1La4vAn6xAOj5iZJAL8mmfuWIh2ZKDAAj3g6ouNva7CRQIuZUlVB7Kjabgr7eMoS9RwsdyFmGggVZV6uOHVXNd5NQ22wOylmGhlMkrRmvNUncS2YUwA9xSaVwb2DgQurAA2PnXgqbhcBfJky3FcY9MRoONP8J0+HIKKV32THtQ6AsZy21HFieh2ee7dFJJNCDMCiwULcGdlixjwMKQrhkXnZLIZjj1Kvpj2zCpailx2Yjd7iuRyBq+wYx+VxnbRZSK7sHBTbKGCVDXxDOgkm25Iu6WZQaCpsnUxE5RFZ5uObwBRApislQlRc0pZPXNfrR4CsOZlR6CSogNdGxcSq4C/C+juclPPVmDhhJh2EgEax/35+q+vLgB/h4xG61SLo3Qk5+Fk4U80eQLerfkUyAsksASKgxlYI8MOfSZpoxh1oO1eLp6uoLrFCqEtZVflHAzbQAD/J0fjcc464gmtK8qN1gDfOcOIrRGgTDRkn2U27ScJVPeAsDYwzp8zNaZ2mss/TXe9NJMS7kBPRjB2cw9unK7CAiKh/RYArtonYw6MxKnPg16iH2UhbgZ0YicsVoEg8Ov7MecrHjW2jyBoHKUuz3eAwSLgBETbawSK4Y3jovou22R4HGkP2ugYnkTiEo/91GIMHUZ/OOvk8Tew09kxXggwGdLQuLePhrbVEpvB3ou9yjBVSGf8NIIYoMYxmYxbzL1OsG8wQXJcYeAao5wVYDDnZIHxWFt8T6bdeD5IyQrDAbUn4KcnQJaFUgqt7HoEAzmr3Qvp57HyZmBvoj6/f0bdnQ30+nx8Prk4aL2TQS5jKt/XLGstGSYQ3M8E6HVT/lzjNvTCBhojoj1nUCv4y4Fq2QzZiStU1wxEumeW5kHPZxv2kw0JP89jgMYhfq6tPm5CnHXROyaDRXvla90KKjyA1x8oH/zj1Cm7/Pm7GXpkJXzL51EYjcAsiH6k5B4PC+Dt/Q2//vUv+PHjBz4+3vD2llhJ3XzTlJYoUuyPEZSvvRbyuvD2/gUfX7/i29dv+PLlG14f73hdb3gL8sBzNvYxgMmqDHRe6N7oRfWhNSTXIo8cQMbneI9eJKEUeKpI2lHONU6IUpCLVA0ffIUth4M78JKNiqLS1NQ5OCsQVEJiDwgbHRvT0M+B7lJhLsfKFI/Oxg5KnlpcLdHopHGIJaDTnzIIak4FG2Z9l+DrVi2IwbEdtwSw1iZYBmtqsCgR3Eng+zwsIFbuas6Eub0p4Dp8S3aKY/0EcgrwfbCyARsVHBKtQmtL0IKyrFqrEakeIpi1u5DDpYUiPExv03lrOQkRxSid+nggblTflNndlANGsClct/ouSS7X500L6JKUKQqgmjxSsFZNnbBxo5C44OKziTQqC4Fm5+jcwH4VrPPeCKzgeLCYuphvydZZor3cpngEqheuZr+ScsrInFZHJq+a+qNcCyjK4lqbv0NCzXr+JUelA6hIZXOAaxvbqCu3swo+QBHqvo6xFZWiF22AWmMbiD1Sylwj6oySNuzB33fgAu2AU9dxq51l0La11kMqe0Ww0hgZ42hUX4gg3SoV6SxwYpfW6qFW6RQK0buqKNMJ1gI1oKZMBTfl7NxcG5HYXXS+W3pcTxT45+unF3sb9NADDIjxGejLcBw8aDsoUqHMG4NLXGkLPCcoggEcVGiQ0GNf7bgY2Bpo+nRkML3PMSloC9+HkEo3mUwVoFpQJMIZRIG4UIBI/rvWVTwyv8GobZfsg7IZwMP5xTzIODsI1V0dx0RQkGf5ZHv8mxgY4Eiys9CuYzMmxZLj9jOuOXUx5DJiOPe6aqGnL5N6ex52Wyi6i0N77WhKvyLobDgOFJzrDEz37VLfAfxGBciOnHmFQLyxdmmsObw8d7sMf4QAgv4U+0v5bM45l/jAYO2AIv0HI8X4BHw0PksFxw53mF2jOlDZojSUMs1JcvIq9pkovdctcCL+0YdS9/g9bwCPoPtjJQy2ACXJl4PGoh3/zkbap5qgcnBl0QrWOOkMpsahW+3B1rN/6CtY95PPKp8Sa4cT0gzqlZ/HznnP93j9jk+RPQD7AV917hKzelsHQJqtAsJzj621LG/LlPxOoHYgewklKiAXpn4HTLG05L4L9cn/yMl2dQN9K/sqzlg+5gkRiCvY+DY4Bp7rTu6d5eytnz1MxdvjJDkD0tqPABiMeGbOkr2hcofO6WbWrh6L+J+8/i152/F2xjBwEmdx+Hf9dI449e0DOFMDzoJZZOC6Xvjl1x/49ddf8Pb+jvW6WOCdGMnaVEZgLToZr3XR0Xi98Pb+hi8f3/D1xw98/fIVH28fiLcXciWuWDI+tBKKrcyiNO/SzWAcRSX9bCHljiAXXuQ24dPpp7gQkwajVYhuQOox0adGIJukJK6LmMOhO3Br3Faw6eAOluK2AWu1KEG6zwR6EzxCNQunDT0BfqHVwEWGqAFgqzM46TmTCTjWDo3FwjzxaHdREWpxFESJXYglACgHqKKkFy/J0W5Wf5TXQkwEh6pBBNxe6FeA2DGV2tWiiqX+C0t80KaaRoPjWIuT5XntyjkY4mlJBMAn/SwaE7urHgWYpQO+InCB3OaWLG22aAG6OQsdm3bD1c48uQGzN0MudgpH3Ghcygqp8/miEV/eLSzumaY+KaOiNBXcDXt3Yt2FXg3LeYYvWyp+T1Zy9MXVYsWvG2dMMgJ3O58RWs2bhwiWuoOzUJ8HwJ4MTeQS7I+JIHGdXjo4c7KaXRuoi1nJAHYoutMQZRAw33nksunt8d6XTvY0LSy5bihrRQpac5yjLDfMGdriqLQQRaZsQqccFgZAuoL1QhGSDw4BPNWCFPdzdWO3D6M9NVIITIdzINCLSmY8sDa2I3MAEoUrqKj2Cs6naWmmdGbImB9I8Ofrd69nd2p7FQ2cDluPVyss3J0EEGem5r3jSwjc+99cDwyIOFsP4PTvmIwZ4I4aGFuxZIvqwM02XmjE9LbgWkb2KMIMr7vJS4eyvjSzIdCjDHfHgIWw3eseCcxo26+Yy03HZVfXWk5U9kSX5GvYZaa0imajB+rxaghUnkDWYz0TNU6hx+pJOZHkd8S0gDgZHMH0J2DUAhhARSQnhwm20lTwW+p7M4eMPqAAE8B9nwJepqBRup73aayXk+3EIMBuMCg2Eed83BhDTkOrDQwMnCCSgjdGKx6mE5U/Y3ske7kQJ3kjpOp7TmWnfCP9/Nhjf/AJpASmKToF9lBtJNBRaGEUhvw5dqbz+Ptba9KZ4+UzB3GygV4O+pPOAAN+rfU89TuHPzaOIAIMMhQOSJ9p1f2A572DaEPbbz+/gl04GULShGjnffWYP70AtDBsK3ZhItvB7jMc7zV7TV+o2JHsEVoKijxfOIdzwGiux7xxze3jzP00g5prUpwGjBzcLgzgPTtLy8/gVSbb59+vtM1rTNT8d/b1v3v9cUfj8Tw2LA86HqMAcW7yOEPnTkKbH4uR9e7CyoXv37/jr3/5K758/Yr19oYVC5e8xFiLalGL/RWuRSrV63rD63rhev/Ax7dv+Pr1G75++4a3d/48Xy/N4aVimWakSACPnjrd1LDSDB5OkcANjSqNUikHe7mlnVOUjvgoY0ONbsGJThmjPil2RVq6NuQSDEefeM2cbDoYKwVEFSUqAJ2LNLDycuViZuaGzoGCvJQFBbBzYaMRcePZPI1Fbbx2dylqFni1umaLD+wmMVctASYZOxWAlxZ9NJWYMtg7oUUAph0Xf93rI+lhL1uGVjQiL+zYzAgpFe7ULKlWAEVEtw5SprhXQvOcKtDLx4FxKCkZwdoaR3rA/Zig0/Opt9IX3tNnJZVRQYBRd4FoCCBnE5CuR51P+eDyQRlL9TJ0HAoc52y2CesupChaBdYtLDlwVLJyM79iwXrqYAMdxeybayIYAtl4AXFz36og9GqmbzdNHFPU0ZK5tTqKqGYeeGqZAZlsUIgGG975HKKOe2EfUBCFqxtLzmCvUiMzXjeVdaqm82AnNWRUSkZydeMupoKtpPISyFFLL5itTFCQc1B080BMplaYGs9mhG5vuK9IVyJVNM+IMuNzsRwF3ogLAhKpNYBRsGnL3wowRFNZK6JghY/UON0KGlQsOHp8deE31awEqKTnJPsAvT9f/+VFSVoFGgCeg4GT9tfPHO01TcPOxSTplWikiXhkQhQJfnbInemIc40cUEPjRsdZ4KRigKfvz7bQQNg3OVBG56WDQUoUsEB6PcB/B3JTLGUr4giDhMAEAEN/MSFyAHnQcnDPETCy09wTmB4HGUGAm/W7RemxrkfWVVkRxbwIfh8ZF36s8fsv0pGNFewp1APZMOMTuhlnaj3mVpYzXWu+vWXj1B3az2xbg2c9gRCWazhIhWXA0JZ2HAHwfPk99nGdBJ7Req9DAab0dw1moB3cvrbW6aHnPofJ5y8DJu4NhfCZBPRqMvdC0t0ak5+m7iewHxOQGkl0Pg2MkPoszXlemTPYmeV1zntnLOfWzzoscD09sD9vS8sv084WbTOaLA6z5tjLSGOqgO5hrGl+/N3huTjz5X0ytc1eYQ10kUDvdfLMQHnfjshRN4whD2ng4ezKNjhz4jUKsObldJ0PWGnS2yYA9V8509ZlW4ZZO3jMq64284D2vTij6/m1q/X4jwbMtiMRjufhKfE8fsC/eP3/17DPh6luomWIxmjp9zJRZ6naQM/7Fr58+Yq//fWv+PHtO758vOF6LbyuF15orIvR3XUBGRdWLmUxLrzeX3h7e8e3b9/x5dsvePv6gff3d6xXquHbUlSIwI+1eSnga+NysQi1D0BbukGW9zISkL0QvVGKGLyaA7+DkdJVZ4RCpExm8RsdG3eLcy7Q5PQcwK7WncUeIZuN+0hjIQ2pkNMpehZ78jrVXHxrA+hLvyxEbyykIq6HMU7H58KNG1Q8CYFLdrCGDpOrgGvNdkdt0kzQ3CQutKbx8rw31t3YV6DxAmVfqUqUOX30BGyZndpg9IbULFJpWs6BVzENpvnNBNUsZE8sUaJqJWk6Bv29EH1rjaVSv9w1rKs4Gy4vIDfXCdcFuacv6Ls0H0h11HaUm7PNbBlyjHgIfAICtvoM0vdxSbLUCc1Ci1azk05WIFDpxoqtiGlq3MyhaSwB6FKadmWh+541vrGmFil1gJbqSFwfsnEjUVR16mLflyxEUz7Za6rzBewLqFL0UBF3KBPAuwMTtaXsk413yienneBeFB1BoCls3BSxmsM6DPKJCKuL4+sggXJSfalbVCl72Fwj5LQDLlwzIHTdRWOh+5NrMMSNiIQ5uT54ph4FXptuqiXwFi2VKYWhEbgiUONR0x0KG/18PFebNmFRA1UY9dZ9WUzhz9c/etEu9tjIocI836GAimHtRMTnxNQ5BpxD1AAjMM3r4nYtkH5h9NGlzOpYWmVOAVM4p08ZNzKcSz2QvgVgdGaWmkOG3x8Cujpb7bhs1iGwWDcHVDAD3ROZZO0ZJgIv3K0ghR/cN677q41dhm1C3IsKSals8nwylPkD5su55/i5QLNLuM4LACdrBMz5aLQU4Si/GuP61bodxAS44TkPwKRaKVFPMIiMBZ5xO8S/91oIZaNb9VyzrjTNUbBKD/d9zH2mnpuo2WvPa63HaaHt0VzGefYYXCrb3M3MgShQthnjZPjaw5PRupdzYJuHoG21GtEM03yPZ9xA+mTqGIQUgvMasYci/hyb0z2xbdGGChOcQLS+w3a9x80/Ntaeon7ojKBp4RbNAAIhCXyKEvmSXm+hTJbXwXlwr9HhZc3rOESeVUtLG/PlI5vgQWwFUd3rgyu9qTQanh+fMycAAM2PfSPAAYKHs4qTyWrPhTJGB1vrfuL8OR5VCdNMt0Zd3AtaFK1xnHAmksH2gGtOAQVQ7Tw5WOOb+ANexL/laIQ3sr360EUfkzhOhZ8rnl9wFnxE4np/w1/+8hf8+ssPfHx5w7VeeLnwWyA218IKFn1f18K6XljvH/jy7QMfX7/ix7cfeP/6jd2+hyq1VE+jrIUO/fZG9oDN3YCqCdGsANIa6VTn8Li1IIqqTuG6BBB4AaBqFcVPuVIVLVdUWDkGIIEr2AhpFfC51CiMvB0ePKVurRC/v0NAEKf5lyKvC4uGsW/ItwJAJ6gykcEiWhYmL0XRuGV2AhFrAHuHYqm9WNdQDSQ5+7vZ2I02lE7RFnmL9RyFSh54tVzULWpQFGoR3MXDuTF3lRHqCxULgVsZA6l9QFzMNrAEOfnYBF/t7u2a017MECDVfA8ASDequrQhaaCzb0nbgnUbGpNsZpp2uBERDzSfbVzKVCO7UHAxPWTkECx8TuVzY7GvRAiEBuQsoZDb0Edn9goWYqGBunDlDaBQkVjFJoy+zEYodf4J6P5ZE0FBg/CcNJ20HYUqZhFtlFh7FooeXqgs9jKJS6obG9iJ1AESqxnBLz1D0aEyr5x1KouF61XcVtmS/OUcMtvcQLDw2Yc2pWLt8DJz4f4Y0YHcPExKoRXGrhqZOWc81Ug27pl7XrMbyOVoKr+7Y2EvGeb+RMQLwFZxLr8/VUTJBMbjdApzbkWdHEeTdDNeunSYhw6lVmZPzlKC2RaQj44AciX2ZFeZaYxdjEr++fqHr4aDBP3434PyIhxAEJKP9/HT8TiLiWGfwQRhx634tyUt4TlvuMeKi0jH0bFD0hgBBp/NkAOJMuVVdrT3vDECbKziSKeSi00BRr6nW0EQOfDLketZ/Q+KSZzodRtcGuirc/mWQ2MI1HoPHDEVADI9ymcCtyaDOM0xiMnqx4C79pv15VZAMqO9Iyar1K1eQRB4NuyaYBTUr8jOjecF00mbmRSvhp7O5ZANMF0azeBXRVC1ypQXhYOMe9AHkD+HNB2aH6dCjloIeP60XjFCEg42lFFn8P5iAbiBUs+KicQHRK2NCZ5B9wcXLWOGF/iMqXEpnLMmPE8RUsc6in1TjmtasrP+yQfOekByX2+16E7FsLfXicYY0Ni2xkaDat97o4/DmwbOVGOaNf5Y0M5QZ2PopbMOIbEYnR3VfWTZd4/zNvtg2Ub0BMMFxTEHPtr+0zhL2G4GcPyWLcGaEQFQAPeRfuR86ivKRRehxoaFUyPW5yMhQRp5fXCG0wyKyWI+rmG5a691r1e+N/V+fyjkXcn2pKiUdZwQmjNKyrg+rCdI8c9f/15Gw56y0zVjDX0wOm18NuKJXjwHGni7Xvjl11/x69/+ivcvX3C9PnCthbVSaTAWe691sXfGuvD29ob18Y6vH9/x48dXfHz9io+Pb1ivF9ZrseN3XzQwpvtEonoDsdC7VLwDURm0KFBAKwsSQDVVZ2KfLtBdYAEZ6hSwtjSTQylAFQRdQS9W+QGslvynImj9u7EgWL2wo/FKZVPUh+W4R1KvQqu2IBmRKaA6sFkBRzAUOTQvl/iFaCaIgv3UcF+E1dyACawu1S/EcdQ6cGkGixid312KXIcMYwG9E24ABz1pC7hlQUpRVN1ZEdhRiOTGiWK+4zQn44EX3uFeZ6FIdrOzdNfi8+v5WCh/dmtvZ20CqWL2aACSio1KRaOd4z5UATul3IOP9R6OzoviEqHidToUjSI9UgdnYY0hdbNCeNekMzKnp0lEI/ZRrsg4hq6h7tvBffbW6gobKhqTsX2FZfdqDj4k6Ez0M1JKBDABsihsitHLMVS/mVSTSyyu5d50uJwJcTd2LKAl6JpJByNafFP2gWEvlx6Fluo9UdknP5gZxZhvjgDBv7KE7caVNFBy4Gi4u+hMpO1Ux8/PvTdVgrBYOBygjGKbGsYdhHWASitMGs2sVPXi3i4em1Sr0smXOtBq6/4X6lIEMgVi1D2+FxBy3rddFTk3HP4/ZtD/J768bhGOTMYBMzp6SCE4J5X378hxzue4VhYapZqfGp3/c00m7Ai0HDwxB8uOzvNsxF2kPqTu0QBaEedCK4jQOJqfApV+zkXbz7UNpJ3PxZrAuwlWrsZEwAevhJykgKQpIa2HgAH1BoHYalApT59LiaM4uxwzGA5O6fGbxafV6nCvwm3fjAHYOEoA6UO6SanTgtPZE2y7Be6RpNF4SBvN8UOYtcL/m4fvz40t4X0sgyntd/Q19Lks0NEP9+nGZIRM4Z1eFb/bkq6l4/2cG3qc9kKxPWsI+/y8ASl24QBqQPLK/jAoQqMzuCPPGnkkhLjy4jiWee5pVMv06wVirkhOYsuesi+b94dcTTlUOQ/A63KKAygqOUZa9ax9EdQF7LKtfA6Kn4Vj4zEO5Mgm9z442x+OAGnh1aIEa15bjmu4+kU239jBakoedzs2dW4ntIzGfsRM3uPG7YQe2hIdWzxaz3vxAVL/gIMc1fHozRTzFsOMQz+UHShFF7IRqynDq14fJ8HmsMDDrTQbxnvYD7keE9CJ8bgAoMVq0AAUQnR4kLGQZJf80QDYv1cMDi4mR+8Yc3NkKJ5rxmZISQwDRP4914Xvv/zA3/7zL/j69Qve3t/xeqWa8S1mNVYiroXMhdd64f3tDa+Pd3x8+47vX7/jl28feH18wXq9I5dkOzuQFyE5KTmiDQVbx7FfAZWZIgh8SUsibKcoxQ005TMDe+gvyFIKc5F+kjVFuzZgvdh8L1VM9wqg43NkbqnGxOhTF4thw7s0PlGRuIv5j7gaXQudC6skixtcG9vR/tAR0Uq6dgAr+WxNZ6Fy40qM0YLWljMk/Geil6JCcppQjipDNQekT5HzftOrlRtzNxD7UjHzZo3FDlRsySOm1MNcSKnoUW8q6iDV34HXZ3qfxeRISu1GW/azsHrJGVmoXuglxzAYh07VnNzNzy7tQh++jIyDjfIgStEmfc0KEXpadC9KxoaKljuxV+lAvrEWO4RfzQNhS1N72ch0IOM6h4uiM7OWkiplHBeCbcJSFk03gFhbY0RVtN1Uk4oM1LbLqaJ5JDr595QTvVM7oVnns/vnxn/0EUXt4U5hjxc0pv2qFFq4jiVPK13LRqtWSPpavaefQYUGo1oZEs8hHcGKRuOirKzoWCsYIKs4Baq9SWlj9q9H7nibKiXaktmvnXwa10NBAJ571c92w43D+qJtyybDl8pnRwY3m7mLqvtx3nAOYjMjEQvTMXwyN3MgHUeR0buAa6oSLTBFhzUllRjVdFAeKe4/X//NK3oA1gH5BAtU+DPgNFIJgTVTFDQBXKr4BCheEDo/dMjT0QXQMRFe87BtK8fB8dkBKDPhSxuk96EoSAAkogD1iDGgFtQSG8mRYa2sNN7jWQeEa02FEWNuoXdhqwPaI9mCVGaZtXG6Fga3sHGeH8rtqAFYvSoMni3VBILEVn8G4tQeXDq4CxjFoJ6rzjQcsLxBhRvoeRpolKLlHAA/L4EVWQEOsrnZgykftFdeM0H2QSzE2uh7nzsoBjXqcV/hgxcH9DIj8DME5U3uWXcznqkJbaksLlFqIpxoV0BXh73fDqdAhcH0VZh1YqKQnQk9t7yYqKDUOUrJb77v6oUhMu0mO8LBw/DD8HsyfG8O5uRB5GKOsPjbmEbjsyyk4fWkczCcVVFWHHb1W6Iuialz8eA+XhGNFm2BM3T2qF+myKaCth10TtEgI7seIBwxdpY+1nkv97tHytmAAFUIb2EUfjZFcyoFfcdpiIY94iqMgAXXVf+UZWF2hUwRRuAI1bn96CzS+dB+kChPjxG0U6I1URAmVmNk70c5k92JmHMRUswrZfvMluD9W1DGdRvDDv4nr3+rjwaJGYAVKc72sZmQcbdRPNsLUGT6db3w48c3/OWv/4Fv337g7e1d2YiFK1+qxQhc7NSHt+uFL29f8OXLB9a3r/j+9Rd8+fiKty/veH1cAJKSayowz6DD8AkaYfLBL61mghg0GIns/Xg2gRdNtI2nVQ9MN3LDEj7ZQkstp0MdouUekzyhdOOmBSF73baG1kfOLC6wq7YzkZYxzKIHuZWJYTdi3lN1YgVZ41Y/6mZDthUE7rVDKeSNEm0gEChJ85LrpLlVfj9Vs0GgtgiKuxTRSvUKFP2LXyIjynvuDtzY2mBqb9eYzssLgcwY9a22s5aMPNwS3X6FNpBS0BVBRa3wNQMdm5EByMu/OWglIO3aiUQB1bgXlS+WCsGZLqaHbrWugCg7ADLcf7rQCVKgtuZ2CYyKfM0lxhPR+acxYjLAoZCFbUGGjICdRYH6BDnQVEWjUU+FuUmno+O6F73lWMDiACsjEEBuZTRi1tvCjWhGsDb2AH5AtT65RDxjFiazUAXWf2yujWo6wT5nSgIIpT4dQhYACixvByaFFFSeopFmVgrJQ5LBPB6y3j9WduIXKcuwgveKPaIE6GRnexnzjETlQqoLcgYL1RtA3AZbL4KS5r4KMOPJFLZqtyI5ZgCdki6tV9ERUQwYLK7ZzhYFA7DqjZJD03jSNTWxtNoEHGolZR6xT4QWQEVh/ZnR+G9fQQOGxznOs3Ep6m8KgYYwLIMrYDdgrIFKSUTX1prQq2nLw1kqUR6qmsGrFJU2f7oxGB/aEfJ1EODnsJhhICLDULa24O3xiwgAdNAXtI4zxiHIZvaWwbMD0KRnhd6iajirX6xB5DnUAhJ6XINER2dDJ7yfMefrzxhFqOWQgPgMrwJW9cClsndoOhq3pUrb1BYcJAZ9CIGQAAdGzjd0nZPViOD+VTIYQxOSrOisA385OSAEdSo6cCA6wKh5a95NPXHQiuOOkWnlvcaDgqNMjg8CAD/VtejeeE2ei3OfARVJ00YUNBeKaCdCpWoGmD3UaT9WyAkJ9Dg5LXu9orH20z0BA4wLPxcem3YzzoMH0N/Hez9epZ5MjkVGS+pc3+U9Jz+oGmqiLIAegbpx1nk4uxzCF8cRZWBUa8PPO3hUf2YAV2Dtxo19mmn2CQwEgF4MGtRNbNMXmRpxn8dueYM9LIsWhvlpSFChhq1wNhwMLuVT4fJ8byQDoP79Ty/tVVM0iUeX9hR/Vqn6V2UBsaHMuj4jpyLq1PsNg6G93+UE4WROEwzW0WbZKHhOjnP8r17/ZsO+xz/aEbqem3DGwmYmdIgiyAO81oVffvyCv/3H3/Djl+/4+HjH9X7huhauvKguFewSGuvC9XrD+/sbPr684/3LV3z95Qc+vnzBentHXi9G7pPc8t1KDb5M7wmmACNGmjU6J+pUtdG5xzGwc9G9yEPHRaEQReFrv5Qy4tPFDp1mQKUkZsuqRASsLO5Ua6C+JTl2IgWZS7Vjgd/AIu4ruD12KELfLHa9QioLUpUOXGfRg1z8gBvs0fKlFsQ9qc5A9Y07FlksmxQkQsqSs6KIhuhjewrYAYSKjzdwhWkopBmsxowxxFOkIg8X8GcH8kpK3jbXD88OnkCRiyC2gN4GcqSUoNxskBtii5qVIJXnKrCOZAcSN6I5Sgn9LlpZCR5OPqgukK7g7rMlTn3BkQsePKVIOUK0Oa2DBjNHiYV70XoyIm4uqjZqnIxTJr952zA2EA+r3trUy85tA1Pc2IVIKnFVMWu3NCixwbz0crakKX+HEIfVlkORjgZW2ImkUd4h2l8wfW480eqbwq6+lHReE54KdG+UesWwRodp4XVCjDSOMkg8k9QUEoHAjTu5yqJLtL2cA3khRGdouBYkgg0sM+sYcQCdoi41i+UZeVFlUnBdIoEMCgZMHU4NuoEPy4iN2EtzJwAieTb2ySHIDJ3oHXSKLgDYyrL0oWDs3NJevwbk3c26rgUHZ7RumNpCKirW/3bu+X/Oy3KQRmeMiJ5gEUSTnfd4oKe50oHL2SzE5xKQmpn2h0F9hLN3+lTmObxF2YUx8mD3QUFzDwxQaL2BscZQ1hgPEY+fTt80EE9E5gCeAG0iZcZjggvO1vDIduRSNl0ZYkOy3x/ygzO9b3zzj3E2Qm2cfk4/fYupnNGTDAk5QvadLbKBkTA9lwqnPw5cY9bZo2oT44O9oTTWyQBBEXgCaX5xVE6jXl5oE9mGa+kwkWiCUNCeDpjG+Kp4DI1AxKwpn9HjtfAAe2Q2aK9DGdHT7hoDEqE1l8mZcs0NwxgDuT06sPMSzbF1VjgUPIuRUH2My2POKfHtb6p5NMBZKa9KPtfgPNXQ0eTx+TqhYOGswvN9dkR85VlLdhMabs9tv1kxhXEq6Fz6l3HWcQAufAvT0Irn52SlZLNJB0ud6T17zNK8ggvz7PMEj2wh5OyZVujmerQXnOOce4wB9ablmaF2AL9W5ni1fmjAtsfrPme8HqH9GDPEnw/w1aJ4BERMn1TBJQUoClovMcv2OBt6Djk9/Qe6yf5b8rbHYCti6gEfAxrnj/F+5WTkwvdv3/HXv/4NP379Cz4+PrBeb3hl4MoXsxgLeLsW1hXI1wsf7+/49v4Vb99/4MvX7/j67Suu93dc+YZci5KgwQjiLiByicssnnwkrqSj0DeA2OSOdrCTstLfEYm+a8C4ZTepJkDwEzZ0mxss3PQkqRw1hkfpLmYD6HD0UmYAhRdCPRQwi2epTwaB1kYHpTs31CG1C6uY/kMW+tYBkiU4LBArz38DuDsdvwW6RzotFAnnDn/B8rK7A62SABdjT2S8RUfqxK2UmzMW1YsZDhV7YxVibzpRkcrANIvL7fom8Nkyilo6VQ1LpdKBIHWkBF5hQNhKw0LNs9C4ZNjYtT2nKLjDDseeCANTjWrVKAu7Y+nsSI3flqMjgwPAEuSZgVektJoEYpBSClOaU3MPSC2lmX0CBKLT4IBGAH0j+sJTE5sdtxmBJKA16F7AHN6JFU03ugN4peSMddauRVlYcN3ElopGNqJI0zqZMxvAYP2A6E+NC9m3svCFetAJS8Y4IungISe6dWmiCzdcrwTxqUMF4FXNrEpdjzE+1Cwrs0VuxF0CBhqLMN3sgK6t05Vmx0DIoORCBmljpJYxQ1WleZIELcIpawKaXAXshZ1bs3XpMNRh3QuvoFxtR+KqGxsLaoiDjk0Ov2iWxkHUobc0sKiepeMigVWUd+Yh9ThL/3z9l5fhi1VbbFvdROxo8E+Mkz+Xk+Hz09z7wVId404YjIcOXJ/73DyiukSfc/G/IFC7Ez/fuaOkWrU8OWILgPnauo5iQEgGdgaW+5xtTO8deG/Eua7tDtr5YDyAHeYMe96rx+qki35eiyZZMYOa6hHQzCQM9me21wpFAVikS+BO4/KQMPLIRZJmGAY+8/vAyHYKsdpfJB0tBhzlYzygE+bciYCggN8ZFP7e4x0RtMVTZ4cJGJYWjYMd8Lj/Dh8aAB5k37qvx2jPXB7472MylsgRzTGtOT91T30cNa/zcYY00Q6CuanjOGrCCf63sxHPtf/z/fQ8Rzw//1w9emiyDvUbXcMLziE9f3/JAS1nPpb2rMfQf4p6NPfrQDE0/6EspqlB+0TpPbZubwKNiY9R6H4TfTrc4zm2Wm/z1vh5jGVLFgJHEIEAP+2AzmBqHuv8+6dJfFz5WSPqTCH0zFOf768ITK2rwsez9Nl1ICZr5yB7ecx8bdHyWqIKrc85E9U/jeE/f/2bDfvi8dChSM+xOj2D9IhsBBvEffnyDX/9j/+FX/7yC75+ecfb2xuu68LrSqwrsfLC67pwvRau1zvev7zh69sHvn3/gbcf3/D94xvy/QNvF+sWSAcSsA5Sp3IMkaPw0tJQGq6RWCkF49XTeTrQqEvxAYMIhDpnhxoHcUCX4/7JSCkLTksAyaALP58qyi50L+wieHScs5tN+myMt9pdlhwSjCqPYE4vVNxyAlodidV3tjBpRFRICj2RxRZiCC3qfSFWPiJ+CapicfPeAPqm2hTT0+Dh1xcVjKIGSEOdkrvCGJsOYF34DQJaNx0PS5tmYZyEaAk8dqGuQNTkSxl9U9Skd6Jyz5xzLSaibjlZjG4Dl6IUBfTGZ7CGgd3VqdTEjdMwRxriPWaqv8iciI5sjVlXNMAkJ90DClnmUTofzLXAeU1UbBqZAiBONo3MxcI17aUOSN1L3badjXLKtUWpCPJ/qwDgUAh8SKzFmgTiHxW1rvOsCAJ6Gn0aw+Xjq4DIVCaIamWyk4hbh7L29QbVyUwb+TRkSkxkbHUgtqNaCw16tJGB3RRcyFqimZCaljojtiO4S45+JfvPZCOaaxbLlAHe1wU2IOzmc3Cp7aO+EpK6nfWVJ0KGcxDQ7/AxewhlnYVoUjQ76aSj6Vyy0J/31gJStZhZIQ8eKgDlnr6ygV7YCXTsaSJXEkbAoqrW/n3Pgj9f87I74ODfAwMJtOUBF3JgLTk752poX7QzgqUaJ17BYGLkZ7W+TmYW3Ofdw4WeRcRDiteZ/aHMQgPT80DYrOOoKBn/8l5ZGzjRJD+vgHKggZ2SWzddRxhH+4PqTQyEpRwcZlcTPw3I/Mn/CI/MmCKNHWkDEYu1HNvS2KTMBLQHfNZs8IDZbvTKuUDxTBlXMAAVHyKpaU6QFDrhmvNXtg8P7EGvJlGX1Bx9jQAasjNXPRwMHAD6+I7oEL1WksaRUpBSfL7j2Avf70840VlKo/nme64Z2ANENU6Ghs+mtVwAtIvHERTgDP+L1O0na45Y/4GJtJZiZpRBJ36hqNFPmpQ2RhuIN0gN9W3ZiukesPrRBRizoDuouggrqgFwE8A1TJIQN8PUnYMnECfQFlqbR9XJWFPPIR9yspIG06C4QKx82HScjMHSuuvHdapJYUx9j/dV88kZTG7ZG2Xau5lVz/U8SXhvo8ebsxa8LE7KQHZD8+8O6q31GX67sF5AqlPQWuwTYIAcrZaN4XTwz3ysgXlveDzOstNiUAOfs7g6phXhrN9/9vrDjkbPfx1FnOmYiRkJOg3QCmYdvrx/wd/+4z/w619+wdevX/D+cWEl8LrYZOi6LrytC2/rhdfbC9eXd3z/+h3fv/+Ct2/f8fH+htfrhet1YeWFLUUDAmObzcLVhU80U9kdQG/Cg2AGw8bRDboibK/VME3pVrKpQocAHQMb4jD1BABajeq06NhRO4DcWkek2NREVRvW/6nH4tgB1U84Yrwk2NpYmRPRbB0UsFJO7GncZorObvUaCHN8L4FSwtFeqQ1PsIQ7tWpvxKUobcUYYa+vu9g0jsdKim/oSoSaAmhGfhIpRa6Sg2eFhZTqzlDQZj0F4ub3NxaVXhRdjpZMCs0m90/piJM+u1OQ5mNXb0o1rnu89lZKO9TMEI6mKeJezeLbNWHLkEqZDF+TFvQbgOzApYwHOUaur2FEOj0rSxkpaD3YYkUDfZ33pQyJaFpTa6A17r0HR/pbGZ/FGdnFLA07swf6Xog3oHYhNruD77hxAfhkuANToddL4GuPXaFtcbTf6zfPeCp/T7pGI2VKSKzie19Jx2WDEsvMmN1wczVAiidFfqk9gUgqxNXiUK2UAfTNiUJgVQ5l7NEhkK8M2jS4aquHEcwQp4Wu/xJQ+uTcKfUNSe02mAFJx5d3SzrbY7OwpVlus5uqweika/KJOPKoOhh0ChGsJIDN3+ZqCkJkYKV0vFoH+J+vf/g6B53WT9AOM0oXymL2ZKzQQG87FHC8BLKq2HLmy5mQMIVAxnA1uih7PNmv5vckQpQ53k++4FrkA0IDQ9vquxCvLZtj8HmezVKjloBuBHCLiuF1ZHkc1TQwqDYogd/TdkocDdKYhOh5U/VqFUDM8/J0fQQPEfM1DZCWgkQU99/EWuYheG3KWvNe6sJ0VMcWTTR4G67TAIC8aV4rKQM8oWeI0SAJ1pNJ0iC/SY2pleUNOoRXpupwbnTdEobBzB+HQs5T8cnRYG1IqGZHNXkl1oSBZ6UBf9nnkIOngCR65Ir1uEMFslPAs0xdJA4K5bjuJzUm/DWj1jULrO18qdZjAb1DcXg7MXy+1sPzDNb8M2ypI+exu2ZdzzcP4ITPQT9L2EfQzTVEltUaXkS7vQ8UV4wFC8zM9aV1HDUgv6Rn25fywTrT7aT7+gug41bG7VqEn3SGWehNFkakGGvjNGDsc68TZgrPg4/iOZYHyQEodL8YGJo+PZyDs3+E4xxEzhj7bmxtqu4EwTww3pPNQLrNRugsOfu9H5lHnzl9to8wbnhNG9sFMU4iKCyEJi7YDqbTLo6kv+fgX7z+eEbj8V1PQ2gdbF7SGyjwdr3w/QedhK9fvuPXv/4NX79+w9vbhXUlrki81oV1LVwJvF4Lb29v+PLlKz6+f8fXX3/g65fvuK4veP9YWPHCdRHMXXikw5uguCZHKFpTiJndz83JBbPlWVJSVH2m70LldviYA5lSuAELfldudCR6rD/kaRqYNnZzA68k8MEU8QRWBmrReN0A0EnaD9iZ+Vb0uJqLllG0BIK1CyEgHHlhbTsw9KQ3AitU0NaLvLlOZjnixWhp0whugJugGI2tSMSliLOlSDOQZXnC7dklqOqbCy5ChX06XCpwF8Fl+mBGHwO0GrlL9SdcNPd2LYlav0VgupmnDvwOdCRWNTpZTQI7HFGoLFQt7PsTXZtjUMXI/m7gujT3pFZlt9THaGTY0f3hKHIf8cAVeEQnbjBqFKKeMeMgw2zj0EWrFVsODnuJZFHy1RIlfB4KmZJHyzVktzWVu66waCzBbcc+ykQL2JFyxLgXchPy16LzlxFSdmk6MKmofBeVPkpKYqkxU0+KEG3EfOBdAFSkvJ1fnqZ5yhLViGQi0afQPR4qG2u8fZ1jJ127Wj0kkvVM0YG4mHnkM28dVVLBKdHnouHmQimnIpr1QJ+q1GQN0cPaZzJ7FgXgE5by66TEH2GXxmYckKasbwDom02/IiWlTcN/g2op0VyHIRqHM0t2utTTfhxK4BEcCM1VpYBZKVv35+ufvVroiIpow/x2jOIB1r1dQkECzDqmypALMk3HiZ8UWnALWMJJOIIAn0kpv7Ayjyb+oDEoNSig/Q7WpxnhGMQgzvntouhsSvwZ4aiH05Om4wBtP2k8yyOktW9wAWdsjoqhv5B/1fNLqnOonS6Y1ncy8EH74SwE933MnPi9aDIyJpJedeRGBZKhIygyVKsGFMmupJ/UGknX2D4fMNjjpwWhIB9dE2KHDQemQpH0YNGvKKl9Y/Z9B5sT2rGy18Qmrg+6VvEkTtkHB/eD/iTKBAAh4jBG7sHKCvIBfaugP42vHswRrY9UlB1N27vvguVP00G9JKV8pNpxllGIg2WAfmo9Gs8hPNmC42SExrIa2Lu9nHHiYY9v1Jp2ztwKXp5n/9Uqal7uK47S79SzyDHyvpCA2rnXWb4xjt5+/sJ78NJZCqA6p8P9vEVrx2M+e2rWk84/0JmBzipSY6lCiYypFQ5hoLTT1gbnnnzAtHEPYoyuPhQ846B3Baw05Zom3QmcQRsDJxYEk6BNhbMLR144gGcEy+r+xGE8Nw9wXtr6YlEoePNcK//s9W/UaJhrdtaS05d2ajyfiMB1vePb97/g17/9go+3d7x/fMX7xxte14XMZAO+laRLvb3hy8dXfPnyHd9++YovH7/i/csXvL1euN4uXBnSz+b1Ixu5KPm6516ATwOWAA/0ABA3eeyS7gpsrBUoXCjciNpge2guOkRjWfVBYHccl2Dx9sQ3O5Gh+K1Av4FD6IRrrjCsTWBXABvQbYLRqsAV8kc22CE8uEhDgDxMV4rCLvZj6MUte2OJGnCTf4/GdOuGTYQO0WhUlWonuLEjVfzW1PCPWshgd+lETjQCCHwuRcBCAK8WSrIkqah4A6jNSJ/2D2VqcQNgjYAbMtEaeIMEPhWpzgZ7dOi+t3YLN25JM1upypLsKAq1b9xbG+d25oSLMi9mD7D3pFBTi7eiUKXIfAEQZ767seQYIoKOIJQxALMcJyLASObqQDQP7kKIfqH+LCBdiVrzBueA62Gs8FBxq8j5Asp1BQtLzb1S2RgEz/alcOEqKmRtZZsYTSMY6WVpYgFjcP9clyI5OoYiC7lF6whK+NbDlLlnDNWaejIopIOB9xw3gbienQZJdTcmdTZEgwjuydrktOpQamguFD1J0AFwwWmgRlbcMn+qKgIqp+B0qegboMOjBuizvngzpC8GAp9grUfqdwT4C6gNipqd7GT2AvoeffHohbUarUxqxIUqZuMiSMGUCJJsqWiP3czSCBxmFO5pyhTouHD/6Wj8k5fA21LUeChPVsM7KNrNw+iUY+gIPk9bsHaFgyzQ9/Hgm0z+fCV/t8x10v0khC69XlKS0m08+KTHhFTyRIFq0XZuuJ3DAfjAubbsEgTAMb2XMB2iB+LrmisS7mTcFewam2APozAdhN85LAqpdA2os+S0xnFgrO6dCDEFxLXZFwMw8YC01YzeRzR7VIn2MY5KJfaKAfxh2a8rZtwRmPNuaB9CSz8VSjfAuijt3QrawgZpUVCQLWuiv6aqTje4oK05CksCyM1zdAmHMBijs2cR6JEZkKpN8amMwTSjjEZ1/fFpME/wWHcApWg175EL6+ZclhzbTlCYQM6xx10ug5ybn2nZrUAMA4WbR7YlwmCHcIH0VWgsz9052O9IugWXB6Qjz1rpHqBKm1/jFfTFLC8DV00cJv4SJcfPPJoqNB6TKXbeNhpIznOjLwLuRIja6xGW05UzM/zdDrERzjqZRw5flueff0bxEIzKmg5/xFIi0w15bVDi8b7WurWT7jVbYJ1xaTyT+KGbAVXX0nIetAdDYu9es4JhFB5o9cqpyfrTJgZ6yXkJ08aS+3mbraEx+oNOBvBv1WiE8aZej80CPApcCZTfroW3txc+Pr7i68cXvL0uvL0WXhlY1yXK1Avvrze8fXzg6/df8MuPH/j4+h2vjw+8vckpufJ4b1FYFw/k3DmNbGwcW1bKaaXOkLwr4Kg8gzNUHLqx0Lln4XakooqiB2kfLTcsw1Y2YSttdQAioY/PNHp91QLNoUIyy3u2KDUCtpTQDOBq9Kb3GyvQ2/Kxrad8MWrubI4sBwH3hY4bCxcuALcsIZViWcdwi5dPFkkysyBqEoPMoQhqUNHI6bEIRZ1jgFpUUDJUFVlVDcQtmTr2buhq1BYtJkDghZ5GahCQZPB+oyv5fQA+tx9bz6+ak4ayz5rXrksNezYy37CuppORxQhVBvriAcVI46kTyXasi5mj6kbFhhu57mysvck9hvp6bB/gKgbPwh3kmq4KIBmrlg2Em4J18sBiUWMNyDRmKGxsSbSSDrRIC4vTZ2Plb4TlDYGWklRwPwA3FPng7ty4kNiujAAWZTtvAfrd7N7doDGqsjOsLJkOgdR/F4Jz1QfKRUgOsCgf7ULvAp8hxcVqhYDZNb5BjXEe4glyKaaALXhIsMhtqSiU2Y0OF9U10Gp+mJsHSTPtDgTL0zvApn1cuKZbtaK4tltlOpcUEapbyScBxQVU6VpTN9XYTI0CzTwbyv6zpHbzHIQ0Y0QiQwvMA5IKzVqfBF5ylLYOkJ+KQ/98/fzyuV2H6tj9iKhuOwY+zvW7UNYN56AvBKKWaKC2vRj50t6wdrl+4AivoU/ogBcNRk6EA/j+S4GUQCYStVb8Oc01m/t5/RjYPS59uBHc/4GRda2E3W5jGaSjLu1bF0ByFiHst/T4NYxWM3hlvriSibScJecIWqNezwZgfOixR6YHxYBQZUbBoA0DUPgpK6Pfzr2hn5H4818+Rxst8jGF9lpAcjvrDJ5TCKCbTk4HkCUZcYPVjpP50s1Y7lPwlDKmAqwO1NN+tYR8NP8lBorbKjlzpHHvAMr9Vrx2Z8Xy+dvKQXpcBJkJSSKFYfwAfNaignVDOmwsBbwCk2M4QgoxjIHpMD9R97ON2nQ9CBhnILb2gD/GqRc1nNiBxyCDT7mgmpfnum7NCai6lzg2dOaf9nqX70efEavCoDpg6hKfne3MhGML4+h0Hh8eNUhXY645OgsOli/2B0aRcFZ8DHZ8Us+oLsYzuqVAisGtfPbQPnxmU2Y8ZAPMAnPdxZNVGwixQhj8ckNp74/j3IUChTEJFmdfPbODXVprMTHBYege+w+eS3+8RkMDN45Fj6ngAQoamcyFLx9f8Nf/+E/8+pdf8PF6x9t14f2VyOvCChZkr0h8vD7w7ftXfP3xAx/ffsH3rz/wentncfhaWBc9bFbwHy7+cppty2gpXZmiKTCaHqjNRmuMIKyReyWwdYoxEYvUq9zAipecU4LB2qmsBvsLHA9ai6gABLsi1255rTHFsICiqLupIoOehbvUY4LxT6o0ITdWGqATIqJvLaqXmh1gVJAYf9gClDZc3LzRl4ryPpnqdVTq5AfVTFC9BLInMtYhZakMrB1ALHTf2sSEarucWaC2U3SqlkPHSdsoAbsCqe64rKGgkpbroqgk5Ggasyu9RU+ConziZ37uxNUbWQkSwcy1dHSYR79C4ugu1BY9KIDalKm9IhTVI1BEKDWIwhUyFsU1dQOiVW3cxeyQqWwGiuw+DzpLAeQmj7pwa23QJSX9jTSNHY7kWeKWf99yeFcFmykGOeEE1gTJLNRmtCdhsAqlWkuNuKCIUJx0tKhWS1FD7+uAI5Cp/UGHqgWOM26kHKDfEoiSzPJ0EGUbkyitK6YJJS6d7LKhDAVsvIKOEBbrakqHQjQYzd3KckSwadddR92lRVMCMzXj0OAcXW06ZG+YgtBB2lQObavHuUC2KIMy6LADkqKXxaEsgHbC8rlIcD8UJbWd0aSzJirVCspKB20TjT2LyFdv1S6JCqqxD2y8jeX98/X7V4urFH3W8+mdccD1yXM4miyqYng9CTQRset3ukYbPDwcisbDXhmLGWoYqLYEGxysAbyqzkKVoXy+7KRKkGKc04gTZNZHjWlYRKZMnYER7GjovNb9No5TMEtL0dIYDw0H4fjsG5kZH0Darwee0I47E+ORcNYBwxw715379f3xDTEZb/3MnHdJ7NgGMO6taw8Afshj6B67Me8L0bx8H77Gz7Bp0CLMo/ewzPzC0d9Dtfnp48BxCB291kWdOZqhjpOB53M+5hkGpOcee56NNG8rHPK7HvA9CMYNYJ0xPgtQE4+GM1RUGPwZmE4N0OOzhtE993euOSmOx7vbGemA0wTzuZjAcZ914P9qTPo5J4OAZ8mcPhIQjVz7dYA/7CS09jt/Oc8xfVSEOaJlE1Lj1+ee5s8+N9lQgPMxFPbwPCmhvGnIAZe08ywqXaefNsHbLTzzZw5aWCW1BrPPrJDmn2fv9HwJulQ7qahBR4+ssaVt6/FoZ38/xuDnDfPfvv5t1amnsXVkgRdNRC58+/od//Gff8Nf/+Mv+Pb1CzMWb+z0zV4ZidfrDe/vL3z7+gu+fv+FjsbXb3h/f2FdL+SVSFwq5im8MfzEyS6qB/Rq1Cejf1fIFVOkmH0sACrtA5U8sNVnDQvKdEyclutiR+ATG5cWJY38wga9w0xFm8KpuEBnY+NGduEVjF6Rwt+4NDaf28Cbxn1L4WG6sZa8yiI72FGRFEQ7QPA33A1KxxbHhGoMMv5KK/4GgI5VY7uzaeypPzgVFEW+ViiyvTmPHcV69kxJogKAHLYi5ajUrT42xy0DUswh9SSCjeGqtGlFeQIWqgprAehCbR4SC0BtOja9VD8BRXixccdCNh2JDlKl6MjJmPQ6Z2InqQyaq9pApdOwOeN0a1mvTVC51QE3u3DLoO1KIG5UJqKSNKWgutIl81SWYwWfz3Z7dSEW74uRloKdKUfCJnrpiFLS+WXwQOQe5cOrS+n9xg4ZzGJmLGKpiPU3Kqs1QS87uutgkWONAFYpsZ00W9TvV/YJgVa5dGUCdcPF7q6FYlQ4R6o5OyjjjFuF+twr2Y/Gd9FAbeyEqCI1TkTLGaLxMnAATjCjFJxk+bwzMCEnyL/Zyflw2YrDVed4IlVOzDD6pCkJeEVX0xZdUrtQwIBZGxl2yPHYDJp0uJJGe6u3AhuqieoDEJByIjNJZdRujwUKQQTQmwfHws3ocf4OxPz5mhcZDTqb+kToflKQCaPbJ6R056CmzdB7J8r3WINeKxXA9K7QoipQ0CMDc8gbq7vA1TgDvAXegwI+shp4gnEoWHZ+dsA15Y/5jFv3afEOB2WUPJw1Z/BgcEzQ52vwPG0VxA94atqneHxLO5wq4OcgH3wtv3X5Bgx8eWX32Z6sEvpkDc6dDuaydQKM00TRmvFiFsoYm7lpzPwcQMbvUOhJOPiALoOnqSvpx910DHBsgevW+eJlVTNPJ4Lt4aBd5by1AKWfcmhyIFOjFtclAV97wenZH5ka2Sg/MxKIW5kWz0efJ3cWaWxQOLnWc6dRQ3aCa1QMwlvjTZzSs7eseFRac8+6gUTPHmiEbGdO9gTYFFXAyRAZDDveVbpZnwINqDb1gGn4c/OcGvc4e4CZgETtQA0NtYUHeb9HXXlc2/ke+w1cDz6zlaGeDd7n7GrvCz2VvKsW44MqpFaS1DWD6+M4bcd+BXCyarq2Fh7HR/f+8G+w25K+v1+RUA0vpt7CDki3WQrK7jaUmad9GJuor6QYU+Nfvf6Nhn2KLD6MwHinAPJa+Pb1G/73//5/8Le//oL3L1/x/v6O9+vC2+tCXgvX9cJaFz6+vOGX7z/w9fuv+Pj6K96+fOD944V1XYhQx+EoRF9AWjVJ8ncOd24pRYnCQuOi5a17WuoQ1EpVsWhfUd9roWsjsmW0g2n3hqhElCRt06YCWAKzU3yW6okRxSJSKA3eJZCgDRsylt3oZmFqVqOlVxfCv1d5Gin5aSpWt2gniuoHmhmebtytsQrSkaIhltieortW+quLGYnlQ/iclMw07C0OupwvqQx0SNozAp0bVRKhU0dvRsoUae5mc+6rCPD2xBbI87tKPFV9R8RE6oBGquZio3CB811tXrGNWTGb0i3wymtMcW+r63htqX7px2iY6MaakJos2EQCudJRKeAKUuAs/Uq5Y260rYgov6Owmu+ovIAo1qOo+/xaC0f+MJThWlQVy0LXNkeA9ykBgba8MKiGVQLpWZA8pY7SKvRqYCe2isZWgdmOpMMJrSeUXOwwhVC1DwJe2ByfVKq1VwA7dTCFou0yAqU1KlpAAri4aBmx0WEDR8h0ePKrEqchlmQ5RW24dTovOW0li79iY19cC2lDvlNFg2waWC356WYH8jGGRWIAAdbFfdUnqxFoavYjcLtIvxNeCTkgtnktRft203CHZH4rGrUSl52g5hpilJcqY9XJLIUBjse6FYAAkChyvddPEOHP1+9eNVSWeByqjwO7IXoFs1hT2KuaMNdHpDyUytLZmwN86LAbPmG4FhHMdu4KXGpctfqALb7JLg1fLsUmgBRdQmDRTpLtFJR1+1l6lTWC5vpP8LcDlrdxxmWit6tx8i4HeDR6DhqD8g7I6Sca/SmqPpk7Oy56Sp0lU2dR/q6eZEWo3mx777aaeoLnouckVB+T3coGaPUXwfYMQ4DZcVvBkM3UOWJrXo/wPs1IaDxC9va5Zmjjz5NpfDyYkUPHpy2Xs5EqkhVIDj17aSiIM3+XZXN2VDTJbqkb4sHleTg45TkWv8Uskxaizg01jgwFhTCOSVTMPQwq3TE2eNam6MZD55seNFpTOhtKczhu1dwPv9sOz1A+Nc5U1Iqh3Y2EvAKS0DxDc4twJpCzyVroOMDbay8mZwegJnkwNsAKWxvj6BhLrvZX6Vp5cC2amfaO00vNWYXwvjyLESLPcDzybNnZa8kQQAjMEzr12b6In9oajCyFapTbawxQtp+THDed/tR80QcPbMronYhHBPdv9gTgWufSEsURmpspQtd+H4EhjX1qDOqnVNY/fv1xRyNsXI6HaypSrgvff/zAf/7tP/DXv/0N37694/X2gWstXC+qS13XO96+vOH9/QMf3z7w/dtf8PX7D7x9+Ybr4nt6LWSq4FbXeDHkOe3cqTHOxcDgihvXtIyvHIwObGUgLqRKkXsWWOLWmMt7q9JmZKH4AgYY3nHRALVTUQuoT+zkYiC9hU4GF5EWbekQjEAo8gwXtGVN8fYC19/uRK3ARbIhEGzOZ88cjQHznzLe6UVQAO4bdWkTIFiI2gCKfSRYnMw+BMAmHSy3FrAOiZJEm/7blIASIEsCObQ6B5WoOpT2Q2Ei3Cga6ruBqBoq8Npb/F7WFvSkwWXkk3UMJGRdKjzXJu2m89ALpLLcqADeKpHrVsalz3iABdGmNxQAd+xsSHpXYL0UHbtEn+lmZoY1J0Dsm5myTNUC8ADtZAHVp+WPF1B1DhmfI1nqeq4wZsciX3gDl0A54AgEpqv2DUX6W5J/LTpNKNuwCa5bJwrXsjIiGdibUsMJOcvF+hm4EDI5PnQIEwg73zy0NxpdC5cM1O4CQrupT1PInT1HM3mddCg3IBDh/idvCHxCto0rtQtdrR4napZ5S7nN9RCxTpag4pHV25NNoGoY9x6bZYZ5DTBnvydG5ugdi/wbW2uGwhNRagSKklPh6F1Ph3OvmXDB3uL8RBWugTm6H61rnol0nLfWZuqAywj0Zgyuw3QGSU7/6Wj896+G5IsFNQo4Km7Ao5qTGUE5JJFSqGpgQKcBcho8GAAxFg6kiDr+H695NSQ/aglz3VocwGtbTWG/E6wywIpxMoVyHGnUlRJASsZob4KFSDI/+QwH2bhgeXWfpmd+Bkemo7VBMcEHiAYZQdEWPoQ/H0fIg3cMB9DGOTYm9PXMROsTkO0bJhvSubtEh5YqX/UlZ1zPYnxkpyN4T94SKTW81pCF7MaqOOpbspkpR3TjMQYIASsAKKz0vuN1rbzXI1dqyNkH0N7PMBVB2rbxh+2NgalCR+375YOsFtsCkgjvUtDVjuv57E9o3vNx6Ywbp9RhKEy/DbR8FabfNK+qd7VTiGB8V5kW+Bkbg/26xbfQrUzDUW0bOhKa8GANE4y3GBnk9y2t9atnL8+1tPcskWvVM2e+udR9zRgJXIi6xPnGfMZDFzNTx6Z62S6tZ6/h8Hj2zZ5MsWB6PqAA8Oy/4PO8NYv65+fCpuC6JLY50/bQquA5PzN3MvG8yRi5Xl5NPTC60BfVKLf2FDM0AVOVXbvl+UFzzVL8QJh2U1b+dpbS9rOYwfPKt0JePTJc/+r1b1Gn7OXREAUiEq/rhV/+8iv+9p//C7/++g1fP77g9Xrh7Xrhei283i681guvj3d8/fYN37//wPu3H5SxfXvDeqdBywxtNB7WGQt326umh9WpRefoN0QbKQGnaKyrRNPkRu8yj/sTFmm9ZPFTGZlJMSczGPcGom+8NsH1avVYSHLiGY1JRrTl0cZmn4lbEYdoc2WBS7vuRs/CuGcZG/gVQVM3fusXDYuLhtsLLsfbr97aNyV1HzkxpaY9UtXYcEE6Bcnv3XAjNW/mQuGumL1ezluqk3qKc0YHrnAHpMxFqtcNRxUdhef4VyiaQy1f3M31jL2BxUgg9iefrJvZkg1kXIoMcFcxgCOAvh3h+ETczGV9OpItx4G2QlkkehqKKiXis2dNuYNsgdmC1sbagJy0xG7gLVvGsxG7WPSmCGB3qyP1QkeibqDzBuloVCqqi+sQjlQpE+KCYrnKvN/pMyG9707pWku6dRfuaKw8zqEtVfTN7/L9dKPj7/iUcQhFqQxYatEZ3TbibN2FqMDGpoMZjdiif8lpzkg51UBloQ2as0EJw+Jpv1SgrSeMblxSmrqxsLDBtoILV9ApRSkjmXK+I8Xp5rO2T4ti5ow0x8AFz+We4EKl1F96I2KpSJ6ZpSjKLDOQKucz4iFqoUCKCuyjCRCtkzWHbyryo/EhPmAA4UogiiOym6mf7MBu2p2J4oLBFW9h7h8RefI483++/slr5kbrG+6VMqiXIFbAj9Lm3HUrcmQqW5aGcsxLtvzESjXrcwh3t6g4UhSahdOzbuw3cCLDuF5Urz1OpWLZhxYhoNp2BLTHCoV9/XwejzxoM+MQckIM0Jip1HP6UeoxNAAMI9iwk2CTzVVTIKl/9/4HGFIgwWUfA4a0PxmUVA+aRcrJCjlJppWE4TQB0w0KcLAP1gm+VD9yMxojN3rr1vHSBtfCjUp2x0WgtX1OaBzYlLfH/k0BbfWZVx+LiSmUHigvoMm1FwrsneXiyH3qO+oRiLI/wuLswG9Jmfg5jBJn/UkswsphT1qM1xVgp6lnmok05OhY89WMBTk9KKDvYN9ZzZlywD/NuNkBaJBOY2AqkYQRR9M2oMPwcA7aeOusX30CFFnh92erESxwsnbBCfVKKQdaux7UW61m+92+X13TmMLr8wD5A/qf0JlHo70U2QltI/Z90c+bODB+4xj4PbNPGyoHEKl/fiFDIW/ZQfbdCm9Y4AE4NNEwDocyhamWCVxjSzisN1grCu6/p4PTiwE5tJy0zcGwvPdzyCeDq8BrgZmX32tj/Hevf0t1ijMUWoSJ9/cP/PXXX/Af//m/8O3X75SxfXtRsvZaeF0vvL8+8PHlHV++fcX3b7/i2y+/4P3jA9e1sK5LRoR62csAd7FwejWtqdM53sCMtCauKuRWKVho/xQXGzn+lGTb27p/LWlXXs+GKYQs4g5cafDAg6pyA58LuAhHMgrdn7Q5zQm5QwU4DdUGQBGrRqrjnRfd0r0Czr4E9dbvplee8lIrcO+lhV9AsZlfhFNrPrf45aXi4mMUDRqZJbhRwL3RfaGg/hKKBHcX+mYPAEQo/Xar2H4PJaY6sEsyu1iijbXoTTUbn8oejMqEovDEhsVqYQBRdCqa/BRUBmXfxItnUe1GxaIyRuQcdNwlSlUHaUHUC+e9LUHHre7ZpEVpnmWkugqhhoND6QEdi1w8VN0Ze5s2k3JGdgo8BPpWX5BkLY6NfzqChUR9JoCbjk65OV2KdsYoK9d1yrEUj7TlvCI0xtz2iY3oQmxepapx6zDKvahKmEUQfs4IFAtmcIMR9l05ADbhgzMRQW2uQnJ+dqNWMau4rcZmSgSfYRWQu+VktIBH6PsoF4pQ5LlNk0pPJZ+1FS8W9bCX6AIuCM8TQS0A2YmSelmi5HQt7CTd0bS+gLKNi+Ncar7Fw0ARZGcem4drKAJO2WoCNWYl+O8I1R/1LXrb0r6uOa0aLZlGH2iS6JXNyRXo22MWEC/BeIYyjMy04+ej78/X719MuEmUoEGbYwrEDGgAtSYT3tZGF8iHaQlBQYBUAWg4s0RdZCjxNSDpGeXOB0oZMqbraxRO5K0YGhfRQC2dE1KVS353mY4BgbwugayDiCaz/8jkzKqVpGxkDADEgKsDmGKeQGD0dgDOrpu/szDUL3NSDcqT1xkvAKbGElyF1J4W5AQJsJHe4kh9K/vRuMRSoKSpAG/E477oYKXETExl7N8BcMcmaG44CKns98xiaF8Dh2ZkgO+Mk+e2H7jhsS/FaIK57ZBjdeRFn/SDjVU5n+5o1NIddArrwJN71luIglkg+O3xF/VcGh31Juntta/7jgap1qKAiaYWEVSoGoyH+eJQZisBBlCnV0oP1kECsYC9Q7S1420EgHVB8lPQrtDY+Q9hM3lxfIbapHRrvI/vpLNKn3V9UkBjkr533pedjEOR5Q6ae3fkXvPsALEmXWuZe9d5K/dtnvoiLZNdXD8FTHAS4dMAPA+hXmzh/RbotpIjg5iWV+lgQ9q+g71e0nscmBC5fSiNDalwDFQtOU92yJ9OlZ1XBiz5BV5bMc8M2Sjtl3zUfHqNnm/9b1//FnXKPmmuC9+/fcV//O1v+Ouvv+Lb9294//iC6+0dr1fi/Vp4XW+43l/4+uUXfPvxDV+//8DXj+94vb/h7boYMYmFa+LyWhABXGBnXTfioyIUN08HbdtyXqwbdyR2k0d9Oc1rj39rseYC1LMCIC89NnWnlxdeCiRJYtbymJkGl61GQ4xyUPGHC3PHxeLfqlmAoc1l+TFL4n6WJXObjdTagJ8Bi07ruAvwik6RomkwUpPIupn9aUbP76Jhz1gjNRfBKDwbCsnYhyKsKxDbwF5yrV3oreLmTtytqM1ImlL15FbRb6U0yUFe5K3C9k8Z/t0blXvqYIbyRd8JtoKxeO8cD0b7S07aLqDWRtWWQ2dDlczUtPqmrMLCxl1sgOXu41WbjRILbJoYBBWWob0jzuDniUpVbji/vdt9Nxo3NrJoMpjN0MEih6p7DegoUczaBi1qnMlSFIYd5GUfUyFMOXddjPlfA5BFS9o8pG7HHyJJ3bAC1A38lpbZPOCoRQfb6hVjKbwVW1xRZu5ivwiKUUDeMkwbFgNP0LmMcq+Cps52JLMhlVRYiqDqGajg05u1D+n7VNiV96fcToORx2Lxf2lIuP5Zs/XZDk4NSxyUjl5y3tmjxvuoMpGbksWp+Zb5ILxaF4DCq0gjY8O1GOBJNmMqAksaJa/7QuUnmIGoAVxZiW3lIwj0gk456fLKuKYdYGi8CarYUFEHYZeaJP75+kev6SQdtlWgopdU1xzFHQARAgGPM43Ahgc4RT/83ZjviMCsReBxsAsoEePrHgQALSbjUL+Lq5nwIKAgagllZXSItz9SBwTF/HEoKnEyfWwhoIxm/jw2j4DpGTdo7cPgeqD24OEWSDJ9zxkLf0NLeAWIibKH0H5b5AT6u1yZUDB35kHn/yjdEs/IX9cdhuUpwtOFCmaTL2U73JxX+HluNPQ9BuWBHrlZX0xtApBgAOixLFj24qJbbcMOYYziGTuUlhi/QHNlJ0NAVevPfm8X6w46OZcMStAZQ/tjms/diC1pb8ukamIrjn8w9+gAB4EAA5mhgfXzaN3N8/pLnpH/ySCIAUKY8Fg9HNgQS6BmgHCctdJ6GlvX6KXtqLXpbKNXYMwE6KUFHHZece7BDVXnfWZWmM5lVshP2cnz3HZOjcPmLRUYemPrPNA+ZoahZ5yMX+dWPdSy41185qEzaaKCi3nuxSFKPxFrbRmkTr/f9m72tLM5coXijB8zSrqhaGYxlEwvMKAqdDi9flyPSOwi5k4ApTo0mYNz9v6L1x92NJxSWtcLv/76C/7X//rf+PHLd3z9+IL3jxfeXm94iS718fbCl7cv+Pj2BW9f/4qv377hy/dveHu9sNZCrMCL+T9kupA65CQcz28B5FkCwIsz1kk+eO/NDZf8/RUg5GjJSqZ5o3rPHNQJhSIRgFwa7i+qh27gM2lYkuBudyN7jyWRzTogJwr3/pyoMg+CxnUfKk52U+2mGujEJ+rBJwd2bO9ERl9FnYjY7K0RkEBmsXNpcvWxl8PnqPZUA90EwjZ6LQciOtHgdWo3avNZstmV+DawbBZbF37DroSpup8ALmxlIaiO1ZXsTSGguiMZ2VaR/TY/K5gRSRmjnG5rm05CNy5sFEj5CVEbsgo7ioX4dbPzusBpUO8LmQzb7E153YzmWiqtldpoSc3uXkBuxG7NC8eyQk5eN15FZ+6+gUuZBhdzlgxxa5Myiq40UmxG2Vv83FCvEpkCF3Ve3UjcivBdBPtNmeKqljqYM26Uv61iL4wKFTvPkcl1eO0GtuKNcQPYLO5Sg0RGNENOLYv9qF7DdW6A1qVnae4hrtuQ45ND8UGsnw4E0vTUlX3TIc5OSjWDY4F9K8uxsIPOYMlxphIcxyibakwpB68hECfefOTCu5pdVgB9QfMvwYeS86sobi4gepNGResqNMB/X55b1T+xqM7XahbaS2jCssbM5vjvCdx0lFcAn2BNVDrKJiBEMToBA2+qKMna0i44apbJKFID4zD/+frHL9NE3BiyAUXIDwAhCJbekLXghQocnRSKGUBPpNfKOJqU4qXDQ9zgFvqtJWyngNWAVGhGroUhNybQghA44ufK4GDQMsb+hBGtf+5sr54rgCl4j8e/H3h7HIJ+3Es8vhYqFp0B9kMqezuHJh6OvgHl83tgfCgqq3PI4/2E8Zv/g/Pxibny3LNUnO9czt0gNI+Nxs2A/5nd8N/sHHCPqXg48qBd9OO+Md9/Vk0/AC+Dd6bs2HlKYOpKJhvCT/JnytBSjYqfZbCPMvi+1khw6x4GisdxNGYUnqZCQ+w2eaaGRngeTreXx/QONnL87bGUZfNwahP0i+NGQhLeOFkhOUUaVYRR7uyjx8zIpj53lUbh8VwaB0uxomEJtz7DM3tmUP+sv6dToDfW+eM8KyQpTzw6alNdVBZN24Ia4C5+IwMbFaPu9NjGmhj9SSBxfvm7teqAx6iczc+e6+M5jh4P2QIHxn0Ts1ZIp27Pysxh4liGWdKYniNiJhDH9pmLf/H6447GuvB6e8Nf/vIr/vM//xM/fnzH28cH3l78+ev1ho/XC2/vb/jy8QVfvn3Hl+8/8Pb1Cz7eP/C2LqyXlDnCKSVSYt4QiGZUIcCmYJ3noLiaWvyK67OTdjJyk524s9Bifd+lpnieqZUEfduGoU0fRySoBgMCMBqfkIcHGX56s6VJUjNFTpOA/U4qE0RfAkr0Xu+AaC6Kmm9JYioN78KwgulUSaAXYMMzFyvqNZJzDfS+yTPdQDc7W0ctdHyqKMtgkrKgBK2MHVUFVX0U1smm9O1WEfrdG/c4JdwHV5nv/lic6FFt2ip23aCqVu2eKCD7TdDBWKUCcdA5bFAet/oAOHHHUCFVrQXs2kAVwrUHIDB3kzkUBWtZzN/4v7pH5HZZBFbTKWEUeYE8/8ZVjF5XALiZQbtl3O+VqGq83ISweb2sln9xqVtmcR0ExJlkRubOwCVajpsS3h24leeiKAE7rNPB2oi1EEUZ4J092akNR1xEumgCW9cC/KZ4eCpa754gCGXmpChCULNJV4tE3kDG0mGu/tppEWQ195PTXUHQZkoKuel7CsNIFcij+hWBxqX9HXAWiQCjdW/csxlcG9vKJA/QlyAwYO5NRfNgdGaiplhc8xedJUZlhHy2QEml1J8aVk/ZEXPAloCQD6DqRYW0INgsLGSTQlkIpDoW9wvYt+gyzT+XFdA6kQGsYoaP64UpccjOpLJVDAj8zo1M/GQH/nz9g5fBpf7eEFCeKN4BQw0MTz1DDR5pQpyT0suHqWiURiKi4Bj/tegZ9QRQYMADEWbKwNLoBLEpVbZgNkEneipKybUnsCA04WzKZDUAWDnHUs9h7mzH4JawEk0+wIuucZwGvjkAnEa46qXTx69gbWYITBPf2VXyuW5HY3pCpGzWM4pu+C6wMo0sH981ILYbqJIfwusHpCwVJz5t2dNWsCzyBBHN359Gvoihm/mqzmRPdsyOvuWxNcbQ322vxnXUODpbpoX5yCrgBCm1bpA41KpbkeMnKg0vQwE91ZjMd2i9Gx76szYXzihUiAKnrx9uPshKGJzams/qn9YZ/1YPp1A/V3ZqACmUEQwyH7h2jZZ9DhoMx6zHDu0X/Xv8KTwcoQCd7/Jafe7VmHGBY5H+bu8j5GQReDvHpkrLBng+xziSMQ5BqPcR2QZQjYado7Pv74gZI/8/VePbvrYdsI5HoUNjGg72GVs7AikHpT3fLbfgkcE7a0fCFA5AzNrtUzCuNenvztYCCGc0ehwWlYHPGvdz/Ws3499wNP76H3/D92/f8ePXX/D923d8/XjD2+sdr7eF1/sH3tYL718/8O3bN3z/8h1vX3/g/es7Pt4uXK8XIthLI1McPBl6pgyBDFNTAmFZzDJQohe8YqHvxEQyQtHHAiwCyrO6uNiRqF7y+kXO6h4AVeIbhj7HxcQoZlXLORVQqYVaG3cHsj+pd7zjpMgAUNUEaCh6iWJ9gXdnLHSd7tybuT0+r3o5VAale6MZJJHR47pkfwB62Ywek8PNFVklp6YDpRLgtRlR3np2tHpUFNDhHhs6RJuStdjq5xEbqxs3lLZuOkCUdd1Ux5Iz0BlDJbjbsZJNoKyUMVONoZRv4e9on0JABn4D+Ax50bw0j61rh89OIGooRNFbtDf2lUid+u38LsB6Exmy3cU6igjJABKYfyJZoFs8kHYG3Ewt9sJrBX5Tyqvk6HYFPqPRuIGmlCnBOefb9CiqKS0ddkQpdymKWqQk5CI44FQ3aqtAVBHOfhjWbluknoLpKmaFKglOskkZAhws0X2iKbkbolztwMsFfABlJ80flYH+jMArcpr82bJUbUrerhO1CVHyNrSeMsdIc77UCRxNdQ6kgrA14GrBWX2n9QsrFywpu4okvxsAKiflnZKbMRVposHNOh8sx/DAdQ4Z76UsVxVW08koOboT8U3JcGo9fiLh6FKJB5Li5TJLIjvQKaUwzgAlBS23C4Q735rKF6J1aZ6QPUpqVqb58/UPXkbUgNat0C3Y3yQsZbrjnKx3swFkH065D88wp06Bj85m8MuXKANHr2O+vWTjMsTN/+mwFicItmOKpBv0QSDqAe3obOqiinrvm7VME1uvpuNskCYidqhWkYIyAdx2CARYNXRk/DWlRoEDqvSVGVLL0e+mQ/rD2XIPkApgq26jhbYnmRNQRrdQ2YhLUesGFXE0rv7epocx/sbYdTlTEWAD0DLoGVcPrGlscm5X+pFFqZJICahtSfn3ojCZAVceDHgchhpHQZB9qHY8e5aoQzwHTp8uUIEuGLBsL5YWxkDK0WzU1k08X8qcUf9ezubQs2mjs2OcSM+iN4bB9QNS+4txCDraM+1s2SOjYOcAcoDv5/zH3KIhVqBk55Ulq57AN8oOgGWjtU9T9Z3gmokdJxj0yD7boebga81qDFjjgRH1RDwwnWRgZy/C9x7KprfGzx4OaxfjPs/HM0ufFKCIHUNvtQkaZhRoN/oShtsxo1+Q010a72fNCxz49rnJfV8KbvMW/dzaXIyi6hDXDdsxfWSeZlYbDNomnSmztjIBs8Wd8XEmLHrBNYzYyv5rvz6dt//u9Ycdjf/f//v/4v39De+vFz4+3tiI7/XC6+2F9+sN7x9f8eXbV/z45a/48vUb1vsXvL8Dr1yIayFXYkUg++J4ClGQulSnfqxZ3OVeBR6YJU45kkCmIarQ1sEMbsKKzR4D2uTW3+faJA3kBilJEWxjnynqRgOfksRFlhYDvbwu31ChYiE279vRRmL/mypXjel/8dmELI1C1I0LzLB0NO4WL04btE012ozIcH8psxPk1TMhtEcBh9H6reCdToEKoDY2NguDY5MTnlQyYrShGSUSOO0BUpubUg5e48ZtAyCPuJQ1wKaGgaPcdzdi32gErriwo7C39xHrYoDAysbdPfUojFil+MVg0XKDBxYSrcaMjsa76dwOUrwQTWWmbUMhWg4a6zMkM+heK9ws96KTewVQvVH3Gv37Xo5gJbI2ei9JPRL49qLjFFlALURSsLWjkFkILKXM9TwoIJcyIA3EJ9di88i65Pw2kipLrYJv2CnVHGVwfbcOkM1dfzs92hcuNDY2jb3XLABn+VxUTs1sZs2c0SsdQqwHadKfNMY8YB8RKPp0KGw6ITtwZcMd6Ndu9KJ6iv2+KYiMkEwnTyfGrHIM+BZZm8oxJDb9tgvXKtNbkRG41XMH2CzczVKdEg+P3QnkUgf0hc+0RHUjYyGzkVsh6gAQi2shaFGqGQBwQWdHTiPL7n7ICvd5vkhcgogVF5CfcD8MeKyLc3qBNoL4gnO4EYhYSATu2HAflXvE+/98/cOXwTEUTYVLluMAWUWQHUWWvyiZYSjju6BGPrCbbl+Q1wnp//cEP4ZhBIEWFWwLefIX1aLANjMgCmYNBB5H0g6uykaFQbqBJiMSEcoGh/egnQx+cjH14O0lGoceZAl9bECa8QQU6+HWtEGaeOhg9s7AQ+aGKm4tUF3M0rArMpkKyJwzfYBuFEGHAA3qRILB7Qr3fbKT0QCwcuaRXPU8TCuxFFpBjImufzbHk14fdqheUpggetHJ7EJce6LoJTAyBfnGG6VeK/oeF/ouhTCY/dl4Sg45WOH/z98CQ2/T7YwZ4uGm3xnIuZskvTlgrHUMhcifbzi48RA0gO/F12+/kyePUPpRQtRZ6ui65+8pM+T95PuVkxmuDVTgZmttE3QrUAwdIK3Pq09FZzoKB9dX8FLxGD/vJ8xY+o+wwMM6jxkR4xjNWvMjyIuu5rmPRZAfm8ItfekDcWiYCIgN8HDJ5Gw489Ag5plaWRyiWjSQauLs/YFNrMACPmfqgjW+j6xhe1PIoPGWGvveY4cSmKBvqKxynjk0u5fqaaWwltGq4+WzWtOZz5gj8az8jr4rHA35l68/7Gj8+PYdb9eFt2thvb1wXRfW68Lbxxd8fX/H1+8/8O3HD3z7/h3X2xfE64X17jtY41WXHihWYi0CNRddAovRGqe+QVCbFeiVAiEuTlm4ICWegECpmtGBRbo5A0hn4I7iNRTJL+V/C4VPyOgIHEa2Oisqva2FVjK+bv7HTzf2VtfyWXisIWCmQFSXAm5sFpSH0vi3nAFFMthDwg7pZuRZIP9uRd5QLMQVKG1FkbGlYqITdKPgngYuOt9b2YylwuvN7/uttYiKgNMN3KIoBdhVuNSy3k7Qb97z0Vi3UsjSqS98wi4hLSApcL+1N/2xMaxLDzkiG+wzAPGR4xFBgMPdiCVZyQ7RxDZKHbQbN9W2IrlGNJ5rcQ6uSFQlIhu/+WCqW45Cou5Dn9lgwztv/AJg1bK4BdRbz6ho9boKHf8HcSewLo5Abc7VItVug9SeSxO+FUVnZ2sWFl+g4fxN0bJRFeP5iXUt/B0EDQmg92/cSwV0btp+dV6/Asr+bTqGu+SPaoSa174TeFWPIUsEKm5G2LuV6dHaCebu0nVUsaTJHdiL2Qf3tOHTQXtQVKIGXkEaw66WE0bJWh8qG4WrNp06ORZigOGCwZ6yarYdlahc3B8h+edXqwdMoOOi09AbVkxj1CiksFKqQ4rhuKJBHfXknP2m9dlb0cROMN3YyOW9wOzedJwWrtxymCkmUOpFYnFhHSoKi13g+jbo/fP1X18R3vc9gQTacEGL/Xq8uVXYC54nELRvKU1dELVGgAByShZYpGZwmCfDMQ4NoOhmin5i8Qa9TzVDUxR7C3yh4d44Dgy4Rm2VIJZoELdwGOWc6SR1CLB1Y1WMDv9OOVeX78HBIm4+15EMeBHwSDsREqZgnwUwsgk5+tBYLCl/NmuSUvapn6CuEko+4CWbp3yOglSyX0vw2fSsPlDYTnrSX2cDxQxYIdr7Kzo4RgGKsSiVzqOe0VsH9oyTw41xNIYuBaH4ROJuCnJkHbrJBvCJwAtyLnV68exPqWwdB+HQdGaHi7mhoB1EXYF8gMcZaaEBQBnu4HPm47k7wAxdBbrWPC+KGZpug0jArk8PaAziDzEoKsKpVidyCDKdOTOint/3KIOGzjV+mhioUAweAaoR0feV3Ryt+/Dyl1PeWkVtZ0nZNS98P08E6WeAcCDn3IXf9vereJ5ajMAOLTqIa5YV2hhki8na6KzTHDBAyGco3Xs7EJpA3D3U/Jx9B/kooT5QxsbPdYFx7GwD3Pfl1lsaOHExBYg3wB5s0GJAn8TY4rkffb6gk05VOXAhW9nNoOzDDJ33606XzrO55bDl++evP+xofHl/x9vrwnW9kO8X3q83fP/yjq/ffuB6f8Pr/Ru+fPsF15c3ZFLeNjSwmQmXjsr1hQVHI28CtDx0HnuKqFQNAKMOhtkLMQsPAghXMC+SkbiLzswblK7IwmcVrGbEVFqPOxvqCbFhZSXIAADIpgRlc/QbVGXaWhA7StCekXl3eiUo4wFyd1M6LoBdgV1UYWIUXPy3Aq5NaUMsYFcBvWc/paKmv8GGgvKtazezM7e866YM7l0AwFb3n82FD1BlK3Zg75ZyDkk1u0GaV20VsyoTIUfkRuOzyN0X00ljR0C0k8eb6VsaZqUWtxxEGgk6nAZQuq8OdCyEunnz6wnMGcnisZArAWx0bWSvw6HUtbkZHEm5mc2Qc+MIX4eoUktFl9WjqlegLGqOoLYb2nBeVjTBeyz1dtm0yZLn3XmhbxY952r0XWDxM7MzUVTHah04HUDmYl1C2nniaX1HoDuQizKrfxf9wSnMuGWkM7CVIbvrwhtUTwMg+hNIyg6uZs3IFEJGIMSpaKgZY2OoT4HCXaRHVXOM2APyUHwI7nlCVAdKdJ+lw3pjKdPGfX0p4ODD8TdlALeA4gJpg8yVKfOAxLuyg5PSzWTvGhWgt7KlgdO9XQxDUpJgZ04NP9susI/RRsbN41dAJ25Fn1s9e9rKbNT3RwRqKdrTwWidMmw7HrLbAr/ZUuoCjX9n4HJB+0qms+UsldS8YnGg3v7MaPy3r4zUifJAZ1UEkGuhO1GbFBmk8v2LaHGcETmRcTWmqAs457+kq3kMCKwPeHg4GwbyCFG4+GfwRs93Oti0ir15BHhYMxHjzEzNULB+Khx2n7PdNIsYkCEIr7EIRn51LyW7/RMdZYkmYgoIv1UgV5fT0Ea7VkU2d8ZEgHjRLi1rp+jecunZQkAWAt8BFpbeOD1swtTY1ti36JlyuAz4AAKpObMxVCIg2IepDJHIccgHjaixT8K3z0RadMK374ALIDpV19wDmQAbsCqjClOS5l2RdWaW2XiOB2MvnhdulzMeg/8Ym+IM7E+u2zkDhDG6oDmU3ciQkAXtsVWF4OXJydEZrPW5+H7UgmVyXMeCZtA2JD3rhWHHIFYdJxzK9jSfva5NpLlznKOhhEUPpaw0D1Gg3H9u6uJKsewszoIFfYCA9Vsps9tnvMfd1TqabcufnXUe58bHCStR9XhjYRk0BUE7SS8fwRUvDmFeN9P0fLkxMJBQUxieQdvfz7XRt75HQYJ6TJmDTUdSl/OTwhKmfqX5jPWo8T3mStgaZomd9YST83JmI8LsHDlJc50pVsB0dP8nrz/saHy8X7iuN7y/v+Ht4wu+fPmOH7984Mu378hXYuUXvH35wLouXJG4wIihsys32N+AEmmhOgOZs4sqPddFw7DbFf6kLdwhEBmWfuQiZoEegWHJpf5NXuoVlKddXejNDArTX+o+Ws1UayUzkTDBSRr+Own2IeUhba4uKgNFEhhsbPK0Rf2oClF/Wl6zHJFP9iGIvsTAalTfLESsxq5CiQa/N+gEONoNb1wZd5i2ocMkqfcTuwUwG7s26gZBIho3uVaIlGqVaDNozg+Fraj0w+gHwfCnDF1g4zcfMpNG5GI1vxcgYHSEipnNApoc+x2mCBV+i0bWYsYpGDFiB+zGvS6k61iUhl5tcMm1kUFq2DRlVHYJGQNSuRlSLL0Qja1wBR3Y+vRpTWc4oci2IgkJplDvKOBiB+9PFKIXKjQrkVwLunxcW+NFeh1yMeIl7XIKZrm24MZvAeS1aDt1CEdsUQpUgSLDkg1G4BdB698FXq37QmPAbul32FnokRGunTwTs3EJaEz2TBK7AaWE5XR0bM5BNS7YPsZwnVFx1kRwH7UjNks2v5lGL/V2ae+0oLbcLdBAjJU/OdemAWQvLIGiuwV4Qt9dDmSIaxtF0YUmRatLQY+gEtdCY+eWJDbloHfz+UrZqcZiM0I9I0t7VDvVYPE2jAkbKPXtSHWUBzmDS/sgsSRnTGerOnCX5Hvh3gItXBJ4Ncf3s08B4Z+vf/xiECYOdgEm+ghwT+04dIZUVu280ZFdAra+W4UQPcGyuda823PCSLd54UYbjjxXc1+nQXzOlzjRO9HOSc4HVG/Fnw1FpuMoLTZBtW5baET3/wji6McQtpiAmUFYjEgCxmHhM7cU7jB+jakeCYz07UjYzliBmb96xs3P5yEFP+ABHjNO4zUBqLHMuqDHExHnOYyhFIZl8NFw6WdQHXb2FcTYOOMDiGKiz4QcsjOsMeupolVY/fAyISfJg+zLGoRrDmYVJefHIgKPG+Ef8fhTeH3AqBygBzwe8DzrVJknliE2x3bEdbTWHg5xzMKDHEYMg4N9svSZAe4OBGoHJESTK83PY2yalGAdx+Mw+bkMUu2wdjCYR1xw1vkAZL90z/Fc/9XaU3yQYwOOYfi9zK0D1j1jiNmLhKjH4R2vG2f/kNbMz7IWWJfS3/0RB9a07SeOQd+UjmnGOX8he+X4wUhW9xm7hhNm3MPhzR4KABbXMry3yk5EKCPW50ZARdDQWVc6z0n1ihOYlDPpoXVfu3/1+sOOxtev73itD3z5/h1fv33Hl68/8PH1K97fP/D2nsxi5MK1dOjb+/MKI4QWZSEkmXo0l+mAkCNYWlzso5FA8FBfBxURQCS/YXvRFrBSaj6iUlWRm3nVArMWTAVTjbTVuO43IBeUrZNRuLHAZml30zPcRpNe+CQJKoUl0AsgsEnV6qOmVOU6lL+rWSCf5Td389p85tyhpmbidYPROvfnuCFjYMnbJo87qnA7Rdzkqkc18BlU86pC41MpNsmzBR94mkK19MWbC3WDRqOqsJIyu7+pA1kqshRYyM0Gb0h2+46tot/Z1CrDjY1PH77ZiLpPRAmMNDJa8Dkg0pzdTxuZFPWhG7WYOsxeBJcF9FqKTt1TA/EKHywaMyROkkKZlJt+bF0AAJSeSURBVM3nJEU00aL3XKoMZFAnsEqc3Vxy/ujcZPL9XSV1GDrWcW3szHHGloqgW8ZtRXD8AiBFYVEZq6holJHYd6uTMQ+MvIFPp5zQWCAJkzK2ynptrnskU9n1lF+86VC5EZkBD52QLWAEoJVRLAYADC52Jzmmi4fPFq0D+4ARZv24D0tgJKW5H83oYhczIDRofB+NN9fNksJYYc9BcG/uMEfr0tmvze/a6GmaiQB74IhCFVPAFgDWFNkxRd8ULigVMkZiXYooLoCZzI1o9r9x7xVndnApQhnqf4FESIL3E2qfpIL0FQY0kk3tkPSuHJoL+JTUNbvIYhRZ/nz911cPdwQYgKP1AtGUDPoO6tNhfL4Epl6hfwZyISBxcNwDSFkGWZFh/mYqKiFszQLXJ9owUm7BtgdQFuIQaDXQ03lqwGuo0QOPuK5Ltjxy6DqTBTSsnWi07lENMeHrg+t4QrQCpQSvJ4pt/DWDKCrHFOx6gH2PIVjkiCxSQBTHsQuDqD7zINWcnlkRKNRYdp9YrMeCTkOgVQsWyt6b67+5ATGTJHv0jPo32thV32XnQNPvcZhnM3AznPQcnlwEe2JojPM5h5DdoZMKg2xFantAM89fA/+DXPm7yTyBa4wOmmxa95lTjYMiKLN1MP+s8yxmA2hKZ+3M6zHnXgfCXwT8a2zsAHn89JfZv5OFcErIS9D77VxR9+v1qbVXZy/OM4HjMxk0Zz8COkfOmFn1S485e3PeYSk1CUi4hULNnTUsOTzZfl1/7kVnpRv9DTTx3xfXt4V65B08AP3PgYZxCHD2+GTF0qMqZ6q9rx730uevMfuT4+BntIPj+ftpWMYQ/PevP+xofP/1V7y/f8f3H9/x8eUH1vWGfHvDeruoJrVeuKivgL1i5LDuLvQSLzKC0p/yNhMYzh3rAWQErPKRfOAscuWnAqICnyNPI9Ci7+gO/IbABzhoW57YZ2/vTxQKK+m1tbhpjLyWMiO08rv8d2AvMNovWhYjxa36Eqnm3A3EpyhTKoT1YdE1qiSfE/U/qlotlau7lT5DYW8hRzkT3VAxd+H/duDV5vzeCNy4BWaJCx2ZFm+8WCS8W0W3RYWg2I0OhZ53oZLUp2qSUgJb2ZXNwmssvND4rYpcWKgo2Qe3sh5W3bLCWAtMwtMWSkYH53NJgtGsBUamF3rzSN0Nqlyl1hIE+J2uXorWBCVYF9jkrFMc4oLk6hoLqSwRawQSLFy/unFn44qFDTam+4zfeJ+/LTU1D2BtxMXQ5KUHIkgW7WYtJIpnwm809ACj+vdiHUgmTyw2bWNGhgWUN6ODcrh38/Bg/XuyhqYBql+RwldLGa1KvOXCjsSrG5/XRu5Etpzy/mRmpADmrMzmtu2gShnKVDYeciYtjhhPUr63i0f2qqI8ctGgLR/gJcGbas7PlsoLaugOpJ8pa6ECWRttH7jRKYdERYsCYdtWr3qKYjfE5y31C4kAQq2+5BBpewGZ2FFTND/rVUY/kzTMrMTKm03zGmj1ydjgHqP6SaOv0N9jBBIqmAmj+E2QDpdAbtKm9qJd7C5mMSBBiOJzkMDwifUHjPn/1BebKz5+ELLpDTh6v3S6ZoCqQsq8QdQ9g8SOB81n96nnMMCU4wDgZDGkRscD2mKnrXpDoC+tEQN6MqGA6wlodMgrpBxbds6qKCFqngB+i3ISoM0lWE+VCR30QhU1B9rr0IqCjkmLepQLFDxwxHRBCofneQcVqULdfPdBHMVrl0GdwM9Ico40Es9t5zpK70nUSOHuHozOQFENnkRATS+7j1MmqDVFv63z2qAZRRqipXtbZFyDe4D1VnLm2lRfEI+0HKyQRCmfteWsLQGxBiST73MNWiL+kekwQEwDWDtiLgWqPCUIgwNDkrzKhphiFDQ3cKJsoKizwX7eSjVJ9c0YO3BTDB73Z7cz3Ob7xwQfEz6fTQEOHfAPcN/OcOcMQOd+2PbzfF7/jvQTcAvc8mEmCXh2ivCjMl0dYNNfibMMtnyAcsIDU424Vqw6Nl5Szy3R5XlsUF/fdG1mXOInadnuVqYe6sVmR0DL3mcFo3DT7TtPV+fj2LVqxaqRNwf9BGa1zxnVOoIX3ZOJ6TzP//AKMA0f7aQpfec4fp0LzJ7rCMnLez+fr/wjJ9MfdjR+/ev/g/e3L/j67Qvy9QXxClwrcS1mMnJdKC24l8S5d6mglW4EAKZtCqGfp+TzyBu5j94jDamKUlteFSkICTwAchkYNHE+Csilom1bSSL3ATTAzUls8vAW5CwUqRG9C9Y5bunl45ZKVDMLUsWILe49HO3YNyknwlnRhc9Qb4HdEyneaGyp8dDOFFiPkTQmLtyW4xRVAmACQ9jqYhrYm1mNatYtEPRigP/n3mOE7iZdixOxEVL8qQjctWk8cyNjAffGjSZVrJunXgdSjc9YLMnPosRh12akJjUNqSNvoSiO5xRQeg6iS0UClxyzZvNGBLNEqxtYwC3eOueRmRj33ijV86T6kPyGE5N058vSbn9hMZCTuru+gQgWxGfjLbfWK5XSqPzhGEMgNxA3S6IiExWLFFTo4N7MZrDPR6PiUq2BKHEISrZCJwRYYHUhyEWWgeqUbOuiekgHnUBasRu7FwqLUrPRWH1hF+lcf09QMlkZvVWMmkcC0xk9gMRWtJUH7t2MyARI9QIKvQopDnKrw3LgViavVSWByUjeYN1K3IXPWujFgkk272s5sHzq0EGbLdCX7Fx+Bwulr4k2xSiEhrIgGyB4g+0iHbQG0KF+PJXo3BB25zd1Ackif3Tgk/pPkom82TRRazXK2dYFXKSRee2lJJ1vtfwjtmKd0M8RbjrIS2v/ttJOcsyypMCGZMauGe1s5DzT/UcN9f/A163T95kNaCFVgouQzDWzZT70CbL5jxhQw++MTXDGfyhoI3upCT4ZByHylq0hDcL0BAC/9VEtDNGfXkCtnGJMLc2JRhKg61riLxn8AAw0LDlRI436SeegltcWtB9CNXiqYjGtSUCdoMngilTfvR1Z9pV1YxqkiASuYnAAHtATOPRZTWdLgH8BwNbaVuS+HqApkkFFnfk7exyKhjLoEbgaQ4kGUnu8lSAJBR01Bk+eSpoCcqgmQ7VKBueiesC76/pIf6P89SogljLtCl6FsqRMGBD7uDeKx5XmgPM4gVVdiCppzHqupr2eMTWO5whwhkqknQBiNZMpm2shC0dsIJ/Xa5cyzELrCDU7NYFLzlQz8CnPSs6pKdx83mxMZoZOVpzi+/B+0v1rzzRyEnljs7WHmejhDY4c72Mz6FcchwpJ4IqGZUfAntY44GJk+LvQWs/Em9y2PVQrxHEa2o6haXx2NFrSzXbWFm04vbAeydcOjkesBz3LtkTvcUDBOCyW1y/QO4Z2uQLAS8H5oINDZ7VmEC2x2/o3nX02D/ZZz9VuJTh/MFibo1XA4HScAK73jc4y1MgNHZvwB15/vI/GX/6Kdb2QrwtrLbzlUhTk4kDHSV12A6sE8oOFjYVWg7ZAqEC0wx7T4v4MwG46Fwo1plsRkoKLhRURjSbHFEqFApOmrgQybny2ZUB1kAdTqBvso1Gb1KJuAhw3TOpif4ROKc31TS7uDnRvbMgxqrOYUy7fHfKSCwBEI6rGzTCInC0QFKNPDw1FXrrJ898BesX3Das57dpsjreB3zJQCvVUg3+XlG2g0Dtw9w3vwt2ldFvpYOT1U8/Qil6z+aAL5A0oJRmKi9mQScXSEC9FsJRcYE8GPROdAxqrBafiqAKW4YR2YW0hg1aTRVEQdoYii+w+3jaGKsyC6DmZlDiNbtyPEKSNWklVymIBVGLlXDYuvBBYUfiUY9Sx8ImQFOZ+pJ8bK0lXqkiqyQQQSNFnklkUbeSsxsrfaHDuhb2AHYs68IiRyXQElvKpoULCVJfVRKykdvcile8zgVr0sJd6WPw9EpmLhqdYY5No7KBz9So3mwOQhfcQtQiJvgkcECrkr1tjvVG5Ub1IU5OEcakvxAoVyXeh1afDNVA2ahs2ViF736IDkcywodNrc35Z1i1HR44lupl5AlDWak/jMK3RUh8UMFvYkgOmkbSqBkd+F1XhNJWSNCTVrkKBi1bX+4YyU2B2pgJd7OfBn9LGlYvUmzbFyj7EjHxmK4wimtkmkAJWTeeqmnVhjEhKoWfS5n++/svLzsENLVxDmDpSrHHe549YXrhdbJrnLQYFjmiGznQRn3EioLqAIt4u19LSeTBVio4FBG6TIMMyLyWbNmff3KlQL4htFgxanf1o2jwpy9Q1bz8OkfYbI5Qxv3N3Yz4NAyhadYQjYWjCz0co+whdRLz81PiVTmKgx9FqxKjtsetrTXSfyfwewM/6DdNUZeN1KgJQ7yNGoWM1PCkdUJBT32dn7NYkO/PUDNQ1+hE154xMUXsOVlXixRgjkCjkZ8waC0OcubZnV2eBLlFnMjk2Br0PjNZhBTGQamqbpc/MnKIgSTDMSvus4+QVHYy+QOD6qbOPmv+KtBOHzUaYMLbOoYfn6zpBgtg+YyR2BxQ1j1RAzkU9ct69DGdT7OM08EwGesWsl/lF8r5C0dnRwmgwiHNB+5Pj2VvOmaL0DKLxPTyKexyXFuXXofvZEv2wHWoQme6d8ZgzN+jD5dNL96xzZOqx4qylGVtnP3JGVeapzi+DtuSCvbL2pp/MKWcGULhtJPcbZoU8lM9gIQA9qFh+x9nQXtLa4tjxgSZcq2cIz0vbHuIPvf54Mfi3D3RciEy8MhC52BQsuQUt47UyRpGFirQXShKOoaiS9ZYdMWb6i4tt90J08bCHU0dcXNaaf/XCbRPUMYXT0Wyixs1MKsduNve5ukfHvBxZABilaqCaVKll0N6NxI26g4fEFi+bFbAsJq5SqtlOU7BOogsJRj83SM/AdiR3j4rDJ9iVu2+O1x2BJYnaatJIGF66RccCUBteEl0b9y33jtIizH7oeYDAvlW03AReZASw70EEHZrss0i7iipZCNZAVI3iVUUo+0Ijdss6E8jKWQpGZ1ckNtjsDwF10o7pmImgalaCkqlXKF+cSoe2YxWMPuQKzTUjNOxXIaUPzUXsUkBzK2NFxzLEV+4oxB24e2NloG6AYr5cq7dSnp8MCSDU7+NKMFIV6msRQYoZgM8gFW2F0u5qXrcq0Vejc+GqQi1lhPJGIHC9LtKPAFwZ+Myl+pdbdQehLUJaVRWpPOS7Aq8GsKiAhYCK54A7Eqs2luudgJGAfQOYBYSyPLvxfwCqasUCMqZgeReV3Li/2Q8lvHfKh93JpaaM1GcXlorV6cFruhe0agUDQlkQtAC+CkIZKqM4QZQiMiEKNEENP7VIeUJPNLEVAXxhYa+a7vQERLxHy1+jQyB+Ia0is3ruGdlS2HKPnULFxczWXZTWTO4LxUSB1jrI4zSu3pMdDYGdVzMK72J3A80CsPYpykscgeh3W/o/X//lZXwQi2eFAVBET0R7IrwC/44DbDAqSWcPA7CHChOeX666iZDqvBmnQGdKclGjw7U1GFqkNTNSEXds2hjEAXF5nmqerQVunClp/aJ18UJiXWzA2aqqbl9MGCX9Zbp33/hIqgJwU0hVkIk+xmGzpGVB0vGlE1TqWabObHAbqR2A3D1SRfrvjKemMqbjdoUB+cmOQo4Gr6l79Sx04oaYAqDqD8E8swLOrt8XHtSuEDhK4A7eYCoQ0IGG6JkwMuD9ZzH7m1YRevne9GdxnZ3BNrhs+YgcYEfVE1ICsr3qnLnvPjRfZ2g8AKSkEVS7XtM+aBjwJ8wm5z2UotzJzIVYOwzQCHeqzJQ2S2PdYXnaGDoT750OY0q5cIIrUWwN4Po5pYGCi0lqhJqDnGFCeA+6NsbOadE2x+LZU6t076EaoVYPl571bVixW+vicQ2ZYgRYn7nt/EMZDGUZgJ6sORSURvY04LODPJm+8GmmbJYcLvTJHjlzZnr+nTZDDZhKVqV+F7IAzaB1yiHuhXGEy8GICAaUW+uroV2LYco4Iep7GO4+PfOhfvZsMj2k1rQdCY8jSxs1VgUfcme//JPXH3Y0rvWGTjXds0cUWiDpjpy8qxJFiRGaQsTG6kBuytbdi/sVTgGlF1xpEzgiCRVT2+tkVOXTKbGmEYOiGKtJ9Wk8shjBCaNikrIYyl50UyWp7q3FX7jFTcQmCG1FLhvEmr0Vl9UEAMwqlFYoMzqF2nsoEncWtuhFsSV3ezNKWc6dq/nM32+nRzeiG7uAy8XeoCE2zQlyKoBC7E9FYHM+D2gzlnXLuSiqnVkQZ11ZGq/FBh2O3jSk1YB5nNU3jbtkb/kdS4fkoY21D7Pm4t9aMimD8hmtw4u8XAseA4CGQAXQTQkxcY8DIB3I2ScIhINGphRZrNjcwDrIEKUhJiWPDXfIOC1t2hWN/yMDlYuGoCvxWwLZNAqRpwfEKeoDdojetFvN4hboI934jIVrE3AwyZf43EyXJthXoddLZl2GO9XQ7UpEXwSfW13Gl7b3zeZ2Vy58ai3HAiIWC9AZkhNt7cYdoEhCUvWK40dVrVylsSCPmzLRzk6pSkN681cC6BuUcy3soJwyC/4L991YE0qk0eri+Y4gLdCp2GBxBWli2Wgs1eOwqB7ZlCvWgXTkKZX5nOURGDW5xRZjVDlL1YnEiRrjcRAGkJSDUx0MJPPI+6G6bEpCmwCAdWMNYFGtEsArJVFqfqRUuyIF+sKFpXyWTOcv+dpCAaGGkEEeiOxSYDbHn69/8HqCuoMKYtIQfEuoCRpM36x41A9Adp1r1hLb4QmC6FNyj31oTf7B36P3GmTzXylaoc5DBYEiwbUm0ApgDvEQBYt0LOPKVjTyONZutIrF7h2Vh/tBXnoMLUVYaH4/Skx2anTOlp+sinLccWodKwRo92lYyTOIZ+KlgvRp8hkC4t3oz0RcBI8xk6JMp7nyShg9ee9WJD7jDtoe8Jl7qd7hMQfl9YAn6CTdsRXWj5/kbSkEYiquUTyDVDlYpt2xWvcW0RK2qXGEuFaU/UlD9rMUiQALoX4X4V4bkyFoWFo1lBlwoH0ydPaWw098IvMHmQDzgIWTbYDOZwX/DJwdA57M808Qkn8bgdo8V0o3SpxBAWuLHuOBxxo/9ozPdbUdXl8zKAGc7olxqFAev+iTSZssDI608WxbP4X2EjrwHKYhU8bWnOTPWT9R6SwL2RyE6YNBp8jfFQfoe9SETf2/nCfk/YZHNuN8frKkXINk9MhP2D0BlHFyosdZHWfJj+hHUZaKATF5SaZEVcEZ2dDaajsbxvjwLcXJLj3M6796/WFHA+tNaf9ZLYo+itaSS414lMZcDXyKmZb0IksD9kJzyLWxGL0MO5DYkBRpEByvAL+7CBLvLsQqbK32hSY3VcB5NpEcExdSVxSzEKFIe0Hc2SYntaVNpJQunZnAKMls4G5mPUyBuuWEoAq3KE9AyemhB51FR+OzNms1Grwn3wNAxSPU6L13FTooecvMxkYFazP2Fl9+6kG4SfhZZnj4M4dWb0nr0kvvDdy1RVviW26QDpNSO9qbYHzJyMfNlcaGizS8nSVngYD1U5G6ilIfBRZJkzKi2hRcbHLktRKO9gTWOqlQHwyBmPoYBEGjvZmWQ9MtehsCBbr/3nQp+gqpd06Zi7vY3PDOBGx56ZYTrSpkLWxl01ZwozMjz/qesCpabMo3R2IvZ8SATjoNO1TT0Yp61IUrewoWO2+sxWyekCj+3gl8JusjIij7h4Vexa7YykRU8sB8AyVTd1B9jc7wQhVpcJ9BA5mbkr9ISrt2B+5diLV0HiRW3EBScQ0N5Frs25HAZ6lXRQQuy0d3oJJUotWB6hsdqn1QaKWuwLUbpe7pruNZ/YkuRnzXYtz4btY03FCkbAnMRWAV3dJPBZ3e7qREbjJQ4XPYa6o363emeBsgYCgAkkiOINVveNM6VNgoSUQsnmh0Dlej7sRSb43bR7Kijpx74O6FjBuIHln/W06V8Am6QmpkjU9N/3SFUKb008WCf77+y8s2+/lvd2nn4gXXEEn+MGU0Hj5CGNStIQALoITOAoP9if/P1Q6AP9mGuZEHVJvr+UB3JLwIHDqcZW/WIaxQH6DzbG2no3Cy0FBEXp8PPH7Xh27FpzLgoEPgJzF+dcDTjkz4u4FxXnQnELN8fpcgoLgjhsF2RQ99yAWrdgqe9B1/azyGD56X393jpHKCI86skemVyqC0nvUBLBM4ghbnarrOdGHRNQ6QU3iLdVT5uA+B46k1NPATdkEYaOpb2r93AIzR+bkXOw36c+48OAs/NUrzuAVpUuhWH5LHYD4AYriXiu89CbEnq9SYNe73zBmKA9a9JzxGLukvrYcwVcm+hZ3iOBjvzLkpQvhdZkjjIGWmB9QV2NWIJcaZJsCPWT8W1fT9EpicUZm6IShLMAMDZUc459HeNefsAOzYEOSrsBSmFPnhe4C7bYzsiubThoeOpFcJFKR/zIP3sifoYV5a6w3d59+PsYrBSfxArNBa6PM+DdpxAPvYKVtDjUlX4FG65sHAv3r9YUdjtXsLSNllqt2BiDXFLZls0oUGYqnL801r1+GJo5lCh6KJKrCpxidkYJ2dyACamQg2wAo2s/oshHjzBJF1hniL71iMtk/qvG6wNgHYAsslvjkndmuzlGQpA7E33CUc+s5N9M8Frf4XxPQbvU/G5K6NwEJHqS5AGYAuxGatSd2ijtlpkMPDTt9bALuB2w4ImD1pFtyRYlWOhR/VxOL7R52jyYOvjKGcbJkTRjGe9SZF5aotb9pGV8DcuYclOhjCGRhGfbesFhND3KYsqqLyBTXitdGQSBXKt9MhADqOFnto15qzT4Wywl0E7TrjtUd89NJYqXybmaPd6pJaOiRkkCInWr9FV8pi1KSiATXkuSNYvwLgtwAiJA6QHLU9tQ4tIC5jqDtBQI2UKH36icYKZfkCwJ24otnULkgJQBLIdi5mgZrF1blUMxIvRDReKPwdlrBIOokBRKZ61gIrF+5Uj5kIRKfWjpyYXaMHX0mp5bYRakVx7s3i2l6IuHGrbiaS5e+k6DFyWLhHFtrFpStUxyH9fnavL1RyjNNpheQ1Lxmxu9VjIizUwEwH6RbqUdJAV07Ray31VNFBwJ5LKcnYjU46nDywQge6gNmS2IACEwGMLDUZmKSQfso+5jbWlOHPYACkMVLCFV7bASD53MxxaK6p3mUp5E7VrlQ/Osn++fpHr5+ZZQZ0theHGO4CaKCHHmAYw/86OotxQhDkihNQ5zm1H1frxPSwGHCqSD67Wu8BsuEIORyLxlyvoe8oTG2RMxqm0BBcKGMhbFmQLezHOvQNlrDQoHY9cfo+df2Blmc0IhdqyFTydkeJS3ZKQH9oJUGnP5WeSF2zl50CTNS4fEWP9wAczDiGz28cwGtIRYD5gMX8waTmfTZMINOBPfDenZ0w7/7pYJ2XqU3B+N0T6Gu+1gMkwmC8zz0QXObj+wEVrQ4YNxpulO6NaymVuWW85hFR9nXk/EDr5qzonvdMEazwQGuwD/hXRgyYcUBK7fKxHny+nj8xmfMWxfWR2OAjqAgx5vzu+bqMFJWs9HV9qFAsfISVwACMEhqsbLp9GypzFpWP++W5qBKWbPaaN8doMgiIoZDxYt4n+Gk1+L3MIpQnBjHDHcx+6OeeGwbSjVd0r54H03q6H9eKyWwNtpn79gK0o3FwkDOCcfd4j53nmSObdH3ZwvmcF1aANg8PZxdSPRMFDN5n8Xvb+49ff9jRyHWebyWjj/Z4+CQbO1Q4VKE0MQ/q0sAvRedKm+cGF9al6HhlYVUw+pSQDBcj5InG51Y6OfjA0c3aB6k20SCH0l10Pbai2wsbW/0l2EWrqNTUgLm4jZIxZ+ErOtgo8K6RrO3a7P+g6vt7s5gYoh9RIYo9MKpYiE25yhqHYkvxydzV3YEXWITM5mo3Fbt247PVT6MAx+JQtzI4TDWwR4c8762+Blr4pkIBjLLEJ+P+xZ1sEyq1ipM23nJaXAAbivazyL4ApAphG8y70hnYos1tGXLyN0Xr4eKAufRMzxFqjR2TLHLKbd5Ocwns1m45tbzzbPYlaP3cTthpvscNs7URY9PmZufQLBqY+eR7DC77UPtA2dFVrLlJAVc7epGFXj2ZNHSxUHwnbn3XK5xmDRXU0WnvpIFPMBvCSE9AxHOMjODDAclPUqAybhajN+k4iRgd7kuqbBUslL+j2BA5oXLoHD7u6TBKecD7gmZ2MQsiNauOQNQCcJMTH8V1uAtXKRCQlvsN2fLEhZJGdMAuYO2kkyabWxZMyAWfsw0QHYD7LxRV3MpAINRQEftkVar1ETpMrwbcOo9qY011l1Kx8HAQEog9/WtyBRIbOy5m/arRq9HNXi03aqJWfI4G7oVqUDaXq0ZjwO8nW0ZruIJF75F4ieqzdc83SOe8ms8XE8788/X7VwhgGDBNjwYscTb7vNMBMtOXDMS0VrmXRo97qNodomWMowEM+pN/z4wE9xWxlOP9/DOUUeGdgPec0N72LervC6NmCFElkBiHhhtjw4SModfoO0rmw+Suud8cdDwZ7e2ISztyzgw175ECECPhHuxp4wxjIlUXR0Pq4c55FNluHbsJngesEwPc2+CnImFFnscOCph6GjOULW6JwAyypV1dfuBPPnPY0VAWsS6BYJgi1KNgNAReO5PDkjBoxgDa8M+UG+D4mKR8nKoz41wfXUC9RM+V8hGQ07TQWSWvSQ0Gx9HpfthB4HnrYniuccPDIq7COvMOKOvA+RuFTHgPJGmrIXnbfTpAl9YLtteU0YPW03aWJjQ2LcDKQLVUd2bfBLeAGqjS/rfG2s9gxxWqo+rucfZadRqUgiaFztyy57g1YrL6v++wzsxEnTnyVhQmPCA8Bi8QhzesSgpRj1pj78IgSwwDosIFzpmoxUPnRPQtB0H7cS9yNCZLZL5tHtEEHoMh3BNj+hSJtgslzKyd5XVkx0YHru83HDjRgmyYjghmQr1XfWP/4vXHMxrBw51dk3vkOhuFzo2t1NdCHNnQtVk01qxkX2XjycG9tCkTqSLqxA5GiIlJgxHwSlIdHJncOca/ytSolO3bKkIGaqtHdAVQG9up6c9GN7MF4WxAQHUJpkzJgInGtKskS8bofSJ47eKzFwrxyGh0N/rmIvxUZCu69Bnx7bC1uciTq2ZdBxnmzJZsGendBsx0qlL57SqqN0U5VSzTKfWacUA0XjyQVHsyxbwb9xyiPYsKCJRoaLNvywpfigygCQQVhS1RunjYNVYsn8UE5eK/jzGkt8C9Vedw4WZspDMt3Wh88uAsNgBs+SdWtEK1qDPcWpblk16ZnKKY3xV47VCRFCODHCPooI7gmFtBZSvKw3FWbxc5HCn+5NahG12iDfGePiF99ADWFuZ2zqWTFCgVO2+rayFwJVWq2PcBzDQkgE060BWBvV5wldt1BxAXo/8CMvdaqAi8kk0Iy44LqPC0k1LTEYXYa6gddzRpcx1YUplDSppRNROhPhU7mPm7koazkwpQ3VSzWohZz6SzsTEhFutsuB6S2b2igtMLpM210uQhJ3HSy0I0pCOqYFbGr2VDtigxCR4Yu5jZonQxRQ9YRHxsTMPRTwUuIrWPmhmi5lxn0wFKJD6xCViaNR3OV2QrUhja8+iRiAywBsa0Pvpsbv7IfXc9QeSfr//ycrQ+jA0DPPyVRWRAAwc1IAC8zl8FKqnURnriDpBmICRlh3nCmxNiPkB3sr2iJsU+WfYBN86cpUONoQC8JjgAyMmfRwgwCok4YHa1Hw+A+t1BX1nGRMxIZhhOgzZye+/00KSmfiw4DuZrdO2hICMaFappC75nJHNBCd1b4c0VYD+Sxki9IgnS0zKzoMMdo/qGGVuqR9WA+QaFQFyYvhD43OxDI9LCSdg0qbvkYQtCrlatWjuQPcC7BTRD+7icFW+LvQC1+FBDJxGgrhGiUPbc6yGAiFTnZtr/Sk6o+fJtIBgYW20ajwHeAZx9DIaeNZWZ2oPdda4O7yZQvbQuDm8oNJ+nCD045lkS1aHTviuQ/WIF5jpgUzFkzglawcGQKpivz4nrgtYPsdBsIQWRh6K4irW9JdaLfjd1SnZCkuc9l6hVJ5Wd0rkSYlSgYnBP9Y1ejVD/KjI+5GioH0yXnY+H4wHNQx+31APZBRUsJk7KRe+fLNsRNxgnwJmu8MfkLG7wRhZObZjsQgIz/56H8kKwAbCtagCf+rcDJVrsPYuL/5hEBzClDYygh+5LSlcIOXEnuOZkzmykf/L6w45Gr1BTkRQ4K0mEcrQupSutYjHAMYIASEaqox8LilFS0pLE+/dGKgDYApgs7t5L/SRKC3uX1KfUHq4Sq9i/o1WQaepB7Z6C5AMoClWb6j8C/n2Le183oOZoKEYobzXqqO3FC1y9UXXj/xYblzGjoGdvRlrvTzoK2dTU2DuUGuedb7B4PJTSvJ1W58pjlHMcCNGsmtSZ3Y3eJaPSQJD+5QLptrKJ4vXV5lfedCoS6FtgewHsKUHnkI2TtOkciXbkqSHH52ymZGZU8Ir/rqyJ/G/Q2C8ksJNAVJkVIEfuFICcVzplHM4S5ckgL4dCE03Dz5oe7poKKRlp1gPi2IaaPQF0YMDDJPux/0Rt2M2alAh2hA5nTAqoTKkG8XmjFylzdu2Cd93gQPDWtw5ejufdpBu5qDKrsSOxY8Fd54lpY/YG60UCVzYCC7fGYd8bLyT2SlQnIrcMsuVmFxKUcqYTmGzwxVlFRSLjwkoqpnXxe1cVcKlQXOBkgVSeDhZur+SzMaLTuCvRiydTf5I6yKI5PhOLVpX5AClabqS1NN7u2H1DTlwHs1EqzsxubBULrlqqdaGtaFvQLqymFLMkIiY60zAVLoBSF3fVwlQlEIUu1qys1dPnogEe5v4eRXd4tF7Mwjqkq0izwWHpECR1YskJpOO6RS0gr50TXyjsVMO1+tfG/H/qKzW+Vh/ufoCIVuAiDdiCyNZF+y0hkPapnwz0dCBuznMWJLu0gLWkBOHQIg6wUEBiFHAfLx7OOtLHweHvtoKigEC3fmfndDhXDOEP0BoFHzmoU0AtPDofG5upCybP6t4NXIce8pCW0uf4TAUq7TEwYYeJ19nRQ8swo4qO+YMmYtEM0H6xSSlvcuneqGiDc/4DHJSlPd05Yln1yHYmAviUk6gAVfSNVvDDwNaqVBzGUgYlBAAFdrEQWFKKk5IkFNxYHFzOTStSvOZGCIplTZuKdZRG9XzLcWo5PxHoG5OpMj3M3782HZQ4xkWLojgABoVtTMD3DjUsGMIFQJ3uOeAOxvLYGKx2F2NVWneUi19wjSMmA+yFdZYMAY0WYMZsjyiu6USjF/ukteSxQvfO5pl7QHzIceH8iXqtWtpIBrlHdFmUW5lxbRo2quVD8GyC7DdaMdFoKXvp2SUTNY0mldW2QEJEC5P2OFlM0SUnMTUgd0v6Sv+OGtsz/TdsPp4OvY2Bt9czU9A4krR6A/3OPt+3e4xOa3/a3MwWRB81Ohy/dbbzJGtlH5oZuAjSe3nGswedAy7O3v2r1x92NNhRusSxlr8XHKAoKmrEEgvPRlTRyaUGPY4WLzkIDXukexzAqsJvUPFtywhjY0UhNx2NqMDfFfXoDUWSChk3PjdDk12NmyECAX5+d6Mn68DowTY9UAZIlQv1SbCJwN6Ut9wAcv/GYuquUYDquknL8l6uQt6lBjfcAJ+90bclaPl5KAqU3di9WWwcHDNUKZvgaG0pVRf6jpIx0UJtNvdiYz85WUHWZU/hhjsnB508AXkuzAb2pzASk8iC4cyWeB/oNAmoRgSUFoYOy5YzwX4CibvBiLvd352KOmxkM0lPdSA6IrkDe/EQrBJPXn0f2EGZu6abjeY6nJng7kxyiMZr4D48afpAs4F7iDbGiQe3oShKWi9M8xMQf2bhKp6mpr2oDSQj/GXV6R7DzfttxDadSkWljtzlphykDNldfNYlS7R10IQog0BPpHW7d8bUGSSzFpvNq6KBz7KBCMkNk1dAP0ccg164Xb0cmw5aqKGg6EGowKWfk0JZpEk2tS+3Op0vEVx3BnA34tEJNgOkIcr4syQmmSVVGvpajbtUOC0qwlbKv4uO396swXgGJJgUYfZliVdSFbJuMftjo7Fzs+mWAA+BZMx4Nwz0YlL/XnMb3Kv5ifGqTcuoUG3N3cq8qNcPGFhxjAxFCfDZkkkHiGcz+79cyZ4ofJ/28B811P8DX8QIor/JGaxoxMX9fGRoZej9XtsIgUCT31sKZU/lVjREN9D5Ap0l3u4CVSnQePC4HJyHLORw4IXOu9SoNUgxsTSss1xxFiUf2Nizde/RA7RSdSlkHTDqXRKn8Fg0aNOwjzMCMKtyHCVSQetu2lmnEqzq5Qx6KMNdmHG2fG+WwXzM/e9sq5jTNhWb9OXaFGsBME3FxHio5r9H6QeK/AtkOcI+ajwbCIhyenwiWdUeWhfgIK2obq5xSUZ3JQQ5oBeqGfAag6LarWfx0Gh4FGCI44jaqbgwamNm6GGyPnWi14+zBAkqU3QMKB5kDmZc0qPTHGPSS8lgQD7uB7SnuIOF5DbSuucKqoJe3WhsCeLoGRUoroIkuM+tDr2sMQ0zydpy7t8OYwxroEMB4LDt5ew/k4VUOhN7wOteY8rWAtxnvRh9v/qa7JyP87yBfmMEoL2I+vHsTaenUbN/LUy0Q/V9aQ8gjoPiLxGOiGhGipS54BHCh6hqZc9tdyAHHnOfeN4bHFz2oGrfQ59Lzbhqd5Fxgov6EgbitJR0KQb3GDPxVRTX0/6D38gPJvviLAC1bauULUJSHOlfvP54RkNUnJYDdxUQsZhqK5fcpqIrBTbAkyxl8O8t45nDNWzsXZNGPR4ZswWlhlgBoHqTMqKI01UtOVelAKvwWTX0iV38DGVu6RSQ0lRDYartRcIsyK6Sdw3k3kCIFtVBpScEdn0SMBaj290be+/5nOlUuNVbQo1fympZynRsNdprga2sjb9HIB2JUao5Sg6Rc2kF8gI7ZiOiMRQnOzo8x/TLzVOQY1CknniRi6rl1CDpVj20uGhu8irrSSsNXGBhuXeF7iW8uNt1IoH7Um5ch1NJYjV4Ioh/6EODnKJdMnDKGnSkLTIzR1qXEY4ue/1I+pZX4mFRAEQ9WA2klI1ityhUVpVRDwkI5AEyMmzEh1Qkv02ReNAMQKe28hhIGoUY4FjK7jWbQoAKU3S2zoEWk0XqcFpczlxgqD+sp7nlTAK9+DzMLvJQqFQGZZHuEMEuujNuNzMfG4lXFjI/eW8ZSFw8VOpGrSQAXpcaA9JiMTDaiE0no1ejg5KNlUDszaheBBW0QuO3fYgGIi+uoaAz4MjOilZN1ZPmBrywKeQgd3gH668ctJuGXSFn1bSAcN2I1mhz/4Ydby6SccSzA3dyrcooUWELGMreikXt/cZQtzYKsS5mfdV80DQomPYVrFfbaYcpCV514NAhlaPTfM6eE/HP1+9fbXU9yzY2KbcDrOSkDyiYH+swFhidVESG/EjZU2OBJZstj4HHj3atrtUCTwSLccL8bWpX+2ICOjk0nJ+6yYfux2hUNxKSc7LG/lkyDZSanyr7aSvpRmTTZ8PQeVAb78fyorw0BV+IZ3ooHgAOaDXSnQGUIx4uuOXvh22fCje2f6Z9HJecChbQzZhqrFK0LtJAFGxqpprSVBiDHUWKn92T/Zged9vnwemiHCFjRFkc2fWc6EHEhQ/UJnBkrcYBzgEGnGjemO0553SP3fS64jngO/H3xGM9nnUeckbNo7T0aKBJW/JymfdD0eg+F5w9IdvjbIU8hanRkQ1vrT9TegdwIB+ZKgYasUPdrVtjxWsRJjvdFrOhIs/N8nlV62L1AwfswH3pDtzTCFBpQOaCpepIFAp7EQbN/RO3UNfURptdJ6ddLo/ouqHO69qHukemjigKdNKXjfF6NdbtZ9bPw1EJeWVtpyodfOjxLZlJ0v0FRuX1Mbsw9ZLBjzg20EtW51/bk/CWTbEKbXM8LBr3AMaZemweOTGPRWkn6F+8/ri8bbAJW2wP2phshXFaoDCBXVjK4XGTmc6A8ZyyW6ArUMGO3xAwjZkI4LVKGYQ+AFeborqQtVEt2VqN1g5CTJ4Hjbta3X1L0qwbe5c6aSs6UhvRN+4N3FVYHYhmf4BqFYR3QGSO4ZEz0qrcRQU+NwvCuxu/gU3ksOXENIvL973xeX8yXRgL60oWSyX7JWTEOBoLSWdDAISMHPHOYUNMrngpDWlFLHSxv0ErZYuNzsWoAp9CY0pAFY/V5hqV6kTUltEOMCcsALcpUrpn4csodSGWDowm5e5aORHkBoC9j3FvoG4gcSNzo34Lyvoa9GaClU0Jl6a59oARx8argPUK3MqNhDI8zJFDdDkZJa0JOsElWptS3gAPZcnO8pXn0APpjwgWFPvUdWUIlWJkIPVst9KQiJ8dmlIEhBrtKqSXK4dmXxgbPdRG5bPuRD1hQAdGXWeQAXwqdR2ZeCHwmzIisQh0YxBKYiWlXysXM2TJhoGVn1hYdI5B4HBXY9dC40Iu/r6ypzYKmw5P9419vRDdeNXNaFQkLiSQiQopvWEh1yeNnuhEPlB2Nz4jFKQAViqDWTzYdp7Ct+ntAjbdov3lQvu/TZ32BUZxE9ybxP0EpAhKAGMBiWRwIEM2QECmIG4688udkMPEGpRCsTtrJOlmzfqZLIZgVrfGN+acKTBzk8pwLACvlmrdAxYzTf6HLfX/uNfTBQvEcNcH1/jvgA5JAoI0htevW/uQ3+EAB/+fxg/QOsSBMhlPcE+bRLf1AQv6wZ2fe+Jf0gmWn55HFzT4EDSfnwmwzlcOJtXZbJ+roeivgI0pRgLyx8ad79JXcN3JX4jH+8YQ1nkGAJJ1lu373fsNiFnf9gCSBoF6V8fDMWnASjjHCTfuiTNEMS6jvlIUYT9nOzLMwbe1pmpgnKZ+Bte+vu7FVthZmPbvopnNHmYG78dNA0kNxpwdPBs1JA+56hmr8P3lPO9zHAM4wPP5/46hMLWchACU0Trz+Fi0ssMgXojjh9gN7eiRVp6h9+dvqPdHKAIeZ41o4ZjWR/vIG2qvGZ1vDIr284MAtIfgdVDn+vOzGGyJuaQDTPhdWJ6OIC6fy08vI+Y7nRl0EKrRI9TFNaT9E/Ff/Aqv3hksLVgHP+e+w9v3POsxEFqT3ifnEqKS+X2+b67IoWOm98XjoGg/4awM3WUMTeonyeEiNW3+reBHa/L9OY59nO/+aa//49cfdjReDAECqT4FQz1RKq9KhktR6JthPwYvpcIk8JzFvgXUk6YlDPWgSHHDTW0iSMZED6o3avOIbkWXqhqWrQUadRd2b9TniTyxUZ9pX1Smce8MAIhduOuTFKfNNF81uYPMSGz1qVAtRd3KakipQvKuI327N/r/a+9tdnXJkuuwFbHz3KpqskmJpCVbIC0Ili0PbMMGDA0EGJ7oWQw9k+DnMTTSwDDggSaCYVh/pMhm/1TVPd+O8GCtFTtPi13dgnvgS2R0V91b53xf5s69d2auFbEiojY+10a/v/DaL7w+v/D999/ju2+/xc+//RZZjbe3N7x99RW++vobvH36Bt+8XbwpIhgBiMPPfeO1HrINzvWStOwXCOz9IufpQAWT1t2ZuAHsXdh4Z3J0suHY3C3dJ6zfbnBX3pEIFLILr00vSPQJue1wV9Yl4tZYKJUSBa63hbfiw6uLetYrgKh39OdCft546++AzfVdEaxu9vYGfPU18tNXiLdPwHVRO4pArER0olbjq/WGr9eFwsLr/Z2h49p4bdY2qyqgFr2S+zNv51JVqmYfhI6tamiUtL3NtRVykbjEAmJfBLuhahpofAZv2qsFcmMBypV4bz8wVbEFCXfX7pQ3PtZ4aBqMbM1dbC9CDbQBK4cBAUcEY/b/y6CjCgh+dkMcMVIvAee1XEAmIgsrdc/FQl6FT1l4C+B9A694Q6jSVEXh6kaxTSwi2NMCuie5pVTauUPlfxOvvCYvKZFYuVHFaitXAq9gzlYo4ZTzy1lgzlGzF0gAWczvMeirLqxxBS2gVLo3GR3xM4slZlNRNNM+JmpGL1buEgDbbZCx2agx+UxAsJzlZpY8vb7NqN9CycMOSvqx8FkOgsWQLqxqpdOA1ckQHM7W9WdTorAaQLxur57Hftn6JjNxpPyUrATsOTxvSYFLAXDfVQbi7NUpedsQAKOxYRywhxMmGogBKe76PhDK5EfHcTM5y5F0SzIyBkkwDCJMNrInIfn0FzBCBt+jRj8pAF7U7ecG7uXDByijlQcnoCZwSO+u8doNWRkwAzMu6Lr8KvF3jy6oiQ8wWU6A5grxAmIPyWtHBwa3ca3UoPuMP0N38fGwTqO11F2dh3gcUBR0fKZkzCF4Fx7d4vNeOaME3Vq5IQqa46US+6WbHVzL0BP6pWeHk4uZb8E96G7eM0dhMG/geNu//q7RvqfQ0Yad47BrXfsAZzUSnTnQ913AAsAtast3QgYl444AH5h/vh9yipnk5STa++WjvXmc99pH2nN6Fh5gnGcnNR3QjKQ0nExwyEerApKBtvYztYNw2WcISJ911/0Ylj3KMa738XTDPnCI90UBRzYnF4JLMIWdnWYR3jNA20GpdeUScv1PfsxtD6yY63OVNys67E0JjcHO+7n+xNAIzLoRHwDHoUB/ZwqN2JFwk3PpOehnDAD9jlVcnYfj++leWvqH7D9COrX0IGiB20aqdG13DlPbaERRN74lMXDd3tUANiMEFcoE2IXGppe4GZ3g5LE5XTelJNkNvFizvxFgT4oXCQmbMHAjScv9ihcSpfK2zbwMddIuKGG8SBiosyy89ka3Stfqnw0meFNY7wjG+X1HT03i3UDVO/r9HZ8/f4fP337GL37+U+z3b/H6/I5ffP/CL779jF98+xnfv94RCLxdF7769DV+72/8GD/+8Y8RX3+Nt09viLWwVB6WTlTnVnBhN9TcrTbeu/G5gHdX2QgpiEvbI1m5C+OJI7hJBNZqdYCVx1bXCN9bAtMEuhuv2Ng7JA8wyLvBoAD7ROhhuAC8ZWLFG765Fl57A/WOq164vn+h3t9xfd64+jMCn/H5Vcj3zUZtHYhM9HUhv/qE/PQ11jdf49M332B99SPE24W43rDWG94+fYWv3t7w9fUj1E58tz/jVd9jf/6M1y68UMjd2P0Zr33h82aFpxc3GQoiJdH4yhEIvQwDaqwnOdVbJt4j0OH9qgtvzXssRFzcd5ZfwH0cWM1j3uJ2lyYfHvReczZ38NwlqRiLygIRm7lh42EZOKOXt5IR9ZJTRXv1e6l54KiOEqNoGfhsr0hcwF545QtvGVBdKnRYPhR4340rEpkX910sedAKjpJvkEgATPx/X5skUeTn5QfEJdK6Lk6JcjnYKI3zlCIeXRsrUrIt7ssFKOClF1/wAX0Fm/6xEljBqe9+mG49ht/0utkNlamW5yYlrSs+YFc21qvxHoXuC8dtR0K3uoBmSWG+gFgql/IqRULkQYzdrCYmne1q9VKZkLo8jauQL79gH/urzOsqjxDsHQQORr4nYody02o334CpKIirChmrGxcqCuXoks8KxG1dDTL84uV7MqKnN0zPwQWMs8UPDiHJbuWZtV7qRNgcTwt0+zUvgqq9sdqyLiM7XbKkXCzrrV9nk6BtY1ZJaMJlfCFHFwZAGYBBGDnbUfEQ/4oDqPKsDw+lcu49y0Agr55OQPK9sXiu3scx7dzizUcRiVMHoGw2Eq3wYQAB7VxgPkAJHGs9s0heAiSkIYLZ6sWTej5xXXGuLUL4o8EQElvQAjcg3WxCaokXMbeS6R2NRyNcYjfOjhmS18nn6FQ31H7xAYdE8znTl/ZWxlQfajsNqwfPB6dMFc9ITkiKct5TFS0HjvOZD3kOEYsbij2EWGMjSfZ44RfNYHR/le0CztzyXtX94dsZQL9gnf65mRFQkh9zQUM3ZhZi8Tng+93xkC7thQVkWkrkezqGiHRiOGNISMEqmTnS3Okn46txlCN4rOBrAN4YLEah4d+rx+FED1g4QY4tFx+hJ1u5xN6z/F4Pg5NEF8KijqSUxl/aq8LSJs4jNivhy3UgCefeTIjvNz9X+HoXTjTJ+A1eTb8x0YhgUywEq7gAJeDVWKFO1R3ILL3sveEBvItU5Iv9DnoD9Zke0dAENG+IVxdlL/DDb89klzoCoxeTodlMQknYZIG16d189buqZBGcMFLB81eQqJB4EKxvMPEtiw+Plx52uxqF17lpSs3s5CUNRTq2cjX2+zu++8XP8ZM//0v8/Gc/Q333U+z6jF2Fz++Nb983vnsn4aFHnhrz973xev+M77rR+4Xr0xuB1wpEL8o6xERR7DnCyl+smsUoBm8K1knjTivuWMd1yIQbgJKSMhZSXdazFS7NW1gTzNm4mhUHXgJ/q1iW87w4WnkXwFsn3t4WfvT2Fb7++hv8+Jvfwe//zu/h937393G9Xnj94qf4/tvv8P79d/j8/Tvw83+P/f4tfva+ERu40CprrIfY6zPqu++x86eItzf0j34X+Xs/xjd/8If48e//Hv7mH/4hfu/Hf4BPP/4jfPW7/ym6fozPv/hzvL79t/jLn/0FfvLTv8T3336P1/d/gb/87jMWuJ8Shbek5ymwsN/0osBJRO5uVkLSg+XTlbhw4XMF3uszb+7dWP1izw80lrxCrb1hCk7pWEwovYISPRSlgR+0zZ0Cxzzv8fKUSuTG3PCFg3ldFStEQrqba5aMSJXlPuA6V7zQ70z+psMiEPGOeBX6ok6bAOR7sPQjC1quTES+8IoNxFJPjcSnKFWG4lOrrgu7mfDZfqksvuRWswFB7CUi674pkjEVH7wZ6r2TCx2Bz+1eFO/a1ewyzgcnnxnrBdQ6LxlWfGLUg0UL3hARzB0Le7r04u8TvQNUjrM3vNlXsJ7mapNzRXmbpVGdk8HESSZV0ikBvUhdJnyhS439UrljiihGgc9KPXf3wzN+2AasAIDnMAQa+DJl+VJ+rhp4qTQqgAFWORmZB/z1drMqe79b5LfhJqzmH3ZSC6fTa6wftqRGIa+BHaWu/uJ/kOd6OgFcUDlkexqF6wbvGIzau4oZT3QNuUjE4HG9LhXZg0plK5Li3kY3WcZEYAztWyVsw9dxovCBa/LFfIgRYFYOZgwBsxGGaN8jwHKyYBnwAv0I75qWtwvAa25HXsvycw96H+WtshSfEmh5p1HaC5efhCiTKjmg/irw1MrZcon6XkGHUgb6lSpPqoirTgmQuKTmr/gD2Lvvj/HZ2Dy38VuD62pieStHDHuwtzzz2ysuRhHXzOshMXxPUJ5d54fed8U1enVD+epTpbIV/xgZmJ9lWsNxmJW8/QLslgN5zxypkaNX53C/NNtANPqtzj4CrxuqfkrgrlzObZDfKkJwoi09pIxDXKX1NvnyPd/ML/QNEyUJW4I9lSS3npnzAcJXhKmexiuISfsKV41iEPw28/iQirObjuz2uygol95QSfw+96JdiLFusiiN1w+ThvaCN1k1yZjuAZQwY94X574iH/+MBNYUw5gt/mvtN8/RKPbb4v4SWAmAlaVcA9rkqSgjQeK1Nl5VuJrJqns3E1ebD0EDgVYHXhQr1bCcq6IO8tR0ELix1j+B3Aubm6bola6XEjJ3YW/ghULsd7xQqH6htyqRFPM0XiIv/VKewn5xgVXjurSgTorqKuwXcxbWBmpvJZJvfN7f4+c/+wX+7N/8O/z5v/8JXq/v8fXa+PSmQgSr8dqNfQUKC3FdWOtCZFDq1Ux0ff+ukHvj+nQB18Jen7jZlrwKaQ3xYbVbpKs1r6xKxRKxiYUIlZEDVAKvUZmoTFz5hpBULBDKJ6FEh4SVpX7fg7km6MY71MSt+MK50Pjq0yd88zu/g7/1B3+IP/k7/zn+8L/4H/CHf/zH+Ft/8w1/+/ff8Dd/7yus3fj5zz/jz36+8Rc/f+Fn//rP8Jf/+/+Gf/F//DP89N/+KbJZsLheHMvbG0D1EwPRF97wze/+GH/yd/8+/vgf/kP8nf/qH+Dv/fHv4m988xWwfoTIbwC8off36Ne3+H9+9j3+1Z9+xk/+5Z/h//6X/wzf/Yv/Ez/7yU+wP3/G9+MzI4i9VmCvROfCygsrF67rwrourGthxRs+vb3hq09vwP6Eb9/f8V29o95feH99j9d+iSg04vXC9+1cAEbDNkIRECWLSlY2zYBMFkQvxrminyVYgcUvG/nSFDbWg6ShNVdVsADlQB1Ab3kxRUyXH3jJinx6itIp8I71uhhRzBflQRn4VAHgwue88EoR83Uhk2Tlu6Xy0I5w7EYv9s1lffsF7IV3l+iMESchu0SYFlarQVRTIpZrMTEcwJTSLXKWDZOqxFLvArVsPKFnZ7+V5qxfk3Nh0YQ9gEtVy7bkctn8fYWBmiUZKhyAwBVNCRRnzy1pAElBUojIr4j3DHQmHZDyWl4d2EHJRwOStKha1kM0fqUZZLfXBkBEKhpRQKvARoQKGRzPu+UPgL3zAN2YBHwdR9IxSGVevnzhOXLBF3lKTshxNbg/+XWey1jA8g2gp4+MlFgEAACBAQ4J1kC5n27AgF72hKvBQGArokcuyIfDAf8kNbyeWokOyXwUdYl9pDOtyx+CsOUIFCAMkYmOBVfBYdXPHvI1ISIP0KC4GYhyAzafy4lJeX0sSR4mWY7AqhpYJQF3MEwlWWuAUlbJQ8YLexDhrB3DyYhBl5qk8tryekfH3lQFZAZJ60v3coIgObSVVpxt5ssGsFQooKLPM6W9s27rFL4OEtvWg51Eltc+kLoUMV5BMuJ9FEHcBF4Ly/8rsuEnoJK7V/QU+PG+DRPmaHnBtbOLc9VXoK5AvGvvGmOEC9HeiDtiSgb3KyYK434vpJ6Fd6iAiu6lIZI7+OBHjRqDoSqNV1uso08uQvXkh+6A2jLQGRSvZjGTXtM0cRRBt3Vr7flaTZKpEOfB9crxtJwJzUpmqTXU2ufd8aH9vMN7/1QvC12MnfZIEfoZWqGj/Npn/rTvHZd2e6kkt55EfR1CwVdtDG6ACA5a757Q88j3f/Ne2FD0RFHX/g1eTr8x0ajlJ5MYogSspRKMQNM/oMTIBbHB3UrWBtCU3bhcVjnUCJZyZQ5FidXzhbu7ydqLm2/1ZvnbDcqespCbUo73LvQu7KBucoPAPmtLStSozy+FSF8kGSqP25uL9uomUHvnA4iJ0vI4voOyolZDvfcCRJB2v/D583f485/+BP/mz/4cP//Ft/gUha+/TqxFEFuvxjdJD27l4kusmGT77fcvfLU+4+1rh9BIJKoW4gL6jaH9zAVXX9h6GDP8vOXNbizVztzdik7Qq52g99Q7KDOw+sJbLnVULmQt1HrnblU3zTc9YKsa/dqqKNXA5u++jsBXb1/hx9/8Pv6TP/57+O//0X+Lf/w//tf40Z/8A+TXfzQhOW/HrwH8AXRjff8T/Ks/+Rr/7hd/iT/9i3+Oz6+f4L2a5DTtboTeDQtf/+h38bf/y7+Pf/Q//WP8d//zf4P88X9Gz9R/sNff0P27+Lu/B/zJ3wH23/0j/PM/+hn+9F//G/z0X/5f2D//Gd6lTW0AsRaJ17WAvJBvb7i++oTr7Wv01z/Cp7ev8dU3P8LbN7+DH331Db7CN/jFa+Pb1y/w+f177Pfv8P76rO7hnxlBAcYDRn5GMKtAEUJJ9akbuhvjvWjMa1BldPmwYvEmer58f196hrHjbuu1wadj6Zj3CjQV4P1Hzoi15PX02FS7vBrIneykG4G3YrJ1r808qMWOwZSEsfGdC8h3AFc11qKn/m3leE9WNPJFDcT32UyAXowkve2khyYC2JIhNZCxob8y9B0LrQo1KU9fOjm+HRZOsDINN1CBDQQvNHIX9ovE8gq+/Kobl5MTXRCgepI6HZURD4SLHUSowlqqy23T0YJusLiccoEQ2M3cFGIjksElXfGrrU9XrgyA1ayyt29w97GPNl5+7X3LjLZKU0ddelnrORbGkAK5BncNVRTL87ACCL7nIaQf3rznfNoqVrIslThR+q1yngGSfuAAH0sunNZDLMd9Lck5jEAZhZCUano0WJqpKLtAwZT0lfx267hhHXicixBmVl5uigARyCQUnRTsNGisDL3T9ZM+oBnBd69abPE7FTM2+EgiAN3GYBrLTKrApefB690Q+PW934AkK4CenU3HyYng+F4dTDUOU64H368ABKB8D0vOAg0ybwSqw6pXzt86+8JylEaoFwREXAW0yWmO91pbLoOP0FpciwiTDjpSrMgYKU43UqW0+wZmNbVsHDpkBfN7cr0AVhycmX53eG/xT+18Pr+XHC/+PniMWizgkrt1T/Q4jNGULNFvGVKCxHA4VrTsKck8DQMjJ4rFbaU9rUgJR5fiF9pfIofVmn9jb5X68l7z/nEkc2ktPuQHeSx+vqSe5c13hSFxQO9qffXl8Wr2+Hdv4J6fQ4TLAOm1zz5f/oTfTbc59XMOAHrl9DIjmbzh9IDe3WYi2ot9L5ih3d3g/nLZXikAuCfl/CoSnfJ064JPtPNXW/TUhXvssccee+yxL8v+13/6TwlSDbwggF301LOKNp0xLclvIFRB8Z6HgA8EYxB8DPzFJHWPfl/yl2RiKjsz+zAkoO5PQSBFuUO2vKNg80oDIgY2F6oWapcItlGLEGwJvRsRtXLDVE63S8UyEszPa+YxZlo6JicguwQg4Eauus4wkFR0YDkXxD2CQ7mZUESG+Q2lJOtWYZcV7KG0IAmOeith08lilF5F0t8CXZaMoFhc41ok4iUQ6MyCyEBcdOTsLeeX1lJ58yfC04ficM4I/jK5nrsIlhlJ2oPU2Yh1PAtA1EQGSDT4z3vGSLjpyU44K+wo9HrkclcB12bvH5bRblbHi4X9YoGTkR0pAscysjXzRLXLRuZGBhPZ27V5DSwbaJU1Y1Kvqm8aaF+SXcVNcz9SqDj73LdBFmLvIWEO1dQVk6vqrvcMBKkq24UhjkPSNaUVjBinotupyOArA+/a96F7IzwsAdzoFDhnxKeuHmVH38hN7mB0XeMywUdzf6abMAcwniS0VDeQ1FHrcB9z08mWuqAKUHmyoTyinD1HAm8CwXk7kXF1ITDxnecN59DkfSppornm9zxB7RVHf07+lM7ZqnxYMU5nOxV4SzA/hIRM+yOAUL5QdOIVUmGEVQAkL//kf/kn+CH7zaVTjz322GOPPfb/N4sjZbMuWzUIBGiMKs4ferfOy/wc6/aXuH+SL9Voy5YODzkCzLgdREcXAHEkIBXVJCYgqDJwJ8gPNTRTQvJguT7kYumzAszCIfCl6lD675MblSuwFJWbojka9RKAb429FL2x3N6TRrXNbT4bUiaQiMSAIX/PYjZ7fk9HhYNT4/AmO5Tv49fBgp3dzprFLcdBx/OBSpg2b/kr5E49KlXLwDy4vl2W13xGPxvMA+deM5jmuPrD/vIWOg0jfZ6ezxg4s9R2K4dCpFljbpE+JirH5LY4ehcGzjef8XwvfJSzF9vg1YRbSvtAw40d7/fLTJHnK7VP7mRjY3JbGLHpyT0y7zl7ErMiPX9a9e8/+T0XPdEGY9XHszlgsSpC6SGIk/PQkPz09jNIqWUJEvkspqnxzNN9IfWnEpq8zTyv0zRYTocFkfxyNOxQgRN8iI/7QsTcigUn57ucrvfRieQcsgZFu2pGp710m+v0AgKmr7omzXWb6B+Sw48on7V8vX5ucDxrfvrD9hCNxx577LHHvlzTmy6ESFnVRUmPr5JXtuaFPI3G8oCJAW0APyc5Dn9vOH6nLJLhlLOBcHTdtkloIEi2LAodkiZQQjy66AHcSn9egKs8MM+AIvPIPnqvGacQ07JAnZ+lZzIl+ZEHdUBMCmw6ktLCjARblp8gVQnLElCIHDjdQpI0g6+uVN+wA2KMtBIaYkhWNl2/Mej4LqEafTjLzA0o69xzzAY+lDhGK4ISnNNLS+GKk1nUzqcJ09b4LKXt2Qhaf1UWFHg0yGXuRcxnLVFpHWNyXWowKveZ8sRauS2u8pW3hqKs6CUIbmYoeZULipCkBEKVBVQyA8bMLeJKtM3xOF+lt35ngpD2fucQJ25hgmmCVRLgMrkUSYRBaEreVY3oxEIjFnsh9RboDvO1BmaOIKB8iDXipMhEiZA4f+l1ZE9h6Q9EoN8DKfktc3K4X1xxfkjJjfCVcqIsrRty1cEb4KDuG+nSvAdcCwS+RXPHEIlK06iQxL5PFTTTAj0HVoIRhd0qmtTiN3H+F1wjP69Y0UHPNV6q+EQPIfP3+f/Q8wOYJNAbIWWOUQ9Jm3LbnktHfnH236Elv9oeovHYY4899tgXa/aWTvtoqBHjiwCtnZgb82o/3r0m4CDY1Vu6BcLuYQIDSIEGV7hBAbjUmdlEwH7HZsNRvpsF7g2Q4jigR6F1e2FTKMGCCCzucUAOSoULxvfMPMmSZj6iVQUOU+0ICKimxwD56FSBgz6eY19y9um3Uy7h3ZNL4sFkxJR8ZbnenPDNrMvNXrpuj6Fw6wQNgmXP9BC/5tidjNvZk8DNBFh7oSW70Qo4wd5rna3E5KUc0WalqBIIJd7cGp+rGnG+uyhVwnswj8XIKbz3DGJL+aQxv+8IyWKcRyOJTuvYJlTqrtepyJHIW0YBF3sMTd7KcGQ3k6UmiWkzifB4Tb5gYM17wonDbQKTZ+9B7QomUhIE4SR1RNapdbG/nuSDoPbCQljXfyslmwH3duaxupngEiI3UO8y3SekTdwEIe7NMYfu5UMW2uOZ3ylSI7Ad2ZRvbTB5WWvbbeIXus1jCEfkyT0ykR62cXt+RLFEvBs/hpNDvJXJpFjtC1DVp7j9wzzfFzTn2YiLKN+4foO5uSkCo/q3LKEVixIy7ZlwMRHtMZ8NjckFctTTlevChML33NWKyvAavd7LBEf372vCnT9sD9F47LHHHnvsC7bUC9Xoq09WZQCnqcMR8bQAT79OcijAst1SktyQ/c2lmaw0Fk0PpMs6Q97g+RwOxrjhO/09hty0vMS4ARV76ks1RgsAip3q01KiCCUz64zZSvo1+UhVS7uN5wVseTEJPGrwEDIl/e5T8EBzxJK0PRKYHVPBk+dLgyF3isZ4RDkFciFfmBwFnV5kwUjGa6TxTklpDGB3lALtZp4BNwiJdFNAYVIxBTn0WSRlsYOAe4C8knNywc7d9aGbd6iYAxLot0Aq4ZtIrgewmoxGsWS9KzixZCwmuXaAKpQ8rj1hL34nUKq0uIplvEmAWMLbSNFxn04wwX9bPuP8nJjiIEcSdts7qkqlkMHBvFA0UMRg1kUlfXGLAh5pFIVPu1kZUTn1qrKIkbQtFHGxIoYtCdZIo6BITlNKOKXH2TiFw/NcfyDlYGEdS/iUJ+JmhQxfpLtHs3qKL77/ihtem/yedI7bJ3xm8xOmGgXOVfSHw9lWh7p8K0rp4hTaSiZquS2f9LbiHlroyfVBklAqU+JE+ybXBnD+TGuvm3BOOWJwQjmvGn8xFwOv1HON+6OTdaZjxZQHfoHVeq9fus6/yh6i8dhjjz322Bdre7kfE+DXchqw5sJdWpLyYG4QYPaCPLOC5KGmX9L6E5ilquRsuHypQcUxwfuGEkZVuclRESMJEZrjC5bMIsb5yqjBZcDuTxES0BmqmIlf8CIXy3gxdD0t2Y3KW9USTtXJeMUF5AV0DB6zHinqjLkNYPomkbLHPHEDecLe+hlhXKqZJ4ZwQcc4pJAfqJlVHSwJnVvX35r8zmCUI5PAOTirrqazACznEIi5UV5FuFYskYRcx2MevRBIrHBEqifPgaQBI1/K3cCr8fpUqGuxiaDKmWU3oxgI5Qj4WNTWtOfjXCmEJKnrf/f8Sr7mKJG1Q47eyAt/3NeSg7mmq9YGC4wG1a1e0Q79SnMDJdh3kNKwgy9OaKPV7I/lTDviVnK70diSQanXl5LIJzoQhWg2Gun2cQFUDng3b1z6XsZCuNT0sNee9RhA3zwm85o2YhViyRVf4E0eid57MsoDC1nJMr7x4kktJ7IcD609E7PHDNzR49aYufB9FdGKOlqlacmTiWIpIKL7rIO9twBGGN65yeJSXs499Kk8GFLq4LMpyk1POGrvV4APuhvzZz88FXho3O62e9bJRk4DHw1KEai0DNC5Qnom/Dp7iMZjjz322GNfrG0hdAOPKacfJ9lSMIwEJPkdVmj3S5y+eL8yCXyOxzVFIvAC8KavIFyICEh7eI9soVJRDze0iQNYAs4ZsBb9JGlv9ABR+WDnulbTZ18DBAEo0TvecdRe9383RHw0Xpx039yKVqBuunV+d/jWbRxxm9Pxq2sMSCBfcFsL1fgC3FcrWt79WwQgQTQWDVS69DePHiGZ0xZ5czQHwTKvr0Z9wswVdfsnWdfRn9J69I3MueqPChNN7xIHwhoqjWuAOQQPE8Uxqarqc35gqmbVYgcly7lQC92B0nfzBhgHezcIDpP7a1oj9Gk2OQD+vg4henXjn1OBQE575wkA+FDKtskUYV87ieVZeS6Jys82sHuxzHkAZmKBRZITKnsMiFDw+l1u3AnH/EBMg8bWvJFvspLXSahWBMAhlAIQxcRvh2vmu873SVXZ0lxmnWibzD2c2r1lOpyUwHwKS8pKJGwqS7VpHhJOoNcxoahE6Lsf7mOLHZdWXbld+BDQE0/MW2TklgXhkskdKl0vAp7zdc6nNlS4Bm8zV81jqyT5NNlokevWnDvPA15i6N7fzLtJ5WjV+dgP2kM0Hnvsscce+2ItcOQCATtg/YLlnwah/HuNl/mUNwLu/r2brmT08NMG26hwchoM6iWHGOelPK1COM4Nh53EAAFg+lDK45hxcoxu2muw3gL7Bmg8+QGh/tdQjQ7zqA8kwzkt9J6fPIzjYibCnqpBOOcdp+loY+61pTS3v4xAmnNo2ZpR0f2Yc6QPmfWCYiP30HWkE1dNMPrDZ2ZEcX42Awnw2pVMbMLGzyspFlbmO4TVM2aup0bs7OviGCNDQDTYK62A4/5nNTHmMMR49IEWoekzcq/zIPFZXI7VmpslkA7mDfG7PUvQksSNRx7QvHm+Yq694c8Q0TstfyIJyquIDExUqwMR15R4/cCO24cOTCRO42MieQgYn3MHnFskEhMhkqGfqXkzFLeMWbf5l3YIfBMxCV4z630+3Gz2TJw55iDOzz0nltTN2t+lV7QqJ18L7JtmTHhsoRVqGNdGQL20etbSE5itRsu3feu59TMDMBG3rk95Kus8pyCiQ3LQZ99+YF+87vbDCX6SxORnTVSsfZZfbw/ReOyxxx577Iu1lNaZOEAJvwbJAPzi9V97BSKKjUeBA6Lw0YNP2cd54Xcyb+KDRzmOBHy8oQYLDXpLW8BOoCcOtvjgQR8M66pIaDWIxXzhSCZCnlYwD8C4YUDqnI4AYUON5gzBDuu5CWpuwMea8xvpuf2d167rFLYx+Bh6ER9TZZwEPhjyg1bcHnaBOoGm3gJHcQM34oFxiWzUzfMaga5DDmNOZrJ2G+RUFdMvE7fB92Cw1u877r/X8SfhHAdICr9lB/Iy9LvPHb31rT4VB1Yqb0eyMwaJeLwCuBeG4OhLlvkEvdV07FvmBjjNJS3PQwypBQrdC6evuNboBrDvuHtyphO4UnsTvgZFxrbJ8n2SeIXlOUQfD/7ccCfa4js3hincyIMHWX2a3fnW8o3lpPUhapuEMs51hpm39pGv1WtteWSYNJhkzFrd7p089w3LHafu35h1H0nVbJG5qc7+ycMduc9VOAIxc9I3B0doHbfyXm4lp+bZlRGKZCpyBkVoq7Hk5KgZYh9pJZxDYgLYyk/zNWqPh0nMD9tDNB577LHHHvtijXXx5a0MdoXPpSZ208hKYMKx/nBjMFUAinuuRIwXeAl0VDmh8vaSdTlMeQALrUo2eSITVCwoH72NtmGPal5Au1rQeJsxANoJoa5GxPZ6i+B6y+tOUTu7z5tDDFhs58qLHB15EeTfNGBkDsUBygCb2BEIGcBA+S6AoVTjJLp/wO7QOAREa+nLpbG4Y3bEkAAXVgKgPN1k0nS4epE90szNYKWdWzJz3wCjCEfGAWwAgOwBrFyKnuo6/E+hPgOoqqkyxR8LTK8W2NLvlucugC7k6yQwb0UQnL7LRoLNimKeXl278xoy2KcAYA2yd0dfwETdWFAXc5GcPHuY1yH2mUurpctBq/cJ53YCe62Gbg16wgu41R0WNUlkJNJ1jtFAFPfqvgdvNBfpOWZ+yfS2niDAQOhD6KxxQ1vseEsY92StOWbo/qD+Tse/EelQCeVoy55MNEVWlucKJx0EIhnFpHAD78OqDzkxISR3CWwVW7Ba8pYmhEhGJ0qyrZE6djNpbCV6qUDCkG8r4IL57Lp/KJdKZdj0REx97/OauQdaTgG2CwXeSp9zEniLNCf3b7XXRIIvS9wCTNBXFDG1J36dPUTjsccee+yxL9aO/5VorSOwe0+yckXNC9RADgCy2Km710EE5RJKaFRu9ZEIxAsTIQhIztHBcplJwJepnFK7fuUxbQC9Wx2+3ZDM7m2Cp2y49cVkSxvEmBQQ3B7gjlWTWG31d0RP1R/D0ih26Db2GqIR9ErnnCiOJzeCFaoE3o3jDcqdZDxgHpZEGQz6EgmVup2sMocUBVSC+8FuJyKUCVzygldLNgZs9a9g5KoQ2CPPqfuOkMfV3cwneX2bQbAscSdUpoogPiXx8f/2pfXoOEUCotkfwhGNWetDUpEkEa0+FXDibKcqIcesm/N9jvNe7Q/JbbGL0QIsyf5MurxPwFyR1u9ajDgWcCUYuXCVrygmyl9a7N3spyEiZNLRrwBWikh5kdI7bebB3m7HKVaEmudhxlOuWBSLe8TecoPX7On4XSIteXkX815t4ORpYClfKBgpiAZrFWucU8KNz4TwQAJOphqCZ3J/roA5IivAkkopktFFoqSkbJL281wQO5xcGv/Y0YqT98D7oHCLnLx8Q4goukN3sGP4njAoiU/rEt2fB2hYDecIWngatA9Tezghp4UqqrWeQ3H5GRoq0dyn4/nk1twikmi4Dtavs4doPPbYY4899uWaog50VPZRTNs9maNq4j8LeHsDEol4LYK+oLewoqc5VXdgb3oEF1QNR9r7AZZ2BwrrMKISxmRHUjWZqKeJl5PAMfCGPtIPXtU2QAAlUij2CGH2NEikjkRsVeBahEzM9UzKpaJ4ARvuSydvZivng/9Leb6jXXazEa+6eUoNtqGKNn3A0RAbedcForAJHl31CmfKUE2v7hIQ58+PZEdO7jN/i0m6u4BPMNlQf+LkfO4WKVgA3oQrX5hmg0SZTTnNxqQ7cAEUYUBNcKcA7GIpgSgCTRYz0lx00H3tPg+KGBiIutpTLM7hRE+EOXu+BeDt5GVYT28NPq4ehqa+e0euLw/91r71d96aX3vFxk5ekEv5elsCBtqpik/AKxv77ZZo32yuyOtaIuwmbOc4qf0G32uanr6AaxWWo3ytPonNwgze54hEL5ZO/QQSXqgbeAn8soBCj0RSWw8d8u7HpLWLKmrChhScqF5qg+3GfEfU+ORmNRfKkRD3BdEt9CGXwzRjomf+vM7rwXJ5ejqAZ/dtxSGyGuq7ouASGln0bPh+BbiYasEy+Savs9mHUEHXy2aLTcKuCCCyZ+3REJHXfkCLi3rTyWOh59yc6AfsIRqPPfbYY499ueaEZLt2nRgAJWIXZUFu3FcA8B5oLPQyGm558QpYmxrrDuV6FL2mmcDOD8ndTGptqlNAqRFBZ1DUEJI2AWykZt14FqIK2YnGUpTD3liM19Uu62gB1SBqniiMnbTyUiKAEiGIGb8kYXujXwYWBD0LQCpp3aVJOY0NVBFw52aFH9EQg5ay5iZ4XZPXESJsGmI4aiBpV4uUwWQrJHWrovcf4ebtByxJ/tS7saS3RyhBtU4ujfMYBn1uO4qbvUbajfgaLtkJjXmvFoiXTzh43qxAvgJxpTzNkOTJXbQlbpGuJbKRmQKEdaI/GQ5o3AjfLLAmZaGR9HDHwbAVgb6C52DjBvZ6oJ4OuRvFJhVghSjNj/odNPbJf0Hg1c7nABBqBohE7WTn9DDd65HoRAEXFisirWbPBUdWArN2J/2BkaQiIziEKk9vkd6sKhYm3Zkf8nTK7alDCd1dVHOB5yOx4F5n4QVu6ppS0t5wBOiUM0qOlUPvJjrCPX8jGQgxhZdAuKMoH0k3bzOWB74ykMU+NhVbZDEU1PJ9ItKiZ48prfORsPgMCRElN8/k+Vzy124B56gpt6kC6I2OrepVp9pXAFiOwuLM0VC4Vs4ZKLPiR1hZC3l7OrSdBYcc/ZA9ROOxxx577LEv1pyQHAL95hzsQmzfHwFo+e2+2VfiaMith2646QMTcZvN0MpyHhgdgACRTcp6Q5KVHs0Isdvx+tnrbBwseT0lOAfyHO+8znOv52QOVX2cikNEDC49MfJyUurEq7OH1ChnNYEdO4QbOPBa6kXpkueo29EOJaXfwFgEy10G8e/U1PHn74m6JkG+unRuiSsgAaoGdXylkaMmkdadEYlKEz+DShMpkojuEEkCegG1T+lg0TNIAYctoBpqPPdhnZKfNicY2VLf5juFaR2TKc4BJVACloqGRJMMtD3c43bWPwJ4xqHuz+I56oiJjhDwHoJlAuHxvdDTFR3dLO0cbGA4MrswDYAaKqordze6OD7mjDQ2NspVypynJEmf55632wHUlviV7oGCpUOnOAJESlnWtm8efS189eQRdAbKydLeS4oYnGma4sHc1clnRY/8LeB8dudCRJx5bHUpn8WF8n3gNdD+VEQUoHzJiffZPTkhpX27lJSRce4pzzsQqIpp9ugeFaFCDmdxeP9MY5pxNcSAf/PfESsOYW/loSlfxYGP5Fj8DNAyfYxVNKu0WW/W2kfx8VN/pT1E47HHHnvssS/WehHOYcCFXbXNpNkpJ0QJUJZelONJxLxVY7x88nKOduXo4S0fiLQnd6E3va1tDX7iSI0EGA2eAbAevcHxhEj0Sx036iPwnKHaa4xDWggm8iQZT4Ucg3iBLCPXMKURYOkwgiZ0CYrKTdwG0PQBx+5/AYOvxtHIa4zt05kEwpzg5H1E2416Syq1h99AkLU/RV58QYArPQ0gFMFrZ6YrsdgebKTXic35bswJruIVOg892wSga9Fzy/yCA3ChJFsAR0an8RvUuXoQJtqia7uR1jAQ1pnDrOou0+lAs101BuhqzzAJfHaXAxuaKe7paEPI8rSwKtVZCK6/2GwISDpRmg5ugXcyBS1DnGscGWPMOGcPDtn2ftK+WOcazTqIZWPIG+9ljNywwhLGWXYRdK2F74FhXDG/c4P2PoNhX5GqicK11itia45z9q12P3yvEPh7+C1JWaMlcZwISRxChzgRR5eznqeDyaqjSrOQvkccutSzI63R7Plnqtz17R/tx0xFKG6E1Gv1wRFx3A56tAbOYnmPkBz+OnuIxmOPPfbYY1+stXTc+i+nDcB4eOrk9ylvCQGo6Tug71DnoY8PmIrxvB4YDXlgKdMYMNSBiEK4Y7USiDPljTWiEnAz5so8uSUdwg+SR7hUrkEfvY19iMkAy0BnoiT/sM78BGBMbJw4TpnVziN3ISgUCbqSyfHAQSO6cOrpz3k9Ma4+NVknc4GNWE7cFUlrCPwyQjLecUelAiJMMevQAo8s20lgyLKgJlR9S6y/jW9r8VxhCIAlX25Y2IjpYH5vJBeppFiRu9uEHCezN4XnegEsocpzGAaOR3k5uoYTdQsTDZ27MIUDXKq0AkPgZi8KHN8Br4FrZNzkV177E8nYdYiOCalKCR27nazRyNwIxXxKQDm1lgvTdFrece0H3184YDvj7LX22vr+RWiuDplwd8WI/FB2dqIWQyoE+KsO4df9mM6P0dwDqsKVrSoOkqMVWPkpC3FJLnbD4K1og7uzzzETlHtpL7acGyu094b65aw7j0d5nEvlDvcTOfFPGOV09KJMOTgx7TRwR2f0TPCu9WLciGUAU4yhEIp0KUAFjrfjEOtDblW1735L/IA9ROOxxx577LEv1wroXPP3AboNdDHSUX6xCkzzxcuX9uQRNFjGVEnTrPoigNzr6KtDpEGJ4i5rG3XxBW7pyOsQnIhE5kFs9ihPNACSWkgiYsBlTX0PySAsB3BjOwJSAPoq1EsJ492GHETO5URz0QAyK+zXDbDZA9unqaEDL87B8M8s/0mRgQ0AS/kMQQ3/+EUN/HW1eUaGXcncluaYBszov/nXwgR4RDyy1o00cn6c3AvI05qWggX6BZ61SU4SRbBXxapG6uSe/nyZd8YhiBBZ0IkbKZJmFioX/CC7IwEb8qv/KK05btcVZqAFdFPq1t24QFKbCewXlGDO4yz9Gb0YnLKDe2ueBWQ1K4hmz4tK4PWmXKQSiC0B8wbzNgRMhZu1hktld1MyOebypPKaliU4AZJBMLIIpEiZ1mnWBnfcP/stQ1JBN3pwTk5ADoK+cV/tKjOt5PeiMOc+lZR0LSGS0cB+D6iOMlb4mcB5RjWw6iypU2HkAHAE8gB6EdfVyEvyQYSqPDHa4LyiQCNWq6qUfiZQfxwJORzBE8ZngrPqGw4xRW/2FcoE4m1ufZOw6behRc2JsrYCaJRTLpFKF2OL6OPM0TPWz8MPkchfYQ/ReOyxxx577Iu1MBhZQKwT0egNlZ99nTetEJebfUUk4tJBXvJavwe9m8pSbQR2J9/noeRp1ZLsLnQUMhdiJYFR91SmMVY7kZWQrMGEAvOzUEigN6Mb71aD3T3lRjqNk3wLjO4cLwC70NjYQc9/Xh53geVJTzdqozvyMJGMFHCRx/ZUMcI0/SORArBOEnrnAUe8ZhOiGG4kbsd5A4BkomoATJrX1CRdvJQQOfnZE+E8j6Tn9abiueWNaBDd9LoHmEwdPGeuxoK83pIIAVqSFZMse+RQASzJcaTd71L1pVtezFQd6o0TInDZ2DPZdiyfNfVfSf7wukXEulCeZ0n5Qp0CKSnLKTU887cBSwWhXdIiTRMWicbKQO+c+cuL//TWHCOGnMfkmQR2LMqXsthrpgrIhQJvIxNMJKtF8dK1706rexF6jEStoSID2pPE21pkkyhHPgC4P4RZnCN45B2ODaTI1MnfGumY1uFqrtzai9e8tEjT++U10Tbe0x5tDmm520QllOjeLamU7vETWOB+yiitJdB7nWvCqaNn8s0JY9EBzh/XknPhkM2Cq1B0+mHkaeSBVp+xIgqZhbf1htXO/eFnCnDTe94g26sDniN/6eL/CnuIxmOPPfbYY1+sTf39fYBeLmBffE23ynEanLgpnOUVeOkgrsTig06JTCVLA3gT6GJzvZSzs5ErkIsVdFrl/A0M0p+15pr+ydH2hzgNFgFjNatVvQJYVUh7Oi21CpEMJ5LKM7sxxY3AUrjEAQZxgKpv1QzhEIMVahAoJFZBInEZ3N1yKiBwcmksESf/Q6ifwDSUdDq0RjIZrhUAkryF8RLXlPkEUgvlhoJ9A7pYgYzEW7eqKinWI5BLbkLPegUojQGACKwIrGClsGBBIRISRVm2kOgQjeSBQ9GARqi/SnKyazAhS65qnYf8ubQq00OmYlhUy1vPpPXw2jZu/SIwKSS9ybe8lsNjds1CaqYmYuRKa/PZIEmuCkXQgK5mI8ildduM/mCdFJbQ3BmsvlCUCEJ7t8hAewVeG8xB0r5qBN6hecfJVxiS65yQ2T5xWp3sEN8nm+0dKGzJ0niMkjMgVeXLkqshFU2Zj0npy3OstXVp2FyMcp37XqcY2Rz3b7rJXYQaefq+lIQMlkniHKdIzOMTZp1xI0wRjGJVq2eGo2be8/OlQ17jdh939hS6OLkkgbp3osRRxK1OLJDAk3AlcuvZKQdIqD61JXu7N/fWPZXqN6g4BTxE47HHHnvssS/YrmAJzwiBQGAqPGWkHOAuzSjdPDAIoD8krtKseXdeB+UfkkEUJQ8VojWR45ntIjCZiMkIx9mDoYVGQ3IqdEntbnctdLbi29neT/OfJMlwovho6wVcRpudGOnQIOCddsLqz5BEJ9R4Th7UuJEuySVyxnW8t0cuoqjHhiJB7WCCkmoFYm+Ty0R6yUhwLjDTGnPJUV4as/T8nj+SvMSGOsB7vOrhQdmbaZ3mIIBINvPoblagcjgknbTbCHCwdZAqejvqZBrEiYhS/sUNNAeYq7CD+DtOvVd+x/PlMrLaIt1xohZhwqC/N1Dlq9F+CiiHxZGq2fgEniY6K7g/lUs0nvHmGmRor0i20wVM45htYipydZGY5CTGA1EJlnbl57NE/ExC+/RkuDR11afc7bnp9K/NyfNc6PCwPGooVUO50dSUdTE6k6sGgLPQQKGTBX4LDiR6//Ez2UDsUCJ3ae9o/18AXiJUyrmCo1hWlykCNwTCN0Dd/tPH2vpuO1IRM56+JZNrotDBqJx9H/P7IRm8Hjfsa7PBRfI0N6LyaarkGFhi+9CF5Ln+DXtjjkMjNiVybnnOCl6lctA/bA/ReOyxxx577Iu1FaynX9aTd0wjOCcfN2LA7IeE2fJL3556kYO4SUX0rg0I0zixWGAKGehXTFEhn2qSX/3vkORFYN45CgNUBszLMwl/QOAijF9ifm48Mp7nSQgVmSlHOADsHpIwQAmMhji3wZGfhnRJML3AzUsKt+GYwkil30cQ6MVmzkMD0sYfT3zDuTIYwFueW+D8TnGKEjFJA6toRY0aOxnJOc5dUgEDxbPUokTStFf6/J6QHKKxHD0JesNPIamTs+Chs0Sxox81x4gORgbOVhN58OoQYE5lKgA7iiVbg4DPUpszH4fYmRJHNAHs7El52gER7ZiEYCiaNER8O4rx0er+A+39ca7f75O5LjLbBpAvebkjSAK1ZzK4nS6vat+KH+B2T8518aIrQfmSCZnO3zofRFIPd2oR7tB8809xIEYmG0MXs0M5XYroIRQhNJ7mWViydq6YkSCBeudgQJ7/6h41UXgM+ntNcnZLStnD2P0MuM3szPtwGM7mMFsXh5iE+45RN00/lHZ0ZHpKcv69r703NZzCHP7D4uRtN7PbPUYS9uvsIRqPPfbYY499sea6+zfnmzyDYN4GMIB2tNyN8do7+kEpyDrA4JfPY1AYPX5l2IPoc/iFLXIw/TGiMe7zSRw+5AJ9e7lDUQpLcnRwJ78e6NKwy5te8qPFdjUbex/pGi5ExolI3KI1zvvw1yiVkkvZLu4ItNzM5FkCjCYtQ4B8Akw+ypCmWQs57osFU8dDO55qTwiv0QnKc4hy/4uer4VBucDk5MTcwGhoRe4Fc856f4xoHc/xbWHzHAMRLAjgPInDVpXXIsR6UPSQAc6NwaXpwy1dfvbkAcVOvm0fAOe4973j3QLtv5DMzlGG2XO3a70Pj2qus4YTFWtf4umhPb1bvPZtid+ecfnzJE3eTw3L02YcBr7OK9I9auc66a8KC0SeMrwzry7N63vAJXCVnG3yqWhD6B6cJpookuPg/AlLq+llDtHw3p973yRkQLdvXm8knIRsE4Rz1bMHe9blEI3/cFW9wULVqFhS+/6c4BdI42L36SLv46TGXq3105zNDab93cpJCo+yP4xEwY/z0P0Be4jGY4899thjX6yVNPSEehK3yBPXGR+TrsMKlpakJC3Kx0hV4A/xZTxevSZGcgUrJgQHEz5LDes8qD4eS1fCCcu39GIfb+TNIwu4W/YhL04HTVgKFsgyeoiPBCUaoWZmDaA60aGc1iwkjryMY2rNnUvpgMCpNBtTI9+gTmBLOQ2GHs7RaADxUhUjyXImKVvz4qM5ztFIoIrHM2AVaZiMVXmeG8RQWQCuA5wdYWGOBPBS6g0gbzVCpUOBXooc+B9fmSRk5Qo+wCA0Z0EMEYH4hfiZW5lTmiOErN4fPUTK4JS/ztljvt7CQn7gn9bdkHcE5S0exRAq7cMQIQvvifoolYoYssp5OEm+xsAkGiZUrCjmyNt8wETWkUIB7s5AXyHwe3hjhoCmZFA9/4uP+RrmlXFLXL+Rt5kskQPPX5hkBO+x7JJQSxLDBss+t8nkiY50ByoVRfSSaR17FutGMO4EQMSq+lDE9l7MXxp28No3GK3KhMrdmmSIRrUJy1l+FtTzXZsiWTmJ346eTOQp/Liq8TOYS/Q0RNTcxU2M1pLbKcfqRJG8MTCODeTtGXVP2vgV9hCNxx577LHHvlirzQTWaaAnFNGbgKQFtkOJ0fTwSR6DPUQAnXCy8pCL7ENULHuIAJaEBC+BgjXOV0A+77JnUD8jQlsco7zt49DWm1y+0/lzA1M1KRSeIYhJkighC2LbAHBxPBlTutNSosCbgLVa3kUdaUfx2G2UVBrYNiEAx9fNJOawxKYFTOgxtmyklVjsbtq7FQfZHhsJE/O6mZh9ZuAgbbXVQ2QN6IkE4k0kRQn9EQK0zX+cZ+1UgxyvNaa/wyTuBkGiew3W4n8vsKP2bi9sS4JGL3cvYTAn70LAFaxQtroOaRSAbJ04tJ+iRPyCeQwSfmEjCCijgWCOQYMXE/scqy1oWaEE5LLDm9GEDeU69IDf45XG/Hn+uUvqOMazH1sMr2+VlvT3DX4iFiNcBujBNVwA8CLxr1y6LgH0kTxqb8FExgRL5CiS9ziUrzOVsUzGeJzcOQUUmEug/d+36xepZpSnlaO0Jt/pBJr65F/BJBjnu7jdv5qeXLqvnJ8VXAPKqgL5SuSFW3RMDRSzpgv7kOYFzmFPTEjf2CgUliu7eb3irCs0tk7f436s6RMiCwEgKrA3JueEAzDRUBT0ipmD6Vqvvfvr7CEajz322GOPfbFmD/GIvkPOtwvASkQveQf7lrhIV/DC6wbr6S0kYBfsuksd+na+ffMsy0u7DVJgSchGoNRzAOgt37C7YQnIYtmrrGRLybd6CcDJ82pg63yLD1Iwg4Ziid2QZCcnipJALZRL4hoDxRamD3QvRngimNStXAh6qwFgAwWsncAVI+u5z4tnq+/yMpisNGIVMlRCFHfp1mCb4ykXyWBODHMRDKIyE60qQ3Jeo2FCQ1CXqmZVSnhHnHNN9MnJ8MAk7ObCSNc6YNUYeYbnzUWPwjkunOcF510Y2McZkM47oBjKaWleaTnbpRu5leCcjpCwORt2IF4xCfuHwGIS7pkD0yLeJ4n4FpCAwxR3GV0Ap3k5DnHmf/unRU85kbFylAq5GohPcIfyVkJ+KGm40OhLY2iNX+duJas7D+lD9QPHF1QRKa7gJtm3pGTNaUXNvRW/nGhSZ4+xirIrIrR6ZXDMloxFAJc8/6EvujpWKdmd8yaSZDmWYxvNOe1c4picN4Tv//MM0IA5d5fuG/exQSKnGzjLpLEJ4J5oJLd2SOJl4jNXfr8xh/DM3/Wp1HPvPPnqbJgb+eQVyuHQzcjRU972sccee+yxv85WqpgU8oo2KFNw2crT/btHHjDgtnOIQFVhX4EMyS4i2cehWbO+3iGn9vHwGpw1WJVmL7C3BAJdiSURBz3S0rIDI3OJJNAyqAjEeFBLTdlICggs22VzhH4Mn5wIGu8AruOzbnvhl723uLmvBXfTEQBHBqyzF5CuIBgzNlRVqWh/9oBdgOVmXx0neddYKulpXvLKErYCrsvrarEARFSAzMAqoHao6pKuc92wGktxoQvY7pXgKEIkdvJaQyTmChXTChKL6uLcKgKW1R86iceip7qqVaqX5XE9xwWWNrYWPipOlSQTFoN/rXJ1aB+x7KrzBV4r1a+Dc8DE3EDWmv2M7JkfdkQ/XnBd1gDL5OEmejTkL4F+A2o7iZgUJCUjertYWhnugaE8BZLARbBqEA5LEn2xzbK0ACrpf395vuOo/aE9O+xQ7vSJME4ie7D8skmHyX+GwgSglAiMTKQPLkna9O2Yey9UAQ4oS80ueulb5Gh5fHN9YQUg75vwsVokQpkoEYy+uQHF5EOA0QpFl3qd7cHGguvcQjf6bUnWAtSrhKWvt/ZZvwL9dojh/XumJ62O6g1xswK6JGVcuq4PRQnsGHCHPsyoqkl5s/3bQ85+yB6i8dhjjz322BdreTJcYblTLL3Y6+ZZj/OZpstf0Q6/muU5t/+9U97kZpfrJqFZPYpsMQyKlyMkqalWAivzDwhpmBwb4QpJraGGAJuFRn3LrSSwShOKSUiQNxw9kiDD3rowVXqsse451i1p1OB/ERSftg2O+KiWzuoJ8Ng7nmAH8w1Lm/jPdKQusOP15D+YFNjjyrGlNeACqrD3fxJQFTmI830TowNtODjmiBS/UAux2OGZ8irIE8zPF+yp1hylBEgjzYEiAPyGc/hvYpGz11qRBpWXJfER+eqAke8HzXsuxF4kDKr+40TvHNmRRDLyVkcmVmof/tLVz8bCLddnyF2w3KxRpGVIBdXfVW6SWFtDzQvLNKYnCjEyO+/ISSIOEQh+x4QOJvlROF0ZY4jgJFJrT49kBzEENcvRN52riz/LQK6YiJ8dA52SX7UJgOk21zetDdL6BgIVyTKtXSMT87gCvEdO6WndKMPq9OxokJGGJI3YZ77rkHJkA1dpE7uSWh75WQKRJbkY8zYYtdEzS+fzPVeL1b34XDBL1y5tShnRfRt+iwwpEDhk0RMuCV7x2dVzE7ZOoWjNXYr2SKcee+yxxx7762zHSX976VtGgB55ASRpyeibcsEgt+WFbAFAiCQYZBGoScAwQIPv9DigTqd28nAHNf5sJjYDnSJFdnpaYrMbqGuU9/MS9xh9PkslUi/9KrXJSJwEUP/PVZNgGY0IUsdoYyY5FoNFCZCUtBwGmkHwt9F4gYDvEhPgITl/ufHB0+m8CMpmCvcgiGVfHTGJ9nHYhY57PPLODZjGeKGoUhJsAsRcaZIY9uaGZC8q/4lwKjq6S2PwxWPWy9C6wqTxLGRgqgCf/gx9voeAemt4r/W4hkORiYJ+bpDbnAOTUWit2dYiRos/WN/3gcYxKUcgrQq7s3G+GAj1g/E88OwbJFIuemAqwTz0hqMacXYjJiFce6s9wDBn7CFjs6ypnJiZKJwJ8/xtBavCbeGONGlIVdwuzdcR3ABdCg4GeN+3BXlngSscDVI0S/fMRB49n5bKeUOO9Ct8AkUG7BT4+I8jrkqjOvsquA4KzGAqtM3VYgov+EqH8CsJqQF0aT51PZ7/VkRoopeb9xvWpNvMpvFq3ve/d3lowKcwwFmv34BnPETjsccee+yxL9eI3Xowin8myAQIPn3w/t5fxv6tAAk9hwF3dB4ZgbyulsYziZcEwwnk45mX9VCOnNFQwqUP/HLBlhbQ78ZKJrKHPxNkKJR+EMinUip6iJXP6VHYG8tKN6HQRQTEhm7otMcBC88e4qY7t0zKQLjtyY4D5puANEyC5ndCKTtG0zb5EgCBIeJEa4Qie9DqQe4GchKjYZJykcbBihZx7adr+Z2o+Hxzrp6wzocyoz59BLISqa7t/LlkIxebBxqkNbh1piysp9hyrpM9DfHL8RA7LlI3tkA9vJgklua+hlAPNNU+mb3lni0JoNaNawQQ8omHjh9zxfxOKw9jiJ32++GsQ1l84Na+MCnnzSHvu3I6Zjt61VI31C+XfXWS8q0c8y2xiOOUNKo9fxCpjv64J8O5M9w9jpIhYq4fDeW05CRx9xATj/c2wNu9HrHOvEqe2SZE7WeLon4i4rV9dzqnB3R0OOp1kmcYld28Rkqi9N1QThcvEs6lcsnaBgldnwWE02AyVLWr9FSyLkz/hPaY1/C+dfw4MgF9iMZjjz322GN/ra3kTR1PbxzigGjkdYCyJU5+zfd4/dglOoSWDVIobYqR5mT0BAQAINodmgFMCVdiPCadmsZQnxRVjBIAt+Rde4P1vQRWqRHheCiPd3uq42SzWFTQoyn8TLAEnUedsONzS37R8qpLxW05lroUR0hSkQRok1Mr13AVZR6RwJtzEuzFFU+I3fScSgoERSsuKksEuDGyNHprUxIyAva2d1aoJsJecdwAUw+OD0WdIsDu4t0MD40ehxIi9jNoRj/kqQ2TEDMlEajQ/mFuiI+hzbMM6Jg/gJfInqtiNdD7oNLp/gwR2LfN60PA0aBIjq3sXTYBiMDuViEwxTUGG2p+dV13l3OgmX8SqVwJ0YgGNphMn/qs92ArHONGbPbEG02SH4m85OF/AbDC1T6E0Pchj32nMZrrLpH6s65D/BaY/B8850lkV8d270sPwPMQH3/nKIY72/OBgZH5eX+vzQXopRKz+5AWBoRqnjPOA9GOuMkCeR99wN0TulMUEoFdvJ8qwGhXzApwcMobiebvsQt4Seukam3QnVModOZENjwqkyMTqlOM4fw8IuEKfXy+yMWwGpmFqlvWh/PgcCMxwOQR/Tp7iMZjjz322GNfrNVFcFBCX3y353j2Ul5VJ5Zam02piL6HRDSwrIMRAOMPmY9QBWQkpVewRKkPoGoez5AqpyqQ/rB8AWBDMuvEO47sJgPZhVVryrIyT9bALQ+YlKdzPM3J8RBYJaMe0YiL3vPqoOd98O/xmrpG/gJwobGa0qiXvKQkchTi7MXPfUp6bkte1Rgv70JchFWc9xtQ9IcEFk+nZEo5lkGtCVjy+lYmc2PasjbltDjHQgfJwiSn94L0+gPxgcXr2O3TeF8sJZCbFKhMU7HKz9YZ1+qR/kDXhherTvUSQIxwG2p6wu0hD84HfHx5it14bjzLySTtqJh8h0JgRyGrSAQt7VlQzos1+RB5CkQvVK8P+TEkeACihhzwmk9kaKILwTEkghGglZO30jiRC+d3AATGd0xv9l9QrgZ8Pu3p1H58+cbQ+Z1ntSXjAn9Xkg2NXSK5+yY7w2wvcR6vfog0MLKwQ9XJEHBQwgUHUvd2K7G9Ism1HRm8HX86ryOGt09FBoH5kPNBO4EJ2kUO4XQejpP7rq3xCyCWTjj9KtgOcVcAfSkYKXIMSeKki3LjSkfIRlqmxXHUhXvU4rxgCWX4ean5m9wo/Vx3v0VXP2QP0Xjssccee+zLtTeCRQNRAo4ceVDKsx5wIy5AUAmZSZARzTKqAN/6qpbDqjuuvLMGtFSyGVaNpppAIKSgkROQIFdvdkvcmfBpry4/5IKvBidwVZhBBoHe9Fxb1hVOoEWwdKjd3Dgp5Fkuq7kEeMhSdFoe/00eU3kntzzzjZJ+PFCOLDRBQ4Je3br5V+MOilSTywWySiB6IImSWSax2/xpKmrZC63/vCetzsAVCSj24hhwu0HGoh4ELm16JDiYUqDcDzGe3YksdTIy0y/seKElnUvlqvhz5eR1ucnHe3/F9HkAHO0YERqPhQaUygur8JtrPKTNMqcIRG5EvMvVn05E4fUX1Ggv5lyVEEmAVFRKLncVpmrdEZbaye/t6MtEnwJRC12JqI2OPQDb+3buKzNp30rnr+Mx9zLErGFrrXoUi9E9DcQ970MX43bgjQ/mXwUw0TBIaoiOkSWKv03FuZj94aeD7yePPRn1QKNXzRcsRZqLGiKpE+h+7wDqNXceK42t++T4npOUKimZis0CBbmVnA2Rwmh0JokiWtFLkkuW9tV5lEyf8wxSdOImC+12lITHz7NLORe+SR3KrXPN9/3zQ/YQjccee+yxx75Y+6A1h2QzC4hLv23nVfTN6249s16sxq7GjIC678I1HU/W7+K/Co2tF3MCAm6Y5FV78I9nFcIheqlHoFH05KMnUkI5TU5ZSnesnvKYssTduyuZkwBuQhKvAgnKW4sEUaDO8xBs9ntQ6rRimvBxDMxalWMfYHAHuZw0W+DIMYA/0kBVU+ncD+H92AaVUPJ8jH+UDACwdt74k8OmV3bIQvQAxiyBLMttXrCrGseLrUiE9Oc5x2D5XvaEEO1o7qWMpo4NiV1Keo8ckI3m9TEDaI2Uyt1Q7ioeet3BimRvjbgKucGcFWh+simrwcmHmTwArXec2sVwmCjXAbAmuJx7fa+A3qmmhzcGMPeP1wD3Hx7QCwBVcPEo/RJZPTy4Ipl+M9vxloekKBE/K8IwN4UHWx/2hBsllvbrBIHikCaY8Fk32eB9jxM5bBOTBMtPt+RSzgEBhhj0fW7izF8Diopyjxa0Z3TBTGMwkMeZBO03do+POfaSPPJD5C4aVYHcfeZIpCUjsRZQizI+NzAsnNwT71uFOIE4a8Oo2o3yxSm2MHlWob1cwJsIJIbc6at2PrBYsp51iXw6gz/22GOPPfbX2SJyfKNOYJ4Xr6MBBrIhX38INMnDR0/v7cWsLmchT55fpQmgl5K0m17akAwFqqfv5nAcQwmEHPRhiMPu3gBQqmtvZLaYxLkOOGm6JeFaq+FmZUSBPFckUHmq6yi6MQncfTyP1MErqfh93ZKj1bthkmJNfQ7IkjjLedtTaWs4AHDm21ECA3iBubiNIwRiQk3LbitpfHPHxSJrZj8mEqF5wvxsIkkHcqJjI+dK43bgmIugLOjkrESl8l4OSQQkwYsiyVFy/iTegqDexZNPdAroKES5ZbcBnfRBLSW/IidhJlmNLEtoWrkkTZmMIwFNkOpSw5FNYrdFgpbmtvpUUnO4IwS079neICtvr9sqSuJeecBm87rjwgdyAo2LiFi6PN9guhcogxMtC0nWtNdnHgtg9I6L4RwqRElKZGlen2EXx1Vzj8dZZj8GRGanezcYNbkT+RO68vlE7JSv0C6n6/sJcQtjmrj0OPxDEY7Qvdr3veFIbFjm5H1Eots3OZVHvAofz9M1TxfMEXrWqT0BmudQJbwhlO3n3NS8U46Q7kF6CuaYpCti97/GHqLx2GOPPfbYF2t+8Y4H+WC9sQZuL3P+y566m1qHL1XJxqf4FNw/AgPSnC2ezUyEtKfTiLsPXB4d9M3ziUm0JVjZBm0eQ+SA9TaY1ldH0RE5oMRViKZU7g24nDIxx6M5sxL8717Urc9HAgKtPWTCTd/qzOjMeer6+H0d1wBPQHi6cXsJPAzjUBzSMg76VsTAX2zRhvFI921MEAE7AAmqCGY5jq+FidKjqpohV+N0IA/Twhxg6gtwda5AYN3AGNBzDatZklb84RyXmFDnMBzkDgpVFZtZ6huI9c8EeqdBoMaezvnQxXvuTaKHb3qOF+Tep2yOYFTo9RaVMjlkMQHKcCxVi9uG4TDrjFmAvpWEEJqvcxMq58Z7RKSrm/kQnv8hJkMMz75lfkQPvG7tJxMTE9XYN84wc/lx7Segcbt2b9R2ZFJELAOo/KXCbRrqL3M1XR7vgXBkkTeMg6UhGSGSMQPcuMZkQlTPnnGOeUnuOGWTRwQVZxFmHc+eO/kiMeNnXxvJzHCLxEKNKucG1QYySdtPROOxxx577LG/xpZdApangsspTdnzbwBAqyka8ujA40YC+vjinS/ABG3g6sCrArV11AYgkhHZ8915STfYDTuTHXzx8TzsOA5gyTvaJWDP8VW9EPGSJGfJC9pTC//0lmDuRfQdloHXPeCaDOrIQ/okeV4iMuDcoVVhq6EkXh7LQHyjEbEp2RH+cE+vSfTFDYgobBG37tkDVAax6xr83QC6T8M4Ex+zivD/ghEed2sHwMiOk2Umh6anis9ECyx1wwGaxrEH5DnCAObtDPDkXLmSFUBJVvlYighNL490Ba9AF1nHyHp+SSpzpqCHSJhltvZwhKVQWpnCSLcmZtbM1dlL0aIJDclzv5w0npM0DzhfJeacvl5um5KsDCNzYyGCwFRp0g0UALITJfQdyth3YjEZl4B5hyJCEsutZkKzQwz6XKBPUvQAYpMXo/xZhPHEd+Ek8Htwfk50k2spAZrOhtDw9AyIQ2gYafKceqvEnDf8vKmPpCZbAUnwPqiu44qowPE0zNNKF635LxHCgIJDnD9n+cwG0bOQt/xZ18O+9bnE5LRNVsZtfzvG6Wtv5zy197A+0bfz/wp7iMZjjz322GNfrrn2OwDr7ufda8+nvHlVIPBBqpFaDbjtZiWXXvLuOpETrDpFr3QMoB9QuviCzgxcraTear6MU0D+5kkt/StEGhhCIUStBLByXuDBAvoCODF4ionUPL4TTY3ZfeFOYp9ozA18TQ7ndaZpwCOkE49i2dY6Xl6EszKKXs75HucsC2o+tuilb8BNEHGB+RM7BvNEY3JR2hEQAeKQJ9lk0AMMBPACu5YDGC/66Le4Oq1fTW+FdbuOZa09/9P5Bkk+NuvbUGUy/VcO+GpcBl3+pDuAC7BtxHiZ0aE8HkxCvjQ//EPSLBRJCX8tnT2UrzBLK1Dfd9AMDFmBJEZoJQFznxtrpjrxsQQx5y1L5EJkyp72kaIBypEJxLWtAhM2Zo5PgoCdTbFNALhm3VtAHZNjoCJH/iRlf0hELiQ2anvGXe2qkVGKEklOpLCjgbKjAogASgQxCn01C1sVEC+RNu31zmIRgzZpxBD0IXqaU8oqwfSlbYdCnA2Ds+ST49AC9Ku9fMBm9apWDhZlbVpvReFOPoZZgT5bJhFcww8gXiTERDW9bjjzHBnA23kO+YsFEpOYNCBVIouEq+6yqaaOrIjvB2L0K+whGo899thjj33RZmmCZUZVU8gGkFccQW9ttZrJ7UCEVfRUAOwUcPK7U55H7MJeC5kxOAYAXIoTmAIzqAjsZOQDDeCzAMxNzmwQPFhML28mhTJiQHRwCRxI2nAnUO44XY1XAC9dq1M1KwKdhbdBQDcSFjjlow6OwXAN0IHKXn/uDyJZxSXJF8Z5zWTb6Ok2LR2ZJwl459ow6ZlTNutjcFf2pMpHbNKwcORqAQKhD+D6mqT4mtX0ZSashGcvBF5lb5FOA0qFZlydp0vELTC9THYo/b0TlzB1KdE3MueMyqxFN/AON/oTEdtN4ul5q5t3OjBg3LKstLe4nDekfeN5nkoHgMMOcZ87sB/LvQRpBCVdHsRCs/eIh963db3NZUnqkwKlzoyKCsQu4OL8xejFQKKIIjBf2hMVqijFaBEH1YhLpZ3BSNELgVdYHtRIcFFENbHjtjd2QLUJmGn9gggP7zn2IAEyG+stTkWyrfvO/RPDzxGOf+710Pw2y1zvcKGCcEoYhld+5B0TbR3WvzAOgwUleEtKl9W4uLx4BTu1w71bZhxQ+WTePytNnHrW339mmMB7756B2eHQ2vANFiRwj5D2Lik5RC5GXqtb9zZJ8a/P0HiIxmOPPfbYY1+wpbxq++bNvQQsyhnLpXB/uLOuw/4YwBbZWAuI7wP5jqkEBACRhQTlLlvJ4wWCByeE8mA8dvYB3NUQYhH0FbDnC/4gCAmm6BnuFyykb73YN6iZSnkrw9ETgdG0bGVL/pIG2qcE7bKnWv9DY5qB3bA7Pe1LnthoZMbx5+8QqIrJ1zABotxKiMuIRfOUO1DpoqbHU4yAZDxMcuc1KSF4abJEDihruSXgKtG+1WeEF0cEFpvUr8Zt60gVo0Fc0xvpS2vm7doOgelEp5GoerY0I0YVjf0SQVks9opNANkB9NVMJockOksMq8BGf5OjAEV++OdsW3m6oxtvSJFYTP44qzP1RJec32HI6XU5ciV55meuGlOpqBlR827mfTVua1wiBwT6mpcAOkpRQN5jDUweAhPrJbUqniqAW48Zk6NW74pS3wz1n0j/ThSyC/1a6EXpI4pjiCVvfTHZfUqwCghPJbBzw+t2zAHZQwimYEHektJ7pFVYMcTBkQJ4Py+oNC0YKQIk6dQ8Y9GbUUT5bgC6GcNBofDergaFI9PSdHGv+C8Yz0BDMkl1N5xkeN/9Jg/BualQPhlACWH3NJoMNNJhRt9Uq+aevTpQUczZyULvWzLcr7CHaDz22GOPPfbFWgLYmWx+VQTyK+nh3/qAE02tCHICcW47yglm8B5IgaE93k2WmLwAvAewUxWixCsmSmBwAAGaZkMulskks8jqAVW1QPIDzEHsoO4WiFPUY7e87MmX9oId2D3ypFSOQKcTJvTHeM2Pn9Veemu4JwHZwDQxdf4Npho8v1UhdTDZkabdwK2d1d26LhEDJ7/aC+y5uruCGRQIIlLLvDQOlKIiFxDyXFtLD8QUN4oAeis3wuTCXu5m12heA/cGl5D5KcdfL89tBxqLQ4mzj/ZyGVaMfCgLyGB+SZlwepLuHvDW+RofcopCldEqE1v7ahVwXYXPqCFhJ5G38erAAiMnViZ1nmDHEDtLrkZiqPiXE6c5nQimScy6HxkXbhGLPtXQQntZa+conUEsoz89hDCCJMmN+qJiwgfsjo6RNk2lMhGE7XEoBDO72lug4hYECF54mZMyEpciMHDkStcY1s/ZOREsexyaT+eBOZ639T3vO0c4+FwoFcdSXsXijVzd6gpup4f2aVJux6PVSPlCN5cjglqQyVFxrgRniYujpcXkXugTehwwOqVbdCp6JRC7j5MEIiauMlGYVhqww+VOxn7AHqLx2GOPPfbYF2snWdbJ0Qbh+kvf6tK0PJ6rKXeRZxoiAAYN9rSeY7nkYwkk3cQoZi2396313Gy+tQAshDuQxfluWD89Sdr0uPfOkUIYQA3G8KnsMfa49PE6Zan0RwjwGpzKe2wMr8RX6+3bYLHPJVn7jyBwqipksUKScMohckasnojxFMcZ04EyMP8ZSORfJSsQuZzpaMyh5NkGf27Q7HHYc6/TWBI0dXS0NiwPe9s7O4SIDoAngGU1KJ7/QLq5vKU/XZko6EfuaTxxKkmN51kRk9b+tCc5ptzrmnkvBCVCVwFVk+NhwtMdWJtEakZmAjf7JZSno/4jA1KVB+P9YlmhQj3eXUChb/tqAK+B7ix8zbVObrPXP3uiXCGyc/vAjNsEenJYvKTNPCWGe4rehD07k/klNyJM8NwC9NZV+cIKc3UhSVuacHmvk7GybHTNnkhoDqNPOdwpVQyzFrj0tS+q51mku1aN8kKTxTUKsMGmdFGRSoLPQ6ocufR8s5axxtxwd3GgRZZ02boxnetlqeckuPuu8brck7zb/3l7tihHKBK/1h6i8dhjjz322BdrfP/FYBVjUEAeuL55BD+82OVBBV+iWYNRBb4OzK4GQUdLFoPTUyIMMPKA5qltH+dnE2Q4GBuT8CwAajI0nmHLGYzTb6SDI4uRTg1uczJz2NtJLzWjCgIZAhbvzWjJgAxhmBYId8+RQYACsKlJi/CxBnnyYHX7u1BN3+Z6xidZSYDgk1/pAT5DFG+u+QDXSjgKvexmvUWUPF+qzIQ4XtyB433WGzCQOh7gEcQZe03it+eAR1oAoyUmISI+XFeTWC6Mt4ElfW7PYDAudZ0v50xnBkH0TaXidY0O6vph6HwA9DiktQ+j+Z1TWw1Dn/z5C8xdacv64vbpwHRVJ5j2Tef5Put2j3Z5TVOkwrN8Nq32R5zoCsAxLEdT4pa7rNDf5FNJxlYRSvrHB1Ye4pCNQE3u0PkdJJ1zlMR0ckoyhxPwocgHo5pcd3CNldziBG7PuQfS6tjNbKGYHBLv+uEsmpdOE93zYIs0Aem5keZZYEatub6vsB8c/uzyj2/5PUOWT8LTnOYj5ziENjrMiX/QHqLx2GOPPfbYF20xECRGUbD08m4AVigBgV7ywpcSVf22dzduDNYXzqUHuK5QLqeJh+Q9PNmQCoIDoseRK/UZX7fkG5DHs0GJhsB8ldB/YoCMQdrgFg8Od6DYSGfyxp1gUUwRAuIZ6pYufT9wAIgjPJUcXy95S12pqAAgp5xtCoATVOYtGsEyqEyoDkwpXleAOkgFo4l3gnOcSj2NLWexSvumNf85GvO7AzfQNzlaDZYqHfcEnph/QdwbQ/ZC4H/W39Kg5s5yzooXIrWWMWTrvncoK5kIT/IcOxjtqAIulbiyWieWiwJ4egZyY78AlEsA82cdlEytRaa8XT0KWitltQeA2PbWkwRFFyJV1QlcxyXCAxSTrc3wwnkDQcDrbHl54odjeu0m4uSpYtPA2AEzYVEtmMO2y6PBpA6DcF3tC9HYWVpnIFtlqoWGq4Llov1dSbxW8xh1sDhOb5Q4uTM7JtG+lzwPG4c0wUSLFzC9CL1WinSQR+Z8aRKyTTYL6DrEMsFnS7T282KndSbNLPRuYEvmtnqiS5xvjffOBvIQZpSp5y2qedtbp4CCdrBkUkOrG3xmuVmO51bEJG+n/VX2EI3HHnvssce+aPtQVUeJmE64JsYX6OeblCD5VcDaTLi1Dtre8bo5/AJM8rx4LOc3jETjlhIhGKdByXubALAFngg2po4mIFkHQA1OKCm45GWMkToMyzBwtav+fvIlcUgIMN+IhL2VjWTScxF42SFZdPmq6eDtospEg5SGma4prXlP2Usgf4lA1IChMmwhUhuAkgJMDeXEWOfveTQSA0EwiiDLWvZDurwPbn82wHI5mseOqSrFueKYDLPSp9xeX/12pkKJ+kranvK9rfmWpCVmitLNuA9g0/miGkukhY5oXuesVhzyZMK0nPyggbbd8cXqRFGFS4UA2HRyZhHs0RJAsOt8gEQ7A6iQhKc5tmXJUgDZpUiU5HdXAO8il+n8iVPpDOWqUD6Hr0NCnR0Esp80h1QVjlwP4SiP7iQtfylRp+3pL0WNLPUCx7Jutx6S13jye/g5E4Uh7SWyvmMiRpFcH5YV0zxPtIMOAPSJrE0BArAb/ETwQvLMOMUjgFCOlRrxIdEXbzFGFfIUbAvLvfismrwVPePM61uOjcM1+JuVlFK2tJJdH3aZCLilXLrdRKzmmRP3fSly2cw3c4nfX2fRH2jQY4899thjjz322GOPPfbY/3f7DdI4Hnvssccee+yxxx577LHH/uPsIRqPPfbYY4899thjjz322G/dHqLx2GOPPfbYY4899thjj/3W7SEajz322GOPPfbYY4899thv3R6i8dhjjz322GOPPfbYY4/91u0hGo899thjjz322GOPPfbYb90eovHYY4899thjjz322GOP/dbtIRqPPfbYY4899thjjz322G/dHqLx2GOPPfbYY4899thjj/3W7f8FgnBN/a6sD5kAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "image_path = \"dataset/black/frame_0001.png\"\n", + "csv_filename = \"marble_dataset.csv\"\n", + "visualize = True\n", + "\n", + "# --- 1. Load Image ---\n", + "# In production, you will likely pass the frame directly from cap.read() \n", + "# instead of reading from the disk to save heavy I/O time.\n", + "frame_bgr = cv2.imread(image_path)\n", + "\n", + "if frame_bgr is None:\n", + " print(f\"Error: Could not load image at {image_path}\")\n", + " exit()\n", + "\n", + "height, width = frame_bgr.shape[:2]\n", + "\n", + "# --- 2. Fast Cropping ---\n", + "crop_w, crop_h = 300, 300\n", + "start_x = width // 2 - crop_w // 2\n", + "start_y = height // 2 - crop_h // 2\n", + "\n", + "# Slicing the numpy array is an extremely fast O(1) operation\n", + "center_crop = frame_bgr[start_y:start_y+crop_h, start_x:start_x+crop_w]\n", + "\n", + "# show old image and new image side by side\n", + "if visualize:\n", + " plt.figure(figsize=(10, 5))\n", + " plt.subplot(1, 2, 1)\n", + " plt.title(\"Original Image\")\n", + " plt.imshow(cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB))\n", + " plt.axis('off')\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.title(\"Cropped Image\")\n", + " plt.imshow(cv2.cvtColor(center_crop, cv2.COLOR_BGR2RGB))\n", + " plt.axis('off')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37125413", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- 3. Optimized Processing ---\n", + "# Convert ONLY the small 300x300 crop to Grayscale (faster than converting the whole image)\n", + "frame_gray = cv2.cvtColor(center_crop, cv2.COLOR_BGR2GRAY)\n", + "\n", + "# Reduced blur kernel from (9,9) to (5,5) for speed. Adjust if noise is too high.\n", + "blurred = cv2.GaussianBlur(frame_gray, (5, 5), 0)\n", + "\n", + "# Thresholding\n", + "_, thresh = cv2.threshold(blurred, 100, 255, cv2.THRESH_BINARY)\n", + "\n", + "# Invert Threshold\n", + "inv_thresh = cv2.bitwise_not(thresh)\n", + "\n", + "# visualize the frame_gray, blurred and thresholded image\n", + "if visualize:\n", + " plt.figure(figsize=(15, 5))\n", + "\n", + " plt.subplot(1, 4, 1)\n", + " plt.title(\"Grayscale Image\")\n", + " plt.imshow(frame_gray, cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.subplot(1, 4, 2)\n", + " plt.title(\"Blurred Image\")\n", + " plt.imshow(blurred, cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.subplot(1, 4, 3)\n", + " plt.title(\"Thresholded Image\")\n", + " plt.imshow(thresh, cmap='gray')\n", + " plt.axis('off')\n", + " \n", + " plt.subplot(1, 4, 4)\n", + " plt.title(\"Inverted Thresholded Image\")\n", + " plt.imshow(inv_thresh, cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ea342f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total contours found: 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- 4. Contour Detection ---\n", + "contours, _ = cv2.findContours(inv_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + "\n", + "print(f\"Total contours found: {len(contours)}\")\n", + "\n", + "# Initialize coordinates in case nothing is found\n", + "x, y, w, h = 0, 0, 0, 0\n", + "found_object = False\n", + "contour_area = 0\n", + "\n", + "if contours:\n", + " # Filter contours based on area roughly matching previous BlobDetector params\n", + " valid_contours = [c for c in contours if 2000 <= cv2.contourArea(c) <= 100000]\n", + " \n", + " if valid_contours:\n", + " # Grab the largest contour by area\n", + " largest_contour = max(valid_contours, key=cv2.contourArea)\n", + " contour_area = cv2.contourArea(largest_contour)\n", + " x, y, w, h = cv2.boundingRect(largest_contour)\n", + " found_object = True\n", + "\n", + "# visualize the detected object on the cropped image\n", + "if visualize:\n", + " output_image = center_crop.copy()\n", + " if found_object:\n", + " cv2.rectangle(output_image, (x, y), (x + w, y + h), (255, 0, 0), 2)\n", + "\n", + " plt.figure(figsize=(5, 5))\n", + " plt.title(\"Detected Object\")\n", + " plt.imshow(cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB))\n", + " plt.axis('off')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c80b25e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Detected color: black\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAGKCAYAAACLuTc4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXm4ZUdV9/9ZVfsMt+d00k1IGBICYUZCkDETQQgQiEwCRqaowPuKYPQHyGCUREAhAoLIJAKPAd5HoviigQBBwoyorwMQCAImYAQy93TvPWfvqlq/P1bV3vvc7k4aCARwL7jpe8/Z865atb5r+C5RVWWQQQYZZJBBBhlkkEEGGeQmFHdzX8AggwwyyCCDDDLIIIMM8tMnA9AYZJBBBhlkkEEGGWSQQW5yGYDGIIMMMsgggwwyyCCDDHKTywA0BhlkkEEGGWSQQQYZZJCbXAagMcgggwwyyCCDDDLIIIPc5DIAjUEGGWSQQQYZZJBBBhnkJpcBaAwyyCCDDDLIIIMMMsggN7kMQGOQQQYZZJBBBhlkkEEGucllABqDDDLIIIMMMsgggwwyyE0uA9AY5MdeTjrpJE466aSb5dwf//jHERE+/vGP3yznBxARfv3Xf/1Gt3vnO9+JiHD55Zf/UK7j6U9/Ohs2bPihHHuQQQYZZJBBBvnpkwFo/BhIMRDLz3Q65bDDDuOUU07h9a9/Pbt37/6+j/3lL3+Zl770pT8047PIZz/7WV760peyY8eOH+p5bkxijLzjHe/gpJNOYuvWrUwmE4444gjOOOMM/vmf//lmvbZBBhlkkEEGGWSQ/0kyAI0fIznnnHM477zzeNOb3sRznvMcAM4880zufve784UvfOH7OuaXv/xlzj777B8J0Dj77LNvVqCxurrKIx/5SH75l38ZVeXFL34xb3rTm3jqU5/K5z73Oe5zn/twxRVX3GzXN8gggwwyyPcul19+OSLCH/3RH93oti996UsRkR/BVd188ohHPIJnPOMZN/dl7FNKFsBf/dVf/VDPc8QRR/D0pz+9/ftDH/oQGzZs4Oqrr/6hnneQ710GoPFjJA9/+MN58pOfzBlnnMGLXvQiPvzhD/PRj36Uq666itNOO43V1dWb+xJ/rOX5z38+H/rQh3jta1/LJz7xCZ73vOfxy7/8y5xzzjlccsklvOpVr7q5L5Hl5eWb+xIGGWSQQb5n6UfeP/3pT+/1vapy61vfGhHhkY985M1whT8cWZtxUFUVhx9+OE9/+tP57//+733uo6qcd955nHDCCWzZsoV169Zx97vfnXPOOWefa8BJJ53E3e52twO6ns985jN85CMf4bd/+7d/oPv6aZOHPexh3P72t+cP/uAPbu5LGWSNDEDjx1xOPvlkzjrrLL75zW/yrne9a+G7Sy+9lMc//vFs3bqV6XTKve99b/72b/+2/f6d73wnv/ALvwDAgx70oFZR9usNLrzwQo4//njWr1/Pxo0bOfXUU7nkkkv2uo5LL72UJzzhCWzbto2lpSXueMc78pKXvAQwD9Lzn/98AI488sj2PP0oyrve9S6OPfZYlpaW2Lp1K0960pP4r//6r73O89a3vpWjjjqKpaUl7nOf+/CpT33qgJ7TFVdcwVve8hYe8pCHcOaZZ+71vfee5z3vedzqVrdqP/vXf/1XHv7wh7Np0yY2bNjAgx/8YP7hH/7hgM53/vnnt/dzyCGH8OQnP3mvRafUNHzjG9/gEY94BBs3buSXfumXALjmmmu49NJLWVlZOaDzAbz73e/mjne8I9PplGOPPZZPfvKTN7rP+9//fk499VQOO+wwJpMJRx11FL//+79PjHGvbT//+c/ziEc8goMOOoj169dzj3vcg9e97nU3ePx/+7d/Y9u2bZx00kns2bPngO9lkEEG+cmU6XTKe97znr0+/8QnPsEVV1zBZDK5Ga7qhy8l4+DNb34zD3/4w3nXu97FiSeeyGw2W9guxsiTnvQknvrUpwK2Pv7xH/8x97znPTn77LO53/3ux5VXXvl9X8e5557Lgx/8YG5/+9v/QPfz0yjPetazeMtb3vIDpZsPctPLADR+AuQpT3kKAB/5yEfazy655BLud7/78ZWvfIUXvvCFvPrVr2b9+vU8+tGP5m/+5m8AOOGEE3juc58LwItf/GLOO+88zjvvPO585zsDcN5553HqqaeyYcMGXvnKV3LWWWfx5S9/meOOO24BJHzhC1/gvve9Lx/72Md4xjOewete9zoe/ehH83d/93cAPPaxj+UXf/EXAXjta1/bnmfbtm0AvPzlL+epT30qd7jDHXjNa17DmWeeyd///d9zwgknLKRa/fmf/znPetazOPTQQ3nVq17FAx/4QE477bR9ApK1cuGFFxJCaJ/Vjckll1zC8ccfz7//+7/zghe8gLPOOovLLruMk046ic9//vM3uO873/lOnvCEJ+C95w/+4A94xjOewfve9z6OO+64vVLHQgiccsopbN++nT/6oz/icY97HABveMMbuPOd78w//uM/HtD1fuITn+DMM8/kyU9+Mueccw7XXnstD3vYw/jSl750o9e6YcMGfuu3fovXve51HHvssfzu7/4uL3zhCxe2u+iiizjhhBP48pe/zG/8xm/w6le/mgc96EFccMEF+z32P/3TP3HyySdzzDHHcOGFFw6F4oMM8j9AHvGIR3D++ecTQlj4/D3veQ/HHnsshx566E12rpTSXob8zSUl4+BXf/VXedvb3sbznvc8vvGNbyw49wBe9apX8d73vpfnPe95fPKTn+TMM8/kmc98Jueddx7/9//+X7785S8vpPx8L3LVVVfxgQ98gCc84Qk3wR399MnjHvc45vM5559//s19KYP0RQe52eUd73iHAvpP//RP+91m8+bNeswxx7R/P/jBD9a73/3uOpvN2s9SSvqABzxA73CHO7SfnX/++QroxRdfvHC83bt365YtW/QZz3jGwuff/e53dfPmzQufn3DCCbpx40b95je/ubBtSqn9/dxzz1VAL7vssoVtLr/8cvXe68tf/vKFz7/4xS9qVVXt53Vd6/bt2/We97ynzufzdru3vvWtCuiJJ56432ejqvqbv/mbCui//uu/3uB2RR796EfreDzWb3zjG+1n3/72t3Xjxo16wgkntJ9dfPHFC8+vXOfd7nY3XV1dbbe74IILFNDf/d3fbT972tOepoC+8IUv3Ov8v/d7v7fP97IvARTQf/7nf24/++Y3v6nT6VQf85jHtJ+VcdR/BysrK3sd71nPepauW7euHTshBD3yyCP1tre9rV5//fUL2/bf8dOe9jRdv369qqp++tOf1k2bNumpp566MAYHGWSQn04p+uX8889XEdEPfvCD7Xfz+VwPOuggffWrX623ve1t9dRTT13Y99xzz9X73//+unXrVp1Op3qve91Lzz///L3OAeizn/1sfde73qV3uctdtKoq/Zu/+Ru97LLLFNBzzz1XX/Oa1+htbnMbnU6nesIJJ+gXv/jFhWMU3bpWzjvvPL3Xve6l0+lUDzroIH3iE5+o3/rWtw74vteuz0Xnv+IVr2g/W1lZ0YMOOkiPPvpobZpmn8c744wzFNDPfe5z7Wcnnnii3vWud73Ra3n729+ugF5++eX7vMZPfepT+pznPEcPOeQQ3bx5sz7zmc/U+Xyu119/vT7lKU/RLVu26JYtW/T5z3/+gm5XPfB39JGPfEQf+MAH6ubNm3X9+vV69NFH64te9KL2+7Jm9vedzWZ66qmn6qZNm/Qzn/mMqqrGGPW1r32t3uUud9HJZKLbt2/XZz7zmXrdddctnC+lpL//+7+vhx9+uC4tLelJJ52kX/rSl/S2t72tPu1pT9vr+o455hg97bTTbvRZDvKjkyGi8RMiGzZsaMOB1113HR/72Md4whOewO7du7nmmmu45ppruPbaaznllFP42te+tt/c0SIXXXQRO3bs4Bd/8Rfb/a+55hq899z3vvfl4osvBuDqq6/mk5/8JL/8y7/MbW5zm4VjHEjB3fve9z5SSjzhCU9YOM+hhx7KHe5wh/Y8//zP/8xVV13F//pf/4vxeNzu//SnP53Nmzff6Hl27doFwMaNG2902xgjH/nIR3j0ox/N7W53u/bzW97ylpx++ul8+tOfbo+3Vsp1/tqv/RrT6bT9/NRTT+VOd7oTH/jAB/ba53//7/+912cvfelLUdUDpu29//3vz7HHHtv+fZvb3Iaf//mf58Mf/vA+06CKLC0ttb+XsXL88cezsrLCpZdeClgK2WWXXcaZZ57Jli1bFvbf1zu++OKLOeWUU3jwgx/M+973vp/aVIlBBhlkbzniiCO4//3vz//5P/+n/ezCCy9k586dPOlJT9rnPq973es45phjOOecc3jFK15BVVX8wi/8wj715cc+9jF+8zd/kyc+8Ym87nWv44gjjmi/+4u/+Ate//rX8+xnP5sXvehFfOlLX+Lkk0++0VSkA42qfy9Sov4HHXRQ+9mnP/1prr/+ek4//XSqqtrnfiWl6oaixfuTz372sxx88MHc9ra33ef3z3nOc/ja177G2WefzWmnncZb3/pWzjrrLB71qEcRY+QVr3gFxx13HOeeey7nnXfewr4H8o4uueQSHvnIRzKfzznnnHN49atfzWmnncZnPvOZ/V7z6uoqj3rUo/jsZz/LRz/6UR7wgAcAlub0/Oc/nwc+8IG87nWv44wzzuDd7343p5xyCk3TtPv/7u/+LmeddRY/8zM/w7nnnsvtbnc7HvrQh+633vHYY4/ls5/97AE/00F++LLvmTDIj53s2bOH7du3A/D1r38dVeWss87irLPO2uf2V111FYcffvh+j/e1r30NsBqQfcmmTZsA+M///E+AAy5U29d5VJU73OEO+/x+NBoB8M1vfhNgr+1Go9ECGNiflOs9kNzMq6++mpWVFe54xzvu9d2d73xnUkr813/9F3e96133+r5c5772vdOd7rRXkWRVVQt1Id+v7Ov5HX300aysrHD11VfvN13hkksu4Xd+53f42Mc+thd42rlzJwDf+MY3gAN7x7PZjFNPPZVjjz2W9773vftdTAcZZJCfXjn99NN50YtexOrqKktLS7z73e/mxBNP5LDDDtvn9v/xH/+x4PT49V//de51r3vxmte8hlNPPXVh269+9at88Ytf5C53uUv7WTHqv/71r/O1r32tXdse9rCHcd/73pdXvvKVvOY1r9nnub/5zW/ye7/3e7zsZS/jxS9+cfv5Yx/7WI455hje+MY3Lny+P9m5cyfXXHMNs9mMz3/+85x99tlMJpOFwvcvf/nLAPzMz/zMfo9TvvvKV75yo+dcK5deeukC8Fort7jFLfjgBz+IiPBrv/ZrfP3rX+fcc8/lWc96Fm9605sAeOYzn8kRRxzB29/+9hb0wIG9o4suuoi6rrnwwgs55JBDbvR69+zZwyMf+UguueQSPvaxj3HPe94TMED2tre9jXe/+92cfvrp7fYPetCDeNjDHsb555/P6aefztVXX82rXvUqTj31VP7u7/6udXy95CUv4RWveMU+z3m7292Oa665hquuuqq1mQa5eWWwEn4C5IorrmDnzp1t8VdKCYDnPe95nHLKKfvc58YKxcoxzjvvvH0aqTeVAZlSQkS48MIL8d7v9f1Nldd/pzvdCYAvfvGLrTL7cZDJZIJzN0/gcMeOHZx44ols2rSJc845h6OOOorpdMq//Mu/8Nu//dvtGPheZDKZ8IhHPIL3v//9fOhDH/qpYpcZZJBBDkye8IQncOaZZ3LBBRfwsIc9jAsuuIDXv/71+92+b8Bef/31xBg5/vjjF6IiRU488cQFkNGXRz/60QsOtPvc5z7c97735YMf/OB+gcbaqHqRflT9QIDGz/3czy38fcQRR/Cud71rwZFUHF03FFkv3+0van5Dcu21196gA/FXfuVXFqLQ973vffnc5z7Hr/zKr7Sfee+5973vzf/7f/9vYd8DeUcl4v3+97+fM8444wbXtp07d/LQhz6U//zP/+TjH//4guPu/PPPZ/PmzTzkIQ9ZeCfHHnssGzZs4OKLL+b000/nox/9KHVd85znPGfhvs4888z9Ao0SYbrmmmsGoPFjIgPQ+AmQEuIsoKJ4+Eej0V7Kb63sL73pqKOOAmD79u03eIxyrhsrOr6h86gqRx55JEcfffR+9y+h4K997WsLUZamabjssstu0EMEVqjnvedd73rXjRaEb9u2jXXr1vHVr351r+8uvfRSnHPc+ta3vsHr/OpXv7pXNOirX/3qfkPaP6iUCFRf/uM//oN169a1Rfdr5eMf/zjXXnst73vf+zjhhBPazy+77LKF7cpY+NKXvnRA4+nd7343P//zP88v/MIvcOGFF95sXdsHGWSQm0e2bdvGz/3cz/Ge97yHlZUVYow8/vGP3+/2F1xwAS972cv4t3/7N+bzefv5vtaNI488cr/H2V9k973vfe9+9znQqPqNyZ/+6Z9y9NFHs3PnTt7+9rfzyU9+cq+00QIibiiyfiBg5IZEVff73dr05pJ2vHY927x5M9dff/3CZwfyjp74xCfytre9jV/91V/lhS98IQ9+8IN57GMfy+Mf//i9QMeZZ57JbDbjX//1X/fKDvja177Gzp079wsErrrqKmD/mQ7btm1bSFnrS3k+P+29VH6SZKjR+DGXj33sY/z+7/8+Rx55ZEuNun37dk466STe8pa38J3vfGevffoNa9avXw+wVx7qKaecwqZNm3jFK16xkA+59hjbtm3jhBNO4O1vfzvf+ta3FrbpK7z9neexj30s3nvOPvvsvRSkqnLttdcCcO9735tt27bx5je/mbqu223e+c53HlAO7a1vfWue8Yxn8JGPfIQ/+ZM/2ev7lBKvfvWrueKKK/De89CHPpT3v//9C+xaV155Je95z3s47rjj2lSstXLve9+b7du38+Y3v3lBGV944YV85Stf2SsNYH/yvdLbfu5zn+Nf/uVf2r//67/+i/e///089KEP3WekCGg/7z/3uq554xvfuLDdve51L4488kj++I//eK9nva9FbTwe8773vY+f/dmf5VGPetQBM2cNMsggPz1y+umnc+GFF7Z0r2vru4p86lOf4rTTTmM6nfLGN76RD37wg1x00UWcfvrp+9Qvfc/6TSElqv6hD32Iiy66aK+ft7zlLQd0nPvc5z783M/9HI973OP427/9W+52t7tx+umnL9B6F0bHG2qwW77bX9TmhuTggw/eCyD05cbWgr70n/2BvqOlpSU++clP8tGPfpSnPOUpfOELX+CJT3wiD3nIQ/aqFfz5n/95VJU//MM/3Ct6nlJi+/bt+3wfF110Eeecc84BPY99SXk+B5LaNciPRoaIxo+RXHjhhVx66aWEELjyyiv52Mc+xkUXXcRtb3tb/vZv/3ah+PhP//RPOe6447j73e/OM57xDG53u9tx5ZVX8rnPfY4rrriCf//3fwfgnve8J957XvnKV7Jz504mkwknn3wy27dv501vehNPecpTuNe97sWTnvQktm3bxre+9S0+8IEP8MAHPpA3vOENALz+9a/nuOOO4173uhfPfOYzOfLII7n88sv5wAc+wL/9278BtIXKL3nJS3jSk57EaDTiUY96FEcddRQve9nLeNGLXsTll1/Oox/9aDZu3Mhll13G3/zN3/DMZz6T5z3veYxGI172spfxrGc9i5NPPpknPvGJXHbZZbzjHe84oBoNgFe/+tV84xvf4LnPfS7ve9/7eOQjH8lBBx3Et771Lc4//3wuvfTStljxZS97GRdddBHHHXccv/Zrv0ZVVbzlLW9hPp/fYGO/0WjEK1/5Ss444wxOPPFEfvEXf5Err7yyLVr8zd/8zQO61je84Q2cffbZXHzxxQcUEbjb3e7GKaecwnOf+1wmk0kLFs4+++z97vOABzyAgw46iKc97Wk897nPRUQ477zz9lrcnXO86U1v4lGPehT3vOc9OeOMM7jlLW/JpZdeyiWXXMKHP/zhvY69tLTEBRdcwMknn8zDH/5wPvGJT3zfdTyDDDLIT5485jGP4VnPehb/8A//wF/+5V/ud7u//uu/Zjqd8uEPf3ghAvCOd7zjez7n/iK7N1S3cKBR9e9FCrX5gx70IN7whje0dOHHHXccW7Zs4T3veQ8veclL9mng/8Vf/AXA95V2eqc73Ym//uu//sEufh/yvbwj5xwPfvCDefCDH8xrXvMaXvGKV/CSl7yEiy++eCEi/uhHP5qHPvShPP3pT2fjxo1tjQjYO/noRz/KAx/4wBsElv1Mh74dcPXVV+8XcF122WUccsgh+430D3IzyI+a5mqQvaVQ05Wf8Xishx56qD7kIQ/R173udbpr16597veNb3xDn/rUp+qhhx6qo9FIDz/8cH3kIx+pf/VXf7Ww3Z/92Z/p7W53O/Xe70WpevHFF+spp5yimzdv1ul0qkcddZQ+/elPX6BSVVX90pe+pI95zGN0y5YtOp1O9Y53vKOeddZZC9sUCjrn3F40q3/913+txx13nK5fv17Xr1+vd7rTnfTZz362fvWrX104xhvf+EY98sgjdTKZ6L3vfW/95Cc/qSeeeOKN0tsWCSHo2972Nj3++ON18+bNOhqN9La3va2eccYZe1Hf/su//IuecsopumHDBl23bp0+6EEP0s9+9rML26ylty3yl3/5l3rMMcfoZDLRrVu36i/90i/pFVdcsbBNnw52rXyv9LaF8vEOd7iDTiYTPeaYY/bad1/0tp/5zGf0fve7ny4tLelhhx2mL3jBC/TDH/7wPs/96U9/Wh/ykIfoxo0bdf369XqPe9xD/+RP/uQG7+eaa67Ru9zlLnrooYfq1772tRu9l0EGGeQnU/ZF8/rOd75TX/rSly7QaK+lt/2t3/otXbdunS4vL7efXXbZZbpu3bq9aGiLrlsrhd52aWlpQc9+/vOfV0DPPPPM9rO19LZf//rX1Xuvp59++l6Uriklveaaa77n+y5yn/vcR29xi1ssUJ2/7GUvU0B/+7d/e6/tL7jgAnXO6SmnnLLw+YHS2/75n/+5Agu07Dd0jeVZXH311Qufr9XlB/qOrr322r2u6QMf+IACesEFF6jq3vS2f/Inf6KAvuAFL2j3+fjHP67AAi1ukaZpWpr1q666SkejkZ566qkL7+7FL36xAvult33Uox611+eD3HwyAI1BBhlkkEEGGeQG5UD6PanuDTT+/u//XgE9/vjj9U1vepOeffbZun37dr3HPe7xPQONu9/97nrEEUfoK1/5Sj3nnHN069atevDBB+u3v/3tdtt99dH4gz/4AwX0AQ94gL7qVa/SN73pTfqCF7xA73CHO+i55577fd936VP1pje9qf0shKCPe9zjFNATTjhBX/e61+lb3/pWfepTn6rOOb3rXe+q3/3udxeOc6BA47vf/a5WVaVvectbDugaDxRoHOg7+o3f+A095phj9Hd+53f0z/7sz/TlL3+5Hn744XqrW91Kd+zYoar77qPx8pe/XIGFflrPetazFNCHP/zh+trXvlbf8IY36G/8xm/oYYcdtrDvi170IgX0EY94hL7hDW/QX/mVX9HDDjtMDznkkL2AxpVXXqnee33b2952o89ykB+dDKlTgwwyyCCDDDLID0VOPvlk/vzP/5w//MM/5Mwzz+TII4/kla98JZdffvkN1jLsS5761KfinOOP//iPueqqq7jPfe7DG97wBm55y1ve4H4vfOELOfroo3nta1/bppve+ta35qEPfSinnXba931vj33sYznqqKP4oz/6I57xjGfgvcd7z3vf+17+4i/+gre97W2cddZZ1HXNUUcdxe/93u/x//1//19b0/i9yi1ucQse8YhH8N73vpdnPvOZ3/d1r5UDfUennXYal19+OW9/+9u55pprOOSQQzjxxBM5++yzb7Df1Ytf/GJ27tzJS17yEjZv3syzn/1s3vzmN3Psscfylre8hRe/+MVUVcURRxzBk5/8ZB74wAe2+77sZS9jOp3y5je/mYsvvpj73ve+fOQjH9lnPWTp6zR0Tv/xElG9AQqDQQYZZJBBBhlkkEF+LORTn/oUJ510Epdeeul+mbT+p8oxxxzDSSedxGtf+9qb+1IG6ckANAYZZJBBBhlkkEF+QuThD384t7rVrfizP/uzm/tSfmzkQx/6EI9//OP5z//8z6F/xo+ZDEBjkEEGGWSQQQYZZJBBBrnJZeijMcgggwwyyCCDDDLIIIPc5DIAjUEGGWSQQQYZZJBBBhnkJpcBaAwyyCCDDDLIIIMMMsggN7kcML3t2978Z6hAElABEcCBRIUACCAJiIgkHBVJHSlK/g6EsqP1plMUEc3fOTQJKrlkRJNtlxQSiAOcAzwIKEJSUFUc4L2gCZIqiB1X8nl+/Zd/g6ZqbsrnNsggg/wYyLnv+UO2rhyEAEjRCQ4VDyScJATF2RZoUnBKq4UUVPs6CiTrGdNHCS+Ky9slMc2VD4cgiCiakinGfBBVU3WSHBRNJAmVBOrACcSEkHCAiBARogAoEu0U3oGIIymc8Stn/Cgf7SCDDDLIIIP8wHLAQEPyYmkmfocrUnIkUURSXnsF1BOxBTk5EM2rslPEKZIXYZItsGW/JELEDIGCM0QAb2uzXUBCVQpMQfO1OFViykYAeVtx3bmz3PG/7sTJXzgZcZjxkY0OwEAPAglSNioyqmmfQdleABUlYeBGVM3oSIK4Xn29SHuzgubrss9UAVEzShBE7fuEot7CTaKCK/egdq7g1DCXYSozlkQMCGreT7BrytZUUiXmjTUlNCZitOu3l5VIKZFIJE2oKqqCJHtOqg51asYSkWQvn5QiKSgpJFJM9uz8BOcmiEtonVASSSJaR6ILKIEUo+2TEnkLUsrAUu1pa375Hodb2sy02sB41KBplXmYM0uJOI9EbZDQ5H3tGAokEVI7XrV9FeIqRlWFH00ZjceM/ITpeMJBmyccPN/Ft1d2c+Vqog4JTfmVpTI+bIyIuGyUio1hEZwIznm8OCpfUU0mjJamjKopyhRNDalZRcOc6MDlF1gMTfFC9EKKgk8O8YJ3gvOCFzuuG1U4rWyMZdBvMN2MUs0g3F673bmoYfQyf9vRma1tRfFi71my6ZtIuDKYyr5JOmeAJhBBpIxTSElI2YaWPCd6TwxXzifazilEiUC0LfJlZUPeZX2TyHNe+MYtvs5F9/xQN70UJClOshYRl59BQjXZe8tzVU3lZL1TpnbWIdEhleZ9yzVk3aBi+2UniORj2A1BzLqKfN029+y5S3u+7FxJirpkuk4UH7NmcfmaUFIevy7rRk8yR8sg+xQRufGNBhnkRuQOt789DzrpJIImYkoQbR1kQRdkOwDTNTjH2Dlmqyuc//6/ZWVl5QbPISKc+piHcfitbkma16SoxDoRk5IShNTbtnXImkO1qEyXHbMiDu88TjxORggjQpP4uwvPZ8fO6/Y696ZNm3jMYx7NeDQiabT1VRwjcWTXCqpafLv5GuyanRNwwu7lZc4//32srq7+II96kJ8yuTFOqQMGGipkww+yNZytHIdmWAEg6vKam41S78gWe16ozSAvEzabQhRzX8pFt4YIJQBihmQBA0hrLNhkyNdVcEEJuZgZ1N7H1j0HcY9v3g3nXAYOnRGKZMM8uQw07GCarQ8RkKqcvRizBnnM2nA4NaDRgYpiQSTomb2IARp13Y26fO+qSspAwyfJICQDN1WCN8NFkrTPJikk3wENM/bMCCMlIpGoaiAiRWKIxJDBWRQ0BVJKRAIpRTTatUoUXHSId4hT1CnRRSKRFANRG8JqoJlFYp3M0PdT3HiK18QkJqYu4V1kdxPYEQKJhhgCsYmEEAka7dzRwIuNF0HFgRsxqUZMN96KTUu3ZNP6ZVK6jl3LO9k1r5mt1sxDDXWNpggxGYBRITkxEChqzyP/OBkxmo4YTdczGa1jPFrP+ulGtm3bwKGTqxl9+2rczsi8NmMVASKIS+17RpwZgi4DDHF4L3hXUfmK0WjMeN1G1m3cxPqNW0m6mRRWiPPriLMdRE2gIUfe8jjxjlRZFLBCcJXHe0dVObz3jF3FaDplIhNGzsBZUCXgMsixMax5fGmeVz4JzmdAWgZMnh6agZ0X8DhQRxJHIiIp5UFYxqugUfI4TqiS7z0DDcTGrQou5WdXZrzkgGReuMv6rWI4N6kg4rvp7czhAAmJBTg5ol8TmcxAWstc82LvKSX6aqQFWIY6WpVius0hIqjLmkKgIEwRi4coCSS1RkbRKUp3oNYRU9QU5X5tvqr0nr0UpwIdmCm6qzgt8kFVFfwNK/JBBhnk+5Oqqjj8loey7ZCtqEZzxCU1/ZXXY4qNkDLQaL2NSkAJKbZz/cYk1pEwj6QmkKKiAVLKBn6CvtYqLtUCNgRbHru1zC3aOzeCuVOMJO9QjSQxb2WUbl1QNeejZmUp2Zlkz0BwznGb29ya6667nquvvvp7eMqD/E+WAwYayfXmUVnYVUg+Gx/Fe1csfSWnCmgXNRAbyJq62aBl0lI8ifn47QqcF9ykSFKLbPQmU+cJJBv4+Roke0HXugJzWpWS0F6JStEb0Hk7XUH25X7bqEp/orcO+GzsSKuABCybDMBZWkfKgM1pjmAkaT3GsbVyigeUzh+fIx8l66KzSgoQUjOG2/0wIBMVSQkVU2opJaJGUozEaEAjJbG/NZqnI0Y0mEEt6kgJqpHZmzhgJGgwwJFCoGlq5vNIaHKaSnT4SqBRNlbKLavE0ijyrUlgx45IIhJTpImBJgRCtOtJKZmBl7JrXjyu8rixMpWKzdMlDllqSMkjUambQHRz5qkhamPHiJEYIzHag+qnytjlGxCMKEEqYhBC7dE4oVoKyLRhZ90wnyeakCxSJ7SLDzFbx5KjGk7wIngcWgnJZY+0ODRGlhpl5D2pmhLrgERDkFoHNDVoVvRJHBo8EmwwBC84yaAGj/noQSQxnQgbFeokLEcISUlix3HazYeSydNOsYXonnagPodGOuO/H4lYnB+Sx2hCWrdXC5VFDcDHznFgnjjbO/XSGcv92NiVHE3pGdjZw6CpODDsTP1gYTl30u5KLaKIjWM15aDZWSHkyE5r0HdzOYd0kKR5XubJ71w71US1jSDZf4uXURcfVkE4OfJqj1czsMNeUpm7IoT2GDbPXT5YuVclp2YNMsggN7ksLU150PEPYDQeE0Odowt5vdWig1Ln8Ox7N52lbNdNjd7gWTqZ72lY2TED5mgEomQ3pP3baRXtjK6iU8SyGcSpOWbw5qwUwTtvCm5/ET5VQt3gstMj5RUxEc2vQ7GLoDhoLXJizjQiVL7i+OOO47LLLufvP/ax7+NpD/I/UQ48otEi3t5nDtTbNxI7o72kBKEODQCpDSxInkzm1GvzGrBVWFpD2Yz6duWmy9HoHIJldXeO1tNQDmdHSZ0hUERo0xBSNnbIHsiSxpVNe1wxxlzPYkuJ4rI0sGFgIeGyQZNaA6x1YBaDLJnHt3g2HXTRHmceDVRxal5c8TkNpLUYzcMisXsPKmIpTamkXplbJGEpJ6agIslHUoiEGInJ0pyKFyVECAQ0RvOwNMnqbkYe0QmMKvzE4yQgVYOOIuxp0DQjzmqaWWDeJJqoeAU3qRj7DYhG1vnILScNB62L7KoCutwQY01oAs28oQ6RJka0sbQtNNm9JIc4jxdBVBjF69jghYNmM6LuZlbN2D2aMVudoU1NDIFQIiQpEZLDJWfgVMqgNGXq/IiQFNdA8A1hVBPDKup20ly7m5279rBaJ5SS1lQea3Y55ZBzQbkjbyMlqUNcwIWKmGI2UCPVKBC37UG1ITXLSJojJDSY8R1ECUSSKi44S4FSi8Zocm3UYZwc1A2TTTM2phGzuqJOwopYFCqpQRLv8i8ZQKAOkgEAelMK7dKlcBl0aDRj2HebtSljeZ7gLJIRy0RLZbAnq9kyi90M5Oy5L1EB10bnyq4OlyMKZe0usRgQklYGULTEJxeX83IMzWDcp4RrzChQl1AnLaiosGhLkm7em0Kwa823YP9GA1I6MkiURE3HSXFEaGsISKt0OlimDjKCsO3aVNDsVagMuNgcVJIKThWX87B8Bl1gALAArkEGGeSmk7vc5c5s33YIuMocb9FSh5Oaya2qpFj0n7brdUk7UpEcGZjyM8c8kGuuuZKv/8cX93mu7be4JYcdfmvG6zcwixEJOQMgmWNVtbNdSjZm56axv8zpVZaeLmXU+QCuYTFWuygKBEm4fE+2VTTnDOCyAmztNwTX2jnS6kUR4aAtB/GA+93P6sdS4t+/8O+sDOlUg+xHDrxGI7v3pbNwLXWiMbAgPuesaw71qRkwVUhIlQz5I23thQ1jpc31BkR8tgfV6hLaiWfezpK6paJt9EKyZ7VMzpS9sYYFtECJTsqG/ZSpBYOJ1j4rnkazR3Kue053SpqQlA2nVFB/f/ue/ZVdk1Ll9JECAgpqKt4TSRmVKD75rNvEjCUtHs/eO9FyD2bYpCj5WBbGjVHRaKAiEoghElJDiEpMZlwlMaWTXIIYkJgjJmOHugrcErgRqakIMkfrxDwlZnVDmK0QQjSwEJQQFHVCpSPmK5sI1Fw9aRiPlfVT+PZ3Gpavn9E0c5qVxiIalqwFTQ5ZayJGl6MFFT4JO9XR1Ncyn+/m6koRH1mtGpbHM3bvXmb3zkBIjd1nzIuE+jI6sqTscU/4nAzrV2tkJIhz6LJnde6ZrySWCawGSxOTysa2Buml7rn8Ii3dJ3kr5DVPk8d7DzQIDTvSCnG2m7RrYlU6uWZYR9m1HpWokRDNoPWV1WlIElxSquQsmqdCg8PvbthVJeJBnuArZsFnoBmsPkZAIrZqOUWcLzPN6kn6Y1qljbZrcdppBK9mECOQBInFu5ZQl0xtJMHnuglVtchZlcc5sY0alpQgyXMoFXCjlg3kxHVRx17EI4lFhfAuj/Fkz38vvQTii/EPLiQk2L2XTK1yVaVmIrs1cuRG22CElnSz/IrVlYVeLJrnc+Sn7CWmAyQ7SVr9YXloFPVW5ioqaAZwBDJw0+xNTLnOK7+tcqHl1wFnDDLIfsU5Sy8NIdxovngREeE2t7k1hx12S1KIxJiIIdcposRsdFukXXtIQNqayJIV4dyII293Z0bj6V5AQ0SovOfgQw7hyKNuT0g1TQYa5hxMaDT7qjVFpEQ5OodnMfpVsBowBy5K1qvBCDAcjEYjvK+IMSxch2JpqkFBY0nlxBxQYDq2AKriFBZt06dKraiIY8P69dzpjnfEO08Ika9/4xvUdUNYc85BBoHvAWiYoZajAZmlRaMVMIk3I7vENMQVg0LxIlD5tuhYg3n1bQ2V1ta2Bb0rKDdwra1VoNmI74c0rOgyo4aU0EZJuWip9Yy2xcX52pIgjYORGRKWIG7fKdlIG5nBFs2WaCMXIoo5JIWorpfugUUZinFRMn9yuLE8G8HhUy4IzcZMuTiNuXDeWz69jxBznUvJz9bUSyWJ+YY85lVN0TykGiFENEVStChDSBElEUMw476xFCPNKWragI4rqriEqzBgKArSkNxONCgpQhMbYmxYDTXLcUbaGUmjhjo0NE0iNvm+4tWwNKNpElcvR1Z3NozcjOuWZ6zEQL0nUCc7VkyWMiXB1GCQRIhg5mjEOc+8HrNrolxzveCnDSNZZRxnjPyM3dfO2SWBFEpubU6/6vmBkOL9AeeE6BKuEqhGCGNkPEKXJixXY+ajHdS7Z9Q5N7cNXvS8SGbRZrAhjoQnlVqaSqikglQhTNk5X88ul+DaiEhEXMK5hPNClcyAjXkYKoIL4KPDeY+kiCZvAWwPwXsaN2bn9VP21Irosi1UVYTK7lk1j1s1sIKLZha7Mo5tvKhCcop30kbe1JPvCzOEk3TlRRnwF0tZYl6YXCYJyCll9niyC0CFpBYbJBRAI3nxFDyWMhXy6YoN3joP0Ra84ztd0JeSqWhzQHA4S52i01PloIu1Yd1cQsRSGLSw1knrbCDme/VAJS140CSkJFQhO2HaVMz8Qunski57Uxc+VzV95FQX7ktMsZGRSHvNgwwyyL7liNvchmN/5p589h//kf/+zrcPeD8tRClqkYygOeKflJjKGtnzGMS8rgjmORShGhnQmfiNjNy6vc5x0JYtHH/8A6hGI5yriTGQcpoyuWYyRVu7UrSYbetcJK850um6wnQnEomThEsJL45REryMOO6Bj+Kaa67k05/5QFsnZzcLzTynoKt2hCIlZ9YUYHbopHweO7FliWXSk/y580ZoIeI4+cQHceXVV/GJT33igIHeIP9z5MCBhpbswWyx5MiDeetdjiDY6izQ1lNEMhNTcQZnQ61EP9oYYV5URcvgxzyG2WAvk691P5InSAEbkhCfEMtNssXdq9Ua9NZoFVCfJ0tb9WQLfWtUZu+ueREETzlH9rKaD7OYK4b6XTIjNnt5S4SkyzrJB1fzU+BS7zl2hnAh9Ek9X2tHv6kZdJnhb9ZptgRTzMortUZ3CJEQEyEl+y5GmibS1A0pBTQzeAmCxAkyXmI0VtBcOyE1Mp8hMUDdQDQw40mMU2Q2jtS+YT6rmc0ioVYqFD+vkfkOpBFGXogkqhhwVWAkSiNKSoEQG0t3isaCpSmRJBFzGpyXhJcRfl2gisrSSJi6iMiMmJZZ3VPTUFvUJliNiMZCIZq98LF47XNhm3f2rtab56caTdmwaR2TzUvsilNmrJJWAqlOnTeazD6SjXIpA8UJ4jzaRCJC5R1evL1a5/GTKZtGG9i8YZU9u2bsnjXM64YoAUEIAt4781nlVSQFUHJtyqjKNn/EOVhynqWNY4Ql3HyVGFfyM3QwcsjYvOquRIR8SR2LVMnIApwrY0m66AE5Nzh79CWKAXToonEdTVOeLgYWkqYcDcjjPIkZ5dKrrM61TXm6ZrAh7dhWn1G9027CQI5UWmLUQl7BWhFLHdRcO+NbAgppvxcxMGQpbmLRlpICmSNUJZqqJfSRoIR8NGUAUXLp8jPRKqeCqlpNjdq7VJX2UjXrSRFDgZJKcTvtuyiMXKUsR3I0pWzjdA3CGmSQQfDes+Wggzh468Fs2rSJQw7ZxrwJXHfdNRaJuBExFsW89qRISjmyodpzxqXOTij1g5gTp9A/OrF10a/NoACqynPwQRsJKVI3jblWNLWF5+W8Bm56TrIcjm1ZLKWzm1xxegVzySXXmA4TWLduM5s3b2H7LQ4FDZmRMzKZLqEp5UhHoQrJDsw+0CjRGyzaT7HBpKufE5e9Ps6i1+vXr2fD8vof/IUO8lMpB16jkcriWqILPc892nkW6Yy6ttY5mrfShmbB5Pl3dSWRo+xsYUOnSHJt2JCe/VEMDs2eBVeKq8XbBCg7KN3F9o7feg91AYPYB05y4XkJFxrtmxOIDlMEydJkSlpGEim1pHb9qj2HpGYDxXLU23BlF/8Bcg56dr+rmqegLc0gG1mlVlpo0zdKSgt9hdXY7yEGQjSqPqOSDYTQ0ITMLEUC9WYcVwk3VqrUoPWcuqmpaRg1NVVSqDPQqyLORUYamblEM4vMZw3zOtE0SqXgvVoKi58yHU2MCldWca5mFBMikZQaYqgJIVo0JCt3lYgmA4IqoJPIeGTHXLekbBwLqarYFUbMmkCoO5AVUyLGHNkozybn7WQ4ZRbcaM44CGEGXhPrm8h6bZhvmcOOZbSek4Lm2hgw6l9LwjN8aKlyOAc+Ep0jisvFx8YSRapwseagDQ231sh3vDITZbUUGpJwCVyVmYwyg5UZ7YkqI/CoOXVH5zjnmU7Ww9YpcnVgvssTU2CmCReiMYQ5QdThnLdQO+RQQcRFM/A7zxQtOUNKua5A+hxw3fgkO/pxoDGDYsAlZ6mM0KU2pjz4Y1fzVCZwWcMK9W0qdVd9EoNyZu0cD+10XpzNmfDBGMaImVI3GwWaEZCUA0Ta+gwtHkIt8Y0SYpA2Q040M64U/0B2HpRwhHhBnSOp1VTYrWTvqCkyS7/T1AbZWhyV0yClF9UUl3VAPo/Vt0irYwYZZJBFWb9hAyeddDKT0Yg6RO5xz5/l6DvXfOCCv2ZlZflG9laSa0huRmgCMSSaJtAkWzM1ZJr34uhAM/GNGPD3HhkXhyRMdCcj3fucThLT0ZwmRFJokNhAXo9jVGJIRoiSlJAXfadmYIiCltRVMsgAxEXEOVwcmeNsnmhcQyWeMA1M11U89GGPYiJzxjpnz/Iy8yayJ9Y0jbZ8nEXtqRaCnw5kmIL0rTPEZ4ZFzU5a5x1kp5Y5Meub7L0O8tMl30PqlFVct+kByEJgo220Vwzn/HvxdPbNhGL0SRm0dCkunYWToxIlbpAnQjku2uLx7B30xf/fAy4LB+xkX+kIxZAq0Y1IL9Wk3YSS4lUQS4lemBezeEjXnjlff+b4b+9iAV8tXmdq96Tl5C/5XEouICVmGk/7SdFoaUNIxBSIMRCjFUdrk0ihpomN8YTH2Bo8yXl8MiXr5nO0XqYOM4ImiBFlgo9jqnGAKqEpGGtTjDTLgWY1UDc55UkEKkeKHqnW0bhNNOOIF6WZr9CkSBMamrqmaWqLsGSgEXLUiGRpNVTmVg5JSV6hSlTrHaGaEFeV1XFDvUcJwe65yYxTpJwulCM2PZjRjqf5LFI1DathxoqMET9m1Y2Y7d5FPZvRYL1D7CWoFc8rxkpUipdzDYFznuhc6+1yArWHkasI6yZEicbai9VypJT7e0QLYztyHmxR5N5GmkXSbJD4CkKAxm1FZALSEJjTEHL9TbDi98oK+JzPUYc8ENXlVCVr4GHnyWmQWkB7Hr9tYXM7+DPRQIvMuxqP8q892pTnYgYInUu/nT0tYqDjbGqBSJngIh1gKMfo5S/3RVVaQGiUz7G7ztw8RChOgZbSov2vUDwnXZG6XU0eL1LO26sJa50fBjRUU+cU0Jyu6cozVLposLTApqAORVuyASn6MqWFZ6QiHXvdIIMMggBHHXUkW7dutTovTdk6cYxG67nL3Y7nmqu/zeWXfWGf+x9y8FYOPfQWTKsJ9UpDmNla2aRo66OqrX0KfZrblHJNBrl2rHHMvTUbrnSF6XTCve56d0ai+Ez0sW7jlMYF5ikwn9fM54GmSYSUmSCLM1CVpJlYpKSRZ91Z3DBWq5qjEZr7hEWrORTfGPhJEUae6ObUqSHFQN1YXUjTmEJ0rqu90BxhJfV0dMu80+aOo3l9KrZfSnkNFOtBtLQ05h53uwvfvfIqrrxqoL4dpJMDBhouu980r7wlFcoc9pkJiQ4IWEBR2rqG1iNZ7GktHtCOJ6Et6GyN/myCZO9+Mer7KVrqOiZKo8q0ot8CYdTtzxPYeUrLmRZz1dXSTPKxLU0z51O3gMuKdCFHYbKBVXWXbuK1TQNJmAfWlRSzNjfCDCVtn1XucixqjdOULtUr5ovN6VBJLTqR1Aq/Q0qE2BAbU54xp1OluqZJDTXWKI+U8/grh6sDzaxmuZmDrqK6SkqSm76PmY4cvjKgNK8TuzWxWicDGfOGJiSiOqrKqF4TStCKmimrLpC8Y89KYmcTWFmeM5s3NKEhhEAMmlO78k0mZwacc2gTcCsNstSwVHumTokIq8GxmqCuI/U85uPEHKmJVhRPr29JecdYkfVcI0kCKTSspBnj2rNylWP3njmxnhtwaCt31Sh/M1VRofwTcUj0OBdxrjKgEUGTEhWaOGKkY+aHCMszYaXJ16cdT7umXhFw6cWhmV9JtWUkccDyHvDzgPy34mqI0d5P20RxntnKnMNViksOn0kYnFio3ktqU4w667jM1jwfVA1kuQ7+2kJUPF+6kGbUFlC30ykviK5MZtooh1VsFGCSDx66SVhAh9WyF6VRlEMPCZTryvNSUJxaepJDc+ZUQVk2X9QXAN85PLq/ehdU7iUjgK6IvLynjgo4FVYvktFMugxjvE1Rl3t6tNKmf/bIcfPDS63eMx1XXk9PTQ0yyCCA856j73B7DjnkYGbzzKIk5o3w1ZS73O14rvjWV/nm5V+im+8mCmzfvo273fXOhNAY0FgNRsqBOdEiaga8au4pZfo6pUwykpsBiwZm4gkBNK0wmUw49m4/wzqXmLjEqos0PjJzM+ahMaCxGm29TMEi5TGXnyuolhyOta5HsztElJSZo5xYbaClgUdjsvMCzNHa0YgnNom6UVYJNKo0ITtSveIqyxcv7Qk6shMFfM/TmmO13nWNUSETL3pEHE6UpaUJ97jb3YBL9gs0DrS5ZllfBvnpkANnndLsPcwLn3XcNaShLheX5uJZIAOCPLkzKtEcAtF+bUT2FrbHbb39mr33WAMxLet5BhGxOP1s30g2BBzZ48y+XaBk/0C5Tin+blqnavmMSM4nx7zAbZ64awtkJd9XEkuJGWmmF82AQouRlC8l5gfQN3K6vH+7t/bxBMurR1NbRE4yhapBUY2kOve/cFaHEXOEoAkNsc4duEmkJpKahiY21NoS+0KKoA3MI7FpiD7gBCqpqJwSayUyR6RhsrtBmzmzumaXKHWCOtY0sxlNTCTxaPL4GInMCUmZV3uoYqIJe9i1OmPHypz6+jlzCW0heErJqHWLYSnR0k1U0bgb6kAMu1mKYya1EiaJ5RhYvm6FZscKIRlISRozoXHqjGK6FCgR8Ag6ElabEaujKcuzJa5NgtQB3dOgvkFnwZR2GRlSnnsZsy4rV4cj4bJhr7EijT0BoU7CLATqPctcuyfgNBpTmrexZGk8YuAqG5rO5dz+5FH1OG9jWMUhEVaud0TZhZP/wkmDozHKYUm5oDEitSKVw+Hx6tFK0Mbhyjx1Dp+9UK39jrE6tWAbMkDoIkL0p5N2ILhrvV3enc0PKQfrzcOW8CHTAqtzpQretisDX4ovv0xQy5Nuo4Y9SZghX0CA666WHEYqEIrCaVVynckMdXYzsQVeLfGEbUwhg3CAs0Y4ubakBwKSeVWRDBxUbPLm4YhgzQRLyqSWivHU6gCN1pdItMK5Ft104c1BBhmEo29/JLe//ZFs3LiOJtSEUFKPE6TdqK9hHDnooAknn/QIxihjEkujhqSR5VmNW5owq2sDGDHRxMYcdSnkxrba0c/maEkSo7/NrqbsRBVirHBOWG0UL3A9QjWO+Crg4xwh4Ks5qysNq8sNyynSJEVjQDO9NVq6kEvvp6jUognNvnIOAxviLHItDnxF6ashSyO08sz9mKg1SefUs4YYI/PsqJTG6kpL0AI6v0zn1RTwXQZLwuFz/Vmx1aQSxFu6rqpHGKEdrcdeco97/Ay3vOUtbR9aP5SpuexMjgqXX3YZl37lyz+E0TPIzSEH3rCP4lyU1qYAUKc2FqO2kTcrVMqF0hmZZjZQ+7s49Rxl6e+8qdKeiC7VQTrqJkpqAq0Bj2TypTzx2+QEty+c0cs/dx0TTbkIq5MwY0BLnUa+dsNGPS8p5aJpDa2U77m9nzVGgstPU9q/pAU3tks2aEvahxgrRcgN4yxRRrMBFQliXbpjCsQ6oLUyDzEzRAVSDCRNxCaQ5oE61VZ8XardE4wEvNZUkzGlCZ2MRuAC83lgeXVOWG1Y1RpJDfPUQFORvKOZz2nSCk2thDQm+YraWYRF2U1aheiUKikzVdhTQzU3lik18BRDjrC0tl0eADEgTY13u/ArnmtmFcvLduQ9dWJlZzCwFe2z1FeY5YEmWmNYwbzsxlWKVOtYmmxk4zplPN7NHpbZudyA1NatNb/DRe9KykDDOJMcHjdyljs7hooR3jmWnGMpNLDUoNeuMq9mBBFUKqSqECortKNbSJwI0UNVjXCpwo8EV8Fk7Fm3Xjho7Dh4506uH13HjtoTK4eMPVJV2ahNOK3xapxOXirG0UPlISjqEsFVJGdphlWhsCW1+beyBhzYJHItWCs1BIXNte2c7nL9Sn4BcXFaFd89iZgZrV3PEZHHvlhKGSWFq7AvFVanQtXUn0+qlLibisu1DKU3RdYe2l1XO/lbXFEmafZkiLcFmJIuYR67cu0pCWhujJWHhWRAUs5tPxnMuW4Bl16uqaD4qC2AESTXqwhSuRwFTm1Ea5BB/qeL954N69dx8CEHsf0WB1PXFsWO0aKZ5oSsrXjbQeWFQw4+hCWUKYkN1ZykkV3zOStqzqpU6N+zwyulLo2prFGQcm2XEnKNltW6OWuGqwnnMhDBopyNKE4jo9DgtaGaW3pWqKOt4apdDUhhtdJ+tWofaJQ1LQdENTs4nbFspmykiKuMEn4yAe9p/ISkUKeGoJrvKx9VadNy25YFrlOPUvQv5V/XRoktm8rAFsnAT1JbDXFVW6vXl9FoxHS6xMEHH8z2W2xv6xGN4tzsrMK8GIHdu3exadOmzlYToWkaVlZWbqLRNMiPUg4YaMQ8yCjFUWKGgc/51JZ3TjsjHIZQA0UJZJul2C/QUsAWxyiRTBFbcr97hndxJpuN2CoAyEgflykqM7sQgkiytKOeGO2ng0phBNJI16nc5YiIZppcEqLJcuWTMUrFfHciHUgqXli7IiFqVxgqdJ2FQXEty1bOkcdAk7pSvFy+VytuJbUelpisXiHEAPMAkghYrUQMgZTTh+bzSJ2sa7cViOf809gQmyZ7o8v79FTiqNZvpNqwiUpnoCvENCPUiaZO7KkTsyDscR4n4FUQ3xBHMxqd08RIHaEJkXntWPYOLxXVyBFWPWGk+HEkaISpQhORTO1nnnhyRIx2fOVfLXWsAecis10J8RY9C0FpUkJi7tytHSh1ajmo5DFG8Y6r0Zhq0+AqcFFZx4ytDawPc3Q0ZyfBiqPRbExrG2lR1ZzWZxEAMGXvG/NTV0EZjUe4KrG0wbN5usTsoA2sfuc6Zrtglr1lThucD3jnqFyOAuZULO8dMVrxuxcYJ8W7MUsbKg45fD23vUYJ1ylXu8CsaaCZQzXHOcGlRJUS1bjCV+CdZzyqSLJEGkFaNQAgTjEeXd8ayRIz1a0UUJ+9+3TvxEZ+XliKza7SdrsW86cRcTkbquQSt24JFCF5W4Q9KXvCHOoN/JaFpQU2TtrC8TZLqSeW5WgF6aU9J0qrj9pmg23EMF+HE7pUUDKYMaDlpHxnzgZ1BiYS3spwyhjA6nFsoU2doyXZPCHl6xXXgsnCriVYDrdk/4nTTHOs+an3uPtLquggg/xPlkMO2cpDHnw8jKDxgXmsCU1iPtNcJK34urb1f3a92QJBGFXmwNF5sPk9DnhgRCF40ZzGZOtoCNqmNJXaDJUc1ci2gs/6z+ORqTXIqpJSeZiOYewTIxrqaoUUG2Z7GupoIKOwWBnIUWJTDKBCZJFXrGTeHMlMOpJyOqsTxCXEKW5JwTuq0QhfTZlWI7ZsXYdWIyQusTrfTT0L6HwXmgKpX68dc4prSSjNjhBbjrK7tnQad44U7LOIMx4U73DR44pF5zxuMkH83mbl4Yfdinsf+7NUFYR6hQJpjHLenJtWE2mR4iOOuBW3udUtcZp7lFWeyy//Jp/81Kd+KGNrkB+uHDDQ8L1IhkgxPBYX6sLS0vLAt57gNTi9rJm+sxzafOQeLjDj21C1RUdypEJKbrhmrn3N+eQ2KbpiSxYPCO2kUbBVPXVFn4uBCvMyqMQWXGjJV3TZ89vmkGv2WJq+aHsFiCkK9cY+QwFcxbPqte0I2p5YyfSbRq9HsnxRAxpq7FEhoLGGlIhJCTHRhEDUJgMKK4qOIRFTJGqweo2Qe1fE/JzE49SRJiPSeCNptJXITlJYpYk1NUoTErIq6AiiFa8gIlSuJu5ZoV6tqetIaISUEk4S0oyopiPGoxGTUcVkAn4UWJ03zCWSYkOUzM6TyKwaJZU9g7ZSGJzfhQYrrNOYx2E2wqw2ZWGIYfnvZdf8ZTbUVCCGYEq3qVmOy3gPe0TZ5ZRmTmsgZodyrpWw/N82WlWK5HIHPpXsxQqRUVDq5AjrNtDMt9H4QKpmSJ2QlDnUIyQnBClAw+HE46uKmMCPEn5mlLmjRpnMR6ysLLGyDZplQebWYVzT3FjGXDSjPUf+UjDruFpfsWU8ZctYudYr18wi8xisSaKANGbMJ2edzUHa+owuFpHya7Hme1YDoaScp1w88kIplsypWqWQCyj5xZLfp0g0A1qwInifcv0KtHR2JW2x/2rXTGd1th4X1gmVlBesUglS5qm0EVSLmuR+IOpyv5HUqgfJB7Zgh0UdRK1rjmu9jtoe2mpsuvdYyBv6pBSSQZelgZlh0da1iKXRteNazEsqLb9yLrocZJD/weJEGI8qApG6jsQ6EptEE8m060rK3nHXmP4SKqJUJOfQ0RzRgIhRvvriCJGchlyccslqPmIs9WiptTe0l47tnFHq4wCP9b+qlPEYlrww9o4kFU1QmlkuMi9UshnApFJ4niyK2rl0zDbJ6iBnXmSnQxLwwajPk8cFJTWmcyoi00bANayuS8zjKsQZGho0BFuusmbsmiun1klXgEYp+ibbVrhkKbz5M1dYfiQi4lANkBwSm05v9d+dc4zGY1TN6Vksu1Seo+uea2EKrHxF6VbmvGPLls3c8eij+e6VV7Jz584f3kAb5CaX7wFoFFvLvLht3nqx4VxmVFmwmmkNC8pEyTDAqFo1ZyjkAZ43IxsErTc6SUm3tr5dGRn0bZJigLR+vzbysvegV/L2paBcaFmzSq2IHax4tQvAsl+KF1NbSi0pl93eeinmLsxairbZIGZc5e1ynnib6p5KvYuFdFPKNRY5pBubSIoBzRR5BjQiTYgEzUxTwaj6QhMJKdJoQBtTNCEGQrJ0EPPKOFJ0pFQTpjVp3hDngXo1MgtKqJOl+Ew8xITGAFpDqAm7G+a1NQCMyZsRWgkuKCNRxlVkulFYVyk+NgTfkGYZAGVvjuZC96JmW+Mwv/tisCnZy5QVcRlXhQigK9g1Y619r713UoxMSVaaIpLYEwPzzMJUCzQxR8NUW8PP9inARvLIK8o6G8NRaFCYzRmxQq2eZlTRTDyh3oPqHKHBSSJh4f6YKXNtsXM4V+GTAbBKHB5PNXf4lYZqusKeXbvYXTvquYM4w84YIQZSHUm5iaA4R2w8GiIVke2blaO04mvzit1hzixFYjCj3qMwtvB7VFt6S7pOW7+xOLPyu8qLhJpJbxFMaedWIa0uoLuNnNC9ixIV7GZIrk+iK+FPbZpCSTtc9Ozba5F8nZLHUsdIZ/8v74qOgrodZm3lRussKNtCzymg0p5fW4NAF4obW+CUn0cs9RftdWv/wHZWsThOiRIlLeQZXcpXi/kGGeR/tFgkOdWJZh7tJ0TqZOunV2siJ2K1VOIqZDQlVkvEaoRWuxGdW3ppVHxMuLLyxIYUIyE0hKCZdrawO+ZCc7uETAAjaBVhpGilyMgM5tFImU4T60fCpKqo/YTQOOqZRTNiMLuJVDqQW5NAohn8ZbXLp6IYIH3NWTyijsg4KE6N5tyPa8apYsPKHPUVezaN8bNVNKxAPUfrkPVrOUZe03IDvy7LuKSB5h8niHckZ07GKEZ1a7V4xr5FFKtBbEZI2rs7eMFHGqXLflFbi13uMWSaXnIdemZglKxjo3LI1q1se+AD+PRnPjMAjZ8wOfBi8LKQQzcNSvGjyznrKQ/hFn30FnLFogc5/YrsybaBbiBFKUCleAMX3NR0XsSuskPL4l3Sn8rV5Tzvtui5961N4OKW6H7tp0DZ0XPedzZWXDYIynUU86ZcXRvEaYFQj7Y3/9uyhpJBhRRAJa2XQ1PK3n5rrpPIKVAhs0clS5NKIdGkRBMsihGi9c5IIaBNIDT2eZMaNNZoSIQUrTeD8Z9abmSdqFf2UDUOv7JKWG2o50o9y30pKrPyYhMhzFBW0WZGmgdCyA2OcBmwFfAVMI7gBlJC54HYNISVOaG2Rn0pqBWCd6+t9wp77zG/oKS5mJ5c3dJ6ZNo3sDhGpNThLnqY21obMWN/Lu1wNY80xkzVqnztQtrlysoItFQtyZ6whOoqs5BYrRuW4wqzzTuYL88g1RS2pqjWj6XNBW6BhtWyJEmoeJRAajyszmDXDlZHc66rK5YbT5OUmD3fSZMBS28pBBKiRbDmgThr8FKzbjRmXC3hK4VmjqZobHGYR9/60eWUInVIoNMOKi24z/yrlELq9qmUMS/Zwy/dsyrRCSnvQtqZa9StWoBcAYcZmLRW/8JJFkT7XoD2PXaUtyzsmpF+ayyUYaNdbUpBqNADRx20VEktKOopiu54GbyQ061y8Vj7pEpjRkVa5wZ5iHflXz3g0+qU/gQZZJD/OVJVnp+978+wZctm5o0ay+BqpJlbn6gQsiMipxW53ExOXUWSdTRspHZTZpOIJFhe2c1ME7OUWJk3NE1kPrdsgBCbNnUqxkTpHN7ZGbY+RC+oVmhKNLUZ6zIGnDJOymjikKWK+cqUefTMfE2gsdTnkIhRu7UzlLB+op86VWwc8r8LUCNYF/FaA8k5ktT4iWfeeIIfoSuencsjVvbULO+qCasz63VR8rBanaTGqlWWWS0wJMepcyqtRHNgiQjOudy3yNLVKx+ZOaUJ5nA87NDDOXjTVtavt35jKyvCaN367ADKuq+kI5OdjfTWjWQgI5W6wZyHmpLDOccd73A0t9i+nX/+f//Cyurqj2AEDvKDyoEXg5c0JjXUq2CWn++MlQ5k2HruxSIQNqY1Gxs5ZNbSw2TjKJmhGrtkfZCUjcRiFFgKUixdfyUXgybNIKY7pkoJe+5jgS6TyuVVvOSZC23udWtHxI6RSqDt0tkZUHmC5O+Tg9S1GcyXnffpR19aA8lCrirWnC2RaWrJoCAEktbGLBWjFZClSBMtktBEo8ozpWVgI8aGFKy7dxMCTWzM0K0TjSYiinOKekWdMW00O1aYqDKJAXXBOh5HJVaREB0sK8wjKdWIn+G1JrlgbEDFM2KOGkJIzLzlgzbXw6pGCA3L88BsuSFoQwzmvdVUQGFh9eo/36wIy99SivULmNDOSw2Ul2DGvOYi2t57gNbY7+w2bQNu7TGcLNSLlHefD0D+qjW+UwYyYCxas9iwI6xSzxxh2RGTs3oI7wGPJoeWTu65j4YTZ2xlVQKpqCThfMXEjdikgU0rK9RuzhW7HSuVY9WPUDfKnb5LlEQIJCQYt/vKPDDa2fCdq+eMbrWea6gI6vFgvT1iIuVIZAhCrMSaN5Lw0ZYaV3J0y+QqxrdCqSWPkukNUjaMXWojBmXOO7XamcI2YnnPtq/x1JdxYC+5vGZ7Ymvf4uJcRvK1OHJBeb7cmOu1pKQt0ToNyiJn4Ea7Ra6k2GkHJ12UFlykPEa0OEuCgUQr6+hcMSkDGOel1JW348ainQVolB7pRZ+Zbug7JIBc2D7IID9eUlUVo6rihkdn30QuW+penxRxPReeooxGI25961uybt16ZiuB0CRLFw3WpDVFl+s/LZbo0NZzn/BEKgIjGmeUrbUq86TMUmLeREIdaZqQswYyuUgyh19S+70lKMl+y+RKbm0kZKDgXMQ7sTWZhPfQJEeThEbJ9ZXJgEzud1UK0HOKR2t0d7Hu7vn1o61WUuYIjaJi8eM94gk40kqEuWNlpWZWB+YzS5vWpMQ2pOso2R4aS8oq7fpLji4457KjqejInOKZBOdLKhfUdcCrAIH1Sxu5xUHb2LJF8F7YtVuYxcRyjLQQqthm2v1dUq5ELE3daQY5dHoc4OCtW9m8aRP//oUvwgA0fiLkwIvBU8rGVLG6nO2t0NFD0noLjfYMXHRmgErxXtIaB5rrFSSzoWlOzQL7PmcEtspIMhBPbRF4/jEHhnkxS4RTjI5NdbR4I5INC1esol4xuORby95VM1ozBlcrmJVR78zlUkvYL6dOmJGR60ByXw/Ko0q2QWGPkyhIps+LKVrEIkZiMgUYktHvxdyMjyYiqaHRwGpTohjJ0qUaAxkxWV+J0CQDJLHJNQnRUq004p1DnUfTmKBTdJPArKLaVKGbxqRxII32EHesEpYVrS2S4vE4nVCJklwwsBEV1YDKjEhjynmGNfDLBmTUSJhHGgJk5b1YPtEVDSvavYPy3MrQK+9FaL3Wxbizc3WxhtZabVPkuiiF0oGNFtQI2aDsyAjQktZTNpR2fBW7uIDUhIX2I8I8wi4fYadAZWlQrniEMCWvyY7rRPP7SOYlIzHCw9KUyYaKzVs2snmyhStnm/lOdR1pz3WkqsZXgZGDikSURBSPqEcqox5ebRSaGvedPaysKrWsEmLAhZoUaKMapIqIh1HCjwIjr3g8JI9UCbxrQVsxiCVZLYIVzpuFbIDAkF8qICMD8VJE7pylNaQkxGQODGMcEVL0qAf1Vk9BBjuVmsHQlYr3pnNmuGsN/PwjLveqKTVbmp0PmZlBytzvo8hW9aQWVCQcFUbukJIaMHJWDFkcBsmDx7WU352DQ5EoaE7QKOXqRlxgetEVJ4qTDlhE6Fj1CmAegMYgP35ylzsdzd3veheakmJaFLoK1lVa0DRCkyeFiuQD6iKV1jhRKpds3U9Kyiv+xpFjQmRJG/bUDbMUmatnz/KcJmHpv7E2xsMYaTAWuFFyuJTwIiStUTcnxIba7UbciJWdu9E4Z/fqjJUmsFIH6t2NEagQLHoRDVwYtXps52u3FkUQ8E0ixTkuKtSR6CpCMyaNPOMwoponmCorElmpIyvXrxCW56TluXUBz+fS7Fxsjac811Vbk7yb+tk+cYpRazuxiLer0GrM8nyMqysqjUAirQaUgEpA62BewFHIellax2oHbnogMHuRnFjvDMFlp5PDeas/TcETR2qAauZwjeBDYGVlzk5JXLs74r1FTLIXOue+k1sHZHsuOxu7prAWyfBO8DkVuKRpJfuVEOKgEX+C5MA7gyclOetW0SJsR4n40WbYFxqVbIDZGHYtw5LmfEpcF+1QMrOL10xJm0p2VbH3O+o1BYmAFLOjoAP7vQXmIqj4vddnzSxYmMfCqrg6v4omzWlcZgR1nKlmEPnML5dKKVkxKFLCab6PvI0RSWRvRfYKO4Q24VwEGqsz0BCtE2kIRA00WH+MkAu7Q8ggpIloE5jHxgriSrF3CoRgufpNbNpu2SHkZnapIdbWa0OTFfMGKiqEjZumbJx4Nm2p2Li5Ik09ewiMNs3Zs8t6c6RiFI0c9fopTZWYzWuCF6JTtLHajVS8/CI0sw64qSqhVZ4p1xfvzWrUIsU10hKPaf7JHmy619Ntm8dD91GnQDvHcBeaLp91hl4PgWgPmhT6oVLIU8Bz2VYK6Mxh8ICtCrUQxFlhWw4Fu4yJNZnxreJILuE14VOFkwRzcK5iy2Gb2H7YrVj5j1tz5a5LSf5aq6WpI43TbkxVI/wERi4xmcCmJdg8rkmpZsd/r1IvOZrJiMQIgjfGrlHMqQfWEwRtEBdwMkZHkvNyU/baW7GlrXZlserNv9Q9515DixyFso9TLAuLGdZVD/hRuZZKupA0KGJUkMg+aRMLRmjPV95lSkjjFgaDVHkAZR2l+bgGnMr7BuvLYQxnTrxdRaGeTWJhmKIGPUjuDKyl0LNvOCwUfZVBLIsFkCn3JSnDznd6T7Qkbg0yyI+PTMYTbrFtG4dsPZil6RJVdpb1gUbplyNpjKo3J4qLqEt4GeMk4V0iRYiNUccKMK5gTGSSoBHQ6Jg1Zo4nFesNFWPLFJXUmKOCgyalnAYKyWXHmqtxyVPHGZoamiaTo9TB0pBzw9u2GWnqUqZKpH7tDLSU19DqeCcepaGJjplUeFVSUGYSmTeJZmVuOrtprHZLMaCx4PqiUxvl031M/axCDMRZ9z2QEcgYcSO8n+d1K6fVpmRKNyUIUJRXnzWzdc5J7yJ6aZ65bIzSN8yyS4TC9ljSk31MiARUlGYWiJKwPFy7Xqqib6XV6SVlq9ys5PWlpHe58rnL9YA9e22Qnww5YKChTkiVAQuJ2haBtkWhC8uhLaDWXy7nYMduzU/mALUUDiCKGdvWbkZbPmUolLlWtCqKpUkJPRaWsqh7u0byJM3pDW6N3WrHoK0KtbBdzBNX23mmbcGStPNPklgTu+xmsGY75FxCS5cStZtyuS8EYv0djLbXztjO5Vz4ayxIsWWGiI31Jw2NAYyQjLbWaGxzwVpTumqboozJAEnTNDR1k7dNOeLREJLlokqykKh5ExzNBDY7Yct0xEEbl9g8hbiUqETR6z2hnjBbishqQEdK2qjUGyPN1Y01PKotnaukuyXVzKCTn1sOHFnRK8SSqSm0Sqr7SUgq0aqeUdnTtuVtUx5vfqclqoDk85XKfC3DUbqh2dX1df8pp+vp/Pb0rRrWtji4FIuj1jhJ8vgstFQWcaF0krS7k2hAIxvZpY7E5VQZhxCjATqZCSyt4pd3sukKYfuexDVpGcfVgBprV0zExhYrp4qbJMYxIWPPeGPFxqURW6uNXM9Grp0vUy+v0sxq8IGRCCPvUO/RRhmlQJUEUUf0jqaqLa0reDzGiGXlG5by45zNRcnvtb9QWApdZnnKa4IGmwPJ29yUKHi19MogEKUr+Jbi4RRyMWb/9Sy+HHEWRUKlR28NguvOX96NlqQMzePTfkpRuxR3YUkXSCw02ZMMLHrrc9YLpuwSnW6SArpyjnOZ7yUH2miis+FUnC2qPYgibVqgE+3PhkEGudnloC1b+LmTTkJR6qYxhia0l45sc9uom6N5pccj2kqtKnuqq0icJ0KdmNeWeqrSMCMySyH3gIhoY4695B2xDoSmJurMKN9raxabPDRizIeQOk1RQ6xoHV41EOpMEU9jVLGR1rNv6UyKZkBQlpEuBJ51XooIDVFWzecws95GKXhmq4nKw55onbnnu6Idrxy7ByRK6m43x4uhhJ285GWXBa842XItivgK/ITxaB2Tasym9QaUllNgVgfivMEaDSSLJJRTpP7SWn7JaA+PiJCMisOcZF669FBvzfuMXRMq5xiJsBQjVNHaB6zUpBgIozlWdu8thdgZTZcgViuKtnq6iBPBe0jJMgGcKs55I5tBwMeF7Qf58ZYDj2iImEGkqZ1wSY1vpnBKlx/KQo601I/9MdE6OxPZuM91EU6z81+MM5o8l7LFWnKvW2WlxcGcULwh7VYzaGuM9s+tFCd4ARDdJ+UOHFaIJE7bInNBUC9WqxK70Cb5egTfGlUd85Z2s7o4CEQ7wzhGy9WPmfItWFTCCtKMUSPWxiYVUmqBRlOoaoM15Yu5oV9oEk3TEELd0dvmYzaxoQkp1wOYJ0RRUoRGHfPRCOKUaYqEukbqRDP36HRKNZ7TlC7kM+Mcb/ZYcXesjYJXckGtFbIXL3J+T1LGhD2TfiFta9cXENnmpppWbaMNJa2ujKdy/GzDdfU55UUXRCnt8dpaH3rHXPDiwGIRcc94bu+hy9fvVfX3tmmP1IEl7e5IVfKYNq8QpWg958u6nBvmKkc1m7FnV+Jb2rB8/Ywrqh3s3pNIwepsjIbRFmcvER+VxiWa1Yr5csPqkrK8bh3z+XYiVxLTMrEJqFNLbRxNGIWKcYwoEVUhJPOQSbQaCkmJpL7t69H6wpTWY+B6LHRgc9cpOXKnmZUuP9KUaGut1DphKzlVSlsY0C3q/WKQfSwspZGWeTxcO+Yst7dEE8lpm86OL8X3mu+m1UOdkU/OE7ZsTGcRkFRqPco4LNRx/fS6DGCio22Q20fTeXu1Nd+ehZDTuoAGXC/b08a17C/QN8ggPzK53e1uxy1usZ2UEuuWlghqZBSxNZ7B6peEQvzixOFGE1w1wi1NcSkgGlBXoyRLqwmJFJR5tCLplASPYybWbdoyHrIN4ANRGiJGQxsKGyPOOny7DPR7dVPaCCkIjMx2aUhWIzoCojkpSn2Axs75VaKMWhaosuZ3f4Joa89EEkGVRhOrlbEpzRslRLs38zjm82hxeHROhTY43GPALItjhwesnlRjAg2WjpvMCTomsuRGbJqvohjLY3ARo8u2Cy6O21KrqP3ja+fQaKnIc35ozHaDqL1TsPXAMwKUagRj71iqRqRpRZxUBFkm1TVNHTFIBy6k1lawwvKYA8xlHbYLdE5yHYg9R6dmjzmBkdI+x0F+MuR7YJ2iLfYEmwSWTqPG9lA2zAO6TSmRwiCjZf239IMyaVX72VZ0LE5mqLX2iWbncPb8FqPBwocl1zq112mTaK3/Mx8rT3CDSdkznU/kNE8CX4BI7/5dtmfyse2Lro6k2I9rbIr2b4ksdvyNEU2ZjrZEKwpVbZPrLEIgpEBQY6gIOaJhFLYNIYOUJiSaJtFkAJJaRgsLEVtUQ3Eu4cVyLRUHIVCvNKzMIqlKjHzE1Q06b5jHhHqHt1puKw4nF57XOfQco+XgS6c0u+Jo6CuxDmyUZ6P5ERaA2D7pLkWq3Te/nx6W7G2+F5gsL0LbT7LW1t5YFe1tw8IBCj5sT9DmtfQGRXFF9d97//iU+dKrCynXUkCpPYC8bw7di+BHnnE1Ynec8I1Vz7dmc3bXgV1YzqxzEeN+T2jMi4kTGnHMQ2B1uWF3VeNHM+YyQ2POQU62uBfmsaUUWYfVdMyRUkWAy5G4fuEzIsUPRamFKYGjjk/EHoTLIC6hufdGllRARVeGU3AKmYVt8QXnY69ZhIvEsniSDXx1veLvohmyNsnvU3Oxf/tNcQBIgTkd6W4ZEKlUruftikMl79SRPPSHW24CuDjA8vZRjeFrYazYhq7UshUAvC8lNsggPyIREbz33OpWh3OHO9yemJ0boTEykBRj1wQ2YcawOiocKg6pxrjxBD9Zj08zXI7kJ80028noZENUmqCkaDn6c5dr2xCca6yGzTUkaYgaM3OfZuKP3Hcmk1d4cTifc/xjzjYYR3CZ0dEXrZwLyrKXsKw5hTbbUqjKkyirSbduKNl3gliKqQpELFtIlGiki0RtjZLFJasPXlol10kf2LSfZSIJIaclZf3siYzxLNU1KpGRDzixqrX+9RbAUbI/8uJjGSDY+3OFkCOnfatkw18ETREhZ2qoHd97qMbCZDomLE1gOibMbFyE2YxGEzXg1Gp9xScbVyWSLdrqZ8TGjyZbb4xzKFqzXm/f7d1haf/iXK4vAXOEpgGk/KjlwIFGViKFNyrrE0hq3bd7/aRsvbQBKiXsUGZKXtRL3bbl/bWuUnIgw1IitDPgk1qdhxRwoV1haj5bnuhrL3pRStCypG9RjOKcP2GeBcvJbj2d+RoVchMfFgyRlpGBds62XtTWRi6GVFY2KSRLk0oGGkrTPQMSanS1obHPcmfvUq/RZJARm9wXI0RjoApWn5FCQ4qJGGL+sTSrBqVSo04VlzKzw5w0WyXuXAU/o6oa8DOktnxWTQlZBlkFqUAl0+5qZsRKitNUTEwcHu/J0SRLLyu9QdoO0dIBifJoisFd+IbLiGkNfmkHVvfepQDTnsHfvXzawp42kiKt0dqDI+276o8S+6cDJ31w0V6FSHuB2j9WH5xoiynyIdecp/d3u/A4hx+PmGzZSBpvYYf3xDCj3rPKXCKVD/jcxd6KFm1MO62IXkhika3VnSs4vY60OZJyeoOp2GRdYVPASY0XM9BjdERNuXg729CW30NxrAsYyPcOrVz+u0xxAwolDckAinZOiZyuWIIfqmKARw2E2yPr6wppgWFhqVorKVmjQYcYilcHzgyK1nAoa2nexEB2Xmo1GwmtLjGg16bLlUEaBVfaoRfmFmjBKkhHagAWNcrF50UPdDw6Akna+7G0O0vVENc1BqSFfUPq1CA3n9zysMO4971/lqX1U+rsGNNYqNZjTjXKa7J3WR8IOvJGMTtaD6MlqLaguhPRRDPbSYoNDUqtShMVZoKLWKQhRzEtUyEhroEYCCurNCsN9SyYpzx31rY6soRES/MZTSqcd4xGFaORZ+Qd02lAJTGbB+okNFGtG7ha+nZErBA80qYY9dep/iTUhb/zRjndU9EcruyXrXUOlLRwkDUH7kkHMroLULJazIQxKYWsvWYsN8YcaBmkym4Hq8GchO0hXL6vlHUq2tWhamlIa5kObZglKyoDk7lHkHc0ohAi0SXmjSLe0yytI7CeZnU9DRB9hVYrSIz4GECjnbfJp+zZjZIdMyLe0qScwye1f6tkkfIEs9wZfZ+MovuQex9zLIcffhgqiSuvvJLP/cM/HtB+g9x08j0BDbOVs4Gdw19Ay4rSHzQFqVttQjbE1bZt0XROl1A0537bjq4AjNw9V7E0Bp9NxUJ31qU2mDFLjAvft/VECy5mwBmabtlqJFNNZuMo5RxxXN8Drzn9IheAF0M3W1qRNTmXhZotezaF3E1ZjW2CYEXdNQ11jz0qBEuBsshGkyMUpV9FzClVoYt2hIbYWASkSZEm1sRYW4+KvH2MOSqSFHWKlxyFEsG5mqV1M7bM50yYEatA8jNGccaGlNiZEvNa0ZEyHplCD01RchFtzBhVEZyrmHpHVUHw2ELQmPc89likulAFC2kj0r6g4hrr7LgFlVI2kZz2Qg6tt1/mAVgqh2TxfOWIbVpK/5AZhJaTlkSpsldrX7bzYhEoSK5NKWCqD7Ap3mxZNB4lF9e14wnHZFSx6ZCNrNu6jamA7LqWK1d3851r5wS/Sij75GN6J1Rpgt8MS1Nl5AMhzthzXSSs7ia6JXBj1Ctjp4wlsV5todqFp05Qp4KppI1SiSipUaLXnD5EBqolAmDpSoVBC8jMiZai1LLNuW7NShhpAgLOA0G7FLnWtAbNBeeuP7dYFIcBAFeAn5fc9DtlSlhZABoOzONIUUYK0ZunLI+TNm0gv1UDXoI6l6+jN0BSHmXa6ZrCoKIhR0dy/VYHUe0//RqWNv2qGDraorcCgwYZ5EcmmzdvZjwegcIhWw9my+YtRGydskh8biabgUZMlifoWlYD7dJzyM6GCgiK5B4VMSSapJnutTeBKmf7JiUXbFmKU0zo3EhRQrBC71LvYCenrQl0kun1PYxGMBpbkbmqUju7xrZHRslqUlqnWD8TYY3by6TnVKC3TXu/9Ix7zMnWpUq1O7XHKs6UtqYtf7/WmG4dOGX/7PgSEg3SRp4VWHVCE7F2AHlNknzMxYwB2pO2frkFKQta/kuTRWkiSIwQAqEORNeYQ4vGCGqikdTk3K72GYikFtvEwnilZGet6fHcOSHrbBsLZi4mQkw4hc1btiDOsWvnrn2O4el0yqZNGzn44K1sPegglEhTNxxyyCHlRtixYwchxn3uP8hNJwdeDB7sJ+WKfy0FE1mJoGJ803TpFG2NREmNySE+9dKBlqSdl7c3Owt7RbdAG1AxWsnUpkVZf4+chpAyh00puhyxEGkBesXgxbJ1ZhmVfHKvaCz3KJCycSHFs2qTWXw2BCQXvJPJipylrneGaz5NVq51LtomWdZiTU2T6ytCU7p6B5pQE6IxZFjRdykEj9ShIdSROtQGItrvAk1qSJRIhnXgDvmcUe20SRLeOarK4aZLrJts5eCNm5iu20CcrhJHNSMPG2aR3XXDLCmTesQkRqoqsSo1cR7QGrQymtzkJ1R+ytJozIZ1q6xOV1ndUVFHpY6RREBT6MDoAo1UZ4B3A65EAvqauTcWeooPFqMGRS/a5wLqu8XILMnuZNoFFUTbPXoKODvK+9dQAIp09ScLV9ErGuxwh7TnSv1zLmwvuag4MK1X2exW2XbnFbZGT/XvieQ835k6wh5H46y0XgBxwsgJOm3w6xqW/ISqWk/tJyzPI831iTBZZTSeUXlh7C3EvXH9ZnYtHcKOXbvQeg9KsL4P0YF6fGPddmMx4EfWvFEzdawPyXrDtE9W8mIZwZfXm4utW1RV2FzEDP6ysGNh+eIZtMJoaUP5qGSgzoLk6qj8P0vWQlOuAaFdiJFknriEVZ8XdrjCYKLJDPx8HV0Kp4X3DfpqcVR2pSCKfaNdhNa1dokVepdu9lpOlxf8Eikt7GnaHrBQN2o3LmWNIhtkkB+i3Odn782tDj/MohYKcV7TaCBihqVm4z8lYzYKVhZMhTe6brCoh0ZSWEanAd2gpJ3LsLpKvZxoghqb1FxJc+1Y59YBIaGrDZpqMzzCKtoE4p5AEyN1iDRNsmtz4CrBV9Zo1GmicsF0XRWZrndM1gnrlxtiSsx9oK4DaR6ItXUEj02yyHDU1tO/Fl7sE+y3a1i2R3KqVealsMhwP9uBHOzQnn2QTaN23clf9BN82nOXNWXh4kxvhMKW6Mn1qp391WaHuO6GUptjXo5fHD59p0j5UtpzxahochAcKa0Sqkg9V/x4hTrOCNOJ/cxWiU0NaRXRhM+6MKEthXD7O1hqOeRaDGesZOoQZzU7zqn9u+oYVRX3ecD9ufbaa/nk31+8z+jGbW97G44/7oHWkDBZ75WDN2/lIQ95KJUIGiMf/MiHue76629gJgxyU8iBF4ODMbCU1KbUTZRSM12iHkoPW6TWhrcvXKK04PLYr+oMbKSI0eVKpHBqm+SZGI35SvIFdN7XghlcTg4vM1e6dJ0ixXmspSDJkbzRsaJqxUrRrsvmZDY6imHq1NjkyJ6FVqPktJzUTWZVAx8OjG9bA6oBjYFUB1JoaFLDLBh7UGwaYlMTgrE5NZopbGMHMqwvRqBuGpom12pEq5Wweo1MYRusIVvMObRGKWue1xRAKiWNheTWMfNb2T3Zglu3AbYpMaywazfsnCdWQ0PY44mxYp4ZP2b1HN0TAMVJha/GeFmP95vQ6TrChutg18yavlUOUZe9taF7n/lfG0Od1jVlzRrksPD6un2gBalKZ8yWdNiuuC6/v6zRe0Gq9pj7Oo/2rmnf17CvHfNAL0glT4bsXO+uq8UiChh9LGBAbB64fqLId1fZ8akVNvgR1Z7I1dHDSGAiME+k1Nh7xUHlYDmwsiuwc33FpNqApCXc0gpaL9PsqYnjBu9GjNaNiZsn+O2bcXtuTbXyLULaSaImBo9EZ7SSUyFJtAhBEiREoxh0Do3Ocl29tqxrgukFdTGnGrqOklItD1fLhBDWOAEsTcLyjlMHBLQD+b73jtu9nEUabCxo9nz2IpElaknXfacQMpiDAfDWBFPxiwZ9fpWpzPc+/CgDoD1NKtxUrd4qw9gcqHlvr7lI3HSPqSrTMU4Vn4ELkVJysr+RNsggN5ksLS1x+6Nub/NWlQ0bN3aGdiEiSUa5rskKDzTkhnaaCNktL+rQMn+zgcfKDKcJP3L45VVktSYVZ2GwlMHkzLGQVJC5QFCYB0RqRBpL49WASmZv6oEBs96tNtBFM/ZDzNeQEm5mKZY6s5TiWbAmds3M0n9jMoINY5HsrQ89J9eCP6m3IiykevZkkQCn+13R1qHVHlnoHGrF0G/9YMXB2XO8LVyC9I6f18TUW2DabfKK2ffUtJER3ccd9L/P52hpZQtDXkKDoJqYqYJ6du+sifMRcVbRzENuRhja+0pqa2HXdT21QMN6LVmEWkUzA6A3p1apd0sRX3nGktjQNKw2ZlMctnUrhx98MCHbckE827Zvzyl9ZBeUZjs1GwZrF5NBfmhy4J3Bsz1TEHgZyAVE2ByRLuJvDGbZSwiIZFIpX0yjjilSSyfmXIyavaClILwMCs0DpCB9y+1WXAA/worF8lQsoGdN7WhLGQnSNctKZqSkbF36bj5lyRGcJNZcULqvNBNMF/NCSUjMNSyq3fNIGcuHSGoyY1OIRn2XAqkJFnZsCuNUQ0ND3dZZFPaoQB0CdROpGyv61mh84jEa+xS54Del1DYgah0TzmWyL0WbQAoz6rSHPbLBIhw7lbAa2L0yZ5dvWF1KhCoQV2ak0ZzoE416qBwyAzcS3MRROcVLDSI0uxt0p+BHiq8iotEWjpwmRwsCikkmZuC5zDqSDbPWmO8977JX6RTaFhT3Xlep/+mDgRKSTnQunVb9FjAg9AzUbgwVLd9dS/6SdteF6ytjpk2H0j40ouUkL2NMSrV0KajXyM5lZfWa3Yx3ClNfUYnV5CDBuoc3ttDHlEil6KFqWL2uZrdbJmyumIznjGNAUYJLyDzRVIHJXEi7a+T6GdXWGdVKTbreUhmSM3+6OtAmkxCqIJWBDFFITWO6oDJCAYcj5XQ83z63XMslslCno0GMS70oebG6jvYd5bEppTA8d7012NJxqreSEqRYyOHyey61EXSF3lg0ImJRmjI4igFh11peTq5EE9MNpVKiFGi36612wEnyyCzvv2OMsRNYmmZJqdBck6JWnIjpruIJTmDgrgBvGBbFQX6osn79eo499licc7nY2xxbmg1xa5JnYAO12r0CNKJCxJSDeJdJDlKrb+OeGb6OjGKCOuCbBp0mS5ltsgHoEzE5W6tmQKMwj4ivwc3xNAYwxEgwjHWpM85VDUzEaPMreItqaoC0AvWqUoeGlBIrdWA+jzTzSCSasRugFH5rb/2BXoZGlm5adyCjfFbm/YLG12Kz6172SP8Dpduua5C6xhSht0b1lUzZr1zXAo5pLan2+7WApV86uEDY0t5H9pLlf1P+zqlan5MUjNlr5kgTIY6FmHKyuzcWMJxDk7f1sGUsK13JtdXXCjhf6u0U1OXUaCNBGZGYuMT61Rl7ZjMAbrt9G/e/051YHXka51l1IxBPXSer/ZAMjNScv+IE1biQ+jzID0++h4Z9ZcE2MaMrh7+y91J6sb7idSj5ggAqrozOtkgUpO3Wa7PTpmjnV9T2s8IcudYlbekb2WNYkL/maMaacVS6QxfmnGL8GgDprI/WAJHUTsbWcyDFm1JyyfPclmLkd9eLQohWlxFUc+SiUNgqTUhW7N3MrYlQ7p3RNJEmBeq51VhYilRDE62mo8l1GSnnzFrjIgMXpeFQSzuYQRyZBcQuNntx6xkh7GYeDma2CuMaY5QKjTEVzRLUc6rRHD9NxEpRcdQjQav8aLIHRaTGpYhPgTgBvKIhL0ix4yQX6bPqGLeYeIcfCVonXCg9lFnQgJ1XSTqEG4sWX7D2WwhT9itAuEXKvfG3MET2ATLp/5lBRguQcl5Q+VsXd168h8JI1VsnigO9DLGcVGhjZs8egp8TnKfKnm31lsqUQpe2oCr4Spm6gPM1afcydVTSuhm1G9HoiOgUFxNi5UHM5jUrO2akdctMNzaklUQdEyF7GJ3DFoYSWdQSOcwNAkeC876d8yJGyZZaACnd/aJ5YZGWFaadH06sd0oBW+0iqF2jP8n+qHbB7kRTyuSL3Zt05RrWeBtdjkYaoui90ezYSNkZYnpOctQ254i3eLSA5QJGUnus9nQZNHY2hM2P7pTSDevCkKV2j0md6dPMitM18ltroQwyyA8uzjnue9/7cvDBW7NjKuSaC4scWMTcIgQhBqJGSLEFGlGtTiLmUL6kgMtuxKTZvFhy+Ohg5pGx4NZ5dOMI1Ujyq6S6Ic0jsVZSdGhjzgPzB9giUwkkiRZhdYr6ZNGQBCoNSCJJ7IzgRnHRdB1ke16NvKSpMx28dmtlaXtV5rntVPa1id1CioL+i1rPm/fLEHvupm5N6X231qRYY/cvAIdCyy50TplyRe130u1bjtddg7ZF4OU/slanLKiXxfWruyZZWGpFLXVdSKwEYSbCilOYgdaSs1cyHa6IEV3k4jzJCaX9Oh4vxrjnBVRdjlSrtRUQb6m1DsbrPNVI+Ng/fpHrd+xCVdktU77jNhNmq8ZmVuUicufwYk6cqGZVJLG6QifCfe5/P6677jr+6fP/mKMvg/ww5Hugt+3y0QV67DkW8izmWFd3WxBw/pVi1GdjytZqytrcN9idZqDhbD9NBSDQep07BiPzvhpJQjY3tDVv9rZM8jHa+pFyta2dKgsTVdp7U+sC3AP3PYdKd305UbsAIk1W6NYE64cRcx2GRS2UJiYr6s7dSq0Y3P6uU8zNkCzNKkRjoSr0tzEzf2g2OJNGUjJQs9B0KJWrNBVn7yijtgShUeZJqWtoXEIbo0yVGJGZKe/pyDGdKGmkRC+srEh37y1DhRVsVVMhLXl0rqR5ykaxvVBj9EqmNMQKZRGPd56RC5aHL9oCwIX3ll9U26xRyIQEsvCeSw5rv/RnL0XfG3vFKF2wC/M2ogV4ludXBkoeLboGqGSw0X6ar6PFvNJdbmfuam+BK3NIiU2NxIZGHElM8SbnAW9e/GReIcQxQlg3dYw2VTAXwmpg3syJ44ivIi6nHwgVMXlmUdlVz5nMd7E0mlPnuRZU0VxsZxHvAo4Uq4aw/FnxAjFHO0rdlBj4dK4dDq3DQCQ7AqreQis2b7q51zXnK5GJEhIsQ3ivgAYFlEperLq4QlvHo6YjrCGgWNRG6b+lsplNc5d1SbvYd0lT3aDXXiSjaMWiOzpPxV5l3IlS3tMt2O0QMMaY1G7aOWkGGeSmkspXrFu3BIDznlvcYjubt2whNZngozit1Gr8ujVFe2tKFy3XtlllMsChnpj1omTSkcyKYhHwqcNNPU4jblqTtLEIrdraruUcKElM50Xxdi6RlmCibA8xOzU1d+wGYg529vSG5u1CkzD3ROkvoXTT3WZzbzXpKZ01/66x0xd00xrEUepYaT/unaFfnNj3RO31q7b/9q+kqMrFzXXxErrlP5+zO8IiDur+WuC6WwOWyvGLMzeoUfuG7KBBBHxOhSJHdMWq7syWtBdTQIbSrdfipUvxynZDclhzWcRoi0eO7+7Ywc5dewAIUrEqU1Ka5fEY8c4o3y2aYXZFsSEtygKHbDsE7/0Q2fghy4FHNHxHFartICkJDSbZnwj0B7KlPBUCCWkntqU3GGmNtuxDZGYnV1JZCurteQQV2tVYvBkbxaiRDGZKoW5aY5mUlI7MdWW548gie5BmYzwrx2I15T6Y7Z22PWNcd2wrHi/PJzdXCxadiLFjkDKgYQxOTYgGMPoN9kJDHRvqti+GRTWaxorhYu6TkWLKjD+2OGiyXgkhRzZIhQaumLFqF6wOYQTVFOJ6ElVmFUlogBiwyd40qB/j3TqWpCH6VSoaUlSL3FT2IMywr3DjCdU2pZkZQ4gGu56EGJ+1Nwpi563Ii8qDH1GFET7O8MTCFWXPtFjnRVsWliilR4kKtO89/xQLtzUW18q+jTgLqeZTKS2ybH3z5STFSOzhjnaxKlq5p5xtndE+ojUprBtCmx/dUp8KhMzoFsU6sCdvPVatwZQtxiKW4jRZP8Fv2YRbqQi7HbMVmNc14+kyE1GqpMhkCcVTM2bF1VThWlwdoLHOrVGsS71DrSATzGsvVa5p8vbuggMi4qypUqZyMvY41zkUXH5QiqVUuIpMrVtyoe36XQYiWqKjmow1LlrBOakA28UFQV3ZJzsYRIwRC7V6Ee2/T6EKlpXRHaD/LnpFkwX5uXztApLzfdvFWS0aV2L+LZ21YiAsj4F+PY4Ui0SzgdGLjilqhfeK1ar19IoMxeCD3ERyi1ts5+QTHkSOoeFGjhiNWMRoay3KnpJaOmWyQuNYUnSTRT1Sk2F+Xs8hOw4Y4xIsrauoKlg/cownjvUbPEvrHeOpY0/lqDXgNs6pdU49M4ATQl7a1TIOdFwRxhWpSoQGZrWjiY4YohHBaEJizAZk5xBIZZ0IvRvPOifSFSCXHhNl8egb8QspRt1GJmsN70V1v2D4F13el34KVXFE0Vsa1lote/3eXWRvzVk8t6xdZ8oFLlxkP42q2DrSeTtaT1GHVfoGn7Q3kp9jpLPVUibzyZTdUmpZ7Z/2UvqR4JJqK9lWcMkTnSDiSa5CG7MzxtUiOBCmOLagbjeaZubgFCW4aGxckEPdBoBG6nN3ejVin0F+qHLgNRoCos7o60gtX3Sx6YrXzwaO8dQ7yXWPvYKcMlxLCLD18OWFvRh6lsIsbYQASTYhE61BQbmG4umgq7+QvMKvxamC7W8e2FwJIiDOgViTGLvWhKgHyS3vM0NDp0CkBVxWk5L9mmJ5iwYCoqVCJeuX0dQNYR4MXOS+GE2OcDR1zAAkEJqa0ATmoaEONSnUxv6RKW5TE7Ky1+y1KZ6Z2M3a3IW0ZFO2YEMTKiPwDhlXjKcTNmxYx7aRZxQiTiPzkKijMvOR+byhma1ndboJ3Aqxbli5Xql32b1WkjI4AHyFbJrAbRP8RySFuS0EGFuEH3mqyjrMi/NUY8doaYQfjwnLY+o9kURN6b5tOC8Du/Iuc2GuJIEmLyjZ+OsNrzW+6mLoQx90lLFSNq0EKifkZrUtyCiHLptrd1jb1dEp51YJ9yxM6f4sitoAdGEjLCxarkvNaYGNEiWPcQWCGPMLQO5w7QXSVAgbp1RhA6OJpTQ1oUZ2L9M0Owgjz5L3LI0n+FHFZGnEeplT71zl6vVTZjImicdLg5JzsQVT+jHinBkcMUJIufBSjPcqiZWNIIrEHHHx2jJSWdRHWmrZ4mb0KOTvJNNJl2fZer3E5rZ1inVdXVX7OvIqnnLxuReCpG5hLSAlr4OlsZjSjRERpbL1x8Cv9LSZZmpawcqIsgJIQpcyGsg1ZPQimbSLKq5bkHVx8OURKr3n1BkEFsk158XgcBvkBxXvPbe+1a3Yvn07o/HISENUjKpcSxQ809aGaPUXbUTD6NJLQXgqjc80ryl9+zdHKadiqTCTyjEZeZYmI9aNYFIJcWyZNc2KoMkTk7fUxkpxjekC9aBT+wl17gCeumg95Ycyt3RBd9LTt4A5NyjumV4/i2KTtLM+H6/379o0zL1lb2jQwwIL37ZZH2sO1zq2pLdTO+9lr+Mu+lD7a1X3hfS3W8Are9/LQiS+7KhQ8rLKGtrlr9g2e4Gj3joMFqEq7l3Jjp9+sXt5Fn0nj2gy/Zf1fgwJfLTO8qFmEiseeOThLM8adrspW7ZtRWROQUgGfm18hnK90fS75DVT0Zy2O6RM/bDlwOltxeBqG80oRn/ZQMw4T6RctG0jLa/zLXJ1eRUtjDQlPiAFDedBakyTHfeypfnkQe3yqk8+eFEI3gxvSTZQJSX21UHSSWGOynUaCKpuwago6F6ILUOV9qaYarEqtTMoIhATotaYJiXrbWHpUgY0mqahaWpCbqIX59HqNeYWwbDaDdu2biKzUKOxQYMVwKUMYDTlDqctU0ayrub2JKCXW953qXSqNuE0UjFnk19mezWinjqaXbuJ1++h2bPMLNbU18+p3U6SzKlTQwyrLO8K1ChjdVTO48UWCaSGPQpfSaTVipA8KdrL9yOhGgmVWvGwG3uWJp711YgxU3YuTZnN5mijVvilLVzMA6T0SqiQcc7PWa3Rui5INw/UYr33BmYZj23IIbuQep4mQagUJkCNpdekfawG+cl2u94QK1Dq7SRdUWFfxxeCEDtMHuf5WoVcTN3WR9jzSGqFzSUjQZIS9iTqK1eYbt3BiDGOivk6hSZRLwvNOOF9YjKJVEuO6ZYR6+YN116ZuGZixZYVVmwd1WU6YmvEJcmIE5yWVKlsBaOMoholdLKxUAqoUTVK3GyMV9qvSzCL3PUfjsfmdyrPqqSQSff8nOamTmuecc/YSFFyl2Alp+IanXaS9t11aVCpBSPeiXVDJ/XoJzNyUMl9PxYdF6m8AKc5wqRtdLZ4z2ydzuM5ZUCUqbUFC+lbkFcM6EjePl+X3VnKee+DDPL9y2g04r73uQ/r1q1rmQpTirlINgOJHvlIihYZL0Aj5IhG0CZHOfIa207JDOi9omPYIIL3wroMMjYujVk/Tkx9Ii0lqqA0wUHwxGbEvEo4l4w+1ys6UsImiEtKc6WlEzelh0YwdrleR7wWPJja7qUO5Uil/aGdw6GvoIvupaTXaA8g5MhJe5drjOre5+W8xd7pDH9Z2Ff6iGGv5aOkp/cscopbt1vh2633czFtrKNE+1mzXU43az/JTp02Els+7wGerrayW0vbIyw44UqNnC0ISXKKbdKWmKWcwX6V1umsOcXKiWVDiICrheQixBkyFzaOJ/zqfe9BGq3ja9XBfHvXKt/etRMIZiqKdhG5PDacGtBwqviUUOeRprFeIDcIIgf5QeXAU6dcwsVk7LFS8vpcO7DKFHclDcrIKG0SpL5hJrkAtDTgKzlQeZu2dqIzlF0SUjZa2nQMoMTgJIJLmqnyFCTlxVwtfWhB8uRytui7FmiYQSFOrGA02sUIMRtItl2ZI23nXqcgPkdCjGlfU2w7dse6dO7OIKOuacKcJvfIqGNtLFI5XSrEmtBYn4wmRGLTWP+JwiQVus7cJY+2NB0Cm8jWFDA/C7X3VCZ86TMQXaQhMGPOblnm2vUV8x2O2Y7dzJf3MKuXSasNSo2rG9ZN9rDJW9FfHEX27FbcWPDTDNBE0TgnrDQ0O0bE6QhNmYFEjLo4RSFVglSCjCrUexo3hmpKmC2hYTcW/dAuzT0bczIy49PJCNGJsVc4kCrgolpztzx4jAvd3pUTB1X2UqWYKQzzcfPAK38mURpnvheLumQV2vOGC5mcWcr1SDt2k5OWH7wA0jUjr10mpHhUJI+qYvtKC2UpBfytQi+Gc6lcbN1Caoxr162yHJV6skSSJYI6dKyWxlNHoo/U88R8p6NZVxG3RnQ1IVdHQhUJuZMv6pCkOF+DF5pcwJdUqBJUVcR7h4t0qZA4UpUYF2OZAhpcZlxy5KwpayBVUhvQnsGfskMh01zSGfgFHpcOE61ENY9UyQHW3JlYNNPKFmPdnmVJsfJq3cPtHTtKv4/U0hBk5rsy/sqC3Nr7uVhdBYlqx5JSVWEpZpHceCym7NTwLRmDtJG+1DVBpUu7tACpLb5EUD943Qb5/uXOd7ozhx56KNWoMnKREDKBSIlmqKXu5ro/+z7lxqxqKcCxgI/GKGRD8VSr6UGKY0Gt9UUSmuSY+QovI2gmVD4w8QG3O6KN0swcgQpdGuOqBq+WtqsJazq7OxFXE3FPJM7NaZeaiDaprQ+wxr5FD3WRCaC1h20taWFDT4tob7t+2hTZdtaeI8OOZDaP9IBIljJFpTO/W9Cg2ltzWLs0LIqSSWhaWNL+t63n2Avg9Gz3NRvs04TW3r/S/6y/SuX/rr3WvEn7fR+I9A5WUtTtz5wqn29JpLs3iuPPFX2dKEygIlgkuXJUKTJenbOyJ3G1zrm0huTHfGe0zHXzxJ65gWVVNZKC8pNiaxea88giY0ES9XxEmIf9PKRBbio58GLwaD/G/pgNgGKAYYNBiheyNwHNXs9hsx7zgSHb4gW0Y4qzc5T0gwJOLGWhS42S3khX6fj1o2ouFAMVVzLY976ZRGdwYJ7J4q9wqSz32hqCHULPYKPMaBUrhHa502nqiuRCMDQdQyTMG5pYG9AINU0GFnWwGoymbmjqDDTaGo7QFny3zZGikqLlmMbYRY5bSr5kz6a09ujeQ/HBd96WGJWmicxnc/bsXmbHt2GlaVhtZgQS+BE6VTREZDplaWnKlqohxVX2rGuQZcUnRZpk6NA7kjqiczQbleiC1WhoDlWLGhtEqnDiIToMxinqAnEyR32EGbk+pyggcm2P4Lwz6mFnNR/q1FJd8vuXMiglMwjhkMrDJIc8gqDzYOlJ4nKRfGr1XcyfiwhunMGymjc8qSAaLFolVtPjRXJdkLZRlWL/K7Q0JIW3uwybTsUWkNKNUfOC5f3c3muArh3OggGpqSci1CsQmwaRZNdXBaQCiZ6kjgZPHSPNSiCuU9KSh0kgrASaENAqGFNHanAx4kbBOmLnOqukEJNj7ByVOEqmlEpOM4zBFoeoiFgOLE5xCbwYULCmn66NxmgCrex+c4ZiO17LXEsJokBc+wB6qVYgFl3IhrqANedrH3rmUfc2x7Ntb5+XWpn++l7IC/J7JuVoW37RzmXLwmmn/6CN6igQsA8SJRXMFlGLYlkk1WdzLYn9+KRtqFcy0EprIzmDDHIDIiKMx+P270NveSi3vc1t2jqL9kdjTkeCEHK6b06RUk3EaM6ZmIzhsETUizPL5oeBdYvAdl29Swpqg5jTI3h8jIwSuDpBnQjBqHG18rhxxKVEzJZzSok0MydKqo2kpLuGlN0GnSFc0rNTMVztSVBsjGI+t/Uka9OH2uKGnk7ea9r106t6kYK9jtV9q90lrlHotHZ2CxS0/3f3xwIpzV4EJIsX2v62ZqOFR0Jvo/61twbammP3QE8HMnrXCy2JSWcj6cK1dJTB+QBS7s1+1/zM7AjJmgJ607dG5KH4mKjrwC6v/HezQpKa631gd3LMYnZug6XeFUdsstpV8cFshLyWhHbMw2Q8oW7qoUv4D0kOPHUqlsWwfJDTn/PvPRe0fZ/IFqLAAnrV9qdw5bfpEW0OjOb+FN35rdGLtoZWm8SU50AqXo280pci0H3oiW5CF69EmezkrsXZupX2XF2KVVuApKA4RHJoTk3FxWienhDNQ9SEQB0b5iGnRAUz6Jom0DT2Wagbi2I0ueleiK1i15gbFGVPfIZmdv5Y7qXTtLp2gre/pfYvTUpyeVGZz5lXjuXrIvNqRi2QvCKjkRmIdWTEOpzfhPpVogZSWLVCYTFgJc68s5WHpSXHui2JXTsjdbJcOEu1z9GGhKU9JcFQQwJtrGhcg+WzO/OAF++NeaddLiy2KJgZijF7PaSt80KdpZFh1HZuVDFa8ox9QoIy08QseGOwCDnCkePB3gveO6RyMMoAIzo0epx6XJphXadzDUG5HjXjVVMH9lJvKqzNG0aKR6dd/crwy9tINsIxI1bKGJWSLtvuVCIiiiNOHKF2hFlAxHqeeHXgHE4qppVn48ixoUpUvqYRMQpKmZNoaBolJcE7oUqK8wkvEVyg9a4rEB1x7A1U5DlhZRGOiOCSdSx3ud7K0ifNcFCnVs8ANkfp2EBcno+i0s5JzZZ/G5VbW6zgnI2V8kiEnOaYH5Ar153ndZJCP9UVYdLL7e7rMO1qaCxSW3QDrYGjao0AnXaL62KWk92I4SVFNLYOi/aCy32p5IfV6UjNRtK+Ot8OMsj+ZMOGDTzkoQ+m8hUxKePRiCY0LX1tCk2OVmQSkqTm2ErJ6v+idf9uGQxzpCPFSGisD3iDzQubGwY01DmUGtWKZtkznyeWp0tUU0HXT6lizVJd45oZGgMzbYgpoElxu5SqgbDbpkIYG5tRTEpImea9MbrdlO0HKCQwLk9vadNRoTNc0S5RSvYxlXSvX9b83s/PbTMFFvFC3zjvHJQs6Ox92SOLImv+3Xuzvb7prSFaflmLRPapPtbaZfs5UbHt1jp5pIUJix/v6/n2T7Ow2PX2z+BDMb3rwcaT97ix1XKOp0vs9kvsTmP+21tULFwTjEmwUqo8Hn0GKJZpkZk3o9kKKWVq9kqYjyPrN67ntJMezKWXfYN/++pX9vWgBvkB5cCBBsaI0uanaxfoT3nWmdOwb+Brt3Ge8l1RVVoDBKR1vJeiytYTIL1jSpfrXhIOEoZQS8GReUWLV5y9JlnxmLYFbD3jXNXWeS97z9cWoFA8HiVCoGZ0Z09QE62Dd0jWYG9egEZTE5scuWgCTR1ymlT+Ccb6lGLuwJobE5V0nNR6DGhDxeWiWj2gve/+f/b+/dmWJbnvwz5Z1b323udx78zFPIABBoQgQhQJ8SVBIiWLEZQlhi1HSD84/IdatqXQT1ZYtn4zHTBNR9gwJUvmQwTxmrnnnL1Wd1Vl+ofMrO61zxngjhwhzwxO3zh3770e3dXVVfn85jdz/HYYLJ7yiVGbw7GaDq63HXsYyFoppaKXglKQUrjYgpWVZ3Zag/3qHOa6OHIlgtpcFuGLV/Cdi6K98364AyLTnrZYH9UNx+LMU0UV9g3VDuKN33xJyZHpOj0JE8cFV0LhkE4gkxiAUliWSr284u0Xr3hbO/X6gT+5Go2KPSzYNaNfQCmsF+FBqneKryXqSypmlcJCkeadRuUwfE0Cb1/kqAm3QolutzZsOggJvbcQqCJH3cIMpp3lrx2O9Esb+/iYZ9q0Cf0RdFHoAx07Q5XGyiLCugpvLgvfe6i8fRLqEzQpjBEK2hwa0UdkDvBs31IGNgKzpeFeFWOsRh1eb2Nh0KsUhnln13IatJnTGQ+LmoRcC2GAZwYok+1IcACkfLHj/svdjmR+/1BuEbiIrEB21p6GejgdWf8xHQZSz0XmMuQY4bjI/ATHg/G4G5qwy3ge5t7JdHbOzb+80DF+y89MQ8QOxw1mk0MV47Of8fn4psd3v/Mdvvrq27x5/dpluXpmPbMVpjoz8Pne0MzKZ7H3mNn5ZDJMx2QEXFdzH4Rgk7CovX6xI6VTrLC0Tq2dYg2xhtERGoVBtcicmEOftceuEag1oJIa+g+HQltmQdPMDVlTRFgKvq/SmLXYR6Re5G4/zr13Z4u8kCnpNZyj+i+Oo5Ti0y7B4WykYJfjVCc7/25gd+d8oRjmZ+0jXyHfPGnMnzTY457keM1efE7uzi3HDMzryt083tke+dX43BEofjm2k4KbCIB4wuJohmVduLx+xOobrDxg5YrunSHeQFJ3ZVQPPtrJULVxspPEaz+8YANqMZal8GZ55Dvf/hY//P73vX+H4DpehGQeVRv8we//C3o/U5l9Pr7J8VMVg7vx72z6Fa9T0DC0XDGnOckR9Z2OcjDnqAsmwaKDaJaEzuIMN0Ay2zBfS0Mgfs69551JmxjVkuUq/i18QkH7zjZCAEWgQsJiMcVhDrU6K870oHQav5JN7zQNeM9mWDTWa9ru/u29cWsNbTsajoZnNPbZM8OzGdGNdQyUQ9j7pSLbEnOYwjNm63AyctLmhg9pkJ7bcbP+cl1oPHKthao1aEeD4vDrwXIz6quNUd9x3a9sH3baTZ2KTivD4nsU1gKvi/HtHw3++NaINq1uNFZHpGMVY/FagLq68Th26DeGDYeNSD4hoFTKslJk+DOIwvv0X2fhfxSTzXqgWliWheXVd3n9rR/wba4s/b9nZ+dH6wKvF0wHcutulC6F9bLwgDAQxhDaCFpmlFo7y6KMJtEj8GT8iSBSWZYFKVGs3cwjg707ZWkW2ZlO1hEpZRYK5x6JzTYD3XcrV4jMgT9TCeVaisE+6M8NnnwTeJfc6hCyYtQ38PoCv/S48OrVI9vlFderMnp8tuMNJBkI7uytOJSMWg5nboBIQbU67/6olFXROlAtjOZZIS2+J9wBHJQFugXpgnrGyreqzKWamFzP4niWxOFsWct1wvxOweRYKzs7YlF0PasavGjD63Yqk8FrQiAh+BadeU5Oz1YlXErz4lMrPr4plChoOQrXJ/RNpms9074WrFqT2tEOpW54M0W/keDxGyFfop7s8/H5+LMOEeHf+p1/g+9//3vuOPTmePQeTsIYkaHIRrDDm8hm1iDhVCM6cXcLdkOddRtde+DgY3+IUSOzzNDIMFfWy43HqrzdbryuhYUbVnZabYjeWHTwSr2H03UorZvTql88Il1X88z58KCbWo/gG9CYzHZKoZTCUrzHghQPlqjhTW0FdFgEIF/Kj9O/fEmOt+a8nkIFU4f+Wc7/+SsSv8xUt91nPuVTX4xRfOREvBx8fEeOHy/PZJ86x53jdHJe/rT7eimGcrJOdfX5Obt74f7L0w/g9ItwEuLnNyvrZeHx9SNvvvMFl6evWC6veNj/iPb8zB/f3vPuQ+fdtaF1D5s0TljKHJuXB1fqWOHiBDWPj8paPevxmz/8Pr/1g19lPC7oUlF5wFigrFjt7O3K/+5//Z/w9Y9//KdM0OfjU8c3djQWsahLDOMrDFcTpUbnxwmtKJCNzBwRcEQkEPX+BzUiIFkBhDdZMatuLBZC6U+3wCMRemQbjFhDNVA4qY8zy5lRiZebQxwvrovXCEyjVdzwSdrTxHrKBCwpSvVC8DACPLLjAry1Tuv7LOhu3f/t+07fdnrb3BHZO/ve2Tev2RhRPD5a0NdOgZ9NkohGSWF4RIfLhGt9KvKRJXEn2CmS8xXOnmcTF7o9si/i3TxHR6/ey0M/DNbVuIwby/vO0jdG39AS8e5Hp8g1W1At7Ff4kQ6g86Pe2Jqn39dVKEul9YU+KlIrUh4RefDmfTTQHYYySpqnXpEjVinlgbp2/0w4uzoOLvSaEauIcpXqEZAiC0v/Hv39X+LDm3eUtzu3r/8Ifa6UDwuL1sjSCTYqYyzsF5DuaKElDUdVlrWzPnpGRnsuL48IrStcLguPrx6curEbH27K+2eQZczZd2O4UEQpCHWJfjHpOI5jCx3RJFfkE2plkSEyh3qtF1hXw/ZBu0JZlGKVWgs1cNNvX8PbV7CuwnZZQB7R7RXlubE/77zf4DqMbThsosjw4s65mQq2Crakw6T0XSlLQZfK6F6voiIsi3hdzCLUoCKuYXxbWQLqdNLksUenWR5LeJx0oJfhOITqI/6UYmi10MezUiPgd3FOiQDBKZKX9Aizz4YAVjCtfmHx2qMS/rmCM+HEPhOYDFku4yTk2yH3knOCzEhEOVNimeduzdoNDNGKFmGIeoE5Rin1Yxn2+fh8vDh+8INf4dd+9Vd5/fo1OsKpiMxFOhi9pcPRJzy3jxEsUlmzET2ZJuWtzfNoQJk0Cm4ntb0Ejl4EqQWWhWV55GF95PXjI08PDyyXB2eSWt0ZqQUeb36NTTyr0dRYe/WgoXS6KY2AEDfDOh5QK4LVoKQvF6QsrHXhsnZKVfa1M7ohVj3oQ4nO4dnAFmYU9O6wU8DuU5vuCDLI+c/zx09xCHnx1RcfiUNefCEDSRkkfDGCF07JSzTp+awv/Ze7WOMLh8rOXyT1TwSYXlzk8Cc+8l5CRt7f2pTGd68ffwgZnDkNTIns2GDtnQfbeVUbr3+58fitxtv/VtluRpPCXoV3izC6B5Q0aukkhTR4tqsIVIV1UC+DVVZWWbDlgS5CQxi7oA3G0h0WXocjFPo43cDn46c5vrGj4Xg5ZrGmO4nOHjWxM3BarV5eXewotrZIV4Uvcs8bbf4NBcSMMuRMq0923q4SRZSBy7ZgeikEpn4WUZpHX+/GxNwEi0ALVS92ZrI67Cs1O2RRRGMdqq6UKDYyG2jvdIt6i21ntJ3WvPh739yY2/tG2z2D0Vpn3xtb74yt0+hY60e3VVV6GF3ZefVwMo6MxnwGEYG1I60RUyrzns/BFXf8FB2dsV9pIty6eI+EkkQ+7kA9DUF54mKvMflAl4bZDXkQ5FGgG6aDUeA2Kn2rvLsUvtbCrQiXBpdmrAxEhL6ArIJcjPKglOLdx8Ui5dkdkCeCG+S1IRQWD58lCY+znkTkTC7hdKpBx9mQhlGKspQ/ZOj/iw9fX9HnP+Z67Y7/NFg8fcUwoYs51KgJqwnLq4JIieiZsiAsV2VswiglGlg6cGhZjMe3F771/QfeKvSbIVflpsZo6hmGNKLFO2sv68JyKSxU6A5v0Nroe6cBWQkuRahLcaNeBaUHuYJHEVcTLl3YpdJev2L51hOyKbUPFlHWInzxWviqfMmyfYurvqU/rqyvO+W2sf/4xtfbM21777SV5g0BSy2wVIRGRuq9C7lSpdJbRWTg+R93mNwxr0EXCFZhicpo64KuhmQB9Vmrneu7IgBl4kJmQhjj8y9JXjMJkOQBmXDwOh53KaImn4RJCYViWXPBHbkFYzDhICdjI8s8ZjG5iFd6pxNFPGMs+nEw5Z9FNsJeCCNLoyazeOZf0uLRYsGd3YpFgezn4/Nxf5RSphH4/e99j9/+K385irk1nA2dxd0HTEqDqtZ7ZvQJp0poVFLeHo7GGEmnfjAd6oyK4M60eGDEqiB1YamPrPWJx8sjD5cH6nrB1k5fOhSvq7sUYxNFJPp2GKyjUkxZMUodFDrWHebrdYkCtWClxmZ8QOrKUi88rBt17chl0BpYEw8KypH5l+g6fhjshw0ygx3TKueIhXL6/Pn3O0t9hjfm/+UTzoK8/Mo5I5Di8KS1T4Cm018noZC+00s5YS8+9/KQDLjcv2Dnk8n5vC88CHjhsNlZbH7kYMjHU3E6UzpWIa1ngGlQR2fVzoM0Xn+r8eoHja/+6eBWjD8R4esqjppoznDZ4lmK6Qw6ee2fQhlYVWRR1lJYZGEvTwyMbkq/huO9OpHKYsIigrb2uVbuf+DxzVmnxINuk2iFpLQL6FPAVo7GcLg3KDUMERcQGl2PQz+TtJES/kpSUsZVT56CCwM3LOZOoKgwlvysBN2m4jQ15SPLJLMjqon9NxA9WI60BDIi2RAywhGGTMKXcCHemxfHNW1s286272xtZ9/9X2uNNjZa29n3doJNtUhVd1Q9umTRHGn2KgmaH8vo0kkQ2hSOOSnMyOmUexmtTYEX35vZTu30dmWjeTajAFREFhfgVqir8HR5ROoXsICWD9gNuAGbW4VSO1VgrZX1tfDwuvC8+bNRhE28cLCHZqoKF4wyPCo2ROlDXTpkZgwCntTp1ZBlQSywcKKUalQpVFkoi9EixT+hbMOo6+DCH2Ltyj46Y3tPofOqO+SvizJifVRTVjoPuvD0VHj6VmHfC8/PoF1ccTd3ZGuplLL6HKlSl0GpFy79gTeP0Bm8vw0WG8jDilRFuzGiD0ypUC6VUhfKqwtlWyk2MIWrDVorlCJUKTxehFdP3k1364XtHWxNp7PZLZi3amXhFXX7FnVsFG4ge6YDsNdvkfp96quVOgR5bpTLzliubH/ygT4+MNSdChEo3bNJSNQSiEGpSFPEVo8MFaXSZ3+NYd78q1IYijeyk5QyER5QjZ4rEUWoFen1YJxK/gjzgEP6H9l1+6xwwYNTRTN2F5TGqkjp/nzw99U0IE8VtYraOOCXJsFeZn7CKMaWkHTpAGERT7EjO2LogYVKcaXTrXEn7WSoWMoUsXulWw51K+osXTkRmpnLz8fn43Qsy8Lf/Xf/Xd68ecNg8Pjw6A1g02FonpnoIzt9OzmJ/xxYvHbUbXQ39lVD5xjWw7EYGjBe10czhB/6RpOR8sGc0U8eaOUNW33N8/oGe3hEHp+wLwf9TefDvxBuDd415bkPbr071e0mXEdhF+Vm8Lw5Bbw+O6WtR6ldNtWyImWl8oZaH+DyxHh6D8sNu21Ig6qCFqEsIU8SLj0P++j3BHPf2fFh/37SzJxOyv1Lx8+sI7RZN5ofjxKyCeGekE45zmFZN4ZNHX93yZ9w7T/1SJHJxzJ1niPU8Z96viMSO820szMys8U/4fzAYbyHkSKnwnvryjB41zbGh8r4Fzd+/A9uPP7XhT/6406/Kn84Cs9SYC1ZrAt9zEAwqR+qB6+Nzn6p3Grh3evKujyAvoXakbpj/Ya2Tr8NpCi6DIYs9K589jP+hx3fvEbDcCMcXO9KOAXpecZmmU38wpDI4sfJUIWntaTg0eKT5+u0p5GWlcMhSdYntwnS17eZ7RA8Cs84ed4RJf2YCE7AhCEpVDxEafEdiXO+DBZk4ZkEp7iRaelO14BItca+uaPRtshoBHyq74227UFnG3UZFh1YNSBTWYcRE27pZJAF4T6aiQPPwZ0GOm2nF3ncdDAmFa7kM1HaGG5AIyzn6RJh0ZWHYYy1MVrHrgPaYUZRBLGFWheWp4XL68pDL6x4N+fRcKMzsCOyDMpQFh0Uc4atvg/fxFWgLMgIixNzNonhAraYUSreh6NW6j5YDEowR3XJSIpgxeltl1Vor4R2E8azULTwaoEryhbOm0lB1sq6LDxW4bUIbzbj2pWuhVtZGKXQu7GMxlIKrM5cxTBqFEBfgNfDaOqRuhKN7cQse3ljeP+F4m0ckJuy9MHFBqZCw4vRlwq1Fp4ulS8vladXKx/WhffbB3Tb6IizPJnDFusKlUEtu1PTWvMskVVsq5i+Rl5/h7IMyvhAaTdk2xna2WVMXn1/7IaWijR3Luwcni/AKEgrSB2e2bHi5E4Fr2GJOoSRDepMkKqUHnC4zAjk3lffy+eWNyX3ZqzVZFzTF/u5KtQRxA9yZEAlOso78+bRrAnzwneVcPokOpRnAXZ0+E7HwZW/G/xF7qVJOvsWgZSgB5hBOSekMO9w7Muf+WZh1oWdgnhE3CPYs5LQ4lOmwOfjz/Px5vVr3rx5wy/90le8efOabiNqMg5dMrMYn/w3pvOgIwNZEejScz1gOhfHv9Q9Zw2TpBVHPwsm1LpJYSmFViu7FMSE1pW9K7tFEKq4LFYVbMAoSlGlDaMPPOhmRzhBAqJVxNkIpTi5iOFU5DRBuh36vOIZyJOhf4YVn3/O4/zG2Y7+1CEnm3t6AXIXSD1t8btrCS+/d760nF5ICtifdI5jjiYRDifpYfM0+ecnb/futdN85Xe/iSNzd277+EtH7W6ON2TnSfgaWder7ANk75TnRvvDjeu7Qtt2Rh88D6Vlei2NzVyHpiRjqEY0S4YymtJuyt6cPbMS9sW09kDVsylGx4qganz1xRcsYvzo3ftvMAufjzy+ecM+cwS0JeUT8TO9cTiyB7l6JHih5gaUWQuRD9OFlFuIbs+cKnpxJT5i02oaDkJs4HsrO2puOTS28LGjEe/PeobCXF5GLLZp504zfQqSrCfRdDKi+Lt7M769ZVfv6I8xWtRk7OxtY4/i79H6kYpO9o90JuRo8jOFe4oLO5KyGf3w6Ukl8Kc8w/T2zj6K2eHEKLM3gDcRWxi10rvStxt939hvnTGUGaYtxYul1gVbFkwLoxWHi6RwNoOwSb3L+oASfTTUO9E6fKSAVER6PHmLWh3f5BNvmQ1ZQgmSzQnTkCsSxeDCw8OCygWsoLZQS6UuhiSbl3hNR10XynqhrJ4N6Rvo8OvVsqA8YNICi+9OjMMWCmUM6mbUjnevDgJ569kDhanZjoJlw4phW3fccz5ranTABlkKZXFqv3J5QHjAbAvnWqYToFaoZpTekHb1TvLsPl8iqCy08Rorv0RZPiB8oO83xq35erTh1x/u1Ao49JB4vuJWtPUo0rbh3eDbQNQNB3WwBaPCqFBG4HqLwBAGg2rVa07wKKOkPMBiyyePXM6XK0wt7oQoZ7hD7uSjUH1q4Qgm5IdtWht54iiWmI5CfG2yp8zN7sQPcb6UBRL7JpVlst0djFKcop/GiQLlMISm+Drk42E82JSdkiLn8/H5OB1/7a/+Vf7Sb/0WauoMh4SjMU4QqO6Z8qHR/FW9d5KqB5csmjE5lW30rchgV8pWs8P50KizPG/CULq5wnUY0gelb/TxzG7Cs7xCZXXa8PfGeKe8/7pxbY33pbGtg201+qXRd2XcFFsGo3aGimcgl4hibkCFsgjlIpQKi3ZK3aDA2HZsdOydD6iuxqhe50bz+/ok61LeCxzy5IiE3AX57lnkTsed5Z9nKRG4DGlg9x+X4+P+3hHM/+Q1hHOwxf7Uz9ndL/cfOGTTpy/m7H/fxKU4uz3pCZ5OdiII+mhs0ymK17OhnzDPaaYMFd4/Gx/azo/bO9Y/GtSy8rCOIOkYzOK3EspWLJxoZy4zEVDX9dTB9twoG7yvz6yPg8cvhIs5yoJAlYzicD1pBuugLJW/92//Lf7gD/+Q/+1/+X/8DKP6KY5vDp0KV3bimjNqUV7InRLPPBabnr4DEckMo/Dkrvg+VIniyfRn8zoWij4x2NPUdidBc31bZFGYLC2frPcSf9+Zmzz6PYOp+fnBpO9LE2E6GaIoSV/bvKv3lr0w2tEFvO+R5WhsmzsefbTZJ2MkR3mkqxNLDil4TpGkGFyCKLKYdMLF5tizgdJpc1s4gx/JjpxbjfqHgOKIU3aaKJvCu9acOq5tjH3QQxGJaqyJgkqlD4FnoQ/Yu59DykEXKhExMNHoexLNdMyjChKtr808xVnFnRMtaaspDleKCHd2QTeXNRrNHqV4L4h1KTzWStdKCefIqnhRb9R1ScGLqqOAXKtxbcpmDnXqAqUIXlrtzpEa1OHFZUuFpQh1uME4DFo3+s0LpjX6bmREHoIIQ8Qb6XVjN2WPexrFu28XxxVGRND7eNyuldsogQissFaoUbzcQcbAbjtGBwbiFZWMh8pu7nCVeoWh3PrO+23nuu9eqxPObmIgHTZl3kekl0MZmFApdKmUEn00gGLFe2WYMIpQtPo5VCnDnbOuIxyX4s0Ez0ow9yVZm5Su5tln+HQ4LZs2JrTKAAkI5Pn7WQ4mot7dPXfBSW+rHlS42WgxU5zpPIgdWVoPnlmS/M59Z7nnjAnF8nqRMvn/D/q0Q04p4cPPE+Ue/yZK//Pxi358+cUX/PCHP+Srr74CxHtKmHqwoKv/0wMKNYlGhk4K22SdsuEQYw2nInXRDA7NINQhZ6dtFVbshBzPqJyBDWgNHRtjVProHqy6CR2Hqepw6JZ3oPXADHtHxmBdG6yGPAz2YvQhjMWbdlpsXAt7wTeP4s1UhaKdgqKX+Fz1wJH/0ySPfGHMvwxHJo23GxNlgdHNbYJz6hE+MsbnX1ORu+yUGrAt4CM80Qtb/XxOeXG6KWXOEQ053ntJfvOR+XMe7t01jzvPYM1xbTl99jxXaaW9OMn5Yh8J2fvj7nZl/i/djPk5NZDeYbshZWBSKf306VgKo4TddIL5WSyYUguLDC51sNTidYjXDR1KqwWVQqfQtAajGpHBV5e/Kt7X42Wh4CeOX//hD3n16jX/6L/+R5/pcPmp+mjA4R2EkxFRNwvjFMOLcAGQWdyNnXsdGAteeKxZRB7CzJdrxka8yNhLEEJRW0WspPlBwoGM6p6t6FTiElHDj5zylIs1iruxo1BXY3UVTkaFj+U4z8BkHNmM0dmzJ0Y03mv7Trur1Whs+07fg05wsoHEz2lcnfCXkk6AeeovBpSfu9uKZwDpDCwcmy+zM6kc7oVXphczUhs8IgYsG1uHcRXMKjp2rHfPViTWRTr0hjXoLAwzpDtMzEygXgIbOzzqXvxZ94ELYcKpUQV6PH83eAtep0AwG3nwTPOJMUwRLSgjmjjlZ0BKYbXKZVOWp0Ypu49VB9rifsRYzAtuFwYiO7oJWy/0UhArFBPK2in1GbnuaPdiSXRnGTWcocry5YK8XrwXRVOHxhXD9iUcqehKXQQthXJZsIcLukPbhY6iMlhKZ8FAB9YLQyrtuUM3Nnau0hFbkcuKPASLUxZwvy7ovngGUKGYYK8e6Jcn9npF139KsR3azvVW+JPnnefnrxnbDY1mXRZQL5Yo4K5Rfh+1QEWhOygtivEl6rUqokopxZ0MHYh2z7hFLQ6LuDOpFk5jdsUunrnKZaq441vdO9Nux15+WaqQ9R4pM0Iu1ZBLpiEjSmYJxeEW4icyO5wYkwHoZJItU4HmXnRZJObY73Tcix0xUHLvFss3D4MoFK8Gxe5BS0Xs8VDcEs5O1HpI+UmZ2c/Hn7fjq6++4t/6nd9hDKONg7a2m/8+mqLRgykzGn00+rCTo2HT0fC+FOFocDgVk4DE7OiubByMTUCu6TObW3jr0DvWN8YotNGobdCehV68/5GNDtoRVWRXuClsDWmdy8ONeoH1sfBcXR5vmxt6LES2XLAI7jj7h9d/VesUBvZI1HIajMguRx1fjlQi+nCgOFOvuYUptXjCfnHBY6YUTXvk08fxTuQ4xZEa3lHWxyLTU+JwEk4v3b3+8YnvAoZ2+udiLN+wu8+ffsygy3zh5A/cfyFmxZjP+LCDji+ns3F2suTF+OWjP06/n68vZ9fl9P94jmN0JNgPO17/azVgc+L9uSwifgkHzItUGSwFHquyLoO6CFxv2NbYGbCssDyAPBx1icEIKCYwopu4/dndw3/rL/5Fvv+97/OP/8k//uxo8FPWaNjJ0RBApM7+b6ZGaf5Bq5CIZQkamGy3QYbvkqVqIhgUb4zlwqNgzg6Q9FSd8KazslJ9c97x2eoJDuj5j5dCIWwwcigucKILeHXDfbx4//w976TaaX2EU+HZi73t7Fvnuu3coih83zf21ti2G/vm3OQaisFpAkMpwKSwjcsyvYpwDg4GqcMZubup44v+qVPGyF96cTNyPqM/HO+26hvTxFMEOnanjIOg2B2TXURNkdGRy8bloiyrMUZlbA2RHfoD1Ac3tmoD2SkryOpMEKZeNNzxWhGGh/UtBLRWj47bKDOZIRG9oiu0Ql0LRaGJRy6MShF3UG4UfnQzrvvOvu2MfQc6yopSkFExwY3gMVi2gZULl8fKq8Ub9jUzujT0+Qp7ZxHjgU6xQdUCeuHh6cKXbyuvlpWHZdAflVKdq1aWXOhunkuplLVSLhekXKiLs6WhHW1eg2Jh0ctQyqqU3qj7huDOhywrsq6IrAjCUjpvHowvvlf48McLzzdXwrIIUh6hv8b6B5b+j3n6UtAF5MfC+LDT9h/Rb8FRz3AnLvahYpTh2btBsrOZZ1OkH9rEFy8mFS0VG9WF/zhCAqs57EpHOeiwxZljtJQT6Yq5o1+O5ex1YQEnKy/28zg5ExBdxjND6bKm5F6CcGDEmXEyM2FJYA1mSVV3nGMq16TMDRjVMHeKkk3K0VgGNQMTcS/xa1J+l3CqsueK+xTywmIgoIIeSPmzVdvn4xf5eHh44G/97b/Nl198QZtMUgd7VNfujoa6g+G9kNLRUPpweOToTiQxVCOj4XLcAz5jQoMSLjUsZHKkM2zupbOVGpF0BKxCXaBeUH1k7E/sulKs0GSwD6WoMVrEqUbIuTGc9vxSeSgPPBTliQ6PHei8ex+BtuayQSUDZC6RhAWRlfpKKMtwp6kP9IPDZ7SpsxWC2xCC2yUS7JjZpE0k2KwK1RZnFdTuexubQYhzD5yPLPkI8s1ZOmKnM3SRH5vfOwcFORn0J3F3r8+P69npvfOTuRveJ32je+chn6Edb905AZ8KdfxEl8uO706fJ1PAMZ45Vntxk0XubRxL88VPOEaaRWGrBNTJSjQnMKI+0UkLsn5v0cKlVJ6eLpQ3j5SnB3i3MFqhvV8YFfq6s6yNWmCR4Y7wUGy9wFLY9ULT9SfdNT/4tV/jL/3l3+arb3+Luq78nb/zd/jn//yf87u/+7s/8Tt/Ho6fqjM4Q1zRp6NXXcsOojD85GCE5Qo4dd1kqDI5Cn8Kjo8xmIXYJ2VbJBb9iR5SputwGDEyQ/ZlMjZJ1GdoebE9jON7IQEEHB9oWXB63lQR4WfQJZrq3Tq97ezb5gXe28Z229i2G9u2cdtuzkC17Wzdsxt7NOLz6FH0yIixhJ02WaVKZBckOS7lEFwZPLLTDOTfZ2Fzhp7OIwXa+fUULmZQHT8uJzy6o9wcf6+RSRAMs+KO5uVCXR+4XFbWpzVSkAtyFVgG1M2vMxQZAlSkPnjjudJQa16InAxFGndloYiKIavff8IwJZ3Yh4XlsrBuYH3Qw0EpViilspWFdhn07hhmlQLtCV0HWgdUxTr0XpwpZSwsTxdevXrkbTf2rnxow2FgV1ApXOoDjwVPg8fCf2iDL6m8ev3Iwztle75RN4miFJmZMikBwyoO66mvjPrB4CKIBeRhjNgTKzy9Qr58olahbh15544SdN+LAqUKiw3eNuV7P1L+kMFOp1tHuoDuzsLyUFhWePxwYTSvVWkVxmYMPAJKErSGI1rEnJkGo89dB1IaNoobKnV151TVHSVZAsPmY9TFgxAOZ/O1bwpWK9lh/Wh0N238yJBGRCvT9QHFvTsyVQ4kBfY5uJBF5SIB44x1PYY7GAteEK54ZhEC2pRyImtJ8v5z/xUw88JVEz+HiUUNEjNOgHH8zTlkUKJU5AxJOXbxhA0E89S5uPPz8efreHx85O3bL/iVX/kBl8s6KWpnLcbpXw/KWoufeqJM955MY9ZbpAMx/8vA1hmyq3q3NierJODVAg51PQo0vc6OugArwup1TiLzGtkbytIxt6CuxQ38IguFziJQZUxj3e3GiGwmPWU6PVKQsiCPg/IAtEqiAUyJDM1RTSUlKNRDNkgJh6mI42FLofTFdbE6NkNOynPSts5tmRZ5jseVbdozoodhfUjSext76ue7w07//9RxfOF8/vOw7mAdYbvdV64fcvfOyzg7GyfH4ewo3H/wpSd1vJuZ2hcvnm4x7jMdssjqelbo/uYy/OJcQs4gaiVsEtKH1LneMnCWDmW9LMjDhfLwgOzuqI5roanSsvi7up1TsKCTX+Nq1dfpTzhevX7DD37thxTtiCm//Mu/jJny5s1rtm2jtT+f2Y2fytGwStjdEigqQ2ywUMPbPAoYi6TR7rAOIv1vBtSkbBSHWqn4RizBSJXZD5NZ+CST8SU1dhhaxVDt6YXM0tBckAdy+jhm5LEEZtzKIbMSolQJWIrgmHXD2mC0wdY7e2vc9p3btrHdgsr2urG3m2cy9o297Z7x6LtDexIPm3UJuBBkHM4PZMGdTaPE5m2nUIgdqhpGSDwTyn2k5SRMEp9+2GnyYqPL9LCSPcSMMLqG11SQGFNxx+xSkbJiywP6dGG8Whhd4IsF/THo+zHrOAoRYWcBvTBsMGR3ONYYSFDPqdlRFJbsEX0gvXB5Jbx+Aqxw2+C2r2i/0EpHq7ghihv4VgtvHxa+9Xbn/fuNH2/CM8WL1tmwfqN0byq3VKHWBasXzJ7Yb4+8r8Mj+YbDgKqBLlgp6IMiOiBhgrWjS+H984X318a7UXmeXe8ryAjDubgj1QraPOoymmd1RnfDoJROqStFFuryyKO85vVj4eFx43kT2MNx7zhcygSK8aEYf9AH71tn34dfc4G1N8ptA6nc3gs/LsJoCx+eC82EvjjzmdngqE0AekCIShbeO4NMkUJrzeE8YnQxKit1GsYdlQWlMMJBGEXoxTNA0mO/xZ4uNQyVcKo1lKAUC5hkMreEgfHC0TBJLWgBhQCCOMCNiHLsB0ulrdNRGCELLDwYMbyhKBZOjCDm0Ewr0TsgDBNZcXYbOYwei/3o2daUKRI1HaFskyRjpAz1Z2mTni/u84w/eJHJ+Xz8+Tn+zb/1t/nVX/212HuRzQiWuN48a7Gf6jGsN3c0Mns+nRLXlYlAmHWWc6Hq3CPZa+JQjBnMgwNC7XpTcj2LIGulrCvLwwNPT694/fCKr9aFtQhr61TN5oBem72tynYbTv2+XVB94PnxDb3sjOUd7z/sPF+V7WtjtHAOwrGvMnyPm2d5efOA/AB43eH/o9gNtEfvAxkUWxDEM8rFKFWPGuJanRTkUlgeV8pS6c8XrHlxukYo4kAGJPnMyTtI/4IkMeFwNFqI0Xsl7Ef6bmdDPl//SYfcv/2RlSPRLiAYADUe7UgHIaMfnxjK+afAkV2Q079cEi+ueff+aVCzrOET93RcM+thE44v99c+fd4TTHo4McO/aSHvp7UiNu0afSWMp0r/4pGlvEbaK9ZHt/VGA73d6O8a+vCevXba4mxplyJc7IEiwvr0wPJw+fgmTvfpzaPV7SZTvvu97/Af/cf/IX////y7/N7v/aOf+N1f5OMbOxqaG8h/kE5xCeWe5Q1pCmdh9ox2xOaMAEakPA9sszf8coT+0ZTPDzdKgg3qtPgyd+I62xOoNc11MRLN/6nj8OMl8Hgcxn2cVNULlCW6iVo3Rh+0vXPbO7fe2XpzOttglerbRt8909H23dk++nD2g4g6TS7yHEXK94iKJh58YkcnLtTmfSvhW8ixr00jtWvHvjwLjNzsZ5VxDmCcDxNXQO6r6BE1tnB0EhJnio3BuDVE3DjV54bt4ZQMiz4PriFExCPLxaLLvBfjgze/s3QiS5nYdFNgER4ulbclKBmLcZOBWqOrusEoMpWesfC2PPCrffAHQ7hhXKPgyxqu5YpDry5LZamVdhFaU7at06tG50KP7Ht37oExGBo5leKOhG4VVeEqys2U96o861lRuyc5+6OYOuvSRkQejaFen1KiEH5ZYCnKowxeDeWxdS69O7yw1CA9cKfcRHjuhdsOrQ+aGOsqyEVYqlHagDfCJitfNxjPG9fnTttvp0LQw0F1SHFAJ6KLvEd1HIJBEUpvlOKMUN62D3fMx0C1MUQogYaT4Q5FH3JEDrVQh6e7s7udG+gSv3tmrQRl9SSheLGfDSbMyuxQ/i4LYk/BdN5zM5gJZ7j58fsJKkXOsXc9TuiF17/YrBlJOJdjwl0+JQmG5VYBD1bkOSqz99BUrhL3V+bFmT2D9P6+Px+/+MeXX3zBd37pO3z59gvWZaHt7dTVu6NjxO/uSPRszDe8A3YGtfxnZCf0VIdhTF3k6ue0R+YRVnB8PgQZNt+LAEBCcc3rNYsoaxlcyuCpdJbSkLojo2FtR29+D33v9Gtn3Lo7T1ZoY4PeYOvsN6XdLLqRp2zy/VIyTl3ckRDrcA24zF7QUaL+j6lPkcwqu8YJUkOkFmoVLrVyKZUiC9uyeO1LQj3h7FNMfTNfiYBIMjZ5MCagPAGXnsGQNKByGk/T+anC6ayBTTvl/HgOQ1yO8ZnXznls2F/U87lyzC+GkC/Z6cVPjOb4YZ94/cUakhc/57JJfR+37HFFP+l0MiQlfq6z/JnjtPv5ywDuiZXUp8YcQteVsQ3q0qE2ajCOyiKUxQNcOo5MnhVjqeGpCZRLpT7cZzS+/ys/4PHhkQJ855e+Q1GbQabUSZfLhe9977vse+Of/bP/nn3fP5rVX+Tjm9PbAsfKk7T+uSvBt7mGSIiUSrlvwudPj2zK4iamK3JPlMg0mqdXk56peRdUy6xKvCxhHMhpIFkA+pGCttzfAtSZeXWj/TDm/RMWaebAtXbobczme/6vs+/dX+sb2745pCq6gPfhkJIxBsOc+cPsMPWn4xZDnQVIJrOonsxSpIeV+1le7vXcdC9CCjOSC3ezdLfzX36fuO5gpiDnrByDNuto2+jPHW3i9Kbvd2fpOA3FE0VlKqGygllBCeakUjH1oj7vkFxDUOd9F5AFkqlEHYOp2hhBzyjF4UkiArYg9uQKa2yHohRmyl5qQcqKlIrUWEM2MN0Y42Abm84fjn0efYFSKWUBWan1wmUpPNO4auOqnaaDiSlUnYpORKl1sKxAF59f66HsPf2LutIv2rGxMTZo28YYmwu7pbKsRtHI/llBS2V0GMHsVGplvRQeLkLVQXldsfLE1jptu7LdPtC362zW5cmCU/4v12I4MhpwMWEwijBEGKXTiwcJSi3YcGdsaKeWyBYMAXGGjyHeW0VKoehgjOLNC00mvCJrNw7lGfvlJZ1KDtMyWEAYO66k0OIypFjUbYTTEOt7Ii9gkitMGZL/S/siG/6ELWHgWnsEbDMiLDOrayWcCj194bTZ4/8mef5DZkblpTvfkgn/hKx8Pv48Hb/2g1/jb/3Ov+mNXdvO2CNrYZ0+WnT17ugweh90HbTRYQQ+fbjeyj4ZWfitUWuRRd9HBp2oW7qz3I6NAp8wgm2uaIvMf7FBpfMgG69K4ct6QarR10q/Xum3K+PrG71v7NZo10577vRyZUiD1v1e+sb1feN2G7RIoqxhOyzF3QSn0FawDu0Gf+h73m7FM8eU6M0RuiGa91WEaiBU3/dL5bIUHtfCk6wstsD6AAxudfNzRA1o6tZDFYfgkOM1keoBocsS09goYwRFeM7a9AoO6/6FmJOEj0/hE7N9p+dPYzgdJe5xOb0hWeLKp+XJeRh5hTjZWTiebIkX3sj5y+db5IVfdfaV4jQz9Cp59ntbQ8LJyIDOgIOsJ89lsRLj2m4qmtfhbcaQQf/Rxvq6II/KYgtm7jyIerX3uIrXZ16MSzHWAvakSDGWN5X64bB5pRT+tb/21/nud7/PGvNdWg9YvBPVgAfUfvM3/yX+wm/8Bv/Zf/afs//xZ0fj08f0FmLB11DwdtRK3HnX4c1RBKUiCaHCpotRgSoW6U+bJCyOqXQYVZ5O0gg27jDTIKfacnGjIhgD3HB4kd+bxguIemQj+wamkZ9GSaIYkpu8daW1Qe+N0Rpj6/SbMyxt2xZdwTdu+05ruxfnDS+iHl294DYzAzlfYjO7l4X1OY922moHNINjzmX+bzohZT4PyA2YHr5xRHGnDDjLqrn5Y97j7+kWpaEuzMaFhUEDZxF5jnLi1rx4OOc6gTVxf4splxWaekF4L8WN2ch2ZNG/SKGU5HMXdi28Q7AOtx7dts2zGYmz9Y7awqKV933hny2Vr024DvM6kII3+Kvh3Fqhm/f90B5KchnU5rC9IcogWVc8YujzX6m1sK4Xnr54xbdeVbZt8C4Md+9Mb2CDyRkkXrbxsBqPj0bfjb6N6Hthcf+FNoQyjDIGz5vXSNSx8952hIV6WVgvSukjmlBV6sOFuit7URrCRQqPS+H1g2f56uvK0i+IdrTd6Pv7cF6iOCgyF2kwJ4xQDIf4mKFFPeukTjU5htB70ED2wSpKsUGvEjVZnl1S3BGpJtHfr6Jl0EdBurCIspQjEnh4/uaQNYAs/HypH5UwImzq2ioul3oUcFowU3lWwTMtVmyuaQvxdtaV06GuobjUd2NUBx2KU+yIZUhWhHgWdEJJJfKq5/DdsKMLOuL71nKv5mYJ58b9ps/Hn5Pj9evX/LW/9tt89a1v02x3RyMKvr0AvDFG88Lv5v0xkjLdnYmQQeloZLAssxzpZMzgBqFbD12job/P7FPpZNjdTvFATJ5kiFNHNGvc2LlI4f3lBqLs7wr9/ZX2fOO532h9x/aGtQF0LwqXwqNsrKI8yYDaYVE+PEd2sAhlEWQVsIwEOGJA98HYommfVKfmzmhcYWYQPTYgoS8AEcpSnbqUyigLlJXRLg41GzV0cqIqDlkxdagIEoFubyBYcZjwA2dIpdRkxpQpb93Kjuz04bpMWFae19RJa0xP6IJThPWgd2E6M1qEIW5PIa777AWv+FT/lrYWU1+nvJtBT0lb6Yw4sbvznD2el27p+Yo5Rok/5uglf7s/o01n43yaCO6EQPb1Gq/f6QrXAzYUe7+749oGVh8wWdj0QleFxWDF0RfqToIWozfzpr/vK+PqD+Q3f/2H/Eu//mt8a3kFHxqjGqP4unJdVcC8sLCUHjK88Df/+t/gj/74j/kH/+Af/LkJIP2UGY3p1s794QYSsW88oojIbFIWvAATwlQck4MM9UB2KFL/bjgF5kanV8+ms1B8gwTN2LHiU1F78FTNjQzBHLP/Mo0n5u2EZxM1OUUN0t03kio34VL7aLSxs7cbve/0faPfNtq20dqVbb/xvG3c9satt+AuH04TPiwoUU8QpPjvqJ2Q8IITUBZbMHc+TNgYMffMjepzfqYZ9M8F1RtO/Wpn5qlTeCENrilg4q07cWQvf1dGAxGPGnUUunO5dxmIVqRkztqi47Ib9Es3HjejVKPbYG/D61/MG0jNyJPI4Tgtyl6V3g3bhbFXuuHOhigVT0uLFGoRatl517/m3Xb1hokKQ4q7PNWi0H5gttN18fdqpTwuLOvKsnvX8tGUsXsdA7U6Y5UULKBdLCuPy2u+3YSvRZw+tlfoEtTNdcpOqcKyhgNQFm7L6swoe3GctDh5gRZhsUJdVq488GEoundG2+FiLBflEk6AlopdHrl8+ZrH91dKu4EYl0V5RHi1FxZbWD4Y9qYxLoMhXgC/qzvR01HFZtGxw5HE16wQtVIORSjFK6+6+D7xzTQQ6Y6hHt4hHHVoXBXvM1IF6u5F4UpQ3haHWiyLR4eScjLheocx40wzLw1uIwwIc2cj+/QMU3oYERJWhsv5KAaNzOKI/SjDDRibzi7ufHWJ52KBC/d6MqfBDtOjHDtagh44Cwld552ikpz23QnHLW5ruUCMTGvKBpn7+fPxi36s68qbN6/5i//yb4JwarrnDWLnz+E1GrM/xiz8HuGUHx29j7rA+JvDeZjNWk/OxgGTTXgVL9Zfrucoyw2lYaHnR/T1aNbYKFzLBgbb80K77bStsatDp5wu3SGpDlMtrGXwWIzXRdmq0qsTpIyERhZv1DdJYgKnol3Rvnim/OLGtav4o6A45YXVKGUPXUN0FvfgUoFS0QRiZ9EVJwcjPAw56Win6E7yiEKRilkNw78jZUSAIgYTBn8WPp/FQ5LZOILDhcSsXSiB5DnZBicjIf62Q5aVQ/d70th/OZ7pWbnfn7NMP+1wrRK9dJBrcFoH+FhP3tjLJNhphAdMVV5c+piKCTk9sr/y0Wc+/stOc8LJjlJsG/TSvH/ZpYAYw6rTgRS3DwBk93tR1G24BmMTdPfzfvc7X/Gv/ta/zNd/PGjbYCwdW4rjni0hc67f1IbD8Ivwwx/+kNdv3vB7v/d77PvOGL/4nII/laMhclT1Z4p1UsRHgXga6VC8eCb6JqSDOaN/1YEaOpJdwJyzX0JxWyCbi3gYuGta5EejXWINHXYSWbjge1mxer8Up9SUdC3Ew4USLbcMvOGZN+YbMmg09rFxu27cPmzc9hvb7cZt37i1G7ftyu36ge15d+hUc0UwO1POqNCYWehTXiNn93RTdtyYpIMRgk5efPRAXsZ+emnSyAtH4tjmx5zcv3KuEztHN+7WAgYMrNcQ9OoMRdYwrW7gVTnqBlWw4VbitRjdlHYb7M/NMboWbAzxMB1KdmINM0N6p7SQcNUFeAPnu8MhV8VizZSd8thYXnVsdHorSFdsEYfTqDGsU0ypfSBjdQW2Vswe0XULCknve0IdzqhUHl0hDoUKwx54Xl/zx2/h639hPF+v7KOgK5ThKXszsMUoS4Fa6KVye7XQv14wWdDSJ/OYFzoWLo+F11+uqD7Sngd9271x4YD2rNTVlZ9phdsjyFuGKKo3yhgoynUxWBaeyspjB/tRw7TTFhgi2AazbK7Y3BbuvJYT28cIRI8rY6hetD98f3jPGqcNkwKluTI1IvFZ8PqMxTuqS6wXMaMO7ya+qbCUQhUPOJzhhbk4pXjtyN1RDsjT4aCDFKNq0imkakq+EhckJiPkgAcxLKyFEtnbGQGtcYZhx15YmIXyEs0nCWYbRe63S8gmM5wDPhW7ctRlgK9NxA2kEXvhDKv4fPxCH6UU/s6/++/w1VdfBXuUOxWteb+lvp8a8PV4bXYBV8/ums7K36R+1hFZabNJDZpMZ1MnT5UoERiM9+5841yEB0rg/IqZR35NBmw7z1KQ1vkxisnCbVzZdGO3HZHFG5Y+AZuTZMjDA1IXnp4eeSODr7jSH2+MpVOvijWHi5auEe33xm2OmhCGVOQVSDWGdLR12HXuZY3AiCGoupfvlYGeWcVjI3Rx9MG4bAw6tvRgTfSMip0t/DR3BERlZtXdQFesOMmGpqzxOEIExfwUjpR2g1clK08Eqa4v5BJFaNqhDWx358izn+FsRQ3dNK8lKbu96WvWO5Z6PDfRdEAkdG5U25ken49MQyHXR9okIc/k7GDcLQ2/zuFvHJ95+cf88cLIiMulKXQS9J/62Cd/B59vqmCP3mtDEVp3+vqxN5DOYjulGHVREHUq/aX65xWaVKQY7bYztubXWQr6uMCjB9v6tTOK0NZBrY0i4tTIRF5/6Z55L4W3X7zhf/4f/i/4vd/7f/J//4f/8OMb+gU7vnln8Mg4zGLLSGFJ97NMeDW5YJyZqAqzSFnTL87CTgMZNqO9Hv1N71odq76LwxdOFZpWDs174A394rMjOek/vFyVQrLe5CaqHM5K6H8/RzdGN1pzVoxt3Ljqxra1aMR3Y9tu3G4b2964tZ19a5HqzjQ20cE6okp5D6fh+MXc870frWSQKb5jgWc/Ub6p3EUM7JiUAx6eAm4KtxejEI4Unrx4OyIoh8CwtI78LxlYUJjm/WmA5Rh6fK6E0pOddms8t2Dh6tElfCzMqngBU+dC7zF0uazUxwdEBmLeOLBi9MVm1KkUkMXgIlh9zfL0lsv+Dh3v2KtH3TGNLFWh14WFhVKq12solL7Do3kn9AFqJeqMitdxPJg/q1ijnZ1nfeaPf6S8e29c9xv76Ohw4TzEu5WKgAyQTek7zgyzq8OmujLMjf8SDvqDLbwaF8arB0oZ2PZMCThX3yq7EXAhA7kx9h+xcWXpyvL6gq0XrrqyPcPQHdqzR2p0p+1Xht2wZY+i/XMNTkQxRRBJagUOZUOSBATH/kiFL7Bb1LpEzcWJMrJ3r7spVSPz4YxfXnDu/VLS2DlInAJSKQAlqG1f7OdpKcXqrMf7xSMisT7MRUpxx8DXfNxRkFako16Oqsm5/8yATVxE1eP5Zz1JQp4yH4lZOE0yYQaG+RpNK05ykETDyjgPcifjPjsav/jHF2/f8sUXX/DlF1/y9PTE3vcIcniWQvNnysxJWXuQi1iQluSCnRkJXiyhk+ObwbV8OaPHd5+fOuEj7RV/pbUpJCWudi/u7gL7tUDptIBVqTjLoFCRtXqgsRdKWZByQcoTIg2jYRQmC9v5vpKkIoOaRViqcHl0HaB71EhNeyLCEAZmScsLB0VcWLDF78jwwJlpP4IekmQW8b3TTKTdk//5i2lNhG5POHfUr05H4ziBW0gShe6RZamrG7nVCiredLGbZ5ellIAUacDEJhhpZmukiEfTBWSN+1YwaniSFRENuecSyE4ZlZPlxczg5JDNog1BegQv18onvIJ4XeTuT7dPPl5e89mFj+OvZFbmcK2OT5+dn+PbGAHRLoKq/xvN6+gEO7rOJ3eRuC5eSuGhCJcCtQyK0xKSeeuYCNScKGZ0dRuzENTIFvPrFEfZ2Pbt6zf80rd/iV/55V9BRBhj8Ad/8AfRZPAX6/jmjkaHSQdLYo/DQ64ePckForGJrBSP4k+4Q8CDZuSWsPLx9N4oQVMT2YssT1U4r0qJ4lDDnEJTPAqcKdI0tiNI8PJOQCoy3AAYofVDFhFmiS/EYfSuXgC+N/bNu33fmjNNXbeN7XZjv3lDuNYabTR6YmEzopRYWPQevsTJO5tX9tnNSCzRvTyZaNwhKDPDgYhvOhJHmyriNBcz5VNOZw/I1WkoHCLqeC3+HTUyMh0Xl1cDuh1c5WEtGhbNFJnPcBRFCKXZfJy+DoRRqne0npg2bx5HCNzCgrVHujUgqGcxTPsRHUoh1wV4zdi/x47Ryw3qQPComHaFAlUqtVxYlsJS3YEYewNrSK/oqGhwOgfwhjqMWqNxnSlL2yn1Cq8GfK1ovzkcABc2SCxnk9lYjqKUvdOsO2NWzHudaqqitdJZ6NcL7doZ3Zmm1iLU6gu7CsHqfaPpRlNDnpT6vUqRJ3h/QZ83Nm6Ur6+MpaPWuXV3jkf3OZzF0DDXhBsPvsfVmHVRZkZVQ8vwAjvHNMHolKL0XqmlUhiH+BfHLBdxmuQxOqNFecnqkdwaxrWVEplTid4UKUzibC/y8GkjeIZVZrZTwkNQbEKUjjfUM19ZgF6JhqCxC8/wrCIRBMC7Ele82NQMJ7U4+ODO28PPNGL/lnjPwigIxHPMnTPkgQV3ns3u6RNgyefjF/v4V37rt/jXfvuveJ+m1ultBDyqM1r37EVrs95vQqWCltpsBEtewqbSWThlzXMZpf17evlsmM3g3SfxemcXJIlbptL1CP4AdmFUY6dye78jS0EfvEC61Arrgi2GPRoWMaa1PyE8ovYttnrjfe1cn2/sV0WvQciyHLqriDfXLAIPi/DqVeHNt5RlVf7k9wdX7WwjDX0omZHUNKSrw3mjRs+c7hKR4RDbbcAeLF6YB1RrOBIa9WJmHv0mHI1Uusl6ZH0amkf95/EwPCiTNK1xjuy1VCulVF49VdYVXglsV7ia8qFVmhbP7Kth5nV+GTASEe+bWApVxCnfi8DFUSS6CyqL20K2IDZiHdjBBOiGWTzqXDBuV2Feg59wrumznVbJJ487v0DuftyJudOJpuierxsHjkri+cq0Vc4x0/xZtGC9MC6V8VDQJmgX2HawQa9byPOFIovXh1K41Mrbh8q3LpVXKzw+Nd4/RkZDC9rrRPJoad6AuIkHGsW3ZBEnICh9uL3cJZpCCn/hh7/Ob/yF32Aphffv3/Of/Kf/G7Zt+0mz93N7fHNHI3/JEF+wwJTiCnPS5eXHJBTr/LIvCBOJ4t2MVMYCUZARhlgsmmR4MHNMtdsJaQ5F3YF4lLCYRZETc6WJEpz4x2HulUQB9oGr9i8ERtscl5ep6da74/xvnsnYbhvXmzfn2zbvobG3RuvOltETE5sNkSzF/RFlmsWuHsY4TS7HnM3vHffvtJ9H9EBiskXu59+nIb5jNjubmgVf/+HKIPcux/0Dj4388txzrAYyxjQAE75CRIgPJ8r7RPTuStPUC+tqCFWCUOpeAPsiKIbzr/eOjoaq45MVjSLd09JUC5hdp/fdKRTbwIZGczRFxSi1etF4MVbx6PMQp2qVDqg5ZjNWCXHu2kfUgHiB83Ip1EehqIEMV7SBNzbxyFnJqHUp6FpZLoJ0j6h0OopGNivM1QJainef7zfa1unaEWBdCuWxImpUUx6ARcCGsIUzWLVQLgv6uKDbTkOxvdMaDgNsjW1v0Zn+JLtzLZTUlRmBS7v36HXiC0KZ2Mniiqf0zpDqTkREnbz51aCWgVbP9gygm2dNlqqU2k9BgiNtr3LUqX/qUDj5HkF+ECc61t/ZNAq5UJg3buM4f2ZS5uaw2CcnuOU87wnGObd0vCenPWOR2LPzPpdji83maOdzZ9by8/ELeSzLwr/6V/4yl3XFVPne974TNRde2zdmjV/Qowc8SlXpwxvcedNXnVkEc7zpXEsaCzANUGDqooxAv4wJT7dkLsZ0OGwaeuei4/nh3EARGLBSGLIwZGGX6hAlTye6DCkDzBgfFLkaZTekdKQ0dLnS2HjeGvtt0DY7Eg/mclM0MiKRzVgrPK3GF7uyNuW2D3oPSGNAs6XGBiwJlfZ/4IXglIJUB1NJ1JFa6BlBJ97+8Mxctkkpd4iOmIj7onELPXxy3iRe93kN2RWsfLVWyvpEXZ94+vItjxW+3H7Mdbsi9oG9FEYt8FC9ceqthF49Ct2XS2VBWMRrXk1Ah3gW2pyaB3GHTUypkpC6E4VOOE02Df7MckTRM27naWTSkslMNOvp5EC6zDV4LDgp0cggzYbTwrqT+XL/6/05ZH4+dUXKUbcjQhd1D1yP6qE9q+4tOWFCrgfxRpEF6sXLLV4twhdr4e1DhccLl8sl7kNQ86CvKXiJqdHVs0MliY6KUDuUJaBokYFMwpCadt5PUnK/AMc3b9gnnn6bf8ckiRRncTEJAzafvhsiFkC+TEh4xDA2/smI5SSnXirZjKa/TOKZWNRkGgctLG6opEP0kt42HCA3NMLwJtsCRuTRoufF6PTeaa2z7Y19a+z7xrY9s11v3qhvcyejtxbKQSdsKoX+vO/cHTm2FPNprEznweclC+kP+yXm63QvkoXvp5hIXPD+pPczd/8Zkfl7LvhZYH73zdOpjDnfxxVyw6ciygfrlpapp30xPajsDLLYPxeBp6ePjtGmBmP3QsPevQmTdpJ+NQWgmcOTdShantH2R9j+Ht13j/ilIg6t4OieQTZ3oxRYCtYqKtHELgqdPUOjYah6VG5ZFtbLgiwXN9o12KOItS8CFF9rtWLLAuuCXCq1iEf9DEhFJiASmCsKtA1rDe2DweZF1WtB1gVpg2rGUmAtK5suAcNq2AeP0ikFFaGbMYqydW/s1Xpy1o/5hI6tG2tBjnWaJATq1os7tWpkrxrXbl4qU2QwaJOfnuJN+kbpniEazoJSzJv/iQ5K1i6FEeHwMV/vcl5v5L75xCGnD8WyP8SKnYgS8sOWImre9nmxz0xqOlvTOJPDo4jfT+KLaXQJx/pNWJod4zl7PtmR2QMnctx3YAA+5zR+8Y66VP7Vv/KXefPqFdoaNp2MPlkOp5ORMKmhs2eGJdd/BEJmr4wM+M3An6X3PNcZ8X7+IXCqxzo5vnd77ViwbujNDRmBKjsLdEwKKguDlVYKRYpDR0rADiX697xXys0oDcrDoNSGVmekGredfRv0TU/q7JBtVYOZULyZ9+NivNmVS1d+tA+uPfRwBh4r4Q1E/Wf8c0iNU5ZLXRBrzjiUNOonCFY5OW8OiyzOMFWKZyZyXtPz4HAmZkPal4tBj+dSwnEptVLXR+rDFzy++T6vKnw53ABuduN9LR6ge6xYF+gj0eYeSK2FulSyP3tUMXo5Y9SuZT1eEaUUL32XQVD55iO3Q+ROYRxZZ6me3S0gzXUCMzh3BG/vbjjtsTQTc46E45pnWW4vzjFtpDsROudvOhmn1Tof+XDtPHacWWops/Bbu+fgdTpGBos3uH9a4ItL4cvLwu3hwuWyUqs7uaoHBE/D0RiBYFFxGzcZBWsEsktEnhRF1K0fKQ5JriVaOPwkPfdzevwUncFlwgIO78vbndS5r47YuBRntJldnkmj2YJK0mJxhVEqIDWFloS8smORTBtdZhRzUprFqpOTUzGV/0fF4ByCQpJydxzjUKd0GG3Q2mDbdm7bztYae9/p+419f2a/RTaj7bTegvL26MTqAk5PBZ93F7/bR9O4C6PfSgi1mLPDEgpD52wQhRd8NkyY88d8L885T5Xft6z3kHm+NJ0ON+O8rbk797yz+XY5E18wo0nmxrRTHtt0DjLrrsONzcPRdMtvhOA2dUpH60HfiB5zRwlD2AI6MBg8I7q7sa6NAxgPWMG0etNA7S7cpbqyeqjsdWXfPJtl2rwmAaOoc2l7WlWoVllsYfSF64OwDe9ea2pHcbWoK6JFom/HQmFlWYS6CTIGZi3wtA4lqwirVJ6sIezsUVuiEWpZRgmFp94w71LRfsE2Zzdru9+uDsNuEbcrgyGGmhfsD/oJMnUYxgmXSqRxCvF4lP6s0usQV1IhZ2MnjSRqchhCEaoURhmM2uktmulJRIOiwZipMNqgLAXNQASAJgVlyJ0XR0IwZzAoQm9qDmrKGrAiFpEvc6jneS0rDosqHN3lc48qlKpUAtSXn08nIonqkCNaKYeLbXAPxUqoVDiiYh6dxcXpSdnKhNwJygFd+Hz8QhwGY2/0tTH67hnaoey7Oxptb5OIYkRfjCz8zloN0yOjoeGse3wrjGGdudjpWOidA5HW2Xlc5/fi5yeNnkPXe6Qe36PFggyhMuyBbiutRm1mF+/xUbxpmg2lvx9UlCrKYs0znx8GZTTqvjm5SEk8pMAqYSAGo5M4DGa/Gu9NHc6qg69757kPenPzsYixXNwxGKOg6rBYCeeilAdEwiwv6VB00I4Nh6dl8zifrgyOVUQukYWIlp7aSbqm4IgAOzFv5nMJ2WHj8H8mbEoq1d5S+/foz7/Jdim8e6Nch7Fdv2bsFRsFuVaKDSSb/ghe6C4FHZVRxR2sYaBQ+xFRMfUMS129S3pd1ZmWolWVi7XDcq/Fi+HXdaHWynJZWIKg47pB68ptaygBHY7A7dl+cBsvHIBgDyth3Kvmur1bfRNAcxcqkmAYvFu753Xr9RW1wrpCKYZ016PjViFWqQQpQF2qk0QCrx684e2rJ3hdoaywrwsf1gtjPPGtL37I//Lv/a9YLk+094XrJrQGN4Wu7mhoui3hCFODHEVBxHUc1W3ZJfTU48MDf+8/+Pf4x//4n/B/+d1/8Ik99/N7fHNHo4aiszBOw630rrjutd1r11DYWWkdAsvLZ2KxqUzvOr3UaU/jwss78IrX8daIrArRhMuwNMcjLVkk08ZhmLyUkaeNTZpTVg54kw5seNfVfd/Y9iu37Znr7er1GM832nVn2/eo2ejOMtU82qSR0rZTlOIwatIReOEQpaFyKpLPHZTOlr+e3n+8kI03EqJyPkpMFMxdeldjNI15mxC1OdbMCJXz5J3CCNNxkvlopyLIe5NwWub7h3Cdgk5wR8KZf+f33MsanmcKmEDX2et5ypNpzkkQDQRH/DCjMxAtTqM8NNgeDg/IdDC69zzoERl7qpU3UvjwGP0h0lcUocpCqSDdsAaCN95bLx2rjQ9/sLO925zrvgDJvW4EtjcdiUFdhXqtFKsgXhyGedS9UKnrE5enL3jUa3Qh3/wZaUf3Do9RA9EdDz10R4vCooxR2LeGtK/dad43it4oVRgUhjnsbEItAh+MyMwyeawmnvDEHEc0Trx5X0aHOAUf1Lx8U0pkO1Wow7MZtVdaGVQWenFq46JKHcPhcM2f5qAgS4EoKp/rXAlY44tlrkbRdIpiRQRkcYjDy6pArSUM/pMyy6Bbyij1awk2CRCs6nR6Sjj5E/6Y+/VF5DJHEn6KO1zIUdAas5zzXaKe0J0WwxkQbEIkvZfIp4y9z8fP4/Hq1SvevHkDMB2JdCDGCIrwccpgnDp8H12+jYOe1magxUKhZFYDDjk5Mxp8ejUd/kRKd7v77NnfeKFtTobhaTxq3m8nyDOsexbUxCl5NQIzWsxrnyyClsN1QrED5jUhMNUjC6lqfL9D77Dv8CxGNeOmxm7GMDdBiszWX0x4lx2/u3cRMKgZaFDIbEbOYqhasXvL16GeMQdTF8tU91EpcujNuzk71N75fGJeJ2C9Mkphr4WdQhePvGfQw+2kw/SKQQS0J+oEotBaxHtiOLzKIdVFbAZsPJgc40sbKf6QYt6nKiDDD68qF3x+NSZmb16XplqOQGXMh8X1vb4mIEVF5pgkFtmE/mFYFoifJjsfWcnneHQhPAKv8ZxKOZ59ml8a45jP+xRcw2BdhMsCj7WwloqwMmShFWehWi4rv/yd7/O8Da5bpzVj7+b1VeZU1DM/IjZZ0cTB3ujw6PMQ15MJD65F+KWvvuJ6vfLVt7/N+w8ffmE6iP8U9LaHJ+p/EYXOjmsn0kNuTNr9ooe5gByWQxgVBCPLYXimsyFhpc3C8oi8ayh60XBYtARjkEIdHhU0ZoT1ZR+NeUzsTt6VWx/D1It094ZuN/r2TNuf2bcrt9uN59vGdb9Fc76dvXX2yQUexXnjEPLH7MX/smA6NlFyaRP3KCGVsrgpFciBAT2E2PEkTjbMyQCaTpvdK4lIG9w9m+kfpL+Q8vVOmH5KQb1UOccNT2zmx29NOX42EFMwu+Gdgw9hr0sQETDn5Tibnu5bgIE1An/pmNdSxGsfekSlTN1wLN7cqY/KVStWhe0WKeYouGZUZAW5qPOvj8BYSqdYR58b9uONsd2cUnGAmDeppEQkvYNtyqiD1t2p6L1gPYx9MSgV6kLhia7f4vqmspnSdzc0SlFKU5AdK0Yv6s0Sm7KPxmgLDw+VJ9nRcWW7DfZNo0lUoSuMHpz7yfBlhwMmpOBOJcNkR5k1DJFtSLihL2mLgMGgSKU1daotK0B3p6MURCst+0ykBhyD0prLEQk6R3W+cZUYSDbbyaL/F0vZTuvBJk4BhwRMWCQ+pjDmNW5MQsNPhzjPN73EMOgQp8DN7EQ2OcQVs0OtUrHmoneWONMTTvl8AwszCp104RWBGhA9c0NAFDfEPh+/EMff+Gt/nb/w67/OIDIXrU9nY9saY6gz13VF+3DaC1Ose2SdGdCyBHXOrXxusgdMyXqwUzGdYDgM3Ll/ptw9vc/ZSP4JEv8UzDIGyubtrsZGGW7AjRALKkfmRTEWhZXCxS5UVkxfUdlABsN21JoXolWBh8gAKu58YQypbKPQ98Lz4kQZH0zYrNDKcA6bAY/NoCibqGdVCpFpFmQ1ZFXkwZBdvTg6adsFL3hPSJEE2kC8tszlyKBmRD7hlDEfakafkMiKLH6OfG4aQabc656BVqp8oJQ/YowLtsF4/0fsz++5XQfdzOFj5miBinlBuxakEnUTOp/pYl4fsDxJQHPEu5QPo1I9E3RTaIIN8fSFCMmHK2bU6hC1y6uVh9eVN9++8KoZazNkNequ3IYit1gjhSDACOsxoUTi0MFSHAocPd6xKKzWuruT3fo00s/wKQn64HrxgmpVwUS9JjKegciBDrgoVBN2ipOsXB4pr1fq4wrPHuVcGNMhefUkPK6VL8prFntEtjds+opeHljfKGUo9dbQ1tjfd57blW1s9O0ZjcpOSRRE2h7VURfVICnUHXqsIBWJyJZQ+cGv/ID/+D/6Nf5P/9V/xT/6r/+b/19Ezc/M8VPQ22bUMLSoucd51K/cOxczSi5G9Ms6CkdxXN8wQLKQ+MhsHIIuMfoaDHdhKBDoSnOP+FDscVLzzsUq4uwyd8fJ8tZ0biQYdBxb2Hun943RN0bbaNuN/XbldrvyfLtx27yYdt/dyWijx3W9b0ZGlqbdm9GGF1EHi7vGw8WRmo3sUMl3D+ElMDn+xU4ZEF44Eh89h/vXzqU04ePcfygFw9mtyOJ1SSchMJ5z/x9nma7QnXNzf9+fcv88ixX4RLn/jEDAv2xCAoxTkuJ0DgsImeixYh19YqEIYw4rLgAEL+C/7uxWoSlmHdQ7YUsNOrshUBd3Yg2keypZ3y7098L4OhhfouZiRqWjUM4qaHEObyteK6GlRaFgZuUUsRuj/4jrn7iDO8YO4h3Gq7hyUBZ3kAz66OjeUOlUlMfdmWm2pmyqnjJe1JtZhpOQzsQRdbqfx6MXxPG+RBZRzcswHSLmzfsImE+WzpsMbOzI7jnHIoVaO720e2dBYLHCWrwhksPqhlfsSMVs8X1cyl337rsnPiOf6tC54oaILEIQRfq66l4AqMU7sCd1Yyr48K9nRM23ZgA+NRWwj3FOi4GX/KVsyqLZiJAJvhZmRNG81i2MJSIq7b5R4c6f0BAD5dP75fPx83V8+eUX/Mqv/DJffvmFO9JRf5FZjQmVUifO8GJvdzL0RF9rmjQmoWRmVuPIABz7As6exHQyhPSoXyyuzNZx6C2OyDzHGQ/5Li90lQYroHjQp8V2ccZJN2At9XKsbxGotVLripRHV4l1wTbxZkkdl+cj9o1aBGjcOCsFyirUiwcmZBdK93s0fLu10LWJoc8AgwOgYq/p4bxNmFk6ELnpzzbPUKx2VApjRsWzxsF1eponzp5IOAJu1yRZjestpm3iVSgbi33A9I/c/tnfM8YNUDLJ6WQ87nBZ2llk5YnTzFeDS3UY0eWVMFSQvTitfNQDqHlwLVChXj8nBcoyYXelBD13qRQWFlu4VOVB3NlYxDPyZNO7GtUak3HEbRbPTJWg3q2UWuY5MWMRpbcO6mOdcN6Q10sVliJcHlyGdy2MLmgjYEueSfNnZh4Id+Eb11kp+ui9s2iefchxSQaDCrI+IPKE2FtkXZ1+uXmQTOrASsfEYfO97YyoI3V5HraSZVYmkDkiiHptpCc0vLeNl2UmbA7qWvnVH/6Qul74f/83/83PfWbjm2c0RhbOpPL0P2fRdTnSmxlZEQc8e+Q6o35ppd0JSd+KKhIpL5vOR+KdQSnDjY+wQqbRMeEUiVMwvO+BxWY5H2Y4PWp+xxcVEtmZ7oK/tZ1bjwZ82419u8a/PZyMFgxK3YWNjsjw2GTl8dkKwRPFs3MYcW9n4Z3WSwrxAxEqB+sUMBlwDBcUOvdxnOLkRcR57eXLd6nfTI9azKHNjXke8b0TyBzdXBAz6hVRbzveO11qXn8ON9+yfIhynDyNvWCyuHdX/Eqz+Nyy9sNA3YGQMNJmEV7CUTLTMDEykZHaElLkbFCzwy6ArsilurGKsRejjIK+W9BV6NXjGRDRFTmmrS5GWb37dCmC1A7bHlEzZmZvmNHHDdvEu8/r5h10QwDW6g6+EzA+xlq/YmwwjLYPPhSHLbRplAwYYTDLyfhIrzHhxiFojzVzdjXsWDen99Sg4M6GRF2BkzQMp4cWgqpxYRmdMqrT/YnXXlQVBtXPE4rei/CzeVWhjqhlyLGeDje2MmuRIcG4mZq1O7EiBac0XIjGeZJlVO47hBzL2q+ZQi1Of3le/1FO6XaSFTwq5fvSDUI3eCw2cxJaZIEgVTxoMCGWwUgip/VWDqjY5wqNn//ju9/9Lv/Wv/k79N4Zw8lDktmwj1MzPj3R14bDYaYBeXTIkcmhT6Zeif2TJCwzw5EOwJ1jwPEd4+44JKy8eHFKDo5+G0eWxOGXESwZjSFjUpzPmq2JI11IoeNyTVjryrJcoLyCClpX7FaggWSkvR0RKKlO4lHxaPv6UFgfHZKzfBB6iUJc3D/ZY/8O04D6MOHZC94M0JpHpIfE5xyyEbJRpn5Mp0AiuAjCqIsHHKxMTeh2kffAEAlDPaCa1srx7NKHyXIUlMqNioYBC2N/RvsOKKtCNTfiLcargrNWhQNVGR7EofKwwHIRnt4IbS/QhS5One+3JAwtgGIFqnhzO2SJ9RMZ9SqUcArWvvBwMZ5W5eGq7IjDgYvBqvPepcU4zefQG6+XqI10cpOyeu2iqFGrZ/h1ZDNYmVCpIoXLIlwW4fWT46L2Uem3QRvGHnDypDpX9YawJhJZmkqVCzKeKPsDRa/I9GQJ81FAKvbwCPU1Ur9FeXC4r9zcrpXaYWlo3elto+8bapvbf0owp3ugy5+Je9NVvC6zYIxheGG9B+PMClKVagKi/OZf/Iv88Nd/g//+n/2zPz+OxpQzEb2YfWvyAycjRUWiUQnTkElsYwo2iQi5xYlfyDrO4g5sKvGz+Eu56tmOo4DVi02jTOGln8G0NV3ODaKWIJyEoWjrtH3ntnsh+L55Iz5nnWq0vdP6YGif+NnEy2oK9LOhbHZ3Nx/dImnzHRmieyP+UBRCKBaxj4wPuzunTWN+zth5/k9G/J1KSUdl1tUcTsx57HL6n4ncPZOP0GpxM/Li5XMyXtJDlfP7L743nTXLbx3jy3udA4uLZho7BmLne8VAgghAnWVKLJQ4/WB7yakQm5ArlWg6u3VMb5g2p53M+hwI3LFHl5YCl2qUBbQ6lEG0T1/TiG7luNNaeqN0r6cYE3Dq96yIRwkD2rXEglMztm70gKyOyN5IibmDWZB48g3zf2EMy+lZu8BOQjDBJjXsjL6RrqF5PRXh3ISNPnTQ+6CWzrhUihbKcIVRS0EXj9YOHdQxZubTESLmiIm5sPjomHVLuGA/YJjpHjnjSn7XwPnfT3/b/O6LS0issZj7j9bm/MVrw7KfzQhHxaNpU39Nh8IihCrg0bEII0oo4skaHLUbOR+fj5/P4+npid/5m/86X3zxNrLlDpXqrTG6w6e6Dnc4tu4UtjZm9iIdjTFcz4wp9Jh70OFSHsbNrIWeVvShFuxeN52O45uHDLeftO/keD8/4mbTcaaublgPySC3UCVzpSM+tzgyQSvrMBYZjMcbOjb02rGrYlsYEb7JIyjjLoZIoT4uLI+V5XXhMgqyK0tkXaWANqK7c9Y7ShjB6qx3Q1gsxwO9D7QrvSljmPfXyABnz+Iu11UZl0OFHnZKiWy5FGD1QviyD4q57CluAE3nYAZ8IHp5RK1eXVguC+PVhQFs2460QdHCJQywTYxuPtckkmIpTr2+LqxFuAg8SWFVeP0B9qHocCjRqBVvSusNaqsqxYYHPapgD5VsPFwkiHzCybkIPHXjlRgPYtyKOyOM4U3pSOZMv8URTl0xnKRDLYg8FFpn6XHerpQOaoWtBAlRdfRALYWHpfC0Cl9eVlgK18vC/q6xKVjviEILXaAqdKuec178HoROqRuyGMU2RDuFHs6JQKuYFaw/YfUtXL5C6o1iG2X/QLFO2XfYvJa3i9JE0XYEiZwKGUTqhCNO+GE0AM4MuCcWneZWevRIE/U61T5+IWT/N89oFJ2GrBCw6eINu9KJSJM1F5YT/cjELrt8s0wgTGmVyYv5MCSMmskUFEo88eFzn8uBg4xzerIjipvsRLN2OuY1BE/LWOBFk0Jwa7Rt53bb2bbGtnX2vbFvXvjd9kGLbq2mY0ZNx51TIROilIb6vP4RWjoUxRxb/D+dgFNB9mHbheA9Ju6Ibh0XIZf32VOYPODkd89ORtJ7nUZzaI85insdJaefhwI8XJyTRXd4Ah97HTBxUPbibSPnwWFTx/jt9JmXo8uJv3ct/EM+TgtqDTNxyI16YaJGrU3ioHWecuBkYmXClsZ+c4+jXem3PvnEMQdQVV/Jnp6XoyRn7LFgwoFx/K9iOF10Nq07DOnYG+psTUPUBR9GsQbm+7MN2PU854eTYnrAIg7YwzF5kp+Hw9LIIoh8dud9ywT+BSQo9lqQK6h51EZQFun05uxbTl9bGL1G87Fo4odQdQFdvc6pGCxKAA4mm8758DEE970JGtkHoXimLyGSGutr8dfK6VQauOFZxGmuTROaGOHBKf9yP81kadBazo8XoHomySxgVTlnXokYTgazmDNrRbKIM2tNTJjRuc/Hz9/x8PDA2zdv+NUf/IC6FPoJJnUHm4qMhkbPjJlNDQdidtzmqNk71mJAfOysW0Jewp2Oyd9OSfGpew/vIn78WQZOitXTXjrESjjalqJDfI9gToMwHXtf86IlnG7FrGG9o9vAmrksAGbwK5z/dDSk1mlcSxMkM6DnMal5DwnB4adikPVibpLiHzuohG3WKUaQZxarnYSmF2tMGyBlqL8cAt/cKvJMQ8BpT7Cqu9x+wGuKCKUKdSnI4sJneDUFWKFGo2OJ56YpfwSvc6vZ8O8ohq4m1N3c2VGXmiKCyYrZQKV5FP4EVfLCe8+8TFmlh8O0mLGoO1cl5jHHlDbIySghYjCH/jFz8gt1p8+fh0PKJCMtktPizk+t3q37EkUj/eHCuBpF+owHJUyJ06hKXLzoQOj+TKx7KMpGPMzQGyroWDGLrEbxmkzGwEZDmzujI6B2Q+yglybXFO6sJVlJOGEloNiqGrawxO/CSDbH4X02TI2np8doq/Dz28jvm2c0Iio6kS0C+RDDvj6ONKji7NlAS8JLSVt3GlJypHcBD3YEBtPmZkz7Uj1EEp6NhHchJQXtgbM+sJjnoSXWLz5cXJCBZyZGG/S907aNnsxS2862d++XsXWGdUzj37AJv0hhP7klXtjUh5OQP+wjYZ5zZPlNO+b8MLBjDk4b8SyuUhzbqRHhXaOgtKdOn//oTQ4jeLLqzPt48S2Tu1qQ415Ow2OiYo+vzb/kxescyY2T/J0dbw1eIuKmrgyD8+zkyfy+n9gk4mm9O186DvnJ3o6Hr5AwmjhRMIoNlkjDKrVv9P7M2Jqvi5zTsM2TGGxPiI4a2lwx9GJOIxhaamb5otO6pIMegrl1x+EOLZgNhuyYKA1XjiON0fM6w41bSYEdiyNvKz+bTvvd0zDzjV/mG5+sF7BQoCUMZMXmHhMzBoNWBWl+rrJWCpUug9IGbR8stVGKBVa6IgOqh74c0/xJzxQsugtGa0Qs0tGeMQjFntzx1bNJ07kLK2uyxUwDJmoqQnmfDbRkmc0olMW51DzNb+ImixYFHdHt3bOsiI8hjT+DmS2az61E0bkZjCMCK5++/c/Hz/AhIvzbf/tv8b3vfRfE2Hu7y2jst52hg9a22X9pqAcrdATuPuAxgGfP79ZjyrXpPvjPkJPEq3BA77I4138/BxfyxFPzTPVzb7FzL9jNT35exvPKduhusyzRdGiOdh+v2UpbhJtUpBvFOqNdPaOxN9oY9NR3VjzYWECkoHVFlspYq9dQvXfqWrSwD6FHEToFWIiMqz+XzL5SBlaEsYBRYu6DmU+yzi6bDZY5+QVNoqqTvo7JEI7gQougSwStBIdoYebkHIornqDGKqVQl8L6IDxcKk8PC71dsCbIvoF1uFRnARWHes0sf/XzL2uhlkqpF2QxbDFuu7KrZ7wHxmaGyUplQXlExOtqoKPSaRGsqb0iRak16z2M5TlQ9E/QF6OJ0TalXZX+HHVFjIB0ZzDa15eWsNfMqdG1iGfwB2ziGf6beX+pJgUxp38tYq6Himdh+lLZnh5AFm7vHrld4dacWt2qOfwoq9dzcTZcGfbmzs3qDX2FQS0NyoKUFX2AsRZ2e02xL4DvUlZlWRvb1zdG39m3zte7cm3jgDmSsNl0XEP/iGCLMLp58LsIpQysGFUrNsyhvBU6ARN3j5haCv/+3/2f8vu//8/5L/7L/8MpkPDzdfxUrFPpWlpi99Pqy1+DHcZtwHAGFMcdx1mkyEHJRkRnIso3FS+eekxplhkTE7zRynRKjKMyNz8f8CUJM/alBVygVAmDJIq5zNDe0H1jtBttu9FvG+3Dlf3Dldvzjev1xr5vNN0DMnVqmnRMA1OkT4P4MNKPDuFp2ZwXjczbIe8XDSPTo6dCpv5kmu3Ms53OWUL5ZFTnnMU4W+8nU/94xqefFsaX5fhOn733nubZ7O78CWfzq4zTFUCYDSDD4r13lY67O+7W7qBw55hVZjoSPnfclpDh6/OsecQ9pybm1JiR4/yccD4P6BB6MaB7MXg3+jD2qaiPi1sYCjTYdqO1cIhHh9IZIwkRahiSzpphskeGxTNm+boKNAlGlLiHhrlCnAPPlC1zPiWfo2ZVQU75yeOYlkUq59zvOUmx9+esWxjLBwAu+1lIOO5z3mTQekF3b45YbXiqWipSC0ur7EWoowbk0bndLZVSFBZ6puBe0Hoxuk4DIoAJgZt01pFaQWqhF8GiStBinEI4rXfOskAUi6OntTC3kczCSyN+dq+/mGTsA4TqtWKlTmigJKBliq2IduVezb6S4fyKxJr57Gj8XB3f+vJLvv3tb/H27RvWdaXt+8xe9B4/oymfZzaSvjbhUuFkzOCKTZmVqg+YEZb8TMJnyM9YOCDTjzhka0oDmfL99EWBpHD9lLNxJ8fvtRoh+TiLGAu9TCmQcFRcx6m6sbYPo1jxAOHwRqVdT/fMkQ3If97V2ff6SD0wNLqp+yi8qJkDfXX6l6PVaYOcAqc2tUXcowInumsiYVF8HrLW1IM6/p2jz4ndRfJd1xjJUJXPMmsRKs4UtahnYEqmEsKpmPMa8tqz5sHGRECSIipi6k4N6tUIqpFMr3hWRYbrlDh/wvMEjei/HRS4eJ2hrG48J+W49kCDEPcUENGpa3MmJVAoxWsXbCmT3v6ciM8WBjOLEv88s+ef77unhNvodM3uHQGrq8WDgcs5Ihm6Lxg3bIRtSZAGeSMTrC7oUhmiDGlYuSLsiHZ0eMDvuQ+25s2ctWfgOWtRYp1yZK08WOyw7BIRwTE0dIqgASm0CLqrqr9W4OGy8sUXb/mXfuMv8Ed//Cf8+Mc/5uft+CkcDRArRwM+4fCkB9HIzBW0U6fFcwsQoxjBBhRCTo7a7YnOiHMmfzynjYmfBqKhzPRUSnJAl5ALh0iYm/58mHijGw2h0T2S1PfGtm08X698uN14d73x/rbxYbt6D43rlb3dPKU7mheAnZUAIdA5+hKkQ+aFPkc67U5RvDxCYs/CZr+N/N+8Sor36WSclYueYBx39+/fnBHu8/ntODcc8+5v5QM/j+f868u80f0VSeH94lM2v30/vnNSZS4W7DTOQ1Hk+dOZ8CeQ8xPrbbwYwQzpHTdxuvPDXziPoeBOsogryt7p2NFN9CfOgY/IxA0IrPti76mMKwTAytXuANtAb07AIGenwHz9Wj+pOhxukKH2k1MpORk1rIXprZ8Mg/wlN2A6HfPNYy1OJ8M4nLf5NYlC6vxkQj5CiaggvaJlMBiMMpDakO40v3UtNCIFr/6vhkJpimN6857uDvXmiOLrRgZMvAZZa+0pcYbXjiVr1HQs4qcUXy/ZQM/KizWb83m3NKIANrkyIsNpERxgVKIrFTAmxDGQoORAMlAjchgrDh8Nxdg/ubg+Hz+jx2/8+q/zr/+Nv87WGn1vtNa8BqO7cTLGoHWnstWW2YyE7NjsxaSmBxOacedoCJlxPfapW2tyRD5Tldq9k5E/ZxAiAlPgxucBAOZO9N8dJ0EpL16exrCkE5RvBjF2Bt3qzjBlV6XvEZayEoZbNGiN1IsbbK633SNvmCljN5TqQZsxQDtt7163AB6pBhLimJmN4ooZU2MMiWxiSfBPzHlaummwRqRawyGQgtaCNwI8ZsKvN1L6e3ghZEvW2DjLk6V34ZmW4lSvixYuHR52Y3nqtMWg9vjSkdnCvKA7A5QFYwGKKFIaqKBd6M0dglYdGlWH33+pg7Ju0Adl77MmcTAcMTr2w4ER76FR31TkscJjZTSl79Cbd7HvhUmzC3YH6bYCJsXtorWipcC6OMlPF3pz0d0ZFFGqeNF00VAivjjRqEvZ3zesdHYam3U26XgDRUHWxbMZa/Q7iCyDVIFFsFExra6DbaAdallguaDrhbFeaMvGsrxDl9+n6HuqXmlNuO3C17fO7Xbjdtvo+w3VPnuoZePguebEHRlFvfalRy2idajVm+sikRmM/luSAb1KFeNb3/qCf+/f+zv8/b//u/zu//X/9qnd+DN9fHN6WyV6V3CkbyVweZJ2iS8sLW4jLTrNvcM5id81IyZxshmdnr8fgs9PnVmU2PP5vcALikxSUbc7CSPhBbbZnQKdBlIRT/0NG2y9cWs7H/aND7eN97eN59vOdd/ZevPNNIbDXcKYSIGKecTZg6N+s9NO5nAaTnd0+n/cD3Iv1NMInPPLZKVwqSLBnJQKgxfC/xTzP/sJme05X9qSMvF4FsfP80CZka687nn4nzpmUeJh/00nQM8vxrlzLc2Lp4OaLxmnLE+Y+JY/CeGmiGR4+ZhPX7dyP9Q7G9zmM5hFusKMLhONpcYIqJWc5oOjOPA4f3oKBwKO4vAozz5lVMMf7gB02JFpSYjgaUpsmBulYb9KQvdgXsuI945s/0e+4svfDxhFRvdP6ycMlZJOnfi7xU4rRr2ZXxUiXC+zK+7oCiXw6LXTh2Opy6j0pizroK+NOgq1e+pfx6AXjRSyF75/tMSigM/iXgXzDEg8gwlpFKWUoxZjBivz3sWNikI55sxCTp3maYqp3Pti4csJ2YjUwKk9RaILeYDMi84H6es8Iqgll52F0RDvnCinXiRyPh8/o8cXb9/yV//Kb/Ptb3+b1getdfo4/eyNPl8bs0nfXUM+s4BJZRYjAllJ6GCnPXvnSZwM+mnMM1+3qUDz/fjoeW3ly/G/Q9+8OM5C5XyOKVgMj45n4MH1sVN9ZlgmDOagwxVNnemZRxvZYZrpUPk5BqrCcunUxVhr6uElungPwGE4jOi/VApID6HekQXvUr1YBEn9ut4xPHH94WgMAkZ1ksGShjNY/pL9cmKsEvUADMN6vidH2WUoT5Ws4QhJKkKTwk3BdmOz7gyC+0CHw5ssQJlKORzMCGyOJCTprgWE4p2vRVijZsAGWDWsDGwf7tC1jpiyiLFEH4hqStECUilrYVkLT4+Fh4fCQ1lYlx4NURUvro97KwWT7LWkMwgtRZzattaoIVk96FI9GAWGtcgElNStvlaA6cAUUeqmAccz2B2dItl4sTq7WfazkqI8VGO9CA+vC/1WaHtlb247uG5fQBbMLthYsW1HlvcsBuulc1k69b0/o7F1RtsY4xltzdnhsgnuiZThTK6SdVYmUWs1orYX80B5EaSM2FZBqW9GsepQsGL88Nd/yNObN/zDf/APeffu3Sc25s/m8VP00QBE0VN60ZeQe2luo4h7cmnIhZJWy5RWbCWxKRu9iDQN5azZYEb0/CpyFPccUpB4c3rzM7JDGBNikbk43QcnFyCM06FK08Gunb3ttLaztc27f+87vbWZ7nYmIjsoZeOkNk95RF1flk2f5+1kcR8Gz/QWfC4nssju7vjurIeN6yc6fy7rC45akdiwaVXPh2DzBiS9hznXp4k+Kxw5XWMO5s6NOAxXOX1dOZqenc99+vHyGTtenbmejiHEuptfOV8oHMrzOWLCJKL3cpwo5t7mtc+uyHTKxmH42ZyE+E38+qlQ/XMSufXjo2fFD7E+J7QwjYZTOj2nLxTh3RxpXjj+KR6VS8WeUcBcY2cgdY5XmHvuuCt78ZAMSwakU7bRpzy7uh772yyj9WlsmKeBx0Br927nKpQh1LG4gG4dXYQhhS6VWitdK2JKFcf5ehb0blGSmj3nXcTcKh9M6FNGayUVSowxp00iRe9z5Nzyd2v2PGlzL4bcSm750/tYBhxwg8PGXE9zf1lshKNg7fTFvKTFWvl0DdTn42frWJaFt2/e8pf+4m95lL673ugBl+qj0/ugJetUPyhsTd1QmnUZpFGtU0wfxgr3+oNcTylrTvIDmXUZcxXfKYnTr3dr7IBgnWM+dv7w3OP3elmOU3A4Cr7OD1KD7OHQI4MxppzVuKimwTZlk3AU27rxKBWWqIzWkDNqikgoDIVomHR/4yVeLv5WytEMaKapeExc1r2E/SOnIIQFpDTnadou6uxLZlg0IS3VZR9EAbHJ3P6CZ0mgMKQ4qyFum3T1ho1Mal6bY/FnehqX4RH87thQKcKyeBF1LcWhUyQdezSC7NEUdkKknF2xBOQLFWqpLFV4WAuXpbCU4tBUcCcjDZUpk4/Muf8Ub9wa/TOyM3eJmsoShfPFAicQ69xCj6RTPXteRMG0MKD7s5sF+Emdi1MNF4S1wsMKr5+EmwmiXsdj0RVaStyNLaCFaMzhzQwrrCsTCm/NUQ06toA/2gyoZmBryvQk9ziva3XrZAAy3HHCRjRZzOyW28qaOn7AV7/0FV999zv8d//tf8f1eqX3n49U9zd3NPBMxSwq4zBgcwPeGVBp4IaizIRnUZBgfjE8EijibzpPi1PT3kfKZZ7vZOPEOIiahOM9C8PRzJvMvLiRw9w3j7h2VfYxvPlea7S207eNtm/+dygG5zcPHGhi7nIcOeaTsJm7LKfHMmZ5bzDP+7DjPFOGp9dl3DlS+Yv355A5luN785GkvYeUk/K40zB2jPnF2M5XvNNtp0Fn9PsU2H855fdnPLHqnOzbF9fkMM7v5vWlA3Rc4SV8yQuxmMahhdCcSKxcv+cLWxYM+kup9OZdTP7i4yXj/ufH0K/zVyLKNyfLPsoG5bOb85vTdn+7zIjlySjwP+WjtXLnAMUb4h7WVOTHMI5MhcVimnM5hyVTO+b3pjGdm1EgCQkMImo7GFqoVjxyGKQKOgQbgvaFUQfDBk0HRbt38Y6o4YsEJSWEsuV1YxNO251cM4H3rYcunI5G/FqIDEUoyhJBg8Qh362tuKuSl/Rvx0TnXJ2FQqhalTuY33G+w6iR00OzeM6Dz8fP8rEsC//+3/27fOvLL+m9sw/XG1vb6H2wbZtnMUZ3Wtsx6DNo5QbkdCzMGJGC8H3j60D10HN3md+wa85BHU572o+XQvNekx4yzF78/acc502WDvJHSuIwN0XwOk67/0i6DiMCQ+lkKbNiwvc/gklFywLLQlkuLEvl4WFFa2XUSqsLbAPZQhotIwqth8OOTIOiu8BSkbJ65lsj8ygbOhqjd6Jna8ypnOTt6ZkIsEQkPfWZHtn2kjVja6UsxaFHrcEI6tKcJXN4TYmI/C6VvoCUYLg0Z0SUUZHx6HNaDK2DNMQJqCklZOso3p9CKg8PFy618KobHeNq5pAzFezmNSom3sV6kcpF4pEOfzZWYBnKQxfeULjUhYdXD1zedeptUG9C2SW4yAMPr5CUYeE/eVa5liTrojwaZXMiEVacRKMP3xManexEwFYv7n54QF4/IA8LdW9IV8pzi9WUkDocJlvcGfXGhcaroTxt8O13yvuhPIv3r+94EIzRwSqUHRbD1oI8DJYFHq6Vp2thsYVSCr3CiDkcqt6ZzVJK27RZDM+YubOZlS9+T30aOCDSfd2PQmFgujhETuqsjdHuNL1ShH/nf/J3+NGf/An/xX/xv2f8HDgbP0VGI2ECnlZMT96pz9I4Tk9AKPUQZGbed8CLbw/L0USm4BFJJZ/Ic45I68kguBd8voLPtR8zxRqOxkvDN2MAejL8uyqtjeiTsdNu3gl833bnOO8eUVB1BZBsRHedV09XuL9emCQnozENxxl3OhnDh7Q6bv3OiDwsbj9fMjqUvPfTuWK+M8I9i+5dU31k5acRnzjxGdG5u8e0Nk/G0smBudM0ac3Ne7UIlL88171lPgvKzzdeDq12Ny9nv2Na6C/m6zy38ZpMjyMvGx+K65z1ps6L3a++2SiQ+2mSPG9C/ObCnZbj6X7inuMpzdR7TEt+PCYxYDXHTsiurSf8YjBDhQFu52k5Pev7mZzjtPPZP3r2uYLLzEyVvK18xnqcdo49orJK0AEOp7Stlg3JmnO5j4pWj+p0VcroLKNgvXqQiZAJ52egeF+TNJE0p8qi+POwvLxLezzjJJ2I55jLQcWOfSRQVBwGFbCVGVkL4yOjfRZOhWY0TkokDs8LNOY5cfRzHeV7Gueq83n7frDzI/h8/IwdX7x9yxdffMGXX37Jq6cn9tsekKgMUPUTjW1kxqMmYxZwJ40t52Z7+Hvx+5FhOO3LT+zR+VbKjPOLfoLjFTl/PnXVSau9VECpIz6+4iG4Xg5kuuW5bc7OhjEDT/O6AamS042nsR8QHKJrNbUiS0Vq1EKtzjrlcYmILls4GCFrjy7TUbuVlKaS8z/iWWSG3+fA60cO5XxkPOK85vKmFnOyo7aKXjgAAQAASURBVOqdrV1u1eN6koxWeaq0c/z+RIRahFqNuriB2g9lG4FFJwlJmM6s50r3RjJVU/F2hEtAwoLyP2TNqYOA31RCddN+mw8tbKfIJiAFtUofld4LfQaBUoHFvbxU0JkKygZDw+Zt5HrP+/FsmNO8OySqImWh1JVaV5YHd0zKzYI9MsecSAEQFc+2EHabGqPbQWM811dkyXT4uawAw23X4Vn4HvUuY2Tg/JR55FgHc+/kL2kzzuUSDW7NYZHFvPgbEVQ9C+VQLJlNGC0gwjp8bl6/ek1v/SNr52f1+KmgUyWLn8mNyvGTNAKiCDIeuop4F9xIpZUQGoIjHIqWCPp56i3JpjI9nL6GqR31WIf15co+ijd9bUcKMDZJeSEO3S6w+VNRehu0rdFuje22cdtu3PYrt9uNvTdnmEoMXjZjOxnw944Ah/12Hm4aQmncnD8b35dpDKYjx7Qhp7FRjxPLxC4eBvM0kpCJiBKz6GadDsS9skoBeRjDco9C+kmH21ZeXD5fO202i+dzuvsM155dC05ws/vTuwVrp1eAO8PrgATYnKtjfuOdGUE+KzyLtSGHoI15MwvnIhWBMFkkUp7cweKKzXPnc5t7INfsKSvlOtM9w2lccAwlqYgPJcdxb3f3nRhYOYzf47Z9nHK6tZkOsLmvTrM6n9WxDs9Pimm4nBZlOOuHgoJkibG5N0VKBCqUIYNOQSQiTdZpVVhqpfSKiFLLwJaBLAXThurqvO1nfHMcVSOrEAGH6T8TEJOCvy4zrnqnPKduEC8ytBh77mtVf06HM3AsFzspfyTaU7nncnpgICUzQyeHEsiutzMLI9ERxPCoJEdA42Mh8/n4WTn+td/+bf7Sv/KveCZjb/Rtp43m/9pOHz0obBNC1Q6GKbNg0Qk5oAc4MBmFMkgLZy2ih2w8ZRtT1h6GzkkunQ8zDkD9S4l5MpSOk96d5ND5Lz57+rLlPeQf50FI6tCQ8QpHnaBy9zUDrDDx92VBygWrF2ytjNcLqgXtFXtasLVh78Sdt214wCEiIiIyqWQ9k7FiVhnWMAZaOtobNoZ/R2YCEh0nQG1hzrnXQrjhXha4XISnR7is8Pxc6F24jYrpglJR1LMREc3yIEdx2GstlKXy5lJ5/dR5ehj8ydi5DmO3BZMKSyF4DrG++/0NoS7J6OpMd1pXYAVbaduD9xhaOspg0DFzNsPsESLqRe1WBb0Mty/KmGO0ok4RvgjNKtuHC7ptaK+8K8K1uFZ1SKgQ+FUS5oURTE8FDQZG6ep9JtQzBBbUzjAoMijVI/hFKlJXSnnkkVc8ceHNm4XeOs9XoY7dm0RL/Bs44x8arH3GzfxRNVW27iiWtvu1lgdvUriMQt1bZPS9keHtPbwzoanw/lq4tkIzoQuMmv3UwvU42RKO1NFpT2nqSgvHcLheGYj317CwcU3dNhVjWHW2zhLEL0g0DI6sz8/J8dOxTkni3kJ4nY26WQRE7MxUrP6Jkp9RmTv0ZBOH83HUdtgJT36y8UiQp9xJrfw+871ItMLLz6Ugw2F4Xn9xpe3P7LcPbM/PPD/fuN12bqOzR8fWEYqBGNZdbcKfckyz+6VH8kLo3hm7M3R1/5nZUAw4+xg5lvvhWNpPM+x8dEs+Xd8+MZcvLz5P9HJQP+m4cy3mKx9/4hPXkp/06fPnIjP0Yppy6sRlxGnsuXaO9o13But5Qs5rLs97shunsT0XamapTq6GnN7O186R+JcYNTvma34q/8h/enpO9nJ2z985z6rvgI8J/u7PlUOZDepmKoX7qRfmXZJOjoW7Jq4wZmM7mDBVEaNEUfRIGFSXYIsTal3Y66Asg0pn4Cls6d4+e2hwqRM0j6ejiFEZgWizQ6dJwZbTrdiRvcDwgGDebhAq+NBij8vxRGc3UPGbmnSNIpHVGpiMXJVRMB9zlPcLHFSWh2F3ntsSNSQyYiWVoIRO3Onn42fy8BpEY4zoFDwao8e/gEmN3ulDvS7jTGVrzMiqnhzK+f+UZy8dXMkoqo/hbPhDGvF+jkMvniSob0zO1RzpZFtc+k4Kn0XCncw4lUGdPm6n7929eBI704me4553N88n54vmv4Cp2OhYM8azoyNUCrY3L27ezfsRpW5UJr4+swY+DxaBIp8plYLVglkw2pgGDX/MX0brg8p/IhYAqiBVuKyVR5RHNYanXCHkg0PjesBI3fAsM0jjxd1C5VEufDHg7Wa0IXP8FnaAZa+xkGNSHZJUF2EtThveV7wviCp9dI+QWxSnj0B8SPyzY259TU5Ow7jP4j1BpKKjMCrsddAYNFWuw5nDIoQbCyxTFalij0xFylztOh+rQwOTrtwXS75Xo5N7LYNVGheBh22n7oOlN6oNotDDv5dtBTTWfynsA5oVdoE+HPLUi3ltyFqRUqgFN/jVYBG0VvZy4boLoyu3/Zl93xltQ0c/mvSFs5x7NO2LmfHXCO5pOE6x0nVmX/zZJvWtFAmCEZydCxArFPWAndng4eHC3/jrf53f//3f5x//k3/Cz/LxjR2N0eWwxwJncBdkC4njD9ZXh5qii3iKLry1GemkekT5FFWxWJeyHIZbUOm7j2LufUpJvPbJYUmBEgadiqcuP2pwYgYjHI1u9BFQqeuV2/XK9fbM8/PGbd/pe2f0oyHLFILHTR/QlflKyIwZqTwbmHYXubcX76WEP7kTHGk5uXvdb5IJAXlRMHP/XFKdpPI4G/OSkLa7SToN+zRGTYv7fF+n9KiRUNr778174TCSs6A61tPUMy+N8nwpxnVElg+D0E+SYnFq2mP45/TwHLaEn5ZRtVQ+x3NOIQvnx3Oq+8i9MC90zI0XB8pdLUBY5CG443ya5896gNPpMvuT3ztfJ7Xw3XMKRX0eknDAp+Zp5HS+mK4cD5CMSPmOTc+JaVU4BlnD+Yq96JqY7C57OHiuQLw4e7hRUNyB6KPS+qB2hy/WOqi101qlyoosQg2Du0aU53wMc7jSVMApA47hMyNIYhNOptMZyJnzrAczQ2Khs8xxw2lQnA0eKU7jnT1PAg6XrFFpTel08LOYVZzGUF15WrVQRq6ErMoBzczTfESg8Pn4WThEHLbXZl+MTtdOTycjHY3W3bAZ6kZeGHpqbvDcOxpT+vhh3G3QWVg6X5ijmX/cZXo5DB7//iGK7gkm7hT66cRnp/gY29w3cc5jfOcZ+sRYT7InnSUlM8yH/L6j5CjH3pMsox0d2xV9Htgi6CrYrWG37o7GsEMNJyZ76qaQzcVmv56kwvYeDwmrIu7yHEgSomtgTqIfVZClsNTKI/A0BhsavXWj6N2caWw2VRQ3KhMX4hCrhUcuvBnGt4fyrgstZa54vYSF8+FU3n7dslRv9lec+s9WovnrcFZcE/pwpyIbFua/CU2IuddRSUdKpIJUp4TdvTniMGMrnWcZbDa4DWNXvX++Fk2BJgT+tJBLVOBo1LYFfCiJQzxWXaJ2hShSVyqdVToX4OHWKHtn6bs7SsUmZJWFyZQqUd/XzB1ID974/eriz+1wNISi7mjIUtBlockDV+20Ntj2LRyNndF7jDnrq0hrLW750NWWsHU5MmSGYepMkxR/nnV4jywtA5VT81f8XtyG9Grmh8eVv/ZX/yr/j8uFf/JP/+nHtu7P0PGNHY1eOCICQBpjMrLwiaNhV6QqFUEVZwZIGxVc8dvwlNbJOHJ5kF6sLzDPctphp1Ecx5ywjRIUu0bQXB7SdIh+DBs1ic7iyhjGuHXadWe/7my3jet147k19m3MJkrptZ78CeaIZl3DvQCeTs8x8PthzM/4e8LHtiTi4BjJTTr36/ElSyvyI0P6uNAdYxBpNKfh5B+LfXCWwx/dj7+QRtD9DU379bhMfPxUtJhu03kqT/7AHO9pov18B9Qn7WvynEakfo/rhG15BzXKk9/XzJyuJdNrczx+KJF8TtkzTeT0XTsrVTtN3v1x+AIyPzqzU2J3/oLq8bwE7iPZFuO0+9cmtG7O32l+VDKrP5/PNJrxzSocDZWISNaxN0MDx3P3eT5qGjJ4NYWcRESIMoeAEZhcg+F4bBsBoxqdZez0XllaZSyDsXTaqNTRqX2wNu9Wq6VO6GIeo0SWagYYnMnDn5fNx5JroWAMk+hQG7MRwRFTqFqcDfM0VyZMRpED1pbPNMwjZRb5JQsXQw76RYmIlwpa5JjfXE9K0JeeeifkNYpgP1Xu+fPxP8bx/e9/n7/5N/4mj4+P9JvX943eaftO6zutN7Zo1Nf6zlBzSssgFNGeNQGnWo2TQe4y79jQuSY03j/k2Qlqez6OjqQTP38nOuzsEL9Y1/OvTxsv9vLfn2HjfNL3mL/r3ctnWG9mZSXrmoYHFsBby+gQL9ouHrxwKM+gB/zEZZkP0A19piwDi+Z2Sn1wmOTewWp1g7f43vamexIZU3dAitRgzY3MgJlnPkdlH5X3YjRRnruxD0WbZ10Vm5mshGZlh/FSYNEFxsqH8UgR41aVP6HyQWG0GHfB+wopaDVmo1JbUK20AqgwGjCUMowiw2VgD7tB3HZSFB2eaZmsR6KYXfwel5UiC7WsrK9Wnh4qX76tNIGx72zde3uYBOd/tynvUhmdbZulqlMSP7iNp12wEdfV5gQA5ivGJGpc1PWR0+R2rrfNGZ+6wxHfs9EQsEJZK3WB5aLIMGihX0VYlhCiCkOcGncEdexjqTxehFcXccatOihfVioriz4h7QO67/T9x/R9p92ujLEzInDwEUlM2DHOhGVHI1f1XatylBgUjb4aRCBNDHEiLd8BtTh55TCqjolIq7VQVuGHP/w1vv3t/5C///f/Pv/893//T9+I/386vrH60mRRCAHnayEtX3cmTpbM9JVTCuXnU9mfu1xCfjVrPzJKEEZJcc/PKu4kWJkwBAvjy2bIbw7Ix2FnS83fd6/X0DHY+2Dfm9PZto29OdPUdDLOdLZhvc5Ri8zo77HG0gLLfycr8th7hxFL3ITkppT5UT/hCVJz1jIn7I/l/OUvd3/bYZ2frj2vYMf35/QdXsW9UpB0UOTutfMAX8KZbF4rUqbz1Kdzh7Mk5Mo6zn9kdPI2spj9OMc57X6auNPwTvc+zy8zdXwckbKdVnROJFNhz/n7FPY5BnYewr3v4daD2xRxz+e1cQzDlcl5Li1nJuZjZqrun9GRD7M5JWks+yM6ZhnJ8x0Dvl99aQCUqfJ92nP+jmvNbEw6vuLfO935NJ7c8VGnWRyN3oW6rA5R7J3RK7p4A6ixOgPVsB51gy8smlCa/tgkDH07zdf5nxwZicP68qhgSSB34eWTdWdpcO/kxcOL9rcOLvA3Cw4JcyrwMEIsa3MOJ0Py5GlkikfzsnTj2MsJ0fp8/CwcIsIXb9/y1be/4nvf/a6ThkwmqR7/xvyZxd+aSJKETFkWfge8JPRA7pXTTj22czqm+aKvajLwdYia0/deiATiPML5XBzLbUL8jvPm25Z7KF45B43sfJqXcu1u254kjr189aRD7nSSDzad8az3MhPokP1stMdc2/mrhzw/7bxQux7dX8WDqVXgKLE9dH1qsDluOWpTzzregG7CHudvCl2ZGau7Qn+J84QomYE+g13h2Tw+czXYU0yAI0csno643Eg9ogYj6yIjEiZi3nPJCLZ1ifrUKGbOcYXc1NPdZu2bSaGuK8ul8lgrxYTF8GZ6MbCjluyAPp0fHzgEailwie7cw4I13mxCpoQybQ0N2Zo+s5nRho9VhhOLbKYMcxpbiSL8GvrTJPWVZ3wKUJrhlSp+l954UVhFuASsSQqe3RBnSPR1qc6QqA6RPPpm5AKx+5udOzj000kX5Pqz1KzhrM5eG6qoup064uZVzetaAnYnAqbK49Mjr1695qtf+iWer1fevXv3M5fd+MaOxsQ6hoUyA7LFpmDJ6IimMS5Zc3FIIym+OK3GwtbDeEmsYCTsgBPqRcxx19F5/Ax7wAkCTvLkJKE+gW0WEYoYqoO9dW5959Z2bvvO3rxvxlEAHsLtxDqTVJd37kQs6mnQnXD4goFyEuqHgE5DN89nOdmnDMn5A36daUH6s7DzX5/6eRKRqcUOy/64hswPHMb7oWeO487ouR/nHJnd/50Gchqp+a4dHzgudb7mi2sfG+isOHzABjPinIvyo6GfB3dM+IsznkREzvsdEcGhFO6mZwr/e2fj/j7sbo6S7fFsWIod153zeJryl9P/k2zQ9PHk9IBzJdxNQyy3dJKnkvLBcOYAz1EquUwPAzo/kvt1qnTLa+f9e+3CUC+I69qpwyGKXZVlDEZXZ6CyQbdB1cGw4vCSu5s8TYU5a3ruURUmzaTMfeP3JDmRE2Buc80Ih7GVQDo7X2r+kQrkgMiJWMC3Q0Y5vV3IOJKw60WMJVZbjZMX5XD5Yjw/+wyGf26Op6dH/md/7z/g4fJAv+20ttH6zr7f6KM77LYHve04GKe86Dtx8zYdDe4KwO1Yb2fxa8dS1UO1EDnve1TQ6eedGD2rjeLXeik6PpbsH7+aWYYpDaZI/rONm7l1Xsr1F7/keI+icJcZ0fw5Xgu4rA7PdHRliDdEk+GWphSdJ3aIVHSmDmVdB6xmPO5GF/PyMXPItPUR0BZ1O8U4CqclasymdgNbDFuMrSqtG3QYm6BaohErnskKmVrNIoDgwc9aCrU0DHjX3/HedhiNfe+MbvQIwpaYaykWtXuG0j0LY5U2smdHgcXrapdloQgsmzP+teH9M7IzvTfO9RoMd0SqQ7rEHMmyLFyWR17VlW914SrwoQqFHRsNT3FIBECPAttpI5UCq7Au3oPjVfEmJvtSaQZdzZvxqQXTkj/7jgdZihaonmG58oCNyo/7wLoxdkEryALLaiyL8ZBOveBF8XXl8vYV1YzLdWcfna4DilGr8lAHj1Z41SrVnN2qPgMPij027KaMpowu9C7sduxjC+avOyMs162c9G8sahuektBcv+nMmcPbqL4WQYNeecTPgN/VGv38fE2UWLd/89/4Hf7SX/lt/vP/9D/len3+M/fi/5jHN3c0hh0MLmEoO4zCvMAlQ7DihsSIGfYmLoe4814qBa2CjcQExttCVPsb2e7YJ98NIBuBKLyLAvgGYdyLTG8eKOgLcLMbEYbZYGhj2ze2feO2bWzbRgvGkJEea5CXT8F3h/u5myEfI+XsJ9wpirvSu3nPx7jdmft0aXYKs3Rq0mAtKajuLCG8LmZ+9ax17IimnK3NF7fy/2Xv355ta5a8MOyXNeba37k2nG6a001foEE2YCFusuyQAANyoAc/yP5rfVEELxYRVoQF2IDDCtO8GNvdgERfz/nWmnOMSj3k7Zc1xlx773NrHOzxfWvPOceoUZWVlZWZlZeq6lNXgtnCBbpTYEoKSUeYCU5JFc6KuVLezDmtdloFsWYebZD3wBZfPbExkFWu8rDaUN1ags+M4lr4D08VCU/7Fitcd8s3Eq5lnSgyZj8Wu+J4iO6MxWQXeAplvw1G9EcoNyrel67QO2fvI7RoLkFD8V7kVNj85RUOSpfQDlW4uUco8ukt8dAAmSkxTHjZAVt1pO4AVM21PydeZp1VE1tJH4cz+HHgOLazpeaQ3BQBww0VYTUckgugtBY55La7k/d1xLiqe2YNM2V5dDodWzAkazs0vwi1igWGP1MYDMYfJwTTD2by+G8JnCpiy12NEDPmA6oYXxYa/05cv/orv4Jf+Pnv4cPLCwTAPnffxtbyMvZ9z5O/j93/4sTvCT8NOKza4c2ghUb+qf/mcM/uf7SbwSdLiGZdwQ8AntFdKGUR51V8v70QMDFviPJxT07vnprhap/caw/aw/CKiyfXOtcNCzCOmrNweRPWFlXkLl6+yLAdXk1Zu6vxm31OHPcJfURI28z3GUo7RDN4JXdYfTWpLhtGhvVWjmrkMjj8kR8oYjxz7JDtDXLbgW2HbFYfHqZjVa5KyFAgdy5UhSUeGH8V17eM8Qp0s4WMHpYXZKGovh+lbMitg1Vy61vT8jYc8oJ9vODtRXCfwOMN2PeB4xgeNgpblCSOnWL8YERxJqkimDcxpfkY0Ni1L8OyDb+8s+m4CbaXgdtXG+a0HbyOxwbVo5T6qX5wnm8LC4d9DihumPsHQBW7HEYrMK+IAJjzwC6CNwVeMDAw/BB5xXyznJo5PEQPEjsmF32E3AvasIGF5HEQ4rgM71MoHzFnRuJLFbkgBWIXLsE4LGRQRMyjAaNf88ZPbNsNt207pwv8O3B98kJj88SqOYYNPASCw/Iv5pYWPJVQzrdaaEw/JEctkWkHoJYhBUgcsJJ6B+C5FTpckfFFy6a2p30c0JyCesJW9uJE7VduvUmXQnGMiSk7Xt/e8MO3N/zw9RVfv9pi476/4Xi7e6iGWUe4qVCV2eIfq9ZSDCpURUMGKPFkVD0BVfxLUTn5SFF5MBZiIcbIRlmJTVYE6zEmGLGJrlslByZnS7+at6AzVtAvxmkyO6px1AMbSypdOTTEmCG+W1F/P5S9JrViQQBbbHBYQG9FKuFcSaCVRp6hZqtMC5FZDVIFociTQGvx9FI5NZwkH7I8D9pyN0KuWwndMVyDvChNUXC8SFQTaNQAz4iojWJENno/RlVVynScekr9zQVzCJ0BHA5QWPE1YIpFl49RnEwuCCVajWdM9S2vYTugDMW8Hzhuvv3nTfGYZvE75mEWoOPAOHw7RrrG9Ho2tYUGeTY332rR2MMs3EM9jqDigWMezy3yuiS2qDd3PMR4GhQYvsOUqrXrLMhy2FzB8KQn2az/oiZypk5sGE4zrgQ6EevjMOZ4g4VEQCq0j/jal+uP7voP/+JfwK//2q/h7fXVFhXHbtvY7r6V7b5jvz/s/r7nQsPCLixHI4xnEbICVEgNUPN8gpTJmM1Ca4rQSoBiBvkoJmZ4R8vrFmsTtLqvL2KXpggWEyaZEyUZsCdfUy704lZX8fPqinaA/bf6TnAKtV0l9MDU3Q2LJZBzd6lghCqey2nXY/iGEjCjxv31wP5mi42JWGgQkFpot/PBiLmrGyoOMQX2sBBKFalt+wH3cobUsIP6CubDPJovO7YPB+Q2cXw9MQ9YzsFQxHZ+GnlfYdhVO8XaPC8bsE07d2JsAF6gEMzbYTlgqh4WPk1Rhe9+NW4ANk8ydx6nAtUbHuMDXm8f8IOvgLe74vVNcX/c8NgHpusiY/oCznENt7bLsJOuVUyHe7xswBw47ptHq0xLwle34ntokMDeu70IPnw18I1vbdj3FxyPF+DrVwhGbhOsE5gPxXEA+4vdmyq28Dpe8Pj6Gxiu+yl221nrME/ZvgNvMoAN+CADN3HX831ivu2ATsxNcQzXYXakoUBjHqUjp5S9JHWfSBKyFq4LiADiRi8pnjCPmbR77NMNd5JzY7icG+KHPo7Dcpf/Hd3y9rNOBoeqG/NsBRpqoQhsFS8wK6K7J03ZGxiHvy8SkQR1jZHDwVvapjKgAKbtURVMdw5XQDWs+o582OBFnKtC3apc1wRwHBP72x1vb1/jh6/+9/aKr98eeLuba/HY43RWpCHYoHKGUlA6fnBxh7RHWR4JOKuPmHln+6mEuqKocdf7L+HKEK4mHOrIvKw1iOi5aFlL6UdLIboS9aYA1HNf6EvwolTKT60+wV9/Qrcjj8D+4l+GS1xZvurWeiv7siKLFjBhJFv7n4aKNtY2TqOqsdsTGS6VOIFPKaaHwFu0L5q0j3hvNEJI4CfF8QZIoPd64uk6ataIWeSQc4+MqOijULDH+Oq0feNlwg7znGJbtDtzPdRi2h/zwDZ3DH1gewx8tW3Q3U73lQ21SZ1fw5PZW4ikBD84bC9yh/mWPdsM5xGDEgYOeNin00lGAYzqomEjAoDpZnianMchKHoConZmiChirz0o1PImdwu/kM34J2IXlBjoGq0v178D13FMPPYd+7774sJ2oXnslqex7wfu+27b2e4H9mmKnc5ZlkoFOC7e9uDv/Cd5W85ZYjYteSuu0oIjL66mpy+AQQaweD9oPNprBiCql3gpUum+4u4LF5Wqk1ni6WJjzhNyrwhOBeTwHQ7FcVsKn0KxhbCMnZAcfWHZMYX2gfk4oLvgzbcbno9p0QwyMY8ISNOUZ/CQFp1HS2EXCHDboLcN+OoFIjsGJvTxqHEWS96O+gTO393hIDdAt68wbjdsH76BDXdsjzv2+UMzlLwoNDILPNJiHpYLNseA6AaMgTE87ElhZ0vsD+DFGpuPw6z+c9hWvu5hlZAdN4PHEyds1HViYsdd3/B6KP7wB4q3u+Lrr9XyWqftqKaZO2Jom05XuUlQhI49FA9PHp93hR47MA/oYYvxw8PSAAspGyL4oBs+zA3fmC94fHjB/tUL9HUD7gPyMIY/ITgeAxgWyZV0LgeAO/T4gRm98YZx7Jaf840XyLZhxw3zGLjrwDd14gU7oG/uYVJgvmHOO+b+hok7dOzungRirkXEROomqrklcQundqrKcEeno6CT6Xqd+M5Yh2+NzFHnUd+YFkFjCeKCl5cb/tO/8Z/hX/2rf4V/9k/+6fVE+iO4Pn3XKTHX/6abrXwRbsNhFs5RjEJzj9MQ5KPlEcSJnxmnfPhuEC9iljsnct5mYzoy5w3m6QBy+zKYV5B0JHXrqmBZZ0BVsevEQx+4v/0Q99cf4u3rH+Lth694e3vgsR84Do+f9USndEEX5SKTcvmZM/PgiLVHuDYFslmhCOYCkpTuJn20YAhvUWqf0W55OZCLIlK2aVGSPQlN2RlDsJjSmPOmveMLA7p1woMHj+azRfx4P1g5Nc206MRhjnF1AWsTWkpgkOhyx7ovXBw6t5irVBgNL0FCBAcO04JMsHfJV0uKph5MAlZcR1RND1uE+5lg1AxVsnAqTwatESq8hPuZNAQBPDcqROtAcKHKbnL6lM3wlasY//BXSq8ga+ICQ2reHtscdKcj1Wm0CU5DKzkWufRNupkKHFMxdlssHLcDx/6wHajuGw5sOD7cceArPNzw9lhCpw7bN8Ugnn3uWZjZkVgxbuWzIfbBd+KaPncEYgY+1k4yULzmu46YiHYKOPxt28qb+j8s5XLCwkbjTAwV385z84KDhVEOigdEDAhrg1+un/l1u93w8vICiJihajnp2w7im34SuIdLHdN3ENNMAM8FhhrP0+BhC49MttOSs1KC9vkZ8pgs//y+cYgLNT8KJSMsuqMCaIuMJG5uS7IUf2Z/Vvn2zsK5bc5x5a7233aydoTOxiIDGU4VMqM8oARv4F98S1UYH4Kq72oV50HICWXBF3LsqHqJEKXt5ougndot/KmUThHeXkmV6QWQD5DxbYxjmGfEE52xuTFqzlxAqcsNkwEeozRGwhwnZKd8OYIWyyRXPDwWPaVniCsHigMTOw4V3HfFY1fsu53PYfms4Z1D1Vj/JMOPaIvjzXi27gBiIe6h8hmRhwifEueAA9scOOSGsd0gI851S+pBeKzmLMVcMAHZMeebj92OTaepjV9Z7sfUr0zB34GbH2Xwgt3GZRNg3jHnA8d8YM46N4nPqznTaZg7kZ8FbJ/XaRqPBW14NuBjMKcdGDkmjiHYpi1Gpo/vGII5J8a24Vd/9VcwhuBf/Oa/wONuXtY/6uuTFxoPAT4MwSbGDGwnqJF7xAM9DCHDRnwimYJUQyI+2cLKEozOQjRqAphS5THeW62S4XWMEYyGFWJxxVkqZjqgFAv92N8e2F/f8Hh9w+PrsEp5bK277zrjr18Zz89mbOZnQDIS1Zlxh9n3KlZGqpzY1UY1GG/yLXXFGJWwfC5WDIefJaw+EUwDI5kWDNmVLFcsA+74O0CJrfAJEeUZHq3vGVdL/2rW4cKSFGpI6e+h56UbPAV01ani7lKJ3c3iHS+l0i14+UXLgp3PSKCzwBeCBR1OeFtR9/DBjZ6WMbKQkvoEWf6MvDzhL+qqYbPxj9wBFnhRn9+I6G82grbF2ywajOm6ofQJXnxYX2kmEPw5YSQD1xDhGgLNLapjnqsr0VNMOZNx4HgMHLeJ42VmXPsRSZ7jsLMKltCp6a74BHKYMI3wRaY0QZImckcHGGLHZl0YHuJUyyOgnytSfZ9Q23VlmxYHHYJ5SimU4Q4XPwEW1WwsiCXGZHhc9ByJI/V+rCeif7l+ttef+Y0/g7/61/4qBAOv9wfeHnc8Hne8vb7i7c02EDGhfuQOVIfa5gbqyqElfgcv0lRUGgcr4mhKLm9kADBv8ny1iGen31lewyEuyRfsmZuLJGoEMZIqp0J8PZ7pwiy9P2y3vVpOXC4xWKhUdcgFjVQ5w5YfhPlwmI98gaqoOM7Crc2lKeYZUHjo0FQL14Epb5tYMvXheVxHKuveRpjuA+Ni4T0DN2C+QF+/gWPeTT7KAz7snvzvYeTer7RhHOr84xtQfBv72y9gyh9AZGAfX+PYJsbweP0ZcE/Ad0YauOE2XjDGDR9e/DDVOf0MjQOYD8PCYaeoK/xQQs8hSFbo52xsm8keC/+fkLcHbvKG7WXH+M6EvCrwgwnMN+jbHcqLsxiu0I/MaWJGlpvDvFuLO5A5eVNMWm2+sIjxg2w4tg372HDHCx5fv2A/PmD/+gXH8QB8tzCL/LIQMPF6Nig27BjY8dA3HOoHuX8FyAdg+6UbxvYV9Pe/DXy9A18/sIufmv6mUNlwbG+Y+sDUHT94e8N9t3Nxpi9wa5nLNG7y2abTsBxBl0cz5KYbukQies1DyGC6iO24NYBjty3RI1fnUOwyoBMYetjmSmqzz0L0Bn7xF7+P//K//N/hH/7D/yt+85//86tZ9zO9Pn13dnHF02d78ZxSPZK/KamRLkXVGV7uFy5qlsCMFXJT36x4RSEmU0pPLVBScwgGLqQOS2h+nbWpAseheDwO3O93vL3efXvCngSe2nFT4qz96JY2C3yQl1bMtQIcvlOMkDqVz6QUdmjiJRKHGgjRpchByUB94skUcxPxurGYaQealQbZ686bplVLexYvEfiIorGCF6Q3iHQ6tnz39G0WsizQ1nbrMllU+AuNXanusvpLg1VBNNzcbb33lZcTgn/NG+Fx8vtSz8t5pR0PUUKNjsKqEa9qliCBzxgLWBh//qDrpOE51AS3wA86Ve5AFxhByyhFg2wLVo5M+LY3f4ROgsozvQQTni6A4VsGDjvManfLoifczWNiHjuO4wVzWWgoL2y04IW6oMu4Vi12kUWqn4kOx6s4XLzDm4W3pXoXDZrXVCdqC1rDiYSGATamEBcIJZOexeFSBlMuLdMb9+X62V4vLy/4pe9/H3/iT/wivvrGN/D29VvuKLX730E7S8XhrlM9FCcWjGmBXhcX5eHwn/1KEuV5z4xEnScxNZ+EgRdtppMsmzOgRN7pSq+Lty1Z3/W1ihW+c83OS6Y8Q0VJWlowUaGIM+D7CqVQsgoFwvQcDD8ny3V2C6fZwvgj6agOvhByRljm5tydgNqpzToP36I0wrpm0kKTn0AuQN1dAcwDc+5Q2SFqJ8nHAXNIpVIJDgtrHWKHmg6Y8XC6zqaCDDCoRe6MUW3ojeTwsVn54YcJigjkZknZFo5tDNYiEZimfQzCg5/jbF5gvVlok0xxj5BtEnKgjMXWJTc1hwricvc4zOt97MChe56pImK7bI2b5RCLW/w3AC/Oz49ph2uaCDJBMI7hO2JttgHAqEiFh9qZLccEdpjh4L77wZxkLIjqGknTl2zPx119XKY6h1fXjxEeECGeYDxkKNr2tpbMb8npEJN10+OVhyq2seGrb31VZ4f8EV+fDMVwIX6IINbBG9yQGXzPkRuLjUjmga/mVFAMMcOPQ1FBjpYAvmmOs0ARmihIhmdMRPPmjPAYrzISgvlSwLZ323fcH3YC+N0PV7KTHo+0znJ4TXxh3piKKOmwyUKU3rkSHv4pF3W+e3mdKW9KhmAE7p80F+WqsQWwVKqLr6YFOAf4HGuYzNY1uQwHOHU3FLbeXlWUPAkp9cD0Zee4hMPqJHQJMLbcNXhlufGOqMypr5ILhbV8drtJViUBVAw4iYFkYVuIJV5iHhhtl3cwlFJHgiLrTY/F4hLj03YrEiEEL2FgQYPSX95RLPQpTBw2Hz0BRrwd1as6FJE8pOoM0wU0jmkHOPlBSNMXGqoH8qTZBmf1P9oM0DKP0wVtdKA8OIEHybybNqdEUoDG4n+4sqbqG0WJ4diEphJuTdANFE8KulXvfgbpiosXjZ9WfriycGI8X66f2fXd73wH//nf+buYUHz99ob72yse9wdeX99w7A/c33bcH7bj1ONhC4592rahh3vHTZGs0JIwKthXUlTahDNmkh6HpMlrOA/YvBKnv1wQS7zj3mJEeK+9R9MXdScZWcEWyr0u5ZdFE/PzWFII1WE3znKn6lvU8Et5FkIwkmuRiAl9I3WHqhZwNfOYZgSQfea29cEDLVLGIyWGMYXIqbEGXODTrn4yYSdXH4+07B/7HcexQ/OeN6CBp47fOB8E49V0mymYxw+h+9eY9wd07s4bnJZ8XLdtmEdDFLdx2DkV0WEBDrFcjAjpBOKsHoWO4qkGw2GLlDlMaR+CcRsYtxvGhxtu37phfHWD3BXy8IHaFPOm5l1SBcRPk8PwcDDXGbaB+bJh+2oDbgPjAUxPHI/8PI9bcbaotmWGn9o8ZeCYiv3tDY/HgX0feMyvobhjU/MoycuAfNM2IcJ9YujETYGvhu0idczNzjOBbe0rqhh/IBhfCea3hnl6Hr45wLTQsHkMPB4Td99m/Xiz08BnLByJxrroFZ4NbUql/cnL2ynoPjbqgXBiCweRkTqVzAnx5PVDd2AM7AJs6qtCOQxd44CoeftXeflHdX36QmOfwBh2EiVsQsfhturhSzMnYSk+MelrUJwhaAZGIdhfHlYQ8XVRRf4Tv525aXg3ageK6bs52Mni88SZJyYesuPtfsfr2yte73e8ve14PCb2Q/2UzBIE5Vqm1QRpisbjXIGcxEJyCx5uvdiLBldbvD/dQB+eoGC9iwAA+UvK9N4u7S060IoM55nFlzPMLNqOTGVi1/ytoJHU0gwWEj7dhN5nWApT6dOScBBeobgnGYYX/ZdWfbXrv3jsXOJljkFrT+p7Ska3lgvhmoYgBan3sexpZGEXF/Cc67II2lLG473wIPX5EVasgAkqiH3Y6yoLSrMoSaxxHHMJR9AXw0zr8/RExm/J8klvIqjdCjx7OurKqWLCcSQqfAym8YZjmBfDQkx2qD4w8WLxsGQFXrPB7bbDzx0ALDyTJiDHItc5U0Fb9jnDtOl4tGkVW9/Wom84Lgbge5rzOPaxs356j0OhOCKG2GOlpx0aVTTqfDTfXSwmX66fyaVAJnTP44F9N4/G7rHPlgBuu0yZZ2Ni+vkL6rHnU7UlJZMEo1aaeo3gJqvsqwgAoIxq7Clf6tL1nssUEjihGCUslOsBD/NRlALFRWVdNAS8zvNSBkSNOX/ZS85ykdpmtrZqcywoT6svai+YlwBxsIKxq8DubO+lMQCeMK02Z7PbEv0yHjf9MDWFAtNCbuY8MI8dehzQuVP70UoIMVu8zam+2eqE7HcgttU93oDjjnnsPhDOYNKgYX2PvIeptgvoFA/nwsDYBC9DbGvwKTj2BxA8dvL2va4WjJD34vxtw4aBbW7AccM8Ntw/DNzHxOOwHZ50LxwU//OkTwHkJsBm8akiLwkXBJBDIPPhSLdFiu2wqemFHrAwqBsmPsw7pr5ZS/oAME3/3Cx+KnZATV4tinkbkLFB9cVg3XfDFyb2h4VpzTkwXwV6D4OPtX/IxOG4VY1tcQ/3rGun0RhiXvSGRz2pW07lp7r3uyqwfAuxIN7hKxOjzVnyR4fvdOioHr4XrG+DO+bAn/nTfxo/993v4p/9P/4ZfvjDr/FHdX36ORox8KFfKOIgXfsxp7n9Q7+OyRXaYszn2O5RgOGJARrKyrCyumkq4WVEKcX2JsYgjJjKsjDUYsGLfY8zIewT+w8eeH17w+vb13j94RvefLcQ3Y9yY2Yd8c+KDxDD9YnPvD1dzF0JtI9kgU25iyL2s0KAWCRJxssSIKHQCvlggoGT0FBBBnsLK6xeT25yM5tqu3R/QUZ0wHk2iUe/rdTHqo89BJLJzIHOpY2o2xNmQ6+NpPAcC6UXJEUZUnE/Mfwai0A8/SqBzqENq5Cm8a2FT2Ujcf6M5pPeZm+rhnYAtUgRrYUgTEGPtpoXa7YsikRfx63kuElGb5sdKR0u8kQRaNZCMzZYDSMtnprP4dGQml5JwNy/hj6Xbptp/jsUj3lg7A/cHgPTTwvfj4lbHIx0stAIJrbCrxa9qYcjmAGyYNLYZB01D+KZweo8bgI3FUron7ZPRYRraezZ7vQR/dt8caroW3GnNFfLcYNAdLhRpPipblav6vDk8QO6brf15fqpX9u2Yds27IfF89tC4oHjuPuZGf307wi7nXHQq28okicma04WklH1LS8SOjYXBX0SwxfD2u/7FQvY4LmVX8GLDmqzKfRUhupeVfkwevA8as855LK1VrLFfq3y8ZmwPcNg7XD5UV2wh1VzyBoFoJYtlfyHxan4nhLw/EquXuLPvZSTOa0CoYwqbAelY8I3A+8eHRgv5zCq6Z6KXe6A7sDcYfFBu9ex0EmGZ0sO1fStbQ/Yhj03EYzNQooesrl32OrQGZ4MN8wGjlSTV4YJcKifjn3YGRaPIXiIWP7coW6QtOiS9Jopcsc+DDEleAyIZ2CMYYukAZilfoby4agW0xHC6WsLDUvQ3i2QKXUNHRZxbwuM+PMEelHoJpjbgD5uqauqmuQ7dsPh8QD0Aegdnk+oEJkWPjeEdjY7fGsPl+Mkr1OGJ1UzHpkOkWoxUY9dU10XNnxGVIPJrVpoTA+hGIcvrKYYzUEsFBATcxz4/vf/JP7kL/4J/PPf/M3//1ho+GinAA7KTMWyuSCYjUolGruV3whIsPkBOxNAblSV2cV+MAoyzBmqlqg6nJBKobRrIKI0pSIQF8Vk6sTjeMXr2xu+/vqOH+533O+2FaGdAk7dWPpf/F+6MrbyRldGTg/SGhNlCLfLNR1Hqajne1L7NUfY2Coo2NqTsMf9EZipyUCgsj4dr4djIxxWjfey3hxNuvzLoYyaqc7ApdA73M2OlhJqchitidpKv20qggLGmlJcIrcKnPB0GnQUOrOpWeTe/XTI8VCqU7KkujJc95qUc0EWQ9rkJesICY/QYoD7RAsS/0aRQwsazPrVnpEsa/qtz1GdNZaqXCO3K57MVjQS9QmAbSMflprQn4ficdgBfi+H7Ws/58Tj2PHBLYRtgkbH1E6Tnb7kGJBc+5fQDNxJ9q1wbsIqwqfMFmdbZI4cHsGctzwIKtmVKh4Id7fHMhMeM3oreIKI9SHnZOyoEozQjN8HFJgHYrvuL9fP9hpj4D/7m38TP/+972Eeh+Xwvb3h8XrH4/7A/XHH/jjwuO+4R47GTrkZsV1qhM2QY1hpfuE0vPUwdNNI9EyS9XuA5KK4snmoDhaOyWeIAWsverqaXGHkLO8uL6WTNeYWbe2fPl/aWvqyfZqrl/AAEVdoD9aVjhB+QZ/cIWay3pwiNr1UC+3BIiqCQwxPAt7VFTsLOTKp0/Gu68BL5CP4thM67YRrTOzuzRSLLXIl3BcCN3QBrbCFwgQmR4jIALaB7TbwAYIPInj9IHYC9wMWZ3d4bhwEww77Mf12wjK0N1sgb5jYbhO3lwO47ThE8fXvPHB/feDxQwsPmyOyvV1fYaOywLbu9fCXcdux3TZsb8MOMlU70BDifQ36UOvH2D5gu32Fl298Bx8w8Y15xz7fLAlcDuSBl8eEyIHtxbwiG3ZbvBxqXojNfMJzU+jNcgP3Y0Dud9sZUCf02KH7HWPeIThsJyfXQ6c+3IAwKeKlFsxFHeLyQU7zMnUqdv47Gcb280MUKhPie64PTDe8C6Z67sYwmrBDBXfE4ZBz2jbFx74D24ZdBkRH7p76R3l9ukdDYOF8Qn9QhNPP3HelBcUSQXLfNs18ClUxy2EoZQJXD0ITOYBxc+ssEObC4StWHJEEbavO7v4cBPP6DNB54PH2hre3Ox73O477Tm5ObUpci5NZlbjUnuKeXmjhQgNcLIvJs+mOsXgojDm/jQTkYned8YXWF8/IAi1IxTzc0uElqf417XX5Xu3Jcu8KD/k4PUMV595kky799qrqnBVt+I637QAedYWvamx9JvClkOKwMOxoeGvlU72EheA0XC0dwYTKSOzaek79qZxxtoiuEoLaZGvqAhK0pYUwEYKGNJekwWr0Mq7b+y6QMhwkjfj7GtRyRdsUmpWhVKHMaHWR8a4uj2ALxAjhDUFs4QrqxjzbbWr3Q89sN7jdLDp0DV9wmm5gAkvFM1NcWRkO0uEHe3O0mcBd06qwg5OGG4DVlKTpJ7v62UD2XpwabGN/S8uoSdXsTbqzRrWpyPknbl1R8YO/pvnHLZHe4pMV6p7eizH8cv1Ur+9859v49ne+g9cf/ABHHL63h/fCz1ty5eOYddJybWGrPmVJ0NNUTZ6e85U4ZIkilG9ZUsFkBTbkScoMt5azt87eEGoPyEnpADX+HECcFH7tr/MlNLH8XRaPl1fIPOUiUh+LCAYoLPu08rho5NS21r9NvrA80rV4tc2hWyHX3PgRG6FknVGhtlatHpTRiZvUeWRuqzgtDcdRyJcGXMOF8xIVOzjPf8eGGc3Dw3IzWHfwbtPdEYZMge14ZQq94LgfOO4HhQieBqnjH6jktMMUZfX8jAjdLtmr8L2+HbYNIjdAPhhv3ybw2GHby4bGrojdmLCFFdBgj7BFc6jvuYWuTSWB6LSQt/kK3XfMfQf0gTgw1UCUTOq38a6xXxIzzp2Xs06ReEqjJDIvT1PUO22RUhO6xFQ7GRyA856B4cYNEclTxUf0H4Lv/fwvQEXwu7/zOxdw/vSvT19oREjUZknX4pNkqtQBesxoJLaKhG8dJ0kAFmtmGE0GqqabjZwUyLosTi1Dp231p/GkyiEVpnhd/KTQuuZxYL+/4f56x/56twTwwyeLJ3KVKiNFSAsXtjlZjeUjJTonfhnwKXWtBAmS03FkDmEf2dzShhFnNRSKsTREFCMVfnFlDlp1rChIHYsUJizl1CePeruscwb87fCmQITXF7woyyezozYCFwqfRMlie2MMIEk7BRA7Ip3CfbXCZhDKZmCSeGmv3tvcKjCqykk+HsH/QvH25yt7YutmGkGDl3G5BKLnVlxZLmrIjSgjsXn1QjJtVptq265GR7Re6xlHFexnKVM1vxtEEQ7pdKKER3UL8JwmxI7j8F0/zFp87Hradcp2jg/Plnkk1U+ZVwCb8xsRO0jvkJgfMdfCC2HMY/VeTYHnjCWCjQfB/LIbgJtOszZJzW/Gowa+Fbmoy+wND6WaVD2cvyUM+mV72z+Ka9/veDxecb/b9udv97tvaxungB94HLufvXRkPpFJt1h4FM8Daoh5OBWAH6VcsyXGP0KkQlYGgyK3SPCV8ITOXGQE3+5cpn5pvseyJXnFCnTCurB/QZf9Wb2eOpssZ1AfV9760esTCityUXABGRcredMEMo8GvR1uWj0q0StdkTfYXtnnNvqvyB2dC97EFHHYhFcPA1LfdSK2iOUFrDijsaRhWB7t3LBDcJ8DEwP7NvC4A8dRW6tCgG16mJHAwpJfzDsCdxzrocDLAZGJIYcp+PvE8YcPHI875vFm2+0eitjC1YzLWmeDQOwU7amQ6aGnt4kHBPMYOA61dg51w7AbsIYAskHkAwTfwJzfwePDgbdvAvfD8mn1zbcLFsWY0yJd7ARUC2cdbgbXHboLHseOOQXzsIT07Sb4Su6AKt7uBx4Pxf5QYFidsg1baExJ7/rEhAoTLglEvkgWpJoVusXoaqWIywEjMBtPk2oAxA+/9dyVad6OA5ZDhDncQW5yTAHI2G1DA91w6MS23fA3/tbfwv/w3//3+D/+H/73vqvqz/b69NApx63NM/XpIjkQJqRjdezID0EO1ISKAHuJnRhG8ZkYFZbYACJx3OoJS2E8lDaTIzwlR3CZ9Ton9vsdb29veNwfFncb8XehLDdf9pVoQH8uIE4N5/i6vLIo9bJ8xrOWPBQ94jKuvEZaQyJPmvIoNBliXKpBKXg5NCOFjPCAeDsd0ISphd2U8IuWmHeTLawp2mmFa3WgfwKpzJaCeh6TrCOEsdNU5QyhBBwr6SzgBT2k2ctq/kvD6NZ0DjXr3OWqx8hxYw8CWz66UzYIk34PFuLUt9Yoqf9RLmBrADscDacrYS4XeS+5u1CgEtRZw6hCCqSgDGOUbR1rYQSRTJlbhmLmTiC6LDQCU8J3JoG4zDOlRZDFdAYwo49N4D8tiW7fCrSJ8Tu4MjBEcUg1ld42rz/LBieToqVg+zEGQwRFZ4u0+nL91K8/9Uvfx/e//4v4xocXHJ7s/dgfuO+2qIi8oeOY5eGYPR9j5jakKHnkV2NtRCb8rBSYYBTnORh0xLGVNYWFaF8pyjZ4c+djV5EVyl/kfP+KU6yFTs/y5WcSrviQ0E8zYqX5rM339co7VzAsYviE98txUsp1dDznuGk6m01Mam0jpIXXxNUTZGU0SBeY1VeFewBq8Vocwkc1vK4ww8Vjn5ii2FUxH5ajER4IC/UsqWZtOMMcLo0EduK0h27piwDbwLxZbgNvnBNbdRfJqYul6pMOD/Gagl1sIX5MxdTdw4V6f41uD0AfmPMVx+PAXe/Y32yH0FyYOPwSc2EKdAwzBonkzm8W2mj5bxG+/7Kbi+O+KzAtdA2HL5ZgfFtVlpAp0hEuaKvnbcaDJs3JCK3l+Yp3ve9FO15gos5agmIMxaETMgXj2DF2a3kOy9uYxwE70PDAtg1861vfwl/+y38F/+pf/TZ+67d+64oQf2rX521vK4boWHMJNBcbtdOMpp7aZbytujWUPiCFdbfyK3xJChE7ODeY5/TdCGLLTvXYi/ACZC66U8DIbKS6dE7sb3e8vdm2tvt+5Emg3fpKXgGAnRfUsXLjNj2e8NAx0XXRmFCrMajcmNH3INdgCOWizWnWGHfASRbjTM5z/CLwxr1eIw4JUmlda4xZfEw7Ky4YchIp0hqQ/c8kZ56Imsip9YJUPdkPpAxu52lEHczka/42NpDwqiNeUaFEjjanthLiwSQUJwNj9oEWNkwzSsIykhGTfp0ONGKP/XfsSJE4rUc5HpIl+vfoj4RwjH4QgdVY+vvRp0K2w5E6No8AIjE6ceCbCUSOfyZiAoikh8BnOK1EzWsg6nuXq1i41MMP0ITFv68LDX/ZaCgHw9X52BYvxh5iYU4x1uJQHX6rojyrriSY6Z6wmmvDv5tFmKxxRAwZThGgxDyaYsmTuczw/d9r4iTOPZ/yy/Uzun71V34Zf/kv/UX83g9+iPv94R6MB+4PPz/jYSeBx4ngh07sHg8eITXmIPfRJYYZ4Xw1PVmhAJIHB/9byR1BmlGHuhwtmZoXCxlIzsOqTHL+n1Ot+IbSv8Rd1iLPNa+SWQRDll48q/31XmfyupPGXvItvrUQq3fmz7r5iK7fV5hVWrngLWEwi4YrZFgJX2teXT0rPlxGW5ABLnb3rjS1koES2/n5TkU6FY85sc8B2YM2AUvosI10LB+g4NLDQkQxhiXEK+w9t5jrhw162zBv5h3OSBBEiLoCQ5OHSSQ2w7wLuFm+A6bxZtuha4figOVbXEUP7BC9Y86vgeOAvr5iv98x94e95/Qv4vl07iRS2TBlw44Nh9rp5dg9MX8cAAaGAi+7AtPyAnUqdj9jJcYGEJKbPhKc0V3Cpa5lCnZpTfoJlVWi3xCMUio1wYHceVOne4EUkF2xjYEDwLZNyCE4Riw0bCeqb37zm/hrf/0/xj/5J//3f3cXGrb12EAeXU8K3iGGOHNkaLqBU0EBEEelSC7/LdllethBMooQ9CMUDwBTbY8BZ7AyZtJ1xPnJAOawpCzAVel55i9zHrg/7ni9P3B/3W3rwjgZNDnHqtLxV2JDTWDkzVLSYp5dXI3pU1OGCVdg8l5VIqJ+dLMzVSllWZwYRSyGT+SiDwooJvhAP+J6+a80PJzX6NXJUqaYrwcCYpIKWQOy0IQzif6OPXWbvtLtBZk5Kf1ZQC8hOeNdCVczeVC8e+kQW1fHCU6Hmtuo91vv053NgjctGG1ITBEZiYfotRbthHdw0oJchczgEZPt7S0Kh5Tm2hcPkCybfXLBJg57lS86J73F2xw5FklFsR2kSiZsDkHsdtgWToDFFNuBdxMSByTtapbj+4553zFfdjvMb3H7qgAYI+FSwGNvkS54U+amn4ErFvUAtd2uPFdMph3WZAqZFF1t5GcK5S88G/5gRoiGKoWVeIfjGuKWwfIyJRIUFWrgxhT2AGdfvlw/k2s/drzd3yz5+/7A4/7qn3fc72ZNfTx2Tw498nRpdSESWxhPgBbGQRUxqyTPcDgr6OtFz0Mp5PpK+25FjbY0d3O0Fzifg8tF3fT5qRd38eLdVKwVnd6prRMG1nr0nWetDin+fgHqKvJaCMtSpndHFxgKpzk3c+cHEL71hB+NMMrQUeMfQSW4L3IolG8OrRPADnALa0R4aeeBjIE6PLzGgVOxZwr1M9CCaQqAG3SzMzQ23xlwxzS+dAjmH27QsUG3gccLcNwm9BGKk4UUuVqXDnMZim0DZAPGi+kmIgNye2Du07PTtULSnEMeavx0Px7m+Xjz8KjHA7vecehR+pH/DU/QnyKYcgPwAuADhr5iKGwL9ak4DsGOA6+UzvE6gcd0OEK5PIRg8kXZOheZpjdcXM8nVclCNkpvOcYRPSQyXAZI6sMKG2pMP+Eegn0fNt03w41swzddKL17iJxk6M/i+oxjAxW2v5YAe6XtiAAvQWiAKWalQ0apynwXGPF/iFEqRxYizhBGqZHIguHejeHKy7CJoz7bFLaRApSy/B3AJfAIx3Hg7fUNbz/YsesB3WdNNlIess9W20dR04qkRaMedVX+edWlgl2xveVl334v9tw3t+kG1VEqzhMhpk8AkKhfuU0fw/jFrxBz7SKVYeW/elnEDdxafLlgzuAT9HkhGXbTmjh3pV8ki6tHyJCqi6VUCgPfkCg9GAGj+iKjebWkyjSSmBTe49wtVdFByilbq5yphGSmLIje1Z5YsqCacSlXb/sTrT25L4R63JpAnp8jrgyX8Z+EK8rTeArfzk5oWa8OhW5m1ZoQHHJgh+9bPnfMuWOfFubI14yFtppXJcKCJ4AjBLqHZVkC4WYLDGYYto+tE0QRMn0F1LyrMiw7YyoNevQtPCJH/ZBj2AJG1A8A06z7cBYowcDCMFiTN8dS1yH7cv3Er23b8O1vfQsvt5cK2zvo5O/dw6WO2U4A11mLC/NmRHhnyAGf3Y2eKvSl/l2uRadhRTMXGOsrsj4TRAJQKEoMB9vUQnE7CykrmOGtV/xW6SczWuiJ22QjyVsoJ+mCBZ3rPvPYJh2vkKkd//weRy4Uh0UZRRewT/1S1GJDtRRBgkriX8b1aqA7TfKy8KdOe6HTtEWJaaKZL8ECw4baQ4DC6xaeaK9yDO6ZG5HV5Nd8m2m4OTQ0sKDzHtHAoA1RbAPYwkAqMCEitlMU2zyVvGzT3Tc6DyjsoLwRobTkYTb1hyIFDAOOvwE3Q8VSy7zmE9iheHOZ91DUye0SItoYry0ytE2p6mxXfPI9sgzlayty4h36tC1ty5BwViYqLwc0flPhJ4NPzGNChrjHKBLED9tAZ058+PABP/dzP4cf/OAHeebGT/v6rHM0AJjL62ausDkF2wRuw4Tm4UQUAnrzcAZN5dCIDhuAD2qHp7jAT8uwS+DYKSFwegOwuUsRsTtUCGC1XVtkCmLvH1vwhBSva+4H7j/8GvfjFfurHWGvqcytlytSfKcpcWiK5YmOJPQGLR1GEUA/wfRCiRk2tZTRULDoVsAwKMzHtcArPcUYV9j54RNer0EbwZC0TQ57sRYF1sdwk3NdmnAknpw5iDNPnse59stxLqGdsZLCw1suW0JbF4xrGwRaOAQCT9Mt+m7YyfFjeRL9zYgbVj4Jyyvj5UuMl1r/Rx1LU8B76z6Xgunn0SMCxEFUTANQZP4IFJ5QWHULbRMb1ciKMyLo+DkA3wwiZgZlhib9nMV/C/YT+JbXggjHjJ3VVM0yPKd6HLwp9Ycq9jlxLNvb2jhEMKdiTGAMwV0EO9QPezJczSmYA7a3fCCaCcFxZvPW88804o/9rAtFCkZzxDr2pjRrmMDc87ppTXySGemU8jEdOQiBPhfeYnhSOon4y/XTuX7xF/8E/u7f/ps49h2vrw+8vT1wv++4v9rp3/fHjvubLUAe7l2LA/mSNWptagE9G7ljaHNmXDHmZxfz5Qzr0OSjGTkYstpfERVXYGhqUsO8oG6yrrVVbT4VXQznSeb4r+H1ULhsGprew0Vj2LJ8kiLuhVYQT/ofwVhNMyOIycoltMOYYETfWGi1kb/sEsuitmoJvk+vrdFSrZKp5sW4AdgOCzFS9dAlRWyna0VN35m779woUblCx4EbLE9OfWfPHQOHTtzxRsndP8TxuGP/evoByahwrq3QJL697csAXgT4ANv5bwrwuMNOGL83SkTsYDUhflaUuv15FDYjWmEr9lvya+BQwV39lPRxYMMdQ+0wRfeDYJ/29xp78ca4uWwiNTIV+TSoBbjxJbZ7jnoaUa0zi5UIGtwU5qFvSoJjxi3BJqPqtQxxqNihkjIFOyaGHthgh0QeYcUd03chs5Pi/4M/++fw5/7cn8Pf//t/H7/92z+bEKpPXmhM0RTOoUSmoI0BoN+uUiDU7HQHiYceHDEZ7cSIsBiHT3WI9CHSWl+kMpmb2QutWj1rQRRDJtYTdec8sD9ecTwett2ZTpT6GQ2WRlBPOkuqsq7Qnaiv8PJMdz8zrWXWhMRKK7V0xkfhPgmZ41cYDlJyzlTeGaECT0KuZp8zVCTijNUFGoDyEsVsZXwFSK5EZZdMKubCbxV6mjPecbIKPSVkJJH4+z4QsdDLSKOY34kiJS0yxpU0RHQrVHe9tx8XeC4mI5Qzs56uK8l0qPfRj8gfcbxXqekTIpqchALCS44JDI8jFpo+X3MsVqkvkOW3Va69i4EFX3wOJQ4dCFPLwUo6H96pcJeoC04/l8B22HCr8TpVbTeKwsIG6JDciQMAbdlUORa5aEbQopTbatRrA+YJmTpy+QC1xZZ6jSM2jM84Tt8nP1apM9qUXKQBINGJwmF85VVzxCN8uX6q1xDBy23D8bBzlfYl8Xvubl0NT0bEc7soKz6Iheevc+n69umg0uDdKN0z5i9TdChnzrGKfUFSNhn/LFHijN4rOUs5IJpOtcdq5hWB1rsV+rHWQjUnEOtzrddW/Ght2NFqTFkYNawFqo1S3ahZrzvwWrcvZDzJ3AvJyD3wB7Nw1/DybA5L4VI7bpV55yoQnQ5M0Zx2XolOX3iYgSY2nwjdaWolNTePLYx/pdELm7HD4bxn0tawD9+tM6JKiE74oEZfv9jOswD2ARxev50xg/IU+Hfwd9cN+kHCkavgUTWqWb+o+DF+AugBHRNzO3BMMyhPVU8GL1yW52CdA9Kfd7R3dUqX53mxDkL6ShzOFBP1xB6kFU9IHREUC4HQaWbsjKiWjnBMy3HEYSHZFlx1YM4bbrcNt9tmhyb+jK5PX2ikOiKIrH4MQG/IkLZQV3LMgmAiecUpShWZPxEnNIbl39YO9sIgC/FUDzVoOpgJ8OG5HBEtqLCTJNvhWQHScWC/+0EzBx0lTwzmggV24ooHi6UyHqz84KxzMnNeK70YfJ9YwsS5tCjeWldR3yEkAjtVZ1e4Uqglpasz/Oob48XlbDEddqUui4yqq7qrAOKI6RMr9qER73e6P2HtJBNKtZLU78jxIYAZI21d4n1LRuLW7lwkJ0MhXK2wSmt9fQQEaoTvk7Xx4h31foQVx0K2emcMNU6LHkLEc6SseNTKKV6N+CHBWKpDiVhxpWEt77O79TjXRREmoIGjHnqQn7Mq1Zti+ta285i1yFyhjkYGMP3MCR2+yIkx1oQ8zYPpMUVZ0oJnCGpXlsP7lWlc4oc/YWBTyX3zNPqtI40gSecKwHNpTIDblu81lkVnui48FaiTKb9cP61L57RFxuOB/bHj8Tjw8MTv/XFgf1hSqVmFzZuRyhmn7SSZLt5M0sMjvKn46Mon7UsL19D6NJYXPIvy01AiSRFB6NaWKW1LjhBNwtL/7QvDlr8i7JOVq4XhEZjna11kBO8gflsybOU+jAwJUfL0kl6aGoyxOr+8SmA9vYmUeSEiwd/Zu8VdfgKb9aHnFdbYkrnQv9Qi1sYrVE/dd4vH95stFC14c7yrGjp7QeJGvHh2QDB896KhCpkP2852Kubbbrm1zkhXVQEiZuxx/ezhKbWHALor9BBX+NVSSA7PrY0JND2nYCDz/VSHeVri7CFvawLYDzNgHxKH2gmgE1PMbTFdsFg+MBkDclBZvgOL+IQPxylE2mRJcH3XPng+ZRVRMSMqKqnGrueLwTtg3vUtcyJ95H3MZdhiAzpxbB6lsyNpcugGbMAQSxCPKKOf1fXpoVMZtjQ8uUwq9MFj5YZGzHVfpaorYDnFNRJ9I6TKEQ5FHiPvsYalhEgZMVzpDCLJpHHTEAGMtLBjCTmYc2J/2La20xP4eKs4AE8GvmtgC7vO15qtKWcel0ARKVeNYCautFwF+gfXEHrPLfu9uHQOLPTwgriiJzXnmLkaTsPAWlXU5GnMnjiach3BSJD7c6DiG7W8U1lzKcwZkxjZEhkrvI5JdCjuB8CSbTNqlPC9jn386JYyo/M2QS8Ws6ldpilxSd5MOq2vOZQBURYLqxZzRha40Q8SGOKQs/s/YaI2cleLCxrNS+kuRzN3rJcQprYC2cLimiUSkzLRU/xNsyAf+2E7nMxjTdhp0DgHWXpSNNKoWkeOXR7sGdnYGuFP7gvKch6rm0/hPEwhctBYb7l4pNWJD9TAVNvxpbGyETLB507MlUD4F4/GT+16ud3wn/zVv4I/9t3v4niz7TMfr3fc73fbaerxwH7sOPTAob7QcI9GHPIaQ1Scr/OmZdLkeNp6/4r30DvrPenVpRcDOf2hKrk7TQWHV/w3J6Vn1RoSxmdjTAWuIq4T07sE88mT5VdOfefP2nnqGQ0nZF6iqmC1cnawp8fcn6S31Zfy8932z1CwFFGUyEnefvGuVMQrQdD+KVngCmNAz+0n+UxbfJTXSlIMZfQbw752LAwhCt8V6jA9eFdgAvOwbcZ31YxYuCbROu9IIcAhOA5gHPBdrAQqlj9wHOobYkUnUSMzFYqjQm3d060aB33YK4coDnGL/gyrkwmRHcXfY+tp7rtIR0zkXOaYxeIvF/X+3tWgxrgpfW4xYbVejHIRh3uBQQBNB4wNvPLssNSHFdO3BgYEGMB+TAsMGAoRi3TYYMS2ycQhBzAEf/k/+iv49V//dfzDf/jfYt/3Czh+ctdn7DolHu5gwQIYrnwe4VLtPNSYnp1WqBDfTEGxTc1ICVsHSIT1QWRCIgzBQyhUQyn1pP4Z1t1o061KMEZiB9fYO7mJAF0TE3d92NaZUNsyzgV7MJ/Gxuj9nKSRsCRNX6yXgjkHvdMz4XLUWNN5qUxYYqsNK6StmAsOLR076ZqYVIMhf1YICGAMRWVpkTUigJReq5d1YGMGyFhNQFuUUyzqeH6p01FBtLDuiA31ziiFNbV66N94HriNPjd3cTAUT8A6cY9k2AlaG4/0CiztREy/Jtoj3yNgrv7xQkYJT1Ye2U7Bx+MXdRARNsHlzxX0rranK/aqAfpJA5jiI+JKpd5XRSYzC9OQVz3ip3NyWnLCZ6GFPoqFKG1T7SC0/TDvY3g1liuisKBiORpOgnOawBTATraVwoDx++FkRe73+E8j/th43QY7bTWdQuoej/idO7mZlUmhwBELFWtX1J+pxUiPNr8sx0ygtj990LvPqStx9OX6yVxjG/j1X/lT+OZXX1mC5GPHse/YPYTqmOTJiNAT+mN+a+S+SJI2v1fDhJWz6bwys87l27OULepe6C5ozMGpCz+oRUbzhVwx5Jisp/aX+ScpfXqfVFp3uiDVU3XFw5yLrtOc6zrhhuZRKyztl+HiHZ8zu5szdJu1gTPvSQNojKG/0yKgTp3QGjtleVtFmCuWR3rh2Cfjg1AZyee8yODeNLCE8K7iAe2AquV7WJSg80mlmnSpTQJqVFK8eq4bJuSw+jGm64c+W7x9iW44tLFbaQCv6T70Sed4RPBQhydGz8KzZtZHLqHSMhjn6obznE41kElVPB5CZU6f3lcWzFdFGp3SPBb66UNri8aCSYedBxK5hIFTQIFj4pBhR/9tZtyac9qhf3Pil37pl/Dd734X//gf/2OY++Ond33WgX2igGxOMN4XmUaMwoiMlbSHBqiaIwSidpKvnyQ+YeVHKB1KI3EI1E9A1CnYVCC+fVjg0cZYoGpbgm2H67cbsA+1UyeXyTgPxeNt4qETxwHMoeX2Zlf2FTMK+CSYmo0+K4HWITSmv36820YS9pVCWApf/nKiy1C05JOa48B1pYW8yLpfdPZAPowQD04BCBik1w+gsm/ZfxxdIwEZLF9Ai5WL3AsNIPIzrDo8cxk/ndFz31igJ48MPqAUoSuo/s6qt1kmlBRNKbS59pqMXb2qsEAUAwsGWTtXhfcPgJ8bw2FmBZ843imoodAXXeSxyUEj0cfKgLCu0cUjf1dXIsJyZnOBQjy2hRZE0uN5btdd5FmzLzRcMB2YOHY7o2Ae/rckg4fgCNf7gPhuni68dGBMrcR4X7TpUIhOz8MAHrh5t906pBvmHB6CZRtbiG+fmGQgMEGY2/Yi0s5srDNypTxhqp7DId7X3NhiIERteUuijSvr65frJ3Yp8PX9AYXgB293fH1/xdf3VzvUdd+xP+44jgO6H5jTdr+ZcWYGWHcpW3NbbISB5KSPxXxc5MKnDDZP47YQXWRRFE9DwxOPBvEwKGpBzwrWe+C4/HmaGOs3uI/n+hZ+fu7G2qvPQlWNyLO3uky8KpWGu9Wxyvxc+13uVY72Eh6ZEcBYDEeAGUNdiV69GacfKTr7TV3fWYqE10DCBROH3Kn6Dn61QQZ7VZ5fwQyDD0/IHuFUAPZV1xIINu/54TUoVB+OoLsxVTdwtflD0S+qe7UZmPdtxW1r32gy5HhRt0TG91C0hXfCWJh9PheEFIhopxNF7UInbc1tikLoTJLh2yZbSq8s2YkSNHBvVISdQYF9YGKaF1Zs2/ixHR7HZifFH8eOC8r4iV+fsb0tKnRAbOCGmxL1UAs4psGNXVQM54rNg9wshHrz2DKufOS7oeWZ3DfE60Z60+Riw5NEBcfNXUuhGKtiTbQ9oHjojuMxk/lq/wcNsEYjC1O+RNLym7m0nou1ai7GW9bbetW4M8jo6yQF7pmUCCK9vIjYr2DTc1Fd2+AOqgmiyFWOApW0zsr3O6iNRLdrKXXqArDw81UH9nvsecq5C1D+R7wcEoZFXdUTnrQnzZWVUBS5tQVJgEt37AX4Ni+QYTzUm0J7q4veXIHSPlTPpPvptXhvFuOzB12IhocgdpFL2OILuwRV3f1ffxAFdttmdNcjdw1hyOI8AoGF4M1hoZOi0bqVCzdytCk4ABXMCKOaCtnsvCCMYcx9TmBMHAHnWIQc4U3j+Qbbhx61lK7QTn9vHojAX9uaV8wbC9vr/KaNNL5cP6Xre9/74/i57/4cFMB9P/CI0789ETxO/c6TgfMPOUA2tDXHOh95prxq8Z8TVHr+Rpbq+ND1FWL5PP0znCoFqM3Rq0AhXb4YjJQrAHS5CaDOxVmBimlSyIoZs8L4nhzsOWdLH0tUvXsFhNy/Uv6JZ0elCxiRY/bUGEMy5KLhzH3swaeldjBegRircz1pNzr1V1I/4lwg5QZQOIsKyM5TYxF90fBEGI6ulhea/+ByDIr6yUOU9RtNhFGUstzQTuFG5LAQBlf1McMBCEKBe9Y17zf4mzpniGvBGlSOpx8PjXDZwGEjaqFFPgNM+gb6+Me2yhUyjgqJ8xcqJM9umrfD7xCfmvl9Ik44lykQ39lx2wZ+5Vd+Bb/3e7+Hf/tv/y1+WtdnLDQMUGUO69ZKPzY8GVoSjDPa4QiX6dY6tzQGkV2x4hzkyIzfKDQjY/CREybXLRXc7icDL704FI+77z6QQqJIh3WmRlG6sIjGJSmRjhdBAQp1Leb4Mh/SLWaTo95Z2JmVYWuK1Jew2ORZIsT3Q6dLBZFnDlvpqZMCNStHbArkL/Pkivlfc4K4LfW3XV5foAgCN1a40oXZJzcx2TNPK8WPBU4bx4BhwbnwQyGWmHhTYLJHQanisjrHOyxnmxe+3UsOUXj2ATstiiRuSspqD+ZxWinpxuMciZXiN1JNyHGln47n6FZ5GODuQan6Wa4KShCoCaJksiHEAGSule8sN5zAe45WVD3zmSjcyGCtTBUcEzhOoVNKOBqYewAXMHjoFGBMYpRXyGwSal6YTTD2GAtNpJgxTnAIMFQwDvOOZBxvdto3sRbxozkGjqkRbVrId3Ft3rOwWnk4qsMd54FEv9Pt/+X6iV//s7/4F/Ebf+ZP4w9+/w/x9dsbfnh/4PXNt7bdd8vN2GmxcZBHa+Vz8Qkjv9FUp3rWZMJP6Mo55KQv/MBha6xHkOdTcbkMB724ov5LD9vK47N96/WVJV7Wb0ulst5aePvp+TvXNQSnQpe8rl28ZdHKUIGOOw2REcqiLMWqB1VjGGxHs8FEyS5fis+u5UgtOPW4PQco0VnzMGCEghphoIPEn5zhiXpKbkXS8nKt8Hi7IpEXFzeD76NC0UnGdIeDQRP6oQIVvjuQh9ZlOWCtIGvJvEUG8DKPgt+6ur2+dy4XETQDUnM2dSgp8Z8vuPximT3VPeqRO6p+YjsAOWxLdwEOP+pdppiYnQPHMfHVh2/gb//tv4N/8S/+Bf7r//r//E4/f7zrsxYaIpsrVBaaMgcQm/8PzMq7Dq1Z8s1lkSFOCJqEhvwwqk/1wO/pDHrTVF4UMIHN8R80AVNBo0tVccxpZ3gEswoG5qEz5xUFOtFczlwq94S+amJqq8NAllIOTxdxP1LwuM8TtSbrFUeZ0oxSD6PFhrETXiVZBWukarYeIJGHoU3OmPTiK/pgismIQAsrezYSJg95C0BFisEzB10gzaYXgcSo4t/heiyLFjOiKBsVhmWHks2ILQIAn/gaHQ1s1l/AKe2dlEoK1Na3SOaBVDgNwsoNcCuMFNxdsT0T4xXz76FNfp8TmRfJxNO23uciRas2XT3Z2ukhFiaZ6zF8ccHWmBl/yL9T5JTjOnMrhpT10PEwBXaOiPOgXE8zyL5TS6zkIlTQhofwkn/eL4sFhU7fonv6eib5H8UHh5f1oBy3gdqfXgXqp9GyB8jm7s/mYKV/366p07xl+8P+Hg/sxyMP6pvk0bDQPeQuxqXsOf/jENV1kjnB5agmCxFaoNCzuBZtru1IFmTlsqMZ/r3+nKLE+zjVjrlYxMJf8YeqhG8TXSO2YJZiXKk0JYdEmOsipDD7ke3oCc4GQ0dHoUc70hLklDfaXg6luHvZo+zSygkhXBGBPAsFV3K8i594segn77M+wa2lO6NyMtfFRnQuyweCJMarI7W1ErzV91wpWVqQR5Ocl9v0kYzZpXaIjZVsiaWf04fL+WpFq34aW5Y7wcPb+IcOEQayLBt5TP5CHkxIi5v0ZAlYX8oB9vcKEDIkJIhK8GnpMPnUWxU1WVVCnrtdOIblHQsCPzwRwjALG3M3rKsT9/TNVOyIp+Hix2XVHLbZiviewz/l08I/K0fDuq5JJGFdl01su9t1RgpyKOukRlQ8oFecxBNEwyEoYuM/Z50Iv6A7itWKOsZtdCKNfuhhbqNwaTC51ZkYqzJFfZOqK0EnZqnU96eo7Fynqg2crUIhYId0YUMMVNW32gxFVTqeGj8PWBXuVVrqfBJWtTL59WGdn4GSOf5s5d/c8/BscbKT4YmTw7HgTZKxEyuxd6n4u9eVAEu+r9yU/c7Bdkbb+UiOXbNlJt0GU5DeWCrlUb5s2GGpYMd7AbwkXGc7/riypOmuTai4va6LEw/a8SAXvvzoYczpoCJZiobQE/gigjwagYsUgm4uDrfvPDRPYI7wlX75AsPjdiX4CiuAYsaOOBQwzsfgOANxGBvcIZdiIbPKU+I3M+9boYmQad4fogcObQj8S/TX+WqrH+io/3L92JeIYPgZAcc8cBwPSwDf/RTwuWdeUOwuNWctgmuL5C4XmrIfPCjG8kpoaeUNvDfEjV3Q6wDxuoXZ51z0uaYLAasyq9dOatwPkmnxEXJYE6AeNgq6D4TSFcDSnFv75w9Oc60VLOBYVpzQS0h7Ks0o1DNsA8/klK7fiM9ltEW0HcIsynXIEuKeRF51h4hZx1gzpAaVT8HlksEo8adawBoPJpzp0lU6DLmBi8LPypJOXrEmzFgW28224IgyyY8XVF3cinJBCqehYnhmfW0gZmesR2tYd8i12FChV1BBh7y2ZkiSwrWDIx01NSdiHqpUGY5/PpFSCCf/NTRDDDXyVabY3xDMabt3zXlgjA2Rg6NzAoflXG/b9kTG/vjXZ+06JUCeSqzTczVi3604hTDjp2I9ZiEFc/gvhVkvbWPgYrZDUEtpIq3QPQ4rbrXVzNKwSDNuKB5D0U0WuROWmMBI3qf0Xsy0K3y32baQb4MhaJLZU3elUxcbswCX4cl3wUlrbguSoaqmcnR6zS0OUl/PuPObZ1idUXB/2duQ/V64lN/rRhqhP81vACVNhnSLA27O3Kl95mRnqdguOffX39H+k747nUiNXVvE5OQuThAxy8KwhCJMMNqjuCNJiMWEZNn33udasuwqZwwtCFkQ2qrynGRCEg/bQZAoMe8UVtWXFIBSsDcKW2mUQtHstgQ6jWecCF4SjxGaMjUWGQfmPKB+GnO7LAYkLTsWdiXhHjNZozH3BlQnxHepO2kwA8BOrDwWCGmmHIx0CsfTbCu/J9sJM6e35+78xFVIevU42mGe4php0SdtWuSX68e9fvVX/hT++l/7qxiieLy+4vH1Kx5329L2cX/gcfccDd+CU9XPUwmlAKyYE8O45C/+qE3aeLc+F655Wedl1dK/xCFvoSjFrlQthFJchkNqezt5Crq9FmcGOBuKRXKHXXHWXpGsvpTjK0ToNf5KJHX27vNHW2jM1dUESr9Fs9Y+n+QlyvnWdTNnKX417lxA9LzcAL+3KMvVCi+gCMDJiELxchQaIzrEtK2gj6UBlnNAx/0VIhriLsY3lS3m/eexOakJS7ErG6hSeckClkCoQVdcJ9WrQZdZkVyWi2pWz1BTFxa4S96XPErDQ8ZgMjA+qqRTpOqzjEku3iN02NMbxrB4d/Wt1I9j4tgUGNN2T9QDcw5MffjZIsCv/uov43/7i/8b/Lf/6B/j//0v/z9nBP+Y12cmg/tOODJ9bTEgohg6IGrfRQ5AK/PdjIZip4rDhbdPnkSgV77qh6EIh9HhdmjpnIgYwLB++k44kZnvFc8l4kChONw6OmOf8DZxYjkQI1or8ISXaUOXflB1JyNwEgQyLlIaQXY42vzQqkPoeZCjwFxxVoYXa9RAvmINx/crnpEL+TgegDrU9KsE0gdpsQqHNYXnbAo6gl8VmR8tGgzfBz/aYRy3VTeFFYUQzEkbyK62V9ZWQ+pKvQjiSDarXRj95QUIGEL3XZkiCbFcZKp7RRZGFcmGCDRHH6XS5YuJUUP5NRh4tCkZtiZcn9ZInOQ5hdJ1ket5BYUFH0/qQ2OAXruPQ5BH9JPhFucREwJMP6IH4kYFQIcfjHbsvtDoUNvBUJ7/EYtCwlOdNisYCO+H42H4+270EIA8rQGLwvZ832xnnc2FgM5msJSM6SLegQgR0YrVzq7HWJWVXLeYDSN3H4mdq+QUF/nl+nGuD199he9974/jB3/4B3j7+msPn3JvxuHyQWts4jsUtQAFOr9u17PxWufMBf/V4kfPq5DWRLEcv6/lXczFBnnwmI+nQhufLCuoa41rJCuQXrDxow60tG9CfaU5s/D1vErgVLlo2vvbL5JLqOcs288KKwnsbu0qgchwrZZf5svxk0FePjscz+hlVSykPzvJnIuGVrgbzMBpoJevPfRnfVZ8rden/fclnTCOS8qpv7h623V5JecI1VVf46lLX6bXBgNXeoGyZ3MwS8Vk4UnSodaGZOXuEow1H6IiDXjplW64XtCdTVTfmX+JnxY/p8k0C50SqE58+PCCb337W/jqw4d3+vujX5+x0DCXm/qmLDKAMdXPrrCFh8U5ixlIbl7eMTDc6n1MWxQAACJx0us37cJjmlMIG/7GMN9EbIUbTEbhUdAc9x3Klidjtl6oJZTOiGdDsdwaws4I2yVoZEM03a+Ib98Yg96KdDiDqBbWVr8o36VDmur4iamdgCZg+wFwdG/UHj2B+1Yt/RAXuFbUR+K0Qg8Y10uRAe0Ks9YKTJELUEPQnZKzQO2gDcAVv7QyDrj4VyKKYmy9jsglam7hqobqPnUu4S8GHQ1LtdfeI+FNlr7G7JhRa1i41WGk96MP8Q8xPlWP9eT2To2dWW2+7/k95XR0nPmYt3hobzfjVE8Nxmw1H+WRSlAIhorhVajNZVbw/JqHYqqfYQFPqnZvRgaluJK1QT2PyRYmOnwxFjvbaY15eBMGBIf42T5TkDESytvaCnDUHreqAmzJ1bBZ4BbEVw264FY3ZxcZGz2hh/cF3p01lvzL9WNd8zhwf7vj/vaGt/sb3h6vuD/uuL/e8dgfeEzzomW4VB7M130Zp+tCXlxe703B964nuiJALH3VWwRg49+1wFgqvpInbinXdiZN0XlqRHk1m6xPbZetVzLzdH2k0Lx6XBpXvf1eQ5olrsu/K1gvLtIdHNcpR72BZ7WdoAw9ZpBxivQeEwnaFXIKp+EK2zhFlyh8ncPMCoUXNPEOKvPRYBlHL7SkIKIDb/dj4YOniwqX2GQAJ5WRj5LBFbX1NGLNMWQjW1FI4FHOueAf68SFh0818g1NL2PDVm4D7900QG2L9HmYPr5h4HAr6HhM6BSMMSG3A0MF+3gAmNi2YfJmzKtjqn4i12d5NHLi5J+tjAAAhyNfBLoZ6vOQep05LHUCtHgIVjA/32mIvgchChFL0aVkDLSIHVpiVuFQqlw4rBZQ8YO3/KC+nFfMmAPEBelpLPJJSjztfA0iUq7zGV7bhPS/qV2fbvXoufyaKPK0QaVtughIWtCsxdduxs5GFVriMfjruye9trhuZ+HS8JV9zIkeyA7lc8WJ79TDE3YRvOzYWPtnZSpM6Ylu/HHhmJ47LmrMYtKv/pRhuK62cCXXhVc4470oFgKemNX6WiosS92taiV4ffw13Iy0ULzqR9kXgo8owTNID/FJH3N3Wu7CFD8vg66BiYEDggHxBYHeAOT8Nm48VNNjBpWe+E2dM48Hj8nwnI5agFiiONHx6Jiz+TWAsZnQnYBMC6Ga22ELNh8PZiEy1RfwE0M3zztxTeX46Sbr/ftyffjwAf+TP/dn8fPf+54lfj/iYL4dj31i12ke7zyYzz+B/ATO8+bdsOazDpEvad2p4swYWQMOWch8mwwOVlxTua12O6cs+cH3NRUqbXNYcl6keBA54YH1ObtBuQQXKKl3NEVC7/D6ZlXW5EQbiFVgs5LYa+byjGIrrtn3k2OmQSo58OfhX8ZWGWdNIBZbVtY3z5RW9RnEqmlTQSXbECRBH3r5s/Cy3NAEpJL37f94XhhbSSWfSN5FG0epsoH9ku8EBb+SociL8DrVzn3tOkLRCwmwmohZkiPjVx2wSp0pOsfPGqnwrcYcFnkt3Nd1slCOCGJo+/haFT4OEb4+4IPsXgugDllUyzk7RDBkYjvsRPVjmhFs6sSv/dqv4qtvfAO/+Zu/ifv9furnj3p93kIjVss+RlMAP4i7tDjxfIup0F081AoewhFU4BI/FGl1JdURrkLhReEZmIBu2piMAohdIccOjMPin1VcqQuFpfUBFooxFLp3RhSBMqWTNKduKqFWD3O7s+AJulhJUoo3tfckziOg8KpVYAj9EdjGxBxnLRz/il+vFwFOzWfveyTUmUGqj0/2t80FrfhSH9vcnRjIzhlj0hxzBjqYUB8JV0r9wLUMuUIJoTOzKia+gtjRE4m/wVxhlgUah5jvJyZ2wee5J7HcFtAWxPwur24WPNi37rVRdcY5WrPZHsn8ZEohBLpgqLL1qQ2PETcaAi5pnOofJLjF64hJYAnZdOAw06uPYTrGpASFba84oeqHpS3bTgm0pfDMOK/FGbx5EgKWWXNvSN9WOLwyQvlCAmBOO23ct8XFCG9SjGXxxAh1A3xPPLXd7TR4mwyoDByKWrRAcyetbVqIqajtMZmL+dyH+8v1417f+Oor/Md//a8CqvjD3/8DPB4P3B87Ho8Dj/2wg1x12k5TGuFTIB7E+onPtDSCPLtqXiuFQpQScuH1FbrblBVvKnLw0kzOCgk1GSHMQa/RcG4wGAuMzm+pYQSlBo9i+Zv67dLPyhtb4HFoLnFEsqeQdIVb9rxTvY0Rn3ligXE2iQWK+10q1TzNzPlX6RG8hiHQC1lKNZ1WqSeJW780PMjwYTfml3l2OY7En5JuyTOCZXziNo8uCzTJuyFFUGFLHS8inGcp9Lq0upLRpuNB1g4vKNEm67kyxmPRQcC30EqzAroH+tSXi+aJBoL2+WpyI9phRWRJ1kndbsG/fViOhYQc4P4RbguVsYOV8yMxjSPMvwcO6AS2/cAQwRwTxzEhMvxTMObEn/2zv4Ff+7Vfw7/8l//yj2qhYQxmzsr7jo4VMximJKghIXIxIsQgiFRduxipWTgrFIWvFPpEjUVKMtzQEGCDMAVySFqzsx1c7NoVYTchvHmnCBRrOU91Zn7wWPBYHPUJ0jaboFVooycumH10PBOBrjkcjYWGVXQUcwl3W2x5eCnBpP8EmihiSq7ZlAzMf8/qWpGB5GSJ18M6VHN/Yf/JIPMVmtDGzGqIfGYmUiy+UFIoE5a4j4lPVqg5hrm6rCMCa05YS+4SzDrorDO9YuqrQMq+r25SFsI1gYyuM+PS7kkADU2GqUslmndItK68FhfROGoYkmR4mniVZMjUAgtflkdS8yKZHwtlCRqrv9ghS3N+Wsf0JnbY49yh87ia0MmAI88lBTEv3kU9jyKUFPXQTpgiL3HKRyWVG+nWvASDjYFw5oaimaQcDHJO3zzDFUyx+YlDYauXaAPOh6yBnCEKp36ah1+uH+tSVTze3qCqeLu/4fXtjtfXO+6Ph+VoPHYPmZoVNkV+tE8dhcavWb/4iQ4jayqr8mwznPO82iNmACcZcV3/83Lr5fNLkkX1qt5tM5qOlwPYJy/w44/UmfItXki+hOIVWZAFOgHMuS/O0+Nxcf7Oje2DKWgBlvFyAXO+uoaKEU5LlVBoWFqa5euiAUmRRnDCjX6B/wtPzAng0kq6noLzmGQBSRnMdQa71vXdT6Y9uhKgK7h9tHhl7sPCUST5ZmvfcbugQQHS/VzmvwfaOpaqrNqgzmE/T5xaQEr7MHFYxjXxcyFUfKMR2Jka4xCMbQOOA2O3UIRxTByH8b6f9PUZu0654u4rBzu0SjNZEbmKLYUkrDdNCCMsolpKHpBjN7RUHLOievkhiXJjYjTxj6IM10+QEdpXB3zpJIt1cKrz5Mij4unVSF6l8Y1H7UoyIMI94/R6QspaKO4vE7C7x4vnrry8eTnODfT3SDAQKVuYnBdKd178x0iIziqNbdSjp6a9IDKUq7OvAibC3GrhRYwBcumdfNZU6rtAW+utoiAQcBLS0suem1UuajJdGXjKo5DeFtdZePDPxXrJ1khd6uCxKxo7i8B4HmOlcP0jXedLX1qH+/xoGT6cV9TGreNMAGK4LjHJ4qTQ2tp20g5O2Y71PzYOENEUnOoTMOd4kEwI0CkRWUXOpBJ42X+r2nhLIgwpKNlTFWVjAtBeWAhDgO22p+e1AwuLxDrP6C/Xj38pjv2A6vSzM3bsx4H9MC+G8gIj/7AoFDwr4nK6ueDjSQ6rYtFfPT/SpVhNqXPFoRy2tpkDURgQCQaNitfGuH6qozaqoGKLQrp276MX9esiACGbX6Rx/0U85iRv5Qq5xMOJmT/jvfws+CAPW2xyw6JwDUnKSkoMLD3SJtN7GmV1rkUHd5Z+unT50RdT9T3WcyKln4VXKvlZtHehuKxgnOn0UvJfl1/gZXks64uXhLYMshSUa46/SZgulVqRNkZ9wEy8qNfR520WawCLzzlpIWyJ+3yncj0AQC8nRUFqTRQfKOAUybxiwaFmnI0dHUWGG1WEjCt/hAuN2FZShyHLnPvufYiDuKJsHuUoF2ZTiTP+fKa5IuBYjtg2QRx1VUwyEmzLqgjIYZJdHRSz//ngqyWQtn6YZhCQICY/LW3QJxV6CBQpMX1LNPoEseemXT9lY0gtI8JPFm+HvS3tk/MBDJ3RliAnEHOAJD5uWxojT7sYMzsN8NJPFAe7Z6FkQFe4IP4akGURgtf+L0VTcpVWEzWYYFUfYyDJlPgskZq9IGYt7Sf7/9O7wcyRGXQypWIuq2Ui+lXsq0RkbDVpcfq9ykiADgU5kv285zUYq7RQdpAz41/oswXoIudsMmHAQvDE+0RWxaxfqsNsMMhFhhdiF31uoxt1EjjGAmoeZhwV4EmF0/iAOv1dxmGbNzP0JZnFN3he5YgpjGdN2w7QtqIdia9YqFjfJPFifdZ85r23A0llIM+tEUOOOI9QGc42alLFDmDN8+jeHO1oQoZnfbl+7EsVuN/vmMeB16/f8PXbA18/dtzfJnY/X0mnnZuhvuBgtnZ5JZ9ihcUfwW/FgK7HTV1qWAzwJ5bj4iFLEVLgDBdQc19jQby2xbJjvdYExFXjJdbTPPwhS9vBZ73Z3k7w6nfmwEdwU49ZlpSMP1V72e8a3+CtpaKSIVXeAec07lr0wTJNF5ly/XJ7pK2MWX+FiW2WJGliwcQ5mE+3JkP2f5T+PpFAuW6Wv36vidKFHi/VqIY0XAwmnoznuarwGKWeTbrD+XVCDtUSd2nH6NY/hH7Dk6zpFq77kU7W52VRX2g7Rjv+qYItwyKRyoyKQsfEPASHJVT7TrAT+2Ec4sCGYxw4joOQ/5O5PnmhcTwm5KYYc1CiT4hugal3JijFEcDuPFIvbJEiADZ4MnjEYdORDKmABH6N2k31gCefA7ymAXxLyhhk1esTD1UtfCHail5oMOZOQjzOKS/4AS4IMfTBoKPSMToRrY0sTEMc3tyZ6VKYKXkLSpE99/sMq6IzNfX2UgEMeKbjExN5RkfATcz6Yn3kbRa9RPlQ6CMsJxXeDB9RDNG0FkHEN6rSiuknTiCtTa121w4HJ/fvOeWV4k5psFv4Vz4OC5a0NiOXIfTGqHuKzxA15VMY73EKqwJ8/kn0TvxhKRHFqKSZfPitql8H1RU0QGTUaJwJIsd1PYmK6oESjCvcQTNeflvhBMHegTH6cKVvV8yvaiO3dkndD3fxUEsct0EzfiWeTHSIQoZCNkBlQA6LYqJovQIjOpEhC85cMjFpQKDYNDrWJ7NsVono8D7ZAmNMBTanc1/ViS8+bM0boTq2fJOA4cv1Y11/6pd/CX/8j/0cVBX7seOYux/Wd1Ty97LIsHWlc6MlP6HmQjH18OaXNzaYgRSdMwsngi7FShY6PwkHCCneWVbOb3HCctVNPA+htpC84UnKcivaL4ZJbS9y6ZmeIlcP5bo8K2CrpstC2hvUJ83rEjoWoXAVIsM5BfF5ISxbHSCs9YZJT7zsULzTZIRWTSu0a7u9xvCOK9FXdUZ4zMir3vJ/iC77eFaDa38yqZpDybydHJqGuy4fEuaoWwjOtaM1vS4e9wlU8Ns/ucymOlr/Wx3WiZzBrDqwMnca44aZC08WfU+41IfKcUACSL09ppZ1rufiXS40Vv5K89fsWNOOgph8iN/EMY6MHBAR/Pqv/xp+53d+F/+/3/ot/CSuT15ozNvNDgLZxP5kQGM7rXlANlJ+nNpCQStaHmUIocGwSa+1QVTMh2AQKuH8gEJwwARy7rIXF7f1rIcK5PaTKhknvc7gkA01wMyI0Yj2GTM6TRz+ze9cKV+tDcFFz9rrufhz5E6O7wcsaf5CWQl5dQrxWnfkyfJO/t6fxBPDzX1ax0iloTs8CGzos0lsQnsqMQn6OzHxj43FCtcCWFSdNirm18/kYI4nMeWl/ZzzYiE2AlssycnTR3jkTxaGsHmSKUoarNThViKXJ/B0RJO4JCUlz9sIBXvE4TQdEYazsTR6cUX+gSDncXWs6FqC8YY72ovMYXt/2ynhC84OwdQSCjfiGwpAfFtsmcCBgemjMA6HQWIs4g3t6HE+gyNgDTfiBDabD+Hm1shNkaIN0emhncZrBgAZgjk253dG4CrAlknsg3N1Kx70y/UjXyKCv/KX/kP8yT/5J/Bvf+d3cD8euO937PsDx+5C1hcbc/qhrpOpoVj4iSfSN1Y9+f6aD5ElSebVE76CTxUkOX2eTLm6vTIEJGGWXR4n48ZaEbM44CLkD0BnmL2KZ2JvReRllyjCoSuRdXMVP1eyQUMfoRG0s0U6nKbQ9Haq7VUwX1GD3wqeRx+dfWpEUF6+ruo7StHvXsIq1tb+EpGR/TQ6kHHugQApE1ZxFnQrK47iaRKwpAEtw82F6lugPoe2UbvaH7Sczit6T73FkalBMm0WpB7ZZM96Kc0D4RpIthKcoad08DSNAIUDp5MY/2USmMiQ5Q7DvU6tGqw0GmSoc+lXDK+qpTkcbpEWsY0MFYpxHBAZ2LcD29zwctvwv/hP/uf4rd/+bfzWb/92jumPc316jsb2Atk2yBg5uNMFqUyBigErIpiutWqutgSR/DN81mTojYRiYxbfTcu6YDvOFOLtMD7FFkoLkLPAaC1Wr4I5gUMF+6NPxQBnqOkOjYBQVoYiCkqSzg+pRNBL/lwErcsTbXUptS9Nh+F4I1MipdWzTro0aETVxCyEKU+obQAc2ybMUQDjdHtnWsrjk407y1PQCjvul3eimElt3VaGsGhbULv3rMs7L5OxiKsCZlbhldHE+QcKSuzN6s5COFmG1jAwnTRo9DQUuLwzgTjrQV2YiQReiF2trxK8wVBq4nOYmysOgohLLIGXQ0w7x6j3N+MDyYvlUGXbU8pDRp2vAKKq36b6Qv9kUSzvmyTRZu8S9ZrzLsBMNWHheUMFW4xNi0UbfoSNK4y+/Z15LxS42YQY3oPwIehQHCLuKZI85Eh0sxCo8ImPCNEDsANzQ+KoLNz+sR1JPObZ2qDmzoW5ZhXQAR2Cudkho5XXIk9o7Mv1udd+7Lg/Hrj7CeD7/WF5Gocd1Df9oD5dJn3JA1qEgjkFkp8Bzp6keP3l2AniGKFFg8lm7Y7ws6LvkHf2c1V2WlFSxLge4tGz7lyKiPgu9aeMiABlbaLBVDwdgO80FDxf853O70+9ao1eKcCpYNGcCetxrya8ysV7hcYveKlI3S9ZTHD1AUwggos2DBCu2NvdFTn3bsrCW+VKFnU+k+MYcmUNN1vaJBtPhaSyh5xYMlMNdzn4rkDKCBZVaH06ghMc3n3SRZKNXdBWczH3rV562/HuBdFqlbEql3HKS0oO+QvCzwg/bf47sZG4s89hN+ONfohsr2MQSK4WJB5CL46dVLN9pfkmYTKYNHbiCeCKSEDI8zi8cp0TMgc2Uew6IZS3Meew3Rt/gl70T15oyGYhB0bNw5R5P7gvjZB+7HkOcBtXP7QKpr9OBabUzgMR8rCJ2gm5vsHMBCwMQqyNga5HmT7goTdiqzbzjkzscmAfqwkURRDE6IMgo0zq+WpklwraykJo0KMKWYidmXG8XXvf0ATWKswThOE6Cy1SNl0BT0FBhaV5hRrHQVs5rFzbGYjhwx7mQYyZm1F9v7oyjCAmsQSj89Fn/CsdUeJMJ86AbweeL4JD1u/ZBw7Feg4nj2elCVRFbZx6zxooDF6DK5TQoKNgIj4eWWfCHVxe8/1gtnN263m1r70dwHd8095vtcVg8vOFWar6e8TZQ9ka+ZLviUGu86Ax1ZgXxRxjC9oQKuuCL2nT/0p+SiJdJ7BaV8amGJvFn8a2s1PtFHAL5hRbZw61Qz+nGgOdQjjVdOCEg0aibfd4httZnfFDBhSHAbY5X0T1PWlwgVcVOGJcM97ROjtNLhTihxpPC8R8uX6ka9s2vLy8YKpiPw489h37fuDYPWxqHj629mc8o+zfwQNPeQl+9ZGpOViTcFVbOr+pGbo+XN+Qkgn6ZAHDLSVvqH+Zi9nclWwqpzbXcZI5Uh8e55yyvnVuQdQaq3nqLPdX6amsL/iDhadlG8/qLx7GZg+gWGwtfKT3RzqOqgatsldKT3r/a0CTJZAiutJPG5OTFZ6Nlx2nrEcI4VsbrZCisoC7QiNcdl7LvjPUpd0oasqw70WpXB6rxoqOdYJye1ZK1/Y16Lbl8ZxC7SprL9ui8W1TLfAQHUiY/NkqrKO+RSe5hFiraAC+Gs94452khJCnvMJ3PSJlLslTHbCNkIbvXOXRRybHKix0TtfFXWe2z9D3fnLXpy80XJDK2Fz/CSEtgMwSiGCLcmDddnkSTIs/3sQ7t0ExfJVlmLXET0P+ZOJ0F4opThUwYpOYNs9XX4rJhMphW2I+QVnsmX/iizyjglmM0IKIAoIG1QkzNbU+b0jD8w9BxVYQ8dNMYItYANitW8tLOSlospK8I7tNwZAgnakqb0cTQdAwHJgHY8YMT4XTUKPVxJm7VL9IePb+M0Po7Kzcn7LghCYlAhcLEKsQbYB5jV69qFTcKD1n0Rz96Pkw3f367OpThERO07QX5JGpMWNE45MEDYOd4064NbRqPY25K9Ue72ihC54znMFXJ+mhQDA+XWogBhjWujZuBrAob/rgzBKS/AC4CNvYAn6YMBxCOk3xCVsI+N7cCugcedCeTphST3gEBHFgXuAIHr+a3UnXFMV8UxxhsqY018UjrfYSPq+KEkNiZz9DxJejwX/U68//+f8p/vJ/9Jdwv7/i9fUNr693vN3fcD/uOB4PHI8Dx9xNyIbUkT7PT6EgoQTw/Yi3BitHCxNg+mUb2KoXRdlnPOQd3nJVLMVDEOogi/kiGlZQGYzmHV/eexekMOE3waj92SX0V0gIfnnicsVXqXrPWlxqeWdcEiySz/6gK700dz+mla06walbyXWq/WhhkUHPmjpVJwvan5TpNS6DqVXHpNdOjZLRJG9d0jeFCmUY3wLTlS7inyPQ8xTfQs8uFuOLnmFlWDBWuVyYXs1NdFwGj6iqLug2B9T/MjTZNyIEiQ8X5MVR4j2XyP5cRhlBbJzM+l9eyuky2uTukJE7sc7Dwojn48BUwTHMMC+i2Kf+RM+I/fRdp1LBDiGpGKz05cqvlBKeqHkA3lAcI1ZS6mY8G+rcmtY7aL+JGak9O6LZ9ogSlF2xEEw7kZcvJ4YWS52dvOg3uI9L+dTopNFCTnKUInhizFpfo0CCfgbCyl4w43WS8lrjSkBGvGa9qOTKlWwn5FG56Dro2upoc7tcxF5XCKeZQCIHQJ2TVnJTVNimWG9DnT3JVYGVFRPwJ8FV5fhJLsycrnhM5KIWKBo9sZpdSKkXarHSQWccxj2B1oHWIWDb886Iuety7mYq0jGGkStS2NbTe0x3ZRWkA/qcYFJJlz4sK01ybvWKrVJkpMEaz67SZC3JWlLWRd2Z34Pk2/lQHZHRb3GP60EeBeujmIUn3mLabfN5Ev+hOFkOXVPUomayrCtsZf8FkCPao8H4cn329fLygm99+1u431+xH7ad7eFhUtO9GHOGJY/8i8Rn1vmeX4LXE3+Mq9k6/FnSI/HI9Woe2YXJtroumEgL9E05HOWdl7EV/iRTKn9jBbISjztsC6d7fn0GCWv+u874aENP5drzBFSRu8GdajgzyOKlxZVYSjS8Am0R0Cph3SX7wF6yjl7nKFiVXu4lyx2NTmrvefEUnBYZVzA2BnlRBEsdTU7Ri+vraxT2E1IDQNbznBtn7wdQeklvuZe7irBgCrp8n2DNeuRZXec+tNBEqVHSBbe8HL7UaxrF0EMi0/W56umNkq+qbRyGl48/k9mK2J01eaGaueXlqw/45V/+Zfz+7/8+/vAP/3Dt+Wddn3GOhnPTw2MXt4ovs10dRsaHq8AOqsJEHiA33DoonmwnHjoVbj3x07xDiE9tseU55SwxBHXOsmsTG5cTO+xsPpk9GrFwljMSiehpXVxmpilX7MRdVM22Aqg47hBZyZyUrEhBbDHg8XoG2SsxTORbVpYJWM7fvU8VwtXJuliDFsNyU0HDmGiEjyMT8p2wtUk6lp6EF8cbz+BascfCMDBaq/divK12VEVsn6LeyEncsDaHWDll6Jj3J1B3ehdLFgL1g2GLcQ6nV3l3PCH/Av9hTQeuNxRShBUu8C1JJ4qwXgiVr3ymFFpNKyjhmox9ONxZTkDxdTSUdC9va4VRKTHbaCu7bbhOL6cOh119QWf03hxPcabKppg4INjI0LHgaRdgDjvpm/hJhkLFYkgFqhuBKNBRnpUNGyzfbNY7gHs1thK6sQVizJ05MoSkL5Id32mYQfioAZEMr5IYD5U47968Ggl3UMOXbad+1Gs/drze3/D6eMPr/Q1v+47748DjodgPxREbDajmroctP8E/mzJED8/KC8+5rikYy9G6/UxzwvKM70mvtRXndyjUNCVRhGwOdLl1EpXMfUJJYQXyDJycfl114Or6nLIrlGflq4WXnODiJ73ZfCsnZ3C6Lo+q7ALzk26oP1vDUaIOoU8OcLskjc9E01pHo5srIoorclAJuZk/sMB0QTokX1EIkAoZ52Y02lGAdynkV9fOXLUZdWQxWbUELyqoTPul3hgBBVKPW/F2mvskHpNa9D3k+rNRRSL8n/WRqPzsjSujtGqfxipqckw9+sf1hNAF51GLZdtlL0KmDsy5YZ8TmAd23fHHf/6P4X/99/4e/vE/+kf4Z//0nz7py6ddn7zQsC1pHZuHhUFFYjgAxEIhtmiEKxOxfWPEvKlT1SAiKOKVbGObhuk4H6N2mDJupxInZtgoC2KnEFc8xY9vP3o/VGBhUFNc6dJcdKQVowl5pEKqC0E+n7BFaMyQZUjbfKR7jLXwlBR8PbP6RCfyFySe020ZsfarYCOlKGLmFbThRqCBZnso6CphmRHfn5sEKGPBx5tzCbgTGabEAsHhLK9Y/NNfVk+kEHIllpCX9k5Z8BwBxJBOzNeVyAQmxiEZQt3KcB5/Pxe2GQ+6agSa/b4ygTKTEsByoqL+pKcusFiUSt1IOFrTHuIGaG4PTNPXaUUyU0/pYeRKxOnbQI2N+o8KIYsFFnvpJPGXCyBt/NRMB8GDJTwmdoiaihsnFlIYKhiWhOE4822EY7yCh4wB2Z2XyMSLwz/FGLJFXw4MaM4dCebv83YOYB4+tlsAL9BDIZuNlwDAQd6O5GMK3DxPjd13Xkd6WwTAmNDNx9xpdZ5ixr5cn3rpnDged+z3+LMcjTo3I5b16mEFlHcQ1E5zlpXB7tZaP0ILoPKg+kH8JOpiOdI0G10eKGqC+t0rEsk6pbSSoDOus7neWw/zdyqB/qzJnw5KPkvPd7Sp3CqFJV4JuJAFi9Ba5UhWLuvLhE/tr5xQlcPUBaWiy6Imr/2Z8isOg1VFeIxF36KAxnMjr3qWPDVEAvHi8hxrWv8zbP2Ex1IyE+A2CMvAJXZkubPmEQrx8o6fSJyW6FkMjSOrPC3SWoD3ycCTApeh03gjDGlFfw3i1CEWnLIhTYSeOO74OSKPSSvXxMdCBppaot6pLu/OkQtNn0i6ir46HBGSHETVXZz0HpGdkK4AzWnOYfqBZVVgTstXnFCMw7aDn56vNuew7ybwT3rdj3J98kJjIISrk3Vx4kRpTK7oLADIFllEpUTbM48Pc+VMh/iuUsAmitsLoFNwqEBlYgzY4XzT9mmNsKomEA57bKtVwTgU+rJaAgXAgG4ApmIO+O5WZ0beeI9fi1j50a+ikGQ+xSKLaNbGzkz2CUAXDLZPLho9Cu8IVDLPbjlWahMjGSEXXumReNoiSmiiic+7zyTmVNY+472Loie4AFSiHr1EBZfdDzvf4LFSt+BQOGExOaXvJ9Fmmx4ow1IVn136Tzq60kfwrYuhSliWVznWdEV1yapghvSArKkeLXTml4TTWJDqkEy3qvA6wTFhcaML1ENg51UIgAMYu0JuVqmvH8xbOTW9HUMEN9i9YwJ7bPvoC4UtYAKgMmuhKsDhPGqo5dkp7AXZbKETJrrgZbGpgPHqgRGLkeFCbXAuCyxcSsWADjzM98b6y/XeNcYAdFouxv2B/fHA/tgtEdxPwuWTwAEsYaGdE7TwDS638ttkCKT8GfNsxVpTfoP5UVtLxPyFtgdXIbVnvhiTbWEKCwNs4mKposn1iya5ZIsuj25vvZXCYyw46m4ZK6/hu4KtDYzo9ZxRxn3vy8qDc2cmrCqjlv7HL0qH6wSrri0Hm3NNRv0J0xIrsE1h9iIS/Px6IIWZPdGjPClfSCfZrv1xGxet/giEatema6Sa4C+F/kCPEXkGDFDz2qfc1GWsuvxN2IQiAhyJiQqRPkVSHJO841a0RBLPoh4+y2PzJAwu1BaCa13Wp6E7O+QwZSJHn83nbMh1jtZoGwty7+20XRfnYYb/2HVvTt+BDxNTDpOZw04Q/1GvT08Gh62ex6auxwfXmwC2nIipY4gT+Q22Ye8UyPQjwcNSKSPPsyjrryXjHUMwZVRIkyo2HcBWBwGewgk2orJY8Nw7uxExpWDAzuOg0QErW0lUWgRxLe4vWG5MBod94X8kBILBSpYHgNpKTYvYglRSAbsCocq0Q4qaXBIP/5iux9VkEPHzJbn+YFiISeWwJuzMLC6WC6sCyvCSlO2HKlWBPgmVWl9wwMxQtD9XLMp1F7YskmSFTal1V3yNjxRDNjTGGErW2lgSWxPDExjm+RwfcpuixqwsHsXlgjF3fBWsDAWAyqJTYtSZWdcvpU8j10JeWYkI7qCjULIlYCsGaP1QiAjBJl7eV7rhWguG78ndGwTbsM2dtoXZZSytKLApdgFqLxNFbC1oYZvBn8T2ixLFAbMgDRWf60rbnsFXlbaFd3r+0qwV+BgevgUzxgw1Q8bDR0BQoSq+21Us2DGpnqnQI/KWAHFBEKabL9fnXT//vT+Ov/03/lMAwOP1jvvr3T6PHQ/f0nafE0eEzmqfDlfcvqj66uk7l+asS4XjSim9GuUrtnlJDfLewyqSnmqu9MxCzvfXenX5vCoj4B3UT88DBxlGe9FeUD+Dfeomewqu4OSxbfJwvZZI+qWPSoAEr06VQzucCrS42Ct0RUtll5GSbiWaizaVgC9xcHGx53RteJFNJ6STpFSSA+jiPIpXv6teCwl13sfEfkHz7ebaIUYqTIZkeEtEr1z0Pkex9Z1LGsZDlls/Mzaj2qZ6GpnzIPsrCqSMCQlUsm8BMApdXYkql+WpJ5TcuQp7DM/VyIaldITso22yBJl2JpUqZBw4DmA8gHGzYyosvcH44l/4C38Bv/Ebv4F/8A/+AX7nd37nCdDvX5+eDA7bfna48AfEcywc0+oCOLaH9LANOeyPJ7e6ME/FLcb2gB8qY5bLCcURhCymbKi7rGIBwnH5bBUQtRCIcWHuMSuzNIbb5yIpGwsZN3ccERm/n/GGsB+hLp/CAgXgA2lCgAmAtm9z9JGYW8HaZUU2oaATocuqFgudDGdi3h5JsJGIq9rmQk5C98IkauNwIgliJgbnk0ToVlW4sqcqEG5RxkXUkDhg5YCQwMqwMhJXAHL+GoZGVsyn2kVRDgPq9UR7stCaAL4ldIwMpfuR8ONwrEBveph0WahGHxk2OQuVWjBJKuMZq0n0SetMQynzNLjI8B8tBC/KeAWqFrKU2yq6qS0U/BKiDn+8h47PctHbjTFtq9oNw+wI63wmARC4RGJaE+MCD70CnZ+jsTZSIBbZc7grSWlcbRxFkJtXhZdBgDwbKOZc5DIJKmE+FovpEaRxFYGFVk3qu2rF1/o24l+uz7tutxt+4Rd+Hj/8wQ/xe7//Bzh2W1wc8/BEcIXqTLlxUoKYwbYbrPus8iXoegntSOWheF570OrS84Skds55ElL/stxYr8402sQ78RjYXFtFYONfzLSV6nB2l+Bzu7Kgk3hj8I3cdAHCPcv+ss7KXIQDh8I4meXpnYJF1xs4X3JGZnTsPDT9xsUgnJJ3CYfKv+UKmhWZfqeR0NJRpukQ35AM0wqDGI9pGRqXl1fZEmXE6Z2BD8NarSSr7+s8SxRYeXXikHrxYr44jdCK8ZzL4O+3Jq/Lr/VL8HTqfut1Chvn+6sgbbWSckI6h8lU8qGs8zMAaWizcN7yrEbYrWOrqQE0SbPdiJex8ZhQDLVcap22I1X+iX1+61vfxne/813cbp+e0r1en7XrlCpQO5p6T0kChlLFY5DJjALAY54zVjyteaaUIA6qg1o4UyQSI5Bjn5Xj7eFWrjlYTkhYMN1iv2wLaamdSCGe7zWmfmb+qT+pImPfY2LQzFvkkRdRprFkn32Vrwu1XQmWIpCa067IMWMm+ir3LrFl7uYiSRrvTQbizCfgS87NPXJWw3x5mXRmrF5g6M23Fy8nH02qKksFs83eQDFWf//Es5mLisfnXzxvvxW9wx12aa/SHS02GrB2pWQJCaQ2Tka/xlg6fK2vQBB9gb5KwsbQAparBvhe1K8pHDOfAyyACGBZ6hN4zhblu5AnIv+LXAYGuU0lKZ5KbYzo98xJXFtJSFFyy4/K2A3aPEBtp708/TZOeIkVS2bMEq4dm4Pq17BMMeKnQvVAnhrjvDMXiT+BONl/3y5Vxdv9jte7b2e73/E43rDvdxzHjjl3qJ3sijaJV/aGznKE7qU+9S4gH7/XplcMusK8ZFzuWV1nBvAuKC7VspvrlFzhEiqny70LcfkJYMWcEmqDa4/617sXTRFP+0nMkqcwx7yGdluUEh9K3prdO1uz37u4zlAtNXLOnjL7j1S2vrAOWDCac/GV9i7D9Bjo0A+cX2boL8stljOCS6/P9R3nu6cFSy0yS1+B9SnPw5L2TkSLmI20OiVPoGgQLHh4VlrfecZlroezZhvDFMZ5nZEH2bQl/62Ob/EQXCbKGgjbaEVxzOE8TCz6aEzM3RYhcwB6fLwfH7s+eaERrr2QnaLuLZDKyYjQjvDuZZ9iP3z4pAEgRwQ4SFrXI/k1lAFBeZeCHuN9wHUWiZCIeMcHRCwBs4UB+TvD6S/WNx2J/su33V1jaSS5WXTOyTsVHKl+LxTUGbWyHlL62nJF8u6JGE+FpfAOOTGFGKN8VaN+kAuPJ1yVraa0ip2ES91Mj0gonwsfqpaK6NuYsvAWZGz95TqQGBiDkYaUd5SAEAQtVy6rDba18F8pmkrrOnkJIIE7hkrif8Q4xSNxGDuQQvRHiAFSodUFZpK1Nb5pLaTx/JiQUvhJpAtfkrq3/pshUarJE7J/i/CKRbFG3RK8JIHufaLcoTBSNHBFsq5Y6HrhDEczVAhkuEdWy1oWdGiHx1uYVpz4PYM3BVTTzz/KG3aKuIWKKo2BI21TPxsjQsbEclD8pPU0GMDzAxSIuHA2hChvhfvl+uRLVbEfdvL3Yz8sAXyvvIw5ifn7pAnyuXCcXTSAU3km98Y3WQN9p7610Wfj/ln0cKXNKJrxhQzPT5TJaxCV7zZZ6XNyYYVZ9dI3o/eTMCbwe14Di6Kqv95fMzTOcBeMDATnv3HddZfL263gt0odY0wIfCt/eucpYAvsmcjN/D4QcHr3UoOg+9Q3B6wMVzQRLrrZPq/kf3aPhDfVb7L8DF/SxzIVr6KCCw6pFwP5QnwXAO/8yAPCNNemhax4qPt5hzw9pyHk8dHl2cV3RgzrLQ3KdmhwFY7ohCb5CX8N32JG4IrycF1V4cZj9Sgh92L4gaXAAT/1z50MP16i4GeETolnoZt1eHgogc8iCEoIh2MiV1niQQwqHr6guPEJJQeKK22alJYWzHAHO0LCeChqbdpBvwLI5q4oLz8BHT19VACMIZbA+YhQkrJSpnbE7kPmxDGoUuCHBTrzDCJGit2rwS+EGVGbhb0ddoVdaYdt0F3Z43pC4eP2fEb40YuZj5pxpw5P7mPt9YUwsQnBjOiK41TZNgGLB1D3rhL2pPeZrBeMqmyvSCwnbDJ8RYM1rBjMuzltMfm3W63a6w3ExqJaf6R+rFKww83vE27KY9oGrdWR+Rxsjo8VgdJ4JT0I1V20faKqBMtDIiUEXZVU6l6GOfj3WmQU87tk8FrzV+Dfa88IiA6IDIxN7GFkxt9QmdoJj7fvIUvmVo7kXmtZvf5ARcRAR3jLdHinKkQPn7622exMehdss2V/ILauPVQwjuFGTh+XHb4QnalEyTBPim6+KPFxUwX08I5uOcxdeHzZ3fazL1XF4/HA/fHAfd/xeBzYHxMHbWnLSeBxtfjuivflmpfyPvNp0M6nMevVq4iZwWWTxxFDk168GxriXpMVi+DBed7kLPAGk10J6N3iX3qqgQCh9xINRLMt5NHnYPApKNderZwDZpSq6PwTQqUjZCrgb4ycenHhaqi05hgXXQv0nxJdKDpZDXzavlzXw70lltPqrQpdYokub3K9VzpDVVKhOwswq8vcyycVRBitIzXz1dDJJtfVJAaUO7iAtY5+C9ELfUIIjtSg4rMjPuZChhSvOhR5AwqfrcvLmOVA061VF/J/yRi1zpn2LVDNVlX/HTgTRirc0CZrBkgfNnXYFG4085VhOy1+VqjeVDNmWV6kQucBy14UTNygekA1d3L4ka5PD7qaQJo6DVIobMvIoIgYbIFgS/0j4pGNNDbRzNnOMsHsx7SbuydSq2bIjoTCkdZIpoVQwGrBENEMOvfWDRmwXWmGmFDfi0BigFKhs26Vqy5DpZBtBBCswMZE48SiC6fBpVu1k88iJgq0hRlowRAPaZHBE0armmKpPMtFPea/YFyZT4MvOEpOrurQ6A2d3j13ML4Tc6U8jgxjacWdYah2RsGFiFnx/ZXHolryphcFIZhnbP/KwhnLuHgeTNJnllgEmPJ7lXBsAKh7nz3Ph8YpgtXy/RE0pwQyi2fHI5Gyt5igBb1nnTluNEhcbhkLdYNCKBViaDjF9EZoVS4iiOjFaVdlYIrt5DSm54dBTjlXaWgRMyBI7CAXc0vF8ilUILdoiyc3/B2/LQeOsQEyoDog44DOw0bsFudpKBS25e6mE2NsmBi5Ba1MTU+heWwnjnCjzgJc49AGFYjaxhg29jPxGZLtOCkmX66PXVMn7o833O933N8e2D35ex4TeoTAhefb6EkXOSuDNacuHlDD/sm8/pLRYbmnz28RD83nTvjBx58C/exai67CJ+G4gtmvDBdcGD2/Ru24iKlbPg8/6mnl4izTiEVbgbPKegm/39ZTCeb3xcfeB8gvXlgN11uC33K8f1TakZCQPIHYi+jyUC++S79FesqpciUURrwm0GVw9eoZVDgP9iVWIRcYX2tJ1F/oRlaZ1I/1M64ZitkTcFcyka4XnYqyay5looJiZnHK7r6as0y3UUxrBldKgqQOW+e9agh5hPF+GUr7zE6obcKk5hiAt6Ix58Jj4vr3hGJXO0fjtj8Mns3y2Vj3+lGuz8vumApsYekNgAVsTQj9AcicSQQXUdg6QjbfvhPmksmEzCnm3XggTz9TBXQAmyeUi2omXIqaYhGv2vZfxrSmeHzZbVmJidiuP77b1aW2+exKS38pvpGIk9ZjmrhBE4Orb8RnXzxVJVXQ967mbDk/pQ8quJR/T+Q1WSdAkhfxkYC1nWmwztD3nn0EfOJ8p6reu56yr5CDy0NZfxQn4+bPnxSfG4JzWWUgXLa12IgnJEyY8cTzC1kdWNAFYHFY+D5bhwhCPMeiJ2wzjB8br6tnQrczVOhKb6H768owrGWO/CkT27b52RhieRyLNWwOC0eSRIS3QGOWelB4NRKYBUIFFAOHwhcLh708pdwuGiGgtvvdJsCmgn1OPGDeWlU1g0ZWO2xBpOERUeQ+ve7aidBTBewcjliEAdD9Cc6/XE+vb37zG/jmN76B49gzZMq2s50eIlDhannxz3f417XuFS+TcsVz2es48ydiEPTZePSTsS/2flZOV/DbzSuYMyn1FKSURTlb4oyDspg2A0zwSf8Mr2NUmt+eysjnfGv9ebLwa0Hbq9MFxwu/R7CmjtV3zxNoDLTqqIVGyYqspdEVMayETRIx78nqRZ14VuwyhJlx1V5ogihgKOnFXdWlVBvXEySEiLxFy2RSyVq0oSzQaIS1Fmw52oSXNFSfgO3vB35WUc/1ZaXUHyN5yiRKXZDHmcfwQsuTQouGYhAySwHecCXma8tdanOrdFOrszOUZDMLD4iFhh3eN5xP1knhogPf/OY38c1vfhNff/01Pvf69O1tp2LcbLvFAV8lAeYVuMEPPSqCid1WRh5ihlSMMATqIU9Kll+oPTOoHDlWyNjXoRlXqlMwI5xMwno+i/kKIDexLXFbR8zyuWFgH2Jbhz0RJG1iBkGrFivNsJ7YaoZr8Ni4qEjguQtaRATJxHZt1IIMXWncJJ61/nTutrBGNGblRJtGZLL+RtuhqhFEWXMlLCv1l9qQaudK6jlPofsLZ2zSgPEhOQZrfKqMHBl7M2ZjLG4j7Ea5DLUVY68wQRm7pk2a+OwtSWWAhbAszFmqgfgo9Nh5DSzIqnsAyMNEirGIbTeXmQB+wvQpIFSInPMft5AzGyV8nEIFq6pecXRokZZNmASuqMoMA/O/diBR43yxSIjxV0BnLuatK4vocsuOjYFQXbbptsVXwnjOIXZo34YMAUhh5mUC15BIFxdIJIrMCfUVgPoiRVWSj9lUUowB3DbjVeHNtV09xPmPl3f+ZV1XDEzbdnsTOw8I00PK1kn/5Xrvut1u+Lt/52/h29/+Jn7vd38Xb48HXufDTwM/crHRCXcRAnwbRSdF79qUn6tX8/57Y5eaKNWxvvPO+xEoPFAJsaf2n9WT7RSnj7N/6j2SAlfa0RMucf1Or1aoGBBGSUdJzMmrbujFzQUs4iBLpA4JI2l3CibiW1cooyL9CcuSQ1OemiKqCA/1kwo+Uv87hd974Yqs1zHRi6pmF3HW3DyPOnmzaJ+oC1AXuXLF0q5oPlSL5fZp6FOOnG+t9XVxdq6Raed91huEIilzns6/dX5zFeL4US4vpafoUtgrWWd7qASRgxHvjgLvFMpmn3GuBrAfJptedtPhLZdtYtuAv/W3/lf43d/9XfxX/9X/CfveI4U+dn36gX1iDWfINMS3XbSexenaddrWdOEZKCpitF0UfH1MMToCU/xbWJ3Ad2TRUspDQKtZOGUIhmdMGtLgFkltW8oaHANDNgyxbTMpyvwjRAXEdCnFKQDSjAFfGYXQvXP4oyJOniQQUgFarSEQLctsNsI5DRG6AqJJbUCN2Fa4NFEWM13vm10OMoxdidQ8XbkhkSaOy+gzz2OGgqKT0lar8Y8x/eiN0C9zcgl5gl0gB46ZOT5h3CcBmn33J+7hUA/1AWKiS+VRhBvexyUFmvqcWPolXPbU/+hhvRX5DrlQYobbuG0fgZNTzxlVfDcQTlSbRNlR5iPgeRJNkiuA7YrHygWCrXyGPgUSxsA6oVfbWfyOrdZTiOo0MMbIhUMKRs+1gC/CSz+qDorHseaKMfieL0inlmFhg2+VOwQzFkDR8RmM3xPQmVoFGKo4FBXfPoMWviRpfM718vKC2+2G4zjslNsjLHTX3gyjkVULWX+uEzGMTnwzpP0KkRRB8pWTlblWtXuhPzHE+bTxbeUqOm+R0/srlMEAChed94mz+Og5I2hh9sHkmon5ou1rUHp1DQYaO+ZbQLWlHRZV4k/QNiWxgBfDFErbiv/Gdwm/kQMYzcd7mppfB7hE39mjoih4V+FzBVMJFOpP9pGDuDu1XkhkXD/SJ0UEoa+E7I92Uq6kjncxaFet+ztXpNLgSfry3/mCNAT1mcVtEq17w1cLwWfyP36IcuE2clWDwnTej600L/rWZqGsbcW9GukzDyETo/YqWqvJG/17HGbqi42vvvENfHj58A7cz69PTwZPRSlirO1PAXP1S+wIIzC/h6LtEcw0dkSd6ApJhE65IDZru3pssyLi0tqkF8WG2Xm7TlMs5qSG/RKBjA0iA7FLVg7TyqkD4Ea0K9mSAFkocp3SKRAYWHarLZyD52ghjxuR83ddnrAMSFrVvNW5myTujcCvWJO2+XmSYifukFrbScbWhIr+s9rv4/1EltVv7hgzQx8PJRytQlhtYtZwVFjP6iYvOr5AKDxEShYGk+eYCBV9NssvfgoJ+aRTh7AxbwqdUCrHBBCnaCoVanJpFSScjAeqi0RUnzhcMPvZ9ndqBG11ZQ5HmjGJE04hfMNPDT97KBesIeZJVwHsnrZDPQMvbrBA3c9kwun10ECEUE3vGYAY7AztmgLdUDG3RFuWAE70U6v2XNxLvhOwPZW4X66La993PB479scDx2PHvO+Y0/NtDk1mxOuN4nbrZLy459eZb/ONjygT8ZkKgXTeSiVlfS1ZWqgh9EDQ9OxnLOdUYXi+XXFZz6zJqVjs2YwKJwREh4r2uZ9cB1/y5Pt1medjxOc1lEgom7qe3+5Ved8i2CFaW7SCxYhYtSvciR4iqLjPqiJ82rxeX1pvyfKA+hGPT2KS9ZSQ95eEEnhlDCxy4AKOpg41vv9OfxcEryTSuPtKLK1anxOLCCzAGH6izeVaVY/zc0mxxS897eGa53GFkjAmn1pfoVgnzxpZUB+xYAYq5yNkboWPFT+ch2Ienn6wTxzbxNimGWx+xNPBP2t7WxVLAA8xDhU7ZE8lQwlMENsOVcKWd9+ZCkqHwPkMsFdNgOsBE9BeNoS8DI8lD5cS7L0hmgMYyeCmP/jknucBgbjNcUh5vdhCS4MU3+q+tDE33Vwv6EC6Thr9BZOPpnF0rYBXyWk10wKB6dVgEnrX1dGodxFa8Ur0yVW+dj9JL+m8qHWN6koLS5RNWpSUN+B3zufhQRC7uUlfkCitxgmc/roLSK3uxvNxKs82ZEkmvIbrd74oqIA53i/FmFbjzxzORDqxuGTWGBNvNOmA8NWj0iQRZzgq6NunlkMpqkqFgAfU25crwb+8KqcH0trTVm75pD4UM5Ned2PSUkQQpDjFFPaYSxcn10XOg8FjnpS+kI5LjX/JBMbmPMkfTcsX22A6qKWD1Ta3gOZGH2kAUfsu4uFUlJPhh4lDDw+BCmXM+zdHHDgKWujYd1NuFFucND5s/Kb03ny53rsU+2PHvj1w3Hcc+2GLjMNDpiIrUPVEgtdMpuNerm43mSFIowkxI21zLBQc+1zYzUlZYbkEZzFZnZxKtrr4Blvpgw1VTDjNen8vdlJb+6tUH0meK4BOL5702QXf7MHV4IcrQhZ3Q8DThoyQug5V6Bet+Xgw5JmYavVr/5JACzzvkuhrruWS5180ckI0QtFAjoY4v/MyrQ/8bhh7GacI+il53h40hYEQSQz/gvTpRlc4WIXgugP7KznwtZAvjd3zcut0OOlnrLycPpEy2ER0Td7awMWRwMIvF5oLP6Gqpb26zimptlLHKIYUIe5stJR6DF3KM3Z1Am0ra1GKFijwpyosVFlsUSGA6oGpB6YOHDprm+bPvD59oaETExaiNP0kQUAyjMg8BHDX0HSB7AmaQxA7+GxQxBG9CmAEQx4W2pDhBGox1RBkYqUtNAwhoW5ZaIovfgZwSHlUVMfJAioQyBjQW0jxlZT7V4UvojSndT32MV/39vebxOkXBhyErvXVipVbtAHSCq3f4oYSQEKTWlqx6JPBUcSXgEVZD+lZQ5ty1dCEQuWetH5WgfpKnJG37htS49sXaDU5AGfYxGBrasZnwMcwaP9OnComaOtrTOqM+Xc6QKCY6+7d7TdX/1fBkVv1ZZagPY/zKGBkjfBgxMIzGU0uyKSYnNNBdSPeCbCWffeCTqXfa11KjxsvMrQkWlg/L2hbEfMmyoGJ1zyebYU3UPlOAmwwL9HwF5t2Zdfmt4OtbNQXVQHmQJgeoNOViMPmSORvbYpNBLdp9JU5F6LYpodM7UgvhVmC7LmGMST+nH6P4XxpV8tvS2CBYwoswEptZSNIg4cOo7uxTUh4XyYh7cv10UsVOPYD+2PHfHjolE468bbYc0sITTT7pI/58e5FdK/0O4FBmxPnd1NTqFdkKUIgVp1yKhLc7HQ1oxW9Gj/yZpdTEjwpFB1mo8Ug6j3uv9Z8WOFfd+tLpUgKViGQQsmqqBP/IZTPdoHAZ6g7f2MFr5fl8KNTU5fI5oRpX2joufD1bF4gJXyeRpYWqMJ6wwqkVvEI026LzYDGRWbUupJ+OySP2FGDallgMNyZZ3fZ6xXrgcXqP5a7pJAstYUAW+bbRZhRb1OdXKWJx9YGxxlLwRPUply+NXPu3/XFdMv9145vhaUsXFJ4lK9ammlUK1y/VADNZ5EUrnNiTrF8Nl9gKNT1r8+/Pn3XqYjZwsCQadaPbQBHKBpuwB3u6hdYGMCUNQKitrXcLKHbqF5doA5bXQkgmyFUtgF5WLkxfaERCszw8z0mgAMYGooFgDEx0HedkiG43Qa+GgO6CR53IM6gaCg80eMyqK67oN/tbZ2ene9o3n/Hidq4QlmjK/c4JpEC2GwxBkm9rFkzglH4jc7wSwAzea7soUUSxHcVIlouzMy69z3aAwzeEcKEGkw5iIXZhhy74l1PQx2ic6ukMLprg55DJbWAljMurtoXCIUdJIIWMYa+/lnvPRFi+SwGtsUiL5VhQSYjjEMN+LWLV4LGWpDEWiZQ6FVLTihnxkWs7eWgP8XIcMYxxNIxbob7DcC2ATepLbHjol2vDXex+dQAZN/MezEAyAGBb99kJp4S5ArEBlOAbaWrU5sOpjB+NDz5Y8ZiQ51/5Ok05Z2K+GVemASC4kwh3NxbMjzPC2GUEWQiPA/Sl+uTrvv9gQHgfrzhsT9wPA4cmJhivm49Mfwf4VrZzCXbUfqLQs8reaY6rK8lv7jU3aqtxgpyjgYfKB7FRpXU4bIh5pt9/ha/IH6XZS+ZUn9tveT64eV6b20CT4bgmTjISuhX8C6St5cwolBzruV5/f1uyBry4jd8d7iyeR6LK3xdNZme0xKocQizUv0t86YL7qy6yYlPnUMrPks8XBc7deX9ILOrZ7Gm6Oi5AnzRKybaesTQvSpN9MqTqq70hQYCwSVEC6HYrfpO0Vsline0rtgaNTWJEcQSI73qWqHDimmGGrVt5ff9gDwOyNjNo/Ej5gp++q5TwzwFUyJp2xVDz1a0lA1mbILhiY8YvrrnZKDNkGX74Esi0jor1lE/vwq7lsI3gHEAMqUU7S0Ng77blWbYw3brjHGI4Lbd8OG24aGSK8NAfnMnNgSgCE9Qi9vqLqYnbkYMnLSKgoCWOrNabZ6Rctl1ZXB51eANrxIBla0GQba5FX292FVD8h9YaI9SW+JyRDyUwyuchZ7wSiSMLLFogql3zZhc5En4AOekU/d+acRVXbIboT5drHMaLFci33ZBkmySp6vp8rbTWun0ms9qtndvlPtIiKFI22U72pjwndkEfuCdwylUIMqznA8UXSMDaWuJnAcOOPbJlrMx5s5aScMl0Va2HY3ZhGCPisVuhxdoiU2mhnO4PeRpiPjGExbnHAuObWwYtxvGsl31ECsDcXryMKtxi7YPJ+c4OM9zyZwQFJoJ9ApApo1D/C5haP0Z6iOrMKY7fScWDZxrhnMdRN9B776bre26JyHMFbEGsofuwo3QjiHInTC+XO9eP/dz38V3v/NtiAj248Bx2Ja2UyvRsSuHJZOKGxbhs3f1GedZphX6zaquLwq4rfTDnl51NlwPCIg1Bj15xFJH8X6O/wZ06bOsQo3BWOWHI8YWbP0llhkrzriPK/4Tnxe4a199UgqCF+OEP23v6FJDbAaibVwbzlBY4n7VD82xyWnLTPUC/t6HMzUlDCcaRaL8RCfVeOOxybfWaAvt+K2mlKvyfmnSNMv0FmpFwHHyehcdXTa34SWhyc79CDFqIT40DzL0l8DgNlnek82rLdLe5ajOz1mmX46YPv2xiurruRX159Sr7SWY4kgc2O+QXfS7+ldvy+iRGtZ98TFaZ0d5NXInKjXvhh72edtu+P73v48/+IM/wO///u9fYeTy+nSPRp6YN6AS2zuaJa8tMMJSEsxvquVn0MibMhCxhkFNpuylPVBN6EsbAHibQNunf1KZlCSew6GdoEQE2xgYIpDNLM8yXCnKnaNanj6ip/Z/uMgqVjI9DP48HuQwNred3wOABhlqFyOJCajZZhbnyS0uHqkaWf6sKOWLuB2DnX4JItcT41umjvojeaTAVSKEta+BT25KqCLCQvQlKucl+6ByqdDiYrHnQueKI9RgnYahEpWrnTap4a7GBD3iKWNkCm7D+zK+jst5wdwkuIN0N2wOtXi4WITvOXB9kRjIXaWN/x5LuRTOfRmJhk9CRkxpZbpiCGpu8CK1KvTxJqu+BFpqGNJta0XFSPUGqPMc0Q2ynFB6wA+zC2SpQA5fDMxgItGuuo1neGigVsgSFMfo4XESQs63vsXhp4hHTpoLo+Hko+6dnUP9YEGpzsH75AnflfTnw+R1iY4afYEZaZqb/Mv13vWX/uJfwJ//8/8B/r+/9a/xgz/8AR5vBx77xKFH7qCSukZerKp8BM+N4Tz5/uzmJ1TfmnkHrJ4bwW8xF6ErcoiyYq5AT++mRNW1zHKlvheyihlpE1jra8UnO7PtsLMyufDtNcyYW1tFJa7aWmEqkVuHLz+Bfp2RpbKdOfwzHKygMatcRYg6fMGOTpWsiFi+G7zSXmmfJKtD/skFHP0t71tPPuoXJRxLCtA+kJFbOEKPG1VRV3eaAPL7VS6hYpUrW5Srpp/2rWYBqfNr3xSnCA5p+O4wvHddVN3u8vLD5pyHQAku9Jma6/VO6Bg1dpH+cOj0XRolEXkcJt/348DYNwwcOB4Hvv2Nb+Hv/Rf/Bf67/+d/h//mv/m/fKRXdX36rlMOWNvLRc3jEDsshGUwrimAjEJZKGN5IG502SW1TTpDjR2kq4YA9W0kHVoRUq5VIUcI+xDumrrFOilFBNs2ILcB2SxPQ2QkEZuyQ+Xh9CnRhyV+0TkgDy7ouQoNvEZMer3LRMyKVzCgVV9rniGxhVJMpGiHt3NNXafx8nijhG7gnt2NEEnlPeZ4l0O8mGq3zzw6FpeML+ovAZeMIukj2lJe/i18g/nIyve47yxTY2CddiW36KV6/F1PKzLdL3sQ+I4vF3xMCX6qr6/HS8FlmIX6paSYGv2VNbJbAH1EnGCj3hSiglo8RqgTY4vpxeHmQ/LCKyD8DmzupWNIBldXHWv3lvtOi1ODMiVDAOcQqGyQ7QZZcq52tb/Aom1bDeDwGqPjg8I7ETiNvhpdTt7bNgwZsUMe0ySNwyAji+WPDZLaHqqQvEmTHtJ5FfxQakvenGueo8Ntfrnev1Rtd5T9MXE8Jg61GGNbYNAiY9W0nmsedGtVF84MTOlbzIyYf/FccG5B1x9a77YCXXwgFvdBI93OH6+c1RzVCd/u4DQnYw62Xkr79R70xUNa+VV18nsr/rUgFr7P1SjQNEn0Ia2pFtKpBluWO1yJTXspno4ahnMMY5edxhuKH6v2lvjfM9K1ffSe92d9sVBmuyYMGTELvfROlYgTfi6MW00e1Hh54kRKZi+Qx1c59bvXn/SV8irakAbrCU+8cHFmGt0t1BJiIkStraC8niyiWOnjPHvWSUm0LaCQs6iUxilyJ5apTXngjrMwDgdyo4YwNtKIqdgJ4Nx5YjKNzAK1NPXECVjT0u75GOL5GpiYnuNoZRb8fcL1GTkaATz3wsNvfGUUOYtCSlCefKs02EQwaTkQxGYgKYjtVU26CGeFhMogADAhOmGKjqQiL65grCcJiwBjE4zwasRONqJeDyyUR53ogng12UiC2yzrYa1M9lDhF4kLLUpo+50kQQE8gPXeMhYcPA76TMhG3V5nXoRZMSRi8A5mOVy/IbTDkHMsOX/+Zd3McIkjJv6IMQuQGGvTvMUyUV39VoHls3bl4Vw8XNwLrzwXzD4U8xlR2BV/DnqIGVE9sW/iFZ2YXzJozdsc2tAwEt6MxvTjCzO8oDjNhPOSa+UJ4QS8mNbdGokcr9rdRGv+BUPNuggfGWfK3KywQ63W9yR1x5gzAVPUN4yxYWw3jK17NKp83cEA9PDvPnYyndfkwsOx5GZCnXDPAQAdacwYw05LdcZA88hnuMR0LO+QHeKnmTOS3YfncsgAdDN+4zxKJfLOSmJnKMaBEx/7cl1fx5w49h3H/cD+sCTw8GQk/6mvT65mP8zr6RBEfUzS8YA+u3guBStgyTbfsbo3eNYWiE9eR7Rrm5Il0wgOBNGKz/XgT8QX1m72FgqQFgpcJc54vO5vJlOLXqM1YaPmCBH2NWBZeCTx2cLB4nEOo02IaVpsML7DCHECT/vvlDf08hUeW10sCv1GC2NqL1JJqXssA+JmS0OBs7YmWLyXEt9WXSSRYvWzMg10+lOeGtzIMq6tCSkYG7IbEEiZQoq3FGi989y0LNNMg4+f5RZLd6u/XpSFmaSU4/rjc7F6t26J/6MlV2scpek0koRUCAs4yni70HaU8WcN7x5WrWo7KNoZT5Z+MP0/FV9khOHmOfO8vD5vobGl/IfADpeKreAA5KIhEzThX/LgNyK/qRbv7OOngCVDepiV3KpdFfUsUHGz8rA99bOIegxzKCakOK2rV9gi40UGtm1guEcjXCCiYjtjRTxEEBILk6iW6mwjRwS+BssE3RsDNeW+lVFS2OJ9SVXU6pAiKAmFLHEhze2bymPOB58ENMkFyEVG0HvJvCDyVXjY7xjnxE3jXh2OUKSDeRCvR7r2KCcl+nnhWW9oBs7jodnhNlfrBafLxjf9DBd+LxiPqHnvhPtQ6DxdHEqVVBDjRtuqsmxoREa/o5/iPbP/a1lQ7IOR4aE/vmjuPLUYYYT+NKtO1CiAzv5+jHWNnTQY6zw9DzfL/lt+Q/p6iYhrwVaMWiAYvpXDBwx8GBs+jBtucs7R2DbJOSlQzM17eUSSm81rse2kMEcc/lkjZ2dewL2rYlvr+hik12ELOtPSXwDzuKAMLuaJmOlF8cBM9w5OzDGgnpNhPDTgdLIYarlwSnz2y0Ljk655f+Dx9Rse+x378cBxt12nLMlxmQinS5bPi0svimSe0fXjq9ef3v/EYb5aCH385eAWpaDk7VaDIuKWfxSyU/rnSv599BqcS3NiXlSZnm43/pQyC8vT64tHf+WZp9eUagv9IEM0S2ipn7zZc1wuWr5YXH4M9SzOrt45B+qW1D9RugL6hKRMV2nQUmPqouPCC/WJV+I65OEgvYXrylsE/RKi2jwDrQGaoDRPY/wE8CgB13mgaXi6jgBclJKUgXJ6nN8p+76P0yL28/5MWLjs6Wph3CuUFrAdemJFMXBIGGFb1XfoE0wZOKbimGpna0zK2/hEY0hcn77QiC1mVe0QK7FEE80JJplT4ZuomIPiEMjhSdpj2m4t6sJXkKE/mNZJDIUcwDbFFjFDzCKl8M3nxYL5QgWUaV6MoRjz8PM6TEmBbpBYoCRON8j4CrfbK7bxYttI5nHqfRIaES7M+aJMTl+mvdC83EfWlDMNlXGpV0lBzMvLcOChrgpaKLKC8BixwgYmqpyIVwS8sB+XN5onvGQHsrJwrljMen9GCMqyqZg2hHWBFAcwW9erB4G6zsxi1kp+KvdokatsZS7LUOXdsMdnZQbL/mXLZ3wnF2bgP5mQg7kSSxdxKeliIRCP8jXijtM7NcTD8nzLVgrmO0EZXTW8a3ppZuZXxDOrLsP9QhhJgQCGzz0QhbtRtJ+eRtDkWKhOKvzKvAm209TLBrwMwYebYHvpPRki2DYxvvRQ25JPUNFbavUOspCo+GZ50PSa1hk8kgxegLQCTY0wKeN/E755gw5fN4702pYl0BAd4yY6MFWgUwC3Cm1iNpShtpnE9HwMa8/b54X+l+vda86Jue845o6pRzsNvHgfFkVA6v7pYk5/WcBLrTx25QvL7avhvGIJl78DXqos2aFetLH0QS7u8bewpqQGRvWsiRHtx1UHLjoqy1hc1dFEyVJHa991AyHDhqIUobxxBuspmojf5Wfy4wCJYGqKYwEeNNd2ODuhIww5Qs+0lxXushI6uneb6esUyiQdjSVHCZnE9w1+ArN3l/iRVRxsvVMT1y/LuKHxy/Lsl7RPSe6C/0xJ0uBqNuXYXe3qWtCbLbdhKvmUfTq5QC4k7CWboBsnYltf4zkdtLTOK8KThP5COmjSb4yUkpeEgQhcO7Zzrvh955s6NcPW1envc6XRJy80wkshrgXaNlebbUErTnh2CEbFs8dL8MNAbINBqFsl1a2Mqa+kEjNxSOzdgpoA0wW9Ahovxt72MOCG12MJ62hb0AKAyMBtfMBtfMC23XAbO/YxMEaFfiXjeMb4hQk8mAoV+dgoeBscL76SwTP2/fw6++UCd+0gmKtTiPyZgmRuTEYn5KxWQKtsjVoRcfV2BdLXhrQacATX+oWFIGphi8Ct4LwlpS6T/7kicPU4RULooO/JSZ7f8Zs8SQI6k0XCQn3R4DvARfkSksxkFqaa4CyMiN1dca3SyBEbjIluBTXnt7bRw9oHriAqXPtI4EcKRIQZ6ayJwAYXjqaEL3TkJthugm3t2yzvgKofbKdiW13vcDcUMCmOMM7JEIUlcEfSmEjyOMGMajyi0xnxoYAeEJkQ3Ax3c0Axsp5xU185KCkhggxphDUqcOEm4of4BRMJ4e2q04nuv1zPrjkfeByvmI+H/cnuLn+lHDG6LkzN76L6ir79hTRmXxQBiD1cVPNuG+8VanyK+Qb6vGxvnvN+uoIoEJ09hIOvS2Xq/YtEa5L405KrboXld4oQrdypxuNOmuQ1IFfPOG+Ny8XYTgduGWehthVYTuTEojNwn67D9C5hPr27XJfjud7oIx2fl94M6v9zCE8j+wS49y57X5wh8iIjn5/IeKHNoBnpt0hzIbhIVzopelGt9L5zEdWyhlLiOoAervwZl7UhSVdZy4KGwo4m0UX0RmzzQ7F+hcfcdZL5xqzf8XXC8qqnC8Z9QjczrB1QN4jp+SDsj1yfvNDYoHZ+BhRmxRs4oLjBLb2+4ICaLJ4C3IZ7lQXuddhsAaDDzJUTuXtLDp7vgx/jr46wkaEENZARSwaYIjHihF5fCB0HIGOxQ4vgtg1sLwPb7YZxGxh3dy3FVreHq1tM2T5OYY3WUQUudLiaxKw7RCFYKAcnhitxtkue5JVXbGUXV8qKbTQYhFh0hwjpCYWvmJ2NhQKIM0py7GgsAu9QElizQoNyMeD96SytoTPHUhxGFbUxoMVhx10lp+dCCN4PsNKPVkG2voJB+EyU+QTWVgg5YU/8TMh3QCvH8Ni1Dk8Ao/uYwlqTsDr6am14ZvGB9xHPNZRnRARg48NLtNuV7lHwAFANS5l2PspWTu5XYsDnT9QDfs/hZq4tNXaAhTGOEfkRxiN0vEC3G0ReMLaXU45GEOZMhqlQmcYvbkbTc5l7E2o5HIQPwHHnZ3hA65w83gjADtQb5gVSQA8LdRKZ5kmB5VoMAMfmxgs1npRnsSgtsKdvkiCCPEA0wvpUki2u54d8ufr1c9/9Dv70r/4KvvfHvovpJ4FPjW0Zw6PBykZXQfjS04+LnK+Yt6SorIrN1ZCdZnNTJLQVPM/8z73kHKe+Ni/RVkHfpdolV72+LpTSlfcK81ahL4lHY4Iry7oak5RH8WtRBnnMWk5kA6oH/YTlPB30Xm9+b4ytA5gWfWVp4TWHdyO7zFgObtsrbEEHxFQv5dvStavQo07x1d4Jt0zIa3tLZRwceyXn23x44jlkGc/4eNaskbIv0LS/tc6hvJXweg36TDcJeb8AtpZLoV/9C+jS/7zKl/Z6m/j1L+N1afKK7NaLsRE2txbOpYQtUjTV0wZy/HnHpqnmGZ7TD/D7fGH06SeDH9OFrZma7bTusNChDh125pax2hFfLABkeLiBjZKwNUmASHiZsIP8hE1E7qEQoFZn/o6dnbE5bGS5Km6R1xjA9iLYvhrYXjZsY1joxawY64DCO1CDofaPKdN0MGDDOxEqgM4tuFRSQXv1eoIRxWYZniYOY1iGo11SUo3ZOd7jRaKruC80HDxBLJTESpuMlYLfKyzr+sWkDMWMfLqZxOvoFsAOSqPhTc4ScCkQe2/X4sx9KjSfoiNdkY+xJLykMBGHKWYj9Y+5oNJYUOvUJK4WB8jQpgKFkZxM3zuvE2VRVAbxiQsZoCS1EiFm4SD4CbTiySF4iCg6t43O1331+qXKh9W/uqlevLw1kXOUNYvAUuzDg+k7wY2BIRs2uUFgi4zb7QW3bTUcEGyCXIgC6nlc4t0n2lTP2eDdscwd0nCqUOgU6CbGiyLeGja3rJ8TKs4Tp9fjoSfDc86C7jLTisgx54GKeV0E0DjzQ50GVL4co/GR6xd/4efxd/7G/xL/w7/+1/i9f/u7OFwoZmzxnEvSbh+LurNeNKc4NtxlwcqaWd2oa+EPF8/46+VQB99g5h1gnSY1VyQFHNVlbJGgbd7ZkCN8J75+DiH2sqF8Nb5GT2MTFmIwvSryVLBO1B3sNcgZbgsej6qjB+WSqA5+IQt9JA9d+K0yl5SUhDEW1Y2SfXVHcKqkKRxUOLanC/QxOTa6iD7N6hdfUtEBRZLRp0VJpneAdUSr/fNguVwjeRlGvGZ9JbB5/lxNkbgvopk7yrw/JljJADKAMi3H3M2uxXsXdM4WTb9qcU5yjkPs13GrN9cuFYyo8SwyIMqRKt/oKd8I2atF26Q/m6xGWsxEJA1epSeg/nK3xdi1b2LuE3PMDEf9nOuTFxo7uQxFgE3EkhRnxH/5VBYKpGGdRWDEMW0i5jaUaaV24e11dBTW7ymK3OHSBbMIsEVMdaA/rU39ErGTwce2+d+wv0MwppRldLnO/G8lpmW2EPynKnV5B52h9TL0flJiILQXzem9LGAYpJMcYkiY10kHs+IvAwnWxvRKQw6koGiMjPoYDWV8ZjEwny7V7hOZFu5Bjk0UQjRbczpVtNpzbIKBBazN88MIzvLBaYLWO8O0vhaz7f3QZOYJWb6uT/ucOARynhRDrZ6vK0UN3AStxHdtL7ZbCIEvRUot1S/dLqj6mY8z+ZHMDGHYvD2D5n3A4x6NIXamxBgD223D7bZZ4ndDZ0nLpE9vKzfiCyAFll82C+hcmC8heBaWIZ7yEsFeC0sRQIdCh+0kJYAxb/eIyGHe3vA2BcOfkNq33BE93cM5vY54rjQOX67n11TF45h4zAMPPHAcO/Z5eE6gVg5gjOtn1V5z6iRfn7CJ9dXThPgRmj/fvCKKxu0/oari6uBvwaOY8CKmca3+aZdOGYLFaGLixaKgms2cBeJ454vFLTOvsA+G8vhOHaUPaptrnRl+5GIUxy4sKqjkxuBCDNd7wp5gFnrlnTfOb6+cauWZ9KmofIZcZLRg6Xdk0km0tWr5uYQAGIpi/k/AppeDf6czPdh96owhWDTp5TIEmiuM+8+m0KXcfufS/Oeq0Vas0/TFuJyUufW5I2AsMPKYspylmH7DozOxiUw54PDr+DZdxx5upJnzwHEcGMeGeUz86p/6Ffz8f/7H8H/7p/8E/+bf/JtrvND16R4NrVWMxTELhk4TitPG2rL0rWMjvANjFnVMCx/QwRboUNoA6ICMcBlq0njS3wTkJqSYATIsCTN2rNItKdHeH30aWvLoDdvYsHkI1biHUuNx0yK1Yl6Udk2YAwL7LGuyw5fxSlzuigC15ksrwwyYJogruCcYTMtJRasTbEhIrVlLgq+EASmYiHWutGYAX1gK0HZE4BU9gcrgVTEhvGgm3hoZuPLX4n00n61Qc7hYeInqhPUmBViyoNdWd5RgyPZVydogiRfKqljak8JHokUIVc+icmmcuNogEJEFwxGrWcyVF1wNpOH/NKbIs6ualKyIJJ0S/lae6rTXmHfMwWzOcBhnkEjQsfgc9ZBHCCy8TOqE8O0muN02vLwIbrcr5tz7E4tdDe8jku36YjhoeDi+3MzjjFfDYgb1sdI2n3nRoKLQMdIqloTinjnrZnhVxHfsIPDDqOJNqPNOmwPFAC90jS8XXapmDDvUD+fzszNm5LqEQpv0X4uNE3e+QDZPRT29cFEunmv/eTW1T1UtrO8Mm5zbFiZR5pPcWudWAC4NT0LAXapPTaaheGXra7XVwmpIPDeFkOCoxQYVbIzPdYPldksAX/AjHQUheaweYdPUAhPhTnhgkr/p5ViY0t756tWwXc9rBYvWhqvgP/yuUlEfmwxLvhY09hpPgHfKReEQ3cjioTMsFSiy7/1JUMP5bv/S8fKM92U960os+1W8/+r5GTeF5D5v3tnj7TRBeEJ1uAx/S11K9YQcd0NfjjM1xOauihJYASmxzLAKbI4YvWub+1Ym/oulRySET8w5KjF8Kr77ne/gT/7CL+D/9Zu/eYGZ8/XJCw0BMGCBzUOAMSyc4ORuBMCnSRvuNUNjQscVhPtLavKI5y2IbekosxImZQJ4ANgAje0sAUA2yCEYxwEdM+vZJrCJ4liCm2UMTwLfcNuGW0kHtiHYELCYMhmBEk4DOU14YM0FyTNkSe7KWNFk4wA07RwV6tTpMtxzCTcp49R8Y/7JWPJPscbV61BT7DyELd4fBFe5NtEZXtOlSNEWH3lmrsSRxCdKxudK4CmQQH/K7nOiKQSaJQURobOPQbu8Him2z0mO0oQGIG6Z9paMETTGLj4WsVheJ/gycDHIfEOKdVVpIbwzM/G5glpg59hzrD+7SXN8kPk2V1hhuqTAKZLnQZxaT8XnImVsh4Mt+KxodtPndK/Y6NS8Fnn4plewQe0QUAFkCG4fgJcx8OE28NVXA7eXq94YnYsI5LA/FTNyiB4UPme7PmE7IIgTuBnLoXy4R0NgXGBS0pxb//LcIrH9xmNHvCBFAYDN42TVFxoDBl/zRJGHy3M7ANt+V8TRLPgSOvWRa6rivu943HfsbxOPObGrwjci9HUyB9AZPV9nUlxdwY8kp2rcvdTTirE+15R+pCsm0XOCWHTq07P1eeZ1xY9N6uF7Gt9TEN4h1savep1xXlhM15y2z9p/Vr/At6fX3uEnIIYKV6GpsYOPdpn7UTiCT7InY6WwZ9y4Si3itkrJKos+As6zy+tRpk36FIe6LSBlpfPQ9fREi1FVOJc4AIVU3gImlKuxvIiKFgN/xtcnE6/OtqixrUn7KYxUCbyPYzfUB5an156rDuepjuVuYqmhy/Gd4Sf+UIo/jVZTH7Ec2wIYQbcCp1q1oycgwIRvbYuJ45gYw7YLn3PDnIu37p3r0xcaQzBkM/Gsgtoznjq0xsJnnPnNCdeUcjoXqwghFXT7K8un1n65G4AXQA+TvLZrlQl6uRmSY1EwAGxDcV8VwSEWhrHd8CIf8CJveMENuxw4tglMO2wrFLUi1DMR1KNR6C5t1n/32RHKtYL0OH5vaSEgyQVd0q8mUx1OcKYiL9ubcvlQqCYp82FVDmG8mLgqrhK+CJSqDvGeVBspyYv4T1b26CEtTLJLDpclyEY32fqoWTiEgmuuhdzAew6Bhq+K5n9wVKHuFozpGbq6JO3jKA0bhX25EuhyxtOJiXEfqtfRvUl4iDpENU+QrtYkcSk+2SJ+M2Bhb2KFxVXV8SWZZ03NJlhiwTVcSCPdsaWMGZkRfFIHSg6aA8MTwjfnMdgsxPHDVzd8dfsKH/CCm/bd1Yxmqc9DAZnevgLqieFDcYjzkAhzyv5phkxqeK84CBxSA+uSj62Bsg9P6kZarCLXRiY8IRnAJg2fcQijiGIcztdUsaviGMDmoWNbYvTL9exSVRz7tH3fw/KWC4tQAKNwfPD8ew+/UnRAX4FaIBYTWFSGS23x3KQsRUsCPbmavnbNqFh2FeBcQLIf7Xby7+Jda60Jt2gagK7CeU/XO4pbzNlcZHCLp+F7Z4m4om2pTHkMid9W7a1llGXr+XgUruVi44GLAW9vBv/S58Ww9LuIMLux2BRTviXkl/U+w+IZv02NCCAaPZ+9hKcKJGpeKd4KrGFPskASi8ET+FILxBZ253NzbZO9YYnKEz3oU53CHmUrbRjP/jFGfL1TVS31NxywB9zfkqv64xlIPruUI5qwA2KlgxT9EY7MofbDcqjh4dBmtPmU69PP0YBg2qb67s0wma0K7CLwkyvcyqrJd2T4LlOiUBw2CCnIadRELRRrv2FuA3Y+RrSsOeZ62F758MWOHBPH5vkgdFJgbsG1bMMlEGxj4LbdsH14we3DC7avbtj2Hds+LPFzSk92IcbLI/TJ1rALefau2kAoirNJLl+KyYF0lLYHeafNfkHfU7k/b+ujoF9eNNA0z8li0paYnStrC3O+djosM4v5rdNQLJwrbM0LTLgiXfRxWX1+iOu4zCIuJt1VBdCG4YYsui6Zc3yL8lMQZpvUm5lnXPDg5gEJXjOuKXAVKhk1BwY5uSKx52jreS/6NfAUf8nc2MYynPY6Jg01AtthYljo1A0QGdjGDTf5gPHyFeSrF8jLso0z0bqBpPZ3TIxknNLwV8rGpD5zlau0U7PyxoGOgFVwCGQUDiS9ZnGSODCPgAm1o9puqDsOxdgmhseIaQhhPbDJBgv1GsbC1s22vlztmofi/rbjcRzY9cDhSeA6ijF0wdiDENp1pQNFmff1zbreEw0LP2+botC3y6beqfcS7I++J9dFtLe98pSnOAjB9e6l7SPmb5MnXHSFXTuOLuH5yHtXiO3DovWvy7FPG/ZSyhKIT3lxgfPpa0/GMfC2Os9TJSU2/TyP9zP0mZYD87yWLm704mYK9rb/zgrzp4DUQGN52hT/JvnPcywnUdV41qHO7XKd/QnJnScwt3uEopVf9Vb4s7S9CO1G5PvhLM5OhEKAiyrVYhCIaB30dExMPXDoxK6fnhT+yQsNhULGxFSBDFfyp0IHsAtwG+ZZSG+Fy2dRhR7TVkV5Aq7tPpUKkOtgMgSbKiDWkZiwqjCroHtAJigB3RVT2zG3hIHC9qZfmZ6IYBsbxm3D7eWG2+1m4VMvA+MYEB0QD3kADXrWG8mb/qRCb9ALy/Ku/2AL/krA6g9swVlhScyYVcW2EqZmQiHPtwZ6G9k2TTOKwe9JxaV0rkx5hdlHIMvX9tTydEIqTOmybkW5wok6PLHoHm6Rmd5wJi4RA+GlT/aROy/xU+sHl4MQ/lCTcIR1asVlIjzbC3YypX43HgeiKeIRpgezFFgwJo5dBRAWcIdXQ58dxD8anEVT0Ux2OWnKJ2qGCQgB7hiZVF+G43lbbulnfySPfbhox+hwhetXPXTKDsMzvOoQQDbI2LAhjAEvGNsNgsWjQe0K4iA924nOnBseRiWwRHDH14ywCkeaALY+mJUUWmGeA9gB8QUCNme+W9Gv+NyuXA2jxeNW5CJAzt1DFceGPH12iMPlBxAVvU7fuKrzsS9XvyYUDz2wHxPHzifYsmLVuFreOfFvXUpo3Y7yl8PB8dc8z5lZM/vKstrm6ZVI6Xk9xL6prpPSRPf7lwWeYoQJ9liKMUtPXiMFl8a/nKvHQDODUvT8ijBMkj4AaOoH3CfuS8oUWZ5qf6HhtrraywZckecYuAjeGfOcAFK9qMfvX6kE8StqD9vlSkuXY3gm3Va2o0BOY8qOh0By0j4Tjqw3moi2ItRoA0l782s/cnawMKLON/nERduXgLEad9GYdMv9zdRC7kv+0IbAxJbUKHVZtvRnoQOeF+2NREZ5bC5pMXGgYPGkVJCwdeIv6xYX9lhQ8loTKUpjkP3WCYwNmZOorLOUB2Oqbdt+zAWf71yf7tGYfmSHCEQ3Y+QzuPjC4gYgGwBfHECHqSLuhrGUDXEkBouSogpPMg9CARR2QJ8QYdbo5tRVVyyCDseAzH5in4iFTm0vm4VQjc0WG9uG27bh2IZl2vuBgBnc0yY6TdnKDI0GWnttTl0JOS7HT06Zcny/ZkcSkwLiZ5BItNmai/ArbQ9PMbCOT1VqKgXkBbeTwhGRcypeUXERc71YeKV6ZaJ8MUJ4V3DbwYwiByFipznMinpunymxoy3xp5LlaP1F/Vii+WmhwfWvC4YcwoyFDcZWiO0ZFMGFak7lIgO+yGAzD5GJgEmDvROEZ8eRtnGw9mKpUExeacxjfsV8T2QWwbUJoqZAqyTjLKTUCMXcjrwYO0ZC8jyNITZPXz7ccHu5YbzcILe+0AhjRuQ2iM5y9SLC1XxhprOUF1o8Rf9zf2i4QURgHrNpfMngMwOIxTgrsBs+K64bNT5QbEssnWww65BOSIa4ii1yBqA60iOsKHw/2z7gy2WXQrGrxREfsxYYpfSRxuHz6LmQZM2E8N5JvDPwjJnWGtOra6mjc3kf6wWw5PGoqi+n3Ql2ND51lj81h3uS7wXMp/qon00kB2JWBDH/lqVUcqmL6JHeH11qCl7WlXWtD4c5Qmx5HjXL99r5k7ea4WCdgCUDysKbr/d6ijVQaLbmraXMAoJc3y/bENO0tBeUbyuSyIS15carz83z1fNQA37SU9ZvjRxCpnXcZfs0j6JfAWLJ5gVpQT9AeZZJ5lVntH0E3BcQn34/HQ7p5a7ePc/Ti/KyzNBG19f1t9yqiysCzI39lWIjRBDNSJgyOnBPTJTmnwUL6RkpT65Pz9FQYO4K3QRT7JRASKVPWLiMWw6D8rdQcjTrUIht0St1v5KwgnEcCLNNEkyd/FcwgWjJZHePZ1NgLFmUMsQWGVv/u91u2LaHxUVLnIqaIqoxN6oNoWJLJDksfHdV5BtN6qLY5YdeWzmEiCEma37UAitOJUg5glKU0ZSwU3eq9qXTyv8KkjFlLjzxK1pZgZfwMYxTfaEp3BjhwPuT3hW5nkfMSuvOklcQfL/JPvrhpo9c+QuVh21YQOmBJhSXyc+yJtsmURpNBg4bfRB8nbK9zVnCI3IslGvxe6nnxPMUPud6DeYFofwzFghkdmS9POVAyoegMIdbfIE0itGll4DQTq/4AsPCMoeILT7Ghu3lBR9eXnB7ecF2uyHyO7JHWn3PtY+bIcMJXIYIZ+Qz4KB5ESuQrcCKHBLDp2AMzZ0gJ8yTa3xP0bTD6JOal9XG2WGaYp5dmBfHuLZZiDQtROLjWgzjNF5frnbpoThedxz7YWdmPCZ01yZUkz78nZwNjTcs13LvmWW5aYz83lWdF0m4Hx3dpb6i2yflWWDJOyBT2didtRV4hhtGIpJMfRrQZFeW7M+QfFGnnm/XDS18r0KA8ep/McatngX+Vg/V1/hyyOb8sTD+btN8/0pcna+PYOnTKj8RLnr/GDd8m2V23q0qTj+SRVUDKxqDl14/JTjm9eMVlIs10QVg9TVVEFY5YgvyHw/RDVTDeu9Xw7vSG++1ezEu1z+oXnGNIeaFSnYyc0MFZWBT1JkaA4lUmbZr03R3pailIRyiGFMhh4UD68Hy6uPXZ+Vo4LCQpxnSd0PGdJlVxHujAhwmnKfyqssSuG3AKcwAtBJnzYEVBueCmlslhMIkpWQg2IAmktbtWv5H9v51yZYcWQ8DP3cgInNXdfc5lESK1JiNjUaPMzZmenDNmIzSC1CmkXgz6vSpy85cEYDPD7/AgYiVmUWef72jKvdaKwIBOACHX+AXEBG4qDWjsFk1tg21Hqil4GQ9LEz9yVMgzjqigbEmxBjyxA6uSCr4fEgHrbwPpJo2+ykhcooZoahrEBjfqRhENgngwUBspU0cZ/QpZ29QYSeVI8wr+G6QAjB95ilLw74RO95WB6mmGL1IcFH0b7nEBbfhlDYRD57J27xD4P3Mc7eAj2kIAHAIqUEwfAidsfqacJh7mhoaCQumhsTHwIgEMtenae4DJUjnOXcpBFXvaxTUnswhXINlrlab+JdHELpAULLJJ952nKLAJ6V3kZ4Bg6JRaoSgorv+kSsa9keWtGHfN9RtB6OC+qJojGG1zYECskPyok9d50ThEjCbFcXxXLSs0mYxEmRnXTTduRFSVGLb7Ohd65WUj9w5l3ZNY73Y3dtEk2e7TjJOYfWxoTFhZk2FowEAWVzGflzj+pf/6r/F3/3l71TB6B4IjswmxpoZi8SmawiOecNkCAhXVnpH7u6o/bLZ/anwONGZJxycbr5nVnOBQxK9vSiric+md8gFFRsEP9xtpY/R1iLESnpINGhzcCS6KfjkuoH4esNAndLb3hSb4HpaLtm3bwrJ+j3mdpm02zmkhGP3PNN5Qx7SL1+Xemer3YghdoxPq4KG7CTpfQf4xtMpmpylOAoentgjYsNnmnuHdNoKveJw2uk3aCavpwHLVUgbKG/0n8Z7EyeT25m49nSw0gXI6yXLj6m2C6jBNCce7p7KwxhBA4abekO28HmmEaIwKCBh5vfz+EddtqamT8wB4Z8s37i+btEghrDYid0YGiE8IYsKDV1I88CLxkg4P9XjLNgEJnVx0N5MLGAMFyuSkGVz6bDTccWQNm0HZGtlUQnAZoiTEBA90cw2rmyUDYU3PVujFrDFanCxA/xoiLDAmK+JjkiGXGKOZcLIVEGa0yGAzkUnHuXELMtsNvAh7/L8YmSPMiTzfP2xuGTszGcCHJ5Vi1yTmVowDPG2Ffix0zDmc1o09q8vnnGqtMFPlE43G+9EPWkHOupNQt5geM+oIWW+Oj3/cGeDnBCn3WmMd8bCNshC+QSyVc5NtAmc2CFXRqljQh58KNYIzX13N56YiRsUG/ycLs8UBgmiBW/XRiisebFxsNRFmPYDBiKMPpRJiCA76Tsjb7I3mAJC7jJVCKUQNmZsLzvKy47COwptYJoXtFtRNR2sBnGxD2heZwCkQJMrQODHcYiR2U6itKu5DcbpzVj93ZTAKbSIJCYxe88obqakEqa4KL6SJasYi5hAmnrayBeTgCzYX5j/2G7p39j1//4f/1/4/dff8e//z/9op4F3CHUIuuW2BbL5H8B8L3N9wTzWH9GF/NJ/ocXp8jbd3fykjsxbFhnpbvc8hBe3lPqmoDMwUHIr+WQgBgmIurOVdeai/sJy3ch1T0qmDsg0X7ls5m956p/1ZJHPJkF0vL8OcGIenAnDkwY+7NAMx3/5lWoKIjZ+3rly53EK3pwL+G1nHZRQ39YSPZsEuvYrxjzR46s8OAMpfcBKT0ZrXdZRnyy4GczZCplcK15L5p+UNzEHct9zWNw9TGWW75epmoX/p+Rgmd5cbfbikGwtSs/WuY3X7b0ugmbn3/W9oQujS9O/1p5Bdbm+btEoBdIYrQqoELgQUCn2IwENyHMUKaQEoLHPHQ3hhAYiiZ3S677Uqg1X1RX62K1X/ksjHWbasc/EoZhPtXRAKq4CM2l+rIKCyuqOUYoFhW8byrmBSkchC0pthA5GT737lGL5ta6BG4EwYF/LXOqeFyygLlJESdvIdSc58UKwnTisjInSuxHsMcPtQpgrc5kQ33Vu5R3AWORTV30XxM1xC6H/+CLMScFzawbMs4o+2ShW/MvxJIqL+WDOIXSmm0G1R26jqc8LkZr9cwcVuKdTdKGksjzyrs3vK2Di4jV5u/qF1qLrV8cZSxPPtvgl7ZqQTWIk07I2fINh1KaJF5jVsiAFlnoWYGKNnXqpKLyhsq7PwmwHgeah6OjFFDhLa+tn9jjwCgNZ5qiOAkYVAaihAZoLTyyQXzgOr+h5YMnOvjHk7USQU59r8LlNh1k6UHyDBGphgQDEINstoeb7SBQbN8S69vhklCLq+kOCXj7A3x8XqAFyAu3R0bpS6jioj9yKl65JGByfsT7vxjo9GOtYludPrkx/L9LP3S73XF9+dI8GiQrfyDAzzAOGQY+NqtuG0QrKXUujDUIWJgWDloEW3rbAFLcWYS+E3RiYdZwX7uG7wYuEPN6ixAJSLNXTnpEDlWJhbgYkYEmM82md99dEwQPGj96jy5DMdcnc70tBibbiZ94YS/Mwz1u+qWWGkiG3/H7wGutVnp8MwpOxHV4YqTtIbuqpz/p83CMk+BaEVpfUWdAaUaTrs8SzbKwyqx/Nj/HJctb0ZcKPNEvJM0Rbyx4+n+DCJ3fCncoHZCmk2GD8n/z7WH+BU2RWjN7jD13w3/8//nv883/+zz+AUa8vKxqlVjALNqMrpQClakpb92sOmkNd5b6m7jIkw/XDNuzA6kiQ3BdswUqxro+FLgRTPADmrsqExX8IiaaLtEHSTcIsGM4LjRmoG2MrFWXbUF8rtrPgPAvqWbCVgp0YD99hT7uvIQRjnq+phcDLZSdIlpeeEJO0mZ/aSZTbcYUsUw+5sgHzA58XnRKvG6pEydib2otYBUmBygtdn77k+QkBWdKCy0TeXmN3oRpE0QlW7kKcs5KYBFKdM0DWtoiZzxwwu5ecbQO3BKrM+kq093KgVH5Hu2U7/wJzs6E00zZTOZL+goMyBn3hGbO+mNoOomo3XLfEIIzhkoOx6zKb87XycZiPBG7E2iMfm0Fco81uhzoWI4zhmpRN4t7vrs9s/bgLgv4WXYRcECdzs2WlInXNqoWxvRS8vm54+WnDtm9gqgDKhSlRh2aTMj9TpQkpmM2ZUufAgS4dqmJ0Ux4K2Fy39PyO0We1+ohaG6SrO5WQZuFl88ys0IANM6SGzmvWUOE+xkF8vATVdpmC2tkY8waz9mnwOrXM/H5c69UeDf3o6Mc4XCrM+3c8Pi6nUIrzzuSRaNAkdA15YCbRsvxGeme89iS+QyYooh2rc92QWECf+5FkovycsAhtSeAbdNVpd6qA5hrueukCSZRLRUTy/nSqJp6n23djKM57c1upAxOtNAJ4N88il7rzfOYGtJcSOEAOxk0XaOJDGcilrRsFZPaSkHnorV5lE2tfRzs0/7z5nGWQaY+GzHq6YEfs9OepzPDnMbvIBKPuMbc5OQyS8Dq/OMsBCxpPKGmrNPM/72laKwKl01d5KuH6BEeSJ+MVGS6uyJ3wkb1OdsS4JMCzhDJmJq/6GRL9XMbGx2Vq1uqiUX5BocnbYjLOTDxer97HmWyxUe2yjCUwgXQN0ujq5v4//D//B9TtczXi64oGAVRtF51ViOBYrWTMncyfywa8m4JhPVYhktBIGT9xGog4h9s7N4ZyIK0ebBUaqc2ATi5H+64ZigC8uBwQMcq2odQDtRbdLS0VtW6oRf+2eqIdRQXJTskP/rro56lKS2jZ5bm8twi/YdpyXCZaXxmVGGLlUNcRcjdQVXxBxgK9wjHdpoHIPldkczGtt/R6BAnHSaxjRNSKlXxdQ/g2BmI7aRdaHcRhZjSeOzZvogVUfOU1gXt5ETrxccE398lxkfJ4QhkVmeuLt2VjPuibnzVti19uxmthDlkX0Z1Nw2XO7y0wesdcMMpULFMkhyXLANZWPmyHZEkYa+PrOwJx7ogLyjzgSsOxbLxEDigfpaF0sH16DWR0gAvYUtpyqdjKhr1u2MqOWgpK8QGbsSWn1IYQmhA6dTB1VR7GjIz+MNC6I5lYPYng9JyMQfyWltHOKMzNaFOzP4haZYpAmtqTuvU9EmSQAG2MmUBThktHKDA5OA8CPU38Lj7pxwUAaK2h9RMnNzR0dUsjPV09Y8wz4UCvNL7PiqRSHxS5XhmIJW9sbKoMvh/t/KEZ/xAgefI9tZU7tnxfQBsvrfJnBjriAPILi6DkvCZV92Gf1+Uv6eYf8Be/tLEKbhN4txx4lBwCDpIzfKr7DihJdSe480A8A9i/rwZ8zNVcgXa+LKOaZ4Mtnzy/qx4AXebGZRAXa+UDGD+d/T98RY3PEDjjqMmo8SwLA8/gyp24lalGr68xEE7c6X7OvYZlTMP7+Kbdeyh9gQ2MW5YoPOENk5+9oa5SmrjEccYsxIKIg+uws4raPez5+nqMBiw3fd5Fh8DMDKMDLmjaPLED7gKMAB44rrjoIqkSCxVofYL0JQ8o4+w/Z0JZ9xmyOvUnp8FZ+kGMQhWFK7bC2KngLBVH3ca5GqWAC4POkYGKINPhajFtrvFNpkX94ks7/s0zvK7kJOdM8E7EJyG+Czxz52LXdJ67tI7oAmZq1CcpCWFjYlN5SfDIWKAU+xf6bx+73aO7vutvZOcmsnJeDIT0auwm+qimY2kwFcTAuwE3jfYN3tzoNJoeAGmtUH4lDY8DleHzRTl2Gdw9Qkb78c9oc+z6ZEoiAZs4pTF+NiwgqqTEDsTEIiljYGrHIJSAMLOgIIDDBS8GI8WoJBw37c97Pbpgg7I891HVc+zITgXXdVlLRakVlTds+459ZxQ7g+fW0zscSk3x9h2GPFlGQzSNbExUjA8RNPWsEdLAeXMPZBnzKGm+dW4E7sFI3GOeAr+nUxlFNxVAeoq5+8JP3MOh8nXGWFb6jytdIl3TrTvVT+Rp+o1YOsuVxvYjYZWW75nky02ZCcibZ3JfYNAHSU/Ts1tQbZVn3LwFItPZZ1iVmc5aYuVZvns9MZJUldWRgcp88Kb4c536Isku9TybhDt1ARiblZiEsVHl+L26ygwKO4TJC2yyfN6BNjfz5CEwz9uzygwK/+cOEdIG6NRu+sys54Om7vsyCTrzy8kRBwMnLi+naZwL0F3Z3J9wdxucb+WCE9ogvRu0FmPcxN/KfO6me5frIsXdzNmQk+Ju+jFgF3MBu678LEfQOh6AxldJHgUEz5J4y2lCktzSrsMso40xkPH0wpPvrq8rGl3JeC+uaAw+rpYJmuIvXLBQFmrCkv2xCx1Wlq3M2GkdQpArGdEdP7RPJNywSgSzrQt6tDFuEwoqChdUZuxccJSKrVacdcNRTNApBUwd3bUbF5rTQOuwuwA4mn1GS6YopEBYfzFp+3YrfOxloFacrGxbor67P+H/PVXVf2mQx7gf620mlrG4ps+pyFg2wUvI5bMYjWlMJAu+Y2bZNFHCNWwiWk7uXpFFaAxfuOfJqH5e4LnjSQORNH4rbQ6dMMcErbQ7w0njPSAxc8r9tlHxsfBJpvF1JWj5Z1ibcles0xHfOrqH9HUCbliOBBAnSgabTUSEF2SanMcqXTI9t7oEsamgcNFEC7QZQiFGZTYlY1Oro6W1fdkYtWiA9Nqob0x4TBGDhrk7KYsxFmb9FScmkAgo9xkeliCJ9epxZt2VrGztga0rN7t3W0suNbnrqK9x0Qq7BZI73fKg9AIZ8SFGV4fZ5sd1vU6InJDW0e0cFbfyZ7oV+JkQYnLk+IBf5g2OqY6M9M8uW0t0U3RiBf85ly/ElNr9rr4P658J9AyVr59PAVwFEq/Lv9LndaRl9xGcMhV0eioT5Jf3lptyeZZctAS2C2/U0JZy5vGjFkIQ3cmiMT6fze8kZtL0YIY3t33ha8t1wccZcFofXYH6HJ/zFVnxMNNaqyyJwMH/nsE+8T6/8QnO3IP7B1bU8jJd7l0mfar5bj1/9PvuHSDJGamMGG8yUWFKRvgEtPE+jU9dv6OBITP6Zlza/rNnk5xqbqiwA7o7if5BN/q/kqfk6yeDt2aEgEDSQEV32VhYmS5JWC+UIWO4WxizdAGIKbsj5JGlYPoduinJxqBZOoQ0BkMPC9G97AZFZz1RvE+jLpMLhF4EPRm8bIytFmxbwX4yjsI4uKKWHXU7UI4NvOmOuSWmBJq7ZomNhdfvK+KTFeqCA9FNSRpY5JzMzbIhtarER0wA8xBcZSBT5n8hmE+Spgl6gpv1NIThseBSwVyZwZl9IF2PGtWlFqa2x97GaFd9RlnM751kbEjHqvGqZDD7lDI1NTHjgY9twE7xcSEUYWJewZfB6ASg3EAyFflOWMQoSKqTEAqCx3a4aq1VWwOTWZyRdyTCfzjcq2jgS6LSE/yLZhQ8kUbp8ZYPuQ1kHCo3BlUw3K2IkgLukJI2MCUUgOEuKcwRE8GamKEUywS3WezU/oKyb9j3il1YlYyCaV4BHQcJgd82QYQhUoLKUmihEmMioLDMuE+YnGJHczu8g4YRBE16vKd02HDW1p0aZzUFeOaa5MfF++ZAwcAPo4US2fUEQFfLsXDgg9BXyPnf5iVihyiatK2xGcPUr4UQeDzLcBRkaA0+zeWmDYxVokqkX5bb8ZnI++11xz4yfUp8P1ccipKTSBl0bWr/D1wTffvk5Ynf+Bdb/0utQQ8oijk9kal4pkVLFYPvOK3ycTd2OQts10kZ6DA/U5CtAQeQry/r2NJN1dnamt9xzMKAN/FMWorHz1VuSTw477dMry5oiehOxgaJtSAB38wzVyeD7O52YSmTzDKLCvmXpKKYyiz3nuHbDTrMDHwFwjer5RY+IPP3wfdymbzUBRIbY1H2ZvJW8PM45HnNFsphuxgN53GYQ6BmxTXqT4r8Ii6NcoJZHvb5tfsuMwyLvDfOqdIOsb+OHkrHZ9eXFY12NlDF5CPGXMDkKWu7xYG6H1cF7UZMyuyWoRt5kgZUFQhdk7ojWQBQ6QhxzFyl9N08kibmdADoUV+MXFkQgQllYxQpKG8MrgSuHFmn6tZQzgN1f2B7NKAow28CNLcGJCl9wrXJAXUgVl4L4aqyCkz+6TKRvSgEEIumDI4GtX+BvhHANJbKqF8nSzIQsRAdxoVyTVaH8Rnj7vUlDupdn+oTJ965zwMT8kKOHTmxnWvQPKw374Sbjn3vthAT6YzyAoB4dHPMX+p4mr4lnmu6Ys0tBCDDFcNsfo9eFUV/3IUM/oYFrw1ml/sWLjywAy+R4AufxPFe6uKAO1nUhDxGhWyOesA0XKpsIz3tWlHCXWJzVUrjwoa0bOMNNvwFxeGebAow2Zk1KKwujYU1GUPdsPOO17Kjlk0zU2GM52U+0CGBnQT4SeMCtSKw/qAWPNbG1F2ttPtyAig9T5KOVQOEAZKOKhTvKrI6Igik23kgzGDb6+mA0SAaxDvgJnUv7KoA9aq6lIigJasxSXLb/HFdrt7NksEm7IUZblCxy1qwf1dmfL2fVlMunFOqTlHYaxvjka73eXXev7m2bTCJ0xClE7MsP6yjXqd/Dko4j4LScKMBSXSJDYIPIPOnq8vf/GzAHjunyX01PAHExxCLJJT5x6gwDAfTlNjqp/SO3NSRqpdEe522OdPNQcHBc4guY5556dRoamzEYgzvDuTxjjczouTqci9nf/88zoNGYr4o1S7a8akbgvGMrrg/eP3ArHm8Bqi0vOtPhjsjXZ5eYE3jI7n/mWcPP+MY5WWbdYYtGhwtL87CEwj38Vxz+ad98M3EqcDamsk4zucpOmvrO/GqZYKzHOXlLyAghic2PDOjFl+HQrFBLAaHz7Bvroy4Z9+8afbnysbnm2BfVjQ6wSwXmkJWrRm2g+hna4Ag5gjVNwIX24+VEKVsYNT6UQrQWQUxEVEp5ASoaX1s524Ai7QDgMQyXqX4gNh99RkughHBqxcToRZCtSS3XHUHtZwd9eiopaFuFVur2F4qRKofZQ3dM2tKcIqk2fQJjC7eMrdJeky3pnUUdHuwCQJrVh6YxYe1b2IIo0htc3HTar5WcAPQp4JMrO70tpEYScN9xzETHfImKHU4eIvkmp2QOgO8IQaJHmdm7tEazzzaJ1j9coNIv2kj/IWujGq0m9y5btrzJevN0PRUVzjlOZ8Y7fjeCXGS9JjllSU8v2T5RIIoC+lmFxj1Bm4q7k1E1jV/65jnA/Ch07iFsF+oi5SQ4jL7jr79lQLmDdu2Y992vGw79hfNCsfMI5Pcgt8aXF4hoofoEUSzWGXmaXRBGsxlKfIKRPOR4Yw9UEOtFRAAByC7Wm89a5e7bY7BYLMCCZg7qNvpqj5Ot4xGjBEwUHRcpAPSSDc1pOu4Mf1QND64RATS9DRw+DlKavZO3Hp+J6/ZjynmkzZjNhN9vKvos4X5cSNzVU4nKLk6XEnT500LbNPB6gjhz+nBeJvzNu7H4M3P0jtZTrpAKKO1D+chH7t1V/aOAH8Ak7b5pMWML7kfEbCWhM2LwpeAYWi2O6/Q5b0LD7nrUK5rfZ4xNwGYSEuuW4XHKx+9bfbJOA4xXgvci7YI7r1WQ8tnlsKjbC4kNCsZMQ4zH8rXvb7/OWJoCVmA8I2468R8WKPMb4wxc749xm+Kf0gvCeVRHKMdrFYGLuU5j1wpYYlbxsmRL8IavG0anRJJ9wzfWT2UpMM2OBqkN+BsepL4bcKD+fqyonHCMrxYh9h72UkfVhMemCFgM/V3daECoSCiNeIQvA4VDrpr2L7byjpanciCzzksFnaaBly6IR9h0vrD84E9iOaGwzCDSgHvFbVtKPVE2U7Ul4J6FGy9oj4KtsLohdGaSi5UCNwYPRy2nOEMl4xxyfKV4DuaYu5Q63KJTVQT3GLdMfSkZFBs1um6EFPI3BeSFjcpYIqum4inW0gy4NclNHXL4cPwHcylCBTab0yRZxZzuRoYhIJlOjdDKO/4YCyGiCnoA/bMYCUR8MRAHWSZOz7vNEyB7RiSMtskLIx89aV0VzhnJH5Kuf6fWTcZg8+BWTIOWoQJTCIQKXa4na0pDyIXmBuOmoRjF9AEVNW0UvhbiitJ3Q+oIq0tnIGqUjDGXAZKEMIFzBFQhXS3hFDoHdPw2ICLCeJSoOvIvYJIBelSKuq+oe4b9pcN++uGfd/AqOhS9JTtctWHC+mGQe9k/pZia344pQWNYFELZQeKx004sT91bMXG0+eTCJAdwAbgIMQ5o/4PASgMaWQH2wta6YAUtdRYztsILjXLrKbDswYIyLk1rEqoldgWUfuhaTy7xJmdf4rS48DFhQes/vxDH5RUZm1kvJdvThSTLk1Ndc1t3fZkblnmulfAngl7U9uL0HktOSq+CEg3u8/hxZtYyiU04wlEAp+TQQ+9/piPREAidikN1jQD63gv1o9oKsHh95zyfQh14gvr2Ohc5g44rHaL7QFh0NlkYZvA/RiYC2hRi1uJHEa6FJ1gvvxw/KKl8M37Mwf9uOSqbHiGzYHLaUytG4H5ISPgMncZ/HmluKVMlk67a/uQgeQyEMOBmZYn48t4msut3735TFvmysbIpFmbcdj7b7WsMK2okp09UzNRT/6dJc4hYuWFLJgIFLnM4rcsVkO6eS7pJ4XQ/fz6A4qGoHSl3mTMMggAe8coEMrltC5AEReI/XAsjbFwpUkE046dmLuJhWoaA7fRYU4Ckk1Kt/cJqqT4pwBlRVPbPaWi1gyuRWM2iv7VWlBLwVY2HEVTJhKLCcwCFtG0X4ZZFDM6jG23PARQoZoEcRIr0v6x7+z4rrVVS6yCmG2W+llppltpimFXNKZd1uUK+s0j0N7Hj1bp0FZ8Ju+JLwyOYQJvjCsUB8K1LCM7RbVj7YoH0hvpDAoz8Cgv3lgs7ldKeZn5ngsZPs37c58R3eApfTAEMqRL/AbJiScPxvwz4SZhhFxkIjfFsmD4sIqtGRIkVy+zFXpTdsJ1LCBnv4SRMlow7gdYw1XIYRMG/PwVxYU0LgSzEiSiaO4DBCeDFFaiaUeJ3MWIo20wUNwlSH2q7MTwouuwbJpm2oLAt1rBldFZPZqYZDVQ2jkaugkSR2UYIJGPLA+CANx5fiCIw0G7Kxs+a6RrcJxYb7SFJdLahrnZ80ZANzKLqCIlwuO4z+yT1tO4oQeusqg7lS1uyBeJ+d/s1XSHTSCaMSynW5zwZVDnD4OHb66JaWOsZborvDT5lTjoGcavl/56ydTC4n4otqAve9ErKM+krGftLJ+ziHU/6hfqapr9bCEZ/EIIwfQue2bL1z7R3GcQ0/2tIBXaOk/SscSzuJxJ33bTN+QGzV8FyJtXlrpWkTGB7GwB93PwRy+Ze/aHcFmHyLdBnYs8HRZ/LdanICkBoaD49pFvXXutzyB0fLY5m2IgRwRLyNmZ4X+xs+F6ZH9uMR/raoUojem6Hq2E93bgRqpJ7ImM++JV0UCXabl6l/zmykyhiDNcg60MdYsf1Fjl3gCpQ0b6Svjg108Gt1N3KXfc3Z1sRNPczQILxqC7ADT+TVRYSIMiTRjSncCESOTh5pikhyHs6m9HwHX/CQCIGMymXNQaCob+qZ94jZPCK8pZUXtHEwGkqauS2I4yKDBs2uyNzmJyycmBv5mCuTgbQqDv5BONeqZO6D80Da7MC8RR/mKn9SBrukeQidbOHJJ8NVo5ghNJmvuc61rgDhNsQpaYq+5OdQlVphUze6c6juj68PiZMS6ZOMWYO2X3qlPAMAFDQ44+eJDx+L3ClxW1eYdhEd69aclEgcZYTH21uYtYijyoCX44V1lYieTyY5wH0c+kzLDJd9etmuF/Lbk1LeOWIxqKmGd7In83zQS5Odhx2qyfxIxSC2qt2LaKbVf3qW3bULmo2xTZqr/lTiagU0rMlOY8GIijbXe4ZCwZX6N+FssF+Ybzm4QWl9ZWt3fCu5OcZidqKYhTRz14ReCFVKBSzQTDj8vByAz1x7VeHpwoXRD+527ViDWfae8sP06bET7ume4hveRfjE7j8ix9p6m40SeZn90KSCstB4Y260UnBJkbn8Ci2++DTBhk2VRr69fX1fQeEhhOf2Wp1L/nwV56OorbvMjoNhk9x8T7sVSy0OFbbj+uj1ePzLUlXiNpLhyNMnucae944EMzt72Mzx2UeT7pppjQ5fu8S+89oXmo0tzapD6pdozo1YJ3B891+i9oGjtQKexZFwNuQLc6bVZjPa7i+qJkXGh2AiiNaUzZhRI8u2Z+Or1FOcz+Jq4rk/7cmSn+Z8a5qNwWmLLkBb68cxEA+LsS/NdPUL/rXaYK+d0sjzjviVPBRdelGAgSRT/nTV8/sK8oHyyYk7+QuTIJfCNpQEldhpybzDAaT7CG25hbgrAFPnvh7E4jkDgjw6dWEKklo+eiAZyEcEEZrRAqF1CpONySUQtKK+q+USu2WlTJaBX1rNi67pgdjSEs6N2DzmVB2tR/GoKw41tPytF6TehOCCFuoLHWJdaHweQGm5x3RsYuudc5+RMDk3lyouMJPA9eD6ZAucxQC2LZp3cvvNLx+LLQoZqxIA50c8OGj0uspU7p3VQHDybgqob2P8VAyPW1CcT85TIuMxlRS4z3ORWmsVvlVqjYJZlp1qg/LW63/FGM6iD3vskt5nuuCvlQrB3udTfLBS5KClbE/3fLFpeVjNRzyjhLNMaXZuYU82Nzq7hPMRdMHgRO0BPBGcxsCn/BtlXUFz0FvO5m2ShV4yLYZvLKH6ODQdPFNhOJI+GErwP/G15/4zkVpxXDSqnEdbCDbMELj8SCkLXioF1YQoNub8a4pVmZFqcATSDcIUWVjLCa2ov0I+vU06tLR28dcppFIyY909t7ZkhPn4wr1tGQUiIHAH2lgn+qS558v5RbBJcPeklWXnFepvKelnoVVDLaTs0sBRaydwfohRbHd6ehyB4ARpOGaPB8GG66fA/Hc2Ha2PcAKX3vzvvIQ2T9XZrR7epTfWkn4PoMj+7GavotCw3PcKS/r7SVC9Hgqc/n8snr5LGTkrwBnLeMosGfM//K8y5z2XtLRv49eF3WxFZ9PXgXMObqrpMJVdfnz4cyTXCeowtizhVmyW7iGcs4PL2Gy8vHExZTMdcfxjqy1ZHdpYzvC/RT09x+DtSXFY1aNhQIKiq4FFBhk4gGGnVzjNUkLyo4xpHmgDLtTnowlvWPwp6Z3D8EKI5OIhbvYdYNasN/yHo7gqDF3uEImLlMIgGVGWwZbkrRGI16dtTasdWGtm2ox4ZSDtStorcGOTuEGhrpgukJeSYPP5nbytL8APsOAVaqQyCuIJbYqYsntiEaogvp2OYqQ0GALVivXm1gY5ne2NpiByvZdynHXaS+x86JxzqkdmObKsYBc9yAB7KbsGy5jGOBCOb6wrIgszsTfHQNLvI58mEjB3t5byI6NNoiSnVpP5IOi9jpi+1vir56XeJjrVzJdsrTvLsZ2FJDx3AlJdzBssYAuJeAZNo5WIARBoXEhf1RBWysJwtNgJJFAon24twWn6+MuoLRD/+axi3+mMDMltyBA4GZKCyI216xbZtaNTbLAFcZhTVOy4lcXxaOHpUwrGTSCcJiGevGnEVcMGmQdQyJmY+pCHonkNvVA19dQTMaFM7/NufWiCs4kLFMIEqInTESCBDfppGxhg03BKwB69IgbK5lQookz7M1/M1fHRbgzzaOseOy0lQEHfVYAcf6wN9MxvSFQTdyXTLmGOnZLV+X6eMC0qAzt6+tstPalSgwHqfQX8pP7wUCGkWRXoDyXI/7S7Un8i7AU1k6hJXluXspRLVy01d/RINuk9HSKErzO9POvoz5TM3AqaU3OolylF+XODuHUoVieDP4HmIzYqLJRou9kysviypxdyVIlz5GZ+Jm5tXzXDyfdwphJKtZg78tpeU61t5m5mk0bg+2BR8Ll39nheW+/1j4G27Hgaygc94pPtVgIJMHaJnrSaeOfo6+rO1flCLvv1CqbIw4+UB46RSLOnuZ0DSNk0t7GsD4nq7c3TUW2cvPSzfz+Pmr/pwVm6xY68aaKdWea6OP759dX1Y0XuoOQgdLAZGmtWXyIzvcmdwlOxkIYAKqakIEIT1tGwLgdK6sI6KCie3We1wf3DnCxCcRkOWhh+/6WX76iaIRQ8JLO90m0jNANgYf6j611R19E/TW0LYT5X1DLTu2cqKVE7029NrQtgI+GkohSBvN3wbDOfDa6lgMSEzNnuUPhVH0fBJmlE0gralfXCYC4YDuu8krNfdKF604ONoN0ERLAJ7M5t/Ega/mvNSNO1i80/m1tEMMQVg0OAViz7TZCKTQ3CeDJltKRhgPxcCpOTG/l2COf3l0k1KHQxiQYDbxWkyhpLZni5JYPIqbgAdT1zUTv6f6YG49soxdopKJkljro03CJMBkP9Ls9jGG191OKNU29rICcyg/07rCzhiWkaGUqIWSoKlfCwga7F6YsZWKl5cNL/uGl71i23bUsqOUDbRVXf9MIGKzXE5TZ96Uw7IohgjSZAhIpujFBgf68GAiKJ1ogAasDx9yagA1AnmKbGqmcCbBYVq39tuFoSIadC59kEakXWKysTQiIpbmFtSTgsfR9o/r/opkIu5xlmmNK8J5zeqdEETyLqcHj44V4L7giElLniBa0x39R7wwtXm5bl/2dS2YkCUXn2BIdCckJa9+IrhPIaT1ppnsZlehAUMej9v+ESUXjgwQ5jUyGrTHmeEoHVmGexbgUpvD9kvTC7mOLAyOOzNsMv1MdC1J0JLnRgaXnXgfLfUbT5svGUrvKhMA84QLBi5GObkpm2qh+Y1p6DIOz925FkmyzE0jAWLuVx5xFXxnbEtQYeLot0i53nuy6CbA01zHZvQK51LXimxJ8nePAMllQ0jJ8oC3qzhz5RWrI+yMF3eyla8O7cqVrkT1cu3LaC0vCp+D61xMGrpvlro8Q9DNf1MyVHx5SgDj+rKisYOBvQCNNQOM6O7fCGHsQxSJyO7h1qMWbTO/FHN1qqmH4rhhbxiRa6ac+OLmLuDT3xPLUDXq8FHT3QTBejI4yAQMs4SUUlBLRS8neq04Xyoej4LysLM16oZ2dnDtKEdHKR5xr6m9PABbMqLJ3F7Gx8taXC/dAgZVRtkLKjoaNCN/B8DujpYXVBC7KwgX0sM0ATJb2SUIrRdh8h1dmawD05WYxh35dxhXHulKg/vIi6dDlbk+heUZk0xklwbSC3I32bp2gys8fudFJ8tsJbqV7qyDkd/HcP8yBjGFEiFVeOlaIjUTwQsRWP+lMW3Bpt1dR2wci9dBI0KNJSxyHhcXRMp9t3oGICkZc1dBsDNvxJIRJEUqDGC+EcAAV4AZKFRQWS0X27bj1dLa7rWi1mJZ1vTq3ULBZn8tvZrEOApbgommYKsLVTdjF8Pzx3ITM6qQzQ+rxcOZhONCAYi1LHXAA+Hj0J8ydkNIMJJWdELf1CpbAxck4cDswx26BDGkKx0l2ykT+urZq3+7l+6u2bwDEWvzgafqfK3ChV0Z0254+/O61jroaRM3r13p3IWWJ0K61je3cdPwE5kg3MCmNtb4MAxcd/J4eWeF5smtlJVwPhR0hcvWwdqv3PnUt4/G+O5yip2Vjctc34DvX8T7ctfoOj5Pr08gvunnH3n98m7i/f4oN0HLax9W/wleBb7EjUH7TH79J7koTchwrdd23edmgEszHvqD3Fnnb1nmuch26wJcpZQ0mlEB3Q/ozZqOjby7cheGPNg8pXIagkBDvCtIF10/42ta+6kNioBH5WV9HYIn19fP0ZACNiUjhMRCY8cVlvqJ9BwNDxYlZ5PuS+6+y6yCAQCg2eB7xhwrD7Ic8oVsg6VDqKMJzOVKom1Pn5mSxQwpLF0W060wFt1VLe4rzgWVC7ZSse0FVQpqr2i9oUlDaw3FcggXER0936201JYRIB4SZl5lI8BuAgiAaw9k/uua8L/oeR1m5SHxWBTzeZfsJoA4ot4X8DiBO4mKgkUzT9QmtNwkzzn8y27E5NkaZQfZ1p/aphpHRLN3RXUURF00HVmAEbvoGcGnRTAYxDS/sYWPYZGBKsS+qzYxFB/+ZT2NGj3+IbutmFWCRlv+kqRKcrBxCP9YCNfU3/ReUJAsLS0KmO+wrQzf55CycA7o4hoMmkjCzcQPSJwu35XppMI2JegoTQQyebVD+bwMIdzhCOoCxaTn8NTK2PeCl23Dvm3qNrVXbC8F+86oG6FUJ5CG/5QYSoBpWgWN8S2O7eLB12TdNo2Bu7omOcQMTUTQh5uTNavnl4igwIiqqIsTk6/mpID7Lq65RIkQekvuVn4wh4yNEyFf32b2JU7z6skEJi/wH9dyTV6b9iWwJA9bYoqxLG6ErhCM7lyvlir9sdw8CJfI9N6q/DzbDFxp0aACK3UaLzgcMnUQE91YezJD6HWM9e5VTbAZoRtk/44X4DpQc1PL80HLJXVKTFAK4fFCpGkZk8t0RU0X+MKFZVgxLwOffic27qwUc7XywViv8GBmX3QDt8sTSGLCDWhfasthdTrumzOYcexZnf5sLXM3nQl1Ep/OPNy5nIy4zVTzatW6dmgetIBLZjhBuInJSL3JMA5UwIAwNRfyw/p01JldCgP8leEbPgcUlHn+XDfduIhP82+vyfqMZi4ZbrtTX0ZFCzvHNMvp2Xhsiv/k/fLx9QcUDTXnM9mEdoqc8gRXBNyNxwWS0RPjm9orS0EY7sq2qzHoujNfY7LmJyogCCvzJoGdMmzMvyA8Pnyq2AX9fImd6UQAWZYpLhVcGrhYatutoLaqf3VDqx2tdZxbAzf965zORZEeSoYKHk6urT+Sm0/uQpgZH8HJtxHP1uFWIEruNWr0oIj3cYInjlA06s4LXW9mrJ2zsKBL1KframZzDpuke1P1hHm8bU25r2rA56+QFRcPJqdp4URMgHdJxhxPo0epXzSDzbFbrDdEhkPdLBzQ2NXzdsgWuwBDgZzHdhonmo2UDnOPN+ADEjt6vk6UUDoxiAczIUm77clBCtNFquSTlXODnw3zYKhGwQKnJoU4DVAiMJ42diVsHSPQ25dzuE4x2VkgfmK2KvWadGHDvlfsu6ez3bB7MoZaRvA4YHqS4MLJkyug0wsfIyIAxXHbGZvhsGsRBKAQhDXldu2iKWnJT+2RtC6GFysRUEFoxDjD9XN0IoJcAAEAAElEQVRghcbPiZ64EwhMgQIwnCK7IT5migBIpedJ+HFdrm5+wpGsq4/192H8ADBx7rno4GXjnYXmPVmCcy3z50xzZnj82yw6L82INz1iGi91ZFzxjgo+wCGjzzJw+1KP38ryBy1lLuVTo+tYZTYh41PkWkyWgpfhS3NBd8+/ehnxn4ZvGbdFRjO6ne7kxjMwK2DTGM+85dKB5dFXSIEsP2Kqkjd5HtsPmowX8obYly9avmR8lbUvd9sptMgsA7qLPGGPnq6LFZwVz+/wfQYvPmR9vnYvo8OFfM/ce8gQmdYkl0HnZ15+pT3hoje+z3x7Yj+JpSQ3YatUhiCa+pT4MFHI/gLlcV8J0viyotF6Awtsl9ooup20G0GLwfTdrcMdob2X+p2hikuMLSFyU5J6NyAWvJBaL4oqDp0nmRKaYowSsUpe5X4gwXI5A9GDwnikt60F3DRuo9ZNA8NrQ6+a1eTcGkpr6OcJtoEm8//2w+dU5kjRGHlnKaHnQCCE1h27to5J/bAsKuqT4YqFp2CNTVD4zrvEHKS9kDTI9jvjtAOC8TiwlICcqSgejxdT9dpPtXTPBGP46DpC01SX+Dy7pm9V5x2PGT6v2AeW4MqK/hwdHNmUJKwcYxqMiF24/0J5THiXoIwLFZk4kdWftqDCp3kZy9GHdUKmAtFx8f5cmFrGq0VoTXVQ+scZJAWPW2bYNw1i/IM6IdZmWvKZGMYp9YbLxG7NIDCxZncrplyYgrGViq1W1GIpp1mzzwUeLrvDcXExojHG02GTiN0acxwuUAgMjj+yxTi3lNex+6x7LIVaNwQNhGbjyDEePqzup57tVrEGwr9uAESQnKvXUPbS8x+XX65Yu4cZpaVBMsz9MuZ8upabw99+dqa80In0HuV3fb3kOvP0Te8lWhmMbWwq5R3Z2ClNgsIEr38mOGelYaXiSVwaEk8qN3+dvy+8zOFfB/jZbudCdp00O1zRZ19M0UaCGctQrxZ1LzDBM3+/rnWfg9RUJn35uvANDPq/DpzTn+XRSqOjDu/POn60fnnGHG8u8rkaa8HfGsOUR2Ta14fjYwZTIFMQ9S1IT0CNsVgGdl4P+eV58pLoHQBJfjW1GX3Ny3dl4zL3eF0KUTbhoARfomg3R2fexUJqtYJ52OYBnI2pg1c4vcjxSLlMMLK0nrV/yQiwCFRkeOZu69OaotGbkLODxMnU14+urysa0jUekQoKdRAxuJMK/vBdS2eoerBdABFCpAn3GvVrg5AJLXT2OzS9IxtDtx2qrLKEQB6564eVw0VOFkFbEIWAOGVbhCBcNHWvpbhl/YFSKvZS0euGvnUNFG8VbavAWewQWmNgbP5qsGnvC5H3vuF+PVL6c0uOHqxnQaoR7IoQ4qJKGS9nEjxS762tJiHIYByK28yM1Tpi5McLycDjC4H3uUudvljVbd6sqGKIaFuxE+8uKIkJZQJNGGZKD4CUCCC3BeNtcbKm2ZhQ/IdhIZn4l+TKkU2+hs5OdmOZgzAseo7TMnA1f8/WEbeKBYHMwrWDQmPOyF1tHB/E+2ZKXIyVaNRUos8ZH8NyJmYVTETarUhwN0mb81HVTPQpvcPJzcmVC1c0CjFqpLStKHYwnyr1G6qda8NUNBkCeMRdiJiVAPNlGx+Rd98ti3a+Dwkr3WoYnKWwbXaQhVvo4Lr7asfYzdC0vEavBMH89cw/QrekEwSxTQfbFTJGIonjSSwcihkI4i3QmJDomIxnM/v7cS1X9kwjYPCEJKewDLktL/FRSbrnlkRfq0DEqc1XIparROMlstwy0dq5munmHc20tobw+0T1XECk20K3RZGo/gSAyy531xB8MNNRBBUMHB70f24/86MsgF5GPJhOWiXT2MtES6NHg9wuFpNl4GXMuyPKVCLmZ/C1dViu8CJ5djx7wQf5Dr8+mMCpMnn6xMdyym648Kj8Ds2vXq4AmWxdudzwDNaMIDLsdXQplH9lZpVoKLqla3HcG7T2tibnn+utz4ZacuFlHY+uXGYgk4P7NZ426fxRQjKfp7Efm3kG4PbOy5rM/Np/y/TqYhgSJAic2CHOu0rj5pb81UGIrTx/wV/w64oGOqhzBJMUky4IpuW6udqFCwFAZezaM4FZUBjgk9QnmgTC5ljSzH1DZOwcm58WxSnPZCftuq9z+G6NASTNgKOCNoHykeNWtAhAzOhlh5QDrQgaqwsV1Q20NdRzQ98aemvo/YQ0Rj8ZrRS0UnFWaOR9KFRFfdld+LSDB+fVPAS3gVu+aIabkPZbXU2EmvbTMdiD6MQFSYk6Y/WTt2TIuZplPXjNVpzT1bA+idPsYRdR61BeHV7/oOAeizGC4yhgCmuLrQ7iJASb1Yo2j08RjBD7hGM6pRYjofCSC5mQwDUSUyY1uhzdtJbee4ylE9vJ+uJEM03ZZLIEItNouCHZip8WtH/3U6ajrjwNVzO0IDPuRAgSvgzrV37TFWer2cZIVVWNwZiLWyWeycD6Ir6mfU5soDimToXllBwWGlPkc2qwMcJ6wXYuTiWNh6pw62ENBWPfd+wvFdvLpgoIexpcGkrtDbEEoNmlXCig5BpFI50iE4EdNj8IyEhI78BJgg2Iw7qbJbZgIRQhfaGbcmoWVxGgUYewbZUIaxtC6FCaBZ8TMTfTNLaDq7hAM3axRNjOi7EMaEOb/HHdXL4Ll9OmhxELYw27cH4bWr8M78r8EyW8FnbkpLt7JtIG0x7yw6XNtYoVtknqHVGsd8LOf841xula4fClv+/mZUicDl3aWEulB3RTVgapCj6VAfPvWZgfJHyuTOZhnwTCTwbuVkG8LXjz4yIV3lxfnrQbxAkryvM68w75R/FetHzOJYcbu4sp98M2almfu7fBXXcl/c13HctzUoDhOJXfuV0qwbyvZef+3oxL5un58wZf50Zpvi8399M7+VXf/JuKiPE2SkrGCoOvAR5AuwwaoxjlR88p/w7CaSNiG97dBMfYjBbfzP9a4vWvH9hH+hfBng4kEUqhwTcNWBEOZq/dNWGwC4QKhJVpx2nCIFAhgJtmdTqNuLEJCc4dfNeBc24B2420Bu3cv2D2+RLyfOtFB6528HmiMmEjxkup6FUVjl5PtFqx9YLeC1ojHCdj3yqkCbh2HMQ4ezFftW67VmxZfZ4Fcc5MyOHyJwSgcgG4qOAipylh410haNrN0EQTQom7nxMuqru3kxFZ0oK0cRa/71jk2YsuzGAQAILMnnKpY271cjyJnXxrr2xAqQSgonc95Vdg2cpotOVTSkwAV0grIGkgnBBRMF8KsBfCAUKjggZG7wLyFKEi5s9tQqqN67D8z8RtIovujgNXJBPi31G8abBmcnalSxQTOEjqcAnD9J6vKYQEELUHETLhteU3nTuokhoLGpm4ef90zIXF8zwskoFqXG5YHASH9OA5m3Nm1rVNjPJasL1U7C8am/FSd+z7jpcXOw28VhQqahlxpmZz1cnOr8lj4eYAi3WnRpp9iKDthpXVh9gWh3igNUKRAgAuKW5JCA0U6XkzE2AyK0bzozi09+JjWgl0JrcSx3vxNcOQ+M+mJI2teEY/W5hrnvQfV76GkOl0bKwxnesQMif8vZNIr3XLXDpd9OS7vXkRLm9o8ao5p7q0L5nLTRRjpUwLFKukkgTMi7CRvi7btOKWk9gVuvbp2mbeYRbcahwT0LLIysl1RNbxz+1/KF6mnzJBHmQ6innNfiMDu475KpzOpeZWnj17OtzzU7q5J5J4qixl5DK1eZuMUpnhPrXgwKdk5jkOp+EeBHUSNBwuG+/07HPq5rjrs2e8cRrudT3TzXTkeXQeJ9c6UtkVn+5mdvbJ+gTfp7rXa4QM5LG6Tg5FU9E+pSEGwsNi3iLJv4zPx1pLdcciydvNdjO5hSfO+uH1dUVDVJ9Rn3cV0mHuUpwbI9GdRQJ6YZwNKA2ak96kBMnMPu+2mqIgAFoZgbxixGoQI1NkzIWhiAqgXSTOtoAoDPWG1rvLhGbNYnAtKFvBJhWdOuTc0PnEyRWdN3TukNLRSsO2Q0+h3XTAVQDKE+ixJ4q+U5ZQ/5jwf0w4iCG2S88M4BXAG0bQdwiqJvZMFFMRLZuIx657XhAIbTgz3kBQQlSSDUZiczsKjWeZ2PhvMZ8scZ938hPlh3WKdJhABFQBdgDnDuAE5CRIo8B5UAGjgN0nX317QNThB+cRq4L2Whg/V8J3EL6LCmkdHd2FSyacAJqnKYUtSvFllcZ4RZ6kWKjVgMLHEZCgg35+TJBy25KLgFUZfsgjviG5Lzlu9OQF6c1HHIjVb5I02a5HT1x0Yobk7Sz9kjEPBEtTm+UDGng6dj0plA9VAB2DdE1JL5bZaRzSR/sG3l5Q9x3bvqkV47Vg3wp2P6ivFBSlNApbH/jY6Ubp4hRv4jjI6SC/lCZXx4zMBdRGWGblmCqjdKA3QhOggUZsVO+RUauQBto7zXG6JQzddDgwTNlmkSAdDbOc2ATGOqSBIyJoLGMXXATlR4bbp1cnhAIqDE0yYnMdYoTITRbVlXnfXLOvzSdlkRZcFlI+eZnm0vdsOzN3IBTbEJfkw2Y+hmC0GpstWa4jDL/Cu4qfyhkuUFqZ/jEcdx4Y4knYnBY1r3YpHK4TNyAYjJIf38F86YvMtMPn6QtTOlU6vfS5UHZ3PW3yGRzRlIvSLjkhXEWnOhd0jfG+qT/EgOeNRmULtQ7L2B8Zh4Sd9tuBGtzyD6y2VDKDfYd8GAvCZSHn/bmmzLRjFz4XkmVhp7bp+jhmzDWAvm5X38gl8TF8IigAxpjMGzTMPD5ERds5VLgsQbB0lS9YQxIaxllyn11fzzrVjbQVhqdgVXmPYvT9hGcx/3ArbmfyqTA2FnsH+6l8hBgaEcvFH9mCFDN7FswAk3AEbGdsdBJIRGbbu7hOibt7sVXERAAxpBT0Iiito5RznKGxddTe0XpD3To2EbTW0ERQ0FEhkFN01xyCLsNty7xspmXhLjsOi16sh9RxAdkuLDogDwwBJnWBBbajj6Hg5wZWQpBXX6KcY58nuTEl4SZ24CdaaQ02Cp9yCUHbBN5O4KLvdmcUEzZmf3XFoS6C1gA5xRY1maDqAhmjsM4JFTuApb+j0YEW/dfDJFGLKmkHLHNXA3U9g0VtfZamOWAeWj4BkYFoiOSpA2Q4HwvZfmfrVXIxcwXCqXO2AHlc0UxioEI8TIF3JQISQz/wmgI0Ygp3qRjliJ2hgYcZMXgoVzG9NJNxjonPFEVhMgNVMA4lBaooU2EwFz0RnBm1kh7Ot+94rRte6oZ9q9j3irIVcK0gqiDYDoOoykPs1qd7xqTeX6QxYTTGn2Kshirv5gjxhSNaAXVdSyKkFpHEVHRdECCq1JL1XUBotqGCArXAwpn4wGFynLNddSlQWtVH3JXTJPVF0BTehUyAjjn7zxNQ/hauCB/LuEoW2xMrza81hNrXqtzKGlb0ltF/eUbSurlE28Su4434MNHxQcTHvzTowhW8exCAoTwMxqtlyFu5cW0xWkkDjIA/4kUW2SpASexhISHTBrX4WqM0Y/lDxtyFtdngyWx1HYZ8+9aAlJ55fR/NbV6OOWbmpsbxyF2GBolPMC7MOdVFKw/OzHz+mNn8hecP6+g8TqkSnx9KT5YJDZ4nCUeS++d0y/tIU0WjrSQzxHsrXJjxax4DmtesjKiNtZZ1JU39SgvwAmr0wXn8beXB19XCv2BP4H0alLTG7iLwJPHlm8mcvy9w0Tx0E75GDGyedscPIDaz5x7QhB8qz6msq1k8nxHOcX1d0YAqAOxQ8FgkzksDJnNxYAgKQU/ytgBvsYFhf8eJm2grvhEcDDaQfiUyOlUqpBrS2qiS7yTfEYwkqDGpL78wo3NB5x7nanBhcGWUXuyvql+5fXLrKHY6ogKvKW65qcKjgqIfGpYmvM+GqCG0ukOFAtcFkEP7pIeiaLkC9XcXG5O8M+7XhOdGwDOBz5J/Xm9jfI2oiISwOiG7Ec5hIrU++Xxy0fGDKltNAOlpPzGvZoeDGCcVoFcdS+c+AwXATNgqgXdWDfadcTRGb3048RaCVD9IkiF0BvyRnCi2inkQTHLY1aqkY+RBDGOA5vkylyDoFnoPP0oKZVEXdh+dCFrjo52sUz43ifY6rmYGkPE6zipJkz8RS6JQCNTC5AyVABeUe5rDAeZEmtOKu/zyIVUhPEYGhQiFCVwYtajL4f6qysbLtmGvO2rVYHA9Mdz9swiR9IAUB2MDAvOluzDD6jN8SJE2K/S+2Hk7I4EEfL8CWfwcTMGtuLpe9Bwb7XnnlCkyLQsRt9h5HYKxpsKBdNBu7xNJtB3vR+wJTT67P675EvIzlHzt8uRDLeQoTileLRFF0UQKw1thSIPJke6W1U93PpkjmnAgqh3zTcAqieYEE4kZBuJlKh5xcEv54V6SAPxcNkAQosxgksDhdCFqFcBTdRvi6je31DmNoZuhWgSiMTW2eeKfSAJzAizOHLjpwmXMcdM+jX6FF8CF3lypjwF5ua8q4M14X6cnwSXriEaBPMayPrSKh3XrRh5IclSudGw0+aTmsZr5r8oaNqfuRXA3kQHS4laXhOyEnZex8VkdeD+WhuOIJHgz4rhfgC33y0Wp/zNKD3owyUoBkyQe7G9kZSt1IFmf8zzMaz5v8+JSKjzkQvNdF4b908e4Sl6nVsk4RyvB5z2gKGaPadDNjKcm04j9eTpxT//+lQNlv6xohHN8IKYiyNQ5AkAcO5AkAvZtfZB7S8UgUbw0BAQpADWKXRcS3xMeQeegMc1kImVHB6WUNKq1qcgzX0OUUF9r9SEvhdAqoXRCqax/nVFEP2svqGfVv7qjNGhmLOtLR0Prorue5k7mSsYdhRtz68LZgCdSmEqHpO1VAtu5BFaBTBUh1zzv9MycQsaKmd7RogtxcSTP9dP8TpAG14a5aKBvYTQhHL3jPBsgJ5zdeCatiASgAt4qBC+AHCDv+9gy0rmmrn70GwAwzrcKNV0kUAjowhCpUDe0BuYGAaMdJ84wDXDgB7H53JcXdHoB+gHIA5DT5oBCmGZ3GWQ9wV0VaAE1O6yS1L2LWIDebb4Esas9thQnhnO55/xOxhQHA/DghXjN5iWoaxZQ/FdWJpLThTGNJF8h1mfsfiQKRIgYCjgxtE/FfVbXIsPnwoxaqsZm7Bu2fcO2vaDWF11LpYLJrFGGa0oIfW2o0KLMZmXCTu5pInjKlPx9Xyjdxk2S77lmlVKlGkGgBlPwA//GuojaTLCinsduzKFaWPrEpCJmINaVfRVopixxmidBuXqWFH5clytU2260s9BQ4HwmZ/I4rpgYuRniaXF+ft0Vd+moXwXAy2tdUqDTKmqN2wSEhWCSPP4L4Z+wLMiIC7B31aaNlbRxtbKXWWh1oSE9vBsUXO8PIfJOnL595fmVZZZ0L5QM+30fQ5FhEicpC0xj7PO/KwxRKsjGMtpyLf/0IbIAf9M/L5ZAzOL2XbTN+DG2RynLAr5px4mXr+BNZgcb0CzD+IcBP4/jMgFD5JqrT3WuGeJmf4WlW8s1jS/TDB8A2GaTeBq7D651dhzuWFoZB/NaXhd8gsNv0VTJwLAkOqSW5557GUkbZxMcNC3x+GOxA3nJHEOaytxPVPzp+rKiUSubgAVA1PTfHQkI6OyIrkIBUwd1MWGcBjO1TkgRY6BpDFlih5FPEy78zAhbzOY3NAZPACI7qZtMkGjOwBmdF0VDpRV1OW3QtKhq2gAXDWzfCqNuejJ4F/M3bwVnLZb/v2H3s9cFkC4o0lCaQIrFaPSBRboj4wL2QAqyfqmAhmCOBE852u0Uc10s5Lt27orhFSEJQHmNhWQ6VuVQ9DDWMEF33+8Cxyl/UcUu0NB2xGVwPe0LF7yWDX96KXgH4fezQ3BosLzmBbakOkoCihD2Qnh53XC0HWcTNDnMPOdMGBDpaCLAqSnV1D2rgLrnLxW1LDSgF01VvHXGzgV7PUEC/IqO49DsU4wKlGpj31BwomwvaPgZrX2H9Ab0BhGL6YBak7joLn0pDN4Y7Z3QxFyzRNMaEWuGBik2dq3FXAxWkneIMpmwdcKGR3f0x+fE8HlQL8yEKE8/zcV8z00cV6xhsp0QcqpIQ61X2ZjydEPRkuEWRs86pdYMVchqxGBsqlxsL6jbjrrtaiksOma6UaGV66GYqtD4vZU7bAAKjdHstqPKRUOwAqVFVGEktTNmtA6CamfWeIph1w27KQvTnoW5koqMpT6Cf3VUxRQYNef6+sGgoQ6EwMx+jiJkzyWt0Y+Z2t/yRet/oWRcLWDr71hTlx2hm3aevnytX8lskugCF32efd0vdWX5hXBJAjALEH4ziWY03Zrf8SV+W589oCToZoGDcqEBf7TljMcFlcEiRrlliOUOxnjosX0uKA3/fsn9k9HhoR8stMI2eOZ+pHUf5a6j+wwrYvMn1vpNmeXbxIoXvg2k8cnzufYzv7TijlWS3kZIFGsnJFeS/QdwIwCP30Fp73bYE3+Z8MX6JCHvzP3IoAkyVNZWqth7tb4zgRkTvSLf0rf1nTQxYw3StAE1DX2qY8KXZazlMvxjkV9wEMt4rHwdo/fZOuPK90yjaPmY8ZtwNxiZIQ4A3PPDc+EQPLGJ4J9U0dioRKCLm1DctEPW1W5AcTMDiLhYBSVgJlAL98jK5ARFQCgdoNN28oq74wjCBOf96V0VGAJQmu4qCmDqwzA5edzGPIz6qIumxmTtDzGBSkGpG6QKtg4craOXBqkdfRPspwq6jXsyN2k6TEYHd4BNLKFGYEun2oEYECceAYdXY2cNELHtlCtidGqg3lSYZ1Gf9VgQhqHZeR+AnjnAJrjpeGVnveEf6oCIZZUaDDp/BNMgBqEatW8aHOSzlxkcAa8M/N3W8PtOaI+OozU7fFDMAkAmoAJFOl5F8DMRvr9seHs/0U8eOxOk49dpw4kK6YR6wIhdUTeq04RUUleaZkLjVjt+rg1/kgZqDY07fiENfKFCoFp1F74Lts7YdsJRCPSuRg3IcLsI/AajglE6gY9uMqr2rVQBqtaNkyFU0fup41fs4EUIBGZNKT0Wa05fF+MuNt+T7wzZ/5lKpzm7MZcGacrF3E0ryieqFj7FrgSnmIyoWsLCpkSIIkscVwJvBWXbUHZVKray63kZnl2qbiiloO4bClNYANS9wnCESc9H6EbQloM0KjoKGkSARoJOenxe5UBphNbWK6SS7cKQ9c/HmgY/ZndjyuxON1OUHPloAgLLMGcwxzRodHq077yEWJLwaGvad2CQYLHU3oZceJKU9ceFREstR0RkCbOxf5axawiyGEg9rYOnb81lJunjSfH1E0Oo+kp6yPXKTd32jp49+KSyWaLTr3RfZK5D8f0SlLi+tAp0k8ry2bVUfNO/2y7f3KTLl0+umwGnaeLXRmYe6mzsIu976UWg/BSOJ+Xkpqj+cH9Rs9CGsPuBlPuVK7MM/+pMgpYCK6CTdjP/zJZ8rytGepl+v7dOZaKo9u79ZFMGXGYYLmUykF+4pj65dJVTJ+Z6l6GK5D8TiZIEzNKPG9DypsHtALn857LhhM8Gr4TNWF2i3WOBAXN4/vT6uuuU5ZZikzaka5ytMk+CnWAFwIiHj/AJ3YGH8XtLH0ki6STXNMJdhYWed3h7ygwjApwIpu475M7os1eCQrIw6EBaAdjDWEiDV6noOiyCysDWm1oVNh3+3jua2K58UYEyBAERSOtAP4FGaEwQYt1t72cc5jd2ZNJq8R3j2C0n8EboJ4HFYPSt0/ApgwqzXdTqEbKKUzSCdBcsZ04xRpumFfrzBvxsAtabEN5OQbMRVEGSwbzrOQg4ccgDrXe01kYaWpOPHgz8+k3w9t7w+K2jf+8jkIcBTyggAIROPMoJ/lZwPHZ0OeHSq74iIBTs247XXS1PHYLetEGhAioNfmYCvRoQrUP4xO/HiXezTry1hspAq4ImBSybCSkdZe/Yfia07zQOZBwYomZDhp3FQHqwW2+KD83mpuinuuIUdCqqIxRXMhvQAEJRxRYNIs3S+d5ciUAE3b5zPUheVK4YuNzb75dAwr/8kFIBScTI206VeNYpcgVDiU8tgloZW62WXWrHvr+ilhdsdce+bdh3DQavZUOhiq0ywM0SANh60MhpNNENgy4p4N7BZ4FQ03XbAK4KHLuXVPSRIRvpmu+iY2JKFDvSpvEDxpoSw0F3oQt3LqvbsosDUCU3aELpachsQ8VctjoZZepdXX4Ac6ljyyNOCl8XUBP08kclgL+dy2fDGeGFf2IILSNeIUvSq5QyCJkKMTKVix28hCjXVLa4F3ATPiUUin7M78v1exSZFu3UZt5MyPVL7qfxnaBuSSi8F2PWjgzCsVY7f5lruxOGxOrTteqWDH+4vjGL0jm2atpfyUUnuWmM4+Rc90RPuIF0friWkzypie9GNxIi5nflpgyAEH7pBktCmLiDNTWcvChURpJrf++uTEBXC8YF8KX13O9pEEYdc0ygYWKANg/OrGTQ5KK6Tu0MyPh4itfWTx+fDOPEA719ZxdPs0ekKnL/J8S+A2h9RhMcypvo0hdFmyGnXLtGH3Q+ywrz2nI3scz+B7VFIqafU4wvKxrCFr/QACm6e9ig1gsSAp2iW4hsPmy+iC/rjgHpCXD31R9ACzCOayMLqxZWv30AUoHIjuNpjQzTsn85gSaZLMakQAUPUCj41AEWVXKoMrgztleCPBj9KOgsqEWw76pQ9N3SqlIHpEKkofcN0jpkO4HW0HtTSUzUH8zB1LFIBJTUr13/00PCuOmINIadDk5GJLRP6lJi9gTHx+AojniuhA1OMBjvaF8AoG746aXiv9kKhBh/PYHz7QDOQ8+gAEC8o+x/xr6/YqffwedveDwOO8BMd+lV8tzwOF7w618PnGfDeWgmHXTE+SkMQKVBQTs7jgOQ34G+C6QIcOqiCreyrWB/KfhpV2vPQwRvbx1CJ4TMqrUV8J8r6M876DdADqA1wuNBOKGKATdg46ZB6nQC9LCxbCgnsL0dePTvEJzoxABVCDUApyoxUAEQlvWrnww0gtBp0VEFVF5AZQexoBSBPATSO3oScFEB3hnl7GjdU7dK+Oc7HZNIHh3UOfG7YbJ3fM9Ln00Ihigejd2NQTICIUORR7Kg5Npshz/asz0OMVcVc5nSZAoVpeyo5QV7ecFed2yvG+rLjvqyY38xJaNW1L1g2xmVWE/ZXoiX23/0XJ7E8OzqILVokZg707zDIpMQj6Atncb4iFlbLSfukKFszXbfrhBNsybG8VQZsrFs0A0Vi0cTi+PxDRf98PVKaocR2Cbw6HOIPoLYSRoZOH5cd5eT9A3AQWbcdPmAlUTfS5MY9DEi+w3v47sMVzcvP0k1C2O/1L8Aen3luaz4tNLn5Sh/5nYTb8D67E4YXOvMdQQZGJV1/9nGe1cg1vZT0O4z2ZfWdz5+dlv8s6XzxfH9SC582sw6DnIZyq81/AfG4FrvKpoqIHeo8FVUu+vXpYk7vPpAGXjycxDtr8wjzT+9wsFN6Po83nW+OKqKZeOvfbZ97/w5DfmojyYS8/S6gSN1ZVHi5jZu6yJM/D2DQEjOEpTuu/t00FF74hsBnVTu+aAb+fqyokHsWXwUWjamL11350rRk789QwvsVObh+mQcupM5X3cTTn1mtHxSEUDwdJIEsTQvwl1dU0Q7O9wbBN13NqG7uErErjMqJgjEohdjNL3rzqzFatStoHXNPMXdDpVDQzkrtqbByiIFvXW0XlB7RT+7u2PHLrcIq2WiJ6UqMzJmC0onm1CgT+kvHbkIbtpRz7BUJjrn/U3ZkjAUP50HU+KiegKkomwv4L9UQCr4N4Af38F0Wu5/AfOOjf+En7Y/4c8vhF8eD42j6N1chxiFLI6FX1CPht4E1LvCGi4i2m9pqmjoIY4A3sVSgU6Yp4tBGEQF2FXwkkc3F7rTTGu6JOUswHtFpEJrhFL10DUR1mwJJICc4N5A9Bg4UgDGqfCqv5s6+0sHuINkHADHImo+3AhHJ5zChq8FhBcQv4D4AOQwAVPGTpI7OrrCIhTuf9lH2jMYOaYkx2R7PqQA3ZmPkkoTxDKyOTWJsUeu1do0UZiANRNahoEo3WUGmMOtSv8Ypdip39uObdtV0bB0tttWUfeKsleUvYA33YMWYbVgpP5BdE7EiKUSwJWFUrjixQ5tM4ujrxszpvmeBPs9nwrHR8HITBZjbv840SWk+SRfiErLeGQuckUM6DG37oYW8Rod8FBbHQOjl6zES6B44mbrH9f9FafQs2dYc5c7iskMVoQLeblKuqFpzsT14oJlvBAJfwDPNEjwuCta67qRMn2ziFIBwvwaaIVofubtXN57JsRPRcTSPEtgJKIf0cAEN8W7F1Bm95k77SvNRS6yjoFX+MT7LUldNma6aIYV0h5Nq2cZ/7Hntxa80oJIgAHbDgoSOl688uQbsBPogYL5/aA1czUXKpBA9qD0qQ2DVIt6R+eYjAkucpf1Ucm0Sz5MDgHQra+/C+4Trlywe9D1cOe6AWpF/ImF0QRLFE0wLmh7wbe5ygywx4fI0+Zvr6hi7uPUoP+ka9sxn3nTkSiO6BilMgItcK1A2tCSe84FP8Ww/DpzFJibPNmxC6k5Dcyw84oIMCPAZ9fXFQ2DbjBSDcJsTAiZjABekTgkoIEsAmiMBWTepTRuQIAGd7uQBJ3yLhQDkxsRZ/aku5PZyrwKJo6EamQwhSawzVxAOoNLQakF5azgIuBO4AJQr+BaUWtHt+Dk2gRnbyi9o245NashCbsr2ZKgX0QZo5+ebEKFABaI6oTSmBaTnl3R05ANWVP7lyl3uP74WM8ondamguSIg2JIph54TOLx8tgK8KcN+K9eCH1jvJ2E89TD7zo8w9CG/eUbXvoJkTfbZfR4EYVLwVNFVQCzdAiITnUlElNEBcH2pAPdd6iNM4vFwcAF+QZNQiWspzOjo+6C2gGcDd878F0UjjKGzdIpu8DfQO7CAhpnIriFBbaD2oGNFUcfMLcN29lX444qyEJu6bH7OthA57BUueVmTKW7ARqOGrOdg/0n1L4w08DC4I1O6C9k1V9RAmQIpUvT4HL3PiDGAWxZ0IgQ9IgrStnMWlGx7VXT2hZTPFJK21KrHsAopKlrXRBP3FIMXudDlxzliQ50ZzSZmFoE6WC6OgnuW+q0U08dz1x7EJEwV7viRyO9n9lF4bE0ktoaEy7gxGE8Ix5DRgxMTMCgG5mJXtxqflxx+borCRfJ0qOsVj65SIGZEo6PFLyTihrNCQHLitAol61+8Y7Xv7qsJD7lSDALk1kaX+C7cSAfSixwiy6fCHFiDHc0lUZuaX/G1yE8+vrwT5kLjzXp3XIehyEOT2NAy5jFgCz9mqR2uSs1jcE0RQuM98OU60/jIk/fuJkDutzL4yXz3Zt+6+hk3p+LRXa7qXHfEBklP/ecWoQKfzUvpKwuZJpMDkmoqjM4049cvzYw8aPRhQWGmzV8g2skyziSYdk0h6nAqGD0I286CK3VXa/bfiYMv934ttITQRnzSX5vLIr0h5Vo3MK2eoc6mzXR+QIpIck7SaaJFxkmH/mDj6+vKxqB6PrJ0F1mAenpua5oyMhLBIgG3BYFxM+cED1SdzDTRGRFxJg3dHCFLGC7o3MHd9FTxofz9HAdItIdUANA6CZQRUxI7U7wbJptl5lAYCooTBBuKKWhFEHthF6AchTUUoCtokPdx5p0VNGD/aS2UBDcJqO79kiI7JRFMxWRHWqW15D4LmmMfRJgHV/zAgSQ/WZHf2ki1gFC0BITnFkg/cT5O4GEgV5QGejEaKyubkwNhX/HXgSv9Q0bdRQ2Zcm6REwo9RXb61+w1QfaLwWlN2g8BkP6Cc3hxEMYJgEVQXntkPIA8LDUUb647eTp1tHeAKp0ZfaiCCZyQqQAeAF4B21q0di7nn74/hC0prt3ZWcIF7gYyBDs7Ge/eOB9N4ao8LsXOAmhdEERS15grjSldLVkEAMNaFxBrDhByVojUmLXIHY/mRQnGZbswGI9XJpeCW5ifuO8EwncD1pkr887kxJrjjDWdRCWTP3IhWEnOmPCNYmBW+QYpagCUV8KthfG9qIZp/bqlo0XbPyCwhuYNP2wEnTvkyRlI4K4FP8TbR34bUNDtmnBCLelWD/hYpYJqI5tnP9j7wmTxoRBwnwMMXDCV19HLI4qEiS9xN3fbIzcoht90k+GZl6zniHiAVxYWHjp143Uf4OXW4IZullSaWQuUKPSLEQ41jtdvJUYnlyJ7s4CsX9cK3w2c581O20q/FE4b9q6hDukh+FLkGlE2gSJSmaJZMCa2/FiSUaLh8F4PpV2p/4+aTbW/1r+poqvX8/qy2Nzl5vhC126a+qPot9n9+7r1Lvy7IX18v7xUo4+gJfmArc48eztZ8JyXsMfvZD7QHh6343Ql2fI6EqXOx9NLD379U+0dnOtw+PnWuE9biQJMngs5nml+Q2CxhcLRtIngRra3Zjg6kUpjFIKPru+Hgzus+5ChkAFL6GIXYyA7YblMD6zhJhbVSFoFtAkRwgRpJnLE3UwEYS1s+rq0qBxosNeQKDIPS6AnkjtVo0bzdEbMz0DFlVg2WpcJmA9EI8ZvWwotWN3qbYLQBVUClDU374J0G33Ha2B9maCowY7A0CjDmkUQatDqBP4SdW+Cgj6szJwQtDEsIKMFbSQXUIwcUkn9CaBCVOYmOkkyIRLhrq4197x+H7gr8SoRYAi+LkS8Mo43gCmDsaJ1r/jl36i7yd++WvHcYgG61oaYymEjh2of0L5r39Rd5iDIe8V0iukCbicKETotUAPY+vYtobXbw3ff3/D+TjQu4ehe55SDQBvhyqaOWYW5h9PTdBbQ2snTnoFyQtIBK0L3qhByoGD1IWNq4B2BlAhJ4O74LUK/v6njrdHxy8HNN7GTC4E1jzSZGekCPAOwYMEjyaWRIBQqqDwqdvrp55i3qSGsCuOg0KoFShg9EZozLDNd9VRDgDSFN/ddOsozUZmkuvURAuTUJ00BuQq1KgigS8rgSTAFHx/NqwZbMqGZ0rTIPCqGaTKhrpv2F41/qLUgrpV1Jcd2/aKbXvV8zNKReFi7oLWBRnCt5MSkg628zUoCz1jNQfSkyA2ITyjrJBluCO25Wam3t4BdDQbuPCy6T4SujbJxpZMmelGeCGEYi51AMAbmRuZgE+zknRowgI390CD2oUAdFNQfUtJCB0GK6dps6vhx/X0cqXXrOeDoToNtO/iqy/t/QZ+p/UjuLpJ5ecw9yJZlo7JJCEEpKUnuUAq/tn1kZKyCm63spavZZq6et+Cs6X7gre3spzvvzNcdPNQ0miMumVY4z9q1gb8EmFwo50vpO8i8H06/l4+3qfrSzJ9wBntnW1hBcbp/e2VYYbh41p26ctl1zojgY1ZuHvdjNe1WkXw6bToVdmg9U1PszqvqRnz/d6A5ToMFB+Bjr6xnMYty/IDbHcilEvD/nNNKzJUCh+r+ZrW1jTuA84ot3Q6j9vdKMS7mQClKq4wXmoYe1h36yeNl3snXCqfexPtDZnF46Ul6om/zw0afyAY3MVSUxrEguzIKmGQxlCAro2Lme/E/Gb1PDN0mNuLx1WI7qALcVoWStQjYKXTtN6pjB8kQLGk9l1MKLjpiQjQxJKKstgJhwDCTUhQWNCIUbkAdVNBEwRqJ3BsOgldNJZiU7WFRWwn/LAxEBBVPA49UFDbswkU3RENRwtWRx4SdcsppIHkHTK51k/uGfZAjTuZcWY6tWCTUMwlEYEqoVgQ73ur+P214mVj/IUYf+aCc6/4zTL6UN3Q+AV//b3iH84GeZxojxP9sCBnEhPOfwH1f4vyH/4K/sc34HGqMkYNqBpUXRnoxZSU1rH3jte3gqMxvjOjEYXLEaEC/Ipe/oyjdBR5gPuBYkkFoIeJQzag70CrALUHCn5B7e848UBrJ9qj42yGuB3gE+gvpAd8tY5vdOLvf+v46yFmMeNBtKibt5CAwZDGeAfhQIOcTelFB2oTU9S0AYJmIiM5Tbkt5gJXUF4rtjdTrkXQicHEgJyANEi1IHGLY5kCwn3+E/NUndSoSiijC5tLayVM7y6JBDZSSPoRsxHviVowoJY/JgZxUSVj09iLbduxsf7Vsqvi4RaOvaBuQCmK8hpvb/FXXdC7MytCMeGeuIFwKiHui8gdVNbohNEKgR9NQZYRTVDhbk46Tr7R3TJ3kEHrfPzEBkxo5LDjYlYf0gxlDM10xUIa31O0sl6iUkC6KY00fL2di4rSv2ZediyKTxJrHj+uZ1eFHvJaSFN6Mw/lTiaTxn/5lYLC49RuwwMgrTcZLcZnWq6rInl/aV2eDTPLvF8Qk+eaPsKhOwE/Glu0pSd1rDL90+um3+TCzBMhfhV+LnCuD1btJ5f9L0WDqe5/Ipz6SptIAvdyUfqUtdykbPjX1IlnXeAPngW+L5rYnSKGFTcGEj1Xfsd1t07GNI6HGbedZsctvpZZ3ceyknFFpiewLZ/reh8K0tMqvn4tipVzqTt45nt0RYW7KwEf1nuyMTE3VPf6yQf3FRKUf9KTwaGNOJEcQAu6qDWi+XOj9WNUIjIbecQoIjpg2WbMbAPCable4nl6lT1O4dQHunup5ZrDRmLWjbkLriCQGDMiAUu3wSUT8js6OioKpFZjEISzE2jbUOTEZrvMnQE5LDuNudLUZooEdQCbWnTaqRupou442mdPiaKnIhM0PSgR9OTr721ey4ShnfYkBOnkJMlxmjJFGCcOorvohRm1sgp9IGx7xcu3gtdvBUUYeDAOFMijopyEby+En/+sB60dj4Lj1zd87w8cjw7pFtMABlEHPX7B2/c39O0db/LAQ7oeWMdqARMApwByAL2JCmClQfZNg/7DMCfQ1LUFdfuGff8T9td3UD9xvjWczc8z0fMryg6UTc9jKe8PCL/hfDzQ6R29EfqpZ25QUeH9aIC8m5CHjn8sDf9H8XM2KgiWZcgXkgvDlVS4BoEbcFDX08ZLVzdBMsylE60JWj/RW4OcGqfBG4NrBbVXS+XcVCGkDbwVVH7HSe8gAlpntNbRqQPSYqp9Ti9TLohd3WlT1qwGqjOs6qetPX/uONjd/91+uwsQoOPIxQ4uLChVT/7eXjbsr5ulsN3x8rJh3yu2WrDvRdPebqyKBola/dJuDJvEQSDI2UE7QFVTE6v/+EzUeh3nW4wFjonAqyHUXDKF0c3KIdCsVSJdYcGwdnbjThNhd7dNArgCxIQuek8Iw9pRdaz0+AtBZH8zt7hwFS3agAeFG6BwH/PRn3sG/uPSi52d0qB3Hp1Bxnf0w9zTEv+ahA1JYtCNMKnxBO7iZm6O1i7ElYw7sdiVEBm/yL+7+DUknwFb5l9DtMq1KayyAp06RZd6c4cHhEMcudUn7sbj8q9RErmxOKRdccqjT2mURMdh3pVNCzn6IlHf8Flc4LoT8GT+elG81hsfCesTeFkKlARqDswnH5y1UkvqkQk5pa9rm6OtxNKv3Q3UpGmMnT6uu+cBTa7o1tySxp0ojdmEAVNdvgaHLLO0OXcLyGtrvRIua/8Xa78zxhhzuVYj45Hk7vjDhEBj1aXP+CDEIcd3MR/2de7JRHHmz5t4pBuMi7vZoWFUT1O1MZ60wJF/DL9l0HjJijlMMmTPae31C0++u76saHQilAILYkRMprSRzUUsta2e0u3uPp4GMq0ZFwZsEATmX911txQgNMxrTDogRbUnaqQuEI7IJ0CbuUwVHShPc3lFVeVG7mbhwKhHmLqBFSJUZggVSO+QUy0gxABKReFN+15IBR3RnXmWDm4dZfPdUgZwxpkMzTIwiehCUiuEWXCcEHvsyAHLqjWGDEB4A6jfomKLWzMopYBTJsvxttpUYIcCQrNqMWETzZNU9w1//q9e8PcM4Lvgt3bgVxL0lwJ+FbwS8BcGtm/A20/A70Q4fmF8L27yZhBvoLJDasXbUfD97DjfTpyn4g/b7qJ6mVkWrm7E4sGQh+gBjNxA6BaiwYBsKAXYS8O31jW9cFM3qn6qLxkLoUpBpReU/RVFOo6j4aialahzh2w6FqzZh3FSA/UHGAWNGL+2VzzeHziOQ+N7qqY2FRGQdIAZIqq/lxoeXegCHA3mf6PxI9LVotYaowlpyIlhO7eO0k+gHOjHiS4NnQlUGeWVsJ0EwgZ9oyFWuAejEfxYu1gDg44ThvN/xn4KHFsXhReNWBF/3fBluKDYZ2VQYUtiYO5Re0V92bD537ZjKxu2MrJO1Vqx1apKrse7EFQR9/aGFyE66zhbFBGi8+lSz7Yp1HrmdfaTw9EUQ5kgFzjU/auIoDkt62Iun5mOWBYODLdDsKa+hs2WmHUlBAxCZJLzGDXtBqN33+Sw9etMtI1u6Fhk4vnjWi/uZPGJSkeZ3bJlLn7OKJGEshv5A7iXSfR+DsyECRiUBDPHi/m9tU6i+WnIzc9eWITjpDfMrlsyv5oVlNh8vsq4k4VzPLsZmZtNrDEgSyxk2uEYsekyv5KrSrDT8jv4n/9g/ZHrm68nguX6le7evel5FmADsFwhzYAijenUphjeLPRrBVvSG2lQ5/DLFDgvCSdu8CDTQm8jymb5kJ58B2ahfxKy0wuidHSR00Hp3qpjZTF63voyFe0CBwZNnbqbKx6wTlnBRtWDrnIa82kOBauC/+l1s36zk8lkwP6oigTHPX4qs1dacLOg/UVKj1w2IJs3GKV68jpFJemOJKAyYpPEOXkfXX8g61SmQRLAEKuFQc37w4+LugVWOkAmhE1U3iqUXKczah+ZuAeTKjogDHeUcBOfirBki1MFeTL3pKkfUIZkLasQSYKcxq+DNY1u0XMQS9FsS60IatnQqu4s1wq0ruldNUNSg2x1CP62GKWrdYZIXUOku5AtNiQEV8rggfJdla8YBxsvXbCetcnn/44xMGA78h7YQXbbw2wgmsmrsArzxK+gn04IHui/nzgPRhfWsawC7IDsRvT/QsAbgw49cIzBoLKhbK/YXwsaKvqjQegBMNAC48ngsd+WGQbFFM7zhLQGP2sFYI2JqQCkoePUOZUOas3GEiZoaxB4xU942Rs0gxXjbKwWpfOEtBO9AcyEnRuABwQbGC8o5QU7CYSbZmGGWBBOB6EjlGdRdxmY+4+cNgeFgY1AxWOUNFCaYEJ5mKw7ejs16X8/FHMFIGE9vI21zyQnmMXmrkcc0ThwydcRG24Mdx4y/KaEOL7kyBIEeMYjX5a2dIbSy/bdAmsjw1QxixgxaiVstWCrGvD9UnfsddO/bcO22Ung245aK7hoRjcPzIi1L1Z/QmEVGBUHIB5kvTiEemZjZ1tkGw4QsxRYoDBZv20jQofOaY6lj6VYUBgszMjylMLPLC59wD8xePd5woggiZgqXwJGo7Jg4UPNRBNTJhJcsyX9uPzS84eKxcgUMCqYD6VJvkRosJ1VJvhoZC/PJx+NJMVkX4wPpAmtb5EmngJgVrYbSXlFh6lJr/OZ73RSEPTfWSqZxudGOkqsO6ydz+C6NLlWlGR3Z2V0X2QoG/mTkDzjbgblA3iewpmHA3laVwCWtm5+TqU/kjLvrq7C+7rH4HVd8fnGmSYJ5iEver9MdvoqWIELVsfkOuif97u7iflkeJZ1gPnrihOyvke5/97oqp2NOvM45vm53KWbex9QiVvczs8nnF6x+xm2z/UDCS+XhqclEa97o3NEVPKCnpTXCe/9hijwHvYQCTZg8dOVIVTxFTXi64qGS7aZsRJAxTIWiXbJs+R4ykcAsUufBQLx4Nik9hFH75BCl2bzoKjPdbhyAJaW1QWHTCXuqbgLVVlW88tCPGx3UoW+YoJ264zzLEDZ1Ke+C7baIb3qmQ6lQqpYncOQLqIRGkx6mnU7SVPj8pjcbMLrPr4FoHMgyLSqxVFIog93VsyRpcDGmNw8plYj6S57FTSqOMwUeUjH2WHWFx2PA4IuDQcLTu422kNBYybUytj3AtkZ8o+E4yQcoq5SzdqMDhUe4+SYeOrJ62JbNaTmFwBqBTlgbmqx0+xua2qlqKegkuBbBWhjoLN+Psyq0AVNgJfC2Iq6vjRodrTXb4y/NMYvTDgAoEnA4gxVSmTo1eBl6M43GVK5IiddXfc6FxRuIFisgM1bE4CbxGFiqiQQ0Cz4vQAQBktVfBXB2dVy5rO64nTgCWa67hfD8VLg7iQERPyTEiEnKn7DXKfYLRiaXapywVYqtq1YCtsNe614rRUvtYaysW2eynZDqQVcSC1D0MP5CDLWMdLaMaYV97oHcy8dl0Ewg5naOqG4qX0RyjzKxtGtmy7F2FwP4UKCAAVtoWRp9DVCmsGKzA1CwHqmkcHn9MZdrHRO0/wYqMXXUxJoBdDYth/X7aU0yP9GmnDHZ8UxLXsrWFx4hCyPnFXTbWnHu9tdv0trrjrMbSufm4FUNJgtMffyDl0EqVFp5oGrUJNwOlOLJDBOLGUdrsyTaLm/AjpMG+Hm7GxuFhVvpKnc7p0sdpnGZwXuyj5pK78gy+8kvcsK2x0I0/2l4DpWGY+mtmmCXcbXxRr2jDPM7dwNoxa5Kz/jzRCcUxYr7xb515sxz1LugH5uXnC5N0p62zIxujEsd/N814dUTNJ7tJTLY288c8KRqejNaCbiTqPgeLZqtBmvouzau2UN03h6uwQTfg3pmGaeOfUpjS2AcJWI9Zue+ZkHX4gG/wPpbQEPIsrwZ8Y9aBrBIsMtHkLv6Sa2dcoUDQgsc5RKAboLaVYID0gRisDX2OlHh57q6964xuR9F3MCfO4HO+PJuNPH94gOYa2LRXepawVqZaAVNCmo0iFS9SyHXjSrUh1+tSQqSHaROCiuUQMJ4RTNouQKRIf1zSfd4Zoy0OjI+yxIGvusdAzkGuNIsPgAjMO/RDS+pkOAImgEPH4F5FfCcRBaEUBOcGXISTh/7+h84HwBzl8P9aF3BZI6mE5UPvRsiT8R5L0Dh4SLlIhl+SHziSmb7uJLB9UOhvniw1zpfDEQgbrGtrROAFWAd1A54cGZvQHtPCDn72Bu2KmgcUHDgVYPnOcJ2KGJnRhcCHtltG6Wnxdg/3bip98FbyBwU6FTNbGEU8VWAHVLXCQad2Nwwtw4yIKa2a0ZJqw6IZXCEK5hAQQVEL2C8ALIAeBQ4d60FxFGB6GhgZqEWV2rE+SlpS1QuPw75RpeUNYbGqjmrlOxQqzcOIvA3VH05O9a1FKxWQzGvm14sTMzXrYNL1s6N2PbUbcNpZTIHKfmGVb6UMx6ZdYb9A4/4wYwRa6vu3VjPQdtIjK6olEWGi9D8BVCtsb8RbZx4+CcFoehwIwxkq60tLsFyDdJbA7Y4dCEEE4nR4aqQRYF6lrHbkWNWCSnF8ZoaPTuh+fUJ9emuERF47nAFeJJGP1EW3NHm65PxjRo6lR2FZYQuPM0gPYSY0NPCl4hiOqfCEpPr2eL5fYGLd+dliTRLQmJz0S3Oxn1aZP4IyNwrSIEMVpv3rz8bOiucu7iogRzyryb8OfQO9Y8L5UBy3N8rT7m/gbOa92j0B3UDphXn8/GnXSVO3jDXWcp5b/9UKr08qVPuUaBynSXA3qf1O/fbzuWb5lsc1PpEN6f1EPpWZZlgxZfN/g+umj5nEG6PI02VsiXYb1/IE+H5tLihKD2IOaVndlY5d3kAvPkEDGvIVa5ibmCy/ZBq3r9gWBw2xky3t11y99lGM24ZPfU91ldiWAyBRvDV5psy4fSsLbBrHVuXQvL06uCj0B9+LVEsU0C8dgUFQJcEFtmzS0GovKUCpGzbB/Wv1IswNM4PwEau7FVPQ0d5tLQbRe+Exo19KrwkAiokR0cpxYBnbSmu7V9CC1oUJ873/6EAA+KIG4PehpuM2NJhYYnntEG8K1ytp0+Vc1UrKn2Zve4mA3gU9B+EbyJQBqhvxAYTV2jsKFUBr8LcBw4tob3twPvR8d5ioEgQGto/YGjA+cvZrWhjsamuHUK9xyUDZBXyMkQOcEvB16+dZRDgGOsBBKgEuGlALUKyoMgfcODgVbfgWIuMoVAOCCt4/14xy/8irfHC97bgeP3A+fR0M5ufa5oVNC+FbSD0Q6CHMD37yf+WgRvzJCzgaHpS4kEOI3QNgFRj114aabk2Y5zqaqUng04O+EAoTNremNAzxkhYKsFHZuOS+kg2kD1G/r2ilN+B3CgSkEXhqCgFw0uYDzQ4Ge1OBsaSn6K6zLGMDMp8nugeKYBmI6bqtjoeMKIkCoZhd1lyk7+ri/Yyq5uUxtbwPdmz3Zs+47t1f7qjs3Ghou6M1FjPYWdnHEajpOt56CIRQPwSRCHh6cOqaum0YqwivaxFjAIqVMVAkCWYjZimwg6t+6wRbYp4U2F6QfDPdJph2h9gKhllqBZqHx+EoweUaInibPB1h1sc6/yXXn6TK75ccXBkTnjgWc08DnLUsS4svBxL6cSxi70WEshKvo6+wxGX5tz5Van1pDrDBovi55ygwvTqdTBP1O7U+Hbr0m4sE/r82XT9b5r43uGPV6lqbDQiCvMwxBfaACe5yduJ2HZLZEuEw4Bca54WB5uBMY8piut9MdGDMUBCoKy9COPRa7vdv3KpNisRW/RBXBiOfi/laYBzgR8riePm8fPOqWNOuCbPGRyFcW718vxNzWadr0TVkOSAKtjKvE9rba56ruBAU1rYkT4pYGc1nReH+kK0NIkLLgbCzfjxbJUroBPXUifN4VoWT8JblreyDBlN74JTxZ2EZuPNziWZ2l8LskgPlr3BPzbf/fv0M/jeSG7/ljWqWDcCn2cxAuAegnhXUgPsSOIarps7k5xnC4FU40QCoFaNgpUQPfRiVnwL56xiRIyGZNu4s7xtqmoQvM8OgJpgpNtz7Kp/73v2aqgY9Sqq3DRUPRsEAClnuiwsz2MqpFYgPIGbM2y5bCANwLjBD0ERBWEhsN2MYkYaILezK3KFQbv92E+4Czhdugu5CoXrYtaBo8AANrAZUcpBKYT7dFUZCNNMSpFA6B7Z3AllBdG44bv0iGsAevcNwgI/PIzyvYTuB7o53e079/xvZ1oB3CKBnmXUkFlQz93PI6Og7/j8fYA3hrk7ABYg2GLHVJ4vKGTjiWKphPej45qsc+qKRaAKqpseK2E7e87yndBe3T03vB4dB+McH/pJ+PtLHg0wXGeeKBBHnp2QS8MYQZ6Rz86zl8bGgoaFQgX/H4WnK1pgiNTQNnisXvToCdN76pwAQTwoYomA9wY5VQhuhXgrSuutd6AUzOvlcLYWPCKE4/yjvdyAs3yB2/vkD8B7XtHOXcUk7otuZodzJAYcGAgB9rMRJfmr6uQ4UQpTB0mnCWXPt25UHzlUlC4oO47tpcXVST2XU/+3gr2WlDrC/aXn7Htm/7Vig0FWym66UVQ64QAjA4qPQFk6y/650HVPXrVl50D/cWmHwk6mxAjRd92xpHcnZT+iEv08LTdEFILG8FcoZaIkFBIXDnQs16oJ2JomwIKVTcPtGFxUpjVytdjfKE0RAG1+CAlZSz9w0yTPy6YolH00FNTlKWQZrCjBfHl9ut8P9AmiGkSmBbBAIa6WcJ+dmUB5Zl0i3TLcVeWIkSXDbTpvUsdycUlPmQplBtcxKJJkslfab2Vqhwia4Z7EC+CH6iZmpzlvbXiCWQXkT+6cofX8R58NRdd3w5LNtF12nB7Q0FNbfr7mW7PTS51XKpLjN03uAjISHDNT/SB5Bs6xJTiYCgb3kD2r1mro7sfTwYx98F/Jfbk/HtaYQSsgfMOx1XOn2ZK73+wRu5X3brIcrs3b3xQPIE6v7VM84o5voks00vPmrG1tbriBWj5/s16vixuz8IyvACG7KBflEWa3Guy6v/yv/yv+Pf/9v98NgxxfV3RcOJgikI0CICgglrEeIto7C71ERAeDtbG4ImTAK377SgwJi3qKkLjlHGVQywY3DLDuJsKYFaBIh4XO4jzZQdUgNJR7BRmlm4uPYMhqRAk4JOAQugMUC2gncCNwHTo6eBmgRBoPYUIlU5I30Aeh82AcEd/1/1rBuEk9XMn7mjc0VrT9K6dxunpAusLWZB9EsBsUFjcuG1imXVaHW521PIN20+E+vKGxz829PcCqgz6aQNoA53FFA/Ct28E1A45u+U6IjSuaLShnX/Bn//89/hv/5vvABH+f//hwK//4dBsOwfAlVG3gpdtw8+84+fjDX9t33F+17Su7lffiCDo6HKC+qGClp1Q9nhh/PJnwvvvGssB0R3KggreNhQW9O8d7a3jODreW8PR/HQSQqnA/o00dWpnPc+iPrCdDccmOAGcKOgnobcDrb7j0dR1qRgOa1pfArGgbASchBZWJZcSBSp4V6jA2VRZPQ0/KqEQYVfdCgc6cPgZ8gRqhMaCd5w4T40BIXTdXX8QypugmMWg2sLWjGXAW+/4/tDd8Sx8kgu48AWYKIlAz3MxXBo008lREpCdWFsMATGBigZ9Fy6opWDbqqWvfUHddnWZ2ipetoK6FWz7N9TtG8pLRa0ax7FTRbFT0DXTsZ30XjRuiUSAkzVmx9Zzt8AgYc0yB8totx6kpjI+K47ZeMLO4SngOEvntBQQav0RlEFFNWbCcE6cZQv0jB3W8zGGt5e6sBlG67z2Ard9kC1PKh1o3UheGmui0F7ZGIWRMm1Z7IwSNrrY1YL2Q9V4fjEV+LlAmm5ZM+oJKe12y5LbwH1X+l5EBK6uTndllp9JOohHND3UW5JFwiwIyG35a7mP1BMJYXQUdCFDpkxbQ3mR8Qlg+EJHFBPcmn8RWHIbE1BeJ6V7LmjnUVf8p6Xe6AJBNxQXPyECLJA5M8W78fIKzeUxtU3ZbBTt2vhKvGa1Jel2AZQMRoLzX3sQY2+FfUNsBRXLqN7GcCDBKosSJpd/hw8fLe9alS6Ek8kXkl3k1nYvgN5eOdZnwtI0mcvqGOvsTuH0395ZR7F1XFfg8u0cbJfXVF4jGU8XHBs3ZfDUKSgnK7qJ365wRFWjzXUlyc03Xx+X/kVTYnO5rI+QAfKVf8fk22W8K+Lb4I4N6n1ACHHdwzJsG/hTMunXH7ZoqNVC1Pzp/uhGXPwESYbGNXSQHoZlUZgCpfjUdHF6/Ab56JBp2CLBJAQEaZ6VxuiKDMEA7lJEmn0kRCfH4ZuRcO8kKgCfhKZOQhCoAsD91DIMCJEmgoKAWeEorMea+64ZFfVVKxWx0+BCnwZ/AtXgL8TgswHU0Fl3sgm6Y97Nv1zASkhtXJ0kjqClDpJ8NontihqGq6DSUcuJXQj10dGJcDB09/UhoNrUfZkJGzG+1Yr+UvXQsPcGOtRNpYHQtwN/2n7Dv8IDXA/8+ncd/8cvoq5UVYWiwoy9Vvy8b/hnOPF4r/iVO0j0EERijWVo3V2dfDtJ0/s+DsKvvwje3zXIXvvD4PqKsv8zML3h5AdOeuDRTjweDzzOZi58QGnA3oG9EupWUA6gHpop7L13vDVBPzW1rrCgsVprau/YiqC8EvhPFSSH9utUK1UTdbfKGZEEHeQuVYcFARfSRdkNluaLdEOrFh9iBLc1Qjfc6Spv25kUFaXs2ASo6NhqBW8VJBXtDehvgu/8bjEMlnnLEDoyRTlxyrsSdp/MYqFxBhTr0k7eCdyZgmqpaHYpLtgsuFuDvCvqVrDXit3S1tZaUbaKspU4W6PWgroxeNPxa8SahAAJPFOGwH2IAgR0y8AluAkCt6uTnqOhmywCNNI02KIHUYKAE9CDIaHn5DBSOIggFHl2wuHuEK7wYwgSJzpE2AQHMiKiGcWcDkH8kEAGQ08713Yw6FOcKaN0skM0fbgpkYjkGTZ/F8bx4/LLLcTEbMkKVNnvZClukxh0fTfJLnc4Fov+poDLcosMs4gKsyVR8otWIiSTpf70XtB+uTZLk2KhBa58b1hlhoy1CLXrL0ptydyXSYRdgpcnXJ0EP3snCWvDWWct5g2NzghdJ2gqm+X71M/LG1mTycLiJK8NC4ZvPlxUU1vrSjLSU1nGMekfgx6PMZsVh9HGikcrjHM+IbsXMsO4O+lpCWbA4DbFw2lx1JznOqGrvjd+hqJIqdWgow7jYt1a+yMJPycheJS7+z5NsQ/dE/S7vHCZiydv5cFPuD3P2yga4zhNzPigVDBEuIS7E07fvO+PsxVwzMeF+sx1hUvkUDbsTsjMnoE1Ppnie8oR8yFdXa8/lt6WyTJDKXRirkVDkR/AjxHQT7KdYEVidxfIlVN8hbk7kQsPMkbUO+sDKC6FUB5UGVhwMxKOCBSSge1kCsMPDvQTfDM5IFJLCAoDom44whrY22tFg56UiK4ah1tkqu1KM8FtGhBiSGu6UxrZhLplveoquHY287JEV8R8Jq+nnq955RqkH+iHxo1IN4GYSGMg5ASxbrsXriivFcCOTh1CDwhrwLE0ApoK9b/JCeoPvJ8aLj+vDgZxRdl27N9OlL9uwNHBtaGQaNzCQ4OxKwi1aIBzExtDIvT3ht4s4xREFQ3+Bsbfo8gvOE9B6weaNHQ5IM1iFboKm12gMQ2FwRuj/Q7IJhaU3jQtlXQQCipXbNTBvaEUsVOFNeOTMCyA3eNcgBGcpHgu/bTfKjYTCF1YvaDgu98FKBVMm+20qyDNnVCI1WWrazWFKgrtYHkF4YFaDmwbg+sODTIGyncBqIPVmQoC99hR3BmuPbreSHOljh0Ocp9/IxFp5zaKQMswsVndCioztq3an56JsdWqJ4HXAt4qSq0o24a6VT0IkguqnRjOJVgRCGRZ8tylQBei2I5FDoJWwIsRxR7BaBPWkwdW628BdAPA05uJzleQWycP4sRZwmLV3cIaHEts5Vvwd6w4c14UAqhC3Rm8H1ikHQL8QCODg7uvF4RV1mPkyeqPUBNf2z8UjaeXCztkluLC6qonpeEURiNbZNmfPwl0hCFI38qm6ZKEZ8HqaDwTqIfjwt4xirlAOgTdz1oeYueg+VcVAXgSIXwDw6XyWz65Ps5sfXr41bbuXqGx3u7Kq0XfxmtV9rq38gSQ5dH0M7sGLbC5NzdPc73O6AKHizdfuJ7OwR+4Pn6F4Klnkyz69D1acP/5GK2fuUWn6elZbH7JRShd4VASPJhRlHZ6TWOdXq47of4ri/nZ5TJuv5Mfr5V+vIToCRw0fcjdM39dbkYvE6ApRmutJcnrcD7v91w7kZhnF8U9k238EcDm4VC4oBTl+RG3+Mn1ZUXDA83JNFU9gXtoQegjdNNdC/xALHJlY3QVeTBNrBzCDsHcFXQgfPPQEdDdO4TVKgKBWTvGrJFxjisxThpkmiAyBUOz2+hCbaS7jc6awqWhkJ4m1nXgqRf0DTit9zDLRj0t8LwpjA1AD0WG4TmyW7eJVvkR/lOFEh2dCI21fmq2qOiS/gkhZ8Q5Wze4xZifuqeAoD7hXcLhg5jQG+MUwqmJtYbp+Gz461vD//b9hJQT/+kfO85HD2uC7gxL0H1+JeCNgO8EKoTKKgweokrSVoCfCuMUxrsQTmaUF8L21vGeVgSBwHpuuebJP1hT1DKAKuCHKxfqmPQQAZoeyCevGj/yYNUxTouHETQwKl73ip/MfauRWi38wEkLy1AwSEZiDEev3jU43AR6J5IdhAeReu6TBoF3UbcODeLQdfQCwkspeAOjk6BSx8aESpopp4PBpJYmtmxhUou674EBUbe5bu5Srl/4OnDyPtaTrpfxqUqprimJZ37eBxGrolGqxmUUxmbnYtRND96rmykaWwVtFdg28IsqGupmxSh2sB94+MsyRoA1kRhDlNGBRBTU1YvAJqgLJpoKQAlYsbXuVsDO6qLVoZPJoKClXM0VDRSCme+gqUCj8EyWdnJZYigsvt60N5qcQmFw4sIj0ML7CE2awZODsltXfJexR1lK//6xfCd/WxeT0mVmU5DNGueHk7oS4m4uIbH4rmuWYGb5Ztyi9PBWclgk2knAyIzIXV+8vVsRL1d0bWPScqAbMw73+spF4Bpl1z1mWj5vtRkbv1GlpIIjPcVUx/WrwRodGG/kQrl9uRn9mMe1B4ke3gpyemdeU0uJNBghJvtc3blJTK8NwS5qv5NFHA6a+/ek2GjB6baP2o0y5bT/vo5c3qlN0jZWixN5SW+B4ORzrji3jnjv7prRctBi/XlF4ih/wXlHxqm2qTvp7u2d+bL5ncxhz2bmbrGt4NO1yEJjaPp+WYWpwoR/MQ72RqYjlD/vRmHI4jHkogxSE6ikOZyW18AFmLzwCdbG9XVFo6g1w10OWFTg0125bjc55r0Z0xVBpIwk240Xy7jkJjv9G6ZH9wWzfo5hMsbuGQu7CdXU1Y0LMAQ0K8CacQc+yGyiDnHEjZBJEwxRwQglHZBG6gJkY4yqggRF/iZCA2mWIkuf5SemV+gR7WTEtGluMAAnwCpIHgI9s4FIXafM0sHSQay7uAI/21tfj9RwPXXNiQTDBNaKQwhEJ6gDXCu4voCrRuGzEAgFdBLotwbZ3nD2A2cXtQw024GuBb98L/j1BBoeeH8/VdE4ochphxD29o7eCP3tHSgHQA0sgnIqItOpiFyJ8Q2CgzoaMc4K8E8FtTeUhw2PLQbi7yj8n8D1O/B4V8sFbxD+BnrvwPEOIeBsBDoExA0VJ9oDON8I7/3A+Tj1JHJSbY824OWV8PNBOBrwvQtOOsD7d1Bv6CejWeS9z0MXz2pGdm4LDZQ0M1srjIPVXbALoxsRoFOAs0HsJO0dFd+I0WrBo58o0rGVA2V7oFdGawyWV2ydQDgh0tCOB0gOgDR4nHgwdSUyPMUjDZcRQhyKCMxmUTZk8vMxyIK+mUzBKOBiJ3pvFdu2oWwbyl5N2dhQ9h28baBN3bxqKWrRqMXOzSjw3QYBUNDH2ra1JSgq89n6DQte4qni62BZz0WA0o0W+BJoiAxrgLookUBTFjMgJBHbEwIoubsTgWyrxOltDg7WmZcYQ5ASOz/d3APryVI6u6Ci/xscpAqvdAJ1oysstklgfQ+GTxYT9zWC/rd4cYW5yhXNjFYUh4kJVM3y1Ow3PPuXcpvIgDRF3F8VvVuRdBXEk65Cy6NZ8JTl5r0UeqfOPMWCLHjdF4ArOZ/JQQCSS/Qsoq2Cbe7LnSPFtAP9kby2dlbSH5wbLIKTx2mkxnITdFevTcxsGXUR72Z8LsDfVBq4k0YqK1hJllnrlg+q/eiipy9Q0My7joy3aJqcQePmsqNG/0ZTgRnP5QkWXJ2T1ovjn+xFgoxeU3+m81PZYZFRdoF8Ano1i8S0Jfy6nTRZXrvGW90qGT7oebD8kQR7nOq9Akc3z9Yyqf2LsjHP04RwFqogsGQrxozdyu7DojzVEuqggHrajf7k+kMxGprKc4BMwMhPzh0o5hbVLeySjLSlAfbf4pEk3TUowDWqhmGN1APFVRGI/zogZGkxsyUjBAB7t1CkHfVLU3W6sO+96MbcJblumMuG77ZogIUupS4oVMy5HpDCqCC8UsdJJ9ppXe4AFcHRu6ULZRXuidSycDYQipowIgRbd+LOU4Pje9fgaEVGgjRz22BYQKvC7i443FX/KGQ+/3ZSdX8IhCpeth2vLx2QhvMEemPUV82OhfcOeeuQE2DReSxFIFVjB/h7Q3tT9yV51x1cjZ0RkJzo7R2/9gbBgV9+OXH+1tFEXVKIgJMUtoMIv22C1hqOh0COirYzHpXRiuEUCB0drf0Okf8I+nMDvnfIG6G97+hHRZOHTq/o9HDroEdDowPvAI5T0N4ahBuo6BkHTYD+ILTfCf0b0CpwHg3HX99Bbw14J5TCeGE9yO88BacQyA5aqQxUc/TvAFrXgwBh6WtRdTe1tgJIwXkIjocA3DVbVak46473b0B70zXSuaFvgrK9ozZgbz+hbq8gOQE5IP0BOR+Q9gC1E1JPWx9kmGr4bJSZ/Oj3sFRouTCHEkUZT2lbiVGIUUgDakNR4A37vlsWqYqyF9RvuwZ57zvq9qIuU7sGim/7ZspGURxU0oQsNajli0IxVruaBH0QNF3frNneSMzSSFfvBOlD13YXs0qka9eDhJ251NGCkwy1IfnhgbZnkhiEvqu0iUCacEJMIWq6xjVo3S0oaZfRDzLtroBknqNkm8yKpi6RPRi+gBA7KkyYRagfV77+p//P/xc///wT/uW//BdDwWCa1kEo4wBck/MYSoH/o9ckwlFm9UOQCfknCcL+brCQpQwA24zUFobQkHbXsywjMxzx1YVCAvKJ8RT1p1fEMd667U3Y2h9C3SxWKt5TElyu4I3yqwAmazcMWEzC/5DNCfkQP+/j82sVFp1PL3rbKpwCRm8Q849cZGl0Es9MBhn1zGORjDOwZmY8mUEZZfKzpUD0YbkmJSIpY4EYhoRxBtedXJ3G2zdpUpbvIdZSegewne9By6b+rDAijYtNWdST8IrSYKz4PrXh+Gs3uzVEtDyfq7gd2wyxpM742gASvN7lLFTTVcYOfFnXyjTBcsFtSp3OMEdyAq/Cq1430KefK1KN5xM+5++Bu9pRz2rqYxE8idQTByggNg+LL26A/fFgcIGeCSDpbSJIK5GRyt2awAQ5zHXIfYE6oVfAA9h0IehQehhHXpzODFwZiRgW39zvsAPTXBDRujrUfZ4XbIgMV/o2wAKysxjENRy/crKXjChMKJVVSjUrxFYJkA7GjhMnSNQqQR2gJjiqZR2C76K6yatDsJmx5gRxQysnQBX90GxBetidhLAC7qCmwy9G1rvJJb0wKrO6sHyrqAXg88QBwYMadj7wJ1N03mvFgZ9Qv/0E3t6A7+/odEBIs2jxZr7nPzG2f/6C7bcTx38sePsHhnBTVy+yg7LqhsYFvzwq/vE/nXj8VfDQo7jxaFaPAISOowna74oXHYC8nDgL4fG94TxEBTcRdDnR+3fIm4B+A+QboR1AE8YpHWc/bdfYBIuXHajfcPILWn/glAfapkyILedMY8Eph6bIPRva0XGK4MGiWYtqxc8V2FvH0TqO3nGIoHRCKUCVjlciSNXTw+W9g7ug7wBeVWimrtm8ShOc54F37qjCJqCeOLsA3xlnNyWzqfVJ6AV1+4aXnwjbtxPEG4R/hhwHpP0CtAMoDGlbpI8mQAUGdyNEYhZEEaPBxODqBwAqF4oME1DltjBFXEXZhsVi3y34u9op36Xi5UWzTZVawLWgVD2grxTNTlVYg7EHTTSiSa5O23/GgTTVq7E7MwxKHcydUEAQO48nL1Fz/jMJw91r1VqTnAvJiEcH9GRyS0ogZK5xXeOnxJyXaLh4hSDTe5wVJMJDeGNonJbRKN1DUfGuOw1LhJ9AmjwCCNMtmd/hsPIMd40cK/bjul7/87/+1/i//Xf/Cv/dv/oX4UJFflZLdhsM+usC4bCCOWslk2QCy2SsqYu0knjDhU2kAqvA4K1dXo55lun9VHMS/NaA3Vm6uWf/KfzblIyLoOASjeNfrutGRhnl18eeHGH0acRWPpHSAWQB+Lkke1Vj/PsEQwhQdCk9j/OAeu0rYYxaqE93EvVU1aB1a5tEN9AHUnxtlbvwKwl3xF93uIdkeZW8p0cSn7EOEo55XcOCkkVgvz/we8X9tdHIYQOkdgYc+e0hcmXx29fRgHw8uUlvcIFn1DCKWE3GD7N1xyOKsy3ndtNnaueZ8H3zzAVcjLVI1vF5pKPQRfmPejIwPnjT+k73F8DHzPo9f9dXAEUsre7qMqjy864u15cVDYFnoTGAjGfrjqyDM4BSfxZGad0PEdRnzvAh8PM0yM5OcLdmYBgiVGAyIbWP9gaBdkEyD2Ra/xc6Kui6xagKBtRCwQLdVXS/reEF5UCoZcUYEsz9Sv3kmwZvnx3MglpsB7apNxl2DN9gu4jUX5ukqUuTqG/xiUNhqrqx307RAHPp0acGgHpTYcRwwb2o9LwDFQZJCjoJ+kbojw6cDaeceGwVzAXUNmz4CT/9/Pf4+7/8I9o/dHz/tavIRYJtA9rR0U7G+b4B+4bzLxX9O4Eemimng9Gh53Jgs5SvB6kG2FR7E4vNcAuXCDSOwuIb5E3PF5HecIrvNGqWquP4jl/3B0gKvv9fBe+/Es4HoZ0d8jgjeJ8Kg79t4P0ncPsGbr/DcgShHZoetkvTjFbtwLs88I8EnAI8QOhdM2OhA402PKjr4YsWvu+I36njUdRV5jwJzU+qPwF8t4BwZmhgSgO2E3sXVDAqBFVOlH6i9oougrMJuBA2Ktiwg7cXyItmDPv27Wd0/AVHPdDlAP/+K/CoADU7abwZoSL4SdqFRAUtQsQQE+lZJ9xLWDhA+g6zWvhKoXA72faC7WVD2XaUrWKrZq0wRUPPx9iwlRqWj8oVe92wW8YpKh4v1DXDksVciS1KEQ4lQ5ygiOWR9ehoX8isiQNGgtJ8ke20DK7u9AJdND1u0KaZmApZNigRs4BQ0BX9qQuLBOqfdTY9m8HojOKLxUG5m5Noyl5VZRrYrRHWjuJ20bUJMQVD4e0gdM9uRqZ0OJ3LGyA/rutFquzBlAu3zhUmS61cQKTn3aB1E/jUmj5SndrnQJLnzV11gPRlefmLzDhf94rLtQRd/r2vxwtk+TMrCOu9JEkOnnpX5weDNYswtw8/7NvTgYsp+oPj7H3Jwu7y6p0ykJ4gPwk57AmuPGtjaivpXJeR+ggHU8EQg3Ld/bbocgUlnPw7Pn/nawg9WS1c/GFg+KROYMwNR+zUxzgAQYpLvEJ6d5emEtc3nRU8xWqafk1W9ltoM46Y9Rs0z/0FHF/4Mn7mv7FOs7qlJaeyk8a2QGiFwuBrbzvv8/+YNIvfBkYlTbSxc8VOG5i+lgHhy4pGh2bAzDAT6cF1HeThGfDsKxA2Ii5g9x0XqGDhu0TdGHwhjLQCyrvVh1oA1qw/ZH6QHeZLbfWZLDAjhu+CrhNpIKgSY4dpQRROQew8erKBwA9fxBb/ACIQOqToTjGJgCtAraD0LSZY5SVC76QJj1zAOzUrThEB9w4uDdkvRIXGU5GyNg0+jiRPGj/hGC6i8EPstGpy4bED/YA8VLFqJ6Mzo52Mx8Gom7nI7BXf/u4Ff+GK314I/FDXtNKB0rqm3eU3naPzDefjoUK5KXgCTQMrrekUfuvqwsRB0/PUx3g231WQDlDD8S5oXpfPkwCtNfz6Jnj8X4L23vUcjBNA10P7YqJbB44TXN9QKlDbO3ppOI8GdM1m1brWTyJ4PzsO5uSqovjIRdB6xwOih/QJYrFBOlrTvW8B0Luefg5oRjKh0/TTBkD9F7ls2HCgsqCio3ZBFaCwaLA+d5Qi2DbB9tpA3050Kahtx7cOtJcHCAfOfmpiAJJhEoftNPgaAJmSQSAa1gtmU0TIA2SNhLBmlmIuKBtFNoltq9i3DWXXmIytFGxlQy0VW9mwcY3MU1u1APGtYnthbKxpRn0n3iiCoXci0k4ACSrMeyYBIRP8E6ERgUgzJfW6on3+AO+b3pEsNIkmVmDAElmo8t8ApVFs1lAiO1hU7BR4q1vTiIV0MWRTg8fDvSzgn229i5jrlrXXu6DZBouQgJuOkEDTOvfNxskIlQDaD8+i9eO6vXQdKKPwk+w95miceu98huDxV4EcYeZYJEf7urr051KBewtEF6lDrqXs1Ut9vmZSkZu6MK8nUHgKSC6IUfYibtAVothOuykfu/t5GUaAuExlx3d9J9bBzRDEeRlrXy+SWK4T4ZLzoaQ5jaMOnHsAxWMX6CiTplSxMa48upOMsFxBHm7uexWXMhGDNgQXWl68GD1oFM/yCt2Ny1Rn6svSVniN5FdpLnN3BSY9wdupLwnZ7wV6zA8owSyjDwEvbL5kViWWAZ7na+mgb8CtbY8lNl4YpH9YQdc6J/skGY7b6sr9zp934xvzQgPnxgNz5/f59oIweZUwKxuLBTPXN6ybFPWEEw1gNBXqXm1yxVevr6e3Nel7GoyOKdQh8nn7KEpi1KZgSBphMWarvFt3iZ3KEkxwdqwiqDuWuy5g8I1wnUiUVxWHW7Ku4JmQ3AnjxHJHUkn1YCzeufcMF6NduC+1gBtsp9+sJQS00+QEGQOoZ2gUlK4nGHfuyigFIAvEhkCD3FvTMeqigour3KZ9ifqswU84V72jASq6ozcBoYC5AFQgp6WUZT94bsM4YdDHSINZe2s422+g397RHg+cv7+hnar8CAToHYIT/RD0o4O2DqGWgvx9UZkfqCuBeWClAU3jOXy1uEuYCHA8GtovAjQOtyp3t3Nk6l3QjgeOAkg5IMeJU070o6GdHa11PcPD3m0iOI0Ss8Nj2mGzE7ilIwS9Lgw9Ad76HD7eJvijQdqJTha01ArArxDZ7MT6Plw5ukA2AXpT95wCYOug7QChglsB0Yu6lrXv6OcD/XjAfOgQHvtOCEiVQzJcJHYBi8dzJvdqtE87M6ZowHateuq3p63dqgd+b9i4oPJmrlOmXJRN75Vh2aiFNV6EzFpBFDM00WKjDUM4GZm7lMENX3oNSNN++2vTUp7WJcHdXsTWqBNSjbEZjCqv8yH4JEeA2HmwQRMegkC4lgzaRFBr6MxEzDWMRn8GYfdYEYk5HYKWw2bwBWQ/rqcXEToXgDdNCFE29NJRuFqmQAE1RjjArIIc0pDfXbERNt6Y6krCzAcgTn7qFwAusJg715NC9CnQT+CIzxsx0IQNceXs9j2JfxMJftqXTzHXXZQjic0XcZ2WLylWU2/fSLHL77UK/ToKeUzCzG2chsESs9xPw7UXH5d6hpefXkbwMhq6IDy7bN5DQqOK64PLm069nlOkyY3PBN08rRET8SHupp3yLA3HOzLVebv8TCjUAOfk7jX1K1e+9uP+GvsREkJ4Jtlrt6KrJretaHr3Lk0NpQ+6h2vEmQx3aH1Awa+EhrI/eJH/O+QyUsNwyEWF1CFpY6AyYSPCVgjb/nVl4+tZp2xrWniaaxAIBUnXGxLmEKq7RUXYffeXVT98CWuIpm21cws6EGYBIvdQUFgk0RSVLeAeCCNlnsM3T7sjhogKp2KnkTMQgsQd3xg7rC4a6W6lujRpJqytwtKaaiCxpvylyIwjBEgxKwD0ZHHqFYyGGtqnjY0FlKPrpJ9NBRMW0fM1zJrRPf2p5YpnO138ZMGwn2rmKE9LSmQC+wm0Qnj/XvDrN8L7IRanQhaA3vFoHcf3Ezi/A9LQjqZB1s2UKWnaz1PQvoueVcH63Jt3AdE/PShZUULnWPo61jZ/Jln2d4EHvruQFlcHDgD90AxOjIcGfjcxBUNT8XbbxSSPCYJEDM8wH2rsSLNt7zivJDvcisLiwoAuyAYcGEG/bHErJ6FZdi7e1IInLKDSIUwoZvVznNkfHTsxennBmzQc7ycejxOP1tHQh/uRkQY91sXWV3epl+MvdiQi+NtTf5olo1YUrtgqo5aqVottQ6lqwShbReWKwvpbU9pailtTNEpRJYWE4iA6CouGjVeDrrXutERpgRA0yURYWmwN26uMjiKi57tcOCEiBoJiDj1eY6wlhtIcRzGRIbqHbCM0aIgL/STDv3txzxLEizqnMrrqHmDCY2c41mHwT5neD7rknTKU83YoZRT7cd1fmtq2gKmCqOh3U7rZ1kKWNla3lfElSUGTqTyz8DnDTt7rXnednXUk8Tz9vik0i4u5ANK25fx+Kh9CzVQeg4ZNLxn9y+1kAuzvZTBu1uFc8Z2olZ6sfimUwJ0kUErzM77l18m75Vb+PKPJS2KZ4GkXerwmNgUy7t+JdRRiCSjNg+8se9PjyjAtFd1qAjTjUarrijM3N9e2l/lbp8+HiPKPS11ZsUgC61REB2XFqOmapndBgumXrzKjpb5YZbFKLF3Vd/MMSvrt80tpLVDQ/wvAn6EzuSwxMMWtFqPcjEu5GTfiTUs+erB0ysv4+9MSorloLne5Es6NIYhlT5jxLqOVewcTA//wD/8J/+Z//9/xyy//eNvKen3dolEIsLSRYN3FhQksFiEJdXtIFLRDzf/k5xL4ybzqFdjRwd377RYP7V0tHDJdd1d0WJYYEhP0YQfKAb2Y+4gVFEfKlejb7q4f/nU2gIsJf6YcaENOpByxbYI6AFZ3sW6uKVQ1sw5xQ4MJhNQALhABaq3qy3+YnYNKHLRGlppRektEkQEqGsPRk8UHmjKVS1PhrKjC0BwpfBdZgLMWEG8gqCBcANS6o+wv4NKB3iBoOLnhrR349beGx0MsVW1Ba4TGhwZDMyDfNbluE03H27jrKeOGib0L+tEgp2ax6Ift2CYGPJGVFHEVsjtiyMf3ZDnIjNKFTl/LZwcOEdDR4Tmh0VxYHO9zZsZpvfmf6jJ6SjvMAtf9/a6DLeE+Z2UaQGgWQEwq8BOA+jtONHV7OhtKV3xsEODUrF5s8QhyEuTYweVn7D+/QraKt9efcJwVj+M73glo+BW0MegoADRgv0KzjzUi9EomObs1w9ylAFV8QPpp7k1cLMB7r9i2Eqd7182UCtpQyKwXJR3KV1UZ0QBxT4PLKKXouHRYjIKYKyIBJ2KNOZMfvF9GUDTchQm6wqSDiSAoGKrBuDxei8WzXYrFVQhAHZ7a1ulCg6ORmEKkyqZSME9D7euNTImxdR8ZrizovIpauUIxMJYm0G0ghlpjHG0t8KyAwo3KzbLhWiYAGY6Jb7TcctUfV75UeXblQpXnRk2Vae5h6hfR+DmBmIU8i7C5wnTTWYF9kYtkkDfaBvu7ixMOeZauzwZBNJueWxemggOwVV6fasrCQpZ7bq+xKbDKqH5z7JjKwGf7dzF8TELeaILm+wkuALEt7IJbHuJBJ/Qfr8cFuyzEzS/MUFH6nnuQdTEyL4wsPIvBP73OqYYQeShkmakVya/mtoeQCtzPz0XGpXU8lncXIZPGdC3Kz5iHPBeylHNaGIHK9i+BEimWgM0/nwq5CVbJ7634TcM9T5z+wmUxWTpsXUl9WB/7huXYoHZXqbnc3KNb8JPLndyUHXjmbr4m1Zrnw7LOcrvroE20P43LzVqVpZxOq9ErGndUNLIBTwOlIuYS35GrdPMGEagQ/t2//7f4n//1/4qvXl8PBq+wWIp817vjZFgB6YxIaSqGuVx091J9ks13HB5PkBaQ4VAnAlCMcQ93EXblIUaDQDWNSoH6V5v0KmVBA4GducFgEHY7mU1PxG4g6mApYY0gRmx7yok4IFD7zQ6CIgUXMDUIq1RSbCZPNPBLR8UJOljHgEiPRGCCVFKYGKbEMegQNKqgxyB83ha5otMYrQHEhNYJeuo1oVSgbBtAu2KZaGxCx45SXvHt5we4N8jRIHLgT/WBv5wnTnS8C4BSwBuDS4ccJ/opOC0Sv4uOG09O46ZGdFMW045sYIrhgvMqXwDTDgBwSyTGIuo+2PdMo3UdR3e5A8z9aQxg+AInriRQnPBxllAyerhp5Z0H94RxH00AOr5doAo0oXNDkwcEv0M6cDTSzGBQRZeaq9yEvxTBzwX46dsLyk9/Av/pBS9lw+tf/g5v3/+C3+RXyG+/47ERqjCaFNCpAa2ogl4Ycmp/mAjFEjfoeRj2WUnTzZJllSpq4WJXLEzJUOWhYucNZSvY9t0sF+ZStVdLd1uxfaso9h/ZQhFSpT8EdKg1pb/4+PeRApZI8R26xqjrX1gyLRpGzyQpls5wVjSCfri5ouqmAWIOaQRcw7LUkcFGrvgnwi1NgYnYCovB0cFVBQMAs+h5GGInlmeTeJhJ4AQHo5OTYwY0ZFzP14mg5NIxshXruoqGf1y3F8GSGTCpjlcIXN01sIGLJqkYwoVO0ER+7qWj1EiS2PtnhTNsN8LhLGOO37KU/ye7VolqhV9mCXEiwkOYm4CbXDHye874Qyy01ymqiXWEeUhWkNZnU3s5Y0x+aamMcLm1vpRuD2EryLvzd6IpKcM6VJ/N2ToOWej8SLCd6pAxxM+uCS5nuKs2OJX8GOluMWcapFkSnAG+qehTyPPrMj25KH2f1JEoe8xnCgf6HISLpvfs2bqgtbCkReOuwdcKnwAzKQ8uwNw0s9ZoEzSDOi8IAUU5Z1iE4fEQMW2laEYjYggXCBeANqwbfp9dXw8GF9Gc734wHhGkCUrXTEvknNGIlWtz3f7RDDewg8Ssg+SdM5kDYv7sSZu1aC9d6wJqiMwiAIXGrruZurPuVgliQivXAREQhHUM6wmcTWlWN0YVsScy0MS9diybKgAxpYdi/rsgdl/VVKEvFi6gA+AKMBoYDSQNVPQ08ZPUqgE/IA+MQg2HamWavaow+Gygs4EAdQuiDiJC6/oJIaBseN127Ozz0NCPhsfR8Xg9UInx06OjNEYrL+h//xf89H//F/jLv3/D29t/wm8FEN5QC6E0PaW6bW+Q3iC9Qe0qYsHmSAI8YDqhqx2TZQI2bjPj0BUv/rmstxzy47HC2pxbMoZWPtL/DiuWPw74psoxlEiosYI7gYsKym1sfcM5XixctzJNfXGlSeHrjYYfL+np72J9ImhcBneAd8bfHQV/koK/vADHzx1nE/y8Mf4Z3vDr33VAfsPxyzvem6FU0XgcH/Me82BxF8wRDOtrjrmYa5QpGeYmxZseuOdudcWtGh7wXTZU2EF8pmjUWjTDFCoYxayaHG5mwgQ03VQoUGOFsCdZcC3NGLqMNQykE9pZlT8xG5ScalHzFL5+cYfiPif8s/EQrdLmgFE84BuS5AWPu4AFfNehUFJfGJLAm2IQuDPO5gHb1q77cdZgL6BeXR21JnsIGx1qjZIOVLEMcw5PsfGBksUf1/OLYH7FZrGmQiPFLXNKkgD4FioJ2abCyuyvg61CSiICK025vHInVDik9sKNsqGQOH17UseHkuYdoVvbToKXU2IaLY9Yy/Tu4hMU8GGINGNjKSsZua0kvC/dSeLY0o8PJD1fTjRa8j7dynPxjsO7zkHqmwmjs5wst9N8BZNM/kk3ZX3BFjmNX6PIR9J5UqQyE4p6jFelZzHPAesNTsQEZIF01DGgpun3FRdp+Z1m5Gbepx/TeMuET7r06K7qm58ZRpnuzQXn+Z9Q4S5jwdO2B/ZOBQPXBFfliJZ3c23ulHl9R5Y349syD2N+5jGjWONeSv9Cnqb0PX4PV2w9m6pg3fD77Pq6RUNMCegqoan7iMCO+A4hy5lu9LYrsWchkzR0qIg9C42dcGAUSDciJfzNPdak2065CoekA+juTXaQYMfYzWQBWCyOYrrcLA0NAgds95DspGyAujpZu4UGAoxDBU0wYZhC4+Xg2XpBzOilapyDdFRpeNkETQidThBYA4yh46dtNzBBXWCY0UnT5wpBDxGnBlYnGXAXHJum2wxE8Zx9ZYfQNwtKPiDo6KWBt4YNB1ojfC96DgjzjtL+hP79v8bx7d/jKB1nYzSp4FLBr4xyEl5wQsBobw2wLE5kjuhOQLotqkmgyqMegbRjzO00Ro07iAUxcEF8vIM7GfUPwd/eYSSTtYQVzefrsg4zzXFwxpobAmNQb8NzJ5aGo5Oy4S4w3v/JaqINhQXEhGIuglp38M8E/B1DfgL6d8H5BrwVwl/xwPff3vD9l9/xON5xEtCbCUdp582zHQkRSiHUkk75rpZpiqu6N20lXKG2uoHrBt53VShqsaDuqkHe+4bttaJSQeUSAd9bUfwgLiAylywbJmFC7ww/bVlcqDdFTuODdEKIBjroPXN7Cy2g6h83UNETxZnTlqK9FlnifHosRR75Om1kLpysrnjcgyF7OJludrhVoY8/r7RD09maMtWF0KUEvkc/4bTdmWPR+BOL69GYLgsCRzFqpORfFXjDEVsbETt2s6Z+XOMiIuyF0TZCa4T6ols6pVaUs4FJUziL0XmxuEGKsV2kSuBW9xBXNpLA+mUYv/LKjYAbL19lkj/a+pMKDFdpNOIb+LfS4G29g+TRBV/HXnc2Cq2yroEyWsr0ARhr0csXBAHPe8fPQNU6aRGmr+U8Xb/DQ4AuXUKc33Udm7mejzwesxD50XTSzbjcTkF6NJXPnbiUWgXjO549Vzrtkcvy+rMrmlsqm96l8V2WAs/qNnIKwPjMk5iQwZHTnY8W+hMYOd37gBTfP9KOfRRAP9XvpWNn9g7Z7lvRl+miJ6WIyaFkkLn+C4Xy6dGC4V6NMlxSNcEtylbB5Y8FDf6BczRg1gxb/eT31Y3nWhrBp0OgiCBcc2HuHQ0aVNxJd/Uppyig/JXQ7BRdFSAoEFOMwPVGZlXwncfrxKpgRkMWHE2NSTaCQiwuwWr/hTwQJO3Wa+fIklB5nIQqG1pP7R3MBSePg9SFdOT4FBQ0nDFWusMJaBC5eQKhgc0ph0Gi8RXdpWLuoFPP1YAJSt1S4mosyaYnPJcNvW343Q77e2FB5Tc0/gc8vr/h+N5xHlDf5kYoLGBm7MI4NwYfBBykgpv3E7DTlGcFPo93mk7/ZcLhKBhE1YnHhVBnBkFjnu6IcSqW53WcleDFzOrgSo4JxnBcdeAdFkM0fwVWnSqNamFcHH6Rex26CzGkqPWh1gLedwAF/Y3QHxrn8/shOL4L3t+A72/Ao6n7VUtEwlO5svtO+snexChOKJhVGaiadYxLjUDvWjdw3SOl7WbuVMWCxGup2Iseyldc0ahq3WAzqRLb2dvd454w/N6ZxsntPRlb3UWQABJG75p4gLKiBlPmEiLckdsGzSAWdCE2BvoQbhgKG3TdwQ/o7IN2uLdVYJfVpZmhECY1MpIteT7te+xbkM/JUGJUobYdIgGkEHxvgKwNJ312zI/SsYGCP64Prt9//x3/5t/8b/j5p2/Y9z1cB92iEaeF9+zo+4ECJ9PHoAMf8vtF8vr/s/evz7YtS34Q9svMGnPtc+7tbnVLJiQ+IoxtHC3zMmEsf7MD2/8DjvDfiB0YO8IWFshCYR7GDwQEAvRAFt3X3fd59l5rjsr0h3xU1phz7bNP970NEexx7z5rrTnHqFGPrKxfvtvC5a/1+LN2HkDMeuKzcs07OMm/ax/UJsHj+ACAbD8zn0wNXb66Biz3cfafBdhbVx5eYfvntQ/7WCinyfZ22v6tt3bevSPm6tN1zfy9tPV540nPNuMzEiIsX/j6aKc3ugyQtr5kT9DW0J6+rtNUP+8WvV5Emw3sPOl3vjPwSP5vtdS60/+kvZ3HK8Zk/a+8fcXlbMv4zrvW9+087y6wAJ7t7TUHl01zjau5bNi6e98wWztX+FFnUT8nai1s+7uUqY0ECmfk39T2E/VxXvuFtfYt5nDDYM3S0d+xCKV5G6GdXUyBKT7LCB+uL68Mnu5M6X9M5gGL6pmjclEKGNCaDOLQ6Jm560MEWGW628gc2SzTzkpygoq4i8mgJtbCqlBWFQWq0ED253J15uQfxIFOtLBhWCPyA8u4EorktRnMTGj+1MFcPCl/hItMkJkHxIrE2MOvWwWVWbctMADXoIgDpCkOIidNeHXDgSirB9IJwgy3EreSMO4gS4OLhwuzHDheBKYDigmzE2YnVH+Ot1fCdz/7Od5eJ+ZpUL5DT/V6e44YHayKgCUCpXOizOdvP+wun9POvH3K17a8Kqq2g6EB9850t4N3I4p24mF9Rpe/kW2V+55v4SwiiN5kSvxbR55xVVu0hGTKywRMgLs1DYYMxjAB8wHgBn0b8ML0Ezg8NsTuBDt9zcwipiNiZYwk2kPUyfB9JoSIxVg1MlgGcKRVwmtepKAh44AM8aJ8KUTwqCxlx3B3Ks9QlVYNz+aTGhGPZcoCfArChBWjSC/sWnhkSmujXAPZDvPaTGYwm2U2X3Pap95g4UK4mGfEdDVzlZNiGo57OF3SZTIXi1CK1ApF37PWT9IfWXkOelPBwGCowj7EDYglw9rHobBlCc1bNV0v1ofv+hR/vQAAP/nJT/DX/tr/Ff/cP/vP4J/8y/9EaeFEOOI1CHTnlvpZ4yDPAP46wp9ei9+0zbyhj86nEl1c78sbvn8xP9+bH/DkhpyuPKzd0oAL1WDzPN3v365Opwn0yOosv8C3zbP7YXxb1zvS2x2qngKrhxmLv59OZP/wyk8Il63X/ujnSHbo+SoVXeUZGb2naL8vx3PrB7V1aJ14Pvjro4/n8TvH1bsN5Hq+Bygvk9NX6vMQtHO6ePrxo8dHnj1K62dOy+OaPVLFY//bB/3z9Md/bzM+4ICdE9TX+cuTMdbaP/CIy++E75moNdikuwz73ZujdSzn8qaiPL7LotUU8Y8VpizwWE9hV6T9gOvL09tyWwiyOnNVk7HmaKxAT7m05AFM8EPY3Atraro6ITpOJbR4tqVoI+ImloBASHnGgHIfSzeDpItJKwlpv9L1RBkVuMzk/cz9pfWsc1ojCh9gLFevlBIJAWxWf8k8E9UhFP7VDDaCnIZKXaTAGYsrZ/aOqkMWLyQhzEhu7NN0YJoHydJ0hyoFQWliqrtZEdh9lFVg9oJxvOD2jQDKIH0DqYJ04vz4K3z8r95w//mv8CkFQZtQBmakuZ0DmObBlmMw9GDg1UH1Zs9qYM5HTE7EeUNkY0qgt7IyoLS5Gd+3bSkr0ioG6Juz++LS3lCfzfdONwJKao8dn5mSDO5esRjTap/yb1r0xtFGxWXky+NfuuaMwfjmhfFhCM77wImBOQfuU3AHYB8UAsWPboof3w78CgK8Dpw8cB+McaYbYdRuEf+Xc+PJjjwIVgaHBWNAXkbUu/BK3+k6NSK97RgcGaRGZJHKTFSHu0mJgzZhrwLublOxrIC7BxEDZaP0PeBZr3yfe+pk36sJ7gzh2oVmKYhlhAGmClUHi0UD7RowjKZUWEWRtPaon9cGqLsn0bncHS3otGKuKdJr5/oS3EITtUHaR54xrIEFQQpR7gpIiLE3XuVGL3aXUjNUFLtPShE6K5B1fpLdfL2+/6IsQMkCidgMEQ7a9crrgnX2q8X6h3BwccBZ7WJbnvgw+Vd8YF2AXW6l2+o9EPHju2oP5F+0HrNnz3VtbHfh3EA77c9tvKx9c+3OFfBsY3IlISzO6s1d1J6ObgnQtt1F1S5W+5bnR8xE47eprd3709/W/s7FQ5vTDvwKV1yYd36fgBPtZzZK2JQCZZO1Bbkf3Fi288mQT9nDjfufVq9tvMmeAPuN3Kj+Cyp1Hy6T3ZRhPTvYsmWsd6z52d/b1m/rQKO3nC+y/fnLeV3vt2tfcVnH3Gfx+8NE5FmAoM3W98RvTy56+GPR9EYyFevyyJ0fccmiF8SZsFwM+55cf+arifLdMSd5kMQztT+2F+9xSumiS62MesVihXdQ1q0jNHsCk2PrYRhMGMw4hruh/pDrywWNM3SBcR5WNh9jpI+rAzMOhZ4hxbUyC6XrCrlLzzl8QGIhf5inHMzBJS/xImkoLUCBQQJMIpC6uWkB3v5zs7iV3GNgTLKoeB4gBCja0OUx7ZNO5hl9jPfMMoh3CzzzUQRxCBGYkxnBAz1FQZ7gEkQKmgZ7i/oXxB5BywhQE5tcY5KMQebaXzXA6A45yVOjEuOcAh5xTwo4UVfjkDccdkC+OSCvgL4a5ulpcN/ODziPV6gy9MMBwgcYD9z1E+bbR9zf7sA5wRMYxjh5gIZFBiH31ct0ptMc7PneSPeY3ATrpPR5dp/5dCEBwa0/NesXdmZ2YdotOGrfZdjvatuunSN5WGZV6hIwkNn0ciMGEScXzE1Jy7RYZluqZjcaIQAsgtuL4EffDvwOMX5xZ/zCDDpPvDFDvhkYv82QN8KPvjH83o+A8Q3jPhmffg7cANyEcE7GKS78DyYIESAhDAMuLBxulRBiL7gnB46Xmwd1C/vPMXDcbhAijMPdoTxzD0OOgZu84CYDJAMYDApLjFTih9iLMamMGQKbhLEo6r6Qp3w2IVC63VnUrYh4ieQiCrckcDuwVQw0Yn4vIVcDwKCVCrv4TFooMqaMONwh2Y2CqcGJd5wAlKzOo4rhAAWNN791WIUYAQjXKyeMzD5lwQPJ0krmlkAigokFzXhfPYDdol/x3qAdRYKWr9eXXFmwkin/uSCbQkcKtYRI3FFW17a5G5/Z3TwS3lzOlfZox2/PTp8dKD02krTTZYQOyJ4ZQzrrW0NZUGx7xwZC968oxvbgFrH9afvf5WLaJsByhq9iW3IKW1OdT3W+ud/SurzareG0ibrGhTwfazLwyxjyJnt4YL37YVFSQF3TsvXnQkP7OxphvXu1XocXSO8ftX5kbzbCqV87LYQoYYve6h31PVAuFkFQ9ITw0vWriy+fv9pExTp0+shzOrHDRvD7sleP0wVyp4W472qauqzpRlf1Orvc+rgX0tK077BHHr21kfPY3mqNFjP2Z3/ROm+uqWf7XFht+svL4/luXC0ayPZof6QEjNYAMcASFcEBzHm6a/4PuL7cdSqBUway5iEedn+CVz5GwnWbLo2seOWNqxDcjYQ0GcJKI0mK0n6jHrUy4/oEGSCA3Qh4RQk0Jq2/+y/1l0JB8Jy4EqtsMEwCeC5NhJNFpLCNAJsM2SQAaloHlVlqNBWRa8c7egCkXpjNIs2s0QATMIbCXhXHcL+3aadbJO7mpn4CSAQkPvmkAr0D9kYwZkC81oWCoRDwoQAdEDkgN8L5Brx9mrjfX2H0CW9K4LcBMYMMw2Dg5Rh4+/YD+ONH3E8B6AaSb3HwwNBXfHf/iPNNcZpiEmGyQInBpACmH0riNQFsKgyzzp7rMbGvQv5K8WMJeVtBxn6utSxRnankQdsVT5+9ttMvme3lKDIEEIwP2wGRG7GeoADGHFU6eAmtGveyuABAfOAUwaff9Yrx/J1CP7zhfmOwAOcvGALgp7+tmH8R+PgHjF99ZLy9EU7xPcBEGLpyIhDCH50YcjCEbx7wPQYGA3wQZNxwkxuOG2OMsE7xAKc14wghQgjC5EX6bjfIS1gvhEDiC3DC14jZIIg0u6QRoyBAVCFnUxc0bFkuaawUsUqAsRdTrDUwhG9zzL/4biKzsPLtS1mgKPlISwNrk1ABb/BUvyQGRLB6BoI7I3dmSMm5g8A8MipeEbElCOF4Y1B5hkYsRsaX2N2Dzws/SR6wtiy+eUgl7xq2PM7mlV6/Xp+7yjUxikgOOjBIMVgxIl26iGfP81pCK44I6ND4OXTawBquYPgBteH6sX9Hzz/HEjKSp223fA+au0Iduny7fUr91665pv3L/vtTOqTqN4FWjB1ly+vvHNMVEJZiuPH8MiD0Nh6Ye6G+fYhdYHln31xnymDFd7KJZ48Set/WS65Q2x4ewj6l+TMPiX7f5SqvznrXZzr4tMeXV9u1Q09eGkqX6zn3cNuFRveW2lupPRB3ftEQynXpiaATzX0W8pqvbtHfwyKgJvcCA55e22zSta33NmiMdAGjRxroa1+Cof9MC3v1b8knpaTd2A21c7H3dfPA6UPNnZ+FTV3w4ng5i3tIjGPgu4/f4W/8jb+Ojx+/+/xEXa4vL9gXWXfcapG1L/JA9ixPNM0BB0VRstJ2tNVLqjjhh/50QKHsAZTFNyKrFYV2kpQKjLK/BjgBmFXlcdPwm24mILsQaGrdvdyep5HVAElliUiptrtG+MOVQccRX2hhFe6nJe6W4X4P4QoyzQMQybyeAMRBqBLIFCY+EDZyY8b0YHUOEE8z5k8ZRB4EbqSw6alvT2OcOEFjQkwh4R4jNnFnBQ2vLTHnwOsABBPMjBd+wcvB+PA7A/yPG+zvKPR1QkUhL8Dtxnj5yDhV8EkYUxVv6hWzySwsUQQ+BvSDYJ6K+XoH3zXM6TnjHAdMbJSscdIAY/r0VuAaXY/yxQSS5xCWRrm0EbnmTw7D7cCrvUfl259vqXfSlY+Q9x2ZZCAaIt8NJAMmUrEKVWvkPBFlW1yLbgp9A15/wtA3At8EpoL7Lxm4TzDewB8M+OnE63/yhrePBz59fMUr3qBGYUlBVTwGiVsKmHEcgnGTqOJ9YIjgEIBvAMvhgoYwRhTXYx5u/bgJxhFpbzlrbNw8UL00wQ7YlYC7EW4gD/A2hpB5qmaKoonmiQzKt7PSUSMEEF9DNreq6QTm4YJ6GHhDs0vhekU1/9bLtwRduXDjhOFMN1ywxCe9gJS5YVBZoROeHQuAsUHYMMwiZorgdTScRlZoRsss1Wi8B8Q+HLojic6KoAoPmb+nTro6jzhSFnuHn+df/3o9vQhlxdjilDLNbVo0KP+Fdak0mU0zbvWfzkEuS2HBLva1fehUu/3Z798TIvL8u6Q/ajD3Gkv28Jyt77AfzTvqyTHtQLW0MNu7qL3n+wjV9pduDfcPdprfhlLuU2kZBNJ6bm3NFoCj9son60RXIePqIpPvb4DystGN1hzYdo+17nSry3UObJ9DyqF+TmJNEN3W43LLPtWt/x2xPnkDbX+0NXu2vE8+u4JYu963FjOP0YthKfrX1o3WQkT/aL+/iKSv3+fm79l8Bn20/q1X0cPvmyX02uoFez7c8dCd/gG13vR1eX4WpG3IDVGP+/fh/vgq55EK8DRLB6HwUfJSU8PPfvYzzHk9iD9//QCLxr5BFOTCh7mDUWSnhJlCBdCsAlw7BptLZWomiXUz7yA2rJG6dcCRimsnU/JszM7Cz63AbLgjkNm7MXduHjbANIJMIkONR8G4qxb5uOKj5RNqEcw9460EEJorlay20wqimc9dLVJ8CgwEVoXZdKOPTgduRI7GZG1Oj6eIuhYmmDJxwGM86PADU5VBmN42sQtP7GNjJggPfDCvuaEk4HEDHwLhAfsjYL4qJp3QqaBXwJhgNwZuAiaDGGOcE9Cz4BYxefYhOwBMgBTGszLB+gItY3cRdQCoXau8NnEJGZaHSdNZNGbEW8PJqK0Cfxcz2jf22npZnGZrGr6isXGrH6iNSa2vCLcMEsG4HRDy2hJ+8xvuZrgH6HZLnQHnBH0EaAhIGMQDdLJr7W9voFcFy8R49XXl+x2ir177JSrZe7DWCM0tl4ViDI/FyFiLIZ6DQMaBY3hmKREP7GYKwUSOuD+DxKNwX9bkYC5XRiKLzFbJY69B/kvzYgg+EfsU6j7dGhvTw4HCopTa/QxZgAvcxgyNYG7f/09O0uAZHmipBT4sxL08gTReaqTA5ObtYYBqGEXM+U1Ihp5XwjweI8/z5GMdd2T/Gg0BgIpFHFhMSKfHRvdG4Ypo7EJOFelrSTi+Xt97ec0YjyUSEchxQFQhOiCHQE3BbwyQehrT8FVKvLDhiw2jPIKyz8kF33t9Bv+8Dw/eb4v67x2LPMOTV/SCZc/YvnzmctP7buu+7+uvtT60o6H90dptjXWN+hpKaMNtKR/r0daGPYyzd+hzvaV3b9iWrWHbLVzkWRuJXS7xgiWUvNeNhz+pluapw9IPIpy9j1e6o+rbY6N0ueP7X9V4Xp3hVi8tVnht7Lr4/TMskaLDR2rE8CDgPGn63Tl78r7HTu2d67eutY3v6XrHe1fbi5+7/TJXiU0WRlkKlacD6ZhmSRZOpFkAC+SJNVggNCBbdewvv77comGR1SljNOJ/kmdjHIgW+D0Pxlr4dkgvrwP3z64JKiFj0eO21kQRQOkfaICT8r5qIBQ1eddx5GJQAVJoWxCiKgrmfVok1OnEYhFqrXOduLcdX0UWG+J0w0LFfk5ZW4UCUHHSZj43JxiEadNT34YSlEYerO63b2CoCqZ53e7TPCiVD8GNGS8GvJrhLX2XAeDthH43cd6nV182Ap0T89OJOdxvgw0YTK4hNoGqeaphFdfuZ8A3A8pUNcNjiYsOEGuUmsQQ2TbTp9NLnkh5rHRglm2Hfijb1fV5Z40LHzSm2DdXmhNLoljtrD+ofm5blgAKsyLfBj58O/ACASt7nYXpbUetaRCxCxaHa9kTFPGQcJFj8MEgCMY58CIEMOHOwF0mRE+A1SvPswdpjwjS9joBA7fbEjR4CJgIh1BkmzqqYB+P4cLJ4YHhwp4bO2tpHJFZwouexZohslDQmgAvxOdzZbBKyIBcG/I9ppY8YrFfT2CQ62RxMKTZloLmPXFEkNfj1ZlEWjTSmhhoI9dK2ap2QvGGHId6coj6kFfzKfymssXChavS42ab/QCN/14VIQ/ndgNrGm5aAtusqSB6kK++Xs+vcACIfdn+cft9MGxGrJ15Mgu3lD0HDADiXFrr+nC9B5Auf1Pe+4Donuq693a7IESNLSF5WEq812cW3T3DTBtIa+31mxsXfpKI5ypFrN+vcZJ0efLal+uvNV/t7/7e/LvOl/CffQ6Pr9Nplzmh7a7eB9+mi3dxn6u4tN1Ddul0W/j+lgcbxzZw7NPqjGbNIe239l+6BSex0+rP1Wp3ed21Ixe2Re2/VwNa/XlZAHoI3G/vt2ynEVb+fBYQ3pupq6I14py22i8PwoY9TnP+0vfXBTq0Jmx/oCxKK1HMRpNJT8+YeO6Rtj59P9Y8t/133RPILtB6blM29Ieor2dQcGKgYCppFSHi9Q8ew8njT6bx+gEF+/yor02SQkUe6kQF/ANFeMxG3/SWWWUCmEZshLe5NI9xa9GZ5bdBMRko6RNGG+Hs2LDrQ/IieKGstSoU/UcGZx4GOnOl1raifF/8TFAEqAdxMtzFyXIBEQeAExnXIqKyeJ1Qd0uJ+4mQyTaQRQuJCIoZVZDhVhPYqmzNBLBg2gRON9JoVFUGmbvNHAe+hQJvngrXq7DfYZ/cDcuDe45wLThhp2Ked9h5evYguO++ifvgKwj85ozSYzXc7zkzhVEQySZMU9BFWRGyeGKkc60Vux657JXp86O+3rXki7nuzG5ffwJWsHq6TwD1zp7Q4xkn7/cTU9Sn8ODrcRs44C5wenqFb0EkGyCEkHGAPxyQ24S9elpWGgz+ZoCPAcEA2wuGvOD4HcF8E7Ce4DODozJ1k2eIckEhwNUhOA7GTTzeAiG8DDCOqP4tY0RGqlFpbQdnjQ3PVDWi6J8LRlSSRbmEJY+l3PvWNr5r5DObktaJsO+nep4pblV0CJfCgPlXxcwfdAd5QwJ+GIiSQfRofN/bCnf36pYsgCppAtKiSN6uTd+rnuiBqslNvmm0haTjODwzUC+PC///YlLJvwyeGEHJwJoFNq6nxdfre69YGOYmbDTLHEtk44NXdqdWRHYdv00T+oCJH6Hzhno2SWD92ru3AwDbaOnS8mryKTZvtF39vd5YRPiAqhafw8an05WFtg70YTVruzXg23uc0/KkjU0B2D7v7mN0nddtSOkc2QBY4y1rNfua7O2kK+QDT7r8sqbM2sc5f9SmvLef7ba7U/HaPENq1pqC9WGonVrq7HsGvulyf+tj8etLUw1JPyHVRQAbCO5nYqOD1p1HT5LW3wstAbRZu/bOYV+7HMe2oer0fzyuY2O9JwzRtpp72zmu5RmB5oZ/YQzbmrQ7ivbbc50/9E4C++HW3dXa/S5Atfb6iwil9F102zfV/nsXSDqdpJCR1g1HF64QZZHHM/gLri8WNCYoUgf6QMlW1h0IIctpUkoH8Akw3pclBYYUOCziI1wj6NpziE+oBerzibCKjyxffovioMjX7RmLUGBjXUbkQbu8JtkCGVfVUI7ATyzrRBFSYRcPZOfoW/g9ASZt42T6P0IVNOb0QvcYj6GEm7omU0OrqicqdS2s3M99nnKO2QEzU1RvxASZQFWhND0C5WAwA2YHxniBvEzIOCFvE6QTqhMn3WHyikEMvNxcqOCohfDdiTknpgEWLh1MDGWJdTTAJuycMNVi7EzwOiBYpu21DCFssfujEcxzcEV2nsVTrLTgRB4PYpH7fnE1f54MLUi4aX9tHQZYX5fFyN15wu0N6m5BCMtSvEGjH5T+K5n8gAwyCHILQYME8y54EwOZQqe7/mlgbo/dZwy+QcYNY9yh8w2YDn7GB8HxzcB4u2HMF4wffwP77xywnw7g7Q4aCha3aJCeIPN6FscQjFvQ6WAch2eZEo4ifYdAzIv0cQgax1hpbplHpMGN/NjCkEHAEVKsLCtbF8l8m9OaX6MNz9SeN4cCke16szBVrEscLL7/Q8CgsIwRwGqNIe6X28RWJjlPc72UH1nUkKIvvJmSiyTKYpM1bQy2Yq/IfNtK0Ffw+rR8XrwhAACqBm3cNfetz5tvahLsyhp4XI9GrRQHww34fr2+9/p//4f/If7u3//7+Of/+X8WHz68hPtg/BsCU8UhAjKD8QlmP1mMw8XtIXUN3gH5f/Kru9J/SdML6DzS/97wZxp48uAGed+JAyoc3rHtFdAhQdH68lnc9oOU9SDAfGYsT8d2lQae9X6ftOQDeYT4eeIds/0upKjSoGc7TS6Nfm+QDR6etOuHzx6/zvez++j6S/v55FdvNvnK8xcTPxnns5c+MuR2i10Qd3z22PFH2ni4bE3YVc56pytJk9tIrJ9B339dscMSfGj7GTlZC5U8NLI91ynqMr7cR6mgf29s8YzRvsbrdbsCoN5IKCE776B4D3Eo1ULQYI6K4GNAbgO3wzHDn+T6YkHjBHCQQQwgdVeIDJvwPKoTaXrJMSX6S7BZVgbzA11DpMrY6hEHPAgRY2GuacznAU9kRQ6wCQ5C8nBQM/d1zgWlpKp2GYDTgMPWyQ93C7OQFxAuETPiNCK5ZaQQogAc6nUx4KBTjbzAWryGbKWjI8AxG6JicFRrNiPcjEDToNMD4pUk3J5QKT3BDKMTGmYsn1fxLFbqAeVGDNMTQuxpasndmHi4Q8sxDCI3jG8/YMgJe71D7cTb7YC9vGBAMaZCxjew27c4iXG3n0D/+BNO8QGQEChAl30iEI1CWaGUXkwcsZYpLDKtjGCaKXAzoNlBLdEEzjsyDoZsBfWDsFUgX5aPoDnjArZ5IndAWXux9rnBGn04EGTgdgPTDSxwYWGqS342w4KBCHYmDBCGedpXkEGn4u004DRYBMVbxIEwsRe8+2A4vp2QXxpYBRgOwscduBHhOAgHKVhfoX9wh7655EnjDTBPr8x8A0fa2psIDmZgDOAg3AbhoAGhYzEKGqCs6h2Cxm0MvIyo8CkM+eCpcNkrAMZ6ZGD7OqBhsW+RW0fX/GoI8DNqq4hbLLrVkaYVLikWbQj3xbHWmhSVMpgBkejHlc/lgqZigCLFrxkUs2llnRb9kAmlgIb/IqULp4FS6CeKTFmh4LjniAlK6QrmAe3ZZ4JvTRX4s/FaDsE1s1FZosYZwiwl2/euGXv9Gp5hReply79en71+8Ytf4OPHj5jTk16kYLkCw1fa291/uWHl4i2PmMZvXPf5dwtwUN7QjsK8DAvPW/8wW3oAbdQ+f3KOJXB4Zy46Xa422vn88NKLLdn2Mdj6pmHbqwRitW+fd+gBH+4f1q/rg4XhExtccFveVw1T+4DaQPxsoG0Bkq21iYrEDd1d5WEoJZitBCSPW7S9KLvx2BL2mY3fLn3Eel2ffGyzmR1B4JWNAHqzPY7RG1ytdI14HZZ1bQLkdl92Dtsn+Udf02d31xnx7jy1p3O91pMLH9a9a0Ha8J++P7dyX79H5JDr2IWz9sZ9meMzb5SuX8R89OD3+mlrjtspi1jR+DVXcafb4kYxj4Y2ps4H6LKO8WyvAp8xG0QZo8n41a9+iV/+8pcPCZa+5PryOhoKGCmmuFY3fY89WSywwj7T9pAPAuE/URJUjleI93iIhJGVo3etfs2XGIQi2FYJdk5PJQNPI5ltIfFmmRLieQJoIFCxQu8Mk/DPjkWguG+IByJ7Fzi0+gAmvLBXtk3kKXfMF2tpP1HSI5X7R6gyM5r2ZIioux6ZuJBzRiDsqRhCHtzNHgksY0Jtws4TL2ZgUfB9Qs7Qok5zIGiAsmeLMgNEFLgd4Pktxu0OHG8Qu4NVQVMx8QbIG/DNjyHy5zHuN7x8uIN//P8DJuGcwDw96w9P84Jxw8HzPA06g4GRW6YinGfVK9CMJnY3M2afUxdWXgDcgPERgw3jVEwlvJLh1dXKNc2Z+pZyncnAQwAbHsRvHpSe9dpgi3auTIMRrk3s6WcPIYyXF3z40Y9xE8Prp4lf/erEdx9fAf6E8ESrMSkYczKGEkQAlgk+fZ3tZtATOBmgc4B4AMawj4ZTT/Dd1/VQr+swX4G3k2AvBMKMDafQaSBViM3iFEdliOKIuTgAGeAb42DCERaWrOZNzKBbVP8WwSEubPARJEniwbLC7hyZJtMQ5gtVw3yvUYneyDS+xMAMNyujcJkKRQJHwU1ThQ0rK0keKAaEQoHqPcbmix3C/QwNj15VpeWOmYePt6gEUGoNQNHBCKwQDRdA1HmhpqAZ1Tw0zMqyjmALrt0PAU9n3XhTeDyV5RXw2hgxPz4dLmyksm8JXACmgU7ABsJV1V0UTSl43NfrS6+Mx/AsfBPnOCHjgJlhHAKYYt4ZJ1lYcLOSyyWbyudQ/DNg2Q+4R0RVfz4DUu9dz3Rlz64LLn18T2eI/KQHhbiAzNRU7ue94V/X9XQOLx/n+66u4dnXK1p77z3bL0vxqch9tr5fmuB86cIQ770mA5sfMVgHo7Qtyt6bJyg37/vsnHdCo4dnr3duPXoy/6XlTv+5+hyfTUix0yi1h/pgabtxeba83+f9w8fBGdHDHdd98Nnm84v89yxXbmC4XTRZO2wXmHYqQhNIcz4tXIK1CXXLttB7+oxTRBsLLV/GHTRm7pmRpRhiUdH+QMYguIARcaPsaeAz9hcjYlDB+L/9jX8Lf/THf/SDM04BP7gyuODUsDTAYwS8gra7KywashownbbAXgyWDJXelrNaNOdSGnAPMEexNzMw0wBopLv0uORKRel+VN6HtE4AeAzAocYUwNDh2ttaMPZ3kGWBL+9zVHArNy+2tXYwBxSefMqy+Ln3OXGbWOyz0J2aB7RwaFhIUJYUY/ICYEMBu0eKXHjdkEmQ04lD53SJkwgnAzoJU2YU8HN8yMqwSN4FU7C8eW2FceAggby9Yc43fHoF6CMAvEI+/NyLvNGnSNtK+DQDQJ4umLAoBhRCBGMBD09pTHNl/Fr8nZZ229gtO+wBRj74E65NPvEiwAsBbwbMCbzB6uynOPwqWAmpqTwAOmAjBEOaoNPTGM/pFdCBFZxcbimU2ZoIQxgvIvjwW9/ix3/xt/Dtd3d8R28wBe56wu5pMUExI2NgCjBAkHFAvj0g04BT3YXtfkJPdgA+DBCGyQ0nDeBQsE2McQMdL5jD0+OCCDQGjA6AJpQmIOquUFAQCW4v7GsXfujEERCeweEsGMQYzJAxQGN4/MZgDBZ3rSKGpIVsROaq0l7EhhSuYple9yFYaKGPtAQs7bBF6qhVGRuAWljYYr9UmmBPZmCHp7j1tbG1VmFBMYILw0RYFSnWfvYEE+6mmXRfvtC5/83gRWr8MyvffN/vIAlZ2O/nYMgE88xYEnwlaMDriLh71wlLjzpQFt5zuTJmp8oPLv7T8FG5m8Ye1wHg9Dn3bFT2uTP+6/XkYqaiZVf+ZI54ifiNqKti8S9cHBcNx/UOGN6uKyDDggMlONd3j+fR9wozSYu5F3rTl26EPLzeRIumt/aa/8ijKzhdfrY+1tHerDcPEs4CVeu7dlNqofIVbb6t9al/uibWqlvelavt6XE+6u4AIXF8FMAztDm6zHfdnHu0X0/Wjdp/Fz/Lv/Nnn8y8kR4FiqtF/sLSnr+5rdnexOevdt8Wf5pzQWtqrI8hXN6v7+5ufqWMCVq85iyotdymhbZ3rPsex0n7kPdG9xW5jHXx8/Sa325qk77RYrvnPadWevLXTtPtpuVm8eTZhaVrT17vi0FQvYeqzT5z7YXINW3OUxUKUT8ZyxIsgnOeOM/z6Xi/7/ryYHBKdx0PRiWoGwUEkbrVgbMr7d2Vh5Sq4nfNR6hJsgIuclBoG4jW9FQcSDLZDDBPGkw1M1DUXfSheNQEBhCqYoMZKxCMJD2lsdJrIQMkDOrpRpF8sjEnRjj/99Mg+6RrgImUifwhtlpUL0zm7ZoaGAw53KVqmoHUCwHadGmVzb3KabgLh5JjKV+dCAqHx60IAWQKpjcMOuCVEOAg9nzDS1LD+Qb79HOcTLD5Bh0CPrxa9TADMN115ASY1YEuPAZF2IF+BtYmj+ao9j7hwMwLTXPjghPAHZge03IfLmSYptkxwa7PDQWNuFuQQPgGopcAwF40UEcIRDjdRUqjVjwBII5aJV4jgg4GHQOQA/rhG5z3H+Eun3AyYDYjboVrOc3cIiPiLj1CBNYDbB+crocLN0ROK8MMQoZBApEXyMsLxO4gfQUfB+R4iToWHhpx0MC4vUDkBE6vm0KqnmYYXLUwnAlQy64zPLtUVAx3i8dwH8tMa8suVHAIKMTiVb8j6IssApRin4VXmpNvgYOo+B0Ze1zqjoiLzHMdGuIwHILGcllYDD0E0sYD1raxsiKAAOKI2bpsZ3dx8s+9LS+WuJ1kloKS+UbIvf3koF9sN74n74PlYZD8wAfun6muvU9Y7zantZU0IscTf2seDMEf09Rf+2fxs2cZ9L5e719bADhLCBgDwrY+H+wWXV2HLINWFkNgO5/7EtbfeYZfIk7TPWV/sP9xuToO2AbSnijwtN/bH6PrdzuJBz3ZOnfzs0sjyXetfdBdllIru0MkK9DWh7XJGNamoeMe28dSoNYe28+DxR+zx/saYlwA8try+oy23y7zkIdYE1Suz21gk3pLPhm2NbjB9ct8PSGA3u34oD56Ri+0dePd66GN3ger3m9tXQXdJwNYz23jXrwtX7XIkha9xcMZqpk8j3LOco27ZLG9e9EHXb575u2z9S8T7bwzcY9U0/ZGexdhrdDi2W2ntEXbhMI2xzXOZ/1ttL/u6yOh2NvL/WkJMmt/loCxNLdA1Bqi8PBgdmzjacLlT3UGfbmgAQDWtcLYQiDW74XOHXgAWKJcfeKoulKS5ktiFkLrGGPHpj2hJYW6xo+W1aLv97aR+0VIhkkBpHIhzLWRybhqzEtnkoUIne6dg1kjluRH28sCmELifdW3CJ5mZ9ocKC5tK+6G5Bl0JhjTgDMAs4lrOBVwooCHyegknEyYFLU5JkUbrnFlilz9bvZB6P8xjPDNYEwZOE9AbWKeijcz174zQYQ8GxdzBJwHB2d3IWM2iISVAqmJ9b8Gk2cvsowbCXAegfFGfr++TpyYOOFCiZpTjBEvRhVMhsFlkRDOPM8OTk/z/rmmHR5063by5GABrKk0niGy4TwNr7/0FLKvbxPnmZvTXeIUXgWd2TCEcRMfDwuiiNtKW0DMPidmGIBniPrRwPjtG8Z3Bj0ncAzcXgZuh+AYgAzCUIG8CCQEXyOAlDHYcFhWPnZBSdgzTFEKGseIyt5L0BhyeABsWkCkCRrjcAaTzMeo3HbK64hyNy9LlcDcO9AAs1yrxuCjHY19OtYW8JCuxkyzzXTDAtKlwTcR02NQJuo+bD7hDDgdwMr3OncUpRkyP7PGo9B4QPIg8jEs5aw9O5m9vYzJ2g7idtCBYpyGzGpFdY/vUSNEytzoEfv9fHnb1+v7r9gdXtdGJniMEjBkCNQEPMWt6gbYSYsQ4ZbX2Xhxx1Ub6ngmN7wnNDz7vA6a57dvOM6uX77znroev0wgRO23BUQu91/7eznfGvbdXWeePdeeNySvAb4vMpfqRNZq4Arfnk5f+/IJ3Nt4DwzL3/Ha7dTW2+r7FR8ukedLruwxvbvu7e2rU1/CAJ4s4fe/YcXA9oiUGiete3O5MhnPdnF/EGuuLteVbLPoYn/nYx/3P94d4ubH+v7kti7W782L9nJdeHgbVemeusnmvevJuIr8DaXM86ycfgZVdlVDJ+fWh7ZifeixbmUFD/o2WglYuhdCC0SONV/YYtzc/Vr4T1Y/I68vFzQYrrmj5HxRYMzgrgIWh6Xr0pcWgVBCQ4K7lFKM3SXID/AUDC5MEBaB1THFjevWMZCRWGbrySSCh5E0SNNWOoNBPbhToZRVxqP/6b4lWKAiNil4CVQOjL1f9c8i+DnjNDKAloAU3giRISoAksLCDUvA7H76oOkEM+IeIqi69cjzTjn4PtmB9Ly7Vp/YwFGzRDSFnHtkzpkQMOTlhpNu4Ok1Nd7eJu4sgB5gVQwG6BCwuL+84g12RtpdOiFsgI04uDxIXY0gIAwBSDyr1plWgMjLDBGABiYLgI+Yb58w9cRUg5nnD/Jdo2UZywAlJnIXoOHpWAUuSNmcmNNjO9jUNd4hBKSQmLyS8pA8DaYT+t1H3IUBe8P99Q497yCOKvJZ5VndojGEcGQNjMMAuYPucGZhFhYZhjIwiHG8HBg/Gjh+izHOATWDiuA4gNuNcBsCuQ3wXcA3A7+lIOoxO4cQDos6HOH6NAI4kYhbR8YBIcJgYAzGGAM3HB4wLgwbFG4jHh9DwwM1ah4iqr8EcTQeSo2WwSXYaaYshoVvrywLAKHcoDzkgta7jGLv+HfFYIMJ5ospimpa7pnOl8pHcgnxTjNhVQnrYWYFSd6xOpaowQef2fRK5Df/PXZ7jCXeFEgwBbAlkdDiD8mLEq4aXGMh5NbMsvbGpOT4suYjEAqQr9cPuV4/veLt9ua8ggSr8CTvv5f2L9z4QnGVNJvruJFO/vzcorTvrf33yxFja8oen3oPRtHDnU/eF2AiNZ/1GRBgbe2p7gXltz0H1H4EJ3TdhZCn3al5pKW8/NzAcn80tFkWFuS4bZ/rEiBWvx47vp7eXp4wBQie96Q7T/vZ9+ozALIRxfq9NLWNL3WE2fq0WrJLU/2GnKdnQs3e+b3ZNRO1LGS1tgs3tSY63gn+WMI5XVuNIdNOq9vy0/7ZQ2fxSOel8DUELo2zpwQ1W8KPIeqgXa/LBG8T/33XIuJyLa5376MP1pJ3t9cmZuz7iC7d2oUM2v7CNndUUmFfzR6X0W/GZihiijgNiexTzF80C+9dX14ZnADIdGWcEWgFZ5Q7CQWI1oDJMw9m7zpSY9pFL0/liEUECAAZGlEH1BrgBy1Yx2qCLNyj8kDOhYy7HgZixGV9ScZp5TYFSAQ1+KZaelaCeYC45ZidYE0AnnFQrRaji1YZcRw0uiDDMf7pFBGgjt36wFFBHAqY5y1mVvcCi1jyE1HIbDKMHAiThM/9HSBSMHktB5qeEYzhqJDUYLi7vzsb8OIi7QsEghPn7Q2/OoDvPg4PnIVi2sRJAqEDUxl6MFTcveqElb/9NALr9KD001177CCv/XEHxnQ3K2YGY4D4AI4PYP4Ar+RxAqfhNMMrG96Mg4YmzPxNRIxBbsk4XhjHzetFAA7ux5sC94kp0wPVk4CJotJz+vM3H00ohIBjvuF4McjrhNIJEXU3ISHQYIi5hl3IvHjNTcAYGATgfgfuQeOhItFBUB4Ywl6B+z4gPxOMCeAggEdUdWGYHcDbAVEAr1buM4IwYYYFp7uFVJVvHuDjwOADAwQegNwYfDtAdvj+E/KsWZyxLQNEgiwOZ+QuQAZ1V7HpDMqEKosS4EB8AgVSUnQl8zTEqlz7nsLFjM4Kcwr3yrB4tO2ccg4QVpUIuvC2rvs/uIraKnCJsGghbwz9TYGZSOlnVjEYi0t4x1Q8MNhdJakOJYvv0wpRDLkBi9L0hRCV36SAQVEZ3aaH6FGYQDM8o6qq2wJzzpvagfn1+t7rPE/8tb/2b+DP/4W/gL/6V/9nkJtgQDBOgWFi3AWqXj9m8Cxl0YQhCBsogTPPhsezpB/hX7I6Dwf1M0zzpdcPwUDtvtR2+rHjpyVdgNDeQdr//Nwrv6AvG7h5Hmywv/fZpMVn1rMu9C4kLugfXvu+EJX/mc9chrwJLe1VscXXrfbO8DfieG/RLjN/JahCpQ109iYuY3sYI/DobXF5YXKrrY2rQHF5Yt33nDAKhz3pa0fdz9t/HMPTdq5XYq1nFg0qeeMqsz7r/vbpU5gd+I6apPx576L9Syp3rfWzDHdxf81y27/9pOwR+qutRi95OHLgb+LlksbtX7zClbcEORxX3V4Gbh8GjmO0lMc//PpyQQOuVd0yLUpo9A2eqlE8MNhIYJNDY54D6DNoFfjoAIdCe43E4xjsMSBT98wu5b6FnVgSwFAAChDCDeE9irRCPsQp/7CD+tjYPbLfQiObQZ8Kg07ybEtqOIKKLUBN2WVoEYIVAAsfd/IsOhYghGMAPNh/N4egNH3uAQJDMPgONuBNw0mHPP0tTY+P4NsB5RN3IWAqzkleBAyGYepVkNXdPdzJyvNsfsvAbzHj5ANDCcoM+8iATNz1hEzCOQkygckM2AssitLd4Wk42RRzMowGpoQemeKwZmAcnlCJ2H3+BAaSO+zHCvuZYtiAiOEt3GXOfs6Za8SZyPPiHwMvLzfcxjfQ4xtMm1C9QeQNJBMEhfIdNE93GStmGgcrMyw0/SCG8MDxu7+D8ed+F+O7X0F/+SvIx1fw2wnWEzAH+yROI6QMmyMy2xwgucGDXeLEOu/Q+x0msabHgNCA6IExXNDilwMQFwRUw+UqEwMwgTAwAHfDIgEJeVE9Hi4oRLzFgGsebkMwInMEiYDggeCG0E4QL0GDnLPlFK9cb+SAK5IhZEVtVWe4DA+ANiVQxoaNZFYGIreIkMKTPWSaaxhw6kr0EP7nnmjC3SDVCGnVtNjkac18xuaYF+MEAE03Kxrue6+rT1r7PsKzg3VV2mXnVGtGFMV70spCWWAQSzFB5AHoqhftbMR2UAAi4+RlFDzA96ECmGRlvS56D4aoRF+DwX/g9fHTJ3z69MljmKyltQ3tXFo5hBhKnmig3Igs3Tke3XSegikgqfXptYGPZwqwy/fVVlMxWh5EDRUt/NpAX782kNfASv3Pn318uqPSZZ2rqAy6WNiebcwnUlnNX7MkuqKnuaRQn/Xn1z53aaXuIt+yu7higcp7YIHQhe6ot/rONLib9v7e7lJH/aEwA9m6dV+LRkyEZS3Z2nofK1fHyuGp5vTzoLkLlIb1H8oXXuSZ7Pui+51WGpf2drvAl9Pw0HdsC3j1nCte3pQti24fWto/uaB8q7G199aa7iuXM7PNeZtMuqxRdduenEvU76UnpBX8JbcBPXS99Y7a/D/rMaqdfkfyMroswFrX/n7a/zVF5mDGz3/2U3z67iNe396uI/3i6wdYNHzh1SKzUvjWpds7RqTDgvtlu7YcKFgekqaFDxrEHOCV1xg3t42winBs5XS5SmZB6bkMeAEzi4C+fF9IHUKVWjev+isLD/orI2sWQY1xN/M8/obShOa/BBZMgB6tqBzMJT71cda0Id29uArBJeVa7GwGPNtMIT0GH3C/4aFghsdwqEHFIh7DcFO3iOjUqjvAp/gGuwGYJ+jMaRDYVJApwO5hrwbwfIPqG0wNJ4BfMWFi4JwOZse3A8fLHa+vjE+vIRyJt6cmMFHQMOATg0+DQGEyoKYe66pBNOba4qmEMYBB4mtuBny6Y+ob8ApMEujNAshiAUWgXIgorAt8OwA+gOMb3G4/xmCFzje8vb7ilQz2NnGMT1D+BMWZkicqdR8LxsGe9vUY+PDhhm//4p8H7C+BPvwxlAXH/AXm+ebuU8bwlF0+pwOMgwaOm+Dl22+Bl2+dpg3AqcD8BH39BDNAhlX18PEycNzFP7u9QO0GnQDZxDgUIkm/HvOS9UYy+wMJA3wD88AYgjE8/kaO4dmpyN1CBAyZwws3DvG/S1RgwCYIJ9KcygmIlbagTZ5WW4bZhUPEPvDg6txbvjfTUpbmaa7aL6cHhaeVMIRdM4AmwUbjvAZQuDKF+AWN9dv5Eq9DoEyNqw2LIO2MVSJ4oLsFK7ke7r64Qbdm6YHll15PreBtQiBlpNHHBZ2oQt5dFzQmkRBxGIasNC/5ZMOYpikGrqx4X68vv4gAEYaZuDVWhifZkOF77z4g4nx+nqeTFqNQfYPWQAOV+0uwufA8Iux246/jugCzz14NgOYHCY78OKXa43W8ogGkK2zdEPNzK8+XdKkPZftjYbLtO3r4y9pfWA72hbqyj0/6vyHbhbwIyfNSQOlvuKwu5RviuwYknXQekHH78tI14AEzpKi0P3y57DKW92jic/RyAa9XgWiBVO9wrnpimAd8i8u6UWPXdv3geR82WeBpn+mHE93lXZnh1D9aI3q8bO2Ttn7XlaHLIxud5c1K+8151PWcOEFce6Hq95bvuq9zJLSvzIMUkxh2CRYrlb2AeIBYHPvxwMED/9F/+nfwt//2335njr7s+mJBg9QP8LWPMqNUggmrwzprHVSd7hMry5Ohgo/Sl50qIiuYyPSgYX8XFfYguNawGCZ8Pb0aMGDkwLWqTEd/tsscwHJqVdHoAl5neIZvGznq8ucYJW0zu1beg8MzngLuonFaILLcuOTZoh6oJS0fVXKjVbd2QG3kbis02AsTTnjsgQ2ADHT6OxWKGRm0tPzoTycemmA2TAUmK3i6W4yJFyabbwP8SpiH4lT/p1B3gRLCB2X8CAO/OmLd7wSb5JYm9VgWHATDBN0VptPdTixiXIyR9QzOOXFCcNw8RgPmwo6ags4J5ekWojvhVHHBQpJGvG2TMO+BQ/YzGCmOF8U3poCe+BV5ULnJBA6Fqr+nBC3EJhM3Dx5DcGPBN0b45uMb7Ee/hH73EfP1xGHAPBhkNw9oB8EiOP4QwY0P3OSG202A3wqCOOG0/jZg4wZl85iJb14gv/0B47c+YPxUMfSECGOqefFLQgSWRxxDZMuhrokd7K48UYzvYMZRAekCGgOIWJ1McUtDgNDeDrgFwAjQiDYr/JtCuSGC6TNGJkWRDAL3jZPno+W/9OPVOJB4MTzfS027mDQfv5snVHNeq0ugH76VvLZeChD9mhbVLX3fUZ2Y8eroQwqsiLbU2n6bC3SlBbaAjyAyjuXchDCjIUyFRisFImzuk8sVzGPSer/X2JnMY78IlU7Y42U8QYEnm3vvMPx6vX+5BRJkOEg8DkwUYwyYKqYIprgChtljDgmZDIAifibd5qLJ7deg91RsxRkSr976sf67EhvYw33fAy77vnk2XLvcV0JG+5n746pxx/qDnndujZ3WUPtWe+irXT9AKTBse8oaonoCRJ/5QZt1rxHv9wYf/WxcoL9/vzremy/lxIMEFGd/KCb7uFNhsK0x9U8WT3NFZQOg2QfKGLJ9CR/ccCjH43eWoJMvvc4bOlJC3Ztj2OJoL+PaEG4XVi8kurqz4plqJqzNb/5SFqjVyAPUpwv5GF0m0x7GV+Tal7iPo9Y25sD6THdqbO1d/2r0WWMtS1L7fIv9i3fTY5u1Dn2ccfuyNNr2XcY+0vroMlfZQPSqnbdt69e0uHiRiXUyK6VnqvRslQOgvtH+ZNcPcJ1yX6e+3jNcBbidzBYaRVaDclT35T73/oBrq13A6LqjZQGlhW4oXZhiIVo2nFXrIqQ6CwaTDJ0uTt0bM6M00dT91iodZ7rUNLEWiai59SEWTEqo0dJQrndRojB03znHKn4vB+hxvhiUV5ueHGyGlpuJPA0sFMI+ZmVz9wAdYEQNB0uXiwgTZ7/fwm8lMxrQbcDAEFZ3a4lAbJALeyQMHS5YHZHTVU/CeSpMz8g2JCCcmDRh84RNRMB8SMqHAXKCP57ADC28RNVqBsAnXj+e+PTdGwzTATABGBRpkN0KYeLz5FkRPKMVs2JMA6uCabrAY3fgnGCaEDLPstSz+Zhb34jcd9v/F6D74yuMfgr7+Ak0755dajCED/CAa/vhmZ5uh+B2OzBwgwwvtojTShsOEHA7YOSFu8eHF8jxAaLfYvDdfSEHQKqFUySFBhCIh6fmFA+cZxLwQXmjCxLkqW49m1Tex952pvaMat9Z4zutdJSpV9NPKvcww60Rk2PueyB17v/YYwGg/f48QOPoMKoDuswHxMuVqHZ0bS3fI6FVJlDM9/sRChTJDXxdc5taHDSerpdsHXqIeK9tW2fgoEVbWp0JoSyE5VC2ZFB4BXpfUFcG8BVobRyn/qj3xsGXypZcG7BnaDMORcgFSHy9vv8y81pDZhixH5Q9zbNGuufME09MERcXa84UdLDOigITtr3CfwLofhcdp20XFXnGUZS0ZvuX2Qj69xes3QFEf2cHLzGe9fK8kepo2vrcwdG149gGm714Ps4OtOK+OOFb3/qz1x2e+8keP872uxt177Ot3ua9+89s69F+0cdVTdrqRz3/2C2sB/ZWqBFJuk53rPPgutQaIFzmoAa2jzC/fMYmrm0Gi750fvGp4otPxtk/3siAsASXrf0cQcsc2MdWAHrrzCKfJjg8I7TaKrk/UqDIfvRNce1/8O0tbSttP/bfm/J6sXDb+plj9fWltV4Zyxz3bsq2/Ky98dmessvPLopQW7guQO7UuOafsHyJXKW43EuFokifhIXjz1LQMITWM3o6YwE9Nf3KlFQbLQC/+og2nlHZbZBnfAgbtFwJiuJzc5inPGVK74OW7SV8qX0CL3qNJ3NEdV8Aq0ytEX3h1FLG6tcWMY9JCXf/uocCNC0NfM5Z3/j+Rka4lpkHHw4NjS2w3MuKjFc/0kec2cAQdyszgIggZlBjSAQ2nnNWPY1p0zMm2YSyuyTN2DBs8HiAFwGxYhyKcRLOO/BLANMMyoT7YNjd6zewCCYzmCf0jIxDcGA8wVAiTEa4rLkLDx0GEwJOgtKITEmHF8gbgByMXx7slc1PhZ7kKXPVQogzQL2GSQoaPheC48UrZLvXmkUOfCoGLhEE5fVWZgTcRkaFrMNBnhZLIbgrwT5pWNXc5egwYIj/86JtHoQ9bp5Jiml4PMTpwkbRXWQWAufzA2IDcg+3JvbaGRQVsA2AMFWFbhavKM4i4BG1AIYnHvCUc953ieJ6YBfgHFQREC5UlIX5wMhqpBXYHFaCDHLOuIlSBsY+7kBK0WKXLjxiUXv/MLm3VUBZCS+U7ZBbgmRxXENaHsgtGhcXA9/LVmlrN80YRXfrH7Vu6DoE4t7u70zpnkloc5NzEUPKZBHV0+XL3jq3eIP1w41i01vQaSpF4nFOBQQtUKoXhcnX63uvP/rjP8b//l/71/BP/eW/jP/+P/nfxZxeEXywwFgw+cAYnmRA5glFFGmdFgIsZf7k4sqd6K8H/7vorF/Xrx6A1DOI8bmraYQJuxQEoNBsuu0K1/sKLLW3Lm3zpgbAhoR2sn/46HPXwp+pjGiftnf73/bOdCRjWqDiAYdaH1sf6WNL9cbLui4BwIqXRHmhUPIanhDBs572BtEnsjBEvurdVvIGev7V5feH+bgsZe/b0yn+voUsXJYNPXbkXY9TIBRQ1D96f6m/7MP4xtDTnQMoEL4EIUMXHt+dgyefp84sre/7920k/cvccoqdXvp6Rf92I91jr65nbt8uO/3E/spU6liuUhz+WhTZSiXqcmUGSzkG5Dggxw1yG5Fo5093/QCLhmtDnaYMFgGifPo3ad1IhkZpxtAAAkAFPYMATPL0toS0qPl2S6FkYiF2de18Bux5utHwuTaLfDSa2BwAqp9XSiEswqtcxSEkJDjxe9LvzZ+yRF4cbkGULjwAm3qqUiS4a+wjAU1wEjJ4QS7zDWjqwb+55XrwOiHM95R5rEL7RshqFQ7OzC0cZgIjBRNwTp9CJvdtNyXoVGB4X6niH0KDTsDLAbwcd7wJ43xlvIZ/+8kTDMVBhEGC80ZRFd6gE+6aRe7+M8PlgGYIjVH9yqbPjQ3gED/vXoTwo0G4HQN6I3x6A+YbQc8JOU/MqQ5qCbA5/R/lHHtw9fHtgdtxgHl4NeXpdUbowwBNd+NiRGpc46gtF1EKlFK7gIUBGZg//hZ0/ggYn8D3j255MMUgxcHh3xOFbYQZAwN8DPA4AH3xrE4Ef9+hIJsgIq+jAYboBPEreBjEfIMrvPii+fbxGiNEkBEWjbRqsGcgOwhuEZL8PhgKC4YMvARta1iwOCqwF1yitXeK42UKlzxsJ5Al5eswaW5B7p4YJ266+lgicVtAP3cdcVgrrKw+viWatWLG+8NCiWjK4Bpm5zuXDe1x/GUcsNhj4AAYUYnJwmZMFCls2ZCF6QEO4d/3YLl8BZChEHQr3iusLpYdUCseVmAv/1DFmiCEhSTH2RhWTfzVy9YzqV1jzb5e33/NOfHHP/0pPkZQuCsnlpKBMm1jBT+GxTjohUDFtxcQ7Wi0IbZn6PsHXbRTwkMT1L5EQ7DpGpHgO3+01LyFUztVxT0t8H3ftA0idzejhy7RAwk/GdqzAWED6td5LevEM7DVhYx+4O+v9GN+FzKM2kzvwTV4up6lIdjbpn7vxbVn9bg/lAtDWyv7Z0+A7ZOm9jbbVOH5Gm1WVdvvWb1ZHd8RyPWdT+i7CwzlGnUZE6E8Cvoz1ZsmVHbt/ANtxXxb3EjtuzgysAuo10H1WbqO49Lhh7GjHYbXR9tZGj+XvWytU2cbW//i97VVqT6hbD8HWwt+XUXE2R7PtzlIaltFEJO/LQHE+eMqcjrPiZ/85A/x8bvvHufiB15fHqOREkCcmQLz2gkE3DkHm/7KcZ+4CxUwY/AWAACwAcC8+FkuABEcUEx4BqUIcLZwm1lmTATQqTwy3ses8ooV/2BXRSABkEUKHBvAMp1W3K8BQHounnI3ErRiZQ6ylRQTAjODlAmrLXDUDAGo/K0JS2BLQA0gtL2x4bSDQQKYPejbBAdP6KEwC22/WgBLLcWwMntgtrnN4ZDT52XCY2cmx8HrB669COhgCBNe7ojUrieMT9gkKARsXhBOmWB3A88JhpvYaHg62AJG4W9vxgAENBXHMXGw1764D8YphPOTS9Z8E2DcoZMxT/VUusRQm4B64DITY7BAjhuOlxuOHxPoJPDdMySxEMY0zKmYryfMZh2gvhYJ5jI1rEvyL7818OEf+xFw/g7o7cD9V4S3715x3ieIJ8Aj3L0IQgj3JMHtNnD75gaSFxC7EDnvhnnOXdAggHH6xNPhNTM+DMiMDEmwSr9LB4FubnHJGA0ZAxKB6MfNg7YSLbusMXDQqg3ggEkq+JngaaPJwn0ohQtCuFallXBZktz1MfZTbFQKlwUNQcN5mvr+Jguuoks4T/elsAbajC0V3ceEuwYGbyFdCoCMjaKIzZKrlqeDoNiurtBIxhBpcY1X4DpFSlwNpp1/JzPZhBkrQJJWxHIDYIZN3+cMF7iJIllDjl0NRDOKFfI6bM0TSYDiIAqtaQpLeUTVAVYd/Hr90IsYoEGQ4YnFZQyoAXIqRD2ttcw7FPDUt6agCKIxdRdSDV7/BW/D+4gbAbgutz9r4vuuhjc265x/UOfO3iw1gLeE4z1qpDtkXJ79fHee/r515DotT1F08ukngO4R9bb7n3xVze0TfsHBSzighVHzsdSd7E8DWyOEp/LZ+xe1lj4zhvcfffer5zAYq8/v9Y0uP9sjzxu63kx7GwGlLncku03ofelvQfLHgTz9PXw9aE3Ls/5af67M9NeN2F7Z3m21zsGJee2XtpOw2/gZz1ai/mo6vT5lRU6JM7vgcRkTtX/5C3F6BPmcLGfpaKtiQAIfhIIyk8ewRDZPGTj4wE9+8of463/934D+GqzpX27RyHiK1AZPD1C+n4Y7EBpiLIHiCPN/IHtKBNDS2qqS+4HDJ6nGY6hS6MvtIIHIXERq7JaFfAYW74tlf5KkJoNG6/xGpKUEojrjQhwTCK1/jMnM47DhPv+ea58LWKR7hweHK9I0TCAHU8W10tTtA54ITFIjy8KGOVchPNnyVifAUzMKMI1g6jEWflp6lWzW6Je5WxOYcYAhp1uBFICObr49Yaf7qI8x8KIGPgEB4zwEpxhsEkT90OWbOfi+AxTZv8QMUzWEQIFphrpPkJ4QGF4YOMRz2d9P4K4T5/0MbSNHbRDBZHeXO4lwni7gMNyqcmPBcQhECEM/gI4PILlDxyeM8YpjTrzRxH2Ij6kCPW3tarl5FqgxcAzGj38k+PGHHwO/9+eA/wp4fXvFd+PERxK33rAXBxQIBsLU+ML45oXx7bcfIN98Az4J8zS8HYrXTydwv4OEcBDhEK9loUyYFpvbBAdnSlp3MTNDWCkOF+BEwAfjGAwJHC8YMHEXEDOEtcljR9jtfW7NInig9RmkH0y59hQMahYWwkbrGjRivhaJy4URMUKGyRpCN4WPExqn9jk2OG1SZZsDdAAIhYBnKTAg45VCaeFyQgqrUSeGPC30vp/jP7HPqjYKuSumZdfU6+MQwdOmoQnzTMVH7B7mkbQ2JMAnQMERfuN7K5nMhLs5edpmb0vVQCFRkUq4nfq4PBubW2ktXLTMXHjNw2YzYPwpiyX9t/3KlI0k4mnEhcFTKsGCRIpoUYZE+XozBpNGspg8vBMY7TFDneTrE9rpdIPSTxYzXRfXf/frCsUbxvVPwgUyQxsBrLOwEB4WyCnhZMGdq6vG/mfc1wEYYs89ERjWR0+g38Vl5mGEdJmDhegK+BlCMM+brQPKS8vPWMY77T+7J4UO2qQ7elzyvJl2GWoZXy7jpgVNF6DssHvdXND+Oje9AVpzkYHrGzvOR76HmVzjdnbFeXNtx2PmsQ3UX64Cx7Tu3lzdLzRtl8YobqpYhwTYl/aBpR7OD6gJ2DlJ77kmPfTa1pwsUSiYtT1/LjhGvPtJ4zGXu8iCdSZte9P2sVqbyz4PaZXAir1IuJPJj1IBmf8q8UUVNvXYtcEev6aqX6hg+fz1xYIGT0c4NILxRjpZgscleJyEeRYicrBcKb0QIoCld7dfQgwMDp9Hcz/kNoluIiNkMb3QTUKFXCpI9wsEgDcgfaDcVWJ/X966kkUaPI6AGvFr/XQ3rUif6eXPQQHzXMjIHnmQvJi77SBcjlwwikUNFxQlVADRQXAXo05wkZqGYkw8UlhIsss7KbCQF+xLU7/NqJFB7nLhRiQHqEqMczKmqGe6YQ9uUSPovEPt7oHuBpiJg9IDAKsDa/P0uuc08N1gYjAOv6+7gZQiZa7CaMLsBuHDhR684T7fcEJwG4TbLYIv7wo7ge9uJ351xvoRQ1XA6gXgxOB1SoZbIYiHV7kO4A58AB+/BZY76GScHwHMiXG/Q4ZbOTQCfSlcy1wyvkHGiwsaBwOH4Pzmx7A//h3g7Q2Tfwk63nAwRwYo81S+NLzmhkQGrRtg375Az29gJ6BzwlQ90PQFka9/VdkkYgemA1Fxk9Y5MfwXZopArCNcu8KsmTzCHbG8Dgil5oLDOpfp6sjd+k6F3hkY6X6Y5O80nFnBcueZwq0emAAGzBimCV8s5PSo+6AhpITg6uRp4HCddFlaPbDElgVguafA6TAYd9W0SNXiqYAylH2zzyeowSKttOWBQE5D3hnnARQaAyO4ZaNqe/h/jVLIo3Xi2Zojt8rwRVflQfQCroQUBu8LTQXRdD5IjFkIYQG24jkz+ISY1ybK2HxCBDfyO5Vsv15fcllMdtaccQHDIJnJTQQyGGZu2TSbMKVwo0o4lGdExC7QAhBWLohP8VWJJbZ/iPVAvie+uCKvfnUQSDm6633rbPamU9gAEML3IyKkGtfTQVTf9i/LS7C1Zft/4qttwPt4HgBY/tznNIHb7r1iAeabe1ufN8I2pfurO/jcX9+D/N1j+rq+fc3a8NBTV9ACh/S8D74WCV6vvdj75n8trHKRpy6u4q2NciXK9c1F3iemdaVefZ2ZhVXaTQ9CdV/U9HLJvxp4zp8VTLdouoh0k3pyEv27wky5Fx8kqCWFbaoBu/5Cl5+XWa+1o8uHi973N2eSlXywzaJle10h5uPprdU80ZqXNMJsvc1zpLw0kldRuUdx8gPqzyXqCN/jKOArEol6uCm7fw3XlwsaHkvqV9uFbJ6RKD0xrIi4WFcT/Hy0nP7hGXsQj5A4MKnFoCCR1CTFwZ+WD5/QnViyrXJveM75HTBMDn/wZfrKoBzAgfZ6MZJ0kIJDZxAZkqfhSw7E+uU+SusCWT3u7XONlRHWm2iXFeW73/cRBXPPuSX4fSACiQfqz9BEV1Xk3OhhuzSNgEcznAoYFKoBuGJziPgsGnnA9Yh6CG8TwDihdMLud0DvIChowmNVKqB44HbccINinBOvYHwSxsshuI2BGw+8vCj4/oqffiKcfMJ0QlmgeoLV0+zKJIAVKm5BArl20kRgcngw+7cGmQZ6I1CAYpkADxcHT1PXUkJdK0/wzE2DPPUsA5jA+Ys32He/gOkbJgg0jjAnCg4Ypihm5OT3tLgEVgbeBHo6ZzYjkIV1ISp/p6BB4hpUgEDDN3oKBSQEuvke8GDww4Uq9kJ9LOmi48IjRjKEjKBCBZWDQwDI/RTpUzXpN7ejJV3zdrA4zTGWv2Dbc0YQ5a7cc7pSNxbI9BS6Rftp2UDXRjnH1LZJk4+s2Cy4xTNct56FKmRwvlsFmhYvY0Xqb3JBIvYlFLDMKmTB+BUAVbLq2Fu03J0UwcAbTwgexdxUGhRuVHEoKKyslp4bIGfXBcO03tCkdQZz8lMAqg8Bjl+vL7/+zn/2n+EnP/kJ/pn/0V/B7/y534HcBAqDnBPDBIqJQZ5gY0SGNpPIIueb0d0ZFSg3iiteAp4jyc9eecgtV7n2zTME89hCBw/5WXg5M609R4jtYKg9sv7lwf5kIJ8b2zvjrf13beMz1xdNXeKEuv/KDOKnAtuQuGHZdnbm99QW8kF7GxNnjMAsADaMs/djCz24dLG+akJMgsWFeWm/nxbcunbrOq9L8H1vyq1iaK0Axd74Vlf5+s5SwuxotwPgHBM9ayZcbqkLEvR8LNb5MoKWc+2SBgr7YDtrahKqXR936dIKC21d+6IrV52uI8xJDdrI73fBam+IqLcRVjogB9KwbTxgj830y2IijbgmNc+QjFFbQgk8VlUo3LIFfAyMY8AI+Bt/89/Cz3/2s1+LNQP4QQX74j8loaXEFZ5IFJ5qTaosV5VYaItAR5ACGm4MwbHXIW1to9CihlhDf33IYoSKsahOUogYV3H/YTCRjUjhCKd2CdX3rgEP94ciHO9ELmoxGlt/VwYtwAO9Z97VuI8BUD8RXBOha+dEW+lOZZXqYHW/AxQYrQB3xEEDN4dV5qtpgHgWJmP3ladpjuzU4w90Emb4mwnc/UvD154FkOMA6MBxF5jeMecbpjIw3A+d2Cr1r/d2YMiBQQrme8WCeFrJsCaIYXxgHABunwRqEyoTOgVTFQyKQHKF0iyNMwuD5cBxe8FxuJtDVj8/Bofbmwu1E55lyLXwVF4xEI9FGewuQUMMx9snKBsMr2ABFAcU4bcI9WxYMYZjCA7x5LjDCCYagJVifQTEFr6SaaWIZAEBaMDigkhkofIq5eYJq8StGflMFsvzR1MTsVheMc7ttPD5Igkwm8HXG3AlwDjoTIN20xGxMU3KPR0WQ7Oi89TM9OM32y5NaZK2AshinP1kMiw0lLuJOQoseUzWlfGVkETZsO99irapv8DiRMxAbsp7sr+RIcGAEt2S7wXzyVSVq07P8tB1GT50WUKgmQdNMjTOzQsvRuibldISYkhJ0LmFkb/PDJl2++v1w69f/vJX+NWvvsM//U//D1qwo1s3KhA80zpSuhEsuEQN5NRZU8CiA5wl2CaVftExvY6Ph+fbx+t9CLpfR3CRae3TAjKr/cRc/kzzSMjz5nN9vgyq7/CWuLRznfjlPZS82ruGmBTMQG3RveH+/jXwdTZvA760jcX6aOvHGmDxBmCB473J1a7lud505r3/hMIrlQq1D36tXnv3whXOQWy//fHXenbr37uEdKGxyx8PXiDo3z18hNwEJYc9jKr1z7CEjVy3WsPdJTHZdR4LV428/24PY8731Eub0JlK1FVqAI2eLu/PhwgrvqEPO9us/i1+seZqEaw1Qt72T47rchwCtu3h63N+Y3M9Q7jh1pq0/l94wl4JnBYfFC/4/Ic/+UP86pe/xK/r+gHpbQmYFK4jfnha+DJ3huc3O3gmDpeKBDdx2HMuTqeG/AyN7vNQTzMPrS8ZnlaXCa5JzebbrvF1eGAzIShE37WlLSxCJgBcjIETjISmeu3JxpwoDqFGv4QQhCT6ZVRrbwTMk1bgaWMkFhUPi2h8stamIgeykwzQgjIASTAldQ0rSwTuZjYrgiToPhFr6IH6woSTCZTxFaReIBDAqS754hAQHRh0gCfhDuDOEzSGZ0tSd1HSmVYUP8DBgLIXwfAMSAPgAeCACaAywa8nxskwTKhOTy1rkXXKCGYTmu44BK/FcdxwfPuCmzJU2etviOBGwwF1CD6s0yuWwyuXM0X/okANC2MMwcs3gm/A0G8M9ivCSYL7KTjNJX6BgXiWUHCIx4m4ZUagJF5gzdjd5CaFvJqCMVWGKGIJS0XUwjCGkMBIoMPctYMyj7U/5wHoiOw44fqTgdPlg9kOyCAozeQDFZjvn1sW0MyNFXTu1E+1n1wwWyBnbZTgBZnRp1RN6+wuHUAPpkIy5jh10hwTaX5rDwmlJiFA/hPQACALC6a7ZD7fzhHf1eq8asKWo1gOZXU9N5x/p7G5B1aMX4HO9W8lcIgGw5UqC5LuWUTCnQsOYor/dCaUUwu3gPw6AvL+2365MCFRTyPTOnoc2ZADMGCMwxOMTXjqb0qRWyPu5lnLCSaoBNFFS0+ujpwLbD+7u7nVdl8eWkDKC2Au2gK5/iLpn9aWqv2bEKgMu9GV+azPV/T6MPTclHHj5fz7zIMBvnY//X2CGxwt9EgLkW1vof3P9175me870MsztTx4Ukn65AXbWtPll03xuj/gf1sJr9e5L7VlWtGuL758UCC7d/NZ5y7Cx8YHH0bX731Co7Ukj2PY+O86Ypqw8fCCrVkDsIzOzUWws1i0/hM8N0oOOzvTreT5fJ6X2vr4dMzrfUnqfR2vRqGNGi+kaf3PnbBrvLLNymWG7PpxO7wKHboCmvLo5PV9neypvCRPmS8yIHJg8IEhB4x0zfWv6fpyQYMAmkAWuAtRw82S4VIAxPdm7m+cp2UGgauBpoWmmN11ocYTLSpFbIcD5qKiIA5CMn4XMsQik0toSJ1uLlT9cIWIS/D6DiFU1IZgeJBqiNGEcE3qft2UzD93GlfmKsKqxZF9dxwR2mD2QNAae4KZAGLpmmERJ5uAgxIgFsCJAyZ9seBVwoslUmxQU4+fEfM6DacPRSO4XMjfz+yClKp6cLco7gFwKNafeEZA8AmSCRuu954ktfQqCk97yuW/7FmnDk/JSsPjeuiEvoV2lxjHix+tenpchWRlZGLMSZXNS4jdbembG25/7obj44H764E73UFDIOcbBiZOUcy7QueISfZwXndzIZhkjYoD45sDH377BT/65kfQD99Cf/JLvP38l+C3Nwd7wmAztwiZ1684WDAG48Mh+Oa3XzDtA2bG06hC73cYMeYMFybC0iLIAGEAQhhEni2KBTYYk8zLYlDLCEZeFlF4bQdTg7v6OP0BgHG4eGgelLTAMXJL0ubnbEknQUPEi3686QVyXJAJS1lal2yxynKjJFQMBgzuphfbztJvkHgdCJlsglyTX0yVteSZypTRLwM49ng+lgoCkuAlNX4HilF3DwYK4TFeVkV/8kdY/hQeN0HtX865eVYiif1ZrmopOHC6kbmlK83XFeNGa9xmtgEhMg9+l+3U+nr9SS9mtzRxxWq4RdOL+DHUBDzYE51EcDjgyUI0NX+2gH/trQ58N3SFRSv5mV1WsjTBaRe4QrX+d4CtFDI2FET1Wdf+2kNL1J7FOpvwDLyjnZ+t0UvDROX08RnE9vhc9bfaXkypprb3q82dA9V97J99X/6Zr0qe1+7b56dZXPXSN2DNW1/vBgApOkntBmqrYMX4qBang7ttyyfv2zu69weBBzY8le08mR9LpRM1npZ96q33cT4GUKcldi1rd1993A41T/HMssLTvlY1J60dWkIXXWhxw+1Yz1p/2cMLnl37PVTzuFpr3WtrtvDeVWjbWngwjTUxm9p2CxPEY4+XYn+tsN/bp3I7qlp7VC5UnmXK/7nSRYYrVLUv3K/p+vL0tmQeqBgbFGaRctJBNZBa4kCbjUGRpb+ygSUJkRpzDMadm1Fi8s0WCDkoBAA/9JVcGzgJSyWTCAfNM+4SIJTaYRBKy7/0i+E20txMEAdKeTQgIGsEXjj2oUgTO8O9I/lTwq+goAiusLLlxdvDBzQmYs0bzLOgEBzkg1rQaYKqAJOelwcDXud5hvY1hTKwAzgFeRB3jtPYXZ10pT5NEGnGgE2IGmy6u5vNE8onDArjCbmZz+cUcLgM2akwZpgQiKenOJ6EKQdOGrgdguPFwPYGvBrm6wQIcdizJxyQAJwaQbiW65YWiAGWG+TthuN4Ab28QPTEeRecr4KpJ+i8Q8qdS7GCwcNlTQZ4DIjccIxv8OFHP8I3/9jv4fVnv4v77Q/B3wCDfxkpSj0omQSAedDUcRMcg8E/ItBf+gb089/ybETnxPw0Q2NA4BFolZL+PHbD/6XLUTNjCkWq1Mj5n4FeSkHrBMMEWINZZzh2ZzYUQgVW3E0Istbo2mXUiJVSRMxD7KCIJ+r26+UH2txJQsA2de2c8fILD9Krqu6Vtz+cR53/B/rnWXxh+gYFmy2zdTDG7ToNFm6BgIVOI/xdh+8pUxe+2MwDrwHICBcniviz1GylMmF2fpRjaVAw5oFYIOzxThqZtDJu3sgTMKgOt2qVAsarflPQpbFPUuS3QE6eIbTMBg8m/3r9qS6KAzWFiCGMKQJTiwPWIDogqlBTDFUwgDPrImnsT00ajnVq4KkOibLix2d1dnc4i7rXP3sfpS9Q3MBp/ct3Lmjhp9Pejw6K+s8SNHozJVekCPSOHJLjWUdaHf8bkK9x9F8aXOugO25IkJlt9s+7kJEuNg9CxaWv/fMHALyNJsaU2COB/kqriRSO1tyuZQAQwgltbW/BE7Q+8mF0oWT1tIPx5Ke9yesgHobbP3hiXVlNPAG7+Xm3VIcyZNECNZegJUz10S+wu/rbt0zFKtQeWvdvMxgTkO/YdkSCb130bkVXOb58IgZgO91sr7aGIhX7eNZUbYJrUmWdmbXv88zYadoFpvVcLTT3paJtashWA0UPtPZDogOKzwpX0KLdrJchwhiDMY4BOQRyE4zbgNl/jRYNAPAy0MvcbxyF4wigdEbIBDagchvBDD91Wnl9gZijcOfwGN8I/IlEr2Yc2sfgYhPAHS12gaoPjAARlW9+Zxp5/dv/1N/C//2/++/8gEF3VvKbuP+959+7vqzd6yw8ZcK/tssefn02C9tn9Pz+H3y1TWb7f35wQ8Uwmj30c8FQm1blyiR/g9fD+XLh5E8PJFtfXLtZXb8eWJ9bPFsA5R2FWXt8BxDvn/6fO0X9b73EKlSWqrSixBOWB31oeqKMS2SPUchcAl6+u3eBEMaQtDJGX6o2iFIltipLIy83FTMXGL0abPQqBYow5asAyhEaXiee+cHGqFTHavRk1b5eP+QyM/w//v3/AH/3934Xv/9X/oq7C4yJcQ7ADHIOT/Mc6R1tGHR66mI7Q/ikhDcBpohKWXXdQJbo94o325+PsLJ98WS5A5JfPo0X8LLS53ifAjduLbT9srWae7eEDWyxKav/thq4DEJbX/ceU/thD/P2DEg/iVlety9UuQ9kQ7J4mItdOHzeS0NbvybMJdarR3sfqIHGBgqfd+6xX9zusMvCPD35vxcONGqjRpO9N6kYaWOp8fP6vO5v/ar4nBZ8nRbdhG0W85J/WNxYS9BB/TtD4+2LFDJs02l3Utz30vNJ/Ox+u8zRez+zDw9HXP99W+o+qi2CcNt32wFsjx9V281NMq0pHMHg6QmRHggET32fMWqedW94spvhaf7/4//ob+MP/uAP8PHjn75IX79+mKAR8RmbOZMpfJdDCoo6AfDzvPm1+QGthHCHAWwANiMnfeGHcIBirhoQWRCLDDCOahPpdpHPRAVyihodlX3nAhSNDSfOHz5TX6+v19frv3GXceRUMADhr+7pd2mdL0Ze+2MCcypIJmDpDUueLU2Ak70QKU/UYZjns/tcTVRADLXvmZDF/wiI9LQECx4F0uVO1QUKSmsdFv8Kqxsxo+sF9eEk/Hr90Osf/n//EX7xy1/h93//r1T1WxYG66qGmwewiXp2OFZMcGRqt8Kc7qLUgnWvrh+4xB7Ec0mUz60Xn0GVvf0HcOmuEHnYWovF6kJF17xe2yo33GtvbAkM1v5buDs3mV2G37QP++dXsJUoMXfcZXAd2RWW7bN3EXY6uO9m1WqDmhBC7dVt/C3OxhWryQeWsPE4uH3+urBh9Yy1+x7tPZVYw/r4dni6jf2Cene8vNZlLf7q06KLCx1epY1GKLso0AnI6vvs43aLPQHZFyC99cXa/LXPFzfsc3mhBewksF63v7snDNhovwsYG5kuaeKqWOu7w28wbNKxrbm/rHg6ubR2ctrpcQxtuij3JbU+JY3Gz/x+ZbeiZenYAsDDdUoEf/gHf4C/+1/85/h1X/z9t+Qo/W73N/YDksDlD+4uLuT3iO30mn7J8GDhE5GqUkseqTNYzdxHP9PBIrIr5U1l/vGAWYYf0NaY6BJuXNv6v/lr/wp+9xe/+2uasq/X1+vr9V/3RUr43/7r/wq++fSNB/2zOaCnsJ4aR7X1xbBVgckEFXbPrbAwEPl3p3kq5C2AvR2WVokgPJ7CUpOSbqTJC1OYqMB2d8PkuFexnFHIFGRe1yZj+oVc4ImKPZFC/AFdfr3+BBcRcIyBYxyuxZMB4QiEjH8isv3jQyJVtbvuSSVmcODAlC4TVGioDvx8cR507c/rv/c7ffmHBB09o124QhwEEVR14Yd2v/dln+/GQ+/7ufveq9Jtow8AiD0EvGut28DBl/exANu1QxUVf5nSdOEuwNdEqxqmf+JFZQMOGWrPPnaEHtZswWSqd2QsZ94S+hJfu2em4ry5R0J/5qLtbRdEm9cmDbePupKWsNaxETVdJzT7v0VqY3MFyjnfh+e88aoY3vZQ7++VJuj65bPvHqWEqxC8jeXJ/D4lyX7PytLw/B3bCy6vfuedG43l3Ir/K9d9RNIiy9X2p9x925PwuDWDIMwY5Fkzb7eBl9vA7Ri43YZns/wNXF9u0WB6WDBqWWIyB1xmOdo1Jm0bWUqQlEn0YUh/aCxxtCQ6Wz6Ymce+LXO9qqS4fJ8FkRr+hf/0n8Mf/vYf4Kc/+hmeUk4TFbPozdYXGFIlmc5ftktS/kN7yk5DSZOlRdlZKuWzEfi9vgg9WfrGJ8/qB4c13UZ11oDIzV/myJx/ivmmNDoWK43HlzYhmgcynajl/Zm9qvv8uxBo+VnE2tT6oKau1pEiPStR+L1MxTTFGX7xK51vtrUUBBR1J0QYPCQ2krqve/hWuwRrXhekDS2nu0fIpGRPPCBjQG4D+iaY8w2mr67FzimMLGsZp0A1eVjrDLhmiryvqJzWwWK3g5nW+qw7Yg+F/wx80rbgRDxqta48Ep1WYgIL3C7iXkv+SJjtUO73xgIC1S//OuJeqg+ZXGFNUlFsP5vMg6nzYPNt0wBM0+5lZifAgf2/+B//c17vgGeNY0WqXMACqOKZVha7C82r738TLMEhgUa4YiVvo6R3AIgYmdKIZGwLUm9Ja85p7b0NrO2n1drTljP3PYji6/VF13lO/MN/+A/x4x//GD/+8Y9j7+c/KrcCovU5UwSDU/s92isau2isrf1OV/AEFDNfHK4dmZ08PrPu5XfNFH2PMMbWdnVve3D9sn5N7rBuWRaR1aEdBxXze+jr1ZqSPy/HTM1SJoHofV4deejtfs/1NW0sT+Dc4r/rWC5eU/vUHp5aAsmFuS4IQftDgWFovxOPbkL7yHouDJ/HxUc6XLn2c39XP1Oam1J9fZm8Wq/O6+mykNinsI39YT2f/L6U9O9ws2J7sZ/o8vlDX9EOvOvVgJM99jGnblkzYo5zH/czvvAP6vMnXd/eXB+2A69FiNQc9H/rfGhDS14T7aSl/uqW6N3aTz4Ee6gEKgTnYZyKCc/AJ8z49OkT/viP/gjf/ZpdpvL68mDwIjryTCpJRex+y1mgK4Mt2RA+y9THCYKFnzTBXamsFD2snhUpC5PlXk2WqRbahNQYmrklJRpP4GZI4WQBl//1v/MvB2ihmvgUXsALABlZ+XKTZWYdv5GgYB4wE6inFgrtQ4x/RsqdzLDD8DSmyv4yvoTVWR4S1qoBN5ABg54eQM/xHguiJyOPS4kgc4saAGQDauLhNAEq60Ca5vfEhHmcS65t2I5mAjKD2YSdnqLK73Ugb6SOv8N/XaeDek9tq+FHryFdw8uUmGHCvJyHAON2gPhwAHc/8TpPvN4V02YIDdPn1yt5RPAsgclTUR4vB24fXiDyAuGJc95xv9+h5xsw78A0vL1NnLHOSXJChpEMgDgK1RwYt2/w8u03+PDtB7z+6gPun36Oef8ZbL42q2nUucjsTHkwxQZ2NxjP3sQDYBrwVL6hYyC0VK4eWbSCAF0L4fM1oTyhFBoJc823Reoji5TGW6mHbFa9eBwo4pgyTsqCqXJWyi7RseqStU0KZFY4RJh5OMMq4GmTiUAziNYA2PCFxUr8AEQ2JeagVyrm7nzANfX3AZzZd3XNP4kzfVVe6fpMlxCW/Y1AcovO17nIFB6dFvsatRfK3UPXXiTz7FWRf2ADIazujjVBINLIahUHv2VXKCQVA0d6QEMeLrbOPbOW0dpWoH62GPdVVl/DZ+OEvl4/7Pruu+/wf/6//DX85b/8T+Cv/tV/CXJ4Agq5e9YpGQLVAZ3qWeAYYJ7Ozs3cx44Ixuq0FYd/pGVoYsNnrgQT9Ai8n15PvrTwv6asBTLYMzFGMo9S3huWoHPFRx2kPeLOwkkbmLk21LPAvTeWSyN9zPmPsYSNaxvv4sgn83LtayqFvK/P76vuXV5UbUT8KCUUuNy6uOTnOnydPyu8UsRwGVbxNCQQRn/LQ9tb3pvez/4aYC3AdZxPO9yI5J1xradjDAlw27nbG3/azHVCtz93UL2QuD15oL3s0u087wAUjsoOFw6qqPL1XQ0tXRNztPZkLJXF63Ff9Dl6GG7fi7Fgyy6RT9Pqc2slH12Gw1Bwx8MsWDXMwBD2wnwel3HgNg78w3/wX+Jv/a1/+zqaX9v15YJGBHi7Ri+cmKPacGrkEwCTkbslwMJoEW4DAVh6wFMBIqOyThC56wCsyYBEHvhJ1goMUWXhKaOE2coFO+tEB0c6ydRoJnhxwmlbO4qJJVNZwkYsu7o0lW7ZMES17wCYk1dBOKDAmpl55hs2IN7vrzLgdDCe4rODseiSRJBpcBI/PHaQm8xUPVmn742qbRAsMDelcsxxrMkkd1MTTxsr7EBQydM6Sgh9kxxo+XsYPBEA2EIQMEzz+g7pyqJn0E1YcjjAKhm80N8JT3saazEGQYw97a4yVAkGgZlBhcCTAWaMg3EM4AbgEK+pcYqnnNVIQYmPCiHBp8iwlWs8ABc0lGCR0m0cA8cL8M03E9++vWIcik/zxEmCOW/Q4uBcGctK6c5+EBkYw+BFv5g9tWrUxQgZMzO6Qjm1ohZrmUzC449ILEjRs96kcB2OgkHv4dNfmsAFclwoyf1E20mSwjrHXGQ6XhjCEhPa+JSZkXvEx48gU8++xRGEnfsDRSG1keMTIw7hN8YaQijE96sFYqeYIw6k725FtCxRFPO9fCVrs6SlIg/kZMsu7MTM9ejRSLmdAhuHa2iCe2LfH8nwLW73bgRPUoKauRUN8Qz5Ss3gHTQ5WNgSPbq7aAJC55cEC8VECiGP3v5frz/tRfDipUIMJYYMdr6m/k9UINMtrjwEPF1BZux70syg7K4vGu56lnmTl1S5AmFrkds62g4gn7hlt4Ngfekie/CBpE5jxAETCqWgdcr3xn4q3kULFOUXcUw8AGYrcRn7V1Rj6EJGB3RrHL3/HVunVXQF2T+BYdH2Z9Dq5oJkrf3gP9k5NIvuhlPX/OSt1m4xC+zQx37px7JQ732k7YPrvKDxyd6vnI9qeevbtqZraM/jni+f+0eZWeiRs1iA7eRx13GuqaPL+G3dakG6Pd6kLe2lOdg+q629NQd19xMBY88jEk8mfsxtR/s9/cqzpaxWRUA5B+vcqPia3DO01qLT0up6nstxfyYYoesoW59iv2wC7EYRsZcbbSylJ9W/cvNjd/kcmWlKGENc2BCR35jLVF5f7jqlWAA+wWsCn/xcCek4RuRIZWgwvayrEVYGxCOYKAGAoje+yV3XmgCHELnqa5ut7A/JM2HwNLDR1+IzhnL92tyP6jJk3nxfvGYijsCe1BLBHIwJAcQUINSWRpgJOrmAlLtYRC0A8arOFs0yrExz5bNIbhmIPFolVAE5Rm81YE31k4wDDHFzRS29MkhrAWNuYxMSeTrhQnGNuYxk26gFIzBYFTaskBexlUBjMzAXYkNRuNLFPNRrBoFOgKLGxISncVUL/Krkrk/hc4ioiWAWgNAyCRrh+EagbwN0ipOYmguLHwwDE0YTWVtByOtWwACIIN2b9DS8/eIOOifu8hq4UcAkoKIIZIqzrCSxKfSYCCzuzsXk+0DX1NVabVqKCCIuqs79pUkfpz/FDFKu9aG0GsVK5hqp5ImfDLnleSNA1l8IpzCIUlv2OCHib44TzJI0klmesbWI4wD2FMQS62wp/BCFRQ/lbpf7UqNNRcQnDFci5PJk1hMfDpWgUoezUdFWHXpV68YtaNT5lUWWvNjnxhayhrtLCa+x+ZgNgFTYhSafojzE1kFrpGFB9T7PeJ40BO/oeAp5NY62Hvk7ZT/MfJ2JIg/f1+vXdZkBNh1sCUdOeRBEGToZKh6XYbCwFghYDcYTCl9XhkKluTbU/qF1bhBqP3UZt8GmOKIIvdgf2vfb1dwjqKMLpXDrtOZmCiSES0N550EdwCz42gHu3scHMAQ8Ith8Z8dM+d8OitubH5Fo31ufsRL1xvaG+ouX7NffU+CgjYi2x9bzlxkpUNxAOF2e+ewiXqcs2knLZs1V9XEpUpH0lPNymdBlvKK9L7aWykLZZ32MDwNYny0vJsN18Z4OrR1BbfUf+9R+rjxSrf/5+0Zjvrf2Zq6NNr3/Ji3299ImryQW2uE2VZxMn55HhUCoC67rep2cRlgrLijXchvh42N1/+5ylWPJD3omzFWpPGKLmMBjFSod4m5T/80SNIJISF1zEkIZ7DToDShVic2gUC+ORgLXygfYiFkrZifTeWSkmncmbuGikbkrxUGXKFwDGlldYJmuOjTmgL+Pa11c+/kGF0Ail3+lmFTvJ1RLy1NMHIGCGveZcM3+Dat2SPF6AFn8RoeFIJGuEAyIgeJQygOlCqNEG1wb0WthkCFS/lp5eaTvrxHBxAG+GLxMg1JpmhWufQM7IGeLLF1qcAXrWoPajCEUmIZ7jkXGjVi3AsvKgABTyIv7zRaULwY9CTwJPCxcSyzqjjjaVDKvlwGvF8GsYDDUZljGGMpWGcpEPfhSJbKVxfxNBei7E8dhOD9MYE7YqaBJXsNDCYMdBBv5XEaZPOB0kJwiwzSGnYQTVgY7Akc1b79HBWleiLkzSDBtTgmKeT0X92sIvzl/rE6Ls4CIL+4Sb81pkngxWQl3ohDMXYnJoX0nH88AMAQzrU1BXyZO5kEOAKuvgUYgaadfdaud01H0Jl0Lk9hzHCnUGkKYNggRponXccnnsqLytp2sDAqlCQsBkmzFVdfmQ4I1K9r1zNnL5az0/rFPDC7YM6XAFK2lpcCWsJNB1xQ8xOD0MdXnz+6tK/EuhmUeT98nYeEtV6qYfx+Lj+EwF0iTTVYIT/mKGmgocBp47obyr9ev7/oH/+U/wP/uX/s/4J/5/d/HX/qLfwmHHQARzulKFFPCnK6cOY8og2oGsgEGQdkX0C34GfXfwJJdAPL3uL/lc9t6X9BHP2sqk0z6/55nELCGUim71FomivS2SwvqVBn8fwtm2/v30LfPDeTa92djeee25y+l9+/snXq3MUftGTtI3zcQ3/wBFgIox1zFdi+839u6rl3AoPjStu8ST22T8Wxo1N+Rq7W8HjYLVAPO19CK/RZaN9YDlz4+k5i2NXxs/boUDy1knwqsXfpG7ftr81tjtH38fSTy2e8S19aZtssleyPxm126mH9cB3ydkGj8e+kvH7lYbnqzKRasGhmIw4QcNwSzYPL6apm2+5ADx3HgdgwcN/89rRq/yesHVQYHAKgPxJmqOvgRDmCacEnXv3CZMGMXNsi15xSVvMvSUCtsIJteOdnEXSjIM7Og3HCaD2poryXcJgr0R3/IyGNFmxrR1HmIQ9CENCkEMHiGNrZRPsHd8zHcD9ZhRlINFZA0otC4m7sFGbs2fgCwFuANl2rTIqRm5Seo3fkviTM4Sx0QDBi7Tzul4MUOCjEJrAlvLCY3UFxkKiBg1R+qTDnhu1J+Iv4oG6KSOfnMMwFMnsfg8MJx5ZJiFsGUFBPiQikFZ7aIbSF1Nygm19qSqbsh2AkkAI41qKWjoJvwy3daOHFXhX4i0F0d/A3XrjO8MJojfadbIXahha1cfpzZsOed1hmIPNaVPDDUIB5WAUJqyBnuCpeuT0kvXWBla4wAoeUm80BT5RAerEBLCuy+R9iBf+4JnWClJnAl6vAJ5jPHgtwdTjNpzDKEm48DEpc4w/VnIZhw14ujwkNlfP6atcubcYGXKeKDaAIccSlxuftGFKVLwcmi7bRuioE0XARjHjTcqSisO9czsQQejj2eTSLdVSxxV2kGcw/5HlxjSZemHq9loIibsrXP6wSKrFXkCQg8jW3jPQTMdGfRiO0qywqioGFosGPfbsdaKD7ysN7N51+vX8f1+vqG19c/wuvbvaqErxS3CmH1NLfBzzINrk2GaljK4GdIaV8bCCrLQDdjADsdxfP5bbbTQfhz/ELbz2TWph15WrOQJBC5NLRdSWkL+HYd83M3ljauZyCr86F2XV06k1cCeU48tP7Y1XoX1bvWcd1vaLNIfS2aleBhfzUhsSsb2/j8rLYHYeNpP9egsQZJSxipsVtNWa5DucNEg6vezt5fH2ItnN8b3+1rdxlIWIaDeT4sQFqC3yWebhrZxnu5tfWtDXm18aSH7xDqteH1GV3mxZ79Qdt/+7579g7a/6yWqohs0dyzPqHWpU8rbfdQa7s5kKVmrrll5ZRS4YxOJ6n0XspvTvcphMBBDO4Z9djduv/oj/8Yv/zlL5/Mwa/v+mJBQ2PMGRga2CYCLlHndM4Zh6Yxd6FaWyB2n/7OYHKS/TzmmliOTcfKALzq9gQW4EB5sxTZZLCsgcBKEGpaAI/X9DjseH8ZoyKrCBthTgrrx+ohhz88U74t/3UiWDgK8A8oiC3jNQpkgUpT4plu4MAuN36KrT50wCi04bZ4aAp47DEs7r4xXQwKv3fHdlaacF/DXE9sK5D/Ui4hnwJYdqNKwBJo+pyF03LwckNmZrJIMWrxMkPyNA5rQvqBRhMz+lDB0zn3segEIFxUcgMqGG8KzGkRLJ5SvQ9WQAip0oMmwVVrxXI+KuYl4kAAd19hjy2oQIwkZ1sbursR0ryckqCwfMW4ikhi/gzNxS4OmlgrfyhE6lC/s6UHmbuUJWAuhUbxLOc0GtYpCs24NdCc4y2XqNWtcL8w9EQP3t91ICeYp9wJlHs5grWXat+nb6jvvbBEVjxIvdMJTXssVRySXOegdzSTGGBSubBRkAnBoEQeABdJCJLP1MpYc4XLDoQwle4LafFoS9nOsrDUmcuwMRUR4xEu8nmuUvKXPBQMy5WfUAxNHs3n6eDoXXvv0P16/WkuYgbJgMiAgXA7FRQWaZ0KIvKfAABzpQbcSqxR7d3ZszqdO+Yv9lwcobOGK5vAhmMe+0iLnqg+o9Af+QuTBj08agHWdbStfZyXtf+uQ2A99LxPTz7NIw3YVf7bmDsQvUxAn6ze5vYqal88uad4RO9SgjQ/yJJX7Q/T1tV8brkxBR8BQNK61IaQU/bYZds/4PYsgAehM/m3a60qHnC9ZI0M2XPa+2SX5dypsE0WJROKNq4WuPZ8nSlPr8tattfQdldjioSH5uqcz3mvdtoz16Vrf15d/rbmN6tSIpk1qlqGdWR95trfcR2K9SnuN2ieHSjFZO///gof4FJipBWuYwU0N6rwTok9XvEZcDfxrJEhY0COo/6NMfDx40f8n/6P/zpeX1+/d+R/muvLXacSQRdgdK1r+R4Y+ukKFNkGyOd63AEMWUgv/SVB/PUv/P5L6kbLcx8bpN4ZW0LX1nBNI4Mww12ieQImiDYCIojapQ9aK5kO7ZQ7OMFW35TNvSHAw8ZTOf5Ih/hmm0vjRjH8fFdl1EFttq7Z4JBkyAgaAFhj75BOkJdIR27Y9JUsGSEFAiwpGNUP3yEFXlMrpk70nDtoG7QgzdIc4FEjzgLs2VDACsOMEDSCDndtWqcwwdSDp1EbBWE3aiyQCFa+Te4Lp+SojwhgCTeaDAqP/rncEQBb/HtrsTw+9W6doxlrHyYfQ9SNSemsuc1VcE76wcBP+8Vvcm6t+HoGFQKurXehKolYaxukuJxr6EJYvE7TAuZci9JsRP388tmjyq7U9g7EgRGw9ldYH0C68fvryVHpI2P8RUMmQbpuQqw8U5Qa4CT4WM3k9/G8Iec7PmcK98YiTiRbNa3uoG7Iw6jxh07/679cY3etJC3+gQVQ6og1drRhKD5oOY7kVcAGspIDlhAXfCGFGcvxt4QV1Oa7FCNOJdsh+vX6NV5MgDCIBWyGIeKZ80QhwjBTCBOUGYMZyukGG5ws3GtCJEYwV/SdH5t+gYuO/eLqX10/63/nEbHQRnyT7WnuA1u0eBVSbZFstlunWVr5eh+uW/ByNUz+OJ72yxY0uz1CSBRmTUFR3/b329oj9WGO950OUnun/72Q3mbtrOOIqk0C/NxIZUsd3pfX5bRv87C0y+3N7SeC34VltymNuoU5MYuZhoJO84BY4LVNxZosXNbF2o8LR8mFTt6WRxn1e9c5kEqfHpvQ2OzDvFQb+WzrD7XnrH8T81FDeSTjx3Fe9litazvQKOml3xz9KieBmlfbX0y9v7TeQ11Ma5Td39s+I8AxSNu611VsYkWNf239bsHIgtYUyv+0YqTrVFgzWLaipB6bIZjTM33+Jq8vzzpFcNecdF9ii+w5PjWhAEZmaVIL7Sw8LNPdQdwawuTuS6pp3oklUgOBK0+51eJRWFSoK1yQWZWgK+i21ikkOih7ulRZAa0pJ6Yfu1G4SZlrVEEW/u47SFH1yBOxYDhRIGzbss0ZPInWU+VyuOoEcK44FJQPe2rI+6FhQPhxU4BnBGOKgUpyMgthwAA+AQxYSEoEd/ER8tiPfDRZ59oBwdQsshVwuGXFLVwmAArhxgJSL8k7gZinAnaSjy1cgEkzjkbJXb8MUZyRAfE8z/EmD7hUdbzZwKG36elfmRTK6kXNKPLhU9BqWDBoTRNIwj0umQkFwI553uKniUBp0YBbUywCL+OOdTAwl2k7/SuLz6QLJIXbXzLyWu7QzJunBVah9b7g0JOcVmfSDKyEpuS6mgyzMcHyErr4fG6m5pyLcL/I9Kppxci9nPs8Xauc3vwFNhkW6aqknYKkBjqbuNhOk/JjNsCmjy8tHR4rQZXpKeePLDwRKUO1GjyPufKMZcvakUHsKZRx8qawKLk7U24ONCDR3PCgLeuUb1ga6xzKxBCriRV3kwdBvsOSTxQ2XUd5ZbIKIdatw5dT9uv1a7mM3YLKwoAJTAQqE6aMKc6B5t3vMSLM2OOcWT3UU5Zs7inslg7TxhcTXHZgnMirOtNBh18Lki7YgXwsnyeKQ0LDmogdHDFK+1mchlB7I99drV9dM3qfnrmn5GN2/ayj++hwB8b1tVVPqAQGwgPJl+Ko98GaYm4J9g9X218dxAOpAW4f2VoI50N++FSNhfYv+SzRZaW6NYP6+GPDm63p0HZbPJ/nssVzBURN17s2XoSo47VPjQ/9wnfr6v4kbU2sfXBp65lVYvNUY+Rhsea7TcFOI9cXPCz4+65pz4bUuraRyZN95kOpX2o1jVLo7JacdV8149utWSeaIJV7p+YgJotsCRn5E1TCfa1x/qQUcNs4KKij7WlPMMJFNwL/jtk9OgQuZGQl8C5kuGL2N3+2fLmgEf7YkADKZJtGngwY8ceE4Qw3HrWlCU/Xq3SDMRgsyoMT4Blawm1j9pdzMmqCaQT2ptkohIzSJIjB4wIWKFc22IiMRnlj+F8xAVN8A5hGPAJ8c7rifJmhT7ADdYSAUW5RSSTNZh52UivNkgNIC9coNXIX+ZhE1lUjRC3SAk9HVD1N2eZ+Y+bWIZi7kUwCDQYwPNg6tezk8gibwQQBlto2yjYIfjgagRQQTRedeGUGdYDcxQuElWLKys2sajSEu5bvT4KZODDDmmshgIkdPB+e/cUQkrl5nycT6ObrqXB3Jlfgew55X291//50fwuBWA1VyCq1RiDyjFoB9rJIo0kuZAhF5huVkdnVGGqhhG4MpWBEHcLc6EDDlW832sMigL7u883j+a89Q8TUFZHtgofXm6D2itqAcbn3XbCsoCdKoV+44luclmIuMuCJAK+Rw9V9G6jMTLCIOYFVNVIkTROvmA149qneMZoRJ2Se2ncFuq0TySaVkbMl8q31QfAPlsgJYR4Mjij8mB6HCehnFmOE7y+aiP0UNNrcKDOHV9YDWrTifZF06wv3thShEw8Ze1YsU6mDP/lCxejEOmvSHUrl0Ta3/6nd0pb09fX6tV//n//n/wv/4O/+PfyL/8L/GC+3GzSysJipp+Amxhy+f1UFY7hqRdldqE5L31Qu18RyfSy8RTBLlcz3rWMeZA2otq+uQFpCseL1mtxiq+5/G26P2RoVmSWv7lvU0zqnZcY/tyfvf9rd4B0JJBM2dfBaj9pqu9wT81jJ9ipmiZ6+k57MZIHt6/12/XN5B4Bq95V3srMab58lzl4J91mw4xVo4ZZtXqjgJko1EEzCz6nggTrhahAtb57BfhYeERuYSiUl91owBHYhpyUuq3LMUymkbCOSdUZdO/vOVWNZg0qLbx9nze2VnN8l72aptn3qetPr3bV54vusVNOEriev3s7j3pngr7Tdne+yBCn+T/ujrac5gJznnUFXc3vPlgOUP7tcyLNe8T5nrUE/PDYapet9zeU23SMpCngSeVFjHl4SYByy6mew4N/99/5d/OFP/hD3+x2/6euHpbeNzVnmvljM9MhJ4WBygLaoo8DkwMDXMDRAFCUwYgto+n9HZqmlYQgGmY0Tb+uiwFqF5JAUAkySngF2olA6wfsFCWEpQUQx2eSG5j1OFyUhcKYUTYdYABTypBPohBkHOEqWuxih03RoVcVAZwSZGy3fbSAOA6ydw52RZv+A0qdJaKmYYDYcDceGbSEU0NMFqO6aNNOFRuFpS83fXdqN0uCnO1ZaA8Ith7W2Esq062PDQNCLZ5LKjSwGUGjOvfibgzd3hVragcxWxYNAMzPIR6wK5Qq4Jp2jjy7xG2AKiTSsmb53k95prbdrpjQI1uuBrMreXPRPRhANa1T8XJnhMuo6UaJWcBJhaSesDlK/jBa9lyvi9ABnzy5GHsMTwcndMlHPNdxOlVLa5xgDEb+DiFHyNtikTiIaBvaczZEcwHemhxXp8nJKfGI5n1h9SUFTUPRRbsCTPJ6IJLyhbNGP+A4RWXwijH9lyUqjUx7ME/0QTakrno1tL9SAvFCwAt/lzaDky04I4XTRXlr1oMCMhBISE54KAgpgYJMiBgshT0UWLkMJ6wYDuBwhfO1ClmyJiyLL3nZ+feYA/3r9aa4//qM/xne/+g6mFu4F139UlXQ9SNytG8JOQcxeVNJpJs6EhlmcfPwscMULodS0eV7lf5O26r+PYonjpeZUQVT/QOHeadd2EO+4ftL/MmQNmU5zS9i4MppnLWDxo9bG9b7+5Q4OF5Z7HPT6/LGd/fNtatNbYZtVlPKrP70gnk8Cw1m/hFtqxkttLt8dMdf67VYShFXc4mxaHVzvZmqCRmitJ60zN4/hcsEL5udeEblocchHDJ+30528n4D67bqsbQg7BCwFbb+3vXb9WHPwMD/5JGU39/XfZ2Q7IR8+6/Fzi2bafbbfv+a9tZpz1Yj2KfnGWbR91zXMV7ps7ZV1O9qo9mjtx23U1ty30uIGp4AuC63+NSEmMUbnCUzuwRH/JP4xM37yk5/gH/2jf4Q/i+vLs07BD1zLWID4vNJvTg0InhWnLVXny60KLlCcMBzxcgVw0hIYDMsrxUFDupSELEuZKJIiINMBKEVhtkX03peskpxUV9mRQvrLwC8jrcxKnEp6AszY06wSbYe/FQIiTyzFBAmBxJixIo4jq1VshO5TSQoMdeX6aa6JTiEsiSZTaBqQ8chFWppaDwCYFq5C0XgpwwPMqVsGlGjjk8yGSebF+JRa9i9U2EFu3C2rSTYgFlYKq/AFi8xkdFDsHaeHjDPI6ViFDS0ydVFplZMWAK4geV5L55aQoJ2T4j5z2xnM+8WpiOoHjzUrQlrlKPD7SaDhCQQ4Ay3JQhvZ4i/IQaWCoJSVthGR2tumiU2/6NiZ98UNuRAvoSwuCXjdDBeHl7sampkHzGuj9xCW6mySmOTcWBG8moKZl1VJE72FhTBYnxhwR1gFQntP8IxfZJFSdlkMi9Xl4W1ch4kFIWW/stBZuUcVwaYVIxlrHAph3XP5z79VI0/dnP2Nw8IoE0OsvZo0a0GHWbObcq6x1pnyd/WxcfRbRypWUBYdH5b/1Nob0RfEhlGnP9MUjGwLQwyyjWHGgU4ASQjS9WW0//X6jV2DvYDV5BlnnKewJSZMmTA7oUcCcd9P56Ryb814Ka8fM5NVhPVr6ekqw1shoSvYuF6xSwqYJH/INNrB417g5s476oxp+HpvryPPZ6/rwNHq9euy5793ISPY63NgG/sk+dNuGb7e+z40LrDW/O0Ll6RCVNenyWKvBpOL+mkdbXBWOBAxhwPOF4Eo5Bngv1hJns7iSUlSOeeMPITA4EfJg+LcOIRxY8KPQmH4CsIdwD0t0pbnQHiAhHJrwhWUqguyW9JIIfClFvahP3OW2aSFbTLcmg/AOGTphrr72ZWvu0qb1tvaya+RG0pwScDRvk0Rwnl6W8/4xXL616ua0EzVpxT0U3Cq2I3Wka33i6Dw3tXdu3LLbdPStnqOT5vFqM6DpWXu2z68Ny4v1XDF5/gJz47pSmwGWIBjgI8DcogHfx8Dx8vAcQwcQ0Ix+2dzfbGgweSCRAJD3y8+MCZFBlvXak8DkS6NS2qUNTTXsMJAkrwXbTHiu2JKabIkDVDRNhQQ7sy6aLraCetCrLYhNzsvQoh+ig/Nv2cUcEzjAidoT1V6puaNlyoTzHyRCdJ2kHqw9lTPwgTAJBgAx3OpMUd2NYJ42G1AKRxoKN1N0pzvE0cZG1CFm2IezGfaC4oJAIEU4AmXqYiKLrNbTFdtZEHE98bpiaUFoPWRM0JOBiErJa5hMVVDANwFnslPYKcBInefyvOjmPfyt4ct33yX9zy7VR0bIeeReQxDusxZ0gU7PZXRKb+IAHAzRgUllirDkPY4hazMWIg0t82SHvIEiMJFTizSDa8DkDwwJUM/wgi0F/hjxJzTOiR0oizwqSVJN6Cl+1BYqsjjRlYEY8p96HFDiL1p4SaXB2EiBapj2KmBYG7CySJ/m3Ur5ypMEEjtfWOqBEjGd+ShNFHCdD6fcUhLyUBIqTFdD4lmrU0Kun5JmJl8YjOOrAQxUGWm62vra2e1djCEZdATDpQlJLVObCUI+ImQrpOeqtnYhRSEm+BCUkt7mvzFijh9L2Ci/LMBQ4/9+nr9ei+div/i7/09/O7v/Dn8hb/wFy6pbg3MI9z1LIQOAYmCzVxTCK/x5EoHlEXWl9MXPTXL3aLRsVScBheQ04BHPhvptjeoaGsPdbzYz9I6V4LGOmltL20SQsNen71WE7Z/mG+m640NblL9Z38Z9QdsfVeArlmjbc03ovsdWHbAByRvxqVBhxu9dAABAABJREFUWkC3/e3u3Vh82takbd4H8Uyd2+I+8VWQyE7AJox1LzyafI3YeVYisnUAIs2dFMoGWgGd+zzXsKm1HWJFxQwG5RRx5Nyu9ciEN/vy5N/0+Exf43Y90ES10a0sybc7PV9+2b5PHBF0nPvq8qb+PiC33MIAD13LvWExxuuQOp32D1ssJj27N75Y3/f90M7F1jb1257RaZ4eZbmI8O/4m2lZYTPj1GD/J8z42c9+hp//7Of47uPHhxn7TV1fLGgIsDSxTRqM9PjbGvg0xIG9KComjyJ+2WrDBW6KAm1+b5cEE8QurWTbR8B6T4FJiwDOHr9BBQoqGC7fh+VvvbVrqdmE16ygAJTUaCSHF+0unuiDSPNgNlxHiQIU9QryjFhzt0iP4FaLmIL1WYDtMpasnoSWnpqFNqxMMc8ClGCiRMgUpmvdqPV58RS6aDLqvcEALeYruoVevqTWMS1igWdrq8VNTCEuNmCWwkDdz3mm+po6UGsHVwo36ckUXVTYXhn6yic5lykqvmuzEAQhT8oqzbGpba/5kfTr+4JWfAP5vOfkJWPsplXAirYlDnx304s1jIlIK0zOa61pDGY5Nea8udE+tfYJfeowDvODpcscUJPN+X20TW3h6x0NmLTVLvqjHDHBwVnHD4TqL6o9Z/qZ0Kvvh9xb1vpRQkbMk5EDg5SX1Dyeg9WAkXutmcxDKMp5SZMzsFyeqp+2DhZf56wmm25iIcQ3C156E+b5mDO5Vsv7nlYglMbOap4ezriv16/tup93/M2/9W/jH/9L/zj+5f/5v+ypkQ1gPTyY8phx7hgkDi1Wz2QoEY1E5jFBpRxRr2HE5IH9HDw1eUFpQROI2L7Ea++ESqYUdqkcCDq1UFK9eVtZbuoK7zKddTEMwk6X10lJnksPH+0PJE9KHpogsm/+bVBWfOPqpvWUxMvnN17MrU9x5ndGTvXfpeAuzGDXUeZm3IWRFAY1TPSnGnBasyqSCwXlW+yYw9fJBdQxBlgEoMgoM90yPmPQboDw9SMIwOLKw1u0eIfX6MlAFrXAHlZnovMgKpyS0XmUc03Bu2md6fXMti6GjQA4FYDUaGCdFwv82KIH7Kyqmk+6eHLPg2CN/uCVgvtfrsTp7LuT2nZ3dXAJGYn/dqKjtfZPxrB3IE60YujtTMgzqP9t7bE+BuS51iYHa222PtSrncaAxQ+kMkq5gCECMDMGCW5j4DgOvIyBIYJDGP/g7/99/Hv//n+AP8vrB2SdWgTdLTzQCKosNUESuE93eCWgFhJxMDOFu/nyPQOSZyzgsSSPeAZUQKEIOHzcDRyLZAVkGeqBxp3a4RtWgarTUUCFza0NBgeaqdVGunZkYG1vklbAVNbKIC0AHNPkBFVWktRo0b6nsAisFCU571i3Wp1Si9GVSwcM6b5STAIerCuwCrQ1JHiSWJvUd1iMqQE/rJfXWhsFg10MJ1OseRd6CFr01ai0s1m8kFKCqKprF8bXT5ZgFEruNsdI7Xxotpg3wTNpympu1gwvYSPfF/2j8E2NQ3wtUcZe+D0EeCyHNf/meGfWx3jG6CgtarYsNTU28rgUntE5an2CwGgiYy18VdcCJR1TfbPTLRcUoHUQZR+bsJFuSAhLSY0h51eprXnj9lmgktp4i5qKqmpvriWmWtfN3SMerMrlsHARS+2wVaa19Gd1ISNjqHxc/hxVAgKQtaxfOf8KY3e8yiDajKUxinTRuWftydjzuEiXMDFXYlq6paFmP+ky+V4mlnDrpDhthGtY0u0S9r5ev6mLiNx1kghCBFGCEUNOL9w3bGCK13JiMRjY70kwNiNDXlj2ncQ03FGDRvJ4oPrI352sL/rSQUuCnwTO1y2Ccq0JmknSj/NwKfdSgRR0rF1Av8xF/Ke/p1tgau+my6HZ3nfsfyzu+yQc3mzR94aA2515rj/paSox/J+DMBZBxiFmBOGcGoNY2jnr7cZX6+0MJYaJFyF1n4cIPNXZb/Q1Zd/HwobB/hMfovOv5MkFpkDNU4K7l0b0XeCBvRoKK6XdKk0GHDNwg5brT1sIkA1fzxYDSOFbZxl5bDOYbzd/Wa1rxQUU4I7fpRhiCNFAZup0Jh0nkcX5Vud6Qy2JZ2idCX1VCflF8sh8oE7sIgVqpFF0Z6vNanujpyus6Gf0eqjL4yu+rn0f/60kMqFQjhcih/Gk6f23BdBq/LT9vl5oWGvTv2c0JXEEgQszZIi7Sd3SXerAMQYOuUH4y0Ozf13XD4jR8D3MsVcda5mnuQ1Bw2KFuM9yovn2kQGby8CMhV3Wh83dzqe2/KsyGFxL22yGKKCcnJFWnQFys3aBmAric2BULjVOMTvQScdaCvkzYh0sgMrSKnumI7Fwg4IFI0phiMIitOYoYo63Q6P89grIoFyZ2NyEm/UhPGbYxxBdDGYdzJx0Sb7IQnTu2pSACACMOTJh+VoWPLT0WQeyYhpFBK6RV252A34s4lLV1hxu4Iqs+Fvi2liptcihNSwwaYBZVg8P3/54XTHFPChsuitQ+M66Zn4BVy9nol7JG+L35mvVgqmjUC1n/ELvXqx1MWHKaeRSuF34mic8yHieAI7LetP8pmLlXJXqPrdZxTuLG8KwtPyNcJSoXI8s3kcRb+MCaGS+sqDlWhsryxgFTWJSeu64S0gsra9FsPtgqletGOUa51hqb8UaJXU2oEK6hPyMg8+bTFFFxqsPMV+S1jO7tM3UXCUt6NAD60W84svC+tlTZ0YErKx2xbIUbBpsg7eAb3/HOoTY8wrGXoo5iXEgMU4+zqnTSmsJiuY9RXNMUmaIuBLW1+vXfqkp3u5vbrkWzzbka38NEE/XKcDYIBHUxxYaZXW3YaQVIvad02nsBrssaQj4DV4BQPGasj6iPHaRMYax6VFuwfGmeoY4dSPefpJ9P6efAPynFNe02fmz+tvR2KWt/fFn7XfoSe3vhh432Hb9Pse6rArEFMkbfIMZZssWlc+1PWzbhACZDITd5dgwkDESlfrmYiUpF1/yGEFPhgJgEuzMxAHpshzfpaKNEtimj0cwIvIkNI51CBkCVEqyXGsr6kJaw0ECYoHSAQJB7Q5YCkkNzCWbAYpG3WK/LGiluMsJs3AmbVp2BA36kujF+pRLcXWpRcNu+f5GD89Io5NDLX/QVQdx3TzQD/NNcRPjNdQ50C3ODaXUi6n9d33S+kW9e02UyinawELro6G5CiMR1rIw+cZHCoBJKZkQ1N2mIvB7rH9jeNzQ+TZd4P4zvr68MrgBOMyzEqVCINZzbswjKjoHEVoevgBKmxCbm8gPdg2GndROsfk4rB31IoJL0+SLYZl6Bumpp4upM6X6sjL5bdMbyNB6+22jOGhZu6/2y/CxzBot1evSr34Ww4/3x/tcC5+8ZVkWaowKZNB0AZ2YC5LICgQAAsgA7CRghp46LbkAQOJgS2IO7wZMggxa2uHwUVdF1DwhmEhgLu9AaYWjsrT78kc/PXmzb2qVdsYsD0wCKiZnaYhz+pMxGmBaANMQwb4xF25EyDVpO9jIU5Vy0COvNaoFanET7hqXGhln1mX9qgPYx+bruS0AUrwVABzmhD2gLNpCHnZ+kDBFSIM2lz8jkPKyPqgLblUYyrNT4rQ1NhA8wHum9i8ZXJwbSgVu09rGceDVueWyb9CpCwWqVhmZKDVqCKsKPChek7Y0B7uElSoskX2nOur8wAmmvnQ1qNTN7OdgkKwLwRnfbmTAWJYK1ainYc4wOYLdfXsk/eVpDawdmkzYMNTfaUpNOCPQ4ZprFwpmFL+k2qdkVG5vGiTk47JyEUwhKwUkTX9qJF2jDo4e29XdIn1qp69Z0DCFZbJR99frN3T9wR/8Af7Vf/Vfxe///v8Q/71/6p90UEiCeUb6ZAXmMFCk41aS5O6gSVDzvO0aB4GGYMHq1lfEkZTW6M2VpwOo2C0Lh1Cdlw1rAEi+lpXBuwU5aJucAVkoHUxtYaz2zu317fey5u5I6/HG7vv79B6r/fq0KWq/UPKL9wBRgr/lfLMeZxAPvMgNQwgfDsabEe5G+Ph2h+oE9I41/8FH00caFvWigIM91mK8HFA7oDrcYqUnpi6cUF2a3qaKYnrpePCb0wIfBJigClllYpU4J0yDbwwXbsgGhvn5PW4GIcUxTpznxOsdeD3NXbpS6QMBSRa79fS5jBPEAyQ3KL6BGWHOjwDuPreuecUMXumexoFnRqSJTyvfwdA7RRKUNQYGw9QLXiL4bKXcT7OdzsUbn9AHNRrcaP4ixEV3N2MM8IxuU6CPf3y9C8/pNNuw7FShvgX426fXJvy7BFj9M1z+oPIuuOgRkJiy5BBKpVQ2EMpjplqfjP0W8gJ943DXveMYGOPA4AMybvjpT3+Gf/Pf/Ov4+OnPLjYjry+3aCiAV8SpavEkrUxHqSEILSZoaZNL4W3h6jCTYTIgAYpJYdNqgcoqxw7cYheAECkGFQ4YTw6z3kRVJE7zVaMI99HvV7K80PgHz/E6DaGRsoKOBRQS8x2x6BTT0eSkANXWYhdiQLxbatz328qX31KqT+0nAzO0sxTgkaZ54PPEqiocxEugMh8OnfDib2ulTVZMikm4H7GCTvc1pxm7OBggsbt/1JoLtRhbWocQrUxdud4EeNE20KaxzV0ncMHDBRcHeZjLZOvzSHGIBkNGLiKBhGruKxaj3GHiR1qdcv4T2Bm27Fo+hKYhz+eay4OB4iAP6SWlSkpXIXOBqQpBtFOVEK46QRzR1zTLljoC7POKBK5UmbMI5hWLGx0u2kLFEqbDDcgzmHFJFrQD/jj8iQ0jmKpb93xdhQhi4W61zuP2LEVqeVvfd61oWgOTPtvz7MThZzO7rpCi7k5HNRS/Jnt1a6YP3uQE6ax5K/dCAwyVRNv/xWeaAWVZwCX5xCAP4gBArOWORkBZFpKHbTwkwd7mHrDcnRZtNX0XLbqwSWXBcn6V7zpDqcAryFfw9foNX3NO/OIXv8BPfvIT/PZv/xh/7rd/JwpceWpuFoaoJyoQcSrh6WDUzEAszkPYtdY9LqIL2psW2T/YXDwKVFCxdgDNEklrH2eSFSBY9wWBleWzePVl0E8AV/JM6zf0zxoAfCo0oPe79QPFDvcH3+kTZaDV9mSLC7Bnj/vMCBEOJrzIck7l2dhLa3bNS5tjc3czIeDGhGmMSYIzNPx6aaYDZI/VizUqpWxbCDQ+nFecBflc9oMJOMQzU34g4I382H/Lpmy1T3FY+Ig1FEUU7sRR5yiBVVPC1XlZ1NP6kGAWi1Z9bdrEE+o83henaaQTF11AO9rtPT6i3xfT0x7Yqe5KSt3rqm7oZ9Hl4afG4lrYve3NQLI2MFIxtTqbQ992Ud7aPmtKu9rw7V0JDS5rUkqHXjtDvK4YteJ8zO6B8ZOf/AR/9Ed/hJ/9/Gd4jFX6zV9fbtEgX/Z0DwDBD8A7wUbCcfhBa17Z2Csqu6Se2nGBAyIuHrKAigOCcBkpvkIFbBNoFv8iQDPxvgEU0BbZj6D8EKrdNSMKmZA5gLUAcRS+GWSolHXJNNLlxCu+amiKqdhFBn6WA0z6nFJs3jR5Ni/53NjL2pPf0HKFDE1yaljCiFCYFBKC24VuKi7GeIHr4gIBw8iZmupWu877E1lNPL4khKEzRitUwZJKvtZMqOrbmhUP3xQkDCOudUWA+MTaGnPt0+sbxjS9l9IE7YxVQaU1J+MS+HzAcbjbYlGrhXVWUVhplHzucFJZrT2VacRacMxUauRJ3SUngn1KS590CyyNP63AyKvfdTGNoIuihGAcZvBaIRIamTB/c/YrEEDKVL5W/jIPSHdBKM+SDBYtd6tZ2Lr2j8sK7GkS4WMNmRIyKYpWwUuJaI4nhXOrdjpztSDCSmHb5sAPLQdWua0J8EDtULJVHy1oOQ5QYdcWGwM6CWxShyrFXFRxxXCxzPo8Gahv8HvK1cwAO8P6Gj5jvS4lQqOH4B/a3LyNfe9IWm9z7JSueBO5VdMCYrEfAbgyolvOmDDV43Nc0DW32rU4sa/Xb/76T/6T/xR/5+/85/hf/S//F/jzv/t7mEMDNhkGHaDJUDUwTbdAx54XuPmRDeHeEmCJDKzOTzVFVTOkqb3zh/ajATFq4MIJswBGnseAu1lOvfjI09LofhEJLTgZJItENctNtt1O7/e/fhFcbnqC9vK7ApuFpOLzZD5ap2e/OmgDATcGvhHgt4aCh2t8P52Rja+8pwyZaa+sP+Tzxma4ATgAfADhPgR3GjATmM0VU9KlndD2GAZmREOOCXc31zjIMoaN2bUsFd0eAoqtmDFhA7HiW1HcyPDjc+I7m1AyfIxMnym0EhNoSBRudMutqPNMHoQp6UWAh/CMnD3NebeV4ETAYAX49Js18FmesiTm9HXEs5OapT9M8+QYC6KLpooO4tzd/O33MyPJJeFikuEDGS0q2N1fzfrXj4883RddZI92r/SN9//uz+ZJ32m/BNrexmXjF/m3JzODa+o3WcirfAt7KlsRyLhFUb4DQw4AwN/8W38TP/3jnz4b6J/J9YOCwVNJm6M2YFXYapeFWtiMHUAgnV7WvSVLBLjPvy38Wy2BfG6I5DcJyuCMfy0gwBBkIEDBTcsFMlDVtiBH8WyrvhwtChYDPBYhmS0F6HHpPuMUAJSrlplVCkyyBJJUr6uKy8kwM51oSMLxSr/Ku8zCUsDpqulzWVKNA5V9QzaNTzFrhHUlEFISuXnNCCKqEhDLghMMrwPGIIBi847kQmDyNxvgxRpFXcjYTp+QLOLgcx9QrLUOPpzHem4uTk1MAD9nyvAsWKVx5taxMAKHJsbPWv+y3InUYJbl/5pWodQba25Xyl4nxDLeBFLNPnNYp7IjnRlezmYQIhNYLNEKsAdIKNKbKgwztDlSkkG682T7FjTpvrEKIQpATcsamOQQP10YQAQdOj1X/M7yHytBEOSHdYaUbDsv+4PI6Z71R/K0qENjuTtkm+4mZJi1ZxZrLl7DQRjJK6b6oc0MkFef8fmW2mvRYFgngh/BvPBmFjaDz2VKO77Wi6m7P/QS5rYVjLV2F6d1IpRAr8DyUY53EdYYksry0IzvJdNLFyLA5d1frz+Ly8xcIzgEMhgKwUAKkIbBAjKCivMSiEGnm+mUIwd1VAtP5YO7AwOqKWygzrTFU5s7beHvtS8IoaUO4SPdad0aqWtv5ZlrFko1IJkNRV8Qwk8y83UGRQvJJIzg6oGkx27Xox0krRkskAm4+8dBDjgEwD0E/7PxktwLpbWFA2ciBodpbxrAAXhNdXtjB4KTgJMNbzfDfQLnK2BvCjt3l6nsfAXaEiELt05SkAD3G+M0hpqg4idiffzx5arDxJAxMIQgQpu2vPzyicNrItbDpVSPR0uhUD3OEqR4m9PHOxVvqriH1wGTVcIVAwfNCRjufsmDwAdhvBB0usLJ57iNvy0dpdIw2BnFH47LPAOWe5LE86mlC9wD85gOA5Uiyc8SXWd3Ze5yQMfsSl8/GUJVm2b795QrtK/dPo424cFvtw8ary0rRGPvqezcG9lpq34WfVObTor/5wMF3FbP8pcwE21t5t4sJoC117GEDOZ0y85MU4IxJH4OiAwID0i4tD0Xpv7sri9Pb1ub3wpkpmtTzXPOaaglw5nHQUqbXEutIBUcL2bcK+RuCxPv4AI1PnOK2BigALEN3NDS9CYQzk7W0gdY1uhDGAo8QFoa+DcCT0CEMEPjmLwUhHKtoPjFgWQD5OQwi4BlmjgL0sCBUriuRNeIXRO2XTnXGoA5xmMxD+lHX+C9HrtS2qoYLmSQttUXPk5GGSA0Giu/dP9mV3KZL55K7sO2xhknkPEEwQTSL5TY40XYlmBaggBQ/uyxVPG66FTX1icdsr+Lsy2iork5y9Gu6DSD9XfelAe2BnBAAc/KOiHmnntE4UYTZvC+dBvYj7kPrfhiSxbUsNzNki+X8qoscLGqtu6tuayuLzpUOD017O/dCvLjTGmILCzlcQzpNUcWQnmsW2Z/4/bOUhZQrkUzfQdRVWxzUpgBpoazjup2juT8ovmzxyFJoPIfsy7sBm9Iy0nSKOAxL6vqPPmY4tv09CLZzzfT5GUo2tnPMoOBax1SO+qALoTfNhPU/xMTlrwjCyNqCtuLXT31bf56/WavdNdgkajw7u6LMGBG4ZwhEgHGfsgDCIFDAWVwKHaMGWbuzOhuje0qELNASf1df+ygw/klISvTu5v9ejaFDMBp+IFuiR4VARcaK16LZNXBLDb6v06YP7l+87uYgBcBXoxwA+EjEU5LK4/fNxNfxT8m8RomLHE+TZAZNGogzf62OmT8Sq/q1wHcT8X5ZtB7uGen4BcDyDMOlIk+fA9PNo9zHASdjHm6lSJ9oElRVvQCrsQYIrgJMIQwKayYuvpaJyKnRT3WcVApQPwMd879NhWnKU5VnGa467J0z/R+gFtqCYFEYV748yDIgYgTwn5Wt1UsKBca88QoFnzS4xe1NdAWKwFzMH8KdXue45lMxknI+R7lfIe7IUOr3hXq7lTCNt4ZtEIb4fVRoBGuFZtdQmHHROtnkgAjlGuGjZ6y69ksrl8/+cOCJrqfGT15eUBh2PZxWjBXB31as0aGtRgNr5VRQsYYYBlgHok0Hifrz/j6cosGgvGZrcW3yx1EIfGnD565RhxrpcuDuT4KgEGo4nV0ZgG2+CLRh/luoUaEaYXM9KJlFjT4RnbSKWIyGDLtmgsnznxcaFouIaWdT8FlRrVeImBygQqF+2inNsYo0hqm61RsQCpJ3ta4sn86PXgspTZiQDxDkmuRbT1JiEBdVOMONGPjwiIoDbUjymoEOBOoFXUw51p+xZZC05D+OaXgrhOJgCz5RyE8+NitmK+BMCn875MWyEEZjJFZnmofEaIPtsJEapc5r1Ky0Kgn7SWtWQkthnADS+AcY3erhj9DcPMvhZ++kwOlUWCtT3EpXXQfwoFrpOIWQWUjqmlqp3SySULS+zpg0r+qLDQpoYT/nJvTOx9LDZE3vPxRow2ixfATqsR9lcEmPkyLoAZwYUqFAIGy8rnFLCtq31hopvzpZtutwwSJnNu1BKI6n2IONKxE3KwJOYlG5kCppKlw55Ocg+A0QXM1H7E+5WaGVBA0YTWZOXL/WFmMcizF/Gn9rMNW3eRvVa0xXp4EHS5a62BaC+nmfQqrmt/AZpklEulLnYbWL+fUX69fx6Wq+Lf+zb+J3/u938X/9H/yL+EYUWZWozbGEZnIMoCYADPxnzp8mZVgw2PlVCfMGKruO0/q8XdJTkWDdVnt8QRHjHQPTQ0nKjYuuFSRIJCWuOK+wdKjzeZOoh2LXH+i2yCtf/H0omd/iUCE8e2N8VvM+JYZPzPGqwLnpzum+vy4q3BadAZIPmDcvoXIgYM+Anbirh9xTsWcEzYzGisdaQmgAaOB+3lzIUZPFzROjaQnWsdYWXeyp565BDYVpobpNfacvwtgYlBOpcdSohZnF4EMwe0m+DA8tuKNgWmGt1ctCwVowuKsw2DQweDfHuAPAnwH0EmRndHH9/bqLqCTyb0i1M/KAVQ02sQE0T3aPUFQyATkTSE4wfM1zrhMjetPu5njjDmnOr9qmSV4kQKmEskEQuBIpm0HSF5AxO5KRX5W2GmuxK16IEGkRoC4cEWHe1WwUiQisVUhoFFRYUYA62Cx+r6uC3lav4EWMt3pdEFMBspiP/MsvN5Z7fXztL2n7yHqX+By41IsL5dmWvSUez3wbRab9/Tb4gL4uEFkYPANNzkwhmDcRgkcf/s//tv4+3/v7+EXv/gF/uu8fkB6W6tgs/U/qsM6cYCDEG73+dPUzmJneFaEHWc2bIa0nyktEeAGhqwcnUGkJejoWmxu1pU4up0YlKEpMZO572DcSARgWDFzaOwFT6nv95gBbKXhNUnNtb8lfc2TeZW6ypJkEuiHCXuGQJMQyJLkUmMaACjdo1Ix6jgvTPg+B5QCU6qROc+QPEhCsDIgPdotzINpRj0DCVmZgF17nSlgTa0JN3X2VSVtt6QkNVhVLgfMgb6i/IaZXFNuTEhnrfRvB6EYUrfH5JRyquZLqAhBjQJ4bvTqwL20TpSZneI9Qu7ffLq/v4PaBOSodH5VMCn6hwxaRk0vcKeKcVEkM4u9Ygi3JHimqQAJGYeTgmT64Vv4ernLIeWk+M3hD6vq2tKik5hjIObWYm5iUktjCFsCLycP9GxMReONoI3CXdAibqF8m31sHtfi96mZZ9YBPGGBYQmuRuX5ZTEnJWzUxMaKJrZyZgJMP0rXvcCMw76SAESNi65RhS1XEC1/gChsqFgxYu1QIE33OwtAEPpLs4ylXyAl3pHprpPWk179Xo77C9kgK73DEEGaGt6MPikaJ72klcTQCoV9vf4sr5/+9KfNguC1GZhnuVVZ7AFhgkXQuJkHjatGEa2yWoVihZYrnlNrUFMCqw5Matlzn6++dIVF0tey868m1k7br+6+93Bt5rOi9iZsdGxFraHHFh1EeTCyyMBxCG7/f/b+/MnWLbkOw1bm/k7Vva+70WBPCAYsixAkBknRgugwJYfMH0xFULQjHGH/rx4UDsoUB4MYJFIEiYkECNAECDR6Qr/xVp3z7Uz/sFbm3qfua/g9hkV0o+/XfV9VneEb9pC5MnNl5uE4bo5zJtxDMlJOpoZZDvML3B9xjAc8DGZy52SFuYhcTpXSFYoosEbcYATpNDXlzm10cj1nj3f2WyXzM8SqPIs58PLh1rOXXF9rhZUhHVCl+5JJW46JxFKXJrSxIhp1f+VAkRQ0UCZbL6DST4EqW5tbEoZlwkPGR1NGgIp67OtlgfDN66/L2N7EzxT/TSI5KpMLx19KOkuWFzWlxnVfGAbNWQ3EMt70ILqHbaf02/eovh2h2/Gp69sMbxkb+mU5s7aHv7vWy9/3sVtXvI/G3N9tY87CbDUG/b4GRmOyO+JNY9HdwM2V9D0w9M+NkQ33AT8GPv74E3z3u9/9tJH493p8dkNDaxlWnklbYEaYiBQCrAE2hty6HGd/j6M9wFJwmcUVx908knnABW3B8xUHqwydFVtK4CSn0lz3WABaHucArXEC783X6euiORKF8TIAr/jsSEwznEmwciTaA97i12yrmy1h7rVRCKgnCMRGAn6UlGJiK3pjToEWfc9QecZM8komjU0i4s3QWACsDSWA9CHdZHVf53SmynXyuQzGqPBWMSmRHD9YhyCRQGWcZ31PU+HyMo8CUwZFDo6mz3kAMw1E+tnYjmtsE2h65v1w7Trez7qhO7Fj64sdcUGtUahiFxagBlReub4M9tYob6H5WiNbQKhEYxuWvu6pq5bp7QEXv5KTWHQGLw+PBivrfFEBJe/rcooNiIORP6+qZ1kXQRzADHRDvzUo9Swcmxpjgy+e916fvYSvAR40UMx1f5x6Gq5W2S9FRxAAqGpKNe5l2MS6HUM7hFvu3gMjKjLO3aIt0bDF1nq+Fh9QROSCFZG2kqnTVnSm1qYtEGHFWwLnyEayDK96fawAWyn/zaxsTywWJQVQtagCMQQTDeQymp8MKGcnUqyFQLrTy7v1Bnt3/Ps9zAx+XFgZ0KHO4IbLGez2ncVJAeYxkF5J4ZJhN7CkqrGZXwokwNSHQxtOEgBr7cuBIy7/3T9fMGmnw+ygUWfYAEs9T6/YO7rGp4KyO2B+Lx93aGUvvvESllkM+HEAl0fgSwP52oHvH8Bzqi/UMyzOpmCy9sOA4xUe/Ut4dbzGl18bAk/46Hbi6fnGa8Vkue9JytMww+Hkpl/GAw5MPJynBilwSyUy2/bMnZ+VYg5EtcBqmWXVdR33A738T/pfRV7hiAswH4F4A1LrJpBzIuOkgFZ+YSZg05GfHMjbodyyZClz9UN6eKDgKb05QdZ1IICT+v6IKarouWicB2AjSJmdp/okyfnqx8q1qIWYpaOWbD4iMdRt+paO04B5Oko5OgaQFxgeKT/HDYiTTJGs6M8WduPwLGE6Cytay9amXNnL1Vaa/mWU4dNX77LeX57h/tv1V9Fnq5/TMgj2T22/3y32ba/QK4Daw+0w3b697fL1c1kTqIpJBjn5tienMXFgjMF1flxwPDzgclzY/dv18zgwKkT+p3x8voC8rFNu0p4JJbgtK9uak1aJNbYEnBZaJKs5p0pUprEeM2QJE4BYe3iLh122Rhs4K+akyATWZEHUCxNFwSYMkyDQDl6vMB7AzydgWZ5hLvgqMYr2KVjlmgojrqWbMzDVAW0LtijpSZV6FBrodWogh7ceqtpRA6jqVaV0ulQTl9xW15rj3lUKCncBXTEo+6rbfteZMLkaiBXLUxbylnMA6nkJrAImGgBPKBpTe2GWl742TtqAjYk857qDADyjYj0CzmsrFujtfhk1zrUec/a66/GsTohJxY5hzZc0yb1Oxhtr/rOyDpKAvoQtep0UUaiMCT23BJGFwSathBjoRXrkQEV7SGsLVNkIa43H89BzvkWqdqkvTxKTv32tfQP7rBhaWmZRgIrWZ+UJK1M/Wf9cHcp78F8cZok8NroB1h6tg553leKtPVfjOoG9qeSKtFQUfX2W+71GqqIBBrOJxMlUV33XFecOcZLbaKhkFrCRqK8hQiXRQ2uc0RX6CsmLpDhM0cTMQsaHdS5JlDFoQLcXr1Bf8DOGpH1R+1HGZKaDPT+44Fgxr6oEDe1E3n8GAIvO25g/QJe+O/7nPZ6envAbv/Hr+MpXv4qvf+Pr9CAORi3SEgMHK1Al4OGqqhjKBdfnQBlXa7vUY0XqUMCmw6lYhivQHt9OAm9ttcBu9V/iH/pE5QJu0bvGczrBotSWXNd7fWO5Xrs7qFcN92/X30uCyzDSfsrTkE/GEvd9P4pMl8EPyT+fuIwbHsfAe+NE2sTNWTjiOsXakTynijF6dscFx+URByaOvGHebsT1bm9RmpdgM8n9LbpuFCB2JDAm4CeyGzRpn+b2vCVayEZqrn/jBGwTdj+SOqeEtzkwvKNfY7DM+OUM3GbgOoGz5ls6sdYG4EtHAwXZ7uYCLufhiUVlQn1/zaOBQfSRwCWgalOFEeqZU06lWJEHM4bqq55wNXYShuHHtDBLhpazSHOyl7rVK3dYnu9l631kYbEXi/HFn3b3cm9ElKuyYOX9F+u9td4NO/Rc3+hxfzGWfETbT4euILd/vsZhMzpqj5A2NRTJYKEEPxzjYjguxuZ8gzlCn3z8Cf7gd/4VvvfH33v5NH8qx+fI0ZCXZulx6katp6YQ1CKosnvaDA3GEgh3KuxgN+cl+EgdIW3HUCUQIhIZQY9SYnlKeUp0Vmrtql2YRyDARjkEbgNN2ZrRi3RfhVFhUwB28j5K7nomcioJawNoqmeFnKJqiHBOD2VKqIvrWsqhQGJ5Z41Cx+oZvU+/xsjoWds3RhGQLIWX0AGH5uRGAGeVKs2itmAhMehLMFi4oqIGlvM1XWdFNRhBldAogLkL6hYGJX0TrAYmb86L/eShuU+TVxgrZ8I2nF2HKv5wbBTJ2aX9nteie+M1TQpnKRQmSVMJBTQX8mgXnzobYKZoUtaPZQ0Mso2cNK7xYYkxd/MEjKIM3CceV5i4jYcawDqfhFFblXoy6SY3RpGszlV7TnYQC+PkAuhmiBNrnVu3HmtFXIYozGQIbp59PU3RAFLJjGMmTszVTDOXY8AA5KDTIE6q7DyM43Cux05Zg7mjH7PlQdS5wpLFp1C0PcCCxkpTgbHOaw74zH7/7tBeLYomS+UqUVGvhZN+Vgn8mGCxBinPlFFhwWS9ntbCJT2vVSZScwd6QimzSijUnCzj+N3x7//45JNP8Mu//Mv4S3/5L+Mb3/gpOFvEYxwDCDqTZqiISBxITEY9IpFq+IZyWkUgfZK3XrhKRT0AdLQeAAFGLnpiJX5X9HrHXIugXC9qzSi6j4GO4vWx/a5gn/Z6LsfDfuy0RH5rXbnU4Aa621EGyVcPACdwBZtAnKLVCkRZgWDtZbeE+w2X8YRXI/Alf0aMG54Hk6HHNVcrnLHk+hgHxnHB8fgah504cMWZzxhzGz8JuJgVTeSdZhf7kLPEjVVwLgEck976qxI3Qt76Do+YnEOJnIG4iqWx6bBGqTVrHWmtELsBdgHARpFpDhuG48KCua9AJkQg8BzJpqCTz40LHXkrwrz+U7reADpjHQRSkZR5Pbei5KAAsMnISFyQ7Vw1AXNPb4MQfqOAbdaL7scNSMLMas7KES8Os22yXbJUFuRqEXC/bstZxr+zIeCdlWD9nw08beu4Fr0M5rVYt3MUZqg3rV5aUbHttrbrSX7XN/e95ku2o0bZ7l9LJUv2vocaJ5rRwBgqkDAGxsUxLo7jwXEcjsMHLuPAB+9/gF/+pV/CD8vxOcrb1sQCGmrSPxod5P1nCgW692KqifB0VE1nyykgINDiZeERabfgcl/K+2XH7sbujYL6HshXlNUM+hoN5NLCGKG4WyS8QW1OcuAK8DDXIhEWK5EYK1pDvFmeS9epAlVuN19cBpuYY+7ItsK3ca4NlLBO3L07i0L3LNuqdS5DqOjdUUCqS5iuS1mFPxZcozelRrU2e4WTEgpjrQgQ5IEnkOaJLZxKri80UaUDKym9PNEEoWA50QbTeNvTVmCsEb41MF3eQIPqIOpvCi0LCbtud40GidCac3U1rZwbxtEacrcILuPFUtF3lS2uUpXWJVS3cdnmPKOECGHnesRshctP87kM8sZV1ZSB3mNsfEj/6E7C6LmwEuv7WiozIVsDtL6RsVpGBY3LpYx6HRtowYJjizBkBMyrzryUSGmCcPYjQfYeq9K8CRkkW7SPN7oFuq3omtzL1VyP8oJz7H2PhgL1RcvrHIt6uFqZbdXWQwMle2rdF6O5VFzpsUXD0Dp0W1HHzSFS9EkmiNBZwb2qZ9IQL2NDz2EcoxwvNv2749/r8fu/93v46MOP8J/91f8UX/vqV+TxmogEDkXSI+XVjcCEyl3fTOVsDTYnbLK7uCdwhtaMRQOtHc9befW6sctaUGXrlm0yqzjDrhzqTTnLW2TihRpCdpS32ah3Ry3M9fFGYTtQ3z5mqNs2Gl4ncH068TEMNzjOQdfFew7cLoarO/IMRBjcWNPO44pbfIw3+YzvXW4IBD5+CjxfE2RNqeeWKJQsM37A8QgbX4Q/XjG+8AT/Y8Gcp4EMR+YgkyIm5ZAFHATFIZCbSBxH4HIYHl8H5rzhPCfmeUOcE90PpZTUBjwTgTgNcwKhfVsIpKPOgdahmIE4T5gBExfpxkcAJwAnFRYOHBO3AE4PRMmPgye1iyOhrPWTOu3hSLz3kPjCo5ynZwI3tENlWQ4yTLdy7y6n1ZmkWJ8GXDMxg5Fi0/ryIzGOADmCDsyB6GpSykmxRY8uwdmMgcHqgG7JBH8zqZSKymkJT4AVyqT/3l6kWBbHDzo2bAjoPG09LJn+9jfu/9701KYkPvULltsX+1KFa9eHy/ldJYVhWCVsjV3ahyv3wg8clwPjGDgeB46D9GdGNAbG5QI/frg6vH6uqlMlyHpsU0pa4bMClAViYGWVFvgqhbvYBuRNlxGQ63O1B2oSXeE02yzQtxDoEn/7nZeXtILRAdIxCMDq2rqOWC1weg9yX0DakKNpLWUUbWK3gHiiOacv1+N++7aN1QoXbbiuR1SUme4RkB0S5yWVy5ELAzZ92DdwtJUw6j3gzIGxAj79vi2+pxBr2Yukoy3l4tt4SM1g3YmAYMfva1D4fo23mSGcEaxtyEsP8nlj80F9Cj4sQbCkReq+ttHuudxEigSNDdFUkmMaLYF0T3mfD5LIZQxpomkUlPCwvkcOXPbfFY3Y1/79/WQ/h+3f31ePHpqsQ72ja9SCKzJSnT9kgEbndixFYPtYRlG5dL8VbYLmv6hKRQ2ay0vfpTV9PXt792t5pMoAzDWiu7IuUey69t0YF4hBeRI5Ngj1uoFt46l5jPX33SRuV+4mZ6gk+mwF0fn5dQpDN5oSAauXPqkh1lE76PeoMatri5aXSrZMfa8iUXk3hu+OP63jo48+wkcffYS/9J/8LBW/06ProX4bYNMsZCKHnGTpZYdjCMEzkkpHl2VseYjAcsgBdxu/Q78bCtKfXiCul7etNQosw2FTk7a9tFRo3i+y2gaQgK9vbdZEn0cCeDmpXtw2AETiPBPPYLWtKtxyceq1aaZiDIkqM2sIzJy4BvAJJiIDzzeeJ2I5EOpBlkPEUPQjfzDYAdWLKLngopotR4WXToM1RXcY6aCHM0rhokZmlONwG+h2pPIc0RFKDqYjuzmpacxq3ErXFJDm2CnKqXMVdjiNdlXWnJW8cUnLdJQ75DA2LnwciYuRqt7yrrnf0ld997sj07rAYxjpWt2wVA461xrsYsOV2JLbWCxP3qageR02/xVxzlRhsT9uS77OuqMlj9+WifZi+ecCWfWlT/1e3dM6//4h+5RP2v6Zlx/4tItofa1In+1vrTmvZ6hodkU1tsRvV6R0DFKl2AHcugv4m6cnPF+vn/qUf1rH5zA0No5+yZx+0+j9vwM68opnyyXJUe6wKrXmDdyswUSXny0eYmaxekhJyWwudEs6RwOWNinUJI/yUQvUah+sKkqFf3mvzjCvY9GZhL4qNIrpGOW11yrJLLYOgYTMGSkCw4TpXrYB2d0/WF7NGlMUB1XCETaYyzGVRBrc5AYClSiUOEFnyCSnPDQXiIBJEKEAt5J2Pby9sGYiyiTnLyrC0wBNgxKOOIydy+saBiQGtd4Rm4EBNADdzmFpSlxWSWNzVZCSfz7LS2/rfu9woiILLUiSnzl6YBcQ1TgVNKw+DXUmZBAgWr3C61YlIAN7fOysOcqFMsYWOiyhDTgb2AFgzkhpGAFKbQwadboN76KxfRelsDByJbLruyXEZoYksp5Vgm2UgZCkQPW/ZIIhtG5yM/BguVV1KuWj55B27qhky08WF7DhK0IJrIjBKLC1XUfdjKthblVaq/C8QQZhAlWxxZK0BvfRqr3vrevxVv5ELjDVIKkUULZQRxvNKyZEWpnm3WoFaN2isEVu1KgKqfOnb2ugP2s1HmvZaTGogc9aXGndivBOMb07/vSOMQYul8qzCRZQqEpil0A4awn6dIzDYXZiTnWIr1yFCUQ4AlO5h1UtaC0HdoguxFWbQ1IhlxNreCE/ouO5hy3qyCUuGkz27sSi93zm4+3zq0g6akdiyCML9hpBGp7PgafHAVwGvmSOBwO+YI6hRLlrkpLMyPOAPTzgNi+4PQ18/MeUWnE9EbeJOANxpsZPMmUCkU8cuxzwpxPj+hH8w2fYG9I5aVpUThYTpVkuFKs+zElj4siJh2l4dXVgGiLUW8gdOdWlxwxmA4YB+CPSHxD+GqdPhAd83kQ/pu64C0wlf89HIA6jzponGJtIWN6APDFxRSLwfJuYZ2BOx1SkwCv/bQJ2IW00VWDi0SbeOxM/8Sbx5hY4T81dGlg+sVZFtNOuxsMls890BBKz8mvk6KrqfWMmDk9FVgKwibDAxMSZp5oqnpSd1WnOIFqhYzwMjPMGPx0WjFCdKEPTYVmZ+eyInkdpxKKuAXbfYe+ttVlkhzvDoHDbvqKFMcu5vQi5a8mXGP90a8Xufl864k6sN07av1FGhVvHlMSKMPaSMcM4WD7ZB8vXHsdg928fOOyCcVxwu97wd/7O38FHH330g8fkT+H4HIbGgnYAB2tYeelMCZOa/LLSZxkU4GRPTt8AMNWtNCoS0hQCSdshz0HU4rbmKrOpSrZV7xdULvICoSXZ05BnwC6TlZDKotzWRJUareSchIlDaqh+SF0eRxy7qnNdowMU2AC6/Ju85gQdjpX1GjRmBEogoMxIyzbiOk0CpKXAYcGQZHPv+yF4bZfAzATiQHdUxzRFHXgblacBAH5S9oWzDHArLgyYW5dgXZEkDfKDqjGl00YxGoSHu/JwTmScFPy1gQVec8h4Cj459baTlwqgGqKE6TUBz/AC/NG9GYmPvZVOlStG7edYa6KVrNZfe4YEYDF3aszyzlW1rl5gWcaXcj0GkNPkhy8jhs+XengKKc2/VDIvtu2uXtd95gacpZhqybXnsNyZSf5uA+JBtJtzQfEqNDLAyBwFN0FTgfxQPds8Ujk+HM87Xqopj95Ne0HPlgbcaAwz0TsZCZGOiTYasIS9IipFZCzDonWijAI+Fa2szAuLLnSfHs7B2j+KHBSdxa2dbqUsskM4vgzpqhIlMcYy3Fj/ymMKrMiRruc6cW8feRmt1rRFGy0xFAUcrvUyVS7MZcPz3pu7/PmQ4Lvjf6bjm3/0RwCAn/qpb7B563BGOCLhztrrPggsA1W+NeGD+9KHd8lbOiyC3Z0lh5ZasvXfAh+2AR/U0pW8UsECHvrF3j4bZU5LuBc6LPcPvzQn0HTE/gqVU0U+ygvr6opdfXl80FAa5rBHgz0YjskitGmOrXOp9AfYj+JxIObBPjunFOEMypZZVY1e3GEwC3vOj3HmxDWuOOPEmeof0Y6upT1LbKUcmKtPU8mHnoglCPQnHYAGuMP8IH9+PGAcN7ifKA9kAfR9Qqp4i21GmUfljSRynkCcSL8hknkfjISsyDLvQZGGag+QfO1E4IrEMxI3yJzNWgkV+ah1sAB0RXEFfADE5vDDishaycbSLnQe02lG4yCbt2dNFb0r0YrBeajwjwHISniuBgDBXkVAN75kxGhT7NsqbgW+027z7kf/VgUN9u/cn2xN+74/63azrp/bF1pPWteKqZGUuueS2s/ZJxZuFF2qfroMM68oRv1zVwEEx7e/9W188MEH+Oijj3D9UY1o1JEaHFeIU+p5rZONtsB5M3Ris0KBrDJUCZlFx7G7Ci04BSz1kkcquY0T4ynHrvuqid9oDOiydaI7slxeFqbU2rAlqCop2pPExEI4Eb0omkJSv+80nqbE1WKrJPdanNFR3Tohf9XzF8+0kW3eLVhy2YOc+CodGhCFZb8ObzIcy5MescqNGiT8OGbmNBh5uimKicFjdElXm6TbdFR6V0EajKKODLDPx0S2UKQn3Zi0JyGepwQ7kpEtzzasIKspcqD7dBiUh5D8rC3nfrVRCI3JXqmr7d6yPcoDfSqhX15G5BYK1/pw6RAkPUXzjOIoMUkzAHcjPpQgrkfwBEwcrALoK9ejBLmWSku6ZWSYxjISmHMLuxcesO2MrSAMhoGq4FXzXL/uyq7yHCsNsfNZZBjVvqik1X118z6sDb25v1F78CCIoHHj3eG+P6K1s5RXKXvbXqea6eS4NCAHEgNpXBusSCkHhaO5xctNW5MPoApPaBAtZLU5UImpqOaLBdz87k5QEbSlPdQhPUTDHEbj7U4Hrvq0pg72DtKoVik1A2Jo64unLOfNW4jv3fGndvzKP/9V/Pbv/A7+L//n/xMeH14Rk54URCmeVEU9PcES5gZETlTlPqRhIhBzNv10ZfFxvbqAYK2Nyllc1Ar9u0BCAuVx4VH7sf6s31PSpYB0f/jeyMD+9otzpG0fNDTFx1A8cYMfLH/tZhiXgXEYHh4dD4+O4+LAG0NOYMIx50Cc3BsehsfXwMPjgddfuOA8L5jTcfvIMSeQeWKegbg1WRGOSkoGEFfgPHF7vmKOwHmcuOYNV8RKfDZGfb30v4mNXJFJ/ZEjKMMOgeiqrNnKRZwlVQAaxwVjPOI4XuPyaBhHkm40gzJ8KoFb8+wD8Av/DcnTcar7rV0R80TOE+lX0qqeD6STEsY1sSIMCCBvEJMBSE+8iYCNxOmBjy3xbIArdBzKIWxnSwIdUit9bQa3qpZJylsVsVhsiNwC+VS2kXzOyEmK25zMjVEnPkPCDxkZ80K8AtAxmQnV5YUfQwVOWC20dOuM0fgoS7Hntn5rDd8pmxfLOtdn20bI/afwY2Ewuz/ttvy1Taz3yP6vvycqnW2fq/dWtFt6ripS+jIkfDBCelwGxnGwKd9g4jejGwd+49d/Hf/m937v7Qf+ITg+h6EhATckEJvyJOXdrn/r5mFIg080HaEmKAVrR/eAgM7Hhd55GX1KvjeK66T7cQhdmgLBngr5Lc76oseYGoqJAlW0nRPVzgEN8IF17Y67EXyA+qJwC1buB8TWSD6X7iPDWBPbAYspC9raM9osClXpaoVgizRBA00wtvJeJlgT2215FEbQs7JB2hAX1Sxhg6VMOV98tAzHHNaA30p4HtbjDoP6YxQQRKOlu0TphDwaEqRhYGI81OndqIw92vsbAFIJ4jUHVqX6GiSLHuWBYWjDYWbSkBwEemSeuHJTeA8NLIl46Y05sfo6vKVfN4kyNf5hVCQn5zJk2FYJyzKOa9xL6FIGbmX/oHieGdjPdirfrxZ9GYQDCN+iZuvuNl0Ars5FuWO1GF9rJbOBKh2R0VZBHsYxCOVJRGruqVzuGkvVmimpWxS72jYaSM5zUjEPKfKQA0GfZni+Z0Z9TujX8m2d7FKdl5Vi12sFEqrKGvcn2juYs7UnmiLVJ9S6LSO91mygSz6m0cApKkLKqC+FlrUHjb7BXrMJ4IToH6leObH442nwacgh48WKNubcz5OAyWv1rql/d/yQHM/PV/ziL/0P+MbXv4G/+B//RYQicjMJqixJCfZkszRADTirvGDS2oyDMiLUMDNqv+pfRxBES2rHT24i49TnKxAt3bkFLdqDyj+AMmaWXpQQ/BSbtt1htvZTfT60LxewYvPCYaRrspWTkW72OPCFn7jgPQMeYXgTE2cAb4zyNB8M9sjo+iOAVwZ8yYHr68QJ4CmB281wvnG2olFvCl6YQJ+InUD8FqQGPc/E+RyYt8Ds8P7mx6/hE+hmLyGNxykZcZPsHAYoUT2VfB8yOAxFcwEuPvEQE8ctgJk4Z+J6BmIGi0BURCtIWT7ywDgeYH7gUCWoOdlHZ3b58UAcm7OPYqXL24cFDCeIb6gXnvIBcwaeMHE9J85Jo0C2EeKmBTOLAi4dXY4eA/xolhn1ZtQaA5bnFZuZbOqJZtwPyb4kFH+JQ7rGQxSXcSKT1lFW0ZwRwIWRrxGQk+pAlWuHaNUpLLeS4zbdi17eO2Ss291w57YebOXCbJsFzTj4AbK43iv9wqFcm05QR/uo1mzpTd2geihUMvjKyXCWsB2O8XDBOJQEfhk4ysgYBw6/NM74YTw+u6FRExa0tEgR2DyqUwNra7gdgJlKamJNRMBgMTDKm1w2YQHLCVEYdGR5eNdihsK0JjAeuboz1y8Byh0PiF+Z63vFE1cyWsvfXpW69B5Kk9FZZV3Da8k3lqHHoBYxCpwUlwktlItKUwVqSKkosELrN7SHLFZ+CGlTVvivRSZQwLR8S4thmNWEAlzASd11F5XRu8u6zt0Tv21GhYIrJphAo70UkJyZLZFcHttMb++dh5OOVWA1bUW+dDNV7lPwlGVMBVjLUZ/G9cNCPpr/EAPl0LqsyJHGPQ2I6rdSa7dXrELSVTlIj8t8hSD1x1AwvgE+Bu8hq9yvBH0Sb3eMYRVSMFLUUHtjU/y5tlF2NzsBYzfY1B5oAc9xnMY17l6KgRQ7H1DOy76uU3MClmh1YC/hXPSIMEZreD/6jkPV5gqwF3Upi0Gw8mACbeikbw7XAKyfqyghwCrty/tZtIhoz9sij1hHUVsR6BwmnltW3fyKxunZTftwj6b0eJTSzLILtKa30TOYcp9Ig2IOzNofy7gzUSetAywVfa2ZrYamrUPLFV7jBtEQ3h0/NMd5nvhX/+p3cbue+Nmf+VkAUEKmkrx9T9wUZWqy0DLXACmFbLxKoRcyTCykBMt5VpK8gEut+fI4iMK+NsvbYKP3Rmm3H4hHbJ1//55V6Hen1a6vFLBqqhQkj00xmEEv7MPrC15F4HWQ1hMyrsLBBPpBZ8Uw4GLAoyfwAJgnzht1hD/zIpTRkE4WbckP2GCkc+aBzIkZpyIDrHhXjhSgqMNlbIhaFaR8soKjkY5UFQy95Ghu42Qcm3Q1+E4MCza6Q1J3R6rKXCrqBV3flAg94H6BHxeMSYNkRrDXRZqMn2g5nrq+JQkOpNYGPKfkKsvc3nJgxsQNoJEjRwypy0ldErkEUpe63wC36KjEcqVDrR7hfjElOhpOJkNID9qSpeUAVF4Fo94TKZpVygKzQQqeZzUwrea+MkYke3d89lJOtgu4lPJ2uz19ub+2qGT7rllXqN+ysUUPw/6NNiTWxRYG2c7ft2TEU21k0KlQeNCHM7pzqKTtqN+96ZrneXaO5Q/j8dk7g4urRNqzEGL3zljgesU5apK5OKrsJwfdC7HrPV0jCzxsBkUKgKBzs/satXwyyVEEbPEHa9E0VsteGH1YrlAVbwDV4K89Rvpqr0d2J0RFGnbAWhC/UA03zb3wLm+ptYWGhXD03UpgX8hTXMgFT7ggKxJTI1FRBzRzbJMDdb91f9oMAjUdcyrOe5SSA1CVUuraDYB93ZPuMQXUCOiiqScFmhbE7JW17l88+qaArhGQ93dRbe6+jk3glPdaF63IUQ+1ZS9XPuc2zyhAuu4x+9nUcKs4PsCKRqGGPxvAZqv1+qeJpzRGkc3YhG4B084B2r67/G87YK7ByTUG/ZnlZawGJD08XgA/1zqo/1qBkW1OGgH3kll9JKC+KNqvDfxRRkK2kKVhrefoPiqKLFpKJrjGL9c99c9cN5kgBc+3oShlUpNiipuaDHCVdu5FpevclQOt7WY182sO0kzignPruWYlK4u09k72SUgZ8OJ+c/1VWeMqbRvbo639vY3BD6/++LE+/uAP/xD/1//7/w0/95/9HP7Cf/gfAln9MVgO9NQKGWpsOueEO8uYehUaiUB4VVFKdaXmzwqQFV1qqZYFNqPop3LSLLCDTfbfr6MCZIttUvLuUxZaIVNmVkJ1rPuctW6rKmfCMLOAKkvD27wg5gUzXuN8fcX14YbbmxtubwLnm4FphjSH3Xj6eJ2Yj8D1PbbdOAHMLwDzMOQzdaPNBAblcdgBHxccl1d4eCBNKzBIO3qeOMeJuEyc6ZtsrufddK8lPemlyw/ADiMwn4G8BXBO5KSLn0ngNKRwHMCFOGnGiZufmD4xLWgERKjMcbRDMA6OkeGCY77CgQe8OiYwElc/ceLAmRNnOCIC5+2GnBOYp8rbJsZgrt3jOAnW05H5Gp6OV8crPPgNFwOeLxMzAk81/7fk80yxJHq+ReWrLudyrvmASsxKNLmR4fTKYBeDi27uYjlMmCizibiggnQ04BCYk6XuDQnME4gJU2kpmxN204Uque+QszZPmLEiqKn6194YcZ/Wl3tgrfbt5dwckfcfaxzRKmNbJtjOUSqE58mXV+D7Y/tgRb9d68xAw8ocwx0OZ5f7g3Spy1FdwC/sAj4OPA52/348Lvid3/1d/NNf+RV8/MnHb+/fH5LjMxsaodmgA3Z56O4qyPRs7ZBSiwEJpK/GduXla1BRilxe4/KYanIDRq+2oZV8YfXYZEUDscIU5SCCgiQbGCddy7bXFrg2JxMpk97iCtNxoxAglcitBV7gQXhFoK+uASa9KiG+wVMC3chPZ9kbARmSeSnWj7UuOOoGdDaFt6vP9qJQ5YoarDvdtsOif3FONuEjwyRQXgmer1hsthkWdbbAMjRzA121QzuvZDcoJNTW3ZiUZ/ayip6n3cugsc4tX0OAsp6yaXKglyoG1yUBX9aC07NvkRpJq3pmOGCnNZ1SS2iD5bkpbb7odxNG46tWSOWoFAhPjTcjTdl7qyoehdbcnjfgyN4DCeP3pOD57alyjCtCVGC4POgFG3RX3LVp2zhvxkk/p8bd1h5Ige6YhvDluUMCBVdWdeU2bfs8ZTdwPehaBuaD9QanHGn6pvU3UFW2MhlJK49XoEBVdqRoGW1LfhmwomrYFJXoXB213NYea/ljLYhtvHJwvVa+RRkgmegqI6HzhvgwO3Vj6aVqmPju+GE6zvPE+x98gNvthmFOyqwlDmX45khFLNCN/pAslJEYGGrcV4suI3p97EmkbbRqvWa/xr1Vcr/l6H60hwVrs62zrH0Bvn+3yuz+Z25vFKW2HRo6ynipPce/+aEwGiFzKu8s5KrIjrX0OSJIOQqfW25AbsbRdpu6B3cQeA8WMMkTyBvfOx1dRa6q5XVcxtY9FsaxtGVj1U3NwjslxBZ+sE0hRDICXwZFWvWn6K8BUD+KarwXAbfAZdDZGeVETDInUtSl1hulB43gfpTTAmCp4AEcD8AlgVfS32uAgcrtKN/WPgyoXke2HEZrPkux5h1Vp8F3FuojcyTMugBg0wCwOUJzRyLCfEbD1mKwXxn2RSZUY9xTHONNOuZbrshtoby1pPsXa8S0xmhhCOGIBgZb3MPWB/tz9eau1Po9e+tvMzAXRtG2kiUsX7vK2B5+/y8j8K1vfQvf+c538P4H7/+gp/6hOD67odFUln3SN4WdGnQLllytRVUN0PQhl4USHtK93sBnGJnrqHo7VW7TyD6cYTjUAGfkAlv8UJk0PLrfeArsF12jKEMJbQUAxs19X3qV6XjF9W/nL7kyaO96C9PsJk4bbOlRIvpeXu40CTOh0TuvOkjSTj17tSErq6vzLKLOlR2ssEjMTEyFrpHky1JARc9JdQD1TEUDFt0le1zQIc9OVpSASWyl9QSClxKT8htrE67tX558w3qykvoaTPOm41MQydhwJckKJJuePTQU1BMvomzVVNK1FlJlXbFxeTYDJ2qOFU4urnMKUfuEGkeKwrX0PSu/WO0DraVpQCXe1dqMBNwWna970GhNTQFkzWGLtb4fKfl65k37kmoTrXSsaG6AKEMbEtDc0rgpJMJyviGDeaF/fm5Rl2Kj6EoGVIWtiUUT4w1iZJ1K11KSP5UNEwfTalWUsJZx35NgmkOo5BVWrk0PUYriEEuwG1QOu8CaeOmqSNVlKeSWzVpj4PyZ9o+dNPpd80Ub3DBZRm95POStympqCajgnGGI4gjNTSeha79n19nka64xiJcA8t3xQ3MMNxzHEFUEXAJjuXncA5bAnCuy6jGQAD3dRu90TMM5i+K7nEv3GNFE76ESY/BbGyHuwd/+LdiSZYD2wbIE8MLE2K650aQqEURr0axhX4PFVXDC4JOfzZGIIzFH4vYGsJvh9rHjdgZuLjdkjZkZ87kBXI+J23uBeTGcn9wQzyerQc5AVU2kU2Fi+InhJy4jcRwO/MQB3Fid6szECMA8aOhk7OUZ+CDjoNvex9qXB/ceLSLmW3TvoIpCG9aYy0kQmbhNAuHAA9JO+JgwJSskpK9OADaB4xkGYOQFr3RSd8ctT3ieyIcTFoHzib1EMlTJ30jXu7jhcRjOcEaTDsN4AF596cR718AXnuW6C8Mn2OZdzUM5l5LrVaky2z3c4zFnrjVU62Pqz1MvsRQhEo5QEyaW1JeuRMk5RrCHHUuvlHPJH+B2geFSXprtQiz7ysI+xuhSmGhDAcuJamUgwHZ3vxXJX9GO7GfvJZ/rRkvOF87Z90a9thvba/ft7Av99P5G7xc3U0GeAXPH4UcbGJdHlrC9HBeM4Xi4DP194OFywQfvf4C/83f/Xz90FaY+7fjsORqyrGugmG9AEJEAtmzOrr4BMyrmjmstpQ+kmtvZMlLkC0fX3Kj/8ZpHQuVHV2MbAIoaSOhJYYd4/mnASpiGBNQq9dqeRl2JdHVaI1PVG8zJG+UzLGRTCcsjczU9q2coz7Tl4tGGTCiFDM0OebqgjS3QVlRY3rEMmrpvdE8R1PWKiZbLIZsnja3iy+Lgfaaqn0QeCLiw9vLSexkdrYh4HcfsP9XuApmBEbaqbwk0uXbdxDYGMAksAAgMJ7qqTdqduLtcaW3HXID2XPNskPATSONTRL+OiuVk3S8fZCSroQQMs+ZCuUI81fruHZqv+TiE0dsorRhACVIZKCbg6jWvrkiLjEKwMktFWlDPmEBFNzJZL71uJYvvq21DQ0ITbsxhgslbjmhcYENr/cjey30t7b0qkVtVzyw34Wt1TesSuNWvgvON/k4NnfVMLQBTy3YU6tkFdoXF3ZE2xPHVvuyEGK3VYcBDMjmxX1dTLECAL3vbAesea0qL8bsTxXiT1uV6eTX1wMhAHpNeWe0pRmg4x8jo3K1m1yXXLIsfiH4yB8FPRSlLfoZ1Yz6CN05SbBGud8cP5/H/+b3fw9PzM/7iz/4sHh8eyZt3QyLY5yJMSeIlNwHDRIwDaRMzA6HQ+zgI7NotUXsfoP5IRiyBrBC9uPr3lI21tvh3Knqfm0yHjNiSV6101uLnH7lHuLUVbaNoQsW6lw1CWVVVIpN7dT6BvRxO1j2IA723PBLAWN7dTPa+SCAuwPnmxLwxoXkK9/d9KiKAPLsRaVzZaTwtMfWvU4h7aDck6QOwgxebwWe+TJgHjgfDmaDhNHdK5RqmYYZDNPuBUFVCx2kDacCsNs9Ng65/AYsbYgInTjwPIv1rHLjFxC0nbnNiBnuHsPJioBxpaY4Yhnh0xM0Qk47InMDtGrhGYHjiZox0YFK/OnIB8t2JUf3J6tkkDPfcEopla+dfVdwMyauZbMBIFkThGSqKUtfVhG4r17n4hH5B+gN7kuAGwwRMvWiUvEtVQNmKBEzGPMvprtlZsHNF4RfFl3N/9+f9f5Ze2H4phkotHZQOaVxIQ4tO5PWt+sJuZLiiGPVvDHb/HuPA8APDaVwMV1RjsDnfv/yt38L3vvfHONkc5Yf++HzlbRV6LOqMg2ByQ70EsRrcYcsbOMy7TGUKEEQAboObr7z7faJsJZxZ7YBUUcjQm7Y59ppHoq8K3+k9eUvJx/NObOpbl/CHDHxzbuYpQSjovbw1yYiDyQgpgJZIoJPO1pj10AAoGGHBzVZVHSJdIClffH4DQybDwXqEeEatcjpkk82HBpXSMBlJRSuxgtOmvn6sBMEW90xsLRzZsRmNUTV6ywQmqaTLS5EEvRaU12ksh3enJMNQHEZTQjHnLNe8CuczNyrvnr+kBtcez1W4t9YeIEPMSUcpjFoCjsnZhqsbzqqXrtLCvf5CxltZOJuXsNYVUEZT9jQbsHIuquar+iIw0qC1chobHGnOGH24n3EW4RIIKIOXKB0aMs69tgENhvvwfKKeC5vy4O4NXceT0QYAK2on0FErJcrbntEGSHs1y+6u+9U1tX17fS4gv0D/Dp3NQPQBQ1kvFaVn3xe9nsZ+PFd0mcVe3roWe3sYZlvg0MJMlLVc2UUz5d6oAg/YaKKloAyKFHqxF1iKUtSCnIDPVfxiN3By0KOHlJE2ORhV3nsf8o7gpnptgJGXl7Ux3h0/XMfv/f7v45vf/Cb+lz/903h8eMTwgTRDuGHkAcSJHKy+V6VHJwxHRUDGihpkckGO2BwQu1pEgZb6jgB+lPQSCGo0VYLAsCfLbtCy93v9bMpko7K1jYB7Ci5VsXIaYaL5cGOaJyuvJWBnIt4kbkHK0FRCtyPULyu555JAyjJhT6STxQiczxNzhgyNlGGlO1XZ94iJCBawmM+hEqvRe5qRo/vHvjM0koZGxATUz8IdOC6BMfkMTZ+pMYMcetKzYySGJ/wG2DTkOOgMG84wRFUpLBBqAcsTEROnOZ7jEYkD12k4Y/JfnkwOV0lfMjIknW2wWe/FiSESiEkZebuybDw8qe8UBQMUmRUNvARWqTMTcCq53o2Tdz2s+XYHfFhXVz6FCWaSNlWzVF+rggFkppBCSPZ3goamAcaavzkeViU26eMBb/YE8y1laOQpJ1yBiPrv/eZpJuFmXex+xJdRi33tdx4gChJY701bmxNtTKwv3q81rPMZfDM2ZGT4wPALhh/6myWjD2ciuJnjt377X+Hb3/4OflSOz2VokBEQvdkyfVEgBO6oRYcirKlGxdYgv8h+ZsnqQ0oANW0cywA8ei8WSNq93L6hlIpsVOm/cifyVlYfZLYFHVqghplQ4pI4orUAkbAMgayFiOp5Yovk1H2lSspa1fXniTbBvAOK5Y3HWfz2Mt3qnLGoX1UWsaksvE5bAYj2LmUYxw+qeCGrpIHu1tWQ0Y/EYTTiWNJUgNdsuy8aWJ70GLgUUr4A4OXJzkregD4btaN1j9rKTTMqgF8KreZWws3uTCoUo6m57ZBhtcqLFipmuHWE97fJfS3l5DJWUJO71pvRG8eILc+3EwhcY1y9SXLW2td9W4JlbUUBK46uGSuraIxh6BObIlsOwJJNvDqpIdHRAhukYPjuedLaGAdUfgpY/ptcP4wNELvCBRIWk+Uim/eL7T/lvdKYlPKZrnvjjKHoGyiFUbPs697Lc2+lBO6k+9L6WYqJSox7z7ZIi/IXVdaRgZjU3K3okcEpn6z2m4HJknzu9Ip/8Z5nggbg0JpsZBVrDFFMA45FKuNsyHgqg7x3RS7FxcajPEGtLetnhmSU9osv7ytqjd5Dw3fHD9lxzom///M/j69/7ev43/71/wIjFZWbYsePRKgfgJ2Ax4TZwFTDUjPDnNEAHaKpZJYHu9Z3yUqtiymPsbhAqvZeYr7lZR3a9XqzdOYyMupDLY2N3XBtHHALmAXiNmmkSxc7DMeFpTmnEwjOMNhhcDf4xYHDML2yB+W8SIPlQEUy7HiE4YAfr0g3s2fgdsW8nbjOiXMC86zcDuueED4OpB/IuGBOICxw2jNiTpzXE7hO5K0aydnyClmuio7nMxInIm+oRqNugYHEwzlxm6RfNbIMCWMbcBwYeeBhkLI03kuMNwG7KmowA7ebwjC7oVOyMQ3zHMDp+DiBQOA8J04w2pU3roVwQ8oxS8GXiPNkBMEdczoiXGVxgedwzGm4puFU70AbpWMT1VQ+JtdTOlAlZB0lCFsR9hopQ9MmS3WPAZzCPrfJiFLO5L1nSGBTnrqz7PFDBuAnTpdchj4HA8YJXAz5yhC3yRLs5yH8aXJ4AzFEcw0+iG1yel/zpZEKU62WB1zjhSz7xaYLf/pet5e/FK7ZDIkN8C2YJGcvC6CYqtIpL+M44GPguFzgqtJ2XIo6NTqacYwLzGls/Cgdn70zuDiRkBWcxg1trj4J8uI2gDDtBdsnMVl6UgvuzuOpc5hBQojvtWIXUCLG1z0IAFYxmXL1V3I1Ax5KhPLi7GMp8ayvxAJB1j8WRcUUjoQ6YCPayt7HZnOYrnEDUAQS2zz6DaGjMK7C2MiOWNQZ0rxY5O1lL2GRUYaEfpcpY5vCoWyVB9XRdBs1gG4wBssVoZIuCmPOx6FohyfvW/i5b7Q3WZYczy43WxdTmwC4rPhtWTDtpZJuS/8ZWjGYvFGJ9UzWU1ZGhoCq1l/ZvRnMO0jnXJq8NENroOldDoaWJ0Oa1Q68OLnVvG6XJ2IVdFSJdAINbD0PduWGdZLd898RBD5/pGylXj0cWLL6lFVQa6GMNUX8a20jkyUSsdZmRRtrBVpPgA4tYCvjFeserKyO+pxVlEbUKkX87qOT67nLONWtLUHNtvKicfCDJQ/ojcwNNC0lUVTjqkZsaUyGLxpndQWv3dZdD0sGLDOWDS5JP/P6fMm73tPl6ZUpZGv8ioJWfDRLOlUMigQavZEG614/XtROVJdjPlsoD03iAD9aKuXH88hMfPd738NxHAQRZmri6FxD4vTmSIIveJe2zVGN/EAHg9ZCSMGZzgFIDuqapu+UPqg1uYOb7P+glRqj8/v+zPXBuy9KItmA+QEfk2o0gg43XcjMYAdL+pqNBlKk1bBMqQ1epxwRfemSROZAPsDsgnF5jcs48fiQuH48MTKQN2s6Jfe9rftzeYMxaMDNBAarQ8UUgI1FI2teo20yLSYqZt/4Rfe5xdRbXixMQ6qMdwdnYw6Xlz5X7Dj3M1irWAZTqCsybSXIx0Q5+UrvdRGV9tqv9+Nc8rByvGjwAZibA1R2CkR5Llm78k6sdRnn13XHizq1UI3+t+U8dBQeKSW2gSIHr2c0rnlLa9w79pGTQNrPjRrl3ac4q7x/3ZGVkbHca28fG675Qe/tr7QxYvtwl6LfP/jiFHs0w7aPrddMa8ZkZFTX7zEGjQz9pCFSEQ4aJs/PVzxfb5g/IpSpOj6HoQGgwIZVXwBfr0E8b5WQ61rwmhRvUJoNtJp6kgyRmhUpRUBSAqHALfRulbDtBNYCpEIzVWOhNkKp6loAqfuKAgeNlgU6arNhLaI01kiv5zKgE95t+3vD260AcrsX204LJYv2ALdCsAXitYMX2BCg3M+D2sslTJ0bua0fK/xW/8H6evtcEQh5geuOJYz7pm0TRBJ0tXf3TdWPkZ1Y2yFf84V2kdt9o8+/Vk1ugFe8LCnIMp4c6LySjobwm3zNBaddAgrygKvmeF1rKUDrMacC3IRwvbrLJA1xtclLIyXArOZhdXvZphcVmq5o9raUCWATKzehFVOZkWDipEpg0ni0jabHPdBT1qCi1nO2Mb6OFyK6qEpVihWJomvcUax6re/73XW2Jaxr3daPXdFmlOJwdEJgBhv4esmCaOAufqO6MVtXd9q2sSZGP0vff8oEair4jVKE/dq+PvZxrPGQLFC55+Zu91oxODa40nPoWJKhlzS654j4aNmK+l5pvTt+mA+DH1Kr04CQ8+YAzGdXMrKYiOshxxvJjKHIRiiK7SmKUMgQHZOOslrrC8feW6P7/mw0hrUlcKc6+tiBsBcgwgXDWTr2eO+KcTlx/SAQZyKvBEt2GOzVBTYcdl5gUVEOw2UArx5pcKSzpGmKXhhgadowUmgy3wPwCl969WV86YtXfO0rH+Jb35t4/6PAR99xlQLWMwdgamR2uRx4sAOv/ILXmRjniQ/nM57PwO1pgqVTizOAKjKIBDDlNLQ4lxwThfN8cDwfho9eGZ4m8HwFouVscSsECo8Dw0l5jTeB+cxIxFX0p1sEc3E01g5gXIDjwXB5zzDCYek4JpAZmAd7acRM3C783mmiR00D5omMwDxuvO/JRWBwHMH7Gmnw6cDJAj3pifFgiBOY16KlYwlAlAySfLUB2AVm7NRX0R+fZJrhoJHkw3DMJeqnJSZIc4uQ3jYj08VYqe9qrJU7T3ZMpxIkTcPOE35NmE8MDOUuHMp/QevkDMM8gedI3CYdoqX5a67vsdfm/uo98sIptm8j+5T9Ujrl7jvWf7+8Bm0L6W+FvYeMUlKhlHvxeGCMA5fjAvcD4zhwOQ5chuPhcnCMj4Ff/fXfwD/71V9leeAfoePz5WgUuNTvd1arwFGBIS5+gEKLtZ5BuYu7UmulmJNevwqNQRScwn9VXSN2AAXx+M2KKbM2ChKZLiFmjCZIo7sV57CqzwhMp3U0paMaAKpyjpkpehEtrQq3WFWiKU58A5/daACK5pJbPwPfaCu1ME3eiwD3aZlKHJ6aA6yeEA56wXYvesF3gRXXs+Z2rvppmUCsDsamKIdHeSB4VNnTlPvc1Jyt6G/c5Bs1xRjqrqt2foUEXJfZi5WHskqbcu2cvWbqe+homRbmFlVAG3qpdcOcD4H/U57jHZVaLUMBvWMpovZmWzY8bJVcp1BEgZzUom4Bzc0HEJ53XGvnYN6tM/5WHFw0Rq5Ug8UHVUTQxI227WY0d7ACw9brkfl4tSaw7ClshpAB3W31LSFsPS6VR1PnytpH8I4i8HaWEtvpyf0cbUhaAyezWMAgoByNMo7Wvj/NeozqH0PRWlOWHZVC2pbokOiGg7nGtgwBlzIpJUWAZt2rYBsOwFSYohwQvXZzJYyXwtG5vaKh5aHEMliUBt5rfCnLd8ePwvHmzSf4zX/xm/ja176Gr371a3A5VUJ5X4mED256P6RHkGBGkaLOiix3MzWgS1SLhcjD0N7dEg5LxJTZUH7iEjS9qvvouJxZv7fvM7fAsIljBhxROeiSMRLEs1aqCFVGaiqTpJ2GxuHywAepXpldYAYwlp32iVd+xRftij8XJ95cEtfXiXERzemWBGy5dKWb4RgDD8fAq3QccDzNIfixyokXcCx3ZpQ3P8ECEwk6LEV1neG4ncDzE3C7JYvDbE4EeqUv8PEKNh5gdsIsMG3KRy8KVLCHBXNGaj8nPCi/jzSMg+c7TiDDCOYNCGcjwZnADNG6i4rqINvBiilA+eMXwA+DP7pkiq3+VKqO19U0AVR9214TWSsoYeJX7ayN6srY88AG3/y+0wBjrq6yy0TZLspVJiuIwmi4lZ6tPDw2vBwE3IqOD6s8UleHdsBuB84EJg6cvnReFrVZz9H65qUzNF/+cj8OVtiosAdPooDYtkvMhAFL19rSuwKExHRU5GVorPK1A0dFL8aAK/F7uCua4Xjz5g1+/w//Lb717W//yCSA78fn6wy+hVVrQzIhacKqlOm0pVnPpCcnF6e8lCcXqYCvEXgPWIOpoqTAUrWU0RTmAAXg0AQuZV3unVoH8qQX6INA1Abt6GTVReX1nicTndu3rgoaHb4WEduUgMeCMgacZRAIsGrocoDnqG7T25tk2WQ7pmgU6XubsVU9QMIocGDVydR6zZelb8kmUHYs3qJVec9Y5y2+r9X8JvsvQMaUGTCUV9P0LFT+jFxrM5jopv1MSlUK3zn/OTf/gLjsyO6yTWpMLbKofQtB9qbaTWMHVVKHmAQWKjmVAI7e8BKeZbxGwuEyNNUQy/uCWIslGWk5KqExCv+BOSrWRmTNYm2MAtcbpK4TYxF0tGfSWgD2N8o4gAzgc59/61usKIchYOkyAI1JcDIkil5VMRbUPvUAqzJxzdgUnSEr6qQLyKBWsgjXrMaAOR68LxNQ7rCyysD2XkTdO9ds5Qx1fgqchum5ng/ILkJSNCqb1TxzGfXNjALlRh7CT9N69Ek/0LOmvuBod3CF/GuIUqWTrfJKrJ67lEmq+gGUPCn5ZbiLPPWsJoAIpcNYs7bcAVfjq4r4VCTMcsjQ5jUirPfrp5ctfXf8sB0ffPghfv4X/hH+2l/7a/j6T30DIwaN6UzMmG3QluPHIsSyZIfkMMMMdpeOEO1nc8aEsbxyllPIHU01bPMCWIoUcrxE/w4Z2u3cUtxtxbZ5EDwF3CeG3XCcE+MMTN2Pu7bVNOCawAj4kQgbci46DhgefMCGIy8DMRNxBlDVo45yChjCT4wBvB4f48t54qduz/jkcuJ5JI5XdHr5EzBVdrFSzaoyz6uHA1/AxAHgkzcHTgP37CSN10d2dJRdulPy1FrWGrw9z3NqjGbivPFf6QOqmwE/HmDjC8wrsSeknUi/4vTAROKcJ/9F9PVq1MdMHDNxBHA8Mpdl3ACEIW5MPSB9znELRgiyqkBJGIYd7Sg5JnMpxwH4I4D3BuxZgDtA2XfjmoOa3WWNZYmXYgzIiYgxYVPJ8dLxDHaQLeBpsBMYN2XGHSasdWAOeUjzWJgvKNdC7BekK3Jb3mUDxoCNA8MfMXIylxQpr77DjgM+aJaf6bhZYthN1OfKrw2t6cI5Wve9wGtjCOPV878wumhsqPJghzjWu/Vals7EFj1pw72iX7YZ4DQyjnHgOA5cxgEfB46iTx00PvjvwEcffoR/9Iu/hL2gw4/S8fkiGgWONYi+0msWkJUHuS1eRQimrOHMgGFQWU+g/AsEqHUdU/3/7DBnM4wg0KKEbSFPvhFMQmprXx1XGwJ7TRK9HAltjmz6IPLkfZkBR4F3RzMKTd8c4ttl7ZG57ZUh9DGhShO8hRybWVO8xhQPnYHzBh7dfHtwzEJh+ExXV+QgxcI1B7kpGQtOrAANut+FhmFAfNe1bxIAhvc8kqvui2llqaEW51R7zW6UYiyhyrJ2s9ZKEjx5eWKO2V70qEp2Ap/Vp8NCvVZ0nkr0HQoLM/ozsZccqgha/evfDE1v0+1gJetaJ9Q3kKtukrTmQFNJn5W3or6fqCjUVtAAdS91/axPojxYyPL4K4agdbQ5XnBXZqj2U92vjExzia6kwJ1a2wTdLgMy0cnxGgwqVReXMTq/gpeybfxqP6HHsn5YFXgY6zHNdmW9PQtIs0VqykZ2R1+brL6Wh76wc6YNSn7cTLIsz+sCVY6EzRV9KKKaCQB1TIZuNE7JkLFREZtJLnPNddamkEAryuE8513rlc4fm1CSpQ7T7B7AKS40Pa+p8pR81qrpzGf0LvHcXGVonNuQeXf8qBy/8zu/g+9///v4X//cX8NPfvknOeeT5UfpszL2LIhopwzXgJMqFZONL0FvNsmQiiVP9fsxAk/6B3wrIx/tO2l7Q00uQ0Jvr3IH7HKrDkmtmJgzcZ6U827spxBpW68sQGFr2eRc23aBaFUDGAMzHlRFLXAeBNExQBkTgJ0n8px4/3qFHQGMG/7o4xN//BS4XRNxVt7KJrthNNJsIP0CvA45Kw7gGdzzF4ePwPHAp5pPy+l2cUbNLxdn5CC8y7Lbwbk6QmV2UeML0lvN4fkIzy/C4zU8HIlngvjbjd277QTsbLCeIOUHSJwXLDETjhEOf0XnwplWdT1w+yQwwxDnVOQ44EkN/XAMuCUu6thuoLOGHdkHkCF5TwOpSn+TmleTX8pLAkjlghMAbprbYGJ3Rx6mIYIgn9iGa20ejoiBMJbTNIClnfWZManfx2CxjhkDE4GgWoCb48AFlg/weEDihsSEjxv71QyH2QWGA3iVcL/RmOqqa3PpZ2yytlZ1ChOUE3ehgcYmbXR1ScUao81wuN8+Szf2xzmmLiekq2+I6xmGOx4OUqTGODCOCw2PYxka4xiYM/Dzv/yL+OPv//GPrJEBfJ4cDSN4SUmvCqN1Iuq8bB9OJfYCyAKM9Ch7OPyAqDUCBJBRMqCFDQHAFeFogwaQd9NFP1EX5BIAqn7QSbGnwBdImWnLFJD3UPxIIaZA4hQOO2BtJGW1as3ECOs6/NNlXB11D0X9MfbW0Ips8CLg4WVEyCPFPgsSEOD98/n4uSlLyC1VDndtE9M4KPiASxoOWx3Zw9Y45xB8LnpWLigMhVlVEY8NFN1Qff5kF8HSOEYGlmmlFO68iTCCS0M0TrbqFK0xrFQQT1r5Z7Imi8eim0wANxgukHGJs/AuAWDR4WQgLJpOaT+u21LSQFbUV17u7ZZs5aJkluer2PRYEYMDsDCk+KaMEKQciyXY0KZPNmhkoiBCw2WysmAVyKGershZIep+v7xhAtR9b+wIEghMWeqpSnAJqCa/gHpRqoi8aZSnVlGWsVS9KLTw63nMOjQMrS1E7UVrez+ChkgVIyiDFklqBEZVaEtSpDpqk1Le/JsUPek93TudGIosncmSk+0/sKYrMsqj8e4ZrutgKVTJgOr7cuojCbRBydKOlGFTJajL+u7Td7+AdYJ0GlVRjgvJyhSA2MTQ+rzudKQtllcpv3eWxo/U8f777+ODDz7Az/6F/wivX7/GuFxgGHSUyPs2fIg5NQgEVZIcgHr8QJtYUf+iaGzroZwstToc0gsLEy95AqAskOw9t17bkoX6jBTXyYpYpl410q+W1t7/VsBBFNfeb4C0KaO8jqTEikFDoxkoAD3tAN7cEj4DHhPvXwMfPwXOk9Sjjihor9UQZT33YUxMP0zNUq1l0RjSXxrbUgGHAw8uLztW/wcfcirebBV5BPpZReqB5QED55eWk63CJVWUQvRo1P23rcSKd14piKIiU4+yJG0ko63sR1EJ664ysY7DEg9ZZciz80D2QyJYuKFoyisyjLZ4NmkZyYZ4d5TrGrvSPEXxSkaljIZfuIs6TIBd/cg8Kd8eRJm9pqLAqUR6Y08WRpYrdM516kYqXr/nDhsDNgbDxMvNxJ+FpfCWBqCesPWTzvMlk1cEWZEJWxGKcni1daGxKzRm9XcxDtRkkMUS2IyRJWuV8D0GfCgpXInhPhy3eeL56Qm/9we/j48++uhTZvVH5/jMhoYb09VyR2cRBJBjINNpwas8LdJpohboAIFVusGOlGd2ARkAsGm90Jvi1OChPrYBeS1QRhbK47xZJmqQZiPUTRRcJM6fsDJ4xI41Wu29oHpVFs2iBGpDeI2FiXPKe1mN2wxNRxmiiRQFBEtJNDtDQ0t+ujV/t3mdAtM2ADsNYxbo5nl9WNEhCWQh8G1gePJEc3rNXHQNiZmZSqqVwVWAD1ClinvFUwnYGNF0FNrv5FLWxk7MtXlzTSSpc3WPQJWbBSrKG30PpByxaU9WiAn0RDGCBGk+zVNQyeQw5DRS12rQ9by1hFYlExpxuz++aCxWuSQBzaEKHzsBc4rzWlWFWvNzcu64zxj8PEJlHSFKkuhLbuIgt+KvsDbXcRvh2DxsGYhjcjdPb+OoAYRlU8pC82AB+ElONMZBA7jWvIFaL5q/iKrfyjK7uca7zV2to962AjK9zm3deBth1eEYonylrkOgks5aaQMuj6weQMZEKa8GReUIgUNNYaggy2OqSmB56jzSV7FNWTO4U5xi4/xwxsshwXmCKJEFDjdxxecNFEtsrScs33F520zDm2Uk9XVCc2noju7vjh+ZIzPxD//R/xs/+ZM/ib/1f/zbGJeDa3am+l4YMhzTHGET4YELnJSp4N/hgdNOxGQUd0boHNaRahipSNbrjwsuZLynwFQCyiOTHgH2hb/QGEr0cPFOsMHrCRZsMXlT7DiI3sdBHCBup2Gw5Ps02NWAj0mtziNw5g23mHQkBKMIKaekycv9xx86vv808c2PnvD8HDhvE9fnwDwDcWsbQ1THxJw3hDu9cc9X2DmBcYMdU3uIpWmPZ87JuNGfmTBU788vJXtKvUEgBrta+xccRyYubybms7axsAOHJ2D+BB8fwMcVPt4gmGnNXinmiOMVMA/Y7Q3sTGCjz80J5A0IFyUigMuNovW8Gm4ZuOXE+XwiZrB5azl4BuAH8Pja8YDAF27A9crysk95EqO/9wb4JIBnRcfmwLkgCYroWU7ZLv2boBPUqPe7t5dZr4schjnYj2oaOJdwzPSC2owmRQAnE04yHEcceIDhvWOw6M4hB7YnRk4cFni43JAXIC5FHwMsHzHC8TCBZJMSxPUKnyccNxgYOUKoA7vTEbSqaN5jut2gqPvtYh/Lmt8+X7rYNpkuwa58SfNyWlUE2+BjoErZMu/ESZcajsuFUQw/DowLe2YcF5a5HZcL/vH/8Mv41//6X+P56enfSf78MB2f3dBI9Zso7IKaLKlnM0xbdAav+FR/sDy7WthnKhGi+KW2rtWfLiuanu7ihdduKM8zO1LKOw5U6khh35XEVNhfp4mKftiiTRDsUfO39wRYCMJ0/7YlN2EBrKJC7iDMpATKA9wRITDaUOyuAmW1jqv0bZew7bECzL07creHQt+HeYfGGzy6rcZrAlA14rVxajxhtp6jMJTcsG3917k3UG16LrcUM26NDyCKib5jMsjWsFqvp7CUQtysTMhIqkGuyxYIB3psuIg4P1VEYLuRVlT9U3i9wagEzgaPGzz3OpW3hCV85U1SabVea5tBbL3w0JxaE1Uo5bGk3bCMHT6adoBDNLnQ/Gxjk8poITZtg6k52AKpZbCmQcl12dHATsrf9uGipm3rP1J7ig+yZMASDC/L3FakJHsM0XuR1Mhl8C4X59o/DusIXparVgbgZo911Enbvv0YtE2tm0XR28UP1HjQvs4GErkuo4AZ97DVZi8AF1JCtbeijAhTRCzXjYC9QSxEi5CRQaqXKdfDVjU71HpJvMvR+NE8np+f8cGHH+L3/s2/wZd/4sv4yS//OcAcaWxiG5K7pa9IsSAALn00lJDLKnuLIpWIjurW3gLQMvmODLUvnw1HAejoR/2daf3+nUdW0dbWYeZdfvM4uE7Z0oC9NKyij5nImMAM5JzMf6vcKRkZDlE64WDjvEQ8GfKWiDkZfZ33z1APaxnIPHHmFdc8ETlxzol5BnIyL68a0DYFqnUTx256Kv8zkVUVUVHVcFvsim1AKd9vAJ54puMKyxOZU/kYhsxDTq2BxNknyMZSyZ4pk9TpcIHrCYSaEKbaoNOphXVvSnI0s65mhgme6zaRzyfsmrBZ5fuFbQSGU2uly/tLIVbp+ZX/Krld8rTlquReK2I5C1OfURSmtBqETdKcJZ1Nz9AiP8mqOOiddtyAHFr1YxkDFdWJUwM1gZxcByVvbWHH0qVLd+uHnnFtilrv2+/1ud43tk6xrBUZFjSyqsxxGRvmrrLHTHLvMrZ7NOPuJ9+73W54evMGfxaOz2xoZHNHgAY4JdzKIrb9vU0Zr5OgqFfIeyBnAhJrEWxAykuwrQ2SlYBQQtVBD8qONgoppxZZC9hGHAKtuTZLJf5gA3PZ8Ihgt5pvSWHoDBoPLfD2Rusep7UxUss+xatcO7PA6/JiNy1vaQEpAluJJRJYfEbBovLIShIksAw7KxCVax6qfnvPSgmXEhzLF1tjYVKEpJWlIjHZXP9JNIilxpYnr15KZGFXncuaRtJfL0FlW1JAw8mawxWLYE8MjbHvcyihrAgFCmSbNfVLCw5qzd1jhDZyfUWewDVGA03J2SVh9YAJdAi/tg76z1jP4ms5NwXvzou9zXmtA1O7SjMYu+6t2ctWaUs53hlQ2gPFt6tntbsr6n5rfWrtxdqL/Uzg+HQEraIfhjsFyaXaq2/tB1tX7VJq1f03rWKO9SCoksOcxk1z5PoMpua2F0brWHrsao/XHo3tXLh3NLRBgLXHOyrmNaoyprL21XYvuX613p8ch3rGMnBq/u6G5UeYn/vjfrz55BP8/b/79/AX/5O/iL/xN/4GLNkNGW5gjpVjYqIi3J4JTIdZYErP8T2V5E7F4OW9yorOJ5hoq99ZWS17nSKhBF5Q3sRaUwYo1wJNnWUe5oDbYAKucuxYYIUlacc48HAceHxwuCfO28SchpiO4zCMC2MikQlcE3kN5I072dJV7KNokQ4YuyL7NWGfgFShPIEbO4j3cwDdq8LmDXMEnjIAnBgIfPzmxPNTIp4SZ1HP1FNoOkRN5hjeHHi6MPfknIm4cX/PJ4MNwzkcc8xVWleyyDARcUXGR0g8wV6LZuSBvBriNhDngZwDkVek3YqkwOc3UGeegfQTkUnmeCabE97UB8RZO5bM29Q8U0XFsyEuiaiytROY18mE+zOIO6a6rQ/Dg9gKZ1fAynVDacqTAIaMRCIU68gCG+TxQwmw473yM10JupGGebJ0bSqftB1Gx8D0A9dHYoq4LtyXFoiRiMsNhmSyfDzCMXBcHtT3agJ5Ev/FDZgTGSeNjnkCPkUvQ+OYKj1fGKGFKgHBnf5YhsQyThqjlkCuz9TnpfurmH13+nbmopiMDFclrePywGpTx4AfjnEZ8AcmuB+De+oYB/xHrCnfn3R8ZkNjAqv9ASDBVoCbYnBIArhRZoQ8LgiXNSzjwzaaz9zyOQpgynAAsKIYQYoTFXQVO01iZwPyAJOkC9BrI+LYAY2UvFzKNsWNdHEczJDVRCkJWKsbshVHcTjXenteCVdWG4NYtCKjYZKiHvmgoK9xSyXCZaznbVSkDPXiu/fmCG1Q24FKMcYIeIW2wdgStUzoM47oUrgzW27iYl3gpMHQKDRVRpk2bCf9JuBV9apE0sgizXeOgxe4B5CzPGQULAWup5cBJWVoqWdNGWviviaFjVWYqsLuho5cFR0GUEnfzVisVKDwlYLQONDEz1U0pChGluio1z4V3TiynjecHdRRN1P5Qksw9wwnvVjpHFWv8c0qEAlxi6OFZFHz6p6RldPgPQDpswF5bs9X6788/VYCs4xQW3XmN7FK7JHFEQdsBDKGktHLRrmPipgX1YhrpaqO7UkxC/uUp0z7RdevkreMuNhdadnMKoUNyo56/Fr2Krmdk+Ne3b69PKLlOE3tJaS6zwLL0aDzFVXMsApeZHYkhkZxyUH0gHfDxzLSFL4LzUusC/Seo4cPvVexnfKdmfGjf/zRt/4Iv/ALv4D/+Gd/Fl/7yleRw0gtoXXRRmxkYtSCqvC8ASMvkgdTzXJNoN/o8QdWjQcrEEmnSetpWfztr8DSue1QyeWRHcMJhh6duiNXkY7pAbeJwxyPxiqQ18Nx+oHzuMAfHuCXATtuqnR0AwgHMKakWldzDED5FceXDvg1MMbA+cZxXlt5r41j1CPF0w8MPE3H+YbvPb1RSVrQQAlUnwXJM1ArRhrOAJ6eWThm3hLTgpRqD0xLnGcQNM9cA5ZAmgyN6cDtYOUtT+QFyFPyKw2RE7OiHNrnNJTk7T4uwHhA2MANBMozJ6YrUt2wOTf2AcF0zCufJybiGogzmNdRzlDN9IM5DgcukZii+t6EAVwOKFf0aSBxEYg+BxkZxESK1quHBi6S8cEqSgaHT+CMwAyOfVhipKN6oiVYUONUA8YZRt0QWON1O2hs+oXJ0Q6Mh1Ck5QD8Ql0Xhowb1xWMdNnw8hlpzKx1X+tgGVi1pLiitkiGIvUOBxzK9XOdq3RwRf02XakIxqgmfG7s/+EGP2hk2BgYD4MJ4cdYEQxFNI5j4Lvf+Q5++7f+Fb71rT/6dxM0P4THZzY0zs3SK+CZQqoEF+qIKbpAKf2sTpSpEC9PwnNNgjP+ofBvsnICJBg74iBEniC1hjQIazCLa8rjwYXgZsAFiOGdjFl07sLPXBy6lvhLBX4AIOBKPqK3PpidjJxAjAKCXJgJVgepzsLo+tCpBW5N26oSsXOWZ7murBvTIJk5cATclQ2SO1ghPcnhMrYE+AcATJb9lHDoZGNFbFzUjURierZBkaju14YjwY6sagSUwYQuBkgI+CksyxASFPKigCyqiQg0BJ1pBGwC7ynAR/pbYKRjBNRRlkaYi06SorPR4s3ujbLT4SpsxPsLdJlU47ocYDLatK27duF4jgBnKOSDMcAG82IwuRZcIeFEGVV1vaxUhl5oacaqSlih3PJksU6+5kTCvgsnyLNYkRkaWbaS7632U0nR1P+9A3klSNvASXTovMvxbpuhZGhCkadpfHas61Swoah3JqAedS6k1jPRDrdtNtWqvZfC35ye4prXKcpLK2NtgHuhaAaBVTjh4FqpiEMZjF3GWQ4Fy/uKLLRXrWmXwwBcpGCMBg6N1c2LmraMmRTf3Xx1cLaSkFUJrr5ozM3RKmD0n/NZXXxbRoCyaDPLNovx3fGjfLz//vt4//338bWvfBVf+fKfg7shfWzTaxgpKlB1uDUT/x3wSWdL9bHICLizKlp9RqpWK4mue+bjVbnP0uPLAQe0SEEZN0UFcRkafjhGWAV6UVrMwR4bF2OibgwHfCBxwbg8wtVsLHFKf6NlNKCeIoUXDsAuhvGlA/48cdwGxs3gMjR6f5SwV4ItlGc5w3G7cm/fZDgQtCfHocZ588AES0rieqM8jpmIQ/RU43fmycZ5lYxe8CQzEHki5hV5TuQNNDIebIsCOCJJf6JBYCs6bgTHdjmQ/gDYgRlXyDwipXaANDOgZToQmk8g5kkDZgby5D3SQLJVBVOyEoCqNoZkLNRHrNEHdViSWmvlJJLjho68JMYYoNAMY4jIRRsSVqL4JymrdBtxnRo2nkSJzNORMqgSo1ONEP2CcTjGMIxLkJrkB9Iv1EnXk5hETtWiZXGoctOBu4GAjlKvXddvSTdiRTbKoBWGWSFxmRg1rli6gzQpW4ndroaDSlwfhzqBH3v3b9ITIwLf//4f4zd+49d/kBj5kTw+Xx8NAHZCJVsLwsQqxWrrc/UV4iJZnw2qeRQoKI9mddbuTpLtAW0XAieznPbQGmumChO5dDZ6DKrErJWDMRdI6jutxUoZOFDrqaIfCfPoyjJx9MeXQZSMHxS1qd6r7sZ8GjbikQlAOGIFTfh9U2JUQhcRL981fozlTADZhlZCVXpYi6/LeHZkp4SElAhTbKWQMtvwAQCXdz48GZ3QpKQRAEPCpkRTnJrkEp5pIPTMzWvOGemkdm+sKhmRzGOBwRHwm/Uas6jP17VrdoFqblbO43Vklx5tlK3nnbpmCOjl9p2eUwRUEgy90m6xjLyggZEHCFzpqGNSn2sootRnnSLLzaLoQLbla8U/BV/vMQrTtXguc4J0q6QeGe+1DHtTVMdw030ZkMN6vfQbot4xKpCNeYlvjPOqyI4XMK9NomgKH0HG/sb9Ik2hntl6bBkhKKROZefVO2Obs2rQh2MLfRunhUumBP1aSz225QT0HlWJp1hvSqEcBc9WmKcjp5wZoMjhOawfkQmKW+UzVCEAPahYfsvY0F7S2uLY8YE6sK9nsJqXAhZ3a/vd8aN+/ON/+k/wL3/7t/C//6//Jl6/fg3msRZJI+EqYR4Ae0eMgWkOh2POgM0b3AxT3ZUZlQOBcECGu8CeG6JKwQtkVt+dKrMNSIYqRwgwJq4aPa2spuSIYewzdAvS4s9A+MSZwPU4MIYh54DlBUe8xuPjF/Hq1YEvfcFxnldMD1yZzgC7BD3VF/A+J9kPeQ6cTxfmeP7EgXlzRDhwMxlHovcmy0QYHHk5UFV9cJbOyIUbFG1P9dkpijdF1ayK4YAcJnkGMIHzYydYjmBJX9Rw8S5mnMAZeDpumEpkj6vj+SPH7Y3hxkq3BP/XU1HdugFSmfzhgH3xAR7vweICn04vfQEHkMrFZn8TWXkPk3kJ11DPKjPcglkg55RutwDLTDLn8XTgWhUKpYwM1roC0ksnUnQox3lLJqLLsZZGDGjg7UUZB5chdRnIwXpUh0rkHnDZJomRN3gARxzCE4M9YQIYg80dH/ICtwfY5RF5SeRIHD5xHI6HxwfMfA8zH5gP44C/+RiWDpwDZgcA5mvQyXindCVTc+vnJQy2jUEliLuofWZbgrv05/ofcYgBOEZRp1xlah2XRyZ5+0FDw91xuagR30GaFMvbDrx5eoP/7u/+PXz40Yf/f5M1PyzHZ8/RED6wQTpJASCT5cvkm2yaAUIgJEkFCQEPlnS2QlXo5jc9aVs9J4v2IlLhEi44CZJIW+XVLMu7yPt1edwxjULHFohbDLDsZ0uBm4qUpN4oFlTAMY6ATVrhNM6zT9Ogq4BGWU1WlCX9KSDvJTIdAIskdElL1k5PlYitMc1e5BNMtxibdyVAqkg+12JPVHlZbMIkLDF7fIFKwq2/m/KSjhPVhFNCVAK68s7CgPPARu2qjUyBD9GoUveeYPO+mucaOw96lbyqCFV9ceFp2p1lEtR60b0n10GlGpTB1wmTQp4196I/MxJXDVQ0AKSkEVQ3paGGvQB/0bLKWJK3Kd0qh7GVuOwu9aLgOJXaS6vytNZ0Jt47DUZSF7haWaI42I9kpsY50VVnFCmqLrvmPUwSjuzEWh4ZJh4bqzoNGoYxQveuJkyyuDvfQOsnQWNtaH4WlF+gf8LZhkTWT8oI7cTAfs9RCYBVZrEM5I70STZwTdbzccNW9KgiZ6xgA5Zezto7UqkR6nchCZCAZ8i4b30sI4I3YWakdoo397I0ZNkP/exlgZQVX5TIkidlzYsWWLTMXs+QbTQ0VsWzgq398u74kT8++eQTnOeJb3/7W/jyl38SX/rST3TSNHsXRTuYxK1knlM3rq06rcmISJBG65aUr2U7S8YkDHe5RwJK2XuraKtl6dpGHwHKKRDanFHUX2i5q2xtnROgF/e4HLg8XPB4DPHsjU6k2vZWvg5FuJO0MCNcxizP/t3az9Z5KE846JyzkbAG2dqcWDJMO3WRBvqVpY9SkX0kGwtWLlgUTXb7HmVZ4KZkbr8NZCRuz4l5Zc4Ey9KGogjbk7SXrShRdGR68Jrl1LR6RlEsI3NFABKYylt5MhMVusyxkso8fxWpYLGy7OGQySNfRvbzV1PgOU2Ur/X84mqgqjVWf47KOyNxQvA7gVFsgqweaItJsvomZTuRh4N01wIaWqcDRkqX5H8UJq1R3RQRnT58wM7VWIOPoqHVtmjduL1o2jcLm67/Atseqf3iZZQoYqF/jGzQ8LAqYds5G+zDVdHO7/3x93C73n6A5PjRPT5Hw74d1C1UYB2G4EesCk6HVnHYlj8ATbDEl+ryVydsSFClUq3Kou/4Q51Hn22BA4Jbcv+5QUztes1B2kJJFKCVuImCRTpWbcuUN9Kaw02wGsBg/YOosHZtMgHsNlAK3SVBCp3XJcisMAifLAKmXiBTHqXqvhyT3VDJ2+U5zYBDCekzlgFhEoh5Yw3xin0USmRuRTYf0nSNGsCqSLzGHcgqIwunR7z4ZpqDqPWAHXSaKAGcWLsrbxvNA80eI1No3xVtCkZmJFgBzRP5aG0Ica0o+uMF2ddShLwZpn4XVr02OkKQqNKqpshAOdo7QlfWstUTL898XYlAUS8GVrQBQKp7uhfId+HPbPWCTUz2ZHSBWl9X8mqU2IMC9SZZ44F1aVQECOBzHa3Y65rGEsBePTEWFarGz3JF0joKg1XauLdtPUUJ9S0Uz20rMqVNzYnfR/1EpWN2o7UNUn0waBTVuWwB/Ro1Rdjqf95PWIq27Bpb3+8oKddglW6M5L4rB0obOZZtrLaxVI9Yj6IoFSkCspKKEhWBisia1laWsVGKEXVLtqJLm3h9d/zZOa7XK/7ef//38NM//dP4W3/7b5PuMlWyPBQTPpk3N4fR+HV2Ry4DIXIA40SoTFmoPLtHtAMvMppNwPWm3aF1Wg62XZNiA04eE3RNTcQ5ERHIq2gvYyByYJ6O69XYX+ow+IWc9McvHXj93gVfOgeuZvj4ARgqLe03ytnjVAPAANKfEHYDHm6I64n46BPM5xsTmxWVoM5PUodO5jPEmfDLAN4LGE7Y8+Q+LPGIJordGQq5vwBgUaq46eJ2g5mKmpQHCSgGc4kOPF0TdhrenEB7OupUs2R2PQPaALJzwq4n8PQEfwT8eMJxskFd2MnqUWcCcyIiccZ2HzJcbgFcDarIWLJIYF6Sj0ndinZlrqgIFOVWzBhRVcNowHTuXZsYlSMyRck6EVVy3lgGhsp7wPzAJU/AAsdgkZgRgUM9xIarMmUETvGEx0iMI3F5dQKPjnzNKEWm4zgfcIHj9QxcH99gHI786BnzvMKnZL2MNWRltgi7Nd1paUu/MwwK88ggKXlskGyW4w+Ft7RHqi/GYM7iuKjylA2Mi0rYHg80Ji5bRGMcGMYyt8OZ9P0//tL/iH/7h/9WFcb+7B2fvWEfcK9cUQMutOqgt7WqSFSa6GYjWIG6UWzRWiD00JajM5f/v6+2APyKNvSNbNJihb+0n8tLE9xwKWMgM5mHMJivsAucFiTadAVX2LnVGs9tTJGmW1WAt/MuYgHgEm7l8CxDxurcQBsvuhN5KKzfc03aadYMtkPegDB0wmoZBTt9Z1MlG2DejYRdAK+J61Bje1MkuFLPugFLB7onQK6r6TrdhaWF/PIS8HMhg6fvQ+A4bIFJSACGbrzzRVA0FiNFAOV12IzTMhr0s+/cOAt3jdJq3Iw0KWSqD8k2mBtAtOqlUvfuhNgdVcrF8qvPlPorcFzj3V7wrOgXFOmz9lTWnFoZxSUYt4lOCccDeBEZ0jioMtMGdQV2NWKONqYJ8K3Xz+y1k7X4ly7VZ2udRa3pspN6bcoY12ykraFfzS5TqIFKpOhzqGfO7ZpZ3irr8aTRtNU451QuuhW2vdw0zHXOUrjIXH9vY1WArbfMMK2F3YMJ7ZNaO7nkVElDjUmGYUtdq8HAu+PP1hEReP/99/FP/6f/CX/+z/95fO3rX6crxQDTrq/KTBbUEGnAkQOzKKoTdPYBMLnzSYMKhV5ZOKRA0pJrtQ63tdxeZnBvRWIaAWhiqv+PZICoSkPeWgtvumtOsgvO28DtOnAdjqsZZmSfo7zzbIRJD/p8SsTVEN+/wc4T9skVt9uJczJHIqOiDcq3cOpP9qJgFKCND4Hp0uFommxu+30H53WUUIj+k9s1X3zE+s2UQIkb5c+dUZK5fTe3E6oYSUzgvCGQMB+YN+ZznDlxzsQ8A3MyvyMU4ewoBzb5ktlzatszleFR7Itueth3s2RSQSlL6YXtf2vJGJ24AcRpG+PEABukr6Uh4+jk+c5bHNb5pbigc2iILxJV7ixEvbLzBp/MX8yDVKvbDNxubOB4nlec8yTxu5sirnkqPLb6k2E956b3q+DC2h/LyOgxbFzJX9xWdMLMmQTuDjdSDg8leA8ZFz4GE8KrrK2xYd+3v/1tfPMP/xDvf/D+n1kjA/hcEY2lmPUXCOjIQ7GNGF4J0EA2PcDupre8s6g5JRiIAtS+tPZ2tXR0D4sGp/Lks2rHbCBr5SFH+aLR16PcMXpWJIAqolEUGoILRSyELQOygmux2iakQ1jI1k43oL2osJI3Je7WaJgP8sJBgc7z6dmdQjsF9FeuBatiuMITrmvmKKMA7TWOumKNdwMc9DiabQJlkzrlC+pywz2OJVC3vSmQ62IdscOqo6ITxbvfDax1lAIwJhDvQF/zNTaQiALjue7B5J1Z5wdwSIjmot4UZOe9leCoULWe2td9wWyV3NW6WSs6+zNEh3XDisSVd1DXdhmU3Sl2K8fX6333tiP7/gHlBIyluwr0VyJd1YJacwgmdbYXjCNda6DqmFclMABdCQ3DGMKfdRsKh4vKx/2yLyomnXa+Qmu83Lym1hQyXqz2Ce5WQ32WUYR4CwSZLOvqq1FzQ31lvT8rWR9WY8Nx3SVLRbYaUOyaGhzXAitrrVMesQmXTuvrmQl6SjZt36uFZaDMw2bsQlXPRAFD7TN7KXvfHX9Wjg8++AD/5B//Y/xv/vpfx9e/8Q3mYamaEid9wG5x57CgTCN1wGWoA4rABTDleKLcpYEdJYMaXzkiY3uhJJqUnfbDVANeRsIp41gtyWDDu1pOGUTE587k7OvAbQw8vXbc4DjV9kCpJQgAZyZmBs4ZbEwnEG0ZwC1w3k4CbYHtLHmIQOV+xg064fJo0/lvu73An9s+KmyONQotH7HLlZK1/SGrD+Ku9851tvGyvnhP/NrPcCYQMRmRmSccrICVMrxCyelTidsZNafS0WXM6Cp3eWuJRbkGloNw8hthZAI0OmvdWCe8v/eErdzYqKqf56pVkkD4AbMHRtDmQJzKJR3UWdHVKIE8FBVW9TFHipqcmCMwMOE3w4gHDDOkXXAi8TxP3OKG007czhvOOPkstFxfjDBUCQqb3kbLccJIr18aR9lb/wojla40GReiQJkiGu4YNjD8kJHB/UGD/FBRhQHHociH44++9Uf4J//0n3zKCvmzdXyOiAaVdi3I7tGAsTrh1CerHGTRlwqIQaEnZ8m3dl9KpqaJltGGBtDoT1WeGJGgBQptOKvoCaLrcvNOwHt2CPTVLer3IXwmt2hVEiyDhrtsoggZTa/ROYojmNiAS5FPBUzcSJqaysVAluc8UUVA4QOeLLFEEM/uoUqQgMMXFzHXcHs/SvK8AeVPBDwI94g/BZ72JOEWwNpAAqY1jW4KP6ZCx4vHBHNV6QHYr8hybUjn9+IocVwUoewKRgWr25hM5uWUQUfGktZbvSZVy/Eh+FyRlppani/hLBN6AauaqPIR4N20sKJKtSY1GBzHyjNqASx+bBkRkKIFAATSA4Gx5h1A1dWGoWunt+/HHEcGqQ4O2FwdoEPrpQRwCfvUePmsKI1pbFKAldW0WCQ+e98YKv8nMV1eJCwere6Ii0J5VJnZxl4qT4OloEmhK27ZPm4JQ4QjEXjZYZ2RiVhzVFtRoH6BcGtaJnF4ypgIkZ0Fy91QiUFVYhgQFU6AyUqTiLqIlFJ1EDTldi8yNDpKVCwHX0UTEli5IToPhvZ0lDODRkKtmV5HZdjIsG0aQjlOtCATRUcEI6G1V5vS+O74s3r8i9/8TfzhH/wB/ov/8r/El37iJ9pZZ4MFMlK0k/BgQZYhw8NcFfJSPTRqTasK1XRkTNEdo0Eiactcj2Fb6F57omgncSFZvjsigwUS6JF9wDgOjMtYjqgIpE/kCFzzBE7Hx28mznPieuM9Ao6YB5CBGBMz2NfhZqIIf6LMjATOOTDDWP688uYkT9sYqrrswb2VSMQ1V2VAHbn9XGhl/ZMmffHpH3Dkuo02TuqNimrb3cfvnAWZrC9ikaKOCitV0leU4y27iuDuxyxt0tezNTQtT21drMaznovnjiU7ExRGch5uhIZ1z7Hwlkn+t18mDWYTdnlC5kTgijNPGALjPFlF8VyMiArZ5jRBsQTzOQfmecDwgMNe4Xh4hXFckMfBfiaXV7iFYU7gat/DiTeY8cSo/OGq9sLnpdMpmSNi5fgE90iTZkonFw6q5wFsjDJXFJbxplzt1aJYutZxeeDfQx2+aWgoGdwGBlhY4RgXfPj+B/ilX/pFfPjhB3/yOvszcnx2Q0OrvIw/yq1KdtAi3Fc5DMBl/aqVa1lh4MFiUKOAgL6vpi9rtgVyi8oB9bEUNclmtHi488iYicMuEG70cKBu79B6r0cw0AsJW2B25B1HetQmTz6vC2ClQeBK2zhSJTWhzVPYz2RAcxxKuGdMVMUpWCLMpTD4mS6ZCyZ8nZJYw0BvQaJLvcIJ0r3KzCIJZlWtp3NojF5mloAtMMWkvkpMHzDcpmGqnF1NB78eGM7ng6p52EiCsQKhm0RPAU2WI1ZJUFDAVl+RUMm8ppNo84fK2qYMkg4dS6EOzX2Cpf2AaL58FhA0kNfri8ZTAG8BzkQXM9CzuiJTs7G7jIzm3ZArzXWxeEOm+VxJ6MYx94BbdHRqhsHzQkE7Ftg07QfOUDLZEaaqYHV9ThybTyVMgLy3kLw4TVEc0eUKTYZpGWs0FKSQHN0JN1M9cEye1qDhYMUDi6JtJSJP5EiFz7HVjU8auQ5GUMC5WGJd85DLLK2BzABw9APVYlpaV4usprGNgIp0tcKVsTjBGxlYuWHZ6qTnv+ahG/qVAChZlQBu+rscJZsSb8M80W1oaD9YG9M4TfelSlcwGXGxKGFRl///AXzeHT/Sx4cffoiPP/4Y3//j78N94PG9V9y/LseBePSejhyJoQimp5LGXZGyTOV4BR0DzkRmdzq21qJfDhaDbcYtz1tqPMVDJ5cdAtiJok6Zk4/v46SMObMdCylKS6hDN/aIfOt4AuyiIyYos6UdukQs9ax0HF6A6ALmWYZGyR7dyxbG+NRdlHrYOyvG6vTodz/ty/bi3NkoYL3eoiB7DOtHTOmFkiuV/xolh/LOkFnkTfSY9cls/VLDc2fcbL+V4ZHb3zunqpxw/c2XoaAA565YE8E8wrRTZW0nIthgMmx2jYy+idZfyqYwNOPB0uF+wO2B1ZougxnixwE8HMDt4FzbxwicvAXn2ij9AqnxonJ3RALoyAS218uQLmrwXSQDlXthWvOrdK35feJ3GRqjunyLJlXJ32aOTz7+GN///vfxzW/+ISmOPwbHZzY0XODbWp5tICI1UV0qzIhsVTazJEeX1oQjwGY5pnJ0HlDZpQGMoZJK5VrEAhYZCyTZ/T1SOfcKWjIDTKqrObVRRo1OWyuSD0YPuIBWV/DRnugE6m0h89o0ChqAulH4zWQjImB5Qet5UOMXCFRDmoJa1teZlk3LqH1kkWKG1Ln5nQQwTX0yBJqG7o0VbZYsNICDMqiEMr2LZYWX8SHwdpORWBsyT6RNDrFwYFWl4jCGIigmAFhikVb9yEngL8qWOeBjCR0oFJp1w1mgmIOSyb4mXkXly3hCiGOqsTyxel7VtXT+MTcBtAvqCA5AgcJEh+nNbFHDLFF1vXCm1rrur76na68QNksFQuvOpawr2RgRW3UMnqPzRhpQCL2WkRxc045Ejgk45xJhstNZwDhjLgXkzc7lWoc8hkZPvBtLRwKuEDunoQxz2IRPgX8HzKa88jQyQvIiq82wrsMxFYwQgKoCCWbZZSbLyKL71DmJrgE5U6Wv9Leal8HQBl0bI7tBX8KgttceKUiskrT6QHnE+nwzW+ik9ufO8OyiF1sIfwuOcQw7WGsbOBLPF/QKJk4+h8BYRe/eHX+2j4jAP/yH/wBf/epX8bf+m78N94PJ3Fl5SsZ9LEqMzYSdjGi4EbROJU6F+Iku56AH+yKFjPeQKCHvX70MGvwBQ9UEx1E1vFWHNhM5A9ThDzj8gjEOvHrNgh35pGTmPPHaTzwehi+eE7ecOJE4Ezhh8AeCLh/s3F2Vn2eyYV4VzKjSoY659m8fhdg3ubsFZ/aIQh1vmQHLpviTPvWDP6Y316dje9PuPnZ3zy13Ejix9JKa4wHohO3cT1J6Zb+JwgS6y2Kp7rSwbItjMyrqqTrCq/sr3LP+vLt3zv+SXyYj0A2I8yzY0qe9EQrgVrrWIAqpy9nJazweiQdz/MQx4A+P8Mf34K8v8GPgYVxwPDzg8t4X8PTJe7g+Hfjo4ydgBI6DfbFOGFhyPOmAlt7Nwyl3J6N0HJuKpKh0rUEORHSzSj/0E6JHmSnnwlZfDHeM42CvjGPIyBj9++Fs2DcOJohHJv7hP/j7+O53v/tjY2QAn8fQMKAqVohRxwTdg9UJVlJQhTeLr87FaQKBRX7PsLZDrBR2QnQDekJEqGkmSIEqF2hceFyLdysL2Rx4ofMM79DZSOvSsNHWNJb1gTov5Fku77QEtPJS3FY53BgQh1SWNeiJx1zGCMCoyjKUAjkScSbL5lYoob0aollYVb5Aj3OV72VTcwK4uv/p6vgJGgkWbNLngx1lKSbkoRINKVICvSr9AF3mE1njoLFwMGKDwWdYNpHwXTatCygnrahulePi9O6KMtqgF1GCs+p0WQssh/XQaHgUfbJliJZRcaCrjRVDDx31ieW9rofjJYETQFqD4l1LxKi5pKCeSaPO01gVyrf7AQg4T2Mi+aZ/FOXHBcCRKcWsyBisy1RGABaC+7rVppclumEmWVvka0cbjHpWo5Iha0+qSLSuPVjISmeOFXlCRzEza44NOeh9P/Lo6FzpKj+BfKAHIGsR5fbsSaMnEb1/PUlOnMYSt+5lAdgyUOokCbQxf1hHLhhp4kNEJGKkqn/JDto8WLndS92kQQaKNHiBCi+PMsAxEJ0qK29KJ0kkhoKndalAwid9JnUVBW20/1Af5BedfXEGgJglqxQtgqtT9Lvjz/pxnic++ugj/PZv/Ra+8pWv4Gtf+xqjasF1TxHnS0cMLLoNuNdHSC6nfvId7Wc1XgVzAFyUJH6moobegOpwcZbbgFbOAKBqV8wTvCQwJhDhiDEQlwuO9x5xef2Ah08+gV8dFwS7Jhs7jpNCzA3JrcVoqiq2ovK6KsKtx1jHC6C/ER/W3y8+un/nbTuk5H3FHrLl9dumx4vv17Vsfz/7hT2noq+hL3TD0rw73f3PXLdXMd+9sEezSTZDpDGZLR0Y+eI5KvJ792SbECxs9CmG14IH1PcTJV83ui/k5K3TlfFTbIoE4Kp+NQ1HOF4Ng12AfFjPfHHDgwGvLIDHE/DEcTkxb1FV9BXNLt1T82c9Fj0/LyMYpQ+Bt19XLsYwRjIORTGOMRjN2/IwOoIxBnzI+FAJ2+ED3/n2d/C9P/4ePvroI5zniR+n47P30agWzlW2MQ3eOQX7Bl3IYgmIbDDaoQhnchGq22ZhgSGviSwGLmgFsHStFHgiWLTl5s+idm27XiB3hce4exJai81PbdQKU/WMqrHf+zcTbHFPSzyt7lBAxW312Sjo3KiN91PlRXlpp2fZwB4Su7Qp0FoioAeQRoZbJdyWINN5nUCOwpFKg6V/DxkVk89QY6qxctG6SAMprwhDTV5UmBKU8hTv3ZPrMWvcN3ZT37+5BIGaDK0ciRphrQNVdopJ4MhcjQWcDYyLUI5kdwzPln7oyle1LrtsK+o8tq3Htc6bRtDlAit4SqWMzWNWs0NvdK4L9p5QZKOiFbIUOkfHZH9p/VkUGq6B9C1SJWk9Td2tU2PFa1GsVritNARWKL6nRrkuVf1AysrEH6wO3N0IUF4X+hYHahVX6cSaexhINaw1XNfURutdJ6O9vW+u/T2wuilWqUQPIKeQx44QcmnWLLVm/bqVV0JWWZZR5YunvJhvzO1ohVzJ42t2UdRLOj9sycBWmprrsiRqy7pYhSVzalg07ga0MbVtHhkx26L8FDrGu+PP7vHxxx/jF3/xF/BX/spfwU994+sAvPv7rCIhtSeNFZcqqjdB55bkRgSNejuBiQlzJlWbBcxUnamUTQIKY6j0puNB65edqIPe7BmYlgicgBmGJR7OwJHAnAPzckG89xqPP/lFPH7hFV7nR7jhGQ+fBA6nV/g4Dgb4gw8TaZgjATsRpxxsGS03CEqjROidzK49VQ1Y34587MdGC1vfRklB/lHoeoHT3GRGf2fXdX3V0sfLVNilyZ0s3uTvy2fZr90iPe9+3VUmpOpxd4slFhUQLvWIipbWh9ZF727k06Kouf3c7FtUL5SwbWo0bhWd4n+Vv1dVIZOGsx8Gn47LdHxhGPICnK9Y0tcSeDTDK0t8MZ+BVwG8Nrz5zjPi+YYj1LILIL6wt2+2e9zWvcm46R4YwiHulRBOXVhGwlCFqWMcXTHKx8E8jopsKMrhx+i8jWHL4Pjd3/ld/Ppv/NpbY/rjcHxmQ2MP8pCzZmvjvJjY5Q1QIy5b654h2uK9ZQP+NEU3GhguqzggjlyDey5QBnA3WJAFMvZ74i9eAZa759EFC3y0ELJ+rko2BnZMSjARZXMl5C0SsMl98eZdCHeLYDY43ysdrEM7p+gfOmi5S6S9+HwBYia7bkCyQKA+RbwuwySBqoTTAjwL99gaIltCvHi2IWODAqM8wxx8ihQptDJidH4GN3R93UtBz4rCZL1nCXhQpZbgtEp6B9JNLClJvbQ1xnMb9ztpT7pKs+zuDA0s4Ln/S2sKU8pIMEARrTWP26IFnE0Oo/KYak1Bz2zZpZV76Ov7J9T7w+QNsrVGtHCK1kdlxxvKWjPSyMVfvnd5aQ+h1kGs6/drJuW9xqU7whteuOVpCOIQQLizMqzPWZFBrlEpIa0LriHtH3mVNNibQss1WFqwqQXa9221fTc00nOvNVn7ZF1CVLL6XN03V2TTMb32xaaA7xRyNuBIWNOk7koOR3YzrrqnLgOsiGjRM1NG6d0zvDt+bI7f//3fx5s3b/C/+qt/FV/9ylfZkM1U1hxABgtKWJWfNaYzmUEdm11lwUkndRjOIcDenW7l2EMqkMicC9gDaOCwchCjmuz6jGPCYTjAJN85A09uzNm7OMwvQLxCPH8JMV7h9vAKt/MNbjZxxsB5M5hd2Jj00WA44XAc4LNEGlL9Ne7q1LZiWoq8MHJuO7qB+ItjORfuX0hsOiDWWyXjP+1c66TYTppvv5cvLrqL4TsxonuPXfCt56zHfnnZ/Y9sWVTy09phVgHhJbe37255O7tQzMSdbuy32nFiCw/1GT5dUJXM59uSqwB8BHuvDMDeM+A9Q36JBks8B+LKTz85EIOFVz5+c8XTLXF9fmblKUXsK1rTPZrE8GhNsOkBN2JCHxXNUDU1sQOYCjBojLi14eBbD4wyMvw4YOqP4ao2dXQk48B3v/td/Nqv/TN857vf+dSx+XE4PntEY6OZWHFEGxUB5TlcWlLgUgC8DIYC4iMBn/bC0iw0tq3wSpQoQwPLg+ASkL13y/jReaqZXNGRxLToDr/WnK26AT2bEpJXf4FCyACb0EnguQB4kLfvarbUT1MAGLlVbKhrEZ22Y3RHVgWYgb4v6LmEMfu7ixdEoSwIXSOizX0CNtvI66S6xm2cKzXoXvfvpsTC5WHtTexAii9chscCRYZMRzqVFHMjBKjgSAxMCyYyCryuxn8FyjTGI2A+RYUR1K/EaJCXSSUbvQY6wUzN+XqMSnE0cNzWb323lEMNYUUbJqMLFdQr+g+pZHE/BpUTkDV+RTPg+RiSZQ/ciG3N1oRUONsFALR/vBPty+LV2lzO+xauBAeJ5uto0nolZSivyDRO2eNT8RFWQCqgrfVM7iCq7DMEpNe8az9a0R4rsE5ORHfDbqWgfRHY3GFyIVQJJgH1LEur1wzA/IbstckpFNWj82O2NTCsn6+qvKWcGg0ydA+Z1ctAz+8FCBLoeQOq6l1tDTpESX9qPGcbnUtysGQMAL1HDn3l4dR+2ktLvzt+fI4PPvgAH3zwAf7D/+A/wJe++CVcHg5UhcDY5YKVLgRVWUjPuHSV6KKWiRzeUVkCeG/ZmVXNzR2wseiBOUkLtqWOgZLGpGBdoew7p1Nw5ADmgTwvmObs+5Skg7KTOOVKegDHgM8kXz4dt2FboYZS2IV8X+D33AEwPtc2aTlQsvMFPfGleu3jpcGyf6PO4S/fwzJoXgL9l1aTHvKt00vvLxbDfjubM6Pe2JyrdzCivLrb55sNsBkb7UTdztn+y3ott/usZ9msk77Htz7HZ3EttzEAe3DgwZEPNDTzWdXDkLhV5cgMPF8D16eJ8zxxzrmMjD2itRsZfW0rUNbRjM7HQBkXK7phRp3PBHAmfVdOpZeRUUneqjA13BQBYTH+5+sN77//Pn7nd3/n5Wz+WB2fPUdjB0FRPOwFqAFgT8S2ILiOmbxK8fCqqlBh9cKFSm4tqn1dlRuIrsFEgYzaOgQyZgkPJU72yQWMXX3GYxkknuy4LVI4rxN1PynQXWre9Ug832haV0knPbKoXCH6LAzqWp1MioYAjR7ca8eGLYBYABV8vOLmR5lTSVDXgGoTZjxV8LNLVhHIh7xBUKWQwWvlXA6Oyi2exlXhAZVEHMsILLqNAxDQ9oFuKFX7Ox3shu0CkaLiMKnRNc6qllLcyXo2s9WYyYIGkkITa5zYpbwoXhR6SqbXmkkkrErs2loxSxs78yqUPdi+mSbk1jcomPLQ2nLr6kMMF5O73KwZDpkqnklQQd3VRRMMS0yB56EHK+PZBCA2FLsMYt0bjeS6Xw2ML4xeX2V98TW23KvaH7WdAeQJ4IgWwn1hF3/aq5lRErAMyoHa701wUE6JDYj7zWtEyQYZIulom9FE7s2gQKcPI3vO+2kqymE8lwXYhFbjRyWh29+rx2FFDzzLFDTmRgVIDYtUJbJas/xetgWXsFlGX6IbVYbuP7RWpezKcG6yWTAxMVWEovRxG2DcvS1XmO5DRdmUu7dQx7vjx+X4xV/+ZXzpS7+B/8N/87fw8PjIiIWLVgqWpx1pMAvMoHxPVbeLSAwPnJas6ndLUp6dss8yKWMj1FNHbqo8eW51Gc9pCDtQ/YzcHOMykDkwp+OTk2v8tQUuxw1jfIh4+COcDw+4fvf7uH30CW4fJc6YOJON2JCG8cT95zA8JA2Q2zHogDySdMqmU9wb3GVkbP74Br/78RbAvftYyQlID7z93R9ou2zGzltHKdaXkYwX3136KPtPe3kTJdM/xXhZJ99+lhxvI6b0h/5+eR+5rr/bPKXqy7C4Q16m25EuuX+8xFsCqz5QAnZQWBsYJTjGAR+PsDyQ33capHNiHoHwwJsbdfQnabi+OXBeHc/zwC0GbufAmaTz1S1BxUwMxWaRg8kgRx+jGkPdue46hbsE9aGIhq3me0WdOi4XGhy+aFKXgxSri3I1np6f8N/9nf8nPvzwwx80cT82x+dq2NeWtBYwKUMm0EBBw/Kl/FwkcKo0KoAGVr61GK+1n7OaVZX3m6vXjclqRaUClpNaOF3JcXwxRTWy5HXLUerbZuhN28YIR8IEroVlIRncN7/TjXrfArCMNi7YxVqbMaHSo7roNEwokmLB+95oGR2Bwdoww5YREALi9KYe7MRetAtjxChgzP0oWSNg1iJUmAjG5GZASXyoyhD8zuUAq2GU0ZRg2DxqIwMG3ypLSeSnvNMIrYUDZbJFGVVzqt/J20ssPWkwyVDNYTA7mIdxusqTirK0aRlXkiHqpW5HurKGaAgkr134LcF5LcNyK0eM8mBPeebnph3MADt6XJcRg3YKenWzrnUCLsaA4cyE8tVJFQCBJ5dlLllduRg7vzDk7RdgLzpQrZlFNaro1aeK/h6AvMRaR+BzE+fLwHAlq88C+akiBImdUqdFwfLI8ly28dWds4YowgL24U0Z9mFwcXJ75OoEnUuCrp7GJ7BO+7KqGnWijage+80Am5mY7aHlGHky+jCmnH29lpjsamOjRel+S5gktBZqkUXSGNMeQNCQWpUvarG8AAg1h84KQSrkfUdbfXf8+B1PT08AEr//b/8tvvzlL+MrX/kKV48H2DgMi35sAHxovQG1EcZglMJjdml2C+UYWnZD0trLy33Ac5ThjHSWs1X/AFascqSdC4bmRM5nzOvHMHvC9c0TbtdbN6FjpUM2t4tTAFuAu69awE8eZ0uT0S3Zbfcb/E622QtQXSJk++SdvAY6Elvf2TXxvVbez983fnf0de6x+zJa7oyMvPvW/bFk6v1HXnynjJUNn/W86f1CT59+t/faoU4H2It37MWnS4m+PGNRWtcJ6SRS0z9nRSeHY4AVnWA0WjMG5qz+RQFWFMzu6zXSMM1F/XVmCzbzBEtf1CyY8jut7h5yepf41v8UuXBFL2AOOyoRXB2+1Zxy+Ojoxv5vDOtcju9+77t4//vfxwcffoDn5+dPmdsfr+PzNexD0RWKHuGKRjBp00AFPdt7aRu9pxR3LfnqCAaFaNeVGrUDKGRckQsqciK5WjwJVq7h1yWkUNa4KCTIVc1CyVGLt1jPs4H98ipuwICbx1HVYBC1kNlps+3/ucC/Af08MRxpovko6mJzUWd2eWEGdVCt65IqxWo0A1UFh1U/s42vDhHVDdYul3yvBmwtTJSM6ocqcQGosqg2sXjp0kzhBNzGMBWbxMEkFEQPaS/sQoQ9d5akPjW61CBVeFzRjOaxJxOP3Y1G6yml4KCCNC2lYWuZ1WMDrDcPefeRDcQ5o9s8WT0HDVv231BlNK3BhtTBcqQ2qMxX/zd6FYs+la5B7yiLk54AJlBaxDIAS5HrubrLLWSUwZGHIQ6D3bR2g6syrArRLt2VsC4ZnKd1FKb6vZjAxA2xmnzBliE5jV4nBCyCxmNqvsCLkVWWKxchshz7LK88uH/cEnYmhjkyRzdNbEbQNm+pNR8jaWQqxLlwvXpmFJ0JKSWhOdTc++740HqeVmt/VS8zPUx1GIfLoO9bEze9Pj9rvoAu7XaqJLckUR7LoHBoHOoERTlLdO8hOvlWZA+RLOZpWkPuyLruu+PH8nh6esZ///f+Pv6jn/kZ/Nd/82+iIBLMkO6kmFpgyrhNS+7fCMBOwA9YGLuBR+ICVSBU3x0aC5NV2zLhdm56iRZMxgWZB47LK/jFcbw2kelNlNcJxwTmiXj+GM/fe8LNDbcP32DOG65GL7WfQI4rMg1TxVXS1C/JRKuyxHHIoYKEXUnH5S1RyFShi5Ely7nPFlBG6/W7KEFtbmyf2d7ajx/0+o64f7Aj5/5omXd3QsOnnP3ta32m7W/3wQxdaOWN6WRNm97NhhcDgn3MrP9bKGc726ff2vaGbfr14eI4DsPjwYjDnI70A4kL5rzg9AO304AjEQ/qOeWB10fgchl4dTg+ngNPAUwbgA9cLnRAxoyFzRTlJi3L3ooSuRHflaHiYzXhq7K19jAwjL0xjoMN+A5Vk2KxBDbjG+oMfpTxMRz/7J//Cn73x5wutR+f3dDo9anKAQItMyggLA5UcxyCn8KQArkF7pJ4xZrroderitJuCW/ec24UxUrGxqdLAo9Zwg6Ai/JRwKcM3PLaEMux8pIo5ygEyiiEqFTdoyHbcRG6IX7F2uAKC0yd14oHbushhJmVl+sygAhkXIIWgp0FGhke1xc7+qF7MIKRIcFCe8/63lBnkgHQdP0WOpuwoePgrn8DH1O0HxeFIxd3NkEBPyy3CI7moP+G8ngkqILUOQACUIFqENXJfMLlbUAlQaGHxm+sdVF0FCbQLqDGdWpl0yzvtZYca87zXGau+xVtKx05Cd6bipMJ91LgC8xqaNWRt4Qp+n3aegYMWzjTUyZHrS3+bFEfQA5yrleVGZ4jhrF3yEztCa79qDwSZcgnjMaz8gjoRNQ5rbqpp8C3dxSLy0prWpES3p3LvtD6qp4uqfEvhaJSX7XWav1UJHNoLu7yg+peSr4411GkIVLrW1eu7Zhgr7vi3tY19qTseh0yuEr7nnOt81Gf0PzHNqYl5wAgh2MuDhps0+RpQBzYolBai7kXzNgS4LPKi9JIM/Hj3ZjvlEFDJ2q49cD5UlO+O34sj+9897v4xV/6JWQmfAz85b/0l/Hq8dWdY92CfXPogDBY9SeC+mJMlTgPGuGVpxST+75keHHVKU8MEdzs7icTYkFuul0MfgMdPic35UzDnAeQhmcfiJy4uSGPg9SU8UCjAhMRgZiBaScyJx1ZARypRpalFBUVzc4D1b4DWt62Hkm0DjZ8miVAAVIvtZPGxKooGLLBEUj0l5jpLbkZG43od8ZEfewu+mHrC/YC96xPfDqK/wHWUOXjlHOmHvutr5a+sH3RWFtC67rSgbLcSg53Xpl04/1D2v09l/w2hw3H5cHxcDi+OFj58HlS/zB/JzBz4nYM2CNgr63Luz8+Aq8O4AuvQPx3GN58aIjTyLAz4aW0Zn+YgT0srGi3mo/WKTQuzB3jol5GxoiFKdfCx8ChBO/h3sbEoQhHla99fnrCr/yzX0cmMc13f4wTvz/t+FyGBhCqrCOgY6kNJRs3ScCpsFkCpGA0itECha0FqYVaJSkbOOiT2ZvY2IQIFU7dNmLWDYqBnfTWAlCDN2+vLVAAhUnJ9PjMBVLK5V0gYTuihIEBVeuffHomjiJMCdSUjFmSSrfnlQsgjw2FI8kZ6xnq9Tp35cJYOyDcmCeSjbTWnTJXxBZ/nBemV1o7rGpKVzJwSVSOnS0hDSLtokx1EqEV0IwGadCwZdXRQ3Hjc/Heq0QTamEQ1hmLwcPuhF1JbP0IKN8BSwPUZIwVwSqFmobmS1Hg8KMOdLNdb7qAxrkoZu6rbGwv4mBIFb7GOyu2l6geMxYVR6uIntHzNhWRq+eqSJBbP2YZ8BC1ru6rjEHIOZml2TQMpmhfVlhrXxMFkLM8W/JYJiMzFUbufVhLxkQXM6PxrEWcxkjDzufpNRAVKUg1N+QJqyFfqJkYgbf3PFbZShvQeNgWeaoxsTZ2YWAX+ommafJR6wnLwLGewxqOZtQtwVHaUwn6WjMyN9x8AZsiS5v2hxodkrKVLeZCc7+usUy22o9lfKDoUcoXqm4oytagzAi0cfLu+PE+PvjgA/zqr7FE5uVywc/8hb+Ax4cHDK/C6RC9kg43yiEKvAAwxD8PA6O2MDoLItiPEkVVEoe+nCSxaMnuE26JkfQE25EYMxmJE2Uy4IgciHBMp67NcMThsDxoaIA6JDIQ84aZJ818dRF30bDDXJ4myUKgnrT1dkrvU2TUZ0p2LJXRu2ijXi3XnIDoNt5LVOyv5vb++s7+7c2/tn2r7nk/Njn0Kcf2JG9f/u4ricI/spj65fus1vpqRX5Kj+S6lZaLy6La76N0QRUm2E9ceaOlyutqpEs5jsvAw8Xxyli+fsIxEzgtkTlFt0/4BfBHxzi5Bi4H8PCQeO/RcHXDzQ1jVJ7F6uvKEpR6Ar8vV0vMqkgHqDtsqya1cjecBoqSuo/jECWK/V9IkxKNahBDPj29wb/4zd/E7bx96jz+uB+fPUfDsj2IxcuOwl29sAvJ80etvxdYeNsgmwQoyCeQ4XqvIwl9hV3Q3G+IigS4knSp17MBflTUwEwNzZSQXHi7DCckkyNqixa+2fbwvsdgxUWn4B3yEnXRHN31yBIF/HIZLkW3r0ELgep9IMPKACA1p3paFLjehdjA6qiQ/WzWj1YbMff718lYzXB5eisaE9v56kRhhf9X/gqVh5qv6Ry75ye3x1ogrLwom7BrWp11RQneV96tr1pCq2FkXSf7MwTOCpWKduXKxah7ZvShEpVlyGYZrlhgdVM4/T2rs6y1mALYlQxehq8J6Ce2gbA1JD1ebveGRhrzYaIEKaN5lXvUOUP5YlzQZiqNDI1593+RoO6GdQZ5NdeJZEJxrTqUB7Qp79Aa3/IgRi45kcbATDX8WuO0T6R+OupqTTgDRKkABzyhaIRzPHZFWmkS0H68WxeKkKTz+So5v8rp1jrazIJFdVC0K/rurJtm1lh7TSA2hZzoEEqmdS/CLWsKbfxFPW/JDd7P6FffHe+OdZznib//D/4BvvH1r+N/91/9V/DhYNPuir46qYinGLXhSHd4TFTjybBAKPfLRoU0BszYsM8v7DZ+PgO324mYE7AbAoZbAjZJP2G6YMIfA8cALmNgPjxgHgPn0zPiDMzTgHEg8YgxXsMtccQNJwK3eOJnIjHb+DacNsSO0H5JJenBGClGIicbsEYZFijJ0sj5Tzjeft/WLlx+uCUeN/21vr5Dmqbwbvjl5RV3ubHrjc98lMDzly8u2ZOf8vH+z50exjZUJfsIXj4lQEGnmpUjlHqi+oDZdq3Caj5ASpKxy/x0x/VLhjzlfDoBPwPx6oZ5JK6vOJ/+MR1Xpyc++kLg9soxvwF89C3Dm48M12fD7TScasxrwldOwLTduyS2vEwmQ4LGBCNsx3FhI0mDaFQGHxdFNA4cByuqHYPfZySD9PGf/4Wfx7e//a13RsafcHx2Q6M2lBApPSVKejzpbUhEK+RuNFYe7MQCbQDuPJSAQOQSD71ABFBcwqedwnUUMjPIwwl0lSqjp9dtRQOyAbfSnwfQnU+VfIQEvdCxPXQh5DByXyvTWyC4+PXd+bpBjLcnvnpgEDNykxb9BK5KWKFqOCBQKu97eaQLfFFpAHtpz0JaDt2iiVbWXb/R6HinULVgdet8FeYYzD5nAncljpHobtZpzNgwE00HfJbyKAAmgjxQ3Kuu7tRgs7qEYiVrw5R7saR9R4J0js51icaoXGeKcXMNoKt8eSyTiI4/KauyDOVot+C1aKQYTJUFaOh5UYdpJHGRAlpvla+SU++VgaBqSBBtr/MMbIllduzm+Tt3wkzXTgKEZAUrS8dAwgY7a+cU6G6Bn0CPEQSUl2ENK3qj1qu2gjmAc9GerKg/kAF9Y3Mlqw7cxvViohu2UWLL4AsigaZltJJN4wZYqLt/tRp3Aws7JJePBeCzPK/idtf9GRO9uwpaKRnJgeFgT5nJ+al8JYet/xnnqCNMGT3u2hqyJ7INsvo+/68oVqXnVPqG1iZzjLKNtC63XWPZ7sC1/u48mu+Odwco/95//32MMfCd734XX3jvPbx6/arXqUM6aKDzqYp+OEDdU965zHpPFJIxYGYYQ3LVSU3ZnQIzocio9pAZO38PZ37FK4MdjrhR/oeM/zQj7cQSF63rQOLWpzYVJ7mLa/f+LG96DlKQ2VN0NYBbAL4hPRL7G7QA7rC93e+vVfo++/p3hkEpoULWdvfrUmtruHZ20gq67Dv7U7e4vf1WnXs3cur+JVvXuN2bHG9da5O7+zM2Fmsdtd60wlxFCdjoViuiksj2lug9I07JNMzWn9ttJJ2Uc3LUM6hLcziuZwDnhJ+O55vjejOcwWjY3RopnHAXyVhrhpiK9PYqTesmCpQBwwx+EMd19MIHhoOlm70iHo43bz7BJ2+e8L3vfRfvv//+p03eu0PHZ++jUf+p9tFgZ3CcBGjssAtO6L6ysIQcwW7WisNdqU3tDi4a0R/SqHwDwKHOzGUIlADIQSBv+l4KPK/L9D3wKrY9kypfmMMy7ptER4ViF9870tkISYDXxgICdXbISi8gb0naVkjIl0FAYJ+ycYraxLuqXJK6GTfrkq8s1+tLQfTkrOPUc9c9BLZO0ACKFgJshl/y3isZN10ANVMJsJorMEJUM1AJ9jXXDHcDPgjsIpWoJRBKvDl1f1XViOOdot7gRq9B1uq8E+YGWKxa8bV0zDB1L6H77JYmseg0qe566YocQUVGLYAjRP0SsG9lUVQ38peYNuPkj9YEdCRDYi+yE4ezDBhfa4/0OaxIiUmoR6meIYO4zMCU8UFQe2DAite/lZKtRkRiItKAcvLoUuGoqP4RKLOJi8Bke/OeJZz7mWqtmaIqW6RGYNs8YQfPkQphF4ixSjqw2p/yOPnKPSpDuq2NTX5YpCqW1FiNnqclP1SXHVDVp03LgVTDExpzT9hBlF8AYGIQZMmA6WZhg4vX0lXxN9XjpLHIAhiJzgWqqGdVrrMyKGrPHaIVaghrvkcZONq/553X8t3x7rg/vve97+H/8d/+t/jPf+7n8Nf+85+DGXtWsA8Mq5eVzMwR8GBcLtIxwSRwy8TISc66OQ6V9hwxcVrCWUaOfPpzsHFgcB+5aKUDhgc4jocDr74w4F8znI+JeE7MayCeJivcXQLHo+FiwKsnOukiCPTmYKO+GYmbrPBqBktxosZqhyMeVXr9zcn8kltsTUyxNmd/G/3TpL9si+S+UKM8xWY53NsB5bxccB5YOqO+u+P4tktKlW7fq8985mN/pHqmogfdYZw/6XsvbjzyLgJ8zx7hPBmsQhRSNNt7mXCwVHIVGYBBziuRXCMQt8Tt+waEsVCJOfziyBiIZ8f1+1xTjhvsMeHHifxwYjw5Pvlw4PrJwO3Z8BxPLGdSUegFOXmnhVVHOWUX/WkcAzYMh19YrnZcZEwAfoEKjBykTvmBizt8gN8zg9uB3/7t38I//ZVfQcTGI353fOrxOcrbuhRqoa9sSgDXYWnDReJJAZ48V3IoYBjim/d3736hxq3qGazKtzjwyHWd/u/CwFhFj6yNGwKbijhgAddgIieGKtmEkXdaVCKzuwQull4FqumYwZlgu9/PCUx5MQk8ovEQ3JWaQIOojAVGQBzVRTyhoj81Mpao1IeJ6hTNS1bVUAM3Lg7R+WuaKk+hKuT0HOl+aVn0FKStKAUSqkRlqAYh5tUUUJhUloIc+hiRwGAHgeoBcjrH5EA5d8ddN28CLeMSu7BL6LKFsgFraQML9uKoCk4sGYtOrm2gCiZ8lx1QXvx0IC7APIkhh+YwMJglJKTYWQ0OJvjPos/If+1s1MjmWTUp29pRVSoulsXvBxQNlGHQ86KSvtiigIsaReLTTIcjoJx6rod6NgcGgrhYEcMUBaupUVAkJ0klHMmKS8bGKby9GusXCitVcY3jqbWgZoVQJ+J2VR31YNYGWi+yOuG0u6RzbJ+oK5d9woIAixLQ37nX/uwn4MoBQUUsVp+TMtR8Fn2ylhXX0EB2IzI4DcpUBLejfZZtfBVPIrNyuAQ87vjkUrKKbLJctwOnS65xfaSzzrQN6/LAJ1it93jxnO+Od8d+RAS++c1v4p//6sDP/MzP4PV77zE67iv3LJHqt2FIT8whcAo6AxzUs2aONO+9F5ZImwJyAmpmOAqdZ8gZ47BDHZN9AM8G3BJxLeAZpI2eQN7A4hbDuLgP5ZhkwmciM+AsE4fSrWW8mzNpF3kweq4EtnRbjf7qC3Vs+/wOPi8LhiMU9bn6jMibdn/KxKZTOIA/0GrYxP5STVuOXf2y0kZsff7lg3z6r/tVtjndL9ya6e6bd7kkDSrWOfp8W0SgG9gdNEppZFDRut0w50SclFt9Z6LEI4Ny91ze1FWsg4DIbqA+Gie47Bx+BcY0HKdj3gxxAh5XZMyNsUCnG9kyldw9mEdkKj1ryr0Yirw5+2KMY5A25fWPUTfv0rYOZOBf/svfxvV6hZnjm9/85jsj4zMen9nQmIPIOeVpUz0ILl4f2KkllcA4QYDJNSh6EYA0Nf2iC0/rzVUlZ6LKlxaoWIfgfUIhOHHzaocWkmgru3zBtUnQeQlJOaW9VZ8iJBiSLIlNeMi4GIUXTc+Tot2ovFUM4VRdjE8cgLMCR+Gx4iNZrHvOAjC5UaQ03nBsIE+yUa9RzPrKtc6N9YXcjEJ+IHpUdTIndE49f2rw041RDnku6DBZ1XQGGGpcnqMQvYpwLVgiCT7kbQjAkmXthlVEKu8FougmBrC60pk4HwJxDDYRVDkzz2QUA6YcgTqXvHc1HutJISRJXv+txlf0tYoSFXeoojewtRBlTXiXELaeGwwwGqToSQLANL2lsUF5fowmjcVar5UIMqhIc5JisKqaJhJTNCiXQSQlWNEBC5g4zFlEYQMQK1G07Mah77kNWJWabkXT2nABeoW8mdc0YSNgQ674ADe5OXKqrJNoTx7OMr528qJFJyo6HqQcUMoMDdxRORBAj0XtK7OUB65YmkV50txYCBxonyWrjzjACMONi8wO5eXsoU/lwdCkpgI0i2p6wrvekUDRxmX5mwXMDvEXse222tWAYcK7gY9uShEoLxpg5QpJJrw73h1/0vEHf/iH+MNvfhNf//o38MUvfhEA4JE0GjwQUGM/CQCDYSrclhUShQM2EGWQGOksRbk0M4yD0daR6vadwGmklNg4WInKHfgYLJd7TcQZiBEsHX4m4gqW6350RJTRTSrWuIH6J9QBvauQADB1c/YByyFf50TKWx3bNmm6zwamN3Ha2Lyj6gk6ExOf8p09oiEg37mJseef3x2UuY181g28MET2W+rXO9nj7s7XV229WtUTl4GQHVG9+8J+hrvxKZm9Lnn3xDXuMjTGGDguBwYGBhzsCsXzngDOiC77XrkTVIPCWlc+m1+Ea7RmTIYGjiAN90xYOMYIHKfh4bny8BJjXql0vbCF6PgyXNjNu7p3Mx7DqlKHErplaNTnjI7t7laucrfHMTDMcLsFfvXXfg0ffPAB3h2f7/jshoYQegGPLqdfi7P/OQ0QRwuhZb3TXbDb1YnlcXUZETgBXPQVKNFaAIUe3kVbCFfUQ30PFh9PGCsrYZmLvaj4E9lAdN+LbhSgCZasLdABU4WNGzbPw/bfhAwf3S+2cO9UtAKx8db53ba3tvuwbUwFxZqWBgf8RDdcmqhynCyrZinv/hYBcBCNWQJRgrTEp4nmNGW8VTQHxjKvZyIe0GNFHqyhZHNFf0LzIcdCPwfMoKqr3bukAmEJlcYtgNkGHjqKU0ZVRK7rA6hGazEcE2g6F2Ig0xD6rm+AsbF3guDQub66NUKuZpMN4Pd5MJlXm76oqJSsPVSeAIC7UrZJS3EpHXld1khwn7ilSvIO9iwxoCwxAxM0YSp7DDQP1otjrdydDaF3g8bUuNHeZJO6lVCtCECFUAKABZnPFa7p70L5Pk5DWeOQXtWS1sHon/JHTItE+RNpiekgpSxkhFVOh2WZeXBUAr3OCUUlTN+928dFdhya9WgFvgX0ZCf6MqRsGTWokslJ4MLcKutgam2fMuasavBmACXHjEHAnGhjI2Vcp8bcrM+24SiDTebduDFHK9bH3h3vjj/xyEz80i//Mh4fHpBI/C/+/E/jr/6l/5S2sGRimGkPGx0Bbl2gIoMlQpHO19LYTDeMDid3PIyBAeAxE7cAzkpaMsBzws8Je7McL+c5McMw5wOjxpaI2xVzAvO8IucNOGfv0UGyPHBxRB6ieJF/68p3c0/AT8r0k4ZI6hnbcbWD+R3F77IRpW8p3yt3kP2Usj7WoNte7EPKAsrHbDm9f2jpkNy/c/fLflOf/1gUYpOeT+mat4XGfpUeEv0n3/qEvqN5t8EIxng4cDw4Xr0eeJiGI1RCXmWKFf9tJkfr/mPAXg3YYbAL5ADiOgwz+EX9Kw6VTR4OywupfHnBZRgeXxlikkHhD2+Q56k+UbFOaACqx8UYnVtB/WKdQ3QMx2Ws6Ew5qw6VxD2UDD7GgV/91V/F7/3+v8EnH3/87zxPP87H52jYt+gCBs1nZ52arGvr16rHJ1FnfsrukvdE27ANcbeFWttDuQwc5mHkArUKDReYErbl7wUIA+2A7jyOvk/eYzXtXV1IV/hy3foCofWfNjXSOuy6GxkdDgS97cW9XtKHIij7Ouu6LQSaG7NoaaixfSlMkmNYtLVCRfs5+0y2f19ifmWp8Tm8ElfLwMi7z/QdbaHWvhEDn13JxGWw8fNKikUx8yuElX3PnE/dcbmZgvdobgKiTFhk9mAvIq4/Yzi9PPpAeXly3bnZGtMejkZ95T4h+KxI2U6h0XdSlLj2yAMatxov62cv5ZRC9FkXrkiC8irMpQCJUmF2qFwztnvVUPcEbwrGlAdVlapyXdsA5RZJOZp12Jn3EqRLSG1Yz1v/B62cBJizEv1hvc7bNus1Y2uMeRPr9RqTotT13O/UKx4RMjnLsVBmRqOMgVSooRW/FRDJnssaQFdSYeWrtFmSS2YAZYiX91d5KmPJKcjQoXGQa93u20PPnSWcUJLEtg7Ntg3TS374u+Pd8YOP73xn1fB/PB7x0U9/hIfXDxjHgXT154G3WApu0BUFD3T0vNR3bR6zAR8HDgMumcgZyJntcDJozZ98nZXdQqKtSoiCAjMS7JvBSEdtkhILqQIMlta0TpuKImTRZGkUrGQ3LN1ZGrVEwiZqCvlXlL7Vod3Li/3n4kjg7o1dZTR8X6LlTvfmi+/a+vV+j79tI9x9k9fcv6how3bh/q2eDSXe7f5k2KRZjQdywRQzRle9CgWsf81qmIUPScFzyf6lLspYOWCHIsSRsBsnwcpIOhz2SMoTo1YHPAfcL+wm/mrArw47ARuTzsG4oZtaoSgnFclwJXUDZWjYwdK49c8VUWEUhK5yN1Kn5px48+YJ3/7Ot/GH3/zmD56Ud8efeHxmQ8PFdeaGVMJvgWQAm338/23vTZsty47rsJW5z31VXd0gQAMCR3OQSDnssGhZpMMh0rIlSrbCIdsR/q9ymAraGkEDJCiCE2iQIhog0Rh6bvRQVe/dszP9Ya3MfV4DclQTDYAgz+7o7qr37j3DHtfKXJnJOToMZoGRuQ5d/fpowbdcIAZQkO52+B2E94xkoa2hBRYStJamgJ1AzzHY6mhB7z2zsiJBlosD3l6SCZOlFYwDKNzQILVvR4AwtZ5QEKzApQLPmkqsVW91td6b1p/57npPYZva1HofsvV+hVGzATXQjAz13CUHWqApp8CRHcANURdsE9ko6442466TgAKEa1NvS23dfw32Mj1jfcb6umXBx73WQfqGBSSF3zwNvhX0O/YdrfVdlwHrWDBovORJcV0vAM4Fw5qThiXzMYXDmUZUgLjCXFzXK+9JheJnDqy64hqjA8A+4u6OmXZg87Kq1TvIMzbzAADqMnzDqD5E9jpbC255W2rlWjOF9W/JlhC59LN9YOqmUf1dRxsDSs3We1oxb82jetca65JHWpGGPu2Px7DWjq91w3TH3jVratxbUtVTZB34PX98cUfOc2vXfvVJ15fJenXWByjZVpNl7V1u0sG3Fl4e2kgMGTmiHzGXtBIVQ6Ipr/Ux+x01x9X/ZzvbB21/9tKf42vf+Br+wa/8Cn7mp39KCr3k/J4OzIRjgMlQBhKqsTNCKkLXeWLw2JDYsG032IZhbBPbDMQ+sd0p/iImwiauuSNAADhAoIcHN9zHMuHbLSwD+fQOEVdE7phBSWjXpCpgaIBvhnbjigHlHWt2ZSxpVYHbb8MH3ofkdaWyTNZ+HFheWAHn3mfzsAesHzW4r//m0Sjybe5pxz+8//f198C3+eVqfu9v2q/C217HZ1sGT1PMqOXaA+81nQNl3Kkiqj6SAP/CeAUzpakNx7wbuPPE9ERcSRYDyQyIkjM5oCQeBseG4Q8ou3q4I+dEPr7Sox4O3xzjwcDloxd4DPi+YcwbDNswnnsAf2EgPzEQb2zAOyIldgsbqiBuCQtKAS1Gey4uF6lR6rwaTFM73HEReWoPynCMHJRYjQ1f+epX8Ru/8Slcr2fq2u+kPTPRGFlnr9F9Bk7C1lA2SJBlX2jVBVhCjGHFSlhbgYdAR0QFVB4OWenPywIY4GGc6cszEWLtrvu26VaLZQOqCFZJgyjFJ4BeFg8ukAnKVCyShdaQjDOxRNj6/MoipGeCwAeWvIg9Fg0Yac1ZQBlgQByBUAEYLGJe3hCgA93vYXfoOQREY+jL0izS8q++F0aqxEoAFKfrDJq27KJMxHtk+cy0cwhmzgNgFOFwW4ANAODZgJVDkZ1dh38V6qs9O6KzTPHHAtMjBbb0u1F9Z0AGfF8BzFMehLKolCvcUoUgDe20qbgGN9YpAJiD7FrelwpuHFAVc5EcX3OY78H5zQh26wMgkKp9wr5tx15yDkWClvBA6ZCwqAmDHb3yHCMBC87VeXTeqC+8+pjxJV3buk+ThtCL0JXGDVliR6yA8eqs0de0OqUsdeBnEw0eTBXMWbKnbFZlFcOieI4OB4FIRhiL3qE8EsWqFzkpQkjuYgxkxVJL9qMHYF55+AX7eztIgqvhyKEECVjyNirglHqxNL/OyRVFIazW0IEKaQ6kjAIBhqdeQp+rIHAOozLjlFylyEYuiZuB+m95EV1z4mxn+6AtInB7d4evff1riAz8xE/8JMYY3BuDxNwdiOz0CWvvzYRlnSnMNJQpK3AFy8JJVGL2fhXiMOnEBj6N50QC9GoM5M0FiInYd8Q1EPNOJ+Uy8vVaa2hB7PF+mMzjnhtAY3edrbWr3vNqHJJtoH5f68sMXTHbjzfQXiFDQ64v62t1g4NBBWufqw+uvx98IyIv92wJtowf39KqPw4XzP6v3f+M4itdWXC85JsJepoAIGLhj+r3ozxaKISZmMrQxmNgam+NnX0UaFvwwjO6vw+mjvWNxtGsWma6oGkUPChfd2fV74FkVsgJxC0YNxqG8mJ0cV1AcivQ8+Ks5l1B4Ea3BpNtDKekykgqzBTYbpzPc9/x53/+FXz9G1/H7e3ttxuFs32A9gGkU/V/Tr80w8wp4JgIiz5AC8gBgAcnSY6FCOJQPTp8qo6E0R3GH3ORyVKIKfDp3BQHyrihnaPkBpMad1gVJLNF41GTW7eOw9Js4FPgdgF3jGiXclsILDvrT8FSC2CrBXNYqJDW0/tGtiy5ZsxQJfC+NsnsmBS+7LK8V7GxHhQt0IQqGCu4r/hMaMyGdr52CJRHyB3YZAVXers0YKp+BT1XAcPUvrFKz1UHulkJbHo+EK3xz+4kcCq7DMg1mYd/5qbxSNMGT+A2RX4a1imuokgqnJtkqk4FKnA2XZmQrcet4n26o00HW/KvM+gtwNDGW6Sr5gkYK5L6XYoR2wA2Bz0XMpebBV3KmwZ7JutpiAjVQU59qevsq0Eqlat1P5S1u/wUw0zF89DPwxTChmFDOt1cnMy0fsQvQqTFt5rFXKsJrDgNjHbHW5OMeZADLekjJXJ6ENNis+5m9p/G1TWWniyQhM1ETLlAO/gzirQfwIOsj/cqgmtqqJixfsJ1EDh4TvZaECKKQ31kwAxgHvQFJnJoWlJec1nTqzxoVt2geeiaww4ZLYJ/T+1DttUeKqCHbDlcVHfi4JFEovJgne1sf9H2R1/4Y7z45T/D//6//ihunn/AXdcDzDYF1CZIshzoZCtg9kd3gyVLwY7B889t0Aq9GYbtiD2Qd46widgm4rIBVslhEiMSYzyAjQfYHz5CRGC/BgPGb+8wHSqqu4yLtkGW6tpEhtZ46Mwr4CwLBhaEb+Bem6CBhjfahPiLOtu1ifAfJraw8uYgkDG59xk/XKdXk5K+D+6ds6vZwUgoHJAH7/G9J7YjZ8H7roK6xDqCRadsSbuEvvge2wbHhXv5AIPs9wCB1X3vi1UmskwdOYYBZ7J1dxlYRCpmaM9O4E77t3O/i4qolArA3TEuhvEgMG4Af5yM407HlDHGjSRjewqMDdiGYVP6ZM8ddmeIN3bkrQM7YH4Hw95HPozZLitRz2aOiw9sxvuzKIwBAwwEH4YBZp1ybCIZHPent0/x6U//P3h6+/Q/uqbO9uztg1UGl+G1fBgAegHDF5NNADmAywUcuH207nOmLI2SqGQa5kwgskvJd77mApZa3BDWoUfFCpMtSVXLPFcRrwoCR8MbbkT3rKpZAAGUSCFYI4TR0yCRWhKxEYZtEDIx1tO5rCz4AhMrzV7p7Auw6e0cBJ2VQcH2OFhKC2xDGW1ygaMmNslrl6t0EjxW1iusLkNo0xgC4mUBKk6QukX332CQ7gzgBkU2VJ/Y2Z8zRQoGgItw5Y4uNshdixYgmwSAixvKw6BsHXXrGdRHmlzhAZE+EViayvRuoMeggGhle7LBPmzviTBn9rcAXJazu/T0rUPeshlayz4P/YlM1h6sQwKGS/Jru01umrlS+da0BApouzI+seLpvGAF2ieLK/K9hgj7Osh6Smm+odaauic3YBvMLFNYvTJEzj44+CA5mDr1BjpYVA08BH4DYGA65FVU9zDtZUpeUPBbO0LXuOEDtVVME2wm+juixu0ZYmdSCoFE1wXREroXy1E0o+199Xndtx6Ww5NdAdwzDyMOkVVT3RU5l5CsnJyrhB/AwVQJFlS8yb4mexMq6H1DZtg5SlLFX9TYIyEir/mAFBetSWcob1Ev1LOd7Tto17srPv2bn2GsBhI/+zd/Dj/+4z9JC3ES8KO8csFFFbnBk9XDTfJAd8qOcdmooY8NY7vCfGJIMu0WuCIwMzGxAwjAJ3DzALg8jw0fQ+bEdnmKMa9wxd5NADFJciIAmzLMlNFnKLuVQ8HmgVkqggLaZeysk6gMgG1xEVh2AO3tPhhMnBWsmZEmgXGFTYNNpm/PTFzBwqC7PLDNB7Tf1l7Q/0/IQJKwQRCe4cLsjEErpcf/f6v9bZGTkvkOnoAscwGdK9uAbxdsNw8x3LGNwH5N3N4mbu+u2HdllumzHd0fNHbQGGdhzPhoJieJzoAplL/JM5ty8Bto+EyXx57kIJ4GYibmHZQ7w5h9L3RmzcR+a6zDdAGoeAlg7n3+llLO4rpwmsZvyOsyjEHgQ6lrTfEhJK+HgG8jwRg28JWvvoQvfulFAIZ9v+LuevfBF9nZvm17dqJRAcnFsiswAAR1CDLSKtwXAHA1JAZyeC8OWvECGJO6vTTFelBjx1oTfi+4G5rUrrKmMQp0GkUNJmkTwEJqcqPBAxYBT0diYNWQzPUOtbKSGxEZPVFze2HKSCsrJQyskgpJGxRVZwbqDvcCFtwUBgBX0HqlJmU3ptyWzKEfBxpSG1SUxcDKxSgLu4mw6RGtvAaSdqVIGYpsmaRuEbT+QzIuvTugzSW52Edm3y8disngQ1UcQ6PPWYbiVHrAKsSXAryC+caCTMSksgkb7+th8J26S4wilSonVzIrOErXYp60UiQDv9v741YOjQPh6wFWp9AyZzvHp+W5ZsjNquQtzSuT7l1MwGciWKQCMAZAwhivsgNITHT8Cwx7LjczTMUA4YjprJxuRfeyJToWwIaBNMp7MlhIErpWjd0Kf+DhEmQEi1D5qi2Sk1nF+CwGuK/nNENUeWpZM5HBswG8X+gwK6BhwUkdnUq6JhwBekovnKjg5nXgG0xz/kAyYGIKu0D4Ag44kG4uMwaHbsqY45m0oIKHtGsdo0EHOmalKG3FI2FwDzERpSqeyftVyt8yC0gOpj5jAcyJNKbWTKxsXwZglBcWq4+awiW3L+6EcucbM2vBD7uDurWsqmc723fSZkx8+c//rP/+0Y/9MP7GJz9Ji65xH10ypAAOtZ0s246wKi6707qBC3yQfIyNRjoPipWZ8AOAqc63b7Bxgc0HAAI2LsC2IS+OKXnVnvLOIvueVVjPnSSD1u/Umcn9ts+vJhnLQML/63NFC/RL0zvp0OKa9wGmnk7AmYraQSkPsDzJbQg62AHWPRdpWDhG8iM40gb7R+mxO9051m71LUaGPrPZH/a+H1eKezcaQ8fmGJeBm4cXjG3ggU3cDXbwvoeMLDuObRnXVi8W0WxpuPBExU+mpNI5+RChc4L7nzbGNNZUS2DO6kBHZ3vMOm94/VnEzIgFkMQNWSlyWW5ydTiqmvexZgazZXmN6WDWqeqj/ToBTEwLvP7G6/jii1/8NivnbN9pe/bK4AW4BfqLc7AKcdn+OOgr2Ix1JZaGvPTQ2SvCZQKwaSo5b8uCzTsDxiJlOSHJSvZKt6LuWpDFenvhCTdMK5EOgHpWrw1sLdn6DiDs9X4iUuCyOuawCUOZkMpCWihnaJNihfACDnyX2Cldqj7KLG8H7STLwCE3pPNe09A5derzLdwUuD7GiXjFlmQzBFTF1aaM3moSad3pkQgv4legsogUUCl9Q9tqDiDmSh0segYp4Gh9kjZT1SDWODk/XZygZUt56G8XphVsIwksCZSApbwhlsqGoo0o+zDRvwJ4hUOrPkv1UdahUGTlQEyLQNTz7ciuio6ktSuMFrCW2VnRgDpPTO+byODzMWYkMTERlaUsS+pj9/qey20B6pL4hdYA7WSpcTzMV1WkNxkPqpJ6maMqjiDrwKi5D9QpvgyD1smDOaude0W2/E257XX40/O3+rEy0vTgAkqZXWOg+SnrF0D5UgXek2jIp6J5OxSUsfTI6/AGKlWnaU2l9h+0x1YBZdwbSirAWYqS39WcFgfVy6iLZQCg+iuXXLNkBda0pb2O3dJbB95zuYHT2c724bU/+vwf4sUXv4h/+A//ET72sY/RUhyJqGJ5QQMIK4xPhJJe0ANnoDfgCh+JMXgYXy4PMebEuO7I2IGYzCx0BfAUQFyB+RjbjWP4xAVPcWcTmw+YG64AzB37pBwbk7Fp7rSsDEQTnXCZWbaEhcsAZqj0roejk03W7lRmy8wUwWLNhFrjZWgw3AJIWOzYLLAN4KbWdQKIxBW4HzLSW1t5VNFnTu1rbhs3G79w799U+NQCtmvNJxhcnUnJVmGXw/FV51QZcIbxHlVQ8cYd24OHuDx6iEcffx6XbeC5d+9w6xMeO/aYlMntDlS8Rm0zsbotZOPzOrPGBr84xsMNfg3YVPrxCMSVErOMQB98GwQuLkjfMG0Al4ClSKlfYL7BthvkGLgbg94XABgb1Sl2EZKY2u8DdlkpzMsQe7mQYFxMyUJcBEOkA25Me+t853/zqX+Lt956E4CdHozvYnt2ojFMAwqBCyEtJOxg9SsXoEtTWfpBXiQbHJU500xALpcFggtKf/ey5A7kpLU1S4PvWFIjAcYCzwCYCq/AcbtI9MsKaor7wLMfFSuo/QDNgfQVZGwFXQrEC2QVcrXacARYyjSkXjGjqLyIWwOaXOC46l+gwJc2uPpsg5g8kEAUJ7B+dpPmfVVWVx8LlHFIXCRNABgLuAO2AKEIXpb5KLn7lgUbXuPE4nwH5oTK4mVZtiV5qwCMoXDAOigEcMudD2DJ6PT8Beq68mh7W/RuB9JqBYR1ZytWdZTppCFZrhoNdDVnqjIq6mq2uq8DGLMgZFS30MW/BoLjLzZrApIVKE0Dt8A7mYKGwdY7tozR+jl7DjbZrvmkeTHWOxbrIJa1Jm9cy+WIYyzV0SqnWdAuoF4Dx4OvgqTrudfDsK5IRHvhUuNlNtXH3vNWsx99wMKaLFmmLIlJ2YE8Q600OsZayONY6ax7d0j03LNitll9qpMVpvkUst7WHqcR77Lth381H93lobDVPTVW9wwRRdBqeoRhDVbNEfBeZzvbh9hub29xvV7x8svfwH694hOf+LhiAB0VKMw4iKAMhtis1y8yKZPC3gJABtUaMwHlcjQD2odiAtcrMJ5QrpX0BZf+n6uOnkpzGX9Q9Xy01/fZzTSpLPRGb/JKbw0ctgH+X679ZcBjcLSBioOFA2pHrzMw+qzv/CVznf19+B9lwwBKslUPYdpPTdmbGIDC69OTGfXCtNw7/39w/aL30jpv2OsoD/Cq3G1MDzs2YLsAdkFiACNYW9VCmK3UEwfsteBF76n0IimOQpEbZhvPeqSeU4HY83AEgwYf2pWdpGIMOHbtzYANh/uAbxvMB3wjaer6Fz5Uw0Njnyww7GHqiVKxyJMhyVR7j5x97/Vnd7zz9tt455138NY338I77777F1tAZ3vm9sE8Gh2TmC2LKzzc2sK0dUQKQHXdAX2HFFkfbzBlbXk9zPOe5BEr0JiehVAWgbI88nA3uVwBNHCrxeO+YkvShB8kj6hUuQX6EgJJvcYLWBrSHSH5R7n2lgOmiI0IilFmNX3JXQgKRYI2Z3A86oWzX5zey3Xf6pjKPlVq9/WCCRuy0tYiSwj8Skla1vHyShnQGTM0Dqkdgmk7pR11WcfZMYfA+sPzVQqKyjAEoCwNVbAwYe3ePRaSM1dQrMjdoUP47LULNmqD4go4yAw600fKojzKu4Z7Lt8s+Gx8h0ocUKlKw9AErudibboHwFvA1RTIBtCCXcC3DDozFtGpMwmOb7GELW6XcJ8w+XxCQNk1lgNddBodI5mogtyahnxIerI417LGttYvTH11OMhUXdHM76Wdba9FkwoB/ohF+CvDScXHqO8B9nF4UhMBerQgDTY8YJvkYgcMnvI2uNB6X9NBuZfmYsq4MUxzr6mf97jzepTHVarchhYiJ/UTejnLe1FhjUAjLZRnFmtPqFlbg9EX51UrGUPA5OmSgwp83rRFrBe5Vda+45I429k+xBYR+MynP41PfOIT+N/+2T+DbwMRKiwbidi57grvVsIFszpnKbsZeMgNd3+AtB3hAcOOERMPE5TUPgAyrsDdjj2ewpCY+x12TMyLIzfu4+MpN5hLlLTTkOU6EB6gAY6KiOElSqT0aGEPoOwitPRz1U8QTwRIMNwNm6RC6hX9O2UoogFtOjqD4F5pggF8+8W59lQTySDQZk0Isw1mNzJ2hJ4+mOEr+JQWE6pQKBylu9mBXGApF0zxB35DK374hvngBnZ5iNvbR/QkDODOHNeYiHAYJSfomiS6fp3DY4BZxoYpltrgMWBxAeYDzgEZFoGAXdifacCmAdhAz9HAhnF5AL+5YMQtaIGDqslfsF0e0JOxpSp0JzYMODb4zQMSFt9hPjFnIHc+o1uU4HwRjXHwIOlnlMWzPsd/+JM/wec///nvbPGc7ZnbB4jRANJH/7mBboJuMivFQfYmxIOXhzbZqHR8FSmrzEFpAsg5lr7aRBoUKF5pbS020WTe2/ZFcMhaF2Iri3J7AyCpRfs+s70FKStHpZpsFNhsR0AKQG6B2BUwnlmQg8g5KtBcNIDMCnM/ALaywOYqaliOl7JS1M9K/uMiAxOgznAXeI+yPJWetbYfQqUCSTOcsS3JZ2owo7/zj4F28Ih4eIx7G3dmZdDi5mouggNwk9/BuyYPJQezllhQt5vOSu5en4/ine1sVr+VhV50LnTPBOTPPyC7JQFr8qu/hMYch/eyYqABZFLqlpnt4XUH5g4FmPM6Q/+3HHROlYF7qp8FZNUrYNq+RDiwXxSLFAKxIWCeYNyGgKlws8ZwKO2uSyZHi5crrmmUBMdAMgh6FgEXKdM49djgiPt7vrlJKliFHiR7IhGXVS+r6zSrimk5v2eBvvfKpKR3MZGMBObVoDzKsjixv7MK1IyD+74tp+qY8myihl3EtfK8a2SnJBHm2XFFhoSNVFYp/UygfuEBb45QHcY9QaxpJsrFZDlZa8AdsEsv/SJhK9c+H9jby6pgSVBOOUQqKxmbWS5jjvbY2g/veSLPdrYPub337rv4rd/+bVThvb/98z+Hj370owAMGYzf4D55IOlVyDV4BrDA55W1NJKxZQMGu1R174G5M5iXVcdTxoXB4POKO3NblcG5+yNsV70MAySVNETvEe4Ow9a4I2LJF2W3x2aQGsE685QNypGHFYNaRr+QkYYUgLqxnCQfM0BZKYCkxeugSkAfRGVp9/I2aP9RsW09W2ImwXpEbdS1p+u663A57FEiHHWfwg6FqyIRtzt2u4P5E4QNpN9iv71iv92ZSUvqFBKhZbhiUhCSuKG6E5QhMeW7bQHbprIp8nnbCJPAgLcXaFiyQveDge2jDn/oGO8OhsHtAfhADsN2Yaapm+GdBndMqiLGjc4VHd1AITTDppjDkQbfFMPjKuYLptWdc+IP/+j/xd3dHWAD3ziL731P27Onty0wMgAby6ORjKVB+r5OWi2Kzm9sDtt0kV0bytVoJlGUasIw03mea7NJ5ZLMDKQF3Fma3suSeYjTqMWXpVusVKclXNfPqOtngGwAuJYarIEo0EgnsYJvUWd90ogzA4mJKWuJb/XcAaYnXdWoe4MAUFWy+XwEMXT5LmlSFf0jkQIwVhB6+gJHfOciRNbcSNyu3d9wBqoawA1WXeM08VJCVMHP1REV5+Hc8w8qnkPciB4ik1YnA4Opjff0kcyEEdESIUBDMqyDZZccyoAhOY60+xnKvmSLhnTWoZxYLoJKG7s6uwzLa0zrjyR/2A8esaQ1KcvTIFkADwuxCqUa7v6bQEkFoVmSZRkrt4glhhtyevdfbaI51cd1WECSoOQ8njYoX/JgrZngphzgMiqCCWe2KL665t0qda+Dh0C2BY5ZlAhtIauDPksWVwSupGt9eOo7BjAuiROOZGrFb7V0TOOwlQVyDr7z0CB17Ze9vW0mCYd6rEnLsTXgUaB7Zlk5ucaXY4HziUWdRILnWO8EZc2qqVFsx5h0gP0XAhO5yAcGKgtFem1G1Y2CILmeFRZwD1zGBSNNS5efCaCK3nOBzBod8B7+vpc/29k+xPbk6VP84cHC+2M/9iP46Ed/qA0t7kPkHjKQZRPqgz8ByB2Zk8aP5G40ttFJD9IZzJu3JCO7DBR0Py/pJpVY3gYkhCHnVAZBAdqWKXpnMIIzrsFLDmr0BA/QwAWDPMTcor2s9KCkBoMWfl5r6D3ukNMQc2JmkChJYWE6aJjadZ31BSqWpMnb6l4F7MbgXrWBpIDV0bm3GNafZeU6bKp1j+Vvblun2ZKiWyCvE2F32G1T8cVbzOuOeb0iFPTaZK3syLRwEtgfCtt1ettBo5CNvUlNWcnKONiF/0x9vw1sDwe2Fxz+nGG7c+BKQhPuSGea5G2ARONi8IvDdgWLX3Sc3dGb388JMIMUVA9rHKRSIhpmwN1+xR//yZ/gvfcef1hL5mwfoD17ZXCBBqaS5gbgA5gbj+lUOs4CJ1UUruQV2HURr0/o76KnCQVLA7gIdLG4nsvYyUnvgxl0Uun8Cxh4fbY019wSW9tv4jQYBIyRzFa1GzCCrjeTrEJrRZllRBeMNs6JTm4EyP2aY4E4QNm3oh9hEYNhKhBYZgMjkdgK3Fl/vAHSpmcxW/Ef2oMITGvTbFojmQzHCgBJ3kBbiaPIDqibRFoXFMwD0IVSCV4ylVVJ1iLtK+QmtKyHgdIYADBpLI2ZwizA8c+UhUoS11yeJFrH5Y9RHQnWV3F2dnGglBVI49zkr1KryrBSGcMsdKIYg9atxjZxqBchTgrOK48lS2seM6MHUj3VHqPKtNafNZLkCJMHDchIFoIcGrdJ7w+UirBJkcA8u0wBgtDcVeXXHIZ9gjFImlcJwxXqd6x4hSa5FRPS08dWqZNp4vs8rXIaAlOyNF4jZAxwZfkqyVWTiqTMp0jpXn2ssa3UsEy9uMxS9QjZsjkdei6obqZCnrUuJSFDySSxrhNgLZ4b9DjjQJjM6MWKVM2M8prVnO8vLfJqh3WcLs9qyQ9l1IhjJUosRdxIxwAJPAmXw6f2ThlATPmpS7I3k9l5KusXn+iosTvb2b777Td/87P4nZvfAzLx4z/+E/ilv/eLwCSgXrJpguvKAuSYSExJHkPpSRml4QBu4LSCY+LJdod9Gp7cRqsTUp6KqZiQaRsiB9fNuCOJGHdATmROSoK1P7acObnnZkydgZT9wA15AZf3nvDJ2lIuMmQ2hGsGsN3AfEP4DeNI8BjYb5F+B0xSqrsRmGHYo/YlGkuq4GjJMEdZ1t2XBOlyiBfQDjZ2BlFfJqtrpwdip0EURWZgva/X93oD1J+5D3Jv8wF4XOF7YrthJsFxx/v4mBhSk7jS5GNUYhllewLlS7Y5cFNQ3ilRzQDu7mBXY3rk9sRKuDrAWEeTx2G7wDHg7w343cDYOUfGJrZnAxs0FcyRsQHXjecSjMkEKo5Rn9uAxhpNFkd5jIaUIIbP/vvfwUtf/SqePDlrYny/2jMTjc2YwpNFbKwILJDU39EAXqkZCSTEO8AFWKugl4gswYaK6ygriQPSh7NWAjXa3pZZWi9yeUxaOM4aDCk0apJTIUNqd8OK5qIVBhuW9bP4j5NkVKB4a+sFXFqb7WjpUCPgqeu3MdZkmDAVniOQqexaCWu5hPdzNb85yEXk9aDAlJKYRFuMEaVBXJ1LZi8ZCdYLupfGXHKUXc8sV3H1H0kej48QqE8YDomyUZXWO+jfwCwPyWJKMeXupIYJSzrGh42FVJGzvE5Fg9gRFoq/OIBmA2MVphF/28r3yu9Uf1UaWU2RTFteCyvCgNrL6cJH6fUl79EhQk9VT3wCzyI6wzg/Zelqy3hyDNw0VyTbyQC6cEzVTSqX/kZiQtlZikA5KtgOIkOd+UhygKrJsKnrIiuQehGqRuCTnVd9ocuj5FFNqVJYQRatDHpnfEQDcJOIO50JfgPlSKz5x894gvno6zAWeYHeGbsIlWKuUF6sUpfJA9cEohZAHP5a15r6bpanwvp5CJaKTABV1TvS2vbRv2+Swfepgn1ZbHDwnOyFqHiakL48h9g+9CK+3n+irDHWC96mgkKVOpgZvELpoM92tu9N++bbb/efHzx4iNfffAOPnnseNzc3AuQ8f0pu41HbneTRMpgUGXc4NhlBBhIBh0/gukuKGUNeVF4opE1lnJrLuwCYDe2VymhnBPGVeIFnrWSPQYLRCWVKFWVA1YmoE74O9AoshlOGkwGm25c7xJLB5OHl0cDhP0uu1VcuEKwMSCwURwlSuxDgYBbGVJhb0CgV3R26lp6/nrm6F9bngA61llIx1Su9A+4GnzKqSvJm2hOhz6eu3H1jwnzWifdXVsCyrVSKyd4yZZCsmL3hkjI5bMqzo2AfHjesOl8+H0qvfakHgLZuFgyDreeg7Gv1dWTgrTffZF+54bXXX8frb7zxHa6Is30n7ZmJxjDm04/Sk6d1IbiaqFkLFrgfMFsBWrkWSWUTaqmIzlqyaMArsFhgCm7I3TqpUO8NhUfrvybJi8C8PIoLqDSYTwHS+oDAhRV+6V2oF1RbnjsgVGQmysMBWn0OYL+6IbBiG8rzk/BOAdefbCspqgxHE/nQ780I9Gwy5iEBaeOXJT6RvVkU4I3qW6yNpLaFEDHxAlaW8holptOTs4y7pAIFFNdQixJJ0x5e968O8SYaA/KeGFCFfjhvClWucS2rU2nmm6yk0TOwplrts01U0qyJhgGYpuJTRsDX1pvuj0XsajM3SwLYnpO8LseDMTQVEAx5k8SdWKdhrGtXi+MPNPfrOyukZHm46iBMAL6DYNSMJLAOc+N02mpU85D8AIc12e/Flw4H3eFFyLIwgh/WVVFkzg0Sbh1q+r84ED2TCbTXLK1lFHW4KVRFeJp3qcOini8OoF7HPCDLf2S2msjqGfTnyEV+cwUiaXuow2vdp/q9OQx7s5ltJYeg3JDXKHVT10Mp2UB2TUlUmsp7c1OPU+qG9w+OH2YzgRJaEna2s30/2te+/jX88//jn+Pv/8qv4Od//ucZf0ZdK5bck/JGypKSMQ0t/zFsAB458NAMN+YYz13wdAZ2GPIayLtJUm4smDkDmPJmZiTiQtNSG2QCsGAKXLNQHBi9GpmJnGOdP7XOBYJhCRuKFQyd4aq7wDM0YTaRz90CwdpTtJpvTOBQeX6liGjnYwJASGnBn1Zw8rYNbNvA2AYu4wHcL4jtISIDM+9gfoHHxMWnZK0BbBPzGrB51BPwRgdz7ZKAdhGNKns8MB48xPbCQ4wXXiDRefwYeXuH8fgJ3CZ8Biz27qdWdsjzToX3ACaDqN0Gtu1CA65v9FrxsGCfzCtyBmNZ5EmiEmWDjYGRAyM2jMET3TFgG7NKMTuWS0auJ3KdSTIuU4HHtLZulQSmsmyR1Lz79jfxL379/8Ld9QoAins52/ezPXuMhnNhH4xv7UZFASkB2kJtlmirfXk/KAUZCxi8/z4FCjvgC2KyB+RZB7bIQS9BS7T53HI9T1kY8nC4w8rbubwABZv1+YYhXn83ZAeG6BOJtj7SNBzM1V0g6OCtafNEgUozQSjpfWTlT5mZybMEGIu0NAGqG6DjUZo09VjIcK8iOG0S0P8rBqbesQKU+xLS28/q3wKPRpAaRchEPAqMmkak+rrIyerFGmscLMeHgfV1DZgxIUDFSSy2ujakwBFFNxlg3xS4LPpQFGIh+5IBmMZrEUQ7XOz+3KnZAs0/k8yuvAw95w7venw8qrnWGLZXLOsVO50AunZLjX2WxG/2c9XneUjWfEqUPK2fo4CvKa5Ia7SM66S/qeBmX2l4u19TP6s1UClwFZxd5FPeBtMa7EBFBMmxsf+EpVX00pto1NzvtV8kpEF3Ld6aSFgB2UUQ1lv3HDxaG9+/+6xRrQlmknMo68thn+AXeIDZzFVFvq4jvTY9arUZrn5r4JCJShF8lHzWkxTm+JYAlbOd7XvUMhNzTnz1pZdwd3cnYiHpKjhbf/Zn/hYePXpehCMk6WVGKjqbaZjZpZ+fIiVmoHf0YvCNi9gOns0ySnRmN7oPZZyasJ3yqIp9ZKbERJjXyXpYdjqXRqJiIinlNHoZykKeQaPSnbyfM5WF0BGDe2Lu2ovs/r6RcDnVddIonaoNuj6Z9egCGxeMcYOBwAVGUjUndpW99gikOiJqb9WLWNY5Wnst98cxnNWwVYfiMga2Rze4vPAIdvMRmA2MR8QS427HmIaIyRoeoDmniwIb32ckmLUJTgnUcIxtU6aoG7Qlt+LYpiHnTqOw65wZoFdjDGwXenVGFC9yEY0NaWQtmVVkOOGuxCKtSlg4AkoX7D7w6quv4tXXXoW74cnTJ7i7XjHn0Zt8tu9ne2aiEdLQE+ppissSxwI4C90JKxJsDKOcaC6gVwCqtZkl+rc6nNEZrGg4MQZ8hgKp6qFyWSwrE46VfEsHe1sjDxZZoCbyIi8VDuooKZjBo9CD3QOZlINYW04jHWmKafWAY8nL+EypvosGRTBT5UwvzVQ/XcP1XNsL8eXSxNuuLEaS5ZSMpKzsdbXycyQcCOk/C7CKNHTEqizPCWIoDwDbAs7lYWGMBLDHqinqtfVpfHLE+6qJ6s1kjYrK4AM0QqsoiCYiEL8o97FynVOaI4Ss2h/ZRKrAKX/tPcfqfQMDfo9/lu6GvMPobq+naEKleWjofOzs5rgvlTKRrqx+QAf5FgYm0ShCxYxitV/3B6w2UxEFAe50Q24m8NvYH25azJJBZf9jTcobxyZYzK40Y/WwxSaoTURlR+nlJBJlpkJLlTu/aua4y5Oh/aGHRFID5BoyjWP2YB0IxpEAiFhFLoqYNRf9fY9tfPcJAg+nPPxAMkSjsgjLGn6qGGrVukiWowK/y3vSnier7SrazlBcIrsgovrODmK0lNwu0PuU3ZsYaMMG/LBHHYM2zna270P70osv4ksvvvgtP3dzfPITP4YXXvghABvjI0raWbwajPODGaYD+z4QUylfR1BSdNGieaqQvgDC6BV0+PIUe0qixSJ/ccudzpFctykyAe3LldFKsti6ZubK/rTh4E2didwTeTsrWE4yLUcOSYIVgO56N9NhxbiROnfr+gbbmHLWfAPGBfALto0pWzdz3MGxY6eXPxIjJzelcYV5IFPmPnmRioRBfQofGBvJxmWjx+ByM3B54SFuPvI8kB8DMICbycDpJ3cYV4ikzEWROvc8u8INGBjYbGAbDt8GLjckSrh5uIjGDkq6w5G7I8eu8zExNoigMPOUD8flyqxUY0CkZUPERXLnCbfAGEGiUfiong1lbJJHwx1f/8bX8Lnf/d0Pdb6f7cNrz040ZlJfXXpHoYic0vYJbJsCo00uSQZHzSYCSEcFKze58FxEpSwXZsCQkGAXKBhtfEXZJwJHl6JWh7G4S1nb26Ctk1xTtP8/gc6aZHLPEMQ4SZR2LGJbA7DxeVxysrKWmMFwEbBWyTuLJe0IXjsLJYUebNbGBD5fJoOYrSQ2KWBCi3HJRrLcmwJrM+UHmfVsJExp6MDs1QMLaausHi0bAj3mgF1EUjK70JobC5lvGjIlIlOA/PJWVJq8DtyVtahqDcbg3wdYUXtmDawOhUkrdypvecl1+Hh8t5nAyFUptvR3qRub5pOFiF+5WTV3JowHkyVgjDFI8GVsrmtlCVqGKQCZlvSaVzahWIds8LuOV/T/179HSR2fcc3HRBVBagJTf57gJ2zQw1UA3SrrBoCdxD9cmueyrLXkUXMLRWSKYIkcqaJqSSJWZqwiY7yOS2vb3hbT/M/D+4tU08uTilEaHe+0HE254q9g95hmre5ev+oeH1pXWWseLeuNNPjOFInLO6YCih5dhd005ag0YMpZtJGA8o9AYFRmtxovW+MKPVt6rfHa1upwRBs5LAxz6mfqA5Q0QPsPNus+6Kr1mrtnO9tfxhYZ+MxvfwYPbh6iVhsy8V/9l7+AH/nkjyA27np7JqbSt16TWapsAFsYbtLxQKYEXBJ3DoQbYnKfq6x6qYqBCQc2oxQWodS3ofWXqOyDAWEWALXJzGABwIBhbIpjYPQyAvTIQGdeIphRThIqGj0ckcIJysBJskEiwH2b+x9xuArZ8UWQoBXv8iBwycCDfcKx44qJXfqB9ADGhFkqXsUwY6IyJK6sTryPuWPbHGNjhqjNHA/ScXMNXJ7cIh++C5gjnjxFPr1i2xObjFaOTftNnVnGAs3GdLObDWy+YfOLiMwAbhx4HsrACcW6ArhSUqXuBAzYPOGXG4znbjB+iHU0tncmPOi5YdpcKScysZvqaIyFN3l+kRWaOeY+8Znf/Awev/ceYIa3DzFFZ/vL1569YB+A5YsEdKbyMB8OyyHrYB4CF7nhDOwHWE9rIQG7YNdR6pCH+80Da5eVtpIwlAiG9stQzQEgpyh2VcMSkIUmvkK5oAzfXBAFcg7AtuIt7knBCjSEo7LTwlgwhkDMgRiISolbGMimML0hc9DDY0YLgGIhaK0GAFpRxuRGWrKeY79Ub1WWjoIgZdW3EXBTClEcpVuNbRqAQiSDMTGMRSgQ5e5IZRmS8RqJIjTo9IBSjLWnpO7V3if9rnhlKoC2Y/8MpRojz6h+0zSiOirhsuYMAecONK7JqMAHVzBN+YLMNF5wROuGEz65caWjdbFe824XuGurvxWHJYlF3V+Wf6HWg0OirT1HGZ0Bq3g5FnHWsaE/qYATkbFilAI+ErAbVKBfKiCf2Z9IenPTM2S51NWHClavOCQFVx1mTjDoEYBtxkkyo2WBqT4Ni15b9v5Ak1hzjAIH7xmbYqXpZY3i7TcZMU1frOxYIcDAfhNJKjmWAEnFXaUPcUwd4lbrf+0BemD23aZ1U3Vs4AxOhFwguo7ZbG8kp7ZJ4lXEp9/8uDCb8PSf9SnXvrd2vlgT5kA++YYyOCR1zGd627P9ZW6vvPLKt/zsp37yp/CRFz7CDG+pFNyskosHN2sfc094sLaOW2BTCu+q7kxPcsVelFeflu6E6lkF4wK4uA4xf+hk6EynjQSue516B6KxIctAWPvI7SSxoJVACucy3DBRiHvtSdy3ocx2JZ+mx9qWctJq/0rWqMjAZoENgYkJUzYtqh8CVaApE8r4V7uEdq6SlFoFnK8sTANUZYzrRNzcIs1hd1f4rnsYwbwr5sGG5LkgyasUvJRiDQwbHKOhvqxaaDgcaFbn5ugzYzjg28C4bBgPLvCbC/ypwfcAwzgqAL+8V9lFYLu8iRn2OXH79CnMHPt14utf/zreeeed78p8PtuH257doxFcNPQUEAKE+AINwmVBzpYHNLhNbyIQEZibwU2yC3PWcUjmrI8rCDabmmSDswS1m3OAtSVgyHAMiThokV6LpWQu5gRaBSoM1hbUqHRsWiSQVOcYdV7wqQJB7cqeK/6fEPIeZb3FAh4l3fLyAJRnwDqVbhqYpUb3JEjNUvToswvsAnRD79KIQp8j16n80dYkJABUXt7KFgtARIWu3RHUukaBxTTYOGA1puKiDLNqJZQXwRzT+a4mErPZIf230gnD0R4wj7xXSdwGLdURqVS9TI9bfRxgauPSwlvYypJUhKXAv0Y50jSPmHa14gX24arXwT4IEJh7jJ7PKPc8CPurYnPBvQaX6pqhOVuHYBGNvAAx0VW9AR4GicRlY2plVA0MuYNJAgcPuALhKElivWwyLS2A0IG7V3/bUvtDc7bZoczp7WE0ydl0EFuRjiL/lVYmQCkR6JnwuniJoKtuR689k0WQhxbMkBvQWZ9MHpg8vp+VApDrpvS4ljr8CQRowQvuGwGseAgBAXmXcqzpwcKCYy2hA/0uSdYAVKuEqa+n5lnuhrwsYnj8XtETpmLWVBRJzpCUcei9Kv4MzJaWTclWS5TSw5X/X31zxmic7QesffZ3fgu/87v/Hs2swb1x2wb+6a/+Q3z0ox/V2WJgNlMaIjEDIx0PbWDujpwEmRkpSc5A5gbDzkBtsJhfuiRbCXk0aKjp2gqPduKM9xxzOmwObD54/m0b3OgJ2G4mzCeePtlxvZt4+viO996A2Cm99IsSQpSLHikptDCI5Ec0IlX9jMTYElsExh7AlYRmYmJi56m+M624+Ww5shsNKZEr5biBGxvTgLPfPFnLyGRkDBj2awD5VCTMkE/vEHMCW2AEgGDMhNMRsUL7JEu73AyMzbHdbHBscAz4tnGcngC4prCFNu40YGyUPBAaYNsAv7nBePAQfn0Ovl8w9issJ9yvLFngCcTk2TuXpG1UAT4YXvrq1/DvPvVpzqNMFt872w9Ee/Y6GnnYLSR3sqGDPQ6WdVufSZr85e2oozkFvksGo9R0SG4WyUU0shXZYhgUL5P4CpQ7KH2BK3SawT9GXCSrpZ5dRElKzkNsJYFV2wo6IIEblSFbElSwNzZ0lp7SWGdf6xA0WuB/EBSvsg3l8dE2NLIdPGUdd7CC+URJm5RU0NEpSV0Lu29n6xmZ0SlZb0KEqf7fwdMCPRqm/n4RowVt+HCMEZGlJQYzd1RF6IQswfx86LqtQ3cJkFqaA3kA+I2K4T+IRdZcS3kalF62DicGrxsK+d7TvPuAzUHCkJK3yTvlLTuSSEaWJ3PHcM3D9719Tywsi3SPrxvTOxaKLBlSQPl3FZsk1pZQ8cIoGlOygPJgFVU6MEiYCAS/U4SO92HsyarKaE0EKcPROvIignqrIrJR3jfdK4M/U8aQ8viVYSBd8qssAlB0m+PrpQ3S+Bqkb/aAZbRMrJ7LwDWyUk9roTSr096RICM1SRqxLJiIRcrhCWyyLlplUvMlP3NI91x7kcida8/S/WrNxWB2L+4LxdI1S5NSRmQeHj9FhuQIbLJYHS4JXnDvyl6EqVvIW3OUop3SqbP9gLXr9Yorrt/m546vfPVreO/xE3z8kz+mczwxrfAB9+jNmFY2jJ7RsIqx4tY50mVoc1TJq6pejqiNbgU4e2XGMlrcEt61FtwNmxlu3HEzaIXPB7SsX/eNqoOSL2fSy5KQB1ZnVWW8ypA1Xz5qY8Dy2AxjcwzbWADRZdYJaxxTHgwrq4ZkEZZJ2VAbHXRKyKNhGJQgGfdoGNMCmw9M34C8SFIcOk3ozR0ur7IrAWZlscSgMchd/1Kc66bq4HBaV0qiXHEUqc2u8IWVcXMIMsmTXAbB6n+DktMI7jl/9vLLL+PJk8cwGF5+5VU8fXrWwvhBbM+edQpoQNGHfskIkC0vgCQtbhUUhbVwkLJCpgAgRBIKZC0rQFnDgTrTbYE63TrquYwaf7oW+0E7SVEZPUtiMxOIrZX3fYjXM9b9SirhOvQjVCbDsQJA65+yoKBkNFox2WaN9j4kGou2t9WdQNhqcQbBzQ4Cvk1MgJdk//nEPUtnxUVQNhM4OkFK9sWgNo3TYhe67rLIV2xAF8YzeZWUNQQg5vIiibp3qJ8SSv+JzoyNlLY0K+K8hjj7SEBYkcY1kIbOArzqM+T6Hi0nh5iMun6Q4NBroZ8XyE32QZFRaKzpDbbW4jfWr3Wg5+iQI9Sm7f1O9UWDqR5M9QPvPkEiVUkP6qhKA5zulD6kSj6UIgapuZX1gFZ7ejYZ62F1xcR0R2F1WPXflLPKqizckiY1qbLDq9V71KEUcg4auO6zBHlrgMOWjIDpCGVCKO9H9WdJ5WpCtvTL6gbyDJRR4P6/5XFVGNWaV8ZxkGMGFeuz3paEKPpiWIRfQUgJIEP9qfep/k95hNp7OaECWKhwm540NZrH+V+z3PTAJaVDbSmwnndnO9sPeosIfPZ3fhcf//jH8U//55+ADcaT7ZILelIeu5lhjoEYhqsNGoBsQ8RUKSdXeBflynMy01GW4UH3s8IF+1AsqQC9K8Wt8Xy5OPDcAJ4fjm0AeLBhXB3XMMTuiH0gNnpWfJ8yBGLdaIYkoqFkH9pD3YBtYFwGtpuBzS8kBYMyhxkDExs94jfSbseSTgJ8Jx/U5lYKeuu9mGey+2B9DtX8CBvIcYN4cAPEQ2KFmyfIuQOgUQ1IXCzVB2I3BUJMNTh8YFQaWrk+LAcQG2wAuBwOw03PXRn5wNTGniQaHnt7oz0Tno7Rig3htFFICvj93/88Xnrppe/eZDzb96Q9O9FIAQC7d25CkAkQfOrz8AgSrM5MAaPydpihKjq3jEBW15LGM4iXBKMCyNsyr5ZNObyf5qjTlN4Bhy+0e3W4MQ6hPmNkKJR+EMir7kwDo+x71lMYAV6q4I4vNs9HO6BT3XuFuiSWblPWiQpAt2ytffWD8DMJQJGg/p1QyrTWtHW8BNAWlPbWCEVmo9WF3AvIyRGMDsqFr70oi2jMJik4EpW6X98r263TgcxHsGwGD4erajt/LgvOxuKBBdISnDqdFra6uORcK3qaYFe/49zSCB7YQllaqAEb6vtoQt3QVPOk51bVbHEAMQ5cw7AKQOn6tjZQgNcPedCKL1L6d69rmmT0fS2blHNxyPqumI6ejjVqrgV1jIXSMxpwLx3zIbCIzylpVFb/QaTa8v6ctIqd4ewpLxnM+v2RUEyLt1Uum5jU8x4e8LDWzcbqV8kzswhR1t4ir5+IeMxanSSZZqCho7xeK3iGXtnJd6QkSt81xXTxJVGxVJWyNkFCl2sAUWEwtJTW97S+cv1rmmM1hsepU9tREdCTaJztr1p799138ZlPfxqd+toSDx88wC/9wi/ALywMqGTbGBsQ4UibNI4EayIlhQ46Nx1Te8Mhf8NaWiImYzA7lEXiMnhmDzdsYhzXAcwxSFzClb2O8SPpOzJDjmqTA0LGCpduKyYt/zB5GRx+2TAuRTYU5xCuytcbschwkqlQPEsRF9xPbQsUudDeBhENFQJ0o9rg8mBgPLrBePQAmM8R10wgrnfYnwBzhmqEKLFGeSqsCtWKiDlLwQ4f8M0xbjZQZ3GBFPCICT53FRzFOu82kLBQpbKjDjdzxq29+OUv4aWvfbVMPFQfyNLy5htvfren4dm+B+3ZYzQS7UVYIKiQU8K3BZRL4lTHfFpZ/VIFctAekERJm6ylOW7ZDgEAtEjUYZuVwpUYT1m1geL3nsyQ5LIMHnTaLYEPkv4RKkTYFspl3e7sOJ5MFmW0aAo/EyxB91ElbLvLTr1nHbjqaDlW6StNkgonQOuYWpmGI7ghmgOXikkoK654gs2k5VSuR8hbsVFZIsCNlqXRWuuy9BCwE7TaoWJqWcVxAEzZON7kdaI7VNaWKQClSeFSVqUlvR+QPKZISDElESjT/Ik4XkOTZxSgM0prdpG9VLBYAjkXKu3qzzA+xEW6VBjKG2Ry00dZl4sAmGFmKhGY/BqNDdW/eq+jydmQjD8xV6yEaEQCEwymd3225mDKHVOF2MoSX2gyFWBX8cnF/wxghqu5CGGtQ177SGPU1xki9WtcUfcb6OwgqRpUtZLiXkBKHkiN4RhkjoMXoyrbc8NAy/xqfo/JAWCKSGPQvUgLHULR+0zFgWhGHGSBXEf3cHe77uSFhGEG11MYuuhTdgdELeIlf5gB7NI6wRHdj8pq496ejT4oa1Q1dvV8NtbPq6pudX5prDES7oGIQ9RHxcHhQGKAjiM629n+KrXb21u8+MUv3vvZC88/j7/zn/9nMHdkGPdQM9g2KHktc4TOnGjpoaFi1xLoxBQA2pAE0IhDOSP3geEh+ZBi58yw61ya01QHB3DnWVLGP2QwWWZ41w/18z4AACHvSURBVLgKD3RqcB0Sw5nCd2w3GGOwlsSNMSbxKkNPDsQlYWMipjNOUcUIc4/GJtX4umvvN+EV3yhLHsY/3zzn2B5tuLxwA8QDIBx2t2MacLczw9WEw1wGOR/ENRXoTt7FFMTGiuZjOC6XgYRjn1HbLi7bRWGDof05mkBuQKdfv+63mBlAMiYmhuMbr7yMP/4P/+G7MMPO9pelPTvR2AgOQuiLZ3vpH1O1AAicsi2V/GdC3wPTvI3SwdQCsgQG4xEiamJnGRGxClrRcjhRwg4ovfzheiVfAFiQrHTiaUt24wbPwIjRaVkZJ1uL1xeYlKWzLc3O5yGwcno9LGEbF2ukKR2dOu5gNYWsLwPAhsRISqMojyoiRyHOHPzcjXNjDVlVrdn+gG3c0NjvB6BYHxJYXJWSaQkatTEXAXO+33Cn1SFL1qaYloqx0EU80MHpObRpZ0N8YPA9ZtZtal4Mgq4O9HWUm5hBcbzjGNnSH+jdsDPrVA4BRLMqQ82jpyzkxv5Au4E5EFV4rg8ppxXGpLWFqd8tmKkDaFmaDSjmpTT5EHkyHhI57sXHkOABsGhywHdenqH2LhifwcGdvfK017O2nPCgX7JKw1toW+w/sFzWvJ/mtGs+ljGpvBsVZ6WCVBUrHpINddtEcudBdoaeXuI8Nfom0mDSXUNF+Xi4AuiEA661nQpsD3Ny7fIMHq7flddhzds7I4PAvMn4oJnAAO0gh6hwHj4n512Wxs9AGYNZbSgAKIuYYUBuckaKHEOSOOmiKid/echaWqbBKa8L52iJ84wplFH7pfrPa1j1c63+El2d7Wx/ldt7jx/jn//arzNDG7g8L5cb/KNf/cd44YXn0Zk3JmB2YcpZp2edsXjaY3UYsn5UH+YAQkkqEgOJi5dsaqiyuON2D8RM7PtERO1FrnNCcqcL8dBMIJzy76lsHJRwM/7jotiJSj3rwzBwgeWAXW6AbcK2O4z9DnPu2GZIMh2Y18DcA5hbWY3a/GFV6wI6C31jQPvGeIptGB49ctw89xwePHgEvPARAA68MnGdiaf+FLfbhqsDaTyX08vLoAxgaRjQM18MNzd8j4cPb/CVl76OT/3GbwEALpcN/+Sf/I944SM/hLu7CcyJKlxsBlzMMIxeo9/6rc/hz156aeEjszPu4q9Be2aigQvBYgFRAg5vQ0IF9RjKcQYIKkmPCBKSeUApypbDrDuysCtVjMEQzmJY0ZpqAgHFhkFGQIJcnewlcZcHsOVWgKQdsAYnqKwwjQyM6fNK7mTMhNUSsU3W6IM1xaAqnghAC9YYCVa35fUvspjKOjllmU+E9OPUl9Y7bPUaCcTBvmpHUCS3ciXICoHohiQKZunA7uJPnVGrrND66zFotR9cnoBgLY4GtxPcoVWDoCxIS4KDTgUqR2pbdtuzlE7PTO6YtiMlnXPFqtTnooLXZSanldcIgA8i2SrEVhQXFYCuUF6UCj85xk3a6DeW+33C7CpTvwS8Tlf8CLT2tu4VDpEESEWVkvppnkRqRZTUTnbv8r6098lgMZDhsJiUCIAAu+Ztr6ti0rWU1h+xspLUuNYYlikva2qTUNZF1e9NF+1w4fcVWK1fGdDeMJjp/a1lieJvnXHOen7U7lDrqZ7d6fVAIkf0F0qK1C/VRFI30HpPA2LvlcdMY+PYObXmJKVySqZs0hLos6QaIoWWSKfcgIc7mOUlh1L76j4Kpvfeg7gx2UEWmlleEl7f1yxlX9QiLVdurHc+zp+zne2vcstMvPPOu/d+tm0bXn75G3j33ecBBD7y/CO88OgRXATCUYYxrIBseR4oBVI6FdsBBGbsfbptznU7hsPDEJOYJrQAZwHwTO7RWQYwv+c0saMRwrPMf+0NqJoQxEgDjg02HsByZ7bNDJQU1BGsoTvKQJeHjV8y67bA8OyCb3B5TIYCz1mNe4NtFwA32qzpSXCn7GtYGRP5XlVg0BVVODDgm6kYoCERePmV1/DqK6/iHdWu4Pi8jLu7Kz7ykf9kxUu6IeaOl19/nTjJDW+8+RbefvtMSfvXrX2AYPCD1hySzQzANv02K64iD1b30jPrYK3VXZgRUPVdoKt3lrdj8D+BxNTB7ICAGzp4tSz4y7IK4RAd6sbF4QEWh2tJghG0Ki1lVazu9JhqjqN1VzInAVyHJF4BEpRLigRRoM77EGzm1Sh1GtZF+PgMjFqVYR9IGmyY37rg5WjMZwoer9SfCRIxJDpg22aBSih43to+SgYAAkNhpVHDErTKNlmwbMDoIZBVcpsdZarmjSomwHhYtAzL6t3U34ppIF/jeDB4zTFDQe/mDbKRfD9GAI2WUpUS9KjiodUd1LVeErYFfIIxK1D/eFJWI0tQWV0g0Me+2g4XZd/6WAC2CC77Xt8LIKcz0O0Q+7HWT40Bjj9coBegFSgKvPPdPbJ5cJgz/Kan4yEOSV4iflaEoRdFPWzcmxNVKDE0X9sJZIs0oQhf6SYTXPdYnsMsYuJg+umUXMqW57FlYce+sdV/Ccgryjka0JzRCzOMoYA8VidovrESsfW1R1RMpFVXUoIUBp+5+kikxc0xBhBD+miNe2DFntS8lYsTsDU2bUWtQbeKH7EVZ2WaywFcRCDR5E5fLeMDQ0O11zn8rAx+tr+mbd93fOrf/dv++y/+vb+Lv/t3fwGA9qld8CFrXyLAYIaqDcM31YC4AzCx71RFTBgum2M4cHMjL+UO2G7AnHiyTVwj8WSuZA+1GU3VfJBDBZnAVjKukagSqjZoOM1hMswZgAtgD2CX5+G2K64CiKsMXRHwfe+ivBXgnrKOGVaiF/47ALtgbBeMsUniZMBmiMtDzJtHyMfP09A538O0O+CiPS+URcp0vo265qY9ccMYhk0FzZ88foxf//V/jSdPntwbn3/7b/4NPvkjP4Z/+j/9L6qzMeHuePvJe/j1f/0vOxVt5uFQPNtfm/bsRMO8baMVwNwHb3kDCsiabP0m0CQLX4p898Esy4DJkldHqQPIoSDtpJXWJEOB8ulXcTg+Q6BK0utpURDH4AJuCrJq9DcYxFnEJsFrMtUMIE8DrOI3KsCJrtjOriPvRgdwlwa7umUoqPi60tkVkMoOil2Wiv6dkFtlmJBzonEjv5X93WOMSQFdOzyHCcSYraqiB+qxLEJYN2CxsugHqKDkDuQuazwKKhUwmvB+Uztc2PolKAtaMSsW0oZikURAEjwLkpwQIWwmRFBfyZOXdwpIC1hUye4CdNIHydLVWb6KSUbSSmaGrlafyQOoPAFJkFqphs2TxG6KBA31bcii1ug99BjVgXVKkJVnjdsISuJ2X2Az+d624R45gZ6LiLiiIpe3C4BkcKJlJsma5nr3YwD03nEwKoaKBaPYf3zsXI8dfK7oNW5rmGsbEJnt6t2g1+RI5Jfrqu4nYqd4hax0urWeYAc3ZhGXbIO/ycNhWqt5nBvlibWSOdU8ItHNg5yqnngE7t8no3cX9BWyxymrA9TPlfGmCWXWPtc57yDuzDVIS0Ffk3RF7P5sZ/tr2o4A9aWvfg0zAn/7b/0cHj16niIIQZKVbpt7YNrANjZsPnATZCR3XnEYLqJh2Hzg9Tdfx4tf/BL+i5/6KfzoD/8w7Jq4nYGrzTYApKlyuDI+moMxhQnkhZ4U1vhyIJlZiufCoFHVHbgMeiseJCwSY0/sAdXhcBlKNpKKAcYOIhFZxiqrEDNtVA44yYW7vDQ6cvIamE/ukE+fALsjY6e8zDfY4LuPQZ/zaC8uEMZ4jbE5NgXKf/GLX8Rrr72Gu7s7vJ8vZCbeefttfO5znxVpCcAMt7e3uF73k2D8NW8fKL1tHfZ13gO459FP4HCY8z9lqTuodXioSjbeyadQ9SPQIK2ixT3pyvOydBbizgWXWwfdwAYClNxQ0ukZ6cBaI9AvsJ4FpvXVVnSYNyipLESdKvcAXJrj1IIqy22jliR5smWFJsCg67fIRBV9i9Wj3edKsa3v67oF8KyC1u6TkUYzhUOxSEv9LlMeg/piija0RToPzwQRsAWQoIxgJcepd2Gg9CEuLxujrgrkGnt6zO5b4cVPCbUOYAzIfoeRTEkr/rCuS0yoexQc5AwyZRXrXsoDiK2fCfR2gUA9u1fMh16++r5IdPPN6uMBmfcpmyMYFXo9eKWKHDKZgNz5FZt0mDB8zFjPLECfCkIw9ddahIq5qTki0pXpnZrRelbUvD4MlmW77wtep+ZTEZMiqjYPnKH78v7Yt0Pj8O41UbM8kyJibrTmleeqh7IkkYu/QK/HNWDlWeSCKWdpAQM4fQY4cI2OhIjsOVNWw5DcsdMmtwjK1iD0OK45t+JFrJ+fdW0kM8PBEwsVquwFqglUJG2eHo2znQ0AvvGNl/HKK6/iJ370x/Ho0fOozXC4Sy0gbwYM8IFtG7iMgQf7YMBWWBuFhoiGw/HWW2/jdz//h/ipH/4onvuRT+CaF8ACT0UumALbZbgxnQmFRQzYQkA9FRfpiqVwYFRV2kEmcDHYTcD2gN8pSY4Mmyy+JwmWjKSeiR1lqHg/0dC7uJLceBnFDHm747o/BW6d59C4EvPYgKlA4uYsVHsBa5mEJWaRl60MzMCXX/wzfOWrX/2Pjsvjx+/iD/7gc9/18T/bD177AAX7lAJNgLakAgVE678AgFRRNPjSgduBBOSyxVe8gEkzuKVhD0NMXTUBiGSYZ3+3D+kEXY/urOCL+/dhxXEAw9oa4WVFhiNih9kuSc6QFTQ7F/6qLcHYC8sjLAPfu8G1gfKgRvAryHMTkQH7DmlIU+YK5D35TiSjCswmJTvay6qmVwf6Vqc26k/YoXp2A5VG7HqH+q6BGyhSFnWC1mIVVv8YPTxVrR0AqiiQzLYNljgeubwFJXXDApqFYxfIKw8DGLfTwJN9VZmsAEqyoq4lj1DX8vDK4GXIIOtoWc/7pDKrC8pjgGaZqTlsVlIojUyof6x6hvMs4JhD3qJ2DclyPwQs0ztoHqh4Fet71vty2iiffE00q0QE0gpXJxb5SRZnQmYXkLJie+BnU+9Hj5DEciMZ0FwuBn3OkOig6AbERV4K5fcgtCU+AyuAvx6u9olMci0FQNPYYHo87QG2CA09TdWnNVWs72u138R9UuMphyS4Dqh9likiDMvS0LuVXlr9HyKEwgdFLirKpyeI9kIu+TWui33rc46OaeuojMP8Lh9nvXtWzFPWHD7KNs52trMBQETgNz79aVwuzHb0Mz/90/iFv/N3kOGSKk5UWr2BDYYNcdnpbbA7oM4cczx+/ASf+tRv4O13GHPw737v9/EHX/oS/odf/mU8ePgI2+3UOanq45mYg3LmUAwZyoBkTNwyZAAcbiwEOy7wjQHbWxXWu7ISOALYNqOVyga9mhtq025DT/lnHVl5a3T8m4gWPRrDuH1vF+CLL/4p/uRPvgSE4/lHz+O/++VfxLY5pg3MGAgMbINEY4D7bVgyRa4ZbsbAl770JfzRH/0R3vrmN78/g322H/j27MHgjPAUQMteXAD64C5rXgQIfOAKDIoGt5nM5JJD1l1+DAlmnaJV2hrQNygdXFnuhi3lHo3kYewC8gdLaug/JtJAFwohajiA4X2AGxPoC+BY4ymkJFGqMxD7wuz14hXE3t6YA/jqGM5tdVODR0gnbsG0rbGsvLCKylDhn/4e+8xplEEw6kT3SqKsDYyfmNaYxxIdi5LlAREgNlmSiwzWAxoM2MHCOgDait76LY5O6lddW2Ec3mOU1p5/rXgDVgFFj29Cmcn0t5JdmSW2Al31yaoALsA2YW1lRprieIAKyJfmR251VUcIkhL+Wjp7KF6hh9ZWAGCDZqDJCiQxQioImPO8sGa5062zIiptL6zJVFnaW4oGKEbGYNtsS1JZzkxxQXCoKHYRAI5Z5hRQR8cYKMlRfZKyP7BirGMy/7kioCrGwC3kJZKcSG7HAsrlFYAZEJWNJZBbMrFVgDpnFIdJVgUfZNorMVb2EJn6wEQ80sHwpVkGhTpZ9V2Nc8c4pAD9yBo+YNIimK7vD9P8QtflWfEYxQr02SgSwTG8t1GKhBRR9Ro3rH42mgh7H6ovBkhMrMOAqClPo+uGjiml3IaL3OI+MTrb2c6GN996q//8kY+8gLe++RbrUNShlA7kA9i4YWVqfwrgiuv1CSYcMx2XMfD48WO8/OorHUfw5jvv4L2nT/HaN9/CD0XCL8+jdlva7ejOjcIoWV5dA4R1SpExBjrr1N31Do8fv4dNWCPNcDM2PLo8hA9mi+q9DwANlWUoqt3lQDTq6JOUoSqcmzsiJt5++x28+cYbeP3VVwEAT58+wttvvYnnHz3CwwfPATZgSSMtK4yHUuUnLB0RgW++9RbeeOMNvKJrnO1sf5H27EQDaGlCyYwiOpENIKs4jAuoitnYNJiVip4KgOkCTnV2yvKIGZhjdEaEJeURiEapqRlEOp2eDySAOwGYg5y59pvGYlYZFhjwaaagztwEDiRtOBKoyqAQid2AXe9aoZphhvTApRHQgYQZVvqohWPQXAMK9HLILQsC2wCwSfIF9L+o54sCjbivS7qiN8NwdlmPT4G7KEsqO7e9G2NtjjAQCN0D11sHxUePZr2mo5TwrIXAt8wp0lmAUq6Zys6TIeJm6Fom0xT+no5NmDoU6GvufUdF1iITuKIK/YmIzSTxrH6TzKct0ALjJcvyshZHxQ1p3lQ/d6YDoNwOduw7VPaOBQbNKOmqhxhI1h6pR8/DuB76MiT1cYHSclxbGGwGsLH/rPViIFFEEJgPzYkwZZSi5Y4PlbBNqZ1BT9EOw24lD0o4OCiimph2mBvToNwE9NHvEOHhmmMNEsA9MS62MpJNrbuqn3g8JHNxljbRJdNcT6tEBVYhYWheeZ93tLe1Wb+qy8LZ91EeF5Dwbhxe7MZK7ajaLf0cUPpkrp/hRZyyx7/+71Zgo+buerAyOKQmfAIIpYrmbSrnrwwiGz2vkam1TVJ8Rmic7Wz/8falL38Zf/6Vr3yb39j7/pT39txq+77f+/vd9Ypf+5f/Cj/2oz+Of/yrvwozGfVUy8l37deAJNj0smRbF7mR3AzHcMfl4Q1e/IM/xec+93v37vM3/+bP4e//8n+PbQ6MmNjkO50bU+xGJFzpbZmJUESj9iMeqEhnGl1zh9/c4PXXXsO/+hf/+t57vffeY/za//2v8Ld/9m/hH/y3fx932vvGOCRfccVq5MCbb7yJ//Nf/FoTsLOd7S/anl06JavaPFhzNwGLqIjlkLvfqrJuuf3r0KdFegzAbg1+Feiqw9sDTgceZuh3pPMdEMqL8dqeC3BHQohF0FfAngf8QhASTNEynDtKSJ862CeomXJZK628JwKjXrKVKfmLF9BeKWhHWar1DxJdDOyA3WlpH7LEGjePtudPE6iyjtcoAkS5lRBXIRb1k09DeCU1XZZiGCTjCQWdYQUED3WWyAFlLYcA3CQ1yvLXBlD5YW2S+kWbbctTRW8Qx/RA+rw082XaNoFpR1bhIFPNlqTHKCwxdxGUwWSvmASQaUBuyWBySKIzxLACLPTXMQqQ54f/72krS7dl4gIXiUXHjzM7U7Z3qeI7CnLWuCy5kizz3VeJzlSU9KjVbOa6arM1NpEDJUdkvxgY5DjkRtf4VRwCA+sltQreylDqp5r7sr4bYKqoy2JXpvTH9GQYkoB4H0hV0EXwGWzIWh8MdpcDBxAQ7kxga8FrOXqD7CYEVr3nh6D0bGkVhjVxINzWOyS4jjw1BSvTVurzkkxM16awCoBO+nAQCFw191Okp1MyNpGpP6AtAwnJJFXdsIPha/UXeTD2TRhEukEJYWYXmjQkvNyMtahG9Jrd0liwy+kNynkIhjvb2c52r2Xmt5CF77Tt+8Tbb38TX/jCF/DJH/kkPvHxjzOgO4HcAl27CXZQNlpt6jAw/uP29hZf/PKX8Y2XX/6WZ3zjjdfxhS98HogJd8PP/OzPYNs2NFapAO0sUSnxi6kY7n2iQY/In734Jbz++uu4Xq/fEoS97xOvvfkmPv/HX8CuvatjI2UQ5CbmeO+993B3d8daJWc723fQnp1oAJjuLH4VysHstPBPfaACTUsRVAHEPstQTjCDq8EFhmZbN5lubQNwNTB9nEC6idAUUCsVhen3jO8SMEtaLAtUxQDJD9AXKQN1pkCcDBAzZWV3dsxAGbCz5UmuGIH0CphAmza6JoJ+Xlb60nB3AHIBU0fn+S8wleD9SxUSC5MtadoB3JaxOlPvJWJQwa9lBa6+OpqC6RQwItIyxOg5EPKKbIDJcl1aesA6uZEZkFOxEUUuysqdrBrNd+Dc4BAyPmXZ62W5TUNi8FFszaM5Kg0rWj7kAbgxvqRc2N1JRwt46n6JezFFpsxo4Y6peTUC2LbAHaJJ2ArkTeypAkbyWtVYlbOjiV1JrlpiKP+X1ZtyzRjDJHrcl4wLB4+FEiOI5GVlOLF6VWsQS+9PNiE0I0mqQn0W1u4DVkdHS5s6U5kIwqznkAumZ3VNgbCDE8D44lGclBY+F4FBea70jlb6uTJOGNMe63xDxYGVP2/qezXvysPBfSGUHEtxFYMLOTJVFbyMHpqnTrkdrxYt5TMtrvIIakBQMSoVK8Fe4uBoaNGxF/qEtgN6p7REO6OXAzZzGUkgYlJZJgJdSgOQweVIxs52trN9z9o3334bn/mt38Qv/eIv4W984pMtX4ZTOoVUTEhKLotUFkPGMPpwvPf4LfzmZz77bQH7a6+9itdeoyzpwYMH+Imf/E/x4MFzcJuS0dLImiWjQnCvE0EAQNnl2GDu2OeOP/y938c3D7Ky97dXXnsVr7x2SqHO9r1rz551SmAMqODoAuH6QzNu/j0jFWxK03B5DNrqfLC0rmtVyscQSDq4OYu1HM7b0nOz+NYAMGBVgczWd6300x2kDaa2nd5SiAJQjTHqVmUxrufSx6MjVCuw2AR4C5zKelwYXoGvpbfPAou5Xqm0/zACp4iABwPHhFMWkSvEWh1hZSm29UwLyqD4T0Oi+pUbMmX9VerguoJFERVl0zgQnrbc6zYlCSooD40NMruQG2DIaZp1C8ATwDIbVFltljhLr1cpDG3FbxiChEWBPsvTUAH6sq9rfpYl2Trd6+h+DxglQlsAER3jUYQn0zAmidTReFV/qz5zzbOq7QD1QVawMUwB7OhY+ppdQCAP86oBbwHdHvjod+3Y5hp/z/ZymcjO4QP93EWgO4alhjR1gLng8vCuCM4lmveIMMFzCtCXrqpeLNBvZ5K0eRGumutkrEwbHT0nWIRrpVvkwHrPLbEWVOrreqnsvUirVoXyTJ2lEFAwcFO6KHMZ83yRqvJcVn8zl7GeOVHVxYEUWdJra2FWrFdJPYuw3iNmBtwL8s7662FvUYyQOc52trN9n9qffvFP8eqrrwIIPP/88/il/+a/hm9bWesgSw4AGjDgjhmBz/72b+ONN15/Zq+AowqcGiXVw5pkRAKwQc3D8eA1A3zgC1/4Al76ylfw+L33vit9cLaz/UXbMxMNnn/WWKUwKCALXB4sgvcOdllQAbH+xqgCXwtmcyHRWqmwKBRUsQIYvkBz57a39bN6qEWCCAapY7e2ahdbysI6RQIakN8nAOWCbNxWwcxW1k5aqelVEMgQsLgmvSUNMoRhUiC8ao40AhSAdXWaWV2rkScvFoc/C9Xkoa/7+SQrMRB88ivZwKeJ4sE0b+BYCUchR5lZDx6l6i9lZoItK27D8VzjDRSQWhbgFsQV9soV68A+4JUGIHdxzSl5FUzytChAu+JaStJX5RkKjEtdV6+zutO5uR/PhBpXS6OuHwWdF4Bug7TmoSW/s3KroelTfX4DY1fK/V7EuJ6pqqoTTNeiq/5e43b0dtWYug6f6uU1aTU/bHlXAD7DKG+KtWOrY1M6nkoytjBT0D/usXIzJUuBIe6XzeVzSzpXXpKik52S2QyVtYueD3o1Oe7gGCu4pQK4q8/rQVJWRaqlrWNIatY3Z1G/pBfRXRubeRGQ7IXUe0ExavX1cYRr46jPjvrxIb6nyfIKeOrb3Occi9BaWnHis53tbN+H9tZbb+EteQl++Ic/xnXuBgvnnpYAXPIEcI8LBL7xjW/gzTfffOb79HZRagikPPLWn6mto3/ifIa33nwDL33bOJWzne372z5YMHhDEGtFwdDhnRCx1+9zyAofClSt076qcaOxvnAuLcCxmWI5i3hI3sObNakgOCB6bLlSrufLlHwDsngmFLRFoBAh9O9oIFMgrXFLPRyOQDHhFclrR4JFMYUJiLupWrr0/cBhY6jYA+fz5ZC1tDIVBQB4p7N1AXCCSj94I5gGlQHVhk7FWxmgFlJBa+IrwFmEjjUWpozFSu3rpfn31pgfDbiGPMjRojfH0HWX44nxF8S91mTPBP57/EsalJxZFbNSA+EaS2uydZw7dF23h8d5j2n0dkQAm1JclVrHhmJhGss35MbcAUSlAF4b/YBjDDLlWRYsaKwU1W4ArKrIgiTIMmCurE7gOA4RHiAYbF0MzypuwAh4K1pelvjmmDV27XGqrmJKQpuGYsI69lAcNis9GorUoRFuZfuCJaaHxhnwVJpqoeEIY7ro+q4kXiN5jVhYfOl/zVbszLQOtM8hy8PsKcr5VBtGYtUirLGSp4M80vtLHZBdZDOAjEUsO/98aj4PVlpn0MxAzgSmZG4j27vE/tbzHtmAL8KMKOp58Goe5tZKoKAZLJlU0+oE96wqllN9K2Lih9ue7X47i4Gd7WxnO9tf3vaBiMa9rDoKxKyAa2J8gX6epATJewBjMuC2dNBlHY8jgweDPDdeq+IbWqJxCIkQjNNDyXrrADAFngg2Oo8mIFkHQA2OKSg4ZGW0ljo0yyjgWqb6482HxCEmwHwgEmWtTDiDnoPAqwySQZOvig4eXiqKaJDSoFPopfJaQ94ffx+BiAZDUbCFSK0BigswJRQTUzr/6sdCYiAIRhBklZZ9ka6aB4f/J8B0OerHtM4qxb7iMxXM8rrlrPHVb7srFKivoO1O35vqb0larLvIqxj3Amy6n0ViiLTQEM337NGyRZ6KMI0KftCDZpnjgxk6LAKbEgEwDWH3IlijxQBj1XkDibYbECYJT/LZRkmWDPAMeaIkv9sMuIpcesVPrExniMoKVfeo95BQZxqB7I36kKrCluvBysujlaThDwXqtC445DUqqRf4LOOw9OB8xxXfw88VUWjSHiLr09pjZM7xYVox9XN7O2gAQC7PWicgAKvBtwfPJM/UfKoXYoyVCvHBkRuXGL0KvhK2Wcm9uFd13Ir2uOL1KcPGvcBPUF0WVrExzsdcs0wEvKRcWm4iVr3n2HFeilwm480qxe/Zzna2s53tbD9ozfI0B53tbGc729nOdrazne1sZ/uQ2xlieLazne1sZzvb2c52trOd7UNvJ9E429nOdrazne1sZzvb2c72obeTaJztbGc729nOdrazne1sZ/vQ20k0zna2s53tbGc729nOdrazfejtJBpnO9vZzna2s53tbGc729k+9HYSjbOd7WxnO9vZzna2s53tbB96O4nG2c52trOd7WxnO9vZzna2D72dRONsZzvb2c52trOd7WxnO9uH3k6icbazne1sZzvb2c52trOd7UNv/x+XnMS3E6WAVAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- 5. Color Detection ---\n", + "# Classify the detected marble into one of: blue, green, black, white, red\n", + "# using HSV statistics over the bounding-box ROI (masked to the contour\n", + "# so background does not pollute the result).\n", + "\n", + "def classify_color(bgr_roi, mask=None):\n", + " \"\"\"Return one of: 'red', 'green', 'blue', 'black', 'white'.\n", + "\n", + " bgr_roi : HxWx3 BGR image (ROI around the marble).\n", + " mask : optional HxW uint8 mask (0/255) selecting marble pixels.\n", + " \"\"\"\n", + " if bgr_roi.size == 0:\n", + " return \"unknown\"\n", + "\n", + " hsv = cv2.cvtColor(bgr_roi, cv2.COLOR_BGR2HSV)\n", + "\n", + " if mask is None:\n", + " mask = np.full(bgr_roi.shape[:2], 255, dtype=np.uint8)\n", + "\n", + " if cv2.countNonZero(mask) == 0:\n", + " return \"unknown\"\n", + "\n", + " h = hsv[:, :, 0]\n", + " s = hsv[:, :, 1]\n", + " v = hsv[:, :, 2]\n", + "\n", + " # Use median to be robust against highlights / shadows.\n", + " m = mask > 0\n", + " h_med = float(np.median(h[m]))\n", + " s_med = float(np.median(s[m]))\n", + " v_med = float(np.median(v[m]))\n", + "\n", + " # 1) Achromatic checks first (low saturation -> black / white).\n", + " if s_med < 60 and v_med < 70:\n", + " return \"black\"\n", + " if s_med < 50 and v_med > 170:\n", + " return \"white\"\n", + "\n", + " # 2) Chromatic: decide by hue.\n", + " # OpenCV hue range is 0..179.\n", + " if h_med < 10 or h_med >= 160:\n", + " return \"red\"\n", + " if 35 <= h_med <= 85:\n", + " return \"green\"\n", + " if 90 <= h_med <= 135:\n", + " return \"blue\"\n", + "\n", + " # Fallbacks for ambiguous hues.\n", + " if v_med < 80:\n", + " return \"black\"\n", + " if s_med < 60:\n", + " return \"white\"\n", + " return \"red\" if (h_med < 20 or h_med > 150) else \"unknown\"\n", + "\n", + "\n", + "label = \"unknown\"\n", + "if found_object:\n", + " # ROI from the cropped frame\n", + " roi = center_crop[y:y + h, x:x + w]\n", + "\n", + " # Build a mask for just this marble using the largest contour\n", + " contour_mask_full = np.zeros(inv_thresh.shape, dtype=np.uint8)\n", + " cv2.drawContours(contour_mask_full, [largest_contour], -1, 255, thickness=cv2.FILLED)\n", + " roi_mask = contour_mask_full[y:y + h, x:x + w]\n", + "\n", + " label = classify_color(roi, roi_mask)\n", + "\n", + "print(f\"Detected color: {label}\")\n", + "\n", + "if visualize:\n", + " output_image = center_crop.copy()\n", + " if found_object:\n", + " cv2.rectangle(output_image, (x, y), (x + w, y + h), (0, 255, 0), 2)\n", + " cv2.putText(\n", + " output_image,\n", + " label,\n", + " (x, max(0, y - 8)),\n", + " cv2.FONT_HERSHEY_SIMPLEX,\n", + " 0.7,\n", + " (0, 255, 0),\n", + " 2,\n", + " )\n", + "\n", + " plt.figure(figsize=(10, 5))\n", + " plt.subplot(1, 2, 1)\n", + " plt.title(f\"Detected Color: {label}\")\n", + " plt.imshow(cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB))\n", + " plt.axis('off')\n", + "\n", + " if found_object:\n", + " plt.subplot(1, 2, 2)\n", + " plt.title(\"Marble ROI (masked)\")\n", + " masked_roi = cv2.bitwise_and(roi, roi, mask=roi_mask)\n", + " plt.imshow(cv2.cvtColor(masked_roi, cv2.COLOR_BGR2RGB))\n", + " plt.axis('off')\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ea342f3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
filenamewidthheightclassxminyminxmaxymax
0frame_0000.png720540blue296120484204
1frame_0001.png720540blue279120472299
2frame_0002.png720540blue264208456397
3frame_0003.png720540blue251310439420
4frame_0004.png720540blue288120477203
...........................
2039frame_2039.png720540black213241421420
2040frame_2040.png720540black210346399420
2041frame_0001.png640480black00144102
2042frame_0001.png640480green318474169
2043frame_0001.png640480black00144102
\n", + "

2044 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " filename width height class xmin ymin xmax ymax\n", + "0 frame_0000.png 720 540 blue 296 120 484 204\n", + "1 frame_0001.png 720 540 blue 279 120 472 299\n", + "2 frame_0002.png 720 540 blue 264 208 456 397\n", + "3 frame_0003.png 720 540 blue 251 310 439 420\n", + "4 frame_0004.png 720 540 blue 288 120 477 203\n", + "... ... ... ... ... ... ... ... ...\n", + "2039 frame_2039.png 720 540 black 213 241 421 420\n", + "2040 frame_2040.png 720 540 black 210 346 399 420\n", + "2041 frame_0001.png 640 480 black 0 0 144 102\n", + "2042 frame_0001.png 640 480 green 31 84 74 169\n", + "2043 frame_0001.png 640 480 black 0 0 144 102\n", + "\n", + "[2044 rows x 8 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# --- 6. Save Data to CSV ---\n", + "# Convert center-based (x, y, w, h) in 300x300 crop to absolute xmin, ymin, xmax, ymax in original image\n", + "img_width, img_height = 640, 480\n", + "xmin = max(0, int(x - w / 2))\n", + "ymin = max(0, int(y - h / 2))\n", + "xmax = min(img_width, int(x + w / 2))\n", + "ymax = min(img_height, int(y + h / 2))\n", + "\n", + "# label comes from the color-detection step above\n", + "# (one of: red, green, blue, black, white, unknown)\n", + "\n", + "file_exists = os.path.isfile(csv_filename)\n", + "with open(csv_filename, mode='a', newline='') as file:\n", + " writer = csv.writer(file)\n", + "\n", + " # If file exists, try to detect whether it already has the correct header\n", + " has_correct_header = False\n", + " if file_exists:\n", + " with open(csv_filename, mode='r', newline='') as check_file:\n", + " reader = csv.reader(check_file)\n", + " first_row = next(reader, None)\n", + " has_correct_header = first_row == [\n", + " 'filename', 'width', 'height', 'class', 'xmin', 'ymin', 'xmax', 'ymax'\n", + " ]\n", + "\n", + " if not file_exists or not has_correct_header:\n", + " # (Re)write file with correct header\n", + " file.close()\n", + " with open(csv_filename, mode='w', newline='') as file_w:\n", + " writer_w = csv.writer(file_w)\n", + " writer_w.writerow(['filename', 'width', 'height', 'class', 'xmin', 'ymin', 'xmax', 'ymax'])\n", + " writer_w.writerow([\n", + " os.path.basename(image_path),\n", + " img_width,\n", + " img_height,\n", + " label,\n", + " xmin,\n", + " ymin,\n", + " xmax,\n", + " ymax,\n", + " ])\n", + " else:\n", + " writer.writerow([\n", + " os.path.basename(image_path),\n", + " img_width,\n", + " img_height,\n", + " label,\n", + " xmin,\n", + " ymin,\n", + " xmax,\n", + " ymax,\n", + " ])\n", + "\n", + "# show csv file as table\n", + "df = pd.read_csv(csv_filename)\n", + "df\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv-3.10 (3.10.20)", + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test_coral.py b/test_coral.py new file mode 100644 index 00000000..7c6dc3c3 --- /dev/null +++ b/test_coral.py @@ -0,0 +1,63 @@ +import os +import sys +import argparse +import time +import numpy as np +from PIL import Image +from pycoral.adapters import common +from pycoral.adapters import detect +from pycoral.utils.edgetpu import make_interpreter + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--model', help='Pfad zur .tflite Datei', default='marbel_coral.tflite') + parser.add_argument('--labels', help='Pfad zur Label Datei', default='labels.txt') + parser.add_argument('--image', help='Pfad zum Testbild', required=True) + parser.add_argument('--threshold', type=float, default=0.4, help='Score Threshold') + args = parser.parse_args() + + # Label Map laden + labels = {} + if os.path.exists(args.labels): + with open(args.labels, 'r') as f: + for line in f: + pair = line.strip().split(maxsplit=1) + if len(pair) == 2: + labels[int(pair[0])] = pair[1] + + print(f"--- Lade Modell: {args.model}") + try: + interpreter = make_interpreter(args.model) + interpreter.allocate_tensors() + except Exception as e: + print(f"❌ Fehler: {e}") + print("Stelle sicher, dass der Coral USB Accelerator eingesteckt ist und die Treiber installiert sind.") + return + + # Bild laden + image = Image.open(args.image).convert('RGB') + + # Automatische Skalierung (das Modell braucht 300x300 oder 320x320) + # PyCoral's set_resized_input erledigt das intern + size = common.input_size(interpreter) + image = image.resize(size, Image.LANCZOS) + common.set_input(interpreter, image) + + print(f"--- Starte Inference auf Edge TPU...") + start_time = time.perf_counter() + interpreter.invoke() + inference_time = time.perf_counter() - start_time + + # Ergebnisse holen + objs = detect.get_objects(interpreter, args.threshold) + + print(f"--- Fertig in {inference_time*1000:.2f}ms") + print(f"--- Gefundene Objekte: {len(objs)}") + print("-" * 30) + + for obj in objs: + label = labels.get(obj.id, f"unknown_{obj.id}") + print(f" [{label}] Score: {obj.score:.2f} | BBox: {obj.bbox}") + +if __name__ == '__main__': + main() diff --git a/test_mixed.py b/test_mixed.py new file mode 100644 index 00000000..333f02a9 --- /dev/null +++ b/test_mixed.py @@ -0,0 +1,73 @@ +import re +import tensorflow as tf +import numpy as np +from pathlib import Path +from PIL import Image +import os + +LABEL_MAP_PATH = "label_map.pbtxt" +THRESHOLD = 0.4 # Etwas niedrigerer Threshold für unbekannte Bilder + + +def parse_label_map(path): + """Parse a label_map.pbtxt file and return a ``{id: name}`` dict (0-indexed for TFLite).""" + text = open(path).read() + label_map = {} + for block in re.finditer(r'item\s*\{(.*?)\}', text, re.DOTALL): + body = block.group(1) + id_match = re.search(r'id:\s*(\d+)', body) + name_match = re.search(r"name:\s*'([^']+)'", body) + if id_match and name_match: + label_map[int(id_match.group(1)) - 1] = name_match.group(1) + return label_map + + +LABELS = parse_label_map(LABEL_MAP_PATH) + +interpreter = tf.lite.Interpreter( + model_path="/workspaces/zip_ai/models/ssd_mobilenet_v2_quant.tflite" +) +interpreter.allocate_tensors() + +input_details = interpreter.get_input_details() +output_details = interpreter.get_output_details() +output_map = {o['name']: o['index'] for o in output_details} + +# Pfad zu den neuen Bildern +mixed_dir = Path("/workspaces/zip_ai/dataset/dataset/mixed-not-labeled") +image_files = list(mixed_dir.glob("*.jpg")) + list(mixed_dir.glob("*.png")) + +print(f"🚀 Teste {len(image_files)} ungelabelte Bilder aus 'mixed-not-labeled'...\n") +print(f"{'Dateiname':<25} | {'Ergebnis':<15} | {'Score':<8}") +print("-" * 55) + +for img_path in sorted(image_files): + # Bild laden + image = Image.open(img_path).convert("RGB").resize((300, 300)) + input_array = np.expand_dims(np.array(image, dtype=np.uint8), axis=0) + + # Inference + interpreter.set_tensor(input_details[0]['index'], input_array) + interpreter.invoke() + + # Outputs + scores = interpreter.get_tensor(output_map['StatefulPartitionedCall:1'])[0] + classes = interpreter.get_tensor(output_map['StatefulPartitionedCall:2'])[0] + count = int(interpreter.get_tensor(output_map['StatefulPartitionedCall:0'])[0]) + + found = False + best_label = "Nichts" + best_score = 0.0 + + for i in range(count): + if scores[i] >= THRESHOLD: + class_id = int(classes[i]) + best_label = LABELS.get(class_id, f"ID {class_id}") + best_score = scores[i] + found = True + break # Wir nehmen die Top-Detection + + print(f"{img_path.name:<25} | {best_label:<15} | {best_score:.2f}") + +print("-" * 55) +print("Test abgeschlossen. Prüfe die Dateinamen gegen deine Bilder! 🦾") diff --git a/testgpiopin.py b/testgpiopin.py deleted file mode 100644 index 43ff998f..00000000 --- a/testgpiopin.py +++ /dev/null @@ -1,33 +0,0 @@ -import RPi.GPIO as GPIO -import time - -# Definiere den GPIO-Pin und die Frequenz -PWM_PIN = 19 -FREQUENCY = 1000 # 1000 Hz - -# Setup für GPIO -GPIO.setwarnings(False) -GPIO.setmode(GPIO.BOARD) -GPIO.setup(PWM_PIN, GPIO.OUT) - -# PWM-Instanz erstellen -pwm = GPIO.PWM(PWM_PIN, FREQUENCY) - -# PWM starten, erst mal auf 0% Duty Cycle (0V) -pwm.start(0) - -try: - # 3.3V Ausgabe (100% Duty Cycle) - print("Setze auf 3.3V (100% Duty Cycle)") - pwm.ChangeDutyCycle(100) - time.sleep(2) # Für 2 Sekunden auf 3.3V halten - - # 0V Ausgabe (0% Duty Cycle) - print("Setze auf 0V (0% Duty Cycle)") - pwm.ChangeDutyCycle(0) - time.sleep(2) # Für 2 Sekunden auf 0V halten - -finally: - # PWM beenden und GPIO-Pin zurücksetzen - pwm.stop() - GPIO.cleanup() diff --git a/testneopixel.py b/testneopixel.py deleted file mode 100644 index 758ccce0..00000000 --- a/testneopixel.py +++ /dev/null @@ -1,79 +0,0 @@ -# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries -# SPDX-License-Identifier: MIT - -# Simple test for NeoPixels on Raspberry Pi -import time -import board -import neopixel - - -# Choose an open pin connected to the Data In of the NeoPixel strip, i.e. board.D18 -# NeoPixels must be connected to D10, D12, D18 or D21 to work. -pixel_pin = board.D18 - -# The number of NeoPixels -num_pixels = 24 - -# The order of the pixel colors - RGB or GRB. Some NeoPixels have red and green reversed! -# For RGBW NeoPixels, simply change the ORDER to RGBW or GRBW. -ORDER = neopixel.GRB - -pixels = neopixel.NeoPixel( - pixel_pin, num_pixels, brightness=0.2, auto_write=False, pixel_order=ORDER -) - - -def wheel(pos): - # Input a value 0 to 255 to get a color value. - # The colours are a transition r - g - b - back to r. - if pos < 0 or pos > 255: - r = g = b = 0 - elif pos < 85: - r = int(pos * 3) - g = int(255 - pos * 3) - b = 0 - elif pos < 170: - pos -= 85 - r = int(255 - pos * 3) - g = 0 - b = int(pos * 3) - else: - pos -= 170 - r = 0 - g = int(pos * 3) - b = int(255 - pos * 3) - return (r, g, b) if ORDER in (neopixel.RGB, neopixel.GRB) else (r, g, b, 0) - - -def rainbow_cycle(wait): - for j in range(255): - for i in range(num_pixels): - pixel_index = (i * 256 // num_pixels) + j - pixels[i] = wheel(pixel_index & 255) - pixels.show() - time.sleep(wait) - - -while True: - # Comment this line out if you have RGBW/GRBW NeoPixels - #pixels.fill((255, 0, 0)) - # Uncomment this line if you have RGBW/GRBW NeoPixels - pixels.fill((255, 0, 0, 0)) - pixels.show() - time.sleep(1) - - # Comment this line out if you have RGBW/GRBW NeoPixels - #pixels.fill((0, 255, 0)) - # Uncomment this line if you have RGBW/GRBW NeoPixels - pixels.fill((0, 255, 0, 0)) - pixels.show() - time.sleep(1) - - # Comment this line out if you have RGBW/GRBW NeoPixels - #pixels.fill((0, 0, 255)) - # Uncomment this line if you have RGBW/GRBW NeoPixels - pixels.fill((0, 0, 255, 0)) - pixels.show() - time.sleep(1) - - rainbow_cycle(0.001) # rainbow cycle with 1ms delay per step diff --git a/utils/BiQuad.py b/utils/BiQuad.py deleted file mode 100644 index 5e1c619b..00000000 --- a/utils/BiQuad.py +++ /dev/null @@ -1,83 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import math - -class BiQuadFilter(object): - - def __init__(self, filter_type, Fc, Q, peakGainDB): - self.z1 = self.z2 = 0.0 - self.a0 = self.a1 = self.a2 = self.b1 = self.b2 = 0.0 - - self.setBiquad(filter_type, Fc, Q, peakGainDB) - self.calcBiquad() - - def setType(filter_type): - self.type = filter_type - calcBiquad() - def setQ(Q): - self.Q = Q - calcBiquad() - def setFc(Fc): - self.Fc = Fc - calcBiquad() - - def setPeakGain(peakGainDB): - this.peakGain = peakGainDB - calcBiquad() - - def setBiquad(self, filter_type, Fc, Q, peakGainDB): - self.type = filter_type - self.Q = Q - self.Fc = Fc - self.peakGain = peakGainDB - self.calcBiquad() - - def calcBiquad(self): - norm = None - V = pow(10, abs(self.peakGain) / 20.0) - K = math.tan(math.pi * self.Fc) - if self.type == 'low': - norm = 1 / (1 + K / self.Q + K * K) - self.a0 = K * K * norm - self.a1 = 2 * self.a0 - self.a2 = self.a0 - self.b1 = 2 * (K * K - 1) * norm - self.b2 = (1 - K / self.Q + K * K) * norm - - if self.type == 'high': - norm = 1 / (1 + K / self.Q + K * K) - self.a0 = 1 * norm - self.a1 = -2 * self.a0 - self.a2 = self.a0 - self.b1 = 2 * (K * K -1) * norm - self.b2 = (1 - K / self.Q + K * K) * norm - if self.type == 'band': - norm = 1 / (1 + K / self.Q + K * K) - self.a0 = K / self.Q * norm - self.a1 = 0 - self.a2 = -self.a0 - self.b1 = 2 * (K * K - 1) * norm - self.b2 = (1 - K / self.Q + K * K) * norm - - def process(self, input_float): - out = input_float * self.a0 + self.z1 - self.z1 = input_float * self.a1 + self.z2 - self.b1 * out - self.z2 = input_float * self.a2 - self.b2 * out - return out - - - diff --git a/utils/CameraWebsocketHandler.py b/utils/CameraWebsocketHandler.py deleted file mode 100644 index 475979e9..00000000 --- a/utils/CameraWebsocketHandler.py +++ /dev/null @@ -1,60 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import tornado -import tornado.websocket -import tornado.ioloop -from tornado.iostream import IOStream -import threading -import time -import base64 -import sys, os -import asyncio - -cam_sockets = None - -class CameraWebsocketHandler(tornado.websocket.WebSocketHandler): - def open(self): - global cam_sockets - cam_sockets.append(self) - print('new camera connection') - - def on_message(self, message): - print (message) - - def on_close(self): - global cam_sockets - cam_sockets.remove(self) - print('camera connection closed') - - def check_origin(self, origin): - return True - -def start_server(loop, cs): - global cam_sockets - cam_sockets = cs - asyncio.set_event_loop(loop) - - cam_app = tornado.web.Application([ - (r'/', CameraWebsocketHandler) - ]) - - cam_server = (cam_app) - cam_server.listen(8889) - tornado.ioloop.IOLoop.instance().start() - -def signal_handler(signum, frame): - print("Interrupt caught") - tornado.ioloop.IOLoop.instance().stop() - server_thread.stop() diff --git a/utils/FLIR.py b/utils/FLIR.py deleted file mode 100644 index a771f54d..00000000 --- a/utils/FLIR.py +++ /dev/null @@ -1,46 +0,0 @@ -# utils/FLIR.py - -import PySpin - -class FlirBFS: - def __init__(self, on_new_frame, display=False, frame_rate=30): - self.on_new_frame = on_new_frame - self.display = display - self.frame_rate = frame_rate - self.system = PySpin.System.GetInstance() - self.cam_list = self.system.GetCameras() - self.cam = self.cam_list[0] if self.cam_list.GetSize() > 0 else None - - def run_cam(self): - if not self.cam: - print("No FLIR camera detected.") - return - - self.cam.Init() - self.cam.AcquisitionMode.SetValue(PySpin.AcquisitionMode_Continuous) - self.cam.BeginAcquisition() - - while True: - try: - image = self.cam.GetNextImage() - if image.IsIncomplete(): - print("Image incomplete with image status %d ..." % image.GetImageStatus()) - continue - - frame = image.GetNDArray() - self.on_new_frame(frame) - - if self.display: - cv2.imshow("FLIR Camera", frame) - if cv2.waitKey(1) & 0xFF == ord('q'): - break - except PySpin.SpinnakerException as ex: - print("Error: %s" % ex) - break - - self.cam.EndAcquisition() - self.cam.DeInit() - del self.cam - self.cam_list.Clear() - self.system.ReleaseInstance() - cv2.destroyAllWindows() diff --git a/utils/__init__.py b/utils/__init__.py deleted file mode 100644 index ec95199f..00000000 --- a/utils/__init__.py +++ /dev/null @@ -1,19 +0,0 @@ -# Copyright 2019 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -def mean_arr(a): - total = 0 - for elem in a: - total += elem - return total/len(a) diff --git a/utils/__pycache__/BiQuad.cpython-39.pyc b/utils/__pycache__/BiQuad.cpython-39.pyc deleted file mode 100644 index b4427d38..00000000 Binary files a/utils/__pycache__/BiQuad.cpython-39.pyc and /dev/null differ diff --git a/utils/__pycache__/CameraWebsocketHandler.cpython-310.pyc b/utils/__pycache__/CameraWebsocketHandler.cpython-310.pyc deleted file mode 100644 index 7c44ecdf..00000000 Binary files a/utils/__pycache__/CameraWebsocketHandler.cpython-310.pyc and /dev/null differ diff --git a/utils/__pycache__/CameraWebsocketHandler.cpython-311.pyc b/utils/__pycache__/CameraWebsocketHandler.cpython-311.pyc deleted file mode 100644 index 0060dfce..00000000 Binary files a/utils/__pycache__/CameraWebsocketHandler.cpython-311.pyc and /dev/null differ diff --git a/utils/__pycache__/CameraWebsocketHandler.cpython-39.pyc b/utils/__pycache__/CameraWebsocketHandler.cpython-39.pyc deleted file mode 100644 index 0fb5c2c9..00000000 Binary files a/utils/__pycache__/CameraWebsocketHandler.cpython-39.pyc and /dev/null differ diff --git a/utils/__pycache__/FLIR.cpython-310.pyc b/utils/__pycache__/FLIR.cpython-310.pyc deleted file mode 100644 index 815c51d7..00000000 Binary files a/utils/__pycache__/FLIR.cpython-310.pyc and /dev/null differ diff --git a/utils/__pycache__/FLIR.cpython-311.pyc b/utils/__pycache__/FLIR.cpython-311.pyc deleted file mode 100644 index f4d9fccf..00000000 Binary files a/utils/__pycache__/FLIR.cpython-311.pyc and /dev/null differ diff --git a/utils/__pycache__/FLIR.cpython-39.pyc b/utils/__pycache__/FLIR.cpython-39.pyc deleted file mode 100644 index 51f43b25..00000000 Binary files a/utils/__pycache__/FLIR.cpython-39.pyc and /dev/null differ diff --git a/utils/__pycache__/__init__.cpython-310.pyc b/utils/__pycache__/__init__.cpython-310.pyc deleted file mode 100644 index c40a9eef..00000000 Binary files a/utils/__pycache__/__init__.cpython-310.pyc and /dev/null differ diff --git a/utils/__pycache__/__init__.cpython-311.pyc b/utils/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index dbfed356..00000000 Binary files a/utils/__pycache__/__init__.cpython-311.pyc and /dev/null differ diff --git a/utils/__pycache__/__init__.cpython-39.pyc b/utils/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 0e517430..00000000 Binary files a/utils/__pycache__/__init__.cpython-39.pyc and /dev/null differ