From cc9828180845cda219c8fa810a4a08932b0ba2f3 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 16:25:50 +0200 Subject: [PATCH 01/28] move to pyproject.toml - update RTD workflow - update CI workflow - remove setup.py - move shape data --- .github/workflows/ci.yml | 7 +-- .readthedocs.yml | 8 ++- docs/examples/01_basic_model.ipynb | 3 +- nlmod/data/{ => shapes}/opp_water.cpg | 0 nlmod/data/{ => shapes}/opp_water.dbf | Bin nlmod/data/{ => shapes}/opp_water.prj | 0 nlmod/data/{ => shapes}/opp_water.qpj | 0 nlmod/data/{ => shapes}/opp_water.shp | Bin nlmod/data/{ => shapes}/opp_water.shx | Bin nlmod/read/rws.py | 2 +- pyproject.toml | 87 ++++++++++++++++++++++++++ requirements.txt | 7 --- setup.py | 53 ---------------- 13 files changed, 97 insertions(+), 70 deletions(-) rename nlmod/data/{ => shapes}/opp_water.cpg (100%) rename nlmod/data/{ => shapes}/opp_water.dbf (100%) rename nlmod/data/{ => shapes}/opp_water.prj (100%) rename nlmod/data/{ => shapes}/opp_water.qpj (100%) rename nlmod/data/{ => shapes}/opp_water.shp (100%) rename nlmod/data/{ => shapes}/opp_water.shx (100%) create mode 100644 pyproject.toml delete mode 100644 requirements.txt delete mode 100644 setup.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d39d0910..0d830cf0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,12 +30,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install flake8 pytest - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install pytest-cov - pip install pytest-dependency - pip install codacy-coverage - pip install -e . + pip install -e .[ci] - name: Lint with flake8 run: | diff --git a/.readthedocs.yml b/.readthedocs.yml index 7caeef40..cd955368 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -20,7 +20,11 @@ sphinx: # Optionally declare the Python requirements required to build your docs python: + system_packages: true install: - - requirements: docs/requirements.txt - - method: setuptools + - method: pip path: . + extra_requirements: + - ci + - rtd + diff --git a/docs/examples/01_basic_model.ipynb b/docs/examples/01_basic_model.ipynb index 5320336b..8a86cc28 100644 --- a/docs/examples/01_basic_model.ipynb +++ b/docs/examples/01_basic_model.ipynb @@ -39,6 +39,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -49,7 +50,7 @@ "- a structured grid based on the subsurface models [Regis](https://www.dinoloket.nl/regis-ii-het-hydrogeologische-model) and [Geotop](https://www.dinoloket.nl/detaillering-van-de-bovenste-lagen-met-geotop). The Regis layers that are not present within the extent are removed. In this case we use 'MSz1' as the bottom layer of the model. Use `nlmod.read.regis.get_layer_names()` to get all the layer names of Regis. All Regis layers below this layer are not used in the model. Geotop is used to replace the holoceen layer in Regis because there is no kh or kv defined for the holoceen in Regis. Part of the model is in the North sea. Regis and Geotop have no data there. Therefore the Regis and Geotop layers are extrapolated from the shore and the seabed is added using bathymetry data from [Jarkus](https://www.openearth.nl/rws-bathymetry/2018.html).\n", "- starting heads of 1 in every cell.\n", "- the model is a steady state model of a single time step.\n", - "- big surface water bodies (Northsea, IJsselmeer, Markermeer, Noordzeekanaal) within the extent are added as a general head boundary. The surface water bodies are obtained from a [shapefile](..\\data\\opp_water.shp).\n", + "- big surface water bodies (Northsea, IJsselmeer, Markermeer, Noordzeekanaal) within the extent are added as a general head boundary. The surface water bodies are obtained from a [shapefile](..\\data\\shapes\\opp_water.shp).\n", "- surface drainage is added using [ahn](https://www.ahn.nl) data and a default conductance of $1000 m^2/d$\n", "- recharge is added using data from the [knmi](https://www.knmi.nl/nederland-nu/klimatologie/daggegevens) using the following steps:~~\n", " 1. Check for each cell which KNMI weather and/or rainfall station is closest.\n", diff --git a/nlmod/data/opp_water.cpg b/nlmod/data/shapes/opp_water.cpg similarity index 100% rename from nlmod/data/opp_water.cpg rename to nlmod/data/shapes/opp_water.cpg diff --git a/nlmod/data/opp_water.dbf b/nlmod/data/shapes/opp_water.dbf similarity index 100% rename from nlmod/data/opp_water.dbf rename to nlmod/data/shapes/opp_water.dbf diff --git a/nlmod/data/opp_water.prj b/nlmod/data/shapes/opp_water.prj similarity index 100% rename from nlmod/data/opp_water.prj rename to nlmod/data/shapes/opp_water.prj diff --git a/nlmod/data/opp_water.qpj b/nlmod/data/shapes/opp_water.qpj similarity index 100% rename from nlmod/data/opp_water.qpj rename to nlmod/data/shapes/opp_water.qpj diff --git a/nlmod/data/opp_water.shp b/nlmod/data/shapes/opp_water.shp similarity index 100% rename from nlmod/data/opp_water.shp rename to nlmod/data/shapes/opp_water.shp diff --git a/nlmod/data/opp_water.shx b/nlmod/data/shapes/opp_water.shx similarity index 100% rename from nlmod/data/opp_water.shx rename to nlmod/data/shapes/opp_water.shx diff --git a/nlmod/read/rws.py b/nlmod/read/rws.py index ae0cd280..d3d4706c 100644 --- a/nlmod/read/rws.py +++ b/nlmod/read/rws.py @@ -31,7 +31,7 @@ def get_gdf_surface_water(ds): surface water geodataframe. """ # laad bestanden in - fname = os.path.join(nlmod.NLMOD_DATADIR, "opp_water.shp") + fname = os.path.join(nlmod.NLMOD_DATADIR, "shapes", "opp_water.shp") gdf_swater = gpd.read_file(fname) extent = dims.get_extent(ds) gdf_swater = util.gdf_within_extent(gdf_swater, extent) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..d430001c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,87 @@ +[build-system] +requires = ["setuptools>=64.0.0", "wheel"] +build-backend = "setuptools.build_meta" + + +[project] +name = "nlmod" +dynamic = ["version"] +description = "nlmod is an open-source Python package for building Modflow 6 groundwater models from online data sources in The Netherlands" +license = { file = "LICENSE" } +readme = "README.md" +authors = [ + { name = "O. Ebbens" }, + { name = "R. Caljé" }, + { name = "D.A. Brakenhoff" }, +] +maintainers = [ + { name = "O. Ebbens", email = "o.ebbens@artesia-water.nl" }, + { name = "R. Calje", email = "r.calje@artesia-water.nl" }, + { name = "D.A. Brakenhoff", email = "d.brakenhoff@artesia-water.nl" }, +] +requires-python = ">= 3.8" +dependencies = [ + "flopy>=3.3.6", + "xarray>=0.16.1", + "netcdf4>=1.5.7", + "rasterio>=1.1.0", + "rioxarray", + "affine>=0.3.1", + "geopandas", + "owslib>=0.24.1", + "hydropandas>=0.7.1", + "shapely>=2.0.0", + "pyshp>=2.1.3", + "matplotlib", + "dask", + "colorama", +] +keywords = ["hydrology", "groundwater", "modeling", "Modflow 6", "flopy"] +classifiers = [ + 'Development Status :: 4 - Beta', + 'Intended Audience :: Science/Research', + 'Intended Audience :: Other Audience', + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 3 :: Only', + 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', + 'Programming Language :: Python :: 3.10', + 'Topic :: Scientific/Engineering :: Hydrology', +] + +[project.urls] +homepage = "https://github.com/ArtesiaWater/nlmod" +repository = "https://github.com/ArtesiaWater/nlmod" +documentation = "https://nlmod.readthedocs.io/en/latest/" + +[project.optional-dependencies] +full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] +test = ["pytest>=7", "pytest-cov", "pytest-dependency"] +lint = ["flake8", "isort", "black[jupyter]"] +ci = ["nlmod[full,test]"] +rtd = ["nbconvert>6.4.5", "netCDF4==1.5.7"] + +[tool.setuptools.dynamic] +version = { attr = "nlmod.version.__version__" } + +[tool.setuptools.packages.find] +where = ["."] + +[tool.setuptools] +include-package-data = true + +[tool.setuptools.package-data] +"nlmod.data" = ["*.gleg"] +"nlmod.data.geotop" = ["*.csv"] +"nlmod.data.shapes" = ["*"] + +[tool.black] +line-length = 88 + +[tool.isort] +profile = "black" + +[tool.pytest.ini_options] +addopts = "--strict-markers --durations=0" +markers = ["notebooks: run notebooks"] + diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 0fc358ae..00000000 --- a/requirements.txt +++ /dev/null @@ -1,7 +0,0 @@ -nbconvert>=6.4.5 -netCDF4==1.5.7 -rasterstats -geocube -gdown -bottleneck -contextily diff --git a/setup.py b/setup.py deleted file mode 100644 index 9efdec3b..00000000 --- a/setup.py +++ /dev/null @@ -1,53 +0,0 @@ -from os import path - -from setuptools import find_packages, setup - -this_directory = path.abspath(path.dirname(__file__)) -with open(path.join(this_directory, "README.md"), encoding="utf-8") as f: - l_d = f.read() - -# Get the version. -version = {} -with open("nlmod/version.py") as fp: - exec(fp.read(), version) - -setup( - name="nlmod", - version=version["__version__"], - description="nlmod module by Artesia", - long_description=l_d, - long_description_content_type="text/markdown", - url="https://github.com/ArtesiaWater/nlmod", - author="Artesia", - license="MIT", - classifiers=[ - "Development Status :: 4 - Beta", - "Intended Audience :: Science/Research", - "Intended Audience :: Other Audience", - "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3", - "Topic :: Scientific/Engineering :: Hydrology", - ], - platforms="Windows, Mac OS-X", - install_requires=[ - "flopy>=3.3.6", - "xarray>=0.16.1", - "netcdf4>=1.5.7", - "rasterio>=1.1.0", - "rioxarray", - "affine>=0.3.1", - "geopandas", - "owslib>=0.24.1", - "hydropandas>=0.7.1", - "shapely>=2.0.0", - "pyshp>=2.1.3", - "rtree>=0.9.7", - "matplotlib", - "dask", - "colorama", - ], - packages=find_packages(exclude=[]), - package_data={"nlmod": ["data/*", "data/geotop/*", "data/shapes/*"]}, - include_package_data=True, - extras_require={"full": ["gdown"]}, -) From 125c8edb57a3864a847e936e7c9aa3683cc7231f Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 16:31:05 +0200 Subject: [PATCH 02/28] forgot to include linting in ci install --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index d430001c..b4dd21ff 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -58,7 +58,7 @@ documentation = "https://nlmod.readthedocs.io/en/latest/" full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] test = ["pytest>=7", "pytest-cov", "pytest-dependency"] lint = ["flake8", "isort", "black[jupyter]"] -ci = ["nlmod[full,test]"] +ci = ["nlmod[full,lint,test]"] rtd = ["nbconvert>6.4.5", "netCDF4==1.5.7"] [tool.setuptools.dynamic] From 6a853f569969185b28028b4d6c634639a565967b Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 16:47:49 +0200 Subject: [PATCH 03/28] fix --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index b4dd21ff..70a24fac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,10 +56,10 @@ documentation = "https://nlmod.readthedocs.io/en/latest/" [project.optional-dependencies] full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] -test = ["pytest>=7", "pytest-cov", "pytest-dependency"] +test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test]"] -rtd = ["nbconvert>6.4.5", "netCDF4==1.5.7"] +rtd = ["nbsphinx", "nbconvert>6.4.5", "netCDF4==1.5.7"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" } From 997839286ec9dd2b1ecd7f1aa9e5167259e88f97 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 2 May 2023 00:44:31 +0200 Subject: [PATCH 04/28] set correct netcdf version for gh actions --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 70a24fac..8733fd53 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -58,8 +58,8 @@ documentation = "https://nlmod.readthedocs.io/en/latest/" full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] -ci = ["nlmod[full,lint,test]"] -rtd = ["nbsphinx", "nbconvert>6.4.5", "netCDF4==1.5.7"] +ci = ["nlmod[full,lint,test]", "netCDF4==1.5.7"] +rtd = ["nbsphinx", "nbconvert>6.4.5"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" } From b61b20dadf7067cd8f3fd7c42069a0380f19bb35 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 2 May 2023 10:23:57 +0200 Subject: [PATCH 05/28] fix nb --- docs/examples/03_local_grid_refinement.ipynb | 16 +--------------- docs/examples/11_grid_rotation.ipynb | 16 +--------------- docs/examples/16_groundwater_transport.ipynb | 16 +--------------- 3 files changed, 3 insertions(+), 45 deletions(-) diff --git a/docs/examples/03_local_grid_refinement.ipynb b/docs/examples/03_local_grid_refinement.ipynb index b2f6cb52..405bd4c7 100644 --- a/docs/examples/03_local_grid_refinement.ipynb +++ b/docs/examples/03_local_grid_refinement.ipynb @@ -399,22 +399,8 @@ } ], "metadata": { - "kernelspec": { - "display_name": "artesia", - "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.9.7" + "name": "python" } }, "nbformat": 4, diff --git a/docs/examples/11_grid_rotation.ipynb b/docs/examples/11_grid_rotation.ipynb index 13ec6a50..de54f199 100644 --- a/docs/examples/11_grid_rotation.ipynb +++ b/docs/examples/11_grid_rotation.ipynb @@ -358,22 +358,8 @@ } ], "metadata": { - "kernelspec": { - "display_name": "artesia", - "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.9.7" + "name": "python" } }, "nbformat": 4, diff --git a/docs/examples/16_groundwater_transport.ipynb b/docs/examples/16_groundwater_transport.ipynb index d48cbeda..706d3912 100644 --- a/docs/examples/16_groundwater_transport.ipynb +++ b/docs/examples/16_groundwater_transport.ipynb @@ -553,22 +553,8 @@ } ], "metadata": { - "kernelspec": { - "display_name": "artesia", - "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.9.7" + "name": "python" } }, "nbformat": 4, From 17bd39187505dae17b3cc81003978975e077ebcc Mon Sep 17 00:00:00 2001 From: OnnoEbbens Date: Wed, 3 May 2023 14:03:42 +0200 Subject: [PATCH 06/28] try to fix 'no such kernel' error in rtd --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8733fd53..f4e291fc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -59,7 +59,7 @@ full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test]", "netCDF4==1.5.7"] -rtd = ["nbsphinx", "nbconvert>6.4.5"] +rtd = ["nbsphinx", "nbconvert>=6.4.5"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" } From 7bf05e76e6f484328331a4e9de8ceccf30f6181b Mon Sep 17 00:00:00 2001 From: OnnoEbbens Date: Wed, 3 May 2023 14:59:50 +0200 Subject: [PATCH 07/28] revert change because of weird error --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index f4e291fc..8733fd53 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -59,7 +59,7 @@ full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test]", "netCDF4==1.5.7"] -rtd = ["nbsphinx", "nbconvert>=6.4.5"] +rtd = ["nbsphinx", "nbconvert>6.4.5"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" } From b8e227e599974400f3aa2b61faa90cbc1c753467 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 14:32:36 +0200 Subject: [PATCH 08/28] add methods: - get_structured_grid_ds: create a structured grid DataSet - get_vertex_grid_ds: create a vertex grid Dataset --- nlmod/dims/base.py | 209 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 201 insertions(+), 8 deletions(-) diff --git a/nlmod/dims/base.py b/nlmod/dims/base.py index 472491c1..d9fdaa78 100644 --- a/nlmod/dims/base.py +++ b/nlmod/dims/base.py @@ -77,14 +77,16 @@ def to_model_ds( drop_attributes=True, transport=False, ): - """Transform a regis datset to a model dataset with another resolution. + """Transform an input dataset to a groundwater model dataset. + + Optionally select a different grid size. Parameters ---------- ds : xarray.dataset A layer model dataset. model_name : str, optional - name of the model. THe default is None + name of the model. The default is None model_ws : str, optional workspace of the model. This is where modeldata is saved to. The default is None @@ -101,7 +103,7 @@ def to_model_ds( botm are removed. extrapolate : bool, optional When true, extrapolate data-variables, into the sea or other areas with - only nans. THe default is True + only nans. The default is True anisotropy : int or float factor to calculate kv from kh or the other way around fill_value_kh : int or float, optional @@ -234,6 +236,197 @@ def extrapolate_ds(ds, mask=None): return ds +def get_structured_grid_ds( + xedges, + yedges, + nlay=1, + top=np.nan, + botm=np.nan, + xorigin=0.0, + yorigin=0.0, + angrot=0, + attrs=None, + crs=None, +): + """Create an xarray dataset with structured grid geometry. + + Parameters + ---------- + xedges : array_like + A 1D array of the x coordinates of the grid edges. + yedges : array_like + A 1D array of the y coordinates of the grid edges. + nlay : int, optional + The number of layers in the grid. Default is 1. + top : array_like, optional + A 2D array of the top elevation of the grid cells. Default is NaN. + botm : array_like, optional + A 3D array of the bottom elevation of the grid cells. Default is NaN. + xorigin : float, optional + The x-coordinate origin of the grid. Default is 0.0. + yorigin : float, optional + The y-coordinate origin of the grid. Default is 0.0. + angrot : float, optional + The counter-clockwise rotation angle of the grid, in degrees. + Default is 0. + attrs : dict, optional + A dictionary of attributes to add to the xarray dataset. Default is an + empty dictionary. + crs : dict or str, optional + A dictionary or string describing the coordinate reference system of + the grid. Default is None. + + Returns + ------- + ds : xarray.Dataset + An xarray dataset with the following data variables and coordinates: + + - top : a 2D array of the top elevation of the grid cells + - botm : a 3D array of the bottom elevation of the grid cells + - x : a 1D array of the x coordinates of the grid cell centers + - y : a 1D array of the y coordinates of the grid cell centers + - layer : a 1D array of the layer indices + - xc : a 2D array of the x coordinates of the grid cell centers, after + rotation if `angrot` is not 0.0 (optional) + - yc : a 2D array of the y coordinates of the grid cell centers, after + rotation if `angrot` is not 0.0 (optional) + + The dataset also includes the attributes specified in the `attrs` + dictionary, and a coordinate reference system specified by `crs`, if + provided. + """ + + if attrs is None: + attrs = {} + + # get extent from local grid edge coordinates + extent = [np.min(xedges), np.max(xedges), np.min(yedges), np.max(yedges)] + # calculate centers + xcenters = xedges[:-1] + np.diff(xedges) / 2.0 + ycenters = yedges[:-1] + np.diff(yedges) / 2.0 + + resample._set_angrot_attributes(extent, xorigin, yorigin, angrot, attrs) + + coords = dict(x=xcenters, y=ycenters, layer=range(nlay)) + if angrot != 0.0: + affine = resample.get_affine_mod_to_world(attrs) + xc, yc = affine * np.meshgrid(xcenters, ycenters) + coords["xc"] = (("y", "x"), xc) + coords["yc"] = (("y", "x"), yc) + + dims = ("layer", "y", "x") + ds = xr.Dataset( + data_vars=dict( + top=(dims[1:], top), + botm=(dims, botm), + ), + coords=coords, + attrs=attrs, + ) + if crs is not None: + ds.rio.set_crs(crs) + return ds + + +def get_vertex_grid_ds( + x, + y, + xv, + yv, + extent, + nlay=1, + top=np.nan, + botm=np.nan, + xorigin=0.0, + yorigin=0.0, + angrot=0.0, + attrs=None, + crs=None, +): + """Create an xarray dataset with vertex-based grid geometry. + + Parameters + ---------- + x : array_like + A 1D array of the x coordinates of the grid cell centers. + y : array_like + A 1D array of the y coordinates of the grid cell centers. + xv : array_like + A 1D array of the x coordinates of the grid vertices. + yv : array_like + A 1D array of the y coordinates of the grid vertices. + extent : list + A list of [xmin, xmax, ymin, ymax] defining the extent of the model grid. + nlay : int or sequence of ints, optional + The number of layers in the grid, or a sequence of layer indices. + Default is 1. + top : array_like, optional + A 2D array of the top elevation of the grid cells. Default is NaN. + botm : array_like, optional + A 3D array of the bottom elevation of the grid cells. Default is NaN. + xorigin : float, optional + The x-coordinate origin of the grid. Default is 0.0. + yorigin : float, optional + The y-coordinate origin of the grid. Default is 0.0. + angrot : float, optional + The counter-clockwise rotation angle of the grid, in degrees. + Default is 0.0. + attrs : dict, optional + A dictionary of attributes to add to the xarray dataset. Default is an + empty dictionary. + crs : dict or str, optional + A dictionary or string describing the coordinate reference system of + the grid. Default is None. + + Returns + ------- + ds : xarray.Dataset + An xarray dataset with the following data variables and coordinates: + + - top : a 2D array of the top elevation of the grid cells + - botm : a 3D array of the bottom elevation of the grid cells + - x : a 1D array of the x coordinates of the grid cell centers + - y : a 1D array of the y coordinates of the grid cell centers + - layer : a 1D array of the layer indices + - xv : a 1D array of the x coordinates of the grid vertices + - yv : a 1D array of the y coordinates of the grid vertices + + The dataset also includes the attributes specified in the `attrs` + dictionary, and a coordinate reference system specified by `crs`, if + provided. + """ + if attrs is None: + attrs = {} + + attrs.update( + {"extent": extent, "angrot": angrot, "xorigin": xorigin, "yorigin": yorigin} + ) + + if isinstance(nlay, int): + layers = range(nlay) + else: + layers = nlay + + coords = dict(x=x, y=y, layer=layers) + dims = ("layer", "icell2d") + ds = xr.Dataset( + data_vars=dict( + top=(dims[1:], top), + botm=(dims, botm), + ), + coords=coords, + attrs=attrs, + ) + + # add extra modelgrid information to ds + ds["xv"] = ("iv", xv) + ds["yv"] = ("iv", yv) + + if crs is not None: + ds.rio.set_crs(crs) + return ds + + def get_ds( extent, delr=100.0, @@ -255,7 +448,7 @@ def get_ds( transport=False, **kwargs, ): - """Create a model dataset from scratch, so without a layer model. + """Create a model dataset from scratch. Parameters ---------- @@ -267,7 +460,7 @@ def get_ds( The gridsize along rows (dy). Set to delr when None. If None delc=delr. The default is None. model_name : str, optional - name of the model. THe default is None + name of the model. The default is None model_ws : str, optional workspace of the model. This is where modeldata is saved to. The default is None. @@ -294,7 +487,7 @@ def get_ds( (len(layer), len(y), len(x)) or it is transformed to that shape if kv is a float or a list/array of len(layer). The default is 1.0. crs : int, optional - THe coordinate reference system of the model. The default is 28992. + The coordinate reference system of the model. The default is 28992. xorigin : float, optional x-position of the lower-left corner of the model grid. Only used when angrot is not 0. The defauls is 0.0. @@ -354,8 +547,8 @@ def get_ds( if isinstance(par, numbers.Number): if np.isnan(par) and (extrapolate or fill_nan): raise ValueError( - "extrapolate and remove_nan_layer should be " - "False when setting model parameters to nan" + "'extrapolate' and 'remove_nan_layer' should be " + "False when setting model parameters to NaN" ) resample._set_angrot_attributes(extent, xorigin, yorigin, angrot, attrs) From c0770dd265000b3076eb00c8e19898717e35a283 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 14:35:34 +0200 Subject: [PATCH 09/28] add modelgrid_to_ds function - allow creation of datasets based on flopy modelgrid objects - supports both vertex and structured grid --- nlmod/dims/grid.py | 65 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 63 insertions(+), 2 deletions(-) diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index 06295d1b..2e030902 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -26,7 +26,7 @@ from tqdm import tqdm from .. import cache, util -from .base import extrapolate_ds +from .base import extrapolate_ds, get_structured_grid_ds, get_vertex_grid_ds from .layers import fill_nan_top_botm_kh_kv, get_first_active_layer, set_idomain from .rdp import rdp from .resample import ( @@ -172,6 +172,67 @@ def modelgrid_to_vertex_ds(mg, ds, nodata=-1): return ds +def modelgrid_to_ds(mg): + """Create Dataset from flopy modelgrid object. + + Parameters + ---------- + mg : flopy.discretization.Grid + flopy modelgrid object + + Returns + ------- + ds : xarray.Dataset + Dataset containing grid information + """ + if mg.grid_type == "structured": + x, y = mg.xyedges + + ds = get_structured_grid_ds( + xedges=x, + yedges=y, + nlay=mg.nlay, + botm=mg.botm, + top=mg.top, + xorigin=0.0, + yorigin=0.0, + angrot=mg.angrot, + attrs=None, + crs=None, + ) + elif mg.grid_type == "vertex": + nodata = -1 # no data value for vertex indices + + ds = get_vertex_grid_ds( + x=mg.xcellcenters, + y=mg.ycellcenters, + xv=mg.verts[:, 0], + yv=mg.verts[:, 1], + extent=mg.extent, + nlay=mg.nlay, + angrot=mg.angrot, + xorigin=np.min(mg.xvertices), + yorigin=np.min(mg.yvertices), + botm=mg.botm, + top=mg.top, + attrs=None, + crs=None, + ) + + # set extra grid information + cell2d = mg.cell2d + ncvert_max = np.max([x[3] for x in cell2d]) + icvert = np.full((mg.ncpl, ncvert_max), nodata) + for i in range(mg.ncpl): + icvert[i, : cell2d[i][3]] = cell2d[i][4:] + ds["icvert"] = ("icell2d", "icv"), icvert + ds["icvert"].attrs["_FillValue"] = nodata + else: + raise NotImplementedError(f"Grid type '{mg.grid_type}' not supported!") + + return ds + + def gridprops_to_vertex_ds(gridprops, ds, nodata=-1): """Gridprops is a dictionary containing keyword arguments needed to generate a flopy modelgrid instance.""" @@ -390,7 +451,7 @@ def ds_to_gridprops(ds_in, gridprops, method="nearest", nodata=-1): def get_xyi_icell2d(gridprops=None, ds=None): - """Get x and y coördinates of the cell mids from the cellids in the grid + """Get x and y coordinates of the cell mids from the cellids in the grid properties. Parameters From 1b6488beddf42b867194dff76e53677e2c261366 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 14:56:15 +0200 Subject: [PATCH 10/28] code formatting --- nlmod/dims/base.py | 4 ++-- nlmod/dims/grid.py | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/nlmod/dims/base.py b/nlmod/dims/base.py index d9fdaa78..8c858e76 100644 --- a/nlmod/dims/base.py +++ b/nlmod/dims/base.py @@ -78,7 +78,7 @@ def to_model_ds( transport=False, ): """Transform an input dataset to a groundwater model dataset. - + Optionally select a different grid size. Parameters @@ -294,7 +294,7 @@ def get_structured_grid_ds( The dataset also includes the attributes specified in the `attrs` dictionary, and a coordinate reference system specified by `crs`, if provided. - """ + """ if attrs is None: attrs = {} diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index 2e030902..dd3cf41e 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -1329,8 +1329,9 @@ def gdf_to_grid( desc="Intersecting with grid", **kwargs, ): - """Cut a geodataframe gdf by the grid of a flopy modflow model ml. This method is a - wrapper around the GridIntersect method from flopy. + """Intersect a geodataframe with the grid of a MODFLOW model. + + Note: This method is a wrapper around the GridIntersect method in flopy. Parameters ---------- From 224f8ba73a23de6c02672b9ac148fdb92dbb9edf Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 15:14:31 +0200 Subject: [PATCH 11/28] improve x, y-origin calculation --- nlmod/dims/grid.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index dd3cf41e..87d9f903 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -211,8 +211,8 @@ def modelgrid_to_ds(mg): extent=mg.extent, nlay=mg.nlay, angrot=mg.angrot, - xorigin=np.min(mg.xvertices), - yorigin=np.min(mg.yvertices), + xorigin=np.concatenate(mg.xvertices).min(), + yorigin=np.concatenate(mg.yvertices).min(), botm=mg.botm, top=mg.top, attrs=None, From 8576c3c0103d31dc4ca7915e82010de65dc4a7d4 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 1 May 2023 16:20:57 +0200 Subject: [PATCH 12/28] codacy suggestion --- nlmod/dims/base.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/nlmod/dims/base.py b/nlmod/dims/base.py index 8c858e76..6d56ad00 100644 --- a/nlmod/dims/base.py +++ b/nlmod/dims/base.py @@ -307,7 +307,11 @@ def get_structured_grid_ds( resample._set_angrot_attributes(extent, xorigin, yorigin, angrot, attrs) - coords = dict(x=xcenters, y=ycenters, layer=range(nlay)) + coords = { + "x": xcenters, + "y": ycenters, + "layer": range(nlay), + } if angrot != 0.0: affine = resample.get_affine_mod_to_world(attrs) xc, yc = affine * np.meshgrid(xcenters, ycenters) @@ -407,7 +411,7 @@ def get_vertex_grid_ds( else: layers = nlay - coords = dict(x=x, y=y, layer=layers) + coords = {"x": x, "y": y, "layer": layers} dims = ("layer", "icell2d") ds = xr.Dataset( data_vars=dict( From 8d242ca9237d8588f564b557d519c8162f4e8b45 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 8 May 2023 10:54:01 +0200 Subject: [PATCH 13/28] some improvements: - add gridtype attr - improve reading grids at real-world coords - set delr/delc for structured grids --- nlmod/dims/base.py | 33 +++++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/nlmod/dims/base.py b/nlmod/dims/base.py index 6d56ad00..a0c1f599 100644 --- a/nlmod/dims/base.py +++ b/nlmod/dims/base.py @@ -298,9 +298,16 @@ def get_structured_grid_ds( if attrs is None: attrs = {} + attrs.update({"gridtype": "structured"}) # get extent from local grid edge coordinates - extent = [np.min(xedges), np.max(xedges), np.min(yedges), np.max(yedges)] + extent = [ + np.min(xedges), + np.max(xedges), + np.min(yedges), + np.max(yedges), + ] + # calculate centers xcenters = xedges[:-1] + np.diff(xedges) / 2.0 ycenters = yedges[:-1] + np.diff(yedges) / 2.0 @@ -308,8 +315,8 @@ def get_structured_grid_ds( resample._set_angrot_attributes(extent, xorigin, yorigin, angrot, attrs) coords = { - "x": xcenters, - "y": ycenters, + "x": xorigin + xcenters, + "y": yorigin + ycenters, "layer": range(nlay), } if angrot != 0.0: @@ -327,6 +334,18 @@ def get_structured_grid_ds( coords=coords, attrs=attrs, ) + # set delr and delc + delr = np.diff(xedges) + if len(np.unique(delr)) == 1: + ds.attrs["delr"] = np.unique(delr)[0] + else: + ds["delr"] = ("x"), delr + delc = -np.diff(yedges) + if len(np.unique(delc)) == 1: + ds.attrs["delc"] = np.unique(delc)[0] + else: + ds["delc"] = ("y"), delc + if crs is not None: ds.rio.set_crs(crs) return ds @@ -403,7 +422,13 @@ def get_vertex_grid_ds( attrs = {} attrs.update( - {"extent": extent, "angrot": angrot, "xorigin": xorigin, "yorigin": yorigin} + { + "extent": extent, + "angrot": angrot, + "xorigin": xorigin, + "yorigin": yorigin, + "gridtype": "vertex", + } ) if isinstance(nlay, int): From c4ca68d095bbf2cc2b3a8ca25a540b462c8a31a5 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 8 May 2023 10:54:37 +0200 Subject: [PATCH 14/28] set gridgen_ws add correct x,y-offsets --- nlmod/dims/grid.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index 87d9f903..dc748661 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -7,6 +7,7 @@ - fill, interpolate and resample grid data """ import logging +import os import warnings import flopy @@ -194,8 +195,8 @@ def modelgrid_to_ds(mg): nlay=mg.nlay, botm=mg.botm, top=mg.top, - xorigin=0.0, - yorigin=0.0, + xorigin=mg.xoffset, + yorigin=mg.yoffset, angrot=mg.angrot, attrs=None, crs=None, @@ -297,7 +298,7 @@ def refine( ds : xarray.Datset A structured model Dataset. model_ws : str, optional - The working directory fpr GridGen. Get from ds when model_ws is None. + The working directory for GridGen. Get from ds when model_ws is None. The default is None. refinement_features : list of tuples of length 2 or 3, optional List of tuples containing refinement features. Each tuple must be of @@ -328,7 +329,8 @@ def refine( exe_name = util.get_exe_path("gridgen") if model_ws is None: - model_ws = ds.model_ws + model_ws = os.path.join(ds.model_ws, "gridgen") + os.makedirs(model_ws, exist_ok=True) if version.parse(flopy.__version__) < version.parse("3.3.6"): sim = flopy.mf6.MFSimulation() @@ -1329,8 +1331,8 @@ def gdf_to_grid( desc="Intersecting with grid", **kwargs, ): - """Intersect a geodataframe with the grid of a MODFLOW model. - + """Intersect a geodataframe with the grid of a MODFLOW model. + Note: This method is a wrapper around the GridIntersect method in flopy. Parameters From f7b65eda69b7918826489715ef7029e7777cf074 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Mon, 8 May 2023 10:55:48 +0200 Subject: [PATCH 15/28] improve dealing with ssm packages --- nlmod/gwf/gwf.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/nlmod/gwf/gwf.py b/nlmod/gwf/gwf.py index dbce476a..9118285b 100644 --- a/nlmod/gwf/gwf.py +++ b/nlmod/gwf/gwf.py @@ -365,9 +365,10 @@ def ghb(ds, gwf, da_name, pname="ghb", auxiliary=None, **kwargs): **kwargs, ) if (auxiliary is not None) and (ds.transport == 1): + logger.info("-> adding GHB to SSM sources list") ssm_sources = ds.attrs["ssm_sources"] - if ghb.name not in ssm_sources: - ssm_sources += ghb.name + if ghb.package_name not in ssm_sources: + ssm_sources += [ghb.package_name] ds.attrs["ssm_sources"] = ssm_sources return ghb @@ -571,9 +572,10 @@ def chd( **kwargs, ) if (auxiliary is not None) and (ds.transport == 1): + logger.info("-> adding CHD to SSM sources list") ssm_sources = ds.attrs["ssm_sources"] - if chd.name not in ssm_sources: - ssm_sources += chd.name + if chd.package_name not in ssm_sources: + ssm_sources += [chd.package_name] ds.attrs["ssm_sources"] = ssm_sources return chd From 0de78bb8035733e740b0509208ee3f9623dede56 Mon Sep 17 00:00:00 2001 From: Martin Vonk Date: Tue, 2 May 2023 11:49:26 +0200 Subject: [PATCH 16/28] fix reading ascii file header if key is not in header fix #171 header reading is now fine if not all ascii keys: "ncols", "nrows", "nodata_value", "xllcorner", "yllcorner", "cellsize", "xllcenter", "yllcenter", are in the header --- nlmod/read/meteobase.py | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/nlmod/read/meteobase.py b/nlmod/read/meteobase.py index 00b2f70c..ca507d66 100644 --- a/nlmod/read/meteobase.py +++ b/nlmod/read/meteobase.py @@ -89,15 +89,30 @@ def read_ascii(fo: FileIO) -> Union[np.ndarray, dict]: Union[np.ndarray, dict] Numpy array with data and header meta """ + ascii_header_keys = [ + "ncols", + "nrows", + "nodata_value", + "xllcorner", + "yllcorner", + "cellsize", + "xllcenter", + "yllcenter", + ] + # read file lines = fo.readlines() # extract header meta = {} - for line in lines[0:6]: - l1, l2 = str(line, encoding="utf-8").split() + line_cnt = 0 + for line in lines: + linestr = str(line, encoding="utf-8").lower() + if not any([x for x in ascii_header_keys if x in str(linestr)]): + break + l1, l2 = linestr.split() if l1.lower() in ("ncols", "nrows", "nodata_value"): - l2 = int(l2) + meta[l1] = int(l2) elif l1.lower() in ( "xllcorner", "yllcorner", @@ -105,14 +120,11 @@ def read_ascii(fo: FileIO) -> Union[np.ndarray, dict]: "xllcenter", "yllcenter", ): - l2 = float(l2) - else: - raise ValueError(f"Found unknown key '{l1}' in ASCII header") - - meta[l1.lower()] = l2 + meta[l1] = float(l2) + line_cnt += 1 # extract data - data = np.array([x.split() for x in lines[6:]], dtype=float) + data = np.array([x.split() for x in lines[line_cnt:]], dtype=float) return data, meta From ad39be6270f1ca568a5024efc16121de8b10440c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ruben=20Calj=C3=A9?= Date: Wed, 3 May 2023 16:15:31 +0200 Subject: [PATCH 17/28] Minor change in surface_water.py --- nlmod/gwf/surface_water.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/nlmod/gwf/surface_water.py b/nlmod/gwf/surface_water.py index 3031cf9f..6315769c 100644 --- a/nlmod/gwf/surface_water.py +++ b/nlmod/gwf/surface_water.py @@ -495,8 +495,9 @@ def add_info_to_gdf( silent=False, min_total_overlap=0.5, geom_type="Polygon", + add_index_from_column=None, ): - """Add information from 'gdf_from' to 'gdf_to'.""" + """Add information from 'gdf_from' to 'gdf_to', based on the spatial intersection.""" gdf_to = gdf_to.copy() if columns is None: columns = gdf_from.columns[~gdf_from.columns.isin(gdf_to.columns)] @@ -523,6 +524,8 @@ def add_info_to_gdf( # take the largest ind = measure.idxmax() gdf_to.loc[index, columns] = gdf_from.loc[ind, columns] + if add_index_from_column: + gdf_to.loc[index, add_index_from_column] = ind return gdf_to @@ -762,7 +765,7 @@ def add_bottom_height_from_waterboards( columns=columns, min_total_overlap=min_total_overlap, desc=f"Adding {columns} from {wb}", - geom_type=None, + geom_type="LineString", )[columns] return gdf From f1c920e54125c8b4db230577ace1ddc471b7d037 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ruben=20Calj=C3=A9?= Date: Mon, 8 May 2023 22:24:55 +0200 Subject: [PATCH 18/28] Knmi stations (#174) * Add option to only use most common station Slow determination of stations (locations.geo.get_nearest_point) is removed * solve minor bug and add test for most_common_station=True * Set gridgen files in a separate directory. Solves issue #158 * minor changes * Make most_common_station work with structured grids as well * Create gridgen directory when it does not exist * Solve fiona.errors.DriverError: not recognized as a supported file format. * Remove rasterstats as a dependency for tests and docs * Codacy stuff --- docs/getting_started.rst | 2 +- docs/requirements.txt | 1 - nlmod/dims/grid.py | 2 +- nlmod/dims/layers.py | 4 ++ nlmod/dims/resample.py | 9 +++-- nlmod/read/knmi.py | 72 ++++++++++++++++++++------------- nlmod/read/webservices.py | 19 ++++++--- requirements.txt | 6 +++ tests/test_005_external_data.py | 8 ++++ 9 files changed, 81 insertions(+), 42 deletions(-) create mode 100644 requirements.txt diff --git a/docs/getting_started.rst b/docs/getting_started.rst index c8e08598..ca9ecef6 100644 --- a/docs/getting_started.rst +++ b/docs/getting_started.rst @@ -121,4 +121,4 @@ potential solutions. On top of that there are some optional dependecies, only needed (and imported) in a single method: - bottleneck (used in calculate_gxg) -- geocube (used in add_min_ahn_to_gdf) +- geocube (used in add_min_ahn_to_gdf) diff --git a/docs/requirements.txt b/docs/requirements.txt index 01b1ddd5..c0796e16 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,7 +3,6 @@ Ipython ipykernel nbsphinx netCDF4==1.5.7 -rasterstats geocube bottleneck contextily \ No newline at end of file diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index dc748661..72e1f6af 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -9,7 +9,7 @@ import logging import os import warnings - +import os import flopy import geopandas as gpd import numpy as np diff --git a/nlmod/dims/layers.py b/nlmod/dims/layers.py index 197fc8ab..af12af55 100644 --- a/nlmod/dims/layers.py +++ b/nlmod/dims/layers.py @@ -47,6 +47,10 @@ def calculate_thickness(ds, top="top", bot="botm"): else: raise ValueError("2d top should have same last dimension as bot") if isinstance(ds[bot], xr.DataArray): + if hasattr(ds[bot], "long_name"): + thickness.attrs["long_name"] = "thickness" + if hasattr(ds[bot], "standard_name"): + thickness.attrs["standard_name"] = "thickness_of_layer" if hasattr(ds[bot], "units"): if ds[bot].units == "mNAP": thickness.attrs["units"] = "m" diff --git a/nlmod/dims/resample.py b/nlmod/dims/resample.py index 756f34a1..a9e01e28 100644 --- a/nlmod/dims/resample.py +++ b/nlmod/dims/resample.py @@ -375,11 +375,12 @@ def vertex_da_to_ds(da, ds, method="nearest"): Parameters ---------- da : xaray.DataArray - A vertex DataArray. When the DataArray does not have 'icell2d' as a - dimension, the original DataArray is retured. The DataArray da can - contain other dimensions as well (for example 'layer' or time'' ). + A vertex DataArray. When the DataArray does not have 'icell2d' as a dimension, + the original DataArray is retured. The DataArray da can contain other dimensions + as well (for example 'layer' or time'' ). ds : xarray.Dataset - The model dataset with coordinates x and y. + The model dataset to which the DataArray needs to be resampled, with coordinates + x and y. method : str, optional The interpolation method, see griddata. The default is "nearest". diff --git a/nlmod/read/knmi.py b/nlmod/read/knmi.py index addd1e62..ad851ffa 100644 --- a/nlmod/read/knmi.py +++ b/nlmod/read/knmi.py @@ -2,6 +2,7 @@ import logging import hydropandas as hpd +from hydropandas.io import knmi as hpd_knmi import numpy as np import pandas as pd @@ -13,7 +14,7 @@ @cache.cache_netcdf -def get_recharge(ds, method="linear"): +def get_recharge(ds, method="linear", most_common_station=False): """add multiple recharge packages to the groundwater flow model with knmi data by following these steps: @@ -41,6 +42,9 @@ def get_recharge(ds, method="linear"): If 'linear', calculate recharge by subtracting evaporation from precipitation. If 'separate', add precipitation as 'recharge' and evaporation as 'evaporation'. The defaults is 'linear'. + most_common_station : bool, optional + When True, only download data from the station that is most common in the model + area. The default is False Returns ------- @@ -51,7 +55,7 @@ def get_recharge(ds, method="linear"): if "time" not in ds: raise ( AttributeError( - "'Dataset' object has no attribute 'time'. " + "'Dataset' object has no 'time' dimension. " "Please run nlmod.time.set_ds_time()" ) ) @@ -71,35 +75,27 @@ def get_recharge(ds, method="linear"): shape = [len(ds_out[dim]) for dim in dims] locations, oc_knmi_prec, oc_knmi_evap = get_knmi_at_locations( - ds, start=start, end=end - ) - - # add closest precipitation and evaporation measurement station to each cell - locations[["prec_point", "distance"]] = locations.geo.get_nearest_point( - oc_knmi_prec - ) - locations[["evap_point", "distance"]] = locations.geo.get_nearest_point( - oc_knmi_evap + ds, start=start, end=end, most_common_station=most_common_station ) if method in ["linear"]: ds_out["recharge"] = dims, np.zeros(shape) # find unique combination of precipitation and evaporation station - unique_combinations = locations.drop_duplicates(["prec_point", "evap_point"])[ - ["prec_point", "evap_point"] + unique_combinations = locations.drop_duplicates(["stn_rd", "stn_ev24"])[ + ["stn_rd", "stn_ev24"] ].values - for prec_stn, evap_stn in unique_combinations: + for stn_rd, stn_ev24 in unique_combinations: # get locations with the same prec and evap station - loc_sel = locations.loc[ - (locations["prec_point"] == prec_stn) - & (locations["evap_point"] == evap_stn) - ] + mask = (locations["stn_rd"] == stn_rd) & (locations["stn_ev24"] == stn_ev24) + loc_sel = locations.loc[mask] # calculate recharge time series - prec = oc_knmi_prec.loc[prec_stn, "obs"]["RD"].resample("D").nearest() - evap = oc_knmi_evap.loc[evap_stn, "obs"]["EV24"].resample("D").nearest() + index = oc_knmi_prec.index[oc_knmi_prec.station == stn_rd][0] + prec = oc_knmi_prec.loc[index, "obs"]["RD"].resample("D").nearest() + index = oc_knmi_evap.index[oc_knmi_evap.station == stn_ev24][0] + evap = oc_knmi_evap.loc[index, "obs"]["EV24"].resample("D").nearest() ts = (prec - evap).dropna() ts.name = f"{prec.name}-{evap.name}" @@ -107,14 +103,17 @@ def get_recharge(ds, method="linear"): elif method == "separate": ds_out["recharge"] = dims, np.zeros(shape) - for stn in locations["prec_point"].unique(): - ts = oc_knmi_prec.loc[stn, "obs"]["RD"] - loc_sel = locations.loc[(locations["prec_point"] == stn)] + for stn in locations["stn_rd"].unique(): + index = oc_knmi_prec.index[oc_knmi_prec.station == stn][0] + ts = oc_knmi_prec.loc[index, "obs"]["RD"].resample("D").nearest() + loc_sel = locations.loc[(locations["stn_rd"] == stn)] _add_ts_to_ds(ts, loc_sel, "recharge", ds_out) + ds_out["evaporation"] = dims, np.zeros(shape) - for stn in locations["evap_point"].unique(): - ts = oc_knmi_evap.loc[stn, "obs"]["EV24"] - loc_sel = locations.loc[(locations["evap_point"] == stn)] + for stn in locations["stn_ev24"].unique(): + index = oc_knmi_evap.index[oc_knmi_evap.station == stn][0] + ts = oc_knmi_evap.loc[index, "obs"]["EV24"].resample("D").nearest() + loc_sel = locations.loc[(locations["stn_ev24"] == stn)] _add_ts_to_ds(ts, loc_sel, "evaporation", ds_out) else: raise (Exception(f"Unknown method: {method}")) @@ -225,7 +224,7 @@ def get_locations_structured(ds): return locations -def get_knmi_at_locations(ds, start="2010", end=None): +def get_knmi_at_locations(ds, start="2010", end=None, most_common_station=False): """get knmi data at the locations of the active grid cells in ds. Parameters @@ -258,14 +257,29 @@ def get_knmi_at_locations(ds, start="2010", end=None): locations = get_locations_vertex(ds) else: raise ValueError("gridtype should be structured or vertex") + locations["stn_rd"] = hpd_knmi.get_nearest_station_df(locations, meteo_var="RD") + locations["stn_ev24"] = hpd_knmi.get_nearest_station_df(locations, meteo_var="EV24") + if most_common_station: + if ds.gridtype == "structured": + # set the most common station to all locations + locations["stn_rd"] = locations["stn_rd"].value_counts().idxmax() + locations["stn_ev24"] = locations["stn_ev24"].value_counts().idxmax() + else: + # set the station with the largest area to all locations + locations["area"] = ds["area"].loc[locations.index] + locations["stn_rd"] = locations.groupby("stn_rd").sum()["area"].idxmax() + locations["stn_ev24"] = locations.groupby("stn_ev24").sum()["area"].idxmax() + + stns_rd = locations["stn_rd"].unique() + stns_ev24 = locations["stn_ev24"].unique() # get knmi data stations closest to any grid cell oc_knmi_prec = hpd.ObsCollection.from_knmi( - locations=locations, starts=[start], ends=[end], meteo_vars=["RD"] + stns=stns_rd, starts=[start], ends=[end], meteo_vars=["RD"] ) oc_knmi_evap = hpd.ObsCollection.from_knmi( - locations=locations, starts=[start], ends=[end], meteo_vars=["EV24"] + stns=stns_ev24, starts=[start], ends=[end], meteo_vars=["EV24"] ) return locations, oc_knmi_prec, oc_knmi_evap diff --git a/nlmod/read/webservices.py b/nlmod/read/webservices.py index c74892eb..850a564f 100644 --- a/nlmod/read/webservices.py +++ b/nlmod/read/webservices.py @@ -1,6 +1,6 @@ import logging import xml.etree.ElementTree as ET - +from io import BytesIO import geopandas as gpd import numpy as np import pandas as pd @@ -138,6 +138,7 @@ def wfs( paged=True, max_record_count=None, driver="GML", + timeout=120, ): """Download data from a wfs server.""" params = dict(version=version, request="GetFeature") @@ -191,7 +192,9 @@ def add_constrains(elem, constraints): # get the number of features params["resultType"] = "hits" - r = requests.get(url, params=params, timeout=120) + r = requests.get(url, params=params, timeout=timeout) + if not r.ok: + raise (Exception(f"Request not successful: {r.url}")) params.pop("resultType") root = ET.fromstring(r.text) if "ExceptionReport" in root.tag: @@ -209,13 +212,17 @@ def add_constrains(elem, constraints): params["count"] = max_record_count for ip in range(int(np.ceil(n / max_record_count))): params["startindex"] = ip * max_record_count - req_url = requests.Request("GET", url, params=params).prepare().url - gdfs.append(gpd.read_file(req_url, driver=driver)) + r = requests.get(url, params=params, timeout=timeout) + if not r.ok: + raise (Exception(f"Request not successful: {r.url}")) + gdfs.append(gpd.read_file(BytesIO(r.content), driver=driver)) gdf = pd.concat(gdfs).reset_index(drop=True) else: # download all features in one go - req_url = requests.Request("GET", url, params=params).prepare().url - gdf = gpd.read_file(req_url, driver=driver) + r = requests.get(url, params=params, timeout=timeout) + if not r.ok: + raise (Exception(f"Request not successful: {r.url}")) + gdf = gpd.read_file(BytesIO(r.content), driver=driver) return gdf diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..96ea70f4 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +nbconvert>=6.4.5 +netCDF4==1.5.7 +geocube +gdown +bottleneck +contextily diff --git a/tests/test_005_external_data.py b/tests/test_005_external_data.py index 37f9f22c..cc9d1f35 100644 --- a/tests/test_005_external_data.py +++ b/tests/test_005_external_data.py @@ -11,6 +11,14 @@ def test_get_recharge(): ds.update(nlmod.read.knmi.get_recharge(ds)) +def test_get_reacharge_most_common(): + # model with sea + ds = test_001_model.get_ds_from_cache("basic_sea_model") + + # add knmi recharge to the model dataset + ds.update(nlmod.read.knmi.get_recharge(ds, most_common_station=True)) + + def test_get_recharge_steady_state(): # model with sea ds = test_001_model.get_ds_from_cache("basic_sea_model") From f931206c398782ceb44e8f5aba241258c37191ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ruben=20Calj=C3=A9?= Date: Mon, 8 May 2023 22:25:54 +0200 Subject: [PATCH 19/28] Knmi stations (#174) * Add option to only use most common station Slow determination of stations (locations.geo.get_nearest_point) is removed * solve minor bug and add test for most_common_station=True * Set gridgen files in a separate directory. Solves issue #158 * minor changes * Make most_common_station work with structured grids as well * Create gridgen directory when it does not exist * Solve fiona.errors.DriverError: not recognized as a supported file format. * Remove rasterstats as a dependency for tests and docs * Codacy stuff From ae08bd14da6a3f31af51a937e2b1424a9ee87d4f Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 09:18:03 +0200 Subject: [PATCH 20/28] update pyproject toml --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8733fd53..5e64363e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,7 +55,7 @@ repository = "https://github.com/ArtesiaWater/nlmod" documentation = "https://nlmod.readthedocs.io/en/latest/" [project.optional-dependencies] -full = ["gdown", "rasterstats", "geocube", "gdown", "bottleneck", "contextily"] +full = ["gdown", "geocube", "gdown", "bottleneck", "contextily"] test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test]", "netCDF4==1.5.7"] From d7d7f16378c0f1ec9b61f49b5248f96e3f8123ed Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 09:46:20 +0200 Subject: [PATCH 21/28] codacy --- nlmod/dcs.py | 2 +- nlmod/dims/grid.py | 2 +- nlmod/read/geotop.py | 2 +- nlmod/read/knmi.py | 2 +- nlmod/read/meteobase.py | 2 +- nlmod/read/rws.py | 4 ++-- nlmod/read/webservices.py | 1 + 7 files changed, 8 insertions(+), 7 deletions(-) diff --git a/nlmod/dcs.py b/nlmod/dcs.py index e7c0b670..e01a2f55 100644 --- a/nlmod/dcs.py +++ b/nlmod/dcs.py @@ -230,7 +230,7 @@ def plot_grid( horizontal=True, vertical=True, ilayers=None, - **kwargs + **kwargs, ): lines = [] if ilayers is None: diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index 72e1f6af..dc748661 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -9,7 +9,7 @@ import logging import os import warnings -import os + import flopy import geopandas as gpd import numpy as np diff --git a/nlmod/read/geotop.py b/nlmod/read/geotop.py index b2dace52..dfcb574a 100644 --- a/nlmod/read/geotop.py +++ b/nlmod/read/geotop.py @@ -196,7 +196,7 @@ def convert_geotop_to_ml_layers( lay = 0 logger.info("creating top and bot per geo eenheid") for geo_eenheid in geo_eenheden: - logger.debug(geo_eenheid) + logger.debug(int(geo_eenheid)) mask = geotop_ds_raw.strat == geo_eenheid geo_z = xr.where(mask, geotop_ds_raw.z, np.NaN) diff --git a/nlmod/read/knmi.py b/nlmod/read/knmi.py index ad851ffa..1abe66b9 100644 --- a/nlmod/read/knmi.py +++ b/nlmod/read/knmi.py @@ -2,9 +2,9 @@ import logging import hydropandas as hpd -from hydropandas.io import knmi as hpd_knmi import numpy as np import pandas as pd +from hydropandas.io import knmi as hpd_knmi from .. import cache, util from ..dims.layers import get_first_active_layer diff --git a/nlmod/read/meteobase.py b/nlmod/read/meteobase.py index ca507d66..b0eea605 100644 --- a/nlmod/read/meteobase.py +++ b/nlmod/read/meteobase.py @@ -108,7 +108,7 @@ def read_ascii(fo: FileIO) -> Union[np.ndarray, dict]: line_cnt = 0 for line in lines: linestr = str(line, encoding="utf-8").lower() - if not any([x for x in ascii_header_keys if x in str(linestr)]): + if not any((x for x in ascii_header_keys if x in str(linestr))): break l1, l2 = linestr.split() if l1.lower() in ("ncols", "nrows", "nodata_value"): diff --git a/nlmod/read/rws.py b/nlmod/read/rws.py index d3d4706c..0c519ec7 100644 --- a/nlmod/read/rws.py +++ b/nlmod/read/rws.py @@ -135,9 +135,9 @@ def get_northsea(ds, da_name="northsea"): def add_northsea(ds, cachedir=None): """Add datavariable bathymetry to model dataset. - Performs the following steps: + Performs the following steps: - a) get cells from modelgrid that are within the northsea, add data + a) get cells from modelgrid that are within the northsea, add data variable 'northsea' to ds b) fill top, bot, kh and kv add northsea cell by extrapolation c) get bathymetry (northsea depth) from jarkus. diff --git a/nlmod/read/webservices.py b/nlmod/read/webservices.py index 850a564f..6de47bd5 100644 --- a/nlmod/read/webservices.py +++ b/nlmod/read/webservices.py @@ -1,6 +1,7 @@ import logging import xml.etree.ElementTree as ET from io import BytesIO + import geopandas as gpd import numpy as np import pandas as pd From fc5839a74e844070d035e63420bb77840924b6f5 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 09:50:37 +0200 Subject: [PATCH 22/28] merge again... isort+blac --- nlmod/dims/grid.py | 2 +- nlmod/read/knmi.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/nlmod/dims/grid.py b/nlmod/dims/grid.py index 72e1f6af..dc748661 100644 --- a/nlmod/dims/grid.py +++ b/nlmod/dims/grid.py @@ -9,7 +9,7 @@ import logging import os import warnings -import os + import flopy import geopandas as gpd import numpy as np diff --git a/nlmod/read/knmi.py b/nlmod/read/knmi.py index 27d12d0a..1abe66b9 100644 --- a/nlmod/read/knmi.py +++ b/nlmod/read/knmi.py @@ -2,7 +2,6 @@ import logging import hydropandas as hpd -from hydropandas.io import knmi as hpd_knmi import numpy as np import pandas as pd from hydropandas.io import knmi as hpd_knmi From 9a970d9fc1a784ea2d7fc3b258006aeecf810c50 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 11:44:34 +0200 Subject: [PATCH 23/28] modify dependency grouping for rtd --- .readthedocs.yml | 2 +- pyproject.toml | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index cd955368..9cf35493 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -25,6 +25,6 @@ python: - method: pip path: . extra_requirements: - - ci + - nbtest - rtd diff --git a/pyproject.toml b/pyproject.toml index 5e64363e..7f51f266 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,9 +56,10 @@ documentation = "https://nlmod.readthedocs.io/en/latest/" [project.optional-dependencies] full = ["gdown", "geocube", "gdown", "bottleneck", "contextily"] -test = ["pytest>=7", "pytest-cov", "pytest-dependency", "nbformat", "nbconvert>6.4.5"] +test = ["pytest>=7", "pytest-cov", "pytest-dependency"] +nbtest = ["nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] -ci = ["nlmod[full,lint,test]", "netCDF4==1.5.7"] +ci = ["nlmod[full,lint,test,nbtest]", "netCDF4==1.5.7"] rtd = ["nbsphinx", "nbconvert>6.4.5"] [tool.setuptools.dynamic] From e42e0667d54b549f4e24d12cf9228ce3784c953a Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 11:47:37 +0200 Subject: [PATCH 24/28] add ipython --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 7f51f266..63e4fff5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,7 +60,7 @@ test = ["pytest>=7", "pytest-cov", "pytest-dependency"] nbtest = ["nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test,nbtest]", "netCDF4==1.5.7"] -rtd = ["nbsphinx", "nbconvert>6.4.5"] +rtd = ["ipython", "nbsphinx", "nbconvert>6.4.5"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" } From a9f629924ed11eeb1637351b2e3027bd82775313 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 13:40:45 +0200 Subject: [PATCH 25/28] attempt to remove metadata --- docs/examples/00_model_from_scratch.ipynb | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/docs/examples/00_model_from_scratch.ipynb b/docs/examples/00_model_from_scratch.ipynb index 9629ad19..b3a5f8ee 100644 --- a/docs/examples/00_model_from_scratch.ipynb +++ b/docs/examples/00_model_from_scratch.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -35,6 +36,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -53,6 +55,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -78,6 +81,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -105,6 +109,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -121,6 +126,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -144,6 +150,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -173,6 +180,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -215,6 +223,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -231,6 +240,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -247,6 +257,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -276,6 +287,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ From d2715818ab0a6fc771509d647af26e02e5da8748 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 17:26:01 +0200 Subject: [PATCH 26/28] attempt to remove metadata --- docs/examples/00_model_from_scratch.ipynb | 729 +++++++++++++++++++++- 1 file changed, 706 insertions(+), 23 deletions(-) diff --git a/docs/examples/00_model_from_scratch.ipynb b/docs/examples/00_model_from_scratch.ipynb index b3a5f8ee..a70fb62b 100644 --- a/docs/examples/00_model_from_scratch.ipynb +++ b/docs/examples/00_model_from_scratch.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -90,9 +90,550 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mINFO:nlmod.dims.base:resample layer model data to structured modelgrid\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (y: 100, x: 100, layer: 3)\n",
+       "Coordinates:\n",
+       "  * layer    (layer) int64 1 2 3\n",
+       "  * x        (x) float64 -495.0 -485.0 -475.0 -465.0 ... 465.0 475.0 485.0 495.0\n",
+       "  * y        (y) float64 495.0 485.0 475.0 465.0 ... -465.0 -475.0 -485.0 -495.0\n",
+       "Data variables:\n",
+       "    top      (y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
+       "    botm     (layer, y, x) float64 -10.0 -10.0 -10.0 -10.0 ... -30.0 -30.0 -30.0\n",
+       "    kh       (layer, y, x) float64 10.0 10.0 10.0 10.0 ... 20.0 20.0 20.0 20.0\n",
+       "    kv       (layer, y, x) float64 5.0 5.0 5.0 5.0 5.0 ... 10.0 10.0 10.0 10.0\n",
+       "    area     (y, x) float64 100.0 100.0 100.0 100.0 ... 100.0 100.0 100.0 100.0\n",
+       "    idomain  (layer, y, x) int64 1 1 1 1 1 1 1 1 1 1 1 ... 1 1 1 1 1 1 1 1 1 1 1\n",
+       "Attributes:\n",
+       "    extent:                    [-500, 500, -500, 500]\n",
+       "    gridtype:                  structured\n",
+       "    delr:                      10.0\n",
+       "    delc:                      10.0\n",
+       "    model_name:                from_scratch\n",
+       "    mfversion:                 mf6\n",
+       "    model_dataset_created_on:  20230509_17:25:09\n",
+       "    exe_name:                  /home/david/Github/nlmod/nlmod/bin/mf6\n",
+       "    model_ws:                  ./scratch_model\n",
+       "    figdir:                    ./scratch_model/figure\n",
+       "    cachedir:                  ./scratch_model/cache\n",
+       "    transport:                 0
" + ], + "text/plain": [ + "\n", + "Dimensions: (y: 100, x: 100, layer: 3)\n", + "Coordinates:\n", + " * layer (layer) int64 1 2 3\n", + " * x (x) float64 -495.0 -485.0 -475.0 -465.0 ... 465.0 475.0 485.0 495.0\n", + " * y (y) float64 495.0 485.0 475.0 465.0 ... -465.0 -475.0 -485.0 -495.0\n", + "Data variables:\n", + " top (y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n", + " botm (layer, y, x) float64 -10.0 -10.0 -10.0 -10.0 ... -30.0 -30.0 -30.0\n", + " kh (layer, y, x) float64 10.0 10.0 10.0 10.0 ... 20.0 20.0 20.0 20.0\n", + " kv (layer, y, x) float64 5.0 5.0 5.0 5.0 5.0 ... 10.0 10.0 10.0 10.0\n", + " area (y, x) float64 100.0 100.0 100.0 100.0 ... 100.0 100.0 100.0 100.0\n", + " idomain (layer, y, x) int64 1 1 1 1 1 1 1 1 1 1 1 ... 1 1 1 1 1 1 1 1 1 1 1\n", + "Attributes:\n", + " extent: [-500, 500, -500, 500]\n", + " gridtype: structured\n", + " delr: 10.0\n", + " delc: 10.0\n", + " model_name: from_scratch\n", + " mfversion: mf6\n", + " model_dataset_created_on: 20230509_17:25:09\n", + " exe_name: /home/david/Github/nlmod/nlmod/bin/mf6\n", + " model_ws: ./scratch_model\n", + " figdir: ./scratch_model/figure\n", + " cachedir: ./scratch_model/cache\n", + " transport: 0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds = nlmod.get_ds(\n", " extent,\n", @@ -118,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -135,9 +676,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mINFO:nlmod.sim.sim:creating modflow SIM\u001b[0m\n", + "\u001b[32mINFO:nlmod.sim.sim:creating modflow TDIS\u001b[0m\n", + "\u001b[32mINFO:nlmod.sim.sim:creating modflow IMS\u001b[0m\n", + "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow GWF\u001b[0m\n", + "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow DIS\u001b[0m\n", + "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow NPF\u001b[0m\n", + "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow IC\u001b[0m\n", + "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow OC\u001b[0m\n" + ] + } + ], "source": [ "sim = nlmod.sim.sim(ds)\n", "tdis = nlmod.sim.tdis(ds, sim)\n", @@ -159,9 +715,78 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xytopbotmQ
well no.
0100-50-5-10-100.0
1200150-20-30-300.0
\n", + "
" + ], + "text/plain": [ + " x y top botm Q\n", + "well no. \n", + "0 100 -50 -5 -10 -100.0\n", + "1 200 150 -20 -30 -300.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "wells = pd.DataFrame(columns=[\"x\", \"y\", \"top\", \"botm\", \"Q\"], index=range(2))\n", "wells.index.name = \"well no.\"\n", @@ -172,9 +797,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Adding WELs: 100%|██████████| 2/2 [00:00<00:00, 694.31it/s]\n" + ] + } + ], "source": [ "wel = nlmod.gwf.wells.wel_from_df(wells, gwf)" ] @@ -189,7 +822,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -211,7 +844,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -232,9 +865,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mINFO:nlmod.sim.sim:write model dataset to cache\u001b[0m\n", + "\u001b[32mINFO:nlmod.sim.sim:write modflow files to model workspace\u001b[0m\n", + "\u001b[32mINFO:nlmod.sim.sim:run model\u001b[0m\n" + ] + } + ], "source": [ "nlmod.sim.write_and_run(sim, ds, silent=True)" ] @@ -249,7 +892,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -266,9 +909,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(10, 8))\n", "\n", @@ -296,9 +952,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArUAAAJICAYAAAB/rByGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9W6wsS7sdCI2IyKyqOdda+375997//v9l2W657X6gJcsW0A9AY8kgJMtcj81FFi0OD3ZDGxA0EpiWJbAfGlqW2kI6WFY3PGAZS42O4AgDMogXS5wjEEj2C26D7Xm/r3mpS2ZGBA8RX8SXUZF1mzXnrLlWjqVUxYrIjMzKqhkZ9cUY4xPWWvTo0aNHjx49evTo8ZohX/oCevTo0aNHjx49evR4LPpJbY8ePXr06NGjR49Xj35S26NHjx49evTo0ePVo5/U9ujRo0ePHj169Hj16Ce1PXr06NGjR48ePV49+kltjx49evTo0aNHj1ePflLbIwshxJ8TQvwHttTXf0sI8a8JIf6b2+ivR48ePR6DLY9v/3khxP91G3316NHjcShe+gJ67D6EEBLAfwPAdwD+dwD+EwD+KoA/B+D/DOC/AuAU7vv0/wDwXwDwv7HW/j3fxc/W2r8ohPi3nvnSe/To0WMhHju+WWv/thDiP/T8V96jR48UfaS2xyrYB2AB/FMA/zKAfwfAvwLg9wO4BPBHANwC+NLv/39iE1qOPtNHjx49dg3bGt969OjxwugntT0W4b8ohPjXAPyAOKAra+2/D+CPAfj3rLUXAP7fAPYA/AO/j0n6+ae+n//fU19wjx49eqyIrYxvQoj/GIB/UQjxX3uWq+7Ro0cnRJ8mt8e6EEL8MQD/WWvtf/elr6VHjx49tol+fOvR4/Win9T26NGjR48ePXr0ePXo6Qc9evTo0aNHjx49Xj36SW2PHj169OjRo0ePV49+UtujR48ePXr06NHj1aOf1Pbo0aNHjx49evR49Vgr+cLe28/sZ19/CwBQRQnd1HNlwqbtj+rLAqosoeukndVts33RvhYWRVmiSdp5Xa79MffCdrUzLWDr+n17elw8VwHdNIC1rX3pZPwYWZQwjXvf1B7rAKVKaB2vxcK26qQqYXQNEi5afrwFpCpgtLsWaheqgNUNrLUQsoA1Dayx8/saCykLGNMApr0vAECI0C6kCO0QwjVLtOpCX4IOF+GcQohwXbE9vj+A7+vvpYj3RyDZtyhgGrYvu9f8uNx3RLDjwY7nx6Sfu+D9J+Xs+Rd8H6+P/smFtfZbvBK8++xz+/X33wMAyrJE7f9OeJnQ1b7Ovmu3W6AYlGiqZExhddtspzKXEm/vvVoU5QBNXYU2C6AsB6h9HS/H42NdON7y4/PnT8day+qszY3F8fosgKIo0bCxNK0L4z6NOa3+47MgN35aNr4aG8fdOBbGsdIahL9pajdszLNJGcDcmJaOPyKpo79vQeOfyP/N8/b2mBPHjLgv6GRs38z4s2RM4Z+lgIjPMzHf3t43YlvP+9N/+o9fbHz77Is/bJv64dnONxn/079rrf2Tz3bCR2CtSe1nX3+LP/Ov/xUAwBff/YCbs+O5MmHT9sf0ZYzd6rU85lqtXf9ajAW++PYXuDk/ce2sHI73dcbauXZrLT7/9hf44OuobJirYqyL+xqL1nG+N3z2zS9we+H2pbI2cSClOgB49833uLs4RaONbwfeff097i5PYbXG26++x/3VKYw/XmuLt199h/urM+jG4s2X3+Hh+gxN3fh2g/0vvsP45gxNbbH/+bcYfzhHU7n2ujbY++xbTG7P0cwajN59g+ndBfRMY/T2a0zvL2FnbgBqxg2Ge19hNrmCmdQYjL5CNb1C/eAHq2GBwfBLVLNryL0i7CsH7s+jGEkM33yN2cMlRFlg+PZrzO4vIQZuoUMNVDi/KlS4LlW6oVRJib3Pv8XkwzlUocJ7kcq3K4E3X3yHh5szSCnCvRCsrJQC4CbYb7/8DvfXbl+6h3zSS/fatcdy2g4hw2dEEFK06tJ2XiclFu77t//Sf/Wf4BXh6++/x//wf/ZvAwC+//EnnB4dzpUJXe3r7Ltuu7H2SfvvKnODnO9+/Alnvp2XAfdDdVE7rzPWzrUbm++fm8J+98NPODs+BCzw7Q8/4fzY9UXHf/vDjzg/PgIQy7yefnQbC3zzw4+4OD5CY0wo01u11uLrX/yIy5MjNDqW6V402uCr73/E1ekRtLH46vsfcHV6DN24q22sxZff/YDrs2M0tQ5jfe3Hx6aJ42+jTRhLZ7UOf0d15fatqyb8nVezJowJ1UQDAKazKow51SSOhc3YjZVyIENdMSgx+uwbTG8vUAzdmDAYlGFMKkoRxt2idGNOUaow5igVx5Si8ONfqcI1F0qGZwGA8L5Kv6+UMrxvKeJzh8YnpUR4rknBy/E7QPdSCBHKdLyQItx3AKGs2PG5dsGmvV9+/wOuT48XlgHg3/yv/+debHxr6gf8oX/hv/ds5/t//t///DfPdrJHok+T2wNSxM3Y5fv36NGjx67BjWFip8cxEX597ugF7jiEEGH7lCGEm8D3mMdak1pVlPjiux8AAF//8MtQz8u5unXaH9OXMXar1/KYa7XW4qtMO69L242xC9t5nbEWX/0iOd5afMnqqMwjtbGuY19aXrMWX3z/U9iXyjxSS3UWFp9/58pNEyO1n3/3oys3Gp99+2M4DnCR2HffuLqmtnj3zQ++3IR+3n7l6yqDN1/9AoCLWgBAURnsf+GWiutpjb3PXVmXDfbefefOVfhIrK0xeuNWibStMdxzPzqFX8ZUwyLUqb0So323rxz6SO2ewuit61MMitC/HCh/vArnL8oiXFeI1CqJN1+66y8KFd6LLFx7oSTefu3eq1QilF3U9AffhzuXlAj3TSoRynyQp3stpWiV03YhZSgThBThcwPQKqd1UiJ87q7+p7l9XxPKssT3P7r38OOvfh3qeTlXt+m+67Yba5+0/64ynyAu6svC4oefYx0vp3XG2rl2Y5E9np//h59/5c5lgV/4smGhZF4Xy6yeRWq//6Wra4wJZerKWIvvqF1bfPdTu71uDL796WcAgDYG3/zoyjT+NexZVNc6jNu0klXVJoy5dWPCWDqtmvB3RJHaalaHv/PZtAljQjF0Y6GYVNj/gsaUOBY20lOIhgp7n/nxaViG8akcuujpcFiGMakYyDDuln58K0sVzq+KOGZQpLYYqHDNRSFDWUCE90WRWqUkvvR1UsTnDo1PhRLhuSaFCPctRGKFyD6DqV3KfDuP1H7tPyte5uPnN6y9q9xjHkKIPwngrwFQAP6GtfavJu2/BvA3AXwL4ArAf8lae7Dt61hrUquburVc3lV+bPumfdGEaZvXsum1Et9pnb5o8OaUgpR+QHU0kKf0AwAtGkFKP4h1Hfty0hcQ6AdU5pNaqiOk9AMAgX4AYI5+4Ooc/QDAHP0AQKAfAJijHwAI9AMAgX4AoE0/mLj22eQKZurqqukVas8dVML9GVSza0hZhH2ldmVt3IA8e7iEqHw7px9UKpxfFSpcF6cfAAj0A3ovnH4AINAP6F4IVub0AwCBfkD3MA1ccMpBSj+gOuospR+kdSn9gOr821q672tBXdetpfmu8rL2dfZdp53+5p+q/65ymp+HUwZS+sGidl5H7yWlH+SOT3NuE/0AQIt+QHB1VD5qlTn9AECgH1CZ0w8ABPoBlTn9AECgH7hym34AINAPADfWN35fGr+IfgAg0A8AzNEPAAT6AYA5+gGAQD8A0KYfVDLUFbPSlW8v0Hj6gR64OqIfAJijHwAI9AN3LW36AV1zofyYchHHgZR+QO+bhqSUfgAg0A9i2e1Lk8/0GcrpB3TfCSn9INcu0N6B0wy6yi8Nkb6pF4QQQgH46wD+BIADAL8rhPhta+0/ZLv9mwD+l9baf9enlv4rAP7L276Wj8r9QEoRttcIKfx7eJ2XvxU4UcN6N0AoETZ/E7HxTTRs69Fjh+CW1kV42O8aBPv3mrBL91UK/wxb5Vqk2yT89T/3fXcK2s7mdZ7HUiL8SO7xKvHHAPwja+0/ttZWAP4WgD+V7POHAfw9X/6/ZNq3go+KfsDLhq1ZvRb6Aa9LqQhz7R8p/UD7qG5d6ZXpB03dxCW3QmPvM08/kDMA69MPhvuuLPd6+kFPP9gd+gEv8+jkrtAPeF1KRSDsIv3AWBvKYXx7IfpB1ejwdzSYurGwk34wdWOhGtTY9+MLiurZ6AelF9KqQmTpB0rK8L6UjGNhjn5Q+LFQip5+sBIEnvtXwDdCiN9j//8ta+1vsf//BOCfsf8fAPjjSR//LwD/aTiKwp8G8E4I8bW19nKbF/pR0Q94mU9qX+JaN6EftK4/Q0UI7R8x/YAmtbRktwr9QDd+Ge7uAs2U6AcXsBM3aV2LfgBGP7A9/SAt87qefvC89ANeTpfcd4F+wOtyVATevkv0Azr+4vgImtloAc9PP6j98XcXp5jN6Ad+B/3At1cTN45NPpxj6svPQj8o46QWmKcf0Jhze3ESJrVd9AOa1IoW5aCnH+wQLqy1f/SRffx3APzbQog/B+D/BuAQgH7shaXo3Q+eCFyladOnwhOeU2bOSZOPdHL7FKDBpfWjQkgISUtV63+H+ZLcWtQEmgFKCajN17esAax2ry+/QLkYr52C06PHuqDJTzq53QQ5bwJOT9AbnKOt2F/9eBGik9SHmxTSlhtLhZRh+9h5bI8d6wT857Lzo3oOYqc4tXATVB7K/qWvC7DWHsFFaiGEeAvgP2Otvdn2hfT0g2e4Vj7BfEr6AYBQl1IRXJ9PTz+g+940NixTW2PDkhVFVdehH5jGhuWxykct1FQvpx8oisQy+oGerU0/UAOF0dtvQ90u0w845QBATz9YAz394HXSD+Lx9tH0A7qv2kT6gTEIZRr/1qEfNI2JVAQ//q1CP6jI/WBah7/TaqbDmCCHfvxi9AMxiWOhIvpBKT5K+kFKNcjVLaIfCCGylIJXQT/YPfwugD8ohPh9cJPZ3wDwZ/kOQohvAFxZaw2A/z6cE8LW0dMPnuFa00jtU9EPeHuOikCR2qekH9B1NZ5ScHd5GjLb3F2ewmia1K5OPzBuHovxzTlq745AS28L6QeecxboB+MrmKnj2a5DP1CNpx+ML4Mjwq7SDzjlgNDTD1ZDTz/Il3edfhCPt6FuU/pBTOQQKQc0bl6eRKrBOvQDquPJF1ahH1R+n9q7uNxfRUeEh+uzQDXg9AOiLEzvLlCPKSugCHUfE/2A+ufP0HXoBxShzVEKevrBerDWNkKIvwDg78JZev1Na+0/EEL8ZQC/Z639bQD/EQB/RQhh4egHf/4pruWjpR9kl8F7vBpwKkVuyU6ouKFZo2OS2TIqgjU2bLDxNfI1VqctWOO+c/YjdU/I3L4eL4BtLrkvA/1geupTdSWBoa/aLv1JcUqUFZGiYCkiaSyUcBFCnRwHtJfOpW0vo6+6HE5/g+QYI6RYuqRuYWGt9ZP751u+zlEEnpoqRfd/t1bptwSxe8kXrLW/A+B3krq/xMp/B8Dfeerr6B9NPXr06NGjR48ePV49PtpILYH/GvyYorZcvLBJtGbT+6JWjIDziJ7OhFi4+OGx4OIIIXW0TwyKWIpmuBMLKQAhIP2ymqk1jNAwtYYaSBehNQZuFSWBsYC2z5KHsy0K2RJaor0erx2PHQeeCtyz1mZWWh593cJHkFfQXrUjwMTdtAtTg3etFG0yXvGxVq8xbtCfPT+ei85oKV74MYLGP+nHOlW6DnRtYGoL01iowfrX3/VeNjqefRbbxKpRy03FYbsowN0xodjO4KMViuXat51G9yWFYq19ef8rCsWAvGhsmVCMwMUNOaGYMbFON/NCMcPEY3Vl5oRiujZBMNXUZk4oVtQ6pIZsKsOEYnUQRRjlRWUi8an1QrDGOKGFERrD4dcAgHI0aInG6DUIxQYKIxKKkZCMCcWkUnNCjE2FYqpQQRQShWCPE4ql4rB1hWKLxGG9UOz5hGK59m2n0U33NXazvvikNi8Em29PRWOx7lds3/nUtjmhGICWaAxwgrGYJndeKGYt2j61SXujbRSKaYNvfJn4sVqbIEiqdduzFgCqJi8Um1U6lIOobNqEv9PZVIexsvT2hGrShPFFlnUrfTgA6MoE8Wz5pgxj1WDkfrSvIxQrBypcC+kDVhGKhTS5UrRS48ay+1w2FYrxySYXh32diLtScdiqQjEp86KyHruHj1Yolmt/ijS6LyUU4+U00rGKUIyQisaWCcUIJGjoEorRMXeXp0EIxoVi1H5/dRp8aLlQjMQVDzdn0ORTy4RiNOBPbs9DuxOKeZ/G+wtYLxprvJBiNr6EZp612gswDD1oqmvYqZvIVtMrSOEntV4wNhtfQtZuIJ89XEJoP6gzoZiUvsyEGJsKxWjfh+szFpVx93pjoVhGHLaOUGyZOKwXij1vGlte9xRpdHmZhplVhGK8nEZq54Rgdr49JxqjBZ8zJg7jorEuoRiBi8bomlya3HmhGF3RxclRELVensR2qrs6SYRiNKn1g+312XHwub05Ow7jJr3OpcmtdChTfT0jn9pTVLMoFKv8+DXz49z4wzlmJBpj6cO1F5xN7y+gjReK3V1Ae//adYRipY/+3l+dQqo4qQUWC8VCmlw/UPHUuK7s7vemQrE0UsvFYVw0lhOHrSIUo3PtjFBMoBc2dOCTuisvtYTAl4pWhRR44ZS5dM0ie9/SutXFDfP3X3iagnvNLLfLuBHNYJ3PkgspeF9SSUjVPpfVgNXWvVovquBCso8Um6Qn7rFbeOp0r8IvGz9HNtlNlqn5+5dBvLXucfP3LyeOlFJABUpApFItE2yF99XqMz/W5rb2WDnfrsq4hdThT4yuZ4Hy90it8CHQM3LuM/TPwE2eoY/FLlIOeizHJ0U/4OVt+Niuey1p6tyV6QXsWp+LfgAg+AmmVATA+TXmfWxNqMvRD6xvbxrDKAnRs5YiIPWsifQDbVopcwGgrptAP1BTvZB+oFUT6APKVhjtu7LxtgnS1IF+UIzKefrBKNIP1Kj4KOkHfELb0w9eJ/2Al7fhY7uY6vC09IN2O8LrIvoB0JUm1y6kH6SetUDiU5ukzKVzEv0g9awF3PhGy9UV86mlSG7V6DDmVrUNY21VL6YflNMm/M1TdjE1bsKYomZ1GBdl4aK23Lv7KegH5aCbckBlGn+66AeFIq5zm3JAZT6hfS76QUo52CX6gdi95As7g0+KfsDL2/KxXWffXOrcla41CRA+D/2A7ztPRdBmvu724mQp/YC8rsik/P7qNHrWXp/B0KTWc2cfbs5C+/jmHE1Nx7v2ye05ar8k10U/0DPyqb2MVITJVaQneL/aqrqGkUQ/uIZUftJqIv1AkU/tR0Y/SKO0Pf3g9dEPeHlbPrZd++aoCIRt0A/a7a68jH5A4KlzuzxrOf0g51lLmcMuTo6yKXPpkl3dvGct0aeuT6M37c1ZpCdQ3YfzE1R1HH9pIttFPyAf2vvrs1DP6QdVFekHladace/up6AflIM4plCUm1MObi8i1aCLfqBUu51TDm7OjueitM9BP8hRDnaGftCjEx+9+0EXPnYf21zKXL7k1ZUyl8aGTW9L8M/kimG2/G9XzJIrpYBUXjGsF18MX+oT0i+7yegZ2fJxVHF77Ce/616021w+6+lbrwtP7WPLqQjLTkETiZwLArD6tZKhiUTiWUtf7y2+VQHv0JJ0S9falS43tPO+AnVAQJgoeJJhyT06MfAle2PiD1FyLJHShHGRJnLcM1civgr/R9tyhFn2vvl1+eP5WNzad61xZX7fTTyvl41pXd6069Ljdp5yIHbPp3ZX0D+qevTo0aNHjx49erx6fPKT2uf8ZZb6C24LjxWHPMU9WNbnnMghEwlYeByLSLw0nLDMbT167BKeWjz2HMgJxnjUNn9MXjRGm4CPZqJdn7tX7eilF2qJuPFIaTg/F2+x6GGo59fXIQoL5+crTUyUFnysC8fPl0Umu1iyetW+h+uPn1nRMI8UrzHuPxY8Ar4JFt3zHq8Xn6xQLNe+ro/tY86VisYImwjFCMbaIBQD2qIxQhSHdYvG3DGbCcVCbnUmFGsaGwRHJuNTq3UUilFuc93oIJiqKh3EC6aJnNt98mac6iDOamZRKKYLxykzXCiGKBTT2udG31AoJoaeczuQQXyhBsXOCMVS0RiwuVCMLxH2QrHdF4rl2tf1sV1dlLbatVjYrBCMYOyy9sVCMmvR4U3bFo3RMaEuEY0BQGNMqOOetdyn9rufoniMe9a6uigUSz1rAedXS+P3Is9aeqW/w2pah7/ZyvNri2kdxkc5qMNYI0rPqWVjohoUYawaeaFrOSjCmDQYqjD+lENql1EoVkahmPSc/0GHUExJEcveZaZQbW/aL5knLb0uEoql4rD0GZuKw6jMA0nLvGe7xGG7JBQD+uQLXfhkhWK59k18bDc9V0401nX8MqEYgQbctD31yXXisFhu18dBP7avLhRLr+Xu8hQNE4rZjE9tEIpdnQUhGCVpeLg+Q+3rxjfnQUjWeCHZ5MN58G6c3l4E0df07gLGCyRMh1DMTP2gv6FQDN6zljL3TO8uoMoiXssLC8VyorFNhWIp760Xiu22UCzXvomP7Sr7pvTSLh9b+sHb1U7X192e7z/wa4MgLLZ3ica4eCwnGmv8AHlxfNTyrLVsUgs4oVjOs5Ymt9enx1nPWvKpvTk/WepZW/nx7+7yFLX3pr2/Og0BAPKrHd+cYTaJ4+Js0hbCTu8uoAZFKFsvcK193fjDOWov+nq4OUPp64sgDmsLxYQXig3KvDetYmXi55LLAfem/XB+EietS4RiOXEYF4LlxGHXZ8dznNpl3rNd4rBeKLb7+GSFYjnwZYhdEpA9Vrz1eHAfxVgbBQ1rXFhQK+QVY3HyFpfRZPBkBEzmMPJsFDKheMg4ERQKc+0ikwW3R4+PFTkqwjaEZNTdKoKxXUmduwzptaSiMd5uJYJnLV13Kg6LQlY6PnqwtgRTuu1ZC7TbW561NFYyekSaMnf+Fs375+boE9Sve82nNF8m8Got7WeCim2xHE1q571phWAeuB2Ug1zQctOUuK8CvVCsEz39oKN9FR/b56IfENLUuc9FPwDaVATaL/opmpXpB5TAQDc6Sz+g7GJa67D0XjP6QfCpZfSDojKt1JC0vKb98pspaozeOsqAsu2UuQAg6qqnH/T0g4+efpBrTykJj+tr9eNTKgKBe9euSz9wdZEy8Bj6gbHt1LlUpkisMZGSoI1teda6ukg/4J61lL2sTT/o9qwFgFnVhL+tNGUu4NLlhjEjSZkLAKqsAv2gGJZhfBqST+2I+dSWcSwajNz4Vw7imFEUrOx9bBelxuVUBGDem/arlH6QUA5SH9qUcsA9aUMdoxys40Obti8q99hd9PSDjvZVfWyfg35AyKXOfR76AS/HSSvglpZyKXM76QfUv6chpPQD8rSldLkP12do/OA+vjkLk15OPyB6Ak8NOb27gPacM0vpJB8u0bA0ucZ72tY9/aCnH+Djpx/kyjlKwqZ9rZNGN0dF4O05KsJS+gHVMe/aTekHdAz3ruVlGj8vGeWAe9a2Uucyz9qG6At+TLs5O17qWUuTW0c/iJ61RLsi+sHDzVk2ZW49jfSDYuZ9am8vYGbep9anBh/fnEOVcSyqh66evGvvr05RFJF+oMjHdklq3NuLk9akld4fjXs8JW6OcsA9aXOUA+5Jy+tynrSh/bXTD4QA1JJQ+SeKpZNaIcRvAvhNAHj31TdPfkG7gqf2seVLK+mks/Oa2NJM7rK6lu9ocODnWeZZyxXBy27BMtoGP5cfv+eOyS1v8euPy1S+jtETWvsyH9oXzDG8Mbre10ucaxMfydcGPr599e13L3w1z49HL/kzrOtduy4VoWtMoq9nl210m3bBxsDQF3dCoPY2VSNQDehYaeP4adtOCABgBTuGjXWKVqo4Dao1vrU9a925uEuMgioUpFIQ0sR2Na/kJ3pVi3LFqVr0d89Th7O+8h8c98yN++RT40YqRbjnWxxTcp60yygH6zgdpFSHxzgt9Hg+LP1qWWt/y1r7R621f3Tv7WfPcU09evTo8Szg49u7zz9/6cvp0aNHj5XQsm974u01oReKLcFziMdykdSXwrYi1Fx8kGYXA9CZWSwIKaz3YJQSujMG449RcUPT0SltUrplmxVCBbvoO8sjKV0CjixWSSfU45NGKiR7TAR33agtsF7GsVzUtpVxrEM0FsVQNnjX8v6Mpfdu5/oHWMwxWT3iojG6VvrbzGUU48+VwgoUSqKQArYQKPwWr0VASenOxyYatHzfsLrUMxZIVq+WoD2Zwdy1bjrRyUVGUy9hd1vb4jB+3oXXnc1Ytl5Ulh/32iZyPSJ6odga7amP7bbPlYrHFgnJUtHYXHsiGqO6vDisLRqj/kO7XSwUSz1rAfeAikIxE8pEdTBMKNY0JorGSGihbRSKzZogXiDLr6qKgoii1tj/wpXraRNEW03hLb1UHcRdSjChmJ4B6BaKSe/jWOwPnk0opkoZ3reUck4oVpRtcVgqBOsSigk2iefiMC4KI3BxWE781QvFPh6h2KJ27m/7mL6e2se2LRSLdTnRGO8rLyTz7Uw81pi2aIz6JKFYo21LNAY4wVjwrk1EY4DzpqXxX2uTFY3NvCh2VumWdy33rAWAYlKHcaIYNmF8EZMKACCLKJ4tyjg+DbxQbDAqghB3OCpCX6XnzJYDxcRhRTh/UUTNQFYcpmR4bpCVF/emLaRsedIC8+KwVCgGtMVh2/Kh5f2/BqGYEL1PbRd6odga7Tkf222eKyce67yWjGgstJ+fZEVj1P+8OAxz9fReP5yfZD1ruVAs51lLuLs4DeKJu8vTcC7LhGI00HPRGPnRPlyfofaisIebM+ia1MNMKOYFFU4o5srTuws0XjRhvR9tSyg2voKZukltl1BMwA3qWpT+mKcXiikvrni4PgN5O3KhmCrmxWFcCNYpFEsitVwclhN3cXFYV/uy8mvDpygUW9bO/W037eupfWzTRSUuHktFY2lfXDx2zoRiXDxGjgVcKEanvGA+tVw0RmPe1elRVjRG4rCbs+PgaTsvGouTWsCNrznP2pkf3x6uz1BNSFR7junMTWqrSRTP0vgzuT2HnrlyMy3CMc0wilMLmtQyb1oa3+4uT8OklqLfc+IwP4B8OD9pTWqpjsZF7kmbE4dxT1oCF4dtw4c27f+KtXeVe+wmevrBGnhqKsI64jG5gWiMCxI2F40Jdkxc2oniAAd+f7L3rSU4sKGdLsvo5Hi/5K6lfy/Mj1FKw5apJNv8pHbhnVwOa2x2e87fycvYA9tK8fgpiMN6rIfc8v864PSYRZSETX1s6aufiseWURH48XwJ3PUlkjS68/6+QrguW+On779QEmUhvTOAgZISSjrRGAAUECiVQKEEjBHIi8YyVAVGT9A1/ShWYZOFDilz5cxHP/mYyKhatHrDfcBD6l0ZhWBtARp7v5nrS71pwybpuxDfX+uzz/SVAxeHZT13lxz/MYm/Xut1PzV6+sGG7eum1F23fZtpdPkDgHvXdlERqM9sO0UybD5NbsioYzjloO1ZC7iJYqQctD1rAZcul5bB0pS5gPOrpSX9um4C/UBNNaMfuEiGFo+jH6i9MhzD6QeSfGyfgX5A0dzUm5ZTDQiPoR+klIOeftDTDwiLPG3XPVfqaZu2b9vHllMR6PiulLp0DNU1dp5+kHrXcioCnYd718ayG7946txZHakIdaPDGE1R2SmjH9SNDn9n5ZgitRrvviGf2ipQCUThIrViEilZxUCGsXLoLbsGI8XoB2WkH/jsYjw1bjFQ4fxk77XImzZQDVhUl3vT0jOK0uh2+dCG4ElCOUgpASnlYN32tG5X6Qc9utHTDzZs3ySl7jrt20yjm0ZYuHdtFxWB0w9a7aGrecoBpyJQ3d3Fadazlvxq7y5Ps561xJ19uD7Lpsyl9vGHczSNpyLcnqOmlLl3F2g858yMH0c/UDbvUyt8+TnoB1LFyIK7V236QRqZ2JR+kKMc9PSDT5t+QFjmabvOuXKetoSn8rHlVAROPyB0+djqnE9tps751MZJbayLVISGJWcA3NI5TV45/eDm/CSMdbM60g84lYt8aMmv9uH6DLOpm8iOb84wffCTXkbJIh/aye059MCNdc1UhmMaP9F19AOa1M57095dngZ/2mXetB/OT8KkNtALmDftzflJy76M7gWB0w9ylANOJchRDniZ+llGKejpB68XPf1gQ+SWObZJSViXigB0+8nmlg+7qAjhmC1QLWjQaStyKZK75NiWtyJT92YUuek50yWpVNEblL2ZNXZrPb3APg29oH0vnqD/NRS/H8N5ezwfntMdgVMRCLblMbuejy2nIri6xVQG3p9l5ZbnKvOupbHU/2ZFo23Lu5b+5ikiGby5IaAKiaKQUIWEtbblhAAAxjoqQ1lIGGPj+KHcyYQ0kGTwwukL/mLEzIRzpRQB91l0UQKoEKliOXR50+bGhNTxgGgKOXCqwDJN1LJxZ5Ol+q7v+05ArOZm8SmiZ8716NGjR48ePXr0ePXoI7VbxFMJyVb1seW/fDc9PUUPuWCs9Ys7pNHlv8iRjdLl7kXwwZUxgirt/H0jS1khATBP2yAoCO9VxKhLogQJnrjSKwtkO+qbM3jlQrAl9rivEts01O6jsz0AtKJXm0RvHysky53f+dDmo7ZAWzyWi9pKJh5bJeOYkgJKiDBUxeOdd62i8c3334rONjqIn6ySUH4L/rvCuuN9xFd5ERc5oSjlor3htXT9Fsq/lxJQpYBnVi35LNo+sQCSlbL5COwicRht8+N297l4dHZRxrB1RWGLkP8O7Th6NW8WvVDsia71KYRkj/WxTb1ru0Rj7nh0CMmikIJ716Y+tdy7NhWNAU4wRiKl1LMWcH61JIiqax1FY4xTS4IrNa2x74VYcqqDUKvxlje6aLDnxV1a1NFzVnshxXQShGJyoDAcOaFYsTdw++1vTyg2GBRzQjEpxNaEYlwcBmBOKJaKwx4jFJNS9EKxR+y76+2PE4LZnRGSpQKyWDfvY8sn40EoZpiPLVkaWrTEY98nPrWpdy0Xjbm66F1b1zqIn2odnxu159JOq+hdO2151jp9QDmuo5Ar8awFAFvOgjhMSjEvFBuqMP4MRmUQnQ29j23qTRuEap7esEgc9iUThQFOFEvPpdSTll5zPrQELg5b5kO7lk8tm8R+89PPS8s9dhe9UOyJrvUphGSP9bHNedd2icZy3rVOSBYH9dg+LxrLeddy0RgJxu4uT7OetSQYu78+Q1NHoVhIzuD9asc356j85HXy4TyIJqa3F2i8AMx4v9rZ/SW0F1fMxpdofLmupgCcUExaN1BXs2toH9pQYntCsaaMnpDS//VRFGMbQrGWOAyxnfhwOXHYpkIxuaSv14ZeKLa9vnKisnWO36aQLCcg6/KxTSPM58eH8EMOzo+PwnmpTy4Uu2Cispx3LReNce/axgthr8+Og9Ds5uw4TIDJp/bD+UlLNFb5MgnG7q9Os561k4kTxE5uz8PfLBeK1d7l4OHmDDUTitX0ozzjTcuFYsvEYR/OT2LyGBmFYDlPWhqfUh9aAheH5URhBO49u4oQLI3MvgahWG/plUdPP3giPIWQ7LE+tl0+jznR2DLv2rWvPZFd8f61aXvWAi56Qt603DsxlzI3FYJJ/xqED7QEldIP/ARODQu3iQJ61sAIDVNrqJH787CGaAnhP27bEsWE+/C23hf7vDfCEoFH+xpW67KnHPRYBanIJq1fRk/gQjICP2QdIRmnIrCdsz62MiMEK6RFIQUKGX26231m3qtyWbRohSUKqQIBgnnXesqBdJ625F/rf+u3vGlT0RgA6LJAOShQlAW0tihLhaJUIQBQ1gplqdAUKrgutD4TNv5w2lf8ocw2LnoLNzQvDst57i5Lg5ujHNDnHa41M/6smuZ2p8VfPbaCnn7wjNe6zTS7j/WxXURFIOTS6G5CPzAJFYHqaBlLN23PWsD5OAb6AfOsrWcuEsHpBzxlrmL0g9pbeukyTz+Q3qdWmzp402rbBCpCORq5Phn9oNhTGL319IORj+SOikfRD4oi+tQKKRjlQIWlwOD6sAb9QEg5l0a3i37AJ7WLKAWLKAc9/WC36AOPbX/Kc21CT0gpCaum2V3maZvzsQXQkUbXrzS1vGsx52ObetcuSqNbNzosg3P/2qmP0Kapc2ksnXr6wWAa6VvluArjQzF0458oqzD+aG3m6Aej/SLSD4ZFOH7of9Sn3rRUHnj6QZoON9APVNuTlvZdlAY3pRykaXC7fGb5JHehT60QSykFr4J+IPo0uV3o6QfPeK3bTLP7WB/bZVQEQppG9zH0g9uLeN5ASbg8hWZUBPKsDfSDq7OWZy2lzOX0A54yt5rxlLl+X/JpvL+EYfSD2udGN36/anYN7fuvqmvY6RAAIEOa3Cto42Z/s4dLiMZPan263E3pB2Tz83B9FiIMD9dnUEqxerfvWvQDfxCnBHTRD9JIbTc9YTHloKcf7BZ94LHtT3WuTegJOUrCKml2l3na5qgIBE5J4D62be9asLJtt6+QRpcoV9enxy3/WqId5FLn3l6chHbyob27PMXM/5C/vz4LtITpONKzqH9OP6B0uQ/XZ6iGRTi+HlIa8Hlv2ruL00A7yKXD/XB+EqLU3JOWortdaXBzlAPuSdvlQ7tqmlu6jt6n9uNFTz94RnSpRjehJTzWx3YRFQHodlqQrDNafkudEAg8dW50T/CHJy4F3AkBYD6OHSpZLa1byZPtlLlCaZYKMtIP/NqZoyUov7zmB2Ur/PnTZaht8C569Ogxhxw9YV1KApXpsEXuCPPLzIw+wKgIxD4wyLsjxFmvQCGc40FKRSCQI0JKRfBXFdLoWusEVPTjlqgIRUn3BSikr1MIx5kiTpBV4dwQUicEACjLAoNBgaYsYGd1yzEGyLgbEBVKxOQKfCP3hfAcE3nHg9STdu7zZNSDXNAxdTpYdHwOXRSYTRCfQ4/uaisQeL3pfZ8avSdEjx49evTo0aNHj1ePPlK7AwjerZtm7loSXQ3nyYjHXP181LZF8pd2TjSWetfyqK1rj/vozPtqR61j/7S8z01iuXiBfp3G/ucjCVF8QIp/7Y8FrAgdBSIpRXWF6rhxxrgUaMbgU/0d+KkIw+htcmHRnMhoQfs6++56+7p9PVY3uUzE0xXJ5dGzEMm1bSFZGsF9vJDMsghkjNq2YrHs+nnUlkArWUYKH50VAGSI2hb+htpCoiyVE4dZG6K+UruxqFASZaFQKDknGgOAptaQhYAsAKkVVKEgC8XoT4pt/lpUjASm4jCePQxoC9na4rD4vOGc2IXeskt8aLuis5v4zHZFX3ndLkVnWxAA1Kf5LFqGXii2Q9f6WCHZY3xsuYAs1GV8bPmKPBePhbKN10KChroxGSFZ27uWi8YAoK4aJh5re9a6do23X7nvYlMxz9pZHYQQylt5NUWNvc+ceEuLOvjMKuGFZHoWhGKirphQzPvU7jGh2JvykxSK8QdLLxTrhWK59mVCrsf3b1c+vutaOC3hMUKyVDwWy669LSRb7GNbMdGY1iYIksiyq2pMGOtnVRPG5Wnl7QtnTRSPTZuWaAwA5KAKY2Ux1XEs8j60o71By5s2eN4O3PRgMGiLw4InrZ9UDcq2H+1XQSjW9qQFMCcO4560tN8in9lOoRibea4qBBNChPvOweu6yj12F71QbIeu9bFCssf62HIBGa/jPrYpzZSLxz6cn7BoTRSHkd8iF43Ree4uT7OiscaLv+6vTrOetfQ6vjlDQ6KxD+eovDft5PYctfesbbx4Ynp/ATN2/c4eLtFMXNlMnQtCNb1C7Y93QjE3aQ1CsckVtGA+tZ+QUCyNrPRCsV4olpbpb/+priUnLlvH55b72/K6TYRkOfHYORONtYVksZzzsaXx8YoJya5Oj+MPeC8Uuzk7Dj61N+cnmFXkY+vGsduLk6xobOont+Obs+DjPf5wjmbq/uj11P14596091enYSwblPPisNuLkyAQG5RubOB+tDfnJ1lP2pw4jHvSLvOhzXnPruMzy+vokKvTo0z70dJyj91ETz/YITxWSJb6mi4Ski2iIgDtiG1KRQDW01C1l6w8DJ1fzInGgPa9SD1r3TWZzDKXaKXMDUuPUjh6gUx8asObZuqGJwAXsi0D9+Tt0eM1gZbwn4q+sA49oUtUBhv3J0qCu471hGTwS/FSCkgv5CqkQBPeRKQkSAHvcysiq6olHpMYeO9ZNCZQEQwJWWGDd60xjmpQKglb0ljMvGutRTmQKAcSTe1XgkqFcuC8a03jVoa4MC31pqWNkiek4rDQruJzhsbiQgoUyt2LnMC3UCK8FyB60uZ8aB8rBFuFXvCa0QvF8ujpB6/gWvmkdpPj+aS2y8d2nZS67pjV6Qdtn9p5+kHTcCqCO77h9IPEsxZwfrW0ZL8oZS7g0uXm6AfSugiGttGnVsymW6cflGURlvyKQi6kH6hCBfqBEKKnHzwjevrBy17LY+kLi+gJnJaQ1uVS7m6aZrchH25WZxDpB00Y//I+tlXiXwu00+jOakZFqKNPLfeupb9DNXTjW5o6l8Yfoh+k3rQ0Zgy8T23JKAc8JS5Fbbkf7bI0uKUSK/vQ5ugHQJtysE16wbL2nn7wOtDTD17BtaaR2nWPTyO1XT6266TUzXnXdtEPuE8tTWp56lzybHRUBHe0ztEPmGct+dU+3JwtTZlL6XKnd236QT2mNLqecjC9Ql15KsIW6Qd14SkHH86Dz2MX/UAVjHIgIhWhpx88PXr6wcue67H0hWX0BE5LIHSl3N00zS5NWjklgfq/OD6Kk9oOH1tORSDaAU+jSz61N2fHqHz9dBZT5xI94e7yFJMHN6nNpc4d35wHqkHOm/b+6hSlr6cx6/bipEU/KIIF2WLKAfekpQjtKj60y9Lc5jxnefsm9IJl7TtDPxB98oUu9PSDVwA+odjE23ap92yGirDMx5Y7IvD0iAiDetu7NlWxGmOzS070vtI67lkb2j0loe1Z206ZS9ccaBnSr3ex9tcEvqS2TEncOi6zzxOzLnr0WAub0hdyYxb/Py+bln+t/3sC0QREmPRySgKnD4SxkFESuDsCTeqMbafWDZ62zNwl72PLqAgMZalQ+B+8w1JiUMownjfKBu/aunHpd6UQKPwP7Ka2wd1AFtEJQYWMYNHbVijnjCCUajs3+I0cEJwjwvx970qDG6gKzN0AwJwP7abuBvy/Hwu9oMdm6OkHr/RaU6eEVY5f5I6wTkpdqntMGl3uiNCmIvjjm5j6sWlMKBP9oKkj/aBiTgjVtJ0yF3Dpcoke0Kg6pMxVnn7Q6OrV0A9UIVuUg5Re0EU/4A8JTjnIUQZ6+sHrWbJ/yvZdupZF7TlKQfe+dkm7+/+ilLu03ybuCA1NRE3bEaGLigC00+hyKgKl0R1MmzD+ltO2EwLgaAg0jqhJdEIY+vFrMFSMclCG8WEw8EKwhH4Q0uDS+CUj5aArDW7J+LeL0txu6m7AE+dsSi9Y1r5b9IM++UIXevrBK73WnFPCsuOXuSOsk1I354iwThrdliMCc0KgSa316XLvr05DGsn7q9PgdEDuCA/XZ6j9ktz45hy1T3nLU+ZSutzp3QW0dzyY3V+i8apg/YroB7TUxykH91fzaWxT+kE6AHLKQY4y0NMPXseS/VO379K1dLWnY9ai95K6u3TRE5al3N3UHUGzSS3QdkTooiLUIaXucYuKQGlyJ36c+3B+gsls3gmB0uQ+XJ9hNo1OCM3QjV/VIDoelL7u7vI0uB7kKAcfzk/CpJbcXW7OTzrT4PJILTCf5pZHaum9ElZxN0gjs5vSC5a17wz9oEcnevrBK0Vu6XkZJWGV1LrU3SopdeO18GXs2EFcHoxUBBr128kbonuBn/+hNt4tQEhPdaBlKXe8KlTYtDagRAyqcMt0qlAQ/gHgEiuIOQ7Stn7pWmvD9lJ4iuQI69AbevR4KfCvZxd9IZbzy9gpPSGlJJBTggr72xYloZBAIVjKmA53BNpBSIGBlCilhLQWpXJlwLSoCARyPAAiFcHPf1Eai0EpUZYSxioMB26jsbqpBcqBRFEKNLVEUTjnA6niSlHcYiKFGD31+8t2O01mlYzJI1LKATkd5Khm/P+tRA8LHC5SR4N1qQY8kUQ4f9JBV3tu3xdDz6ntRM+m69GjR48ePXr06PHq0UdqPyKs43O7zNM2Jx5z9V4I4ctp1DeKjtrisRApYWGVkCaSi8ZInFCIsMHGvmj53Zr2e8h51hb+YrS0EOQTS1EBHt4Rvm6FX+HWAFb78y/de3voo6U9XgqiFSmbHzPSfXetvTU+LYnqRp9uFiX0AjDFhGI8kuvKEkpISEH0hHb0VrmhJyzDGxOFZDBcSCZD1FaEuG9bPBZ8aimNbqkwHBQYlgrWWgwHTkhWN95yi6XOLUrrX4swlqbiMBKaccsu2pSUKKSEkjJQDRZFZ5cJwYIfbWbsTaOyi9ASku1qdHWLEMBKvuefInqh2Cdwrav43C7ytF3mY8tFY6G9w8eWW3rl0ugSl4171zZVWzQGOMEYiR/Kad3pWQsAYtJEIRdmQSjWeKGY0hWG+14oNp0sFIqpvRKjt778xnNuhyr44BbD8kmEYkUZH9Q5oRif9G5LKCalWFlIlpZfI3qhWL7MJ44/sfafMn3tYrtN/GsJm3jm5oRmfF8av7p8bkPGMcPEY6YtJIuetiQUy/vYUiaxaaXD+D2Z1WGsVd6+sBjXYRzgorGShGBMHDYcRFHYcOD4/VwcNijaojBgXhDGvWcfIwRbx2eWj3+fhlCsRxd6odgncK2r+tx2edou87HlorHQ3uljGye1wHwaXQL3rtX1vGiMBGMP12fBm7bLszYIJu4uUN+7iez0/hLaC8Waid9vcoW6mgLoFoop64Vi40tI69srGfovZq5u20IxVdCkFuFecFFYGsndhlCM+lxFSJYrvzb0QrF8OY2G7uq1drXT+LQNz9yc0Iyn5OWTWqrLicpo/HPetvDlo1Z6XZrUNh0+tpUfF0Pq3LNjTP1E98P5CR68KHbiX+8uT1uiMfqhzMVhszKKwmhSy8VhFL3lorCcIIx7z24qBKOqVYRcc8efHGXLj23P7fsiEP3qXRc+efpB13IIR1f7Ovs+pt0uEYAtwzo+tzlP2xwVoSUeQ56KkAe9t/ay1SKfWi3aojEAEN4nV0hnc6VKCVVIaK3BPWvdGeMymCgERCHd62MHhRU/F2sMjDGwxrh1yB49XhirUApyy/vPBSmCnXQLvG7VdkN//2tQGZSI9Chr7Rr0BN93QklIfW6N9Mv0flwdKImBEmgMMJACpRSQ/kepFNZ50xZksTXvYzsaKAxLBWMshmWBQaHQ+DS6jTat1LkkGiMf20EpMfCUBUq3S763gHNcIfFaKgoDsJBysEgIJgRaNIb25zIv6grfjU+AXtBjc3zy9AO+dLKr1/rYNLm59tTndlVP22U+tpuk0eX0A+qfe9fWVfSp1ZQ6stIxdW6tYxrIadPyrAUAUTaBEqCKKlAFGu3su2Q924h+IPcKX1cspB8oJQP9YDAoevrBjuJToh+sQil4SfqAEtvrX9vH9ZWjLyyjJ6SUhEU+t9q00+wu8rSd1WbOx3ZWNWEZfzhtIhXAr0DJcdVKnUtjQjlw49dwpEI796SNkdqYBrcs1MLUtynlYI5+IMTK9AIpt5vm9rHtPf3gdeCTpx/Qwz5N25eiq32dfTdtTyO1T+Vzu4qn7TIf203S6LY8a4PPrXu9uzwNCRfuLk9hNOVD996112do/PKboyKwNJDes3HmU0NOby9QT4l+cBHoB/XEp5Ncl36gXVk20ac2Rz8g65vJh3M0PjrS0w92D58S/WBVSsFLXSt9XU8y7bxulfYclWCda8nRF5bRE3KUhE6fW1/maXa7PG1pIsupCERDuD49Dj61N2fHGFN6XK8t4Klz769OQ6S28qlx7y5OW560gzJmHAPc+E62Yl2pb3OUA57ylqe2XUYvCPtukT7w2PadoR8w8V2PNj56+sEq9IJdB7/eVekLyygLy5wSutwRJE8z6ZfOgDYVwbWtnkaXL3nRQM29a1MnhHBuRf1KtmmQZy2pQ4WvE5RGV7XT6BJdITW4s9q/ruFDa+H3hQ0T+55x0OOl0PV3/JzgQ9Q69IFtnv9RVAYh5ugFnJ4AxLJnR8HYSEkABErvGsAnvaX3qdXWoFRAId2kb1g4KoKxRJ+ywdMWBQIVgYvfh4MCA08/ICoCiXIbbTAaFKhKhZo5IZBQTErveCAFChWpBzSZLXx9IV063aJwVC+ySVXex1ZJCSFFaJdC+H5kNo3tKvSCHj3WxUc/qe3Ro0ePHj169PhYIESffKELr35S+zFEYp8C6X0hLIvkLhOVLROSkRCMi8fSqK3bIZ9xjCIfLe9aLiRTfknMWBcdUALGOBGDVE7EQBlz/Eo+mlJA+a2ZxciV8H3xjGNc6EDv0WobNxM3CttYE9t69HgppFHZ58I6kdiV+6TVn8QNmtet076tvvj7KaXzl+VlQ+8dwMALqIxdHMkVVoZIbhrBBQBQ9LYQkFpipCSGSsZo5gAYDSSGAwmgwN6oxGRYBNqDNgZ7I4VqqFA3BkNfDu+jUBiUCmWhWhnDCqIXlMplMSsVCh+1LkRc5XNjrYwWX0wIxqOy4b52RGcJXITGy0/ZviwbZ4/Xg1cvFHuM0Ou5r3WX2pcJxRbtCywXknX52NKSfCoe+9KLE7Qmb8YoHuOisabxS2pVEwQPXDRWzZoguqqmPk3upML+F06cJUQVPGsbOH6ZqCcY7TvxlxhOMBw5oZj0A7/aK0N7sT+IPrUjz6nlQrG9MvRfDGJay14otvt47UIxIcRWxVur7ssDRtsSiskXei+PbeeWXzmhms0IyQwTovF6mtQ2BvjBi8dqHYVklR9rZ40O4rFpFX1sx14roMZV9BHfi6IxChqMhkUYfwelYJ603qe2jOKwIiP+KpQM4i8g7zO7zEdWLWnneIp2zSa1r0Uo1nNq83j1QrHHCr0e2/6c59pmO0UVNxWVLROSdfnY8kltqPPHuPY4qQW8eIyJxmhSq2sngri/Om2Jxkgc9nB9hnrm6qczN7hPbs8xu3eiiendBfSDK1cTJw6bTa5Qz7xQbHYNCTeoS6/omk2uoEk0Nr6E8kIxob1Q7P4CRVOG/pWfiDb+4dALxXYbr10oRt+XbfvULts3fbauK+TKtVOE9OQw087q1mnfZl9d7YZpDoB5oZpNhGJcXJZ63oZJLdUdHwbP2vPjI9S+k8qLZy9PjjCroo/txPt033sXhA/nJ7jzY97dRfw7nXkXhA/nJxj4MesDE4UVXjB2fXYcItNcCEbjV+o9y4Vgy3xk0/HrkrVfZsRZ225PI7W7LxTr0YVXRT/oWlLvsT66aBu5JfRUVAa4iOtiIVnex5Z8Zpel0W2dk4nG6HjL2rloTBUqbDTZ5UIGWaqw6cI9DGSpIAcFZKNQvClQjEqYokDtHwByoGAbCyT0A7pX/NtovR+tNQaAQgpjLYyxMNbOLXe6+2rCppRi9e5cqudR9UC3z+xTIhVcPTW9IMUqordVPXclACV8atqkTNikXbBrV1J6r1rnQ1tKGSe1sIGeAAiMColhIaFNrFc2Uq2GSmIoJQphsFdKjAqBwsRzvykLjIsCQmjsDxXGjF6gLfBmb4Bq5H5wf/52AExKTL1TDE+DWyqJgU/DS5NZTjngQjEZ7m2bZsB9bLnfbbwv3fQA15fbVtDlbg2r0B92iqog+khtF14V/SClGjz2XE95ra+tfV1P3C76QrT0shv52NIyUDf9wEcvWOrcumaetZUJy/dy6CK01bQJy/8o6lbKXACo9Sz40Db1FMM971lbu+PL0SjUFfuD6Fnr6QfqTRnoB2qoQv+lb+f0g6JQgX5A9AROPxBShOtXSgX6AUVVVSF7+sET4TXRD54jdW26b+od+9z0AiEEfsnqfpk5vqs93VcC+OWvWfuvM31t0G54e+b8MVJrs++1MW0qQlqnrQn+tt7JCxWjJEwYFWHsJ63luArj82ASqQgDT88aDlSoGw1UGLdLmtQyykFRyLnUtinNgFMK1qUHCAF899Ov/L16Xh/aZe05qkKP3cOroh/kqAaEnn7w+PZ1PHG7fG7T5bX1fWzjpBZoe9feXZyG9Lk8dW6gH1ydofHlh+szTP2yG1ESJh/OMfUpI3nK3GbsJrez8SX01JWr6RXqyh1vp8NQp9U8/UB679rp/QVUFT1rG1/m9AOiF4w/nAeeLKcf0Hf84fosRGpdPfy+85SDnn6wHbwm+sFzpa7lZfoKvRS9gN7zNugHckn7suO72s2Sdh6pBebvFU2YThltgeo4JeHsKKbXrRglYeqpCBcnRyESe+99aq/PjjGZRioCtZMf7YfzE0zL6EPLI7WAoxyoIlINeKTW1bW9ZWn8WIceQH1dnhyFSO1z0A9Wbc9RFV4CAn2ktgs7Tz/4VCkHSsQtV5+WV2nXK/wtLvPEpUlvLrUtEB88EnZDH1vXnnrXBh9F/zgyBpCFglCq5YSgm7hESRNAUygUnpIgpYZSri/heaqykGHTSkEUClAKgHsAwJiw2cbA1hq2McDAXaw1ceMIPreyTVcg0MReCAujHS0hTRm5Knh64W3BGBu2fgB9eTynu0FKNXhUX2xJfhG9gGOd9yqTcmo/nZZd/wgKfbqu9FSbtHPCUSFEGH9D2R9grfOuLf0PTyorBQwLhYFScQKsLPZLiVEpoY3AXqEwKhRqP6BLRkmQQuFNqTAuVOsuv9sfoPb0A05FABxNglLvpk4HgIvYDny9EDG1LU9VSzQDIRBS6tJ9Tu8br8u1p/utcvxLURV67B56W/gePXr06NGjR48erx47Fan9lKKyq0Rin/qcm0R1c5FciRi5JXAhWRq1BZb72BpNUV8RPB4ViwpzP0VrfBRWKajCoih9BjLtfrNpbSEL72PLPGulX/Y3SkIUEkLJbHYx01iY2sA0FoJlFws2ksb6SK5tedo+xV+XtZThbL1IahC1JZ8RbbL/ebtT2AUh2NrHJ+KvdaKyvJy+11Uise7Y7uhqGmklYaoU7f/zvpSM2QB5mbCoXQAopIVfrW+VAZckvFQieGnz8lAJDJSL5gLOx3uoFAZSwgq4SK1SKL1otjYCb0qF/dLVvR0UGJcqpK8tpMTn+yXqPRedpagtHxOGwwKDgcJAuajtgPnOKpkXf/F7y7Or0apcWo73frV2s0b4lbp4qoitMRbaj7W7AZdJs8c8dkootmtCsGXtj+lLCeDrH+dJ6rzuOdvTfbXd3PM2reOetqv62DbatrxrSTRGXFsuHqsrEwRR1awOorGZz31eTBu8/coLscq2Zy0A1GaG0bvvXF3FPGvHEwCAGhZRKLY3aHnWAl4o5o9Xo4IJxdxDpBxI7HuhWJnzqVXMp7aUC4ViUonw/lLPWnrNCcUIQoogFAPaorFYNy/+4pPmXij29EKx5xCCpXWPFYKl4q9Vj+fvNSeu4o/uReItKURn+/y+i9uFAH7+9fvwf17O1aXtAhY/sz5/Tvq3EJ3HU5kmaMYyIZq1oaz9DpU24XtT6Sgqm3n9wUOt8b0Xj5XjOgq57p1+gD93B0wIRq4FSsms+ItPakmcBqCzvG67sTaIxlrtrC5tT8Vl2/Sx3TWf2l2DEOJPAvhrcCycv2Gt/atJ+68A/LsAvvD7/OvW2t/Z9nXslFBsF4Vgy9o37Yuiorv6XihSu6nnLReScU/bVX1syY+Re9feXpyESS33rq29N6Mrk3/tGSovEKu8IGJ8c47pZN6ztnlwdbOHy7ZnbeXKShS+n2voSRnaNVxZWu9Ne38JVXOhmDuu8eKLyYdz1N4TcvzhHNJ/CYh/9nBzFoQYXUKxKA47y3rWcvEYF4oR6G8sFXelP/rn28XC9lz5tWGXhGLPJQTjdY8VguXEX6uIq9L3mran8ahuIZl7PT48CHVdZblk32V9LetfhLpD1h7LNnNMWuaT2rTu5PAwTGprPz6eHh0Gnu3Z0SFmvn7ixbMXx0e48+LZq5Mj3I198hn23B34iez16XErUkvHcPEXn9RSHWEbQi0a49c5Picu26aP7a741AqB8PzYBQghFIC/DuBPADgA8LtCiN+21v5Dttv/AMDfttb+z4UQfxjA7wB4v+1reXH6wcdKOXgJesE2sYiqALTpCbnPkFMSUioC4AbCQkkUUqAx8z62BaJ3YgPpxV0SPncB6sYE71oh46Z8qlz36n0elfFpHAWKokBZFqiLAk3pzqUHGnKoIGrVEo2R56SeNdC2ga4ayGEBW1jY2sIO41OH0ubaDD3BwPnSGtg2ZWDJF4H3JVZYxn1KPIUQrUcbL5HmdhuCsFUoBsBqPrOxz3l6QbuvvHgrHL8CvSAnOOLdCdjwfyoLEdWgUmhI/38qS+jQrkQNJeq5MqEQFQpfly2zixmqCkNVw0BhWBgMCgNr3d0ZWIV3gwL3pYJWwOfDApNBgYGf1BaiwedDhdlAQooSX74poffLMGlsGhMoB0UhfbpcJxxz700EIZmUQFkIlEVCGQj0se7yon2NwRyIhrAuFeExSGkGu0U52Gn8MQD/yFr7jwFACPG3APwpAHxSawF85sufA3iSXwgvTj94yTS3j21/TfSCZe3r9rWMnsDpBykVgUCUhEabhT62KRUBAKpGh+XuqjJhGZ2nz515H8ZyWsfl/QnzrFUuUiExDfQBOR0HH1oMx+Gah0OXOnewt4fhfvSsBRL6AU+ZO/T0g6EMlIeyLKJnLfnUdtAPpORUBB+JfSH6ASH1ru3pB7ub5naV9kWUg1X74pzIbfnMpj6yof3X8ZyL2zejFwiWESxHH+CT2lw7n9Quoh8sal+0r4EKZZrUGhvvRWMiPWHqx8px3QRv27sqUhHEnadfNTpQDspChWX2QRkntUQJkHI9SsGq+/JJbbadPTeekn6Q0gz6NLkr4ycA/4z9/wDAH0/2+TcA/B+FEP8qgDcA/uNPcSEvTj946TS3j21/TfSCZe3r7LuMnsApCTkqAuHm7BgNtXf42OaoCERDuLs4RVVH+gFPn1v5NLmVTxf5cHMWJrrjD+eYUppczy2b3l+injge7WxyhWrmytY/6KrqGpa1k2et8vSD2f0lZBPpB8XM1TdD92WY3J6jLiL9oCiJs5anH5AQ4OH6LER1X4p+QMh51/b0g91Nc7usfRnlYBX6QRqp3YbPbM5Hlrfn6AGE48ODjekF6TQhpQ/wSW2unU9qc+3z15pv79rXeNOw48NDNqmN1+/nsTg55PQDNyaeHR3igVERrj3tihLaXJ8eowg+tEetSC3gluFpnFjX23XZvmmkdq49eW48Ff0gRzPo0+QCAL4RQvwe+/9vWWt/a80+/gyAf8da+z8VQvwHAfyvhBD/grWpGebj8CL0g0+NcvAUEPBLeckwzOvWaV91X5rgddETaLLLP+O2O4I7wBgblh8LiRYVAUDLEUEatnzIJm/Bu3aBEwIAKC2hSpfasVAWhVfvSm/VKAcScqggKwk1KqD2SihboHjnIrH13SzeFOupBtbC+KTsylj3xil9LqXTZSmDs/Dv1UpHT7A2ScH7WHGr9el6rQkT3C6YcN8Xd9l7124XL0E5ADajG2zD3SDfb7ucfgXbrgU5v9h2WTJqQZcfqhuJFtMLhDAQnlIwRx8QFko0kMJNGHmZ+pNCh/6ozPtXsoaUDQQ0CjmFkm6c4WUC1SkAA/mAUo5Dm4XCqHjAsJjAWok35RR75QwD/2N7pAb4Zm+IejTAQGl8szeAHpUhxe/drMG7/QGqvRJSAvsjhclQRZoIHOWA3BS4R218L7GOyjZ8XnHfNKhBoHEnR0MA4sT6qWgIr45iIPDc86cLa+0fXdB+CICHsn/p6zj+FQB/EgCstX9fCDEC8A2As21eaO8J0aNHjx49evTo0WNT/C6APyiE+H1CiAGA3wDw28k+/xTAvwwAQoh/HsAIwPm2L2RppFYI8ZsAfhMA3n31zaNO9rFFZglPHZnlEdRcRPU50XUtVFYi/uIN0ds1hGTk5cjFY0URfWkbHwzhGcdcJi7p/BKLuBntIwdKhU0W2nnWFo4/BgBNoaNArFSQAwVZK4jB/G8+WxtYpWFrAwx9RjGtwwajWIYx79RgRIhuWmNgjI+gpsaXC9ASnVH2scwXb1kklUeCH/v3yM/F//+awMe3r7/97oWv5mmxqShsVSEYx7II9CZCsHXFX6Ee7ais29e0Iqc8KhuvUbv/CwshrHtlnFsB4/oVBlI0kEKzNg0pakhRQ8BCyQrKWwjCX48SFRRqCBgXCQZFfV2Z8i8KYTCQE5RiCsC6SK2YtN7LSO1jKG8BAHvFCCN1E+kJssRngz3clzcYFvv4dl+j3tMoVcwq9vmoQDUsoK3FXukylnEMlBOSGet8bwu2pGOszXrPGmuD+C6sWfk2IURn1HYTrNrVxyIEExA7tVJmrW2EEH8BwN+Fs+v6m9bafyCE+MsAfs9a+9sA/tsA/hdCiL8I95X4c3abXwKPpZNaz5v4LQD48ff/IfsYoRj/EJ7C+/W527koLNQ9gZCLPxi+Ye3fZI7ftH1bffHvKF1/KioDlgvJUvFYEI01cTAi79pZpZmPLROQeZ/a2VQHv1c1qYJnrRy45UQrZ8FbttbMs7b2D47BOAjFilHZ8qwFgOJNidFbLzTbH2Lvs+98u3swlKOCCcVUEIoNvL2XLES4pqJgorFCBaFYSD8sEYRiqpBzQjEArTouGkvbU9EY9b9M/PUxCcX4+PYH//Afsc8tFEvFYc/pQ7vs+HWFYLwuFYURHiMEe4z4KxVfCWFWFnoJYfHzr724Coa1/4r11RYsCWj8KrRb/OrXPyftJtQJGPzqfWynMp1LCoNfvafx0+DX79tjqRDtOirTpFbbQeizMm/DtX6Y+fHnocIvfnZ1jbVBSMbxfRBsYa7dJMd8z8RdVOZTl5YPbdqXWSw0S71rqcz731QItuz4XROK7Rq85+zvJHV/iZX/IYD/8FNfx7MKxdLI0La9X1+inYvCnupcaWT2+vQ4W35s+zb6siySQdefE5UtE5LlxGMfzk/CpJa4VbcXJ5hVOpQbzTxrg0+tNyG/PsNs6qIl45szzCaufeoFE9O7i6xnbVVN/Os1jCfiVtNr6MKVtfexnT1cQhg30Z3eX6DworGmcq+T23M0PgIy+XCOpqRJLcI1kTfkw/UZVMF8aonf5uem99dnIVLLhWIEXsdFY4S7y9OsaIzmvsvEX71QbDtCsZw47Dl9aAmLhGKrCsF4XU4Uxts3EYI9Vvx13BKtmbm6TqGXX306OjxsRWpd3VHo6+gwioiE7+fo8Cgcc3TA26nuOExejw7i+Mjrqf/Dg2NQzPPw4GTuvfC6w4MTJiQrQ5+V3Q/v5c77aF+O3Y/78+Oj4H17cTwviLo4PgqiNN5uMse4fWN9Go67ODkK43pbqIW5ulZ75pjLk6O5SO2mQrBc3U4KxcTOuR/sDJ5cKPYxicKWebc+Fqn4a1tUA/7l5+lsu8rL9k3b+fJNjp6ghJ33ue0QktGglorHoo+ta+dpdDkVAUAQgmnvU1uUFuVAoigFtFYoBwpFqWA8laEqNIqygCoUmoGCGBZArSD88fxzaaY1pKnRVDXEyLVbA1jt9VhJylzAt9Em4/J/ED0EeoKL6hC9QHiqgjEmeO5ypClz08+6vTPl9F0uGOtT5z49nksYtg0f2lXxFJQDIH/tOarBIvFXKtIiagFNYjnVgI7lQi9ONXD/j/QC+r/b2sdLGAgYSDSQ0K2JaiGIkuCoCFLUrt6Lwvi+KgjFNAZyjIGcAEGkZrCn9jBSdxDCYL8YYq/4EIRr1gp8PtC4G5yhNkN8MahxX56iEM66UJt9fLVXoh4VuK80RkphqGS0V7RAIQSUcKM7lbkQdpmfLH0mm641P1Yg9hopBj02w5P71K6b+naX6AVpXeo9u20fWSHEk1AC+ETnKegHxtiF7dbahT63KRWBjsn52JK9V1caXe5fO/D2XTXzri0mdVjSL4Zu0Ddyhv0vHP1AYBboA3LmFcbDAYajr8N1cc9aACj3hxi9dQ+INGUu4NLlUv9pylwgoR8sSJkLtOkHqWetaxdZ+gGBe9fm6AdA27v2Y6cfcDynT+1zpcF9TOrbbfvQppSDVdPc8kntLwMlYPXUtCnVwF2L7tiXJqVtSgGnGrj2SC8A0KIa0PE5esEySgGnEvBJ7a/fu++lQhPKIkxqNd6//yHsS2WacFsrQ11tRnj/3v193zduHFIPb8L3cm+mAxUhTmotq0MsI056c5SDlJbgrmUz+sEyn9pl9APNJrU9/eDjxpPTDzZJfbtL9AJel/Oe3ea5KMq5bUpAGr3bNv2AJqJd7fSLvsvnNkdF4Kl1ORVBs0kt0J1G9+7iFDOfHrdh3rUzz7N9uD5DNXHtE+9T61LneirC/QXqsacfzB7863XWs9YoRzmYjS+zKXMpXe7k9jybMpc8aMc350tT5nL6Qc6zllMOWvQDAvOuzdEPCNy7tqcfbJ9+8FxpcJf50ObqnsqHNkc5WCXNbRqpPT48yO6boxlwb9nj1rXo7L48Ugu0KQWcasDpBa12JMcn9IJllAJOJZjf9wTKn/fw4LQVqQWAg4OzsO/BwVkrUkt1tRn68inGfqy8mDhKwunRIe49lev8+LAVqXV1R62yRbs9pRzkaAk0tVyXfrDMp3YZ/SCN1L52+oEAdipN7i7hSegHHxPl4DnwWIrBKvSCx4B/njazjEPn6aYnzFMpOCUhpSIAmHNEICoCR0yjK1rXQP61ilI5Wpf+sSgkmsQJAQDKUqIcSDSl29TA+drakeekvRugGA1hpoO2Zy35zHJv2SRlrmuHdz6YT5kLrDY4UV/rfFce64TAqQiEnpLwaSD1pF2EdXxo88dnjkmcDmi/LneD+T7nKQfuWjxnljkauP1ty92AH59SDdw53fGO4tCmGrh2ohw0jj4QfGx5/w2EcJQE6duV0CFNbhCliQaFmEKJGZQwKOTMuSnIyjdXKMweCnMP6ApqVkBVN0DlxypdQ7yZQXy4wgDA4MMtBndXGH724N/Ne3z/5gF6bwxj9/F2oPBQKlTaBwUsUCqJQjmaVCHdmNyYx5IKHgdHv+p2PkidDhaBT5oNo4Z1lXvsLl4k+UKPHj169OjRo0ePDdALxTrRT2qX4KmyhHVlBFsVXdHRhedMIuhdZX6OtK7lNbvi8e2MYg48eptGbYFuH1vqwrYyjomQxUbJuBXeScAYQBZO+FWUpiUaA4BiYFEOCtSDAqo0UIMCqiygvTuBGNSQQwlhZPtzo1/wjYVpDExjIRvjvGwbA2vc+S18tjBYH/mMnrWuA+mivmZ5djHrI6ch6qvbkdilGb86soxRBH7Z6koavc2V+2juy2OT59260dmn9qHl+84dj7YozO0Xo6urCMFI/OX+Py8E4+IvHpWN12BYP3Gja5HhenQrKhvbXXRWwmUnU0JDCO0FajrQB6TQKGSNQjZQqFGIKQoxA2rve1vPgNkYqKaw1Rh2PICd3AOTOwCAvbiEnV3Cnt0BN7ewx29gLx6Af+4PAADefruPz0rgtjzDQ/n78W5Q4L5UMUKpjftcEBan1gbdNWvj+MaRyyRm/L48OtoVneXR2EXRWWNtH339yPEkQrFUHPaahWKLxGGPEYqlojDCquIsKdc/Pj3mqTxv07qckIzXcSEZcW27fGy1t+xqjGl511K5btqiMQCoKhPET9W0bonGAECWNd585UQTRjDRmHGcWTEbY7TvhGBiOAmisWLk+Glqv8TojWsv9svgc6veOH5tsVcGH9xiIFuetYDzq6XzL/KsBdz3hjx3U9EYteeEYjkfWy4aI6TisUVCsq7ya53UfkxCMf4jfNXj5Rqeuc/pQ8sntat6z25TCMZ9ZrlP7apCMCGaheIvCVYWGr/2Qi6iO0gmBFOo8P69GyvQ+EltNcH7X7sxx85GeP8rNxZh7N1ZZIX3P3zu6gqN99+/c9fww5eum198F8Rj8uGX4b7vz9z5Z9rgh59dXa2jaIy0DtzbtksoFoxeEnFYEIKxSW1LSMZEYdTPY4Rg5qPxqRWQr3WgfWI8iVAsJw57rUKxZeKwTc+VE4WF9hXEWTRJWed4+lyuWF1XeZvtFAXk18LFZVxIRpPaLh9bGry0HwW5d+2H8+hTy0VjVc29a91AzUVj07F7HX84x/TOC8VuL1Dde6GYF4TNJleoZyQeu4aZOoGYFG7yOhtfQdvoWSt9uWi8eOzuAqp0nwH3rCW/2vHN+VLPWpoMPVyfZUVjNAFIhWI5H1suGiPkxGPrCsVe61j7MQnF0mjnKkIxitDumg9tGqldxXt2m0Iw7jM751O7ghBMCBJ35cVfMgjFTsO+BwenrUitqzuDQu3L53FSWzvu7MHhJWzlHFsOjq5YpNa9HpzdATeOR3tw8QBxfA0AaJqz0P/p+F24x3eV9/n2Y+rZ0WGYyJ4fH8IPry1v2y6hGI/UAjkhV+u2tsRhfF+aHG8qBKM+r05Z+2lGKNbRntu3x26hpx904CmEhZtSDrqEYAvPtaFYj9v35FIfpvuu0m7kPD2hTUkQUEpCSel8XgFYBZRBCJZ73y5Vo5ISKExIo2ushFISUkpI6fqitqIQsLotGgMAqXzqXCVQDAXKoUQzFKh9mlyXOreAbNpesdZPljE0gGa8AL+RNaz1aXGtMbBatTxrgWRJbIFnLQBIKb03rV1bNAYkPKwMFaFFeWD/X+d7lFtK7LF8yf5jx7Z9aOO+/m8joRzEHfJpbvnxXBQGOg+jHHCqgWtfTwgWNn+tChoKjXMzELZFOXCitJh2V6GGgkupC80244VrvK6eAfXUvd7du+Z//wT66hb6eozD/+3/B9WgxElV41d/3q00lV/9hFIPUepblMqgVBqlin/EBs7hILxaC2PB3A9sdrPwVAFgjm4AtKlMLaFWoCjMUw2WpbndlF7AdyHv70Xll4bAcqrYp4qeftDRvkrq2+fyoV3FZzZ3zCZpcvnE9Bu23PJNZull1XZjF9MP+Pm5pRfdv1rP+9hqbaKPLaMiVHX0r61q71ObpM6lJXflI7RiMAtL/qKsAj3AaheVlbNJoBdY5llLPrTF3iDSD5KUua5dRfpBWbQ8a91rB/0g8awF3KQ2eteKlekHhLRuURrddnv8XiyjH7xWPDX9IE2JS/hU6AdP6UPrztlNOVg1zW2Y1CaUg5R+4CgH3os98ZylPjnlIHrL0qSW+83aFuUgUAHCpJZRDnTN6Afe3aCaRvrBpMT7n934hIEb35rjfbz/5o07fFDip4FbOfrlt2/deX75Ld6/d2OSrH8K960cu2udNAY/eMpBrU0rpS7gaAhdlIOszyyjHCzyoU2pBsDyNLeb0gv4pLvruZZ7xvXYPfT0g472VVPfPocP7ao+s7wuRzUgLKIfpNHWbdAP4pLPfJrc9L2ESS2jJJAnLaciEA3h5vykRUWo6khFqD2nNpc69/7qFFPyqR1T6txzTCeuPLk9x9T715Jf7Wx82fKsVT49LqXLnU2usilzKV3u9O4i0Ai4Zy351Y4/nC/1rCUe1cP1Wdh3FfoBIVfXlUaXl9OoQO9Tuz79IJcS97Hn6mrfRfrBU/vQLqMcrJLmlkdqgTbloEUv4JSDjOdszm+W+9C2/WbdMZxy4HxmY6TW1Z27aGwoE6eW0Q+mLjp7cHQNXN8CAJprT0m4HuOkcsefVDUG525feXAe+jxtDsN9u5q4a50S/eD4MIzFPKUuURK6KAfck5bAKQddPrQ5qsGyNLeb0gvSCOw6FL0XQe9+0ImefvAM2MThYBvuBgv7F2IpfSB7Dr4cyJYSRbKsyAeJ9FwA5igJnT61ECgSKoLr36n7pQCM71sIty/515L2mpwApBCAkC4qKSRU4R8wyjklKOU8bokKIT2nVQ0k1FBCNRIF86xtPP9WDBSMMjCVgRlYmNrCNBbKk85MI7w7goGUquVZS9cXHAuE6HRCcDeK3ePECYHuI0+dmzohdLojLEmjy/2JN6Ek9Hh6SLF+StzndDzYJrp8aOMObcoBdzpIj0+dDoC2O8IydwM3kXWv7bS6kXJAm8r45HLKQaQ72DDB5pSm1po8+WCzfy3exsD9qFY/fwX17Tuot3f4+c/+8/jl129QXj5AfOcFZaoIm2wihaNiiW5qbdBoC20tGutfzTz9IKUc0PgVHFKsRaNtmBxzqgGB3toyn9mUapDC9TNPGdhVSkGP7aCf1Pbo0aNHjx49erwi9BnF8ugntQxP5Un71FgWMesSf2X7WjESu+xcBnbh8Ur4qKgUsLYtKgM6fGp91Jb2UEp6hwATMo65CK63ldIxCsyzjNHWeJ2FKlwGMVVIqEKhKBRUoSC95ZZQKmxQAqJIviQUSbV2zrMWAKyRsNrtY4yG0dq9Gm+5YwyMF5IZKTpFYwAg/L7GmJZoDCbed+5dy6O2dC8I2ahth49tDl2ish49OJ4iY1irr44sYflrWc2HNo3OpkKvNDobo74xksujs1wU5qDD1orO8r5o3663I4hypMJmiwFQDIFiALxxnFkxKCF++AKiuIH48QfIH76APL6BePcNAGBmPsfUfImZqVCbErUZoDYlKu1oDTNtMNUGM21grEWlDSpfBtxqUd3E6GujLbS2rahsLhLLyzmf2a5ILNWtEokNx2SEaGl5WXtu3x67h14ohrY4bB3x16r78uW6pxB6LROSrSL+ojK/1k0I93yZe9XjrbUtURkdn/O5JW4WF49x0VjV6JZozL3q4F07q5ogGivHblZbTOogvuKetRpeKFZPgvcsptGzVk5cezEaYrjnHhCpZy3g/Gr3PnNCDDWMorHSC83KUuHNl+6cRaE6RWOAE4yFa2WiMfrcUu9aKsf2vFBsVR9b3r6o/Brx2oViSqx//CJxWLpvKg5LhWKpOIx70s7XzQvJUnEY96SNdXQv2560rs7mvWeZJ+2qPrSp9ywXhTkwIVgiCot17ruUisIcdBCEKeZDK4QJZfKpFUYzoVgTRF2BU1tXUShWT6NPbe3GJ1RTvP/lV+Emk5BMfO5ep3vfh+sbTKNPbfXBWRlOtckKwUjXwAVfQN5nls8FV/WZTZ8haTt/bnDknmt8Mrqp/3pu3x67h14oxupynrTbuNaUU7ttH9o0Urup+Ovq9HguSrIu4T5Eatcg7NN4w0VlXEiW87Tl4jFKyHBzdoxaz4vGSDB2e3ESHBHuLk8x88kXyK/24fos8az1QrEHLxR7uMSMedY2M9dOfrXV9CrrWUt+tdP7C6gqisYaXya/2smH8yAk6xKNkWDs4fqsJRqjSWvOu/b+6ix8rl1CsVV9bAm9UGz3hGL0EXYJwXLlZeKwttBr8b45cRj3pCVwcVhLCNYhJEsjtVwcxj1puSCMwMVh6/jQ5rxnuSiMwqdc/NXlQ5sThQHRj1b5fQ8OzsJxTijm3VkM7XsO6CaWydKr9uKxw0tY74hwcHQV/GuDj+3xTbjJB8c3EPde1DraD9d3ORuG+35+FyO1QLcPLRd8EVKf2TTAuYrPbO4ZEtqT58Z8e/u5lkZYNxVA74pQTPRCsU709IMnwiaetOuIw5aJwnLirNbxYnV6gRQiCq3S62URwDmaw4J2XsepCkGwEsRbjl7AqQju/UdxmTBRwKJk9K8tvNeiMTF1Lr/HhZ8g1pJ8bWXrusPnUEiIUgKFhGQbTbBtbWCVdq8DDdtoWK1htfd+baxLm9tYWGUdFUHbaDMpDbQ20MZAGNkpGgPaS/4GkYqgVNtDtwtdQrGlPraEJZSEHp8enuIbIUBiLVa3IA3u/PFM6LWhDy2nHLRFYanQbJ6eIGEhYVxihRYtwp1fCgspDGRCleC0iPwb4xwN//guLFCUQFFACAkx2IcoJ4ByP7Axegvx+dcQ9wooBxBffwMxHcEMPwMATKvPMNFfYKonGDcG97XGuDGYUEbGxmBSaUxrDWuBaWUwq+OYYIxF1ZiY7IaVORWBUDcmONLwMuAium4s9OPdAnpBLo0usJgyYEOK8rgimFKmutpz+/bYPfT0AzwN/WCTNLiL0timdcvoCVKIhUszQoiV6QFSirXSCa7bzpeZcn6BjTZzPrYNS53bNKaDiuAGy1kV6QdTRj+ofIRWDjn9oIopc6WLVAgzwZ6nH8jpOHrWDrwP7aiM9IO9MtATin2vPn5ThuPVqAj0A+WtvMohT51bMCqCbFERqI68a4UUzLPWJ5JYQj8AsJGPLSGlJPT0g55+wCe126IfrJsG17XbTsrBc/vQdqW+jZNaE+gHArZFOeBUBCChH7SoCH7ia+pAP4DWsWzIKwaxrhyGshl9AQD4UP0QqBZy/EX43KtbvypVm429Y/kYv6idkFIK1vU/BxY/Y7v80Vc5frfoB+s5I31K6OkHrG6b9INN0uDmKAeb+tDSg6SrnZ4zq9ADQl8nmfYOv8B12vkyU84vkOgFnIpAxt/XZ8fQTaQfcP/amCY30g9mjH5AnrWTMaMfPLjw6fjmHBPvUzvzr9P7S9SMflD5lJRGuohINb2GVEVo13D10pbheFUzz1qfHrcZuvs7uT1HXUTPWuLR8vS5PHUufQcers/CpHYZ/YCwto8tIUNJ6OkHnzb9II3UboN+IMK+q6fBzfnRvpQPbVfqWx6pdXVn4fyOclDH+iAOZfSDFhXBRzgt0Q8uQt3B4WVrUhvqykHY1wwdJ/fO06CODo5xPnU+3KdHh7i48ynB/Ti6qXfsVcaHtuu5k6MUrON/njtmFX/0FF3tuX177BZ6+sErwrYpB119hHIHZYBAy/lpee12w87ldzE2UhKUki0qAgAoY4NThWWUAu5fS0myOOVAeooCedYCLqKplEuTKwsXFZUFoErPUy0ERCGd64GUgHL2CvTDpZnWkKZGU9UoBwq2sLC1hR36EboxLqVuY2AH0bEgpJk0kRawyAnBfYbR3UCx+xki3Ea0vGu5EwJ9Bwhr+diGE7UpCV3lHvMIn7v/br8WPPW1Prp7mvxl/Gi3A4tVfWgl4+RGX9vodCBb1zrveJB/f5JtJtIP/A9cWO94oAaAAjDcBwYP8XgpgTdfAPs1tNyDHn0NPdSYNJ8DAKbG0w/MA2aNxrTRmDU6TGYfxjUGDxUexjWkFBhPa0xnTes5VDc66Bm6ygRtIr2AlwnL6AONNiHQsQ59IAUf63L1i8ovjZ5T242efoDXQz9Y2p5QDtKlm0WUg9S9oKtdLWnnWLU9Xb4C5ikJnIoAOJpBLo1u6oQAALPKMPcDRkXw9INyXMUl+0EVHAeschFaq6fBvUBMIv0Aw0G4vuHQKYkHe3sY7jsqQqAfjIrgnqDeMicETz8oBpx+0O2EAMynzuVOCID7jN99Q3VYmEYXWOx+kKMn8PZF5deIp6Yf8DKfKO46/YBf61PQD/ikdhP6QYhoMsqB62tb9IOm5XRA7ZxyEKgGyLU3LPUttdus44GAnqcfWMvoB00sM1+s4IgAtMrupDIco+V+6H/cfAkAuKt/Ee/rg8YPP3v6wQcXqR08VFna2yrp29d9Bi5rfwx9IK1L+1p2/G7RD3p0oacfsLpdpx/kKAe8nKMc8PIyygGnGoS6ZBkp/XWYqlhTrNKeW77KURI4FYFS46ZpdHNOCJUXNdxenGBWMSrCzE96p2757v76DNOQMvcMkwdXngb6wQWqkDL3KqTMpYhrVV3DMnqC9kINpWPq3OCEcHcRJrUUEZ7cni91QsilzuVOCDQBcfQEhPeVS6NL6HI/yFERePuy8mvDU9MPeDmNfu4y/SC91m3TD3Lta9EPWPQTcDQDwnboB+RecNKa1KZ1hwcnrUitqzsFQurb01ak1tW1HQ9EcEVg9ANL+54HSsHBwXnb7JXqPHiZlqwODs6h5V7of+KdEh6aeC8vxq58dnSIS+9+8OCtD1NXnmWuO7nyY9sfSx/gdSbT17Ljd4l+IGQv2s3hSegHXGH4KaXS3MTxAHj6ZYRly3s5dwPJ3AKAefpAapSeNU33dW7J3218KSmsovm0tkqJyKlllATujkCcUgAhnS1gQhpdw5wQgjerP394nwmNQ0pPPZDuGEq5Sw98qbzjgZIuZe5AhZS5AFD7wR8AoJ37AbSGabylV8kcC5qYRlf6NL1WK1gNt0m2b5o+F/Opc7kTgnsv7YQMi9LoplQEaud1i5bn+uWvHl2gv3v+HZMibuv1tT6lZbtpcFm/meQK3OmA2ldJBLERHD8KgWRPKAZAMYAVArYcus26G12bIWb4HDNM0TR7mDSfY9pMMDPe/aCRmDQS00ai0g1mjUXFEibMao1ppYMeYThtMJk18YeyFKFdCaCuNRo/UaYyfyY2jQk6CF5etX0ZJWDVdos2DYzA67rKPXYXPae2R48ePXr06NHjtUCgT5PbgSef1H6qUdttYp00uKtikffs3PnFfCQ2FaWlAjUpgcJHT+n/UjIfWsR2Y9jxLPJL0VtpBcrCicWIU8tFc8GnFgKqkCgKl/JWs+gjbUpyz1r+/kQg31PUVvrlf1mq9jZQkLXK5lN2kViXJld4yx2rpfOp1QaiMS6S2xiYhu6N8n8jXtxlrYtOJ6Ixd4J26twgBKPzd3jXkn6rK40ufXRpdHZRVLZr3x49NoEARVDzaHnTbjESuk4a3Hgt7ehsiPJm0uByT9oQKe6IJHNQpBUCLgIrBKwVMFAwjPRhoaAxgEYJYxQaM0JjhjDG0Z9qO0Rl3qI296jNPmbmM1TmHrV2VIRpozGpnUCs0pQG1zLfWY1Z3aBqNIwBJrMG00oHKpQUArNZg6rSkAIualtpCCEwqw2q2rSiuo2xwb2GlwlUp0Q+Oroseppr12wXfk5t0WpL67rKPXYXTyIU62rnD8aPUSiWisO2luZ2WTubTK6a+jb1nl0kBBMCwaeQIIXIpkYM7TKfOpEjpFM08+1pikW6FhpotYnetU3Dysy/duYtu6rGhNS5XChWeC5tOa6DyEkNq+gDW7p2K2fBWzZNmQsAYjwJQjE1LIJnbbHn6AnF/gCjtz617l4RPWv3vFBsWGL/C586l3nWKiVbojEAc6lz6VqDECzxriXRGGEdH1tezgnJFpVfI3qh2PaEYlKIOR/a1Js2FYql4jCeEtedpy0O46Iwd3y3Ny1PiUv7kjhMolk7Da4SLPVtSxQWJ7VcHMY9aanPnDgMQKuc7mutnGu3UKHOWBXOpY2nR9lRuP7KvA3ve9o4+sFoqsP3spzU+MXPfty9dfoBPRyH8dMYhHLBJrVfsWc8lYUQc8/+dUTk6z6PF7Xzyeg2RewvBdH71HbiSYRiXe1pxPFjE4rlxGGrkNDTL+e20+Cmgdwu79kuIRgdz4VedHyXEIyioKsJxebbcykWL0+OovsBictOo0/t9elxy7+28qIwmgi71LlRKDbxk15Kl3t/dYqpF0U8XJ8F/9opCcbuLrIpc+vK+zlW11DC/UlVs2voiYuUkF/tbHwJSaKx+0vIxk1Ui5n3sb29aHnWKn8TuWgslzr34easFQmh66dI7cP1Wbiv6/jY8nI2je6S8mtDLxRDtryJUIx7zoZzZeq4UCwnDuMpcXPiMJ4Sd5k3LU+Jy8VhEk0or5oGVwXx2GkiCuOR2rY4jHvSdonDCLwswvHnIXrL2y1UqDOWlVmklq6/Nvv+vR5hpu8AAB+8YPb06BA33hHm/PgIV14g+8EnYfhwfhLG6g/nJ61ILeC8wekzvjk7Dt+bm7PjufHpqZ7HXe1phHWbIvYeu4WeU/uRIudJu4hysEwIxvtIEagF7OnGBVd0XPpwpDqlwIRifvQxkd7ghGJESYgL7UpKF1lmlAPb6OBfS1FnLfk1sjS5itLkMnpCocImJSmlmQAwSZmbQs8aaNtAVw3k0P15mdLANG6TpV/DankpahitYYyGrhV0baFr2xaYEZVCiFbqXBKN0cMm9a5d5ItqzLyPbTwuLyQLx/VCsUeBvuevya92V7FsST9NieuOaQvD5vpckgY3pRwsSoObetK645ekw2WwVsBa6V6h4mbd+KOtRGNKNKaAtQM0ZgRthmh80pfG7KE2+2jMHhozQq3dq5/LotIaM61RaY3aGFTGoDbRC7aqbdhmVQM1rvEwqTEc+B/aQgTKQVEIVN6bVggRfGqloeeAF4/Vjp6wSChmpUCtbXC3IfC6Tdr7NLkfN3r6AT5O+kHqSUv9dFEO0n1TygGV+bmIMpBSDWi/VekHvBxMt027jlMRABd9jT63kX5Q1zp8LpSffFY3jH5gWilzAUDdV2HpvJg0Yfke3qfWiFmgB0hMWylzAZcul+gHAFqetQCg9svgbVvsl4G+ID39QA1VoDcUZRGpCAOJfU8/oEhtmjqXqAj0uaTetVQOPy4Y/QCY97HldamnLaHLx7anH6y3L+DucU8/cP/flH7AHQm6KAd5H1rmU5vQDwT3ps2kwVVoWpSDVdPg8kltF+UgpRfwOk41iJPaSDkwdhCuq7GefmD2w/uv9JtwDx8aN+kdTavgTVtOG3xP4/K+X4EqJ/iSxsxZE8ZPmtQqKSIloYhlKQS+YmWgm57AwecLLzkfWGXfF4N4etek14qefsDqPib6AVVxH9pllAO+/J+jHFyezPvYXp4cZakG9CC8YHUXGfpB2m7ZpJb6zFERiIZwdXrUoiKQlcz12XHwp6UkDI5+MO9ZO/HetPdXp5hNXd3D9RnG90Q78K+3F6gyKXMpXW5VXYf3wj1riZIwG19C++jJ7OESQvuHQsVS55JP7e05mjLSD0i0lkudO745C/c75137cB3bOf2AwKkIoY5RErp8apem1H1leE76ASGXOrenH6xHP0iX9LsoB9yTtuVDm0mJ2/KmzXjSKkT6AQI9YHkaXD6ppTpCV5nXcaoBj9TS+a2fyB4enLYitfT+al8+PjzE2E9qb2dufDs7OgxUhIvjI1x7q8IPN25y++H8BDMfCLi9OGlFaqm9KGI50A/OT5ig2L2XlJ6QglMWVplbPFd7bt8eu4VnpR9Q6L53QWgvg290fOI+sMn5c6lrc93xc3GKAS3pc6oBP5yZGYQyv14lBRRNxnyZFqKE4u4HbacEf/bgiGCtCdenpAz+tVJa37dEIX2dsMGzNvSkPN1AKb/k6H1qiTNWugQJskQrZa70g3r5pkQ5GsBOS9QPdbwB5H5gCk8jAKzWYUPjbqZVFlb7TdIy17wTAoC51LnkhEDvNfWuJScEmuBy71rBPsucT621kYqQ+3707gc9Pga0PWnnv7+5NLhttJ0OAMxRDjgtYl2klAPaaDILW8DaArAFtFXQ/pU4tRoltHXuCI0t0dgBGlui9mNKY4DaGbKgMQa1NmiMCQluOBptUDfaBRXcXBhlIVE3Bo02MFYGqoIUFlVtUDP3AymRpyewgUVrlzrXWuvKaZpdXyeEyI452/KxXWXfl0Qfqc2jT0nRo0ePHj169OjR49XjRYRivXftcnAf1pWPyYjDgOU+tjlRWBqd5VFZvg9FZ3ORWN5H4aOlsQ0opEAhBYydjzwba1vRW4quimi9GrOUSeGjswLGxvtGljNa+8i4aEfIuSKXNlUIFKV7pcstpIsIF1KiZtnFpF9qg1IQhQKUAhAjtVbTq8syZrWGNdJlDjOA8L/6uaCLZ7kxhomy0I4WhCxjXjRGP09b4i9g5YxjBO5jC2BOSJZGb7vKPVbDMjHfOjBRg7h21q5dQ84bdiv9Mk5tTiiWFYJljufisHV8aAXz1XXttrMcfGoZuOwMnoqgoaBRQEPB2BLGDmBsGVxXjCmgTQljCjSaxFMIacQbY9EY41513KK+yo8XsNBN3AytHlmLadVgVmtIYTCdNZhVTSuCK31UWRqgaSyaxkJKuPNoCyvjfaEosRECjXbXRZAUnbUAKJKbRE+pTor499W6h6xunfbcvi+F9FnbI+JZhWK59nV86566/TmFYlKKx7UL0fKkpfPnhGB8mSInDktFYdR/TgiWE4oJgSAu4O287vs5IVlsNxZz7cZa1h7LkVNrw/krJhqrG90SjQHODJzECdNKByFD6e1rymmDz79zQovZpIpCqsJxykRRBcGWFdGzttaOMytmMwz3nTetmEbP2mLkHipqr8Ron4Ribc9a115g7zPXpxoUUTQ2iJ61xKVVhWLetW3RGN1r7l0bPHfD8l9bPLbIxxZYLCRbVH6NeAmhGK9LRWOETYRkPC/IaxSKOdFXcvwWhGJk35WKw34VPGljOxeHUVnR8UwcJkW9sg8tn6QvE4oRZ7bLh9YQZ9aW4fq0GYX3UtuRe9V74b5NmjLc9zvPj92bNcGbtpjUURTsObV2OA3iMDuYBUEojSlFIfD5d/7+SBn2LYtYpvTmUkSfW8kEZpzWlhOaEbgnLoBWOa3jorRc+7LjV9m3x+7hWYViufZ1fOueuv05hWI00exqp/tylWnn4jDenhOHcU/aUJeIw3KiMO5Dy4VgaTTp4uQo8GYvjufPxesujnn/sZ1+aPN2Eoe59lim38laR/EY+dBenRyF6AMXjZEg7ObsODgifDiPPrVTL464uzxFNSXP2jOMSRTmebKTD+eYBvHYBRrvWVtNXN1sctXyrDXSPXSkKkJ7zrOW/GqndxdQgyKWS3eTJrfnIcpNgrHxh/OsaIw+H+5d+3B91prUhjoR2wnrCMmWlV8bXkIoxutyorFN+08jta9NKEaTPy4a24ZQjPrIicMOD46DQCwnDjs8OAkCMS4Ok34ivIoPLY/UurrzzjJFajt9aK37o9f+9fDgBNqQJ+0xGu9P25hRuG9TLw47OTzEfe2u+96Pj+fHR/jgx7/LkyN88P7ct35ye3txgjsvmr27PG1NaqmOxvrbixOUXrR6e3ESxh36Dnw4Pwljiiu3bsuc0IwgM3W8zOu4KG2u/bULxUTPqe3Ci/vU9lSE50OXOKy1D7N+Sr1nOVLKwXza3EgvEBAoRBSFhXZfpwQwkAIluy5jBQZSopQSFhYDJTFQMi5FMSEZIDEonHDM0RYcFcH6i1fKOnqCklDGhuNo0G20QVEIFIVAzSgcFF3g9ASeLlf45AaiFG5rRMvTNixbkQhM2+BXGzxrQal1LUxjIQuXFtcaA+M9a00NmKF/WCapc7lozH1ube/aRWl0ORWBHiDWYKGQDJinJPTYDrZJRegRIUIq266lYwtKiRuOScRhlBI3lwZ3mQ+tECQWsxBs+VrY+P9cuTthMF02UbWK1qap7B/vLXGYdR60tXViMADQ1qWN1dZRAQIlIBFIGWPR1A3qqkHjJ8SASwNeTRvUswaqVFFIBi8KawwT7QpGSYhl6PjcyNET6DmkrW2J2KjM/16M9QJbizn6AhDrWlQGBl7XVe6xu3hx+gEvv7Qv3cdOP0j9aHP0Az6pzfnIUntKOUjpB5xeICHC8hZBCrTq0nZjY51BpB/QAKVNpB9wKsK00i0qAtWF1LlVE5a0Jj5CW0zruHw2rFopcwHAqllY8kdRt1LmAoCoJ4FeIIYTDEeOfiCH3rKL0Q/UXtuz1h1TYO8z511b7EXPWqlUK30uMJ86d45+INvetYvS6OZ8bAEESkJKRYjt82l2ef1rxUvTD3j5sWl0e/pBpB9IoTt8ammZu2mlxI11P/nzRvqBFOReENPgKjFPL0gpB6HMJrXv3/9iYdn4CO06aXAbMwr+u42nH8z0G/z86/cAgHGtw+dK9IO7SofxVT3UkaLmV6oMox80cjznR10UMvp8D1QYS4tCtmgJ7lWEviQrC/bcWJWewMt8hZBTFlL6Aq9LqQyh/RXQDwREK9FOj4gXpx/wco6KQOjpBxGb0g9yfrQp/YBPavP7+smRr0vpBakf4cXxUbgv5xn6Aa87b9EPYp1FpB+ESS1REk6OWlSEmefRXp0eoWko+QKnH/jyOfOp9TSEu8tTTB6iZy2lzJ14ysHkwzmmE09ZYClzq4lPnTu5Qj3zdbNrSP9QkjLSD5Sd96xF7ekH9xcoGBVBSl9m6XNzqXPHH86j/Zj/3Lh3bVca3RwVgeAoC67MqQiENM1uqO/pB1uhDzw2jW5PP4j0A5nxpG3TD5gnLZvUUh2JNA8PTsO+PA2u4lSDjA8tT3MrEqHRIvqBQeTUUl/L0uAS/eDo4BgNXLnS5E17gIkfE0+ODvHgJ7UPnpJ1cXyED37Muzo5wt14nn5wf+N+yHM/6sKveN1fnUKV7vruLk8DPeru4rQVWKG+JCvTp78OPYGX0+/oavSEeSrDsuNz+/bYLbw4/YCjpyJsD10pcQk5x4Mu5HxoU8pB3PwxEJBuMd65DrCNjneOCJ6XxcoERzlw7giOiiDCBFlai1I5egJgIqXASgxKR0Wg50dhDErvc1s3nCYhwrXQveLOCPQdVIVC4VPnuuXEmDIXgKMjDArIRkGNCreJAo3np8mBgm2cNN0atDxrAUAY6db8TZueIAay5YQAABLt1LktJwR4MwTmXUtUBHqvy3xs+cOBUxHCdyGhJOScEnp8XHiNKX15atxse8ublh8377bQdkLIpMHlVAUSmlkLCe0m1MZAGA1hdGI10riNl4WEHyTC+NMluCdSEfeutYgbTYC14ZtFY6x7JdGtr2s8lYkoTak/LNB2j6FENVpblNMGs5lGaWygIpiyQFUZVLUJvFtjHOXAURJiWcUHAzRdh0ZwYpDsUiI9QXiHGHc3QjujLMTxj912X5dSGcLxGXpDWu6xu9ipSW2PHj169OjRo0ePxeg1DXns7KT2JbKPaRs39Ql9X3IZw9LoLBeFzR3DorAqtJNQrB2VZT/IUaoQ7Axl7lNLdcYKF2mV8foazcVlMkRtrbIh+5jWccmesowpaYKnLfnYzhCpIzy7mFK0FKljJDfJLgbA+db6TZQSolQQWgKOiQBbG1il3eug7VkLAMJHTkFRVE3R1Cgasz6lrpHtLGNcNAYA0og571ognzGMgzwnWz62wEIhmTsuX+7xODw2OkoB82XDJ89aJ/EJDXpLkIrDuCct4McEv7VEYRQVpMiraVyo1Wi38ahhDDPGsoj70qfhxmDtKQ3MqDsDF5uWTmRmY6TXeA9pwzYKbmrrIrfa72PZvoCL7tLGV4dqT19QhURdazSe2lVXGnVtADRoqga6bmCN1xcUIgjJCkjnR8sydaXRW63dGMe/yNlILvvqxmuMUd3wubaiu+2PYNHH0rVvj93DTgnFcvu+lI8tn9S+RqGYTERhQLc3bepJm9blfGjb4rDYXrB2Enrxsgr9Az/8HIUgVOaTWqozFq0y4IzDqc/KRCHZrNFMNOY5tVUT7ttw2oTPmLi0alwHwcJ02swJxUQxC4IsW86Cd6ywjmvW6FnwnhWzKYZ734Qy4PxqqS71rAUAuVdg750TismBip61wygaK0rvaVuKcP5UNAa4z52Lx7hoDMCcdy0JxQhcPAZgoZBsUfk1YpeEYoTUu3ZdH1slVheaLRKN0bW8FqGYFE1LHJYKxZRoglAMMEFoRfQBxYViQrc8aaku50NLvF+YJoq/rG2VCe/ffz9fFiLu6zn1RpShf20HQShGVl21iUKx2u6H91p7Li33pn2odfiOkZXXYFaHMXM4rsNzRez5X+V7VfSpLSbRp9b7eKsyjhllqYJgtByoOJYWcVKbE5KFoAITj6WiMgIXl31J7ex5nROSEbj4LNe+6Pjcvi8FIdriuB4ROyUUy5Vfysc2jdS+NqFYaOfesx3etDlPWprEdPnQtsVhsZ1HagHg/Pgw7OvKaLWfMdHK2dFha1JLdTSRPTs6DIy3xovDzo+PUJsoJKs8T/Xy5AgzP6mtfATh+vQ4TGRvzo4x9YP6w8Q9qG4vTjBjnrWpUGx8c47JxA3kk9tzzHy99oKK2fgS9dS1V9Mr1JVXD3u/2mp6nfWsJb/a2f0lxMB9ANP7C6iK+dfSQ4F51+ZEY3T/uHctF43lvGu5Ty0XjxG6hGTLyq8NuyQUI+S8a9c5nv7OuoRivG6ZaIyu5TUIxSjJwtEB96mNQrEoBDsGghDshE1qSTwWxWHck1aGurYPLYnSiCt7cHAeJrK8TJgTivmbcXBwzia1Rehf20Ese1FYHbxpT4LjwdHBUZj0cm/asXeEOT06xNiPi7c+4npxcoQHL4S9Oj3GB+9+cEt+tRcnuL91E937q1OM/finijhmFF4odn99hrKMAjKp4qQWmBeSEbh4LCcqI3Bx2QfmSUtIhWRp/13ty47P7dtjt7Cz9APCaxKP8RSn4iNdyuPuBpxyQJ6zYdIqoyduIebpBVIIlD51rhQCQ6UwUKo1OO0VCqNCwdhYppSIEgbDwgnJpABGSmKoBACFYeH6Mv7brY1FQT61hURRuFflhRCl97gtC4mqNsyX1r+XwkU9ZdEWStD3UUhAKC+iEr6eC66spxNYO+dZCwBCGUdNaAxQSNKJtPa1PA0uS53LRWP+xrS8a7lozB2PbBpdQk48Ru+h9X56L9VnwWvwrqUfmnxyy5e8N7lsLn7adqrcFK2UtkvOFSbQjHLgaAokCiPhl2GbBnQN6AbgQjRdAaZOypLt6yCVDP2bVqLc+Wu1ELCWWv2kmG0toZiJFKMgntLON1ZrEwILfMzh9ARynbFWo64Y/SBDRVA0xliJptLQtYYxmBOSwaBFSeCiMsBFbyNdwS6kJwAiUi08DEsDDCymLywq7wJ6Tm0eO08/4HXP6WO7Cf2A16VUBMJrpx+EzFYJ5YBTDehcP1DqRTlPL1BChGUw2SrH66U6Y2OZBuLamNBnrW04/1SbcF0TZtlF92o8Y/QD705QTpq4zDWuQ8rcYugiFXJQhWV8qyL9wLFxgcZMMXrr6ANpylwAUMMiSz9Qez6N7qjAiOgHe2XwrFUDGegHlGmM0w8KJUP6XrWMfiDjj4lcGl1Cl48tR1ea3Z5+sH36Aa/bJI3uc9APCBJ5egH/Ibwq/QBAi4rg+n8a+oFgPrUhEpt40/46eNJWvq5uUQ4CZYBNagOlwDR4/2tfZqTzUMfLQsayKsMr9d/YUThv4yO0ldkP11+ZN8GftzJvAACTRobP6m7WMPqBu9ZR1YSxvriv4jPGR2oxivQDlJNALzDSRW25N3Y5UFkqAkVzuaetLFQca5nPNqckpPQDTkkAsDI9gYPXrUNf2CX6QY9u7Dz9gNc9p4/tJvQDXpejIoT2V0w/4JNaqiPKwTmjItC5zo4PQT/COb2AXk9ZXc5f85TRD06PDkOktvaM/bOjwzDRPT8+xExHKsK0jskX6F5N/EB+fXaMqaciTKbu9fbiJCy/OfqBT4k7JvrBWfCxndyeY+pTRuoHN/jPHi6zKXOVXz6sZtdZz1pF9IOHSwhfnt5fQPnlO5cy16fU9c85njp38uE8pM+l+869a8c353Ofa5pGl9DlY5uiK81uTz/YLv2A122SRvc56AfhXJk6TkVYh34AVuaT2tC+RfoB96mNk1qiJLTpBypwamtfFykHBwfn7UhtqKPjL4AkunpweJGUZdzXU5VocntwcB5S3zr6gaMiVGYvXH9t98I9qM0+AGDauD5PDqM37dnRIR78+Pjgs4NdnhzhzqcEvz49xi351N4z+oH3rL2/OsP41v/oZ97YRD9IqQjKj0Xc05YyMt5dnsZJrf8ycEoCpx9wSkKunddxekKKlFKwKn1hl+gHfaQ2j52nH3A8JxXBz42ezAWhtYz8xO9lk/4F2o4HPAWua099aP2rP1chXIS2EIASMm5scCqVcy0ohMCokBgqGbmf8JQDpWAA7JWefuAjHUqLQEmotMawEMzT1rkiNCqeKzgeCOeiULD3wykFPD1wSFjAnCAk/L2AgPQDtBbScxBkK2UuQc8aaNtAV82cZy0ARL6B8dJk98qXnikBhdUCVgNWzzshuDfD1NFs3TEsEXel0fXvtcvHNn6X2pSEnFPCa0ZIiWnzZQBzD8DnwiZUBOO+ajB2+XUvc0J4LBWCK+9z1+IWlN0U9KlucW7Jvmu/tjetT4lLyRVY6lto5nQQpPJ1pBRoAzSeUmB0PEldAXXdLksV9w0XI0L/UkpIUUOKGlqUC9+DteRj2x5H6F/4fnOmRItqwChHYEvwfsww/iFZzzTkoMZs0sAYoJg2qGYpFYHGJYOmcVsBwHgnmCYkqrGuXTvKgTaeBhEcCNqUBO7MAHTTE/gz0L0v2yrzv+9IX1hMZeixm3hVk9oePXr06NGjR49PGULECHmPNl7tpPYlfGyfEy8lkFsWgeHuBXFjnrV+vzQ6W3jhWOmjp6WQTtwlJQoFF6ktBCRbatwraowKF8l4U9TYL+qQWrYWwJtSYb9w4rIoKtNBQKZ9pKIpLAZeCFZrJhSr45KXku76C+XaCyXjsqkUkMpHcn1mMVkoCOkzgpE/bSEhlIIoFIRSKEbuWimzGIA0LAIAsEa66KtZ7FkLuJSZ7nsxLxpz3cc6LhqTxr0ZE/aZj9rSeyXwqC19BylyS9HbrvLHjJbXJ/Llp/6T3cTHdp2o7XOCAoLb1MFxwRTPKkZZuFaN2AIAzx5GENaGDXwj4VejgaYBGg1ralhdweoqRmqNga0msPUUEAK2nsI2M0CqUBY8qttUQFO7zIUkSvN0jJbILRNJ5BF4Y+MWoq9JHV8ZWnhf/FjeVGx1R1uYxr02dVtA5qCgG+NFZjFqK0m0phR0Y6EbCyN59jDXnkZvSVQW3uuSSC6Alg9uTvyVF4cxUVqPncarEorl2p/ax1aJpxGK8TKfSKzavo5QTLHjlwnFKCFB6k0bhWJEL4jisELKOR/aUsogSChkFIINaFIrZRCKlErg51+/9+fyaSiZKASIohGa1FY6Ck0mTfRefKh1EJAFztgseteOpnW4h4MxCcXqIAIopnUUKgy8D+Owit6uZR28Ya30nDIzjT6zeobRGycEazynVpoaw+HX7lyjQUs0Rq/kc7vIsxYApFLY/8LXJaIxwAnG6PpaorHwawQt8dgiH1sALU9bQs7HNi2/RmxTKJYTPK7b1yrtm/rYclpVrj0VjaXtqWgMWC4Ua9dhzsdWCIRxIPWsdf2vLhQT0EEwJYVeWyimEH1qlayCNyyNTwpVFIfpOpYbL65qGrz/tfs7tqbG+1996/dlQrJffRPeeGiXKpQFCcUGoygeG+yHc828EKwyb8P1z/S78L5n+h0A4KE24XO7q5owPt55rcFw2oRnQXk/C88w5Tm12KvCmGhkFIqBfGoHdRCsloMijDnFQLYEZMC8eCyIxoiWVkRvWyFFEJIFATMTkqWiMgIXj32REYrlfHBz7YvKLw8RtCw92nhVQrFc+al9bGnw37ZQjJdTzmvankZq1xWKpf0vEooRoZ+Lw7gnLU1quTiM6rgPbelHobOjwzCpPj06bEVqASde8BonHB8etCK1rq4tGgmRWv/j/+TwEFM97714dnSIibfMGlfRu3Y8iz6MY+9PO/ZCsQ/nJ8HH9u7iFA9e/Ut+tQ/XZ5iMXfv4wzmmXjRW+/1m95eog2ftFbT3rG0qd3xVXcNOybP2CtJz4kgwNhtfLvWslZ4zO729yIrGSDA2/nDeFo2JOKkF2uKxLh9bAve05XXLyq8N2xSK5QSPm/S1rH1TH9v0+lIhWU40FtoPo2htHaEYwf2dx3J8L7GOi8Y2EYqRd6wTjfn6NYRiCtGnVkomCguTWqo7dxZcoewngt4P9uDwEtZHbw8OL1uRWgA4OLqK3rRHV4ETf3B0BUFG0yWJwy6AwV4418zcAwBq/3p4cILK3IX3Xem3AICxHwdPjlKhmKu/n0Wh2L0fv67PjnHvx0cSj91dnOL+g/epvT4LPrWV32/y4Ry1d2kZfzhHUZJQNYrGcuKx+6vT6M7CxGM05txdnrYmtaEuIyojcPEYF5Xx9pzojLcvK/fYTSyd1AohfhPAbwLAu6++efILWhdPvUy/aerc1+RZy8VR2XZGLwiZX5g4DMKPyyJGcoWnJgjhIrED5agHA3+SUhkMC4NBYVDIGYbqAQM1CQ8LJSrsF/sYqQ8AEMpkPq7kCPtlhVFZARgEUVljLIZKYqBkcEVQPm2uUo5m4NLlijiQMqEY0M5uA4D51orWvuFz9W3uFcHjVnj3AkqXC8CLvKx7JYEVW+bna8RcP2bJE1IywUciGgPQTp0L2aIiAGgJgKIwBFkfW6DtaRveA/O2TekJrw18fPvq2++21m/LG/MJl/yfysd2E9EY90NNPWuB7dILnhwsNW6rmjKG8T9ObQCt/StRiuqwoamdEKypHY0AcBHb6QCYjd3/JyUwfXCOB7MhMBvD+smsEDIerwrvY1tDytHCt0BXzmkn6Qa02RP8eRc0b9ZG72sO394YJ+xqjIFoNJpGQzcaUhSOitAAmn6YSAmto8iMqAixa3es0RrSiiAk0z6leEpJ4KIywD2TuKgtpSdQfeqDS+CUBQCd5R67i6WTWmvtbwH4LQD48ff/Ibtr9ANe99Q+touoCLk6TkUg7CL9oFDMp1bM0w8KKefS4BaSp76NnrREL+A+tKNChuWvof8lXqq4lFjKaVg2JB/IQlQsjSVCufGT2trsh2PG9SAsZd5VzVwaSO7DeD9pwj0ofVSC0w94ylzlI7ByWEXv1rIOy2tG+HZE+kHN6Qc+aiNm00A/SFPmAoAaRfoB96wVw6LlWevOH1PnKiVbVASqi/QD2aIiAGh51wJY6GMLoOVpm9bxci7l7msAH9/+4B/+I/YpfWql2B0f22X0A17m9IFcOx/feOrc+TS54tXQDwpRt1Ljvk99ai2jHNRV9KT19AOrq0gpqKtINQj0hBrvf/46vPdQLspYLt2kVQz2A5UBozfhvLX8DAAw1Z9l6QdT7drvKh0+q/sM/WA0jWOiup+F513hV6JwPwvL/FDTSD/w9CueOrwsI/1pwKkI/gd+OSzCOKGUCH3R+KJUm5IQqQieC51QEjgVgV7DtQIL6QlpmY5/DfQDgfa8oEfEq6cf8Lqn9rFdRkXo6iuN1O4a/YB4tK5+nn5AS9vck9a7WTnKge//7PgQAzY5AtxS59DvfHJ02IrUAm4psfCD49HhUStSC1AaS4QyRWprSgd5eIhp7epODg9x7z0XORXh3r9enBwFqsHV6VFIj8vpBzxl7sRPeieMfjDl9APvU1sRTeH+Es3YUxHGl9BeIEbpcqvqOpsyV5lIP+Cetag91YB51soyps6l+z65PY+TWuZdSw8CTkXg3rWELh9bAve0DXUd9ISeftC9L93CXfCxXUY/4OU0UjtPL5hvz1EROL1g5+kHgtLcxtS4BwdnbFLL0uDWRD+4CPQD618PDi9dhBWeXsAjtQAOjm/C+z84vgnetAdH14F2IMpJ7Gs4DuetffKDmR6H6+f0g5m+BYBAMzjtoB88MPrBLaMfPPhx787X3V2e4t57095fn2F868dHljq88fSnyYdzNN5be3wTx6fS0xMers/CWHR/HceXHCXh/uoUlN4xR0lw5fZzh1MSuugJuXKOstDTD14XXq37QQ6vKaXuc4KWX57ql52EpyMg/iIuvONBIYV3QHBOCDQZLuQMpZyikDMMxAOG8h4D8YCBdAN0oaZ4UxbYL68gRYN3A4u3g3NU2k1mlX6HPbWHkfwAlJ8HKoK2JfZLhb1CofHrZ6V2frildK4GpXc3oMl86k2b0hGklGHjoDS63qA30BBo2wQtx4HEs9a1m7BxT9rwGbPUuUCkIoR9O9aIo/tBdETgk5WWwjjxtk2vu0ce6bIvsF1KwjpUBLqGlxom1/GspRzRRgAGCgYK0mpYKwArYP3xXW/F9SO3QgQTREcwjH6ABrCNeyXOLKccVBNHM6gmgBePYjoD9gVwd+vW+ocWuLkFRkPgTgEP98Ce68tKBdvMYHUFoYeB6iCVdz9oeepm3j/7Xhj4+w600uBq9uzkr9QevGtNfOuhfx03LV2KXW0MhDaBHkAzUOmpCbpx3rVEReD9ae0oCcbY6GnrZyrWSOajLVr+ugDmKAk52gS5J3CqAiGlLHSVXxyij9R2oXc669GjR48ePXr06PHq8VFFajmewsf2MaIxAJ1xgqeOpL4EhM/AJYSAEo6LqwRCmskCMxRiigIzDNQDhurOveLGdXB/C3XXQN1fOi/H0QS4usJw5Gxqir0Gb8oS++U1TFViIO8xEGPU6gsvFHMRYgBQwvrzC5cljTaIcK2UMaz9JuZ/80nho7g8u5rkG4vULomWBfEXj3K2sovJlmft3PE+QmENIEIgNgp8FDKR1tS7NonapuIxitryz5X3mROV9VgdXZ63jx0KVvWxXcW71oBWAfI75M6VWxCwFv77lP/T4IKlTURl1sqwQThPZ/dX0GT3NbQvbOs4t4MIkeDs2079af1mrY/Uap9RTNcuOjvzUdpb51Rg7+5gZQV7eQ/MZrDNHezlA/D2ra+/g/jyS9dXMQDqKVDPgMHIeeHaOorWOu+He219x/ylwrJILROC8ahs+E4yW+1W1JdHerWLYgrun+0jsqbRMP7LpaWLvGovqKOorfK0Bd0ATe18alUh/LmApiGhmc0KyWisTqO3UVQW70u4PswLzUI7e2+58ktDoM117xHx6n1ql7U/lY9tKhoL7QuEZKl3bepjK2W+/bFCMYJiddsUipVKBPEBWXkNmThsv1BBFDJUlX+9w6/e/+zbR0GUMYT3qXooo89jNQlCC7HnxA96/1u8f+++i7fVD6Gv+/rrcK6B58eOZk241sG0Du974IUQxbjCV14oJh+iUKzwnDI5mDGhWBWFYuRTK2fBT7bRs+g5W7t2MZ1khWJyz3Nq98ogLlNDidFbLxQbtD1rXXsUiqWete5aondtKhqjdu5dS2W+ZpPzsSV0CcnS8mvENn1qV9l3UTufYD6Xj60S3aIxd02L+0q9a7loLNQx71ouGkvbU9GYqzNBKJaKxtx+TCjGRGNSNEEoJv0EV8AEoZhkQjEl3ZjQ5VNbeB6raJhPbT2NY1VN9IIh3v/sxWEPBd7/8itXHvnUtSOL99+7sQyTAu+/cz/W8dk7vP+FqxfffO7qvvwy9CXefhXOZUZfAADGzVfhWqf68yAUmzSun/1ZWzxLY+HQWw0Ox3mhmPLjH0azIM4SxTQKQpUb3zSmYUwqBrLlnc39a6mdxpSikGHMoEmtEALvvvHtZRSSccvBVYVkAOZ8bl3dvJCMP2Nz7Wm5x+7ioxKK5cpP5WObE40t6yvnXcvL9Ie1baFY2v+2hWJk43V2dBgmtQO/w+nRIUY+McDx4QGGyg2UA/kAwIk3RsUHAE6UESK1YydyODi8DA+Kg6MriJE7Xu9Zf8wZvF0ijg6O8dBMwrluvACMVL7nx0e4m9XhvZIQ4t4Lum7OT3A/ZkKxiTt+4ie/D9dnmHrPxvHNOSZeIFZ5IcX0/gI6+NReop54H1vPo0uFYsLnO+c+tapx92r2cAlRzXvWkl+tE4rNe9a2xGMZ0VjOu3Z8cz5HREp9bAldQrJc+bXhqYVi67Rvy+d2HR9bOmeXaCznXdsWguXb0/UO7l3LRWOE48ODrGiMhGDHh4dZ0RhNfo8Oj1qiMZrIHh0cheMEF48xoVic1OZ9aknUKrzg6+DgPDgaHBxewPofsmTVdXB0DUxcdPbg5IZFan3duYvUAsDB5QMwE77+DqLxj+eJDH2JNyacywy9UKshUe0JZuYhvO9p48ZQGv+4ePb8+BB3XjT2wMSzd36suzk7xr0f/6ju7vIU4zt3rQ/Mp3bq66Z3F+HHNffO5v613LtW+efCw/VZa1Ib60godtbK7ujqlgvJCFxUxuva7WJhe6780viYVna3iY+WfkB4KvHYplSETZCjUvDUhrllCL6ktGyZgi8vKbVw1wDuXcsRBh/h7otMtqBkFjWUqCBFjVKOUcoHlHIMe+8muDg7hBV3sGcfYA8OYY/euOW59+8BAOoXEmpWQFU3KNUbDNQ9SvUAZT6DkhpKmmBl1r6G/HUTnI+taNmgcSpF672ueK84rPVUA2vjSqchCsKC43yb87j1W+JZC3j6gYmpc7lozLW3vWvTNLqpeCxSEeL1c0pCTlTW4/HYlpBrXfHYIirCJt617jiHLgHHsvcaFnwZvSAVjQGY85SNx8eUucvS5FpLNiCLl/Y7QcvTXFFV1cCsAqoa9s65E9T/3yvU1xPUNxNU/+QO92+GeHiYYfgHvkBzM0ZzPUbh1VHizRsvOqtanrgi836JcmGhGKXFZjc6WntxlDa29RnSnef0KJ4mW/sEE1y8amoFXVuYGjDD+H2hfbl3LdCmIgDuGae1htZOSEZUBBHGn7yQLKTRTSgJdN10CiEjPQEAUqEZgBZlIZ8yt8cu46OnH/C6bfvYcipCqHsC+sGy9kgZaFMOOBUB6KYfLEuTm6MfDFQ7NS7RD4b+1zf3pt1r0Q9cJHWk9sOS39tSBiqBuKPR5x7vf3KcMju5Cctz4hduSU789E1IHflQ/CIsv32ofgrLksOJG4CG05rRD6JnbeEjrZx+UE6aQD8QIx+1GVZhSUwUs7Bkb0sftbGr0w/UsJjzqZXDItAPij2VpR8IH8lQAxnpB4lnLeAm2rnlP/pBlHrXLkqjC8z72PK6VntCS3iN2CX6ASH1tn1OH9tF+z42jS6nH4R2kacfEFLvWk5FcMfrLP0g9ax1xzRZ+kH0qa02ox9QMoXpIPrN7iGOZT4TS309wfuvXJrb2UWFX71zri6jL/fx/mtXX9CY98OXoS/x2dfxXG9dnw/1N+FaJ/or5t/t+tmf1Vn6wchHasuHKjxLyocKXyX0AzuYhWV+FJNAPzDCvRcrZ1lKVDmULSoU0Pau5Z7ZRREjrdHHVoVxN2QUU21KQppmN6UkhOv26KIncOR8cF39DtEPhOgjtR346OkHvO4pfGw5FWHZvpvSD8Lxcp5ywKkInH4Q2yMVoYt+sCxNbo5+QEkWeGrcs6NDDFTk1AJu+ZLTDwaehzWUbmns8OAEb8oLAG55T9xf+s48JeH0g4vQwi3PiXcf/PX5Yw4vMFbD0NddLfy5DnEzdZPaW+/D6OgH0ZORltU4/WDil+JuL05w76kGrTS5fsltfHMe/Bln96vTD5Rwf3LV7BrSp8EMqXHHVyFzTko/IL4H+dVO7y6ynrUUPU6X/+i7k/Ou7UqjS+BUhFh31irnaAmvDbtEPyDkvG2f08f2JLPvNtLocnpBaOeUg0w7jUncu5ZTEVo+tUs8ayMlIe9TW3hB69r0A7Lsmvkx6/gauGVj2blPbXvjvWdvJqge3PGHDzMMrz1t4XqM4sxFdYW8Dn2JO09FOLyEfeM9s2vy3D3B1EzDe53ULqUu0QxS+gH5d9/58e3q9BgP40g/IFrC3V2kHzzcuf4frs8w8Z61lC48pUQ1w3kqFPeupSzAnIrA/a6VXzZ0Pthu30g5iJSEVprdDCWBUwa66AkpUh/cRfv2cBBC/EkAfw2AAvA3rLV/NWn/twD8R/1/9wF8Z639YtvX8dHTDzg4FYGwDUqCF7EvpSEsS53Llaeb/ApzAtxudfFqfZAoY9lS5WL6QxfoYSOECZu0DaStIW0THgrmnxzC3N/AXD5A/Y/+D84LF4D5n/ynXEdffgs7fYCdTaD2NRQaKGhIvmXcCx4NyTZ6T1JAKHI9cBPLlU5Nq27GuGVFY5wPo3arloKvB3vw5UG+7Gc9P5dTIlrLxWH5jbWz71tIo5txRKBLbB/XFl+ktIQe28E23RGek4qw/FrmnRBa3rVY3wmB+9FyqoJgVAIi/bj9pL96+rJHegJvN1bAWPdqbVwVQ27LgafR9fzZ6p/cYXZRoXqY4e//7y/wNUpcosa/9KcF6qsZmvspip+/jDfLmngz/EbXwq+VO0DQc8n6e2ot0BigMRaNATRzXwnetJYoSWxJ3nqva2taVISQKptRogycM4ExGtpTEXRtgdKP+8y7toBsUREAQIFRBqADFUH58c3Atnyy6XnHKQKckhCcEvyX2Gpk6Qmt7xGjLOjG0R+AdvmlIdDOFPrSEEIoAH8dwJ8AcADgd4UQv22t/Ye0j7X2L7L9/1UA/+JTXEvvU9ujR48ePXr06NFjU/wxAP/IWvuPrbUVgL8F4E8t2P/PAPhfP8WFfFKR2hy2KSRbRzy2SdS261rJO2+5ICxmjnG/cr2uIXOYhQ8QII3K0h5tIYix7pV7I1Kkp725X9zWKlhbwFoFLYbQYgQthlBDxwOT73+G/MXnkO8+wPyP/5Mw37yBuXiAoHztwzcQe+8ghjM0tkRjB2hsCc22xoUAkvPH95KD9vdIryAIWBpNz/xkbHvSZoQeSSSklV0MPmCjfX0iGgMAq0XI7tMSjYXvUMwyJlJOARKBIY/aZt4TF5K5/9tWRPfVwSbenZkyIdf+nL6R/Ou5SfR21RUZfq51fGxzUeGOZHbhz6DrUsKtFxSNxZxoDMBcljGK2nLxFDwVIY1ucs9aADBCOFElhI8Sus1Yz4OXBpCF26ABUQAoIPxSiJWFS3krC2A4BEYjYDgD3r4FAAz/wBcYfbmP4fUY/9KfFvjp7QiH91MM/rmvMPxqH4OrMcRbNxaiKIFy4F5VEV4pZbgxJbQZwJjSvxflI7XeC9aasFm46LpF4r/qN20MGuMygtXeG7a1opP9fNjqUWNhGgPTuPGF/Gt99nNIRO/aBmhFbenbROKxNGrrPmPZykKWCsnS6G167SHLmLEAXYuOkXwpRYhKA+gsf4L4Rgjxe+z/v2Wt/S32/58A/DP2/wMAfzzXkRDi1wB+H4C/t/WrxCcmFFvWvq6QbNG+6/jY8gfLyj61iWgMQMu7NvWsJQQ/QiYaU5L51MrYF9UpKZhozHNqJReKCfxA3oeMU5vzqR0VbvltT70JQo03ZRGEYureDyDyLoorplwo9oV7/TEKxe5lXig28JY0w+njfGpbQrHBLIgbROm9xMCEYmYahV4kFBtHoZgcKAxHXig2Kv2rCkIxOSyi0GygMCKf2qGnFxQynEsWbdEY4AQZJNRIRWOAo0pw71ouGiNkfWwJHUKytPwaUQweJxSTQmxdKLZOeyoqW+X4RT62qRBsUx9bPr5x79p5oVjbuzZtT71ruWjM9dn2ruU+tVw05up0y7v2V4lQTMkoFCtEHXy0lfBjhphGoVg1xfv37m8OMyf4srOH6FN7K4JPrRVuTGhuxkEQVl/N8OvPHP91+NU+3n/jJr7qO+9j+yPzqf08jnt16caUh/qbcP1T/Xm4B2+8/d9d1QQh712lw1g+9JzZAROKyYcZvvRjodjz4999FIqJchYEoSQUM5iGMQlAKKtBMSdkLQdRvKoKFcYfEoql4jE6Fxe6kpCMe9ouE5IRuJAMwFrt6b4vjWdOvnBhrf2jW+rrNwD8HRsylWwXn5RQbFn7JkKyrn3X8bFNI7WpUCyNCHLvWi4a4961Oc9awtXJUUs0pliZBgd6EF2cRHGYE425cimZUIx8ao8PMVzmU1u4h8IoCMWOsV9eAXBCDPXghGKWhGInH2AvvOji4gHi3Y27PkPisgs8yLxQ7JpEX7PH+dS2hGLjKBSbTkggEYUS2os+Zg+XqDJCMekj1dUsisaobja5gtS+PL6ErFXoS9Q0qXXvb3p/AanmRWPcpzYnGqPvDfeu5aIxwpyPLaFDSJYrvzY01eOEYnS/tikUW6c9JypbdvwyH9ucaG1dH9s0Gsy9a9s+t+6Ve9e2hGJcSAYqH7YmtVRH9l5Hh4fB8YCLxkgwdnRwnBWNkV/t4cEJlJ/oHhycxoyIfnJ6cHAOVFS+ACo3VtnKC8GOroF777l98gH2wom/GiYIa+7d+HB4P8XgytdfjaHObv0b3w99iTsVzlWX7londR2uf2buwz2482PGgxeKnR0d4qF27/vi+Aj3XjRL4+D16THu/Jj14fwEd14oS2Pe/dVp8KZtCcWYTy1hencB5b1puZC1KaN4VXpHl/GH8/CjOycec0KxOKkNdczTdpmQjNASkmH9dl7u0cIhAB5l+6Wvy+E3APz5p7qQ9egHCSG7y7/ttVpNPJWn7UuAi8bC8mDHL7vWkrxfy1vmVxuX8gFJK+kWISUwX8bXEmisddQM45bMGjFEbUdo7BAz/QZT/Q4z/YD9N24gFd9LiB+/hrCXwNffQfz4FcTRFcTIRzfKL1GXX6MuNar6LWbmM1TmHrUGKg3UOi4la2v9+S20tmi0f/XtWxU5sZy5khwLhoXbRAE9a2CEhql1mJTagWTir+6Uuf4EC0+fS50LsO9A8MS1ACIVwaCdnAHo8Drma8joKH+iTP0uastz0RNaQqtVxVUtX1LMUQbS/jcRj22SRjdQmti5iC5FlClORQDQ9q5lqXHT9LmAp38FekIqGgOMLcImYf2SvorL4EL6c0n3d6yU8zYsB/4EBihHQDkE9veBN2+B/Tqkvi2KAsV371Cc3aH4+UvsffsWo/N7iLdvoL77zE1ov3L7iuEbiNE7iGHl+vP9auN+zGuU0BhAo2xTsYy71sZ6gZglkZjbSCjWWF9nbcuzPHxWyTJ+mg6b+3jrmYaZaZjKAGigK7eJgVuVaoyjGzTGoDQijj/0ITci62MriGNSIPjkShnHTXpucSEZAOjGedrSuKa1DT63QszPXdpCM7FwnvOSEGLn5lm/C+APCiF+H9xk9jcA/Nl0JyHEHwLwJYC//1QXsh79oFyNfvCY1LQvST/gZf6FeY30AwAtKgIdk6MfpJ61QDt1bo5+UIiYJrdgVIRhQZFcGZY690oVlh1HfqI1Km7D8p/zrHVLfW9UJk1uPcH7X7klebHnaAj14NvgHXlb/xj6up19FqkOPipbTptw/eW4Du+79BGIwaQKS25q3DyOfmCrQBlQxqfRrWbBm1bbppUyF/BpcveJclB0psx17Woh/UAI0UqdS/SDYHkjRMu7dlEaXQDzPrasrrP8Sie1j6UfLNv3OekJ/Hm3yfHLPG038bF9zjS6qkU5aKfPdX02Cf3g53Cc2y9613LPWunpB6WcBsqU1NOWZy3g/GppzGp51r7xP2T3gPc/fO7qJmVMjfvuHd7/+IWr/9a9cm9avP0qnGtiXJ9j/VV4L5Pm83BfyMpwv9KBHnZXxbFw6FeiynEVnlvFQxwLpR8fBfOpFUWkH1CaXCuiT60um5jaexjHqmLoxzo2JpUlpx/Elaacjy09l1QZ6QcpFcHVIdAPgFiWTOSyiJ4AIJuGl9f3mIe1thFC/AUAfxeOgP43rbX/QAjxlwH8nrX2t/2uvwHgb9kntMlZj35Qr0Y/oAfga6Mf8HIaqX1t9AMCpyLw1LnLPGvJr7aLfkB156zu/Pgw+NfScvfp0SFGfsA6OTyEp4ZiqNwy3NHBEYYqetbuqxu3A0+T2/A0uW4grUv3N3FwcIZ7L0I4OjjCfXUXznXrc5t/8PSDi+Mj3E3qcA+IdjDxrx/OT/AwiT61m9EP3L6zh0s0vr2Zuddqdg3tlwJ5ylypvB/t5AqyifSDXMpcSpfbRT+g7xJPnTu5jfQCiqBx79quNLqElo8t1S2iH7zSSe1j6QfL9n1OekIaxFn3+GWetpv42D5rGl0/OT06PMymz82lzj06OA7Hce9a7lkrwqSWKAdnkJpREbxnLVkTHhxdtT1rfUYxyix2cHYHTP3x5/cQPmHMwdkt4McC7k2LNzqca+qFsBM9De9lqu/Cfbn36XHJj/bs+BAPVRwLyYeWxsHrs+NARXBjoR/3fJKaFv3gJnp2T+/Z+OfH2un9JWQVx6di5sc6NiY1/rkw+XAe0uRyyhOnItB3RxWRfpCjIhAN4f46+mXfX5/NPUO76Amx/XQpFeGlsWORWlhrfwfA7yR1fyn5/7/x1NfxJO4HqeIwF7bPte/Sh2STJYl1KQnrOiEAmJvc8vMD7S9xjiqxjncsd0JQmQvkS/KG9d3wdINhudPOt8MvcRmL2hhU2qA2BsqPOkqMUOs9NGYEAYuZ/gyVfghpKovRHmZ732M2KiCFRfP5d2ju3oYlt2n9Ge7qX+Chtpjpd5g2n2Gm7zDVGpNGY6o1Kr+8VhuD2p9fG7/8FJbg43JbVPP77yapXvkSbbr8jvbym/OqdRsRlGUhIEsJqQX88699r5mLAcquD8wvDzNGQkiT6z1r3ecSOQfkgkBOCO5i0PKuXZRGN6Ui8O/Owu/YJysQXoxl9ARefixVYRvuCNumIqyTRjelIgDd1x/eKqcZ+NS4qRMCURWsiKlzHY2ggIFC/DOx0e8VCtoW0Fah8I9MbS20HUDbAURhYYsBbDGAIKrFABDDfYjB2HU5egsMqzDrEvv7ED98ASFuAGtcee8GKAbAj18C2AM81Qqjt8DeZ8Bohhr7qPEGNR5QGydKa+wQjXFUrkYDtbbhFQAabVFr42hX1lPCbHR40X65XTemTTMIlJRIZVsKGk+IRqUpva5PkKFVGJO0NH4sNghskULFcxta/kdIg6sbA127a7Xeh1Y3OnJumTuCECJkKqb3KiQW0hPc+7U+HW+kKgBolXvsLp6EfrBp+7bT2G67fVNaxVOn0c3SExInBNovl0a3UGKOfiAlsvQDaufuB4WMVIRSzdMPUicEABiqKroUqIewfDaQ9/74caAXSGFCufED+UR/wZbcvgh97c90pD34qMFgVof3MhzX4b4MfCSinNSMfhDdDygqK4d1XPIqq7A8JnwkVogqLL81iPQDaV271pF+IOpqjn4g94pAP1B7ZZ5+4EnOYlhg7zPffylaVAQArTSVUoqWE0Ks88t7CRXBtefT6HJ0uSPk9n1NeGr6wTrtfFL7Uu4InIpA6Eqpu6hdZo5flkYXaFMR6PpXTaOrRJ11QiDOrBR1SJ0rhG1REdzxVSt1bnRC8Kmzk9S5Ic23dzxBM2ulzg1UhMqn0a2rSEmwJpbLIUuv6x1f9j4P7gq1+jycd9I4R4WJ/oKlxh2Ee7Tn6Qf3VXR/eah1aywEHOWAnlV8LCT6gRzM4jJ+WS2kHzSqjvQDRpVSfomuKIssPYpEYUWh8vQDRp+i80slVnZHIKxDT1hUfmkI0afJ7cKT0A82bc/RFp7qXJu059wRVqEXPHUa3TSCzFPndtEPwr4sNS6nH5ALAq+7OI7l0u/g6Afw5UPmjuAqz44Os04IQ+UG1OPDQ5TSKYWPDo5RSrdUV/i6g4NTSBGpBiFSq+MxU/0Q+rrzy2unR4dh+e3WL/lfnBwFesHV6THGftlt7Jfh+JLb7cUJZkRPGHuV8PUZpp5eML45x9TTCmae/5DSD2r/0DB+ebGaXqH2lAhOPxCI7gfKUsrchH5Ayj2vaJ7eX0CSE8LdRZzUsjSVtBTHnRC4O0KOitCVRjdFlzvCp+x+sMm+Xe1ppPal3BE4FaH7Wtt9pe4IacaxVdLotvf17ZxywMoEOsvx4WFwKUidEIiKIH27c0Tw7YyKIAPlIKbO5VSEXOrcg4PzOKnVPo0uS517cHQFeFcENP7445uwInRwfOMitfCuCSP/o3kUU/LWKtIepp7qMDUP4f1N60G4b5Qe9yGkxj3CuPH0AzYW3rPUuK2xkMbHe3I/OMPkYQn9wPc5u79sUaWUtxcjmsHk9hyqjGMRpdFVzBGBJpo8TTdPx03j0yruCIR16AnLyj12EzuVfKHL5HlX6AmbuiM8dRpdG5ZW2svFYSnT9xXM+JPlTa4qDsvURoQleaHaiRjce4qOAjAipF6kS+CG37WGW/7XhimZS0yaEtOmhFYlJs0XmOoHNNZNWpWpcN/8AmPPZ7itf8R9jWA4Xpshxs2XmOgHPNQGt5XBfW0wbTz9oNGYaXds3RhUjTMT19qpb7XfALc8Rxt9DnS/F+EplLA2UAIo0QLaTgbGep6EnUvEADBKAuLyXeqEsPj8bUeERc4m3B0BQKvc43Fo0T22SEmgjbDKMLYsUQPvL0dJWJacIewnxMLkDC1HBMQxiy7LIjoi8CQsCnWLiuCuuQybFHWgIoQ0uVbB+OQw7rzOCSGskhuEhAcN3ApSY4YoPH1ISAkM9oByBCFUSBSDYugvQEN89nXgy4rPv4a4L4CigPjsG4g74VwOADTiDRr1GRo1xUy/xVR/hpkeo7a+3QxQmyEaM8DMGEy1wcw4upX7TOJYnY6FAFqULONpCfS3DaDleNCmpWX+1hkvxTYWtjEuIYMkelQ7IQOl0ZUl0QE0Gk8pAJRzQtA2uBvIgp3fRCpBTN1ggjsCgJBmlya79FyjHArL6Ald5V3AM/vUvhq8UklHjx49evTo0aNHjx4ROxWpXYZdiuRuErXl4jH+/1wEd5tpdEOfjPDPo7bwv1R5X0HoYS1kEG3EsEiaOpdSL5JQDBCoNfz/XdSgMQbWOxVoZYOgS1uJSWMxbSyUcJEMIYa4rz7HQ+3UvFSme1dpjdtZg/vKRWXHdYNJ3WBcWzxUBuPatiO1tYtOVNpFKipt0ITvEUWMrPNQ9KkbY6Si/et/WwgRsIz4bG5fiiQs69NHWV0a3LZoDGCfuw93cdEY0I7251LqdolAX3oV5VPAU/jgptHbRaKyx3racvFYuO4OIRmP2hLiODQftY3XOO9jy6O2kVPbBPEYj9rC0wss836VVkLbgU+R6661AYIfrDISjRlBmyGMDwUrMUAj3qIRY6hhBTt8AzscByEZrAHefAHs1y48+PYr4I12qyOjL2CGFWrjki7UeoSJ/hxTPUFt9lGZt6jNfmivNDDTFpUGqsZg5qOxNL5V2oSN+3RrQ5688XtV+yhu3RjoxoZLpYgmT41NY0ArTa6Jm0hEY66vOD5ZqLCS1PhrKVhq3NZYQx8y97GV1q+6WTaWiiAkcylvfV/sm8Sjt+lqgdXICs0AtMovDYHdcz/YFeyUUOyxfT230GwdT9tF7cuEZI/1seUPu640uty/1rVH71ruWRssvxLv2lAmn1smJCsVQppGcj8YqOjZOVCSiU6iICAnGqGECbMmCsImjQ79P1QmnHfi+WP3kya8v+G0DvedrLwmMx3EYXJc4fPvXLkkIcUkCsWKYROEDLZ0nDal6o2EYmro/vzUXonhvmuXe8yndqBCylxBnNmhCkKMNGUuAAglondtIhpz7Wh513LRGND2rgUw52PL69rteVHZa8IuCcU2ad+mD+46orKXEJKt62ObptTt8rElLm0qHkt9bCXzrlVMSEY+tkromPpbzqKQjE1qg7etkKFsoMK+tXHuB5XZC6K1yrwN1zXTLp3upJHhXt3NmvC5jD2Xdq+O3rQPUx3GwrEXupaTeqM04dbze6Wssj7dopQt0ZjrS2XHJ+LXFiqfRjcIxfg4w1J2ryokA5D1ueXoEpqlorMeu4mdEoo9tq+XEJqt42nb1b5MSPZYH9u5NLkdaXS5fy33ri2YkCz4BWa8ay+Oo6ct964lIdnZ0WGY1JJLwunRYRCVnRwehuNzQpDjw4NWpJaOn/rJ69nRIca19ec9wtTvQ+KHq9MjjL0i+PrsGFNfnpGg7CIKxe4uTzHz5dk0CsWqie/z5hyTiffM9UKydYViIU0umE9tEIpdRaHY+BLCC+xEEIpdZlPmCsXEYxnRGE+dmxONce9aAvexJcz52C4Qlb0W7JJQbJP2bfrgriMqewkh2SY+tq2Uuh0+tmFSmxGPcR9bLiRTwdM2+tgqf56Dg7OQcvfg4LwdqfV19Md5cHAeMvsdHJzFSK13fDk8OAl1RwdHqPykd9rE8ZOnxKUf9SQUuzg+wsQ7wlydHGHik9OQX+26acInPiV49ZAXytIPcS4aI8FYOj6Rfy35m6dpdPmklc7PU3avKiQjpD63KbqEZrl9e+wWXhX9YBleip6wDU9boFtI9lgfW8qwOi8Oy1MRqC9ayuNCKj/OQAPB7xAmpl+kbIbG0rKXhbHArLGotIWUJF5AEHTVwuK+0hjXuuXUcFc1eKg1jLXYn9W4q5qw9FoZi/1K477WqBpOOXCUhpnWqHye86YxqBsdvBjplTwH+ZIb96yNz5+4pJaKo9y9nBe9bAxjAO0uwJq4fMaFYnFJT7Q8a4H2d4RTWMIHg7Z3bbq8x71rUypCvMQ2JcHV5f/2XhMsmCjJzpd3XZexTXrCOqIym/lbaPnQsj42EZJRX5ylw6kINH4KkReSZVPqooAOaXC1T4MrYbxRtBDGicP8I5J8bMlH21pGORAatRmhNkNI/4dqhUZt9vw+A8yaz1A1k+DEAAAz+wVmdgYYgan+HDM9RWNLjJuvMGkqT3cAajvCTL9DZe5Qm33M9FtU5g0qP5mdNhqT2o+lXiDmNneuRlvUjQ1+tXWjg28tgBYlYZlPt9E2iLeI0sT9aNupvUUUjdESfmPCJig9OCys9p+xZBQVLxgzjUZ48MgoSJUuLzJgIk1FyryQjL6EKSUhRyvrEpptbYzfBkRcVe3RxkdFP1jWvm16wrbPlabW3baP7aI0upyKAHSn0aWorRT5NLohzW4rjW4s0x9iIduUhDS9J19KNdaGsqZJrbYh9eOsiZSDqdbhWqaVG5jG0zrci+G0ifQDH6ktpzE1bjlt8Pl3zo9w5pfninEdlrHUONIPxMD7OLLlNy3qx9EPBjLQD+SwCPQDWr7jS3qiUC3PWgCt1LlCsjLzKubetaum0eXglIQcFeG1oixLfLeAfsCfIbtIP1jWvi49Id03pSQs6muTNLtpal1ORSDw1LqcnkTHc0rCqil1JXQs+6ira6cxLabUDZxcNPhVy8c2lt37i5QEARPLbFL7a+83a60I7Y0dhLLxTi+V2QueupV5E6515ie1D3UHFctHaB9m0Zt2xMZCWsFax6cbahaX/xWNfzFNuMas5a0dqAh+rOPe2ur/396/BtnWpGlh2JNr76o657v17fu+7p7unu6BGFkChEN2a5ADhyUhIIYQnpGFbMNASGMJtWUz1tgYEIQVYzxCNgIHYUyMsRo0IckyGkIoZA1yA7ZlC3wJoBsZg2ccSKMRw3zn1PXUuVftvddamf6x8s18M1fmuu1L7V31Pid2VFa+65J77TpZWW8+z/Mez938RD61QWlvNhfNUmV0IyoC9fHSuu9F9IKYktBFP+DtHFVBsH+4V/SDvvg26AljPG0JOXpCqrTuJn1s+8rocipCrowuLWrpF01cRtdxboMyurDtJ+66duc8oCRcPH0SZGqBZvuSMk+8vbJ/eV+cPsGq8pSDZe232pY2U0s0g+fnp24h++LiFAtLO6C+V1dnWNjtudfPzrGynFuiIbx9foHlwtIPXl5isbDlb9n2m7ZUhMn0g7pgbV8yt7C0A76lRw+We9YSt3bx+splUhevr9zPTsq7dkgZ3RickhBTEQ4VZVnigm2Nx+040blv9IO++BR6Am+nKAm5a00ps5sqrcupCLwv5WmboiQMKqlr6QWcnkBfnz55GpTUdT63ru80KKnrF7WMkmAXwk8+OQ8ytUDjw00+Y08+OUdls7NPPjkLMrU0FqIfnD554jK15D0bU7FurWr3xs5zz848/er63NOvxvh0k2ftzctL51m7uiG/2ito28e9tZdvnzl/be6tPTueu7ZLpjDvWj4XFWxRS/dPUREKR0m4CKgIhBQlIUc/4O0uqsJdQAGjdl4eEu4V/aAPqS3SbVIS1nFH6HNEANByR+jzsdWkdjcpn1pPRWgODh0ROBUBaH7B0ZYVZp6K4DxLlcLKboMZUNtA0TZUwSgJSmNRaedWQCBKgjaGtZtYqQ3eljVuy+YerjRuqbFYaSxLjaXNVHDHg9T2W1MyWLvPi6tv3XONtua09ttvO4GT3aZd+Jy6mJXcVelDOxGUN2VUBELOHQFA0L6P4DuPKXpC3O47FtgtpSFFT1iHkjDGKQFAi5JQs2s1B2TcEdgxU90RaP6iSykU0GYGbQoYFIGnLQDrijBvaAkoUGtbEtdOYAbKuSMoM0dlHqE2J24hWkM3NIH6NZTSWOn3sNKvg2e0rN/Hqn4DYwrrPfsWNY6w1B9gpd84T+5Kn9hj30NZNxnaVVU4zcCK6Fa2NPiyamhfq5RPN6NflVXbp7vxqdXQxqCycSpFW1d1OP/Zhx+U7mbe2lChE4I7lkrnlrV7qSNbftj61talAY78zwDsYt2V0bUfbEBFsD8PvLSujn4GY0oCd0pwP2OBW0PTrrV/BoL9xoNa1AoEAoFAIBAcNqRMbg4PflGb890kbOIHZ4qQLPa0BcYJyfp8bHnWFmAZ3ET1sT4fW9Q+a0vbPwYse2uzBqtau8xQbVRT+aY2AAxuqtptlxGoTxsfJ05tXRvcrmosyhplpXGzrLFYNhnYxarCsmwq0wBAVdYoyxpVWUeiCMpUMG/a2mYk6tpnIoz/iz/OTrY+C5bpHQxDIgsTZLjCazEFHqW4tLGph3S6jHtCIqiow7IsTDQGhD/vQdYW/mcolckYI4wUeBgzLdO7qQxvnL1Nzgk9N+M/6mOyty0hWJS9dW22Zc+zt10VyWBgq2jZHSZtUGv/3OLsrTaqebYkFDNNpa5aN9nZyhyjNkco7PaMVrOmipg5gYLxbeXnhdK8gxKPoUyNlX7saATN8GZY6vewMu9CmxmW+gMszWtoM3dCsNoqfEsNLGpgWTdZWbcrZTOxTXa22fVa1raiGBeCaV8xrLS7VmWtvU+t1rbKl0ZVGfdyP3Nsp4rPfwbsh9JVOWTZ2YKLxqzALhK3usy7tuWJmXdt2qc2FI+14jWCKmTe09Z+7lH2ltokGlZKHUxFMUEaD0ooNiUeC77uUrQ2VUjW52Mb9DtLreE+tlw0Rmsn3qcUWkKyQnlxGYCgHfdpY1ybyhlWtXHXX1Xaja+savdeSks/WKxqfNY+y8WqdqIIsvKaL0rnTbtaVPjgIysUs/zZ2e3Kiw+OSyeImlH8KO3TSPXn+4RixcncxYuTAo/eIXEY86w9IcuuWdIH0vnYcqEY86wl/qtSKvCu5aIx3+cFX7GPLQAn3uDtnKjskNAnFOO4a6HYENHaunEuMBt7rW373MaiMroO97ZNicr8/IOkDzYNJfa25aKyps8kfW75otbHayf0IhjMXFybuWvXZu7uVevmP+VKG/deuD830bVuSy+Uvam8UJY0BbfLyomCj2+ZT7e19DpecJ/usiWULY5WXlx1tPL/z+fWxxZLNw9VZuXFrUfKi8YsfzYWt8Y+27F3bZeQNeVjC2CwkAxA0Kbrc3FZrn3nUP53rSDEgxKKTYmnxGWbuNcuhWR9PrYE7mk7xseW4s/Onrb8Aq/Onrr8MReS0der06fu/rzN+yhzdHX6NMjU0j2JG3Z99hSlneivz09dppYWry8uTt1E//LyDKsyFIq9fnaO0rbfXJ9jtWyOXS7Im/ECS+vdePvyEisrKisXaZ/Gyh7bKxQzMxdXmgnFKi8UI8/aQHzhhGLes5b8ahevrwLPWreotZ8G967lojHuXUvgog3X1/KxzYvKDgV9QrEYmzh2anyoaG3dOBeYjbnWtn1uU6KylLdtLCrzQtTma+yD7Re11OfFY1xURtnj2OeWL2pdH/ncPvHzm8HM9Wkzc9fS1qf69MmTIFNL4+f+3JSpXdj57/LUi8OuTp9iZdskiL0+P8WNnasaoaz1oV1yn24/F5JQlgRhb19cOM/a25eXWNhjyzckFHuG2orGljfPnChs+fYZ1MouNRLi1sXrK7+oTXjX5oSsKR9bwhAhmTuWtVPislxbsJ948PSDPnTRE9bxv+VUAMIYSsKY0rp8y8SNGQju3/K0hXLisdr47StaYBZKuW18U9gtLrvFBzSZDBInFEo5n8SCqT6WVe0mad6O41o3WYdVpVmmVmOxqrEs62ZbjcRflaUaVLVbzDZbbiQOa8ZEX5v3zl/+867teHhpyPAz9J+l82ncEuhezq82E+dbeqgxWDSWKqMbUxEAtBa3/v4TaBeCyRgiWovjUykLXFg2lJ7g2DGJscT0hCk+t7GoDECLkpAUlRm6T0hJcGO18UJ5SgIXlVFxhBw9gQ0HpX6ESjdlv1f6XZT6He9zC2BZv4tV/RjGAKv6BGV9jFp7IVhp/1OXtXE+tJVuqAXkAd7cxzghbqUbakGl/fxWljVWloJV19q9Kusaw326+f9jVyY3oF/xF6l+w3K4/qWcaIyEYiFVwYvGjH0vbv6CgS4V6tJAlwCO6IMJxWNERTCUbCmKbiGZRkBJiOf1HD0hbt81xP0gD6EfbGCs65bJJXRRHeK+mIrg4qy0buxjCwygHwzwtKXjOCXhoy+F9+qjJwBwfXE77tPat2lRWzLKQa11QDmgZ0AZilXFKQfabbXRone5qt2W22pROvrB3NrbzBeV26ZaLSq35aWOrH3PPO1Tu0n6gctkHKfpB/Rg+ZaeUqxk7tHM9aXoB4RcGV0C3/4D0lSEQ8Uh0Q+mxMdQAsbcaxv0hE373A4tueuvlfa5JeToCRy8j9p+UavcNY1hZcC1ce1Se84sPZdSa+dDu7SLTu7NfVt6T1ry6b5l3rS3y8pRsY7Jp5b5dC8Y/Wp2YqujMfqVmq/8//N5Ey+xcvPQzKyCOavbZ7td5rs4mgXe2nEZ3bi0N6c/NfEiWbo7RU/gZXYJXfSE+FjBfkLoBxsYa5ypnXqtFCUhR09IURF4PEVFcHFGSZjqaZuiJDw789trffQEAj+Ht3kf/SX97OxpkKltxuT7OOXg+cVpkKkFiHLQtF9dnbk49TX0g2Yh+ub63JXHJZrBzYtLR0+4fXmJ5S3RD5hPI/Op3ST9wE36ZZp+QKkvvqVHf4AsXl/5RW2GfkDIldEl8O0/Qq59aDgk+sGUOP2f3HTJ323QE7bhczuk5K6Ls75UPEdPiMH7Tp88CTK1dE1K/p0++cTtdJ09eRJkaul9V3YyvHj6xGVqiVt7dfrU+dQ+O3uK5art002UgxcXp65kLvfpXjKfbqIacPrV4i2nHzTt6o097s0zVAH9wJf5pnkrRZniZb5pnuLe2pyKkCrtzelP3Ds75WlLiMvsEvroCTdCP9h7CP1gA0hu72+AktDllNDnjhB72gJ5d4Rg3HR9GFR2m0oVquWOEFMSaEufwOkJNRgVgb2XsmrKN8ZtGs9ipbFcNe4HnGoAAHWlsVxVWK1qVDxeNR61q1KjsseuSuNeQUlc2qas7RZW3bgjUAldt5Wu/SvYXuN7jRPQt1Vv3P3Cc7j3I2370W9hToVQ7AfCbRUWvjQld0JI0RNSDhrcEQFgavQMLUGwP4idFggp+sKYnc2t0BNo/ooG6ygFUC2fWw3TbMEbY+kD9ufUeq/WRvv5C3YOMw1Vi5wS+LMiegLQLCyrOnwulVZodvgLlPUMZR3+J+J91DZsSlnWBqsaqA35bDfzKbkb0PzVUA4aKlalETgdAM2idml9vmkeLSvj/pjnjgeVbub1SoefE3nTBu4vFK/8lj3//0+UAW5bweeskIrQHMvnrFSZ79ixpVVGNyrtzT216cmSO4NGSEVwR3BKguOlUCxPT0hR0O4SYjiThujnBAKBQCAQCAQHD8nUbgmp6mW8f0wmN+Vzy9uUyY2zt+1Mbpi9TbV18FdrW1RWkycuy97CNLzWmo3TKLhMLuDb/JiV9ZjlbZ71IfEXz8rSeKvaeL/FWjsf2kp70VhZtn0YefUwEkpUtspOVWnrjwjnkwjYbID2GYpYoMKr6QQY+mc9U6qZWnlxFxOFuUxHRijmUla8Mg7zBVU9mdQgG2y9a/m96Fnkfm5Tz+UQ4f4/wCTb/Lixx/Z9BvuETWZ1+zK5BJ7RXTeTW7tMayM6c9bO7LNxWV34TC6hRsNfLW12l7K6oRDM7wbxNtDcZ1nXWGnKpjZtOsQY44SwlTZNRUU7/5EQzGdqvQ9tqQ0Wdd1kZxMVw8pKu7mUqFhcHFbaXayyZBXFmDdtXdsduNq46lnB/Md+rzlBHs/Gag3Udi7ThY/ZsapCJX226dHrSrtXMWeZW/jJiHtrx5nYsAqiz9o6AXNGSBb8jOUyuVFW9y4hQrE8RCh2R2Od4lObiw8VqnX53HKBGSEnKkv1teIZoRlHKs4nGLpmVXkhGE2kZW3c+6tr7cQPVa3xWSsKI65sWXlx2KqqvSet5ZxxcVi50nj/w+Zn/Mha2qyWtRMXzJalEyo4n9qidN6LesaEYrrh0tamTArFSDwxO5n5+PHMC8VOhgvFHKeMiS/UrO0DqYoiKcQgxN61LaFYxsc2bh8iuFCMxDhxO9U39FgFtddCsqnHbsozt1BqY0Iz3p4iOuPxlCcuj8dtoJnHUnFKMhjjxV+V9u3aGPfz4hbMtXE+tCutvQ8tJQQq7US5y1Xt5tIlWXYxn+7jReVEsySkPVpUgTft+x9aoazl1M5uKjf/qeMVE5I2/NnAm1sv3ZyljmbD5y+an6I5ywldrZVhbn5K+dimvLNzQjKOpM8t6xfsN0QodkdjTfnfTr1+zLmd6nPLBWauLyMqy/ncEnJCsxhxPP6r+fr8FLWdvJ+fnwaZWqB5/7X9M/zFxan7RfDi8sxlaonr++rqzGUnXl+d+0UvE4dVZXP+2+cXWNn+0i5+b15eYmWFXrevLlFaH9vSTv6LN1cwCy4UayZ9TYvjSChGArGZFY+sFtdAbYVgt9co6ua/5/Lm2gnAuFCMfhEsmVCMiy/oM+I+kCSkiIUYhJR3bSAUy/jYptqHhm0Lxeh576uQbOqxm/LMLRLisE364I4RnRFynrguHonSCJQR5tc8e/okyNTS/WnOOn/6xM1/F6yfvl6ePkFp21enT4NMLdCIw2hOuz4/xaq0cxHz6SZx2MvLMyypOA0Th5E37ZvrCyxvSShmhbIvL7GworHbV5dYWdFY6M1thWK311AlE4r1CF1p3krNWYvXV86/Njc/pXxsU97ZOSFZjJbPLfW/2J/5TTK1aYxa1JL4CEj7AQbHToxv8lpd8djwe9fYNj1hiLgs5XnLt06JkuDLLGq/6NUGVaXdgpPaNG4uNAMQtGmc5J0IwLX5/clvllMN6HnV2qC022y1Zj60lXHba/QLgovDeElcY31ojaGfi3DL3gkltEm+kqVys1yECWBbeaDtN359zbbynFDMv7j4y4k6kBZipLbGaZuPUxG25dv8EGDYv1R/3N5mfJNUCD7dpugJHF30ha6Svf58OqZZ7FXaJGkLQduYFvWpUGmqAgf11WjKfJfR/3feF8e1aay4yroZL9EL6O0YhDQDamvjhWCe2mBcSfFSc1EYox9YOgH3pHV/tDOfbm2fBVEJgFAoy0vixv+vtTbBnOB+72TmvFg0RveilypUIBpzT4Z519JLo11Gt7mepyLYAwLxWNs7O6QkVNbrVjFbHvd+YdzviqJQSaqCYP8walE7Z/SDz7Kt7c8mtsmnxjd5ra44X9TuI1ViXXrCmPP7PG95O0VP4O1USd64DTQTRyrO/yChe3KqgVvUcsqB1m5LraqMa9MvqeXKl4EsGf2gIsuvsnZbbuVK431bDnG+IJ/a2pfGZfSD0mZlq3nt6QfF0pWGnBmbyZhKP5gXfvuOPG156cmoZG5zQJEsQ0mfW1w6l1MRmtNDSkJcRrfp66YfHOqidtv0g32K80XtXXvurktfGOKT26Y6bPe9auP7NKMauHUgQpoBtWsNRzUg+66V9mXCy1oH5cGBhmb1EaMcfBj5dC/LKunTTfZeRzeefnW0qDz94MTSD269N3dxVDKfa0uvQjjn0ZyFWdGmH0Slcz39wGdiU/QDcnLhZXT7ynzHntrN9UNKgqciFK2+MJ6mKtwZlLgf5DBqUVvdI/pBnKndt7GuS08YU4a3z/OWt1P0BN5OleRNtWlxGsfjLNPzi9OAasAztUBDM6i196El8dfLyzP3VzVtv726OnNUhNfPzlGXtKht+t5cX6CybU4/oHK5Mf2gstt2ld2eW7y5gqHtt8CndiL9gOgFt9cobH9QejJRMpdmurgMJV/Uur4EFSHlXcu3+nhfrn2oi9r77lPL2/H/40Mu+TvUJzekOky719A4LV45peD86ZMgUwuENIMLRk+4PH0SZGqBhnJA2eArVh7clQk/f4qVneuen586esGq8pSDlE/3cuHpV+RT++Z5mn5AfbevLrGynrT6bXvOW95eO9PXgD6VKJ27fOPnL5p/uHctL/nNy+j2lflOeWqnKAkNVSE0guKUhD6qgmC/8GDdD1KlGeN2V3zb9IU+egJvpxYRqTK8dE7snlAXquWUAOScFJqOGW3fRe4JfAuPKAu8ze9R6UZ9zNt8bOQ3a4xx6l26fK2bUpC11oF6l2+vuTK4xvsw1pV/Bc/RbrnVdjuqrmpnXmC037IahbjSRAy3JQe7zWYzDgmVrf8cMz93FOfuB9pv5alUXWV+ffpjIuNdS2V0/XjzTgzxz6xg/xDQjCY4OfTFx9Ab1qUv1LZDkTdtgr4QUxk4fQEI24ShccOoBvw5lHaO0oa3/f2JZqBNc25zPbgSuPS+Slv6trSlb7nTAdBQv8qqbrbKjXFzqStUw+bHmIoFRPQq6y2ua+5u4Oc/coXJMawCx5XICaG5li+di0rDlBqm0u6nxcyLwLuWl/wGEJTR5XOV+1wjR4RWKeWIksCdEtw12Fyf9LzdAygAM+HUJiE+tQKBQCAQCASCg8eDzdSui1hMFPfH7a74ulnfVEWzuB3HiyijNzSrS6hAVXZsNoG1CV3xxie2EZcZY5zPrIsbBBXLqApOXRt2fjo76yqGJTIVMPavcKP9tVh2gmdtU56EgVCCV9SxfotJFIV7FUczFMczFGYGbd+vmls/R2OgKFsdCdZcJkPDZzqU8dXF6PPkY4k8awEALivcZCdINBZvv9G9uiqO8WfBv8966QoeDO5CFEdZW8rI5tqEKfHAR9tmX5t443PrMrFosrcrbQADlDVQaW9ZyDOyBgYrrRvfXE1tf20nlHU+tDbTSpxaWzFsVWtUViRWlbXbJYvFYeTTXVuqFvem1Vr7V2Wfq/bzjAHLlCaglHKvwHOWPiMrDmvmrEj02gw28K6lnSa6QK7imDsfoXis9Tswyt62K5LlM7mTduu2iANleW0dD1Yotk9j3YRobWw8FpLt2v9Xay/+Msa0npXWvk8b47xnK7ao5YIwLwTzQgia1Fcr7XwYdVV7T1ri1DJxWLms8J5tE792tfJCidmiduKE0nLR6qPKCR70vPSiicKanzOhWG1KnDxq2lpZn9uTuYsXQbvworFjKxSbF3j0nvWBnBctoZgqVOD9yD1rgeZnjYsvuGiM4imhGP8jKBXn7UNd1D4kodiQ+D6NZd34pq7FF7XpONzXL1rBlzFe/OUXtd57VsMLwSodisKAZs4jH1ouCisr4sxqN5eWpfekJS5tLA4joeyx5cqulqUThy0XlRfKnjSr2tmi9N6vt5WbM2ZFM//F4lgSh+lKB6JXwHpv2/krFr0Cbe/aeP4KxGM9QtcxPtucl83FZV2et4L9xIMViu3TWDclWhsTTwnRdvnc6K/nFxenLosYxO0vhxdM8PXi8izI1AKhIIz70L66OnPHkDji9bNzZ+P15vrc+9gycVhpFcFvX1ygtp61pfV7vH15iZUVUjRCsaa/XpJQ7BnMknk2LmymhAnFanvOavncZWpnau76SDy2WlxDaSYUq0go5r0flRVScM9aLxR7lvSspZ81Lr7gorGUdy0XZRC6hGKHuqh9SEKxofF9Gsu68U1cK87mtuNNm/J5F6dPSIaAy9MnQaa26Xvqsp5Xp08db7dp+0Ut0PjQclEYz9QCVlRbek9aWhSnxGGvr7wojOa8N9cXWNn56e3zC6xu/aIXaOY/Omfx+sr5c6fEscvba2g7Pi56JcFr413bFr2mvGv5/MW9a/uErmN8touIA94WkrUFZoL9hNAP9gDritYIY2gMXX6j8TFT4lzcBSBoA3l6AT+fhGBaNxN7HVAY8pQDVwbX3o9vn/GSuH7sfsvN2C1G+hqfz7fkB0OpZlK0X+k1Br33o2cX0Er8K0UfCK9vb5DxrqX7910HCEVlAo/YhzXuj9t3Hd+nsezqvfApLiUU4/8NKw1UBkl6gTZNprWqm2tyqgFdj2gG2hgbt6KyuqEeOOoWoxzUdn6jrwBQ2/msrpo5lObSVenPT/l003/qUCirUZfNtdx7gXHb9MH2fx+0f6VK6gaiMdXEFW33U9wN057PvGsReW439wzFY5we5d5L6vcWm9dy9IS25+3dQUFJ8YUMhH5wj8aq1HRKwabpBTGlYCi9wMWNpxdoDe9DW/sFfY5y4HxoK5r0DSuDW7k2FY4oy9rTD1Y13vuspR/YSmLlqnLbUAWjH9Q2w9FHP9Cqwsk7ln4ATkWw23sD6Afk4zg7nqXpB5SJZdt3sWctkKcfEMaU0QXyVIRDxLbpB9qYvdqS74vv01jWjQ+nF4yJ5+kF2jB6AY+zRS3RDLTx7Vob50NLcx2nHNTalwwn+tSyZPSDqnZz6YLKgJfep3vJ6AcVK5PLvWmJfkW7Utybu5iXbn6o5nZ+y9EPZtrNe8rOP8VxWPqbz2XNcUXgXUvzF/0xHXvXdtGn4rmqOaffWztHT4g9bwX7CaEf3KOxUqZ2H95LilIwhF4Qn//y8sxZa728PAsytUCecvD66txlakkQ8frZOaqSttrOHZWBtuzePr9w7ZsXF65kbrXi9IPmmotXV6jLofQDtiXH6Ae0KB5CP6DtuVmVoR/QpMy271KetTn6AWFMGV2ClMkddiwvgTr0Wncd36exrBsfRi/oicfnZ+gF2vU9Ddo8Uws0NAM6h7efnT0NMrVAQzkgm67r81NUxKm19AJOOXhxeYYl/VFeeZ/uVelL4pJPd8qb9u2LC1cenHtzryy9YPH6yvlzZ+kHK08/UJVd1FacftCey4LS324u8/SnlHdtjj6VmqtSlISUt3aOnrBP9APJ1KbRu6hVSn0DwDcA4L3PfLj1AQmmI3Zk2FV5Yk4l4GjKCqKXXgDAb/lrf653N2iyFpVV5wK2TG6GckDba7SY1bX1na3roCSupqwv2xLTmrakPG+Xb7/F738T4Pcfc2ygHkY3kdVdu2CfJXNCSPnYcqUz/bKI6Rdd7giHAD6/ffajj9fehu87VtAG/7G3O8+t9rpxaifpA1EbAGCsxartozb/HGuicJmm+lelPX3BwHrF2vmR2sSTNfb82jS0qrJq5rdmXqPv/VxHlIOqqoPy4S5u51+iaNVsruTzYzOvNS/ayYq9af1cHG7RN2Vy2fa/pvmTObJwGObkQg4pM5rDEnMZgKD0tzZwTgg0/0TetZyKAKDliJCiiqVcWlIOQnyhm/sdINg/9P4qMsZ80xjzdWPM1x+/9/4uxiQQCAQ7AZ/f3vvgg7sejkAgEPRC2TK5u3odEkQotgEEmQb21zpv73t87LXi7GucjerLxDbXpFeYlbVXCL0V60bIRdngIPtgDPvqrxsIIfiL/GhZJiPwpiVxg26f3+fTuDbYGzC1YpnUoed7ocWU2YgLQbh3Lb3fXKWoSQI6wZ3DJcQ6spup47cVT44xPj/R7oxHWVeCMU3M+bjybB3LvgLtTGzT11QAi7OyzfnGictqK/4qrRAVCL1njaFsbDOnkqDLVwQLs7Pk+U20hKC6oo1R1re5l9+9MnUNXdUwdc2cZJg3Ldupovkv9qMOHlKEYLeQT8bkbhBVGeOiMQCh9zafy+j6OvSujSuOAWkf29xOU+p95Xxu96mimCAPEYptYKz8B31fx9oXH3utWNzVJfQCEIi+2n1MFEbbd0wIprVhQjDacvOCMK0NE4eZwJO26dOBOIxEESS0qEsdeNO++9lGELCynNd5WTvBQLXSTpxAnFi9rNcSihXHM+ddOzuZubg6nnmfx5O2T23K5xEz1Sm0UDPlvR8j0Rgh5QNJyPnYxu1DxPzo+MH51Gqz/++FryNInBW3u+JcyMXBxV1xPO7joq9WH7joy5+fEn9ptqgl71ljwLxnQ1EY0MxTnyNxWG0CT1qgWXDT/LkqDT5j50riz8biMJoLjyzXnwtl54vKCWVXC/KpDb25nVBsZn1qZ5Wbk2ZYuTlLowrmMsDOX1Yopo5mgWgMaHtvP46FsJF3LZ/LXF+Hjy2ATiEZj+dEZfsC4dSmIUKxDYw1/uONC554e9/jY45NibtyQi8CF32Fff5YnqkFQvHXq6uzIFMLNIIwGsvrZ+dN1TCEnrTEHePisDdMFEYuCNyb9ubFpfOnJaHF7atLF1+8vvKLWiuImCoUc+Kw5XPMTDO5rxbXAHk63l6jqGlRa70dcz6PdvLPCS3ol8Pi9VVSNEaIfSAJOR/bVPvQUJWrB+dTS//f9vm9JMVZiXY2bt/jZeJYLu7ice3OecqOfdqa62OfWb6opb6a2mdPg0wt0AjCaIOrEYe1RWEkCHt+cerOe3FxGmRqgWb+JBuvl5dnvjhDQhz25tr71HKhLDke3Ly4ROnmqrY39+L1Fepb+qPezm83z1BZodny9hrGznt8LnPisNtrqNILxdyiNuG9vWSi15R3LZ/LUuIxLnol5IRkhJzP7SELYR8KDp5+oM1+bdkfCmLPzLGekFxQQHEunApoAMH3dLwXf9H3TSjc6tE69KENxmYpB7wMLt9eo3vF4jAninBxJo5g1x3xMFvbZBuH+2sgzUOg9xL432raAvRCC8B0bt/xxW2KipASjwl2D/6jto0t/7XHR/eK+1nf6LjxlAEgbLtDbF9MKYjnr5heQB61qeeaohcAYH2eakD3MAiFYE68ZeO8r9YGq7JuRK8mFIUBCCgH5PfdCMOap8PnP621o2r5bXP/4j7dtAXPvWlD+pV9L2zLPlUefpDQlbb72fnJ2YOba3PRWKFa4Xgua95MKB5r+djSGDJCMi54zZUB3xccGtd1Vzh4+gH3O930WDY91n2K99EH4r6h9AIX18jQD/wilrbJAN92i2Sd9qE1bNGboxzQ9hrdq64Z5YCVxK0ZPYF70xL9gH6p9NEP6rn3qTWrajv0g54ykzQbx1t23LOWDhu6fQeg5QMZ9HVQEQ4Rh0Q/CLfkt3P/da7V0BqG0QOGxmMawRhKwabpBQCSPrNuUWsQ+M2m6AeOZlBrfGjb2piWDy2nHNS1bpXBrSo/F/O5kuK8TPhqUTLP7mY1d7Qok/Srma2EyL25q2Xp5ox6buc/Vbo5qS7KNP1gTmVwVVD6u0U/mCGgVMVlwLn3djyXAf1lwIH8/NVc/v7Sqx4KDp5+QJPMIWzZ71O8jz7Qd60cvYDAvWV5nC9q0+f7RSvQ9qF11++hHLy5PmeLWmP7LoKSuLSopUpn3Jv25uWli/fSD6xf4/LNMxhLWdg4/aCnzKRb1Ca27LhnLWUihmzfEfhWXtDXQ0U4NBwS/SBOiu2bTy0lvwbRA4bG7XvmNIExlIJN0gsIOZ9ZOuzq7Kmbf56dPQ0ytQBwfRZ6z1Kc+9ByygHNVdyTlua/xsfbz5U0b/Iy4aWlR725PndzHZXBjelX1M+9uSvrWbt4feXmvZooBzfPXBnwFv3A0qPIr5aX/g7oB3aa4ZSq5VtPpeLe26m5rK8MOOHQfbgVhFObw07pB8HWzogt/fuy5b8u1qUM5Po4AgrBBHqBjzO3ARNSDeyd7PXy7gaccuAytJTp4JQDtv3F70u/OOrKoCoNars95198e4571FqnA9p+Y9tQfEs+td2W9WzcEHJlJge7I2xyLJETxFZdIe4BaDt7LD3gLugDwf3jsSTaqXgnTDd9IG431x4+/zXPKXQjGEIv4DHe5z87f+/Kug4YeKqB32lCQC+gl/tDW3NvWet2YCkFLR9aRjngZXBpMeuoFsa0SuICCChZnIpV2wQAp19xpwTyZOX/z41mW/6p+Y/52BpHBQBUQcfGZby9Zy0Q0qcCH9tw8QCiVMVldHM+3PynMuWO4K8dUhJybcH+4kAt0wUCgUAgEAgEAo/RmVrJrm4GcdYh7o/b62BI9nWdTGzwfSITwrOyqfNTmQx7ln8O2ou4gEicYOxf3kYH1/VCMS9OCDKd9H6ZOILDZSr0Af2Vrk1LXDEE7llkqoyRZ2W8jXefYJDOiI7JnvYde5cYK94anHUlRNnXvkxsa3wDMrHBmE3i9w7LyKY+F56V003uMTreRNciIZjPyjbvg/tooyUEMybtPev+m0XZWffV/vetDdz8xbOzoeisuRbPzpLQTBvjKipycRjftaLsaOxNq20m08+1fHeKi7USc3EPeCZXKR141jbXyuw+8d8L9GH1zG+BqG2CENZdYy93opTQDzIYtaidzY/w6Y8aErmIrzYr1HLxNcRbuTifqHPirqFCLx/P+NCy//Nc/PVpJgqj87n3LPekBZrJJeVD67bvKuMED0Z7H9rYkxZo+GtcHOZEEVQmsjJMHKbx7meatrP0WmonEtB17YVi1upGr5hPLfNsrOebF4rF3o50L+U4aSrp89gnFCPkhBYuHnnX5tqHiKMDEopNiWszTpy1TSFXKt4n7uJ9KW/ZMJ6+Fy9zysVfsdArjHshmPs72DDxl0ZLCGZM2nvWW3ppJwira+18aGsDJwqj+amsajeXV7Wfd4mesCprJqqt3VxJQrByVQXisPc/JFGY5byu6sCblua/OQnVFpX3pp3XTqilrU9tPavcnFSrjFDsyHJq5yqY07hnretjc9qjyKd2jA83gLWEsF1twf5i1KK2rsqdCKb2VVy1yWulhFrbGivPwAJ5cdcQoZePm2Q8/mOdi78CoZf2fTVrxxVbYh9avqilPkqhvrk+T3rSavuVi8PePr9wogvdzO24eXHpeGg3Ly9RVU2gWjbnL15dQevm/EYoZjlp9pfH8s2zwLOxXm1eKJbydlzePHP+jjT5c3HFEKEYISe0cPGEd22ufWgoD0goNiU+Rby1LSFXqt0n7uJ92t3raSL+NBnnoi8CF39xoVcYN67NM7WAFX/ZB8uFYHSZ2HuWZ2oB4Pn5qbPmen5xCpIdPL84dX+UkyDsxeWZm9MaUVjTJiHrqysvFHv97NwtamnxysVhb59fuP6yJKGs96a9fXnprlst/ZxXWXHY4s2VE4LVfM5jc52xx64Wz6FqO/HMmFAs4VmbmtOWb5/5Re0IH27CVCFsX/suQWVyBW0cvE/tPiC1ZRW3U/F1EPvE8uvnKAXBcT30gvDYcDu/uXZu25VtEzEhWHx+TDloXz+kHDiqQkV7m2nKARdCeIJ/KA7zZXLb90ptvwXPnQsh+D5tzR4Gf8jrIEOLSMINhu3Z0ZYgH1csxLCiD5WYIYOtwhn5RDLvR/b9faYlHAqG0AvWgumnFyTHNWJ+9MeNoxc0wwsFX0Qv4G0/X3lvWT6WlM8spxq4cbD5M0WfItEWUQ68OMvuHmUoB7WjCXjRbCjk8i9e5tuVDOdzqZ0TgjmRbcm7+Y3NMwE9y/mz+nmgeejacjloDvCCr+BaRPcyBormQjXrnNMCcVjhuQ5ETxjjwx2IzhL0Kv7ekBKSQea3Q4TQDzYwVj7ZbYM+kIrHPrGELsoA7+ujF4THtu+lTbfPLIBkmVtCTDno8qHlbVrUcsqB1p6KwD1pKStR174MZFAS12VqTeBNG2+/1aVx9IN6VTGfWjvxLSu3TaZXtacfKCojqafRD+Yzd15x3EM/sGtZ7u0YbNUlykwC3T6PADrL6AbxREndQ8Oh0w/G0gv64puiF/D5cVv0AgCBnyyAZJsvatNxn2nllIKPvxzdi1EOas08Z7WfvzjlgHxoac7pohxwT1ogXwaX4itGOagqHZTEBWwZ3IRPN2VlY2/ad2j+I/oCK41bH1VBSXCg8eOmOSlHtSqOyHIwnNNi+oEq1FZ8uAn3aX4TTm0aQj/YwFjjbMMuxpLyiSXkKAO8r49eEB7bvhf9csj5zBLiMreEFOUg50PrSuI+Ow8ytUDoRxuUwb2+cMeSdU1DP2jOe/viokVP4N60fPtNN3M3Fq+uUNstu8XrK9R22w72l8fy7TNoqrfOtuKojO5o+sGMl8ntoR84ThnzduRbdYkyk4Scz6OLZ8roBvEELeHQcOj0gyn0gr74JugF8fy4LXoB95MlxG2+qE3HfaYWCEvbPjvzx3LKAc1lDRXBZ2qBkHJwfX4aZGqBPOXgxcWpu26uDC5lasn28PXVeUA/oJK4RC+IfbpLKh6T8Ka9fXnpzgtK4xIVgZUEJz/u5c11lmpV1MSJbc9pnH7g6FMb9uEmPOT57aFA6Ac96FLkbopKkMIQesFQhK4F3bviAQUgogQ090+OdrC7QSpur2Cvb1rxgCphdCIevWqiIlBWt1udG3vTxsfGithDBlcvqxE7arRdF0/+/rohLUGwGcSUgn2kF/hxbM+9IDyv+T/J6QXp6/v7cKpB11jpiKB0Npt/Uu4Gmn2leK19uVujTeB0AKCTcuD8axNlcPlcS4tZTp+qK/8KnGkc5cpTsbhojXvTamOfrfbPwrkI0NyYmUthyJGm/wcnvG7TF5Sp1Wg7IWgTUL3iscTetTEVISjTyzKdNL9RO+X+sm/zm3Bq0xD6QU88dik4FHoBb/P/h33uB3wRuw13g1Q8djqgr74PQRlciifpB5WnH/jiC97xQNemRT+oVt7xoK5qt/3G47T1pMv6oOkHY8pMAm3Fb049nDr20LCP9IOYUrDp0rO8byq9wI91e+4FrXhENSDkHA3iY3P0A1qLjXE34PQDX1zBuxtobQKnA6CbckC/gyq2qKX5l8+lS7tDVGsdOB74udBmaleMflB6KlZpz58v6sDxhUqCl0vK1IalcXlJcCCkH9TGz29aVZ30A14yl8roBnMaoyKk3F2mzG9A6IiQmrNy7i+HPr89FAj9oCeecik4BHoBb8d/XHa5H8SZ2U27G6TiBO50wCkHNH5eBpdTDpL0g+cXjlbAHQ/oWE4/oC25m5eXbtF8+/LS/VLhpXGJXnCo9IMxZSYJwfZdRj2cah8a9pF+kKIUbLT0LO+bSC9wY7X/d7dFL+DxFNWAkHM04Mfm6Ac8UwsMczegOeWal8GlvvNTt+vDnQ76KAcvLs+CTC1A86+fN2lRy6la5Hjw+tk5dB3RD55foCr9XEhtKoPLHV9uX10615dUaVxeEjykH9jSuotr6BVdP00/4CVzad5ylIObZwEVIenuMmF+I3BHhNSclXN/2Zf5Tcrk5vHg6Qdjtsw2iV3QC8Y4Guza3aC5EnvmOiyuwLf84jK48fgDda87B45zFtyTP/fEswm23+p2PN6KAyLFcIrqMGJLbgxCpfBmJrjc9pxgOxhCL9gY6Ecw+jEcSjOYOlfy/wppykHYjuOpggl95/OxxuNurmldAYBedwN+vsvkRtQDogy4RS/NTURDYE4HQJ5yEIyX5nE2Pl5ogRDQE5grDNcM1HVDQagrjbps7ktWhrHji5tX4d9LUBrXbv979xftiigEnxufD2vivPq50JfRtYUYABhdpOc00xMPfgB0M75EGd3YEcHN5RYxJSHtlCDYZzz4Ra1AIBAIBALBISEjb3jwuPeL2rvKxHLkytSOxRhv2fA8E7RT4q8u7n+fEIyDW9qk4v6eaR9aej9dZXCB0HsxFofFf33H3rTuq8uq+ExF8K7dWHiZSJa12CF4SV/yhEwJvaZmb+n95DIZlMHIZS9yArKHCv6TtLNMLEe4UTBK8AW0581h54SZ2Dgrm9/9oSGH4q84K5s7P+WDG2RX4bOy7l5sxyYlBOPXMgbuRTx7Y5DMrtL/oy4fWrq/84tlL14Gl4orZAWxLCvMd7Lau3ChOEyz+8bnN9lTEmhRdhQs48meoZuL+e5V9EtqDfTOZSxr7JCZ8/zYw/m7S0jGv+dt2cHab9x7oViX0CvVNya+yTK1Q+JjvGV5e4j46zORkAsYLgQDEIjCuuJ9PrR8UZsrg0tjIvGDrk0gDiMhBNEPYm9aKgmpXW10L5Soa90SSsSlcUloYEh9vKyTQjE9s5Y5qk6KJ8YIxdSRcn0poVhh41BFskxun5CC0FdmEsj4OCZK6h4aNikU479ndyX04m2+Fp3qLbtpoZg2Ped3+MzS+V3esnEfF3+1fGZNtxAMAD7+kj+fl7xt+rz3rDYmEIUB/aVvjTFeEFbrzjK4da1ZGVzN5trmWrE4zJfEZT61TBxG81/Fyuhyb1ry5KaKY7w0LhfF1jS/FenSuLWq3bzGy3z7+U11lgGPPWttZ1A6l4vGqI9719K4CfGc1yUky7VlUbvfuPdCsT6h1y7GOrRMbV98jLcsbw8Vf+Wv1RzQJ/TiorBc3J1vn0nsQ8sXtdTHPWn9LwXYPi/+4uKwRhRmF7UJb9qbF5ctIdnty0v3i4ILJVKlcRdvrmCoEERGKEZCCb2kcpGheGKMUIxEFU4IdnMdiCqoTenb5dtnSU/HnJCC0FdmkvcF8YSo4tCwSaFYnKfaidCLt6ME61Rv2XFCMeoLS9MOjff5zNL5OW/ZVB8Xf10xn9k+IRjh2Zn3meUlb6nv+vzUncNFYX0+tHT/FxenzmosVwaX5rFXV2duUf3qyovGUuKwN9fn3mc2IQ67eXHhitNUdh7i3rS3r7xnNy+Ny0WxVB7Xlcm9vXalc1eLa+cOs1o+R1HZRWvN57d2yVwuhE151gbzW0I0lvKuDec3tPpyQrJcex8WtU2Z3Lsfxz7i4OkH+0AvIMTir01SDYadM1X8FbwL37L7ln1CMP49P4ZvHQ71oXXb+pkyuMF7JcpBJA5zW21seywQh9mXozJktu/c2KMt9+CB2rHSK9jKS3z2fZ65GwXfnkuVwWXbimM8a1PIPqMDQ4omkKIM5OI7oxcQTEgvGEs1WEf8lRJ95Y7tQiz88tcPz82NNUkZQJtyAPjF5BAhGNEASKBFJW/je3NRmMvUGv/icecNqxvv2kqbYH4K559wbnVlc0E7TO25sq6t6IyV8Q7nN7A51z6LyJuW5lT3f1kbelBJMWzn/Ghfpmhiij/4mS/p3UevovcSl8519AT+GQe/5HQw/+XmvMCXvKN0eDBWwV7i4OkH26QX9MXjY7Uxa9ELeF9MNRhyvtbd949pBpsqcxsfCyDwngUw2IfWTZSZMrjulwbzo9UaeP9DWwaXlcSla1VVSDnwJXEpkxt60xL9gKy8eGlcXWm3DUVZV7OqXDnHeq59yUibAdGFZpSD0m3JadWcvzX6AdueU9YnMt6S41QEYDr9IG4fIo6OjvHxF4l+MI0SsCt6AcGY7XnLruMzGx7bE2dLz5TPLB/rUPpBTDmI6QUx5YBTDYC29ywveUvnpHxoaX6qtHGUA83arvQtoxzw3xuxJy3QphzQvLmymVDNKQesJK7LxJaVo1+tUvSDyJuWlwQHotK4jGrl6AfK0w/MrA7oVSePPgfA+8wWR4Wf345n3qd21j2/OcvBGYLSuY9ielXkXRuX0QXQSb9q4ukyu6lj7xKSqU3j4OkH26YXjBlrylt2k2Vs+86nCTUbN93nTy1zmzqW8PrqPGjzTC2Q8KHl2U+0fWg9Z832Pb9wf8W/fX4RlMR1W4H2F8nNiwtnY3Pz4tJtJaa8aW9fXbryuLw0rrbnLN5cwVDxBRtfvn3mttyWN56KQMetFtduq261fO7iW6Mf8O25OS1qc2Vy6fRp9INU+9BQlqth5WJ74juhFxDsf5dtectO9Znl7ThTG8fjTG3sMxuPdQj9gHo45YCXvE1RDjjVIOU9y0vepigHz89P/aLWxp9f+PiLC18ml1MO+O+NlCdtQDmgefPqHCtLFTAJygEvE07c2LfPL1z85sWl8+dOedPykuBBadwU/YCVxkXpqVZ03mr53NEOyK92tbgGaja/zbrnN7eotfMUL53L57qUdy2nIhBy9Kswvr8+tfsIpdT3A/ijAGYA/qQx5g8mjvlvAfj9aGau/48x5oc2PY6Doh9MUeRuCzmf2SkYU8bWH9ftLhAc23vIeHeDMWOJnQ6ac0LKAXc6iK8Ze9K2Rh8pVvm4/L3MoOcaqH8T26I5JfDeI9jHDbfkOLi7Q+yEAIhIYudYk17AMXX+bFMA8scFO78RfWCsuwG/55D3YuApBzkqGPd+TbkbuDmDzVlNzDqtGNpJCikH9KoS8ZpK5NbaM5bY+LjPLH8GfFerth6yvKStYfHgFZUJ532cfkXuBsH8ykqCe0qA8Vv6AdWq/TPgvWfbsfaHyF6zdnijPtz04Pmc1kO/ip1u7sL1Joem+MJdj8JDKTUD8BMAfh2ATwB8Wyn108aYn2XHfC+A3wfgVxtjniulPk5fbT2syaQTCAQCgUAgEDxgfB+AnzPG/LwxZgXgpwD8YHTMPwvgJ4wxzwHAGHOxjYHsVaY2l0m4r9nZdYVgncdmsh4e7ews3SNGLFQYMpacD+0UBJkSx7mlLC9a4rAuoVaQgaFMBRNKpO+fzgSDjaXxdaRXLLSY8GELHh6irOwmsE52dtdCsDCeF4HF74W+y1ZpjERhzbFhdtZVPgziPjsb+9Bms5up7Km9Bz3T9ph4dtZmdLWvGhbOpWwqsanSWBxG8yK5F8TetH7+owwkAm9a7sntPixWRYzmOv+A2Yt/LlxAVtBn0pNe5NXJGA/WZ0iVu79i2V3nsw0E3rUuw0xpzeYht3aq+PvZlHh2u1C75tR+qJT6Dvv+m8aYb7LvvwTgF9n3nwD4VdE1/i4AUEr9P9Hk5n+/MebPb3qgeyUUi0VfLn5HQrC4b9+FYMH1zTjv2VjoxftiURgdN8WH1p8fisO4Jy2d47wXax140tL5OXGY86St/LXSQrHaXZ+Lw5xQwvLf6lXlxWGlCTwbAQTetPW89kIxK6QIxBPMu3GXQrE+H0c+geeEEkBDPxCh2HaEYsaMF3r1xfu8Y3Pn34UQLIybwUIxznNNisN0WyhmjPeejUVhTbzbh5aLw4wxzpO2ZAUTuDiM/44D2n60NC/HnrTN+Lw4rKqMmzdJCxCLw2hedD6zTChbrbSb/0orBIu9abknN9DMYykf7npu46py85QuqrRQzApVe+c3pbxPbeRZS1+deGzu5zpCPOe1fLqBTh9bIC8k2zeh2I5xZYz5+prXmAP4XgD/EIAvA/hLSqm/1xjzYs3rtm4yGNsWiqVEX9u615T4vgvBguubvus3B/QJvbj37BCfWhe3zyr2ofXnw/WlPGm5OMyJwpgnbZ84rOnXwb24N+3NS+/DyL1pyfHg9tWlF6WtmFDMii+4ZyP3pvVCsWvnfhCIJ5h3406FYj0+jnFWIieUIE6tCMW2IBSz//XGCL364n1CsNz52o1ld0KwMG5a8ZxQjGdqgUbwRcj50NJCuIk331wn4jkfWjrn+fmpe3/PL06DKmCAFYdRm/2OS/nRNr8XvCiMZ2qBZn4kIdnrZ+dOIJYShzWetFbIxYSy5Ihw8/LS+dOmvGm5J7dZpH24aS7TTChGQrLV4nkgilXaLmr75jflvWtTnrXcu1bN/FxHSM15y6RQLO1j6+NpIVnq2DuB2i9OLYAnAL7Cvv+y7eP4BMBfMcaUAP5zpdR/gmaR++1NDuROEux8O2efxF8ccRnDu6IcNOd1b90H21fJLT3jXjnKQXyPFOWgayzch7brs8yJw1KetKl7uS3+DCUgEEW4Tv8Ktg11W+gR+DQmSucG21cPEFkqhmAc/H/JjVEOpsypnGbQRzlIzTO5Y2NRWHx+3/hT/QZMCMbbAygHsSgsphyEorA25SAWhXHKAfek9YLW8PeHv3/aj5bm5T6qV7YkbqJMuI8j+mpf9BnxOY9RBnKlcd287SZzmsftvfX4+WGSx/UY1W7qB69nLueXT70EAb4N4HuVUt+jlDoG8JsB/HR0zP8BTZYWSqkP0dARfn7TA7kT+kGXt+y+0A/4xJrb8t+nMreub6D3LG/HVAKg34eW93FPWh6fUgaXb++5uDEt70VjwnK41OYlcR1/LfKmdSVxqWJOhn5A1XkCb9pl7bavjM1wPCT6QRDvoCIcInZJP+C/89ehF/C+MZQBQhc9YWyZ22AsSNEH0mVu+Vi6fGiN6faeDfr0dn1oOeVgTBlcRz+I/Gi7yuBWlacf1JUJSuICTenbVJnw0mZKeWnwauXnv9JmcmNvWkc/IMvCqDTu0DLgGvVg+gGl14p5MZx+EHnWuniCfkAI5j+g08e2qy0IYYyplFI/AuAvoOHL/qQx5meUUj8O4DvGmJ+2sV+vlPpZADWA322MeZa/6jTcCf0gRTPYB3oBbw8tbbtPZW7z9w8PyFEOpvjQ8jj3oXV9I8vg8kUt9dEl+fYafT68HO7b5xdBSVz3CyrhTXvz8tJx0lLetItXV6DyuNpec/H6CtpO9Is3zwDaHnxA9AMXZ961Qj/YfRnbVDxFNeg7P0UzmFrmlvdRhnZImVsfb5/DqQj0yHLes4Qc5WCTPrSccjCmDK5hi1og9KNtlcG159Gc9frZuZv/eElcRz+IyoQTZ5aXBidv2puXl86fNuVNu3h9hdoemyqNO6QMuOY+tT30A76opb5e+kHCszZLPyDw+c8i52Pb175LNJZe+8U/MMZ8C8C3or4fY20D4Hfa19awUfeDlFI1bu8z7ppqEG+5d7sLdG/l5agGuXsRxvjQBpQDHSmVdbz95WkHzcl5ygEQqY9TlAI+Dr4lFowb2fENAW2HxX6F/L6t+3P1Li3guXdj/weXxLb9YX0ZSt6X9qx18YiKQG3xsmUwIb1gU1QDwjruBps6NqAYRJSD3Pl94w627FP3TMzVfZQDmkvGInY6APrL4Gqat0w4Vj8nsVdMJdDhfBU7HvB5E00Xkk4wboXuX8a5xLDzI29a9386Mb8l3WXYAPvKgPO5UBWetpByReBOMkOdCAJvW/qgtAncD1qOCPSB+A+8HRccDPbK0ksgEAgEAoFA0AUDFXuoCQBMWNSmsq+HkolN4a6zs815w+49MckX3CeXnR3rQ9t1j+brtGfRB18lx2ck4rj7PBP3DjIVNusSVxGjrIU/h4kD+F/6fWoBnsG0mQ1da+hKQ9caCn5LjV4BCvY6IDwoEdmWM7Ec64pqmx/bvBCsfWx+rkkJwfrOH5udNSZ8lF0+tK3zWXY2ey/NjzVOIAaE2VcOohrkKorR4YFgj2eQ3fXy4jBui0j3Sopa3c8cy7AGxybeK8+01vReQm9atyvFdtXolfLh5tlXU2qYQsOUGmqm/IvoAzPYvvTnkgP/HHwmmHnWFomtJg46P8rOJrO2/BwuJHvAAuFDwnSh2JbEW7sWiq3jPbsrIZgfa1oIFlw/40NL90mJv6b40AI5IZhf1JKfYnOs96RtvobisFgoxsVhujaBEKI5Tme9abknLV2Te9M6oRj50EbetCSUIM5rvdLem7ZiQjHLWdOlCcQTJG6oFfNx5N6NJ1Y8YbfpCyaeKI4KL6Q4nuHRO14UBgCYFVsRihFy3oxUm533dbUPEVOEYsZsTujVF58iBJt6vjbjhWBAtw9tTgiWihsTisIonvOhdXEmCCPxFxB60jbnhOIw7klL8ZRQrGLnkziMt52NoPFiaO5JS/NblzjMe9La+SkSh3H/bgAoV0woW9VuLlwR55UJZctVhXfs/De3/P7Ym9aJYsnSa1U5QdasaAthNTLetDPl23b+4vMbCjbXWU0AF4rxuS4pFItEY7YzPf8RZmmhWNLHtqO9D1BKMrUp7JVP7Tau1Rdf13t2F0Iwd30z5vrNwUO8Zaf40BK4OIyLwrgPrTuWedKmxGG8TVkI7k3LhRBcHJbypr15ceEEYjQ+7k17+/LSqYtT3rSL11d+UVuSOOzKicOWb57BWFEFLZ65eGJ5e+2EElw8QZ63q9Vzl6kt4IViRd30rRbXQO2FFG5RW5B4YrNCMULOmzHOIotPbd5bdpM+s7xvihAsPJ/aw71nxwjBCDkf2pwQLBWnGZGLwvp8aFOCsPaxJjiWi8O4J21KHPb8/BRVFH9x4ePck5aLobknbXz/nDjs9dW5E4ilxGHcv5vEX41Q1nt2k4CMe3OTN+3ty0sXT3nTLt5cwZD7gZ3nlm+foVq0hbDkY9vyprV/CK+Wz6Fqu6jl81vBRWN+UQuQeMzPdTQvhUKxtmgsO/8REuKxrI9tT1uwn3hQnNpNUg04pmyxj9neH77jkRaHTRFHJK4cjSnyeOx4L7EnLY0p9fLaA+a9yIQQqWv2CcmC6/OxJMfKtuJSPyfaBGUY47GkfFxz9+TZT4ei8K8EVEF0hWR4HPj2Wo8owpWhvO/iCbelm267wxJ928ChUw6GjbH7hGS560gU1nl9vbkyuPyafs7yL399Lg5L0BMy8184r9ID6BbVxu81nguDc1hJcJpPU960RLWyt/elcVNCWEav2icEorG+eYue14HMbwoGBeq7HsZe4kHRD2KqAWFd+gFf1A4vkzt8LHzu6qIfjCl9y9t99AODVJnbzZXB5W3HmWWUA14Sl+J8m03XJvCmjekHsTctbb/RLyBOP+BbcdpZdoWlcWlLiyr61HPtt+RWlaMMaMvzqk0ZeNMS/YCyEmrut+GKk3mwJRfTD2LvxrXoB2j7NPaVhoy9a+8T/WB+dIyPLP1gKmVgX8rcTjlf91ApYsrBpn1oeR+nHwzxoXXxBP1gk2VwiVNbVdpRDmJPWrqmK4PLPGlpKo7L4abpB3YsjHJQVZpREez8EnnTOiqWHUvsTUue3OXSnh9503aWAVclox/Y81GmvWnvmH4AIJgLm2tm5j93ej6+b/QDQRoPin6QohoQ1qEfxJnaYWVyh48l/oM8f/00ZSD+i34q/eD1FStzm6AcTC2Dy9s8Uws0lANeEpcvaqmPjuXetJx+kPKmvX156YRinH7At+LcojZRGnf59plf1DpvWlZG8vbabd/xLTmKr1bPUdgtOdqaWy2fe89atiXH6Qcp78bJ9AMLTkXoKw2Z8q69L/SDqlxlt/HHbPnvQ5lbfz719XvL9h2bohxs0oeW93H6wVAfWh7n9AOaHzZRBpcWtbSgfHFxmvSk5b9rQk9a+ywS5XBfXZ0F8yqdZxjlgHi2nH6Q8qZ9++KiRU/g3rS3ry6dP23KmzZbBpyVxCXPbs3nN+5Ne8f0AwKfC7P0A0Jufky07xrCqU3j3tMPtkk52Ia6fxrGv7euMrhd6N/qGz2UUYjdDlL3b7bahm1LAgAvE5k+kG3TM7jtOx0qgl3Jx4EPQynrfiD+rgKLdd1khlIAplIGxtwr9V5StAqDtuNBcE7PnNtQCuD8aHNlcOP7x04GzVg85SD2pE29f04t6B6rXUjqtONB+n2H9CyiTdD8E3vTxu4vsTctp1U0zy3yprVzXcqHOzjWJOLsuamE92wf+PUnzYacP5HiaGnT9q6N4tz5odMdQbCXuPeLWoFAIBAIBIL7A/GpzeHeLmq3QVpfNzs7VhzWnUFJi8K67tWVnU2Na2j2IDk69td7LHSIzw9EG0H21P7RnRBfBUKynmx87E1LQonksYFoon1MXFXHDiYUT9gX+UBmP8zUX/82awulAp/HXaEv0SHYHnYtChuKrnkgf/32e8m9v9TVU1W4ctfnlKW6Y06aimQmNxKH6WgOisVh7pWY/4L3xefFVFY4mvdofNybNt6pir1p3cs+2NibNvbhDs9P7ERNTfezuW7bSApd+7K2HFEGV7C/uLdCMT5xThWCxX1TfWgJsTis815mvA8tEIrD4ngsCOs6NhaHtX1oc3F7vg7FYbEPbSwO4560dB0uDiMhBNEP6lKnxWE6JRQLvWlJKEFjCXxqV22hmKm0EwnoZe3EB672OfOm1TONk3esaKKwQovCiyd0pb1Q7LjhzxaxUMyer468UIyoCdsWigFwQpFYNAaIUCzVd6g+tEPfC/8DDFFzEwAAiAxJREFUMC30QqKv7WObE4rxNS4Xf8U+tK34l8LzuSAMQCAO4560dH7Kh5YvWkkcVtahJy3FuTgs/r0Ti8No3nbeskwcxufaqvJCMbLy4t605apueXbH3rTx/Bd703JRLND2po19uLkQtlalm5PMzGoKmDdtML/Ni06hmJrP3FxHBWbUjM1589l4oRjgPHVj0Zg7JyEkA/fhFqHYQePeCsXirN1UIRjvm+pDS0iJw7L3Mn3Xbw5IecdycRiPpwRhuWMJXBzGPWlT4rBGNNa0U+IwLgpLicO4J21KHNaIwuyi1i44W+Iwe97Ni0u3QE5503JPWl025yxeXQWiCV3TorY5bvHmGQwTipGAIvCmJdHY7bU71onDls/dNVcrLworKhJMPIfS3ptWVV4o5ha1WxaK+b6rpGhMhGLojR+SD20uzttxprYt9EIrnhKF5YRice6Li8O4KIzAxWFcFMYFYQQuDuOetClxGPek5eKwys4j3JM2JQ7jv3dS4rDmd4hf1AJtIS6JWl8/O3eLWu5NS96y3LM75U3L57+UNy0Xxaa8abkPNxfCcqEYyMd7mZnfmAA2KRSb+bmOL2qpT1F8jFDMYvn2WVI0lvKuDeZH6ssIyZYiFNt73Cv6wbZEYeti6HbYNigHmwAXWqTvux4tYwxy/rJ+MP7V9xxcmciED2V4zWhLzhk59oyV/gCISuMqpZqvY0pHJnxrs+V1twi+VXnvPWu3iNS2/LTrDKccjMEUT9ocvSD13gzaorC++XsMPSMWh3WVwU2Jp7g4LPv+dfu5p+fAnnmbjTWYSxOe3uG9WDzh0+3+aO+hXLXeWE00BDt6JoQN5le36E7PbyjYa8ugsU6mTNGzkznt4HGv6Aeb9qGN++66DG7Oh9adn6EXEKbSD9I+tCagHPCSuMD26AeUXejypvUlcWnS10n6AVl5xaVxWz610ZYcbW9pe36OflCjSQHHpXFpS644sZnazJZcQD+YN8eqQiXL5PaWidwQ/aCJ+9K5Qj+YdixfmN2Fj20f/WCTZXD7fGj5+UPL4ALopB/ElIOhZXCdZaBBsgyuoyzV2tEPtAlL4tJxNL/zeZfO7/KmpbmU7Adjb1qaK0tW8ZB709JcWNkMK/emjT25gYh+MKta9Kp6zkrjqmrw/KaOCufPTX8Ab4t+QFCzifQDQoeP7T7RD6T4Qh73in6wDR9a3nf3ZXDT9AF3foZeQJhKP+DeifG9OOWAx7dFP3CLWntczpv25sWl28ojQURMP6BFLV2Ll8YN6AeJLbnl22c+U5GhH5B/Y6o07mr53JXHzW3JBfSDGS1qm/fXUA44FcE++C3TD8J4NxXh0LBL+kGcbdyFDy1v99EPUp60hLFlcPt8aAljyuDyeIp+MLUMLs/UAg39IFUSl+bSF5feW5aXxOVUM14Sly9qXR+bXytWEpf8aVPetG+eX6CiRS2jYlH85sWl86fl3rQpT+6AfrBo06s8/eAamvvU9sxvSjP6AS1qt0Q/ILj5cSz9gNDjY7tP9ANBGgdPP9g25WDq1vpYp4NtInY7AKZTFXq39CnOHA+mIFAXMx/G9Jjo/eTH1FUaN3ffvqE7H0d2Dgw5PqTvdxeOBtuCUBHGYV13g/Ba087pojdNoRxsC2M9aTeNLD0hRaVI/A7KPSs+F9Nzjh0PePlv/169N22rZDi/P6MHmMTD457cpvYJhBSjKunu0jO/5TDJg5vf1+4kxXN5ZxnchJVLb+lcRr/YayqCEk5tDmLaIxAIBAKBQCA4ePRmapVS3wDwDQB47zOf2/qAhmLbYrD9qBRG6H6v28hUbFIcpqNsBxBmHwLvxYHPPZeh7x83z4rYa1kP21Zmw2UqQvFE4/HoMxst78aBD8ZlL4qCveBfgq2Dz2+f+XDznLlNZmen3X/72dV1K4b1zeVDn12XOIxXDwOieSCqHtZ9j/z7o+u2zknMf1MR7iRlnns0/+Xeq3vumuatMFOc3Im6o1KaawvBpoBnbYGwvQeQ4gtp9C5qjTHfBPBNAPjiL/kvmH0Rim3Dh5a3+f/Z3PndorLhojX+/yQlFOOTfk7o1RWvE/GcqIxviXX71IbiMGr7baFQHBYLxWJxmGvTQtGE3rTUputXlc5605JQzPHfqtr5NFYJoZiuQ3GYE01YqxpT6kA8QeKEes58apl3IwkhamXjqk56N5JPrTqaMfEEE0rM9lsoxtuxaOxQwOe3X/L3/HKzaaHYVCFXX3yo0EybET63SAu9+LWGCsFSPrWxOOzjxPlcHJaMM3EYCcFq7eesnDgs9qGNxWHkSUuL2lgcRm3ymeXiMC5QJk6sNqE3Lc2vxKXt8qb1orDane/EYSvdEs3yubBaaSaUbeLzsnZzXrXyoljiwuplnfThrmc2vvLzm0bVOb/lhGLE/1czNVwopvxch5k9n81/sWisOZ8JxRCKxlxfan5kyAnJUscK9g8HKxTbhg8tb8d/iObOz4vKTGc8ONZ0x+PcRk7olYvHnNqcOCwQnSXEYY0ozC9qU3HOqQVCcRhvp8Rhb55f+OwnE4cRl/bt8wt3ffrlkvOmvXnJfGiZT23FfWqtP63WTBxmf+ksXl850RdsHxdPLG+eOQGFXrW9G1eLax+nvsi7sbCetOTh2IgnuFBiv4Vi4bFt0dihYRtCsZT37FQfWt6O54ycUIyOGyIkS4nDrhLXGiIES4nG6CguDuOetAQuDuOetDxOXc2xtJBsvubEYdyTNiUOe35x6ha1KXHYi4tTv4Bm4jAuUOaLWuqj+evV1Zlb1BJy3rSvn507f1onDru+cOIvLprlc2FV+vmP4iXNf0wotnh95Re1dp6KfbhrKwRzc97tNYwViuXmt5xQjLy46Y/vQUIxpVicFrXNcW2fWhXGYyFYlOJtzY8RckKy1LF3AyOc2gwOXii2TxgrDtvmtmCqJG7X+KaUwnTnRttV20Ty2TJxRDiu8f/pg5KRvG/g+2tKUDblKJMf7gjvRqWUe7m+O/CmHQIRjYXYBt1Au630zV2zTxxG990FxorDtlESN31ftv2eQHrc3ps2ORczmkDsTZssKZ7woQ3v3xbKul2zqDSuf3n6QZcPd1A6vG9+u2NwelgfVaFXNCY4SBysT+0+0g9iysE6ZXB5ewr9IPakpeNylIMuH1qgm37APWkJ26If1KXf/stRDuLtN6PNYPoB92w05FPLtuRMpTvpB3x7Thc2HpXGbW3JZegHxbxobb8FlINUmcg7oh/w9qE6O2zSp3ZTPrTxNcf72PbEOygHXWVww/hm6AeccpCKx5QDXhK3OX879IPAk5Zlark3bexJzudf7knr43lvWporycqLe9PWdduzOy6NS/NfaTOxcWlcPtcByPpw13N7f1Yat29+u2v6AYBgTuyiH/B2cP6B0A/UPfWpVUr94wMOWxhjvpUKCP0gE59CP0hRDqaXweXt8fSDlCdtH+WAl8QdQz8IPGkJW6IfkCdjzpuWxs2332h8Q+gHgWej3QrkW3LGbvXl6Afk87haPPdldBOlcYMtuQz9wNEL2PYblcPNlom8I/pBeN5hLmo3ST/YlA9teE1q9/vQEvroB32Ug1wZ3DC+GfoBpxwQOP0gRTngJXG3RT+g7f0XF6eBUAwIvWk57Yx70waetFE850375vrcL2qZNy3Rqzj9IFUa9+blpSuPmyqNy+e6nA83zW+8NG7f/HbX9AMCnxNz9APebp2/9/SDe40/AeDfB9D1i+S/BmD9Re1dY189abeDuymJu/a9JvrSdl9yPXoDLxMZbMWBtueYe0FwYoKmwcfiXOH9i1TJxhg32QelIxk6y+JuC3yrcUuLz13QUPYFsQp+004HUykH2/4IUur/nCNAaiibLonbXNM7HowBL4mbckdIIe++Mu7eY8E9u3udFiZQylLuLn3zGwf34U5SpbjTyy7RY59An/uh/kF+z/DnjDH/dNcBSql/Kxc7KPrBrsvg9p2/TfpBXBKX0FXalsc3ST+IqQhNX5p+wHmsm6If1FXtS+LWfvEwlH4Ql8alrTinZC4z7geUyci4H2hSB0elcZ062DTx3JbczJbJRVHsjH4AeMpBQEXYIP3gUDGFfrAtdwPCtsrguutPpB+k6AW5Mrl83ccpBa0yuTqKfymM5+gHfE75kFEShtIPKt0ug8vpB8aYFv2g0jr5e4PK5PL5Oy6JS9eZQj8oy7pFxYpL41JJ8JLK4EalcbvoB3pWtelVUWnceH4DkHR3UXM2r5GQi1OtCrU7+gEhKp07pozuPtEPFAyKeyoUM8b8tnWOOSj6wV2Uwe07f3v0gzZVgNBX2nbT9AM6LyyTC9eXKolL2AT9gLbMGiqCCeJD6Aep0ri3r5g7QqI07uLNlduWMxn3A1r0pkrjrpbPnbo4tyU3M3YmL3ZIP7BYMsrBpukHh4op9INtuRsQ+ugDqb4hZXAJU+kHKXpBrkxunC/klANONUg5HjwLyuiyOKMfxPSE6/NTd84Q+kFlPP0gjr+4OHVj5fQDmlPi3xuV2+3ZDv2ASuNyKlaqNO7Ny0tXHjdVGjdHP6D5K6BXJUrj8vmNELu7KN62VIKAahXQC5prbI1+QEiUzh1TRlfoB9uHUup7AfwvAfxSAH8TwO8yxrQnzQz2nn6wbcrBJrALCsAQpFS2Y9G33TeUmhEbjg+lL3h+3bTSuOvSMpIlI1lnYE5Oz8qEpSNjqkTvlpyy3yuVLaO7U9Nxi0SVSQHGbY3vK/rcToihsouprW9OmfKY44ILWkelZ1kRgrHXbfUl5py+eSgoiMBeQT9NL5YSl2V2MXpACnFpXPdy9ALDissk6FV981uGXiXYLu5x8YWfBPBvAvhLAH4AwB8DMEQ8BuAAFrUCgUAgEAgEggeB940xf8K2/7BS6j8ec7IsaneIXWY/gvvmxA5reNNOBWUfuPdibyZi6r0GPug+H8pe7JfCULBB3FVWdsoccVfzy1Csu+t2V960TdIyFOtNLRO+6TG2+uzulskIyZLXSWRfg+uPebMZH+47EcVOwOF4197r4guPlFJ/H7z7wWP+vTGmc5G790KxWBy2j0IxPnl0CslM2oc2uNcaQrFYHNblYxuLw2If2rjPt8HieaFYLA5zcaIXROKw9z/8YhiPSuPGQjEujoAGE4d5oQTxx7QxnUKxelV5cVhpnFDKkCVY5N1IQgWy8opLR5IQTNsykjnxRHFkeWLMr1EdpYUS6oiVyd2RUIy3Of3gIQnFxnrD7roMbnjOiOuzP2hz4rBYCBbGxwvFYnEYL4nb6mNCMTo/9qbtEorF4rBYKBZ708ZCsdib1rUNzT+hN21c8jwujRuXIe8qjevadn6qSuPmx7r2QrGSOP1MKLtaVW7+m1v+bTDnrZhQjDizszJdBrxoPA/75recEFYVqjXXBaLYPRSK8b4u0ZhgqzgF8EfY92fsewPg13SdvPdCsZQ4bN+EYvFfxFkhWUIctkmhWEoc1ldGl4vDXl+dtzJSsVAs/mM9JxRLicPeXJ8HmVogFIe9fX4RLGpdn/aiMf9Lx4sjiFp08+LSlZy8eXnpyuPSL/CcUIwED02Z3KZv8ebKlcdNeTcub7xoLFU6crX0Po458URR24mY+TWqKi2UUKWf1On+2xaK8XbMqX0oQrGUEIzH+9pT40OFXrwvJSrLnR/v0uTEYVeJa00ViqXEYbwkbtDHjo3nDO5NmxOKpcRhz899yduUNy0XiqW8aV9cnrnrprxpuQA4VRqXz7t9pXHfXJ+7e1D87fML1LUXipFojAtlyfHg9uWlK49LftyLV1eoSz/XkXsCzV+tMuBWFNY3v+WEsDT/BHNdsd9CMd7XJxq7Syjc3+ILxph/OBdTSh31nb+38o+1toNHYL92jvfHm7YPuyyNG9w36Q3pS06mEIoymGjCbtNloUk8EXo3mkh0kTontwesrChMKdXv11gUTYZi156ODxUmpBscshBsG8g9l5w3rTG5mWzc9bPHdvyfn4r159f8/A2kn1XvFRkVIjXv9j0LLooLqFaJeSoQwk6Y3+4Kg38XJZXA3dd8SL7b+wjV4B9RSv1rAD7pO35v6QfbLoNLiCkHd0k/iCkHQ31mCbukH8SlcXdFPyCbG607fGoj+kFcGpe24igrEnjTcvqBzVQEW3Lz2tMPrE+tmdWBdyNtxWk7Vk4/KI6ZTyOjFCTpB/NZsNVGX4V+sB1sskzukGO74vtIP8jRC1Jlco1B24e2h34Qe9N20Q+0bpfJ3QT9oGIVC6fQD2i3jM/VfT61ffSDcqWTnt001mqlA2/umH5QrTSjHDCqFfnUsjLg9axyc06tmhRv3/y2D/QDQjwntugHCEvndtEPeDumItw97jWnFgCglPoHAPwQgH8MwGcB/A4Av6vvvL2lH2y7DC4hRTm4O/pBmj7gx9od3yX9IFUadxf0A1cwgVEOeGlIui6nH6RK4y5eXYHK49Lk3KIfEGeNb8k5+sG149SipNKR187QfLV87jxvOf2g0LZM7sJTEfg2XEA/IFrCzbVbVAr9YHvYZJncocfm4vtIP8jRC1JlcqnnKvCZ7aYfpLxpc/QDXhLXXx+2bzr9IC7DPZ5+4Be1QMKnNooPoR+Q92zs2c05t0Dozc3pB0S5arxpGdWKfLhZGfCa+9Quhs1v+0A/IKTmxBy9IEVFCOKsnaIiCLYDpdT/HMB/E8DfAfBvA/ifAfiOMebfGHK+uB8IktgnqgN3Stj+zYzlowy4F/0yrgx0qZuvtYauNHStvW9jRhHsULCXQCAYhXUZCNzHtv9ew27W5xke0N6MpUEZHcy7U+a7SVvmPVvyTVnxpsQ4n98IWW9tTrUaCKWUe+0T9tEVobi/PrW/HcB/AuCPA/izxpilUmrwD7T8GhUIBAKBQCAQ7AO+COAPAPivA/jPlFL/OzS2XoOSsJKpFawPlmm499AaqIcpC+PMxV6AqpntSbZB4KGdUG071zcw0MhX0dpTDdBgjBGa1ca/1r/v3Ty3tcXNiQFzISwlAp1ALXqum6wgto25kgt8N1kRUYRj24Uxpgbw5wH8eaXUCYDfCOAxgCdKqf/QGPNDXeeLUEyEYgDaQjEuZAjjdqw69KblojE6f1NCsbrU3qeWcdK2IhRb1k48ZSyXLRCKqZIJxZp4jTIUUpxYUdicxBHKiScK5lPrhGJzJo6YbVcoFojDABGKMdy1UGysJ277/J442t6yQF4cdihCMTdnMHEYgE6hWKVN4E0b+9TmhGKVE3r5+b2qTeAvDoTiMD5vk1Csqozz+dZMHFZVmonG7PxSm6RQbJXwqS1XFd6x8x/ZhuWEYvXcCl2ZD/esYEJY1cRz8xtRBNTMC8Wyc93Mc2pTQjF1pNw1nTgMWEsoBqA9P2KaUCxu7wPucZlcB2PMEsC/C+DfVUq9D+C/0XeOCMVEKBa0U0IGF88JxWyG9s21P3aTQjGa3N++4PHmnI0Lxax4YvHmmfOpDYRi5Ol4e+2O1VZcsVo+d0KM1eq5E4iBCyYqEkowoRgXRwTtLQjFuDjMQoRiDe5aKDZG6JWK951PGdq89yxa8UMQivHiDk3fqTs/JxSrjBeKUfzFxWmwqHV9TChWs0Ut0MzfFRON0RweiMPYvOzcE5g4zDBxGDkacKEYzW+xUKykP7rZ/FetvE8tzXtZodjC+mwzH+5qwYSwdq7LzW+UqaU5a7V8np/raFGZEYqRQDYQh1lMFYq58/n8SH0jhWKptmA7UEr9k+ucv1f0g3XLKO4S+ySkyokRHiJ4mcj1r2Xc13X8CpXd8leFgpqRsCJz7J4KJQT7iUOlDPT5gxvjX1PAxV+BT/UdlAa/KxjrzU9+3M3L+s9u6QeGz3W9EIHsZCh1ry29/v5M/w8A+BKAf7Pr5L2iH8QlcQn7SD/g3oSD77Ul+gFf1D50+gH3aaSJeyr9wPk4MvqBZj6OQ+kHcWlcarvsA6MfFPMi2HIT+sHucIj0g5hycCj0A60zcUY5iH1ox9APYsoBtenYuDTufaQfzO1OUlWy0rjL2s91q3YZ8HXpB3yu4z61SfpBRLuiawr94GHDGPM/oLZqfsh+K4B/AcBfBvAv952/V/SDVElcwr7RD7g34eB7bYl+EGdqHzL9gPs0ukXtRPqBSfjU0i+CMfSDVGnc1cJvqXH6AS2E+Zab0A92g0OkH6TOOQT6Af3/5VSDVGncID6CfpCiHDw/P3XPIFUa977RDyhO5zT0A9t+cwVDPrUbpB/wuY4WvVn6QYJ2JfSD4bivZXIBwDod/DCaYgt/GcA/YYz5W0PO3Sv6geBusK2Sk4eCbW/JbQuqaDIQm1T2CgSCEJsom/yQaA8CwTpQSv0OAD8K4D8E8P3GmL895nxZ1AoEAoFAIBAcDAyK+8up/WMALgD8VwH8aqYvUQCMMeZXdp2sxoiylFKXAH5h2jhH40MAh7uXmcZ9fE+AvK9Dwi7f01eNMR/1H7YfkPltbdzH9wTI+zokPIj57b/89b/H/OW/Oqhq7EZwPPtVf80Y8/Vd3Esp9dWuuDGmc44eland5QeolPrOrh7irnAf3xMg7+uQcB/f06Yg89t6uI/vCZD3dUi4j+8ph/vqU9u3aO2DsPEEAoFAIBAIBAcPWdQKBAKBQCAQCA4e+ywU++ZdD2ALuI/vCZD3dUi4j+/pEHEfP4f7+J4AeV+HhPv4nlpQuNfFF9bCKKGYQCAQCAQCgeDu8PWv/93mr3z7J3d2v3nxq3cmFCMopX4jgH8JwFfRJGDJ/eCDrvP2OVMrEAgEAoFAIIhwn4svWPyvAPzjAP6mGZF9FU6tQCAQCAQCgWCf8IsA/r9jFrSAZGoFAoFAIBAIDggPglP7ewB8Syn1FwEsqdMY80e6TpJFrUAgEAgEAoFgn/AvA3gD4BGA46EnyaJWkIRS6ocB/HVjzF/fwLX++wA+h4bk/QfWvZ5AIBAIBA8Zytz7TO13GWN+xdiTZFEr6IVSqgDwzwP4GMB/AOA3APiDAH4YwP8FwD8J4BzNz9N/DOC/DeDfMcb8XwHAGPO/UUodA/hf73zwAoFAIBAIDg3fUkr9emPM/2nMSSIUEwzBOwAMgL8D4B8B8K8D+GcA/FIAzwD8cgCvAHzGHv9/pgUtACilHgH4X9iXQCAQCASCdWD07l53g/8egD+vlLpVSr1SSr1WSr3qO0kWtYIu/Fal1P8QwBfhF6wzY8x/BuD7APx7xpgrAH8DwGMAP2OPif8X/Gk0RO9fv/URCwQCgUAgOGgYY943xhTGmMfGmA/s950etYDQDwQZGGP+9ajr91NDKfV9AJ4aY/7v9tgf67nWD256fAKBQCAQPEyYu8ygbhVKqS8YY86mHiOZWsFoGGP+qjHm99z1OAQCgUAgENwrfGudY2RRKxAIBAKBQCCYDKXU9yul/pZS6ueUUr83Ef9hpdSlUuqv29dvz1zqv2g5tLnXawCfz41D6AcCgUAgEAgEhwIDYFyhra1CKTUD8BMAfh2ATwB8Wyn108aYn40O/dPGmB/pupYxZrbOWCRTKxAIBAKBQCCYiu8D8HPGmJ83xqwA/BSAO9HSyKJWIBAIBAKB4JCwX5ZeXwLwi+z7T2xfjN+klPobSqk/o5T6yiYeQ4xR9IPjx++Zxx98FgBQzI6g67LVJkyNb/Ja247HxxoAs9kRatvH24RJcbbLUMyPoKuy1U7GZ3Pouorei+/LteNjjRl3LXoayWfF3ouazWHqCqZvrMYf66+eu79BUcyhNbuW6X+vqpjD2HN4e2h86LNMxhWCMefa7lrJuNrMWNaIx8feXH9yZYz5CAKBQCA4ZHyolPoO+/6bxphvjrzGnwXwbxtjlkqp/y6AfwPAr9nYCC1GLWoff/BZ/Fd+y78AAHj3Mx/j7fOLVpswNb7Ja207Hh+rtcG7n/4Yb1/YOGu7a02IG8adeefTH+PGxnk7jmsNvPPpj3Dz4jKK+z7X7jlWG4N3PvURbl5GcdundTtutMbjT32EW9tHbaP9e6E+DYPHH3yE21f+fK19n6nRihsNPPrgQyxeXQHwbQODR+9/iMXrq2AsvK8Vr01nPO6L42qm1ju/KLLxoddSbFGbei7B+VuKx8f+1T/1u38BAoFAINgwDKB3aul1ZYz5ekf8CQCeef2y7XMwxjxj3/5JAH8odSGl1Ge7BmKMue6Ki1BMIBAIBAKBQDAV3wbwvUqp70GzmP3NAH6IH6CU+qIx5tR++wMA/n+Za/01NJuxCsB3A3hu259GU9X0e7oGMmpRW8yO8O5nPgYAvPe5L7p+3k71jYlv8lrbjsfH6tps5V6aZWrf++wXk+24T2vTGQ/aGnj3s19oHUt9Wpv++GfCuNY66KM2z9S+Y/u0MXjn0/H5vs/UwDuf/nwi7vuobYzB40+FxzZZY9/XitemMx73xXE1U+udXxTZ+NBrKeUztannwrGteOpYgUAgEGwBe1R8wRhTKaV+BMBfADAD8JPGmJ9RSv04gO8YY34awD+vlPoBABWAawA/nLnW9wCAUupPoKla+i37/W8A8I/1jWXUolbXZbDdnmuvG9/ktXY5Vm0XbJxSENMLpsRNZN3BKQcx/YD6aGciphTEfUQ/6DqWFtUx/YD66H3H9AMAjn5Abb6opT5tibYx/YD6TI1WnP4/8+1uoh8AaNEP4r6YftAVT/XF9IO1zi+KzviQa3H6AdB+Lq3ztxRPHSsQCASC+w27+PxW1PdjrP37APy+EZf8B4wx/yw7/88ppZKUBQ6hHxwAKAsXL267UBRAUSgUxa6pN5uHmvkXLXCVfX+q6P+DVRWFe5nEw1Az5V78e1rsdh271vsqxHxEIBAIBCNh7m+ZXIanSql/EcC/Zb//rQCe9p0k9IMNjnVb9AN3fWMG0w94W+se+sKe0w8ABFQE3/d5dmyefgD4bfqYihDHg2Nr0+qLqQZd5/fF+aJW6AcCgUAgEDj8FgD/UwD/nv3+L9m+Tgj9YINj3Rb9gECZ2iH0A96Ok5OHRj9wxzIqQtDHqAgp+gFh8foqSUXg8eDYKFO7eH2VpBrkzu+Lx5laoR8IBAKBYBDueabWuhz86NjzhH4gaEpw0Cvx/6RQqqEyKBWI1rqgigJFYstfFZZKoYdTKcZAQUEpBQXlFriTr8UoBpukHNBr7Wux9yoQCAQCwX2BUuojAL8HwC8H8Ij6jTGd3rZCP9jgWA+WfoCQikDglANONUj1xfQDwFMOYioC0Cxqt0E/4P2cgzyFfrCNeOx00Hd+57WU2im9oC8u9AOBQCAQbAj/ewB/GsBvBPDPAfinALS3iyMI/WCDYz1Y+gFv9xwbZ2pz9AMeT1ERKFO7afoBgVMRXN9I+sE24imng77zs9eyGdpd0gv64kI/EAgEgh3g0BXg/ficMeZfU0r9qDHmLwL4i0qpb/edJPSDDaIoFIpZs1Wvt7S9vo9oXBamv+8CDbWhgHIL3Nw11az5yhe3OScEWvTxxW2fE8I28BAoB/wzEAgEAoFgTZT266lS6h9F43zQWW0MkEWtQCAQCAQCwQHBNLZe9xt/QCn1KQD/YwB/DMAHAP5HfSfJonZL2EbWVqkmo6mUGu1ZCwzcraBMW+bYwlpHDRWMAWnRmCqUe3HRWGEzkHpNkdfQcfH21OxtnIk95KxsnHFNZV/74gKBQCAQrANjzH9gmy8B/MNDzxOh2A7Gqpk11KbGEovGXLxDSBaXzu0Unem0UIxfq1dIlvCp1WzRyL1r34l9bpl4LBaNAe3SuTnRGND2rt2Ujy2hq8ztkPNz8bsQghWFEqGYQCAQ7DMM7r2ll1Lq7wLwxwF83hjzK5RSvxLADxhj/kDXeSIU28FY40ztJoRkKdEYISckS5XOzbVT3rW8nfKu5aIx3sfbcSaUe9dyIRkXj6VEY6nSuTnRWMq7dhM+toS+Mrd95+fidyEEo6xr/Fxj5OKpYwUCgUAgGIk/AeB3A/hXAcAY8zeUUn8KwOYWtYL9wRQqwi5K5xbWh3aTQrmUaCxVOhdIi8bibfwuH9ucqGtb9ALXToxvGxhCLxAIBALBnuOeZ2oBvGOM+au8WiaAqu8koR/sYKzboB8E12eL2qE+tl1UhOaAafSDIL4h+gGAgIoQ93VREeI+3k752MbtbcaHlLbdJ3rBlLEKBAKBQDABV0qpX4qGbAGl1D8B4LTvJKEf7GCs26Af8HacqR3iY9tHRZhKP3DxhHftVPqBO/ZVm97AvWtzVATCEB/bVHtb8aGlbfeJXtAXF/qBQCAQbBsG5v5nan8HgG8C+LuVUk8A/OcAflvfSUI/2AG2sSXPQRm/sY4InVSENUvnZn1m7bZ9XDo3dkJIedfSdQG0vGtzVAR+Xs7HFuimJEzFLukFqfcatwUCgUAgOAQYY34ewK9VSr0LoDDGvB5ynixqBQKBQCAQCA4FBve+ophS6gTAbwLwNQBzlrz78a7zZFG7Q3DvWgB75WO766xtyru26bc/uJF3LWVt+ZjomvweGsZlbQlDqo+5eMYbti/TuqlMrPjECgQCgUCAfx+NR+1fA7AcepIIxfZgrPvgY8sFZJ3HsoVgr0/tQB9brXUgKgPa4rExQrIxnrZxX9zedXybQq5tx0UoJhAIBIIN4cvGmO8fe5IIxfZgrPviY8sFZL4vEor1xONM7RAfW8rUcqFYSjw2Rkg2xtOWsC1x1pj4toVc246LUEwgEAi2DfMQLL3+X0qpv9cY8zfHnCT0gz3ANoRkWyupW0TtiJJQMJuqFCUhKfRiVAQP7cRjzTHDhWRdnrb8+/B9r7flv8m4QCAQCAQPEUqpv4mGNTwH8N9RSv08GvqBAmCMMb+y63yhH+zRWHVt7szHdkxJ3VafbvvUAiHlYKiPrY/rZJxzbYmSMMbTlrc51/aQtvT3NS70A4FAINgRRiSrDgy/cZ2ThX6wR2OlRdhd+diOKakb9CWO5fGUp23Ox5aQoiRwT1veN8bTlrf5ojYVj7FPW/r7Ghf6gUAgEAimwhjzC+uc37uoVUp9A8A3AODR+59d516CHmzLHYFXrhpKSRhVUneCOwKnCfDvh7ojUFsVCoVG4I7g2pF3a8szl1EQuugJ8eJ30+iiR6SoEruKb/t9CwQCgWAi7j+ndhJ6WXzGmG8aY75ujPn68eN3dzEmgUAgEAgEAoFgFEQodgAoWHZyk9nbKVlbwraFZC5eKGi0hWS5imT8+yK6L2VveYY4vldw3xFCs3Xj+4j4fcf9XW2BQCAQbAsPwv1gEkQodqBjjUVl61x/rKctsH0hWSs+UEjG20NEZS4+QWjWd/4m4ru81zbGKhAIBALBriBCsQMda0pU5uIThWRjPG23LSRzceZtO0RIxttDRWUuPlJo1nf+puL7JASbMlaBQCAQbBAPoEzuVAj94EARi8qA6T63nIoQ3KODnhBTEjrpCVxI5g4I70NUBBeOKAkxZSCmJKTbbYrCDAqzWYFZUYSleBNCM+epC5OkJ4TPYzvxsVQJgUAgEAgeKoR+cI/Guo7P7SZL7gID6Ak6XUaXn98b76EfaLayHkpPiNtA3geX467pB/tKlRAIBAKBYFcQ+sE9Guu6PrebLLnbS0/oiacoCWN8bnn5XcIQekKqnfPBjXGX9IN9pkoIBAKBYJMQoVgOQj+4R8j53BL2ip4AhJSEiJ5Q6JCSENMTYheD5JY8u+BQekLcBtCiLHCqAn8WLZ/cCXFe8ncMUq4RcTuOC2VBIBAIBPcJsqgVCAQCgUAgOCRIpjYJWdQ+IHRlctfJ6vZlcnnbuIpi3ZlcFEAxVyjmlsoQZ3KhmvhMARrJrG4xs0IvkxF6FTP3XnOiM//smj5VALP5DMXcG7IarTszvXFfHA8Ea1CTsr5TMrwpAR7vj9vA9Gy/QCAQCATbhgjFHshY++KbFJ11xbmrwVCf21h01jpni6KzVN8Yz9wh5xttskK1WLSWi/Pnuk2hmNZ50ZwIxQQCgWBH6Cma9FAhQrEHNNa++CZFZ7l4zL/NCc14X0p05uNpH9xNis5SfWM8c1N9t8H5pjM+5FpxpnZbQjB6ViIUEwgEAsG+QegHgiT6RGdx31D6AqcopOgJwfVtX1GYNj0BjLIwhqoABLQFGvt8XmA+a07ibaCDvuAfBObzGWaWkkBt/gy66Q15+kIXVSF4Fgif6yboCcn7RJSFPlGaQCAQCDYMY6T4QgZCP3ggY+2L75Nnbtw3xie3l6rA22xOWIe+kDufL2qn0hfGUBVSfbukJwj9QCAQCAR3CaEfPKCx9sX3yTOX943xye2lKvC27onTe+mhL6T6eHnfXJwwpOSvP7abqpA7f1f0BKEfCAQCwQ4g7gdJHCz9gG/JrqM8Xye+y3vty3vJbX/HWJe+EPY19IAZpwRYv9iYvjCbAfNZgdksvBb1GWMC2oK71xr0Bfd+x7ov0HsZUPKXFr70OewrPUEgEAgEgrvCwS5qBQKBQCAQCB4kJFObxFYWtX3ZpLhv3eyjYHfYhww5AMwKhdlRgdm8yWjm2kCTvezK+gJwfUqZ7WZ6I09de8Da1dH6Mrl9GfZUJleytwKBQCA4JGxFKKYKhfdZ3/sJEVAuPubYu47v01jWje/TWNaNx8caPVy0FgvcWvEe0dpYT106JydEGyo600wJm4rzRe1QoZk2RoRiAoFAIDgYbEUoRlmifRAsbTu+T2NZN75PY1k3ztu0oBtyrZTAzcUHiNameOr2CdGGiM5MZO8SC8XiTO0QoRllakUoJhAIBHsEsfTKYiT9YDhlQLDfKIrCvfj3qWN2GedetbPZDLPZrNXui1PbFXqwpW3JR5a33bVsn9K6RV8APKXBaDOavhBTFgKqAoaV/A3oDERJYAtVoiPEi1sfb9NGhlASusr0Cj1BIBAIBPuEcfSD+dzRD2QbfL/GMjZeFMXejIW3+aL2/Q+/mGz3xanNq5cNHYvWujMeUxkIXfSFmLLAqQpxX67kb0A/YH3rlOyNPW8JU+kJQj8QCASCHUEytUmMox9UlfjU7vFYxsQpQ7oPY+HtuKrYOp9LXJJ3GP1Ad8ZTVIbw/DZ9IUVZ4FQF35cv+avj8sKMkjC1ZG/K8zZ1zhh6gtAPBAKBQHBXEEuvA0VMH4j743YqPgV80amYT6xKlLntiqsCmM28lytv+7E2x8XtOF4UCvMjhdm8Od+3rU+sNr33or5iNsPR0Qzzo1ngmOIoDYVp0Re09mVuuSuD3973jgvcX7coeBndhp6ggdA9gSgL2nvehucM87xN0RK4U8JQ/2GOmJ6QoioIBAKBYNMQTm0OQj840LHG9IF1r79LekAzfuD9D7+Lxb8LMYbGi5nqPFbXZtK9+JzBKQ3xs4opC5yqQEjRE/gCNeeeEJf07SvZG1MStumOMORYgUAgEAh2BaEfHOhYU/SBda+/S3oAZV3fsL43ifOHxClT+eaaHcvatE0/9l6xtzWnNPD3kqIscKoC7+P0hJgekXNP4LSEPqeEFCVhW+4IQ48VCAQCwQZhAEzYXXsIEPrBHmGsI8GmQNSAMfSB4Liimx7A23yrvKtMrlLAbO5dBHibQH1FoTBjjgOzyH1gNlM4Op7h6KgZDG8Dlp6QupdlGBgTUhqOjgvMjwq3gIwpC5yq0Fy/m54QUxKcUwIiWgIaGkLKHYEWu5ySsG13BIFAIBAI9gmyqBUIBAKBQCA4JAinNglZ1N4RckKvbWCMuMsdV6QzrRzpvu5MLL9dc3+0Mq38WvSazwvMuXesKnB0PMf8qPkRns1nKGazVrs5VGF+PMfMHktt4zKtCK7l2ox/cHTUZHcb0VkzVhovz/Sawmd1ac5RahZ459Lnrm3+tQieVbeobKqQjLK2qvBCslzWlj83ydoKBAKB4FAgQrE7GuumhV5d8SHirk0JubirQCrOx/LBR/acQrk2R1dcFUXQl2s3xyp86mPfR22+UEudzxd91Ke1aV2f9xnjRWm6JnpBWmhGXNxcGd+UqGyqkCxVZjf2tI3jvD1ESCZCMYFAINgBpKJYFiIUu6OxbkPolYsPFXdtQsjFM7VAW7wVJ4bfXJ8zodd5+/q5uB3g62e+L9cmvmgcj7OPrfMjpdib63MvOmNj4X2UKH1z7UVhdJlYaMYXtdRHyInKpgrJUmV2U562hKlCMhGKCQQCgeCuIPSDLWGIj+ymMIVeEJyfEXqlsC16gfNbZYMgGoEqFIr5DIpRCooCmM29Ny21i6IRch0dx2VsFebzRlR1fFzgmAvFjAnO8e3me60N5sczzI5mUDpBXyi0o0dwegI9i5iSQJ64Ss1s3HvfclEZpyW4krpMSBb8oU40ESYki6kI9F7c5zOSisDbQkkQCAQCwb5B6AdbGuu+0Qu64jHVwMd3Ty9QbMHv+0L6AI35Ux9/yX1P7aJQQf+QuNYmea1UXOs2fcFonaQnuExtREmIfXBjSkKqJK+jMrCSuzEVoemMyuhuyMeWI1dmV+gHAoFAsCMI/SAJoR9saaz7SC/Inp+gGhB2Ti+I0sWvn50n6QO09o0pA0Xi2CBuB/j6itEHbEYzR1+gxenrZ+duHgnoC5ZfENMT/KKW3qunFHAf3BQlIS7JyxfIQN7TlpfZTVERpvrYxsiV2RX6gUAgEAjuCkI/2CC27WgQ+8kOpRe48wc4GhCKQvX6yBK9wI8loiek6AVsMEPpBY37QfNycWUdEWaWMjCfYT4rGvqBbRNmhcKj4zlWR831j+czHM3DN87j1K7JR1YZf80ZHH3Bi7dUkp5Q0Pl1HVASuFMCANSV/yz5z5BGSEVo7oWkp23qj/ZCtakIU31sU+DuCPx7oSUIBALBliGZ2iS27yclEAgEAoFAIBBsGZKpnYhdZ2VHnz9S/BVnYsOxhFlZdw7LvqaysVz8pexgUoKjwo61YBXH4kzsrChc5rH5XrmMa1EonBzPcHI8A6BwfDTD0ZxlfRVwZK9Fxx4f+TiAoI/alMnUBnh0MsfyeA7ANJncYx8vK53M5FY1/SU9c1lpLiqrqiY+mysnJOvK2gJoicc6fWzZH/JEu9ikj20OKvNzJBAIBIINQCy9shCh2MT4toVgSqnBQq9UfKz4q+tYpdpCr1j8xUVfcR/3lOULHhJccdEXXyRTn4LCpz8fxmdF2EdtpRQ+8/lQ6FUo4DNf+LI7ltocvI/afFFL1zTGuHvxRS31GXhRGS1a68oE3rfUpjgXklWlGexp2+tjy0RjhG352MZtgUAgEAh2DRGKTYxvWwhGGdrJ508Qf3HRl4sz8RcXeqXEX1z0xfu4p2ycxWvEXbztM7VAKOh6dXUWLGrjvldXZwCa9svLMz9We8uXl/5YHifwvpeXZ8Gi1seNuxdf1Pr7w42bMrV1xYRoTFTmF7X0rC7csUM8bXt9bBNCsm352KbaAoFAINgSRLuQhNAPRmBfKQecYrCO+KsZQzye9jWS1034zHLKAaca0DncO5ZTDSg+Kwr7VeFoXjiqgb06ZrPms5jPFKMXAMdHCsdH/jkWSuHR8QyL4xkKhabNfGqVUnh8MsfyuCljG8crbfDouMDiuIAxBidEL6hIfFU4eoLWuiVEKwrvg1tVXhRH//mqSrtn3UVFANASj3X62AJJKsJQbIKKIBAIBIL7D6XU9wP4owBmAP6kMeYPZo77TQD+DIC/3xjznU2PQ+gHI+Ix5WDT94opB2N8Zn1fm15AiGkGQ31meTtFLxjjM8sXtSnvWAVPP6At/ZhqQOMkSsB8phi9gFEN2KL2s1/09ANqE5RS+JztM8a04lWt8VmiJBjjrk+LWk5PqGtPRaAMbq01oyQY9yx0Vds+nSyzG1MRgDV8bCeU0eXtIT62Qj8QCASCHcBgrzi1qqkk9BMAfh2ATwB8Wyn108aYn42Oex/AjwL4K9sai9APRsRTlINN3itFORjjM0vIlbZN0QyG+MzydopeMMZnli9qXV+CasApBSmqAacZzGe+Tdd/eXkWZGoB4MXlmaMivLg4dfei415cnLrFI49XdsH34vLMxV9engWLWuqjxd+rqzO3qOU+uBWjIpjaL2rp+fVRESb72E4oo8vbQ31shX4gEAgEDw7fB+DnjDE/DwBKqZ8C8IMAfjY67l8C8K8A+N3bGojQD3qwbcoBgNF0A2B6adv0/e/G3YA8VIEwQwvA0Q2abfyQatAc52kGs6LAMdETlPWhnRWYWTqDKhROTuY4Pp5hbqkGi2P/o18UCu88mmN50vS9+/gIq0dHbqFXGYPHj46wOGlK4z4+OcLyeI6y8JlYGktVFY4KQSgr7dwb5nNfsrdC47YwBwJHBPosgs9Yb8ZRIOVdy597vLgVCAQCwb5h5+4HHyqlOFXgm8aYb7LvvwTgF9n3nwD4VfwCSqn/EoCvGGP+j0opWdQKBAKBQCAQCHaOK2PM16eerJQqAPwRAD+8sRFlIIvaDLaZmQWmicK27T1L5yWvlagIlhKC+XPC7Kx7sRtSdpZnZXkmd2aPLwqF+ax5zWymdk4+tTYje3Q0sxnSRhR2cjzDzH6Gs1mBd2x2dlYoPH50hNuTOePnNtnZxSOfqV08mjsqQFVrvPvoCMuTOWpt8M6jORYnc8xnDX1gVSqcHM1xPJ9BKY3jowJHR+GHRO+PZ23JW7bW/ll6oZeCMUwIZl0XCjOx4hgNZOIf91MqjgkEAoHgQeAJgK+w779s+wjvA/gVAP4ju+b5AoCfVkr9wKbFYiIUy8T5onYbY53iQxt7z3Z5y471nh0qBCPE3rMkfuJjTQnB3EKSec8ezYukD23KW5boB/NZ4QRds1nhhF5HM4XPfddXXD8d++GXfN9H1GaL2o+/9N1u7NSmRW1ZaXdOrTU+tNcvy2ZRuyy1u39Z1U5Utiq1O5+Lx3y7OZ/72NZV7du1dp8XCcHqOvSu5aIxOo5713LRWNMIxWFJH9sO8VfsXStCMYFAINg9jNmrBMO3AXyvUup70CxmfzOAH6KgMeYlgA/pe6XUfwTgd925+8FDEorFmdpNj3WKD23KezbnQzvFe3aQECwaTCwEI6S8Z7kojPDq6szZX3EhGB0Xe8vyTC3QCLpo8fri4tQtep9fnAaZWgC4Pj91C9nrs6dBphYAnp09deN6dvY0yNQ25z9FbReH1+enqCrK1Gp3/9Ie++LyDKXtp/O5eOzV1VnSx1Zb8dib63PUdiH75toLwWhxy71ruWgs5V3LRWPcuzYlGqPzY6EYIeVdK0IxgUAgeLgwxlRKqR8B8BfQWHr9pDHmZ5RSPw7gO8aYn97VWIR+wHAIPrRdWIdykBOBta6lvPgqphw057XPj0VhQJtyENMTSEw1nzfPi6gHR1Q2d95QDuZHjfjreF7gyNIQTo7nOD6au8XyrGjEYY+OZ5jPFN59NMPtyQxzO9hCAe8zoRi1KblZao33Hs+xeDRHWWl3rdJlneuG8nA0Q1OGd46TqAwvF495ARxBYzZvvGlhwtK19HnR52A0Jv0MCQQCgeCeYA/L5BpjvgXgW1Hfj2WO/Ye2NQ6hHyCkHGxzrHfpQ0v3z1EOhpbBJW5lTDkY60MbUw64Jy3QLGq53yxt6R/NrWPA3FMO5oVylIDjo5mjGhzbheWsUPj4y99tz1f4vG3zRS31Ab7tFrW1duevKu3oCZShXa4qd/9V5akIy1XljqP3wukHK+ZT63xsV3VQRpf71wKhd21d10I/EAgEAoHAQugHrG9K6dtD8qHtoxwMKYPLM7VASDkY40Obohy8ujoLMrVA6Df74vIsyNQCDc1gbuPPz09xZBey1+enQaYWaCgFRE+4On0aLGqpj3B1+jTI1ALA1dlTRx94xtqrVe3u7+gHF6dYWs4t0RBeXp4lqQjU9/rZOerS0w9S/rXcu7a2VAWhHwgEAsEDw55lavcFD55+8FB8aFPnpOgFyWtlfGj9OcN9aGmhGVMOuNNBM2blVPzzQmE+KzAvlFvMHs8ab9rjWePvenLc+NAezQucHM9wfNTE6dh3T2a4PZ7hZFbgg+PGZ5YYADNV4NMnR1hZ71pq15aIX+kCn7J9y5l29ISFdT8olHdUwLJyVAheEIGoFNoUznOX3A8KRjmoVdoJgfi1/OcidkIAMKoeeM6zViAQCASCQ8SDX9QKBAKBQCAQHBSkUE4SvYtapdQ3AHwDAB69/9mtD2hXeIg+tFnxV2YwqmMwY3xog7i7Nz2bMMbdDVx21nrRzmaFoxrMZo3wajZrRFfHR/brvMCJzdKezBoqwqO5wrtHM7ydF3g0n+G94xneHs3wyPJzjwrgc4+PsHo0h1LAh+8coXw8h2UFYFFrfIq8acsK7x/PcHtUuPcHVHh0XODkuIA2M5c1NvCZWvLU1Vo7z12tqYqXf3ZcgFdEorEh4D8XlN0VCAQCgeAhoHdRa0uhfRMAPvOlX2rui1BsiA/tOmPdNx/a5vpp8Rdvu+1/5kPL40Q/GONDy4VgRD9QSuEztm8+G+5D6ygFTBB2cjxz4q2To8IJvR7ZRe3jowJf/MpXm/Z8hu/6btu2/NvjQuHLX/2qHRfwla9+DQDcovamqvEle85NWblrvV1ZS62yckKym0XtPG0Xy7L5uqrde1msavdel5aLu6pq9/xWK+1Ed7oKRWMAUFfeuzb2rAUawRgJxapKdwrFgFA0Rl9FKCYQCAR7jD10P9gXPFih2FAf2qlj3Ucf2qz4i7VdJpX50BK4J+0YH1ouBPNWVl4IRgvZIT60JBTjgrBjW73r2dlTt+i9On0aZGoB4OLpE5edPWdtKv51+uQT99xOn3wSZGrpnNuycte6KZuF4G1VufvfLms7rqfO/YAWr414zIvGViQkswvW11fnzlHh9bNzmLotGnPetc8vkp61JBhrhGRNX04oRuCiMRGKCQQCgeBQIZzaDWKqD+1QTPWhHXTdDlpCsCU+xjOXKAXs5eKKvTiVgYRl7FnOZwpHVCZ37r1ej21pXKIdHFnKwaPZrPlqF7PvHM3w7tHMff3UyRw3xzOczG8BAMfqLT51fIQ3R1coVIlPHxu8PTpDrU8AACez9/GZkxqL4xpzdYRPnRzh9vgIQJOJNZjhsaUzVLVxVIiqoqy0du8lJaoDOFXDv3j53FR9223/vAkEAoFAcEh4sD6126AfTPWhJfTRD6b60PrrD/epzZXB5YvaLvrBrCgC79muMrjck5Zstjjl4OSocKVvKUP76HjutvlPjgq3/f94PsMXvmLbNgX77pGnHLx/PHdUg0fzt835xRt899fIE3eFr37NesbqRwCARf0pfMWe86acOyrCY0sveL2qHeXhZFE5KsTb29L1Oe/asmL0A/K5rYPSufQsefnc0mZ9Of1AawSetYDQDwQCgeBBQOgHSQj9YINjnepD687voR9M9aFtn9/vU5srgxtnanP0A045mLF2qgwu96R1pW0Z/YDoBc8vTjG3lAGq2PXs7KmLX509dTzay9OnQaYWaOgDb2z79MknQaYWAJ58copClbbtM7VL/cae8wRvy+a/zNmTJ3i9ao59aykDV6dP8WbJqAiLpn1r+15cnLqCCw39wC9q6fkEnrWsfG5laQ+cfkClv7lnrdAPBAKBQPBQ8aDoB7vwpJ2CoWVwpyJFK+grgzvkml1lcPP3ajsicE9aGs5s3vjPzuaNy4BSCgqewsApDTPlvx7PVONha78CTfb23aM5Hs9neDx/jXeOXjZfZ88BACe4xgfFEq+KS2B5i/eWr/Hu6hnw6B0AwFv9Md47muOd+RWAD/HeUYV3jyqUulkgr2qD46LAUaECKsSKFYpw76XW7r2mnkXgWQvvXuDK5Bp4d4MdWroYyQoIBALBfsBAMrUZ7NfqTiAQCAQCgUAgmIAHlandFrYt1JlSMWwUEp60sTiMXkPHmhKHAb4kbSwOK1i2NnXN2AeXnz8vlHsVCpgVzX3IKeFkVuJktsLJrMRx8QYnxavma30FADDXvwgzfwlz+QLmb/8C9NP3oK/eQH3P9wAA3v24wHszhXdnV6j0Y5zMXuO4eItHs08DAG6KuhGyRVljl1VW/sXf6xC74G1CGwOtzcariRkxBRcIBIItQiy9cnhQQrGiKLYyVr4QmyIU44vFlBCsmKnOOL9/l/ds3OeFYEVCKBaKw0i8RIjFYdTmnNiUTy0t9GJxGPekbeKhN+2H30WetM2P7KNjJg47mjmh1rtHM+cj+5499jMntRN6vXc0d0Kw97R1Lzh5ja995XNN+80zfO3z7zfP4Iuftl8/wte+1oig3i2/iO/+WjOWd5ZNMZL57crd82RZedHYbcODvbldOaHbyaIKPGvpa0ooVq60+1xqy8Wtay8Uq0qzllBMaxOIxlxfQvyl2QTaJxSTRa1AIBAI7gIPSihGXNpNjzXOLo69VkxjjYVicaY2ForFyc2s92yi7831edKTNiUO4/GUOOz11XmQqQXaPrV0bEoc9uLSi8rIuuv5xanjxj4/P8WxFXqdHHtvWvKbvTp9irf2vIunT/DWLmoXx82C7/TJE8uLbYRg72rK1L4AAHxy+gLmqhGFfXL1Bur9pl/Vjfjpk08u8bJsHBGefnKKV6tGaHa9WLl7vrYL1avTp3jrhGKley/kY/vi8swJxJZlWihWrnxb17SotUKx6wsnJJsqFKMMLReC5YRiMae2Sygmi1qBQCDYMiRTm4TQD+4IY0riTkFKCDaqTG7HdQG0xGG+ZGwKoTBqCPiWvSJBGRs7F5cpKFg5WeB/SyV1ldIoVA2lNOaqxFytMFclsGpcD8zP/22YV+/BXL1B8Xv/LAo0ZHP9h3+wOf+Dj4DbR8DiLYp5iZlaoVCl+2OC33Pb0NpA1yZbNrcvPgZGa2itsyIxo4178e8FAoFAILgLCP1gA2OdQj+IPWl9fDP0g5T3bM6ndgz9wC1qGeUgLokLhPSD2axwJXFp4ddHP4i9aYl+8MhmX3PetO8e+5K4nzo5at7n8RJf+WoT/+AIjn7w6KbJyuqn7znKQQHga/YZ6I/ea/q+9Dl87avNz/2roy/gq9bT9p1l81ke3S7dPY8W26UflKu606e2LrWjH2hj1qIfxJ60BE4zeIfF3xGfWoFAINg+pExuFkI/2MBYp9APUp60hE3QD1Les9kyuSPoB7HP7Osrfw6nGoT0g+YCLy/PgkUt9aXoBylv2uvzU+dPm/OmfXvkS+I2Vb+AN8cNPeDpk6d4PW/G++STc5zcPgMAaEY5oMT5JwD0ZdNfPGmO++TJM7yen9nzz/DSLkqfM/rBy+V26Qel9bbN+dTWtpzu2xcXMEQvmEg/SHnSEjjNQHxqBQKBQLAPuPf0g331pu3Dtkri9kFtaA89R3Xooz6sQ42Ioa3PqzEFtJnBmAKVOUJljlGZI5wcvwsAUN/zVagvfhrq/RfQf+gHoD+07gdf+1pzoZPHwKN3gZMb6OoItTmGNkcg0wBt/GvU+EYcn6ITGGPca10MpSvElAOBQCAQ3AFkDk7isFZ6AoFAIBAIBAJBAvc+U7stKBIpjUiVblscNgoJb1qOMd60uwRlFI1p/FWNMTAw0Gi+Vkah0kBl4Cpu8exsqd/FSr+HUr+L5fzTAICTzwHq4w+hVldQH3yE4kufaygHj5pM7o35EG/N53FjDFbmHaz0e1iZd7C02/PaALW2X41BrY37CgC18S9tx829YbU2yReMFWmZfu5Ub+bUXqLPmzYnDpPMrEAgEAj2HfdeKBaLwzZ1faXUYB9aP5a00Cs834vDuuJKtYVgwHChWCwO8/2+uAH3ph0rFDuaF65PKeWEYvOZv35KKHZkObNHM5UUih1Zfm3Op/bxfIYvWtHY+8fNsR+czPGVr34NAPDO/Dm++6vNtd611zqp5vja1z7fvNHVjROF4XEjHnuLLzhx2ZvyC0509mhhPXMXlROqHS9LN66Tm4ZLe7OsnOfu7aLEZ79AQrFm4bhYVkmhWLWq3edSWa5sXXmf2ro27ueRhGS6NmmhmLX/isVhXDTWfNW93rM5cZgIxQQCgWAHkDK5Wdx7oVhKHLaJ61OGdsy1UuKwnFDMi7oScSYO46IvHx8gFEuIw14/Ow8Wtan4UKHYkfWLfXV1BrLyenl5FixqqY8Lxeg8Oi4WirkqYRmf2hPyqT19ghu7QH5rF7enTz7B49krAI3P7GPrWXtSvQAAfPLJFVA23rOfPHkGPFoAAG7s+3vyyRne2sXj0ydP8HLZ/Pd5vWwEYZenT/Bq1bSvzp7irXU/uLV9zy9OsbDHNkKxZlJa2ngsFKutgOzN9blf1JJP7fML6Jp50tKilnxqY6FYc4ukOOzm5aXPgCfEYSnv2S6fWoFAIBAI7gJCP7hHmCrOmnrdFOKyuGPhBEuz7uto7V+VNu51pJttf60NVnaBuKwKLCqNZWWg8AFuq09jUb+FsYvtsngXr4sv4E1xguJRhbePv4CbR++j1ifN+fp9vC0/xk1V4aY8xpvyGDflMW7LxvVgWWss6hrLWqOsNFZV85WKH9SVRlVp1JVGXRtUtbGLU79QNDCt98WpCMQWMDbWfNXu5a7DaBn+Gvln7a6fOKhPFKZhqRQ0dtYWCAQCwbYgll45CP1g4vX3kX6Q86FNlckdQz/gVAN+rxT9gDKtvDTuGPpBn08t0Q+O555+cHJUOPrBO8yz9rG1/Xr/eI4vfXfjI/t4rlzJ3EfzJmt7XLxx3rOFqhzVoNZN9bBF/YGjHLwuH+HL9lqPrJXX61XtvWkXFT7+UtN+e1u6Pkc/WFbufZc2+7pYVe5Zrlba+QNXq8r71NoFclwal34eaeEZl8altuPUMvpB7ElLyPnQEqhPG4N3Ps3oB58W+oFAIBAI7g5CP5h4/X2kH+R8aFNlcsfQD3hJXHevDP2AL2qpbwz9oM+nlugHdJ9nZ09xbNtXp0/x2LYvT5/gkW2/PWp+zM+ePMEj6497+uQJTmavm2sVDcHgySdnKFTl2j5T2/jVPn3yFG/LE3etV8tmUfvWesdenT7FG0sveHb2FLfOp9ZSDi5OXcGFl5eeakB+ta+vzrEqOf2gOe/N9bmjHaRK4759fuEWtanSuDcvLgOhGBBSDnJlcFM+tDxOWdnbV4x+8EroBwKBQLB1SKY2CaEfCPYS3DFg5rbIDWrVLKRmzEWAOw6U2mClNUptUNiFoEKNN6saN2UNjQJvS42bSqPSjRBsXryPV6vvwpvSQCmNl6sv4XWpUOtmUbyoNd5ZHuPV6gi3ZYlXyxJvViUWdoG5qGrcljUWVd3QD0pLP7CTTq0N6lo7WgS9KFPLHQlyW/7c9SHlTZv0mdX+RYvZwF0hgbGUA4FAIBAI9gVCP5h4faEfbJd+MJ8Xbsv+eF44+sHcCcVmbps/oCLMPRWBKo09mhf4LksZeOeocFSEExufF8ZREpTSrl3rJn5b1e6ct2XtSuK+tRnWR6vK3f9mUeOjLzVjXSw9/YCXxv3MF8IyuV2lcald2mO544HW2rsflH6BzB0P2u4GJuluQPSDvtK3XZQDoR8IBALBDmAAU0tiIQWhH0y8vtAPtks/mM09/eDYLmSfn5+6RS/RE56dPXX3vDp7ipOZpyJQm75ePH2CR/a8s6dPcGzva0/H6ZMnUEq7Ns/U0jm31pHg4ukT3NiF5NuSUQ5sGdzr86fO1SBVGvfl5Zkrj9tXGvfN9bkrj8sdD2gh2rgf2EVpwvGAl8TllAMCpx/0lb7toxwI/UAgEAgEdwWhHwhGoegpNkEFB3JOCbonTosywygHWvktc1UQd9S7CBTKt1fQWNXaOR8QFpXGstaojcbrVYW3qwpLu6gtlMKjRY2XdvF5cmvwYmFQ21VhqTUeLyu8XlZYVAaPlzXerBrHAwBYrjQWK43lSmO1qrFcVVitasePrbVGpRs6grZUCaIc0DNJFVyoa0tbqI2rv8AdDzhVwLhFa7fjQfCsWaGFFN2gj2oQUxm6aA0CgUAg2CBkrk1iz+pFCQQCgUAgEAgE43HvM7U8s0VUhEOFUlSe9+7GQNvYfRlbnsVLZWW5H6tSXvRF1+XnV4X1oTUGsNvshVJOfAXmDQsUKKsmc2vgy9jeVDVuK42ZUni70rgpDeZF7cbzeFnhjaULUNveCrUxeL2q8bbUWNU13pYVbqvKFU9YlTY7W9YoazuWunk1ceNepR1nWWn3LOvKuFdlPW2rSjfvvyafWp/BphePu8xsJA7TUVY4VwbXfS6Z7CzPwEpGViAQCO4QxqqoBS3ce6EY74tFY+tc/y6EYrE4bB+FYnSvGROKzWaFE4rRUIpCeaHYTLnSsSQEU0o5oRgXjc2d5dcMH1pB1mxWOHEWF40Rf/do5sVjc6Wcj+2cPRfq4+2KvF+Ncecvq9pdf8EqgpGQbbGq3ViJU7tYaff+V2UdlMQFQnFYyb1po5K4TV/ty+CykrjEy4UOS9+OLYObE4LxRawIxQQCgUCwj7j3QjHelxKNTb3+XQjFUuKwfROK8UWt72su9vLyLFjUUt/MLj5fXJ65hSY93xcXp4FobG77j468dy3d65qJxp6dPXXXPSq8eGxmz788feoEYoTL0ydBm2dq6fyV5dE+O3saZGqBRshG4q8XF75Nx728PHMLWV4Sl4vDqoQ3LS+JS+VwG6GYL4lLx5IfLReHjSmDmxOCxZlZEYoJBAKBYN9w7+kHgn0AbZ8bkBNCEOWlXY1dVMP7sXLRmGnWsqhrjaqmUrRFkopQ6+ZadWFwu6qxKGvMZgq3VY1FXUN59gEelxXeljUMGouuN2XttvzLyuDRosLbZYWy0nh0W+FmUaOkRWtZ42RR4XZZoaw1lqsKy7J2jgVlVTfUhKpGVWv3tbI+t7quUVc1dF3DGPKibZfEBdCiJNBzI8SUg6FlcFNisF5P29q/+PcCgUAg2B4MkPUSf+gQ+sHE6wv9YDj9gHvWztz1Pf0g9qylOPeupS39I5t9nc1C79oUFWHGxsIpCdTmtGCiFxgDF9dsUUvXXJW1uxdlaDnloKxqR6Ug94PFKqQc0HOjRW1cDpc+97gkLtD40Tr6AfekpUxrNa0MrjZteoHWJkkpoD5TA+98+vOs//OtYwUCgUAg2BWEfjDx+kI/GEM/YG3lF7WApSQkPGtpyC8uvDfti4tTx5Ol47h3bUxFiMfCKQlXZ09bOeOr06cuX3l19jTI1NL5VAXs+vw0yNTS+Egc9uLyzGVqKc4pB6+fnbtFbaoc7pvri2RJXPKjffviIvSkJUptPa0Mbpyp5ZSDFKXg9tWly8oK/UAgEAh2CAMRimUg9IMDAt+a3qUDQp+TwahrGd/wW9sqcEJooOw2OqC4E4K/kqUcNC4Bq7KhA+h5gbJqXAgKSz+oVJMtXZY1ikrhZlljsQz3yd8uatwua2hj8Oa2ws2iAiUv61rjZlFisaywqjVulhVuV5VbYJaWUlDWGmVpy+SW2i1gtTZunFXlX4YWqsyPtq4MqtK6IdS1e9ECNKBqcE9a52MbUg5ip4OYchA7HeQoB5xWIDQDgUAgEOwjZFErEAgEAoFAcCgwAOq2TkIgi9rJcCImYxwVQZDGmEyvq4wFOO9aaDghmBdFFShtVTFVwPnYmqrJ2FZVDcUIBlTlqyiU85Tl47u1mVh+bOV8ZLUTgtXaYLls4rX2PrRUUaysapcVpmznqtRYrZoMrqlr6KqGqWtUVVr8xQVy9Kpd1jfKzjJPWiDvQ8vdDSg7m8rK9om/jL2/YZnhVFsgEAgEgl1DhGIbGCtf1G5TKMbjsWisuf52hGJAKBqjr0OFYgACz1qg4cx6oVgoGmvi3ru2UF405q7PxGNF4T1tZwr4nBWQ8c+FRGVFoVyboLUJ+qjtfGor7a5f19qNpWKL2pQPrVv0rjQ+9XHzfHVVu2dNi9rYj5Z+rrgnLV8Akzgs9qRtjqsH+9CmhGB94q/mnHRchGICgUCwCxhxP8hAhGIbGGucqd2WUMzFry+SorFtCcV43C1qRwjFwngoBGuEYm3RmPOpvfTishfM55aLx2jMzy9OYXVgeH5xGmRqgUZURvd6fn7q+mlByPuen58GmVq6V22PfXF5FmRqafzch5Znaun5EY/2zfW5X9Qm/GjfPr8IPGl5phZofGhTnrR0zhAf2pQQrE/8RZnYxasr15drCwQCgUCwSzwo+sF9Kpm7bfAytkMelQFVrPJ/PdbaoNbGLXDpSADQRkEbKxyLRGMAUBRMEAVGRaCFqvWorWsN1GgoB2WNWiksrViLL+apdC1qLxrz79W4PmMMbpcVFqvKidpqrbEsK6yqGlVlj13VzPJLd/rQxpQDetFiVtcGdd1QEOqqdq8xZXBpMcspC/x7zT6fPiGY69PdlAJDXsLwIjaT8LsVCAQCwQYh7gdZPCj6AW/zRa3QD9r0AwBuyzz2rKWvKXqCgo9zb9qYnqCUCkrncioC3fMznH7A2nQc0QAAuDYvr8vf9+fYsbwNNAs36jPGuGu5LX2t3Viqyrg2ZW3LSnf60MaUA14GF8hTDsaUwa3YovYdRj+IfWhjygH3nPV9n2fHtikF1GeMweNP+ThvCwQCgUCwazwo+gFvx5laoR+E9APel/KsTdEPeJt706Y8aynjykvncioC965NURG4jy3hxcVpUF43ft/xsQRavL64OHVCtBcXp0GmlsZCC9WXl2dBppbeX8qHNkU54J60OcrBmDK4PFMLtOkHOsqkx/SCOFN7++oySTUgLF5duazs4jWjH7wW+oFAIBBsHcKpTeJB0Q/uGrzsqdoC+yHnMkALmWCRZ6xCfuJg+NZ30eP+QDSEmv0nLApyOjAtKkID710LNC4HdW1gCrs4U6rZ4qdsqm0Xyjsl8PuVZe0Wn9TmVbTIZ9YYg5Vtu0yraXizq9JA66YEb0Mz0O5ZcMoBvaioQl2b5p5l41VbW+oBLWY55aCuiZqgoTVsKWDjFrOVjVd18/lV9ryUu4H7nODpBjl3A04xIMpBTC8gCM1AIBAIBPsIIZYKBAKBQCAQCA4eDzZTq+2W8iYEY7RlvUm/Wi4SWreK1xhQxi+mIfBxAegdU583bRgPs7ZAsyVf2Veh/PFOKMaytwBcu4ZpRGGVdhQGreH6AN/mYimqAqaNwdJ6ylK8poplVry1qmqXrQWAujIoVxrlSkPXNapVhbqs3NjiKmEkaqNnHWdnUz60dC/uQxtXB4ufK//eZWYzPrM885rMzgZVybwPbq4tEAgEgi3BAEaEYkk8WKEYIfauXWesSqlOoRjvi0VjPt4WkhUz1epLCcWAUBw2VEgWi8aaPpUUivFrcfFYHI+9a7lojJCK8z8MuoRkgO/LtfmiNhXni1ou/qKx8EUt9571QjC/qPXiLy8KIxuuqjTuc6/r2v3c0KK2qrTzns350HqfWh14z44VguV8Zg2jYqTEX3yxmhOHiVBMIBAIBHeJBysUI6S8a6eOlRZkQ66VEo0RYiFZW+iVFor5+HlSNJYTkqVEY5SpjYVi8bVePztPisYIXBzGRWO5OCJv2ZyQjMdzbb6oTcVjWysu/uI+s8TN5X2vr86DTC09C81EYTxTC5DfrBeC8UwtANy8uMj60PJMLRB6z44RguV8ZuPMbCz+ijOwOXGYCMUEAoFg2zD+F5sgwEj6Qdv/Mm67I21fbht7X3Co3rXGUKleYIOshyT6PGv7RGMpb9RZJGTjVARCSkim2ZZLip6gje8HU/S7PpiAOkD3p77atjk9IRaC8ZK3QJNFLVcVqrKCMVaoVhu3mK3r2r8qjbrUqCvtSwIzyoGuDXTlqSdcFAagRTkYKwTr85Y1jtqQphSY2rgX/z5uCwQCgUCwa4yjH8yOHP3gPbb1/l5iy576VKH2mn7A+8aW0b1L+gFv8y37bdAPgNCzlq7VVUaX0w8ADC6jWyToCdzTliNFT9AGnccaY4L7As2C0tMLTKvMrdYm8J7lJW+bPu89a4xxn0tV+kWt86EttfehZZQBRz+oTOhDS/QCtqjllANe8hbIl7l18R5vWaN1d7zOny/0A4FAINgBpPhCFuPoB3U5mjJAmdp9pR/wvilldO+KfsDbcXJ00/QDAqciFLm4atMLeLu/jG7qfO9pGyOmJ1AyOHcsVTTj96UF36ursyTVgBaf3HuWl7zl3rNETX1zfRFkagHyoW2OffviIsjUAtZ7tvbes3T/m5eXQaYWCCkHvORtrswtz9QCecoA3Scbr7vPF/qBQCAQCO4KW3c/iMt2xv37Tk/YFu7CszbrSJDwrOWfW+ozynri2oVaoVTSyzRVRjdux/fg7ggcnp7QnE/3dv38XnVDMUnRCwA4RwNONXCc2oy7gYvXofdsudKoSu2yqzHlwJX/rfwz45QD51gQOR0AaFEOprgbuOcXUQ2AbnpBF4x9T1xwJhAIBILtIF5TCRocDolUIBAIBAKBQCDI4M59auNM7l1mcNcVjfFs1aY9a4G8Nywlx8bcsitr21ws/f4pqccfT58nLdDOFObO4dlanr2NhWY84wog2ebH83ittRO20bVJkKU1XEUwohc0VcBq6LpusrJWCOboCdYjV9cmqA7GM7m8Mpiumiwt3b+u6qAyWF3V0FUNDXsv7d+LqYG6NKjLSBjWIwRL+czGWdnWZ5bJvvI+yc4KBALBjiGc2iy2LhQbG+cCM8JdCMn4onaKqC0Wjbl4QkjGF4gpIRihmKnOeOxdy0VjcV8cbwvFCiYkC0VjNOYuoVhOSKbQFoIVkWgsjseiMiAUdPFjeZsvaqnPwIu+eIEC34eWEExrE3jP0nN3ZW5r44VgVe2FYK4whE56z9L9q6rOes9uSgiW8pmNRV+tuDF4/EEizvpybYFAIBAIdo2tC8WmxLnAbNv3ysXjTO1ogVxCNJY7P06KxkIxghd6hUIxQsq7lovGeF8qHnjeMvFYSjSW8q5thGR2UZvwrh3iY5uKp0RlXNDFj+Xt2IeWx19fnQeZWho/rf24EIzi3Hv2zfVFkKkFSAjmRWE8Uwu0vWd5phbIe89uQgiW8plNib6CuOmO97UFAoFAINglehe1SqlvAPgGADx6/7NbHxChr1zrtrFuGd0xVISeHX82pmmlc4eWts2Pry0ay3nXuoVkgdYWf+xjSwuwlI9t3M/pA3E8bvPteqDJeNZaOz9dTjWg91dXzSslBIu9Z3nJW3++pR1EJW+B9bxnu4RgxtIT+HvN+cxyioGjHfTQC4y2x8UiT9aXawsEAoFgWzBCP8igd1FrjPkmgG8CwGe+65eaXdEPCLHP7T6V0R16Lb6o7fKxjb1ru3xsYyoC3SdFL/DXz9MTuugH/Fj+R8bQMrrNsW0fWk5J6KIfxO2uOKcXEEJ6QUg1AJpFZarMLd/S596zvOQtnU8/t3HJW2A979muMrcx1aC5Vtpnli9qh9ILTC30A4FAIBAcDvaWfkBI+dzuUxndQfQCNYxKkfKuzfnYpqgIOfqBfy9pn9o++gGBUxF4X18Z3eDY6FlwSkKOfjAlzq/LfWZTVAPD+1iZW56pbfoukiVv6fymr13ydl3v2VyZ2xTVIOczG4vBhtALaFyLN4k468u1BQKBQLAFGLH0ymHvLb341mzO83ab4I4IUzFUIc69a6fdx5fOTWHINj8fjEkMJvX8ORWh917GUxKC66Z8VHn51o54QC9gJXurWrvStvSq2cvUNUxtXQ0S7gbuFVEO6EXPIqYcBCVvI+9ZTc4IVY1aN84Glbbj1No5G9SlgS7hvhr7UXB3A041SDkaBC+TeDF6QfBKUQ70+JdAIBAIHgaUUt+vlPpbSqmfU0r93kT8n1NK/U2l1F9XSv0/lFK/bBvjuHNLL4FAIBAIBALBCNT7kzlQSs0A/ASAXwfgEwDfVkr9tDHmZ9lhf8oY87+1x/8AgD8C4Ps3PZaDXdTyTNKuvG3X9bEdg76KY32iMZ61TenUshXBUqKyERXH+nxsHTJCstYYB8SDTCj3maX7GQ1d2ays9p6zKSEYf65EG9Ba+wxtVB0MQOM5y7xnSRRGrgax9ywXggHMa7ZuC8HG+szG4i+elXXHZDKxvO3cFLqyrtrYFL2hD8S3BQKBQPBQ8H0Afs4Y8/MAoJT6KQA/CMAtao0xr9jx7wKJ7dcNYG99aqdcKxaVEbblYzv2WrF37aZ8bIuZ6oxzTu9QoVhOVKbYYKb42PLrd8Xjvq54zmfWF/TQgfirSwima9+u2aLW+dCW2vvQukVtJASz7Yotaod6z+aEYEN9ZmPxFxd9xX1BnC1cH3/wcbLd6tMaj99nx77fPlYgEAgEm4XZPaf2Q6XUd9j337QmAoQvAfhF9v0nAH5VfBGl1O8A8DsBHAP4NdsY6N4LxcbEU6KybY01JSDru1bKu3YTPrZtH9rQxzbO1A4RiuVEZfFgxvrYxtfPxVN9uXjWZ5Zlamn83HM2JQRz8ecXQaYWIB9a235xEWRqgdB79ublZZCpBYZ5z+aEYEN9ZlPiLy76cn2RuCvOxvaJvxZvrlxWdvHmGet/1jpWIBAIBAeNK2PM19e9iDHmJwD8hFLqhwD8iwD+qbVHFuFg6Qcp5LbEt4EpVISpZXT7fGzXLaOboiKMKaObEvBpqEA8FnvaxpSELgFbKs5pBvz6wVjsWEN6gn9RJtZoOCGYMWHJWzqfUw60/QxpMcvFaXHJ2+ZZeMoBF4LxhWSOcjDUZzZHL/BCsPAjbNEL+LPvoxQIzUAgEAjuEHvnU/sEwFfY91+2fTn8FIA/vo2B3Cv6AW/voszumJK6cd+YMrqEPh/bqWV0eTtVUneMj62Ph5QE7mnr+6bTDzjNgF+fe85SdjOmHHhPWu2uRc/amLDkLdBQEjjlwPnQVn7BzSkHvOQtnUOUg7o0rdK2ALKUg6E+s2vTCzi9oYdSkIsL/UAgEAgeJL4N4HuVUt+DZjH7mwH8ED9AKfW9xpj/1H77jwL4T7EF3Cv6AW/vqszumJK6wfhGlNEl9PnYTi2jy9upkrpjfGx9OONTG2Wbp9IPOM2Ax7nnLM/U0vhTJW9pwff2uacU8JK3dA6nHNy8uAgytUBIOeAlbznloC6Z92y85Z+hHAzxmV2bXtA6v5tSkIsL/UAgEAi2DIO92i0zxlRKqR8B8BcAzAD8pDHmZ5RSPw7gO8aYnwbwI0qpXwugBPAcW6AeAPeMfsCxS3eEKSV1p1ARtu2IQNdo3kvoiBBv/xdF6GPb5Y7Av9cInRJiekI4lnw8phmMcTeoq6ZNC73Ye5ZK3rqyu3XjeVvXBtDe6aCq/XvnlAN6VVRcoUZAOeBUAzq/GW8NUxvosoYuLR+XUQ3ofetKQ9O9N00voGfKPrd48szFU8cKBAKB4P7DGPMtAN+K+n6MtX90F+PY++ILAoFAIBAIBAJBH+5tpjaFbQvJpvrY8mpjQ7O3Y7K2BJ59jauPxRncnJBrsJAM7ext09fOoMftznji+jkhmHHJyNB7loRglGHnPxf8WKInQPtXZauHVbWGSZzPq4Px0rZd3rO5yl/+c+HPYWImNnru2eyqtgIE6qsT2ddcPHWsQCAQCDaOmJImaHBvhWJ98U0IybqOneJjy/vGCMn6fGwJXUKyMZ62qb5YKMbjsais6/p9cW5tlfOedceS5VbkPUvPmC9qnRCMicKIXgANJgTTTgjGzycf2qrWThRGi9o+71nuN9vnM2v0NKEX/4OhU9xVGzxifY8S4q9cPHWsQCAQCAS7wr0VivXFNyUkyx07xcc2GN8IIVmfjy2hT0g2xtM21RcIyfj5CVEZYbRQLFI85bxn31yfB5laIPSeffv8IliU+j4vCgsytWh8aGmhe/PyMsjUAo04jHi0t68ug0wtkBeCcb/ZPp9Zd62xQq8ovmRx3qbjlm9Z/G1b/JWLp44VCAQCwQaxZ0KxfcKDoh9wbFtIxqkIhG0JyUK/0+lCsua+zdc+IZm7XkRPaN1Pm5aozI87ITTrifP7VVVDBegTgnHvWf650M9AbSkFda0b/1smCgPalAPt/GOb82PKAS95C4SUAxKBkRCMxsdpBlz8pUvjrMOaN26m0Qv4ZzOBMjCENpKikAgEAoFAsCs8WPpBKj62zO5YekFMSRh6Pl/UDi2zG3va+rilDKzhaRv39dEP+uJ91+dtvqjlNINUmVvNFrWcckBttyittPee1d6H1i1qI8pB7EMbUw5iH1pOOdBl3Vna1tQm8JZtlanNlKbtpRcw/tUUegG/vtAPBAKB4C5hgFr3H/YA8WDpB6n4lDK7Y45NURIG0QvUeKpEytOWwEvrTvW05X199INeekLP9XmbL2qpL1fmlmdqgZBy8Pb5RZCpBaz3LKMa8EwtEFIOuA9tinLAfWg55YAytLnStnRN7i0blKl18ZH0gjg+kl4QZ2CFfiAQCASCfcODpR+kkCr3ui1Kwr65I8S0hJw7AoHfPuVjy/vj9pA4pxcACNrx+Ph74e/bCcUiygG9aDGrNd0fLaeD5lmGlIOUDy2nHPhxeK9Zohz0lbYN3A1iqgGQ95EdSC/I+QdzDKYUZK0YBAKBQLA1GOTn5QcOoR/0xGNKwqZK7u6bOwKnJfQdS/ffFD0hdT6nF6TiXZQDXvK26QspB87dwJXJDSkH3OmAzueUA+50ALQpB65d+0Xt0NK2AeUgohrQ/dehFxg93d2g1Wc0Hr3Hjn1P6AcCgUAguDsI/aAnnqIkbOJe++iOwGkJrm8H9IRUm9MLUvE+ygEveZuiHLx9fhFkaoGQcsCdDlKUA+50kKIcLF5dBZlaYFhp24BykKAaOHeCifQCuudUd4Ogzw5W6AcCgUCwY4hPbRJCP+hBbrt2XVrCJt0RCDlKwlB3hCbOKABr0BN43xh6Ar9G6vpOfKWBqjSoK9NyN+Alb+nadalRVxrGmMDpoDnAv9YtrqB1HZS89WNPuxvwz6hFOYioBs1YzXr0giGUgTFxgUAgEAj2BLKoFQgEAoFAIDgUCKc2i1GLWgO0MndxmzAlnvNO3UdsQ1QWZ2/HispyJVZTGVwuqGruFSbfpmZyg2NZH3nHcvC+VJyLvygrm3qvOSEYt9TS7lgvCqNCDE6UNtGHNs7O8pK3zbM2eSEYmq+mqoGKFXOg1zYysfzQOpGI5R67I+KpYwUCgUAg2BVGLWpnsyO8++ntCcWKmdo7oVhXfIyoLNU3NM4XtdvyuY1FZ7HPbZfn7bbjXPxF6PKe5SVvAUAbk/ShpaIGWpu1fGh17b1nY1GY68sIweg+OfHXaKHXAPEW9ZkaePTeR4n4R8l2Xzx1rEAgEAgEu8KoRW1dl3j7gomQMu2p8WKCT+xdx8eIyqbeK87UbsvnNnwvzdecqCzVt604F38R+rxneclbOjb2oeWZWmC6Dy0Jwhavr5KisKz3LMvUAnnx1yih10DxVuM9a9s3iTjrGxNPHSsQCASCzcJEO5uCBnvFqY29U11/xzb3PlEW+raGp9ITuJhsCj0h5XPL21PoCXHfpuNc/MXHqll2s65q1FXtvifKgaMtkPtB1WRlddVkbXUV/pxtwoeWUw5iH9qs9yxf1CbEXymKSx+9IKYU9NEHYqzjYytlcgUCgUBwl9gr+sGUa8WUhbukH/TF95meMNTzdldxTi/gY+WL2tSz1jWjH7hFrXHes1qHbbrmNn1oc96zhi1ic6Vpx9ILYkrBWHqB0UboBwKBQLDHiIv3CDz2in4w5dgUZeGu6Ad98X2nJ+wTrYPTC3icL2rTcdv/4iLI1AKWckBUhJeXQaYW2J4PbdZ7NqYfZErTjqEXpCgFY+gD7p5CPxAIBALBgWGv6AdTkCv3GhyzJ+4K+0xPiD1veX/c3mY89V5iqkETC2kG3Hu2qq2TAlEbjKUl0FdNrgo78qGNKAdxadvsz0VMNcAweoE/NkFfADp/BsdgCFVBIBAIBJuHFk5tEsPd/gUCgUAgEAgEgj3FwWdqx2CMEO0usrp3lcmN213H9mV9h9yrK87fb5f4C0DSe5ZXB3Oc2ig7S6Kw2t3bdPrQGtgsLExLFObG2edDy7OzTAhmL5AUf+V8ZOPn05WJ5X2p+JRMrmRkBQKB4A5hIHNwBgcvFNtWvJipzvhdjHVbQrMxx/aJ0vjCdcr1+X/ULvEXgKT3LDQSQrC0D21d+0Vtlw+tMV4Ipst6PR9aJgrji9qU+KvPRzYWdcXx+FjX9+5Hyfa68dSxAoFAIBDsCgcvFNtWPM7UbkIotm58W0KzMcf2idLibOzY68d/febEX4TYexaszTO1QNuHlmdqgbwPrYEXf+mSedJO8aFl4q8gU4uUUMy2M0KtlKiLx1PH5uJ95w+Ni1BMIBAItgsDL3AWhHhQ9IMxGFIOdteeuet4iALrl/EFhtMLxoxVa4O61Kgrdj4TfwEh1aDpSHvPNmPxojAA0FZkpqsaGgZ13VAPXCY240NLi1ld1u61rg9t8FwSvIJs6doEfWBdIVgzZpO8l2dCDI+njhUIBAKBYFcQ+sEGx3qXnrlD4l30hU1SGYC8j2xqrJxeQOClbYGQatA0kPSeBdr0g7qqnfesNp5qwBe1KR9aZwkWUQ7W8aENvGfZCjBHOUjSBzj9YA36wLrnDzlWIBAIBBuGMVJRLAOhH2xwrHftmdsX76MvbNRnligDA87n9AJ3PittS+BUgxTN4OblpT+W+dBqawV2+/ISGp5qwBe11Md9aHmmFtiMD23gPRulNXOUgxx9YAz9IBX397pOxK+T7b546liBQCAQCHYBoR9sEGM8c3l7V04LXZSAdVXwcXzMszDGOHqBP585GoC1B3jPVpZuQOPRsMchOjbhQxs4HZDQa5M+tIyrEJQFrjkdoP1cc+4Fvi/+XNrtVLwTWgO1BmLuFu/LtQUCgUAg2DFkUSsQCAQCgUBwQBBLrzRkUbsHGCJK23Z80/eKs6+pTKyr/IUwK9t0+FcsBPPHt71neWaTqAZxdrbTh9ZdR0NXrOLYhnxouRBsiPirnaXtycTG2dUxmdZUXCAQCASCA4EIxR7IWPvim75XTujl4ro73iUEc30J71mjTSAKo2OH+tAarb0nLS1qN+hDy4VgQ8RfsfiqL45ab82Hti8uQjGBQCDYAQxEKJaBCMUe0Fj74pu8Vk7oRQi8ZdFu9wnBct6ztFDkorAxPrR0rcXrqyBTC2zGh5YLwYaKv3g7Je4KxFl2/MtbFmftVN8m46ljBQKBQCDYBYR+IOhFSsgFoJdekBR6uQPYi32vg2ukhWA+nqYccFEY0O9DyykHQRlcRwFYz4c2phzkhF8p8dckekEC/LMx7LMyic91ajx1rEAgEAg2D+HUpiH0gwcy1r54p49sRCVw8Q3RC4C2t2zcx6kGLp6hHIz1oeWUA1ObNv1gTR/amHIQl7bNUQqSPrIT6QV8sfnonY+S7XXjqWMFAoFAINgVhH7wgMbaF88dm6ISEDZBL+BxHWX6uN8spxoQcpSDMT60nHJAPKXF6yvo2i9qgek+tCnKQUgpSFMOkj6yE+kFcQZV6AcCgUBwmDAmTAAJPDZKPwi2nzu2prviY7e57zK+T2PZ9nuJ0UsvCA5mL3Ztohe4803ooJBzN2gu6cvduutN9aHllIPAk9YNNqAcjPWh7SpnS+NLOhrkfGLpfDbWVH/cHgv+XFL9XW2BQCAQCHYN4dQKBAKBQCAQHAwkgZDDuEWtweAsn+BwEGddff/0TCzvj7Oy/nrM53aEEKzz/BE+tC7DGGRnmUiM0QvW9aElhF60mQ8jkZ3NCb1a14+yq2Myram4QCAQCASHglGL2mJ+hHdIKNYlAlojvslrbTu+T2NZJx6LukZfKxJ9EYb6zAIYJQSj80kQBmCSDy1f1DofWu5Jyyy9tuFDG8RJ3JURgg0VepnabE0I1hcXoZhAIBAI7hKjFrW6KrPCoDEior74Jq8lY+2Pp0RdPp4RevG+nvP7fGbdsSOEYNx71h070oeWL2p9nIRgVzBVJATbsA9tnKld3lxnhWBDhV70nsSnViAQCO4pjFh65SCc2nsAvg7sowxMphSMpBe460c+swQu/mqODYVgzTHDvGeD78f40DpLL085CDxp3RsxG/OhDURh/OFbykEs/oqpBkPoBZ0Y8bmOjqeOFQgEAoFgRxD6wT0YK18sbuy96LSPLEcXvaAV/0xMP9BJ+gFfDA71ngWm+dC6eF8Z3FJvzIc28J6t/QqQ0wy2Si/QwMk7H7pveTvVNyaeOlYgEAgEm4dkatMQ+sE9GGucbR1EGeg7NkEpGEMvcPHIZ5bAS9sSONWA9/V5z7pjR/rQ8kwt0FEGt+L0Ak8/mOJDG3jPRh8cpxlsjV6ge+J95/fEhX4gEAgEgrtC76JWKfUNAN8AgEfvfWbrA3qI2Ap9oPemmLR1nCpjG48vHGvoM0uIt+ljdwO61xDvWbrXeB9a7hNrF6c69KRdB0kf2oS7QdZvNuMT6x8Q0p+bUAIEAoHg3sIYjKOdPSAUfQcYY75pjPm6MebrR4/f28WYBAKBQCAQCASCURCh2AZwJ5nW5EDQn6XrydzlMrFDfWYJqexs09/+6zIlBOPX7POeBTDJh3YbFcOSPrQ93rODxF86ag/5uaFsdJwBZn2bjKeOFQgEAsGmYVq/WwUNRCi2gbFuQqi1kfgIcVeuzd9L17VyPrM+vp4QDBjuPQtgmg8tW3Q+ZkIw7klLfVwcxj1pXbzLh7bHe7ZL/OXabP4aKuQy2uDkcSLO+jYZTx0rEAgEAsGuIEKxDYx1U0KtteMjxF25dsyRjX1k3a0S4q9NCsFcfID3LGG0Dy3P1AJYcB9a1k6Jw7gnbSgES/jQ9njP9om/lrfXrczsICGXvf5q0Y7zvk3GU8cKBAKBYIMQTm0WD55+EJeIHUMZ2Dh9IDvIqD1RBBT7ya5DL+DYhhAM6Paeje8/yYeW3k9MORhZBneQDy2NlVMhUpNSH4UkohT00QMEAoFAIHgoePD0g7hE7F6OlS1qptILgLaf7Dr0At4XUw2AZmH1DuuLy9wCCCgHnGrg43nvWSBPORjtQ6vXK4M71YeWL2o5zaCLXhBTCnZJL+iLC/1AIBAIdgPxqU3jwdMPUiViJ3u7biu+IXpDyk92Kr2A96WoBry0LYFTDVwfoxxwqgGPp7xnCTnKwSgf2gTlYEwZ3Kk+tHGmltMMsvSCBKVgl/SCvrjQDwQCgUBwV7i39IMxjgR3jg3RC4JLZkrXJo+NqAZd4BQDXto2Lg0bXJ+5G6TuGZe8be7T7T1LY0lRDkb70EaUg6FlcJM+tKlnFlEOWu4GMeXAnzieSqC1f/HvU8dsOp46ViAQCASCHeHeLmoFAoFAIBAI7huMwaAk1EPE3i9q1xFy7Q12mIntys6uI/7qE4K5e/QIwdz5iexsc137NcrOmvj+HdnZTfvQjgLzpM350LKH1UZfdnZIJlYgEAgEggeIvReKrSPk2nZ810Iv3heLvoac3yX+GuozS5gqBHPnM+/Z5ti8Dy0XgvnzQ0HYNn1ogVAc1iUU4560vT607Oci5y3bEl9pLUIxgUAgeOAQS6809l4otq6Qa9vxXQq9eF9K9OXiE8VfQ3xmfXyaEMydz7xn+bEpH1ouBPPntwVh2/KhJbR9aD2ntunz4rBBPrTx9TPesoH4yl5fhGICgUAgEITYKf1giHhrL+kDfdgCvSC4fKZ0bec5I8VfqZK2Pr6eECy4lqvC5YVgdDz3oU1RDprzfSY3Rzlo+dCuiTFlcEf70DZvJk05iKkGXWMM/H293y9vbzueOlYgEAgEG4bJ/z5+6Ngp/WBIOdl9ohcMHusW6AW8PbR0bXxOl7csb6d8Znk8phoQUmVuCTHlIPah5d6zTTzylo0oB2NK38Y+tAB2VgZ3rA8tXSe5jR9RDVpx1ub3EvqBQCAQCB4idko/GFpOdp/oBYPGugV6AW8PLV3L+1JUg9z5KaoBgZe2zcV5mVtCinLAfWi59yyB+9CmKAdjSt8GPrR0/g7K4E7xoc1SDhJUgyDO2nGGdLV4nmxvO546ViAQCASbhXBq0xhNPxhKGTh4SkEK8dbxhugF7vIdZWw7z2OLt3UcDcJjN+tuwEvetu6V8aH11xpR+jaF2PFgw2VwOeUgfX+kf1ZSx/dQDprnKFv+AoFAIBDEGEc/mM3xzqebbdQ7dxS4i7jeDr2A0FXGtuv8gJ4w0dFg1+4GvC92OiBMKn2L3ZfB5ZQDAG36QUQ54E4Hri9DOYi39E0tZXIFAoHgQcOglXASNBhHP6irnVAG9oleEPRt2Ymhr4xtqo9TDXJxQp+jwS7dDQiccsCdDlx8bOlbsDY9lwTlYJNlcDnlgBDQDxKUA+50QMhRDnibnutd0Qv64kI/EAgEAsFdYe+LL+wUuW3iDdMMgDbVYNA5enjxBI4cxcDHN+9uEF4/dDoA2pSDMcUVOqENeKEF17dGGdwxCAotpB47dzoI7UBalIOYajDo/uQGwWka0c/YtuKpYwUCgUCwWRjsX6ZWKfX9AP4ogBmAP2mM+YNR/HcC+O0AKgCXAP5pY8wvbHocxaYvKBAIBAKBQCB4GFBKzQD8BIDfAOCXAfgtSqlfFh32/wbwdWPMrwTwZwD8oW2M5eEuanXita1bGeNfI7OzwLiMrGZZz6lCMPeKsrO5saRK3qays4DN0Gays8212tnZ9PiZOCzKzgaisDUzr/5eTBwWe9LmyuC6C/SUvg3ef3d2lmdiW23JkgoEAoFg9/g+AD9njPl5Y8wKwE8B+EF+gDHm/2aMubHf/mUAX97GQB6uUGwD3rLb9JnNnr9GaVveN0YIxtuh0Mt7z3JRGB23KR9aAIEnbXN+KAgb7EMLBJ60NP5tlsHt8qGN+/qEYL1ldCFCMYFAILjXMHtn6fUlAL/Ivv8EwK/qOP6fAfDntjGQhysU25C37LZ8Znl7U0Iw3jdGCMbb8Vi492wgFNugD20Q135RC4SCsEE+tBbckzYlDttoGdweH1re1ycEo3uulizO2qm+XcZTxwoEAoHgoPGhUuo77PtvGmO+OeVCSqnfBuDrAP7BjYwswv0Xim3ZWza41USfWXf+FoVgvJ2kHCSoBrlxAWnKQXP9xP0n+NDG4+eetM2gMpSDPkSetO76yZd7AMkyuEnwn7ceH9pcaVvXF4m+1kHuZyD18zA1vg7FQyAQCARDMWxtsEFcGWO+3hF/AuAr7Psv274ASqlfC+B/AuAfNMYsNzvEBveffrBFb9lN+cwG5w+kD/C2ZgvFVJwvNHKUg9hnFrhbH1oA2TK49kZpygGwszK4/lmYZBncPh/avtK2MdWg69i+eDCWRx8m2+vGU8cKBAKB4N7j2wC+Vyn1PWgWs78ZwA/xA5RSfx+AfxXA9xtj2iVoN4T7Tz/YsrfsJnxm3fl62vlx9jOmFMTZsxzlgNMHXPyOfGiDuKMXXCHI1CJBObDYRRlc/yxYH/ek7fGh7Sttm6IauPhIekD8MyD0A4FAIDhMGGSLTt4JjDGVUupHAPwFNJZeP2mM+Rml1I8D+I4x5qcB/GEA7wH4d5RSAPB3jDE/sOmx3C/6wQ6cDJK3XXN7eOg2wibK3Lp7TqAcAG26QXOvzfnQBuNPlcHte1barFUGdwyC4gpdP3c9pW+Da46gHOTGLZQAgUAgEOwSxphvAfhW1PdjrP1rdzGO+7WoFQgEAoFAILjPMPuVqd0nHO6iVkftHXzA+yoE88etl52lMbWuO9KHtnOMPTYk3HHAZWeTA438aFMVwyag5UkLhBXNxnjSJkVxbVHYkOxsn9hPIBAIBIKHjsMVim3AZ3ZsfF+FYISc96y7fyQI26YPLYBAHBb70AZx5kmb9KFF6ElL75ULwh4x0Rj3pKWLcXFYlw9t7ElL4yMhWOxJ24wpFIeN8aFtnYO7E3qtGxehmEAgEOwGkqlN43CFYhvymR0T31chGCHnPevunxCEbcuH1vUxcRgXhQVx5kmb9KEFa9P4uDiMCcFSnrQpcVjoQ9sWh3FPWi4OS3nSpsRhY3xo+7xndyn0WjcuQjGBQCAQ3BUOi35wB0KwqaVtg2tM2CruK3MbHtt9/S66AbBZH1o+fvdKbNkHW/pMFJYeoAk8aQeDFVfg4rCYohBQDsaAFVfoKoObK32b9eRdR+jFKRn8+9Qxm46P/XwEAoFAMBoGMtXmcFj0A71dekEq3kU52HSZW94Xl7ztOn+ID63ry1AONuVD686PKAeteEQ54CVxm/PzZXAJvfSDKWVwgeH0A2YJ1lUGN1f6NuVja7RZjx6gDU4efY7FP4cY24qnjhUIBAKBYFc4LPpBwnN222Ppoxxssswt70uVvCVM9aF1fRnKwSZ8aN35CcpBEE9QDjjVoK8MLqGTfjClDC5Yu49+wDK1QL4Mbq70bZyp5TSDyfSAdc9fMy70A4FAIBDcFfaXfnAH7gbB7TfgPTvU3YAwlnKwLz608XvoHHfPc02WwU2+AZN2PEiUwR2FqCQugCR9ovP8Dk/alNPBKMeGIfQCgUAgENxfGBGK5VDc9QAEAoFAIBAIBIJ1cTeZ2ljwlWvvYihres8G15qQnQV250PblZ1dx4e2r2JY9r2kKoYlBx550o5ELA7zr9GXCn92+7LOiaz3ZEg2ViAQCATA3pXJ3SfcjVBM5wVX+yQE6zv/kHxoaXyp+CZ9aN1YI3EY96R1cRKKRZ60dgCBOIyLwgg5cRj3pHXx99o+tPyPAy4Oc3E2Vi4O4560BC4O4560cTwWlbm+Pu9Xfq87EoL1xUUoJhAIBIK7xN0IxRKCr134zKba63rPHpIPbUoQtmkfWnd+QhzGPWm5OCzlSZsShy1TQrGMOIx70qbEYdyT1l2LicOWt9fBopb6Up60BC4O4560Pv486UnbJw5bLZ+33rf41AoEAsEDhXBqs9g+/eAOvGWHYF0hWHCtSVviu/Wh3RVSdIPYk7YTA8faJQ4jT9rBiMRhvCTu4PPta0wZ3EHPYkNCsMAjmNFCUhSRqfHBYjqBQCAQCLaA7dMPRnrL7op+EHjHrkk/OAQf2q74XZTBBZCmH7BFfhf9oItyQFQDQi/9IKIccE9aQif9IKIcDC2D21v6NvKc9fHx9ICACiH0A4FAIDhoSKY2je3TDyZ4y+6CfhBnatehHxyKD20ufhdlcF08ph+04mn6QR/lYHnjy+T20g8SlAPuSUvI0g8SlIMhZXB7S98maAnZY3vi8XsR+oFAIBAI7hvG0w+GOhbsKeVg3ZK37lp37EO77vg2WQY3eX22jZ+Mj3U8qMdvw8elZr3Twkjng8jxoKskbnD/AWVw2/eaRjkYQy8QCAQCweHCQDK1OYhPrUAgEAgEAoHg4LG/FcU2hE1mZ/cJfZ60KXRlZ1OetMlrJP48HONJm4Q23dXDomu5QXemegeAlcHl4rBR1cNAz9S0nuvwcQzPzsbjk0ysQCAQCAQNJgvFtiXu2icf2q547Enr4h1CsVgc1nV+7ElL4OKw2IcWCMVhcTwWhFE7FoXFcWNMIAojcHFYy6c2EodR28UjcZgTgrl4KA7jnrR0ARKHAUgKxTj9gIvDuCctjZWLw5wojBCJw7gnLZ3TKwTjPrWPQiFZLAjrEl+ZOn/skPO3GRehmEAgEOwAYumVxd341PbE98mHNhdPedL2XSslDssJxVKetDye8qR1cSYOC8RfCUHY7avLpCiMwMVhXBTm4kwcFvjUJsRh3Ic2JQ5bvPHirpQ4jHvScnEYIRaK8UWt76P4dZCpBUJx2PL2mo0Fvo9EX8yTNiUO4560ro+JwwJB1RCfWgsan/jUCgQCgUAQ4t7TDzaJQy2DOwUpcdig8/pKx/Y9CmeTNVwcxr1p41K4a4HGOlIcFnvSZsczRmQoFAOBQCAQQIRiXRD6wYjrH2oZXHf9EfQDTjkAMJh+EPjYJugHfFGboh9471jmQwt00g9iykFMPwAwjX7AKpKl6AUp+sGoMriBT233lv4ufGbXjQv9QCAQCAR3CaEfJPpy8UMtg+uuP4J+wCkHhCH0gzhTG9MP4kxti37AM7VI0Qva9IMU5YC33flj6QcsUwtYyoFFjn4wqgxun08ta+/KZ3bduNAPBAKBYMsQTm0W95Z+sCm3g3UoB5sqg7suUqr8nONBim6Q8qTdtePBOnSCwJuWlcSdBFYSd9sY5cSw7r24BzGjnaQoKLn4FLqKQCAQCASbwr1d1AoEAoFAIBDcR/TpVx4qehe1SqlvAPgGAJy895mtD2gd3GdP2s74ljO9fdho9bDem2l/zXo9m1oa79SMaJ8vbTKz3ONJu252Nhb4jcm0CgQCgUBwyOhd1BpjvgngmwDw6S/+ErPPQrFYFLaJ63eJw7qEYrEnbdf5fPGTEorxRXpKCMYXtak4X3zlxGHck5bAxWEtH9pIHNbyoY3EYU4URojEYbFPbexN60RjxvNYSRAGdAvFYnGYE42xRS33pu0UimntRWFcvJUQigU+tUwc1iW+WteH1hiDkxMWP0mcv6V46liBQCAQbBbifpDHvRKKpURhLj5RKNYnDstdK+VJS4iFYHFGL47HmdpY6BVnaltCsCijmBOHcU9a18fEYYEPbUIcFsQT4jDuU5sShy1TPrVMHLZ8+yzI1AKN+IuQE4qlxGHL2+tgUUt97lo5oZg9f7W4bj3XWCgWf65cHJYTX63rQ0uf32rF4qvE+VuKp44VCAQCgWAXOHhO7bYoB1O29MeKwzbipZq7fqYk7vrX3fJW9aTnbpKvafdnr4E/Uylv2jHYhCBMKAQCgUDwQCDuB1kcvE/tNsvgur6B9INNlsHl7Sn0g9iT1sfXox/whddW6Afs+kPpBzHlwFENaCxj6AdRSVxCF/0g52M7lH7QRTkYSj/gn5vQDwQCgUDwEHHw9INtl8HtO39bZXB5ewr9IOVJG8Qn0g/ibOLG6Qext+wA+kGKcsBpCaPoB4mSuIQc/SDlTTuGftBHORhCP4g/N6EfCAQCgeCh4eDpB/cV2yiJ2+VNG6vgU960w+7RM56B490EPcO9z7v2pu1xPBiDIe4GAoFAILjfEPpBGkI/yMTvmn4Ql8R1cUY56Iqn6AddlIOWu0HkeDCUfhDEU/QDXma3g34QUA6ASfQDX3JXB5SE0fQDRjkAMJ5+oLsdDcbQD+7S3aAvLvQDgUAgENwlhH6Qid81/SBVEtfFGeUgSy9I0A/6KAchfaDteDCEfhBnVlv0g1Y8TT8IKAcWY+kHQaYWbXeDwfQDRjkgjKIf5MrkWoyhH9y1u0FfXOgHAoFAsF0YSKY2h4OlH2yjwMLUkrgPEX0FF3oxtuBCZ/WG4Vh33I2jhMm6SoyhTeyi/K1AIBAIBA8FB7uoFQgEAoFAIHhwEEuvLGRRuwEMFVMdsjftWB/VDSZXW9fd2LUOKFMqYjCBQCAQCLpxsEKxQMi1yTK7A0vb8rZmi9ouoVgsDtu0UCwWh21KKMZL4rp45E0bC8Vib9pYKBaXxu0UihmNR+997N4jYYpQzBgvCuOL2qFCMVOHojA6LiiT+yiM54RiQZndHqHYPvjQ9sVFKCYQCATbh3Bq8zhYoVjMqd2EUCxVErfvfF4Sl5ATiqXEYZsUiqXEYZsQivGSuC6e8KblQrGUN20gFEuUxs0KxezFGs/a8FmMFYrRuJe3161M7RChGD3j1YKJtxKlcQNv2YxQLL5/l1BsX3xo++IiFBMIBALBXeGg6AfbKom7L9iGNy2Q3rJPedM2x97Bn3/aNBnaUZ67G6Ry8NK4IzBZJDf0+pnPSCAQCAQPGMKpzeKg6AexJ+2690pe/w7pBzHlIKYXxJSDofSDsIxumnLAS+K2+rZNP6hDT1qKd9EPOOUAwHr0A0Y5AIbTD1JldDdJP4g9aV1c6AcCgUAgELRwUPSDlCeti98D+kGKcsDbKcrBEPpBnKnNUQ54Sdygb9v0g4QnbR/9IFUOdzL9gFMOwNo99IM4U7tp+kHKk9bFhX4gEAgEDxbiPJrGQdEPtgHxpl0fRlt3hNwz1HavZIh364TPYaNUBGOvswlqgfxMCQQCgUCwMxR3PQCBQCAQCAQCgWBdPPhMreB+ofHGNRv3x90Upnj+CgQCgUBAEEuvPB68UCwWh4lQbLxQzNShaKy5TigOe5wQgqWEYpxCMFQoFovDqO0wQijGPWcdpgrFeJyJw7goLI4Hx4pQTCAQCASCwXjwQrGUOEyEYgj7eoRi9L64KCwQirm4F3XlhGIxL3aIUCwlDlveeNHXKKEYec4u2uePForpRLxOCMlYPDhWhGICgUAgiCGWXlnsPf3gvnvTCvYYe1L+WCAQCAQCQT/2nn4QUw6EfiD0Azpu6/QD9iy66AexN63QDwQCgUCwLQinNo+9px+kKAdCPxD6wU7oB9GzyNEPUt60Qj8QCAQCgWC32Hv6wb7CaA2t9d2UlRUIBAKBQPBgIUuPNMSnViAQCAQCgUBw8FCxgrvzYKUuAfzC9oYT4EMAV71HHRbu43sC5H0dEnb5nr5qjPmo/zCBQCAQDIVS6s+jmct3hStjzPfv8H6TMWpRu0sopb5jjPn6XY9jk7iP7wmQ93VIuI/vSSAQCAQCQOgHAoFAIBAIBIJ7AFnUCgQCgUAgEAgOHvu8qP3mXQ9gC7iP7wmQ93VIuI/vSSAQCASC/eXUCgQCgUAgEAgEQ7HPmVqBQCAQCAQCgWAQZFErEAgEAoFAIDh4yKJWIBAIBAKBQHDwkEWtQCAQCAQCgeDgIYtagUAgEAgEAsHB4/8PUNF+nN0C5kkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, axes = nlmod.plot.facet_plot(\n", " gwf,\n", @@ -314,8 +983,22 @@ } ], "metadata": { + "kernelspec": { + "display_name": "artesia", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" } }, "nbformat": 4, From 2bc181ca0bb67d3cce42fa3cc8970bcea12fe325 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 17:26:12 +0200 Subject: [PATCH 27/28] attempt to remove metadata --- docs/examples/00_model_from_scratch.ipynb | 729 +--------------------- 1 file changed, 23 insertions(+), 706 deletions(-) diff --git a/docs/examples/00_model_from_scratch.ipynb b/docs/examples/00_model_from_scratch.ipynb index a70fb62b..b3a5f8ee 100644 --- a/docs/examples/00_model_from_scratch.ipynb +++ b/docs/examples/00_model_from_scratch.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -90,550 +90,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32mINFO:nlmod.dims.base:resample layer model data to structured modelgrid\u001b[0m\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (y: 100, x: 100, layer: 3)\n",
-       "Coordinates:\n",
-       "  * layer    (layer) int64 1 2 3\n",
-       "  * x        (x) float64 -495.0 -485.0 -475.0 -465.0 ... 465.0 475.0 485.0 495.0\n",
-       "  * y        (y) float64 495.0 485.0 475.0 465.0 ... -465.0 -475.0 -485.0 -495.0\n",
-       "Data variables:\n",
-       "    top      (y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
-       "    botm     (layer, y, x) float64 -10.0 -10.0 -10.0 -10.0 ... -30.0 -30.0 -30.0\n",
-       "    kh       (layer, y, x) float64 10.0 10.0 10.0 10.0 ... 20.0 20.0 20.0 20.0\n",
-       "    kv       (layer, y, x) float64 5.0 5.0 5.0 5.0 5.0 ... 10.0 10.0 10.0 10.0\n",
-       "    area     (y, x) float64 100.0 100.0 100.0 100.0 ... 100.0 100.0 100.0 100.0\n",
-       "    idomain  (layer, y, x) int64 1 1 1 1 1 1 1 1 1 1 1 ... 1 1 1 1 1 1 1 1 1 1 1\n",
-       "Attributes:\n",
-       "    extent:                    [-500, 500, -500, 500]\n",
-       "    gridtype:                  structured\n",
-       "    delr:                      10.0\n",
-       "    delc:                      10.0\n",
-       "    model_name:                from_scratch\n",
-       "    mfversion:                 mf6\n",
-       "    model_dataset_created_on:  20230509_17:25:09\n",
-       "    exe_name:                  /home/david/Github/nlmod/nlmod/bin/mf6\n",
-       "    model_ws:                  ./scratch_model\n",
-       "    figdir:                    ./scratch_model/figure\n",
-       "    cachedir:                  ./scratch_model/cache\n",
-       "    transport:                 0
" - ], - "text/plain": [ - "\n", - "Dimensions: (y: 100, x: 100, layer: 3)\n", - "Coordinates:\n", - " * layer (layer) int64 1 2 3\n", - " * x (x) float64 -495.0 -485.0 -475.0 -465.0 ... 465.0 475.0 485.0 495.0\n", - " * y (y) float64 495.0 485.0 475.0 465.0 ... -465.0 -475.0 -485.0 -495.0\n", - "Data variables:\n", - " top (y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n", - " botm (layer, y, x) float64 -10.0 -10.0 -10.0 -10.0 ... -30.0 -30.0 -30.0\n", - " kh (layer, y, x) float64 10.0 10.0 10.0 10.0 ... 20.0 20.0 20.0 20.0\n", - " kv (layer, y, x) float64 5.0 5.0 5.0 5.0 5.0 ... 10.0 10.0 10.0 10.0\n", - " area (y, x) float64 100.0 100.0 100.0 100.0 ... 100.0 100.0 100.0 100.0\n", - " idomain (layer, y, x) int64 1 1 1 1 1 1 1 1 1 1 1 ... 1 1 1 1 1 1 1 1 1 1 1\n", - "Attributes:\n", - " extent: [-500, 500, -500, 500]\n", - " gridtype: structured\n", - " delr: 10.0\n", - " delc: 10.0\n", - " model_name: from_scratch\n", - " mfversion: mf6\n", - " model_dataset_created_on: 20230509_17:25:09\n", - " exe_name: /home/david/Github/nlmod/nlmod/bin/mf6\n", - " model_ws: ./scratch_model\n", - " figdir: ./scratch_model/figure\n", - " cachedir: ./scratch_model/cache\n", - " transport: 0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds = nlmod.get_ds(\n", " extent,\n", @@ -659,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -676,24 +135,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32mINFO:nlmod.sim.sim:creating modflow SIM\u001b[0m\n", - "\u001b[32mINFO:nlmod.sim.sim:creating modflow TDIS\u001b[0m\n", - "\u001b[32mINFO:nlmod.sim.sim:creating modflow IMS\u001b[0m\n", - "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow GWF\u001b[0m\n", - "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow DIS\u001b[0m\n", - "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow NPF\u001b[0m\n", - "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow IC\u001b[0m\n", - "\u001b[32mINFO:nlmod.gwf.gwf:creating modflow OC\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ "sim = nlmod.sim.sim(ds)\n", "tdis = nlmod.sim.tdis(ds, sim)\n", @@ -715,78 +159,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
xytopbotmQ
well no.
0100-50-5-10-100.0
1200150-20-30-300.0
\n", - "
" - ], - "text/plain": [ - " x y top botm Q\n", - "well no. \n", - "0 100 -50 -5 -10 -100.0\n", - "1 200 150 -20 -30 -300.0" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "wells = pd.DataFrame(columns=[\"x\", \"y\", \"top\", \"botm\", \"Q\"], index=range(2))\n", "wells.index.name = \"well no.\"\n", @@ -797,17 +172,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Adding WELs: 100%|██████████| 2/2 [00:00<00:00, 694.31it/s]\n" - ] - } - ], + "outputs": [], "source": [ "wel = nlmod.gwf.wells.wel_from_df(wells, gwf)" ] @@ -822,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -844,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -865,19 +232,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32mINFO:nlmod.sim.sim:write model dataset to cache\u001b[0m\n", - "\u001b[32mINFO:nlmod.sim.sim:write modflow files to model workspace\u001b[0m\n", - "\u001b[32mINFO:nlmod.sim.sim:run model\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ "nlmod.sim.write_and_run(sim, ds, silent=True)" ] @@ -892,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -909,22 +266,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(10, 8))\n", "\n", @@ -952,22 +296,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = nlmod.plot.facet_plot(\n", " gwf,\n", @@ -983,22 +314,8 @@ } ], "metadata": { - "kernelspec": { - "display_name": "artesia", - "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.9.7" + "name": "python" } }, "nbformat": 4, From 5312c0f32163a1381197bef3252c91007acd99c0 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 9 May 2023 17:30:33 +0200 Subject: [PATCH 28/28] add ipykernel --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 63e4fff5..f576fe56 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,7 +60,7 @@ test = ["pytest>=7", "pytest-cov", "pytest-dependency"] nbtest = ["nbformat", "nbconvert>6.4.5"] lint = ["flake8", "isort", "black[jupyter]"] ci = ["nlmod[full,lint,test,nbtest]", "netCDF4==1.5.7"] -rtd = ["ipython", "nbsphinx", "nbconvert>6.4.5"] +rtd = ["ipython", "ipykernel", "nbsphinx", "nbconvert>6.4.5"] [tool.setuptools.dynamic] version = { attr = "nlmod.version.__version__" }