diff --git a/.binder/environment.yml b/.binder/environment.yml new file mode 100644 index 00000000000..13b6b99e6fc --- /dev/null +++ b/.binder/environment.yml @@ -0,0 +1,39 @@ +name: xarray-examples +channels: + - conda-forge +dependencies: + - python=3.7 + - boto3 + - bottleneck + - cartopy + - cdms2 + - cfgrib + - cftime + - coveralls + - dask + - distributed + - dask_labextension + - h5netcdf + - h5py + - hdf5 + - iris + - lxml # Optional dep of pydap + - matplotlib + - nc-time-axis + - netcdf4 + - numba + - numpy + - pandas + - pint + - pip + - pydap + - pynio + - rasterio + - scipy + - seaborn + - sparse + - toolz + - xarray + - zarr + - pip: + - numbagg diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 00000000000..30c1e18f33c --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1,2 @@ +github: numfocus +custom: http://numfocus.org/donate-to-xarray diff --git a/HOW_TO_RELEASE b/HOW_TO_RELEASE.md similarity index 74% rename from HOW_TO_RELEASE rename to HOW_TO_RELEASE.md index 5bf9bf38ded..cdeb0e19a3e 100644 --- a/HOW_TO_RELEASE +++ b/HOW_TO_RELEASE.md @@ -1,9 +1,11 @@ -How to issue an xarray release in 15 easy steps +How to issue an xarray release in 14 easy steps Time required: about an hour. 1. Ensure your master branch is synced to upstream: - git pull upstream master + ``` + git pull upstream master + ``` 2. Look over whats-new.rst and the docs. Make sure "What's New" is complete (check the date!) and consider adding a brief summary note describing the release at the top. @@ -12,37 +14,53 @@ Time required: about an hour. - Function/method references should include links to the API docs. - Sometimes notes get added in the wrong section of whats-new, typically due to a bad merge. Check for these before a release by using git diff, - e.g., ``git diff v0.X.Y whats-new.rst`` where 0.X.Y is the previous + e.g., `git diff v0.X.Y whats-new.rst` where 0.X.Y is the previous release. 3. If you have any doubts, run the full test suite one final time! - py.test + ``` + pytest + ``` 4. On the master branch, commit the release in git: + ``` git commit -a -m 'Release v0.X.Y' + ``` 5. Tag the release: + ``` git tag -a v0.X.Y -m 'v0.X.Y' + ``` 6. Build source and binary wheels for pypi: + ``` git clean -xdf # this deletes all uncommited changes! python setup.py bdist_wheel sdist + ``` 7. Use twine to register and upload the release on pypi. Be careful, you can't take this back! + ``` twine upload dist/xarray-0.X.Y* + ``` You will need to be listed as a package owner at https://pypi.python.org/pypi/xarray for this to work. 8. Push your changes to master: + ``` git push upstream master git push upstream --tags + ``` 9. Update the stable branch (used by ReadTheDocs) and switch back to master: + ``` git checkout stable git rebase master git push upstream stable git checkout master - It's OK to force push to 'stable' if necessary. - We also update the stable branch with `git cherrypick` for documentation - only fixes that apply the current released version. + ``` + It's OK to force push to 'stable' if necessary. (We also update the stable + branch with `git cherrypick` for documentation only fixes that apply the + current released version.) 10. Add a section for the next release (v.X.(Y+1)) to doc/whats-new.rst. 11. Commit your changes and push to master again: - git commit -a -m 'Revert to dev version' + ``` + git commit -a -m 'New whatsnew section' git push upstream master + ``` You're done pushing to master! 12. Issue the release on GitHub. Click on "Draft a new release" at https://github.com/pydata/xarray/releases. Type in the version number, but @@ -53,11 +71,22 @@ Time required: about an hour. 14. Issue the release announcement! For bug fix releases, I usually only email xarray@googlegroups.com. For major/feature releases, I will email a broader list (no more than once every 3-6 months): - pydata@googlegroups.com, xarray@googlegroups.com, - numpy-discussion@scipy.org, scipy-user@scipy.org, - pyaos@lists.johnny-lin.com + - pydata@googlegroups.com + - xarray@googlegroups.com + - numpy-discussion@scipy.org + - scipy-user@scipy.org + - pyaos@lists.johnny-lin.com + Google search will turn up examples of prior release announcements (look for "ANN xarray"). + You can get a list of contributors with: + ``` + git log "$(git tag --sort="v:refname" | sed -n 'x;$p').." --format="%aN" | sort -u + ``` + or by replacing `v0.X.Y` with the _previous_ release in: + ``` + git log v0.X.Y.. --format="%aN" | sort -u + ``` Note on version numbering: diff --git a/ci/azure/install.yml b/ci/azure/install.yml index fee886ba804..e4f3a0b9e16 100644 --- a/ci/azure/install.yml +++ b/ci/azure/install.yml @@ -16,16 +16,18 @@ steps: --pre \ --upgrade \ matplotlib \ + numpy \ pandas \ scipy - # numpy \ # FIXME https://github.com/pydata/xarray/issues/3409 pip install \ --no-deps \ --upgrade \ git+https://github.com/dask/dask \ git+https://github.com/dask/distributed \ git+https://github.com/zarr-developers/zarr \ - git+https://github.com/Unidata/cftime + git+https://github.com/Unidata/cftime \ + git+https://github.com/mapbox/rasterio \ + git+https://github.com/pydata/bottleneck condition: eq(variables['UPSTREAM_DEV'], 'true') displayName: Install upstream dev dependencies diff --git a/ci/requirements/doc.yml b/ci/requirements/doc.yml index e521ee4a4b8..97488e7f581 100644 --- a/ci/requirements/doc.yml +++ b/ci/requirements/doc.yml @@ -6,9 +6,13 @@ dependencies: - python=3.7 - bottleneck - cartopy + - cfgrib - h5netcdf + - ipykernel - ipython - iris + - jupyter_client + - nbsphinx - netcdf4 - numpy - numpydoc @@ -16,6 +20,6 @@ dependencies: - rasterio - seaborn - sphinx - - sphinx-gallery - sphinx_rtd_theme + - xarray - zarr diff --git a/ci/requirements/py36.yml b/ci/requirements/py36.yml index 10fe69253e8..820160b19cc 100644 --- a/ci/requirements/py36.yml +++ b/ci/requirements/py36.yml @@ -25,7 +25,7 @@ dependencies: - nc-time-axis - netcdf4 - numba - - numpy<1.18 # FIXME https://github.com/pydata/xarray/issues/3409 + - numpy - pandas - pint - pip diff --git a/ci/requirements/py37.yml b/ci/requirements/py37.yml index 827c664a222..4a7aaf7d32b 100644 --- a/ci/requirements/py37.yml +++ b/ci/requirements/py37.yml @@ -25,7 +25,7 @@ dependencies: - nc-time-axis - netcdf4 - numba - - numpy<1.18 # FIXME https://github.com/pydata/xarray/issues/3409 + - numpy - pandas - pint - pip diff --git a/doc/README.rst b/doc/README.rst index af7bc96092c..0579f85d85f 100644 --- a/doc/README.rst +++ b/doc/README.rst @@ -1,3 +1,5 @@ +:orphan: + xarray ------ diff --git a/doc/api-hidden.rst b/doc/api-hidden.rst index 8f82b30a442..027c732697f 100644 --- a/doc/api-hidden.rst +++ b/doc/api-hidden.rst @@ -2,6 +2,8 @@ .. This extra page is a work around for sphinx not having any support for .. hiding an autosummary table. +:orphan: + .. currentmodule:: xarray .. autosummary:: @@ -30,9 +32,11 @@ core.groupby.DatasetGroupBy.first core.groupby.DatasetGroupBy.last core.groupby.DatasetGroupBy.fillna + core.groupby.DatasetGroupBy.quantile core.groupby.DatasetGroupBy.where Dataset.argsort + Dataset.astype Dataset.clip Dataset.conj Dataset.conjugate @@ -71,6 +75,7 @@ core.groupby.DataArrayGroupBy.first core.groupby.DataArrayGroupBy.last core.groupby.DataArrayGroupBy.fillna + core.groupby.DataArrayGroupBy.quantile core.groupby.DataArrayGroupBy.where DataArray.argsort diff --git a/doc/api.rst b/doc/api.rst index d2309f28226..a1fae3deb03 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -675,3 +675,12 @@ arguments for the ``from_store`` and ``dump_to_store`` Dataset methods: backends.FileManager backends.CachingFileManager backends.DummyFileManager + +Deprecated / Pending Deprecation +================================ + + Dataset.drop + DataArray.drop + Dataset.apply + core.groupby.DataArrayGroupBy.apply + core.groupby.DatasetGroupBy.apply diff --git a/doc/combining.rst b/doc/combining.rst index 4593d410d23..05b7f2efc50 100644 --- a/doc/combining.rst +++ b/doc/combining.rst @@ -255,11 +255,11 @@ Combining along multiple dimensions ``combine_nested``. For combining many objects along multiple dimensions xarray provides -:py:func:`~xarray.combine_nested`` and :py:func:`~xarray.combine_by_coords`. These +:py:func:`~xarray.combine_nested` and :py:func:`~xarray.combine_by_coords`. These functions use a combination of ``concat`` and ``merge`` across different variables to combine many objects into one. -:py:func:`~xarray.combine_nested`` requires specifying the order in which the +:py:func:`~xarray.combine_nested` requires specifying the order in which the objects should be combined, while :py:func:`~xarray.combine_by_coords` attempts to infer this ordering automatically from the coordinates in the data. @@ -310,4 +310,4 @@ These functions can be used by :py:func:`~xarray.open_mfdataset` to open many files as one dataset. The particular function used is specified by setting the argument ``'combine'`` to ``'by_coords'`` or ``'nested'``. This is useful for situations where your data is split across many files in multiple locations, -which have some known relationship between one another. \ No newline at end of file +which have some known relationship between one another. diff --git a/doc/computation.rst b/doc/computation.rst index 663c546be20..1ac30f55ee7 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -95,6 +95,9 @@ for filling missing values via 1D interpolation. Note that xarray slightly diverges from the pandas ``interpolate`` syntax by providing the ``use_coordinate`` keyword which facilitates a clear specification of which values to use as the index in the interpolation. +xarray also provides the ``max_gap`` keyword argument to limit the interpolation to +data gaps of length ``max_gap`` or smaller. See :py:meth:`~xarray.DataArray.interpolate_na` +for more. Aggregation =========== @@ -322,8 +325,8 @@ Broadcasting by dimension name ``DataArray`` objects are automatically align themselves ("broadcasting" in the numpy parlance) by dimension name instead of axis order. With xarray, you do not need to transpose arrays or insert dimensions of length 1 to get array -operations to work, as commonly done in numpy with :py:func:`np.reshape` or -:py:const:`np.newaxis`. +operations to work, as commonly done in numpy with :py:func:`numpy.reshape` or +:py:data:`numpy.newaxis`. This is best illustrated by a few examples. Consider two one-dimensional arrays with different sizes aligned along different dimensions: @@ -563,7 +566,7 @@ to set ``axis=-1``. As an example, here is how we would wrap Because ``apply_ufunc`` follows a standard convention for ufuncs, it plays nicely with tools for building vectorized functions, like -:func:`numpy.broadcast_arrays` and :func:`numpy.vectorize`. For high performance +:py:func:`numpy.broadcast_arrays` and :py:class:`numpy.vectorize`. For high performance needs, consider using Numba's :doc:`vectorize and guvectorize `. In addition to wrapping functions, ``apply_ufunc`` can automatically parallelize diff --git a/doc/conf.py b/doc/conf.py index 7c1557a1e66..11abda6bb63 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -15,10 +15,16 @@ import datetime import os +import pathlib import subprocess import sys from contextlib import suppress +# make sure the source version is preferred (#3567) +root = pathlib.Path(__file__).absolute().parent.parent +os.environ["PYTHONPATH"] = str(root) +sys.path.insert(0, str(root)) + import xarray allowed_failures = set() @@ -76,7 +82,7 @@ "numpydoc", "IPython.sphinxext.ipython_directive", "IPython.sphinxext.ipython_console_highlighting", - "sphinx_gallery.gen_gallery", + "nbsphinx", ] extlinks = { @@ -84,12 +90,16 @@ "pull": ("https://github.com/pydata/xarray/pull/%s", "PR"), } -sphinx_gallery_conf = { - "examples_dirs": "gallery", - "gallery_dirs": "auto_gallery", - "backreferences_dir": False, - "expected_failing_examples": list(allowed_failures), -} +nbsphinx_timeout = 600 +nbsphinx_execute = "always" +nbsphinx_prolog = """ +{% set docname = env.doc2path(env.docname, base=None) %} + +You can run this notebook in a `live session `_ |Binder| or view it `on Github `_. + +.. |Binder| image:: https://mybinder.org/badge.svg + :target: https://mybinder.org/v2/gh/pydata/xarray/master?urlpath=lab/tree/doc/{{ docname }} +""" autosummary_generate = True autodoc_typehints = "none" @@ -137,7 +147,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. -exclude_patterns = ["_build"] +exclude_patterns = ["_build", "**.ipynb_checkpoints"] # The reST default role (used for this markup: `text`) to use for all # documents. @@ -340,9 +350,12 @@ # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { "python": ("https://docs.python.org/3/", None), - "pandas": ("https://pandas.pydata.org/pandas-docs/stable/", None), - "iris": ("http://scitools.org.uk/iris/docs/latest/", None), - "numpy": ("https://docs.scipy.org/doc/numpy/", None), - "numba": ("https://numba.pydata.org/numba-doc/latest/", None), - "matplotlib": ("https://matplotlib.org/", None), + "pandas": ("https://pandas.pydata.org/pandas-docs/stable", None), + "iris": ("https://scitools.org.uk/iris/docs/latest", None), + "numpy": ("https://docs.scipy.org/doc/numpy", None), + "scipy": ("https://docs.scipy.org/doc/scipy/reference", None), + "numba": ("https://numba.pydata.org/numba-doc/latest", None), + "matplotlib": ("https://matplotlib.org", None), + "dask": ("https://docs.dask.org/en/latest", None), + "cftime": ("https://unidata.github.io/cftime", None), } diff --git a/doc/contributing.rst b/doc/contributing.rst index 028ec47e014..3cd0b3e8868 100644 --- a/doc/contributing.rst +++ b/doc/contributing.rst @@ -151,7 +151,9 @@ We'll now kick off a two-step process: .. code-block:: none # Create and activate the build environment - conda env create -f ci/requirements/py36.yml + # This is for Linux and MacOS. On Windows, use py37-windows.yml instead. + conda env create -f ci/requirements/py37.yml + conda activate xarray-tests # or with older versions of Anaconda: diff --git a/doc/dask.rst b/doc/dask.rst index 11f378aa376..ed99ffaa896 100644 --- a/doc/dask.rst +++ b/doc/dask.rst @@ -285,7 +285,7 @@ automate `embarrassingly parallel `__ "map" type operations where a function written for processing NumPy arrays should be repeatedly applied to xarray objects containing Dask arrays. It works similarly to -:py:func:`dask.array.map_blocks` and :py:func:`dask.array.atop`, but without +:py:func:`dask.array.map_blocks` and :py:func:`dask.array.blockwise`, but without requiring an intermediate layer of abstraction. For the best performance when using Dask's multi-threaded scheduler, wrap a diff --git a/doc/data-structures.rst b/doc/data-structures.rst index 93cdc7e9765..504d820a234 100644 --- a/doc/data-structures.rst +++ b/doc/data-structures.rst @@ -45,7 +45,7 @@ Creating a DataArray The :py:class:`~xarray.DataArray` constructor takes: - ``data``: a multi-dimensional array of values (e.g., a numpy ndarray, - :py:class:`~pandas.Series`, :py:class:`~pandas.DataFrame` or :py:class:`~pandas.Panel`) + :py:class:`~pandas.Series`, :py:class:`~pandas.DataFrame` or ``pandas.Panel``) - ``coords``: a list or dictionary of coordinates. If a list, it should be a list of tuples where the first element is the dimension name and the second element is the corresponding coordinate array_like object. @@ -125,7 +125,7 @@ As a dictionary with coords across multiple dimensions: If you create a ``DataArray`` by supplying a pandas :py:class:`~pandas.Series`, :py:class:`~pandas.DataFrame` or -:py:class:`~pandas.Panel`, any non-specified arguments in the +``pandas.Panel``, any non-specified arguments in the ``DataArray`` constructor will be filled in from the pandas object: .. ipython:: python @@ -301,7 +301,7 @@ names, and its data is aligned to any existing dimensions. You can also create an dataset from: -- A :py:class:`pandas.DataFrame` or :py:class:`pandas.Panel` along its columns and items +- A :py:class:`pandas.DataFrame` or ``pandas.Panel`` along its columns and items respectively, by passing it into the :py:class:`~xarray.Dataset` directly - A :py:class:`pandas.DataFrame` with :py:meth:`Dataset.from_dataframe `, which will additionally handle MultiIndexes See :ref:`pandas` @@ -485,14 +485,14 @@ in xarray: :py:class:`pandas.Index` internally to store their values. - **non-dimension coordinates** are variables that contain coordinate - data, but are not a dimension coordinate. They can be multidimensional - (see :ref:`examples.multidim`), and there is no relationship between the - name of a non-dimension coordinate and the name(s) of its dimension(s). - Non-dimension coordinates can be useful for indexing or plotting; otherwise, - xarray does not make any direct use of the values associated with them. - They are not used for alignment or automatic indexing, nor are they required - to match when doing arithmetic - (see :ref:`coordinates math`). + data, but are not a dimension coordinate. They can be multidimensional (see + :ref:`/examples/multidimensional-coords.ipynb`), and there is no + relationship between the name of a non-dimension coordinate and the + name(s) of its dimension(s). Non-dimension coordinates can be + useful for indexing or plotting; otherwise, xarray does not make any + direct use of the values associated with them. They are not used + for alignment or automatic indexing, nor are they required to match + when doing arithmetic (see :ref:`coordinates math`). .. note:: diff --git a/doc/examples.rst b/doc/examples.rst index 4d726d494e8..ce56102cc9d 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -7,4 +7,6 @@ Examples examples/weather-data examples/monthly-means examples/multidimensional-coords - auto_gallery/index + examples/visualization_gallery + examples/ROMS_ocean_model + examples/ERA5-GRIB-example diff --git a/doc/examples/ERA5-GRIB-example.ipynb b/doc/examples/ERA5-GRIB-example.ipynb new file mode 100644 index 00000000000..b82a07a64e6 --- /dev/null +++ b/doc/examples/ERA5-GRIB-example.ipynb @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GRIB Data Example " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GRIB format is commonly used to disemminate atmospheric model data. With Xarray and the cfgrib engine, GRIB data can easily be analyzed and visualized." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To read GRIB data, you can use `xarray.load_dataset`. The only extra code you need is to specify the engine as `cfgrib`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset('era5-2mt-2019-03-uk.grib', engine='cfgrib')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create a simple plot of 2-m air temperature in degrees Celsius:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds = ds - 273.15\n", + "ds.t2m[0].plot(cmap=plt.cm.coolwarm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With CartoPy, we can create a more detailed plot, using built-in shapefiles to help provide geographic context:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cartopy.crs as ccrs\n", + "import cartopy\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.axes(projection=ccrs.Robinson())\n", + "ax.coastlines(resolution='10m')\n", + "plot = ds.t2m[0].plot(cmap=plt.cm.coolwarm, transform=ccrs.PlateCarree(), cbar_kwargs={'shrink':0.6})\n", + "plt.title('ERA5 - 2m temperature British Isles March 2019')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can also pull out a time series for a given location easily:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds.t2m.sel(longitude=0,latitude=51.5).plot()\n", + "plt.title('ERA5 - London 2m temperature March 2019')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/examples/ROMS_ocean_model.ipynb b/doc/examples/ROMS_ocean_model.ipynb new file mode 100644 index 00000000000..74536bbe28f --- /dev/null +++ b/doc/examples/ROMS_ocean_model.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ROMS Ocean Model Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Regional Ocean Modeling System ([ROMS](http://myroms.org)) is an open source hydrodynamic model that is used for simulating currents and water properties in coastal and estuarine regions. ROMS is one of a few standard ocean models, and it has an active user community.\n", + "\n", + "ROMS uses a regular C-Grid in the horizontal, similar to other structured grid ocean and atmospheric models, and a stretched vertical coordinate (see [the ROMS documentation](https://www.myroms.org/wiki/Vertical_S-coordinate) for more details). Both of these require special treatment when using `xarray` to analyze ROMS ocean model output. This example notebook shows how to create a lazily evaluated vertical coordinate, and make some basic plots. The `xgcm` package is required to do analysis that is aware of the horizontal C-Grid." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load a sample ROMS file. This is a subset of a full model available at \n", + "\n", + " http://barataria.tamu.edu/thredds/catalog.html?dataset=txla_hindcast_agg\n", + " \n", + "The subsetting was done using the following command on one of the output files:\n", + "\n", + " #open dataset\n", + " ds = xr.open_dataset('/d2/shared/TXLA_ROMS/output_20yr_obc/2001/ocean_his_0015.nc')\n", + " \n", + " # Turn on chunking to activate dask and parallelize read/write.\n", + " ds = ds.chunk({'ocean_time': 1})\n", + " \n", + " # Pick out some of the variables that will be included as coordinates\n", + " ds = ds.set_coords(['Cs_r', 'Cs_w', 'hc', 'h', 'Vtransform'])\n", + " \n", + " # Select a a subset of variables. Salt will be visualized, zeta is used to \n", + " # calculate the vertical coordinate\n", + " variables = ['salt', 'zeta']\n", + " ds[variables].isel(ocean_time=slice(47, None, 7*24), \n", + " xi_rho=slice(300, None)).to_netcdf('ROMS_example.nc', mode='w')\n", + "\n", + "So, the `ROMS_example.nc` file contains a subset of the grid, one 3D variable, and two time steps." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load in ROMS dataset as an xarray object" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# load in the file\n", + "ds = xr.tutorial.open_dataset('ROMS_example.nc', chunks={'ocean_time': 1})\n", + "\n", + "# This is a way to turn on chunking and lazy evaluation. Opening with mfdataset, or \n", + "# setting the chunking in the open_dataset would also achive this.\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add a lazilly calculated vertical coordinates\n", + "\n", + "Write equations to calculate the vertical coordinate. These will be only evaluated when data is requested. Information about the ROMS vertical coordinate can be found (here)[https://www.myroms.org/wiki/Vertical_S-coordinate]\n", + "\n", + "In short, for `Vtransform==2` as used in this example, \n", + "\n", + "$Z_0 = (h_c \\, S + h \\,C) / (h_c + h)$\n", + "\n", + "$z = Z_0 (\\zeta + h) + \\zeta$\n", + "\n", + "where the variables are defined as in the link above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if ds.Vtransform == 1:\n", + " Zo_rho = ds.hc * (ds.s_rho - ds.Cs_r) + ds.Cs_r * ds.h\n", + " z_rho = Zo_rho + ds.zeta * (1 + Zo_rho/ds.h)\n", + "elif ds.Vtransform == 2:\n", + " Zo_rho = (ds.hc * ds.s_rho + ds.Cs_r * ds.h) / (ds.hc + ds.h)\n", + " z_rho = ds.zeta + (ds.zeta + ds.h) * Zo_rho\n", + "\n", + "ds.coords['z_rho'] = z_rho.transpose() # needing transpose seems to be an xarray bug\n", + "ds.salt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A naive vertical slice\n", + "\n", + "Create a slice using the s-coordinate as the vertical dimension is typically not very informative." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "ds.salt.isel(xi_rho=50, ocean_time=0).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can feed coordinate information to the plot method to give a more informative cross-section that uses the depths. Note that we did not need to slice the depth or longitude information separately, this was done automatically as the variable was sliced." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "section = ds.salt.isel(xi_rho=50, eta_rho=slice(0, 167), ocean_time=0)\n", + "section.plot(x='lon_rho', y='z_rho', figsize=(15, 6), clim=(25, 35))\n", + "plt.ylim([-100, 1]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A plan view\n", + "\n", + "Now make a naive plan view, without any projection information, just using lon/lat as x/y. This looks OK, but will appear compressed because lon and lat do not have an aspect constrained by the projection." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds.salt.isel(s_rho=-1, ocean_time=0).plot(x='lon_rho', y='lat_rho')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And let's use a projection to make it nicer, and add a coast." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "proj = ccrs.LambertConformal(central_longitude=-92, central_latitude=29)\n", + "fig = plt.figure(figsize=(15, 5))\n", + "ax = plt.axes(projection=proj)\n", + "ds.salt.isel(s_rho=-1, ocean_time=0).plot(x='lon_rho', y='lat_rho', \n", + " transform=ccrs.PlateCarree())\n", + "\n", + "coast_10m = cfeature.NaturalEarthFeature('physical', 'land', '10m',\n", + " edgecolor='k', facecolor='0.8')\n", + "ax.add_feature(coast_10m)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/examples/monthly-means.ipynb b/doc/examples/monthly-means.ipynb new file mode 100644 index 00000000000..fad40e019de --- /dev/null +++ b/doc/examples/monthly-means.ipynb @@ -0,0 +1,325 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculating Seasonal Averages from Timeseries of Monthly Means \n", + "=====\n", + "\n", + "Author: [Joe Hamman](https://github.com/jhamman/)\n", + "\n", + "The data used for this example can be found in the [xarray-data](https://github.com/pydata/xarray-data) repository. You may need to change the path to `rasm.nc` below.\n", + "\n", + "Suppose we have a netCDF or `xarray.Dataset` of monthly mean data and we want to calculate the seasonal average. To do this properly, we need to calculate the weighted average considering that each month has a different number of days." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:35.958210Z", + "start_time": "2018-11-28T20:51:35.936966Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from netCDF4 import num2date\n", + "import matplotlib.pyplot as plt " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Some calendar information so we can support any netCDF calendar. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:35.991620Z", + "start_time": "2018-11-28T20:51:35.960336Z" + } + }, + "outputs": [], + "source": [ + "dpm = {'noleap': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " '365_day': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " 'standard': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " 'gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " 'proleptic_gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " 'all_leap': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " '366_day': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", + " '360_day': [0, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]} " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### A few calendar functions to determine the number of days in each month\n", + "If you were just using the standard calendar, it would be easy to use the `calendar.month_range` function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.015151Z", + "start_time": "2018-11-28T20:51:35.994079Z" + } + }, + "outputs": [], + "source": [ + "def leap_year(year, calendar='standard'):\n", + " \"\"\"Determine if year is a leap year\"\"\"\n", + " leap = False\n", + " if ((calendar in ['standard', 'gregorian',\n", + " 'proleptic_gregorian', 'julian']) and\n", + " (year % 4 == 0)):\n", + " leap = True\n", + " if ((calendar == 'proleptic_gregorian') and\n", + " (year % 100 == 0) and\n", + " (year % 400 != 0)):\n", + " leap = False\n", + " elif ((calendar in ['standard', 'gregorian']) and\n", + " (year % 100 == 0) and (year % 400 != 0) and\n", + " (year < 1583)):\n", + " leap = False\n", + " return leap\n", + "\n", + "def get_dpm(time, calendar='standard'):\n", + " \"\"\"\n", + " return a array of days per month corresponding to the months provided in `months`\n", + " \"\"\"\n", + " month_length = np.zeros(len(time), dtype=np.int)\n", + " \n", + " cal_days = dpm[calendar]\n", + " \n", + " for i, (month, year) in enumerate(zip(time.month, time.year)):\n", + " month_length[i] = cal_days[month]\n", + " if leap_year(year, calendar=calendar) and month == 2:\n", + " month_length[i] += 1\n", + " return month_length" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Open the `Dataset`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.072316Z", + "start_time": "2018-11-28T20:51:36.016594Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.open_dataset('rasm').load()\n", + "print(ds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now for the heavy lifting:\n", + "We first have to come up with the weights,\n", + "- calculate the month lengths for each monthly data record\n", + "- calculate weights using `groupby('time.season')`\n", + "\n", + "Finally, we just need to multiply our weights by the `Dataset` and sum allong the time dimension. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.132413Z", + "start_time": "2018-11-28T20:51:36.073708Z" + } + }, + "outputs": [], + "source": [ + "# Make a DataArray with the number of days in each month, size = len(time)\n", + "month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar='noleap'),\n", + " coords=[ds.time], name='month_length')\n", + "\n", + "# Calculate the weights by grouping by 'time.season'.\n", + "# Conversion to float type ('astype(float)') only necessary for Python 2.x\n", + "weights = month_length.groupby('time.season') / month_length.astype(float).groupby('time.season').sum()\n", + "\n", + "# Test that the sum of the weights for each season is 1.0\n", + "np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4))\n", + "\n", + "# Calculate the weighted average\n", + "ds_weighted = (ds * weights).groupby('time.season').sum(dim='time')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.152913Z", + "start_time": "2018-11-28T20:51:36.133997Z" + } + }, + "outputs": [], + "source": [ + "print(ds_weighted)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.190765Z", + "start_time": "2018-11-28T20:51:36.154416Z" + } + }, + "outputs": [], + "source": [ + "# only used for comparisons\n", + "ds_unweighted = ds.groupby('time.season').mean('time')\n", + "ds_diff = ds_weighted - ds_unweighted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:40.264871Z", + "start_time": "2018-11-28T20:51:36.192467Z" + } + }, + "outputs": [], + "source": [ + "# Quick plot to show the results\n", + "notnull = pd.notnull(ds_unweighted['Tair'][0])\n", + "\n", + "fig, axes = plt.subplots(nrows=4, ncols=3, figsize=(14,12))\n", + "for i, season in enumerate(('DJF', 'MAM', 'JJA', 'SON')):\n", + " ds_weighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", + " ax=axes[i, 0], vmin=-30, vmax=30, cmap='Spectral_r', \n", + " add_colorbar=True, extend='both')\n", + " \n", + " ds_unweighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", + " ax=axes[i, 1], vmin=-30, vmax=30, cmap='Spectral_r', \n", + " add_colorbar=True, extend='both')\n", + "\n", + " ds_diff['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", + " ax=axes[i, 2], vmin=-0.1, vmax=.1, cmap='RdBu_r',\n", + " add_colorbar=True, extend='both')\n", + "\n", + " axes[i, 0].set_ylabel(season)\n", + " axes[i, 1].set_ylabel('')\n", + " axes[i, 2].set_ylabel('')\n", + "\n", + "for ax in axes.flat:\n", + " ax.axes.get_xaxis().set_ticklabels([])\n", + " ax.axes.get_yaxis().set_ticklabels([])\n", + " ax.axes.axis('tight')\n", + " ax.set_xlabel('')\n", + " \n", + "axes[0, 0].set_title('Weighted by DPM')\n", + "axes[0, 1].set_title('Equal Weighting')\n", + "axes[0, 2].set_title('Difference')\n", + " \n", + "plt.tight_layout()\n", + "\n", + "fig.suptitle('Seasonal Surface Air Temperature', fontsize=16, y=1.02)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:51:40.284898Z", + "start_time": "2018-11-28T20:51:40.266406Z" + } + }, + "outputs": [], + "source": [ + "# Wrap it into a simple function\n", + "def season_mean(ds, calendar='standard'):\n", + " # Make a DataArray of season/year groups\n", + " year_season = xr.DataArray(ds.time.to_index().to_period(freq='Q-NOV').to_timestamp(how='E'),\n", + " coords=[ds.time], name='year_season')\n", + "\n", + " # Make a DataArray with the number of days in each month, size = len(time)\n", + " month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar=calendar),\n", + " coords=[ds.time], name='month_length')\n", + " # Calculate the weights by grouping by 'time.season'\n", + " weights = month_length.groupby('time.season') / month_length.groupby('time.season').sum()\n", + "\n", + " # Test that the sum of the weights for each season is 1.0\n", + " np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4))\n", + "\n", + " # Calculate the weighted average\n", + " return (ds * weights).groupby('time.season').sum(dim='time')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/examples/monthly-means.rst b/doc/examples/monthly-means.rst deleted file mode 100644 index 7d620f1bca3..00000000000 --- a/doc/examples/monthly-means.rst +++ /dev/null @@ -1,244 +0,0 @@ -.. _monthly means example: - -Calculating Seasonal Averages from Timeseries of Monthly Means -============================================================== - -Author: `Joe Hamman `__ - -The data used for this example can be found in the -`xarray-data `__ repository. - -Suppose we have a netCDF or ``xarray.Dataset`` of monthly mean data and -we want to calculate the seasonal average. To do this properly, we need -to calculate the weighted average considering that each month has a -different number of days. - -.. code:: python - - %matplotlib inline - import numpy as np - import pandas as pd - import xarray as xr - from netCDF4 import num2date - import matplotlib.pyplot as plt - - print("numpy version : ", np.__version__) - print("pandas version : ", pd.__version__) - print("xarray version : ", xr.__version__) - - -.. parsed-literal:: - - numpy version : 1.11.1 - pandas version : 0.18.1 - xarray version : 0.8.2 - - -Some calendar information so we can support any netCDF calendar. -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. code:: python - - dpm = {'noleap': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - '365_day': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - 'standard': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - 'gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - 'proleptic_gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - 'all_leap': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - '366_day': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], - '360_day': [0, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]} - -A few calendar functions to determine the number of days in each month -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -If you were just using the standard calendar, it would be easy to use -the ``calendar.month_range`` function. - -.. code:: python - - def leap_year(year, calendar='standard'): - """Determine if year is a leap year""" - leap = False - if ((calendar in ['standard', 'gregorian', - 'proleptic_gregorian', 'julian']) and - (year % 4 == 0)): - leap = True - if ((calendar == 'proleptic_gregorian') and - (year % 100 == 0) and - (year % 400 != 0)): - leap = False - elif ((calendar in ['standard', 'gregorian']) and - (year % 100 == 0) and (year % 400 != 0) and - (year < 1583)): - leap = False - return leap - - def get_dpm(time, calendar='standard'): - """ - return a array of days per month corresponding to the months provided in `months` - """ - month_length = np.zeros(len(time), dtype=np.int) - - cal_days = dpm[calendar] - - for i, (month, year) in enumerate(zip(time.month, time.year)): - month_length[i] = cal_days[month] - if leap_year(year, calendar=calendar) and month == 2: - month_length[i] += 1 - return month_length - -Open the ``Dataset`` -^^^^^^^^^^^^^^^^^^^^ - -.. code:: python - - ds = xr.tutorial.load_dataset('rasm') - print(ds) - - -.. parsed-literal:: - - - Dimensions: (time: 36, x: 275, y: 205) - Coordinates: - * time (time) datetime64[ns] 1980-09-16T12:00:00 1980-10-17 ... - * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... - * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... - Data variables: - Tair (time, y, x) float64 nan nan nan nan nan nan nan nan nan nan ... - yc (y, x) float64 16.53 16.78 17.02 17.27 17.51 17.76 18.0 18.25 ... - xc (y, x) float64 189.2 189.4 189.6 189.7 189.9 190.1 190.2 190.4 ... - Attributes: - title: /workspace/jhamman/processed/R1002RBRxaaa01a/lnd/temp/R1002RBRxaaa01a.vic.ha.1979-09-01.nc - institution: U.W. - source: RACM R1002RBRxaaa01a - output_frequency: daily - output_mode: averaged - convention: CF-1.4 - references: Based on the initial model of Liang et al., 1994, JGR, 99, 14,415- 14,429. - comment: Output from the Variable Infiltration Capacity (VIC) model. - nco_openmp_thread_number: 1 - NCO: 4.3.7 - history: history deleted for brevity - - -Now for the heavy lifting: -^^^^^^^^^^^^^^^^^^^^^^^^^^ - -We first have to come up with the weights, - calculate the month lengths -for each monthly data record - calculate weights using -``groupby('time.season')`` - -Finally, we just need to multiply our weights by the ``Dataset`` and sum -along the time dimension. - -.. code:: python - - # Make a DataArray with the number of days in each month, size = len(time) - month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar='noleap'), - coords=[ds.time], name='month_length') - - # Calculate the weights by grouping by 'time.season'. - # Conversion to float type ('astype(float)') only necessary for Python 2.x - weights = month_length.groupby('time.season') / month_length.astype(float).groupby('time.season').sum() - - # Test that the sum of the weights for each season is 1.0 - np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4)) - - # Calculate the weighted average - ds_weighted = (ds * weights).groupby('time.season').sum(dim='time') - -.. code:: python - - print(ds_weighted) - - -.. parsed-literal:: - - - Dimensions: (season: 4, x: 275, y: 205) - Coordinates: - * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... - * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... - * season (season) object 'DJF' 'JJA' 'MAM' 'SON' - Data variables: - Tair (season, y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... - xc (season, y, x) float64 189.2 189.4 189.6 189.7 189.9 190.1 ... - yc (season, y, x) float64 16.53 16.78 17.02 17.27 17.51 17.76 18.0 ... - - -.. code:: python - - # only used for comparisons - ds_unweighted = ds.groupby('time.season').mean('time') - ds_diff = ds_weighted - ds_unweighted - -.. code:: python - - # Quick plot to show the results - notnull = pd.notnull(ds_unweighted['Tair'][0]) - - fig, axes = plt.subplots(nrows=4, ncols=3, figsize=(14,12)) - for i, season in enumerate(('DJF', 'MAM', 'JJA', 'SON')): - ds_weighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh( - ax=axes[i, 0], vmin=-30, vmax=30, cmap='Spectral_r', - add_colorbar=True, extend='both') - - ds_unweighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh( - ax=axes[i, 1], vmin=-30, vmax=30, cmap='Spectral_r', - add_colorbar=True, extend='both') - - ds_diff['Tair'].sel(season=season).where(notnull).plot.pcolormesh( - ax=axes[i, 2], vmin=-0.1, vmax=.1, cmap='RdBu_r', - add_colorbar=True, extend='both') - - axes[i, 0].set_ylabel(season) - axes[i, 1].set_ylabel('') - axes[i, 2].set_ylabel('') - - for ax in axes.flat: - ax.axes.get_xaxis().set_ticklabels([]) - ax.axes.get_yaxis().set_ticklabels([]) - ax.axes.axis('tight') - ax.set_xlabel('') - - axes[0, 0].set_title('Weighted by DPM') - axes[0, 1].set_title('Equal Weighting') - axes[0, 2].set_title('Difference') - - plt.tight_layout() - - fig.suptitle('Seasonal Surface Air Temperature', fontsize=16, y=1.02) - - - - -.. parsed-literal:: - - - - - - -.. image:: monthly_means_output.png - - -.. code:: python - - # Wrap it into a simple function - def season_mean(ds, calendar='standard'): - # Make a DataArray of season/year groups - year_season = xr.DataArray(ds.time.to_index().to_period(freq='Q-NOV').to_timestamp(how='E'), - coords=[ds.time], name='year_season') - - # Make a DataArray with the number of days in each month, size = len(time) - month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar=calendar), - coords=[ds.time], name='month_length') - # Calculate the weights by grouping by 'time.season' - weights = month_length.groupby('time.season') / month_length.groupby('time.season').sum() - - # Test that the sum of the weights for each season is 1.0 - np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4)) - - # Calculate the weighted average - return (ds * weights).groupby('time.season').sum(dim='time') diff --git a/doc/examples/multidimensional-coords.ipynb b/doc/examples/multidimensional-coords.ipynb new file mode 100644 index 00000000000..6fa9ddff5f5 --- /dev/null +++ b/doc/examples/multidimensional-coords.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Working with Multidimensional Coordinates\n", + "\n", + "Author: [Ryan Abernathey](https://github.com/rabernat)\n", + "\n", + "Many datasets have _physical coordinates_ which differ from their _logical coordinates_. Xarray provides several ways to plot and analyze such datasets." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:49:56.068395Z", + "start_time": "2018-11-28T20:49:56.035349Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import cartopy.crs as ccrs\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As an example, consider this dataset from the [xarray-data](https://github.com/pydata/xarray-data) repository." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:13.629720Z", + "start_time": "2018-11-28T20:50:13.484542Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.open_dataset('rasm').load()\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, the _logical coordinates_ are `x` and `y`, while the _physical coordinates_ are `xc` and `yc`, which represent the latitudes and longitude of the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:15.836061Z", + "start_time": "2018-11-28T20:50:15.768376Z" + } + }, + "outputs": [], + "source": [ + "print(ds.xc.attrs)\n", + "print(ds.yc.attrs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting ##\n", + "\n", + "Let's examine these coordinate variables by plotting them." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:17.928556Z", + "start_time": "2018-11-28T20:50:17.031211Z" + } + }, + "outputs": [], + "source": [ + "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14,4))\n", + "ds.xc.plot(ax=ax1)\n", + "ds.yc.plot(ax=ax2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the variables `xc` (longitude) and `yc` (latitude) are two-dimensional scalar fields.\n", + "\n", + "If we try to plot the data variable `Tair`, by default we get the logical coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:20.567749Z", + "start_time": "2018-11-28T20:50:19.999393Z" + } + }, + "outputs": [], + "source": [ + "ds.Tair[0].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to visualize the data on a conventional latitude-longitude grid, we can take advantage of xarray's ability to apply [cartopy](http://scitools.org.uk/cartopy/index.html) map projections." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:31.131708Z", + "start_time": "2018-11-28T20:50:30.444697Z" + } + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(14,6))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.set_global()\n", + "ds.Tair[0].plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), x='xc', y='yc', add_colorbar=False)\n", + "ax.coastlines()\n", + "ax.set_ylim([0,90]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multidimensional Groupby ##\n", + "\n", + "The above example allowed us to visualize the data on a regular latitude-longitude grid. But what if we want to do a calculation that involves grouping over one of these physical coordinates (rather than the logical coordinates), for example, calculating the mean temperature at each latitude. This can be achieved using xarray's `groupby` function, which accepts multidimensional variables. By default, `groupby` will use every unique value in the variable, which is probably not what we want. Instead, we can use the `groupby_bins` function to specify the output coordinates of the group. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2018-11-28T20:50:43.670463Z", + "start_time": "2018-11-28T20:50:43.245501Z" + } + }, + "outputs": [], + "source": [ + "# define two-degree wide latitude bins\n", + "lat_bins = np.arange(0,91,2)\n", + "# define a label for each bin corresponding to the central latitude\n", + "lat_center = np.arange(1,90,2)\n", + "# group according to those bins and take the mean\n", + "Tair_lat_mean = ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center).mean(dim=xr.ALL_DIMS)\n", + "# plot the result\n", + "Tair_lat_mean.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting coordinate for the `groupby_bins` operation got the `_bins` suffix appended: `xc_bins`. This help us distinguish it from the original multidimensional variable `xc`.\n", + "\n", + "**Note**: This group-by-latitude approach does not take into account the finite-size geometry of grid cells. It simply bins each value according to the coordinates at the cell center. Xarray has no understanding of grid cells and their geometry. More precise geographic regridding for Xarray data is available via the [xesmf](https://xesmf.readthedocs.io) package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/examples/multidimensional-coords.rst b/doc/examples/multidimensional-coords.rst deleted file mode 100644 index 55569b7662a..00000000000 --- a/doc/examples/multidimensional-coords.rst +++ /dev/null @@ -1,118 +0,0 @@ -.. _examples.multidim: - -Working with Multidimensional Coordinates -========================================= - -Author: `Ryan Abernathey `__ - -Many datasets have *physical coordinates* which differ from their -*logical coordinates*. Xarray provides several ways to plot and analyze -such datasets. - - -.. ipython:: python - - import numpy as np - import pandas as pd - import xarray as xr - import netCDF4 - import cartopy.crs as ccrs - import matplotlib.pyplot as plt - -As an example, consider this dataset from the -`xarray-data `__ repository. - - -.. ipython:: python - - ds = xr.tutorial.open_dataset('rasm').load() - ds - -In this example, the *logical coordinates* are ``x`` and ``y``, while -the *physical coordinates* are ``xc`` and ``yc``, which represent the -latitudes and longitude of the data. - - -.. ipython:: python - - ds.xc.attrs - ds.yc.attrs - - -Plotting --------- - -Let's examine these coordinate variables by plotting them. - -.. ipython:: python - - fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(9,3)) - ds.xc.plot(ax=ax1); - @savefig xarray_multidimensional_coords_8_2.png width=100% - ds.yc.plot(ax=ax2); - -Note that the variables ``xc`` (longitude) and ``yc`` (latitude) are -two-dimensional scalar fields. - -If we try to plot the data variable ``Tair``, by default we get the -logical coordinates. - -.. ipython:: python - :suppress: - - f = plt.figure(figsize=(6, 4)) - -.. ipython:: python - - @savefig xarray_multidimensional_coords_10_1.png width=5in - ds.Tair[0].plot(); - - -In order to visualize the data on a conventional latitude-longitude -grid, we can take advantage of xarray's ability to apply -`cartopy `__ map projections. - -.. ipython:: python - - plt.figure(figsize=(7,2)); - ax = plt.axes(projection=ccrs.PlateCarree()); - ds.Tair[0].plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), - x='xc', y='yc', add_colorbar=False); - @savefig xarray_multidimensional_coords_12_0.png width=100% - ax.coastlines(); - -Multidimensional Groupby ------------------------- - -The above example allowed us to visualize the data on a regular -latitude-longitude grid. But what if we want to do a calculation that -involves grouping over one of these physical coordinates (rather than -the logical coordinates), for example, calculating the mean temperature -at each latitude. This can be achieved using xarray's ``groupby`` -function, which accepts multidimensional variables. By default, -``groupby`` will use every unique value in the variable, which is -probably not what we want. Instead, we can use the ``groupby_bins`` -function to specify the output coordinates of the group. - -.. ipython:: python - :suppress: - - f = plt.figure(figsize=(6, 4.5)) - -.. ipython:: python - - # define two-degree wide latitude bins - lat_bins = np.arange(0, 91, 2) - # define a label for each bin corresponding to the central latitude - lat_center = np.arange(1, 90, 2) - # group according to those bins and take the mean - Tair_lat_mean = (ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center) - .mean(...)) - # plot the result - @savefig xarray_multidimensional_coords_14_1.png width=5in - Tair_lat_mean.plot(); - - -Note that the resulting coordinate for the ``groupby_bins`` operation -got the ``_bins`` suffix appended: ``xc_bins``. This help us distinguish -it from the original multidimensional variable ``xc``. diff --git a/doc/examples/visualization_gallery.ipynb b/doc/examples/visualization_gallery.ipynb new file mode 100644 index 00000000000..f8d5b1ae458 --- /dev/null +++ b/doc/examples/visualization_gallery.ipynb @@ -0,0 +1,296 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualization Gallery\n", + "\n", + "This notebook shows common visualization issues encountered in Xarray." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load example dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset('air_temperature')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multiple plots and map projections\n", + "\n", + "Control the map projection parameters on multiple axes\n", + "\n", + "This example illustrates how to plot multiple maps and control their extent\n", + "and aspect ratio.\n", + "\n", + "For more details see [this discussion](https://github.com/pydata/xarray/issues/1397#issuecomment-299190567) on github." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "air = ds.air.isel(time=[0, 724]) - 273.15\n", + "\n", + "# This is the map projection we want to plot *onto*\n", + "map_proj = ccrs.LambertConformal(central_longitude=-95, central_latitude=45)\n", + "\n", + "p = air.plot(transform=ccrs.PlateCarree(), # the data's projection\n", + " col='time', col_wrap=1, # multiplot settings\n", + " aspect=ds.dims['lon'] / ds.dims['lat'], # for a sensible figsize\n", + " subplot_kws={'projection': map_proj}) # the plot's projection\n", + "\n", + "# We have to set the map's options on all axes\n", + "for ax in p.axes.flat:\n", + " ax.coastlines()\n", + " ax.set_extent([-160, -30, 5, 75])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Centered colormaps\n", + "\n", + "Xarray's automatic colormaps choice" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "air = ds.air.isel(time=0)\n", + "\n", + "f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(8, 6))\n", + "\n", + "# The first plot (in kelvins) chooses \"viridis\" and uses the data's min/max\n", + "air.plot(ax=ax1, cbar_kwargs={'label': 'K'})\n", + "ax1.set_title('Kelvins: default')\n", + "ax2.set_xlabel('')\n", + "\n", + "# The second plot (in celsius) now chooses \"BuRd\" and centers min/max around 0\n", + "airc = air - 273.15\n", + "airc.plot(ax=ax2, cbar_kwargs={'label': '°C'})\n", + "ax2.set_title('Celsius: default')\n", + "ax2.set_xlabel('')\n", + "ax2.set_ylabel('')\n", + "\n", + "# The center doesn't have to be 0\n", + "air.plot(ax=ax3, center=273.15, cbar_kwargs={'label': 'K'})\n", + "ax3.set_title('Kelvins: center=273.15')\n", + "\n", + "# Or it can be ignored\n", + "airc.plot(ax=ax4, center=False, cbar_kwargs={'label': '°C'})\n", + "ax4.set_title('Celsius: center=False')\n", + "ax4.set_ylabel('')\n", + "\n", + "# Make it nice\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Control the plot's colorbar\n", + "\n", + "Use ``cbar_kwargs`` keyword to specify the number of ticks.\n", + "The ``spacing`` kwarg can be used to draw proportional ticks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "air2d = ds.air.isel(time=500)\n", + "\n", + "# Prepare the figure\n", + "f, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(14, 4))\n", + "\n", + "# Irregular levels to illustrate the use of a proportional colorbar\n", + "levels = [245, 250, 255, 260, 265, 270, 275, 280, 285, 290, 310, 340]\n", + "\n", + "# Plot data\n", + "air2d.plot(ax=ax1, levels=levels)\n", + "air2d.plot(ax=ax2, levels=levels, cbar_kwargs={'ticks': levels})\n", + "air2d.plot(ax=ax3, levels=levels, cbar_kwargs={'ticks': levels,\n", + " 'spacing': 'proportional'})\n", + "\n", + "# Show plots\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multiple lines from a 2d DataArray\n", + "\n", + "Use ``xarray.plot.line`` on a 2d DataArray to plot selections as\n", + "multiple lines.\n", + "\n", + "See ``plotting.multiplelines`` for more details." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "air = ds.air - 273.15 # to celsius\n", + "\n", + "# Prepare the figure\n", + "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharey=True)\n", + "\n", + "# Selected latitude indices\n", + "isel_lats = [10, 15, 20]\n", + "\n", + "# Temperature vs longitude plot - illustrates the \"hue\" kwarg\n", + "air.isel(time=0, lat=isel_lats).plot.line(ax=ax1, hue='lat')\n", + "ax1.set_ylabel('°C')\n", + "\n", + "# Temperature vs time plot - illustrates the \"x\" and \"add_legend\" kwargs\n", + "air.isel(lon=30, lat=isel_lats).plot.line(ax=ax2, x='time', add_legend=False)\n", + "ax2.set_ylabel('')\n", + "\n", + "# Show\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `imshow()` and rasterio map projections\n", + "\n", + "\n", + "Using rasterio's projection information for more accurate plots.\n", + "\n", + "This example extends `recipes.rasterio` and plots the image in the\n", + "original map projection instead of relying on pcolormesh and a map\n", + "transformation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "url = 'https://github.com/mapbox/rasterio/raw/master/tests/data/RGB.byte.tif'\n", + "da = xr.open_rasterio(url)\n", + "\n", + "# The data is in UTM projection. We have to set it manually until\n", + "# https://github.com/SciTools/cartopy/issues/813 is implemented\n", + "crs = ccrs.UTM('18N')\n", + "\n", + "# Plot on a map\n", + "ax = plt.subplot(projection=crs)\n", + "da.plot.imshow(ax=ax, rgb='band', transform=crs)\n", + "ax.coastlines('10m', color='r')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parsing rasterio geocoordinates\n", + "\n", + "Converting a projection's cartesian coordinates into 2D longitudes and\n", + "latitudes.\n", + "\n", + "These new coordinates might be handy for plotting and indexing, but it should\n", + "be kept in mind that a grid which is regular in projection coordinates will\n", + "likely be irregular in lon/lat. It is often recommended to work in the data's\n", + "original map projection (see `recipes.rasterio_rgb`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from rasterio.warp import transform\n", + "import numpy as np\n", + "\n", + "url = 'https://github.com/mapbox/rasterio/raw/master/tests/data/RGB.byte.tif'\n", + "da = xr.open_rasterio(url)\n", + "\n", + "# Compute the lon/lat coordinates with rasterio.warp.transform\n", + "ny, nx = len(da['y']), len(da['x'])\n", + "x, y = np.meshgrid(da['x'], da['y'])\n", + "\n", + "# Rasterio works with 1D arrays\n", + "lon, lat = transform(da.crs, {'init': 'EPSG:4326'},\n", + " x.flatten(), y.flatten())\n", + "lon = np.asarray(lon).reshape((ny, nx))\n", + "lat = np.asarray(lat).reshape((ny, nx))\n", + "da.coords['lon'] = (('y', 'x'), lon)\n", + "da.coords['lat'] = (('y', 'x'), lat)\n", + "\n", + "# Compute a greyscale out of the rgb image\n", + "greyscale = da.mean(dim='band')\n", + "\n", + "# Plot on a map\n", + "ax = plt.subplot(projection=ccrs.PlateCarree())\n", + "greyscale.plot(ax=ax, x='lon', y='lat', transform=ccrs.PlateCarree(),\n", + " cmap='Greys_r', add_colorbar=False)\n", + "ax.coastlines('10m', color='r')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/io.rst b/doc/io.rst index 986c4374e89..2e50e5639da 100644 --- a/doc/io.rst +++ b/doc/io.rst @@ -749,8 +749,8 @@ The ``x`` and ``y`` coordinates are generated out of the file's metadata (``bounds``, ``width``, ``height``), and they can be understood as cartesian coordinates defined in the file's projection provided by the ``crs`` attribute. ``crs`` is a PROJ4 string which can be parsed by e.g. `pyproj`_ or rasterio. -See :ref:`recipes.rasterio` for an example of how to convert these to -longitudes and latitudes. +See :ref:`/examples/visualization_gallery.ipynb#Parsing-rasterio-geocoordinates` +for an example of how to convert these to longitudes and latitudes. .. warning:: diff --git a/doc/pandas.rst b/doc/pandas.rst index 4f3088b4c34..72abf6609f6 100644 --- a/doc/pandas.rst +++ b/doc/pandas.rst @@ -112,7 +112,7 @@ automatically stacking them into a ``MultiIndex``. :py:meth:`DataArray.to_pandas() ` is a shortcut that lets you convert a DataArray directly into a pandas object with the same dimensionality (i.e., a 1D array is converted to a :py:class:`~pandas.Series`, -2D to :py:class:`~pandas.DataFrame` and 3D to :py:class:`~pandas.Panel`): +2D to :py:class:`~pandas.DataFrame` and 3D to ``pandas.Panel``): .. ipython:: python diff --git a/doc/plotting.rst b/doc/plotting.rst index e9d30fb63c8..270988b99de 100644 --- a/doc/plotting.rst +++ b/doc/plotting.rst @@ -782,7 +782,7 @@ coordinates. Multidimensional coordinates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -See also: :ref:`examples.multidim`. +See also: :ref:`/examples/multidimensional-coords.ipynb`. You can plot irregular grids defined by multidimensional coordinates with xarray, but you'll have to tell the plot function to use these coordinates diff --git a/doc/related-projects.rst b/doc/related-projects.rst index fd77ce56a0a..a8af05f3074 100644 --- a/doc/related-projects.rst +++ b/doc/related-projects.rst @@ -25,6 +25,7 @@ Geosciences - `PyGDX `_: Python 3 package for accessing data stored in GAMS Data eXchange (GDX) files. Also uses a custom subclass. +- `pyXpcm `_: xarray-based Profile Classification Modelling (PCM), mostly for ocean data. - `Regionmask `_: plotting and creation of masks of spatial regions - `rioxarray `_: geospatial xarray extension powered by rasterio - `salem `_: Adds geolocalised subsetting, masking, and plotting operations to xarray's data structures via accessors. diff --git a/doc/whats-new.rst b/doc/whats-new.rst index cb0d965e5dc..219b2184b5c 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -13,18 +13,67 @@ What's New import xarray as xr np.random.seed(123456) -.. _whats-new.0.14.1: +.. _whats-new.0.15.0: -v0.14.1 (unreleased) + +v0.15.0 (unreleased) -------------------- Breaking changes ~~~~~~~~~~~~~~~~ -- Broken compatibility with cftime < 1.0.3. + +New Features +~~~~~~~~~~~~ +- :py:meth:`Dataset.quantile`, :py:meth:`DataArray.quantile` and ``GroupBy.quantile`` + now work with dask Variables. By `Deepak Cherian `_. +- Added the :py:meth:`count` reduction method to both :py:class:`DatasetCoarsen` + and :py:class:`DataArrayCoarsen` objects. (:pull:`3500`) + By `Deepak Cherian `_ - .. note:: +Bug fixes +~~~~~~~~~ +- Fix plotting with transposed 2D non-dimensional coordinates. (:issue:`3138`, :pull:`3441`) + By `Deepak Cherian `_. + + +Documentation +~~~~~~~~~~~~~ +- Switch doc examples to use nbsphinx and replace sphinx_gallery with + notebook. + (:pull:`3105`, :pull:`3106`, :pull:`3121`) + By `Ryan Abernathey ` +- Added example notebook demonstrating use of xarray with Regional Ocean + Modeling System (ROMS) ocean hydrodynamic model output. + (:pull:`3116`). + By `Robert Hetland ` +- Added example notebook demonstrating the visualization of ERA5 GRIB + data. (:pull:`3199`) + By `Zach Bruick ` and + `Stephan Siemen ` +- Added examples for `DataArray.quantile`, `Dataset.quantile` and + `GroupBy.quantile`. (:pull:`3576`) + By `Justus Magin `_. + +Internal Changes +~~~~~~~~~~~~~~~~ + + +- Removed internal method ``Dataset._from_vars_and_coord_names``, + which was dominated by ``Dataset._construct_direct``. (:pull:`3565`) + By `Maximilian Roos `_ + + +v0.14.1 (19 Nov 2019) +--------------------- + +Breaking changes +~~~~~~~~~~~~~~~~ + +- Broken compatibility with ``cftime < 1.0.3`` . By `Deepak Cherian `_. + + .. warning:: cftime version 1.0.4 is broken (`cftime/126 `_); @@ -34,24 +83,37 @@ Breaking changes module included in versions of netCDF4 prior to 1.4 that eventually became the cftime package, has been removed in favor of relying solely on the standalone ``cftime`` package (:pull:`3450`). + `cftime `_ package, has been removed in favor of relying solely on + the standalone ``cftime`` package (:pull:`3450`). By `Spencer Clark `_. New Features ~~~~~~~~~~~~ -- :py:meth:`Dataset.drop_sel` & :py:meth:`DataArray.drop_sel` have been added for dropping labels. +- Added the ``sparse`` option to :py:meth:`~xarray.DataArray.unstack`, + :py:meth:`~xarray.Dataset.unstack`, :py:meth:`~xarray.DataArray.reindex`, + :py:meth:`~xarray.Dataset.reindex` (:issue:`3518`). + By `Keisuke Fujii `_. +- Added the ``fill_value`` option to :py:meth:`DataArray.unstack` and + :py:meth:`Dataset.unstack` (:issue:`3518`, :pull:`3541`). + By `Keisuke Fujii `_. +- Added the ``max_gap`` kwarg to :py:meth:`~xarray.DataArray.interpolate_na` and + :py:meth:`~xarray.Dataset.interpolate_na`. This controls the maximum size of the data + gap that will be filled by interpolation. By `Deepak Cherian `_. +- Added :py:meth:`Dataset.drop_sel` & :py:meth:`DataArray.drop_sel` for dropping labels. :py:meth:`Dataset.drop_vars` & :py:meth:`DataArray.drop_vars` have been added for - dropping variables (including coordinates). The existing ``drop`` methods remain as a backward compatible + dropping variables (including coordinates). The existing :py:meth:`Dataset.drop` & + :py:meth:`DataArray.drop` methods remain as a backward compatible option for dropping either labels or variables, but using the more specific methods is encouraged. (:pull:`3475`) By `Maximilian Roos `_ -- :py:meth:`Dataset.map` & :py:meth:`GroupBy.map` & :py:meth:`Resample.map` have been added for +- Added :py:meth:`Dataset.map` & :py:meth:`GroupBy.map` & :py:meth:`Resample.map` for mapping / applying a function over each item in the collection, reflecting the widely used and least surprising name for this operation. The existing ``apply`` methods remain for backward compatibility, though using the ``map`` methods is encouraged. (:pull:`3459`) By `Maximilian Roos `_ -- :py:meth:`Dataset.transpose` and :py:meth:`DataArray.transpose` now support an ellipsis (`...`) +- :py:meth:`Dataset.transpose` and :py:meth:`DataArray.transpose` now support an ellipsis (``...``) to represent all 'other' dimensions. For example, to move one dimension to the front, use ``.transpose('x', ...)``. (:pull:`3421`) By `Maximilian Roos `_ @@ -59,56 +121,76 @@ New Features `...` directly. As before, you can use this to instruct a ``groupby`` operation to reduce over all dimensions. While we have no plans to remove ``xr.ALL_DIMS``, we suggest using `...`. (:pull:`3418`) +- Changed ``xr.ALL_DIMS`` to equal python's ``Ellipsis`` (``...``), and changed internal usages to use + ``...`` directly. As before, you can use this to instruct a ``groupby`` operation + to reduce over all dimensions. While we have no plans to remove ``xr.ALL_DIMS``, we suggest + using ``...``. (:pull:`3418`) By `Maximilian Roos `_ - :py:func:`xarray.dot`, and :py:meth:`DataArray.dot` now support the ``dims=...`` option to sum over the union of dimensions of all input arrays (:issue:`3423`) by `Mathias Hauser `_. - Added new :py:meth:`Dataset._repr_html_` and :py:meth:`DataArray._repr_html_` to improve - representation of objects in jupyter. By default this feature is turned off - for now. Enable it with :py:meth:`xarray.set_options(display_style="html")`. + representation of objects in Jupyter. By default this feature is turned off + for now. Enable it with ``xarray.set_options(display_style="html")``. (:pull:`3425`) by `Benoit Bovy `_ and `Julia Signell `_. - Implement `dask deterministic hashing `_ for xarray objects. Note that xarray objects with a dask.array backend already used deterministic hashing in previous releases; this change implements it when whole - xarray objects are embedded in a dask graph, e.g. when :meth:`DataArray.map` is + xarray objects are embedded in a dask graph, e.g. when :py:meth:`DataArray.map` is invoked. (:issue:`3378`, :pull:`3446`, :pull:`3515`) By `Deepak Cherian `_ and `Guido Imperiale `_. - xarray now respects the ``DataArray.encoding["coordinates"]`` attribute when writing to disk. See :ref:`io.coordinates` for more. (:issue:`3351`, :pull:`3487`) By `Deepak Cherian `_. +- Add the documented-but-missing :py:meth:`DatasetGroupBy.quantile`. + (:issue:`3525`, :pull:`3527`). By `Justus Magin `_. Bug fixes ~~~~~~~~~ +- Ensure an index of type ``CFTimeIndex`` is not converted to a ``DatetimeIndex`` when + calling :py:meth:`Dataset.rename`, :py:meth:`Dataset.rename_dims` and :py:meth:`Dataset.rename_vars`. + By `Mathias Hauser `_. (:issue:`3522`). +- Fix a bug in :py:meth:`DataArray.set_index` in case that an existing dimension becomes a level + variable of MultiIndex. (:pull:`3520`). By `Keisuke Fujii `_. +- Harmonize ``_FillValue``, ``missing_value`` during encoding and decoding steps. (:pull:`3502`) + By `Anderson Banihirwe `_. - Fix regression introduced in v0.14.0 that would cause a crash if dask is installed but cloudpickle isn't (:issue:`3401`) by `Rhys Doyle `_ - Fix grouping over variables with NaNs. (:issue:`2383`, :pull:`3406`). By `Deepak Cherian `_. -- Use dask names to compare dask objects prior to comparing values after computation. +- Make alignment and concatenation significantly more efficient by using dask names to compare dask + objects prior to comparing values after computation. This change makes it more convenient to carry + around large non-dimensional coordinate variables backed by dask arrays. Existing workarounds involving + ``reset_coords(drop=True)`` should now be unnecessary in most cases. (:issue:`3068`, :issue:`3311`, :issue:`3454`, :pull:`3453`). By `Deepak Cherian `_. -- Sync with cftime by removing `dayofwk=-1` for cftime>=1.0.4. - By `Anderson Banihirwe `_. +- Add support for cftime>=1.0.4. By `Anderson Banihirwe `_. - Rolling reduction operations no longer compute dask arrays by default. (:issue:`3161`). In addition, the ``allow_lazy`` kwarg to ``reduce`` is deprecated. By `Deepak Cherian `_. -- Fix :py:meth:`xarray.core.groupby.DataArrayGroupBy.reduce` and - :py:meth:`xarray.core.groupby.DatasetGroupBy.reduce` when reducing over multiple dimensions. - (:issue:`3402`). By `Deepak Cherian `_ +- Fix :py:meth:`GroupBy.reduce` when reducing over multiple dimensions. + (:issue:`3402`). By `Deepak Cherian `_ - Allow appending datetime and bool data variables to zarr stores. - (:issue:`3480`). By `Akihiro Matsukawa `_. + (:issue:`3480`). By `Akihiro Matsukawa `_. +- Add support for numpy >=1.18 (); bugfix mean() on datetime64 arrays on dask backend + (:issue:`3409`, :pull:`3537`). By `Guido Imperiale `_. +- Add support for pandas >=0.26 (:issue:`3440`). + By `Deepak Cherian `_. +- Add support for pseudonetcdf >=3.1 (:pull:`3485`). + By `Barron Henderson `_. Documentation ~~~~~~~~~~~~~ -- Fix leap year condition in example (http://xarray.pydata.org/en/stable/examples/monthly-means.html) - by `Mickaël Lalande `_. +- Fix leap year condition in `monthly means example `_. + By `Mickaël Lalande `_. - Fix the documentation of :py:meth:`DataArray.resample` and - :py:meth:`Dataset.resample` and explicitly state that a + :py:meth:`Dataset.resample`, explicitly stating that a datetime-like dimension is required. (:pull:`3400`) By `Justus Magin `_. -- Update the terminology page to address multidimensional coordinates. (:pull:`3410`) +- Update the :ref:`terminology` page to address multidimensional coordinates. (:pull:`3410`) By `Jon Thielen `_. - Fix the documentation of :py:meth:`Dataset.integrate` and :py:meth:`DataArray.integrate` and add an example to @@ -117,9 +199,9 @@ Documentation Internal Changes ~~~~~~~~~~~~~~~~ - - Added integration tests against `pint `_. - (:pull:`3238`, :pull:`3447`, :pull:`3508`) by `Justus Magin `_. + (:pull:`3238`, :pull:`3447`, :pull:`3493`, :pull:`3508`) + by `Justus Magin `_. .. note:: @@ -138,6 +220,9 @@ Internal Changes - Enable type checking on default sentinel values (:pull:`3472`) By `Maximilian Roos `_ +- Add :py:meth:`Variable._replace` for simpler replacing of a subset of attributes (:pull:`3472`) + By `Maximilian Roos `_ + .. _whats-new.0.14.0: v0.14.0 (14 Oct 2019) @@ -168,15 +253,15 @@ Breaking changes (:issue:`3222`, :issue:`3293`, :issue:`3340`, :issue:`3346`, :issue:`3358`). By `Guido Imperiale `_. -- Dropped the `drop=False` optional parameter from :meth:`Variable.isel`. +- Dropped the ``drop=False`` optional parameter from :py:meth:`Variable.isel`. It was unused and doesn't make sense for a Variable. (:pull:`3375`). By `Guido Imperiale `_. -- Remove internal usage of `collections.OrderedDict`. After dropping support for - Python <=3.5, most uses of `OrderedDict` in Xarray were no longer necessary. We - have removed the internal use of the `OrderedDict` in favor of Python's builtin - `dict` object which is now ordered itself. This change will be most obvious when - interacting with the `attrs` property on the Dataset and DataArray objects. +- Remove internal usage of :py:class:`collections.OrderedDict`. After dropping support for + Python <=3.5, most uses of ``OrderedDict`` in Xarray were no longer necessary. We + have removed the internal use of the ``OrderedDict`` in favor of Python's builtin + ``dict`` object which is now ordered itself. This change will be most obvious when + interacting with the ``attrs`` property on Dataset and DataArray objects. (:issue:`3380`, :pull:`3389`). By `Joe Hamman `_. New functions/methods @@ -202,48 +287,48 @@ Enhancements - Added a ``GroupBy.dims`` property that mirrors the dimensions of each group (:issue:`3344`). -- Speed up :meth:`Dataset.isel` up to 33% and :meth:`DataArray.isel` up to 25% for small +- Speed up :py:meth:`Dataset.isel` up to 33% and :py:meth:`DataArray.isel` up to 25% for small arrays (:issue:`2799`, :pull:`3375`). By `Guido Imperiale `_. Bug fixes ~~~~~~~~~ - Reintroduce support for :mod:`weakref` (broken in v0.13.0). Support has been - reinstated for :class:`DataArray` and :class:`Dataset` objects only. Internal xarray - objects remain unaddressable by weakref in order to save memory + reinstated for :py:class:`~xarray.DataArray` and :py:class:`~xarray.Dataset` objects only. + Internal xarray objects remain unaddressable by weakref in order to save memory (:issue:`3317`). By `Guido Imperiale `_. - Line plots with the ``x`` or ``y`` argument set to a 1D non-dimensional coord now plot the correct data for 2D DataArrays - (:issue:`3334`). By `Tom Nicholas `_. + (:issue:`3334`). By `Tom Nicholas `_. - Make :py:func:`~xarray.concat` more robust when merging variables present in some datasets but - not others (:issue:`508`). By `Deepak Cherian `_. + not others (:issue:`508`). By `Deepak Cherian `_. - The default behaviour of reducing across all dimensions for :py:class:`~xarray.core.groupby.DataArrayGroupBy` objects has now been properly removed as was done for :py:class:`~xarray.core.groupby.DatasetGroupBy` in 0.13.0 (:issue:`3337`). - Use `xarray.ALL_DIMS` if you need to replicate previous behaviour. + Use ``xarray.ALL_DIMS`` if you need to replicate previous behaviour. Also raise nicer error message when no groups are created (:issue:`1764`). By `Deepak Cherian `_. - Fix error in concatenating unlabeled dimensions (:pull:`3362`). - By `Deepak Cherian `_. + By `Deepak Cherian `_. - Warn if the ``dim`` kwarg is passed to rolling operations. This is redundant since a dimension is specified when the :py:class:`DatasetRolling` or :py:class:`DataArrayRolling` object is created. - (:pull:`3362`). By `Deepak Cherian `_. + (:pull:`3362`). By `Deepak Cherian `_. Documentation ~~~~~~~~~~~~~ - Created a glossary of important xarray terms (:issue:`2410`, :pull:`3352`). - By `Gregory Gundersen `_. + By `Gregory Gundersen `_. - Created a "How do I..." section (:ref:`howdoi`) for solutions to common questions. (:pull:`3357`). - By `Deepak Cherian `_. + By `Deepak Cherian `_. - Add examples for :py:meth:`Dataset.swap_dims` and :py:meth:`DataArray.swap_dims` (pull:`3331`, pull:`3331`). By `Justus Magin `_. - Add examples for :py:meth:`align`, :py:meth:`merge`, :py:meth:`combine_by_coords`, :py:meth:`full_like`, :py:meth:`zeros_like`, :py:meth:`ones_like`, :py:meth:`Dataset.pipe`, - :py:meth:`Dataset.assign`, :py:meth:`Dataset.reindex`, :py:meth:`Dataset.fillna` (pull:`3328`). + :py:meth:`Dataset.assign`, :py:meth:`Dataset.reindex`, :py:meth:`Dataset.fillna` (:pull:`3328`). By `Anderson Banihirwe `_. - Fixed documentation to clean up an unwanted file created in ``ipython`` example - (:pull:`3353`). By `Gregory Gundersen `_. + (:pull:`3353`). By `Gregory Gundersen `_. .. _whats-new.0.13.0: @@ -297,7 +382,7 @@ Breaking changes - :py:meth:`DataArray.to_dataset` requires ``name`` to be passed as a kwarg (previously ambiguous positional arguments were deprecated) - Reindexing with variables of a different dimension now raise an error (previously deprecated) -- :py:func:`~xarray.broadcast_array` is removed (previously deprecated in favor of +- ``xarray.broadcast_array`` is removed (previously deprecated in favor of :py:func:`~xarray.broadcast`) - :py:meth:`Variable.expand_dims` is removed (previously deprecated in favor of :py:meth:`Variable.set_dims`) @@ -307,7 +392,7 @@ New functions/methods - xarray can now wrap around any `NEP18 `_ compliant - numpy-like library (important: read notes about NUMPY_EXPERIMENTAL_ARRAY_FUNCTION in + numpy-like library (important: read notes about ``NUMPY_EXPERIMENTAL_ARRAY_FUNCTION`` in the above link). Added explicit test coverage for `sparse `_. (:issue:`3117`, :issue:`3202`). This requires `sparse>=0.8.0`. By `Nezar Abdennur `_ @@ -333,7 +418,7 @@ New functions/methods - Added :py:meth:`DataArray.broadcast_like` and :py:meth:`Dataset.broadcast_like`. By `Deepak Cherian `_ and `David Mertz - `_. + `_. - Dataset plotting API for visualizing dependencies between two DataArrays! Currently only :py:meth:`Dataset.plot.scatter` is implemented. @@ -379,21 +464,21 @@ Enhancements By `Gerardo Rivera `_. - :py:func:`~xarray.Dataset.to_netcdf()` now supports the ``invalid_netcdf`` kwarg when used - with ``engine="h5netcdf"``. It is passed to :py:func:`h5netcdf.File`. + with ``engine="h5netcdf"``. It is passed to ``h5netcdf.File``. By `Ulrich Herter `_. -- :py:meth:`~xarray.Dataset.drop` now supports keyword arguments; dropping index +- ``xarray.Dataset.drop`` now supports keyword arguments; dropping index labels by using both ``dim`` and ``labels`` or using a :py:class:`~xarray.core.coordinates.DataArrayCoordinates` object are deprecated (:issue:`2910`). - By `Gregory Gundersen `_. + By `Gregory Gundersen `_. - Added examples of :py:meth:`Dataset.set_index` and :py:meth:`DataArray.set_index`, as well are more specific error messages when the user passes invalid arguments (:issue:`3176`). By `Gregory Gundersen `_. -- :py:func:`filter_by_attrs` now filters the coordinates as well as the variables. +- :py:meth:`Dataset.filter_by_attrs` now filters the coordinates as well as the variables. By `Spencer Jones `_. Bug fixes @@ -420,7 +505,7 @@ Bug fixes By `Hasan Ahmad `_. - Fixed bug in ``combine_by_coords()`` causing a `ValueError` if the input had an unused dimension with coordinates which were not monotonic (:issue:`3150`). - By `Tom Nicholas `_. + By `Tom Nicholas `_. - Fixed crash when applying ``distributed.Client.compute()`` to a DataArray (:issue:`3171`). By `Guido Imperiale `_. - Better error message when using groupby on an empty DataArray (:issue:`3037`). @@ -444,7 +529,7 @@ Documentation - Fixed documentation to clean up unwanted files created in ``ipython`` examples (:issue:`3227`). - By `Gregory Gundersen `_. + By `Gregory Gundersen `_. .. _whats-new.0.12.3: @@ -514,7 +599,7 @@ New functions/methods To avoid FutureWarnings switch to using ``combine_nested`` or ``combine_by_coords``, (or set the ``combine`` argument in ``open_mfdataset``). (:issue:`2159`) - By `Tom Nicholas `_. + By `Tom Nicholas `_. - :py:meth:`~xarray.DataArray.rolling_exp` and :py:meth:`~xarray.Dataset.rolling_exp` added, similar to pandas' @@ -560,12 +645,12 @@ Enhancements to existing functionality :py:meth:`DataArray.groupby_bins`, and :py:meth:`DataArray.resample` now accept a keyword argument ``restore_coord_dims`` which keeps the order of the dimensions of multi-dimensional coordinates intact (:issue:`1856`). - By `Peter Hausamann `_. + By `Peter Hausamann `_. - Clean up Python 2 compatibility in code (:issue:`2950`) By `Guido Imperiale `_. - Better warning message when supplying invalid objects to ``xr.merge`` (:issue:`2948`). By `Mathias Hauser `_. -- Add ``errors`` keyword argument to :py:meth:`Dataset.drop` and :py:meth:`Dataset.drop_dims` +- Add ``errors`` keyword argument to ``Dataset.drop`` and :py:meth:`Dataset.drop_dims` that allows ignoring errors if a passed label or dimension is not in the dataset (:issue:`2994`). By `Andrew Ross `_. @@ -761,7 +846,7 @@ Bug fixes `Spencer Clark `_. - Line plots with the ``x`` argument set to a non-dimensional coord now plot the correct data for 1D DataArrays. - (:issue:`2725`). By `Tom Nicholas `_. + (:issue:`2725`). By `Tom Nicholas `_. - Subtracting a scalar ``cftime.datetime`` object from a :py:class:`CFTimeIndex` now results in a :py:class:`pandas.TimedeltaIndex` instead of raising a ``TypeError`` (:issue:`2671`). By `Spencer Clark @@ -777,14 +862,14 @@ Bug fixes By `Yohai Bar-Sinai `_. - Fixed error when trying to reduce a DataArray using a function which does not require an axis argument. (:issue:`2768`) - By `Tom Nicholas `_. + By `Tom Nicholas `_. - Concatenating a sequence of :py:class:`~xarray.DataArray` with varying names sets the name of the output array to ``None``, instead of the name of the first input array. If the names are the same it sets the name to that, instead to the name of the first DataArray in the list as it did before. - (:issue:`2775`). By `Tom Nicholas `_. + (:issue:`2775`). By `Tom Nicholas `_. -- Per `CF conventions +- Per the `CF conventions section on calendars `_, specifying ``'standard'`` as the calendar type in :py:meth:`~xarray.cftime_range` now correctly refers to the ``'gregorian'`` @@ -802,7 +887,7 @@ Bug fixes (e.g. '2000-01-01T00:00:00-05:00') no longer raises an error (:issue:`2649`). By `Spencer Clark `_. - Fixed performance regression with ``open_mfdataset`` (:issue:`2662`). - By `Tom Nicholas `_. + By `Tom Nicholas `_. - Fixed supplying an explicit dimension in the ``concat_dim`` argument to to ``open_mfdataset`` (:issue:`2647`). By `Ben Root `_. @@ -867,13 +952,13 @@ Enhancements but were not explicitly closed. This is mostly useful for debugging; we recommend enabling it in your test suites if you use xarray for IO. By `Stephan Hoyer `_ -- Support Dask ``HighLevelGraphs`` by `Matthew Rocklin `_. +- Support Dask ``HighLevelGraphs`` by `Matthew Rocklin `_. - :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the ``loffset`` kwarg just like Pandas. By `Deepak Cherian `_ - Datasets are now guaranteed to have a ``'source'`` encoding, so the source file name is always stored (:issue:`2550`). - By `Tom Nicholas `_. + By `Tom Nicholas `_. - The ``apply`` methods for ``DatasetGroupBy``, ``DataArrayGroupBy``, ``DatasetResample`` and ``DataArrayResample`` now support passing positional arguments to the applied function as a tuple to the ``args`` argument. @@ -995,7 +1080,7 @@ Enhancements dataset and dataarray attrs upon operations. The option is set with ``xarray.set_options(keep_attrs=True)``, and the default is to use the old behaviour. - By `Tom Nicholas `_. + By `Tom Nicholas `_. - Added a new backend for the GRIB file format based on ECMWF *cfgrib* python driver and *ecCodes* C-library. (:issue:`2475`) By `Alessandro Amici `_, @@ -1051,7 +1136,7 @@ Bug fixes CFTimeIndex is now allowed (:issue:`2484`). By `Spencer Clark `_. - Avoid use of Dask's deprecated ``get=`` parameter in tests - by `Matthew Rocklin `_. + by `Matthew Rocklin `_. - An ``OverflowError`` is now accurately raised and caught during the encoding process if a reference date is used that is so distant that the dates must be encoded using cftime rather than NumPy (:issue:`2272`). @@ -1097,7 +1182,7 @@ Enhancements (:issue:`2230`) By `Keisuke Fujii `_. -- :py:meth:`plot()` now accepts the kwargs +- :py:func:`~plot.plot()` now accepts the kwargs ``xscale, yscale, xlim, ylim, xticks, yticks`` just like Pandas. Also ``xincrease=False, yincrease=False`` now use matplotlib's axis inverting methods instead of setting limits. By `Deepak Cherian `_. (:issue:`2224`) @@ -1164,7 +1249,7 @@ Bug fixes - Follow up the renamings in dask; from dask.ghost to dask.overlap By `Keisuke Fujii `_. -- Now :py:func:`xr.apply_ufunc` raises a ValueError when the size of +- Now :py:func:`~xarray.apply_ufunc` raises a ValueError when the size of ``input_core_dims`` is inconsistent with the number of arguments. (:issue:`2341`) By `Keisuke Fujii `_. @@ -1247,7 +1332,7 @@ Enhancements - :py:meth:`~xarray.DataArray.interp` and :py:meth:`~xarray.Dataset.interp` methods are newly added. - See :ref:`interpolating values with interp` for the detail. + See :ref:`interp` for the detail. (:issue:`2079`) By `Keisuke Fujii `_. @@ -1364,7 +1449,7 @@ non-standard calendars used in climate modeling. Documentation ~~~~~~~~~~~~~ -- New FAQ entry, :ref:`faq.other_projects`. +- New FAQ entry, :ref:`related-projects`. By `Deepak Cherian `_. - :ref:`assigning_values` now includes examples on how to select and assign values to a :py:class:`~xarray.DataArray` with ``.loc``. @@ -1420,7 +1505,7 @@ Bug fixes - ``ValueError`` is raised when coordinates with the wrong size are assigned to a :py:class:`DataArray`. (:issue:`2112`) By `Keisuke Fujii `_. -- Fixed a bug in :py:meth:`~xarary.DatasArray.rolling` with bottleneck. Also, +- Fixed a bug in :py:meth:`~xarray.DataArray.rolling` with bottleneck. Also, fixed a bug in rolling an integer dask array. (:issue:`2113`) By `Keisuke Fujii `_. - Fixed a bug where `keep_attrs=True` flag was neglected if @@ -1457,7 +1542,7 @@ Enhancements supplied list, returning a bool array. See :ref:`selecting values with isin` for full details. Similar to the ``np.isin`` function. By `Maximilian Roos `_. -- Some speed improvement to construct :py:class:`~xarray.DataArrayRolling` +- Some speed improvement to construct :py:class:`~xarray.core.rolling.DataArrayRolling` object (:issue:`1993`) By `Keisuke Fujii `_. - Handle variables with different values for ``missing_value`` and @@ -1537,8 +1622,8 @@ Enhancements NumPy. By `Stephan Hoyer `_. - Improve :py:func:`~xarray.DataArray.rolling` logic. - :py:func:`~xarray.DataArrayRolling` object now supports - :py:func:`~xarray.DataArrayRolling.construct` method that returns a view + :py:func:`~xarray.core.rolling.DataArrayRolling` object now supports + :py:func:`~xarray.core.rolling.DataArrayRolling.construct` method that returns a view of the DataArray / Dataset object with the rolling-window dimension added to the last axis. This enables more flexible operation, such as strided rolling, windowed rolling, ND-rolling, short-time FFT and convolution. @@ -1609,7 +1694,7 @@ Enhancements 1D coordinate (e.g. time) and a 2D coordinate (e.g. depth as a function of time) (:issue:`1737`). By `Deepak Cherian `_. -- :py:func:`~plot()` rotates x-axis ticks if x-axis is time. +- :py:func:`~plot.plot()` rotates x-axis ticks if x-axis is time. By `Deepak Cherian `_. - :py:func:`~plot.line()` can draw multiple lines if provided with a 2D variable. @@ -1884,7 +1969,7 @@ Enhancements concatenated array/dataset (:issue:`1521`). By `Guido Imperiale `_. -- Speed-up (x 100) of :py:func:`~xarray.conventions.decode_cf_datetime`. +- Speed-up (x 100) of ``xarray.conventions.decode_cf_datetime``. By `Christian Chwala `_. **IO related improvements** @@ -2530,7 +2615,7 @@ Enhancements raising an error (:issue:`1082`). By `Stephan Hoyer `_. - Options for axes sharing between subplots are exposed to - :py:class:`FacetGrid` and :py:func:`~xarray.plot.plot`, so axes + :py:class:`~xarray.plot.FacetGrid` and :py:func:`~xarray.plot.plot`, so axes sharing can be disabled for polar plots. By `Bas Hoonhout `_. - New utility functions :py:func:`~xarray.testing.assert_equal`, @@ -2546,8 +2631,8 @@ Enhancements similar to what the command line utility ``ncdump -h`` produces (:issue:`1150`). By `Joe Hamman `_. - Added the ability write unlimited netCDF dimensions with the ``scipy`` and - ``netcdf4`` backends via the new :py:attr:`~xray.Dataset.encoding` attribute - or via the ``unlimited_dims`` argument to :py:meth:`~xray.Dataset.to_netcdf`. + ``netcdf4`` backends via the new ``xray.Dataset.encoding`` attribute + or via the ``unlimited_dims`` argument to ``xray.Dataset.to_netcdf``. By `Joe Hamman `_. - New :py:meth:`~DataArray.quantile` method to calculate quantiles from DataArray objects (:issue:`1187`). @@ -2626,10 +2711,9 @@ Bug fixes Performance improvements ~~~~~~~~~~~~~~~~~~~~~~~~ -- :py:meth:`~xarray.Dataset.isel_points` and - :py:meth:`~xarray.Dataset.sel_points` now use vectorised indexing in numpy - and dask (:issue:`1161`), which can result in several orders of magnitude - speedup. +- ``xarray.Dataset.isel_points`` and ``xarray.Dataset.sel_points`` now + use vectorised indexing in numpy and dask (:issue:`1161`), which can + result in several orders of magnitude speedup. By `Jonathan Chambers `_. .. _whats-new.0.8.2: @@ -2727,7 +2811,7 @@ Enhancements - Groupby operations now support grouping over multidimensional variables. A new method called :py:meth:`~xarray.Dataset.groupby_bins` has also been added to allow users to specify bins for grouping. The new features are described in - :ref:`groupby.multidim` and :ref:`examples.multidim`. + :ref:`groupby.multidim` and :ref:`/examples/multidimensional-coords.ipynb`. By `Ryan Abernathey `_. - DataArray and Dataset method :py:meth:`where` now supports a ``drop=True`` @@ -2738,16 +2822,17 @@ Enhancements any number of ``Dataset`` and/or ``DataArray`` variables. See :ref:`merge` for more details. By `Stephan Hoyer `_. -- DataArray and Dataset method :py:meth:`resample` now supports the +- :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now support the ``keep_attrs=False`` option that determines whether variable and dataset attributes are retained in the resampled object. By `Jeremy McGibbon `_. -- Better multi-index support in DataArray and Dataset :py:meth:`sel` and - :py:meth:`loc` methods, which now behave more closely to pandas and which - also accept dictionaries for indexing based on given level names and labels - (see :ref:`multi-level indexing`). By - `Benoit Bovy `_. +- Better multi-index support in :py:meth:`DataArray.sel`, + :py:meth:`DataArray.loc`, :py:meth:`Dataset.sel` and + :py:meth:`Dataset.loc`, which now behave more closely to pandas and + which also accept dictionaries for indexing based on given level names + and labels (see :ref:`multi-level indexing`). + By `Benoit Bovy `_. - New (experimental) decorators :py:func:`~xarray.register_dataset_accessor` and :py:func:`~xarray.register_dataarray_accessor` for registering custom xarray @@ -2763,7 +2848,7 @@ Enhancements allowing more control on the colorbar (:issue:`872`). By `Fabien Maussion `_. -- New Dataset method :py:meth:`filter_by_attrs`, akin to +- New Dataset method :py:meth:`Dataset.filter_by_attrs`, akin to ``netCDF4.Dataset.get_variables_by_attributes``, to easily filter data variables using its attributes. `Filipe Fernandes `_. @@ -2890,7 +2975,7 @@ Enhancements - Numerical operations now return empty objects on no overlapping labels rather than raising ``ValueError`` (:issue:`739`). -- :py:class:`~pd.Series` is now supported as valid input to the ``Dataset`` +- :py:class:`~pandas.Series` is now supported as valid input to the ``Dataset`` constructor (:issue:`740`). Bug fixes @@ -2909,7 +2994,7 @@ Bug fixes reindexing leads to NaN values (:issue:`738`). - ``Dataset.rename`` and ``DataArray.rename`` support the old and new names being the same (:issue:`724`). -- Fix :py:meth:`~xarray.Dataset.from_dataset` for DataFrames with Categorical +- Fix :py:meth:`~xarray.Dataset.from_dataframe` for DataFrames with Categorical column and a MultiIndex index (:issue:`737`). - Fixes to ensure xarray works properly after the upcoming pandas v0.18 and NumPy v1.11 releases. @@ -2960,7 +3045,7 @@ recommend switching your import statements to ``import xarray as xr``. Breaking changes ~~~~~~~~~~~~~~~~ -- The internal data model used by :py:class:`~xray.DataArray` has been +- The internal data model used by ``xray.DataArray`` has been rewritten to fix several outstanding issues (:issue:`367`, :issue:`634`, `this stackoverflow report`_). Internally, ``DataArray`` is now implemented in terms of ``._variable`` and ``._coords`` attributes instead of holding @@ -2998,7 +3083,7 @@ Breaking changes * x (x) int64 0 1 2 - It is no longer possible to convert a DataArray to a Dataset with - :py:meth:`xray.DataArray.to_dataset` if it is unnamed. This will now + ``xray.DataArray.to_dataset`` if it is unnamed. This will now raise ``ValueError``. If the array is unnamed, you need to supply the ``name`` argument. @@ -3067,7 +3152,7 @@ Enhancements - Plotting: more control on colormap parameters (:issue:`642`). ``vmin`` and ``vmax`` will not be silently ignored anymore. Setting ``center=False`` prevents automatic selection of a divergent colormap. -- New :py:meth:`~xray.Dataset.shift` and :py:meth:`~xray.Dataset.roll` methods +- New ``xray.Dataset.shift`` and ``xray.Dataset.roll`` methods for shifting/rotating datasets or arrays along a dimension: .. ipython:: python @@ -3081,9 +3166,9 @@ Enhancements moves both data and coordinates. - Assigning a ``pandas`` object directly as a ``Dataset`` variable is now permitted. Its index names correspond to the ``dims`` of the ``Dataset``, and its data is aligned. -- Passing a :py:class:`pandas.DataFrame` or :py:class:`pandas.Panel` to a Dataset constructor +- Passing a :py:class:`pandas.DataFrame` or ``pandas.Panel`` to a Dataset constructor is now permitted. -- New function :py:func:`~xray.broadcast` for explicitly broadcasting +- New function ``xray.broadcast`` for explicitly broadcasting ``DataArray`` and ``Dataset`` objects against each other. For example: .. ipython:: python @@ -3141,7 +3226,7 @@ API Changes ~~~~~~~~~~~ - The handling of colormaps and discrete color lists for 2D plots in - :py:meth:`~xray.DataArray.plot` was changed to provide more compatibility + ``xray.DataArray.plot`` was changed to provide more compatibility with matplotlib's ``contour`` and ``contourf`` functions (:issue:`538`). Now discrete lists of colors should be specified using ``colors`` keyword, rather than ``cmap``. @@ -3149,10 +3234,10 @@ API Changes Enhancements ~~~~~~~~~~~~ -- Faceted plotting through :py:class:`~xray.plot.FacetGrid` and the - :py:meth:`~xray.plot.plot` method. See :ref:`plotting.faceting` for more details +- Faceted plotting through ``xray.plot.FacetGrid`` and the + ``xray.plot.plot`` method. See :ref:`plotting.faceting` for more details and examples. -- :py:meth:`~xray.Dataset.sel` and :py:meth:`~xray.Dataset.reindex` now support +- ``xray.Dataset.sel`` and ``xray.Dataset.reindex`` now support the ``tolerance`` argument for controlling nearest-neighbor selection (:issue:`629`): @@ -3169,12 +3254,12 @@ Enhancements * x (x) float64 0.9 1.5 This feature requires pandas v0.17 or newer. -- New ``encoding`` argument in :py:meth:`~xray.Dataset.to_netcdf` for writing +- New ``encoding`` argument in ``xray.Dataset.to_netcdf`` for writing netCDF files with compression, as described in the new documentation section on :ref:`io.netcdf.writing_encoded`. -- Add :py:attr:`~xray.Dataset.real` and :py:attr:`~xray.Dataset.imag` +- Add ``xray.Dataset.real`` and ``xray.Dataset.imag`` attributes to Dataset and DataArray (:issue:`553`). -- More informative error message with :py:meth:`~xray.Dataset.from_dataframe` +- More informative error message with ``xray.Dataset.from_dataframe`` if the frame has duplicate columns. - xray now uses deterministic names for dask arrays it creates or opens from disk. This allows xray users to take advantage of dask's nascent support for @@ -3189,9 +3274,9 @@ Bug fixes - Aggregation functions now correctly skip ``NaN`` for data for ``complex128`` dtype (:issue:`554`). - Fixed indexing 0d arrays with unicode dtype (:issue:`568`). -- :py:meth:`~xray.DataArray.name` and Dataset keys must be a string or None to +- ``xray.DataArray.name`` and Dataset keys must be a string or None to be written to netCDF (:issue:`533`). -- :py:meth:`~xray.DataArray.where` now uses dask instead of numpy if either the +- ``xray.DataArray.where`` now uses dask instead of numpy if either the array or ``other`` is a dask array. Previously, if ``other`` was a numpy array the method was evaluated eagerly. - Global attributes are now handled more consistently when loading remote @@ -3218,24 +3303,24 @@ v0.6.0 (21 August 2015) This release includes numerous bug fixes and enhancements. Highlights include the introduction of a plotting module and the new Dataset and DataArray -methods :py:meth:`~xray.Dataset.isel_points`, :py:meth:`~xray.Dataset.sel_points`, -:py:meth:`~xray.Dataset.where` and :py:meth:`~xray.Dataset.diff`. There are no +methods ``xray.Dataset.isel_points``, ``xray.Dataset.sel_points``, +``xray.Dataset.where`` and ``xray.Dataset.diff``. There are no breaking changes from v0.5.2. Enhancements ~~~~~~~~~~~~ - Plotting methods have been implemented on DataArray objects - :py:meth:`~xray.DataArray.plot` through integration with matplotlib + ``xray.DataArray.plot`` through integration with matplotlib (:issue:`185`). For an introduction, see :ref:`plotting`. - Variables in netCDF files with multiple missing values are now decoded as NaN after issuing a warning if open_dataset is called with mask_and_scale=True. - We clarified our rules for when the result from an xray operation is a copy - vs. a view (see :ref:`copies vs views` for more details). + vs. a view (see :ref:`copies_vs_views` for more details). - Dataset variables are now written to netCDF files in order of appearance when using the netcdf4 backend (:issue:`479`). -- Added :py:meth:`~xray.Dataset.isel_points` and :py:meth:`~xray.Dataset.sel_points` +- Added ``xray.Dataset.isel_points`` and ``xray.Dataset.sel_points`` to support pointwise indexing of Datasets and DataArrays (:issue:`475`). .. ipython:: @@ -3280,7 +3365,7 @@ Enhancements x (points) |S1 'a' 'b' 'g' * points (points) int64 0 1 2 -- New :py:meth:`~xray.Dataset.where` method for masking xray objects according +- New ``xray.Dataset.where`` method for masking xray objects according to some criteria. This works particularly well with multi-dimensional data: .. ipython:: python @@ -3291,11 +3376,10 @@ Enhancements @savefig where_example.png width=4in height=4in ds.distance.where(ds.distance < 100).plot() -- Added new methods :py:meth:`DataArray.diff ` - and :py:meth:`Dataset.diff ` for finite - difference calculations along a given axis. +- Added new methods ``xray.DataArray.diff`` and ``xray.Dataset.diff`` + for finite difference calculations along a given axis. -- New :py:meth:`~xray.DataArray.to_masked_array` convenience method for +- New ``xray.DataArray.to_masked_array`` convenience method for returning a numpy.ma.MaskedArray. .. ipython:: python @@ -3304,7 +3388,7 @@ Enhancements da.where(da < 0.5) da.where(da < 0.5).to_masked_array(copy=True) -- Added new flag "drop_variables" to :py:meth:`~xray.open_dataset` for +- Added new flag "drop_variables" to ``xray.open_dataset`` for excluding variables from being parsed. This may be useful to drop variables with problems or inconsistent values. @@ -3333,7 +3417,7 @@ options for ``xray.concat``. Backwards incompatible changes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- The optional arguments ``concat_over`` and ``mode`` in :py:func:`~xray.concat` have +- The optional arguments ``concat_over`` and ``mode`` in ``xray.concat`` have been removed and replaced by ``data_vars`` and ``coords``. The new arguments are both more easily understood and more robustly implemented, and allowed us to fix a bug where ``concat`` accidentally loaded data into memory. If you set values for @@ -3343,16 +3427,16 @@ Backwards incompatible changes Enhancements ~~~~~~~~~~~~ -- :py:func:`~xray.open_mfdataset` now supports a ``preprocess`` argument for +- ``xray.open_mfdataset`` now supports a ``preprocess`` argument for preprocessing datasets prior to concatenaton. This is useful if datasets cannot be otherwise merged automatically, e.g., if the original datasets have conflicting index coordinates (:issue:`443`). -- :py:func:`~xray.open_dataset` and :py:func:`~xray.open_mfdataset` now use a +- ``xray.open_dataset`` and ``xray.open_mfdataset`` now use a global thread lock by default for reading from netCDF files with dask. This avoids possible segmentation faults for reading from netCDF4 files when HDF5 is not configured properly for concurrent access (:issue:`444`). - Added support for serializing arrays of complex numbers with `engine='h5netcdf'`. -- The new :py:func:`~xray.save_mfdataset` function allows for saving multiple +- The new ``xray.save_mfdataset`` function allows for saving multiple datasets to disk simultaneously. This is useful when processing large datasets with dask.array. For example, to save a dataset too big to fit into memory to one file per year, we could write: @@ -3371,7 +3455,7 @@ Bug fixes - Fixed ``min``, ``max``, ``argmin`` and ``argmax`` for arrays with string or unicode types (:issue:`453`). -- :py:func:`~xray.open_dataset` and :py:func:`~xray.open_mfdataset` support +- ``xray.open_dataset`` and ``xray.open_mfdataset`` support supplying chunks as a single integer. - Fixed a bug in serializing scalar datetime variable to netCDF. - Fixed a bug that could occur in serialization of 0-dimensional integer arrays. @@ -3388,9 +3472,9 @@ adds the ``pipe`` method, copied from pandas. Enhancements ~~~~~~~~~~~~ -- Added :py:meth:`~xray.Dataset.pipe`, replicating the `new pandas method`_ in version +- Added ``xray.Dataset.pipe``, replicating the `new pandas method`_ in version 0.16.2. See :ref:`transforming datasets` for more details. -- :py:meth:`~xray.Dataset.assign` and :py:meth:`~xray.Dataset.assign_coords` +- ``xray.Dataset.assign`` and ``xray.Dataset.assign_coords`` now assign new variables in sorted (alphabetical) order, mirroring the behavior in pandas. Previously, the order was arbitrary. @@ -3412,7 +3496,7 @@ Highlights The headline feature in this release is experimental support for out-of-core computing (data that doesn't fit into memory) with dask_. This includes a new -top-level function :py:func:`~xray.open_mfdataset` that makes it easy to open +top-level function ``xray.open_mfdataset`` that makes it easy to open a collection of netCDF (using dask) as a single ``xray.Dataset`` object. For more on dask, read the `blog post introducing xray + dask`_ and the new documentation section :doc:`dask`. @@ -3427,7 +3511,7 @@ Backwards incompatible changes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - The logic used for choosing which variables are concatenated with - :py:func:`~xray.concat` has changed. Previously, by default any variables + ``xray.concat`` has changed. Previously, by default any variables which were equal across a dimension were not concatenated. This lead to some surprising behavior, where the behavior of groupby and concat operations could depend on runtime values (:issue:`268`). For example: @@ -3462,8 +3546,8 @@ Backwards incompatible changes Enhancements ~~~~~~~~~~~~ -- New :py:meth:`~xray.Dataset.to_array` and enhanced - :py:meth:`~xray.DataArray.to_dataset` methods make it easy to switch back +- New ``xray.Dataset.to_array`` and enhanced + ``xray.DataArray.to_dataset`` methods make it easy to switch back and forth between arrays and datasets: .. ipython:: python @@ -3473,7 +3557,7 @@ Enhancements ds.to_array() ds.to_array().to_dataset(dim='variable') -- New :py:meth:`~xray.Dataset.fillna` method to fill missing values, modeled +- New ``xray.Dataset.fillna`` method to fill missing values, modeled off the pandas method of the same name: .. ipython:: python @@ -3485,7 +3569,7 @@ Enhancements index based alignment and broadcasting like standard binary operations. It also can be applied by group, as illustrated in :ref:`fill with climatology`. -- New :py:meth:`~xray.Dataset.assign` and :py:meth:`~xray.Dataset.assign_coords` +- New ``xray.Dataset.assign`` and ``xray.Dataset.assign_coords`` methods patterned off the new :py:meth:`DataFrame.assign ` method in pandas: @@ -3497,8 +3581,8 @@ Enhancements These methods return a new Dataset (or DataArray) with updated data or coordinate variables. -- :py:meth:`~xray.Dataset.sel` now supports the ``method`` parameter, which works - like the paramter of the same name on :py:meth:`~xray.Dataset.reindex`. It +- ``xray.Dataset.sel`` now supports the ``method`` parameter, which works + like the paramter of the same name on ``xray.Dataset.reindex``. It provides a simple interface for doing nearest-neighbor interpolation: .. use verbatim because I can't seem to install pandas 0.16.1 on RTD :( @@ -3535,7 +3619,7 @@ Enhancements - Accessing data from remote datasets now has retrying logic (with exponential backoff) that should make it robust to occasional bad responses from DAP servers. -- You can control the width of the Dataset repr with :py:class:`xray.set_options`. +- You can control the width of the Dataset repr with ``xray.set_options``. It can be used either as a context manager, in which case the default is restored outside the context: @@ -3561,7 +3645,7 @@ Deprecations ~~~~~~~~~~~~ - The method ``load_data()`` has been renamed to the more succinct - :py:meth:`~xray.Dataset.load`. + ``xray.Dataset.load``. v0.4.1 (18 March 2015) ---------------------- @@ -3574,7 +3658,7 @@ Enhancements - New documentation sections on :ref:`time-series` and :ref:`combining multiple files`. -- :py:meth:`~xray.Dataset.resample` lets you resample a dataset or data array to +- ``xray.Dataset.resample`` lets you resample a dataset or data array to a new temporal resolution. The syntax is the `same as pandas`_, except you need to supply the time dimension explicitly: @@ -3617,7 +3701,7 @@ Enhancements array.resample('1D', dim='time', how='first') -- :py:meth:`~xray.Dataset.swap_dims` allows for easily swapping one dimension +- ``xray.Dataset.swap_dims`` allows for easily swapping one dimension out for another: .. ipython:: python @@ -3627,7 +3711,7 @@ Enhancements ds.swap_dims({'x': 'y'}) This was possible in earlier versions of xray, but required some contortions. -- :py:func:`~xray.open_dataset` and :py:meth:`~xray.Dataset.to_netcdf` now +- ``xray.open_dataset`` and ``xray.Dataset.to_netcdf`` now accept an ``engine`` argument to explicitly select which underlying library (netcdf4 or scipy) is used for reading/writing a netCDF file. @@ -3662,7 +3746,7 @@ Breaking changes - We now automatically align index labels in arithmetic, dataset construction, merging and updating. This means the need for manually invoking methods like - :py:func:`~xray.align` and :py:meth:`~xray.Dataset.reindex_like` should be + ``xray.align`` and ``xray.Dataset.reindex_like`` should be vastly reduced. :ref:`For arithmetic`, we align @@ -3714,7 +3798,7 @@ Breaking changes (a + b).coords This functionality can be controlled through the ``compat`` option, which - has also been added to the :py:class:`~xray.Dataset` constructor. + has also been added to the ``xray.Dataset`` constructor. - Datetime shortcuts such as ``'time.month'`` now return a ``DataArray`` with the name ``'month'``, not ``'time.month'`` (:issue:`345`). This makes it easier to index the resulting arrays when they are used with ``groupby``: @@ -3752,7 +3836,7 @@ Breaking changes Enhancements ~~~~~~~~~~~~ -- Support for :py:meth:`~xray.Dataset.reindex` with a fill method. This +- Support for ``xray.Dataset.reindex`` with a fill method. This provides a useful shortcut for upsampling: .. ipython:: python @@ -3766,16 +3850,15 @@ Enhancements - Use functions that return generic ndarrays with DataArray.groupby.apply and Dataset.apply (:issue:`327` and :issue:`329`). Thanks Jeff Gerard! - Consolidated the functionality of ``dumps`` (writing a dataset to a netCDF3 - bytestring) into :py:meth:`~xray.Dataset.to_netcdf` (:issue:`333`). -- :py:meth:`~xray.Dataset.to_netcdf` now supports writing to groups in netCDF4 + bytestring) into ``xray.Dataset.to_netcdf`` (:issue:`333`). +- ``xray.Dataset.to_netcdf`` now supports writing to groups in netCDF4 files (:issue:`333`). It also finally has a full docstring -- you should read it! -- :py:func:`~xray.open_dataset` and :py:meth:`~xray.Dataset.to_netcdf` now +- ``xray.open_dataset`` and ``xray.Dataset.to_netcdf`` now work on netCDF3 files when netcdf4-python is not installed as long as scipy is available (:issue:`333`). -- The new :py:meth:`Dataset.drop ` and - :py:meth:`DataArray.drop ` methods makes it easy to drop - explicitly listed variables or index labels: +- The new ``xray.Dataset.drop`` and ``xray.DataArray.drop`` methods + makes it easy to drop explicitly listed variables or index labels: .. ipython:: python :okwarning: @@ -3788,12 +3871,12 @@ Enhancements arr = xray.DataArray([1, 2, 3], coords=[('x', list('abc'))]) arr.drop(['a', 'c'], dim='x') -- :py:meth:`~xray.Dataset.broadcast_equals` has been added to correspond to +- ``xray.Dataset.broadcast_equals`` has been added to correspond to the new ``compat`` option. - Long attributes are now truncated at 500 characters when printing a dataset (:issue:`338`). This should make things more convenient for working with datasets interactively. -- Added a new documentation example, :ref:`monthly means example`. Thanks Joe +- Added a new documentation example, :ref:`/examples/monthly-means.ipynb`. Thanks Joe Hamman! Bug fixes @@ -3814,8 +3897,8 @@ Deprecations ~~~~~~~~~~~~ - ``dump`` and ``dumps`` have been deprecated in favor of - :py:meth:`~xray.Dataset.to_netcdf`. -- ``drop_vars`` has been deprecated in favor of :py:meth:`~xray.Dataset.drop`. + ``xray.Dataset.to_netcdf``. +- ``drop_vars`` has been deprecated in favor of ``xray.Dataset.drop``. Future plans ~~~~~~~~~~~~ @@ -3945,10 +4028,10 @@ backwards incompatible changes. New features ~~~~~~~~~~~~ -- Added :py:meth:`~xray.Dataset.count` and :py:meth:`~xray.Dataset.dropna` +- Added ``xray.Dataset.count`` and ``xray.Dataset.dropna`` methods, copied from pandas, for working with missing values (:issue:`247`, :issue:`58`). -- Added :py:meth:`DataArray.to_pandas ` for +- Added ``xray.DataArray.to_pandas`` for converting a data array into the pandas object with the same dimensionality (1D to Series, 2D to DataFrame, etc.) (:issue:`255`). - Support for reading gzipped netCDF3 files (:issue:`239`). @@ -3981,7 +4064,7 @@ New features of arrays of metadata that describe the grid on which the points in "variable" arrays lie. They are preserved (when unambiguous) even though mathematical operations. -- **Dataset math** :py:class:`~xray.Dataset` objects now support all arithmetic +- **Dataset math** ``xray.Dataset`` objects now support all arithmetic operations directly. Dataset-array operations map across all dataset variables; dataset-dataset operations act on each pair of variables with the same name. @@ -3997,7 +4080,7 @@ Backwards incompatible changes - ``Dataset.__eq__`` and ``Dataset.__ne__`` are now element-wise operations instead of comparing all values to obtain a single boolean. Use the method - :py:meth:`~xray.Dataset.equals` instead. + ``xray.Dataset.equals`` instead. Deprecations ~~~~~~~~~~~~ @@ -4006,7 +4089,7 @@ Deprecations - ``Dataset.select_vars`` deprecated: index a ``Dataset`` with a list of variable names instead. - ``DataArray.select_vars`` and ``DataArray.drop_vars`` deprecated: use - :py:meth:`~xray.DataArray.reset_coords` instead. + ``xray.DataArray.reset_coords`` instead. v0.2 (14 August 2014) --------------------- @@ -4016,16 +4099,16 @@ fixes. Here are the highlights: - There is now a direct constructor for ``DataArray`` objects, which makes it possible to create a DataArray without using a Dataset. This is highlighted - in the refreshed :doc:`tutorial`. + in the refreshed ``tutorial``. - You can perform aggregation operations like ``mean`` directly on - :py:class:`~xray.Dataset` objects, thanks to Joe Hamman. These aggregation + ``xray.Dataset`` objects, thanks to Joe Hamman. These aggregation methods also worked on grouped datasets. - xray now works on Python 2.6, thanks to Anna Kuznetsova. - A number of methods and attributes were given more sensible (usually shorter) names: ``labeled`` -> ``sel``, ``indexed`` -> ``isel``, ``select`` -> ``select_vars``, ``unselect`` -> ``drop_vars``, ``dimensions`` -> ``dims``, ``coordinates`` -> ``coords``, ``attributes`` -> ``attrs``. -- New :py:meth:`~xray.Dataset.load_data` and :py:meth:`~xray.Dataset.close` +- New ``xray.Dataset.load_data`` and ``xray.Dataset.close`` methods for datasets facilitate lower level of control of data loaded from disk. diff --git a/examples/xarray_multidimensional_coords.ipynb b/examples/xarray_multidimensional_coords.ipynb deleted file mode 100644 index 508d6f388d5..00000000000 --- a/examples/xarray_multidimensional_coords.ipynb +++ /dev/null @@ -1,370 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "toc": true - }, - "source": [ - "

Table of Contents

\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Working with Multidimensional Coordinates\n", - "\n", - "Author: [Ryan Abernathey](https://github.com/rabernat)\n", - "\n", - "Many datasets have _physical coordinates_ which differ from their _logical coordinates_. Xarray provides several ways to plot and analyze such datasets." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:49:56.068395Z", - "start_time": "2018-11-28T20:49:56.035349Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numpy version : 1.17.2\n", - "pandas version : 0.25.1\n", - "xarray version : 0.13.0+45.g4296096b.dirty\n" - ] - } - ], - "source": [ - "%matplotlib inline\n", - "import numpy as np\n", - "import pandas as pd\n", - "import xarray as xr\n", - "import cartopy.crs as ccrs\n", - "from matplotlib import pyplot as plt\n", - "\n", - "print(\"numpy version : \", np.__version__)\n", - "print(\"pandas version : \", pd.__version__)\n", - "print(\"xarray version : \", xr.__version__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As an example, consider this dataset from the [xarray-data](https://github.com/pydata/xarray-data) repository." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:13.629720Z", - "start_time": "2018-11-28T20:50:13.484542Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Dimensions: (time: 36, x: 275, y: 205)\n", - "Coordinates:\n", - " * time (time) object 1980-09-16 12:00:00 ... 1983-08-17 00:00:00\n", - " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", - " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", - "Dimensions without coordinates: x, y\n", - "Data variables:\n", - " Tair (time, y, x) float64 nan nan nan nan nan ... 29.8 28.66 28.19 28.21\n", - "Attributes:\n", - " title: /workspace/jhamman/processed/R1002RBRxaaa01a/l...\n", - " institution: U.W.\n", - " source: RACM R1002RBRxaaa01a\n", - " output_frequency: daily\n", - " output_mode: averaged\n", - " convention: CF-1.4\n", - " references: Based on the initial model of Liang et al., 19...\n", - " comment: Output from the Variable Infiltration Capacity...\n", - " nco_openmp_thread_number: 1\n", - " NCO: \"4.6.0\"\n", - " history: Tue Dec 27 14:15:22 2016: ncatted -a dimension..." - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds = xr.tutorial.open_dataset('rasm').load()\n", - "ds" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this example, the _logical coordinates_ are `x` and `y`, while the _physical coordinates_ are `xc` and `yc`, which represent the latitudes and longitude of the data." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:15.836061Z", - "start_time": "2018-11-28T20:50:15.768376Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'long_name': 'longitude of grid cell center', 'units': 'degrees_east', 'bounds': 'xv'}\n", - "{'long_name': 'latitude of grid cell center', 'units': 'degrees_north', 'bounds': 'yv'}\n" - ] - } - ], - "source": [ - "print(ds.xc.attrs)\n", - "print(ds.yc.attrs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting ##\n", - "\n", - "Let's examine these coordinate variables by plotting them." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:17.928556Z", - "start_time": "2018-11-28T20:50:17.031211Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0cAAAEGCAYAAACuIe5jAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9e9h9SVXf+V3n7cZubgrhYosQwAAZYBwQvD9DEHG8jEpihMAYQ4QRiSgafXwE9Bk1DjPk8W68Pc2gQKJICxqIoyLwxFsiMDRyERhGLgqtHZD7RW26z1nzx66qvWrVqsveu/Z5z3nfs/r59bt31apVtc9lV33OWrU2MTNOcpKTnOQkJznJSU5ykpOc5LLL5rwHcJKTnOQkJznJSU5ykpOc5CSHICc4OslJTnKSk5zkJCc5yUlOchKc4OgkJznJSU5ykpOc5CQnOclJAJzg6CQnOclJTnKSk5zkJCc5yUkAnODoJCc5yUlOcpKTnOQkJznJSQAAV5z3AJbIFVffhm91uzuuY3xmEj865/572Z50HXPG2tgmGkdrZsW5r51oV7x+zp50HQfVDFTts3k4dRyTDExtM3lcXDydLoaBjM2Pbt//fma+89Iev/xLbsMf+OC2Sff6N970Mmb+iqV9nuT85Fb0KXwVbgMQxfcVCv9z5+quo+uLZe4guXEZZUUbAJt2bF2rDzZ1cm0BkHGna2zPhbou7aboSLtTFwLdFg4HJFPvzWHe69hHaU7v3dbSt9YsuX4510/jnMfjmuGjf3Pj4rnqss9TRw1Ht7rdHXG/R3+XXVn54NOEL8aUuqxdo5xKi31T/5x01DhL7WmXt5uzWbRntInLDN2dDQWhPtd3pOtOdkZZdUyubJeWmX2oMfk+zXpDLx5bxmamXXkcDbaKbXZ5PUu/Zts636k+cv3kvmu6fwCsx+3kZR949l/YRqbJBz64xWtedo8m3bNr/uxOPfo8yfnJVbgNvuCK/wmgDWhDALmAjQ0NwLTZDGAU/g5LJKJN0Ang5HX8udcnZ1fri3omGmJFKNbR5dG5rweGlRsR2NWxX8nRAEe+HdMIS0xClxCuzZ9H9ciU+fINbLtRO1kPVU+xbrimuE04Rv48q4eKXqUsOYahW9BrqsvJjDVRcS1hzr2FMguOuKLLtk6kb+pyUq77SGwzx33sMvWRLaNsx+O5tinWHWGMco3B7PrlUV+3AfC7r/3BxXPVZZ+nVgurI6K7E9F/JqK3EtGbieg7XPkdiejlRPRn7u8dRJunE9HbiehtRPTlywaA4g2C5Q1yavuK3dY24WbdrL8/nbg+Vii9biw/USv9GlZ834AwAWcl97pbxUcQeFqE7Eq7yWCkJdempOd1jwWMrLEuEAawa/zvJOvK3uYpUjcSC4yicSnQ2WwSnSwYGfUaeLxkwUjW+7mwAxiFebcFjMQ/D0Zs6PAmthnbxzg+XZ7YVMeb+By6XLaHYddor9tKfd0m/NvE/WMTt4nabjI2Wv6J9tp2rt+kr9p1yTLdRr0f8jWV73HUv/nZyLxvlc9D8l4lx+rzm4P1yFZcBsB9J3Of//E7OI7RKyD6Do7XMdaH9h3kss9Tay79bgHw3cz83wH4AgBPIaL7A3gagFcy830AvNKdw9U9FsADAHwFgJ8jorNaJ9WFcqV+dnvK1x0DINUktTFtnFWb0Rda17XZa9Ltc5/oLlmgse4zSx/UXPAaLbJVhKZCRxZo7BOMMrCTBaPOwmDczNumfzUhoquI6DVE9Aa3uP8hV/6DRPSXRPR69++rRJt+P0Idv+xlngIweo00xAQFAjYUg5GlE4DJHxvQZIGRqjfBSOhEizO5KIvsTAOjoZ0NQUkZ4sU6y7FkF7AalsbryC3Okza5hbgqD44FrafHZQGRrtP1GyQwYoJPDWh027n6Rp85aMpeU+H1sGDGep1zr2UCScZx62cj+7mwPn/qGmqf6WC7AEjmd0r9IGECUufVfM956hhltbA6Zr4RwI3u+GNE9FYAdwPwKAAPd2rPA/B7AL7Xlf8qM98E4F1E9HYAnwfgj6t9uQ9NNqTNf6gy9UyFtrX2ZJdnbRr6clJKFs2mvrI9Q8esR02HwmKz9JrxBmNIWeb1aZWoH9F/VXdNWXhNXaQGOVOBao7XKBqPbNMQTleqr5232MiVZWBnX2AUTPf7te0mAI9g5o8T0ZUA/oiIftvV/QQz/6hUVov7zwDwCiK6L/MFneEqspd5iigOp/PFmXA63TbU+3MLmqSXSYKTtpUJnRvtYKz3izK16BoXicYiTtS3glG06JOLTqef2IzswCwb2lBSH9srH0dt5VjkuWynxyvOW+uietj1WZ2Mbk5MG5U1FKn1AdQaYpyrx7qgZ8zPui6y6fVdmb+dk3wflE2vXjrWbRkEv1dHt5GXEg+NwMPuvPBZpZ3Xc3WuESt9uOukDQE7TtuE14ZAGwbv/PhinWGdNYxquAYAm75z1kX1CrXIXvYcEdE9ATwYwKsB3NVNSGDmG4noLk7tbgBeJZrd4Mq0rScBeBIAXHnbO0R1TZBTAKSgVrpBrARIYxs6P0Bq1bHqSsCgbpQ52JkCN1Vdd+OptamCdQ9Z6vlptVOrt/Yoze1/SThdax/WOZB6jY4MjBiMbafPBDMzgI+70yvdv5Lx2T9CXXRZa566CrceK3Q4XdLOCKcrwtAmBSMh1j4jy5Mk9cxwnqDnbSkwCv1JPcwHowQklEdJtk/K/E09AzsGCGWhSEILYp14fPb5JFjS9TDqMzqtQFQVbScHM0I/C0wNMGR1lUCML/OQ5CokJEVtnB7p44z9oY5cHSd6EoziMgE8QPhRWNYhatsGSKFvLgASxNqJhh4CIHWSnvPUMcrqOyqI6LYAXgzgO5n5oyVVoyx5Z5j5WmZ+KDM/9Iqrb5M2kDe2XC+VT9CsX2UydrPjKfRhhtrNvGnWdKaOrTW8Tv/aOFmkrdo3vucdIfS5gtFsZ+kNqBVeTL3W0DdLpzUJQ9bWwnC6mswBo8KeoWYw6jxJ7MBN/wDciYheK/49SdsiojMiej2A9wF4OTO/2lV9GxG9kYh+UeyZuRuA94jm5uL+ssma89St6KoRYrQIr9GscDrTJiXAY3qcDC+S9AABEOE7FTAK4DERjDJhSpyrF4Bjl1GYi3WYVs5GTs//6s+wdcJYdahXpdysk2X+uBK+BqlHxj8jlM78Z7VVNmSf1XC/ynVm6zaGPSPULXoPENtK6q33q/R+q89P+bM2fp6tz6//vln6/jvGhCTETusAsEPstFfXjb/n2mXCPHXhZFXPkQvzeDGAX2bmX3fF7yWia9yvcddgmNCBYZK+u2j+mQD+am7fVY8AwZjSGtv7z95SL1LBzrl7kIrtCUvC6xZ5j+aE1lnvScXOQcscT/dSr5GUOdnpaskXrLLaPqNWMEpUVga4ijCAbfuE8n5mfmjR3hAS9yAi+jQAv0FEDwTw8wB+2HX3wwB+DMATEE+5ckiXVvY6T1E+O53WizLT+QVPTleBU+IdclLLTCdt1pIvjLrGwq8VjNCwsIxsIG4TlVFSlmsXHVt1EDZQaC/1ppZnyub+EDpbGmyF/gteIz3H++PQ1JcZc7Tl1YnqXBvpCQr1woFi1ssx+GEqvdjDRG4sHLex7ADwXhwmV6Y8SIM+R/olDxKUDsOtBTcwPUi84SG87nznqQsnq3mOiIgAPAfAW5n5x0XVSwE83h0/HsBLRPljiehTiOheAO4D4DX1jsrV5+ZFmmIrq29NhA12W26cNR1VX3odorqVbtpW/1WP0kWQZo9ND69Mg9dobjhdre6SgFHoaoVf5Jj5wxj2xnwFM7+Xmbc8XPCzMYTOAZ1/hDp22ds8JcPpzHE0htMNyjDD6SrgVEzAAPXLtASjYCOek2IYWQmMojbI/JpPSMCo0i6bmAECjJQd04sx0XtkelimeI+MNUvR89PhX/x5Uq9LwWtkZe1r9rZZdfJ9kp4iXy/eu+Q9FvrWZ0h/XnKfK/vzN35HzM8z7M9/BPFA8CDZ3xn1RkT1cYKGnmuwk+doHfliAN8I4E0u5AMAngHgWQCuI6InAng3gEcDADO/mYiuA/AWDBmEntK8Sdh/GHIeDFe/mhdpqQfJ6yNt08uDlO1X1AMTbJQ8L6Jds/cICPZqYzX7tl7vxn1HVTu9pGa35BFqDb2rLOazqbuXioSOEqQcIhjlIG8lMGIAN3eyTUR3Hszxh4noagCPBPBvvdfDqf0TAH/qjl8K4FeI6McxJGRoW9xfXNnfPOVFeY0oFx7ndSX4aDAy9Jv2GXkx9hklYGS0KYHROBZrkTfazIFRAlaRLcRt5TicXku7xA7i9pEuxLmlA6HX0lbrQdVlZNKPoHMWyJX1k643Ezp5feU1iuZ+1aTqNfJ1zoYsM+tZLCmU3Zz3pzQen7Ah7zmSbeJEDcGDxBg+2xkPUtDx3x+dqMGPw+8/Eu6yxIPUSXrOU8coa2ar+yPkv6JfmmnzTADPnN1pA+RUM9ohb2Mq2OSBx1U3QtVqgDTDRjyGEVKq0DFXZryna43FfB+OQVrC8JZ4jaZ6Y6RcMjACAAb3DFe4BsDzXDrpDYDrmPk3iejfE9GDMHx7/hzAtwCdFvcXSPYyT7lFf+6ZRqMeIQKnkkcoaaMgSIbiGfq5BAxJum4/fiC0yYIRvB76gVECQ7KeEr1iu5wOjDp97HUsKLLKjPNWIKpCUObjkLSbKqJ9yzrHgqYoQZPXEWVR9jlBF6TOgy2vK83KMt/WGqKDpKTOtVfdmSA1difTJaRgRBivaTEgYeykCEjyhfFj7hgL1nmeOjrZS7a6vUoGSLxUvUjexlRAKrXLlBdh60ABqXT9sTdItGnxHgERbFXtT5XCe7rY9tShTPHuaGl9DlLN07TW4n/qPqNS/XmAUfb5Ux1TmjKw7fTyM/MbMWRY0+XfWGiz7EeokywX7TWSYJTTB5ANpyuE4JX2GekEDF7GUCGMIT05MPKySUFoMhhZUAOp5+spLrPaqbJEB6PtUr/ybzMU5dpJm6jU5d4XlHWK+oZY817STq0HWvYaBdvClnzNLVDKwckUSIpsePiCDT+EuO9IR9gPYOJGoMEohaz5gAQg7EHyr2kRkDB6j/pGg/Sbp45RLh4cneQkJznJAQtj+bN4T3KSk5zkJCdZSy77PHVx4UhivCFN+5Ay7fe2B+mQvEe5uoV7j3KS80KNto1+LT1j31HRhiUbnM9dojC25v1G+wypm5KE4TzD6aaG0vX0GgEACNvaT74nuUDSmKEuqFPqFfIPkC20K+41kueZPtMkDMKmty+9KuPlrec1Ssoo9Ck9QpaHydyH5O1hPM56mqDKhC1d1uRpEmJ6iyhTX2tf0GuRopdI2Q0PINXro8x8HS0zMl6kyJtDSGxWPUjCHgkbUR3DDrFTQ9ZLCKnnvTZDOUf64a87qXqP4D1CqW7oz69d9NoNFe9RN7nc89RxwxGVF/FeZ1E4VaF9zz1IBwFIKOiU2i/Ye9QjtG6fIXFVmeLWXpKJbon+1GcfLd1r1PJg16jtRQaj4Wt08+INAic5dslmqMsBzNgwgacsGFnSkoTBg4gPpTPGECCiBkZOamBUAxwZApiAkSrP7TEK3/JCn9G50g99aJ1SGdJ2kV0YfVntMvXdJz9tXwxAh81JKLLAJgIlcSxBKZRbc7uwlYUkOQahk9T5Psbuon5K5dExu3XYEkDCsM6xAEmOXz8kNpmnjPTeveSyz1PHDUdOmgAHKEIOULBRaN/Li5S1Y/TtJ6sIkjI2J2ewy425Wjd+cafuPcpJ/X01bhYNbVth6igSMDSOz7yOqXuCWscxNcX3UvhbA4xWgKLQHXCpf5G7lKK8RsUMdUGfEGWn8+Ute4281PYaWWCUHVMKNCUwktcyG4zCAppS8NC6qn1SjtFeDqqSc33txrEFTVKmeJVKkKQnreK6dc7tJTu3c9x9WJPQ+EdDkSw35tugrmzK9yhJyEAGJAl7hFifdJ0/Z4xeJDnesfl46cjb0lnsdPuxrAxIYVzkygBEe5IUICXPP1pJLvs8dSHgCGgAHKAPJE1dcOfaZMqLkJTAD60OSKX2vTw2yTW3hsxZUtJrtXEe0hT+VqhrDalbw2vUmoShyQNU8RrNAaOpsLYiGIUuLvEvcicRYnmNWsHHSXM4nQSj4phGm6m3pgxG8bhi/TlglITRueM8RKX1gFh0Z/ornsM4131CtLPKMrpZGKqBkPUWLr2laNpQknqNWP0ISoke6bZ+zeDOc94kOQSC0Mdow4Ibq8/QhdTl8eNaBKmx62T5GADFACSpVAMk+UBYKZFXqQRIKryup1zmeerCwJGXZkgqrZdKNvQ3pKVdrk1hHK1endUAqTYWq26h98jqZ0lZkNK+I0sqn481peWXoKJO6/OQpnqNlu4zagmt2xcYFbMBGmDU+de5y/6L3KUUy2vUFEKnnmm0JJwusju0qYbTRUCQedCrkJwXaTYYUWw3r5upj643D1LFc8TjnApFTUAkJq8iCKm6Lt6j0jrHnybkIfrnUUnDUhMoqWGY3iQ1JBNonN0c4CTHflxkw48wmQASovLlIXZJtjqMa6kgzYDURy77PHXh4MhLkxcIqELS3FC7Zi/SVDuGjV6ABNhAk7Qv1o1f6iZAykmr92hmaF3UHkCI/+10b6leX038NU0EoSBTvEYtSRhapPaw11LdQjBqDqOburdohbAFBmFrPpHzJBdSqqFvGa/RFIhKbCKGpTn7jOTCPnttGeBpAKPURgpGWSgx2iT1lXa6b+u8BXYSvUzb1BbH5cpmFYSs92bOWla3yf3wq9YP5twerfBZeIkyoCRtufqoG0Ekka7oi9Sxrkt0vUnfH6eAJF8KMv76g2ZAcmNo8iAhLZN2LGEaAamXXPZ56vjhyFowC6kueKNvqd0eqEDSUkAqjGOfgJToqPpS3Wwp9TGxLGfTkp4gVO6oUydTQ+qcNHmNajanhtOVwOaSg1Ho8hKHK1xKyXmNPBhNtFP0GrWC0ZQ+IaChITNdEYyc5CAn93DXUhsNLRKMLO+UtmfqiX6LUJQZYziO7LBdrtsjLc+f1+9T1u2m+sOvbqzWKCzPM2uD0UuUASXXTjaV/QjOykOS6lYOP3ce9YcYkHyhtRep1EcRkKKBlgEpvhYFSBnvUUeHUSSXeZ46fjgCmgAJaICkuTbUTaPaJqOfG4dpx9TrA0il8WS9QVE5YZL3KPd6TNx71OYpyrdfVTr12RRSN/dBsdUsd437jHI2jwWMVk7CwSB8ks9W7eMkRyY1r5EHKAuMFvRZ9RpJoCHMAqO03wlgZEBGFozU4jnRNcq1zdCXrIfSR2pP6zRDUU5fHwsbyRhmSnP7SkIGP6fGXqN0Lh6rYkMSdhLvkrcthyLeZ61DGG1Ew5TnyBxz/HWy9KK/xlhqgBTayddFJ2kAYiBqBCQfXtdLLvs8dTHgCCgDh6/y3+WWX0zmLMAzC+/VvEiGnglIiU4ZkCYBlKibCkg5mew9agmtm7rvaCUJ700EFzMMNYTdTfIatSRhmDKuytiaoKQHGHXaX8QdkzQwgN0lDle4lFLyGs0Jm5Myx2s0BYz80BpTdmuxIaoNjHTIWQmMWOiZukjbjuMrA1N0LbDbp/ULgGgqCC34+BRFrQviPo2EDGo9EHmV3HnWmyRMyfYE0XbsenyPMiAk4QbqPKcXLZ1oRUBCu9dneFnbAamXXPZ56uLAkRf5Sc5IsycpY+e8vUi1MLuWZyHVQKsESCVAzAGSqav3HhnXO9t7VNA5VDHBqVWm7vFp6WNJOF0JdM4TjEqQY+j3hCIpl3mj60kyUvIaiVTeewunmyqtCRjMv7QcjAywyYGQhp+snpCSTgxWBhRJPTXW8RpVO0usMZl6c+YQw1hu3SIBSPQpYSe0j4BIgVLohkO7ZNkhQEa2k2CWA6GS1yjSQ/LSmnuR1gIk6T2CqjvPdcxlnqcuHhx5KUGHr8p98bWdFhBobFf0IsFoY9hZDZBqYxXtF3mDpJ1McoZW79E4NpoHFaq9hqvwOm4wz8OzRFSYXNMzDUpjnOo1CmUz9hnl7K8BRq1hdBP3Fq0FRsyE7aqr1JMcmlS9RhKM1h/MNK+RA7Oi12gtMFLwUQSjBl1vs9VbZMEMZ44juLHGj7S8CESqTINITX+yWKnjdN8CeqIhaFiSXiU1MLkM0PAUIMkZs5YY0VB4nK8tEJJtk3ZCT+uEsZ4DIMGqs85z+486yWWfp44fjmoLc/1NMaQGCSUbXb1Ivk1HQBr64YJOHoBq9VngicopLD6bgMq8/tGG1qu+d7JfH1o3oW1q6wAeDDslpG6K12hJOF3OzgmMTNld4l/kTlIRy2sUkiLQMq/RDDBKYGBNMJJigYhuD1VW0C3BkywPxxjP50DRZCAS52kdm3rmea3cEmstYdWJ7AkDZFDQ17CUgJLXF/OvhJTRpjfJoY1/n0P3oj8euwmfCfLXwHn4yQGPfgkmAZK4jqF8OiAByKb5bgGknnKZ56njhyOgCC+tOvJmVN2TNAeSMm2aocooM/s0+qolapgMSLlrEO1ygGTaEDeErO2GsSQ6mde9i6xpe6qUEjF4mZSkQL75C8Lplob69QCjXmF0HYF42Oh6MW69J2kQBxlNXqO5qbtXkjR0rDMYaTH0onHIeqRlOd0mHeOas+BEmAZFFSAyvUIZ3ey5bDtVEkIx6tg4F4SShaUSKPk/rNqIcg1JGlAgzz0ghbaxbq48a88ftwKSbJwRwYcm9ACw03zveb1x2eepi3XlFlTM0CmCjrfRAgsN/RYX+1Y/RlkNbgadOiABNugkfZTAQNRV4SZnx7xuyi5QRxjK61wmmfqQ2Gx5TzDaZWxl9SeCUau3qATpe0rpzbjcG11P0igCnAJI7NlrtP41ZsBH/oVRb5VldJt0nCRtrHECAHFfKNJAVAKhiSF1Sd8VU9nwurCGGQEIei6XniXXQAPD2HyEnkhFrUUiSAKJ81FfepFye5GSoYpya3mW6E0EpLEs9h7N/lE19F32HvWS3vMUEf1rAP+rM/0mAN8E4NYAXgjgngD+HMBjmPlD3TpdIBcLjrw0ANBiSCq0n+pFKnqtTFCwbczKZDcBXpq8RDnJhdfJvnV6b64AlvXaHJOItXgSBpfbb5T7a0mw0QAjYUwV3QsIRvuCIinb0orlJBdMRphp9hppMPJrlH2H00WL/j3sMzL++pewCkaGrqnj9ExvkO5Lfk0JCFCEvK0sFEldjDoJEOlbQyGkzryNTHAxJO0zXqN4bTECUAQ3fj4OfznM4d5dYnmTLEiCMCXPx71Maaid1w3w5ApDnV9TqKFafcmyNQDJ/quec5R5SGwNkHpKr3mKiO4G4KkA7s/Mf0tE1wF4LID7A3glMz+LiJ4G4GkAvrdLpwtlNTgiol8E8NUA3sfMD3RlLwRwP6fyaQA+zMwPIqJ7AngrgLe5ulcx85OXD8L9rUFS5RNV9e5k+pjqRcq2sfSNsmzbfQNStpzSBae2n0nQkG2f0dEAFc6NfUeA122wP2dMWtZYdLckbah5jXLhdDVbremya2C0Zka6AwKjy/7k8UOSg5inDk2MlN2Ahow9gZGCjyIYaVDJ6GgPT65Oe4q0bnQexlWBohoQtYKQnugb1rAyijF7e0t+iVR9CxAa53UBSxjrS6AUhlKBJOkliuFm1JXdyHH5bsPnZhzdQQPS0Cb/kFipu2ZGuxXmqSsAXE1EN2PwGP0VgKcDeLirfx6A38NFhyMAzwXwMwCe7wuY+Z/5YyL6MQAfEfrvYOYHTe2kzWvhlWfWQy2iczYysJNtN7WNpa/KzLaJzvkDUqKL/LW1eI+aPgeN0tOWlL0mcmjxGmVhacbDXk39Ahjta3/R1DC6KR61BbK7xFmADkyeiz3MU4u9Rn5luw+v0eRrWw+MIlhBvk0CPSUdcY3ZcQQ7CnYsO5aefF0w1kPZiepEffKDfQaazK1pDZNXdktbxnMUbou1hAwlUBo7Sb1JGpJCO3ItIovinMX/x7roWBSUgCbSR9pmX4A0dD1tnxETgveop0yYp+5ERK8V59cy87VhfMx/SUQ/CuDdAP4WwO8y8+8S0V2Z+UancyMR3aXX2JfKanDEzH/gfmlLhIgIwGMAPGKt/k9ykpOc5BCFgZPn6EDkNE+d5CQnOUkqE+ep9zPzQ3OVRHQHAI8CcC8AHwbwa0T0zxcPckU5rz1H/yOA9zLzn4myexHRnwD4KIDvZ+Y/bDVW9ep40T875OoLOlVPUKZt0RtUaNN1D1LNewStg27eI0tyHhortG70FFHRG9BVKuNvlrk2WvcbTQmp29deowP1GhVTdO/Ja8Qg3MxnXW2eZBXpOk8djEzZa+TrYJQRmh4qu8hrJH69b/YItdir6QOo7i+y9KQ9V6fbJx4jadcoD2ajPox7EqVFk0XGpOm+hZcIcLdLy5MU5mrlRUpcJM7bBtFGeJCGVhy1Dd6Y6Nz935VZXptwaRVvj770ot5C71HTuoAwfe9RJ+k8Tz0SwLuY+a8BgIh+HcAXAXgvEV3jvEbXAHhfrw6XynnB0eMAvECc3wjgHsz8ASJ6CID/SEQPYOaP6oZE9CQATwKAK293h6gu+lKVPngFIGnVWQJJU7PZJf3kvsVLAcnUaYSdHCCZdkbAqdpvARR/oww35cF+NvRuovt5b882akmyMMVO6RpbQuq8HBIYLdhjNHl/UWcokt1d5ofrHZF0maeu2tx2eUidCKtbHFLXIFaonQlGZJRboJETS1+WCb3uYKTOx3IFRUhtJHpSB0NdCkNAKxAlb1NhL5L9Gs+5d5F5GNPFeB6AicQtNJeEQWZNkJClICm6FG9HJGGAby5eXkask4CJn//9JVAdkOLrzuuVAKn2FriXpwBS6QNic4C0xg/GneepdwP4AiK6NYawui8F8FoAnwDweADPcn9f0qvDpbJ3OCKiKwB8HYCH+DJmvgnATe74eiJ6B4D7YnjxInFxjNcCwK3vevfsJ6LJmxR9u+bpFPenhC//hLFl+mvyIhlt1wSk4rUbtnKAZOm3eI+a+p8ztj3L6uDV6jXK7TWyypaCkQEeXcCoh7doJSgahbo9XI+IrgLwBwA+BcP9/EXM/ANEdEdkUqQS0c5fwIYAACAASURBVNMBPBHAFsBTmfllXQZzgaTnPPWpV97lnO4sI7gEMGr0GlXt9krCUOoDYiwl6EGDjgKhfDlHOvHrOOqEMmgbAnJkvQVFJSDKwZC5erfq5gibh6NdDTUI0KM9S9Kr5EFpHB5nIYlFOQn1ASTidib8RP+3QWoKIAX9GaLhJ+4nv/cIUVn8/KOWvvpJv3mKmV9NRC8C8DoAtwD4Ewz3x9sCuI6InogBoB7dpcMOch6eo0cC+H+Z+QZfQER3BvBBZt4S0b0B3AfAO3t0tg9I6u5F8u3mAJJRZgKSGFM3QJpaLmwDRrkHpJZvvb9Bevtzw+9K7TYoP2hVSzGLW+NwpobUaa9RCXJyEFBLwnAIYLTEW1R8X3KvyZQ3viyMrr/I3QTgEcz8cSK6EsAfEdFvY1jYJylSiej+GFKoPgDAZwB4BRHdl5m3vQZ0QaTfPOUAIrsLvsVrFDLG0SSvUZMQ8uF0EkAqSRsmg5HxV0NL8/gbbJX6H+xweRwkdERZKxRVvUS5THZB2Cyn3CJiymtorSF8VRg4x6t3DUsijG7MujZ2kHiTCpAEX+yhiqXaiBsm/Pj/i7oEUCqABKNc64QyB4clvSmApF648RVszVzXSTrPU2DmHwDwA6r4JgxepIOT1WI7iOgFAP4YwP2I6AZHhsAwMb9AqT8MwBuJ6A0AXgTgycz8wbaO0HQTYHlzqtkq6VUmh2wfmXZT25j6lu3WdqGewr+SDbvttPKxLC5MQhmMscqJOunDEPPXvWOQfmvxQaZkqAtjyECQVdbqndkTGPFuNz0bnQmCu65g5GWLTdO/mvAgH3enV7p/jGHz6/Nc+fMA/GN3/CgAv8rMNzHzuwC8HcDn9by2Y5K9zVNjh2lIXWeZnKEuO1YIG/VwOnMsM8GIMZZVwadWj5ougzcZMPL/NhyDkXsdAhgRHKTG+oneZigjH2Xp9TbaBmN4Fbwd345B5P5t2LUf+/VlkV7Lv41tL7KZ9MnjOPVr4K5raDdcr34dWV6r7HcTvw6RLtLX0n7fxeuf00Gu7YzPWsHWnB8Asj9UWN+9FaXXPHWMsma2usdlyv+lUfZiAC9e1KH/kFScBU2epBZ7hfqqJ6lDmyYvkjFG04uU2BaeJFXfw4MUl5G9YPW6peceLZHKvqOiV2+J1LxZLd6uJV4jL7lnGpnPPKpAUim0bQoYrRlGd87eosgsCLuOsxoRnQG4HsA/APCzLoQhlyL1bgBeJZrf4Moupex9nmoZk+E1Cj9aNXiN6vZ9G7jFaCEJgyXWoi23EDT7bgejKYvY2WAk6rV+EkIXjUW4LJR+PPZRj4yy8XXi6DzxCIkxlOpGnbQsJ1FuJmlbrRW8F4lksoVQ7srIFfp1gA+9c4Mc3l926oOe6UkK/Y665NRML5J4GUavEUdakY4z7T9zerlk6qvjqIxR9SCZay3lPdJ9D38Lqb0p1uklveepY5PzSsiwnsj3svA56QpJubVVro+CzSltTF1rPKrsXAEpN4ZKubQZdGqJF1r2JtXe333JkkxzrbanhNNZZTVIKuksTbywRhjdnqEomAdwMzffeovPjwAAFxL3ICL6NAC/QUQPLNizZrvz/vRfcCFMScSwRFq8Rtm2JNsaoETIZ6czwMPyGqX9qTZIy3K6vcEoAjpZr68RGOEmasO2DtzbaobNZYBIvVYRsJAsh1Kc91WO7MiL9q+jH5YJRR4/ZJkCJT82BxBgSiBp7FV0EK09OIYpP9crQBphyw9hOiBB6C0FpGTtlLSPASnqx1jLVZMzdJKJ89SFk4t95Q0L3y6QVOknuzgvtCtCUg00LLuqXUubVQDJLIvvwAns9PIeGa+dlCZvHNTr0tq1oZ+10ZKau9VrVISuysNelyRg2DMYrQ1F3DVJA2HbPokVnx8hhZk/TES/B+ArkE+RegOAu4tmn4nhSeUnOTTRHiKrbIrXKABAexKGCDRKSRiSfqgOMrovZHSN8tXAyNWF9slrNwJPpB/1Oc6ZCRTpFbOf55N9SCkMZRM2aP2o3CyOJLlNClujp8gXjKv7AQRGCNKgxJGiuBBfSxghCeOeJBI6bkDx2CRMaUDyawbR6lwASdqgWMdub68p4rZp9rp1f9aaNE9dODnqYEH340FdCjf/YIvGf7NtVSaZrO1Cn2Ybox/TfuW8pU3PPUjFMqB4Jw+/WMpJSLSJJlE9Bm3L1+Xi/Rf+eruK9PIeWZnppPRIwJABI+bdcjBing9GuX1Fg5FMMXcGo+GeteNN07+aENGdnccIRHQ1XCIBAC/FkBoViFOkvhTAY4noU4joXhiSCrym6wWeJJVGr1EUUjdRql6j7NgywFO6H2egIzdf5fQtWLJ09glG0bwY6fCoJ/fL+LWD2Gfk9xQle3H8qoUQ7eOxz5HuTSIGbXZhr9BmM/wLH6MNR/9a9hulbZDYG/cm7cQ44v1EtesZrlu9HqT2JInXn9VrHO3pku8h0tff/mxwVJ7Ui89q82fN+Pzqz3zx82+0mfLdsr631TVso/Scp45RLoTnyPh9wRavUFnrRF7lnG7JVqGu6BEKShPaGLpFj5AxtlqbxIMU1Ym2lCm3+nG6ad8EK1RutrSE1jXIFG9R1cuVq6+FteWk5jVq3edk7TPqCEaRzHmw6xIoykkBitaUjr/IXQPgeW7f0QbAdcz8m0T0xzBSpDLzm4noOgBvwZBS9SmnTHUHLhKW1vAamfrGg16FDSnpIo6mLxoxlml92cc+wCgaZxiHACMS56E/BwSk9MM1jOfSS5R6jER7KH1Zr8pzt5NsJjshrD4E1p6jYRqlUB9us8RgpuAFwjDdJh4ln4abmcZ7dPhMs3t5RKid6zt4iEI4X7xQisLx/HpChdnJJUurB8lum9H35yTqGNn9RzqiZ7QdXoFCWF3+2UezfzgtyGX2HF0IOPJire9NKYBIYjMHJtpWL0gqtDMX+IZuVk+/QKpNMh6hk8BBVFcBpIpu7rXQ7XVq77Ge2oEqV2eULwWqZmkNucslYmgV7TVq2TdklfUGo4lQBCwEo72Fz2X6YOr2axszvxHAg43yDyCTIpWZnwngmSW7Draexczf02OcJ3Ey5aGvMhFDk+1pXiPtJSp6f5DRI61DcZ0GlDBWG4xaflnfGxhJwEGsG+m4OtJt5OqWkIUiDUQU/qrLN/YjWfAzdTkrbSTW/OvKNOr5hb+GpRwoCTBKIInkiMdQu3EsOtxO4obvU9T3AiQ3rCwgyTWMrvP6EpAMiKqCk6HrQchKziDhrIf0nKeOUS4UHElRn928yE9nyZ7TWwOSijaNL4A5DqVbg52S/b0CktW3g52lUrJXHUMvkbZarslat7cka6h5jVrD6SzYOXQwmuItmgNGnRM0MICb+ayrzd7inuXzECIi5hV+krxssjTZQggfpvxzjbJtU7DJhRQnACRSKKd602Emp1cEH8Rt9gpGun8NRvJtjdrMg6LRQai+cka5fBnze47qX13pOdJvTQRAQinAkr8cUcZjMQjUDkmeJFxr2RaRl8gtKKL1i6jvAEjAuG6JcCwDRfK4Rd8ELSD8kGE+/8hY81nJGXrJMcxTa8pxw1HDXKPX+U22SmtRf5PqCEnyF7UWz1B2HIauCTtSp7XNAkAq6lp6QACant4jE3z8ImEPHgMpTV4fc9E/oX2r7ZYQN2AZGHVI0713b9FqWeuo68P1VpQ/AfASIvo1AJ/whcz86+c3pIspWa/RhP1HPbxGiUSAYuuNtkjYzNjR8NKgk9SpfqNj0tcGLAKjUMeqLwFGmRC6FijSXqKSd0i+pHGoXXz/msrgkedIM5nzBvn+E1giUSaRSHuTmiFJLYbYL/qBCIBqYXYLASnoqLVE0esj28hzKuvYoOWuWq/Lgl7/h76mcjTz1Cpy3HAEmIv7nGgeqNos2F3Tk2TazbQxF/wKDJq9SMJ+0ia6QbiboZHJzgKkJmiCoauv0dvLAZIhLa+PKdLbJPU36P+AViCalYohdZZM9RpZe4ysdpHuimC0prfooKDImQeO5fkRdwTwAQCPEGUM4ARHU8QBSLf03ZbXqJo8oeI1olTPXBdZ8JH0ZegZOmFtq3U0wMDok1J7q4CRgJWoHojByK/InS4FeKpDUS5TXfSSqJC70L+QjRViN9Fz5DuV9ydvI+wlggcbjN4i11Z6lMbQO0YLJPFYEQ8G8W6cwWQmzG4lQPJgIm1kgYdUnX8tMjpRn9baR/epdfTeo05yRPPUKnL8cORFf6IL0gxJUumQIMn4AiW6hu2SRyhXVgKbXKrvVkDKjUd7g5qllHyhJbTOej2K/U3UnyOl/UiTwu0qC/4DBaPe3qLqnqI9JWg4hqeKM/M3nfcYLqUY+4+ih8AW2g2LeCo+18j0GmkdlbY7tIv6k7aMvkxYieuLsEWiT2UjqxvpdQAjkq+ZBx5AQlNYiROQeIu8PoY2OSjSQGR5hiQMbYz63HlNYs/R0MmZUQYaF8veM+Q9S4QMKIGbICngD4n+Ik+SSP3Nw3kSZjeOeDEgAenaIG2XAk9SB9GgpCPWTgh14vlH5ljW9x4dwzy1llwcOJISf0+yYrFE1eZakDTFbsZWqxepaqvURul3ByTd59TwOuPaZV3Jy7SWRJ4gufZOQKFQp+tDmYKaJZnpTL1OYFSDIkOnt7eoCDh7zFp3LE8eJ6L7Avh5AHdl5gcS0WcD+Fpm/t/PeWjHKy2JGJrsDPpR+u5Cn1O9Rrk+c94gE16cmJ6dWltlP1evdXuD0ainwCj0a8HQCFVevwWKtHeoBkMt4XSWN0lLzkuUlhHORJidh6UcKIXXsAJJAU2ELgDhSSKxtlBepDUAyQIZ1yBpx0oP6pjFuWqfrLGi0cftZd9JHRB5j3rJIc1TLkHQy5j5kfvq8/Ji4UlOcpKTnJPssGn6d87ybABPB3AzALjMeI891xGd5CQnOclJ9iKHMk+5x038DRF96uqdObmYniMplmfEkGYvUsXebA+S/tnAsNuyD6nF09TkjTLa5ELQmrxH1nUIz04Yj2g/9kWm98iU1tA6bWNDwQtx3p6mRKz9SCVvT+teI22jxbY+7uE1mhNKd4Qeo2CbgZt35w4+LXJrZn4NxT9J33Jegzlq8fuNJrUhRJ4lV1ZK761D6swffoO3pC2krmwDyXiyYXK+nfubjE95eIoeJBR0e3qN9J4h7TWyPEFSF0PZVI9RLmyu5lXS+i2SC6Hzkgul823ZuT123iuE0UTNg+Q9Kj5cTgaKjd4kjK6XYZTreI8sj5Gup1S36DEiUcf+WuO6yCOUrJdEaJ2wO7ZfL7TuAOepvwPwJiJ6OeIEQU9do7Pjh6PSQlnreekBShV78qZv3qsUfLTUZcHLeA1mhdhZttSXOeo/qqsAklWmJAmdq4DJlNA6sx/rmgoy5UGwpfC2xEYuGUMuHC+UFWAm2Kg800j3ZaXt7gVGew6lm5NwYS/POcLRPD/i/UT0WfDrWaKvB3Dj+Q7pAkouS11FopC6zP4iQMBB5qGvpZA6C0bikDlKAcSLBTtGXdKvrkNq2wzVkzq6zMHKZDDy84PWlWDk/zq7MpQuykIn9AiIoChsKTNC5jQQ5cBpYywmWqI0o1uss7cTL3YplE7KJlNPsCEJiFN/RyF2rmGarGFcHHUFJEE/enkTgU8GoBJ4oXxdBEzSprCbjM2XUaY/iPVQJznAeer/dv/2IscPR8Ak8In0WxbERhdT7RUX4KW2mbomz0+jXrMXKQdVEfTMAKScbVc+ng83x6TeuiEY3qNmD5Acz9SEECWp2cntN2rNXJfzGiX9GBC0AIyaky/0yEh3XlC0Qva6I3ny+FMAXAvgHxLRXwJ4F4BvON8hHamUHvxabYuwKJRZ6nISA0uqV4QhIxFD2tYAGsTlWRBC3K7kKdKwU4UoByW+7x5gJJMpFMHI61reIj/HEhehqGXPka+TINSSta4oor33Ep0J+z4lNzBAk/YWaY+Sr98hD0kM+ZykYdL107x/o3SyhrUAyR+OaBRbKYFP0Gutc8PPtYnWm3JddU7eo0Oap5j5eUR0NYB7MPPb1u7vYsCRlPg70U03A/e2vSWQZLXP2F0MSVN0lN3ugGRcXxWQSrpG3XBMgDE+AFFo3eoyA7rIgBMTXlrD6bLgsxCMSmF0vdJ0TwmHOyAoAoaP3KFsdK0IM/Mjieg2ADbM/DEiutd5D+r4pP29zmapy+p7XdHW6n5jw9BQ3/qcI2OsBajJAVQRhHSdBh2k9QkY6fZLwEh4hFrAKOctCt0rHQ1FJe+QB6LWrHW6PifyXuRD7HR6bwlNHpZKoORtWZAErweJN/YDZD2wrAZITKknR4wgAhIJNQXACeqZOr2msqBHt2OM66qa96iXHNo8RURfA+BHAdwKwL2I6EEA/g0zf+0a/V08OJIyAX6Sm3hpzZRpktiaA0ml9pnyOeFkOXul0Dl93hWQhO5UL48OrxvqKAGpKZ4k87WKXqcJIXZeKmvtppC6mscn1E0Ao2iMBTBaur9o396iufuJVn7OEXBw4Qo5eTGAz2HmT4iyFwF4yDmN50KJ9eDXqjgYKj7bKCzyc/uFxLOMDHgpt81DT9WblNM3ICkHa2aYngFGCUxFfU4AI9lHIxjlQuhaoajkHbLC7tbZczSW7djOUpcDJQ1Dshzgcc9SwYvkXu1VAclfi9aM0Mh7sTRAZdqX6sKaBxi9R7Jc9yEH4+yZQETAOt6jg5unfhDA5wH4PQBg5tev+WPd0cPRpIV0aDRBvwckZez0hKSeXiSvp7/k0QXn4MbpTQWkMCYNSMm5gp7a2AvXWG2zVGr2JiQ+ML1GVrs5ni+dtrsHGBWgZ/azi84Ril72V2/A2TXl5lNk13ka6ylE9A8BPADApxLR14mq2wO46nxGdcTiYEOH1NVEwlPdg0RjIgazHjYMyTq9DspBhu/PgJgc3IR1bwI1KSRlAchoE12PZU94fiaD0SaM3IQioAxGw9seA1ArFBVD6jLeIstLZO1D0hLdi5wN7U1iMUFGsEQxKO0o7zEK5TxOxv5o+Dei0CA+lEwBkgMpDh8qRK2bAMmvKUS91oy8RbJerHeiNjUoIjFaFu1UH+JtqACRgrEV5MDmqVuY+SMqQdBqV3/0cATEN8hJoNQJqiwemdJndfy5tkb5FEgydYRe0XtCsV7UZwAacuVcBSSrvBmQgKL3KBEdWqdem+y4OojpbdJr8rleo6nhdK2hdEvAqEcmuoX7ipZCUW8ZsgCddbfbUe4H4KsBfBqArxHlHwPwzecyoosuMhFDixeplohBhsqpLHkxwFh1HbxGGlSsvht1o3OrT+81km1U+dBmBhgFCIrBqCWMLuctaoEiWe7PQx+qTAPQZM8R5P2dItuAWyATj6F1ApYkKO3QBkkbZ1OH2gUvkl5keJJhN2/ziEICE9EMSHpNoQEpghmPZQJQSOiJ42y4m4KfGvjk6rJ7j4Ju/IoslQOcp/6UiP4XAGdEdB8ATwXwX9fqbDU4IqJfxDDBvo+ZH+jKfhDD5PrXTu0ZzPxbru7pAJ4IYAvgqcz8sjn9TgKlBvAx9Qu66seDyTaK3qQSJOn1ZAMkZftqAJ+cPUsveJEaAEmPIQtIlq5IztASTmfa0vuOLMAa7u5dpTmDnQUkEdAcCRj1zkJ3BFAUusXhPFzPEmZ+CYCXENEXMvMfn/d41pTzm6faQYglAPmQuoJeGWyMSkJIxBDbQ4O9ir5buEHpIqdLhi7i8lI4XVIOqw3KYORXnh6GXLu5YXQSigAkHqQcFGkPkTwf9x+lsCRl6p4j03OEAXI2xKMnwYGR/yjugCZIAtxrwRSVARgnZLGuIPbAlvEiQQeTNQASiXINSCZHjXWt4XWmOa0rLlXrtkDU2t6jA5ynvh3A9wG4CcCvAHgZgB9eq7M1PUfPBfAzAJ6vyn+CmX9UFhDR/TE8XPABAD4DwCuI6L7uwU+zZTYoAWVYaoAqi0lMG70gKWOvJcTMfJ1q4CP7sqAnKa8AkrNnjde+hgFaTMiKjgXc5MpL/SwU01OU2++TeFAydRWIGdtXwMjy4mRsmmA0N4xu5RC6uUkW1gQiLQcWrpCTtxPRMwDcE2KuYOYnnNuI+stzsY95akpInfYiFXUFaBl1Tem7k75hTloj/MgJI4UkE3yi9hVdy6YqtzxFsk0CRnLRXQMj909nmquBkYQi91Im3iLpAbKgqMVDZMFT7rhFIi+R8hztxEJkDJ/zZaI8AFAekmSqbz8Rey+ShyZ20OT7jEPtCoDEEN+VAiAFujEASQCNvzzfDFAwIsoteJEQZbavgE/ervAesaXbd17pNU8R0f0AvFAU3RvA/4bhvvtCDHPMnwN4DDN/KGPmf2bm78MASN7uowH8WpdBKlkNjpj5D4jono3qjwLwq8x8E4B3EdHbMWy86var5SRQApoAqFUv+bLl2hs2iuO2gMgoa/EiSd1ET3y5IzsZIJkFSEI361VK6ikGJGCy98i6zuxrIa9hiiwApKrXSJZbzzRqBaOk3gCjfXiL1tpXtACKdp3dhIzDygJUkJcA+EMAr8DgKblwcijzVCsMJc82SuyIei0Z8InSd0f6dUiJ+zWAyOlH0JIBnMimATlJ38KrE3mPkvIYesY+M2DkFuoBkJytVjDK7S0KAFSBIitcTgOR/quPQ1lx8TKIXABrKJLnGwdCGpS8RykGoxiSNsxDO1AERIC9Fym8SY2ANFRxGZACaYQOIkDSCr5IepZMsDEhZbwUC5TC55BFHalqy26lr57Sc55yqbcfBABEdAbgLwH8BoCnAXglMz+LiJ7mzr83Y+bpSEHIKusi57Hn6NuI6F8AeC2A73aUeDcArxI6N7iyRIjoSQCeBABX3v4O7RAj1dYGpQokaZOtNrLepM6QZEKQ0Ml6kcRxZKMBkLSuBqT8OY2LbnlvlXrI6OReEx9a1/OGYz7ENaNbCLHLH2fC6Up2dXlHMOqRhW4xFFWyzpWgqDcQJfYPKwtQTm7NzLmJ6qJLt3nqqitunyo0Zqlrea5RSMRgqOSgJQtKOX34cjL1U724PHtOcbukbw1FoZzTvkmUC70IjMJ5Hoz88dTEC1YYXc5bpMPnNBSZnqMSGCHVbxXZNoEijOcSkCxQ2oDC/qQxbC6Gnw2z8iKNU4OGJgDNgDSAAuUBKaIItaBz1ywhCEo19ONIJ7LiTnTZUu9RXtddlaHbG5JWmqe+FMA7mPkviOhRAB7uyp+HIRNdNOcQ0VcC+CoAdyOinxZVtwdwyxoDBPYPRz+PIUaQ3d8fA/AE2Kxgvs3MfC2GBxPi6k+/e6xzKKDUoKPZImvjnCGpmxcpAqcUkBLdKYCk2prJGWDoS2jKXbMUZW+q5DxOxJyMI1mb17xGsryWtnvqHqMlYDQDioYiDYh9oGjfXiJLmAm3HAcc/SYRfZXfb3OJpOs89alXfbpfESOEzBWkyYsU9hdldAhJIgZfboGP5YnKeoMyYJMAEGI9q53Zh9S39EjoqTLpaWKlF4XT+cs1wCjxFgGLwKjkLZKAJKFoQ2x6hbRXqeQ5mgJJuXA6308AIqSA5P/uMO5PAul9SCP8nIHBsL1I4zlCWQsgwYFNFpBIhdcJ6pFgoX/4LUKQtcbJQNAU71E0Qq0LvYZJy3rJxHnqTkT0WnF+rbsHWvJYAC9wx3dl5huH/vhGIrqLof9XGH6k+loA14vyjwH4160DnCp7hSNmfq8/JqJnA/hNd3oDgLsL1c/E8ILMF/0habhP6A9W9d5SAJhWnWZIMmzsA5Ime5FKgCTKI0AS1zcVkAabww0xgh8dXidBKAc52XJ32619HlrC7Uo6VkjdFK8R0L7PqABG1cQLPbxFrbDTAYqWAtF2heceHUlY3XcAeAYRfRLAJ+G+IcxsuEIujux1nvIyNUudIR5wbJix9hehmIghtU9puQE2PbxGpk7Qy2eni8cg5hcJRlG570OAkQcfYbMHGOVC6HJQVAOiXnuOZJssJHkQApugJHV2ADaMKNzO5zDSoXbei6QBCaqsBkiyLgEkQRot+4+SxU4EIyMhSeBpgaAm75GxxosgKeiq8P5M+6UyYZ56PzM/tKZERLfCADlPbzXMzG8A8AYi+hVmvrm13VLZKxwR0TWeEgH8EwB/6o5fCuBXiOjHMWx0vQ+A1/TtXBw3foCavUottis6Ob4xC1eApFrbmhfJhKdWQIIubwQkabcSXpe9VvK3Sht+ip6kucJcDqmreY0kzMzZZ2RmrCuAUW9vUe9kC0cERcDwcTwGOGLm2533GM5D9jJPiZC6oifJg03uB9yGkDqr7xSUjDA7A3TGMcXzY81rBONce42svixPUAJOCpiGMhbQJNt5uIG4sadg5G3K5Aq9wMgKodNQpEPmpobW6bqalMLpfH3iMYIPrYMNSUzY+Hmb4lA7D0Q5QAKMshwguTGYD4p14NSy/0iG1wEOhJiKEJQAiR6u0SYY8vrWubKda2v230lWmqe+EsDrxA9Q7/X3WyK6BsD7Cm0/z2US/fsY2IUAMDPfu/cggXVTeb8AQyzhnYjoBgA/AODhRPQgDK/7nwP4FgBg5jcT0XUA3oIhhvAprZnqmgEmGpw00NZkn6Aki/cFSdnro1THAiGzjlOdXoBk6kIdV7xHyY1Fysx9RzRhPU0WpOg6L9qLVAqnk2XnCUYHCEXnBUTJOI4Ajmh42t43ALgXM/8wEd0dwDXM3PeHq3OUfc1TrjNkM8tJaXnwK2FSSJ0GkdhOQ1mmvNVLpL1LLdBkl4n7twFTUV+yjSgrZaaLstJB/u0LRhKKgBGIJDRpb1DOkyTLhmP7HmZlpRvrfPkmsh0BD4w9R07XgqThhRuhCITIi9QLkJiisxGQFFEU9x9JeDHWSdFagXxPiCBrCgTpvhjDZy3qwrXT65RknKQuqaOsME89DmNIHTD84PR4AM9yf19SaPscDGF012MPCYLWzFb3OKP4OQX9ZwJ45qI+l4JSOcmy6gAAIABJREFUMNSpnymgVIEkba7UdjIk1dpnQCoBIdgAJI+jtgKQhjJOdHOAxImNEX6sm0fVU+bLUYGmFuHpUJXAjy9LAENeSAZmWsFozv6iTt6ifUJRyz6iGhTtOs46B/j8iJz8HIZ1zCMw7L35OICfBfC55zmonrKfeYrs/T+RCpWByHu4aTyOxuXKbXgxbBJSb1QWlMjWmwA8/lx7f6peo1qZA53YjoQhFuPlqCyaJDQYCeCR9SUwOtuUoQhAAkaJx6jiJbL3Gu2SMqCcqU7rjp6iYc05QlEMTDKkztuxIEnX+VA7CUgSnIgxYA0Rtjv/wfQQWAYkDxUtGezitrJsOA5eJd+Nxw4DggBRlVlTJRCUOxdlwYYsMyHJTszQS3rPU0R0awBfBvdjk5NnAbiOiJ4I4N0AHl0w8RFm/u1uA6rIeWSr24vo93TSYrcFaox+FoGS/gxaa8KMas52MyS1tjcgqepFkm0siIrKBCTVACljQ4fXFb1H8hpVeQ8Je4Z2AvxqYulaXiMZTmd5eXqBUWdv0SFB0T6BKLXdZ9Jx3pznA/h0DOuOa5n5pzo9yPTzmflziOhPAICZP+Rixk/SQ1o8SaWQOqBvSF1Uls6hVU+NP6/UlyBKe41iL5C4r+d0pE0DmCjS9WUSgCDAaLSxFIxye4s2oi4bVqegyIKhWrY6y5skM5FZniLAeXZoKxbJrg2jDEmg5B7nEzZsQNgRhYfIai8SNsNYmQnb3dirCUhM7j1VCRp4eK+i/UfjH8QLFTFItWZJfpANOh7D4nWOP9fQk0CQtueLrTWWOE/WbpZOR+n5PD5m/hsAf0+VfQBD9roW+c9E9CMAfh3Dg2C9jdd1G6SQCwtHJznJSU5yiMIM3LKrxVY1yy0YUk2/johuB+B6Inq5q1v6INOb3TMp2LW9M/K75U5ykpOc5CQXRDrPUz3k891fmfiBMUQ2dJdLA0ezPUlrepFm6lje11K74n6inEH9y0TBbRzZtbxDsjzzq4zsU6f6Nr1Hho3xV5w4u1zwHs35tSX8whOc9YPrfcPTo161J6mWuc4KqcuFvUnPUKPXaM4eo+ZQuprHaGEWujneopb9RGt6i6J+OoUruMQBPhXqx4jorcg8e8fJlAeZ/jSGB/XdhYieCeDrAXx/l4FfVmnJSuc9SgWVrMeJ0J7Cu6EsOw7LY7TwXEoaPqeeaxS8Q9qbxKKeI30yy0bvkfksI9ldB6+R9hgB4/4iK8TOHw9/Y49Rrt7LWWWRc0bjBLYVYXRAPpTOe5FCuF3BgyTne5mkwQqxS7xHAHYEDNse/fWm3qMo9M15j8AUvEZjcgY/FlcaeXPiBQS7Uu0lyoa46XPfOOP9qZ0vbtNRDin8m5m/ZJ/9HTcc6RvohHVNl/1JpbVti/2WsVd0tLc1aafXpBpmcn0kwKLaGfVNIXYKlvLtyoCUs5Ecq2vyoGOCCUkAAsgnZciIFfM7S0rhd76utNfITLLQCYwWhtJdFCjq+fyjibHczc+PIKJ7AngwgFcD+GIsfJApM/8yEV2PIeyBAPxjZn5r68BP4mRYWef3EzkphdiNoWM5WMmk+C6l8NZlERShCYq0HkOdJ5CThyQzpM4au7Yf6jheEyTAJOs5zU4HxGAkAKmUgGEuGEkoAhCV+/Ph764KRBKE0qx1+XtXgCARRjfYG8BpK0AoB0oWJMmx5ELsSoAEABtmcLCZAhIrCAoLAlJ7jwZiQvhBQoCS3GNUWjNNCa1rBhoLsjgcmjqpzU5rEEMObW8sEd0VwP8B4DOY+StdFMQXMnN2j+gSOW440jIBXiI14/1vAqZGMJsMSjl7hf66QJKlPwGSmrxI0h7F7ULbUJ4HJE50x5tGsrfILQaiOUKAUBjOCjeYWeI9RJZnxtpr5M9DeSMYzdlj1Ogtmg1FnfYVHRoQaeH2Saf1+RG3BfBiAN/JzB8losUPMiWiLwDwZmb+WXd+OyL6fGZ+devgT9IgBU8SVx8Ga89fZvmE/UbRGCgtT6BoybnVX6ksQJS4vyvg0kBk7TUCJASNbXRmumDWAKMRfuaDke1FGoFIlgMpEI3ANN6vWtN4b4T3yO8BGo5HaNqBcEZbE5RASCAJFHuK4F5y/Z6WAGmoJ5y5EguQiMZFQZyhLs5Ml+w9UvWCdqKFQPrsIxrvlBbYuHMr0iana567Mkywsda+ownz1D7kuQB+CcD3ufP/D8ALUUigs0QuFhxpmQlLQDqxVO81PUGpxV4OejImcva6QpJVp+Ap0VfjSkPo2gFJj0OH1/n67iAkk0C0qGtvUC28rpTFTtvpDEZN3qKJIXRLky3M9RK1hMytCURxP/0mHSK6EgMY/TIz/zoAdHqQ6c8D+Bxx/gmj7CRzpJaMgVCGIv98o6S8LblCS5kVUpfz5sTjzp9ryEmhRp9zdD7ZawQBPqIu9hYN9TIJg0zAAPc3l7K7BxhJKALyYXU5IJIwdDbDcwQMsLV1L4rMWrdxehqUgBiSgF2AJ5m1bnzDkJTlAAkQEAQ2Q+pC2KMHJE6TM0TgFCZ/N5gIrKzxcfgQ1bxH5jqpAYqCrj9Xa7MEeAxostZzvaTnPNVB7sTM17mEQmDmW4hotZTeFxuOtHSCpUmgVOinCygV6vR3MGmT+VIlv2BYxiog5Os0DGXD7JTOHEAyjzHeZHLeI9E14r1FGEPrFsBUBEO5eUruQyp5jax9RrnjGhi1htF1CqFbK3TuWIDIy/AW95l03LOIngPgrcz846K8x4NMiXl885l5R0SXa87oLa37jbL1NhTlwuCsj1lrCm+r71KfrHSr4JMbp2hrea0iaCKlE9XFQBStNBNAivcZUSjzcBTryWcZ9QQjnbkOSKFIA5GHoTU8Rx6Ywl4jX0eIIAksw+p2oWwuIPlysHvYLMUhdWNf4yQ/zPPjwkE/HFa4kuQfmIsKBLNFEPLFZghdCYIqusziZcqsZ8b264TW9ZynOskniOjvwV2pi2z4yFqdHf9EZyz0J7f10mhjDa9Ss83S9Wb6sVinZMv0Js34gpswJMqjMm9rKiABNiz5ctC4uKcRkKReiyS2WmXJujuCpcI+I+n5McCoCEW+nSif6i2aDEUre4l6hsttO6d3H0Q+y2OxfDGAbwTwJiJ6vSt7BoDHdXiQ6TuJ6KkYvEUA8K0A3tlr4JdJaim7q/uNcmF3mTqrPBuuJkVBTTXELXeesZeAT05XQo7Rj+k1MuyQtiMAaDge6+19RoOq6SWC2HNUAaMrPPg0eIt8md5HJPU0EAVQUq/ZpuFet4MAIffCWZ6j0bO0MyFJhtV5zAl7jlzq7jEpA+EW8YHXgDSMHWHPkXxQ7NZ5jUr7j8rhdX6MRnKGBN7GRUxunSELE29PzG9FgErWJEk/5XPLWbdMus5TPeS7MPy491lE9F8A3BlDkqBV5PjhyIv1qZi6rplpYxIsNYCStmnaq9nJgY/RPAtVrZDEGX19Y1DlWf0pgASlC6McRnhduB5345Peosr70gxVuYW1DquzvEa1cDppB5gORjs1aWowOlAomuslagWidWAolV6x3Mz8R7DvXL9VaNP6INMnY8hY9/0YvhqvBPCkGcM8SU4W7jdK2mRhxgIlOcnYoFTtU0FJcp6zn4OrnJ4FTZbuFK+R05MQpMPpPHTEXqR4n1EomwlG2lvkwcgKnTuzPEfBqzTdczS0EyDkXgcNTOFZRwVISoHIZ66zvUhXYJcFJH8uIcgDks5g52EpF17nQ/BqyRmSX2zNtYukIxT0xrXELK+SLtNrsNJ5RzmkPUfucRX/CMD9MFz125j5ZkuXiL6uweTf+Wf/WXJx4MgS/b7O+QDNsDErXK5gfxEo5cAnNwxDvwpJxk0i6Iu65vL0/iTUK4BkHIfLcWVV75HOWpfUo/o5MB/6amWjq0kunK4HGKmxzAajGVA0JXTuogCRF8bBhSuYwszvw/BMpJN0lpaHv2alsN8otWPZ1mNJ61mBk9abHFKXaZcdB3G2PxPiDLiKvUasoAgCiGCE2KkwO+E1shIw9ACjKVCkgWgMsYvveS2Q5O9FZ+76t9gkwLSDgyJm8fDWTYAk+D1JwfuUepGsyVRn1guA5N6jwXMkQupYhu/592Y8lqF0cF6hED7HiJMzYKAU03sEMVa5LsFYF8PPaCC/rhB1JbBS3SZtkY51jdC6Q5uniOgpGPbVvtmd34GIHsfMP2eoPxvAS5C92wAAHobCj4gXG460NMLIJBuV9r1D8LqAkvEltJrnoCfqeyYk5bxL0RjETSl2aZPT4yZAGpr5G6IzLQAJRn0kxr6jcDNqlQwsAch7jXLhdHqvUJSQwU8S7WC0LyjqtZdoKRBNgaFVnnvE+Y/aSS64VPYclZ4rFOqTNkjbTEjhndgq1OuyqSF1ZjsNPpk2w7m4b0n4iY7ZtK3D5rzXyOtJr5H0Cg1tRxgCjAQMBhiZ/xrAyNfJxAqhTECRBqIoKYORhEGCiNxoH6AoPNtoGwGTh6UhycJGhN8NUHRGjK33EikvUg2QtPfIawKA9/jILHbMiPYfsYClsE9HeIkGGBptjd4jMY4wJmNxwqO9BIS8DWMto21HwKTWPLo7ZHRbzruyzOHNU9/sM6cCADN/iIi+GYAFR7/NzE8oGSOi/1CqP3o4avbS5GQpMC2ApZ6gZNrLtS/Y1d/t6MT4ErZCkv6ym+CEsS7xIhnl8teSotfI35wg0ndnXs8cTCXXURKhYz7s1Sor2uMUjHxmulYwmvPcohWh6FCBaG8PgS3+oHWcQkQfrakAuJGZ77uP8RyU1ELkSvWVBA5arAVSCj0xPFlQYnuU4nNdnzsuQlKuXNdZugqySl6jodwD0qinkzAAccru0KXwGul9Rr5NMfnCRDDKeYokFI2hdU5X3L8sQAp16nzLm3GfESgCJglG8ngY2zaFoomAtImyD4zCrtyD0daFy/nwOg88gN+f5Bs6v5FbLOS9R/6NHRck0b4dvZZpgJ9qCF2uXLQxdXM2jfOecmDz1IaIQpIgIjoDcCtLkZn/ec1YTefo4UiKNSnsHZgmwNKk8TbYLYKX9QUs2DVZyoCqVkiqhdRFdRqEVLdTACn6xQZAFDInstdZQGSF5kGm7d4AmJBI0gQlIIUf6TWyste1glHGW8SZ/UaWt6gEPlOhqGdyhRoQnbt3qCCMg9vo2kvewcwPLikQ0Z/sazDHItnsdLkHuwI2vLjy2DYSgKp5h/R4av2wPm8BHmucoQ3b5QU9nXShfpx6jQCk+4/csQ6n8/XZzHQTwegKByYSjOSeohIUeSCSMKTTd+v03gBC2m6vHzLUQXiRaOsWyCkkbUBhb1ICRRMAaUOcABMA7IijJA1REgaOw+uifUbKS5T3Ho3UJOEpiICmBKBMyLF1IhEgVfwR2etKblRwFq1tCAhbDjrJAc5TLwNwHRH9AobLfzKA36k1IqIvAnBPCN5h5ufX2l0oOLJkNWBaAZaAdLxNsDQFlCrtTC+R0dT6Ykd9TYQkb0OWy3uO9CJFXbQCEtTNJCMWVA3zAQHbiR+cXeaYubz/yNpn5NtJL1CwJcCoEkbXI4SuBxTN2UfUA4imgtB2JXA6sHCFSIjou0r1MmW4kn/aYL5F53JILRlDRqY83yjtU9uqtDHOW709zd4iEuWUlo/nI8ywoReH2XFkq7jXyJtRXiN/DKMueItgeI8awejKzdb0FklP0dCHr/d1o5coHPsHw4r7Ven5RkP7UYZsdAOgDam7d6EczqtkQRJ4hzHUjrHhAZh8mN0GG9zsezMAaQcawwE9CLk3d4CfYQ+S17PC62T2OpmcgcP7VvEeRQuG8dHw1g+5FMYpFiNqrWPCjwEzs71ImbqofSc5sHnqezEkBPpXGK70dwH8X6UGRPTvAXwWgNdj/CmbAZzgyJIuwGR9CFtsLIClvYKSUWc27QxJSTkjhiZdHtrZgOTHEDePvUcAxgQN0nukHyKrx2NJzjNUOi5lqEs8SgJuWsDI8hYVPEXD4bRyoD10bt8eokOBIS2HlAXIkNvNacTM7wQAIvq3zPy9ss6XeZ3LLEsf/mq2SfpIdZbuNyp7cfJtZ4XU5exafSQgJOslFI3gNMVrBHgIcscCkOZ6jGpglNtT5D1FEoqs5xy1QtL4PKPt+ABYVe69SmfudfCQBN65PUkchdppz9GVQBaQdEIG7xGSMmTLG8FIhtdtoT1G8nih94gyx1JKkDOzPNQhr5sDrd5ySPMUD2Exv+D+tcpDAdxfPq+vVY4fjipg0Cq5z8AkaJoIPmabQrsmr1IPUNJtjV8zNPssgSRLJ+tFUmOUMcLiqQapt6gASIC7l2/HsWu4mvzZUtnjopA6y2tUCqebCkY1b1HG89MDilqBaO4eot7eoX3BkJTh7TucSUcLM//QQhNfhuFXPilfaZRdPqklYzDb5OvskDeq6hRBiBoApQQ2ubaZy2sKqaMxe13sIbLb9vIayT1Hum7MKjfCkH2ehtK1gJEFRYALpVNQZANSfS+mh6wh6cIg2osEdx7C8LwniWgIv3Peo/B3sNIESJtok4/Pjhffk2V4neUlWuQ9CgsViPleE8lII1FiBhNcOHxwS6F1zQBWqs+BVic59HmqUf4UwKcDuLGmqOX44UhK7n3sDE3NH8IJ4FNsNxeWKnaa9ijJdkZZwlBKpwWSIhsWEAmqsfYixQA0pvpOAKkmoQ0BzA6S5LHqn4dFSzXOV4fU+b/WQ1lzYCTbW2DUGkY3IdnCEijaJxC1wtBUEFpzL9IhpUjVQkQ/Xapn5qdm2v0rDA+KvTcRvVFU3Q7Af+k3wiOUSpa61ZIx1J5vpNrM2m9klZNxbuiZx6SOM31Y9pNEDF51ptfIA0mShAFTwumM5AsNYKT3FdWgyMpaB5QhaQsrQ90ulEdg5I7D/qSwabcNkM5A0HuO9H6jcO7eHw9LO/cmxwA0w3vkrjEcE9zcOEzsPq236872zkSLCrXQyOmq45I3yRfJNVb4qCtAKnmfesghz1MlIaL/hOHVuB2AtxDRawDc5OuZ+WtrNi4WHOWkMzR1BaaVYGmqV6kIWhNBKfoiu4rZ4Xasbhi6n/iHnTIgJX8H75G3Fe71HsLEmIgxpPTeMqKkDIZ4WDK9Q7lyCUuW+BA5p5dNvLBHKFriJdpHuNwhwZCWA4vl1nL9zHa/AuC3AfyfAJ4myj/GzB9cPKoLKKUQu+y6hNK6xGNjta+AThFELJst8NOiJ65naUidro+fXySqG71GMpTOtzOz0wkQAmB4iXRWujoY6b1FHoZKUCRBSGers1J5e/0tb6LnHPn7fgAlBUljJqN2QBqz0g36A/hk9h8h9SLJ7HVzvEfMCoAIwwogQFL82RnXJmJBkFtXqXXIohA7TNSN6vrCzIHPUyX50aUGVoMjIvpFAF8N4H3M/EBX9iMAvgbAJwG8A8A3MfOHieieAN4K4G2u+auY+clrje0kJznJSc5LGITdYWUBioSZnyfPieg2zPyJhnYfAfARIvp+AP+NmW8ioocD+Gwiej4zf3idEc+X0zx1kpOc5CSpHMo8JbxAplheIGb+fdfW3P8K4Pdr/a7pOXougJ9BnBXi5QCezsy3uAE+HWMc+juY+UErjieVjh6l2d6kOWNo8CRNCrmrtDe9SIWyFg9SsGtdv+EtSkLqpHdHDWmobvceDW3F/iNCHE5nNQTQ9CBYtfco/LCn03PX9hrN9RqV0nOXnlck6nqF0C3xFvX0FO07dbcl5z+CuhDRFwJ4DoDbArgHEf0PAL6Fmb+10vTFAB5KRP/AtX8pBq/SV6053pnyXJzXPDUjzC6XqS5tr9oZa5w4nK7cXpc1hckV9GxPESf1pr4Ii0vaNniSZPicVaZD6ny5zlAHIPYWSU+SCJ0b6uJnGZW8Rj5Zg066IDPSeY+RTNow5VlH8jlH2ygbHQBG5EXaYIsdRg/SkL0oDrHbgLEj79axvUc7isPsxv1GO+z4LAkHlM8/2nmvkPAw1ULrxrxKabidHSaH+MbsXUCRzlhW3Xc01WNkeaZadXNerYVyIPPUEi/Q7P2vq8ERM/+B+6VNlv2uOH0VgK9f3FEDKCy2OdP23sLvlsJSBlCstklYnNRVZUkXGqL8fcdq720oSDI93wqyxvscOV0uAtKg42BIh9Yx4O+0UfIHww0eyQ7h7kwCdORxBE5zwUiAUC2Ubm0omgJE+wybmwtDU56VNEkYx7LR9ScBfDkGuAEzv4GIHtbQbufA4usA/CQz/7tDfb7R3uYpLaXEDNaPtaXsdrp9y0erFWgse4W2k/RaAEveZCugFb+kI0DJ/UaD3rjo1g95BexU3r5egxAwhtCFcsTHIwCJrHUNYJTC0AhF3r6GouhZR1GIXXov27oXbkM77LAJwDRmpBuga8ubADzD/qcNdmAzxO7KzdYEpB3713IApK0PoXMTsTyWqbx1uJ3PXNcSTuffwxSGxvooax2GST38YCrXAED8o6wGIVGf1ZViwZk/hjgvtNO2uydlOJB5ynuBpojY//pZc/e/nueeoycAeKE4v5ebQD8K4PuZ+Q+tRkT0JAy5znHF7e9gKBR6XPrB6QBNXT1MpS9QRW/u/qTJoMRGsYYobTMDSYnXyJ1HtkUZhbbj7iILkKI+4BYn7ICJ3K6k3K9EQswf6XbGcZJyW/ytgZHOSlfyFhWy0JWeVVTaV3SeQLQmDK0GQjnZc3dzhZnfQ/Gqs+WxxzcT0eMA/AsM4WkAcGXvse1JFs9TV115+7hyYhrvJZnqgt1au4xu6Vx/hCftR6rVW32XdIyyGHziv1FTGiFIeo2iVN6NXqPxeGccj0kYAFTBSCdekN6iHBRtsItAqJSMQXqHzrANsAQaPUtbBz9nznMU9iP5iTJ4g0ZAGqAm3n+kvUYyOYPce6T3GcnzyHsUwVDsPWIeHxDrnU8M/3kQWes8M5PhTXKvg/Erar5MHSdRJ7l6baNSl+17DTmAeYqI3gR7JASAmfmzjbrF+1/PBY6I6PsA3ALgl13RjQDuwcwfIKKHAPiPRPQAZv6obsvM1wK4FgCuvubu0966DnCzht3cZFWFpgYIatGrAtsSUNIgpM1mQMmCpNyPK/I8171P820BkjcS0nubEOYOag+DZYx33VDGY1kEPwJitEcpB0a5MLpGb9GcZAstYXNTgaiXZ2jyc4wOZIfpIfwi1yDvcU8XZyK6FYCnYthzU5NvwvD08mcy87uI6F4A/sOK41xFes1Tn3r1NeFDlwed3CTQPl7rI5V6fShbX8tU1wpVTZDU2C4dP6fHlnepBEs0HsehdXGZlcrb/y15jeLU3fkkDDoBg5V4AUjD6DwY5aBo9CwJz5GVPCdkqnPPMaI8KG0DCEFAD0xAks9B8robcjDEm8ETBA6gJMPrZGrvAEbc7j2SHqPgHRJ//fs7ObQu8hBx+sHMQU+tvtRO1qGwzNT2OkrPeYqIPg3DQ1sfiOGSnoBh/+YLAdwTwJ8DeAwzf0g1/eqpfTHzR4joYwD+e2b+iznj3TscEdHjMVzsl/oHMzHzTXBp9pj5eiJ6B4D7AnjtfgZVqZ+7nloBmorAZPWX4+2KTnXPkWq7BJRCsaCcuZBUrrMBySsM58OdRnuPohsYQcASYHGBD5+TzzeiJGxOeXtawCgXRjcDipaGzdnZ6vIf0B6eoUnPMFoAQuXdUcuEAex2RwFHTwbwUwDuBuAGDE8kf0qtETO/BQNI+fN3AXjWSmNcRbrPU6VU3p3SeNd0mvYVtdSp+kkeI2scQDTJhHo12VXhKeinEBSF1Hl1ATVeEg+SAVG+PNlrhAw0wfAeEUdgdEa7akY6C4w8FGkg8udWOJ2XM+cE3jKFrHQSlIDhnryVIRUNgLQxMtiND6XdYeO9Riq8zgNQFFYH23sE8Te8X4wATb79VoIRAWN2utHGCABuRSBDRCDgwwCZVfYdYWIbVddLVpinfgrA7zDz17sf224N4BkAXsnMzyKip2Hw8kT7gSTcENHfB3AfZn4FEV2NAsMw846I3kBE92Dmd08d7F7hiIi+AsOF/yNm/htRfmcAH2TmLRHdG8B9ALyzbnAGQMyR0udjTl8L7C0GphZYUnrN+5VaQMk4T35kmQNJ4l7k6yw2swDJGwnn3g6N5/6f+Vq33D/8HiTp4dHHLWCU8xbVoKhxL1FPICqBzKGA0JoQlBVGZoV4WMLM7wfwDVPbEdF9MIQz3B/AVcLevfuNbj1ZY57qKTUPjKkzpX5K26nHlp0GXVNHzjOWLVWXC6kb/lrPNoqhSe4l8noSkIa/aRIGX6/D6UK5eCis3l8EDKBzJW1NKPL1ci9S6DOc5+9yQzIGuD1H2wiUAEQg5PcmbTDA2CdxhQlIu8iTtMGW3VhoCJs7c16jHfuxyoQMznvk3iTLe7RjCvui5DOQNohD6/z7K0ProjKvF1WOx9ETO3y5pRt5lUS9k8n7jgp6xXC73tJxniKi2wN4GIB/CQDM/EkAnySiRwF4uFN7HoDfQyZZAhF9M4ZQ5TsC+CwAnwngFwB8aaHrawC82T3nKGRcPdfnHBHRCzBc9J2I6AYAP4Ah68+nAHi5i2P3qVAfBuDfENEtGGLan7zkuRi197MrPO0DnGYAEzBhId+i1wJLLaBkEYvqR97EdPfRLziUmrHuZbo7DUjAcC/HzkORq/X3d+8lEqF1zJx/6z0ICSAyvUZy/1AjGOW8RVOhqOQlmgtE+4KhOSB0LhBUkAOJ7isKET0PwHf4FNxEdAcAP8bMT6g0/SUM9/ufAPAlGMLsDpIGz3OeAjDrGUdV3YmvdGm+7Gq7BkFTIKkSSidD6KJzcaz/ymPtMfKSwpABSIbXKBdOl4TH5RIvZLxFGoo0EOlwOplswesNoXS7CJTkc4422ODM2G90K7rFBKRNmJiH8x0TdHjdls8G+Mt4j4DUYxTAyHmEIjASXqI5oXWRB0n/wqrv1bWyEkjl2mtpBJ+1YWnCPHUnIpIe9Gswji5TAAAgAElEQVRdaLGXewP4awC/5LKeXg/gOwDclZlvHPriG4noLoU+ngLg8wC82un/WUUfAH6o+QqUrJmt7nFG8XMyui/GkP51L9IKw4shqhc45ezMgKbZwNQIS9nYVzb0LJvixhSZEiAUmXdtdHm4N/mbny4XgCT7YMBB0XDX8eF1kfdIXHeydhB3kxBSJ71GzMB2Ox4DaVkJjHIhdA1QtIaHKAc0NRhaC4R6QNDUh8fOkiOAIwCfLZ9NxMwfIqIHN7S7mplfSUTkQiJ+kIj+EAN4HJSc5zyV32eUlmd1rTTeuq0GsFYYqpmWP171aFdrb01eKmxOttchdVZdS0gdkCZi0H8Tr5LyGvm/sbfHHYtwOitN963oliIYeSjSQOTHpD1HSRpvDGm8xwe+jh+rXQREgA6nO8MuKduBEfYfeY8Q77DD2Xj9zp1jeY/8FOb3JWkwkqF1/nX1iRmGsZdD6/S9t1Q3KPBIIY37jrzU4KVUn60rQFD3gIT2eer9zPzQQv0VAD4HwLcz86uJ6KcQJ0pokZuY+ZM+QRARXVEbITP/PhHdFcDnuqLXMPP7Wjo7z2x1By+reqBqH+IW2zOgqRswZWCp1avUBFReXc5tOUhCWm79kOPHOIROj88pGqHIHUsQItexG2jYdwQg+6wjAT6R10j/9boSjDwo5bxFDVDUklyhBkS9YGgNEFoCQXuBn6LQsSRk2BDRHfwGWSK6I9rmjL8jog2APyOibwPwlwBqv/BdLsklZlj4zMWu4XRaJNTkyjP2ahDElOrljmHoJiOz5jkPP+Fc1g1/dUhd8uwd4RGKzinOUOd1dIic9xrlwun0/iJvpwWMzrBLgOhMvFMytffOuSzPaIstKCRd2GCbDauzAGnnf1F0ZTtsgkdI7j+SkLTF4DWyvEdj5jo3Ys6E0vGY1EF6jKzQuvAe++FTvO8oFrFSEPXWvqPQQkJMoSxbL2xG2wjyI2uGpWXSdZ66AcANzPxqd/4iDHD0XiK6xnmNrgFQApffJ6JnALiaiL4MQ6ru/1TqlIgeA+BHMITrEYB/R0Tfw8wvqg34+OGo9N6tvAY6F3haAZqaw/JyJFKoM2GpAEqmjlT3c5+cIJ2+HK8HHOetj71IjNEj5N3sO44BaeMM7HgIffF9CEgKP1UpIekt0l4j7xGSe4YcDPF22+Qt4kI4Xc1LJEFliXdoCQztA4LOH4AqcuDDc/JjAP4rEb0Iw4gfA+CZDe2+E8Nm26cC+GEMoXWPX2uQRyctyRSktD7jaKLdSeF0S6QKScaXITd5mtBTr9MPfo11bCBqCakDYlAa4STVTbLJGeF0QVd6giaA0Zm0U9hz5McwAJHbc+RAKcSY+9e0AEgb+YsiDQkdPBht+WzoW6T3LnmPhqk2DvtLgEiF1un3R4fW6QfCju85yvuOMJxbbb1uFYqCx2m0XYOmRFYDn0bp1Dcz/zcieg8R3Y+Z34Zhn9Bb3L/HY0jY83gALymYeRqAJwJ4E4BvAfBbGLLfleT7AHyu9xa5faOvwABnRTl+OCrJlBv8Ch/AVeBpCQx2gKZozCXvUgMs5SAo6kLqiOOsN8mApAiMYjNjXxtKACnyGLljdse0oRFYQmcCgtx55DXaboGt2Fe03Qa9KhhNhKIlQDQFhs4bhHpCUClDe1dhgI8gWx0zP9/FkT8Cwzfg61wmulq7/wcAhqg6/qaVh3lcUvIMLX3GUU2n9ODZYp22k6mrQVDJpmpfLJPlBQ9REl5n6KRAlOmuEFI3/B29RjIzXfRXhdL5Op2VTu5F8qLByCdoyEGR9hxpDxgwhKuNniP3sFcJSRieHzR6kuT+IgC0GeaTAEM+zA4DGLnwui1vcFbxHu2iv36sMtQuH1onQ+y85EGJU2+IXxtYdYaeWRaF3KV6JhSVoClXlymfDF0t0n+e+nYAv+wy1b0Tw17UDYDriOiJAN4N4NGF9lcD+EVmfjYAENGZK/ubQpuNCqP7AMp34SAXG46myDmAVMsEN/lXhmxnfdpNBqYCLGVtUaRWHWbiTXLK8sYhwSgcsNDZYQi0ZozeoqhnHuo2ALGAJIIZWkeRt4hjKNrtxj1GwAhG3oOkoGgYXwpIQB6KSkC0Fgy1gNB5AdDewKdZ+kw6RHR3AM8H8OkYXt5rmfmnXAic+fwIIno6hl/gtgCeyswvy9l3MFQFIjWmL8Swb+e2AO7hNuB+CzN/67Sru0Sy8OMw2dNT0l/Ja9RcXwUi48tcgCWt0wJE2itkleU8SPJYZqgbzuNnGg3t/X6jXWQreoaR8hhZYDR6keJx5R4E659rtAELUBohaXhxfBjFDqBboAFp62PP1f6jHWLvkbX3yGeu8889kqF18jWvhdb5c7nvSL+X1r6jZhgqQdGcsin15y79bgbM/HoA1r6kUrY5Ka8E8EgAH3fnV2N4vMQXFdr8DhG9DMAL3Pk/w+BxqsoJjuZI6+elw4e+G0D1BKcpwJRrnym3ftSxujWbt0ISp/c82gzth7nAeYUI8b+zEYzIl2mRYXQ7iBC63QBIAozYe458ec5bpKBIAtEOtpcoDqubB0NLQGgqBC0FoLXhp3u2u37jvQXAdzPz64jodgCuJ6KXY0iZmjw/gojuD+CxAB4A4DMAvIKI7svM224jAn4SwJcDeCkAMPMbiOhhHe0fpZS8M6ZkIaFlUoh1ivPIhLps4oXccWt/c9ZghYmv9HyjnJT2G7WE1HmxQurk35zXCEAUTjeGxTGSULoCGMn9SlXPEZznyIHSMDHuxP1JxpnvsFUAdBY8QRsXQgfshFfIe4/03qMdI/krQ+sAROF10ftEada61n1HiSjPUhZWQoicsUgx7Rp2poJStEAZj+ckapgthwVuVzGzByMw88eJ6NalBsz8PUT0TwF8MYZX6Fpm/o2Wzo4ajhjTfjHr7nasdjhBd8HYFofv1cZpfckrepOAqVAeheHJKnEjIKngwMfTDwldDUnhn9MPcwALY6J3Yg7JGJgA2jhQ0tfhAIl2Aoa850iC0dYtuXc7kYShDYqA1EuUAyINOVO9Qr1AaAkArQU/3aGnVTpdj0uD6lOhfoyI3orhoa2550c8CsCvugeavouI3o4hPeof9xlRGNd7KF6g94SvCyWToUnLxOazQWmiZEGqNI4sEOqbvVHX8KUKDiblRartN2qVUkidtN/iNdJ7lOQeoxoY+eOhffwXgAMi562B99Z48AF8trmhyQhIHoBAQ447f+zD67bwnhqIsLrYe+Sfe1QKrfOvldyHpL1KJcntOwrOoKLXSCxISjBk1RmAUgupO2g5rDF+gog+h5lfBwBE9BAAf1trNDfL6FHD0VRZssl0dbBaEaRWg6eJ0NQSRleSXHctoOSBxoQkxH+9Z0nfwZgJOHM3VQZ4x0OChs2oQ36f0daBjociAUkBhJzniHfOq1SAIu0lmgJEU7xCJRBqAYm5ANQTfs4NeFpl2q86tedHBCGiewJ4MIbnQOSeH3E3AK8SzW5wZT3lPUT0RQDYxZc/FcBbO/dxXDLZa2Trz9trNK3rJjuU0ZvhNbKuadaeJdWH9fDXqaIfBGv/TbPUAXZInVVf8hr5+hGQxj1JGoyupG0CRWMf8XUNQPT/s/fm0fJsVZ3nd0f+fo/HrDSIjI1SIK0UIuKI7QKnVgtwBKHEspAWS3GBZTmAXYoTJVIlDmXrEkdUBgGLBiyZZIksbBFBZNbVCsh6giCI8BTee/dm7P7jDLHPPvucOBEZkTfv/eVe777MOHNG5i9OfOK7zz6uTHCN68DYMOMG2gg+CCqSA5+wpqhP1hd1HnYcPFlrj3rfZ2hjzLUOCCG8p607sgI1jJkZlMGwCDmtANRomRKE+jiqtuDDjcnqw/r2XQCeS0Tv8ce3g3OTKxoRfS2An4SLlkr+j5n5FmOdXVFwtIvN/Y2sAlWtY2nse7brXq1eKroUy9Qeyox9TquLEihxUIniP4/0M4UHZEFNioqTcGIObbAI2JCNP2z6GlSjfgucbh0InW69YqTc6mL47gGOAEQoOikAUSsMmW50O0DQVABaCnzOAnq2i842g02IUzG2fwQAgIhuBvd07LuY+SNUviO0MpLRENG1Oi0pPD6x/AcAPwsHXdfA+YU/ZqTOlWm7qkY72j7ufXbpY/TBXpSCxtsqbf5a2t9oznqjKS51QO72JtcaybVC2p3OldWK0fDq3iPtQ5yLHmHNEUUoCpB0FW8dIAGDisTAhgjavc4pRE4FCpHpNkmeByMjMEPNtS6ci6mKETBM2WNBGZrc7oBquRoULaEYtbjQrRKMIfS/UrtzjJn/jIjuAeBT4M7AXzLzyUi1pwB4EDNPfjh3hKOjHe1oR9u3LRgFiIguw4HRM5j5f/jk0v4R1wC4k6h+RwDvEcdg5pv7dn8UwN8D+C24yegbAdx8bDzM/AFftjTeJzDzT7R8tqMd7WhHO9oZ2YFFVfUw9JYJVd43B4yAIxytbmfqyregq95kdalFVaqUaRKq1NMT01VYpUVXO1WfWKhLvu6wPYSr7FwDCMwM7skpSMRxzUCMUBfc5E5P3atSjeJ6IxGJLihHcl3RCfdNatGYUmTvXTRurQrRrsrQ2orQWurPLrbUkz5yEtGvAng7Mz9VZL0Q9v4RLwTwTCJ6KlxAhrsBeG2h+f+DmT9HHP8iEf0p3NO4XewhAK4gOFrv97dklLpFVaSF3OsmtQnhBndA/+Rr640AJC5zoXwIwmDlB7VIrzPSqpFzu4Ovk47Jbfoa1Bmk8ggBmxDkx69Bcu5wjBBUwSlAnXeRywMzbEVeWFe083mktoh1u1iyFqmm8lTyWhWjNRWfpezQx9dgryOi3wHw/wC4PiSKh4hFO/9wtMZF8EB+EHt15VsApJrXNo31VXCpGwUmC5bCdU7BUoQhDOUpdNKLuuHPN96HwswOnjrZKYO27i8BpNMt+PRUgNF2ACIAcl2RdKHTQGTB0C4gtCb8rAU8hwg6ky1A+DJ2PwDfBODNRPQXPu0H4KAo2z+Cmd9KRM+BC899CuAxlUh1WyL6RgDP9iN+OJYJrHABvsT1bFKggpFy3LSjxw79yb7G3KDNz2X8QxibwCaMrbTnkRW9zbJqxLrMxc4OxtBiGQA1uNSFvkMABguMNgRs/Ie33erC00JOAGmYV5yL3MYHX9hiE9cOpUEVxn9oU4IyAEjd75BuDruzBdf6sSh1hXqL21rt7mLLzlNnZbeA2wfpy0QaA7gC4GgNO+fAtbpaNXPNU7P6VCpXePqiFx9ZixslLGWqEhQsbRAhKUSnIwJo655SOYGI0G+AruPhBqSHg6LTrYOik5MIRnxyEoMx1FQiCURjMJSH6M6tBYCmwM9S0HOIkKP39F3PrMVq84yZX43yvxhz/whmfhKAJzU0/2/h1g79LNy/iD/2abva+Z9yl7C54LJv08BVyVuz38n5LV2EdUb+U02FpzFrDcZg1k0AKVWNZBvpmqMcjNx7Um2H+SNMiEAApC2Lzy9Uo/Q1qEScrTvqeRODLsiQ3lZQhqlmBWZoCeed7XU01VrgxYxel6e1KEbFtUa7jG+yLTdP7TQKovvU8kP0ukLeI0faLrp4H+FoX7bWb2zhfxCLqlVT2zKuLU1NCggCRBvi4iKhKzKFHLN8ShLeS/XJ//UiQAP1QH9K6IJbXd+DTnsHRSceiE5OPRydRih68XvegC33uD4+pesTdciCodSdLrcSBLWCzy7Qc1agsz+YWcHOwdiZ+V1wob+XtrOfcY+2n29hn32cwa9qLFJdzaxgDMAAVMU+QzhvyvczkmB0GYQNETp/YjbiBG3B6IjQg12wVQFIci7oQSK6nHelq7jWBZVHh/QuzS+liHUHY2cGJrYlz4730e9hzFM/5V+vhttE9o1wn/5ecJFZv2CHtosu3ucfjuS/o8P4IvdrBwJdsx7G6D4a2siUIlXfXPekoUspRjHJQ1GcK3h48EM+Qh11AIiGsOCnwnVly8DJqQOi668HX3c9cHqK/uQUL/27N3iFaIvruTeVoTEQsgCoBj9TgWfNSelcg8wadsDxxono+5j5KUT032H8a2Pmx+7YxXN3rH+0c2yz3AbnuNKtYNq1bkodvdbILIu8TEwrTHxSNXL9OBAKYOTUIw9IRNgyowMNXgjkr88xctwwr2hlJrrCzXCt0xHrxmxQh9Jw3qubfri6dl+HPDcewDzFzA8AACJ6NoBHM/Ob/fE9AXzPjs0Xf1DnH46kHdADh2Y71H8Ye3AtnH2dq8jSJgQZSncsottR6hGzAyJmD0fsYKjzkEQ9sLnBK0enp8B114M/+jHwx65Df8MNeOnfvQEnfIqP8TYC0Rb+1YAgDUAW/IyH2t79yzvvMHNQTx+1MQ7CXaFiIbrP66qlCkZETwHw43Ab9L0EwKfDhRj/bQBg5v+yxCCveNOb14zYmWz+epamQnY3VzPqzXGza6mj1xqNljNc6pI+1WsAIwdKnR+XD/Djq/Zebdr6elvR7hZkuNRxceGh3u+oZmE90VTTrnVL2WSXu5EHtdb9zrkKcHB489Q9AhgBADO/hYjuvWObxW/kYsHRebSD+u012tx/4GtNwLULlE6que5pNzv/GlQlYrj1qRu49UaXAO4I3bbDjT4E0D9/DPyRa9F/9KN40btfi1Ns8ZG+xwmCUuQsAJAGH9tdru2knQXMHDSAHLgd8iTJzC8iog2AezLz985o4suY+fuI6GvgQoc/BMAfAvjtJcd5Ie2M9z06eNvhH070vqPwmkLQUuuMWtppCdYw5l5XBib3AaVa1KHzkNT5jcSdK0TvVaQtGJv4OgQ/CO+tNUJ63VFpjP3I4rq5kBSMqpN6SwM71r/AdmDz1NuJ6Ffg5hEG8Ajsvrn4FaIcHW0/dmjXkZbxBPe5xrFHNzvZjQAmYh+M7mpge1WHm17D2F7zHjznb/8Y1/EW7+/dhDEA0dDxlKddRwC5oHZYk05mzLwlos+cWf2yf/1KAM9i5n+sbEp7tKMdTdhmxDegpjKFkN0hAEMnQGlDDpGcqtHHrSm2YGyI0DNjQ+s8aGsJ571vSJodnOFKssOapx4J4NsBPM4fvwrAL+7YZtHFexSOiOg74TYX/NCUHono1wA8EMD7mfmePu1WAH4HwF0AvAvAQ0O7RPQEAI+CU3Ufy8wvHe/kCPxHa7TS72TC7ydRmcm51/EG+OiNe9zqq/8R33Lnd+LPrr8ZrqYTXEXbwddcRh2aeLVZ6mnm0Y42w95ARC+Em0D+JSQ27BHxIiL6Szi3uu8gotsAuG69YTqbM1ftZZ462tEOwLoRBedoRztkY+brAPy0/2uyXVy8W/61fCKAPyOi5xDRl1P7I8DfAPDlKu3xAF7BzHcD8Ap/DCL6VAAPA/Bpvs4veLeOo10Eo8P7487/kfrrxN/G/fWXgP4ysL0K6K8CtlczTm/COL1Zj9NbbkG3vh5b7vCn134y3nb9HfCuk1vj704/Dv+wvRn+aXtj/FN/Y1zbX41/6a/Cv/Dl+HcdX0r+bsAm+zvhrumvZzqIv6O1GXHb3xnbrQB8EMAXAXiQ/3vgWCVmfjyAzwNwX7+j+UexTtQ7bXPmqt/AcZ462gHZduS2rLaWp+Te1oNxwqc+MqrcXDwNArTrht4l6xv2Qdp1/piqAh1Vo3E7hHnK78sHInozEb1J/41U/zJm/gjcvHUNgLsDaHIVH1WOmPk/E9EPwm2i9EgAP+8H+6vM/DeVeq8ioruo5K8CcH///ukAXgng+336s5n5egDvJKK/BvDZAP6k5UNc8XaF/xuftbO6SpOKUHZMfi+jqBax+7uKQTfa4qobnQIAPnDDzXCj7hQnV21w8+463KS7Hld3XkVCj6voFB0PkYukitT5BbLaZcLa+M5Sk/QC2THXjFabqnSdV0Daq0LHAPrDP09je0SUjIhuAuAxAO4M4NEAbg/gUwD83nKjy23OXHVw8xTzcd1RzXZY1c7wHmX+Dct9b0JI6QWuAy3tuJDY9f2Ut/5aWoq7sUWHDbYxaEJalwHy8MOA37Ecvd/vWW8f4dobgjAMfVDsa2ycpTGO2b6hKG/g+O/NtMOZp4Ib3eiDOcNmu3g3rTliZiaivwfw93C7qn88gOcR0cuZ+fsmDPS2zPxe3+Z7iegTfPodALxGlLvGp2VGRI+Gm3Bx6ZYfP6HrHe0gfiMX3yZdp2plS/Cj8pP0CETs0oPKRAA6gMOGrxsGX+5Bl3tsrtri8iU34Vy3vYyPnF6Ny7TFyaUNTniD6/kEN/JudtfR5QhKG/8HhBCtbt+IE79hXrCtsRGgnIxK8OI24Js30UuwWmPN01Tg2oftHeoO7xRkRkQ/ZyR/GMDrmPkFlaq/DuD1AD7fH18D55q3KhwBi81Vi85TV1++xfQPsoKNBqNZ6J/Awaxv99ATIKi5mqgXQCxER5tiLZC0RYcOW2y5Q1eBpVgO5CPKURbae+tDpG39l7mBiH4aAcmXFZFTgWFtrLVGdgAk/ZqDTwi+MBapDph/zQ31lr5mT4as2ldr5B2AJ8B0O4Ax+2vwBu4h15dMrD7bxbtlzdFjAXwzgA8A+BUA38vMJ0TUAfj/AEyBo2I3Rpr5tTDz0wA8DQCuvsOd+Agth2c7X7Na6hfKlCAoyxMglORJICIA3QBKvGEHRhsGXWZ0l3psLvXYbNyUctp3+Nj2Kvxz55QkXAJO+BJu6C7hajrBZTrFCV3CZTrFhvs4cYZN/U78zuIynHdYWLsBR9eELoGXUC5XiracP1GsWZj8W572aZuiVK0ZZOIQwcuyczJRXg3gHhgWrX4dgLcCeBQRPYCZv6tQ767M/A1E9HAAYOaPTXDHnm17mKtmzVO3vMnt1/m2ex5W4J8jmwVPE+BtKgxNMRlCuhWWHCRhFIAABxcbbONmq0OafX0NkLR1UpjvBwCFzV3lOORDt0E12rKDpOBSJ4MiaBAJ8BM8GuJxEwy1g5NVb28PsPZ5bT7weeBQ5ikfIOijRHRLZv7whHqPJ6KfBPCR0AYaXbxblKNbA/haZv5b1WlPRFNlrvcR0e08Cd4OwPt9+jUA7iTK3RHAeya2fbQVbLHr0dR2KuVbNhE0QQiwYci/SrVIqkfcsVudF8Bow6BN7+Co6+Mkedp3uKHf4GPbq9ARo9sy+q7DFoSeCJdpg8u0xZbcE8UNDxv+BVgKSpFzu/Ob34l9JTbkNt0DUhDouUugKdgWLXtoDE9HW8x265u/2HcpF0A3jnUm0MWh60AmnRH7VwC+iJlPAYCIfhHAywB8KYA3V+rdQEQ3hv+URHRXANevPFZgubnqypinFlSLdu5jibHs4/Mo6z3wOFhy0DB2JQwudUEFCvDUB7XHH2f1fH6Apd7vTr7xLnSbAEnelW7jfQi3YPQiep1eZ3SCIbKqVofc+xRqsteYH4ApBaqWa/IWaV1Z/0yt5Tq9x2t5ckb20e9hzVPXAXgzEb0caYCg4qbku7h4t6w5+qFK3tQY4y+Ee7L3ZP/6ApH+TCJ6Ktzg7wbgtRPbPlrFVrvOzGm3oc6UDQtratEoDMk6Goq8coTOvSZgtGH313F8StmDcNpvcH1/CZf6bepS0blJxDnVETpmXCanMG3QOR9w9HGPih5dAkqu3ABLQA4+W2zsm/ixC1zLnhsJiM2HKMvmgtWSUDVmi0PXYU06JbsDgJvCudLBv7+9fwJXg50nwkUGuhMRPQPA/QD8+zUHCiw6V+1nnuoBnIdwDuG3SsMLy7y15paxtuMiot3H0Pt1O9KVbheL7m8emoJbXASgBogK18WNd7uLG6tSjy68RtUI2BKJNWuMG7yStPGqkmtTXMf9sQSjnsNryZWu7FJnjT2qRQp+NFBNtUzR8q+sAC2IZTp/ss39SRj9tfy8kjJnCWiHNU/9T/83xWa7eK+2zxERPQtuUeutiegauAnzyQCeQ0SPAvBuuM0Bwcxv9Qtn3wbnJ/4YZq7rz1ew7eWByi59tLo/jJUz8qsgBCRXFQuIYnqWx7G8C74goMi/0obda8cgrxhtuj7CSs+EU+7cX7/BCW3RiX9iPXX+j3CZtvECHkApQBKACEob4qgKxZ3HfXsallw9SymyJ7KgNJXcHFLwqn9ZFpRNffI31af/PECVZQcSia7FngLgL4jolXD/Ur4QwH8hopsC+INSJWZ+ORH9OYDP9fUex8wf2MN4J9shzlOm25kClKIpUKAeGNlepqmdFhtzl7M/lwEjY4Ayx8XO1wnHYT0QF9qS7nMAEle6+Opd2oZ0pwgNalKDG12AHq8GOde73sOUWGNKnb/e9bZ65Ncj+Q8dAQnexc4aRXSjQwpG4Q9w19iaS12AG60u1T+zao/t17RsCkE7W1iKFSf9afXsvB3GdoDzwdLzFBG9C8C1cLcpp8x839q2CdqY+ekzup3t4r0aHDHzwwtZX1wo/yQAT1prPIdmZ6IYL9XnhHZmRZKr1W2BIVmOVJ5QiKw63LFfa+TKJGBEHoyiatSDiGNwqRDO+rTf4KTr0PWXnHsd+0dzYt7YosNlP2WFm3WnHpHfcXxQk1yZFJRCGwGW5A2/BiZLGXI7n5cnss5P1CXTADYHnrQtrUiVbBcXwMXsMKIAVY2Zf5WIfh8uIhsB+AFmDm5kxXCofvL5CgCfzMw/SkR3JqLPZuaD8wbYzzy13p3P5PU7FbBYNJBCq+ozpf8GKNIwdAjWB9UoWXvUC/e6NCiDXHcEwLvMldWjQTXC8Jk9IG0xrDXqkjE5i4qOAKOeSSg/Hpa4i69A6lLXs4MkHYwhU48mrjU6C0uUpSoIlbPM6clIOxcPyJafpx6gHpSFbROeTESP98ffb1UkojcjP5MfBvA6AD/OzB80qs128V4Njo52tKMd7Wi2nYuJEYCP2laLTGfZL8Ddf30RgB+Fe1r4uwA+a9nRHe1oRzva0dayPcxTpW0TLHsxnOr0TH/8MLjHAR+G26/uQUad2S7eRzhawM583eDS/U9srzmZw9IAACAASURBVOnzT1WISvXGlCLx3nSrK6xB4pDn9zOKUeqkarRxylFYZ0SEbEsSqR5tiHHa+2d0ziMiPr7r5MJT4Y/dedc650a3wSZEKiLnBrEJ6eE8+JegIomRiDEpJQkorjOKwRlmuuIBhch5DT+q1qAH+1KYVrUDHtoC9jnMfB8iegMAMPOHiOiqsx7UQdoZ72u0j7Dbu/QRL3OF+tKDbKqrXcnFLhyHdUiAcLPLXOlkIAb2a4yGNtPXIWJdLSgDgncADdFJ5dol6VoXQ3TzBqBtch7cfDH8vizXOqkYhc+p1xw5L4bBpc6tm7Vd6krBGLR6VFozJNcg6bZKLnb6uLTOKH81TohhtXK1KaZVQapZce0RF8osbe1t35qIXieOn+YjdurWXkZukfYv+fzStgmW3Y+Z7yeO30xEf8zM9yOiR5jD38HF+whHws4ccrStMZ5d3GJb6y4FQkD2L38WEPl2Mhc6AUvR3c671QX3OuqEO5147dQfMIBRD7f26BITTrhDxz1OveP/hp1bxOUQ7htib4jgR+4haUM9wCkk9fA+6RVQss+lAhYDbpyLnv0F1aBJR8mbCk6x3gKuedLWXvM02w58zRERfRIzv3OHJk78vhTBleE2yH6AV5hNhaBC+RbQyMrMdDGrtiPeJ+UWcqebtX5Jd+VP4fC6W4jvbM2RWGtkRaxrDcog1x2BkbjWwec717rBXbBjRtjYVQLS1kdB7THMS2FtUbp/HiXvo/ucX2MU1xx5MBpc67rMpQ5I9zeKgYcagzHofHnd1mG8SwEYmPO6rRbhZ+SnQZVyu1zPJwdfqNmS88q0eeoDzHzfkTL3Y+b3eAB6ud9/aIrdjIg+h5n/FACI6LMB3MznnVoVdnHxvpBwdHCQI23tse3Y/qRzNzY5TQUhoA5Duh4Z5aZAEanyNIARyaAMHpKog1ONonJkXzkcJHVRPQprjrqux0m/weVui5P+0uAETluAL3nNiOqQFPzp5WfksAapAErqXIW2MysAk2s7L9+qMkkb8zvfBZ7kmObYXkPHHjAcAXgegM8kolcws7n2ZsR+DsDzAXwCET0JwNcD+M9LDvAiGTGDd1GPJsJPFSwWXKszBk3FwBNW/yFIg5UfAziQa6DyGWIp/0aqSEhUJHcc16A03iWWgjLU1h25qHMdwH0W0tv13UX1CORgyM0JnQFI8IpT79cBCUhSJyWPSDeA0VZAz6AeDSqSVI22TEXVqKgYzQjGMMVKKhGrfNusGwurE2sONVpbQEE6M1twnGG9KjO/n4ieD7eWtbRtgmX/J4BfI6IARNfC7bl3UwA/Uagz28X73MPRwYDQvsaxT/iZ0OcSIFRsqxWIwvtCsIWYJsFIQpQHohSM2KtHAIUADIB3qcsBqfdP4YKCtA0udh3jJISN6jEAEgB0cJMYyM/cfZwEQSEiXQ5JW07VJPcB/SsNk0wWXMH4Pixgcm4iKcyMRbBLQn5PgKbYZkPkvJotrT6tZY0f56ysI6InArg7EX23zmTmp9YqM/MziOj1cEENCMBXz9j24cIZMWPSruVFUGhQoVSZ2UCk8orAMwWqTMCZUD/WCVBkZAWVSEDOmGqkw3nLjV6LqpFys0vaa3Ctc2BkqEfg5OHXBl0yNwT3uhIg9dj48fSJq9qwF9JgMiKddqNLwEi405UCMVghvKe61JVgqFRvLIx31VTdsXLNN1BzgEjnFxSlRZWmEVtqnvIA0zHztf79l8HBSmnbhMyY+c8A/GsiuiUAYuZ/EtnPKVSb7eJ97uFodds3fC3U32xo3BWEam0Yk5PZVgWOTLc6ATilMiYUEWf5GRiRdKdz9YJbXen+JIBRUJB6YpxwB/TAZsM4cXMWLnfObcKpSKcAdzhBiG6UqkjwTwq3ApLc5/MwodSk4HaXlIEdhS5OyuE4Rs8bh6VQP9gYMAFlaArjs2yuq17Wzsrq0wWxhwH4arj54eZTKhJRB+BNzHxPAFPdJq5c21GxWTJq3c7q0RRomgJKUfYxoEgIR2OfqzWcNzBcAzeohfDO1x2BMOpaByNqnVSPgpLfCWgKgNQFWDIAKW7nwGF1EoR6JD6b+MFYUAQgAaMtKzCKsJSqRluvNkkoCvPhFJc6edy63sj8DjUABRVpTPmpTQOt8DMViHaxw562bgvg+T6K9iUAz2TmlxDRn8HYNqFmzPzhsTLCZrt4X5lwtG/gWanfNQFoUh8TYMhscwSQTCCS7y0o8vkRikJ5BUYs2kjACAKKukElkn+AA4a4CaxXjECDa13PfjEtOmyJcdJ3uNz5zfj8P9HBze50mOg4fVKYTnoNkCTPD4trARmQIepoUALqsATk4NIS5rsEIEuqTdZYWmzxDV8tO+CJjJn/CsBPEtGbmPnFE+v2RPRGIrozM797pSGeX5u48WtJbZq39qisONVc+6KnrgE8JSVp1pqhEiihkF6AodLeRlaZsaAMsrxUk2rrjoCyax04KPRaPaJ4ze+ia2C47nbKm0CfF+ddsAVjQxTXJsk972qbrZaUopiPDid8KQMjqfSU1hpZqlGLS12aTuarBTdjwRhMq8GSyK/Cj6zb6lpXy29QivaybnWhPpj5HQA+3Uj/IArbJixks128LxYcnRX0rNj/Tm6DS0PQWJutMFRqpwREMi+BoxEoCmUIaX0JRp1rg0Q6MLjShfJRNQplkS7gDy4T4X147TGoR2Fi2DID2AxjEm52PfW4DCSA5HYw924bYtKsQpL7GPk5E6AUJv8ESNRXuAQshXakjQV+0NYSCMKyXdY4rWa83MRGRL8G4IEA3u/VGhDRDwP4VgD/4Iv9ADP/vs97AoBHwd07PZaZX1pp/v8loqfCbf4KAH8E4EcbntzdDsBbiei1AP4lJDLzg6d8tgtrJUgp7kgKG6iyG6oy/FhWA5jJSlTNxqDJVIKMNNVWTAofu5JXC8owtu4oWItrXYAbK2odgKp6NLjY0QBCEC52BiD1viV3HQsPzhAhKQCGda2U19R0nZFUeAxXOgzudE5NClBEsa0x1ajmUpcEZNBKkXoN359Mq0Wly9Ygjag9tXzr55mCjP1Qw+pnV1sFlBacp3YxInoIMz93TqCgXVy8zz8c7ROIVuprkUloDRAaa3cKDFltWfcHVMiXsFPqh0T6mFrk35NsVwISBbUoV40AiNd0CIlyROnao6Aeod8A3RYxnDd1Q/ShOJlRXIe0UZNjWGskIUmrRBviAWrCJCtAZ6N80UMdOWFqF7whOEPuggeUYQkYV5diuZVVpqy/hVWnZltu0vkNAD8P4DdV+k8z83+TCUT0qXAuc58G4PYA/oCI7s7MVpRfAPg1AG8B8FB//E0Afh3A146M6UeaR3+lWikanY/KPNdytaghn4z3lknIkU3PVZKMfFmu9D7UswHOj6yiKEW2EGWiYoR83RGAfO0Rcte6QQ3Ko9ahoB5BgBG4Q69BCP4aa3gSWMdbUT78o3YPuOwflbz+aShyaXUwimuRRBlXzj8UlNClVCNZJuSHvPR4ACd5LN+3rDeKIk90r6M8s/CENt52NKpCYxDUrAbJvEL6ql4IBwBHAJ4A4LlwgRTu01ppVxfv8w9HS9nKkLXYU7iJ7SyiCMUy5X8pc9Qhs17peC4UxfcFMErKh/TgUufSUtVoiP5TjFYnPsSgGg3qEQjomNBHV7geJ2HyEoA0qEdqcgSSJ4tpHcQ2h/NTcbnzpmFpDiiFdqzz4Noow5JuV9oUYHL97g5NwMo7ui/nrvAqIrpLY/GvAvBsZr4ewDuJ6K/hIgb9SaH8XZn568TxjxDRXzSM6Y8ax3NFWzFAgwFOxEElz57GIErWpX4mAFcJbkxrgKJJ9Yz8NJ3yOUgSVfT/c/V1UAYrT7rP1VzrzD2PJBgRFCy5gAmdD5xgqUdhfVG4zoR9j/S1fouyq3U43mIT16omkASg91++vP7qa7OlFMm8IhhxCkZhz6SeuwSKxlQjDURhjDWXurH9jXT5+P0rq+W5dAumrH+3edJcSKrmVeaOxZWew4CjDxLRHwL4JCJ6oc4seSTs6uJ95cDRyvADLAhAwKzxLqYIxTITYajU7lwgUmOoQlEomwBRmm6CkSpP0g2P8nVGg5JkfE5hMmKdVo8AF2HuJK45QvY0sQpIQPJkUbvayXPTSegRTyKlf3dHeUCGUMdyvSsFdQCmwZJrK/2NraEwDf1PDwSxhhEwJQpQy+Z6ln0nEf07AK8D8J+Y+UMA7gDgNaLMNT6tZB8joi9g5lcDABHdD8DHxjomomuRT6sfFmN5R8P4j2aZAQ5VNaihjUnudWNt1+qPqVQtKlYEghx4am1Kdzq93kjnZa51/oO4G3LkYJSkhWAKGFWPtMdAV7zWh5OZA5KDlN7XTSEpegnEa3NuqXKUb+waoMiVzcHohDcJGGl3Ouly14fXgmpUUoZqUepKLnXyvbXuqBqcYQxExtIslWklpWctNz1g8jy1pv0bOMXotwD81MS6s128Lw4c7QF+gp2VCjR7DDuC0GifSwCRTguTVaVcAkUhPYGdIb0IRrF9jmCUQRDt/vOSa4/A3r0uTiQMUIcTBi5jixogbXmTutkByFQkoAmSoomvvuZ6VwIl9xlyVQkou+DJ8yJtDJZ0+0nZGcA0jGMZtanJeNITvpbN9bT9IoAfcz3hx+AmlG9B+XazZP8BwG/60KkA8CG4cKtj9lQA7wHwTN/nwwB8IoC/gnPVu39DGxfHame4sJ5oErC0lBkDohqYxGuLUbdUrwV0WvqulRFpet1RCjxI1h0lTRjltWsdMLhL66h1DoIMxchQj4LHgDuJw75Hlntd5g0gru9hawf3iG1QkeKWDnJPPOSBDrRZKpE8tqBIu9JFtQipO53c10hGqCupRuY+RwY4yXnDcqkr7W+UpI1ADFvpZloBrLwVr/U1sCnkrQlDmU2bp9YbBvMNAF5DRJ/PzP9ARDd3yfzPDdV/ZG6/5x+OVoKiRVUgYH8g1NrX0jBUSK9CkQk+M6FIvwpVqA5GKVgNypFL1+uMOn/cEaPD4GIHuAtyphiRu+AHX3S9UBcQT8qoc1Hs2IdlNQDJwQuhqiKF8kAVkkL/EobiAt6KmiTrzgUl2a60MVjS7es+srI7AJMbz0qudStOOsz8vvCeiH4ZwO/5w2sA3EkUvSMcxJTaeSOATyeiW/jjjzQO4cuZ+XPE8dOI6DV+h/IfaGzjYlktWEItQENrHVM1SctMUoEmAE0JlsbS0/wBRGK6VIes8RfSIk0kQOXashQk6U7XI3etA3wAU7LXIuWwlKtHUTXywOTaJA827nofr3XJBq8YrvWMbGuH8JBMbhAeIGnrm7MeSgWT1+QhylzqVjcVjEKQhqEMRXc6GZmupBol7zl/L5WgqS51er1RGqFO32D4VAOMrNunFFzyfzwlsJnjWpf1v9Z8cgBwJOy2RPQyALcCQET0DwC+mZnfUqqwi4v3+YejmbY4/ATbsd1Z41oAhkb7XQqI9LEaVw2KkvySWhTySJUtgVGYsEkqR0hUoyHfGBvSqHWWhQt7eJqYqEeABxjhly4mTFNByt4DUkXaeLe3DYmNXWtKEtIADjW3u00EoOmg5MrqqHVlNzzX5nRYsvpJ+7S/yL3ub7RiV2HHcX/4NXBBFQC34d4zfQS62wO4G4DXjrU3AYqC9UT0UADP88dfL5ub2NbFMWZ/j2vdOBVCaY9BStJGAzxUgEmPQdetKlZTYamxXrxEaogywMcTVQSJqAj5NBnim5G71gHIotbFK0vJlc5DUApLuXoUQYsAy70O3KMnql/rw3W+cYNwIGzuPaIciXy5qas7HiCmFYxkdDrbnW5wM+9Fefk+WA2WAA1Iw+sUl7rkfQYdBjCJ96Pg1Jqv03UeyraqunNYV+unAfhuZv5DACCi+/u0zy9V2MXF+8LD0aFCELAiCAFN/2JWBSJdLgMkobhU/+WrMmNqkX/fCkak2pNBGqJiJN9XIEmbBUVyk8BBMYKDJe9eJydME5CA+GQxhmulADUervxHBBAhKdnEVXwGrSZpEKqpSUA7KLmy7bA0xw2vtR+zzo4q0xRbakIjomfBuandmoiuAfBEAPcnonvD/QLeBeDbAICZ30pEzwHwNgCnAB5TiVS3i30jgJ8F8At+DK8B8AgiujGA71yhv/NltdDcxrVl0l5HDeG8WyFn7DgwyFg7c6DI7FvXNWBI5k91rYN434P8eiCXHkNyg9zuD4Z6BMADDgCEh2Du/UaqRpS611nrj1xeeq231hsFFUlCUs/i4ZT/oW2MC46OVhr3OhJAFI7TUN11MDrpNwkYaXe6RD2KsNNl4FNSjaxADDpKnVuPNHzPwawQ3sWADBYwWT/4Vtip5auy1fmhNp6Fp6tDcKsTdtMARgDAzK8kopuO1Jnt4n0h4Gg1AAp2ViA0pe8lYKjW3xwgMo93hKKQl8GRAiNxXAWjCEUhnxPVKNnwVbp4jKlFHkbk++EpmJwsXQkZzWgMkFLXunI475KrXQJJ4hyWIAnIXe4AG2S0y577dDYoufK2C55uX/YhbS4slfrM6i3xj9+yhSYdZn64kfyrlfJPAvCkZXov9vEOAA8qZL96zb7PjVVc6ainPLpc+JnqdON3ZLrPVceC5DptKUbAOMBUocvqq+m9bLzeb3pKPTHptoJapNSkoBLJ9xKAQnAGGZABAKy1R6Ahcl0Yxja+d4DUh3VIQLzOmxFL5XEM9+1WHG1QgiTxgCtsJFv5Dehw3jJtCMyQqkUuLQcjHYBButNJdSimC6VoimpkBWKoBWUoutTF8yLriFNvgAjx8L643mgmUO0CX6uAzGHB0TuI6AfhAjMAwCMAvHOkzmwX75Uc6vdkhOXAiCp/E40p/5vdf7E8p38NY2nqs5Rfa8+qnx0P46yeE18vKaNd6CwwEvWmgJF2pwMQ3eqSLiREqTRtlt+zXki6DRNDOMYwgQTXhtRnWy5yNaIDxfpdMqG5vOGJYBiDfjLo0sVO6X4csQxku8MYrHxZ33o6Kf+kxQ0FuTNhJvRhrV0a2qfkb8zG+lzF/APilr+zNCK6CRH9oF+3BCK6GxE9sKHe3YnoFUT0Fn98LyJq2pX8ijJzh8l6Hlnp1p2vvnHSv6WxG6u5T72n3PRl7ZCdLo7L/YobX/XEX94El6KZsciP6gPSsvIaLm/OtcIx/KXKSLzmy8AF6np/whuc9JsBNLjDSX/Jpfu/QbFx0eLCPHEDX4oR5ML1L9ZR17lQLpSV5W7gS/E6G8ak1aI4Hjm2fhPHo8EoDdSQB2HIz11+frVqFL6rUiAGazPYUZe6BHYM8Cn8Rs3fMY//bmvq0aSyK4HRgc1T3wLgNgD+h/+7NYBHjtTpieihRNT5v4eKvOpZO99wdLSjHe1o59G48e9s7dcBXA/g8/zxNQB+vKHeL8Nt3HcCAMz8Jjh3hqMd7WhHO9p5sQOap5j5Q8z8WGa+j//7Lr9FRc2+EW7z8vcDeJ9/3+TivXe3OiL6FAC/I5I+GcAPAfg4AN8K4B98+g8w8+8vP4Blm1vdXS6pM/4rHB3PzPxdXeiKbRj1TMXIfE3zo2okFKBUNSpbKEuJ6uTVI/U6FoAhmFzAG9Ydhah1wbXOlRt80cNiXWlhw0DpXrfRoV8B6DVI7qTYLnZJsAYgtuHSvfvcSNCGYextrnahjeQcrehy59pPv/iS253VZ6nvJezAfLlLdldm/gYiejgAMPPHiJpW3N2EmV+rip6uMsKVbF/zFDGDe5oWzlu6ismySNNN97oJ+cV+KM+vpodx+Uux925L0sfaST+/0Zgu79+nLnSI644AH4jBt2e51sWodZBR7HLXOkCuNUpd7fTaIys4g3avA3VAP8wzGyM4g5sNKG7rsOUQfGGDjtKADIC9x1GwNGJd6m2gPRPke3sj2JJqpIIwCBWt6D4HpSb54zGXOvk+Cj6JYjj8RqpKUnhvlYEq422uUmTNB81lk7xlJ5ZzMk8VbRcX773DETP/FYB7AwARbQD8HYDnw8ljP83M/22RjhaGIGAHEALODobG+q7kNQGRlbYUFMkyFTBK6llgNPQwQI94TYYkoMgdTwOiksl1R6GtYd8hJFCk1x6F8gGqLEAaoGhYgxQCKIRADZ2HmxDNLpgVsEFDkhxvDZLcuUpBSYKLdrNbYm2S7CuWaYQl19d0YNrZzsekc4N/wuZuJ4nuCqckjdkHfNlQ7+sBvLde5bBs8Xkq3LQsFM7b3W/neTnwpGWyeoIxXH49Yl2oA3npstIVrBWhx7/PYMl6X6grP4OLoRCAaWhgiFTnbpitqHWhIRnBrvd9hX2P/CMq9OQCMySgRGKtkR+zXnsUAEnufVQEpPBgS605dX3mkGSF8O4VdWuoC2aF9HbpORQBmA5Gwa0wASPK3ytQCq86fPckl7rAzjzcLJRCeI+tN0rei7YTBWWsXqVtMtrQtzDSRt3ydrXzMU8VjYjuDrfv322Z+Z5EdC8AD2bmUQ+Isw7I8MUA/oaZ/7btgWTBrhAQCraWOlRtOwMgq8x0KMrKaLVIvjcgqAmMCCiBEYn6GopilhhLeB9uqHVghlwtogRu5B4Ywat1I6GoMlkOSkwdkJKADfK8KRVJtieVpDmQJNtrUZOClVSlVlAKY9Q2FvVO2lR1aWeTE+lh2xMBvATAnYjoGQDuB+DfN9R7DFyI1XsQ0d/BLZp9xFqD3IMtM08BZQhCDiZDHRSv2Ta8GECkHwJlECX6UMCUAYpR3oSgSrniWIQSpNMJLFQnQVRGXQlOAYAQilNgVVs9knsehasIg4djAUNhU9hg+loSAvAMIAQMalIDIAEIXgNb6EA/CpLkJuEYrqGduD4GcIrjU9dSGWxBpllQ5Mq1gZFWidKodfk6I5kezmOLUlRSjZIodQkshULiJMgfcFKGTGWodd3cUKbhfUt+aQxL2fmZp2r2ywC+F8AvAQAzv4mInokG9/CzhqOHAXiWOP5OIvp3GGKQZ/6ERPRoAI8GgEsf9/E7g9FOEBQHNafOgjDUMoZCfrVtE4CstB2hKFt9W3pNwWknMFJ9hwh1Wk2yVKSplgKSf3Io2tKRjMaeJka3CcvFDq5uAKQUmHIVKVp42jgTkoBcKaqpScEsVWmK652rt4yqNPS3LiyFn+ihGzO/nIj+HMDnwg37ccz8gYZ67wDwJT7MasfM16481LVtp3nq6su3SPMqrnT+Th36QhvcZcx6xm/JghTqkUbBU91MdcOrqkEYjme54tXATI9PqD4SgJI3CSTV1SOWnfu3MrR3cL8Lqk3UdxJ3Ol9PhPaWgNR8zQecqxzYX7fcdT5EpQOQgdEwnnCdtn5oqWkY0ul6vyMJRW4MdTA66TcZGJVUIw1HrF4B7K4axe9IlsE0cFHpO7nS6VsgrpddXTHC4c1TM1Wg2S7eZwZHRHQVgAfDLdwF3If+Mbiv+scA/BRcdIrEmPlpcE8lcfUd7zTpqzszEAIm/8rWBKJq+63prUBk1E+gptRHCxipNNL/mgUYWeMpPQQOqlEJjFohKXnKJwAp5IWLWtfwXesNAzUgBctVI60oDYA01Mnd7ZaEJPf586eYpbJz1yi5unVQkn1KqwFTS9S7qXZIk442IrqPSgoucXcmojsz858X6n13IR0AwMxPXWyQe7Il5qlb3vh29rddU5E0yMg8S2HqGdiotJyxJgORdRx5ROW3utJV00N9DUUhwxeSTASZFcvT8I9Mg1uYQ8TpZ1/HWnsEIFGMAsLIfY96SHfoYVyWSx0IOO036IlxudtmgNQz0FOPjsR1VW4Wy25dURK6O6r/ORTV9mrTWxVIGIppBhSFz2ZBUczjDifcGSA0DkahDStC3SqqUehXqENDnnubAEtWf3hPY+kQ6Sinj5a1yi88rxzYPDVHBZrt4n2WytFXAPhzZn4fAIRXAPChY39vl8YXASFgLzA0aaxnCUTAMlCk26lBkSxLyMHKAiMK6QpoSL668kOwhSEvGT6l641a1h7lrnThCZ+7oGoY0gEZrCeJG9GeBUgSYLRqlOyFJM7ZoPCkSlKApLhHhoC8OZCU9lWHJFlWtinbjedtAiiFMZdsihveInZYk462n/KvVwO4L4A3wv1q7gXgTwF8QaHezf3rpwD4LAAv9McPAvCqVUa6vq06T4HZ3zsbF1JmEKgYlCGBFORwMqSlEDauEOXrjoByHckoWfs1+BFlUuAawEb3XQYgSUecDoqQB2bwNBXSS2uPQiM9CEROPdLBGUC5e13oPwemVEE66TfoqMfGK1MOiji59rv6Hprg5xMBSVv467EAJUDscYRxs2BIpltQ5PLLapG9xqgORtKVjkU6JwoSRHr4njBDNUL5PZD+4MX7XV3qmiAplIVdNu8biwdjsPo8Y5ujAs128T5LOHo4hKsCEd2OmQPRfQ2At7Q2dKaKUKw/7VfUPOaWcksCUSlvbSiSxwUAmgVGCRC1f0dy89chLS0zNWrdcCwmSNTdtno5SVI3gAimAVLJzQ5AoiS1qEjANEiK44XtchfGWyob03cAJTnmoY02ZWkVWDqsSScxZn4AABDRswE8mpnf7I/vCeB7KvV+xJd7GYD7BHc6IvphAM9dedhr2TLzVA+g4/wi0pJfUZisvAx+rDQzUAPKwGKlKcCBql+GnyGvCaRq7ct00U8WmIEH4JEbwIaGSpHr4vmhIUBDxyo4A1L3uqGSgCMxRmsNUvnhGISSxBkkxSh1CpRcvUF6tOYYrYgngCTGPQZFrsxyYGSqRwKA5D5TnOWPq0YuIXwhgAzEoN3ZtPpTSqdC/SoIVcGsfFztY2k7rHlqsgq0i4v3mcAREd0EwJcC+DaR/BQiujfcB3+XyivabDA6VBgC1gOiUr1q+YWgSLaVwFKhfgMYkVVWtZ2pQaGeh59kc1df3jxFE7/vHIgG+LDKliZI6RKx1aqRACRgUHimABKADJIsFQkoQ9LwhHI6JA3nwFg8PCOQgxyHDvCz6AAAIABJREFUHItlLS54ehyLmH56eLh2jwBGAMDMb/HX6DG7M4AbxPENAO6y8NhWtyXnqWgjUeuInYqRXYTiJY4zlSmChOonU52MJ88JgIQ0XccaSwFiNOw0Q5FvYxyKKP7jcWVVpYnqEQPFtUdBIfKnEzogwwBGSKLXSctccicAUrzWCiUpzisekjrI8N0DKMV63mqhvAEbhmS6hiKXl6pF4fNOAiPjL4bqRmm90aAahTEG1Yh9fk01SsJ3S/CJ6SLfH6fwI29yUH5vwJMuNwo6lbrW8aLzyuHNU80q0BIu3mcCR8z8UQD/i0r7plU7Pe8wNFJuMhBV0/PPOgWKsvJTXOhk+dlgNIBObFK507VYcKmzwGhu0CoZqU7vZ5SUM9zrBghSUOThygrJ7QZrRLJDaNeZtR6pFZJyNw4bklwZD1UF8LGCONTKy/Y1JMmxyPFY1gpKi9lhTTolezsR/QqA34Yb8SMAvL2h3m8BeC0RPd/X+xoAT19tlCvZmvNUNSiD6wjFC3QPUDdv3VFcojgCRC4yXHqTKEFH15EcMgpFskJpHDxEp9P1qgAn+h5TjxwYBV5N1SMAApSGjrR7nYQlEDJAkvsf5SfLBiT3AGtwZQ5lhkh08iHWxq19EqAEIMKStMRd2Xjgkyg2Ij9cXzUUhTStFsX0BjA6DXkSgpK26+50rN6H38D4WqPh5qJJNdImwCEBphpQTIAkMUKzbg5VXB7rLnZA89REFWhnF++zjla3ju0KQsAsZN43EI32OQWKCp93VSjK3nOWNheMZPs23IjodKIcxbzy998avSxOmIXyNX90XUe61+n1RwPQ5IBkRbIDkEBSzdUu7smENJS4XI8UzskYJLm6OciMgVJLEAfZtm4/tqduCHZ1v9vF9sFfC9gjAXw7gMf541fBBSSoGjM/iYhegmFt0iOZ+Q3rDPGcW0VJciDD5ScxBj8V1SCk7WRpGmgK7WsQAUaODWjReRqYsnJZHxQrxbLxn7ukJxbXVigwSiPXAayUKAJ7AAIQrxzava4HgYSKpAHptO9wqeubAKlnQhevuYPbdc8bdMzuOiggqWd3bdSg5OrAj1tcTwskrq+L8joqgQiACUWhjoagUK+oGKk0VnXlZq+t7nTZ+iOlGsWTL+EigZscZhMQkfkZoIhKGTyV2kvzknSd1nq8oB3CPDVHBVrCxftiwNGuMDRTO1wFhhrKrq0SjfZhtJeVn6IWGWUtKALawWjMnW6OlVSkMau51BXrgGC51w1A5dYfTQGkslud7WrXqiKF8VrrkVxeGZJcuRyUpkCSLl9rPz3H01WlpezA3BVMY+brAPy0/xs1IvpzZr6Pr/t6AK+vlbmSbEwpquVHkAEyULLAJ6Zb4DSWpuAkcdmzYKZ0XIGicGy50KWwQ8M/FGtcsZ4AIVXWUo+yfY98fjE4AxBd7KR7XWn9USsghWtmAKIAPwGaIuDE9G4AIoQ1RzkouTrhodZ4GO84ngSKhHIkgCjkaSgK+TW1KJTRapEGoxSKUjCSqlEekMGBy6Ag0WiEuqJqJMoEI1E3BaGhXVN9gp1Xgqli2six+Rl2tKXnKb+h9usA/B0zP5CIbgXgdwDcBc5N+aHG1gi7qECzXbzPPxzNAaMdvvGzUIdG+50FSzOhSLU5GYrkez2GOWA0jGRopuROJ7uiFKC0aiRd6uTapF3MVooAy7VC39CH8NxDmFZaBJAAI7pdTBvUopqKBIwHbXCfMoek+FnQDklhfOn5sdUk2b7uQ1orKC1iK0xiaxgRvRPGSJn5kwtV/jcielOtSQC3XGJs59ZG1hzF6HUVtWjXdUfWfkcJwPi0qmoU+pTHEGMwoCgWGmtL5Ak2Uh0MdJUClcwT0BT79wcM+LODoChFVFLudWEEcv8jCUjEMjBDGZA6Yg9D7GFIzGPi2h+hKQ56gCLnQuei0pVACRDKUcOj/9JGsC6PkjJjUBTKtqpFFhjptUUWGLl8DK514ZtRZSIsyd+GhhetGpWAQ6tKAk7GwCfvs1IW+a3NKAStMZ+sM089Ds41O2z+9ngAr2DmJxPR4/3x9yfD2E0Fmu3iff7hqMX2BUPA/oCo1sYaQGS0m9QrgE7yvlTegq1WMCJAXlG0m1w6pvmq0VmYVI9Km8j2SCPYTQWk0Garmx2Qq0hA2dUu5AE5JLkybS53LQEcZHmrjuwjltnB/W4nOx8/w/uK91cDeAiAW1XK36OhzbG14VeG1UJ4A/73YRGKt8q6I+oMIEIOP2NpVnAIS+3BhONWF7oB9tKK6fhkXdGg+ixRPRKglIIRYAVnkB3kEewGQGIJSygD0nASxWdVaXEPo8StLqjyAyRtvZJlgRIglKOGDWCDlZQjCUQyL4BLfM9yU9j5YKTd6TQYyXI6CIN0p4uRrTUgeSAyVSMNQxBlYJW3YGt4P6b8lFSmYppxLEN4L357s2B7RHRHAP8GwJMABFe5rwJwf//+6QBeCQVHwiarQLu4eF9MONqHm1zsa/my+1CJdlHAdlKLZPlSuzPBSPaVQpIabsif832vbAFstHoU1i9p9zq3EWEawU4DSw2QAKyiIgHjkOTKLLMuKYxTWsveRVNVpSWMsMIktoIx8wdV0s8Q0asB/FCh/N+uP6oLZiGEN5BfqICmdUcZ5JTSTSWpENVOAVFINiFn12OjvwTArPIyX37W+O9Kws0QfCG+sYIzwK0zCqgUAQlIIthpQNIBGuYAUrimdvGD5m51AZISgAIyUHLtibojppWjdJ+jFJgk/IRx2251Mn8aGA3KkR2AIRzDn8KaO10SmU6oRtHdTqtGwkwIagCfXd3j5tRZxaUOxrjKdmsiep04fprfCFvazwD4PgxucgBw27A1AjO/l4g+odKHpQL9pjn2BVy8LwYc7VMZAhYHoqYxnCco0scablS+qUA1gRFUWbb79fUt97i4Cax/v4uy1As1pqXsULQSiAGExJ1OH/MQbnZYmCtgaQSQQpuWipSntatIgL0eSeanZdogyY13mppUq5OUKfS3hlG/fh+7GhHJiaODU5JuXih+tJK5Ozh/P1y+AI+tO3JNeZLIYKiwYexM1zoLUFrKEZAE2rOUpgTaxHHiGmgcZ/U5jWiX0BGJsgqUQn6yxiiqSAOthTR3GocBaEDSARqmAJILwiBc7CDWIsVPn681SlUmJIoSIIP2tCtHGoSkaUVIlsnd6lK1KEsbAaMYoht5NLo8Ut0ARiV3Opcm4EYAkakaqX9EY6oR6fpWWePYBB4oa4GgFaeSCfPUB5j5vqVMInoggPcz8+uJ6P5zxuJVoBcD+N99Uk0F2tnF+/zD0cQbmVkwBJwfIAL2C0W6fAVOdHqx3WYwYlF2aD99n493TDWy1hu1BlOIu6YnDSK7gI21F9zntHpkudfp9UcyxPcYILmxlFzq8jQAVRXJlR93tQsmy7hyy0FS+GxWnWBz1yjtZCs85VvJfkq8PwXwTgAPPaOxXAwbUYoApCBVKFIEKYa7UzZCeidQ0pgWXeuAdCwVyJl7LNvPoWpQeNLr6UBRKQiJgv4lIE8WnCGCUUSiYUAsB2QDkgujjUmAlChF4vPI62n47JZiFCApPqRK8gflCKirRxqCQn/xvfhS9JoimS/BJx6DzPQxMAptave5DIzCtyHBKHk/vPqvLebrNAk8CexA5Iv0FuUn2BgkWcDTUsb1y/Uyu9iy7d0PwIOJ6CvhXLRvQUS/DeB9YWNtIrodgPeXGiCiOwP4AIDnyzRmfrdRfGcX7/MPRw12roBorK1SXuEmbtc+d1aLCnVMtUjkN4FRSEpc6OR7JGUs1WjSV0zuaV5t/6NdLLjOgZE9SdTqkXSv0+uPdICGGiC5NsYi19ludkCuIrny7a52VpnwWVy5eRHuhnNaVpNk3VJ9vUZpKTsPbnUAHuX3lohGRJ90VoO5cBYgaGS/I+oJJQGgtGlsWflpd63T4GS2aUGPuNc0IUi2oY4t97tYrABWiSikH0RFVnIZLNoM7nXsIShxr/MdDf0TSoDEnAZoqAGSuzk35g6Sa4ucyeuqpRgFtQiACUtDO23qkQVCw3GXpFtKUXzfoBYBKIKRXHPU92UwKq4zCt9ZhB4SaYhAlCk+GoqApEyLapS41ony+jhJC8eqb6uM7scss6AtNU8x8xMAPAEAvHL0Pcz8CCL6rwC+GcCT/esLKs38Twyf9MYAPgnAXwH4NKO/v911zFcEHB3taEc72kHZ+YCj5wHQPtnPA/CZZzCWox3taEc72j5t/XnqyQCeQ0SPAvBuuKA/9lCY/7U89m7f37bWwC4kHM162LtSnZ3d58byz0Ix0vUmKEZJ24U2m1UjpRSNjgEoutTNXW80Ze+ikoUgDFrd0K51WaQ6Y+1RKXpdST0CUFyDNLYuSfYRPkfNxS70BaRPKacGbAif15XNFSTZb3ou6y4mLeuSlrJDVo6I6B5wT+NuSURfK7JuAecScbRJ1vBle/cYp28YF6iY7/WNKfsdGelgNIf0jjrK2Iax4QM0HAeFKLRTXJsEUW/MtS62S2qQ0k1RykyAFdo7qEegIXx3EqBBqUfoOzd3dLZ73ZZ9ePAwx1DdxU6vQ0q9AwaFyHKl64zrK2DPU1odGtI7s4xUhMLrmGIUjqesMdr2g7I0rhpRphoVN3wNn4XFWqOYJtJDzZCvlJtFXOoMNShrY6QfYs7qLT2vrOJVzvxKuKh0IejPF89s58+J6LOWG1lqFwKO9uI2N7HO6Jh2haZDgCJ9PBeMRP4UMNL1s7VGGNJLgRi0TVlfNNZWzaILHUpBGHLXuiESkas7uLoNa49K0etKgASguAapFMXOjaEMSK48Z3myr+zzYjlICv0C9fVI4XNpa4lyt7MtNOkQ0a8BCItd7+nTihvrEdETADwKzt/6scz8UqPZT/FtfhzcRnvBrgXwrcuM/AozvzCFgLobHRDXJbl7+9KFWtywC4uQodYdaRhJ22lIs9IlwCjoGYUgUaYETnba0IjsWzKPYCLRyFAhwk+SlgZnYOhGVAQ7w72u7/1nJHIgBLdpLFF5H6QATsEiCJG4lorrfgQj4Wqn1x0FS+aPketN5kanflcSdPSrhiL5PrrIVcCovI9RCxj5b0GB0aS1RuGWogIpU1zqZFrpmAp1LNDKoSgf52qudWu0OdOI6LvFYQfn1fAPa/V3ruHIPzCYZmcJRK1trQlFRvvFuq1qUZaXgw+P5APTwcgMwkBpO6VADaGZMiStsyeShgcrP53UcvWotvaoFL2uBEgAimuQWvZCcp+lz2CkRUUCNADZUe3WgKT0/I6vSVoUkhhoiLDbar8B4OeRhjQ1N9Yjok8F8DA4Vej2AP6AiO7OzMnCVGZ+AYAXENHnMfOfLDbSow3G8hpYuXhz+F+hTNjvCJQVydQY0fekdUexQTmmtN0MiiA+4ggEZeCk2o1VS/DkM4uR63w5qSoxkIX2TgDJA9DQAg99VABJH5fWIG2Z0Hu1KKhIVjCdMPZBKVKApFQlAEkbwfQDOFk+STNuBopgVIEiAJlaFPLHwMja56gERkE1ssEowI8AIy6sNRKfe8gX50LBjAk3aChTgKbsrKt6JcUpg6Ilb1mWnaeWMBkp9RRuDdLvrtXZuYajJpsDQxPqLQJEo/nlX/wuUFSsv5ZaJMtYUGTlj4FRw1hIlbGgp6YkLWUafHSedq3LQEmpR9q9rhScoQZIst1WQALa3ewAFCEJWDZggytbhyTdf2yvEuFO19/VCNV/0pOMmV9FRHdRyaWN9b4KwLOZ+XoA7ySivwbw2QASACKi72PmpwD4t0T0cKPPxy4z+qMBQIw8N7LfEQBwVwjZjXDzz1n9kD4ppDdgwFYKYaYaZdQvqUmQfRTACaKcVI8CCKXlhgQ3BhIDkik+XQKUAiTEz0ZieMsAUlCLdKCGDpxBEsRx7lKnlCMFRVlQn4rlARjsY8u1LrxaUBSPBRS5tDIYyTItYGRv9hrAaMgbdafTUGQCEUH84IrQ1FLGVI30rZeR5sqykYZFbcl5aiF7GzM/VyYQ0UMAPLdQfie7mHA054Z2Qp1mIDlPUGT1VYMifbwGGBXGo8Go5k5nvS91UXKpWyIynVZFxvJSEBpXj2rrj2qABGA0il05pHcZkFz5XEUK+RpQ8pDe60CSHJ8co7SW9Uk7m57cytayuZ620sZ6dwDwGlHuGp+m7e3+9XVG3tHmmLsbdLLByBOXBJYq4b6TG/Wkvr+fmhrSW4FVSXkqwU0GRcMwi/Vq6pFkjxKIQaXFOikTiU45pofQ3RYgufosmC0N8T0HkNzNOxI3OzAla5E0JAEwlSINSkAORZYKJGHKMlM5qgCRfA1QFNJS0KmF6k7BaHCVawQjUT8DI9FeAkYCOki/DyaBhfM00nXkLVABgExogkpTY0rKjvWxtLXPU/uwJyAHISttEbs4cLQyEAGNQLIrEAH7haJSf1UQqtSfA0aF+plqZIzHVpBsWMom+aJatOwFoaQYmU/4sqAL4+pRzb1uDJAAZOuQWsJ8u3GX3exc+XEVydW1gzaEzwusA0lyHHPUpF1swk+surne1G6NtGwkzPwi//r0hfo9mrAWpSgpK2/gra+wwbUuB6KokYyWD79Vl87JOigToDSAWeBUAKxwqAEoSfcNlYIzVN3rEqARwRckIIH9fxYSpUctgOSUIg8zNKhIiKAzuNppSIJIL7nUldzpTFe6wg1EaY2RPraASNYvudC5srlaFNoorTlqBaMBPAwwSoBI5iP5RzGqDGVlkZRdSzXSc0UxEMMKoHQIyhERfQWArwRwByL6OZF1Czj3ulXs/MPRVCg6CyBqKbMUEBX6WgSK9HH2r9borwA+k8FIw5B8H/OQ5xnvk24mAFJJ+alZDYx0eg2EAKj1RIYrnUqT5UtjAzArkp3sr55eV5FCmZqrnXUuyuWWh6TwmRYzYyJc2Eob610D4E6i3B0BvKfUCBG9CPlIPwynKP0SM1+34JivXJP7HdXUIsC5wTW41pn5EojktbIHOASLsCAnFjTSFexkUESYrB6FuoE7wmHodBgTxcopAul0CT/I0jNAwgBGYbaw9kAaA6QAP+TvXLWK1MF2tYswJKAncLSOcKfXKYXyruzUG4e2NUdACkUZKGWANECRTKu50YUz3ApGrk4ZjBJ1R6fHPAlZGmAohxgJIzrNACITmtS5tlQo3W41bUlbf55qtffAzTkPBvB6kX4tgP+4VqfnH45abA0gam23VmYEy88UinRa8V9xmmeqRaqMCUZmvwUwsm4KjDanqEbW/Uhr2lQzwUjd/OeT3gAcoeyYe93Qtq0eaRuLZDcXkFxeriIB4+uRxlQkq1z4zK6sDUnBpq5NWspWXuj6Qtgb670QwDOJ6KlwARnuBuC1lXbeAeA2AJ7lj78BwPsA3B3ALwP4psVHflFtiFecu7oZZZtgSbrWWRHwGEDPoC4HpSJEFQBqqKPSDVBKOMQAqpAuQSmWTRmm2FexDf9GiEMDCCUfIF1/lACSXn8ECUvjgMQebgLgjKlILk2pR/L6D0Q3upKiBNTXHI3Z2JojFsfazU67z4W8kgtdOC4FYoh8MAWMFPRkYOTfxw4UGEko0SBlqj4jkFJTloqqUQMQBdUo+2pj2WVp5hACMjDzGwG8kYiewcyrKUXazgSOiOhdcNS3BXDKzPethZ+d10l70UkQsisQAXuBomI7FbWnmLY2GJkQUwejmjtdTTWq2RJ7FklrUYesNAtwgg3ucsu41+n+lwYkwHazK332VhUJGHe1c2VtSJLn09XLv/s19z1aatIhomfBBV+4NRFdA+CJKGysx8xvJaLnAHgbnDvCY3SkOmWfwcxfKI5fRESvYuYvJKK3LvMJDtdWm6c0/LjOyuNgua6IQT2lQRRUuQRKYp8BCQzYYkT1KLlW8wAiEG0m/WAoMKoeQTY2HFoAlZQVbedtKPc6nS4BKfknXgEkHgadKkcjgMTkQ3lz8qECIAVoCmlyvZGEJOluF058uJZH4IqSWgpLwDDP1dYWlYyNOlKBsiAoHEsFKNSrKUO1aHSyjyYwiqpRBYw0DCXvh37lq86TIKMhpxWSYll1nk1YS8Zhl1/4tiXt4wDgiIiew8wPBfAGMm7imPlea/R7lsrRA5j5A+LYDD87qcW1gKi17R2gaMZ1rNjnbCiy0kvAo/LOEowsd7qSapQkG9+HTisFaFjL6muM7I1iS2ktgARgdA1SktYISK5dKy8HjjlR7cK5AfYHSYuZuwtYpinmLJqcN3NjPWZ+EoAnNTZ/GyK6MzO/GwCI6M4Abu3zbpg00PNry89Tlk0EpkHhMWAnyc/NhJgkr+SWJ+CFRtIl/Ij0EkDVyobMwBxJG0mmgisJSAgdyjNSAKQIcgPVWfsghfMbWIpogCjtZifVIcQ6wq0OQTEa3O0grotaUZIgpNccxXrmt2/b2JqjRDkqAlKqFIW82t5FIU2CkQVF4XhnMArH3kjlJ7cmIs+EHuR1krIZZDWUtfIa0oNqtOityYLz1I72OP/6wH12ekhudaXws3WbCBV7V4mAw4Iiq65Zr9KOytsZjJL2pv1jrLnotShItuscV4/nmuU6B7TteZTCy7h61ApIwKDWTAEkN+6xgAx1NztXrxy6vMXVzjqvoRxQhiTABqWxtUlL2crNL2X/CcCriehv4P6VfhKA7yCim8Jdo69Emz5P6ZuMFtc6ADJww3B/b134/U15Ty4wgy4TXOtgAJGAqGpYbyC9nhdUqhJ4EcQpmABFCdcYdUI/uo4EpOL6I1E6ASR/Hl02xfOUrEMKFEUOegJCQZYhpyaRoRgN1zlDMfJDTN3nhvxk41g1L7gh+2vu1JsjpBAUzFxrZKhEIV8rRaX0AEWx3Zgu00rrizD8aHpMAqMELjQYFcGjDj0J+Ojyqp3wWxxOagGesjzxqy70sbQdwjwVIq8C+A5mTq61RPSTWOLhlGFnBUcM4GVeIvslH5q2FH42MSJ6NIBHA8Clj//4ts6mXiOWgKKRX9XqUGSNoQWCrLS9gVE+hiZ3OqR5c1SjfbjUjeWXVKJW9WisT2sMAJqj2Mk0PZY5bnYuPw/YEMYky8xRkUplhzplNWl1SDqASWfMmPn3iehuAO4B98/nL0UQhp85u5HtzRaZp67e3DwvYClFruL4iOBd60rrkSIITAvMoOva+yXlMFOCnDH4scon0KPbsiBIFExDbw/1o4gzFZAIw5xFAgbIzR8tbnYIbQgwiGoPDwEbrPTw4EkqShqUgByKYFxDa2a532lISgHJpxkqUcivQVFI51BXwJAs0+ZGl5abAkaZ+pNBDqVlmwAmTTchSfep2kr6K/QjLVGNlp5XDmue+lLkIPQVRtoidlZwdD9mfo+fWF5ORH/ZWtFPUE8DgBvd6U7Fr25xhai17B6hqNjeHLWopR1RJuvXAB9zDyPZTtZnHYSK7nSGEjRlrZFVTt9zzIlUJ20KLLW8t9SjYK3qkbY1AQmw3ex036XztYurXansUGe/kCTvuc6BfSaAu8DNFfciIjDzb57tkPZmi8xTt7zRJzZ/2zrM93DDXiqP5PbcLMtI1KNUARIQZbatWCep27D2SKZjuLFO8gQUxaQKYAnWUHVTQJKVsvVHLYDka6YDIWgVqdXNjlm0ZsCQTI8QBCSwpEEpDCmUA5BB0xSzQUnkV4BIpjdBERCBR0NRbHNNMBLwk4LMMLZUZSoAlT42IKmkShXBKsvjYp60JdcIHco8RUTfDuA7AHwyEb1JZN0cwB+v1e+ZwBEzv8e/vp+Ing+3S3sp/Gx7u2cFRMD5gSIrbRcwGlOLSmWSPi2wYqOc0X5Ui9o++5hLXavt4mo3VeEBbPWoFtp7CiA1B47YAZCsvGC1sN8uP4WksQ1kw1iBMiQB09YlzbnRKBozqD+AWWfEiOi3ANwVwF/ABSUA3D/WKwKOlpunGOh5WHACIGxuMwY/Q1kNSxJb0rJhz6MEMoRlQCSv2zKsNzi7SBZVH/8x5cgsgKmF9i7VgcxP3qj+fEoAIdn2LoAUarcAEjh3s4sD9HebLZAUT4K36CKnQUkU04EZwlDHzFpWYrnkaSCSdXWghZCnoSi2k+SFNErHsg8wElCigSmBlgrs1EAoy9NlYPQF1Z+qQ1m9tVSjg5mnngngxQB+Am6NZ7Brmfkf1+p073Dk/dU7Zr7Wv/8yAD+KcvjZqk2+Z7mIUFQaRxMEjbSl8vcBRpaNwZLs1wy0YLWF3PWgljfXJqlGBgSNtWWF9m4al4CBWhS7BIRmABJgr0MaPlM57Lf1mVtVpDBe9xnz8z83eMMidhBzzqjdF8CnMh/Gqtx92tLzVNUE/AD+Ft0Kza3HKPc8Cnfg+vooXehawnrrPjS8hDcx31aPXN8KcGoglXSQ5sHsNx+XhivVJOYCUmhuDJDgQYdjTwP8xL6ZIiRBQYaGpAAP0u0OSNcgATKQzVBenucpNr7mKC87FYpiuiiXudCJsa8ORhIsFKDUQCcDlgIklUCoVC+vz1ndIgwtDkgLtzdnCMwfhttf7+EA4JX8qwHcjIhuFgIGLW1noRzdFsDzyd3JXgLwTGZ+CRH9GYzws4tYK6A0l1sJiCpj2AmKrLTseLydRcAobdHMm+pOV1ON5rjXlWyRPY6Qu8GZ5QrudEN+rh7pumPqUanPpQFpLE/nuzI5IAG5igS0Q1LpvFvKk6uzHiQdgrtCg70FwCcCeO9YwQtoy85T3AN91xSIYajjr2/wsASMbxLLIjCDBUuAAAN7TdJU9cgBB6m2c5iK9Wi4ydZAI1ElAytO2zRVJ59prj+CyJsESAhnwgYkDzx6HZJWkdgfB5hy58JWkiy3uiEUOGxYwlA+WMsDvlrIbwuG5PuaW10NioZ0oRZxXjb5AawIRjEPurzIh3qPUjtDdpIHO89ShIYyXIQhrRqtEXb7kOYpInoQgLBH3/sB/K8A3g7g09bob+9wxMzvAPDpRvoHUQhPEimfAAAgAElEQVQ/e7SjHe1oF8YYzs3q8O3WAN5GRK8FcH1IZOYHn92Q9mPHeepoRzvaFW2HN0/9OIDPBfAHzPwZRPQAeDVpDTukUN7L2wVQjIrtzlWMrLSRtrL+d1GN4nv7XBZVo4LpCHVjLnXmWFU9a9+kNcza2bykEAHSfW7ctW6KemStP9qHehSstmmsyy+72IVyu6xDCuWBesCGRe2g5pyi/fBZD+DCmQ7pHRSaEIShQZ4eNoUdotaZUekQ1JXUtS5Tr7SSZLThi9kubEkbvo7IH3PNKypG8jpcaCOma2VpQfUIIj9Tj4I6N+ZiFxZBhbMX8oWbXVCQgkIU1TVi05VOu93FkUt1feJNieVWZ+1x5NLT/Pgq61UUo9gGiz7U+0QxAtZVjSz1xlKNLKVnTEEyykjT6WWlyM7LxrqUHdY8dcLMHySijog6Zv5DH8p7Fbt4cDTlWnAeoQiYD0YzIGt1MGoFkQg/Rh/FsgYoHZJOXDDLBWyqa121fQFIAIoR7JYCJGAsUl0ZovQ4wliA3Vzsgk2JareknYOfIZj5j4jotgA+yye9lpknB8o52gTTrnQiEAMgb9dLdf0NemnPIwxAkQCRflikXetCywWoGaKylfJT4KHhoxbLRFcknV8pm5ZbBpCGd+JsBFiJD/MoAtIARmGdETxDpeuQEjc7D0kMkRc+moAl05VOzQ0SZlrmOwuIgrWuN2KV3gpFQ3peNwEj5X63GhgpGBo+sA0/GahYeSq/Wj9ph4tl9uFSF/s5HPsnIroZgFcBeAYRvR/A6VqdXQw4WgOIgIsDRVaabsuosy8wyi7gOr0ARi2q0TDGPK8WjGEXk77hLWG5reNimgFOOm9MPSpZbYNYaVMBybVTjmKn8+36u6lIQEkV8qC1Z0g6kChAVSOihwL4r3AbnRKA/05E38vMzzvTgZ03C3fE8OuOdNS6KeuQfPAGebNOPaWbt6q+EwgCZqlHeTkDUDCAF6DKWRBDCpCMMrDaau3Tp+wOSBA5gWBKa5Bc2QGMyIORtQ7Jl42q0ABV8YOFUkpVcmkpLIUhJDbjJsUKv2KtN8qAyCfKKHQxvwJF6XtKT78EowAywLpgJOBIq0Ml+MmUIplntYVKO5UyJij1Mm/ZeeXA5qmvAnAdgP8I4BsB3BIuSM4qdv7hqPXffku5xpvjNaCo2mZpXPsCo0r5aWA0kibSdw+eEKZGK2+8vrzp3nWPoyk25lqny7WqRyX3OgCmi50FSNb+R65OGZAAO1KdHcrbfTFjm8bOUZH02LSVoHMVSDImuAO1/wvAZwW1iIhuA+APABzhaEkrbAibpI1uDpvvuLOkegRZLgwua6s9ct2kMvLYAihaG5CGWuQbztzsPDCBEKkvBSMS8IMBkhJ3O4TGB5c7cY4YaXqAJQAJMMURT5hDS+pRAkWl8pymFaHIl20KugDkQKXVotD30mAk60PkQR23QFKtPAptAlE1ykxAUFF1WsoObJ5i5n8Rh09fu7/zD0c1awans4Oi0XaXVIus9vYKRpylUameSmtWjYw2SNWx8lptqfDe0loVopb9kUrqUalfAMUIdksAkmtnaqS6aW52pXNTU5GAeWG/lzCCn/wO3zrlRvdBpLrH0VrNUmummOFul97I1yYYBUGl8RjlqIepSqVwNQ47pXI0fDQDagSYWVCk2lsdkDzsDLn+bPmOamuRBjCS8DPUC5CkXe7iZ47wQ/GkMFS6Pv0zb1jMe3IDhmS6Xn9UVIp8fXNdUTg26hbd6ESdpcBoFIRqeSotPYl5mVxx4npZ3Z5SjZa8PTmUeYqIroX9s3T/wphvsUa/FxOOLioUldprSRuBInMsa4CRzC58xqI7XaPVVKNgJWCY0tdcUGoN5w2M7Wtkq0dz3evmbBB7loAE5G52QJuKFMYITIOkxWzdJU1L2UuI6KUAnuWPvwHA75/heM631VzrdGCGYI0XJGvPo6AelfZLMtUjIL9wJvAiwClkyXlB73tUKJeAExUASZXP8o32FwekWJjF+Ac0AgfFzVCRED5cyFeQBECuSdJqkgzIUIUlcW7lFWsJ5SjjQ60EybqGShTzDUBKBq2hCEMaqeOh/FBnb2BkAE2xLd0G5Pjstk3L2rchaBUlaaF5ioiuhlsrdCM47ngeMz+RiG4F4HcA3AXAuwA8lJk/JOsy882XGcU0u1hwdISiQtoBgVEEHrtePSgDJ2VaVKOsiUKZtYM3NKk+VZVn2gav4+MRUfBMAGuLYAfMByQAIwCUAxJQd7MrfZ4xSJqyHmkJO4QncmPGzN9LRF8H4H5w/7qexszPP+NhXVEW9i0qudvF2/TKtS8FlhH1CAEwUvUIwBCggazyEkZEf1QuB1lHAFL8LGqKKEPPSoAUKiKgUIIeEYJI5GcqUmijBElBCYrHiCc5bh1VgCUACTCFvGCzlSOjXmm/oyoQFY8VFPl2EqXIpyVqkazDKt/bImDEsi3Uy+vLeAmMKuWHtjnrO1eLVBAGAUxr2ILz1PUAvoiZ/5mILgN4NRG9GMDXAngFMz+ZiB4P4PEAvn+pTnex8w9HCwMRcA6gqJS+BhjpiXABMKqNR6c3RaerNLukS93SZikdIb3mCtcl6tA89ajUbinEd7AlAcm1l0KStU5J5ttttKlIevxJ+kjQhkUByZokD9SY+XcB/O5Zj+PcG3NUiJrUo1KAhUr7SVhvf1c+a+2RODafJnGuHiWvskq42bPKQeSNQBSsOoW0JQAJYUzJ+EVCBKchR6tIA+AUIMmDUexPqEmAgkUDlkKZEhBN8YIo3QNnoCTXICmYSMpLKIr5FSiK6ZRO9Qp2snISJpCWnQtGqVI1AkY6H6qdQhsllScbR6l9aRKYlpxXFpynmJkB/LM/vOz/GC7Iwv19+tPhgv8c4Whna/nHvw+VKPY1o/2qUrJLmvUvr2FMewCjktLTogCNqUYtwDOm4Fj5U137plqL+9xSJt3rAGSKVGuABj3uGiABQCmSnRxT/OwT3ez0uIZyZRUJsIM2yLHGdpqfwrQYH1oUoMTOysf7aMLE3WoEJiAJ7T1FPXJt5hCEnkFdwZ0OCjJUeO+aG14WnCGMWbwm9RhF9zoYbZjtqbZnA5KAlnytk7/5Tq4pQ5ouw769DJLC98WWekTGuRGqUtKmApgElDDPCjcrSXts9K3TYnkBSAJiNBQBChoKapEul6hFvvxOYFQBlDHoCb+T/OTV2yoFYEjrFFSj1WzSPHVrInqdOH4aMz9NFiCiDYDXA/hXAP5vZv5TIrotM78XAJj5vUT0CUuMfAk733BUs4ZfzSJABOwHikrpLWBkPfzTaSN1msAo7cEsM0XBKQVhmGoaqMrlZjVftNbw3O3tpSrQXPVorF0AzQEasvQCIGV5povcdEDK22hXkfTnSNIrke0WsQN2qzsrH++Lazx832Pq0Y5BG0bVowpEOZjI1aOw4w4DZoAGrfQMr5XodaIeZB0DkFreLwVIYDk35ioS+QaqKpIsw7AhaTgLYkA5KAWT6YCAJX1etbvdBCtekliWyWEoSZdAJI93gSJRVisuCRgp0JkNRizbngFGpT7keUvqcwZmJWUJgB2EQRwvau3tfYCZ71tvircA7k1EHwfg+UR0z12Ht6ZdPDg6dCgCpoNRKyzNUYsa6hTBaGw8Ks1aZ1Te46jSja6rjiNTNfwWxsrsM4w3IEN0L6sW6fbH3OuStEKAhl0BydWbGojBfbtLqUihrGuzfX+knYyx2qZ9RzvnVgnrDZUuy0XFomFu0xAk1aMARNULMKfgJIEjedVNcKGc+IyMHJBQKYuRtiYBks+Q7YQRZJCEFH6Gzxi+gwZICnXDgCxQUifBilongSkOY8epw1yvxIX8mF4GomRMPKRlUCTHzeWypOsU4WY6GFXTM7ARaZU6pNuWZuVndeuhu5MyS9lK8xQz/xMRvRLAlwN4HxHdzqtGtwNwMJuMX4ywrMTDX8WYFgIjQnESqvZRGiOh3GYp7RDAiArvjX/BoyG7S+lKNVpK3dllvdESa5Va3bRCuX7iDzdsCjjUz/+pb0ERNmR+6Gsr+uyR57s2CumyPfVZdVhsPbatKl8a+3iZPK1nin9WeavOlrtFQ3kDcHcKLX9HO9oUY/ZPljneMMWn0z3UU+ry7yt7Gl1ZCF68HLLuDyjeMOo0DGn6qfr4ePM69RtbGqZmox0wgJ5iufjZ+vQGHL2sQ8ONuSzXuzTu/ekX5dI/cVMg8rl3Yb+Zyb3vVV744xl/fd5m0q4ol42z9Bm8UsR9fh6pF+Vkm708l6os8nNpfe/Ui/Nf+m2gkN74fhYYZWmVH7X+NybOQwswLWILzVNEdBuvGIGIbgzgSwD8JYAXAvhmX+ybAbxgpU8y2c6/cnQgSlG1n6lqy9T0GrR4m+pGBywARiOw1+pOZ5cJV8r0mFS+hqpWNWafkeqmqEStrnUtdUv50koBGspttCtIQHkdUpsL3Tw3O2usyWcuuNotamtOaEc7LPM3MtGmBGbo0h+KTpfHUc2Ad69rCOoQVRVDPZKqEGSadV3nUM96HV9/FPNG5lhLBYoHahxJGbLrDkKNU2IsN7uQHVItFUkGYwjjiGqQT0iUJJ+WRadjDPNeMhBKPqN8kylMSZmZZtbXT1uNspZKJNIzpSiUkeVlWdFGUS0SbWRqEWR6XqcIM8VzULBaW8U8tsvIz1rsJ3enWwWUlmvvdgCe7tcddQCew8y/R0R/AuA5RPQoAO8G8JDFetzRzj8cVezMoQgo/8qrdVrTjLYPEIxG1xklZa2xcDFvaVvDla3Vlnap02uPiuVg7TtUX3+U1i/DRA2QsvxZkerG90yqjbEW1c71vQ4kUX/0qzvayhajyrk7cL32SENQBKSx6yyjGJyhGZBKfUjIopQpM6Cx3lPaRlKmBEgRWjCcJzWsBMQkSImMCKcacGioIyEpApUvb4XxHtpQAw9vTCDaZe4ofDFcej+UrwKRTs/SKuVDmqqXqHuqTFU1NOpbgNJUjkdvDyeBUT4+pRrVTNZfyJaap5j5TQA+w0j/IIAvXqSThe1CwtG5hKLJsDQORub4zhKMWqHP6jcZn5iNdB8TTNZrAa9dgWUq9IypQ0uqR9YGsUusPwKmAZIcox5bLR/IIQo4UBWJgSWbJKJ3AbgWwBbAKTPft2VzvaPt0foe6IREtC/1SAZnaH26FOFCgBPytDFAqs5pEoLUK2RaEBdYpRtlZZfFMhqQBBgN5f0n4XQOTQBJloOAstiegqT4uSmhslFQEvWSPY1MdQnWQTGpiaF0GQuGZLkaECXH4tVSlcKwWdVVAJEep2CUqlQrglFre5YVyptgZAGTPF7aFp6nzptdjDVH3hZbUwRUL+yz1hXV2rzCwGjUnS5J42JeVjark9btVPqVYHrtkbTS2htz/c4O649c/fIaJJ1vjWHOOqRyOXtt0dS1SHONwCBu+5tgD2Dme4uIQY+H21zvbgBe4Y+PdiUb+yfWxtqjeGPW2zdec27G8qfiPHojaeXJm9CWsqNl0FBero2R5XpVV5eDLkfD2pg+7VOvNwptxPUyvajLiOuU3BqesPZHlVXrhYZxGn9mOd2W+xvWHYX+jXPQ5+fLXFNVW38EcR5i/bHvefjc5vfeq+9m5Hdi/v4qv8mpv+fk30GDNYFROO7Z/S1gK81T58YuhHK0L6VotK8DgCLAGGNDvQw+5oBRyUaAqdR31R1vqe+8wdYK8R0gYcmIeFPUI21T3OuWUJCA9LPPUZCA+jqk+ue1laS1IgUmtv6EcrCb612RxnwY6hFG3OumXOv8jedO7nWVsiEPIZ3QrCCNlqFhisvG4SsNZxaZkhRujOP5Eq524TDesFL4PkIlPThSnQ/1QmMsTwSGcrVw3vE81B70jl2GdL5um41yNZVI5GtlhVS+rNeqFiXtagBpAJ7sM60JRqVXALPWEPU8rXyLXVDwabELpRwd7WhHO9q5sGWj1TGAlxHR64no0T4t2VwPwMFsrne0ox3taEc7B3YFR1XdOxwR0Z2I6A+J6O3/f3tnF3LNVd3x/3qjMW0i1JAaQgw1lVzUFhqDtaUBkYpWvUm9EPTCeiFEaAIKtjT1pl601JZqr4oQMeCFNogfGFrRqrUUKWhUokl8saY21ZiQ1FowFazkPasXs2fO2muvvWfPxzkzc876wXnOzN5rf82c5+z5n7VmDxE9TERvD+nvJqIfENED4fW6mvpm8RoRej0RWwilAyq8RmqsRFO8Rvn+9IaulY6lTiq0qVepm5NjPuOoDefS710+dP6FeL9wBEqhdVZbsn6dP2d4ndWnoeF1ORsrDM8KsdP9lf0eunx6NQw7zMV6hSePi9ftRo23MvMtAF4L4A4ievlhOn4+zD1PbQaGGVpXDOcphv1Y7/Gv532/ukfpyJdpt3vDoUSfgXz5XPhc9/9r9LO9UMiF2UUhc6IeHWqmw+poJ+qQ9Ri2+sW7/Muyt8LqdNhc2x+zz4VxdXUYYXS5Zc3tYy6OjXVeM8d/yGdnEa9RzbL5uf25aY953Tx1ciwRVvcMgHcy89eJ6LkAvkZEnwt5f8PMf320nlRc+4wKoyvVPUosGe2MFUZyt0aEFYURm3lD7jXKCZ+xIXW19xtZ9zKt8Z6kMSFepdC6/eIN/aF1fYszlKgNr5N9yuaPXqFuWIjdkIUapjJgFaCaJ48/Ht6fIqJPAngZVvxwvY0w4zzVXPAAmBZaByQPhj1IaB0AvbQ3VL62P3R4XZRP+8PZZ1tlQ820x9gbyjIt7VFuQt7Ekt/BUJZvS+owu31Oe372NSeD7xomRKYy9A6GbX7XpPfrTefLStmw49TWCr8zw+h0vijXiaJoX9nKfcOuT8DIPi4hjLSgqxZGO1H/jJzzqqpH9xwx8xPM/PWw/TSAiwCuP2onlPfEondxh2MII8p82pW92dehwshq61DCqDRenVQhhNZE7cNdZ21zgPcoLnch8UABtncmV1fOe9TUk89L+jLCgzRlkYY5FmoYD2OucAUiujJcvIOIrgTwagAPYcUP19sCq5in9p1Bd+PzDtHnQ6fJ/faCDFz3YNhFKVw0mhebhTLJBa+uT3sXxMWw5WGKL1Lbl36QKWLvhLXogLz4FvZU8rzo+to6Mx4m/eo8ToWXVc70Hul2dkb/hH3iJUqOczrexCsVHdd926XPhymM1PkxhZFR5xzC6OBIYTRrmBvPNk9tkUXvOSKiF6JZ+/zLIelOIvomEd1DRM/LlLm9DTG59L8/GdggiqJIeqnzdcj/vsr6h6a37VTYj1mVrjeMziijWjXthgqjUV4jy77C5pTQoXVlW+Ni/0jhdaX6L/GFySF2wPhV7FrbnEg6KHISmz7pXAvgS0T0DQBfAfAPzPwZAO8B8Coi+g6AV4V9ZwRT56mf7X4aLmDCa7eLz3GXt4vt2rwjoX+RluF1Vb9gTwmv0xQuYPsEUl85a9sMszNEVCyAhPDJiSRtu+sRSizEUkmMmPuGoKl9JavUFdrSq90ZY8sJoiSs0DoHyXHc20s7fZ6012XU5yCXV/hMRu8Gg7xGYuxV/3OZNmchtOXi6MgQ0VUAPg7gHcz8YwDvB/AiADcDeALAe61yzHw3M7+UmV962VVXVjaGnot99Lufx4gijEhv26qwP5owivY5bzeAZMnwWq8RtXn5f8hjPjQ2B/d+oPpJ7kOqOOD63iSJ5T1qbMuCYq77j6x+HUog1XiaynXOu3x32mjlqwdm/i4z/3p4/Soz/3lI/29mfiUz3xTef3SgkZw0c8xTl9MVwxs2xdPhvUc5gVS8ODvE/Uft8TfK9Amk4nbGexDtq3ZzZff5ZZGUemdib5IWSlmxlBNMWqzo9JoX95Tv0pVnyPIOqWNIYszmGK1jpsroz4H2/kXCKHNerXKJzQ7Jua8RRh09n+8+YZR6KgeE0zHHx2IOZpqntsgiS3kT0bPRTDgfZuZPAAAzPynyPwDg7+dprJxddQ1b+rSNEj/T21hcGGmzaEbrT8/1YazXqETufqNjsL//x34HgPQhruPvM7Lz8vceleqx7tkZ0x99P88c9yAB45bwzo1p6L1IUznVZ0OcEnPOU8w7kLynqPfeo+P9skPcf/8RgOgepGPdf9T9GMZxGWmj70EC8rbQZYNxO59GdrSfnnTZtkxcnkI+R3XqMvvO0X58ogWWg2jLy4EIo+g6gLXxCDIXREmVmSYiO3kvkXgntd9d3Ov2LdHTltMiQNat85WwMe0yQqdWGNn5bNr3/bCwr2+4MBo5XWc553nq6OKIiAjABwFcZOb3ifTr2qVnAbweTdz8hIbK2QcTRaW8bHrum8ZO7r2/yCg7aEU6My1vP1c4XVR9b3+0/XDhs/bFGErUPc8oFUzyWUWxbb4enV/z7KPEzhBIAEQ9wwSS1echAgmAadv0SdsfwIN0xpPOFjjaPKVhxl4gifT2I5l59pFOk/vN9Xj4ayzOMCUCwB7DzAIp7NQKpChd2oYEq/6snRBnaG3kYeNKkdSWEZ3KCiUWDbaH1BBMsl/ROcxc3ERirfbrp8fOFEOyHCu7bPpeSGnRk3jWknaVsKkQLtpOiydgGWG0H+tK5oe19GMBlvAc3QrgzQAeJKIHQtq7ALyJiG5G8zF7FMDbRtV+aFFUamOUYKoXRlXeIqPsdGGUzxsqJpJwuigvrauUVuzixAm/vTDXq90tTc7j02eT8x4B6ZLlOe/RGIEk6fPCHFMgtbaALZJKQnEyzMClE41FOB3mnad2DL5Q4z0a+cXFPEkg9a5eF8ZQ5T3KDEGLm1qBBLVfEkhBj2RtocsKIWTZtQlM2IubjF0ikkJCt2KdPh7thhZKAKRY2vczI5isyg2mTmGp98gQQ2I7EURmHmXtix4mvc/pflYwKVETiZtofIcVRn2M8RrN6uk583nq6OKImb8E+7r205MqrphTqu4rGtvGUME00Cu1rDDiQp5drmp1OssWGWFTqKMk0OYWNcf2LA0JtbNsxnqPhobX5QRSEkI3c4id7nfbXyAWPTmvUG58RxFIzmo52DxVbtQIr1M2IT/xHo38NagRLP0CCQizQK1AAhLvkexjXiilAgltfkgsCaT2UMgwu0hzGPaRXTC2hAyLnfZiNBc6F7XXiqS2AUMMJR4l3dm2Hqgy0UZKzY/BvVOarkTby6leCxqxbXmJdBktfkrpg7xFUPuWnTWWksAx6uwTRhLTaxQ+uKOF0dxT1hnPU4vcczQrxxBFfe2cqTCaFE5XccwH339UkTeXuDm0J2mIGKq9pyh3wS9tx4bXpXUuK5CadoZ5kWrD7GbhjCedsyRcuBS9R7UCZ8ezhdcNEVWtoJkikDpPlBAAQwQSEltDQyAVSFK0RJqC7P3IA5SxrxJJopORN4n3B5TVwLoy2KcnXqJoPxZNktHTVK6cdYGv87TAAIqCyNpvt6tFkdyu2E/ETa69nNAx87ls3/W9ZwETGGntvl62+9Cc8Ty1fXFUYDFRVMqrEDWSMQsvACOEkdmHSiGSE0bZwmIyH+k1Kh76ml/Lxv3QenCqRJEhfErlh3iPcuWGhtcNHdcYgQSg+LBY3W9pB1j3Fg1brGE07STnnAc1FxjSps97VPvl1f4KjbJAqgmvK7Xbep9GLdCQ8QZJgQSkgiS2TUUUIxZIqLCX+1JMwco3+rQXQCFN2SXltFCK8kSBfXZSSTa0bsz8VviYJl/dmf1YXFBiWxRFVh01toZgkXm9AspKV2mmB6hCGKV19a/suO97/yIL2ms0b1gdznqeOklxdND7ivryh3qLMvbZMSwljIYKoKRMhXlPG0M9STXenakeoLk8UVX3Eg1ckW6I3RDvUalfQxZoADDJg2TaTFyhrm+xhnlggM83lvssaT1Efd4jsyzXh9dBpvX0iesFEhALG+k9SuaPTuwMEEiwRA8HIVcQQOo9yW+9Njo9FOrS1b5uM8rPiJ9O6EDZiQ5G3iRZ1hBKsjPau9Q1KQcmmeua1qrHEjtAfNFSK4isdBTstfBR2yUBE9myOGQcp0f9niiM4rTKJe8NLK+RKYzmOu/tIM94njo5cbQZb1HBfmwYHbCAMMrl5YRRwWtkUuk1GhtuN8ZuLvSKbSW7vCgqhbaVBVf7nKKSB6nGe2TVW7NAQ1PntBA702aWJbzHL2PeC+Osb3R1BO0vvaWlvalCmO8wPLyuMJfp5b27OjICKcqLvBn1S3zbXqGm/9n7kNQ7hE0kboQXSesMXWcrYqSttO/aaMWPajcRSbL+glDq2jUat0TTrF4jqx5FKl56xJBITwSRlZerZ4goytjrvPY8R/VoAaTLm/XOJIw0A+8zml8Y4eznqZMRRwddbKHPpiiYViSMqugRU5m8KcJC93uoh6hU15g6Ds2Y5xhNrX9ouF7N4gxz3H/U1Lm8QALqw+xm4Yxjuc8S5oz3qPCF1XmMQngdkC7v3YqN3BefEE2mQMKA5b15gEBq97VXqE8gie04zQ6zs23j7da+E0hiiJ3myHmNREVSOA0VSVJwyTZ0nhZLgChnrWAXbegOiCTreqH2K8gq3COGovQ+QZRL10IjpPWJppxI6fYz9ZjeGyWM4n5MF0ZpO5yWH/I8o7nnlTOepzYvjhYNoSvlzSGKcvWMFUZVXqN8fvUKdAf0GmX7o5giPvrC247FUK/Q2IUZau4/GtpfXedSAglIHxbbMuWZSJM540nHaeh9MGzpl57O44RyeF2uDu4XSDK8DkZdreCpWaChGwv3CKSgSixvUC7MzhI5kbiRQqjthrxQlm1lhEoigkoiSXSgm9ctoSTqNz1IsPMAKK9R6mnSDP56z12+ZERNkjdGEOl3lVctijL2UozmPUFG+6b4mSiMULCVfSwswJB4jXJeqCmc8Ty1eXFUZMveolw9BxNGXMyvDlsbKIxqvEaFblWVSe3ntaul1mM0NIxuSlpS/wTvkaZvgQYgFrGHEEilPo55JtI88FlPOucHg3c70IULkeN0xKoAABOcSURBVPco6zXKLc4A7BdoqPAUAalo2u+nRRvRYgskAOkiDbIPQ56BxGWB1ByxjAAKKaXnIVnCqrNpRU3GiyTbio6NqiupL9TTW06KIVE+6jz29XVYggmpjaTqh2NdXw7rkqJHDGXr7RFFOj0riqw0vd3uB1vTWyTz2BhXlMe2vVlX+SGvORHV9T8II0nUD0sYzTqvnPc8dYBHvzuO4zhZGM1Fcs3LcRzHcY7NjPMUEd1ARF8kootE9DARvT2kX01EnyOi74T35x16WLWcpjgiLf8tm746CjYzeY2YVuo1StrQP18U8uaipw07zajmQKF3h2BX+GDthvwMWFGvXn3tkqg/1w/ZB+lJkXXpfsb1pl83ib2ySetT+UZftY3uY9xe/7E5CMx1L+d02TGYd+EX4vDKXWh0nwllz9zt55bx7R4OycIu7Mtfnu02m/L6l+rc/Q/ZkCK5D6S/pptLGYupXLx3v5yrNDPMqWSDvUeh7Q8Z281FoujPzkhT5RIbna6OGem627I71b9dah+VYcO+4mWVr25T91EeExj1VR4feVytY22dk6QOcY5zn4Pc58b0GmXsa7xGHQWvUTc+sYR2asOHD6cTfZ1pnnoGwDuZ+VcA/BaAO4joxQDuAvAFZr4JwBfC/io4vbC6Q4bSlfLmCqXL1XVMYTRm/CrvWCF1taxlMYY5GfKg133+sMUgxjzjp3Zxhpz9WsLrgAM9ABZ81qsAnR3hAiYJrdNfgMWV63pC8Ar3HlntSLsmjCz8lfce6e9nTpf41oszdP0MF6Zjw+vQ2cfbBIj7kvIPi21tIcspGzDiEDuZp+po99tE6ktDut/ZiQ5Fx1iH3Ily5sp0VpidSh9MaWqwLhVy9mzY6HcjT4vtKL3dN9LM/FKeFkOybd0/IYyyYXhRHbYwKv5gwPZ57xVGkT1j3ulqvnmKmZ8A8ETYfpqILgK4HsBtAF4RzD4E4J8B/PEsjU7kdMTRHJ6isflzCKNS/xcURqVFGKoXaBjKAM+UlT/GI3RID9OU1ekOeY+RFgDxEtzT7j2qXZxhLMcQSCX7STAaj4FzvtSuXCfFD5A+HNZwl7ciJnvvUU4sWQJJSoS22A5FgUQXSC2sMEIgifJALHDitPwqdp34aW1D4ayQakWSFDvBuGqFuoz4IdHprFAS/Y06125aX+Oib1Z6hDU/V05JVVOXJXhkep8gqrEdKIo6W0PQyDxdh+5/4qXUZaM6xt9nBGDvMSoIowhxrxG13uG5ONA8RUQvBPASAF8GcG0QTmDmJ4jo+bM3OJLti6Oa/1wXRv3CyGwn369ynt23nNdo+IIKqf1SiyzMwaGX9ga02JmvvTkWZ7D61Oc9auocL5CA+qW7DyKQzvjJ42dJWJa78x6pL6LsynXWFxYzIoHUtQFbMLXLAwP9izOEq/xUIDUlCNytWkdcIZDQTAE5gdQ2aQmkrjtdmf17nFb3sFgYdUDntSLGmh6F2BKHKhI5+r+6OxMVQqk9VlrpJdcM+kfKgeJlMvrYWGJIbWcFkbTrEUtZUdSmIZPP+bJl8aSFil12DmFEjGgBBlMYQfQryhfCaO5ppX6euoaIvir272bmu7UREV0F4OMA3sHMP6Y1XpAFti2ODil6+vIHChpgoDDK1LGYMCqJmSivp28DiMRUT35f+VrWvIy3mWYIgqEX89J+qPdoyBj0w2EBRB6kYwokPaZ9m80nLRdmNxt+P9HZUrVynXwukiRnG+UrISS+lLVXSdoREC3XLVevA4BkBbu2axyLmkgghUZyAglEIS8VSAithSaKQoeYgzjJh9khssdezLQCJ2y3oXYwrjWzIqk7vvtGkuW6sS+QfQAs4jJdnUDSYDk0v5CXo+cryQr7yu1b4meQIMrkDRVFXXm1XbKToigpY6ZxnDZBGFllOqz7jA7hMZLU1/tDZn5pyYCIno1GGH2YmT8Rkp8kouuC1+g6AE+N7+y8bFsclVi7t2hgPabAHiWM+imJn972Kuoseo166usTPNZF+1yhd3NyCG9Rn6CyhMMcbdWG15n1qBC7NQgkPabZKd1475wczQV4IRQuhMvsw+syNi2th6jzHinb4KXSniJA1Wt4lJrr+XBVr9wouWcg7T1JIwVSV2MskGDlY3+9aIul0IIUP4jFkKVBsmJKihdlo0VOIqQGCKXIXqVD2BZFk7adC6suPW1bwieX3iOIisIqI4o6G5lf2s7sy3t5yl4iJXTaNLXIiOxXlTBSZbo+ZYRRBAthNwczzlPUuIg+COAiM79PZN0H4C0A3hPePzVLgzNweuJoqijqs9m8MBomRhIXfuFCd9IDX5O6RPle28HVj+IYizrYnqBx9xMNWZhhqPeoOIaB4XVnK5Cc80OH1ynv0CzhdQVPESDFEEw7KZCa8Dpp1woWJZCC66UokNq2tUCiZixaILX1wSjTpOXEEod824vUiRqjrBynFjyWNynqixZDhp0plDKiiHINQdVv2U2h8NXU5z3KiaREcMj8gliaXRS15VTZJITOqD/1HCmhM4MwSn4r7lmZTobTUf3KcfXMV9+tAN4M4EEieiCkvQuNKPooEb0VwPcAvGGuBqdyWuJokjeor2zpG8NOnrpMNzBBGNk96i0z6D6jyANU0z4meY2KfRmY31//pOJHpc8jdKh7mnLeoyYvH4bnAonBly7NXKezWpjBOwZd2AF0IcmbJbwuiK44H7A8RYAUSO2VGolyqUACAJYhejxCILUOKeTEjiGQZH9lnV1aSSzZizVEZYUIMgWRaKzblCIplNFtDPUaZcWSZav6pe2i3Yp5rGpqsC45SkLJEjgyPSOIirYwbDNCprSdiibOl5H2UbmyMMp6mGqFUduvnDBS9xl1wmjm1ermmqeY+UvIX+G9cpZGZuY0xNFUb9FYYVQot7gwStLKQsQUE2PF5ESvUa6ZMSF1UV0DxeBUmGn2+vs9Rn1hbPHCDMD+uE31HpWExBwCrUYgJe1mBBKAyQs1jKadGJ2zohNIwdPTeY86Ax4fXkcXUpvk/qO4Hi2QGi8OxflCbiTLfM8okKwy8t8wt1iD7TmCyOcgLDJeJKuMIZJgpEc6sRVJorJEv1hCSTWeu+8osRV1AvnrjanTT7Z8QRiN8R5ZXqNJoijkjfEWlT1HHKftVDlLBA0RRp1NKoz2xyUjjObmzOep1T0EloheQ0TfJqJHiKj/gVBTvUV9F/kDhVH2wa65ujYijMaE05XskmXASx6lAn0enrU93yj3MFcrfcqDX5vyh/n3Lj30tbb9S0zRA2KB/SINNXXnbMwHwGb+ySzbps403XpY7CR4V/dyVsngeUqfy/DgVt7tYMX2mw+H1fH/zMJG2Bvt6AfBduNQ6Xq5YPngS3lR1vsrN4wLwx3vp0HrYjKT1l2EygtUdZN7EvqUbHNXz74/ovzOrotUPbKOrgzC9KXrVXZRnbvUPirTbu8M213cHyhb4gmvXabdTPtJmxXjyh1HPS7C3t58iG7p3PWeZ47qSMqYnytO2sh+bo3Pf1e2IIysBy7HgswQRi07UX4uznieWpXniIguA/C3AF4F4DEA9xPRfcz8reGVTc0vfMAKwmhQXSsQRnYHdH/ydZTESemBr1OYKniWXoxhLoZ4Y0oLM0R5Fd6jUt1Dwut0G007w8LrTBtr+e5M/4eG2c0BA+Az/kVu64yZp1qvEe8uDA+viy6ARIhdEjJXuP/I8BRF+SGcDkBsF7XR/EmW+SYKF7N1HiRcECvUYZ/fNqHTuvQQard3rmTC7EIlbV37ejlsl0Pt2m0wksUS9H+ttKMuAYlGpf3A+hdgkOm6vDwgyFxz5L5ajPK1mNOMTpMfK+5JN/K1h8i0j4RHamPZa/Fhp/fVVwijU/nFtB5h1E5tg4RRJKbmm1fOfZ5alTgC8DIAjzDzdwGAiO5F8wTdYeJobDhYZ3Oiwshsb+i3ZCmvrq7aB8tSJn1Q/QNYyzLeFkPD5Q7+3KQZw+vOTiC1v/Q7W2XSPDU8vE59Sep7kLSYMu8/IrUff88yxVf1UiB11+zUqoMZBBLQLdTQiqFoWe82retjei9SJ6IYANUt1tBsx89FKokgrSeKIkm114khbZsRRVmxJDugOkVWR3MMmRJKttblSJ8Y0uUygiiZtgrCx9wv2nNiWxJWrSCJ7I0wuqQ+Ky33cNcuTQgcdawsYbQ/PkoYzeo1Ou95am3i6HoA3xf7jwH4TWlARLcDuB0ALrv6F+LSk0Lsej5UhbIHW5EuV0eVMOq3mTWcLsnjKrspyHrH3G9UwxJepjkXWMh5bg7pPSr1YWj/c2UOIZAA+z6kQwgkX5Bh0wyap67AzwOc8RqVVq/bcXz/0b7y/ba6vyi6/8i4P8kSQoAUQ/t6taepKzuHQCLs70Nq60bbTix0gLgsXWoyB3uRom0O2xTZd8fDEEGR8BLqS95HJAVOUSgJu6JY0o0rG5kWMWa+q/hKzooXKz8nmKw0TtOKIkjvF9KKCy7ktoFUwOy0vb3wgqyvKIxk/1RIasljtB/TAYVR240znqfWJo56ncThqbt3AwAR/dd//sEf/QTAD4/Qt2NwDU5nLICPZ82c0liA44znl+ao5Gn8z2c/zx+7ptL8lM7RqTB4nvo8f+wnYPxw3tWkFuWUvj9OaSyAj2fNHGssk+eqc5+n1iaOHgNwg9h/AYDHc8bM/ItE9NW+J/NuhVMaC+DjWTOnNBZgW+Nh5tcs3QdnEmc9TwHb+n/r45TGAvh41syWxnLu89TaVqu7H8BNRHQjEV0O4I1onqDrOI7jOGvA5ynHcZwTZlWeI2Z+hojuBPBZAJcBuIeZH164W47jOI4DwOcpx3GcU2dV4ggAmPnTAD49oMjdh+rLApzSWAAfz5o5pbEApzceZ8Wc+TwFnNZ4TmksgI9nzZzSWE4a4kM8WddxHMdxHMdxHGdjrO2eI8dxHMdxHMdxnEVwceQ4juM4juM4joMNiyMieg0RfZuIHiGiu5buzxiI6FEiepCIHiCir4a0q4noc0T0nfD+vKX7mYOI7iGip4joIZGW7T8R/Uk4X98mot9dptc2mbG8m4h+EM7PA0T0OpG32rEAABHdQERfJKKLRPQwEb09pG/u/BTGstnz45wHPk8tj89T6xwL4PPUWsfiAGDmzb3QrBD07wB+GcDlAL4B4MVL92vEOB4FcI1K+ysAd4XtuwD85dL9LPT/5QBuAfBQX/8BvDicp+cAuDGcv8uWHkPPWN4N4A8N21WPJfTxOgC3hO3nAvi30O/NnZ/CWDZ7fvx1+i+fp9bx8nlqnWMJffR5aoVj8Rdv1nP0MgCPMPN3mflnAO4FcNvCfZqL2wB8KGx/CMDvLdiXIsz8LwB+pJJz/b8NwL3M/H/M/B8AHkFzHldBZiw5Vj0WAGDmJ5j562H7aQAXAVyPDZ6fwlhyrHYszlnh89QK8HlqnWMBfJ7CSsfibDes7noA3xf7j6H8IVwrDOAfiehrRHR7SLuWmZ8Amn82AM9frHfjyPV/q+fsTiL6ZghnaF37mxoLEb0QwEsAfBkbPz9qLMAJnB/nZDmVz6HPU+tn89+DPk+tcyznylbFERlpW1yT/FZmvgXAawHcQUQvX7pDB2SL5+z9AF4E4GYATwB4b0jfzFiI6CoAHwfwDmb+ccnUSFvVmIyxbP78OCfNqXwOfZ5aN5v/HvR5qmNVYzlntiqOHgNwg9h/AYDHF+rLaJj58fD+FIBPonGpPklE1wFAeH9quR6OItf/zZ0zZn6SmS8x8w7AB7B3eW9iLET0bDRf0h9m5k+E5E2eH2ssWz8/zslzEp9Dn6fWfc62/j3o81THqsZy7mxVHN0P4CYiupGILgfwRgD3LdynQRDRlUT03HYbwKsBPIRmHG8JZm8B8KllejiaXP/vA/BGInoOEd0I4CYAX1mgf9W0X86B16M5P8AGxkJEBOCDAC4y8/tE1ubOT24sWz4/zlng89R62dz3YI4tfw/6PLXOsTjAs5buwBiY+RkiuhPAZ9GsCHQPMz+8cLeGci2ATzb/T3gWgI8w82eI6H4AHyWitwL4HoA3LNjHIkT0dwBeAeAaInoMwJ8CeA+M/jPzw0T0UQDfAvAMgDuY+dIiHTfIjOUVRHQzGlf3owDeBqx/LIFbAbwZwINE9EBIexe2eX5yY3nThs+Pc+L4PLUOfJ5a51gCPk+tcyxnDzF7iKPjOI7jOI7jOM5Ww+ocx3Ecx3Ecx3FmxcWR4ziO4ziO4zgOXBw5juM4juM4juMAcHHkOI7jOI7jOI4DwMWR4ziO4ziO4zgOABdHjuM4juM4juM4AFwcOY7jOI7jOI7jAHBx5JwRRPQbRPRNIroiPPn9YSL6taX75TiO4ziAz1OOswb8IbDOWUFEfwbgCgA/B+AxZv6LhbvkOI7jOB0+TznOsrg4cs4KIrocwP0Afgrgt5n50sJdchzHcZwOn6ccZ1k8rM45N64GcBWA56L5Zc5xHMdx1oTPU46zIO45cs4KIroPwL0AbgRwHTPfuXCXHMdxHKfD5ynHWZZnLd0BxzkWRPT7AJ5h5o8Q0WUA/pWIfoeZ/2npvjmO4ziOz1OOszzuOXIcx3Ecx3Ecx4Hfc+Q4juM4juM4jgPAxZHjOI7jOI7jOA4AF0eO4ziO4ziO4zgAXBw5juM4juM4juMAcHHkOI7jOI7jOI4DwMWR4ziO4ziO4zgOABdHjuM4juM4juM4AID/ByuPKG9W0885AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14,4))\n", - "ds.xc.plot(ax=ax1)\n", - "ds.yc.plot(ax=ax2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the variables `xc` (longitude) and `yc` (latitude) are two-dimensional scalar fields.\n", - "\n", - "If we try to plot the data variable `Tair`, by default we get the logical coordinates." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:20.567749Z", - "start_time": "2018-11-28T20:50:19.999393Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9eZQsWX3f+fndGxEZmVmVVfXqLf1640GrF2jUgAy0AYMQAgkEsi3LliV7ZHtGHh3J5ox88MjCkmcky8tw7Bmdo7Et2czRYstClkaSR0gIdECAQYCBZmvRdNMsvffrt3WtWZkZy73zx10iMivrvdfd9WjU5PecOpUZ643IiN/v/rbvT6y1LLDAAgsssMAs1NM9gAUWWGCBBb4+sVAQCyywwAILzMVCQSywwAILLDAXCwWxwAILLLDAXCwUxAILLLDAAnOxUBALLLDAAgvMxUJBfJ1BRK4XkV0R0U/3WBZYYIFvbCwUxNMMEblfRF4bvltrH7TWLllr66dzXBeDiLxZRO4QkYmI/Oqc9X9XRL7sFd17ROTq1rqOiPx7ETkjIo+LyO+LyDWt9adE5AMisici97TvzQFjOXB7cfgpEXlQRLZF5L+IyOAixzopIu8UkUdFxIrIqTnbvFZEPi0iQxF5SES+74BjZSLy2/73tSLy6pn1Py4inxeRHRG5T0R+/Mlep1//N0TkAT+u/09EjlzkWB0R+WV/Tx4TkbfMrH+hiHzKn+tTIvLCi41tgWcuFgpigSeDR4F/Dvzy7AoR+VbgXwJ/CTgC3Af8RmuTHwNeBtwGXA1sAv+mtf43gM8A68BPAb8tIscuMpaLbf+3gB8EXuHP1Z051ywM8B7ge+etFJHnAe/w51kBXgh86iLH+xPgfwAem3c4P7414PXAm0Xk+y9yrAOvU0RuBf4D7lpPAHvAL1zkWD8D3Ag8C/g24B+JyOv9sTLg94D/7Mf2H4Hf88sX+EaDtXbx9zT9Ab+GE0ojYBf4R8ApwAKJ3+aDOGH8Ub/N7+OExK8D28AngVOtY94CvBd4HPgi8H1XcPz/HPjVmWX/J/DvWt+v9tdzg//+i8C/aq1/I/BF//kmYAIst9Z/GPiRA85/0e2B3wZ+vLXu5cAY6F3iuhI/5lMzy98B/LMncZ8eBl59iW3+b+DfPMnr/JfAO1rrbgCK9vYzx3sE+I7W938G/Bf/+Tv8emmtfxB4/dP9viz+vvZ/CwviaYS19gdxL993W+dW+lcHbPr9uNnhNbiX/2PAr+Bm6HcDPw0gIn2ccngHcBz4AeAX/AxzH0TkF0Rk84C/O5/kZYn/a38HeL7//0vAK0TkahHpAX8TeLdfdyvwVWvtTmv/z/nl83Cp7eeNpYObPT8Z/HkAEflTETktIv/5Yq6cy4WICPBK4K7Wsj8Qkbf6r5e6zlv9dwCstV/BKYib/LHeKiJ/4D+v4ZT25y5yrDuttW0Onjs5+DdY4BmMhYL4s4FfsdZ+xVq7hROmX7HWvs9aWwH/L/Aiv92bgPuttb9ira2stZ8Gfgf4q/MOaq39e9ba1QP+bnuSY/1D4PtE5DYR6QL/O2423vPr78UpxUdwFtBzgZ/165aArZnjbQHLB5zrUtu/G/i73n+/AvyEX97jyeFanKL+XpySuZTL6nLxM7h38VfCAmvtm6y1b/NfL3WdF11vrX2btfZNrW2Z2f6yj7XANxYWCuLPBs60Po/mfA8v/bOA29uWAG6GftXXZphgrf1jnEXzO8ADwP3ADs7NAs7FlOPcZH3gd2ksiF1gNog88PsjInf5wPeuiLzyUtvjYiS/gXPT3QV8wC9/WERe2TrWXVweRjhlfa+1dhfn2vmuy9x3LkTkzbhYxButtZMDNrvUdV5q/eyxwvqneqwFnuFYKIinH4dJp/sQ8N9mLIEla+2PztvYZxPtHvB3uUJzH6y1/85ae6O19jhOUSTA5/3qF+DiFo97gfhvgJeKyFGcEH+OiLRnqy/wy7HW3uqvZ8la++HL2N5Ya3/aWnvKWnutX/4I8Ii19sOtY12u++RODvH3EpH/CXgr8O3W2ocvsulFr9P/f0HruM/BudLunT2QtXYDON3efs6xbvNur4DbWusX+AbCQkE8/TgDPOeQjvUHwE0i8oMikvq/l4jIc+dtbK39kZaQnP07UGiKSCIiOaABLSK5iCR+XS4iz/cpptcDbwd+3gsmcEH1vyUiKyKSAn8PeNRae95aey/wWeCn/XG+ByecfueA8V90exE5IiI3+LE8D/g54GetteYi15bjhCtAx38P+BXgfxSR5/j4yU/4e37Qsdr7Z36M4tf9TZwF8jpr7VcPOsblXCcuYeG7vVXUx7nsfncmZtHGfwL+iYisicgtwP8M/Kpf90GgBv4XP/43++Xvv9gYF3iG4umOkn+j/+HSQR/EpXv+r8zPYvq7re2nMoeA1wJfbn2/GXgXcA64gHuxX3jIY/4ZP8b238/4dau4mfYQl975fwC6tW/IwDrrr/lPgJe21p/y1zzCZWG99hJjOXB7XJD2i7i0zweAt1zGtc1el51Z/0/9vT2Hy0Jbu8ix7p9zvFN+3X1AiXPphL9/39r33cBPXu59Af6Gf46GuDTVI611Pwm8u/W9g3O/beMmKG+ZOdaLcOm7I+DTwIue7vdk8ff0/Il/IBZYYIEFFlhgCgsX0wILLLDAAnOxUBALLLDAAgvMxUJBLLDAAgssMBcLBbHAAgsssMBcJE/3AJ4Kjh49ak+dOvU1O9+jn/48iYAIpCKIcqnixlhMK9avpUmWtzR8D0r7na0F26xDNSnnogSdKHQnQaUJooS6KLGVwfqdRARJNCrVKK1BBFNWmKpGJRqVaEQJ1rrTgT+lMdjauG2yDNIOohQo7cYSsj+NwRZjNziduv0nI7CW2p/H1u5YACpLEBGstW7f2mdB1BZTG0QJpraYyiACKtVkyzk6S904AFMU1OPCndOCqSussVgDGAsC1ljSfof0yBFIOlCOqXd3qMeTeB4RRXP3w31t/ThKuWsmngqMGy/WJRq5xA2/tvVD2vZ3f0/3fWmXD4RlNmQLTg9lCnLQOjv3IyJ+H4toRb7WR/WWwdbUwyGTzSH9m24+4GSw96V7UZlClG5+Oz9ea4z/3roM/xuIEsQ/4Ka2U9dYlzWToo7vwvEXPX/qnFt3fiF+XrnteXPHtfm5u1BKQAm2NlQGamsJecntez5VqcHUUNxvBSgkbveImZy31l6M+PGSuE66dsyBWdJTOE/xR9ba1z+V8z3d+DOtIE6dOsUdd9zxNTvfz3S/ibVU09XCVXlC2nEtG4ajilHdPDQrqaYwltpaausURlcrOssZOtXUZe2EaG0QrdBZY8il/Yyl4z1Wn7NO76p1kjxj56EzTDaGmNpgjUWnmnx9me7xNbrrK6g0YfeRc4wvbJGvr9A7vobOs3h8AFsbyuGIyeYuveNr5NdeR3Ly2Ui3D/1VrCjUZAjWYMdDygfvBaXRa8cBmHz5Tmxt2HvsAntnNym2h4w3RwAMrj9KkmdU44JqOKIcTpyw2Jow2hiTdBMm2wWj83uoTLN8conrX30zg1Mn6Vz3bHf8h+7j8XseQKcJdVkxvrBFNSqpxhXVqEK0ohpXnHzxKa7+/h/AnrgBeeQeNj/yfjbufoDJ9oikm5L46wamrj0g6XdJ+640QZTCGkM1LjBFiSkrbG2oyyquC/sGZWeNdYJx5rjWLxMtU8uM/53r0lAXddxuFqJl7jrTPkdrFqJTjWihLmo6Kx1u/msvp/8tfwEzHrL9yY/yld//NNWo4hV/8uG557vju76dpauXyZZ7qCyN1w9QDsfURU1dhms38TdIugmdQQdbGybbE+rCoPw4th/e4b6Ht9mt3DiPPbDH3zjXKIV3XddibzlT8MaH9tN9/derbqXbz9CZYrJVcH5SsVsZRrV7nwp/D7QIekZB1LZRJmG7vlZkSqit5R/vffmBuTfjCWCM4Xs5eVnb/gceOPpUz/d044opCBG5DleQcxWOsfTt1tqf9+Rmv4nL674fxza64ff5x8AP4Qt1rLV/dKXGF/CTnRsYJE6QbFcGLe7hA/iZ0Zf3bV9by5HMKQdTW5R2D2qmhExJVAyZktZDDZny22bKvVBljakboRBmtUpLFGzVcMxkc5dyON6nHLJBnyTPmGzusH3facabe6T9DGsMOkvI11fQeYYpqijoogAsSmwxpnzkK5idDawxqLyHXll313jhMc5/9l7qsqIeTxhvDKnGVbwHSZ7QPbrM8WefRKfNIyQ7e9i6ZuO+xxmeGTqlMCwojKWrFd3VDtf++Wu4/jteSvac5yNZjuovU515iPN3fpnzdz+GrW0UpO4eWXSqWHvOKs963W1u/OceQXY3efwjH+bC5+/H1Ia030FpFZWi8uOyplGSOu+Q9nJUlqDCPR4VKKWwWiP+PoVras8TbV3730mcJGJaAYn/3ZSXWk6JmLit2172KQKZkXK2tlPLtNZT60xt4thFi79my/Z9p0lXP49eO87SLc+j+q1PAPDhl72CV37sI/ue4xf/4R/zide/hsG10L9qHZ0mVOOCejyJ48v6znqsxhV1YdCZIl/torTCKEOS19RFwXjb7aMyzYk8RU8qMiX7zvnGh+7kfbe+hMn2QYwi8D2P3cW7T70AUQmdlYwjm+5d2q0Mu1Xzi2RK0OIEf0BtoTCuerPAooU4STtALz9hCOxTTAfiGVBBcCUtiAr4h9baT3uKgE+JyHuBvwP8sbX2bZ6t8q3AT/hK1+/HsUZeDbxPRG6yX0eNcxROeRTG0gd0pt1My7oHNlWK2ppoNThF08x4kjzxQsUgtcKMiihklBZU5pRONa4Ynt2hGhcAmMLdgiRPSPs5Sd5B5xnF9h7n73qQvfN79I72yNdXABhd2EalCYHAP7iDRCvSfk49Lhg++DCmqBg+9jjVcITKEnpXrdNdX6EuSkQrzF4ZZ78603TXl5zF4wVtkmfk3oIpd/YA2Lj3ESZbbmYpWlhe75EtpfSP91n7pmMcee4p9NpxygfvpdzeptgeUo0L9s5uoZQgrZlx0k0QLQyuHXDshTeydMvz2PnC53n0Pe/H1jXFjrNIOv1+vE6nHFJ06u51XVYopZxSSBOyQS8qY1NWqNpgjcEYA6Vzl7V/b6dQK1QGFG5Gr1M1ZUkkeWsfrdw2SqgBnYGtG4livDKxtSXpeiUWpJd264OSCIqgvS/ukYjrVVchWth58CyiFd1jZ+ieOMZ1r/wmHvjgPqaNKbz0Pe/nc9/3BrLlEdmgT7bcQ1aX0Plu3GayuUNd1H5yo1FauWfWK6pqXDE6P3LPblGjM8VSfXBoU2cqXve7T72AN9z/uX3bvOH+z/HuU44JJO1olsBPtJr7+JYdd23/duXm+L6F2ziqm4meUyJMKZKnAoG5ym8uvm4k15PHFVMQ1trTOM4XrLU7InI3jq76LwGv9pv9R1x16E/45f/FOn6e+0Tky8BLcdTWVwxaYClRnOpnbBQV9w1LSv8w/W/5Dfyz8Vfitm7W4vZRmUanGlsbtzzxs8eRoTA2WhLB1FUi/sUnKok2RAs6VSitKHadFJhsT0jzBOOFSb7WJ+l3o/to95FzDM8Myfopy9esRQFpa0OxvYdKE5TWVONJdB/UhbcExs7nL9oJT1sbyu09FwcAyuHIWR21oTNwsQqdOwaKIHyTvOPiJFmOSgvqsqJ3fMDaTdcgSlHs7JEt98jXB3RPHMMUYwBG932Vx++5n9H5nWiZJHnC0tXLVKOSclg6P7RHZ3UZpTW793yBvdOPs/vIBUxtSfOEtO/GJMophiTPogUhWpHghLZ4JZHknegaChZVdEmF2ISftUvLIimHbuxBAYgSFM6iaM/owc36g9B3MsK7Epm2GJTy1mLauKuS3P0WxluLQPPdH7dtgSR5QtJNMLVh+77H2H3kHGs3jVm+/gRLJx454KlvMN4Yo9MtkrxD7+SRqeue/Rzg3KIJ9bh0Y+i6Z7Qua+qi2favntlP3zTZLtCZohpV+9a18Yb7P8dvHn+edw/hlYCQzeieMAlru5y0qCmlcFjWAwQL4nJNiD/7+JrEIMS1bnwR8HHghFceWGtPi8hxv9k1wH9v7fawXzZ7rB8Gfhjg+uuvf8pjCwrgj276Fm5+zjGuPTPkM1/eYKN0r/a/6N3IT+19CXAKoquFQS8l9bPGpJugMu1cQ0qxnGkmO4U3ib2prmBY1aTjCl1bN2OtLeWkRifOR53kiZ+dCVrr+ALVRY3ONNlS6l7MNEFlCeX2HuPNEaKF3tEe2aDf+M/9LK/aG5P0cifgNsdU4wLdmkWLVmRe+NnaoL1wHV/Yxhrjl7trSPvB+mlm6nVZUu7sIXpMNZpgioqla46x8sIXkl5/k3NfVSV2uO1+u70dJo85IWaKis6gS/doEgV7XVbOmtGj6F5SWkj7zi104TNfRaUJ/atWo8KTKPzdMXSeRSEeFQGglRN01XgS4wumrKjHTrE1AlE7BePvj1XGu10awRdn9q2u4W3XUVAC7ZiB0oJBoWiUeNJN0Jk7iJmRYsFqVJn2VkywAsNEQ6bjHcZSjAtkrNi49yGWrztB96hjNb/ju76dF//hH899/m9/7wf4xOtfQ9rfcvfOTxZsbUj7OdpbVPV4QjUqnIsr3PfWGEzhfi9ziZn667/yGd596gWo7NIt1//62S9ccpugBMKtWEkVtXUKY6s0MTZ4aEJdnoCL6RmAK64gRGQJRyr2D6y123LwDzVvxb6nzVr7dhwBHC9+8YsPbW7w8Pk9TnzzMY6++gaq8Rf5yP1bpHPGWluoC0Nd1nHGaWtLXVt05vy2Sgtb5/ai2VtbGNWW7k6B8scc+wc3qww6S6PPPdHNTxJcClk/I8mTOIMvt/co90ZMticordC58xUHAR/iDaJVnCWLUpiijMcWrUh0hkqTqViF8T74yeaO367lHilKrDHgZ+GTjV0KvYfOkih0985uwmc/y9KF0+iVdaQ3oHj0ASabO+g0Zby5g2hF/5pjU/uZ2iDeelFpEgW3ThP6V63TOXkNK9tD0n6XpJ9TDccx6B5ccW0orTAQYwppv+vvaY01hnpcUI2a/YJSDYohKJ6yHLeC/dMz6VmFEOIQbl3tAsnKUAOigaLG+MzyecpBtSWPVwwBOlPYWlzgOGvOb5ULICstMe5RjSp0egGA3UcvzdL90ve8n0+8/jWYsopuyno8YXTOBfXr8aR5Poo6KkhbW7J+yvDMkNGGt7BabtWD8Ib7P8c7Tz7/ottcLt689UV+fuDcTF1//7paTVkPhynQFxbEIcKzdf4O8OvW2t/1i8+IyElvPZzEkbaBsxiua+1+La738dcEj41rzvzpOfK1Lse/+Tgv2Bjz5d1y7rbDqkaPKvK13L20hctQyfopnUGHYljuezC1uMwKLZZUqegjTTuarJ86gZHqKDTcSx+yRjKWrjmGzjMmm7sU20NGF4YAdAZuxlwOx26mnSZI3tjh1vvYg+vIZTO5bXXugtptKK0wxkTlF2BqgxmO0X6GWXmXSxCm+XKfcjhmePpxzn3+EZT6AvlaTu/4CqI1tq7JBn1UmrB0zTHya6/D7GwyeXwLU9fRIgAwSpH2u3RWl1h61jUk196AKM3yzT4FczIiS9LoalNpMqVswCkZlXp3SOq2BWBcTIn5oCjbwji4qOa5n5jal5bycNvobHo/5RWCNRarJRYeJXkSs4TUHAmmtIB2Ma5Z6Nbs2xgLpqYuncvKeKtl++GtKSV0MSsCnJL46Le+is75ETpTLVfRhk+caCyXcuwUUrFbuklNntBdyymGJdVofoC6jaAc/uLpz190u8tF7dOSC2NjokhA43Y6HKH+hILUzwBcySwmwbWXvNta+3OtVe8E/jbwNv//91rL3yEiP4cLUt8IfOJKjW8WP7X3Jd7WvxH1kYd49rffwHPfdCPFO10g7G39G3nr8Eu8Zede/u3KzYxqS79wgdvExwiC+V8MS8rd0r8k7kkKWTzB9E26CXmeuIyjVEflYGqnaEQLKlNxhqozTbEzhJ0h1aig2BlTjSo/g8vorC5jjMH4+IIixAgyn6LYzJRNWZItH4lKI+nlKK3RqbNCip0hSu0XeG1ftK1rktWlqHxcBoyLcyTdlN5646svh2OSrhtj/6r1qJTMziamKlFZQrXt9lVaTcX18vUVsufcijU15YP3snvfQxQ7e4hSZIMeab/r4go468lZYgbjM46U1tGqcuP211E6xR+WB8z62sM2op2Yn5f93s7iUkFJaUOCDzhrZwUa3PMSnhWdaerSZ5fRJCoEl2IzpsZKCcoixGeMmXFLGRuVRIxpdBMmWwdnDbXx8v/2obnLP3T7y50Fm2l0qqZSdsUHr+vSwLCMAeiA99zgmh2G7dsp3b994ta5cYonirfs3Msvrt4ChElYk/LaxDAOy9kgCwvikPAKXHvGPxWRz/plP4lTDL8lIj+Eoyf+awDW2rtE5LeAL+AyoP7+1zqD6a3DL/GLq7dw9OFNukd7rCx3+Oxju1PbvHnri7x97RaGVU2+W9IZdOif6DE6Lz5Fs0K0sKIT6spQW8vABxvHtUGLkK/lceZf7BZYY+OsbF4u/PDMkPHG2KV8Zgqd6Rj0VJl2GTjglMS4cAJTh7qExkWS5B2q8YTaz9aV9jNuHVwdtR+/Twv1mT+kTbqorQ0qS6fGN9ncjYJ05YZrSPs52XIfawzF9tCl3HZ7mGLsXBW1oZ5M/Czf/QU3kShnwShgdG4DueuTjM5uML6wTbk3whTVlOUTgtH1uMAa4zK8QmaYX2fKKipPIAbf43fT5PsHGNpxCX8/WkHrgLb10AS3tfvecu+5zxZRBttOidU6upjC/6AkZGYmbkyTAqszjW7tMxUj8fuFOFYQ2h9/3bdx+3s/wBPFqz7+UT744peR1pZi10ylvYYgeZonlC3h/7q7P3Xg8XSiGM2xjJ4KgvUAzGQRArhU88OAwFzX8zMVVzKL6U+YH1cA+PYD9vkXwL+4UmO6HPzo5j385vHnsbqaMxoWc83lEFeoxhXFbkHvaC+mvE62C8qhE3baC1Kd+epd76fVqSLrN26N8JK7imMDdTMDD9uXvmAs66dk/Qyd1YALWpuipByOfTwiQ3o5pqhi/MEYg/bZSspbDrY2dLwVQOqUQ7U3doHbsiLpZk2MxTRpsp1V19RssrlLkmdRwCfehaPzjO6JY+hj1yBa0xluo9evQpIMs7uJLQuk20fl/Xg/03OPoO//CtV4QlHv+Vm1q1HYuPsBqvGEJO+Q9rrUaeVjCq7YzZTuOo0P0Buv4EIdBCVTVkVULD5GEWCNmQrQxpRZpbBpilV1VJLtbKewzSyMdgrDlCUSLK+WNVGNyviba9UEtf0wfWGaxEmBO48wW1iptfiU4kZ5tZVYmHQUQ3e+j7/u29CpitYMwJ/7/ffuG/8sXn3Hx/jQ7S+P+wQ3lM4sxqc0J3kyVS/j7pG4TLw8YbI9YeVZK86aeGD7kud8IvixbReLaCuGdurrZaemXgKyCFIv8NfPfoGfW76Jrt7/4oNTIr929LnexWKnXoog9NN+5tL/ijpmbCTjhGpUMdkuYh592F7PZHW4ILi3SrxJXxc16Yk+2cAFXMtxReKDr9YYai/kCl+TENwfMfCqVBTkST+PwqQuS0xROffV9tAJyzSdds3kis7qEt31FYanL2B2hlRAb9Aj6eUueDwYgDGId1epwRHU0iqqv4xNu6gTzwZRWJ1iOktQe0V68kaWrz5FdfYRzO4m1ebjANEyMEVFtrpEtTdm7+wGaT8nX1+h3N5jdGFrSjCaoopupwDlZ/ZBOTiXkYtRBOUSrtMq5xZqWw+aBNNysYX72g5mty0awClh5Y+r6qlnQ3yBpGmpKJ1pimHZEvBuG+UVQHBwJd0kBqRjnCM62vXUf/H7huMpJTHu8WTwqo9/lA/d/nIkTWKGVoyR+HBdkid822c+HvcJ9T1SG7KllN7RLqON8ZSSOyw0tQ+NQnAuJznUVNdvJBfTgqxvgQW+wXHHd8016BeYgxCkvpy/ZwIWFsQBeMvOvbytfyPgYhOzKIyrY5ilDXAZTYa072d2mSbNE2pfVyFaosVRl7XPXFLOldByNbj1ZqpwTvtj6bzjMx1H2Lqms7qMrWvGF3YoGZMt+0rhUDcRLAlPMWFm3CjuXBXFzp5zoyhXcR0yhJJuRtLLY61F0s3IjzjOp86RFaSTo9dPogZHkNRnCymNHQ2pzj2C+eoG2annwolTqGLkLAhRmM4SNulAdw3TX0eduBE92SEFpJxgN886cr00A6WZ/OnHyIuKdNBDJWl0G0GTrQVgiooyuIi8221ulpIxLqDvZ/oh1mK8JeIsKU+70aqVUK3AdCwa87GVcE5wVoQY7+rBu5iAmgrRoNAxkcBRaFRT9RAh3hBmcdKu8vZ1FQ7T1xbuR5InJDk8/9ffxae++3VxWWeQka/5rLMzQ54IRAmdlY5zgSlxFvSoGfdr7/rk1PahlsWgSPsZOtOUw5JycrgxiMa91NDehKSQtqvpqWKR5rpAxDzFEFAY2Cpr9G7ZIk4zlMMCY60vnBOyPMHWNgYMnU/YBfpmzWynENx+wRVQemVia8PSiT7d46sAZMt9suU+xjjBmK+vuPhBUSFax2rnEKjV2fRPHYrquoMVqvEkBpq17jRKJYUkz+isLZP0csqdPcrhiKSX0z22RnbiJGpl3XE4rRzHqiRmwKvJkOrR+6jOuWreeuMsytRU4z3sZIRaXiNdvwrTc8rBpF1Mbw3ygWcqVcjKVUgxAlOh9jbA1E455D3Kzc1YCR6uJxLs+T9KlzJrajNF4geg0zSK1dksJ1EN3xGtbWKWWIvLKRQcApEnKSyLfFDKTLmoRKtY0R5jBRCrs5ukgZDBRHwugoJXWqFTN8lAT7snXdyiWfa573tDdHcGEr7xxvAJu5s+dPvLXcwkVng7N1naT5lsu0nM+259yb79Kp8S3hl02Hl0l2K3pHeku0+ZPFWEQtZZIr/DnNGLHF48488CFgriSeJHN+/h7Wu3UFfNS1+NC+rCkPU8RbZxL+pkexIFfcx6CbPDOU9um0XT/XdEaGk/Je37ALQxdNcHmNowvrBN704jsnkAACAASURBVPgqy9efYHj6QjxPUA7twGrtq4eDsEu8pQCNbz0b9OKsO+13SZf6LtV0OPIzZE26fhTJcmxZYidj1GgbijEojSQp6BS9fhWqP8AMt7HjIdXp+926JKM6fR/lw19G9Qekz70de+RZiKmQYg8riqp/FJOvkSa5W6YSd7yqRDIXoK5Gk0Y4t2IJYfbfFDL6wsFWMDkUzIlSMUZhfKyAVpJWpEhPnUUGjQURq7i1ptYKVU8HsW3tLBQXnK6oaxfbsaqOFozOO5iipBjvOaWjw/gcn5M11gnlrKH/UOioDNv1CZHML47dMluh7e5PHSu1Z1N95+Gj3/qq+LmteEQLSeYymKyxFHPqhkJWXtJN6J/oc+4L5yn25tcXPRUEGpwgvMMsP1OHP+N/priPLgcLBfEUENgiTW0RHwhMl1wldTluzO5QswCBZE28YJGp6tvZ4GNAUCaT7YLR2Q3Hx5QmFNtuRh8EXTboR4URFYNuAtOBWiJQbjQz33oqkC1KORK+LHcBZ6Wxw23vbuqQDgZOORRj7HgPOx7ChcdQ/WWXndQfuFl4t4/V2vWWMI1Lob5wOgp5Ox5iN8+guiuut0FdQNpF1xOUzpwLShQoRfrsW6EuMaMhmJpuVVJs7Tj6jFqhIyNukwHWRrsoMASidZrG+oXE36+YyRRqS7zCqFsKwf0ujaWgyiS65EQrKq1d4kDL6gCXitwEovVULUk72B0C2ZL5zKXW7zVdk2Ji2nJwW83yKNVFHQv12tXb8yYns/jYa741fs7X8mg9KK+03DOfMegm7J0fsXd+FAPT5bDwBJUyxb2U9VJe/5XPXPLcTxSB4bXrr7Fd+1CYw/ExLQrlFrhshHTXyfaEbCmNxHrlsKCc1KQd3cQbfG57UA6z7qXgQtBKsK2iqKBYbF0zPOv8xYNroXPNseg2qX1qqq0N+epytBBUmqBDRbBxBXOBeqKtOKq9caMctPIFaDlq2bmz6o2zkYZBrx1HkhTjXUUAmBrVW3brOj1s0sEqBVWJHQ2xdY10+0h/gB0NUcUYOxkjnRy1ehy1tIodPg6TIXbpCDbrIdUETI1Nu8hkF7173imKpINaSrHFmHrLW0ueiK8tYDVM1T4EBPdTyHZq768SpwwBbFVMK5TakGhPDDjjXtIdT1qoNNLJp843RZSYNqnHIcPJ1Xz4rC8a5l2XemxiOm8Ye3xegvtKm2i9grcCWxaQ8edxBZgqVn+Hp6+h6Gjwide/Zup7Z9DxVB82pt2Coi4Ll1mXJyxff5zOI+dcpfWwdCnbqaYz6LiMvBYdyZXAj27ewzuOOXI/nWk6gwzOjxgVdYxFHAZkUSi3wOXihzfu4ZeO3IIWSOoEUQ2jZWEs9bgiS51SuNhsrb0uuAVCXUVAmIXtnN5FaaF/zTEn5Pt55DDSeUbS61LsDBmNXZ55qA2I7pQ0kAxmMVW0GhVx5hspOKoCs3WBcnfIZGMH5XtMmOE2qttHktS5UpIM1e2jllaRfIm6v47VKegEmQzR1iBphp04K8IAMnaKzta171ynsPkyqi6gnGBVAiJIOUKKPdRkBzEVthhBVWDrGrN1wSmgUDHseapqzzcV6hpm0abBmPNDNPc7yaAqIuVGU/swXSQnSiGd3BX8JBkq72GrEl2WU+m3dVmi0iS6woLykrKipkLrTlQM4Crek7RpgGTMdOrt1PWoGn3QNcVLayjK3ZjqGDcL+NR3v27ffiHBIjyjgfZbp5qsn0X3qUoT1m99NnAfj39pg8n2hKSbsHT1Utw37eeUB9DXHAYCMd9KrNrW6LI+5ErqhQWxwBPADz3uaiLS3RKTOUbLcetlrSuDrZ0rqR1LDC9moEpWWqbYP2df5IBqVLF7Zkh694N0jy6TLffdDHI4bqqJezkdLwhD4VjSzXxBWye6RupxEeMKpqxI+3kktbPGUO2N43pH9lchaoxNM/Sx446ML8uxOvP1DRqbdbFJjtUpShx1huTLSDHCbjyGKI1aXsNORtiqhKqgeuTL6OtuoR5c5S7SC2opx6jJjmtjqhK3z3jPWTRbF1w1dpb4moaGEsQU1VR1uGp9FuXotZXW7rtuOseZYuxdbE3dxFTR3QxEaTfWxBUVSm/gXHLeOkpMjTWOZ0rGvk7DKwnrO+dBy2WUtj77IsTw24i3OowxDdNsbUC5exyqy9vKz/pgtjWhB0lDUd6sd58/85e/I+4XLOFA/aGU519qBWeL3ZL+iT5LJwdMtkeMH98iG/ToHl+jc2aIaCHrp/TW+/EeBsr0K4XC4PqxjEqWyvqKzPRFFllMCzxBFMayXdZk/uUMHDDzYGrrKJ/nVN9CU1kbZntJN5myJJQ34bce2Gbvwojlk0ssXXOMzuoSxc6QuqjorC6RLfeYbDqakGzQcz0VvBsEpal2d6nLshFSrWycNpVFUBihYlqSDLW0SnLsGuqlY9hOH6szxFSuXWmIGwCYyvW5FoVNUueyMi44bEdD6q0LmM2zFA/ei966QPb8V2B6q6jd807RdJYwpkaNtpByRHXhMex4iBnuUO4Op8YFjh4DpmfYes7nJnOocUvF2X7LjROthqgw6kYphG3S1FlTSYrq9kEpMMYrjhQhRSeN4pKyij06NMlUvGQ2dpLkWWTlDZaP8pZgUBy2NtOFfKm3zExzzsbtVDSBbJ96GlxObZ6kMHmJFCCttGvRQhlSu8/A4NqVOFGpfIV+/0Sfzrgi7Wfeyu2SLfcodvZYedZgboe7w8CPbt7DL67ewm5lKYxTEEuJmmrc9VQhLLKYFniC+KHH7+FX158bv7cZJJVIE5huBaiBfa4nUeLTEV3fxJCf3w5KBmuiGBYUQ+cDXrrmGN3ja1RDV2lcjwvSfjemtnZWl0lWj2AnY2xVUO0OqUaTGI+wen/Gj619f4gwo1YalHLupU7u4gEAtVcCKnGpqaZCiqFTDsUImQydu6guo3KoN85idjax4yHFhQsuW+pED6nGqMcfwuxsoK6+EbN0DJt0EFNRnXmI6syDUWAmvdBX2o/N1KiUOAsP1wLsE/qi97uLgKkYxPQKJ/TF3wPRLSWhtG+d6gP33gXmjt9UNruZe4HKkuheCplUs9lPwboJY5SiijUUbQWiSGLld7AwwGVbBWr39rOj0gRD5btSmKbuZiYO4brgeeXgt3afPcW4X1cMC7Yf3qJ/ou+C/L46vxiWmKImX+0RqEiKnT3KYfGUKrkvByG7MFgTcLgCfRGkXuBJ4e9cuDt+/s3jzwOcJaEkKIcmsAlN3CGY8iHHXWkV+f7TLHUZUJ6jpwn0TXf5Gl/Yoh6fmCp6y7SK3P6628OWRSTLm2zsTGU5tX3bDSGfm11LlsdCtdBDWuV97GgHXbv+EJJ1sTrFZj0XfzA1Uo299eDfJv+y2uE2djLGbF3AVgXZ+rqzSK79JszOpstw6g9QvvZBqjFm8xxmZwNJMnSS0Uag9YCUQGSkE+MEtZ52t8RrnLHepC3s/fGca69ZHrOwvEKKx0gyxy3VX3bZXsV4OmsrpP0G5VI1PnjVypJqpyUDkWDQwBRHlG6N3eqGdLCdeSW1c0PVZeVZaJ1C0rph5203SQokgs1xm1qcRIvrdV4bJr73dIELepvCMKkndAYZad9xfOnUpb3WWuisLqPzjHJvzM6D59j46iblsOAPrv5mSq+0v+exu3jXdbe58fkeGMNWxtPSUhbTYi+XHlyL6w2xW02zux4WFi6mBZ4SQiesd558/lS2kq1tnK3HuEPt2FRDNzlTmxgEBGJQb3a2G9hAdaZdU5eiRGeuTiII+nSpj3R9v+bR0L3kvhFQaEdq6jq6V3SLf0m8tRD961nuBGFvAEC9sxmFoOoNUIMjbqZtDVKOQSkfm6iciynN3bqsjwZsMXZumeVVN/MeeZfRyjrq6LVYUcjWY1GRSN5HxQwjZ43EWIVS2KpsBL0fl/gYQNhG5loHQQk0FdsEV9K+bbywD59DkN4TDwYLLY5tysrw36M1oaYqtZsUY401zW8yj2Z8yirwy0xruVUGQ4UmoQpxllbVPECis6b9bOqU1WzwXmfaW6erFNt7jC9sMXxsE4DSxydsbZlsF3SPQjUuMEWJzlM6a33SQQ9bG8rtIRtf3WR4Zkg5qWPTLGjowA8TtQ1Fc26Sdqg9qYWp8T/TsVAQVxjBn/umR11z9nefegGBkdOgqMcVujB01zShEX3W970ZhmXLP91YHO3vSoljVdWayeYOKk3IBv3pWbIXktVwHCuklWcixSuIJO9MtZyUJHO1Cl5BkGRI4rKbrE9TBSK1hi0nuA4YI6hLl54KWFHYJI+WhE27aFOhK1fPYP2MWpIMSVPU4IiLVxQjV2BXFS6jqHUtoQajDfFPcqwjSMHWCjHTSoO2m6gNfw5Raq63urECGqXUtjimryWdUmDxGEphQ2zCaKfA1P64BqaOGVgNA2xjfYb4AjRKQYfOfOFcnuIjyTsuk40yjgF8p71WlpetTUyJdbdJkQ769K46gtKa7vqKa1WrNbuPXEC0MGkRDk42hoh2fdDTvqNlCTU3G/c9zmhj7EgrJ7V79ifNXT5261FnmewWlJ51VmU6vgfzmiZdDlxVtaIwNrb/feqYbvX6TMdCQVxBzDOJ33D/5+Zu+6HbXx6bzwdq5uBeakOnLYvE2KbpjO/lAMSCrXoyQSuNrYrYUQ4cDfmsq0V0U0ugktSlbgYF4TvCGd9bOgg/STMk77nYwnAb688lWe5mtta4YLNOkbpEyj3ndqIRonYydjNwpaC/hlUaGW27gPRkjF5ejULdTsZIt48tSx/wNtiyiIIZnLvI+omxAPix06Lo3hdnaLuMlD7Q0ghKAZjinIrnTlJ37iRzgeqgJKaUk0v7xdSNApvj8ppVAtFSqNupz9NKwn13bimpG3ejaBW/u+Pvd7O52EQ4hztW79gq2aBPsT2kHhdkgz6DU1eRLffY+sqjcfLTGWSxd3bSzcgG/dgbfHR2g73zIzqDDq++42O867rbXG3EeVdD0z/eY/nkEtsP77D98A5FWZPnCavPWqEzyBhtjOP78M6Tz79sN1OmhFQpjLUu5fywuJhkP/PyMxkLBfF1gkDnDY1bqR2QDMRoju5ZucpU7Xpgl3ujyEu0Lwhratff2SuIpOuLvVp5/TprWnJKmOG2lANKOWvA1FPuE8nyOLsPrpUoXHWKTTvOetBJjEGElFW1su7cX94iIOk45TDZpd44R33hMbdcaVR/2VVPewLAaM2Y2o2rPXOHKJSDK2quu8jMzErb7qBAY9GesbcC2KL9PUrSaPnEYyb+v6nB+Kyo1jmdklHYqlFgsTivLJxiaf0+7oEIu9f71/nxTafiVlifkaVb6bQBoY9F3N8Xzlndqs/wBZO608GaHcYXtil29ugeW2XpWleDo+4/7X9qN7GpRmVMbugdX0OUYvPLj0xNakKyRmfF9VlfvnqJ8caYzQdci9Q3PnQnEDidlkjzhM6gw/YjB/fW/rWjLkEkKIEwwRctFKEm6bDqIOTKFft9PWKhIL5OEPpaBxK4clxhijp2A2v4mZxZ32QzNYVh2XLPuZda/mxTlVP9nmOwVjmWU1O6IGngBoqWgafCwMcfXOqmy+aJAVwv7CTNkE7umgGFfUW5gjed+vTXBJIcm4Aq97DShbQL1jqXjggy2aV8+CuYvUYY2KpwSmJpFbP9ONa7jGwxBq8Q3PhaMQlT4/1ojbCeQVtcBOE/ZSG0LYOgEGPQ2t3bkNVEksUAedu6cj9kY7nZiibGkYA1er+w99vHXmit2EHoaNeu7XDEfyXtnhdSqymrQdWuRiVsr9S05YFS4BWJKAXjgrTXJVtdgiSlHI4p90bYHROrzjurS/SvWmf42AXK4SR2RJxNeugdX6N3tPk933D/5/jAi26nt96jd7RLZ9Dh8S9tsHS8zyv+5MNxu9fe9Un+6KZvYfVZK2T99EC//zuOPW/fsmA9FGXNqDbsVubQqDaQixe9PtNwJXtS/zLwJuCstfb5ftlvAjf7TVaBTWvtC0XkFHA38EW/7r9ba3/kSo3t6xkhSB3I1Jxl4V641971ST744peR9dOoIHSqqEYFpjZ01pbR/WXXc9kHaEP3uCl3RahpUBrRrewXpbzwSqOAi7EIQKrUWREt/7/oJnDriPg6LsAcspZ04qi70w426yLlxKWMVi2adFFQTai3Lrhgc/Dh46wDM9xG9Qeo3rJTHmF9CEBrDWkaYySxHFlpaH/3y2xVOgFcFa0hqOnAcvODNMqh5YZqu4XacQvxAWmbpM15ICpSZyUopxza+xvj7ovW3i2mXHxfmyn3EDhF0U7l1a0WsEE5BKujTcQYiuzCczCbxRaC2jrP6KwtuftZjKP1mS27YPz4wjajsxuUwzGmcJT3prZ0Bll81qrRhCxNSPr5vj7VxbCkd7RHvjZNSzKL77z307GLnbmIBRAae2VKphTBqLa+JsIenoJgvwX3TMaVtCB+Ffi3wH8KC6y1fz18FpH/C9hqbf8Va+0Lr+B4Lop/vXQTAD++e+/TNQTA9xr2JGjAVHeuD7zodt9u1AmxfC13LUgHfUfR7V0yKCc8Tbm/cAxAdzpOyFZNhlSoAWhiD6kXdi7HH5U4qovR0KdxGh8D8OyqOnVWg06dVaA0qASpK2zWdfuLii4UqzPndgozaj82FRRcC2Zvx2c9+ZgHICrHVmW0MNzOqnF5mRpJgTSN5wSfvprgFIVfFoLw8+Aym/ZbFu3AsvWCPbqTlBPu+POE8cTjgbM4TMvq8OOwIVhOgaWVpeTpUsLv1bC5TrcaVWEc4Xdv3crAvRWvLaRc+yp0Q4XK0lhD0VhK7nzpoEe23GP8+Ba7p7fiJCYkTpTDks7At7Tt55ETzLSCzO+54UXozLlIg0s19EqZh51HHbXMQS6iMJnPlKs5yr0Lq/ZWw6g2kTPtMCDCwoI4DFhrP+Qtg30QEQG+D3jNvPULLLDAMw8ffPHLDuU4//WqW0mfxln8IgZx5fFK4Iy1tt2R59ki8hlgG/gn1toPz9/1yiD85v966aanxYqIJGgt3v9ZJHmC8nUVWT+lM+jQv2odnWeREsO5XoybQWvXezlSUExlLempGap08kg2Jx13rFD7YDt9TNpDiUK8W8bWNfiMJfAWgUisf7AqcbN0nbh1SjtXklLYrAfG1UcAvm5CO0ulP3BumKqMs26M8daCq3WYcmnBdBZQmPWSxuC1bbujlAIfx5D+cmNdKLXf0ohxlla8YepHa2pGbDsO4X7Q6boMoyCMKQSrjW6qrgGbZC5+Ymr3WdXxNwoWQ5uhtp2y2vb7a1JqXVDP1D6EBIZ5hZHQWBJWa9d1sBhT7Y3decuKvccuRNeS0o512M6kXU+2R77DYVPFLlrYfMBlwOlM0VvvoTIVM/Dm9ZEICEHrg7DUSfxxtXs//DjKcYV+fERtfffHQ6uDkG+oLKanSw3/APAbre+ngeuttS8C3gK8Q0QG83YUkR8WkTtE5I5z584d2oDesnPvoVZbPhG897l/bur7vF4G4HPT8wSdqtg8SOcZ2aDn8uaViu4ZSTKXrtqOOWhF0uu67CGlm4yZWeWglCti6y+DVw4oR8RHkk0HbKcGqDBpD6sSxHqCvSR39BvVxLmUPFeT6SxjuiuYfNm1Hk270B1Ad+AL9JyLqy20Q1zFtpRHVBLQChw31CBh+f7UVtX8b39O0qZOYkY5hOM39B5+bNox20qaTQey0zQeU5Jset/WNtLJkU43cjq1026bjKksCvj2n9tmOp4wRdPRymprI1Zsz3a2y5LGbaU05XDEZHOHcjj2xXI7rmuiJ5MULejM/Q8z69GFLcqho5DvHlslX+tGWpnX3f0pRhtj/zyLT+Vu2sVeDr7nsbsw1nFHdQYd+if6LJ9cYnDdMktXLzkuqEEnxiYOk8kVcRmFl/N3yUOJXCciHxCRu0XkLhH5Mb/8iIi8V0S+5P+vHd4FPDF8zRWEiCTAXwF+Myyz1k6stRf8508BXwFumre/tfbt1toXW2tffOzYsSsyxp8f3HzpjZ4A3nXdbZFO4CC4PHLLZHvCeGMcmTY//LJX8OGXvQJoTFvXvrFL2utGBtakl7uAcddVTwfBo5LU9YXo9tD9JUdj0Vv2gqjtW/d++CCggi8/6zYCTVQjxGZ4i2ySOkUCqPEOMt5xtQ+mchaCqdxMuvbpsHUJddWKSfiKYlM5S8Gnf6r+ciujqhGswUraV7cwTxGEKur2/jOVzvu/71cOU+eYorzIXAzGIyqKJHOCPygbnz6sQnpw+7whMSDJYte9+N/HQSTJpug44vlaY3HtUH3co50mradJCduWgymrGK8KPUSAWNFtYn2N3Ve42VZOOtOuNmdcMr6wRTWakHQ7JHk2JTTrsibrZ+Sr7nkJfdyfCBzHmbvuNE/I13K6azlLx/v0j7sMqX43oasFw+E1DIKGEudSf5eBCviH1trnAn8e+Psi8jzgrcAfW2tvBP7Yf39a8HS4mF4L3GOtfTgsEJFjwOPW2lpEngPcCHz1az2wH9+9NyqHn1u+ibfsfO1cTcrTbITA3bd95uN86PaXx/Uf/dZXuUYoKx3Sfoek36WztuRagg4GMd1SLa1CVWD2WlxAEDvDqbwX6TfCIxzTW8Ps17jCMmuMm/Vb69haAVSC6vZj5bAtxuAbC6nRlttOFJgKPbwAwwuOpynNsWqEmuyCtc4d5f9LNcGWE1dsB7HpTsOz5C2FkGpLy3KIrqP92UeBtiIWnk0FplvKIN6H5lgHipO2cvCWhk3SJuAet2msgOAuwtRNhhKAaag14n5V4WojShekluCeihlZxApsmGawDUSL89BuptTGvGVB8FZ741hhX5cVKlWuf4V/RtstUd3wgxWiMWUV2YTroppyyyhvdeTrK5jasHt2D3AB7MvtNGesJZBfmtr1eA+cZp1BF2ssnUGHbMtly3091kFYa0/jvCdYa3dE5G7gGuAvAa/2m/1H4IPATxzKSZ8grmSa62/gLvKoiDwM/LS19peA72favQTwKuBnRaQCauBHrLWPX6mxXQyH8SC9+9QLYmbHGx+6M862DnoBXnf3p3jfrS+J273mzk8ARD6mdjcux+GkMGXpfMFpEovctDHgG9bEWbepsZMaMxp6Our2rNVnzLRpIappf7DUFTYxrhq6cumq9NccR9Bwx8+0E0eNsXUeGziNIPIrkaRuJm1qVyuhNRL4i4qxm6lOxlMV0S4dtYlxNCmsLZdRiBvE4r3W9zD+ttVAU1/QnMcL+8DWSqMoIoxxwrpdGxGUabiH1m3TVgzROmOm7sJ/DzQgErYNqb0hq0s1BX/ilTZKu3uIU5jaK5iYuWSCe2i/a6mtJOYpktkOeqGXSLtHiNEK0VWkCA89tJVXAC6bzomVajgmyTPnCvXr33frS0h88ZvOM1d53U/ZfvjgQrh5+IunP8+7rrsNpYXE+FqhVt1QtpzHMR12JfUTUBBHReSO1ve3W2vfPv+4cgp4EfBx4IRXHlhrT4vI8Sc/4qeGK5nF9AMHLP87c5b9DvA7V2osTxSHydb4nhteNNcHPIvX3vXJfctEO/rvEAh86Xvez+f/5hsxtSFJnd+7Ghds33eapJvRPWYid5FaWW/oLOoaM5wgahzpLUKznjjbDcHmsphumxncMdIIUhds9pXUqS+Em+y5FFVjmlakAVXprRQVhS3FeNp11Kp9mBL2Vdlyg03HFpoxBstneja8T9CH65mHdgB/3rJwn9KWa80Hm62oWCneruEI27j9WxxPSrtU2xg8Dwyy3pVVeetBKWyJ39YFuYPryRrju+v5lFr2u5SUUaCbHhOh3iUqk7abbKadqa0N5XBE2u+Srw9I+jm2NlS+aM4U1VQvkWA9tBsXhfWueLN5p3pHXWMhWxsmG0NsbVk+uTRVKDeLEKd73d2fisve+NCdvOu621w8RAnLVy/hWGhdD4zlk0ssPeAy6Q8zDnGZ7iOA89baF19qIxFZwsm/f2Ct3ZavIzLARSX11xCzfagvho/8hVciWuiu5dEa+ez3fqfva61iU5jgLy6291yRXZrQWVsm6+TgZ+ngax8AM95DMhMpqSVxQk209kVcTWGYpB2MKKcQrGnoMiDSYER4QSdKtfiP9NQMHbz7KMyMx442g6rYx5EUgrOxSQ9MK4I5GUWiW7xLxrToQVrCm/mKY9rVM6MYwrnnKSZfKR7gMq2a2M7UNc3eL6ViZbhbX8fljlMqcGx4y6YsprKdItWIv1aVNoFpgDq4fHyWU02FOuCVn2V8tcbEPtcqS+hftY41TmmMzm5SDkdTPb1jYyPTKKNwXICrb7+Ba//p/8P7b3up425SitG5DXZO71KO57vFwHGU9Y83z/G7T70AaDjN3vjQnfzB1d/MWAvZUhaLTEUp+if6HD/eZ+DpwnlynH/T90lkijrkEI6X4pTDr1trf9cvPiMiJ731cBI4e2gnfIJYKIg5qK19SvGHN9z/uWj+uupSG4uB3nfrS/ZZC+388Fff8bH4OdB+J7kw3hi7jJFUO3+wbzxTl1Wsli6392DgAn/B1WHxwtYTxFEV0z7v4FaZmfXbOrg5Eref7xYHPpBsM0QU1GX0v9u0i1iD6NTta81+gQmNcKyIPaaBSJ0Rz9/JoSybfQLmKIrg8gn/27EGxxNlmirtOZhVGvOC0lGJtQL71hcDIvsJ8PxGc88XAkBTqbBeYYiqG46mGQUblQRMU4yYGkrnigoCW3vLxKgaQ0Wisykro201zGbOiXIKoxoXpNrRsqj+AJ1vUg7Hft3E8UBlaazED0pa5xmd1SVEK4anLwDw8dd9G2k/JckT9s65vtUhjjCL9936EgbXLcfvK89aYe/8yHGQzUE1qphsT8jXckS5znsA3bWcI4/6e1zM3fWJQeanoD+pQzlT4ZeAu621P9da9U7gbwNv8/9/71BO+CSwUBAzeDKKIXSTazcNAvcg1wPZUQAAIABJREFUudxs90CF9L733/bSuI06IKdaZY72W2WatO9cMW3a49DIfrK5i1KKajwhyRsivki2N3VQR5Md+X58vYOdcuOoJg7hrQYxVUOfIVGygShsZ8llJLVgVYJNO05w6sxzLanYltQn9nuiPVq8Q3VTaRxcM52cwHyKMUiaOoXilcO8pj5R4cSAdtakyM6JLzRtQqfTYiPVeIirtO9ROKfSLthuTWNNHKQU2pjdRjsrzSkM76ZKMkdvUvqK8ST1bqey4ZsCR33iFYUtCyhq5ybyDZOkVjGzqQ5p0KrJagpkfbPh6tiEqHb9ydPMZcXlq8uOfmPsAsCmKFGtXiIh/To8twCb9224y/SZTqG6Os0TyvTguoKjN69TlzW7ZwrajbfaeNOjfxpdTeVugfYUHuXQPedHMu26yu0d/HM8ERxiJfUrgB8E/lREPuuX/SROMfyWiPwQ8CDw1w7rhE8UCwVxGXj72i0A/PDGPYBLgw3PyJu3vhi3+7Wjz+UHzzslYWuXZWGNJV1JqYuabCmdWxTUGTQUCB/91ldFf23aT6MLyTUCCkFa7zrw/433K9dlRRJahnoffywwy1vMqS2KB1s1rpd9dNZeiNm2cHcnBBGvCHKXzpovYdKOS10FIrUGOMFXt5SM8o9d0kECmV9VOndX29qIQVvduF88gqKIBW3tdTHN8yJWAd5qaNdA0CgHoFEOupWVNDM2lJoukGsr0OmTcSDa+4TtFNGdRO3dbAnR3YSZuZaqbLickgyVtfpst7rNhX4f7v4YSKHygr49Yomprj6oXVTUw924XucZqY8z6DQhX3dlS+VwTHd9hUAiWO3N9O3wHep0mlCOXUZUm2rjI3/hlS7G1vWd6cqa0caY4Zk9Ku+Kmpfo8caH7uSPbvoWV0C60iE05ZpsT1hayljJFBxG2oscXj8Ia+2fMCdvwuPbD+UkTxELBXEJ/PzgZrr+gXj72i37+tu+fe0WtOzvexszj5SQ5u5h15mmM3Cz/GAqq0zRO9pDaWHn0eYFzAcundUVwvUdF0/dtJgUrTCBznmvcQ/Z2lAXpcsgyns+INpqYBMC0/tcKmqK3tvNjI2rnA4CXXna7pi+mbuK6VDj0F2Jbqh9UMqntTZKJ1oVgKSdqdm3VQkSoq9p4qyYyZ5TcjPupNnrmVIM7cD1jIKIlks7VXbKtTTTf3rqelzg3im9GaU/TzkcpDD8MWbH5M5B09MixFQgUp23g/qiahezqULcII+foXGLhI5z7X4Tqq6x2kwpjqBIQo+Quixh2L58X/uAI+TrX33cMfp66854QsfhI+fZO7tL1k8ZbYxjW9GqLvZ1sPvMX/6O5vbUhp3TuyR5wnjDVW5fKgX2O+/9NO+/7aWOn2w5b9VqCEsnl+Cei+5+WZBDdDH9WcBCQVwGQpFNUAJd7Vgjw/eVVDPyD/tvn7iVTAk68VkdnnivM+jAxtj18vV9HUxtWDrRR6eO2mD56iVGG2O6aznd9SUAVJbGlEWdZ9G3GlAOnXJo9y4AGhdNuyDOUzi02VhjxkyWx0C1dHKvSJR3v4QOPGpKgJt8GSlGWJ0hFM4SUInfTpoxhBRQUVD7+oeA9sy6FRAPldgNK2yG5G4sIQOrTVMRD3cx5TBDp9FOQ21/n403HFRDgCjQGZSTKQUQBL7MBPZn920rhinFaU1rTERXoS1p0l8rH2eZF3AP1OvtNOYwNlVDypR7SWcptSfom7Iu4m3R1MZQlyXZct8lR+RZnKyk/Zxqb0S2vIpeWXf7j4aorQuoR86RdBMmW5OY6qrShKSbMdmeUAxLkjyJtPVHn3eMvbO7XPjSBnVholv2O+/99Pz7OIPX3PkJPvyyV9BZ6fixpZjaHh49hnCoQeorBRH5K5ex2dha+4cX22ChIC6BH9v+Ij8/uNn3uBW0CEcyzVZZU9uGw2leamyYwdSF6xKXdBNUpil3C6Tld9V5igbqccnS8T46T8mW+xhjSHs5STejws2YVTYdZHXNX2ZdJ/4lL8ZI3upLPXEsrLFl50zg2E5Gzb5lcEsZxDhlYYJ1kOTYpOOshQxsNYbKp8LqFlV30kHq0imgIABDxXSIc7TcUM1FeeGptFvshbsFT2vhaEXaiu5AxdDGTNxiap92sLuVgRRbi/rvccyzis2aaBVNXc8cxTG1n8woTBH4/9l783DJsrLM97fW2nvHdMacKrOqKKBKkNmBUlREsdsRbeReFbEH1Eah61Hh0jjRl9uiTSsPYvOA8lSLA4oNIuq9NIojdqtICyrYtC2UTGVBZVXlcOqMEbFjD2vdP7611t4R52TmycyTlecU530ynowTEXvH3nFOrG9/3/d+74snF4SHQmbQboJrT7EtvHZTmP8IE9gQKc7N+bfnQ5qMIphG1UW57ape2E9lfF3S7+GsNKGngkVRYTfXQBuS4zehFo+iOj2WH5fTPbrA2sc+w/o9qxTDgjov6Z9YxmQbsa8WjIRsWZFvTBjc0OdL/9ufcSWo8orJ+oSkl9Bb7qKNvmLb0lkoP0l9APALSHP7YvWwrwAOA8TV4iUb0mf4tWOPZyE19I/16NeOzZVRNEgP5ugAWomIWRh0C5oz2ijSQQpzstCm3cQbvIu4mRvUlMOcdNAlGXSFy+4zh/CFDgNOoUndaOqUwiaJ9ebWgBWgu4PYhAxDX9GJrSU9odolqHBTUmdXphIhPvxCHxrVaU8WxLrwXtQzjCOnmgXTZwdR2A+aKe1wfDqJz8s+fIO6LqTvYVLZZrZU1hbea+GCPYnA7GqXqnYoJ0Um1kx/IR7L1Iu3l5Nce7sQEKYCTDNVviPCwu8lwGVXJvYdIh02BLL24GPLyGhqoE4L6yqUkiwVxrORZsX/ws+zwn/ydymfmc6gWF0j9b+P5NSjSG54BHpuCbP8aXGn697D2Q/fG/drUsPRxxzhCW/5HQCvHLDJV3zgf+z8OewSxbCUTJwu6VyGMprJxuTSG+4GB8dR7vedc//6Yi9QSv2XS+3kMEBcBtZLS6Zr+kD/WE907fNKUuHNCUbBt575+/j6P3zsF9KpHWVekXl6X2ehF7+Uymg6S/Pxi2rSRKaj/f2pL6TRdJbnsEUlNENjoaiw1mKLciqLqPJCeOmTHJekkkEkqbiy6U1UVUZaq2utzSpNIQzJzdJBlZJSU9IBAuvH4MhQjHBehynYi4o4X0tSA6YXxVZzd+rKO7yXhzNCI1WeThub5WqHhnF7YbwEIo13BlNU1XYJaqrnIO/vklSCWcgeZAfxf9fsdPq8fJYgB+Kmn2sFD+eZXpI12Zg1yQxMw8iKA5HhOKvCP6ab7GIGYW4B5G8rqP4aL29iW/7m8XVa46z4jNR5IcNz1qK0kB90mpCvrJOVEryzRz0OPb+Ezoekww3mbxmz8pH7UEZ5MT855w98zVcBXHVgCPi6j32IP3zsF6KNJuklmEzvaYnpIPQgnHP/ci9ecxggLgPfv/4P3Ln0OHrnRiQ9LxeQGUbnxzuWmL7uYx/ijx//VLp1F5MausspXc/wCJOmrrYUG0OUMXSW5lh49Cl0mojZin8+MEJCYzEddCk2R3IVNiunEHR0vJqmSoUmqYyJ1qF2tCFXm9lMOcW7x01pIFmfNRhRZo0ZRZgBwF9JZ33RYirG2P4yerwm0hzeGMgpLaWh0I+wVdPcnS29tAfVwmLp7UtVXRKkwqX0wo6Ty/F+kjaZgy8xhZ8bSe+ZobZ2kFFa1vI2Kwsf1Ew2nf3MBgJmf545P2ulBKc0KDNTamqVqsL98PY+cwj7UmnWBLwQKMJ5WAtlGQcO25Ilbelw+TymlWDDY4EBZcsKpQ2ml8W/TUDMplrbFBtDdHo/VW+AXjiCWTyK7g4wR0/R/cBdTDYmdJaEirt1/+VJbOwWweku9P/aTMGrg9p53mWfQSn1LwHlnPu1mce/Fxg65962m/3s/zM9YPj/Tj7xeh/CIQ5xINFWLt6vEEe5PVNzvZZ4GfDOHR5/u39uVzjMIC4Td6zdJXMRn96gMy9XJeNhEfsQswjaMX/+tC+TRpzXrQkyBnVRU+WVZzsJWyk5fhM6H1Gvr8SrvHI4brKJskKnUhJw9bTPMMgfsK1rbFGhMzGoseMhOslEBtxnEv7FkdoaDIKiJEVVohItNMukkchow5oU3Z0nVxnduRQ9XAGlsN0FzNa5pudAq2QCDWMp9BrqujVnoZhuyLau3F0yNbAnfHehVsaSS3itrUWnaAeZjCmK7KUwwzgKDC7XnUflm835tBCb8c7u2DSXz8LGkpULqnezPYw2E6rddNZ6ahZDBZ2rnfSngLaOVfCabst/26JqsodWA1sOoelHlFtDkn6XpN8Vtde+L0lWZeyPmSzFlhXVfXeTJCnJ8ZtgsEw6mCfppUw2CjZPr5INUhYfuUwy6LF+91mKLflOvO/LnwFwUW2mSyFIcfy3p3yxN+LaowxCqSgxss9hnHPb0jOvGruznMAOOBBnut+QacW5SQWTCqMUc4lm/mjvoo2wS9VXP/zcb2hS9vllqe+Ph0AeVTVdbUW91evqtM3sY3BIm1+pLStcVeDyIS7NcFkX3RvI1KxfTHS3P7WAKa/OKvfr6CM9tYiF19oKZ1LGSKO21ilu7jhWGYwqpXk9O2UdF/YEl/iFJzStZxLaWO9vay8Zg1OdWKtXgOr0cJMxs9LZU4WdHfWbzI5BL/YytvVGJFjabA7bW5RdtJrv216rNM5ZFNvlIVSYJ3FOSkKxFzETHGaOV6VZw1iaPb/wmoSGCjwZY4vc+5U3+5Ze1niqIZ0OevHvKNBe5TBERiMI+LlamEs6TaRs1eniyjKSKUKPQhlNfebTYGvM4lFckjF303FsUVMMC4phSWdpjqNPfDSdpTmywWdEm+kiDnOXi2JY0hlXFzThunwcjBITkCqlBs65YftBpdQ8sOtoeRggrhAnBxl1ZXmwqBn0kj2pcSqj0V6gLlztaS+vkFrLpNgk6XWwZYW2GjfVPLTRTKYto2DLCl3kQmEtclwwpcm6zQLqGU9RTjpOPPvGrGnV39uSFjqhtg6lFB0Nqp5Q6gznHNr3JVS+eWFvhcAGAhTWL/7+nOpKHgtXs2FIz/cEVFUEOlZLhM9OB4VI92xNgM80oZWf9Zhq5LaCwywDyaZ9nEnR+YZMkFetmZK4oMsAoPOBdmouog3vtxHnRGY+l22flf+dhB6R0gY72vTDaf7qP83kc/QKujYf+UySqJPkqoJyOEZpzbEX/wwAZ1/7kjgUB8SsoqonUxlF6D242pItzQkBojWRroxG2aYPVm6MSIebmPkl0ptu4/gzvoylx36GzU+fQRvN4KbjZI96HMnCafIVob2W3b1blr7+k3/LHz72CyOj8KqhWtnn/sYvAb+llLrDOfePQJAUf6N/blc4DBBXgNo5sjlhJfHAMA7ihCBxId+H//4FTwPEDGgWn/eO3+fTL/9ubOWnoLXBHD2F3VjBbq5FWqEtfHlphoUyS0MMcLX1Wj5i7uMyb2/ZafwiIEUNFiRQmMyrqIq2UGxO6+1NVOcZSlpJNqHqEm28HpQtm5JSKOO02ExOaZmNCDMEYSJ7dsYAmsUnynjMLLg6EUnsNMVNWmWXoO46u58LfMF3ujJUcb5BiZe20ujJJqqcxHPZ/qFbqKXUNRUcLjCf0X5NpPhCDIDMlNScNqgUkfru9rHnTkc9LT231NB6PVNNGR2b867IKTdHmCxl6YU/OXUcIVO9FGxZUfopa2MtZjAvJaaimqLRBozPrqJXN+kON+g97etJb30y3Sc9iMtFIr7eXKMebhJc6YKkxl/+k6+84lmINr7uYx/id2988lXvB0Cxsx7UfoNz7rVKqS3gz7ycuENm4V/tnLtzt/s5DBBXgBc8eBe/e+OT6Sx0SDvGL9ASJC7X+KSNKp9Q5wVZmnkdJTHMiZzz4Brmr/40iMib/18kEVqm9sFmsiq8SF/Dfmk0mVIpBdFaDK2VxdwYmRRuS1prg6rk6riyjrxypBpskqKURuPd52yNqgu/uPkrcuxUKcWZjDBxrbxfdfM+M19CZ6MooLM7zBmYDJJS1F+DxHc7ELSF/fx5tP+/ELPdKY1LO0Lj1QZVjiU4hEW7HdBmr/ytbR6ylm0DcUF6pC2j7st27fJTYH/Fzz+hETlMMhlozKWSIBLqgVVkYmmoHm7FUtJsYAA48YOv58xrfsCfhp6qs+90AeKsZbK6SWd5HqXlvW1ZURcl2pioNpx4wb4qnzA8fQ5z11+jl0/ErK9eX6FePUcVFWIrqnE1JQH+P77yK6InClxZb+Kb7vu77WyyK4Ei9vz2O5xz/xn4zz5AqJ16EpfCYYC4AvzK0cdzvJ96iQyHxqI91/ping87ZQ5t2LIiX1knfeDTJCdvwW6uxmYiiKeDrUpMmaKNGMpPfWm9H4TMUaTTX+og9R2mj3sD0T8Ki5zX+xFpb7/DGjBW/AeqAlngbSydgEySG60oaodRmrQuCBalqiouXC6JJy202fbMQCy5hAa3X2hDmWlKwqJVAlJpx9fdp4X7ouQ5bG9Kx3LezllFOzhI4Kl84DHNoj/bN5htis8Ghxg0JUjEwAy4Ygyd6V5GVMONgaQ176Glvm/TDDvcaGxgw+BjkqH838/8818JwMab/30sQUITMG744Z8F4MxrfoBiY4TJkh09sOVwdCxDqTlDPZn4wU5DXZZUuf+5TKYy3a1PfILO0hlPmdUxqEzWtpisbVKNqzggCpJFzOJimfhDgYOQQSilvsk597sAzrmtS73mQjgMEFeI/rEeOtNRgjhc4QRznz+47QuAnZUnL4TP+bl38MmXPI9qXLAsO6OeTOJchKstptMhGUC+sr6NTaHTJAaT8JxOk8YtLiweEJkvLhv4q3gbr+SDzEVsBFeFBIkybGugLsiUpuMsdTrHpLIkyrWG1sJAW+uqTWlw9VR9fmo6uT1l3O5PaN+wVhZoFsyp7cJ9bUQWuzXfMFXm2ikQ7CSdEfoPJhPp8qqQfkN43PnsoF02amsehQU9sLPCNuHzjUOEFpdvye9IadEwSlIZQJyR73A0ZbXo9ZHKZLvuz0cJFTse4kYb4hzo/SEG3/EKtt76E9vPnSZgACy+4FUAmEy0wrRv44SyJhDlNZJuR4JEVcZhOxBJ8UCoGJ1dnaJ8Zt2B9CaGY4rNEVVekPjSaZAHn2xM0EaRe9JHNkijlehko6DwMt5//rQv20b++OPHP5V0kEU58a1zovH97Pv/947nfrlQSk0RQfYxflopdZoLJ8cAPwlcnwChlPpl4JuAs865J/nHXgl8L3DOv+zfBbEopdTLgRcg160vds794bU6tqvFd618lHc/4ilUeUU5qenMG1ztKLfKqNJ6pZObt73+7Xzqpf+crXtOR6/ppNeJf5SqN8AAalWyxbbOvzYGjIlpvU6TKNgGPkBMxmLokvkp2FDSCK8J5YywgLUGtoJ4nksyXNKNDVrnIDMaXex4oRK3D4u500kTJGYDCLY5Bm2illMcsGtB1VVzZR6u7vV2bSqSaQLBtmnp2SwnBIGpzGB7OUi2DxmanXqtqitfJvLT363PMfYanJSU6PRx400pFWmNHW6g55ams6kQcAJluM08C1kSSOkmSak2VyVQWkP/23546pBNNxM/hx2weuePNp/PrIlQKDX558PfZ1vgrxyOKYd5fD6b7+OsJel2cLVldHaVpJdRbIyoywpblLg0oX/qiHyMRcVkbctfAA2xRU3vWJ+jT3w0k7UtVj56LybVjFakv/LeL306dWljQLgQghPdVUMdjB4EcAb4T5d4zccvtZNrGQp/Bfg54C0zj7/OOffa9gNKqScAzwOeCNwIvEcp9Vjn3N4obO0h3rT8OG7spZyfVJhxiVGKfiqKrZONCf1jvatOfW993ds4/eMvki9Wv1nsbVlRrT1IMJIPX3KRXU6j4qsyWmiNMF3qqApcoeM0rapkMUEnUjZpyTxMXeXbWiwu0w5OJdjOPLlVdL1BkXWO1Gt2hEU/qrG2FsfYtHb19gyiXTISfYkWo6mURTvtT00ui5tbEWm4oVkdpbBb2cKUyc9OfYO6lKa8nvlK+Ayq/b7SY/FT2XHhdtsDTQjA5aSRw7BW7k98zyDsM+tK/wCiaVIMUm25ksDiwgeJVpbkAKpSqKdpJuKMwOi3Xzv9GQDJwgI2H2EGPvOwlvLcGaBZ+OvWJH97ZiIgTOvrNJGgUxeYNMUspdGYCJrAAVDnBcWmXNWbNMEMephuhklT0oV+dEns+Cb4+Pwmg5NHmX/84+mevY+t03Jt2UeyiVn6ajrImDvRx1rH6PyY3lLngi50V4SDI7XxzL3YzzULEM65P/e0qt3gm4G3O+cmwN1KqU8AXwz85cU3u344udRlyw/2hPS3LvaKay1fpKQnXhCm15dF2oitaKAjhsG6dG6AbQvvwbRyZ5DO0L7PUOS4NJWyUTD9sk1gAGQB9c1pVRdx+3pwlBJN7RxrhaVrFF2joJaZCWdSrDJonciMgN+flK00Dj0lPz3V7G0h1uR1EhdHl/VkrqBumuDOZKCbPolysgCLydBFMoXZ92w/HwNTITaVIciF50NPwbbKTO1MyLmm8V57ob/oOeH3naSNhWvp/TySDKVrCSA79G6aAGsbGY1w7PggUXlZjRCQWiyuWGr0Zcbk6Enfp0ihKkmP30BaFVQb63IF74cygynQbEnT1rUXcRQP7fB8nRekAyE+VOPJlEJsutDHFNWUjEw66FKXJcqXnsqNEcXmkCovqHLpy7kix/T6pIMuW/dJ9tw/1qO7LBpQ45Uhk40Ck4q/CoCrHWlXSmVVXsE92z7SK8I+mJJ+yHA9imnfr5R6PvA3wMucc6vATcD7W6+51z+2DUqpFwIvBLjllluu8aFuh1HQXe4yuKFPdn4c66XFsNw7xUhkkE2nCabTiVOzgc0EkMzNRYVO1eliAk21LBqVUu39HbLuRYfCVF3Eq2pXTgjOc86EcpMPHlVzfpmRxnRp5b42aXy+dg6UQRlZtJ1JpmYRohrrbMnG1rEEJR920G5Km/JKXMRV4xfR2o/TiTjVBc2mgJmAsKNng60g6cbFPmZApRXqr8kk29KVt2XV26mrs2J7rfJde2jQdQbTsx15i2Bi0u0lrtZxB82ldgCM3hDB98PTXhUSGIKjoCtyGCx4nxDTWLyG/VSiAabThKTboconceo/NJVDrytQraWsNCbpduKAXZJ2Y8+irT1W5wU6TdAklGVO7ctRg5NHRXV1bYtic0ixMaYYFt5rekxx7izZ8ROk/Z6UlHzQ6SzNMXfTcQabo+h9HZQKustd9DGF0opyWML/5Kqh1IEZlNsTPNRneidwG/D5wP3Az/jHd2qk7Dhf5Zx7k3Pudufc7cePH782R3kRvOBBERtztYuCfQD5ak5R1hTl3lTFbFFS5QXl1pBybY16IotvKCFh65g1gFyRqu4APViQhmV/QRQ2e4N4lah78nwcfKoK35cY4YoxrpwId97WMvtgsh0XqbJ2WAe9RNFNlLQq/ELXHgaLyqthQM1nEUHoT17UKjFpI4ZG4aYTT7NNonRFmKFwOsElHWzaiz0Ul2Sy8KZdn7G03sP3FcJt6jGdNIt/kP7Q2geFtLla9+cTPLdd2pHj1c15mUd9/rZMJZooJR30Y5/ePOYfd0kK3Xl5vTbTpktTCrCwbdgOIvssDMHZofQzes9+sfzu+wu+eZ/J30V30Grah2MXFdhydZVyOMZ435FZf4hQbgr3w2ukd7BJNcrjtjpNMJmUPqu8oBqKKkA1zCPpImQ4VT5hdHaVcphTF0JzFdteUUzeuldKS8mgS2chi9I04Tg6S3MMTh312YgEps5Ch/6JBXrH5pk7tbDtc7sieKmN3dweDnhIz8I5dybcV0r9Ak0H/V7gEa2X3gzc9xAe2mUh+N+m3QTlvR7aeNepJ10Va+K+V90RvR1GZ8Xsvbs0T7rQj7z2ajSmzgsJGEmG6pspv2nd6eHKArshV1VOG1SofyeZzEQgi+pUVqGl0Y1S09pJOsGmPZSzpEZUXBOtUNUENcmbBVcbEq3Q1URc6VTws9axzBSlO0zrzy8EEZ00CyRMNcpj1mGQ0leZywKf+EDmr9AD28imHVQ5kT7ATPlo6nwhDpJNBS9507hdctPjqe77h+ZcTegVKNITj2pto0B5L5BHfiH2U39z4V92OB5joDOQclOb9trWdHKOYO/ablJLUPdBIh+hewOyZzwvnt+Og4FhqrosYwnSVaX8TaVp7BmEjDX8D03QaM9HtANJORxTbAxjmSnY5bZfZ631suUSXPKVDQkGw7FkKUZhAW2UGG5tjrDDDbKFPkk3oRpXsbRb5QXZvJSfSj9PIcEFqnHh32Pv2pkHKYNQSvURcb5bnHPfq5R6DPC5l6K3BjykAUIpdco5d7//8f8Awir6LuBtSqn/hDSpHwP81UN5bJeLtbUcoxRdo+kf67H4yAWy8+NIq7tazD/iREzRq7xgvLJOORzHKxOTpvG+LXJUkUsW4aWf7XADO9xoFg5bo8pCpqh9eQHAbq0RBNyE+uqncE3SDLqBWH46C+N1OmlXgoVvwgoFdBIDiCmGUFfTZSGvmxSZMbZuJo21lnJS+2p7iroKOLez37WXrnZptwlGJmv2U1eNTwJsG8BrBw5l7VR2wWxZC0hu/FwAygc+OdV3KM/cTXrDo3f8Xepbb58KEvq2L8b94//EZdOZTHvyGqUkOIQyVO2zsbr0RkFe7sQPBgaDqDA9DTB5z5uj5axKtpeSKAtfjpJFtFp7kGTQjYt7kP8OC31dlnEBTgfdKY2wNmwp2kcql6y3mmFM2XZwqy3F5jBKxITSUV3UKE8hV7VlsrbJ2sc+I1fn3udBLtDk91psjnxmItl9XdaUfugu0GL3AkqpyBw8IHgz8EHgS/3P9wK/ySXorQHXkub668AzgWNKqXuBHwOeqZT6fKR89I8Q8J79AAAgAElEQVTAiwCcc3+vlHoH8BGgAr5vPzKYZtHLTCwz9Za7dBc6cQI00OqCquTlIFvoky0MInNpsrZJsTGi2ByRDqQpR+rnHmorwmh6VYxi+gtNDbpq+QC0zXWsjh7UUX+pXdOeWUyk7u4boc7ivKyGqgtZoANjKdT92yY47T5Du18QFlfdWiSnrtz961riezLE5/ehvWhfCBpK4bKBBKxiKFpO5VgWWdPKSKbYUjOloITp41A6WqXOIj15G8X5e312JOdbPvBJ0pO3YR65nVKpb7196mdVFzh6LY0r/5661RMJ5xZ6QE58GVxZYEeb8vuddckbSCml/IAoPZvlE7E5HeGDQhsuH8bGscnSSJUO+kvlcIwtpFl94uWv575X3UHSzaJXRHtxDyg9y+lSqItADU/84Fy9zSwrXx1j0hXShUH0eBicPIrOZEaoHOYUG3IOZV5hizqWqfLVfGoS+2pxEFhMLdzmnPt2pdR3ADjnxkrtfqT8WrKYvmOHhy8oEuWc+4/Af7xWx7PXmOskzN84RzpImbthwODkEuUwp3PvJvlqfukdXAQmTX1z2mBHecNYqjV1UcWfq2HzPrUuUK1GtB17GqW101ePtoZksMO0bw02yH73ZPFJUlwmNf14JQvxSl0VI5lTaDdbg6FQ+BsMC3zUF2pmLMIV8rbA0M4eZv6UA3PJKaHnWhSldTjnwIJSGZ1ugi48ZTQwhHYIEFFqOwSL1vxFgHOy3U7ZQXbsZooH7xNWVX2ZCqSe4aVCT6TF5mpLi8cmvNZQSznJjqShHcpIxV/+9o5vYY7f1AwM+h6FSrOo9aXSDFdKH6pae1DOc74/fZi+v2DSNAr7Adz4iju5/6e+D5MKS4iWKmzYrv1/gM6S6IQ4iyovqIsaZ52Xxlf+cckEKl9SzRb6pP2eOCz6CyRX19R5STEsfHlJxaCQdBOGZ/cmsz8oNNcWCqVUD9/TVUrdBuyaTfPw6KRcB5jM0D/aY+7GebpHF8nm+yhjSLsJw6JGX4VvbeCQq04XnY7QRUXSzaJotLOWKp/EaVUdZDI8VNYV9kGSiQz2TjITVcvf2BNtVJKiBwuE4S6ne7isHz2nVTVp+gE+OPgDavUMWgt823s5jEQDkakUgkOLYup8H0M5J2KAgArSHS1WklVGfMCtpbTgnKOXyj5yq+ilPcmo2nTZ2UltpSQAxKDhJcdnFuns2M0X/mX5ctZOzeOLQX/Ol8Cn/gabgQque34/IWipbTThREqERXNhUP3tHwhdNehlzfaTQr9CG5T2zyWpzLUATMZU506jjGbx+a9i483/Xjb1Wkph1mb5jldvO4dTL38j973qjphFANG/JMxHhPthnzFgFBXWP2eyhLpoHOqUVtSlxfm+wef/tszMfvi530C2YDHdjni2a40rGsZVOiiYbExEPNOo2B/URl9UAufycOBYTD8G/AHwCKXUW4GnA9+1240PA8QV4DdOPIHF+c71PoxDfJbDfux91/sQPuug9IExDMKXku4C/k/gS5B8/CXOufO73cfBONPriNcvSFPyJRv/AIhQX89nB0kvoXt0kbTf9R7SJZ2FjBuefJxzH9n172AbymFOPZmQDBYwg7k4EKfTRGiE3pgFJJuwgKpFE8fAFO+dbl+al9UOJRArJQe0EWqs9xGgKmDxBC4R8btw5a7qqhl48+WQ9qS0qgtfLmquykOjuqnr++zBtNhKgWqqFJV1YCW3MSDKS+25Ar+NsSXolBonsympQTspb6VGoSbjOJfhWj0U3wluZTP+nWJWwTS76hKImUl1BY1QW6HKSZPJtZ8LJbCZWRGV9TCLDdVUzy81zftABmj3fDSopNPso/YN7uAqV+Txbyn/vTtJFhbiIN3Cd//EJU/hxldcWDn6M694Acb3KQJMlmCyhKKeLvmE/oMM50kG/uR3TKvt2EJcEk1XPFHqVplVZ/JdnGyMyVdz6kIG5eqipi4t6WCvPKkPDovJOeeUUu90zj0VePeV7OMwQFwhsoGXK86bSdG2CbzODCY1vOeJX8RX//1fX9a+A1fc9IYyBOdlm9kcRWaTNgYLURUzsElcWTRNZu/2pbURfvz6in8DKS/oTk+CiW9Yu7KESS78/7TfWvibMoeyFVS1lDS0aRYkf1N1ERuuUzMHsL0x7R+T1ylq2zQSw2LZLiuhTewJ4CzGlnSSVJTJ60kzyOdZVdAEhzbFdqfZjmhT2mYxXaBBHTDOc1TSQdXFZZeYQMpM9hPvl2CQ9fyBtD6z9pS5V5F1gEpo9Jza/RKTSBAPhxK2NWGOo26O0w/V6fllVHfQXBhcJe571R1TP09pPpVEpdb2IB4Qy6XOWHRmeNwvbrdT/oJ3/hF3fc9z6HihyXJjRDkaRzZVNj9g4ZYTOHuG0fkxxZZMYrvaoa9QG20blGoIHwcD71dKfZFz7vIWIY/DAHEJhMwh4LtWPspvnHgCxbBkeGZEMSwxqYneusqsc+4j51FX0YO46cd+XhqA3YxsMA/JAK0Nxksjg6/repmDoJOj+412EkgPQ2mZj1BJKuqe/uowOKmpJPWWkUVsWqvU18QhymME3r+abKHsJArIReG9NuPnQkyh8Fj7vu85hOCgEPlw5RzgpiW+lUY60Q3TSNka7VlVQTcJaKaRA0JWYFrHZKuYFcWswdf6o6LtJTCx0KsmuLRLtnTikq+fhf6cL6G++0M+AGSRDhzeP/RI4merVDMYGNhZs7pS/jEZ5Ov6z6lqJsuTEgXiVuin7p339bajDepzpy/7PHaCKL5mUbwPJGDoQZek11zRhyChjQajecydv3XBfdqixlpLmiWUozxqN7ncUhcVg1NH6Z9YYLyaU+UVdeFZVlfxfdyGgxUgvgp4kVLqHsQwSCHJxVN2s/FhgLhCVOOKjXs30JkhG6TMnZqnd3w56sNMNiZTjePLxamXv5Hzb3gZSX8NvXgUtMEM5khnmCIWYoCwZUXSM7GEEOirFDmq20fPL1GvnpOMo+NNgoLsQmhuGoPqzmGj3EWLahmG0upy+sq+vYDB9oZ1axFzswFjB9TWxSDhlEL5ktX0BLRvYKOl8eylyIXW2ionzC6ezvqpaeOZR/m2QOZMo4XUGczveIzrwzHOOWrHtKTHlUBpCVSzcx4hIIYArZNG+6A9PxHeX2lcKtmGqO52JTOxFrzBkOt4H+m6hBBAQvZnK8x6Sr16jitFpGG3T8Noig0pKclshY16RjpLSJAgsZvafqCRhzmMyeq0B06xMRTXRS0DdtooaruXOmlq2yzNFe9pZ8XrI8BvAI9CRgGe6+WIrhTfcDXHeBggrhBhilN7Ot14ZUi2MCAddJk/NRfLTkGK40pQDnPKrSFZb4DqDlBJSuppis7WJP0exbp8QUKfIgQGlaZ+4bfY8RCNZzfNL8lxe30mlaTSo/AUSNWdo+4vx3JQm02joFE2nV0UZ2ma4Qq8NWw27e+sY3kJQCuFDQ5qSJDQSjXidMDEaZxzGC39idI6Uq0wIBlCmzK7E5NqttSldAwmbenxztziRX8v60GZ1EHHKJzr0lk4culf6EVgO3NNQPWIfZ66bFzzWn2GmEmE4UZfWlRVAdVEfm9lw2gMDn42G8gDYRAPhJU2WhUF2Fm9rl3i3OteGk2D2jIcJktjadRmSXSPSwbdKDxZlxXKGB792l+76Ht83jt+n0+99J9Lxuz7GZXXdwLJUMJgXmASJt1k7wLE3npS/wrbFa9/FPgT59yrlVI/6n/+kat4j6saADkMEFeAbz/7Ed516kl05uULqTNDXVjylXWSbsbcqXmyuZTN+8Qf4U9v/9IpXvcz/nJ37JNTL38jZ17zA5huRjq3BLoR3VNWpqXbRi5RNVQbdH9BfKe9obzSBj2Yj+UklWZ+yjYBStFsSjrUg6PY3qL0EupKZCvCIjIZoqo8XrFO9Rd2UmVtzTzIB9UKEAFKi4JEuBpHBBG1Us0arw3WGSZFjQW6gFUSRJxz9LRpfLPZnqVsc6Br0UGDphNAt9e75O8kBIdxZUm1EpnztiDflUJNfzYSELxYofYXGdbGUpmdyTbavR+qwg8xlt6WNMVmc5JNBMmUupTfrZdL16NV7AN3U507HWXCLwcrP/dDQDPhH/piIEEimx9QbA6naLC2rOgM5rBGX9CfYieUwzwaDWXzA0y3g6trmab234V0LiMdpFR5NaXbdNVQavsg6RXiAorX34wMGAP8KvCnXF2AeDfE664u8GjgHxBrhUviYLTj9yGeff//phpX0UEO/EBPXqCNpnd0juVbl3Y0DtrJRvFCqH3D2hW5eAwnqTCOuoM4ABf++Ou8iFeAeuEI9BZgsIw5clImbJMOqjsnwQDEfWzzQZmCHRyhnjuG685LAArS2VXR1PvL0bSuUUCbNRMa1SE4QPP/Dj0J18ocALQPDvF5B0XtyCsbA0jtiD0Lo5UX20ux4eY9sJ0O/yfx1j4eZ1I6PqPaDc75MsnmpGZSORKtyEkuWIbaLcyjPl8+2yCrHqfHExlU7Mz7/+ew3UUmnUWKpEed+hkVH6DUZAs1XkcVQxiuwXAVt3Eehmvxd+KMKOPqfAM9WkWPVknW72sFhzFovc1k6GJYe9O/A6CzNE8y6Iq/QzeTGR0vE54MuiT9Ljf92M/Hx6N3ibc13e0iXuellJHShO7RBTpLc7HM6mqHTkWGo3+sTzbI4oXZXkD5OYjd3BAVib9p3V64i7e4IcgR+f8vv7HVgnPuyc65p/j/H4PYKPzFbrc/zCCuAt/4mf8V77/3S58O9KmLmmJY0l3qkQ66LNws8uDlVjFlxP6Br/kqkm5CZ0EW+Se9dWcW2o2vuJMzr/kBksEDJLZGzy+j55aw+RBsjakKys1RlGCuxyPRsisnqEzjRuu4wTJubiCXEbUvFQH16hquKtDzR7CdefAqqCrfbPoMvsat6qpxSQto9RYinTWURUKT279um6QEIN7VNUYbKuvQqmETWedA/uGco7KiIGtUq0fhz8MpRe00rtXoRims/1kunzRaKfRMkNoaSUYw179w9rCyOaKoJSCs5TVF7ZjL9JR19NVCF+NI+3WhrGSSJjtxDmdSEQZ0wkZSxTgGZZ1vooqxUI3Hm9Sba/6DrNFVKZ9zb4jtL8sFQDkWIcMqpzp3mnrlAQD63/KDV3T8veNHxHq0rfs0U6pKBz3Ov+FldJbnOPbin+G+V90Rm8yXA1tbylEes5BQztVpghl4Bp21otdUppRbJXW5dyWmy2hSn3fO3X7plz10cM59SCn1Rbt9/WGA2COEstH7vvwZfszf0l3ueV0leU05zLFFzdbZ4WVpw9zwwz/Lude9lL7Wcb5BaYPqDkRrJ1mj3NggKL26IhdKq9ZitJJkkPVwaU80l+pCzHygyULqUkx3/HvGKV4jXtQ6X2+Z3kwfXwgcUxTR8EKvuxQDRqBnBgqtszhMfF+jVZN4IMHAOnlcJDVAaUUgpTiIwaMOQUYpah9U4jH6VxvtgwQw3+/FALETVjZHsc8BsFnU1BbmMs1iR2jG/V73gttfDvStt2M/+VeocdUwmMqR0I19LydObFvx9VaTYcw6glR7mHfJvvRbACje+3aR5hhtorI19PwGqjsn+xtvUq2vYNdXUFrTfdYdFzy+C2HzLa+UTKDTxXS6sfwSRQO1RllDvbUlirCbw7jtja+4k9M//iJ5WZpw04/9/K7e80lvfTeffMnzKPBN77JEpymp1iIm6NVbXW0xqYE59pDFpK41i+lMEDVVSp0Czl7NzpRS/7b1owa+kMby+ZI4DBB7jKf/xXt535c/g2JYknSTWCeVVDplsraJSQ26q5g7tUDilTI/8vx/BsAT3vI7O+63HOaMz63S1zLMpnsDKRX5clEKVFtbclU13EAlqSwM2mCHm5jlVfSxm3GdgdShe4vo+VEjgBe1lCoZYrNpc7Vfl94gxyNIc4OnvybTQcEjlqOc8ymL7LvRP/IzEBeJlcJmkvupdiglwSGs/Qa5H4JB7UD5fkZRhzKUfDOUUmgn+whoB5ELIa/kNb1EkxlFL5Fz3KvgEKBv++J4337i/agSKMaNZ3irn6MmW9jxULKjNMM84Zk77jPKfgOTP30rdjyMIo3O63VdSWAAGP76qwBIFhajx4Qrcq/1pKUH5n0mAqPPeGnx8294Gcde/DO7DgqzEI2oMpaW6npCXVRSfqotzrrYmE67CXovy0zXdlDuXcB3Aq/2///Xq9xfu/5ZIT2JncW7dsBhgLgGePpfvBeAv33O19JdlseqvKDYGFKNy6gLE+wWi43hhXYVESZWz7/hZfQBpU/GIbfATEq8iVA93GoWdG2E9TTaQK+vYI6ekunbtOeDxwamv9iotVaFBISW8F8YBNvWewgBJdzfATFzCEKudctJTplt29UXWLCdc2Stq8Daxxzr5Lnwf1j8a+c840kyktKB0Y5MaWoHi8Gr4CLxobSOopYMouPf+8iMmN21gv6cLwF8oLCVDNV97H2x5OSs3eYGdyl0nvkv9vw4k6UjzZxNkWM3V8VydHm50YKaCGspX1mPx361qPIC45lMlTcfqlol3Cf/+u9t32j3IqYXhtJ71qS+gOL1q4F3KKVeAHwa+LarfJuPOOd+c+Z9vw2R/L4kDgPENcQXvPOP+PBzv4F8dRgVKaFpKhcbY/onj5IOetHI/a7vec6OU6QBdV5QrG/S6Q1QPnuQidglYSWtnpOrt6DiGaANNh/hznwaPdoQS1EvCR6zh7qIAcGRoeyk4dS3S0ehnDRLdd3WgN7ezFYgcuE7PL+T5EQoHQUahlbTi7prpR8W0M5haWwnlJL7zjlSrZm9kLzYgn9yccAD68NLvu5aIgQKQNzoriPG73ydONJpjR1tNlP4ITgMxVEOkKAwHgpxImQPWcrSC3+S82942VUfy+N+8Z3c9T3Pkffyv+wdg8JeYw9prhdQvAb4p3vyBoKXsz0Y7PTYjjgMENcYn/eO37/gc598yfOYrAkVVulGX+cT3//cGERue/3bp7a54Yd/lrOvfQmm+2CjoZRmotDZ6aEXjzZ+w941DJiSUXDjIa4ssVtrTbrsrDQtSwlUsQcRpqUB8ZNuTe/OUlrbFM0gH6GTSKVs9muJTm0hk/CYXfzbrZrCuki7M1rh/P+1dV7ZFWqaoKGUagUKaWqXtePIfD8u/CcXB5xelfs3LQ+2/Y5OLm5/7OGMyXveHP8Ou1/7gou+VqVZ9JqQun8e5xGq0TjuZ7Yk05YNvxq0g8RDh70blLuWUEp9A/As4Cal1BtaTy0Au2YFHAaI64S7vuc5pIMu2XxfJqC7mejh59NS7Xf/4L/aNjx04gdfz7nXvZQuYMZDmW/oL6DSFLN8XIbjNlehs4DOujJNbYxo/+fDaUeyJMONN2FwNLKPQK7y257OEiSmH4uYnZRWGttfpjQdRqWl3x2Q4Ie7gmy4vImwcbTBeKG+EBRms4h4H+kn1LYpJxW1o6olc4CmrxAUno1vau+m3/DZjMmfvnXq5/z37txWDtK9AXpuCT2/7B0LA3FBR5IEiMyGLUUjqa1Rtte4WLZ9TXB5LKbrifuAvwGejTjKBWwCL93tTg4DxHVEZ2mewamjVPkEW1T0vF5+OczFPtHT/8697qVxGO6GH/5ZAI6/9HWcfe1LSAc5yXhEslRKNpFkYiFZlbjVs+jlE1OubK7IZVbCD845a6lXz6GXb8T2FkUZtmoGpYLWUrgfpSqgCSYzzCVnUkrTYWVcMywt3dLSS4JWk6aXZnRdEecRlHN4Q1JaYq60iSchK3BOhuRAykm1laDRzEjIY0Y3wWSn0nPbx2anzOGzFrphlG0Lp4HxlqbiY601dnMNu7Ei3tbaYDpe3gVpXqMNepJTj/fIsOe642CI9TnnPgx8WCn1NufcZbpZNTgMENcRwSaxf+ooAJPVTWxRiZSxDwj9Exce5Drxg68HJIBkZUW61NR70UZsJNdXYhlApRnm6Cmqs/fG1yjAbq6SjNclQPQW0RODqiatwbJ2OUhHJdEg2NeWtXAmxQ6Osp5btgpLaS3jEoaJTB4LZbVmuZMwlxk0QW8pVqFiFuFmFnYXgoeDXqIipRUc1jkmdWhWQ4ZC4dBaUdXSrG7jMChsx05N7JBF6G4f1ZPhzOiD7TPRUMYMdqdSjmxmIFSakqSL1MPNbfs/kDgAJaYWHqWU+ingCcgkNQDOuVt3s/G19KTeSYjqp4F/BhTAJ4Hvds6t+XHzjyIj4ADvd879m2t1bAcZKz/3Q6Kb7wfjDnHwUZ77NADp8Vuu85Fce2y+5ZXMP/+V1/swrhxKT1v47n+8GWFHvQ5Rdv1upiu4F8W1DIW/Anz9zGN/DDzJS81+DOmmB3zSOff5/vawDw6P+8V3Ug3HVHkR/R/ylQ22Tp+j2Bjy6Nf+Gt2jC+JBbTT9k0fpnzy64746S0J1LtfWKE7fE30f9NzSdsN638xWnR7dr38h3WfdQfdZd1Cd+TRm85zMLiSZTO1mvUYy2luETmUTs1AKl/VZKyzrkxqlYLFjWOgYMqPIjFz1b+Q1Z0YV58cVeasL3b7It36OoXZSPmq/m9GQGhWzgqJ2bJWWtbxiY+JF4XAUtnWr5XZq6eKZw93nN7lnZYt7Vra2PXfvg1vx9tmC7rPuoPdN3xdtS8PwpR1tSnlp1GQFSuvIaop1eq8NhjborjDBgq3pgYRCMojd3PYHes65PwGUc+4e59wrgX+y242vWQaxkxCVc+6PWj++H/jWa/X+BwGPufO3OP3jL2L4wArVMKf0QnC3vu5tU68Lzb9AGeweXcT05Mtmi3xbE7Da2iKhbVrv2UVlCWWx46BP9vTnUn3w3ei0i+0t4tKu7ydkuLQvk7uFryPPeh972O4CW6rLylCOZy7T9BJZxIPSQaYlIDw4LikqR20Ng1RmHBK/4FuahnIYhMNBqiHREmisn2VYH46RzobCKEU31SRGfra42GsIzMSPn93E0kxH33rsynSUAvMJrr5cdSAyh2A4pcW8KrjRRZYc4II44AxcWYiOmDFT7nIHEQq1l2quDwVyJc2/jyulvh84zWXoO13PHsS/RnTPAx6tlPpbYAN4hXPuvTtt5AWvXghwyy1788W6c+lxANyxdtee7O9yEFQsCy9B0Ka1Jt6usc4L6ryIPQfwEgeDOZLl4/EKzRU55bkzgNR9XT4Ud7iqjD0JgN6zX7zjsdh8iJkMYXC0kfkO1NWkg029h4StUPmmsJGctIJd2iE3PVZHFRZH12gSrWR6WclVvwzBKebQWJdSWcf5UcUoNSx2NHOedhTUXUUCvGlQ99LmiznvtZMWBz2KesScg44PRplRaCQoOSTAjCsbA1AbnzovV8AhUDx6h4Dx8bOb1H5QLxgatZeIe1a2eOTRuR0/04B8PI5ZV7d/8Pof3WfdQf4Hb/K9hyJKeihj6D1HSDGj33yNGE9BHOJzdQ3B8jZJ905V9Xrh4LCYAv4voA+8GPgPSJnpO3e78XUJEEqp/xvh4gZe3f3ALc65FaXUU4F3KqWe6JzbmN3WOfcm4E0At99++4HnLdZtqe4ZHH/p6y643fzzX8nGm/89CUI9VN0BSmvS4zfIvtpeD/mwaSR2eox/9430vun7tu0ze/pzqe96r5jvdOZEDdU50IZCJbHsY1RKb+4YZryG8lIQLhv456BrRJJC9JCI2YFCykWZgeWuobSOSaUpasewsiilSLVMMMvCLiUm44NMYDeFKej4OS3IXENiVQwmNx+Z456VLWrnmFSOzaJiPkvIK8ukrlnqprHk1cYnzknA+Jzj2wOFnJ80xbVmakZjNqN4cHMUS2CzxzvZWhehQq+jdCVOdNcD3a9/YUN99Rcl7b+jtgLs+J2vaxbSJMXmI5QVB8S5f3GAS0zXXotpz6CUMojh0A8BW0j/4bLwkAcIpdR3Is3rf+r8t9k5NwEm/v4HlVKfBB6L8HivOa5H5hBQDcdYr5+/W2y+5ZXRMCWkuy4fin1oyBiqRi5DdQeQD3f1h+0mY8xwhdokUY6j1inWOsaVpahFMK+yjn5nkTTt4UzGxEJlLVopMiMUVZlodpR+ERafByitMIxSreh2lPQHrPNzENIYy/ziqnYpj3CpgTajpORkNGirGBY1daqjrtLFYHHbqLIWrzgb0bzg9OowltYCSieKsqm9et/na4Hqg++WLNMPVKZf9OwdX7db3SZXlkAZ97fXQeHjd3wr1perPvdN/++e7vuiUEp6LAcAzrlaKfVUpZQKa+3l4iENEEqpr0fML77SOTdqPX4ceNCf0K3AY4BPPZTHdr2QDHq4ukZnl/9HZ4sKnZW4stxRv3/0269tJDd8RnGpIJF83tdSf+RP0Vlf7EyzgZer8GJ4VrKC2jnGlUMpg/FT0ZV1lF5RFRrF1aBn1J5TM0pRee2kfqrI/OBb0FuatPwfQJi0l/s33i77fPzsZlzke6lma2JZG1ekA/ncP3Fuk885Pr9j5vC5Jxb4h7MbaMTEqHbSGzFaccsReY/QuA4BbVRaSuvIjKaoRxgljXWbdBpxwqS754J/+wWX4ydx4LAL29x9hL8F/qtS6jcRT2oAnHO7iqrXkua6kxDVy4EO8Mf+ixTorF8B/IRSqkLUEv6Nc+7Ba3Vs+w3tptfpH3/RJRUud0sTvFJtf/OEZ1J/5u+g7nlp8UQkLSop/ZTWMSwtpV/BO4nGtBzgtJIykpSMFIkiLvxBGVUr7+3gew2h+ZxaMSjKOoZRaWMPIpRrluauTBPpMSemF/67zmxgnWQGZhdZSggSOLk/i5tnAsUsCitzGkZJYOnsmfz03iB56jdSffDdKG1InvqN1/tw9jHUQQsQR4AVpplLDri+AeICQlS/dIHX/jaXIUH7cELSbVzhQpnp/p/6Pk69/I3X87BElykroZKp66I2FLX1dFHLma2C1Cj6qWFSWVKjSLUwiJyTQOCco5cq5lIdg0llnQ8MzXsVtfsIrFUAACAASURBVDSAi9qhkw7Glqja0k/T2Nje62bT425Y4ONnL9xv2Ak7BYZZhEBx9/lNxpWjspbKyrkpJZLhRiNWpfsMBykwPObO37pu771NhHIfwzl32X2HNg4nqa8zHvEqiZlnXvMD0bx9X6CaeD9q8XtOtSHVisKK/SfAYidlrtP4OSgl9NJxbVkdl3QSTWk149JfqWtZIJUREb2QReAb0DIZ3RxCr3ttyy+zWcVeItUKEgmEeW2ZVC427jOjKUgiE+sQBwiKA5VBKKUeC9yJWJk+SSn1FODZzrlX7Wb7g3OmD3MEjSWTJph0H8RtbXAmw3YXKE2H2klpaVxaUq25eaHLcs+Q+dJQxyg0io1JzemNnPVJxXpekVcitzEsas5ulWwVlnFpY79C+fJSsBtVtsYpfdU+z9cbNx+ZIzPSBA+sLuskcKQK0v1VYTrEruGvYnZz2x/4BaS0XwI45/4X8LyLbtHCPliJDhEQVFr3A1zSxSUd6qTLqKgZV1JDzyuLCY1lo5nUtvGKdo7SWha78mfVTw2LHUMv1Uwqx1Zh44BaU3JpJLt3Mv3aGo1jOWqWLrrf0R6ge2B9SOW9rEvHYfZwQOFAJO8PDvrOub+aYQPuukxxmEHsU6ze+aPX9f1dJguYqfI4YFba0GCWUtOotOSVizTV0jq6iebEIOOm+Q7H+ym9VEpQnUSx2NF0EoX2f6yhNBUNgS5x1XV2fcjZ9Uu77+1H9BLNUlfEEfcyOIzGOeNcbod4CKB8k3o3t/2B80qp2/DivEqpb0XmznaFfXMWhxDoNCHpdoDrGyScFu9onDSgjZLySD81pEYxqRzDsqaoLcbbTheeoSS+zeLvMKk8c0cpOokWLwcXsgcVlVtL64RCi6ZCMxrnjMY5WikWBz3G1cGWaFgc9Jjry20/oDr9UarTH73eh3EwcbACxPcBPw88Til1Gpms3rXW3b45i0MIjn7/T1/vQxAobyuqDePSUljnF3nFfCayGKmWW21hWFhW8zLSUVcnNedHlQSCVMep5cyIZlKqFYmnelZWNJMmXnRvFuc2ZGQmCPc9cECziGuBfq8rjnqXYYZUrD4Q79d3f4j67g9di0N7mOJgZRDOuU85574aOA48zjn35c65e3a7/YEqpn22YF/o1SiFchZrMsaTWspHRpP5Yyutw2jH0Hs+jMo69hBCI3qxKz0IhZSRrFdlbWsitcNBEOWrrIuDcWHd2yoszsF8Zx98NvsMu81KivP3RtOfeuEUOt9AFeNreWgPSxwkmqtS6igyg/blgFNK/QXwE865ld1sf3DO9LMISy/8SZmLuJ6Bwta4rM+wEjOeMExW+l5DuOoPzx0fZNww6PhJa8eRnuF4P4kzD9rLbGi8XLfGq7B6emxryE4pxaSyzCYTvUTFbQ5x5bCdeQrToZw7Qb10I/XSjdf7kA4WDlAGAbwdOAd8C6KefY5pkdSLYt+cxSF2xuZbXnm9D+EQnwWYbK5d70M4GFAqStdc8rY/cMQ59x+cc3f726uAC9tUzuAwQOxTLL7gVWg/D7H11p94SN/bfux9KGepO3PklUhhiJZSI9gn1qEw3zEsdRNS3QyBHekajvTk2KtWfTxIZadazH6U8nLg/n21QuYpfK8ia5kCBYmK2sGJSwjzHeIC0N7fwy9eD44rHnBzYggF2E89JNqYBx7O9+cuddsn+O9KqecppbS/PRd492433jdncYjtmH/+K2OZafjruxp83DM4k0bV1tq56O42lxp6iY4LeD/V9H0TupdoFjsm+jpU3slNhuKEZ9cmsrbnHsJsUWoazaXFQY/FQc8HDNnnpRzhDnEJOIuuxdin9Cwzl3RIz30CAPuJ91/f49v3UAfNUe5FwNsQm+cCKTn9W6XUplJqm53CLPbNWRxiZyjdaDSNfuOnHpL3dJ05XJIxriy1870GL889SOWmkWZz6ieplzqGk3MJCx2NUkJfDVf9Rje+C7XzEuDWTam7aqBrZGCuPSdwdn1IbUWme/8Mpx5MZEdujB4UtRN22ZGeAWep+8tg94nMy35GkNo4ID0I59y8c0475xJ/0/6xeefcJcXFDllM+xyD73jFVGAY/eZrgGsrp+xMguvMU1ZNKSlTOjacw8Kvwn1/5S9WOpIZWJogERCa1bX3fIgZhJJtsws05fO6aZIHgb1rqaN0LfDBz6xRWpEpAXjqI3ZXBr77/KYEWX/+V2tvirM4pTFIQDZaoWwJJhXP8UNcAgdOzRWvv/QoWuv9dZf7PsTeof/tL4/3Q4AY/fZr5bkrlPS+GFRdoaoJg3TApBLKaaqnL98TLQHAIgu+a8mzhgCCajwgautiecm09mV8+Ui7Gly9zY6zTWQqDrifcRvv/dQK/dRI8DU6BsvSz5sEefRZVfDTq0NSvz5dSS9GVQW6HJOkPZwPVqoYokerOJNiHvl5V3xOny1wByiQKqV+GXgK8Pc0X6frL/d9iGuEmdrm+J1iSxp8gfcEtkaPVkkXeyS++RyCRJhh0MqBUiQQJ6GdC0oEIs8a/KiDUmvcvQ8aqVFktoAaOnOLOx7KycUB96/JYJzj4GUOAaUVhVsQqZJ+ujuWy6h0dBKonehYdVpZVggWee3YnFgsjhv6SfwdHZnf7p3hdAJ14V37ElSVoydD8Rc/xKWhDlwG8SXOuSdc6caHAeKAof8tPxizhzYu5DOd/5HIiQef6jb9LhgVZc+YEXecDNG2wiQd5vrH2ZzUVN5qtPYLv3NOehC+7qSVovRN6dpCN1EYHBYVy0pBa0kj+zBKga0vec6hMf2p85u7+5D2Ed7z8XN0jHhAlNZxflRgraOfGha6KdY5bprvMsg0eSUDh/OdhHHlODcsWB2XwiIzQgZY7KQcHyTbMrrdwmUSNFQxkmZ1OUJV5UFb9K4v9qgZ5h02X48YFP6ic+7Ve7LjafylUuoJzrmPXMnGhwHiACKUlaIxvF/08z/6JVlwbY3KuqjOLids3/cOsqc/t3nA1rjJCLN5lp5J0N1lNiZioWmVwuimJyAN5Eauu6obSmvIIAK9NcL3HJRC9J52iVuPHZzs4c8+eZ71SRUzhTNbBRuTis1JRVFJNnFuVFBbx/2bE471U+ayhNQotJKguTouuevsFitbBUfnMk4tdlnuVhjdI9VaPLZVCMCS5eW1oygsy13DOM+3eWqousCZDGUrVF2g6gqUQt96+0P+GR1M7E0GoZQywBuBrwHuBf5aKfWuK13IL4JfRYLEA8AE+To659xTdrPxJQOEUur7gbc651Yv56h87eubgLPOuSf5x44gU3yPAv4ReG7Yr1Lq5cALEMvRFzvn/vBy3u+zEb3nvJTxu94AgMp2Ntcxy8dRwZM6TXF1DZWUOpytcYWogJYfeCcA6dOeg3nCM5vt7/4Q3XJCunCSzVIoq85B3SKtGl9GchD1lWpHrC216+gKKbFIcNhrn7j9h7NbExKj2chLzg8lIBSVpfDig2vjkto6Tsx36GUm6irV1jEqas5t5qxsFdx8pM9cN6GfGtZzCTznR5JhPGq5xy0LHRKj+Me1CWeHBV9z685N8Gz5JOWZu1G2OmQtXSH2aMbhi4FPOOc+BaCUejvwzcBeB4hfBv4V8HdMt/R2hd1kECeR6PYh/2Z/6HbnHv8rwM8Bb2k99qPAnzjnXq2U+lH/848opZ6AmFg8EbgReI9S6rHOuUvXHz7L0Xv2i8l/7070YF6ChJW/AZWk6MWjuM5A6s5heMdZVJmjJlvY8VC2qUqcDxrlB95J+rTnxP2bR38hBlCnP8rgyKNZzYOCqyLV4Pzi7yAOxIWvj0P0lELGEAID+OBwGdnDQcNmUXP/5oTVUUGWaNZHJeOi5v71MUVlyRLNYi9jKy9ZG5Wc3cjZyism45J8VGIrS9pJ6PQSrHXcY2UIcX2h5MzWhEFqOLM5IUs0idExaDw4Lrl7dcRTT0m2daxa39bfSW949PX4SB4+2H2AOKaUak8fvsk59yZ//ybgM63n7gWetgdHN4tPO+fedaUbXzJAOOdeoZT6f4CvBb4b+Dml1DuAX3LOffIi2/25UupRMw9/M/BMf/9XgT8FfsQ//nbn3AS4Wyn1CSTC/uXlnMxnK7rPuoPJe94M2qD78+jeQGiLyk/Opk2pyWV9nEnRo1VMch6qiQSHssDlopo6GyQA9GSIqSdkJqV2yvtOW7RSJFomn5USt7TQhA6JQ+2d1GLW4AODqsuH7VXs6rhkdVSwPirjY6OiZm1UsjUqOXWkx7isWdkqGOcV5aQmHxVsreXkwxxbFaTdPvNHeiSpIR+VfHhYcHS5x9G5DkaLYdMTb1pgXNbcuz7maD+jlxrWRyUPbJU8aflwcGSv4VBYdv25nnfOXah2t9NOrkVKfZdS6m3A7yAlJnmjvaS5Ouecr2E9gLgRLQO/pZT6Y+fc5RDyb3DO3e/3eb9S6oR//CagPcJ5r39sG5RSLwReCHDLLbdcxls/vNH56u8m/707pf9gDK4eotIMsh6qmqAmQ1RdYLvz2Lnj2P4yTieY4QpUq9KwTtKYSVQffDfJU7+R+q73QmeAshV6vM7cvPzKJpU4yYWMIPQawl94KCtZB1l7yM1ZdDmeCgzZ8slr/wE9xBiVNeujkpNL3TjH8MB6zoPDSSwh3fvgiK2NCcWkopxU5MOS8eaQeiIKq0VdM04NSWqoypqtRFOMK9YXCnrdhJuP9NmaVGxNKrJEk2rFRl5yz8qIfzi/xW3LRwDoXM8P4mEHEa/cA9wLPKL1883AfXux4xn0kMDwta3H9o7mqpR6MfCdwHngF4Efcs6VSikNfBzYi4mtXUdTn6K9CeD2229/+BexLwPdZ90R70/e82bM0VOochJ7DgBq/QzJeJ16/gZc1sP2FlEmQVUluptjhxvx9dWH/yg2ul3aQ5VjzHiNXmcR0Bg/Dd1LhM1kHdHYJzRPE61IFNI8D6m5s6A02dIJHq7op9JPONLLWJ+UfPzMFg+sj1nzGcXZtZzRxoR8VFIVNcWkohiPKYfr0huyNXVVUOVbGO/up9OMclIx2iroDlLGecXZDekh3bzc5/9n782jJNmv+s7P/f0iIjMra+nl9Vv1ntAGWIARssAwOh7LoMHMjA222cxwLB9ZB9kMGA/HG2APxnhkc9h0jD3WIMxwzByxyKMBdACzD4xGgxAgdknG2t7j7b1WV+UWEb/fnT/uL5asrn6v+vVSnd35Pae7siIzIiOyqn437v3e7/dy/yZPX5rz6LP7PP3wDrsL+1lsVE/fkUH4uHCDFp3fBF4hIi8BnsBK7P/DjTl0B1V94/Xsf5QM4h7grx0cMqGqUUT+0jW+3zMi8kDKHh4Ank3bb1U0vWsweP0bKd/7TqScI8MN5NQDhI17ccUeGqO1N1ZT8AVx8wzEGreYwGgHiTV6waYSSpYTRjvoYGz8RV2S+xku32BeRxPJQWpvNQK7UVZnTpAYkFCjLqNWUBzFCgmNXiiiGsm8qANlHbkwKTm/XzKfVcSozKcV090meygJixnVdJdQmxVGrErq+YTK7ZKNNsmKEbnbYb57kXJaMB9vUs5qLqaY+/TGPh96Yrc9dpE5qqg8kq2HK91INL0X130c1To1AP081ub6v6vqH13/kZchIp8MvA2r3nx6UlV/cXJ1fV4chYP41ud47lpnFr4by0a+I339qd72HxGR78VI6lcA77/GY69xALGxcHbeftD3bxK2H4BYI+XMyktxD5I/D74gjnbAZThxyP4FtK7wk/MEce2caimnuGxA7h0a0kzq1N7qBbLMtW2w6jzqPBKt76kKSnEX9NyPcs/pzYIqKmfGA15x3yZlHXhyUTPfL5ntldRVoK4C1WSXcrpLPdtHY8CloT6aNCLiPC4riHWJxkBsgkhSloe6xmcZlwZZS2xvFZmJE++Cz/pW42g9Okc6zs8CP3tDDnZ1/ADwD7Gxo6jq7ydO4sYEiBcKEflRjJC+R0Qex6YafQfwThF5E/AY8OUAqvpHifj+IMZxfN26g+n6MfyiN7ePF7/6DvLNE2i5b51OMRgP4DLk8ln73nmy4SZxMEaLMWyCm16CUOF3nySOT5lfjzgjmP1gqTbY8AyNA2wmZr7nRFDxlHXEi1l53OnYGWQ8fHLEPER2FzaKdXOY471Do6LpNrSe7VNOd6kmu4Ry3gYDAJfl+GKEOE+sS2tXxgJGPdunnu23wcJeXzA6eS/D8RaDzHFxFtg5sQnAZrpZGGwdeRTAGofgRmUQtxAbqvp+WRb3HfkP8KYFCFX9qqs89QVXef1bgLfcrPNZA8K5J9G6tADhHH7nNDLaMqFdDITd88jeJWS4gTtxn5n25SOYmSuwm1wAnxM3TiKxJsuH+CScg2jkq4Io7cwITQKuJsMYZQ6qOz9ANCjr2M20SF/FCeKEclGz2L9AuXeRMnEPg61TFOMdYgwtWR3rkghtgIiVZRKhnC8FDpfluKygPr3BBx67xDP7C/bLbV5+asTmnV/VuzVIc9FXCOdE5GUk6kREvgx46qg7r39t1jg2lBeepDi1Hnd5K1FeevaObg64FbhRJaZbhK/Dmno+VUSeAD4OfPVRd14HiLsEg9ct/06U730nWlXE2dPttuZOlBjRc4/jTt5HHIwht0bJxsWyFdylstRAIsEL017uXQZtDfy8mOtro4VA3B2pf/jpDz3DtAp4gc0iY1IFisTHPD2dc2HfSGmNijhpOQaNAXGebDBifOZh8vEO5d4F4xxCaDOG5ufTZA5N1iHOI86TjzaZXz7LpbM7/PqHn+X0yRFPXJjxaQ9u87kP7/CSYn6cH88dAcuVVwqqqq8XkTHgVHUvdU4dCesAcZeieO1XLNlr9FH/zs+lspMt4jrYQsWZniK1qEo1R1wG2QDEzOgGWUeI1lGpg5J5oUxfMydmELeYoD4HoNw9R7Fzzy266puDn//PzzKtAvmBeRbj3DOpArM6sKgjizqiEbx3+EzwWUY+3MSfKSgnu/jBiMHOGZwT4tC4g1CX1LN9wAJ40wIbe4GheQ4gLGYsds9y+fwGs/2Sc+dnnJ+U3L854MyDiY+4Az7z48RqJRC8C3i1qvbb2f5P4M8cZed1gLiLcTAwNMg+64sACB/8VSQfmblbWtDRaFPJAjiNpszORzjJGGXSurpC8mjCarYFMKTGTZOlV364d9Qq44nLcy5OS05uFNyzUbA9zHFOmLrAIHNsDTNmWwWLwhFVcd7hByPy8Q6DHfPMGoxyxAnO71CPNtvgoDHgs4KYsg5X52TFKE0ctEDh8qINFNO9BYM6Jx9khKgsQmRaRe716yzierEKJLWIfCpmXbQjIn+t99Q2cOQ/vnWAuMuw+NV3XN3m+wAky4mpo4ZQgfO98lJtnUwLuzHJizS8RiF3Ps2BkFY4V3iz9o6DTXCeyhXksTzsbVcOixC5OK/44JOXCVG5Z2ztrfeN7bPbLLK27XdUZDx1acZiVuMzhy9GFIOMLPe4zJHlDpfI7BAi80mOy4uWsG4CRahLfFb0CGp7LD4FCycMRhnj7QEvPTNms/BkXlZq2M3tCFVzzl0BfApmlnoC+Mu97XvA1xz1IOvfljWuCvfJr4WPvp842kFTKUnzwpTQqb1SXWb2GeXEtrsMcmvNrKPaYJrk06QuT/t4nDn5Hd/F3UBMq8CHn9pjd1bxivs2CQpP7S24d1ywqCObhWeQOU5tFngnzMqaS7ljOM7Jck8+8BSDDHGCT2W6LHeEWsmS1Ua12CBGpa5Cyzv4zNFvX3ROcGn/YpAxHBec3iwYFZ4qqE0H9HdGUD5OrMKvrar+FPBTIvJ5qvqCPe3WAeIuQ5M9HBXuZZ8DH30/YXwaLcz4T32RVNWJk6jmvbkOJU4jcWBuoqPctRPlpkGs3OTVBt6ku987obNmc5hxaVbZrIdpybzwfNKJEfds5Gzknioq08pU1Tujgq2tgXEN0YKAzxzeSeuIOyo8szIgjtaLqa4CdZmMDp3gsy44iEibeTRttC4ZYu3Pa56dlDywNeD+HRM7rjvIXhhMB7ECESLheoIDrAPEXQcNVsM+2NV0NYQP/ioySKMrkzvstDbx2zAfIeWkDQ7q069TXeJkQuFzu91ynuhyqmACukWtuNzhxFnmgQWJWIztWOl4VxtDejvhP334Gf7k0oxZGXjRyVFr7T0qPMPMMcwK7tnIuJCCx6wMbA0zXnpmk9kJ+1kUPeX5rLJt3gnn9xdcikoxMMvvamFBQpzgEyFuOpNlK7OmDdM5YVFH9uY1+6UFidOjDc7oLgDV0x81PgnIHvpTN//DukOwOuHh+rEOEGs8LxqLDTRSqXUojXLXLi6aD611VaPZeGhEm68uQyWn7jF7VbT/fOGJg22y2QUrTa0oTo8L9uc1Oxs5w8y34rh54l9yZyNDtwcZj56bMsgcpzcLiswxKjzjwq49qgVQL8KsCnzsWQsCG4VlWnvzmllprbPNtkUd26yjrCN1HQkhotFI8FkaOrQ1zNgsMu7ZyBltn2Csc6Sc3eqP6o7AKpDUAMlQ9ctU9Z0v9Bir+1e5xgvCUTOHBv6VryN+5H04IGQDcmxh92FhJHVqe1WxgCF1abyEy1Cfoy4jiicmlXWZZlsX3uE04OZ2N1ucuJfFZI9KMvKjOwEcK37lI2dxIjywOWBnkFFF5eLMbDV2Bnk7bhRgI3dMqsADyf57VgZ2NnJODXPu3xpYGSqotQt7z8W5Ge5tDTM2h/Zn+uxls/PfGmZtcCnryO60agPF/qJmb16xO63QqNR1bPcr08zrZ06MeMXpEffvPGTBGaie+fh6kNARsSoVpmSo+vXAOkCscfPgXv659uDR30PqBS4bgM9aX6YmayBGULVxluUUsgKyIS5z7dzkEI1/KLwg9XzZlylU5J6VmjS3u6jxAg9tW+egE2Ej92wWnnFhGUDETApPjQruvcc6nP5kd8ZG7nnF6TEv3inYLDzzOrblizNVxmbhednJDQaZY1pFzp8oGWQudUUlS3FVnp2U7C9q5iG2AePR81NmpX22dVQuTStCnHB+UvKJcxM+dnGDz3pgm089fYLx5BnASk4A+f0vu6Wf4SpBU5a3QvhFEfkH2KjnVguhqheOsvM6QKxxZPgXfybykfcZUV1sEPOR6RlchpRTM/yD9DWYkZ84I6PFWj2HmcMLybSvRLOinVUw2D51XJf2guBFEmEpTKvAtIrsDGzxrqLy+OUFrzg1wgH3bRY8vDNkmAnPTiqiKo/sDHlk21phN0ZDNjDhIMDmYMB2MWQeBjhgv4pMqiFD79jIHaqmTg9ReXBrwKS0VtsqRKqojArP/rxmWgYuTEqevTzn0rRiL82QePT8hAuTkqin+ZTT97Gp81ajUj9hJs1rXuJwrEqJKeFvpa9f19umwEuPsvM6QKxxTWiyifDxD+BiTfSZOb/GGjffA5IVR6OZiDWo1eTHuRBUESDXGqlXt+XyPR87zyBz7AwyPnHJsoHcWfawNfD83tN7LOrIi7bNpuRVD51gdzLj7LRmXHheVmxw7zgjKJzZ3miP21c4y+45RuKIxQYiwlbh2fYBiJxdmMbknlHGwIsFp6FnWkWqoFQh2tjTWUXmhBAjl6ZGlAPMysB/eWafUeG5MKt5YHPAQ9v3c0onyOQ8APWT/5nswU+5dR/qCmDVurNV9brqhusAscYLgn/Jqwkf/wBSjK3ttYFGRCOxKUMFE9Q5lyEa8c2Mg3pu4rsVRlRlZ5gxyBxP78156akNcm9Z0s7A/rR8r8NoIJH7xhlVUOqobBbPPauhHyxceQGcR8oZcbgDBDZzT+GFopqQZwMyZ0GqDMorTo95dlIyyBYUmWNzmHF+v2R3VjEr6zQfu+TDT+1xYb9kZyPnxSc3ePUDWzx84kX4XZvXVT/xoXUmcQBxBfqYROTzVfVXDqioW9zQmdRrrHEY/EteDX/yB90GjUg1B+dwlUODiegIFZJIaxcXVo5KwWHV6t2/9tFzbQ26irAzyHnFqTFP7S/InWNaBaIqr7x3kwuzql1MHr+wz4tObR7d4+AAuvLbDuXuObYGYy7NA/NamcsG27FkmOV4J9RRKYMjc0LuhJOjnOlW4PxWydO7c2t7XdTszy2juJTacusQeWqvZGcwYme009mirLGEFckg/jzwKyyrqBvcuJnUa6w+Fr/0Q60obfD5b7ixB6+rdrGXynx+/MOfAUD4kz9AxaHZ0DIGkdQKG4zIXiH82kfPHbq9ipETo4yN3FMk4VqZdCI7g5xZZWWgG4li5x649CzDwQAJ9pmrZDjUSNSoxvM4ODMuODlSFnXk1ChnZ5Dx9P6CC/slmwPLfnY2cl553xavun+TnYFn4ADNljPDNYDVEcqp6j9LX2/6TOo11nhOuGqaHrg2OIAFivAnf2D30KFGZNHZfK9Qp9JBRDVyOPdC1QxCyq1clDuhGZ4EMK8jk/rGX+tB5Xl57nE7N2xRvzC3Ut5m4cidEBVOb2TsDDKypMkA2BxYcHvJyRH3jjzZpcfbSYPtKNo1WqjS/sxXBSLy32PGfW0Cq6rffpR91wFijTWeB+/52Pkbcpz96YzNjdENOdYax4XVanMVkf8N2AD+AvDvgS8D3n/U/W95gBCRT8F6chu8FPhWzHXwa4Czafu3pKHea9zG8C959XO/IMbUzjowvUS1aBXYq4D/7xMWHPqLgtlISRq3CvMqtqI47yBUyoVZxc4g54HNglEmbOTPTUhfL4p7XkR19jE28yGaDbjsHEMvbBaOItlyRDVLj0Hm2J3X5F7YHmR4B9uFN2+tOpUJ18T0oViVElMP/5Wq/mkR+X1V/eci8j0ckX+AYwgQqvqfgVcBiIgHngB+Angj8FZV/e5bfU53OjSaiG34hW86nvf3RTL1q4x7aGw5bnP85mMdSRu1KR+ZGC5PRnhNl1JQpfBCSJd1apRzZiOn8OaHFNMcsnJvyqmtDW4G8jOPtI8flj3QALFEQiTm8uozNQAAIABJREFUpsc4PfKcGnlCNEI7c4KoItUMN7tsYsc1rg6l/RmvCBo/lamIPAicB1ZmotwXAB9V1UcPGo6tceNwXIEBAJc0ET5DYkCzAeoz3GLy/PseI5rg4ESoNLYK8MNQxUiolEUtbA89p0YZ45QxPL1f8+Fz+zy0PeSTT926IUmD8VZ3fk9/FJ80Kl6kEzRCZ47YqOEP8EhrLGMFM4ifFpETwHcBH8Au4QeOuvNxB4i/Dvxo7/uvF5E3AL8F/H1VvaLPTkTeDLwZ4JFHHjn49Bq3I8QhoUZijYqYvcYhGUR49PdsQp241iE2Dsbgi3bQzWDrxE091d9/crclIRuzPZcU4NCNVfVi0/OiKrlz7ev2F5EiaRHmdWSvrBlk5uzaxJcnLk4IqmymIHKzMooGq9ZKfDtDoZ2YuApQ1X+RHr5LRH4aGKomO98j4NgChIgUwBcD35w2vQ34F9jP4F8A30MnE2+hqm8H3g7wmte8ZnV+UncxpF5AKC0wFLYYNi2x14q96aztEDqxefMW1nkdbfFvSklcmT1U0eZM7wwzcmdzucug7JWR/cqyjmHm+Ix7x2wWjqBmMXIQZy9PU3nKDA2bQCLYY582bK0J7uNH6mBbRajqAlhcyz7HmUH8t8AHVPUZgOYrgIj8APDTx3Vidxrmv/CD7eNbWW6KH33/0rLqX/yZhEd/zwz9DiOqVU03MRgTE2/R2na4DHX+phvhiNAGBi+OqleTDxFwljHkXqiq7rmIEqNlFlWMoJZRbBaOnYFlCmVQdqvI5UVgXkdOj3JGmbRZyfNhdzJjZ7wcJOazGRHBB/u7X4UZGqsMRVetxHRdOM4A8VX0yksi8oCqPpW+/avAHx7LWa1xwyHlrBXT+Rd/JvGP32tPOE/48HuQVKKRbJC2Z2g+IoogSVRntXKHAFm6o74ZbaOf8cAOv/+kZeCLOjKvLUsYZI7cORt6FCODLGNrkKFqAaX5Oswdg8w6moZeyLwwTxbnF+fBSkuF8RTTKvL4XsW48IzT5L1pFfEiNJScEzg19G0Q2Z3MmNWRMijj3DHO1tzdrcaKySCuC8cSIERkA/hvgL/d2/ydIvIqrMT0iQPPrXGdaBbhW4qGZ+iRogBxNsFtnrh6J1PiKsqgeHFkvrCMQyPe+XYxBpjO5myMbiz5+6cf3OGPnrrcfp97W7yrGJe8lbwIybIWJxC1Nx9aoIzKPPkuDbxZYCzqyCgz8VpzrEkZ2mu6MKvwImwWGdM0XU4EzjhpS019nJsF5kG5Z2TzvtnfXWcRNxGrRlKLdf98NfBSVf12EXkEuF9Vj6SFOJYAoapT4PSBbX/jOM7lbsPil36IweuvS31/BeJH3gf05kYkuJd/LuHD7zl8J43oYAxZgFCi1cLI7FijgAsVXjL7g0TM7K83pc6Jbb+R+C/P7pnbrEDmYYjDSU4V49Iwn4aXeOX92wD8wVO7OLEgMQ8R1a79VdIcjIG3ltLohUWtBA2EaDMdolrZogpWvqqiDfZJ8gUWtbK7CNSx4ThqLs4qTo5yhpllNYUX7ivCode1xg3ELeIgROTLgW8D/hTwOar6W73nvhl4ExCAb1DVn3+OQ/07bCTJ5wPfDuwB7wI++yjncdxdTGvc6YjhigwCMC0EoPkgZRI97ix1OWUS0+s0lZhSuEh2HS4dY3ED7pofv7B/xTYvwigXfIDc0S7YTYbxwae7LCNEe761YkjD5AonbUlilAneOcqghGhDkwovqDY6Chjmrl2AvBMcQkSZVha4qmg23tMqEBR2BhlbA0+I2nZ6rXHzcAu7mP4Q+GvA9/c3isgrse7PTwMeBH5JRD5ZVa92d/BnVfXVIvI7AKp6MTUIHQnr36g1bir8K193xTbxRjoTIzibee1CaZ5NmgJANQNftAQ1mhTZLgNREGlbYQEWly/ckIFDIdLW/4MqDiF3jlc9tN2+pl9+AjPny711OkkyyStSlpE5oYq2wI9yc1dtFv2gytDbACURRxkiqWZFHbvsQ7UrR3nnePGJUavJiCiFE0a5I4pnjZuLW1ViUtUPARyiD/sS4MdSR9LHReQjwOcAv36VQ1VJkKzpeGeAI0v91gHiLsDwC9+05Oh6o3GwtPR8iLMJDpCNHTSzmxnNE9msESknSL0gDreIwx0qHIGcDZIVRBp12uglNGUS5aVnrzCxOyrsD9Hu0lU7z/8ma/jI2T3LDtLdY1Bdan2tgjLIUkbghEGvn7UJCLMKNnKz55DEV0RVMucY58Y7NK2uoSW+O5uPROUjIuQOtgYeiaFVpjc2GeWuZUP9eRJr3CCoEo+eQdwjIr/V+/7tqU3/evAQ8L7e94+nbVfD92FOFfeKyFswL6Z/etQ3WweIuxCLX30HAIPXffUteb/y19+FOA/OobV1M8XJHn44RqqFlZjEge8FsOTbxMhR1koZlMFwGz+/DHUJziGpBdVpRHMjqstzj1Pc86JrOr8Le+ZGK5I0CAKZ2J3+YQL/Jng0r/fOMo9FrYwyR+gNlPFOGGSgatP0+h0wTsy+Q9PYUi+QZ46oihPXBqsqkdtBu+wmAnuLwEbuyAB1HnUeV19Tm/sa1wjlmrqYzqnqa672pIj8EnD/IU/9E1X9qavtdpXTOhSq+g4R+W3MtUKAv9JkJ0fBOkDcJWiI6SY43AqU730nUly9wyhcfBYphrjNE8ThVstLNJBQItWMIhsh2IJYZJsMCzVjuVCi2dBEeOW0rcFXZx9b8iU6ClQVJ7YAe7FMoI665LtzcJJY01SUO4cTbRdvESsRDVIL6ihzFhxiV8P2IhTONBD2vpIWH00jQq285VAGDlzumCXdRcTIalWYVMbHNGc2yjIGPmesL0yIuMbz40aVmFT19S9gt8eBh3vfvwh48movFpHPBf5IVf/X9P2WiPxZVf2No7zZOkDchZB0p16+58co/txfv6HHrn7jJ9EDpLRk1oIpziPDAmKwTCJG3HibOBjbXOtQIfXcFNeNfcVsl2LDkfucKcJ+GZk5YSMfUcuQEBVxBdsbA2S+1/IS5YUnKU49eKRzbhZoML+lUWZtrXVadiO2GDfBwqfFvKk0DDJBU8moSLqHeYiEtG0zt7bWhjcoolJFpYxKrCNDL6aaTl+NtE7dT657TzuXbqJZE3SaryIQYkQGjrH311VyW+NwWBPCsbr1vRv4ERH5XoykfgXPbd/9NqBvuTw5ZNtVsQ4QdyOce8GunfXv/BwA2Wd90fO/OLnINlDAjcY2WzkGI6CzIbiss5oOadpcsA4nCaWNvhRhY/MMiqOKyqy2dtIyKFEjC+c5sXGaYt7Zdx213HRic4OwN6WOVubJXKPBEKIoJC4g0pDWVi5qHF5VoRFDx0Rshxgpa2UzrfAhKhF45NQmYF1Ts1qpYkTVsVnYexbejt2R0LAxGjKdzS3LiPa+XgTvheBSluNNud2MGZVUaqrOPgZwzRnVGofjGktMLxgi8leBfwOcAX5GRH5XVf+iqv6RiLwT+CBQA1/3HB1MAKLapTyqGkXkyOv+OkDcZbjZvIM2ba0pMGgMxj9A4iG8ZRRuZCRzrJH5Hurz9tZYXQa+172U2lpFI6Msx/fu4EaZLawRWASF4UnyemZzr68Bo8y1nUeNB9K87rqIcAqxK/+KGGl8kKN4yT1bPHp+n6CuR2hf+boGdYA5kUE69umrGPeJ0AYPjYqkWRRECxRNy6wXyASrca2Apfoq4hZ1Mf0ERi4f9txbgLcc8VAfE5FvwLIGgP8R+NhRz2MdIO5ilO99Z/u4eO1XPO/rm+xhlVCee9wyJrF/DU/RCO7g5jvE9vHo+f02uByGpy5NeODE+JadzxrXBl2xiXLA38E6mf4plgD9MskN+yhYB4g1rhnPWV5KXUoAUgyX+QjnjX8orbwkztkwI4CB60hqjWg27u6ANaL5CKlmeB9o3ZdEUJcxyDyiSsTstzUb4Bb7tt8RxGPl7jkyYKPXFlruTVG1MpM4RY0dWGqBhSRwc2b9DfDYhX28WEYyUG1JaScs2XTE9qtSB+NWmhkSFw4MFZrO5qmzqTtnVRPbaeqMMhsPey7zwqkDM6WrZz/RPs7v/aTn/UyeD+EPfxkA/+lfcN3HWimsmJurqj6LCeteENYB4i5G8dqvaLOI8r3vfN4s4ii8Q0N6l+/5MbQuLSgkzkPr0spPTcsrRphLYZ1I6k0TIRqhnKLefj21GKPiEhfhuoXf58TBJiIORPCqJmB2Hs0KpJxZphBZumWX9F4S667FFgsUYPqBZv5D6BHCsypS97uapCsh9RfviJWERpmppttuKGevz6QZV6q4YGWjxkZjq7i6Z1YZFEcnwktX055j5qzENMwcWjkGiaSvnvn4Uo1rsb+LzPdw5aRz1U2B2r/4M69438ZcUcsrO6Pq3/m5o/FRdwiU1QoQIjLEbDk+DWhbClX1ilEKh2EdINa4KdAQEOeMd4jRuAjsD0yct06qrEDywXJ7q/OoJklYSLfEoTJ+oj/5LNYQSlwMaDFCs6EtdrFGizFxsIVLQ4oQC1CidcpOhp0KuzlWEt+BBQqfDfAuo0xkeNRmLkO3OCidWrq5gqbLqCkjNYt5f1EJUXHOMorMKxnSOrjuV7ElshuUIVJFyxoyZ1yD62cjqjgRfD236y2XRXL5fS+hOvsYceNky/tcDeHjH1j+bOQqAct5dGEBo/rNd7f6luLzvvSqx74ToAplvVLczv8BfBj4i5gX01cDax3EGkfDUhbx6++ybTfoj1yrVG5yHlcMkdHYMogmMDQLUKwhBsTnporu3fJLKJFQoT4nDreNtK6maSpdChrNvzS5TlWJ4nFZAYuqVVs3imuJdcdFJG4iFmOi+G6RjQGXMpioSScBOCdteciLlXgsY2gGC1mdmrQtF6iT0V/DrTcZQ5aChE9DgZpgcrDE1Oxj3lB2DaPhsr6kn/2Atfk2KE49mIJsZK6eoDmj8T1kWQG1fb6mOTlcO6GDTfv5ON9yOWhMQWK29NrFr/wwg89/AwDTd3031FVbZtQYEecYf9WRhby3HRRdqQwCeLmqfrmIfImq/gcR+RHgucz9lrAOEGu0paUmQFS/8ZMA5H/2r7yg4zViPMlz3HCM2zphOgdoSxpaLVoTP8nyVL6YtzwFYAtQOqYUQySNI1VxuLDoOApftD5OKg6p5zif24Kn0W7rfZeVaIyIjx1p7TxRPPM6UvgBeZrbXGhNNsipoym5m66khqMsvBCTQrqBY9ll9uBi0rTHxqSebuw5rCNKDp04lzlhnOzBVcH1uhoX+7sEP4BiE6eBxeULxu8cOEZ+/8uozj7GcPMMk9rahAfFFlkRkXphnE0K1gqp1TigWW6Bty6J+ZYF5mTvIbnZyEes/NRkFM+HvR/+NgC23vBtR3r9bYUV4yCAhhS8JCKfDjwNfNJRd14HiDVaFJ/3pW2QAAsULzRIALZQjZIIznuknFlgAKhLdDFHBkPwG7C1mbKLvGfOVyPVDGIgTi4jgzFabJqJH7P2depzKxHVZcoOHG6xZ8K7Jmg0nk0a7TGAz9L2vD3lMiguG+BcCl4xUGgEnyVTPbP1DlFpBso1jq2qineC9PyTIHESJBpAuxKUCfC68pSTroD17O6kVVkD5ELauWdQONl7zo+/LdE139cL3GKPjeF2y43gHFk2QHt8jM0Od4j0SkzO2SAnl7WZhr3GQdxrf97QZQ7t7wAQ6woNEe21KF/+oW9l+43f/pzXcLth1TgI4O0ichLrYno3sAn8z0fdeR0g1lhCU15qsohrEsYlDF731Sx+6YdQQGcTK03UJTGkRdd7tHk82qLeeRC8Lfb4gkU+JkRlRGXGfaHGuyet4yl1LsVihNQVmuVm+Kd2J0wqg0g17/QTzV0xXWYCdKWpGHAuI/dC1G4hb/aVUFFIlRZLW8WNULcg0V8umiyjX7l3mKIJrKQkXtvHDSIQgmUqIjaNrg9t5kukN9ufzsiByhVMy0AVSTqIoZWifGW26SSSWlNeE2tcNWfgc9Rb95fElE1lhfFFDOyzlN5Y2LrqTBJ91gWfekGcT9CqQgZD4u753oVbM4LkOc55tC7RGK8IFKsEXZEMQkT+nqr+a+BDqnoR+H+Al17rcY5hzNgaKwHnWrsLsIDRBI2jYPD6N6LlnDjdI+6eJ+yeJ073rCYdApIXuJ3T5tg6Pk052EHqEn/hMUaXHmM8eQapZmgxptq8l/rMyy2bUEUHXVZC0/lUl93MiLTot3X1UNrj5i45ZRGAkd7p+YYAlnT333ARrVivd/cu9cLmNUjnuNoQ1NYKCz0Ba1vy8Y7WdiNPXUeSfJmgc3EFW4jK1KJUR2U0HHakOzAnM3EgKftQbYOV+hxNJbkGmka6Sihx1QxXTtsMzQ6SQVZYsG64huZzgGVjxXQcrSt0cpm4fwnqChmOcaMxMt5GBkMkN8t2yS1LW+Xg0CBEPdK/Y0YzFezfXM9Bjmvk6CewyUYBqFX1NSJyCvhxrD72CeArUuRb4xigdYUrhtaO2mtvrH/7Z+z5tKjkn/3Fz32cxcyITOeRvKCln/MCzYbWblovyHyOm16ifvRDSJ7jH/pkI4NDjR9CmY/xWSJm69ICRWP5nQYMaTN1bm7dTNRV6ngKIBWImPYiG6I+Nz5CXCIOAq5RX/fJWO+IaWHVRhGuioSSXCAmWw6HtbvGAy2v0JWlOvq68XFKeY0qw8xZEMjMxXWUO3qJDFsbIxb7u+m6jRxXtT4q76SZT9S2uqpLgRNaS/UlQl+jlYegI5373UtNIBCHamzdeC1odoFYZxO0nBsXsXcRt3MaNrahnNvvTUNQh443kcQHrSIHEdWcdVcAH0rr7L0i8vu97Wb3pfqnj3KQ4ywx/QVVPdf7/puAX1bV7xCRb0rf/+PjObU1DnYyVb/xk63pXh/1b/9M2+KotZUkGtJ7+IVvYv5zb2/r0E3rayznuCy3unw9Jzv/CZheIpx/2niE8RZx4wQ62ERmu7i9GbJxkjjcsg6m2haupt01FiO7+401BI9Upn8gy42Qrhct9yH5wBa4YsOCRDpvoex4iqywu+2m80kcKslhVQRFcElHkTsjsRs7jcNIZpe2SyKZ+6K3ph12VsVkpWHbm7bXw+CqObnPk75E2w4qJ41NSBL1uaxl1A9tbW2CwIHgIKHuXbuk7EmXAoNobG8cGrGjziamaUmNBpK0LsQAdUU9naMhcuLN//LwC1sR3AbZwfNCVb9KRO7HOpae+y7uOXA7cRBfArwuPf4PwK+yDhC3DRqyupntICm76CunG5Tv+bElQ0DJciQvkKG1bmpdofMp4s+jswn1+afbu03Z2MaNxoRiwxTRscbN95ByStg6Y902rmeZUc4QXxBHQ+tmyiKSD1ttg1RzE9jN9qxO7hxkAystNSfcHCuVb+y+HstIxLUZhe8PXNKGpG0IaMFdxYLBZlxLr3TUbDc/pSxFC++EDMtEqmhOrnowSqSFXOoFeT7C+66E1NqNN2U2WO4KO+Q43c5ueVsaRiGpPRZou5cQ16q0tffz3/jyf8T0x/8VbuuElaqct+6nxYx6Olv50hKsDgeRcBb4A1V99IUe4LgChAK/ICIKfH+asnSfqj4FoKpPicihPsUi8maSl8gjj6wdKm81is/7Usr3vnPJhI8kiJMst8W/V5KS4RgZDPFbJ9q7y3DxWcLFs4TzT1l5YjjGn74fyQoLJhs7qC86TUS9AJ8jqbRECK34DY242a6R10UKQC5bGleq+RBXbOAm5+39sqpVcvfNACEt9rG2rp6ssOARAF+0/k3top1KNN5ZcAgq9NeOJkvwpJJS4gm8l7bUZiZ7ydo8ta9mTUzQjpQGGGzutHoHNEI1wzcjWcV19aiGY9E2Elkwa/ZrCOak8zhUDBeTq27/s0nHVHFmmbKYd+aMCRtf+c1M/+N3IqNxNwukrros4w4IEqvixaSqQUTuEZFCVcvn3+NKHFeAeK2qPpmCwC+KyIePumMKJm8HeM1rXrMaP6k7DH1LjoOaB8nyLng0GUazgPi8LfX4k2eon/goOI8/fT/+5L3GR1QzwvknyTUStu9PPEBO3DhJHGxaMIihE8o1ravVrBXUSeq0MStxT8wGFnCyAe78o+h0FxltWRARMbuONIeisfcgBqQu0WYNbRTY0GYc1hlkM6VVrL1Vk84BlrmIxiE2phkRzS9u5sw/anNjxEEs9nev/Oz7flEXnkyfTwH+QPmvDQ7uymyhQai7INF2dMUuOGi0a9Vo7rqkrq5qRpxNiPMJce/SFfqH6vJlcpJGYjah2p8ArHxpCVhFodyjwHtF5N3YLAgAVPV7j7LzsQQIVX0yfX1WRH4CG7r9jIg8kLKHB4Bnj+Pc1rg2tC2tdUloFoqYhm46nwYDBSvv5OdtMYmBOE9jPrOcONlD66rNQMIzj1E99scMPuWz0NOPEIdbqM+YyJCtjZO4/XQXLdK2XLatrG05pLCSU6NxECEOt5HNU8ilp9HFFEYZkCzHU8BpNBLt8eqyrceLlKhmbSbRvNY7T4hq/IMsB4BmLcldIrCXjP4a+46rfLabO1d9rjz3ePMOFhAhlX+kE1qoNpRkl1E02cZBTqKnEQFr45VQLgeO5tqi8Q9x7xJx7yI4x8aX/oP2ULGsqff3yZyjvnwZcW7l9A5XwwpabTyZ/jlg61p3vuUBQkTGgFPVvfT4CzGPkHcDfxP4jvT1ajNZ17jN0JQPhq9/4xXPNSQ1kPrifVe3zgqG/93Xtq+dvuu7O41EXVGfe5psfJI42sEtJvjBSeJwGze5YNlCPujeKEaQpu6e7npjDQy6dlVAsyGuGBJnE9wwti2wiEPzQdsJpQ1HkYR4LZntI0phdX5JE+DwVhZKpG9TgrL1Oamve59JZ8uhbUvtC4VotC6jVgjY2I+QAkG4IoNQl3XlpsOyi6Qkv6IlWNWU1rOJBfXp5ZaD6oveTn7td3Dxbd8EXKaazK48/grDhHKrEyBU9Z9fz/7HkUHcB/xE+iPJgB9R1Z8Tkd8E3ikibwIeA778GM5tjReA4Re+6blfEIOVoIpha8twGPp3oZACxmCIe/Gno/kIVWU35pzcOIGUk44w1WiT6A7aeze2EM6jWWaEq/OQDZBBbD2gICTiOiJYG6cd1kjrjrCOLYHd2XRg0/EaaDTeIN3Np8p/17mUgoqTZK+RJr/BlSWm58KSoV5q8+1rJEjn2L6m+V77RiDd57RsXhi67/tInUtxmnQPWUGc7BHLKzukTn7td1zT9awMdLVKTCLyf7N8fwKAqn7+Ufa/5QFCVT8GXOEprKrngbvMXP7OxfwXfvC4T2GNNW44VtBqo3/XNQS+lE7Y/7y4ndpc17gDMfyiNzP/hR+0ksRs0pajRn/p6553340v/QfM3v19Rn7f+2Iuykn2ysjmyfvJd59IbZTpDlzEykye7i45VFDPzUMoHxHzIbIwPyFiQGvjQNosJIZeiUYRz1KnU1t+Auvc0giadTMu+qplAPFt66lDDrShBstoeGET7fozpqunP5qOm1xrs0FHPjdcQ1N262/T2HWG9RXSTXmuKS8l4prFJPEOl9DJ5dalV8PyeNdnvvPv2lvmGRoi9bxsu5ce+mfff83XejtB1VTtqwJV/e0Dm94rIr921P3XAWKNm4J+2el5S1DPgdEXfwOzn3wrWV2Sv+xhAHYXgXt8biWPbJAW8BLNh+3kOUJpQaIuUakRl7FQx3C0g853rWw0m8BobNoI51suAlhWEPcN/1yWFnjf2Yf3hxgliPRKNI3gTHXJskPqo7mfPh+aclD2wCsAqJ/4UDtkqUMKCrHHVxxE336kUUw3jruxts6lyWXi5HJ6XUBjwOXZSlt4XwtWLYNIDhUNHPBngPuPuv86QKxx22P0V76R6X/8Tu57+NPY2nmQMiiaFbjpRTPNcxmagWaDzrgv9Orv6W7aC0SX4/KNTsNBItn77qNNwGgW/phcS3236KtmiPNoz69KenfmLRF8sO7f1PgTX1CcOFTuc13IHvpT1E/9F8sa0nW2NETz/lxJXredTn3PqZRN6Dy1te5fMmvvlAnWkyuDXEzZgrjI4OQWbjKjvDy94nWrCFVdtS6m34aWOquBj2MT5o6EdYBYYyWw8eX/iPnPvo2tT/1s6hMPtu2nS2NDxRlhK46Yj5IKWFMAGZCHEqmMqJYsJ9YlLNyyu6xP40qhtbKUpjsJkDg3fUdTXiIJ85xbyj6su8imQ7TdRPSOV78g3dLhSAt6ePT3aOXabemscYHtnUfffLCfSTTb66rXFWXEdNg9T7h4NgVQT5iXrafSFaeTAkQ5n5KPR2a5cQcI5BqsUgahqi+5nv3Xbq5rrAzi3iXqpz5Gdu7jSDkxJ9jeICKpZrhq1mUNzrdqYFdOcPvncPtnjZuAbhxqVdls7IF1EuliZorwurLXhgrqhYnp6oUtoNXCylj1Ik1kq9tuIjtI7DyMQmVai+QcS6xtv7aD6fqQPfgp3WzpBGn5g8SrxGDvp7HTN6TzXAoUwVxwqRf2NVSmmF7MjUOamdaqeOBFZCdOId4h3vHsd/+9pfdvAsLs/G6bbdwJaKw2bnc3VxH57OTF1Hz/BhH5KRH5vgNlp+fEOoNYY2Ww8ZXfzOJXfhgdbaP5RiKlMxN1lTObD5EPWlsOqWY009CobIGnIZrTKMzW1WIRoBH6Jf8irUqzFO8jK5AsCc5qrOzUZBcOCLETrcHyYgyt6OzQNtLrgH/4M1IG0fAI0pW2Wk1IFzgaE8KDgaJrlQ1Lbqx2TOMcsjMPIYMRoZwTy7rVOjz1r7rGg2xUUM9KsmFhs8mvkm2sInQ1MojvB14PICL/NaYv+7vAqzAnii87ykHWAWKNlYIMhoTNM0g1J7v8NHGYxKHOLymhCZXNgmg4glh3z8EVJR7zFIrJZDCYKC4rkNGYOJt0xoM0GrSAZKlbyceuu0mkZyPevHdc1hlASxKHT/wu/pNedWP9eSMBAAAgAElEQVQ+nJ5+QV3eZQd6lYDU3x5K87hq4DzElDnUlc11yHIorWMrziboYk6oKvLxaEkQlw0LqskcV2QMTm7dUeUlM7VdiQDhVfVCevyVwNtV9V3Au0Tkd496kHWAWGOloFVFtvs0zPds4S5GZqnRN54TZy53MbWStgt/RLCFUEOwOdcN/1CGNqNovKS0Lol7l+x9+xwCQDHs2l8bQV3DVSRRXevd3ZRw+uRvrJHSFtXwid9tn/MvefUL/myafcOH32NZVK9zaQnOdV5W0NpytNlODJ25XgzJVuOildacR+eT9jiDE1vEqmZQbLG4uGc2HDFSbG+0/EMsa0and+4Q8ZwuDYK6jeFFJFPVGtOXvbn33JHX/XWAWGOlMHjdVzP/2bcB4HZO46uFtaDWNhBI8+HyDqnej8/RYmTdSpOLXdDAiGmywha/5E7aupS62LrVtr5SIQUbl+7O03s3NuTSr+k3OJBBNAZ41NWVr71GxI+8r33sXv65aWPoAkBfSQ2WKTTlpGZ787gJDsk/ixhbTibWFX5sGZvWFTIYkeUFYe8SsawZnu68o5oAE6uaen5juJbbAgphNbqYfhT4NRE5B8yA9wCIyMuBK10gr4J1gFhj5RBnE5sZcfEsAP7Bl6PFqFvwEgmtwy1IYzXVZbYwLibE2QRJU9ZsEQxWPnEOIUecJ86trKRZKivFaEGjThlEXpjQLk1Za3yQGluOK3gHuKJjSMVB8pNyKZuIf/zezpm1GdpD10LrXvY53efwkfcZ/9L7bMKH34P/1D/XBQ2XdZqHpqTUGvB1waBph5WmxLaY2wAo54y8n+6l43nbJ7UDy3DDXhumaIi4Iluy3hB/Z3UwKVd0B9+WUNW3iMgvAw8Av6Bd2uMwLuJIWAeINVYOzR2/7l0knH2C7MxDxPEpKCdWtslyNN+wEaFZQTPH2rqOSlv46zJZkltmsKSLSJqIZiiSHjIUSavSylOp7bMd3xkduHAluQ1dUGiuo7fSqM+NVH8etK2sPW2F5qNW6dwg7l2ymdBZjhy0Ag9VFxgOkNAxGBdjczNyCxxDummCMXRzPxoR3WCIlPN23nS5N8HnOa4wJXWxPb4jrL4b3IoSk4h8F/CXgRL4KPBGVb2UnvtmTMsQgG9Q1Z+/ynm+75Btf3wt53HntBascfcgTbSTvEArG1DUtppqbO2/AZs/XYyIgzFxuAPjk+2c7Vh2d8kNMW0iMOMn3NYJ3Gjcjsykruw1aSJeax9Szm3ORX/6Wgjdvxjbf00XUWth0SDpNejNrlCfW2aT5UkEOFj6GDQf2fOwlJ3YGFjjT7Sco4tpe35aLZIwsESrEk18jC7m7WcZ5xPbP3UxNQHSDTcsMNeV7buYG1ldlVd0Krkia7eJd5z7vr9/E34RjgGJpD7Kv+vELwKfnmZH/zHwzQAi8krgrwOfBnwR8O9E5JC7kRuDdQaxxsph9MXfsDSoSKsKQkkcbi/X1mMw7kHMqVWHW8RYI5fP2R12XnRdTS52RHTyaWrKLG0ZKqHRTeBSp1KVOqJy4zH6E+qsndR3fEAI7VyFg3Oer4Bzh38fox2zvz0EpBgR9y50rwHC7nnccGyBJC+662sCV3OeKbOCdN3NvOmURUgxtLtJ5y1LamZ+NAOGsgIH1NM5+bhzphXnKPe6zGb1obekzVVVf6H37fvo2lK/BPgxVV0AHxeRj2DzdH79ZpzHOkCssZLQ+aQt84Td8+TjLeJW4hWS5UbbbirOiOowtPGjeWHBISQdRNYrwTRzIxbzpQFIzVcjXysoUvnGeQsWB/Zv0AzzadtP+6NBARsr2rO3aLudHFd0Hy19AOkgB17jxtt2h79r41U1BDSr2vbcQ4/ZXHMqOUmaHmcH9Pid0zYQ6vzT3fVlBULZvS59NvXMCOlsNEjHXIGC/TXAJt4e+ZruEZHf6n3/9jQR81rxt4AfT48fwgJGg8fTtpuCdYBYYyXR3uFWFTq9TJzs4bIBsRhZqabRLfQFYOXUAsdwE7d5wu6aoeUiqEu0DF3G0G9tHYzsrns+6RG6vhuG1JxXXQHVEunb5xrkoEBtaedlrUWnvqNzq4XljKPpVG3EcM0iXwzt+pK2oenAkoPn29N/tJxM2p8YkMGwew6WBz45D2kutTiPhogvLNjGsjY+A+4okhquSSh3TlVfc7UnReSXONw475+o6k+l1/wTTJL5jma3w07pqCd0rVgHiDVWEqMv/gYbKJQbYRrnE9z2qZQtzJFqal1AaS51m0VoJBajduFr0GQBTeCRgbXL2qjU3BbMumoFdpJ3pC0cIIHbFll/xV27NO/ZLLi9DqIWDUfReCGJ4zC6cEn81mQoPfJZiiGSFV0gzHoltZ7OobsO2kDQZhF1RZzuJf4lkfeJpG72j1WN+NjyDXBnzJ++Gm5UiUlVX/9cz4vI3wT+EvAFvS6kx4GHey97ETZS9KZgHSDWWFkYD5BsMSaXO8+j2WUje/MBhBJ1I9NDVAsoRp1HUbOYZocs8M4ChOS2sNJzfJXBqL3TpiaNUl2+y17KQJoSTkjdTc7TzzJMU9EEgN5sid5Eu+fqgOq3rbb8Qh/NZ5TU4XogO+pjaemrS7QGqjIFibIlqcW5rhOMus0SXJ6x9YZvu/oPbcWhekMI6OeFiHwR8I+BP6+qfSvcdwM/IiLfCzwIvAJ4/806j3WAWGONNda4BtwiJfW/BQbAL6bxzO9T1b+jqn8kIu8EPojdnnydqh4e7W8AbnmAEJGHgR/Gam8RI27+tYh8G/A1wNn00m9R1Z+91ee3xupBq4o4nxIunsXFSFzMcCNMhNY6mpqLqca8tdpoWjgbIVybVUBXcundcWvolYPqytplAdKdeXtX3sxgaNpcoa3zL22jV9rq8Rl9q3FCtbz9MIX2kvo56Tya9tT+OaUsokVzrf1uqX620+wzTy6uziGUVm7LCqgrwmLRZg93GiF9NdwKoZyqvvw5nnsL8JabfxbHk0HUwN9X1Q+IyBbw2yLyi+m5t6rqdx/DOa2xYrj8Q9/a9tprjDjnTGE93mptu6krJAOqqXU0+cJsMdJfeKuWbhbNGG2BTTbg0LV/tvMi8qJ7TQiIj4m4TcdILafN8a5WyrHn08LuXMc8JqWypMd2DtVyCaqHPuegIbRlMG10GyG0fEp7Tv39m06upSDRBA4LEHE2IZZzO4esSPM00lfvCHO7dpff+QUJXR2rjRuCW/4TVdWngKfS4z0R+RA3sU1rjTsXjaWDphr+EicB7ewFXNYSvu1s6cEImU+7AFCVHQnrAhrtWALprjwtzH60RCpbsHBdUOkT3623U2w7fZbQBIY2UIT2GpoRYG1msHThvbbbsJz1tF1JBxTS9jUFvRA6k8Lms0rnrdWyalxr03w0n3W2mTKlOonjmv1CJITyDjHkew7ojSOpVwHHGvJF5JOAzwJ+A3gt8PUi8gbgt7As4+Ih+7yZ5Ez4yCOP3LJzXeP2givsV7e5e7U2y2ACuOEGbjS2jiTnbX5D7EomjfbBjbfSnOW9rhzTeA3FiLhgAaGHJQK4pzLG+URAuy6AuOVOoX6mYs83d+SuFZtpjEjizE3l3et26r1vey49y4smEDWlsiYQLAnigi3uGv0B8d8h19Rsmk2IVd2ek+R5F5SLIS4vqcrntwm5M6DE1XBzvSE4NqsNEdkE3gX8T6p6GXgb8DJsoMVTwPcctp+qvl1VX6Oqrzlz5swtO981bi9osAUq2xiy86b/xRb2eTLia7qM0p2/1pVZQsyTLcZsz7qDRlutaR/JQsO0As68h7KizSzaCXPtIh/af53L67KGQkuzoqCuOiuLxdyO2XAF5Tzt3ysVNa8LobuGJovpB4c2c4idN1JzrPZzCt2/XibUtanGpWvpn7uWc+LkcnusUFaEedllHqmzS7xrbb7PvvUbb/JP/nhhZn16pH93Ao4lgxCRHAsO71DV/wtAVZ/pPf8DwE8fx7mtsRpo7mgb1Pv7ZEA23rbFXZILafIcgiSqSyUlB8jGDjIaIylwCKnU4jySPJjiJNlONIFhOF4msmOvTNP8NcVecIpxqYQDXUmsWWjNATa0GYP022Zb91THQXuMtqTUnAtd+ejKD6y3qPfOuRXGZb1yVgqEzefVZGmDk1tdWa9HhseqtrkP6WfSDxJnvvGtR/6ZrgTWJaabC7GerR8EPqSq39vb/kDiJwD+KvCHt/rc1lgdaIhoKuGc/7f/kNNf/13sv+Pb7e58PknZQU5cWOlj2T7CoYs5MtpCN0+R5QNiMUxZQpchtEZ8aQ7zUpmn6Vpqup1orCx6C2zrU5QTG2V3lneLc29Bbp1TqaxUleWQHZDN9i0x2m3LhPJVg0OCidy6DIL03lr2OqGSxUiYTdsOpWw8xG+dwCWfpkZp3b5FVVNenpKPh3fUeNHDsCIT5W4IjiODeC3wN4A/6I2++xbgq0TkVdjf2SeAv30M57bGiuDEm/8ll97+LYSyq5fHsibuXyKOt/HDcbdgpjKSkGr6SRiniymSDYjDLeR0geyfJ+xd6so8/TbRhGbxXJpf7Rw6myB5KttUnfGd1et97w6+d7y66oJC4j/EOZSiUyu7JgBcGRRau+2e4K49zyvGh/Y4GOfsM0jn07/O9vqa40Sz8M42rGwneW4ur+W8fQ5s7oMrMup5Saxq8vGBwU13CFSVeIdZhzwXjqOL6f/lcD+RteZhjWvCQTuHajJD/AXc9mlcf6ZDNoBYL5G+Mhgh+cAWWZcRhwU+lMhsgs6vnP8AtiDr0iJsj/1oA4A4udw+bzyG2ZEbKV4s3Z23SN1XzZxrbTqnorWnam9hX0IKYjaTos9LpEBzIJNospu+yrux7YaeKr1RlSdugaq7dmnLWJF6MscPi3YGhDiH845qXhLLmjJMuVOxziDWWGMFcfrrv4tLb/8Wm5lcl8jGDlrOzKivFYzZLAjx3oYIZTlSz5Nv0wA33iaUc1jMugUVOj4hdHfNbTDw825biF2JpU6isvS4WcBjXS3feWc5VBXkebeAN+S586a1aOB6Lq9NRtIEhJ4ITkl+UT0NR7tPIsZ1Me+u0fc8mIKdYyxr6tkC573xDLOJBckQqeeLdoJcPV8Qy5pQ1lSTOTG1yr7sX//Y9f5Ib0vowWB9B2MdINa4o9AszuZ7lMMoRycXkxK4p19YzHGj2uZLazRb7nyAnnqYrBhSPfbHHZncDBQKkVjVS8GgQUPeine43p+VpA4jIGUEkVjOksGd3aFrHtN+0Jab0lCftg22wQEH2cY9dslfqXnNgQDXBrly3hH2JP5k0VNOx0A9mRPKyq43RlyVdS3F3uHznBgClPY5VJM5i0t7lHuWOXzqv//J6/kx3r5QXQeINdZYRVx82zdZy2Vq0XTVDM1HVs8HU04niwyKIVotrPzTjODMBzZ9brSDP3mvHSftc3BRaIJDDIE4s04el2f4pCxunE3785l9SzJHQlnhvCmRI7XFhbLGFRkuJjuOpGFY6oLKCtNnsNx1pD0y3rKPqgswdqLd6w6xyGiO3yijm5bWUNX4PKMME1yekY0GiHPk2xtUl6eWPVQ11XTO4tI+obyzF09lHSDWWGNloSES9i4hw7PofIo/eQbdugcZbZPNLhMunm3vnJtFtbXwLmc4jeAL5OT9uP1L1JPLbbmlKSlpiMQQlkha6BZ+AELAF3nb/inetUEk2xgizlFNZq1y2ef5UvePpDJTO3e658fUtKc2Nhh2DT2LjSoFwbzotqfpeK3gLcSlkln73lXiGKZzQmnnXc9LsmGBHxs/0QSRGCww1rOS6vKEUAZCdYcTuKrEqnz+190hWAeINe4YiHdk46Et4BefRadDtCrJR1vE0Q4MNnFblbWvJlGZzV2Opr7WiJQzYEYsRrjNE8j5p6w7KpWWQlW1i2qfsDZdgy20hw3Iaawo+tyDlZu6DEOCw+VZS/qaZiN0nU6p1GUlpE4kF8s5MS3mttBXuGLYEtDUFbGu2hJR/3ybgJYVGbGsqSYzQlV3eocQyUbF0nXEZO8dK+Mdyr0poarb4PCZ7/xP1/ujvH2xLjGtscZqoprM8MOCbHsHDYHq4kWyqkJGY7Iz0TyZspzYqJzT3bvOJ/jT9xuhneVGYouDgbmW2kJYtQt66PEQQI8/sCwihohrMoZURmoCR3+RBrMMabY3ZZ5sNGizDajbu3vXtL72Oo3qaWdxEasa7wsrVWWdvUdIradN5tOcUxPkDor4+teWj4e4IsPn+RL30p8WF6uKalLivLDYXVznT/H2x90UIO5sRcsadxXOfONbmZ/fRasKN94GYHHuAuHsE9Rnn0Dn+52tRYO+LcbueeLksonWFhMky/E7pwHa4FCnNs7mDvqgortB09FTzxdtx4+9XVjaJs61LqiNXcXB47ffH/BIqqczNEaqyaxVM4tz1n4aA2E2pZ7O23MU73DeE6qKer5osyGgHREae11a2aig2B5TbI2NG2n8ryoLluXlqQWfsiYbZndHcEgcxFH+3QlYZxBrrLHGGkeF3l0ZxDpArHFH4cw3vpVLb/8WBoMh2caIxaU95k88yRA6tXC1rJCWDcs2tJy3Cua4d8mcSje28MOC8vLEavO9jKGdRZFKQP277wbVZI5PZaT/v73ziZHkqu/451f/pnt6Z9b2OkGLwbGJuAASwSIgQeQDUhLbFweUA6dwQLIUYSk5cDCCAwckCBKRckBI5p9QlMAhCYoPRCQKSByQiElkGzvG2GALLx7v2sPszmxPV1fVe4/De6+6erZn2QXW3dXz+0it6a2pKn/Lb/f96v3+PZgFh5M8a+MQ8a3flFVohmfbVFLwbS4iNuzzEM8DSAt/XnzDB2gOy7kYQxLqHKwxc26uJPfpq4aZeynGVqLG6OKytY9RRDeaz16anKjKYnBYNRCK0l8mu5cwVe3dI9sjyt1LVD9+lo2bXqY4cwvJcNTuiuYO972BiHs5JCl2vI+5tOs3HwppojHu0BqFPGvbSfjgdTNXRNelmVRI1XRqNPwEm4YJuHvMVg1SNWSDIlQnpzMXkZmlosa4ga2aOQMCtG6pmGUEs6I+f3xep+kEpGOsIuv0VJoFpL1rqZlUM2PRXnMyqoudc9hGs5gUpbec/djneelTfw1APvL7OUz3LlOPS7bzjGLrZmS07VM/Y7vtQLddt9l7hfT0GdLhJvlo0Ka6xvTPOMl2g9ZxUp3LGOqkr7bppaXF5t6vn3Qm/BiHaLrXVbP7xHRZ8G/46WCWYQTeODQh9tH970XjEnslASHVtpwzbElntQPMZVnZupmtHELcw1TeOEz3p9SlP/d7734Pd//g+9c4Wj3DufnK9DVHDYSylrz+E19g59MfaSe1dFC09Qhxvwd7cJF6b48kpHh2XTSS5dBUYX+JAfloSM0EWzWkRYYN1cPxnkezmmBmOOJKQex8Tkj7dn/EgJi6IcNP5lk4L1ZdxxVMmue4dD4DKbqd4sohZlNBZwVR++B51DRb/cx3go2ZVXNpucZesUoyZU1dNljjsJXF1Os/eWoMQlHWAFs1MCjIRwMm44s0wcdPkmIPLjJ98XmmewcU26P2TdtWr4aMnYHvxFqOkWJAvr3tU1zLCtuZPOPHtAVos+08owGwdU2Sz4rMkk7Vsr9mlr0UJ+v6iKsqTvTRQEQkTXClj1nEeEMsXrN1M7fCMGVFEzb8MUCK76MUVzvZaIiJxqisOlu5JqTBeMZntbXP6KrGFc3EX5MNM6rxmrtftA5CUdYD33Z6SJJnVPuHPgXW+N5IZneHg5+fbye8OAEneUY22CAbWVI2IfE7scnGgHx7k+pg3JloLfloENw29dzbdXx7j+022mrlGgyQ5DliZysPay22U2sB3thkndgFdFYnYSUTU2QjvpFeNVf1He9pbSzk8zvMNSFgbUKKrCmn3hikG37/inANQLG12f4/9dfPntXUFmp7QoLVaiAUZS0wdcN4ZxdJE8rdSyRF1vZqKncvMb14QDOpyIZF+4ZfbG36SdL49txmchgyigqSwSaSJK1xANrv3ZWEM7aduGMAuC2kC4bCGB8jkDQhyXP/Vh9WJ3Fyj2/q6WAjXBv2f0hT0jzD1lmbaZTmWRsfmVV9z9do2Mq3B4+uJGdMqJo2SOoNWqzkdsbQne5j59b2XsbijMMZR5onTPZKmrLBVOttJPyWo+v9jF3UQChrja0bzKGfNIutEUme0fzyFaYXL9NMKsqLE9LxlLRIfb+hOEFaS3M4oR5PyEdD0rD5kK8qzkg2fYC5GZc0Jvr+fbzB4CfmOEG3Aej4xl3NMoskSUiDcfHGxiGphPMdtfE9keJqBHyHWPCrjgyf3TTXhrxjHJqy8sakXVHMGv01kwpbGUxtECMkuSXFu8S6rqxuPymApMjJrMWUNZIKkiYUpwrqcd3GIP7jjrdz7wuP34ARXTKaxaQo64UzlnSwwei2W0kHBZdfPM/4F68w2R3TTBqaNCEtgjvI2tCcbmPujTlu9CNJQrG9SbY5IBtuMN07wO3uE9/Vo5vFdDYdSgczF1FcIfgaBdO25ADaTqhp2wrDYCqDMw4bJmJJfDzAUpOQ05QVSZLMuaHmjYXBdoLocw0HQyBbElkYzJbOsaas2tVKbOgHsTrbp7gmRQqlX5EA/Mvr3grAX55/6jccuRXEaR3EUhGRe4B/AFLgS865zyxZktJTmvEEG1w9+WhIkqZUFy9T7R8yvnDA4asTmpCauXlmiB0ZmvEEE9pgDM+cJklTxi/vAjA8c7rtmdTtWVQfTkLAdta6IpINMux4GlYAs5WBNxSOum5IwnFr3CzdNPUriazI2wn36D4UxviYQZyuurriigaAcRkyn7I5F1asXWgL/eqG+oj7xAVXUrE9xA6KEFOpqccl1Tg+s6OZBNdaKrg0oTpcvCtf33Ec2c51zVkpAyEiKfB54E+Bc8CjIvKIc+7/l6tM6TO2bphePCDJs/a7M45yr6QuGzbPDDn1+i0Ayr0xTdmQ5Dn5yKe3FlubvoFeSIWNFc+mrJjuXebg3B7V2E+IRWiJDbFjq5+EjfVuHGfd3J4Jzjgs3jgkqbS1BNkgw7cAtK0bp30eY+diGt3j3RVCe/+239KVE1u3ChzjDVO7Cqpn98pHG+13v1+EoZk0mMq06a3R4LQGzK1h8ZxmMS2VdwHPOed+BiAi3wDuB9RAKNfFMw98wLe4sJZqf0KxPcSUFfs/v8Dh7oT68mxCv+mO0xRbmzhrme5PKUYFxdZmG2hO0rT9Xh2M2X9+J7QWH2Krmul+5ZvV7U8xlWF486CtG7AkJKn4OoFJSHs1rvXVxwk8TtRpnjDdr1rjIsa7f3z6rMzahIfnTNKkLV6L95NUrqhsdtYRr0qOGJv4e/CGrL3G2DbobENcw5RT6vE0xBtsq98a134AEhFSWbT1fN9RA7FMbgNe7Pz5HPDu7gki8gDwAMDtt9/+2ilTeocLxWymNmSjoXfH1N73n5/KGdw8YPsNp32L8JAptHXbfOFZbLsd6x7GO97dNDhzmo2bTpHkGa8+/TKnzm6xse1rDg52LlOMiuA6spCm1Jdn7pikSNoMoOhqkkRIi7Q1Ft5Q5f5YnNjbFcUsgGzhCpfRorYXkswm66NG4SjR1dVMGqx15AO/8qr3x75AsGyoxjXNpGnvM9uAyN/TruPqATRIvWQWvXLM/U1zzj0MPAwgIq+IyBh49TXQdiO5lX4/Q9/1gz7DjePaVxI3Wv8f/LY3cJPdb9ePffXWazx99cbiOlk1A3EOeGPnz28AXjruZOfc74nID51z77zhym4gfX+GvusHfYZVoA/6nXP3LFvDa8mqbRj0KPBmEblTRArgg8AjS9akKIpyIlmpFYRzrhGRB4Fv49Ncv+KcW6MkakVRlP6wUgYCwDn3LeBb13HJwzdKy2tI35+h7/pBn2EV6Lv+tUPcumYbKIqiKL8VqxaDUBRFUVYENRCKoijKQnprIETkHhF5RkSeE5GHlq3nWhGRF0TkRyLymIj8MBy7RUT+S0SeDT9vXrbOLiLyFRG5ICJPdo4dq1lEPhbG5RkR+fPlqJ5xjP5Pisgvwjg8JiL3dX63UvoBROSNIvJdEXlaRJ4Skb8Jx3sxDlfR36txOHE453r3wWc4/RR4E1AAjwNvWbaua9T+AnDrkWOfBR4K3x8C/m7ZOo/ouxu4C3jy12kG3hLGYwO4M4xTuoL6Pwl8dMG5K6c/6DoL3BW+bwE/CVp7MQ5X0d+rcThpn76uINqeTc65Cog9m/rK/cDXwvevAX+xRC1X4Jz7HvDLI4eP03w/8A3n3NQ59zzwHH68lsYx+o9j5fQDOOd2nHP/F74fAE/jW9P0Yhyuov84Vkr/SaWvBmJRz6ar/WVbJRzwnyLyv6GvFMDrnHM74P8hAb+/NHXXznGa+zQ2D4rIE8EFFV0zK69fRO4A3gH8gB6OwxH90NNxOAn01UD82p5NK8x7nXN3AfcCHxGRu5ct6HdMX8bmC8AfAn8E7ACfC8dXWr+InAL+Ffhb59z+1U5dcGzpz7FAfy/H4aTQVwNxXT2bVgnn3Evh5wXgm/hl83kROQsQfl5YnsJr5jjNvRgb59x555xxzlngi8zcFyurX0Ry/OT6T865fwuHezMOi/T3cRxOEn01EL3s2SQiIxHZit+BPwOexGv/UDjtQ8C/L0fhdXGc5keAD4rIhojcCbwZ+J8l6LsqcVINvB8/DrCi+kVEgC8DTzvn/r7zq16Mw3H6+zYOJ45lR8l/0w9wHz4T4qfAx5et5xo1vwmfmfE48FTUDZwB/ht4Nvy8Zdlaj+j+On75X+Pf7D58Nc3Ax8O4PAPcu6L6/xH4EfAEfjI6u6r6g6Y/wbtYngAeC5/7+jIOV9Hfq3E4aR9ttaEoiqIspK8uJkVRFOUGowZCURRFWYgaCEVRFGUhaiAURVGUhaiBUBRFURaiBkJRFEVZiBoIRVEUZSFqIJS1QUT+OMNVxasAAADBSURBVDR9G4Sq9adE5G3L1qUofUUL5ZS1QkQ+BQyAIXDOOffpJUtSlN6iBkJZK0JvrkeBEniPc84sWZKi9BZ1MSnrxi3AKfyuZYMla1GUXqMrCGWtEJFH8DsM3olv/PbgkiUpSm/Jli1AUX5XiMhfAY1z7p9FJAW+LyLvc859Z9naFKWP6ApCURRFWYjGIBRFUZSFqIFQFEVRFqIGQlEURVmIGghFURRlIWogFEVRlIWogVAURVEWogZCURRFWcivAIV0oF9Wve5OAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ds.Tair[0].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to visualize the data on a conventional latitude-longitude grid, we can take advantage of xarray's ability to apply [cartopy](http://scitools.org.uk/cartopy/index.html) map projections." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:31.131708Z", - "start_time": "2018-11-28T20:50:30.444697Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(14,6))\n", - "ax = plt.axes(projection=ccrs.PlateCarree())\n", - "ax.set_global()\n", - "ds.Tair[0].plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), x='xc', y='yc', add_colorbar=False)\n", - "ax.coastlines()\n", - "ax.set_ylim([0,90]);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Multidimensional Groupby ##\n", - "\n", - "The above example allowed us to visualize the data on a regular latitude-longitude grid. But what if we want to do a calculation that involves grouping over one of these physical coordinates (rather than the logical coordinates), for example, calculating the mean temperature at each latitude. This can be achieved using xarray's `groupby` function, which accepts multidimensional variables. By default, `groupby` will use every unique value in the variable, which is probably not what we want. Instead, we can use the `groupby_bins` function to specify the output coordinates of the group. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:50:43.670463Z", - "start_time": "2018-11-28T20:50:43.245501Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# define two-degree wide latitude bins\n", - "lat_bins = np.arange(0,91,2)\n", - "# define a label for each bin corresponding to the central latitude\n", - "lat_center = np.arange(1,90,2)\n", - "# group according to those bins and take the mean\n", - "Tair_lat_mean = ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center).mean(dim=xr.ALL_DIMS)\n", - "# plot the result\n", - "Tair_lat_mean.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the resulting coordinate for the `groupby_bins` operation got the `_bins` suffix appended: `xc_bins`. This help us distinguish it from the original multidimensional variable `xc`." - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": true, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": true - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/examples/xarray_seasonal_means.ipynb b/examples/xarray_seasonal_means.ipynb deleted file mode 100644 index d6a354ecdf5..00000000000 --- a/examples/xarray_seasonal_means.ipynb +++ /dev/null @@ -1,427 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "toc": true - }, - "source": [ - "

Table of Contents

\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Calculating Seasonal Averages from Timeseries of Monthly Means \n", - "=====\n", - "\n", - "Author: [Joe Hamman](https://github.com/jhamman/)\n", - "\n", - "The data used for this example can be found in the [xray-data](https://github.com/xray/xray-data) repository. You may need to change the path to `rasm.nc` below.\n", - "\n", - "Suppose we have a netCDF or xray Dataset of monthly mean data and we want to calculate the seasonal average. To do this properly, we need to calculate the weighted average considering that each month has a different number of days.\n", - "\n", - "Suppose we have a netCDF or `xarray.Dataset` of monthly mean data and we want to calculate the seasonal average. To do this properly, we need to calculate the weighted average considering that each month has a different number of days." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:35.958210Z", - "start_time": "2018-11-28T20:51:35.936966Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numpy version : 1.17.2\n", - "pandas version : 0.25.1\n", - "xarray version : 0.13.0+45.g4296096b.dirty\n" - ] - } - ], - "source": [ - "%matplotlib inline\n", - "import numpy as np\n", - "import pandas as pd\n", - "import xarray as xr\n", - "from netCDF4 import num2date\n", - "import matplotlib.pyplot as plt \n", - "\n", - "print(\"numpy version : \", np.__version__)\n", - "print(\"pandas version : \", pd.__version__)\n", - "print(\"xarray version : \", xr.__version__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Some calendar information so we can support any netCDF calendar. " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:35.991620Z", - "start_time": "2018-11-28T20:51:35.960336Z" - } - }, - "outputs": [], - "source": [ - "dpm = {'noleap': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " '365_day': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " 'standard': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " 'gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " 'proleptic_gregorian': [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " 'all_leap': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " '366_day': [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],\n", - " '360_day': [0, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]} " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### A few calendar functions to determine the number of days in each month\n", - "If you were just using the standard calendar, it would be easy to use the `calendar.month_range` function." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:36.015151Z", - "start_time": "2018-11-28T20:51:35.994079Z" - } - }, - "outputs": [], - "source": [ - "def leap_year(year, calendar='standard'):\n", - " \"\"\"Determine if year is a leap year\"\"\"\n", - " leap = False\n", - " if ((calendar in ['standard', 'gregorian',\n", - " 'proleptic_gregorian', 'julian']) and\n", - " (year % 4 == 0)):\n", - " leap = True\n", - " if ((calendar == 'proleptic_gregorian') and\n", - " (year % 100 == 0) and\n", - " (year % 400 != 0)):\n", - " leap = False\n", - " elif ((calendar in ['standard', 'gregorian']) and\n", - " (year % 100 == 0) and (year % 400 != 0) and\n", - " (year < 1583)):\n", - " leap = False\n", - " return leap\n", - "\n", - "def get_dpm(time, calendar='standard'):\n", - " \"\"\"\n", - " return a array of days per month corresponding to the months provided in `months`\n", - " \"\"\"\n", - " month_length = np.zeros(len(time), dtype=np.int)\n", - " \n", - " cal_days = dpm[calendar]\n", - " \n", - " for i, (month, year) in enumerate(zip(time.month, time.year)):\n", - " month_length[i] = cal_days[month]\n", - " if leap_year(year, calendar=calendar):\n", - " month_length[i] += 1\n", - " return month_length" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Open the `Dataset`" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:36.072316Z", - "start_time": "2018-11-28T20:51:36.016594Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Dimensions: (time: 36, x: 275, y: 205)\n", - "Coordinates:\n", - " * time (time) object 1980-09-16 12:00:00 ... 1983-08-17 00:00:00\n", - " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", - " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", - "Dimensions without coordinates: x, y\n", - "Data variables:\n", - " Tair (time, y, x) float64 nan nan nan nan nan ... 29.8 28.66 28.19 28.21\n", - "Attributes:\n", - " title: /workspace/jhamman/processed/R1002RBRxaaa01a/l...\n", - " institution: U.W.\n", - " source: RACM R1002RBRxaaa01a\n", - " output_frequency: daily\n", - " output_mode: averaged\n", - " convention: CF-1.4\n", - " references: Based on the initial model of Liang et al., 19...\n", - " comment: Output from the Variable Infiltration Capacity...\n", - " nco_openmp_thread_number: 1\n", - " NCO: \"4.6.0\"\n", - " history: Tue Dec 27 14:15:22 2016: ncatted -a dimension...\n" - ] - } - ], - "source": [ - "ds = xr.tutorial.open_dataset('rasm').load()\n", - "print(ds)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Now for the heavy lifting:\n", - "We first have to come up with the weights,\n", - "- calculate the month lengths for each monthly data record\n", - "- calculate weights using `groupby('time.season')`\n", - "\n", - "Finally, we just need to multiply our weights by the `Dataset` and sum allong the time dimension. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:36.132413Z", - "start_time": "2018-11-28T20:51:36.073708Z" - } - }, - "outputs": [], - "source": [ - "# Make a DataArray with the number of days in each month, size = len(time)\n", - "month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar='noleap'),\n", - " coords=[ds.time], name='month_length')\n", - "\n", - "# Calculate the weights by grouping by 'time.season'.\n", - "# Conversion to float type ('astype(float)') only necessary for Python 2.x\n", - "weights = month_length.groupby('time.season') / month_length.astype(float).groupby('time.season').sum()\n", - "\n", - "# Test that the sum of the weights for each season is 1.0\n", - "np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4))\n", - "\n", - "# Calculate the weighted average\n", - "ds_weighted = (ds * weights).groupby('time.season').sum(dim='time')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:36.152913Z", - "start_time": "2018-11-28T20:51:36.133997Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Dimensions: (season: 4, x: 275, y: 205)\n", - "Coordinates:\n", - " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", - " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", - " * season (season) object 'DJF' 'JJA' 'MAM' 'SON'\n", - "Dimensions without coordinates: x, y\n", - "Data variables:\n", - " Tair (season, y, x) float64 0.0 0.0 0.0 0.0 ... 23.15 22.08 21.73 21.96\n" - ] - } - ], - "source": [ - "print(ds_weighted)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:36.190765Z", - "start_time": "2018-11-28T20:51:36.154416Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "xarray/core/nanops.py:140: RuntimeWarning: Mean of empty slice\n", - " return np.nanmean(a, axis=axis, dtype=dtype)\n" - ] - } - ], - "source": [ - "# only used for comparisons\n", - "ds_unweighted = ds.groupby('time.season').mean('time')\n", - "ds_diff = ds_weighted - ds_unweighted" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:40.264871Z", - "start_time": "2018-11-28T20:51:36.192467Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.02, 'Seasonal Surface Air Temperature')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Quick plot to show the results\n", - "notnull = pd.notnull(ds_unweighted['Tair'][0])\n", - "\n", - "fig, axes = plt.subplots(nrows=4, ncols=3, figsize=(14,12))\n", - "for i, season in enumerate(('DJF', 'MAM', 'JJA', 'SON')):\n", - " ds_weighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", - " ax=axes[i, 0], vmin=-30, vmax=30, cmap='Spectral_r', \n", - " add_colorbar=True, extend='both')\n", - " \n", - " ds_unweighted['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", - " ax=axes[i, 1], vmin=-30, vmax=30, cmap='Spectral_r', \n", - " add_colorbar=True, extend='both')\n", - "\n", - " ds_diff['Tair'].sel(season=season).where(notnull).plot.pcolormesh(\n", - " ax=axes[i, 2], vmin=-0.1, vmax=.1, cmap='RdBu_r',\n", - " add_colorbar=True, extend='both')\n", - "\n", - " axes[i, 0].set_ylabel(season)\n", - " axes[i, 1].set_ylabel('')\n", - " axes[i, 2].set_ylabel('')\n", - "\n", - "for ax in axes.flat:\n", - " ax.axes.get_xaxis().set_ticklabels([])\n", - " ax.axes.get_yaxis().set_ticklabels([])\n", - " ax.axes.axis('tight')\n", - " ax.set_xlabel('')\n", - " \n", - "axes[0, 0].set_title('Weighted by DPM')\n", - "axes[0, 1].set_title('Equal Weighting')\n", - "axes[0, 2].set_title('Difference')\n", - " \n", - "plt.tight_layout()\n", - "\n", - "fig.suptitle('Seasonal Surface Air Temperature', fontsize=16, y=1.02)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2018-11-28T20:51:40.284898Z", - "start_time": "2018-11-28T20:51:40.266406Z" - } - }, - "outputs": [], - "source": [ - "# Wrap it into a simple function\n", - "def season_mean(ds, calendar='standard'):\n", - " # Make a DataArray of season/year groups\n", - " year_season = xr.DataArray(ds.time.to_index().to_period(freq='Q-NOV').to_timestamp(how='E'),\n", - " coords=[ds.time], name='year_season')\n", - "\n", - " # Make a DataArray with the number of days in each month, size = len(time)\n", - " month_length = xr.DataArray(get_dpm(ds.time.to_index(), calendar=calendar),\n", - " coords=[ds.time], name='month_length')\n", - " # Calculate the weights by grouping by 'time.season'\n", - " weights = month_length.groupby('time.season') / month_length.groupby('time.season').sum()\n", - "\n", - " # Test that the sum of the weights for each season is 1.0\n", - " np.testing.assert_allclose(weights.groupby('time.season').sum().values, np.ones(4))\n", - "\n", - " # Calculate the weighted average\n", - " return (ds * weights).groupby('time.season').sum(dim='time')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": true, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": true - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/readthedocs.yml b/readthedocs.yml index 6429780e7d7..c64fa1b7b02 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -4,5 +4,5 @@ conda: file: ci/requirements/doc.yml python: version: 3.7 - setup_py_install: true + setup_py_install: false formats: [] diff --git a/xarray/backends/api.py b/xarray/backends/api.py index 945b3937c43..23d09ba5e33 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -729,13 +729,13 @@ def open_mfdataset( ``combine_by_coords`` and ``combine_nested``. By default the old (now deprecated) ``auto_combine`` will be used, please specify either ``combine='by_coords'`` or ``combine='nested'`` in future. Requires dask to be installed. See documentation for - details on dask [1]. Attributes from the first dataset file are used for the + details on dask [1]_. Attributes from the first dataset file are used for the combined dataset. Parameters ---------- paths : str or sequence - Either a string glob in the form "path/to/my/files/*.nc" or an explicit list of + Either a string glob in the form ``"path/to/my/files/*.nc"`` or an explicit list of files to open. Paths can be given as strings or as pathlib Paths. If concatenation along more than one dimension is desired, then ``paths`` must be a nested list-of-lists (see ``manual_combine`` for details). (A string glob will @@ -745,7 +745,7 @@ def open_mfdataset( In general, these should divide the dimensions of each dataset. If int, chunk each dimension by ``chunks``. By default, chunks will be chosen to load entire input files into memory at once. This has a major impact on performance: please - see the full documentation for more details [2]. + see the full documentation for more details [2]_. concat_dim : str, or list of str, DataArray, Index or None, optional Dimensions to concatenate files along. You only need to provide this argument if any of the dimensions along which you want to concatenate is not a dimension @@ -761,6 +761,7 @@ def open_mfdataset( 'no_conflicts', 'override'}, optional String indicating how to compare variables of the same name for potential conflicts when merging: + * 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. * 'equals': all values and dimensions must be the same. @@ -770,6 +771,7 @@ def open_mfdataset( must be equal. The returned dataset then contains the combination of all non-null values. * 'override': skip comparing and pick variable from first dataset + preprocess : callable, optional If provided, call this function on each dataset prior to concatenation. You can find the file-name from which each dataset was loaded in diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 559c5e16287..4005d4fbf6d 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -506,7 +506,7 @@ def strftime(self, date_format): Returns ------- - Index + pandas.Index Index of formatted strings Examples diff --git a/xarray/coding/variables.py b/xarray/coding/variables.py index 5f9c8932b6b..2b5f87ab0cd 100644 --- a/xarray/coding/variables.py +++ b/xarray/coding/variables.py @@ -8,7 +8,6 @@ from ..core import dtypes, duck_array_ops, indexing from ..core.pycompat import dask_array_type -from ..core.utils import equivalent from ..core.variable import Variable @@ -152,18 +151,25 @@ def encode(self, variable, name=None): fv = encoding.get("_FillValue") mv = encoding.get("missing_value") - if fv is not None and mv is not None and not equivalent(fv, mv): + if ( + fv is not None + and mv is not None + and not duck_array_ops.allclose_or_equiv(fv, mv) + ): raise ValueError( - "Variable {!r} has multiple fill values {}. " - "Cannot encode data. ".format(name, [fv, mv]) + f"Variable {name!r} has conflicting _FillValue ({fv}) and missing_value ({mv}). Cannot encode data." ) if fv is not None: + # Ensure _FillValue is cast to same dtype as data's + encoding["_FillValue"] = data.dtype.type(fv) fill_value = pop_to(encoding, attrs, "_FillValue", name=name) if not pd.isnull(fill_value): data = duck_array_ops.fillna(data, fill_value) if mv is not None: + # Ensure missing_value is cast to same dtype as data's + encoding["missing_value"] = data.dtype.type(mv) fill_value = pop_to(encoding, attrs, "missing_value", name=name) if not pd.isnull(fill_value) and fv is None: data = duck_array_ops.fillna(data, fill_value) diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index 41ff5a3b32d..908119f7995 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -108,7 +108,7 @@ def align( Returns ------- - aligned : same as *objects + aligned : same as `*objects` Tuple of objects with aligned coordinates. Raises @@ -466,6 +466,7 @@ def reindex_variables( tolerance: Any = None, copy: bool = True, fill_value: Optional[Any] = dtypes.NA, + sparse: bool = False, ) -> Tuple[Dict[Hashable, Variable], Dict[Hashable, pd.Index]]: """Conform a dictionary of aligned variables onto a new set of variables, filling in missing values with NaN. @@ -503,6 +504,8 @@ def reindex_variables( the input. In either case, new xarray objects are always returned. fill_value : scalar, optional Value to use for newly missing values + sparse: bool, optional + Use an sparse-array Returns ------- @@ -571,6 +574,8 @@ def reindex_variables( for name, var in variables.items(): if name not in indexers: + if sparse: + var = var._as_sparse(fill_value=fill_value) key = tuple( slice(None) if d in unchanged_dims else int_indexers.get(d, slice(None)) for d in var.dims diff --git a/xarray/core/combine.py b/xarray/core/combine.py index 3308dcef285..b9db30a9f92 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -531,6 +531,7 @@ def combine_by_coords( * 'all': All data variables will be concatenated. * list of str: The listed data variables will be concatenated, in addition to the 'minimal' data variables. + If objects are DataArrays, `data_vars` must be 'all'. coords : {'minimal', 'different', 'all' or list of str}, optional As per the 'data_vars' kwarg, but for coordinate variables. @@ -747,6 +748,7 @@ def auto_combine( 'no_conflicts', 'override'}, optional String indicating how to compare variables of the same name for potential conflicts: + - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. diff --git a/xarray/core/common.py b/xarray/core/common.py index 2afe4b4c3a7..a74318b2f90 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -91,15 +91,23 @@ def wrapped_func(self, dim=None, **kwargs): # type: ignore return wrapped_func - _reduce_extra_args_docstring = """dim : str or sequence of str, optional + _reduce_extra_args_docstring = dedent( + """ + dim : str or sequence of str, optional Dimension(s) over which to apply `{name}`. By default `{name}` is - applied over all dimensions.""" + applied over all dimensions. + """ + ).strip() - _cum_extra_args_docstring = """dim : str or sequence of str, optional + _cum_extra_args_docstring = dedent( + """ + dim : str or sequence of str, optional Dimension over which to apply `{name}`. axis : int or sequence of int, optional Axis over which to apply `{name}`. Only one of the 'dim' - and 'axis' arguments can be supplied.""" + and 'axis' arguments can be supplied. + """ + ).strip() class AbstractArray(ImplementsArrayReduce): @@ -454,7 +462,7 @@ def assign_coords(self, coords=None, **coords_kwargs): def assign_attrs(self, *args, **kwargs): """Assign new attrs to this object. - Returns a new object equivalent to self.attrs.update(*args, **kwargs). + Returns a new object equivalent to ``self.attrs.update(*args, **kwargs)``. Parameters ---------- @@ -481,7 +489,7 @@ def pipe( **kwargs, ) -> T: """ - Apply func(self, *args, **kwargs) + Apply ``func(self, *args, **kwargs)`` This method replicates the pandas method of the same name. @@ -810,6 +818,7 @@ def rolling_exp( ---------- window : A single mapping from a dimension name to window value, optional + dim : str Name of the dimension to create the rolling exponential window along (e.g., `time`). @@ -848,6 +857,7 @@ def coarsen( ---------- dim: dict, optional Mapping from the dimension name to the window size. + dim : str Name of the dimension to create the rolling iterator along (e.g., `time`). @@ -858,7 +868,7 @@ def coarsen( multiple of the window size. If 'trim', the excess entries are dropped. If 'pad', NA will be padded. side : 'left' or 'right' or mapping from dimension to 'left' or 'right' - coord_func: function (name) that is applied to the coordintes, + coord_func : function (name) that is applied to the coordintes, or a mapping from coordinate name to function (name). Returns @@ -921,7 +931,7 @@ def resample( Parameters ---------- indexer : {dim: freq}, optional - Mapping from the dimension name to resample frequency. The + Mapping from the dimension name to resample frequency [1]_. The dimension must be datetime-like. skipna : bool, optional Whether to skip missing values when aggregating in downsampling. diff --git a/xarray/core/computation.py b/xarray/core/computation.py index bb5ab07d8dd..643c1137d6c 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -342,7 +342,7 @@ def _fast_dataset( variables.update(coord_variables) coord_names = set(coord_variables) - return Dataset._from_vars_and_coord_names(variables, coord_names) + return Dataset._construct_direct(variables, coord_names) def apply_dataset_vfunc( @@ -947,7 +947,7 @@ def earth_mover_distance(first_samples, appropriately for use in `apply`. You may find helper functions such as numpy.broadcast_arrays helpful in writing your function. `apply_ufunc` also works well with numba's vectorize and guvectorize. Further explanation with - examples are provided in the xarray documentation [3]. + examples are provided in the xarray documentation [3]_. See also -------- diff --git a/xarray/core/concat.py b/xarray/core/concat.py index 5b4fc078236..5ccbfa3f2b4 100644 --- a/xarray/core/concat.py +++ b/xarray/core/concat.py @@ -45,6 +45,7 @@ def concat( * 'all': All data variables will be concatenated. * list of str: The listed data variables will be concatenated, in addition to the 'minimal' data variables. + If objects are DataArrays, data_vars must be 'all'. coords : {'minimal', 'different', 'all' or list of str}, optional These coordinate variables will be concatenated together: diff --git a/xarray/core/coordinates.py b/xarray/core/coordinates.py index eb2ceb1be07..3d51c9b4271 100644 --- a/xarray/core/coordinates.py +++ b/xarray/core/coordinates.py @@ -309,7 +309,7 @@ def to_dataset(self) -> "Dataset": from .dataset import Dataset coords = {k: v.copy(deep=False) for k, v in self._data._coords.items()} - return Dataset._from_vars_and_coord_names(coords, set(coords)) + return Dataset._construct_direct(coords, set(coords)) def __delitem__(self, key: Hashable) -> None: del self._data._coords[key] diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index a192fe08cee..64f21b0eb01 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -48,10 +48,10 @@ assert_coordinate_consistent, remap_label_indexers, ) -from .dataset import Dataset, merge_indexes, split_indexes +from .dataset import Dataset, split_indexes from .formatting import format_item -from .indexes import Indexes, default_indexes -from .merge import PANDAS_TYPES +from .indexes import Indexes, propagate_indexes, default_indexes +from .merge import PANDAS_TYPES, _extract_indexes_from_coords from .options import OPTIONS from .utils import Default, ReprObject, _check_inplace, _default, either_dict_or_kwargs from .variable import ( @@ -239,7 +239,7 @@ class DataArray(AbstractArray, DataWithCoords): ---------- dims : tuple Dimension names associated with this array. - values : np.ndarray + values : numpy.ndarray Access or modify DataArray values as a numpy array. coords : dict-like Dictionary of DataArray objects that label values along each dimension. @@ -249,14 +249,14 @@ class DataArray(AbstractArray, DataWithCoords): Dictionary for holding arbitrary metadata. """ - _accessors: Optional[Dict[str, Any]] # noqa + _cache: Dict[str, Any] _coords: Dict[Any, Variable] _indexes: Optional[Dict[Hashable, pd.Index]] _name: Optional[Hashable] _variable: Variable __slots__ = ( - "_accessors", + "_cache", "_coords", "_file_obj", "_indexes", @@ -367,13 +367,15 @@ def __init__( data = as_compatible_data(data) coords, dims = _infer_coords_and_dims(data.shape, coords, dims) variable = Variable(dims, data, attrs, encoding, fastpath=True) + indexes = dict( + _extract_indexes_from_coords(coords) + ) # needed for to_dataset # These fully describe a DataArray self._variable = variable assert isinstance(coords, dict) self._coords = coords self._name = name - self._accessors = None # TODO(shoyer): document this argument, once it becomes part of the # public interface. @@ -401,6 +403,7 @@ def _replace_maybe_drop_dims( ) -> "DataArray": if variable.dims == self.dims and variable.shape == self.shape: coords = self._coords.copy() + indexes = self._indexes elif variable.dims == self.dims: # Shape has changed (e.g. from reduce(..., keepdims=True) new_sizes = dict(zip(self.dims, variable.shape)) @@ -409,12 +412,19 @@ def _replace_maybe_drop_dims( for k, v in self._coords.items() if v.shape == tuple(new_sizes[d] for d in v.dims) } + changed_dims = [ + k for k in variable.dims if variable.sizes[k] != self.sizes[k] + ] + indexes = propagate_indexes(self._indexes, exclude=changed_dims) else: allowed_dims = set(variable.dims) coords = { k: v for k, v in self._coords.items() if set(v.dims) <= allowed_dims } - return self._replace(variable, coords, name) + indexes = propagate_indexes( + self._indexes, exclude=(set(self.dims) - allowed_dims) + ) + return self._replace(variable, coords, name, indexes=indexes) def _overwrite_indexes(self, indexes: Mapping[Hashable, Any]) -> "DataArray": if not len(indexes): @@ -445,19 +455,21 @@ def _from_temp_dataset( return self._replace(variable, coords, name, indexes=indexes) def _to_dataset_split(self, dim: Hashable) -> Dataset: + """ splits dataarray along dimension 'dim' """ + def subset(dim, label): array = self.loc[{dim: label}] - if dim in array.coords: - del array.coords[dim] array.attrs = {} - return array + return as_variable(array) variables = {label: subset(dim, label) for label in self.get_index(dim)} - - coords = self.coords.to_dataset() - if dim in coords: - del coords[dim] - return Dataset(variables, coords, self.attrs) + variables.update({k: v for k, v in self._coords.items() if k != dim}) + indexes = propagate_indexes(self._indexes, exclude=dim) + coord_names = set(self._coords) - set([dim]) + dataset = Dataset._construct_direct( + variables, coord_names, indexes=indexes, attrs=self.attrs + ) + return dataset def _to_dataset_whole( self, name: Hashable = None, shallow_copy: bool = True @@ -481,8 +493,10 @@ def _to_dataset_whole( if shallow_copy: for k in variables: variables[k] = variables[k].copy(deep=False) + indexes = self._indexes + coord_names = set(self._coords) - dataset = Dataset._from_vars_and_coord_names(variables, coord_names) + dataset = Dataset._construct_direct(variables, coord_names, indexes=indexes) return dataset def to_dataset(self, dim: Hashable = None, *, name: Hashable = None) -> Dataset: @@ -928,7 +942,8 @@ def copy(self, deep: bool = True, data: Any = None) -> "DataArray": """ variable = self.variable.copy(deep=deep, data=data) coords = {k: v.copy(deep=deep) for k, v in self._coords.items()} - return self._replace(variable, coords) + indexes = self._indexes + return self._replace(variable, coords, indexes=indexes) def __copy__(self) -> "DataArray": return self.copy(deep=False) @@ -1316,7 +1331,7 @@ def interp( values. kwargs: dictionary Additional keyword passed to scipy's interpolator. - **coords_kwarg : {dim: coordinate, ...}, optional + ``**coords_kwarg`` : {dim: coordinate, ...}, optional The keyword arguments form of ``coords``. One of coords or coords_kwargs must be provided. @@ -1601,10 +1616,10 @@ def set_index( -------- DataArray.reset_index """ - _check_inplace(inplace) - indexes = either_dict_or_kwargs(indexes, indexes_kwargs, "set_index") - coords, _ = merge_indexes(indexes, self._coords, set(), append=append) - return self._replace(coords=coords) + ds = self._to_temp_dataset().set_index( + indexes, append=append, inplace=inplace, **indexes_kwargs + ) + return self._from_temp_dataset(ds) def reset_index( self, @@ -1727,7 +1742,10 @@ def stack( return self._from_temp_dataset(ds) def unstack( - self, dim: Union[Hashable, Sequence[Hashable], None] = None + self, + dim: Union[Hashable, Sequence[Hashable], None] = None, + fill_value: Any = dtypes.NA, + sparse: bool = False, ) -> "DataArray": """ Unstack existing dimensions corresponding to MultiIndexes into @@ -1740,6 +1758,8 @@ def unstack( dim : hashable or sequence of hashable, optional Dimension(s) over which to unstack. By default unstacks all MultiIndexes. + fill_value: value to be filled. By default, np.nan + sparse: use sparse-array if True Returns ------- @@ -1771,7 +1791,7 @@ def unstack( -------- DataArray.stack """ - ds = self._to_temp_dataset().unstack(dim) + ds = self._to_temp_dataset().unstack(dim, fill_value, sparse) return self._from_temp_dataset(ds) def to_unstacked_dataset(self, dim, level=0): @@ -2018,44 +2038,71 @@ def fillna(self, value: Any) -> "DataArray": def interpolate_na( self, - dim=None, + dim: Hashable = None, method: str = "linear", limit: int = None, use_coordinate: Union[bool, str] = True, + max_gap: Union[int, float, str, pd.Timedelta, np.timedelta64] = None, **kwargs: Any, ) -> "DataArray": - """Interpolate values according to different methods. + """Fill in NaNs by interpolating according to different methods. Parameters ---------- dim : str Specifies the dimension along which to interpolate. - method : {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', - 'polynomial', 'barycentric', 'krog', 'pchip', - 'spline', 'akima'}, optional + method : str, optional String indicating which method to use for interpolation: - 'linear': linear interpolation (Default). Additional keyword - arguments are passed to ``numpy.interp`` - - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', - 'polynomial': are passed to ``scipy.interpolate.interp1d``. If - method=='polynomial', the ``order`` keyword argument must also be + arguments are passed to :py:func:`numpy.interp` + - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial': + are passed to :py:func:`scipy.interpolate.interp1d`. If + ``method='polynomial'``, the ``order`` keyword argument must also be provided. - - 'barycentric', 'krog', 'pchip', 'spline', and `akima`: use their - respective``scipy.interpolate`` classes. - use_coordinate : boolean or str, default True + - 'barycentric', 'krog', 'pchip', 'spline', 'akima': use their + respective :py:class:`scipy.interpolate` classes. + + use_coordinate : bool, str, default True Specifies which index to use as the x values in the interpolation formulated as `y = f(x)`. If False, values are treated as if - eqaully-spaced along `dim`. If True, the IndexVariable `dim` is - used. If use_coordinate is a string, it specifies the name of a + eqaully-spaced along ``dim``. If True, the IndexVariable `dim` is + used. If ``use_coordinate`` is a string, it specifies the name of a coordinate variariable to use as the index. limit : int, default None Maximum number of consecutive NaNs to fill. Must be greater than 0 - or None for no limit. + or None for no limit. This filling is done regardless of the size of + the gap in the data. To only interpolate over gaps less than a given length, + see ``max_gap``. + max_gap: int, float, str, pandas.Timedelta, numpy.timedelta64, default None. + Maximum size of gap, a continuous sequence of NaNs, that will be filled. + Use None for no limit. When interpolating along a datetime64 dimension + and ``use_coordinate=True``, ``max_gap`` can be one of the following: + + - a string that is valid input for pandas.to_timedelta + - a :py:class:`numpy.timedelta64` object + - a :py:class:`pandas.Timedelta` object + + Otherwise, ``max_gap`` must be an int or a float. Use of ``max_gap`` with unlabeled + dimensions has not been implemented yet. Gap length is defined as the difference + between coordinate values at the first data point after a gap and the last value + before a gap. For gaps at the beginning (end), gap length is defined as the difference + between coordinate values at the first (last) valid data point and the first (last) NaN. + For example, consider:: + + + array([nan, nan, nan, 1., nan, nan, 4., nan, nan]) + Coordinates: + * x (x) int64 0 1 2 3 4 5 6 7 8 + + The gap lengths are 3-0 = 3; 6-3 = 3; and 8-6 = 2 respectively + kwargs : dict, optional + parameters passed verbatim to the underlying interpolation function Returns ------- - DataArray + interpolated: DataArray + Filled in DataArray. See also -------- @@ -2070,6 +2117,7 @@ def interpolate_na( method=method, limit=limit, use_coordinate=use_coordinate, + max_gap=max_gap, **kwargs, ) @@ -2918,11 +2966,48 @@ def quantile( is a scalar. If multiple percentiles are given, first axis of the result corresponds to the quantile and a quantile dimension is added to the return array. The other dimensions are the - dimensions that remain after the reduction of the array. + dimensions that remain after the reduction of the array. See Also -------- numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile + + Examples + -------- + + >>> da = xr.DataArray( + ... data=[[0.7, 4.2, 9.4, 1.5], [6.5, 7.3, 2.6, 1.9]], + ... coords={"x": [7, 9], "y": [1, 1.5, 2, 2.5]}, + ... dims=("x", "y"), + ... ) + + Single quantile + >>> da.quantile(0) # or da.quantile(0, dim=...) + + array(0.7) + Coordinates: + quantile float64 0.0 + >>> da.quantile(0, dim="x") + + array([0.7, 4.2, 2.6, 1.5]) + Coordinates: + * y (y) float64 1.0 1.5 2.0 2.5 + quantile float64 0.0 + + Multiple quantiles + >>> da.quantile([0, 0.5, 1]) + + array([0.7, 3.4, 9.4]) + Coordinates: + * quantile (quantile) float64 0.0 0.5 1.0 + >>> da.quantile([0, 0.5, 1], dim="x") + + array([[0.7 , 4.2 , 2.6 , 1.5 ], + [3.6 , 5.75, 6. , 1.7 ], + [6.5 , 7.3 , 9.4 , 1.9 ]]) + Coordinates: + * y (y) float64 1.0 1.5 2.0 2.5 + * quantile (quantile) float64 0.0 0.5 1.0 """ ds = self._to_temp_dataset().quantile( @@ -3043,8 +3128,8 @@ def integrate( Coordinate(s) used for the integration. datetime_unit: str, optional Can be used to specify the unit if datetime coordinate is used. - One of {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', - 'ps', 'fs', 'as'} + One of {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', + 'fs', 'as'} Returns ------- diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 15a7209ab24..61dde6a393b 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -59,7 +59,13 @@ remap_label_indexers, ) from .duck_array_ops import datetime_to_numeric -from .indexes import Indexes, default_indexes, isel_variable_and_index, roll_index +from .indexes import ( + Indexes, + default_indexes, + isel_variable_and_index, + propagate_indexes, + roll_index, +) from .merge import ( dataset_merge_method, dataset_update_method, @@ -204,6 +210,7 @@ def merge_indexes( """ vars_to_replace: Dict[Hashable, Variable] = {} vars_to_remove: List[Hashable] = [] + dims_to_replace: Dict[Hashable, Hashable] = {} error_msg = "{} is not the name of an existing variable." for dim, var_names in indexes.items(): @@ -244,7 +251,7 @@ def merge_indexes( if not len(names) and len(var_names) == 1: idx = pd.Index(variables[var_names[0]].values) - else: + else: # MultiIndex for n in var_names: try: var = variables[n] @@ -256,15 +263,22 @@ def merge_indexes( levels.append(cat.categories) idx = pd.MultiIndex(levels, codes, names=names) + for n in names: + dims_to_replace[n] = dim vars_to_replace[dim] = IndexVariable(dim, idx) vars_to_remove.extend(var_names) new_variables = {k: v for k, v in variables.items() if k not in vars_to_remove} new_variables.update(vars_to_replace) + + # update dimensions if necessary GH: 3512 + for k, v in new_variables.items(): + if any(d in dims_to_replace for d in v.dims): + new_dims = [dims_to_replace.get(d, d) for d in v.dims] + new_variables[k] = v._replace(dims=new_dims) new_coord_names = coord_names | set(vars_to_replace) new_coord_names -= set(vars_to_remove) - return new_variables, new_coord_names @@ -411,8 +425,8 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): coordinates used for label based indexing. """ - _accessors: Optional[Dict[str, Any]] _attrs: Optional[Dict[Hashable, Any]] + _cache: Dict[str, Any] _coord_names: Set[Hashable] _dims: Dict[Hashable, int] _encoding: Optional[Dict[Hashable, Any]] @@ -420,8 +434,8 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): _variables: Dict[Hashable, Variable] __slots__ = ( - "_accessors", "_attrs", + "_cache", "_coord_names", "_dims", "_encoding", @@ -527,7 +541,6 @@ def __init__( data_vars, coords, compat=compat ) - self._accessors = None self._attrs = dict(attrs) if attrs is not None else None self._file_obj = None self._encoding = None @@ -862,13 +875,8 @@ def _construct_direct( obj._attrs = attrs obj._file_obj = file_obj obj._encoding = encoding - obj._accessors = None return obj - @classmethod - def _from_vars_and_coord_names(cls, variables, coord_names, attrs=None): - return cls._construct_direct(variables, coord_names, attrs=attrs) - def _replace( self, variables: Dict[Hashable, Variable] = None, @@ -1503,7 +1511,7 @@ def to_netcdf( Nested dictionary with variable names as keys and dictionaries of variable specific encodings as values, e.g., ``{'my_variable': {'dtype': 'int16', 'scale_factor': 0.1, - 'zlib': True}, ...}`` + 'zlib': True}, ...}`` The `h5netcdf` engine supports both the NetCDF4-style compression encoding parameters ``{'zlib': True, 'complevel': 9}`` and the h5py @@ -2112,7 +2120,7 @@ def thin( indexers: Union[Mapping[Hashable, int], int] = None, **indexers_kwargs: Any, ) -> "Dataset": - """Returns a new dataset with each array indexed along every `n`th + """Returns a new dataset with each array indexed along every `n`-th value for the specified dimension(s) Parameters @@ -2121,7 +2129,7 @@ def thin( A dict with keys matching dimensions and integer values `n` or a single integer `n` applied over all dimensions. One of indexers or indexers_kwargs must be provided. - **indexers_kwargs : {dim: n, ...}, optional + ``**indexers_kwargs`` : {dim: n, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. @@ -2280,6 +2288,7 @@ def reindex( the input. In either case, a new xarray object is always returned. fill_value : scalar, optional Value to use for newly missing values + sparse: use sparse-array. By default, False **indexers_kwarg : {dim: indexer, ...}, optional Keyword arguments in the same form as ``indexers``. One of indexers or indexers_kwargs must be provided. @@ -2422,6 +2431,29 @@ def reindex( the original and desired indexes. If you do want to fill in the `NaN` values present in the original dataset, use the :py:meth:`~Dataset.fillna()` method. + """ + return self._reindex( + indexers, + method, + tolerance, + copy, + fill_value, + sparse=False, + **indexers_kwargs, + ) + + def _reindex( + self, + indexers: Mapping[Hashable, Any] = None, + method: str = None, + tolerance: Number = None, + copy: bool = True, + fill_value: Any = dtypes.NA, + sparse: bool = False, + **indexers_kwargs: Any, + ) -> "Dataset": + """ + same to _reindex but support sparse option """ indexers = utils.either_dict_or_kwargs(indexers, indexers_kwargs, "reindex") @@ -2438,6 +2470,7 @@ def reindex( tolerance, copy=copy, fill_value=fill_value, + sparse=sparse, ) coord_names = set(self._coord_names) coord_names.update(indexers) @@ -2651,15 +2684,9 @@ def _rename_indexes(self, name_dict, dims_set): continue if isinstance(v, pd.MultiIndex): new_names = [name_dict.get(k, k) for k in v.names] - index = pd.MultiIndex( - v.levels, - v.labels, - v.sortorder, - names=new_names, - verify_integrity=False, - ) + index = v.rename(names=new_names) else: - index = pd.Index(v, name=new_name) + index = v.rename(new_name) indexes[new_name] = index return indexes @@ -3327,7 +3354,7 @@ def ensure_stackable(val): return data_array - def _unstack_once(self, dim: Hashable) -> "Dataset": + def _unstack_once(self, dim: Hashable, fill_value, sparse) -> "Dataset": index = self.get_index(dim) index = index.remove_unused_levels() full_idx = pd.MultiIndex.from_product(index.levels, names=index.names) @@ -3336,7 +3363,9 @@ def _unstack_once(self, dim: Hashable) -> "Dataset": if index.equals(full_idx): obj = self else: - obj = self.reindex({dim: full_idx}, copy=False) + obj = self._reindex( + {dim: full_idx}, copy=False, fill_value=fill_value, sparse=sparse + ) new_dim_names = index.names new_dim_sizes = [lev.size for lev in index.levels] @@ -3362,7 +3391,12 @@ def _unstack_once(self, dim: Hashable) -> "Dataset": variables, coord_names=coord_names, indexes=indexes ) - def unstack(self, dim: Union[Hashable, Iterable[Hashable]] = None) -> "Dataset": + def unstack( + self, + dim: Union[Hashable, Iterable[Hashable]] = None, + fill_value: Any = dtypes.NA, + sparse: bool = False, + ) -> "Dataset": """ Unstack existing dimensions corresponding to MultiIndexes into multiple new dimensions. @@ -3374,6 +3408,8 @@ def unstack(self, dim: Union[Hashable, Iterable[Hashable]] = None) -> "Dataset": dim : Hashable or iterable of Hashable, optional Dimension(s) over which to unstack. By default unstacks all MultiIndexes. + fill_value: value to be filled. By default, np.nan + sparse: use sparse-array if True Returns ------- @@ -3411,7 +3447,7 @@ def unstack(self, dim: Union[Hashable, Iterable[Hashable]] = None) -> "Dataset": result = self.copy(deep=False) for dim in dims: - result = result._unstack_once(dim) + result = result._unstack_once(dim, fill_value, sparse) return result def update(self, other: "CoercibleMapping", inplace: bool = None) -> "Dataset": @@ -3471,6 +3507,7 @@ def merge( 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts: + - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. @@ -3479,6 +3516,7 @@ def merge( - 'no_conflicts': only values which are not null in both datasets must be equal. The returned dataset then contains the combination of all non-null values. + join : {'outer', 'inner', 'left', 'right', 'exact'}, optional Method for joining ``self`` and ``other`` along shared dimensions: @@ -3619,7 +3657,7 @@ def drop_sel(self, labels=None, *, errors="raise", **labels_kwargs): in the dataset. If 'ignore', any given labels that are in the dataset are dropped and no error is raised. **labels_kwargs : {dim: label, ...}, optional - The keyword arguments form of ``dim`` and ``labels` + The keyword arguments form of ``dim`` and ``labels`` Returns ------- @@ -3900,42 +3938,68 @@ def interpolate_na( method: str = "linear", limit: int = None, use_coordinate: Union[bool, Hashable] = True, + max_gap: Union[int, float, str, pd.Timedelta, np.timedelta64] = None, **kwargs: Any, ) -> "Dataset": - """Interpolate values according to different methods. + """Fill in NaNs by interpolating according to different methods. Parameters ---------- - dim : Hashable + dim : str Specifies the dimension along which to interpolate. - method : {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', - 'polynomial', 'barycentric', 'krog', 'pchip', - 'spline'}, optional + + method : str, optional String indicating which method to use for interpolation: - 'linear': linear interpolation (Default). Additional keyword - arguments are passed to ``numpy.interp`` - - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', - 'polynomial': are passed to ``scipy.interpolate.interp1d``. If - method=='polynomial', the ``order`` keyword argument must also be + arguments are passed to :py:func:`numpy.interp` + - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial': + are passed to :py:func:`scipy.interpolate.interp1d`. If + ``method='polynomial'``, the ``order`` keyword argument must also be provided. - - 'barycentric', 'krog', 'pchip', 'spline': use their respective - ``scipy.interpolate`` classes. - use_coordinate : boolean or str, default True + - 'barycentric', 'krog', 'pchip', 'spline', 'akima': use their + respective :py:class:`scipy.interpolate` classes. + + use_coordinate : bool, str, default True Specifies which index to use as the x values in the interpolation formulated as `y = f(x)`. If False, values are treated as if - eqaully-spaced along `dim`. If True, the IndexVariable `dim` is - used. If use_coordinate is a string, it specifies the name of a + eqaully-spaced along ``dim``. If True, the IndexVariable `dim` is + used. If ``use_coordinate`` is a string, it specifies the name of a coordinate variariable to use as the index. limit : int, default None Maximum number of consecutive NaNs to fill. Must be greater than 0 - or None for no limit. - kwargs : any - parameters passed verbatim to the underlying interplation function + or None for no limit. This filling is done regardless of the size of + the gap in the data. To only interpolate over gaps less than a given length, + see ``max_gap``. + max_gap: int, float, str, pandas.Timedelta, numpy.timedelta64, default None. + Maximum size of gap, a continuous sequence of NaNs, that will be filled. + Use None for no limit. When interpolating along a datetime64 dimension + and ``use_coordinate=True``, ``max_gap`` can be one of the following: + + - a string that is valid input for pandas.to_timedelta + - a :py:class:`numpy.timedelta64` object + - a :py:class:`pandas.Timedelta` object + + Otherwise, ``max_gap`` must be an int or a float. Use of ``max_gap`` with unlabeled + dimensions has not been implemented yet. Gap length is defined as the difference + between coordinate values at the first data point after a gap and the last value + before a gap. For gaps at the beginning (end), gap length is defined as the difference + between coordinate values at the first (last) valid data point and the first (last) NaN. + For example, consider:: + + + array([nan, nan, nan, 1., nan, nan, 4., nan, nan]) + Coordinates: + * x (x) int64 0 1 2 3 4 5 6 7 8 + + The gap lengths are 3-0 = 3; 6-3 = 3; and 8-6 = 2 respectively + kwargs : dict, optional + parameters passed verbatim to the underlying interpolation function Returns ------- - Dataset + interpolated: Dataset + Filled in Dataset. See also -------- @@ -3951,6 +4015,7 @@ def interpolate_na( method=method, limit=limit, use_coordinate=use_coordinate, + max_gap=max_gap, **kwargs, ) return new @@ -4312,10 +4377,13 @@ def to_array(self, dim="variable", name=None): coords = dict(self.coords) coords[dim] = list(self.data_vars) + indexes = propagate_indexes(self._indexes) dims = (dim,) + broadcast_vars[0].dims - return DataArray(data, coords, dims, attrs=self.attrs, name=name) + return DataArray( + data, coords, dims, attrs=self.attrs, name=name, indexes=indexes + ) def _to_dataframe(self, ordered_dims): columns = [k for k in self.variables if k not in self.dims] @@ -5048,6 +5116,48 @@ def quantile( See Also -------- numpy.nanpercentile, pandas.Series.quantile, DataArray.quantile + + Examples + -------- + + >>> ds = xr.Dataset( + ... {"a": (("x", "y"), [[0.7, 4.2, 9.4, 1.5], [6.5, 7.3, 2.6, 1.9]])}, + ... coords={"x": [7, 9], "y": [1, 1.5, 2, 2.5]}, + ... ) + + Single quantile + >>> ds.quantile(0) # or ds.quantile(0, dim=...) + + Dimensions: () + Coordinates: + quantile float64 0.0 + Data variables: + a float64 0.7 + >>> ds.quantile(0, dim="x") + + Dimensions: (y: 4) + Coordinates: + * y (y) float64 1.0 1.5 2.0 2.5 + quantile float64 0.0 + Data variables: + a (y) float64 0.7 4.2 2.6 1.5 + + Multiple quantiles + >>> ds.quantile([0, 0.5, 1]) + + Dimensions: (quantile: 3) + Coordinates: + * quantile (quantile) float64 0.0 0.5 1.0 + Data variables: + a (quantile) float64 0.7 3.4 9.4 + >>> ds.quantile([0, 0.5, 1], dim="x") + + Dimensions: (quantile: 3, y: 4) + Coordinates: + * y (y) float64 1.0 1.5 2.0 2.5 + * quantile (quantile) float64 0.0 0.5 1.0 + Data variables: + a (quantile, y) float64 0.7 4.2 2.6 1.5 3.6 ... 1.7 6.5 7.3 9.4 1.9 """ if isinstance(dim, str): @@ -5098,11 +5208,7 @@ def quantile( new = self._replace_with_new_dims( variables, coord_names=coord_names, attrs=attrs, indexes=indexes ) - if "quantile" in new.dims: - new.coords["quantile"] = Variable("quantile", q) - else: - new.coords["quantile"] = q - return new + return new.assign_coords(quantile=q) def rank(self, dim, pct=False, keep_attrs=None): """Ranks the data. @@ -5222,7 +5328,7 @@ def integrate(self, coord, datetime_unit=None): datetime_unit Can be specify the unit if datetime coordinate is used. One of {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', - 'as'} + 'as'} Returns ------- @@ -5287,7 +5393,9 @@ def _integrate_one(self, coord, datetime_unit=None): datetime_unit, _ = np.datetime_data(coord_var.dtype) elif datetime_unit is None: datetime_unit = "s" # Default to seconds for cftime objects - coord_var = datetime_to_numeric(coord_var, datetime_unit=datetime_unit) + coord_var = coord_var._replace( + data=datetime_to_numeric(coord_var.data, datetime_unit=datetime_unit) + ) variables = {} coord_names = set() diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index 71e79335c3d..cf616acb485 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -351,6 +351,26 @@ def f(values, axis=None, skipna=None, **kwargs): _mean = _create_nan_agg_method("mean") +def _datetime_nanmin(array): + """nanmin() function for datetime64. + + Caveats that this function deals with: + + - In numpy < 1.18, min() on datetime64 incorrectly ignores NaT + - numpy nanmin() don't work on datetime64 (all versions at the moment of writing) + - dask min() does not work on datetime64 (all versions at the moment of writing) + """ + assert array.dtype.kind in "mM" + dtype = array.dtype + # (NaT).astype(float) does not produce NaN... + array = where(pandas_isnull(array), np.nan, array.astype(float)) + array = min(array, skipna=True) + if isinstance(array, float): + array = np.array(array) + # ...but (NaN).astype("M8") does produce NaT + return array.astype(dtype) + + def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): """Convert an array containing datetime-like data to an array of floats. @@ -370,7 +390,10 @@ def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): """ # TODO: make this function dask-compatible? if offset is None: - offset = array.min() + if array.dtype.kind in "Mm": + offset = _datetime_nanmin(array) + else: + offset = min(array) array = array - offset if not hasattr(array, "dtype"): # scalar is converted to 0d-array @@ -401,7 +424,8 @@ def mean(array, axis=None, skipna=None, **kwargs): array = asarray(array) if array.dtype.kind in "Mm": - offset = min(array) + offset = _datetime_nanmin(array) + # xarray always uses np.datetime64[ns] for np.datetime64 data dtype = "timedelta64[ns]" return ( diff --git a/xarray/core/extensions.py b/xarray/core/extensions.py index f473eaa497d..79abbccea39 100644 --- a/xarray/core/extensions.py +++ b/xarray/core/extensions.py @@ -20,10 +20,15 @@ def __get__(self, obj, cls): # we're accessing the attribute of the class, i.e., Dataset.geo return self._accessor + # Use the same dict as @pandas.util.cache_readonly. + # It must be explicitly declared in obj.__slots__. try: - return obj._accessors[self._name] - except TypeError: - obj._accessors = {} + cache = obj._cache + except AttributeError: + cache = obj._cache = {} + + try: + return cache[self._name] except KeyError: pass @@ -35,7 +40,7 @@ def __get__(self, obj, cls): # something else (GH933): raise RuntimeError("error initializing %r accessor." % self._name) - obj._accessors[self._name] = accessor_obj + cache[self._name] = accessor_obj return accessor_obj diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index c73ee3cf7c5..cb8f6538820 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -10,6 +10,7 @@ from .common import ImplementsArrayReduce, ImplementsDatasetReduce from .concat import concat from .formatting import format_array_flat +from .indexes import propagate_indexes from .options import _get_keep_attrs from .pycompat import integer_types from .utils import ( @@ -529,7 +530,7 @@ def _maybe_unstack(self, obj): for dim in self._inserted_dims: if dim in obj.coords: del obj.coords[dim] - del obj.indexes[dim] + obj._indexes = propagate_indexes(obj._indexes, exclude=self._inserted_dims) return obj def fillna(self, value): @@ -557,6 +558,113 @@ def fillna(self, value): out = ops.fillna(self, value) return out + def quantile(self, q, dim=None, interpolation="linear", keep_attrs=None): + """Compute the qth quantile over each array in the groups and + concatenate them together into a new array. + + Parameters + ---------- + q : float in range of [0,1] (or sequence of floats) + Quantile to compute, which must be between 0 and 1 + inclusive. + dim : `...`, str or sequence of str, optional + Dimension(s) over which to apply quantile. + Defaults to the grouped dimension. + interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'} + This optional parameter specifies the interpolation method to + use when the desired quantile lies between two data points + ``i < j``: + + * linear: ``i + (j - i) * fraction``, where ``fraction`` is + the fractional part of the index surrounded by ``i`` and + ``j``. + * lower: ``i``. + * higher: ``j``. + * nearest: ``i`` or ``j``, whichever is nearest. + * midpoint: ``(i + j) / 2``. + + Returns + ------- + quantiles : Variable + If `q` is a single quantile, then the result is a + scalar. If multiple percentiles are given, first axis of + the result corresponds to the quantile. In either case a + quantile dimension is added to the return array. The other + dimensions are the dimensions that remain after the + reduction of the array. + + See Also + -------- + numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile, + DataArray.quantile + + Examples + -------- + + >>> da = xr.DataArray( + ... [[1.3, 8.4, 0.7, 6.9], [0.7, 4.2, 9.4, 1.5], [6.5, 7.3, 2.6, 1.9]], + ... coords={"x": [0, 0, 1], "y": [1, 1, 2, 2]}, + ... dims=("y", "y"), + ... ) + >>> ds = xr.Dataset({"a": da}) + + Single quantile + >>> da.groupby("x").quantile(0) + + array([[0.7, 4.2, 0.7, 1.5], + [6.5, 7.3, 2.6, 1.9]]) + Coordinates: + quantile float64 0.0 + * y (y) int64 1 1 2 2 + * x (x) int64 0 1 + >>> ds.groupby("y").quantile(0, dim=...) + + Dimensions: (y: 2) + Coordinates: + quantile float64 0.0 + * y (y) int64 1 2 + Data variables: + a (y) float64 0.7 0.7 + + Multiple quantiles + >>> da.groupby("x").quantile([0, 0.5, 1]) + + array([[[0.7 , 1. , 1.3 ], + [4.2 , 6.3 , 8.4 ], + [0.7 , 5.05, 9.4 ], + [1.5 , 4.2 , 6.9 ]], + + [[6.5 , 6.5 , 6.5 ], + [7.3 , 7.3 , 7.3 ], + [2.6 , 2.6 , 2.6 ], + [1.9 , 1.9 , 1.9 ]]]) + Coordinates: + * y (y) int64 1 1 2 2 + * quantile (quantile) float64 0.0 0.5 1.0 + * x (x) int64 0 1 + >>> ds.groupby("y").quantile([0, 0.5, 1], dim=...) + + Dimensions: (quantile: 3, y: 2) + Coordinates: + * quantile (quantile) float64 0.0 0.5 1.0 + * y (y) int64 1 2 + Data variables: + a (y, quantile) float64 0.7 5.35 8.4 0.7 2.25 9.4 + """ + if dim is None: + dim = self._group_dim + + out = self.map( + self._obj.__class__.quantile, + shortcut=False, + q=q, + dim=dim, + interpolation=interpolation, + keep_attrs=keep_attrs, + ) + + return out + def where(self, cond, other=dtypes.NA): """Return elements from `self` or `other` depending on `cond`. @@ -675,17 +783,19 @@ def map(self, func, shortcut=False, args=(), **kwargs): Callable to apply to each array. shortcut : bool, optional Whether or not to shortcut evaluation under the assumptions that: + (1) The action of `func` does not depend on any of the array metadata (attributes or coordinates) but only on the data and dimensions. (2) The action of `func` creates arrays with homogeneous metadata, that is, with the same dimensions and attributes. + If these conditions are satisfied `shortcut` provides significant speedup. This should be the case for many common groupby operations (e.g., applying numpy ufuncs). - args : tuple, optional + ``*args`` : tuple, optional Positional arguments passed to `func`. - **kwargs + ``**kwargs`` Used to call `func(ar, **kwargs)` for each array `ar`. Returns @@ -730,67 +840,14 @@ def _combine(self, applied, restore_coord_dims=False, shortcut=False): combined = self._restore_dim_order(combined) if coord is not None: if shortcut: - combined._coords[coord.name] = as_variable(coord) + coord_var = as_variable(coord) + combined._coords[coord.name] = coord_var else: combined.coords[coord.name] = coord combined = self._maybe_restore_empty_groups(combined) combined = self._maybe_unstack(combined) return combined - def quantile(self, q, dim=None, interpolation="linear", keep_attrs=None): - """Compute the qth quantile over each array in the groups and - concatenate them together into a new array. - - Parameters - ---------- - q : float in range of [0,1] (or sequence of floats) - Quantile to compute, which must be between 0 and 1 - inclusive. - dim : `...`, str or sequence of str, optional - Dimension(s) over which to apply quantile. - Defaults to the grouped dimension. - interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'} - This optional parameter specifies the interpolation method to - use when the desired quantile lies between two data points - ``i < j``: - * linear: ``i + (j - i) * fraction``, where ``fraction`` is - the fractional part of the index surrounded by ``i`` and - ``j``. - * lower: ``i``. - * higher: ``j``. - * nearest: ``i`` or ``j``, whichever is nearest. - * midpoint: ``(i + j) / 2``. - - Returns - ------- - quantiles : Variable - If `q` is a single quantile, then the result - is a scalar. If multiple percentiles are given, first axis of - the result corresponds to the quantile and a quantile dimension - is added to the return array. The other dimensions are the - dimensions that remain after the reduction of the array. - - See Also - -------- - numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile, - DataArray.quantile - """ - if dim is None: - dim = self._group_dim - - out = self.map( - self._obj.__class__.quantile, - shortcut=False, - q=q, - dim=dim, - interpolation=interpolation, - keep_attrs=keep_attrs, - ) - - if np.asarray(q, dtype=np.float64).ndim == 0: - out = out.drop_vars("quantile") - return out - def reduce( self, func, dim=None, axis=None, keep_attrs=None, shortcut=True, **kwargs ): diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py index 1574f4f18df..8337a0f082a 100644 --- a/xarray/core/indexes.py +++ b/xarray/core/indexes.py @@ -5,6 +5,7 @@ import pandas as pd from . import formatting +from .utils import is_scalar from .variable import Variable @@ -35,9 +36,6 @@ def __contains__(self, key): def __getitem__(self, key): return self._indexes[key] - def __delitem__(self, key): - del self._indexes[key] - def __repr__(self): return formatting.indexes_repr(self) @@ -100,3 +98,22 @@ def roll_index(index: pd.Index, count: int, axis: int = 0) -> pd.Index: return index[-count:].append(index[:-count]) else: return index[:] + + +def propagate_indexes( + indexes: Optional[Dict[Hashable, pd.Index]], exclude: Optional[Any] = None +) -> Optional[Dict[Hashable, pd.Index]]: + """ Creates new indexes dict from existing dict optionally excluding some dimensions. + """ + if exclude is None: + exclude = () + + if is_scalar(exclude): + exclude = (exclude,) + + if indexes is not None: + new_indexes = {k: v for k, v in indexes.items() if k not in exclude} + else: + new_indexes = None # type: ignore + + return new_indexes diff --git a/xarray/core/missing.py b/xarray/core/missing.py index 77dde66484e..117fcaf8f81 100644 --- a/xarray/core/missing.py +++ b/xarray/core/missing.py @@ -1,18 +1,46 @@ import warnings from functools import partial -from typing import Any, Callable, Dict, Sequence +from numbers import Number +from typing import Any, Callable, Dict, Hashable, Sequence, Union import numpy as np import pandas as pd from . import utils -from .common import _contains_datetime_like_objects +from .common import _contains_datetime_like_objects, ones_like from .computation import apply_ufunc from .duck_array_ops import dask_array_type from .utils import OrderedSet, is_scalar from .variable import Variable, broadcast_variables +def _get_nan_block_lengths(obj, dim: Hashable, index: Variable): + """ + Return an object where each NaN element in 'obj' is replaced by the + length of the gap the element is in. + """ + + # make variable so that we get broadcasting for free + index = Variable([dim], index) + + # algorithm from https://github.com/pydata/xarray/pull/3302#discussion_r324707072 + arange = ones_like(obj) * index + valid = obj.notnull() + valid_arange = arange.where(valid) + cumulative_nans = valid_arange.ffill(dim=dim).fillna(index[0]) + + nan_block_lengths = ( + cumulative_nans.diff(dim=dim, label="upper") + .reindex({dim: obj[dim]}) + .where(valid) + .bfill(dim=dim) + .where(~valid, 0) + .fillna(index[-1] - valid_arange.max()) + ) + + return nan_block_lengths + + class BaseInterpolator: """Generic interpolator class for normalizing interpolation methods """ @@ -178,7 +206,7 @@ def _apply_over_vars_with_dim(func, self, dim=None, **kwargs): return ds -def get_clean_interp_index(arr, dim, use_coordinate=True): +def get_clean_interp_index(arr, dim: Hashable, use_coordinate: Union[str, bool] = True): """get index to use for x values in interpolation. If use_coordinate is True, the coordinate that shares the name of the @@ -195,23 +223,33 @@ def get_clean_interp_index(arr, dim, use_coordinate=True): index = arr.coords[use_coordinate] if index.ndim != 1: raise ValueError( - "Coordinates used for interpolation must be 1D, " - "%s is %dD." % (use_coordinate, index.ndim) + f"Coordinates used for interpolation must be 1D, " + f"{use_coordinate} is {index.ndim}D." ) + index = index.to_index() + + # TODO: index.name is None for multiindexes + # set name for nice error messages below + if isinstance(index, pd.MultiIndex): + index.name = dim + + if not index.is_monotonic: + raise ValueError(f"Index {index.name!r} must be monotonically increasing") + + if not index.is_unique: + raise ValueError(f"Index {index.name!r} has duplicate values") # raise if index cannot be cast to a float (e.g. MultiIndex) try: index = index.values.astype(np.float64) except (TypeError, ValueError): # pandas raises a TypeError - # xarray/nuppy raise a ValueError + # xarray/numpy raise a ValueError raise TypeError( - "Index must be castable to float64 to support" - "interpolation, got: %s" % type(index) + f"Index {index.name!r} must be castable to float64 to support " + f"interpolation, got {type(index).__name__}." ) - # check index sorting now so we can skip it later - if not (np.diff(index) > 0).all(): - raise ValueError("Index must be monotonicly increasing") + else: axis = arr.get_axis_num(dim) index = np.arange(arr.shape[axis], dtype=np.float64) @@ -220,7 +258,13 @@ def get_clean_interp_index(arr, dim, use_coordinate=True): def interp_na( - self, dim=None, use_coordinate=True, method="linear", limit=None, **kwargs + self, + dim: Hashable = None, + use_coordinate: Union[bool, str] = True, + method: str = "linear", + limit: int = None, + max_gap: Union[int, float, str, pd.Timedelta, np.timedelta64] = None, + **kwargs, ): """Interpolate values according to different methods. """ @@ -230,6 +274,40 @@ def interp_na( if limit is not None: valids = _get_valid_fill_mask(self, dim, limit) + if max_gap is not None: + max_type = type(max_gap).__name__ + if not is_scalar(max_gap): + raise ValueError("max_gap must be a scalar.") + + if ( + dim in self.indexes + and isinstance(self.indexes[dim], pd.DatetimeIndex) + and use_coordinate + ): + if not isinstance(max_gap, (np.timedelta64, pd.Timedelta, str)): + raise TypeError( + f"Underlying index is DatetimeIndex. Expected max_gap of type str, pandas.Timedelta or numpy.timedelta64 but received {max_type}" + ) + + if isinstance(max_gap, str): + try: + max_gap = pd.to_timedelta(max_gap) + except ValueError: + raise ValueError( + f"Could not convert {max_gap!r} to timedelta64 using pandas.to_timedelta" + ) + + if isinstance(max_gap, pd.Timedelta): + max_gap = np.timedelta64(max_gap.value, "ns") + + max_gap = np.timedelta64(max_gap, "ns").astype(np.float64) + + if not use_coordinate: + if not isinstance(max_gap, (Number, np.number)): + raise TypeError( + f"Expected integer or floating point max_gap since use_coordinate=False. Received {max_type}." + ) + # method index = get_clean_interp_index(self, dim, use_coordinate=use_coordinate) interp_class, kwargs = _get_interpolator(method, **kwargs) @@ -253,6 +331,14 @@ def interp_na( if limit is not None: arr = arr.where(valids) + if max_gap is not None: + if dim not in self.coords: + raise NotImplementedError( + "max_gap not implemented for unlabeled coordinates yet." + ) + nan_block_lengths = _get_nan_block_lengths(self, dim, index) + arr = arr.where(nan_block_lengths <= max_gap) + return arr diff --git a/xarray/core/nanops.py b/xarray/core/nanops.py index 17240faf007..f70e96217e8 100644 --- a/xarray/core/nanops.py +++ b/xarray/core/nanops.py @@ -25,7 +25,7 @@ def _maybe_null_out(result, axis, mask, min_count=1): """ if hasattr(axis, "__len__"): # if tuple or list raise ValueError( - "min_count is not available for reduction " "with more than one dimensions." + "min_count is not available for reduction with more than one dimensions." ) if axis is not None and getattr(result, "ndim", False): diff --git a/xarray/core/ops.py b/xarray/core/ops.py index 78c4466faed..b789f93b4f1 100644 --- a/xarray/core/ops.py +++ b/xarray/core/ops.py @@ -347,13 +347,3 @@ def inject_all_ops_and_reduce_methods(cls, priority=50, array_only=True): inject_reduce_methods(cls) inject_cum_methods(cls) - - -def inject_coarsen_methods(cls): - # standard numpy reduce methods - methods = [(name, getattr(duck_array_ops, name)) for name in NAN_REDUCE_METHODS] - for name, f in methods: - func = cls._reduce_method(f) - func.__name__ = name - func.__doc__ = _COARSEN_REDUCE_DOCSTRING_TEMPLATE.format(name=func.__name__) - setattr(cls, name, func) diff --git a/xarray/core/rolling.py b/xarray/core/rolling.py index a1864332f4d..ea6d72b2e03 100644 --- a/xarray/core/rolling.py +++ b/xarray/core/rolling.py @@ -1,12 +1,12 @@ import functools import warnings -from typing import Callable +from typing import Any, Callable, Dict import numpy as np from . import dtypes, duck_array_ops, utils from .dask_array_ops import dask_rolling_wrapper -from .ops import inject_coarsen_methods +from .ops import inject_reduce_methods from .pycompat import dask_array_type try: @@ -542,6 +542,11 @@ def __init__(self, obj, windows, boundary, side, coord_func): self.side = side self.boundary = boundary + absent_dims = [dim for dim in windows.keys() if dim not in self.obj.dims] + if absent_dims: + raise ValueError( + f"Dimensions {absent_dims!r} not found in {self.obj.__class__.__name__}." + ) if not utils.is_dict_like(coord_func): coord_func = {d: coord_func for d in self.obj.dims} for c in self.obj.coords: @@ -565,18 +570,23 @@ def __repr__(self): class DataArrayCoarsen(Coarsen): __slots__ = () + _reduce_extra_args_docstring = """""" + @classmethod - def _reduce_method(cls, func): + def _reduce_method(cls, func: Callable, include_skipna: bool, numeric_only: bool): """ - Return a wrapped function for injecting numpy methods. - see ops.inject_coarsen_methods + Return a wrapped function for injecting reduction methods. + see ops.inject_reduce_methods """ + kwargs: Dict[str, Any] = {} + if include_skipna: + kwargs["skipna"] = None def wrapped_func(self, **kwargs): from .dataarray import DataArray reduced = self.obj.variable.coarsen( - self.windows, func, self.boundary, self.side + self.windows, func, self.boundary, self.side, **kwargs ) coords = {} for c, v in self.obj.coords.items(): @@ -585,7 +595,11 @@ def wrapped_func(self, **kwargs): else: if any(d in self.windows for d in v.dims): coords[c] = v.variable.coarsen( - self.windows, self.coord_func[c], self.boundary, self.side + self.windows, + self.coord_func[c], + self.boundary, + self.side, + **kwargs, ) else: coords[c] = v @@ -597,12 +611,17 @@ def wrapped_func(self, **kwargs): class DatasetCoarsen(Coarsen): __slots__ = () + _reduce_extra_args_docstring = """""" + @classmethod - def _reduce_method(cls, func): + def _reduce_method(cls, func: Callable, include_skipna: bool, numeric_only: bool): """ - Return a wrapped function for injecting numpy methods. - see ops.inject_coarsen_methods + Return a wrapped function for injecting reduction methods. + see ops.inject_reduce_methods """ + kwargs: Dict[str, Any] = {} + if include_skipna: + kwargs["skipna"] = None def wrapped_func(self, **kwargs): from .dataset import Dataset @@ -610,14 +629,18 @@ def wrapped_func(self, **kwargs): reduced = {} for key, da in self.obj.data_vars.items(): reduced[key] = da.variable.coarsen( - self.windows, func, self.boundary, self.side + self.windows, func, self.boundary, self.side, **kwargs ) coords = {} for c, v in self.obj.coords.items(): if any(d in self.windows for d in v.dims): coords[c] = v.variable.coarsen( - self.windows, self.coord_func[c], self.boundary, self.side + self.windows, + self.coord_func[c], + self.boundary, + self.side, + **kwargs, ) else: coords[c] = v.variable @@ -626,5 +649,5 @@ def wrapped_func(self, **kwargs): return wrapped_func -inject_coarsen_methods(DataArrayCoarsen) -inject_coarsen_methods(DatasetCoarsen) +inject_reduce_methods(DataArrayCoarsen) +inject_reduce_methods(DatasetCoarsen) diff --git a/xarray/core/variable.py b/xarray/core/variable.py index cf97c997017..773dcef0aa1 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1,3 +1,4 @@ +import copy import functools import itertools import warnings @@ -24,10 +25,11 @@ from .pycompat import dask_array_type, integer_types from .utils import ( OrderedSet, + _default, decode_numpy_dict_values, either_dict_or_kwargs, - infix_dims, ensure_us_time_resolution, + infix_dims, ) try: @@ -887,7 +889,20 @@ def copy(self, deep=True, data=None): # note: # dims is already an immutable tuple # attributes and encoding will be copied when the new Array is created - return type(self)(self.dims, data, self._attrs, self._encoding, fastpath=True) + return self._replace(data=data) + + def _replace( + self, dims=_default, data=_default, attrs=_default, encoding=_default + ) -> "Variable": + if dims is _default: + dims = copy.copy(self._dims) + if data is _default: + data = copy.copy(self.data) + if attrs is _default: + attrs = copy.copy(self._attrs) + if encoding is _default: + encoding = copy.copy(self._encoding) + return type(self)(dims, data, attrs, encoding, fastpath=True) def __copy__(self): return self.copy(deep=False) @@ -978,6 +993,36 @@ def chunk(self, chunks=None, name=None, lock=False): return type(self)(self.dims, data, self._attrs, self._encoding, fastpath=True) + def _as_sparse(self, sparse_format=_default, fill_value=dtypes.NA): + """ + use sparse-array as backend. + """ + import sparse + + # TODO what to do if dask-backended? + if fill_value is dtypes.NA: + dtype, fill_value = dtypes.maybe_promote(self.dtype) + else: + dtype = dtypes.result_type(self.dtype, fill_value) + + if sparse_format is _default: + sparse_format = "coo" + try: + as_sparse = getattr(sparse, "as_{}".format(sparse_format.lower())) + except AttributeError: + raise ValueError("{} is not a valid sparse format".format(sparse_format)) + + data = as_sparse(self.data.astype(dtype), fill_value=fill_value) + return self._replace(data=data) + + def _to_dense(self): + """ + Change backend from sparse to np.array + """ + if hasattr(self._data, "todense"): + return self._replace(data=self._data.todense()) + return self.copy(deep=False) + def isel( self: VariableType, indexers: Mapping[Hashable, Any] = None, @@ -1671,40 +1716,45 @@ def quantile(self, q, dim=None, interpolation="linear", keep_attrs=None): numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile, DataArray.quantile """ - if isinstance(self.data, dask_array_type): - raise TypeError( - "quantile does not work for arrays stored as dask " - "arrays. Load the data via .compute() or .load() " - "prior to calling this method." - ) - - q = np.asarray(q, dtype=np.float64) - - new_dims = list(self.dims) - if dim is not None: - axis = self.get_axis_num(dim) - if utils.is_scalar(dim): - new_dims.remove(dim) - else: - for d in dim: - new_dims.remove(d) - else: - axis = None - new_dims = [] - # Only add the quantile dimension if q is array-like - if q.ndim != 0: - new_dims = ["quantile"] + new_dims - - qs = np.nanpercentile( - self.data, q * 100.0, axis=axis, interpolation=interpolation - ) + from .computation import apply_ufunc if keep_attrs is None: keep_attrs = _get_keep_attrs(default=False) - attrs = self._attrs if keep_attrs else None - return Variable(new_dims, qs, attrs) + scalar = utils.is_scalar(q) + q = np.atleast_1d(np.asarray(q, dtype=np.float64)) + + if dim is None: + dim = self.dims + + if utils.is_scalar(dim): + dim = [dim] + + def _wrapper(npa, **kwargs): + # move quantile axis to end. required for apply_ufunc + return np.moveaxis(np.nanpercentile(npa, **kwargs), 0, -1) + + axis = np.arange(-1, -1 * len(dim) - 1, -1) + result = apply_ufunc( + _wrapper, + self, + input_core_dims=[dim], + exclude_dims=set(dim), + output_core_dims=[["quantile"]], + output_dtypes=[np.float64], + output_sizes={"quantile": len(q)}, + dask="parallelized", + kwargs={"q": q * 100, "axis": axis, "interpolation": interpolation}, + ) + + # for backward compatibility + result = result.transpose("quantile", ...) + if scalar: + result = result.squeeze("quantile") + if keep_attrs: + result.attrs = self._attrs + return result def rank(self, dim, pct=False): """Ranks the data. @@ -1814,9 +1864,9 @@ def rolling_window( ), ) - def coarsen(self, windows, func, boundary="exact", side="left"): + def coarsen(self, windows, func, boundary="exact", side="left", **kwargs): """ - Apply + Apply reduction function. """ windows = {k: v for k, v in windows.items() if k in self.dims} if not windows: @@ -1828,11 +1878,11 @@ def coarsen(self, windows, func, boundary="exact", side="left"): func = getattr(duck_array_ops, name, None) if func is None: raise NameError(f"{name} is not a valid method.") - return type(self)(self.dims, func(reshaped, axis=axes), self._attrs) + return self._replace(data=func(reshaped, axis=axes, **kwargs)) def _coarsen_reshape(self, windows, boundary, side): """ - Construct a reshaped-array for corsen + Construct a reshaped-array for coarsen """ if not utils.is_dict_like(boundary): boundary = {d: boundary for d in windows.keys()} @@ -2006,6 +2056,14 @@ def chunk(self, chunks=None, name=None, lock=False): # Dummy - do not chunk. This method is invoked e.g. by Dataset.chunk() return self.copy(deep=False) + def _as_sparse(self, sparse_format=_default, fill_value=_default): + # Dummy + return self.copy(deep=False) + + def _to_dense(self): + # Dummy + return self.copy(deep=False) + def _finalize_indexing_result(self, dims, data): if getattr(data, "ndim", 0) != 1: # returns Variable rather than IndexVariable if multi-dimensional diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 5c754c3f49b..d38c9765352 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -269,7 +269,7 @@ def line( if None, use the default for the matplotlib function. add_legend : boolean, optional Add legend with y axis coordinates (2D inputs only). - *args, **kwargs : optional + ``*args``, ``**kwargs`` : optional Additional arguments to matplotlib.pyplot.plot """ # Handle facetgrids first @@ -672,10 +672,22 @@ def newplotfunc( # check if we need to broadcast one dimension if xval.ndim < yval.ndim: - xval = np.broadcast_to(xval, yval.shape) + dims = darray[ylab].dims + if xval.shape[0] == yval.shape[0]: + xval = np.broadcast_to(xval[:, np.newaxis], yval.shape) + else: + xval = np.broadcast_to(xval[np.newaxis, :], yval.shape) - if yval.ndim < xval.ndim: - yval = np.broadcast_to(yval, xval.shape) + elif yval.ndim < xval.ndim: + dims = darray[xlab].dims + if yval.shape[0] == xval.shape[0]: + yval = np.broadcast_to(yval[:, np.newaxis], xval.shape) + else: + yval = np.broadcast_to(yval[np.newaxis, :], xval.shape) + elif xval.ndim == 2: + dims = darray[xlab].dims + else: + dims = (darray[ylab].dims[0], darray[xlab].dims[0]) # May need to transpose for correct x, y labels # xlab may be the name of a coord, we have to check for dim names @@ -685,10 +697,9 @@ def newplotfunc( # we transpose to (y, x, color) to make this work. yx_dims = (ylab, xlab) dims = yx_dims + tuple(d for d in darray.dims if d not in yx_dims) - if dims != darray.dims: - darray = darray.transpose(*dims, transpose_coords=True) - elif darray[xlab].dims[-1] == darray.dims[0]: - darray = darray.transpose(transpose_coords=True) + + if dims != darray.dims: + darray = darray.transpose(*dims, transpose_coords=True) # Pass the data as a masked ndarray too zval = darray.to_masked_array(copy=False) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 20ef58c3c0a..a23527bd49a 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -3984,6 +3984,7 @@ def test_rasterio_environment(self): with xr.open_rasterio(tmp_file) as actual: assert_allclose(actual, expected) + @pytest.mark.xfail(reason="rasterio 1.1.1 is broken. GH3573") def test_rasterio_vrt(self): import rasterio diff --git a/xarray/tests/test_coding.py b/xarray/tests/test_coding.py index 6cd584daa96..3e0474e7b60 100644 --- a/xarray/tests/test_coding.py +++ b/xarray/tests/test_coding.py @@ -20,6 +20,23 @@ def test_CFMaskCoder_decode(): assert_identical(expected, encoded) +def test_CFMaskCoder_encode_missing_fill_values_conflict(): + original = xr.Variable( + ("x",), + [0.0, -1.0, 1.0], + encoding={"_FillValue": np.float32(1e20), "missing_value": np.float64(1e20)}, + ) + coder = variables.CFMaskCoder() + encoded = coder.encode(original) + + assert encoded.dtype == encoded.attrs["missing_value"].dtype + assert encoded.dtype == encoded.attrs["_FillValue"].dtype + + with pytest.warns(variables.SerializationWarning): + roundtripped = coder.decode(coder.encode(original)) + assert_identical(roundtripped, original) + + def test_CFMaskCoder_missing_value(): expected = xr.DataArray( np.array([[26915, 27755, -9999, 27705], [25595, -9999, 28315, -9999]]), diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 7c6dc1825a1..a1e34abd0d5 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -14,6 +14,9 @@ from xarray.convert import from_cdms2 from xarray.core import dtypes from xarray.core.common import full_like +from xarray.core.indexes import propagate_indexes +from xarray.core.utils import is_scalar + from xarray.tests import ( LooseVersion, ReturnItem, @@ -1182,6 +1185,16 @@ def test_selection_multiindex_remove_unused(self): expected = expected.set_index(xy=["x", "y"]).unstack() assert_identical(expected, actual) + def test_selection_multiindex_from_level(self): + # GH: 3512 + da = DataArray([0, 1], dims=["x"], coords={"x": [0, 1], "y": "a"}) + db = DataArray([2, 3], dims=["x"], coords={"x": [0, 1], "y": "b"}) + data = xr.concat([da, db], dim="x").set_index(xy=["x", "y"]) + assert data.dims == ("xy",) + actual = data.sel(y="a") + expected = data.isel(xy=[0, 1]).unstack("xy").squeeze("y").drop_vars("y") + assert_equal(actual, expected) + def test_virtual_default_coords(self): array = DataArray(np.zeros((5,)), dims="x") expected = DataArray(range(5), dims="x", name="x") @@ -1229,6 +1242,7 @@ def test_coords(self): assert expected == actual del da.coords["x"] + da._indexes = propagate_indexes(da._indexes, exclude="x") expected = DataArray(da.values, {"y": [0, 1, 2]}, dims=["x", "y"], name="foo") assert_identical(da, expected) @@ -2318,17 +2332,20 @@ def test_reduce_out(self): with pytest.raises(TypeError): orig.mean(out=np.ones(orig.shape)) - def test_quantile(self): - for q in [0.25, [0.50], [0.25, 0.75]]: - for axis, dim in zip( - [None, 0, [0], [0, 1]], [None, "x", ["x"], ["x", "y"]] - ): - actual = DataArray(self.va).quantile(q, dim=dim, keep_attrs=True) - expected = np.nanpercentile( - self.dv.values, np.array(q) * 100, axis=axis - ) - np.testing.assert_allclose(actual.values, expected) - assert actual.attrs == self.attrs + @pytest.mark.parametrize("q", [0.25, [0.50], [0.25, 0.75]]) + @pytest.mark.parametrize( + "axis, dim", zip([None, 0, [0], [0, 1]], [None, "x", ["x"], ["x", "y"]]) + ) + def test_quantile(self, q, axis, dim): + actual = DataArray(self.va).quantile(q, dim=dim, keep_attrs=True) + expected = np.nanpercentile(self.dv.values, np.array(q) * 100, axis=axis) + np.testing.assert_allclose(actual.values, expected) + if is_scalar(q): + assert "quantile" not in actual.dims + else: + assert "quantile" in actual.dims + + assert actual.attrs == self.attrs def test_reduce_keep_attrs(self): # Test dropped attrs diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 67d3b3198dc..7db1911621b 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -8,6 +8,7 @@ import numpy as np import pandas as pd import pytest +from pandas.core.indexes.datetimes import DatetimeIndex import xarray as xr from xarray import ( @@ -22,10 +23,12 @@ open_dataset, set_options, ) +from xarray.coding.cftimeindex import CFTimeIndex from xarray.core import dtypes, indexing, utils from xarray.core.common import duck_array_ops, full_like from xarray.core.npcompat import IS_NEP18_ACTIVE from xarray.core.pycompat import integer_types +from xarray.core.utils import is_scalar from . import ( InaccessibleArray, @@ -2458,6 +2461,53 @@ def test_rename_vars(self): with pytest.raises(ValueError): original.rename_vars(names_dict_bad) + @requires_cftime + def test_rename_does_not_change_CFTimeIndex_type(self): + # make sure CFTimeIndex is not converted to DatetimeIndex #3522 + + time = xr.cftime_range(start="2000", periods=6, freq="2MS", calendar="noleap") + orig = Dataset(coords={"time": time}) + + renamed = orig.rename(time="time_new") + assert "time_new" in renamed.indexes + assert isinstance(renamed.indexes["time_new"], CFTimeIndex) + assert renamed.indexes["time_new"].name == "time_new" + + # check original has not changed + assert "time" in orig.indexes + assert isinstance(orig.indexes["time"], CFTimeIndex) + assert orig.indexes["time"].name == "time" + + # note: rename_dims(time="time_new") drops "ds.indexes" + renamed = orig.rename_dims() + assert isinstance(renamed.indexes["time"], CFTimeIndex) + + renamed = orig.rename_vars() + assert isinstance(renamed.indexes["time"], CFTimeIndex) + + def test_rename_does_not_change_DatetimeIndex_type(self): + # make sure DatetimeIndex is conderved on rename + + time = pd.date_range(start="2000", periods=6, freq="2MS") + orig = Dataset(coords={"time": time}) + + renamed = orig.rename(time="time_new") + assert "time_new" in renamed.indexes + assert isinstance(renamed.indexes["time_new"], DatetimeIndex) + assert renamed.indexes["time_new"].name == "time_new" + + # check original has not changed + assert "time" in orig.indexes + assert isinstance(orig.indexes["time"], DatetimeIndex) + assert orig.indexes["time"].name == "time" + + # note: rename_dims(time="time_new") drops "ds.indexes" + renamed = orig.rename_dims() + assert isinstance(renamed.indexes["time"], DatetimeIndex) + + renamed = orig.rename_vars() + assert isinstance(renamed.indexes["time"], DatetimeIndex) + def test_swap_dims(self): original = Dataset({"x": [1, 2, 3], "y": ("x", list("abc")), "z": 42}) expected = Dataset({"z": 42}, {"x": ("y", [1, 2, 3]), "y": list("abc")}) @@ -2745,6 +2795,42 @@ def test_unstack_errors(self): with raises_regex(ValueError, "do not have a MultiIndex"): ds.unstack("x") + def test_unstack_fill_value(self): + ds = xr.Dataset( + {"var": (("x",), np.arange(6))}, + coords={"x": [0, 1, 2] * 2, "y": (("x",), ["a"] * 3 + ["b"] * 3)}, + ) + # make ds incomplete + ds = ds.isel(x=[0, 2, 3, 4]).set_index(index=["x", "y"]) + # test fill_value + actual = ds.unstack("index", fill_value=-1) + expected = ds.unstack("index").fillna(-1).astype(np.int) + assert actual["var"].dtype == np.int + assert_equal(actual, expected) + + actual = ds["var"].unstack("index", fill_value=-1) + expected = ds["var"].unstack("index").fillna(-1).astype(np.int) + assert actual.equals(expected) + + @requires_sparse + def test_unstack_sparse(self): + ds = xr.Dataset( + {"var": (("x",), np.arange(6))}, + coords={"x": [0, 1, 2] * 2, "y": (("x",), ["a"] * 3 + ["b"] * 3)}, + ) + # make ds incomplete + ds = ds.isel(x=[0, 2, 3, 4]).set_index(index=["x", "y"]) + # test fill_value + actual = ds.unstack("index", sparse=True) + expected = ds.unstack("index") + assert actual["var"].variable._to_dense().equals(expected["var"].variable) + assert actual["var"].data.density < 1.0 + + actual = ds["var"].unstack("index", sparse=True) + expected = ds["var"].unstack("index") + assert actual.variable._to_dense().equals(expected.variable) + assert actual.data.density < 1.0 + def test_stack_unstack_fast(self): ds = Dataset( { @@ -4490,21 +4576,24 @@ def test_reduce_keepdims(self): ) assert_identical(expected, actual) - def test_quantile(self): - + @pytest.mark.parametrize("q", [0.25, [0.50], [0.25, 0.75]]) + def test_quantile(self, q): ds = create_test_data(seed=123) - for q in [0.25, [0.50], [0.25, 0.75]]: - for dim in [None, "dim1", ["dim1"]]: - ds_quantile = ds.quantile(q, dim=dim) - assert "quantile" in ds_quantile - for var, dar in ds.data_vars.items(): - assert var in ds_quantile - assert_identical(ds_quantile[var], dar.quantile(q, dim=dim)) - dim = ["dim1", "dim2"] + for dim in [None, "dim1", ["dim1"]]: ds_quantile = ds.quantile(q, dim=dim) - assert "dim3" in ds_quantile.dims - assert all(d not in ds_quantile.dims for d in dim) + if is_scalar(q): + assert "quantile" not in ds_quantile.dims + else: + assert "quantile" in ds_quantile.dims + + for var, dar in ds.data_vars.items(): + assert var in ds_quantile + assert_identical(ds_quantile[var], dar.quantile(q, dim=dim)) + dim = ["dim1", "dim2"] + ds_quantile = ds.quantile(q, dim=dim) + assert "dim3" in ds_quantile.dims + assert all(d not in ds_quantile.dims for d in dim) @requires_bottleneck def test_rank(self): @@ -5408,6 +5497,11 @@ def ds(request): ) +def test_coarsen_absent_dims_error(ds): + with raises_regex(ValueError, "not found in Dataset."): + ds.coarsen(foo=2) + + @pytest.mark.parametrize("dask", [True, False]) @pytest.mark.parametrize(("boundary", "side"), [("trim", "left"), ("pad", "right")]) def test_coarsen(ds, dask, boundary, side): @@ -5416,12 +5510,11 @@ def test_coarsen(ds, dask, boundary, side): actual = ds.coarsen(time=2, x=3, boundary=boundary, side=side).max() assert_equal( - actual["z1"], ds["z1"].coarsen(time=2, x=3, boundary=boundary, side=side).max() + actual["z1"], ds["z1"].coarsen(x=3, boundary=boundary, side=side).max() ) # coordinate should be mean by default assert_equal( - actual["time"], - ds["time"].coarsen(time=2, x=3, boundary=boundary, side=side).mean(), + actual["time"], ds["time"].coarsen(time=2, boundary=boundary, side=side).mean() ) @@ -5432,8 +5525,8 @@ def test_coarsen_coords(ds, dask): # check if coord_func works actual = ds.coarsen(time=2, x=3, boundary="trim", coord_func={"time": "max"}).max() - assert_equal(actual["z1"], ds["z1"].coarsen(time=2, x=3, boundary="trim").max()) - assert_equal(actual["time"], ds["time"].coarsen(time=2, x=3, boundary="trim").max()) + assert_equal(actual["z1"], ds["z1"].coarsen(x=3, boundary="trim").max()) + assert_equal(actual["time"], ds["time"].coarsen(time=2, boundary="trim").max()) # raise if exact with pytest.raises(ValueError): @@ -5808,7 +5901,9 @@ def test_trapz_datetime(dask, which_datetime): actual = da.integrate("time", datetime_unit="D") expected_data = np.trapz( - da, duck_array_ops.datetime_to_numeric(da["time"], datetime_unit="D"), axis=0 + da.data, + duck_array_ops.datetime_to_numeric(da["time"].data, datetime_unit="D"), + axis=0, ) expected = xr.DataArray( expected_data, diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index f678af2fec5..aee7bbd6b11 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -274,23 +274,39 @@ def assert_dask_array(da, dask): @arm_xfail -@pytest.mark.parametrize("dask", [False, True]) -def test_datetime_reduce(dask): - time = np.array(pd.date_range("15/12/1999", periods=11)) - time[8:11] = np.nan - da = DataArray(np.linspace(0, 365, num=11), dims="time", coords={"time": time}) - - if dask and has_dask: - chunks = {"time": 5} - da = da.chunk(chunks) - - actual = da["time"].mean() - assert not pd.isnull(actual) - actual = da["time"].mean(skipna=False) - assert pd.isnull(actual) - - # test for a 0d array - assert da["time"][0].mean() == da["time"][:1].mean() +@pytest.mark.parametrize("dask", [False, True] if has_dask else [False]) +def test_datetime_mean(dask): + # Note: only testing numpy, as dask is broken upstream + da = DataArray( + np.array(["2010-01-01", "NaT", "2010-01-03", "NaT", "NaT"], dtype="M8"), + dims=["time"], + ) + if dask: + # Trigger use case where a chunk is full of NaT + da = da.chunk({"time": 3}) + + expect = DataArray(np.array("2010-01-02", dtype="M8")) + expect_nat = DataArray(np.array("NaT", dtype="M8")) + + actual = da.mean() + if dask: + assert actual.chunks is not None + assert_equal(actual, expect) + + actual = da.mean(skipna=False) + if dask: + assert actual.chunks is not None + assert_equal(actual, expect_nat) + + # tests for 1d array full of NaT + assert_equal(da[[1]].mean(), expect_nat) + assert_equal(da[[1]].mean(skipna=False), expect_nat) + + # tests for a 0d array + assert_equal(da[0].mean(), da[0]) + assert_equal(da[0].mean(skipna=False), da[0]) + assert_equal(da[1].mean(), expect_nat) + assert_equal(da[1].mean(skipna=False), expect_nat) @requires_cftime diff --git a/xarray/tests/test_groupby.py b/xarray/tests/test_groupby.py index 581affa3471..97bd31ae050 100644 --- a/xarray/tests/test_groupby.py +++ b/xarray/tests/test_groupby.py @@ -137,42 +137,58 @@ def test_da_groupby_empty(): def test_da_groupby_quantile(): - array = xr.DataArray([1, 2, 3, 4, 5, 6], [("x", [1, 1, 1, 2, 2, 2])]) + array = xr.DataArray( + data=[1, 2, 3, 4, 5, 6], coords={"x": [1, 1, 1, 2, 2, 2]}, dims="x" + ) # Scalar quantile - expected = xr.DataArray([2, 5], [("x", [1, 2])]) + expected = xr.DataArray( + data=[2, 5], coords={"x": [1, 2], "quantile": 0.5}, dims="x" + ) actual = array.groupby("x").quantile(0.5) assert_identical(expected, actual) # Vector quantile - expected = xr.DataArray([[1, 3], [4, 6]], [("x", [1, 2]), ("quantile", [0, 1])]) + expected = xr.DataArray( + data=[[1, 3], [4, 6]], + coords={"x": [1, 2], "quantile": [0, 1]}, + dims=("x", "quantile"), + ) actual = array.groupby("x").quantile([0, 1]) assert_identical(expected, actual) # Multiple dimensions array = xr.DataArray( - [[1, 11, 26], [2, 12, 22], [3, 13, 23], [4, 16, 24], [5, 15, 25]], - [("x", [1, 1, 1, 2, 2]), ("y", [0, 0, 1])], + data=[[1, 11, 26], [2, 12, 22], [3, 13, 23], [4, 16, 24], [5, 15, 25]], + coords={"x": [1, 1, 1, 2, 2], "y": [0, 0, 1]}, + dims=("x", "y"), ) actual_x = array.groupby("x").quantile(0, dim=...) - expected_x = xr.DataArray([1, 4], [("x", [1, 2])]) + expected_x = xr.DataArray( + data=[1, 4], coords={"x": [1, 2], "quantile": 0}, dims="x" + ) assert_identical(expected_x, actual_x) actual_y = array.groupby("y").quantile(0, dim=...) - expected_y = xr.DataArray([1, 22], [("y", [0, 1])]) + expected_y = xr.DataArray( + data=[1, 22], coords={"y": [0, 1], "quantile": 0}, dims="y" + ) assert_identical(expected_y, actual_y) actual_xx = array.groupby("x").quantile(0) expected_xx = xr.DataArray( - [[1, 11, 22], [4, 15, 24]], [("x", [1, 2]), ("y", [0, 0, 1])] + data=[[1, 11, 22], [4, 15, 24]], + coords={"x": [1, 2], "y": [0, 0, 1], "quantile": 0}, + dims=("x", "y"), ) assert_identical(expected_xx, actual_xx) actual_yy = array.groupby("y").quantile(0) expected_yy = xr.DataArray( - [[1, 26], [2, 22], [3, 23], [4, 24], [5, 25]], - [("x", [1, 1, 1, 2, 2]), ("y", [0, 1])], + data=[[1, 26], [2, 22], [3, 23], [4, 24], [5, 25]], + coords={"x": [1, 1, 1, 2, 2], "y": [0, 1], "quantile": 0}, + dims=("x", "y"), ) assert_identical(expected_yy, actual_yy) @@ -180,14 +196,14 @@ def test_da_groupby_quantile(): x = [0, 1] foo = xr.DataArray( np.reshape(np.arange(365 * 2), (365, 2)), - coords=dict(time=times, x=x), + coords={"time": times, "x": x}, dims=("time", "x"), ) g = foo.groupby(foo.time.dt.month) actual = g.quantile(0, dim=...) expected = xr.DataArray( - [ + data=[ 0.0, 62.0, 120.0, @@ -201,12 +217,111 @@ def test_da_groupby_quantile(): 610.0, 670.0, ], - [("month", np.arange(1, 13))], + coords={"month": np.arange(1, 13), "quantile": 0}, + dims="month", ) assert_identical(expected, actual) actual = g.quantile(0, dim="time")[:2] - expected = xr.DataArray([[0.0, 1], [62.0, 63]], [("month", [1, 2]), ("x", [0, 1])]) + expected = xr.DataArray( + data=[[0.0, 1], [62.0, 63]], + coords={"month": [1, 2], "x": [0, 1], "quantile": 0}, + dims=("month", "x"), + ) + assert_identical(expected, actual) + + +def test_ds_groupby_quantile(): + ds = xr.Dataset( + data_vars={"a": ("x", [1, 2, 3, 4, 5, 6])}, coords={"x": [1, 1, 1, 2, 2, 2]} + ) + + # Scalar quantile + expected = xr.Dataset( + data_vars={"a": ("x", [2, 5])}, coords={"quantile": 0.5, "x": [1, 2]} + ) + actual = ds.groupby("x").quantile(0.5) + assert_identical(expected, actual) + + # Vector quantile + expected = xr.Dataset( + data_vars={"a": (("x", "quantile"), [[1, 3], [4, 6]])}, + coords={"x": [1, 2], "quantile": [0, 1]}, + ) + actual = ds.groupby("x").quantile([0, 1]) + assert_identical(expected, actual) + + # Multiple dimensions + ds = xr.Dataset( + data_vars={ + "a": ( + ("x", "y"), + [[1, 11, 26], [2, 12, 22], [3, 13, 23], [4, 16, 24], [5, 15, 25]], + ) + }, + coords={"x": [1, 1, 1, 2, 2], "y": [0, 0, 1]}, + ) + + actual_x = ds.groupby("x").quantile(0, dim=...) + expected_x = xr.Dataset({"a": ("x", [1, 4])}, coords={"x": [1, 2], "quantile": 0}) + assert_identical(expected_x, actual_x) + + actual_y = ds.groupby("y").quantile(0, dim=...) + expected_y = xr.Dataset({"a": ("y", [1, 22])}, coords={"y": [0, 1], "quantile": 0}) + assert_identical(expected_y, actual_y) + + actual_xx = ds.groupby("x").quantile(0) + expected_xx = xr.Dataset( + {"a": (("x", "y"), [[1, 11, 22], [4, 15, 24]])}, + coords={"x": [1, 2], "y": [0, 0, 1], "quantile": 0}, + ) + assert_identical(expected_xx, actual_xx) + + actual_yy = ds.groupby("y").quantile(0) + expected_yy = xr.Dataset( + {"a": (("x", "y"), [[1, 26], [2, 22], [3, 23], [4, 24], [5, 25]])}, + coords={"x": [1, 1, 1, 2, 2], "y": [0, 1], "quantile": 0}, + ).transpose() + assert_identical(expected_yy, actual_yy) + + times = pd.date_range("2000-01-01", periods=365) + x = [0, 1] + foo = xr.Dataset( + {"a": (("time", "x"), np.reshape(np.arange(365 * 2), (365, 2)))}, + coords=dict(time=times, x=x), + ) + g = foo.groupby(foo.time.dt.month) + + actual = g.quantile(0, dim=...) + expected = xr.Dataset( + { + "a": ( + "month", + [ + 0.0, + 62.0, + 120.0, + 182.0, + 242.0, + 304.0, + 364.0, + 426.0, + 488.0, + 548.0, + 610.0, + 670.0, + ], + ) + }, + coords={"month": np.arange(1, 13), "quantile": 0}, + ) + assert_identical(expected, actual) + + actual = g.quantile(0, dim="time").isel(month=slice(None, 2)) + expected = xr.Dataset( + data_vars={"a": (("month", "x"), [[0.0, 1], [62.0, 63]])}, + coords={"month": [1, 2], "x": [0, 1], "quantile": 0}, + ) assert_identical(expected, actual) diff --git a/xarray/tests/test_missing.py b/xarray/tests/test_missing.py index cfce5d6f645..0b410383a34 100644 --- a/xarray/tests/test_missing.py +++ b/xarray/tests/test_missing.py @@ -5,7 +5,13 @@ import pytest import xarray as xr -from xarray.core.missing import NumpyInterpolator, ScipyInterpolator, SplineInterpolator +from xarray.core.missing import ( + NumpyInterpolator, + ScipyInterpolator, + SplineInterpolator, + get_clean_interp_index, + _get_nan_block_lengths, +) from xarray.core.pycompat import dask_array_type from xarray.tests import ( assert_array_equal, @@ -153,7 +159,7 @@ def test_interpolate_pd_compat_polynomial(): def test_interpolate_unsorted_index_raises(): vals = np.array([1, 2, 3], dtype=np.float64) expected = xr.DataArray(vals, dims="x", coords={"x": [2, 1, 3]}) - with raises_regex(ValueError, "Index must be monotonicly increasing"): + with raises_regex(ValueError, "Index 'x' must be monotonically increasing"): expected.interpolate_na(dim="x", method="index") @@ -169,12 +175,19 @@ def test_interpolate_invalid_interpolator_raises(): da.interpolate_na(dim="x", method="foo") +def test_interpolate_duplicate_values_raises(): + data = np.random.randn(2, 3) + da = xr.DataArray(data, coords=[("x", ["a", "a"]), ("y", [0, 1, 2])]) + with raises_regex(ValueError, "Index 'x' has duplicate values"): + da.interpolate_na(dim="x", method="foo") + + def test_interpolate_multiindex_raises(): data = np.random.randn(2, 3) data[1, 1] = np.nan da = xr.DataArray(data, coords=[("x", ["a", "b"]), ("y", [0, 1, 2])]) das = da.stack(z=("x", "y")) - with raises_regex(TypeError, "Index must be castable to float64"): + with raises_regex(TypeError, "Index 'z' must be castable to float64"): das.interpolate_na(dim="z") @@ -439,3 +452,114 @@ def test_ffill_dataset(ds): @requires_bottleneck def test_bfill_dataset(ds): ds.ffill(dim="time") + + +@requires_bottleneck +@pytest.mark.parametrize( + "y, lengths", + [ + [np.arange(9), [[3, 3, 3, 0, 3, 3, 0, 2, 2]]], + [np.arange(9) * 3, [[9, 9, 9, 0, 9, 9, 0, 6, 6]]], + [[0, 2, 5, 6, 7, 8, 10, 12, 14], [[6, 6, 6, 0, 4, 4, 0, 4, 4]]], + ], +) +def test_interpolate_na_nan_block_lengths(y, lengths): + arr = [[np.nan, np.nan, np.nan, 1, np.nan, np.nan, 4, np.nan, np.nan]] + da = xr.DataArray(arr * 2, dims=["x", "y"], coords={"x": [0, 1], "y": y}) + index = get_clean_interp_index(da, dim="y", use_coordinate=True) + actual = _get_nan_block_lengths(da, dim="y", index=index) + expected = da.copy(data=lengths * 2) + assert_equal(actual, expected) + + +@pytest.fixture +def da_time(): + return xr.DataArray( + [np.nan, 1, 2, np.nan, np.nan, 5, np.nan, np.nan, np.nan, np.nan, 10], + dims=["t"], + ) + + +def test_interpolate_na_max_gap_errors(da_time): + with raises_regex( + NotImplementedError, "max_gap not implemented for unlabeled coordinates" + ): + da_time.interpolate_na("t", max_gap=1) + + with raises_regex(ValueError, "max_gap must be a scalar."): + da_time.interpolate_na("t", max_gap=(1,)) + + da_time["t"] = pd.date_range("2001-01-01", freq="H", periods=11) + with raises_regex(TypeError, "Underlying index is"): + da_time.interpolate_na("t", max_gap=1) + + with raises_regex(TypeError, "Expected integer or floating point"): + da_time.interpolate_na("t", max_gap="1H", use_coordinate=False) + + with raises_regex(ValueError, "Could not convert 'huh' to timedelta64"): + da_time.interpolate_na("t", max_gap="huh") + + +@requires_bottleneck +@pytest.mark.parametrize( + "time_range_func", + [pd.date_range, pytest.param(xr.cftime_range, marks=pytest.mark.xfail)], +) +@pytest.mark.parametrize("transform", [lambda x: x, lambda x: x.to_dataset(name="a")]) +@pytest.mark.parametrize( + "max_gap", ["3H", np.timedelta64(3, "h"), pd.to_timedelta("3H")] +) +def test_interpolate_na_max_gap_time_specifier( + da_time, max_gap, transform, time_range_func +): + da_time["t"] = time_range_func("2001-01-01", freq="H", periods=11) + expected = transform( + da_time.copy(data=[np.nan, 1, 2, 3, 4, 5, np.nan, np.nan, np.nan, np.nan, 10]) + ) + actual = transform(da_time).interpolate_na("t", max_gap=max_gap) + assert_equal(actual, expected) + + +@requires_bottleneck +@pytest.mark.parametrize( + "coords", + [ + pytest.param(None, marks=pytest.mark.xfail()), + {"x": np.arange(4), "y": np.arange(11)}, + ], +) +def test_interpolate_na_2d(coords): + da = xr.DataArray( + [ + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, np.nan, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, np.nan, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + ], + dims=["x", "y"], + coords=coords, + ) + + actual = da.interpolate_na("y", max_gap=2) + expected_y = da.copy( + data=[ + [1, 2, 3, 4, 5, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, np.nan, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, np.nan, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, 4, 5, 6, 7, np.nan, np.nan, np.nan, 11], + ] + ) + assert_equal(actual, expected_y) + + actual = da.interpolate_na("x", max_gap=3) + expected_x = xr.DataArray( + [ + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + [1, 2, 3, 4, np.nan, 6, 7, np.nan, np.nan, np.nan, 11], + ], + dims=["x", "y"], + coords=coords, + ) + assert_equal(actual, expected_x) diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index 6e283ea01da..a10f0d9a67e 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -265,6 +265,7 @@ def test2d_1d_2d_coordinates_contourf(self): ) a.plot.contourf(x="time", y="depth") + a.plot.contourf(x="depth", y="time") def test3d(self): self.darray.plot() @@ -2149,3 +2150,31 @@ def test_yticks_kwarg(self, da): da.plot(yticks=np.arange(5)) expected = np.arange(5) assert np.all(plt.gca().get_yticks() == expected) + + +@requires_matplotlib +@pytest.mark.parametrize("plotfunc", ["pcolormesh", "contourf", "contour"]) +def test_plot_transposed_nondim_coord(plotfunc): + x = np.linspace(0, 10, 101) + h = np.linspace(3, 7, 101) + s = np.linspace(0, 1, 51) + z = s[:, np.newaxis] * h[np.newaxis, :] + da = xr.DataArray( + np.sin(x) * np.cos(z), + dims=["s", "x"], + coords={"x": x, "s": s, "z": (("s", "x"), z), "zt": (("x", "s"), z.T)}, + ) + getattr(da.plot, plotfunc)(x="x", y="zt") + getattr(da.plot, plotfunc)(x="zt", y="x") + + +@requires_matplotlib +@pytest.mark.parametrize("plotfunc", ["pcolormesh", "imshow"]) +def test_plot_transposes_properly(plotfunc): + # test that we aren't mistakenly transposing when the 2 dimensions have equal sizes. + da = xr.DataArray([np.sin(2 * np.pi / 10 * np.arange(10))] * 10, dims=("y", "x")) + hdl = getattr(da.plot, plotfunc)(x="x", y="y") + # get_array doesn't work for contour, contourf. It returns the colormap intervals. + # pcolormesh returns 1D array but imshow returns a 2D array so it is necessary + # to ravel() on the LHS + assert np.all(hdl.get_array().ravel() == da.to_masked_array().ravel()) diff --git a/xarray/tests/test_units.py b/xarray/tests/test_units.py index fd9e9b039ac..0be6f8af464 100644 --- a/xarray/tests/test_units.py +++ b/xarray/tests/test_units.py @@ -222,7 +222,9 @@ def convert_units(obj, to): if name != obj.name } - new_obj = xr.DataArray(name=name, data=data, coords=coords, attrs=obj.attrs) + new_obj = xr.DataArray( + name=name, data=data, coords=coords, attrs=obj.attrs, dims=obj.dims + ) elif isinstance(obj, unit_registry.Quantity): units = to.get(None) new_obj = obj.to(units) if units is not None else obj @@ -307,19 +309,689 @@ def __repr__(self): class function: - def __init__(self, name): - self.name = name - self.func = getattr(np, name) + def __init__(self, name_or_function, *args, **kwargs): + if callable(name_or_function): + self.name = name_or_function.__name__ + self.func = name_or_function + else: + self.name = name_or_function + self.func = getattr(np, name_or_function) + if self.func is None: + raise AttributeError( + f"module 'numpy' has no attribute named '{self.name}'" + ) + + self.args = args + self.kwargs = kwargs def __call__(self, *args, **kwargs): - return self.func(*args, **kwargs) + all_args = list(self.args) + list(args) + all_kwargs = {**self.kwargs, **kwargs} + + return self.func(*all_args, **all_kwargs) def __repr__(self): return f"function_{self.name}" +def test_apply_ufunc_dataarray(dtype): + func = function( + xr.apply_ufunc, np.mean, input_core_dims=[["x"]], kwargs={"axis": -1} + ) + + array = np.linspace(0, 10, 20).astype(dtype) * unit_registry.m + x = np.arange(20) * unit_registry.s + data_array = xr.DataArray(data=array, dims="x", coords={"x": x}) + + expected = attach_units(func(strip_units(data_array)), extract_units(data_array)) + result = func(data_array) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail( + reason="pint does not implement `np.result_type` and align strips units" +) +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +@pytest.mark.parametrize("fill_value", (np.float64(10), np.float64(np.nan))) +def test_align_dataarray(fill_value, variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.linspace(0, 10, 2 * 5).reshape(2, 5).astype(dtype) * original_unit + array2 = np.linspace(0, 8, 2 * 5).reshape(2, 5).astype(dtype) * data_unit + x = np.arange(2) * original_unit + x_a1 = np.array([10, 5]) * original_unit + x_a2 = np.array([10, 5]) * coord_unit + + y1 = np.arange(5) * original_unit + y2 = np.arange(2, 7) * dim_unit + + data_array1 = xr.DataArray( + data=array1, coords={"x": x, "x_a": ("x", x_a1), "y": y1}, dims=("x", "y") + ) + data_array2 = xr.DataArray( + data=array2, coords={"x": x, "x_a": ("x", x_a2), "y": y2}, dims=("x", "y") + ) + + fill_value = fill_value * data_unit + func = function(xr.align, join="outer", fill_value=fill_value) + if error is not None: + with pytest.raises(error): + func(data_array1, data_array2) + + return + + stripped_kwargs = { + key: strip_units( + convert_units(value, {None: original_unit}) + if isinstance(value, unit_registry.Quantity) + else value + ) + for key, value in func.kwargs.items() + } + units = extract_units(data_array1) + # FIXME: should the expected_b have the same units as data_array1 + # or data_array2? + expected_a, expected_b = tuple( + attach_units(elem, units) + for elem in func( + strip_units(data_array1), + strip_units(convert_units(data_array2, units)), + **stripped_kwargs, + ) + ) + result_a, result_b = func(data_array1, data_array2) + + assert_equal_with_units(expected_a, result_a) + assert_equal_with_units(expected_b, result_b) + + +@pytest.mark.xfail( + reason="pint does not implement `np.result_type` and align strips units" +) +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +@pytest.mark.parametrize("fill_value", (np.float64(10), np.float64(np.nan))) +def test_align_dataset(fill_value, unit, variant, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.linspace(0, 10, 2 * 5).reshape(2, 5).astype(dtype) * original_unit + array2 = np.linspace(0, 10, 2 * 5).reshape(2, 5).astype(dtype) * data_unit + + x = np.arange(2) * original_unit + x_a1 = np.array([10, 5]) * original_unit + x_a2 = np.array([10, 5]) * coord_unit + + y1 = np.arange(5) * original_unit + y2 = np.arange(2, 7) * dim_unit + + ds1 = xr.Dataset( + data_vars={"a": (("x", "y"), array1)}, + coords={"x": x, "x_a": ("x", x_a1), "y": y1}, + ) + ds2 = xr.Dataset( + data_vars={"a": (("x", "y"), array2)}, + coords={"x": x, "x_a": ("x", x_a2), "y": y2}, + ) + + fill_value = fill_value * data_unit + func = function(xr.align, join="outer", fill_value=fill_value) + if error is not None: + with pytest.raises(error): + func(ds1, ds2) + + return + + stripped_kwargs = { + key: strip_units( + convert_units(value, {None: original_unit}) + if isinstance(value, unit_registry.Quantity) + else value + ) + for key, value in func.kwargs.items() + } + units = extract_units(ds1) + # FIXME: should the expected_b have the same units as ds1 or ds2? + expected_a, expected_b = tuple( + attach_units(elem, units) + for elem in func( + strip_units(ds1), strip_units(convert_units(ds2, units)), **stripped_kwargs + ) + ) + result_a, result_b = func(ds1, ds2) + + assert_equal_with_units(expected_a, result_a) + assert_equal_with_units(expected_b, result_b) + + +def test_broadcast_dataarray(dtype): + array1 = np.linspace(0, 10, 2) * unit_registry.Pa + array2 = np.linspace(0, 10, 3) * unit_registry.Pa + + a = xr.DataArray(data=array1, dims="x") + b = xr.DataArray(data=array2, dims="y") + + expected_a, expected_b = tuple( + attach_units(elem, extract_units(a)) + for elem in xr.broadcast(strip_units(a), strip_units(b)) + ) + result_a, result_b = xr.broadcast(a, b) + + assert_equal_with_units(expected_a, result_a) + assert_equal_with_units(expected_b, result_b) + + +def test_broadcast_dataset(dtype): + array1 = np.linspace(0, 10, 2) * unit_registry.Pa + array2 = np.linspace(0, 10, 3) * unit_registry.Pa + + ds = xr.Dataset(data_vars={"a": ("x", array1), "b": ("y", array2)}) + + (expected,) = tuple( + attach_units(elem, extract_units(ds)) for elem in xr.broadcast(strip_units(ds)) + ) + (result,) = xr.broadcast(ds) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="`combine_by_coords` strips units") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +def test_combine_by_coords(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + array2 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + x = np.arange(1, 4) * 10 * original_unit + y = np.arange(2) * original_unit + z = np.arange(3) * original_unit + + other_array1 = np.ones_like(array1) * data_unit + other_array2 = np.ones_like(array2) * data_unit + other_x = np.arange(1, 4) * 10 * dim_unit + other_y = np.arange(2, 4) * dim_unit + other_z = np.arange(3, 6) * coord_unit + + ds = xr.Dataset( + data_vars={"a": (("y", "x"), array1), "b": (("y", "x"), array2)}, + coords={"x": x, "y": y, "z": ("x", z)}, + ) + other = xr.Dataset( + data_vars={"a": (("y", "x"), other_array1), "b": (("y", "x"), other_array2)}, + coords={"x": other_x, "y": other_y, "z": ("x", other_z)}, + ) + + if error is not None: + with pytest.raises(error): + xr.combine_by_coords([ds, other]) + + return + + units = extract_units(ds) + expected = attach_units( + xr.combine_by_coords( + [strip_units(ds), strip_units(convert_units(other, units))] + ), + units, + ) + result = xr.combine_by_coords([ds, other]) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="blocked by `where`") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +def test_combine_nested(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + array2 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + + x = np.arange(1, 4) * 10 * original_unit + y = np.arange(2) * original_unit + z = np.arange(3) * original_unit + + ds1 = xr.Dataset( + data_vars={"a": (("y", "x"), array1), "b": (("y", "x"), array2)}, + coords={"x": x, "y": y, "z": ("x", z)}, + ) + ds2 = xr.Dataset( + data_vars={ + "a": (("y", "x"), np.ones_like(array1) * data_unit), + "b": (("y", "x"), np.ones_like(array2) * data_unit), + }, + coords={ + "x": np.arange(3) * dim_unit, + "y": np.arange(2, 4) * dim_unit, + "z": ("x", np.arange(-3, 0) * coord_unit), + }, + ) + ds3 = xr.Dataset( + data_vars={ + "a": (("y", "x"), np.zeros_like(array1) * np.nan * data_unit), + "b": (("y", "x"), np.zeros_like(array2) * np.nan * data_unit), + }, + coords={ + "x": np.arange(3, 6) * dim_unit, + "y": np.arange(4, 6) * dim_unit, + "z": ("x", np.arange(3, 6) * coord_unit), + }, + ) + ds4 = xr.Dataset( + data_vars={ + "a": (("y", "x"), -1 * np.ones_like(array1) * data_unit), + "b": (("y", "x"), -1 * np.ones_like(array2) * data_unit), + }, + coords={ + "x": np.arange(6, 9) * dim_unit, + "y": np.arange(6, 8) * dim_unit, + "z": ("x", np.arange(6, 9) * coord_unit), + }, + ) + + func = function(xr.combine_nested, concat_dim=["x", "y"]) + if error is not None: + with pytest.raises(error): + func([[ds1, ds2], [ds3, ds4]]) + + return + + units = extract_units(ds1) + convert_and_strip = lambda ds: strip_units(convert_units(ds, units)) + expected = attach_units( + func( + [ + [strip_units(ds1), convert_and_strip(ds2)], + [convert_and_strip(ds3), convert_and_strip(ds4)], + ] + ), + units, + ) + result = func([[ds1, ds2], [ds3, ds4]]) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="`concat` strips units") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + ), +) +def test_concat_dataarray(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = {"data": (unit, original_unit), "dims": (original_unit, unit)} + data_unit, dims_unit = variants.get(variant) + + array1 = np.linspace(0, 5, 10).astype(dtype) * unit_registry.m + array2 = np.linspace(-5, 0, 5).astype(dtype) * data_unit + x1 = np.arange(5, 15) * original_unit + x2 = np.arange(5) * dims_unit + + arr1 = xr.DataArray(data=array1, coords={"x": x1}, dims="x") + arr2 = xr.DataArray(data=array2, coords={"x": x2}, dims="x") + + if error is not None: + with pytest.raises(error): + xr.concat([arr1, arr2], dim="x") + + return + + expected = attach_units( + xr.concat([strip_units(arr1), strip_units(arr2)], dim="x"), extract_units(arr1) + ) + result = xr.concat([arr1, arr2], dim="x") + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="`concat` strips units") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + ), +) +def test_concat_dataset(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = {"data": (unit, original_unit), "dims": (original_unit, unit)} + data_unit, dims_unit = variants.get(variant) + + array1 = np.linspace(0, 5, 10).astype(dtype) * unit_registry.m + array2 = np.linspace(-5, 0, 5).astype(dtype) * data_unit + x1 = np.arange(5, 15) * original_unit + x2 = np.arange(5) * dims_unit + + ds1 = xr.Dataset(data_vars={"a": ("x", array1)}, coords={"x": x1}) + ds2 = xr.Dataset(data_vars={"a": ("x", array2)}, coords={"x": x2}) + + if error is not None: + with pytest.raises(error): + xr.concat([ds1, ds2], dim="x") + + return + + expected = attach_units( + xr.concat([strip_units(ds1), strip_units(ds2)], dim="x"), extract_units(ds1) + ) + result = xr.concat([ds1, ds2], dim="x") + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="blocked by `where`") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +def test_merge_dataarray(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.linspace(0, 1, 2 * 3).reshape(2, 3).astype(dtype) * original_unit + array2 = np.linspace(1, 2, 2 * 4).reshape(2, 4).astype(dtype) * data_unit + array3 = np.linspace(0, 2, 3 * 4).reshape(3, 4).astype(dtype) * data_unit + + x = np.arange(2) * original_unit + y = np.arange(3) * original_unit + z = np.arange(4) * original_unit + u = np.linspace(10, 20, 2) * original_unit + v = np.linspace(10, 20, 3) * original_unit + w = np.linspace(10, 20, 4) * original_unit + + arr1 = xr.DataArray( + name="a", + data=array1, + coords={"x": x, "y": y, "u": ("x", u), "v": ("y", v)}, + dims=("x", "y"), + ) + arr2 = xr.DataArray( + name="b", + data=array2, + coords={ + "x": np.arange(2, 4) * dim_unit, + "z": z, + "u": ("x", np.linspace(20, 30, 2) * coord_unit), + "w": ("z", w), + }, + dims=("x", "z"), + ) + arr3 = xr.DataArray( + name="c", + data=array3, + coords={ + "y": np.arange(3, 6) * dim_unit, + "z": np.arange(4, 8) * dim_unit, + "v": ("y", np.linspace(10, 20, 3) * coord_unit), + "w": ("z", np.linspace(10, 20, 4) * coord_unit), + }, + dims=("y", "z"), + ) + + func = function(xr.merge) + if error is not None: + with pytest.raises(error): + func([arr1, arr2, arr3]) + + return + + units = {name: original_unit for name in list("abcuvwxyz")} + convert_and_strip = lambda arr: strip_units(convert_units(arr, units)) + expected = attach_units( + func([strip_units(arr1), convert_and_strip(arr2), convert_and_strip(arr3)]), + units, + ) + result = func([arr1, arr2, arr3]) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="blocked by `where`") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize( + "variant", + ( + "data", + pytest.param("dims", marks=pytest.mark.xfail(reason="indexes strip units")), + "coords", + ), +) +def test_merge_dataset(variant, unit, error, dtype): + original_unit = unit_registry.m + + variants = { + "data": (unit, original_unit, original_unit), + "dims": (original_unit, unit, original_unit), + "coords": (original_unit, original_unit, unit), + } + data_unit, dim_unit, coord_unit = variants.get(variant) + + array1 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + array2 = np.zeros(shape=(2, 3), dtype=dtype) * original_unit + + x = np.arange(11, 14) * original_unit + y = np.arange(2) * original_unit + z = np.arange(3) * original_unit + + ds1 = xr.Dataset( + data_vars={"a": (("y", "x"), array1), "b": (("y", "x"), array2)}, + coords={"x": x, "y": y, "z": ("x", z)}, + ) + ds2 = xr.Dataset( + data_vars={ + "a": (("y", "x"), np.ones_like(array1) * data_unit), + "b": (("y", "x"), np.ones_like(array2) * data_unit), + }, + coords={ + "x": np.arange(3) * dim_unit, + "y": np.arange(2, 4) * dim_unit, + "z": ("x", np.arange(-3, 0) * coord_unit), + }, + ) + ds3 = xr.Dataset( + data_vars={ + "a": (("y", "x"), np.zeros_like(array1) * np.nan * data_unit), + "b": (("y", "x"), np.zeros_like(array2) * np.nan * data_unit), + }, + coords={ + "x": np.arange(3, 6) * dim_unit, + "y": np.arange(4, 6) * dim_unit, + "z": ("x", np.arange(3, 6) * coord_unit), + }, + ) + + func = function(xr.merge) + if error is not None: + with pytest.raises(error): + func([ds1, ds2, ds3]) + + return + + units = extract_units(ds1) + convert_and_strip = lambda ds: strip_units(convert_units(ds, units)) + expected = attach_units( + func([strip_units(ds1), convert_and_strip(ds2), convert_and_strip(ds3)]), units + ) + result = func([ds1, ds2, ds3]) + + assert_equal_with_units(expected, result) + + @pytest.mark.parametrize("func", (xr.zeros_like, xr.ones_like)) -def test_replication(func, dtype): +def test_replication_dataarray(func, dtype): array = np.linspace(0, 10, 20).astype(dtype) * unit_registry.s data_array = xr.DataArray(data=array, dims="x") @@ -330,8 +1002,33 @@ def test_replication(func, dtype): assert_equal_with_units(expected, result) +@pytest.mark.parametrize("func", (xr.zeros_like, xr.ones_like)) +def test_replication_dataset(func, dtype): + array1 = np.linspace(0, 10, 20).astype(dtype) * unit_registry.s + array2 = np.linspace(5, 10, 10).astype(dtype) * unit_registry.Pa + x = np.arange(20).astype(dtype) * unit_registry.m + y = np.arange(10).astype(dtype) * unit_registry.m + z = y.to(unit_registry.mm) + + ds = xr.Dataset( + data_vars={"a": ("x", array1), "b": ("y", array2)}, + coords={"x": x, "y": y, "z": ("y", z)}, + ) + + numpy_func = getattr(np, func.__name__) + expected = ds.copy( + data={name: numpy_func(array.data) for name, array in ds.data_vars.items()} + ) + result = func(ds) + + assert_equal_with_units(expected, result) + + @pytest.mark.xfail( - reason="np.full_like on Variable strips the unit and pint does not allow mixed args" + reason=( + "pint is undecided on how `full_like` should work, so incorrect errors " + "may be expected: hgrecco/pint#882" + ) ) @pytest.mark.parametrize( "unit,error", @@ -344,8 +1041,9 @@ def test_replication(func, dtype): pytest.param(unit_registry.ms, None, id="compatible_unit"), pytest.param(unit_registry.s, None, id="identical_unit"), ), + ids=repr, ) -def test_replication_full_like(unit, error, dtype): +def test_replication_full_like_dataarray(unit, error, dtype): array = np.linspace(0, 5, 10) * unit_registry.s data_array = xr.DataArray(data=array, dims="x") @@ -360,6 +1058,163 @@ def test_replication_full_like(unit, error, dtype): assert_equal_with_units(expected, result) +@pytest.mark.xfail( + reason=( + "pint is undecided on how `full_like` should work, so incorrect errors " + "may be expected: hgrecco/pint#882" + ) +) +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.m, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.ms, None, id="compatible_unit"), + pytest.param(unit_registry.s, None, id="identical_unit"), + ), + ids=repr, +) +def test_replication_full_like_dataset(unit, error, dtype): + array1 = np.linspace(0, 10, 20).astype(dtype) * unit_registry.s + array2 = np.linspace(5, 10, 10).astype(dtype) * unit_registry.Pa + x = np.arange(20).astype(dtype) * unit_registry.m + y = np.arange(10).astype(dtype) * unit_registry.m + z = y.to(unit_registry.mm) + + ds = xr.Dataset( + data_vars={"a": ("x", array1), "b": ("y", array2)}, + coords={"x": x, "y": y, "z": ("y", z)}, + ) + + fill_value = -1 * unit + if error is not None: + with pytest.raises(error): + xr.full_like(ds, fill_value=fill_value) + + return + + expected = ds.copy( + data={ + name: np.full_like(array, fill_value=fill_value) + for name, array in ds.data_vars.items() + } + ) + result = xr.full_like(ds, fill_value=fill_value) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="`where` strips units") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize("fill_value", (np.nan, 10.2)) +def test_where_dataarray(fill_value, unit, error, dtype): + array = np.linspace(0, 5, 10).astype(dtype) * unit_registry.m + + x = xr.DataArray(data=array, dims="x") + cond = x < 5 * unit_registry.m + # FIXME: this should work without wrapping in array() + fill_value = np.array(fill_value) * unit + + if error is not None: + with pytest.raises(error): + xr.where(cond, x, fill_value) + + return + + fill_value_ = ( + fill_value.to(unit_registry.m) + if isinstance(fill_value, unit_registry.Quantity) + and fill_value.check(unit_registry.m) + else fill_value + ) + expected = attach_units( + xr.where(cond, strip_units(x), strip_units(fill_value_)), extract_units(x) + ) + result = xr.where(cond, x, fill_value) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="`where` strips units") +@pytest.mark.parametrize( + "unit,error", + ( + pytest.param(1, DimensionalityError, id="no_unit"), + pytest.param( + unit_registry.dimensionless, DimensionalityError, id="dimensionless" + ), + pytest.param(unit_registry.s, DimensionalityError, id="incompatible_unit"), + pytest.param(unit_registry.mm, None, id="compatible_unit"), + pytest.param(unit_registry.m, None, id="identical_unit"), + ), + ids=repr, +) +@pytest.mark.parametrize("fill_value", (np.nan, 10.2)) +def test_where_dataset(fill_value, unit, error, dtype): + array1 = np.linspace(0, 5, 10).astype(dtype) * unit_registry.m + array2 = np.linspace(-5, 0, 10).astype(dtype) * unit_registry.m + x = np.arange(10) * unit_registry.s + + ds = xr.Dataset(data_vars={"a": ("x", array1), "b": ("x", array2)}, coords={"x": x}) + cond = ds.x < 5 * unit_registry.s + # FIXME: this should work without wrapping in array() + fill_value = np.array(fill_value) * unit + + if error is not None: + with pytest.raises(error): + xr.where(cond, ds, fill_value) + + return + + fill_value_ = ( + fill_value.to(unit_registry.m) + if isinstance(fill_value, unit_registry.Quantity) + and fill_value.check(unit_registry.m) + else fill_value + ) + expected = attach_units( + xr.where(cond, strip_units(ds), strip_units(fill_value_)), extract_units(ds) + ) + result = xr.where(cond, ds, fill_value) + + assert_equal_with_units(expected, result) + + +@pytest.mark.xfail(reason="pint does not implement `np.einsum`") +def test_dot_dataarray(dtype): + array1 = ( + np.linspace(0, 10, 5 * 10).reshape(5, 10).astype(dtype) + * unit_registry.m + / unit_registry.s + ) + array2 = ( + np.linspace(10, 20, 10 * 20).reshape(10, 20).astype(dtype) * unit_registry.s + ) + + arr1 = xr.DataArray(data=array1, dims=("x", "y")) + arr2 = xr.DataArray(data=array2, dims=("y", "z")) + + expected = array1.dot(array2) + result = xr.dot(arr1, arr2) + + assert_equal_with_units(expected, result) + + class TestDataArray: @pytest.mark.filterwarnings("error:::pint[.*]") @pytest.mark.parametrize( @@ -1114,7 +1969,7 @@ def test_broadcast_equals(self, unit, dtype): dim={"z": np.linspace(10, 20, 12) * unit_registry.s}, axis=1, ), - method("drop", labels="x"), + method("drop_sel", labels="x"), method("reset_coords", names="x2"), method("copy"), pytest.param( @@ -3190,7 +4045,7 @@ def test_reindex_like(self, unit, error, dtype): marks=pytest.mark.xfail(reason="strips units"), ), pytest.param( - method("apply", np.fabs), + method("map", np.fabs), marks=pytest.mark.xfail(reason="fabs strips units"), ), ), @@ -3365,7 +4220,7 @@ def test_grouped_operations(self, func, dtype): method("rename_dims", x="offset_x"), method("swap_dims", {"x": "x2"}), method("expand_dims", v=np.linspace(10, 20, 12) * unit_registry.s, axis=1), - method("drop", labels="x"), + method("drop_sel", labels="x"), method("drop_dims", "z"), method("set_coords", names="c"), method("reset_coords", names="x2"), diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index d394919dbdd..5b5aa1a523f 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -22,6 +22,7 @@ PandasIndexAdapter, VectorizedIndexer, ) +from xarray.core.pycompat import dask_array_type from xarray.core.utils import NDArrayMixin from xarray.core.variable import as_compatible_data, as_variable from xarray.tests import requires_bottleneck @@ -33,6 +34,7 @@ assert_identical, raises_regex, requires_dask, + requires_sparse, source_ndarray, ) @@ -542,6 +544,15 @@ def test_copy_index_with_data_errors(self): with raises_regex(ValueError, "must match shape of object"): orig.copy(data=new_data) + def test_replace(self): + var = Variable(("x", "y"), [[1.5, 2.0], [3.1, 4.3]], {"foo": "bar"}) + result = var._replace() + assert_identical(result, var) + + new_data = np.arange(4).reshape(2, 2) + result = var._replace(data=new_data) + assert_array_equal(result.data, new_data) + def test_real_and_imag(self): v = self.cls("x", np.arange(3) - 1j * np.arange(3), {"foo": "bar"}) expected_re = self.cls("x", np.arange(3), {"foo": "bar"}) @@ -1482,23 +1493,31 @@ def test_reduce(self): with pytest.warns(DeprecationWarning, match="allow_lazy is deprecated"): v.mean(dim="x", allow_lazy=False) - def test_quantile(self): + @pytest.mark.parametrize("q", [0.25, [0.50], [0.25, 0.75]]) + @pytest.mark.parametrize( + "axis, dim", zip([None, 0, [0], [0, 1]], [None, "x", ["x"], ["x", "y"]]) + ) + def test_quantile(self, q, axis, dim): v = Variable(["x", "y"], self.d) - for q in [0.25, [0.50], [0.25, 0.75]]: - for axis, dim in zip( - [None, 0, [0], [0, 1]], [None, "x", ["x"], ["x", "y"]] - ): - actual = v.quantile(q, dim=dim) + actual = v.quantile(q, dim=dim) + expected = np.nanpercentile(self.d, np.array(q) * 100, axis=axis) + np.testing.assert_allclose(actual.values, expected) - expected = np.nanpercentile(self.d, np.array(q) * 100, axis=axis) - np.testing.assert_allclose(actual.values, expected) + @requires_dask + @pytest.mark.parametrize("q", [0.25, [0.50], [0.25, 0.75]]) + @pytest.mark.parametrize("axis, dim", [[1, "y"], [[1], ["y"]]]) + def test_quantile_dask(self, q, axis, dim): + v = Variable(["x", "y"], self.d).chunk({"x": 2}) + actual = v.quantile(q, dim=dim) + assert isinstance(actual.data, dask_array_type) + expected = np.nanpercentile(self.d, np.array(q) * 100, axis=axis) + np.testing.assert_allclose(actual.values, expected) @requires_dask - def test_quantile_dask_raises(self): - # regression for GH1524 - v = Variable(["x", "y"], self.d).chunk(2) + def test_quantile_chunked_dim_error(self): + v = Variable(["x", "y"], self.d).chunk({"x": 2}) - with raises_regex(TypeError, "arrays stored as dask"): + with raises_regex(ValueError, "dimension 'x'"): v.quantile(0.5, dim="x") @requires_dask @@ -1814,6 +1833,26 @@ def test_coarsen_2d(self): expected[1, 1] *= 12 / 11 assert_allclose(actual, expected) + v = self.cls(("x", "y"), np.arange(4 * 4, dtype=np.float32).reshape(4, 4)) + actual = v.coarsen(dict(x=2, y=2), func="count", boundary="exact") + expected = self.cls(("x", "y"), 4 * np.ones((2, 2))) + assert_equal(actual, expected) + + v[0, 0] = np.nan + v[-1, -1] = np.nan + expected[0, 0] = 3 + expected[-1, -1] = 3 + actual = v.coarsen(dict(x=2, y=2), func="count", boundary="exact") + assert_equal(actual, expected) + + actual = v.coarsen(dict(x=2, y=2), func="sum", boundary="exact", skipna=False) + expected = self.cls(("x", "y"), [[np.nan, 18], [42, np.nan]]) + assert_equal(actual, expected) + + actual = v.coarsen(dict(x=2, y=2), func="sum", boundary="exact", skipna=True) + expected = self.cls(("x", "y"), [[10, 18], [42, 35]]) + assert_equal(actual, expected) + @requires_dask class TestVariableWithDask(VariableSubclassobjects): @@ -1853,6 +1892,17 @@ def test_getitem_with_mask_nd_indexer(self): ) +@requires_sparse +class TestVariableWithSparse: + # TODO inherit VariableSubclassobjects to cover more tests + + def test_as_sparse(self): + data = np.arange(12).reshape(3, 4) + var = Variable(("x", "y"), data)._as_sparse(fill_value=-1) + actual = var._to_dense() + assert_identical(var, actual) + + class TestIndexVariable(VariableSubclassobjects): cls = staticmethod(IndexVariable) diff --git a/xarray/tutorial.py b/xarray/tutorial.py index e99c0632fe8..d662f2fcaaf 100644 --- a/xarray/tutorial.py +++ b/xarray/tutorial.py @@ -42,8 +42,9 @@ def open_dataset( Parameters ---------- name : str - Name of the netcdf file containing the dataset - ie. 'air_temperature' + Name of the file containing the dataset. If no suffix is given, assumed + to be netCDF ('.nc' is appended) + e.g. 'air_temperature' cache_dir : string, optional The directory in which to search for and write cached data. cache : boolean, optional @@ -60,10 +61,13 @@ def open_dataset( xarray.open_dataset """ + root, ext = _os.path.splitext(name) + if not ext: + ext = ".nc" + fullname = root + ext longdir = _os.path.expanduser(cache_dir) - fullname = name + ".nc" localfile = _os.sep.join((longdir, fullname)) - md5name = name + ".md5" + md5name = fullname + ".md5" md5file = _os.sep.join((longdir, md5name)) if not _os.path.exists(localfile): diff --git a/xarray/ufuncs.py b/xarray/ufuncs.py index 0f6fc3b1334..ae2c5c574b6 100644 --- a/xarray/ufuncs.py +++ b/xarray/ufuncs.py @@ -13,6 +13,7 @@ Once NumPy 1.10 comes out with support for overriding ufuncs, this module will hopefully no longer be necessary. """ +import textwrap import warnings as _warnings import numpy as _np @@ -78,10 +79,49 @@ def __call__(self, *args, **kwargs): return res +def _skip_signature(doc, name): + if not isinstance(doc, str): + return doc + + if doc.startswith(name): + signature_end = doc.find("\n\n") + doc = doc[signature_end + 2 :] + + return doc + + +def _remove_unused_reference_labels(doc): + if not isinstance(doc, str): + return doc + + max_references = 5 + for num in range(max_references): + label = f".. [{num}]" + reference = f"[{num}]_" + index = f"{num}. " + + if label not in doc or reference in doc: + continue + + doc = doc.replace(label, index) + + return doc + + +def _dedent(doc): + if not isinstance(doc, str): + return doc + + return textwrap.dedent(doc) + + def _create_op(name): func = _UFuncDispatcher(name) func.__name__ = name doc = getattr(_np, name).__doc__ + + doc = _remove_unused_reference_labels(_skip_signature(_dedent(doc), name)) + func.__doc__ = ( "xarray specific variant of numpy.%s. Handles " "xarray.Dataset, xarray.DataArray, xarray.Variable, "