From 2012579574d6b9974c47b2c5a7082a688b18d962 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 5 Mar 2026 15:14:37 +1300 Subject: [PATCH 01/16] Implement cog3pio backend entrypoint to read TIFFs Read TIFF data into xarray via cog3pio's experimental CudaCogReader struct that uses nvTIFF as its backend. Use cupy.from_dlpack to read the DLPack tensor, and reshape the 1-D array into a 3-D array (CHW form), setting the coordinates as appropriate. Added some API docs and basic unit tests. Cherry-picked from https://github.com/weiji14/cog3pio/pull/71 --- ci/doc.yml | 3 +- cupy_xarray/__init__.py | 3 +- cupy_xarray/cog3pio.py | 100 ++++++++++++++++++++++++++++++ cupy_xarray/tests/test_cog3pio.py | 34 ++++++++++ docs/api.rst | 16 +++++ docs/conf.py | 5 +- pyproject.toml | 3 + 7 files changed, 160 insertions(+), 4 deletions(-) create mode 100644 cupy_xarray/cog3pio.py create mode 100644 cupy_xarray/tests/test_cog3pio.py diff --git a/ci/doc.yml b/ci/doc.yml index 414cd07..2f829e6 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -4,7 +4,7 @@ channels: dependencies: - cupy-core - pip - - python=3.10 + - python=3.13 - sphinx - sphinx-design - sphinx-copybutton @@ -18,3 +18,4 @@ dependencies: - pip: # relative to this file. Needs to be editable to be accepted. - --editable .. + - cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@178a3ffb8163c97f7af9e71bc68b6545a4e8e192 # https://github.com/weiji14/cog3pio/pull/71 diff --git a/cupy_xarray/__init__.py b/cupy_xarray/__init__.py index 5c3a06c..7581f95 100644 --- a/cupy_xarray/__init__.py +++ b/cupy_xarray/__init__.py @@ -1,4 +1,5 @@ from . import _version -from .accessors import CupyDataArrayAccessor, CupyDatasetAccessor # noqa +from .accessors import CupyDataArrayAccessor, CupyDatasetAccessor # noqa: F401 +from .cog3pio import Cog3pioBackendEntrypoint # noqa: F401 __version__ = _version.get_versions()["version"] diff --git a/cupy_xarray/cog3pio.py b/cupy_xarray/cog3pio.py new file mode 100644 index 0000000..d7d46fe --- /dev/null +++ b/cupy_xarray/cog3pio.py @@ -0,0 +1,100 @@ +""" +`cog3pio` backend for xarray to read TIFF files directly into CuPy arrays in GPU memory. +""" + +import os +from collections.abc import Iterable + +import cupy as cp # type: ignore[import-untyped] +import numpy as np +import xarray as xr +from cog3pio import CudaCogReader +from xarray.backends import BackendEntrypoint + + +# %% +class Cog3pioBackendEntrypoint(BackendEntrypoint): + """ + Xarray backend to read GeoTIFF files using 'cog3pio' engine. + + When using :py:func:`xarray.open_dataarray` with ``engine="cog3pio"``, the + ``device_id`` parameter can be set to the CUDA GPU id to do the decoding on. + + Examples + -------- + Read a GeoTIFF from a HTTP url into an [xarray.DataArray][]: + + >>> import xarray as xr + >>> # Read GeoTIFF into an xarray.DataArray + >>> dataarray: xr.DataArray = xr.open_dataarray( + ... filename_or_obj="https://github.com/OSGeo/gdal/raw/v3.11.0/autotest/gcore/data/byte_zstd.tif", + ... engine="cog3pio", + ... device_id=0, # cuda:0 + ... ) + >>> dataarray.sizes + Frozen({'band': 1, 'y': 20, 'x': 20}) + >>> dataarray.dtype + dtype('uint8') + + """ + + description = "Use .tif files in Xarray" + open_dataset_parameters = ("filename_or_obj", "drop_variables", "device_id") + url = "https://github.com/weiji14/cog3pio" + + def open_dataset( # type: ignore[override] + self, + filename_or_obj: str, + *, + drop_variables: str | Iterable[str] | None = None, + device_id: int, + # other backend specific keyword arguments + # `chunks` and `cache` DO NOT go here, they are handled by xarray + mask_and_scale=None, + ) -> xr.Dataset: + """ + Backend open_dataset method used by Xarray in [xarray.open_dataset][]. + + Parameters + ---------- + filename_or_obj : str + File path or url to a TIFF (.tif) image file that can be read by the + nvTIFF or image-tiff backend library. + device_id : int + CUDA device ID on which to place the created cupy array. + + Returns + ------- + xarray.Dataset + + """ + + with cp.cuda.Stream(ptds=True): + cog = CudaCogReader(path=filename_or_obj, device_id=device_id) + array_: cp.ndarray = cp.from_dlpack(cog) # 1-D Array + x_coords, y_coords = cog.xy_coords() # TODO consider using rasterix + height, width = (len(y_coords), len(x_coords)) + channels: int = len(array_) // (height * width) + # TODO make API to get proper 3-D shape directly, or use cuTENSOR + array_ = array_.reshape(height, width, channels) # HWC + array = array_.transpose(2, 0, 1) # CHW + + dataarray: xr.DataArray = xr.DataArray( + data=array, + coords={ + "band": np.arange(channels, dtype=np.uint8), + "y": y_coords, + "x": x_coords, + }, + name=None, + attrs=None, + ) + + return dataarray.to_dataset(name="raster") + + def guess_can_open(self, filename_or_obj): + try: + _, ext = os.path.splitext(filename_or_obj) + except TypeError: + return False + return ext in {".tif", ".tiff"} diff --git a/cupy_xarray/tests/test_cog3pio.py b/cupy_xarray/tests/test_cog3pio.py new file mode 100644 index 0000000..eb47c2d --- /dev/null +++ b/cupy_xarray/tests/test_cog3pio.py @@ -0,0 +1,34 @@ +""" +Tests for xarray 'cog3pio' backend engine. +""" + +import cupy as cp +import pytest +import xarray as xr + +from cupy_xarray.cog3pio import Cog3pioBackendEntrypoint + +cog3pio = pytest.importorskip("cog3pio") + + +def test_entrypoint(): + assert "cog3pio" in xr.backends.list_engines() + + +def test_xarray_backend_open_dataarray(): + """ + Ensure that passing engine='cog3pio' to xarray.open_dataarray works to read a + Cloud-optimized GeoTIFF from a http url. + """ + with xr.open_dataarray( + filename_or_obj="https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/TCI.tif", + engine=Cog3pioBackendEntrypoint, + device_id=0, + ) as da: + assert isinstance(da.data, cp.ndarray) + assert da.sizes == {"band": 3, "y": 1098, "x": 1098} + assert da.x.min() == 700010.0 + assert da.x.max() == 809710.0 + assert da.y.min() == 3490250.0 + assert da.y.max() == 3599950.0 + assert da.dtype == "uint8" diff --git a/docs/api.rst b/docs/api.rst index 70d22b0..4aef63a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -51,3 +51,19 @@ Methods Dataset.cupy.as_cupy Dataset.cupy.as_numpy + + +Backends +-------- + +cog3pio +~~~~~~~ + +.. currentmodule:: cupy_xarray + +.. automodule:: cupy_xarray.cog3pio + +.. autosummary:: + :toctree: generated/ + + Cog3pioBackendEntrypoint diff --git a/docs/conf.py b/docs/conf.py index 2dffa80..9b920fa 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -54,9 +54,10 @@ nb_execution_mode = "off" intersphinx_mapping = { - "python": ("https://docs.python.org/3/", None), - "dask": ("https://docs.dask.org/en/latest", None), + "cog3pio": ("https://cog3pio.readthedocs.io/en/latest", None), "cupy": ("https://docs.cupy.dev/en/latest", None), + "dask": ("https://docs.dask.org/en/latest", None), + "python": ("https://docs.python.org/3/", None), "xarray": ("http://docs.xarray.dev/en/latest/", None), } diff --git a/pyproject.toml b/pyproject.toml index 106967b..71ea26a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,6 +19,9 @@ dependencies = [ "xarray>=2024.02.0", ] +[project.entry-points."xarray.backends"] +cog3pio = "cupy_xarray.cog3pio:Cog3pioBackendEntrypoint" + [project.optional-dependencies] test = [ "dask", From 1393d57d446a9839856c63cd1a2b48ccf601430c Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Mon, 9 Mar 2026 14:20:20 +1300 Subject: [PATCH 02/16] Allow passing device_id=None to determine CUDA device id automatically Make `device_id` optional (default to None), so that it can be inferred automatically by `cupy.cuda.runtime.getDevice`. Also added a unit test using xr.open_mfdataset. --- cupy_xarray/cog3pio.py | 12 ++++++++---- cupy_xarray/tests/test_cog3pio.py | 25 +++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/cupy_xarray/cog3pio.py b/cupy_xarray/cog3pio.py index d7d46fe..7c2456a 100644 --- a/cupy_xarray/cog3pio.py +++ b/cupy_xarray/cog3pio.py @@ -17,7 +17,7 @@ class Cog3pioBackendEntrypoint(BackendEntrypoint): """ Xarray backend to read GeoTIFF files using 'cog3pio' engine. - When using :py:func:`xarray.open_dataarray` with ``engine="cog3pio"``, the + When using :py:func:`xarray.open_dataarray` with ``engine="cog3pio"``, the optional ``device_id`` parameter can be set to the CUDA GPU id to do the decoding on. Examples @@ -47,7 +47,7 @@ def open_dataset( # type: ignore[override] filename_or_obj: str, *, drop_variables: str | Iterable[str] | None = None, - device_id: int, + device_id: int | None = None, # other backend specific keyword arguments # `chunks` and `cache` DO NOT go here, they are handled by xarray mask_and_scale=None, @@ -60,14 +60,18 @@ def open_dataset( # type: ignore[override] filename_or_obj : str File path or url to a TIFF (.tif) image file that can be read by the nvTIFF or image-tiff backend library. - device_id : int - CUDA device ID on which to place the created cupy array. + device_id : int | None + CUDA device ID on which to place the created cupy array. Default is None, + which means device_id will be inferred via + :py:func:`cupy.cuda.runtime.getDevice`. Returns ------- xarray.Dataset """ + if device_id is None: + device_id: int = cp.cuda.runtime.getDevice() with cp.cuda.Stream(ptds=True): cog = CudaCogReader(path=filename_or_obj, device_id=device_id) diff --git a/cupy_xarray/tests/test_cog3pio.py b/cupy_xarray/tests/test_cog3pio.py index eb47c2d..b82ea96 100644 --- a/cupy_xarray/tests/test_cog3pio.py +++ b/cupy_xarray/tests/test_cog3pio.py @@ -11,6 +11,7 @@ cog3pio = pytest.importorskip("cog3pio") +# %% def test_entrypoint(): assert "cog3pio" in xr.backends.list_engines() @@ -32,3 +33,27 @@ def test_xarray_backend_open_dataarray(): assert da.y.min() == 3490250.0 assert da.y.max() == 3599950.0 assert da.dtype == "uint8" + + +def test_xarray_backend_open_mfdataset(): + """ + Ensure that passing engine='cog3pio' to xarray.open_mfdataset works to read multiple + Cloud-optimized GeoTIFF files from http urls. Also testing that `device_id=None` + works. + """ + ds: xr.Dataset = xr.open_mfdataset( + paths=[ + "https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/B01.tif", + "https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/B09.tif", + ], + engine=Cog3pioBackendEntrypoint, + concat_dim="band", + combine="nested", + device_id=None, + ) + assert ds.sizes == {"band": 2, "y": 183, "x": 183} + assert ds.x.min() == 700260.0 + assert ds.x.max() == 809460.0 + assert ds.y.min() == 3490500.0 + assert ds.y.max() == 3599700.0 + assert ds.raster.dtype == "uint16" From b4b41415db79a5a2a2a640e663ec4ff29fd763f3 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 09:36:27 +1300 Subject: [PATCH 03/16] Set MATURIN_PEP517_ARGS in readthedocs build Specifically in the pre_create_environment step. Xref https://docs.readthedocs.com/platform/stable/build-customization.html#extend-or-override-the-build-process --- .readthedocs.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index d67aad8..50e4923 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -5,6 +5,9 @@ build: os: "ubuntu-24.04" tools: python: "mambaforge-23.11" + jobs: + pre_create_environment: + - export MATURIN_PEP517_ARGS="--features cuda,pyo3"; # Build documentation in the docs/ directory with Sphinx sphinx: From fe0814cc9d6412866ffc54e66909125eb946f00a Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 13:13:07 +1300 Subject: [PATCH 04/16] Install cog3pio[cuda] in post_install step Also bump cog3pio from 178a3ff to ce268b0. --- .readthedocs.yml | 4 +++- ci/doc.yml | 1 - 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 50e4923..a460971 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -6,8 +6,10 @@ build: tools: python: "mambaforge-23.11" jobs: - pre_create_environment: + post_install: + # https://github.com/weiji14/cog3pio/pull/71 - export MATURIN_PEP517_ARGS="--features cuda,pyo3"; + pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" # Build documentation in the docs/ directory with Sphinx sphinx: diff --git a/ci/doc.yml b/ci/doc.yml index 2f829e6..ea9172a 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -18,4 +18,3 @@ dependencies: - pip: # relative to this file. Needs to be editable to be accepted. - --editable .. - - cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@178a3ffb8163c97f7af9e71bc68b6545a4e8e192 # https://github.com/weiji14/cog3pio/pull/71 From 77e5564672c1d5f8c9836ef47ef6e2fd83e1a225 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 13:33:00 +1300 Subject: [PATCH 05/16] Install libnvtiff-dev and do the CONDA_PREFIX dance Whole bunch of stuff cherry-picked from https://github.com/weiji14/cog3pio/pull/58/changes#diff-dac7bdede3716bd72abd5373a7b025c170c21a6dbaef90351e075be774fd45d0 --- .readthedocs.yml | 11 +++++++++-- ci/doc.yml | 1 + 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index a460971..be1fbc6 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -8,8 +8,15 @@ build: jobs: post_install: # https://github.com/weiji14/cog3pio/pull/71 - - export MATURIN_PEP517_ARGS="--features cuda,pyo3"; - pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" + - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; + ln -s $CONDA_PREFIX/include/nvtiff.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff.h; + ln -s $CONDA_PREFIX/include/nvtiff_version.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff_version.h; + ln -s $CONDA_PREFIX/lib/libnvtiff.so $CONDA_PREFIX/targets/x86_64-linux/lib/libnvtiff.so; + RUSTFLAGS="-L$CONDA_PREFIX/targets/x86_64-linux/lib" + BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/targets/x86_64-linux/include" + MATURIN_PEP517_ARGS="--features cuda,pyo3" + mamba run --prefix "$CONDA_PREFIX" pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" + - pip list # Build documentation in the docs/ directory with Sphinx sphinx: diff --git a/ci/doc.yml b/ci/doc.yml index ea9172a..718c92c 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -12,6 +12,7 @@ dependencies: - ipython - ipykernel - ipywidgets + - libnvtiff-dev=0.6.0 - furo>=2024.8.6 - myst-nb - xarray From 832ed7b47f2bceed6adc097edf39eb013e035b76 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 14:13:54 +1300 Subject: [PATCH 06/16] Try using nvtiff.h in $CONDA_PREFIX/include directly Maybe no need to symlink? --- .readthedocs.yml | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index be1fbc6..22da20a 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -9,13 +9,9 @@ build: post_install: # https://github.com/weiji14/cog3pio/pull/71 - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; - ln -s $CONDA_PREFIX/include/nvtiff.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff.h; - ln -s $CONDA_PREFIX/include/nvtiff_version.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff_version.h; - ln -s $CONDA_PREFIX/lib/libnvtiff.so $CONDA_PREFIX/targets/x86_64-linux/lib/libnvtiff.so; - RUSTFLAGS="-L$CONDA_PREFIX/targets/x86_64-linux/lib" - BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/targets/x86_64-linux/include" + BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/include" MATURIN_PEP517_ARGS="--features cuda,pyo3" - mamba run --prefix "$CONDA_PREFIX" pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" + mamba run --prefix "$CONDA_PREFIX" pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" - pip list # Build documentation in the docs/ directory with Sphinx From 77adbbc7a30b54c7b8fe64c763088523cc68f645 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 14:42:23 +1300 Subject: [PATCH 07/16] Install clang, cuda-crt and cuda-cudart-dev Try and fix `fatal error: 'stddef.h' file not found`; 'cuda_runtime.h' file not found and so on. Revert back to symlinking nvtiff header and shared object files into $CONDA_PREFIX/targets/x86_64-linux/lib/, while also setting RUSTFLAGS, xref https://github.com/weiji14/cog3pio/pull/58/changes/186fed200f37d56635ab870b83e969210d832360 --- .readthedocs.yml | 6 +++++- ci/doc.yml | 3 +++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 22da20a..208bc0d 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -9,7 +9,11 @@ build: post_install: # https://github.com/weiji14/cog3pio/pull/71 - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; - BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/include" + ln -s $CONDA_PREFIX/include/nvtiff.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff.h; + ln -s $CONDA_PREFIX/include/nvtiff_version.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff_version.h; + ln -s $CONDA_PREFIX/lib/libnvtiff.so $CONDA_PREFIX/targets/x86_64-linux/lib/libnvtiff.so; + RUSTFLAGS="-L$CONDA_PREFIX/targets/x86_64-linux/lib" + BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/targets/x86_64-linux/include" MATURIN_PEP517_ARGS="--features cuda,pyo3" mamba run --prefix "$CONDA_PREFIX" pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" - pip list diff --git a/ci/doc.yml b/ci/doc.yml index 718c92c..3810821 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -2,6 +2,9 @@ name: cupy-xarray-doc channels: - conda-forge dependencies: + - clang + - cuda-crt + - cuda-cudart-dev - cupy-core - pip - python=3.13 From 8bf1174f01a640107bad5924031b3627ceedcf7f Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 12 Mar 2026 15:00:45 +1300 Subject: [PATCH 08/16] Apply nvtiff patch to set enum on nvtiffTagDataType Fix `Unable to generate bindings: ClangDiagnostic("/home/docs/checkouts/readthedocs.org/user_builds/cupy-xarray/conda/81/targets/x86_64-linux/include/nvtiff.h:553:5: error: must use 'enum' tag to refer to type 'nvtiffTagDataType'\n")` --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index 208bc0d..4c01b43 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -9,6 +9,7 @@ build: post_install: # https://github.com/weiji14/cog3pio/pull/71 - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; + sed --in-place "s/nvtiffTagDataType type/enum nvtiffTagDataType type/g" $CONDA_PREFIX/include/nvtiff.h; ln -s $CONDA_PREFIX/include/nvtiff.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff.h; ln -s $CONDA_PREFIX/include/nvtiff_version.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff_version.h; ln -s $CONDA_PREFIX/lib/libnvtiff.so $CONDA_PREFIX/targets/x86_64-linux/lib/libnvtiff.so; From 9c6abf09b523df4121f9bbe80d59f6ff007bb873 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 26 Mar 2026 08:44:28 +1300 Subject: [PATCH 09/16] Install cog3pio=0.1.0b1 from TestPyPI instead of compiling from source Try getting pre-built wheel directly from https://test.pypi.org/project/cog3pio/0.1.0b1/#files with cuda features already added, instead of running maturin build. --- .readthedocs.yml | 10 +--------- ci/doc.yml | 3 --- 2 files changed, 1 insertion(+), 12 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 4c01b43..d590dc0 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -7,16 +7,8 @@ build: python: "mambaforge-23.11" jobs: post_install: - # https://github.com/weiji14/cog3pio/pull/71 - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; - sed --in-place "s/nvtiffTagDataType type/enum nvtiffTagDataType type/g" $CONDA_PREFIX/include/nvtiff.h; - ln -s $CONDA_PREFIX/include/nvtiff.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff.h; - ln -s $CONDA_PREFIX/include/nvtiff_version.h $CONDA_PREFIX/targets/x86_64-linux/include/nvtiff_version.h; - ln -s $CONDA_PREFIX/lib/libnvtiff.so $CONDA_PREFIX/targets/x86_64-linux/lib/libnvtiff.so; - RUSTFLAGS="-L$CONDA_PREFIX/targets/x86_64-linux/lib" - BINDGEN_EXTRA_CLANG_ARGS="-I $CONDA_PREFIX/targets/x86_64-linux/include" - MATURIN_PEP517_ARGS="--features cuda,pyo3" - mamba run --prefix "$CONDA_PREFIX" pip install -v "cog3pio[cuda] @ git+https://github.com/weiji14/cog3pio.git@ce268b0ccb58ff0c7e329cdf38f2326a4fac22e9" + mamba run --prefix "$CONDA_PREFIX" pip install --verbose --pre --extra-index-url https://test.pypi.org/simple/ cog3pio==0.1.0b1 - pip list # Build documentation in the docs/ directory with Sphinx diff --git a/ci/doc.yml b/ci/doc.yml index 1abf076..f6d5ca5 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -2,9 +2,6 @@ name: cupy-xarray-doc channels: - conda-forge dependencies: - - clang - - cuda-crt - - cuda-cudart-dev - cupy-core!=14.0.0,!=14.0.1 # https://github.com/cupy/cupy/issues/9777 - pip - python=3.13 From 8abf84ec20868804677308900c3c07a3ab8de7d6 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Mon, 13 Apr 2026 09:45:51 +1200 Subject: [PATCH 10/16] Bump cog3pio from 0.1.0b1 to 0.1.0b2 Bumps [cog3pio](https://github.com/weiji14/cog3pio) from 0.1.0b1 to 0.1.0b2. - [Release notes](https://github.com/weiji14/cog3pio/releases) - [Changelog](https://github.com/weiji14/cog3pio/blob/main/docs/changelog.md) - [Commits](https://github.com/weiji14/cog3pio/compare/v0.1.0b1...v0.1.0b2) Changed to using `engine="cog3pio"` directly now that there are no duplicate Cog3pioBackendEntrypoints. Also fixed some import statements. --- .readthedocs.yml | 2 +- cupy_xarray/__init__.py | 3 +-- cupy_xarray/tests/test_cog3pio.py | 8 ++++---- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index d590dc0..03d6b1d 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -8,7 +8,7 @@ build: jobs: post_install: - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; - mamba run --prefix "$CONDA_PREFIX" pip install --verbose --pre --extra-index-url https://test.pypi.org/simple/ cog3pio==0.1.0b1 + mamba run --prefix "$CONDA_PREFIX" pip install --verbose --pre --extra-index-url https://test.pypi.org/simple/ cog3pio==0.1.0b2 - pip list # Build documentation in the docs/ directory with Sphinx diff --git a/cupy_xarray/__init__.py b/cupy_xarray/__init__.py index 7581f95..5c3a06c 100644 --- a/cupy_xarray/__init__.py +++ b/cupy_xarray/__init__.py @@ -1,5 +1,4 @@ from . import _version -from .accessors import CupyDataArrayAccessor, CupyDatasetAccessor # noqa: F401 -from .cog3pio import Cog3pioBackendEntrypoint # noqa: F401 +from .accessors import CupyDataArrayAccessor, CupyDatasetAccessor # noqa __version__ = _version.get_versions()["version"] diff --git a/cupy_xarray/tests/test_cog3pio.py b/cupy_xarray/tests/test_cog3pio.py index b82ea96..7abb4d8 100644 --- a/cupy_xarray/tests/test_cog3pio.py +++ b/cupy_xarray/tests/test_cog3pio.py @@ -6,10 +6,10 @@ import pytest import xarray as xr -from cupy_xarray.cog3pio import Cog3pioBackendEntrypoint - cog3pio = pytest.importorskip("cog3pio") +from cupy_xarray.cog3pio import Cog3pioBackendEntrypoint # noqa: E402, F401 + # %% def test_entrypoint(): @@ -23,7 +23,7 @@ def test_xarray_backend_open_dataarray(): """ with xr.open_dataarray( filename_or_obj="https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/TCI.tif", - engine=Cog3pioBackendEntrypoint, + engine="cog3pio", device_id=0, ) as da: assert isinstance(da.data, cp.ndarray) @@ -46,7 +46,7 @@ def test_xarray_backend_open_mfdataset(): "https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/B01.tif", "https://github.com/developmentseed/titiler/raw/1.2.0/src/titiler/mosaic/tests/fixtures/B09.tif", ], - engine=Cog3pioBackendEntrypoint, + engine="cog3pio", concat_dim="band", combine="nested", device_id=None, From d4ab1dee1341a6b1eae6bdc7fee586ae558befc5 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Mon, 13 Apr 2026 10:17:21 +1200 Subject: [PATCH 11/16] Fix some intersphinx links and other minor edits to the docstrings Change from mkdocstrings cross-ref syntax to sphinx syntax, removed some type ignores, changed a url from github to readthedocs, and removed a reference to image-tiff. Also changed the doctest TIF file to a non-ZSTD compressed version because nvcomp might not be installed. --- cupy_xarray/cog3pio.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/cupy_xarray/cog3pio.py b/cupy_xarray/cog3pio.py index 7c2456a..066781c 100644 --- a/cupy_xarray/cog3pio.py +++ b/cupy_xarray/cog3pio.py @@ -5,7 +5,7 @@ import os from collections.abc import Iterable -import cupy as cp # type: ignore[import-untyped] +import cupy as cp import numpy as np import xarray as xr from cog3pio import CudaCogReader @@ -22,12 +22,12 @@ class Cog3pioBackendEntrypoint(BackendEntrypoint): Examples -------- - Read a GeoTIFF from a HTTP url into an [xarray.DataArray][]: + Read a GeoTIFF from a HTTP url into an :class:`xarray.DataArray`: >>> import xarray as xr >>> # Read GeoTIFF into an xarray.DataArray >>> dataarray: xr.DataArray = xr.open_dataarray( - ... filename_or_obj="https://github.com/OSGeo/gdal/raw/v3.11.0/autotest/gcore/data/byte_zstd.tif", + ... filename_or_obj="https://github.com/OSGeo/gdal/raw/v3.11.0/autotest/gcore/data/byte.tif", ... engine="cog3pio", ... device_id=0, # cuda:0 ... ) @@ -40,9 +40,9 @@ class Cog3pioBackendEntrypoint(BackendEntrypoint): description = "Use .tif files in Xarray" open_dataset_parameters = ("filename_or_obj", "drop_variables", "device_id") - url = "https://github.com/weiji14/cog3pio" + url = "https://cog3pio.readthedocs.io/en/latest/" - def open_dataset( # type: ignore[override] + def open_dataset( self, filename_or_obj: str, *, @@ -53,13 +53,13 @@ def open_dataset( # type: ignore[override] mask_and_scale=None, ) -> xr.Dataset: """ - Backend open_dataset method used by Xarray in [xarray.open_dataset][]. + Backend open_dataset method used by Xarray in :py:func:`xarray.open_dataset`. Parameters ---------- filename_or_obj : str - File path or url to a TIFF (.tif) image file that can be read by the - nvTIFF or image-tiff backend library. + File path or url to a TIFF (.tif) image file that can be read by cog3pio's + nvTIFF backend. device_id : int | None CUDA device ID on which to place the created cupy array. Default is None, which means device_id will be inferred via From e31bb63842794a48ea60d6e6e42346d16713fda6 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Tue, 26 May 2026 22:37:26 +1200 Subject: [PATCH 12/16] Install cog3pio=0.1.0 from conda-forge Get the stable version v0.1.0 from conda-forge instead of TestPyPI. No need to depend on libnvtiff-dev anymore, as libnvtiff should be pulled in, at least for linux-x86_64 and linux-aarch64. --- .readthedocs.yml | 5 ----- ci/doc.yml | 2 +- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 03d6b1d..d67aad8 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -5,11 +5,6 @@ build: os: "ubuntu-24.04" tools: python: "mambaforge-23.11" - jobs: - post_install: - - export CONDA_PREFIX="$CONDA_ENVS_PATH/$CONDA_DEFAULT_ENV"; - mamba run --prefix "$CONDA_PREFIX" pip install --verbose --pre --extra-index-url https://test.pypi.org/simple/ cog3pio==0.1.0b2 - - pip list # Build documentation in the docs/ directory with Sphinx sphinx: diff --git a/ci/doc.yml b/ci/doc.yml index 1bd2f9b..2d170f6 100644 --- a/ci/doc.yml +++ b/ci/doc.yml @@ -2,6 +2,7 @@ name: cupy-xarray channels: - conda-forge dependencies: + - cog3pio>=0.1.0 - cupy-core!=14.0.0,!=14.0.1 # https://github.com/cupy/cupy/issues/9777 - pip - python=3.13 @@ -12,7 +13,6 @@ dependencies: - ipython - ipykernel - ipywidgets - - libnvtiff-dev=0.6.0 - furo>=2024.8.6 - myst-nb - xarray From 0e0232f0fe29c7ef548b43cff4da3d23623c8adc Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Tue, 26 May 2026 23:05:28 +1200 Subject: [PATCH 13/16] Add tiff extra for linux-x86_64 & linux-aarch64, and update install docs Optional 'tiff' extra to pull in the cog3pio dependency for reading TIFFs. Updating install instructions in docs/index.md to mention this. --- docs/index.md | 22 +++++++++++++++++++--- pyproject.toml | 3 +++ 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/docs/index.md b/docs/index.md index 3025717..b400480 100644 --- a/docs/index.md +++ b/docs/index.md @@ -18,13 +18,12 @@ CuPy-Xarray is a Python library that leverages [CuPy](https://cupy.dev/), a GPU > `cupy-xarray` will use an existing cupy installation, hence cupy needs to be installed manually! Please follow cupy's install instructions at . -CuPy-Xarray can be installed using `pip` or `conda`: +CuPy-Xarray can be installed using `conda` or `pip`: From Conda Forge: ```bash - -conda install cupy-xarray -c conda-forge +conda install -c conda-forge cupy-xarray ``` From PyPI: @@ -39,6 +38,23 @@ The latest version from Github: pip install git+https://github.com/xarray-contrib/cupy-xarray.git ``` +### Extras + +To enable the [`cog3pio`](/api.rst#module-cupy_xarray.cog3pio) backend for reading +TIFFs (only available for linux-x86_64 and linux-aarch64), do: + +From Conda Forge: + +```bash +conda install -c conda-forge cupy-xarray cog3pio +``` + +From PyPI: + +```bash +pip install cupy-xarray[tiff] +``` + ## Acknowledgements Large parts of this documentations comes from [SciPy 2023 Xarray on GPUs tutorial](https://negin513.github.io/cupy-xarray-tutorials/README.html) and [this NCAR tutorial to GPUs](https://github.com/NCAR/GPU_workshop/tree/workshop/13_CuPyAndLegate). diff --git a/pyproject.toml b/pyproject.toml index e7cbccf..eff1cfb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,6 +23,9 @@ dependencies = [ cog3pio = "cupy_xarray.cog3pio:Cog3pioBackendEntrypoint" [project.optional-dependencies] +tiff = [ + "cog3pio>=0.1.0; platform_system == 'Linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')" +] [dependency-groups] test = [ From 363e21cd7979c98cd45c98953e8e4b7062542646 Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Tue, 26 May 2026 23:11:30 +1200 Subject: [PATCH 14/16] Try to future-proof for either 3-D or 1-D array shapes So cog3pio v0.1.0's CudaCogReader only decodes to a 1-D array for now, but hopefully will return a 3-D tensor shape in the future. Try to future-proof things by adding a `if array.ndim==1` statement to gate the case when a reshape is needed. --- cupy_xarray/cog3pio.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/cupy_xarray/cog3pio.py b/cupy_xarray/cog3pio.py index 066781c..1df2e95 100644 --- a/cupy_xarray/cog3pio.py +++ b/cupy_xarray/cog3pio.py @@ -2,6 +2,7 @@ `cog3pio` backend for xarray to read TIFF files directly into CuPy arrays in GPU memory. """ +import math import os from collections.abc import Iterable @@ -75,13 +76,15 @@ def open_dataset( with cp.cuda.Stream(ptds=True): cog = CudaCogReader(path=filename_or_obj, device_id=device_id) - array_: cp.ndarray = cp.from_dlpack(cog) # 1-D Array + array: cp.ndarray = cp.from_dlpack(cog) # 1-D Array x_coords, y_coords = cog.xy_coords() # TODO consider using rasterix height, width = (len(y_coords), len(x_coords)) - channels: int = len(array_) // (height * width) - # TODO make API to get proper 3-D shape directly, or use cuTENSOR - array_ = array_.reshape(height, width, channels) # HWC - array = array_.transpose(2, 0, 1) # CHW + channels: int = math.prod(array.shape) // (height * width) + if array.ndim == 1: + # Workaround to convert from 1-D to 3-D shape + # TODO remove once PyCapule returns 3-D shape (e.g. via cuTENSOR) + array = array.reshape(height, width, channels) # HWC + array = array.transpose(2, 0, 1) # CHW dataarray: xr.DataArray = xr.DataArray( data=array, From 19dc6e322de6f29dbed78d073603b5e8e057d82e Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Mon, 8 Jun 2026 22:15:54 +1200 Subject: [PATCH 15/16] Init tutorial page for cog3pio Write up overview, prerequisites, and a short section on how to read an RGB GeoTIFF from a HTTP URL. Also show the resulting image plotted. --- docs/examples/07_cog3pio.ipynb | 855 +++++++++++++++++++++++++++++++++ docs/index.md | 1 + 2 files changed, 856 insertions(+) create mode 100644 docs/examples/07_cog3pio.ipynb diff --git a/docs/examples/07_cog3pio.ipynb b/docs/examples/07_cog3pio.ipynb new file mode 100644 index 0000000..11cd4b3 --- /dev/null +++ b/docs/examples/07_cog3pio.ipynb @@ -0,0 +1,855 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7925d0e3-47d3-4b99-8182-9551d83c5304", + "metadata": {}, + "source": [ + "# Reading TIFFs to CUDA memory" + ] + }, + { + "cell_type": "markdown", + "id": "572a6638-416d-4344-9718-2bf8fc7c37b7", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In this tutorial, you learn:\n", + "\n", + "* How to read a GeoTIFF into an xarray.DataArray backed by CuPy arrays\n", + "* Understand some of the limitations of the `cog3pio` engine\n", + "\n", + "## Prerequisites\n", + "\n", + "You will need to have a CUDA-enabled GPU (Volta generation or newer), and be running\n", + "on Linux, either x86_64 or aarch64 platform. Please ensure that you have installed\n", + "`cupy-xarray` with the 'tiff' extras that contains the `cog3pio` dependency, e.g. via\n", + "\n", + "```bash\n", + "pip install cupy-xarray[tiff]\n", + "```\n", + "\n", + "or if you are using conda, manually install `cog3pio` via\n", + "\n", + "```bash\n", + "conda install -c conda-forge cog3pio cupy-xarray\n", + "```\n", + "\n", + "There may be other system prerequisities needed by the underlying nvTIFF library used\n", + "by `cog3pio`, which you can check at\n", + "\n", + "\n", + "## Introduction\n", + "\n", + "In this tutorial, we will learn how to read data stored in a GeoTIFF format into CUDA\n", + "GPU memory. This will use the [`cog3pio`](https://cog3pio.readthedocs.io) Python/Rust\n", + "library that contains bindings to\n", + "[nvTIFF](https://docs.nvidia.com/cuda/nvtiff/index.html) which does GPU-accelerated\n", + "decoding of TIFF (Tagged Image File Format) files.\n", + "\n", + "Let's now import our packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3050505e-8890-4a4c-b896-6bc3f5b8f58c", + "metadata": {}, + "outputs": [], + "source": [ + "import cupy as cp\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "id": "0a8c58ff-8e69-41cc-bee5-c3995c028343", + "metadata": {}, + "source": [ + "Check that the [Cog3pioBackendEntrypoint](../api.rst#module-cupy_xarray.cog3pio)\n", + "engine is available:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fb3dea56", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'netcdf4': \n", + " Open netCDF (.nc, .nc4 and .cdf) and most HDF5 files using netCDF4 in Xarray\n", + " Learn more at https://docs.xarray.dev/en/stable/generated/xarray.backends.NetCDF4BackendEntrypoint.html,\n", + " 'cog3pio': \n", + " Use .tif files in Xarray\n", + " Learn more at https://cog3pio.readthedocs.io/en/latest/,\n", + " 'store': \n", + " Open AbstractDataStore instances in Xarray\n", + " Learn more at https://docs.xarray.dev/en/stable/generated/xarray.backends.StoreBackendEntrypoint.html}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.backends.list_engines()" + ] + }, + { + "cell_type": "markdown", + "id": "527550ff", + "metadata": {}, + "source": [ + "## Reading a single RGB GeoTIFF\n", + "\n", + "We'll first read this\n", + "[EOX cloudless mosaic](https://source.coop/pangeo/example-tiff/geotiff-test-data/real_data/eox/eox_cloudless.tif)\n", + "(low-resolution version) GeoTIFF file with 3 bands (Red, Green, Blue), compressed\n", + "using Deflate. Use\n", + "[`xarray.open_dataarray()`](https://docs.xarray.dev/en/stable/generated/xarray.open_dataarray.html),\n", + "passing in the HTTP URL to the .tif file, configure `engine=\"cog3pio\"` (shorthand for\n", + "`engine=Cog3pioBackendEntrypoint`) and set the `device_id` parameter to `0` to read\n", + "into CUDA GPU 0." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "020a73bd-5afb-4909-a5c1-53e4e8096426", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'raster' (band: 3, y: 256, x: 512)> Size: 393kB\n",
+       "array([[[0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        ...,\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0]],\n",
+       "\n",
+       "       [[0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        ...,\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0]],\n",
+       "\n",
+       "       [[0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        ...,\n",
+       "        [0, 0, ..., 0, 0],\n",
+       "        [0, 0, ..., 0, 0]]], shape=(3, 256, 512), dtype=uint8)\n",
+       "Coordinates:\n",
+       "  * band     (band) uint8 3B 0 1 2\n",
+       "  * y        (y) float64 2kB 89.65 88.95 88.24 87.54 ... -88.24 -88.95 -89.65\n",
+       "  * x        (x) float64 4kB -179.6 -178.9 -178.2 -177.5 ... 178.2 178.9 179.6
" + ], + "text/plain": [ + " Size: 393kB\n", + "array([[[0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0],\n", + " ...,\n", + " [0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0]],\n", + "\n", + " [[0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0],\n", + " ...,\n", + " [0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0]],\n", + "\n", + " [[0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0],\n", + " ...,\n", + " [0, 0, ..., 0, 0],\n", + " [0, 0, ..., 0, 0]]], shape=(3, 256, 512), dtype=uint8)\n", + "Coordinates:\n", + " * band (band) uint8 3B 0 1 2\n", + " * y (y) float64 2kB 89.65 88.95 88.24 87.54 ... -88.24 -88.95 -89.65\n", + " * x (x) float64 4kB -179.6 -178.9 -178.2 -177.5 ... 178.2 178.9 179.6" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Read GeoTIFF into an xarray.DataArray\n", + "dataarray: xr.DataArray = xr.open_dataarray(\n", + " filename_or_obj=\"https://data.source.coop/pangeo/example-tiff/geotiff-test-data/real_data/eox/eox_cloudless.tif\",\n", + " engine=\"cog3pio\",\n", + " device_id=0, # cuda:0\n", + ")\n", + "dataarray" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5043393f-e675-4d17-9775-f36d5f053ff6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "isinstance(dataarray.data, cp.ndarray)" + ] + }, + { + "cell_type": "markdown", + "id": "15f000b0", + "metadata": {}, + "source": [ + "That was quick and easy wasn't it? You now have an `xarray.DataArray` with dimensions\n", + "channels/band: 0, height/y: 2355, and width/x: 2325 in CUDA GPU memory!" + ] + }, + { + "cell_type": "markdown", + "id": "4acd27fe", + "metadata": {}, + "source": [ + "We can plot this RGB image by calling\n", + "[`.plot.imshow()`](https://docs.xarray.dev/en/stable/generated/xarray.plot.imshow.html)\n", + "on the `xarray.DataArray`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c73d5daf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGwCAYAAACpYG+ZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfQW8ZWXV/rN779Pn5tw73UwwzNDdJamEhITSDYJIl9INIl0CAoqIqEhL15BDTvftOL07/r+19p2BEflU/n6fwVl4vTH3ntz73etdTwlRFEWoV73qVa961ate9foGlPivfgD1qle96lWvetWrXv9XVW986lWvetWrXvWq1zem6o1PvepVr3rVq171+sZUvfGpV73qVa961ate35iqNz71qle96lWvetXrG1P1xqde9apXvepVr3p9Y6re+NSrXvWqV73qVa9vTMn/6gfw71ZhGKKzsxPpdBqCIPyrH0696lWvetWrXvX6O4psCSuVCtrb2yGKXz3XqTc+f1HU9IwcOfLveY3rVa961ate9arXv1mtWLECI0aM+Mp/r0Ndf1E06alXvepVr3rVq17/ndfxeuPzF1WHt+pVr3rVq171+u+9jtcbn3rVq171qle96vWNqXrjU6961ate9apXvb4xVW986lWvetWrXvWq1zem6o1PvepVr3rVq171+sZUvfGpV73qVa961ate35iqNz71qle96lWvetXrG1P1xqde9apXvepVr3p9Y6re+NSrXvWqV73qVa9vTNUbn3rVq171qle96vWNqXrjU6961ate9apXvb4xVW986lWvetWrXvWq1zem6o1Pvdao7x93An/+wXGn/F2vzEkXX4GTL7rsf/yd7x1x7N/9Ku9/yA++9jty2tln49Szzvry/R99zBrfH3LkcTjsxNP46yNOPYM/n3TOef/jbR9x4g/58weLFuGI407kr48+7qQ1fuf4k07GyWcc/nc91l2/s+Ua319123XxbR7+LZx1wXH4Z1Sw+Mf/47/vfcD3/+rPOxY/u8b3Yfjymrfb8y6Cwkdr/OytP9+8+uu77joXJ562Z/z1D9db/fObTpmB/5868PCjcPBxJ/PXPzjtfP583E+vXeN3fnjDzTj3vkdx9j2P/F23eeyZ537lvx18+JrH7YnnxPe5qo770Tn8+ZjTz/78/s+/ZI3f+cHQ+fSXdcIFF67++syr4/ee6uwr4q9POvdSHHfWRat/ftblN+L4H31+P3y/p5z+pds9+/Lr+fNFN9yGi39+Ny64/nb86CdX4fCTz+Sf77Hfwat/d5e9DuDPu+594Oqf7br3fqu/3nnPfVZ//f0TfozDhm7jByeehiNP/jF+cOKPVv/7EcefgqNPPQNHnRofc4cfH59fh534I/7do06J//bo0z4/Pw854Uc46NhTccDRp+DAY07GwcecjAMOOxZ77n8Idt5tH2y/027YdsdvYZsddsXm2++CjbbaARtuuQM25o/tsdFm22ODzbfHhlvujE232R1b7PBtbL3LXthxzwOw274H8+3ssW/83A487Bh+fCed8xOccs5P+GfHDp37q+q4s36Kk86/Aoef8uU1pF7/XVVvfOpVr3rVq171qtc3poQoiqJ/9YP4d6pyuYxsNov/9jr6R2dDVBTcctnnu0qqY370Y9x69ZVf+XeHHH4E7rvrztXfn37ZtbjqrFP56/0PPgQP33/f3/0YPpy/GDMmjcPXrcdfeBd7bvP5ROGv1ayNN8L7b77FXydUGZYX4KsO+a6XLoI7/TSMbkzhlJMPw/U33P03H8OPzv4JIvovCBGFDq676nJ8urSMm6//Kb67x9bYcttdV//uopWdqJgKBmq9GN+oYMyoSV+6vaOOORK333oHNt5iU7z39kdw7coa/x5GIURB/MrvV9Wjr8zDJO1TrL3hd/j7gXdvx5vzivh4fje8chnnXvv5e/h1qvzZK8hM2WL19+9+uAzrzRjNX5+112Yot03Bz39+J8679KcQJAVWpYKrLl5zGnL2OWcgCoHLLrviH7rv7534Y0iqAS2RgppOQQJgV8u4/SfxDv7cBx6DIMqwSmVYhX5YpQHcfcVPcPCxJ+P+W27g3zn2zAuhGTquv+BMnHrxVbj23NNx1Mk/wu03XP2V9/ujn1yCq8+Ppzx/rU676HJQKPTV58fTjb9WR592Gm675hqcfNFPccMF8ZTxgptugZFKQIoA23Jw3nFHrfE3Z1x1ExLJNC447tA1H8+Fl+HqCz+fTtB0RzeSOOvo7+HiW+6jiGo4toXBvj70dHWh3N+HmlmFa1v8+4qiQ1JkiAiB0Merr7+FzTfbFJ7nIQxDQFKg6xqMZA7N7cMRRh7gOXjg1htw7Jk/4ffVtU3cec1Ph57b2bjtmktxwo/Px01XDk1Vfnw+bhn6+ocXXY4wCHHDT87GoSedCT+M4vsKAsiSAFmIELguarUyzHIV8+YuhCwFsF0Xo8eMgeMFCKIQUhQf71EY8d8GfD5LECQJsgSIsozl8z7FxGnTEAoCFFlGOpNBJp9HSzoNT5YhCYAsS5BEmW/r2ksu4M+nXHgVrr/wy5O0ev1nValUQiaT+c9vfHzfx4UXXohf/vKX6O7uRltbG77//e/j3HPPhSgOnQhRhIsuugi33347CoUCNtpoI/z85z/HtGnTvlGNz+nnXoSrLo5P5LMuv47OcHheBN9x/upJfdxZ5+Lmyy5e42c0uo4CH4cddRQ2W/dziOKUs8+HXTVx641X45SzL+TXfv21mjFnhY0rzorhoFX16kfLsPna8cXwq+rQww7DL+7+6w3GbnvuiT8+/vg/9NyH6QK67a8+pP9aozDoRGjQBLz67lzUXAWu2YEFb/8Bp555FU4/4yyceMZFGNWgfum2Hn/qOey58/b/0OP76I0H0TxpZ3zw1h9R8Q0888fnYToOXKiY/erTWLZo6Zf+5v0Hj8GsA2/Ff2Ldct1FmLDWTOzwrRj6euh3z0AoLcD+hx7/N/82Cu+GIB6Ga39yFB588iO888Yb/POTjjsOK2shJD0JJWHgwevWPHaPvfQG3HJ2DIl9/8yf4t7LP4cxv/vdA5BsGYZ7bvocXjrt0mtwzdkxNPOXtd/B38ev7r8Xv37oPnz3gENw3nU3QlVVnHf8Mbj85jtQrdVw8elfDQsfdfzxuP3nP8c/UgS73nhJ3Ex8sZ741X3Ydb9D+OtTzjofsmZw43PcaWfh5msuw+mXXAsIEizbRuBZ8P0QZq2G4kAfBnr78OHbr8Cq1aCn0gh9D6Ikwa7VVm8EMk1N8Gybf7aqttxlX+Rb2pBJp3DfjZ83ridccCX0VAaeY+OGc0/B4Sf/CHd9oWk84+Kr4Xkurr0ohudOPOsCRIIA07JRLZdhmhZsx+XGB2EITVGgaQr+8Kv7sMu394ZjOwg8D4Ig4YXn/sS3sfGW29CvQhQlvPnyc6vva511N8WH78fHxhdr0tR1gAiQNRWffvA2dtr7AGSyWfz6rlvW+L2rb74DPzruSKSTeRz2w9NQK5dw541X/UPvWb3+sxqf/xio64orrsCtt96Km266CZ999hmuvPJKXHXVVfjZz362+nfoZ9deey3/zttvv41hw4Zhhx12QKWy5q65XvWqV73qVa96fTPrP2bis9tuu6G1tRV33XXX6p/tvffeSCQSuP/++3nX0t7ejlNOOQVnnBGPvB3H4b+hpunoo4/+xkx8aMpz2Zk/xLk33oGLTzry859fcxsuO+1onHz+FbjhJ2fghPMugSgAN/4kHt+XB1ci0zDib97+EcedjHzCRzXUcMu1Mbn0pB+djhuvvgoPPPI7HLTvt//ux/q9Qw7FL+/7xervR00Yh+ULF/9Dz/fww7fEXXetScD9Yj39u/vRNGY9rDdz6ho/v/LCU/DjC6/HjcdvDXn9ffDBK69i/1POx4J33sDRh31OUn7vtSew7ma74o0nbsf4bY9EiyF85X2F7nMQ1a+eAp161smoVBXcf9etCEMfrm2v+ffhMohiPCULq7+BmPqcYPrfUM+dsyFWRE3Q00044Kz7cNEhG+OC+978h25j2vQpmDF9Cl547kVM3mgbeP2dMBIJCKk8lGQSeiKNUJAQMmTjwSdox/fR8enbmLD+FvCqBTRmDdx3/8M47IdnQlI13HHFRdj/iBPw8J038X3svMeeeOr3j2PHb+2GKAqx1sR26JqGIDcCyUQSiqRACANUyyVcc+mVWHe9yfjowwWwa8UvQak/PusUXHlZTDr+OnXA0acjkckhbchwrQpuvupi/PZ3T+DRP/6JJze777Y9HLOMx596HY7nwbYtvPjHRz+/AZqIhyHaRk3gb2VJgqqpkHnKomPO26+tcX9bbPMtvPLCk9h0u13w4ezXsON+h+O3d35OIj/4uNNw/83X4Izr7kbgO7j69DVJ4OdccjUCAKZZg1Ut4Y4brmWBg+O4vL5Wq1W88eenvvQ8V71u3z10P5jVKv746BPY53v74je/fATb774TRF/F8BGj0NGxkqc+/YP9GN7SisamZhSLJeipJALXw4K58zF/0SdQZRGFwcIat/2Xdd0ttyDf0Ag3CNAzMIjzTlxzEnnA4cfiob+YENXr37/+a6Cuyy+/nCc+zzzzDCZNmoQ5c+Zgxx13xPXXX48DDjgAixcvxvjx4/Hee+9h1qxZq/9uzz33RC6Xwy9+8fnF9YtFzRF9rCo6MUeOHIn/xDryxFNxx8/iBerCmx9AJEq46JgD8MNLrsd155yCM6+/B4Iowq1Vcc1Zx+OYMy5AEBI3xYcQRBAQ4vbrv8zvOfnMn+KGL8AFq+qDD97BzJnrr/7+witvQ1fPUiiihJuuuhj7HHgwRGYQhGgesRZuufKr+RFfrN89/ht8e899sOuue+CJJ36Pf2a99v7HePSX9+Laq6/GU+8swc7rj139b0dtnENftYQdf3gzZqw/Dsu7SnjoluuxkVKBZTTAbVkL7VPXQr6pHWPGTMFW68QQ4DNP3YMdd47VaMs/eRqjpu3EX++0697YebdvYcniD/DCq+/ALNYwfnQbnn36Wey+6874/R+fxDexbj5+cxz381e/1t9us8MuqJgW3n39Rayz4eaYM/tVrLvxluhYthgjx06CqBsMRRFEQhyQIPAReHR+R5AlEYqmQ5Jk5r/QB/FB6JwgjpZnW7CtCn8OfA+SLGPJovko9PWtvv/9Dj0CD997x998nNvusDMURcbTf/ojf3/KaYfg+mu+zH87+NjToSZ03DXEk/miuvLem29CLjcGG2y7FWRFR0KX4Lo1WAwVmXjjxWe+8v5pzVOMFBRZZy5LX18/dF1Bob8bw4aPhaKqWLFkHiZOm8VNYzKZhKEbOHDfXfDep8vw86svwSFHHAffMdGxtBtSPgffc/Hyk7/Fdw46Ao89cCeOOe8KXjus0iDuu+kavt+DjjweqpGA6zqoVaswqxVuxFzbZf6SbZuwbRej2pqwYMlSrLveeujtWomurgGomoLQC9HVsxJrz1wHb7/2CrbYZnvkhuVRLlWw0drTsHhFL/qLA9hw2lqouQESuTw++2QBPMeEAB9BKMXveeDB9wNEYYglc+fzbZ54xbXIMZxn4fLjP98Ir5j/R4yctNsar99p190JN4zQv+BjOLUybNOERceF6+LlZ7/ctNXrP6vxiZld/wFFUxx6MmuttRYkiQ7uAJdccgk3PVTE+6GiCc8Xi75ftmzZV97uZZddxrygetWrXvWqV73q9d9f/zETn4cffhinn34683qIrPzBBx8wrEWcnkMPPRSvv/46NttsM3R2djLxeVUdeeSRWLFiBZ566qn//onPyWfijhsux6mX3gQ92wBBEHm3cvXpsUrkx9fdA1nTGF6xywXYlSIrMg4/7TxIisK/T6SvEBEdGLj18vP/5/s76Ue448arsf8hh8EPQoYXaGoU+QF++/B92GHX7yCbTSHX2ILBvh74joffP/arNW6jbcwEfGv3HVHsGsBvf7Pmv/2t+tMDt6CGAQyf+W088ou7cN1VMWH1uFNPxs3Xxuodqosu+ykuOOs8fHuzqUiMmYz++W/jmbdXxr976J64+RcxgXq3bWbBDgEhmURKcLDLiefBXLYQT771NkLbwcyxLbjykltx85Un4Lgfx5BIR9HG8JzOX9//8G9x8P578ddbb7cTLJt2oD5kwcdbb7zO4/ZMSyM22HYbtCcC7NLm4IBLYuLmN7GemfMcdlznc1jQjSKoNIn5itpp1z3w9BO/ZwimfVgLVqzsQBSQSk+AHwYIQoJ1SKlDtyFCEAT4ngfftfl9oKNbVCSE0ZAiKAr5g471kBVCHjzPQeA6CH2fBRWhF8CPfEiCAC2RQE/HitWP59QzT8cZJx2D6y8+C5fd/Ov/8bkecOgeeOyhP2CjLbeEVQnghyLef6cDu++/A1K5NMQogOtZPEFRJBEP3nnb6r/ddJvdmAhcHuiEIUlYsGAemkeN4amUEImIBIJyAoRBvJTTtEsQBTQ1tqJqVlAc6IEokmpKgB/JSKoSmtva+bmWajYUVeepj6EZkGQR4dBt0etK01pSTTmWw5CfqsgwDANayoChJ3m1cC0TlllF4IcQZYX/jkjPpChzXZdfRyIquz5Nl0MWTfBjpveOHjBdgmj6xqosBaouQVUVhhNpWjVYKGD4iHZUazYacxmIsgi6gVrVwpjxY1AuldA8bBjKhQL8IFaKBXSftBZFESRNx0t//B1OvPI6NAwfDvghLjp0/9Wv7xX33ovSytm49Nybcdx5F+Hmn16As+/+DSvIrjj8u2u8j9vvsx8TxF3H5SmhJER468Xn8e9Q2+/6HTz3xGOrv19/s+348zuvxY9vrenr8oRfVlUkk2mkkkm8+Mw/d6L+71L/NRMfanrOPPNM7L9/fMCuvfbaPMmhiQ01PkRkplql+FpVvb29X5oCfbE0TeOP/4aipocqklVuRGi8P7QW4viLfwY/INVqgIA+Q1wtQxUVHaKqkaiVF6jbLzsLx15wDY6/+EYIIslEI/hmFbdcFMt0DznpdIiCBNvzsN9hx8PlCwtdPHxufFYsX4E9yAhNEPiCUqw4kOl2lC/32F1LF+Luny38Ws/3/c4SUuk0njh+FxR7OrDFthvjlT+/iVQ6hT+9+Bg+uf5UzDU1bnpueeAXUDQDR+z7XVx1x5145u0jcMGNNw81vY/jjKuuRrYhD12VMWfOW5g/bwmmTpyE52c/jalSBXpLBg6t1tQsDTU9VLf8/HP1BzU9O+2yG8MbixcvRxR5sOwK+rt7Vv9OuXcAzz/8G/76fnzz6rWrvoXNTn8ST+0m4M8P/3KNf6OmZ9ykViye34N9v/tdPPLrNZsJgqmoEuksipaHbL4Rz/zuYf7ZJtvvDtelxiWA5/nwPYePR891Wb5NCiNqdiBGMQQW0QU4YNk2X4CFuPmJwgACXZipGaIPulgjZGTM9T0MGzWO1VQdCz9Fx/IOtLaPx1oTx/BjOO2Sc3HNObHC7JGnfoeLz72Sm4gglYFopLHlzjvjmd/H8CY1ZVTV8iAkmW4/4mORGjVNEbH3QYeywqpcrvLjqhU6sGj+p2hoHQEjl0epVObbkAQJoiTyeRpvWkRIJPAXBAwU+kjGCE1L8XPg11CSESgK+goVXhvITsD3HbheiJpkAgJYcs6NIf0XhvB9ah69GC4URYiSwBslSRSxfOEnGDV+ympZehSJCEJqnKjpCCDQoxIQrw9E/EEIiShH/GXEXCBuPHlpCCCJHmw3lqBLksiwJDVlNdOCpquw6XG48Try3ttv4LOP52DCxHEY7OtGQ+swuLYPy7FZ0UYqMu6F3QBb7r4POpcthxcGSCRT+NGNtzAIL8kKBk0fpjqRb7PmBTjq0htg2SY/3yPOuwh3/vQCHHrGmfycCO6SSxXUaiYfD8QpmrXFNvBsE0IYQpVlvPvWlxVm/6zabpe9EMgShEjg5o7WXs/x+FjtHyxg+rqbwXcdOKGP/v4B/pvRE6fx8T8wOMjHhaSqcLyQ37P1Nt8+thJQJOiJFJKpDFRdw2/u/u/mNf3HqLoI014lW19VBHmx3wSAsWPHcvPz7LOfu87SbuOll17Cpptu+n/+eOtVr3rVq171qte/X/3HQF3k2fPcc8/htttuY6jr/fffx1FHHYXDDjuMVVtU9JkmQPfccw8mTpyISy+9FC+++CLmzZuHdDr9X6/qOuH8q6EnMzzxoR0g71p92kX6vKMiEiftDHzX5XG+61i8K5MklZtIn8zAggC/vO58HHXB9ayQobF56Nu4+aw4RuGgE89kOIEgAMeuwrUs+F6AJ39zL/Y8+Ag8fv/nxnijR0/GsmXz/ubjJo7VBRfEvkN/rW686SZEsoRCqYyKZeGaCz+3+7/jlw8ginwcddCX4xeuuu5ynP7Dz83k7n3yKXz/WzvjriefwuHf2hlXPvAQqsUSfnJCHGnx07vvRj6XwvwXH8XIWdtBFCLAtfHM+3MxMylhbW0paqM2wNFHf/mx7nHgwSgNFrBg7icYNbwdC5cshggFfV0rkGlqYDjh6MMOxGcLl6GhqYmnjD+/+joccdJJvPNaf8ZaOPHY2HvmP62OOuYY3H7rP+YzdP+NJ2IJWjG6KYtDD4wjQL6q9j34EDxy/33Y84BD4TIZX2JvKjIupF2vH5A6zuXNEUEyjm3Cskw+vonYzJMU34fIkAoNGmjCQNOIGPIiCIeKjfAIGuGJDP0kJF+/1dMSOhd8jyYBcZEJHpnwfbF23GMflItFLF28FD0di4Z+qqN53AgccfwJGDdMx4MPPYVqxWJIOJ3NIpNNIQhCVCpV2JYd78Blmaev1Wot/qhUUSkXGKqgBy6KMjRSZskxHES/TxOggKaS5D0oiZBFgSGueNIVn//0HCDKCAgS8kOGAX26zWhoEhb6DKFFAT1rmtz4PDmL/IgsgiDS3UvC0LQJKJf6kGts43WE7pcmPvQQCG4kWFGVNX4sQRTAcwJ4Pr3uNEWLN7E88QljOI0egyjQpIYmPXQf9BqLMDIpGLoGVdN5YkUTJxECGrIGihWbnzt98PTOsVByCOQSIagqQoLrAp9f00Q2i6bmRmRbWpBKZ6EmDEBW4PoBapUqfnXJedjj+B9BMWIUgKZbkVmAEHqQhJCnVzRJshwXZhjBhQjLclHt64PV343AdqDIInRZgUjGkATVKSpef+Fzz6H/31pvy534NQv9iKeDtmezPxtBs3Ss03tHazh90DrNHP4ohB94/P7SpE4lAYCuQ1VlIBRAtmaqqiOda0C+qRHJbBa/ve1GHH7m+QyL+Y6Lu66ITSj/U+q/RtVFXjznnXceHnvsMYavSLpOxObzzz+fVRxfNDCk5uiLBobTp0//u+/nP7nxOebsy6HqKYQ8GYsXwDAinkmIgBUOEV8ASHFBzQrxCWhBItdTKnYfJvxT15BIp6EYBkNjjl2DQ15Igc0LLjUEru3ANKtsZkiNVboxh3xTHg//7K+7PofuHyCqu/PX559/Hn7yk5/i+uuvgSQpOPHEzzOvzrnoQlzyhRwjqtvuvhtHH3bYGj+74tZbccYxccNy72OP4vvf2Rs/u/0WmKUKCpUyIlFGNpPEmaeciFMP2hLn3f0MHn3mJejZPBRJYvijPDCIE/eLMfyTzzgCN1xxJ3548n647obPuUbX3nYxUBxEz5LPMHX6RIxaZwsYeh4bbxBzUw4/8Tj09pfwx4cfxIS1Z7HihsbkNG0kmIQuEMRXKPT3YOMtN8eihXNx2U8uxZsffgRBVnD7NbEa5r+9Pv3wMUydEbtIU11z/UWYM2c27rvnCf7+jAM2g9A6DJdf/ygOOfJI3HfHHdj7oIPx6AMxILjXIYfDdX3YdNwGQCRJrEQkngo1jq7jwDJNVt/YJKO2Tfg2XdQ9Poapj5G4o4kvBgyBMBcohmOpvaEGiM4chS7aMjkaRxjo70UinWN4mIoaJoJ5FUVlrgvBqqlMhiECRVFQrVVR7O/HkgUfI5luQBSK0FI6kpkMcrk8kukkuwV7BNlEAhJJgx2kqXErFUuoVWv8eOKGJeDjiBo3+n2HrQ9C5u/QfSWMBK99iiYxH+aj99/CtJkbxbwWUcJHf8XUb1VNXX87WLbL57br0bHqM5RDsBdtjPh75j/FcCBtjKjBsqokD6fXLX5BRoyZCJH4OUO3u3TJfIybNA2L53/C33/x8jJ93S3Q3bVy9TrDmypqdIgfSM3Q0PswBITx39L5YyRTrPhSVY2fL6nz6D75d/wAITV1Q4+BYU56/qoOOZHgBo7O9ch3WL4/7923sMW390a2oQlGYwNkIwGfHLOJ62nWIDo2It/l5y0LQM/spxCs6MamO23D/CG7Yy685jSc9k0RGCm4AVDp68fLv/oV1FQekye0YWWQQGFFBzacMhJyIgXNSLLztmYY3LA9cs/fVgV+sdbfdEt2rSYo13EDbmKocV3V5FBjGlfsSk+vJ/mUMBwpE3eT1n+PUF5oyQRSDY3QUwm2ezDLRTgmNY8KMrkGNJBZZWMTkukU/4yONdrkEq+JmmQ6ZYjJSVyt39z972uq+l/T+Pxf1X9y43PQMT+CpFATKDC+TUsB7aTohA0JYI9I3hvCY6knLfS0w4sXGDoKuAkaWtSp6aEdInMkzBpLWVVZ4J0QrTmOaaJaIWv5Ei/aTWNGYOS4MRg+shWZhIrzjzyCH9NNDz0EXVdpCwi7ZuKEA77HPz9wqyl48KXPVj/2K6+5DD8eCjC8+Obr8Nr77yLh1/DoPY/hZ3fegROP+NyPiOq6++/nRZBIp8d897u48zeP4Ih99v3Sa0ILYr51GAa7u/j7u556AogsaKVO7LL7d9CQHIkLrrmSd0cX/TB2773p0V9DlFXYpSJOPWTNSdKPLzwXlUoNg32D+NV9v8DRJ/wAb87+DIMD/aiWqnFTSTwq4pDwRjsmbdKinSRybOdSJFUDJ513PIpLO7G0RhM1suq3cPYP98Ol1zwIz/fx4pN/+KcfH4cdcwzu/gcnM/+/deARx+HBOz8PMKU6+5xTsM4m66C7cwBhKOCHx5yGX/zmQZi2i2O/MLnb5+Dv82vohXRBC2DbDnM86OLGkmWXmnKaOLrcIBDh1HcteEROHuLp0IWULpJ00VMVKY5oEGgqIcb+NlRhTOanoosE8TQWLZjL34+bOIVvm6cjQQjTignI1NDIssiTPN3Q0LOCeGo8Q+K/07QkX5zoEk7ScSNB0Q9pPn/oYkRFDZSqq1h7rZmY/dZrfF4ShyQMaBdOvB1iANNxxG0aFIUmNuBJhK6qmD9vzaDYv1Vb7rA7vFCE4/gwTZunYjZ9ODb7AVGDE/ouAs/lSRo3Hvz6gS+EhpFAd8ciTJg6C0Y6iWQqjTeGXJX/snbeex9IlB8RRBjRrsDxPcz7uANLFnfxpquhqRnpRAJ9gz2olKu8Tq2avPGkmqY3Q1cmmmzxBEuSoegaT33i3wsQeDTdCZkGQb9D7wE1aYqu8weveZ7NPkbt06ahtHwp3nnlTWz3nV2RyDdyUxqKEt8/Tdgis4rhw5tQNR10ffoxvDmvQdZVyJksQklD5NSQa50At2s+oqiGSWfeAaP7E6x89nGyiIbluizZV+0KHKsGd/J20NJ5JNINSCSTzFmiBsKuWbCrVfzuwa9m+q29wWZwLAsOHdt0DNKHRw1izFcLqUGXZKiGhsHlX/Y+m7HL7lBSST6+w3IB7z/zDJonTsOGW6+PFNkTmDX8/tcPweutYZ0tN+PmLN/UimSuEZCoOY/l+7Q+rSK50zFL548Y0X2LfEykUgm+ZhCKcPvl/x4K6f8a5+Z61ate9apXvepVr//fqk98/osmPl9Vu+93GA+mOaOKJjs01g8JaRd5V0X7LBoP+94Q1j6kCqFxN0EIBCXQb+uGyuN1wthty0KlUORcG8+10djWgo9e+RNOuPRq/Oys03DPk08ilTCw71Zbr34ct//ut6gM9GHBKw8DqeHY7Tv74vnn/4Am2UMxPRIrSxVUH70RP7zlAXzYA8w7/yDcMi/e9v1gtIAdbn+Sd6IH77obrnvgAfzwoINW3/bxd96J3eccj51/5uDGyw/GSWfej58//BDCwMWlJxyN6QkHN770AqZM2BoPPPtHLL5yd0jjN8A5t87GR68/hCc+q+CgPbZGrmkMxPJ83P30R7DKJZx+RAyn/bXa5lu7YMXS5aiUCKKgaY/LypZwiOfA/8c+eUK8W1UU/tANBT0dy1ffzuSZm7ACjCU2pDXxg3hq4cdyWYF2dZrOI/9kJo1Xn/3nT4P+r+vAA7bBrM22haSm8aubrsAJV92BcrmCpQsWo2v5Cjxw6634zoGHMoeGdtGOZaNGu2TLglWzmd9AxyWrt0hyTlMYVhXF8CKZB2o6KY8klmgTFLTwCxOS9TbanECjOGA2jL7kXvzFmrX+prAJUnMDFEslfp8j348HPHSuDG0fWSVGknjHYa4MwSz8G7LIDsdfrExjG/NXCNIa6I2tFVZVKjeMp0KKQtNXmaFZmhQsXvDx//frvs6mO8I2CaYmCboJx4kVbyT55KlLSJAXEZuioSBPEbKqoK1tGOZ/9uGa7+Hxp/DvPnzrTfjOgQdDkmnSLPMgjafNLHW3UCkWMdjfj8JAgbO66BwxayUYRobZPjy9ICUYTxSEmIPFqlTiJdGwmOamNIwWGTYmyfuqv6P3m95jURZ4okdWAKQImz8QYNLIFuiNaQy+9QJaxk7EYZddjr6+Dsz99S9gDvShsGIlMOBAzQNyWoeqJIDaIOwa06Ag6ICRaYWfykFFgEDWoKd0ZLPN6O7pRhQIkClnz7YgNDTD9CRUS4NIigKqHfOh1kK0jNYgb3oAjHQe915zLU669HLcePaZ+MGPz0S1WEZxoB+VUhGO73Om2NtPP8XH76bf2R8DK5ajVo3NE12T3icPhLlGDMVKkDQNRiqLbGsz8m1taBrejnS+gaeI9G9qKgUtleJ1fOmNp6NvdgfLuNV2YLtzz8cY8wM89Is/o2nXw/Dm5TeiSvYcqyefn9tK7HXssZg3+zWstdWOCERSk0UI3YAP+2QqhcZcA4xkEvBc2NUKQ7N0LhA861Wr+OUdn8dK/V9VHer6B+u/sfH5a7XzXgfx2JKWqD89ei922OtQlrs7foiAFKPEL2AOAElDXSYb0qKjazo3Sq5r8riWxpvkmLp87tvYbs+90D5qJO678Xrc8fvfoqGhEQo1V4EPy7Kw/867rPEYbnvi90w4ffaZ3/O4/fe3fS5vvu2JPyLT0ARFFLHPRhvimTkfIKEbcFwb2629zhq38/ALf0a6IcfYP5EniazoOh7232wz/PLPz+OArdeGKLas/v2Hnn8KWbmKXbb6PA7i1eWLsfmoNZPir73oSGw3qxGhmsENv/kM0zfbFdOafTz97Kv4bFkvSpUy3vrz88g2tHDzR7Jf8jKJGx/hC9AHwY6xCpE+aAEn8idFB9BImQTIRCQVSPo/0Mn3ncq2oFrqRSrTAkGOmybNSCGZTnADlE7oeO35r/YAOveyK5HKZRj+Of+UzzlU/+oq/ulk5Ha5AZdecTx6Ozpx/Y2P4cpf3AlB01HoG8QDF5yHmTvvDo9CKgPAJX6BY8MybZg1Ii9T80MLa8wJIXiWuDD0OtNrSs0CwYqJhIF5n7z3T3/8k6fOhO0SNESbhIAvAo43xJsj0cBQAybC4+YoRAxr0eFAG4ahI2HVDyCKRPMV+ZhgSFRRGcYiUqlhaJj36ZrNxtettWdtCtMNhgjNDr+mLsm+3c9hrZhjQxwiIhVL0HWZI4FSqSQWzoubrv2/fyT74tDjd0OCzEzYlSq/B2SvExKMOART0flABPNKocSEb+IvEUzJAOAQf4ep40MO2/jC2cIS96GfrOLvMLdJVRjSooaROEKiIkJVFPQXKthovRkw9BDNSgi/1AsVNQiyBtGxMFj2sXJ5H1n4oLklB+gGtHwSZAIguRYQegypkr8SBTrrmQyq1TImT9sAhWIBxcF+9ipym0ZA6VmOhKFiYGAA46Zvgt5578CQFZSXdCPXlsSkzbdCfu2Z6CuYaNlwe/zsqJPQ0xUT3U+54gpcf8YZOOzMc1GulFExa3jm3s9Dmve48GJuWtyqiSeGEuNXVXZYGyIfkA0dgyuWrP75zqedgSevjq1MrnvjLSSTCU6qJ3I3fRAPyC0XYRUH8MYDd2Oz3faAktIR+SGv7/SeCKICNZFmfx+yjaDjg+JYPrzyVDRNWxudf/4Dpl/8EBw/QLlcQ61QhG/a/Npn0xkkDB2R5+OyE47AyZfdwO8hka7tSgl3XrNmiPD/RdWhrnrVq171qle96lWvoapDXd/Qic//VFt9+0gOFOTdnEW7QocVHiBJZ0iqApIQB0ws1pM60kkVJ+zo4/BzYofQQzZqxNQjzkOX0YzpRgyx0Q5+7ot3YdRmh0LSDZy83/fw4JtvsnJm/403+auP49nP5kE3dIjkfjw06qb7LVaq2GWdmbjl0Udg1Uw0t7Ui05jjaYpH5O2QZL3AARtsiF+/8y7cShGV3k6ETg06kTJzzZCSKdiCAtsDk2ad4gDM7hWw+ztx2QWxPcKqOuTgfeH5Hh566Hf8/Z7f3g2P/+6P2GL77fDKc89jzPjJWLoolu0nsw084uVd7CqpdKyiZsIqQRbsrMsQFrkMxzhJvPeNd7k0+WFibBi7EtP0iH6PiLlE6CZ1SO/yeX81ePHIk07CHTfeuPr786+4Aj8ZCu39V9QvrjwDY/fbHc+ceDB2uPg+PHXjRchWCli81lZwFnyMXzz4DE686Ceo+T4q/QOoDAwwrOU7NEXx+TikaaFjxQRPmgzQjISOPXotaWJC5E3itcqqhAWfvo/1N9oC77z1CnbedW889cQXwjr/Fyvd2A7btmNfMbKIICBZImd4knmvUitRxa7SxBim44GmPAx/agSBGrxzXjTv03/qY1tn/U1RLFPWFMHWAUMfDhGYCSYk6GRIzs4lgadmNF3N59JYPETy3uegg/GbB+7Hj6+6CC8++QI0NYMaqTprFkN7rCSTSW0lYu6cd5DJNBA4hKbWNlg1iyE1mgDR1Iak5SRbJ7cImpjROUuQGU2aZCKfiwo/Ho+k9AEBkjHcRVJxIngz0Vmm91+BopPaS0anFGFik4GGcj9CT4CUVCFGIlw7ZGm5nNChJdNozOUgErQnRLDLZfQN1uCEIcyqx6o/RRGQSciwLA+eXcWW+x+NuU89DLtSg5TUEPm0tgSc40az7w0POB4vXn8h8htvgfWOPhETJq6DP119PksI6dhFOoPC0i5IqoFENgdFS7BDOR3jFkFXNHlqbUWipYUJ1IqR5GPbLhSw+LWXYBcGYVcqMItF2OUSPzctn0N+xBg0jR+HxpEj0TC8Hc1tbWhtbEA2lYSu0OsH+ILA6keCDiM2obR5Qu/bJpxqGW61DN+y+cikaU8i34BkMgtd13iixoRqhq1CXnvp2C1Xa+he2YX+rm4WuLCjOSEHdF0wLVx/1qk44aKrWGQTEtG7WoRTLOC+vxA4/G9XHer6B+ub3vjsfsgpcEMwrlyrxFb0NA4nKMfzbLjEC3Bp4QB7kLS0t6AppyG74nnkR0xE32AfyiUTvYu7YZaAVULLtaYAozbZiZOt29fdDqnGFo6yUCUZZmEAB39rd9x4/308Qj/poIPx6xf+jKbWVr7Qk1KHTtaPP5qNgZUrsdV3j2Cux24zPoe8zjhuD3i9S/Deix9j7gBw/tNPQs828kJ8w6knYHvhA+y40wTMe+Vj5JPA0ysy2OPBd+BHIqziII7Zajf86MD1sM8uU5BWRTTs9ENccdn1+NVDT2DjHTbDemInXDdAqdCBKx+O4YcHTt8WB131Zxx7/EEYs8Xu+OWVV+Oj999Z/ZiMFMmgyQdl1U/iGAUe0cuk2qFFPOZvEJeClCn0QdYDdNFn+IQWnb9ocCRFgqHSaFpA97I1+SH/DnX0kYdi0/VzCEUXb3/qortcgIoIU0aOQr8gobxsGX5xd9yQHHD0kaiYPmq1Gh9zkUeNArnKBqygsqo2bJf4NT6/DpTKncqkGfLQSHIuEC8kwnuzX/6XPNfxU9ZhlR89fnq/VivJWCwWN76rZNqrGlWGu+g4YIm4Al3XGU7qWPK3Pa++bg0bM53DQuPGh1RqFLlA6rTYPyeWl5MEWkQioaExn8a2W26AxvZmvihPHjcDxx11Atpb2lDjRjSOo+Amf4iPQw2TuKqZZ0Eawc50waVVIISkCEhqMhKqhEgOsKK7hOGZNCzX58iRgYEyRo9uY6iFVJGxUs9HX3c/2oaRxDqB8Q0WTMWATNJyQURKkZnjQ+eLCJ+DS0n51JQAHIG8nojJKCNUFGR0nWEfsxrLsqumjaSqIiUCjhhAUjVEngmdFbEyNFlDiXyVSNNEsJGiwS2XocGD4Ifo7LcwYvMtsOEhB+PTRx7m517p70XpzdfRPH4kxn9rF3S88SKWOWnIfoCkoaH84VuYvNc+EIZNgNlfgC1JSI0YhURrG+RsliM/qDE1B/ux5KnH0Dh+LLrnLYdF3JlKmRV/Rr4R+bHjMWyttTFswng0Dm9HNp9HhoJmCQqkhpKsCQguHPLyoQ0mHYuk0qpVSij3dOK2E47ESLsHkehj1I77YsY+hzFHiANrjQQ3T7SB478XRH6PKO3+wIkTcert98DnGJMAAfGcahY3PvT60jFNzfztl3452Prr1l6HHsfyfAQOHrnnbytT61BXvepVr3rVq171qtdQ1aGu/+WJz1Y770nOEnGIIo10iRRJnhlkkCVGmP3qn/n3ttvxW3j+mTjH519RO+11MATRQCjJHCZIOzrTrMEhNQERdyn/xanBrhFB0eXuu6GpEe0j23DpXdfjvN03RxipPFYO2VTOQsbuxXcfeAda4GPFK3/E0s4u9M99F1ZfF/JmD4rj1sN+R52Gdz54F2q+DaMzGQhivMNIp9JI5XJAbTkWPXoTVvZVUerqx67X/w7ZhmbeNZeLg5BXPosOZTqe/d1DGNb3JoZPXhfvLSli5ZzPcMjdj/HzufGo72OkbGLPg/eD0DIOyYbhSA9vR6q1PQ6yHOjE1GW/hNo4BouXrIQ3ZhOs6Crgt0/PxoRFz6KmGqzoGT18FNI5BaXuTphjNsHk/U7Ea7ddiQfu/tyLg25voy224OPoszlzvvQ6JxvbEXqkCIqnPzTxUWkXTMGPus4OtGQySeoXmiIwGZQI0xzCGfIEiVVLsoB0RkVbSwpFx8EPjzkOPzwp9kH6d6pb770KT7/0Gh67J4YJV9XRJx6JqhVioFxFqVBl4jKHbpKqjVxxyYmZJj4EezH5NlYYaZqBxoYmaLqE917/5zni/qO19gabwyRHZTJLZCjHZgg4Ju2u+burJj3sN8NfUUpU7EpMHj/03g90Lf1feZyzNtkapVKVIQrK/iK1YEA+XuRZwyTkVeNIglKJ0Cwhk0lizLhh2GKtURCGj0V/bz/uuvEezuSq1moxFMkKNjI5JA+koVtgr504N4zcnePnzlGh0CQRqaSCrbZbD81BFfmkhqLp4cNPl+ODZQPIGzQlELHJJjOhT5qId59+iV24KwMOkpIPV4hQRDP2mViEKGmo0r/5EUqmg0xCAxwPvhzConG1kYJJUJYfQg9chJLKGV6C6ENRSWwhIyPLcKseK9uaUzIkXefzcqDmQCUzv5Y22NUCzNBDQtQghgEqtg3HExB5Nkw3hGdVkTRkaIkUSgsHIaZJlJBGQqwhhAyv4sLQgBJkZNUQmVSSYdtK0Qc5zJALtpQCilXA6QPG7zAVnprE4j+/DbUlie5lNSRoyKECHg3mREAniN6sYnEFOPbqqzBy7RloGjUSqWwOhq7HU1AI8ChjjaD2VcR6sjcMAziWiUJfN4pLFuDjDz/Azt/9Hj5+7H40rrsVrL4VSDa2IJHLI51v4kkaSfRorSdfMzqMS4UijpwxA6f8/Da4NYJPSXFZ48kfSWUevuayf/oxvM2eB7JCjZ27eRpHogKHPZzIzJGdymmCHvn4w1D+Xx3q+pqNz1bf2oXVOY5NvAIP777ywt/195NmbLham8AusXTwUHo00fGZt0FGaHGYpyaLWDCkPFlvw00YQqImg8a8PApnv/FYeUVW8LSoyLIGVZfx3usvY5Mtt8cbL///Lf4bbLYTIjIEEySWvJMEl6SVZOZF8knPceHR4kHGZoELzyIViBM7feZzOPG8U7H0l1dCHtYELxDQnKdTWsKkmRvg8dcXwcg1QBYCOO/8CouW96F99Hg0trQxRt/SkINmlvHJ3KWoVouwgxBrTRiBct8KyJ0FhBtsgenb7ILiJ2/BVBV8+tarcKfsjoP3+zYO3eFbuO/ZZ3DIDjvinmefhCoJePKi72FivoxesxGDi3uwSJ2Ob199DWqdS1B960kY42ZCz+Rx4fFxNMTTK1dCkQT0P/lzbDfOg6er0LPNqFQFPDFfRFf3IF5+9BGkZeCIQ3ZAItmIiuWhUCnifUyCtuJTrFyyCLIziKnb7oUpE9rw7sIeLPnwQ/zy3geG3teN8e7sNzFr6x3wwUvxezVs/HRuIF3PYVUJcRTIDC6dSUPVaIGJuBGoVMusZqKASDJFpGgBkrrHBgQRQs/Gt7eYgKZ8EmLjKEDVcdvP78fe+++PRx+Owzv/r2v+x49g0vR9secRh8Fe8SF23mVnNDaPRKXgoWvJO7j46ntX/64spLDxDlujUqW0a4pQId7JKojDheMNuS7z+kvKtljplMs14ON3/r7z8X+jpq+/GUdOmATPEV/CIRg4biQ4FpMVR0Pu6UzeiteDiER8ZPxGvCQ2GR2CulSKn4gjBCjMl/6e4VGKEhBlzPvk/a/1ODfbfg8OOSW5dJmgEnazJvjUX6PpocdKGw6yXEhmRKw1phk7bzgeXqijWKiis6+C2fN7UK2asByfoRiWvQ/FdaxKWGcYVyKDO/ocG9xRs6oqAhKqDCWTx2FTZXy6oozOQg0NKRUbbzALNz/9AUoDA0jLAUYqLiYe/gO89OfZ2KBBgJZrgNDXh2ooYcXSIhb39mOwbGPttRoxrIFgMwX9lQgGvWw6NTsOIjEJ0XVgCApKocvwUZ7OKeKcBB7SUhJpnZLoAdvzoSgUZxTBDTyYXoCaZUIZPh79S+dzw1OqOvAil2XymqQil1WRTiaRTRncLBFvRo9kZNIaTMfBohV9rCbLZnRkUjpKJWo4Lai0qZMUJMUQjg+EsoDQ9SCQBQB8+NVBuA7gyQS9ychmh7ElQ0Mmg2LJRFdPP9qaUugvO1jeXcEep/wQo2auh4aRwzlYVBZlNt8kZ/CQ3PUD2ijFFg8kkaTzqlYuotC5DI8cdCQaiYKwfiN6lgzALAOiB4gZYMTmo9A5IKBRjxCoGlJrb45J2+8BQTPg0YZkkPhGNVbiVtliosZrfipFLuRJVibSBo6OiauPiY1sv1iHHncifnHz35a4b7zdt+I8WlHlmA2SzKeSdJ6obLhJ7uy0Mae1UWV+WQTPNfHiH/5Qh7rqVa961ate9apXvVZVHer6ionPeuOS8GQD6ohZqJGBVJWM0mwmA9IuZuFna9rFT1lnQ5iWw4Q5CoVbNUBmk7Qh2/lVNtn07zQJ1hQRmhqbbrG1ehhi0aJF0NJJtLU0MPkV7ANCFL04eFBRNGhk264oTIIlpQTnbtHoecgQTYhoJylydg/5d5DfBmcA0g6AsmxoasBTJRpJS2yIFdvEExwXxWZw8TaOR9Ws+hh6RiLn+Xj87+SXQlb8RFYslAMcu98sLC2qWD5vHhYu6Ub7lClQEgl8NPtdnHz1T2EteB/DRo/Fh7+9F35xAGMmT0ChqxuuVYGcyUGQIiRyDbAjBSlVxNufLEH7+OmoFHuRzWXhWSX0vP8atj31Gpx73Km4/jeP4JR99sWDL7+EbDoVq7oEAR6FB0YCqraFQmcH/nTucdCyLWheawr2O+ks7LnODPzq3XfR3N7O3iNETpV7P0b3nJew/owx+GzOfHy6oBfO1O0w2LESPU/dgzGTJ/GueIvNZyClG3jisacw+51PsO46a0PUDXiBhPklF7qegmtk0CRU8eCvnl19fBx06o8RGglUBoroXrYEg51dqJTKPM0h/xnyS6GJj5EwWMVFY/5arYJKqcJqHIImOF6ElV6x0VzklDCmLQ/bC9HdX4Kg6JgwdQImjRmHP/7ucfyr6qyzv4cPPu3Ek7+LpzLPvPYCinYZtxzxbWwxM4nNNl0b938yBr2DJgYGKwzr8U7SJG8ZUm8RHBPnOdEIm3xtVuU0KZoMXdURCQT/0fQhDsckAztFlvDB21+dT/V1axoZTCLEpx+8hYkzN+HoFXrMFJfhORYTeEGGhkPKLZp2UKwEU0oZ8YknITRhIJIoBV6SGqbYXwAEFS1tjUx2716+HCPGjUEQxPlhFDVDf86TXkmBqKkQIjJjFFm99lW12Xa7IxDIa8tDrVJDuVyEWSmzIIDiPTjLaTUcF4dUUpHaiv5rzAVozCbQ1t6E9hwR9B3c/8d5SKb1GHrlAzH2TuJ1hYMwVxHw4zgQgd4PVoepaGlJIxVUMT4vQIsUiCRYADBQjdA8YTqWLvgUY9vzyIQDqBYcqFvsDGvlR+hb1o1QUTFYtZBSY8UVvY6uE2Ll8irKtouNZ7Wgq+JANwNEughZEJAOwf/mMLk8QlZLwLZpxEIfAUxB4jXCCclrKWKvMC8SYAcu+0YJkofACZAUNVTgwZB1ZDIJjBg+HCObGiC6Pjo7uhFK9B6F/L0niGzuJwcheqsFhIKO1mQKiutCMWT0U4af5UBGxAo+ipugdZ0gw4QsI51Ooq93ACXTRTqfwrgRDWjINcAxq7BsH9mkgY5CGW1tbfCLfRhEFtl11kfbWtORaWxgmPievb+H3S/9MZrHroXBgSJszcCnv74bxc4u1NQExK5FaB7djllnXYuPTtkX2YmToagpJJMKw0a0zhR6BjEsbwA1B8hlIFpldPaZ6Cj2o6cT2Pr7e6F9yjpQZBW+JMV+UDWLjxvKrdMTCSgqxbJo7EdExy3n5loWzj/kkNXH6Jk33sIQKCnk6PplmxZqNJUkv65SGeVSmac2NE2lS5XKZo0pZDIpzrej65JLghvbZTGEKokYNroFSz6bi5f/9Fwd6vq6jc8uB+4Hy/ZQLpb4IKqVaFRMYXeUC0OLr8quqjTepZOLTMwckt8ST4Egibir5DeX2x9yQSUTQDLhkulkE9DZ2Y+xo5ohhzYGnAgtKQNtORUVx2S8XRMFpFtHoYNUkU4BTjoNp9visSY50U5ebwbef2U2q40IvyXbtKF+JR6ZcwAjwd8BfGpg/HAocygedbPSgoyuePQ+lN1FzH/SghO2yyP7WKFCoY00RqXHP1iqQWeZJDVjJLGWoMuxxHjuggV/9XUdN3w4Jqw9DV2lKk646Q50/Pk3fPKQI5djlRE0j0DxmfsgqEmIepqhts6+boiCjM2mD8eyARsdfVUIThVNk2ciM31jZDQDkSzjvO8dzPfx1ooOCKoCKwLKrovBwgCWHj8Ts/tlLC0Amhq7H4vTN8ERp56Opvbh/DrZpUEs+vBDLO1ajv5Xf4fegoulb3yA4WNIeqrCsR309hLXKcbZlRSjEcg155Bvm4zSko/R0j4KLXkdjlnB+D2OwBH77oVLL78Ey+d/hvU33wyh3gQpnWH5PXEOPnr5JQz0DaJKOUW+z3lERiIBjdQjosThm8Q/oByjCvEqbIcvhswXofTlMISmhEgbKvr7BrDx9JHQmkaiWKygt1TFzE03xJ8eeBD/V3XsscfilltuWeNn5513DJYXLSyZvwDrTV0b773/DtrbRsLv/ACfVtPI6VmU3IgvCGRKSM0eNfN0JSbDzLjpkWHoBuZ+/PaX7nPG+hsPNf0EIURfcMcmibiGV154hn9v3/0PwiMPx9DjP1LrbLA5J6PTOsDIkyzFijta7FlpFqdh04aBznkqMimkjKpY4SSi0t+PbGsrK50G+4pobEkxt6+5IY9EUkDfoIcRbQ34dO5ybL3JBAxUQiTgoTRo4t1PFkHP5BBG8ToDKZYpU7POOWGr0tbJ4I/OYzLrkyhYMl4HSKpOSi4KbeXcKJfO+ziseFXCOp3bkRA3MPEaRZsxktfL6C36GD88j0TGQGAPYsBRUOwrQCBbAdeGnEzwGsDXcGoNWSAW3zetKdSoJpMa9tplJJa9uxQVT+bzNamKSEkq5/zVHB+DWgZpKWTbCTUho79mIyuK8GUFkq4hraqoCT6cwIFmSZAVCR+vKCOyA2y0bgs8Ol+oqai6aMokYIsKBk0TCnGZgoA5OLQ+koy8GnkIBA16RI0hNUcec4WocaZejtZverMNRUUmo2E8Gfp5EbSGNAa6i7AcB0WviuZUI6TIhyyosEOC/wOIvs9cHCmrc9BzX0+ZYlNjKw6LmqN4+ygz9UFAqAAqZdFRMxu4LIFP6DKyisq0AUOV4dXKKNkuLC1FAYlIpJMYObINxd5BeP1dWOvAwzFii63w0TXnoPOjBRiwgagItNIxMgxwdBWtE2ag2NeLKnHQqiWItRqM5jx8WUUi28iKMLsWm0yOHz8Z5d4eNE9bF4Pdveju7ERS96C6HpL5RnSsWI5gsB/r77kPJm08C2/edSsQKRjemsSSd99DsiHP65OnpRBMnoLp2+2BUGni6xWdI8QHo2M0IvUaXZ8C4umEbClSHCygVCjAqlRRHBhEX2cHqoP9rESjjUHSMGCkEtAMLXbzpmsU8eRkiY/bGy4/H6Pa1+LzsM7x+ZqNz+a778KySNqVFwol1EpVJvWxr4Qg8UU+TndmSwjmX8QuskOLCEP15FexyqQ1gkb284qPaU060lKElBQikAHT9JFWZcZ1Tc+DRd22kkDJ9RE4VUi0K1Fi4jDdZloS0GjI8CiBmEL8kiI6rABNsoZljosVKzoxQo+Q0BL4tBCiqyIC1SI/1uGjR/PFglLbKZCRFmdyPxXJO4YWQHYvjUlxJB3OZRNIGQnUBAFVx8XFJx6FOY/dizdWWOgtEtdHwoxtNsGC19/FR5/MR3NTM1y3ilK5hlHDh/MJTo992bLF2GrWZBy8y2SIE9bFD75/AX50zrGoak2oqTlMSIYoznkZqcZWdHd1olYZhCxp6Fm5EkGlG5KRQDaZ54vhiq4+PhEaWvJY2NmH0297Am2tLcil07yTKlkmBigluzCIUmcP5t1zIWpiBnLkIHAjaG2TMG3Xb6OhfQwHGXq0qyr2wS0OwqpW4YWxh0htcADl3gI++GgOfnzt7bjwpCMRhTJmThsJ2/HR2JbBygUd3KhUli+A6nsoug7GjxmHkZMnY/L6G+CeW27Dbt/ZByvfeQ4hRVe0T0Z7s4EnX/0Ue2+/CZ6cvQwDyxbzRYgmGdRgciIyLdSWxRyNcrnE0xAKKfyi74osRXDNCo749rqYPHYsXu004Q+sQI9roFYdxKfv/u/Jo79O/er+63DzfY9h3uIB9n9pH9YA14vi4FHX4wZGVXWeflHjQL4qH77zyte6r6222xla0kBSM/DYI/94Azh9/S1QrVRQZR+ruPGJ35eQp2889eTJZ8DnES/EgginYvFOPj8sgeGjcyiWaGPhIZHSMG3qJHjlMhYvX4BRjQ3oLVsY3tyIcSNG4t0570GiSbFAER00TU1h3pICBgs28nkDpYESErlUPHnlDiPe4NDmirLnuQFifgfH4g4FD8ecMHJe52kuTZ5pFESxHjSdoNgDKUKtUICezfHtsUeSHE+siEBP5xtt3ohszncrCMg15tHWLKG/nyZ2JjybGipSGtP0Gci2UlAyNVEKDEPF2ms3QezuRb8VcfOfSqYQpLMoL1gEN6xA0poxb0k3NphmQPAFINAgqBFCHsf6GAwDpGjSJ3joLYRAWkdt0ITgB9ATCkRdguRT/Eg8IPeNJhiVIqYNS0FUdF5X4dj8uiB0YUfEqBFRClzIYYiy40FSSfoeICnLaEyn+DXLyjq8QMaingEUnDJC22UX9ZZcHs2pZhTtEk961ICmeeTRHaEWenwRd8MQg9UqxCBiebxDMT9hBIUadIoLigQYABpFD5YgI9IUaBHNTShEWsCAWUOjkUeB3I9tE0rSwJj2NG80XVeClh6G3iWLoZRWIg8XVUmA0TwGyXwWspEFVAm9nSuQojUnocEkHpIPJgeHioYg8pEWAJsn41W2kSABjhWRc7WHWi1E/2A/Jo9qw8TWLHVrcBUg4UWQQgFdlSJMK0IiofIGtqdQxjpTp/Dgs1LoZb7opI2/hdfuvwHTf3A4ki0TuOEhThsFBsuajojeF5LM07QsCHjIQPEmgqyiWq7g5YfvQ4Pow0k0oLO7A9NHD0c6HeG9z3qQyTdj+LTpceDsFjMhyOTxJnC47Iu//1Od41OvetWrXvWqV73qtarqHJ+vmPjM2nxDVnXZjocqZQRVbZi2xxBMGMbwFuHFMchN0564W1+F6dOuSVVEWIVCbIeqJZBtT2CzcRKkgMygaO9G4JQIOaRxKxiXTwcharKImhDBcAHZD/l2yMGXICgvCqHLgFUNoOsiar4NUdUwom0Mko05tDaPQ7HYj3w+j4HulYzpa2ocSDpQLSElaJi3ZAU+6rd5zN2e1njsve7YFvQUa1BkoN8K0dVbwLCWZnjFMmzXQiKMkBJ99FpVtKYbMGpUO5YOWkgNa0ar5ENvGwZnxRKst8UO8MxeLFzcgffn9qJcNrGs4KDc14E9994Tw8eOQjKdxZXn/xQnnnMGnAVvoLZwNoxRa0NOZdDfXwICF+NGtmDlgIO+3ipmnnYpVjzzENRR66C28mOMGt6GpW+8gGXLlyHd1IL9L7oZLS0tSBkqTKuGizebyiaFmbWmY+oRZ0MQZTiFQcxbOBcdrz4Pr2YishxMmLURpu60Gyic7IU//Bpbbr0zLjv1ND4OzvjZTaj0duHt+29Auqkd09cZB1nwsPUZt+COn1wIm7goloWFcz/ChOmz2FhL8B0oArD4jRf5NsZOnIz+vpWYtckOmPP6M8hmMmiYsTG22Xx9/PmVd9BZAua/+x6mzZgZ5xAp2mrolHbotu2iWq2iNFhEtVphHDzmv9AeP4QsxsdYzfEwfFgeI9pH4K3ZH2D69AlY3t2JUncf/pU1f/48XPTTn2DW5GH41ZMvMZ8incqztLpcJQk4GekRbMfzRRiahsnrbIpzzzmDJy27bBqPrf+va+0NtuSJZc0i1Ra5G5NbNBVx9eIATbKjEHjaA/iWj0yjhnJPFU2jNIQJD8PahmEkcULaJ8Hs7oJfM1Ho78VgqQg7DJFT0xgMyugrm2hPJDFQtWBWBQhywCG2NEZuaExzXpaqKTwV7uupMvfE80WUSg58s4psY46nzTTJoZ1z7BwYu4BTsWM4uSRL8XHFk5mQ1icg05DG+lPptoH3P7V4CsxrF8Pb9Dex2SJPsYkfQzdNcD05ZksCBsoipk5Qkc0AGVnn+xogF+SCjYF+B6UBGyVbwqipk9jGo0nshU7crCCCqwpsiGoIwMKuCKNaNBhJAVHZRhUqJCGATPycjMyKTcWPYAVkYCkjl6CpaIROy0dnJUBWJp6ehZogotXQkTNUNDdm0F200RuFGNXShvLgABpSBloVDYVqFTWCwCQRjaqGAd+M1VlBCM1QIBgyagMWrHIZCdWAmEihYJVhEp8ExLGSYUkBu0x7psWyb4H4R5CQ5GzCCK4kwbctKKIERw7ZcJFeA+JnkcGgRtM4hd4viVVh5PVNawCjBpT/FoSohCr0lAZdDhCpIkZkm2CoDVBUg2EhLeyHoSmomSXochqSYaC7XEJPRwGqIMDIalANkoBLSJJVgajBjqpQyZ7DcdnNW84k2WE5jDwoqoyaSUahEtItLehd3IGEHCGS6OIkQoMER1JRrpXZLHHUhLUw/+N3+L5a20dCMjSUSkWkIjBXs6tUQsf8zzBzm51hD/ThqeffxsgkQBQiUQX0EFDySXadNlUJfYsXIuoLcPrzH+L53z2AQucKrJj9FJpHjYRAnC2zCkcKoQUB8qIGJZnEioESBN+D6cqY19GDUdPWx0evvVWHur5u47Ph1DbYbWMgEYnRDWBbLjc+tuXDDUjuHSJkuS0tMHGy8JA5RwxxEQQ0vRW7zsyhu1TEh0tcTB3bhL6iw4tQd7GIxkQOllXieAVDlBCEDqqey3LyjCyhUU+gEvpIUihgCLgIoAlE9FRB5skBu/2qaB42Grl8CzqWL2I5pWVW4AsGsjr5V1RhmxX2EJEjD/nGLAK7irQEWIGHAAp7S6wsOFhp+WhKq+yWmyLIQRNQ9H2oQcwxIDzVV0XIbsRQjwwPCgJkNR1rj2rCyr4iSw5FMcDEMcPQ4eeQ0jwU+7qxcnEXRq+/KQZCATMbNMwzZUS+yJ4Ujh3AKlXR3deP9fc5BP7KD+JFgLgvIyYhM2oSVr75PAqLFyDb2sBjfRqXJvJNSLe0YviUmUg15KDKEqqFfnzw4ssofPAcLDWP6bvsCSOTh1MqYunSj7DwztsxatIolGsuvP5uTPnuUehdNAeVd97CBnt/B9HojSAoSYSOiUfuuBUTmhSISgIj8ipGrb0ullshHrzh9tXeLFt99zv8uoSujdfmLYM/UMJ2+2wDeeVyLHzuJaSbmmBCQDaXhiGJyDU2w1REDPaXsP5666FsU1Ag2eqT9f4qx9oAFgVJVq248SmWODCwWqmx9X9AZCPiaYgUZUGwiIRkQkVv1wAacwkUQhl77rk9fnvfwzjjogt5PH7puefif6see/wu3HbX44zp0kWVeGHEnSIomDgmFE5JPB46R4hYz5yeoXBEanrowkFwKPEXNttiW9x3y5X4V0rVyzXyUDL5MZKFAzsbD/Gr6P2JucAEP/vceBrNApqzOfQMFpFJ57Hj1tsyRL5iyVKU+jsQOgEUQ0BvuRzDP0TWJhdgz4flxk7VxHOgjQ1xPEzZhUN+NLy2yBCVgJuNloYUUgkDjukgrel8rg/2WVi8vALX9JFpSsYbqqEAVbpIe5aFbGMGmbQIL/TheyS5pgs4YJZ9NLdkUDSBxlzI3DpJVZA1IiQFG1HNw9wlg2jOJqCl6OIXwk0KyMgkxzZguRLS8ODJAnyBGrKIz3+VvHskG43J0UihhiV9RSxeZkHXVEwabsAnd2hqGki7DZ/h6a4+FTndRYL4iyrJ/n0sWlbjkOOxw3X4PvFAAD2KYDRqGKAVzQ+ZREu8w66+IqwASBoSxubTEKU0Fi1dgUHXQltzMyfPk09QTlehhgIsahbDAA0KcXRCkMGIG5GDdIhmWYasJ7GsOACR7ldU2OXapwdAMnECFwWJ3ciZoixLsN0ABv2dFEIKwARfgo4IurRDn+MzmMjMr3zIEntXVFELbKhEFld05iERB1Ol+A9BRMnxkE+qSGVT8AIPCT0Jx44wetQkZEMTg9UyQqeKWq2ERMsIFPv7ONqFaABiFMAh2FKj+414U9GQyTNUWa7VMH3cZCzrXYaaHaCvbyUcM+DjkqxNaDPO4omh85lk+KbjcwQG0TqSFJgcAbZTY/k/IhVaQkVPbz8drZAzKjxJ4EbJQ8TO3bRRFA0DLQ1ppCUFfZUyBFlCPmHwbSnk9aDGNgndK1ZgvV12wsevvYWwXEU2l0HriGYkE3kmn9PaV7YcQIyQUBKYOW4kOns70V+xIKoJ/Pbx1+pQV73qVa961ate9arXqqpDXV8x8fnu9uvwrseKiHyWRMva6+HxJ16AQbCJS5knIVyPDAeJPEhheiRHZ10n77RIweVXbegq0DIsjWHtOpqHGVjaWUQmmUY2l0OlWkVXsRctqUb4josMSfIaWmAxOzqCnkijZ7AEkZwqA8AObSYs60aSzaM0Gj0HQFdfF2yzDMsjOMyGrGqc6UKTJTLJ0ol0abmwPNqtRpA1EY2ZFHQxCTWZRoMR4f0lS1Co+UgnDCSIaKsoMGkkTqNpMYIua9DI5Zi2u36E/lKJd61EgiTFUXMii5QYQgxdpNMZpBPA0v4KkrrBEwyaiHBWkFmFKvoY/p1jUCqU0fHxJ7AaJqDvkzd5UrTd9/aHEUp47Y03MGNkIxbOWwp0fAJNF5HONUMMHLiGCiUMsNc51+Cjt99FsmU4K0xoF26VC1g6+xU0z9wQSx6+FWN2/R7EEVOx5GdnIaECoZaD0tCO6mAvMkkRol2gVwT9Hd3Y/Kr7UFswH4KkY/ToZvzpmsvhkZKG3KhNBw0NCcye34Uttt8WqmbACXwUymWIUYT991gHwpw38egbb6M7NRMbbzIFjRtvirdvuRPd8+YibSSRTEjIZUiqmkc+GaBl8gwcfkIcKLr9d/ZA8/A2jBrWiq6VfaiYNiu6qhWa+FRRKZdQKhLcZbJbaawioqkPqbtkRIKHmZPaeJdZ9CLIiopZa7XjwQf/d4z+dtn7u+ysXKtWWR1DdgpkyEfjEDomyEyNpjm2RTtSMigki4R4KkrEcTb8W53xpGCd9dZFZ+cKzJvzLv5VtdaMDdgR2HJchrjIqJOmHBzQO1Q0tSKleuhZCNi4DZAbE5gwfjgmjhnPmVsjWkdjyYIFWLDgXfTVigjEWJRAo12SLvsIeQ2R1ViVxdMAchmmaVBSZgjIJkNRL+RpHkIRSihDz6U4By8QbTRls2zaRrtfTZchBD56BiwM9tfQ0+VAT5JMXWA4JjMsh7HDTHSbKtyih+UdLnIpCaZCFgoa9KCMYc0aQolXGki2iEKxBkI49DQ59wr8nhmRiBo5MwcRNFp46D0WFJY0E7WYpt+erMHn183DRrM2gQoBC1d+wpJ4A7Re0Lkbi0IKlo8swVaWi76ay0TrDE2Dcil+HCY5FC+x0NSoIG+QGjYJTxPhRDTRCEkQiiSpuGyH1SRLugZZRGLVdBgZIJWMMLZpGCrlGqo0QXXpPkRk9ARSooKCQ+8fiVRkeGGAnKrAtTyUTROyoTJBl3LJfJruSAISpMYSfEg+zcnppQ/ZCkSVdYREcOeA4QCuKCGkg4TUTaS+JJY+m1uSxoucnOmYl0GhiDSZocloKEhI0fjW81HyIgRSBJWgvUBEtjkJ27fRlG5j13xat5OqBZuMYS2bp/FVMv30bOiKzhMsmpSROIShTYRIJ3RkkimMHTcNcxa+zzmMdrWEZDIDzXEwQMRtMYZwXSeCbMigeVxTpgG676NIU2YiXts+JEFmy5NskmA2um+PYUmbkA7Fj4U9bgiV1mk9wRMwcvInsRC/9QSX0jXGUBnWg0zHqsLXnCD00KJkEboliJoIXdL5eprXNJiBgAIhENChKgDFiUlKChldRdEkU8wCWw/87nev1qGur9v47LD5GLQ0NbMFulDu44NHkiO82qMjl8xAVzx8vKKIsOai0SA/A49l46QYpDElS9eVCLoqsCOrokowEaChQYUmqjC0JKo2SY8rbFuvSzLLzCkgMJPMxgquSILpWKhVKnz/NRpRe4QH+8gnU8gl0qwCI+8ggoXsIEBSlRGJNIR1WZ1FPCJDkNGQzKJULfEiSotKFLqIIhrNAutMHId3Fi2C50Vo0BKohS6Pc6WITv4IWkKA4FLUX4z3iz4pLgSUSwGSGjkI04eDhpTOo0onknnkSGPblGBD0UiKmOQxamBV4UQhFNmALgSomTTyFJFraGNb9L6OFRBDEaEYQtVErCyL3KAkJAVhRJJdCYboQwwtdHV3Q3VIBYH45HKAVBOQbR5GMc+oFgpo33x7FD58E17Zh9LQwlJg4lKxDBk6dJK/myZzt2SnhNSUWfDaJ6H4+M3ItI5EoMjsfVRY2RELaWQFc3s9HHLSMaiUaliwcBGPwQcGuiB6Pjr7ipi5/kwkUjo0ScALFR072h+isXUEPplXAMIBtDcP4+ZPNwRs9b2TEPYtwQGHnoSHHnkQLz98B5a7GYyYtC76OpezUmiwUGaeT7lcgVWrMi8mDpikkTlBXQpaGxLYct3x6OzpQV+xgiihQrUL2Gnfk3HJ+Rfh9B//GFdd+c+DkDbe/lusvKDGjOJN2BtqyMOG5KWiRJ4zBGsRlyf2IaJrgUw8FIF4MjGPSRhqfMixmj5Tw0RSbZZakyJFkfHxR1+O/vhn14SpM1EzLdjkyUJeV0ORDKyAYluKWFDFHj2KAE2TUBx0scFWE1EorsDmG20OwZVRqvShr2Zj0WdzQOHbBG+SEoj7HinmeZBwSYHE/1FsAZE+bOIJEvAcBVAEFbKhI/Bs9pqpmSJCD8jnNMhqzM+RBTouSVkmQaUGSqONEvl7BehebqOvyxwKHZWg6BImNQArTQPLenxWL00amYSRtuBLEa9ZSqih6Jgomz7UMEI2pUAVNRQjCxrJrSFBZg1pLNkWyH7BILjLZsUhvecV4ruQd4shY1L7CCRFA+W+Pgw6VVRcG1pALBgRKh8CtKGS4dckhIKD+fP7MHN6AxIpWrt0KGIEv2Zj/qJBtIxqQJU2m15sC5LNGFBI9j5QQzZDaeYyBn0LguvAtAKkDR2aLsC2Qm7m6JVl/h1x6ETKVCd+lohUQoPnOwzjaGKEFjWFQdeEEArwZQmR50CgNZT6FvYvItl7BDUSOQqHLELoIp+g94KbIHCz4AYBRNvj+AgIMjTBR+QBpkHEAHLwcDkcmdY0k5V2AZ8Xkhki1CMOCU1GMvpDCzq3UyECMUJDugWqbCC0LchKjTeybhBHkJDa1BMiJIk8Q3CsIiD0RVh+iDJtNlUZ+dwwjMgPw5hhjahUC/ho/lz0Bw57VJFSrSXdihqtMYGF/r4+mPCRzjUgcmx2EKcNDTlfS2GEUtWDnNS4CRZCn+G+oucgQTglcVcFcqAnSJA24wGSuoJ+i+xgImiyAE1SYJGrtiBCT6ho1RvYJbtArtlKiLZsK5qMBDzH5Odl1QZQCzRUfZtdtxNaGrlkkhfzmunAkAOYZLFC0PujL9WhrnrVq171qle96lWvVVWHur5i4rPfwXsgiRKbSEU1G04Q8Tixq78Ay/LRljWRyrVjRD6JjnKANz9egcUdZUhQmLlPpnhURiqNEY0G7xA/nt819KobGDlMhqKpbMYEGp/qRGKk3Qnt7nwUiiZqngWJthS0axEiZudrCu34ZDRn8ugpVXnMLGkqRIEwBAnJpIQgEpkc65GpAuXkRICu6dBlBcPyLfhs6SKEohR7R3guZk2ahEUd3TApk4u8g8htVBEhhQocInXK5N0gsmsue63Qvo38PZzYs6jmCWgdMQGF/iVQpDwaR01DpWMOIiMP0erHQH+VdyAJxYLiikBSY/iOVW+CBNeT0d6Yhlkus7GjJqtwfBeaqMARidQdsfKAdhdBGLsICpIKULAnKVBCD0S1RmDBIE8PQ0WRfMjIzdh2kEml4Os6RBo9eyEUncaq8pBLtYjQNqHrKkNc5RVzMWWPA9DT2Y0PPloKte8T7HH86Zi88eZ4/U+PI5FMQlJ1ViR1dXZjzjsf8I6LJtc0paPpnZbUMW7WVCx560U0VwuYPHE0xm21G/RR2+Pan56EZKUHOilFBmpY3NGN9pyIgw/7AXq9CM2iBVfX0bd8CRwpiWGNbXj9vSXo6+lnXxmartB0z6OJleevnvjYlRoOPmgH3Hf/H1cfy8d9f1dozVNw3VVXf+0Vb2DgXdx5728xZ85S2HaAtvHD8M7rH6JvoMhjdsqyIw8e9rWh94IJ17EXEe1kSYXG2U5REJNAqzZDv46bRGlgBVqb8+jp68esGePx/oeLVt+vnM4wedSs2Ji01gT2l6FxuKSo7KD8z6zxU9Zhwid51Xg06VlNZo4zqOJMq5jSLKkEG3tINkrY/3vbQZUUdC1cCl00MGfBXPQWBhBYLhIEvdLrQH9HCiXaMetM5UUgS3TKs8dOFBKVFPAJBiBomUY7QghyAyJfHHHod5O6iO6VFArqI5kUIGvk+yRC1gleIDd5mqbKqAwGGOyzoWkiWlo0UHSkbUZoafYhGESS1lmVRBPaAZqIyAbDo2QOSLdBz1QLRKgIQacq7foV0hASFKcoPA0j7xoumoaFARRS5ekyGltbsF7raNRKRSZ69/UNoOiFTJimKVNslirDtYlYTDGeAoq9NUwcl0Y6l+b1yLc8eFbAYaIktFjUQUq5FGQ7ZD+zYs1hEmuiQYNIJoD0Ovke+iomZFpPzBogkwFgAFWX0JpvhE+Gi5QxqCdinyKVjO9kJAkpDAjN9OETaZoc8klyRWuTaCAhSehzKpBDcoQOUfZMGKoBFbEQwY88aOwIRMaS5CmU4Ak8mdn4RArWJZiUJUUZjLLKuWCC53Hop0oITiixWldQJJRcl38vJeoYkc7CDxws769CSfu8rmS0NDTdQEoyoEQRPKEKmdZJs4KemsXUBvbIYTp8yCozWc7A9mmCIjNxWQ5JfaagJdPMVIfO3i6GYnvNMnzPQVLNQxcTyGeHwTQ7mTRt0geRuhmV0OGK9NrICCUBKVXiCQ7ljzmBzZN6HwHcgFTIIWSZWMsxZKvIGvteURAznWuaQkabdAxTWG0VKUmDHZgYnx0JTfZQIUf0KCa+J/UEZ8wVq2UYoojRrSMYiSn2d0FN6JzXNjLfjF46DFUN99//TB3q+rqNz/Tp45GQqpix1kSsrEZoyKQwMhNi8fJlKFsh7MhBRjUgK2kYqo7FK3vx1txuKJKKtcdmsNWs4Qh1oKO/irJV45Fe6Msok+LKl5BNE+4voWp5sAOfx+MhqxZEFKoONzChHLJs0CX1GIWaUoigocN0IxSqNUQSYcQUBKgirWmxCzJsPqFouSJ+jmO6kMUQUqSgPd+M1nyeOUEV30Zzvg3L+zpQcx3mCFBjoCUT0MksURBhWybKNYudpj1KI6ZQPUFGWlRgaCo3DeRg7ToExLnwqiKMxgno7++GrKcwcvRo5CQTny1ZAc3rYw4Dueu6NIKng5oWCEXmCA4p9KFQ7+bH6buUxEsnD42LaVxKjqp+4EIlu3mP/t3gkFcyBaRFzib4jVy1SXJMJmGcYK5DjgIkDGp6PDZTJPdWem4RNXn0htsmZp5wMTqXd2Lhr69HW2MWC1YUUE024bs7bIDfvzEXlUIBO265CVJNTdDZrTZCqVjGymUr8cn7c1jFlEgoUHQVYiYPHTaE6aPQMvtlDG9tw7Dho/Hs629BFWRyh+T4BU/Pon+ghAWLlmOjDdbFW2+/h/Wnjca6a49GdvK26B5YAteSmWvR3dWLgd5+5tNQg0GrNZlQMrcGJJGVkc4YWGvyaGy+5y4Y0dyKlXM/weUXX/u1m4EXZz+H8889G3PndSGniSh7wJiR42GaJkOrlNJNnBXmJ5D5JSV1gxRaFL9CT5PMN322lSeXaWrMM1qIrdcfAWJ7TBuTwbNvLsd7C7qx2VgV2WHN2GaLbfj8WrZoEUJfQktDEhXbxafdLuZ91onWEe2sg02nkuxwTeZ4KU3FC39++ms/zwnT1kO5UmKYK06BHzIlHbIVWJ3EMJTxYCQlkPPcNhuMwoIVXRBp1G6ZIAYEqdXoNVFFHaoUcKNGvCdJ9uFLgFsNUS24rBQiqJh691wDhRiIHAXDzBG6EhN3iyGa2FjUNkntJCCZ0rBwbpkfQ+yODJR7qUWiIkhEQkO7hnRWoGs/Q+lpSYcuGah4NgSZYAniq5Aek94rmTls5OjsIU4lN4lXFIYxXE2QI513oQ85CGAoCmqkbmLnZ4lhcYuCRZvaWQKfjiKs6OpHtVaF6RF3xucLEzUkBHV7FHcjCzAUmZ3umzQB1YoP23eZU0MQekYiKTvghD4SqoqSEzH8Z3k2uzqT0sgasCBQ4yCoqHoec1MC2vhR1KfvEg4HhxRUdF6kkvA9n1WgukjrSMAGeblEglW5vVYNqihy80SbInqbM9Tg+Q50UYFPTtOkwCJjQlqHiedI+0ldYiqDSNcCklgLGjKygUKtAlGTkJY1eMQPdXyomoSa57MC06d0d5V6I8LnBRiSikKhBtmP4KdD5MQk0hT5IEhYtLIDWiaOt8gkUvwa03NsS7UgqaehwEfJ6oVN/rS2wzwsSVS4uYr8gDcJMj3/yIEYyEhpGrJKGr5nI5Fs4PVe0qhp8TFYK6Hm1uC4RYReiLScRlPLMA5X7TdrKNaKrKijTS5ZqjSkNDimx9cBgqhJIecTl40AWzKAJRNE32auU4OeREuigTe/ROkRbA8iNcOkovNFJBNZ+MQBJeqDT3zBOASbIkaIyyn4IarwWc2YadQxumE4PluwGLrosOO9azncjNmpBBKCguee+7QOddWrXvWqV73qVa96rao61PUVE5/W9hGcBUJGXWwUpyrYaO1RTOhqy2uYMmEMfv/Ma/jtH95Fy4h2WHbAuxga4XoVG3JDEvttMxqBqqDXKtOAFaETQtYVLO4twTMdJBUan3poTKfRPViDZ5poTOoIYiEHhFDmuIhSpcq7Dcq/0Eg1QYoeSWEDrlKtzONXyjOi3SJPd0QtnjBFHlunR7IAeCEaM2kkIg/tzW1suJhMpFEs15iIm0omUSyVWamSzibRkM6xhwz5CuWSKdiOiSJNj2QJA6V+LO7uhkljWmLnCwJGphrQU0shECWUu97j6ZYcOshkFBQdA1pCgUYhqqqCpKqDYgqrjsOQQlJVeVfjsULMZeJmzbKRb8ggtMvQVQO2S3AXjbN13jkYepIzlFi5AvKWkOCRckQxUDEpT8eDIoYQZArh0yHYFUhGmonMcuAwhEfUbclzeEcq5IbBK3Qhnc/hTy9+gm/vujkuPuP7uO7WX+HF596B2tiC6RtvBFkbmviUqujq6MbKRfMxuU3B1EkjYBsGBrp6mGza21XBNhtNxoxJ4/HsG+/grkc+xKyJTdAl2gHqvHtraMrBC0Q8/vxHDH9uvulUvP/JAuQbGzBrgw1YiddXKKLQ04dyqcKjcCI6yqQSIR+WoSkFTQho8pbKGij1DWKdsQYcPYHG9lF49vd/xj9aW26/M6qWyURqhtZomsOwAvl7xMRkgi0oR2vRvDisd/K0maxyWfDph5g4dSbv+EiBZrHvEM0XIs5mSmd02EGEjafmMLYxCTlQ0D5xLXywsAMtY8dj9p9fZOLj/M4Ctpg1BmmhhonrTscjz85Dd3eVCbHJZBpJXUMqZeCDt75epAXVhGnro1wt8xSL1DI0uVqVfUVFEx+aP2K1CSDFOXgYNTaLUU0N6C5XeVJZMD1Y9HxrAfJE+JQD+FUfoko+W4QdAYVOeg0p6JjuA5A0CYEVINcaB4/SRIL8Xuhz5EVQNAW2Q141LjgAQo2QU0UsX2JxfACL+mhtInPDPvIXC/k4HjlDh8UQNJngBRBDAVmZpi9AxbaRkAWOZCFHGRIQMBGW3leFYgMkyLTOSBI/domysnwfsmpgoNoF36PwYwOq5GPmxMmcV9Ux0MNwx+KViyHS1FihCQUpXTUEsGNDwFBGqOs8WaFMP5qkaBH5xBCxPcnHGpFfS2YZpuXxrt3kCQ7lWAVoIMcwInAjRGGAYiMihEkiznsMeRMsTx5C9Nwc24QoG6i5dNsS0qR+o9ecoP0oAj0qmizVfC/2SCPvGt+BFwrQVIL9fBh0jNPr6jk8ASTFVjZB6iQhVqiCJoPkwUTeREmSkcD3I/Y+o3VMHLoPCsGg50jQtB/5COi8VUgPFsAfpOl6HM1RLVjIJDQEcgizSpMPEZObm7BioI/9mQRDQiapMgmYpvEpWYcSSlAo74rgSYLQBAGmV4QZ+EjJCY61NkMRpmuhgabUbsQqZN9y4cse2nLt8OjYUg24kQjTs5E3EkhyfKKEgdBCYaAHo5pHIJAERgg6O5czrEdTcyLkk0JOo4lVrYakpMNTSBBDUymfTRrTOkXPpFCkeAu3CjWRxOh0E5KBAl+JUDRrSKkGUokcBpwSdEHFoFVmageFMfV2dqJYdWEkJDQ0G/BMH2bNw7isxgGpFPJNk2G6PxLQCFoOyzsG8OGHy+pQ19dtfJINbUPep7ToUcYKBZNK0GnsX/Ow2brj8fr8Hgi1Kqczc0g0cUZ8DzK5NqsSKpWIR6IRuXiaPufFSM0JtDXIWDm3jIkbZWCkkxADCSu7i0hJAUzfhySpsHxK8o2DCEn6oUgaLyqUOE6wlEMjaVmHniRlSITBwSpswqkVgqGyGN6UQ61W5tGtGzosdRQEhRfLrGxwfhDxdhI6GaHFJ6EaqQidfuYV6HoSGcNAkkfFCsLQgxi4EAQZjdk8VvYV8HHPEuYhEX9jeLKBx6J0gfPMiEMTST6q6QmIqoCKbUGUNIQ+KXcCeIGJtJqm4TQvEsRTIkfcVCoHV4xQ6OtDIp3nMbHjeWw65pBDqSIhm83BJl2oXYMnBSwnJ/5JsVJGvnk8hMji7C0aUbdPmgE1k8Fn781GJhubv9EiIZCsFqT0EBGEItJJ4kdU8PpHBUyeOgwbTs2jKZFE10ABCnExZPrbIt76uAPjN96WnXQH+wsY7OvEyGxs9OXYHlb02pBFD66UQEp2sNa4Rs6WTCd1rLfWaCxZ0YuOrjLzlTJpMh4UoSWb8cJnvajWfEwcN5ZT1mkhLVcqKA0OsnLKc+OsIUOTkUgYWLbwUwwbMZHxd2oy6I0mXkSlvw+TRufROHw4bDHCe698dYr3V9WMjbdAYbDEackeNaeRD1EUmddA5pmqovBx8cn7s//mbY2bOIUzxnxWr/jo6VzJPx89rgWbTm9GFCiYNm0yXn/6RXxUlvDdPXaFk8hh/Q03xnPPPYm3n30ci7slZBIyqwRJFKwZ1MwmsPyz9/6h5zVzw83gEtzixYZqZK9gUTI88aXILyI+2WM+D/2PIFnagFCPIXG8JJKtDgxJRk7V0FGtMqwcUPokuZfTa0Qu68SrcVwO06REcQKxln/mwUiRU7uAWilC81gNKjkVB9QcSbAGXUQKhQbT+UHqJ8rKI9kwpVPTe0tJ4LR58DDQ68KuCZxQn6Hcv9aIM65kR+SLJ4VayuSjQaGbXoiEQo1VgIpNTvAR81ncMGLOjkShpZQZSLnhXoQkpZ8bRpxJGEqQNYIok/x4+mtVbgQis4ip06bjzQ8+BQQXqiwgResFnecheRCTUktktaUqeDADCZkUqdRIxRNCD4i/p8IjOJGaIC9CtjEPu+owbKHpKkxSBBHMTe+Tb0MQfYajKuzyTWshUAssJEjFRC2WH0L2BKQNGSWb6I4EHwKSIUMnp/2AVD8CGqg5CVyG9OiYpA0D5xRGtGmMm5IgouwsjaGYGBqnVHkJHvNbyLzVgsi/GxcpwlyS8ksSUgSrEW8xETtZc7o42Z2QQlHilgCeE8JwBSQFBcXIgdagMx8zLZISVEY2mcLCgZW8ThPER4aa1Hgbhs6QNlmq0OurqwmUnBqy/P7I3JzR8UswP1mDOLLARppy4EOWyUogYrm+SMQEXUXJpdumjaWGpJGDLhiwnX5UrQpm5EZANDLo8y1IkYMS2XYIAiqeg1LN5vQAus2ib/NrkCXbEs+FqghQAgHpTCNzkXQoyGez+LR/GVRqPgMfOSWBZK4RC3o60aAkUXRLvJlMiBpzUWUhQNWusUkhnZfZvIGmVCO/TwuWdTN8Orw5hYGlfUiLKmwxhG8F+GCJg+EjdKxc3FFvfL5u46Plh7GsMXZAJSdNiQ9kImzRgUXFbqu2i2FNKnINOfR1FdBVC7lRiS8UMnSDsGBKT6aLbRx02DvoQ45EjJ9KB6OCRYt7oBsye1i4IhFkiQhGacK0ANLZ4sM0K+zeS5Lz9jFtGN/ahqpjQtcSyOfoQrEh5nzwLkaOGInX33kfg5UK7GoFqp7inZ0SRDFGTQ7R1PnzCUqTlghCQMTR2BfGDB32qIhCutgYaGzIs59JSpDR3NCEUErypKlcq6K32I8Vg0tY+t5MRGY/9vyw2Vk2iX7LZpyduAI2eV8wT1tlPJgkzgaRDQPyfRhKco0UaEkiKQMqhwlqqJQHOI2e8H56/DlZgpZKQxZ1BLwgAj0DJsdJeExy5j/n1GOD7ivyICQScGoWkukU79ic0GWppKhIWDhAviUxqZV2ZuTwOnpCMz79+DM8+PPz0dIyHGde/QDM3h68/2EXNtpwBE45dDecftl9CCWDL1LFYgGVUhVNDYk4foHiJyQiMKpY0VHD8JYEZo1JMLdBoGmPKuPjBV3or4nYdfNJ6J3/KbbeaSus7K3h/ZUuN9bk0ky29Nx8uOTBGvGiQKGxixd8tvp4HT52CvvpkFycdpfkjjtQDnDBWftg1rQp2HPPI/+u4/57hxyEnffaDouW9OO+Ox9EoVCGYxNp0ucFjxbHdCaBZQvn4v+nJk+dyjvvBfNWAhGlcXogfXOuhVzSe2FHMmrdFPMCjFtrShz4SF5Z4RdIxpIGw9A4zDSla5gz++W/eb8TZ2zAt0U8DuYfEUGcSKfcNMZRFFTEXSHeEk13VEniaIhMqgo3FJBulJjTQBPOEk0bVB2eHXCyNxHGKDSWjnGaE9HPyF7BLHqoFR0m7BIhuXmMDtUgnyMivtJjkSFIPgKRGgaVpzs0ydSp4+I+TIROE43Igx4q6C9ZaBiuwRAj1EoBXF+AYoQwBXIHJv4OTT45WAE28atcD4KW4ukmEVJdctClc4SIp2TVQRMuTYTqCpAciyMEah5JNOg1oABJ4viESNDFlly3XcBQI8iJHAqFIvP/qCmiiz21T8S1S0gky9YQuJSaTQHN1ACRFYbPz1uTIjg+EZxpa0fBtCICStkWZI7hMU1a+wJIZMVMJHnZQ0SbQoqA0FIcHaELEnuK0dQhooBbnnxQ5Ae5Siu0lMRp80I8IQ8D4oGoUIiAr0osoKBgzpK/KnYoll4TCdv1iFuowBNcJIwsHy/U/pLdgOh58Cjgmd4t4jeSDQa9AvR+IECaxvUIYekKh6gS2zKeqVETGvAUSvZpiuRDlVTmOzJpKAhR9T0kjQRGpbKoeORarSGnqkyUnzvQiVLNhErXBXLwt1QIKQkhuULTpgBAg6qylz49Z0MPYQU+p8mT03IikUWSJimRhNZMCivsfpSqVTieTFQpSD65aWfQnmjG0sJciI6P4a3jeOPqVXuI3IaaWeV1P0WbQJlCWE2exndbA2hPNaG/1ouMpLNMP1I0tMgJ1GwTkabCodeMGiElFugTV5Kcp+n4o/eCNgpluwzZ8TlKxXFtVDwfVc/mDezwhibkJJ2J2KbtQHBo0lpjJ3PVd9GkJ/DGSpOHBT1L/3bjM0TPr1e96lWvetWrXvX67686x+crJj56wwj+ngMKSbbJmD/tOEMIFAg4ZGzmOw7LJ8mUbWxrAiuKpLShXY4ATVdYXr3JpBw+6unDWg2NEDMKTNGD6APzFvayiok2CRmNYCcDkq6hd4DMx8gokLpgl02jmrJpbLjexjj6sKMgaWk8cP+teOmNF9CSyrC7M+WxSIKG9hHtPCrs6+tDlUIgKXhPEBmHTmVzseOsQ2ZbUrxbYuNMlWE0clyl52MQdkyqksCDXa0hk8shKZOaysKoEeMwcdQILFq6HGtPn44Vy7vw6sIPEJFM06OQVtKTEaNJZXMtug8lQZMbgr0iJFMpJBIZ2N0lHmEjIkszsKKkRvJWyrwhR2jPhZEkCCqJnJZCb6XKJl867VojCa5LvIwaP/6qQ+7FQL59LLzupegoOmhOqiwbLVYtJHUdgiYjdMiN1kGydSQ5EaJYqqKvz+TdJykiaBxO+3Ua3ZMZnOeJGKx6mNiehCLa2GyjmbjjF3/A8NFjaYPGU4O+viI7zeY0UjdR9hQpQ4gXpkAkAzOmYggomT5mTWpFza5hQqOBCRNGYGVNxWDFwjvzu+ANFjC2PQHPaIdpuagUK6iUivBoVM4cHhmZdArLFq85cZm+7sassCJ5PXHM6PiknWhPxwAit/8fWgzW3WYzvP/i62gZNRGmZbPBID12jXhZCR1LvzBp+mfXehtuEGfgBbGSipyMSb1H/CIq2hnSOUHnVs2JX2OSx5NCSZFoIiXhsy+4Pk9ZZ4M4C4zO0SCMA1HJ/DOk94ngDJoCrHrPmVDHkBPxZMhstLiyAGQt5PNJjJ/cxudFT18R+WQCqmSgZNX4GDBrsfGgShw7uKxIovitWqfHMnPmCUkCMsMUCErEsl636kIJADcig2NSyZAaJzZ9DEOb7Srsmo+EFsKg0MoAsFRSzlAQlw5ZA1qbVFYlWV4E1w1RocmDovNrRmtPSg15MuK5IrsdS+T4TccRyYoJKhcj5mcQlKOT6jgkJY0KT5URuLETPT0ehn4Ej/mIbkBSZB/5dAKCQFytGsO6NCwmewjmdYVAmrgXpE61Cfan942k1QI0kpCTopLAljCCExGviibPAnPGPFdg5ZamZRFZJB1XYYU+PHMQEkEzdHzzoCoYMvZTecpL6wcFu9Ia5HoWXCnDkyZ6byVJY3hTJaWnaLArNgV3NhgqJNfDIDlzCyoEcnEWZEiBx5YBDkdQKexOTwovgnXIYFYMfTZRJQUj0RrY6FXUGRaL6HSnPEMHCEnhmvb5vohioAkByuSuTKqmkF5fmraRQ77Kf0uqMIFCS4MIiisgIPhGo2NXYKM+UlyVXRM5OYmy7zA9ICUIrOiyaH13bWRkhWEfy/aRlylDTOdJji07qIY+JreOgh/JGGmk0W+VkEroWNi1nCXvBImSIWPayGNcrhmdtT5+PXRZQorMYVUdfdUq87syahpd5SKEyGe4zYKJsdk2DFRKqPpVTGwcDSOk6WIFQjqFPtNGJplBrVKERm7fNL0kFZZH77fEk3zHtaCSA7SkQCRLEuJHJRrYxDNwTbjVGrxIhKrraEipMHQZY8ePwWCRTH096JrJ79Of/tyBnqWddajr6zY+mWHjeJFlfxIKmwtoHB4vlHEge0y+i8M743iIaMjfIraKpzdJxuSxSdRKFfS4FoblkhjwAkQ1IJmW0D9YgRSJyOXILp6cmwX2eqDAu5Qhc4Oy6bpTEbp0AZDgJZJ49fXnYQ7YBBZj1LTh2GndbfDZnNl49d350LIiXD/E5rPWw8vPv8OP5eDD9sGCBZ+go78XkUpQj4NM0kA6kYZtVeAFEbud0og4pSQh6xlkEyr6C/18EQpcC97Q2HutMROQTmixQ2wADG9t57FjoVTAi++8iUD0mAvFvh+82JFsFfDJhZmk8hRoSjBiysDysocBC2ghuWLgcUieI5DE0YZOUlUQCVqDltDQkNA4zDFJ0KEsMyy1om+AYxtodF6plqAoiaFF2uWkYoIKTLvMmHoymYftetDEKozGESgoo9Dz4du8UAcecR6G3k/ioTBQETGBmC6sEvONurH9tjNgOSo+m7+SYReCPi84bXecctY9+N4uMxlCXNJT4WbK8l20NGRYav32J11ozCZiQvrQiHXFiiJah2fQklIxc/p4rPSA3qV9CGh8H4q8cBEJ23VshMQZkySkUwmsXDrvK4/bqTM34pgL17FiTxKVZN861tt4CrbZZhscvt/hf/PYnzprQxSLJYaW6HgmjglZBmiaggWffIB/Rc2YtSE+/Asu0YiJ01FzYriKTkZqNqpmEY1NaShikp1iqQHgKBkCU8h52Y/Jy7FanS7MZOBCvuR0vtLFmXindJxLaMhFaB6mY+qM9dEoJ9HRsRwRcTtcB7VKDX19ZZhODbJKx6LPIbNEMvV8m2HB3rkWjAaJ+QmEfFLqdapZQ1oP4NvksUWOwjFMw445LGGPibBuzeSmgZovIRFA8wQkIMBWNCbtV4oORzVkKQW+6nNcBR2zviQy34XWqrJvg85C2gy0pSTUSF7suqi4lPwtsE9XSMHDOsVPBOzLRVCxTU0KXdKZ5K0yD458esjaWYTF64Ppy8wPSqSScJzykN0Ewf7UAtDbITNvjppAMVTgkQs8RT4IQIuuwKR0CQp4DWWYNQcJQ0OhWOE1hV57IuzSGuubDtS0zlA2cU6SuQQkJ+BzVfI0fv+IT0Uu9kTVrnoUIO7DE2nzRTYWavxeGwYEj3g2DkKCWWKcD4pMnmQOR04QdMkeYRoFMNPGNoStSbyx9SiKgjNKCEqrscM4vRoOcRvJ/oADO0X4RMYmGgERfqmhdSQoKfI/omae4BwBLgV/kvyeyNOEiEsSR0qQksXIJ6C4IUyrwrdBF36XvHFEasZkCKELhbyhyOWZ3NGlEJlUBgMVCyY5NwcuN5/syUSNRBShwchBilxYHKpqoD2TZVdtzQrQmEhhxsyZTGZf2bMMCa0J/eV+eD4FI5tYXiyh161CDkkU08Jc0MFqkTciGntLhcxDJMsVuA5acw0I7Qie4mL6qIl8fC8e6Obn1lvsRcqO0NSYRcGroeqbmPNuAC0nYtRoWtOTbJtAG/1MOgs1oSKvNvA6PzKfR0eliJW9S6GnkkgZOqqmie5+H+VBH90LBjFyfANWdA1i8uTR6O2tYnDF4jrUVa961ate9apXver1Hwl1dXR04IwzzsCTTz7JGUCTJk3CXXfdhfXWW4//nZ7KRRddhNtvvx2FQgEbbbQRfv7zn2PatGn/8MSnYdQUJhaSksB3HQ6GpN0UwV20c+TUUIE0GkI8KR8iPAscuCbwrkfXJIwZKaI8WIVMo/CIyH0aiq4DxScCpExhPhBpV59Moly14FRq7PKcNjQsHxjE1utviJlTZiAodyMzeR1c/vNroEJDSpB4xLjjdrtg/JT1sNUW2+H6K8/GZx99BD2ZxvDWVuRb8pja1oyzz7mVH9uuO0xHd6UIO8qhOZ/DYP8gIIUomTTq9JhgNnnceOgJnfZkGCwWIQYkIdfQ3TeAsWMmQRVpNxlg0YouOB7J20NsMnUdvPHZh+TNx9kpnN2iGExUJpJxhcbHnschp/l0DvOWFNHSQs62lMkEVH2gkUy7yGCMwlZd2rFQHhLtBjQkyGCMdva0j2TusERbKh7Nk3mWYFc5p6zm2EiSSkRRUCA5aUh5ORoi+nuBQgollCsEoZDBFpGZacoTS/JpcsCfaPdHcwD+HznrxvlA9NiIwEjO1TRFoGyitaa1YenCHoxoENHclIEAD0mRdmuEHxoxbAOgEhl47oVPMXJkA1zaAQ5NHhjeINInyNGWjP9MQEzBoZ0UT6A4CZFhru6VC/7H43aTrXZApWKiZtU4NJaOU0kR0bFwLjbeahNsu+kEXHLpfTj8hBNw8hln4O1n7sPhh5/Df3vfYz/DBVf+Cf7ACrYTIHNIg4wsVQUKQrw3+1X8O9W4GRuhXKrCpskFGZ7x1IfeV5LnqoQW8Ou2KlyUFzh6H2m3z5AZqY7ivKi4yLYiQmiFGDdJhp4UscGW20MSEnD6+zH7vXdQdipoyudQK9V4xqAKCuctEfGc84giwIlqsAbIXTyCR6aePMmhiY+ESE2iocGDR+cHkW9JZeS57PRO1sw0HSVzT5oIwCCjPh+F5RZPXrKtMptykjDAL9oodLvQ0hGMkXHgJ/1OzNaU4DEUQ4LHAA2GjIpHCYEiG3lKkgyZIPRIhhkCGRVwyyUIUgJBMg6DpCkVmfWJHkFdPpuO0vmSoGBVcg2UZA5HVY0EisW+1dMyNnukaQcZWooCq0gVzlwDw1K9tdjJN5/QoRGMI4nwLYK/ELsZc/Ay2TVECMT4faU1QNYkzsZSQdNsG5KSjqX8IU2tYsiecgkpwFIkUi29xTTRYQd7jaemQmDCF0Rkjcxq+weDMsVCImPTuh7xVDsKPZZg+5QNRYFoTg1JPcXEY+ImiFFs1FcK6TaJxE1KLxEaJFgc5hwHkxKMSkHRREqHQ4T6iAn8NP0huTe9xuRIT0o8eiwiGeEK8XpFsnyiHbDUnwwPyaCU1HcE/dJ6FNHKLLHwhhRgVZ8gIFqbKEsrROCYSGcyKLg+SNPvKhHac40QyUHbIE9nn4UooRsydDZjxHhYXhWylODXpj2bQ095EKbjoKPUx87igiJzeG9jIsnXNSLN6yIwWK0gk86jUhnEqOY2JJMa6WTx3MsdqPYWiM3NUvPmCS3YctMsnCCNdz7sYHi4rSkm5edCAR4bzAYIZbJQkJlykYpSWF5YgfVHT0J+VDsWdCxHVxcwb/Eg2jJCHAruEPxKiszY2FEkR/IoQmHFov8eqIsamVmzZvHY/thjj0VLSwsWLVqEMWPGYPz48fw7V1xxBS655BLce++93BRdfPHFePnllzFv3jyk0+l/qPFpmzSTR5E0Fuak5sDlxZO5AbSIDslfv7B0ckgdHYOE1dIYVpOAfs/HJpMNaDZBOuDEc9O3EdGiSTLQYY0QrQCVwIVVqcH0Ag4qpaqVyUa/iqMOOgZ77XMALrv9Z1jw4Weo9q6EY9XQNiqHsy+/Az848Cg05VuxwZZj8J1dvo33330J/b0qvvWtLbD/zgf81ee5+16b4sOPFwOazp4hNGrsHSijqaWB7fNrNYuT2nP5FNyQmrcBhlBI7RKYdAqG7J1g2RYaMzmU7RJULcGeOuQ/Q68hOQunEkIcgkigO6X7ugIGKj70hIymBh1NooT5xSLasg3s02BbhNNHCAWL9AkICW4a8hoh/xFa4En1ISnULqic7NuYUFkiX/FlNCgqirUy8ya0SGbIy1dJjRKiu89jVQpBiuLQUU9NEV1wZAqTpEWcPnOEgAvPtvg5UNgm/27c2/IFhJrbeJIuYHirhlxCglmhBZK8inSAYj9EBQlNQq6pibkMxCUaGCjizTkrSS6DTEZnfghdiOn1oUBO+pqgBL4z4mEJgEaKqnQSuXQSb7724t88hqessx7DeMRtIciKGpj5cz/GhFnrQNZyKPUsx7SxOTz9pzj64cQLT8fzf3iZvYnIriCXb8A1N96GZ/78Iq45+yj8u9X4dTbhxsehDQk9T7rY03vEUmeCKwm15P/n36f3ibyEUjkFrk+8lZh3Eje3sXcPJYOHtodEYwkjhg1D1XYxadwEWOUyPl2+lGXc5NVDUAyJuEiRQ7dDgZTEY6EmV4SDajFEpc+DkREY3vRLJozGFHJtGST0gP1yXAo0rrnINKTY1yoy6b2iZpwuXB5ChZywQ/TPtZAdRsGagFMNobaq0BIS4Ans75LIyawWE6QQqUDBgCSxdxZ5BckUUhuFsEMKT46g00WaG7H4+CYOX5rcy+k+tSRfiCWPmiuNIw8kwWeIhOBEXYvgWYCjK5ADUgYRDCqhGlT4fKcLjkK+SnIIzSfVlwibsCdFwoBj8oWa11I1QqQYfC7A8lkVR0UxBwSRgdZFSjMnVZyms9KKXmV6jFUKDFV0KAb5FQtQyRun5iIQfG5WyB+H+FuWaccwtS5CF0Q4joWeqouGbI4l10WzyCoz6rHINiR0AubTUII6bXrIaZs2rAR4u2YZLjX/Li0zPkxqLonHqMp8ThJ0TxEVESnUFIIGqSGh95EgKo6gZS813kzFptB0tkP2A5bRs9s22aO4Fq+/RBMg8+h4pYygqdQEBBAVjZ37JVKmUVMkaswtIm6LF1ncuCrkKO25cHwH2WSeU84ToQRXJyiPOJE28tkmtitQNQMDhTKKdhEbTVwbn3UsRaFSgChr0AUZtktK1BFQFR26BlQKA6y4a8k2orPYg5RhYExjO7oKBY6pcUIHI9uH4/153Xj/tU40tsaSfebGSgKrTtee0Yj33yxi3IwGrKjJWH+sjtGqj6Ksot+14deK3Ix6pFwsFzG8uYXpF56poL8ILJq9EKOmjWZrB3odycQ6dq+nZjFuNuk4pFe5uGL+32x8Yvblf0BRUzNy5Ejcc889q39GTc+qov7t+uuvxznnnIO99tqLf/aLX/wCra2tePDBB3H00Uf/Sx53vepVr3rVq171+vep/5iJz9SpU7HTTjth5cqVeOmllzB8+HAcd9xxOPLI2Kdk8eLFPPl57733eDK0qvbcc0/kcjlugv5akZ8MfXxx4kMN1rgZG7OHBAfMkf8N5/jERlekOOFQOkVExfTiHUwkQiTVCe34ZWD0+EaMa7bw+ocufEXC6CYfSU2G6YEzbYTQQVnXkE2kkEpn8M5Hi5BKicgrFGZIqgFgYNDlzJrv7783lg5U8dBDbyI/zMSwtgR+dduLOOLYg7H7ngfivGMOpzk7oDRj0g6bYP4HL2HW+hthzIR1MOf532HakT/CbuPyWNm5HBttuQN2nTgDr7z9JA4+9EBA1LDB9HXhWCbe+XgezAhoymdQLFeRyyV4ylCuuOjr6mSSX0R5LCkBamjAI38MIgOK5BHiQSN4SySGPmW4EMmUDMtoRE1eJBTk5yCXjqcw5DRrhmR+pqHkWZAljc3VyDyMlBqkMqBsGSqBhm00AmUvFwtRqEBJCOyETY8tn9XYi8iLdAxvIOddCa7j8HicRsWy6OP1TyvIJWXQBJjcNTjQT1UgKypnZ/E4mRQF5Dwb+KiWSrDKJbiOybteGnGzQwu9vwzRxQGJqYSEsuths6mNqFVdVN3Ya0YNLIi6jpaGBib4EXk0EMhbKMLseQMoDFbQ3NqGvoF+hrxIpTA8p8OWVVRqlHFFKgtShEls6Eb+HumkgXf/QafitdfbgHePNH0iV+DYwTbAu6+/hU23nIFtN1sHv3l+DrxqbIqZSCSRzzdwxtGzf/gV/h1r9NSNUKNQUZr4MHmU4ApSXsYqqjV8eejdoKmZIcBIaiiVeb8Yh4cO/QLDmExuDuC5JYyc0I6N152B/mXL0NFbwqBT4108kZgZmXIihnPofaHzPiDYmtSMhE3oZC7nwClF7NacazVQqxAsK0FRKeOJXNQDzrdTRAOVigOnQpMXgnnouIyQbBSQb84g2ahhwVt9UPMCUkkVVSFAIpJgpGT2ZyF3d99MAqKNhKHCpIkPhcIGlAdF7sGxSo4mGzTRchlmi9gYMCHFajea7iKRZPIzy8dIkSk6SKl0HHqIFAFZlQQcGkpRiMAP0BAIqNL5SKo4z0MmQ+6/PhlUMwxFG2/KMKMcQfYPGtqY0lSF1ptOn3xYCFbS2M1YjAJ4pNcgd2OBPHto0k6fCcoG9JCRIgRE3KXXSEvCdwk+J5UbeR4p8PWAw0+JLUznMU0oyI+MyLcli1gJMqvdFIGmZhpAHlWayJ49BJmSICOQQp5O0dTKJ6+hyIVBlAJS3RHUR9MSQsokcudWEPkmT3gEQ+dwVfJtI3iT4GvyJfIZ6gELTgj+p/Bqco9HQJOtAJlQRYWes0j+PjKHtpZsi31rKNOMAptpMkzkeJoA0zUoremosWEiZSuSAasGk6gS5H1GRGNJQOAIbFSophUEqogkKACUJvNZnoCFnsDUDfIzSmlJVtcGfpUnzqTwLRNx3xd5qkXlwUNLtgERvc5+DUklAyGS0FsoQ5Z89BQ9dH0GNLcSVYEClEmJyPI19nAj5RZN+LtXOJi8UQb5pIvIoVy1LKqoYdFnJnJ5FZrQhI6F3RgxwYBvJNCgi6gMkEEu0UcUVtaxgaoMfPjm5+tg85ipfC2iiRmhjT2LPv7vgbr0WOqDU089Ffvuuy9mz56NU045BbfddhsOOeQQvP7669hss82YB9Te3r7674466igsW7YMTz/914MML7zwQuYF/WVNXn9LNjLzSflBF/ihxGa6CBL8wTb+NMomZRBfGGNOBqkEOFBdEmGVazAysfCSDM1oQSCDP+RzmNTSh6JFC6WK/nIVVpeF1oyChGxAT8pY3kE29D5szYIntGJ4Nsmp0IPFJdhwg+2waH4PZMnlBZQbs5DCOFPQDcKWSY1EBwsNW+MgT1aiCcCcV17Ejkfuj6232xQpcxBTJszAb5/8E4olFwd+ey8cc9rZUKMqhEQKpf5ujGofjnRSQalqYaBYhOTKKPk1liA2NzehREGmAwPINSSRSmQRuDaigKzkYwdOLRTgSzK7ShMCTzLaqOKzssxn9QcNfyNIHuARth9oqIUKUq4CV/CQUCnYzoFLbrYeGZ8FMAwRoutxuj1JRcWIFkFSOsS8KUmRoAkh1EQCkS9CjEy8OrsXze1peJ7EsQckP9aTGaTSaTbCU8gxlEfvAhtFDnR1oVYYiBcKCmakkTaNbqm5ZT5QHAOQTutobdLRkJRgBpT47nE6seXVeJ6ey6Y4TNGgfiwEsoaKZ+ebyIsko6djiOTzJJt3ccER2wJqBg888R5c24JpU8wBcUTIjdvA0nlz/inn0swNNuPmh9QhdIwQxEKwUQgJR51yBh5/6BcMjz37xKP4d6uZG22LnoECR2kQp4cvvkNLGLkCE6+HtD7ExMKQKlMUE7FBpxBDiTGYEJ8PpMjkoFVW8hF7hyAYE1vPmIJlPX3oGCgikRA5bTuGKQDLpNiEEIIvQTTI1FSCCwHplMbKzpyio7NzEJVqSFfz2ClcEphzJUkCqhRXkAqhGfTae9DzKvwSSd11SAkXvk4mfwoih2InTOY9pKMAFY84NIAylEpO18ViRCG/EpwgYl6gV6nBDgMYQsThw6S8IaaWG5F1RBzySdC2IqpwPIdNAOmxsfOzHCBghIrOxwjlMOTGngxJKWSUTOh0km57AVtPUOwGKXoMQ4YiRigWLTZfJRiaGndaE3WFnJrJ3kFEJMkYDCleRmFOB1Gs6DmwseRQY0JWfEIkM7xNj40kzLSRJCRMcEKoIkVz6MwvJE4PmQjYZHZKjt5EpaGAZimCTfwfUjqpaaTkFKq+xVAlIURkc0HcIZJWh6rGRq+0XhIExjxCUoFRmjm5z1dNiMSdCeJ0etrz0mOlBimh6rCG1nbXNLnpIL4JwWJ0V2zYSGuRrHMaOvEhRTKNlQQMVsmRPeaOyqKMSI75g1QEp0oxIS3mOzmx6aaupSASgYtYW9H/Y+8/oDVLz7tO9Lfz3l8OJ59TOVfnrG7LasmyZCyBjRNgm+SBAQaGIcyMPYaZuzDDsgeYxeXO4GFs5oINXI8tj20wWLaipVaru9Wpuqu6cj45fvnbOdz1vF+1HEDYFjamW+fpVaurTlWdOuf79n73+z7P///7S/RIoDYrnlCkZU3KUOtykIsUQb4u0aFFzFVbDPMhWSh2/AzXrZIaE01czXEIIp08FPSfo9ZgIpssHmC7cieZhHlId1k0QyE0CppTNeqzgjCwKcRxHDlsb8uYVkCq91yB6vkjG32d0SDBXcx5+PgSD585yVtrd3jhV/vqACAbu3ZbNuaiURKNjk4aB6rBUMhJsRC9rIUrDQJJYncdvvS5X/7yenD8oafxg0j9eXV41eHuW6++e1xdssl49NFH+eEf/mHV0ZHRlXR7/vE//se/4c+9LTJ+u95+SH2l+sEf/EH1Ir39Y2Vl5ffse9iv/dqv/dqv/dqv3996x2h85ufn1bjr19eZM2f4uZ+bnErn5ubU/zc3N9Wffbu2t7eVzucrleM46sdvLnGJSItYRGpyFFAn/Xs8DCkJzVRuEhHDFqYK5hOlvezM1eSryLFKHkksZ8hCuSTE8WWkmup+rJtlbm9p6MOMmbkS9z14jJXNEbVGwsrODpt6xp/5ox9gTMHNKwYv/uLH1U6/fmCOC69eVAA3dWIqpLEvAl0JALS49upEsPqb69TDTxJEKQfOPsTN167zyX/y0/w3/9MPUjsIP//ZF1VDc/boCX7gr/9Z/vKf/muceeoY43GHvZ7JyrZGveIyVavgVtvMRj6bezucmT9Mq9UgKEZ86gsvkHmTeANxXkljKxXXmpyoNahmLqmY2EQtZ8WT10l4MdLVqZSYbjns+gEVt0Z/GHDqSJON7lhSeYgLi34cYXsarikCxTGxABZzU52ilMvKNYnDMWkW4qSWYmFsxxJCaLBU8nj08Tm29kboiv2hKcZSvVGmNT1NpVzDEnik5SqxdhD46muWboi0zdX1oITtMg2YRHtMqmBhYY65ZkZvNFBdQJXZVkxOcaWypU6Y4ppIDI2S47E6HvLkUZcgmebi9V3VPZyZL3Fipszr17eZro/59vcf4v/+zA3sVMaGcs0JpE3j2JmH1YlHxO9f+uJvHdPwleqNV7747/3448+8n5/7yR/Dcezf127Pe5/9IM9//jP/3t8ToWQgJzwl3p50eyauu0KJTAU+OY4NWtJNCQMqMybjnvB0pOspb6CcRpX3R3Fa1GBMNYcmPaI0M5lfLLPeWWMQBCpUMxpr7G3npLHG0bMmkWaSjG2VjRbHgeL52DKGlS7JZsDW2Mes/NrXLI5EReyRYOEpyfvScEo52bAgcT1sOyNMcjWeDZMIO3KINRHdFmokmwcFPbnubF3l6skX7QlgM4rx5CC+nZI3dUZJrkZmAqIL8gkUUOiCIZKzN1nqZfQhwt9URkQqViJVMQKJPVm3NNtQJobQTJVYVF4rp1JnPBySWGJukOzBCYhRfT4kHFNYNzIDNMgEeSM5gvLvZJPuiwRxCjdIQkGzTHo6+aQ7YxqEwoWR7DcZMZvQG42xlVM2JpdYiTjGKEqyPBGkPrnnqs6uqIAr4qQTxpAt4apifsjU504LQ3WlLJkSWBZ7kiEo93PFVJmJkYQdJyZJxVLQvFSL0HRxfxqMo1g5ttxcV904FduRmEpMLF0WPTWQx4V0gWCkng3iTpPujnbvGpM1JC8M6iXxe5nKxVUUMabh0vN9JWZuViuMZZwXyOeSeJFIjbKkSyNjw5L8W46uIlHKlvCMXNVtEieiMMlkvZcAaunaDYoER6Z+KpbEwS3blASImGcEMnaSUV1qqfeuYkuEks3sfJvROOGtS9vY0ilNxB2ZTCJ3ikjdJ+FI1lbp4OcqSkRzSqo7mvQtlrd88lxGVCV6O13KdRmDCUMpV1FA8kOglbpls/hIRssu85H3fpBfeO55Lr0+Ikty5hZ0OutiFpJun6y/QpSSjo9ISyb3qhKJWw6e7SjA75c+90tfvq8ee99HGIx9DKdAz8Q1qOYb766Nj4yxxJ316+vatWscOnRI/fzIkSNq8/OpT33qyxofeaiIHkiE0b/TuvTKxMJ7+vH3qZtf3D68Pe6SG1jB76QtO2nJKcaVLjf4vSVUVgClNVCGRZUhpVKYCwMnH7GzXFCWPyxhewOda29tsL0O7qM+YWBx9nADK2nyhU+e5+7Ni0w94jC4W6iLQhY2lQVmWipTRtqdlmVz7c1XvuL34+jyNUjAXqIcK/OnHuDf/Otf5n/7+z+GWe2oB/Y//OEf5sDpCbH67/+tH+a//x/+W0Y9scMmiggajnyMrs9Uo8zhuYNcX73DojbDH//oN/FLn/8iwTC6Z+1XxljSUICCkrUjPo2UhuYh/tU9X2y9kl0k6dOaIi9LAOKMZ2GHmbL6X1/dUxkuAnocj3OiQOCHFcay6Ykl2T3HVbk8kgI8AXepLDT1X6GCJy3DYDwc0SmEdNtiwRPIYcyFbckv0jFdCZMt+Pg//z/U9/wdf/kHJjlmop+Q19iU92syN1Y2Amlf38tPmoRZZtxdXufCpYTjxyroVoYuWivbUe+NbMaEemzHIUYmThlTjQ+6fkjFTXjsvhJJUVKbmiSaJDhv7EV0Bj4nD7tcvjCajFuFXpsIgTVRD6ML/xGbnv9QvfrCb+0Y+72ur3//h4iTlCeeeZ96kMjSKzoeGftK1pFkmKkk9XuuSnWtqcXWZHHe4PpyxtGZgul2zMquzuq62Po9TENefyGuyz08yWWalMwgJz8TiYsceFauuWyZgXIlZXGBXDaVqklvKyQIKlS8gNQDw9YYb9hKZyLZdhKUKCMZsyJBqibZKCE3RHs0ye4q9Iy96z6VaYv+SkF5SrbsDkmQUgilGZ1QF1dfTGbqlCXBPZ6MWWMNaoVFIGuGjGCCIW7dU7BTuQnkGjIMV4VXyghHRhCm4BTk8xQmUToG26biChVaOO7i/Jq4w/RySLlmy3aEJJe/LzTdUD0EZXwiIcBGvaQ2ZYk8jHLJWw5VILIkwBuaEKBDDM+egFyTnCQ3iOQeMzMCefAL9E5GXzKqkk2Fgh7marMaS/hxJtd5hmeWkcQ9ySnUU3E1SUioTmZIppdY4S3l6hQNTeQKkdqgCMQFKgdRGWUKpDFXLrWRaEMinzyIlZ5PxtuGK+v0hLws46hxPFJjpdxJFaZDnFSiJZJbPJaDWL2MryU4ohiUg6ulqVTwKBVHlVA1hCxskMl7Ji403VOoA7vsKEhiZzzCdkw6wxRtFKhNhGT4HapNKRRBYPpUyk08TaPXHZK6hYKXoslGMEPiR+u2pcZsW0IwFuhjyeXw3AxdydoKxM5eKE2THLYHcYgjtOkwEisjohwaBrKRgVrZ4sTCIoWhsbk75tVf3WBq0VGHK2UPV5Dee6NZdcibHCzknpncJPJeyD0XKnCl0lIGOaXKZNMjf0TAvVnhUpnyqNQjcAIGw5SnH3o/P/v8c1y4sEbZrGP6BeHAoFx1MQRLItod252gPsR1KQkJCgvjqJxAGb3/+k2PuvfVNW8p7ILgH+Tffxsi/FvVO0bj88orr/DMM88oPc4f+SN/RGl8ZNQlzJ7v/d7vVX9GNjg/8iM/opxfJ06cUGOxz33uc1+VnX3m0CmlrRANieh2ZNGUkl256D4i0fko3UehFmhJNJcXUjD5k62ObHvk9prYpJX2R9MnYaciQrsX2iZzbelCjDsx9723pk4T406Zi8/dZPZkk21tlUPHGphBg9XzgRIpCs1T7JBl1+P21bd+x6/l/LH7iIUgrbZjOcP+kLlTOtFWwc7eiMaBMn/kW79VBcA5oc8v/tLH0a0y5VpD3bhF7KsgTTlRXd+8Rbs9D+mQ8SCZ4NkdB9s1VNiidKXEOisW19zV0QcyjRcL7URbItRTQ8L+9IIj7Qa3Vrepu2W1YZR033LJFBkBOyOfdt1lGPiTU2UqLJycnfWUxXlvYmEWn7E30XEYwhGRZ4R8rJCTZUGtZDFnm6xUa1y5s0dzNOS+pz6AmYSYtkeumQzHMb3dLv5gSKb4Tak6WQsOXYSdSjwpwYmKXTLRk1gmdHYSnnx6hvEgJMuEdmxjOxaeLKSFRhiNldBSkOwDP2DQ7VOplNScPJLNnpYzNVWF1CYRHMB0SW1wb6/kdDtdpb/58iJQ8qiVXV75z2Cj8p+qjp58mJEKGZXuiAhxRW8lQvOJbb3kZYzHCdVSwcklj52RBHim5HpM6ZDH+mWLeDi5Hn9N3DzROKkS4a6KsRDezeREL/+XB3k41Cgv2kzNG+zciqjUJF7BpyjuMWyErqsnEMomvlAdgtkjLht3pF8rNluJ/XBxS/Jrm40bIfWGSfWgRiJ5NXGuohacVhVDzxl2I9VNmi5cdsbB5BSu4hcLLE8jFxGz2N8Rmq9DFElshK4E8rJJNB1XsZyESq4lsuGSDrUYDmw0S0Q2JiQp9aqtAjNFSxYnGr29EaWyh2OLoFewGjbxKFE8q1K1hDzr9kY+WiLBybkiqU+s2hZRIfwhEQ+LwNVXiIhqrYIf+IoNJTZ5SwuJtUnnSx5vYnqQTaMIM0SHGA4n3ZaGaPgUt0vO/5r0HJQeTahHKiYkG9PQNBLLQasZsCe6lhy3YhP2A7V5s13pwkhnqMCsOajE2EzepwLTswlGkXo9hKYsuxzRTYk+T9ZiIXEpNlMeKSOECHY9x1TxE8KYka9JLptUwp1VvEqiNkpTlTq25dGLhuo1l6DNtlNVnRujsFWnZRgN1QbvRHtObaLEDt+RLpfSgcmFmDMKQsqWzd1eh4pTpW1L93oiiC7rrur2jVV3MKfumMjbIc8l348xhPhdGPTHXXWF615JaSunKi3qDZfebsDly3s0a7Zap0QIL5uWTOJdRMuqiBzyCaUTOolrmmwlJk80dauog+29w588v+TdVNorDd1uMnd6SCYCfj+imxU8MnOM3Knx+vpFBD6txy7plnDtjHuW+fJkU2qI7T6mvzuJ2pGNo4iZy45DtWTz0vO/ptN9/4f+oDKq+LHEtogBKZ1wuoqCm68//+6xsz/xxBP8wi/8gtLk/O2//bdVh0fs629veqS+//u/X4ENxe31NsDwk5/85G9707Nf+7Vf+7Vf+7Vf7+56x3R8/lPV2x2f6szhCcxOTpWyx9ekBSi5P5LblSqwlOyyVeZPIV2didNCfm9S915W2cmrLs9EKySuDjnVyTxWTUwy0d1UqbUtNm9G9Jd9RXOefBqd3CwYb/RozIktemIRNSWHSQLmLp3/HX9/jz75Poa+TxAKyTiZnFYk8SYf056u0u3tkmoJB06c5ehsg+PHT6md+bnXX+X23bsYuUPJKzHsdXnoycfZXL/D8uo6060qyxt7lMslnIatTkijTqzsqDJea7caynk22unjlUx6UUoRW1h1U+XByLdb9WxGUYQeiiW0IJTuSqxRKksb3lCOAdU9MyVvaOKIUmNG4x4kzDIVLToZC+gLZcnUlINFI8hSpQlwJKDSFCdYQR6P6fQ7DHoF7akSO1mbQwcPEYZC687UvycdnzSSDKxYnbzl65LWuxz12s0629tb6v10HJ3p6YrqZol9deyLo0On4jlqxKVbOWEQU6u4BGnC+taeOuFI4ONeb6hOnYvTdczcUY4WQ6y2uUZ3L2IYiEV00gI2dRtbMAjVMhfPiTbra6OOnHqUwcifOCrvEZdFT6YJeFBeGS1RWp6Z+YJWSxw5Jp3Qp1wpsbUhXZhE6e3EKvRlK7vUvU6uInLLCPte9tekEwtuxaW+GCrERJGY7N5O6O/YLJ5JCXo+btlFM5QSDS2y2O2MJ9elOgfL6VmuVZuD9020DLl0keV0Kp2L0UhRlUsSFuyYk+vNTwjDDLM+cZ/Fg1hpH4R2LHRyCfwVyJz8WRnnipZC9BKio2k1qypDKh2Ku01GUAZWYVBY0O9H93KOxmo8IAgK27bI9ZR6u670NnsbA0Itp1IXJ6pgnXOGvRGlGYNgUBAbKVNemW6QocepeumkMyEQTmU3k/FQILZyCeeUnL1i8us4wiy56HpGKt1zuyDx5cVJMTRxWOmqk6PFKUEQqzG+6JA0ybjKNexQOnoSglqoLocKC9VzNNdhXKQKMBikBaW2ozoxSW8y0s8DDb2UU54tEw0S0kFMyXM5dGiaC1dW0JOEY4enFRZge6dPbOZ4mkfoBxOHkYxuTE11po2SqWQKcrCW7n8hb49ockQfVSScnl0kkLGaWVAvlSgbZa5trnNi8QhHpma5tHGLzd4uJWvS5Zj36uyEXcJxSFVClA2T7Xg8cdplBWUBOGYFg3Go8sEwCrzcwlC4BKFI24roPpYOUqaroOJaqYohBPswVKO4kJxmvcbxxXkcQ+eLL1/FzCxSmTPKN6dPuuNCwE6l4yMhwTKF0CbB0W9nzd2jPbwNkr9394hd/V5agV4gPE8JoT38qMldCVcODOqmw4HWDLvDISv9AfPtNoaToDseG28meOWyciJ7pYrS8QjNXPSVnW1ZG0WGYOLZLpWSybkX//2aP6knPvAHFfpDlmXJZDv33KfePR2f/9QlGxhpA6oUaBVjIBfAvXbf23NQ2RgJe0b1BScUWHVBvB1IKW+EapuKjVGNRJUorVo3SB1ZNKvMTU/jdwpe+8wmnmurmbyog0edsVqQJF13an5GtUllMZevQUIjr5x//av6vl5/+df0IYfOPKk2QDKfloWuuxHixxpe2+T2hcvceCPg1ddf5S//13+Fkw88yIuvvkyz0lTi3XqzOdFc5WIdF2usqZJ9MyNkOB5jODUqTQ/NjDk8N0Xky2zbYHunR+iHagPjGJPwVbG5igV0FPiqTS0PHWm7CtpfBAUSLSHhraKhMkX6KC5hwerbk4eLWeiKuCrMHtEvFBL5IIoFUx50MovIlCgwRseXwFmJs7AKcqtEUTOZaWhUZVM62mHr7hqZPaesyPNTLbUJKQwRzsnaM2HATN7unGDYU6NHGadF45RsSrRFmeIYqTY7ciOHajxlGbJRi/CDHNszOXBgjs21HTqdHp5dwtdkdGHSGY2oirYjmeg2RolPrpUVCkGwCUpAGGSM3zF+zN+dKt6+gUQs/3bMiMwZlLB5Mn6sz8jDMWNr26fcNHFKNlkqGp2C3eUUtzIhLMsmRw4qk0/8tn7h3lr+9s9lgysjWtfCsmJi3yQYyDWcc+IBC9M1sasZ/Q3UhkECbT1HRnDC/JWaaB5kjUh84fiUlDZFghhFwGoJmDixVciprB+yMbNNm1CEqvJ3Ihlpiw5ONi8TKnylIiG2opaTewG1qV5otVnb3mXsBwwl8kQ4Y0GK3fAma5iVK/3EYlsiGmzs2ML2dGyxxw+EiuNRq3rqEFdvu5RzES7r6oFrOBq1+ZJ6qCVxRr87xqjVFWtscxCQ9RP0EpRF4yEaKvmG7UI93CWCI5OYct3AqhqYtkYUGHiF2NcDpfMRLY2dW5MgXsFSWDaWxIorvUmqtCgDw1e6HqFGi33bFXFtXDAIZRQHmhySSg7pOCHcntipG7NVFRAqGiJJM5c1oK+lxJZIsTNGvTGeZ9GaLZPaBTvbQ3UocRplma+QxaaKg5BRt25UKSKxlKcqqFZpmGQkVghXXnQpOnsDYRLZbHX6ajNSbdW4ub2hxNYZMZc2bmLpBmcWlrhyd5m+HqhxrZVPYmVGoisU4ZQcjmVuVWQqyNMS2UDJwhZuWKGp4NFCwnblWiEmCFIqbpM4kU1PCdd00T0X0wmVucSs6czXmnR3Az73/FWqTUdhBpADvKh/JHJJnm8iCtYlmkS+t0ks0yQC4st3w+SwIJqvewcOKdkkqWgcaQroGtW5gq6I/fMyJ+YXKOs2r926TJxE/MHH3stLGzfZXnFpeXV0ra8E8rYyF7nKJKTI4sIuE96RfP3CyrL0/+CmR2pqaloEd3zTh76Fv/pnPvrbWk++xpbP/dqv/dqv/dqv/fparv2Oz1coGWlJO1BIzDJGmRz0Rcj867lAMvIQ8Zf0PSdtQTXauredVFY8aWMLyMlKsGomthHRnqtx5ZJJkXZYfmEb8TTWFpaU8FIcEmLLqywIrGrSYRCq551rF3/X3/xqpaJovkIulTBWShplsQZqKXbLxx9V2d3p8j//yA9z9r77OXL0MP3ukHGRYEUjdnd6ioIq9NJcXAR6RsWrMB6HbN7o4FVg+lCLu6sdBt2I6rSF4VhkYaasv2ZVrMIxuQgKxQ0g+TnKGZcqwm0qlORcfFgghjAklE40ipGcVDNKepU0FYfKJBdG/o4CJ09efELBZGcJmS0gLyF7ioZVrP/SPRFBYIQpPbnCIpOvoTxFwxYQVsGCl7Dbu0mUapQkv8hxKbUa7MmpUroGYhXNcuKgYH7epH24wjCefF7pQMzPNxmOYgVAky5emogt0yASF46MCKolmhVXdZbye4C6eCBZWfmErGu51MTtUPLQ85CxbzEaJqyt9NSJ2Dg4xYOPP0PJdXnp+c/ybq4HnniWTn+kRskTMfLbgDRBRORUpEnqirDeJgwMxoMS1elYdfyyIqRc1mg8aLGzCpHIjRP5uAyjfmNml3QnpEsrn1cXN5ahqeyjmUqVQccn8iPqiwlbqxnBNkgzIRwL2A4msVMybtUYdmKqLVt1ZfyuSWNBZ0ikDBAC2jREnG1a2IaOPyywyiYlyWpzLcZRhlu2sGSkHkKQhSTpJHi0iCYBoFkQUSnZhInP7shA83JqJU+ZC3Kxcds2zYrHxtZQuTkHg0AB4Ea5r0bKWys92u0qnji5Ril7qwNyVzphGaayuudYpri3xNVoqRGUAjsKCDGRTk1BEcRUdBuvouN4Dmac4OomY6RT4WAbEOg69YqHHwmEVF7tUHVxiMSNk2OJxdoWyKl4j0QOYJIUsQpyFZF2yXYoTy8x3ttV1v68rLMXp1QqHqfdNuudPQWPFCK+oCPk3ha3UqcbKmqzaUFt0UOTUaCEEhsm3e6QXn+kgpijXGdvN6G/52PrJlknwjITRYWPJATVzAj9LnluKSepiLAVLFKE5tL1vXevKowFAXfO7fDI1x+dOOJSjWPT0+z2Omo9FJRF0aiq+9uPI4YSVG15uAr/IR2uWHWvpHvsCfU5k85WIImIRGLSF1exZAOKjT3KGUpQai5MwY76v7wmAnSUtXDQ3xMDH6Zf4cIXtvE7HdxmifEoUQJ45OtXHc98YswRs4Z0snJD8fJkVKvuARnXqhDlSfbd250gNb6QUnBm/csTDbOks+OPaNpt/GLEjTvbyik5Nz/HINriofuW+MJ6hzQZT54bSkYivaScUOtiFOJrzHBUB0q6PWLi+a17M9/6XX+Wkwen+Rcf+yn+1F/+G/zk//7Dv+Xf2d/4fIWS8ZY8LGX4LA1Stfe594Yr1fuXL4bJn1c6HrkRiomtTtrkliFt5RK6laobc7fv0+mBL/N2y1Hz4WJJriMhnwozQxZeQYWb3Lj4xmTRf/hx1Ta+w+9ufeAPfCt+GKt2oqC+g0islqLit0j7wp6R1OAyeiABfBFL802MuQVu37ijxjidQZ9yvUSWadglh1xSckkYJzAz32a6WmJtd4f1G917NkiDaEcWfhnh5LhlB0dGYY5g3YUYm1M4OppZEHYlyd1EsyXxWGJDZJHUlWYmMYQlKpRWRyWui2VcmB4y9nLdgopuEInNtitsWYvckoDSiR9BNivqJtdkWTQUol5Y+eoG9DNM3cAvYjS9ima6lBtlKnaqFk5xwXh5R31OWQBkLp5ECafvr6uW+sDPlLVYkPuO8DWyDFsSr02Lriw8lYnVd3dlhOPpeBVx6GkcO3KQy3e28YU/JJoMp0KWGvhmzqg/IE1FH2QSJ0MqbYezM1UGe2O2V3ZwnJJ6KD7+dR+k7Lm4tsEnPv6LvNtKIfAV00ObPGikJS6bARlbotE4mDIsGZieRjV3yN8o6HUd7tyOOfagQ5oEuJZJs+1y986Ykmso91CeG5N7WrXw5RqVtr88CGR8KRtVHcsSGq+LXfEZ72ksX5CPa9TnMoZdneasTW9bNiM5FYmWaNvMHHQYD2F3J2PmPh2voTMMhaCcKau4JfbpcYFdWJTLBnrJJA8zBl1xZ4kd28YRtINEXCQauZCBA9GoSIBphtty1NcqDuJYi9UiLo6d6Wadzb2+uhfFoSRMI0lLT01HOd7kwVavGNj1OkZuwbAg8hNMYQplmqLjJ5IUf2/MIK+uhETY2SR0WQ4Jvc2uYlJNNT3myk38cUBJdzElvoOMml1TYaH9dKRclfIeyWts65Ziwch96AljRtZHzSIyhR9UUNMd8lJOGOUcsD0yPDTdZtTNSMUKn0kkkIcnh65sMgKX8VKnF9FbH1BzbTVSdw563F3exXVctFjWo1jpknqBjyezMasg2kvJo4RuJ1TO1dl2VeEn+v5YbSKKOMFwZUPlUjIsdocBWjBxocoEW4I55ZUxK47aoEnY8IXLoVpTZg/WWL21jl0YdO8lp2e2xjAds7PRVa5O2cQIO0n4z/J1lF0JopUty2QDLkiEYCDEaNlIW0rzmEQR5ZJGsC7aF4NyXRhBYjXP6MQZIyHShxtqGhyEfXLKaOmQajXELNfV+N92XSJfImgzyoISUdd9Tn88YmnpJL3dzckoS9exTKHiC4NNglYlsWDCSFJiLDXGf3tcNEG2CDE92c1J2wXlSplxlLIT7HFoapGpSpvnzm2xsJXhOJJELzpXYb1pir+jZwnnP/1Znnr/N3NpfYcj03V1iLjyxm8vnuflL36CL71sK5ZUfs+k+VvV/qhrv/Zrv/Zrv/Zrv75mat/V9RVcXc2ZA2oEJCd7afdNsq8mYjD5Ibtc2QWrbKB7IjEZaTlGzjjMOXBmsrveXB4z26orAZmUGoeJjs2UMEBTdQHEQXDtrYlY+ZGn3su5L03gif8p6/iDX0fgD4mSiYsgc64RB1MUiY6Wh9QXLKJQ5/DCLHWrxIsvvoHlWYqxoJUcQt+nKNmMeyLk1Dkw01AnIJ2EjY0uYepjuGXVztfSiOp8laTImK/U2el3ccsV9TlyXScZSdcFJOPPSMwJBC6R10va/TkIeFCAcBq4jqmopZ3MxLUKBhtDqDgslCEIhI8iwYeWcrDZVkGSCzVXV5A14YiIUFDGbLZlomexyvgS0Z2kBsnYSi9Zqv0rJ6Zx2GcjaNDKAiX2lFP3olCYfSH79hUNejyMKQvDpy7sDpOS45CbMUUmQtYQS3VwYNSX8L2Y2QOLhEVEfxDhb4U4dZdwFFFvyOncUy12X06ho4TEEKCjxmjkK/dPZ2PMwRNn8Mo1quUSrzz/ad5t9dSzH6I/krFrqCi0KhcvDag7Ou1Fn76wUEaJcqg4MzadlzLMquRGabSnwS1N4VhbqvO22KxQtW1evdhT44JYGDr5BGooJ1/p9kiHZzzUabSEqJwi+vpWvVBBlU3LIBBBr+RslWQUYbByZ8jUlIwkDZKRhFHquMLNKRlkWkY0ihFan/QpDelWagVyVle8HUvy6AySIqXsimvIIk4jAslUQkTZk2woGTL1+yOVRSTXq3RiatWyEnxLh8gzDBVqqVynQYrpSYcnVJ3l+ZkqiWYoDk4wyojykVp/hCgs2V6DkWT8SX6XjUDK5X6Js1Rla8m6JsBEgegtjzqkw0k3e366xXy7RhjGVDSTyEQJt2XEK90VYfPomUEviRQtOQtjBmmkgKLNUpmu71MRGKEIWmWsLaGf0lkrEtWFbmUuNUfH1zS2B0Jb1+hnwqnxqToVuuMR47FP3SmprvEwDYj7MaFvsLhYY+DHpJ0hlZkaa1sdTh2eZrFRpxfmbIc9hr2AJJQFXLK/CtqLdY7MzasR/N2tXTqdPcW4kU5yebaiYJRWYjEYjxgFsfo+3JKuQIhN3aW/rbG1I58n4MTBGfb60tX16I/7gnZSeWviTpBxnnSr5ecyNbAE/ZTLelFS11ccRhSGju0JDFOCsw0c4ZgJGDOXfDiNwC+oCsS7ZNPviyllEs6bSSdQriuZOFgmJxZOsD7eJRp3qEQWfuKiG03m5uU60tneyLl5vc/snKtGsm6lQX+7r+jd0p0X0bGEJ4vUIxfIZBzeA4dOoIYqz1ZZveRiyjGk465X0B/scdg9yO5ehzz1sWs1OuslKtI9NUroKltRBlzSYdcVtdtxLZ7/tCQTTOrJ936j8gcpV52m8fLzn/qK68OvvHyXn/3pn1Drugj0xUH4sR//u/uurq+2fi2UcuLmktGVUsDfG3NNoGJiRp0smnKxSHptuZLixyl3Xtli6cQxDi5W1Bjr+sVz6u/d9/CTah564dzL/95/9/dj0/PMsx9m7AuaXDD0EpEQkUYtAno4aZs0b7JzawBWly3X5LEPP6row3fOXYGSSzgO8BwLX584t+JBSLs9S6XqYeUZC/U2K91der0Bm7s7VMoVxgPR0ujsaWM0R9xsBprE7spsf7qMFqY4mVBwbfXwqHuyCQiITYkHMbH1lOFmytAPFfbeT8tYHnQ7CXN1T5QGoI1VvEOYyW2WKHeVJ+uZBDJKJICkG4vmSC0YuaL0+qZJQx5QgmyPCwWUVMGFxaQV/c0P1LjdMbn86gqkMbMnlvDKlmo9Z1rBtG3j1WuEsvj7mQoJtDSXIJaZvKas/rKhKjUMorHPIEgZ9HzyKKQxXZ4kmQpWXjZrUYIfxwSJpEPrytERhLYKos2rUKsvKIKupgIG350l7XBXxluWqaIUlDZLoJt5ir9sUD5iK21KteSoUYw3I2G+PlZNx/Ni7HIXyxCEQEivF1JUU4WG2F7ZJYhNSnauXGJiW5aR5sx9AnyTkVOKIZqHeOK40sYFe/GQqUZJxRbsbUYqxPHIgRJZYTHsiOPIwWuK10dXVvM0LGh6NXIvJQ5QSecSIDzs+3iepxZ/2YCX665K15bNdBTkClSZi3vHtuhtjHBdg5Iloy+bMNeo1SSqRajDsokSh75OWKRqLC0jKmWDD1PaVY9I4iN0edjkZJIgbxpkYaHCcjVLp1xOlWPSkyus0DByjWSU0q55ajzoJxIwHCv9jLigm67N2dacAnqGUYZdLanNQ6Nk4FiymdEI0hxHfa0RnuXQkdFRptP1x7iGoUZQsqbOlloUQUi71SKuOfQ3thRdWsy03SKirJU4cWCeXjCmZBaMugWxbqjQ0arn4pQt7izvUi27HF5s0bE1Vu/s4QYauZaxPRxhlcQtZnBzu8vQjxj2B1ScGiUbRaWXlPX19T5JT2jekzX+7IEltTGWGImLG5s0pipMVWBxrs1eZ4hu5oRpREursbussbXbo3IoU5uRG+t76v0aRENFchYEomxyyoarIjAircBIJRoiIpDfswwGKtB44tgUOGnqC6EfCjuhGCdoUYHTlLUhI88lDkNXGyYJepd9zjgWe79IpzTcxCDVTLr9vto0i1uuXK6TGAl1bYeVvYBmYkHbZvZwxn3tJrtGlywPGO0WyllmGTau6ymnrApKRXRX4jiTO3KSXjCJepm4ZZXXKytI3YBFo8Hl9Tu0G010v0rnrqlCrEtzM+rZ6dmWAhO+/Plf+Yr3/Mv3DnBPP/th5ZL8ug98E+fvbjGz2ODDz34X//jv/CX1+3/kT/1X3FleZro5y8rGqoqTCv3xb2tdebeul/u1X/u1X/u1X/u1X/9O7Y+6vsKoq1yfvgcwlB2voXarwmw5fd9ZKs06zz/3ClkookkYdbbU323PH8ISVb7ncuvqZR58/D2TlqZp8MoLvzf5Sr/bdfLBJwkloiGLGQ73VFaObTsKGBYNR2glmFqqMT07T9v2uHH5soKcLR2YZ5BlDMIAf+BTb3gsTi9QaDEVx+bR+x5kqVbix3/249zd2aU0U6ba8NT4R04VFbuCLjyPQif3TGJz4u6qWVXVpRGGRpAM2YtjXGH5xCqalGgcKkFx2pilHsckuwN2Ki1alokRdBHahujxxoGvGB9upaTGXgKklPNMvebhhwJZEz5GrjpPthbhCC/JE6y6AB5lBKAzLFIO1Axct86Nmx3lfpEssZpXIk5itrs+bsVRLjzVps0TBYuTjp/iCkmmmmHjhz7JYERlakqd+kZ7AYU/xmk0MfWC4WBIrVzBMHMG44Ao0XFLtnJaKDdSESnhazgW9oaLJi4ay1XOEelwSffjC5//yu3hd2odPPWoGuFkuS8tWVr36aSejhFId8RVsQN7V8XOEtAfJCwdS0jylHZ5Cs+wGWchU4ZFaGpU3IxrvTLBhox+Jp29+dkSaQmi3hBNM1UXxBE3lQnDUaSQ/FXDU0J8yfz0Zayka/SikJpnMNeqqw6dKEyNAvpBhFcpKavfbtfH1GPsShk9yhlFKY6XM440klBYPpkSvIq7UsbiInptz7YYDQP18+lGmbt7fWrtmnJdBspZJZ/DVHwXcUqVRVRfNTEE6hnILCJTxog0MxSsz6q6k+wt0XMbcr1Ld1NCQ5MJJE8CUWNxQuqUTH2SaZZpRHrMRhRyY2OH9x0/wnylylCEwKbGtFfDznM6wquyxD1ZKLdaoEtgsVz1JqvdPo50hsMQP4jxLJ1umHK03aCKSZRL51XYLTbDMKBRrTMOxmxHEQfdCv0k5kC7wtWdLsMom4zFBBnkady81aVUsqg2XXpFphxrprg5TV11tmzh8eQJaZTTqsq9H2JUHQUZHIYjSlaJKE8ZDxPsJKZeNXn45Cl2Bz0CuX/zErckwibo0pqewrV0dnoD/B2LVrXCMO0y1XY43G4RyGue5mglg70gUgHTjoyyKi7bnSF+HGCXy9w3M0+eJ1xf31LOQoUHkxGuaSrxswAaLSzG2RgtRLGcvHYdTThgyRg9k1BmWzliy5Jn5wojqSAfiLjcQG9UqdkV1rZWKdVF9KxTlB3cNGaYa0znsJvLtZtzX/Mgq9kmccek2xN+moykHGy7pLo6st5IJyWJAjXuEgOM9EvUuEvMBWI0EKOXNQl+nl5o0m31eLA5z/lXx8odKCHenqxNbplqyeNLn//kV3X/P/ZN34lteszPLhJ27mDZHk6pyszB44z6QyK/qwxCP/Vj+6Our7rG/RGahFQ6OtWqR3drnbmDxzn/2nmVvkvUZ/7gcaX9aTUbyhl14+pbnLn/IS6/9ab6HOdffYl3WtUqZaVxidNQEYcll0za9gJ+c6ploshme2dbQc++80/8F3zsp36Kilnw6sXzlIwybmGg1yqMw5hzly9x7NgcYWpzZWOZ9S2NP/kdH+SlVy7z+csXSFvGJKMl1WjoDtOGw9iVwFUD18jZSXwGWayAZUacYZQdZhybyC9o1kr4ortoVblxZZ2DMyam4xHUKix2BuQljSy1iYOAQvZWMu4S+nLFVqlHkRBiXY3RUBCyqDGXW5Lk+EKF9jlGipMnhBIQioanfsui2y9IOtvkuYzjEtxmjq+J3gcq4haybfQ0VZsW9IJIRhZ6pjYlgzBGMzLGvTH9XZ/Zkq+S5Y1ojNdqEImuoqRRM6rKljqWOb+uUW5KuKKhiNI6gRplGFYZXZLbAxmGx6pNLo45eXC+8co7Y5P9Oy3blBDPgiQT+7hGMcyJBzrppkXcS7FmxecSKC1La8HBcqu0ihSzYkEwopRaChJaNgv6lRn0lR1cx2Bzw+fkMYtKzaS7N6QmjhuhI5Ph5znBWJLgRd8ADx+ZpxMJTTskE4pvaiqXloTHJsEkxNOVzXOhU7Nt/CjEF+KyntMolxnrOuNIiOkZCG8wlWvLJItEkzbRdQi8Ug5Q4SBU5HNJaB8WOU7TVfoesT8LOFUN/WTEnkbUNKH7ani5jpHrRFmM63n4CpQ3+bOy4fBFa4OurOhqxKZpCq5XKpUYxZnKzNOzgpGgAkJxVebKVj5nOZgLMm6TEV1B1dZIFeF3TLlUodlsKRBdpztkty/2+Qyn6jIah7RKlhrtZTLmc3TlaHUFaaFsxRqdLMFNJExVp6XJKKvMTEXUK2N8I6OzFzEaR+wOfHVgklGTjNO2RRPj5ep76nRC8HWqiTjdNBam6xyotdjq9Gi0qoRi/zYdur2eyu072moxX1ni8u4um70+7apNWS+j6Qk72x0KJ6FplNWmYqbp0qXMeDdgbTtVbr80HuPMJpyZWUA3TfQ4Zy/wcTyNUZgSZAmOrSnchIzWdcPgYHuKdq3KWqejvn4Z3yYCWVVZYLb6uuTiltdEdIdaYdEiJiRhNBziWhmm4WE5BVEmG3EYpwX1tIyRy6gpZCzaxzBSWW0CWkyEqD3SSHd7CPGxsCdp8NU0ZWMr562BT1TyqekVCsNQcM9UaVtFzqEpmrno0SS8WW1y7kF6RdsqI68JsHci9RHdz2CkcfTsPNdfH+OYonkTPIuFI6nxlvFVb3qkXvvE//PvfOzJD/1RPvYT/xvf/V/8ZXbinNMHDv62Ptd+x+crdHwOHD6uOjfXLstm5hH1dl956xyn73toEkyqG+rX7+Y6+/DTKmTQV+GQioCipHSp01UP2TMPnuDgkZO854Gz6L1t/vFP/D8qPLVerdGPYvb8PkGcqtm4CDNF1BlHAcfnF7l0ewWrVuBVa9K/oZ4bHK428GWzQEDNM9mOUjrjMXEQKdFl4dmT6IE0V0RdOYqLFkPiL/QM6qLOXJrG2OkrOvSeUG57I8pCJQ1SRtK9MUy0LFO0astxVNik51VUWKE8sORBIpwNWbQappCTM8qapEyLdV/orbk8WtH0Erbc+LlkUxr4nTGGbVFpCqE3oogSxt2EUlMs0abSOshDAEnH3h1S2GWsUqE2LJaW4FZqpLJQFbnSiIheKIpCyiWHIJJTVYaduUR9nV7fUbwVz+uQZR6FhCXKBkqhEFylf7hxdYJDeLfUM89+iMFwjD/y6Y6GFAobMdHgyeZQcBLKcCDIAkMjl0Da4xk1raQo32Yo5FuL/ihS4aN9v45pxLTKEfNzNdURiVOTUMQ4eUGjWuLWxg47/RFlV6fplhnGMU8cWKBrFEpgLoG2EkSpAojlJN2wyU2DdDAhuYsMWTYHQz9mpuaSKYs86roZxgm5oxF2A2yhjmc6iY4K/tSiAD0XTg9U5wy10RM1oZYkpLnFuIgpy+NRzygkITdOFdG4sHTiMKMqkRRxjFVzCZXomElUgjxceykHKimlmmjbwC8KYtGBmB4df4Sru+INULRk6ULIYzjyJTTTJHMt+kHAAa/CwPcxyrJJ0RVzqlmSZHjpW+Xc2fZV5ErJlQ1KRkUlqud0Ip9+HNOWjpFESqSFYv9s5AFN18QdibhcxypVqUvXSwjOpFzb66sux8JMibVxxHY45M2bGzSrHnW3Spr7jMWkIJtIM1PBnwYWcxLXMDdPR4vY3NhFLxJOTi1ytd8jHIWYms1aNCToDWl6ZbIi5vjiHE3TxbdzVm/H5N6Asm2roFYRM0ejiOpUmdlyjZZZpTcW3WHKSmfE9qCDJRw2R+Q4hYr8sBoeTadEu1zmSLVMJxqz3PO51NmjLZ0nw2bJqXNj1KMzTlSnTUTuhZGq6JtWGjFuSmdcOiwRmm6yWCuxHQQqmb3IXVqBqTSInlPQk2Bnq0whLCHTJNKkQ26S+RF53cMLDCxdyNM6nZ7ocyAyIxqnSowu1cnGvUnwQG5SSJSQSmwXcbUQnyccH7XpkTa6XOSTpBIEkiY6LtEiJcEYr1KZIAxEgK7CmsuqM/eFz/xa0OjvZf1WkRX7Gp/92q/92q/92q/9+pqp/Y7PV+j47Nev1fGzj+AHEp6XEohn315BF4KpPybqSaCmy9/4b/8iv/rcF7l75w6eU6FuG2okkJs6w34Hy/RYmmky0yhzfXldOb3e3FzmvqOHmCuV6XcGnJieUiOG3E7Y8WO6acJO5FMnolaq0ylyfF/oxpKlY9APY8LRSAVRjuOYUmZSajUpZFTR7yri89beCIkMkpBRdTJXlng5vcloyyMZjzBNh1DCWiXosGYTikzD0qlqOaPMV3Nl814gpiWtYNF9hKZyWYgrQ1oIg/VdnLkpdTIVuneSBMqlJuBRcQDKqFBlEwm/tutTbjVAEz2FdHZ0xpL1RYYtIzVdOltC+9YV6NEX/YTjsbYsf08Ashq1dsbdcwnVeU85bqRFLcc3CTGVIMZGo0qrXuH55959VOfppRMKaphlkxGjJk6hezR1oel6dV2NFPMgZHu5JAhEFk4K4Ez7MqTw1uWcJz+QK/dU1aorHUnXlw5eRHcoLrFJJphrWni6ydZoqACRkkeVpDCMQ+YaVaWpkvBMyXXaCkY4psNUvU48El8wVNsuRijvv8Y4SxTML4lDYmOikbCE7J4VmJ6nyNDy/ZQtS9G+80QnjEcUgoWOJxoaPxOqb8aUaTNMQwI9oVwYOLahCOiI0yoz0U1doSYmlm0NwxG5WqG0IEtTJlXXY6s/xswFySkAVUONU2UQ7DiGGisGScjRpQMMw4jVlU3l0hRa+bwjIVky/kvojyULzGO6YaFlEbptcnNjTLWsKypxJHoQN8ILLbazjNfXenz9bJu9LFb27VhCQMWaNtIoJIvOgGEUMuvWKbScOdHg+RmVeoUky7mxtoNv+1zpjvC7I44uzNIJxtQ9B7ewVejygelZ8nhEd9CnbtU4ceYw56+scupYhdfe1PjI1x/m2x6Z5trdXVYGQ/7FF96koWnc7g+p2aKTM5mp19joDbi2vUW5JmiOWFntbdPk+NwCDzWmuLa9o95TCeDMhAwto65SReEvxPknGWKtukWzUuJAucJixeKRR9/DS889x5XNDs2yq7RgR9ozjM2Mz91dZXm3o/AKlivXWoEunTDHxpdg2CClPVdHk2tfg51wSDjMqYifUYJg3RKpYVGJEtw4YdhyMWTdkYBbAsQb6mUmVhBTLtfYWZcufkbihMy2bLZDB7ZT0kT0XdJxmxDxpZWqkgzulUw8VDCw6rTKmjrJVlw6s8DqW1vKBWdbDhWvxOU3X/l9WSP2Q0r36z+6blw6x32PPK1GL04aE6VzDLbHNOdtynMuK1d3+NH/709xcHEKPJuV3S2GmkOjXmUcBEh0rq7FrG1uMx5XVFDeWneXmVadfuSrkdhcrULfCXCLKjt7IZGRsiebhyRlLKOJaISje5STgtgWOhC4hugwCqqaTWClCJC/P9hTf8cpeTQsWaBRtvU0kMBHD9OKKRxDPbxy0VloErCoEfmQjWPcuqGYFEKQjkR4Kg8Rx1IbI2GmGMKgyCU4NcawzYn9VwJUS2XFuxC2k2bksp9R7A2ldRXMDCZpOnnomjNlJYYmKBR7pKt0AxKAaJP5OVbbwCjFBOOUcTShg/t+gFuVbrOGKyM6a8D0KZ2oZ+CWC4KhTGgmCeNim5Uf78ZNjyrZfCsrrRDTJ7wZmXnJgiwaGX9QwjT6SM5DayFRURFBmKgNbr+nceSszTNf7+MKazwzGYRdcAosQ2M48llsNVTw7s5gyEyjNknItg1qrkMWx2o0ZXouWZwTmhkjeSACJbNMqezQ6Y+VYFk2z70tGXsWKoZC/pxpFIrcbdgO4TilZUlAbaqQDCIWls13N48pBACTCmE4pJQ5CHbGlH9EolrkGy/ySap7YlJWI1pN0lnU9SgjHVt3sdKUpusqW7qweTzLpmcF1MtV7NzgwUNt6rbD9u5I6X9EWxeFAZ5XJQt9EC1OnrPa6dOolVR0Q7tss9cb8dCxCjtdgyhJmWsLDsLBswt6MRyZa6hYmYMzFZUSfn0tUKPbMzWbE7XD9EYhVcdjuzOgm8V0OzElTcO07InlO4G+MaZqeozjnEpZV3Rhedi3GyUGwZhqSfhANqM4pavFatRdrZY4O3dIRX2IVvHMYkvFQpw6NMNxO+Pidoe/8W2n+YXXb/P3V24pS7mM2D56+hjDYES4Y3OkUlY4klZDRvYNyjJJ9ErsDkbquvMkjLbQqFQsbN9krTNQ/J9MUuJFn+TZBGGGVjaZaTvURXRvWMzWKhxo2czkAbpb5uhBg3GuM1cy8CxBAhjEzgqGI7QfCf6ULXbGTLWFnep00x5uIjwwIUtDqW7T0F3WR5LOXlAzbALdVoen0XDE2CmoBDrFOEN3xP4um1rZtAc4VUOZUCSUQlYmGccdjUtEDFje9qlNtRXVWf67l+hyL6FgQt5Wdh+la5OkAY0o8pk/cITe2pDp+SlKnqfEzG/+ukDs/9xqf9S1X/u1X/u1X/u1X18ztZ/VtV+/rbp47sUv/3zx+FkqbkHQS1VLv7JYJe9ZdDpjwmLEgYUlnNGAasWjprncFTCbJkJPUZ8mjIRs6hq07SqmC0cqTR6Yn1POGPlxuFJlN07YGHbViEo6O/0wZXvYUW4GTU6wUUo5zRUleZynRD2fWrOGbmpKcCo24KonYx9TufBqLZfEzUm6JoZpYegJea5huKYSYpqejaE16a13lX3UqeYkeS7+KTRxZYioO5dTndh+TXQtY9orsx1kilBaEXEnQuMVumqm/o/YiGXWJdA4IdT1E5WtpIcueVRT5ObMG7L4gOS2iVMjJBp4hH6OmdfBDhmth3h1IUkrl7Q6XTpHArJBgVbWsCohllso4exoeeJ8k7a0tKnfrSUjw0l2l6GQEwoxqfKCJk4hXR+RqzBYDc+F7V2D2VMNZuc2mR0WuFaZw55DX14j1yWLNtR4cHG6xpUgoSWBl5qFNtRY3R7gVSxKhkeYZZRcR1qNDPsjxnLKl3FAljI3XcG0XSWGdnWDxIiJkkKNmaTzp9sOVpjT6wfofWg0NOp1B1OykCRbS8ascl0JsiCOidGwDY3YMgkYYxWmEvDKCKoqQnbbIhQHkF5gmToxOlVBQBQiB9bUqbxumFRscQTqXNoY8cCUzUGrxtFmnWarjZ75CtxZcYWGnLNYEWlynVFYsBrnTJfqVMWi7NiUGhVSGaE0mryxs0uWNKlXTBbmy4xGEbtxxJmDM2x0Ynp7I84cmyWQUfVOyvowoV236cfSMUhI9YxBECkqsGOWqUlOmCYeLrHf58yLHVuI7EyE3XsZHJ5qs7YrCIlCUZTLRcCB5pQKSM1GYzo9n/XlLd64s86HHn2cUg7N2YPM1nUFL3xksc7iXJXpssOpg0t85KkjBKMRV5dXuLXcwTQ9Hp6FziigNxhQrU+pDu2BVptyo8IXhiEHS3VOzbQ50qxzbmeLteGQ3bGvoIzyKJWg476RMz9TItVg1i3R8DwGQazQF3t+zMc+/wKha3H22CnKes5gd5u9MGYrDhn4oRp9F0JoLmLmvbLKOxsmAYXjMLZtFcI6nRb4uz26EsLqiOQgY+CmZGZIaRSTCWS34apOdkkzGMU5aZjTmHHJ+hHetIV/wyUvUrLAYaHuc+6iQaxbmI2muscECqruMZXge8/NJTDfSbTpPdijdFs13HKNcNRXXZ5qtUa9VqcsKJD/jGt/47Nfv+PScJS1sRCGRGEQbmq4dki/Y+PWdPp+j8Mlj/tPLLKzO2Jtr0ep7KrgzljYE1UHx3UQAv7WyiaNw4fZ8AMWKhVFQ760u82mjJ3QqIlLqewyin2mhCaal0htWz0sxrGPLu34JKPUbEJmKQeNLvEWToUhsXooKPS6pL8HEZkhIyV5UGrkVqjopq5WYrwqJFtpZ0twoOgwPHAGWBWLNEnVCEI0QomlKQ5LYdjshmM1oxcphVghxHmRSYSJLFz5xKbsh4HSQKkbzXaVTZXEhcqIwvKVJkSev6OObGxswh1Jh9ZJYnFsGJQaolGZaJOEo3HowZSaYRCVDGLNU0nzrsQ22OA1hDY+YW/IA+LhJ97LG6/8pyeB/17W2Yfew8b2jop6kTDFt5vWiiui9Aiy38mZnjWYOz4Jpj3gyyiljx+KwyvDSg1mxOESa9zsjTjRapE6BbsbQ9XC3wpiepsdpWkZhyFpkqEXltIxSGBxEGfkVs5ss6GMLls7fXY7CccP1SnKOtP1Mjd3thXdXGjugjmwtIJS3WVxpsbKdo9uP2LYG5JMtXDaDvYwxs3Frp/QyyLKukNJiNIySsgcHEdjuiSaCxlhFYy0VCWx11x3QpPXCxzdVONX2QyVJfVbs4jzkEcqdZLZFiXbJiKi1xtzbHGR7Z1dTCvl5EKFrbGBFQt/ymGUFTxxf53tlQ5GETMzU8H2qkq3M4oLFhsl9e/Ixr0u/Jq8z6znUj9zigNFwLnnL9PpSwp5wNYooFoqc6jdVJq4sNDRI7mv62rTIKPwQzNtZaE205ByrtGuVgQlpDafaRzy1tYueRqhFwXjNOXRpSUarsWFzQ4PnzzJt1gPUS0bHDpY5aXzt/jYl87Rtcq8tHqbMwtzHBcG0G7KAyeX+Kcff5l6uc2ZqZPczQsemq/jpQE/+9YWe72hikeZqZa5trZDFuWcOjDDw3MNjjoeW4MRp5emubnb4U63y+HpWaU/kkOOJxESScT7jxxmbxSzUJNA4QZboc8ba3sstUtoSYDdKtN0bB6vwNogYmA2KIodXrp6jc3RiAo2parDAa9JPkqJh7EKkK5UWuRmjlGMsfxEoS98GY+NYyqGgVXRqJQ07MTmcGOaTcNnQEQ6GpOVXLBT4kGAbht0V4UIrinys+HGhH2D1BiTJxquIa4tlAZShm3Ku5XJRlruq3vhpEpTJxufyT0pekvXdimXXOrlEmceepoHHn6Qz3z85/nPtfZHXfu1X/u1X/u1X/v1NVP7HZ/9+h3VQ0+8T7WVxVmlK42lhCmCWetT0ypoJZvl9Q3mFmwOlivU8pw/dPy9vLC5zYW9HS6N1iBIma7WadcrXBkNGQUhneGI1B9ztbNHreSShhrlUpk4TRmMEuWAEGabbntKABnHOrpTKM5OJwlUIKhywxQ5QVYw41qKiiyBhYlA34KULMsVaVuAgMFoSH/TINh1qB4syHyT1AxwXFHzCVMlwsgs+v2Mupg6CiE6mwJyVrlPkjkjI6juZv8ecTVTTqPUENK1hplaivCbaBKGmWAOoL3YUk6v7mgdiaG0MxlxWaRBglHWMGKTrC5MInW+UkwhaSVLSVCuVZ6iv+KzMsgwMwmFDWi3TJa3M8pTFq2jDndfDai33cnfLzS+8Vu/j0//63/2rrnKEyHc3jt9ymsjOUGq26OoNIKDlM58wfY2XL8S4jV02gsO9x33mM1tRg7q+iko8drKFnW9QCKK+r1ICdLrZYuOuKxKkvwl3UFxiBn0hhGVilzwQp81qLge4SimH46UqL2X5Ox0B4qufXsnVhTixXoJR3K0tGjCYioSJQYVnklR0Uhu+uwUHRYbs8pRpS5wYVqVS5SDnIYpp2idOBOXkM14OCQ1M0p2qr6uyEqZsavEtkGWhZip6KETfKE6SWCprbNQ9VS+19lGjU4Sc7pW59XtIW/euM5s2SUpDLo7CXZo8qHv+eMs31mjubpM4+AsXmNH5cM1FHfIAVNetS7HFmc4faJNf+Bz5MgUh+ZbtJouV6+vsSIUdCwWF6cY7CRUG2XCoU+jWWfcHzPrmXRDi9vbY9IiZLoi2WY55bLN4SjHE3bNbE39vgiap+s23/XkSW6vDumMh1ztbuHvxMyUyhxr2+zs7fLLd25xcrbFH2s+wMmFw3zo66d4bNbiF7/wFr9y/hrTTz1C3QMzs/lDH/p6Xjq3zHOXNnn/A9Ns2Rmt9gl2xzk/e27EgWZZOdEamk1UJOyNR6x3RqoTfXTK5u7WDr6R8+hSg5PNKo/MtxQosGxblG2dxUqNX7m2yoN1j3w44vJWV4V7SmZaFgnR2+Rsc4rdXo8Xbu6xPk6o2AWbYYhXGJRrhqKMJ33Q3YTeOFGhqFbsk5TKzJaE/B0oiGHd0qjbJVq6zUylqb7mG9YeqSuC/Zzelo87FMilvHUpeVkjGjgkwxS7JGu3xnCocfB+k/XLY9yyoBPvpYOqe+ser5B7c3ZxB95zcVXa84z2NhQzS8CEyzcuffkefem5//zDkvc3Pvv1OyoZHQllVHQkcTzRvYgCRtQBmZnQ7Q3xUp33HjvAbnfItf42D7ZrClRWc2ylhen3x9za28UTSGDJVWF+O7tDNrWClY0Oc4tNghgFjhNYlusZtCxXpUwP45QgjMjE/SGeLr3Ac10iLcFPQjWakEBHScEWa64f9JQNOZfxkEC8LEHkx4S5i+aNMadyCtETnB3iSIr2poUu47SkT27oGOI4r2bKFSNDJxlllWqiMYrZ3Q1RMyhLIxEnjmeo0YTY16MkUEni1XZdJX6XpkVLEtLrjolTcUVAa7pCdxRShAWWlZPbBumORrUmCEOXILHQzTFaqU/Yb2NqAVFsqJa2ZbbZWN5kvFlw5NQ0nU6XYCBY/Ta6YauvQ8aRd65feVdd4TIW1HVZoEVnMHGbiH1YQdfuuU4UcC3LqDUsTFtHD3TCxGaqjCIDF46MuLo8eqBBzdC5MwpxNJNVgcJRsNMJMA1ZGgO+5Q98iM2tbbqdPR48fITn33iDKW+Kfj6mGwwVZbnINKZnayqB3DBMipKJK4GcZkUllYeJXKm6sr2v3d2mMVVmQSB0UxEhGjubI2baLt10hJGXaTsOS02xnJdYlsBfz+DEfI1Xb/tUNTFblYkyi80NYfqmTM86uHsxXlGwXaRoes6B+jyxritNkDjBbCdnyS4pEOIHjy2y6o+40fGZrurs7Qa83K7y8nOfwit7NGsWL7/4Fv/TNz+NeCVvXFxGH21w7NFTXHljmdkpizgc8/LNTb60M+LbvuFZ5ufKDPtDbt7a4P4jDc48/QBf+lWfa8tbzDbKDIdjZW/e7o4wyzqOo/P4iaN4ms7a8i52GnGudpSZqsmXMo/dCjywFLLq27x4a5f3L7UoZbOc9yOC3h6t6RZv7AogdQPSjFKW8S8++Qqn5+Z5/Kn7eXipzfGZed53apFfOX8d25qi98YVFupljixW+ez5DcwkVxubRDP5wP1HODZfZXVvl3Fmc3U3Yrezzb++sMrVjT5PLDWZObHEwwen+OTdm/zB4/OcmJtnsz9m3c84UrVU1M+X1js4QlX2SmS2QSt0eLbRYL5scymOGCYRQZGxvjdWYaINL+F21KXVrmCGYtsXdIaJPw6Q0IhTi4uM0pzhQNagBCcS4KBBmMY8MbvERq+LYbnE/ZxbyYgrow4nqw6aD2ZSYNQtQjLKls1gmNC5alJuWxRq7TQolSW+xaI+UzDqpYqyrO4k0aapWIrJzkcZJ5V5UqPebNMVWKMp652OKXjxd1jtj7r2a7/2a7/2a7/262um9js++/U7qldf/NyXf7549BHFrRGhcGwYSnzX749YqlfQs0w5ahYbNZ5fW+Nn37rO+44c5sTSFC/2B0w7Zcpeha3tAS0J9tRNDs5VSYyEaqnKYtkkDGOVH3Nrp8PAiiikI1KkSuwnY4HdNMXVTGxHhMQVgiJS8QSzXlO1ZDvioClsbBEUWxIr4JDbhYrAENaJ4USUGzFWbJDHLqaV4Z0tCPpd9H5Gplcpl0yCzYKoE2HUwGlpFIFFuZYz9jOyKFNjEQuNMJEg1QzdFOeQxczBGQ5Mtbizu0e321OvmTjbHFwkAUwyfSQEBDeh0HS8eqGyo8JRileLGa0GmJ6B1orx3JBk17l3GnNwHZdC+uHArYt73PfII8SxoOXlZGZiqfGbxuyUy413yTX+0BMfoD8YT06lIuJWgLXJeOhtv8lE5CwhisJSkkiLgjDKWbsxZvrxReYMn9u9kCt7XV5e2eFovcZ0tcJmFKkOix/JyEsEvFW+4YmvoxcGvPTyReZmW7x49SorWx28Qw6nD83R8yehm2ZJR5cAWk0jCRKKtMcYKIcpsZWqEEwJIN3ZGoFkXMUJ/jDGqtvqut+822e6ZmObBk3L5qlyS4U+/psb4OYxL2z1eHAx5U8/+yC/fLvL+t6QkYyFPJ04yTF6kQJrDvNUiedLAtBzdPRcU8LTuivRDi67gXQcfaZbLbr+mH9z9Tq39naI4oTv/O7vYAsZETu0PZcTDxyjO4qYMddYnC9oHDlEFIYszrQ5fOwwm1HO4/P38eZWnxdefQvOzDBddTAOT2O7NUabXbnYOXDwGN3VFVr1MqVKGVeFkaaqwxYOJRssVSHEn2nez8lSwt78AX7oUJ3lq69RVOtcuN6l071Dx3K5MRxxdbuDvlvj0fmQJ48uqA7Ia1cG/Onv/hZmpqexIom3ECHvNlNOzgMHBXBocmiuxrGjC+zs7NLrdTl7uMxVH3a6OaeXPL6wOqSmwTP3P6DiGD5Ur+P3N/jIA132Bh10q8yH3vMAvX6Px4oAx6mpkM88lW6hwfGjB7l6Y5WzBytYsy5HF2bYiRI6mYYfJLzU65HmITs7Q+5qJlvDmINzM1hGne5yTFAFvaKhElMkYzUXXpqMRaus3lwGz6Nq2VRTnS0b2m6NXX+MH4NVNlQW2fpwwJFyWU2qYrcAu1ChsU5NIwwzhhsVvJmC/B7AVXVMdZdXn/MJBwXNqTq5QIL0YgKSlftL/pwK2rbISynaCKJwTN0Rho+4WzXKEmT4Dqv9jc9+fdUl7VCxAMhoYdYrcWp6geXb6zxz9BBHalPsRGPMUcov374zCfgc+Cqr5vTsAlXTYm+ro8i3Z47MERQpF24tE0kYo5bRMRMOTtW4uLbDMI9oGA6BJEwbBrWKRxzGtHJT6TV8YlrxJCTSNm1sw2JrPFTwN4EkSl5QGkd4jk5TiKxDX82pTddEc2RMl5IIaNGwKPoO3Qs55UWH0Y5F/UxCFoSMU9HN5PRWPIpxQl6ElI9ObKp5rKGZJrWyyalWizAJGAkhtzbHQBLlgxFZlCDmG01GL56pgkyH4RA7lxwdkySrECUm1YYkeMfEToRTiik6OoOLFQXfsxwNwxBKr82tS78xJ+7iuX83N85rHCfovVu2PaLNSdUYUZdx1T2Umsy65NcKGil7cGnhq/mXuNwNpXMSW3KcZHzpzWUePF5jpRersZOZaFzZ6+BnOSvdIYdbFpme8diJJZbaLVa2drhw4xanj89TdixFIj7wyHEGcZlf/GWf6QUhJaM2HKJPM4oJ7dkRG71j05XQUXGZqcRyTWV3GZgMOhFDI1O5b+r9LJu0SiW6KSx6NlvpDp+4YTKleYwSg4VGg7dux3RP3eZ4SaMTWSxmcG0vxJkbEGQuFbuJDDCqJiopfWccY2khNyOLY/WcXuij1dvMzUhauc6v3F7nStrnkaNnoFKiP06YymHOsanNzuBd2mVw4il2ey2+4dSI7c0BOwOf3LGZf99/r94Pv3ee90YhFy68xvbeGk55AX0m4eOvXuDkQptHvu4JFWh6q13izsYASw85cfoweegz3Y8ZjTIGWqoI0GYW8gWnhvvj/ytX/9yfJ88covUBYWebwA443/e5Me5zsm2wNJdTnzvC7c0N5u0yH3r2rNJnJZnBzsaQowdL2FqJz718i5tbQ8JM49+8cJkP5Rbb3T2W6i6OkTOMUt5zqsnAl2OIjDwLsvWR0i62I41WucGHnzpIuS5J6B1eeGOT6SmPB+Zn6HdSanPzzHptqqOAouRw9OQCS3HKQmWRzW6EHXV535Eme37I555fxgxDvvWpYxycmuYzlzbxGhX0RFxvda6t76mDyozTQNdS1nQ4feo0N2+tqLDXwSik7tTZTTscnZ/iS3fWCIZDjs9NUzIdcsPmmUcPcPfuHW6PumjDXLkRG9M2oVVh+4aB6wm0VR0PJvq41KZ+yGH79pDanKN0YhNwx0THEwi+oCIKSZs8NBhu9phqtxTS4c61i+oaeOTxpzj36pd4p9X+xme/vqq67+Fn6PZ8dSqQsMRqyWOlt6UeOO1ag09cv62SoQfjMRs7Xb71sYeZ9kxevOUrjsdiq0lzdhqn4jHOY7a39xh0BhSRwbhmcuzQFN//p7+V8xdu8df+z5+m+sgM047L2u6Qa5I0bGfKxp1FNs1qTWk8AhKmxApbCDE5w5LQUNkwhWPGUYgrTBPpzejykMwnmyjLJSpniLrj2NIM68shjYNCXzY48pCQlWOoRlg1XaXWO/UU81BKf8umUSmRz/oqwTrxIyWi3h736fT7JL7GoO8TeZPwRIENZ6LNsScMoFIi1nyb0aaGZoUgROf6gGCgkfgG472IrFswf6yB0ZC4C10tSYZhqW7Sb6feTZseqTCOlHj37Q6PIbEP6ucTAaegnGXjUQijQOIpFMpAokVEd5VRDHw2dgtqQl3OpRMokQBllUqeJokSqI+CXIXJerMmV3bWmZpyCYcxy4Mt5qdKtFObzU7C1EzMzVcTGu0pDt2fs5NsKQKxxKdEoWi8pOtn0vQkDkVnMJSYAYvpdlmxWsSarWkJjXJNEXh7gY+nwYFqiX/ycoc5b54gkXiKyfc+M+fxM7dWuLhzkiP1hNUkI3cdNrRH2d05R5reomxWqdhib7dYG/jUDNgtfO47cBCzCBn6ATNHD3G9v8VUqclDkcewm6FL9MvdO8wG8Jc/+DRa3WPg5fzCL/8ffOCZB9gb1xmPxizONrhwVxLk4ebaLX72E8/x3vvnmapX6AxKrG3vcez4EmcPznLu+jKrG32eeugwa1vbTDWbGDHcvb3OjY2RCjluN1w6qUEYaTwxuMmH8yaVP/jNvPTia+SSTj/KsdOQK8MdvvP+93ASePPKHR49doCFh07z0fYf4PqNC/w/r32Jz6xfIIpy/sIHP0R9aBENUo4cPsxzF19moVXG7w35+U+8wl5/rMS7h+aqNFs1ymmTta0+xw7OYpiirNOoz02x09lm5LsKf7D51jbTTolHlmoMR5FaRw4edtjY6mGGPk4G3U6Zq1sjvuV9Z2HUxewPKRk5tpGT6jrPHqhyev4oD545yrnbW0TRiFvrQ1Z7Y17b3OK++SZWIRRnj/mqwcnD89zupVSskiJdC7dsoezxek/jla0N5sslLK+M6xq82V2nPVXmZGWJ1WyMloqeLMVeKpEYde48t0djtqxMG4UhlGnp5IBZgjDKqJ4ICNeaWFam9HIaBu3aFEF6k+FuQr1RRrfye5se98ubHql34qZHal/js1/7tV/7tV/7tV9fM7Xf8dmvr6qiWMYFEgMq3RGNwTii4yd4msnO0OfIwgxhEHB+NeaxI0d4/NAB+tmAQ+k8r9+6o4Lz4sxnqtHioeklPheFrIdDtNDAUYd4jZfeuETJdDnZajHXqDMqcqZKcnLJubzRoXmoxpHFljo15UmCYZkYoqExLWoljziJGMbBhECa6QpA14sDao5DPxL9h0a3O8bONRpVF8NN2N3JKFcMzHpIEOTkhkY5b7FwosrWdZ+tjs7D90NjGuYaLa6+5ZEFCVpiUJQLOuVdct9CSyL0eR1NYKySK6XLiErDGJgMd1KScY7TkLFMRtLVqd8X4PcyRm8lHL5/gX5n4saqV46QihVWxihqvCiurnfeTP0/ts488AT9oa9eC8OyvgxP0+0CP5CRK/hj0UR4DHcHzB82MXRdtewVCsDRsRyL7ijm+Ikm7zk6z1any1vruzQ8OHB0iifPHGC773N3c431vXWsTOON11OmWzrLb7mEDxrcLneYazQZrBccOuMRZwF7dzyeee8RegtjVrsDuoOEzt4IXfRaRq6Ag6J3qdc9GpLbJKOLNFHan6phCS2OTDMomzrbuzHzpSWCzCIthL8sB3UZ6Wn0olPM1wzGqaFca+La07Y3SWjRXRkQHPQZxdtoVkXBMoM4ppZ4XN8d03ITTMthbRjw0u11+p5LuuWTjDPEQnlwrk6+tQdnFtl4/TzLG10eODlPSUsowgHt2QXaS4eYP/0A/9ePwid+5sdoTTUJhg7Z7goHD8+zvbWNm/UxdjZoBUNKyZif/lc3mZ9rsXb3MgeW5lhsVYkKg62tLv5gRNAb0g1zygfmiQvY6iU8vnSAyB/yZtDntubxC3/hv2YvCLm5tsGgt8eN9Q2u7GzxN2/d4tmT9/OAN8NuMGScxvzKcy/yCXuaTnebxZrGjdEOH/3Q+zl+dI5ba5scWmzx2tUVSrrFMDJVjthuz+fW7l3mWyXeuL7Hk0eG9MKE7/qGx7HyAa/vhsSNlGHhM1UxOXd3zMlZyWUrc2U9oFyuUO8NebiW07+7gusUGLZGc6rBUrNCdXePwnIYjQpefeMOv3zxDjf7A/AyTkw3OBKVqVk1Dk1XubO1x0tX1zl24DCRH5PFoqFxMSydlU6fkYz9TVNdF2vDAVZuMCu0dhJ+4YvPoRs6Zd3FrhZkhk3nlk9jvoSeG6oDKpRzwxAAa670YEURULXL6IcDKmmZ3vaQBIeN3Q3Kdp3qtI5tWViGiakcve+OtWc/nf031X46+2+vDp18iOEoUDRWz67RmNnh5vYuS0aVw4tzfNc3fR26H3Brd5cLt9b45gdPc2HtFnOLSww6Q3Y6e0qf0x9oLC1VudbbZW0wxMh1ypnNex+6j7kll6XWlEqGDoucta0BLc9hZ9jjWqdLqWTj6JYS+SVZyjhJFUejZjks7w7wXJ1eUjD2RwRxiCHJy5o90UGQEsp8TMJHU6i3GrRbLq/8csD0Aai2TCw7pl5ycAxJxR4wHBrocZNjxyKWBxH50KQ/CkkDETZnlJsaofhIY4ckiyg1PHr9joSDq6DFYlwm9DNy2SSpkcxkTGNbJp31PodOzmHqJq5r89arr/7u3+3v4Dp68iEGo0DpeGyJjUBCZGOmZzPsaqiSuwVXkLVK7PQi9MRS723bK9MdafhhD306ZqExhRMlTNs2B2br7AyHtIwpXriYUJ9pMq0JbXmd67d0vJpFkkzotbpW4PcrPPpMn0DIz9M60V6bKzd3FSV7667G4gGX0nTAweMV7t7dphtFRJKOnhTUvRqhXhBnEVO2wyCdRAIIG0pS5ktVEz2R1HiD5sIioWRzZ6IZYhJBICTde55iCaPVMrHwy7WUKIq5rsf0F9/PkeJFKtoyBxYWWJhu0ROL9Zt3JVCBlq3jWg7HpivY7gwvXbzDUET8uU6r6nH/kRb/1fc+yzPf9HUUUcy1c+cZjGIONSo0qiXMWksUuPzoT/xzJXaV4NZvff9jtBYXOff8i2zdvs3UlMOo71P2LIKwwB8n6FNthplGGEW44YAb630eOHSQThpQiwK6vRC7UsXXY167s0NqaVhFTF5rcG51hQ/PzXNte5c3N1fZGvocqtTQq3VWdzbVOP0j9z/EyVqV5Z0u1zZWWWgvESQVnjxSJchi9vojNvYKTi9UePS+g1zfGRBrI/qdgmiY0qyXGccph5plzq31GA1GPLxQV4n3e6nPsbk2UzWL3ahgdb3P5saQmekytuHwyJEZPnhmjiCJMapiKLAJfR/HdSmLySPs0vMzNnoBiW7z5tU7XNiKFCF6Y9DloYUGjx0/zImFeb50+QYvXLyt9GGGV+LFK5sYes44zWQSjl0Y7OgjzrSmee3OCjMt2UDHjPoRlT2TqSN1jFKu9EC9jYK428T2JjozZTs3TXUIKEQhZ1jYjYRD0xrr3T71Ro2dXo/YiKmU5snuSghwoTY9Ny5d4J1Wv1U6+/6oa7/2a7/2a7/2a7++Zmp/1LVfX1VlqVByM2UXFuqqiEOPNJuEQc449Pn4iy9zdKqNneU8fHyePAyxMpeVu13OzrcYjYasRGMSG7YH2oRyLCMdP+QHvuf9PPfGMt1xh5NPTVPxygxGXfb6XcZjV500W16J3nissoaOVlvsDPqibWU4jlnNArqDgAVXkNIFvuR3FSZpljM0IhzNwtIMFeYoLiBhAQvwL40iSiIatCLiKFPtYMlU2os7nJyZx20a1EXQd63CYADJYEzr/gC7qeHkJr4a/xmYXk6ZEkmQo+UutlYwV29x+06EXlISZXXqkkhNU5ecG4ci7XDnUke9ts88++z+Vfnvc3SJ0lccXKoDo1GrGhhmQCFC3yQlz3QO5yX+2H1NFtoeGwOTT6xu8OSJCu87dpyfeeUaca6R2S7rgwG3OiNmWga+P0W1nJMOOqznGWnmYtg5UaAiTzl7zOPy2ha1lkYpcXGdiDdudTkzrzMKbZqVhINHBPgW43cNvvRpjZmDVY4uVhWg0pGQSCz2BkNqtslokOGWbJXJpo1zJcL30HjjVsT00jRxLqGXE/CgXNSmBMKJI+ztpNp7Yz6xKotDZxJHa1Ld+gJ9I+P26gI7WY9Xr91RXYKFxQa7UcKNfoc6Bo2Ky6y+w2DHwpbJcYSyXN/ZHPLPfv4lnv3uv0t0+Z8SBzGL7YYaq1mHT/JzP/kxvuOP/SGu7W1zfbXDj37ve2jYMZ0rb2AH2zjVKnuxoRxTku9Ur5qsbg4pmSOOnD5NEI7I1mL+1e51xlZOs1xjLQ652lmH3YyVkYjUDaZcmGnM88VfHfPWxQ6rT26x8UJXfZcf/b5voG7nfOSpJ3jttTd44co1bm1t8NiRQ3zzA4cwX3X5xgeO0k1bDHyfkxWPl85d5rueWaIzTgnSEn/yA2coNyv8y0+f477pMnthQL/n4+k639SucXVzT0H55D5du9XHSPvUmjYnpqtYzbpae2ZaVSrknJ0p8cbdHapNCyOyqboZ23FKurvJ3I5Fu2QxDlI6kuc2StjoSPZbwc2NLdb7AxUi6+h73Fjd4LUbW2z7EZ6dsXpnhzzM2A1SDs3Os+gVnLu7StTMeH15narQmlslFrUpXnhrlbTpsPyWiVUp6G50aMzXcMqBtAvVvTLJ15p0DktuGX96m6xTcOeKSzClUaoWbJ+zWJxt4vhyXUgwssb5c+/OzvP+qOs31f6o67eusw89Sa8/Io5jJCfScnOceo+HpmZJdZe6bTOKRxw5cIDx+hYPP3qKy3fWuG/pIOdu38H3h5SdEtuhz1S9xpSlccMPuHRzg+/+hsf4c3/8O7hz96YKQqyQcHW9y/Ov3+TQVIMXL91FAtKHvk8UprSqFaKiYHfUx9BM4jxnpTdGzwymmmIDHbG2M6JSsrAtl5lmDROdfhIQR4kaFYhLarrRoNG02N2ucf7KHc7cb7Oy06fumJyYb7PlW1xb9hlvpjilEK0a4lgxo0Rc0wWO5WAaOpZVpt/r4NoWSZ7SdkuMi4jpeo3d7ZB8KFRmYWQUyhEnjKGqaAXOv847qR56/BmlkXrjlS/+nv9bZx56ku5eX9lrZRToeCVlX7cseS9iKpWImukQBTn3TVf57//wg+wGpho//K2ff4EjTZf33X+Cp554iCKM+PhLLytOyusbOyz3E8bbTbpBQXrvPZGEc9nYy2RJRgTNWZ/NzYKKXWH5DnzTB8oU1a5iTm2MezxTuo+r2yk9cfEJ/Vu+aDNnHBucOiO6nzGL9QbTpsOrq2tokYMfxczOlGg7Nq1qlbZj8itXbrO9fZCF2RKJhOhmKQY5Y+8ExdZncWdqGFpIIhuW1v3o+TZhLKMu8bbpaq9kGAmOk7COznRxi3SYU5ur4xYGS9Uaq8KxMRKsespZb5HPvVJwaNohScCyDKabZXZ3O/zZ732WI0tt3jNfw3Ac2k/9QQzjCK9+4sfQ4h2211b4sVdvMV31+Lvf+gBfeukmi8cX1cNyeXmXpakKFDG3rt/Fy3W6zRpfV6twazjmf/nS6zx+aJ617REv7HRZqNTwoz6PNKYxbYPpRpU3VzepWi5HZuZ4+Oz9WI6DK+TyNGRKIm30nO5Wl+m5w/SznFarxefeuMStlS2ePLiAoeU8dPIAa72Et26uEkcRe70xcZLyh548qgJuZVPx8LEZPv3aJRbaTQ7WXArNZHN9nfrsPGHgMz/fZOQXrG7uMD/TYGOvT2e3zzeemePAoSZau0W4vMobN9fVRlR4OWvjPmPfZ8osUauU+dirV1jujimXqmpMmcSybozxTJ2NQcSzBxZ5fmWHnSzETWUNcdE1E0fGdHpKS3MZDPvQMPGThGpuEkYj2s0lti46UO6qg+MkSlQS1YXaLhvnScSEbpj39D2T8oc55vEx/lWJ79HpreR4s44Kei3bDrVSmddefIF3cr1rR10/8iM/ohbev/pX/+qXPyYz87/1t/4WCwsLeJ7H+9//fi5e/DXr3X7t137t137t1359bdc7ctT1yiuv8OM//uM8+OCDv+Hjf+/v/T3+wT/4B/zET/wEJ0+e5O/8nb/Dhz70Ia5evUq1Wv19+3rfbSV0YEMzsCy5fKTRnqsxz8Yw5OrWNg9M1ahVXYqxz7d8+4c4ceYhNv7l/4/lnV2KPGGuWSe0PT5y/AH+i//uH/C9f/Y7WRNcKUNeP3+X/+tjn+DK9Vv8uW9/P6Zh8Ff/95/HTnUeOzGHoTs0Sp4SNm+ud3A1gxvdDjvjIfNTdcJUukEpNQcqrkmYltAtn6l2jTTTcG2dIM7UqVzL5HRu0KiXyKOcSze2cdw9pg8mBKFweuq85+gcjiXE6C7ztYDZ0zU6fshoZDAem9gybghiXNdVuU15LGGrMQfm5xj2Q9KoYNjL2LkUYFds5tslRUVVr2MmnSKdt954jXdSPfjoM3Q7fdVlOHT0gUlAaC6EVw3HMbl2+fzv6r+Xp6m6xmTUIw7CSUCpoU6zFHXK7haHag1mLYcz0zXm5xfZut3jxz97jtMNl1PzLbbWNtlsVHnyPWepejn/6uWQlU2PW3d6HDzUUIGNhfo2dPJ7+UTy+fuDkRKsLtQN/Mhk8UDB5WUfK58it7qcfHiGUmXEtx2Z4uJ1jYt3UlZ6HqXyQI3eqlUD/05G7CXc9BO+/ugBBnrMyk6sxqldP6TaLDHbrvHhQ4d5sywXpsPazi1i36fn1DCCf8Fsq4xrJCw1ytQXYq50zrMZlfD7BXpiEluOXFCwts38QzUeb40ZhR551SIydBUs/L2PPcLjH/kgr6zucGn5Lm9sr/Bd33KU21cieqOUMIK+n3D81EE2ewGNesCVksWRSsT4C/+azRf+CfWGgyS9PjI9y6OHKrx4a42VzR0ePTPF6t6Q3X5Cq90kzxNG3YjPXNyjqmvMHE35ue6YXT/n0WqFBaNE+eAUs1OL2HnET7+2hntggT/6vvdydW2FaqlBzIivf+Rxri2v0dSa/ORnf5Xv/5ZvQW9I9l/Av3rlNt97pskB1yWN+pw8UOfJU8d49eod3EJjpxfw5sVbPHT/CeLQp+aWePH6uiJ3L7WqbKytcGdjm5urW9xdH9B85n7aNhxsVZUj77W7ffD32N7c5cBMi2xnzJmyh982IOry3JsD/tm55xiGI4Iw5U89fILeYMQbt1fZEyH0aB3PMhj5PpZncbjicXFzh+1el3bFIS88Or2IO9UBJ+frnNArCu66vSs0aJ2fu3yedttDz3KaepnMToiEu1N3sRKLkl7Hqu0RR7pyDSqro/qf8L6k6zOhLhu6jLkktHiydntCoB9Pobe6pD2X+nyAoRdYhY5r2u/4bs+7cuMzGo343u/9Xv7JP/knamPz67s9//Af/kP+5t/8m3z7t3+7+thP/uRPMjs7y0/91E/x5//8n/99/KrfXVVybYo8J0l1FVIq8Lg8TZh1K8wcKnN+dZnHWwc4ffKoSlp/5XOfo+k6xK5YIyX5POexh86QDCMI7vLsbINzesHPJTal3R6zV67znkPTvH7uCq9eX2d11OG9x47xxUsrPHhingWzTJKaVByxeRqKgDtXr7Jgl3hjcxctzWg2K0RhzmgYUi+52IVYhuHu3g5eqYRrmirF2B+L+gLWQ5/+MKahlzg2NYVTragFu14pc3V1myTO0WyLW7sd1aq2U5OpVovdvb6KwSiZBoVpY5DRaDg0nCYbnQ5aWjBTKWFWBftuKpfEGy+9yDu5xmNf3YeykArwrMgVMlktvLZjMbd0Qn2vsnEQKNzN62/9R/17jm1R8jwMM1UbE2lUi8vK0nXKboI/8uniEWsx53c3uTHuQZzw5OmjfOTsHP/q1Qv8zLVtSvUyP/q/fpFhv4kfSXSCxqHDSyriotvfpV6bVnDBQkOlTluWztKBQ3zw8TW2uwZvXtFJw5Q0hNQYYWkWv/pLGjfuCzAq5/jDJ08y1U348JN1fvQXoD1nsTRTZ70dUsgmqKTR3avTjda5fdmgSCNqtUViv8/duysM+xapZTHX6nHmaMFeJ2daE6L0w4rK/ORSm1U/pGyajMJN7GKHdDZioVpRtPDTB5oYRoPUMKnpbUU9l0iXg9N1nuMWf+PjX+TE4mt8+0OP0KpX+NbKEf7o0/dx/n6bH/nZ19EkWDcviKOcP/eN93NzdY1+Zw93dpaXXniTpx8+hj7exarXlGalSAo+eHKO0SAiMwxm5mfQhACc+pSMOqHl8HXvf5DxIGBUBPiGxulmmfqJg6yNhwz2QnUfFvEIP/N57tZtFquz1OTBbujMNBYkdYHTwrtu1ogcj+fX7nBWn+epB87w3/7xRczURytGDPwBD0/ZxMkuf+jxGabmDuBoKaXpWR568j10N27y+S+8ScOM8YOc5Y7FMNX54NP3cejAFPPtKQ4uNDDTnP/zhes0S3skfoAVZfTHAe0w4OjhFrH44/KcjlGmUQv50OEqHzh9hCurHTLd4sJ6xFs7fQ4tHFTBroNxzImZFt/20AmWuz7Xdvdo1+cJ4rEiy5+YbRKbKUcqcj1O88qdAbXZRYa7b3H/0UWiJOLO5kCN7go7Y77mqNBjOzjOXq+PXuiI6k3hHe4dDORQIL/QVCzFhMIsF7VEcci1Pe7oeAc6eJWAolwiGuho+QT2advvDrv6b1XvuFHXX/pLf4mPfvSjfOM3fuNv+Pjt27fZ3Nzkwx/+8Jc/5jgOzz77LC+88JV3sFEUKV3Pr/+xX/u1X/u1X/u1X+/Oekd1fH76p3+a119/XY26fnPJpkdKOjy/vuTXd+/e/Q9qhX7oh37o9+CrfffWa688/+WfHz/zMEkhboxcjZG8poe/HPOFG3dZmllgsVzixFOPEXzheW5ubnNovo3lOVy4cJMj0zU2b17kkUceIfrMJ/m3Wc43fePDHD44xWKtxr/6wqu8sbXJ0VpTBZZalkWUg22kOHFKu+xRYOBpBodaVWJ0mq0Sdck+qnnsDcbkmgSZSpZTQVnTcKmCIW1dk044QtNywkQjEqEzBY6jM8gTZtKCXuwTaBl39gaT4MAyBCMdPYRhFhCbEviXU21UsGydMM4oiUPHtTn35k1q1Qa2Z1GyG7z56ud5t5SI2sMoVCyiPMuIgxBLsXU05ZyDGEOQMyouS2Nm9rCCB0pEiGk7lDyH82+8/Nv+986f+zUs/qHjj6h2vWVqXN1K+eaDEd09OFwrcajdoO+P2dodsVR1+PCpWU7ff4Q/rg3Z3R1xcatDkbfVsifj0Dg1qVUtvuG0wc+8PCNoN1KEmWKqHDrL0Lh28S3+9AcOcmt5pJpaSjoqAaiZriZLM9MZ9Ey2tlt8Ntvl1ed0NnyBemZoRFw4J+GOcsCKef+Bg/zK80MuXNNx3JxmzUGmnkdrOXv5kPc+eoCLmyLiTqnpdR49tcjZ04d5z2OP8ZlPP0e/s8NDh+a5fGsDs7D4vgcf5uZWB63msjDTglxgfEPubnWZmq3y5IEm4zBnqlLjb/2Bj/DCnev8g888zy9HBd//B55lfdDnysaA/+6fvcqBVgM58snbJ0ykH/jXb/LP/ux7ufzFFzl3IaBka6xurbMaBHjOiOmKh2UWdHZ6yk1Zdk1uD4f09YLXlrt853vOSvYuty5ep1ErMa0Z3FzZZaNesDmIGUqIsQ5lA1K9zVNzx/gr3/A0oyTFbFQoDIeGpWEEY7Zn2zy24PKjf/JDeK05zLDDxu2bSnxsFinlkk4Q5RgmCvanJUPefPM8jz18PycOH+CVz3+K/u3L6KMB98/V0SsthpHGbLnG3HyZOLRZ3thge/sOuuFy9sws7zk8h57GLL91CS8y8OOcnjjVJJzTsDhcytlNPI5W23z6tXUGnR5BUbDXhxm3jBenuKbGR06dVNf99njEP3/jvOJC/YlnnuHO2ip2GvDAbIs93eKHfvYKT93vszF0+S+PbfN8v8zOhkdRy1maciiKlI7Wpz6Y4/VX1lk46KsuojRzTMNU121xL8dOE1W+qklX88s2wAnnk/JUQhZD7hcUC7voo6rq9gj49bUXf21tfzfXO2bjs7Kywl/5K3+FT37yk0pP8ZVKWnu/vmQE9ps/9uvrB3/wB/nrf/2vf/nX0vE5cODA79JX/e4voeMmiU7Z8QjEXt6y+QMPnOWnXzzPhZvLfPvXP0iNjL1uj6mpJnsb2zz55AO88dZdDj56HCsMqbemuLKzzTc/8zA/9Ge+g2tXLnP11joLpTKPHF3iC1fu4ugGTx9d4uLKBrtzTWqOReoYlF0HY9ckv9fSXWpW8ccjNQqJJKbJLBR1tFapsdntqcXBcAyCaExuGByYqqvRVW4UtOsOS+06r69ssbEhroAyfqenrKD9QZ88LnB0VwVe6oajNjqWbmBaOnWrhL83oOd2GXRbVCtiHDbxbPddtel59PFn2Nntor+9uGri6nOVW0XNu9KURGznMv5CnEIWoR5jBEKMNbDtWG2WHnviaV575Xc+8pPk+Vw2J4bBY2c8vu7+KuF6i2PtChIDOt1ucCio82/O3eCBq7eojne5trrJX/uWx3htY5ePX+5ysRtz5foylZqHWz3Dv/zCLUpOQ+UyTbLeZXRgcPzUSVY6Pq/eMLix0iYrJM9LRgu6CpxVOzABCqY5/ZsxU48XfOM3PMDttS2qVZskgsuXPJYOlbFnfF5fXWWqZWN5Iaa4H8tVltdWOR+YfNN7D+J4ZWbLBdUZnYEfqYyn2UaVpNfhUMOlbzV44OxR5Qo8utTk6x88wcLyOoHSfVT5wlvrrG8PqLg61ZrJxnJER4J86XOUef7CM0+x2hmiBUIMblPNQ/7+C1c5s9Bkpx/LW6dKNHBH04Q//RMv87P/r+/m4uVbrF69SVp2We1uqny7lYHOqN/noQNNXMmHMjTO39okjHVaMr4adDl/5xZnpmq8srbNntcinT/C3f4qt1ZWGGYp3/f0R7g+NrCjgPmZo3x2ZYhvlHiw5DAaD3ns7HGeu3GL73hoHn97hVFcUMKBPGbshxgSaOxoiigs+hS5T329Qj+bpqfHfOKlFUbji7TsCKtUkjxb8vZBVnsZl67e4NCUx91bt+jt9vB3O5Sn27x17TrXNjY4t9DGzg1+6E/+YYLCIhzuMkpCbr32FqVSiY/dGvCzF7v8sYcX2B36LMxX6N7dY9gds+1LDlnOiXZLyQB+7vwFap7J/VNLzDdnOVDSqR+Y5cVQ5//zxg0ONz2eeHBagTAPH27xhRcfnzUAAQAASURBVCubbI50/GCgRn1PH22zHu3SDzS6xoBqWf6sOA8nmXUy0jJyAYBPwkdl4yNjaEPy6mQ3qC5V0fuIbi0jGXgYs0PqDZu4X8aXkbRuqSzCr5V6x2x8XnvtNba3t3nssce+/DEhnj733HP8o3/0j5SA+e3Oz/z8/Jf/jPyd39wF+vUl4zD5sV/7tV/7tV/7tV/v/nrHbHw++MEPcuHCb0Rnf9/3fR+nT5/mB37gBzh69Chzc3N86lOfUqOTt1vyn//85/m7f/fv/j591e/uevLpr2cwDFSrFU6wZ494erZOHMPxepVxkfDxc5d5qB/w3qceU+yV9dUaleY8zz4S8fkXLuCv7fGr56/zS1f2+I7mFFo6Zm5zhS/eWuba3T30RpVT9RZaXmCVLB46tsg3v+c0SZhwa7OLJuLNahXH1JSzbDAM1UUdJhBlEbZmKNz72qCLH8tYJqake8p5JSdlSW4W7oVl5tSdMn4qfBjJT8owXJM0jlSKt4i4jcQkNyQ3qyBPY8XOcB2bcJxwt7uJpVVxPYskrKMXPo5lYzlTvJvq9Vdf4PR9j1JkqXodsiwlijOSVHLHCtUE0e2QPLZVA0hxS/xQjb+ccgtNF9Bg/lV1ex545L0Kxy8sH+k4Xb4bM1fp8z1nG/hRwVZvxCMNj41gRNvzeGVvzO1+wP994Rb/45ETfPDDH+LfXnuZJLvJscNHmJpZYGtrHdcRx19MlonzRZg4mhLMB2HGUtPizevSCplETMjvRUVCu+Rw+YoaDtE6UOLUo7B+cwZ/vE2qcuHk9A3NWsHG9R5P1Nv0ooBaYfA/fM8cL5yPWB9NoWlb1GsmuaWxNthmdrrB08eXuHR7g8L1+MyFizzYKDM9M82x2RN88fINolgjiQM63Q4L89NcvrvJ2vomR8tVHj1RV+NmYclc7w64/8RxPnimzp3VDT61MeDPP/skYZrw6avXaHgaz7+6ztNH50klvkU6A5pOlBb0g5z11ixU2uy+8n9zabNPYjnM2nB62mF2usqKmWA4JVYFyBjaZJlNkSU8dP+C0lwe1DSm5maJ8kh1v8J8xLxtszkOOXDqPiWC7l6/qyCPehRydvYY5Wmb5d0Ozy5UyUd9DjSrpKMhXn2KojDo7m7QG+dM18tUq2W0WGJBLC5v7DEzNc1Mc5pgc5ve6nU6vRGnjhwgKcqcuf8oYW4y1Z7GvXuXg3Mt7ly7Sn+cMoxiUdDzxYtbkITkSc5Lb92iP4pVNtYzp85ydKZFabipBODOaMhW5HKwbjBditH9mCS2aE1PYfo5C+WI7X6PMEro+Sn9OOPbHnmU3VBToFTL1qiGEXu7Qx471KIXpMq1KuyoaGePcSyNU125ULd3hxTHc2btMZ3YYsPeQTtcpeiXyUWwLG5EaSvdg3oK/0cgl8Y9gb50f9R9qUu32iLSM5jtoSU5njnPys2AelXHsSyqza/cIHi31Ttm4yN29Pvvv/83fKxcLtNut7/8cWH6/PAP/zAnTpxQP+Tn0pb8nu/5nt+nr/rdXS+/+AUeefwZlTGElnBl2+bJANwi54kHT3D57hbTTcEIxBS2xmx9is3lDXbXlplqNlSGzvm7d3ltc4PvfPYMHzg5zfDCeX7lrRXMZp0r527z2rmbnF6YoWQZfPdj7+Gf/+vPqaDKre0xK/0h8/USvWDIjC3OloxxGjFjORimRepruIaG48nYIaRIUsplizSJSeOEYX/MuTSkXSkxCsWdNKYkupVUHlopo2BMyXYZ9HxSXQYcExeTTDlsp6Qegkk2oqTbjIuUasWlyObIkp7SiViGxWtf/CXebXXl4m+ELR47cT9xnCh9z2QjZJEYshGS3y0wSiaxX1KjSP3egvzVVBQnqstba9eo1eo41jqbG1vMvqfBrW5IaGW81RmyNFvhL37wKeqNEoN+l2/86NPs9RL+3j97gZWb60RhQpHF7GzcVu+paHYksE0GXfJTmWPJA2rz7nm1aTbNgsuX1jl1ZolhnHFgfpoPP6bzj/7SUfR0wA//4l0+/YLD0SVDaX9k86SLCwexxkfsBWU6Q425uRF2VOVjn4WqV8LTfeWO3NjMuLnhcGLBZ2845OUbyyxMzXJxbZNAwkRX+yyOU77rD53Gv3Sel29u8PJGh+8cJjw2O4WFQdN2WOnG2E2TadOjUfPQH3a5NNripc2EarzJSzzMI605Nm9fpOmaOLmEs5q8eHMPUouHDleU/Vm+3yxL+Ki7A8mYIDH5ro++l7eu3+T2+jafurTJkdmIwaiHfvsumldhV3K4toZ45Tr+xh6XOwnvf+IhksAn0WSUc4pra5uUdKEET/Pi6jp6lvKH33eWa+tdSlnEbF3nlZVdPvqBh/niuUt869E5jlTn8Hc2uLK2x3yrxUzVo1KMGWcZmzsjIsNjY2OTw0tNvnTlLicGI375udfVgezEwTl+9fwtDtdMGlbM1PQ05ZkKly5dptky+aPf+XVcu7JCMW5yZzCkMHcZDA3O766yI5TrcpV/+/plPv7yRT5w3zG+/cFD2FNT3O2NWGxWeezwNL3RkLXYZNgdERcmm70Rx+em+NzqDb7hxBmyImPG9rjR2cMfpDxxfI7PXrjIyuYepxZnefjEQX7l8h7P3RjwZ55sc7Hj0Lm+wdyxU9y8fJWpWp3PdqdZci2ON2Fj9Q2Kko9u2xSpAbk8wmXMb0zGz3KD5ZoaPcqoSy7wwTjDcTMGvsXCCYMdf4RV2OyOx1RrYn23cFyHL37mF/haqXfMxue3U9///d9PEAT8xb/4F+l2uzz11FNKE7TP8Pm9q3OvThxzp+57hAOuwb/4/BX+3AMzPHBqiZmpCj/207/C3/sf/xs0s8Kly3epGw6l6Tlmm2X+5ne+j+dfv8T7vukxlvcGfOT+o5z/wjn+6PuPQXWK93zwSX7xEy/zhQu3eeXmMsO9DhfX9/iZz7+Jq+voesGMY+K5Jlt5hKkVTLk2s5bN0LAwJFYiTQgQ+72pxNdCbE3SCNsxSXWL2VpVbW6EMhtGogdLaFg2vg5BntLf7RFJAKFl47g2SRyhZ2+f3GAUOARRMGFglDX6Wz1lHRWR4dvz9Xd7/Wa7+rET9ylCbianUSS+oCAxExHcYdvWVz1aztJUsUmEgDschorcnWlVvv/jfV6/sMWjjx/iR//aI2xeu8mNS5e42jd4a7lDuz7FT31mhacPu4yCCIuE69fe/E2fXbazE12SelroOVRKMPDBsfhv/uQZtNI0P/NLt1ldXuOndyx+6vM2f/XbjlI2fI7OjVSAqqLl6hONkJQIwI8dqjPol6hVM5Y3t7HNGW5v+FRKFY4dXiRNXVyjxq++cBvdCTmxZPEnPvwAr15apbsbcuxsjelyxBsXL/BL1xNm2/OsX97l0brDE3MVnGaZK7IBrNbp9RMOLraJw0jRoSUKo9dNWO/kHJ+7ix56aKMep44eoaHr/Ne5zs+5l0jMjHOvdcCqq03BK1ev8HPdA9z9L3+Am9sdfuHJk8yZGs2ZKo2pKS7e2eH40ZNs9Ydkm5s82WhybT1CD312bo74tm84y/TRBoZ7hBNnj5GFIUWlRCIaoarFpcEuB+fLfOqNNWrNGhd3Q5I1nxuKXt3nmYeP8L997NPcf/w4RxaahJnOWmdMpdWgXrOxnQbXX3+NO12fwRg++eIltCAkOj6HPxizM4o4XaQ8fWyasL/JlYsXeeiR03RXNU7NVAiHI/6X//fHsOdrlAYp7Vqd9z98gu6gz9RMk1968yI//9mAk4cHbHc3+cXzVzHKDcpaTKNd5nhVOjIZF5Y7vHanix8FmJpH03RZcFwePbjE8uYeh+sW/SigUW6yvr1Kodt0I4Pa9CwbI4tmR+Nwu86ffTDhVC3H1GKCpcNs0qS4KDm7Ou5Wlxv1GgfrFvMzM3STHp10h3xrHqciwUG6bLG/LGoW4oNC+ojwR8JNKyLMN2kez9mMuoz3xuhljXhcULJsXHvy42up3tEr8+c+97nf8GsRMQu5WX7s137t137t137t1369qzY++/WfT0lSTJxKp6PJjVHAR4uCYL7B4w8c4wf/13/Kv/w7f0G17ptmiUOVAe2yyzgzWB8VHD4yxadfW+ZP5Ab62SP80qjgi//0l/j/s/cfcLKldZ0//j6pcuyc0+2b851wZ+7kgRkyEhQEMyq65pVVF/3tKv4XFV3Tri5GBBFwRaLCMDMwOd+5Od/OOVR1V65z6sT/63mqZ0jqIo4Spj5M0307VDh1zlPf5/v9hJ9599v4zz/6ZsY+/RCFQp3zs+vEM0kOjPZRLlSx6nUmFvOkk3E0JSC3UaRuNai6jnRw9useHR1pyg0T0/VwAw3Tqsl5umt7HNnZxVhbO8VCnc2wwlqlQa1uyg6hpukoDTHM8mmLpwglFAJdY3PFkqGRsYhOKKwRVhRpBie4J55dJhQbw3WL6HoIN4jxYsTUxFfHxIzv3C+VJcLt+9JXjMr+NaMu1/Ukx8eqFajWGmh+wGa9zI6BOKFakT/48EU++shZ/PU1XnvHYTwXNpeqXNMT4Fg1Hn/mFANd7bzj+4+wUKhKJ+J4Nk1fVMHyQ8RVjZ5MUgbg1nyLlUKd3e0Z3FiMeDTg459xKVm+HO1FzAl+9wMzcjzmqyGOHDrAhcsTqEL5pWoMDfUzNzcvuz89fYMsrdjMztQYG9Xp7WjbkhmrpLLtTMzmUfwo0xMm7Zm9/PL7znP/vQvcdttO/s8nTY5st7myuMJ1IwYffd8av/rzO7hhpJ94R4JIMsmx3i4SAwP4G3nUbJrNiXlCkSiRdJZkQuexU1N84fxF5ibmpGlgrZ5nfHSMm9w2buq+jUR7hHuvn+Hq4gbn1ld55uEJ/nBfF3ccvI2VQo1PPTJJOtygLRqmuFGXuWjths+ug2OsGj5ewSLblUEXXaa2uOQhLZ6+JF2cN6riOGfoUjSmbYszOYcMYaZzDXqzCRbWC+zuSrFY8nnLm+9GC4WJqD4JG2auTvGjP3cv7/mt/0Q2rrI9GeOzj4sOo8HM3Cy6bhByAhl67PpwdaNKEAphaBaq7nP+isjQ8uW1nSudYtvIMpc3Am49MMYd1+0nV6zRCNlUqhZVy2N1s8hguo2Xjwzx8h+PMLuSp1ocJpFJk4nFmVjMMZCK8fGnz2D7KjGR5RYzeHx1kYF4gsmcha022DMwwPGJs9w6fpBkocB6sUqgalRcXTqdh3zoSsPU7EUSkRRCi/+RCXDLDRrWOg1rWbqhC8sEofYqTW1S64wxv7HKWG83tl3DioZlVqIYbwmeYqAEWDUfPdY0MhRKVS1I4BpXpalrWB0iYqrcfeOtFOxNLpw30QIxkg+TTvbwYkKr8GnhBUE0LFqlHkMRnSeXfEYzOV518356bohKueiRXQMszi7T3ddHIhYwO79EnLrk3Jy7uoxqu7znE+f4pR+6Df3KCvcYYf78r/6Ro4dGGRiI8z13X8uViTluHGzHXc/REdJQuzOU1wqYtk9BJD+bDVKKTklIrEMhfIoUaxX52BRdlaGVIpFdMP/E7P3osGhHN8i5dZkML8ZiVqNBQYdoUsRWezL2wnY9NjdM4kaYiObTEYtLMuR6uchtu8eljPp8cQG0ODW/QMKIEAlFaO/o5N/mWfztg8krXy5M+NdifOc1Mg7AdX3OXzgni6igmTEhi14haw6pIVbnl7h5KMQj6/DpB0992W3cfc0on33PG1AwmSx6vPrQKLe98kbclXX0tgTEU1ilEu//64d4cmKNn3n9MeY7K+TLFtt7klyzLcuva6flyM1yAxqmQr3WIJFJoOkBx0+eIRyJyMJneLCf+YVlWfSIsUNbW5zVFZ3h4R7p7D3QGaNYLFI1VWZXJ6QbdizWw9693dLzZ62hs/+anZQaGfb1lHn4iTJ7t+uUqlHJmypWLekDU6qFiSQDAk1heWqBdGcHoapHtLOd9PAoS1MLTE3lGEqFeN2RAzw9u0AYi71tSTp7OjErVRZtkw49wluO3UVAA9+qMvwXt2IuLvDEE2dYLZh0ZOOcnFjgzsPj5NcrqIHLuSsL7NNCBKrCRm2TVDzK6KFtbNo2NQWibRlmymUSsRBzhU3m16psVmoork5POsvjFy9RslSO3XwjU+dOojmCiCt8tzxmSx7v/rP75Ov2nl98I8XlBc7mKnzhxAxpxaFUqzHSFWesP0uxbrMv1AGmSclyyKKRysSZX5gm29vHRs1iV0JlOVfjTHkWLxHj6eNlosK1uF6RPkSe7XPvwhTRtk4sa4n7T04xMt7N3NIaYT2gWsgR8lWimsE+vYd6oHB6fp5rRC5kIo5drdKVbSc9kOTI2BgFs06+avPU6gZquI18zaY9maBU2ECJZUmEVAaTClVixFIGnzrj0BOp0nB8XF+RY1Ox7Wr68ij0jIpx6RqBahHoLsP9fcznwthBQ3qUiQIole4gHxIh0A6+UgMvjhrk2NbTx+WFOdbqKzKt3XI0GZVCoKGqunRZ/8K9H+HFhG855+YWWmihhRZaaKGFrxetjk8LLwjOnnxKfr726M0Mp+FMNUL53kfpGevnlTeMQcTgjkN9rBUNGl5TBm0rOnXb4sJiEVeFP3nkOHeNZ9g21M/PvfnlfPKZ0/zNp0/xq2+9hYSqcOzgTvLrq8QcKHsejuKR8jyqgUtvyKASjtFQAwLboWrXZddHKB82TAevYUtDOJFdFA0rdAx3UXJMbMVlqVDBkGM6le42QXYOUbA9Qp6PZbvUHZdQzKAtZdCo+ORLVanU6DaiLG+ssVk1UcMdzE35jPREUARZMNLGFz7zwdbZ9QJBdEEsqyFVXWK/JuTiYsAqctY03Sek6Jy/cpXf/pmX4Okd3Lw7zuHrD/LG197Cb/y3P+fKpstN+wZQGhUqSznecGwfvZ0hIXlhfn4TZWKR0T0DRLaN8fZXX8MbHY3Otii7SmUs0RFpS0Nkg2hIkUovJ/BwfJVQNCTHXppQ0ggZsSrIzSrpTBp/fhE/8Ekl4tIcsPmYYb3sUqq79MVFfleYZCpFLJyW8v+R4W1cnZqREmTRnDy4Y5iJq+f4qdckuO+yLjteb3l1Dxen57GGTXbs34HS0yfDNJNaHYI6S1WDwPPIqC56xMByAuqez77do6jxEM9enCS3XuO+J08x2N5JV7vOxMomO1KdrG1scHTvNvxGmfLiCgnfYkdnlL3X30AqFeP6m46wdO4cuuOwWKnSmQyz6cew02lGB7swGzaK2aBnpAfT1aSRYmUtR8nSOX5hRuZ9uZ7G6ekpTp2Zo1Ss88ypc2zfP0yoLhzUYXykA81v8I7/+n387m99kInlDbZ1hTm6rYPVQp1CxSIs9PFBmo1Nm4pl0dWbIdnZRp9vYsTSaF6ViUsqnY7HZqFOXzLCYDaEXTOJulUcz+L81BpV20eri4wyl3IoSk+xQFs8Riymc3J6ho1ajXQkLs8/YVQ51J0lXy3RFk9I9++ZYo2diRjveNkr6BdO7RGPmY0SF5fXecWhnXR29TMaS5OvbtIV1Kk0hMN7nfm6TwidvOmTVwLG2i0s10BXQ8RzNsWQhuMIB3BBtFe54/YRzjwxTVf/Xi6eWyGuGmhuFOFw6BZd/A6PjdApgrROX2+WRi3FwT0DTC5M0RYfYW9kkNVChdW1NU40CqxsVOhuy6KGNGnK+WJDq/Bp4QWGJn1A7EaWZycWCC4scN3uLib/4O9YmZ7iXW/7DnZs30d3ZztXzp/mO191G7tPnuXRiyvs7jT5gb9/jKBcZqS/m72jA+weG+XRMytcN5Tk9FqFHdvGSdUKnJorgCWCKkWqu45i2SiqQ8Iw2LA96iKCwgsQmXsRR6HqQSSuC2U9iytVhtpSLOXq9KSSOKbLSG8HqyWTYskkSCuExWis1iATiTHa10e+lqdSqCNMibOptEx1142A5XwNVRskGzIozT7MmVm4+fa7ISRk/C28UGg4Qsru4jjCU0eVUSMhVSMWgkxMY3JplZffsJNDnXEWTagbHrFEAkoFvveuAwx1ZXFM4YGhoagqum8xM5EjP3GF/cNtRPq78WIZFN+F3bvp7O0kIEH4nnsJx7MEh3Zzy23vpC8TxhThtzVoyGIGXC/A92xsWxQ/QhIv/J0MzHpdjuG0jl5WixUMhFeQz/jYQS6dfYaJglDdmIzvOcTFc2dk4SPGsnXTlLfR29VNPGpQrZl87pRKJOQQuAEfOVtk9X/fQuedr4JYBj+3jH91BZJtKFGDfs3ELIr0eYuf/quH+ZO3HePM1Dwd+QKeaZFSfIa6usk3qpy8sshAR5yR/g6WFmdZr8FnnpkgqVzEyi8wOL6D0ZERTp4+wVhHjL9+/6cIxxXaIlGGBnvZtFSSHR20VVwKVkDddLDMEslKmKn1IhvFKsWSzb7RQW47PCQjXSaLNhEvxEhXN85YnPzqOhceu0wsmsIeS9A/KiJgdBrL8/zqL38Pz5y4wlrZpDthsW+ok/mNOuu+xo39WaiZ7BntQytWePj0KjftSOMrNkYkRKqzA09T6dUTrBc2CCkK2/aPo3hwdmGRjZotr/O6JjhCtrzeKYdYjRWEYQUpzcDSNYYyGRYWSliez1KlzqNT01xdLWHVbOppk/n8BrqW4aGLE8wX1kiEwxRLdczeNBgKimUxuTRLKtPGkiK8xmqkQxqzVUeOUdeu5Ljz2n6WGll8EbabhGjBxGrYWxYLAY/ccwkztg99Zol4KI5dsHCpEdcStO+z2dxYI+WNULNM6l4ZvzHA+YkZJucnmTVDtHeFUHzoaW9HCSy62zJCfyhHaVL2/iLDi6/Ua6GFFlpooYUWXrRodXxaeEFhGJrMO9IbJXYPDUl/HNf0+MKJOka9SMGP8fSZS9RqDs6SyXCvQk/3IK/tH+b11QqPnJvmytIGj0+usWJOUix5/MUP3UHn4Bgfvedj3HEgwuv2dNPh6iysr3NjV4SPLZhkVIOYETBZM6lYDul0gpGEUJQUKFMjohjEYzrFWlUGl87nS1w3PijdnoUh4nrVlGTZQKjBnADHsRBROCKwsVapslFvEHF8+jrSRAyVuc0cDUvsQncSUcPElb7nj8FjDzVJmV8Ljlx7E3bD4/y55qjwxYqbb72TWtWSqryrl04yNLpPBoXOTJ6lb3gflVpddvCamUM+IR2yEZWlXIHtfe3cMD7EK28YYGatwuTCCq+7eYgjA0kQTuDil8uLoKcxTBNzYoF1I81oXxcD6QjYJq6ZgsosavduyN5AwCawF/0VoqMo3HAW+OjbdtD/E/fwAy/Zy3qhQdn0ePzSlHz8mXSP9IeyfRfXtvnHz9xDSFVJRVXU4lUycYNnLjbVbOmQQ8i3ZSaWGJedeeZxqdwRPkdfePBRGSQpzsXJaoWZ+RnZCRLb9Ww8TEcsyivHahRzNu1iRJcs4E3OQbGEeXWJ2O4+7MkpjGiKbXsP8EtvuJ7FssWqpfCaAzsYrTdIplMEgUVxpYLX8FEsn4n5GuvrFsubFqYfpmA6XLd7gOhGBSOao6u3m3Bg0R4OEQ975AoVcBscOLiPhx++iFUtEaYkXahH+rqZmFjF8sJolsFgMkxIjXNo1xgf+LsHuLpUZm1+hp5shxxT9g6nCfQR1ueW2Sis8EfvfYpf/e/vor3uYJY3OLKjj7nlFa7f309Cg7GKwaiaYEBXSQ93s1mpYkYNbr9xG1E1IO5azBardFdLFIw4hYJJRgQdu2XOzyzjKTAxs0pnIs3OkX5OT05RimkEwv3dsgm5CbqiUUrFnCQNl2yTilIn5sUwwqBGDeoNn/ZUinAsysXlPMcvzZPoSEiFqVX3iIUT1PCp+yrWZoF2Qlh6mEKlTKlaJduWkSaJie4+TMekUg0zMhAlb0WxGiq+o6AWK/JcCpwA17RImD7VhnB1DtATIUIxm/FdAROzy8SCEUq1ZWqNMrFaO22ZQZamK/i5Dtq3hTAINZVeiqAZCAfyAF1tOjYbuhgYv7jQ6vi08ILiycce4KnHHpBv/h3DeyhVGszldaJmDiXcxvz0Vca29xNrXCXTHRXCAjzTQS0X2DnWRSIT5+Y9fXzyHW/mN153I286PCY5EIR1Xrmvn5gwJkwk6Q0HGJ5G2PTpT8dIRhWmTBFeKCSgGgNdnQx0dGK5Ho7poxuGVG4Id+FUNMpYXweLtQbn1vNEIiFsN8BXVCKpGLrgjER0wSShXKti+XWZRi24P13pBLmKiKOIcmDXHUTUKOWCQt/I8Nd1vARnw7QajG0/yPbdhzlw5Jj8/u13v/ZFdWY+9sgDnDr5xBaHJ878zAKbhTKZjlHK5SqOJUI0mymaugrJsMZSbpH/8T0H+Iu3buOdr9nNoW0DFGyXvuFO2nqGeOJ8nvOnVzB0Gy9fYvLiEpMXikQP7KRr/xBuVkUR4r2iSZAvQlQjsIsgix4Rs3FOKvYUVggqM/Qe3InX+Cu+87YejDa4a3eEQ9u2ycc03hkmKykXNnKmZteJag2m5q5w/Nw5BswVLrzrLv73a/byzLlzXJ6+wtziJMvLV2mP+CQMj5AiTB7FO5sl4xxcwUGz63hOHd+xiYV8HnryCtcPd3L2mSscfc07+ZX/8pcgOGyKgd4WJajaeKkO8hXwZxe4/aXXcM3Bg/zD0xNyZDS9tMHY+Cjbt+1geGCI3t5+1u044UaV9kyUH/7BV/CK2/fhKhrdmQR1LcwTEyt0aPCJU9MQ6+TKhosf0lmrNnj81AS5zSqHD+7ASI/w2bM1Pn2mwp6Dh9i7fQg9pNDRleHILfu5MrvG2dkV6nWLH/7B76Bn7xi2XWVjs0JvVxvXH91HOKvSUDz+8v3vZ3zHtdx+83X0DmTZsa0f36pQd2yyA90MjHTKfEZXOIR7dRJqgOHXCNw6K9Ua5UKR0dEUfSmDG4ajDEWqpDSPaiOgUhNKKBUlcDl5dZJNkaQei5GNZAjCEaZK6xSoY0Z9kkoSx7HJCE5fJkXBNDk3kyOsaAhvbtsJaOtsY2xgQPKlknqcbDLNWF8nbzp4HZlogo1ijt6OGBXNoyOTIZlJMDg0SFsmw8bKijSkbIQSTE4s8arrdkjOjSpGZNIIU0HxPHrbOjAtG9/2CMRo1fYxywqLayVKG0s4QRmtmsZcTJEMp/DtJXrbEuzYMSbHp1fOPMXl009Kx/BENEwyGiYmPwwee/geXmxoFT4ttNBCCy200MKLBkog5QMtPIdyuUw6nW4dkBcAb/jBd/KJD/wWXb0jGIrH0vIC/V0q//CHv4xTvsS1b3oFl//xcU5ezLE3EyboHuDieoVObIxYlGPXHGZ1eYWoV8fGp713EDOWYWFljV43x0e/cBJTD3NqtUgYj8lShVAiTKVo4rkBSsSgXLfwKw6hdEiGBorAzGpdYXw8y+JqnsA3pF17oPlYVQtfCxFSPUIJneqGRXc4TE9fG+WGi193ZFBqwQxoj3ahqxEevudrH2v9c9i77zpJ3tUUhVA0SjQWJxKOEDJUPn/vp15052LPwC5JABV+OTLwS1GkIioIhC2/QiKs0ZcNEw/bPPO/38hCxWP14hR/d3wRrS3Ozfv6ONCVQi+7TBbr+NU60YTB0bEUjMahlsde8NGObJcdH/eJDZSuOEooQMkmUToN1F4R2GgQ1NbxJ6dRBvbgPTqJMpxFd/KY6xAdHybYNYj76eP82oee5jf//sTzz2F8YICeTJQ37krys796M+y5kwBhaKnhHX+UBz/yOO/+h7M8Mr32Zc/9+oP75LjFdEX2WSDHE4amMnF1ih983a384zPzPPT7r2PnoVFKl5d5+tQER0e68Op1hPVUJBmCdBvo4nlu4PYNo43v5uXf91vctaePgUyEmw7vxTVLfOHpZxnu6+bIzu2cPHsO3a7T2dvH6N6DXJ1Z5eyZc3QODWPbHvsyBvMWXJipcXFxjf3bEsTDERbydV5/4260cIgdB0dYuzotlWRtXcM89uSzDHYkmMttsCHGmHWL89NltnVHiWRiLK5XiRsuH/jcU/Rs3832mM4jMxOojseli0skQzHe++s/Syk/RaVcY9dAP7nZORzhXZNuw1KjbOuNE1EcnEZNDHPQQ2EuzW2Sjamccfv57n0GV6aWuTy9xBOzkzRcjaFEho1Kla72bhJJg5n5Jcq2UIqapLWEHP0YUY8Ns85GvoEe1olFEszNLeG2xYn4OoZoVYs3UF2jRAOzXpJjo0w0gymIzbrOqw/vZWl9jZlcmbZkEl+EHXsBUUPl8Ph25kSX0fLpSEQJJbNs5jdIxVWqWobNYoPV+TxOQ+TKuSiiyyM8fhwRlivuN8BXA+zwBqFwlbh9PfVqjpARIhENcfbZR+Xju+7Y7ei6wpOPPPhPXmt3vvSVPPD5z/LthlKpREpMCv4ZtDg+Lfy74NaXvIqB4QF6BndRKW6geA4DPZ3YZpmPfuwTuMfu5mj2R3jt0RF+7q37+fCDZ8kF0yxvVLmzP0PF0JlfyLG4uMirX3Yjw9tHOH7mEsODY2SjQjI+wg03KuTLFR5e2iRtiDcIBdX0pRLLVVSqQVUuGo3Aw6qI1GVFtokz8ZhMe68WTOJxHTUqZLSWDGYUzrSC1RH2XMaG2hnu6GCiVkcPFGr1BqVqCU0dRdMi3Hjgthek8Llw/vhXfe+Ol77mRVn0CAgDQFHgSPm3SA2X9rTCd7LZ/jcMhUxc429/4TacSJIPfvJJ1LV1bjw0Rq/RYH11nacrKi/Z1s4NCZ2PHa/yndd34bYpBMsNiGch6qC0R6BeRd2dBVdHELzU3TuhnsdfWpf8NCEpVzqyKEoVdWcbQS6PG1YwOhK4G2V49jzatQN872PTPN7XTnV5A8HkmVxcZHIRsto2fmbbfoIFIVGP4D11Gm33GC/9vf/KS3/PJ5g/J7afuI9f5a5f/hSPnZmQJoKCV8RYgp09Ka48NUs2m2ZvVOd9n/xR1iwdpbOHc/de5GVvfw0zn3+WsBEik47hZmMEXhQjGcfZLMF6CV+7yGd+5TtZqocolmq8608/waOrOd5590EGevto78pCLIGIaXUKOT78t5/h1a+6hXzfIIHl0tfdzqmJSa7fv49GQ+fpK/OMDe9nbW0VVTfYc+dN+IUNLp0+QSKWxivlqJY2ONINTqadDz9+Ad+2yUbCWLUS+VyFuYWAV998ENO3ybRlGYqIDD1NOhqPtMfouuYQX3j4ab7/p3+Nv37PO9g55KHV8yzH06iNCiE9YL7SQFkHo15i1lLpDnnkyhU64zZXZ8tkuxWePlXhwkJF2gnEo2ncisVaxUZTEzx+dYooGmOdWXQcwvUQjVCDjWqDtK+g+qp0a66rJkk1TsfgCDvHx5mbmqTaqGEYMVQD1LpKPK4QEVYHwmZDFKyGy5X1ojze3W1tGGGPQtVhcXmNREgjm0zR8FXCoQjFRg0tpRFEoyiKzvW70tz7+KJUAIq+hLDZCITfs+AgyjbFVhCpHxBS0nj1EDVlHVUoTRWNkPFFzs7xJ7481ukr8cC3YdHztaDV8fkKtDo+LwzGr30z6YjH3NRpqqUCvuMQjSqUK2XuOpjhN3/hh7n2e39X/u4nfv016KkUT56+yD3PrpDWw3R1xZlb3eBg2uDYNXtId2VZXiugx2MkjRj3nLrCa195HZfWqjx48gKGr5GIKVSKgrwcglRI+q+s5evYpkfRKqE4IqDSoH+0G8tuYNdsQqEENdeUwaP7do6ymd+kUXWwApu+RAjbCJgv1ggHKlXTJZXUcGrjHN2+lw99+I9foKPVwpeid3gv5XIN2xZeLZLZK78vVLfCBbkrpbOvP87rbuqjty3K8nKeajlgtgp24DLcEeU7D48SDmlNr55QCP2WNgLTAzMKqgeag9IRg5pL0IiLPAzhd4DaMwIU8ZeXQKkQrOcIKkW0PdshvA3vzCUCy5IOuGpXgqBSR2lPog73ocTEDlMhKK/z2oPv4TPza9iPvQv9xusIRPdoM49/dRaltxNNEK4Xp/HiCdQ9bwFBjg+uyvvGW0JZneEHfuFD/M2Ti3zo7Xt48zt/v1kMsYR35jKNap3JK4vE0nG2Hxhh5cI0HcLyZW+vDBrFcwg2cijRJIFro0RCKF1DKPFO/u+f/TXdvf00GiYz5Qpvf9m1rF+6wpWFNckvqpcLsnuxYMVJdA1w/NkLHNzWRbVS422vuZ1HTk3zoY9+jsPHdnH44GEOHh6jur7IydOXUdG5blc3arWIWyxQGruWWmmdD/3fh/npH/surl64wFPHz1NrGyQaUnnq6lVWqiYH+4bZtGpUrWUsx+LW8bt49PxxZq9MkmnfzXfe3MkrbjzI3z90hje/7i7Ky5NcmFvFMT36u8KcWyqSjGVIx2B2ap7AV0klhQBig2p4O5gbJJMqhu9QcqPsHR+HqM70VdFhcunIhFhc3WB5uUg4FUeJ6ays5cm0dVBy6qws1jh8403obomp2XkUNSAcS1BxLbAcanZAVA/JzVOlWGdguI/2tggbm3lCsXb2DfayuLbCqStTZJJp2tsyzC0u44ji3vDZ0T9EX7ab7775Bt73hccplFyWBHnd86UvlOhg27aN5whmkfAcU/BFLJBtk4onpGu+pmhEQwbJeISnHv/8i3pRKf0/Oj4tjk8LLbTQQgsttPCiQWvU1cK/C9rCmziIIEZVtmqFVsduCKEu5OwwVmGe245s5+GTE3zXu77A03/zQ2yul4knNEqOiuI6HJ/PYQx0k5xfZerR07zjh7+Dc/M5TEPn+15/OyulMuZmlYFkF4vFIhXThnAE23WoWjUMP6C/O8Xu4RGevnKOgXgPiUw7hcKU3Jk+U91kNN5B3IRATbE8Z+LYYtdmoCox9FQvj598kqAap2/AYaS3jWKpTHt7hPn8ZOvMeYFw5NpjWI7PxTNNSb/nipZ+gKKostkjAhg11W8aD2oBPWmDe569wm9932Ey8YDSpoOa0Lk+Fqc3orA9Bj1tUVxdJ8gtcfFynX2d29EExydlQyKNEoriXV1Hm1lHGezHTxuyK+AvrouERwKrgeJvEpRN1PEDBPRDQ0EX57DZALGbDKVhVw8U1nAvLqLrLsHO/ZC6gU/PPAMsSk5PQA3YhdJWRL9BdK+SBAyj9HYRPHEWWMZ79LfxpxbRrt+LtnsX9PfygXe/hf96MceuWw5j3f93RO56Bd7xMzi5PFosxDZ7meXTFSrWHF037MKfKUv+ktITJ7AUlI4uUHXY3CQQY69gBmVHgje96Q7QUjxwbh42LvC7f/Mwn3lmkgfe/WZOnb1CLKzQ1rON8sQSh7a1ccPeV/Gnf/0P6IrPqcklwriy05RvqCzn8/SstdGW7mF39zQLeYfPPDPNzcNxhq85ytpKDd3V2DvahmVa1Go16p5KyXK55/gEetQmEQrRn8mgFerMrjjEk+3k7SrZjgTR+BG+cO9T/PoZ+MvPXuQHXn4Tv/x7n+QX3/46+lKr5BWFnBVHqa0Sjph0RdvJh5LYqkrV92lr62GwLcTiUsDaZoXOdJrAiPDpRx9GNUI0IhGuHRzk0M5ONDWgkK8QU1yMVDde1ZQqrI1Fj3xlgxAus4srCD0XWphsIotTWKFgNWR2F3Yg8/5cTcdXfdnldnyfwHN4+uJZFNVg29AosWyE08+epVapk23vxXQCNgpFrLLJ/95YZXjHALlcDVWMuqTNgYxnA7+Z+6aiylBoTQGrvExPNoUqnJwFR9AwXvTdnq8FrVHXV6A16nphcOyWu9msRqkXJ1iYvUQs1o7vu5KHk0kYVCqbfOg3Xs+nPz/Fn/7jKT70njfTm4S//PwEl+YLaDgs5yp0xyL0tEdZ2Cjyrh96LRs+WMUCyUgUy3X41ANn2T7YwyPVGpoIPRVpzaEIlmuLnANMxSEeS1NeFe+h+taMXIT6Bbz0rsNcvLDG/OIS+Aa+p+BannTjlWN0Wa6BEda47oYbOXPpHnzXIhxtQ61nwdeJh8I8+PnPvEBH7cWJXXuPSP6U5/tUTBdNxEE4jmzlC66PiIiwGkUp6RW+OOcnp/ngjx7mjoPbeSpny9dNeGlbNty6q4toOo6SjOFfnUbt0/Evl1AGM2gHulF62ggqCv5kHsNWWJ5fo29bP8Rr2FOTqKNdKJl2UGyU9k6CejtKKoJ65hyIYEcRD2E74DrIuYpZJX9mmXAqQnJnG/7IuAyhJDaEQl6eSP7CMupgFwE3ySIHyeERbXjx9iU4PV0Em+dR27L4sxcJqiao7SznK6i+R+++XVzzkndz/P1v4qYfeD8f/eFb6X/lXgqf+ALHJza58/AIaldIFjfKUBvUTQJblcdAyXSjDu/BX8mj9iQJTFeO5JS2NNf90j/y2i6P6fkNsmGdH/2+uxkyGpw9cZL+9gzx3mHmr5ylEe5ifm6a+5+4ihvLcPTQAcaGOjl3+RJ9PVmenc7RoXukPYeJRoi51TJ/9I7XMbW+QTt1Bnt6iHdG0HyDWtnk1MISP/ve+7l1Zzs/84YbuTy3TG6pSDRUplKuUmWEx5cLNKpFVjfyuEaC1ZkZ1lcFVxCcMvzaf/keBvvb6G4P4VQLTK8UhLics5ML1Bs6Y/3t6JpHpWEyv1Tl4Hgn62WTpeUK4UiUkuNRq/vMreeJ+3F+6ee/n/m5q6zMzeNZm0yulOQIq6u3l0sVi9z6OomuLsKBSyIWxnUCOUqdy+cINBU90PDLdRle7KgqAx0ZIqEALRRhPV+jatfILeTZvmOc7oEO1qYmWV7dJNvTQzoVwzBtLi+u0N6dpHf/Ucwr69Q2GqiBGG2pMkTZdwXTR65ekuivaRrRsM7F000is8Dtd7yMhx68lxc7Sq1RVwsttNBCCy200EITrY7PV6DV8XnhsW37Xqy6SaPRkDv5iObL7JxMLMbv/9yt/NBvPgSBxZ+/426m1orcc26RQrUuiX2pkMFQZ5SaDzcO99PXnSQ/NUPVV7jujmP8zf0XuHPvMDPL09KQcFPK0XUsp0a8f4Cu2CiPP/Aoii8GJiHZzVHwUTWhEBKiIdGKFu1kBc9VpVOz6GS/7GV38bn7Poei6tx63Z2cX3iaMusMt4cIPJXTlwMG02le97Lv5N3v/vl/h6P24sHuvddSKtdo2C6V0jqKlmC0T2FyoUQi2SalwoLYfOeBEUa7orzrB65jeaXAUsGmQw3YP9iOulOMogrg6QSej5pV8HNrkoSspDtQB1JSpIWaRFuoYk/P8eTVORRNZ2QwRRSfzu1DeD0plPZ2gopFsF4gqJZRO1W8szmUzixqr09Qj6ObCvbqJmpfhiuPTLN9rIfQrcN4Zgh12wjoY8AqCh7+6jL+8jLakVuAAUBkQYngMG3rQ3wtst0ESXUJGsv4U1Noie0EQzvAW+Avfukj7OwI+INHF/lf338LnRGfRzaqlKoNhss1Dh3rQj/YS0CYILdBUBRSaZPACqGIDLKuMdThEQJTkHGrEAlDEOIPPvB5njqzgGd5nLciXP7ULzB77wMovkm2vR3bsbjv0YtM5iucmF7n7S8/wsmZAiHHp2rWOLyjk8mii90w+ZE3vpJKfpZcySSbivLk9AbHRjto7+6jZuf5s4/dz037dvO+h84xntL58VcfxVECllY3SYdUXMfGK1SZr0d5cG4Z4TUguoCbQUBubQWUMIpjcerECWqrMDycZNfhI1TX17jh4CBvf8srMDencPQssZjK/PKqsFlms6pRWV8kpFmUai5/+9As+U2Lqelp9JCKoencesvNpGNR0BrU3TyhasDFuVWIQDiZwrZNcuJVciMEvkvDc1BjOr5I1wobKJ4KjkPN8nE8iKoKsVSUbf0DXF1cpFIqEQ9pHN47jum55NbyMhvMj8UoFgoEDZ9G3ebVr7mJsxcq+HXhgWlLwrKYdrkN0YluOs+IrvVKLkckpjHa08+pZx74Rl/C33Roydlb+IZjauLC81/39Y0QeKLVD+/5/R/iB954O598cJpPPXmVH/3d+zhycBtHtnfzhdNT1AORug2rJZfx/g6pYAhnsiyrm+zZ2U/P4CBt2TnSHVmsOR3frGB4CqNJlateiqtPzHCyOoHT8JqFjyIky1sJAE36iBy/ibYxvuD5a3hivAJ87O8/ISWkmm5w/sLTmKpN+1A3qlGiUKiwa7yLjeUG7//Eh+nffQTN94mHNS6d/aKXSwtfGy5deJbxnYfkaEvVEwSaTs0x2DmS5eJKjd0D3ewbSLNtJML/+LU38cHf+QRvfcVBdvZaKP2DKLEI6p49UFlDift402fBFWYnCVAslIgD4QBt4DDe3BJU5lA1H7VU4IbXXg+WeKdKE9x+B6pt4Z2+iDrgQWYFbbwb57OXwKwTLBcIIlGE3bhTbUfd0QuNOrt/4maUjms58+t/wHf+yRd4475hfvNzvwrqOAEdKMki/sQq2o5JSIzI8ZY3eQZ1ZBvo+1HYEFeJMFGQY66gEaDtuZ7qR/6O+NBBUKLctjfNkV/4NPXCJoYYS+1K8J7PXeJ7b9nLoddcg3HnHqBKkCsQbFYxnykR2daNknAJ8mtSaRYUS6g7R1DaUtIgWknfTHHhrxnqzzI5ledQtMHR7/ktXtGu8Gu/9H3kNtaZmlzgthsOsX1tGVUP0dbWwTFf5dyVOWLpGI9emKUrG2Vu3UKNaFTMClQ3WClp2GWbmZkSs0tr/H8ff4DJZYvpNZ1XH+zglj2jIrKVuYVljIbPjONTWN1kcbWIGWhE9BROXCGR7kKtFAk6sqS1FNm2FL0dWc5fncB2fY5fvkxpfY3Hn7jMJx66TE/fNrTqOvv27aQv0uBjD5ygs3uMUxcuM9aXprt/hKdPXAHTo3d3O3t2bWeuuMJDjzxIR2cvG6UNYgNxInaA6gak4ymwXWKZMCnB1spVCCs6Wlonm85il8WB9LBNR7o/a4aCo0A6Gsa2LTaLZdIZEbqqNh2UF9cJqQFrxQZetYIeiHrJxSwXeOWrX8WpM3k8R8e3hEOzYOEqqNLKSpUcHkElkuP6wMXc9ImMhFvLzNeBlqqrhRZaaKGFFlp40aCl6mrhPxSZTEoGgLK+ynv/z6e5bbiD13/HIRYqNcpVV3ZTpudUjmzv4+mZdRxVkUZeBeFm26izo2Gzc1s/2we7uXx1lvaYxpmZSYJ4nN3dSS5cnCNfq3AxH0KrOFTLDVxbJI+yNVaQsogmhBuw78p2dfNbumwFCeXEc7+nqQ4La2tEEmHqcxH0/iJBoJHM2OTO6GwmXZFkiu462I3WPuLrxeSV0/JzW9eYdNjeKNSpaSbb2qLs6Inz0QeO41X+FvQwn55c59JfPswPHu5mrGQ1VUyFdfzpZZQ2A/NcnlNVlcGBQfrrNbTX9aDEhZIqIcNKHa+Isj3NTbe/ESIx2QnBjOCdeYbqkxfZLFsM39VNUKjiB2GUbBsuCTQ9jL8mSMIK6m4FdSiBf7Hc3D+6JQzToeAEfOT0Av+/T38e/XUZccajxA3U/kEwxFZdnCNtILyDqj5kxHiqgsImgRuHRBeKzAkLiH/Xayh/7H0kjx1ldKCHeqHMW196HR/+1BP8yO3fzdF9A1xdyKG/9CUyW8xfWce7UOSZR1Y5XbTYHsS56UAvobY4lBYIFk+j7MpCpBMlIvyKDN71+7/FH/3SL2MPZplbKNBn1lksRjj2Q7/Dx37rbVx3y02omR4OHPlBfvvH7uRDn32UWw6Nc+TYQRqmyX0fm2JxeZ1IJMo7/+cHeeUdh7n/4RmG+rs5O59jb8Li1pv3Mzo0xH96RR9vfdkRSvOzJLs6WV9aJev5LBRr1AqmDPBMp5LSx2tx06QjkiYWj3B2NSedk6NaWPriFOo1XnbtDSybFWquyLMysGsl2Tk8fu4hnAY8euWyHF9T8mBiDUKQnyyQ3Fgn2h3mhkPjDPZ28vSJaRYKVTwUcpV17IZLZtVDTUeJtbdTnM/hWB4DA1nG0lGseJJ6JExRcYmQxPJsaSYoCPim2cAOdDp74qQ1A9P3sXwT34ZgrUCst4ulYpVELIRSbxD1Q4RMD79apae3n5VwB5a5hmd7eMJzyvelMlWMuwREaO/u/Xt44OHHGRscIRaL8pK7Xs6Tj7z4srb+rWgVPi38h+LiRSHfbeL0mQV2vfxdHN4zwg3X9PCpB+akfHNieZMeJ8X2ziQn59YlD2DtSpldQ11cnF/h6MERhraP8+xDZ2hLRUmmIvzJ/c9yaLiT7aODqNisRqpMnduUhl+u6yEimYXFuyho1Gb8teT2BDKOXVJBJGQwoHAKlgQgsXY6BCKOUAlIhYqMbL+LC099lqinEAspNLSQ8FRFcz18y6GtdwfxsE4qEf8nHZlb+OchglrFaEBEVaiKRyhsMNAe4dHzE9hP/yrEBgk2JnjHHTvoiseIBTpK/wD60e0ENRHuaeNPr/PeaZukajM67qP29hGIUadTh8YltH17CYQxoufiXS0ye+Ekccfhjx6bpVw2+e7X38AnTy9y62MXeKCg8PrdbTy20eDmvb3c9NJtBKUEFz5bYs+NYkZh4T6yhH5XFLVjmD2/+SbuTcZIJwz01/0wuGdlIrwoYvSbxShqs6nKcRdxH79A+O1iFCZ8wkWUhUlQyaFmfYJEtlmk6RlSb+zl0l+8nz0vu43DR0apux63X7ePl//nj3L6Yz/Nf/7te/mt1/48NwymWStZfKqg8OvfsY/vONhGzRCBuwWqVoiEKOC6unCfeQxq96C/6vUQul0e9596z++RveUn+IEbMszObjC1WiKlh/nF3/4EH/78LO/8oWv53rsOENmxkyG/wRcuzrJ0/wlZ8BfKZQxVId0eZywSYn5+iVg8zno9YDAVAkMlEY3zs688xp/d8yTX7dlE82IsLm5iFk3ytsK0cFV2VVaqPralkMyopHrbWJ5dJVmxqNcKjHePoEfjLJ9dpFjMY2zbRT6/itdoMNi7jbbRUVKZNCvrSxwZ6GVivYiBS6FWp60jRSPQsOplKU+fXcpTMl1O3vsUlUadWLydaHsKy1bQtSqa42FU62RCYaKpOJGMSlRo9ObW0NUEtYRLfDBFWGngeg30SIhqw5HGBWZgUauoeLqLazskexKsnl/AKldIxAxGDQXb9cg5DoFqUHVsMeAkue8Qc4+ewbMCvIYjOVdiLTQ0V7pyK5qGoSHHtoI3pigau3fv4n/8t59tLSlfB1pb1BZaaKGFFlpo4UWDVsenhW8Yxse3Mzk5wamLs/S3aew/0MW991yks6eN2fUqr909TM2xuTK3StjVsV2F1c0yn7j/NBNLVV51641oUZ0P/f3nhOUG+brNUEeWvnA3bfYiV4PiVm2v/ZMlvsznbXoqbn0WnR3R6QkIVF8aL/qC+Oz42KaKGTF45rGzDB48zLYelacm8wShjHBmlOoTU/xew5LW8nJr38K/CmKkKbo9ogunaZBJaTx84gKedw/4DpRncB98gJFMJ923XIs/NY8SS0PiKEoihyo6Kmo7P5BYw9qssbqyTLedQB3vJ6ibqOltBPSh9i7hPn6SJy+VGcpqdGR1FiyfkqNx00/+KGHtfQz03sjl+87w7tPLDGcNIrkGx+omf/iBKX761i7UUR9tzw4ZZeHnNnA+/yj+zCr7e9sx3nAYcFH0eNOjh0HR6wT5+RLORx+AWhnn4/ehv6F36xwNoWZD+OsVlFgZooMo2joB29n1qhuwSxbv/J6jvOkdH+Gmwzu48+hePnKxzOtffQ1nryzwd4/OMper8dLrt/PZC0uM7zCIKnm2de8gGfUJajkCYQya3Iafn8H52McxvsOC2CH5uL6vY4Pf/okf4g3/31+jGw4bpSqW4/Hddw9j1mv80Z9+nNgXZrjrhl527Bjhta95KdlkiIG2DIODvU1zvqNv462vu4Zrbr2WmBai0ShKq6MEZa596a38zoc/xx/+7ZN8/8uOUKisUivXWSmZbHoqS4UaU3mTeDbKwvw66UQ760s5wqUSiUQYpVxlpbBKKKkzFB2he2AnO2JZVuavkNAaNJyATLYdRTPQ4gly9SU0s0pbexdPnrwss/g000I1wgTxJNQ2cWsW4VCUqBgl6Q5GVKNS8FCTERkl4evCyNJi3fLIJiJksglyVYVIoKCvW8y764QC0edBCja8cIy4akhFYEOtEhYRFksl6vUGsVRMhiFXGg5V28V2xF+ZeIHF/n07uHJhXqSMYNui2+NKFVfg+rJz5DkuhmHgahonHjtHNp7CalikEykOXvdSlMDj9LMPcuDwLZw99UVPnxb+ebQKnxa+YVDVEN29g6ytLLDUqPND33eYyZkyxaIwYHN5/0ee5a6XbWNwsIPZxU1K9Rq9apKIFjA3vcjx9Dk2SmWpsog6JpcXG7hOg+E+n4vncogJl7CIE21hQdxRRaEjVVtNIzCJQIy1vqRKkV96TXmq1vynWKMCx6VuOvgVi6vPLLExmGbj1HG4+810P/Z/WRu/mUCO1QTnx5G/28K/Dr4MYfSkO3M6LlK1F7Z+cg3B8ifxJ89gVTw6R/pQh0dRe9tx7ruP4P4/Rb/pEOh9fO6zH2XFcdjXmaRddVESKkomjdo7SMAOsC8LbTAbVza57/Qao3GFkb3b+NXvuo6RAzvkvVWLVXq+/w5+4fbd9L7zr3nDsVH+6B8v8j8/fJWff0kfxmuHkOmUbAJp/Kt5Sp9+guzPvBJ1/EaC1WnUtDDUu0GeSzC7lTfWDcW/J5hbRz2YxTu+jrrtfrSDXQTlMkqqE++Rh1D6OiE0g9qXQOkLoaR1Qq5NbybFW7/zKJsrdTarNhcfPMfOlwxTWs9z3XgX1+0w2NeX5RWHxyirBu1hQxpyhraNEKQjBMtXUZJD6Hd/F/7caZxPfw7ju28VJh78r7/9cQgfZKES4ZZtUfIbIRJhjZHeBL/89u/kD/7ks9wyaJCfWZEjn2ceOEVI17n/809w45tezcn7H+d1Lz3Kxcslzl96TNpECLftT3/6Ef7Xb74J7eEHmVhaIjUM1fU5rFBAvuaysLLJes0lt7BJNtOF2/DJksBXwvS0t7Pp1mlUbXLrG6w36tKzOB6PsjJxksmVVfKFAp3bdrC+eBXdrpHW4MziPLqqE0RCpNNdpJMzpIe68YpFdM3g4uo6ffEYBRRS7Z0ySFTsd+JilhSOSu5MoChUbAfH9gjHE6TbM2iNKmXVIaIGKKaJX3aoiz+JSB9lMqEQmjBY9Fyy4RDTSxu0Z+K0pRO4nsNasSYHm2KEFbgNenuS3Hzdddx3eoPAUwiEWWUfLE6JTYArj6FvexRrq2TSvWjCgkNyEDV0TedTn/kcqqbJsnlk+/VsFqsMjhySz0UT656mSJPFSxdaI/evRGvU1cI3DFeunCeZSNA/OMyp4yu896/OcM2xIaKxBI7XDKa8/95VUmqcZFrsCjdYWNokFVLoc2ssXJ2AWpGdo9286pp95NbzlBs+J9fmsUwXx5WmPTLtW/r2iHRvyVxWtz5E6uVzhFOR8Kg+3wmSH5L8LL+DJ3xhHQerYlIr1Zg+n4Md14IRYu3WN0M0CtEI5DelZX3dccl2bWdgeA+79lzTOsu+BrieKwuFcFijv0vwXsBd/yAKT+KdfYKgHpB47ZtQujpAqUOyB6WjEyWexZ+v8cfv+ltmVov84HXtHL27nW23D6HubEfpFkRewdKYJ6huEtTrdNy4jV9725289e69MqB05PAgSkTDnzlDNhGi+vQUJ//6C7z1Z19P/Htfxy99+D/RmW1D7Qyj9h9C6X050I43dRX3wSfI/uTLUMdfD3ShdHU2C57G/VB9L95D7956hlcJChG0l4yj7drHylIdf2pNhqf6yxWgB+3269D27kHtiqJkhK/PMMSuw7l4hdW5dd7xA3fywNlpVFUlX7T5i8/N8Ds/+1qO7e6h4gW4usrC6iaNQGFgfEzKp/3NEuVyksBJE5RyBPVN1NFtYIprQRCpVyC8S8rh08V5/vwvHyBnazx0tcCv/NefQR3exsDuAe598GkRtYpZqbOyWmRidp2du3diz69gbW7yt393D5ubFmt5k5W1GnMrda6/+XrueXyF//PUGm+45Sa+466XcsZsZ62cZrEWZapS52yujO0HMh2+aDZYrPvkl/NsOGKDolKo21RtH1tyaHQ2V9aYXl0mqJcZ6UyzvJljbXGasFnEq1XJb64TCYnNjkpD8/A9lY6Odsquwbrl4NoWrsgyT6So1W2iCY2UcPr2VFLtGaqOiar4grMsuTWCnezU69TKForlYtZqFC0LP6KhxXUczScdjZGNGJRrZQr1BnnTkR5RJg6e4lOsNwgZGh2dUWynTlSx2XXtNdxzagPHaYaQ7t7Vz9zF8zTMkJSsazFNdkFj8TYZhWE1bKxGQ3aULachydSNhoNpudRMV7qfF8um9MQqlKuUSlVKZZO9+65vrT9fgVbh00ILLbTQQgstvGjQGnW18A3FxFXBfYCh0XEuPTXB9IUit782xYP3hAjF0iiaz8WrBbJDnQSZFabWVgkbEcYyOj0NhzNza5hGhun1ImFXTLQUltZEpk8cXzoyi5DUQJrjSTQbSVsuhrId9CWPRiYByv9Em1gqv8TGUXSMDBV3s4joScT6hUzZR3MtvHoNKRMTrSFNh+ERFLOG22hQsyzZJXKd54hELfxz2Ln3MBubBXQN2pMhdo228fj7fgKlfQ/uo38pc9HUfXvB3kTtDMn5Y9AooyR6yM8uMHn/Cd7e56C/6hrZfQsWyyidSdk9CegmcBcIKsIO10OJRtB29wkHP3jG5Y7vO4QSCxHUNaYffJb3fOI4L18u0BbT6X30Ct1OgLrvDn74D4bxHv0rICsGoPirs3hPXUK/aRfqzpu3Tq9ZAtum+Ocf5/h6wMjUVbb9xi0ESw/hz+TRbzyIkongXVll6L++FvdzT2F/4FG0w32Si6Z2bJdZXv5GASWIoDBNQIy3/cYned9/fw0PnLjI+PZesqkIa5sWcVdh9I3/h4f/7Af4yFMLnJrdoGR73CRmJqEoyUSUxx89zpEbj/LQvMed1wsejCNMkFEyIi/MgHoRYqLDlufhj/4sSrfgKAmZvoXCGt7EOb7ntu1M7O6Wxg9XT+UZTCVYMRtUGx6oXxzrPvLII1/+uh48Qs1xqTw7z8Frerl84kHGj9zA48dP0N0zQl9bN3ZjDU2NkIwlcewithvgeA0qgUrUdUhEkuLlp1qooAVg2AELy3lUxeLS1Tmu2TZIyNdYcgxixIh3qZimGFMFhBsNxofHmJpaZnU9RyMUEFZ8yg0hYU8w0B1DMRTmZjcJBKfH1zDVECFHCkHl+pGNhmmLh6nUTTrjBqamUXQcDF0lHA0R2rq8xSgqHo8R8l1My6Phu4x3DVOuFfEaOmajgLupc/MN+5hXUzz11AK2GLU7LqoY8XozeLqG5pWEZyJuyUNVxdBKhJM2Fy7xWfIQA1WqTZuBvuAKOw3bxZdd0yY/UdNVVNEFbC0/X4VW4fMfjMNHbqBh2fI998KFk//Rd/9Ni1RCtPWhsy3JvZ/KQyMk6whhgyou7PnzsPPIAMI4frVaoeqGqfs+g2mD5XyRVDJFZ38n6ahBT5BmNScWAIGmK7Oy5cisKoq0gH+e5SOyEKTMXbxpNeXuYt7eHIM1ix4latA76KPHuwlbecIRi5quULxaZKMq5MqaDDSkIaTx4sNvGkGLBccXQYkNOvp2y0BBEXAo/EZa+HI0bBE26jbHXL0JPvipZ3n/x/8S/+zHCWoxynaC5KkpKKyg7tgOkQLB8pIkn7bVa9z4xlEZHOo9NYl7fg1tTw9a/BDu6Vn8mcfQb+lFiXVDJNHMCNVFpEUJYjpKxJDxDXOff5Y/v/cUw21RhmIRbv2e23AeuozSnUDhQvN86OzEu/wg/lWReF5DZKCIwqQZRbEq3HcINpe4Z6nMjj3jjL15FHWkg8afPYZ2uJ2guEQgMkiH21F7d8MddfyFVbRDYtRkSu+ZQGknyD1IYLh4Zy6xcXKBo91R1sww+47s509Gh7jjRz7Isb3D1Eyfu2/ax0cen6G3PYZmORzoTdGRjhIYOiM37GJoRhDwK2ibOZTMKITDEI6jdHcJdghEBZeqIuaKKN3HUIITeOeewp+rQkxD7R/nF958jPfde45HTk7wY6/ax5//wzm6kglKps/l82f+hdNZo1q3ZRFx8sQa4dEsDz50EbVcZXntPA09StUy0ZwwsUYFG5tQNEml7hDCx1UVuYGolCzMYhW70aC7p4+4LvjhNYa64iRjMaYLiwwmkzhelcD38XxhS6FxZX6Zkl1FvIL9nSnmylXpgBwPJdBSMXo6E8yvV6haDUb6O1AEP88OMH0X1VCouz6NaoMVx4VAJxLWcTUVLQjwhRO8FzDS104uv4lpuqTicVbWVyWXaM/uEXb0DdDVfZCpyUlO1evEoknO5XRK80tyqXCFc7znI8IvxH25TqcsVnxX8IbEvkxHE4RtvTmOV8T/VKWZ0C5H8v6Xf0hWYxPClsMwdAzBXWrhy9AadbXQQgsttNBCCy8atAqfbwBEXS4q/V17DjcJt9F2xnccfL6d+WLE+XOnJaF4YXaKoc4e2jIRuWsSBEXPEwa7FnNTLum2OJbuood9pisWpViHVOnMrqzLVnnN9Ugl4wSaipibiF1foClSvPXFrZAwW1WaPw+rqCENPayghVW0kI4S2vobTUFNJ+kf16mrMZaXA2ZKHSzrw5gLddrG4EBmgh6jgdqooDaqKLaJ0KUKYrS4H8e0cRRVKkQKlRrFUvUbfKS/OeF7XlNZEwkx3JfB8x7En/wHLn9+CmVgO6lYCOobaNd3o12fRNvvor+kDf26TvQ7BgnKFv5CmaBYpV6sUX3kKh//6b/C/ev7UDsDgrJCkLdASxD4YYKChRD7qf0JgmIBpbOL4bsO8hu/+j28+3d/mltu3Yva24lx27AMDQ3qqwT1CkrHENN/+ETztkTj6CX7UJJhKJ8gWL9AsHyFiY8+xLrpMHXiEmpfGO/sNEo2hNqZwV8t412YQensw/7QZ2S3UTs4jBKKN3Pk6jVhlUewUUHt7xTyHoorZd7+mj1shrMEsTj3PnqWhU/8OKcml+Ru3mz4XJndJJOKSDuAN/zKj7B3tJti3ZbjOO36W5ne9Lh5QCGoWaD7YFZQB0eBRZkFpoghbk0QrDelnYA/v4mRW8JYXMI7cYL08ABvueMQf/jTb+aXf+Qgs0/8hpSzR0S37F+AyKcKa2F8R6FUsdnMFwhZ8xTLJS7nC7RpEdrCCcqeRbneQA0ZFN0Svq5SMBsU6ia4ljT9WzYtQtEE8WwbIm+26urEYm2cX9vErlqU1gqo4RgmClGljuvkMMINensjHD2yn5e88iUoakM+ls2yLQwE2NWRoL+rjd5sgpCioKsBqqcQNlR0IVX3NWwxMvcDwirYqkbD8Vjf2KRWqxGN6swsLFNr1KlUc1RrRVKxALwa9foGi/U1HipscHy6Rm3aYel0no2rKzhVD8f0perOE0IM0+X8GRe3oOG7ze60UG/JD01D05udH7Em6npIWMrL49vs9Gx1rBVVjsY08fuGRlgYMEbCnD/z5H/AFfythW+ZUddv/uZv8vGPf5zLly8TjUY5duwY73nPe9i5c+fzvyNOgHe961382Z/9GYVCgaNHj/LHf/zH7N27l28WnDr51Jf9WxY71iZTEx5qtgO/IBZUje27Rrh6qWnj/2LD3PRlxsb3ygu+bloy0d2qqSTbHTZrsslLudKQ3hZiRt4eUsltLnC5XEaLqwy3J6hnRgnbedmKFkNuV0rZhTarOeSSDs2GhhaGUDyBq1tk2nxMNYJZCeFP56Q3j7eSZ6kakQuyEQshLHpKV9dQvDTLTzmMHPDIRiexywrlVeneIgMMReETU11Mt1lAiTd2Mcuvei6dveMk4xGmJ89/ow/1Nw0ccXyASETlEw9e5f3KrQTLn2XPj34P+Gsw1oW/oqAk4rj/eAbtliFQDAhrBGt5UWGi7h7Ge2aKxFAKdSDL618fRRkSSqwOSPWgtAvuSgMlUYdIF96ZcwRlE3WoD0UXKe5htNFhAt/BL0yAvYES8gkKddSBQfzVNZRYO0MHtsnUdu2mnTKxPbhwCa8R4cff9X/pzUa4tFFlbKCNVwym5e/5cxXUkQjexDLarhGMlx3Cm5yTaqGgWgA1DF2dBJ6NEtcJ3E20o9fjL29SnLXZ8a434F+a4A9/8zNEA4/d+8f5y48/zavu3svasrg+ApZWyvyfX/4BTjx5Gn92gVf+1Hs5tquXd/zgrTz+B+/nFW95JX4OWRiKcNUgl8Of2UBpfB5tfJDANSEkAi/LKGL0a9mghbBjQqFmonYN071WkH5K6v47OXLkp0hFwk3V07+A0888/vzX+6+/gbMfPSHHjm40QA37xLNxlApMrZUgHcHx6tiOS1xRqVsWSV2llkiQMFQ6a2kOjg3T2ZnlXKNMtquNfM2UsRBGOETNqULQhpscobq2hKa3SX6dkw94fHWWhm1iqA5mIIqNMnuHthPTDAy/ITcmYkQd01Xq+CSFMrNuYxgRfCFhV1Sy8Qglu0F7qoN9fb2sri2wsLoKsT6i7UNEkyo7ghVMPc3mhkdus8R60ZJO3bYd4NmCk+PLyXpzuh6giEm8ULT5PtiB9CkS4aTNukaTo3kxmlMVTUrsm3L2ZtLy8+Mtv/nx3PuJkLgboRBhUXRGQv+u1+23Kr5lOj4PP/wwP/mTP8lTTz3F/fffL/1S7r77bll1P4ff/u3f5vd+7/f4oz/6I44fP05PTw933XUXlYrYybTQQgsttNBCCy92fMt0fD73uc992b//6q/+iq6uLk6cOMGtt94quz1/8Ad/wK/8yq/whje8Qf7OBz7wAbq7u/nwhz/Mj/3Yj/HNiOfalFDELwiCr097R5iJy7MMjuwmEo0wcekULzZMT16Qn7v7tlE1TXTdpZJTCGccEoZGe0cbBh71UgUlGeXaoWHGPY+np6dZL9To67SoFlQCVzTxBeFYGIRt6baEYsvQ0cIKsWGDLoT3RYlgI0DXNwhV+2gItZfoFuk6vuVKsqEIDwwqawTJbkmWVmMwu26Q7Gpj29EymbjK5csmxXkPK+8Lmxe0tgiK4hEonvQMang+bk204R0Gh3ezMHeJFzv2HLyGYrEs/ZZ8ReW7Xr4H75nfQ7vpGnBXUcKCfJxh7W8+T8dogtD3XyvdtIOqQ+DWCUoW/nweraeL8K+8BSUi1EqCcFySHR6xk0ftJBDX2KUrBJszEEqAE2ZzeZPOXVH83CJKOo2/OidHQUGlQLAZlbtvpUOouOKoPf34G5uE3nIr7mOn0XbvAqsMWkPeXTydYb5SwNU1xjvj6OUKSs8AasXDn1uQRH2x4vqLU9J7SDucIijWUfr65e5e+L7I+agbIiit41+wabv71U0ncXeFX3nLLdz3+Dne/ra7+ePf/zteubeP//upS+QbLrv7uxgb6OZeq8Kv/6+Pkwor3Ly3n9RIP8d8nWBjDmwFpVuoupJ4q/Mog72oPZHmi6BnUXRzKzvMAcPHyXSh9qVR0gMQTaEd2cPY7h/lV37xdWzryjC1UkG2TL9GnHvmKQ7dcKMkslc8aOtu4+Rknmg2BladtrBKVcniaB5ew6K7O45u+5JQrGOjo0lTvwsLy6zli/Sk2mUHShFGqH1ZOtM2k46PNzOPr+qceeQJeb/7jx3FtITfjU0iMcBgZ5lLJwsyY8szbcK+z1g2iq7orJXq8j6EEk0PR2RnQIyqc2YF2/MJpePMrC9xaPsRxke7+eBTRdJuGTZzuFWFYtZmYamMXxe5Y0FTdSUyAcV55AdbXqmq7Dg3zVS3JFdyFi9+4qOHddkFEkR3ORGQggzpD/1cv1reluwYyfcQsbaJ2/a3xl06IcMgEgnJY9fCV+Nb9qiUSmJRg7a2Nvl5ZmaG1dVV2QV6DuFwmNtuu40nnnjiny18Gg1hAiVkHk2Uy0LG+R8PYXInFn/LbEi79L0HAy5cXKO3p4vd+67l0vkXpxIok0pKdYLZMLH0OqGEJx2Sbdui4CrUNV+mGwvpcWd7B287ei0feeIJjEYePxHH8JoLg9f0MpSLhSrGGiEVLaIQLpeoeQZ1x0BxGmjZflyzLoskNdAkH0vqQX0RGihmMZ34Qp7edDZEqypU3DDThYpUg4UTBqluA6sWUN0o0z2WYm26TCqt4hCV5m9qUpWLsOv5dPRuk1b2kUj4+YTyFxvChkEsFsFxm4t/sdQgdMMv4Hsfxrv8LP6agRJJMjmzTM8PvZyAO8GoE7ifkwWsunMI7che6XwspOYB4s28OaJRRPGjlvAuCCWWSSnnkNnXw/33XeCGQ4N85tQy37+tF6XLIMgvSnm30p5uhpiemqOeD5F6swgYjRHQAfU5/I159Ff/KAoTuOePo3RE0A8P8fv/6/v5q3d9hIoCT89s8ubxKEoogzqqgzjfRofxZqakGkwJl1GyWdSx3eIISG5PUNlEicTw1zdR0m0QKqF094C9BE6RjnSSH337G2ksb3D66iKjuk7Y0HHdBmsFi+/++b8miHn85+/YK00M9113kMCCZAq02iSu1g9+AX+xhJIKo/ZGIbKDgCo01iAcQ6GAPzNDUFfRbzuI0i4UYOL5t0klnHBM/8I/nmJypULNDpi88q/blJ1+qsk32Xn9DVSXyhhGQD1Upi0i3rwNlEDB8G0ZWVIvVzA9G1NJYfgu+WKRZyctDF0nFlVZKm8yNT/N8LZxgnDAxcUGjrBS9pv2E8/h3BNPM7BrL7bp41s2gwM7UXqPc+bqAr17hriaX6FU8xhK6tQCn5Sq0JbO0JNMMFvIoaMSNAxsR6FcqmLXTfJ1i0tn82QcBcdrjvtWjE5SYZNkr0b53Dq2ZSMykJtpxxq62hxdSUhFlvf8mEo6a6ii7GlK14U0XqwnsvCRgcpiTC8180JD+pzFfNOSQxFRO+KjadYqeF+RcFiuKSefeegFuEK//fAtM+r6yi7Jz//8z3PzzTezb98++T1R9AiIDs+XQvz7uZ/9c9yhdDr9/MfgoMjTaaGFFlpooYUWvh3xLdnx+amf+inOnj3LY4899lU/+0pllCiS/iW11Dvf+U5ZRH1px+cbUfxcvniCnTsPEwrpLMxdJhdJyh2WLnxkvjRL6tsQN998Bw3bkbESTz/55SF7Vy43uyBDY7uIhA2WL9ZpG7LR44I0KI5PnKVCmdVyQL+nU0t6XDc2jBbROU6OsrWTgEW5P5IbMxFLIfJtQgr1vl7aShNoWgTFsQmFfLSISv358eOXQDR4PHEu+UQSIRp1YRYWyKlAiBUaTlQSDRtlYZYobkvBiKfo69PZeSTORq6Cq9rUahGWJgKCgkmQCHBrHpbtYDRsuvp3ogulmUzSaLaxjZDG9MS3Nwn61LNfTvgf6DzE4b6kDPf0zq0RTG9i/NjLOPYzLyVwPFQuETCE2t4vwyGFAR2I8ZZ4gTdRZNdHjGwGCBiTAaFKJo66SyVVXETbO8D1q0Wsmsn3f9cBtCO9+OtVlFCUoAFBoYw62oVn1pgKTPY/MoX+apHj5aF0pFAHOwhEl4YO9OuPbd13FbXX4G3v/XG8J8/y+Ocvo9ZX8U6eQGlPSMKwc8+z+AvLqL0J1P0RlL5uFCNBsLlIUCtD2AIjA7UqRNNMnLvM7qNZMFIo8XZihsID/3Av+VpAxfGZms2RTcRYK6oUazazaz7DXTHmcnVeesMIf/K397Bv+wjhjRKv/bGjMDcFlgFto6jtCYiIKI8quCtQL+CvLeBPz6M7ZUJhF1/1IHyHjOYgeFI4HsqO2MRiiY2KTcj42sdcXwVPwXKCZtcz2kajuIargSlMP0XfIxrGUFXsWiBJxomYQtUVBOGAW/qz1KwKc/kc6a4EqUwn+RWhpkxjCGWWrnLqieaY6zkowkhINF5cjasn5xndM8zVy9N0Z+IUq7Y0Kl2v21imRyYel0GhBa1Gw/Gx6iYxD0Ix4Tel0JaNMpUTIazgiPNFVUgMdRG9/HmsehzHHcJr2PiOyPzb8kkVI6ityBzR6RHjtGYelzAgVGS3R3RumgaF4kvh0+NJYvPzz0Gc4c/dhhhzydtqjsRkvgbidjR0w5D+PWGjRWz+til8fvqnf5pPf/rT0iF0YECYhjUhiMwCorvT2ysSj5tYX1//qi7Ql0KMw8THNwOufEnbeG2pOXJry+zi9Kmn+XbGY489KD/fcEwEJv7TmJ++zM69h4gmosIMgPmZEp1dVbrbU+yO9LFc2iRfKbNe3mRXXz9xDMp1hbHdJaamFYpTBoFjE++JEe800NtSZNYvYVrgqBVCSkBo7wBrT4t0INEIbXJyZMUk5vHPOacCdk1YRIt/BKhKmFBGE/5w2EULLd4smhJ9Bo26wvKKyY1jaWoRj1LOI9kRZuzaOk4pycqlGl7IIJxwaNRDWGZ9S8a6xf0SLrWGSkf3NnRdl7N7VchtVU1+f+rqv2Qc962JPXv3Uas1OCWzqwYxXn6weazdBvqRnfgLizif/Fv0O19CIPLR7CqBIVyTRR6ajYLgAoo/8FAQb35CLVYiaFRQwkm067ej6B7tfSlym5Z0WRYSdyUeIaiWpH2C4AUFm3XJ9ZnbKHHh7CSjH3+Cm973bojeKCXgiiy+xgnYuVVwia5yFUVIlEJVbv7+YwRra5Ir5OcEv6ZGsCmKNDGGC0tXaYxbCSgTFJ6REnss4QJuonRnCWrrjHYYeOdPElidrDtJeo+MsLN7hstPL/HWO/fR19PGR44v0W85NFyfquWylKvzjj98mD/++aPs6o1z7a5hPvIPT/HaQJeKOPE8FWHZEE0TuFP4M1P4E8soHV2gRyAxgCsK+lQZrWdcpsbDBt7xi4Ru/M/cdus1TM0Ld2WfcPjrt99wnQDfcXGVgLptkAiHiOoRKlRIOCq665J3G6RDEcJtMaxahWw2JTcCc/UyViFH/0AnqmEwfd6htyPK6Se/eiMscP2Nt1Cu1CQHxrQtbM9h7oIqR2JdmRgX5wp0dcZZXNggEdFp64hTr9RYyVfRowaRWJzcZpGsH5W3Ew+lMTSh0BKbHzFaCwh1JPDakgRGH4UZU/IBFU+sD4JzIzavW4P2IJBqUd8Vlhduc9SFRiBkXiIYOemi+u1gm1/kf24tCppUdAmFV7PY0sVoTHAG5b5MmBqKPV1T0i7oAU3Tw28NXHvj7XIA9eyTD3DjzS/jycfu/Xe9v2+ZwkecBKLo+cQnPsFDDz3E6KjwoPgixL9F8SMUX4cPC9kqMsxNqMGE7P1bFd/uRc+X4qknvtzu/itx5cIXOTC7Dx3k8plplucKjO905UIQ0yMYXoRGzWKgJ8Hmeh49rDG+M0nPkEKt7BJN6TTqZYJaiSCiU7L8pnxWC1DiHYSMRVxHkVwDuexsyUfFQiIhB+nNGb2AU6vQsTOBOqBTnolRL9bl/L2x4aFFk6zN5fjkkkvPjgirZ8XfFJs8o4iHqov3Go9ku07BsaltCisDDz0UkvJ78XYqeC+CHSTuXy6gQoavqHJX2zu0W+4AhW+HkMefP/fNk8J8/Y23SQL3yWefYN/B6+QO9+K5E//Pv3OFU67l8o43X4t/9i/QusRWOyNasZA7gbpQQ7n7TpSYKDqiYOxF8U5C8BSBfj0BL9t6sxbJ6RMgxMm5dUhmQNEJ1l24JBLaQ4Q8CyXZRlDcwF+RNrqy2NG9DYrHZ7Btj750ioVanBvevH9ruewmkLcvCM9b8m+ekc7HgnsW1DSUbAptZAeeXwfTRe0cxr8yi9KtocTSEIugpMXtlFC4jG+Z+KsW2oG9BOs51KFhlPASxj6TYCMPqs2zTx5npLzO3vEevru7nytz63z4sycY2dbPa79rH3/w4bPM5aqU6g47+zv53FMlDg27XLxwkeNTKwSbGxCLQiwsyd7usw8SiGiXWDvq2DUoXb0oiZT0oJIf8czW8y0QFM/KoufO248ys7SJ2XAxdEMSaL8eHLz+Zio10SoRcu6AuYUqWWOTrkoBXY+ixA1U4fZs1sk7PoNJZMHRkYwKYT2XF2ZIRaDTS1HO+XS2qZx+4p8uegSe+YoucrZ/hBh1KiUdT3VIJEMkYhEqNYtwOkPVqqP6PhEjQlsqTEIN85LeXmzF40I4z9RMATM4Syq9Fy+3gesGrD10EdMZJxIUmyII0R2WHZjnig/RblKb3R5RMLm27BBLp3gtQNN8km02oR2gVqqUpnRcW5OcHVHgSC8fRZVxFb74O2ksLwjxYl/my3q92S360kyebx3U6458xPuvvUNyXXfuOUo4BGdPP/3iLnyElF2osz71qU+RTCaf5+0IXo7w9REv+s/93M/xG7/xG2zfvl1+iK9jsRhvfetbv9EPv4UWWmihhRZa+CbAt0zh8973vld+vv120RL7cln7D/7gD8qvf/EXfxHTNPmJn/iJ5w0M77vvPlkotfDthUunm2Oe3SNjXJleJJpp0NXuS/Vyzqriu1X2Z9Kcn12V3ZFKySRwfRK2Qq3hSOOwsBaiW3RbKjaBb1E6X5Q7NQFhaKcKKZh0GhNBgc0Z+vPmYWI3J9rK4Qj5SbHbEuoMp6nAEB0f00exy4RjITQ1oLxoEc4KhZiYyytytu974BY81ku+lK+qukznafLShIojHEbxFVxxu46PJjs+Iq9HZPqIjqbTbG8LXtCWyuybBj64nseuvUeo1OosLs0zNLobXZhG6jqGpnLx3Fdn1YnnHvgev/t/n+V3fvEIXLHAn4GyTy5nEunsIXn5DNSfQtl1UNxJs5NxfholdBquvQnoA1/kvTVgs4TaPgrFZbBXUPbsgBM5RLJkekeyGTArjnpvBCIiAEqDKwucXfFZOr/KkZdmGBjpRbtRmKCKo90OQt0lcRWFKWCpmdVljKK2iVGYEP39A2pfEiUiVKd9eE9O89nPnODIthF6b+yDsV2y2xOYC3LMpIYsybvxK+tgBPiT67gfPYG6rxMlW+BVt0b4vY9foFHdzoHuMBcuzyMGo9Nza3zvK/bQ0R5js2qx3nAo1BxW82XY3c9MqcDOvixzx5cZefk4NOp4FydROjqhp0uOW/tGk1KW7y0uy+BSJRxCFcaFly9y/P5HeOPvPsCNNxxhZrmEaYlRq040HObS+a/PZkOMYCJi3CYUl3h0+yXcIIJZN8mkNEJRnfObK6ghFd9x0LUQRiKG1/AJNUzGBrqoVXso5erCm0Kqrr5WDO84QLlaab7ssTibDRclrLO/o53iQJViwxRG0XR3JOhJJlmr1GhLhOlNxZgr1NjZliSh60wW6nj+ApFIH9VaXqjqCXslXNfDd5priC5mUuJSEMuIWEd8D++5jo9YW5pMHVCF3QWYtkPcjhON2tixMRxxbgjnZjG6EtweTSZ1SSd7eY41z1zZ7ZZrgxiryXNPHFjBhdv6xW9yHDhyO/W6KTMUbSeQnCrRGXMcnUOHj3H61JfztV4IKMEXjWRa2CI3iy5SC9862H3oEJfPTIEeQmsPSI74KNUKL+kf48rGJnRlsTZdfKtKX3cXlXyZ+WqdmqMxvq1NLoKLc6sU69uIqrmmXF2uS+JNOJALly88NQJ1yz+jGZwqCxThCdSk+0hCsicLkCYx+bmIDPkr6lY4qvTbaF5y3nM+HqJFLbxaxM/kYilkrcLJ1Sc9lKGaM+XPRPkl5vfP/W3zfn1ZTLRlkyx+k3oCDWzbQ8M0KRTytLd1Uiys0dnVTzgUkm+g579kBDa2fQfZsMe5usPj/+UgCSNGPKowONIGG2VKvkZ+pUpvTCfWFQGrAUqI6WKYsXQAwyG4UIKhQaxcnRnTZfdoGvJXcHMV9LExFubzbBbq0klbj8UZGsqQFO7O7cnmKHNuCbJJKgs+yYOdBD3dKHEx+jyCwlUCbgCWUVgmEEUWggsjXhfxRiMiScQIaAqFSYLCPErFASUCORFqWscfiKD2DhGU1vCncihdHfJ8U4d2EjQKBOtV/KUFsFxqp1dIH3Cx17Lcc6XIapDl0Eg7iTaVRKAwtV5ho7jCJp38wyNTzOcb0gW4Ix3iwvw6f/pTR+gOR7m44vHD33ENgr0tvHmCik3tchFFt4j29qEdPESQX5ahmBc+/Qj7/9MHoVHgO191K2uFGnPrTaNYUfSI0WosHObsCzSGHztwGC1UpieloBoJsnGDQm2TUChEWyrOetmTA+Ko0aBa9bGsEGrdQA3Evl0lpGmcfuafH3V9KQa3H6BSrRKoLkP7HA52Z4hGMqTjGVKZBH97/9NUKhbDQ51kQ2GeurTEtdu7ub4ny9VShdVchR3dbZxZKzFRzJENZTDrWeqlsjDi3ipqAjly0sRYestnp8nxEQuJK0fAz4+5xDMwFBqWQdd4g/ZhjdK6ibZ+gLKVQxe8PqHtl3L3Zp/CF9wg4dkjSpsgkM72MuZiSwYfDhukklGunPuia/Y3E26+7W4ee/g+brr91XLzJkaMwsZFFDsConkh1sxQWGNusrnBvfGmO3jy8SYX9Gu1u0mlhOjgn8a3DvuphRZaaKGFFlpo4cUy6mqhhX8Ol05vkZ4d2NF7gEtPn4Nwmr9fXgTLg/MK3QMxchsBZW2NiA8pTcFRPVbXi9Ix1zKixPQCKA6O5ZPsDMkRmRgx2VaKRt2Soymh1JCjLk8QCv0tJ9atHYRoRwfPyVKbe4rnnQi2JlHyb+SubavzI3eCskEtuz9ykiZ3cyLCyUDTQzJYURgmytsUytWv6tEKpcc3b8CtsGRwFI1MpjkiEjtTETnT3AUrbN97CMX3aQili9cgFNL47zcN06h62IL83dHOzIpDdzaNYZtEEzHcZJz1uoNTc9BtCzOkMl116Zt2iAwMs1a0OL5ZJKg5BGvzDI6143WkqC7WiSUM6vUQ2Z4eunpj1Cp1nPUljHKUiTxsH++GVJTk9RmIqATloiS+S8K0Ow/6kOzqNKXyortTkGaJcjlVrkIgiNAi42saRYuDLUYPOohA3bCDqnswu4h7dg1CIYzCFVw9DZE4atcg7tnjENYx2iOkhflh1We17hBrT5MoNJhcWaHfVugZ7mW0O8r0nEmys8HTqw4HO8KUao4k3PYOjhMYqjT7vH5bO0oiihJJgFBjWRqxDg/X16nOzJJJJFEyMbziCvvf9ke85s7rWMxXeebiKg3XQzdCLE5dfMHPjT3X3EjNNMmVFLxgg52dMVTPoidscLbQoDedlGaS2/u7efriEvPnVxgfGeTymS92CW+8+bav+f6EA7skB/sKTpBlUY2QnzDRjAaOt0zZqbG0WmFHfw86AQcGk3TGdDIxg3AZ+jNJ6sJk1vGINFxm11cZHBfd2DaqmyV8V/Z4mte2/O+LvQXxPaGYe040IT/JTo5Ctsdh/952qTArT2zDSKzKDo+45sV47HmuspyYbY2wtKaPqvixcHZujrm2MrzEYvVNhKPH7uDpJ5odG0tcD0DNbOCJ4+F7z4lm5XkrILpc4vnv2neDNKycXfxiNNULgVbh08K3FS6eOtv8wipCM0CbnQf7pTt3d7vByskCHYegXXPoJ4KlqQT4hGIByYEAxVVxSi6hjErNblBY3aS/zSff1Ul1wcK3BXlFFCZyhRHm81uzd8HN8aVNkAwX/GKt87yUVZWt3K2vtwRizQJJkUrW569+6cvR/Gvx5q+I4iew5aom1lPfV7aGYU2ll/DsCIW+PoXNvzeOHruVSs2UY7rZ2Um6+zro7R2Skl6hDJq6eo7dB47I9G0xohEJ2M9O5PjQL9zAZ89Osu5Z3OQbFEsWCg43727nY2fmyeo6I/1pFlaqdOhhRvo07MDjE6eWecv3jXPsN/+GN/bE+OGje7CCCLW6TSimkcrEiYZs2rNZ6B6AgR7iyzNgLUGqjWc+fR+1wji7dw0TjgujFhc1KwJmA5SICZEYpFear4ckMq2DGidwPRS7TpC4CUVxYPMxWG40FWmmTn5xmURUI9KZxb+8JM8bo7cTgiqfee8sr/rBa+Uoz8tfxnBsyPTAxFTznEi28TvnNglv5tje087Dk6u86XAPfzdZkPEGG7UaC1PH+T8/fDe/8r6H2dnXRc106IpXWVx3+MgDV3nlLddSLlgc29uNtncfWt2Cvg70uEEkneSZR57ire+5h+npNW47eoDz85tUao6YtskRXmck+u9yfog3PsfxiRsaa1WIGCV297eDG5ANQXc8jW1tELNNIpbPQG938/r4Ejz52MP/7O0fvvYmOQo6f0Yo75Bfi6BQISJfu1Rlc8ZGC4WaTs+ahxMTmSKCJ1Wjv6ODdKgTXfGYKZj0hOPkBAFIUbGlFF2hIyaUnEUybVAvNRWfYtQlCvnnFFbCm0tA1i9bBVGz5hfO8AIKlQ0f19CkUtGINK9u8S9fbKKeH68Lt2dfXjuSb0iTJyi+3/QIErflS/6QKMy+Xuw9dBTbcqXS7dTJf/u47OC1t1CtN9MRrr/pLmzHY+/h27AsS8r9dU1BDWmSrhcEYownxnYBM1dPsPfQLZLj1NFl0N11J7quEA3rPPrQv03u3hp1tdBCCy200EILLxq0Oj4tfNvjypkmQW7XgcNE9oSZOb2KeiBCps0gLvJwBKm94GCuW2QiMTxXpRHo1GwX04tTU2q0J4apq440GhO5OELtJbs8kre85a4dqM/rv5q+HVsE5Oc3qE1FlvhLeTuC16w+FzooVGKi06PiiR2e3JL4OJUqeltERCzJZlFTdNbcTco+k6YSCYeY/CY1M3z6S7yZjlx3IyePN7Oa9h+6VmYXCVw621R3DW/fKwmOiajO1WKZ4cFBKlc3+cQTV1jdMOkKR3nq9DJX3SpRH7rnVrmcszjW38aFBZHx5KNmVXJLK8xML/CSI0cgZEj1kOmpNAp1jKiHWQ1ouBXaFtdIbAyDHkD/OHT2sr3rKY6fvMKuPf3YqkcoIQzqNIKpPIq3CO0dKIe3gdINy2JU1Qtrl1FiWZFmilKdhskTVDcqlLwwnYN1zGqFx04usntXJylHo1G1uTK1ycvuSGAtF+k7NASdPVApoOTWIJWgrkaJZRTqJYulzRinri4RC6osmjabNZM/fGQa3XHp7DIIKR5Zx6Nm1zj9/l/mDz/09zx7sUQQOOihDjbcc6QiBquOxx/dd46bZkpcc8t+gkKFH/nFj/HXH32M737ljQx3dpAIx5lcrVBrNDsHUm0oM6Car9ULDeHvJIi5MoTT7qWUyJOv1+jV4DtGY2xGPCo2VHRB4BVXnIqhfu3dzarZoF636BvZh+d7sssgxqyiq2CJ6FPHldegogtitY9mKsTSUfrbU5R9jUfOTNIW0dk93EWlXGOj7kgae8VqujxXnQbD6STF4oY03FTVGpoSPJc5+nwXpvn/orcsuhlboy5JgG6OuSNJncvP1Bi9LsPJmQ1UrYFmCgdmV3aIxBojIHIcpYO86Cw5Po5wfpb/FkdGiCuEItSl0VDYvud6Ji42O13/Eq4/ehuu53Ly2WZ3x6w52K77ggWcNiwH2wvYc+gW6Y11+vgDzU6OGASqAedPftFnaXj8WtmR87YUcRdOP8p/eff7+PynPyJn/GJtdL961v+vRqvwaeFFg8tnvyi/7TQOcuGhGWlYlx4K09FryAR106nih3RpRhdWVTIitVkzmd7sJKwWm+nuW7chDMWkkZgoQsSFKn8gvpYR8PLCFjJ38Z4hFV3ixzIl/jkhqiiEmj8Qagzpvbr1/iKV9Iq4yC2oCWWHQjgUoW7akkPULLYUDE37ph1zfSWeK3oEzp3+6tBdwXWwXejrSvHfPnSC775uB1fWS1j1GinFZ8mqs7Fq0hnXWPEd1nIWjUZAx84Ium8zX3W5dXgYU9F55227SQYKFzZqpByLUixCXFeINMBWQ0StEiHhnlzLkS/arB2fYuSa/VTCcY4e65IWBwl0HMFHMi2smkjNDtPeX4Ozxzl3rsDB7/9dFu//78Q8n8zurqbx38JVSkWbDVtwSEwia+usrm+QjXksTS+w4NuEwiE++NgCo/0xBuKgJ3Q2L81Qr1W4mrNJ62UO7qiAUqNUKBCJptiRjZJs6CxaNXTNxvYVDMejkjclF+3YrkEqm8v8/t/ej226zCwts3e0h9NXLDLZOMvVOj2pKL5vcN/ldX7ug3/FU4+e5jvuvo6jRw5wfHIDq+FJB2hHnHxiHKM23YBlsWH8+xQ+4nqQppy+RjJs4zgBl2YLxEfbeXqtxHXDaQLHIZxKMHmxyLYdnVz8J86dfw6O7UnlkHizFEW1KyTlno2qGEJg1eTTifdYJ0AVhuxeBE8rsNmokopk2dWTIByOy6LRd2yqtomv6SiRgPbOOFlFoSsZIxJEqCpRSjlL7F0kV09c3c0dzNbaIExJ5ZrRLGLkqFr8TNhbOD6bJRP1XAB6g0y3Si0MbsmRQafalqz9+TB3oTaVqtMmL1AMx+RS4nu4+FiiSPA8RsaPkEpGOPsvSML9wJfco4NHbuLsqSlmJq+ybcdOzp15YVR7slhpuJjiMQmT0K2CZu/hW75q6CQsMBzHlUL/vuGDRCNhPvvRD3DxdHOced1NL/8SU8ivH61RVwsttNBCCy208KJBq+PTwosS55/dGg05kAn1M/X4LBg60X6VgWGViBLBclRC0TCK4aEVKlteO1u74a1WtUDTe6fZym4Ov5okR9GxEbtx0ZUR2zIZTCitPHwcYWS41S16TtwlSdBypy2Ijc2dsGpEmh4d4vZCIspJ/N1WZo8gBerN+IpvB4jjIHaeVdenVtngj5+4KhtgIfE8BfvbMNAiCp4QT1kqyURYjgQub9RRFYe2ZBzFVHni6Uk6nDiXTYOnZ5bpzRiYXpE7h9IMDfdhFU2mVxuE2rux5iosbzRIhRUeevIivtXg2QkHrpbZM9aJld+gPZNlcNcwZ6bX2JWb41NX6hzavZNXvWwHAz/y67zzrjv4+e9NUV3P8aePnqc/KpRXeY7uGuXAUBurRQvFtJjesPDxSIQVNq0GJdMlbNsU1lw01yQV8mGjyFikxsXTCZIhBc8P07ALXDcQ59xUgZl6WerIQrYhc6fKVp0jPUMEdZt1tUpcr3Hico5dvRkmlzepqxa//Orr2b5zJ2/+1b9nb28KqxEQ8gKuObyXSwtFGpaNLcZasoPQPAd1TWO0L8PM8qZsMlw6+/+OG/nX4oab7pCjKIIQDVeRYxyNGI5akuThjVrAEUen5gRkwhoYIpT4X9d5Eh0d8fhlw8UXiiIHPaZAQ7piNcM9tyJoBPlYKKj0SJzFtSLrUzHGOm1iqhDcRbBKKulwmGgiwVxuA8UQqiuDSChGqb6BrznN61h2f7cib55TXG4FlQaauN/mua6IMZVoD4mHsTUWD2Uc3Csaa3loH4K65jXJ2J6L4hlbcTXifhUU8ZpJY8Ot5yq7Ws0Okgh/bZKhAyKhf/mYPfvMl0d6CGTSMV4oCPK6CKEO3Aa2rTO64xpJXL5w6lG27TnG+L5b5HjQsR2qNVOuk47tbxHfXSKez66DtxCNROWa9xxZ/N+CVuHTwjcFjlx3E1XTRle+tkynFxKJcILhnWPYjs3K9DqFaIiBPRox8YbgeER7swRzTTdUuYQqW2MuiS/Om6UcXfuicZkoSiJhjaM7MnSPtPO5R2YIHPGGVUWxPBxB2BELpJzhi3n3lsx9q5gS7W01EsOt1+VCJ8YtwqVV3pcofGRYqUH4BZrFfyNx4NobKJer0lpAHOW+bdswV9ao+yHKlkM2HCWs+pieR8EN0FRYL9dIRUIUhaLKbCZdP3A5h+VbVEsWo+EwnuajBdCdTFLyQyyV65QqHg9cLXCiYnDv4xO8ZFeGXV1xqq7HiumT0kJsH8lwZjZH0lBxbZiZWuCe8wu87egQPZ0wvTiHYSn88h3H2DvWyWcfepil9QqlaonVeZtoKEKp0OADZ85jNxzGelN4RkAyluAfH5vgh17WzP56Zq5AZ+ATV5OUa3UGMy7TVownV20+OVmnNx6ioRU42j/CmreIWhVjEVEEeriDSbKxDOmyxucn8zQSUV67f4ieVIhatc6Noymu5nw++sgSxXtmaQuFmV6uSu6OjJxTFCJaQDIVQpiGP31uiqGRYeqmEBwp3Ha4jTMTs3Rkn3OqfmHx1FcY0g3uOsjykkW616XqgBaL8uRiCSeqsrhQZXw887xNxNeCI9ffSqFUJaTrkhcjahxf91G1MOIEkkWexNZISvFpGHG6si6KY2NYOhdPx0gNu8TLq0SVKCNtadSIzqCXkJlluY06q0FAvpJDMUT+WvO4iou56djctGwQnEBRhDTLni0DUpkHKNaAgEbDIqjpaGPtdPT65FbqREMKfqdF+apwZhfDLE8m1gt7COHo7AQiV635DKRf/JYBoMjwkkpRv2m28K85Zv9SMfS14mWveDX33vOP8uv9h29mY7MqC06hQnM1D7uh0Dt4QD7GarkmR4PimAmLEKsh1JLNdVA41suNpjCNkInzPiE0Hv78P/Bvxbf+itnCtwVMy8asNQM+t+85zMTFr88O/+vB+dNfLLR6R7exeqmEotWJKyGMpIpthUiEczi2KuWlktfzJeGDsmsjuj1iNxJSROOI/IKDeDe5/tZ2Du+K8ncLOumMzlvuHuPX3ncFQ9MJ6TU5/1YFz2GL6CeWt0AucuL7IsFaOMK66NHYFh+iaUvPVhKzICBevvDV0Q/fajA0g0gkLO0EhNn+yoyNMT6KsTCHbQfEExHypklEcBg08ebvkg0b9KUTzBaqkiNScktEdA1LbHpFV6NUo6L6TJRMyDdYa4vRni+zWGrw6MU8exSdUCzM2TUbUw/hWSbzgtSpKJwtNRjsUNAVjfNF0SVQGUnrnJ3alK7P95+Yw/U0/uHzz/AXjz7Bm/eOUg8lSMWh6Blk0Ln3qUlM12epWOOJxRwH+1IcHOripv1dNETwbUUUdg49g8KduEomGrCcc/j9RZ/Lk2u0h1V62zLUTDg9v0zR8xjoTDO1XKXh2/T4UUqbJWYbcTozEU6JBPFYmKOHtrO8uMJ9x6e4tFjiJUfGpbxZSKzjYZWIppMU3jRxg7/5jOBxxPn9n7qeP/ulW3nbbz3OqiAbo/Cxh1cY7huUBNzl/4BzQFF02rMR7EYnV+ZW2Dnci5lWSEQMTh0vk41FpGv014qTzzzC/kPNCBHFdqV/jCEKEbtZODTR9L95ritETSTdhwgcsYEpkMoG6PWAtaKC7y1z3e4eUT1RL9VpuDoNzaFYq7BzrI8rV/Rmx1ZUP4HYmIjnJOImmu2m57y+RFdGRHVIUfpWFIWIz9EiOhtzVYJwg/79YdzNEEHSxxB5uBsaaiC6HbqMfJFcQrkP2/IFkutG86tmsdCUiYvfv3ThPzbo+t6tokdAdHqEhYDru01vIxneKriPTWsP2aUSnMUtoYMgnotjJLuPolsnN4aBtAgQz3HLKP/fjG+PHnkLLbTQQgsttNDC14BWx6eFbwoYukoopDdZ/a7P7gPX/LvwCv6fj0ML0y5cns+bJG82CCej5Go1Uv4oJX2BwNOluVhTktrMyxEqA7HH0lQxioowukfBaF9hMBsiV5rjM1NpulI+A+M6J05N0Lu9gWoETN/nEQ4LV2OXTHdTmaU7YWzqcsZtiwDFkI0RD6MJdZG4D5nn1dyviFBTYV747YATT3+xtb794EEsz8W7WsRu6yHtLlDBxlMED0UhGhPdnyrRiIKrKFIqmwipqLpGYOgkGyY1IV12wwQNV3K31ksmxXqN/miEcDTErvEOZnNltg2n2VhrcGWzTk9HmC5TvB4hnp7NowZxtLBGoVQjpOlEwj7bR3p45MKqDFPct7OTfUe7+K17n+bKYpnkcIiLV0uYpsIqIeq+xfC2NvKOi+e6XFouoAY2mquSbPiUUhG602nmajC3ILKpfKZnTOJBwM6USrsWRvM1lsoW8YhKpKqQb1TI1Sq0pcOsbdYI6mUinSl5bqzXiqxVqpyazhNPhLhjVzv3/s/vovfN7+Mtx7bxl5+5QndnHEdP8rs/eYAbRjv5vZ++hY7+NoiEWb6SIy26DoJDompMXzn3H/b677/uNorlOgQGgZ0gnK0z0tdNZzrMimURb3dQHJ3zJ576V93uudNNJeHg9sMyS6uptfrqMbWAcGXXIw6a6mLVk3iej+f4csIdDzK0be9gvV5DNKaFHd++3TuYXb5Kva6xnOvGs9ea0/Atrl5zUfjiPTUNR5/ryIhxoipHtuFug/pm0w5D9IFU3SU2GqeQtwhsHycXkTw32R0SI+7nOyJf+vi33N+f80CVPxP39411dPefV7A+15kSXEev6V6/xUsS6+hzvye6QuI5NrthzbW1GdL6wj6ub49Vs4VveXxp4OGeg9ejKj7XXH8TsWiYRx9+4D/scYjQTNsWK+Qmlvjs+AyldBZLMyieiuoKWWmTXCwMTqTMdCtsUDd8whGX9phPYqCLSqmKZdlklCyzp/NMp4sc6+7nup4enp6bZP/1IdSMRlF3qE8peE4CI1sgEncIuzpGPkE4o7O5LtZPH2ne7DXdopuF1pb3z7cZ4tEYiiUiBCDI1ymoCTrCAWlXY8N18eo2RQcilseUalG0GtRtj+G2pHS7ras69ZBCVA1wRZvcUag4Dh0RTbbcq2WHIBamO4hSq/lEIxpXCgXGR9IopSp53WdoMMVKrkFbXGF3b5q5Uk2OP2KaTbZDJ9HbRmdcwVU1XrV/F2enahTLVXImhAODqu6iJRVOz67Ro2XQ4gq+FfDMVIX2RJhGaR0Dn4alYCRCrBXK7OmKsVFxJRdFnFUOJquWx4ZnkaiCq8XI23XJ2/ADlagRImzEMRIKbWmDbN7gYj7P3Xu6OHZkmIpp8dDMIuc+8p/I5Wq84+230JMKE0+n0BOCSQsU6xAzwAjz/2fvP6DsOrP7TvR38rm5ckTOkQBIgCQABjCnDkotWbLk0XuS15P9PE7yrFmyl59sz7O1nm1ZM/aM5ZHHlj2jsWRLrQ7qSDabCYwAMwkQAJFRhcp18z35vLW/UwCIJtlNspm6+/65LlG5bt0Tvv3t/Q+/9r8+vOQzIwX1x2uRoJZp4a/II+9hu/088vwrrBweond8Ga5uEf8Qp7ry1lFk4iwwWJBdRVlBomThOkR12YzYzM/q5EqyEGdSdMOG6rkCz062WLPOInY16s0LHKmNU6nPEbYloT3zmVHDaBEzyHgry6fI3JWF+6e4eVnhIt5flmFLrUfsy2su5B+N6nEdJ+9hDbo0L1o4Vkoc2hhWJmEX52a5D4hcXf2qS87wunGZeyhflyy9vXnbjeRzNs8fuuKp9XHgxpvuoloV+wVDCTxk06KcpeX1l8BnsRdY8ihS00Ep5tR9LSuAlNhf7rVLJPWsYPxwoji6o64uuuiiiy666OInBt2OTxefOhxZytX5JHDs9RdZv+Ua9FXjTD43D6WY4ZXiIDZLwCCmm1dJXCsHNnPOO0peK6gAU9lCNGo5zMEqk75GyYxopyZR3uLF+Tlmz7VZtdvkO6enWLk+wtQTgqiNHuUoOg75lTA5N82alQMUDZOTsy1mBnwiI2Lbxn5OXehkO9JQdqdZ50eyrn5UzAvfD156JhtPbN55HZ0gM5abPRcx3N/BxiXqQMGExSiiFEVYiUEzjKgGPo4yujWoBiENP8RKE3pti3rgM54vMtdM8eKQWGwGcGg1AnpKJhvK/ZyaaGN5ISOjJTpGyIlaSL3ZoTkVs7w3x5kZn+dPzNBXcOksplyMQ45PtkkTk23LBjhaX2CgZBN2EvK5CC+MsSODSPeVqsXWHRzHwTc0SrpFI/DIaSaG7zNaMDg7s6hGI5ZbIrFiFuoejp6nZEOr5dGUEYCpU8ob5HJ52p0WXhiwuNjh4kKDvlIPgR/zxJlTfPv4US4uNujVLf7JL6csswKaL11kWroeG9bTYxj04mNX8kSNRcxrr+fbD59n99Z+9dobH4Jk+P3AtXQS18ILEqI0otMWF+KYFcsH+IvjMeNxjGZFrNmxAzO1cE2bUt7hyYNXK8O+H/Q0xXmL67Mapyx1FFRWnrRnNIe41aHn+nVEpy6iHDWlOyOu7G6bUs4SwT29g2VqnQI9jXlCP8scy2wpMkd1IR2rjsVSCHHW8ZEuT0alzvL9EtyRkPpEiv0WCXx51MZ1IhanY1rnNPrXhsSBS+RFyH9iwaE6OtKlWhp/CYRIbZjyu7IQZcOU46hz9LVnuG7PLWhanjQVAclHjwN3f55HH/yKenvtxj2KaJ0RucU2IEU4zF7gKy9r9dxVbtul71bqkcs/S8wno1CMJyOeeuzRD+X5dQufLrr4Hpw4kgWdLlu3hSD0mH7NY/iGXnp7msQSSFm1qRWPUizrWOYiab2XhWN1Nuw3KDp5ppsR8/UGbmIRBzH9m4oMynXcitGGdLywkykWDI2VuQLt2Gc2jNXNYaycJ16I2FXs51ShyZGpWUZWGfT1L+PQqxfRA5MoTNQNWYqeIy8f+rE9fkdfep7123apxGZVKCY2OTei4WUhsYZu0mcaFC2DIwtt6klCLpU4AQ8tsZT9QExAJzDpKzhMzXXUiEh4QGkzpBMEtP2Y1CkSRTGprzFiuWrxnW+31WJcqvSp352GOnnbxtU1Gu2QiVqNfFxicbGleGk/s3kd5bxJzY+ZFN8et8jMjHjgRISWRRxpKkQ1JsUxLXw/oO6HLC/kGcjbRHpKqZSjpTc5fn6Kcq5ManawUoN6S2eiWqXcb6ljL3Gtlh0pvoir5SjkcqwbKzO50OH4xHnmEl8Vh+v7S1w/WCQ4dZx6tUbn5CzWihH6V6cMb1kLxQqUKpjPP8wLD73OL92+gpfPt5VPysd9Xh1eSu4WrNm2mwsXWgyOu6zsNxjpLHCh2mDFmoSLZ/P0lzNF0CsH392N+HtxyS2dSxQc5Zd1qTBZouLIYmtEJFaTivcq8wPXorVPK1m6+OXoqUmS2gyvHOSVFxr4XoPAl6BalDITNWrKCsZYy3gsmXpMFv0r/BsZrbXbPpU1Oo1zplI1ZZnumeop1VJqFy3qZz36VgJDLeIpmX/aSt0kBWEW5CkKUuFjZcVONn0XGbvEjKSZ1cXSxujjHHPdcudnlRrr1rs+TyjXWLtNHJqX+VaXsGL1NTS9SNkrSJyIqncucZWWfMxEzCXO3aKCdIMPrxjvjrq66KKLLrroooufGHQ7Pp8gfu4Xf1mpAILA5y++/Kef5FPp4h1QLhbpdCyc9Q4zb4QS50O+vMDo9hiXAgtni/hOCfrmGdhmMl2dIbKL2IbOXC1hYCAl9qHccGlELRIHBlyT+mKHRifEcR3eqM2xyahww1AP1vgYU55HT97k6Nkqc0aLyNf44tPnyecuMLxuOcHZECNI8TUN86PKT/oUQXatEsQoRNGFVotCvgUSHNsMMPIxc6bOmSREs2xcw8FMPPwopJS3oQP1OMS0AhLHxvYT9FyOGS9lzDDQbdFCiS2crl7z6UadN7wO2kKTSs6g3Y4YLRWVl89Uw1PuxoePTTFUcFW2UjVsELZFNabx0uwc8+2AsBPRNEwCz1cZS3GqUZdMLS9AE+NFDAaLEGgB7TiknoTM1wJa7YC1fT2US2U2lGGiHVIo5NBC2fka5HQhvpvUz8Z00ghdDOEkRNdL6F/rsLyU45vPn2RNfy+FUg+LrQ53rO5joFzgzHyVi69OUtN1mi9PUzz7IGuef43Vm9bi5kzGR/rY/Vf/kPtu3Y5hWjgftoTmfUJ2+6P9JtOTRR5/RcdvB1QK4uFisOnaErMnO29TZL0XiBggNQ0MR8NvRWrslHV8srw8ecuVEWJkYmsLjK/UOT+RBRBL50b8taJI59CzHWUiGfmhIs4bQtQ15Ofr6OrrlhywlYHhUgcojt7yB6YUhiqk05FSd7KUXyWQbwtbEfnRlL7BhMFSStWDtD8gmnIv537J8xaPnixDLetfXOpexWFAKiNTS+f4x+zhI/A6nspCc1yDpx77Ju+GcrmAafp4XkRHnJ3lglk6rhkRXEng1BgxirWMzP0hoVv4fIL4sz/+o6ve/+W/+U/5o3/9Dz6x59PF1Tjy0hWu0ead1xJGBU6+/gpvzvfRtzZl4dgiK1evYT6ZZmxlH40zNheNGk7eVfP9hXZKPtCo1qq0zKaiEOSFD+D7lFONPtOiZSSc99vMzqaklsWCF7F1OE/QMdmwcYS8VeXU+Sa5QpGLJy9w667VHD3qiUzlLSaKP77Ii6mh2N7HBmZqELYsgqiOF6QM95t4QRs9jtHzFh4xDT8iCUzKfRXm4haFxKRBQs5y6YQei5OLdNwSAxUZT8TkTJNK0aba7jC3WMeu9FNxLGwj5Vy9ylyrxLIel+GSxYn5pgpyFyfmnlyOnKFTsxOaYcJUq4MRwqJEMDgSGSCCQAmR1VWBWogMqlGobrh1ce2OQrUwia10W1yCTahFMUHbIHX70IIFPGnxE5CLAyJHZ0ircMq7iNPrKLWaGC32OCb9lT5OTMywvNLD2VbAaJiye6zIYC7l9MQMF1cNcb4jqiEdijmcZhNnscW5R1/krjuX8YdfniVNGnzjkWx0tG/fLR/6cbzxpjuVk/Chp77zA79WFD1SJwz2Fpk4M08cxcq8b3GuirXCotFOKPbm3vPvvn7vzdQbYkctY8yIMIrwCcnpUkhkiiGBjKvC2MOYhlouR+/gBLYlC25GCJJxpZopyQ4ojonCUEng5Vo0ZMxlCvtPV6MoLRX1Z8bBUYrtpaJExllSJIm7sqTBi/lyKjeGy9L0hNwgJA0Lz+uQ9CS4aQkqHRpHCxTLIYkqsCS+Q1RPmTO0oigpN+rMQbHmVekpjvBx4rY771dGtGJYmOoJj33n4e/79a+9fGX0NbxsK/FlJ+0lyGumbJ1lFLgU8Poh4cf/ztlFF1100UUXXXSxhG7H51OCA3d/TnV77rz/pzF1jW997c8/6afUxVtw9KW3xEK055lf8nbT88ton9bwhxwKrofsQyMrptxbpFbr0F8xqKcuodamINKRekR/4uAaFiOlitrlP3dxCl2LaeQMEj/GDDp00oRTp+pYsU/O1NEdGzdyOfLaBDfceh3PPH1atdO333oTrz528Mf2WB1++oqx4eade7IdYEHH7fXQnQLtRZ+egktkpxhJTMtIsfMakZHiy5hB16h7ARVMJlpC/LTozyUUihZBWlAk40SPaMvYQnKcbI1WEFIq2gxVKgz3FJmtNjh94QItzWWwIDtxiyg1me8EKvDTFQJppFENfVIhlxrSnhcjRJT3km7EqgOkpzqmYygFkYxHkljD0wLlXROlLWLdZdH3MdKMRC1jsXbq0/YS8laOEg6rhwoYrk5qx8zMt9k6VOGpiTlePT9NOBewYmWFJIj5jf2rOFKLyVkdjl9s8qZRZEsuZm0xZvcdu1lh6Aw3J7C338Rf+3/+26te86ee+vCJsB0vVK/BrutvRxNPF2nppAmmZXL4qas7A9HS6Ef8XWTsJeMjeZ3zQxGBX6NWM1k5NPief/dzbzmHBIMrNqgOjCEBZdJdWjIbTJfaAEIgbi4WFCnX6XMJF0PCQJOWz1KWXkYuVq6RKp8iG8uocZj6AZlHjRIsiZJrqRujJjfELDZ9SuNVxu3dTJx+U3WEZMqT5cPKfzF+08Tp1SgO5rlwzqZ6BIq9Qto3VefjUp7f5bwvpe4SP5ysO9af61UdoY8Tj3znG5ff1jQxinrvkA7WlRCg7NgLpNkmI0Q5Ty6Ztd51/0/z0De+9EM9127h8ymAGD3Vm5nMsN32eOrRd5+LdvHpgqFbJA3lQUrQiXHLFoEX09E7aEGLtnTGKz4lI4F6il4wMC1bGeqJcPjFcxdptmPyOYNKYipH2LnpFoWeHFqtRdnJqxFJJOnMqcFCI+TJp55j45ZRqtEwHTti3bo7KftjROdOYmoaL/yYFkJibGiEOu1QeASmyjGKEou5lobp+eR7XAzNQsvreLoUISFemCq1VeB1lHJqxbI8a4dGefV4nWrVpVDQqSuVjEXaGCAx2uom67flRgsLjRmeenOWTr3FjvU5pucjbBLaifA8ZP6hoTsOVpIolZh8VpdFNIkzpZClK2WNeAWmUYotiq7AI0kMCppJq6OrcYd837ido9lp0A5auKZFIV+kkKTMhS1KbsrFcI5SziFXTpnsJAy5LnE+x+npmlrsNoz0U+zvwYo6/O0/f42N64bYO5bDdktsSxOCiQnWD/fTe+IkhRt2Y999C//hz4/wa5/bwf/xlR88gvphIGG/QZSZ74keO45CZZYoeXObd+zNRM2ieguz11HGQbZlcfroC6zfuouZE3MEVi/zC7BtwygvP/fBuCvrtl5HvdEib7qKLjM4OMTswtQSsyiTk4vPXm8R9HaBTnSeTdds4/hLs6SBjLiWjPYUJyhVxYWoCy9BuSov/Qy1dotxolIogWYltFs2/atnifwG+uAUnUiUWUsuzGJXkTQxGkX1XBaPa9gumIWQXDFHIuNe4b4sGTCq5xovKbxMcynnL5PM26aRFeSfENK0edX7N998B0EUKluAZ565WpK+ccv1VJtt5bwuL1kgFfIShF8lRZBwmY6+tjQa0yzu+9zP8c2v/tkHfn7dwudjwnU33KykqLmc/bZUYpk7dzoeG3fsp9FqsXvfHdiWgWNLkKXBt7/5w6fRdvHRoTjaj+OadAwdsQmRG50ZxAwUi7RyLq6bEMzFFMpFiq6tbOiLpsFsGDBd8+lxxbdDloMEE4PQsAl1AydIWdWfZ85OmGtFBLGOLbseO8cLL5wmrL5CseLQrrdZcHuwKhWazTy7brmRFx9/f9b+Pwo4/PRj6t8t192gOBLNekx5MMXzIwrlEqHtEbZsoprGwsUGFbekfE+SvIEn/jVxjjNv5KjP1dX2vlIU0rSdpUYnEZab0mlEWGMm062GIkifakTknZIipnewSBMf3xS/mYg0TOl1DDzhXAQ+BXSMvCyoOk1htUsBZKSYmshxwTV06mGkiM8Fw8EpGOhmwkI7oOOnLFZSbCtPEPr40vUIIgYsm4J4DhU1JpOI3jSHVXII2h6O4/JmNWF/Xy/HGjm25Fyivhyz1Yh40SNYqJHkE/Zfv4X8NVt57C++TV1zaUdNJltVZk83ePmlC0x3Ploy87Zrb6bVkrP7SmSB8EDUlSJS7CVysVrP1XFKlf+MOtfFXuL1LLC4cyr7eZX8ug/8XFRpI/J05c2T0mSa/HiI2RmgPFBm6sykcmsWUrJV7iOcPMOpM69jlcskC1K+Zh45mfOydFkkTmGJiHs5L2KJrHypg6PFJHpKT74fvf8MhmPTmStz8dxZ+tfZ1C5IJAU0WgFmWpQsC3UPKQ7k6UwZpKGtZPaXfnwWaJx1RFSXSinBs3Bj6V6Jm3vOsa/i0HzSeOKJrKt3477b0HLrSDtvXv6cvHZSpElwcxa1EWSd0yhSga5ZUZz9vfsOfFZZTzz09S/+UM+ny/Hpoosuuuiiiy5+YtDt+HxM6IjaJEqwHIu77/ssD37zL/jZv/TLfPFP/ki5V4rKI0PWnszkimm32/Mph0gsg8BjYaZDzgHXLFPKpRTiXs6256jkNXIdA8vM0VfJ0Wj7LLQ9OqlFELTIS7fHknBCHUQlkrhK6aOnCY005ZWpWX7qxk1ops4XX55WyodAzA9l1l8eQMuZOFqBdjMhlq5D0Wdgx1quSfdgYvHCE+/d5O1HBQU3hxWa5OyI+myKb9QIwiadWQ3Dt1m2yqWUKylJrK3Bqw+eg3yOnTuHePH0s4yM7FM7vuefvvq1WbXlGtAKJFqMaVXoNH2sXJnlK3qYql6gFtkUSwGdRKNgucSaOGsn5Ao66XxKO4oppTLGkU5GRM6KCSxLufS2RS2k6zgSaGvIjj7lYsej5MJgj8lcTWOx7ROlPmZkYNomrUCynjp09AQvMFhX6aPH1dlU6uG60SEmphc5ON1kqwGtMOFI2GHUiik4Op/bOcDGYplFLeIf/Odn2L+yn7GVI7zywin61xTYNVriuv/hIXaOWfzFwx/tORIEIX4cqYw5ZdyZJIrHo3o9KtMqM/czJHcuzrx8ZWGy3zJCeisOPvrB3Xst08Y0Q8xEujYRF0906NnawtDnaMxoFAY2EtV90VOzcH4KJ+cQNU3MvjphNIbrZHlcmnZFgp7qMu7SMYVjI5lSKnNKtOzyYyQDLFThp3P6cdKmT9oqoitvDJtWfQAz9RT/ScbUosqSro16PcSEU5kqZnwhI58o+bw4KqrwzktKMT17DWXsJb0f4cJIEO+nEc+8xajyEpycxRuvZx3qLdtvxLMMgijCI1WWAdL1kVHp6o17qdc7FIpvsQb4gOgWPh8T5JrWTGnXX7lopegRKHdK9VbWhlWW4/LuJ+yn0cUPhrTs+wctLNOgbEnAZEw5l8Nr5siVUkqdCF259uqcrPpcnKupm76dixmwTfKlPLWWl0nT2wl+6mFIi9/USHNizW+QKPPXmOVlg8l6iCat4DjGLhTww0ARayWp3dBMmgseJ599jnLvKF4tYde+m8g7Lk8+8tFyOD5OHHry6oVv1769JFEFfZnGi08/y+LMO3xTC1588rR688XvKXgEW3btpd7yiET+Pmli6jG6bhIGKVqUMJDvxzN0/LkabqGfdnNRefOYMfh2G91r0AwManFLHV8petK8iZVz8LyYqSmP/tECwsQIg5BQSK85Uy2wfgD9pRyxllLtwKArVkUGfhDTimJM22I+8Bhv+qwa7ae34PJ/Hptle9Jg70g/311cJI09Buy8cgcvD+RpLbToW7+SLz15kjcn5rlQ9bh2Y4WRQkJ1ZJj/74M6m/pgtvnheaO8GyKVch4iXsZZbSOclliNM2SEcSkYVbtUNKhCSMaAH/7978jLz7Bp2x70doLnJxTLNu0TNj0rA/zFKazBBXpLG6kuTKlxk3CnxEuqVLLpmGUMo0UifD0pPpZ4PF4+oBTllKQ9jMSRXT4nxW8W0aCZKWZfSGda5O2mSmUf6Cug5XtYnPAVv0zGY/I6RPJ/oY4Jf8jKiptO0CYnnCQ1ohNptxRYivZ7JaF96aWSgihzbP7RWdoLuRx7b7qLpw8+xJFXr4zox1Zux1f+PhJxEdH2xL8JTCOzIfhh0B11ddFFF1100UUXPzH40SkLf8SRcw2l5Phe7D1wHwvVhmpxCikt46xllb7R7fh8KrHzhltVtoyE59U7dRZbMcVcizW9o7RTj/nFkHNzb7J8zFWMzWaYcnShjV1yKdg2YRxiqe2iQc1vq52wTaqUSEZoYgoBOg6xU4NcyaW/XGCh3iIJI8LUwA11dEPOpQQtNtRO0JattB7h5hzOzzbYNp6gd8RYjR+rbs874cWnfngSpwqZVLpiU72mSlQs4wVTo5gvMLO4iFY2aAlpfaBEPtXxOzKVbBP7sTK3cwwbLe2gRwFRauEX8oqELQGlMsYJQ4OOODorKbWOmYYsVENxZyTf06u6TG6SUAsTjDSvFGexSNhsGJIRjWVxcLrGN37lPr7x7x9hAyYbV43zlUTnBT9iwIaxgot1ocqD81W0sRGenqpiFRw2jvXhOLBz40r++I2VLL55hGorIVXn0UeLJM4CJqU5IQMi6fiIakmprXXpbcjrLmTWjDgsnRJRL718+MmP5Pm88VqWQza2aovqRknWWrhoYxfGSP2A0D7L0Jox5i4ssn1oOSenJiGxyPfkIPSU235toUZvTxHDcCkHjurSKrm6EKPl+BowPraC6dpZ7GKo8tYsW0wOxfVbOsApSZDDICLVzWw0Jq0epXq7GlHQQbdz2euTSoirtIQMRXKW/6TTJARhUT/JGiKZf+mHaPb3UeLu+z+vAki/+9DX3vY5IbdbYn2gulrS9RFSfEAc/fDnbLfw+Zjw3NPvLDHutD0V5CYyT33pIOtLJ38WcNfFh4Gbb7ubJx558If+OTuvv4WmLF5Lyc51vU1hMCbvLxJFw3hxzPTcIoYWc7GhE+ZtZup1XNvGFD5DFKnjHBsaNa8NUaqUPX4orX+Z1cfYhqv8KzQbpSB65NQkcTNgednlQtBBOu3ibZK3DOYbDWyjALlYpTEribX4BKGRKwgP5scvvf0jQZopc4RnoRaQpQ+L8md6ZpqZiTr960QiXCT0OwSheLoElCplGktWFIbovnSNjmOqBbUdJ3TmW8rht1iysMuyoYkJWzpanJDaCVYSqzGoxFcUDIO6FyrVn95p4Aw45CwbPZ+jFbbxPZ+2EXF+apL7hwY5NlVjT6HNmeMTXDtWYCyncbzeITQ14oFejjRbLJNxSbnM/o0lShWX586WqZ9/k1aoE4tM2PzolwAVAJuo8kad16LakhdYCsssPFQWb+H/SFEUK2Xjx7FuW6aFpgXgehjRAO1mjNkzQew3mJt7nRVr1/L6lMNw3wCNhfPY5Wmieh4z1BgYGFnaqGqZ4MjIQod1PRLtH+t3urx57Dkix6HdNkg8HdOwcPJ52i2fwI+xrRkh7pDGKl1UFcTCBxPInV82vvI65ExHyf6l0JGXrpHWyIc96npXPkfCMVLfd4V7FIYJO/bcptTBwiN87LtXPHY+TXjwG1mC+yU88LkvqE1IvdmkulBV50cQR2p8LGGuWen89uLw/eJHoyzsoosuuuiiiy66+BDwY1n4/Nt/+29ZvXo1ruty3XXX8cQTVzt3fpogAaXiYrrkypDtjKSVqdrBXXxYaLZ9tuzax7Zr97Prhlu5Yf8dH+jneOLDEkZEMhoxUvKDDo6Zsnx0BQtBSivo0Ddis2p8AM3XqM7HdDoRhii3fF+pwGQXZ4uTr5ATZR9nGNnICgcMi8j1VZfAiGKiqk+12uZctcHjJydxdZ0wjlQu1PVj/Vh2hCZBnLJLDrNwRPGcmZmrcs3yhP5St2v4XmCaYiSnZ/4oory6tKlMhUiaYtlCvI3VmKaxOE3idzBt6UyYl9UIhm2RaIYyURQTQ9n5x4Gn3hZSa7gopofKySZz3g1idEvHsHVsIbE2POJApioOxaJJmNhMzsu5kZK0UybqVUzf4xf+t69y6I1zaDmb1+Zb3HXDBv7Svo3cu3qY0eEBTmuiPivihTr1fIGTZsqXXlnkH/+vFzh89AIPP/IUhw49x6svPUdBpIgfITZs26NUXYqwfImDq2522X0uji+FUKZEEkYrL7wQeD+Gm5+on0zDpmIVibU2URLSOjFOu5V1nKrzF+l3alRLm1ksbqYvnaJ3YBxdxlqOha66ZdnASUQNla2DzCcdtmwf5+SRC9QWDMKmge7HaIFPGkd0ajXCdku9CH7ikxoFRYBOhAxtJph2imlr6iFZXk4pVWRlGbmKR1jHaeKYNgUrd1kJl3WJrizl0hUSs0AZsQZh5jn0bnjgM5/jk4aonC9BOmjf+vqf8dRj31JE57OnXqJQcLFtUxmLmqauxsQ/LH7sCp//+l//K3/7b/9t/sE/+Ae8+OKL3Hzzzdx3332cO3fuQ/n59z7w05ff3rPvFm74IQP9xDzN0DPDLrGul/m2KAIOPfkdHn7wq5e/7jOf+/wP9Xt+0iE335YX0PZCOr48AsXVEbPI62+6kxtvues9/RyxrJebeKLHDI4MyISJZfk8hcHNLPjz2HZA0oaJGQ8/SPA7HXWxinZFsgqk8JHkZFwj6/urG7CBreXQZAwm/oSRFDCe4v2I1L2ETc42KDouaeQT+qEwA3hucoY4TInjkFRa7VGKKSaHhkbeNHjszCw5Cabs4gdCRoJ518KRm6ueKqm1ZAlkA5oEcyBPsyXJ8G2GRldQ6OlRTIFmu4EmCjxR4knBFGeOtbplkEghGmWqLTFIlFFIEERYeoJT1oksmyQWlZ7MfaR4jVWBVCg52I6BbeoUChGpGaHHEZWRkhqJBF7AoflpBqIQv+bR1FJ6lm9kbnAI3zFY1mvTO5DjzYU20+0W/bUCjRmDvpEcne8xK3zise8fJPnDIgwkriNSPJ9M5r3kkfwWw79M4i5ybDEVFH6MobgdHzUKOYtiwVVBuKZpYY946MUUM+zDLmn4Pvhtj/zCa6xcO4Cz/QHCnIfmSMCopYpeSVCRmAjbzTF75nHc/CxvnDlKxxebgyJGHON3fMxcCS2XIwxjFU1hyO9xcoTOBIZscqyY0KpijSygl1r092o4xZg4N4udt1VxIw+rGGMOSNGtbKIvc3mUDF4KZJHpC/8wEu6SVNxL0Rbvgq9/7coa80lBrF0u4S++/N/e9nnHtlWRqVyyLZOXDv3wzvTv+674q7/6qzz++Ief5fJh4V/9q3/Fr/3ar/Hrv/7rbN68mf/5f/6fWb58Ob//+7//ST+1LrrooosuuujiE8b7LnwajQZ3330369ev55/9s3/GxMQEnxYEQcDzzz+vnt9bIe8/9dQ7m3T5vk+9Xr/q8W64497PKCMlwb5b78p2/sAtt935gZ+z61i4rk3OkWygzA9GWrBCxn0r3poH08X7h+x+RDEiR0xav8ogK8jawRJQ2eoEqvtz8233fP+fE0XK+Awt5GLrdcbMDq7dy+nJY0SdkOnzIXMLvoiDMKJwiaRoKvK67GolwcmyHKX2iZdaPvK50JCwTEjMiFwa068XsLUsT2i2Xcdvd0hMUWyIv4zsjCNliqlhkloGqR4rvxkvDim7OZb39rCufwV3bV7OL/zSndz3s3dy22fv7Z4674LDzz7G6y8+TT4nXR+DCwtzirwqhvmyX86bEb2lIXr6B1U0QKcT4hTyxJarMqUc1yE2UlJR2MShCrqUkUgqx0x25pauVHkSXhnGGoZVxHUcTLcfI5dTpngykZBGR77XUcZtzbhOrmLT9nzlL+QYplJoFdAYLEnIbR/ffHOCgy8eI6nW6NNzjHs+q0t5tHI/WthiVTJAtS2KGItUlEDCiP0YoTo5Mn6VMFDVlVBzv8wD5y2NCPHwUX4+uqa6PUdefe4jf24vv/AMp4+9wIVTr6p7b+s4BPUWnXZEkDh4QZt8JU+jGhC8+BxmJ8Jr+ui2jF5cpbKTwFXlQdRo41glimZZkbZ7ykVyZZ1Y+Ws5iqictAN0K6WYN7BzJp2zFYregBqb1fw6PeUBRpwt5LQyBaugjExnXjSW4hqy6AZvUaM9IdE4Ym6Y0Gk3iYUwr0kXWEbwkTLDlfuUEMVFgvb4w+9ObN57ywdfuz4M7L7hVq67/vtPTeRcUT54Sgj74cxA3/dV8MUvfpH5+Xn+6I/+iP/0n/4Tv/3bv82dd96puiyf//zn1Qn0SWFubk6NEoaHh6/6uLw/NSVBdG/H7/zO7/CP//E/fk8//+FvZZK7W+64/11PppsP3MUTjz70np/z889mbbs9+w5ITI0qRQ3DRP+eG9RXvvzDZZN0kWTzYUnsXsoLspIqAyPrmJysqotKLjD7+4yGtiqTu7YqMgr5fsyyjl2dY6rtsRAtYEoRoklps5QHRBYsalgWSeijJRLKqKkbVSxpz2FCKgaFomyJY8xIAglzLNZiUglxdDWMpUUj6mhYOeVkqLQxiShl/AAtkcRvGZZIvlcbPdEplkRfFPPaG2eZWlzk5vWDXDwb0BrewZ4H7sLWTJ78WjcI953w8qGDXLf3VrasXE6oFo+IIJVxVId83yhBuwatOl6tTpS3yScRLT+gYEaqmDZSk1R30GypYjU0CebUxLFZGD8hkcidTXHqBr8VZOHexRy53BCdxUXiKKGoabSNHHknZqTi8NLLDSrFHK8dC9mwSefkbJ0VtsM/fuIQnhexcajI67PTjOd0zvo6czWfQjjNem2IN2ON55/NZOE37jvAM099cNfjD4IojEiTRKnj5BxXpoWGniWSS6GjDPmy7Cw1ChOuy4e0uL0fyD13cKiiZPc5p0BY1XArYhDoYxdM2p7Llh6Dg4bNSieT3Ce6hpGKTD/BN0JyQUCnXiW2ShhiSZGTP1Jk5+KSIP83yUshnJqMyNhyyiVORRGY4jgmepSyWFtg6nzKlDfHyOoSgyv6s9dM8cWkYI5x416afrZBT90O5eIA9UWYax2noI+wZuUqZhbO0momilv4/VCrt9m4fS+2afLqi09wzbX71XHITCZTLEPnlRe+v7O35G+JcaNl6WoT/+jD334fr7yUcxr7b7mDJx9/57GrKA9t4c9JjluSsn7bDWpDadsa+XyOZw6+3Q36B+EDlf/9/f38rb/1t9RDeDT/8T/+R37lV36FYrHIL//yL/PX//pfVx2hTwqXrLwvIXMCfeeL6bd+67f4u3/3715+Xzo+Mhp7N9x612cVkfH2ux7guw99/arPbd95Pe225Gu/fxxauiEJ30SCSWWR7uLDwY37b6Mtc3Yj2zHIblw6QJOLTarhWeqLPmOjg+oG9dRj7160hkrCnGCYCeWhlnISDQOTifo0rmOqzysHVpEgJ5Fympfdl+3o6KlJYsbo0nVSJGdDXfJyI7sUwCdFr3SKdFu6OjZmpBMlHfUzlWRV9YjE3TVFswx88bUQ8qxbpBKKX4pHX38/hmtydGqOudkFau0Ow5UiFzuLhK9/ifLICLG7nBs/ezdGbKrn9cQ3P/k5/6cJzy+FoUoB1Ak8ZibOU1yh0Zyepd5aXPLYcrCMiJvXD/HMG1OEEqppQOBBGvqYhQqBEHflsBqGijQINHH01dDcAoEvx1H8m0SKLATpkDBO0B2IzEDd1CXHU474fNWgUrQYywdELY87Nm3Azhmc1y1WrsjxzFwVvx4zHfm86YnjcZv6eQO/KZ2VK+Tlj7voWb/pOqq1Jonwm7LlP0tAV53XJW7PEvFWFjThASlOuZBgPkZcs1vCoX0cWzqnFkY5JmnYxFWXpCTcq5TQ05g6c4KxleNY55tqlxTKc4+yWAk5xlplE3hvEDQCosAgbaekYUA+b1IomCwuNqnXbQw3wD0/RKK3kTZv7Jn0rmjSerPEmjXDUHoFr52CV85I4AgBXEqEhLhlkqs4+H4W5Gm7w3QKbSJ7gl4tJZx7k9mgzfSpkNLyXhLXZ+2Oa5VnktxD1H+6zmuHMofkdscjDFNVXKzZcgP1VkCaZCT+eKnwWbt1D6dOzLJ23YDy1hH367ciiBL1kOtCbeLeBw4/+4OFRy8cyqg1IkzpBFmnXuKfnMTglRc+WBjzD7W6Xrx4kQcffFA9hJB2//338/rrr7NlyxZ+7/d+j48bAwMD6nl8b3dnZmbmbV2gS3Ach3K5fNWjiy666KKLLrr48YT5QbKJvvrVr/KHf/iHquC55ppr+Dt/5+/wl//yX6ZUKqmv+ZM/+RP+2l/7a+rjHyds21by9Yceeoif/ukr6it5X8ZwPyxuvu0+ZcYlxdX3dns2bdutdg0lzeDa629Sc/9nnnx/Lbjrb7pLVeMHH317q/CmA3eLzRe5nMl33sKC7+IH43uPw+69txJGGivG1ijpZymfqIBB4VZ9P0hOjswmJEMoblYZHRhgfuEivt+m5PbiSYZWquPaOh2/jUzVRL0SqwwiDV1GXZLVoyXYroFmOkTi/Ktk0tIZ0EjDRF1jKuDQStE86QCA7bhqlyO7v8gLiQ2D69Ysx8lpdJIOI26FExer5M0CZ2rzGKHGhpXD6EaOIxMLzMxPM9bTQ606i+6dp9LXj7VsD8aFeW669wHVcZZ99hMPXn1e/6R3frZfv5/+4XFanWkCWtlIVKyU0SloGjndYaTg4hUcWvU2NV9y1wx0kaVrgWrPm65BqJkkkYxapVsnBoYBsR8ROzYEMUHHR08c9HyKVzdYWYb5hkcSmkRNn5xdZuuaMqcXWyzGAeMU2DE2zGRtnuWWxaCr82qk0QrqzM3OMPVyma0b+3jpUNa9+iQgtgsqp0vO+0tbbDVCkb5Oxvm5pLSWLkP2cTX4+lifp1z3eVe6TwZxquHFPkFqkbcjFhstevqG0eOUqckL2K0Z9KF7GfJf4MLFEpop6WtiTqgTLYb0FpYT+yexbIuAmFKPi6PZyh7BtVxlbTA4OkZjUo535r7ua23a9TmckseF1hTVWYuonoMeqMUXKTqD9BX7mJ+dUTl9sbdkq1BbYGTdMlYPbOWNM22sYp3AtPH8DpWVJcwOtKcD5ushZvkCRqEX2x+i4IasumaX6nx7ci+Rbpsco1Dcs7MRl1kwmTp9kaHBPoJQnqdHtdnBMS1lUXB8yf16z747CcJQydBljP/495jEyghLjvWTj3/3hz5Or73wJJt33qC6pdIUjKOYdVt2X+5C3XTr7Rx87LsfTeEzOjqq2v2/+Iu/yHPPPcfOnTvf9jX33HMPPUru+fFDxlYydtu9ezd79+7lD/7gD5SU/Td+4zd+qJ972533KnddaWt+7wj6mmv3Ua03VXDkqy8+zY49+wmjlFtuu/ttJ8JbceP+AzyzFLgoRY/M/613ce8RabSS1X4EwX0/aTi8NMq4hN37DiiX7Jz7/RONpZWrC/lc1xiuLGM2rVMLAnXhJTLGiFPV/g7iFFMWOsX1kWMm7B+TVtjCLjoqjiL0VcQgpT4n8/ZJMhn1fCtUTD5dzrWcRSrZhGL7UUxJzZSondBTyNNXyXNupsqOzWvoIc/zb85xYbZBb0+Aoek0OyGNZpXhcYtafYE4DOgp5TgfxFRyJc6emufe4QlqW5ZT1BwWouX4Rw9y4L77MDQjuxlGUmrDI9/5dLq+fhwQJ2dLlwDaFdS9cwwuG2duok6jOUOcOkz5JTqGBImm1AIPtyj8K5e2+KfEMUYi9wstI5oaUvxIYGeAJTEJXkyxYmdE1ThSUvei8LpSCWMskugmTV9ndLlDb1+BakfsGHR6+x3FySglHdqexphp4nfaHJHRbdvgwsGYtVtzJPEnOy5XRY1yH9aXeCrZNaRdSjFfimbOPH2ySHJdN9TG8pMYbV7Cup17MRyDUqHMudpJlSRRdnLKYbvcbjPgv0Qn59COGuSdEsWkgZeWFNG51NdH1DpF6nrgJXQaMbXEpn+kzLrx5Zy7OEk7ktdCSNEGupaQlqqYkYNhD6NJ6m1biiOXsJOQTJlERZ+J2Yu4RUmsL6q1pdn00LQi5U6BsyeOMH+8w/CeEYaHLGLD59yhJuVhD9so4q6aQ0uEZ1gncOp0tAqlpMhQaZQjx08wsLKk7l8ycs/y3aHhdTBcPfMri0LK/RXm27P0FvuZPVNn9ebrVKOh1cmoHUdefOeRVccL1b833XoHBz8E64Sc7agiTWwB5LmJTYm4VG/efr3iGb1XvO/CR0ZYX/jCF5Q54Luht7eX06ezJOSPG7/wC7+gyNf/5J/8EzWK27ZtG9/4xjdYuXLlJ/J8uuiiiy666KKLTw/ed+Ej3ZRPO4RcLY8fBhs2XcPxN165/P4j3/kWt9x2D48/8q23fa1q3Ipj61I3xtRFlSXun99/x9Vq+4qwJUo4CbyUWlvIj7ff/Tm++xbzwv233Ue7Le7OIsl+f+SxLn4wDr9H0qeQCy1dVxlZcwsLnHN8vCBWSoZIwvOSFC3SMOIIrxUpZY/InHXbotUUN2aw0ljt8qycqY51qxMLr1XJnAtll5wV0W7KGeUqxUsaJRRsk+HeMp4wZ20xyYP5ts/khRlCw8VrLdIJYaBgsXp5L41qk+l2g8gwCbwOFcNgwdfZNNzH2WPTNIyAoeEeRZR95eUvM2yZ9PTmWNU7RC2p4DXmcAeXcfDcINfa8z/Rp5BjWSojSIJlB/Lj2F6d8cEiFx2NdqPN+ckFCgNF9A5UQo0ob2JbEU65wMULviiSwTZB3HvRiQ2dfI9DuBhQ6dHo7c0xPeeTBjLqiWlVPQbHBplcaFAoF4m9hDt2DqFHITVJqXQ1RdTvG+/jyEWf1yanuHPjMt6MO1Q7VcLpIVZuiohDkSh+sq+dsuewsh2/XBtyvqv7opBgxblcywwiL427lABF0zh14sVP7Dnv2HMTXiRigiUjda2HTnMO1xrCyjtEmsWZ11+hsOMazA3b0SYmsUYG6JyR6xrqDZ8df+Vv8sh/eYiSdYGhnkF8o8NILiH0Jqm2ZkBbRkW6hBiE7RCn4tFrFxl093G28yiVFfOY4RqiVKdnqFcp3XpGEnRaLJ6xsFYsUuyPM/uE/irJJIys6yOcbTHrzOL2FCivSQlm+9EHJzFFaKHlsYo5nLyNH3t06nPMUGfgRov2uRYrR9eyOCfd5qpSGkoeWTlXzixblhReZauXNWtWcSR8gzOnTzOybAWmUsnCms3XqzHY0VevBMtu2bmPdjtQo8SDz733bs+99z/At77xziP3F5674iG4ZvN1eJJrp8sJZCri/HtF1xzmXeC+Q7jj44+8s0zvtReeYsO2Gy47ZMrIRIqexx5+e5F0Cdfs2qfcg5XtubR3lU17SixS1/Sd1ESi9JEZaleG/Elg667rafuB4u+IJ8o1vTY5r8ErqYWbL9FsLIIt6kGIHA3NS3ElBNHSiP2QvC2u3OL4qpP6Fl4nwXKz+AtLlO2hQSNo4mgGfZUyum7hp01C3SRs+0zVG+RcC6/dVv49lmuyfOWQCIbRnISS67LYbDMxOcdirUVPQWOgUFFqmmYnK5pnam06nQ495Ry9ps58p0FJL5HokhhtENZDeqIZ4labreU5MN6gveHnuMcUvobGdx/8Ojff9hmVTP/UYx/Nebhn/x2EQRbh8sKhx9iz9zY1Xj701EfrMPxueKtUdsvua2mEIf1xwrp1w8zPzuJrBk5kULGLpNoMXmgwVCzim+DmDcJWrLhbjmuieRFtXceKYip9JmlgEQQdUishaXnojkOxkGd+zmG0HNLQY05MLbLY7PAzO9YzWiixPmrx8omzHJteZI2ro21eRt6xmWssUIiHyRsLtH3xwhHeyQe/vd986x34QZCF5ybJB1LPSByGfK/c52QkEUsY51uQhT1cDVlgR5ZtxnFtSgWH117+6P183gqJRpD7cCIXspfS746SL40wNXOc/tExQizcQpFE66E4PwNWjsbFGM0IMtVaqvPal5+lz7IhXUXdl3tCngudlELZYf2Wmzh24oLyKhKhu+QLnz0yxnWfjWnPhsyc9Vm5uQALJdr12tJoUKMxl5JKbIOeJ1jMfI9cyyLOFel0Gri2yVjfOhZ1l+qFCK28iN5/Cj2CCv2KOxjN1MmNOGiWQxDZmG6JfEkjHpkicI9h9OkEUQFNzMdDA/0SMSvOFFty/zpz8hyd2Qij5GDaMZ1W5o8mqsWOHrFs9S5VAIpQtVbLwnvzeYfdew9w+On3tsF8t6Lne6EaARLqLYrX98mp7Wqmu+iiiy666KKLnxh0C593wSuvPP++Xsic65BzMs+Mg489xBPv0h26BHGADoU4luiKPCdKHkXYCmPFkn8rnjv4kNodCbH2jrs/856ejzhy3rj/dm4+cPdb2PVdfFBko0gh1xns2Fri9k0FRg2bxNRJJHvJSDHSFLtkY6UadkGSthKaQUAUpfjtiLYEVCrXXzEwDJTTqii9xGVVi8XoLaUtpORGm1qzTqej43dEGaNh2TadtofXCjEdQ+3mxaHZiyNa9ZBqraXM8mq1Fu12iNfSaIQei20P09XYtnKIlX0Frhsp0q9FmZEaGuWyw0LQYWykj5bt0GOWsd0y7bhAwdMZOvllqv3jlOyEu++5jzgJVCfg1tvv/0hOJl+5aMsjYuuum2lLl6QTcO31B7jxpveWp/aRQcit+TFOd+rMLsxTMiJ6U428lqfYO8CGlZsJIwNPt5TypFxycQt5GVoShh5eIsMNg9nJFp2qR0dr4es5RkYG0HtsrLJGoR9qjYRmahLqsLZSoTdvseD5HJ2YwDs3Qa/r4kj399xFeuwCRxtVnr8wx8JCvwqllHuKZVqX/U8+CCTD67mnn1Cu06+++BrX3bCP/Tfd9r5+xssvPMnJYy8weea1LFhSfHvimFjcz5NIdQ5lvCeKLmWOtuSwLoTYRitQKtlrd+/n48ShJx/lpece45VnH806Mtj4bZ3Boc3MLyzS65qsGu2lX5z2dcmPshS1Qb5StTlCjcQXWyYDTTx+IodUXLMjm1atn8a5SUZNIc2bSkQgf/b6tQ71dh2n6OBNGPRbvSTFOfXaqBy3VEcLTbRWDmkPazKRSm1MbLz5gLxlq/Oq1lwgrTuUcjaFcJANA/tBG6edD5jXFlmw63SMBLyYfsPFij2a802MqEC745DmDLTcLFGxgW5IOKqGKQ8JSBXBhSnO2gmU6pRX6MpFXO5dEi4roagd36Pe7FBttKjVPRUM3fECOp2AwL96TRN87qd/ns/+1M9/4GMljuAyZZFuj4yk3w+6hc+HBJljOu8wHns3iMQ50yxrav4dSpKu76niqVTp47obbmfPvjvUY+f1t6pFNEviffefefMd93Pr3Z/n5rs+R5oYPPPkd3ni0QfZf+A+/DBl9w0H1NfddtcDH8af/BMFZaUvJnW2yatnG+x94E4WZ+cpujbtxQ5BahIFooSS6JSEVAzrvAhHM2UaRUykjOp8Md+S/zRpD2sYMhZLshGYnoq5WEIkY09Jcw9kNq9RcOVOKcGoBqkmTqauaidPzdbw2h3CRCMMRD3m4EeRUoeJGVtPTmeorFFxCvTlirR8Xykh6o0AQiiEEa6eFWgFLWVQWtRhxI0bxwksjevWr+XO0TH+++KL3Lk1x7rlNlFZloPMQfWjQBCKuWSsCs3ly8eVuZqoNjw/ptkO2bH7VsW1+7ixe9/NpLFOp95keHSUqijzIpM6DfTEo9qoMhcl6niluhRuC1TEWbaQYhctotQglduDLCg5Gz9KKFFkVbmHYc/FlADTCGYWAnSvzUJHCuiUvrxL7EW4witrhSyYeSYti839Lo3U5IXZRXwr5fxFUQVpqkiWkfiHZYD6/HNPkqZNnn/2KbX4fVCIaEjUwFEYLj2k0Fe1UKboWoKMxpRjtjiXxwkvHL7CGfm44ZgajmnQqneIOzB9wWbi4kXFvfEpqxG1rUU4xFhaqowOxZbUTFLEp1sUgXK1KAqKSNcjQ4XWEsm1Dntv3KWCRWdnA1b2FJiam2XVlmGOH4WKI/reLJg0M25WVvCZ07eYXurGFS7pEjdqdGxAcXlENef29DE7O4udOpjNfsZ6dtA/PEbLsGiaAXNek5AArR1Ay6MzOQ/NDgQm7bTK4ozPcP8yNm9cz2xjlrbXwi2a9AyVqawzSOZzLE431b0jTGSMlxd7RZVwL6atspGX8aaMSuX6feWFtx/Hr37pv6kC+INC7hHyCsvY0HyfSsBu4dNFF1100UUXXfzEoFv4fAi46da71E7v2Se/o96/94HPvu1rJItr555buPb6W9X7UpXLLk9Ca9ROKJJHjGXrnDt7lo50gMKIdes3ZOGFmsYzj3+b73wzywt7J8SJ0L3EI0NXHYcbb8l2xrIPiaUrEGsqiLPtx+w7cD8H7voc9372itFjF++OggqSdTBNm0rvMCv33MEXbr+ewYpJMVwgr1sUS0XSIMLJGcSi0jElpkKs3wOR/anjnPrS1pdcG0vlsaV+dg5orqW8TVSoaXYwca2MwBjqBmHHIwrETj7FzuUwbBvLdegplTBMk0q5QHHAZflIH9vXjNCIEt6Y6bCq0suysoPYQC1U21RMnWHXVXldXphAJ6DiFphpdDjarKtRg3SFrCRmqM9lQXZs1iCVdpXKueNs6ZnghTc79I5u+EhOl6yTpCsFkOO4WW6QdETFFj8I6XgSIFn42E9V8WKSjq5tOfRgs3GoQo9bIBYWs59SnZlFb1dZMTzGSP9q1o+tJWfnsHp04tAjDkJcR2NkNM/2tSUSx6JS6aE/sTDsFCNOKfVbKth0YE0FxykqtcrEfJ2pxTYX5ppEforrlPjCnjWMabB3sExq6jR9n3xhmKCTGQCKsOJ7s/4+DDzxHs3hvhfrNl6HH0RLY5GlsN6lzoXcpzLnmLd3k/Tv197+GPDM49/hpacfZeumLRiYbFu7nN7CZiheT322w7KCzfKxCg0fcmaAa4Q4eoJrJ+Qdg5ytYRsaIvY1NbkLC/n5Snfr4JOH1WvR15fn2cNlJs6dI4kN8k6R2lyP+vvF60eNu9RdQe7vgozwLGvCW9HTX2ZxdoHJM+eIB+bkpMXUHSwzTxKGrBxcB7GPHWtEMmo0U0ItIbZEfQq5OKUY6wzFDpUVszST05y5MEWuN4++usO8foKJ6nEaR8sQ66RRpqPKyeh9qEYhV1QtKdXgEoPKJbNKCU5dteE69Rxv2H8Ht955JSz561/9c/XvvlvfHxVj844bldmickTSTJ59n+KHbuHzIUA4PbZlXOY9fOvrb3dWVm0/eUQJ23bfohY++R4pflLhd4jBGVAqVYiFgS+Op6nG0FCfUrVIobTvwNXp2nv3Xz1zlxMtuZR5IzeXRONGUeGo3JVMQyGZL9J6lFgpGZFs3PZ2A8ou3o7nnz7Iy4ee5uCjj+EGDX7mF/4uxsAwdthSeTsLnRrFckEpHPy2T9CM1PiKSFPte4HYg0neliggZJQVdsIspFTa1TJHT6RZbhJJWKktBogaTS8ilZBLxyFnyjjDwLBDYj8mXyyycawP3RZnYEM5ww4P9jDc18OKoR5u2byGSl+FjhfjWDqWH2PLAmvBeI+jQgVFar9vfIRVeRNHuEhajOeHOEHEuQuz6KYNmpii5RkYG2XeSBlZnuMrf/y/fCSniRSHcneXv/mNN06pMMtLEK6UfF6UTx83nnn8EV567klMM8dcowhGiYWZGXKpQdNIOBvUOD8xz+xCnc6CtPvzdEyHqmQqhT56TooR8BoehpZQqOgsJk2m/AVOLFwUrzulwIkaKY32PPNnE5rNBC0n4zOduTiiGYQcW1ggaHlqdPrYTJ2RPhNDd9myMUd9YU5xAWUkLk7CnxYIZ1GUqcLtkRuQ3J8uFQD60iJ+yeAwG3vJgiaj4E+HdUd1YQbXMtUmJGeY1GdPE00+y+LCY0TTj/Er181zzYYy+VyefHmYNWMa46MW61etYaE+B60qphGzY9N6Tpx6E8NI2bl1XZZQnw3DJLSPQjGfZZhh0GkE6LqJLeoveaiE8ixzUo2/DCka5d6yVFxEMUdfPU3PQIHyYJGh1dsxTQvTsXGlAHddZhZFlm+pY+HYNo4hnNRAjVi9nEvNMJjzI+oe9K4o00lDqlM18rFLfm6Qdc6tuJ0hikUbTZzoVdGhK/7WqL2RRnGCjtdQOXIqEFqNRrPRddvzWble0g06isf4VojiS7hpNx147yNsuS9IYSgbEnkhhQP4fvDpuTp+xEIvL+Ge+7IojCceexDLevcdysuHn1S7HOnGqGrd0Dny8tMcefnJbIareCQ6xWIucwaSEzqBRx99Wh1k5RW0tIBKh0kgC5RAcYH2353tqCKxIJdUaSmchEyYRSAIgVBkf9u3b1oqimLlGPz8c4e4+bb7ue3Oj4as+uOIesNjeqHFv/zicTaUXDYP9ivfnkbLU+7Kkr6tCxnd0ClIcaHriiSaGgapdHnk5p7IzT5GC0Pl9SJESeGJyS5KLuZiPkfb9zG1JLvRJbLn05XLrxaZWLZB22/RiKPMDTiNqIUdjl9Y4OCxcyxGAeW8wULNZy5JKPfkCeVRLFAaHaPSW2K8mGM4n6ciz69jcmNfH8MDRQqDDi9EdS622hyr1jg+Nc/E1CxCYDpba1Lq+2h24tt33aw6nypUWF0r6p6mFvHNG1ZL/a+une9844/4pCDXr6kHxB0Dp7+Mni+qxcfvNKg7PoVSSK05TbLo06q1iRrghzoVx8TO2zR8eQ0DaRKpgNljjSlm23VKFRstWYpDMVqsWF9n8YLDphWD3LPvWs7NL1JvNLlmrELYSfnGqXlmOiGT9SZRx6IWLNLoiA5ZwiiF//HJdkveikvFzNuRRVeo4lYuCfVQse2KwyLBmZ8GPP3owxx6/BEOPfYIz333IeWuP9y3Dq8+wHTV5M9fOM5rJw9i6y/T8R7kujU6m4YWWFd6kztuGcMqmPQODPPKsdfZuHal4si9dvS4bFUx9URtfqVGkOOvfNpkd5omilhsWGJNkFJtzCunZNvSlwohna0b1ymOzEXvDHYxUhEUSarT2zNG9eCEIk8r8nXOwS64zNU7lCVwdX5WuThroY9ruyReQCzhzYQMDhZJixqNqTZm0ItREmdmKc8MZuYmJZxDvZ2VPXKcxJnc4NyZSdKLPYq/1DeYV4RoL23je4niJcp1LeGiYsVx6MmruzPSeRZumnjh/e5/+NP33IEvFGxsJ4sDkZ973dI05b2gW/h00UUXXXTRRRc/Mfh0lNQ/Qrhm1361s7+EbMqY4Tvffufw0B27b1aSXFXNG7KjlYr5yvfJrNY0M3b+88+/pgItVUtzaXyleECaxoaNG9UITHEzpEkZZ+6Y0iaULoMyUFwKAJR/ZbQllbaEuUnLoLdcIQwk4yRCTw1Wjo+qPdfUtKTZa3zhr/wGf/p//ruP9PX7cYCMCn3JvMq32Tw2wnz1NKUgoNmOoBPRM1yk6usEQYxmJiI/IM059PbnadfEzM1XO7kspFEm/5mSRe284phCwcqcumOT8YESEx2PRhgR+gG5XAEv7NBpB9iuhesaSx0j2YNpJGGMGSUUK3nmWoEyP4xzdqYIjKXTp9MMPHq0Avl8mZdmZcwSYtguxTihz9GIWinjxT6CRpsgL98TEKc2dS9QnIX6opi1ffi4tNuXNv661Ss4efYCmsh+DY1czsXQRQLMJwo5PjIquHgaxleXOXV2mrJj0JMv0PBDAi1hIVig2qiRmjGVHpegFRGmutrxyqjSDxNkyqB2+bqDa4dq7LBQbWIZFrZmE1ltOnGeM6cX+cJnd5EaPodfu0Bo2fzZE68yk+isHe2jP2fRTGMuLlaZqpcZ75XOocHhZ6/m4+zZdxuHnnp/ockfFqS7Lc8pm24Jx0d291knSPINpQOtlElyF0oTpVSS/Ltjb7w/S5GPCwe/k3E5L0ErjasObrEQke8b4b/Nv0mgBQwN9LLo1/D1gBGtQ67Uz7HXLlAoFNl/414effK75KSzU+phZHgFBw8dJJ8WqAwWlZN7qlkMDfby4nMnGF2WY3DAZbaaGUqKyaKoB+UeUnaKVKcaFEq2sseQjp9aCqQvY5kZH9A2WL9mHtMYo3fbvXgXX2DqyKvEepFSLsfAaJ7NK9fz4osit1/BdPoCces1mtogJVFMSbiyrEvSdZbp0hIfL1OcqbQ1CjmTOMzhE6A7MVQDjAGfkcpmTpyeYGjAUuPq1ZtvyM59NeoTq4elvydN+c1f+8J7OgZvdXDeuG2/ClvVtfduVd4tfN4nOn64lCIswaWf5cFvfvny5+657zPYjsNffPmLV32PHOwsoThrEWYlTaqIznLBywxUl1RchHSWqDa/nBTbtm3kpVeOZD8k0Xjx5aNq9i3fs/P6OwgkJkFmrTISkPadkjbqqv2pQgAvEQml0NF1JqqTEvNNEkfq50vrdHp29jK5sFv0vDdIC15qT3GivXbvPo6cn2HTgM9rWozhmjiWTb5o0mwHJCGqBS1xJkE7JvbE/VmjVMkztegzlLdY9DJ5uCwIPT1lVg9XePbEJKM9BTpxilvIEdSaWWFrGQTiVppq1BsdTp2ewTE02npMUUabacjIQJFSOacIpWLb4ZoJNTlXolD5zkjzeqHeUM7S9abHKvH00SPqoc+moaIqtgskfGb3as4vdlg5UGSuGvH1iQs0hFxczfyqPmxI21yNi3WTcqUHTZ9Q572c014o7rjCk/lkRzgynhI59rARUSklTHptcsUynp5iKJ8eSZWwSY0YJ59TY0jh70lciWxudPFj8RNyEkAr16Eeown1xQsxwoR8oZfBUo6F2iyDQ+LsbfHqqdMEUcAvXruOjhFxsuWxe9Vaal6T5Wkv8zQpuiknF+pYQ4OK7P5WXHPtLdSaHpt23qQc6dUiI5JrS/9YiqFSMct1DMTBOZLCURY58fFZCieVe5p44Cwhk+P/6CxNaWNC/dtoQWPmDNNLH7/trlW89Og5rP5eUr/IqfOvY8YpN+8e5eTkI4z1R2raF2sm8/UzjC9LGM5JXoTJ8TNV4qTAplUpv/qFATqByUxV4k1qSwkBOq++ekodRyftQSsaaImmVPNLe2W1jsjQXWwyktQiCG9E6SzOz4I+yq7rE46/cop2UCVourzyWg09zdH26uTtMWrxcYqjbeonLPZs2sSp6dNZsCoG/QMVjpw8Q1+uRCIb6yUqRqmYZ3nPCl5eOEapp5eCU5A/B62njmH1qLDeyBMfp2wdE4sQa2ltfLeQ0Z/66Z/ly1+6ek19K+Qak3tslMKevXdz6Ol3Dwa/hO6oq4suuuiiiy66+InBj05Z/Qnirrsf4KEHs/wQYc/Lzvyaaw8o2e9b8e0lqfkDn/lpvv61L13+uOz0rNhSlbIw7WVHI8JEqYSffQvRa9uuWxRRKxP0arzyyhuXK2Op7IW0LDsk2RUrgptU8orfnBGhRQKs9k9xVgFL6T8+Psrp0+dVR2fP9p288vpJjr78Gtfs3kWxkOPM+Wxsl6v0fTwv5o8BDj31xOW3f7fX4cDKYSbma4x4IVXbpFrzZfaUETTF6dTMAhtlO5YY0tWLGS+55N0Bcq2QNB8i3qupnSkwegoFblk1jKObPHbmIr19eXAt+osF2oaNnSbkig56mLAYdOgtOUwQE4fye6FUcPEIoBmQ010lq++0fYwows4XlTGb5HWdW2jSSmP2Lh9hrKeH51oe+XKRkT5RlVmcPV+laWrMNQNen5hmwagzf7KfjStg8uSH/7o6jlwbomzT8cOsKykdTrkajp84p7qln7RaSZnrCaHcMmnHPiOjBUZzLkkrQbMT/ERCSPPUopbiqLppREFPiZR9gYzxMtVfhEUnsPBaLYqmS74/j57oiFel5G61RZAQelRch5cnFqg1GxxsLFJxmvS6RY5cuMidK5dhJjqjzYTzrk5utYNtZyPznXtuV1v+l557BC+I8EIx0Lw0ms86Pm5qcP1Ndyln+I8Sr7707OW312/epVSG4VL3R2UQxqpffflr5HnKPfJHHY889Jj6N5hb4OhcdsFs33sTpydj6n4vhB2RMTI0qrGsZPPimX7mK7YyASw5Je7abTNcjPm9L86zbLSfMK4uqbhE0ZWtPdIFletCuqVq1ZAZkmqxZGuBrAs7R1bzwtR5xAdaM0w0mVUZOSaCLeQ2b8GSLmbbI237JFGALh3qsMCO7Xt56dzT2MsWmI0LuFaemdp5+kqjLC40iH2fRNkuqD8jmxvoOmdOnicfW2os7LXazBRmybuSZSeqVgNfhDXq+pZ5nFzv8n1CZn/na/tSt+fnf/G/47/98X9+x6/J5P2mEge8F3QLn/eAS0XPNbsPqEiATImQ8MQj7+yp89aiR5BzXTTRqsqMVNd48dl3vtFkcnNxstQzJnwsIxClZlc2DqLEEuiayd59+/nffvcfcc3uW4iThFgTJQDs2rmDZ555eskPJeXsWWnDZgFzOQnXS2LsckH9jHw+r4okOf8kWLWL94ed1+8nrDW59u6dPH/sDMNFg2+dX6Bl5cmJzBPxnonRrKVWv3BpEgPDtZlvemwZztNOEubrLWiG7FoxQijO3fmUfMdQI6fA0GjUmioFXnhalfECWsfj/PQiy9b30hflmZ7rMFAuKCfVnqJNi1hFZER1jYbZIGfl6HR8ek2TsV4ZZSXMVBd48sIMA5Ucz/gJ29KU8xdmCOodvJbOxXpM2qjSFKl8FDMR1Jhv9bOu1yJh5CM5VQ49nW0Cdu77WSYunFYSfLnBj46MMjkzpZRt73Zz/Lgg400ZJdRJ2OQuZyp3ggv1FguzHYZGC0TtmE67qdILpHBFj+lEmXv3Jama5eaIIo24E5BPbQZ6S5RMi8VWlTQfUylYFN0iNhr9lrhx62g5h/yCi95nUDZDOosxDS3g3Nw8pUBX8TdDa9swMUjipMo+Q7Bpx80EQeaSrGxxUi1zjV8a1cr5uXvvHWrs9fTjH20BJDhxNEte37R1t/rdyqVb2XlkAZ9y35OXyX4fLvgfJ+646141RnpzssX21f184+tXqA7vBYefPqj+XbXxWuXwLvf2oFPi6VNH2Lauh3OzosrqY2FhhvLACv7Ff3iR8RW9BIouoWI5L5eIagNtiPeT+F7JCEpVEJmHU0aXI9VNnj1zUvkliUxe9g2ascRMNR1021SbDVUmCb8Kuc+Y6ue1poZJauMYWsxMMIUXpdh6KYutSExG+kfUerJkHK0WKVETqrVI4nkkjoeIzhmLQm+PKspWrBnjzaNnL78eKsJEF4+zGM8L2LzjJop5i0NPv30Ee6nokeBi35cxsfxNGqG8bRrKrf7ZJ75/VNQldEddXXTRRRdddNHFTwy6HZ/3iL233Eut3lFvC1H4B3ViH/jczyGcL/HWefjb2a5gz7671Xjsuhvu4vmlrs899/8U3/5G9nlFSkskaydR5oPKA1MIavql3U/mASS7Xun2qAMomVCR7JhC4tjh0OHD6uPydVs2buHl117P2oC6TiGfOd6uXrWK3kqRKM0CMmUUl18KWO3ivUOI4y0/4Xe+cYRf2r2Fx984TkX8LpKYnLjuiC9PsmTM1glk3qV2NkNDRYqWxUsn55RCsDxSwTA8Ts03uNia4unXPdb09HDzllFuWDvEG6enWPQS8q6Faccq5FLOgeZCQDsIMEKN+kJHeQA5El5q2jTmfLV7k6BLUXwZjkGnlah8n3Oz8yy02kRpRsTe2l9Gay7wM6t9GvoQf3p2gpuWj7FquMhiFPKd82eZtK6BxrTKKZLu0keJl566QmS8cf89hJqJa2ekZs3+pEeyMkqSkVxK4vejh6/SbgVYlzxodH3JhT1lcDRP2JEEI3BzJkEa02zWMLUceclls1IMp0DJsjk3vyBRThRtm+H+HhamJQMqUOaWQRrh6QYjFZjpGOj5FsOFHIvSRc4nTOCzq3eI2myd0kad2hnxRbmyrxUSseCK26+R7fo1fclJOWsH3XLbfTz+yDc/llfxjdez+9QlXLPzBl5ZGolt2X49jvXpXJoefuhbl9/ef+NvfqCfsWHbDTTl+ovFrlRndm6KnNXLqSm5T2ssLM5Tq1X50rfPMCq+TVHm9K8g3RUxLxTjWzEllbDUvI0tql6hO4hRbZrlvsm/EmwtR1+UvVkHSIwyM8Wo+Obo4hbvnyKK+5eMlJZce6Sr2b7ISH5UGkAq/+/4kWOYwxUc0yGUDnF9gWV9A1RKZWr1ujqHlOoylAlDoEa3sobliw62kVB081SbC+o8FIPDS15AM9NTbNu1jdZiS6llraVx9s233ae+7pGHsonLJbQ7vvo6QxSQjo3pZKG9Lz733juWn86z61OIpx//Fhu335I1GjWNV174/snHX//qn6l/733gZy9/7NBTD7Jj9+1EpNx40z08c/Dbl4segVjix7GoQK4w8+XXycGX9qWmZ7JP4fdcwgvPPcrmHXsJo5SVA30EXoeHv53ZgG+95hr180ROKheOU8ipFqecVtOz80zPPZM5pBoaxXLxI3jVfrwhzttRrGMHMSs37mL0/EXuXOfw1Ll5ZmVEVG1gabYYO6sCUw/EtTal3gyZbbcIvQg7p2NHKYtNkWPGFCyb/nyWtlxtJewcLKP7AYvNBWHxkDZDSjkZnejktZxKMZebZUeCoQMPr25S6NUomTpzzRaabZF3deJIZ04LeKO6yC0rRnjt4iQ5y2LNUC8XZ6t898QU//y6At9u1KgFPpVUYyLSeeP8JNP0Y0/P0Yoyp/GC+/GNIZ558urW9R13f+6qokiK98NPZSqO62+6VyWTy0kuhp3CiZPne+ipq+XHPwxkVG1qkgad8MbEDPNhkz47T6hpLC+5NDo+gamTy+UUH0iCPSuWhltLqaUebmqRuFnYbRxbRJ2QqWpdud+WS44qptuhuBumtAOf3l4HIzJJxKDSjDl3BlauM+jPuYRpQlPXVBF0et5nstrmxoFBFtOLyv5CFrXd12/k4BOvZOqpt1ASZfN260038OhTTy2pqz5ZTs2lokdw5NXn+FHAn/zH3/1A3yejPbElUX60wruSsaNSNslnUxXFkM/34En1qmpS0WbJeiCDLjWtVOe43Lfd8ZRNq0eYPVtltmgx1oyZKqylMnWESI01xUAzztIBVIEbiVASPTXR/QRhnvYvPsVD9hdYEzevCh/WlkZXtmPw6pJ8fN3K69TzkM35+vExFswETewzck5mRynpARLJI1EsMsJCsk/bODlHydaD2RTLzO4fiumapIyNL6dZbRMkbYiF45Sy6/o71HjfWVJQvxUyuhX+nDJ4NCSoVVSpkpzwAI999+oi6d3QHXV10UUXXXTRRRc/MegWPt8H191wQCmttl17gK07RcUVZ/44Kazbtl/5Ygjhec+Nd3LTrVmO1u13feby99/zwM/yra9f7T8gXgVSxEq35/a7P89dD/w0937m57jzvp/ixee+y7FXnySXc5TCpeCaFHMWjmuzec0aldfkOjbG97SBM99C1dBkfnGRHXsy6+7Dzz2/pELJvDJOHj+rYhHEI6O/P6fI0lJx23aB06cusPemLAqji/eGw08/oXYcXgj/r3/9ZW6/4TpSJ+W65WUKifh6RETiT+F7eNGSB42pYchGLkowkhhHl84NjFRs5duzdrDC8sEKzTTiaG2Rl6oLzDQD+osOTtFgarYjLGnmFjIFV0HOB1dCUQMVZNoOOtT8ANuxFKl6rL+Yef7EGiW3wHTskXNMGpFBLU7Q7YRYj7llWT/fbfVyvDrL+p4yBcPm5Wqbh2am6clfT6rZOJal1Gm5YukTO0UefvCrl9/udALabZ8de+5k1w330vFSFWLq+TGdS48gZd+td3+oN0wJZSzkLFYuT1X2ntcJKOZ1CrZLr22rvLa8Kd2cmIX5Dq5hUOl1seKERqeFi02tHrHQ8CjlHFI7xYp0Or6Pa5jEkmVkxnQsIccnrB0fxAo0ji2Iz0+KHmtc9APO1z2EZ9qn69TSgNhLsZ0lWeiSwsa1K5w/8QIT586obpUKjpTxFglPHHqas4tnmaxOohvpxzbm+kmHRFNcgghTpPtzOYxXchQlGFgMS8NQjSJlaqmyzITMLGNrRSZOVJxNrmbgBT729pVsp8r+6A1uXfwWmwebFJ0Ga7cY2P4MxAFEPknokQSe+pfIw1k1xArTZpV1BkOUoEuZkbKeyLkuKkrXtLl1KdLoxWcfpVhweePFg5QLeVa7Bc698jhHX32aUtEhn7Mp5h0KeRc3l8N1XIb6BpTAQsbsQqS2RJlqOZiGiWFmuV7iD2TphWyUp8mILJt6XKFyZ9i+a59SVgtMI+tAS7dH8s/ea7dH0C18vg/a7ZBWO1KmhUEYZw7I6iUTFnrKsZdP0pb8kSDm4GPZ7Pe7D31NcXhuuOU+vv09Rc/OPbctFSHZy/7dB7+iTrBvfe3P+M6SEeLNB+4j79gUiq4ap718+DFKBYfZ2pw64fI5S/F63orXX3pajcDE/E64BeIMu+Ga/fiRKCay3yfjsS/+8b/nxWe/yyuHH2WxlqnH5LF8+Qjzc3NKGSJz1V/41f/hPZ9AP+l4/umn8cOUDQMVXp/x2TQ4SE/F4YGRPgbyJpXIY3dfnjBqUpeFreLixYHK8BotFBnt6WE4V2Lj8mVUCjlyls6R2TphpNFqpUxMtkhLwh3JQgtXD/fQiWLcvJmFP8YRRiotaZ2eviLlniL9Zpm8laOnYlF2bKaqVZqtFqYWE5miImvQ9sU1N1S8AEfTGSikXBT36FbC5mKOh2cucGhqinx0HeHCCZ585EGeOfgQTz32Tf7oP/wOnwaIKkjckMWocd26ldliEUdLxX5m6SD3cSc/+qH8vh3X36K4DlLk/I+/cAvLRiN680UqeYfty4eZb7V5Y0b4Vy5FccvWY0zbpinZTssH2LNrMwN9/eQrsnGJVYvetmQkZePFCU0v4ZoVA8w2m0wEVUqmgWG5NNsd5qpNdqzJERo6vUZEIOJkI1XBtp0gYX0+p6TvieerxUsFYGoajz/xLMvXX8vK1WsYWN6jJMaSzC3FT0rA6uUmt+yXEONVH8pr1MUPhow15XqVUZUUyZKvmPHCpOiJlCJPih8l4pWRpdihuCY51yTvZnw3UTwWLBjs7bDlyGH+yvnXWFFfYL4yRkHPsyZN2BXMUJie4eXjbRI/JBET0zAkiSS7UUhAAd7Fk/Taw6yKp1h0V6nzWzbJcp6ozbQKyNZ47DvfuPz85V4gOPz0d68ywDz89KO8dOhxjrz0FKeOHqaYc3GcHLbjYtsulmVn2WESnmoYKstQhZwaJrfevFdVOlLUvf7iY2pzL0XRk49eXYyrseyS/F0KpsNPfZvnDn5DFYSSOfle0eX4vAs2bLlR7eYUMTASmWV6JZTNFO+BFEoezbTO6rFdpOmtiiQsXy43Kju2uOWO+3n84SsnjMw8JbxNODc3HvgMzzz6tcsFzyU88eg3ue32B9Rs9BIe+847R2Fcwsbte9XMs1Aoq1l9LP4+sotYIjjKhbNzx07FhZDfK0WbSAdVLIam4fsh0kQS4mPLN+np+fjTr3+UIcWldH2+8vI5/vV/t5cvfvHbXNQido/0S4OH3eO9bBsf4tDZOc7Vfab9gLyj0bRNBkoWQ50Y72KNfCVHNQoYLBRIQ4N5s0FSE1ffFMfWyYlrc6tNj+moFOapaltuUZQrBcpFC6/TZGC4hBHpLHptOkkbxy7T57hMNHzCVsJAn8vZRkf5SA33F5hoddiUr3BseoFN42NsKq5holrjq+dPk3QGuW4kZdWqG4Ar5/GnBbKAy0Yi0uVqNNTuWaBSoeXclpujBEBaHw5/RTq+BVtncraB573JFw8dZ5njMpxzacYJM402cRDT31NQsSCu62AK4dPQeOHcND9zzWbu2Gzw0LmzyrFZ+Fy6ZdCqeTQbLXpck95KhTVDAROzVcXJi+2I2XqTDSN5mm7AQO8YeTtkJoByIguHRr9tECU6q/qKzC3OX5Y1ZzEQsrBki0t1sq7Cc+VeZugh0zQY1z2OTlSpuPUP5TXq4gejIF2+NEut99QG5JK7vmyosy6QnL+WFDy2ra7tsmtzNozYlINQl3iilEOLMbcIWblYoTIySH+i0+i06S/YGDmHqqnx2pa76H3jSSLh78RZ/0STsOQlu5OctoBvuQyFDaYGehn2NDxkTUgyx6fUyMjvHwAqQFQE5xJZotZMORuXrAs0TRVh0oWUkNMnn3qW0ydOkuvNhBOKu2OZ3HHfz4ol2uXJiXijCd9V1uFLLu4H7v48jz74FW7Yf+d7fm7djk8XXXTRRRdddPETg27H5/vs4qUozlrGS6FsyhxKdpHCRk9YNb4JW1WdKUdeep3NO7ap71GGYaK4MK+W/T6/FBx47d57ljJq4O57PsuD3xNu+sj3zCrv+8wX+ObX/pQHfvqXCPyYVrtNEGTzWPW+76tZ6LPPvUwiMlmxo1JGVbHaEYoZ1eEXXmLnDXer7o7sBkV6K0/BsAympy/y3JNXpIAvPPX9O0xdXA2xKhR10bkTFxlev5n77urwF489jW4LJ8agoUtrG27d0KcCA7/88nmmWzFtcWjFpO1oLPgRyy2dcxdn8MNsJxMWZPYfYdV0xtb0EuspPTWYJyayEmwtplwUB2gNPdI4N9uib7QHr+7T7DSxcjatKKJgWuTNiJW9efqKOToLHgUDCrqEl6Y4ZkTHSFhMWmwqFbk4lzA+2MPZo5na5//4t7/9qTvkwr1rtMWkL8unqzfaSqEo18GmTWt5442T2XWra3znq//pQ/u9pZzBxvFB2qHIbm2WlSoiL6ERpOREbmPbrOgvUG9G1EVCHPvk8y5nq3WKRQc3P8TIwiwzXshwLs/oUIWFOCJvhKztHaFvoEL/TI2m7ZBzNK4fKnNmHg5PVVmfyzPcW2N1sY8L0wvEcaj4YaW+EtN+iIbNtn6Tpy7Gqtt12y038eDDjyunXtlxy2uR6sIrg/lmxP61MScmdN5sRNy0JmbX3pt58ekrruRdfDR48fCTl98eX7WdQJSIaab4VJYIS/wsUUL1FF2KO3Zwa2GSnekUp9IBTsx5ythz86oQc7ZGT87FjAPGSjZNM1FmtNV6A3vNMvqfPsgLF6qUxqyMR6QcF5LLEwhyQ8SdDhVcbrdPEA5bpNM+XjvrDAqfxvM/WChx1nFN0EyTDevXc+LNUyonTtRrogxT9iyKbaFhiFI1sSjny2y44W5iMbxP4OFvXk0XefXFg6zZfMPSGg3X3/IZ1e0RNNs+azZex6ljPzjctlv4vPtRWyIJZieikAHlRioniwqJU91IQ8mET58+y5rNmxHfS5mdSiSBEWcn4DtBHeslEtn3Fj1vxa13flaNuaToEXz9S/+F/Xf8FB1fiG/SipT4g8yRU25q6ieKY7kstEtW5pes38X3QMISVcK1menl1d8jLdVPqWfGjwpsiaMw4NqNq/mFf/jn/JvfuJlfuSvmm08fpZPCbLXKgufRZzjsHOrjjrUd/uur0xi2xbnpKmKaUSGPn0SKrJxGIneNcMUvJmcTBR2KjkUjbXE2F2FGKVGro/4t9+bwOzHz1TZlK4+NTSNpojkaZs5hvu2hN0Nypk5Lb+NXQ/R2im7qnGl4DFopE2lK1U95fbrBielFrMhieb7AxZwE3346owPE4FzWCDmHV69cpq5B8UwyxdvENtW5Lk5YEuPy4SGlr+jw8zevYGF+mptGBzg92cYtxIxXeojyJaqar8jrlpHSY7hqYzTlVelxLBbrHTpJxJBbom8sR9zxVKitH0XsXzbMqtEhLtTqnKo20eKImTDiO2/OMNcIGMk5nJwPWFHW8LUe1vVW0BseURIQ2DrLHQuvGlPvSARtdt95+DFZYBNl4y+naDbOhmnf5XO7DQbKBo2WzvEFi1dOH2bYWMbO629XQaZiByAS6OeeffRDfP26eNsZpTagUgRkvm1KEi6ba9em0pPn7LKN/N3kMGMzHvnRHvb3mtjFHH0FCyMIaaTQXylQ64iAIlAp5YODZRptT4lWHpqL2Le1qOwyPGFtSByFIdEOBrZpUHBzDI/0MTnbZGvtHI7l83DfOPGin43D1PdEbN6+X4ls8j2jPPXQf3mvl4uCjLXcpfuIGkML4iW2rHgJ6TpeO4JVTfyOSxgOEqeRCvx9KyTUu9H0lsJME7y2rzhR11x/pwrm7nQ8WkuO5T8I3VFXF1100UUXXXTxE4Nu4fMuyIi/V97PwuGuvC2tumxHmWVsSQUqbTypjknFajPhyUczI0HB/gP3s2f/PWrMJYRpMUR8N+y7JZOVS7fnhlvuZffeu7nuhrvV97aaHoEfkCw5cWbyv2weJz9XiGRCvpaHkK2lut+ze5dyDBYJtfwRB26+QbHpxe1T1AGPv4U8ffd9n/8hT6mfPDzz5OM88/jjfP3r32HUjvl3//UJ/n9fO8rP3nOAz911B/fcuJeKaSlX3mePzfL7XzvDjtGSys9qNDzmp2u04gA/ydQdOUdXhGUrNchpJqViTo0qKqbLmnKe/opYEUgLWaeuRywEHdW563EdwtinWMnMxCR/qZ34XPQ75E1HOaIaobSvE8YHKvT1WNhxQL9hKkdmL9R54fwsTT2hL2/T32eqUd2nFZeciJW5m7D7gUo5h6WZisgpXQs//nC6mdftvV3ZUDx25AL337OdncN9HDtZJS8k4iil6fnkcgVuXLOMUm+JdatW0FdwWDPSx+BgketWLVfj0JiE3pxDn2ErI9PTs3U2D/YzU4to+AHVhQWGyw53jg3y86vWcmD1SvaNL2fTSD91I0DXdFxiHA0mgyqJrTPR9NX4u2AbfOnRhUzNJkZyIlvXUnQrYe2uPbRNg0Y6xV/Z6VOO6pyuRniJj61XiGs5pSSSe8jKtZvUyEWk7/v33/ahvH5dvB0btu5R3QtlMbD0UM78YmVSdFne5/Df557HlYDhnn6cfEmt2LvMmOFWmw15g/E+JwuldvI0vUCJF1KxrujJs5MW/9P6SYobBhjrMektmpRKDk7eISeyc9fkzr6Q8XKevBDkdRc/sPGbc0ptlkRZ5pvX8Wm12jSbLRanTnPNrpu5/obbf+Ahleclf5usOYm4Tas1U2NkqF+dxzLOE6rFnmt3YIvoJyiwddtWtYYmosxME26984phaZwaSrWsjBD9kI7Xod328DrSBYqItZTAl47nD0a38HkXpHK/F8b8UuptluqWtSbFW0H5HCyNw7KbrIaWakShFCVS/Fz984T34/khvp+F8gmu2bX/HX+3vzRTvXbfPcqRWW5G4kIrMsTp+ozy35H5a1aMLcVaLBVkLLUPM4dnUZFJWncOseu8ZB/R8TJ7/ZcPfVf5CQnuuOenOHDX52h6IXuXPIm6eP/44pe/yb//v78GWoEbf/P/4omz8+y9eS8PfP5zrFg2Rn8l4RfvWMONKwa5f8MKvFodWgmTszXO1RrU2m16cy471gwKk4eJ6SqpqXOu2WGhlZI0RKFj0fZ8FttZknJqK2Mg5SSdxBEdT8TOCW4xpc91cIVgZKaEhsF81CIUWXuacHq2SiuJeW2uSaAl9JVdRp2Sks3WvSamNpDxAD6FUGrLJbfhE6fOqL9bNh85N8fs4uKSG7Fcvx9O4SOxMGrU1ZcjbXb45utTVByH65dX+Hv372bPmlF0O2VooMT6kQFaslhJsdrfz7qRDXhRQjX0uOOaHSSOjmeGlCoFpcT6wqZxNi8r0WMbNBdCVhQc5cSNE2MaIm2ucT5uMai7GInO0c4Cz83OUQsN6g40OjPMRx0G+q5n3dggkSpuY6UUktG7rYeU0se5eXiC3WMiK3YpmXmWRTavnpmhPGTTVypkUQXi/eM4KjD2+ece48kn3x4W2cWHA7FIkU2IKnqWxlwi0a7kDGIjz85NRYbdAuOFAkM9eUYKFnMX52gHHtMt8QnrkPodRocHlTt8M4SmVeDEYkvdK6pBxM71y/nVcp0DyxLOmT2sGMwxMlBgoD/HUMVmne6p2J1N4/3cunWcNeUyPWlTqT6Vi3SSEAZi6ZJ5ZrVanorZkUL/xv3vXvzs3ncngVoXU6WsfO31Y5kMXdMZHhhQdJFLnnLNhqec6vMdk+KIjGmzEFUZU6skefHHu/8X0HRbcfiU0DpOCCOJaQrVWEwaDRf182i93VFXF1100UUXXXTRxVXodnzeBaraVBWnSEMyFvyl0Zd0dFQbWbk4L425xIMhFRMqIQXK2OnqnbLkdIkTpzwCP2L9ln202iHbduzjppvvuOprZbe6Y/dt6uDIiOPFZx/ipUPfVQ89LuJaOotzdVZuWK7GaxJYKWqzS50nQdY2lTBVnWazSZxmozH52U8cfFKRwnbsvpNf/39nih0JUn30oa/S8ULqDXHDvY19t3adnD8o/u8//Tq716/iscdfZ+j6/wcrekr8yj03U3Fd9m0cYdNIhb9z9yZ+cesyfvHaNezu72XyQhPTcKmUXHpKeR7YuJrNy4co5XMstjyOzc1zvtah188T+yn9pZwaYVoeFAyDwb4ChmlRbyeUNIc+T8OOReujUcqb9MmOqZWdyxNzdRIimkHCbN1TXkHHJmZppiGlsobXqVMoj/Otr3yNTxt2qzZ7gqHM1tLL572c8z09PZw7fUF9XK4JMU37MJCRpRPGxwfBNrE0nz2jBQbchOu2reXm7VuYm2+hazL2alApGizvr6jRg2PGNKIOQaBz/NRZ1lpCQRdSaolBy+B8p4Mf6rx2ps7eVUMs7ytAAZJmxMJ0k1V9fVy/fJggjpX5myQstbwGUdokMh0MbT2GczOHXz5FFAmxO1Ntyj1Kgmqrpkl5bo5et8DowDB9ScTkxXk0x0UzPdaN71oylhP1l8F//oN//qG8Zl18f8i1m1EkMlqF8H4LVsoFp4/f23CCewdSrhnrwS3ZuK7GhbkanVRT9/8hI+TE+QXOzgUEpoN25hTLJ8/Rk+oMjw0pn5+TpyeRWO1mbKI16vyLjdN8ZpfL5jGH9QMWy7eOsWHlgBrBnpmtcTEIyRdttuZsRYhXFGLxyYrFSTrOxl6BmPlGap2bmPbe9W9TY1M1rkrpKRWyaYSakmTrk/zNYmC4bHSIN8+cUsqulWs2MnW8tjSt0Fm1cpWiaqjrT71S6lW7/J4a52oJyzcsZ2T5EM5ckYXXT72n064r53m3k3JJ9ZSFwwmHRhjp2QhJ3WylkEgzAe1VsRGphiYGS4bJ1l0HlMW/HKRLNuTK0EmloktzU2TxOgefePiq3+1YBs8+9Qj7br1Pvf1WTBx/nImlt0+cKVPJucrETeR/fhyIuJfrd+/kmedE0peNt557/hVlWiiQ1mocySgtVdbps7NTXHfDvepCkZpJZPJRHKq/I5G46C4+MBpeRNNLue/uW9j5s/+Q//D/+Xl+6Z47+F/++Etcs3kzpTDkN3/mZh584Ti3bh3j5WOzfOP4NIdPnmfNyiH8FAb7XVpRgklCpyOcnYBD9Ul6XZeRQp7E1qgBi3GHXEuOf0yvaeGlAX4nkz5p8r6dcr7VJjFNepw8C75PLoQozVGLPFp4qn082JtTqqgztRzLe6Y+lUf/8LPfZcfuWwhDTd2U5Zy+ZMYp8jq5NuW6tQ2d55/80ofyO00VuKhxYaaJVihz97UbePGNC2wZydO7bjs3XruefyXRIFNneWZylpweKC7PaDFPvdZg5/gQ64Z7mW426XEcNvaMcSyax5+u89yRSfavHWFwUy+lvM3ps1WV5D7nglt08SKP2mygHLqnAx8viBgwLVaNb+XceTEljDi7cJrQF9ahpiaAap2RQkmH/qJGX7lErm+IuXMXeaXtMVjp4VzbV4Uv1Ww8LhECMmrp4qPBDftu4dmnroRby5qggkPlrFUbWI0+V+OihNeWhvHmq7hDPSwbXInmtag1GvQUxDrBpKVbRIbPkBEwNH+C1eMOk2aekeEc8cqNpFu3s3DqFYqDvXgvnGDZcJFlIwPYrsGN6/s470WUOg2ePFNnpM9hedmkGsRMNBLOL/g4VjFzkpZoZFnrljwMVYyFmXFbz7/51Lv+rWEgfEUxKBRejtA7ZKMiRZtBW9afJauYXD4v2mM16hO+3iWKiJzD5y6cU5EXAs8XBZeveD+6Jtw1YQtlHL8z9Wc4u3gBO1zN2m03cPK1K4G374YfibP8zJkz/Nqv/RqrV69Wqcdr167lt3/7tzMvm7fg3LlzfPazn6VQKDAwMMDf/Jt/821f00UXXXTRRRdd/OTiR6LweeONN1Tb9n//3/93Xn/9dX7v936Pf/fv/h1//+///ctfI9kiDzzwAK1Wi4MHD/Inf/InfPGLX+Q3f/M3P9DvFC+Vt6q4BDJWko7N2emL2a4qySpZqUJlzLVt2wZFhrYdhy1btoNmEkSayl0Svx2UfX1mJa/aeaaFbppKtfVWSLdHILlIj3znSiij4PY7778chHrimUcolfK8+Oy3yOVMTCOzH+q0Oku7X9h3/bVLJLqIeKnbE8n7YYQfhLxx5Cgtz8MPsxwy8aTJObbyIPo0K3p+FPDk449x8PHH+ca3H+H+u/bzyqlFxtdvYc53WHXDnazac4CgbyUnp5skqvuis355P+IwNz1T45GjpzkyOc35Rk21mCuajlUxcAoOWgi95QKmpuGkGmsLRcI0UG1oyWDqK9ksiodLkDJi2FQ7PvWgQ7Xj4VsRrqPR44hqK8V35JyM6e2xKFoOC7UWcToO0aeT2Cx4+fDjHHn5MZVd51jyd8i5q6sOq7TpVXjhh3j6yu+wLZO9y3v5B7/7DWbiHEb/EIOuT/v8OV48/DwDtz2ApWlszpcZx6C/XOLViSqkFtuGBhm2LJYP9zIwPkxPRXxUQjYMD3HL2lEVY7DDKTEcp1hBizAIKGop7SBmMQw4M9OiFjSZbi4wX5tn5br1nLvQJAzE50ln24YthOFSlpGaAC6NBHSNhlfitU7IQhwqrxOj5KD35nju3LTygTp5fEKpPOW1W7Nm+4f3onVxFWr1Nms27GTN+h0sX71V0R5kXOuYEnBrMJAzWVEy+YebFtlnxQzHdaL5i5RoYUjvxTYJ/Ra9Q70UgnmG4jbXjZhYzRZ1P2XVeD/NyQvUDj+CU3RZse8BVm7fx0BBprM5glyRVphSO19j4aVXqfkQh9k5VjMsGmFCw4/pyxc43imSc7PujrLeUV3EK9EVP8gfS1RWKnw1SZWnUDbSSyiVK7x54tySEhoVvJ155Mk9SCjVKQvVSQZ7+1VHrNP2ufHA5wlEsCEnuCjDlJpTz0azlkWpuZnS9HZWjQ8tiZF+TEZd9957r3pcwpo1azh27Bi///u/z7/8l/9SfezBBx/kyJEjnD9/nrGxMfWx3/3d3+VXf/VX+af/9J9SLpff1++U+aG05rJ0k0tuS9msf8XwcDYKUy26S1+fcPDpg+SsojoYJ0+eUk7Pgkuni2SkyIGTOkrGZoaMwTRdKbd233ifKl7k5v3wg19RYaFPPPJNbth3B88+dWUU9t23hMV99qd/8XJxJllOgZ1VPu1WS7VQ5Sb4yBPPqJbjJbM3+ZgYLCoPRmHsRxFaIlwIk1Wr1vHn/+XffLCD1MX3hRiIzTg+Tx8+qkZRD37ly1zYsY7tQz1sXbue0UEXX9d46tBrdISbJa1oyyFIDPJOkYVogUHDZTqMGM8XMYshtWYLTw+p+j4j5RKRoRG2A7woopgWWdR8FpIAI4wpF4oq4blpajQiUQtF6meN5l1ysU6U2pgy69QS5lrz6GaJOLraefzTiJcOZZuE666/nU5SwIt1lT6vpfHbxsQ/DJ59MjPyG7jzVnJ6xOYVfZw8d5HYMTlxsorfW+Ib//G/8Prhk8wleW5emWPPuMOK1Ws499oxothnuu1w+vQUvYNljtYmOTtXx8t12DY2iutFPHt2glOzdYYGivTkC7TDEMeBn9+9lv/47CnOd+psHxziZK2Xi6clZdsgVTmCUG+2lgqepbG7vKmnKrl62GiTt8uM5HNMBjELi0183WYiXmD9wEZCubmlkpqtk8+/Mydq17U3qrHiqy8fetvnbjkgjvCeGo1IFuGzXffnd0S7LTyvGGNpRXCl6HE0lf9WMXWGCgav776L3wm+TG+hjKPFLPfbzJ18k7hQYqTewIml0D6JmSacb/rMzkd0UoN1FZeBost8rU2j3iL6w39FedsNJDt2sfbW22n5OnFY4+zR13j95Cm2rBuiPFjkjTfPUjQ1Tjbr1Kpt+jSDscES9+Q7HG8XqaR1anI2hUKnuMTPEbXku18rO/fcQr0pxU6mLA5DT5liCg/WdSxSCUCVddEAT5RpYsOiaaxZuZITZ06rQNPJ6gWM0CE2IvRYZ82y5bxaq6msLlE0KwWcZF8aBqHXprEwx+qRtbx8+Ikfn8LnnVCr1ejr67v8/tNPP822bdsuFz2Ce+65B9/3ef7557nttnf2o5DPy+MS6vUsrC9z0l6SgCsSZcb7yTx8snmkCiWVT6RZeVQu9KqTQnabynpcuAZixy0pvHp24EVeqpFJY8VhWb5MXJUljsDO9/Pwg3+kfpcUPTv33E6j7bPt2gO89sKj3HLgHh5/NJOfC/7iS398+e3HlzpDP/WX/gYn3jymkuTFnlx4RZJ8p+sG61Yu480z59XXyUxfnqyS/Mrfouuq6Ln3M1/gW1/7Uw7c/XOEgc+Tj3bjK35Y7LrhZprtgHYhoBN4bN22kWanxaAW8syrxxmvWBybWWR5j8NMNaBctFlIPGTdtmLx2AmxMCkPFbH0hP6GTi3VOBO2yaUJtniuSKqzzOQDcH2LoKgrJ2jZZfXmczgRTKqIA4tASM1JQj1JKAlvqOOTy2u05gOsSkwzdaidcVm29ns8GT7FeP65LA7myOGP9vcsiPQ2CfiZ3/kye9IGu+7ahnnqWY5cfJqFk0dZ3TvAvStsduwaplSoMLc4zbwVUx4aojC4lpWjQ5w9f54eu6zOg0Kxgu43OHnkdUb6XV6cqbO2UGDlSD9Ru8XLZ2eZmG5w9twUvYbFnD2GGVQZ693A0foJta1aPjrOiZOnl0QWstxIUHF2jUsHt2CbBI0mPbrOzEAJ3dN4aapBbDYpaCt44rmvcP1Nd9LyHf79v/2n7/h3+2HI0ddeUAvUzl038OILz1z+3OOPZmndghv33fLRHoAfIVyzc6+63sU/Te7DcRBiE5OzJHBYI29qPD1j8wv3jzB+ocOvjrao2AepL/i4g4aKjSj2l2lXY7QLiwwNOzT61mG/eZbTQUo+CShrBTaULYpGSjFnsdr0WZjxcMpFjNefZebYEYY2LKeybTuL0xNMvHKCidRmeyekpEds37ocv9pi9TKdLz9+lOl2gl0qsiufsHs44VXb4asnXYYcH38pLUC84uYWvh+FJOvIYKXYtsbrL14pRox997BU9jC6YTWn3pgg1hIV5lwu5VXDobc8gB95WYGUJhRzBSLh9SzxoRQxemnNle878tJBdl5/C877aPH+SIy6vhcnT57k3/ybf8Nv/MZvXP7Y1NQUw8PDV31db28vtm2rz70bfud3fodKpXL5sXz58o/0uXfRRRdddNFFF58cPtHC5x/9o390me/ybo/Dh6/ewk1OTqqx1xe+8AV+/dd//arPXeK1vBWX3DDfDb/1W7+lukeXHjIqE1yKvM/UW1mluX3nZqWUUGMww2D79k1qHCYP4cO4tsHx157CtXUMTQJCY8XUl/ZeoZgjX8iTcx3Fn3Edm43r1zE6Oqp+pmSNXPo9lxBKQFwQ0/FDrrn2wOVuz013fIbb7v0Z7vv8F97295w9dUw5O/uBr0ZcqrNkGjiWxdDYsDIoy2SrmbuzrpQcpmohCqTbI2i3fKrVNhu33cLGbTexYes+1m68ntUbrmfNxhuUHH/rzpvf45H+yYYYUgZhoDhWJ948SU8cEDWrfPvENLYG167uodbq4AU6U56ndkunpussNH1s12RFucSavgqJqALTmHnd50K9wcqBPJZ0bXTpPBoMmDZxO6Xi5DFtaQWbFCxH8X3mog6Lgcdc7CvOWbsdYIYhXtJBz6LGMPMJuR6N2akB1i7TeOLhKzv5LjJITp4EfG7oLWONjVDXc1RWr2d0zOWmLcP83IFVbBg1yYVN/MUprJlJhss6A6KumTnBzMwZVq8a53O7b+SXfu4vkx/bzBtn5yiZKQPD/Wwc62HVQJ5ao85U1SNtp7x+pkpFd9k2NsaIjEHR8aKlLCVxq+4vLUl8s/evvWbjkhWGRsExaPaPcttKl50b1zBW6aG3VOREe5GSXWB6sqW+57mD3+H1Q1fzCW+++QB7rr9J3T+PvPr85WDlpQn+O+KZt6iWftLRaLao1drK9TiNAopWwnAhoaeoceD6Pj6z2ebJn/P5H3Nn+I3dDbRyQH1iFjdX5FRHTDPB9VIqRoqbelQXO8RnJ1nVY7KsYLNmoEQejYlT8xx7c4HTZ6r4mAzbOsf1Hhqr1qkpw9Ennic6fY5165dx++ZhVpcMphptdf2P9Tj0DvWxfO0K9uxYy45Nw+TtgLphULbL7B+DjetaSm1oy5jKNFXHZur8uweBvnToMfJ5i2LOJJ+7enQqXUhZU4Uv5MYd4r7jnDotnJ+Yqr/ImTPnGO7rZ7h/xZJ6OqVSrjAzObXUAcrW34wyIurNbM186bnHyTmioObTP+r6G3/jb/CX/tJf+r5fs2rVqquKHhlZ7d27lz/4gz+46utGRkZ49tmrZWyLi4uKQPa9naC3QshV8vheSLEQC3E5FGdIGUulHD1xnLPnJ1i5bEzdDKIoULEVwv3xo4CTr2e//4VDj3DDjbfx7DOPsP/AfTz56De4+/O/rA5R7Gk88u0sfX3L1ms5eeQ4lrqhaLj21YdD2ooZsUgnSlKuufY2DFPH98SpUuORb12JxLiEIJBIC0lgl8ht65xOAAB6/UlEQVSCrCCTMRa6QaPmqWTcWDdUSF3m8yOFm87ytesw7M/w7OOZb0u93lIW5TK3l7uoOOMKWU3GZtoSSVsuhA1b9ytOU/bQlF9RF7ytgNWTOCvAI42f+aW7+Zu//a+pVEJGx1fy4olJhko2BRzG+vL0uTmErjUrvhplg4r4siQGU1FC2wwYLOdYbpbQAxllamoMMTJkUe00SHM2peEcoZmQdhIMu6BCD+1EY0Av0CCiEwSksaECTUUWWi7bJHpAf6/DyNAyarMRhvYjOwX/SCFJ036asuinPHRsin/+Wz+PPjzIxT+do2z0cHFqkW8/M0N+sMSezX2MOzAtY85Txyj6KZu3baPpGwTNDg/92X/izeOvEVUj4sEK1dMXuDZn0J5uUK+G2F6VfKgxaPWwrJhjLgjRkrOEhR1MTp/MNOuG8C0yybGKBxC5/0tH1KKQk4DUdsQdpZOUiiVeOXGBFcIfimL+3Ys1VvSu5PWXv/Ouf+sTT7w9oFQWnRcOXxlzdfHO2Lhll+LMxJGvRlsDjs4LExf55e29/OyyhJ5cm6hoYRWKzKYGnUqBM3FIf26WjTmDnJ9wbqaBszKvgkdNN0/d86m3GtiGQ9qKsJstnIE+Wq6pxCutxRpPzAYUXJtNuTazMyF2K8RZOc7okCZaG9zYZ3NvnrhS5tSZi6wbKNAzOkY9MSj1F1ndqzOaNzhVj6gUi5xrB2zwJ/mL3BArtTZtTzx8EsZWX6PI/rLZf+O1t/O+3olrc9f9P0utLvE6Ej+R8OaxC7TTHlZsnyYftjly9Awtr06hVGDy5JklQrRJf38/58+flWVQWcgIfzWzARDrhivNgkcfee9rzyd6dxPJuTzeCyYmJlTRc9111/GHf/iHb2NvSzEkJOaLFy+qLsolwrMUNfI9XXTRRRdddNFFFz8S2zrp9Bw4cIAVK1YoFdfs7OxVnR7B3XffzZYtW/iVX/kV/sW/+BcsLCzw9/7e3+Ov/tW/+r4VXQKRqksYmnSMVIicbhIvdlgxLkVVNjp7441Tijwqo6JO4+pxmnR7BE8++k31b96RFp9GkF55yY++/gJGGqkwN8PSqbfalz936+330+r4ShKfJjrDo8vU62BkzSEOvSVY9K2Q5yvVfzZ603nlhccuf05Y8PJxUfeMDQ0xOTN3+XMnjwtRMuWaPfcox81my1NOnaIAE2Rk6UREP2i6EM0yNYn81V6Q4FhCoNbYsuNWpUx76XA34+cSMkWdrsy7+gYHaYYGu2+6kecefowvPVpnz7WrGO8pqbDSydOz9GwrYOUcNpRzFEwDVzKiBkrUOnVYjKg3PKWemWt0sBOIHV2ZzyWBzUClSC6f4IQmOctWuV31lqi2NJUtFaZt2mZE2IrRwpS07JN0hLRbZ3hkiOppFz32SbXK+75mfhLwyuFn2b13H80w4Qs3bOCxY9PcvnED7UCjbgwwQczOzT6NesyCZ9LTP8AyJ2RwZJi5logJIjYO52HExPE1jC0refHCPBfnmvSnCW94HtduXMsqt83ZszrtngqULLb1L+cbJy/gNWfZtNnmpYtLdhupQasVZWIMJcDIZMdZlmDC3p1jFP1XmWxWSJJZkthjXivRTH1K9mbg2Cf9kv5YwvMilSXlaCnn6z4bb1zGkf2S1+jyX6c7hPMecaOlOu/7V+apXaxyuiNGhgGxY+PqOuWCw9nJOXpMg9APcXMuESEXkx5am9cy/OzDLAYhNT2llkqocC9uZ4HzEy2G8iaDbkrDNim3mtSPnKGgG2i9ZQb9Bn3Lennl1EW+80aTzR6MymQlBdux1dow688QLC4wXw/ZMzJOuydP9YjH86dj+gdiWr5kAvq0DYPlq7erCYAorHI5h1dfevptr8dnP/8F/uIrf8r+2+5XqktRMkdxSp48518xWHN3nuopn/Vr1quBrawlWmqo7pA4s8v7likqaEMlJ4hphyI5f7+564964SOdmzfffFM9li1bdtXnLs2dhXPz9a9/nb/+1/86+/fvV0aHv/RLv3RZ7v5+camMuSQRVfbiWbYohpHNHuVgyMEWqd7rb35/Gd2X/9t/ftvHhOkfBYFSgsnC+PzBP7v8uce+e0W2nj2PA8o+XJ7Z8MBy5f1j2wbl4jjf+vr/cfnrhPkuc1BDM3jlhavn7c8/95D6d9OOA6roka+TgX028hKPH9RIbeuWLTzzzCFV8GU/L71c9Kh2oxQ/S4owKQ5F6igpeZohJyv4VsLWHQd4/eW3t8p/0nDN7ptptFrkTJ0/ffBx/vF/dxtzfozZSdm2aoxWEHKuHrBlZICvPXkaemz2LVvJU6dOUxTFT6IjBswLWoCpOzhRh0YSkY912mHKeKwzPt5LrR6gi9Nv3CZpmfRGDrpvcDqNODXXIF+0WNNfVBygZrWOZcYsxhrpXEKvVqJs5zj5osaK4YYKsZSE6C7eGYeffoob9t3IfL3DL/79/4vpn/8cQc7l/MQcFTzWFhN6Roocn62hzfgU+8pyoRB3WphajppjoLsFIneYShKSD3xiA0QBXAgTZharPDbVpJUk9Boxj56cYltvCdKQ+XabvqkJUgkgxVA+TmfPnlZSdLlnyWISyvWooHHioslIf46tI3kWaqDN1zk4t0ifk+fMKYn26OKjQCg30zSlYIPeW+K/XJNw6rsNFlb3cU2/ho/NpBXx5kKbr73Z4UZSckUbtzen3NXfqGsMpT6TjZBDDZ9lRsz+cQvL1ZkSp/6z52n5McGiT8GxMJKQaKFB39wc86nFK3qerXmHojeDmVokXkz10Bs4K4dxKham+LQZKTfvWsX5s///9s4DvI6rzPv/qberd1m23G1Z7pZ7772mQ0ggBEIIgaXsUpewkA0skGUpAT4IkFCSQIqTuCS24xZ3y91yb+q93H7vtPM951xLtuIS2YktSzo/P8dz78zc0cyZMzPvvLUWRw4UIap6cNoKscziqmTBsEloCnqR5YnHXKMJxiAZpyoisEsyK7vEhBedFt6OjT3qHqLRXDtXgQo9lO2b1rQqZEqzOvft0xsV50SIhoozxcXo06sHy5u1b/d6jBwzC1XVNewZu+/ARgwcPhUR+iwisSKnl+eamzhpFiueenDv1s4h+NBcPLR9GFQjtGrVnVdbiMPhcDgczp1Bhwxnvx1QdRx1NqYOXLIUcwKmUVe0xRI4CVBlETaVSqaxHCIfxqIlKy5O78Ezv38LNHBMEmI1TGjm2eth6DTjsg7LMFFRWXxRpw3UNjZgzLQHMWP2MgwdNZ298VGoC9SY8a1zF02cMhcjx8yIZeI0DaYypHmFju5/Dwf3UH8ogeWJObD/IKvXFYsyozEkzZkyaT0fhWnXKFQFSR2eDRaRRrVDBLpJoGkW/AEdffqNQ/7giejKUMdj2s80l5MzNQ19BnZH6dnzGD6gOwx3AkRVZA6w7vg0FJZWoV9udzT6g7ArCs4F/DjaVI29tVXYX9eImkAAjWE/ov4wM3U5JUBOUiDRseqQkO1woLIxgnJvCPsb6lEs6XAm2GCXgWggipPVNbApHlaQNBhwQ6vNhhyIQySsQgp70DMjEaqkstwv2zb9s7277o6GlsLx+UMYlO0BKTuIQU4Vs/qlYUl+CpKCYSTUFWNCtoT+3Z3o2S8LohmBR4hCaaqE6q8Cakth02sQb4YxNduDvm4R9TQpiUtFj745OG8RBBQLPROdsAsWDtXVYXBONqb17Qd/fail9h594z20dwvT7tppJm45ljeM5hKjpnVPpAJBexzO+hoR8Achq06crq6CZnmQ1/fGXQA4H07fvJEsWz7VojtUCQMSRagRDUJCHDNtFVYGIBId3RJdGOGmyQcdSEhT4abPHaLBWx9Cep+eoCE3dRGCtypCzInY5pRhp07rTSVIiVYjMd0Jt0OCJFsIJCeg1OXBmdR0OIbkwsxKQ6NuIsnrZzW2a6p8qDtcjoSMJAST09CohWDzuFF1uhzB8jrmGJ3lttAtyQEhGkaSXURyWgqykt0I6CaCugS7YMOCgnTE22kOIhq5HCtiygpv0wKmEQ3BYATdew5G3uCCK/pl/sXnH2XW/GUo3LEBB/dsYi3O5oEECf169WRFvqm2h2JTJUSjDS3PWLtKKwrIsCk2Fhm9f8+2lm1ue389My+2hQ6h8WkPHA4VB/dtRN7QCbHiohcf8ixaShbZQDy8/31MnNK63MT1ePvN1y5O/8kaZejwCcxOuW/Ptc1C1KzEao5dDPGneZoKLw6My1l01xdx5PDei1mh5ZbSF81s2/IOm+YNngyN2bV05jU/fMRUHNi/GYU7Y+Hyub3HsL9Hw6+pTZWmF6dhkbTwas+ePXD2zAWYLDM0tX1ZzL7LTIK0SjYtwEqDvwwDEcuApksYMmwSDh9sW0bNzoZ50edKoMUzLdrnJk4fO4IzWhinq6OY1isNx6vKsevYSTRZgBKNwmuLsAhAkUblQUVU1Fh2ZjeN1EIs63bQG4bbKeNcOIhKLYocOEAv+QtGCE5TRpNfQ0K9BJdHQ4XPh6gWRISIIMejsEcTkJgCKDYaZqtAkm3IzhyE9av+0t7d1WGgJV5CERPVRIb+xuvQfS68VOuHpyqIZRMGgpw6CMXfBDnZAXTPQTdbLaqrCEQlATaHDFHTUVhSiR2nKpHvsONgjYnzEQPdkxNgnK7EIJeEIwFAd9qgEQO6BLjtIvPjqvKGIAoSuw/RaurN7N+zGaPGTGHjg16XNlcydKORlSXwCAocUhSVQQlzeyfg1WMebFzXthc2zo3BXBgMEyroi6SIv31tAoTdm4EMDwanKohTMrD1RBVkhx1WvAtS1ERp0EBPmrrCJsKkD5kLx1GrEVam4oEeTqjEwsn6CFIUHdUBCT1TbGiK2pGcQFAfiSIQCMFuRtDfI6Kb2QShqQnueCf0RAd0Q0Z8OABRjMLVLQcNZUXolZEET0ocLtSehJqZgAtNEVhWFOGggiCRcOC8D2kZMnyagHjJRK1fZ0VO0+urkJFs4NgZDWkpKoI0mpAGEdPwclooW4sJHjTVIU3gePgyf59mt5RFyx5oKe49c95SbFi7EhEzyiobUAVDTV0tCibMYeOblm1qhq4bimggxMaeN1cLX1fbmMSQa3w4HA6Hw+F0Gbjgcw12bruYAv/Qdpw+thsup40VRHTaZGYGo9oeyrYt6zBn/qKbPgGHDmzHgYvbambu/AWtvg/MHwuB1d2hhRgFlifoapw5eYQ5YlONj3LRHPVBRo2bCUuyQWChRhZ7O5Q+oPfTtGgsmo16z9PiphdThVNp/PyFEvaZVkuhuUKo07dJne0s62IhVKodM5j5i9YBo4XmdKoC6qIwzRk1G5oGwt4ADuw7hbF52bE3PrsHNmIiYnNh94lKJCoq8pJT0C85CcmCE3HUP1InUC0RNkUAMQjsioqkODeSXSoMQuCQJYSCFs54Ayj0+uCIVxBtMGA3gbT4WO6XoBYBUT1IkYYg1e5CQgIBDAkSkaEKCmySwrU9N8Cg4aMRjcQ0PicKfRDSM6E3+DA8IwlmWW0s+VvPdGgXqoAQ1dTaqAoUNj3IojctTUPIAkIXgog0aNhQSnCWzhAtdHc5YYOGFJuKuvoITvk1NGoEYdnCW5vL8eoeanJWYFNVVkxYM52t9q1w9xYcObANRw7ugGT5WWLLV9ZW4JRfx4mohnPBEN4r0eCr8X/MI53TTCwIhYCWtqIxsYt+cwRNxVUI1HpBXCq69e+GYXEyuuthWsQPmZaOEcnUnQI4VGdga20Ix6ujKIsQlreN2GSUmSIsI4IoJERsCvyE5oQLIFpVDy9c6K5FMQIaegYa0cMtIrWmHu6aOrg1A+6GRnjC9XAN74aAacfY2WPgqw5DqPOiX6oMxeNGkgpUV0Xw6vazqKv1o1tSHLYW1WLb2Qo0BHV4wxrO1zYhFDbRM86OT87LRENcGmg8oSTHctnRZ4LJCncb7J5H7//NzFmwCGvfiuWdo8+y1RfLLVFtz9S5K1jdStpo0W5atLS5BuXl0HV3bFqDg3s2Ij7OAafzyvx7B/ZeMn1dD27qugajJ8xkvir0IU7t54cvqzcybsL0Vuu+u+bjrWf1zppYgsNmaPZLWY5FX9mpw8ZlTJ+9kAk7G9evgq5RvxzCsk7TAXQ5M2bPw3vr1jK7rCDGtkN9d6i3fOFlZra+A8agwRti/jsMFhpLo7nkWK0yZtGiMy7WL6MDmdBipzQpHjWJ0VplIhRWn4wKajGVfFdk4OACNPj8LLSYJo5MTfbA723E3pISNIRMRCsr0JTdA5MHZmFj2THYXQqybR6cr2tiiSJZ+KYGyBbgtwhMSYBIE9q5PUhwyIhGdXR3O7H+XAVsNgmGIkII06KzAsJBA16HjmS3AyQahRbsDt2ohyRQHx7qu6YwQZpm8PaHuub5uVlMnfq1EWimgM/Pz0TEE480ZwXe2XMa3ewmjjVo6D18FByhKMiZYggFZYhKDtQGRcRHq9EQMuBJsaNb9zj0NU1sOd/ArpEBKUkQoEH36aiIGDBlCcdLy6GSKBxqL/iIH0l2C7u3b2/Tfu7acem6fun9XBZhVFRYhpnT8pA6UMWGsqO3sJe6LuweSLPhCxZOBAREk0XsSumLM7vOwpNaC5sYgEMPYlDPBJhlYdSEdNQbIhI9Mo42GvAkORA1AIdpQPSFINK0FAJBQ5jggC8CQmS47BoadAkNNN1FfSWqLQl7gwYG2k0EM1TE985CnEkznIaR4IwAozKAjHi46duU14/KJg0DcxMgmEBtyEB+sow95X7kylGcLy3H5P65yHBacKnJkN0O5m9kWTL8kSh6pKeiMVCD7rZGBGwKaNYVWpC72f+1GeZLepF3V196Rr71Wkzomb9gGWgVQhoYzB5XzI+WQCBUnKK1MK99X9r6Xutn5I3CBZ9rQAuHRsI0tbbBSjMUXeajsnP77bWNF+65lIvng9AMlpsuVmynOXeoDxAtP0G1M5dDhR7K7h0b0L3vBJScvvrNk97QmUhDhaeWoP6YnxF9k6Eh7lS7c2lZLH049WWhgpFKH6aKjNJze9Fv0FjYZLHN/j00HJHax5tzIHV0NKYBM1nYqF2WkJKWANkmIGfoINiKqjB2cG/IKamwtHpoHhd8/iYkxKt475wXOTYn8rJTEQ5HmY/GBT2AiKBDMZ0IBSJwyTKrzkyd4s/7mpDmdiFZtSEYoc7l1HHdQiBMEGj0IS45DnrAx3Iv0WrdVOg5XXSLq3l2YlihRkGCaRH4NeDX75fhWz/8Mpb+8Dm8eIigvrQetaqMFbZkpIUqIe8/BFufXPRJVxCKEBypNZFG6uH3NWHO8BwkKw5sOFOJJi0CRRWgOOIBNYiUkA4BFupp/q9AALoZE1RvhvOHLl1T6zde+37C+WiMogWJg2H2mb40a+UNmDSpG+pVEd6ohaKKIMZnRNG/mxOwohiToeAf50wUV4QxJVuGQxCRIABJGQnwltcgya7gZMhEnwQbnNAgRgFTAE6aCgwtigwiIynTjaClIjUUhjPgxflT9XDmZSKjT3f07q8BF84D930KlisBounBuX1rMamXBzUllahNyAWJ1sESZPTvFoduqoU3iqpheOswJBEoCwvI752Gem8EJ8rrURsMo7tpImJICAQizNcs9hLc+llBx+nRI1dmdL6cNavfYNOZ8+8CoeougT63CN5fH/NFvREWLb0Pb698uc3r81c9DofD4XA4XQYu+FyDSIRmLtZYi4SjyBs6EcNGTcPYCbNwpzBj1rwWbQ9DoOHmKpPC9+1+j82aOGXexencltWulWSKbYJFjclwqLHkULSOV6wQK82USQeMBUmgphuBmdRUWuRUkmPLqL8Qzd5pj/kXnSrahSOHdrT5eGg4ImXchJmQXdno6FDfJ5remmpZqLnyycWjoKkOnDp0EpYnCe7MdDho4dq0bthYUoIR/bOhGzY4VDuz7Q9PzwBkBZJDhCibiAZNWJIJU9BRE2xEqkNFUWUNy/BKNXE2UWXZoZ12FeluB0xosLtFqI7Y+RCoPV4SoCqtCwdybgx6Lp0OGwRZhTdK8OO/7QFCjQimZSMpMw1TsuJRs+cUTl9oQmDCFJY6AlXlEBQNZ49egCpE8P5RPw6dDuJsrQ+wAwNzEjE4pye6JachLKko8+uQaRQpVb7SVBc6NWPHCgtz7lwKd7+PE0cLUXzmMErPH0PP7Hi8/2ohgg21SO3hgUshsBQnGqFidy1QHBGRl+rCkKw4pLgUJIkm7L5GnD9VDJ9FkCab6GYzEdEJ0l0mEo0QhnlMpAZ86EN0GNSMXR+B73wlPE0+EMWG1FQX7FV+eI+cx4naKDBiOEiPYRDSB+DoX/+F3Dg3zMGjEdfoR5KvFIMSgXB9A1yRIOx2CUPcMo5dqEGqFsAA0Qf4G+FvaMTQ3Az0ykpn9zXqW5ielc4S+LKC4iyTcuwzNevTdAptZcOaV5lZkNbDVGlKh5vAJBLmL7l+3c/L4YLPNaBOuawSrElLV5jQotRpi7pv3Tld9t76S6F+FIn6hEginA438odPw7CRsxAMOzByzFyEIxbGTpzD1qu6sOea23Q7VcS57XC57KyKvKoqUFUVNlVhfiS0HIVNkVgoocelIi7OhoQ4OzweGzwu2hScOnbzRQypmWvn9g0wguXo6NCcS6JIWOmQDdv3YuKo/mjUCcK+IJxmEFZNDcqOH4UUMlHvC6G+KYhz9Q3o5nHDr5kobQogYESZE7OX2vrp6DOoszNQXxVGbTAEn0yQEx+PbJcdsmUiSVSRrAgsi7adVlI2dASD/lhmVRHM6Z2aIjk3z76923Hs0F4cPLAPjWEddw/vhrOrtqIHvCjSBCyY2A+Tsp0INTXCqKiGWRNEwy6aeyuMzYVVeO3dEzjaCGTaADsVcHNtSHLbkeGS4BFp6nMfLOjIyU5m2ZkT7DbUltNQXRk7tl6ZxoJzZ9K73zCEdAv9c1OwjSQjdVQqvJaMKkXFqTBBQnYKmoiCM34TsmWggoavu5wwnHFI9zhZyYZKIiHNKSCe+mf5bQi4nAjKKis0bBN1wCCoDwZZagt3NIhz52qYeSp5xljUJaWjPmziRL0CqEkwD+xCvqsJmDoZUkZ3GOkpqFLi4YiG4bLZkWxXQRoCyHKKGJjkQqJsQKRlKSJROH1V7IXqfFUjorRoNlEwOzcFZdVN7CWYOjaxEkashqbA8tzdCBvXvc4Cd9QbEJg+CDO7tXXdm/4rHA6Hw+FwOB0M/up3DWg00okTO5HbdwR0VqDTxNEDsSiJ6bMXM6fSd1evxJ3CqDGzEaRRaAYtIBdkDs6mIMGhEERCFizBRFrOYOpff93tXB69NmjoRFaLiwrvVII/dmQ7+ueNYaFcVOV+7OiVDtKjx0y9JcfX0Rg4ZCSavEGIIDENWVw86usCiDbU4FhFPVSXA3qgAUP69kRaSgIrdltf04ieCekgmgldNFFYW40oCcHhjUKNROBJSoPoD6IpHIZiAnGKBJvdjbBPh2WaSKEh7obIajxRVbRCCJx2BRZJRYOgs3BRu11pUy0bTtvwBjScMqLo9+AL2PTfSzA904YfvncM/z57DKqq6uAPh1AfMFHfFMbYMzUYm+tBSSVBrziCeE8mbFEFp2v8sCkOCJKB8vIyRKim0EVNzSbLzq1BQG2dgYS4tr/Rctofw7BYkIzfMrFyfS2mfCERKYkSDp/3YnCygkCDF+cbIshKcMFumHBDQ2UkggZiQ0MoyiIyqXZXFBQWFOEgYVbTrURXoasS6k1AFTQooSh00Y5KU8EFnaCsqBLdJgUwuF8aGoubEGVKmGSI6UnQBxVAIgEYp4/DfaIIzmIT9sWjkaC4UbJ5N7S4JER9UfQd3BNK1Af0yIHHo+CcZSBsWZgxKB02VwK2HKhHcbgK8ekOIEpVKBcLWAs0kzTNIH7jY3X96liC35thzZt/Z9N5i+/F2rde+dD1ueBzDU4ciWWcpCeSBi6ZloD8EdPg8dixcd1buOMQwQq70ZBn6oMjKnaIssJy6xCaC8I0UVNadEObLDp0ZU6Ek8d2X/c3e2iGUg40GvJsmqCXPy1tMmRAJlyKhbMllcjplY0suwKXR8ErB8/g5ModGJWWhSbdxMwxE/DW6reQmaJAEXQ0BC0EaTZsxQbDsuBWFeRmeeBtiiLJZkejHoJBS41YCrwAygI+6KYFu2VAUgHJGw9JMuC225n/l9N+Ze4Lzs0xdMQY+IN+FkU3paAvpn37TViv3I+CMg2OU+fQM94DIc0DLc6JnqqJY/uqsdsbRP/EFGQbXlaWJNTgR72hIiXJDiESxMHTdVBdNoRdCg6U1EOzuVF2xo3sLGrFvnkzAOf2Q6NcaV6bsG5hQKqFV/Zq+PrETJTWBvHXfTUYleVBUVME3Yf0RdnZOvj9IQiGjqxEBT5dRGqahMqSICKWjWV5pm4Ih0u8kIQwu74bdQ29MuMQcibDuFCNTKeK+HQ7jPomxF8oRsLEwRCMWph2AqvkIKxDh3Fq9zkMzB/OBCn0SoInU0bqghmA6sb5F9dB75PAcgQpcCC+YBqk6goIkolQTgrqq0rg9Ubh0sO4UF2DHlk2hIIinNQ8S93RCK2WLrAyE8eL9t90v62471N47eUX27z+nPnLIMoqE3jaIvRQuKmLw+FwOBxOl4FrfD4Mqu0hABNqLQvkYqTFnYYsUa96AlUQsWd7zJw1efa9MA2JmalMU8Dhg0WQXT1hBM+39+52emitHopIkw6KQFW1H263jdXuqfUFMbZ3f+QZIRyKRNAjyYUh6dlIHJCPte+uxaDsJBz3BxE0IkizuVDU4IPslNEYaIKsuoCQAVWQETQtqESGm9YBUwmLNKLO91GvBpdLZAVLqbbpxKET7d0dnRKapE5WbKxWUV3QxIIJfbGusAyutHgkVpfjeIkNr4Zo3jg3xsS5MKx/JoaGosgQLNQYDpRGBRjORJBIGDYbsK+oAgkeGwyHAn+TH3E2B87WxKFHAk2VIqPe37YCjJw7A6qfk2i+J0IvWYLyk34Iy0eg32gBjoxkCIaJ4qoQXlp7COkOBSYRkeS2oaSqCeGwgUGL+mJTYTUiKW5MTnSzWn05ogul1RpSEyUE/AGERIIEYuC8bEeaS0GOQ0VUtnDu3cPYXWmiYGgWcqrLUPHyK/A4vIgG67H9F7/D+E8shCQpSMhKBtatgX6mFvVERoquoU+3FMSPGgpRVRH2OlEb1hHyN6De6wcxJThlCU5VRanPgB6UQFyx5yS1NMi04PZHTFhLtT2Llt2Pt994CdNmzm8duXwx8nhEwTTs2xPLp/fumlg+oKX3PQoLCt56+bkP/Rtc8PkQTCroUDvrxYG8a9v1fWTai13bWkd7zJ63HEXHLyAuMQFpKS5MWfx5uG2/wfubWw8izsfPwMGj0eSPlQRg6QAEAZ+f1gvVDT5W0PV0lR+qOx6HG6M4X1mNelWFJNhQV7IG4cYm9Bg8CKt3NaDJCmNCWjwSwk74vAHYZAVhSYAZMhAVLThoFu+IxUwgjbqOYJMJXziCdJeKvAE9ULbpAoSLqQU4Hz/79lzycevTfyDLhjv3l7ux50czcTyqY0PQhn4ZqbDLFg7W+VBrlxH1A87cOEQDEUByQzCjiBcMNFR7EaV+W6kJsFQRSXoIxRU2ZMSL2LWj7SkhOHcGY8ZNhdcXYGUcaEoUGhHsb/Bj96nzsAfDGDIwG/ZIA5bq6Th/rhENkoDUeAJvcROLjqXRn6tfO4OsNAeWTu/OfAAb60MYOTIJZ6pNxMs6ZNkDQwD6pcvodqIOxaV1aAzqcEgSErPikOathb6rAo1CBPKS+xGq8uIHh8L4xafGQJLCwOkSmKk6ap1x8JYXY8n94+HMycKq94rw628/ix889TnU1dSjtKwe7x08h6G9U5CeGoeExESoTgmHq7xIS4hD1KBZliUm9Nhs1I/w5s3pK+5/BK+99DxCkVi5Cyr0TJ02G5s3rWvx4Wmg0a6+MIaOmgaXQ8GO92PLVr78B8xc/Ok2/R1u6uJwOBwOh9Nl4Bqfa9B/8ARoUR2hcJRl5LYs6fKs3Hc869bGCsKVXwCOA9iyPvadc+uJ0ihAi7TU7aFQ9bCgAIpB0D/Vjlq/H8EGH/olJ6C4IYILJZWQk2zol9sNBmTMys1CQzCEuogGXTBZPiWDqJAFGWEzDEsiqK3R4LZJcDlV2CMC6v0hJLkd6NczB+/trYRsiThxhJu5bge0jm9D0MCkfpl48b0T+MkDI7D9ndMoPlmM3llxEH0BVETsqKrzI4FaK0UXHIKOYEMjLkQkKG4VpUET2S4FNXoUp8tFpHqcXNvTQdm9s3WQR7ceA9CrWzyOnNGgh2tRISkY6JZhS3Ci7yAFJ2sjsFQddWIUBb0ycKGiDucMAff29iBF1HC6KQqXXYHqEJCbreJ0ZQjHz2mwbCr21sjok52NtHgXQg0+JKoEhg8Ykj8Ysq8OdQ3VqKyqR5IrHQM9Zegp1AKbjqFBV1AWlwJx52E0yTakZOai6HQZCo+WoJ8EyIaBZLcdFZYGwdBgmQJMPYoNhUdQ2ViPOMENqpdRFIU1Glxjt9tx7MjNlcNZuPQTiGoWps25B6FACKPGzYYkmC3aHgp1Xp4wbQlkRYIAmmuv9UM5Egy26W9xweca0KKchqWxBxh9dtGMt1Sdx+F8GKZpssKk1PBNp4ZpYe2RSmZPpzVs6oO0DlyIZWzNlLsjfD6A6pJzsDQB6Q4HJEtATSiAVKcDTb4AJElGXFICvMEgbA4V3nAILlpdXSSIEgOqLoLYgWTRhgS7E1t2n0eUmsDAMzTfLnSDJVdGQ8TCr985g7un9MeI/O4I+oNYVVQDmYgIhP0Y2S0RVUER5eEwUhwiMh12pGg6TFiYN6wPQoqE375QiL4pqTAMfr/pDPQbNAp+fwBhDShvUiAHQxDrvPCQJNDgqvL6KPx+C4NzEhEQI9hcB1TUS5ia54aZkYDzloyTEYKQRrB562kcqBVx/kwjgDosGjscFvFh9e+LMaBnMkblJWNYNwXpUhQn3j+EfqNnQysrQ1r9QWipcShIc6HhQhlMXYK9ZwbE02fhSY9D+qSpOPT2Zmw5VIqQIw4DsuMROHMagj0F3sYA+nbPwsl6DQFTwJG6cmSmxePUrijS021wOOw4f+bGIoavRiRKa5xp0E2apZyKVLRWZut15i28G2tX/QsTpi7E9s2rMGX6gpZlcxfejWC4bX5wAqHlUDkt+Hw+xMfHI79gJryNXoSCYeanEedxodfAUSDRaqxf808sWroCb6+8+bwDnI7HsNGTWV4j6rNDpWHBsnBof+tcRoOGjUej13/xIiawK0CqW4FD0bBoRA4EIsLuUeGmYcplFVBVJ7afKUVCShzsRMDQ7GQ0mALO1NQh2+1GmFgoaqpFTaMf/TKTUB81UF3XCI8hw6Lp4RXqZCtAdahIk5zYWekHmqLQNQs2uxMlZ8+gIzN8dKxEzIE9d27G4ryhBfB6A9ANHQkOgqAg4o2vFOBYuR8p8cC2gw0ISgLCloj8RBUJgoX0ZAWVAR0NXh2GrKA6rKG4NoS391VjUGYaDEuGzaa28iPidEz65I1k44M+yO3JTsSFSuDuk44UVcTg1BT4ojrOn2/AsF49UFpeBdnlQmVFA5KTFZyvCGBXUSUVrdm2Zo4eDj1WOAhbd8dSi4wdMQqWodFU8VAFE9uLA3j6gWwUFzchJRRFH7sO3ZGEHYaJJfEWkjMTkeyQUH22EkPTHDCGFuDCwRMoP3EW1aIDp2oNjEuzWIboiDsDJ30CLJuMPWcrEIxGkZYbh617apBkc0NV7Si9cAp3Gl6vF3Fxcddczn18OBwOh8PhdBm4qesaUAna1HWYhgGR2hNFgnVv/Ip5lTeH2nG6DuMmzoQ3EISmmSyc0oIFYlkYOmI83E47tm+LhVZqOo3goKra5qputHwf0L+bGzVRmkzSibqSWmQ4ovA2hWEiApvTjmHZ6YiTTIQNE9GwhkSbjUVs2FQ7+sUlQvCbKDpVAYfLBmpxdXloocMQ3ILMigZaYQ3lsgyXLkBXbFAkARfOnkVHZGD+OEQ0g/nW1Tf6WB/26j+G1RijhXMd1K9h1wbcKdDM3C6HDZohQpAtVJTVscK075+rwrgkG3om22CPc8KIhhG1dLhViSW4rPYGUeXXYEkyTlRp2HJMx5CcDJaCgh4r9ZngdA7TNw0NrqsNo2+6AdlpQ5bLhhpvENURA3ZBQW5uCo5UlyMlxwl3nBMZ8cCLa+uQlyCgf89usDkcOFRUhPW7r0wMuGv/JZ+afr0HIC/VjqdfLcbD0zMg9oxHKBLCf24S4OoRQnXYwp96p+B7r55gOQeHfz4P3rMXcL7Oh0HD+2D+rJl4+40t0M+chZLdE01hHaeDdaC29EhYQ73hw4kdOuLo/ckAnM5bO0YHDRuNaFRj99zTxw5gxOipGDF5BU4f2gqTGLhQ2oCyk1tueLv8yroGkUAQ4XAUuh6FKKox78WLzlWcrsfObRswrGAiaB1iCnWq0w0CyzJbhB4KLW1Cs2QzaSdmEUNJg46x/ew4V+/DzJE5yHJYqKkPwLAM2G0qMuwOIORFQBYRkRT2cHRJEiqavCCyjWbmwbCeWXC4RJR7fYiXVTTpQdg9EhyGAjg1nDtXD4n6Ahy9ZNqiN4uORv7Q8WhoCiES0WJdKIoXKz6LzMHbZreBwMSg4VOYydFml7B3x3vtus8HCi8V5R0ybDhG9e+GTz1fiIGZIpSecWhqJDhV7MPGk004eK4RaGiEnOmGw+GEv8kCIgZG52dhWI4Te/bEMsZzOgejx01hZi4qyLrjDFihCCI2ev8w4XGrKAvWgzQpeG97LbWdA3oIgB1wOzAgKw5RU4IoSUzoaQumJCMc1ZEZ58T2Uh8S/cDmdySgmx0FHhFnG0NoJE707JWKvhlxiFrAyoMV7EUjvVdP2P0CumWl4/WjpxHnDeO0PwJREVEZ8qMp6kW/bpmIBv3QowCtiU0zNd9KAsEQQqEo6ipKkNVzIOobvdjyzktQVQfz/4lzAMMKpuDg3hsTfripi8PhcDgcTpeBa3yuQThCHUR1FpVDpUNZ6nhvz5yPl4N7t131je5yTMNkScvo2xvNmC3IAjLcBg5XVSErOxf+AM3gnAJvTRhRIkEPRWGXCaolHRYRkJKajJKmINKdDkRJFBWhAJJhgwAfqo0QMnN7wBOxUFxcjboGC/WaDxEiouJUAH0HZLbal44YtxCOGIhoGnQaIsUcyKmZmV57Mkx6PIIIgwjQwtScqEONKkz9vX/PnVEj7vDBAxg9ZhwSZBWvbq7CmUofDhaepLm8MXn8IJD6UrbehL5DQCwBW85ux9jxE9i5P3WBVlvjdCb27NzSUrSYJiY8daIWkGtQU64hLtOO6goR0YYgcntnQ5EknDp5DEAIIweMxr69e9hvCwrGtfnvOZ129szSTB0l5ToOHY0gt48brhQB726XMKJAwebqCPr1i8fuM3U4Vt0Exe1CNOTDSR/QeKgIqGtEjTsJpV4v6iwLmmli/qB+2BjQsfNEHWxEBSEiZEnCuTN0f28NeYML0OD1QjdNeDIyYbkiKC9uRHJyEiQEQagmWJDhdMgYNWYqCm+gTiQXfK4BLTBJ7RX0pkvVlMeLrl+ck9O1b2yUvGFj0OD1wSQxs6gkAZV1GhZMsGPzqXp8+YEJcISqodsSUVpeiZDPgGUQOF0SzpRWscKyiQludPfYoRsmLEmBGtEgiCaaolE4iYTyqlKIVhS9uiWirKgJkVAsZ1BaVhYEoeNfzpppwDItEIG0pM2i12BzfU4qzNHCu1HqS2VoLCtuLPT1zmHP7kvmqgN7i9l07Pix0MklBfvmLZeyMe/awSO3OjvHD++79MUEGqM6muoDbDznDx4B3bKgXubT1Sz0UPbubbv588jBmL9P3uARsJk6Eux2lFU1IsOuAoYFbzQDFxQB+6ui8CvJyFQdKPFWIhANoqa8Gig1EQxGELUZqI4Axy5UQm0UkBeXipOlDdDqCZR4lSkCVFm5pS9XpmnQSq/M1E2zQrvcMlKnaTizxQeXm5q6RIgirQRvR+HuS+bmtsBNXRwOh8PhcLoMHf8V8RZhU23QdeqoGnOu5HA+DF3X2FsKfQuitXWopiIjiUBWRNhdDiQQP8JEx/79h5HgUuBU01DTFIGECCJRDVFDZhFdaTRigr6g6TIUU4BTNNAgE4QNHclERJziRoU/AE2zWNI80DcfWcLJY7dO7Xw7yBs6AfWNfpgWTQBpglZ3Zf0IARYxYVkGNC3Crkc9GoVm6DBEmiRSQ27foXA7nTh66M50Dt6148beSDmdn2ZtydEjV0ZqfVSOXbZNer1EvA7AH4ReIeOFcCaGppdAFNwIhCPYU9WIiB5Gg1YFhyIiaBDUBnXoTTpCXoK7x+Wz/HZNIRnxCXboTAsjMkvIrYTW/XI6HBB1nQWC+CotuOIyEZflQ6TWhGizYFGzni4ib+hYHDvU9muMCz7X6hhVgqpT4Yc9WT6uc8npxGi6ycwwxLQgyQRNAWBgLrC/pAF9EzNwuugkTNXOKjaXBwiSPA6kpThw4fxppMd54BNFVnZCdMsIWhKChgmPChA9CgkuxIk2wNIhqgJchgVFsoMGHNLQ+Y9SGPBOgV5rlknTBcSiuaivFAumNAmIKMDSTJYqgApC1JeKJmyjNYTDRswnSNN09M0bzsJeORzOJQHLrjqQnCUiFNFRd7YcVRk+eCsDcIl2JEQA2UVNRxLqfFHoCoF+PgqFCHBbFsobamGzCRCJHYZF03PQFy0Rqu3Wig+HD1wy92Xm9odmElScCiOjbxwak8KoLjQQl2ZBp/eAyI0Zr7ipi8PhcDgcTpeBa3yugShKsDudEMJhSBJB/7yRcDnt2F/IHRE5V5I3fAzqG7ws6SVNVkZzTDjdOjRC0Fjrx4CcniitDyA9S0GuEYDD6YDN44BDcuDMGYKGaAh2yYlQMISoMxFBw2CJCSWqDhdtLHmY27JBtjth2XWcOWui4vwF9rf75w2CTe34dbmYQ/dF9T9Vz9OPMa0PYZ9j82JaIFEEc4Cm32mfG6yZzDG6T/+RcMc5rhqFx+F0ReJcDggCDQwwkZUQQGWpDcm2KIJSEFacCTgkWFoECTYZgmyHCR1pmQ6U+e3YeNYHjyJCMwSICoEsgjk2nzx++LYeg2lQs7cBb4WO7JFR6A0ignUqIkSD7ogiu/cAwDJRfv5059P4RKNRDBs2jN0EDx482GpZSUkJFi1aBJfLhZSUFDz55JMs6uNmEGUZE6fNhd2hQlFUnDwW88rn/j6cqxGhPid6lIVc06gu+k8QaQE/G3JzuoFIEryGCZfHg+KqJrgNHZGgHzuPHYcmSkhITESDHsK5Gh+r4O2QgDjRhB7xIWhoSPK4oXgUhE2CIydDkCOX/M5OHitiYdQdmZGjaVoAwhKiUWV6s8BjmAZrzcEjlmWx5G+xaSyBJG0GbYaOqKEjrNFmYsyEae19WBzOHcHRQ/tQfPo4ys+fgsfuRN2BKpzcpaH6hIo6rx2GLiEctXD8vIzyOgvuAU6UR5wIBwnspoywX4RNjl1z1BQtU+nnNtGz/zAYhsX8Jy0QBCyCisoI4uIN2ONLkTGkGi6HiWAoDL+f1kjshBqff//3f0dWVhYOHTp0RVrwBQsWIDU1Fdu2bUN9fT0eeughdqJ+9atf3fgfskzs3b4BouqBU46yWVzbw7kWUY2GV9PQcuqUQlgSVhIVERDCOFtdjzh3POQ4AaYpIrF3JgwiIkxoOLuFsGbAikQg0iytqoS6oAFPvAmvYscBTwp8JQ1oOFwPrawKQBADBvUHlM7lcL9vzxbkDR3NfKRMS4SpxQQaqtGh/j4QqOZLYG9qhtHscxcLeY9pglj2JNBMAnQpFZQ+WNmZw+EAJ442a2oCSHSnIdwUQtUJmjHaDU+GBl89QVmxCY8j9sJBS/OYOn0RsVpe/EV6Td4i/vneCXz3a1+BTLwIhcMIhiOI0iKsMGFL9AC2MpAqAVqjCIGWiglmoPJsCHZVBzFiqUQ6lcZn7dq1WLduHX72s59dsYzOP3bsGP72t79h+PDhmDlzJn7+85/jD3/4A/NI53A4HA6Hw+kwGp/q6mo8+uijWLlyJZxO5xXLd+7cifz8fKYNambOnDnMNLZv3z5Mm3Z1tTddTlszzUKSHtWh2ACnSnD04A5MnDQD295v35pAnDuTAUMKUNvQxLSOAjXBUP8Ty2IaoPr6IKywDBp+ZIpOFJ2uZLV00twKK07ZvxsNaRdQ5/NDliwEaEI+SUQgGEZNkhPW0QsgAQ0JlgVHr1RcOBvA8aMn0Bk5digWxZHefSB0Q2c+CQKJZU6XQKNKmt/TjFhGdarpEQTmj0cRJBGCJLFQW5o1mxYK5XA410aCAqJLcCa54Ip3Q4+I0PUAXPbYtaPEO6A1+lk6iVhCX4mZuW5lAd3/+e5jsLQAvOEIIpoO3YyCWEYsk7tGr/kkeDJMCMkGVDETdSd9sKu0PmJMI9xpND5Ujf3www/jsccew6hRo666TlVVFdLT01vNS0xMhKqqbNm1eOaZZxAfH9/ScnJy2HxJFlgmzaKDsQyrXOjhXItQIAItqjGzFS1eShEkAZ6kMGSPB0P6DEBcvA1Jbg+rmu6WRIRCYRiBEGob6mCzxyPOk4iUlAR0S3QiM9WOftnxkO0ueP1h+IM0XJtAkjrMe8pHQhTobYk6MlLVOu1Ldk8DRGruorp3AkMPwSIxnwNqAmNCj0Ab7XwLNBieFpblcDhXZ2TBRCiyAllWIEJG0KvB5VZZZnlZlqEoEmyqzF4s6PVFodeXqig4dfLoLevWxoYm+Hx+hCJhJvQIMEEUkQUZ6WE/SJCmLpMBt4zy4zq779IbhCLJLADpjhd8nnrqKWYzvF4rLCxkPjpUE/Otb33rutu7muNxzBnr2v4QdJter7ellZbGaulwOBwOh8PpfLTrK+QTTzyB++6777rr5Obm4kc/+hF27doFm611kjaq/fnEJz6BF154ARkZGdi9u3U9rcbGRpbY7IOaoMuh2/zgdinnTu7DmPEzWr7PmbcE7659syUCJRgMQdN19nbqdNpw+MCdmTGWc2vpnzcc9Y0+6JoG0zCYpkeEgGCdiewBdpSeDyO7lwFvox9yYhK83gC6d8tAgzcMX8CPJq8fOekycuMV/OSNIvj9IfTpn42t4SDOVUXhinOyNxrZoeLsqQ8P0+zoDKL1zhp97I2MKa7Zq5nAtDqUmEaNvv05WJFP2t9U0xOL+roYAk8dzJlqnsPhXIt9e7chf3ABM8lT0zHNjhyO+JCWEgS0ZChqFNFQNQTBEQsioJYQgdauvLUm5EAggKimUz0PRJkgRAiSEhtQV+eC3abCDDmQpNei+KAKuxQFIRIrmOp22VFy/tSdL/jQkHPaPoxf/vKXTPhppqKigvnvvPLKKxgzZgybN27cODz99NOorKxEZmZmi8MzFWpGjhx5w/s2fsosSFSddpFmoYdCi0JGdRORUCxni0QjTjhdElpJnJZRoEIPjUCifig0ssjukuCrjiJcHkLa9G4oPlIIl+pA9xQPzhbXImzpUEwT8S4FqiIhweNAz1QXzMwkeCO0PIUDngQVetRgBfpu9c3mToH65aiqBF2PXXs0PQAVJEWay0ek0ZsWveQuCkOty8nESgDQKDACqbmqKYfDuSZHj+xl08zufWGGDOghDX5NQ06GH0N6p2D/kQBC7IKjLxgSFEVBWcm5G+7RadPnYNPGd9t8T6XXvSCLiBgSFHcNkm1xmDctBYfqJRQfr8WpTWEkZzqhyCpkVYEii3C7nShp4/50CKeB7t27t/rudrvZtHfv3ujWrRv7PHv2bOTl5eHBBx/ET3/6UzQ0NODrX/86c4iOi4trl/3mcDgcDodzZ9EhBJ+2IEkSVq9ejccffxwTJkyAw+HAAw88cNXQ97YQDms4sGf9VZcdLNzKpt17DQMxqXmja7yNc66EmqEsk2WOuZTjAoAap8PbRABZQLzbDpdog6xaGDioO3K709w+QZwsrUFaigtxqohqvx8jBqZh7/F65AzsjhOHK1l2YrsiQJYEODtBLa62cGh/LJigd/+hCEc0Zk6m+XioAodqWoWL0SUswuNifwvUyZn5+EnMEZM6OR450NrszeFwro3DprIiy7QEns9vgxZnIB4KqsN2FtFFrz9BlpgFpbm46o1wMebjquQNHolwMALdNKEbGsKaBkUVYXOIiJIwEmChT3YSSgIiDm6uhSfeQlx6PHPMrrwJ7VOHFXyo38/VOp9qhlatWvWx/I3GJi8G5I+BpIgo85n4wucew4//4zMomED9fgSW3NDtcbGEayeK+E22q0IrsEuyDPliMsLmgraCKCNcbyK7VzKOFB2DHo7iTFklahud6JHuQp9kBSmOBOQkxiGgm6j1+nG2MYiQoKLuWDVcdjtKz55C7779IIkSTp08jq7E2ZOHkD90LCJahPWrYZrQNINVhiYiTRlw0QtIoIkKBRbuTvuJRpxQUxmHw2k7blbSQoBu6nA77ThXdQ4l1QFEfBKS0hNoWVKWtJBmor8ZNr/3LqbNmo9N69fgp395B994eG7LMp8/gGAgxDLe04BOu1NCbXUQM5ePQ2+XgQvVp1EvWNjxTjU8iQIsnUCVZDhtbYvg6rDh7BwOh8PhcDgfBwK5Gb1VJ4aGzdN8Pt375ENVbRBlEaePFFLjBYaMGsMSGSiKDbKigFgmK5BINe6+iMByHxTteae9D4FzG+mfNwy+QJClVqd14aiDM9VE2JwqfNWNGDKpG+BwIa7Bh0Gp8VDtCnrlZCJBCCE9RUUopOBMXQim4cN3/nYWGRl2CKKCigtn+Xn8AAMGjWD5kppvWNT0RRvVsskyjeyguUdkOB0K9u/lUZYczs0iCAJ69+sHQkRWM4/6N184f5ItuxmRYdrMOQiIydi77h+t5vfpPxQNjU2IRCOg+UYVmwRLNjBtyiDk987Cqr2bUForwWgS4CvT4HRaEIgAt9OJqrLz1/x7NDXN9Xx7O6Sp63ZQciaWoGnIqPEXT3QUh/ZuxYjxM1C4fV2rdYeMW4CT+1dj/ORZ7bS3nPbi5LFYody0br1gmjpMUwBRVMiSH7DrqKpsQHbPOKS7nUhLsTOTDI0FPFIcQFJqDhwZSfBWHEKj30D3TBUBzYLTziOSrsaJov1XzBs8bDSbHjkYy/rM4XA+OoQQnDkZE3Q+DjZtuHpEVziqIarrrCxx0C8gwSFgbH48HNF6nDlbgUPHTaTQSNkogcdNU+KDha7bVPUj7Q83dV2D0RNotWjgcOEOjBwzBYvvfzLWYYKE0ZPns88TZyzE1FkLcXjnavadPvg4XRNJosJKLJxa84UhiCoEWYBsE1FRcRamICISCkNURYRVCfmDuuOsN4jv/3UrnnlhJ373eiH8YVqUEyxklNM2qMDDhZ6bZ9KUS7nKOJzbrsFlWnITkmQhOyeKtNQg3AoQNiKooOliLgShRWjCdgl2mx1xbjfi4zzwuFwf6W9zwYfD4XA4HE6Xgfv4XMPHhzJq/FRoEQ2HL4bY9htUQMN1WCQPLZBosyk4uCcW2j5yzHgIoojCndtu9znktDMDBg1HXWM9wsEgiEDgdGmIBIPQZRnLl8xFZdl5uMIE+dnxgEGgOi3UNQZxpq4BQBzK6sOo9+ugLzgO1Yba8mvbrjmc8eOnIRgJsyzWHzVj/ISJ0xA1dezbtR2jCsajcO8O5A8tgCwLOFDIo1U5Hx/Tp89k/o8bN8bSxPSj/j0+L6JaBAF/BKmZIhCvQknzwxHxoPSkCqdisQztDtWBypK2ZWWmcB+fj4Cm6QiGw+jeZwjLGNvU5GO2z7rK00jP6QOn/bJwOkJ4BucuSjgaRTSqsdTvlmQiGiFwZPXApCHDceFMGfLTMlBaeRI+l4A4txNhTUTP7llIjnPihY3nUVYZRkaPZMgWVfly/x7O9dmxYxOGjxjLQvupE+rI0RPhsCt4f8vGG+667ds2tXzeu2c7m9KyBLTqx9jxk7FrR+zFjsP5qGzc2LposM2uwmU6IUsibLQUhU4QKDFglDlhhYCUVMAyZZavx+NyohIfH9zUxeFwOBwOp8vATV3XMXX1HTQKoVCEZY+lCdRo6DrzPhUIFEWEw2aDy+WE3WHHocJd7XH+OO1M3tAC1NY2wB/wsizeNBwz2BhAavd4bDx8Bt/41FKMyo2DM1DBCuw1VQdRFwojP68f4hUC0fDD5lDxP8U2nFh/gNWlqq8sbe/D4nA+EsMKJiNEnfkFghNHaToQTldj6rTZ2LypdQT0tegzcDBzdC49V4KM7umQZRtLmCgJsaSkJ4oO3NDf5qaum6RP3hhWfJIKPM2JQ6gPD6tSKxKoqgKbjeYNkWDjUThdlmAojCiNTDAtiJIISXbAFdeAQGMt8uNjeSQGfW4pKusV5Ga4ELS8kBUVkhCFIujQSAirTwZQtqcKJi14aphITcuGJ86NhIQ47C+MFRHkcDoS0YiGcCgC0zLRvecgyIoMSaLZfwFJFnDs0JWpCTidh4ETF2HzprcxZvxk7N6xFaPHTWLFRHds2Yhn/74eX/3ErJb8PrquY9tFM+2A/KFMuXCi6PBVtzty9GRWTup8cSXS0+PZyyYdU9TtpOho28cUN3VxOBwOh8PpMvAEhtegqqoKCQnxSE5KRn1DHSQiQpQIi+hKT0tC8fnzqCyuvb1ni3PHEdEM5tRMtYGSDLhcMizFjqryMFv+0K9/Ak/RRpTpUZaksNbnQ1ZaMqrq6nDBNPHjnRp6W14EAlH2lswyEVsWJFnEuTMfXwIxDud2oioiVLsMPUKHs4FIVENlZSX6DuiB44eLIAgqevbpC5vDjuOH9/GT08k4sT3myKzrtKgwEImaOLzzffZ52qRx10xseOLooQ+93wYjUcTHOeHzBmBaBqucoOsWhgwfg8NtLE7MNT7XgKa+T07PRmXxeZa0kD7YRJF6mMssEV2giQs9HFqdnfp8UaFYgiSp8AU0dM/JxtSxeXjk3x5D4MguRBQN/eIMJLllpKQkQpUtJNl0HAnJ6Gk2oc4bQSgUhaHHKr1T82pU48kwOR2XQ/t34OzxAyg5fwQetwtOuwO9evbC0IKpSE+k0bAqQuEo8wMaMjyWfZvTeRg6bDib7t+7HWnd8uANa8zvi/LVR+696e3S0jREEGBYFqK6AY01iwlE2kUhqy1wwYfD4XA4HE6XgZu6rkFKahqqK8rQrfdANDbVQ5RNGswFm02Cy/HR6oRwOgfT73saR3f8A5KssGRy1HmTQEBtvYk+PRJhRCJw1lSiOjUNSf4KHCuugCwIIDYFz9fYUXGiGPHxMsIRHYZFq9XQ5JgEJiGIaBqS0zJhtzvgcNhw5uTx9j5cDuemOF50KarL6RARl94L9uTY2zkNDpF57qpORULWEPiDEfTsN4I5NA8fNRHnzhVj3/trUDBuGsKhEMaMnwTLsGARC4ZJMGHR3di68mUcPXT9YI5Dhe+j96AxEC5aYWBJbD69Z+o0EKmNcMHnGpw+uhMDh09FWAvD7rRDEkTIooiiAzE7JYcTqdzCEm8Ri5qnohAFwN/UgOH5Q7C/cDtGPPhZHP/nSdgPHUF1NIR6Xz0csgPhnn1hi9QgIUlBKGwwvx56IVO/HmqvprVrTMNAIGixxIiRiMoS1V1O/4GDceLY1SMfOJw7lSMHeWh7Z2XazPnYtGENUhPsCPpDMGnaF4tgf+EuJCRlgpAQ9u68lDCzGXpvo745ObkD2OfrVX9f+f4ZfOdLDyOiSrAMFYZosfmSKEEzgPyCWTi6N5YZ+npwUxeHw+FwOJwuAxd8rsHdn/0G7A4H3A4X4j1xWHDf55DRZzCmz154e88Q545lx5Z1KD19ADbVBllU6KsLMlJTYFNdaPCaKHz9Few+XooLPi98oTBstkSYhg5bdTHCFoEmCDAhQKBO86rKtEeqaoekKLBAHfhMBH0BaJqBKaO7Y2JBD8yd2BNJ6Slo8vowcvTY9u4CDofDuYiEux/5LnSDmp0MaFEdmmYyDbYrKQPXgmp4+g0cCmJZyOnRD9dj6aQ+UGQJTocN8fFOJMS74HI7oNpsEAQRQZ8XbYFnbr5G5ubUHiOR178XPS3Ysu7VNnUmp+sxYvRUeL1+BMIhGLoGQbCgRYPQ/LXoOaAHZGcSvPWNyEuxoGsEPiLAp6o4hSR4SksRCesQDROyrEBVVRZBqBs6otEoDMMAiAmHTUIgEIbLpSDoCyIhOQWiaEN9TVl7Hz6Hc1NMmDgd4ajGktcJotRSCJrTMXl5Wxnum9iNfe7RdwSCgTAMmsleUZlwcvrYnjYVe6Z+P6dPHcbgoSNhmQKKjhZeYfoaOWYK9u3e0vI9f8QEVktTFCUYUHDywKYPzdzMBZ/rlKw4UWdi2+6j+OyCoTc2CjhdisHDxsEfDCIcCkPXNTTWNSA+3YPs1ESMmDAea1e+iUS3gnN1fuRmepAjRuEe1B97C0sQ9EVgarQ4qQxFUiDKChN4mgUf6j9Ei/jRatk2VYFdpevQ0Hkbis/dmjw/o8dNQTgSZA8lw6TVkU3IkoSTx47ckr/H6boMHTEeNHWVqtAs+DJLCyESC9v3VYGEitp79zg3QXbuUJamgOZvolrseI8Lp0/ceK6m/MGjUVoXhq/qBACDCUBjJ8xk09073rvubz9M8OGmLg6Hw+FwOF0GrvG5jsaHw7kRevcbjGAwyMIqZZEgHPVjSP4AVNWVQLLH4dR++uYC9EsG0h2ANykNhy+E4VEkmCxfIY3qkmFdzHhK32xEiJAUmaVR8LjsKD1/5paelKkzZjOzWjAcRDgchqGbMAn1RJJY5ASNPLMpKk4eu7GigRzOjSCofUC0WzvWOR8fEyfNgj8YgtcfQigUQiSiIeRtQnJ6CqrLT7d5O1OmL8CWjatbvg8dMQmiMw0NtdVIT3FApvcgieD9za0zPn8Qbuq6Qbjgw/ko9M8bBl2LgmblsUBQcvY8kpNdSEhNxvBZczF+5mK88rNvYsioqag4uBmmGUSFBpwrbkKg1g+HamO+D6rDyYQgZgJTlItCz7HbenIGDhkBParDIrHcQjrNu2GaEAURcR43Cz1VZLHNaeI5HE7nZeiICWjyBxAMUDO5CV99HYAA+vTNhygJOHXiCApGT8Ce3dswaepsvL/5UuX2T3/nL/jz0w+32t6AcXfjxM5/wZncFzIM+OrPt3lfuKmLw+FwOBwO5yLc1PUBuMaH83HSq+8gaHoU5cVn2fecAYOQk2VHFCqqSksQbPDBCJsIh0MwafCC7IDd4WZaHofdxqY21Q6n04YjBz88MuJWMnDISGgRg5m+aBSaZVoxrY8Si0g7vH97u+4fh8NpP8ZNnImd2zYgOzcPWlRDXXUFiBViy5oTsDZHaE2cMpvWYoaUkIuDOzbCXx8za06fvRgb172FydMWYueBc9CbLmm5BcEGQqJt2hdu6rpBuODD+TgZNnw0M13RXBaCKLAbwMmi1hmX45NSYZrUOCZAlmTIsgqXy47iczGfoDuVvKEFrKgqzTlE/ZMIsUCrD4iSjFGTHsL+HX+BSQsH0mOXBCYcHdy7s713m8Ph3ELyBhfAMHSosoKjR65fgkIQswFS0SpkXVByQPRSTJw0G9u37QchdZgzfyneXbOyzfvATV0cDofD4XA4F+Gmrg/ANT6c28GAvMGIahpMk+anoDpgGtFF8/WIUFR7h4ua6j90HEKhKMtjRHNkSCwrtQnTsiDBgijLcNhUeFwO7OdaHw6Hcwv5MI0PL1LK4bQDJzpZMkCboiAkUMFHh2UaLOM5jQCjpn0a+UWr0lOz2PUKEHI4HM7tgCcw5HA4HA6H02Xggg+Hw/lITJm1GN0HDI85NoPm+rFYMVaasp46dVMdD839oygSDhTu4r3N4XDalQ4l+KxevRpjxoyBw+FASkoKli9f3mp5SUkJFi1aBJfLxZY/+eST0DSt3faXw+nszF+yAlvWvwXZCEO1xeot0bpioiiyTM+yLDFzF41ooxmopy9ejh/9368gJw9q713ncDi3mO/9q31TcHR4H5/XXnsNjz76KP77v/8b06dPZ74CR45c8pMwTRMLFixAamoqtm3bhvr6ejz00ENsvV/96lftuu8czkdl0tT5eH/zmjuuI9e8+RqbqnYHXA4bBNOAqiostJ2F6BODRlBAFgUmBM1bcB++8fl72nu3ORzObeDMzv0tn5tz+VDa4uu34JGvYvXzz7LPExbej+2rXsK0mQug0fxhxMS2yzI/d0rBh1ap/vKXv4yf/vSneOSRR1rm9+/fv+XzunXrcOzYMZSWliIrK4vN+/nPf46HH34YTz/99DU9vGkVbNouj+ricDgcDofTOekQpq79+/ejvLycqc+HDx+OzMxMzJs3D0VFRS3r7Ny5E/n5+S1CD2XOnDlMqNm3b981t/3MM8+woqTNLScn57r7UhG9+agUKvEOGTaGfZ4+azGb/uGtox/6u3sf/GzL540nm9B/9F3YfqT2pveD07GYPmsJBFHGpGmLMGnaQoybPBtjxs9oGVOf++bP2WdRdmPI8Nj4ut3MW/EQqsrrcLJoP9JTkzFh5lKEIjoSEhLQ0OhltcbsqoI9Bw+1y/5xOJzbz0vPPtZKy0ObJzW3Tb997NOfZ/UKJ0ybAwQbMGXmfGzasBqnz5bg8JFTLesldB/FpnTdNkM6AC+99BLLdNK9e3fy6quvksLCQnL//feT5ORkUl9fz9Z59NFHyaxZs674raqq5B//+Mc1tx2JRIjX621ppaWl7G9drVnEavk8/xPfZtNp93yHPP3nrS3zH3zkS+Q7z64kL645RMYv+AJ5+rm3ybN/WkuaCCFOVyIRBIFk9xpPnnjqeXKgXCeLPvP9a/69y9szL2wmc5d/gsju3Datz1vn64Pv/uof5N7H/p189ye/I9OXPURGjZ/TsmzFp79CBEEl3XsOIj16DSJ9+g1lYy2r9xASl9bjtu+rL6bL5o33AR8DfAyQm+2D+cseZvex6bPuapnXc+BoMmb8VCIICdf8HX2WX4921fg89dRT7I31eq2wsBAWLeoB4Dvf+Q5WrFiBkSNH4s9//jNb/q9//euqNsRm6P33avObsdlszAx2eeNwOBwOh9M5aVcfnyeeeAL33XffddfJzc2F3+9nn/Py8loJLL169WKRXJSMjAzs3r271W8bGxtZQrX09PSPZX9pSC5l1e4KLBwTM6lt+ufTrDXz1+epI3XMmfozX/oexk4owPPP/QL792xHONTE5lec34lVf9fw66cu+StdzqbTAZSePQNdjMMjs3uhIkjw4kvvUmcnGIELH8uxcDoGVGhvdgQsLtqH7e+txSbdRG1xTNVbMG4a9u7chE3r3kFObn9oWgSBQASGYcHuTkWCJwmV525/ssS467xscDicO5cxY6aj6GQ5crolwDAIzpzci34DR6K4MoxIY8y95Ou/2Ihf/+AL6J2bzBQTgYgdgmxDSdG7+MzXfo0T+1Zhx+Z3bnofhLi+mDapADPmzcWaN/6CEROmYeP6V9my88f3IH3RoyBk880fJOkAULWVzWYjf/zjH1vmaZpG0tLSyO9//3v2fc2aNUQURVJRUdGyzssvv8x+92Fqrw/+rWZ12V83nrshtdzf3j1CVnz+B+Tvaw62zHvvQBn52V83MHUdNUUIgkycrlT2nS5ffs8nb1j9x7YlZpLZK75AfvD797gquQOpksdNnENkeypJ7TaepOeOu+66iz/9TfLEf/6YfR47dwURlDgya8GKVuuMmv0wyRkwmqR3yye5fYaThLTeJG/YVJKRnUcGDCogQ0eMb/dj5o33AR8DHWMMTJ46hyT1mEBccbmkz8DRpEffUaRbz+Ekp88I0idvDBEED4lLG0BGTFhK+gyZSHL6jiBZPYeQ7F7DSG7/AtJnyDgycNQkMrhgGhkxYSaZMHMRmb3obrbtLQcukLu+8gMyd9GyNu3Lj3/7yk0fx4c98ztEVBc1Pz322GP4/ve/z5yPe/TowSK8KHfffTebzp49m2mEHnzwQbasoaEBX//611kIPDdfcTgcDofD6TBRXRQqzFCzGBVsCgoKUFxcjI0bNyIxMZEtlySJJTi02+2YMGEC7rnnHixduhQ/+9nPbvpvPji9F4ZMWMY+//gvO1vm//z5VXj6udfxH8/8iX23iIVBYxbDDHvRv99AbHj3XSx68N8xYPQC7N6zD9/41KyLv9SR3b0PQsFLEVmv//NvbDp5xVdb5u2qoEJrjJfXH0bv/Kl46pevt8yjpo8f/t9zWP/677B7wyv4/L/9CA9+7lsYN/MBiO6+N328nFvLg1/9FZqCJlxxDmR3T0P1hdiYyugxGuk5IyDHXYoozOw3ASVnD+C3P/4B++40QyC6D+tXx/LmzJ0fiwosLz4HX2UlBuQNQPHZg8jOSoGMMKrKj8HtdsLhsPHTyuFw2sTWze+ioXg7gr4LOHviPNyJyXC6XFBtDniSMjFk1Bh0655NM+cxczptmmkiqumIaBGEIlGEwlGENR1Rk8AkEuKy8vGD37yJKcNzMXrAQJTXNmDM7Hs/dF+++YVL66Tmzft4z+BN2Z46Mc2mrl//I2ZCeujJmKnh8vbqtuKWz5//6lOtlk1f/gWy63Rjy3fBnkLGTpjJPuf0H91i4qIe6YtXPNAmtZ0gOK46f8k9nyc//sPbZNqc+5g68svP/KPdVaW8Xb0Ppi97kMxY+DBJ696POD2pJDmzNxHE5IsmUIFk9cgnw8fNu3i+Y/Po52kz57Y+53ffRz792fvIwiXLyfDJC8iAkZPY/G//+Dny19e52ZOPvxu/BseOn9al+637kMntvg8302YtupdMnrmYTFr65Me63T+uPsWmX3z67+SBx75Jvvuzv5Aho2eR2SseJXmjZpG8UTNJ/2HTSa9Bk0i3PqPYvSojdzDp1nc46T6wgOTmjyV9h00i+eNmk7EzV5AZiz/R5r+95O62r3t5m7T8q+TeBx7qGFFdHA6Hw+FwOLcTgUo/t/Uv3uHQzM00kWFb+NEf3kLp2RPIzu6NQ9tX4bWX/3xTf3NNYTm8fh33T7sysdNnHvsKeo9agNmzJuEnz/wcr/7uO2z+39edZNFieza+CXdiBmprS2CG6m7q73NuLVMWPoGmpvOIV93YvWsdtHATMnIGQJQkSJIAVZER53Fh/55tLb+ZNHUW3t+8vtV25i9dgTUrY6YuDudGSM4ZRnWJqC87cMUymgyTmAZESYRNkbFly3rkDrsLBcPzUV1Tg62rn2vXzr48HYkkO2HoweuuP3Lq/ejZdyBMowFv//15mEYEIAZGL34Mu9/8LSbNmA0LAkQLEBURDruKd956M1Ze5RpJ8P656u+4Z+EnWs2bPmsBwuEoopqGA3vfx/CCSRBpbTq6n4KE3QcrQYJFN3G8HgB2TJw8DLKiwN1nKqyKnVj91hst6yy9/xFEw1GsW78ZVoRg0rQRUGTgvXfexpSZc0D1xWdLalF6+lLJiLYwf+knkDduDn72H59qNb9gwlxEdZPuHftuEcLMXJYRhWkZkGldPpsCUZQhEVqoWABRJNidDoyfMRcbV70Cp01F4d7d+OJX/xN7tu/Frk0vx47loa+joboEW9/5Jx766v/C4xbx6//6Mh7+wlP4y2+farUf3/jJnxAM+rBo3lzMGzfgmsfh9Xqv69vLBZ8bEHxW7ynDgtHdWr7vLw3j5//7S/z92f/A7eJYsRd//MNfcPLUOaz514sgpPG2/W3OjfOVZ97EH3/6GOwOJ+oraqE6FJhmCBnZfaDaVYyfMAV//+P/Mr+thUuWY9Wbl3y5mlly7wNI65uHssP7sPaymx+HczN85ms/wZ9+/h/oOWQSLhzZ1qa6SZRvPfsaDm58CWtXxcKKbxeK3QVFUdCzdz5mLrofuhnCn375EwwaMx373vsnW2fGrLl4b/2l8On7HvkWXv/Hr9E7fwRMI4rTB3cjt/dA2Ow2KDaVCVOKpGDf7vev+HsPPvI5JtBYFsHrL7+IBQuXYPWqN6+5f8NGT4Gm6ZAEEZIqQZFFJviItD6dRD8LgCiy74oi4p3Vb3/kPll6z6ew8p8vtnxfu60Q//fjH+OdDzk3oybPQeHWd6+6LG/CgygYMxwvPBvzN/32L/6O44cPoV//Pvj1j3+BgQNzULgj9tv5dz2Obrm9Ubh9HfbvfBeL7vs3vP3y/+KTj34dJ05fgK4FoWsaO/7Du2MvcENHT4HL40I4YkALBljhYrvNDp+uIc6eg8mTR6K8qhp6JITj589gUP9BiI+Lx77dWy5uSwYkF8rKSlBffvi6x8kFn1uo8Zm39H6sXfkSPiohQuC8+FYzaclX8P6bv8BLb26BNyTisfsntVr3Gz9+Cb/6yVMYNmo8dq2/OQ0T5/bwqS/+F9546TkEGhvQvXc+NCMMp8MOWBa7+VJhSLXbYFcUbN2w+prbWXbv/XjjlY8+zjidn7+9tQefXDwa3fMXo6nqCAzdwNiCwdi0eTPiElPhrS1uWXfJXffhzVdfxj33P4B/vvSPNm1/9ryliGgaTD3CcqSZhoGqhkZkpqSi8CpCxEdl3JRZKC+vwuwlD2DvplU4tH97Ky3QuPGTsed4GEMGyti/fccVv29er0/fmHZAlKlWQoIkiyg6tP8Koe/xLz2J5371S/b5voc+i5df+ON192/67IUIRKJM+yIJFhPQdm/fdMPHOWP2PBAQbFx347lvUroPQMGwfFC3QF1xYP/uXagvPXPd30yeNhNRzWSam707NqNgwgzoFoEeNWCZERBi4uSRmLYoo3tfZPfog2hIw5HCDXj4C9/D8WOnIIgRRHQZB7e9hm/811/w0/98GO9u2oXT5Y343x/9FJXlRyDJKpzuDPQfkIfi0mOorypFfEI66psaoaoO9OzZB0NGjoLLZsPGNSuR1H0gdm/4JxJTUpA/uABRi6ChthZRXYcsCfA2hWCzO5GRnotxc6fgN0998aYEH+7jw+FwOBwOp8vATV3X0Pi8tvUMVkzu0zL/YHkEW7Zux+iCERjXJxGCMxu9e/WCPcGFo9vaLqVvPWfhyOHjePvlFzFyzFg8/W+xcPlmfv7iFnztU1Ow/mAF9uw5jJUv/QbjZi3BL7/9WSx7+Pt44y+x8OZmnvjBn/Gbn/wQJHQO+RPuxdHtr9zcSOB8bMTeMlMgKkH07TcYp0+exuARg2GZFizLhEBMHDkQyzI+bd5SbFq78kO3OWX53djy+qXyLBzOB5HsybCi1P8liklT52LrprVt7qRTu/+CfmMevqFOHT1mInsTP3xgDwYPGw1FVaEoNiiywPzTxoybxEJs9uxsrQkaOHYOTu3fBVPzXnPb339uFQ7vfw/Hd+3EyaLd6NU3Hy6XE4cvXjd3GuMmT8fOrRvbtO7SFfdg5WsxE93SpcuxcuWV5u3bwehxk2CYBKJM9R8iTJMwfyVDj0LXNQiSAqfTjaOFsfM3c95SbFi7EjOXfgpaNAhiWBAFC7Ik4fS5c0jP7I0eOSkIBSKob6jDnq1bobjiYJkaFEVCVk4PED0Kw9ARq+QnIz09E+FoAE2+IPSohqGjJmHDW3+CKykLOVndYVgm8z+rLK+DYQSQkZ0LT4IDRwsvZW12JPRAuKkY2f1HofxkIZvHTV0fg6nre//3Bk4fPIj1q/+G+pqzbJ4guAEEkdtvLM6fvJTj5+NgfZEff3n2e4iGw9i4ZR/CBkF2WhJ6DhyB9f/8Sat149J6wldz/mP9+5ybh46LUaOGstwW9GZCYEGiqnVVhSwKyO41AK+9eMlZdO7iu/DOW7fXZ4LTeVi8YgXeeq39Hd7HjJ+K3Ts2Y8qsBdiyfnXLg5X6yVDzj6xIkGUVcnwPbF/3GmbMWYKx0+bgjb/+GgG/F1o0DMs0mPOsrMgwiIri09SPw4GefXpAVVWcPHa4zf5InI/G4OGjmQO4w+GEJy4Om96J+TjNWrQCJiR2nkSLYMPqmAC3eMX9eOu1l3DPpz4LLaKhqcmLsrJyOGwqii9UQNcjUB1OZKUnwWTn2WLBHbKkoOjwXraNYSPH4wz17Rk4Ek9++2n8/L+/CS2qsVJNDmciSi6cgddfh0jQi7yRY1G0Zwt2HKvB+Ly0K/afm7o4HA6Hw+FwmrldiQE7CpfX6uKN98GNjIH/+ePLH7rOuMnTSMH4yWTsxClk2qzWyQl5u719MKJgLBkyfBQZOmoMGTthasv8n/5lTav1Fi+765btw1/WHbju8mUrWtdmu1qbPX9Rhxo7s5fcS2YsXk5mLr+bCIKNDBg0hOT26ksyu3Un6VnZbNottxfp3rsvEe2edt9f3tDSB/OWLI+dw8X3sumC5bHpsrvvY9NhBXmkpOL8R+qzmfOXkZkL7iGTZi8m46fGkrreaPuwBIZc8OGCD7+wb8HNbfrMOWz67z/8Nhkw7FKh0JyBQ8nEKdNvaFu//cfGLn2Ohg4dSfr1zyfxKd2JIMRddZ0hw0eyDLID8gazzy3nYVbsPDS32XMWsunocZPI4JFjyOBho8mwgnFk7MRpZMbceWT+kqsLGouWx4Sfuz7zFbJg4ZI27feg8cvJ9Pu+csv6ZeHye8icRSvIjLmxY+rorX9eHunVpy/p3bcfO5d5g/LbfZ94w031waKlK8jcBUs/1v57/l+r2rwuz9zM4XA4HA6H08xtsiB1GLipi7/l3GlveXff98l234f2bM21yxKT04kgSq2WvbmrhC3LH3ZR4zNoMJuOGT/pupq1CZOnk4IJU5mmp3nenAWXTEbP/L+XyYr77icPPPZVsnjZPbfE3LVgcds0R7zxPujoY2Dpitj1s+L+1veyRdfQsC574GGy+O621bK8WuOmLi74dLg254Fvtfs+3I72yUc+2+770F5tyWe+RUZNuYuMm3h14aS5SGv/cXNJ/uAR7LtdtRNBsbPPk6Zc8slpbqPGxEyKk6ZOv6qZ605q8xcsaPd9uN3NLH+p3feBtzuzD+YtXBabLrmLLLnvU62WTZg6j8xY+HmiOjLJyIKJ7PqfPDVW+PtajZu6OBwOh8PhcJppb9PSnQY3dV2SmqfPnM+mSd3GkPj0fuzzwk9++bqS9icf+kyr73fddS/54U9/02bJf+GSq6v/Fy695Cj36z892+btjSxIbfO6i5Zc6Yy37KKK9ns/eObq+7V8KVn0gcibGbPnkllzrx+N8OknvnRL3pwEMaYpuVNbz4IVJC61H8numU/65Y0lqrs7GTv5+s7eDzz8uXbfb954H/AxgI/cB/c98sSHrrNgRSxSbPaiu8jU2UtIwYQ5RBA8ZGD+2Gv+ZurUGWTqtEtaIG7quk2CT9HZUy2fl98TC+1ra7vnU4+Suz/xabLs7k+0zFtxT8wWeqA0SO65/+GP9aL71R//wqb/9q3/vOY6Uy4KPbey/elPP2vTerQ/5y1ZRmbMX0imzJ5Hxs+YRxbe9TjpkT+HzF20mCxZFlOTPv7tH13x289+6cmrbvOhz1y/T5csvdL2/MWvPEG++fT3yc9+939XLJu1YBGZPvujh6c//NgXb3m/t0ebNG0emTxtHhGURPadCjtjJ8ZuVBNmzCaTZ84lU2fPI9PnXjIBLVwcO6/Nbfa8mwtt5a39++ALj3+h3feBt47VB7MWrCBTZi8jIyfOJYOGTyJDhk8i4y7eMz6sfZjgw0tWfIQipX9bdwyfnJ131WVvvPUqli2+C8vufgCSJx6v/um3mLdwGRoiCjLS0nG2uAY9MhXIogRLAIyo1lLwdNb8ZUjvPgBpWVlIcsv47le/wOZPmT4fWzdtBiEhtJXJ02aguLgM2ZnpOHG2GHn9e+LC2TKUlcWK2M2ZNx/vrl3Tsv60WXNpDU2amBNbNryDmXMWYsO7qzB7/hKsW3PtCsUfxqgx46DrNGMncGj/XowcPZZl76TVHQp377nqbz75mc/gb3/6E+avuAcBnw/BYACRqA5LN6DKMg7tb1v6+k99/ot48fe/wfK778Xr/2pd0mPZXXfjjVdjpSCW33U3VZngjQ+s8+DDD6KsrJJVCB49aSbWrX8bJedKkZmbjYzEFBw+fAgZOblIcTthWAZES4CkyNi66T3cau554JP45z/+hjsZWsiRDqnN61Z96LpzFiyGLEtY/SavQs/hdHUmzFyMUCgKS9dwaO8mTJ21EC6HitVvXb/MB8/czOFwOBwOh3MRrvH5CBofyhNf/i5WvrMNMCyUnd3aMn/+0vuZzi0pMxd//+0zbN6Kh76I1174Tcs6sxffC5MQaFEdUVqr5qJGRFIUFJfUoOr8vlZ/a8qsRYAch2g4iJCvBqZlsjpQh/fvwMgxk1ixOFovh51YRwZIuIp9HjthMnZt34pxE6egyR+CpAJZSalY9+4azJ2/AO+sWc0Ka16vDs702fOwcV2s6OH06TOxceMGTF7yOLa++dyVWqOZcxHRdViGDtMyoOkaoqEwdN2kTmWxIp6CBWIRplmSZRmqrMLudKJw96W6Z/d/5hH4QyE01jfC29gIf8AHPaKx3zntNpw9dRy3kumzZkLTdJimyc4lrS1D6w5JooiN69Zh0rQZTDX2/qYNH/vffuTxx/H8c5dqel3OXfc/gFdf+gfuJNSE4dCaDlx3nSX33oc3X3kZv3rxdXzpU8ux9L5PQjAtvPGvO+tYOBzO7efTj38Zf37u/zBz3iJsWPs2mzdk9ExEtSirDnbsYOtit1/71lP4+TNPXXVbvEjpLRB85s5fBs0QYFgW3t+4A8PGDmfqt5490rBr204kpGVDEBW2LqHVuEWwApWyLGLrhjWYOW8hNqyNqf0nz1yEYCTCirFZtFIufbiqKnRdQGpqIkRZAHQNG9a8iokzFyEaiSDQFEJED0LXdbYNahqQBAEupx1xKcnYtv6SEEKZNGUq3t9yqZptM9sOnMfE4T2vmD973kKsu7h/s+bOY4UG31v3DjOb0ePZsfcgzFDTdftowrSZ2L5pAzNxaYbGCtcZhkEl7ZgdDSZMZlMDEyTOnD6NYcNHwu1y4f33t+CuBx6EBoKmxiY01NfD7/MiHA4BugkBElwuFedOn8LtZOKUKdi2ZQvag7mLl+Gdt97A4rvuxVuvtjbFLb/nPjZ9/Z8v3/L9ePCRz0EURbzwh99dfT8XLcM7b8fMVIvuuhcWMbH6tUtFWKm5kZ72la+9gmX33o83XomZdy/nM59/DH/6/dW3z+FwOg/3P/IoXnr+Dy3flz/4Wbz+1z+yz4OGT0IwFIFhmlAkCaUl5+GKS0Gix40LZ2JV2C8no+9MWJEq1JQe5aYuDofD4XA4nGa4qesmND53f/Z7sIwwDuzahXs+cT82rF6LnF69cer0CVgRHzNfASIz6QgSgUo1MpIISRZQuH0zHnjkCfzj+V+zbU2YMR/hiMbMQCIzp8iQFQmyYoMkSVRlBFOPIqrTdXQYWhSRcATRaATEMmCZ1EFYYGauhIQ4OGwqCvdSZ9tusAQF1cVFrfZ91uy5WL/unVbzHvjEClTV+Jg//MYN63EnMX7aDDT5/IhEIjB1HSIhEEUZNrsMj9ON3Tu3obPwic9+AX//429bzZu7aBF0nTBTG7MQAkxbOGPuQjaDavvefXvlNbUnl2NZTRDFhI99v6fPngvDonX/ANOizWAmWFVR6FWAjW1wauZwOF2TOUvvZs82ERIsUYCvvh6RSBTRiIZQWGPrVFw4gpzcwSg5f5h9X7OnBL/53+ew5uUX0H9oHxiagYgWhaZpqCn5cI0PF3xuQvDJK5gPwfDD1Km5xkRE06EoIhNCqJDSZ8AonDlRCEGSIIoCBo8chROHDzCzlU1VoaoKCrdvxYRpc9gDQ9MM9sCQJAGSIIFIAkT6ACEme9hrWgQRLQzDMAGTmnpifjLU7klNT7goMJ09fWt9XtqTUeMno3DHJR+qrsrkqTNhXTz/1LdoxryFeG/tKiy++wHIkgDTMPDmZaawRUuX4u2VK6/YzrZ9azFx5LyPtC/zFi7B2lWxSL/RE6fBNC02Rg8XbkdSSjZ69ukNu03Fts13ljDN4XDalzkLlrIo4alzF2LTRX+eibMWYNv61RgyYjzzW6X0HjgM0aiFb333KZw4cRp/e+H3cMd5kJiYynx/ouEoIpoGQ7eY8GQaUQTqz3FTF4fD4XA4HE4zXONzExqfQfmjcPrMaSSlZMQ0LoIAi1jMOdmyqEuuCFEALN0H2Z7ATBTUgVeUJahU42N3sKkkymx79LeiIEKURPpL6vbLIrwMg2p7NJY/xjBjEV+qLDKN0cmiI9fdR07XYNbc+YCowmZXoUgyG0uGrjFz0ztvv4UFS5Zg9ZtvomDaNBSMGAZXEsFPv/ML9tsHP/MZNmZLy+uwdUPsret6LFi8BLphwaI2LUGAavegsa4KetRkTswUOrUME0cO7kXB2MnYs7N9nME5HE7H4L//7084efY4zp04DkPTUFdTw557pqEhKSUL1bU1EESZmc2pP4ZAp6LANMxUy0Pzw1kW1TYb7Dd6oJqbum6F4NOrz0A0ef1MrR8M+mCj/js2JwuztogR8+0RqI/Ppd/Q75IsQ1ZV2O02yLKdmcdoKDdt1J+Hmiqob5BlGjBMC5ZBI6FMmKbBEsApiozjh68fMszp2ixcugIGTSVgGVi3dg3mLlgAUZAgyiJWrVyJZXfdhTdevRRl1czye+/C66/E5i9dtgwr33gDEyePxbatu/DaK8/gxZf3IBiJQtNN5ssjCtSsZrK/RccojfTiQg6Hw7kWO375SYx/MpZsdd6Su6DpBmiiEOq0Qd06aORvNBJCfVVlLI3IxQhg9qLFoF6wsUhgBiEw6TPXIizlCH1umlRZEGrkpi4Oh8PhcDicZrip62Y0Pr36s0gjan6ib7oCdUgmJgh1biYmwuEIM2O5XHZm4qLaHuqtLhABkkyT4MlQVTtUuwKbamOmq707Widn4nA+LuYuWszMXh9Gs6bnchYsXAJREvD2mysxY+487Np9CCOH5WPrpnX8BHE4nDZRuG8fKnb/Fosfj+XoocycT03nBtMgW4LAtMfRUBC+hnqmTW7W7RDS/ElkYa3ULiKQy5dTPRABMU0W3FFTVf6hGh9enf0mipTm5w8lPXv2IYIgkF59B8Wm/fJJ9559SE6PXqRHbu/YcsVFbK549pv+eUNIv/75JD41g60/eNjIdi8Cx9u1++D+zz/WJfpnzoLF7b4PvPE+4GOga42B9/YXXboHLWpdjPjjaLw6+22ozj5p9p3/8Hjksa7xIOeN9wEfA3wM8DHQ8cbAA5/9/G0TfKi3UIfg1KlTWLJkCVJSUpgKa8KECdi0aVOrdUpKSrBo0SK4XC623pNPPsm8wzkcDofD4XAYpIPQp08fMn/+fHLo0CFy6tQp8vjjjxOn00kqKyvZcsMwSH5+Ppk2bRrZv38/Wb9+PcnKyiJPPPHELdf4tHf7BNfmtPs54I33AR8DfAzwMYAb7oPPfvFLH3u/dQpTV21tLTuYrVu3tszz+Xxs3oYNG9j3NWvWEFEUSXl5ecs6L730ErHZbNfthEgkwpY3t9LSUj54+Q2sTWPg4TtQ4HzoDtwn3ngf8DHAxwA+Qh987gbva53C1JWcnIyBAwfixRdfRDAYZImKfv/73yM9PR0jR45k6+zcuRP5+fnIyspq+d2cOXMQjUaxb9++a277mWeeYVFczS0nJ+e2HBOHw+FwOJx2gHQQysrKyMiRI1lElCRJzIx14MCBluWPPvoomTVr1hW/U1WV/OMf/2hXjc9n+Fs4f+Pjb3x8DPAxwMcAHwOkuQ8++cUv3rLxcEdrfJ566qmLWY6v3QoLC6lwhscffxxpaWl4//33sWfPHubovHDhQlRWVrZsj67/Qehvrza/GZvNxpylL28fN3/63e+uueyxx5Z+7H+Pw2lPHn7sMX4COBzOdfnbb35zxbzP3OC944P3mm89819t+l2sWFQ78cQTT+C+++677jq5ubnYuHEjVq1ahcbGxhbB5LnnnsP69evxwgsv4Jvf/CYyMjKwe/fuVr+l69NaHtQkxuFwOBwOh9MhTF1vvfUWc1z2+/2t5vfr1488/fTTrZybKyoqWpa//PLLH+rc3BmiunjjfXCjY+BT3PzKrxt+3fAxgM7ZB50mqis5OZksX76cHDx4kJw8eZJ8/etfJ4qisO+Xh7PPmDGDhbPTaK9u3bp1iXB23ngf8DHAxwAfA3wM8DGAziP4UPbu3Utmz55NkpKSiMfjIWPHjmVansspLi4mCxYsIA6Hg61HhR7qvHwjcMGH3zz4zYOPAT4G+BjgYwCdVvDhRUpvokgph8PhcDicO5MPK1LaIfL4cDgcDofD4XwccMGHw+FwOBxOl4ELPhwOh8PhcLoMXPDhcDgcDofTZeCCD4fD4XA4nC4DF3w4HA6Hw+F0Gbjgw+FwOBwOp8vABR8Oh8PhcDhdBi74cDgcDofD6TJwwYfD4XA4HE6XgQs+HA6Hw+Fwugxc8OFwOBwOh9Nl4ILPB6AV6zkcDofD4XTO5zgXfD6A3++/leeDw+FwOBxOOz7HBcJVHK2wLAsVFRXweDwQBAF3Ij6fDzk5OSgtLUVcXFx7784dAe8T3id8nPBrh99Luvb9lRDChJ6srCyI4rX1OvJt3asOAO2sbt26oSNAB+CdPAjbA94nvE/4OOHXDr+XdN37a3x8/Ieuw01dHA6Hw+Fwugxc8OFwOBwOh9Nl4IJPB8Rms+H73/8+m3J4n/Bxwq8dfj/h91f+zGk73LmZw+FwOBxOl4FrfDgcDofD4XQZuODD4XA4HA6ny8AFHw6Hw+FwOF0GLvhwOBwOh8PpMnDB5w7m6aefxvjx4+F0OpGQkHDVdWh26Q+23/3ud63WOXLkCKZMmQKHw4Hs7Gz813/9V4etSdaWPikpKcGiRYvgcrmQkpKCJ598Epqmddo+uRq5ublXjItvfvObN9xPnYnnnnsOPXv2hN1ux8iRI/H++++jq/DUU09dMR4yMjJaltOxT9ehGW/pNTF16lQUFRWhM7F161Y23ukx0uNfuXJlq+Vt6YNoNIovfelL7Hqh183ixYtRVlaGztonDz/88BXjZuzYsR2+T7jgcwdDH0J33303vvCFL1x3vT//+c+orKxsaQ899FCrVOOzZs1iA3vv3r341a9+hZ/97Gd49tln0Rn7xDRNLFiwAMFgENu2bcPLL7+M1157DV/72tc6bZ9cCyrMXT4uvvvd795QP3UmXnnlFXzlK1/Bd77zHRw4cACTJk3CvHnzmPDXVRg0aFCr8UCF/2b+53/+h43/X//61+yaoEIRvUY6U+1COtaHDh3KjvFqtKUP6Bh644032PVCr5tAIICFCxey66kz9gll7ty5rcbNmjVrcDkdsk9orS7Onc2f//xnEh8ff9Vl9BS+8cYb1/ztc889x34biURa5j3zzDMkKyuLWJZFOlufrFmzhoiiSMrLy1vmvfTSS8RmsxGv19up++RyevToQf73f//3msvb0k+didGjR5PHHnus1bwBAwaQb37zm6Qr8P3vf58MHTr0qsvomM/IyCA//vGPW+bRa4NeI7/73e9IZ+SD98229EFTUxNRFIW8/PLLLevQ64deR++88w7p6OAqz5KHHnqILFmy5Jq/6ah9wjU+nYAnnniCqRkLCgqYmYsWWm1m586dzKRzebLDOXPmsEKsFy5cQGeDHm9+fj7T5lx+vFQdu2/fvi7VJz/5yU+QnJyMYcOGMRPh5WastvRTZ4EeNz2m2bNnt5pPv+/YsQNdhdOnT7PzTc199913H86dO8fmnz9/HlVVVa36h14b9BrpKv3Tlj6gY0jX9Vbr0P6k11Fn7qfNmzcjLS0N/fr1w6OPPoqampqWZR21T3iR0g7OD3/4Q8yYMYPZpN977z1mqqirq2sxa9CLmfp7XE56enrLMnoT7EzQY2o+vmYSExOhqipb1lX65Mtf/jJGjBjBjn3Pnj341re+xW7uf/zjH9vcT50Fej1QtfsHj5d+72zHei3GjBmDF198kT28qqur8aMf/Yj5ylEfluY+uFr/FBcXoyvQlj6g69Drg14nXWUczZs3j7kW9OjRg90/vve972H69OlM4KGCYUftE67xuQOcDD/YCgsL27w9KuCMGzeOvdVToYf6dfz0pz9ttQ7d5uU0O/F+cH5n6ZOrHRc95svn3+l98lH76d/+7d/Y2+qQIUPw2c9+lmkCn3/+edTX199QP3UmrnbOO+uxXu0BtmLFCgwePBgzZ87E6tWr2fwXXnihZZ2u3D8fpQ86cz/de++9zBeQanCoE/TatWtx6tSplvHTUfuEa3zawSxF1czX44PaiBuBetxT5136Vkelbuqg90HJu1lV+cG3m87QJ/R4d+/e3WpeY2MjU8c2H29H6JOPu5+aIzHOnDnDzF9t6afOAjUDS5J01XPe2Y61rdDoGyoEUfPX0qVL2TzaP5mZmV2yf5oj3K7XB3Qdajal18nlGg66DtWedQUyMzOZ9oeOm47cJ1zj0w434QEDBly30XDbm4VGrNDfN4d6U20QDVm83L9j3bp1zA77UQSsO7VP6PEePXqURR9cfrxULUtDmDtKn3zc/UTHBaX5pt6WfuosUFU8Pab169e3mk+/38k351sJ9eU6fvw4Gw/UtEsfYJf3D702tmzZ0mX6py19QMeQoiit1qHXD72Ouko/1dfXo7S0tOU+0mH7pL29qznXpri4mBw4cID84Ac/IG63m32mze/3s+VvvfUW+X//7/+RI0eOkDNnzpA//OEPJC4ujjz55JOtvO7T09PJ/fffz9Z7/fXX2To/+9nPOmWfGIZB8vPzyYwZM8j+/fvJhg0bSLdu3cgTTzzRafvkg+zYsYM8++yzrF/OnTtHXnnlFRaxtnjx4pZ12tJPnQkadUKjT55//nly7Ngx8pWvfIW4XC5y4cIF0hX42te+RjZv3szGw65du8jChQuJx+NpOX4azUQjmOi1QK8Jem1kZmYSn89HOgv0HtF8v6CPvuZrhN5T2toHNDKQXif0eqHXzfTp01m0HL2eOluf+P1+Nm7o/eT8+fNk06ZNZNy4cSQ7O7vD9wkXfO5gaCghHYwfbHQAUtauXUuGDRvGBACn08keZL/4xS+IruuttnP48GEyadIkFqpMQzafeuqpDhu2/WF9QqEX7YIFC4jD4SBJSUnsYX556Hpn65MPsm/fPjJmzBh2E7fb7aR///4snDkYDLZary391Jn4zW9+w8L8VVUlI0aMIFu2bCFdhXvvvZc9xKnwR4Xg5cuXk6KiopbldOzTMUKvBXpNTJ48mT38OxP0HnG1ewe9p7S1D8LhMLtO6PVCrxsqQJaUlJDO2CehUIjMnj2bpKamsnHTvXt3Nv+Dx9sR+0Sg/7W31onD4XA4HA7ndsB9fDgcDofD4XQZuODD4XA4HA6ny8AFHw6Hw+FwOF0GLvhwOBwOh8PpMnDBh8PhcDgcTpeBCz4cDofD4XC6DFzw4XA4HA6H02Xggg+Hw+FwOJwuAxd8OBwOh8PhdBm44MPhcDgcDqfLwAUfDofD4XA4XQYu+HA4nE5NbW0tMjIy8N///d8t83bv3g1VVbFu3bp23TcOh3P74UVKORxOp2fNmjVYunQpduzYgQEDBmD48OFYsGABfvGLX7T3rnE4nNsMF3w4HE6X4Itf/CI2bNiAgoICHDp0CHv37oXdbm/v3eJwOLcZLvhwOJwuQTgcRn5+PkpLS1FYWIghQ4a09y5xOJx2gPv4cDicLsG5c+dQUVEBy7JQXFzc3rvD4XDaCa7x4XA4nR5N0zB69GgMGzaM+fg8++yzOHLkCNLT09t71zgczm2GCz4cDqfT841vfAOvvvoq8+1xu92YNm0aPB4PVq1a1d67xuFwbjPc1MXhcDo1mzdvZtFbf/3rXxEXFwdRFNnnbdu24be//W177x6Hw7nNcI0Ph8PhcDicLgPX+HA4HA6Hw+kycMGHw+FwOBxOl4ELPhwOh8PhcLoMXPDhcDgcDofTZeCCD4fD4XA4nC4DF3w4HA6Hw+F0Gbjgw+FwOBwOp8vABR8Oh8PhcDhdBi74cDgcDofD6TJwwYfD4XA4HE6XgQs+HA6Hw+Fw0FX4//3hxyXZJb0tAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dataarray.plot.imshow()" + ] + }, + { + "cell_type": "markdown", + "id": "1d30749b", + "metadata": {}, + "source": [ + "Notice that most of the ocean areas are coloured black (pixel value 0) instead of\n", + "with a transparent colour. This is because `cog3pio=0.1.0` doesn't have the ability to\n", + "deal with NaN values yet, so you will need to manually handle this." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cupy-xarray", + "language": "python", + "name": "cupy-xarray" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/index.md b/docs/index.md index b400480..e567218 100644 --- a/docs/index.md +++ b/docs/index.md @@ -75,6 +75,7 @@ Large parts of this documentations comes from [SciPy 2023 Xarray on GPUs tutoria examples/04_high-level-api examples/05_apply-ufunc examples/06_real-example + examples/07_cog3pio **Tutorials & Presentations**: From 83e9c2a720c9f8c5d7cd33eb7f8637c8a7b9bcfa Mon Sep 17 00:00:00 2001 From: Wei Ji <23487320+weiji14@users.noreply.github.com> Date: Thu, 11 Jun 2026 16:17:30 +1200 Subject: [PATCH 16/16] Write up tutorial section on using xr.open_mfdataset to load many Tiffs Using LandCoverNet Australia example that offers nice small 256x256 Sentinel-2 tiles as separate TIFFs per band. Requires a hack in xarray to fix a `TypeError: Implicit conversion to a NumPy array is not allowed...`, and still, dask loads things into NumPy rather than CuPy... Added a summary section with extra links, oh so much more work to do! --- docs/examples/07_cog3pio.ipynb | 1486 ++++++++++++++++++++++++++++++-- 1 file changed, 1434 insertions(+), 52 deletions(-) diff --git a/docs/examples/07_cog3pio.ipynb b/docs/examples/07_cog3pio.ipynb index 11cd4b3..cb311f8 100644 --- a/docs/examples/07_cog3pio.ipynb +++ b/docs/examples/07_cog3pio.ipynb @@ -669,65 +669,17 @@ " stroke-width: 0.8px;\n", "}\n", "
<xarray.DataArray 'raster' (band: 3, y: 256, x: 512)> Size: 393kB\n",
-       "array([[[0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        ...,\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0]],\n",
-       "\n",
-       "       [[0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        ...,\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0]],\n",
-       "\n",
-       "       [[0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        ...,\n",
-       "        [0, 0, ..., 0, 0],\n",
-       "        [0, 0, ..., 0, 0]]], shape=(3, 256, 512), dtype=uint8)\n",
+       "[393216 values with dtype=uint8]\n",
        "Coordinates:\n",
        "  * band     (band) uint8 3B 0 1 2\n",
        "  * y        (y) float64 2kB 89.65 88.95 88.24 87.54 ... -88.24 -88.95 -89.65\n",
-       "  * x        (x) float64 4kB -179.6 -178.9 -178.2 -177.5 ... 178.2 178.9 179.6