diff --git a/.binder/conda-lock.yml b/.binder/conda-lock.yml index 3805a2f2..594f4785 100644 --- a/.binder/conda-lock.yml +++ b/.binder/conda-lock.yml @@ -15,9 +15,9 @@ metadata: - url: conda-forge used_env_vars: [] content_hash: - linux-64: a9096c0ec9e0da28a616a7cd5195dab1031d21fb745df69a95feb6a283140daa - osx-64: 89c1c35d776c0f1b3d62e1fd19c5976432944021d6ac9f353375f840c488f237 - win-64: 2562905301719ce1a1031bd3e8be2439edb55ff28fb5ae2de57cad0279b6ba28 + linux-64: a06ab1f6b457a8e01ffc7a0c8389db5666da7a52528bfea3171b297122101e98 + osx-64: ab65fbc2b501e3e5c402a28483b0fb11501ec06cae542e31b8d7179a96cc0e48 + win-64: 1d8ac907bf70156023b42600406482d8e59b586e2b3c87dabd321f2b1c0348d3 platforms: - linux-64 - osx-64 @@ -2079,6 +2079,18 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/linux-64/antlr-python-runtime-4.7.2-py311h38be061_1003.tar.bz2 version: 4.7.2 +- category: main + dependencies: + python: '' + hash: + md5: c0481c9de49f040272556e2cedf42816 + sha256: b3e9369529fe7d721b66f18680ff4b561e20dbf6507e209e1f60eac277c97560 + manager: conda + name: asciitree + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/noarch/asciitree-0.3.3-py_2.tar.bz2 + version: 0.3.3 - category: main dependencies: python: '>2.7' @@ -2417,6 +2429,18 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/noarch/executing-1.2.0-pyhd8ed1ab_0.tar.bz2 version: 1.2.0 +- category: main + dependencies: + python: '>=3.6' + hash: + md5: 348e27e78a5e39090031448c72f66d5e + sha256: 42be6ac8478051b26751d778490d6a71de12e5c6443e145ff3eddbc577d9bcda + manager: conda + name: fasteners + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/noarch/fasteners-0.17.3-pyhd8ed1ab_0.tar.bz2 + version: 0.17.3 - category: main dependencies: python: '>=3.7' @@ -2895,6 +2919,21 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda version: 1.3.0 +- category: main + dependencies: + libgcc-ng: '>=12' + libstdcxx-ng: '>=12' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + hash: + md5: 7415f24f8c44e44152623d93c5015000 + sha256: 9dea30d75b5eb31dac447aee56bf0648b5d58438a686123a2e085a166ed69900 + manager: conda + name: msgpack-python + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.0.5-py311ha3edf6b_0.conda + version: 1.0.5 - category: main dependencies: python: '' @@ -3251,14 +3290,14 @@ package: dependencies: python: '>=3.6' hash: - md5: b8afba5fbf891019eae564c3edb28b9e - sha256: 904c98c6bb45302f6349656d5e2f2743677da4254ac76be660475ecdd0fd0c6a + md5: de631f19ba156d224d80241e3fc7d32f + sha256: c0781a1aacc2227379c9614852bf92b967a0e8b52f66c04b5723e0b7b2bd4f1e manager: conda name: python-tzdata optional: false platform: linux-64 - url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2022.7-pyhd8ed1ab_0.conda - version: '2022.7' + url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2023.2-pyhd8ed1ab_0.conda + version: '2023.2' - category: main dependencies: libgcc-ng: '>=12' @@ -4544,6 +4583,24 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/linux-64/numba-0.56.3-py310ha5257ce_0.tar.bz2 version: 0.56.3 +- category: main + dependencies: + entrypoints: '' + libgcc-ng: '>=12' + libstdcxx-ng: '>=12' + msgpack-python: '' + numpy: '>=1.7' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + hash: + md5: ecdaf0772e524ed51218f6d52ef74424 + sha256: 0837de92c8251f2ce6940bcb404f6cb8a2bf5f6cfbc1f65d1c823ef223bcc6ca + manager: conda + name: numcodecs + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/numcodecs-0.11.0-py311hcafe171_1.conda + version: 0.11.0 - category: main dependencies: attrs: '>=19.2.0' @@ -5283,6 +5340,19 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-6.0.0-h8e241bc_0.conda version: 6.0.0 +- category: main + dependencies: + importlib-metadata: '' + python: '>=3.7' + hash: + md5: b2ec66de3480db2f5124f547cad7e7a4 + sha256: 0569bf2c7ad1f647b4f4b83dd1152df093585ff9a2ba38af98d7a2a348b2b74a + manager: conda + name: humanize + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/noarch/humanize-4.6.0-pyhd8ed1ab_0.conda + version: 4.6.0 - category: main dependencies: importlib-metadata: '>=6.1.0,<6.1.1.0a0' @@ -5740,6 +5810,22 @@ package: platform: linux-64 url: https://conda.anaconda.org/conda-forge/noarch/wsproto-1.2.0-pyhd8ed1ab_0.tar.bz2 version: 1.2.0 +- category: main + dependencies: + asciitree: '' + fasteners: '' + numcodecs: '>=0.10.0' + numpy: '>=1.7' + python: '>=3.5' + hash: + md5: 0c5776fe65a12a421d7ddf90411a6c3f + sha256: 0f029f7efea00b8258782b5e68989fc140c227e6d9edd231d46fdd954b39d23f + manager: conda + name: zarr + optional: false + platform: linux-64 + url: https://conda.anaconda.org/conda-forge/noarch/zarr-2.14.2-pyhd8ed1ab_0.conda + version: 2.14.2 - category: main dependencies: argon2-cffi-bindings: '' @@ -9768,7 +9854,6 @@ package: - category: main dependencies: joblib: '>=1.1.1' - libcblas: '>=3.9.0,<4.0a0' libgcc-ng: '>=12' libstdcxx-ng: '>=12' numpy: '>=1.23.5,<2.0a0' @@ -9777,13 +9862,13 @@ package: scipy: '' threadpoolctl: '>=2.0.0' hash: - md5: c928bd2c1f3dfe6e5c89bbc5f03af284 - sha256: 344b84f89a2d537c250d4eff98ee85c4bfbfb0227174448c4e03bbf4e6126345 + md5: 1a69529b0bcf0e3a03e6585903659df7 + sha256: 7bf78d2c375b53e3a61fcd70847b12d2152a2699e43224ba9817badb199a62f1 manager: conda name: scikit-learn optional: false platform: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.2.2-py311h67c5ca5_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.2.2-py311h103fc68_1.conda version: 1.2.2 - category: main dependencies: @@ -12665,6 +12750,18 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.3-pyhd8ed1ab_0.tar.bz2 version: 0.1.3 +- category: main + dependencies: + python: '' + hash: + md5: c0481c9de49f040272556e2cedf42816 + sha256: b3e9369529fe7d721b66f18680ff4b561e20dbf6507e209e1f60eac277c97560 + manager: conda + name: asciitree + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/noarch/asciitree-0.3.3-py_2.tar.bz2 + version: 0.3.3 - category: main dependencies: python: '>2.7' @@ -13013,6 +13110,18 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/noarch/executing-1.2.0-pyhd8ed1ab_0.tar.bz2 version: 1.2.0 +- category: main + dependencies: + python: '>=3.6' + hash: + md5: 348e27e78a5e39090031448c72f66d5e + sha256: 42be6ac8478051b26751d778490d6a71de12e5c6443e145ff3eddbc577d9bcda + manager: conda + name: fasteners + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/noarch/fasteners-0.17.3-pyhd8ed1ab_0.tar.bz2 + version: 0.17.3 - category: main dependencies: python: '>=3.7' @@ -13407,6 +13516,20 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda version: 1.3.0 +- category: main + dependencies: + libcxx: '>=14.0.6' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + hash: + md5: d3a60c5422b7d61b2740c7c5df508c86 + sha256: ebe4d269e0605e7de3b9a9199e1e20d96c66945ac67fe1fccf778177d1a615a7 + manager: conda + name: msgpack-python + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.0.5-py311hd2070f0_0.conda + version: 1.0.5 - category: main dependencies: python: '' @@ -13758,14 +13881,14 @@ package: dependencies: python: '>=3.6' hash: - md5: b8afba5fbf891019eae564c3edb28b9e - sha256: 904c98c6bb45302f6349656d5e2f2743677da4254ac76be660475ecdd0fd0c6a + md5: de631f19ba156d224d80241e3fc7d32f + sha256: c0781a1aacc2227379c9614852bf92b967a0e8b52f66c04b5723e0b7b2bd4f1e manager: conda name: python-tzdata optional: false platform: osx-64 - url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2022.7-pyhd8ed1ab_0.conda - version: '2022.7' + url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2023.2-pyhd8ed1ab_0.conda + version: '2023.2' - category: main dependencies: python: '>=3.11,<3.12.0a0' @@ -15636,6 +15759,19 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/osx-64/harfbuzz-6.0.0-h08f8713_0.conda version: 6.0.0 +- category: main + dependencies: + importlib-metadata: '' + python: '>=3.7' + hash: + md5: b2ec66de3480db2f5124f547cad7e7a4 + sha256: 0569bf2c7ad1f647b4f4b83dd1152df093585ff9a2ba38af98d7a2a348b2b74a + manager: conda + name: humanize + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/noarch/humanize-4.6.0-pyhd8ed1ab_0.conda + version: 4.6.0 - category: main dependencies: importlib-metadata: '>=6.1.0,<6.1.1.0a0' @@ -16522,6 +16658,23 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/osx-64/numba-0.56.3-py310h62db5c2_0.tar.bz2 version: 0.56.3 +- category: main + dependencies: + entrypoints: '' + libcxx: '>=14.0.6' + msgpack-python: '' + numpy: '>=1.7' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + hash: + md5: 21f2ae35161c19b8c4ad0791d12ef2a3 + sha256: 27c7eb0a5f6b3726252c5331b6101d492b8280af0a041b1c8b5fcd45ee56268d + manager: conda + name: numcodecs + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/numcodecs-0.11.0-py311h814d153_1.conda + version: 0.11.0 - category: main dependencies: libcxx: '>=14.0.6' @@ -17043,6 +17196,22 @@ package: platform: osx-64 url: https://conda.anaconda.org/conda-forge/noarch/xarray-2023.3.0-pyhd8ed1ab_0.conda version: 2023.3.0 +- category: main + dependencies: + asciitree: '' + fasteners: '' + numcodecs: '>=0.10.0' + numpy: '>=1.7' + python: '>=3.5' + hash: + md5: 0c5776fe65a12a421d7ddf90411a6c3f + sha256: 0f029f7efea00b8258782b5e68989fc140c227e6d9edd231d46fdd954b39d23f + manager: conda + name: zarr + optional: false + platform: osx-64 + url: https://conda.anaconda.org/conda-forge/noarch/zarr-2.14.2-pyhd8ed1ab_0.conda + version: 2.14.2 - category: main dependencies: python: '>=3.8' @@ -18165,7 +18334,6 @@ package: - category: main dependencies: joblib: '>=1.1.1' - libcblas: '>=3.9.0,<4.0a0' libcxx: '>=14.0.6' llvm-openmp: '>=14.0.6' numpy: '>=1.23.5,<2.0a0' @@ -18174,13 +18342,13 @@ package: scipy: '' threadpoolctl: '>=2.0.0' hash: - md5: 7eedaa9f41426c4208d97ebea14b59b7 - sha256: 6765710a393afdde4e96d75047d81ca5276dc6c1b3a0390ee78c9a829c054b33 + md5: e2dd2bd2dcf23b11d5af2d6df01904a6 + sha256: 5595daa14a0d93752eef7b266b0bdf0a8c1b12c1260c6f1e6862c52ab030772b manager: conda name: scikit-learn optional: false platform: osx-64 - url: https://conda.anaconda.org/conda-forge/osx-64/scikit-learn-1.2.2-py311h087fafe_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/scikit-learn-1.2.2-py311hda7f639_1.conda version: 1.2.2 - category: main dependencies: @@ -22877,6 +23045,18 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/win-64/antlr-python-runtime-4.7.2-py311h1ea47a8_1003.tar.bz2 version: 4.7.2 +- category: main + dependencies: + python: '' + hash: + md5: c0481c9de49f040272556e2cedf42816 + sha256: b3e9369529fe7d721b66f18680ff4b561e20dbf6507e209e1f60eac277c97560 + manager: conda + name: asciitree + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/noarch/asciitree-0.3.3-py_2.tar.bz2 + version: 0.3.3 - category: main dependencies: python: '>2.7' @@ -23225,6 +23405,18 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/noarch/executing-1.2.0-pyhd8ed1ab_0.tar.bz2 version: 1.2.0 +- category: main + dependencies: + python: '>=3.6' + hash: + md5: 348e27e78a5e39090031448c72f66d5e + sha256: 42be6ac8478051b26751d778490d6a71de12e5c6443e145ff3eddbc577d9bcda + manager: conda + name: fasteners + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/noarch/fasteners-0.17.3-pyhd8ed1ab_0.tar.bz2 + version: 0.17.3 - category: main dependencies: python: '>=3.7' @@ -23712,6 +23904,22 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda version: 1.3.0 +- category: main + dependencies: + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + ucrt: '>=10.0.20348.0' + vc: '>=14.2,<15' + vs2015_runtime: '>=14.29.30139' + hash: + md5: 01a252f384a5d1ad338cff1184d9a9c0 + sha256: 0df20f87b92ad3e86f4ed468d753901bf2da4e4661e395e8dbc5ee4f652ca9cc + manager: conda + name: msgpack-python + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.0.5-py311h005e61a_0.conda + version: 1.0.5 - category: main dependencies: python: '' @@ -24024,14 +24232,14 @@ package: dependencies: python: '>=3.6' hash: - md5: b8afba5fbf891019eae564c3edb28b9e - sha256: 904c98c6bb45302f6349656d5e2f2743677da4254ac76be660475ecdd0fd0c6a + md5: de631f19ba156d224d80241e3fc7d32f + sha256: c0781a1aacc2227379c9614852bf92b967a0e8b52f66c04b5723e0b7b2bd4f1e manager: conda name: python-tzdata optional: false platform: win-64 - url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2022.7-pyhd8ed1ab_0.conda - version: '2022.7' + url: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2023.2-pyhd8ed1ab_0.conda + version: '2023.2' - category: main dependencies: python: '>=3.11,<3.12.0a0' @@ -26021,6 +26229,19 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/win-64/glib-2.74.1-h12be248_1.tar.bz2 version: 2.74.1 +- category: main + dependencies: + importlib-metadata: '' + python: '>=3.7' + hash: + md5: b2ec66de3480db2f5124f547cad7e7a4 + sha256: 0569bf2c7ad1f647b4f4b83dd1152df093585ff9a2ba38af98d7a2a348b2b74a + manager: conda + name: humanize + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/noarch/humanize-4.6.0-pyhd8ed1ab_0.conda + version: 4.6.0 - category: main dependencies: importlib-metadata: '>=6.1.0,<6.1.1.0a0' @@ -27342,6 +27563,25 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/win-64/numba-0.56.3-py310h19bcfe9_0.tar.bz2 version: 0.56.3 +- category: main + dependencies: + entrypoints: '' + msgpack-python: '' + numpy: '>=1.7' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* *_cp311 + ucrt: '>=10.0.20348.0' + vc: '>=14.2,<15' + vs2015_runtime: '>=14.29.30139' + hash: + md5: 9b66ec550742f950ba5fdc1fe650ce26 + sha256: 07dc9ec52ddb18a70f8ada65a9be9a982a427b6bcd479725659cc0d34d9e8fa0 + manager: conda + name: numcodecs + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/numcodecs-0.11.0-py311h12c1d0e_1.conda + version: 0.11.0 - category: main dependencies: dataclasses: '' @@ -29471,6 +29711,22 @@ package: platform: win-64 url: https://conda.anaconda.org/conda-forge/noarch/xarray-2023.3.0-pyhd8ed1ab_0.conda version: 2023.3.0 +- category: main + dependencies: + asciitree: '' + fasteners: '' + numcodecs: '>=0.10.0' + numpy: '>=1.7' + python: '>=3.5' + hash: + md5: 0c5776fe65a12a421d7ddf90411a6c3f + sha256: 0f029f7efea00b8258782b5e68989fc140c227e6d9edd231d46fdd954b39d23f + manager: conda + name: zarr + optional: false + platform: win-64 + url: https://conda.anaconda.org/conda-forge/noarch/zarr-2.14.2-pyhd8ed1ab_0.conda + version: 2.14.2 - category: main dependencies: geos: '>=3.11.2,<3.11.3.0a0' @@ -30241,7 +30497,6 @@ package: - category: main dependencies: joblib: '>=1.1.1' - libcblas: '>=3.9.0,<4.0a0' numpy: '>=1.23.5,<2.0a0' python: '>=3.11,<3.12.0a0' python_abi: 3.11.* *_cp311 @@ -30251,13 +30506,13 @@ package: vc: '>=14.2,<15' vs2015_runtime: '>=14.29.30139' hash: - md5: 05b85818eef8dd80bfd854b9bde11e09 - sha256: 0f7f139c9218348c0ab53057e0f6a78da240a911ebef0e9e21af3bdecd29f39b + md5: ce1dbe81f1199a0e2719c9876715f7d4 + sha256: d362742096303d8d4eb0f052d53327074e9bbbae6ad297f7bde7a92c16f238ea manager: conda name: scikit-learn optional: false platform: win-64 - url: https://conda.anaconda.org/conda-forge/win-64/scikit-learn-1.2.2-py311h6619ee7_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/scikit-learn-1.2.2-py311h142b183_1.conda version: 1.2.2 - category: main dependencies: diff --git a/.binder/environment-python_and_r.yml b/.binder/environment-python_and_r.yml index 01e961c3..0dd44b2c 100644 --- a/.binder/environment-python_and_r.yml +++ b/.binder/environment-python_and_r.yml @@ -23,6 +23,7 @@ dependencies: - geopandas - geoplot - gridgeo + - humanize - hvplot - ioos_qc - ipyleaflet @@ -63,6 +64,7 @@ dependencies: - xarray - xlrd - xmltodict + - zarr # R packages. - rpy2 - r-base=4 diff --git a/.binder/environment.yml b/.binder/environment.yml index 3723d6d5..f6ba20cb 100644 --- a/.binder/environment.yml +++ b/.binder/environment.yml @@ -22,6 +22,7 @@ dependencies: - geopandas - geoplot - gridgeo + - humanize - hvplot - ioos_qc - ipyleaflet @@ -62,3 +63,4 @@ dependencies: - xarray - xlrd - xmltodict + - zarr diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3ab1c1fb..b0a06279 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -35,12 +35,12 @@ repos: - id: add-trailing-comma - repo: https://github.com/charliermarsh/ruff-pre-commit - rev: v0.0.254 + rev: v0.0.257 hooks: - id: ruff - repo: https://github.com/nbQA-dev/nbQA - rev: 1.6.3 + rev: 1.6.4 hooks: # mdformat works on the CLI but not as pre-commit yet. # Use `nbqa mdformat jupyterbook --nbqa-md` to run it locally. diff --git a/jupyterbook/content/code_gallery/data_management_notebooks/2023-03-20-Reading_and_writing_zarr.ipynb b/jupyterbook/content/code_gallery/data_management_notebooks/2023-03-20-Reading_and_writing_zarr.ipynb new file mode 100644 index 00000000..76be410b --- /dev/null +++ b/jupyterbook/content/code_gallery/data_management_notebooks/2023-03-20-Reading_and_writing_zarr.ipynb @@ -0,0 +1,1681 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "29370978", + "metadata": {}, + "source": [ + "# Reading and writting zarr files with xarray\n", + "\n", + "\n", + "Created: 2023-03-20\n", + "\n", + "\n", + "\n", + "[The zarr format](https://zarr.readthedocs.io/en/stable/) is a file storage based specification for chunked, compressed, N-dimensional arrays. The format is based on an open-source specification and its main goal is to make cloud data read/write a bit easier and more effective.\n", + "\n", + "The main propblems in data storage are:\n", + "\n", + "1. Read/write data that is larger than memory\n", + "1. Being able to parallelize computations\n", + "1. Reduce the I/O botteneck\n", + "1. Compression\n", + "1. Speed\n", + "\n", + "One solution is to use a chunked\\* parallel computing framework and a chunked parallel storage library. Zarr helps us with the latter.\n", + "\n", + "In this example we will load an ocean model data, stored as netCDF and served via THREDDS, subset it and save as zarr. Let's start by saving a single time step for the surface layer temperature and salinity.\n", + "\n", + "\n", + "\\* Many data formats can take advantage of storing the data in chunks for faster access, the zarr approach is different in that each chunk is a different object in cloud storage, making them better for parallel access. The chunks can be compressed to reduce their size and improve cloud performance even further. Zarr has a nice tutorial on how to balance chunk size for performance. Check it out: https://zarr.readthedocs.io/en/stable/tutorial.html#chunk-optimizations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2961833f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:   (time: 1, eta_rho: 106, xi_rho: 242)\n",
+       "Coordinates:\n",
+       "    s_rho     float64 -0.0125\n",
+       "    lon_rho   (eta_rho, xi_rho) float64 ...\n",
+       "    lat_rho   (eta_rho, xi_rho) float64 ...\n",
+       "  * time      (time) datetime64[ns] 2022-06-06T12:00:00\n",
+       "    time_run  (time) datetime64[ns] ...\n",
+       "Dimensions without coordinates: eta_rho, xi_rho\n",
+       "Data variables:\n",
+       "    temp      (time, eta_rho, xi_rho) float64 ...\n",
+       "    salt      (time, eta_rho, xi_rho) float64 ...\n",
+       "Attributes: (12/46)\n",
+       "    file:                            doppio_avg_6280_0004.nc\n",
+       "    format:                          netCDF-4/HDF5 file\n",
+       "    Conventions:                     CF-1.4, SGRID-0.3\n",
+       "    type:                            ROMS/TOMS nonlinear model averages file\n",
+       "    title:                           ROMS doppio Real-Time Operational PSAS F...\n",
+       "    var_info:                        ../Data/varinfo1040t_daily.dat\n",
+       "    ...                              ...\n",
+       "    his_base:                        doppio_his_6280\n",
+       "    cdm_data_type:                   GRID\n",
+       "    featureType:                     GRID\n",
+       "    location:                        Proto fmrc:doppio_2017_da_avg\n",
+       "    summary:                         doppio\n",
+       "    DODS_EXTRA.Unlimited_Dimension:  ocean_time
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 1, eta_rho: 106, xi_rho: 242)\n", + "Coordinates:\n", + " s_rho float64 -0.0125\n", + " lon_rho (eta_rho, xi_rho) float64 ...\n", + " lat_rho (eta_rho, xi_rho) float64 ...\n", + " * time (time) datetime64[ns] 2022-06-06T12:00:00\n", + " time_run (time) datetime64[ns] ...\n", + "Dimensions without coordinates: eta_rho, xi_rho\n", + "Data variables:\n", + " temp (time, eta_rho, xi_rho) float64 ...\n", + " salt (time, eta_rho, xi_rho) float64 ...\n", + "Attributes: (12/46)\n", + " file: doppio_avg_6280_0004.nc\n", + " format: netCDF-4/HDF5 file\n", + " Conventions: CF-1.4, SGRID-0.3\n", + " type: ROMS/TOMS nonlinear model averages file\n", + " title: ROMS doppio Real-Time Operational PSAS F...\n", + " var_info: ../Data/varinfo1040t_daily.dat\n", + " ... ...\n", + " his_base: doppio_his_6280\n", + " cdm_data_type: GRID\n", + " featureType: GRID\n", + " location: Proto fmrc:doppio_2017_da_avg\n", + " summary: doppio\n", + " DODS_EXTRA.Unlimited_Dimension: ocean_time" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "url = (\n", + " \"https://tds.marine.rutgers.edu/thredds/dodsC/roms/doppio/2017_da/avg/Averages_Best\"\n", + ")\n", + "\n", + "ds = xr.open_dataset(url)\n", + "\n", + "time_slice = {\"time\": \"2022-06-06\"}\n", + "surface = {\"s_rho\": -1}\n", + "\n", + "ds = ds[[\"temp\", \"salt\"]].sel(time_slice).isel(surface)\n", + "\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d8fa04f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'820.9 kB'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import humanize\n", + "\n", + "humanize.naturalsize(ds.nbytes)" + ] + }, + { + "cell_type": "markdown", + "id": "a661b199", + "metadata": {}, + "source": [ + "It is a small subset but it is enough to ilustrate zarr's compression options.\n", + "\n", + "Now let's choose a compression level and save it as zarr." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d8e3601c", + "metadata": {}, + "outputs": [], + "source": [ + "import zarr\n", + "\n", + "compressor = zarr.Blosc(clevel=2, shuffle=-1)\n", + "\n", + "\n", + "fname = \"doppio/doppio_compressed.zarr\"\n", + "\n", + "ds.to_zarr(\n", + " fname,\n", + " mode=\"w\",\n", + " safe_chunks=True,\n", + " consolidated=True,\n", + " encoding={var: {\"compressor\": compressor} for var in ds.variables},\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d982caef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[01;34mdoppio/doppio_compressed.zarr\u001b[0m\n", + "├── \u001b[01;34mlat_rho\u001b[0m\n", + "│   └── 0.0\n", + "├── \u001b[01;34mlon_rho\u001b[0m\n", + "│   └── 0.0\n", + "├── \u001b[01;34msalt\u001b[0m\n", + "│   └── 0.0.0\n", + "├── \u001b[01;34ms_rho\u001b[0m\n", + "│   └── 0\n", + "├── \u001b[01;34mtemp\u001b[0m\n", + "│   └── 0.0.0\n", + "├── \u001b[01;34mtime\u001b[0m\n", + "│   └── 0\n", + "└── \u001b[01;34mtime_run\u001b[0m\n", + " └── 0\n", + "\n", + "7 directories, 7 files\n", + "144K\tdoppio/doppio_compressed.zarr/salt\n", + "156K\tdoppio/doppio_compressed.zarr/lat_rho\n", + "148K\tdoppio/doppio_compressed.zarr/temp\n", + "16K\tdoppio/doppio_compressed.zarr/time\n", + "16K\tdoppio/doppio_compressed.zarr/s_rho\n", + "16K\tdoppio/doppio_compressed.zarr/time_run\n", + "156K\tdoppio/doppio_compressed.zarr/lon_rho\n", + "676K\tdoppio/doppio_compressed.zarr\n" + ] + } + ], + "source": [ + "!tree doppio/*zarr\n", + "!du -h doppio/*zarr" + ] + }, + { + "cell_type": "markdown", + "id": "e345b204", + "metadata": {}, + "source": [ + "The first thing to observe is that the zarr format is a directory based storage. That structure should be familiar for HDF5 users. However, instead of being a filesystem inside a filesystem, zarr is layed out directly on the disk filesystem.\n", + "\n", + "Each variable and coordinate has its own directory and the data chunks are stored in subdirectories. For more information [check this awesome](https://www.youtube.com/watch?v=qyJXBlrdzBs&list=PLKbXDtRY2ZfU6OfZ8JQimBEY-u1WLCpwp) presentation from one of zarr authors.\n", + "\n", + "Note that the stored size is quite smaller too! We went from 820.9 kB to 676 kB. Zarr has many modern compression oprions as plugins, [including some bitinformation based methods](https://xbitinfo.readthedocs.io/en/latest/api/xbitinfo.save_compressed.ToCompressed_Zarr.html).\n", + "\n", + "The data attributes, groups, and metdata are stored in the `.zattrs`, `.zgroup`, and `.zmetadata`. They are plain text JSON files and easy to parse:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44822485", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'metadata': {'.zattrs': {'CPP_options': 'DOPPIO, ADD_FSOBC, ADD_M2OBC, ANA_BSFLUX, ANA_BTFLUX, ASSUMED_SHAPE, ATM_PRESS, AVERAGES, !BOUNDARY_A BULK_FLUXES, !COLLECT_ALL..., CHARNOK, CRAIG_BANNER, CURVGRID, DEFLATE, DIURNAL_SRFLUX, DJ_GRADPS, DOUBLE_PRECISION, EMINUSP, FLOATS, FORWARD_WRITE, GLS_MIXING, HDF5, KANTHA_CLAYSON, LONGWAVE_OUT, MASKING, MIX_GEO_TS, MIX_S_UV, MPI, NONLINEAR, NONLIN_EOS, NO_LBC_ATT, N2S2_HORAVG, OUT_DOUBLE, POWER_LAW, PROFILE, K_GSCHEME, REDUCE_ALLREDUCE, !RST_SINGLE, SALINITY, SOLAR_SOURCE, SOLVE3D, SSH_TIDES, TS_DIF2, UV_ADV, UV_COR, UV_U3HADVECTION, UV_C4VADVECTION, UV_QDRAG, UV_TIDES, UV_VIS2, VAR_RHO_2D, WIND_MINUS_CURRENT',\n", + " 'Conventions': 'CF-1.4, SGRID-0.3',\n", + " 'DODS_EXTRA.Unlimited_Dimension': 'ocean_time',\n", + " 'NLM_LBC': '\\nEDGE: WEST SOUTH EAST NORTH \\nzeta: Cha Cha Cha Clo \\nubar: Fla Fla Fla Clo \\nvbar: Fla Fla Fla Clo \\nu: RadNud RadNud RadNud Clo \\nv: RadNud RadNud RadNud Clo \\ntemp: Rad Rad Rad Clo \\nsalt: Rad Rad Rad Clo \\ntke: Gra Gra Gra Clo',\n", + " 'NLM_TADV': '\\nADVECTION: HORIZONTAL VERTICAL \\ntemp: Akima4 Akima4 \\nsalt: Akima4 Akima4',\n", + " '_CoordSysBuilder': 'ucar.nc2.dataset.conv.CF1Convention',\n", + " 'ana_file': 'ROMS/Functionals/ana_btflux.h, ROMS/Functionals/ana_srflux.h',\n", + " 'avg_base': 'doppio_avg_6280',\n", + " 'cdm_data_type': 'GRID',\n", + " 'clm_file_01': '../Data/doppio_clm.nc',\n", + " 'code_dir': '/home/julia/ROMS/doppio/svn1040t',\n", + " 'compiler_command': '/opt/sw/apps/intel-18.0.1/openmpi/3.1.2/bin/mpif90',\n", + " 'compiler_flags': '-fp-model precise -heap-arrays -ip -O3 -traceback -check uninit',\n", + " 'compiler_system': 'ifort',\n", + " 'cpu': 'x86_64',\n", + " 'featureType': 'GRID',\n", + " 'file': 'doppio_avg_6280_0004.nc',\n", + " 'flt_file': 'doppio_flt_6280.nc',\n", + " 'format': 'netCDF-4/HDF5 file',\n", + " 'fpos_file': 'floats.in',\n", + " 'frc_file_01': '../Data/lwrad_down_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_02': '../Data/Pair_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_03': '../Data/Qair_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_04': '../Data/rain_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_05': '../Data/swrad_daily_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_06': '../Data/Tair_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'frc_file_07': '../Data/Winds_ncepnam_3hourly_MAB_and_GoM.nc',\n", + " 'grd_file': '/home/om/roms/doppio/7km/grid_doppio_JJA_v13.nc',\n", + " 'header_dir': '/home/julia/ROMS/doppio/Compile/fwd',\n", + " 'header_file': 'doppio.h',\n", + " 'his_base': 'doppio_his_6280',\n", + " 'history': 'ROMS/TOMS, Version 3.9, Thursday - March 16, 2023 - 4:32:53 AM ;\\nFMRC Best Dataset',\n", + " 'ini_file': 'doppio_rst_6280.nc',\n", + " 'location': 'Proto fmrc:doppio_2017_da_avg',\n", + " 'nud_file': '/home/om/roms/doppio/7km/doppio_nudgcoef_7km_1500-2000_GS.nc',\n", + " 'os': 'Linux',\n", + " 'rst_file': 'tmp_doppio_rst_6280.nc',\n", + " 'script_file': 'nl_ocean_doppio.in',\n", + " 'summary': 'doppio',\n", + " 'svn_rev': '1040',\n", + " 'svn_url': 'https://www.myroms.org/svn/src/trunk',\n", + " 'tide_file': '/home/om/roms/doppio/7km/doppio_tide_7km.nc',\n", + " 'tiling': '004x004',\n", + " 'title': 'ROMS doppio Real-Time Operational PSAS Forecast System Version 1 FMRC Averages',\n", + " 'type': 'ROMS/TOMS nonlinear model averages file',\n", + " 'var_info': '../Data/varinfo1040t_daily.dat'},\n", + " '.zgroup': {'zarr_format': 2},\n", + " 'lat_rho/.zarray': {'chunks': [106, 242],\n", + " 'compressor': {'blocksize': 0,\n", + " 'clevel': 2,\n", + " 'cname': 'lz4',\n", + " 'id': 'blosc',\n", + " 'shuffle': -1},\n", + " 'dtype': '\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:   (eta_rho: 106, xi_rho: 242, time: 1)\n",
+       "Coordinates:\n",
+       "    lat_rho   (eta_rho, xi_rho) float64 dask.array<chunksize=(106, 242), meta=np.ndarray>\n",
+       "    lon_rho   (eta_rho, xi_rho) float64 dask.array<chunksize=(106, 242), meta=np.ndarray>\n",
+       "    s_rho     float64 ...\n",
+       "  * time      (time) datetime64[ns] 2022-06-06T12:00:00\n",
+       "    time_run  (time) datetime64[ns] dask.array<chunksize=(1,), meta=np.ndarray>\n",
+       "Dimensions without coordinates: eta_rho, xi_rho\n",
+       "Data variables:\n",
+       "    salt      (time, eta_rho, xi_rho) float64 dask.array<chunksize=(1, 106, 242), meta=np.ndarray>\n",
+       "    temp      (time, eta_rho, xi_rho) float64 dask.array<chunksize=(1, 106, 242), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    CPP_options:                     DOPPIO, ADD_FSOBC, ADD_M2OBC, ANA_BSFLUX...\n",
+       "    Conventions:                     CF-1.4, SGRID-0.3\n",
+       "    DODS_EXTRA.Unlimited_Dimension:  ocean_time\n",
+       "    NLM_LBC:                         \\nEDGE:  WEST   SOUTH  EAST   NORTH  \\nz...\n",
+       "    NLM_TADV:                        \\nADVECTION:   HORIZONTAL   VERTICAL    ...\n",
+       "    _CoordSysBuilder:                ucar.nc2.dataset.conv.CF1Convention\n",
+       "    ...                              ...\n",
+       "    svn_url:                         https://www.myroms.org/svn/src/trunk\n",
+       "    tide_file:                       /home/om/roms/doppio/7km/doppio_tide_7km.nc\n",
+       "    tiling:                          004x004\n",
+       "    title:                           ROMS doppio Real-Time Operational PSAS F...\n",
+       "    type:                            ROMS/TOMS nonlinear model averages file\n",
+       "    var_info:                        ../Data/varinfo1040t_daily.dat
" + ], + "text/plain": [ + "\n", + "Dimensions: (eta_rho: 106, xi_rho: 242, time: 1)\n", + "Coordinates:\n", + " lat_rho (eta_rho, xi_rho) float64 dask.array\n", + " lon_rho (eta_rho, xi_rho) float64 dask.array\n", + " s_rho float64 ...\n", + " * time (time) datetime64[ns] 2022-06-06T12:00:00\n", + " time_run (time) datetime64[ns] dask.array\n", + "Dimensions without coordinates: eta_rho, xi_rho\n", + "Data variables:\n", + " salt (time, eta_rho, xi_rho) float64 dask.array\n", + " temp (time, eta_rho, xi_rho) float64 dask.array\n", + "Attributes: (12/46)\n", + " CPP_options: DOPPIO, ADD_FSOBC, ADD_M2OBC, ANA_BSFLUX...\n", + " Conventions: CF-1.4, SGRID-0.3\n", + " DODS_EXTRA.Unlimited_Dimension: ocean_time\n", + " NLM_LBC: \\nEDGE: WEST SOUTH EAST NORTH \\nz...\n", + " NLM_TADV: \\nADVECTION: HORIZONTAL VERTICAL ...\n", + " _CoordSysBuilder: ucar.nc2.dataset.conv.CF1Convention\n", + " ... ...\n", + " svn_url: https://www.myroms.org/svn/src/trunk\n", + " tide_file: /home/om/roms/doppio/7km/doppio_tide_7km.nc\n", + " tiling: 004x004\n", + " title: ROMS doppio Real-Time Operational PSAS F...\n", + " type: ROMS/TOMS nonlinear model averages file\n", + " var_info: ../Data/varinfo1040t_daily.dat" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subset = xr.open_zarr(fname)\n", + "\n", + "subset" + ] + }, + { + "cell_type": "markdown", + "id": "eeded07f", + "metadata": {}, + "source": [ + "And a quick plot to check the data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fb7122f3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAAHVCAYAAAAO+9SSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d7xdVbU9Ptba+7RbUyGhJaElUhIgSPVRJDx84qOJiKBSpPiI9CKISKJAqEkABb+AIj8p+hClCEoUSGzgQwKCCCKQQFAxkECSW07Ze83fH6vvc27LTc8an89J7tl17b3PvWucOccckxERISAgICAgICAgoA58bQ8gICAgICAgIGBdRSBKAQEBAQEBAQE9IBClgICAgICAgIAeEIhSQEBAQEBAQEAPCEQpICAgICAgIKAHBKIUEBAQEBAQENADAlEKCAgICAgICOgBgSgFBAQEBAQEBPSAQJQCAgICAgICAnpAIEqrEAcccAB22mmntT2MVYbFixfjxBNPxIgRI9DU1IS9994bTzzxRL/3f/PNN3HUUUdhyJAhaGlpwcEHH4z58+fXbff//X//H4499liMHz8enHOMHTu24fGefPJJnHzyyZgwYQKam5ux+eab4/DDD8dzzz1Xt+2JJ54Ixljda8KECf0efxaPPfYYpk2b1nDd2LFjceKJJ670sddlPPfcc5g6dSp23nlntLa2YtNNN8WUKVPw5JNPNty+P8/9X//6F77+9a9j7733xogRI9DW1obJkyfjtttuQ5qm3rYDee69ob+fRwB4//33cfbZZ2Ps2LEoFArYdNNN8V//9V9YunRpv85Vq9Uwffp0s/+ECRNw8803N9yWiHDnnXdijz32QHNzM9ra2rDbbrvhoYceAtDzZzn70p+/3/3udzjllFMwefJkFAoFMMawcOHCuvO+9tpruOCCCzB58mQMGTIEw4YNw7777ouf/OQn/bpGjfnz52PKlCloaWnBkCFDcNRRR+HNN99suO3NN9+MCRMmoFAoYNy4cZg+fTpqtdo6ea4srrrqKjz44IN1y+fOnQvGGObOnbvSxw5Yx0EBqwz7778/7bjjjmt7GKsE5XKZdtppJ9piiy3o7rvvpjlz5tDhhx9OcRzT3Llz+9x/8eLFtNlmm9GOO+5IDzzwAD366KP0sY99jFpbW+nVV1/1tp0yZQrttNNO9PnPf5623XZbGjNmTMNjHn300XTggQfSLbfcQnPnzqX777+f9tprL4rjmJ544glv2xNOOIFKpRI9/fTT3uuFF15Y6XsydepU6ulXZv78+fT666+v9LHXZZx//vm0++6708yZM+mJJ56ghx9+mD75yU8SALrrrru8bfv73B955BHacsst6dJLL6VHH32U5syZQ+eeey5xzumkk07yjjmQ594TBvJ5/Mc//kFbb701bb/99nTHHXfQvHnz6IEHHqCvfOUr9K9//atf5zvllFOoUCjQtddeS0899RRdfPHFxBijK6+8sm7b008/nQqFAl188cX061//mn75y1/SddddR/feey8REb3++uveZ/g73/kOAaCrrrrKW64/f9OmTaMxY8bQEUccQQcccAABoAULFtSd9+abb6YJEybQlVdeSXPmzKHHHnuMTjjhBAJA06dP79d1vvLKK9Ta2kr/8R//QY8++ig98MADtOOOO9Jmm21Gixcv9ra94ooriDFGl1xyCT311FN07bXXUj6fp1NPPXWdO1cjNDc30wknnFC3fNmyZfT000/TsmXLVvrYAes2AlFaBejq6iIhxAZFlPQf4z/84Q9mWa1Wox122IH22GOPPve/8MILKZfL0cKFC82yZcuW0YgRI+iYY47xtk3T1Px86KGH9kiU/v3vf9ctW7FiBW266aZ00EEHectPOOEEam5u7nOcA0FvRGlDRqP7niQJTZw4kbbZZhtveX+f+9KlS6lardYdV9/jt99+u9fz9/Tce8JAPo+HH344bb755rR06dJ+HTuLv/zlL8QYo6uuuspbfuqpp1KpVKIlS5aYZT/72c8IAP34xz/u9/GfeuopAkD3339/w/Xu79N1113XI1F67733SAhRt/zQQw+lpqYmKpfLfY7lM5/5DI0YMcIjCQsXLqRcLkcXXXSRWfb+++9TsVik0047zdv/yiuvJMYYvfzyy+vUuRqhJ6IUsOFjo/qrv3jxYjr11FNpiy22oHw+TyNGjKB99tmHfvWrX/X7GHfeeScBoMcff5xOOukkGjFiBAGg7u5uQ5T+7//+jz72sY9RqVSicePG0YwZM7w/XkREb731Fh1//PE0cuRIyufzNGHCBLr++uvrtltbmDJlCo0fP75u+VVXXUUA6J133ul1/2233ZYOOeSQuuWnnXYalUolqtVqDffrjSj1hAMPPJC23357b9mqJkr6m3b2pSegMWPGeH9E9WR2zz330EUXXUSjRo2i5uZm+tSnPkXvvvsuLV++nE499VQaPnw4DR8+nE488URasWKFd04hBH3nO9+hSZMmUbFYpCFDhtCnP/1peuONN1bZdQ0GJ510EuXzeW/Zyj53jbvuuquOoPeERs+9J/R3XAsWLCDGGE2bNq1fx22EK664ggDURZ/+8Ic/mM+ExgEHHEBjx44d0PH7IkoueiNKPWH69OkEgP75z3/2ul2tVqNSqUSnn3563br//M//pO222868v/vuuwkAPf300952//znPwlAw0jb2jpXIzT63d9///2JyD6Pp556asDHDVg/sFFplL7whS/gwQcfxDe+8Q3MmTMHd9xxB6ZMmYIlS5YM+Fgnn3wycrkcfvjDH+InP/kJcrkcAODdd9/F8ccfj89//vN4+OGH8V//9V+45JJLcPfdd5t933vvPeyzzz6YM2cOvvWtb+Hhhx/GlClTcMEFF+ArX/lKn+cWQiBJkj5fWa3HQPCXv/wFEydOrFuul7388ss97tvd3Y033nijx/27u7t71BUMFMuWLcP8+fOx4447NhzHqFGjEEURtthiC3zlK1/pt8Yki8suuwxHH300AODpp582r9GjR/e639e+9jUsXrwYP/jBD3DDDTdg7ty5+NznPodPf/rTaG9vx3333YeLLroIP/zhD/G1r33N2/f000/HOeecgylTpuDBBx/ELbfcgpdffhn77LMP/v3vf/d6XiLq12ckSZKVuh9JkuC3v/2td99XxXN/8sknEccxtt9++1636+25ZzGQcf32t78FEWGzzTbD5z73ObS0tKBYLOKAAw7A008/3ee5APm7M3LkSIwaNaruXHo9IO/h008/jV133RUzZ87EmDFjEEURtt56a1x//fUgon6db1XjqaeewsiRI7HJJpuYZQsXLvR0UADwxhtvoLu7u8f7+vrrr6NcLgOw17zzzjt7240ePRojRoww69f0ufqLp59+GqVSCZ/85CfN7/4tt9wy4OMErJ+I1/YA1iR+//vf45RTTsGpp55qlh1++OErdayDDjoI/+///b+65UuWLMFjjz2GPfbYAwAwZcoUzJ07F/feey+++MUvAgBmzpyJf/zjH/jjH/9otjvkkEOQpim++93v4pxzzul1ojj55JNx11139TnG/ffff6UFhkuWLMGwYcPqlutlvZHLDz74AES00vsPBFOnTkVnZycuvfRSb/mkSZMwadIkI66fN28eZs2ahSeeeALPPvssWlpaBnSebbbZBptuuikAYK+99ur3fhMnTsSdd95p3r/66quYPXs2zjrrLFx33XUAgIMPPhhPP/007rnnHtx0000AgGeeeQa33347brjhBpx33nlm///4j//A9ttvj5kzZ+Kaa67p8bzz5s3DgQce2K8xLliwoEcBfU+YNm0aXn/9dU/cOtjnPmfOHPzwhz/E2WefjeHDh/d6/p6eeyMMZFz/+Mc/AAAXXHABDjzwQDzwwAPo7OzE9OnT8fGPfxx//OMfG07WLnr63WlubkY+nzfnev/991GpVMxn8sorr8QWW2yB+++/HxdeeCE++OADXHnllX1e36rEHXfcgblz5+LGG29EFEVmOWMMURR5y/R19HRfiQgffPABRo8ejSVLlqBQKKC5ubnhtu7nYk2eq7/Ya6+9wDnHyJEjB/T7H7BhYKMiSnvssQd+8IMfYPjw4ZgyZQomT55sIkEDxac//emGy0eNGmXIj8bEiRPxwgsvmPdPPvkkdthhh7rtTjzxRNx666148skneyVK06ZN61fkqbW1tdf1RFQXdYpj+5FgjPW4b2/rVtX+feGyyy7DPffcg5tvvhmTJ0/21p177rne+4MPPhi77rorjj76aNx+++1161cXPvWpT3nvP/KRjwAADj300LrlDz74IDo6OtDS0oKf//znYIzh85//vBf1GTVqFCZNmtQnAZ48eTKeffbZfo1xs80269d2GnfccQeuvPJKnH/++Q2/aKzMc58/fz6OOeYY7LXXXpgxY0av5+/puQshIITwzpWd7Psal95/iy22wAMPPGD233vvvbHtttvi2muvNdHhbDQuiiJznIGca/ny5Xj88cfNBPzxj38c7777LmbOnIlLLrlkwKR+ZfGLX/wCU6dOxdFHH40zzzzTWzdmzJgeo4/9fd793W5NnisgoD/YqIjSj3/8Y1xxxRW44447cNlll6GlpQVHHnkkrr322roweV/oKeXS6JtwoVBAd3e3eb9kyZKG3+D1hNXXN56tttoKW2yxRZ9j7OsPwl133YWTTjrJW6bD/cOHD284Dp26avTNTmPo0KFgjK30/v3B9OnTccUVV+DKK6/sF2kEgCOPPBLNzc145plnBnXugSB7nfl8vtfl5XIZLS0t+Pe//w0iMlGsLLbeeutez9vS0oJddtmlX2N0yXFfuPPOO3H66afjtNNOMxExjZV97s8//zwOPvhgbLfddnjsscdQKBR6PH9vz/2b3/wmpk+fbt6PGTMGCxcuHNC49O/vlClTPJI1evRoTJo0ydgJLFy4EOPGjfOO9dRTT+GAAw7A8OHDvS9GGp2dnahWq+Zcelytra11UYr/+q//woMPPoi//vWvdV+oVgcef/xxHHXUUTj44INxzz339ItM6HvV031ljGHIkCFm23K5jK6uLjQ1NdVtm/2iszbPFRCQxUZFlEaMGIHZs2dj9uzZePvtt/Hwww/j4osvxuLFi/HLX/5yQMcazLeS4cOH41//+lfd8n/+859mnL1hVaXe/vu//7vHqMPOO++Ml156qW65XtabX1SpVMK2227b4/6lUqnPib43TJ8+HdOmTcO0adPqdD19gYjA+bovzRsxYgQYY/jtb3/bkDj0RiaA1ZN6u/POO3HKKafghBNOwHe/+92634GVee7PP/88pkyZgjFjxmDOnDlob2/v8fx9PffTTjvNi+DpezSQcfWWVnM/O5tttlnd78748eMByN+dH/3oR3j33Xe9L2DZ351SqYTtttsO7777bsNzAVgjn9XHH38cRxxxBPbff3888MADhrT3hW222QalUqnH+7rtttuiWCwCsHqhl156CXvuuafZ7t1338X777/fp//cmjxXQEAd1oaCfF3CEUccQSNHjuz39rrq7dlnn61b15M9wAknnOBVcl1yySUEgJ577jlvu6lTpxJjjP72t7/1OoYFCxbQs88+2+cr6w8zENxyyy0EgJ555hmzrFar0Y477kh77rlnn/tfdNFFlM/nvTLv5cuX08iRI+mzn/1sj/v1VfX2zW9+kwDQ17/+9f5diIMf//jHBIBmz5494H2JiM477zwCQF1dXXXreqp6y1Ym9fT5ufzyywkAvffee0RE9Lvf/W7AZeMuli9f3q/PyLPPPkuVSqXP4915553EOacvfvGLvVZmDuS5P//88zRs2DCaOHEivf/++72efzDPfSDjStOUtthiC5owYQIlSWKW/+Mf/6BSqURf+tKX+jyXtge4+uqrveWnn356nT2A/lvw+9//3tv2sMMOo5aWloaftVVZ9fb4449TsVikKVOmUHd3d5/Hy+KYY46hTTbZhJYvX26WvfXWW5TP5+mrX/2qWbZkyRIqFov05S9/2dt/xowZ/S7ZX5PnaoRhw4bVWUkQhaq3jQEbDVH68MMPadddd6XrrruOHnnkEZo7dy5dd911VCwW6bjjjuv3cVYFUVq8eDFtvvnmNGrUKLrtttvo8ccfp7POOosYY3TGGWes1PWtapTLZdpxxx1pyy23pHvuuYd+9atf0ZFHHtnQcPLjH/84RVHkLVu8eDGNHj2adt55Z/rZz35Gjz32GO23337U2tpKr7zyirftyy+/TPfffz/df//9NHnyZBo5cqR57/5Ru/766wkAfeITn6gzknRLgRcuXEj77LMP3XTTTfTYY4/RL37xC7r44oupWCzSjjvuSB0dHd75999//375I+lnf/nll9MzzzzjkYxVTZSIZOl6U1MTXXjhhfTII4/Qk08+Sffccw/9z//8D91yyy19jndV4X//93+Jc0677bYb/f73v6+7767fTn+f+6uvvkrDhw+nYcOG0SOPPFJ3TNdAsL/PvTcM5PN4//33E2OMDj30UPr5z39OP/7xj2mnnXai9vb2fpuKasPJ6667jubOnUtf+9rXGhpOLlmyhLbaaivabLPN6Hvf+x49/vjjdOqppxIAuv766xseuy+itHjxYvP788UvfpEA0C233EL333+/97v729/+lkqlEo0dO5aefPLJuvua9SuKoohOPvlk71yvvPIKtbS00H777UePPfYY/fSnP6WddtqpVxPIr33ta+bvb6FQqDOBXJPnWrBgAQHolz/S/vvvT5tssgk9/PDD3hfRRkTprrvuoiiKPEPWnq5rm222qfMjC1i3sNEQpXK5TF/+8pdp4sSJ1NbWRqVSicaPH0+XX345dXZ29vs4q4IoEclvQscddxwNHz6ccrkcjR8/nq677rp1xkeJiOjdd9+lL37xizRs2DAqFou01157NfSc6olovP7663TEEUdQW1sbNTU10UEHHVQXRSOyJKHR6/LLL687T08vjaVLl9KRRx5JY8eOpVKpRPl8nrbbbju66KKL6MMPP6w7/+TJk2nUqFF93o9KpUKnnHIKjRw5khhj/fJRGgxRIiL6/ve/T3vuuSc1NzdTqVSibbbZhr74xS/Sn/70pz7Hu6rQk4eUfmWjFf157vo+9PS68847zbb9fe59ob+fRyKiBx98kD760Y9SsVik9vZ2OuywwwYUiahWq3T55ZfTVlttRfl8nrbffnu66aabGm779ttv07HHHktDhw6lfD5PEydOpO9///s9HrsvoqTXN3pp7x+i3n/vshN/b4TiT3/6Ex100EHU1NREbW1tdMQRR/RIKG+88UbafvvtKZ/P01ZbbUWXX355nfHomjzXSy+9RADo4osvbngMFy+88ALtu+++1NTU1KePkv58u5/jnq5rzJgxA/aOC1izYERryawjIGAdwIoVKzBs2DDMnj0bU6dOXdvDCQgIWIO45ZZbcNFFF+GNN97osXAiIGDdV7UGBKxG/OY3v8Hmm2/ueWsFBARsHHjqqadw1llnBZIU0CtCREmBGngKZeH6pAQEBAQEBARs+AgRJYW77roLuVyu19e8efPW9jADAgICAgIC1iBCRElhyZIlWLBgQa/bjB8/vk+364CAgICAgIANB4EoBQQEBAQEBAT0gJB6CwgICAgICAjoARtVC5OVgRAC//znP9Ha2hqE3AEBAQEBvYKIsGLFCmy22WartQVNuVxGtVod9HHy+bxp/xLQGIEo9YF//vOf2HLLLdf2MAICAgIC1iMsWrSoX83LVwblchnjxrTg3cW9V2r3B6NGjcKCBQsCWeoFgSj1AS3eXrRoEdra2tbyaAICAgIC1mUsX74cW2655Wot/KlWq3h3cYoFz41BW+vKR62WrxAYN/ktVKvVQJR6QSBKfUCn29ra2gJRCggICAjoF9aEVKOtlQ+KKAX0D4EoBQQEBAQErIdISSAdRN16SmLVDWYDRiBKAQEBAQEB6yEECAIrz5QGs+/GhBCzCwgICAgICAjoASGiFBAQEBAQsB5CQGAwybPB7b3xIBClgICAgICA9RApEdJBNNcYzL4bEwJRCggICAgIWA8RNEprBkGjFBAQEBAQEBDQA0JEKSAgICAgYD2EACENEaXVjkCUAgICAgIC1kOE1NuaQUi9BQQEBAQEBAT0gA2KKM2YMQOMMZxzzjne8ldeeQWHHXYY2tvb0drair322gtvv/322hlkQEBAQEDAKoCuehvMK6BvbDCpt2effRa33XYbJk6c6C1/44038LGPfQxf+tKXMH36dLS3t+OVV14JDQADAgICAtZrCPUazP4BfWODIEodHR04/vjjcfvtt+OKK67w1l166aX45Cc/iWuvvdYs23rrrdf0EAMCAgICAgLWQ2wQqbepU6fi0EMPxZQpU7zlQgg8+uij2H777XHIIYdgk002wZ577okHH3ywx2NVKhUsX77cewUEBASsT9j5glnY+YJZa3sYAasZqap6G8wroG+s90TpRz/6EebPn48ZM2bUrVu8eDE6Ojpw9dVX4xOf+ATmzJmDI488EkcddRTmzZvX8HgzZsxAe3u7eW255Zar+xICAgICAgIGjJQG/wroG+s1UVq0aBHOPvts3H333Q01R0LIDOzhhx+Oc889F7vssgsuvvhifOpTn8J3v/vdhse85JJLsGzZMvNatGjRar2GgICAgNWFXaeGqFJAwGCxXhOl5557DosXL8bkyZMRxzHiOMa8efNw0003IY5jDB8+HHEcY4cddvD2+8hHPtJj1VuhUEBbW5v3CggICFif8NL15yLulj/v/qWZa3cwAasNYhW8AvrGei3mPuigg/DSSy95y0466SRMmDABX/3qV1EoFPDRj34Uf/vb37xtXnvtNYwZM2ZNDjUgICBgjSIq27zKR0+aiWfvPA87nycjTC/NPHdtDStgFUKAIQUb1P4BfWO9Jkqtra3YaaedvGXNzc0YPny4WX7hhRfis5/9LPbbbz8ceOCB+OUvf4lHHnkEc+fOXQsjDggICFhzYE7IYNczZgHBFWWDgiD5Gsz+AX1jvU699QdHHnkkvvvd7+Laa6/FzjvvjDvuuAMPPPAAPvaxj63toQUEBASsFkw+tbE2KS6HaFJAwECxXkeUGqFRpOjkk0/GySefvOYHExAQELCWQJyBEUHEMr3CE+C52wJJ2pCQDjL1Nph9NyZscEQpICAgYGPGR0+aCQ6ZdqMI4Anh2e+ft7aHFbAaEIjSmsEGn3oLCAgI2Fiw1/E3eO9ZCgRPwYCAwSFElAICAgLWc+zzWUWQnL/oFL4Gb/AQxCBoEFVvg9h3Y0IgSgEBAQHrEf7jyOsBAEyVLImIATmrQ2JEchmAP/4wpNw2ZITU25pB+M4REBAQsJ5gv8Oua7ic1whMWDsAnlIgSQEBqwghohQQEBCwmvGxo2QU6Hc/vWCl9jdRJGcZcfmOKQ2SliLxGvD7+89fqfMErF9IwZEOIt6RrsKxbMgIRCkgICBgDUE7ZA8EmiRpsJQMY9JkCZDVbb/92coRsYD1EzRIjRIFjVK/EIhSQEBAwGrG7356AT56kuy5ts9nb8Affty/iM/HjrreRJF4ImNGxCDDR0zqlIgBv33wQm+/vY+7AZV2J9Kgwk2xamvyfz+QZO2jJ8+0xwTwp+/J5bufIpcnRTuRvvDt4MEUsHEiEKWAgICA1YyJ584ChjC0/LN/bUh1qg6QJCaq2Rp/RoCIet53r8/P7FOiu+cXVKPcnL98ty9LR+9GyRzdJ04jOHyvfQQx95pBIEoBAQEBawgdm3HkOoHJp83q0SV736Ov96YvlyTpyI80k2QAyXX7HHOD0SqhIDcqLPNJGUuBpORPjLwGiBjIzpciZkiaAF4d0OUFrGGkxJEOwgciDR5b/UKoegsICAhYzXhx1rmIy7LXmsbEc+v7se37GemHRFwSJJckATKaxFKSOiUAYAxp3v8zHlUIUUVaBIiIgVcJvCr34YlczxP7istW88RrJNN06vAiD1AsX2CoI1QBaxcCDAJ8EK/wQPuDEFEKCAgIWIOoNdufdzlzFl64+VxjGMkAgDFEFQFiAEsaf+WnHAMThKQoSZK2BdDBBSaAXJcwhEdX2+31+ZleJIq5h2dAtVVOnC/OCmm1gACNQJQCAgIC1gB4lUARQ64TSAt2+d7H3VAv2I4YeNWmzqKK/Tkt2ghSXBZgTtSp1irFSyJm8lgM+N0DthLumbvPw96fc9qcqBPnughP3xssBdY3BI3SmkEgSgEBAQGrCbufMlP2WwMAbkv7424gqtjtKJIpMeJAVHXCPEymwyhiYOQIup1IE0+tQ3duRWocu+f+8qsNx/T0fedj7+NuMCm2p+8LBGl9xeA1SkGk1B8EohQQEBCwGrDHCTO9qjImZIsR+cYuFxFD3C1TbR5J4gxICSKWG2u9UlQVSHPcHEfEDPMevQgAcNDHZwAAnnjykl7HFqJHAQH9RyBKAQEBASuByadaMfZzt5+LyafJ91porb/nk1PKn0ay0owpHyRdxVZr5igsS0EcEJyZFBxiZnVEFXvQqCbMeVxS1BdBCtiwIMXcg2iKG1Jv/UIgSgEBAQH9xO5fUv5DDACzk8yeX5gJlOonHV6zuiN3e8A2teUqiiQ0KSKlMUqtwaRJtQkgLSi2lAPmPXbRqrmwgPUSYpAtTARC6q0/CEQpICAgYBUg7nb8jiJIfVECgMkKNRCZKjSKGIgzGUGKGXIdSqytSvBZKh23NYkCkyLuXEcCngj8et7X1uSlBQRs1AhEKSAgIKAf2OvzM5F3NEQ8ERA5GSVK841TGFHFbi9y9euZAOJuxxhSp+Qi5uuVSKbrkqYYc38RokgBEkHMvWYQiFJAQEBAH/jYUdcDTRwiz5BfIcvYRMRkRRqX0aRai/I0SuWLIqDWzJBfrohQjkkSpBvZqkkqKTIZjdKmj9oigANxlyVRTz5x8Rq40oD1Cdo4cuX3D0SpPwhEKSAgIKAfiLuEV63GUzJGj2nOrqBIlvQzIaNAadG6Y0udEslms4yZJrVyR1vZxit++5FAkgIC1h4CUQoICAjoBXucOBNo4+A12e5DxMyL9KQFqUFiQvVNU8s0CYq7hCnxBxFqzTIC4GuaGOKyPGaaY+AVu/ypOY39kAICUmJIaeUr1waz78aEQJQCAgIC+omkyFD4UJbx6xRZ3E0oD5d/So1PElQVm7YKSKRpJADkOwRqTZIsEQNyjkap0h4h7hKotUSm7UhAQE9IB1n1lobUW78QmuIGBAQE9IKmfyeIu21D2aTEwYTUGqUFbsr1eUKmIS2vyRcgPZJ4Ks0k0wJDWlCl/0xaBCQFhu5hEbqHRRCR7MsWSFJAfyCID/o1EMyYMQMf/ehH0draik022QRHHHEE/va3v3nbnHjiiWCMea+99tprVV72GkeIKAUEBAT0gH2OuQF55z1FDE3vyrzYh9sV0bRYCrtzHQKV9giIbKRJV63JlBxDmmNgTsRJV7eJWO7zzD3BLTtg3ca8efMwdepUfPSjH0WSJLj00kvxn//5n/jrX/+K5mbb7fkTn/gE7rzzTvM+n883Otx6g0CUAgICAvpAfnkKnsgUmchzPPmri7H7KTPRtUlke7kByHfYNiNal0Sqx1tUJaR55xs8ARRLwfeG1lLEbbz79H3nY7/DrwMA/OahC9fWkDZIrOnU2y9/+Uvv/Z133olNNtkEzz33HPbbbz+zvFAoYNSoUSs9rnUNgSgFBAQE9IJqa4TChwmIMSRNHL99UE72f7rjPPzHkdcDgCFFcadkTZSTbUi0VpYrMqU5Fam/vBsCQdr9FOlWXlimImgpAQUrEv7Yp683U/n+/30d5j0SyNKqgsDgBNlaHbd8+XJveaFQQKFQ6HP/ZcuWAQCGDRvmLZ87dy422WQTDBkyBPvvvz+uvPJKbLLJJis9zrUNRhQcp3rD8uXL0d7ejmXLlqGtrW1tDycgIGA14mOflsTndw9cgAMPuQaAbTVSa5ZN23IrUjz5xMWYst+VAIC0KFlP0sStkzYkWQKkuzbFdjIrD5HH+eMPz1udl7JaoQkiAHQPlzTII0ou1KXrVCTxDTuytCbmDH2O/zd/MkotKx/v6O5IcPpuz9Utv/zyyzFt2rRe9yUiHH744fjggw/w29/+1iz/8Y9/jJaWFowZMwYLFizAZZddhiRJ8Nxzz/WLfK2LCBGlgICAjR46NQRFaA46cAag0mS6z1p+WWLMIjVJAoConCBpkn9KRZ4ZssRqBEQMFDPp3K34Q65TrLdi7YP5Z+QPh+9Zt67SzlBYJqv7ZMsWtYKk59QgDKQDesDgDSflvosWLfJIXX8IzVe+8hW8+OKL+N3vfuct/+xnP2t+3mmnnbD77rtjzJgxePTRR3HUUUet9FjXJgJRCggI2Kix32HXmaiHm8XgVYGkKYKII+SX1QAAaSHy9hXqPU8JrFsgLXCQYwsAQUiaIkkcmIxUrW3scYJMlem2K8/dfu6Aj1EeKifY4gcCpSXW3sAjQ9JbsyH2O+w6/ObhDTeqtKYw+BYmct+2trYBRb/OPPNMPPzww/jNb36DLbbYotdtR48ejTFjxuDvf//7So9zbSMQpYCAgI0Gu/3PLADA/Fsz5ED1UtMoD8+h8EGCqCxAEUPSFIPXBJgg8KpUGiUtsnmbjjIxQYgqAiLPAe7rRogz5JclWBcx+dRZxhyzr3Rg9dA9AABN76WGFIk4c63qLVN96+pScert/p+8FvMeC33r1icQEc4880z87Gc/w9y5czFu3Lg+91myZAkWLVqE0aNHr4ERrh4EohQQELDBw1RhDfG/fR/wX9eCA0iLHCwhxBVCVFaSay7TbjKNpNuPACIvI0RROUVSshEm4gy8KhAlKZLmyBCvuCzqWpKsC5BVeD7J2e3Ls8zPuU5LnvY/9Fq5UBHAWhM3TuI8IQhlpkkRMz3siCkRO2MgN7TE4Gm5AlYeAgwCgxFzD2zfqVOn4t5778VDDz2E1tZWvPvuuwCA9vZ2lEoldHR0YNq0afj0pz+N0aNHY+HChfja176GESNG4Mgjj1zpca5tBDF3Hwhi7oCA9Rt7H3eDiWJUFFEqLhXIrUi9KJJsQyIX6IlfLoeJIrnbizy32zFn+9SKlkXBErN1ScC81+dnmp/TnHUUrzXb69BEKaoQcp3WAyFpimyKzW1VFwNcZiiNl5RdqXRbajE5Ebff/mztpyNXJdakmHvWn/YZtJj73N3/0O+xMtaYWN1555048cQT0d3djSOOOALPP/88PvzwQ4wePRoHHnggvvWtb2HLLbdc6XGubYSIUkBAwDqJXb5ioxsvfHvgOhoA2PczNwA5+77woTCNbAFfk8TgpNHIncxJRpFSGRdJm2wUiVeFIUuaZBGXEapIRZLm/nLd69X2zN3nYc8vSLLEEy22ZtIHyvnurIlNrTlCqkr+eSaV5qYeRQ6IytIWwSWVYDLSRAxI89w0/wVkpeG6oN0K6Bt9xVVKpRIef/zxNTSaNYdAlAICAtY5TDp71iASCtJRG4A9hnMwioD8hypCEjEgtVEkG/GAIVSkKtcAS6y4M9HzVDbKlWkne560yE1/t3URIiejRRqa6AEwDuIUqxeX98bdRm5gI2j6fokcky1eANMsWG7AjJ4pzTGPcO39uRvw9H3rv6fUmsbgDSdDKWJ/EIhSQEDAOoWdL5gFDklo/nzjwCNJmiQBktiw1FZj5brkrE05ZjU0DlkiZtNlvCo8UTZLSEadHPEycXkcKOGyWb4OE6Q9TlRpN2eOZD3ozN0UGVP96eQKZ18h7y9x2OrBSG4TVVUK0rtncrs09ollwMAhiEEMxnByEPtuTAhEKSAgYJ3AjhfLVBuHjHasDPb+3A12Lld/3VgqJ3MtPnZTZUJn0VxiQ2TTRk4ExYsyxQxxZz27qLXGMvoi1n3tDRMyPaZJkk0damF2hhwBdQSp0c/kOCikeYa60CDJlyZPdXqmgH5DDDKiNBgPpo0J4S4FBASsUxDO17cdL5nV84YOPnrSTHz0JBkpoUgaP2roCT9VUSRXtG3AmCfIBvzIEUvJppgSktqkHAdLBFgifxY5ZVApCDwh7PPZG7DPZ2/AugYRyciZDiZQrHygSEXCtD49VfolJdAGc15QUaTIJ0buz7rpL3HmRaYokmlKqQOzm2vNVEDAuoZAlAICAtYNkE3hpPn+R5X2/+/rzM9JkSEp6ma0DLymJnrGbOQiS4giJs/rBpWYjHikRQ5ekzqbqJxKobMSJccdNbCUkDTbgUZlXyy+rkGTSY2kIJ3EifmVfmBAVCOvX50GcWbIjkaal+7jImJIc/J/+YLzksuIOak6ta+OLu35xUCWBgJBfNCvgL4RUm8BAQHrDHSaDLCps/6g6f0U3cNlOIOYLHmXPkFA3O2klJg6PmOWALgl7pxZPVOn0jNFshluYUlqPZYAiBwHRdzsF3fK0EvUDXSNKprj7nPMDfjD/65dobKJ1qh7ShzIdSkRe46BmW69NhVGGQ1TI+JKnJn0pd7e0ywhU/1mdoR8FpocR1inCea6ihQM6SDKHgaz78aEDYpOzpgxA4wxnHPOOQ3Xn3766WCMYfbs2Wt0XAEBAX0jLgO5Tvv+5Rnn4uUZfYu5ayUOYkBxaSqrsIRtwBpVyEzaeuLW4mKKGEROvvR6Ecs0kcgxVIZEKA+PUR4u2UVleB7Voeo1JIfqEMkceFXI1F4xNq/Ch4nnPbQ24aa0eAJENSmyFrEkSCxVWiX1Mr3a9D5Kp8QbCL5FDID56VJ5H31xN6DScpn0HeAQY/V8QlQpYF3DBhNRevbZZ3Hbbbdh4sSJDdc/+OCD+OMf/4jNNttsDY8sICBgIIi7fa2LbjsCyNYju58iJ9L8CjuZJ0XuRTxEzGTERKfZHLdorV/SKbq4TCaiwoRu6gpUWxjiijp+idtjqJRT8z+qch8i2ThXkYuk2f5ZzXWmay1SkiUcRqytdEi8RqBIWR046UheE2p7K7hmQkaUGKl7qJ8PqWiQEmezrM+O1iFp2wW1H++DQ+5xwkz83129t1MJwKDTZyH11j9sEHepo6MDxx9/PG6//XYMHTq0bv0//vEPfOUrX8E999yDXG4ly2kCAgIGjLG3XYext13X94YKrjh40lmzbCm7QlZjA0BGNNSvNU/IvNK8ozvSYm0mdUu1EvN0OSLPUGvhqLVwJCWGaosiUwUbjdIEiaWE/AqnESxTZe6MIS36TXM1Sfr4wVf3+x6sCnjC6Iz5Y1QmRIocmiiR0l6BpCeUJk48sRE55pAbntr7orVHgLwXWrxNnKkIXb3oOyso13C1Yrp5b0DPSGHTbyv3CugPNgiiNHXqVBx66KGYMmVK3TohBL7whS/gwgsvxI477tjnsSqVCpYvX+69AgICBoaxt16PsbdeP6B9/nzjuTYt00vFuPRFYqi0c4g4m/ZhpjyfCTVBc1vpVm1lqLb6lVjVZo5aSWptqi2SJCUlZtJwScFJzeWY0TzV2mIjahY5bh2qHSNFngjwZC2FlMiv1gNTlWbZPILbfkX4WiGhKgZdoqNtFfT9bXRe761LnLw0pyZamX2CbCZgHcN6T5R+9KMfYf78+ZgxY0bD9ddccw3iOMZZZ53Vr+PNmDED7e3t5rU+96cJCFgbGPsdpyQ+ZVh4Wv96nE06a5anmYlqQFJSxER576QFlTZKqK4rvcgxo4PR7tDGLTpmqDVz8CRT3QWZOoNKyckmrvBL4GM5jlwnmf5n0mSSkDRxQ4aicoLcihpEXjpyy2gMQ+eoPJ781cUDvo+DgU6TuanHqCxMM1rtuG3SlYpE6Ws3BAbyXprjquiRTMupXdX9a6Q/agTXMkBGr/QKu41+dsEyoHeEqrc1g/X6Li1atAhnn3027r77bhSLxbr1zz33HG688Ub84Ac/6LGZXxaXXHIJli1bZl6LFi1a1cMOCNhgsc0NamITDCxhWPg//TNd3HWq1CERs5MkcdsqJC7blJr7tz0pWkG2hquJAWzpujQ5bNCrjElLAREBcKMpedjolgC6h3Gp82EwpCOqENJC5JG2wpKKdJ4ucnRtsmZT/fsddh32O0ymOtO836IkLSj/otQniyIn70uaz/gd6ehcatNkTJCJ4jFhU211IPvyoloaTGm7jO7L7pdNxwVxd89IiQ/6FdA31uu79Nxzz2Hx4sWYPHky4jhGHMeYN28ebrrpJsRxjLlz52Lx4sXYaqutzPq33noL559/PsaOHdvwmIVCAW1tbd4rICCg/4jKrFcB86SzZmHSWVagvcuZypE7lVEkJmQ5unaM1ikaz/3ZLUVn/ktvJ/15tEDblqC7E3FSki+towEAXgWse7TakPkO0pq0sZRMao1ibl75D2uNCcQaQun9FJHUmsv/lT7LTVVaryObDgMcgkQ28qRBkYy6idh6H/mRIN/MUxtZ6j5xDc0+1b12q+R0NV1IwwWsC1ivq94OOuggvPTSS96yk046CRMmTMBXv/pVjB49Gocccoi3/pBDDsEXvvAFnHTSSWtyqAEBGwXeOP88jLu5ZzdqlyDpKBIcsTAxSVi4muRFxFRnextpMi1IiLzJ1SNneg5XjWpZ6muZmCDUmpm3H0VAWpTEQouV9XLtTl0ewtG8OIUocDBdHZYCIs9N1IRX5fLiexUQK/Tzzq0aJCXuRdzSAjMRHc8XSZAlcg4ZSfP2Wl39kfQ7kgQ4zWdO2iB15kXttGeS8+xk5IipcfhVcG5j4tALrncQGMQg2CQFJtovrNdEqbW1FTvttJO3rLm5GcOHDzfLhw8f7q3P5XIYNWoUxo8fv8bGGRCwMYLaa+ZnQ4oaiH9td3m7TOR9sqSFw275uYx6+L3Y6lI3Pehfai3MMzuMKgASf79sVIwihlynQKWNS+uBOJLVdTnIpro5IL9MDTqT6t/3Mzfg9/evPtPJfT+jyCl3RNY6rcUdjySnAo6lZKJC2hIBUPdeuZFn/ZE0uLOvC0N+XJ8kHTFSz4+ceyPJlxSH11kGqHHyhLDX8TfgmXvWrmnnuojBps9C6q1/CHcpICBglWDHS2ZhwrRZKCzhhiSN/5afZuO6QW23JEKmRFxrWqAICimhsRYXe9EN8vQtRrSt9ncnd5c4MQGkRYa0yMATe946I0WlSXLJVVwmxGXrsZQUmSEiAICIIS6nEIUILLUMq7S4YmwF9j16YFWA/YXWJAF+JZprCeD1dmN+dSDcCI5Cve5LabxUhZohWDoaKJxn0qjkX7t3Zwik3r6he3fmOHsdv+71zVvbEMQG/QroG+t1RKkR5s6d2+v6hQsXrpFxBARsTNjpwlneX5Pim4U63xxDSBiQFuzEHNnAk6cLMlEkJ9LgTrTMjZjoajV9vrg+FZfmpTA5ceo+eAJLxFyipndL5fKkwJDrEuZ8+Q5hjBfjbrlc5DjiFfJiWJKiOkSl3RxCtfdxN+Dpe1ddZGT/T14LxAxRRaDW7H/vNam1rAlko8IWTZY0qSRnWyJjxKnBa2QE8lmSQ4wZsbZ+XobUZiJKfvsY5947y0Vs+/Tt+YWZ+OMPgxFlwJrFBkeUAgIC1hx2vERGi/TUF1VsygwAch3y/6QZJrWlK9qYaOzQLEv45aQtG9rK5Y1IU1Sz5fr6uHpA2e2jKqHS5uuS5M4wkSvr0O2sZ3JfkWOe0SQjgNUIImKIu+TFiTwHTxggCLnlNVRGFBBVCbWWVRu811EkBoAlhKTZYaXGDZtMus2DJk69VAL76UuHIKWSNAJuis9GnMyg1DikjoxZU87sebhN1elUaKNCABH3XiCwsSIFRzqIxNBg9t2YEIhSQEDASuEj35jl/ZnVVWrEZd82QJXYK6RFIFLLjYCaSWJkUzOZ9VEmNabTdIBfPeVEQnRKLZt6SosMUU02zDXLtZCYdEqqPkLCUqmhyXfYFSJmiLuEXZ+PEJWdgSqPoNzymukJp7H3cTcgKstj/e6n/bNP0Nj3Mzcgqjiu4DFDWtCNeTPjzkSFGqFR5sUTfbu7KZ1RVCOkGTsGQ0jdYJEmT72k1dxnaMgus5qqRtjr8zPxzN0hqgRg0OmzkHrrHwKdDAgIGDB2vHiW916XketS8qRoX4CMDDHheBNl/j7rijfATpJ1k6U76TIpQNamiK5NgF5v/levqEKGJDEhCRhPIPVIIhOtcgM0EUNUVT5DTKadeE1GmKAq7+p6nEGKkEVBHkiTqpXFfxxxHf7jCL8VTFLipsrN7XNnfKi8++Gqq5l5nzWZzJKtOv1Yqty6VbWaNggFYNqPZPfxnrV+Hpn1jZ553RzuaJmCEWXAmkQgSgEBAf3GjpfMMuk2wJ+gAasVctMkSVF5ITHHo8iBiK1w24iLnYnUkBaH9LgkQKfp6qrUuD1OUpSmkjxxolXacsAhC4AjelbtO1gq+8bpSVpqnZSHknoBgChEoJhD5FUDXUWe4m4BMOkwromFyEndjSvE7gl7H+eLmNOC7EmnvaFc8bZ7bfZG9Jxq06SmESmpE2Wrc3FHD2bsGTJRIE0eGZH/vD1yRGZZb6TIG4PTCy6IuwEBPuhXQN8IdykgIKBf2OFSP4rEqyoSxGGiMkZXBEtCmC4NVx3oXR2RyFlnaGKZijUAugKNMuRIQ7fA0K1L3P10pCMtKH2LS4Yc3yY9VnfM8uCoK4FPi1xGinLMM6AE4LlPm0hSRw0gIO5MwSsCuRUp4rJAXLasbv9Dr0VP+NhRfqUcrwm/2a8+tzLoZA00X/KCyfu5YfRN/9ygak2TWDfqpAli9tno++c2y/UPmHmfjWhpO4HM83bdwetMKzdSpMQG/QroG4EoBQQEDBxMptEostqkuCJfjJQNgIpw8JolT251lRtF0kTGjSLo5fo4bu82dzsRSbGwiJh/PMBUZnkeQO540ICA6WNzGLE4ACQFmb4TOS5Tb7E8r9uiQzfJdUlT3FkDSwlRRXj6Ine/Az5xjXd79/3MDcYbKSoTas3cpNpcfVdUJvCqqkrTqU+l+zIRHifVJmI5PpeYaCLkRmvsIJ17pD2aHAfv+oq3esLkRp18stp4kvbSnqrnnD5GVvy/uiwXAgJcBKIUEBDQP2QmV5YqwsGlm3VdlMMhQCaVpprMmnJ83VIkm2pjOgpFvkcP0DBV47XgiKxfEjjsXzmdmnIMGD0dVCYFpwkgIyDXRch1WbLjGTTG3LyIMUTdcjan2P55dYXecUeKqFtIU0eHLH38oKsBOOaRkMQr61lE3I5H32fdw81t/aJ7umkbA+EI5l1yZJ5XL9qgnu67u5/3vDWx6kWUrd259Utfo7xuf2xuVSOvScLq9rHbWBF8lNYMAlEKCAjoExMu99NurhEkrzSeQDVIbedWwOl9dQTEkCMV1dANaoXTaR6AZ1DYaBIWETOia50OhIpqsVT+zBLUpXaMTonsPqQIYFQhRU6EPHdCYIkTQVLkJaqkiCqSJLGUwLsT2ebEieiYy08JvJoiKqdGHA4AB/6njSy5KSYthmdCejiZbdQ9iKpUb3kAubyh+bITZesprelt7hBRmW5l3r5mG92jradqNzet5rSfyZ7LhUnfcttvT38miLONOqpExCEG8aLgzN0vBHuAgICAHtGIIOmJUZf6y5LxPiZc9fdYxJBERB+ObOTBPQdLVURJaYE1uQEkyaBG2he9r+M2nU3lNQK5uhy1fexGK5i0ApCtVGx3LK2XAYCoKqNMEASKmSRMEQNF8sLTgt+7hQkCdLuPzHjyyxJQxJA0ce8aWCK1TpST+7k7aosARrYXG5meeJln4uiyeiJHukS/4TpT9ZYNIaKOIBFztUx2++zz1uvrLB/U2KOqXU6xEzULWqWANYBAJwMCAhpi/Ld8kuRpRWowFVBaN6KjMlk5Sl2JP4NJiWkyBMAIvrPpG9tiw5loU2pIhhqWpOv3GaFyT9YDbkNXXpUaIKPtASDyDIjki3Jc9UTjni7JjlOAd1sHTq1hEjn7p5cnwqQWeSKkABzSUiDuEsh1pMgvS5BfloAncjx6rGmBG5KkK+10SoqlVEdc3co4b5yZ6FyPLUVMCsw5qE5vaqLUwzHtcrIpVYfo6J+z7tw8gdVD6YhUpmegm67cmJCCDfoV0DcCUQoICOg3XLfsyHHgJg4IbqM/LHFID2SEyKsoI389AJVq6+G8kSQwfoRIp2Hgka9Gpf56+6zeqaeoiYihvJJgRNKyYk+Rpcim4LQ4Wh+PESDy/oXkPuxGVEmlg7can8hz5VoNQEiRuMhxpKUYvCq8l46iabKmfZwaRVREXjf8rZ8ETcpL35MeyIwbHTT3kJxKNnefrGdT5r4aZ27ARsIyz1ETX/fzYHyu4JDXOm2aTWtujGRJ0GB1Smv7CtYPhNRbQEBAj6DYrxDTbSui7vptmbOP3hbwyZFwIkTmHE6vNtPexHF6pkiOQff80uk6d0xZWwFGkKJtfRzKpn4kaTLl/86YRCRbo6QFJiNngCcc1tGNtMgQd9kyrLQYgVe1W7ewUaNcHrycglVTUCz7waUlZ8DKOZtXUln+X7TrNDHKSklEjoHXyK+C06k25dOk7423r0cc9fX4963ONoDsdtmebz21HfFSdxnSVBc5crdRh9Y9+Oq9sRzC1ehcGxm01mgw+wf0jXCXAgICGoK0VkgbM6pJS/dy60mTZOZHFWUy5IgyZoXuPpHdJ9uU1ng1kRZ3O+sFWZLkptYcX6dG6ThjJ+CmAp31ukVH1lBTxMyUrHs+Sur6RI4b/ZEr4BbFCKIYgWIGJvwWJBTLFF7cKRlpVE686FFatKk1fb+TIkdStK1LeE1W44lYkUbV581YLuh7o8bp3WPn54aaJScK5UapzLN3I0Ss5yiVOVx2vZNCNa7iHF4q057L1yp5FXaC8LFPb7zC7oDVh0CUAgICeoSIbfpDT1Zxl2p+m9iXSa0JgKv/U2UmmY0AAeiZLGUmXHdyz7bYSPOyws07HrPHsj5Cdr1nbKj3I/+9vg7hWACkBWZTcHkGnmrSxOqOm5Qir3UIRdy8eE0eMO6sIupOEHXaFwDwagpRiMATAVHgEAWuolcclONAxJA0R7bqT8g0HHGpe3LToQCsYDsbxWuUWkMmZdZovSMir7NY0M+pgT6skSZJnqT+vIZ0xsyOgTOPPBJntoGxY7EAYKMiSwJs0K+AvhGIUkBAQB3Gf2uWNI6s2RYhgK10A2y0h7lRImdijStWx6Rbh5iIUSYY40as9Pm0eJxieH5IImJSn5MhQW6ZunYDz070dZM4OftH/v9mE119pyZnlgJuixLiTEZ0qqJhrzJJLuz2YAwsEeDVBCwRYIlQmqUISXMOEIS0EEn9k0PqRKTapwjyr8mk3MhLQepr97RhDUiMvg/mXrHMdtn3+r5lzmM215cpfJ8o1yjT6x/n6ZX8yJI5B7fXAsDYKTQS0AMbD1kKztxrBkGjFBCwkWLSzy8DACx7a4hZtnDq+dISQP1loBjQVUZxl1yWlIDY0SjpcvRsNMIrQ48cvZDeNjNJ6xSY0dUIh0TpHTMmhC7RsQfXYmy7rlFUJavXEbE8b6yMHLljOKlTQSIG4rI9UFpgiLuFTbkpiEIEXhOSD2hNj24KDAD5SBIk+OPiNYFam9xI5O0A3VYqpFKGxPz0n97GElLy9mFaLJ8lNere6OfkrjORtoz4mjjzon8uXEsAbfVg94UhXjxBYzR4ToyQGYP+gVnCuhFrlQJWLwJRCgjYCLHX45eg0a//jhfPAgqQPjVuvNkIhqVGKc172SyrI0J9dIGcyZInjvDaiQgJ3WwVsJYAkRX1ZqvhGgmFvQmb5Hm8yEQPeiUNnUKkiJmIhXs9FMvGtvI+2DYlSYnLkv2IIaoJpErELaJItizRztkgZSMgB0RqO16VjDBpzZnzuBCxjJ55fecYTDsU49ztNA/OeidJksc84btHPjRZStX6zL3sDYb89AAtxgfsszWWElmxuUuGMs9YR654QubZymtzdt/IyFIQc68ZhLsUELCRYb8nLgQAlHIJli9rqlsfqX5t2ZYYaUETCfnekaUAcCYucrI1DknSE7cXSXAm9EbWADrKY+CId92y9UYaqIa9xrIREoJ0607haV7Mfvqe1Mj0fTPaJWZ1M2nJRpSimmiox6FICrdFIfJSdCLPIfIcvJJC5BXJiq3ztPYtYgKmhYrWJVGkrABcA07nnrria55I9+6o6qTBMvfWI7F6MWXIB4NtJ6PeA5kUp444EbxqQ893S/j/m2Nl0rhuao+n8sPlXq+0Z5Avd5wbg2O3wCBbmASNUr8QiFJAwEaIfJzgmUNmAADYkCriLoa4i6EynJAWYXpqaeioQdLcOIKgUzpuSi0rvna1Oyz1J0BT7eSFqZxjab0SUz+r9iemJxg1eDnH8bZxoXUvWY0x9ydyXSGn9Upumss9rm7Qq4mUOY1ORZFMXYk8R605RtIUg3JSqJ00xUBa33JEp9G0ENxfaclQXSWb6Z9miYSnN3LE124vOHPfsrfKe7Y+MXMr6XhCMuqTk1oy/bwAWM2UZw1gfZTc85uegm5KU/k46c+BewyvIk4Nb7/Dr6u/kICAASKk3gICNjL85iA7eSw4/hIAwE4XzULSrBYymFSbF/1RabOkCcivUGX/ensoE0ZNHJx5lDdIjXhl9662KVK7p858HtVvyrNRCBeumNqNOsX10SwAdS1UKGLW3drR8GgYM8rIv7akKVINc2Ea3qZFjkh7KxHJSR7MIxoitu1HtC7JbREiiQXVRYk8PyPXS6pB6pOYf508lVWJPSJDeOtIozqPS3Tt9dQTNzleO07vOTDmEdmsR5a+H9llrscWGLNEkjHJBzcCN0UaZOUahYhSvxAiSgEBAQCAuNN/n+YloRE5mEnMNJeFJCtpUabkdErFjTrI0nWbPjMd612NTAbaZgD2lI0CRAYmuhTZc3ipNtgdDalhmRdgxN46ZaZtDcw6+BohU3UHm5pyr0dHU+R95E5zXjLaJECm6XgijJ+SvTCoxrnCmljq8wkVdXIiKHUkKZM6c8mH1frYe1DXey2jUdJEyxN3U6PokL2HbkWaiBlEzFTVXv1YXL0aIxuVAuA1wPWaC6v0cDbqpKNL+rj7HbbhRpUG58otXwF9IxClgIAAJM2yms3AjT6o6jFNSEQOqLRLIqV9lHTlG+BPnjqKADiTYoOWF3XIREVYhjE1TLfBWZ/Rt3iC7gYkSoOYtQBwx6jJl8gxc81y8vaHLfLcI0kAEJXlydOmCGmTCo9FDJRjSJoiI/7W986UzSuiIXLMH0vE6kim8bJyNGUuUeGO2F6mDrUxpXM+Tfgy6USZBpMpRWLMtIBhZO0LvKgfc1qWpNY/idfIiOQ10WsU9dFpQxE3/oB4+iS3F6C6L42I6/6fvLbhsQIC+oNAlAICAiS0LslxtTbVSurbuevTk5QsmYgqsJEHV3eUuNEaeHoVuRF8UgQ7Wffo8OymaLKkJwPP1ygbVcn2hdMtOnj9ebUbNxPKfDJLopzjaogcsySp4GyUEpASWE1GPUSe1VUKGpKUd/NQMqKS1feYCErsROscYXrWi0lfR50jt6NZsitgokR2W0doTtYKwLMW8CI8MM+LZwTzbgou66UF+FFCQ/QcXya7vdSQaf2SPSjAVGRqQ4ws6aq3wbwC+ka4SwEBAXj18nPNRMRTSZB4zSc5adFuH1UUOWJAVLOpLw0t2Ha71Wc9erwGto2cu/sgQfo8PVkENO415qxzj238m5gRlWcnaDcqY86RTT0ByoBSRk/SIpd2A4ksz09zTLlsy4iS27zWneDTIretSzQxYb7o2iVzacGJsqjy/mzpvaun8jRHTlosdbyb3Ko7TyiuIkFRVb4AlSqrNXbf1sdxSZG8JzD7mgrARqLybJpUNSHOGoNK+wMy99IUCGTTmhsQQuptzSAQpYCAAIO0oCYrR+hL3JIkI8jNwaSosmX9UdUvQTdVZ6iPKmXLv+sCSK44qb/Iam7gkxAdHdI/G/2Vp4txDkdW52P0SnlZzZUUMwNTE3pa5Oa4LunRBE2TE51ecnvIeYSzB80VqXQYGIPIMz81qcaaFJk5rn65WrKoJp9HXCarD1JkkaewdgixJCY8JWML4HoX1YnIzNitaN0jMMqtu1GUiDutcPSxs35QukLOVGWqsXEn1eiSXRcbWlQptDBZMwhEKSAgAADwt8vOBQBTdu9GkAAYcTagCFK2aopp7Y7zclNtZIlWo9SV68/kHrMnywCNhkTCFR7r82RImSlpV9EvTQiQHZerd+KyWoy40iup6resFQIApCXuuWtr00cdHXKvUUZ0uD2fI2D2SvEdNNIZAbYHnlmfuVfucq6eI0/IIz9pjpnGwNmKM72dvm7t40SRHKvIWYLm3k99Tq9HnnNcHZEyyxRB5amNELkaMb2fTrllI4d6PJ7HVEDASiDYAwQEBBhosgRAtjJR4FWH8DBJptyJVUQyFafL/4FMaiSjk9HH0TATrjouAf7E5xyK6X9csbF+70aTVGTF+D410Dvp8VIMz43bSxm6BMhJEUU1GS2KKkonlAFPyJArfey4K0VS4uZYehJ3K7xEjjVM5+k2KnKAkjBYgbf8X0e43DGLyN4T97hp3t43maKy47bnde6TK4h37p8mg55VgLO9K+jXFZRRVRIm7vhLmfvmVss5JEdEQFyRFYm8StAVcDKaZu9ftmJPEzmtF/uPI6/Hb392ATYEDDZ9FlJv/UMgSgEBAT1C5JAR6ar/dVQhD0Sq75v2x9FmgEZ34jZqdSdep9rKizDFSk/TSHtEhg85B+39Gjyy5GxvyBmz10PcFxg3cvzW+6c5t+0KqyNLaY6ZyVzkgFhN1HGFjBbIRJli5gmx3Wouj5hEtqIuKQL55TYVljQpcXUCJAV/3zpjT0d3pdfzxKbgsvc0S9wAee9M6rHBPjqiqCNB/npCVFNkySFmzL33zudGt75JCgy5Lv0A6x98nYZMPd+oLCSpK2Qf6PqNDYEoPfzww/3e9rDDDluNI+kZgSgFBAQAALa9biYA4PULzwOQIRFOGktGNuz/adE2yXUJkiZMQH0KyGhPXF8efQo9KXPUTb7ZSFLWLwjIECPHmsBs4xIP/b82QSS/75w2SHQtDjyWlgJJiSEq2wiH3K9+Ek+K3EzuehwyUkNIC8yLxLnj1STOE2wzmQZNSjb6pPvQAUBManvy/Z/SvK8H0tfIYMmZd6+ce22c0wmoNTvXmnkeJuWmx9qIm9Qs0UzzDJyrKJE5qLxuTmSIYdYU1EQAXQ2TsFE6kKM502lVhX2Pvh6//8mGEVVa33HEEUf0azvGGNI07XvD1YBAlAICArDd1bMARWomTJcpNwYYzx1AVblBRpEoBrh6H6m0nNvTzTUm1DqabCrO8z5imYmQO9GFBl96CX5Eyt3P7C/UeTJl8Nk0lNuqReus3GPV/ewQoqSgmrQ2M+RXyAP6fdfIL8M36UefVEUVUjqfBtek3KfjbkKtyd0PVqStG8U6+0UVQq2JW/ICm4ZiQm6vKxfd4+m0o76H7viTEpM2EqlDfjORP8o+S5fIGDIoF6aRTfWJPPNK/zV4TUXg1OckKTHkl1sTTtdfSkOm5xQJ02Qp8lOEe3/uBjx93/lYn7EhRJSEaBCuXMcQiFJAwEaOba+ZJUlRyjzS4EY2oirMt3wNUZBpNx1x8SrFdGpO/4Uxol/nxMz5X9gJliJJklxtS6NIktneSdu52TXiqtWJS7ocEMu0V+FyonZbsWSjIS5JMvchZoiqhFozN1Ed2QbFralXURFlE8AEeWTCCN1TG/HRESTd8kXEOrWmiEVko0mmukwTDQKqzZoduddotzcpLzfKlonsaSLmRQSFJMvZ7eX98f/Xx8meP8079z6x5qXaWsHdV+SYijw5qd/sveMAiPx7lpefZ6n58vVnrg3C+owNgSitDwhEKSAgQOo4qurnTMrLtQCIUiAqOxVMORtpygq5G1Wdeed0025ORAqQESuW2AiHOU4jsuQeM3NdIqM5cs9rIkcRbIouZrIsXqea9EFNOop6IEv+ICS54ZbUqPQXr8l0UF3ZvCIIuiIsLWQ8gchWppnqQFc7ZirRGGotzFsmx22396rbCo5ZaGRvoD4nE35POKOjyrqt9/AQGvXKk9cLpNxWtAFZzZf7+bDpN60hq7ZyFJal6j4w4wfFa76BZ6q0WiYtqf6LKoTyMI7dT5mJP91xHgLWHXR2dmLevHl4++23Ua1WvXVnnXXWWhlTIEoBARsxtrt6VmMnFTcKoewCeEV986/5k61wRcish2No8iWcCd7Rs7gTr1stlSU5ru4ou9h68jjLncq1RtEIQ+6cqJMbnXJTTFmCpD2F9OTLlaA67iZbzh4zeD3Zctwc3/f9IWMPoKMiXtTHuS6ThnIiXhQDqePppIlGnd+RWmeq8HQ6VZMkh9ToFCoTKuXmHEPfIJP6qpdkmWN4ZpXq+bv959KijWSmkby+qFp/QNmQVxIqI+iGvI+6gs71tdIEL6oBSYnbqFLm0Lv9zyzMv/XcxhewjkP+Sq18VKiHx7bW8Pzzz+OTn/wkurq60NnZiWHDhuH9999HU1MTNtlkk7VGlDasEoCAgIB+Y5sbZnrvRS7zTR7wfJBEAQBz0i5qmSg428bOK+PZY6Iyqfo5G2GK5DI3UlInAgfq/moZzbGTLvO0NZoMOekl6YMkz+VqqNxKKxE5JEmVnbt9zgCYVisukhIz1249mwhp3jYa1qSGIt94EpDRDkkeyZAdXdWWNFkWp+9X1lFbOClTD+qeswZ6WO5EqtznkhaZR8D0WPR9BGzkyass1Ns3ILXuZ0w3TE4L/mclzTPj0q2vJ0u6ak3c8bdyvJlUDzqe2irMpADUSpn7lOnJtz5iQ3PmPvfcc/Hf//3fWLp0KUqlEp555hm89dZbmDx5Mq6//vq1Nq4BE6W77roLjz76qHl/0UUXYciQIdhnn33w1ltvrdLBBQQErFm4ZKVRtZLIA1CamWq7s7wgq9/SgiVXWVsAXS6uJ+usWNpN0zQ6t2cW6ZoZuqSL6okLslGPTKRLRzlMOjHPzCSqSUzdeMge17h1OxO6b1zJAMak6F1P6CTTZCJmxqwRTFaT6YoynVLSjYi956CJqCtg1kTDvT7HDNO3QVDjYTAETt8P4xXlPD/jK9UozZa9rzptR5kxsV6qHxtA3xM9Lv0smJC2BDxRETrHvFKnj1lKfjRO2yKoeyxyDLlO8j9TAWsdL7zwAs4//3xEUYQoilCpVLDlllvi2muvxde+9rW1Nq4BE6WrrroKpZJsM/7000/j29/+Nq699lqMGDEC5567foYvAwI2VogcQcT2xRJAN8UFYNJl7kvkgOpQOQklRSU0zkGZNsJPCXH/Vdf3zZlUDRnhDcgOHP1TT6meDEHQk6PXFFcHZISNjrhVeobsZMZtjqsn5SxBU8uM8aNqnKvvTZqXx4mq5LVK0feKOFBt8aNCurRfR0F09Vea9x27dUsZt4WJvk/6+nXvPj1OXSXXkJBG9rp4lZyojT22ubeZljSajIjIki99PS5hMrcsQ2yNgNwlMDoSlvFNqrYwEz1yoVvoADa9yRP/3NpsM9dJqLUAO100q/5GrAfY0CJKuVwOTKW4N910U7z99tsAgPb2dvPz2sCANUqLFi3CtttuCwB48MEHcfTRR+O0007DvvvuiwMOOGBVjy8gIGA14Y3zz8PWN8r0W36po+0oKb2OjiLAn8yEScUR4g7/D60RBwMN0zyuONttZcIbaGm8yFNWIJzdFv4yt3pOHcpDXUrIra5ziFidZUEKEFNCazeC0g97F23IqeGltBwtVSN7AhEz2V9PWGFzIr+vIir7hNBtmqttFrSFgHstkSJOwjmPZ5UAeM1rgXqSmhb9sdtUpSVRjZyyvUrHTFWc6+yto2/ygmDIY1xWRL0kndHrevvpZxVJsuSnJpm5T64WaodLZ+GvV65fX/Y3tKq3XXfdFX/605+w/fbb48ADD8Q3vvENvP/++/jhD3+InXfeucf9jjrqqAGf67vf/S422WSTfm074IhSS0sLlixZAgCYM2cOpkyZAgAoFovo7u4e6OECAgLWIt48+zy8efZ5eHX6uRB5qz+i2E5oMsVjUzQUAYWlDLkVzE56zPkmryY5XutBo+JEbFwjQzeKYMwPG5lOAjYSBeflRCdIT8QNolPZMWUFz5p0ePsxZwIngvZb0i/3PtgSeJu6czVI2hSxYfk987ViJo2Z0/eFgaVArckOzTQszsx5+n6KnH8tUc2SJLeizRAb795QXaQqe940L4+T5myqzWjAWP3j088mCzcK6Q8CHinVXkrZ522u100Zqh5++jOWFhjAgVqLfAFA6T0y93f8t9avyNKGFlG66qqrMHr0aADAt771LQwfPhz/8z//g8WLF+O2227rcb8HH3wQ+Xwe7e3t/Xo9+uij6Ojo6Pe4BhxROvjgg3HKKadg1113xWuvvYZDDz0UAPDyyy9j7NixAz1cQEDAOoLXLj0X4785yxHU+i0uAJ9USI8aPwXjpmZM+ovQsL+b3s6tenNNKE10JRPF0FobgvJJQv3kairZGkSkXBsDfT3aNykL1x/K9eKReqPG90YL2fW+JiLDmEqRkUoZsTqtlq480/fSjb7pJrUeMVLnTppUZCntIToHSc6iKpnUVt05M1VyPKn3G2LCltyz1P7sph1dGwLSHlvwr8c4uGfJrJs+dZ9bpqKRpYSkABlZyqRcrVhf3S/H84lXCZV2yd6SZiDtktsUlwKdmyFgLWP33Xc3P48cORKPPfZYv/e96aab+h0h+slPfjKgcQ04ovSd73wHe++9N9577z088MADGD58OADgueeew+c+97mBHi4gIGAdQ1RRFUNmUpKTZlS225RHCpRHClSHyFmQGBqbOmoRcYOKKFdkXac7Yg5JyWhYbGTHRqf0PtmoTlaUbiI4kaou07umKgqWknlFNVvZZrQujtbHTUu66SmeyAlc6pHsee3JrL7ItQjw74tcL/U+DCJipppQnyNpkuk3HdUC5HXxGoHXyPel4vDNNPVQFHlxqwQ9TZlT4QfA9OFzBeCAjYK5FZH63rtaKFd/JDhQa5XH1Pu7+8oB+tEwGzWyKUER28hbmpceVJokCTdCpiJKcVmmlwGge4SNhmlsPduvBl2XQcQG/doQ8NRTT2HYsGH93v4Xv/gFNt98835vz4gadBbsBW+//Ta22GILcO5zLCLCokWLsNVWWw3kcKsUM2bMwNe+9jWcffbZmD17Nmq1Gr7+9a/jsccew5tvvon29nZMmTIFV199NTbbrH9fH5YvX4729nYsW7YMbW1tq/kKAgLWPnQLk7oojZqYdERD5J0IS5kZIuU2d9Vwox/meO6E3ahkPaOXcf2K3Pd9lqST/78R+joO14CdkF0tT/Y4WU8g9/xZrZWphsvZ64sc12kRMUOUdGpOH7OmfYucYwO20tAlJACQ6wDiTvvetu2AIWVa12PO30c+wZbw+zc4KdnxuHYKScm5/sy90c9S75eotJf+zOjPFq/Z5wMokpohm/rasoQ128JFR8Mq7fWpRn3/ypvKnYuL5cHLI9TzGF7Fwi9cjJXBmpgz9Dn2fuhMxM2FvnfoAUlnBU8ffvNand922203PPHEExg6dCh23XVXI+ZuhPnz56/BkVkMOPU2btw4/Otf/6oLcS1duhTjxo1ba03rnn32Wdx2222YOHGiWdbV1YX58+fjsssuw6RJk/DBBx/gnHPOwWGHHYY//elPa2WcAQHrOkQE5NSkW2uW/zOSk6KOIrz+VSl63f4KpelgkkCZyAqhPqWkdTx6fSZaoI8jB6EmPh3VUvuyxKbcyDmW59GEHtI5an+hqvPc0npAHi+u+FVUWQLnNYp13ntVc65jtmueqc7ppvBEJIXJvGZ1MsSkoaI2ntQmiq5FAK/KaAxgSUbSLFvKAJIk5LoJaWRThtosVI+bJ474ukHkRtpAOCJoHc2qqc+BSoEmzXY/oVNqKhJoSIwTMaq1WDKkdUKAXMaXZdqbINO6xCXBmqwpryW3/B8AKkPVccuSIJVHAsX37P3r3pTAqgxsqy5gsbwIMdx3gg5Y/Tj88MNRKBTMz70Rpf5g/vz5yOVyRvz90EMP4c4778QOO+yAadOmIZ/P93GEegyYKPUUgOro6ECxWBzwAFYFOjo6cPzxx+P222/HFVdcYZa3t7fjV7/6lbftzTffjD322ANvv/32Wo1+BQSsy6g110+ctXY7S4353rUAgAL07A5ACXiZ0hU1mtTc9161k6tvcvRF7vmN7imVaZssWcq2y8hWVHl6JNT/7KbaGlW9eWOvS5kxQ5rcNKOp4iL7s+v7Ix25gVynAK8BSZNlaVFFVrjlughJgQGqXUxliNo3sRGdSjsQd0tSkV/hXFPVr0Rz76dJa2aiVhpCO4DDapG8RrgEpE1QDuTw7ruXOtNRsmZ7z6pDCSzxo2ZRlaHWrvoHqrFniS9FgGC63Yslu7ItDFBtk+/Lw231ZVoEqkPkuTvGCfCKvBGiJAcWA6hO7AR/rRn5twqojtFlm+s+NoSqt8svv9z8PG3atEEf7/TTT8fFF1+MnXfeGW+++SaOPfZYHHnkkbj//vvR1dWF2bNnD/iY/SZK5513HgCAMYZvfOMbaGqyZRdpmuKPf/wjdtlllwEPYFVg6tSpOPTQQzFlyhSPKDXCsmXLwBjDkCFDGq6vVCqoVOwvyvLly1flUAMC1nm89vVzse01s+RE5URLcss5am2ibtvx31RRJQGjo/HSZhntEZAhURnO4REcDpPGaSTubmQumT2+S7g0cTDtUViDVJue8Lnif9mokgDAGNzWJCwlJ3rUoNQLKtqkvJQ0WdI6Ka8qjqQPU3Z5VAaqbUDc5UdxNFmqtdqIkgvtTq0r0UwaTAukyX/OXqpNVZHVVcQxS4rTEgzh8siYiggSB5ImdZ0FV+9EjoEoIS3IE6QFeY1RVabIzH1V/0dCRrr0uaptckD6usrDYYTmSYvzILgeg0BuZBkRgOTdEtJ/l0BtCbBlFfFiG7bb5kdX4Y1j157JYX8wWJ3RuqZR2nrrrfHss88a7bPGhx9+iN122w1vvvlmn8d47bXXDBe5//77sd9+++Hee+/F73//exx77LGrlyg9//zzAGRE6aWXXvLCV/l8HpMmTcIFF1ww4AEMFj/60Y8wf/58PPvss31uWy6XcfHFF+O4447rMR87Y8YMTJ8+fVUPMyBgvYObAtGRhKibI2l2IkvfvxZvfeMibHf1LLPMNTbMalUAeCRCa5caeSOZaAy36SXXtFJHlTyo9FqdJUCmmssSKjJpJzfCwnWrDjddCHtuHdFwIe0OmD0utxYAgE+49PqkxK1QvErgVUKtmdcRE32c/HKZrsqtkHold55jJElLV0GmmCptzOuJFlUlAUvzMnrGnYo7W8HHTLWarfZTomgB2bzYqVxz77vRLTnLKQJSRY5cTRsAUE7rqAisxlBrT02UKWmWHkn5ZerwqRMhyjnksMV+3ro3tcdPmwlIJWEVBfnQeMLAEwYxJEGtO6eHLf+P5Dbp6ArifxVAW0rx1A4PTsNfj5iGgDWDhQsXNpTvVCoVvPPOO/06BhFBCPk8f/3rX+NTn/oUAGDLLbfE+++/v1Lj6jdReuqppwAAJ510Em688cZ1Qti8aNEinH322ZgzZ06fab9arYZjjz0WQgjccsstPW53ySWXmOgZICNKW2655Sobc0DA+oDXv3outrt6lqpkUhNarCb0FBAVDipalsJrfhqMWL0It67jvIJbAm/WG3NHq4/yquoUwRJOis6NYrlRqUamkfJ8+sSw5I3Z85rO9q4mSZEaGRlyCIZp9OtEmYQ1OtTXK3uq2WgIT6Bcth1BN1ln7qhK9tipTDXllwNdo5175txLbclQHinJVFqU28tzEeKKdeROc8xLNxrNlhP1M+aVwvHY0tGkVEV8Ur8CTqbkyE/lRWTWkSZMefWAUgbKyVQc5ci7nmq7FXzX2mzETEfUoopyileptbRoSREiUveRAc2JTTOlDKgxoChA7QnQFQEdORQ26VK3uQC2qIj8dut+NmFDSL0BwMMPP2x+fvzxx9He3m7ep2mKJ554AuPGjevXsXbffXdcccUVmDJlCubNm4dbb70VALBgwQJsuummKzW+AWuU7rzzzpU60erAc889h8WLF2Py5MlmWZqm+M1vfoNvf/vbqFQqiKIItVoNxxxzDBYsWIAnn3yyV5JXKBSMsCwgYGPF2FuuB9pg9Bzm2z93iECZA27Ug2yqBXDE2ITGWh84KbIGxEkLgrPWA57YWljSkoXRtTA/omRFwEyNjTIEyh+L8UlSTWqzVVlmX4JXBaZJEkthDDFd0pjmlE1BhuDp9e7YNVlKne+DOqXmX5NKr1VV5Mnx1HNL4IsfCHSNjJDmrMu19yxTm+p0z6mvgSfWGRzwSWOitEhaUwS4kSsCUoAKwonmkMyn5QGkHKjKjVOVrkubAFYD4m6GtOTopYoCSasdgygJSYAApE32ITJN0hgZwpZvlTedcwJagCRxtGHbdKDybhOSf7agfatlmPTzy/DnT30L6yI2lNTbEUccAUBKe0444QRvXS6Xw9ixY3HDDTf061izZ8/G8ccfjwcffBCXXnqp6STyk5/8BPvss89KjW/ARKmzsxNXX301nnjiCSxevNiEuDT6k0NcVTjooIPw0ksvectOOukkTJgwAV/96lc9kvT3v/8dTz31VF3uMyAgoGeIggBTKQwvfeZMqmPvvBYLL7sIEy6fZcW7RnvikBR1jGzlmCsmNiSpUXWTQ5BccmGOn4n+1B0TGW2U2YYZEsRVuw9NHkROOUCr6FOdVxQpvyLGDKETujdbAhNhcvuyJc73MI8k6etzx+uQJV0FBwCFD4DyCPkzr9hojxE/O+1btK4JMfO8o5reS9E1MkJSZIid5eY5CXjpRTdiaCrwHHLoVuXpaJO8LjfKxkAxgdU4UEyNbojH8sGIlAN5AUoZ0uZUfvYARDWOpETG+U/kyXuWabO8cNYsgIpMXaKobkYqzZtYXr7Pl2ogoTRggiHSabeEI+mUg27azHdt/sjPpuOVIy9HwOqB5hHjxo3Ds88+ixEjRqz0sSZOnFjHCwDguuuuQxRFDfboGwMmSqeccgrmzZuHL3zhCxg9evSgS/kGg9bWVuy0007esubmZgwfPhw77bQTkiTB0Ucfjfnz5+PnP/850jTFu+++CwAYNmzYSpUJBgRsDFh4xgUY9231Dc7T6DBQRJLIFBuxDhtFMJO2S1ac6FLDhqxZoqWXx44+qGpTY2a9oy9yz2XWK+JQd/yMmJsiIO6273mNGqYO3RJ/SfxIRVCYqlaruy2mvYbrDeRVnDUgea6GSArGmWlfEnf45AQErxIuKisDylSaU8bdqr8cAZ2jIuQ7CLluMo2AeUoeWRMRM42DU91013lmvKaeSy1jXVBjSIuSQIqck3LTkR3hRJQEA4uFJC4MYPkUuYK8OdXuHNAlLyZtsZ81igm8zKXYvk0yzSiniFY1AgrCEDAQZLQKAKUM+Wa5PeOESAncarUYjAFJJQLLpSg0WfZaSyITdVkX9Uo0yNTbuhJR0liwYMFqO/ZgqvIHTJR+8Ytf4NFHH8W+++670iddU3jnnXdM7jNbkffUU0+FJr4BAb1gwVfOt2RJgRgAwYCYgCrHwtOdAg63iqqRnZqTAvN6ual9dETIFWx7vktK1C1iIK74x3UjUI08gXgmchPVqGFUy60Ic4XbgErVMatTakTIWKr8jzIROJ5KzY5MUdkV3jzlXKvRCemsUSr7mwFArstaBCCzP68CqEG6T2tzRZXe8xoWw/oNAUB+BRm/In3diTOvRDX73jw7jxzJa0lLVsPlQu6jPjd6WcrAcpIkcfU/ANQqMeJ8ilwxARUSJOWcfzMqEURRgOWkP0SuqYZUpc54PjXHYYwg1PK4aEOBRAxxJD+IESfoj0ZcSMEjYf1JyR5nXYXi6IPaf13DE0880WPG6vvf/36f+3POew3grIzX44CJ0tChQwdkFb6mMXfuXPPz2LFje/R9CggIGDgYSQLVF0hVSXlpLydF5vV/g0NumL+d3RkmzaMjJVEls03dYP3WIhomguREcVxiJ5wUla5II02QGAMYs87XmfPr9FjDBrPklN476Ss3haTNMF2y5N4nJqRwOtcho0T6HDplSLEVPEe1TETKIZ/a+iDOVMXVSgyIMpYJpEwfU3gaLPeead1Q1M2QNJEktAV7n5mOKKlIJDMRH2Yqzhgn8Kg+ShkXLctlDEicVF6umIAEQxQLpDVFllTkioRM6TEOkOBobpaq8GwUpVioIRX1HyTGCJWKfEhxbu0YKfcFAQbW6y9B3/sPBDNmzMBPf/pTvPrqqyiVSthnn31wzTXXYPz48WYbIsL06dNx22234YMPPsCee+6J73znO9hxxx37PP706dPxzW9+E7vvvvtKZ6x+9rOfee9rtRqef/553HXXXStd0T7gFiZ33303HnroIdx1112el9KGitDCJCCgb3zkG7MAZMiBjsg0aNJKUT3JAOxk3uhLPHOiQrku1H8dzhwvK87OVrvVtUJRiKpqfWK376lKz5bE2w1sU2Fm++U5qbo0z8xYDFnKvNfpv7TAvHPrqJJLktx7HnU5qc9MilNfj2k1E/lESVsJVFu5iaKVh8rzUeYrtb5GfY6sIWXSTKZKEoApBkAplRFJAFC6pEhph3TkhnPyyIy7PE01GfIJlY4oMaZ0Tvq8arNSc9Wk2txjJymXgm4AnJFHmJJE3kihiJg8HsNrR1+G3rAmW5hM+sn5iJpWvvgo7argz0ff0O+xfuITn8Cxxx6Lj370o0iSBJdeeileeukl/PWvf0VzsyxFvOaaa3DllVfiBz/4AbbffntcccUV+M1vfoO//e1vaG1t7fX4o0ePxrXXXosvfOELK31NPeHee+/Fj3/8Yzz00EMD3nfARGnXXXfFG2+8ASLC2LFjkcv5yfi11YtldSEQpYCNBWN/eLX5uT99rsZ/S5IjXoVHUihTPQXYlJYRB7vaHAeNrALc97q1ijmu0wwWcHyfMu+zImwdKTLptez6KtVtW9e6BP4YdbRIi7lFhrC4PclcuBV3rtYnLtuy+1S1Eqk584zb/kNXt+mUnK7M0+fKL/ebGrutVTQpc7VZ1RZuttGicVdzJhfAPEfXHkBWpikxvNaxNSf+zjrVGae2Kg2WFEWxTcVx7k9R3DHPSoUlRZogpTVuyFCpuaKO6x0CtZp8OFrIHWtBt2AQ6pjCEXy74+Cc8OpR30BPWJNEaeL9FwyaKL34metXeqzvvfceNtlkE8ybNw/77bcfiAibbbYZzjnnHHz1q18FID2QNt10U1xzzTU4/fTTez3e8OHD8X//93/YZpttVup6esMbb7yBiRMnorOzs++NMxhw6k2X8QUEBGw4GPuDa7xKtrr1d10DAFh4gvzjt8PXZwHu32dShAm2MztgUz6uI7Te3qZk1DLh7+d6G1HkT/QUWVF3o0o6ntr3bopIR3ZcMbjf0qT+e6NpXsv8bc0+ZImMJ2pWImiCilI1SCPo3mgUqV5nGRNIff+iGsnqtC7HQ0k32u2Wx0kc4pTmbeor7pLnTYtONIlbApeUGPIrZLsUr20Ml5GrqJypaHO0ZVq8zxO7TVSWy0QM8DL3+6cZMRpMyo1SZqrevPvKCVwNMhfLgbnRoFQwRFwgSSOzfaoIEGOEfDGBEByMEYgsCdORIsD6CFWTCJwRGCNwLgxZAmyEi8hWyK0rEMTAVoGPUrYDRX9tcpYtWwYARo6zYMECvPvuu/jP//xP71j7778//vCHP/RJlE455RTce++9uOyy3qN2A0V3dzduvvlmbLHFFiu1/4CJktuXJSAgYP3HmO9fC9agAk1j3M03AOrLpm5XEkGZ/UUOGcrXR2Z87Y8kN8L5+5vV8WTFzbpPmknx5G1UyavGS2w6zydG7s8ZEbZ7XnUNxFldHzdXp0RRfUsTETOlP9IHs0aTgE3lgUhGnciPKmlbAtm7rPHYtPBaR3cAFQ3qlPfB2AMQUB0iLzr/oX2otVYgt1wJujVvIX3NQLWVIddJ5t650aq+FL9au5T1VuIJkLQKWbnWnFji6pANIkmSsqm2NOGIYgFBDIVcA6GZQqqIUFK1N5RxIJev30efI4oEOCckOo3nfCBcAbf3O5G5Bzs+NA0vHz6tx3Gtb8iaKl9++eV99l0jIpx33nn42Mc+ZqrPdVV51thx0003xVtvvdXnOMrlMm677Tb8+te/xsSJE+syVjNnzuzzGEOHDvW0TUSEFStWoKmpCXfffXef+zfCgIlSQEDAhoOxt18HRFJ78daJMlo09odXY+wPrwb/QAtoALbc/1PhVqtp8TBxAFwSKK+NRaaijFecqJNbHeZEkbyqN7VM5KXbtIhd/ZA9T08ESY6TrCA8WxXnuoArPyVXVC5i5uicHK1RzpnchbwQbT0QV3xdE0+ApKj0PpEfheIpeU1lK0MYCh+q6Ifah6VAdYhzPTqT5TwWXgMqwwgsZcitcCYKVS2YNaB0fZGMcFw98uIHhI4t5MK4Q+7fSHwuF8jxueRP/8y7OcSQxG6n0lc6usN0NRxgHkrkRJcakRi3HD7iQgquGXn7CWKS7Kj9dLou0v3eiCGOhKkY661MnqtmeHlF2HQEa+Ij38CL//3NHvdbEyDC4Kre1L6LFi3yUm/9iSZ95StfwYsvvojf/e53deuyImwi6pcw+8UXXzQV6n/5y196PWZPmDVrlrct5xwjR47EnnvuiaFDh/brGFn0iygNGzYMr732GkaMGFHH1rJYunTpSg0kICBg9WPsbdfJHwx7AVjKsPDUC+X6268DMnYjrjt1dagw/bj0ZCxanQlYqMk7EzUxURhVccWrvmmh8edxCIqZkNX/UUUeU7tAe9ErN1VHTmrJFFexuoiSWwlGkSJLnBlfJNe00fVOkpEl5t2XpElFJ3Q1nLIAiLuVv08sHbDjsnxfaYusU7Yz0a0Yy5D/UJIlI5DO2XsYVWRUTQqx5XJNoNICASQdrHVqMqtLokimA6Ma/FQiSVKW65SDqQyVrU/SnCV2PFVjEairgNOIypIEx90M1aEOc004oHRHnhDbIUKMkRFjuymuWhJ5gmsNXZEGoGFKjASTac9IRqyYR7rsdjo9l4V7rrwT1YrqGgyuPawqZ+62trYBaZTOPPNMPPzww/jNb37jpbNGjRoFQEaWRo8ebZYvXry4X+1DdKu0weDEE08c9DGy6BdRmjVrllGrr0zn3YCAgLUH7YVEnOp/4wUzXkhjvnetLDUuR9ITp0mAd/s5OeIA5cmUgUcVJ6qiyZFKlUVVX+Sru8lrAhNVbLWU3cjqk7T2RSMtyLSbK37W+zT8GVBkgMzPcMhNNoWmyZK8TibJUs5vWWK1OWTIkOuYLWJbpab7qAFAeajeUVaURVVZZaZJ0LKt7TG6NidDDlmmbF3rwOJuRXpcr6MKg4gJaZ4Qla0uSRMqz8k6J8XigE3b8apM8cXdhPwyQvcIPyoFqPuj7qNrbmncw0squuRmTLQYWzBwp8zeRJMyBIZzghDME3Hr94IYqtXYaI687+xOZIyEJUapqmwjYkiFJUA6MqWjTvo9Vzolc6+E/zvAGJmo0sYGIsKZZ56Jn/3sZ5g7d25d/7Vx48Zh1KhR+NWvfoVdd90VAFCtVjFv3jxcc801/T7P66+/jjfeeAP77bcfSqVSnxGpF198ETvttBM453jxxRd7PfbEiRP7PQ6NfhElt/dKtg9LQEDAuomxt1wPAL7PSsKk6R+TqaiFp15otkNBkqm3vnQRANSbTar5QouDC0uZ0bJU24H8h8p4ULeZcEiQiKy2SJOjvsiOm37T6T3TG43pKE/motUycta70SQXwtEbucexnk5M6Y3kdWX9ahhJYmH6vDnzqYi1yaMkTvkVAiu2smGzYa+m6B4m33eNZrLCzSWNHOAVTXYIvKbTdOr4eWkFAMixpUUVLXOIlY6+pUVJagzhU0TT0yvBaqkoshExwJIhUzmoBPRZiwBAPqekSZ2viyNtFkB3ZNqJZLVw5GjcZYpMEhqdonPTZjVHhO3OmV40iGyUxD2OIUVMki03wuSm8gyJcqJMJBi6y3kUC241gsTabm2ypnu9TZ06Fffeey8eeughtLa2Gk1Se3s7SqUSGGM455xzcNVVV2G77bbDdttth6uuugpNTU047rjj+jz+kiVLcMwxx+Cpp54CYwx///vfsfXWW+OUU07BkCFDeuz3tssuu+Ddd9/FJptsgl122QWMsYYeioyxNWM4CUhnywcffBCvvPIKGGPYYYcdcNhhh/XZR2WgRpWMMcyfPx9jxoxZmWEGBGxUGPtdSXgWfvkC8zOgIkmuHiVhgPK1GfftG6yjdoVj4RmO0zYgCYnjh1N4T3nLqIhBrsMhPCqqYMrgCyplo92udSSnajVMUcWJijh/19z0WNwlj+0eh6d2PXfSY9n9rds3kzol5xw9+SjpY2myZJy5M9omHUly9VhGt8SAaottOJvmgNJi8nq7lZYKvDcpMteh4eqLqu1yzCJHiLsZRA4o/VuuS4pSP5Q0O0aPjp4rqsjnxBJ5G9K88p9S0NVpvAZVmehXvRWWAeXhzv0wN8c+M5MmJdS1bQGAqJMjbUuBGgdrqhdYMwYvHcfcKBIxcEYQgvsm6pwgUmb2N9sLfxljZIiTS7xMOtYhvo1Sb9l0XbmSQ6lYldVvXBjiNv6n38TferELWJ1YVVVv/cWtt94KAHVdLe68806T8rrooovQ3d2NM844wxhOzpkzp08PJQA499xzkcvl8Pbbb+MjH/mIWf7Zz34W5557bo9EacGCBRg5cqT5eVVjwETp9ddfxyc/+Un84x//wPjx40FEeO2117Dlllvi0Ucf7dX/4MMPP8Ts2bPR3t7e53mICGecccZKsb+AgA0JLulZ+OUL6taPu1n98chltuewaY+aMxNnJgUmGBZ85XyMvf06qVGCjDRRXsi+WQCKC2wOTU+S1XYgaZbrW990/GxycgKNO6WAOM2rSdl1h1bQ1VIihiE1dmB2MtdaGy9dpiNGTsqsDjo6pb9dOlEotz+ccRFnlnARnPSZXsZ8YsQT2yokVcJrEdlITVJkKL2fIgc3/WZ/bn2bsHycmrzJthjpHqWIQ8rMfUlKhNJihqQJqChNqr7uuBvIL2eoNTe+x0jk8qQEFJSMNFF+wTo92vxvpU9qY1aMrRruMlLHadTej0FGqYRP+KJuhqRNpm9FSWm1UuaRIU1qRMqNd5LWG2UjPoyR057EOT8xT3Oko1RutMRNxWWNSXkDkuSe39U/uSk3t3JubWFVibn7v33fOzDGMG3atD6r5hphzpw5ePzxx+vK+Lfbbrteq+bcYMrqCKwMmCidddZZ2GabbfDMM8+YCNGSJUvw+c9/HmeddRYeffTRXvc/9thjsckmm/TrXGeeeeZAhxcQsEHAkB/AECAX26gy2bQoTEqI1RhEyYqtdSSIJQzQ7SM0apIRyEmOZPrNOc/Y714viVaFA4KhPCpF8d9+xDhRjUpL/+Km6aqGjlTkl0uyJPJKV6O/7evu8kqL5LpcA/LnqKIiSmXIVFTWh0lt16gCrjdkPZpcc0vjYu36CbkGmglMBZgxlBRArUWRJBXBSfNAvkOepNrGjQN2moOxPFixlRsCA/LL5I/dI2XaSpSEJboAcsvkfXbvg1vFpgksceXHFFlNk14eleXz8FNuMg3XOYqh8KG6/kRGqurguHxTJN97QQlS+yoS5j3TrhhRmzwxpTbyxhgARp4DNmCJjj6E0GGtzFztVq6ZdFlmG02cWNa8sgFJykaXXO2St1zIiBcRw4SffrNXE8qA/qGzs7Nhx4/333+/X5V4AHDXXXdhxIgROPTQQwHICNdtt92GHXbYAffdd99KEakBO3M3NzfjmWeewc477+wt//Of/4x9990XHR0dPey5fiI4cwcMBpN/can5eXmHrImvleX3k4VfuBhb33sVAID/w6pyRcEvLTftHyBJDxMwZCgtOpEHwHxz1+/dSjAvtSV02ojseuc80Ptr52rdR0vpZl6/6Fyz6fZXzjJko/RvKw6W55H/Jw3Sa4DVv7gtTVwBtyZfbjPXOg0TLPmQP6vJkrszuI0qkQpHmCq4rJWAji4Bnh2AWeaUyrutSyptzOp5FNEqLpUHN87kyl9Jtwap6TlBERDtQ1RrJ3tCR3dUfI9Z4uak2Vy4Bp7uvTTRpy434iX/1+/1fdbas6yTeqPzNGyAC6DWoshhuzpxQTWizQvTWiTryq37tPUU5dHptWwUSS/Tx2kE11m7v7DEi/VIoNxb8+pR31ijztzb3X0xoqZi3zv0gLSrjL9//up1Zn479NBDsdtuu+Fb3/oWWltb8eKLL2LMmDE49thjIYTAT37ykz6PMX78eNx66634+Mc/jqeffhoHHXQQZs+ejZ///OeI4xg//elPBzyuAUeUCoUCVqxYUbe8o6MD+Xy+wR4BARsntrv/CrS19Lx+7A+uAe/hV8a4H5OMFGUnKooJLGGIyhzCITg6zUERyf0Auy9zCBTUsRN5bOIE1Ji3XpMxc+yqHcd2M2aZCAhaVeSnW2/nR2HI8VYyhopuZCmnxpLVJcGPiOgx6/30fbIDhtUjCWoo4M6SJ30+cwiVPjJaK9e4jsHolXhNkh4mJEEy+7syHAaUh3G0v1kzxwaApRMky3LtE4zAXQCV4UISWS2K4oR4hR0kU9Ei7VjuQove05Lc3fWccpHmHa+jTGWhUA2NRQGN9Vsq1elVt2UidBQBuU6GyjCHhVYisKYEImWIcilIcE/4xbnUFDFOktcrjRLgaGmciFIjfRJQT5g8sbhrdtnD9u55LamSES9TAUdWT6WztwCw/QPfwp8OPrv+pq0mrGkx9+rGddddhwMOOAB/+tOfUK1WcdFFF+Hll1/G0qVL8fvf/75fx1i0aBG23XZbAMCDDz6Io48+Gqeddhr23XffOm1VfzFgovSpT30Kp512Gr73ve9hjz32AAD88Y9/xJe//GUcdthhAzrWa6+9hrlz52Lx4sUQwv9a941vhDBmwPqLbf/3CjAmo0g55cGSyyVe+wQAENUI4IDYtAa+VM06gkE0pWBVDldM7U6WOvySlpw//DrVpslONsWkiJNHLvQkUWM2reJ2nFDHcltWZCMwuRUwZpPVIUBpsboMlwioL708hYlSCYccuOfgVbmvKzx2K9y0qWN2Es86antmlXEmuqRduE3exo7BiMPdKjbdO05V3BlLAALyK0h5G9lzpCqt6N6r5WNVJ/qyjSQxYVNcbqk/cTJkyW0GnDRJEukSTF6zBM2YQiaQRqKR1Yzpa3NTapLwKUKVaV+iTSQNgXU5tpN2zKbe9PkN+StzULscIHcjSNw6crtRHhJ28k97EFwzZhvnioyFgmtg6Qm7nSGSu49DpDSEEmwL4UeSIi5MCjBNOGKVKhyoKDqgMXbYYQe8+OKLuPXWWxFFETo7O3HUUUdh6tSpni9Tb2hpacGSJUuw1VZbYc6cOTj3XBn9LhaL6O7u7mPvxhgwUbrppptwwgknYO+99zb24kmS4LDDDsONN97Y7+Pcfvvt+J//+R+MGDECo0aN8jwSGGOBKAWst9j6vqvAIxhRaa3mtFdghHyphlolBjiBOtW6mooM5RzikxcmHcY6IqRFsqkyAFHZ6ZLOIVM0jIAUNo3mpNAoInAVJfKiRTp6JaRRoN7eBeUB1wwy7la6I7fkX8gUTrVN6m1cqwDAT49pDZNQOhe9Xvv0xN0+aZEb2LFGVYKImKqAU/fI4UkiYsaNW9oDwEtZafdtAjPnjJxGuO68lxZs5VtSsisKy1TZehMDIFufaAKlW7qwKrB8TA5RlcBr5Hku6ehV3CkJpvQhklYApC0c1L0XJMXRgENACaY3HMU+0QSA1JhoNriXan8Rq/su5LPIktbsvajTJOlrcbO2TpQ0t4yjumkCVDhYyQ6ABAePRMYEknl6I8ASKDfa40KktmkdZQgTg/0dJGJSU0Tu+WwUy9sJQBzJD3oqOKJMdEnX4KUJR+KQpbWBTEZ9pfZfl/D2229jyy23xPTp0xuu22qrrfo8xsEHH4xTTjkFu+66K1577TWjVXr55ZcxduzYlRrXgInSkCFD8NBDD+Hvf/87XnnlFQCSBepQV39xxRVX4MorrzQdhgMC1ldM+KlsY1Ata4EKTCdzQIbouVOezBghV0jkN+EhKZKlRSAimU5z/+YKBlSYTHlBRVVS5k1KelKV3/7VCjdoFcmUGiD3lemjDBlS0RpeZTZyk4nY8CrMJGIIkLM+qthJVpelR1UyJdh1QmwVyYDjfq2hjRCzDVrNuUwFnJ3kGk/wrC41ZTreZ1J42lE7i6RJjj/JMURlmRJq/pcdcNemMaIqIS7LprK8i7xUnC3TZ1a702yvmaVArV2SmOoQ22vN1SXpbdMSIe6wRMysF/qzAc8t243AuXoiQ5icS6bYEjcR2+flEUwbqLEGlFlCzeS+pqKuicC7IoihNZDgIJE2bIALoGE7EW00qUmUWyUHQGmd/LSb8U5KuUzjkSRRTBlZmiiqihi5cCNeAEzT3ThKQST9lXQVXKGQoFKJkSRyLHpsu/7s2obXtzqwoaXexo0bh3/96191BV9LlizBuHHj+lUF/53vfAdf//rXsWjRIjzwwAMYPlx6XDz33HP43Oc+t1LjWuleb9ttt50hR/3tweLigw8+wGc+85mVPX1AwDqB7e6/AnX2YQQInWJjhCifQghmKn2inC5/VmXRQ6pIOmR0ljjw1ikX1p1HV8EtOPN8bH2TctqOCbyby2q3AoFXmRFzQzAZWVJgQqYLWMIaOluzlJm2HxTpZXpfZ1uli9HRIbd/mKlQYzaqwVMCMWbK/DV01CFyok6NBNtuJZpeX9fc1kkv2uu1DWjJPgrvOnQkydgBcHsuN/KTFIG4Isv/88sJ5eGxGT8TQJpn4Ik8XrVV/lxts4QvLViyU2u1hMbt3ZYWFJFWlWqmKlBfogoWJi3SdZup+9uoia4oeNknewy1rY40eeSV2ecOSKLrrc+ACRuN8paTJUkAkLaqC08YolKifjc44rw/4dWlz2CjSNYfSZMelyQ516c+425kydgJcGUtQO5yt5wRiHIpRCqJmZciZ9IWQFsXpClHc0l+GMvdeXV84RG5gJVDTw7cHR0dKBb7J1ofMmQIvv3tb9ctbxSl6i9Wiih973vfw6xZs/D3v/8dgCRN55xzDk455ZR+H+Mzn/kM5syZgy9/+csrM4SAgLWO7R/4FgCGNOVSyxARhP52qb51kmBIq5H8Fs0AShmSSgTumDimZftHuRFJAiRB0hA5AldpN10Rx4StgDOIYAXdahtwstEKN2qkyYJapgmTjii4UQgTteHSZyctWCG3FwViTKWznGt1U08JjP+OmZQdrRBgJ3eu2mVEFT895kaSVO9SpHlff+IK4wFLLsghIpUhzGiitM5H+yPxGpAUpGaq1syQlID8cjLnFTGT4mi1fU1pgJKirSajvNXsUARUhsif3TJ9lsBWLxbccJ69NcQA0UKIO5kXMdJw02eGBKpH4IrlKbKECXCeG3N0S3l/OVBPwETsE1yjSyKgOkzq7Firw7iYJC1ppp+bC60/ImOvbqOxhgS5aVbXyygrU9OR3Ax5sq7bqpozTiESDsYh25w4aUHhFDjkcwkKsfxl6KzknWNyQ5aeP/IitJ94ZcNrW+XYQHJv5513HgAZdLnssss8i4A0TfHHP/7RNMtthL7alrhYbS1MXFx22WWYNWsWzjzzTOy9994AgKeffhrnnnsuFi5ciCuuuKLHfW+66Sbz87bbbovLLrvMWA1ovZPGWWedNdChBQSsEUiCJKG/qZr+VLEwE0CtEoNxsqmARPf2YEhTgFTJPYsFWCyw8MS+09Bjb7lepvaKArzC5cSpo0ipemnelUKKgrUg2+VHTvSA6e1MhMamiXSqxp0QjealplI2iSxrz/ooRVXySBYTNsgVl1HfAsNNEbmREpIEwByfZciAvq1Ks+RGkTzRMXfITJPdH5DXUGuCJSUcnkCaCaDaas9baWdoeo/Uz85QHf2QyNt99RgAea+yfe5E3obH4k4uzRpbhKxGzNlxAkDcwc0YweVjdKM/mggBvi4pW8av7w8TMH34NLjyVqKMyJupZ0Gw1Y1uZZ0WpKdNQkY4h7oDU/+lzERVzfkyfd2kuaSOHPl6Om/8ettsCsk5l3WltyyPiBn9HneiWyQAHguVBtSRLN90spLEMn0ep6BCDakiaq8dfRkAWbq/xjDI1FtDwdlawPPPPw9ARpReeuklr4I+n89j0qRJuOCCerNdjd7algAw61a2hcmAfZRGjBiBm2++uS7Xd9999+HMM8/E+++/3+O+2QZ6PQ6KMbz55psDGdZqQ/BRCnAx4aff9Cpc9LdN/Yc+TSJEsf1FTKqq5YcK5S/8oiVDY+64zvzcKJI05ntS66B7r5mebLBC7rRZz8JOrgqw+iOdesikqSw50fql+jSKe7yonJl0NQFRy3SqLdcJ07YDcI5JMO07Eo8g2PProRsC4QrBEyf1pv5kichhfs65NAHzIiLOcV0zRPeaDHETPhHT16+R6wRqJX/9ionyBrS8LP/Aa0Im8o642skcuKk7Q5KcOUvkyEZxdNSwqp9FRldTY4YoueSrkUFn1mbCkLjM3KHH7GqeXCE+AL/3G+T1uW1MaqPkQaJiavRH+kuD/n3RBMRNvaVehMjxS8pqmJxrygq5ARkVshFedT7VlDdResJcKUGqvrBo8mbG6hxSj7OpaEOAtSQyztxuv7c16aO09Q8uBR+Ej5LoKuPNE69cZ+a3k046CTfeeOOAx9Kba3cWK2M4OeCIUpqm2H333euWT548GUnSwLDDwerowRIQsKpwyp9OBADcsfsPGq7f8aFpADg4I9Sq9leHhOQl0qeFkCYR3jj2a32er6c0GwCM/X/Xm9/Osd9RLt1aTF3lMjrSlNrlZtJQqTUGOagsgcqk2BA5EaeMQFu29JDrRV6SCtfFWu+T7U6fFJmNPkVwhL8yahXVgKSQIXR66DkZwWjUOFc3cSXmR7w8IbfW8qi5w9XLANaSQDtom9YpDnRJvSEaTB6HOymmXDfQobos0PadQJdkCB072ok0/rdiQyV49wOQ15g0E6IuKdbXLueGBKnSf4oISAGeMPvl3yEFpklurnHECFDPymaw7DI1Ht7gCzZlZ4YGX6dJi77JEiReAyqbyAPygj2wdt+WP5OnP/KsAUiLt+171ZvY/5wD3nOL8qnRAGqxuEg4eCzM+ygWSBVxKrXahxnHqfVHAsxxiICcIlZ6vOVqjMgZbxwJvHTYymtfBos13cJkdePOO+80P7/zzjtgjGHzzTfvc7/V3Q92wETp85//PG699VbMVC0UNG677TYcf/zx/T7ON7/5TVxwwQV1duXd3d247rrrgj1AwBrF5545Dc29/DaMu2cGmlrkN8uXD5/W4zYiZVhw/CUDPv/Y/+9q+6ai3AQzMIQmIkuSiJkeZXXaI018SKbWDBzSZEiG1rZoggUrD6HIdq/XKSkuHA7mVEmlSstDcSaq7xI0JnuopTlmz+mMQUdrskJknXrTkR9NklwRtj4XT5RWSB0jadH30Dmm87yzGQjZJNa+L29RQ8vf5IJKm7zewhKg5ROyQ21HoYBiThlL6mNtCixe3Ib43QLSgkMq8vbC0iZC1M0Qd3KkJbtcVzoCzGzPCFKMnyMvqiRi+3yNxqlIno8VT5iXomOOtsXt1Wbuh0Oaja+UK/LPaJagjl0eKcCqDGyEJSJENpIURbLSTAhmyuoZI0SR1C25JpFEzPJ/5hyL2WibNpAkkhrByGmu61awaf+jKBaI1TbaVDJJOSLl6STUl52Iq21MtaodhyDW49+ANY0NrepNCIErrrgCN9xwg+ny0draivPPPx+XXnopOO/h20AGP/zhD/Hd734XCxYswNNPP40xY8Zg9uzZGDduHA4//PABj2ulxdxz5szBXnvtBQB45plnsGjRInzxi180oiwAdWTKxfTp0/HlL3+5jih1dXVh+vTpgSgFrHF0JnnkG3y9luX/OXR1FHolQStDkACZYmMN+rmxhJuoj54402ZXMAJJgpidIL11jKQOQ5ETQG4P1VUdcDU8zDaXVZ5KcgMnJVJU0SNHv5P9hs+V0aAmJHqyjqqyH5rueSZJjpzwTEuRVFbRMXVaXfGmH4mbViJlK+DqjlyYZUy6VMvqNCByxMu6qiwt6pthvYpc4lXdsgqkDB3jayi0SwKgU67dH7ZgaKsMqZVrOZOWbSvZXF0yqgK2PIcUAC9beweT3orIjEHkmSE9UbdKCXVLxpoWyaThRM5+JljKwASDyCmfLR1ty1kCJQrSwNJYQzSKEDnVkIycR69JQiZhoN3BdUpR5IC4k6M2qmrN4DMpNkCRD2ZNHTWiSNQZsvLIL+FnEczAmLNvnHOiV2rIjFnCk1frNeGpJVF9GpIRirnERJdycSq3g5+GW1dIEgD7izKY/dchXHrppfje976Hq6++Gvvuuy+ICL///e8xbdo0lMtlXHll3yL5W2+9Fd/4xjdwzjnn4MorrzSapCFDhmD27Nlrhij95S9/wW677QYAeOONNwAAI0eOxMiRI/GXv/zFbNeXZUBPZYB//vOfTbPdgIA1iSxJmviIJusxCqXaKm16OfaHKoKkUgFU41ZrA9jqNAYgYVJAW5CGOSy2FXXgpNqQUOM/epGz3E1fuBEowIi+TSorYyEgYjmxJ4osZS0GhDaQ5DLaZFJuGVIgYmZbixhtEaHaasdoxNlKJKyPTcxGgbQA2XSU0FEmfUyC53qtU3HSrFKNKQG6N1X3sigQLY+QlsiSpE0l2eEA8q0JNh/6IQDg3eVtQCwnUo1iroZU7djRbRldTpsslhLUOvJImwEkDLzLJwRMMOlInpc/s0RFDguaNDFEZWZ7zDlVk/YeM6TNwos8uusBoNZGiFfIzxV3dGEmQhTXR53c5rquOF5bBGjo9CHriCEYEBXltUdZ3yR1XE/A3aCNiPwf9WJtZiNHcZxah25nG5OlFByFvBVrMQZUa/IiUsd2wE2naXIlBPPI0jpFkDZQ3HXXXbjjjju8Lh+TJk3C5ptvjjPOOKNfROnmm2/G7bffjiOOOAJXX20j9bvvvnuvgvDeMGCi9NRTT63UiTSGDh0KxhgYY9h+++09spSmKTo6OoJlQMBaQVVEKCrF8QFPXABARjvzuQQv/vc3B3y8j/xMahdeOfJy44OEoVrD4vxR5wC0GzPUBCeY1A8l8n/S3kuxjQbpijtpOMn8CBLgEyfq4X84URsu99fmhfIkZAiVyKlqtYKv1zH8UhEjoSINOq3GUqnxyXVagqT7sQEwJElPwq7ztIiVLily1js6H3d7imHafejmshCOTkndjjRviVVuBUd1qHJhbktN41ZNcPJ5+X+acvzjgyEoFmrIxSk4IzMx10SEiMtych2NWLKiGUOauzG0tQtl5cxeKlbR2VVAujxvU6cA4qW66RpJMtoigDyAlgRsmfLX0gQwkZEiQEWJUvX83eKyyDZVdsmQji7V2gm8wsA7VXRL85hGWY2MLsitJtSfkagbqAwj8DJD2mJJUVqOUVBaIJfoNLIF4M69A+Cl4NyIkkuQ3G1rtdik4Wo1S0JzTiSpW5XzF1RLIf38cnFqBOSNGurm4hQvHPqtuuXrAjY0jdLSpUsxYcKEuuUTJkzA0qVL+3WMBQsWYNddd61bXigU0NnZuVLjWmnDSUBWuh122GFobm7ue2OF2bNng4hw8sknY/r06Whvbzfr8vk8xo4da2wHAgLWFO7b6zac9OxJADRJAoY1dWHuQdf3tluP2O7+KxCr364x378WHJkIAiNQIs1/KOEyO5YweOkAHRlwSRLgTV6GLEUEVnMMd7LBJS+SpJf51gFMkSydYjEWNjpqBZW+coTJXKW/ssEs3VoDJElJXJYeSsaRmiRZMl3qNQlyyukNsemhOavb/iTNq3PmHB8kx9NHxDL1lBYtYTCTOgFImPH74TmZ7ikULPuIIiEn85SbSJJLltxJvlSoolzNYVlXEUObu9GUr6Ga2ucftVWRVuR7/oEtg9bPIrcsQm1TeW5qrwHlSKYzVaUjE7J5sY7yJE0ExDDtafQ1aw8tak4BvU6TJsFQHULILWc2eqgiPdkUGyDJcdQtq/9cjysmdP85hlqbE5VR0aSkFiGXS83j09GabOSIcwLnKZKUmwo2l1wxZt3tXZIE2BZBlRUFSfYBFJutqL5SzRn37ELBXpxuU0Jkny9gI0163Z8/tW6SJADmmQ1q/3UIkyZNwre//W3PSggAvv3tb2PSpEn9Osa4cePwwgsv1Am8f/GLX2CHHXZYqXENiiidfvrp2HPPPbH11lv3e58TTjjBVMdNmTIFW2yxxWCGEBCw2rAyJGnr+64CAESZ3yzRnMoS5ZR7KS8Nk/JySU5ke7sxt7VC5o8b4wRokuQe2rgCOgvdL/PkpNoAZO0BPF8l13QSMFVwIu8f02iTHHF4VFNVZI65IjFYkqTTSUosrKvX6q7XJXGaWDmmkSaK5B5Tk0sB4xXFCEiGqIHmBbijb9El4q3NZZSrMYisvsUcmxhyPIUAQ8TI9P6qOTbZxXwNlWoOH3aWkM8lVkCsy+NLCWqqRF0UbWuS6pb2JjFGoFoExCQjjir1qh1dRAGIOjmiMkPaJG82S5n5zAhXzxZbATRxAqry81JrI/Nc9BiM8DyDtCSJEiNfLxZVpE4pt4KhUgTQlCCtRCi02GvhDjHirrbIiS6ZVJhqWcKUls4Iu4khn09MFCRR5LO6XLljxzL6mW+u1rcm4YRCPoFQgm2X7AIwy+V9xzobQdrQce211+LQQw/Fr3/9a+y9995gjOEPf/gDFi1ahMcee6xfx7jwwgsxdepUlMtlEBH+7//+D/fddx9mzJiBO+64Y6XGNSiiNEALJnvSOMYZZ5xhesUFBKwLuPOjd2KPX8qy/uZ8pY+tLbQBZVLxBaJJEiGpRrJMWstFBJe6IUd8zSICKV0PM67XiiBlf8Uy702LBr2PqXxzNuT++QAZlXCP54nBHf2RrFKzVW+A9QYyLSyciIRHqJiNOLkaF02QXMG0iSQxmHuoeQczY1QpMzfSpMfoQAuj05IwflPMmTjTkgArc4gm2Zte1CITARGCobVFapOK+QSVWoxaEhlxduJ4/HDnYQg3lcpk5CQuVYxeKUk54kigtbmMioqA5PMJuiMBvF9A0kqyV19HBNauWAoBLJeCljtqdZXW5F3WdNL4R+WlCSlLLFnS0Pc6bqkh6YyRtiS2Qq4EsAo3RAmA6tXn3Fsh77+IrB8W4HhPJbK9CgCgK0Z+RLeMdBIzKTFAEiM9bWhdkE13MZXClO9qjrC7ucn+PnZ0FhDHMgLUvbRkPiCUMMQttTrXb51+01WJmtDqSjfAEiYAmP/Jnk2T1zVsaFVv+++/P1577TV85zvfwauvvgoiwlFHHYUzzjgDm222Wb+OcdJJJyFJElx00UXo6urCcccdh8033xw33ngjjj322JUa16CI0mCw55574vnnn1/t/gcBAf3FXo9fAs6AUk7O6rs99nV8sFSmlRd8/hJs82MrJNSRASFYXfQIkJ3FtdkdjwTAoN474RENRrKap7e/WY2+kzh/5LzUm16X9VDSpxVO81tYEuF5EikNihT02vRctqEqKVGw6Z2mjqMjEtk2I8bsUafMdHpM+JEkT2Ssz6V1MeRXWrkVeLK6yyFLRRmFQYEA1w26KGSURvUgo5ShucVOxoIYOCMUnJYVLkkCLDnSJEg2UFXPXA26rVRGNY0gBEctiZCLUxRyiUcCMKIC8aEKjTnaJe1MjZYUqHDZ3DiF1SVp8ieAqIsjbRIQBYGom8t7VeGgITVzG/OlGtIkQtycmKo97Q6PCkdlhEBumRq/I+j2LBXUsONuKZDnNWu9AADxCg6+tdSBJJUIUU5ApNxovQBJlhppkBrW/zBgeKs83rvvSZlGlEuRJBzJsoJ8AnnrlZRlzdqOoOSkUXU0ELDPGVi/CJKHdSx9Nlhsttlm/RJt94ZTTz0Vp556Kt5//30IIeqa7A4UgyJKv/jFL/rN8rI444wzcP755+Odd97B5MmT63ROK9OPJSBgZXHIvHMAyNxNdy3vaUoAHTVq7OGRJtyY1HkNcQFwFeIXqaxqM27BkWMgpHcE7DL3bW8kSbC6lJncL7MTh+0foirkXGLkEh2v3xrZ7XWVk3apds0n3dN5HechyYyxDCCbLnMrptzoktutnimtk1nvCL3TghpaDJtuKthIHKtxiKLKZ+qqpqLjP5WTDYsBoElFLPJOebgghqElWfpfTe1g9SRrS8cJScoh1H5RJFATEXJOFSXnwkRQXNNCneqLRpZR68rJqFzN6nSYWzGWk5FB45lUUZO99llSGjf9nhiA5TnkNulWYyDwfGLIPecElKT4WbtTV4sC+X/HMnXJZCSQMs1vU6fprvsRTkfLe5h2xyaSlNY4csUEScqNiBrwIyHaJiDiAs0Fm65b/EErhrd3IhUci//dbu5F8oHjRK2epzaXJAHkVXRQk7GCFuQ7HzLPXZ9YSLWtQ/jggw/wve99D6+88goYY/jIRz6Ck046qc9q+O7ubvzqV7/CgQceiNbWVgCykwggncznzp2LQw45BIVCobfDNMSAW5isKjQyjhpsP5bVgdDCZMPHp/9wBjpqcvZe2mV9vcq1HDqWyz/KugoqrUX1BwBMJ3PdoJPx+l8rt6KmkWDVrmSWHPVCkkjYn+t8lACfvaSWWAEN9EhpZnnGMVvvpyMNusS+7jhqvXbABvl6l2wZf1ryIxZmO5d8NQjCiZzDFRU50mSJVMd6rirGhG4W3ORENRxRb6koB5h3JvJSzg7arciqKnKk0zeNBMCATCtF6uZ0Va2QKhenpjzdpJjU+2qn7muiL1K9zQkIp3Fy1Kna4kRApMmSaY7M/HvRJq+pqa3bEDkAaFWpxIgT3vtQhoRSpZnSjuLacd3VlrmtXFKlCSuPJIiCGmyzVuurfRW5ifMpiqpMX6ceAXn/TPsf9btT/rf8HYyGKeL1gQ47wn4WNOHVmWZ1nkLJPjf3eeZ6sBEAVr0eaU22MNny/10OXhpEC5PuMhadPn2dmd/mzZuHww8/HG1tbaYDyHPPPYcPP/wQDz/8MPbff/8e973xxhvx8MMP44knnmi4fsqUKTjyyCMxderUAY9rQBGlJEkwa9Ys3HfffXjttdfAGMN2222H4447DmeffXZdY9veENqZBKxLaMlVsWj5EDBmu4JzRmhpK6NcyRliwyMhtUiAEVgzJrVFRHJioJTVERyPODGtS7KCVQ1DnPSk4E4ObqrNrVxLGke6DNIMmWpAvigiVYmmIhOu6SRgIjLSGoAhzctKNg/aP0mJsnUbEB2dMJevXL1NGs4pNXejTB5Zc1KCZhnZFJudqFOzn2ivgedTeSnKvDPfZCfSgpMOcifVtoJ/YSlJ5+buqvz7FkfCpNo0CYq4bcuhSZWOYGRTbflcatJNScoRxymE4Iiclh+mhYduy1FMQR2K+BXI9H1LCwSuUqTCScexlEGUUqDMwXU1HxdoK0nyoSOmEVKMHNKBpR1NiFqq8rlBXlPSBORWqOdD8nmkRZhnWRlmP0i8wuUz6IyBFnsvdaQnqUYoA+azp3VD2qW70q1sEJYWpIYPgHhPEgAGSXZ1VaYmSTyfej3ecg75jSKBVPhRrKwf0wYRRSIMLvW2jqXtpk6dimOOOQa33norokj5XaUpzjjjDEydOtXzaszinnvuwWWXXdbj+nPOOQff/OY3V4oo9Tui1N3djYMPPhhPP/00pkyZgo985CMgIrz66qv49a9/jX333Rdz5sxBsbjy7HZdRIgobRz43DOnAQD+sni0941Tf8vVvySJ+vbvdSV3NjB/uPV/2RRYJvBjIkvZSjgTLvHfZxuEWvLjkCD3UDoqkfjHz/pTskz5OBPOvu7YtLYkYchlLEnc47lu2Y0ar4o86nyRdBREl7kb8qSPRa5Lt72vujEw5YWxUNApNfevG+PWqLCkmpvqqI4uW8+SpJgLVNy0m/be4amJKlWT2DuXW/3mHruqRdxq8o7Uvfyws2QiU+UOxy4gsiRaaHKuiVDZJ8csYYYsxp1yXTJCRdZUKqq5WUVoBEPRIYk6vbikqxld3Yok/UNKIQpL/EijsSRoBmot9ua6juGaKOnPPtfpRadlCQCUPyx6XyBIWCNOyqsTqv9JN7dV791KxThTlajtA0qFWsMo0uomSGs0ovTdVRBR+vK6E1EqlUp44YUXMH78eG/53/72N+yyyy7o7u7ucd+hQ4fiz3/+M7baaquG699++21MmjQJH3zwwYDH1e+I0owZM7Bo0SI8//zzdfqhP//5zzjssMNw9dVXY9q0af0++RtvvIHZs2d7ucizzz4b22yzTb+PERCwqsEZmRQL4Ex01dj6v4D5pIQpssMy0SNNaBoEfXQPLMqmzUj9Q8yJLJFPpphDbrLpu8y3TL1dHWdzhNqel465EbBl9cKeiyICg+ylplMxOqqROuX6epzab4div5KNpUqMTT7xQcYCgAm7nhxpl9knZaCSIkYJM21G3CggIElumnLkcikq1RyKjsDXJUixU74OAIUoQSK0SNuJYCiylI8TWarOgJqQ0SfXVykV3CtXNxEnWHIliKFWjmWk0YjGyXyuWF4AXbGthnQ+MyJHoDyB17hsh1KSBIt1RKD2BKIWodhSQS2J0KwiSs15m09riuV9aGr7EIswBMuXlYCRZbB/2QlYC/Qpsh+ZXAczYvxa0Xl+HTHQlILAQDUOrooj0oSb9B66IqAg5LVpvVYxAYqJ2UaW+8vNNdljmWo+3eLEFYsDMETQNQHdICJIdWCo+/Y14P3XHey222545ZVX6ojSK6+8gl122aXXfZMkwXvvvdcjUXrvvfeMNdFA0W+i9KMf/QgzZ85sKLKeNGkSrr/+elx66aX9JkqPP/44DjvsMOyyyy6mp8sf/vAH7LjjjnjkkUdw8MEH9/siAgIGi/v2us38vOND0xA7BnSAFO7GsW3oKYWjKtqkIyZOs04DhsbVPJDLdfURc4lQA0dtlyTVRZEy52sURXIL4DzC5Dhve+JufW59qoi8dSIvLQPSkowypBHq9EpGO8tgK9rUNi6hkhVc8pgsYUgL1LBgD9qxnGQEg6eAUBocfQ1RKUFSjRDn0rrnEedS81aTpJZCRWqQiBvxtSCGYpSgqlidroxyoxJEDIm6QFJi5Frqk2sjCndaZej31mhRoFSoorucR64ghdbIST2NJtAsIohaJFNO3REglBVAUv/8Wcps6rFkH0i5o4AhwzuQCo7NW5dhRU0ynFJcQ1VEhiwBQFt7t0wVbltF+fU25JRtgPt4o7JMzfEaPCE+hPJ7qnHTrDlZkXe0b85nssLBh0gSJcp2KoqKia0YVWQKQJ3uT0eoXANK7XnlGlpyRutvRVtf2MBSb2eddRbOPvtsvP76614v2e985zu4+uqr8eKLL5pts1xkxx13xK9//WtMnjy54bF/9atfYccdd1ypcfU79VYsFvH3v/8dW265ZcP1ixYtwnbbbYdyOStcaIxdd90VhxxyiNeLBQAuvvhizJkzB/Pnz+/XcVY3Qupt44Tu8+ZqGirV+u8VqYo89fRbZEhSg5mfhD0+NUqhme3cnJafCrEb+ftpV+aGhANOOi0bZcpWWTupuEaiaysmt47dns5I922LGrQccaIDUtvkD8ZMwCp1w1W6SQuXoUTaUVPNu8BYRRN0hA+wE6erWXEb12qSVFRWALq8X5MhremJuTDRJcCm2VLBvSiSu48mStpcUYuZiayrNABTeRYXUqRad6adv7vVdhWVgjLpSSb9lxTcpreaKMXD5HXq5r2bNMuu7F1JzlzDyJLNoy7ukuLud5e2Ae9IxXZ+mfqcKi6oI4napqEyTJj0m/eZKjofVEaAI0rXTuiMEURFXZ8mP0pvZIoj3M+vepaaKOmIrxaFF3KJl/J+7r8GV2o+UKzR1Nst0wafejtj2jozvzUq8nLRW8HXbbfdhvPOOw8/+tGP8KlPfcpb98gjj+Bzn/scZs6cidNOO23A4+p3RKmtrQ2LFy/ukSi9++67A7rRr7zyCv73f/+3bvnJJ5+M2bNn9/s4AQGrAy5BylbJ+B5Ksk8UY6jTGXl/3L1ohLsNGesA823bVMRlBwUp3tYEIBsZAmQEqyqPV0d69GG4TKfpSdV4GGUOZ4TTDYTU3qCEnLB1ub4+RxYigu1n50SbzDlTZkkQr590RVE4bV0ISBmiZmv4k3O0KknC5XMi+SwJDK3NcnbPR/4f2CxJchEzgaqIEHNhSJKrW3LJkWtgWHOWc04gktogxmxvsZQYcrnEOEzHBdtDLopt0YBXGVkQYKrqTdsB8MQhS3pTAng3hxhaQ9KVQ6ndksLFnS3Yom0Z8lGKriSHmojwXnczNm9eLsfuWmNs0Q3xXhHlTQi5D7khu7VW5ybpCKZ2DweMtsh8+LQzeXvV/F6kyh2cxQReSAwpyjfVTKSVR/aekrp/UNYDOm2XCo44SkFkU25EbMONIm3AGEyR12mnnYbf/OY3OOywwzBhwgSMHz8ejDG88soreO2113DMMcesFEkCBkCUDjzwQFx11VV44IEHGq6/+uqrccABB/T7xCNHjsQLL7yA7bbbzlv+wgsvDNocKiBgdSCXs80zATkBCsFkhU3GjLCndJtHfrT+hCtdik5NZfVIgI0U9RAJMlAtLLiahMgRBJP77V7IyTVawaU+Sfkykit5cML6DQ189SVHQFIQ4KpUXVsAGLKTsR7Q60VsyZohSICpegKDFPIkTLbggCPyBRA12chRXkUgdE+vONZRBvl/Ppea1iMaSRqhGEvBbyGW7S3iBqZUeZ6ayFLMBbprOXCQ58atwRihuyYjNdJWwN/Gff4Rl+vjKDXRpmotNmQpLqQQKUNai8DytuqNcrbqTVYXkrm/xAlcrRN5AlsRg9pr6F5RwPDWTmzZ8iEAoEOl3vI8RVOpEx+US/h3V4sXWRre3on3P2gBG14B3pPbi8jqy1zinFvGUd1UPQ+lYQMAXqgnn/oe8Jywn2MmK0b1cwS3kbjslwyu3L25E4F0xekbFUEyv7SD2H8dwmANqO+++24cdthhuPfee/Haa6+BiDB+/HhMnz4dxxxzzEoft99E6fLLL8eee+6JvfbaC+edd57p8PvXv/4Vs2bNwl//+lc888wz/T7xqaeeitNOOw1vvvkm9tlnHzDG8Lvf/Q7XXHMNzj///IFfSUDAKoScwITROGjwODXuy4IkyfG8k/r5h8clQjJFRDZa4k6ubvSpN5LkiLJ5RR7PTZ8ZLyFNXiJCbkkstxFyP2neWH/whpeUmcOYsH5GgEPKEgaur4s7ESU1uael1DqKmwo/SD+e7li27FBCbXRGYClDboSMjuj0VJyXJEhHHNy0ixDcRHAYI4DLZ5ttn1FNfZ2O2wPMHIsY8jxFa76C97qsHbW2kwBkRZurT4q41Ta5nkucC2kJ4NgKZM/HGYHHhKQ7J59bUwKmvKEoTyCQaXar9UBUEEBVeTxVGZIhCVDjaBomq4UWdQzB8GJXneZqaLEb5TRGR5LHuPaleHvFEDke7Rs2JEGCGPFybtzWWQLbCJcA3hEhbVWieiEdzwGbIktr3NO9GfNVAKUmKy7XXzo4J1NlKp+rvFDZL87es6ZidaM1jSTqOe3f3/03NBxzzDGDIkWN0G+itMMOO+BXv/oVvvSlL+HYY48FYzo9QJgwYQIef/zxAQmlLrvsMrS2tuKGG27AJZdcAkBal0+bNg1nnXXWAC8jIGDVYbfHvg79q6Fdl4FMCgR+93gdXaqru89ApuiclJuGSqd5FXDCmQQ1Gv1hUxOIbnSqv/XriBAVhUqlKXKQEXlrp2xWA1hVN1iFieIwpYsh5fhs0ipVbiZqr/2JJkk5ASSR9MBxzqm1M6yQAjUOytn+XvoPNwOAkhONSDlQFMi3VQyRjGJhBb4E02FeC+6NV49DditJjDgSSFMp5HZF3Bpu1Zt+vsXIjmV5tYBSroqaiJCkEZoLVZSVRYD2S+Kc6lK2GjqS5DaHJZLEvKVUwYpOqTlx03cQDKhwGVHL2WeNmKx2SxHKtC01z8ytEluyohmbDVmGjloe+Siti54VowRllVLcqvVDvNPRjs1HL8U/3hxptknaBOIVskWKm17VrW34BxGSEYmMgAmGXCExvzfuWKJYQKSyKEL3cUuclB/nZLyVXFG+Jki6yi3issDixf/+ZsN7HbBxYPny5QOS/qxYscK4d/cHfTjV+dhrr73w8ssv47nnnsN9992H++67D/Pnz8df//pX7LPPPgM5FBhjOPfcc/HOO+9g2bJlWLZsGd555x2cffbZhoQNFDNmzABjDOecc45ZRkSYNm0aNttsM5RKJRxwwAF4+eWXV+r4ARsXklQKdHX3cgCmy7hwWjDo8nPej4iSrpCzZpMqdC6YVxFk9EjkvCfUh9rdNFlOEiKnx6iM4CRMRY6YR7SS9lTqPSqyLYYoqDLzhFlSBBn9oZxK4RVTGd3QxMeJQFFe7g/B7PpSCrQkoCE1iOYUojkFi4VxUmZKqE0EsHxqGgjLHmQyD8hzQpaH632UH1KkKxO1trugjRVlp3jOyHzj5tz2F0tSjohJA0ltIgkA5TRGPpI6If3S2iQXbfmKEXHHUYpqGoEz8kwlXTsAfSzmHE+bVsaOBidJOborOcRx6kWZomIi71lzAqadr/MCrMakLoiTaWsCgky/xgRqtgSwe1kRm7atQCq4IY0J8brIEgAsrxXQleQwrNiFFWXb7oGXOXiZy4a5SvIUdTPEXQy8xpC0p/IzBYCqEfKlGhgncz1RJBDnUsS5FKVCFc1NFTSVqnVfQKqVGNVKrCK06rKE/T1zG96mgm/cJIlWwWsDwNChQ7F48eJ+b7/55pvjzTff7Pf2K9Xrbdddd8Wuu+66Mrs2xECYXU949tlncdttt9WVDF577bWYOXMmfvCDH2D77bfHFVdcgYMPPhh/+9vfVsl5AzZMFPOJ0Zdoo0DGCJHjywJYTbUWl0ZxairhsiCdHvGiR+SXTDtRJTNXZvVKgCRLanLUuiI3auNNnKr8XkeCWFeEqFtFIVT0h5FMnZHeBypKFKm/pswej+dTiCqX588JoIB6IXuFA90RWJskL7QiJzldU2KvJ5XXwGJhog2e07LTjgKQUQhSmjAXWYdtI6hWzyHfwJ25ksRIBUdTvorl5SJGNEttjptmdQlEXkWdOhLfKKq7ljOkppivIUm5FR+rQ6UqWqR/jtTnqFzz//ymQgrQOSOkKfeuM4oEqisKYPkULJ9ClCNQKQXvdqrIKtxWDqqoHaXMaLkMURRcaqC4QDmN0ZKrmmt1o0y6Kq5ts+VY/k4bktYUUadV4cddQGWkOo/z+CPlfp7UIpl2Y+RdS84p52eMnB548t7F+RS1bntvSDDTQsi4n6ccrx71DWz02MA0SisLIsIdd9yBlpaWvjcGUKvV+t7IQb+J0nnnndev7WbOnNmv7f7973/jggsuwBNPPIHFixcj61IwkF5vHR0dOP7443H77bfjiiuskI+IMHv2bFx66aU46qijAAB33XUXNt10U9x77704/fTT+32OgI0Duzx6GQDmRQc4V+m3jF5Jg0FNqor3ZMmS+9H2nLh1lAeQ2ovU/uzpkbTXUfZvmlBEwwlkeRojE21ikiQRM+XlaUmlwxyHcd7NwFLpdM0SZiwGdL8w1w2ZN9esv41DcrSDNBVk1IhSJl2V8wK8kMpr5FRnHOjdz7wwXeeZE82R1WMMqWr7oZfZ+yyjdDpdqnVA7jpATraVag5RJFuQDGnqxvJKEcOKXaimkVcVp6NBAsxYBgA2TZRzxqftADQZI4cgaUQOWTHXq5bFUYqIy8hUIZ+YlK8m5tp0UWjSWRCyr11HbKrR/n/2vjRcjqrceu29a+ruM+VkJoQkJEzBhEEUUARBBHEAh6t4cQDE66wIIoJcEJAACjJdvwsI4sURL6NeBwZlUBCUIQgCIgFCAiRkPGN3dVXtvb8fe6hd3Z3knJMAIfR6nn7SXV1VXVXnpGud913vWtKJDzGVSl71sNX0NYgz3/7+Rl6KTFDVbss8lL0UAgQB47aNKCTB+MowhuohJs5cg5XP9YJ3CETLmTWa9AYosg4JMKmIGgX4qgjR1GG7D65NON1zdXVGbvYbIRI8o2ABB0+YJZ1J1cf4CYMYqoWQAJ5sk6Q2HGyzzTa44oorRrz+lClTRhW5NmKitHDhwsLru+++G2984xtRKpXsstG0zI466igsWbIEp556KqZOnTrmdhug8mHe85734MADDywQpWeffRbLly/HQQcdZJeFYYj99tsPf/nLX1oSpXq9jnq9bl8PDAyM+bjaeO3CJTf2RmUiGZzMqELbwhRdWlkBGO0NyTPejGElCCCNKLeVkLuFt5I7Pm+0ItKTuRmleb+VONuXqmXjSVuBCPq0H1AowYaprU5lU5XIlvq88PnW9VrvPwhTxNUANOTwo/xmnSUM8EXBPFEmDJI7N34j2GVKc2SnmfR1NmJgo0MiWv8TeNy2QfMD059DclFwknq20mQIsAmFFSCIMw8TysNNxoumLWVE3IBysV5dKyuioS+8G3priA5QrJxIXcEBVFUJUL5K5tiZQ7gCP0M1Dux2je0x2pnmImujT2JQZLjO8sBYqUbvQYBly8dh1tYrkPCcBAGqatQVqO87ColMUgSMI6DcVpQ6wjrW1sromd6Pvue61boZEE8p/jHLqvoXcVoNacoQhqn9HReSIPQV+cs4tVNqmaPT85hAmrIGEbdEV4/yf3ql/ZBeCyi02se4/auNcePGjfj+v2bNmpbLFy9evAmPqBkjJkp33HFH4XVnZyd+/vOfY9tttx3TB999993485//vEFb8g3hmmuuwUMPPYT777+/6b3ly5cDACZPnlxYPnnyZDz33HMt93fOOefgjDPO2KhjauO1i7ju5/oSt53QoFMxVQPTJmkEZcJOZTWN+ruibUOSCHKS06RVQm4dAChloSRNBo3QWhWSUrUPI7o263GS+/AQ5J43DlidIO0UQCCB3gQEaqqMZ8q+wORqpdpJWWTEZnlF5byFY8wcV8VOe1tqYlXKctG2e6qcNrfbHDLhmnN6evpQVZD09i32CeTJ8ZQKBH6G0OP5iDokQj/DcBqgO9DkyakcmlaUalVxQFKML1UxkITwwTGUhIXPMiJt5lS6bLvINcWkzddeSljLgXKUoBoHqjqWMaX1Cbi97pZYA6r9aXRuLhzNXKCnygKWYTgJkXKGsp9PmiWCIaBK4B1zDwHlmFQaxnMD4wAojykjLo8ncbAqBRtS7ttZpyaAZQFao8CLJWCKupautxSgyBDRtgluzp6tKrnyOyZRqdQhBMWjh7a/k1tiY3VGmwFRcn0TV69ejbPOOgsHH3ww9t57bwDAvffei1tuuWW9gbcvN8akUdoUmD59elO7bbRYunQpjj322A2G8TayVePs2Qonn3xyoc04MDCwTpPNNrZM2Ak2iabYBBcmR4rQFr5HUJoantJCanlxPQlos0orfm5lAWCek/y1NDdH85Zpf2kfJWghLHHXYxKosrw9xwloVwIx7COZmGuHggl58CSjAlmmtCam3ZVlDF6Ykw0pCZLEs5WftOZhVdW31SZz7CbdnWcMhKgqVFL3wQIO5lRfbCvQqeAJXYUzPw8hiSWvUubj4271hekcsIxTS5ZCz2hdAJ+Z4Ny8LZdw1uTO7SKgGYSk6A1rWFHTwbFe3iZjDJYkCUksOTL7KgWKCMbaa8l32nxJxkCRE7/OUh1cEgwMlSAFgZQA83lhWjJvtar4F0gCVD2QDq0Nc3RrL6zpQW9ntaW/E6DIkrnm1cxXrbfSMPrqqmuQCorxs9Zi1Qs9yAKOaJkHHkl4gxR8qqpKCZ1NQwHEtQBhlLtvN0JKde2qSaAnEfMr7gXKQ6oW+1j0kf9s2raNLQdHHnmkff6hD30IZ555Jr70pS/ZZV/5ylfw/e9/H3/4wx9w3HHHvRqHOLqpt02Jiy66CCeddNJGlcwefPBBrFixAm984xvheR48z8Ndd92FSy65BJ7n2UqSqSwZrFixoqnKZBCGIbq6ugqPNl4/8D1emFgyMFNujY7dxJm6MjCTVkpjg9YkyeiTtDbJTqUB6/4rT+iH2Y2puxOpiFZG1EtfiaNpwPP1YqoeTNqHuZnSSgpSzkA6UoQTqyBEIgpSRPqm7nlced7o8/V1RATVbTLmCQSB8g/KEgbCJPxSBuZzhKUUXsDhBYqoMCYQhCl83XoxzymV+YPIQtvK6L+kJOqaolB4gO9xeHpazVx/e5kLmqX8fdogyjeZZwFT7bxWJMmAOoLnyEsRsgyVIEHoZwj9TBtIquM3wm1CcpIEAIGXIfAyLWbWppgeR+Bx+Npl2pxHV0cNvp8hCDJ42pTR70jUz9mYNkooghxxIBCqvak1bCBAUg3Q01GDkAQJZ+CSYjAJkUmK1XE512LpapqZ+AsYx6TyEAZqEeLER5z46Jg4DJIQ1MdzEE7AYoLg2Qgydab+1oTo6IjhOxN8Zoo04yz3RQJQDhJble0o1eF7HL7Hsegj/9kmSRuCEXNvzGMzwi233IJ3vetdTcsPPvhg/OEPf3gVjkjhVasoHX744ahWq5g9ezbK5XKTsGpdvUgX73jHO/Doo48Wlh199NHYcccd8Y1vfAPbbrstpkyZgttuu81O6SVJgrvuugvf+c53Nt3JtLFlguQaERfWFwa51oPoqkdhHaNHaqw4Oa09K27OiDNZto4vLzMxD4BkFNKMy5v9Oa006nGrhRKxpwwldSvOiLIlVyaNXqhe+35ebTHwPY5Yj9CbNgohauQ7cwTrXCgzQc/nKEWqpWO3Y8ISn1xro1pe5rW5dq6I3jieU6Km8Yjj+KyOR1duBLWEyFxYlywZPYyQBKlg8CkHF8TmvrmTXkNpgK6g3iTeBoDMqbgAwFaVAVttSQSDD45MUGsdEHiZXZ8RAa41TRS5XUDhXJ33/YCjzj0rEC+FKbpC1c56YU2POu4wQ1bzQTxp7RZkRi05giSgHodomML0qEA9Y/CYchGvBAlWx2WMC2uF9Yx31LKqap9Sd3rN/YPBB4J+wPuXj+pWwjqDZw0tafWHBgoCd1tZ8zgqYYKEM4R+9vpy194YbAGtNxfjx4/HjTfeiK9//euF5TfddBPGjx//Kh3VKIiSm9oLqPbVP//5TwwNDRWWN47nrwubIs+ts7MTb3jDGwrLKpUKxo8fb5d/9atfxdlnn43tttsO2223Hc4++2yUy2UcccQRG/35bbwyOOfxdwMATp77u1fk88Igs5qJvL3jkKDGDQhsNlVhvYYKkYoq0YTI3ETMFJxj2AgqC2RKrYfia+RkSVKp/IdQbBUSKsGrOk5DC6dZkLduCNPCaEEQhqZFAnsehsS4VTba2IqUua+NufGnWT6tJJEH0RrS6Y6K2/Yak4Ubq13ucaQZAwEKU2yUCnBBGkbNFeHyWO6M7TVMsBltECXSRpgAKt+sWxMRk+fWeCyZpE0xJz1hDdUssLlpgMqOM+df1La5WXCs8D4jwpIpgfzauxN4Roitzl9bCESqKsVNNcclX4FQ/kMeB2ESq/sr6O7MyVCm274DcYSeKF/e4as22pp62S4bV6naDLghx1sp7RTwByiSLhWZAqh/ZXeK6kCEUqduyZnz0T+vNMtJp9GzcaGE5PcdfA7aGCG2MKJ0xhln4JhjjsGdd95pNUr33Xcfbr75Zlx55ZWv2nGNmCjtuuuuNrnXwCT0ri/Rd11w+5Lrw7nnnovPfe5z6OnpGemhFnDiiSeiVqvhC1/4AtauXYs999wTt956a9tD6TWCq/61D4BXrv1ZTz1LepgnbCvC1RmZSpKpYggTiivNVFueeG4MJkmhuqRaYDLT1STXjduASjvN5vojQaCQhUYEAbXBsCh88RmSREJ14zaJ7MrzKU+n94Ks0IYK9YSYa6LoehGZG6zJvjNVJilz4mJuhOa1qSI0RoK4sR6ESJTC1OpnDCny9XSbMY40CExlzDlnm7+nq1+q2iSs+7Y7ll8OcjFz6GVWxAwURdzWfb1FhQlQHkuJee4QG7Mvd8KM6LYWowJdQR2r47I+h+JnCJBCFErIMkuuJnYPYVhP2qUZQ73uWe2SmhrU5F7o1q9Q1UPXksH1ejI/m/56hPGlKmLuYygN7M+m4ieopT5ClqGaqs/tnD6A4WfUBFzWoclnQlQ1SQJYEYBsU7WfZwghF0SH2Kr/W+UgQZIx3H/I2WijjaOOOgo77bQTLrnkEtxwww2QUmLu3Lm45557sOeee454P3/+859x+eWX4+mnn8Z1112HadOm4Sc/+QlmzZqFffbZZ9THNWKitDGpvhuDs88+Gx/5yEdGTJTuvPPOwmtCCE4//XScfvrpm/zY2tgyYcbTDQEQkhQMsA2kJHZk3VRcpPXtKe5TGp2NE3NCPGl9jQAUfZWMPxLVY28EhUBYG2/iCYiEgZUy680k9GQUMXokScCccFLTFjTVoZbeUJokGS2SS6TM+RGSC6aBotmj73G7f0NSuJN5YQhF7j2Ut/ZaRXyYLd2KkpRqP2Yf+dSbtD5H5txMy40RYasaQO5OXct8O/XW6KOUPxfIBIOQxFoDGDIUsRQRS1HVhpSmbRWxFKtiJfoueyk69KQZJQIx9zE+qtpKlCFUKWfwiMCgnqgz1Z7Qy7CqWikcY8C4nRpjnsjPN2UgVHlRmd87mRH0D5aaqoehl2E4CdBbrqrWo19Hl19HJqk9tjjLg34jP0Wc+qhs24/hxfkfMbzX8XBKKDx9HBN7VNdhoJYP3GScorusrvff3tUmSWPGFlZRAoA999wTP/vZz8a8/fXXX49PfOIT+NjHPoaFCxdau5/BwUGcffbZ+N3vRt+ZGDFR2thU37FiYyfj2njtY7I3ANYi1X1TY+ZPzgXg28qLyZNyPXkMTIUIQBNJagVTcbF6JSIh6yzvpBWE3jK3BYCacCNUv3RCbc2XnNt24zVPC7z1ai5BEjSvcDFdefGE/gs/nwAzBIk0iKozh9Q0VoICn9uKmqlQFNtGOXExk2f1zGvS6uTmi0VyZsf5dfwHoITSjWTJ3PxNEC4A63KdarF2yhkqQe6VBqjx90xSW0lyn7vwKEcmFJEx16Ds1RFzXz9P0OmpfYc0w0AWYUI0jB6/as8fAJbHXYiYIiwumRLOZF7oaJw8IpAIhgnlYaytmSpUflxhC0dyQE2PGZj2XL3u2/aniX0BgDXVMiZVhlDNfEwqDaIvKaPspXiuf5w9NkAR38hPsaa/A2RSHXJlqCJu6iq3DwD8cYoElUsJhutBoSVtWm1Sol1J2lhsrCB7MxNzA8DTTz+NH/3oR3jmmWdw0UUXYdKkSbj55psxffr0EeXJnnXWWbjsssvwyU9+Etdcc41d/pa3vAVnnjm2uJtNNvV2ww03jFif1EYbo8ErQZK2vy5PHs/qHnyf29YNkPv5SKkE0BsiSaShDaaWOaJuo2kialpJ+iJ/eDnRIYKA+LoyZCpAPgf1eT71BFUx4LGnik+eAGECVAeTmmkyAIpwaR8mqkkbbSAqgZ/B9zhKYVrIIjPTXK7uh1FpW2CqKqQIYSVI4DMOLqglPIRIlPzUTpx5VDT9bM2UmNUzWUdnIPQ4Qo+DEWkrKYSoShWj+Vh9I0z1CdDj/74zfca4nXQzZCvhDJmgiLlXyPYzrTaPckQsRUCzAtmZFA5iUjiIEkvQGyhn6i4vxuzySoz3hzHeH8Y4TxGmKdEAxgVVjAuqiFiKrSt9ttqUCYresIresGqrO4CqXkUsw9SOAXQ7mqLQyxB6GSI/tVU4T08immlA+zOWBCKjSOuejX6pZx4qQYJKkKDDT+xx9ARVrKxV1FSaQ+SrSYBqEiAqJYqYA8rFnSlHeROZAgDVWoAk9ZBmDFGQ2nbn/Yec3SZJbTThrrvuwrx58/DXv/4V119/vdVAP/LII/jWt741on08+eST2HfffZuWd3V1oa+vb0zHNSqidMUVV+DDH/4wjjjiCPz1r38FANx+++3Ybbfd8PGPf9yKr9poY1Pgyn+9DYC6ER653V9e9s8LSimiSoKokhS8dTindvrKkB+TUK+qNM3/jaRTEVKvia0oWXG3cZzW5nuEKNNJV7MktZaJUEV+WMgV2XH1JiY6REJpm5w2n+fGjjBhH0STB6NnEUKRDUYlhBbVupocE8dhHoZMuRUnczMu+anKLXO2Z0TC15ob44EUOH5F5mHG4hnJw2gZFeiKYkR+Cp+Z8fncqsGjuSmlW/mjVBTad1IW24BmO1eHVHViPjwqrAGkgSFLpmUHAEJShDRDXXjwqVAPwtHjVzExGNTnr0ihT3MSwSDBINHBEgjdyusK6ti60m/NHw3KXoqIZQgoR2+oSFhPqYZSkKIUpNZaAADCIEVnKUYlzDVYAKyVBPUEAm3sKSVB5CvtUcUxoKxmIYbSCFPLg6jpyTQp82pVmjKkukIlO7gyLzUWBVDWGGGYIQwzdJVjdJVzJ/Q2Qdp0cB1CxvrYnHDSSSfhrLPOwm233YYgyB3v999/f9x7770j2sfUqVOxaNGipuV33333mA2yR9x6O//88/HNb34T8+fPxxNPPIFf/epXOOWUU3DBBRfgy1/+Mr74xS9iwoQJYzqINl5/+O8n9wcAfGGHO9a7ngBBIl9+FwvOKXxbGXF0KY6gdsStNu2bIx3CU6gmAYrQJLpd5OVVocJtWRA1+h9yyIzqChFAPVXloZ4A19lqbqSJccr23PNx9eAmTsQZyjM32cbAWUC1sXxaXK50OlqA7Fyv0FMj/5GXQkqCsp9YfYs9FmebQsuIFyfBuKBgWhMDaEJFeWF/lEhUtQ2BS2x9jwPrqDDVEh+hn6GW+ZYcUCItsTNTbyY81uiNDGlyRdyAIl+ZZAhohir3ETpkKJUMNaG+8KcEfUglw6RgAGvTCnzH+2kgi9Dlx9ajaWIwhGVxNwKaYVqpT32udKwTiMTapAygjjVxSflTMW6JIADUuYfucoyQZUrvVMotG6xdgyCIUw8TO4YQc095JxkRuj7fmd1r8dTqCU3ZcwX4EiTgkHUGXvPgdySo1z10VPIWJyOyrUfa1NjCNEqPPvoofv7znzctnzhxIlavXj2ifXz2s5/Fsccei6uuugqEELz44ou49957ccIJJ+C008aWETjiO9APf/hDXHbZZfjUpz6FO++8EwcccABuv/12LFq0aMwTaW28PvHzRXsCUDqLzz34CVz2xp80raOI1Ctj8zX3ptMB+EhThihKcyJkqkDIyZGtWDhTQ4WWj77x2dBbw18cLYCyCaC5WSByEuZms1l9nlDCb5Ex64FkNE8s5KrlpuGZSkHjzcydDHNDbDlFEGQ2iwsotjopJDpCdbMzYuyUMzUt57S01DGpm6iJxiBEIhUMHsvH5e1N1kzJUUVo6txriolhVNh9me0Gk9CSNkOQ8utFEPiZrVq5sJoqPeKf1hkqQYKhJETAMkReVvBOMtNxlEjbgnP341GBgTRCh1dHnXuoeHV1DTVJGuIhuj3VHhvnDdvj8In6+U0KBtCflZFq8lNieTUnkwxr0gp26VqKFUkXhCSYFKjMyeVJj11vXFDFyrhD+T5JgkQwS1QB5fpd9lL01yN0BnWVmxbGSLhnp+YoVe3QahpgSmXQ7sdUrZ7qn2g/z2MCSeqBAEgTpoTingDVRF+kTGfLSWR1D1FFnVPCGR5+T97abqONdaGnpwfLli3DrFmzCssXLlyIadOmjWgfJ554Ivr7+7H//vsjjmPsu+++CMMQJ5xwQsHxezQY8Z3oueeew4EHHggAePvb3w7f97FgwYKXnSS97W1vKwTvtrFloIdV8af+7Ue0buNNb1Ni25+fjagMOwkE5B419vMbSJJ0cqoATZZcfyFJrF1AYVyOOITI5HAR5LldTjaXqUrBabHZ+A5OwTxhk9ZpwPPgWEDFplAVFWIcsM2xF4TTNHetLoUphCQo+amtHHRFceFaUcLV9JjWKHFBC9fBVH4ECNKsSHzcsXg3u82MvFMi4VNlsgiocXjzGQZmND0VtCBYVp+t15e5NQCQ/+4YewEDjwnEmWqVgQFx5imtklOG8ogoTLgZ5+rAqdoYDGchKl7uGVRiKWLho9ur2rZaXfjoZkqjFEv1XpWHWJ1WENLMEsAOll93Q5DM9gYmGqU3HEYmGPqSUuG4uvQE31AaojuMEevraghgJUgQ6GvcE+afR4lExFLE3LfHDeQtN0Ik6jU9AceEDUCu90f576okYAFHmnj45wfH9hd8G69PHHHEEfjGN76Ba6+9FoQQCCFwzz334IQTTsAnP/nJDW7POcfdd9+Nr33tazjllFPw+OOPQwiBuXPnoqOjY8zHNWKNUhzHhTy1IAgwceLE9Wyxfjz00EMFV+1f/epXeP/7349vfvObSJL8r6vf/e53mDp16pg/p43NDwyiEBDaCl/Y4Y6CduT7/zzgZTueuJr3wo1GRpkbksKDEFmoJBVCWM30iXlfQFsH6HVM9hpRJo+EKu2RJUnmcjii24JdgDk+PalmwDxhTSPNw3x+GCX2PApZW+Y49LJAT4hFnmqDdUWxJUlGCGxE2RT5NBqjwr5f9hNQSJS8FCVt4tjYommMBjHxHeYhQGwkCKAIlwDBQD3CQF199zDH28nA1UkZoXfoZVoTVIwDMRork2IPALU0AJcUtcxHJqh9JIIhMXYAgiLhLPc50saTMfftcQJAXXjo8mJbOerPyuCSghIBSgRS6SGVHhgkIqKu03h/GF1ejBJNQJH/bId4hDJNUKaJ3d84bxgUAhODIXR5Mbo89XPqCWpWmN4T5ELvgHIElKPLr6Osfy6RlyLylKh+QpR7HQHA+HAYFS+x7cVplQFISdDbUUWSeEiS/G/rSkcdgcdRH9L/fzhB74RB9E4YxNMf/Sae/ug30cbLC4KN1Ci92ifQgAULFmCbbbbBtGnTMDQ0hLlz52LffffFW97yFvznf244zoYxhoMPPhj9/f0ol8vYY4898OY3v3mjSBIwyt7GlVdeaT8wyzL8z//8T5Mu6Stf+cqI9vXZz34WJ510EubNm4dnnnkGH/3oR/GBD3wA1157LarV6iZx7m5j88MvF73JPn9r11P4xHb3rXPdL+14+8tKkOb871mgXrF1ZmIx0oxZ80Ibkqthq0VoJji2YkQckkQUcXGrTiJlBUE2hCJZdnzftODcypUgVoRbPB6Vt5ZpcW2p4qTC6xubigMhuTmkIFaTJSRBFKRIBUWnMzZvtDmxbou5xMdUVwiR1t3ahWrxmCmyosu5R4St0rhtPmvoSaTdxq0mmmqIG4HhUUW6uSS2IpNP2aFAyE1r0NVU1VIPHhNIk8BaB4Qss5Uvs665FuY43FZdwj1ELLXrrk4rlsBEVDt/Cw/deuKtQtU1joWPXm8IgyKCD12ZER6qPMA2YbMeo4PFWJV22vZeSDOkkqGkJ+9KLLVVrb60hJj78Giug0rSEB1+UnD9FiCYWuq3n7F0eJx93htWsSquoCesYdGq/Ht+0vhB+3z5Sz0AJMAEOntqSDOGRw89o+nY22hjJPB9Hz/72c9w5plnYuHChRBCYLfddsN222034n0YTtHYvtsYEDlCo6KZM2eCrGv+1uyMEDzzzDMj+uDu7m489NBDmD17Nr7zne/g9ttvxy233IJ77rkHH/3oR7F06dIR7eflxsDAALq7u9Hf398OyN1IuCQJAA6fc/8Gt3GJUio9HLfTrZvkWGb/coGtqJhfa88rtlRsi8ip1ACO3kg2Vnv0E4cgFfZnxN1Wl0SLYkq7fvNC44fkiq2tm3OLSBAXyhCzWN0xVRjzrxk3t4aRur1mJs/M5FMjDPmhROZEhja7cHNBbdXFbb0BKAiQXRjRNhd5i85dN/C4FYDnE2ikcFyGrJnqUaazxNxljcTL6KLMPlySBCjPJSB376ZE2OeGqABAj1+zRKmb1ey6hii5Qwp14SPWrzupIlmdrNj6fD7pVddFt+B8wlHVQvHJft6iG+QRnq0Vc7GG0si6hwO5EH1cUIWnny+rdavjDhShM623f6yeos4tSKy2afVK9V04ZXKf+kwda/LYYafj9Y5X4p5hPmPGuQtAnU7PaCHiGM+ddMoWdX+79dZb8Y1vfAPf/va38cY3vhGVSqXw/ljOc8QVpcWLF4965+uDlBJCqC+XP/zhDzYOZfr06Vi1atUm/aw2Xn385Km9EOj75kgIksGXdrwdFz5xkH294LH34pSdf7NRxzL7mrMbRveVwJkLWsh2I8hvvG5VycaZuK24FlZPrtBbuDEl7kQcUVlc9i1dZeKJHvfX4iZe9+CX0oJtgXHNNtSokSQZAtDocm2WU6qqQkasbfZpjCLrmWeJiEGj4LrweVSgzj1lpdBinIZC2kqSRwRA0DR+byBAEHgZkkx9RfmUo555qrVlDQsJfO2BBOTER4DAHLUxozR+UIxmtlLkMVFsSWpU0wCdWrdj2lWueaY9fsBOqWWSIqAcNR5Yc0lAkZpOFqMqAoQ0BQUwLEJEJAWDsC21iKUIpY8hHqEqQviEY03WgQneAIRWSGwdrMGz9YmqpUg4uKQo0wSzwhXquIUiK4M8wqzSaqzN1MDEmkS7eTsks9tpz2WCoT9VGqdOP7ZVuKcHFNkyVUYB5Y/1wspxYAHH9IlrLJltE6RXCVvY1Nvxxx/fcjkhBFEUYc6cOTjssMPQ29u7zn28613vAgAceuihheLOaGPWXLwyY0UtsMcee+Css87CgQceiLvuuguXXnopABWVMnny5FfrsNp4GfCTp/YCACSS2S/90eC4nW7Fgsfea1+f8sgHsWD+DWM6lpk/ORdMF0ekLOp9TFyJgZ1cM/prJp3R+jzTrUCSGqpJjVlvRV4gQZg2V3SEsJQJcLOvTLeRfI6szuDp3Da3skSAAnkC8hZiI7pKuu2jCYghAKlghfT4TFKU/BSDSWhJgXGMtus4VSpDPkKn+lLL/IIXkACxLTvX+dolS7FTucorO1I7fiuX54FaZMXbZp1qGoAQVUFiVCDheTCvbe8RqT7L0b5BFhPtuRa017mHzkDFeLgVpVZu3QaJYNaVG1BaPACo8gDjfDVF5hNulxuS5J5/B4vtsZmKEoXAGq4kD2WqzjeVDIwI7BS9AADo4/lfzWVWt/8ujdUNpezl7VjqnENNO4oHNLOVJUYkllW70B3EyCRFXf+uUEgsWaH2N2vKKnBBEXkp7nzH+eu8Jm28zNjCiNLChQvx0EMPgXOOHXbYAVJKPPXUU2CMYccdd8R///d/42tf+xruvvtuzJ07t+U+7rhj/ZYzY8GrRpQuuugifOxjH8NNN92EU045BXPmzAEAXHfddXjLW97yah1WG5sY1z79RgA6y2ojjOBP2fk3OOWRD9rXxz38UVy46zXr2aIZM3/8HWcKjYAZM0ZnhL8wxu8YTBpQKsEdMbFLkmz2G1XGiU2j//qzzGszVu3pCBLTEorrPvwoQ1ZngJ+bK5oJI9JAgvLYDzd41Jm8AxDp6Tc3SsQQiCTzUPYTDCYhxukW3Jpq2e47kxQlL13v9KER3suGdVpFgZjPllrcbaoSqSZekUPIIk+NrkMTsbLWUrn7B4DAy1BPPX3+RR0Sl9Q6S3tMCcfd8Fkj7O6MFMEwYvRM0EKwLdXXwp18E5JagkEhUdM+SiWWIJXM6omMcBsAOKhtv7n5d2YZkLfXzP+ZHlbFi2kPmD5un3CHJJXhkwxVEYCDwiccazNFnEKaYXI4gBpXLbOayIlRIjyELLMVpIG0ZM/VEOgsowi9DItXK4I0b/qLAIChNACjAn/c/wK00camgqkW/ehHP7ItsoGBARxzzDHYZ5998B//8R844ogjcNxxx+GWW25puY/99ttvkx/Xq0aU5s+fX5h6MzjvvPPAGGuxRRuvVUQ01ZM+HEfM+euY9/OvocnYurx2o4+HpxRemEHwfMxfNEyXUe1w3bgcgPIA4sXlroi7kRg1bU4l/JK6gRqNUGdUx3Bd3cx8TZh8P0NtOFSZa2GxmmPcrQ0Cq7thNmDWjO9HQW7YaLdHPr3nMWF9jFbWKoWqkJQEAcuQNZCPQiyGfm1G+7mg8LWztCFxhhQVrgORGKqHheNxjS3N+XWGMfriUlGwrZ9nTmuQy+IxWmuAxqk//XmG1JV81Y4zhDHlDCUn5iThzJK3hDN4VOWuGbLkEkFDjGo8QJdXU61NL9caCUlQponyc9JicHNduKSWvDIikEpWuGaTvQHE0kcnVWTWtNoCwrGoPhndrAoGgTVZR9O1NmSuk6pWZaoNMhPhgRGJwTTXubjmm8/39diW5tzJLwEAbnzr/0Mbmwc21l17c3PmPu+883DbbbcVdERdXV04/fTTcdBBB+HYY4/FaaedhoMOOmid+/jTn/603s9oFW+yIbxqRAkA+vr6cN111+Hpp5/G17/+dfT29uLxxx/H5MmTR2wu1cbmC2Us6YFBgEGMSps0EnzuwU9Ywam5Efz37j9tWm/2LxfoZ56qJIWZzWwDkEeKUNhvDiGcUX/zZWL+beBOZj9uRckstzdoZ5uubqVhMRUMKQm4oKiEia2WVGOdQl9O8mkz5ziM8NxzIkgAfZOjRo8jVAVMkxwOUpgyMzfqjFNb2QgYR8gyRF5qBdTmBu6aLgptOOnCEKyqCHQAbZZflwZI3X4L/QxVLRA20SempcMFtRUj857UBClvMWqNUIOWqrH6ZSJYpNt2Qy4OV5oljkzSQpSHW91ys+DKusIWMfWvSy7rwrPRJYa4DYoIEz21zAi81bVtvjapI/IWILbdxiVBLH0MihJ6WBUc1FaeAKCfl+ETjoimdnkHqyt9FMmss7eQBD7hGOaKaK1NyvC0IN1k1y18Kf/+9ZjA9hNWAmiTpM0OW1jrrb+/HytWrGhqq61cuRIDA2pgoaenp2Ah1Ii3v/3tTctcrdJYNEoj6oUcf/zxGB5WPfY//elPyLJsA1tsGI888gi22247fOc738H5559vw+puvPFGnHzyyRu9/zY2H3BQDOu/fjcWz1fHocZ9q61ohNueA4CZPz7XPmdhBurzQqitFKTYcmvwQxJcr9v4haIrR+7DbbUVyBMASEV6onKCJPXQXYrVzdlUELSXUOQpZ+kwyGyYre/xYvVG57G5omymhcmuVsljwpo8EqfVZo5LSgIuKVLtFWSIz3ASopoGBSG3WV9Kgg4/sWTJoMNP0BUor54JpWHtX5QH27peSZlUBKieeqinHhgRttVjMuAEFNELWVb4+bjnSI2oXsMVXLuBupTKQltSSkW8TNWIa0LLBc09nPR+q463kguTCZcIrxjhQjOENMNAVlImkoSDQaJMEwyLsEB6XJIUEI6AcNtqo5AISYqQpIV1O2kNDAKDPCps382q6GZVlJ32nUGZJgVyZlBhdfQnqt2Waa+nRDA75WZ+HrtPeR4dXr1Nktp42XHYYYfhU5/6FG688UY8//zzeOGFF3DjjTfimGOOwfvf/34AwN/+9jdsv/26zYrXrl1beKxYsQI333wz3vSmN+HWW8c2NT2iitJ//dd/4Rvf+AYqlQr2339/LFu2DJMmTRrTBxocf/zxOProo/Hd734XnZ2ddvkhhxyCI444YqP23cbmgZfSbutEDACXP7kfPrvDXWPen0c5Yu7jpbjL/uULAEuHegAA+00qBiHudOMZAELwOrP5Z4BT8eGkILIWPK8AFdpnBIVpM1dnlK/nVqdyJzezjV9SBGhKj/qryNyQU850Vlieo1XyU9RSH77HUXcM/qijTfI9biM7zHYGUhI70WbJQgPTY0TYKhJ1yIcrcjZO24ZglR2/pLKX+wbF3EM1M9oXbTcQxhjSTtqt4kRqOn7EHAMDBxcUnp5iM1WdpIGsGRjhfcgypYNi3JKufB2AMW4rgqlQbUm3SmRE71KqKbtUMFAi7Xk0EkKzDFBkyThgp4Kh4tXBQayHkou69kyqigCdNAbXc3lM78volmLugxFhjScFaMGEUoAWKkY+yVQeHk3xYtqj90Xg08xWW01Mikc4hjP1B8uaVGnQTNWvoiNU/vbSNmBUwPc49t9K/X86f5dfNp1PG5sJtrCK0uWXX47jjjsOH/3oR21BxvM8HHnkkbjwwgsBADvuuCOuvPLKde6ju7u7adk73/lOhGGI4447Dg8++OCoj2tERGnmzJm45JJLcNBBB0FKiXvvvRfjxo1rue5I+3/3338/Lr/88qbl06ZNw/Lly0e0jzY2f/Tzcsu/cseKiKUYSkMMidDenEOWYVJpCM9UJzTFS5Q664iHA0hOQI2Jo550KuiJzGu3JWdgumcsv6kWRvxbjbg7+zN6qN6uKuLUt6PngPIryoQS4BpRs5ncipPWVTNDjoy+iUKCA03GmAAKlgeAM40nFQEyr41vkqspMlojKYt6qExQW70xP4N65qHkp0gEayJlLtlgRCAVysvIJTZcEASa/BkrAFPxCViGRGuobJXLIXKe3mfgcTvNx5wqjzlHt+JkiC/RruKNSITSIhlXbjP5ljni67Knoj7GB8OgujVZYinqwsMEf8iSQBNlMixC9Og/HALC7fQZc4hQD6tigCu9kKkuuUMQa7LcYVjplWKkUpGhThqjn5ed6y4gpPrdqmoxd8Wr44VaDygkKl4dg5n6rGEe4Jn+8Sj5KXbuVd+/fWkJV+7xP03Xpo3NB1uaRqmjowNXXHEFLrzwQjzzzDOQUmL27NkFZ+1dd911TPueOHEinnzyyTFtOyKidN555+Fzn/sczjnnHBBC8IEPfKDleqPxKIiiyPYcXTz55JMbFY3SxuYD4x2zqfCLvX6AQ/50LIC80tAXl+y/bxhfJNicU01U8qoCTx0tiyYzBZ4jnVF+IH+TSBUC6m4L5KaTEk4jO19m9FDdnTVkglpjR7dKQZ22z3ASaLdnPZ2myQ8hshDVYcbj1baKXKh2VV5dKgibQQpCaeUcLpvWczU8vnZuLnkpMkERc8/mgpnjCyhHxDKszDzUUt9OzVEiEXkZBpKwcL5SkgKxSTmzPxtDxoywezgN4FOVL8eosNYBkSO0FiCWPBlTTJcQNfo+mcBcs7xXR3gIEHtOZoLPJYQx92xr0pDxLj+3UxCSostX1yYkeSXOtNoKE23St388BKT5+7KLxRjgESgEIppa0XYqGTpZDX2aDFEo7ZOxGTDmkwzSVpHMv2q5wMqkEyWWYlgTp04vxoMrpgMAZnYXByXaJKmNVwsdHR2YP3/+mLZ95JFHCq+llFi2bBnOPfdc7LLLLmPa54iI0vvf/368//3vx9DQELq6uvDkk09udOvtsMMOw5lnnon//d//BaBI1pIlS3DSSSfhQx/60Ebtu43NC4Miwgk7tR7lHC1+v+/FOORPxyJgHM/39QAAturub1pvu2vPAtFkwIzzk4aQViO+difWADjlaHd6jaCpTm3IjiDqT7MGix3iCYiUorO7hoxT9JRzkmRuukb7YmI7Ao9b92OPcaQZUyaQ2srAbRt5jCPjDIwqsmQqOVSTJumQE1cD5MKNJnE1SYaMmBahR4UVMJvX7rTXxNKwbeMMJKpKsS6XcFM1MiSHELVuknkIzHSZMZoMOHyq2nKm8mOIVM2puJmJN7f1Zqpkrlu3G5gbsAzVzLexHgHjlmy527o+SoZATSrlMR6ppOjxa+CSYJxXtTEkE/whu84gL6HXU68jktq2WCwpyrRuq0ZGd2TIUURTlGm9UEmy59eCZLlVJFfo/WK929lOXaPBLMKLw13oCOvYoXsFVtfVZ/QnJVz7lkub9t3GZghHTznm7Tcz3H///bj22muxZMmSJtH2DTds2D9v1113BSEEjaEje+21F6666qoxHdOopt46Ojpwxx13YNasWfC8jRuYO//88/Hud78bkyZNQq1Ww3777Yfly5dj7733xoIFCza8gzY2a1z5r7cB6EZd+BvtpN0IIUlBu2Jw9Zt/iHfccTzeccfxAHrz8X5dISIAmM8htImj1bwYDuRWmNwvEDvt1rxMZkRNy7nrO7okAIgTH5O61Y2Vy1wwHLEMYEC/JhauzogQNXnnMWErSYYkuaPuHjPaHtl0TQiRLcftW5ElCgmf8sK+A60XElrA7SKgvFAV8/RrlS8mbKRJ2UtRzdQylxRSIiEEQ+SnhRgSZWmQH8NwEtrX5vokWtcFoGW0iZQq3sR8FjOf5wjCzc/AEEhPt84qfmKjPhrbuMYSoXHaD1DTZUBewSmzxFZ4ABVmaxBLP3fkJuq6UginCpR/t67JOrBGm0lO9gZsi60qQtSFb9t3PuEo0wT9XFVY68K31gNrszJ6/Bqeryq5xJq6WmcgVr93b5q8BEISjA+HcNkbf9J0bm1sxtjCNErXXHMNPvnJT+Kggw7CbbfdhoMOOghPPfUUli9fvs5OViOeffbZwmtKKSZOnIhoI6JeRs129ttvP3DOcf311+OJJ54AIQQ77bQTDjvssFH5H3V1deHuu+/G7bffjoceeghCCOy+++448MADR3tIbWymmOz3t/xLeFNhQscQBuoRVlUrGBgqYfvrv43p2tl+mwlr8MwLqoVrhNyCUzBPgPkCaax/9d0vilZ/XJl7YuN8KAFkagTd2lrAQBKQgCONPUyZmFe7XJGyuTELqGWDST4VGHkZUkHBaO4r5Dk3dKOTsVlvRNpKiEsyzLaB1zylalpa+WmSwqi8ASUSEcssYQLyLDeXfFSznBRERmBNhSVJHhEAyzVN5hhMy9FUiYbqIcpBYsXZ5mK7JJAQ2HZcq0gVQlR1zAbaeql1BW91jiZ+xBAhE3ti4BIjs91AWsLEUJFfnwj0pWV0eXkrrsoDlFmRXLoaJUOKIqKeV2gdAckQywCpVFql5ZmqAs2NXrT76ONl+3+Kg4BLhoikqOvqUUQyxNJDSFMMZREGspJdd2I0iIWrtraVua4oxht6lgEALt79F03XsY02XmmcffbZuPDCC/HFL34RnZ2duPjiizFr1ix89rOfxdSpU0e0j7vuuguHH344wrA4aZ0kiSVio8WIQ3ENFi1ahPe85z14/vnnrcX4v/71L0yfPh2//e1vMXv27FEfRBzHCMNwg6G7rwbaobhjw8X/PNB+eZ849/ebdN8H3/VVAMDamtJqrB3ULtI0H4034Bm1hEKktLBeQXOkYVtyAGDE2o2r8ZwgFbY1LbxAvTF+0kBBL9Ol9T1WGGw8kzLfkhbTcgLy9pe5ubvO12Z9N6zW1d6Yzw0bAl3XldVm9ueu39hyMjD7NrEYmTAVIROGq9tK2oDSVGaqmW+XuTDkI+UMA3X1V59poRkCZapJ5tvKDbIFlKC9UZgOFCtNja04M8VnXpuKXTXzbRuzR8e6mHYiAHT4dTt1aQwmQ5rZqlJHw9SbuR5bB2vUuTjGkgCsgaQhUYOiZCfdDKFamanvHjPmvzJTk8IMEj5Rx2CE3P2aHJmq1aLhSfa8VtVUdcoItts6pE2PVzIUd9tvnb3RobjPnPHNzeb+VqlU8Nhjj2HmzJmYMGEC7rjjDsybNw9PPPEEDjjgACxbtmyD+2CMtZzMX716NSZNmvTy+Si5+MpXvoJtt90WS5cuxUMPPYSFCxdiyZIlmDVrFr7yla+MeD9CCHz729/GtGnT0NHRYctlp556Kn74wx+O9rDa2AwR0rSQK7WpcMt+F6E/Lqlqh59iam8/ojBF6GfgGUWWMvCMgmd5q4cnKvuLelIbS+YRIo1Q0SVE/e9w23ISOXlCsYpEuOO1lFBUetTNL+EMXWFsSZJH8haUR/PqkHGyLvsJKkEdlaAORgRKXgqP5j5DROeVMSqQZCrvyzwA44otrIeRWzVqRMA4AqbE2J1+HZ1+LjhWHkEsX8fLCu7UgKoiGZLkOYTE/MwjlqnJMRDbznLJl+vubao2XWEMj6ppvFKQohIkhfYhIUA5SBEwDqbbaubaWBsA3lxtCr3MfhZ1tjGfbVqD5mcjQCxJAoCuILbXAgBi7qPElEWCsQMY4iFSybA2LaaVUx1i+1LaDQoBn2SF6BJzHoOiZImRAMWgKCGWQSHHLRa+CtqlsY0zSaWHWPoIaWpJklrOsDYrY3w4ZNttE0rD2GX8C/AIb5OkLQFyEzw2I/T29mJwUFVqp02bhn/84x8AlDl1tVpd36YWJvy2Ec8//3xL64CRYNStt7vuugv33XdfIb13/PjxOPfcc/HWt751xPs566yzcPXVV+O73/0u/uM//sMunzdvHi688EIcc8wxoz20NjYjMAjEUlU7vv/PA/ClHW/fpPu/7+BzMP//TkM18TGxYwiTOgex+KUJAAA/yJBlxb8BvDDLQ2wdh2vKhDWdVO/lU26WFJn/c87ovRthQowVgF4U9aobbJz4GN8xjFrmFwJnTRvLamEYt8GjJnjW3tSdTLLIyxBnns1JqwR5a8dU0Wrau8glCaZNRSELOijhTJl1+AnizLMtKHMMmaCF1lPkZQh0FSURniV6GaeIWIpEV4xMxSUA0JeUrLYnoBxlL8WQbtW5Ro7GP6rsJ6imAeLUt1W1yMts+zFvyeWVJeO63XjuAsQSQEP0jL+TyaFzxfUmx61Db2ME664twKQwF3KbapFbUaoLD0NZhJBmTmVMGT+uyrow2e9HKmFjTFZmndZvLCJKtzQgSvBJ7oXkE273NciLFQRKlBR8WdKDRjy+VplH+owj5h5md64CgLYWaUvBRtoDbG5E6W1vextuu+02zJs3Dx/5yEdw7LHH4vbbb8dtt92Gd7zjHevddrfddgMhBIQQvOMd7yjoqDnnePbZZ/Gud71rTMc1aqIUhqFlfC6GhoYQBEGLLVrjxz/+MX7wgx/gHe94Bz73uc/Z5fPnz8c///nP0R5WG5sh3CDQlwOPvO9MAMCH//J5PNPfi57uYcSJD84pPE8UvgMEpyBMqH+JQ5Y0Ci03oFA5ahp20+/ZYplutREAQaduR3GKqd3aXNLLEHPPCqIbXZ7NOra6QnINkFmXQgWyGv0MaRAVm/VcPRJz9pMKBgFiiVJZT3r1agKXSWqJmJDEkgpDeCiK2W5CEngssf4844IqatxHwHIiZapNPUFNOXI71a0uv24JC5BXqcwUXtlPbNst8LJCfEopSO15iAZy5DqdGysD460UZ7mLtpAEPdoscigNkHCGTFJ0aYKUcM/Gk5jjiFiKTDAsj7tR9nSbjSWo8QAllmCIh7kuSrfIuKT2uWuVEdEUL6Xqr1vXlDXRQu6IpPYPDdda4LlE/TGwW2kx/hFP1+dCsSarwCccbyg/j0eqavni2nhM6+hHhSUoOXqpi3dr65Ha2Dzx/e9/H3Gs/l+efPLJ8H0fd999Nz74wQ/i1FNPXe+2xrn74YcfxsEHH1zwXgqCADNnzhzzRP2oidJ73/tefOYzn8EPf/hDvPnNbwYA/PWvf8XnPvc5HHrooSPezwsvvIA5c+Y0LRdCIE1f3htsGy8vLnziILyaMYKMCaRp7kNklmUZBaEi1yYZw0ndXlP+SS260ab9RnQYLpGq1QZAehIQBKxUDJLt7agiznzrmxRQRXDc6kXEMltVcskRgIJw2tX1GH8iU2kyafamfeRuCygdzkASwteVHPczXOJjROJuxci8X2Ip6tzTn2PE0OoG3eHVbautxNJCBYw5bbYa9+FRbitOlEg7lt+XRIU2nGlvDTtEygjHhTbCLLbR1OcYIqqm7zz01SPb6musGBmBuiGfQ2kASiQG0tCSpZgbXybHksGZ7psSDdgqEgDURAAhgRIt2hhURYAOluuW+ngZEUnRzaoYFKo6NMhLGO8NFZy4I5ICpKhT6mZV7BotwYCI8IZoKW4ZUF4z7+teCABYnnVjfnkprnx+HwDAYVP+jkeGpqPGA/xgj6vRxhaGLWjqLcsy/N///R8OPvhgAGpa7cQTT8SJJ544ou2/9a1vAVAG2YcffvhGTbk1YtQapUsuuQSzZ8/G3nvvjSiKEEUR3vrWt2LOnDm4+OKLR7yfnXfeGX/+85+bll977bXYbbfdRntYbWzmuOXZubjl2bkbXnGM2LZ7DaQkCP0MGacgVIJQCQlFkhgTCMOG6S/pCL+JcdyWRZuARt9JJpVoW79HeJEkZQlDb4duo3gp6pmHiGWFsfJM3+jNRJkhSQHjhSqRac+ZSI1A65gCypsmsQyRoJBWB2WqTCaDDVDEyrhOA8qBOuYeYl1BibTuJmIpApqhxHI/pRJL4RNhNTUm1wxQ/j+edpumRMAjvJBFZkbVI5YiYBk8ym21qieIm6pVxgLA6K98ym3um1nHp7wg1h5Kg1yYrfVRtjUo1HkPpQGG0gCrYiV8djVjQpthVjPfkhxAVZfM8WeCQeiWHaB0STURoCaCQiYblxRDPMIQj6weqSoCRCRFRFIMisiSpH5eBiMCfbyMRDLE0i8YRb6YjsOL6TikkmGv0jPqZ0pj3DO8PTpYjMPH/dWuO8XrxzUvvRkdfoI39z4HAJjfsbRNkrZUbEEaJc/z8PnPfx71+sYlORx55JGblCQBY/izv6enB7/61a+waNEiPPHEE5BSYu7cuS2rQ+vDt771LXziE5/ACy+8ACEEbrjhBjz55JP48Y9/jN/8ZtP67rSxZePat1yKt//xBHSFMVYOdcBjApznN780KwqalS6J6opS7sRtK0pNxpP5cykIwGTLL5hSWVUSBuMQEzuUuWBnULeVECMGNq8bhczuCL5pu1HIAskBiq071/TRhM26/j9uNSqgKnjVc9pU5hi6tcu0SxAqrG4T5j3SYqzeeBhpctQKXBJFqlheBUul+dlQlL0EmaSYwDIMpbmLt205NhAos4wQ1Yo0U3q8oRJoqlElX1kDmOsdeVlBUG5gqntu+81z9FoCioQGNLOkdFW9Az1+DRnU+L0hjUNchd+GJEUqmTagDNHtqQqSIUvGHykiGdZkHVq7ZCJYEqSSgYNist+PSSyXO0Qkw28Gd4FPOOaELwFQ+qfLV7wdADC3M58MWpb0YMH8DZv0tdHGSPGnP/0J5513Hh588EEsW7YMN954o217AcBRRx2Fq68uEvM999wT99133wb3veeee2LhwoWYMWPGmI+Pc44LL7wQ//u//9vStHLNmjWj3ueY+yNz5swZNTly8b73vQ+//OUvcfbZZ4MQgtNOOw277747/u///g/vfOc7x7zfNjYdlGkk8Ontmyt/60OvN1QQnPZ6w1jNO3HEnL+uZ6uNQyYphuohfI+jVlctEyvQFiQPwnXE2gVBNpUQDYTKttyc54RKSCMUN0aIVQ+V8VVICXSVdNsm8zGuVEUmlelinHlIOMt1SjLXHrmvDcxkVuBYA3hEFIiMW6VKOCsQn7KnctdamUUCjo+TJAhYhmEeoMISmwFmPrPC6k3twA5Wx9qsDI/ylu7QQlKkkiKkue7KTGh5lKMvLenjF4XqTE9QQ8x9VDNf56gV7QXMOZtJPiEJ6tyzTt9AsV1ng3V1VS73fPItGQIUSapmPjyi2peJYJZMuYS28eeTCIZVSSU/Pg+YFChCY40wCbfGk/1ZGZ0sRlWGqIrAkksTZzLIIxt7EsvAjv3P9FfbffxmcBd7DNsEq5BIhruHt8cgj7BNtAbdnqpmHrvjH5qOuY0tD2Qjxdxj2XZ4eBi77LILjj766HVqft71rnfhRz/6kX09Uv3yF77wBXzta1/D888/jze+8Y2oVIoTpCOJNTnjjDNw5ZVX4vjjj8epp56KU045BYsXL8ZNN92E0047bUTH0YhXRUiSZRkWLFiAT33qU7jrrrtejUNoYwO47dmdAEwY8/adLLbGeC+l3S+LTUAjOsI6Vg9W1E0s0X+ZawsAUzFiTCAzeW8OEVJu3doWwJ0sbSBLkhOAFitKNOKoDYeY0DsIrt20gWK1x4ijM0ltG8fAJUnuTdncgA1hKHsJEuHZqpSB0SgVKk1as2SqM63cpE2LDYAV+473h+1N2bTdgFycbAJWx3nVJgJhxOOrkw74RFjC5Ya+VkWgqjCOsLum/bZM28qQJOPqbQifgU85qpoQWQ8mwayWqLECZ66RS/j6kgg9QZwLxh27gJycUqvJatzeGFhmgiHm1Oq6ViSd1i6gpjVOlCh37EnBAGLpoS6UM7eJGunnZUz11wIA1vAODItQC7gDlGmCp5LJWJl1qgocTSyxWqKF3WWaoJPF4CBIJdtkcUFttNEKhxxyCA455JD1rhOGIaZMmTLqfR9++OEAULAaMnEkI82S/dnPfoYrrrgC73nPe3DGGWfg3//93zF79mzMnz8f991336hsjAxeFaLkeR7OO+88HHnkka/Gx7cxQszwV7UM7dwQjtzuL/j+Pw9QfjGjl8GNGm/8/SngOhsrDDIMDqlqltEfEYfY8Exli7lmkVKQwv6sRsm8IChYA7ggFJAJQ9eEIdQzD+MrKqrCreIknLVs9wDFVpdLrMxN2ThcG6IQ0AyZrpCYEXu34uJOrBniZPRKXUGMRHh2v2WmxNRTI+UeHlIlcC7TpGl6C1AxHGuzCsosseJkd7JxWdoDABgfDNkJL1Nx8gnHiqQr3zdzBOtCrdOXllD26qhmodZ1CdWaE8z6AOXmkPnn9oSxJZPUVq4EMt7cvjPXyvw8zDRh43VU+ygaVAoQK/B2f1aJYAhohsE0QiYp1iZljAuq9twNKXwxHpcfs18FIyq2ZKrfh6oIC7qkYREqLROPsCztwThvGJQIe73d/1dVEWCbQI39f2K7Dbc32mijEY0B9WEYNjlbjwZ33nknJk2ahJ6eHuy3335YsGDBiPJhG+NHxoLly5dj3rx5AFTsWn+/+n5773vfu8HJuXXhVRtNOvDAA3HnnXfiqKOOerUOoY31ICKpDeoETIUJeOesJ0a0vWl1MAh0shhHbveXl+U4DRgVGKppPY3PbdVIcKKqSkRZBFAmwK1Dt9pWRZBISF5sqVnFtrknFvLc8ui3oKuOOPHRU6lhOAkxvpznepmbtNvOMXA1N9RpTan3tCmlE3USc79Q1TCTWwaGUCWcWeJgKkk9gZm+y6weCYCtfoTOpJupDJl8sl6m9FaDooRx3rC9WXcytZ+IpHgxHYepfp+tdriIqHp/UjDQ9F5VBKjqEGBTaepgiW3PDWUhPCLQG9YwoDVMpmJknMGrWWAF8+baNIbZrgumMuQ1VDy9hnZfLhJPC9Uwg6EstMTUfG4qWdO6vUH+u2GsA1Zlndg6WKOMMiGsyNv1g1qbVbCTjjJ5MR2HkKYY5w0j0O25NkF6nWITTb1Nnz69sPhb3/oWTj/99DHt8pBDDsGHP/xhzJgxA88++yxOPfVUHHDAAXjwwQc3SL42RptksPXWW2PZsmXYZpttMGfOHNx6663Yfffdcf/994+Z/L1qROmQQw7BySefjH/84x8te5GjsRpo4+UBhYAAxe2Ld8AYBiRBibQeMJc/uR8+u8PL02Z98JAFmPfrb9nXhiRJSUCphOBUheNqECYLVSTqSfC6accVFdwyza0EiCFHboVC+yaN71Q3wLKjQTIViqChMgEUDSWLgmVqJ8eELIq2jRWAO+WWb5c/NyG7E0vD9jMMIpaiLjxMDPJkexdlPe7eSRWBmhGsQp+Oxpjur7brddF83H1ARNjKX2uJtQl6jfRNfAXvxFb+WtuCM4LlRDJURS8mBQMYytQxV6FI04RwCINZpAiIvg5lL7XkyM28K3uJjRjp8OsFQgnk+XLWfoByXQXioJCIuYcEDGUvtQQpcUTwje03YxFgfj5uyzNgHAIEzw31NnlR9fq5X1IqGWrcxwAizKs8r645i/F8oox8Xe3XBG8QZZpgWISWRNWFjzKtg0v6sv2/amPzx6bSKC1durQQYbIx1STTPgOAN7zhDdhjjz0wY8YM/Pa3v8UHP/jBDW7/k5/8BJdddhmeffZZ3HvvvZgxYwYuuugizJo1C4cddtgGt//ABz6AP/7xj9hzzz1x7LHH4t///d/xwx/+EEuWLMFxxx03pnMaE1H685//jMsvvxxPP/00rrvuOkybNg0/+clPMGvWLOyzzz4j2sfnP/95AMAFF1zQ9N5Ie5FtvHx428xFuGvx9k3Lb1+8Aw6Y+eQGt//CDnfg+/884OU4tHUi8DiqtaJoULRomRmSJKXRJqHh2ybPeiM0N6eUUpEsAAg68tZad7mGjFP0lGq2ohOxDJlQvkQCpKliATSGz4qmZULm6xkxt6vXMYTJGDeaSsb4qKq3zz83EwzjQ0WOTBXJJVt14aHMEtSFbzPJpvurkUgPPaxqCW+FOC1F3SrqoTkBMGSJOrokd2LLCJSHRYjlWTe29tcglR4mewN4PulFSDPUdXtwEBHGh8OoO95LQK498ojAUKa+0I3GKBHKXdysIyRB2UsLTuiJUKRImWDmVg3mOrmk04W5lrk+SVX6lOhenZdpzQHK4LIriCEkwbhAXaPhLATXv1/Twj67bioZYuGjm1WxKutEKhkoEZjsqbbBSzogFwC28vvQx8vgoPjCDne0PNY22hgNurq6Xrast6lTp2LGjBl46qmnNrjupZdeitNOOw1f/epXsWDBAssDenp6cNFFF42IKJ177rn2+b/9279h+vTpuOeeezBnzpwxF2BGXSa4/vrrcfDBB6NUKmHhwoXW82BwcBBnn332iPcjhFjno02SNg/sN/Nf9rmbJ9aKQK0LgzxCLPwNr7iRqNYCZJwiCDKIjNoHpMoWYZ4A80ShkiQ5yXPdCgpuCdQpkJGClolFGajPLUkqRwnKUYJUMHSE6v+BmUQz2iKrE5Lr/q+mBNf5JFduNskLrzNJG4iUumF3BcYg0bPkp+wltvoCwJIkISn60jJqPBdDGz8kLinGecMYFqGtHvXQKnpoFT44fHDr82Nco11ENEOZJohIisCJ3KAQ9sElBYNEF40x01+F8d4Qpvh9mOgNYLfyYkvSAGByMIASTdHj1xCyDD7lllBmkmJNvYyEK32QISoGHhHKbdsxpzQVJIrcvNJ1P3dJqEebv4MyHTkCOEHA2huqUdgeMI4J0TACylHRPwcOgrrwkAmGLi/GII/QwWIMixA+4ehkMfp5uVBNeinrxhreAZ9w9LCqDc7tYdU2SWpDYTP3UFq9ejWWLl2KqVOnbnDd//qv/8IVV1yBU045BYzlbes99tgDjz766Aa3T9MURx99NJ555hm7bM8998Txxx+/UV2qUROls846C5dddhmuuOIK+H7+ZfmWt7wFDz300JgPpI3NFwwSB8x8EgfMfNKOef958YatIcwXvitSfTmw041nAACSxFOhsFEGyiQoy78JeMoKJIkQ1XKzTtxEi7Zjph4upGqxMV/AjzIQIlEKE0gJjCtVMa6kbl5muswYRLou3K0qSgamnQPk2iRzI/d0dcS08hpH5d0KVoefWBNLg4Bl6PBjW6WhRFg90nAWqlwyHmJGuAozwlWYFy3FvGgpfMLR60RrGKIs1vOVEQsPsfCQSGarTY2hvY3oJDF8cEQkRYXWMTNYiZ3LLxTMLAGgRHPX70CLzjv8us1kc3VX6lpl6Alq6ApiRCy1+i1TPcoEteaTQG6vAECH+HrWFNOYfAbaWdx1FzeTb66GaXI0gMnRAEo6OiQVDMNZiBr3kUqKildHXXh2lB9Q/0dSyeCT3HJhiEeoCx9DPCqI5o+Y89eX1WqjjdcQNtZscgxkaWhoCA8//DAefvhhAEqA/fDDD2PJkiUYGhrCCSecgHvvvReLFy/GnXfeife9732YMGECPvCBD2xw388++2xLw+kwDDE8PNxiiyJ838eNN9446nPaEEbdenvyySex7777Ni3v6upCX1/fiPdzySWXtFxOCEEURZgzZw723XffAqts45WHW1UCUEg+//PiOXjbzEXr3d796/jCJw7CcTvduukPEkAQZEjqPnia/74wT5MPhyAxL48w4YlZV0/FuS0XCUiqlnkdKQSnCEId9OqrG3hnlAuXXddtU1EKKFftt5GIiguj7MWx9IildloNQEHEbfQ3RuAcMDUVl+lJLEAZQpr9ppLC11YAxqxxkj+ANVkHdik9h1Qy9NCcdEQ0swaRXKp4jYhmqIoAAtTewN0Kk2m7ceecWpElM1EZEG7bUQZzopfwXDIeW0VrsTrtBKDag772kqp4iW3JDaQRuv0aJoaDWJsoraN7vay7uWOr4OqK3AnFfAIut3MwGqOBtJRHtGj/KfPcoNOr2+usPoc5InPlLTWchZhTXgEOgqoI0MuGwSUtTLKVaYJY+OCSYoI/aK9nW4/UhotXw0fpgQcewP77729fH3/88QCUI/all16KRx99FD/+8Y/R19eHqVOnYv/998cvf/lLdHZ2bnDfs2bNwsMPP9wk6v7973+PuXNHluzwgQ98ADfddJM9rk2BUROlqVOnYtGiRZg5c2Zh+d13341tt912xPu58MILsXLlSlSrVYwbNw5SSvT19aFcLqOjowMrVqzAtttuizvuuKNJkd/GqwtGhL0J3rV4+yYyZfDZHe6yppWDXE0xnf/EwZvc54VzqoTbLL8RS6kIkltVkjKPKRGZCslVk26OWVIogERPxUmAdambaEdF6XrqiY+6nnADlH9PqSFDbUMTV9QhLut63xULu+2mPIdN6WECxtGh/Yqsdke3mAxqPI/kCGiGIR6AEYma8LFjRbk4z4uWAgB6WTUfh9cVGJ8IpJKqKBFrkpjY6hGgyJEhQuZ3w7w2VUifcMTSAwcpLAMAH9BO1AQz/ZUYFiEmlgbwVDIF3ayGF+rjAET6syTqwrOmjwCwrNaNnqCm22C5LgtAkw9TNfNt3pupSFWzos7LwJAk2xp1CF1h4pAIhEzp0Yx/kiGrbkbexCDXazFIhFSF3zKoSmQHizGkzVpNxSmVDF/Ysd1ma2PzwNvf/nbIxlRxB7fcMvbv969//ev44he/iDiOIaXE3/72N/ziF7/AOeecgyuvvHJE+5gzZw6+/e1v4y9/+UvLQbGx+CgRub4zboHvfve7uPrqq3HVVVfhne98J373u9/hueeew3HHHYfTTjsNX/rSl0a0n1/84hf4wQ9+gCuvvBKzZ88GACxatAif/exn8ZnPfAZvfetb8dGPfhRTpkzBddddN+oT21QYGBhAd3c3+vv7Xzax22sNf31uFgA06VQeq0+zz139xOVP7gcAdmInlQwnz/3dJjmWXX5zKmqxFnDr+5YUxAqwDVESjgu3qSgZZ27Jaf6nlb75sSiz+zIIIz2WHiXwdQUp0JNNxhm67Pj7BIzbyoWdgGuoQpjWjT0245fEiuJgk2QPwE549YS1pu3MPoF82s3c3M06nZpYmVH1t3YoojvFy8f3zbpupcdv0T6LhYncKL5niFDuzJ2/H5uYjoZ13GsCAH2aXD+TTMKS+ngAwOpUfekZjZUhSjYOxpJQhxjxXOBviM9QGlpS5OrH3BZpp6/I8XAW2OUDqbr2Rv9lfnZmv24LNbaGk2rbOZWVhePq9tTPz3hO9bIhOxFofmajdcVv49XHK3HPMJ+x3dfPBgvHnmvG6zGeOu+bm9X97YorrsBZZ52FpUvVH2/Tpk3D6aefjmOOOWZE28+aNWud7xFCCvqlkWLURAkATjnlFFx44YWIY+3BEoY44YQT8O1vf3vE+5g9ezauv/567LrrroXlCxcuxIc+9CE888wz+Mtf/oIPfehDWLZsWeudvAJoE6VmjIQoCUnwpR1vt6+vfuotAIAXtSnhpiRKAGyeW5axPLpE/2YbvyNDkIDccFJkLO/T65gT5uvKiLYGMK8BoFKJ4XtFoW+v1iiZm3VjZIi5OZqbayOBAdDSm8d1Mzf7bjQ8bDRFbCRJhiS4YucZ5Vww/ebK0wCAaV5fE2FJGrRlkd6Hce52J9vWRZTMMblECSjq1lpFhBjEwsPj+vfKjM6vTJTj+7CeeLMj/Zq0Ge8pAFhe69TrqM/v8PJYEyBvwZlRfrWOIpJu4O7apGyvaeII7w3Z6tY+VYOaSBniZPZR0mSoy6vZFttkPyemZVq3HlRGsP2+bR9Z53VpY/PFK0mUtj9h44nSv87fvIiSwapVqyCEGJFR5cuNMdkmL1iwAKtWrcLf/vY33HfffVi5cuWoSBIALFu2DFnW3J7IsgzLly8HAGy11VYYHBxsWsfg0ksvxfz58+1o4957743f//739v2hoSF86UtfwtZbb41SqYSddtoJl1566aiOs41m7DnjWew541nsN/NfdpppQESY7q8uTGkZcvRyYd6vvwUhVNvNYwJC3/QIkSBUWkG3yXmjTOj2G3Qgrsl90w9JAAnwhEJk+UQcTxiiUoKopG6yacbgUwGfClQCpZVxRdwGjSG3MfcR0MwKtA3sBJX2TzIPtY+iuDugGbr8GspevUB+zGcbkpBJqgTJDQRmQjCM4SzEzqXnsXPpeQyLENO8vqbjdcXYBkasTSHylHuo9Vw9EpcUiW6jmYoUB7WCZaCoXTPGpI0P48M0N3wBjAjMCJX79Lo8oAKaodOxPujxa9ixawV6wxq6/LolSWpdXgjKdfehNE0CXBL7AKCtADLt1aRImZk0HEwj9Ccle+2HstDuwyMcqaRYkyo/KnN+q9KOAkGqihCMSAyKUpsktfG6xBlnnIGnn1Z/vE2YMGGjSFKSJHjyySdb8ozRYsz5EuVyGXvssQfe/OY3o6OjY9Tb77///vjsZz+LhQsX2mULFy7E5z//eRxwgPLfefTRR9dbRtt6661x7rnn4oEHHsADDzyAAw44AIcddhgee+wxAMBxxx2Hm2++GT/96U/xxBNP4LjjjsOXv/xl/OpXvxr18bbRGm+buQhvm7kI79v2Ebxv20fwpR1vRyeL0akjLn7y1F4AVPVhWIToZrVCtWGs2OuWk+1zLqhNj6fUtNDyqSTBidUsESpz40gAhIqG6Q8CcAqZMlC/udXEBUU5UNWByFOTWCZ81ZCShOftINejx4iyTVWocRRdyNzTJxGerZC4yz0i9JRVHqrrEVEIufUazCoBVW2ZoFttu3U8h1R6mOmvwkx/VdM5NlaSGBFIwSwpApQbtyFRKRRpGhYhUulBgBYIVqrFzYY0NU5BUiLBQe3DRQ+LwYjA3PAFhCTF9tEyS7JMlpy5HuacTW7dQBZhIIuUm3ZDnh4lUhtYqqm2OPMgpHI/r3gJGJGoZrnpnomBGUpD9Ok4lUQwZJJiIA0xlAaoZkWjy5j7iLmP/rRkj21xbbx93z1X9/9Me6KtjRHjVZh6ezlx/fXXY/vtt8dee+2F73//+1i5cuWo91GtVnHMMcegXC5j5513xpIlSwAobZLrsTQajEjMPRI3TYMbbrhhROv98Ic/xCc+8Qm88Y1vtDYDWZbhHe94B374wx8CUDkt3/ve99a5j/e9732F1wsWLMCll16K++67DzvvvDPuvfdeHHnkkXj7298OAPjMZz6Dyy+/HA888MCIjKvaGBuO3O4vliC56KQ1LEtV3tXF/zzQJpwr52+MyMjSRSVM1A1Ot90YE7lxoG6zZTrbTeW+qfe4Xj+3BoDyTQKAiAOehB9lEIKAhRmYJ5BmDJEmSJ1h7krtmkEa4+oDOQAAlD5JREFUNGpfWjlzAzmxip3wVHdazeyjrG/8jS0qSqRt7dQayBclwkZ7eESg26+hLjzsVFmGfl7GHqXWfXrTTo1IqqpC+hx88CayZMAgwQi3tgBuPqDZ3rTtUrs/VVUyZMG9Nkw/NetGOjNwx3A5FqeKaGwV9mN1WkEYZAXiZUiUyq1T25vQXQFir6UxqjRtNiBAwhmmlgf0cZupwlBX8fKcvDVZyV5/t/1m2njGNVyZX+Y/ywpL4FGOtVkZ47RQ+9n6ROzdoSZHD9v24aZr20Yb68XGkp3NjCg98sgjeOyxx/Czn/0MF1xwAY4//ngceOCB+PjHP473v//9KJfLG9zHySefjL///e+488478a53vcsuP/DAA/Gtb30LJ5100qiPa0QVpe7ubvvo6urCH//4RzzwwAP2/QcffBB//OMf0d3dPeIPnjJlCm677TY8/vjjuPbaa/G///u/ePzxx3Hrrbdi8uTJAFTV6aCDDhrR/jjnuOaaazA8PIy9994bALDPPvvg17/+NV544QVIKXHHHXfgX//6Fw4++OB17qder2NgYKDwaGPj8PNFe6KLxQgIx4xglRWvfv+fB+CWZ0c28tmIhOeTTL7HbUuN63aax7RvDhOgTNj2G6BsA3hCAUjIjKgH0xYBNWY1SZRKlROnP4MLis6ojmoaFCpFrrbHWAM0tsIaSZLQN9JMWwHk+9JTZSyx5oge5XqdvCVn1jWtoYBmSLgyMzQVJkC1hjr9GAIEO+kJtzfoCTcgH9FvZSIZkCI58sHVGHvDw7TZmA5tpRBIpVeYfjNVJQM1/dZc5QHQQHzUpJ1pVwHATqUXENEU08I+dLA6xnlVlLUmSDlam0pefr3GBVXtbO7Zkf8uPye8HX6CDj+xGiMATe3NgGaFypTxVlKVKEWihtIAfUmEoTSwpAyA9YViUNXCl5IuTPAHsX20HKuzjjZJaqMNjZ133hlnn302nnnmGdxxxx2YNWsWvvrVr2LKlCkj2v6mm27C97//feyzzz4gJP/enTt3rm3rjRYjqij96Ec/ss+/8Y1v4CMf+Qguu+wy63HEOccXvvCFMYnBtt12WxBCMHv2bHje6BNVHn30Uey9996I4xgdHR248cYbrd/CJZdcgv/4j//A1ltvDc/zQCnFlVdeud6YlXPOOQdnnHHGqI+jjSI+sd19+PmiPQvLIprihXQcfMKbiMNo8NbbvgFVk1CTZfWMwfc4Mp6LbKVUoaJGt+R+Xhp7KgRXUBBPQqZa/M0kSKC1QZzCC9RN0tO2A4wKDMYhpnYp8lxwyQYpTLy5laDYGRc3bTZqW2hOO0u3iIwHU9lLmrRGjWTJjcxwCRcASwTq3MOOHctRFQF2Ky9W20kfFVoHB7GTVj7J7PNY+qAQhUqSIT4pGHxwe94AEFiBuuMHBWojSxotAwBVMTKTdAwCHLmLNgdFgObfk9n+SiznXXhDaSmWJuNt5Ec981FmKVJBC9YKQC6kLoWpDdst6cw7SqSdZHOJEyMSqfZAMuTIiLm7gjqqmd/ktm6y+ACgN6whER4mhYO2BWgMNHeuvKjPkWANr2xyu4w2Xj94NXyUXklUKhWUSiUEQbBevbKLlStXttQ2DQ8PF4jTaDBqjdJVV12FE044oWAEyRjD8ccfj6uuumrE+9lUfcQddtgBDz/8MO677z58/vOfx5FHHonHH38cgCJK9913H37961/jwQcfxPe+9z184QtfwB/+8Id17u/kk09Gf3+/fZgRxTZGjyPm/BURSRCRBFwSDPAInbSGqggQSx+9Op0+lWzUbTcg140wrTvyPW6rCYy2+AYgqu1GPfUe0ZNQxJdg5QysrG/qKQVPGOpDIQiUTxMlElIShF5rYaAxlzQPt3phoFo11BpCujCEwyPC3pyFJFaDZNfT5MIQDOMc7VaRBIh9bFdZge0qK7BT9AJ2il4AoIiOyW4zxMg8pxBWhO1Wk1LJIPQysw9zzBRSi7s9O/rv7tPollrBVNtMFcmtHCVgVtfEIO2jQhJUSIIdw2V2QmycN4wSTdDlxQhphhJLrIZJXXtFMHuDYUvGQpphea0T1cy3pNQloT7l8ClHiaWYFKovaVPp6/CSgjbMVKS6gjomlYbg0Tz/rctTeW817heOiUG2SVIbG4ctTKMEKHfuBQsWYO7cudhjjz3w0EMP4fTTT7dDXhvCm970Jvz2t7+1rw05uuKKK2y3abQYdQknyzI88cQT2GGHHQrLn3jiCQix7piGRmyqPmIQBJgzR8Vp7LHHHrj//vtx8cUX46KLLsI3v/lN3HjjjXjPe94DAJg/fz4efvhhnH/++TjwwANb7i8Mw41KTm6jiA/OXlh4feW/3oYeVrUVhtW8Ez1s2ObHrcu8shElP0WitUapcEm7AHdsAKiuKlEikWUUhAplNkklhHbxpr4TC+IJiCRfnsQeonICLoglX2uqZfSWq3oKzVSIiuPwmaRNI/xALsxudIBOhIcqD9Dh1W0Wmdm2UZht9ueBo19XSAKqHLkp8hZWbzCMtVkZb+p41m4bCx8T2SC4pJb0GHdtW1kCt20418IglkGhQsRBERBlsjggSujSjt7DshhMbD6DojgdJ0CRIrcZMFoklywZuB5OE9kwBkX+GXPCl7Caq4ESY11QFz4GeWTjQtS1z89FVZMEtir3YyAtIea+1StxSdChq4Hj9YRdf1bChHAIdaFamcNZiLKXoJoFSATDUBpYWwjr6i0Y+tISKl4dFa+OLi9GKhmW1Htx4a7XNF2jNtp4vWPvvffG3/72N8ybNw9HH300jjjiCEybNm3DGzo455xz8K53vQuPP/44sizDxRdfjMceewz33nsv7rprbM72oyZKRx99ND71qU9h0aJF2GsvJdi97777cO655+Loo48e8X5uuukm/PKXv8Ree+21yfqIACClRL1eR5qmSNMUlBZvMoyxURG6Nl4+DPII04PVhWW3PbsT3jnriQ1uK7QlQD1T7RM7gdXKj4gKJIn6VZeCglAdX0IAajyRZO6zRIOc2Hg+R5YxRGEKKQni1Me4ShW1zEd3ENtjSTgrkCWPCoAYYlTUFRlC405jqWBX9bmNrR43n63GAwxnYe7Po7U5XLs/x9wHJDAlUu3B7UovAVAkZ7qXX2sBaqcPTSXJLAeUPim2bbiclKQNFaNYBoiFD0oEBkTJ+fk4dgGgmOL1Fdp3RhvFQWytyTqCgxXsA9Tn5vtzSVMPG7b/KtJdxcqsE3X46GSKmEQ0VX5SRF0/1x+pwhSBebHWY4+bEoEhHqDLi7E2LWOcX0W3V8Pyepe95mGQYVVdkbMuv24NQnv9Koa0d5VHuYpc0flu6tg5vrvLtWijjU2CLUzMvf/+++PKK6/EzjvvPOZ9vOUtb8E999yD888/H7Nnz8att96K3XffHffeey/mzZs3pn2Omiidf/75mDJlCi688EJrBDl16lSceOKJ+NrXvjbi/WyKPuI3v/lNHHLIIZg+fToGBwdxzTXX4M4778TNN9+Mrq4u7Lfffvj617+OUqmEGTNm4K677sKPf/xjXHDBBSM+zjY2HX6+aE+UKWxV4qW0G8/UJ2GHcFnTSLqLXX+rTCUDpuMumKrapJxZI0Egn1RiTEAIAo9J1FPtAq0z3ggT4CnNCZKGIUlKu0RAtYibc4pIO3ITIlEOUiSZB49xrK2XMC6s6VDbZkfoRDAt9s3JkkeE1TyZ13ZSr0WkSSYYSiy1+WGUCEuOzKQbI9JqagLKMTFUVZDpoSJGfbyMncMXIJCP6Lshq4b8UAhbZTIVpVj4YPr43J+RqfgMihIioo5vWIT6eBqrQRzLsx5EJLGvjUYKQKG9Z47LlZW77uCRJlA9tI5YMkxhg+jTBM38XgFAB4vRnymTSEYEur0aBnU0SImmdhKu7mTCVbMAZS9R7U3KMczDgpi7y8s1TH3aE0lFpsjC+x16ug0AFg+rKb2V9Q7c+Nb/hzba2JTY0jRKZ5999ibZz7x583D11Vdvkn0BYyBKlFKceOKJOPHEE+1E2FhE3KaP+OUvfxnA2PqIL730Ej7xiU9g2bJl6O7uxvz583HzzTfjne98JwDgmmuuwcknn4yPfexjWLNmDWbMmIEFCxbgc5/73KiPt42Nw1X/2geR5gGp9BALH2WawCcZlmfdmOL1A0BTNUkJt4utnJSzJtftTFAQIsGo0LlvEmnGEHjctugoE8hSBsIUGTJ/TbkkCQCYbsV5nkPCBEUUKLFwyc9dl4fSAF1BrjsxMM7MAAoeP2gRA2JH+iGLWWJQ02yps32PrzQ5fWnZkq+aI+ju9auocw9bRWvVtZIM86KlNl+tVRVJfRa14u2qDMAgbCWJS9JUSRKgOZmShrAJpWVqMJU07bAqApURJxWpqcC0unKCOCxDBIRbs0kXDFKTRXUeEeFIQNHLqqiK/Bps5a/FmqwDkd9fiM0BYFtxnZSjLjx77ceHQ8ikMc8ktv3GQbAi6cSkYBBllqA/y6tmJZZazyaTUzclGLDkqyoCzKysbrfZ2nj5sIVVlADg+eefx69//WssWbIESVJMORhpkYNzjhtvvBFPPPEECCHYaaedcNhhh41pYAwYA1FysTGW55uij2j8ltaFKVOmFCb22nh1EQvf3rDMaHgsfUzz16Iqw3WOSFeCRPsgAUmmfmUJQW4JoG+0Uio3bUIkMk5Vyy31tD5JkyUqwbPcP0lk+U1aCgLmC0iRT7wBatoNUI7cPWWlw/EbvJGMy7OxBRB67B8AKOFIuAlxzQXe7vg4UNQDAWgyjlSiYIq+tGSF4SZOw4iNO5giH0NZhB0qypxxWIR2ws1UbHiL6pWAGvWnkKhKUx2StlJkYCozkZ4mizVJ8UkexiugBNrG4sCcW+7MnWE177BVpUZN0qCI0EnjwjIlMqeIkCHRrUMGaStO23hrsFqoLLiYqmMq0zpWZV1IoUJm68K3rTifcdR4YLcPHHKmJjPVZ4QswxCP4DntQHeiUB2/xJSwH1xShDTDkljFrVy5x/80Xec22mijNf74xz/i0EMPxaxZs/Dkk0/iDW94AxYvXgwpJXbfffcR7eMf//gHDjvsMCxfvtxqqf/1r39h4sSJ+PWvfz2m9tuoidKsWbPW2xobaeDcy9FHbGPzxURvQLVpkNqbpfl3ZdbZ8sYNqHDYWppXlFwdEG8YHSeuRogJ1Oo+CJHWtRtQ7twWUlWZXEgBEB2kK/XnpRlDb4eq5HCh2jJcV5bizMNAEmJCVM0/w8SAcM9qV9zlRnCdOG0ft8XjWgEYlFgKDmLzzazYmwh0+rG9lmuzMvbryicIU8kwXut41OtiJUkdjyhokwZE7iVkSJK51nXHa8lOqhGBRPsmMYgCYQLylphblaqKED7h6OMeKrRuRd0ByRBLT70nSqiQZrPNWHqoOK1DVV1S242nw+gTJUzyBgqaKSUUJ/AZR5WHllDWeFBwinez8ygRGO+ra2eI3tbBGltBq/IQYEBZ76sufDAisDQeB49wXPbGn6CNNl5ObGmtt5NPPhlf+9rXcOaZZ6KzsxPXX389Jk2ahI997GOFoa/14dOf/jR23nlnPPDAAxg3Thkcr127FkcddRQ+85nP4N577x31cY2aKH31q18tvE7TFAsXLsTNN9+Mr3/966Pa16buI7axeaOT1rBUOyurKSjZFGfRCiU/QaL/cndJD6MSqW650YYacpz6YFRah27TdjPPDaQoEjSq9U1ZyuD5ysenFKYYTortv3E6CDfylAg7EbleqhXRCVhWmIYCck1SxNKmiTWjdzFamkR4lqxQIq2427R+fP3Z20X5CG0qPfSyoYJbdiNJAtCkSzLr9XGdTaY1UIM8AiMCjAhbHTTtNbcilEpmdUrqZ5x/zXCZx5uYn30fLyMiKcq0jkR6YESASwofHAMyQpdTWTKfE0tm9UoGhgxNZENIJbNEqZvlJHZQROj2qhCSYpBHmBgMWhLkE45VqRJoTwpyzxZjkNrDqoiFj4ikWJV1Ft4DgBfqPeqcicR/7/7TpuvcRhubHFtY6+2JJ57AL37xCwCA53mo1Wro6OjAmWeeicMOOwyf//znN7iPv//97wWSBADjxo3DggUL8KY3vWlMxzVqonTssce2XP7//t//K7h1t8JoXK43tyTjNsaGR5duDQBYw7cBhUAnrWFV1oU6fPgka5puaoSUBIwKRF5q2xxAXlFhRIJL0tS2CvwMqWm3EYmk7hf2acgSYSJvxUkATLXnCFE6pihMFXHShKurlOuRYt0GjOGhK6gr/yTtzG09jSTJk+T1Mp/lppEhzTCQRfAot+QHUFNeRjNjSCAHKUzAmYmqVFLUBTCnvAKAIh7bhYowudWSViTJTL+5/keDmmCYa8slQV2qasmwrgSZ+A7jhO2CQdgKYeNP1ye8UD10hd9VESKiShgekQQCJG/l6dZmMQsu37tPhJ6gU8fFSIZp3loMixA9tIo1vJhH2c/L6GRxwacJUFOChsA1tv4ECCKaoo+XrVgcUIRvbVpBB6u3J9raaGMjUKlUUK+r79itttoKTz/9tJ2AW7WqOZeyFXbYYQe89NJLTZNzK1assFZCo8VGaZRcHHLIITj55JPXqwnq6ekZ8UQb5+u/gbbx2oMAbWqxpZLhSzve3nL9D9zzRQAlcF01AgCPcatTWh+kE2+SZgxBmFqdktE2mXUIlWBMIEsYeErhhdx+VuZ4MgV+69/JspciE9Sm0JsKkdCmkUOCoTuoKd2OY19gqkbGXwfICaAhScYfCYD19gFgTSHN+tuW1JfIoIgwL1qqJ8jU8TQSJENOGiNLGARW887CMrfVlmgyZSpJhiwJp9LVuF9XY1Wm9aZcNrfCBMBaDSQy92UaEJHSWDmtVr9BFG8IT6OTd4XWMSxC9LIhVGVoW4ndrGqPxWitKAQGRQk+4ejUn12hdfTxin5fop+XwSDR6w1hojeI55NexMJHSDN8e96NaKONVxRbWEVpr732wj333IO5c+fiPe95D772ta/h0UcfxQ033GDtiDaEs88+G1/5yldw+umnFyyMzjzzTHznO98pFGxGWpDZZETpuuuuQ29v73rXueOOO+zzxYsX46STTsJRRx1lp9zuvfdeXH311TjnnHM21WG18Spj3vTnccuzczHF68MLqfr96GZVLEt7AATK32Y9GBfVsDbW49+Uo6Zz1iyh0K0zV5/EiERmfJZSD5RK1Ot6BJ5JEACCK+G3yXKTgsALOHjGwFMGL8jABbVCbjPSH2ceuqIYXFJUtMGgG19i2muuyWSvnlSrCV/pm5ybuZDUttdc3ySP5HEkyo/HhN82X6+Juk0kJMUO0TLEMkAvHdLH1rp6Y1pbNseNcKzMusAgrA2A0jNJOznmE3UcqWRNLVMG5VBtKj6NOrSIZFqXlNl9mRYdQx6ZotZ1p/HUtRoUkdPmk/BJgmHpI0Dux2TPTcefVEiKYceGoMpDjPeGbEvRbzFZ10lrdn1zLj1sGCsz9YU6wRuw18YgoilO2fk3Tftqo42XG0Q/Nmb7zQkXXHABhobUd9fpp5+OoaEh/PKXv8ScOXNw4YUXjmgf733vewEAH/nIR2xhRuox6fe97332NSFkxAWZUROl3XbbrVAVklJi+fLlWLlyJf77v/97vdvut99+9vmZZ56JCy64AP/+7/9ulx166KGYN28efvCDH+DII48c7aG1sZni4FmP41fP7Gpf9/MyyjSxepB1wTVxlJKolhZTmW6UrFufBCjDxzj1wKhAnPigzBGB61ZbGKZW82SqS65GKQwV+TGO3EIQdJVinSVHMFCP0KtF3MWYkfz/h0cE+tKSTatXGW7qRmxyx4C8GkOJAHRMCSW5sLguPVtlMi3ImeXV9v3+rIT55aWIhY8pXr/NWROSQoDaaTfXC8m03fpEGVwS+CSzFRdTSUpki3anzmVzwUEL1SNrQ6Bfx9LT4/0MIU2t8NtYCviE62PmSKWHiCR2Ws/s31QjKyRBVQSgEIjhoULzEX1zLRMwMAhEJHNaaTVwSVH26k3WBmZyz0SimOsVS6XFmugN2GP5e20GJniKnE71+/Cp7e9GG220sfHYdttt7fNyubxBTtEKbkFmU2HUROmwww4rECVKKSZOnIi3v/3t2HHHHUe8n3vvvReXXXZZ0/I99tgDn/70p0d7WG28BjDeG8LiZAIoUZNR08K1eKE+ruW67/nTV+zzzqCOoTSAr8fsGRVIOQMj0vopuZBSVSJ8jyNOfPget7Emhak3IPdd8nhBx8Q85cjNmACgct66SrElVAAwqaz+8unw6naCTehQW0CRpESbREY6L2x53I1qFlqjQiPGdnU+PlFj65nI89RMFaqDJSjRFHPKL2FV2mm33an0IjgopnnKP8lUZ3ySgUs19m+E2Hnwbf7fnxGJAZ5Pu4UkRT8vgxIJn3DUha+8lhpy52iDMLtwbfU0Gm/4u9UVgcfCty24ThY37cN1BTcVoGEZICIpOBiYrnj5JLPkrCqat2n0elLTdfl6k7yiflKA6Ek6dXw9VBGov8fbAABWZZ04ce7vm463jTZeUWxhrTcXX/jCF3DmmWdiwoQJo9rOLchsKoyaKJ1++umb5IOnT5+Oyy67DN/73vcKyy+//HJMnz59k3xGG5sPDtv2YVz1r33QSWN0MqX/eHh4Rst1//2+zwBQN22hhdqRl6GWqtZVXZMl3jCxBuQtslqqvX08jnrigRCJeuzD87kiPwTIOEPoZwAkkky126TI3b0NMk7RWaoj5Qy+dgfvCmPEXLWm4KmWW1+SV4g6fFV9qHiKCE0IhlDjPqZE/RinW3Edmhiwhm+rxfF4lFhiyZNxxi7pysmMcBWGRYgJ/iCm+6qqZCohxiuJS2r1P81O2ZltpwFARBL08QoC7bkEoKCZ4g0EyYWpIrl+RoZAuSaXZvvGaBOfcJvvNsgjlGkdjEibK8dlvo3P8py5YRna84pICl+fuyFE67Kb4JIWKpDK3DKxx6POJT/XLhrrwF/fTmyWaX2duro22nglsaXZA7j46U9/ihNOOGHURAkA4jjGI488ghUrVjRFlh166KGj3t+oiRJjDMuWLWuKH1m9ejUmTZo04p7fhRdeiA996EO45ZZbCoKrp59+Gtdff/1oD6uNzRR/XuxOGUyx2VzPJRMxwR/CcTvd2nK7riDGqrhiXxvnbWPcCKiZp8bZAC4oMh2CGyfGnDI3nMxSpnRJEgiCTGfGcUSBQK2u8sBIw7dHKVRi7YAp/6SJupJEiUQmKNbUy7byY/LaIieDbX7HC3gp7UKJpej2FKGZqFs35qbtkwyrtA5mZrTaVkLMuRpx8XhvCC+m41ChdUuSyqRoXAnAjthzSa01gGm7ubolI1R2Ky7DIrR+SI2Cb7eK5FaKGs0fhaS2amRG6BXpLZIRd5rNLOOSqEgW6cEnGahTBTPHaNZNpAcQdfwVkqBCEgzLwFaO3ONT2+Y+UWVSt9dGtQaF9WNyz48RYTVKZZq0W21ttPEKQLZqF4wAN998Mz75yU+2nJIbjS7JxaiJ0roOvl6vIwjWL8x18e53vxtPPfUULr30UjzxxBOQUuKwww7D5z73uXZFaQvB7Yt3gN+wrI9XIEDQyWpYFE9uuV3MfXhEoCeIsaauqjSGMEReilQwZfyoiQsAcKelxohANQlASO6qnWXKF8nc2ymR4JwiDHIfnFKYYGg4sv5JkX6PC4KOUJGRnrAGIQk6/AQx9wpZc+YYty71AQB26VgCABjkJUz2B1DWGpcex9cHUBWKPl7GBG/ATmAFjm2CqXiUSYJBGWErf21uxKgJgyFGAJoqSe4N3xCOiGRYzStWl0QhUHUcuDnoOj2uWlWRXNLkEimVA0fstfFJpvRGyImUi6oICy24VBMYQP3uGKJtCGZE1Lh+J40xICMEhINBKrIEgVh6lkhWdavNdeBOZN7eLJNE67ma24WHz7m/5bVoo41XFVtw622s+NKXvoQPf/jDOO200zB5cut7zGgxYqJ0ySWXAFCM7Morr0RHRy7E5ZzjT3/60wY1So888gje8IY3gFL1Rbv11ltjwYIF61z/scceww477DDmfJY2Nj3+viQnsbtss3SD66dgtp0z0RvAc4kqoz6ftJ6Q/PQDRwGoIJOqMlT2UlQzHWCqRcxUZ7qlnDm2AdLqh2qpCq11DSejMCdEtVjFVpRLxYy2RAfoZilDpVyHlASRr26qHTrPLZMU9cxDh58gYpmtHFUzdRPevuMlAMCsaKXdbyerWVJgKkOGEFVIggERoYdVrVjY15NcbsuMQSKRDJ0ktstNlcQlQtwhMQaWzDjtqNW2khRYM0mDVqJtU0miDbEqLllylwHNU2VmWpFBEba6pLpiZM5Dic6VbsmJkCH5sfTxihJlN4jJB0Vkl0UkVddCV6mqMkBEMkQkQ5kmWKOn3gQIfMLBAHTSOmKhXMsZEfABrNbeS+/b9hG00cZmiy2Q7ADA4ODghldqgRUrVuD444/fZCQJGAVRMqN5UkpcdtllYCz/azMIAsycObOlONvFbrvthuXLl2PixIkj+sy9994bDz/8cEEJ38bmg8XPT8XMrZet830um4NTX0q7N7jf8eEwVsYdoESimvlqwo0701p66swQJgCWNElJUPIzJHp9YxEAAKl25iZEohQl+rnapymUBkGGQJOjkv63M1STbpaoQeKlagdmda22x9Thx9ipokwee70hu7ysdUWGIAF5RUOFuQboorGdsmpl3ghAC5B5wxg8KRAiBgmm1+Eg1msocbybKATWiI6CeNtta7Ua+zfvixa6n8b2G1B0q65r0iOkJiUEhcqV2i9pOu9UO3RTbVegKkXqfKoiVAJ5k1vnWiBAB/PqkF8OqgN8A0xkSrDdy6qWLBkM6mNys/B6aBVvm7mo6ZzbaGNzwZaoUXr66afxox/9CM888wwuuugiTJo0CTfffDOmT5/eZCLZCv/2b/+GO++8E7Nnz95kxzRiovTss88CAPbff3/ccMMNBXvwkUJKiVNPPRXlcnnDKwNNycFtvPrYZZulWPz8VPv6Gf081jfRudNfKKwfkRSDIgKDwHNJTpB9wjHEizdMQFWNMklR9hIMJFHhPY+I3IHb+R8utHt3pslR4pCqNFNWAhmnylRSa5WqtbCpohT4mSVHxkix7Cdqws5psQkQdPp1rKh1Ylq5H0Duij3Z729ydu5lQ/ZaGHTROhIwlGnSFAhr4BIAax+A3EPKdZU25Mhohcw5NFZ7+kTZttlc8bbRI1Gy7liZRkF3Kw0QbdAGqfU8+685HmOImUqvQKxi6VtSKTTJcQXfgGqXRUQglj4CwhWB1NfEnE8Xiy1ZMhly6nPVNe2kMQZFhFQya7I5xetDLH1bkXrLjJHlVrbRRhubBnfddRcOOeQQvPWtb8Wf/vQnnHXWWZg0aRIeeeQRXHnllbjuuus2uI/vf//7+PCHP4w///nPmDdvHny/KAD5yle+so4t141R97Q2xqNg3333xZNPPrnhFTX23ntvlEqlDa/YxmaDvy+Zblty75z1BG5fvAN6WBX/rG8FAOj1hrGknrfdjnv4o7hw12sAAEfffzQABo8IxFz9cgeUo5rpcFvTVnJu2MbpurEiAahpNVNl8piw02/uRJuUQMCME7ew2wFA4HGkgqEnrCHmHnzKsXVFEaOS45K9Q1m128w0n0+4JUUT9di50RT16PZaLBkC5KaSjeTHQPkTtbaFMwTJFVK7laRYeFar1CfUHyeDTlCsS2jMSL2xA7CBtxDWlJI7Y/114eTC6Qm3Rs1RKlnLFqCQeWxKRDJbdQLylqT6vFxzVbHXTRlTxkKRpNgRl1e11kptY64nQyeNIUAwKCLrC6WqeBmGHYsAl8i2SVIbrwlsYRqlk046CWeddRaOP/54dHbmKQH7778/Lr744hHt4+c//zluueUWlEol3HnnnQU7I0LIy0eUjj/+eHz7299GpVLB8ccfv951L7jggnW+d+edd47q4NrYPDFz62W2kgRA3yQlqpq0PLRkG+y+zZKm7UKaop+XMCkYwIqkaB3/uQc/AcCDRzkG0hIoJMpeir4kgqf1SEbAK51sN5cgBV6GJPMQMI44U47cUuqpN87g+7zgo2QIEqBacMaJ22PCVpA6tTYpYpnWSwWYVVHTFFODfrt9N6uqiBLJbAjrJKZ67Kb95ibeuxEcpsqRC6O1GSOaqzON2WRm2boqSVxSDEpVmRvkJS1wdvyiiGjSJ7m6JKZbXI2O26ZyxCDthJs7ESecc6rqymFjVEmZ1ZXYmiZWn8Ql1TmAvKC5stUsiWYDTcmshYKpIg0L5cINwJJEt3VocuV8kqGHDSt7AhHh4FmPo402XivY0lpvjz76KH7+8583LZ84cSJWr17dYotm/Od//ifOPPNMnHTSSVYPvbEYEVFauHAh0lR9MT300EMjzmtrY8vFti20SfcvmWnbI48u3Rrzpj+PA2Y+iV8uehPGsyEsqitx3YpE/aVgbrRffuhjAChCmmFtokTGAgQJZ4hYpqo5jNu4EilV+GkmaYEoGZ1Sxil8yjEUh3Z9oDj2XwrVTblxas2E8EpJrIBbgKAnUNWibr+GgSzCnPIKcJDCBBuFtDdnEyFiXKN7aIpYUlv1AZpzyYpTZM2VpMZqU+N7hii55pKm7WnaS43Ea1iEhUgYdRya7ICqGBNNUkwVySVLppKUE7O8imSqRr4T9mvy52Lho8qVF5S6FhRVGdrJQGNK6ZIlQE0IVkVYiDwxcCtaypfJTEwK+6+rx1Kf49mpwjZJaqONVxc9PT1YtmwZZs2aVVi+cOFCTJs2bUT7SJIEhx9++CYjScAIiZLbbmtXhdpYH7ger3Zx+Jz7cfVTb8HWwRosiiejy4uxOq0U1hnM8qqGR1RuWMQyDKTqRm50R4b0pEKRIiPsBvTIv6BgVKKWegj8DPVE3dyjMEVd+yoFfgYuVDuOO9sDQOgp4bElSZKgN1RkaEZ5DQCg26vqylEu0DZj61wSjGfDEKDoMRNu+gaudDVUR3kUq0gu3ErSushRY8utcV23kmS8krgkVp9kqjvr0iMpHyWlIbKGj4RjkEd2W5eYFPRK+udv2nmG6Lhj/6bFNsQjdLOqEm6b6bcGmwO1r7DQGgNyPygK9XOsWJKlfs4mAsWtdFmvJlAMixA9bBgcFO+e9Y+W16GNNjZrbGGttyOOOALf+MY3cO2114IQAiEE7rnnHpxwwgn45Cc/OaJ9HHnkkfjlL3+Jb37zm5vsuEatUfrUpz6Fiy++uNA/BIDh4WF8+ctfxlVXXbXJDq6N1zb+8ty2VuuxMuuETzgm+INYWh+PMksxkEZgtEiq3DDZvnpJ65U8S4KAvDIkpQq2Na01AyEJQo9jKA5AqbBZbWGQ2ek2KYkSeuv3XLG2eS4kQU8QIxMM44Iq1iQVTA4HUOUhJvuq7ZZIDxO9AXBQTGF5Ky6iGRIw9NAEQgKp0w5LpTul1Txeb0iHMYi0fkgOceCSwlUEGdLgk6ygSVqddeh9GkE1c7anTXokANbnSDS0vVziE9G0gYDkVgUm180NvnWF4KbVZ8w33aqgK9o2n2XjTrTQOiKpFW0zIiB0Dlwf9yxZMteukSy5VSVTdWp7JLXxWsWW1npbsGABjjrqKEybNg1SSsydOxeccxxxxBH4z//8zxHtg3OO7373u7jlllswf/78JjH3+uRB6wKRo7S/XJcz96pVqzBlyhRkWXMi92sZAwMD6O7uRn9/P7q6uja8wescf31OlUzNzT8iGR6KZziJ7eqm90xtImpc3XiN3siM3wPAQKpupma03USSCJC8GqLfMwTKEJwky/czXA/sjZg0/avWoZpsAUDJz6sW3YGqgEwt67FyX1WNpgb9VnxsHLaNaLtT36i7jCGk/gyh/5clVv9THPMHitlr9r11RHGoa5FXpQxRGXCiScw1N8SgKgJ7/XnDcTQRFEenpPbBmgid2VejbYCZYuvP1Oc3EiUgJ1YdLfLd3OMy+i4gr0IZoXbd0Vq5sSQRTe06BsbA0yVKR8z5a8vPbqONjcErcc8wnzH/U2eDBdGGN1gHeBLjkau+udnd355++mksXLgQQgjstttu2G677Ua87f7777/O9wghuP320ccPjbiiNDAwACklpJQYHBxEFOU/HM45fve73zWRpzZef3CniHqo25qqYmXWqTxu9I21xBKs0ZqkileH53GsrqsKiJl2o5AFHyAAjsBXj6Q7omw3/81omoxPj5QEVJMpU2UyU3HKfyktaJMmRIoYpYKhy4tR4wGmhKpqlEoPW/kqgNadbBOSoJfVLTESzp8hhtBwkIIuSDlJ+3a/QO647baXADgTaNS+VmJrYifacoKUX7fY0Rf52pOoWSjeTMpcg0nVMlTbGPG2G3BrMKQrRoYgCamqUy7pMdfDwLTVTNXKnX4z+0ols+fRyeJC20CAFMgSI7KpQmbIrU8yfHj2g03n2kYbrzlsYa03g9mzZ4/ZB2ljJvPXhRETpZ6eHhBCQAjB9ttv3/Q+IQRnnHHGJj24Nl57OGDmk7h98Q4AgD5RwmregW5WLdyYFjz2XkwKBlHlATpKdaxMOiEkRY37iFiKoUy1VYRzI/UZt5NvduKt4X95XbfofMZtBSr0s6bsNrMdIao6QYiEr0N2K0EdmaCYEFUR6+MBgIEswqyymnarigCzwpXgoBjPBpFKhl4t6q5Y48jidRFSu2u3ICPDTpArhbD+QcZoUV0L2lRxSrQpYyx924qqNoTaJg3bGFKTC7Jzt+zGUFhX+GzaaK10SalkBS+kkAi7XlUEoERYkkUdfROXzFa5lK9S2pQvZwgQd3RSNnKEJraN1yjkNmhF/tokqY0tBlsYUZJS4rrrrsMdd9zRMtD2hhtuGPG+Fi1ahKeffhr77rsvSqUSpJRjHkQbMVG64447IKXEAQccgOuvvx69vbkXThAEmDFjBrbaaqsxHUQbWxYOmPkkbnl2LgCgi9aapolO2fk39vlJj/wbeoNh9KUlVLw61iYVBJRjKM0rUx4ViDOvpZdSo4+SkARcqGk266XjVJkYFbp9Z0JSpd225KuK0ISoqsXkKqdsdiWPI0klw6xwJVLJMMXrA6AywmLhYbwWd6dS2SWo41HbNZpDmmMe1BWUxmmsxNEpNY7zA9AxH7zgft7f4DadNBAdF8bE0RyHmWgzVReXYLiVJ9cLyd1XkzWA/jzW8E3shuU2HpN7nsOOeNtdizl6KZ9wRFRFnqSSWbF4K3KkzsNrt9vaaGMzxrHHHosf/OAH2H///TF58uQxEZvVq1fjIx/5CO644w4QQvDUU09h2223xac//Wn09PTge9/73qj3OWKitN9++wFQDt3Tp0/fpKN3bWx5GOmotWkBdXkx1qQVdPox+hM91u203VwvpUxSCKkct63IW1eSjEu3lAQ+gIGaqjiYWBIA8KmwbS8pVVWpEiSQkmBcVEMmqa0kuZgdvmSfT9LtNtNe7HTaSoYkqUgRRZxaGS/G0oNPhG03GQzLwOa9ueQByJ2nzXWLdaszFqpN2WqKzW1BAXmECnf0R6rqU/zrjRJRMJZsfM+cozknLpXTODRxUteCN+mT6sIHWrTs3P2mkinyQ1trmLikhfDfdU3gucvbJKmNLQ1bmpj7pz/9KW644Qa8+93vHvM+jjvuOPi+jyVLlmCnnXayyw8//HAcd9xxLy9RMpgxYwYAoFqtYsmSJU0xI/Pnzx/1QbTx+oaJM6mwOvpSVRUpeymGsgAeFVZrZNpvHhGaLDmCaEFti43qb4+UM3REdQzUIsSJj84ojyxRBEtt3xWpm3GHrij1BDUkgiGTFDt1qPy2GeEqCFBs5a21+4hIikQyW0lS55KTJABaj1QkS6nMW1yDoijENO21FMxWmUxlzPU04trjCECBaBWDcU3uGUNEUzCIQpUpIBli4du2myvodomOQSunbdemwLTfGsXdQlL73pBjbum24nKzTFWZcifdjKZKXYvivt2puFSypopjmxy1sUVjC2u9dXd3b3S266233opbbrkFW2+9dWH5dttth+eee25M+xw1UVq5ciWOPvpo/P73v2/5PufNfyW20ca6sGD+DTj10Q8UlpW9BH1JCQHl1hrA+Ci5jtyGKLmCbDP51q8rSanOdgv85t9LRiUqWrhd9lSbbWppAHXhIaAcO3e8CACYEShtUg8bVuaTuopk4khMhciQJN8QIqfdlmpSYSJG+njzpMqwDKwjdyxd8iOtiFk4rTYral9HJYlDGXIyiIK1gEuW3DZVo37JPTd33L9xffd5q+BcE4qrzC/VtTHkbutgTX7+ItRkh1nhd134gNMmVMfS7OPEtbAcgDWt/MR29zUdSxttbEkgUoKMbnC9afvNCaeffjrOOOMMXHXVVWOOLxseHm6ZJ7tq1SqEYXO+6Egw6v7ZV7/6Vaxduxb33XcfSqUSbr75Zlx99dXYbrvt8Otf/3pMB9FGG11ejLrwUGKJFlFnyARV1SNB7dSagVtNkg2VpeEkgMcECFEEybS5Y8c2oDOM0RnGoETCowKJYNihSwXbhjTDrp1L4ROOrYM14KDoZUOgkC1bbaaiYgTbAoDQy41GKdIu1gBQ1TllZqItlp6tJHFQJNKzJopcEkuS1LrqudHlCORxLi5i6esKkK7YaJIUkKwpHsW8duFWelq1z7iOa8nPnbYkSSFNQYm0InNDFkOaYqrfp/2PygX7CAalmTIVpw1N51VFgKoIkEqGHlZFQHibJLXRxmsQH/7wh7F27VpMmjQJ8+bNw+677154jAT77rsvfvzjH9vXxrjyvPPOW691wPow6orS7bffjl/96ld405veBEopZsyYgXe+853o6urCOeecg/e85z1jOpA2Xr8wGpPp0Vosqk5E2aujLykjYMoiwKMCNW0VYDRKBsZo0lSSXDLkIs0YukqqxdYVqn8jprQ6u/WoEN8hHqHLjzEzVOJtM/5vdDJd+t9eVrcGkr7T5I+ss3TDZ0vVfouIQJ9Qvk6pVOPqfaKckxmnNSZAC5UkICdJxsTR6HSazlUTJFNxYQ0khxFhW24GHBTGwtJUjlzdkiEn1kQS0kaYtNJfuetWRWAJVdlW4aglcwatWnauZimvWhGt/WJOFUkR17Z5ZBuvK2xhrbejjjoKDz74ID7+8Y+PWcx93nnn4e1vfzseeOABJEmCE088EY899hjWrFmDe+65Z0zHNWqiNDw8bP2Sent7sXLlSmy//faYN28eHnrooTEdRBttGI+cyeEglsXd6PJjrKmXCxNwbtut0aXbVJgCxtFfjVAKUzAqkGYMjApLkkq6xTappLLYdutaYnUzHSzGBGsgOYhUeuhlar2uBlGxT1S1SEggbFBEqpu4KteGRKIuCYQEYskQgFs7ANtCc7VBTrXENU1MJAOFKJgsMqKIldnW7M81lWx0uc6PP29n1YXvhNw2Vo7yfZh1GqtLhXN3vnld7RQHsYTTaq/gVgiLyW1hg4+SS5LUPnKCZUKI21WkNl5v2NLE3L/97W9xyy23YJ999hnzPubOnYtHHnkEl156KRhjGB4exgc/+EF88YtfxNSpUze8gxYYNVHaYYcd8OSTT2LmzJnYddddcfnll2PmzJm47LLLxnwQbby+cfobfoWTHvk3AMBwFqLLi7Gi3omyl6Ivyc0LDUzOW6MjNwAM1VWLp1b3UQkThF6GwOMFI8kpJUWG5nU+D0ARJJdcTPdVSrW5sfewmr1Bd9LEjv+rKlEDSTIxJboFByhSNayn9Myk26BuRUUkRSx9JabWPkpFHVBmJ91S6RX0SKwg7GZ2f2aZ2t74MJHCNeRSESDTEhMyN2RU5yGadEEm8iS3EuAFQbf63GYio44rK1ggNBIuV8DdqoXnkjiXvEU0RV36+PT2f27apo022nhtYfr06RvtEL5kyRJMnz69pa/jkiVLsM0224x6n2PSKC1bppLjv/Wtb+Hmm2/GNttsg0suuQRnn332qA+gjTZO/8dhiGiKThZjStiPuvDQ7desNUDAuLUCSB2XbkaF1S5lnNk2XOBzBD5HKhgYVYQqYBkSzrB950p0eTF278qnH8wNeqI3iIneICKaIqIpUjCbHUaJRA+tF/RIPmShzVZ47oi33SBcpQ0qehQZsbV5bRDLALEMwIi0JMMQHldzZM7BrRI16o4azTkZKRIhSvLJN/PI31PX3lynkKZNIm+To9Yo+G6lXTLvC31d8mnA3LW9FVlyj8uQNi5pmyS18fqF3ASPzQjf+973cOKJJ2Lx4sVj3sesWbOwcuXKpuWrV6/GrFmzxrTPUVeUPvaxj9nnu+22GxYvXox//vOf2GabbTBhwoQxHUQbbQB5+81F2UsxlGpdj7YGMO22RGfDuYaSkZdXRbgg4IIg9DOkgmF+74vgINiupETbxihRSGpDbiOSIBY+pnh5wG0qKXpovaBJqhAAMDlp+bdNIqWddjNC7twOQCJBXvkx1gAc1OqG8s/09PRbnnFnz6vFBFtjXEdAssIkGFCsyhniFNIUdeE3BNwWSVQqc8JYL2imPEQkK5CaRo0SbKWOrLNSFNIUFEVy5B6LOS8Xptr3qe3vbtpnG228XrCltd4+/vGPo1qtYvbs2SiXy02BtmvWrFnHljnW5cA9NDRUiF4bDUZNlBpRLpdHrEZvo41WOP0Nv8KZ/zjUvu4Nhgs6pYhliLkH38l0q3MPTMeOGDRGlXhM2orTzK416E9LeHP3s5YcmUmzid4gqiJAJ42RSs9mtxl00sS2l1JJUCYCif6ogBDbbmMEiKWqkMQFPVCxiqTsAUqgkE2Gkvk6GWKp3KeNmWQjWQKKXkm0SSslCrokl2ABiqwph2vVFlsXWWJQJM7dv2qlsQIRU0SS28k1F42BukDRXNJdP/djygN73WMG2gSpjTa2RFx00UVj3vb4448HoKbcTj311IJFAOccf/3rX7HrrruOad8jIkrmAEaCCy64YEwH0kYbgNIoASjolKqZtgvQN33jqWRgCJPro2SwTedaNMI4TjNI9HpKrG0yxoyhZCx9jKdKJBw4LawydSa8pKogMc0BUltBInoqTD13EYCjT5QQEI5Yesr0UQagekrNJU6+NoT0SdYk4jYwVShDYgzBSfS+CwaUznaGdJkIEJ9khbaWad0V2l0yr0Cp9bQeSTjaI3gos3qhgmSJkxOw28qVG1g/STKk8Es7jj79u402tkhsYVNvRx555Ji3XbhwIQBVUXr00UcRBPkwSRAE2GWXXXDCCSeMad8jIkrmADaEsQbOtdGGTzNUeYgev4rVaQUAMD4cwktxFwLGkei2m7mB+lTHlTAdV0I5BuoRwBlC3X7buiNvnwlJML/r+cIkVieNLdGI4WO6Nj/kkmI8GwYHQaQFy5ERTusvFkbUw3fE2z4BYm0FYDLdfCJR1bqqAS2cdsNtXTsAAAgILzhxBw3kya4v8wnARrhkqdFHyYVpv5l9FDVWSgNEkYu3TQUopClSyVAmiapI0bzdmQoPVR7azzOapTKtg0vfBuS6+2skTcI5f7OOqSR9doe7ms6jjTZer9gSWm8DAwNWwD0wMLDeddcn9L7jjjsAAEcffTQuvvjijRaFuxgRUTIH0EYbLyfKrI7VaSfKLMXKegeA/KbpRplELLMVEU/fSIfSAN1RDXGmbupmwi0TDDt2qhiSKg/tTXmCrybfTOvIaF6qMsRENoBYerbl1kO1zqZBuB0QAgFVVQJyJ25fT7yZVl1EOFaLSOmQdCTHoDB5dqIw6caIBCNS2QEQYUXchnAY8TaIqiYJSQpkyeiTjCeTed0K5hoGJEMivYIQm0HYfRti5F4v+zOjSaGNGTlj/R0st1QQkiAiaSG82JyXqRq5BCnfjqJTR8S0RdtttLHlYdy4cVi2bBkmTZqEnp6elgUXozsaSfLHj370o01+jButUWqjjU2Bk+f+Dmf+41B0sRpWpxX0+FWsSSro8OqIuSI/mY7k8Braa5mg6PATDCYhQpaTgr4kwm7jnldTdJ662ZrWjjFBdJetzjqwXbAcXFL06Jt8RARiSWwsCaAIkouAECRSFtahAOr6xj+sRc99mhy5FSL3OdNu3Pa5M+JvdEqmUjMswjyepEHobCpJjZ5I60LjRJyLRiLWCJ9w1CVFRLKmCpFb9TLHas/VuYSuS7i5HhFJc8sGSduVpDbaaIUtoPV2++23o7e3F8DmW5RpE6U2Nhuc9oZf45RHPogOVsfarIxOP7aaJSB30naRCCViHkqDgrg75QzdYYwnByfjjT1LrE6nysO8VeS0fGLpY3bwEqoywEQ2pCfdFIFyaQgjxSk3t8rESLE1VyYSfYJp36QAEUmtJ5LfEEjbiJwkZRjkeeYRd7Le7Oc2OGw37avFtFl+zHlry1S76sKHQNFXqXHs30VI06ZWoBsxY8hWY3XLHJc5H9PiM8S1rUdqo40NY3Non20M9ttvP/t81qxZmD59elNVSUqJpUuXvtKHZjFqH6U22ng5UWYJyiwpLvMSeJTDo7mfknlELEMiGALGUfbyto+v40926HwJQzy0E1qttDpVEWCK14dhEaKH1pBKhk6aNU1qmSoIQ3HSzWS7ua9TqfRKkSZJgOOcDW61UWbaDGhNcoSkqNC6zXQzvkuGcDT6HrWqIjX6IjV9ht632WejK7aQROnBnH2bYzbkyfw8GuFWk8z0nDl304oEVHyMsQowx9wmSW20sQFIufGPzQjr8kBas2bNmD2QNgXaRKmNzRLTwj4ISVBiCYQk8IjQbTdeeMS8WBTtDBSpqHMPAeV4rH8qur1aQTtjjA6FpOhlw+hlw+jjFUxkg0gkQw+tQ8jcddvQA1Mt4pC2qsQKI/vqYf5TMSghd4Xkn+3qlIwWZ32RINRZn0IWhM+N2qNGQ8ZGgtRyWUO1yd1nKj37aEW2hDbQNCSqYHCpDSpdH6RCy1H46ONlpJKhPyuDS1ogaMfu+Id1XpM22mhjy8TL4YG0KdBuvbXxiuOhJbmF/LCutrxt5qLCOv1ZCV1ejL60jBJLrfC4znOHagOTB5eAIWIZOv28AjOv+0X0ZyUIUJSoMpNkOrNskj9gW24ArC4pAUUnMQGxqjok9HMgJ0xGqxQRgmEJcMDqlIwtQEQ4BmSgn6cqBJcIrTFqXf0JCAcDxwAvfjG4ppSumaQbv2LgiqUb32v6TMdfyRCnkKZ2QtCQSiAndY2BuVxSO5mmthGF51V9vhzUttgGnfMrs7q+bgwn7HTLOo+1jTbayLElTL0BL68H0qbAa7qidOmll2L+/Pno6upCV1cX9t57b/z+978vrPPEE0/g0EMPRXd3Nzo7O7HXXnthyZIlr9IRt+GSJBd/XjwHAHDKzr/BII+UE7dkqHh1eJQjoBkoJEoshUfzqopHBTwq0BPGCBiHAEEmKYQkmFIawMqkA6HWJNX0jZ9LijJNMMQj23LrZVXE0kMP5YUpt1gSPeavPs+QJlfQbUwmDUlSpEoilgyxJTOKHPngduzfwCUVFVqHTzIkkiGiKZiuzHBJi+aRWtjeyo+IaU8mv+Ez1qdlcvdv1ivTRK9LbBvSmHUKSW21yY0pcclTVYSoihAvpd12W9Ni689KahJOx8Woa9smSW20MSpsIREmCxcuxMKFC60Hknm9cOFC/POf/8Quu+yC//mf/3nVju81XVHaeuutce6552LOHHWTvfrqq3HYYYdh4cKF2HnnnfH0009jn332wTHHHIMzzjgD3d3deOKJJ17VEt7rEYYcKSNDhVbC4LsWbw8AOHf+v3Di3z+shcVqbL3Gg8K6Ac0Qcx8BzTCUKoG0sQoAUa2fNfUKZlZUwG2JJlZrU2YJUsmwdbAGg6KEmf4qVEWAGd6g3X/qVKxMC85tqxkMS/WBzAnBVefnECltyBiRFIMysk7YgZ5mY7o6YwiR0SGZGJPG9plBox6pOFVWfM8lQeurLpltTf5cJ42dqBVXoO06jStCVhUhyrQOBoE1XHlh9WdllGmCQR7ZKmBV/yzNJCKgph7baKON1ydeTg+kTQEi5Wam5tpI9Pb24rzzzsMxxxyDj370o/B9Hz/5yU/GvL+BgQF0d3ejv79/s/vhbU64ffEOAIADZj4JAHh06dYAVAvI3GBdwbFLlBITkqrf38obwnZbv4jjHv4oAKAucpNFc4OuacuAvkRNhAU63iTOcu4/IRpGj6/ctU1VydzUp4XKgdu03Xbwcwfvqv6MsiYbjQ0yQxGsdsnxTzLLDVEybbdBPe1m/JMAFLLdyjpLzcBci0Qyq2Xq46oc3Uqw3Uqknh+vbCKmrgi7FcFyq1eGKNljs+Lz3JnbkCC3irU2q+j3adP17/Biu59Tdv7NOo+9jTZea3gl7hnmM970gbPg+WP/wz9LY9x/43+2728bwGu69eaCc45rrrkGw8PD2HvvvSGEwG9/+1tsv/32OPjggzFp0iTsueeeuOmmm9a7n3q9joGBgcKjjZHj8aXTLEkyUAnzAlHDuLlBLH3E0kciGbbSkSJmnZBm6PJiZ/xc5aZ5lCOTFB1+HT1BzU7KRV6GDj9Bh69e96VldLC6/bxUMkzwh1AXPqb7q5uOP9Vu2o0kqdB+cpZTOLokEDsZ5xOJYRNsKzz44EqXBIFEMksO1bqZncgzD9N+M+8P8qhlQKxZ34BCgkI2teoKbTgiCuL2RnG3G3nCiEAvGy608vI8OGnjS/5/e2ceZ0V5pf/nfevWXXoXaGgaGhpZFDRIcIWMgooymDEkzmTiEpdM3KKIihijMZHERJ2MGfVnEk3GBJeoOIlLVBQjSSAaXBCEQUB2aFZZm266uffWrTq/P6re91bdhW7o7bacr5/62LfWt6qrux/OOe9zJAhxx0SjHdWL5UhYnl1DwgnBgUSCTBxjuuf7/gmvs0himLbwOUm9FTrdXigtW7YMJSUliEQiuP766/Hyyy9jxIgR2LlzJw4cOIAHHngA//zP/4w///nP+NrXvoaLLroI8+fnN6+7//77UV5erpeamppOvJvuyzm1q1BlHAisS/frErBI4gs1W7zPUtfY2BAolglYMGDBwBqrB4b235b3Og5JmF7PMLeIO4L6ZEync/z+PRVmMyrMZhywI0iQ6w1UHjqIZieM/mFXJCUphNpQPRIkkCABh4LCxy+Q1L0oTJG2AzBAOkVnCqCJXP+kOIX0TLeosHSkCHAFhypwjmZMyfeLnGYnorf7a41yRZFUEXtmXze1LjNilKunmn8Mar9SGYcBB1FhecI3o+0I3Hojld7MheVIVIXrAYBrkRiG6TZ0+9RbMplEXV0d6uvr8eKLL+KJJ57A/PnzUVFRgX79+uGSSy7Bc889p/f/yle+guLiYjz//PM5z5dIJJBIpNMgDQ0NqKmp4dBkK1mxuR8AwPL+wJ40YLOuURo9IFhEv7CuFgBw6oCNAIDX1o/0jjVw0eCP8d2lXwcAXZ+013JTT8pJem/C/VwWjiPpBHuglYTc72GPcJO7TyjdTuPE2BYdFRkZ3h4YU0QE25E4BMiMv/t+B25/ZElFk5od94t63dvNTbE1UVin0VS0qNhLuZlICw8HQvd0a9Ypu6h3nLveP41f6pRfcKCHMppU+FNwQMtpPXVOiww9NpVC9Bdlqxlt6vtRG90NALjhuMJ03mWY9qIzU2+nTW576u3DP3HqrSW6dTE34HYFVsXcp5xyChYuXIhHHnkEjz76KEKhEEaMGBHYf/jw4Xj33Xfzni8SiSASieTdzhyaETVbs9ZlCiSFEkiKC4/9P7y07ov6889O+gNuXXIxQtLGQdtEaSjt1B23TRSF0r3DwjKlv44Z7h/skFcMXhaKI+GEcHJx+noOSYyIbEcSEmGo1hsUqC+yVZG2758Sap9cKNuAiCDsd9y2JQ1euq3Zq1UyRUq7c2eKJCVIHK+nW5zCiEoL9XZRoNdbkoI/tg6ETrmpz/7zuWPLLZrUeZWgcWBk1S3ZJNMRJO+cutEtXP8jNeW/SCaw3y5Cqa/PW1+zHgDwH8Py/9wxDHMEtNU0snvHSTqNbp96y4SIkEgkEA6Hceqpp2LVqlWB7atXr8bAgQO7aHRMa/nT+lEAgIdGzULKawPikETMsHTvt6gniBySWiSFhAPLMSA97x8VSTq1ZH3g/MeHd8AhERBJQFokJREsWAbcyJLtS8cFZoH5zp3wGuHGvZltFtKNZgFXIIU9w8mosGAIJ2AXoIgK1/dJ+ROpWXGAG1lS4sgUdiCtptYfqoebQqVAc633Y5ERiFhFpaXtCaLCQrnRrA0jy41mvbBIYhimu9OtI0p33XUXJk2ahJqaGjQ2NmLWrFmYN28e5syZAwC4/fbb8Y1vfANnnXUWzj77bMyZMwevvfYa5s2b17UDZ/JSbxejp1fQvWDTsfjDvtMAT2hEZAoNqSiKQkkkHXddWKZTUCmSSJKBUi/t1ifiFuKPLHIjWlI4GGbuBOD6GgHwPJLcWiknQy+oiJI/spSZhrMhArPd3HMT9nhNa5VpoylsnYJT6bcikYBNUoskAwTp2QTUO25aUaXo/LPWlOCyPK8lAJBw4MA1jtT1R2q2YZ5okh2ol6J0VMnXm81fQJ7PjkBFm+JkwobUkbKIJ/AuH/p+zuszDNM2Pi+Gk4VOtxZKn332GS6//HJs374d5eXlGDlyJObMmYPzzjsPAPC1r30Njz/+OO6//35MnToVxx13HF588UX80z/9UxePnDkUe1IlOD6SLugOSVun3EzPDDLpGEj5Ikm9wge87e4f72NCbm3S8OhWLQgyRVLU+39cewy550r6BETa2sCNPuUSS5YnliTS1gKWT5wYILeoG44XCXJ7tTkQgaJoCTXTTqJMxrHTLkVUWroWCHDTaSr1VpxhKaCOd2cGhgK2ALmEzqFwbR0kLBg6opWkkK6NkiBIYQeiTKUy7s1edCNlFoU4ksQwHUlbZ66xUGoV3b6Yu6NhH6XOR3kyvXvA/f+OZBlSjvJa8vdWc7+uMF3jQuWtNLzYLdD2T/8fGnYbLSoxlJlq0+dEOqrix/RNic9X3J3weSf5hZKqSVIpOBXhCYuUFkpGxm+sJuW/ZMd0JMrvu6Qokgk9k84vtNx7M/RxupZLNdPN0dTWf9/+aJO/NQmAQIpPfT9U9CjhjfXqYe9kjZVhjgY6s5j7jC/f2+Zi7vdn/4D/vrXA565Gien+bExWYs7+kThgRzCu5FMA0AXdCTsEyzFgOQYckigxkkg5BnYmStGYiuK4os+yzjfY3O01bs0vklTNkUUSFslA/ZG7r9THO5Re/I7cEa9tiXsNR0+v19Pz4QREknteQ59XwoGEAxsCUWHpfdXXprC1tUKRTGiTSnUckC2SVPTJIRGYKWeI3A7d/tlvKgIVJzPg8RTYX4tEE4YgFMkkiySGYT5XsFBiCpLjY9vx5fKlAIBfjf49IjKFXpED+g+58iA6YIdxwA4jLFPo4blwOyQxNLIDUWlhaHgXpCBEhe35/+QWSe664I9DEoZe/AXPSlSp4m7ArU9SEaUwbE+YuIXcfoGTiQQhSUZA6BieYSQAPbMsKt3GwGGRynDSJr245wvWDbnPyt3mj0ip80tBOcWRPr/noq5cwdWYVTTJNce09ey5S4d8kHWPDMN0EGrWW1sWpkVYKDEFxxeiW1AZCjqiR2QKTakIIjIFhwRSjoGITCEiU0g5hk7NrT9YiZNimxAVFmpC9QCgZ7aplJm/aNufanMLt11B4y+eDnvT95NIR5pMLS4ocJ6osLWwipPpuld7vdtyFVW74sf2YkIy41yWW7At3N50/llvzU5Ei6NMLDL0+MMipdNpFoXQaMcCfd+UQaRDImf/PTUOhyT2pkp0BMnw2QSoiNaVQxfkPJ5hmI5BFXO3ZWFahoUSUxAsrhuAxXUD8MGmQXpdQ0aPsR7hJjgQiBgpVJgHYQon0Cz3rPJPcVb5p9hjl6Cf0YgwnLwiSc1mA4A4hZCEgTiFAs7Srn1AcNq+fwacQ25kSp1HRZiKhQWLJEyR8mbV2VneR/7p/ZnnB1wh4niu5SrV5hdaUWlpAZZ26qaA87e+jiA90y6TTIdtNZNORZqUcFRRNJVGVMeansjjmW0Mc3Tw97//HRdeeCGqq6shhMhqC0ZEmDFjBqqrqxGLxTB+/HgsX768awbbTrBQYtqNPdv6Y8+2/i3v6EMJpEyqQg0ok/HAunorhpCwYZPQKTfATR/9U8Ua7E2VYJi5E8PMnZACejEFZRlHqpltcQo6egdblNhZESclsPzpN4WqWWoiE6Y388xAdkNawE2xNVPEqxXK0SqFpJeWS88gU2MyhKMjOUkyIL3ecP5xp8fkCj/VTw5wo1H+3m25UoOqnkntUySTgYJzjiQxTAHQBb3empqacNJJJ+EXv/hFzu0/+9nP8N///d/4xS9+gYULF6KqqgrnnXceGhsbD/9iBUK3tgdguje5BBKQFi1RYQWax1aYBwOz0XYlSyCFgxNKtqHRieLMotWIUwiVRlBgZRZmZ4qkzNokNwqULna2AUS96JAic5aaEmFxMhCG7YmltAu331FbRX1USk2CsnqwAW5UqVgkdH2QaxXgiUO4USI3spT+MTaF7c5y8wSaKeyAvYDlCau9djEqQ40whIMmTzipZxt3TESlpcesxFICJvamStDX3AeA/ZEYpqvpCh+lSZMmYdKkSTm3EREefvhhfP/738dFF10EAHjqqafQp08fPPfcc7juuuuOfLBdCEeUmDbj7BgGZ8cw/flwo0p+/NEQv0hKkYFURmSmMnwAI0u2wgDh1NgGxMlEkbTQREbOF1uKtEhyZ7E5gdlwCjf6lJ4B5xY0Sx2dydxfnVvNeGvKMJaUXu1Telq9mk0W1uLJ34BW4a81iookbBKIeDPgLDJ0ZMlfgK0KtlWhtT9KpM6nImNuzZGDUhkUoKoWSoK8Jrju+UuMOMqNZjQ7ERZJDPM5oqGhIbD4+50eDhs2bMCOHTtw/vnn63WRSATjxo3DggXdN/LMQolpN3pWb9Ffb9ta3erj1B9wvzCwvT/0mTU3DqROG51cvBHV5j6Mjm0EAFQaTTBAKPXEljrSTX8JWL7CZX9KLFekKEmGFi5xCuWcseaOXSBO0ltCnrFkuiYo7JkyZhZzS7+4ITNtIZBjCr5Ki7kz39z/K5GUHrdnounNjvMT8eqZlABqtKN61qC/iFxdK+0gbuixGJ6gKpIJXHfc/JzPgmGYTsbvVXKkC4CamhqUl5fr5f777z+i4ezYsQMA0KdPn8D6Pn366G3dEU69Me2Gs2MYtqQEKg1XqBzcPgixvhvy7u//Q68dsHX7jdzCpMRLqw2K7EKcTNSYe2BDoKdshkUSpb6WJkpuWJ4wSnp9zTJTbX5cL6X0j4XjFWUDrl1AZgpO0exFcpTIUCS91Jpan5licyC9WiPX9Vql4gDo46LCQqMTCxznT62pfQw4iJOp02+Am/JrtGMwhY1GO+pdU2Bfqhi9Qtk1A/72KEUyCQC6TYoDyfVIDFNItJMz9+bNmwOGk21tDC9E8HckEWWt605wRIlpM7JqdeDzLtvAMdL9QWvaPhCbt/bF5q19A/ssrKvVX+cTSaZIYVztasz4ZDJKjDgkHDTbYQwI74FNElWhelhkoKd0/ZOUSFICSXrnVrPRVEots8Dan0pz+5UJJMlwo0oZHkv+mXEqNZdLJKnjLbiLP1KUFjtBk8jMmXHKN8nx+qfZXlG2f+aZW4/keGOVOmqkCrQBoNQ4qGezWb5IGQAtnkp9dV1+byV1LlPYLJIY5nNKWVlZYDlSoVRVVQUAWdGjnTt3ZkWZuhMslJh2QVatxg77ACoNd6bYSsuGk2FeuGJzP6zY3A9L62rcYwRhj1OMeqcIFoXgeL3F3GLqVNY1iowkBkT2oNkJo8bcAwlCD6MZSRgokv6eaS4O0mk3QIkmCs4u82abNTkRNDkRXf8TECNkwiaJuOOKJGUnYEOiyUnbEyh0I1vk9iVS+KNmwa89uwFv1psSQiqyo0i7ZVPAU8m/X5JCSFIIJUYcNgSKjIQWibtTpTr6ZJPUESSFKVKuxQEJNpJkmAJEoI0+Su08nkGDBqGqqgpvv/22XpdMJjF//nyMHTu2na/WeXDqjWk3qvu5jWyr4UaMVlhAjZHMuW8YNrba5QDcXmhNiMAhmWU0CQC9zeC6fuY+NFME1Z6hZIX3B972mtMC6aiSK7pIN75VkSHlJO1O5w/DEE5W2ky5Uqti7LCw9XlA6YiQihwBvh5qGZ+BdNrN8NqbSATrjKRwhY1bhJ0+xqKQe20vchURlu6pJkF6llomyrAScC0BoiKlZ82pY7ZbFehr1us0HuDOOoxK9xrcjoRhCpi2umsfwbEHDhzA2rVr9ecNGzZgyZIl6NGjBwYMGIBbbrkF9913H4YOHYqhQ4fivvvuQ1FRES699NIjH2cXw0KJ6XBMCOx30g1lTWFjR6oIpSKOjVYvAG7RMwDsSpWhwmiCRQYmDloROE+t19i2wku1ZRLV6SI3qpQZUfJje/VKzU5YiyXAnammoll+ewC3/icUmJWnJFCmwFIiyfKiQfqaFCyczsRfcO0v6DZFyldzZAfqkGykzSejwtJjDqQWhYNS4yD2pkoAuGm2nclSHLRN9A43YneqVNcrFcmkjmixSGKYwqYr7AE++ugjnH322frztGnTAABXXnklnnzySXz3u9/FwYMHccMNN2Dfvn04/fTT8ec//xmlpaVHPtAuRhBxs5dD0RmdoD9vLNh0LAC3MSwAlAk34tPgiZGoJ0R22cUAgFKZwPpkJQDoiNI5tavw2vqRANyC5Lh3bA95ICAiKrzGsEUZM8UUFkTA4whI10SptFmzd251DT8BI0cvzuN4bttA/giSO2Msw3VbpwDTLURyoc6dbhMS0seqMSrhpO0DpIWocKNKSV8UyT3G3TeRcczm+DEAgGNju1FueHVeXq0Sp9oY5sjojL8Z6hr/dM4MhELRFvfPRyoVx7t/ncF/31qAa5SYDkOluRoojLpUOertGOrtGHakSmGRRIU8iHNqVwEAjg3vQo25R8/w+uvG4wLnioqkjiTZJFEqkyiVSUSFg6gIVkM5vgUIehyli7MNHZ1RtUAKVYjt7pderwqz1fGqlskfQXJ80+ttEnpRxdZAtkDKdMX2T8tXgsjw2okoh23V4sQvGtV1VXSuSOb2QjGFjf2pGMpCccQMC9uT5YhKi0USw3Q3usCZ+2iEU29Mu1MhE9p0UdXEhIWdNctLceqAjQCA19aPDGwrlunCYxWFcuAWHccphAqZDNQlKTKLueMkvZYiUrcgMYWNeicW8COScHQURgq3gNr1PzJ16xAAAVHjjyD5t/n3cShYtO1P7alebUpkKXHjr22ySejzOSQRFRaanIi2CABcQVUkE+6YveJu9eyjwsJ+z91beveQcNwf/RFF2/R1LDJ4ZhvDdCMEEUQbkkJtOfZogiNKTIdQLCy3KFiki4x32aXYZbt56kYnitED6vS2l9Z9EQD0DK89dgkMEKIipUUSAC+iIlEmknAIWSLJj0TaQylzxptFBopF0heFSQVafTgk4ZB0+7X5psqrxaIQLAohTqZnKSCz/JfUkgsVVco8rtmJ5KxjUoLKFCkkydA2AXq7cJAgMyvdp4RgkUx4HlFuAXttdA+Gxj7T+8Udk0USwzBMDjiixLQ7I2q26q8X1tWiyKtR2uPVJO2xi7HZ6okln04AAFSb+2DAEy8yEeiL5kdFYkplEklIFAsbDnKr/czqnzAcJJGOLPlxp/lHXKfqjG0qApNLvKi0WOC6/kiQii559UWGIB09MkXKjVZBBq5r+iJn6hiVBnR09Cr9bDJdvJudMEplHLYXeWt2wohKC3tTJdovyiIDEW+WnEUGphz/16z7YBimG+CvMTjS45kW4YgS06GcOmCjTq3VmPsw2NyNweburP1Uiw5lmggADU5Ue/kArkCIehGlMJycs9mAoDWA6u+WRLpXG+DW6TQ4UZiwdeNay2tVohbtyE1GoN7IJqFFUiAN5zvWf4w7pmBKTl1LIYV/dlz6vuKOqSNbmbVM0hdNU5EuXQjuWQ+ozz1CB7RnlJrhZkOySGKYboxKvbVlYVqGI0pMp6DE0hsbTkSTE0G1uQ/FXj2OipC4QsiNPhXLBEykp8or0eLWJrlppKiO9gQVf6Y1QBgObJ+BpAFCvRND2BNLUWGh3qvhUakrlRpTUR9VT+Qfr78eyc4r2oJF2oBbFJ520E6LQBVtUp5ISTIghRMo6AbcGW6q/kjVMmUWdSs3bSWWdnnmkioVWirj+I9h7+YcM8MwDJOGI0pMp/H2huEA4KXXbLfGxzFhk0CFbNaz2iwyfFPxgzU8UZFC3Kuz8ZMZQc5sXwK4dgVNZKKJTN3ANixSaHRiMAR510r7D6nr5qonChZ0t87fVkV91D2qa6iUmkrDqVRbWNhwSOpZbIpmnxt4ZuotfV63ED0qLDTarhhUztvNTphFEsN8HuBZb50CR5SYTsWEjb22a3yYrjlK9xlTqSILrlhSM+VskojKlJui01EY13VbkRlZMkFI+NNY5Da13WMXQ4LQTCrllt1qxL1OUn8NICBo9H55RJKqQ5JwsuqblFhy78mN8Cgx5vjWqd5uKjVok/BMLElHx/znUqjn2ei4/ipRaekGu1IQbjjubznHzDBMN6MLnLmPRjiixHQazRRBM0UQlVZWLzcVRTFAOvLiIL240RWhBUVS1/oEhYo/vmL5Um2uJYCDJifstvaAoR2vo8IKCA3X5br1IkmNMX18OpWYIDOrES2Q7tOWeU4VUZJwXPdtnwmmOq+/F5xqfqvOZwq35ipJBiLC0ik4wLUJYJHEMAxzeHBEiekUXlh7KqKeHlD+REA6+uH2NxP667gnMLTJpEqfwTWyjApb93GzIXQqLlP5S5G2CGgiE1GZwl67CAYcHalR2CRRahz0rpc9+82fAvRHkqRXW6QEi8I/fd//tb8NSqb5pENpU0m9jyBdp5R5TjU7MOnVOKmWJg5koH0Kp9oY5vNHV7QwORrhiBLT4byw9lQA7gwuFTlSs9viZGpxERWWNlO0SaJYZDfUjVPIK9J2zSMdQqBeyQFgeFrC9G13i7/dprBRn/2AKVJ6DMUyEZjer7yLMv2QMtNtToZAUl/LFgoAVDRIIYUDKRxtGOk+k6R24s6MTNkZY9XnpLRIknDYH4lhPq+o1FtbFqZFOKLEdCjPrT0d2RVA0DPeAHeWVrqQO4QyGfcZQ6ZfUVWMLD0RobyUcmEIwCLAFK4ztwFCo5d22+O4fk6msNHoxDxx4bYZKc5o+9GaeiR/HZKapWcIxxMs6V9ESuy4BpDuvaQFTrARLwAd8fI7hqtr6HPCyYpi+a95+dD3c46ZYZjuj3DcpS3HMy3DESWmTby2fqRuXpuJcttWKJNFJUaKRRLFIomosLRDtilSWiTZELrvmoSDuBNCGLbn+O1oewA/EoBN7qJmvqn0XJG00OTV/CjRoiI2js/HKeucwvHSav7IVbAuSZ0TCM5uU6JJbTOF7RZWZ/gw+X2VkmQg7pgICxsJMpGgtLFlppdSrmuq87FIYhiGaTscUWJazfyNwwCkC6/jvj/gL637oo7+fGPIwsBxyrzR9oqyLQrpCJKSG8oGQGbU7BjCcVNscJvoAkCRVKaK2WFj/8w35aXUpMfrjk+l90xho9mJaKHW7K2z4Ea8bK94XI0/XSck9dgVKqqkIklq7Jn4/Y1coWZl7QO44kyNJ+2jlD63OyvP8u4r3YbFHZ/A1cPeyXlehmE+R/Cst06BI0pMq1AeSLnInF7/zJoz9NdRkdRppaiwvNlcKTRRGPma5JqwYYBggLRFgBJJUWFn1SUpJLKNJ5UxpXLkLpUJNDoxfU23B5r0Ij2ZIi1tPql6vuVqZZKJP4IUHJ+j03d+80eFQ+kmuXHH9PaXWlgBrhhSi19s+c/FIolhjhLYR6lT4IgS0yJKJCXJ0LOuVDG0imZk9kh7bu3pMEV6nUq3qRRRWKTQTG5fMnVspnBSn8u8Y6NePZKZY6pGPvnS7KRFXBg29jhFKJUHUW8Xwfaqp6Ii6blre+aXRrMeh+q15s5ECwVEi39mmdvHzc4SjX7U/jYJbSLp7/OmUnxKlPmNJQG3GD7tsaR6w6VrtFggMQzDtD8slJicfLBpEACg3olpEWJ5wsLvLq2m2as//EkKOlvr1iO+BrJKNJla+AQ9lQw4MIW/hYjQIikf/pSbmvXW7KSLr5Pe2EtlAjtSZXrGnboG4E6r90dmVDot7BV7GyKJRieWcd10fzWbBCTcWWtKMGVGqfR4yMgSS0owGXB0G5K4487Ii0orqw7JL5J4+j/DHH20tV8b93prHSyUmCxeWHsqatO6xtcjTRU1p/uPKUPEpFcQDbjprExsSC2QonqGl0CcTJR661V6TGb0W1MiKZdvksL0NJGd8XMfFTbiZCAMGzs9R3A1TsdfcA0nK1qTnsmWPQMvHdFJBWbDqXSdX8RkzpYLFIVTdizMX/ulrmUKG9In7vyCjkUSwxylcI1Sp8A1SkyAdzYOAQBstHphj1MMGxJJCiHpm5Xljw4B8CIoIS0emp0I4o4ZWHIVLas6pGYnnCWSwl6dkj+SZGoBFfzh9s90g+/riCAkISEFocEr2vY7ciuUAIo7ptt7LSP1F/Q18lqOeHVI/polI0dK0IAT6NWWax8gPZtN1UupZxmVlncdoSN4fgsDFkkMwzAdCwslJovq0D63yNkrLg6LVGAaukJ1vFc9ydR2i4zAlHZ/pMZNK4V0c5JMHBIIQ6Xk0tuVSDJBumjbX7xt+II2hvB8lLxC7jiFEJUpWHALn/0iyRQpPSPP9mqI8qXLotLSVgX+NFiWTYBXkK0iYtJLnflFkr/RrlsfJQKLel4SDiLC0kK11Eg7mbNIYpijHIJbd3CkCweUWgULJSbAmbVrsdcp8abrG9r00IATKCBWne4Bt8t9WNgolgmYIoWIsBDxIi8qmqJakjQ5ERR5jtsWDK/+yN03KlKIihSkIB1Zcq+ddtj2SxgliHJ9trz9LRIoFhaanbD32fDuIRXwR1Ljz5ytpoqv1VIsE9oGQDW9VWiB4z0b9XxypdeU5UBUJPMaWbr3EUKzE4EBBz2NA/r5s9s2wzCqRqktC9MyLJSYLCYfu0Q3Zc2VKlIFzmFhIyotFMkEimQCUWmhzIijWCZQLBPoGXL/sKtCZYtC6Gk0aaERFRYq5MFA41Y//lokFVHKFUEC0uk2mwADAlEhEPcEinLkVoXmxTLhptgobfAIBGuQ3Gsos0jSiw2pa7D8ppP56plkICqW0pEmmwSanAgsCrkNf30/iur5NDpRNDpR9AgdQA/vWRpwcOmQD3J81xiGYZiOgIu5mZxceOz/4Y0NJ8IhiTiFERVJhL0Ulb+Ra2ZTVzXNXlFqHNRRqZ7GgUAEqdj7v9+JuzhjBlymQAKyRVKWaAIhTm7hd7NjICpSqPdmq0kQ4mSiSCbQ7ETgkNSpwXRNkj9KJAMtSjLFlH8/VejuEDwbgZB+Pv6okvRcxVXvO7/YUlE7Neut1POPArKNPBmGOcohtLGYu91G8rmGhRJzSJR/kBJL7p/14E+XmhUnQbp7vUJFTPxO3DZJ9DQOetv9fcsIcTJ0AbcUyjAyV5G0gO2NQxVx+wVTVBDqnaCnUVjYiFMIYZFCgxNzG9DqGis1xT93g1tlOlksE2iwo9njEem6JdUexX98ZtRKrbfI0NdWtVOqr5uKIsUdk9uRMAyTDc966xRYKDF5Mb2iagvKXNIVS/7Gq+7UelfkJMmACVv7LQGu0CoV6QJkAOgp3c9JKN8g8vkmeREkocZAbjrNX4uk7QpcsZQZUXLHmp5F1+iEYYoUGh1X4CQppNuWqLYq+tw+YQSke7HZGXVG/tqkdETIvaaj66Dc6fxqXyWSlJGkFKQdtpWBZ8ITS+U+00uuR2IYJicOgPwljq07nmkRrlFi8nLeoJUAgCKR0LPBJEiLpHBGXVFY2Lr2SNXiKJEEuGKjIsNjSRVuK48kKdIiKSoou2Bbp+nIXXy2AOnrqOPdGW+mSBs4uuNM6TornRrzCaJ8qUVV2O2fnu+vLcqss1ItRhJk6rojBwJRaWnRlKQQGu0YEo6pRVK1uU+PhUUSwzBM19KthdJjjz2GkSNHoqysDGVlZRgzZgzefPPNnPted911EELg4Ycf7txBdnPOG7QShkh798TJ1IXcADyvI0tPs48KCyZsFImknt2miqJVuk3VJIXhaC+lMNzaHkW+dFvm134h5RdNJgiNTsjrmxZyI11epEfNOFMoR201VjvHj4WKNKkZf1FpHbLvm19Q+vEXriccE81OGLbnkWSRgV6hBgBuwTlP/2cY5lDwrLfOoVsLpf79++OBBx7ARx99hI8++gjnnHMOJk+ejOXLlwf2e+WVV/DBBx+gurq6i0bavTmndhWiwkJP40BWiw9Vc6QEjwHSkSVDOF7UhgKRJBU5ApTQcgLrVLrNjwkReFmTFNzHL6L2OyHsd0JafMTJ9FJgacdvlUpTs/osMrLSbv793X3TLU0ckrrJb2Ccngjy122p8/vpEToAKRwtnCLSwqDITu/eDC7cZhimZVSNUlsWpkW6tVC68MILccEFF2DYsGEYNmwYfvrTn6KkpATvv58ufN26dSumTJmCZ599FqZpHuJsTGtRhckqnWQIR6fQ1GIKR9cbRX3RG+WJpKJHqmBbbTNzRGEMCO2PpggLoSNJSiSFhbtfqUwhCQNSEJoorFNeDoQ2eATSqTQAATds13hSzbZzI0OqXktFovwF60EvJRmIJhk+MaRQn0tlHKUyjspQIypDjfq8XLjNMAxTOHxuirlt28Yf/vAHNDU1YcyYMQAAx3Fw+eWX4/bbb8cJJ5zQqvMkEgkkEunoR0NDQ4eMt7sxduB6/HXjcXp2V5Jcl+v0LC+pC7LVTDZ/qxG13fZFfoqUIaP3OZcFgJFRqeif6ZZZxJ0k17V7r2N6s9QMFIuktgbIhel5GDmeK7ftRYrS40g7kqtCdTUTEFAz6Uy9j59M80p1PQDaaypJhj7X1wcvyjtOhmGYLHjWW6fQrSNKALBs2TKUlJQgEong+uuvx8svv4wRI0YAAP7zP/8ToVAIU6dObfX57r//fpSXl+ulpqamo4be7TindlUgtWbBCAiJuBMKTPdX+Au21RIVTiBKZPpET1gIGBBZIgkICifd280r7FZtS0plSqe6GpxoxvHZXkkqhRgWKYT90a8MmwAHIpC2i0pL92bz7+NkjFtFkFSRuylSntBMettTbCLJMMzhw6m3TqHbR5SOO+44LFmyBPX19XjxxRdx5ZVXYv78+Th48CAeeeQRLF68GEK0fv7knXfeiWnTpunPDQ0NLJZ8jKtdjfkbh2k7gCaK6AiM4zOjdA0YgWKZDIinCpndHFeJJENkR5AyZVec0jPhMvdt8n7m650wpKD0NHyQFi/+Qu2AEIKTZ70XwYLwTCQN75xuxCoqkohT2LUCcNw6KIsMSC+VZ4oUbBK6+D3d984dT5k8iImDVmQ9E4ZhGKYwEESfL0k5YcIEDB48GMOHD8e0adMgZfoPo23bkFKipqYGGzdubNX5GhoaUF5ejv3796OsrKyDRt39+GDTIADpeiUgPVVe1exEpRudUSKk1Pus6pAcBCNJhi6Aht7u/2z5irwzU3MqJbfXdrV/gxPR49Fmj56/U6abuB/TN5vPPW+6Qa07JuGdMxS4Z2VCmSDTVyjuXiez711UWlooXTT447xjYRim+9EZfzPUNc497jaEjMgRnydlJ/CXVT/nv28t0O0jSpkQERKJBC6//HJMmDAhsG3ixIm4/PLL8a1vfauLRvf54fSBG7CwrlZb4Buey7W/Lskh4aXcJMpEEg4BEd+0fyWSzBwptlwiyb1Oep9MkdTouHVQe2zVrsTR9UOZIsk/dT/gLO7VXNkQML34k99AU0WkVK2WiiwVy0S6gbDXnkS5bjdTRLc0qQw1eEXwhMnHLjnUI2YYhjkkbZ3iz/YAraNbC6W77roLkyZNQk1NDRobGzFr1izMmzcPc+bMQc+ePdGzZ8/A/qZpoqqqCscdd1wXjfjzR1SmdGpNpdtU5ERFZ6LChg2hi7eBtOCJimByzSLVBFcEPitURCnsS6caEIiTazOwx0n/60rVUCmxpGauqToi/8y29LicwPH+9RYZbo0SghGjuK+3XURYaHRikIKQcExYFEJEukXvQ8M7tFP3hcf+X67HyTAMwxQY3VooffbZZ7j88suxfft2lJeXY+TIkZgzZw7OO++8rh7aUcGpAzZicd2AtLgQQJxCXrG2m2ZTTW79kSQHrj1AqVSpOiWK8ls4GhBIUjqqZIN0JMoCwRTQvd2iMoVmJxxoq5IpjnJeI6ONih0oHJe61smfuotTOO/5ItLSXk7HR7a5YxOWdjxnGIZpEzzrrVPo1kLpt7/97WHt39q6JKb1jB5Qh8V1AwAox2tHC4li3wwyhVuEnY4kmZ40ipOaOSZgE8Em0nLEL5DcY7yeajnGExUp7LWLvPGInBElJXgye9Yp7BypwHSqLf2LRZ1XRdDCho16uwjFMqEb3B4fdQWSRQYcCC7cZhim/XAIyNHF4LCOZ1qkWwslpjAYPaAOa7a4rufNXlSnSNr6Z7BIBn8YM0WSDYIpJBwtWlyx5NYHBZve5hJJKvVWLGzssGPa58iAazjpHhdsfGsg6HvUGg8klX5zx5wuXFf7NjkRFMmE69ptWKgwmvSxLJAYhml3OKLUKbBQYtqFof23Yc2WahTJtCCRIrtnW6lwXzmdbtNNadP72d4Pr5WRJlMO3X7ShdzueZV5Y5MvJZZr6n+mMPLbB5iwdVG3e85g+5EkhbQjuTp3kxMJeDQpGwCLDBZJDMMw3RgWSkyHUSoA+MRNkXAFhymC6bZMDCFgEcGA0EJIRaH8xd1qW7MjEBU29jhRmCKFJiei65IUKs2mBJBKpSkkSBdv6/97xdtA2g7AL7RUA12VZlNoryRIXDDok1Y+LYZhmMOlraaRHFFqDd3emZspHIb23wbT69dWIQUMkRZJJSIECYGICEFCwqJgbEgGCqfdtJsSQgZc4WRTdoTJIrfJbgOFYQoHFoXcprW+86nea0ogtRaLQohTOMszSTXHtSiERjsGi0KISgtRaQV6urFIYhimQ2Fn7k6BhRLTrtT2345SaWjhYwqBEi/dZnoRpQQpI8pgqxJ1jCHcmiObsu0DZMbXRUIgThLFwkLcCXneScFAqU6rkQwsmfuo9iQ2SZ3Cs0nomWuAK550es+J6Ca79XaxPpdNHEliGIb5vMCpN6bd6Vm9Bbu29QMAlImga2wK2ek2FTlSdUpxcmCIdOG26aXiMmNBDuD5JxHqM9JfmfhnuGV+7SezWFuJoqhIwiaRcz0AVIX2o94pgiEcFkkMw3QODqFN6TOe9dYqWCgxHUJl9VakdgzRn21fqs0UUqfRHKRrkSQEEuTAgNCRI7WfRLZbN+BGlD6zXXFTLJPYYxcH6o107zm4ZpiGLh5Pix4/UWkh7pgw4GgxBLh+SartiFpfLBOwKIQacw8AoEI2Y+zA9Yf3oBiGYY4UctylLcczLcJCiekwJFR/NAeGkGh2koHt/plu7hT/XNJF7avOGfysGuEaIOzxIjp+B+18Z0xS7lc/LFIolgkAQL0dCjhxZ9ph9jAOBD6zSGIYhvn8wUKJ6XAS5M4CM0Rmwbbwpdtyz4ADgp5JDlyx5I8wFUkb9U4YpTLhM5tMt1Vxr+2LLJFKn3lRJ8/CQNUjRaUFAw4qjCY0ODHd5NfMYaAJsEBiGKaLYB+lToGLuZkOQ1atRoIsSN9/CkO4s+JsUHp2m8h2xM4MDGdGlIqFa3IZho16OwYJQpJCWQJJYVHIm7Hma3RLAskMryTXZdxGT+MAosJCVFgokwdRJg+iytgPAKh3irgdCcMwXYdDbV+YFmGhxHQosb4bAp/9oskfRTqUSJK+xb8ecFNvRdJGE5kolgk4EAiLlM8sUs1eC85kc69JegGgU3VNTgQ2uf+PCgs9jQOokM0oEklUyIMAgCpjP74+eNGRPxiGYRimW8BCielwYn03QEIElmYvHQdk1Cp53kv+FFs+bLgz3podA8XCQpMT0RElPw6kri9SIinz67CwA4sDibBIodGJIipSKJZJRGVK73tm7dojfh4MwzDtAvsodQoslJhOIdJ3PQwhYQiJgz6RBATNJv3O2w5yR5qUgIqTQJxEIKKkZrv5I0iKzEiSH1OkYIoUoiKpF8UuuwSmF6GSgnD6wGCUjGEYpksgtFEodfUNdA+4mJvpEgy/E7dnDWBRcF6ZEkmqpYnaVx1fLIBdnjVAoxP1HecaR0o4gZlqhiDXCykjqmQIgkUhmCIFGxJRERRyiqhI4Qs1W9p24wzDMO0FF3N3ChxRYjqNUNVaNDvJQAoOcEVPghydcsuMJOUSSUC6PqnBSZta5nLddtcLbRiZaRmgtsUdU9cmGRn/1NplF7NIYhiGOQrhiBLTqZRV16Fp+0D92YBAo2MFpIsppK5b8qfilDGl7ZlUFgtgj+MeWSSSaKSo56OU/VobghB3TEifTUAmjpeuK/J8lAyQtgRgCwCGYQoOR/3Tsi3HMy3BESWm0ynuuwkhGAjBQJxsmCL7NZQQAZHkrnPbmvgjSgBQYcTRTGHtum2KlFe+nf4loKb/KzFkUQgOSTgkYcCBAUfXKQFAgxNFkUzCFA6LJIZhChMu5u4UOKLEdAmRvutRv60GBgQsn6BRoqk5w4BS9X2zvGiSIioc7LKjKJVxNDpRGHAQpzAABIQSAEhftCnu9YZTfkqmsFFhNAFw3bkB4NQBG9vlXhmGYZjuC0eUmC6jonqz/toQAkUiBBMyr0hSqFqlYgHESaJUJgPF3FGR1CJJwtHRJCWS6u0ixMnEhkQltiR7YF28t7e+GKUyDgnCxEEr2vluGYZh2hmOKHUKLJSYLseERJEIwRACBygViBgpkaQiTSYETK9pbhO5EaU4hdDDaNbH+H2UVN83lWJrtN2o09bEMXBI4LNEGQDg04N9EZUWdtll7LbNMEz3gJ25OwUWSkyXUlG9GRER0k7dEU8QGZ4gAtIz4Py1THEimF5kqUIm0ehEYAob0jdbTaXVbEhI4aDe6wO3orkaB+wI1jf3AgDUW0UYENmDvaliXDrkgw6+Y4ZhGKY7wUKJ6XJifTcg4UWSHBBMIfSLqUSSA4ID0s7dYSEQFu7Mt712BMUiqYWR8kEyha1ntzXaMZjCRqMTRU10L7YdrHDXpyI4rWw9otLClOP/2pm3zTAM0yaInDYvTMuwUGIKgorqzdp4UiLbjVshIRARUrtz1zsCpTLtou1AoJki2mgyKiw0OxEYwsFeuxgA8I+9QwAAKcfAyLIt2JUqxdXD3umwe2MYhukQqI1pN65RahUslJiCwYSE6b2SppA6mqTEkwkZMKeME6FIpP9FVCEP6hlvgNvj7bNUOSwyUGvuDlwrRRKjyjfDIYk7R7zR8TfHMAzDdEtYKDEFh+HzSvJjwYEFR5tOAm4KDgBKZRL1TgxRkdR+SLtSpQCAoeHPAACnxjbgvX2DIQVhROl2NNthfP+E1zvprhiGYdoZnvXWKbCPElMwlFXXoWHbAEhVq+TT8Sot5/iKtZVI2mPHALi92ADg00RfAMCoaB0AIE6uZ9ITn52FIiOJEaXbAIAjSQzDdG8cBxBtqDPiGqVWwUKJKSj8YikB108pAiPwOSokbO9fQrsciQojDsvr77Ys0R9RaWF0tA7NnqnkS/tOBgBM6JH2Rrpy6IJOuyeGYZgOgQhAG6JCHFFqFSyUmIKjrLoO9dtqYELCgoME7EB0CXBnw8XJQYW00ewIhIWDdakeqAw16FlvRdLCWwdOQE10L44N7wQAXDT4406/H4ZhGKb7wkKJKUgqqjdjz7b+gXSbEk4AYBPBhEAzEUxB2ONEUGkcQKMTAQDssoux1ToGfUL7Uew1uWWRxDDM5wlyHFAbUm9sD9A6WCgx3QILjp4VF/danDgAokKg0QHKRBJNPkfuXakyhIWNylADAOCc2lVdMWyGYZiOg1NvnQLPemMKlp7VWwC49gA2EeJkw4Ljsw0Akhk/6BXyIPbYJZDCQa25G8UiySKJYRiGOWJYKDEFTc/qLdqR2++rZAoJy/uXVESoJrkpNDpR9DYaMczciahI4fSBG7ps7AzDMB1KJ/d6mzFjBoQQgaWqqqqDbq5w4NQbU/BUVm/Frm399GcHBMuLJBnC9V0KC2CXbaBCHkSRdFNzQ/tv65LxMgzDdApEANpiD3D4qbcTTjgBc+fO1Z8Nwzjy63cTWCgx3YLK6q3Ys60/AMDyChANCJhelGmvTYgKG0XS/cGv6be9awbKMAzTzWhoaAh8jkQiiEQiOfcNhUJHRRTJD6femG6DSsMB7ourRFKj48AUxCKJYZijCnKozQsA1NTUoLy8XC/3339/3muuWbMG1dXVGDRoEC6++GKsX7++s263y+CIEtPtMITQvkp7HdeNu8gTTVX9ON3GMMxRAjloW+rNPXbz5s0oKyvTq/NFk04//XQ8/fTTGDZsGD777DP85Cc/wdixY7F8+XL07NnzyMdR4LBQYroVldVbUb+tBgBQ76QgARRLqbcxDMMcLZBDIHHkU/zJq1EqKysLCKV8TJo0SX/9hS98AWPGjMHgwYPx1FNPYdq0aUc8jkKHhRLT7VCmk6XSLSJUNgIMwzBM51FcXIwvfOELWLNmTVcPpUNhodQCSnFnFrsxXUekZCV2bz8OANCr7yr+3jAMUzCo30fUCWaOKUq0qbFtClabrp9IJLBy5UqceeaZbTpPocNCqQUaGxsBuMVuTCFS3tUDYBiGyaKxsRHl5R3z+ykcDqOqqgrv7nijzeeqqqpCOBxu1b7Tp0/HhRdeiAEDBmDnzp34yU9+goaGBlx55ZVtHkchw0KpBaqrq7F582aUlpZCeAXD+WhoaEBNTU1WYVx3oTuPn8fedXTn8fPYu47uPP5DjZ2I0NjYiOrq6g67fjQaxYYNG5BMJtt8rnA4jGg02qp9t2zZgksuuQS7d+9GZWUlzjjjDLz//vsYOHBgm8dRyLBQagEpJfr3739Yx7S2MK5Q6c7j57F3Hd15/Dz2rqM7jz/f2DsqkuQnGo22WuC0F7NmzerU6xUK7KPEMAzDMAyTBxZKDMMwDMMweWCh1I5EIhHcc889ec26Cp3uPH4ee9fRncfPY+86uvP4u/PYmcNHUGfMYWQYhmEYhumGcESJYRiGYRgmDyyUGIZhGIZh8sBCiWEYhmEYJg8slBiGYRiGYfLAQolhGIZhGCYPLJQOg9WrV2Py5Mno1asXysrK8KUvfQl/+9vfAvvU1dXhwgsvRHFxMXr16oWpU6e2aDOfSCRw0003oVevXiguLsZXvvIVbNmypV3HPm/ePAghci4LFy4EADz55JN599m5c2fec48fPz5r/4svvrhTxw4g5/bHH3/8kOculGe/dOlSXHLJJaipqUEsFsPw4cPxyCOPtHjuQnn2hfreA8Ds2bNx+umnIxaLoVevXrjooov0tkJ951s7fqBw3/uWxl6o73xrxg4U9jvPtDPEtJohQ4bQBRdcQEuXLqXVq1fTDTfcQEVFRbR9+3YiIkqlUnTiiSfS2WefTYsXL6a3336bqquracqUKYc87/XXX0/9+vWjt99+mxYvXkxnn302nXTSSZRKpdpt7IlEgrZv3x5Yrr76aqqtrSXHcYiIqLm5OWufiRMn0rhx4w557nHjxtE111wTOK6+vr5Tx05EBIBmzpwZ2K+5ufmQ5y6UZ//b3/6WbrrpJpo3bx6tW7eOnnnmGYrFYvToo48e8tyF8OwL+b3/4x//SMcccww99thjtGrVKvr000/pD3/4g95eqO98a8dPVLjvfUtjL9R3vjVjL+R3nml/WCi1kl27dhEA+vvf/67XNTQ0EACaO3cuERG98cYbJKWkrVu36n2ef/55ikQitH///pznra+vJ9M0adasWXrd1q1bSUpJc+bM6aC7IUomk9S7d2/68Y9/nHefnTt3kmma9PTTTx/yXOPGjaObb765nUeYn3xjB0Avv/xyq89TyM+eiOiGG26gs88++5D7FMKzL9T33rIs6tevHz3xxBOtPqaQ3vnWjr8Q3/sjefZEhfHOt2bshfrOMx0Dp95aSc+ePTF8+HA8/fTTaGpqQiqVwq9//Wv06dMHJ598MgDgvffew4knnhjoGj1x4kQkEgksWrQo53kXLVoEy7Jw/vnn63XV1dU48cQTsWDBgg67n1dffRW7d+/GVVddlXefp59+GkVFRfi3f/u3Fs/37LPPolevXjjhhBMwffp0NDY2tuNogxxq7FOmTEGvXr1w6qmn4vHHH4fjOHnPU8jPHgD279+PHj16tHi+rn72hfreL168GFu3boWUEl/84hfRt29fTJo0CcuXL897TCG984cz/kJ774/k2QOF8c63ZuyF+s4zHUOoqwfQXRBC4O2338bkyZNRWloKKSX69OmDOXPmoKKiAgCwY8cO9OnTJ3DcMcccg3A4jB07duQ8744dOxAOh3HMMccE1vfp0yfvMe3Bb3/7W0ycOBE1NTV59/nd736HSy+9FLFY7JDnuuyyyzBo0CBUVVXhk08+wZ133omlS5fi7bffbu9hA8g/9nvvvRfnnnsuYrEY/vKXv+C2227D7t27cffdd+c8TyE/+/feew//+7//i9mzZx/yXIXw7Av1vV+/fj0AYMaMGfjv//5v1NbW4uc//znGjRuH1atX5/yDXEjvfGvHX4jv/ZE8+0J551sz9kJ955kOoqtDWl3NPffcQwAOuSxcuJAcx6GvfOUrNGnSJHr33Xdp0aJF9J3vfIf69etH27ZtIyKia665hs4///ysa5imSc8//3zO6z/77LMUDoez1k+YMIGuu+66dhu/n82bN5OUkv74xz/mPe+CBQsIAH300UctjiGTjz76iADQokWLumTsigcffJDKysrybi/UZ//JJ59QZWUl3XvvvS2OIZOuePad/d63duzPPvssAaBf//rX+th4PE69evWixx9/POu8nfHOd+T4FR353nfU2AvpnW/N2Lvidz3TdRz1EaUpU6a0OGOitrYWf/3rX/H6669j3759KCsrAwD86le/wttvv42nnnoK3/ve91BVVYUPPvggcOy+fftgWVbWvz4UVVVVSCaT2LdvX+BfGjt37sTYsWPbbfx+Zs6ciZ49e+IrX/lK3mOeeOIJjBo1SqcVD4fRo0fDNE2sWbMGo0ePzrtfR41dccYZZ6ChoQGfffZZzudfiM9+xYoVOOecc3DNNdfkjQgciq549p393rd27CodM2LECL0+Eong2GOPRV1dXdYxnfHOd+T4FR353nfE2AvtnW/N2Lvidz3ThXS1UusuvPrqqySlpMbGxsD6YcOG0U9/+lMiShf4qQgTEdGsWbNaVeD3wgsv6HXbtm3rsAI/x3Fo0KBBdNttt+Xdp7GxkUpKSlqcfZKPZcuWEQCaP3/+kQ4zJ60Zu59HH32UotEoxePxnNsL7dl/8skn1Lt3b7r99tuP+Bpd8ewL9b3fv38/RSKRQFGuKkb3RwuICvOdP5zx+ymE9761Yy/Ed741Yy/Ud57pGFgotZJdu3ZRz5496aKLLqIlS5bQqlWraPr06WSaJi1ZsoSI0lNGzz33XFq8eDHNnTuX+vfvH5gyumXLFjruuOPogw8+0Ouuv/566t+/P82dO5cWL15M55xzTodNGZ07dy4BoBUrVuTd54knnqBoNEp79+7N2pY5/rVr19KPfvQjWrhwIW3YsIFmz55Nxx9/PH3xi19s9/Efauyvvvoq/eY3v6Fly5bR2rVr6X/+53+orKyMpk6dmnfsRIXz7FXq4bLLLgtMe965c2fe8RfKsy/k9/7mm2+mfv360VtvvUWffvopffvb36bevXtnvduF+s63NP5Cfu9bGnshv/Mtjb2Q33mm/WGhdBgsXLiQzj//fOrRoweVlpbSGWecQW+88UZgn02bNtGXv/xlisVi1KNHD5oyZUrgX3YbNmwgAPS3v/1Nrzt48CBNmTKFevToQbFYjP7lX/6F6urqOuQeLrnkEho7duwh9xkzZgxdeumlObdljr+uro7OOuss6tGjB4XDYRo8eDBNnTqV9uzZ095DP+TY33zzTRo1ahSVlJRQUVERnXjiifTwww+TZVl5x05UOM8+X/3EwIED846/UJ49UeG+98lkkm677Tbq3bs3lZaW0oQJE+iTTz7J2q9Q3/mWxl/I731LYy/kd741702hvvNM+yOIiDopy8cwDMMwDNOtYB8lhmEYhmGYPLBQYhiGYRiGyQMLJYZhGIZhmDywUGIYhmEYhskDCyWGYRiGYZg8sFBiGIZhGIbJAwslhmEYhmGYPLBQYo46xo8fj1tuueVzdd2rrroKX/3qVzvk3H5eeeUVDBkyBIZhdMkz7CqefPJJVFRUdPUwGIbpAlgoMUwn8dJLL+Hee+/Vn2tra/Hwww933YCOgOuuuw7/9m//hs2bNwfuxU9tbS2EEBBCIBaL4fjjj8d//dd/we9tu3HjRgghsGTJkqzjcwnK5cuX49///d9RWVmJSCSCoUOH4gc/+AGam5vb8/by8o1vfAOrV68+rGO6SpAzDNO+sFBimE6iR48eKC0t7ephHDEHDhzAzp07MXHiRFRXVx/yXn784x9j+/btWLlyJaZPn4677roLv/nNb47ouu+//z5OP/10JJNJzJ49G6tXr8Z9992Hp556Cueddx6SyeSR3lKricVi6N27d4dfh2GYwoOFEnPUs2/fPlxxxRU45phjUFRUhEmTJmHNmjV6u0q7vPXWWxg+fDhKSkrwz//8z9i+fbveJ5VKYerUqaioqEDPnj1xxx134Morrwykw/wRhvHjx2PTpk249dZbdfQFAGbMmIFRo0YFxvfwww+jtrZWf7ZtG9OmTdPX+u53v4vMTkREhJ/97Gc49thjEYvFcNJJJ+GPf/zjET+HefPmaWF0zjnnQAiBefPm5T1XaWkpqqqqUFtbi6uvvhojR47En//850NePxdEhG9/+9sYPnw4XnrpJZx22mkYOHAgvv71r+O1117De++9h4ceeuiQ5xg/fjymTJmCKVOm6Gd29913B55Za98Bhfo+PfPMM6itrUV5eTkuvvhiNDY2AnBTofPnz8cjjzyiv78bN27Evn37cNlll6GyshKxWAxDhw7FzJkzD/u5MAzTebBQYo56rrrqKnz00Ud49dVX8d5774GIcMEFF8CyLL1Pc3MzHnzwQTzzzDP4+9//jrq6OkyfPl1v/8///E88++yzmDlzJv7xj3+goaEBr7zySt5rvvTSS+jfv7+OvPhFV0v8/Oc/x+9+9zv89re/xbvvvou9e/fi5ZdfDuxz9913Y+bMmXjsscewfPly3HrrrfjmN7+J+fPnH9FzGDt2LFatWgUAePHFF7F9+3aMHTu2xbESEebNm4eVK1fCNM1W36NiyZIlWLFiBaZNmwYpg7+uTjrpJEyYMAHPP/98i+d56qmnEAqF8MEHH+D//b//h4ceeghPPPGE3t6adyCTdevW4ZVXXsHrr7+O119/HfPnz8cDDzwAAHjkkUcwZswYXHPNNfr7W1NTgx/84AdYsWIF3nzzTaxcuRKPPfYYevXqddjPhWGYTqSLmvEyTJcxbtw4uvnmm4mIaPXq1QSA/vGPf+jtu3fvplgsRv/7v/9LREQzZ84kALR27Vq9zy9/+Uvq06eP/tynTx/6r//6L/05lUrRgAEDaPLkyTmvS0Q0cOBAeuihhwJju+eee+ikk04KrHvooYcCHdX79u1LDzzwgP5sWRb1799fX+vAgQMUjUZpwYIFgfN8+9vfpksuuSTnM2nNc9i3b19WN/RcDBw4kMLhMBUXF5NpmgSAotFo4Nyqs3osFqPi4uLAIqXUz2nWrFkEgD7++OOc15o6dSrFYrFDjmfcuHE0fPhwchxHr7vjjjto+PDhrb73mTNnUnl5ud5+zz33UFFRETU0NOh1t99+O51++umB6/q/30REF154IX3rW9865HgZhiksOKLEHNWsXLkSoVAIp59+ul7Xs2dPHHfccVi5cqVeV1RUhMGDB+vPffv2xc6dOwEA+/fvx2effYbTTjtNbzcMAyeffHK7j3f//v3Yvn07xowZo9eFQiGccsop+vOKFSsQj8dx3nnnoaSkRC9PP/001q1bl/O8rX0OreX222/HkiVLMH/+fJx99tn4/ve/nzMC9cILL2DJkiWBxX8vLUFEOm35zjvvBO732Wef1fudccYZej8AGDNmDNasWQPbto/43mtrawN1Wv53Ih/f+c53MGvWLIwaNQrf/e53sWDBglbfK8MwXUOoqwfAMF0JZdT2+Nf7/7Bmpo2EEFnH+vc/1LkPhZQy67hDpX9y4TgOAGD27Nno169fYFskEsl5TGufQ2vp1asXhgwZgiFDhuDFF1/EkCFDcMYZZ2DChAmB/WpqajBkyJDAulgspr8eNmwYAFf8ZdZuAcCnn36KoUOHAgBOOeWUwCy6Pn36tGqsR3rvud4J9ezzMWnSJGzatAmzZ8/G3Llzce655+LGG2/Egw8+2KqxMgzT+XBEiTmqGTFiBFKpFD744AO9bs+ePVi9ejWGDx/eqnOUl5ejT58++PDDD/U627bx8ccfH/K4cDgM27YD6yorK7Fjx47AH2//H//y8nL07dsX77//vl6XSqWwaNGiwD1FIhHU1dVpsaKWmpqanGNpj+eQj2OOOQY33XQTpk+fftjicdSoUTj++OPx0EMPZYmQpUuXYu7cubjkkksAuALLf6/+aI//eanPQ4cOhWEYHXbvub6/gPs9vuqqq/D73/8eDz/88BHPBmQYpnNgocQc1QwdOhSTJ0/GNddcg3fffRdLly7FN7/5TfTr1w+TJ09u9Xluuukm3H///fjTn/6EVatW4eabb8a+ffsOGZGora3F3//+d2zduhW7d+8G4M7Q2rVrF372s59h3bp1+OUvf4k333wzcNzNN9+MBx54AC+//DI+/fRT3HDDDaivr9fbS0tLMX36dNx666146qmnsG7dOnz88cf45S9/iaeeeqpDn0M+brzxRqxatQovvvjiYR0nhMATTzyBFStW4F//9V/x4Ycfoq6uDn/4wx9w4YUXYsyYMa3yKtq8eTOmTZuGVatW4fnnn8ejjz6Km2++GUDH3XttbS0++OADbNy4Ebt374bjOPjhD3+IP/3pT1i7di2WL1+O119/vc1ClGGYjoWFEnPUM3PmTJx88sn4l3/5F4wZMwZEhDfeeOOwZmndcccduOSSS3DFFVdgzJgxKCkpwcSJExGNRvMe8+Mf/xgbN27E4MGDUVlZCQAYPnw4fvWrX+GXv/wlTjrpJHz44YeB2XUAcNttt+GKK67AVVddhTFjxqC0tBRf+9rXAvvce++9+OEPf4j7778fw4cPx8SJE/Haa69h0KBBHfoc8lFZWYnLL78cM2bMaDE9lcmXvvQlvP/++zAMAxdccAGGDBmCO++8E1deeSXefvvtvOlEP1dccQUOHjyI0047DTfeeCNuuukmXHvttXp7R9z79OnTdcSqsrISdXV1CIfDuPPOOzFy5EicddZZMAwDs2bNOuJrMAzT8Qg6kkIKhmEOieM4GD58OP793/89r4M10zmMHz8eo0aN6nYu6AzDFAZczM0w7cCmTZvw5z//GePGjUMikcAvfvELbNiwAZdeemlXD41hGIZpA5x6Y5h2QEqJJ598Eqeeeiq+9KUvYdmyZZg7dy7XnzAMw3RzOPXGMAzDMAyTB44oMQzDMAzD5IGFEsMwDMMwTB5YKDFMJzN+/HjdUd5vJuln3rx5EEIE/JGY9mPGjBn6e8Cz4RiGORQslBimC1Bd5U888cSuHsrnmo0bN+YUpNOnT8f27dvRv3//rhkYwzDdBrYHYJguoKioCFVVVV09DFiW1S6Gkt0N1TjXMIyuHgrDMAUOR5QYpgB44403MGzYMMRiMZx99tnYuHFj1j4LFizAWWedhVgshpqaGkydOhVNTU16+/bt2/HlL38ZsVgMgwYNwnPPPYfa2tpAakkIgccffxyTJ09GcXExfvKTnwAAXnvtNZx88smIRqM49thj8aMf/QipVEoft3//flx77bXo3bs3ysrKcM4552Dp0qV6+9KlS3H22WejtLQUZWVlOPnkk/HRRx+16t5buq/f//73OOWUU1BaWoqqqipceuml2Llzp96+b98+XHbZZaisrEQsFsPQoUMxc+ZMANBO5F/84hchhMD48eNbNSaGYRgFCyWG6WI2b96Miy66CBdccAGWLFmCq6++Gt/73vcC+yxbtgwTJ07ERRddhP/7v//DCy+8gHfffRdTpkzR+1xxxRXYtm0b5s2bhxdffBG/+c1vAoJCcc8992Dy5MlYtmwZ/uM//gNvvfUWvvnNb2Lq1KlYsWIFfv3rX+PJJ5/ET3/6UwAAEeHLX/4yduzYgTfeeAOLFi3C6NGjce6552Lv3r0AgMsuuwz9+/fHwoULsWjRInzve99rVaSqNfeVTCZx7733YunSpXjllVewYcMGXHXVVXr7D37wA6xYsQJvvvkmVq5cicceewy9evUCAN2oeO7cudi+fTteeumlVn5XGIZhPIhhmE5l3LhxdPPNN+vPd955Jw0fPpwcx9Hr7rjjDgJA+/btIyKiyy+/nK699trAed555x2SUtLBgwdp5cqVBIAWLlyot69Zs4YA0EMPPaTXAaBbbrklcJ4zzzyT7rvvvsC6Z555hvr27UtERH/5y1+orKyM4vF4YJ/BgwfTr3/9ayIiKi0tpSeffPLwHkQr7isXH374IQGgxsZGIiK68MIL6Vvf+lbOfTds2EAA6OOPP865feDAgYHnwzAMkwnXKDFMF7Ny5UqcccYZEELodWPGjAnss2jRIqxduxbPPvusXkdEcBwHGzZswOrVqxEKhTB69Gi9fciQITjmmGOyrnfKKadknXvhwoU6ggQAtm0jHo+jubkZixYtwoEDB9CzZ8/AcQcPHsS6desAANOmTcPVV1+NZ555BhMmTMDXv/51DB48uMV7b+m+hg8fjo8//hgzZszAkiVLsHfvXt1Ut66uDiNGjMB3vvMd/Ou//isWL16M888/H1/96lcxduzYFq/NMAzTGlgoMUwXQ60wx3ccB9dddx2mTp2atW3AgAFYtWpVq89dXFycde4f/ehHuOiii7L2jUajcBwHffv2xbx587K2V1RUAHCn21966aWYPXs23nzzTdxzzz2YNWsWvva1r7XpvpqamnD++efj/PPPx+9//3tUVlairq4OEydORDKZBABMmjQJmzZtwuzZszF37lyce+65uPHGG/Hggw8e8toMwzCtgYUSw3QxI0aMwCuvvBJY9/777wc+jx49GsuXL8eQIUNynuP4449HKpXCxx9/jJNPPhkAsHbt2lb5MI0ePRqrVq3Ke+7Ro0djx44dCIVCqK2tzXueYcOGYdiwYbj11ltxySWXYObMmS0KpZbua9myZdi9ezceeOAB1NTUAEDOIvHKykpcddVVuOqqq3DmmWfi9ttvx4MPPohwOAzAjZAxDMMcCVzMzTBdzPXXX49169Zh2rRpWLVqFZ577jk8+eSTgX3uuOMOvPfee7jxxhuxZMkSrFmzBq+++ipuuukmAK5QmjBhAq699lp8+OGH+Pjjj3HttdciFosFUnq5+OEPf4inn34aM2bMwPLly7Fy5Uq88MILuPvuuwEAEyZMwJgxY/DVr34Vb731FjZu3IgFCxbg7rvvxkcffYSDBw9iypQpmDdvHjZt2oR//OMfWLhwYasaArd0XwMGDEA4HMajjz6K9evX49VXX8W9996bNf4//elPWLt2LZYvX47XX39dX7t3796IxWKYM2cOPvvsM+zfv79V3xOGYRhN15ZIMczRR2YxNxHRa6+9RkOGDKFIJEJnnnkm/e53vwsUcxO5RcznnXcelZSUUHFxMY0cOZJ++tOf6u3btm2jSZMmUSQSoYEDB9Jzzz1HvXv3pscff1zvA4BefvnlrDHNmTOHxo4dS7FYjMrKyui0006j3/zmN3p7Q0MD3XTTTVRdXU2maVJNTQ1ddtllVFdXR4lEgi6++GKqqamhcDhM1dXVNGXKlLzF2Jm0dF/PPfcc1dbWUiQSoTFjxtCrr74aKNC+9957afjw4RSLxahHjx40efJkWr9+vT7+f/7nf6impoaklDRu3LjAtbmYm2GYlhBErSiQYBim3Rg/fjxGjRrV4a0ztmzZgpqaGl23w2RTW1uLW265BbfccktXD4VhmAKFU28M0wX86le/QklJCZYtW9Zu5/zrX/+KV199FRs2bMCCBQtw8cUXo7a2FmeddVa7XePzwn333YeSkhLU1dV19VAYhilwOKLEMJ3M1q1bcfDgQQDpGpz24K233sJtt92G9evXo7S0FGPHjsXDDz+MgQMHtsv5j4RJkybhnXfeybntrrvuwl133dXJI3LZu3evNsusrKxEeXl5l4yDYZjCh4USwzAdhl8UZtKjRw/06NGjk0fEMAxzeLBQYhiGYRiGyQPXKDEMwzAMw+SBhRLDMAzDMEweWCgxDMMwDMPkgYUSwzAMwzBMHlgoMQzDMAzD5IGFEsMwDMMwTB5YKDEMwzAMw+Th/wNBme+6ryNHxwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subset[\"temp\"].squeeze().plot(x=\"lon_rho\", y=\"lat_rho\");" + ] + }, + { + "cell_type": "markdown", + "id": "0254598f", + "metadata": {}, + "source": [ + "What is the current workflow and what are the altearnatives? Most ocean data are stored as modern netCDF files that are, under the hood HDF5 files with more strict metadata stuture. HDF5 has some limitations like,\n", + "\n", + "- no thread-based parallelism\n", + "- cannot do parallel writes with compression\n", + "- no support for could object stores\n", + "\n", + "However, for most workflows what really matters is the chunking, not the data format. Leaving the parallelism, compression, and cloud support to be built on top of it with `dask`, `numcodecs`, and `fsspec`, respectively. That raises the question: Should one convert all the existing data to `zarr`? Luckily no! We can adopt a more inexpensive workflow and kerchunk to create virtual cloud-optimized CF-compliant datasets that access files in any format using the Zarr library.\n", + "\n", + "We can write the data in whatever format we need (maybe you are NASA and require HDF5, maybe you have R users who like netcdf, or want to use a visualization tool that only reads geotiff), then rechunk the data to best support the expected use cases." + ] + } + ], + "metadata": { + "_draft": { + "nbviewer_url": "https://gist.github.com/9fc25f2a1a1a653535bc15428798dfab" + }, + "gist": { + "data": { + "description": "netcdf-c-zarr.ipynb", + "public": true + }, + "id": "9fc25f2a1a1a653535bc15428798dfab" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pytest.ini b/pytest.ini index 9f40dab6..b2fbea15 100644 --- a/pytest.ini +++ b/pytest.ini @@ -5,7 +5,7 @@ addopts = --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2016-12-22-boston_light_swim.ipynb" --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2017-03-21-ERDDAP_IOOS_Sensor_Map.ipynb" --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2017-07-25-HFRadar_currents.ipynb" - --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2017-09-09-hurricane_irma" + --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2017-09-09-hurricane_irma.ipynb" --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2017-12-15-finding_HFRadar_currents.ipynb" --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2019-02-26-hurricane_gis_part01.ipynb" --ignore="jupyterbook/content/code_gallery/data_access_notebooks/2019-03-08-grids-temperature"