Repository: Ouranosinc/xclim

Issue:
Architecture clean-up 
### Description
I think we should take a moment and clean the files and namespace before the next release. 

For example, there is a lot of stuff in utils that I think should go into their own file. I don't like the fact that we have `temperature.py` and `precip.py` files for indicators, it seems arbitrary. 

Another question is then what should be exposed in the `xclim` namespace. 

Suggestion to clean up utils: 
- `base.py`for the Indicator class
- `generic.py` for generic functions used by indices.
- `ens.py` for ensemble related functions
- ... ?

Options for indicator classes: 
- follow the CMIP realm notation: `xclim.atmos` for all related atmospheric indicators, and `land` for hydrological processes, 'ocn' for ocean related stuff, etc. 
- all indicators directly in `xclim`



Discussion:
coveralls: ## Pull Request Test Coverage Report for [Build 658](https://coveralls.io/builds/23135055)

* **164** of **179**   **(91.62%)**  changed or added relevant lines in **2** files are covered.
* No unchanged relevant lines lost coverage.
* Overall coverage increased (+**0.02%**) to **91.324%**

---

|  Changes Missing Coverage | Covered Lines | Changed/Added Lines | % |
| :-----|--------------|--------|---: |
| [xclim/selection.py](https://coveralls.io/builds/23135055/source?filename=xclim%2Fselection.py#L137) | 50 | 53 | 94.34%
| [xclim/ensembles.py](https://coveralls.io/builds/23135055/source?filename=xclim%2Fensembles.py#L50) | 114 | 126 | 90.48%
<!-- | **Total:** | **164** | **179** | **91.62%** | -->


|  Totals | [![Coverage Status](https://coveralls.io/builds/23135055/badge)](https://coveralls.io/builds/23135055) |
| :-- | --: |
| Change from base [Build 656](https://coveralls.io/builds/23125836): |  0.02% |
| Covered Lines: | 1200 |
| Relevant Lines: | 1314 |

---
##### 💛  - [Coveralls](https://coveralls.io)


Patch:
diff --git a/docs/conf.py b/docs/conf.py
index d356c1c4..72f05dd0 100755
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -46,10 +46,10 @@ def _get_indicators(modules):
 
 def _indicator_table():
     """Return a sequence of dicts storing metadata about all available indices."""
-    from xclim import temperature, precip
+    import xclim.atmos as atmos
     import inspect
 
-    inds = _get_indicators([temperature, precip])
+    inds = _get_indicators([atmos])
     table = []
     for ind in inds:
         # Apply default values
diff --git a/docs/indices.rst b/docs/indices.rst
index edafa8e1..4318d479 100644
--- a/docs/indices.rst
+++ b/docs/indices.rst
@@ -2,9 +2,20 @@ All Indices
 ===========
 
 
-.. automodule:: xclim.indices
+.. automodule:: xclim.indices._simple
    :members:
    :undoc-members:
    :show-inheritance:
    :noindex:
 
+.. automodule:: xclim.indices._multivariate
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :noindex:
+
+.. automodule:: xclim.indices._threshold
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :noindex:
diff --git a/docs/itable.py b/docs/itable.py
index 088dfe0b..a8331230 100644
--- a/docs/itable.py
+++ b/docs/itable.py
@@ -18,10 +18,10 @@ def _get_indicators(modules):
 
 def _indicator_table():
     """Return a sequence of dicts storing metadata about all available indices."""
-    from xclim import temperature, precip
+    from xclim import atmos
     import inspect2
 
-    inds = _get_indicators([temperature, precip])
+    inds = _get_indicators([atmos])
     table = []
     for ind in inds:
         # Apply default values
diff --git a/docs/notebooks/xclim_training/XCLIM Demo - Ensembles.ipynb b/docs/notebooks/xclim_training/XCLIM Demo - Ensembles.ipynb
new file mode 100755
index 00000000..29161232
--- /dev/null
+++ b/docs/notebooks/xclim_training/XCLIM Demo - Ensembles.ipynb
@@ -0,0 +1,561 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:py.warnings:/usr/local/DEV/miniconda3/envs/py366/lib/python3.6/site-packages/xarray/core/options.py:50: FutureWarning: The enable_cftimeindex option is now a no-op and will be removed in a future version of xarray.\n",
+      "  FutureWarning)\n",
+      "\n",
+      "DEBUG:asyncio:Using selector: EpollSelector\n",
+      "DEBUG:asyncio:Using selector: EpollSelector\n",
+      "WARNING:py.warnings:/usr/local/DEV/miniconda3/envs/py366/lib/python3.6/site-packages/distributed/bokeh/core.py:56: UserWarning: \n",
+      "Port 8787 is already in use. \n",
+      "Perhaps you already have a cluster running?\n",
+      "Hosting the diagnostics dashboard on a random port instead.\n",
+      "  warnings.warn('\\n' + msg)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table style=\"border: 2px solid white;\">\n",
+       "<tr>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3>Client</h3>\n",
+       "<ul>\n",
+       "  <li><b>Scheduler: </b>tcp://127.0.0.1:45202\n",
+       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:34266/status' target='_blank'>http://127.0.0.1:34266/status</a>\n",
+       "</ul>\n",
+       "</td>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3>Cluster</h3>\n",
+       "<ul>\n",
+       "  <li><b>Workers: </b>4</li>\n",
+       "  <li><b>Cores: </b>40</li>\n",
+       "  <li><b>Memory: </b>40.00 GB</li>\n",
+       "</ul>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<Client: scheduler='tcp://127.0.0.1:45202' processes=4 cores=40>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "import glob\n",
+    "import matplotlib.pyplot as plt\n",
+    "import logging \n",
+    "from matplotlib.patches import PathPatch\n",
+    "from matplotlib.path import Path\n",
+    "mpl_logger = logging.getLogger('matplotlib') \n",
+    "mpl_logger.setLevel(logging.WARNING) \n",
+    "plt.rcParams['figure.figsize'] = [9.5*2, 6*2]\n",
+    "\n",
+    "\n",
+    "# XCLIM and xarray\n",
+    "import xclim.indices as xci\n",
+    "import xclim.temperature as temp\n",
+    "import xclim.precip as prec\n",
+    "import numpy as np\n",
+    "import xclim.utils as xut\n",
+    "import xarray as xr\n",
+    "import dask\n",
+    "from distributed import Client\n",
+    "\n",
+    "# start client\n",
+    "client=Client(n_workers=4, threads_per_worker=10,diagnostics_port=8787, memory_limit='10GB')\n",
+    "client"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'rcp45': ['/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_ACCESS1-3_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_BNU-ESM_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_CMCC-CMS_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_CanESM2_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_GFDL-ESM2M_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_HadGEM2-CC_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_INM-CM4_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_IPSL-CM5A-LR_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_IPSL-CM5B-LR_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_MPI-ESM-LR_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp45/tx_max/tx_max_YS_day_NorESM1-M_rcp45_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc'], 'rcp85': ['/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_ACCESS1-3_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_BNU-ESM_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_CMCC-CMS_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_CanESM2_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_GFDL-ESM2M_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_HadGEM2-CC_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_INM-CM4_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_IPSL-CM5A-LR_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_IPSL-CM5B-LR_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_MPI-ESM-LR_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc', '/pvcs1/DATA/testdata/XCLIM_workshop/rcp85/tx_max/tx_max_YS_day_NorESM1-M_rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.nc']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "inrep = '/pvcs1/DATA/testdata/XCLIM_workshop/'\n",
+    "rcps = ['rcp45','rcp85']\n",
+    "v = 'tx_max'\n",
+    "ncfiles = {}\n",
+    "for r in rcps:\n",
+    "    ncfiles[r] = glob.glob(glob.os.path.join(inrep,r,v,'*.nc'))\n",
+    "print(ncfiles)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "finding common time-steps\n",
+      "accessing file  1  of  11\n",
+      "accessing file  2  of  11\n",
+      "accessing file  3  of  11\n",
+      "accessing file  4  of  11\n",
+      "accessing file  5  of  11\n",
+      "accessing file  6  of  11\n",
+      "accessing file  7  of  11\n",
+      "accessing file  8  of  11\n",
+      "accessing file  9  of  11\n",
+      "accessing file  10  of  11\n",
+      "accessing file  11  of  11\n",
+      "concatenating files : adding dimension  realization\n",
+      "finding common time-steps\n",
+      "accessing file  1  of  11\n",
+      "accessing file  2  of  11\n",
+      "accessing file  3  of  11\n",
+      "accessing file  4  of  11\n",
+      "accessing file  5  of  11\n",
+      "accessing file  6  of  11\n",
+      "accessing file  7  of  11\n",
+      "accessing file  8  of  11\n",
+      "accessing file  9  of  11\n",
+      "accessing file  10  of  11\n",
+      "accessing file  11  of  11\n",
+      "concatenating files : adding dimension  realization\n"
+     ]
+    }
+   ],
+   "source": [
+    "ens_rcp45 = xut.create_ensemble(ncfiles['rcp45'])\n",
+    "\n",
+    "ens_rcp85 = xut.create_ensemble(ncfiles['rcp85'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, realization: 11, time: 151)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1951-01-01 ... 2100-01-01\n",
+      "Dimensions without coordinates: realization\n",
+      "Data variables:\n",
+      "    tx_max   (realization, time, lat, lon) float32 dask.array<shape=(11, 151, 180, 324), chunksize=(1, 10, 180, 324)>\n",
+      "Attributes:\n",
+      "    Conventions:     CF-1.5\n",
+      "    title:           ACCESS1-3 model output prepared for CMIP5 historical\n",
+      "    history:         CMIP5 compliant file produced from raw ACCESS model outp...\n",
+      "    institution:     CSIRO (Commonwealth Scientific and Industrial Research O...\n",
+      "    source:          ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 grid-point, 1...\n",
+      "    redistribution:  Redistribution prohibited. For internal use only. \n",
+      " <xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, realization: 11, time: 151)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1951-01-01 ... 2100-01-01\n",
+      "Dimensions without coordinates: realization\n",
+      "Data variables:\n",
+      "    tx_max   (realization, time, lat, lon) float32 dask.array<shape=(11, 151, 180, 324), chunksize=(1, 10, 180, 324)>\n",
+      "Attributes:\n",
+      "    Conventions:     CF-1.5\n",
+      "    title:           ACCESS1-3 model output prepared for CMIP5 historical\n",
+      "    history:         CMIP5 compliant file produced from raw ACCESS model outp...\n",
+      "    institution:     CSIRO (Commonwealth Scientific and Industrial Research O...\n",
+      "    source:          ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 grid-point, 1...\n",
+      "    redistribution:  Redistribution prohibited. For internal use only.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(ens_rcp45,'\\n',ens_rcp85)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot individual simulations\n",
+    "for i in np.arange(0,ens_rcp45[v].shape[0]):\n",
+    "    plt.plot(ens_rcp45[v][i,].mean(['lon','lat']),color='blue',linewidth=0.2)\n",
+    "    plt.plot(ens_rcp85[v][i,].mean(['lon','lat']),color='red',linewidth=0.2)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data variables:\n",
+      "    tx_max_mean   (time, lat, lon) float32 dask.array<shape=(151, 180, 324), chunksize=(10, 180, 324)>\n",
+      "    tx_max_stdev  (time, lat, lon) float32 dask.array<shape=(151, 180, 324), chunksize=(10, 180, 324)>\n",
+      "    tx_max_max    (time, lat, lon) float32 dask.array<shape=(151, 180, 324), chunksize=(10, 180, 324)>\n",
+      "    tx_max_min    (time, lat, lon) float32 dask.array<shape=(151, 180, 324), chunksize=(10, 180, 324)>\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "ens_stats = xut.ensemble_mean_std_max_min(ens_rcp85)\n",
+    "print(ens_stats.data_vars)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff9b4fcf828>]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1368x864 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.rcParams['figure.figsize'] = [9.5*2, 6*2]\n",
+    "x = ens_stats['tx_max_mean'].time.dt.year\n",
+    "y1 = ens_stats['tx_max_max'].mean(['lon','lat'])\n",
+    "y2 = ens_stats['tx_max_min'].mean(['lon','lat'])\n",
+    "plt.fill_between(x,y1,y2, facecolor='red', alpha=0.25)\n",
+    "plt.plot(x,ens_stats['tx_max_mean'].mean(['lon','lat']), color='red', linewidth = 1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading ensemble data to memory\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:py.warnings:/usr/local/DEV/miniconda3/envs/py366/lib/python3.6/site-packages/numpy/lib/function_base.py:3652: RuntimeWarning: Invalid value encountered in percentile\n",
+      "  interpolation=interpolation)\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data variables:\n",
+      "    tx_max_p10  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p50  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p90  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "loading ensemble data to memory\n",
+      "Data variables:\n",
+      "    tx_max_p10  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p25  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p50  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p75  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n",
+      "    tx_max_p90  (time, lat, lon) float64 nan nan nan nan nan ... nan nan nan nan\n"
+     ]
+    }
+   ],
+   "source": [
+    "ens_perc = xut.ensemble_percentiles(ens_rcp85)\n",
+    "print(ens_perc.data_vars)\n",
+    "ens_perc = xut.ensemble_percentiles(ens_rcp85, values=[10,25,50,75,90])\n",
+    "print(ens_perc.data_vars)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff9a6b36f98>]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABFAAAAKvCAYAAABNkzvKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XmQZFd55/3fqepNvUjdUrcEWkCAkISQ0ILYLA8G2XjA2IiJIRgzXuadgNcx420wHoeNY+J9X0fMOMZLGA9esMGOMLbHxsYxYxgwtrGM2UFqCW0tC6GW1Op9qa41KyvX8/5x+pJZN+9y7pKZNzO/n4iK7q66ee/NzCqFzq+e5znGWisAAAAAAADEmxv3DQAAAAAAAFQdAQoAAAAAAEAKAhQAAAAAAIAUBCgAAAAAAAApCFAAAAAAAABSEKAAAAAAAACkIEABAAAAAABIQYACAAAAAACQggAFAAAAAAAgxZZx34Ak7d+/31577bXjvg0AAAAAADBDHnjggXPW2gM+x1YiQLn22mt18ODBcd8GAAAAAACYIcaYI77H0sIDAAAAAACQggAFAAAAAAAgBQEKAAAAAABACgIUAAAAAACAFAQoAAAAAAAAKQhQAAAAAAAAUhCgAAAAAAAApCBAAQAAAAAASEGAAgAAAAAAkIIABQAAAAAAIAUBCgAAAAAAQAoCFAAAAAAAgBQEKAAAAAAAACkIUAAAAAAAAFIQoAAAAAAAAKQgQAEAAAAAAEhBgAIAAAAAAJCCAAUAAAAAACAFAQoAAAAAAEAKAhQAAAAAAIAUBCgAAAAAAAApCFAAAAAAAABSEKAAAAAAAACkIEABAAAAAABIQYACAAAAAACQggAFAAAAAAAgBQEKAAAAAABACgIUAAAAAACAFAQoAAAAAABUQacz7jtAAgIUAAAAAACqoF4f9x0gAQEKAAAAAADj1mq5D1QWAQoAAAAAAOPWbNLCU3EEKAAAAAAAjFuzKbXb474LJCBAAQAAAABg3KhAqbwt474BAAAAAABmXqtFgFJxBCgAAAAAAIxbsznuO0AKAhQAAAAAAMap23XzT4wZ950gATNQAAAAAAAYp2D7Ymtp46kwAhQAAAAAAMapv32HAKWyCFAAAAAAABin/gCFrYwriwAFAAAAAIBxqkoFCuFNIgIUAAAAAADGqSoBCjsBJSJAAQAAAAAgj3bbDX4tKhgiG5xzXBqN8V17AhCgAAAAAACQR6fjtiAuot3efI5xVqAQoCTaMu4bAAAAAABgIgXVIvPz+c8RbpsZVwVKp8MMlBQEKAAAAAAA5NHpSMYUO0c4QBlXBQoBSioCFAAAAAAA8igjQOmffxKccxza7fG2D00AZqAAAAAAAJBHGTNQqtTCQ4CSiAAFAAAAAIA8yggdwgGKtcVDmTyC4IYQJRYBCgAAAAAAeRQNUKwdbOGRxlOFElyTOSixmIECAAAAAEAeRWegRIUnwXlHLbgmFSixCFAAAAAAAMijaIASbt/pP++o0cKTigAFAAAAAIA8hhWgjKONhgqUVAQoAAAAAABkZe10VqAwAyUWQ2QBAAAAAMiqjIqNqlSgBGGQRAVKAgIUAAAAAACyCoIGa91HHlUZItt/PQKUWAQoAAAAAABkVTR0SNoCedQVKAQoXghQAAAAAADIqmjoENe+k/d8RfQHNsxAiUWAAgAAAABAVtMaoFCBEosABQAAAACArIoGKHHzTySp23Ufo9J//91u/pkuU44ABQAAAACArIZZgZL3nHmF23aoQomUGqAYY3YYY+4zxjxsjDlkjPmlC5//SWPMU8YYa4zZ33f8DxljHjHGPGqM+Yox5tZhPgEAAAAAAEZumgKU8LUIUCJt8TimIelua+2aMWarpC8ZYz4j6cuSPiXpn0LHPyPpu6y1i8aYt0j6sKTXlHjPAAAAAACMV3/IkHXwqrXJLTx5zllE+FrttrR9++iuPyFSAxRrrZW0duGfWy98WGvtNyTJGBM+/it9//yapKtLuVMAAAAAAKqiP3TIOq+k1UqfM0ILT+V4zUAxxswbYx6SdEbSZ621X/c8/7slfSbvzQEAAAAAUElFWnjSqk+k0Vag0MLjxStAsdZ2rLW3yVWTvNoYc3PaY4wxb5QLUH4+5us/Zow5aIw5ePbs2Sz3DAAAAADAeBUJUNLmn+Q5Z15RO/6MMryZIJl24bHWLkn6nKQ3Jx1njHmFpD+QdI+1diHmXB+21t5prb3zwIEDWW4DAAAAAIDxKVqxUaUAJeo6VKBE8tmF54AxZu+Fv18k6U2Snkg4/gWS/pekH7HWPlnWjQIAAAAAUAmjCFBGVQUSdR0ClEg+FSjPl/Q5Y8wjku6Xm4HyKWPMTxtjjsm19TxijPmDC8f/P5Iuk/S7xpiHjDEHh3LnAAAAAACMQzhgsDbbIFmfGShUoFSOzy48j0i6PeLzH5T0wYjPv0fSe0q5OwAAAAAAqiYudJjzqFHodv2qS8ZZgcIMlEiZZqAAAAAAADDzilRt+LTvSC5oSdvquAy08HgjQAEAAAAAIIsiAYpP+07WcxYRdY2sLUkzggAFAAAAAIAsigQoWdpjRtFKE3cNqlAGEKAAAAAAAJDFtFegjOraE4YABQAAAACALIrMDZmUChQGyQ4gQAEAAAAAIAsqUGYSAQoAAAAAAFmMKkAZdhVIpxO/0w8BygACFAAAAAAAssgboHS72Xa3GXaIkXR+ApQBBCgAAAAAAPjqdqOrNnwChyzVJ77nLCKpwoUZKAMIUAAAAAAAk6nZHP01i8wMyRpKDDvESDo/FSgDCFAAAAAAAJOpVsvWElOGpAAlbp5IoGoVKLTwZEKAAgAAAACYTI3G6KtQkoKFtDAnT4CSFsoUQQtPJgQoAAAAAIDJtLFRrQAlrWojTygxzEoQKlAyIUABAAAAAEwea114MkkBStYKFJ9zFpEW6BCibEKAAgAAAACYPI2G+7OsAKXT6Z0zSZHBq3kClGG20hCgZEKAAgAAAACYPGUHKOvrfgFK3goUa/MFEuNq4Rn2tSfQlnHfAAAAAAAAmW1suD9bLRdOGFPsfGtr0haPJXLeACVP9Yk0vAoUn0CHQbKbUIECAAAAAJg8QbWItcUX+ta6LZF9qlnyBih573FYVSA+56UCZRMCFAAAAADAZLF2c7tN0Taeet1tQTzMFp68FSjDCjF8Ah0ClE0IUAAAAAAAk6XZdCFK/7+LqNXcn+12sbkgk9TC4xOO0MKzCQEKAAAAAGCyhCtFigYoa2t+57LWVarEmaQWHipQMiNAAQAAAABMljIDlEZjc3VIUhtPkeqUSaxAIUDZhAAFAAAAADBZgh14AkUClKB9J1C1ACVviNHf4hSFCpTMCFAAAAAAAJMlHHJ0OvkX+/3tO1HnDl8nSbcbHVwU3Skoz3NbWkr+OgFKZgQoAAAAAIDJ0WpFzyHJU4XSbmerZsnb9lK0DSfP4zc2Bqtr+vk+l7RKlhlCgAIAAAAAmBxxFSJ5ApSogKHbjW+3yVu1UTRAyVMJ0m5Ly8vJXx/WtacUAQoAAAAAYHKEK0YCZQUoSefKW4GSd/5JIE8A0+m49qS4x/oGIwQo30aAAgAAAACYHGVVoFgbH6DEXWNcAUreChQpugql203ejrnotacUAQoAAAAAYHKUFaCsr8fP9yg7QBn1DBRrewHJ8vLg88xyvmFtozyBCFAAAAAAAJOh04lf0Lda2Qaehnff6TfpFSj9x7fbg5U2Wc5HBcq3EaAAAAAAACZD3PyTQJYqlKQdauLCmEmpQAkfH97SOMv5CFC+jQAFAAAAADAZ4ipDAr4BysZGcohgbfS5JrECRXLtSv3PhwqUXAhQAAAAAACTIS1A8Q0qktp34q5lbb4Apd3O1loUpWgFirR5mCwzUHIhQAEAAAAATIayWniS2nfizpV315oyAohOJ1sIExX0rKz0zkEFSi4EKAAAAACA6ut20ytMfAKUViu9kkUaPMY3SAgfV7R9J1C0aqTTkVZXs5+LAOXbCFAAAAAAANXnE3r4BChBiJD1er6hQxUClLjQI2jjoYUnFwIUAAAAAED1pbXvSK5KJW04bHhHmjjt9ua2Hd9KDGs3P66sAKKM0KNed8FQlqqS8POZYQQoAAAAAIDq86lAkZKrUGq1bEFE/zXzzg0pqwKlrLklS0vZQx3aeCQRoAAAAAAAJkEZAYpv9UnUNfMGGFWqQJHcMNms4p776qpfZdCUIEABAAAAAFSbtf477MQd12hI6+vZrtt/rnFXoPgGKGktN3m2VI567vW6dOpU9nNNMAIUAAAAAEC1NRr+C/+4ACVr9Ulw3UCeAKXTKW9+SN4htsO4drMpnTiRL4yZYAQoAAAAAIBq823fkaIDlE4nX+tK0QClzB1sfM81jF1zwi1Jx4/P5FwUAhQAAAAAQLXV6/7HhnfPkVx4kqdaon9XnzwBSlntO1muXyTYiHuNgnN2uy48KfN5TRACFAAAAABAdTWbblhp1sf0y9O+EwiqUMZdgdLp+IVARa4ZF1QF1z55Mls10JQhQAEAAAAAjE7WQa5nz2avHukPUNbWilVMFAlQyq7U8AlHilSgxL037bZ05ozbBnqGbRn3DQAAAAAAZsjKigs49u5NP7ZWy7do7w9QilSfBOfyrf4IDDNA2bo1/Zg8Wq346pKsodeUogIFAAAAADA6zaarKkkLF6x1x+W9RvBn0cV/o5G9qmMYLTy+58tbgRIERYhFgAIAAAAAGJ1Wy4Ujp04lH7e8HL8lcZrgcYuL+R4fPlfeAGWSWngajeHs4DNFCFAAAAAAAKPR7fYW+PV6fMDR6UgLC/mv02rl37o4zNpsuwBJ7tr9z7UsPufLG4JQgZKKAAUAAAAAMBrhioxz56KrTBYWim/Hu7CQb+viKHnagIaxW82wK1AIUBIRoAAAAAAARiMclkS18jSbxQe/SuWcI5C1AkWSNjbKu34gLUCxtngLT1mh0xQiQAEAAAAAjEbUTJCNjc2tPGfOjO5+fOUJFcZRgZI3PLG2995QhRKLAAUAAAAAMBpxQ1WDVp5abXq2zB1HBUqR+SdBSESAEmvLuG8AAAAAADAj4gKUoJWn2x3t/QxT3h2EknS77rUyJvrrRdp3Au22tH17vvNMOQIUAAAAAMBoJIUKw6jYmEbttrR1a/TX8gYo/e8LFSixaOEBAAAAAAyftflbTNCT9BrmfX3DFSiIRIACAAAAABi+uPYdZJMUcJTVwoNIBCgAAAAAgOEbxkyQWTSMChRaeLwQoAAAAAAAho8KlHKUXYHS6Ww+JxUosQhQAAAAAADDR4BSjqSQJE/40d++k3b+GUeAAgAAAAAYPlp4ylF2BQoBijcCFAAAAADA8FGBUo64AMXafOFHONiihScWAQoAAAAAYLisJUApS1zAkbdyhADFGwEKAAAAAGC4WJSXp9t1H2FlbGEsubAr6vwgQAEAAAAADBnzT8oVFUjlCamsHQxQ8p5rBhCgAAAAAACGi/adckVVm+SpQGm1XIgSRoASKTVAMcbsMMbcZ4x52BhzyBjzSxc+/5PGmKeMMdYYs7/veGOM+eCFrz1ijLljmE8AAAAAAFBxBCjlKqsCJa4yiJ14Im3xOKYh6W5r7ZoxZqukLxljPiPpy5I+JemfQse/RdJLL3y8RtKHLvwJAAAAAJhFtPCUKyosKWML46TzIz1AsdZaSWsX/rn1woe11n5Dkowx4YfcI+mPLzzua8aYvcaY51trT5Z32wAAAACAiUEFSrnKqkCJC1CoQInkNQPFGDNvjHlI0hlJn7XWfj3h8KskHe3797ELnwuf88eMMQeNMQfPnj2b5Z4BAAAAAJOEAKVcw65AIUCJ5BWgWGs71trbJF0t6dXGmJuLXtha+2Fr7Z3W2jsPHDhQ9HQAAAAAgCpqt6MHlSK/Yc9AoYUnUqZdeKy1S5I+J+nNCYcdl3RN37+vvvA5AAAAAMCsYf5J+crYhafbja8MogIlks8uPAeMMXsv/P0iSW+S9ETCQz4p6Ucv7MbzWknLzD8BAAAAgBlF+075whUi1mYPPeLadyTesxg+FSjPl/Q5Y8wjku6Xm4HyKWPMTxtjjslVmDxijPmDC8f/jaSnJT0l6SOSfnwI9w0AAAAAmAQsxsvX7bqPQJ6KkaTKICpQIvnswvOIpNsjPv9BSR+M+LyV9BOl3B0AAAAAYLIRoAxHuy1t2+b+XuYA2bznmwGZZqAAAAAAAJAJM1CKq9cHP9ffxlPmFsaSC1AY/DuAAAUAAAAAMDzTXIEyqpBhdXXwc/1VImW38EjsxBOBAAUAAAAAMBydzuZZHdOm0RhN0BAVoAyzAkWijScCAQoAAAAAYDimvX1nY8N9DFOjEf069ocmWcOOVis92KICZQABCgAAAABgOCatfSfr/caFG2VaX4+eSVIkQEmrPslzzhlAgAIAAAAAGI5JClBaLRdWZNFs+oURRQQDZMOBRpEWHp/QhwBlAAEKAAAAAGA4JqmFp9nM3o7TaAw/QAlCnaQAJWvY4fO+TFL4NSIEKAAAAACA4ZikRXjWdhxr3WOGOQOl0+mdP1xlUqQChRaeXAhQAAAAAAD5pAUOkxSgZK1AaTZdiNJuDy9sCNp3pMFrWNsbBMsMlJEgQAEAAAAAZLe+Lh05Ip09G/31bneyFuFBO47vtsv9IUSWNp4sVS79M1miXst2O3v1ibV+98AuPAMIUAAAAACgCqx1i+Soj6pZW5OOH3f3vLgoLSwMHjNJ80+k3v36hiF5A5TV1c2VJUmSKlCkfNUvtZrfcVX8vhuzLeO+AQAAAACA3ML61Knor111lbRr12jvJ87qqnTy5ObPLSxIc3PSvn29z01S+05/VUajIV10Ufpj+kOTLGFRve6CD59r+AQoWa2u+h1HBcoAKlAAAAAAoAqSFuG+FQvDtrw8GJ4Ezp51Xw9MUoDSarkQRRp+BUq9vvl1itNspg+KzdPCs7LidxwVKAMIUAAAAACgCpIChzIDlLzBxuKidPp08jGnT/cW6JPUwtMfgPgOks3zmG63t9tP2mPCrTZRgUbWFq963f/9D1rK8G0EKAAAAABQBUmBw8ZGr0KiiPV16fz57I9bXIwfFht26pSbkTJJFShZw5Bmc/Ow2WBHnjT9QVhaFUo4NCujAsW3+iRAgLIJAQoAAAAAVEFSgGJttjaRKN2uqxDJUxmytJTt+JMni9/vKPW/Jq1WenAQ9Rr6PN/+cCYtzAgHKFG7A2UdIus7/yQwSSHYCBCgAAAAAMC4tdvpFQz9W9rmsbDgFsRZg41uN/tC2lr/7YCrIPyapL1GUV/3eV37Q5FGI77apdstvwLFp20ojAqUTQhQAAAAAIxWGa0o08anKqTIHJR63bXhSG5xnqXtY5JmmeQVDj/Sgoaor2etQJHiq1CiwrKi2xhnbd8Jzo9vI0ABAAAAMDp5qhlmgU9IkbV6IGDt4PDXLFUok9SKk0dUoDSMCpRu1z9AiQrLooa69m+/nCZPgEIFyiYEKAAAAABGp90mQIniswjudPJVgywsDD6OAKUnTxiSZwZKVAC2sRH9uLh2rahAw6eiq93O1wJGgLIJAQoAAACA0Wm3Z6MlJCvfUClrG0+jEb3rTpb3YBYDlKRqn7i5I2k78cSdM2o3nrj3OW9LTdbhsUWvN6UIUAAAAACMDhUo0XwDjSwBirVuS+EoVKD0RL32ScNZ416PtPa0uPcuHG40m/HXzjuYN2+AQgXKJgQoAAAAAEan1SJACbN2OBUoi4vxi/20aolAuz1Zu+nkEfcaZf182tfi3rt6fXOIk9Rqk6cipNuV1tayPy7v9aYYAQoAAACA0aGFZ1CWQKnV8lvUtttu9kkc39Bm2qtPpPjvxzIDlG43+XH9bTxJAUqeipC1tfwhGAHKJgQoAAAAAEYnaI1gK+OerIGSTxXK0lL6a+xz3VkOUOJmluQJUDY2kt+P/h1ykt7fPIFGnt13ArTwbEKAAgAAAGB0gvCE32z3lB2gWBs9mDTMJxyZ9gCl1YoPCfIEKHGPSduCOmjjidrquF/WQMPa/PNPJHc/097ClQEBCgAAAIDRCYIT5qD0lB2grK76LbSpQEl+DaKee9qg2Ljz+VQNray49p2kSpWsAUqtVryKhLDz2whQAAAAAIyGtb3FHHNQerKGSY1GclXA4qL/eZJYO/3vU9Jr0OkMvjdpr1nUY6T0ChTJVQ2lBS1Zw5Ai1Sd5rznFCFAAAAAAjEb/wpIKlJ48IUXSji6+VSNpO/FMe3gipT/H8GvpE4SEH2Ot3+Pq9fR5JVnDjCLzT/Jec4oRoAAAAAAYjf5WgFlYnPvodPItUOMCFN/qk0DWFpZpk/Z9GA4+fL5vw8ekDZDtl1aBkqWdpl4vJ6ikhefbCFAAAAAAjEb/QowKFCfv6xC10G613Ja1WeTZUWaapD3HcIDi85qEH+Mz/8RXlrAt6/dCGdeccgQoAAAAAEaDAGVQ3kqcqKoGn513slx/2gMUnxkv4dcgz85FZQYoWXbFKavKK60CZYZ+lglQAAAAAIxG/0KMrYydvIvc8FyNbjdfgJIUCEx7m1Wrld5a0//6+A7VzTM3JQvfn5uygo2kCpS1ten/PulDgAIAAABgNMILvxlaeMUqssjtr2zw3bo4LC5A6XSmP+DyqSbpdnvfp42G3yyTdrv3XvgOkM3CtwKlrAAl6fvg/PlyrjEhCFAAAAAAjEZ4QTdDpf+xioRI/QFK1uGxgXY7ekE+7e07kv9zDI7L8poEx2YZIOtr1BUocddrtcrZJnmCEKAAAAAAGI3wQowApViAElQ2rK8XO0/UY2chQPF9zYLXOU+AUub8k4BPpVFcMFbm9RYXyw+HKo4ABQAAAMDwWTu4EJv1Fp52u9gCtNNxC/W81SeBqGBgGgKU9fXkr/s+xyIBStntO5JfgFJmOBl1PWuLf99NIAIUAAAAAMMX1QYw6xUoZQRIKytSrVbsHFHBwKSHW62W9NxzyWHDKFp4hlGB4tPCU+bPVlTQt7Y2kz+/BCgAAAAAho8AZVAZIUUZVQDT2MKztua+586cif56t+s/SyQYHpvl/QoeMw0VKFHXnMHqE4kABQAAAMAoRC1Wsyxip1FVqjzCYUmzOfmzLdbW3J8LC9FVIFkCImvd+bLMFGk23XWH8TqOO0BpNl3l0wwiQAEAAACQX9EdQWa5CqUqz73T2bxAHlf1Sfg+8goCj8DJk4PHZH2Oy8vZ72NYIcM4ApT+n/MZrT6RCFAAAAAAFJE2qDOQtBXqrKpKBYq0OVAYV4CytiYtLRU/T72+OWRYXx9c9Gd97fNs11vGc4niE1qW/b0VvJ4zOjw2QIACAAAAIB9r/Ydkxi36qhQijJK11QqP+t+Hcb0nq6uu5aaM84SdPl2syiZPZcyw2tPGWYGyujrTbXcEKAAAAADyabf9F6JUoGxWteddlQqUZjNftUf4PGHhgbKTHNylBSjWlh9yBOeb4eoTiQAFAAAAQF6dDgFKXlVbwAfvY7c7nvekXu99j5w7l/887XZ8VdT5871dcar2+mfR6SQPpx3G+9fplBNuTTgCFAAAAAD5BAu5tMVo0m/EJ3khW0TVnndwP+OqPulfmNdq+bf/jao+CVgrnTjhAoYyhtWOU9L9D+N7q92e+eoTiQAFAAAAQF5BKJK2YEta7HW7k7+YzaNqlTdB5ck455/0yzsLJSlAkdxA2f5WnkmV9DMzjO8tAhRJBCgAAAAA8goWcWlVC2kLuqqFCaNQtQoUyd3TOCpQotpulpbyzfFIC1Ck6QgCkl6bYfw81WozPTw2QIACAAAAIJ9gQZW26E5beFUxTBi2Kj7nRmM8AUpU6GGtm1mSRf8clWk36goUSCJAAQAAAJCXbwVK2qJ21hZ8nU4125bGVYESN5j0/PnkYalhPtUn02LUFSiQRIACAAAAIK9gEddquRkaacfFGcaCb329/HOWpaoL3Fot+X0cBmvjg492W1pe9j/XLO0QQwXKWBCgAAAAAMinfxGX1JIyjhae5eVqVnlI1Wzfkcbzeq2vJ1/Xd5hspxO/ffE0Sgq6CFCGhgAFAAAAQD79wUhS68c4hsiur49vS940VQ1QxiGt7aZed5UxPufJ0u4z6eJCyXZ79FVEM4QABQAAAICTZeFl7ebjk8KKtAqUTqfcRV+j4c65sVHeOcvS6VQ32BkHn7klPsNkZ2n+iRRftUP1yVBtGfcNAAAAAKiIel3atcvv2HAoEldVYa3fziitlrR9u9+10wStHOMOKrpddw8bG70PFrg9rZZf283ysnTFFdK2bfHHzNL8Eyn+Z4rvr6EiQAEAAADgZAlQwr8BjwsrfOdqNJvlBSjBANlxVqAsL0unT4/v+pMgS+hx9Kh05ZXSRRcNfm1jY3a2Lw5QgTIWtPAAAAAAcAvQLLM5wgvWTid6Eeu7sC1z4RdUNbRa4xmM2m5LZ8+O/rqTJkvbTb0uHT4snTw5+J7OWvuORIAyJgQoAAAAANzCK8viK2oBF1WFUkaAkmU+SjD/JOmehu3MGQZ5pknavjjJwoL0rW9JS0u9z81a+45EgDImBCgAAAAA3MIrSxtE1LFRFSy+C7q46pd227Vv+FbHBO07gVG38ayuzmZFRFa1Wv6Qqd2Wjh2TnnnGvd/h93wWWBsdorDD01ARoAAAAABwC69Ox38r2FFUoDSbLjxpNKSVFb/zjDNA6XRc9QnSlREy1WrS00/P1vbF/aJ+BotUoHQ60okT+R8/AxgiCwAAAKC38Gq3pa1b04+PCkaKBCjttlsIG+P+vbEhHT/eWySurEj79yefw9rBXV2ytPAsL7sAZts29xoEf87P+z3+7NnxzFyZRLPYdlO2dnvzzkS+O15FOXtW+sAH3J8f+Ug59zeFCFAAAAAA9Er/Wy2/ACWufaA/BJGyLeiCnXjW191vwvtbPNpt9/mdO+Mf32gMtoUEg2R9QpDl5eiKlfl56eKLpcsuk+ZiivhrNf8qmVnXbI5/i+lpEP4ZzFt9cv/90oc+JH3/90t/8Rfu/UnaMnqGEaAAAAAA2FyB4iPqOGvdefoXX1kClFbLLd5OnYpuy1hZSQ5Q4mZhbGykb8/cbse3+3Q60uKiq5rYv9+FKf26XbYszoLqk3KEf7awXzZOAAAgAElEQVSyBiitlvQnfyLdd5/08z8v3XCDdO+90rlzbstoDGAGCgAAADDrOp1e5YZv4BHXqhKuLMgSoJw/77apjZtpsbqaPHg03L4Td09RarX0Y9ptF+4Ec1kC587lb52YRT6vNTaL+r6PqrbydfKk9Iu/6L53f/3XXXgiSQcOMMcnAQEKAAAAMOv6F14+izBr44OM/mAhmGviK23ga9LWt1HzT3zPK2Vb1Nfr0pEjbl5ErbZ5S91Z0Wi4533+fLbHWUuAksf73jdY5ZS3AuXhh114cvfd0s/9nLR7d+9rl19OgJIgtYXHGLND0hckbb9w/F9Za/9fY8yLJH1M0mWSHpD0I9bapjHmBZI+KmmvpHlJv2Ct/ZthPQEAAAAABfVvfepTSZF0TDhAKdvKymALTXDduFDHJ5jJsxXu4qL7mAXB9sz1uns9g9d6bk7auzd+NkxYvc6g3axWV13V08KCdMUVvc/nnYHyxS9K73yn9Ja3DH7t8stdMIhIPt/lDUl3W2tvlXSbpDcbY14r6VckfcBae52kRUnvvnD8f5H0l9ba2yX9oKTfLf+2AQAAAJSmf+HlE3okLYCHHaCsr0cvFJMCkHY7+Z7r9eTWoFlnrXTsmFvAr69vfq263WwVJVSfZHf4sPszPDsmb4CytORadaLQwpMoNUCxTlAnt/XCh5V0t6S/uvD5j0p6e/AQSUEkfIkkNpIGAAAAqqzMCpR2O/s8layihpCmVZAkVaHEtQXBWV9PDqCyvH681tnFBSh5W3iWllzVUBQqUBJ51VkZY+aNMQ9JOiPps5IOS1qy1gbv2DFJV134+/8n6YeNMcck/Y2knyr1jgEAAACUq3/h1emkzy1Ja8EIqlCGFaCEtwtOmn8SvqcoVEUkSws9fHfV6XbT3ycMOnzYbaGdVoHSH4QmWV5ODlCoQInlFaBYazvW2tskXS3p1ZJuTDj8XZL+yFp7taTvk/QnxpiB6xhjfswYc9AYc/AsCRcAAAAwPuHfXKf9JjstGBl2gNJsbq4o2dhID33iKlCazezbv86atACl2fRbvIfbf+Dn8GHpttuSA5T+nbSSdLsugLzkkuiv793rruOzc9UMyrQLj7V2SdLnJL1O0l5jTDCE9mpJxy/8/d2S/vLC8V+VtEPS/ohzfdhae6e19s4Dcf1XAAAAAIar0xn8TXZa8JFWgRIspocZTPRXofgMgI0LUGgpSdZu+1WN+LyOVPpkt7zsvr+vuy45QPH9WavVpO3bpa1bo78+Py/t3++2N8aA1ADFGHPAGLP3wt8vkvQmSf8sF6S848Jh/07SJy78/TlJ333h+JfJBSiUmAAAAABVFLXwSgtQxl2BIrnFZFB14hOgtNvR98OiPplvwOTTxkNYld3hw9JLXuIqRsKvcbfbqzrJMv8krvokQBtPrNRtjCU9X9JHjTHzcoHLX1prP2WMeVzSx4wx/1XSNyT94YXjf1bSR4wxPyM3UPb/sjbL5u8AAAAARiZq4ZW2GBv3DJTgHmo1adeu9G2K++9rS98SqNNhJkca39CjVnOBljHRX+e1zufpp12Asnt39HvRbkvbtpUzQDbAINlYqQGKtfYRSbdHfP5puXko4c8/LumuUu4OAAAAwHBFza4oWoHS7frNJSlqZUWam/O/zsaGC1wCVJ+k8w1Qgu2Md++O/jqvdT5PPSW9/vXSnj2Dw5OlXpjpG6AsL6dXoLCVcaxMM1AAAAAATJk8LTxpFSiSX1tNUbWa/w4w0mClCov6ZPV6tiqipLCF1zqfw4elF7/YBShR3+vBz6LvDjy+FSgEKJF8WngAAAAATKusAUr/3IUko5h3Ya37jbqv/p1FrGVRnybre0iAUq7FRReMXHGF+5mMapPKU4FCC09uVKAAAAAAsyzqN9dJizGf6hPJfy7JKPUPkq3XZ3dLXd+Wp6wBysZG/PdTFb8fqi6Yf2KM2zVn+/bByq6sAYrPEFlaeGIRoAAAAACzqtuNDkSSqkx8A5SqCqpQZrUiotWSjhxJP67TydeGFRW6zOprXVTQvhPYvXuwjafddoGYb6uVTwXKvn3uPeuv2IIkAhQAAABgdiX91jpuQTbMnXVGIaiEmNVF/fHjLuRIa30K2kWymrUA5ctflr7xjeGc+6mnXAVKIGqQbKfjfo593yufCpS5Oemyy6Rz57Ld7wwgQAEAAABmVdLgybigZNIrUII2E9+hm9Pk/PlewHH6dPKiO+8Mm6jgZRTzcMbl61+X7r13OOcOWngCUYNk223/9h3JrwJFYpBsDAIUAAAAYFYlLbzivjbpFSiNxnRXRMRpNqVTpzb/e3Ex/vi8oUe49afZzLbAnzSnTkmHDpU/T+f8efezduBA73NRAUpQgeIjGLqcVoEiMUg2BgEKAAAAUAXd7uhnDuRp4Zn0CpR2O9vOPdPi+PHBRf6ZM9EL/6IVOv3hyzRXn1grnTzpWl6ee87/cf/8z4OtOGGHD/cGyAb27Bl8PbMEKOvr0pYtbhhtGgbJRiJAAQAAAKrg7Nl8QzuLyNPCM+kVKNLste8sLERX3bTb0XMuwlUOWfUv8qe52mdtzQUcr3qV9Oijfo+xVvqt35I+/vHk48LzT6TiFSiLi37VJxItPDEIUAAAAIBxq9ddVcSot3rN08Iz6RUoVdfpuICnVnNVCufPu4Vs3uqkRsPNO4lz7txgKFa0aqRe733/THOAcvKk9LznSbfc4h+gHD/ufs6/8IXkoCo8/0QqHqD4zj+RCFBiEKAAAAAA42Rtb4E7yhaetK1Pp7kCpaoWFlx7x5NPSs8849pCTpxwC9k88yislY4dS57P0e1uPre15YQea2suKJjm75fTp12AcvPN7n3zCRcPHpRe+1rpzjulv//76GOs7bXw9Ivbhce3omppKVuAwgyUAQQoAAAAwDgtLPQWQM1m+cMo46QtuqZ1BkqVJc1mWV7O3np07pyrBklz/nzv3LVaOd+Da2vTPf9E6lWgXHKJmxly+HD6Yw4elF75Sultb5M+85no6pGFBffnZZdt/nzUDBTJP3jNUoGyd6/7Xhj1XKaKI0ABAAAAxqXRGNwJZVQLlrSy/253cCEd9TmUo9VKnoFjrQs6fDUa/i0Y/VVQZYUesxCgnDrlAhTJr41ndVV69ll37Atf6D6++MXB46IGyErRLTxZLC35z0CZm5P276cKJYQABQAAABiX06fd4rVfVQKUqGOoPhken4Xx4qL/e3Dq1OD3VpLlZRfglBV6dDoEKGHf+IZr99m2zf37bW+TPvnJwffp8GHpxS8efPzu3cUClCwVKBJtPBEIUAAAAIA0wwgOFhejh8aOKkDxaQcJt/FM8zyLcfPZWrnTGaxYirK2lm+hffLk6AcZT7JTp6TnP9/9/aabpG99K/nn6uBBN/sk8IpXuEqPhx7afNzhw9J11w0+/uKLR1eBIrGVcQQCFAAAACDN0lK552u1orePlUa3gPWpQAkHJlSgDEe77T+4dWEhubLEWrewz8NnXgqc9XUXdgYVHTt3StdcI33zm9HHt9vSww+7+ScBY1wVyic+0ftc3ABZSdq+3X09b8iapwKFAGUTAhQAAAAgzeqq/1ahPs6ciV8EN5vZWi/yytPCQwXKcIR3VknSaiUHenGVTSjXqVMuYOifU5LUxvPEE9IVV0j79m3+/F13ua2Nn3nG/fvsWWnLFunSSwfPYUyxOShZK1Bo4RlAgAIAAAAksdaFGmXNc6jXk6sNgusNk7VUoFRJlgBF6u3SEtbpUDEwKqdP99p3ArfcIj32WPTx4fadwNat0lvf6mahSPHzTwJ556BYm70ChRaeAQQoAAAAQJL+7V3L4FMdMOwKAt9qGmagDF+W9p3AxkZ0oHf2LO/RqARbGPe74QbpyJHoVqgHHtjcvtPvTW+SHnzQBWNx808CeStQ6nU3b2XHDv/HUIEygAAFAAAASBIEKOvr5VRg+MwvGPYg2bwBChUo5VtdzdeyFZ6h02jEV6agfP078AS2b3fhx+OPb/78iRMu9IqrLNm1S3rDG6RPfzp+/kkg7yDZrO07kqtWqdVGN9h6AhCgAAAAAEn6Fw9lVKFUoQLFt0WIGSjDl7V9J7C2trnSIWpLbAxPVIAiRc9BOXhQuuOOzfNSwt76Vunee6Wnnkpu4clbgZK1fUdyFSv791OF0ocABQAAAEjSHzYUDVB855tUpQLF2s1VJ1SglKvTKTZbJ6hCWVvLH8Sg5+mnpfvv9zs2LkC5+ebBAOWBB6Lnn/S7/HLp1ltdi0140Gy/vDNQ8lSgBPdFgPJtBCgAAABAknCAUuS3/L7ByLAHyWbZUai/6oQKlHLlbd8JrKy475O82xZjs499bPOWwnEaDffaX3bZ4Neuu84NXg0CrVrNteW84hXp533nO6W3vz35mFFWoEjpWxk/+6z0gQ9kP++EIkABAAAA4oSDjG43ekCkryyVJcNs48kSzgShSbdLi0jZilaNWOsWsGxbXNy5c9I3v+m2E04LCs+ccTvUzM8Pfm3LFunGG6VDh9y/H3pIuukmNx8lzdVXu1aeJHkDlCIVKEkByqc+ldyaNGUIUAAAAIA4UUFDkZaLLAHKsNp4fLcwDgTH0r5Trm63nK2xh73l9az4h3+Q/sW/cIHBs88mH3vq1OAWxv1uuUV65BH394MH43ffyWPUFShJWxkvLUn33Sf96I9mP++EIkABAAAA4kSFGEUWvVkqBYYVoGQ9b/Db+DLbd7rd8s41qVZXeR3CvvxlFziMWqfjBri+6U3S9ddLTz6ZfHzUFsb9brlFeuwxd94HHyw3QLn44nz/DVpcLH8Gyt/9nXTXXdKll2Y/74QiQAEAAADiRP12v93OH25UoYUn6+IrCE7KqkBptdxvw2cdQ18HfeUr0sMPj/66Dz7oKi1e+ELphhvSA5S4AbKBF77QBWRf/ao77/795d3r7t35vneWl5OH08aJa+FpNqW///v0lqMpQ4ACAAAAxIlrj8jzG+BmM9sMkW43W6uNr6zl/8E9lFWB0mi434bPsm43XxvGtHvuOWlhYfTX/exnpe/5Hvf36693s1CSpAUoc3NuN54//dNyq0+k0c9AueQSN/cpHP5+6UvSi17k5rbMEAIUAAAAIE5cxUie7YzzVK2U3cbTaGQPZcquQGk0pPX14W/VXGVra7TvhDUaLpgItmYelbNnXWBy113u31de6b4/l5biH5MWoEguQDl7Nn374qx27XLVaVl/HvPOQJmbcxU0/W081rrhsTNWfSIRoAAAAADRkoatbmxkr8jIExiU3caT5zfXZc9ACV6HWa5CoYVp0LFjrrpi1AFKMDw22CVnbk566Uvjq1DabVclc+BA8nlvu82FLC95Sbn3OzfnQpQsVXD1uvvv2Y4d+a4ZHiQbzHe57bZ855tgBCgAAABAlLTdTbJWoeQJQ8qu0sgToFjrFktlVqBI7jf8s7gt8unTBChRjhxxVRu12nBa16J0OtI//qP0vd+7+fNJg2TPnnVDU7duTT73854n/c7vuMCjbFnbeILqk7zbDYfnoATVJzO0fXGAAAUAAACIkhZeZJ2DMu4WnjztO4FWq/wKlHZ79gapnjwZv6PJrDtyxM3UuPTS0c1BeeABV13xghds/nxSgJK2hfEoZA1Q8s4/CfTvxHPihHttvuu78p9vghGgAAAAAFHSKlDW1/3nWLTb+So42u3ygosiQ0vz3n/Uefqfz7DaeLpd6ejRalW4nDgxngGpk+K551yQcdllo2vj+exn3dbFYS99qfT009E/eydPSldcMfx7S7JnT7bwMe/8k0B/C8/f/I0buBu0PM0YAhQAAAAgSlr1h7UuRCnjXMN6bL88OwcFygpyws9lbS09qMqq23XVDMvL1djpxlo33+P8+XHfSbU995zb/nf//tEEKGfOuEqK7/iOwa/t2uVCgyNHBr92+vTsVqDUatIXviC9+c35zzXhCFAAAACAKD4Le99QYtwBSrNZLKjIugVznKjnkrTbSVbdrluIB/Npxj2oNghPynyO02h52X2PXXaZ+xhFpc6990qvf318JUVcG8/Jk+k78Azbnj3ZAtGiFSjBDJR775XuuMO9RzOKAAUAAAAI63b95oXUan7BQpHddMrYiadoJUZZuwFFBSiLi+WEM0F40r+wXFsb3UDSMGtdGxEDY9MF1SfGjKYCJRgeG9W+E4gLUHy2MB62UVeg7N3rdvL5P/9H+v7vz3+eKUCAAgAAAIT5Vmt0On6/CR53BUqR9p2y7iHuPK1W9h2NwoKwIvw8rR1fgLGyMntDcvM6cqQ3yHX//uFXoBw86KoqwsNj+91ww+BWxp2Oa2WpwgyUrAFKkQqUINi6/HLpuuvyn2cKEKAAAAAAYVnaXdIW6L7VLHFarWIDXJvN4gFIWcNY4ypZirTaWOsqGOIWlONq4yE88RcMkJXcQn2YOxWtrkqf+ERy9YkkXXWVO7b/5/v8eWn37vEPUM0zRLZIBYokveQl0tvfXuwcU4AABQAAALPFJ8zIEjisrycHLmVUbxQ5R9Hqk7J0OvGDaFdW8g+pPXEi+bfxjYb/sN8TJ8oJPrrdagywnRRBC480vAoUa6UvflF673vddsl33ZV8/Nyc242nvwqlClsYS9lnoBStQJHc6/aqVxU7xxTYMu4bAAAAAEZqaUm6+OLk3yJnHbi6tOTK26OUFaDs3JnvsVVZyCe9Dta613D//uzn9Xl+i4vpr9/amqswOH9e2rfPLZTncv6+uVbz3+J61gVbTgcVKLt3u5CzXpcuuqica5w8KX34wy4c+4VfcMGIjxtucHNQXv3q3nnG3b4jZW/hKTpEFt9GBQoAAABmS6OR3taRNfRYWYlfMJcxgNV3WG1YGe07ZUl7HfK02rRafpUrSe+P5F7bkyc338tTT/lXroQxONbf6dMuNNm1y/07mLdRRhVKqyX91V9J73+/dPvt0q/+qn94Ig0Okq3CFsZStgCl0XA/I3kDWGxCgAIAAIDZsrHhFh9xC+9uN3s7SVLLRhkBxvq6W7xlVZX2HSm9qqfRyD5Mtl73O67TSW7NWVgYfJ+aTemZZ9zrniW8srY6VT+ToL99J3DZZcV34jl/XvrP/9kFIL/6q9Lb3ibNz2c7x/XXS4cP92YQVWELY8kFTmtrft+XwQ48xgz/vmYAAQoAAABmR6vlwo6gZSRK1vadQNT5rM1/vrCVlewhSpUCFJ8gKev8Ed8ARYqvcGm14oeWWuu+9vTT/oN8a7ViQ39nTf8OPIEytjL+whdcAPL+98e316XZtcvdy5Ej7t9V2MJYkrZulbZt86uQon2nVAQoAAAAmB39i/ilpei2jrwVI43GYJtKs1neDjaSWwydOeN3bKtVTvtQWXzuJWvLTJYApVaLDrNOn04PPOp1V9Hgg/adbOIqUIq28Hz969J3fmfxyougjcda971ShRkokn8bT1CBglIQoAAAAGB29Icj3W70YrdIxUi4CmUY80eWltK3eU2qsBkH362cNzayDV/NGhCFX5Nazf91WlhID1po38kuqgLlwIFiFSiLi25HpZtuKnZvkhsk+81vuu+Tbdt6s1rGLUuAQgVKaQhQAAAAMDvCgcbS0mCFSJHQY3V18yJ7WBUgi4vRv6FvNFyFytNP5xvKOiy+r6m1/lUozWb2WTX9YYm1riXDV7udXoVSq+XfjnlSFdltqNFwQcmVV27+fNEZKPff74bGbt2a/xyBoAKlKlsYB3bv9gtQlpepQCkR2xgDAABgdoQDjVbLzQnZs6f3uSIVKNa6OR779rl/D3MHnIUF155wySXumisr1dlxJyxLkLS+7haHabK07wSaTfd+797tAqas51hYcIv7uO2Ns85wmST1unTs2ODHmTPSL/9ytt1tAsePu5ki4aCj6AyUr39d+u7vzv/4fldf7d7Xb36zOu07UrYKlHBAhdyoQAEAAMBs6HSiqwP6KzXy7MAT1l/lMOxA49w5V21y9mw518q6C46vLKGUbwVK3uqepSX3HvvOkumXVoUyrQHKk09K73mP9Pu/Lz38sHTRRdIb3+gGtL71rdLBg/nO++yzg/NPpN42xnnmB9VqLuy4/fZ89xQ2N+fCoS9+sVoVKL4BCkNkS0UFCgAAAGZDXMCwseF+u37RReWEEK2WCwG2bi3W3uCrzCG1i4vDmfGQJeyo191zShv+mXXgbGBlxZ0/b1B27px06aWDVSjT3L7zla9I99wjvfOdg1975Sul//k/pXe9K/t5n3tucP6J5H4W5+cHq8N8fOMbbvbJRRdlv584118vffzj7jWoiosvzj9E1phy/7sxQ6hAAQAAwGxICkeCqoKythxeWqrWDjg+Wq3hDUDNEkx1On7H531944YH+2q3o+fLTGv1ibVupsidd0Z//cYbXStPnu+dqB14AkEVSlZf/7r06ldnf1yS6693f1ZhC+NAlhko4QqUbdvKmQ8zgwhQAAAAMBuSFuXBFrdltdysrQ2vHWZYGg0XXpQd/HS72YOptOqS4F7H5ezZweqiaQ1Qjh934dqLXhT99a1bpZe9THrkkeznjtqBJ5BnkGyrJT30UHzYk9f117uqjSoFKEW2Md6yRdq5czj3NeUIUAAAADAb0oKBxcXyKlCkyVtQB69P3taYOHle07TwKc8A2TK125tn3ayv+23TPIkOHnSBRFJL1W23ueAii5UV972xf3/01/MMkn30UVfRUvbMj927pV/7Ndc2UxU+AUqz6T7CQ5m3bJF27BjevU0xAhQAAABMP2vTF/IrK5PXdlOm4LmXXTmT5zVNC3HGHaBIrgolmCMxrNanKrj/fulVr0o+JghQsszVCKpP4oKZPAHKffeV374TiKvAGZc9e1ylW5LlZRf6hF/jLVvKnREzQwhQAAAAMP18WnOsHc3Q16oKXqOyK1DytEW1WsmBVxUClFarNwulyEyVKltednNKXv7y5OOuvNINfT12zP/ccQNkA1lnoHQ6LuwZVoBSNXv2pFe5xe3AQ4CSGwEKAAAApt+wtxOedNb2XqO08CIsLXTK+9rHBTnWVqdS6OxZF+aU2fpVJQ8+KN1yixs6msQY6dZbs7XxJA2QlbLPQPnWt1y1xajnlMzNpe8YNQw+LTxR808kF6DMz6e/rxhAgAIAAIDpR4CSrNXaHIT4VqG0227IaJK8r31clUmjUZ1KoVYrW9XFpAnmn/jIOgflyJHkACVrC88w23eSbN06nnkiO3a4n4Okn6+lpegKlGAHHqpQMiNAAQAAwPSrSsVCVYVfH98AZWXFtQnE/SbcZ/ZMnLh7KLvFqKhpDedaLbezzitf6Xf8K14hPfGE3+vR7UpHjya38Fx2mdte3Ccss9ZtX/ya1/jda5nGtaONMelzUJaX4ytQJAKUHAhQAAAAMP2mtcWiLOEAxXeQbDCD4cSJ6IVus5ltsGi/ej16q2LCsNF47DHpmmuiF+BRdu1yFSVPPJF+7JkzbmeYXbvij9m2zQUTPvNljh511VDjGPQ6znkiaW08cRUoBCi5EaAAAABgujWb1Wn5qKpw1UCj4RakSdrtXtDSarlFcVjRsCOqjacKA2RnwcGD6bvvhPm28QQ78KTxHSQbtO+MYxbJuCpQpHwBijEEKAUQoAAAAGC6TWuLRZmigo60VpmVlc3VJQsLg+FG0dc+XAlTpQGy08zabPNPAr4BStoOPIH9+92g3jTjmn8iuTBi27ZeKDFKaTvxRO3CMz/f+/vc3Hjmt0wwAhQAAABMNwKUZHFzSnwClPB5TpzYHKoUfe3D97Cxkb8lCP6efdYFAldfne1xL3mJm1ty/nzycWkDZAM+FSjnzrnqp5tu8r/PMgXByTiqUHwqUMItWMEA2QABSiYEKAAAALMmaq7ENCNASdZoRIcSSXNQ+tt3+tXrmxfPRV/7en3zvdG+MxpB9UnWlpj5ebftcVoVStoWxgGfrYzvu88Nuu2vrBilIJAYdoAS9fx8hsiGK1DClTLjaj+aUAQoAAAAs+bkydkaqkrLR7K412djI352zOpqfCXI6dO94bFFA5Rud/P9EaCMxv33Z2/fCaS18fzDP7j39aqr0s/ls5XxONt3pNHNE4ka5ptUgXL8uGvR2b178+fDAQoVKJkQoAAAAMwSa90i9Pjx2Ris2m7PXsVNVnEhh7XxbTxJcxe6XenUqWI78PTrvwcClOE7f96FYC97Wb7H33ab2/446ufukUekP/9z6Rd/0W9mSFoLz/KydPiwu+a49Acowxpia4y0b9/g53fvjg9QPvlJ6S1vcSFKv/DrPsz7nkIEKAAAALMkWNS2Wq4SpUparfSdX7KifSddUoVOVIDS6SS3DUguYPEZ/ukjuIdul/dzFA4edIFE3qGo+/e7aolnntn8+WPHpN/8Tel975OuvNLvXGktPPffL916q7R9e757Lap/R5thDmTdvTv6OV58cXSYubgofe1r0pvfPPi18PtqDFUoGRCgAAAAzJL+BWitll4ePyrNpnT0qJuNUOYimQV3uqwBSnj3nThLS/nvqV8wayU8DwXDkWf74rBwG8/ysvTLvyz9yI9IL3+5/3kuvdR9v8VVkX3ta9LrXlfsXosIzyUZ1jyRPXtcQBO+XtwMlE99Snr9613AEhYVjLGdsbfUAMUYs8MYc58x5mFjzCFjzC9d+PyLjDFfN8Y8ZYz5C2PMtr7HvNMY8/iF4/9smE8AAACgkqq60Asvls+fT97FYRQaDReetNvu47nn0iscspwb8TodV/kTZ3198Hs5qX1nGNptF7Axy2b4Gg3p8cel228vdp7+AKXZlH7lV6Tv/E7pjW/Mdp75eRcCRO3qU6tJTzwh3XFHsXstIryjzTADFGkw/IiagVKruTkzP/AD0eeKClCoQPHmU4HSkHS3tfZWSbdJerMx5rWSfkXSB6y110lalPRuSTLGvFTS+yXdZa19uaT3DuXOAQAAqqxer+aMkahF6OnT4wsaGoU+a4YAACAASURBVA1X2t//G+ZgO9zFxeLnL2vRXcX3sgxp73t4iKtP+84wrK+nb6s8zRqN8ip6kjzyiHTdddKuXcXOc9NNroWnVpN++7ddW88P/mC+cx04EF0pd//90s03j7d6ImqeSJ7HJdm5sxfU+AQon/2sC8Auvzz6fOHQJ7gGvKQGKNYJ/iu59cKHlXS3pL+68PmPSnr7hb//35J+x1q7eOHxZ0q9YwAAgElQxd+Yx+2K0u26wGLUw1Y3NlzlSdx1z56VzpzJX83T7SZXV2RR1jyPqvH5Hu0PLnzbd8q2vl69n6dRabddBcd//+/Dv1aR3Xf6bd8uXX+9u+ezZ6Wf+InBYaa+4uagfO1r0mtfW+w+iwoHGtu2RQcUYQcO+Ict/W04URUv9Xrvv6GtlvTpT0v33ON/z5J7v/K+PzPG61UyxswbYx6SdEbSZyUdlrRkrQ2mfB2TFOxDdb2k640xXzbGfM0YEzG5BgAAYMq1WtVb8CXtitJquZ1TRqVed5UnaZUdS0su3MlTAVJWVU2z6RZw01iF4vMahQOUcVhdnc12LGulj3zEtbIsLLjAcVi6XemBB8oJUCTXWnPunPQLv1BsyGvUTjz1uvTYY+Xda15RYURaNcfcnLR3r3tePpIClPl5d72gKuwLX5Be8ALpRS+KPtf8fHRQwiBZb14BirW2Y629TdLVkl4t6caEw7dIeqmkN0h6l6SPGGP2hg8yxvyYMeagMebg2WlN9AEAwOyqYgVK2v3UaqNZpK6v+4UngVpNevZZ19KTJcQo67msrrqFbDDMdJr4fI8Gz3tc7TtSeZVEk+Z//2+3Te/73ie94Q3SP/7j8K719NOuded5zyvnfG95i/Trv+525CkiqgLlwQelG25wu9OMU54AZe/e3myXtGqVHTtcVUvS9S6+2P03qtuV/vqvpbe/ffCYQHgIbT8GyXrJVKdjrV2S9DlJr5O01xgTvINXSzp+4e/HJH3SWtuy1j4j6Um5QCV8rg9ba++01t554MCB3E8AAACgkqpYgeITKAx7zkKr5SpKsraBtNuuFeCZZ9xASZ8gpawAJai6GFd4MEw+r1EwxDUIkjAaX/6y9Hd/J73//W5x+8Y3Sp//fPlbfQceeEB65SvLO9+WLcVnqUiuUiMcoFShfUfKt6PNpZe6P41x4VCSYHhs0vWCOSgHD7pr33xztvsNEKB48dmF50BQQWKMuUjSmyT9s1yQ8o4Lh/07SZ+48Pe/lqs+kTFmv1xLz9Ol3jUAAEDVtVq9XWWqwifQCX6TOQzBrJUi5+903GLq6afdn0Hvf7vtnt/qqgtYzpwpJ/Bot3sVGNMWoATfoz5qtfG178yiJ56Q/uAPXHgSLLKvvNJ9PPDAcK5ZZvtOmcItPI2G2+Hn1a8e3z0F4gIUY6KP37lzc6vMvn3JVSHhbYijrrd7t/vvXlB9EndtKbnihQDFi8/43+dL+qgxZl4ucPlLa+2njDGPS/qYMea/SvqGpD+8cPzfSfreC1/vSPo5a+1C1IkBAACmUqvV+039xsb4y8yl+AGyYd2uWyjvHejALq7M3X66XReUBDv1DKsyoj80aDRcJUZ/Sf0ky/JerK2Nf7vrWXHypPRrvyb99E9L1167+Wt33+3aeF7zmnKvubjofj5vuKHc85Yh3MLz8MNuxkfR1qAyRAUSxrgwImrXqKD6JDA/70KUqCG5W7cOhhpR19uzxw3/XV5O/75IqkDZvt3dz6iHiU+Y1ADFWvuIpIGNwK21T8vNQwl/3kp634UPAACA2dM/r6EqAUrSANmwpaXyA5TFxeEswIfdUhKuulhbG1wETaosAcry8vDuAz0rK9J/+29uy9/bB5Zg0uteJ/3RH7mfp337yrvuAw9It96abXvdUbnkEjc0ttFwi/yvfrUa7TtS/Ou1c+dggLJlS3Toc+mlrsIm/N+ycPWJFB+gfPrT0nvek1zNknS/gR07pnPWU4nYqwgAAKBs4QClCrLcR7PpFixlWV+fzG2AO53BxcQ0LS6q8r2Jnt/9XVdF8KY3RX/9ootcePD5z5d73bLnn5Rpbq4XMrRaboBs2RU4ee8rbuvfqEGy+/ZFt9ds2xYdloTnn0ju8eEQZM8e9/GGN6TecmqAQhtPKgIUAACAsjWbvb9XZZGa9T7KGibbbruWhEm0sjL4W2ECFAxLoyE9+qj0jnckH3f33dK995ZXfdVsui2BoypeqiKYg/Loo9JVV6UPXx2FrANZkyqGws8naQBv+LqveIX07nf7bRWdtusPAUoqAhQAAICy9VegdLubA5VxyTp7ZG3Nrxc+aVCutW5o7KT21Ee1HLXbxatzut1qbMs7ii2r4e/JJ6UXvjB9ERvMKfnmN8u57qFD0gteEF0FURXBHJSq7L4jJQcoW7duDisuvjh5dtLOnZurVnbvjh8GG77uS18q3XVX+v1K6S0+BCipKtjkBgAAMOHCgcnGxngHj/oOkA0/Znk5ed5HpyMdPerCgPl59xy3b+/9ubw8uVUO3W78rjtra8UWGktLLlgKXrMdO9zrtX27W0SlLXLK0GwOb7cl5PPYY9LLX55+nDHSd3+3GyZ7443Fr1vl9p3A/v1uZ63775f+9b8e9904adUcO3f2Zgf5zE3av1967jn396Qwq8icmrTHbtvmjqnS7nEVQwUKAABA2cLVBeMOEbIMkO2XNDg0qC4Jnmun4yozlpbcQufo0cne9jZpO+ei2xkHjw9es8VF6dQp6cgR6dixYuf2Ne7vSQx67DHp5pv9jv2u73LVGEWroayt7vbF/S67TPrSl1zIcMUV474bJy2MCCpKtm3zGyS+Z487dm4u+fi04CaJT/jSv82yryL3NGEIUAAAAMrUbg+GFeNerOa9fqsVP/Pj1KlyB81WTVL4s76ev3rD2uQ5Kquroxm4S/tOtWxsSM8+619Rsm+f9LKXuR1p4libHpwePeqOueYa71sdi/37XWBblfYdyT9A8d21yxj3PHfvjh9OK+UPK7ZsiW8L6hc1ADfJ1q3Ts7W7BwIUAACAMkXNO2k0/CpAms3hzEspEuBEDZNdWBjOlsRV0e0mP7+0ECTJ+nr6TJgzZ4Y/rHbcoR42e+IJ6UUv8hsEGgjaeMKCqpL3vlf64AeT/9sTtO/4LKzHaf9+9+ckBSg7drhjsmw3vXdv+vF5W3h8g5esAUrW4yccAQoAAECZooaD+s4gOXfO/Rb6yBEXUpQVphRZLNdqm/vhV1bcvU2ztbX0CpO8bTw+j7PWtfL4zCFotfJ9n1CBUi1Z2ncCd9zhdrg6caL3uaefln7pl6SPflT6wR90/07a8ngS2nck6fnPd7NPrrpq3HfSkxZkGCM973nZZhrNzUVvX5zlukUft3NntkAtbregKcUQWQAAgDLF7a5Sryf3lrfbvcV1o+E+FhZcafSePe63kkll3XGsLR7ELC253wDX69Lp08XONQl8ZrcMM0CR3PfR8eNuV5akcx075hY7117rX72QZ6gwhuuxx6Qf/uFsj9myRXr966XPfU76l/9S+vM/lx56SHrnO6Xv+R63cH/+812gcuONbjHfb3XVhbU+g2vHbft26d/+23HfxWY+gcTeveO5bhTfIGduzg3JXl/3O54KFAAAAOQWF1akVYFEtcoE51tYkM6fz3c/vu1DSVZW3H2cOFH8XFVw5szmAbj9rPVrT2o0sgdTWbdAjpuHYq17Ds8+687ZaknPPON37na7N/cC1VCvu/fk+uuzP/buu6W//VvpZ3/WhZy//dsuTAkWy9deK73jHdJv/uZgRdNDD7nwpErzK+bnq99OFCiyG04ReWegZHmcb1XJ/Hy+obMTjAAFAACgTHEVKEkBSrBlcJKlpXyDS8uoNGi33faaabM7JsXqqgukvvUtF0T0v661mv/zzDqnJE/VSngeSqvlgpMzZzYf1267zyddY21Neuqpyd4daRo9/rj0kpfkCzKuuUb69/9e+o3fkN71rujttb/v+1wV21/8xebPHzxYve2Lt20bzTbeZRhXgGJMvmtneYxvgDJj1ScSAQoAAEC54gKUVit+Yb66mr5o73bjq1SSlDUsNO+uM1XTavUqNbpdF0Q8+aQLVHyCrH5ZA5E8AUr/PJS1Nenw4fjgptNxLRnhgKTbdbMygooVVEue+Sf97r7bbfMbxxjpJ39S+qd/kh591H2u03EVKHfckf+6w7B9+2Rsieu7o82w5HmNsgQoUUFcFAIUAAAA5NZuJwcNcWGGbzCyuJg9yGC3lc2i2nPabdfS89RT2XYXGkUFitRr0fEJQKx17SCLi+7f9boLXaZ98O8kO3SoWIDi45JLpB//cem3fst9jz/xhHT55cnByzhs2zYZAcq473HYFSjz834hygwGKAyRBQAAKEtc9UlgY2OwNHpjwz/k6HRchYTvtphlDJCdNkkhRtZ2p2Cmic9CY2OjWPVHlnuz1g2gXVtz1SjMO6muWs29Vy996fCvdfvt0nd8h/ShD0lXXFG99h3JVaBMQpXUuNuM8gQoWUOfnTuT5yoZ41+pMkWoQAEAANU3KSGAT4ASlrUtZ3HRf0FcxgDZadLt5q8CieN7vrKv62N5mfe/6h5/3A2PHVVFww/9kGtb+9u/reb2xdu3j2+2SBbjvsdhV6BI6XNQLroo385wE272njEAAJg8tdpkbLuaFvSEA5ROJ1vLiOR+O+s7BJT2nc3W18uf5VLlAAXZfexjo/1vTdH5J1lt3Sq9971u950Xv3h01/VFC89wrj83lz3sSGvP8R00O2UIUAAAQPVtbLjFb9WlVaB0OpuPydteEQw8TTMJodMoZQ2rfKyvp7/O3W72eSkYvcVF6eMfd6FGGXx2cxrF/JOwq6+W/st/qV71wNat7p7GHU74GHcFStbXKG/Fyvbt8V+fwfknEgEKAACYBPV6ci92Vfi0GvVXheTZVUdyIYxPGEAFymbD2L43mDeSpFajlWYSHDrk/gx2qinqf/wP6aMfjf/66qp06pTbwhi9bZzHHU74GPc9Zr1+3vtNqjKZwfknEgEKAADV0W7PRsVAp5Ntpkmr1RvWWXVpFShSL9So1fyOj3P+fPp1ZuH7ydfGRrHXO8n6evIuN7TvDI+16T8Lvg4dckNWH3mk+LnqdenBB6WvfEW6777oYx5/XLrhhvEvxqsiqHaYhNdj3PeY9fp5q3riqkx27Bj/azAmBCgAAFRBt+t+i728PO47Gb6NjWztDEFwkjV4GbVOx2++RhCg5K0+CTSb0QvzVks6eVJ67rli5582w2jf6Xf6dPz3JwHK8Dz5pPRTP+UGoxb12GPSPfdIZ88W/2/xgw+6cOR975N+7/ei72/U80+qrr8CxZjx3kuacbcZZX2N8oYdcQHKjLbvSAQoAACMX9AC0GjMxkKr0cg2z6S/8qTKVSi+1Q0bG26hXcZMjP6qh07HLfyefXb4YcEkGvZrEoSgYc0mlUDD9Nxzbm7G7/9+sTapxUXX4vXiF0s33VS8jeerX5Ve9zoXotxzj/QbvzH43wgClM36522MO6BIM+5tjI3Jdg95A5S4ob4EKAAAYCysddUCQTDQbk//3IpgIKzvYmdSAhTf6hhry/ltudQL3c6fl555JtsWx7Ok3R7NEOJabbCdZBZC0XE6dkz6V//KVYx8/vP5z3PokAtO5uakV7yiWIDSaEgPPyy96lXu3z/wA9LFF0t/9me9Y5aXpXPnqrkTzrj0ByhVbg+Zmxt/gCJlC5mK3G/UHBQCFAAAMBZnzgwusKZ9wdVouEW+TxgSbtupcoCSZb5GmYv5EyfcQqzs7XmnySh/psKtPOy+M1xHj0ovfKH0H/+j9Md/nL/15rHH3Na+knTLLcXmoDz0kAtGLrnE/XtuzrUZfeUr0v33u88dOiS97GXVWIhXgTGbA4EqV6BUJdzJ8hoVeT3DYcmWLb12qxlEgAIAwLicOxf9P/vTHKD0b+PrEyKEA5NgoGwVVXk+y6wbZUtTp+OqyiQXFE7zz3MVHDsmXXON28nmDW+Q/vAP852nfzvha65xP8+nTuU719e+5tp3+u3ZI/3Mz0gf+pBrtaN9Z7Nt2zbP9CBASZflPorcc7gCJWlnnhlAgAIAwDgsLsbvHNFsTu9ivH8WRJ4Axfdx4zCsHV5QzDhCjNVV9zNer7tABcOxvu4qfPbvd//+N/9GOny4V+Xh6/x5N//kBS9w/zbGtfHkqUJptaQHHpBe85rBr914o2vn+cAHXIsQAUpPuKKhKiFFlKqEO6MKULZv3/z4GW7fkQhQAAAYvXrd/QYyybT+1rp/vsvGRvriMipAqWobDwFKNa2vjyfEOHWq+E5LSHbsmHTVVa5FRnILvf/wH6SPfCRb69ShQ659Z65vaXTLLfnmoDzyiKtg2bcv+uv33OMWoMvLrvUITv/8E6naAUpV7m1UAYq0ueqEAAUAAIzUykr6MdMaoIR3I0mqJrE2eveSKgYonQ6VBlU1rp+lTie+ygzlOHZMuvrqzZ+75Rbp9tulP/1T//MEAUq/YJBs1tlCUe07/ebmpP/0n9xMFOaf9ExSBUpV3jffOSRlbAsdhCbz89KOHcXONeEIUAAAGCXfdoKNjemsaAjvMJQUoGxsRO8o02xWL6yYxvdqWrCl8/Q6enQwQJGkH/1R6eBBF4z4iApQ9u93c0uefdb/ftpt1z4U1b7Tb8+e3g49cMJhQJWHlFYl3PG9jzLuN6hAueii4mHMhCNAAQBglLLMRJi2KpRudzBoSApQkipNqlaFMmkBSrvdm7XTaLiwKviYJs3m9D0n9AQDZMN27ZLe8x7p934vuoqtX3j+Sb+sbTyHDklXXCEdOOD/GDiT1MIzaTNQoo7LWkWzY4d7zIy370gEKAAAjFaW34ZPW4AStZBtteIH5k5SgDJpQ3+PHpWefNJ9fOtb0lNPuY/Dh6tX3VPEtP0MYbOoFp7Aa17jvvaZzySfI2r+SSDrINm09h1Em5sbDCXm5qrTKhNWlXDHtzUn6n63bcseBO3cSYAiAhQAAEYn624g07aDR9xvguOqUCYpQJmkChRr418/a6er5SVqm3CM3zP/P3vvHSbHVeb7f6u7JyeNRlmy5SDJWc5pwQFjk8zacDFpWaJ3uXDh7rL+EQx7WROXNZiFB7wLy2WBNdyFCwaDCTaOYD+ssxxkybIlWWlG0sxoQs90T+eu3x+vz+3q7grnnDoVuud8nmceWzPd1aerqsP7re/7ffcAjzzibxv5PIX0rljhfJt3vAP41a/cA2Wffba5fYdxyinAjh18r+9KhZ7TBRd431ZTT6P7hBEXoaKROK2LZy12QklHh3ibVH+/FlCgBRSNRqPRaMJDRhBppyvoTq0UdgJKoeAe3pjPi4c7BkkrOVByOfd91y4Cytyc2CQWTXjcdx9w003ALbfIi8RjY8CaNe4uhXXrgLPPBm6/3fk227Y5jxMeGKApPy+84L2eHTto8s6qVd631dTjVMjHSaiwEqd18axFlQNlyRJ7p9YiQ+8BjUaj0WjCQqYwbScBxc2B0hgWy+MwiZMLpZUcKG65MwCdp3ESp2Qol4GDB6NehcaJ0VHgwx8GXnwR+NKX5N7nnAJkG3nLW4A777R3I01N0WPb5agwTjuNr41Ht+/I4ySgxCVrxIqKiTYq4XGR2AkoMg6UuLZUhYwWUDQajUajCQPR9h3GwkLrF7MAPQcnl0a12uxOaSUBpVptrVYrLwGlWm1958bhwySiaOLJ6Chw0knApz9NLpLrr6ffiW7DTfhgrFgBXHQR8ItfNP9t+3bg5JPdr6qzccZuVKskoOj2HTmcWnjiKqDECVkHioyAogGgBRSNRqPRaMJBNs/ENFu/mAW8J2E0FvWtJKC0kvsE8BZQAGp/8YtpRiMszc9TNoYmnmSzdA4uX05XtN/3PuC//TcSUx57jH87bgGyjbzpTcAf/gBMTtb//tlnndt3GCeeCOzb5/662bmTsiF416Opp5VaeOK2Jj8CShwFqhZACygajUaj0YSBn1yJdsik8BolaxWJymU+90A+39z6EwWtlH+Sz/PtWxXn3KFDwMSE/+2IUKlQNoYmvrDWG2sbxGWXAZ/8JPCd79g7Rdy2w8PwMPCqVwG33lr/e7cAWUZXF7BxI2WlOKHdJ/5opRDZuK1JRkBhE446OuLVjtQiaAFFo9FoNJqgkW3fYWSz8RAK/ODlQLGGwvI6S0zTW5gJg1ZyoPC4TwASWXhva8f0dO1HhcC0sEBijJejRbfuxB8n58imTcCNNwK//CUwM+O+jUKBzi2RwNarrwYefbSWjTM1RecVTxvQaac5t/EUCjr/xA+plHO2RhwdEnFbk9d67MZBW++j23iE0QKKRqPRaDRB43ccseo2nijEGB6hgxXsIq05UbfxZLOtNSpX5DySdaFkMuQ+Aehc8+NCyWRo5O2LL9J2du1ybi/KZLwLb030HDjgLFosXUqZI08+6b6NQ4eAlSvF3AD9/cDrXw/85Cf0723bvPNPGJs3NwfJZjLkaPngB6nNZ/16/rVoargV8H7dHoZBrWI9Pf62YyVuDhQvAcWpfYf3/pomYnYGaDQajUbThqhoh5ifpwJABbkcfflfsULN9rwwTT4XQjZLz1FEFFlYoKIrbAoFylPw49KIApH1zs1RkSpCsUgOA6tINzsLLFsGdHeLPfbkZPO5UCoB+/cDQ0PkPmBf/nXrTutw4AAJEk6cdRawZQu19bhtQyZv5MorgQ99iES5bdu823cYxx1Hjhcm0P3618C99wLnnAN87nM6+8QPTu07gP/ifu1aGr27ciW9d8zP02dfJtMczm4YJDakUvQ+5nTRI26TaLwEHS8BRTtQhNECikaj0Wg0QaNiFPH8PBWhKq4W5XJU1KZS4YgPXu07DDZxiPf2QC0HJaw+7koFOHKEz3WSyZBoEJcrlsWiWLtRoUA/bgWOlWqVxA27Fprxcb4r9IUCFcdejqV0mvbvypV0Do+Pt1Yr1WLGS/w480zgBz+g88jptcM7gaeR7m4KlP3P/6RWniuv5LtfMkliy1e/Suu/+GLgK18JT4RuZ9wKeCZqyLTlLVtG4gmjo4PeK5YupfcqJiYz0cR6rs3N0XuZHXF5P2ckk+SicprWpwUU5egWHo1Go9FogmRhQd0kElXtCeyqPq8Q4BfenJJSSXz6i6jgIkupRFeg9+zh32f5vJppNqqQccuIrH9szPlYz897tw+VSsDevfznS6VCRfDu3XRsNPHHOoHHieFhchc9/7zzbWQdKABwxRV0/4UFsW28+tUkonzjG8C112rxRBVeAq2MYNHf7+6eSyToNv399iL34CAJMHZE2fLi5OJz20e6hUc5MZPQNBqNRqNpM1S4TxjpNDAy4t9CbC1Qx8fpy+TAgL9tuiEicMgUwvm8WHsIQMWTUxZMqUQ/zLFRKsnlxuRydOU0ihYjO2QFFLdilzEx4S0sjY9TK4QdlQqNipVxkUSdg6PhZ2yM2iq8ckfOPJPaeJxabGQdKAAVjO98J7BjB1/+CeOMM+hHoxYvB0RHh1hYeFcXnRt+XYkrV9J7ZuP7ZlQOFMMgUWd0tPlvrO3IDrvWX+1A8YUWUDQajUajCRKVI4hNk1woTlfGeCgUmq2+hw+TKNPb6299Toh8+ZWxaotO4jFN+y+hqsnnaX+XSvG4yicTRJzLea8/neYLil1YoNdDo1hnmmSXj8NEpcVOqQTcfTe9Dk2zJhyyNrlTTwU2bJDf/v79fK6Ps88GvvUtEjrs1jg5CaxeLb+Ol72MfjTR41XAiwgWySRw9NFqckoMg4SY3btrn0t2E23CYnDQ+UKB0/vzyAjdz+32Xi1Amia0gKLRaDQaTVCobN9hzM6So0HkyqkVuyLVNKkVYt06cSeHF7wBsn4QLbzDKNStrUXz89G7UMpl+VYnt/VnMmJi1Pg4XRG1Xh0eHVU7ZUojz44dwO23AxdcUH+MDIPey776VRLAXv1q4OUv58/HYfA6R44/nsTiI0eaBeNDh9TlQWnU0N1N50JHR/PP1BQJXnZ0dHh/lokIKOvWiZ+TbnR00Db37hVfi2qWLKkJOI3fK+xeCz099mO+U6lmd05npxawBdACikaj0Wg0QaGyfYdRrdZEFBmc2h2qVbLXH3202sKkUAh+bHKxSOvnFZXC+KJofQw/x0sVfqYFOQkouRw5CkSObz5P+2N4mP59+HBrjYFud/btoyk473mP/d/f9S7gqaeA3/8e+OEPgUsuAV71KmrL4WF0lG/yTTJJ7TJbttD2G7ch276jUUNXF9DXV/txExZWrKD3ELv3XR6xg/fzaOXKYFpRWZ7K+Hh07pPe3tq+SqWaBZTG/Z9MOrcx2Tl+tIAihA6R1Wg0Go0mCExTbfuOlZkZeVHCLS+iUlG/5jACXgGxL39hCygLC9FPiPEjoGQyzV/YCwUqtmVs3xMTdP5OTZHDQBMf9u0DjjnG+e/JJLXXfOpTwJe/TMXtpz8N3HIL3/YPHOAXP9g440ZGR/XY4Cjo6SGh7IQTgI0bgTVraJy4lyvDMOh+dsW8KgGlp4cvq0mW5ctJnHFaSzIZ7CQ4JjgD9mtoPAZr1zq3RtndX7u5hNACikaj0Wg0QWBXdKqiUpG7al+peBfyqsWFsK5qiY4+DprGx+CdZpPJUJCuauHJT4uMada7qYpFsrTL5NUAdA4eOECtGJp4sXevu4BiZcUK4C//koSU++7zFtMWFvhDiQFyoGzb1vyeJSLCaPwzMAAceyy1VQ0PyxXbTgIHT4ApT9uMXVCqataudc4JY+1KQdDZSS4f62M1Yt1Hy5bZ55643V8HyQqhBRSNRqPRaIIg6LYEGRcKz7QS1eJC3BwoPCKSChr39eys931YG9XBg8DOnZRHceAACSp+cmSqVf/HlQlA5bL8tBy77WniQ6VC7o6jjxa737JlVGSznAgn2AQe3jaIwUFymjz3XP3vR0f5W4Y0chgGtf1wgAAAIABJREFUZW5s2ACsX19fwMuyfDkJKVZ4HCg8AkpQAeiN63AKcE8mgxNQliyp/7ebg6Snx318s9P9tYAihBZQNBqNRqNRTankr2WC9zFE2214iuhyWd5Z0Ihpxk9ACcN9Yve8czlvEeTIkXpholwmIe7gQeCFF+Tbq9xGNvPCHFX79oV3TDXhMjZGUztkgqRPPx145hn328g4RxrbeCoVys3RAkpwdHRQi47qUHHDoG1as6p4CveODu/2mDAEFDdSqWACZpPJZjeJ3eOwx+cZ36xbeHyjBRSNRqPRaFQTVijm9LTY7XkcKIA6kaFYDD5AllEq8bVMhSGgsFDbRtxcF6WSdx4Ij4vFDhViXqVC4zx5zyFN6+GVf+LG5s3hCCiHD1MbicpJK5p6enuDcyR0ddUcEobBX7i7iRM9PdGFuzJSqWD22dBQczi63T5LJkmc4hWkGkkkop0w1GJoAUWj0Wg0GpWYZnjtCcUi/6Qf0wzfpRF2qj/P44WxJieRwU1Ym5jwzpCYn5fL1VHlhgp6HLUmWvbupXYNGU45BXj+efdz5MAB8fDXY4+l97jxcfq3DpANnqDbOUZGqCWos5M/eNWtuI/afQLQ+lS7OFgbVSNOj8OTA8PGINuh23i40QKKRqPRaDQqyWbVtcDwwOtCERknrEpkCLvVIy4CitPzdmrjyecp08aLalVcnDPN4NvJNO2BHwdKXx+JLzt2ON9GZvxwIgGceSbw5JP0bx0gGzxhuHvWrm3OQ3HDTZxQkc/ilyAElP5+e+HITQTxwm2Nuo2HGy2gaDQajUajkrDadxj5PF9bhUjrRbsKKLxtPn5x29d254fINBrRNp5cTm7UsGbx4ceBAgCnnebcxpPL0bm/YoX4dq1tPNqBEjxhCCidncDq1fy3X4wOFOvoYrvHk8FtjdqBwo0WUDQajUajUUW57G9crCw8LhQRUaRaVdOuEbaA4vV4YbUUuT1Oo4AyPy92zmSzYhNwtPvEnl//mvI0NEQ6Ta953hHDdrjloIyNAWvWyF05P/10YPt2en3LuFg0YoSVLyNyLjgV/l1d8cjuSKXIGdKYVyJLT497gK+sWKMFFCVoAUWj0Wg0GlVENZo1m/UWPETDP/2KDaVS+M4HrwlCYQSglkrua8jna0KPacoV8SIuJy2gNJPJAP/n/wA33MC//+fmgFtvbV83D3Of8GZS2LFpE7mp7KZF+Wm96e+n1qJnn62NQtYEQ0eHOhFAJU4iSRzadwyjJgapcqHYZZ9YCUJA0S083MTwFaLRaDQaTYsSdvuOFbcMDa+i3g6/AkpUo27d1h2GA4XnMdh5MjMjt59E2ni0gNLM00+TW+JNbyIRxauF6sAB4PrrgZ/+1HtSUqviJ/+E0dEBnHgiCR2N+G29Oess4Pe/p5GuItkZ7URXlz+HEA8qxxarxKm4j0P7jtVJo0KE6OgABga8byODm8tECyjcaAFFo9FoNBoVLCyItVaoZm7OWSSREQ7iJqDwZnk4rds0wxF1ePbb3BxlsUxMyD8Gz+NMT4cbaNwqPPEEFeSvehWJKJ/5jLOI8uSTwD/8A/CWt9CkmdHRUJfKxW9+A3z/+/624Tf/hOHUxuM3/PWss+i4Leb2nWXLSEAJsmUlruOhnZ5zHAQU69pUiBBLl4o9pghu6zMMf208i6gFSAsoGo1Go9GoIEr3CUACgZMzQaZ1RWRqj9P9VZLN8rkpnIQFv8+HF95JQKOj/sQNr/OtVKqNftXUqFZJFDnrLPr3q14FXHMNOVEOHqzdzjRJmLj5ZuATnwAuvZSK9wMHIlm2IzMz1Fr04IPArl3y21HhQAFIQHn66ebf+xVQ1q+nwnKxBsh2dFBbRyIhF8TLS1yLYLvCv7MzHutVKaAkk+Sy8kL2cbyEF9ntdnXFs/UrIBbPM9VoNBqNJigqFcpViJrZWXuXhoybxDT9BckG4UDh2cdOzzWsAFlescouJ0IErzaew4fDmTjUauzeTQWKtQi94gpymHzmMySilMvAv/0bcO+9wJe+RG0pABXvcRNQfvxj4LLLgHe8A/je9+QyWkolet4q3B1HH02vfWu2TD5P5+vKlfLbNQzgFa8ATjrJ/xpbkZGRWj7N8HBwTpE4OFBSqeYsnmSyuUCPg/sEUCugDA/z5RDJPE5Hh/e2ZQWpuLZ+BUQMYos1Go1Go2lx5ubCcTd4Ua2SM8E6/rBalRcP8nm5L9TVqvp2pmyWz7bMJgg1fhEMQ0CpVNRML+KhVCJBqb+/+W9zc9E7ouIKa99p5PLLqbi44QZg1SrK2fjHf6zP2zj6aOC++8Jbqxd799Lz+cY3aJ2//z3wwAPklhFhbIxaQ1QUz4ZBLpStW2k/su2vWiU3gcfKX/yF//W1IslkfVuHYZAYtX+/+seKg4CSTNJzbPwMSaXq31/jECALqBNQEglgaIj/tomEmGDKszYtoHChHSgajUaj0fglquk7dszM1Is5foQD2fuqFhGKRXIF5PN827Zzv8QlQFYldiJJpVLfiqKpZ8sW4Oyz7f/2ylcC73wnZZ184hPNYaXMgRIHsdQ0gR/8AHjzm6mQTCSAa6+l6UKiLXt796pp32Gcdlp9G4/f9p3FztKlze6LwUH1DoxUKj4jge3Etsa1tZuAMjSkZrSzn9vLrn+RBTtrAUWj0Wg0Gj9kMtFNnLGjXK5vdYlCQFG9P6zZJzJtPMyVEjRhnwdzc81XIA8f1sGxTszO0v5hLTl2XHwx8La32Rcy/f1UKMRhEs/jj5NYesUVtd+dcAKJF7feKrYtVfknjNNPp0k87NwcHdUCiiyJBLXv2MEcPqqIQ54I4CygWIv7VCpe62UYhpwIZRj1zlEeghBQZPZpIhGfYxESWkDRaDQajUaWcjmeQZ3T07X/lwmQZRQKcpkKQeSfMLJZ79s3Cihxyz9RRaVSn6WSybiPs17sbNlC7SV+rrLHIUi2VAJuuQV497ubC82//EvKbhFxIamawMMYGSGHxN699G/tQJFneNh9Ag1vywcPcWnD4BFQ4uI+AZqPj4yLY2BA/H0pCAHFLn/Gi7icNyGiBRSNRqPRaGQZH49nUGehUHNtRDGOOGgHilcLRT6vro1JhLBbeIBaG0+1qlt3vNiyxT7/RISggmSnpoBf/xq4/nrgb/4G2LHD+bZ33UUhuHbPZelS4A1voPYeXlQ7UID6ccajo4t3eo4fDMPZfcJYuVK84HUiDvknAIkndmKC9XftJqDwjC72elwveNcl6iZZZO07gBZQNBqNRqORI53mc0NExcwMta34FXhkRAGVAkpjCG6l4u30aJwgFIawYZrRCCjz8+SEmpwML8C2FSmXqaA/80x/2znqKBIEVJBOA3feCXz608B111Eo6NveRmGpX/kK8KMfNQdpzs9Ti8673+283SuvpODWLVu81zAzQ68pmQLOjdNPpxyUQoEccarbTRYDQ0PexWxnp7pjFxcBhScDJS4CimE059OICij9/XItMEE4UADxtWgHikaj0Wg0Gk9KJSpY40w2q2YSi6goUCrJtf04kcs1O05Ec1DCEDYKhWjCRU0TmJiIRy5HnHn+eSriRXMGGlHVwvOjHwEf/jDw3HPAVVcB3/0u8KEPAWecAVxwAfDVr9LjXH99/bSVW2+lvx99tPO2OzqA970P+P73vadhsQBZVS4GxsknAy+8AOzZQ/s9DuGkrcayZXy3W77c/4QjID45Fl4CSioVL7GnEVFhQ1YAE3mcRIL/HBFdvxZQmjEMo9swjEcNw3jaMIxthmF89qXfH2sYxiOGYewyDOP/GobR2XC/NxmGYRqGcU5Qi9doNBqNJhIOH1YrEgSFijwMUfEhyPYdhjX3wwm27nI5nFDVsPNPrExPx2MyTJzZssW/+wSoOVD87O9KBbj7buDrXwf+7u+Ac89tLlqWLCHx5HWvo9HKv/oVPe4f/0guFS/OPpuEi9/9zv12QbTvAOQQWL+e8lh0+444AwP8hWkqxS+2OBGnIFAnAYWtT/X0IT/4FVB6euQFCJHHEbmtyHnQ2alGvGsxeBwoBQCXmaZ5OoAzALzGMIwLANwI4GumaW4AMAPgWnYHwzAGAPwtgEfUL1mj0Wg0mgiZno62WA6bUkmsDYhHQDFN/gLUbl/nct5rYusIq60mTpOYNM24jS8Wob+fCh4/jp89e8gJ45VvYRg0Wvmf/gl47DEarXz11fzBoe99L3Dbbe5CquoAWSubNwMPPqgDZGUQFURGRvy5fOLi6AC8M1Di0r4D+BdQ/LRfJRLN7UNOBCWgLEL3CcAhoJgE88p2vPRjArgMAJuT9h8A3mC52+dBAksEzcAajUaj0QREoUBhj4sNERGCR0iYn+dzkQD2DhTAu42HtdS06wQeDT+TkzTC+Pjj1Wxv3Tp/OShPP03iAi8rVwKf/Sy1/Lz+9fz3W7MGuPxy4D/+w/k2rIUnCDZvJgG21QQUmRBQJ3p6xIWN3l5xkSCRoGBhWeLiPkkmSTi0czWwNpS4O1B4J9l0dvoXg4LINRF10CxCuGQrwzCShmE8BWACwN0AdgOYNU2TeWJHAax96bZnATjKNM3fBrBejUaj0bQDrdD+0ohpUuuOilaJuTlyssRxgo8dqgWUI0eooPWiWHRuv/ESUEyT1tLOE3g0fGzZQtkiqqzmfnNQnnmGQlZFSCaBCy8UL+6vuYZyVrZubf5bqUSTxIJqsdm4ka5Qt5qA4jcnx8rAgLjLQFYIGR6WF0Li4iRggoTTa7WzMz5rBZzFMZ7XqQonDe/7gcj7RjLJ/14Zp2MRIlwCimmaFdM0zwCwDsB5AE60u51hGAkA/wzg//PapmEY7zcM43HDMB6fjHsQn0aj0WjUMjcX9QrEmZlR06ZRKtGEjIMHKdhybMzZZWElyowLXnGgWvUOrVxYoB82Pcbrtk7w5qCEIWyomHakCQ4V44ut+BFQCgVg1y4KWQ2D7m4KlP3ud5tfmwcOkLslKPdBRwfwta+1XgbKwIC60Nv+fmqv4S1Ie3roPjIYhrz4EpcWHraf7KbbANS+pjrw2A9+BBQV7o0gBBSA7z0hTrk5ISM0hcc0zVkA9wO4EMASwzDYWbMOwBiAAQCnAviDYRh7AVwA4Ha7IFnTNL9jmuY5pmmes3z5ch9PQaPRaDQtB0/x3Mj0dDBr4UWV6DM2Viu2q1USZl58kYqqqSkSDWZnabLKgQPA7t3Ajh3036jgFSF4BCbWAmWa3i4UNwGlXPZe19xcOG4n7T6JL8UisG0bOVBU4UdAee454Nhjw7W+n3ceTWr5bYM5PMj2HYaftpIoMAwSnVQcn1SK2k2SSX4XysqV/h5zyRI5V0BcBBSrIGEnTvDm/4RF1AIKr9AXxGSd7u54iVkhwjOFZ7lhGEte+v8eAFcAeA4kpFzz0s3eDeBXpmmmTdNcZprmMaZpHgPgYQBXmab5eCCr12g0Gk1rUirRmF1eymVq+4gqf6RUokLML9PTzq0n+Txw6BCJKaOjJKCk05StwcSCqIJKKxVvZwngvb5isV6I8hJQvHJFvNp4dPuOGNUq8Mtf+sv3iBvbtlFI6sCAum2yDBQZV9gzz4jln6jAMIBrr6Vjaw2/DWoCTyvT2Un7S0Vxa23RGBnxDvz04z6xIirCGEZ8nARWQcDOtaMyn0YFTs4ir3V2dalpKeTdH6KOqiVLvG+zSNt3AD4HymoA9xuG8QyAxwDcbZrmbwB8AsB1hmHsAjAC4N+DW6ZGo9Fo2oZqlQQBr+LXCrvt1JTY/VSh4jGLRcpQ8UM67X8dsvCIBF4CSuO43XzeWSSpVv0LKGHRDgGy5TJw883Az34G3HNP1KtRh+r2HYDEmK4uOUE3CgEFAFavBl7zGuAHP6j9LsgJPK0KKwpVBJVaRbtUyjtbRZVbZ2BAbP1MNIoDVlGhFcbjyjpQVAXh8ggoHR3ix7ejAxgcdL+NFlCcMU3zGdM0zzRNc7Npmqeapvm5l37/omma55mmucE0zTebptn0rck0zUu1+0SjiRAVV8w1rUupFM+wVuZkWFjgX5817+Lw4fDPbRWF+tiY/+PRygJKpWI/TtXJhcKTC5PNxuMcb3UBJZ8HbryRzvP/9b+AJ56IekVqME1144sbkWnjmZuj0NYNG9Svh4c3vpEcbk89RfsmjBaeVoO1sqhwoDS6SUZGnAvZnh61LikRF0pc2ncAbwdKnHAbI+wlbKhq4eMVUGTwajtbpBN4AMEMFI1G02LogObFzfg4/6jYMGECimnyFcnlcn2BWq1SAGtYhXOl4r9AnpoSa1lyQtVUmXyeb99b4bm9m4AyO2sftJpO27dC8Abrij4Pdr9Dh9QE87pNCmoF5udpRO7gIPDxjwMnnkjnx8GDUa/MPwcP0vEJwmUhI6Bs3UrhsaoCSkXp6qJWnu9+lz4fEgk+q/5ighWFyaQ/YcFufHFnp/P+Vp0V09fHL8hoAUUOt9dxWA4UNxGHdy1OdHY6t5R1dMT/+ASIFlA0mnalUKCCrZW/2GvkmZujwjKO026s7hEeZ4fdbYpFKoDDwK/wUShQsaIKFS6UuTlg/36xTJVCwf2xi0VnQcI067MXrJTL9ucpr2glIxLm8yRqvfgiX7aLG63sPjlyhBwnJ58MfPjDVBAYBrW8PN4GBuIHHgAuuCCY9gQZASWq9h0rZ59NGS7/8i/kPolL60ZcsIoJfq6wOxWedoMzVLtPGLwulLgKKFEJjby4rS+RcBYYuru9RQ8RvAQSP602Ti6URdy+A2gBRaNpX1jRp+Kqt6a1qFRq7qNcLn6tXNaClef8dBJZstlwQmX9tO+YJoVNqnTLqBDF2BSkvXvFzo/JSWdR1k2MmZtzFyrs2nh4hQmZ48NcK7kcTTfyI4K0aoDs6Cjw938PvPKVwDvfWV9In3NO67fxVCrAffcBl18ezPbXrRMTUEwTePrp6AUUgMYa79ql23caSSbrw1T9uAScBJTOzuZJMkFNI+3u5ptaEycBpZUyULwEHidhQ3Xri5uAkkh4Z5m44TSRahG37wBaQNFo2hctoCxeJifrWyWizM2ww1pIe7XHVCruLRpBh8qapr/X0NSUeodCoeBvm6VS7f6lEjlR7Fpr7KhWnVsD3QQUL6Frfr7+vCgU+N1zhYK4SGg9p8plYM8e74lAPNtqFbJZ4IYbgLe/Hbjqqua/b95MwlIrf348+SRlTgQVknrUUWKTeMbH6Vxbty6Y9YiwYgXwoQ8BL3951CuJF42TaGSLxGTSXXyxCibd3f4KXC9WrvR2GcVFQGlsR2lXAUVV+w7POoaG/LvM7Fwo2oGi0Wjajmq1dlU0m1XT569pDezadubm4nUONBa7bkUajzhy+HBwrWoLC/723fS0urVY8eNCaWx5yedpnKlIoK/dMXMSUBYW+EQGq4AhKkqIimiN669WqRgeHxc/3q3oQNmzhwqrSy+1/3tXF7X1PPVUqMtSyj33BOc+AcQn8bD2nbi0zLz85cDxx0e9injRKJjItlr097sf5+7uWsuO6uyTRjo73R0uHR1q20n80CgEtKuAEqYDhceB5EVfX73IZhjxEd0iIiavGI1GoxRr0Weard2jr+HHNIGJiebfVyrxuZJsms1ih1vxy1MYV6v2z1sFftwtxWJw7VN+XEV2z2lhQexq+sREs+DiJKDwFphhCShu7pbJSbFR04UCv3snTuzf7+3MOPts/zkojzwCPPigv23IMD0NPPcc8LKXBfs4Ijkoccg/0bjTeFXdMOSutPf1ed9m+fLg3SeNj2VHnArhRsEk7hkoXgKPnbChOv/E6XEAcro0uqpksbpQurvjIwRHhBZQNJp2pLFYDrLFQRMfpqedC/a4tPHYrc9JaPBq37GSyQQzcciP8BTk665YlBNGTdN5XXNz/JNXSqV6YaRSsRclikX+c69QqM8mEUHEaed1TEVeK63YvgOQ44hHQHnySXmB6J57gJtvBn75S7n7++H++4ELLwy+T59XQKlUaAKPFlDijZ2YINNu4ZR/0rjdo44S37YMhgGsWWP/tzgJKIvBgRLEe5KTgKJywtbAQE2MWeTtO4AWUDSa9qSxQIiL+0ATHMWie7tIXCYyOQWJ2p2jou1nExP8xd7UlPe283l/+yzo152MKJbNurfqzMzwb3dmpuY6cRLuRHNFZmboGIq2xYi4rLxEj3KZ//FbsX0HIAfK0Ue732bZMvp54QXx7d9+O3DrrcCXvkSvS9l8GRmq1eDbdxi8QbJ791Ix4zTRQhMP7ApD0YK3u5v/qn+Y4kVvL72eo1yDF3aCRJxFFBkBRXX+idM6Uik+J5QIw8P0Xy2gaAFFo2k7isXmoq9Uit8klnYiDg4fnuyGOIw0FhFQRB0l1ulDbkxMkIDiNFaX4Xf6TtDnhYyAwrNPRdwfbDyzW/6JCHNz8sIT7/38TH5qpBUdKNUqFf1eAgog3sZjmsB//idw993AF75AAsMpp5D7Iiy2bqUiJYx8DxYk64Vu34k/HR32xbpowcvjPomKFSuaxR0toMjjJaDY/T0IB0oy2dwWtGSJ+jabwUF6Tot8Ag+gBRSNpv1wKg60CyUYSiVqe4hy/87M8BW9cRBQnIS8hYV690i1Kleczs253+/IkdrV8JkZ99v6EUByueCzMUol8X3EI6CIuCryedqfdgKKTP5SpVITZUTheW7Fovs4ZQbPsTfN1nSgTE5SUchT6IkIKNUq8N3vUtvPF75Qu9p9+uk0vlcFPI4w5j4Jo0efdxJPXMYXa5xxuqre0SGWxRFnASWRaG7liZOAYieWxDUHJZn0fo8xjHoXShD5Jwzr4xhGMNk6hkF5OnE9JiGiBZR2plqN1+QNTThoASVcmAtgfDz8MMlqlQIveVwXgHxuhkrcilfrOZrJyL9/jY/bt6nMzDS3OR0+bH/c/AbAhuVKEhHFeMf9iooCR47YCzmyAatu45DdyOe9xRFewWlhwXsqUT7fmp+xPO07jA0bSJjyCtYtl4FvfpOyVT7zmfrJD5s3kwPD777auhV473uBnTudbzM3R5ODLrrI32PxwnIB3NonCwVa8ymnhLMmjRxubQm8LpREQn3bhGr6+2utGKlUvIrhoBwoQYgWvPvNKmwE0b7DsK6nvz+448qmRy1ytIDSzhSL8l9ENa1JtepcIOdy/GNKNXyYZk1AKZflr5zLwEbPirpKog6TFRFQ/DxG4+SXdNpeaHI6bn4Fx7AEFJFsCd6WqHKZz6XBqFbtbx9Fe4vXc+Q9rjwOqKjFSFl4AmQZiQS5ULZscb5NpQL88z/Tvv/0p5sLyDVr6Mrl2Jj8mstlcrdccgnwT//knDvyhz8A554brgtg3ToSpZzYsYP2d5DFk8Y/bk4M3paFvr7WmE6yahUV2KomtKgiCAGlu9s++8UvMgJKkK0v1sdRGR6rsUULKO2MjL1b09rkcs5X+UxTnw+qmZ+vv8KeyYQjUExP0xd2kSKXMT8fnZBmmt4CimnS+vwKGDMzNSfF/Ly7uJXJNAtRfgSQSiW84rpc5t9Xom4Vv0ThevN6TJH3QK9zoFXfT0UcKIB3G88tt9C++MQn7ItQw6i5UGS5805gZAS49lrgXe8CPv/55tHlphleeKwVr0k8zzxDbUyaeKPCgdIqV+eTSRI2w2jfSST4RRC72/kVUJYto3YW1cKWqIBiGOEIKF1dOqMkBLSA0s6USq17hUwjh1fxoNt41DIz0/y7iYngAnvLZfqi7hV+6oZpBjPulwcvwYc5qESn7zgxPk7b8mo/AOi4sfX5FUAWFsJt7eARRsplseek4rMjivcbt9avcllMGPISUFox/wQQc6AAVPw//7z9OXHnnZR58tGPOo/SZNuQzUGZnQV+/nPgfe+jIuSSS4A3vAH47Gfr34N37KBjf9JJco8ji1eQrB5fHH8Mw9uBwlOAxzn/pJHBQRIlg2bZMr6C3jDUZ6D09tJPIqE+E4RX2GHvi0Hmn1gfx9o+qQkMLaC0M6VS637B08ihBZTwyOWcgzMPH1ZfQJfLVPioKGyjauPhDe9U1f5SKFDbAM+xYHkyptk67TuMdNr7OYpmyvj97LCbBhYGlYqzM0TUMeKWqVKttubna6lEYuHatfz36ekBTjiBskWsPPkk8LOfAZ/6lHfheNppwPbtcufEj34EXHoptcowXvc6ElI+//na6zXM8FgrbqOMt20DDh0CNm4Md01BEafAUZV0dbmfN4mE93Pv7IxfS4wXMuNoRUSAnh5qJ+E5b5yEEj8OFGvrjmphQdSBErQrpKMjGKFIY4sWUNqZUom+TOoclMUBz3QJ0SuwGmfcsifyefdQQRmmptSF1Obz0Yy15nnMTCY6oS+XoyvafgWQsAWUcpmKNDdEXUd+3yeibG9x2v8y55XTtqJwd6bTfCNz3RgdpVGmbm4RO845B3jiidq/9+8HvvENcp6sWuV9/6EhYOVK9wBYO154gZwrb35z89/e/Gbg1FOBL36R3m8ffZSElrA5+ujmSTzj48BNN9E++vCH4xXU6YdVq1rLZcELT4HvVQC3SvuOHxIJclzxiBqGQa95gE9YctqmrIAyMFAvEHV3qxUARQWUoDOQUikST4J0uWj+H3ovtzOsmG7Fq2QacXgLFu1C8U+57F0kT02pK7KKRfWukf37ydFy8CBdkZ6ZoSI7yPcLHgdKuRxt2PHUlL/XSFTh3dPTzjkvMq6aQsGfiyqOAorMmuIioBQKNBr4u9/1tx3R9h0GC5KtVkk8/tKXgPe8R6xd5vTTxXJQKhV6vu94h33xYRi0htWrgY99jLYfhX19YICKpOlpOsd++EPKgznmGBJQzj8//DUFQUcHiSdBBHJGDY8Tw60A7uxsz/3SSH8/iRAsGNqNkZGacBK2A8Uw7NuTVIar8gooyST9BO1ASSZr05U0gaMFlHbFGtbYqkF3GjF4C6Swr463IzwtE4C6qTy8Y4pFqFapKMtkqCCanCQXw/79wbk8DBKvAAAgAElEQVRTonC9iGKa/oSDKF9fk5P2+TgLC+KtE6bpT0yL8nMnl2sW62RzbZzeV8MUUEwT+Pa3gaVLgV27/DnRRANkGStX0tXN7duBG28ELr6YWmhE2LxZLAflvvuoSHF7nEQC+B//AzjvPOCqq8TWo5KjjgJ++lPgf/5P+nz4538GrrmmvVpeli6lwrS/v/1CKv0IKKkUiWWirq5WhLWH9PTU3CV2dHXVF/Odnd6Ci0oBZXDQ3vUyMMDn0Ojt9XZaibjKBgbCaS1cDOdgTNACSrti/bKsg2TbH5EJO/m83BfwMEMxRQlzbdbRxV7wtFV5sbAQvmvILhxXBX73RSsQtcPr8OHm4ycr6sgKKJVK9M7HxucsK+g4he+G+bn6299SxsZ111ERu2+f/Lb275dzoADkQvnKV4Dly4G3vU38/ieeSGvneY1kMsCPfwz81V95Fx7JJPDf/zuwaZP4mlRx4onk5vvUp6hlZ+nS6NYSBIlEfUG8YoX/bQY9lUQEHqGrq6u5mE8mSTxptewTGVKpehFpcND5PF+1qvl167WP3QQUEfHByX0C0Hns1WrFWo+83Gwiwo7OJWk7tIDSrlgLlXJ5cRQuixnRqR8yRd74eHCFtR9Mk/rPw2r7yGTErub7LbT8TNyRZW5O7Dny7HuvEcbtQtQCCkCFnHUyj+zUJVkRJA6uR1UCit22yuXw3FRbtwK33QZ8/ONUgJx4Ik2bkUW2hQcALroIOOUUEghkrqZ2dZHIsW2b921/8hNqfTnuOPHHiYK3v50CbY8/PuqVBMPgYH2B25gvIUNvLx3flSvDD/61kkzyCyDW55xIkJvL735oFeyEh2XLmp0aS5faiyVeAoqbICEiVgwPu7tDvISR5cvJydHX5+zoSKXEztnFco4sIrSA0q40FirahdLeiBYHokVePk8F2eRkMO0kfshk6PxW1S7jhVt4rB1+CregM0mcME1+scw0+SbdLAbxJJeLZvJMI6ZJjoVMhgp92XOo1QUU6znpR9hqFFDC+jydmAC+/nXgb/+2dsX/hBNopLAM7L1y+XK5+x9zDAk5fq6284wz3rsX+NOfgL/4C/nH0ajF7oq+38wP1tawfDkJT1G5UUTarJgDwzCobauvL5g1xREnF8WqVbV92Nnp7P7wet9wEz14BZRk0tv95RYmy6YGMZzElnYJhdZIowWUdkULKIsL0eIgmxUr9KyiycxMMGN6ZWFX2ufn1U++aaRQEH8tyRaTphmtWJVO8zlLZmdpn3jtl8UgoMQpX4iJKH7OIdkw3Di4cKzjjKtVf5+BCwv1r4UwPk8LBeDLXwbe8AbKDmH4caDs20dXzKO82r95s3uQbKEA3HwziSeLYapJK9DTYy9uDA35E9OsBXl3d3RuFBF3ABNQ1qxZXOdnZ6ez6JBI0Fj0VMr9+Mm28AD8AsrSpXwZJ3ZhstapQYzBQfvn42e0sqYt0AJKu6IFlMVDpSJuJ69WSQThYX6++fyZm6PA0ahFlEqlvlg7ciTY4k3UfQLIt9DNzkbrZmDTNtyoVGhqDeC937WAEj6Vir+2O5lWFb9ihUrY8RBtcWykcYpR0M/PNIFvfYuucL/+9fV/W7OGRAb2uhNBNkBWJcccQ8fFSdj73vfoOV5+eajL0rjg5CgwDHkXSldXs/jC3CgbNsi5UWQnMIkIKD095LhYbNNOvDI8UilqDXQ7bn4EFB7HRzLJP2XHLkx22bLmczKVsncZaQfKokcLKO1KY7FSLPpL7tfEF9mrxAsL3sWVaTpncGQy4WaP2GHNeWAcOhRMPgFrY5JB1IViFSaiZGbGvfCcnKwdfy/xoBUm8PihWo1H64pqRN9fcrnohVWGVUBRtS0geAHlN7+h99YPfKD56qdhUBuPjAslDgJKIgGcdpq9C+X++2nKzwc/GK1LRlMjlXIXJpYskSsm3dwbXV0kHvI4CRhLlwLr1rmPGnZ7PF5SqcUxrrgRnhBUL1dGMinvMuFxfPT08L9vNIbJ9vQ4i2J2oowWUBY9WkBpV+yu9sblqqBGLbICCkDiiNv9Z2fdnQO5HLUJRCWi2IVjVqsUoqlqTayVZv9++cJQtICbno5WmGJUKs4ThxoFpVLJ/VxqdweKX5dDXBHNQYmTiMTGGasUUIrFYJ1h6TRw663Axz7mXNjJtvH4CZBVid044337gFtuoecdl8ksGioq3YrSREJOUPBqf+ns5M/qSaUoI8gwSEQRba/QAZ/u9PSoEwycWr68ts9zTEVHhjNhxK51x0pvb3OYrBZQFj1aQGlHqlV7t4kWUNoTPwKKaZJjw65Y53VBFArRFE1u4ZjFIj0vv+RyFGjod/qQyP4pleRahYLCyYUyMdH8OzcXSrsLKHFr31FFnASUqSnx9czPq1lToUDvK2G4T/7sz9y/0J94oniQrGnGw4ECUJDs1q21z52FBeCmm4B3vzse69MQhsE3jnl4WEy0SCb5nCLLlvGJGytW1Arazk7K4+Clo0PnWXihcgSvk8gRhYDS1UXnl13rTiONLiwtoCx6tICigri1xjgVKlpAaU/8CCgAFQV2/ehTU/wuCL9rkMGrnSablQ/QrFZJIDhwQE3hL5JTMzsbLydDqdQsDqTT9oWsk4iwGEYYawGFCFJA+fa3gR//WOw+Iu9jXrApNkGRzQJ33UXBsW4cdxy1+Igcm8lJupIch+DL5ctp9OnevbW8l5NPBi69NOqVtS6JhPPIVVkGB/m2yTP5xEp/P1+rhWEAq1e738au9WJw0Dm3pRHtPnHHMNS+ZziJHF4CCY9gISqgAPRexJNn0xgmqwWURY8WUFQQxZhRN5wKlUIhXoWZxj+mqSZbIp2uLwCLRTEXRBSvAZ48kpkZuuoqsr5slr7Yq3aB8BSWpimfsxIk1ulG1apzLk6hYP/+Uy6393uPn1HBcadQ4Bcg8vngLiiYJrBzJ/CHP4iJGCrF3Ww2WAHljjuAc85xd58AVCisX0/7gxc2gScusGk8d9xBbsFrr416Ra1NX598iKoTIqLIyAh/ZolIQd7X517grlplL8asXMknjmgBxZ3+frEsGi+CcqDICoi87YKpFO0L6781ixotoKggbl+cnQQU09QulHajWFRXmI6P13r7RZ0bYTtQFhb4cwjyeRJRxsedizsmXOzbB4yNBZNxwCOgZDLxc7QBdHzZFJIjR9zXaOfEaHf3iYp2sTjD+xkXpPvk8GGyWZ98MvDgg8E9jhvZbHCf97kc8NvfAm98I9/tRdt44tK+wzj9dOCee4Cf/Qz46Ef9jcPVkCihstWiu9t++ogTqRSf60PG0bBypX3BumSJ8xoTCb4gWhnXwmJCtWMtqAyUMN4/mEBpGLrtS6MFFCWUy9GOG23EK/RT0z6oFC4qFSpSFhbERwGH/RqwC4/1Ip0mZ4k1FLVSIXfFnj303IMUgnhee3F0nzCmp2n/eDlz7ASUdp7AMz8vdz62EryiQZAjxHfuBDZuBF77WnItROFoKpeDEzjvvhs45RQKweRBNEg2LgGyjFNPJTH2Ax8gF4HGHwMDlCui6sq4iPuEsWyZd2HZ2ytefKZSza6sRILPqeXUApRK1faZxp5kUkxE48Ew7MUOvwJKGEIYC5PV4okGWkBRh2jhFeSXv7AFlHYujuKO6oJ/YYEm2MRhLU6YpnzBWqmQE2X/fso42bOHvsSHIf5UKu77qFxWX4CqnOSTy/E5LXK55iKzXR0oLIS53eF9bQfpQGECymmn0fm1fXtwjxU2xSJw++3ANdfw3+eEE4AXXuB/je/fHy8BpbcX+Pd/B84/P+qVxBORIq2np9a+oKqNR2YSUjLpPTlH1tEwPFxfzK9YwdeyMTxM+6Szkxwra9bQ+8iJJ9LrQTufnOHNqhHFTuzgadFxW0tYTqKhId2+owGgBRR1iNh6TdN5NKgK3IqVfF69eDM11d75BnEmCNFCtugOS0DJZPwLA/k8OSnCHhXsVmAG4T6ZnVXbcsArlja6UOzu1w7vGUeOLA4BmUd4LxaDFcqYgGIY5EL53e+Ce6ywue8+CoY95hj++yxZQsXo6Kj3bUslEo553S1hofrqdhjIODNE6ekRGw1szWZQ1XIhW5AuXeoubPhpM1qzhl7/XV38IbEAtfJs2kTn/9Klum2HF5UtYVbs9j+PKOF2mzAFFNVhzZqWRAsoqhApUgqFYCc2uH2JrVbVFrqmSVfNo5jCoonXfg8rCyjObS5euBWiQYiq09PBtlU40fj+ZveeZA2mbUVKJfkpT60Gz/tMkO6TUokcFMcfT/++9FLg2Wedw4xbiXIZuO02MfcJg7eNZ2yM/4q9xpn+/nCmGK1cSQIZL9ZCt6/P/xXyjg754NBEgs41O7q6/Dk+urpIWFq9OhhnhKZGKiXnQuJBVkBxc6mEJaAkk2KvTU3bogUUVYgUj7kc/QRxBZZn2oXKNp58nkQZna0SPkH248sQhoBSqUQjCKjCqchcWFB/9T6ToWMSxf5aWKh399g9tyNHWru15/Dh8B1MUcEzhjtIAWXPHiqa2MSMnh7g4otp5G+r88AD9Nw2bRK/7wkn8AXJxi1AtlVZtix4Eaqnh4Sajg4+saax0FUxdtbvZJolS+y3oUJ8WrGi3nGjCYYgs2HsRDSeljWn2/gR/GQISljStBRaQFFFpcJfDCwsBDcRh2cNKh+XfWluFwFldpZG30YJr7AWJ/cJEI6g08ruE4AKbjuhKYjnxc7jIAtbJ5gzDaD3pMZzmrV7tGr4ajYbbBtmHHETSK3HOwhY+46VV7+apri0sghXqQC/+AXwpjfJ3Z/XgRK3ANlWpLu7JmwEiTUYledKt50o4TcHxe/VfMOwD3hVIaAsZudJTw+1Li1dGrxgEOR450bBI5nkO65OAopuydJEgBZQVMJ7BZ6JDUF84fQjoJRK4oVcOwkohQJZ8qO8Ml6p8BdmcRNQgODX1KoFt5XG10q1qv55FYu113K5HM3rk7Xx2L2W2PtGKwpipknuk8WG2+fboUPBvvbtBJR16ygz5E9/Cu5xg+ahh6j94tRT5e6/bh29d3hNxtq3TztQ/MIyN5LJ4KZwMPcJY2DA+7Hscir6+vytUUVB2jjhJpXSE29E6eqiENy1a4ENGyjLZWSEnFDHHktCSlCCUtAuC+s5xtty5nQ7LaBoIkALKCrhEVAKhZrtO4grwzyFv9WOncuRYLB3b22UK694YL2a7jVhJO6waRqmST8TE9GsI5vlF9biuL+DbOMpFMLLWQmSxtf9/Lz6dr6ZmfptRtHGk83SGuzeT6wicpza0HiYmWkPwVgUp/eb6eng82zsBBSAwmTvvDPYxw6KahX4+c/JfSJbBCUS1Prj1cajW3j8kUrVu0GCcqHYjep1c5MkEvZBvH7beFQVpNbx1H19i9s9IsrwMLnGli+nfdfoOEkmSUg57ji6rcp9m0gEP51IRkBxEgX1JCVNBGgBRSU8xZ31i3ehoL544BU/Dh8Gdu8GDhygL7/W/nbeq+GNOS6tXFRMTNTvg2w2GrdDNltr8fIijgJKkGtqh8BIoPl1o7oVpFptbkOLQkBh2Uh22RlMRPIzktrKkSPh5JGUy9GJq1Fj9/6eyQQ/xnlujn7Wrm3+21ln0etn585g16CaXbuAL3yBrvKedZa/bXm18WQy9Pp3CvZczPBO1BgZqS9QgxBQGt0nDLc2HrvCmuFngooqAaW3t7aOoCa6tCu8+4uNjj72WHUBx93dwYtd1nOM1y2lW3g0MUILKCrhKR4bv4SqdqHwCij5vLN4w1vQNK69VQWUTMa+iJ2Y4BO4VB5DJp54bdM04zk+NSiHiIgzJ+5YJ2EF4apJp6nQt8Iryqkmk2l+T2rMgfEroFQq1HoXxvlx6FDzvl0sFIv1IlWxSAJ80OfVzp00fcfuy3MySVkoreJC2bcPuPFG+jn/fOCzn/VfqHgFye7fT9b/MEMWW4XeXnLmuO2bRKJ5dHEQAopdZghAa3QqEN0K5v5+uWPe0aG2RWnlSlqHDn7lp6tLXBRIpUgkVSF8BJl/wrC6Rvw4UAxDO1A0kaA/UVVSrYpPKohKQHGjUOArzttBQCmXnfMMKhVv10M6DYyOqimCraKWVzHIK56EXTSXSsG0ZLSL+4QRZAaIXTtFpRJN+1Mm03yuNoo58/P+3CNHjohlB8ly8GA4wbHVanzFQmvL5r59/l7rTz4JPPKI9+2c2ncYr3wl8Nhj8Q71PXgQ+NrXgM99Djj5ZODmm0n4UVGIb9xILbhOnwl79ugAWSe6usj5YeduYixd2ly4qRZQnNwnjOFh+9+7CSiJhJwjQfXV/K4u2r9B5ca0I7JunWTSf4AwEM6UGVUZKNp9ookIn8PiNU3k885qaLHY/IVTpYBimuqujmYyzVddrNhlnpTLVEAHnVKvkkOH3Iu3dLo5DI1x5EitWM1m/av21qLJq4DibZUZH6/vQw6DQkFtWFw6Hc92JT8sLNCXYtUCysKCs5CZzfJ9MSoW1V3RsXs/sgvRzWblvuxXKrXXIMuSCcJ6PD4efM4H4847gTvuoIKb94tlWOTzdA4dOOD/NfnTn9LnzHnnuR+znTtJbHBiYIDcHPfcIz/Nxi+VCnDbbXQOlkr0GmKTpnI5EpuuvBL4wAfUFyfd3RQmu3s3cNJJtd8XCjTh5667gL/7O7WP2S6w4mtoiM7tycn6vxuG/fcg1d9xnNwnjKEheg+yCs89Pd7rGBwUFxaDcB+oKOoXE35acYaHvUOlvQjDgZJI0PlbKvlr4dECiiYitANFNW5Xee0Km1JJ3cQXlZNjvGz1TsJPFCNTZZma4nPNTEzUf3FhUzisBZWKK8bWbbAv4U7wFC+ZDIk8Ybf6qBQ7qlU6TnFHdI25HB0f1W4dt3XwnqMTE8Hm/9i9R8i6B5j7BKD/BuHcmJhoLqyCwjSB3/+eXv/33x/OY4qQz1MhxyYsyXLwIG3HMIDt251vZ5qUF+LmQAGAK64AHnjA35r8MDZGotfICLWEnHQScO65wKWXAlddBXzzm8A11wR3Zbexjeepp4DrrqN1ffWrwObNwTxuK5NM1gsQK1Y0F66Dg/ZiskoBxct9wh6v8TY8LTEDA+JtPLodIlr6+vwJ53bnigidneG5hdi55qeFRwsomoiI2eWtNkBUQAGooFCh0KsUUFgbj9OHqZNQksu1xtWGhQX+ordYpNsuW0YF/cGDzc8/n6er7bIffHYtFtms8/7nESnY85ueDteForJVZGYm/pkTxWItG8PrSiLDNNUX5V5jyNlUHLer/eUyiRmlkrpAukacwkhF3SNW9wkjnVbbaz81FW5oLBMTrrsOuOkm4JJL4lXQpNNqRL8//hF4+csp/PDee4FTTrG/3aFDdDXUqYWBcfzxJKZls/ZTSYJmdJSm4Vx1VfiPDVCQ7IMP0vvl979Prp2//mv/AbXtTOPryjDIyfPii7XP12XL7O+rUkDh/cxYsqRe2OZp82DZIyJOR12QqieR4G9TVRG2u3SpvMgdhvuE0dVF79m835sNo3lf6vNVExHagaKaQsE5d8JJdFB11dQurNEPbleh3QSUuDM9TVfmRJiZoeO0f38w7hu7c8DtvPASUAqF2vGbmQlnQon1sVVQLofXNuEHZpednBT7oqpaGGocXdwIm4rjxuwsbYNNg1JNoWD/vMtl8fdBq/uEoXIk9PR08BNmGrnrLuBVr6Ji/Pjj4xeOqkI8qVbJLXLppSQQPfaY85f9F17wdp8AdGXy2GPJrRIFo6NUfEfFiScCW7eS8LZyJfD1r2vxxAu7wiuZJAdRMklCnJNjSJWAwuM+YQwO1q7Ap1L8bibRgjzMAnoxwIQ5ngsSqsJ2u7vl3W5h5J8w2GtQ5MJjowslThcYNIsKLaCoxjTtC8hSyblgUiU6NAoo+by/9g2nL7VubUduzzNqymX6onvkiHiRZZokurjtTz9CmN19czl74aNc9i5krMJDGAGbVhqndcgyNRXN5BhRrP3Go6PR5LWYJp/Y5HWOWrcRROuUmygj0jbkJK7JCDF2pNPkNAuTdJqCVS+5hP799rcDv/xla7VF8rBjB33pPfZYKu7OPNO5/WbnThKTeNi4MbpxxqOjNOkmKkZGgKuvpqk+73iHvirLg9M+6uqigtfJfQJQUawin0jE5WcYNXevyP0GBvidfamUDntVzerVJGgsX+59HESOlRderj0nwnagJBJiz9n6utPnqyZCtIASBHYtDG4iiaoJGY2iht8RqU7TeLy+0MfxC382S0F+Qa6NtUjIYLcu07Q/b7wK9EqF3AhWwnZy+BURCoV4T9VgZLP1r5Fq1f90El5YaHSxSMeXR7h0ExcaJ+ak0+rzc9xefyLunakp533sN5g3k6GCOGzuu4/CUNkVyKOPBs44A/j1r8NfS5D88Y/kPmFfmi+/nAJg7d47vSbwWNm4MToHyoED0TpQAOAtb6FzRgWLYeSxW6E4MOAtUqhwoYi2SbKiWMRVkkzyuxq0+0QtK1bU9n0qRUKnGyradxj9/eLnaCIRrvja0SG+RqtgooViTYQsgk/JCBAVUAA1hb1qAQWwvyrstdY4tfGwrImxseCL2mpVbn9bxxc3YlfweokTdi07uVy4wpbf887P2OJSiYrg6WkKqgyyfcku7b5YpAJcpXumWqUsjp076Qr+9u3Atm30/y+8wN9q0jhC2Iqd40S1C8XtvYFNLPHCq7Vrbk5+3wdx7HioVmvtO1be+lbgd79rDTGRh2IRePhh4OKLa7879VR6v2gUP4pFEiaOO45v2xs20OuD99gdOEBTavyKvZUKhYq7jcJtNZYvb38RxW/x5bd1QKQNh9HTQz+iOT+8Qo0uSNUxPEy5NY2/czpvOjrUt8+IulDCFtAMQ3xioxZQNDGhzT8hI8KueAzDtWEnoPj9ctjqAsrYWLMbI0hk2gfcwr5EBRTTdC56w3SheJ132SyF9Y2OkjAwO0vnVblM/xXdj4cO0RjP7dtpGsXevdSCMTlJ/x+EeFatOrsd5ufVhI+y1pwXXqDtsQwRWVGoWrV//RaL9q91lSG+PE47HveIm/sEqJ1DolSrVFRH0YL49NNUFG3YUP/7lSspbPUXvwh/TUHw+OPUumO9EptI1FwoVvbsIVGC90vy8uX0X95w5vvvp4lH111H+SGyjI9TodQuX+YTCSq82uX52GEY/h0kfu8vm3Wxdq24uMX7WO18zMOkv7/2fmTFMOx/D6h1nzCGhsRaXMLMP2GIioFaQNHEBC2gBEFjBkS57D0hJ5fzd9WzUmkuqgoF/2JGsVhv4y8UvIvRYjGcFgYvisXw24lkBBS3NdqNM3YTJ+bnnc+1ubnwikO3Qtk0SQxghe7sLP17dLQmqojAJio5ZcYsLAQjoszNuW9zctKfc2Bujq7KHzyo9rjZnaNOImO1qk5443kv8hJQeIOFZdp4Dh5UL/5Wq3xtJcx9YtcLfs01wB/+4M+VFRdY+04jr3gF8NBD9ftfpH0HoH0n0sbz7LPARz4CvOc9wM0304/M+O4DB6LNP1HN0BC5I0SvDLcSXV3+syb8CiiyU85kXAKdnXzFJs9tVE4gake6uyn3xIm+PntBK4ipd4bR7IJxI4oWLlHRxpqBogUUTYRoASUorEUuz5dyp7wLXuwm8DDxQ+U0Hl5BIg4uFJkvw35xmjLiBM9VeWvBa5ruuRRuLRfVqn3LSRC4nXdTU2pHbvO0meRy6kUUnn156JC4MFoskpC0f38wgbSNAoppuru0pqfVtEHxiIturjnWjsdzDEWFq6mpYF4b27cDn/gECSBuj719O3DRRfZ/Hx4mceWnP1W/vjBJp+l5nn9+89+Gh2mU8Z/+VPsd7wQeK6yNx4v5eRLMNmwAzj2Xptb09pKg8sc/ir1mo57Ao5qlS+m/7ZyHoaLwisqBIgtPgc6zX6zTgDT1dHSQQ8hLnGsMlO3uDm6azJIl/GJhFK95USGTnXsqXGQajQ+0gBIU1qKYV0zwMz3Crn3Hbi0yyAgoss4PlYV1FAIKIHYceW5rvY1bQZ3LiU1ZCRo7oadQUNtSVSrxuw2YiKLCzVEsurdeMWSmwkxNBeucanS7pdPu+6RcViMu8L4PWo+nadJ+HhujvBfeTBaRNp5MhjIsguCFF4BzzgF++EMa12vHvfdSm47blbirr6b7i45fl+E3vwH+4R/Ub/dPf6J94fQ8G9t4RCbwMHgn8WzbRqN/2Rfwnh7gfe8DPvlJ4PbbgS9+kf+zqJ0ElN7e2vFpdweKX/wUb7294YsQXoJNKsU3WcjPiNx2Z/VqvuPa0VETKoFg2ncYySTf9js7W0MYY2vs7FQ3sUijkUALKEFhFS2CFh2AYAWUYpG2J+KS8body2KYnaUe8v376Yvvnj3qClzVE0R4US2gWFtT3AQUnuKSt/BXgd15NzGhNqBzelpse6pEFBFBQXR/+50i40W1Wn/e8YhqfsNkTZP//W1ujm576FAtz2ZmRtw9xLMfgw6NfeEFGkt8/fXAv/4rFe5WKhXg7ruBK65w305/P/Dnfw78+MfBrBOgffCznwF33EHrVt3y9oc/1EY023HGGXQu7t1Lol4mA6xZI/YYGzbQZ4jX2rduBU47zf7+N95I7VJ79vA9Zju18FiLus7O9g2SjVpACaJdw4u+PvfjybtPtIBiT1+fmINj6VISrAwj+POBJ0y2VY4pE1B0+44mYtr00zEGsOKxUuEv5HnyRZwIUkAByM2Rz/Nb+d2ey/x8fYBoOk3bZkWMivafqNwngPukEyu8RaX1dk4CSrnM37YQlgul8bxLp9W2dlWrcm6WfJ6KtPl5KrLn5mhts7P0wyN4iAgoIoJILqfWheUEE1Dyeb5zsFCwfx7MITI+7n7OFwr87x25HL0/TE35E7q8Xg9Bh8aaJgkRmzaRM+IjHwFuuqm+MH/iCbJzH3OM9/auvJIEpR07glnrLbcA//VfwBe+QF+4xxjZ67sAACAASURBVMfVbX90lF6rdqIFI5kELruMXCg7d5KYIVrA9/VRQO3+/e63e+YZ57WkUsBJJ9Gx86JSIVdQOzhQUinKP2EYRvyKKrcQThFUFF+plLzAFHb7DkD7zi2wk2efMJdCO7uTZFm2TOz2hkFjjvv6gnd+dHZ6iyit0rLHXFJaQNFEjBZQgqJUoi9XogWjqtYX1QJKJiO+tsbHNU36Un7okHsxpaLIDstlYUe1yvcc3MYXN8IKXicBRcSJMTcXjjvHutZKRX0I5uysfPGbzwP79lGhtX8/FdKjo/Szd697S0c2K7b/mIOLh6DdJwx2PomIadbjl83WO0QmJylTwomww5wB97HI2SytO8ispokJ+mLMJs6cfjrw/vdTewjbV3aji53o6gLe+17gW99SK7JVKsB3vgM89xzwuc/RF+1168TDnN344x+pTcmrULjsMuDBB8mpI5p/wvBq45maoteZm2i1aROfgDI5Sfb4uAkNMgwPN1vi4/a8hobER7Paoar4knGhyIwvVoWb04GngGa36epqjXaPsOjvlzunnKb1BMGyZe45K3F7rTvBREstoGgiRgsoQZLPi39Bly383QQUFUGUxaJ4MKO1aCoWqVDl2YaKyUFBhG+KIJptwntbNwFFBL85JJUKFSEHD1KhYXfeFos1UYc3/FOEIJ00R46QqGIn9MnkgfAKI2E5p5jTReS5LCxQUf388+SiaHSIzMw4t/pEIaAAzfs9n6f3oT17gl8TC0G1FqUXXgi89a3A5z9PgsXu3fQ7Xi68kEYb/+pXatZYLgPf/Ca5KG64oVZgqRRQqlXggQfsp+80smIF7bM77wxOQNm6FTj1VHf3AK+A0i75J4ZhL0zErahiRaCfdanMTpARUKJo32G4OV94QkytIkvczo0osY5lFyWsIFTDAFatsv9bIhFciK1qDIPEOy2gaCJGCyhBwmuPtzI/T19mRYpN06wvZEyz+eq/CseB6NV+JoTMzdHVfl5RQ8Tub0eU7hOGagGFhZHa7ZdiUfzYzMyIX8UuFslBtHs3tRHs308ihtO4aHYeLiyod1ZkMmqcVW6k0815KdWq3HPhEUaKxeCfE8M0vZ1gdszOup83hw/bv/6iElCYYMuyTnbtCs/lw9p3GrniCvq54QbKBBH5ImgYwF/9FQW9ujl+eCgWqaUomwX+/u/rC6K1a9UF1m7bRoXb+vV8t7/8clqbaIAsg0dAcWslAigMMpfzFprbRUAZHLQvoOJUJPf31wp4PyKEysJLpviNon2H4TbOmGe/WM+HOJ0bUTIw0DrFfHd3fc4Ro9WOpXZAaWKAFlCCZGFBzgnB7OW8QkC5XN++YfeYYRVmjY956BAVVaIhjX5cKFHmnzCKRfdCs1wWPzecHBcy51i5TAIIbwFdKtFV+8nJ5ikugPPxyuWolUE1YeW4LCzQ82YC5NycnJNmYcFb5AqrsA/y8UyTnDtWwbZUii7QuVik9ezcGd4Ib8bOncAJJ9j/7Y1vJCHkz/9cfLsrVgDXXAP827/5C7/93vfoS+jHP95cAKh0oDzwgHt4bCPnnAN88IP1eRwirF9P7zl270mmSQLK5s3u20gkSIjxcqG0S4CsU1tMZyffZJYwsGZM+BFQVGY9iAoohhGtgALYP34q5f1cDKNeZNM5KIQf90kUjIw0v9+3Sv4JQ597mhigBZQg8SMCVCp0hXF83LvIdWvfUbEWP8iKGbLrjUP7DsPJYZLLyV09dtonsuJYLsd3lblSIbHFTRBychhMTakvnovFcMWGQoFCTXM5f0W412shbAElKCoVcpwxoSmq9x5GOh3clB0nWMviccfZ/90wKPtE9sv3a19L+/X+++Xun8nQWOH3v9++cGIOFL/7LZMBHn0UuOgi/vukUuRCkSWVonyTXbua/3boEP139Wrv7fC08bSDA6W7272oj0Nx1bjGnh751geVrQqia4hifHEjduITb/uOtfWpq6t9pzTx4uTcijOslcd6LFvNgaIFFE0MWOTvfi1AOk3FiFuR3FjY2t02LqICL7JFVxzadxiNAkqpRMLJgQNqHUF+tpVOu0/bYI4Cr+NRqdifY35asZzwO1JXhnKZnCh+zi83AaVcjq7NJQgKBTpvRMYXtxMvvkiFdVDW7mQS+MAHgB/9SDybCqCRwmed5ezyGBigwsCv0+vOO4HzzlMT/CmCUxsPm77Dk4GxaZN7K5BptscEHjtLv5U4FFd2QqOsCyXKFp4o808Yvb3NwodIgKyVOJwbUWEYrec+YXR11a89DiKpCK22Xk1bogWUVqBUqk0Lafw5cKC5oLS74h9FC48frGONRYhD+w6DjTOuVKj1RaQtSwS/4tjkpLOzYmyMf81hFMqVSvitGAy/YlAm47yNOJ23qmDjjRejgMICZIPkuOOoNeYHPxC7n2nyTf/x28ZTKAC/+x1w9dXy25Bl40Z7BwpP/ol1G7t3O7fsTU1RIRJ1S4YfkknvVqmoi+RUCliypPn3g4Ny21MpoIi6D+JwriQSzeOMRfNPGCqcAKoCfcNmcDC8ANggGB4mIUI7iTQaKfSrppXI55t/crnmbAW7grpYVD8FJUhMU1z0KZXi5bRhY5v37KEwwiDaCBoDg2UZG2t2zIyPi4kVYbRqzM621nlspVp1butqRwEFoGlGi1VAkQ1BFeGtb6VA5yef5L/P9u1UtJx8svvt/AbJ3nsvZcBE4dCwc6BUq8Czz/ILKH19lLuxf7/939sh/2TJEu+WEl4BZflyOuePP55aqNaupVaB5cv9ta2MjNgX2X194ttNpdS20Ijkw3R0iF05D/Iqe6OQwyOgBOFA6e+PhytHlFZ2nzBYK0/UAqlG06JoAUUFQbQpyOJWULeaC0W0II9jETo3F+z5YR0V7IfG8M/paXKmiBC0gGKa0bTvqMTuHK1W49V6pvGPW4CsSrq7KcfkO9/hF1LvuoumAHld+fXjQCmXgdtvp7DcKFixgtZgfb/Yu5euGosUPps20dhuO9oh/6TRiWBHRwefUDA8XBsx3N9P/162jMZu2zlIeEgknFuMZAJZVYsSiQS/iCIiFPT2BissNG7bS0BJpeyfp1/3wtKl3i1kcWRoKD7hyn7o7KwPZ9ZoNNxoAUUFUYckWnErqOPkzuChHQQUUUSLaZWiWLlMeTvpdC1sUYRcLlixKJuNbpqLKuyCYt1aezStBwtOXrkynMc780wSa37yE+/bptPAli3ApZd639aPgPJf/0UiRhguHDsMo9mFwjN9pxG3kcjtIKDwtrN4tWr09bm3s8hOVBoedneMiIoMQWQS8bZxiIg9AwPBOgM6O2vHK5n0fg5OwpNhyK+zt5e229nJJ+SFzdAQvb7XrKk5qUZG6JxsRdHHCd2+o9FIoV85KoiTgOImksRpnTyIrDdu7TuyLCw4t3nYodpVZA3/lCHIdo2ZmeC2HRblcvN53S7TdzQEyz8Js7f/ve+lccFuoacATe05/3y+Ym7dOrkWHtMEbrstOvcJw05AOfVUsW24TeJphxYe3gwPL+eGV0hwb6/ctBIvt1B/v9jrLCoBRcQtw24r6u5IpcQcNkx84jkubiKJbA6KVYQQEST6+53bulTS30/Prb+fnGvDw/S4y5e3h/tEo9H4QgsoKpAJPA1qrKZbQd1qLTzVKr8o0g7uE4DcCCIiRNwcGUGJdNVq+xxjq2Bimrp9p90IK//EytAQ8L73ATff7DxuvFoF7r7bOzyWsXQpfWaInp9bttBV7TPOELufajZsqAkopRJlxYgKKEcdRcJt43uPaba+A6Wzk78IdSuSk0m+QFdRF8rQkHdxn0qJFfBBjJzlEVD6+vjFEDbqWNTd0dcndnsm6MhO4GHIOFB6euqPW08P3zoSCXK2jYwA69cHO85WZ4NoNBoXtICiApkgzyNHglmL2zpa0aHBW5C3S3GdyYgJcnETxYISUNLp9mlzsRak2WxzCLSmtdm5M5rWlT/7M7Kb33qr/d+3bqUihXc6kGFQEKhoG89ttwFveEP00zU2bqRx0pUKHZPVq8VbPpLJeiGGMTvLN8EmCFRd/RYRE9yK26EhPnFANAeFN5tBZBpPVA4U0fYdhkgR39srLrgYhnyALEMmB8XOccLjQhkZqZ3/nZ0kYK5apTYYGKDnq1tbNBqNC57vEIZhdBuG8ahhGE8bhrHNMIzPvvT7Yw3DeMQwjF2GYfxfwzA6X/r9dYZhbDcM4xnDMO41DGN90E8iFogUjsUiCShBFIRujoRqNX6OBS949mu7tO+USiSIVCp8x0nEoRMWQbXwpNPBbDcKcrna8W0X4U9DlMs0dSvoEcZ2GAYFyt59NwkHjfz+9+Q+ERE2RNt4nnuOAqgvvJD/PkHBgkxHR8Wm7zSycWNzG8+BA9G4TwYH1eVFiIgJqZSzUMArjHR18Rf4/f38t+UVxXiyPmTg2SavyGMY9cc3SAGFjTP2cn50dbm/Z4g6Zbq67M/h/n53Ua+ry3mc9THHyI+1tkO7TzQajQc8EmsBwGWmaZ4O4AwArzEM4wIANwL4mmmaGwDMALj2pds/CeAc0zQ3A7gVwJfVLzuGiDgBcjkqkkVGxPLA44RpxxyUVp/MwrBmn/AIEXETTwAqIFWLdKVS+7W5sOejBZT2Yt8+sphH9QV8eBh417uAf/mXemfT9DSJCBdfLLY90SDZ224Drr5a/RVhWZh75Jln5AUUuxyUqNp3li6NRkAB7NslurvF2ih4HTsrVvBvs7OTr/0jCPcJwBfAyuv2Ye071vvyCJ7d3XS/ZFLMWeQlWgB872Ui73duThO3LJ0VK5z3RTJJTpQ1a9Q4R4JsDdJoNG2B5zuNSbDqpeOlHxPAZSCBBAD+A8AbXrr9/aZpsurvYQAt3CQsgIgwwW47Pa12DaWSt6sliJaPIFsQymXnnn6Ank+7hHBaRQKe8ymOAgqg3oXSTu4Txtwcnbut5gjTuPP889FNnmFccgkVKbfdVvvdffdRi4+osLN2Lb8DZf9+YPdu4BWvEHuMINm4kYSjPXuAk06S28amTSTCWD9bowiQ7e6uBVuqQDQPxE6kEG3L4RFQBgbEnyOPCyUqAUXEGdH4PHjdHdb9JRIkOzjofR7wbI/3eHV2uh+rwUH7FrXBQb790N9Pr0u/bW6qx11rNJq2g0uqNQwjaRjGUwAmANwNYDeAWdM0WeU8CmCtzV2vBXCHioXGHpFilhWYMgF9ftcQhIBy8CA5aoLCTUyYmAjuccOmXQQU1S4n1U6tOJDNtufzWuxElX9ixTCAD3wA+N3vSNSoVMTCY62IOFB++UvgyiuDCeqUZdMmGql87LHyRdHQEBV9ViEpCgcKu3LP3AZ+ET1OjQWsYYgLKB0d3nkgIu4TRtQCiptLRKR9x27fiAooIiIpzznA6+7hcX545ZzYnVPJJE2+4aWriwJmZV/vXV3xcdBpNJrYwiWgmKZZMU3zDJCb5DwAJ3rdxzCMvwRwDoCvOPz9/YZhPG4YxuOTk5MCS44pvLkVplkvYqgczRqFgFIo0NX0IF0CTgV5Oh2/EFVZ8vl6J08+H42bSAUqHSj5fHyfpx9Ms31azzQ1opjAY8fICPCOd9BUnieeIGv8cceJb2fVKvqM8vpsmZigx3n1q+XWGxTr11NRtnmzv+00tvGMjobrQEml6gtLvy1iiYR/AWVgQO5Kv5sLhddp0Ehvr/daghJQAGcXCm97EeA8qcdrfyQS9bdR2T7Ie54Yhvfz7OjgE7qWLKnfD8uWiQsaySS9PkVDowGdf6LRaLgQahY0TXMWwP0ALgSwxDAM9om1DsD/uzxjGMblAP4ewFWmadp+8zJN8zumaZ5jmuY5y0XU5TjDU+gVCvWF8dycOhs/z+OXSmrdIqwNSaUQ1IidgFKtBjfJKAoanUim6e3kiKuwwCP+8NLOLo2gRpm3Cu02fSidpkybtXZmzAh45SupKPvmN+XcJwAVIitWAIcOud/ugQeAiy5Sl8+hio4O4MwzgbPP9rcdq4CSTtNnqKj7wg/Dw/VFpd82HhmXUDJZL0K45VW4MTjo7Fbw813Qq1iOQkARmdLktP6eHneHS+PfOzvVOShEQ2zdGB7my3NJJGr7rbtbftKVYdDkLd5pTgydf6LRaDjgmcKz3DCMJS/9fw+AKwA8BxJSrnnpZu8G8KuXbnMmgH8DiSdt1F/BAU/rQuPVedNUJz7wtnSoKryr1VqBm8sFF1BbLDaLPlNTwbYNiaCiELZr5XLbn5WKezZMlPCIP7zbaWcBZTGTydDEmHbKt9m5k0JL4zL+0jCAD36QXBgve5n8dnjaeB56iDJW4sj11wPHH+9vG1YBhbXvhDWm2TCaxQq/RZ6smMBcBqmU2GheK8mkvVgwNOTv6r9bq4yM40YEJwGF1wHROH2n8W9u7g67c0GVi0KkDcbtMVMpMSGEiS0y7VyNLF0KrFzJf3vtQNFoNBzwfNNbDeB+wzCeAfAYgLtN0/wNgE8AuM4wjF0ARgD8+0u3/wqAfgA/MwzjKcMwbg9g3fGER5iwKyxnZtQU4WELKLOz9SJGWC6UYjE+hbVpUqCgH8HANO3bXty2Gdf8E4YKASWbbT+XQivw9NPBvpYB4PHHSTzZsiXYxwmTOATINrJiBfCFL/i7+u4VJHvwIL0fn3CC/GPEnfXrqU0plwt/hLFd0Gdvrz8BR1ZMYMU6r5vACbti2q8TeWCAjpNdK0+Q7hPAXkBJpfiFLqf2HYZbUW8nvEQhoLCJQYZB+3tggFoJV6+mdhqR8yWVovcdVWGuQ0N846ZVunc0Gk1b49nAaprmMwDOtPn9i6A8lMbfX65maS0IT9Fod5tymb6AylpiARIVeNsm3ASUmRn6sOG5ito4RWh2lnrmg7gCm8vVrnhNTsan/eHQIWrDMgz5nvhs1v7YuZ1PcW3fYagQUOIikrUy995LX7AvuID/Pt//PvDylwPXXON9W1kefZTGyj72WLymtvhh507gqquiXoV61q2j4+TEww/T+dXOhUdHB3DMMcCuXSQmhSmg2AVvJhJUXMq+z8oKKKyg9du+NDBA5wu7ADM0pKZYHhigyUuHD9eLwEEHG9sV536m7zTiJIikUvbPLQoBxTAorNnvBByG6laaoSHvtm/tPtFoNJzExGvcJpTL7lfMq1XnwtfvSGORHBW7NRSLNOpxbIwECi+y2ebtWFt6VMO+KGaz9BMHJidrx21uTr6lxun5FIvO51PcHSh+g2Sr1fYZTx0ld99N+RS8pNPUouBWMPulUAC2bgX++q/pv+0wyrlSoeJ648aoV6IerxYeJqC0O6yNJ8wRxj09zq0dfgpMWUcGW49fR4dh1AsMKlo1GMkkuReOOaYmbATtQLETMfxO37HiVNg7nQNdXf5bzGTcGKrEkyAYGvLeJzr/RKPRcKIFFNW4OQPcrhblcv6KTpGCulCod3BMTdGXf1bIT056r8VJ8AnK+p/PU5EiO7GJtf0cOgTs3g1s3+6v9WZmBhgfr/3bNOVFMLdR1k7ri7uAUir5K4zn5tQF0S5W5udpjO22bfz7cvt2mlhy+LB/UdeJp5+miTBr1wJHH03ra3VGR8lBKDP1Ie6sWUPng13m1MQEvSeffHL46wobJqCEOcLYbeyrn2JP1pGRSIjlSbjBXCxLlgQjcPT3UybR0qXqWkEA+yK80YGSSvEHKvf3exf2zHHUiFtuil83hcp9FgeSSXmhSqPRaBrQAopqZAUUwF/BItLSUa1ScVssAi++SKJCY4E1NuZcdJVKzu6AIMNkDx8WL8oPHAB27Kh98Z2aovVVq3S1ffduct7Mz/NvM5Ohvv9GpqfFi/5y2X1/OQlZcW/hAfydB7p9xz/PPAOceipdCd27l+8+TEA580zKKQmCRx8Fzj+f/v/cc4N1u4RFXMYXBwGbhDFhkwn/8MPAeee1d/sOY9MmEvtyOfHJHjI0ji5uRLbYS6X8OQVUXaXv6yMhR6X7pJFkkgRAkXYaNwyDcj0aaRRQeEQRBq/oane83Y6FXwGk3QQUwD3ItqMj3g4ajUYTK7SAohovl4kb6bR8aKaoI2F8nFwnTgV6oeDs9vAKvQ3KhSLaupPJ8O3TbBbYt48yDKan3W+fy9FVfbvnX6mIF/5ez8kpM6cVwlVlBZRSyd2Vo+HjySeBM84gEeXZZ/nu8+yz5CYIStioVEiYOfdc+vc559C/45JpJMtTTwEnnRT1KoLDqY3noYeACy8Mbx09PSRkrF1Ljp+gsy2sjIzQ44c1gccrqLWzky8YsxGZ+wTFUUeFewz94uRmSSTqRUTeiTOJBL9TpVEs6e52Fy61A6WZ3l7n802372g0GgG0gKIaN2eAV1uMnzYQUQGFp0XCrpWHZ43pdDzaL0SFnEKBnCU7dtBEjX37SGiam6s5dvbtc39uXiFljXgJBXYiRCu4TwC5ljSVY70XM6ZJrTIiAsr8PL3mjzuO7vfcc+rdZNu30xVnNnFj7Voq6PbsUfs4YTI1RfvXz6jguGM3iefIEXIvnnpqeOvo6aECaHiY1rRpE/2sWxd8zgVQe6ygMQz39h2GTNEXxn7ipZVaJpJJOu+cBCj2e1FRhFeMaxQ0vI69n33LJum0I07iViudixqNJnK0X001hQIV2I2TaMplvpDR6Wm60iViiS6V7PvTVTA2Bhx/fO35zM15ux8qFRJRZKYK2e07GcplfyGkpRL9iLT2ACSyzM3xW4a9BJRKhbZpvWrSKqGb+TwV8nZfECsVEliKRXrNMIGqVGp9N4Jfpqf9jwndv5/syKtX05f5b3+b9rnb+8r27TSKlln8N22iNiDWbqOCRx+llg+GYZAb5fHHSbhpRe66C7joovb+Ar5uHbUpWXn4YXIQhWl7t7sq3tlJPwsLwWdDXXZZsNtn8I5d7eujz1oR2rUwDpqREfpu4vS+3NFBn3kDA/zfYUQEsGSSjh07x73um0jU314ENpK4HRkcJPG38XtGO79/azQa5WgHShDYOQR4r+SWy+IuhiC/NBYK9b3vvA4ZWSfNoUPy02yspNPRFeJTU3y3KxT4nmujk6NVHCiNU6dMkwQjlkuzbx8d7+lp+n2xqPaYHTkC/O//TW0GrSTKfPrTwH33+dvGU0+Ri8QwqBgbGfF2eWzbBpxySu3f55yjto3HNJsFFKC1c1BKJeCee4DXvCbqlQTL2rXNLTwPPxxu+w7g3lYQhpBz9tn0EySGwZ8LIlP08bTMtGP7hh86OmrOBcOwP9eY4CUSJC3qIGLHmzckVlYUaOfjbxcm29ERr9Y2jUYTe7SAEgR2Ba5IO8PUlJiIEPRVtyNHKKujUODPIcnlxAv9uTlq3/A7AheItg0km+UTzHhzPhq31SoCClC7Kjw+Tm1Re/cGL26Vy8CvfgV89KNULPz0p8BnP0uujLjDBMtbb/UnJD71FAXBMnjaeLZvbxZQnnhCnbvtxRfpS2rjCNgTT6TnzCs8xomHHgLWrw9vKktUsAwU9rqdmaHX0+bN4a7DrbBrlwJoaIg/F6S7W9yxyeNA6e/XgZpWli2rd2TYnWsdHXQbXgEllRLPf2GCCG/rjxZQ7GkMZ9buE41GI4gWUILArngWyRKoVu0nHthRqYRTeIyNiTtjRESMcrk22cavgLKwEL3IwLOveAWUxv0R9xHGViYmKJx3cjKc4NsdO4CPfYzyP/7xH4F3vxu46SZyPdxwA/D974uHEYfJoUM0NWL1ankXSj5P7RbWbAovASWTocc+/vja71asoByGxtYNWdj0ncYv/skkcNZZwU39CZI77gBe+1r12+XNUAiLwUEq+FhI9iOPkBMjTNGiq8tdLGgHAUXEfcJuL+pi4Cnae3p0qw+ju7tZFHESUPr7+duvZfJr2H1476sFFHtYlpL13xqNRiOAFlCCwK54Fy3oZ2b47nPwoHMmxj33qCtKikVxV8fsLP/V64MHawW2XwElDiGkc3PuDgLT5H+eLEsEEM+7iVpICiqbp5H5eeBf/xX46leBa66hNpg1a+hvySTwutcBX/867Y+/+RsSJ+IQdNzI2Bhd7X/724Gf/1wu72bbNsoTsX7JPuUUEpecRKznnqPMk8arzirbeB55pLl9J4jH8Ytp8jmkdu2i95qzzlL7+KmU/ajUqLG28Tz0EHDBBeE+vldR10rTXJxYskTelcBDR4e3Y8UwaF/HVUDhnXCjChZ4bcVJQAmyfQegz7LOTn6BNZUSFxZl7tOKWM8jLaBoNBpBtIASBIVC/RfwYlHu6vv4uPvfp6fdA+QefhjYulX8cVVRqZBt36sInJ6uD3zN5+WLWxZgGzVu04pKJXKo8IoLpllzMIm4T/btA6691l+Ybiuwdy/wkY/QF/6vf52modjZm4eGgA9+EPjkJyn486MfJSElTqG8o6NUqG7cCBxzDHD33eLbYPknVgYGgFWrgN277e/TmH/COO88NcLGwYPkctm40f7vZ5xBAo/qqT8y/OAHwBe/6P36vOMOyj4RCfzmoatL7Ep2WLA2nnSa3tcbz7Gg8RJQWr3oM/5/9t482pKqPP9/9pmnO3Xfnht6YlQQQRxjBGXQJCbgFIkT+X71C4kax0ScEs3PZYxZaBxj1GA0DtGIJk4owQlFFAQZBBqkRWm6BZqxB2h6uLd+f7xnr1O3Tg17V+06p865z2etXn3vOXWq9qnaVbfep573fVV4sJ6EjVvJRBSp14vbhaXRSFecPi3tdnhwHTbXajXz4vFA+qB9ctJOZLPdzri7TzSTk716NuMgvhJCBgoFlDyYn18YlKV1VOzeHZ3msW8fcNdd8Z/fulVs+cNk3z4J2qK+x/79/d/Dxp0RpCgtlAERUObnJRDbvVuOxa23Si2QJHEsiHaS2DhKvvY1edp46aV22xolDh4EPvIR4EUvErHIJJg47DBJ73npS4Gf/ERElS9+MR/n0pYtdnNZO1AA4KyzgP/+b/uUrWD9E82jHx2dxhMljUY2xwAAIABJREFUoGzcKHMu2MLWliuvlGKxUU+/220RV66/Ptt2snLVVeKU2b9f5kQUO3eKsHTKKe7H0GzKfgoWOhw2WkC58kqZX4MOsJMCwajinqNCGvcJYBcgmxwz7YwoooCi68MMSiybnQ1/PaqIrOn8y1K0NFi/IwkKKOGUy/Jgge4TQkgKKKDkhf9JapanqmGB9vy8dDKJEwr27JHaKEkiyyCYmxOXQLAuiOfJDXnY90groBQhfUczNyfike44c9996euX6P1hKqDcc48UAH3Na4DvfW+0utDY8PWvy5Mk2/aipZIEgX/7t1JgdudO4LWvBT70IXm6npXdu4GPfhQ47zzgRz8y/9y2bT0BZeNGSav5znfMP79jh9R4Wb++/72oOigPPSQOkcMO639PKUmvyZoKGNZ9J8iwu/E88ADwsY/JOfPGN8pxu+KK8GW/9z2p52Jj2TdFB66DTlVIYs0aEdJ++tPBd98BzAK7UXWhpHWfABIImgaBpvVPgF5R1KKgVE9UHESNoMnJaBEp6zxLk76jsS0abCuILBYBBZBrLAUUQkgKKKDkhT/QzSKg7N3bK9ynueuu5EB661bpDrFjx+DqUCRx110LBZN7740WStIIKHv3FiMFwE8wnSsttik83/ymiAonnigpQ7femn0MRWPbNhFQ/uIvst3or10LnHuuCB6HHiqCSrBlqymeB1x+OfD618vN94teJOKhCXNzvSKymrPOEieR6by+9lrguOPCb7If9SgpCBuszXPzzeL+iAoKsgobDzwggbe/qG0Yrrv+2DA/L8f/1FNlP01NSYrXv/5r/1yYmwMuvjif4rFA74a+07EPlvJk7VpphX3rreEOpzypVMye7o+qgDIzky2NwDQINHGV6AC6aGk8/rS2vAQUXf9lairafQJkdzplEVBsSSq+HGQxCSjNZj4iOCFk7CnQ3dmYoQMez8teyPPuu3tB+K5d0bU1/GzdKkHRxITZ8oPiwQflJnz37vhOQ3v32gsPRXKfuGbfPklXMRFQ9uwBfvhD4NnPlhvCU0+VgsLjxNycFI194QvtulbEMTEBnHkmcNpp6WqP3Hcf8N73Al/6kgTfr3gFcPTR5gLKPffIU0//Deyhh4rw8O1vm61DCyhhtNviIgiKaTfcIKJBFMccIw6qtLV0dMpHUnC7fLnY023Fvrk54BOfyNYt6KKL5Lx5wQt6rx1+OPDiFwP/9E8LBayrrpIirxs3pt9eFP6gtVQq1s390qUivh177OCDLFOBYBQFFKXig3UTTAPyJJGmVltYe6dIAoq/vohpG98kKhURr1aulAdOhx0m19wVK+JFEqWyzbVBCiiAncBWJNF2EBSt1hQhZCRYZFfKAaID3SwFUTUHDkhwtn+/eS2C22+XG4JVq4qRxuNn714ZX5xAMjdnJzzNzxejeGye7NplNpf+93/lab7u5HHyyVJQuGjunCx8+9tyo/fMZ7pf96mnSvqGqdvH83pFaTdskLbJRx0l761bJ2Kmiati+3YROIK88IXAN76R3H754EERQ+KKe4al8dx0U3j9E02tJkHz1VfHbz8Kk/QdTRq3y+c/L5/53OfsxwaIwPWVr0gh4mDQdOqpIoJ9+MO961VerYuBXgFPTZHSeEol4JBDipu+A4ymgJLVfQKYBeQmQX8w0C6KgFKpLPyOado3hzE5KalTOl3HRpRJO9eCItUgMN1Xi8l9QgghGaCAkhcHD4rg4SpoveceqXtiam+//fbek5RhF5JNi00az86dxUlVygsTh83+/cC3vgWccUbvtZkZcRj85Cf5jW2Q3HUXcOGFwCtfmc/TspUrxV3w05+aLX/ttVLs9e//XsQO/411uy1BsImI6S8g62fNGmmV+61vxX/+1lt7Lo4oggLKww9LikpUdxxN2jSehx6SosmmKR+29Va++10RaM4/X0TmG2+0G9++fdK56WUvk+MexiteIS6+//kfuQbfcUd+LXyDAUzR0njOO0+6XA2avAQUl6kgaYr+unCfABKUJ6WVmAgEWQSUPAv4Tkz0j93FscsiXKX9voN2nwDmTjYKKIQQYkSB7szGkH373Akoc3Pm6/I8ucnXDhTbji9FwUZAGef0HY3J8b/0UmDTJhHP/Jx6qhS+HHU8T+pSnHnmwlohrjn9dHGVmIzny1+WWifBfa5Zv94sjSfKgQJIaslFF0nqWxTXXJPcWvboo6WwsXbX3HyzzJekQOJxj5OW6LYtny+9VMQ7Uwv5YYdJKo2J6HvDDcAXvgC89a0iUj3vecB//Zfd+D77WXFVnHxy9DLVqriLvvlNKTJ72mn5OR2CAUzR0niWLBmOoJNHCk+pJIKlKzfAqlX2AbkL94kmSVAw2U4wuLcRUGZm3KVTBglrDzxsASXtNWAYAkqlYra/KKAQQogRFFDyZFhFTe+5R258Jibkqeq4O1D27UvftWecmJuToqp+94nm+OOlaO/WrYMfl0u++1051n/8x/lu58QT5Ty6/fb45a6/XkSNpzwlehlTAcXfgSfIypWSBnPBBdHXlGuvTRZQmk0RenS9kKj2xUEmJ0WQjWqDHMbll0tqzEtfav6ZUkm623zyk/Gund/9Dnj/+6VYrxbSnvY0qat0001m27r6anHVnHtu8pP52VnZ1h13iLiWF2EBTJHSeIZBqWQe6Nq4AnQ7XBdBf7ksf3Nt3CTlcvrOO2EkOWCSxJCwQr2lkrlQ0GqJ+83ldwLknAgbe7WaXXxaLAIKEC5C+SmVipOyRQghBYcCSp48/HD2ArJp0B14AAm8ilYDxZQDB8yeeN93X/5jGQWuukqeMoUVBC2X5Sn7KLtQ7rtPHAevelX+OeTlMnDKKfEuFO0+ef7z48ezfr0UTk4izoECSJpJuSy1Oq68cuF7u3aJUHrkkcnb8afx3HRTfAFZP49/PHDZZWbFna+4QsSev/1bcXjY8Od/LqLOeedJfZOgYLR7N/Ce94jr59hje69XKuYulHvvlSLEr3mNeerFMccAn/qUuDDyIkxAKVoajyuUMqs5YfNU3Kb1rg4WlyzJ/uRdf97GUbJsmVsn08xMvFMnaVxRnzUJqrWApMfhIi1JExf4Z3GhVKvZzqs0x67RGN657O9iFAbdJ4QQYswY3pUViD17hrPdrVt76QQrVizs4jNqJDlLDh7sb/O8GPE8qdFwxhnRAcQpp0hx1GAbWxfbPnjQ7TrD+MIX5Om/Fgfz5tRTRTCIEkFvuEHm3lOfGr+e9euTnSw7d8p+jHMbdDrAX/0V8OpXS+rJP/6jCAEAcN11IjqY3NRrAWXvXrlWHHFE8mcAcXhs3Qr8wz/Ei5ZXXQV8/OPA294m392WWk2EkPe/X1xAr30t8OMf9+bZ+eeLQ+jUU/s/e/LJcr27+ebo9R84IOt49rPN3Dd+8ixSGtWqt2hpPK5Ytcrse9kEdkqZu1C0oKCUjCUL2lVgWtOkXu8V+XZJXFpjngJK0FWxZImb76dU/BzJIqBkda+kuRYMy30CJO9LCiiEEGIMBZRx5Le/7QWZ7bbcKIyqyJAkoDzwQPYuR+PAzTeLCyGu24lu1ZimGGgcn/sc8M//7HadQQ4ckHE/61n5bsfP7KzUDLnssvD3v/xlCfST3DDLl4sIE9clSrtPTJ6eH3usiAsbN0ptjq9/HfjFL5LTdzRHHSXXiOuvl65BprbtmRlxfhx2mGz3Bz/oF2avuQb46EelLknWNr9Ll4rb5g1vkO/49rcDH/yg3Oi/5CXhn6lUgOc+N96FcsEFEuCdeWa28bkmzj0wbmk8U1NyDOIKHmtsAzvTwDZY7NlkLFH4xzgzkzyGVavctOEN0mxGCzhJ53kWASVMyFi6NLtbq92Ov742m+kdHVkFlErF/hgOU0AB4t08FFAIIcQYCijjiN+BAhSzlbEpcQKK50l3DNJznyQF86ecInVEXHHttVIo9Prr83Wh3Hij1AeZmclvG2Gcdlp4Gs+NN4oL42lPS16HUiJcxdVB2bYtPn0nSLUK/OmfihvkF78QZ5GpgFKvi3Dy1a+mc2C88IXA3/2dtFZ+z3t65+B11wEf+hDw5jeLyOKKo44St83JJ8sce93r4uf5ySdLjZRbbul/73vfk7SlV786nwA2C3EBzDil8dRqPafExESyYyQvASUoDKxYkT410C8+KBVfB2RyMl3HHlOWLevfp+Vy/H6Oq3+RxoGimZ3NJqIk1e3I0s7YRfFem5o7Sg1fpGg0or/3sMdGCCEjxJjckQ2R3/0OOPvsYY+ix4EDYmH3F6Mc5VbGjzwS3Z541y736SijyB13AFu2ACedlLzsE58I3HabFNvMys6d4jZ47Wtljm3Zkn2dUVx5Zby7Ji8e+1iZZ7/+9cLX/+u/zNwnmg0b4tN4kuqfRLF6NfCOd4gDKKoNbxiPfrQcL9P6J0E2bADe+15xmbzxjcCXviTtgP/mb8zqsNhSLouYdd55yR1ZqtVwF8qWLeKWetObBvsk2FT4iAtUxyWNRympiaPPG6WSg+S8BJRgIJm2oGyl0r+uKBdKqWR3noaR9P3K5f6UpLTpO3p7cXM4qYXy7Gy64LxcNkvRSZvG46Jgqk0azzDrn/gJO9+q1XzbUBNCyJhRgKv5iLNixcK2oMNm+3Z5AuW/YRplBwoQ3XWExWOFH/8YePrTzW4IazXg938f+P73s23T84CPfEREm2OPlX/XX59tnVHMzw9PQNGBu9+FctNNIkCZuE8069bFF5Ldvj26A08SSkW3UI7imGPkhjmL2FGtAmedJYViN2+WVJu0goxrnv50cfXobkO7dkndk3POSb+f02LalSRJGBqHNJ5Vq/q/Z1zqTL1uH3SaBLVR3WWWLDFvmawJEweiXCizs9mcD82m2fimphYKbmnTd0w+byJGphH/JifNXGJpBRQXDhQbAWXY6TuaMAGF7hNCCLGCAkpWymV5ClwUh0cwfQcY7U48APDQQ/2vPfwwWxdrtm4FNm0yX/6UU6R+RZSzx4SLLpJuKGedJb8/5jH5CShbtshNclyBxDx5xjOAn/60Nw917RObJ3YbNrhN4cnK0UeLc8TFjfPGjcA737mwI86wqVaB5zxHXChzc+LQecpTgCc/ebDjaDYlKE8KBE1a9Y56Go+uexKk1YoO0NPMT5OgNmp7aQrKRokPQRdKtZq9O03cvgqyalVvvmRxoADZBZQ0KUtJziRNpWLvJqlU3JxLoyigVCr9Y6GAQgghVozw3ViBWLdOniAXgdtv7+98MeoCSphQQvdJj9tvt+tMs369BDM/+EG67f32t8CFF0otCi0iHH20OCyi3EJZGJb7RDMzIwLRj38sxXrvvNMsXcrPIYfIORiWcrZvn6RDpUkfSEulMtx9OghOOUXExfe9T1xML37x4McwMSEie1IAWa+biSyjmsbjr3sSRpQLxdYNApgFtXGCQqtlV1A2aoxBF4pf0EhLu20uFtRqve3HfcakNkfc502OUbVqF6TX63aiiK0LxYX7BDAX0YtQ/8RP0M1WpLERQsgIQAHFBevWSS2UInD77eEOlDvvHN1Wxnv3Lhz7gQNiyR9HbrxRWtSasnevBN8rVtht5y/+AvjKV6QjiU0dmX375Gn+2WcvzOVvNMQFs3mz3ThMuPJKqd0yTE4/Hbj4YnE0PPe59i0sazURSO64o/+97dtlX6YtYEnC0bVQtmyR9KJh7F/9FN1VnY8snWKGRbDuSRhR6Ul5OVCSAmibwqdxY9QulE7H3FERhS70ahP8z84mixGNRrJ4F+cQMj2vbFwotulqtg4XF/VPAPO/A81msYpW+91sRRN3CCFkBKCA4oIiCShhKTz6qeWePYMfjwvm5xc6G+6/f3TFoCSuugr42c/Ml7/jDkn9sA0ON26UmhD33Qe87W3mDqVPf1o+e/LJ/e/lkcazbZsc+6wtcbNyzDEiNG3fLvU10hCVxpO2gCxJ5pnPBD784eHUD/E/dU+q52AawExMpHNlDJOwuidBarVwF0GawM4kPSNJhGi1zNwFYQVk/SglwqltWlDUmJSSbZpe73VKUtwYTeZTlOBgk5Zi6p5Syt5pZSPkAO4cKKYCSlHSdzT+fWzifiOEELIACiguKEoKz549UqchmAqgb6LGIY1nfh544IHhjiVPNm+W42Ra3yVMMDOl3ZauKSedBLzlLVLnI4q5OWmVe911wP/7f+HLHHss8MtfphtLFD//uaSaDLv2Q6kEvOQlwCteYe8+0axfHy6gDLr+yWJCKXdPm23xB4FJaTw2QsEgUr1cuXWi6p6EEXTXVCrpO4Mkfc4kgDYJ4k3Eh5kZN3PQLzDZrC+pdo7Jd1AqfJ/ZCAPVqtm4O510889mLC5TeEzEh6IJKEDPEUX3CSGEWMO+ZS7QDhTPG66Sv3WrWKXDbpZWrJDA/PDDBz8uF2hB4cEHgYMHhzuWvNi3ryeI/OY30mo2Cdv6J0GUAv7oj6Qby/veJylEZ58taUG33irpD7feKq2Pp6eB178++mbwsMOkO83One6e+F95Za9Q7bB50pOyfX79euAXv+h/ffv24acoEfcEUzYmJ6Xwchg2QYx2oeRRbwiQoHDJkuytzut1u8LPk5OSajo/L79ncdpUq8D+/fFjMxlPklg/yODTf92t190VUTfdz/X6wn2qlP0xmphI7liY9m9Hux19fgVxJaAAyXOtXC6mSNFs2temIYQQAoAOFDdMTckfogcfHO44tm6NDqZ1HZRRRd8s3n//cMeRJ1u2iHhy1FHxLW/9ZHGg+DnsMEnpuf9+4GUvA970Jiky22hIN5OPfUzaFscJcOWyiD6uXCgPPCDCZFFa42Zl/XoRvILpZ0zhGT9KpX6hMSqNp1q1f+KepwtlZib7E/NSKbnuSZByeaHrI0tgF+cSK5fNnC3tdrLzbVDOgmp14Xdy5aqyaRMd3Gaauh5JtUqq1fT71LSQbLnsth5S0lwqovtEMzlJAYUQQlJAB4orVq+WQGhmZnhjiHMjrFol7oJR5eBBCe4feWTYI8mPW24RJ8iaNfJzEp7nTkABeik9u3Yl12yIQqfxPPWp2cfz858Dxx+fPmWmaExPy832vff2umPMzYkzrEgCSrVqV1iY9BOWNqHTeIJPydM4LfJ0oczMZA8wV65MF5jNzIiDDchPQDF1H5RKcrziCpYPKvgMBuGuBBSbuRfcZhphoFaT9US5ULI4F7XTI+kewXVKX9LfpyILKFNT6dPkCCFkEUMHiitWrx5+IdmwDjyaUXegAKNdw8WEzZvFfbJxo5kDZedOsbu7FO2UkpuqtKloj3mM1ElxUeT3iivGL7UlWAdlxw7Z38Oq0xFGp1Os8YwiUfUzwjqxpN3Xtp23TJiclCC3XE6f5jA9bdfFxk+73QvosqbwRGHzveLqoFQqgxN3g+4KVykotq2F/aQVBuJcKFk7FZm4UFym7wDJc8C2xfIgoXhCCCGpoIDiijVrzAvJ3n23pEN8//vSBcUFnicdWeJSeEZdgNC58ePI/Dzwq1+JgHLooSJ2xeVVAz3HUZEq6K9dK26hu+/Otp6HHhIXzmMf62ZcRSEooGzfLvusSDQa9l0wyELiBJTg+ZpWKOh03Hfk8QsfadZtW/ckiFIiwJRK2QLduM+6ElAG2Q0pKFZEFXW1xUa883f/yVLXI2qf+sWztBRNQKnVKFIQQsgYQgHFFTYOlGuukWWvvRb4678GXvMa4IILJGUhrSX7nnvkZijq5mRmRqyteRUeJNnYtk0CopkZuelauVLSc+Jwmb7jCqUkjSdrO+NrrpHaJ6PWsjWJoIBSxA489XpyrQISTbMZHTSFdePJkgbi0oVSqy0cm63DQNc9ydoxa3o6e2pMXNBqE0BXKtH7YVDXpmYzfJ+6cInZigl6m1m+e60Wvl0Xhcfr9eT0s0EKKEVO3yGEEJIaCiiusBFQbr0VOPlk4A1vEOHkda+TJ3/f+hZwzjniJLElKZhWqteJhxSPm28W94nGJI2niAIKIGk8WQWUK6+U9sXjRpgDpWgCSqMhT3JdFlpcTCSlIfjfz+q0cOlCCaYC2q43bd2TII1Gf0tjW+KCWlvhIep4DkpAiQrCswootZq9e1FvM2taSvBBT7nsJtVFqWTRwnV6YpxYV+T0HUIIIamhgOKKFSskHcek+OKWLdL1BJAb6I0bpdPJO98JnHoq8OMf228/rgOPZtWqZAFl1y4pbEkGy803SwFZzYYNyQJKXM2bYfKYxwA33JA+5erAAXGgnHii23EVgdWrpbuQdoIVTUCpVOSfUnShpCUp/cmfxuNCcHDhQlGqX0BpNMwD7FLJbS2mrOuK67RiK1hFHc9hFZDVuBBQbHHhQAH6ry1pi5aHESdauO7AA/Sul0HStHkmhBAyElBAcUW1CszOJgsUe/dKuk1U4PuUpwA//al9EU6TYHrFivhCsp4HvOMdwBe+YLftxc7cXPaiqUEHSpKAMj8vwXcRBZSlSyXo8DstbLjhBvleWZ9CF5FyWWqe6HbGRauB4g8K+fTUnmo1ObD2p/G4CMJduFAmJ/ufpJdK5uNrt93WYnKxrjAXimkLYz/1er9YEWwrnBdxxyCrgJLm8/W67L+saTD1+sJ1uEjf0cQ5UFyn72jC5kKjkT2djRBCSCHh1d0lJmk8t90mTpGom7jDDpMn8LffbrftuBbGmiQHym9+I8U7v//99MHvYuQDHwC+8530n3/gAdnv/kB6/XpxFUW5ge6+W0SKouZYZ0njGdf0Hc2GDXJ+6XatWTtPuMQfrLGQrD2m+0wfc1cuhqwulKiuOabCTBHdSmFBbdoAOnhcB5m+EyUmVSrZAvQ0+6JWcyes6jnTbLoVNiqVaHFokAIKBWhCCBlbKKC4xKQTjz99JwylgCc/WVwophw4IAF10pPspE48P/wh8IxnAC9+MfCxjzGVx4T77gN+9jNpuZsWnb7jvxlut+WpXJRjqKj1TzRpBZT5+fEXUNatEwFFu0+K1EXJH3hUq7Sg22IqhumUhSgBxXZOdDoyr9KkQuiaN1HvmW6/aIQ9pBhFASWOLC6UNJ8NS/VKi96nLt0nmqj5nFd79rC5VtSHG4QQQjJDAcUlq1cnCyi33gps2hS/zJOfDFx+uXlayPbtwLJlyTeHcQLKwYPAZZcBJ50EnHKK3Gh8+9tm21/MfPe7wNOeJsf14YfTrSOYvqPZuFEcS2EUtf6J5phjpA2xSU0gP5ddJk/TV63KZ1xFQBeSLWoHHj9FDIyLSqlk/tRZp/FECRRpgsqJCbkmHHGEXOtNg8Uo9wlgFgRWq/kFpllw6UBptRYGyYMSUJLmU9r9rlT6FCRXLo56XeZ/HteYqHk7KAdKljbPhBBCCg8FFJesWZOcwvPrXwOHHx6/zOGHA/v3J7ex1Zi6EZYulSKx+/b1v3fttXLTvWqV3Fydey5w4YVSr2Wx4HnARRdJCpMJBw+KgPInfyIOkl/+Mt12gwVkNXF1UEyKBg+Tdltamt5yi/lnDhwA/vM/xQE1zqxbJ5227rijWPVPgP6b/jzTeGxrURSdTsfO/TE7G56CoZSIGmmdSboe1+GHyzVkejo61aNUihdr6vXkNJGiimxhAkEWwcH/PQcRHJvUWUn7fdJ04MmDlSvzqRMS1fp5UAIK3SeEEDLWUEBxiRZQopwjO3cCe/YkP13XaTyXX262XZP6J4A8FVm2TNJ9gvzwh9JaWbNmDfDsZwOf/GT2AqmjwMGDwMc/Dlx8MfDZz8pxSuLqq4Hly2Xfn3AC8Itf2G933z4JpMPSupIElCI7UADg2GPt0nguuUTm3aMfnd+YikC7LakWV19dLAdKrdYfdDSb+QgdlYo4rMapyKKt2BTlLqhWZf+4ECbabRHpjjxS/u4EA+6pqfiuJHFpRppRElCyBNA6PatWG4z4ZxKEZxFQikBe4whrZ1wq5XfcKKAQQsiiYozuXgvA5KSIDbt2hb//619L+o5J0GDTjccmnWPVqn4BZc8e4LrrZJt+zjhDlrWpx5KVT39a0jgGyUMPAe9+t9Qz+cd/BB7/eOBrX0v+3MUXA898pvysBRRbsenWW0WACbsR1gJKcJ3794szaPVqu20NGps6KHv3Al/5CvCSl+Q7JhMGERxt2ADs2BEuoAyrqGxYoJxXO+PlyyV4GqdOS67cOjoYc1kbolwWB+Lhh0sK2dRUz+mSRFIwWFQBJSw4zxKwa4dRUdJ3gPTfp4gpV64Jzts8RSMKKIQQsqiggOISpeI78WzZklz/RHP44T13QhyeZ5fOEdbK+PLLgeOO678RrlaBv/xL4FOfMnNkZGXHDkmhueaa/Leluesu4C1vkae0b36z3By/4AXA//5vr0tKGHfeKeLGk54kv69eLTeltt2LouqfAFKsr1LpT6Patk2O4yDaaGbhyCNlrElpbQDwjW+I4LJ+fe7DiqRUkuM4iLSa9evl+C1b1v9eo+HuBtzGph8VVLkOkOv1XiHK2Vm36x4WwRoZWdDndauVT9DX6Uh63ZFHmokBccs0m/EOljwpl0W0Wr5czqeggBU8HmlaGPspleLr1rjG5BpQKqWbI4tBQAkKUHl+53K5d60dVItrQgghQ4MCimviOvEkdeDxo5QE50lpPJdfLjexy5ebrTeslXEwfcfPUUdJR5TPftZs/Vn4n/+RtI+owqmu2bwZeNvbgD/8Q+DlL+8FAsuWSWHYr341+rOXXAI8/ekLb17TpPHECShAeBrPKKTvALJvzj5b3D1xYtTOncC3vgWcddbgxhak3ZZzc8mS+Nahrli/XsSasOCzWnXnQmk2zZ+YRwWGruugrFzZ27+1WrHaOKfF5XfwB195OnRMxYS4+TNo90mp1Eub3LRJ/p5NT8s8CgatwZSNMKHBVlCZmBiMA6XRME9vS9uOeNypVhd+z7y/s55/bF9MCCFjDwUU10Q5UDxPBJSkArJ+dBpPFDt3ijvkVa8yv9kKduK58075/bGPjf4F2UglAAAgAElEQVTMi18swsCNN5ptIw333w/85CfAK18p4wkrdOuSH/8Y+Kd/Al79auBZz+p//7nPFWHpvvv639u/H/jBD4DTTlv4uq2AMj8P/OpX8QJKWCeeoheQ9XPaaTKP3/ve6GN64YUiWK1YMdixAXLerFolQpW+wS6V8g+STjgBeMMbwt9zKaC02+ZBbpSAUi67c8R0Ov2CzDi4UPISUNK0JXZNXM2PQQsojYYIJmFugrAx+vdlWABtmyY1KAHFplWwrbMiSweeUcN/3RqUgML0HUIIGXsooLgmSkC59165cVm61Hxdhx8utSGiuvFccIEEnkccYb7OoIBy6aXAU58a/ySu3QbOOUfqg7zvfcBVV0nR1Tg8T7aze7fZuL72NXHBLF0qKRS2qTA27N4NfOITwN//PXD88eHLzMwAp54qwX2Qn/1MAu5gMeBHPUrq0Zh+5zvukAAp7iZ+lB0omj/7MwmSP/xhEY383H038KMfAc9//uDH1WqJ6yTsnMz7KWKlEp0qVKvJPxepAq2W2XdRKj7AcOVCWbmy/7VWa7SDjmbTbXDmD25LpWI4dMJEA5fCmilx+zlJQAkKDeWy/b6tVvNPWapW7YQpWwFlMaTvaPzXvry/NwUUQghZNFBAcU1UCo+uf2LzNLFUkm48YS6UK64QZ4Jt2sOyZeKqOHBAgtlLL41O3/Hz+McD//IvwDHHSGrLOeeIgLNli4glc3NSJPeb3wTOPx94xSskPeatbxURKI6dO8XtccYZ8vvGjbKuvLj0UuDEE5NFiDPPlH0fTHnyF4/1U6tJB5lrrzUbx+bN8e4TIFxAsSkaXARKJeCv/gp48EHgc59b+N4XvygpVC4LZpowO7vQdRJkmDZsfSPuQrTQAkqSQ61ej782uRjLzEy0KDTKLhTXKU5Bd0ARCu2GHbd2e/DumCwCSvCzulZF0QQF2xbWtuNfDOk7Gp2OmWcHHk21Gt0+mRBCyFjBK71rVq6Uop9Bh4ZN/RM/Ye2Md+8G/u3fJN3F9uapWpUbtHvukfob9boEkiZMTIhw8A//IHUtOh3g/e+XcZx9tjgMtm8XseU975ExHnWUuD3iutN885vA7/1eryPExo3R7Xuz4nlSIPbUU5OXnZgA/uAPgC9/uffa7bdLsdsTTwz/zOMeZ57Gc8styQLKihXAI4/0aojs2SOCVFjx0SJTrQLnnQf8/OfAd74jr/32t9Kl50/+ZHDj0IWe/XU4wnBVB8X2/KxUetvN6jxoNHrFDZOeiiaNs9HIZvvXtSuimJwsXiBrikuHSLncH4DV64MrXBpF2PwZRvcdlwKKXt6VAOYiQK9U0rlibIL2UT3P0qC7Jg1CNKpU6D4hhJBFAgUU19Rq8qR1x46Fr6cVUI44Anj44YVpPJ/+tBSYfdSj0o1RtzLWxWPTBIqrVgEvfCHw0Y9KYPyxjwEf+ABw7rnASSdJsKSUOFF+8xvge98LX8+ePSJonHlm77VNm/JzoGzeLP+b7rs//mMRRLZtk9+1+BJl4z7+eHGgzM0lrzupgCwg+9DvQtm6VTpojOJTrokJcSV9+cvA1VcDn/+81JoZVFvQSkVqx5i0bnVVB0WfB6b4A75mM5to4b+ZTwp2TQL0LIHm7Gzyd7FJb3TBsmXZzyNXqVaaqH00bBdK2LkwDAElLvj3i4+auBQeLXi4+h4rV2avLWLrPtHYiCKLSUABxCk1CAGlWqWAQgghi4QRjMJGgGAaz/y8pNukEVCCaTxXXw3cdBPwohelH9+KFeKkuOIKqaGSBaXCW0hq6nXgr/9aguXbb+9//6KLpMuP/+n0oYdKcds8CslecokUNjW9SW21JLXoi18U58dll8W7V5Ytk2AnSQC67z5Z35o1yWMICiijlL4TZOVKEdw+9CERpU4/fTDbrdfF2WQTLGVN49HFYG2CquCNfhZ3g2sBJW2gWamYpehMT+dvs9eUy3KuZi1c7Dr1LGquTEwMr10wIMcl6OYYdCpIqZS8D4LzR/9eqfR/Vr9Xq2UXFbTTIVgXy4ZyOf18sjkWiymFBxicgOJaTCWEEFJYKKDkQbCQ7O9+J8FH2mDoKU+RNJ6HHgI+/nHgL/8y29PxVauAb39bnB4mT+OzsnatpPicf/7Ceih798o4nvOchcvXaiIshAkuWdi9WwrgmtR88fOsZ4lb5LOfFedK0pPyE04QoSuOm28GjjzSTMjZsKHXiWfU6p+EccQR0oHmVa8aTDeIiQkRT2xvorMKKDMz9h0vgstmcX34BZRGI16cMAkgO510T8dXrDBzepRKg3OhLFki21uyJNu1NO/6Jxqlhl9M1kaQywOT8zc4x/X+DNuv/teyHsdmU45Ro5H+b6q+XqTBVAAaRC2QolGrDaamVak0/I5ZhBBCBgIFlDwICihp03c0Oo3n/PMlOH/MY7KNb+VK6QpkKyRk4eSTgaOPXlgP5eKL5busXt2/fFj73qzo4rG2N8uNhqSaXHyxmWPihBOAa66JX8YkfUfjrwlzxx2jL6AAwHHHSUHivJmakv2V5um9DorSoFSvFamNcBMM9NrtdGOvVPq3GxX0lstmYyyV7APnSsUu/UQLG3miVC/I1TVx0pBHzYM4sa1IaTxFS9/RhAkoSiW3Pc76ffzOg6VL7R0t5XK242u6vcWWvqNZrN+bEEJILlBAyYNgCs+vf51NQNFpPNu3Ay99afbxrV4tN3xPeEL2ddnw8pdL4dDvfU/Sc77xDeB5zwtf1nUnHpvisWGcdpq04z3uuORljzxSOvc88ED4+7fdBvzkJ8BjH2u27TVrgPvvF8fOODhQBkWlIm6rtCJIuZzeku1P3ckioCiVLrgLe+IatR6b4MI2yJuettv/5XJPeMqLqan+WjNpnC95OELiBJRh11jQ54JSw+lSlcaBolS4mBhcNmsaj19cUsr+ujM9nU04NB37YkvfIYQQQnKAAkoeBB0ot96aTUABgBe8AHjnO93cuK5dKzUoBp2vW68Db3yj1EP59KdFaIgSAzZtcutAsS0eG6RaBZ7/fLOb3EpFnDVhLpRf/Qp417uk2K5p96NyWQrHXn213AAPuuXvqLJ8eXa7etrzzS8CZBFQgHSBuk3XFJvrgG0tjjRP1ZcuzdcKH1aPJc1cyUNASRrDMNN4tEjQbA6nHksaAQWQcypJQAGyuVCC51CtZt4prVTK7i4qlcxSBenEIIQQQjJDASUPliwRh8VDDwEHDkjhz40bs61zYiK91TyMQXe80KxdC/z5n4sbJMp9Aki3lN/9Dti/3812bYvHZuWEE/rbGd94o7R3fvWrgSc+0W59GzZI1yRb98lizclutdzU90kjoNTrC4OxLDVQADn3bZ9OhwkolUp4vQ8bAaVUMhfwms10Im2tZlZ0Ng2dTviYymW762ulko8LI2muDLNIpXZkDSN9B8gmoIR14AleG9PWQanVwgWl6Wkzx9D0tBtBykQcoYBCCCGEZIYCSh7ovPrt26VmxfLlg2vVOgqcdBLwwQ+KyySKWk1s0CaFZLduFbEqirTFY7Nw/PHA9dcDBw/K79ddJzVsXv964HGPs1/fxo2yDlsBZRBFgouGUmbdjUxIkzIR3OemDhSdbhCkVLIL1uNSj8KCX9ugyvRpeRan1LJl+RS7jBNmJifNg+i0BXXjCAvqg9Rqw21hPiwBxbQYc1Sx2OA5GDa30nYWivvbvnJl/PHy10rKisl5zBQeQgghJDMUUPJCp/FkLSA7rqxdm7zMpk3JdVDm54F3v1ta427dGr5M2uKxWZiZkZvnW24R8eYDHwD+5m/SFwDesEG+67p15p+pVvN7kl9kZmfdPWktl+3EzzA7flgL1TDiAkSbuRtX/DZMiLHdV62W2WeyCCilUraWsGGYBP+rVpkJFHmk0Zk6lYbpIuh0hvMwwDTwDxNGwlKOosS5NH8j4vZHpSJdqOp1Ob7l8sJzc2rKXTrU5GS8AFcuD7cVNiGEEDImLLJ+dgNEF5LduZMCSlr83WeiuOkmual/9rOBd7wDOOccKbir0cVjzz0337GGcfzxwBe+ANx5J/DWtwKHH55+XYceKoGdjQNFFzKt1yWlbDFQr5vXHjCl3V7YfjuOqICoWgXm5uI/GxdAT04urKsUR5xrpt2WeTQ/L79XKv3BpP/9KKangbvvjn5/YiJ7i+qpKSmeHOcus8EkbbFWE8fgXXdFL2PrCDLFRkAxnY+umZoaTlpgFgEl7FhF7etOB7jvPvNxAclpVRMT/cKM58k55tJNVK3KeRlVvJzpO4QQQogT6EDJC53CM0wHyqjXvzBxoFx6qaQEPf3pwNvfDnzmM8DnPtcLVrMWj83CE58ogdjb355NPAHk5vfcc+0cKLrg5LBqFgwDUweBDTZpPFEpUyYBYFwAbdMyN265YAeVsOCv3U4OtpIcGK4cGlm6KPmxaae8dGl86luamjQmmAoow6yD4upvSrstLkTT72yTehIUUcJElSgHSr1uty3TFuBBlOp3o7ggrg04BRRCCCHECRRQ8mLNGnFP3HmnXdDrklZrtC2769aJCHXgQPj7+/YBV14J/P7vy++bNgHvfa90PXr3u6X2yaCLx/rZuBH45CezFxDWnHqqecDhD7iH0XJ0GExP5yMWmQoXzWa0nT+rgAKYdWBRKnm8/n0UFozX68kCSK0Wva/LZXfdYhoNN3V8bDr76BpWmzaFH8+8UgFHIYUnC6WSpDZu2CB/H1st83SgLAKK7TI215Ci1TYrl7OJuIQQQghJhAJKXqxaBezYISkXWa3saWm1RvumqV6XOiJRhWSvukqCHH8Rvqkp4O/+TsSXN71p8MVjgwyr4KM/H34xCCiVisyVvNZt8tQ/LtAflIDSaCTPOX+AGBaM1+siEiQJDlGOjslJt/M+azvqUimdCNNsyvVl9ere9pUavoBSq42Wu7BalWO4caOk1/m/p6k4mbUVeJC4+WRzfIfpBopiZib8+42q8EYIIYQUDNZAyYtGQ4pZDrP+SbMpbYCHlS/vgk2bgNtuC9+POn0nSLkMnH22fHbHjsEWjy0K/mBbF0Id5XkQRrkswVKlIgFyHl1bNO028Mgj0e9XKvGuDZOgLilIrNVkLu/eHb2MiVimC1oeOBDtQCmXRWiJ29bkpCwXrO3iusBquSwBuGkNmCAzM9mceEuWyHfdsUP2WV6uPlMBRSk5RnHzsUisWBEtlAzLgRK3r3Uaz/79yespmgMFkPmxdGl/jaJRfphCCCGEFAgKKHmyZk322hdZaDZH5yY7io0bw+ug7NwJ3Hwz8IY3RH/2qU/Nb1x50moBDz+c/vPlcn8g3emMvoDSbIrLRIsmg3T3tFrxxSVnZuLH48KBAsg1ZcuWXnvsIKZP9DsdKTYZfCpdLvcC0KmpeAGlVBJhwV+0slrNJ41qyRLZju0crtfddKKqVMSJklRcNy1RLayjGBUBpdWKn5PVak/Mi1vGxnFjsh+TRLBORwoYx6FUMR0oQO+81CLQoK+XhBBCyBiT+BdVKdVQSl2plLpOKXWjUurvu69vUEpdoZTaopT6klKq1n293v19S/f99fl+hQLzmtcML4jXN6aj/tRJO1CCXHaZtCYu6g1sWmyKhUYRln4xDmk8S5fK96jVBh8MxO2/ZcvEIRGHiThimnoQ1wLc9Il4pyNBeHA/+gWVVit5TME0HtNCrWmwbWvcbosA6zKFMq95ZzvGUbnumaROJc1Z279hSQJKpWKWnpa0TL1e3FQqpRYKh0zfIYQQQpxhcje4D8AzPM87DsBjATxLKfUkAO8F8M+e5x0G4AEAL+8u/3IAD3Rf/+fucouT6el80wri0EH4qAso69cD27b1P6G89FLgaU8bypBypV7PfrMblkLRahX3Zt+EpBSZQWw/zK1x6KGSopC0b0ul+GuBzRPiTifcVVGrmQfi7XZ4EB68XiTtcy1oafIUUFot2dcm+2l6Wq4dRSiinTWlJIxRCIibTTMxOGmZPAQUk3Ukzf0ipu/46XR65/gozBdCCCFkREi8E/WEPd1fq91/HoBnALiw+/pnAJzZ/fmM7u/ovn+KUqMcuY0o+qZ01G+c6nUJmrZu7b22bZvYq489dnjjyousAkqpFO6WKJWKf8Mfx8zM8AWgYPvfTZvsus3EBYK2AfSKFf3H08a5FNXWNzj3TL6fXk+zmf/1ZtkySYuMmw/LlolLZ9jzBZDjapJClEZAKcL3i2PpUrPlBu1AMd3XS5bE7+NRuJ4uWyb/j/qDFEIIIaRAGD3yVEqVlVLXAtgB4BIAvwbwoOd5OhF/G4A13Z/XALgDALrv7wTQdyellDpHKXWVUuqqe+65J9u3IP3omzt/TYNRJZjGc+ml0rq4CE+XXVOvZ7PnT0xEP6Ef1TQepRZ2WhrE9sLQ+296WlJDbIMSlwKKUiIS+I+1bepXWHHloABSqSTXNNECSp7uEz/Vaq++lN8loJS8vmLFYMZhwvS02XmX5vgXOSg2dZ8AvZpGUdiKci4cKHq5OBfKKAgozabMv1F/kEIIIYQUCCMBxfO8Oc/zHgtgLYAnADgq64Y9z/uE53knep534jL9lIS4QamFN3fDaqPsio0bewLK/Dzwox+Fd98ZB3RdirTHLM4xkEdxz0EwOTnYYDFqH7ZaUkg0KFyY4lJAAWSu+OuCuBDIwgKtpFSGWk3m1qBTrGo14JBDek6gdesGK7QlUSrJPimXk0XRtMe/qJi6TzRxYovtuZ9UkNfmgUKUC6VaHR0Bf9myYotthBBCyIhhFQV4nvcggB8AeDKAaaWUvhNZC2B79+ftAA4BgO77UwBi2lcQ5zQaC2/6inyjbcKmTb1OPJs3y832+vVDHVJu6BvdNC6UUim+ZXOrNZqdGAYZFJfL0durVs2KYkYRFySnFcxmZiRID6vRYkutFh4sttvJQefq1cNzujWbUoumaALh1FTvfEtyY6Q5/kUtJGvjPtFELZ+2e4wrASXKhTIK7hNN1HlNCCGEkFSYdOFZppSa7v7cBHAagM0QIeX53cXOBvC17s9f7/6O7vvf9zzPczlokkDwZnTUnz6tXw/ccYcUkr300vF1n5RKvWOVJhjudOKDDaWyd/gZNI3GYAPjTie/Lj9x52EW8WH1ajfuj7g5Z+JCIQvxC3FJ7qBxcqDYuk+AaEEi7byKO59s93WYC2WUBBRCCCGEOMUkSlgF4AdKqesB/BzAJZ7nfRPAeQDeoJTaAqlxckF3+QsALO2+/gYAb3Y/bBLLuAkojYa0ib3tNuCKK6T+yTjiD4jSBEcmBT9HrQ5KFsdHGrSDJ4/g1DSFxzbAK5eBlSvTjclP3PhsiuUSmUf+IL7RiBblSqV0gl0RBZQ07hMgug5KHgKKrVgZ5kIpqvuHEEIIIbmTeCfhed71AI4Pef02SD2U4OuPAHiBk9GNCkW7kQ0+HSva+NKwaRPwpS9JPZQ0TzhHAX+wYHvMlIpP39F0OsDdd9utO2m7U1PA/v3Aww+7Wy8gwsCgCpPq7elzp14H9u51u/5qVQLl+fnw9zSdDrBzZ/hyUbiw6MfNuWpVxLeHHsq+ncVAMA1MKdl/u3f3L5s2fUs71vbvj1+uXgf27Uu3DVuyXJtbLWDXroWvuRZQkuqjRLFkiZyTnif7fRz+phJCCCEkFSNYEKGAuHwalbXeQ6XSf9M56g4UQIST664b3/QdIJsDpdMxK2rYaLgpflitSreTI4+UoqppC6vGMT092JotExM9ISKvACksWFZq4euVynBSBJK+M10oZjSb4X8TotxfWYp8Jx2zUknOzUEE/GndJ/7PB3EtoKS99vldKEzfIYQQQhY1FFBc4EpAWb48ezHGsBvYcWllXK8DT3zisEeSH/4gp1y2C6xM3CdA70l4Wtpt6XxyxBHS3UHPq1rNTRqJn2Gl7wD5BZxhAWGlstBBUqkMvlaNSecnU5FuVMhLEIoSwaOOaRYBJelvj+4CtHx5+m2YktUZGLZ/0gooUfs0y77WtVCYvkMIIYQsaiiguKBWyx5YLFkiN7lKZbuxd12MrygceSTwrneN99O/YNBuE8TbzJm0Asrq1cCGDRKUhaWMLFniruBrpzNYm3zQ9ZHX+RK23mBQVy4PXkAx2dejWIQ4jtlZ98JytRp9DkR1SsrTgaJT4JrNfNtMuxD9gnVQSqX0xyfqc1mOt3ahjPPfIEIIIYQkQgHFFVmCvclJYNWqhb+nZVwFlFJJXCjjTHAOmT7pbDbtAoM0IsfUlJkjZPVqNy6FYbpPADNHRhrC1hl8TQfag3R7mF4fxuXpuz5nXAtCSSmYYeJlXgJKu71w3bOz+c0pV8Kp/3hk+ZuVh4ACyHVpXM4BQgghhKSCAoor0t5UtVqSo+5/ot9up7/RjQoIWPSu2NRq/a4O0wDCNgis1+0CiVpNhBHTZbOm8lSr5ilJrgjb3qA68QRf08dmkE+6Tb/ruASPOuB32ZWqVEoWv10LKHGpfkExp1yWtLs8cCWguHKBKRX+NzSrKFqpDLYuEyGEEEIKx4gXxigQaQKLRgNYt67/hkx3VHnwQfv1Rd3cmd6MmnR1IO4JC2BN51SaILDdlq4SSZRKwKGH2gl6MzPSTSOs44gJutbAoKhWw/d1vQ7s2ZNt3UpJ5w5NUgqPv6Vtq5V9+6aYCiiuRKWJiV6R4Pl52Ufz872fd+xYuN9cowUzlw4Uk6LH+hrt77CUNaiv14EDBxa+VquFf7fJSTk3XXbM8nevyorLNLpKBZib63+NEEIIISQDfJTiCtvAolqND0zTpPHEBQOmN6PT0+6eJi4WJiay35iHzR/TOZUmCDQVXVauTCcOZimGPOhuL1FuFxdiQfBcSkrh8e+zQdYbMf2uunVuWiYngfXrJWWx2ZTt6u4tnY68PzXl1hkSxJ/y5ir4V8qs5XawjkywgHAaws7PuLHoWluuaLfdra9WW1iYOgth1x8KKIQQQgjJCAUUV9gGmWvWxN8gdjr2VuG4QMAmGB90/YlRp9PJHvCFHR+TTjyNRrqgYGIiOXA0rXsSRrWaLpWnVht8ulneAor/PA7riOU/xn5B1R9M5km1anetSSOoaeFk5UqzwDjPFK7gul2INe22+bHyb89FnZ3gPE1KJarVks9rG0HE9bHS16WsAkrYvqWAQgghhJCMUEBxhU3b2VIp+aa9VLK/MY17Ym3S0UA/HXXhqFhMtNvZ3QJRwXpSEJ82+KtWpSjv+vXhY6/XReTLwvS0feePQdc+iRNsbIWFMMIK/AavE1EOFP35vLEVimwFFBvhRJNGQLZZtx8XTh+bee5aQAkej6mp5H23ZMnC41EqyX5ZsQLYuNG87XGp5N4p1WrJ3yIX9Ur8KMW/a4QQQgjJDAUUl9h0TTF5wmcTTJbLyYFQUgDTaskNsVLJ3SSIUKnIcc/DgQIkz6ms2+10JGDasKEXWJZKwCGHuAlgZ2ftli9C8Vg/WZ6CawdJMGgLBq5+10lw2azBaa2WnBJl+x1tBJRGI90+VCqfVMIwQavRyNadplKxOw8rld4+cSGgBF1NpqlEK1bIdX7tWhFTV68W8aVSkTljIja4TN/RNJuyX7KuNzh+iieEEEIIcQAFFJeYBhamQdHEhPlNpMmT6iSBxT8uCihm6MApbSoNIJ+LCuBMRC8XtNviFNi4UcQTV91Wmk3zANrEmeWaJAElSxqPPjZxAkpYC+OwdaSlWk1O17D9jvW6+XUpy/jzENOi1pll3tm6rPzbc9UqWx/DTsd8nc2mdOXRjg8/piJ6HiJXVAFcWyigEEIIISQHKKC4xHXXlHLZfFkTASUpkPVvq1YbvBugCChl57zwBxBpb/rjAti4OZVFtIlCp3C5xDTA7HTcP81esUKKNU9O9q+7Xk8+J7IIKPqcjEvZCb4XFNKq1WxBdq2W7EKx/Y5KmYtiWVKQWq1szpAwogL+LAJKmqLHrgUUfZ0wcZ+YkpQKpFR+gqeL70EBhRBCCCE5QAHFJTYpPKaY3pyb3MjGBT3B7hDA4iwmqzuBmOLf72mDibgANu69Qbs10mIaDLkWbqpVOZaNhtTg2LRJajvofWqyvWE7UIBsIoTe1tKl4e+nrTVhcq1TKtvYdTt3V4Sl72jSip+tVrr912yKOOHSgVKvu61HUirFn7vtdn51arIWkAWSaw8RQgghhKSAAopLarXkJ+jNpt1TVdNg3iSgiQsG9Q29Hxs7+LgwPW0e8AcdDHk4UMK6tmTd3qDRrWqTcJ0OsHTpwvNRB4Tr1vVcKUmkFVDq9d55nlVAyXKc9fqr1XAnkE06jh+T602jkT3AdimgxK2rXE6XtpYmfQfouTdcuSIaDbfuE83MTPT8KHq7+6T6QoQQQgghKaCA4hKlkm/CbYOhSiX5M/W62c1h3FO9MDeDUovLhVIuS5BlGtgE91naYpRJQXrUnBoVBwqQHGjqwpGuSEpBM01/SusS8J+zYSk8OijNW0Dxn/NLlvQHw2mf9JsISy4EvjjXiC1JAb/t+VQuZxMR0oovYejCr64pl8PXm2f6jkv8c4cCCiGEEEIcQAHFNUmBRRpLu0nwaUJcK+Oom+Hpafd1KYrK5GSvC5FJMBIMnsLSoExIU4fDVDTLy2JvS9L+dJ2+EyYWpCWNC8V/Toa1U/U7Q/yvhx0vf9cWG4JtW3VKk58sDhsTt50LXAgDrVby+WIrCITV1bEdk0vyuk6Hieh51KfJg+D8J4QQQgjJSEGiqzHCtQMFiA8up6akvoMpYQFTXOAfFnSNK34LvMnT4bCAyzYIK5XSCSim24mqfTFokjpruBRQTFr32pBVQCmV+oURHcz5j31cgO9KmAumNaUVUJSK/2zW+id+XMwNE6eIrYNssVwXq9X+Y1D09B0NHSiEEEIIcQwFFNfECSjVaronybVafzBSqUi72UMOsbsxDNt+WP0TP4uhpXGt1l8QNu6JZVQtG1sBxSSATSugNJvF6qQUVaOhUnEXbAPuRaM0bVga3e0AACAASURBVH6DcyOqDop/jsWdx2n2T9j8rVQWioNZiuTGXeuaTbcOoKxFRU3PA9Pzt9HItu9GjaALZdQEFKVGwzFDCCGEkMJDAcU1cTfVWSzb/qedU1PAYYely6FPE4x3OumChUrF/qmfbZFdV4QF93FFGaMCCNun2CaBYVigajKXJibSHYO8iEp5cCny1OvuRSPb4D3s2IQJKJXKwv0xCAcK0EtvqlSynWtxAorr9JQsbg+bdBPTcbusXzIK1Ou9vxPDukanQZ9TRbkGEkIIIWTkoYDimmrVvs6ICZOT6V0nfsKCKpNxpXGhrF1r/507neEUJwwTS+KCpKgx2tZBMRGmgp146nWzfH4t8rh0d2ShUgkXnlwKHnmkLJl01/ITdvyDx6tW638tLigtl+1FzCgBpVKR+Z7VQZHU1cslWeaIzWdNrj2u2yuPCvpvwKi4T4DwWkOEEEIIIRmggJIHUYFFlqey9Tpw+OHZn3wGgyrTgN+2mOyyZenEkHZ78AJKqxUebEbZ9Eul+H1mM37TINb/tN9k/f6imWnas+ZFcP4q5S4gazTyC+5sxIYw8SAoeIal8yWJorbXj7igcWYm+7yIEpZKJfdzrlpNt85SyW5OmLQznpgoTnHmQdJqyb4ZJfGIDhRCCCGEOGYR3gUOgLAb8DRPkMPWkZVg0JZU/0RTqQCrV5uJKO02sHy5/GwTvGgxZ9ACSlyqTphg1WrF7zPXDpTgcib7xx/kFMWBAvQHn52Ou2A0z4K5NkJXVCcdP2EOFNcCSlzqUaWSvbZRVNt2l/VP/KQJ3Kem7K+bSefXYkvf8bNy5WiJERRQCCGEEOIYCih5EBZs5RVU2FIqLQzcbMSKmRlJH4r7HpWKpO7oZWo18xoSWsxpNAZ3w6tUfEAUJq4kiUI2NQJM941/TiUF0kFXh0nL2UFRLi8MhF09zW408hXeTAWUuG5WfiqV/nUmzXkbIaxUSp6DLoSrtPV50pBmrsSJo1HEzaOwgt6LiazFfAeN7oBFAYUQQgghjuBdRR4MMqhIQ60GHDggP9sGnZOTwPr1wNatwNxc//tr1/YHi+02sH9/8rr9Y2m1gF277MaWhsnJ+EBTB0x79/ZeS9pnuoXrnj3xy9Vq5kGsDrZN6p8Ei2bqlrOPPGK2rbyZmgJ27pSfXaXcLFvmZj1RZBVQwgK44DwyETzqdWDfvuRxDCrQjRKL86BSkf378MNmy09MpKt90WgAs7MLRUel5N+oCQhE5g1roBBCCCHEEXSg5EHRBRQd9NgWPNW028CGDf1Boa57Era86XptPwNke7po8oTa71AxbblrMn6blC69rMnxCutYUqSn5hMTvVoTLgLS2dn8v5/JsYpKaQHC56htDRTA/HsOKmAMft886p/4mZ01XzbYeteGJUvEcaf/TU/LdaBI5xExo0idyAghhBAy8lBAyYNSaWFwlFaoyAs9NtP6J2E0GsDGjb11+eueBDERE4KFWW0EFJugyk9UV5ggfgEljRgUhY2AooMAE/dL2DJFKiSrlIg8LtJ32u1sgbIpJmkAUfVP9OfjzjWlzNK+TI/joJwSQRdV3te5RsNM9Gy1stecIuNBXGc8QgghhBBLKKDkhT/QiQushoFf9Mi6ng0bRITw1z0JUq0mBzNBMcemDsr0dLon7qadharV3r4y3Wcm4pRtkFuvJ28/qihr0Z6cT01lT9+pVqWo5aAwmcNxxM1R07leNAEFWDimQQjFs7PJ+2sQohoZDapVNwXYCSGEEEJAASU/bLumDBI9NhfjqlalJkqSgJEULIeNxSQY63TCC3KaYNNNQy9rGvSbuI6ixhwViE9OJu/nKFdH0Wzs7Xa2YFsp6Qo1yMAoaY4lfZ+4/W9TdNhk2UHWfPDvl0EIdaVSfM2ber1Yjj8yXIomHhNCCCFkpKGAkheDfiprQ602+LSiJLEm7H0TgUfX+7AVUBoNuxvryUnZhs2T/aTxh41ZF8oMIyl1oVSK32aRAgldlDMty5cPPkUjbnu6cHAccQKKjbhl4kIZhgPFRat2UyYmoud61vbMZLwoUvoiIYQQQkYeCih54b9pK1LgCvRqUAwyrSgusA/WPzH5DND7HoB94GabPlKpACtW2H0mTqCKcoTUatE3/EnOg04nXpQYl0BiasrOPeSKuDlm0qZ8UAJKuTzYc1uPZ9BC8fLl/fu8UnHXGpuMB0Vp4U4IIYSQsaBAnv4xQxdXLGoLxUE/pS2X+9sBa1qt8JtcXQfl4MHwdbbbvcAzjQPFlrDuNnG0WjIH5ud7r+kuJVECTr2eXuhIGl9eQl6pBHie/Mubej26WHHe1GrAmjUyH+fmev/PzZkJci5qoADJx3HQrXZ1jYlBCyjVKrB0KXDvvb3XZmYYMBNCCCGEkNyggJIXSkmwV9ROEFkLeKbdZpiAEuc0abeBnTvD3/MLBoMQUGxRSgI8QIJek7a9usZFnHAUhhao4qjXZUxphY56XdKI9Pj0/3qdDz8M7Nkj/+bm0m0jjlJJ6p4MM0DOUjdoUA6UYQi29fpwnHYzM8Du3cC+fTI/huFMIoQQQgghiwYKKHnCYoYLabeBe+4Jfz3uM2ECij99B+ilxJiIDlrcGgS2aT96XI2GCBGmTEwkCwtKyXrDRCwTli6NFt50++R2W77zI4/I+HfvBg4cSLe9ILOzxXRzmeKiiCzQa5O+f3/4+4N2oAAyL4axXaVkvm3dKuJekbqdEUIIIYSQsYN3m3nSaBSvA88wCUvVSXJORAlQuvuOH1NRpNEors1fB6G2DhnTug9pnTeVit1cbjRE8HCVbqPdL6OMKwcKEH8chyEyDdP50WiIE2XU5wchhBBCCCk8FFDypN22dzq4fILa6RTriWyp1C+WRNU/0eg6KEHC6n3YCChFpFLpHS+bMZqk72jSpllMTqYTnVzta1snTxEplaKdJrYCStxxHJYTZJgsW1asNt2EEEIIIWQsKVB0PYbYBqtKAWvXugtGliwpnlgQTAExcTUElwmm72hMv2vR9onGLwDZCG82aWJpv3tah0G5nN0RMTVV3GNmS1iQr5RdCg8Qvz+GIaAQQgghhBCyCKCAUiRmZ+M7tNjQasm6ilbENiiGpBFQOp3wgNM0cCxqMO4fv43wYCOgpOkK1W5nE0Gy7O9yWc6LcSFMQLEVT4Bel6+w9Q/bDUIIIYQQQsiYQgHFBWkCoCDNZq+1sG273DD0uoomFujWvoDsN5PxBQWUqP0zTg4UwHyctoWKbb9/1voWWfb37Kyb86sohAkoaVJPogoh031CCCGEEEJIblBAcUHWoKVUAlau7P3eamXL56/Xe6JD0RwoSvUC/nbb7Gl5vd7bH1HpO0CvE08cuk1wEQnOIxPhoVq1d4fYpJbZFo8NI62A0miMX1vasGOV9lwPO46j3KWIEEIIIYSQgkMBxQVZBZRlyxYGPkqZd1UJY8mS3s9RVv9hogNym8BcLzsxES+AJB2LorpPgH6xy0T8StMm22YfpC0e6yetiOeqg0+RcOVAAcKPIx0ohBBCCCGE5EbBIusRJctT31Yr/Cl72jSearW/hopNwDyIJ9h6fGkElKT9khSsm+yLYThUqtV+ocJkrGkElHrdXBRx4QAplewD+3EqHOvHVQ0UgAIKIYQQQgghA4YCigvK5XRBUDB1x0+9nu7J/cxMf3Bss57JyfwDV13c1mY7Ot0nyZmTtM6k9/3pT4Mk7BiZCA9pBBSlzGvPuBLUbNsyj1PhWD8uHShhBYGZwkMIIYQQQkhuUEBxRZonv8uXxwdPti6UcjncMWATvLZaborYxqGUpC3ZUK+LOJQkVGV1oDQa6USJrETNn7jx1uvp3QsmdVBc1h+xmYNLlhS3Tk1WXNZAAfr3KwUUQgghhBBCcoMCiitsBZROJ1mosK0/EeY+AcwdKNqZMDGRfyvUNMG5SU2MuO9aLicfp2azOA6UuNeBbONMEjRcFI+12Z6fLPV/io5S/eKQKwElLA2MEEIIIYQQ4gwKKK6wFVCWLk1eplw2d0OUStGihGkh2UajF+Dl7cJIE+iZBJrVarR7wURIajTk84PuXpTGgZLlGLVa8UKFi+Kxfkzrrvg7Lo0rwe+XxW3jdxKx/gkhhBBCCCG5QgHFFTbBi1Lmy5s6Naam4gMx24Kkeafx5EnUvk1KW/HXHBm0C8VWQFHKrh1xkFIJWLUKWL8+/Fi7bh+slJkoFSyAPI4EBZSsLcu1MMX0HUIIIYQQQnKFAoorbASUWs386X67nfyEWilJ34nDJHj1B+SdTvHaH5sSJTrY1EexcXdMTGQLXuPmQ5Tw0Gy6cYjUalLI2C+kuCwe68e0cO244xdMsrpt/PODDhRCCCGEEEJyZUQj5AJiU3/Aph6ESeeZqankQCxpm0FHg8l2i0qUUJLk2PDvo2bTXECanMy2r5IC37Dv4zrFSgspGzbk1wHHpO7KOLYuDuIXp1ykK+l9RgGFEEIIIYSQXKGA4hLTAMa2vkZUOk2pBKxYkb24KtCrf2Ky3aIT9l1NUkj8wbtpioyuF5NFQEnTOSivGjXVan71X5LEkcXgPgEWiiYuug3pecoUHkIIIYQQQnKFAopL8hJQGo3+dbdaknZhWqsiqZBsWEDebI5mQc+w/VuvJztKggG+SUCvOxbV6+kD2KR5ExxXqTSaTo2kObgY6p8AblN4gJ74SQGFEEIIIYSQXKGA4pK8BBSg5wbRrpO1a+2Dr7igO8ptMQoulKD4ExaoJ+3zSqV/f5q4PPz7J60LJWlswQ42eXdIypO4orij/L1scJ3CU62OpqBGCCGEEELIiEEBxSUmAkq1mq446+SkOCJsXCdBogL1uHSVURBQwsYY/K429U80tVr8U/1abeHn0ggoJs6BYNemURYaogL9dttt2+Qi49qBAozGeUoIIYQQQsiIQwHFJSYCStonxZUKsGZNtoAratth9U80QZGgiLRa/fslKKAkfYeo9+PEiqBgUq/bF/I07ciUtkNQ0Yjaz4slfQeQ461rn7gSUEa14DMhhBBCCCEjBAUUl5jUIMirQKcJUdtOCsgHGZzZdDPSy4el3wS/a5pCrUB8HZSwp/62+8pUcNHjq1RGu9tKmv08juj56qKILDC6LccJIYQQQggZIXjX7ZJSKfmJ8jAFlKginknpLYNMD2g27RwWUR1I/Pu5UkkWt2wdKM1m+DptBRTT+aDHN8ruEyBc7Go23QkJo4KeO6NYpJkQQgghhJBFCgUU1yS5A4YpoAD9QoFJu95yeXAOgWbTbltaUAiKGf7vmZS+E9cdplQK3z9RolKtZneMTd0kOtVn1AUUIF23o3HDtQOFEEIIIYQQkjsUUFwTFxCXy8N/4hxWG8QkZWZQLpRGwy6gjnKg+FOB0hSQ9RMULZSKr9lh40IxFVt0q+RxFFAWU/0TTaUi14PFUjiXEEIIIYSQMYACimviBJRhu0+A/uDVNCDvdHouDZ2qpAvMtlryf62W7Yl6qST7qFo1qyfjT80JClNacACS93uSwBIUdNrt+O9pKqCYdODxMzU1fAHOBf45WK2Odk2XtISlMhFCCCGEEEIKDe/gXRMXDBahm41te1+NUsCmTeZPzOfngbk5YPt2YP9+s8/490+7DTz4YPzyfvEnTIio14FHHsnuQGk0RNyZn5ffk9w41ap85pFH4pezFQ7GpVWtfw4uRvcJ0Ct+TAghhBBCCBkZ6EBxTdEdKP56Hyb1T/zYpBuUShIkpikIC5il8fiXDwtG63UZR9wxUcpMyNDjKZXMxmbiQrGdD+OS7lEu9wSvxVj/BKADhRBCCCGEkBGEAoprKpXogqRFEFCAnuPCtP5JFmwEFL8TpNlMHptfQCmV+tNq6nX5F7ce032gv8fEhNnyJs6KxZi6omk05HjZCHjjBAUUQgghhBBCRg4KKHkQFhibOh0GgRZyBlGQNK0DJar7jaZc7t+fYZ14TNJzTNBOCdM0Gp3GE0dRBLVhoIsFj4urxhZ/jR5CCCGEEELISEABJQ/ChJIiBUs6sB/E0/8kIUQT1ko4Lr0jTJgJCii1Wvb6J5pKRcZjs8+S0niKIqgNA9tuS+NIEWoiEUIIIYQQQoyhgJIHRRdQdFrLoNInTFwoYWOJ+1zY8mGdeJIcIzZB7PLl5ssC8QKKrhGzWKGAwhQeQgghhBBCRgzewedBmIBSpKfNtZqIE4NKn2i3gfvui18mbP/U6xJkHjzY/16YgBImSMQFqf5ipibYCh6VCjA9DRw40P/eYnafADL3Fmv6DiGEEEIIIWQkSRRQlFKHAPgPACsAeAA+4XneB5VSxwH4VwAdAL8F8GLP83YppaoA/g3ACd31/4fnee/JafzFpOgOFACYmRnctnQ3HN0GOIwoN0y7DezcufC1cjl8f9oKHIMQtWxdK4QQQgghhBBCColJCs9BAG/0PO9RAJ4E4FVKqUdBRJI3e553LID/BvA33eVfAKDeff1xAM5VSq13PfBCExbIF01AGUQBWY1S8duLazUc9rkoscU2JaJIriBCCCGEEEIIIYUmUUDxPO9Oz/N+0f15N4DNANYAOALAj7qLXQLgefojANpKqQqAJoD9AHY5HnexCXbcqdWYrmBbzyTuc1HLF9GBQgghhBBCCCFkLLAqItt1khwP4AoANwI4o/vWCwAc0v35QgAPAbgTwFYA53ued7+DsY4W/mC+aO6TYRBXMDROyCiX+9+PEmNKpf5OPnFQQCGEEEIIIYQQYohxtKmU6gD4CoDXeZ63C8D/BfBKpdTVACYgThMAeAKAOQCrAWwA8Eal1MaQ9Z2jlLpKKXXVPffck/FrFBC/A4WBughKUQ6RpG5AfvGlVIoXpExdKNWqiDOEEEIIIYQQQogBRgJKtzDsVwB83vO8rwKA53k3e553uud5jwPwnwB+3V38RQC+43neAc/zdgD4CYATg+v0PO8Tnued6HneicuWLXPxXYqFX0ChA0WIco4kCUx+ASVJbDEVUChqEUIIIYQQQgixIFFAUUopABcA2Ox53vt9ry/v/l8C8HZIRx5A0nae0X2vDSk8e7PbYY8AFFD6CRNQdIeeOBqNnlskSUAxLSRLAYUQQgghhBBCiAUmDpTfA/BSAM9QSl3b/feHAP5MKfUriDjyOwD/3l3+owA6SqkbAfwcwL97nnd9DmMvNlpAqVSYKqIJE1BMhQz92aTuQXSgEEIIIYQQQgjJgcTH9Z7nXQYgqoXMB0OW3wMpKru4KZflH90nPXRB2Ece6b2W5CjRtNvAQw8l709TAYXHhRBCCCGEEEKIBVZdeIgltRoD9SBBB4mNA6XRSG4HbSKg1Gp23XoIIYQQQgghhCx6GEXmSa3GVJEg/oKw5fLCWjFxVCrAzIzZcknwmBBCCCGEEEIIsYQCSp7QgdJPo9Fzf9gKGX7xJYpy2awoLSGEEEIIIYQQYgEFlDxpNMxrciwWlOrVPTGtf2JLkguFAgohhBBCCCGEEEsooORJXgLBqKProOQlZCSJVnQFEUIIIYQQQgixhAIKGTw6FWcYAkq9nlyIlhBCCCGEEEIICUABhQyeWk1ElLw64cSl8DB9hxBCCCGEEEJICiigkOGwdGl+645zoFBAIYQQQgghhBCSAgooZDjkKWQkpfAQQgghhBBCCCGWUEAh40dUCo9SFFAIIYQQQgghhKSCAgoZPyqV8EKxLCBLCCGEEEIIISQlFFDIeBKWxkP3CSGEEEIIIYSQlFBAIeNJWBoPC8gSQgghhBBCCEkJBRQynoQ5UCigEEIIIYQQQghJCQUUMp4EBRSlgFptOGMhhBBCCCGEEDLyUEAh40kwhYcFZAkhhBBCCCGEZIACChlPgg4Upu8QQgghhBBCCMkABRQynlBAIYQQQgghhBDiEAooZDypVBam7FBAIYQQQgghhBCSAQooZHzRdVBKJRaQJYQQQgghhBCSCQooZHzRaTz1+nDHQQghhBBCCCFk5KGAQsYX7UBh+g4hhBBCCCGEkIxQQCHji3agUEAhhBBCCCGEEJIRCihkfGEKDyGEEEIIIYQQR1BAIeNLpcICsoQQQgghhBBCnEABhYwv1SrTdwghhBBCCCGEOIECChlfKhUKKIQQQgghhBBCnEABhYwvSgGdzrBHQQghhBBCCCFkDKCAQsYbOlAIIYQQQgghhDiAAgohhBBCCCGEEEJIAhRQCCGEEEIIIYQQQhKggEIIIYQQQgghhBCSAAUUQgghhBBCCCGEkAQooBBCCCGEEEIIIYQkQAGFEEIIIYQQQgghJAEKKIQQQgghhBBCCCEJUEAhhBBCCCGEEEIISYACCiGEEEIIIYQQQkgCFFAIIYQQQgghhBBCEqCAQgghhBBCCCGEEJIABRRCCCGEEEIIIYSQBCigEEIIIYQQQgghhCRAAYUQQgghhBBCCCEkAQoohBBCCCGEEEIIIQlQQCGEEEIIIYQQQghJgAIKIYQQQgghhBBCSAIUUAghhBBCCCGEEEISoIBCCCGEEEIIIYQQkgAFFEIIIYQQQgghhJAEKKAQQgghhBBCCCGEJEABhRBCCCGEEEIIISQBCiiEEEIIIYQQQgghCVBAIYQQQgghhBBCCEmAAgohhBBCCCGEEEJIAhRQCCGEEEIIIYQQQhKggEIIIYQQQgghhBCSAAUUQgghhBBCCCGEkAQooBBCCCGEEEIIIYQkoDzPG/YYoJS6B8Dtwx4HycQsgHuHPQgyNHj8CefA4obHn3AOLG54/AnnwOJm1I//Os/zlpksWAgBhYw+SqmrPM87cdjjIMOBx59wDixuePwJ58DihsefcA4sbhbT8WcKDyGEEEIIIYQQQkgCFFAIIYQQQgghhBBCEqCAQlzxiWEPgAwVHn/CObC44fEnnAOLGx5/wjmwuFk0x581UAghhBBCCCGEEEISoAOFEEIIIYQQQgghJAEKKCQUpdSnlFI7lFI3+F47Tin1U6XUL5VS31BKTfree0z3vRu77ze6rz+u+/sWpdSHlFJqGN+H2GMzB5RSVaXUZ7qvb1ZKvcX3mWcppW7pzoE3D+O7EHuUUocopX6glLqpe16/tvv6EqXUJUqpW7v/z3RfV91zfItS6nql1Am+dZ3dXf5WpdTZw/pOxJwUx//F3eP+S6XU5Uqp43zr4jVgBLGdA77PPV4pdVAp9Xzfa7wGjBhpjr9S6mSl1LXd5S/1vc5rwAiS4u/AVPfe8Lru8v/Hty5eA0aMmOP/gu7v80qpEwOfeUv3PL9FKfVM3+vjdQ3wPI//+K/vH4CnATgBwA2+134O4KTuz/8XwLu6P1cAXA/guO7vSwGUuz9fCeBJABSAbwP4g2F/N/7LZQ68CMAXuz+3APwWwHoAZQC/BrARQA3AdQAeNezvxn9Gx38VgBO6P08A+BWARwH4JwBv7r7+ZgDv7f78h91zXHXP+Su6ry8BcFv3/5nuzzPD/n785/z4P0UfVwB/4Dv+vAaM6D/bOeA73t8HcBGA53df4zVgBP+luAZMA7gJwKHd35f75gSvASP4L8UceKvv52UA7u8ec14DRvBfzPE/GsCRAH4I4ETf8o/qnt91ABu65315HK8BdKCQUDzP+xHkwufnCAA/6v58CYDndX8+HcD1nudd1/3sfZ7nzSmlVgGY9DzvZ56cWf8B4Mz8R09cYDkHPABtpVQFQBPAfgC7ADwBwBbP827zPG8/gC8COCPvsZPseJ53p+d5v+j+vBvAZgBrIMfvM93FPoPeOX0GgP/whJ8BmO5eA54J4BLP8+73PO8ByLx51gC/CkmB7fH3PO/y7vEFgJ8BWNv9mdeAESXFNQAA/grAVwDs8L3Ga8AIkuL4vwjAVz3P29r9jJ4DvAaMKCnmgAdgQimlAHQg95AHwWvASBJ1/D3P2+x53i0hHzkD8jB1n+d5vwGwBXL+j901gAIKseFG9Cb8CwAc0v35CACeUupipdQvlFJv6r6+BsA23+e3dV8jo0vUHLgQwEMA7gSwFcD5nufdDzned/g+zzkwgiil1gM4HsAVAFZ4nndn9627AKzo/hx1rDkHRhzD4+/n5RA3EsDjPxaYzAGl1BoAzwHwscDHOQdGHMNrwBEAZpRSP1RKXa2Ueln3dR7/McBwDnwE4k74HYBfAnit53nz4BwYeQLHP4pFcx9IAYXY8H8BvFIpdTXEyrW/+3oFwFMBvLj7/3OUUqcMZ4gkZ6LmwBMAzAFYDbHtvVEptXE4QyQuUUp1IE+UX+d53i7/e11nGVu5jTG2x18p9XSIgHLewAZJcsViDnwAwHndgImMCRbHvwLgcQD+COI4+Ful1BGDHCvJB4s58EwA10LuBR8L4CPKVy+RjCZxx3+xQgGFGON53s2e553ued7jAPwnJJ8NECXxR57n3et53sOQ3OcTAGxHz8aN7s/bBzlm4paYOfAiAN/xPO9A17b7EwAnQo73Ib5VcA6MEEqpKuSP5uc9z/tq9+W7u6k56P6vbdpRx5pzYESxPP5QSj0GwL8BOMPzvPu6L/P4jzCWc+BEAF9USv0WwPMB/ItS6kxwDowslsd/G4CLPc97yPO8eyHpvseBx3+ksZwD/weSxuV5nrcFwG8AHAXOgZEl4vhHsWjuAymgEGOUUsu7/5cAvB3Av3bfuhjAsUqpVrcGxkkAbura+3YppZ7UzYd8GYCvDWHoxBExc2ArgGd032tDiojeDCk6e7hSaoNSqgbgLABfH/S4iT3dc/YCAJs9z3u/762vA9AV9M9G75z+OoCXKeFJAHZ2rwEXAzhdKTXTrdR/evc1UmBsj79S6lAAXwXwUs/zfuVbnteAEcV2Dniet8HzvPWe562HpHW+0vO8/wGvASNJir8BXwPwVKVURSnVAvBESM0EXgNGlBRzYCuAU7qfXQEpNHobeA0YSWKOfxRfB3CWUqqulNoA4HBIM5GxuwZUhj0AUkyUUv8J4GQAs0qpbQDeAaCjlHpVd5GvAvh3APA87wGl1PshAri3lQAAAUlJREFUJ4gH4CLP877VXe6VAD4NKSz6bfTy4knBsZkDAD4K4N+VUjdCurD8u+d513fX82rIH8oygE95nnfj4L4FycDvAXgpgF8qpa7tvvZWAP8I4L+UUi8HcDuAP+2+dxGkE88WAA9DnkTB87z7lVLvglwfAOD/69bHIcXG9vj/HaQD27/IPRcOep53oud5B3kNGFls50AovAaMLFbH3/O8zUqp70C6Ms4D+DfP824AeB8wwtheA94F4NNKqV9C7gXP67qRwGvASBJ1/OsA/v/27tgGQigGoqBdHcVcOdcFOX2Q0M2dluDHyDmaKcLBk1b+1vq0dHT3mWRLcnX3Xusb16+qPkn+Ve+7Ab2mawAAAAA8MeEBAAAAGAgoAAAAAAMBBQAAAGAgoAAAAAAMBBQAAACAgYACAAAAMBBQAAAAAAYCCgAAAMDgBmQlq/+vvtS2AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1368x864 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.rcParams['figure.figsize'] = [9.5*2, 6*2]\n",
+    "y1 = ens_perc['tx_max_p90'].mean(['lon','lat'])\n",
+    "y2 = ens_perc['tx_max_p10'].mean(['lon','lat'])\n",
+    "plt.fill_between(x,y1,y2, facecolor='red', alpha=0.15)\n",
+    "\n",
+    "y1 = ens_perc['tx_max_p75'].mean(['lon','lat'])\n",
+    "y2 = ens_perc['tx_max_p25'].mean(['lon','lat'])\n",
+    "plt.fill_between(x,y1,y2, facecolor='red', alpha=0.2)\n",
+    "plt.plot(x,ens_perc['tx_max_p50'].mean(['lon','lat']), color='red', linewidth = 1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 30 year averages\n",
+    "ensSub = xut.subset_bbox(ens_rcp85,start_yr = 1951)\n",
+    "ens30y = ensSub.rolling(time=30,  center=True).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, realization: 11)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "    time     datetime64[ns] 1980-01-01\n",
+      "Dimensions without coordinates: realization\n",
+      "Data variables:\n",
+      "    tx_max   (realization, lat, lon) float32 nan nan nan nan ... nan nan nan nan\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7ff9b4646630>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1368x864 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#print(ens30y)\n",
+    "print(ens30y.sel(time='1980-01-01'))\n",
+    "ens30y.sel(time='1980-01-01')['tx_max'][0,:,:].plot.imshow()\n",
+    "#print(ens30y.time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2010-01-01T00:00:00.000000000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create deltas wrt to 1981-2010\n",
+    "ref_per = ens30y.sel(time='2010-01-01')\n",
+    "print(ref_per.time.values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, realization: 11, time: 150)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "  * time     (time) datetime64[ns] 1951-01-01 1952-01-01 ... 2100-01-01\n",
+      "Dimensions without coordinates: realization\n",
+      "Data variables:\n",
+      "    tx_max   (realization, time, lat, lon) float32 nan nan nan ... nan nan nan\n"
+     ]
+    }
+   ],
+   "source": [
+    "ensDeltas = ens30y - ref_per\n",
+    "print(ensDeltas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading ensemble data to memory\n",
+      "<xarray.DataArray 'tx_max_p10' ()>\n",
+      "array(-2.846863)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ens_percDeltas = xut.ensemble_percentiles(ensDeltas)\n",
+    "print(ens_percDeltas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7ff99b92cc18>"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1368x864 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#print(ens_percDeltas.time)\n",
+    "ens_percDeltas['tx_max_p50'].sel(time='2085-01-01').plot.imshow()"
+   ]
+  },
+  {
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/xclim_training/XCLIM_calculate_index-Exemple.ipynb b/docs/notebooks/xclim_training/XCLIM_calculate_index-Exemple.ipynb
new file mode 100755
index 00000000..3b1cde6a
--- /dev/null
+++ b/docs/notebooks/xclim_training/XCLIM_calculate_index-Exemple.ipynb
@@ -0,0 +1,528 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:py.warnings:/usr/local/DEV/miniconda3/envs/py366/lib/python3.6/site-packages/xarray/core/options.py:50: FutureWarning: The enable_cftimeindex option is now a no-op and will be removed in a future version of xarray.\n",
+      "  FutureWarning)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# XCLIM and xarray\n",
+    "import xclim.indices as xci\n",
+    "import xclim.temperature as temp\n",
+    "import xclim.precip as prec\n",
+    "import numpy as np\n",
+    "import xclim.utils as xut\n",
+    "import xarray as xr\n",
+    "import dask\n",
+    "\n",
+    "# file handling libraries\n",
+    "import os\n",
+    "import glob\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Setting up the Dask client - Parralel processing / workers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "DEBUG:asyncio:Using selector: EpollSelector\n",
+      "DEBUG:asyncio:Using selector: EpollSelector\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table style=\"border: 2px solid white;\">\n",
+       "<tr>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3>Client</h3>\n",
+       "<ul>\n",
+       "  <li><b>Scheduler: </b>tcp://127.0.0.1:39481\n",
+       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:8787/status' target='_blank'>http://127.0.0.1:8787/status</a>\n",
+       "</ul>\n",
+       "</td>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3>Cluster</h3>\n",
+       "<ul>\n",
+       "  <li><b>Workers: </b>5</li>\n",
+       "  <li><b>Cores: </b>30</li>\n",
+       "  <li><b>Memory: </b>15.00 GB</li>\n",
+       "</ul>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<Client: scheduler='tcp://127.0.0.1:39481' processes=5 cores=30>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from distributed import Client\n",
+    "client=Client(n_workers=5, threads_per_worker=6, diagnostics_port=8787, memory_limit='3GB') \n",
+    "#client=Client(n_workers=1)\n",
+    "client"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Finding files using thredds server (TODO using siphon)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['/home/logan/boreas/ouranos/cb-oura-1.0/ACCESS1-3', '/home/logan/boreas/ouranos/cb-oura-1.0/BNU-ESM', '/home/logan/boreas/ouranos/cb-oura-1.0/CMCC-CMS', '/home/logan/boreas/ouranos/cb-oura-1.0/CanESM2', '/home/logan/boreas/ouranos/cb-oura-1.0/GFDL-ESM2M', '/home/logan/boreas/ouranos/cb-oura-1.0/HadGEM2-CC', '/home/logan/boreas/ouranos/cb-oura-1.0/INM-CM4', '/home/logan/boreas/ouranos/cb-oura-1.0/IPSL-CM5A-LR', '/home/logan/boreas/ouranos/cb-oura-1.0/IPSL-CM5B-LR', '/home/logan/boreas/ouranos/cb-oura-1.0/MPI-ESM-LR', '/home/logan/boreas/ouranos/cb-oura-1.0/NorESM1-M']\n",
+      "151\n"
+     ]
+    }
+   ],
+   "source": [
+    "infolder = '/home/logan/boreas/ouranos/cb-oura-1.0/'\n",
+    "outfolder = '/home/logan/boreas/testdata/XCLIM_workshop/Exercise1/'\n",
+    "if not os.path.exists(outfolder):\n",
+    "    os.makedirs(outfolder)\n",
+    "models = [f.path for f in glob.os.scandir(infolder) if f.is_dir()]\n",
+    "models = sorted(models)\n",
+    "print(models)\n",
+    "\n",
+    "rcps = ['rcp45','rcp85']\n",
+    "v = 'tasmax'\n",
+    "m = models[0]\n",
+    "r = rcps[0]\n",
+    "# Get list of files for tasmax\n",
+    "sim_files= sorted(glob.glob(os.path.join(m,r,'day',v, '*.nc')))\n",
+    "print(len(sim_files))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Creating Xarray datasets & dask chunks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.DataArray 'tasmax' (time: 365, lat: 700, lon: 1064)>\n",
+      "[271852000 values with dtype=float32]\n",
+      "Coordinates:\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1950-01-02 ... 1950-12-31\n",
+      "  * lat      (lat) float32 83.28931 83.20598 83.12265 ... 25.12497 25.04164\n",
+      "  * lon      (lon) float32 -141.04314 -140.9598 ... -52.54667 -52.46334\n",
+      "Attributes:\n",
+      "    units:          K\n",
+      "    long_name:      air_temperature\n",
+      "    standard_name:  air_temperature\n"
+     ]
+    }
+   ],
+   "source": [
+    "# chunked vs unchunked\n",
+    "ds = xr.open_dataset(sim_files[0])\n",
+    "print(ds.tasmax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.DataArray 'tasmax' (time: 365, lat: 700, lon: 1064)>\n",
+      "dask.array<shape=(365, 700, 1064), dtype=float32, chunksize=(31, 700, 1064)>\n",
+      "Coordinates:\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1950-01-02 ... 1950-12-31\n",
+      "  * lat      (lat) float32 83.28931 83.20598 83.12265 ... 25.12497 25.04164\n",
+      "  * lon      (lon) float32 -141.04314 -140.9598 ... -52.54667 -52.46334\n",
+      "Attributes:\n",
+      "    units:          K\n",
+      "    long_name:      air_temperature\n",
+      "    standard_name:  air_temperature\n"
+     ]
+    }
+   ],
+   "source": [
+    "ds = xr.open_dataset(sim_files[0], chunks={'time':31})\n",
+    "print(ds.tasmax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Multifile dataset - treat 151 yearly netcdf files as a single dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 700, lon: 1064, time: 55152)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 83.28931 83.20598 83.12265 ... 25.12497 25.04164\n",
+      "  * lon      (lon) float32 -141.04314 -140.9598 ... -52.54667 -52.46334\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1950-01-02 ... 2100-12-31\n",
+      "Data variables:\n",
+      "    tasmax   (time, lat, lon) float32 dask.array<shape=(55152, 700, 1064), chunksize=(365, 100, 112)>\n",
+      "Attributes:\n",
+      "    Conventions:     CF-1.5\n",
+      "    title:           ACCESS1-3 model output prepared for CMIP5 historical\n",
+      "    history:         CMIP5 compliant file produced from raw ACCESS model outp...\n",
+      "    institution:     CSIRO (Commonwealth Scientific and Industrial Research O...\n",
+      "    source:          ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 grid-point, 1...\n",
+      "    redistribution:  Redistribution prohibited. For internal use only.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create multifile data & chunks \n",
+    "ds = xr.open_mfdataset(sim_files, chunks={'time':365*3, 'lat':50*2, 'lon':56*2})\n",
+    "ds = ds.drop('time_vectors')\n",
+    "ds = ds.drop('ts')\n",
+    "print(ds)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Subsetting data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, time: 55152)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1950-01-02 ... 2100-12-31\n",
+      "Data variables:\n",
+      "    tasmax   (time, lat, lon) float32 dask.array<shape=(55152, 180, 324), chunksize=(365, 20, 75)>\n",
+      "Attributes:\n",
+      "    Conventions:     CF-1.5\n",
+      "    title:           ACCESS1-3 model output prepared for CMIP5 historical\n",
+      "    history:         CMIP5 compliant file produced from raw ACCESS model outp...\n",
+      "    institution:     CSIRO (Commonwealth Scientific and Industrial Research O...\n",
+      "    source:          ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 grid-point, 1...\n",
+      "    redistribution:  Redistribution prohibited. For internal use only.\n"
+     ]
+    }
+   ],
+   "source": [
+    "lat_bnds = [45, 60]\n",
+    "lon_bnds = [-55, -82]\n",
+    "\n",
+    "ds = xut.subset_bbox(ds,lat_bnds=lat_bnds,lon_bnds=lon_bnds)\n",
+    "print(ds)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Climate index calculation & Resampling frequencies\n",
+    "http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases\n",
+    "\n",
+    "**Example : Maximum of daily tasmax (tx_max)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:py.warnings:/usr/local/DEV/miniconda3/envs/py366/lib/python3.6/site-packages/xclim/checks.py:30: UserWarning: Variable does not have a `cell_methods` attribute.\n",
+      "  warn(e)\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of time-steps using freq ==  YS  :  151 \n",
+      "\n",
+      "<xarray.DataArray 'time' (time: 151)>\n",
+      "array(['1950-01-01T00:00:00.000000000', '1951-01-01T00:00:00.000000000',\n",
+      "       '1952-01-01T00:00:00.000000000', '1953-01-01T00:00:00.000000000',\n",
+      "       '1954-01-01T00:00:00.000000000', '1955-01-01T00:00:00.000000000',\n",
+      "       '1956-01-01T00:00:00.000000000', '1957-01-01T00:00:00.000000000',\n",
+      "       '1958-01-01T00:00:00.000000000', '1959-01-01T00:00:00.000000000',\n",
+      "       '1960-01-01T00:00:00.000000000', '1961-01-01T00:00:00.000000000',\n",
+      "       '1962-01-01T00:00:00.000000000', '1963-01-01T00:00:00.000000000',\n",
+      "       '1964-01-01T00:00:00.000000000', '1965-01-01T00:00:00.000000000',\n",
+      "       '1966-01-01T00:00:00.000000000', '1967-01-01T00:00:00.000000000',\n",
+      "       '1968-01-01T00:00:00.000000000', '1969-01-01T00:00:00.000000000',\n",
+      "       '1970-01-01T00:00:00.000000000', '1971-01-01T00:00:00.000000000',\n",
+      "       '1972-01-01T00:00:00.000000000', '1973-01-01T00:00:00.000000000',\n",
+      "       '1974-01-01T00:00:00.000000000', '1975-01-01T00:00:00.000000000',\n",
+      "       '1976-01-01T00:00:00.000000000', '1977-01-01T00:00:00.000000000',\n",
+      "       '1978-01-01T00:00:00.000000000', '1979-01-01T00:00:00.000000000',\n",
+      "       '1980-01-01T00:00:00.000000000', '1981-01-01T00:00:00.000000000',\n",
+      "       '1982-01-01T00:00:00.000000000', '1983-01-01T00:00:00.000000000',\n",
+      "       '1984-01-01T00:00:00.000000000', '1985-01-01T00:00:00.000000000',\n",
+      "       '1986-01-01T00:00:00.000000000', '1987-01-01T00:00:00.000000000',\n",
+      "       '1988-01-01T00:00:00.000000000', '1989-01-01T00:00:00.000000000',\n",
+      "       '1990-01-01T00:00:00.000000000', '1991-01-01T00:00:00.000000000',\n",
+      "       '1992-01-01T00:00:00.000000000', '1993-01-01T00:00:00.000000000',\n",
+      "       '1994-01-01T00:00:00.000000000', '1995-01-01T00:00:00.000000000',\n",
+      "       '1996-01-01T00:00:00.000000000', '1997-01-01T00:00:00.000000000',\n",
+      "       '1998-01-01T00:00:00.000000000', '1999-01-01T00:00:00.000000000',\n",
+      "       '2000-01-01T00:00:00.000000000', '2001-01-01T00:00:00.000000000',\n",
+      "       '2002-01-01T00:00:00.000000000', '2003-01-01T00:00:00.000000000',\n",
+      "       '2004-01-01T00:00:00.000000000', '2005-01-01T00:00:00.000000000',\n",
+      "       '2006-01-01T00:00:00.000000000', '2007-01-01T00:00:00.000000000',\n",
+      "       '2008-01-01T00:00:00.000000000', '2009-01-01T00:00:00.000000000',\n",
+      "       '2010-01-01T00:00:00.000000000', '2011-01-01T00:00:00.000000000',\n",
+      "       '2012-01-01T00:00:00.000000000', '2013-01-01T00:00:00.000000000',\n",
+      "       '2014-01-01T00:00:00.000000000', '2015-01-01T00:00:00.000000000',\n",
+      "       '2016-01-01T00:00:00.000000000', '2017-01-01T00:00:00.000000000',\n",
+      "       '2018-01-01T00:00:00.000000000', '2019-01-01T00:00:00.000000000',\n",
+      "       '2020-01-01T00:00:00.000000000', '2021-01-01T00:00:00.000000000',\n",
+      "       '2022-01-01T00:00:00.000000000', '2023-01-01T00:00:00.000000000',\n",
+      "       '2024-01-01T00:00:00.000000000', '2025-01-01T00:00:00.000000000',\n",
+      "       '2026-01-01T00:00:00.000000000', '2027-01-01T00:00:00.000000000',\n",
+      "       '2028-01-01T00:00:00.000000000', '2029-01-01T00:00:00.000000000',\n",
+      "       '2030-01-01T00:00:00.000000000', '2031-01-01T00:00:00.000000000',\n",
+      "       '2032-01-01T00:00:00.000000000', '2033-01-01T00:00:00.000000000',\n",
+      "       '2034-01-01T00:00:00.000000000', '2035-01-01T00:00:00.000000000',\n",
+      "       '2036-01-01T00:00:00.000000000', '2037-01-01T00:00:00.000000000',\n",
+      "       '2038-01-01T00:00:00.000000000', '2039-01-01T00:00:00.000000000',\n",
+      "       '2040-01-01T00:00:00.000000000', '2041-01-01T00:00:00.000000000',\n",
+      "       '2042-01-01T00:00:00.000000000', '2043-01-01T00:00:00.000000000',\n",
+      "       '2044-01-01T00:00:00.000000000', '2045-01-01T00:00:00.000000000',\n",
+      "       '2046-01-01T00:00:00.000000000', '2047-01-01T00:00:00.000000000',\n",
+      "       '2048-01-01T00:00:00.000000000', '2049-01-01T00:00:00.000000000',\n",
+      "       '2050-01-01T00:00:00.000000000', '2051-01-01T00:00:00.000000000',\n",
+      "       '2052-01-01T00:00:00.000000000', '2053-01-01T00:00:00.000000000',\n",
+      "       '2054-01-01T00:00:00.000000000', '2055-01-01T00:00:00.000000000',\n",
+      "       '2056-01-01T00:00:00.000000000', '2057-01-01T00:00:00.000000000',\n",
+      "       '2058-01-01T00:00:00.000000000', '2059-01-01T00:00:00.000000000',\n",
+      "       '2060-01-01T00:00:00.000000000', '2061-01-01T00:00:00.000000000',\n",
+      "       '2062-01-01T00:00:00.000000000', '2063-01-01T00:00:00.000000000',\n",
+      "       '2064-01-01T00:00:00.000000000', '2065-01-01T00:00:00.000000000',\n",
+      "       '2066-01-01T00:00:00.000000000', '2067-01-01T00:00:00.000000000',\n",
+      "       '2068-01-01T00:00:00.000000000', '2069-01-01T00:00:00.000000000',\n",
+      "       '2070-01-01T00:00:00.000000000', '2071-01-01T00:00:00.000000000',\n",
+      "       '2072-01-01T00:00:00.000000000', '2073-01-01T00:00:00.000000000',\n",
+      "       '2074-01-01T00:00:00.000000000', '2075-01-01T00:00:00.000000000',\n",
+      "       '2076-01-01T00:00:00.000000000', '2077-01-01T00:00:00.000000000',\n",
+      "       '2078-01-01T00:00:00.000000000', '2079-01-01T00:00:00.000000000',\n",
+      "       '2080-01-01T00:00:00.000000000', '2081-01-01T00:00:00.000000000',\n",
+      "       '2082-01-01T00:00:00.000000000', '2083-01-01T00:00:00.000000000',\n",
+      "       '2084-01-01T00:00:00.000000000', '2085-01-01T00:00:00.000000000',\n",
+      "       '2086-01-01T00:00:00.000000000', '2087-01-01T00:00:00.000000000',\n",
+      "       '2088-01-01T00:00:00.000000000', '2089-01-01T00:00:00.000000000',\n",
+      "       '2090-01-01T00:00:00.000000000', '2091-01-01T00:00:00.000000000',\n",
+      "       '2092-01-01T00:00:00.000000000', '2093-01-01T00:00:00.000000000',\n",
+      "       '2094-01-01T00:00:00.000000000', '2095-01-01T00:00:00.000000000',\n",
+      "       '2096-01-01T00:00:00.000000000', '2097-01-01T00:00:00.000000000',\n",
+      "       '2098-01-01T00:00:00.000000000', '2099-01-01T00:00:00.000000000',\n",
+      "       '2100-01-01T00:00:00.000000000'], dtype='datetime64[ns]')\n",
+      "Coordinates:\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1951-01-01 ... 2100-01-01\n",
+      "<xarray.Dataset>\n",
+      "Dimensions:  (lat: 180, lon: 324, time: 151)\n",
+      "Coordinates:\n",
+      "  * lat      (lat) float32 59.95691 59.87358 59.79025 ... 45.12417 45.04084\n",
+      "  * lon      (lon) float32 -81.96216 -81.87883 -81.7955 ... -55.1299 -55.04657\n",
+      "  * time     (time) datetime64[ns] 1950-01-01 1951-01-01 ... 2100-01-01\n",
+      "Data variables:\n",
+      "    tx_max   (time, lat, lon) float32 dask.array<shape=(151, 180, 324), chunksize=(1, 20, 75)>\n",
+      "Attributes:\n",
+      "    Conventions:     CF-1.5\n",
+      "    title:           ACCESS1-3 model output prepared for CMIP5 historical\n",
+      "    history:         CMIP5 compliant file produced from raw ACCESS model outp...\n",
+      "    institution:     CSIRO (Commonwealth Scientific and Industrial Research O...\n",
+      "    source:          ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 grid-point, 1...\n",
+      "    redistribution:  Redistribution prohibited. For internal use only.\n",
+      "/home/logan/boreas/testdata/XCLIM_workshop/Exercise1/rcp45/tx_max/test.nc\n"
+     ]
+    }
+   ],
+   "source": [
+    "fr = 'YS' #MS #QS-DEC #AS-AUG #W #2W #5D\n",
+    "out = temp.tx_max(ds.tasmax, freq=fr)\n",
+    "dsOut = ds.drop(ds.data_vars)\n",
+    "dsOut = dsOut.drop('time')\n",
+    "dsOut[out.name] = out\n",
+    "print('Number of time-steps using freq == ', fr, ' : ', len(out.time),'\\n')\n",
+    "print(out.time)\n",
+    "print(dsOut)\n",
+    "\n",
+    "outfile = '/home/logan/boreas/testdata/XCLIM_workshop/Exercise1/rcp45/tx_max/test.nc'\n",
+    "if not os.path.exists(os.path.dirname(outfile)):\n",
+    "    os.makedirs(os.path.dirname(outfile))\n",
+    "print(outfile)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "scrolled": true
+   },
+   "source": [
+    "## 7. Lazy computation\n",
+    "**Up until we have ony created a schedule of tasks with a small preview**\n",
+    "\n",
+    "**Writing the file to netcdf will actually calculate the values for all years**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculation took  73.00857853889465 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "outfile = '/home/logan/boreas/testdata/XCLIM_workshop/Exercise1/rcp45/tx_max/test.nc'\n",
+    "start= time.time()\n",
+    "\n",
+    "dsOut.to_netcdf( outfile,format='NETCDF4')\n",
+    "\n",
+    "end = time.time()\n",
+    "print('calculation took ',end-start, 's')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "# client.restart()\n",
+    "# f = 'YS'\n",
+    "# start= time.time()\n",
+    "# out = temp.tx_days_above(ds.tasmax, thresh='30 C', freq=f)\n",
+    "# dsOut = ds.drop(ds.data_vars)\n",
+    "# dsOut = dsOut.drop('time')\n",
+    "# dsOut[out.name] = out\n",
+    "# outfile = os.path.join(outfolder,r,'txgt_30','txgt_30_'+ f +'_' + os.path.basename(sim_files[0].replace('1950','1950-2100')))\n",
+    "# if not os.path.exists(os.path.dirname(outfile)):\n",
+    "#     os.makedirs(os.path.dirname(outfile))\n",
+    "# outfile = outfile.replace('tasmax','').replace('__','_')\n",
+    "# #comp = dict(zlib=True, complevel=5, dtype='single')\n",
+    "# #encoding = {var: comp for var in dsOut.data_vars}\n",
+    "# encoding = {}\n",
+    "# encoding['time'] = dict(dtype='single')\n",
+    "\n",
+    "# dsOut.to_netcdf( outfile,format='NETCDF4', encoding=encoding)\n",
+    "\n",
+    "# end = time.time()\n",
+    "# print(end-start)"
+   ]
+  },
+  {
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/setup.cfg b/setup.cfg
index 5d47d1de..ef3e08ef 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -33,6 +33,10 @@ exclude =
 max-line-length = 120
 max-complexity = 10
 
+ignore =
+    F401
+    F403
+
 [aliases]
 test = pytest
 
diff --git a/xclim/__init__.py b/xclim/__init__.py
index 9dc2f899..f3eac693 100644
--- a/xclim/__init__.py
+++ b/xclim/__init__.py
@@ -3,7 +3,8 @@
 """Top-level package for xclim."""
 
 from functools import partial
-from . import indices
+
+from xclim import indices
 import sys
 
 # from .stats import fit, test
diff --git a/xclim/atmos/__init__.py b/xclim/atmos/__init__.py
new file mode 100644
index 00000000..583a091f
--- /dev/null
+++ b/xclim/atmos/__init__.py
@@ -0,0 +1,14 @@
+"""
+Atmospheric indicator calculation instances
+===========================================
+
+While the `indices` module stores the computing functions, this module defines Indicator classes and instances that
+include a number of functionalities, such as input validation, unit conversion, output meta-data handling,
+and missing value masking.
+
+The concept followed here is to define Indicator subclasses for each input variable, then create instances
+for each indicator.
+
+"""
+from ._temperature import *
+from ._precip import *
diff --git a/xclim/precip.py b/xclim/atmos/_precip.py
similarity index 84%
rename from xclim/precip.py
rename to xclim/atmos/_precip.py
index 489c1d1b..8397c951 100644
--- a/xclim/precip.py
+++ b/xclim/atmos/_precip.py
@@ -1,6 +1,11 @@
 # -*- coding: utf-8 -*-
-from . import indices as _ind
-from .utils import Indicator, Indicator2D
+
+from xclim import indices
+from xclim.utils import Indicator, Indicator2D
+
+__all__ = ['rain_on_frozen_ground_days', 'max_1day_precipitation_amount',
+           'max_n_day_precipitation_amount', 'wetdays', 'maximum_consecutive_dry_days', 'maximum_consecutive_wet_days',
+           'daily_pr_intensity', 'precip_accumulation']
 
 
 class Pr(Indicator):
@@ -22,7 +27,7 @@ rain_on_frozen_ground_days = PrTas(identifier='rain_frzgr',
                                                "Precipitation is assumed to be rain when the"
                                                "daily average temperature is above 0℃.",
                                    cell_methods='',
-                                   compute=_ind.rain_on_frozen_ground_days,
+                                   compute=indices.rain_on_frozen_ground_days,
                                    )
 
 max_1day_precipitation_amount = Pr(identifier='rx1day',
@@ -31,7 +36,7 @@ max_1day_precipitation_amount = Pr(identifier='rx1day',
                                    long_name='maximum 1-day total precipitation',
                                    description="{freq} maximum 1-day total precipitation",
                                    cellmethods='time: sum within days time: maximum over days',
-                                   compute=_ind.max_1day_precipitation_amount,
+                                   compute=indices.max_1day_precipitation_amount,
                                    )
 
 max_n_day_precipitation_amount = Pr(identifier='rx{window}day',
@@ -40,7 +45,7 @@ max_n_day_precipitation_amount = Pr(identifier='rx{window}day',
                                     long_name='maximum {window}-day total precipitation',
                                     description="{freq} maximum {window}-day total precipitation",
                                     cellmethods='time: sum within days time: maximum over days',
-                                    compute=_ind.max_n_day_precipitation_amount,
+                                    compute=indices.max_n_day_precipitation_amount,
                                     )
 
 wetdays = Pr(identifier='r{thresh}mm',
@@ -49,7 +54,7 @@ wetdays = Pr(identifier='r{thresh}mm',
              long_name='Number of Wet Days (precip >= {thresh} mm)',
              description='{freq} number of days with daily precipitation over {thresh} mm',
              cell_methods='time: sum within days time: sum over days',
-             compute=_ind.wetdays,
+             compute=indices.wetdays,
              )
 
 maximum_consecutive_wet_days = Pr(identifier='cwd',
@@ -60,7 +65,7 @@ maximum_consecutive_wet_days = Pr(identifier='cwd',
                                   description='{freq} maximum number of days with daily '
                                               'precipitation over {thresh} mm',
                                   cell_methods='time: sum within days time: sum over days',
-                                  compute=_ind.maximum_consecutive_wet_days,
+                                  compute=indices.maximum_consecutive_wet_days,
                                   )
 
 maximum_consecutive_dry_days = Pr(identifier='cdd',
@@ -71,7 +76,7 @@ maximum_consecutive_dry_days = Pr(identifier='cdd',
                                   description='{freq} maximum number of days with daily '
                                               'precipitation below {thresh} mm',
                                   cell_methods='time: sum within days time: sum over days',
-                                  compute=_ind.maximum_consecutive_dry_days,
+                                  compute=indices.maximum_consecutive_dry_days,
                                   )
 
 daily_pr_intensity = Pr(identifier='sdii',
@@ -81,7 +86,7 @@ daily_pr_intensity = Pr(identifier='sdii',
                         description="{freq} Simple Daily Intensity Index (SDII) : {freq} average precipitation "
                                     "for days with daily precipitation over {thresh} mm",
                         cell_methods='',
-                        compute=_ind.daily_pr_intensity,
+                        compute=indices.daily_pr_intensity,
                         )
 
 precip_accumulation = Pr(identifier='prcptot',
@@ -90,5 +95,5 @@ precip_accumulation = Pr(identifier='prcptot',
                          long_name='Total precipitation',
                          description='{freq} total precipitation',
                          cell_methods='time: sum within days time: sum over days',
-                         compute=_ind.precip_accumulation
+                         compute=indices.precip_accumulation
                          )
diff --git a/xclim/temperature.py b/xclim/atmos/_temperature.py
similarity index 88%
rename from xclim/temperature.py
rename to xclim/atmos/_temperature.py
index 35d04fe2..4c68c93f 100644
--- a/xclim/temperature.py
+++ b/xclim/atmos/_temperature.py
@@ -1,21 +1,17 @@
 # -*- coding: utf-8 -*-
-"""
-Indicator calculation instances
-===============================
-
-While the `indices` module stores the computing functions, this module defines Indicator classes and instances that
-include a number of functionalities, such as input validation, unit conversion, output meta-data handling,
-and missing value masking.
+import abc
 
-The concept followed here is to define Indicator subclasses for each input variable, then create instances
-for each indicator.
+from xclim import indices
+from xclim import checks
+from xclim.utils import Indicator, Indicator2D
 
-"""
-
-from . import checks
-from . import indices as _ind
-from .utils import Indicator, Indicator2D
-import abc
+__all__ = ['tn_days_below', 'tx_days_above', 'tx_tn_days_above',
+           'heat_wave_frequency', 'heat_wave_max_length', 'heat_wave_index', 'tg_mean', 'tg10p', 'tg90p', 'tn_min',
+           'tn_max', 'tn_mean', 'tn10p', 'tn90p', 'tx_min', 'tx_max', 'tx_mean', 'tx10p', 'tx90p',
+           'daily_temperature_range', 'daily_temperature_range_variability', 'extreme_temperature_range',
+           'cold_spell_duration_index', 'cold_spell_days', 'daily_freezethaw_cycles', 'cooling_degree_days',
+           'heating_degree_days', 'growing_degree_days', 'freshet_start', 'frost_days', 'ice_days',
+           'consecutive_frost_days', 'growing_season_length', 'tropical_nights']
 
 
 # TODO: Should we reference the standard vocabulary we're using ?
@@ -76,7 +72,7 @@ tn_days_below = Tasmin(identifier='tnlt_{thresh}',
                        long_name='Number of days with Tmin < {thresh}C',
                        description="{freq} number of days where daily minimum temperature is below {thresh}℃",
                        cell_methods='time: minimum within days time: sum over days',
-                       compute=_ind.tn_days_below,
+                       compute=indices.tn_days_below,
                        )
 
 tx_days_above = Tasmax(identifier='txgt_{thresh}',
@@ -85,7 +81,7 @@ tx_days_above = Tasmax(identifier='txgt_{thresh}',
                        long_name='Number of days with Tmax > {thresh}C',
                        description="{freq} number of days where daily maximum temperature exceeds {thresh}℃",
                        cell_methods='time: maximum within days time: sum over days',
-                       compute=_ind.tx_days_above,
+                       compute=indices.tx_days_above,
                        )
 
 tx_tn_days_above = TasminTasmax(identifier='txgt_{thresh_tasmax}_tngt_{thresh_tasmin}',
@@ -95,7 +91,7 @@ tx_tn_days_above = TasminTasmax(identifier='txgt_{thresh_tasmax}_tngt_{thresh_ta
                                 description="{freq} number of days where daily maximum temperature exceeds"
                                             " {thresh_tasmax}℃ and minimum temperature exceeds {thresh_tasmin}℃",
                                 cell_methods='',
-                                compute=_ind.tx_tn_days_above,
+                                compute=indices.tx_tn_days_above,
                                 )
 
 heat_wave_frequency = TasminTasmax(identifier='heat_wave_frequency',
@@ -110,7 +106,7 @@ heat_wave_frequency = TasminTasmax(identifier='heat_wave_frequency',
                                                "over a minimum number of days ({window}).",
                                    cell_methods='',
                                    keywords="health,",
-                                   compute=_ind.heat_wave_frequency,
+                                   compute=indices.heat_wave_frequency,
                                    )
 
 heat_wave_max_length = TasminTasmax(identifier='heat_wave_max_length',
@@ -125,7 +121,7 @@ heat_wave_max_length = TasminTasmax(identifier='heat_wave_max_length',
                                                 "a minimum number of days ({window}).",
                                     cell_methods='',
                                     keywords="health,",
-                                    compute=_ind.heat_wave_max_length,
+                                    compute=indices.heat_wave_max_length,
                                     )
 
 heat_wave_index = Tasmax(identifier='hwi_{thresh}',
@@ -135,7 +131,7 @@ heat_wave_index = Tasmax(identifier='hwi_{thresh}',
                          description='{freq} number of days that are part of a heatwave, '
                                      'defined as five or more consecutive days over {thresh}℃',
                          cell_methods='',
-                         compute=_ind.heat_wave_index,
+                         compute=indices.heat_wave_index,
                          )
 
 tg_mean = Tas(identifier='tg_mean',
@@ -144,7 +140,7 @@ tg_mean = Tas(identifier='tg_mean',
               long_name="Mean daily mean temperature",
               description="{freq} mean of daily mean temperature.",
               cell_methods='time: mean within days time: mean over days',
-              compute=_ind.tg_mean, )
+              compute=indices.tg_mean, )
 
 tx_mean = Tasmax(identifier='tx_mean',
                  units='K',
@@ -152,7 +148,7 @@ tx_mean = Tasmax(identifier='tx_mean',
                  long_name='Mean daily maximum temperature',
                  description='{freq} mean of daily maximum temperature.',
                  cell_methods='time: maximum within days time: mean over days',
-                 compute=_ind.tx_mean,
+                 compute=indices.tx_mean,
                  )
 
 tx_max = Tasmax(identifier='tx_max',
@@ -161,7 +157,7 @@ tx_max = Tasmax(identifier='tx_max',
                 long_name='Maximum daily maximum temperature',
                 description='{freq} maximum of daily maximum temperature.',
                 cell_methods='time: maximum within days time: maximum over days',
-                compute=_ind.tx_max,
+                compute=indices.tx_max,
                 )
 
 tx_min = Tasmax(identifier='tx_min',
@@ -170,7 +166,7 @@ tx_min = Tasmax(identifier='tx_min',
                 long_name='Minimum daily maximum temperature',
                 description='{freq} minimum of daily maximum temperature.',
                 cell_methods='time: maximum within days time: minimum over days',
-                compute=_ind.tx_min,
+                compute=indices.tx_min,
                 )
 
 tn_mean = Tasmin(identifier='tn_mean',
@@ -179,7 +175,7 @@ tn_mean = Tasmin(identifier='tn_mean',
                  long_name='Mean daily minimum temperature',
                  description='{freq} mean of daily minimum temperature.',
                  cell_methods='time: minimum within days time: mean over days',
-                 compute=_ind.tn_mean,
+                 compute=indices.tn_mean,
                  )
 
 tn_max = Tasmin(identifier='tn_max',
@@ -188,7 +184,7 @@ tn_max = Tasmin(identifier='tn_max',
                 long_name='Maximum daily minimum temperature',
                 description='{freq} maximum of daily minimum temperature.',
                 cell_methods='time: minimum within days time: maximum over days',
-                compute=_ind.tn_max,
+                compute=indices.tn_max,
                 )
 
 tn_min = Tasmin(identifier='tn_min',
@@ -197,7 +193,7 @@ tn_min = Tasmin(identifier='tn_min',
                 long_name='Minimum daily minimum temperature',
                 description='{freq} minimum of daily minimum temperature.',
                 cell_methods='time: minimum within days time: minimum over days',
-                compute=_ind.tn_min,
+                compute=indices.tn_min,
                 )
 
 daily_temperature_range = TasminTasmax(identifier='dtr',
@@ -206,7 +202,7 @@ daily_temperature_range = TasminTasmax(identifier='dtr',
                                        long_name='Mean Diurnal Temperature Range',
                                        description='{freq} mean diurnal temperature range',
                                        cell_methods='time range within days time: mean over days',
-                                       compute=_ind.daily_temperature_range,
+                                       compute=indices.daily_temperature_range,
                                        )
 
 daily_temperature_range_variability = TasminTasmax(identifier='dtrvar',
@@ -219,7 +215,7 @@ daily_temperature_range_variability = TasminTasmax(identifier='dtrvar',
                                                                'for the given time period)',
                                                    cell_methods='time range within days time: difference '
                                                                 'over days time: mean over days',
-                                                   compute=_ind.daily_temperature_range_variability,
+                                                   compute=indices.daily_temperature_range_variability,
                                                    )
 
 extreme_temperature_range = TasminTasmax(identifier='etr',
@@ -229,7 +225,7 @@ extreme_temperature_range = TasminTasmax(identifier='etr',
 
                                          description='{freq} range between the maximum of daily max temperature '
                                                      '(tx_max) and the minimum of daily min temperature (tn_min)',
-                                         compute=_ind.extreme_temperature_range,
+                                         compute=indices.extreme_temperature_range,
                                          )
 
 cold_spell_duration_index = Tasmin(identifier='csdi_{window}',
@@ -237,12 +233,12 @@ cold_spell_duration_index = Tasmin(identifier='csdi_{window}',
                                    standard_name='cold_spell_duration_index',
                                    long_name='Cold Spell Duration Index, count of days with at '
                                              'least {window} consecutive days when Tmin < 10th percentile',
-                                   descrition='{freq} number of days with at least {window} consecutive days'
+                                   description='{freq} number of days with at least {window} consecutive days'
                                               ' where the daily minimum temperature is below the 10th '
                                               'percentile. The 10th percentile should be computed for '
                                               'a 5-day window centred on each calendar day in the  1961-1990 period',
                                    cell_methods='',
-                                   compute=_ind.cold_spell_duration_index,
+                                   compute=indices.cold_spell_duration_index,
                                    )
 
 cold_spell_days = Tas(identifier='csi_{thresh}',
@@ -253,7 +249,7 @@ cold_spell_days = Tas(identifier='csi_{thresh}',
                                   'or more consecutive days with mean daily '
                                   'temperature below  {thresh}°C',
                       cell_methods='',
-                      compute=_ind.cold_spell_days,
+                      compute=indices.cold_spell_days,
                       )
 
 daily_freezethaw_cycles = TasminTasmax(identifier='dlyfrzthw',
@@ -263,7 +259,7 @@ daily_freezethaw_cycles = TasminTasmax(identifier='dlyfrzthw',
                                        description='{freq} number of days with a diurnal freeze-thaw cycle '
                                                    ': Tmax > 0℃ and Tmin < 0℃',
                                        cell_methods='',
-                                       compute=_ind.daily_freezethaw_cycles,
+                                       compute=indices.daily_freezethaw_cycles,
                                        )
 
 cooling_degree_days = Tas(identifier='cddcold_{thresh}',
@@ -272,7 +268,7 @@ cooling_degree_days = Tas(identifier='cddcold_{thresh}',
                           long_name='Cooling Degree Days (Tmean > {thresh}C)',
                           description='{freq} cooling degree days above {thresh}°C',
                           cell_methods='time: mean within days time: sum over days',
-                          compute=_ind.cooling_degree_days,
+                          compute=indices.cooling_degree_days,
                           )
 
 heating_degree_days = Tas(identifier='hddheat_{thresh}',
@@ -281,7 +277,7 @@ heating_degree_days = Tas(identifier='hddheat_{thresh}',
                           long_name='Heating Degree Days (Tmean < {thresh}C)',
                           description='{freq} heating degree days below {thresh}°C',
                           cell_methods='time: mean within days time: sum over days',
-                          compute=_ind.heating_degree_days,
+                          compute=indices.heating_degree_days,
                           )
 
 growing_degree_days = Tas(identifier='gddgrow_{thresh}',
@@ -290,7 +286,7 @@ growing_degree_days = Tas(identifier='gddgrow_{thresh}',
                           long_name='growing degree days above {thresh}',
                           description='{freq} growing degree days above {thresh}°C',
                           cell_methods='time: mean within days time: sum over days',
-                          compute=_ind.growing_degree_days,
+                          compute=indices.growing_degree_days,
                           )
 
 freshet_start = Tas(identifier='freshet_start',
@@ -299,8 +295,7 @@ freshet_start = Tas(identifier='freshet_start',
                     long_name="Day of year of spring freshet start",
                     description="Day of year of spring freshet start, defined as the first day a temperature "
                                 "threshold of {thresh} is exceeded for at least {window} days.",
-                    compute=_ind.freshet_start)
-
+                    compute=indices.freshet_start)
 
 frost_days = Tasmin(identifier='frost_days',
                     units='days',
@@ -309,7 +304,7 @@ frost_days = Tasmin(identifier='frost_days',
                     description='{freq} number of days with minimum daily '
                                 'temperature below 0°C',
                     cell_methods='time: minimum within days time: sum over days',
-                    compute=_ind.frost_days,
+                    compute=indices.frost_days,
                     )
 
 ice_days = Tasmax(identifier='ice_days',
@@ -319,7 +314,7 @@ ice_days = Tasmax(identifier='ice_days',
                   description='{freq} number of days with maximum daily '
                               'temperature below 0°C',
                   cell_methods='time: maximum within days time: sum over days',
-                  compute=_ind.ice_days,
+                  compute=indices.ice_days,
                   )
 
 consecutive_frost_days = Tasmin(identifier='consecutive_frost_days',
@@ -329,7 +324,7 @@ consecutive_frost_days = Tasmin(identifier='consecutive_frost_days',
                                 description='{freq} maximum number of consecutive days with '
                                             'minimum daily temperature below 0°C',
                                 cell_methods='time: min within days time: maximum over days',
-                                compute=_ind.consecutive_frost_days,
+                                compute=indices.consecutive_frost_days,
                                 )
 
 growing_season_length = Tas(identifier='gsl_{thresh}',
@@ -342,7 +337,7 @@ growing_season_length = Tas(identifier='gsl_{thresh}',
                                         'mean daily temperature below {thresh}℃ after July 1st in the northern '
                                         'hemisphere and January 1st in the southern hemisphere',
                             cell_methods='',
-                            compute=_ind.growing_season_length,
+                            compute=indices.growing_season_length,
                             )
 
 tropical_nights = Tasmin(identifier='tr_{thresh}',
@@ -352,7 +347,7 @@ tropical_nights = Tasmin(identifier='tr_{thresh}',
                          description='{freq} number of Tropical Nights : defined as days with minimum daily temperature'
                                      ' above {thresh}℃',
                          cell_methods='time: minimum within days time: sum over days',
-                         compute=_ind.tropical_nights,
+                         compute=indices.tropical_nights,
                          )
 
 tg90p = Tas(identifier='tg90p',
@@ -363,7 +358,7 @@ tg90p = Tas(identifier='tg90p',
                         'The 90th percentile is to be computed for a 5 day window centered on each calendar day '
                         'for a reference period',
             cell_methods='time: mean within days time: sum over days',
-            compute=_ind.tg90p,
+            compute=indices.tg90p,
             )
 
 tg10p = Tas(identifier='tg10p',
@@ -374,7 +369,7 @@ tg10p = Tas(identifier='tg10p',
                         'The 10th percentile is to be computed for a 5 day window centered on each calendar day '
                         'for a reference period',
             cell_methods='time: mean within days time: sum over days',
-            compute=_ind.tg10p
+            compute=indices.tg10p
             )
 
 tx90p = Tasmax(identifier='tx90p',
@@ -385,7 +380,7 @@ tx90p = Tasmax(identifier='tx90p',
                            'The 90th percentile is to be computed for a 5 day window centered on each calendar day '
                            'for a reference period',
                cell_methods='time: maximum within days time: sum over days',
-               compute=_ind.tx90p,
+               compute=indices.tx90p,
                )
 
 tx10p = Tasmax(identifier='tx10p',
@@ -396,7 +391,7 @@ tx10p = Tasmax(identifier='tx10p',
                            'The 10th percentile is to be computed for a 5 day window centered on each calendar day '
                            'for a reference period',
                cell_methods='time: maximum within days time: sum over days',
-               compute=_ind.tx10p
+               compute=indices.tx10p
                )
 
 tn90p = Tasmin(identifier='tn90p',
@@ -407,7 +402,7 @@ tn90p = Tasmin(identifier='tn90p',
                            'The 90th percentile is to be computed for a 5 day window centered on each calendar day '
                            'for a reference period',
                cell_methods='time: minimum within days time: sum over days',
-               compute=_ind.tn90p,
+               compute=indices.tn90p,
                )
 
 tn10p = Tasmin(identifier='tn10p',
@@ -418,5 +413,5 @@ tn10p = Tasmin(identifier='tn10p',
                            'The 10th percentile is to be computed for a 5 day window centered on each calendar day '
                            'for a reference period',
                cell_methods='time: minimum within days time: sum over days',
-               compute=_ind.tn10p
+               compute=indices.tn10p
                )
diff --git a/xclim/ensembles.py b/xclim/ensembles.py
new file mode 100644
index 00000000..9814703e
--- /dev/null
+++ b/xclim/ensembles.py
@@ -0,0 +1,272 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+
+def create_ensemble(ncfiles, mf_flag=False):
+    """Create an xarray datset of ensemble of climate simulation from a list of netcdf files. Input data is
+    concatenated along a newly created data dimension ('realization')
+
+    Returns a xarray dataset object containing input data from the list of netcdf files concatenated along
+    a new dimension (name:'realization'). In the case where input files have unequal time dimensions output
+    ensemble dataset is created for overlapping time-steps common to all input files
+
+    Parameters
+    ----------
+    ncfiles : sequence
+      List of netcdf file paths. If mf_flag is true ncfiles should be a list of lists where
+    each sublist contains input .nc files of a multifile dataset
+
+    mf_flag : Boolean . If true climate simulations are treated as multifile datasets before concatenation
+
+    Returns
+    -------
+    xarray dataset containing concatenated data from all input files
+
+    Notes
+    -----
+    Input netcdf files require equal spatial dimension size (e.g. lon, lat dimensions)
+    If input data contains multiple cftime calendar types they must be at monthly or coarser frequency
+
+    Examples
+    --------
+    >>> from xclim import utils
+    >>> import glob
+    >>> ncfiles = glob.glob('/*.nc')
+    >>> ens = utils.create_ensemble(ncfiles)
+    >>> print(ens)
+    Using multifile datasets:
+    simulation 1 is a list of .nc files (e.g. separated by time)
+    >>> ncfiles = glob.glob('dir/*.nc')
+    simulation 2 is also a list of .nc files
+    >>> ens = utils.create_ensemble(ncfiles)
+    """
+    dim = 'realization'
+    ds1 = []
+    start_end_flag = True
+    print('finding common time-steps')
+    for n in ncfiles:
+        if mf_flag:
+            ds = xr.open_mfdataset(n, concat_dim='time', decode_times=False, chunks={'time': 10})
+            ds['time'] = xr.open_mfdataset(n).time
+        else:
+            ds = xr.open_dataset(n, decode_times=False)
+            ds['time'] = xr.decode_cf(ds).time
+        # get times - use common
+        time1 = pd.to_datetime({'year': ds.time.dt.year, 'month': ds.time.dt.month, 'day': ds.time.dt.day})
+        if start_end_flag:
+            start1 = time1.values[0]
+            end1 = time1.values[-1]
+            start_end_flag = False
+        if time1.values.min() > start1:
+            start1 = time1.values.min()
+        if time1.values.max() < end1:
+            end1 = time1.values.max()
+
+    for n in ncfiles:
+        print('accessing file ', ncfiles.index(n) + 1, ' of ', len(ncfiles))
+        if mf_flag:
+            ds = xr.open_mfdataset(n, concat_dim='time', decode_times=False, chunks={'time': 10})
+            ds['time'] = xr.open_mfdataset(n).time
+        else:
+            ds = xr.open_dataset(n, decode_times=False, chunks={'time': 10})
+            ds['time'] = xr.decode_cf(ds).time
+
+        ds['time'].values = pd.to_datetime({'year': ds.time.dt.year, 'month': ds.time.dt.month, 'day': ds.time.dt.day})
+
+        ds = ds.where((ds.time >= start1) & (ds.time <= end1), drop=True)
+
+        ds1.append(ds.drop('time'))
+    print('concatenating files : adding dimension ', dim, )
+    ens = xr.concat(ds1, dim=dim)
+    # assign time coords
+    ens = ens.assign_coords(time=ds.time.values)
+    return ens
+
+
+def ensemble_mean_std_max_min(ens):
+    """Calculate ensemble statistics between a results from an ensemble of climate simulations
+
+    Returns a dataset containing ensemble mean, standard-deviation,
+    minimum and maximum for input climate simulations.
+
+    Parameters
+    ----------
+    ens : Ensemble dataset (see xclim.utils.create_ensemble)
+
+    Returns
+    -------
+    xarray dataset with containing data variables of ensemble statistics
+
+    Examples
+    --------
+    >>> from xclim import utils
+    >>> import glob
+    >>> ncfiles = glob.glob('/*tas*.nc')
+    Create ensemble dataset
+    >>> ens = utils.create_ensemble(ncfiles)
+    Calculate ensemble statistics
+    >>> ens_means_std = utils.ensemble_mean_std_max_min(ens)
+    >>> print(ens_mean_std['tas_mean'])
+    """
+    dsOut = ens.drop(ens.data_vars)
+    for v in ens.data_vars:
+
+        dsOut[v + '_mean'] = ens[v].mean(dim='realization')
+        dsOut[v + '_stdev'] = ens[v].std(dim='realization')
+        dsOut[v + '_max'] = ens[v].max(dim='realization')
+        dsOut[v + '_min'] = ens[v].min(dim='realization')
+        for vv in dsOut.data_vars:
+            dsOut[vv].attrs = ens[v].attrs
+
+            if 'description' in dsOut[vv].attrs.keys():
+                vv.split()
+                dsOut[vv].attrs['description'] = dsOut[vv].attrs['description'] + ' : ' + vv.split('_')[
+                    -1] + ' of ensemble'
+
+    return dsOut
+
+
+def ensemble_percentiles(ens, values=(10, 50, 90), time_block=None):
+    """Calculate ensemble statistics between a results from an ensemble of climate simulations
+
+    Returns a dataset containing ensemble statistics for input climate simulations.
+    Alternatively calculate ensemble percentiles (default) or ensemble mean and standard deviation
+
+    Parameters
+    ----------
+    ens : Ensemble dataset (see xclim.utils.create_ensemble)
+    values : tuple of integers - percentile values to calculate  : default : (10, 50, 90)
+    time_block : integer
+      for large ensembles iteratively calculate percentiles in time-step blocks (n==time_block).
+       If not defined the function tries to estimate an appropriate value
+
+    Returns
+    -------
+    xarray dataset with containing data variables of requested ensemble statistics
+
+    Examples
+    --------
+    >>> from xclim import utils
+    >>> import glob
+    >>> ncfiles = glob.glob('/*tas*.nc')
+    Create ensemble dataset
+    >>> ens = utils.create_ensemble(ncfiles)
+    Calculate default ensemble percentiles
+    >>> ens_percs = utils.ensemble_statistics(ens)
+    >>> print(ens_percs['tas_p10'])
+    Calculate non-default percentiles (25th and 75th)
+    >>> ens_percs = utils.ensemble_statistics(ens, values=(25,75))
+    >>> print(ens_percs['tas_p25'])
+    Calculate by time blocks (n=10) if ensemble size is too large to load in memory
+    >>> ens_percs = utils.ensemble_statistics(ens, time_block=10)
+    >>> print(ens_percs['tas_p25'])
+
+    """
+
+    ds_out = ens.drop(ens.data_vars)
+    dims = list(ens.dims)
+    for v in ens.data_vars:
+        # Percentile calculation requires load to memory : automate size for large ensemble objects
+        if not time_block:
+            time_block = round(2E8 / (ens[v].size / ens[v].shape[dims.index('time')]), -1)  # 2E8
+
+        if time_block > len(ens[v].time):
+            out = _calc_percentiles_simple(ens, v, values)
+
+        else:
+            # loop through blocks
+            Warning('large ensemble size detected : statistics will be calculated in blocks of ', int(time_block),
+                    ' time-steps')
+            out = _calc_percentiles_blocks(ens, v, values, time_block)
+        for vv in out.data_vars:
+            ds_out[vv] = out[vv]
+    return ds_out
+
+
+def _calc_percentiles_simple(ens, v, values):
+    ds_out = ens.drop(ens.data_vars)
+    dims = list(ens[v].dims)
+    outdims = [x for x in dims if 'realization' not in x]
+
+    print('loading ensemble data to memory')
+    arr = ens[v].load()  # percentile calc requires loading the array
+    coords = {}
+    for c in outdims:
+        coords[c] = arr[c]
+    for p in values:
+        outvar = v + '_p' + str(p)
+
+        out1 = _calc_perc(arr, p)
+
+        ds_out[outvar] = xr.DataArray(out1, dims=outdims, coords=coords)
+        ds_out[outvar].attrs = ens[v].attrs
+        if 'description' in ds_out[outvar].attrs.keys():
+            ds_out[outvar].attrs['description'] = '{} : {}th percentile of ensemble'.format(
+                ds_out[outvar].attrs['description'], str(p))
+        else:
+            ds_out[outvar].attrs['description'] = '{}th percentile of ensemble'.format(str(p))
+
+    return ds_out
+
+
+def _calc_percentiles_blocks(ens, v, values, time_block):
+    ds_out = ens.drop(ens.data_vars)
+    dims = list(ens[v].dims)
+    outdims = [x for x in dims if 'realization' not in x]
+
+    blocks = list(range(0, len(ens.time) + 1, int(time_block)))
+    if blocks[-1] != len(ens[v].time):
+        blocks.append(len(ens[v].time))
+    arr_p_all = {}
+    for t in range(0, len(blocks) - 1):
+        print('Calculating block ', t + 1, ' of ', len(blocks) - 1)
+        time_sel = slice(blocks[t], blocks[t + 1])
+        arr = ens[v].isel(time=time_sel).load()  # percentile calc requires loading the array
+        coords = {}
+        for c in outdims:
+            coords[c] = arr[c]
+        for p in values:
+
+            out1 = _calc_perc(arr, p)
+
+            if t == 0:
+                arr_p_all[str(p)] = xr.DataArray(out1, dims=outdims, coords=coords)
+            else:
+                arr_p_all[str(p)] = xr.concat([arr_p_all[str(p)],
+                                               xr.DataArray(out1, dims=outdims, coords=coords)], dim='time')
+    for p in values:
+        outvar = v + '_p' + str(p)
+        ds_out[outvar] = arr_p_all[str(p)]
+        ds_out[outvar].attrs = ens[v].attrs
+        if 'description' in ds_out[outvar].attrs.keys():
+            ds_out[outvar].attrs['description'] = '{} : {}th percentile of ensemble'.format(
+                ds_out[outvar].attrs['description'], str(p))
+        else:
+            ds_out[outvar].attrs['description'] = '{}th percentile of ensemble'.format(str(p))
+
+    return ds_out
+
+
+def _calc_perc(arr, p):
+    dims = arr.dims
+    # make sure time is the second dimension
+    if dims.index('time') != 1:
+        dims1 = [dims[dims.index('realization')], dims[dims.index('time')]]
+        for d in dims:
+            if d not in dims1:
+                dims1.append(d)
+        arr = arr.transpose(*dims1)
+        dims = dims1
+
+    nan_count = np.isnan(arr).sum(axis=dims.index('realization'))
+    out = np.percentile(arr, p, axis=dims.index('realization'))
+    if np.any((nan_count > 0) & (nan_count < arr.shape[dims.index('realization')])):
+        arr1 = arr.values.reshape(arr.shape[dims.index('realization')],
+                                  int(arr.size / arr.shape[dims.index('realization')]))
+        # only use nanpercentile where we need it (slow performace compared to standard) :
+        nan_index = np.where((nan_count > 0) & (nan_count < arr.shape[dims.index('realization')]))
+        t = np.ravel_multi_index(nan_index, nan_count.shape)
+        out[np.unravel_index(t, nan_count.shape)] = np.nanpercentile(arr1[:, t], p, axis=dims.index('realization'))
+
+    return out
diff --git a/xclim/generic.py b/xclim/generic.py
index 338864d7..c6d762e5 100644
--- a/xclim/generic.py
+++ b/xclim/generic.py
@@ -3,8 +3,8 @@
 # The other parameters, common to all distribution, are loc and scale.
 
 import dask
-import xarray as xr
 import numpy as np
+import xarray as xr
 
 
 def select_time(da, **indexer):
@@ -163,10 +163,10 @@ def fa(arr, t, dist='norm', mode='high'):
     # Create a lambda function to facilitate passing arguments to dask. There is probably a better way to do this.
     if mode in ['max', 'high']:
         def func(x):
-            return dc.isf(1./t, *x)
+            return dc.isf(1. / t, *x)
     elif mode in ['min', 'low']:
         def func(x):
-            return dc.ppf(1./t, *x)
+            return dc.ppf(1. / t, *x)
     else:
         raise ValueError("mode `{}` should be either 'max' or 'min'".format(mode))
 
diff --git a/xclim/indices.py b/xclim/indices.py
deleted file mode 100644
index f9e3633a..00000000
--- a/xclim/indices.py
+++ /dev/null
@@ -1,2222 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Indices library
-===============
-
-This module describes climate indicator functions. Functions are listed in alphabetical order and describe the raw
-computation performed over xarray.DataArrays. DataArrays should carry unit information to allow for any needed
-unit conversions. The output's attributes (CF-Convention) are not modified. Validation checks and output attributes
-are handled by indicator classes described in files named by the physical variable (temperature, precip, streamflow).
-
-Notes for docstring
--------------------
-
-The docstrings adhere to the `NumPy`_ style convention and is meant as a way to store CF-Convention metadata as
-well as information relevant to third party libraries (such as a WPS server).
-
-The first line of the docstring (the short summary), will be assigned to the output's `long_name` attribute. The
-`long_name` attribute is defined by the NetCDF User Guide to contain a long descriptive name which may, for example,
-be used for labeling plots
-
-The second paragraph will be considered as the "*abstract*", or the CF global "*comment*" (miscellaneous information
-about the data or methods used to produce it).
-
-The third and fourth sections are the **Parameters** and **Returns** sections describing the input and output values
-respectively.
-
-.. code-block:: python
-
-   Parameters
-   ----------
-   <standard_name> : xarray.DataArray
-     <Long_name> of variable [acceptable units].
-   threshold : string
-     Description of the threshold / units.
-     e.g. The 10th percentile of historical temperature [K].
-   freq : str, optional
-     Resampling frequency.
-
-   Returns
-   -------
-   xarray.DataArray
-     Output's <long_name> [units]
-
-The next sections would be **Notes** and **References**:
-
-.. code-block:: python
-
-    Notes
-    -----
-    This is where the mathematical equation is described.
-    At the end of the description, convention suggests
-    to add a reference [example]_:
-
-        .. math::
-
-            3987^12 + 4365^12 = 4472^12
-
-    References
-    ----------
-    .. [example] Smith, T.J. and Huard, D. (2018). "CF Docstrings:
-        A manifesto on conventions and the metaphysical nature
-        of ontological python documentation." Climate Aesthetics,
-        vol. 1, pp. 121-155.
-
-Indice descriptions
-===================
-.. _`NumPy`: https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard
-"""
-import logging
-import numpy as np
-from . import utils
-import xarray as xr
-from . import run_length as rl
-from .utils import units, declare_units
-
-logging.basicConfig(level=logging.DEBUG)
-logging.captureWarnings(True)
-
-xr.set_options(enable_cftimeindex=True)  # Set xarray to use cftimeindex
-
-# if six.PY2:
-#     from funcsigs import signature
-# elif six.PY3:
-#     from inspect import signature
-
-
-# Frequencies : YS: year start, QS-DEC: seasons starting in december, MS: month start
-# See http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
-
-ftomm = np.nan
-
-
-# TODO: Define a unit conversion system for temperature [K, C, F] and precipitation [mm h-1, Kg m-2 s-1] metrics
-# TODO: Move utility functions to another file.
-# TODO: Should we reference the standard vocabulary we're using ?
-# E.g. http://vocab.nerc.ac.uk/collection/P07/current/BHMHISG2/
-
-
-# -------------------------------------------------- #
-# ATTENTION: ASSUME ALL INDICES WRONG UNTIL TESTED ! #
-# -------------------------------------------------- #
-
-@declare_units('', q='[discharge]')
-def base_flow_index(q, freq='YS'):
-    r"""Base flow index
-
-    Return the base flow index, defined as the minimum 7-day average flow divided by the mean flow.
-
-    Parameters
-    ----------
-    q : xarray.DataArray
-      Rate of river discharge [m³/s]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArrray
-      Base flow index.
-
-    Notes
-    -----
-    Let :math:`\mathbf{q}=q_0, q_1, \ldots, q_n` be the sequence of daily discharge and :math:`\overline{\mathbf{q}}`
-    the mean flow over the period. The base flow index is given by:
-
-    .. math::
-
-       \frac{\min(\mathrm{CMA}_7(\mathbf{q}))}{\overline{\mathbf{q}}}
-
-
-    where :math:`\mathrm{CMA}_7` is the seven days moving average of the daily flow:
-
-    .. math::
-
-       \mathrm{CMA}_7(q_i) = \frac{\sum_{j=i-3}^{i+3} q_j}{7}
-
-    """
-
-    m7 = q.rolling(time=7, center=True).mean().resample(time=freq)
-    mq = q.resample(time=freq)
-
-    m7m = m7.min(dim='time')
-    return m7m / mq.mean(dim='time')
-
-
-@declare_units('days', tasmin='[temperature]', tn10='[temperature]')
-def cold_spell_duration_index(tasmin, tn10, window=6, freq='YS'):
-    r"""Cold spell duration index
-
-    Number of days with at least six consecutive days where the daily minimum temperature is below the 10th
-    percentile.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature.
-    tn10 : float
-      10th percentile of daily minimum temperature.
-    window : int
-      Minimum number of days with temperature below threshold to qualify as a cold spell. Default: 6.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with at least six consecutive days where the daily minimum temperature is below the 10th
-      percentile [days].
-
-    Notes
-    -----
-    Let :math:`TN_i` be the minimum daily temperature for the day of the year :math:`i` and :math:`TN10_i` the 10th
-    percentile of the minimum daily temperature over the 1961-1990 period for day of the year :math:`i`, the cold spell
-    duration index over period :math:`\phi` is defined as:
-
-    .. math::
-
-       \sum_{i \in \phi} \prod_{j=i}^{i+6} \left[ TN_j < TN10_j \right]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
-
-    References
-    ----------
-    From the Expert Team on Climate Change Detection, Monitoring and Indices (ETCCDMI).
-
-    Example
-    -------
-    >>> tn10 = percentile_doy(historical_tasmin, per=.1)
-    >>> cold_spell_duration_index(reference_tasmin, tn10)
-    """
-    if 'dayofyear' not in tn10.coords.keys():
-        raise AttributeError("tn10 should have dayofyear coordinates.")
-
-    # The day of year value of the tasmin series.
-    doy = tasmin.indexes['time'].dayofyear
-
-    tn10 = utils.convert_units_to(tn10, tasmin)
-    # If calendar of `tn10` is different from `tasmin`, interpolate.
-    tn10 = utils.adjust_doy_calendar(tn10, tasmin)
-
-    # Create an array with the shape and coords of tasmin, but with values set to tx90 according to the doy index.
-    thresh = xr.full_like(tasmin, np.nan)
-    thresh.data = tn10.sel(dayofyear=doy)
-
-    below = (tasmin < thresh)
-
-    return below.resample(time=freq).apply(rl.windowed_run_count, window=window, dim='time')
-
-
-@declare_units('days', tas='[temperature]', thresh='[temperature]')
-def cold_spell_days(tas, thresh='-10 degC', window=5, freq='AS-JUL'):
-    r"""Cold spell days
-
-    The number of days that are part of a cold spell, defined as five or more consecutive days with mean daily
-    temperature below a threshold in °C.
-
-    Parameters
-    ----------
-    tas : xarrray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature below which a cold spell begins [℃] or [K]. Default : '-10 degC'
-    window : int
-      Minimum number of days with temperature below threshold to qualify as a cold spell.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Cold spell days.
-
-    Notes
-    -----
-    Let :math:`T_i` be the mean daily temperature on day :math:`i`, the number of cold spell days during
-    period :math:`\phi` is given by
-
-    .. math::
-
-       \sum_{i \in \phi} \prod_{j=i}^{i+5} [T_j < thresh]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
-
-    """
-    t = utils.convert_units_to(thresh, tas)
-    over = tas < t
-    group = over.resample(time=freq)
-
-    return group.apply(rl.windowed_run_count, window=window, dim='time')
-
-
-def cold_and_dry_days(tas, tgin25, pr, wet25, freq='YS'):
-    r"""Cold and dry days.
-
-    Returns the total number of days where "Cold" and "Dry" conditions coincide.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature values [℃] or [K]
-    tgin25 : xarray.DataArray
-      First quartile of daily mean temperature computed by month.
-    pr : xarray.DataArray
-      Daily precipitation.
-    wet25 : xarray.DataArray
-      First quartile of daily total precipitation computed by month.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The total number of days where cold and dry conditions coincide.
-
-    Notes
-    -----
-    Formula to be written [cold_dry_days]_.
-
-    References
-    ----------
-    .. [cold_dry_days] Beniston, M. (2009). Trends in joint quantiles of temperature and precipitation in Europe
-        since 1901 and projected for 2100. Geophysical Research Letters, 36(7). https://doi.org/10.1029/2008GL037119
-    """
-    raise NotImplementedError
-    # There is an issue with the 1 mm threshold. It makes no sense to assume a day with < 1mm is not dry.
-    # c1 = tas < utils.convert_units_to(tgin25, tas)
-    # c2 = (pr > utils.convert_units_to('1 mm', pr)) * (pr < utils.convert_units_to(wet25, pr))
-
-    # c = (c1 * c2) * 1
-    # return c.resample(time=freq).sum(dim='time')
-
-
-@declare_units('mm/day', pr='[precipitation]', thresh='[precipitation]')
-def daily_pr_intensity(pr, thresh='1 mm/day', freq='YS'):
-    r"""Average daily precipitation intensity
-
-    Return the average precipitation over wet days.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Daily precipitation [mm/d or kg/m²/s]
-    thresh : str
-      precipitation value over which a day is considered wet. Default : '1 mm/day'
-    freq : str, optional
-      Resampling frequency defining the periods
-      defined in http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling. Default : '1 mm/day'
-
-    Returns
-    -------
-    xarray.DataArray
-      The average precipitation over wet days for each period
-
-    Notes
-    -----
-    Let :math:`\mathbf{p} = p_0, p_1, \ldots, p_n` be the daily precipitation and :math:`thresh` be the precipitation
-    threshold defining wet days. Then the daily precipitation intensity is defined as
-
-    .. math::
-
-       \frac{\sum_{i=0}^n p_i [p_i \leq thresh]}{\sum_{i=0}^n [p_i \leq thresh]}
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `pr.day.nc` the average
-    precipitation fallen over days with precipitation >= 5 mm at seasonal
-    frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
-
-    >>> pr = xr.open_dataset('pr.day.nc')
-    >>> daily_int = daily_pr_intensity(pr, thresh='5 mm/day', freq="QS-DEC")
-
-    """
-    t = utils.convert_units_to(thresh, pr, 'hydro')
-
-    # put pr=0 for non wet-days
-    pr_wd = xr.where(pr >= t, pr, 0)
-    pr_wd.attrs['units'] = pr.units
-
-    # sum over wanted period
-    s = pr_wd.resample(time=freq).sum(dim='time', keep_attrs=True)
-    sd = utils.pint_multiply(s, 1 * units.day, 'mm')
-
-    # get number of wetdays over period
-    wd = wetdays(pr, thresh=thresh, freq=freq)
-    return sd / wd
-
-
-@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
-def maximum_consecutive_dry_days(pr, thresh='1 mm/day', freq='YS'):
-    r"""Maximum number of consecutive dry days
-
-    Return the maximum number of consecutive days within the period where precipitation
-    is below a certain threshold.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [mm]
-    thresh : str
-      Threshold precipitation on which to base evaluation [mm]. Default : '1 mm/day'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The maximum number of consecutive dry days.
-
-    Notes
-    -----
-    Let :math:`\mathbf{p}=p_0, p_1, \ldots, p_n` be a daily precipitation series and :math:`thresh` the threshold
-    under which a day is considered dry. Then let :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where
-    :math:`[p_i < thresh] \neq [p_{i+1} < thresh]`, that is, the days when the temperature crosses the threshold.
-    Then the maximum number of consecutive dry days is given by
-
-    .. math::
-
-       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [p_{s_j} > thresh]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
-    the start and end of the series, but the numerical algorithm does.
-    """
-    t = utils.convert_units_to(thresh, pr, 'hydro')
-    group = (pr < t).resample(time=freq)
-
-    return group.apply(rl.longest_run, dim='time')
-
-
-@declare_units('days', tasmin='[temperature]')
-def consecutive_frost_days(tasmin, freq='AS-JUL'):
-    r"""Maximum number of consecutive frost days (Tmin < 0℃).
-
-    Resample the daily minimum temperature series by computing the maximum number
-    of days below the freezing point over each period.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature values [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The maximum number of consecutive days below the freezing point.
-
-    Notes
-    -----
-    Let :math:`\mathbf{x}=x_0, x_1, \ldots, x_n` be a daily minimum temperature series and
-    :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where :math:`[p_i < 0\celsius] \neq [p_{i+1} <
-    0\celsius]`, that is, the days when the temperature crosses the freezing point.
-    Then the maximum number of consecutive frost days is given by
-
-    .. math::
-
-       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [x_{s_j} > 0\celsius]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
-    the start and end of the series, but the numerical algorithm does.
-    """
-    tu = units.parse_units(tasmin.attrs['units'].replace('-', '**-'))
-    fu = 'degC'
-    frz = 0
-    if fu != tu:
-        frz = units.convert(frz, fu, tu)
-    group = (tasmin < frz).resample(time=freq)
-    return group.apply(rl.longest_run, dim='time')
-
-
-@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
-def maximum_consecutive_wet_days(pr, thresh='1 mm/day', freq='YS'):
-    r"""Consecutive wet days.
-
-    Returns the maximum number of consecutive wet days.
-
-    Parameters
-    ---------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [Kg m-2 s-1] or [mm]
-    thresh : str
-      Threshold precipitation on which to base evaluation [Kg m-2 s-1] or [mm]. Default : '1 mm/day'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The maximum number of consecutive wet days.
-
-    Notes
-    -----
-    Let :math:`\mathbf{x}=x_0, x_1, \ldots, x_n` be a daily precipitation series and
-    :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where :math:`[p_i > thresh] \neq [p_{i+1} >
-    thresh]`, that is, the days when the precipitation crosses the *wet day* threshold.
-    Then the maximum number of consecutive wet days is given by
-
-    .. math::
-
-
-       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [x_{s_j} > 0\celsius]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
-    the start and end of the series, but the numerical algorithm does.
-    """
-    thresh = utils.convert_units_to(thresh, pr, 'hydro')
-
-    group = (pr > thresh).resample(time=freq)
-    return group.apply(rl.longest_run, dim='time')
-
-
-@declare_units('C days', tas='[temperature]', thresh='[temperature]')
-def cooling_degree_days(tas, thresh='18 degC', freq='YS'):
-    r"""Cooling degree days
-
-    Sum of degree days above the temperature threshold at which spaces are cooled.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Temperature threshold above which air is cooled. Default : '18 degC'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Cooling degree days
-
-    Notes
-    -----
-    Let :math:`x_i` be the daily mean temperature at day :math:`i`. Then the cooling degree days above
-    temperature threshold :math:`thresh` over period :math:`\phi` is given by:
-
-    .. math::
-
-        \sum_{i \in \phi} (x_{i}-{thresh} [x_i > thresh]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
-    """
-    thresh = utils.convert_units_to(thresh, tas)
-
-    return tas.pipe(lambda x: x - thresh) \
-        .clip(min=0) \
-        .resample(time=freq) \
-        .sum(dim='time')
-
-
-@declare_units('days', tasmax='[temperature]', tasmin='[temperature]')
-def daily_freezethaw_cycles(tasmax, tasmin, freq='YS'):
-    r"""Number of days with a diurnal freeze-thaw cycle
-
-    The number of days where Tmax > 0℃ and Tmin < 0℃.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    tasmin : xarray.DataArray
-      Minimum daily temperature values [℃] or [K]
-    freq : str
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of days with a diurnal freeze-thaw cycle
-
-    Notes
-    -----
-    Let :math:`TX_{i}` be the maximum temperature at day :math:`i` and :math:`TN_{i}` be
-    the daily minimum temperature at day :math:`i`. Then the number of freeze thaw cycles
-    during period :math:`\phi` is given by :
-
-    .. math::
-
-        \sum_{i \in \phi} [ TX_{i} > 0℃ ] [ TN_{i} <  0℃ ]
-
-    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
-    """
-    frz = utils.convert_units_to('0 degC', tasmax)
-    ft = (tasmin < frz) * (tasmax > frz) * 1
-    out = ft.resample(time=freq).sum(dim='time')
-    return out
-
-
-@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
-def daily_temperature_range(tasmax, tasmin, freq='YS'):
-    r"""Mean of daily temperature range.
-
-    The mean difference between the daily maximum temperature and the daily minimum temperature.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature values [℃] or [K]
-    tasmin : xarray.DataArray
-      Minimum daily temperature values [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The average variation in daily temperature range for the given time period.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at day :math:`i`
-    of period :math:`j`. Then the mean diurnal temperature range in period :math:`j` is:
-
-    .. math::
-
-        DTR_j = \frac{ \sum_{i=1}^I (TX_{ij} - TN_{ij}) }{I}
-    """
-
-    dtr = tasmax - tasmin
-    out = dtr.resample(time=freq).mean(dim='time', keep_attrs=True)
-    out.attrs['units'] = tasmax.units
-    return out
-
-
-# TODO: Improve description.
-@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
-def daily_temperature_range_variability(tasmax, tasmin, freq="YS"):
-    r"""Mean absolute day-to-day variation in daily temperature range.
-
-    Mean absolute day-to-day variation in daily temperature range.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature values [℃] or [K]
-    tasmin : xarray.DataArray
-      Minimum daily temperature values [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The average day-to-day variation in daily temperature range for the given time period.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at
-    day :math:`i` of period :math:`j`. Then calculated is the absolute day-to-day differences in
-    period :math:`j` is:
-
-    .. math::
-
-       vDTR_j = \frac{ \sum_{i=2}^{I} |(TX_{ij}-TN_{ij})-(TX_{i-1,j}-TN_{i-1,j})| }{I}
-    """
-
-    vdtr = abs((tasmax - tasmin).diff(dim='time'))
-    out = vdtr.resample(time=freq).mean(dim='time')
-    out.attrs['units'] = tasmax.units
-    return out
-
-
-@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
-def extreme_temperature_range(tasmax, tasmin, freq='YS'):
-    r"""Extreme intra-period temperature range.
-
-    The maximum of max temperature (TXx) minus the minimum of min temperature (TNn) for the given time period.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature values [℃] or [K]
-    tasmin : xarray.DataArray
-      Minimum daily temperature values [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Extreme intra-period temperature range for the given time period.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at day :math:`i`
-    of period :math:`j`. Then the extreme temperature range in period :math:`j` is:
-
-    .. math::
-
-        ETR_j = max(TX_{ij}) - min(TN_{ij})
-    """
-
-    tx_max = tasmax.resample(time=freq).max(dim='time')
-    tn_min = tasmin.resample(time=freq).min(dim='time')
-
-    out = tx_max - tn_min
-    out.attrs['units'] = tasmax.units
-    return out
-
-
-@declare_units('', tas='[temperature]', thresh='[temperature]')
-def freshet_start(tas, thresh='0 degC', window=5, freq='YS'):
-    r"""First day consistently exceeding threshold temperature.
-
-    Returns first day of period where a temperature threshold is exceeded
-    over a given number of days.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default '0 degC'
-    window : int
-      Minimum number of days with temperature above threshold needed for evaluation
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    float
-      Day of the year when temperature exceeds threshold over a given number of days for the first time. If there are
-      no such day, return np.nan.
-
-    Notes
-    -----
-    Let :math:`x_i` be the daily mean temperature at day of the year :math:`i` for values of :math:`i` going from 1
-    to 365 or 366. The start date of the freshet is given by the smallest index :math:`i` for which
-
-    .. math::
-
-       \prod_{j=i}^{i+w} [x_j > thresh]
-
-    is true, where :math:`w` is the number of days the temperature threshold should be exceeded,  and :math:`[P]` is
-    1 if :math:`P` is true, and 0 if false.
-    """
-    thresh = utils.convert_units_to(thresh, tas)
-    over = (tas > thresh)
-    group = over.resample(time=freq)
-    return group.apply(rl.first_run_ufunc, window=window, index='dayofyear')
-
-
-@declare_units('days', tasmin='[temperature]')
-def frost_days(tasmin, freq='YS'):
-    r"""Frost days index
-
-    Number of days where daily minimum temperatures are below 0℃.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Frost days index.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TN_{ij} < 0℃
-    """
-    tu = units.parse_units(tasmin.attrs['units'].replace('-', '**-'))
-    fu = 'degC'
-    frz = 0
-    if fu != tu:
-        frz = units.convert(frz, fu, tu)
-    f = (tasmin < frz) * 1
-    return f.resample(time=freq).sum(dim='time')
-
-
-@declare_units('C days', tas='[temperature]', thresh='[temperature]')
-def growing_degree_days(tas, thresh='4.0 degC', freq='YS'):
-    r"""Growing degree-days over threshold temperature value [℃].
-
-    The sum of degree-days over the threshold temperature.
-
-    Parameters
-    ---------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default: '4.0 degC'.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The sum of growing degree-days above 4℃
-
-    Notes
-    -----
-    Let :math:`TG_{ij}` be the daily mean temperature at day :math:`i` of period :math:`j`. Then the
-    growing degree days are:
-
-    .. math::
-
-        GD4_j = \sum_{i=1}^I (TG_{ij}-{4} | TG_{ij} > {4}℃)
-    """
-    thresh = utils.convert_units_to(thresh, tas)
-    return tas.pipe(lambda x: x - thresh) \
-        .clip(min=0) \
-        .resample(time=freq) \
-        .sum(dim='time')
-
-
-@declare_units('days', tas='[temperature]', thresh='[temperature]')
-def growing_season_length(tas, thresh='5.0 degC', window=6, freq='YS'):
-    r"""Growing season length.
-
-    The number of days between the first occurrence of at least
-    six consecutive days with mean daily temperature over 5℃ and
-    the first occurrence of at least six consecutive days with
-    mean daily temperature below 5℃ after July 1st in the northern
-    hemisphere and January 1st in the southern hemisphere.
-
-    Parameters
-    ---------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default: '5.0 degC'.
-    window : int
-      Minimum number of days with temperature above threshold to mark the beginning and end of growing season.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Growing season length.
-
-    Notes
-    -----
-    Let :math:`TG_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then counted is
-    the number of days between the first occurrence of at least 6 consecutive days with:
-
-    .. math::
-
-        TG_{ij} > 5 ℃
-
-    and the first occurrence after 1 July of at least 6 consecutive days with:
-
-    .. math::
-
-        TG_{ij} < 5 ℃
-    """
-
-    # i = xr.DataArray(np.arange(tas.time.size), dims='time')
-    # ind = xr.broadcast(i, tas)[0]
-    #
-    # c = ((tas > thresh) * 1).rolling(time=window).sum()
-    # i1 = ind.where(c == window).resample(time=freq).min(dim='time')
-    #
-    # # Resample sets the time to T00:00.
-    # i11 = i1.reindex_like(c, method='ffill')
-    #
-    # # TODO: Adjust for southern hemisphere
-    #
-    # #i2 = ind.where(c == 0).where(tas.time.dt.month >= 7)
-    # # add check to make sure indice of end of growing season is after growing season start
-    # i2 = ind.where((c==0) & (ind > i11)).where(tas.time.dt.month >= 7)
-    #
-    # d = i2 - i11
-    #
-    # # take min value (first occurence after july)
-    # gsl = d.resample(time=freq).min(dim='time')
-    #
-    # # turn nan into 0
-    # gsl = xr.where(np.isnan(gsl), 0, gsl)
-
-    # compute growth season length on resampled data
-    thresh = utils.convert_units_to(thresh, tas)
-
-    c = ((tas > thresh) * 1).rolling(time=window).sum().chunk(tas.chunks)
-
-    def compute_gsl(c):
-        nt = c.time.size
-        i = xr.DataArray(np.arange(nt), dims='time').chunk({'time': 1})
-        ind = xr.broadcast(i, c)[0].chunk(c.chunks)
-        i1 = ind.where(c == window).min(dim='time')
-        i1 = xr.where(np.isnan(i1), nt, i1)
-        i11 = i1.reindex_like(c, method='ffill')
-        i2 = ind.where((c == 0) & (ind > i11)).where(c.time.dt.month >= 7)
-        i2 = xr.where(np.isnan(i2), nt, i2)
-        d = (i2 - i1).min(dim='time')
-        return d
-
-    gsl = c.resample(time=freq).apply(compute_gsl)
-
-    return gsl
-
-
-@declare_units('', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
-               thresh_tasmax='[temperature]')
-def heat_wave_frequency(tasmin, tasmax, thresh_tasmin='22.0 degC', thresh_tasmax='30 degC',
-                        window=3, freq='YS'):
-    # Dev note : we should decide if it is deg K or C
-    r"""Heat wave frequency
-
-    Number of heat waves over a given period. A heat wave is defined as an event
-    where the minimum and maximum daily temperature both exceeds specific thresholds
-    over a minimum number of days.
-
-    Parameters
-    ----------
-
-    tasmin : xarrray.DataArray
-      Minimum daily temperature [℃] or [K]
-    tasmax : xarrray.DataArray
-      Maximum daily temperature [℃] or [K]
-    thresh_tasmin : str
-      The minimum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '22 degC'
-    thresh_tasmax : str
-      The maximum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '30 degC'
-    window : int
-      Minimum number of days with temperatures above thresholds to qualify as a heatwave.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of heatwave at the wanted frequency
-
-    Notes
-    -----
-    The thresholds of 22° and 25°C for night temperatures and 30° and 35°C for day temperatures were selected by
-    Health Canada professionals, following a temperature–mortality analysis. These absolute temperature thresholds
-    characterize the occurrence of hot weather events that can result in adverse health outcomes for Canadian
-    communities (Casati et al., 2013).
-
-    In Robinson (2001), the parameters would be `thresh_tasmin=27.22, thresh_tasmax=39.44, window=2` (81F, 103F).
-
-    References
-    ----------
-    Casati, B., A. Yagouti, and D. Chaumont, 2013: Regional Climate Projections of Extreme Heat Events in Nine Pilot
-    Canadian Communities for Public Health Planning. J. Appl. Meteor. Climatol., 52, 2669–2698,
-    https://doi.org/10.1175/JAMC-D-12-0341.1
-
-    Robinson, P.J., 2001: On the Definition of a Heat Wave. J. Appl. Meteor., 40, 762–775,
-    https://doi.org/10.1175/1520-0450(2001)040<0762:OTDOAH>2.0.CO;2
-    """
-    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
-    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
-
-    cond = (tasmin > thresh_tasmin) & (tasmax > thresh_tasmax)
-    group = cond.resample(time=freq)
-    return group.apply(rl.windowed_run_events, window=window, dim='time')
-
-
-@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
-def heat_wave_index(tasmax, thresh='25.0 degC', window=5, freq='YS'):
-    r"""Heat wave index.
-
-    Number of days that are part of a heatwave, defined as five or more consecutive days over 25℃.
-
-    Parameters
-    ----------
-    tasmax : xarrray.DataArray
-      Maximum daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to designate a heatwave [℃] or [K]. Default: '25.0 degC'.
-    window : int
-      Minimum number of days with temperature above threshold to qualify as a heatwave.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    DataArray
-      Heat wave index.
-    """
-    thresh = utils.convert_units_to(thresh, tasmax)
-    over = tasmax > thresh
-    group = over.resample(time=freq)
-
-    return group.apply(rl.windowed_run_count, window=window, dim='time')
-
-
-@declare_units('days', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
-               thresh_tasmax='[temperature]')
-def heat_wave_max_length(tasmin, tasmax, thresh_tasmin='22.0 degC', thresh_tasmax='30 degC',
-                         window=3, freq='YS'):
-    # Dev note : we should decide if it is deg K or C
-    r"""Heat wave max length
-
-    Maximum length of heat waves over a given period. A heat wave is defined as an event
-    where the minimum and maximum daily temperature both exceeds specific thresholds
-    over a minimum number of days.
-
-    By definition heat_wave_max_length must be >= window.
-
-    Parameters
-    ----------
-
-    tasmin : xarrray.DataArray
-      Minimum daily temperature [℃] or [K]
-    tasmax : xarrray.DataArray
-      Maximum daily temperature [℃] or [K]
-    thresh_tasmin : str
-      The minimum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '22 degC'
-    thresh_tasmax : str
-      The maximum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '30 degC'
-    window : int
-      Minimum number of days with temperatures above thresholds to qualify as a heatwave.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Maximum length of heatwave at the wanted frequency
-
-    Notes
-    -----
-    The thresholds of 22° and 25°C for night temperatures and 30° and 35°C for day temperatures were selected by
-    Health Canada professionals, following a temperature–mortality analysis. These absolute temperature thresholds
-    characterize the occurrence of hot weather events that can result in adverse health outcomes for Canadian
-    communities (Casati et al., 2013).
-
-    In Robinson (2001), the parameters would be `thresh_tasmin=27.22, thresh_tasmax=39.44, window=2` (81F, 103F).
-
-    References
-    ----------
-    Casati, B., A. Yagouti, and D. Chaumont, 2013: Regional Climate Projections of Extreme Heat Events in Nine Pilot
-    Canadian Communities for Public Health Planning. J. Appl. Meteor. Climatol., 52, 2669–2698,
-    https://doi.org/10.1175/JAMC-D-12-0341.1
-
-    Robinson, P.J., 2001: On the Definition of a Heat Wave. J. Appl. Meteor., 40, 762–775,
-    https://doi.org/10.1175/1520-0450(2001)040<0762:OTDOAH>2.0.CO;2
-    """
-    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
-    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
-
-    cond = (tasmin > thresh_tasmin) & (tasmax > thresh_tasmax)
-    group = cond.resample(time=freq)
-    max_l = group.apply(rl.longest_run, dim='time')
-    return max_l.where(max_l >= window, 0)
-
-
-@declare_units('C days', tas='[temperature]', thresh='[temperature]')
-def heating_degree_days(tas, thresh='17.0 degC', freq='YS'):
-    r"""Heating degree days
-
-    Sum of degree days below the temperature threshold at which spaces are heated.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default: '17.0 degC'.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Heating degree days index.
-
-    Notes
-    -----
-    Let :math:`TG_{ij}` be the daily mean temperature at day :math:`i` of period :math:`j`. Then the
-    heating degree days are:
-
-    .. math::
-
-        HD17_j = \sum_{i=1}^{I} (17℃ - TG_{ij})
-    """
-    thresh = utils.convert_units_to(thresh, tas)
-
-    return tas.pipe(lambda x: thresh - x) \
-        .clip(0) \
-        .resample(time=freq) \
-        .sum(dim='time')
-
-
-@declare_units('days', tasmax='[temperature]')
-def ice_days(tasmax, freq='YS'):
-    r"""Number of ice/freezing days
-
-    Number of days where daily maximum temperatures are below 0℃.
-
-    Parameters
-    ----------
-    tasmax : xarrray.DataArray
-      Maximum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of ice/freezing days.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TX_{ij} < 0℃
-    """
-    tu = units.parse_units(tasmax.attrs['units'].replace('-', '**-'))
-    fu = 'degC'
-    frz = 0
-    if fu != tu:
-        frz = units.convert(frz, fu, tu)
-    f = (tasmax < frz) * 1
-    return f.resample(time=freq).sum(dim='time')
-
-
-@declare_units('', pr='[precipitation]', prsn='[precipitation]', tas='[temperature]')
-def liquid_precip_ratio(pr, prsn=None, tas=None, freq='QS-DEC'):
-    r"""Ratio of rainfall to total precipitation
-
-    The ratio of total liquid precipitation over the total precipitation. If solid precipitation is not provided,
-    then precipitation is assumed solid if the temperature is below 0°C.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
-    prsn : xarray.DataArray
-      Mean daily solid precipitation flux [Kg m-2 s-1] or [mm].
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    freq : str
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Ratio of rainfall to total precipitation
-
-    Notes
-    -----
-    Let :math:`PR_i` be the mean daily precipitation of day :math:`i`, then for a period :math:`j` starting at
-    day :math:`a` and finishing on day :math:`b`:
-
-    .. math::
-
-        PR_{ij} = \sum_{i=a}^{b} PR_i
-
-
-        PRwet_{ij}
-
-    See also
-    --------
-    winter_rain_ratio
-    """
-
-    if prsn is None:
-        tu = units.parse_units(tas.attrs['units'].replace('-', '**-'))
-        fu = 'degC'
-        frz = 0
-        if fu != tu:
-            frz = units.convert(frz, fu, tu)
-        prsn = pr.where(tas < frz, 0)
-
-    tot = pr.resample(time=freq).sum(dim='time')
-    rain = tot - prsn.resample(time=freq).sum(dim='time')
-    ratio = rain / tot
-    return ratio
-
-
-@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
-def tn_days_below(tasmin, thresh='-10.0 degC', freq='YS'):
-    r"""Number of days with tmin below a threshold in
-
-    Number of days where daily minimum temperature is below a threshold.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K] . Default: '-10 degC'.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of days Tmin < threshold.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TX_{ij} < Threshold [℃]
-    """
-    thresh = utils.convert_units_to(thresh, tasmin)
-    f1 = utils.threshold_count(tasmin, '<', thresh, freq)
-    return f1
-
-
-@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
-def tx_days_above(tasmax, thresh='25.0 degC', freq='YS'):
-    r"""Number of summer days
-
-    Number of days where daily maximum temperature exceed a threshold.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default: '25 degC'.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of summer days.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TX_{ij} > Threshold [℃]
-    """
-    thresh = utils.convert_units_to(thresh, tasmax)
-    f = (tasmax > (thresh)) * 1
-    return f.resample(time=freq).sum(dim='time')
-
-
-@declare_units('mm', pr='[precipitation]')
-def max_n_day_precipitation_amount(pr, window=1, freq='YS'):
-    r"""Highest precipitation amount cumulated over a n-day moving window.
-
-    Calculate the n-day rolling sum of the original daily total precipitation series
-    and determine the maximum value over each period.
-
-    Parameters
-    ----------
-    da : xarray.DataArray
-      Daily precipitation values [Kg m-2 s-1] or [mm]
-    window : int
-      Window size in days.
-    freq : str, optional
-      Resampling frequency : default 'YS' (yearly)
-
-    Returns
-    -------
-    xarray.DataArray
-      The highest cumulated n-day precipitation value at the given time frequency.
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `pr.day.nc` the highest 5-day total precipitation
-    at an annual frequency:
-
-    >>> da = xr.open_dataset('pr.day.nc').pr
-    >>> window = 5
-    >>> output = max_n_day_precipitation_amount(da, window, freq="YS")
-    """
-
-    # rolling sum of the values
-    arr = pr.rolling(time=window, center=False).sum()
-    out = arr.resample(time=freq).max(dim='time', keep_attrs=True)
-
-    out.attrs['units'] = pr.units
-    # Adjust values and units to make sure they are daily
-    return utils.pint_multiply(out, 1 * units.day, 'mm')
-
-
-@declare_units('mm/day', pr='[precipitation]')
-def max_1day_precipitation_amount(pr, freq='YS'):
-    r"""Highest 1-day precipitation amount for a period (frequency).
-
-    Resample the original daily total precipitation temperature series by taking the max over each period.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Daily precipitation values [Kg m-2 s-1] or [mm]
-    freq : str, optional
-      Resampling frequency one of : 'YS' (yearly) ,'M' (monthly), or 'QS-DEC' (seasonal - quarters starting in december)
-
-    Returns
-    -------
-    xarray.DataArray
-      The highest 1-day precipitation value at the given time frequency.
-
-    Notes
-    -----
-    Let :math:`PR_i` be the mean daily precipitation of day `i`, then for a period `j`:
-
-    .. math::
-
-       PRx_{ij} = max(PR_{ij})
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `pr.day.nc` the highest 1-day total
-    at an annual frequency:
-
-    >>> pr = xr.open_dataset('pr.day.nc').pr
-    >>> rx1day = max_1day_precipitation_amount(pr, freq="YS")
-    """
-
-    out = pr.resample(time=freq).max(dim='time', keep_attrs=True)
-    return utils.convert_units_to(out, 'mm/day', 'hydro')
-
-
-@declare_units('mm', pr='[precipitation]')
-def precip_accumulation(pr, freq='YS'):
-    r"""Accumulated total (liquid + solid) precipitation.
-
-    Resample the original daily mean precipitation flux and accumulate over each period.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
-    freq : str, optional
-      Resampling frequency as defined in
-      http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling.
-
-    Returns
-    -------
-    xarray.DataArray
-      The total daily precipitation at the given time frequency.
-
-    Notes
-    -----
-    Let :math:`PR_i` be the mean daily precipitation of day :math:`i`, then for a period :math:`j` starting at
-    day :math:`a` and finishing on day :math:`b`:
-
-    .. math::
-
-       PR_{ij} = \sum_{i=a}^{b} PR_i
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `pr_day.nc` the total
-    precipitation at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
-
-    >>> pr_day = xr.open_dataset('pr_day.nc').pr
-    >>> prcp_tot_seasonal = precip_accumulation(pr_day, freq="QS-DEC")
-    """
-
-    out = pr.resample(time=freq).sum(dim='time', keep_attrs=True)
-    return utils.pint_multiply(out, 1 * units.day, 'mm')
-
-
-@declare_units('days', pr='[precipitation]', tas='[temperature]', thresh='[precipitation]')
-def rain_on_frozen_ground_days(pr, tas, thresh='1 mm/d', freq='YS'):
-    """Number of rain on frozen ground events
-
-    Number of days with rain above a threshold after a series of seven days below freezing temperature.
-    Precipitation is assumed to be rain when the temperature is above 0℃.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [Kg m-2 s-1] or [mm]
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Precipitation threshold to consider a day as a rain event. Default : '1 mm/d'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The number of rain on frozen ground events per period [days]
-
-    Notes
-    -----
-    Let :math:`PR_i` be the mean daily precipitation and :math:`TG_i` be the mean daily temperature of day :math:`i`.
-    Then for a period :math:`j`, rain on frozen grounds days are counted where:
-
-    .. math::
-
-        PR_{i} > Threshold [mm]
-
-    and where
-
-    .. math::
-
-        TG_{i} ≤ 0℃
-
-    is true for continuous periods where :math:`i ≥ 7`
-
-    """
-    t = utils.convert_units_to(thresh, pr)
-    frz = utils.convert_units_to('0 C', tas)
-
-    def func(x, axis):
-        """Check that temperature conditions are below 0 for seven days and above after."""
-        frozen = x == np.array([0, 0, 0, 0, 0, 0, 0, 1], bool)
-        return frozen.all(axis=axis)
-
-    tcond = (tas > frz).rolling(time=8).reduce(func)
-    pcond = (pr > t)
-
-    return (tcond * pcond * 1).resample(time=freq).sum(dim='time')
-
-
-# TODO: Improve description
-@declare_units('days', tas='[temperature]', t90='[temperature]')
-def tg90p(tas, t90, freq='YS'):
-    r"""Number of days with daily mean temperature over the 90th percentile.
-
-    Number of days with daily mean temperature over the 90th percentile.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    t90 : xarray.DataArray
-      90th percentile of daily mean temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily mean temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t90 = percentile_doy(historical_tas, per=0.9)
-    >>> hot_days = tg90p(tas, t90)
-    """
-    if 'dayofyear' not in t90.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-
-    t90 = utils.convert_units_to(t90, tas)
-
-    # adjustment of t90 to tas doy range
-    t90 = utils.adjust_doy_calendar(t90, tas)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tas, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t90.sel(dayofyear=doy)
-
-    # compute the cold days
-    over = (tas > thresh)
-
-    return over.resample(time=freq).sum(dim='time')
-
-
-# TODO: Improve description
-@declare_units('days', tas='[temperature]', t10='[temperature]')
-def tg10p(tas, t10, freq='YS'):
-    r"""Number of days with daily mean temperature below the 10th percentile.
-
-    Number of days with daily mean temperature below the 10th percentile.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    t10 : xarray.DataArray
-      10th percentile of daily mean temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily mean temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t10 = percentile_doy(historical_tas, per=0.1)
-    >>> cold_days = tg10p(tas, t10)
-    """
-    if 'dayofyear' not in t10.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-
-    t10 = utils.convert_units_to(t10, tas)
-
-    # adjustment of t10 to tas doy range
-    t10 = utils.adjust_doy_calendar(t10, tas)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tas, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t10.sel(dayofyear=doy)
-
-    # compute the cold days
-    below = (tas < thresh)
-
-    return below.resample(time=freq).sum(dim='time')
-
-
-@declare_units('[temperature]', tas='[temperature]')
-def tg_max(tas, freq='YS'):
-    r"""Highest mean temperature.
-
-    The maximum of daily mean temperature.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Maximum of daily minimum temperature.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then the maximum
-    daily mean temperature for period :math:`j` is:
-
-    .. math::
-
-        TNx_j = max(TN_{ij})
-    """
-
-    return tas.resample(time=freq).max(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tas='[temperature]')
-def tg_mean(tas, freq='YS'):
-    r"""Mean of daily average temperature.
-
-    Resample the original daily mean temperature series by taking the mean over each period.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The mean daily temperature at the given time frequency
-
-    Notes
-    -----
-    Let :math:`TN_i` be the mean daily temperature of day :math:`i`, then for a period :math:`p` starting at
-    day :math:`a` and finishing on day :math:`b`:
-
-    .. math::
-
-       TG_p = \frac{\sum_{i=a}^{b} TN_i}{b - a + 1}
-
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `tas.day.nc` the mean temperature
-    at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
-
-    >>> t = xr.open_dataset('tas.day.nc')
-    >>> tg = tm_mean(t, freq="QS-DEC")
-    """
-
-    arr = tas.resample(time=freq) if freq else tas
-    return arr.mean(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tas='[temperature]')
-def tg_min(tas, freq='YS'):
-    r"""Lowest mean temperature
-
-    Minimum of daily mean temperature.
-
-    Parameters
-    ----------
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Minimum of daily minimum temperature.
-
-    Notes
-    -----
-    Let :math:`TG_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then the minimum
-    daily mean temperature for period :math:`j` is:
-
-    .. math::
-
-        TGn_j = min(TG_{ij})
-    """
-
-    return tas.resample(time=freq).min(dim='time', keep_attrs=True)
-
-
-# TODO: Improve description
-@declare_units('days', tasmin='[temperature]', t90='[temperature]')
-def tn90p(tasmin, t90, freq='YS'):
-    r"""Number of days with daily minimum temperature over the 90th percentile.
-
-    Number of days with daily minimum temperature over the 90th percentile.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    t90 : xarray.DataArray
-      90th percentile of daily minimum temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily minimum temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t90 = percentile_doy(historical_tas, per=0.9)
-    >>> hot_days = tg90p(tas, t90)
-    """
-    if 'dayofyear' not in t90.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-    t90 = utils.convert_units_to(t90, tasmin)
-    # adjustment of t90 to tas doy range
-    t90 = utils.adjust_doy_calendar(t90, tasmin)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tasmin, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t90.sel(dayofyear=doy)
-
-    # compute the cold days
-    over = (tasmin > thresh)
-
-    return over.resample(time=freq).sum(dim='time')
-
-
-# TODO: Improve description
-@declare_units('days', tasmin='[temperature]', t10='[temperature]')
-def tn10p(tasmin, t10, freq='YS'):
-    r"""Number of days with daily minimum temperature below the 10th percentile.
-
-    Number of days with daily minimum temperature below the 10th percentile.
-
-    Parameters
-    ----------
-
-    tasmin : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    t10 : xarray.DataArray
-      10th percentile of daily minimum temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily minimum temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t10 = percentile_doy(historical_tas, per=0.1)
-    >>> cold_days = tg10p(tas, t10)
-    """
-    if 'dayofyear' not in t10.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-    t10 = utils.convert_units_to(t10, tasmin)
-
-    # adjustment of t10 to tas doy range
-    t10 = utils.adjust_doy_calendar(t10, tasmin)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tasmin, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t10.sel(dayofyear=doy)
-
-    # compute the cold days
-    below = (tasmin < thresh)
-
-    return below.resample(time=freq).sum(dim='time')
-
-
-@declare_units('[temperature]', tasmin='[temperature]')
-def tn_max(tasmin, freq='YS'):
-    r"""Highest minimum temperature.
-
-    The maximum of daily minimum temperature.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Maximum of daily minimum temperature.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then the maximum
-    daily minimum temperature for period :math:`j` is:
-
-    .. math::
-
-        TNx_j = max(TN_{ij})
-    """
-
-    return tasmin.resample(time=freq).max(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tasmin='[temperature]')
-def tn_mean(tasmin, freq='YS'):
-    r"""Mean minimum temperature.
-
-    Mean of daily minimum temperature.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Mean of daily minimum temperature.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then mean
-    values in period :math:`j` are given by:
-
-    .. math::
-
-        TN_{ij} = \frac{ \sum_{i=1}^{I} TN_{ij} }{I}
-    """
-
-    arr = tasmin.resample(time=freq) if freq else tasmin
-    return arr.mean(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tasmin='[temperature]')
-def tn_min(tasmin, freq='YS'):
-    r"""Lowest minimum temperature
-
-    Minimum of daily minimum temperature.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Minimum of daily minimum temperature.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then the minimum
-    daily minimum temperature for period :math:`j` is:
-
-    .. math::
-
-        TNn_j = min(TN_{ij})
-    """
-
-    return tasmin.resample(time=freq).min(dim='time', keep_attrs=True)
-
-
-@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
-def tropical_nights(tasmin, thresh='20.0 degC', freq='YS'):
-    r"""Tropical nights
-
-    The number of days with minimum daily temperature above threshold.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default: '20 degC'.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of days with minimum daily temperature above threshold.
-
-    Notes
-    -----
-    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TN_{ij} > Threshold [℃]
-    """
-    thresh = utils.convert_units_to(thresh, tasmin)
-    return tasmin.pipe(lambda x: (tasmin > thresh) * 1) \
-        .resample(time=freq) \
-        .sum(dim='time')
-
-
-# TODO: Improve description
-@declare_units('days', tasmax='[temperature]', t90='[temperature]')
-def tx90p(tasmax, t90, freq='YS'):
-    r"""Number of days with daily maximum temperature over the 90th percentile.
-
-    Number of days with daily maximum temperature over the 90th percentile.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    t90 : xarray.DataArray
-      90th percentile of daily maximum temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily maximum temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t90 = percentile_doy(historical_tas, per=0.9)
-    >>> hot_days = tg90p(tas, t90)
-    """
-    if 'dayofyear' not in t90.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-
-    t90 = utils.convert_units_to(t90, tasmax)
-
-    # adjustment of t90 to tas doy range
-    t90 = utils.adjust_doy_calendar(t90, tasmax)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tasmax, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t90.sel(dayofyear=doy)
-
-    # compute the cold days
-    over = (tasmax > thresh)
-
-    return over.resample(time=freq).sum(dim='time')
-
-
-# TODO: Improve description
-@declare_units('days', tasmax='[temperature]', t10='[temperature]')
-def tx10p(tasmax, t10, freq='YS'):
-    r"""Number of days with daily maximum temperature below the 10th percentile.
-
-    Number of days with daily maximum temperature below the 10th percentile.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    t10 : xarray.DataArray
-      10th percentile of daily maximum temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with daily maximum temperature below the 10th percentile [days]
-
-    Notes
-    -----
-    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
-
-    Example
-    -------
-    >>> t10 = percentile_doy(historical_tas, per=0.1)
-    >>> cold_days = tg10p(tas, t10)
-    """
-    if 'dayofyear' not in t10.coords.keys():
-        raise AttributeError("t10 should have dayofyear coordinates.")
-
-    t10 = utils.convert_units_to(t10, tasmax)
-
-    # adjustment of t10 to tas doy range
-    t10 = utils.adjust_doy_calendar(t10, tasmax)
-
-    # create array of percentile with tas shape and coords
-    thresh = xr.full_like(tasmax, np.nan)
-    doy = thresh.time.dt.dayofyear.values
-    thresh.data = t10.sel(dayofyear=doy)
-
-    # compute the cold days
-    below = (tasmax < thresh)
-
-    return below.resample(time=freq).sum(dim='time')
-
-
-@declare_units('[temperature]', tasmax='[temperature]')
-def tx_max(tasmax, freq='YS'):
-    r"""Highest max temperature
-
-    The maximum value of daily maximum temperature.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Maximum value of daily maximum temperature.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then the maximum
-    daily maximum temperature for period :math:`j` is:
-
-    .. math::
-
-        TXx_j = max(TX_{ij})
-    """
-
-    return tasmax.resample(time=freq).max(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tasmax='[temperature]')
-def tx_mean(tasmax, freq='YS'):
-    r"""Mean max temperature
-
-    The mean of daily maximum temperature.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Mean of daily maximum temperature.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then mean
-    values in period :math:`j` are given by:
-
-    .. math::
-
-        TX_{ij} = \frac{ \sum_{i=1}^{I} TX_{ij} }{I}
-    """
-
-    arr = tasmax.resample(time=freq) if freq else tasmax
-    return arr.mean(dim='time', keep_attrs=True)
-
-
-@declare_units('[temperature]', tasmax='[temperature]')
-def tx_min(tasmax, freq='YS'):
-    r"""Lowest max temperature
-
-    The minimum of daily maximum temperature.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Minimum of daily maximum temperature.
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then the minimum
-    daily maximum temperature for period :math:`j` is:
-
-    .. math::
-
-        TXn_j = min(TX_{ij})
-    """
-
-    return tasmax.resample(time=freq).min(dim='time', keep_attrs=True)
-
-
-@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
-def warm_day_frequency(tasmax, thresh='30 degC', freq='YS'):
-    r"""Frequency of extreme warm days
-
-    Return the number of days with tasmax > thresh per period
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default : '30 degC'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Number of days exceeding threshold.
-
-    Notes:
-    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
-    counted is the number of days where:
-
-    .. math::
-
-        TN_{ij} > Threshold [℃]
-
-    """
-    thresh = utils.convert_units_to(thresh, tasmax)
-    events = (tasmax > thresh) * 1
-    return events.resample(time=freq).sum(dim='time')
-
-
-@declare_units('days', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
-               thresh_tasmax='[temperature]')
-def tx_tn_days_above(tasmin, tasmax, thresh_tasmin='22 degC',
-                     thresh_tasmax='30 degC', freq='YS'):
-    r"""Number of days with both hot maximum and minimum daily temperatures.
-
-    The number of days per period with tasmin above a threshold and tasmax above another threshold.
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    thresh_tasmin : str
-      Threshold temperature for tasmin on which to base evaluation [℃] or [K]. Default : '22 degC'
-    thresh_tasmax : str
-      Threshold temperature for tasmax on which to base evaluation [℃] or [K]. Default : '30 degC'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      the number of days with tasmin > thresh_tasmin and
-      tasmax > thresh_tasamax per period
-
-
-    Notes
-    -----
-    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`, :math:`TN_{ij}`
-    the daily minimum temperature at day :math:`i` of period :math:`j`, :math:`TX_{thresh}` the threshold for maximum
-    daily temperature, and :math:`TN_{thresh}` the threshold for minimum daily temperature. Then counted is the number
-    of days where:
-
-    .. math::
-
-        TX_{ij} > TX_{thresh} [℃]
-
-    and where:
-
-    .. math::
-
-        TN_{ij} > TN_{thresh} [℃]
-
-    """
-    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
-    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
-    events = ((tasmin > (thresh_tasmin)) & (tasmax > (thresh_tasmax))) * 1
-    return events.resample(time=freq).sum(dim='time')
-
-
-@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
-def warm_night_frequency(tasmin, thresh='22 degC', freq='YS'):
-    r"""Frequency of extreme warm nights
-
-    Return the number of days with tasmin > thresh per period
-
-    Parameters
-    ----------
-    tasmin : xarray.DataArray
-      Minimum daily temperature [℃] or [K]
-    thresh : str
-      Threshold temperature on which to base evaluation [℃] or [K]. Default : '22 degC'
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      The number of days with tasmin > thresh per period
-    """
-    thresh = utils.convert_units_to(thresh, tasmin, )
-    events = (tasmin > thresh) * 1
-    return events.resample(time=freq).sum(dim='time')
-
-
-@declare_units('days', tasmax='[temperature]', tx90='[temperature]')
-def warm_spell_duration_index(tasmax, tx90, window=6, freq='YS'):
-    r"""Warm spell duration index
-
-    Number of days with at least six consecutive days where the daily maximum temperature is above the 90th
-    percentile. The 90th percentile should be computed for a 5-day window centred on each calendar day in the
-    1961-1990 period.
-
-    Parameters
-    ----------
-    tasmax : xarray.DataArray
-      Maximum daily temperature [℃] or [K]
-    tx90 : float
-      90th percentile of daily maximum temperature [℃] or [K]
-    window : int
-      Minimum number of days with temperature below threshold to qualify as a warm spell.
-    freq : str, optional
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Count of days with at least six consecutive days where the daily maximum temperature is above the 90th
-      percentile [days].
-
-    References
-    ----------
-    From the Expert Team on Climate Change Detection, Monitoring and Indices (ETCCDMI).
-    Used in Alexander, L. V., et al. (2006), Global observed changes in daily climate extremes of temperature and
-    precipitation, J. Geophys. Res., 111, D05109, doi: 10.1029/2005JD006290.
-
-    """
-    if 'dayofyear' not in tx90.coords.keys():
-        raise AttributeError("tx90 should have dayofyear coordinates.")
-
-    # The day of year value of the tasmax series.
-    doy = tasmax.indexes['time'].dayofyear
-
-    # adjustment of tx90 to tasmax doy range
-    tx90 = utils.adjust_doy_calendar(tx90, tasmax)
-
-    # Create an array with the shape and coords of tasmax, but with values set to tx90 according to the doy index.
-    thresh = xr.full_like(tasmax, np.nan)
-    thresh.data = tx90.sel(dayofyear=doy)
-
-    above = (tasmax > thresh)
-
-    return above.resample(time=freq).apply(rl.windowed_run_count, window=window, dim='time')
-
-
-@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
-def wetdays(pr, thresh='1.0 mm/day', freq='YS'):
-    r"""Wet days
-
-    Return the total number of days during period with precipitation over threshold.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Daily precipitation [mm]
-    thresh : str
-      Precipitation value over which a day is considered wet. Default: '1 mm/day'.
-    freq : str, optional
-      Resampling frequency defining the periods
-      defined in http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling.
-
-    Returns
-    -------
-    xarray.DataArray
-      The number of wet days for each period [day]
-
-    Examples
-    --------
-    The following would compute for each grid cell of file `pr.day.nc` the number days
-    with precipitation over 5 mm at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
-
-    >>> pr = xr.open_dataset('pr.day.nc')
-    >>> wd = wetdays(pr, pr_min = 5., freq="QS-DEC")
-    """
-    thresh = utils.convert_units_to(thresh, pr, 'hydro')
-
-    wd = (pr >= thresh) * 1
-    return wd.resample(time=freq).sum(dim='time')
-
-
-@declare_units('', pr='[precipitation]', prsn='[precipitation]', tas='[temperature]')
-def winter_rain_ratio(pr, prsn=None, tas=None):
-    """Ratio of rainfall to total precipitation during winter
-
-    The ratio of total liquid precipitation over the total precipitation over the winter months (DJF. If solid
-    precipitation is not provided, then precipitation is assumed solid if the temperature is below 0°C.
-
-    Parameters
-    ----------
-    pr : xarray.DataArray
-      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
-    prsn : xarray.DataArray
-      Mean daily solid precipitation flux [Kg m-2 s-1] or [mm].
-    tas : xarray.DataArray
-      Mean daily temperature [℃] or [K]
-    freq : str
-      Resampling frequency
-
-    Returns
-    -------
-    xarray.DataArray
-      Ratio of rainfall to total precipitation during winter months (DJF)
-    """
-    ratio = liquid_precip_ratio(pr, prsn, tas, freq='QS-DEC')
-    winter = ratio.indexes['time'].month == 12
-    return ratio[winter]
diff --git a/xclim/indices/__init__.py b/xclim/indices/__init__.py
new file mode 100644
index 00000000..7905c777
--- /dev/null
+++ b/xclim/indices/__init__.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+"""
+Indices library
+===============
+
+This module describes climate indicator functions. Functions are listed in alphabetical order and describe the raw
+computation performed over xarray.DataArrays. DataArrays should carry unit information to allow for any needed
+unit conversions. The output's attributes (CF-Convention) are not modified. Validation checks and output attributes
+are handled by indicator classes described in files named by the physical variable (temperature, precip, streamflow).
+
+Notes for docstring
+-------------------
+
+The docstrings adhere to the `NumPy`_ style convention and is meant as a way to store CF-Convention metadata as
+well as information relevant to third party libraries (such as a WPS server).
+
+The first line of the docstring (the short summary), will be assigned to the output's `long_name` attribute. The
+`long_name` attribute is defined by the NetCDF User Guide to contain a long descriptive name which may, for example,
+be used for labeling plots
+
+The second paragraph will be considered as the "*abstract*", or the CF global "*comment*" (miscellaneous information
+about the data or methods used to produce it).
+
+The third and fourth sections are the **Parameters** and **Returns** sections describing the input and output values
+respectively.
+
+.. code-block:: python
+
+   Parameters
+   ----------
+   <standard_name> : xarray.DataArray
+     <Long_name> of variable [acceptable units].
+   threshold : string
+     Description of the threshold / units.
+     e.g. The 10th percentile of historical temperature [K].
+   freq : str, optional
+     Resampling frequency.
+
+   Returns
+   -------
+   xarray.DataArray
+     Output's <long_name> [units]
+
+The next sections would be **Notes** and **References**:
+
+.. code-block:: python
+
+    Notes
+    -----
+    This is where the mathematical equation is described.
+    At the end of the description, convention suggests
+    to add a reference [example]_:
+
+        .. math::
+
+            3987^12 + 4365^12 = 4472^12
+
+    References
+    ----------
+    .. [example] Smith, T.J. and Huard, D. (2018). "CF Docstrings:
+        A manifesto on conventions and the metaphysical nature
+        of ontological python documentation." Climate Aesthetics,
+        vol. 1, pp. 121-155.
+
+Indice descriptions
+===================
+.. _`NumPy`: https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard
+"""
+
+from ._simple import *
+from ._threshold import *
+from ._multivariate import *
+
+# TODO: Define a unit conversion system for temperature [K, C, F] and precipitation [mm h-1, Kg m-2 s-1] metrics
+# TODO: Move utility functions to another file.
+# TODO: Should we reference the standard vocabulary we're using ?
+# E.g. http://vocab.nerc.ac.uk/collection/P07/current/BHMHISG2/
diff --git a/xclim/indices/_multivariate.py b/xclim/indices/_multivariate.py
new file mode 100644
index 00000000..44225e4e
--- /dev/null
+++ b/xclim/indices/_multivariate.py
@@ -0,0 +1,923 @@
+import logging
+
+import numpy as np
+import xarray as xr
+
+from xclim import utils, run_length as rl
+from xclim.utils import declare_units, units
+
+logging.basicConfig(level=logging.DEBUG)
+logging.captureWarnings(True)
+
+xr.set_options(enable_cftimeindex=True)  # Set xarray to use cftimeindex
+
+
+# Frequencies : YS: year start, QS-DEC: seasons starting in december, MS: month start
+# See http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
+
+# -------------------------------------------------- #
+# ATTENTION: ASSUME ALL INDICES WRONG UNTIL TESTED ! #
+# -------------------------------------------------- #
+
+__all__ = ['cold_spell_duration_index', 'cold_and_dry_days', 'daily_freezethaw_cycles', 'daily_temperature_range',
+           'daily_temperature_range_variability', 'extreme_temperature_range', 'heat_wave_frequency',
+           'heat_wave_max_length', 'liquid_precip_ratio', 'rain_on_frozen_ground_days', 'tg90p', 'tg10p',
+           'tn90p', 'tn10p', 'tx90p', 'tx10p', 'tx_tn_days_above', 'warm_spell_duration_index', 'winter_rain_ratio']
+
+
+@declare_units('days', tasmin='[temperature]', tn10='[temperature]')
+def cold_spell_duration_index(tasmin, tn10, window=6, freq='YS'):
+    r"""Cold spell duration index
+
+    Number of days with at least six consecutive days where the daily minimum temperature is below the 10th
+    percentile.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature.
+    tn10 : float
+      10th percentile of daily minimum temperature.
+    window : int
+      Minimum number of days with temperature below threshold to qualify as a cold spell. Default: 6.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with at least six consecutive days where the daily minimum temperature is below the 10th
+      percentile [days].
+
+    Notes
+    -----
+    Let :math:`TN_i` be the minimum daily temperature for the day of the year :math:`i` and :math:`TN10_i` the 10th
+    percentile of the minimum daily temperature over the 1961-1990 period for day of the year :math:`i`, the cold spell
+    duration index over period :math:`\phi` is defined as:
+
+    .. math::
+
+       \sum_{i \in \phi} \prod_{j=i}^{i+6} \left[ TN_j < TN10_j \right]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
+
+    References
+    ----------
+    From the Expert Team on Climate Change Detection, Monitoring and Indices (ETCCDMI).
+
+    Example
+    -------
+    >>> tn10 = percentile_doy(historical_tasmin, per=.1)
+    >>> cold_spell_duration_index(reference_tasmin, tn10)
+    """
+    if 'dayofyear' not in tn10.coords.keys():
+        raise AttributeError("tn10 should have dayofyear coordinates.")
+
+    # The day of year value of the tasmin series.
+    doy = tasmin.indexes['time'].dayofyear
+
+    tn10 = utils.convert_units_to(tn10, tasmin)
+    # If calendar of `tn10` is different from `tasmin`, interpolate.
+    tn10 = utils.adjust_doy_calendar(tn10, tasmin)
+
+    # Create an array with the shape and coords of tasmin, but with values set to tx90 according to the doy index.
+    thresh = xr.full_like(tasmin, np.nan)
+    thresh.data = tn10.sel(dayofyear=doy)
+
+    below = (tasmin < thresh)
+
+    return below.resample(time=freq).apply(rl.windowed_run_count, window=window, dim='time')
+
+
+def cold_and_dry_days(tas, tgin25, pr, wet25, freq='YS'):
+    r"""Cold and dry days.
+
+    Returns the total number of days where "Cold" and "Dry" conditions coincide.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature values [℃] or [K]
+    tgin25 : xarray.DataArray
+      First quartile of daily mean temperature computed by month.
+    pr : xarray.DataArray
+      Daily precipitation.
+    wet25 : xarray.DataArray
+      First quartile of daily total precipitation computed by month.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The total number of days where cold and dry conditions coincide.
+
+    Notes
+    -----
+    Formula to be written [cold_dry_days]_.
+
+    References
+    ----------
+    .. [cold_dry_days] Beniston, M. (2009). Trends in joint quantiles of temperature and precipitation in Europe
+        since 1901 and projected for 2100. Geophysical Research Letters, 36(7). https://doi.org/10.1029/2008GL037119
+    """
+    raise NotImplementedError
+    # There is an issue with the 1 mm threshold. It makes no sense to assume a day with < 1mm is not dry.
+    # c1 = tas < utils.convert_units_to(tgin25, tas)
+    # c2 = (pr > utils.convert_units_to('1 mm', pr)) * (pr < utils.convert_units_to(wet25, pr))
+
+    # c = (c1 * c2) * 1
+    # return c.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]', tasmin='[temperature]')
+def daily_freezethaw_cycles(tasmax, tasmin, freq='YS'):
+    r"""Number of days with a diurnal freeze-thaw cycle
+
+    The number of days where Tmax > 0℃ and Tmin < 0℃.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    tasmin : xarray.DataArray
+      Minimum daily temperature values [℃] or [K]
+    freq : str
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of days with a diurnal freeze-thaw cycle
+
+    Notes
+    -----
+    Let :math:`TX_{i}` be the maximum temperature at day :math:`i` and :math:`TN_{i}` be
+    the daily minimum temperature at day :math:`i`. Then the number of freeze thaw cycles
+    during period :math:`\phi` is given by :
+
+    .. math::
+
+        \sum_{i \in \phi} [ TX_{i} > 0℃ ] [ TN_{i} <  0℃ ]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
+    """
+    frz = utils.convert_units_to('0 degC', tasmax)
+    ft = (tasmin < frz) * (tasmax > frz) * 1
+    out = ft.resample(time=freq).sum(dim='time')
+    return out
+
+
+@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
+def daily_temperature_range(tasmax, tasmin, freq='YS'):
+    r"""Mean of daily temperature range.
+
+    The mean difference between the daily maximum temperature and the daily minimum temperature.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature values [℃] or [K]
+    tasmin : xarray.DataArray
+      Minimum daily temperature values [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The average variation in daily temperature range for the given time period.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at day :math:`i`
+    of period :math:`j`. Then the mean diurnal temperature range in period :math:`j` is:
+
+    .. math::
+
+        DTR_j = \frac{ \sum_{i=1}^I (TX_{ij} - TN_{ij}) }{I}
+    """
+
+    dtr = tasmax - tasmin
+    out = dtr.resample(time=freq).mean(dim='time', keep_attrs=True)
+    out.attrs['units'] = tasmax.units
+    return out
+
+
+@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
+def daily_temperature_range_variability(tasmax, tasmin, freq="YS"):
+    r"""Mean absolute day-to-day variation in daily temperature range.
+
+    Mean absolute day-to-day variation in daily temperature range.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature values [℃] or [K]
+    tasmin : xarray.DataArray
+      Minimum daily temperature values [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The average day-to-day variation in daily temperature range for the given time period.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at
+    day :math:`i` of period :math:`j`. Then calculated is the absolute day-to-day differences in
+    period :math:`j` is:
+
+    .. math::
+
+       vDTR_j = \frac{ \sum_{i=2}^{I} |(TX_{ij}-TN_{ij})-(TX_{i-1,j}-TN_{i-1,j})| }{I}
+    """
+
+    vdtr = abs((tasmax - tasmin).diff(dim='time'))
+    out = vdtr.resample(time=freq).mean(dim='time')
+    out.attrs['units'] = tasmax.units
+    return out
+
+
+@declare_units('K', tasmax='[temperature]', tasmin='[temperature]')
+def extreme_temperature_range(tasmax, tasmin, freq='YS'):
+    r"""Extreme intra-period temperature range.
+
+    The maximum of max temperature (TXx) minus the minimum of min temperature (TNn) for the given time period.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature values [℃] or [K]
+    tasmin : xarray.DataArray
+      Minimum daily temperature values [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Extreme intra-period temperature range for the given time period.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` and :math:`TN_{ij}` be the daily maximum and minimum temperature at day :math:`i`
+    of period :math:`j`. Then the extreme temperature range in period :math:`j` is:
+
+    .. math::
+
+        ETR_j = max(TX_{ij}) - min(TN_{ij})
+    """
+
+    tx_max = tasmax.resample(time=freq).max(dim='time')
+    tn_min = tasmin.resample(time=freq).min(dim='time')
+
+    out = tx_max - tn_min
+    out.attrs['units'] = tasmax.units
+    return out
+
+
+@declare_units('', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
+               thresh_tasmax='[temperature]')
+def heat_wave_frequency(tasmin, tasmax, thresh_tasmin='22.0 degC', thresh_tasmax='30 degC',
+                        window=3, freq='YS'):
+    # Dev note : we should decide if it is deg K or C
+    r"""Heat wave frequency
+
+    Number of heat waves over a given period. A heat wave is defined as an event
+    where the minimum and maximum daily temperature both exceeds specific thresholds
+    over a minimum number of days.
+
+    Parameters
+    ----------
+
+    tasmin : xarrray.DataArray
+      Minimum daily temperature [℃] or [K]
+    tasmax : xarrray.DataArray
+      Maximum daily temperature [℃] or [K]
+    thresh_tasmin : str
+      The minimum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '22 degC'
+    thresh_tasmax : str
+      The maximum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '30 degC'
+    window : int
+      Minimum number of days with temperatures above thresholds to qualify as a heatwave.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of heatwave at the wanted frequency
+
+    Notes
+    -----
+    The thresholds of 22° and 25°C for night temperatures and 30° and 35°C for day temperatures were selected by
+    Health Canada professionals, following a temperature–mortality analysis. These absolute temperature thresholds
+    characterize the occurrence of hot weather events that can result in adverse health outcomes for Canadian
+    communities (Casati et al., 2013).
+
+    In Robinson (2001), the parameters would be `thresh_tasmin=27.22, thresh_tasmax=39.44, window=2` (81F, 103F).
+
+    References
+    ----------
+    Casati, B., A. Yagouti, and D. Chaumont, 2013: Regional Climate Projections of Extreme Heat Events in Nine Pilot
+    Canadian Communities for Public Health Planning. J. Appl. Meteor. Climatol., 52, 2669–2698,
+    https://doi.org/10.1175/JAMC-D-12-0341.1
+
+    Robinson, P.J., 2001: On the Definition of a Heat Wave. J. Appl. Meteor., 40, 762–775,
+    https://doi.org/10.1175/1520-0450(2001)040<0762:OTDOAH>2.0.CO;2
+    """
+    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
+    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
+
+    cond = (tasmin > thresh_tasmin) & (tasmax > thresh_tasmax)
+    group = cond.resample(time=freq)
+    return group.apply(rl.windowed_run_events, window=window, dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
+               thresh_tasmax='[temperature]')
+def heat_wave_max_length(tasmin, tasmax, thresh_tasmin='22.0 degC', thresh_tasmax='30 degC',
+                         window=3, freq='YS'):
+    # Dev note : we should decide if it is deg K or C
+    r"""Heat wave max length
+
+    Maximum length of heat waves over a given period. A heat wave is defined as an event
+    where the minimum and maximum daily temperature both exceeds specific thresholds
+    over a minimum number of days.
+
+    By definition heat_wave_max_length must be >= window.
+
+    Parameters
+    ----------
+
+    tasmin : xarrray.DataArray
+      Minimum daily temperature [℃] or [K]
+    tasmax : xarrray.DataArray
+      Maximum daily temperature [℃] or [K]
+    thresh_tasmin : str
+      The minimum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '22 degC'
+    thresh_tasmax : str
+      The maximum temperature threshold needed to trigger a heatwave event [℃] or [K]. Default : '30 degC'
+    window : int
+      Minimum number of days with temperatures above thresholds to qualify as a heatwave.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Maximum length of heatwave at the wanted frequency
+
+    Notes
+    -----
+    The thresholds of 22° and 25°C for night temperatures and 30° and 35°C for day temperatures were selected by
+    Health Canada professionals, following a temperature–mortality analysis. These absolute temperature thresholds
+    characterize the occurrence of hot weather events that can result in adverse health outcomes for Canadian
+    communities (Casati et al., 2013).
+
+    In Robinson (2001), the parameters would be `thresh_tasmin=27.22, thresh_tasmax=39.44, window=2` (81F, 103F).
+
+    References
+    ----------
+    Casati, B., A. Yagouti, and D. Chaumont, 2013: Regional Climate Projections of Extreme Heat Events in Nine Pilot
+    Canadian Communities for Public Health Planning. J. Appl. Meteor. Climatol., 52, 2669–2698,
+    https://doi.org/10.1175/JAMC-D-12-0341.1
+
+    Robinson, P.J., 2001: On the Definition of a Heat Wave. J. Appl. Meteor., 40, 762–775,
+    https://doi.org/10.1175/1520-0450(2001)040<0762:OTDOAH>2.0.CO;2
+    """
+    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
+    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
+
+    cond = (tasmin > thresh_tasmin) & (tasmax > thresh_tasmax)
+    group = cond.resample(time=freq)
+    max_l = group.apply(rl.longest_run, dim='time')
+    return max_l.where(max_l >= window, 0)
+
+
+@declare_units('', pr='[precipitation]', prsn='[precipitation]', tas='[temperature]')
+def liquid_precip_ratio(pr, prsn=None, tas=None, freq='QS-DEC'):
+    r"""Ratio of rainfall to total precipitation
+
+    The ratio of total liquid precipitation over the total precipitation. If solid precipitation is not provided,
+    then precipitation is assumed solid if the temperature is below 0°C.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
+    prsn : xarray.DataArray
+      Mean daily solid precipitation flux [Kg m-2 s-1] or [mm].
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    freq : str
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Ratio of rainfall to total precipitation
+
+    Notes
+    -----
+    Let :math:`PR_i` be the mean daily precipitation of day :math:`i`, then for a period :math:`j` starting at
+    day :math:`a` and finishing on day :math:`b`:
+
+    .. math::
+
+        PR_{ij} = \sum_{i=a}^{b} PR_i
+
+
+        PRwet_{ij}
+
+    See also
+    --------
+    winter_rain_ratio
+    """
+
+    if prsn is None:
+        tu = units.parse_units(tas.attrs['units'].replace('-', '**-'))
+        fu = 'degC'
+        frz = 0
+        if fu != tu:
+            frz = units.convert(frz, fu, tu)
+        prsn = pr.where(tas < frz, 0)
+
+    tot = pr.resample(time=freq).sum(dim='time')
+    rain = tot - prsn.resample(time=freq).sum(dim='time')
+    ratio = rain / tot
+    return ratio
+
+
+@declare_units('days', pr='[precipitation]', tas='[temperature]', thresh='[precipitation]')
+def rain_on_frozen_ground_days(pr, tas, thresh='1 mm/d', freq='YS'):
+    """Number of rain on frozen ground events
+
+    Number of days with rain above a threshold after a series of seven days below freezing temperature.
+    Precipitation is assumed to be rain when the temperature is above 0℃.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [Kg m-2 s-1] or [mm]
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Precipitation threshold to consider a day as a rain event. Default : '1 mm/d'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The number of rain on frozen ground events per period [days]
+
+    Notes
+    -----
+    Let :math:`PR_i` be the mean daily precipitation and :math:`TG_i` be the mean daily temperature of day :math:`i`.
+    Then for a period :math:`j`, rain on frozen grounds days are counted where:
+
+    .. math::
+
+        PR_{i} > Threshold [mm]
+
+    and where
+
+    .. math::
+
+        TG_{i} ≤ 0℃
+
+    is true for continuous periods where :math:`i ≥ 7`
+
+    """
+    t = utils.convert_units_to(thresh, pr)
+    frz = utils.convert_units_to('0 C', tas)
+
+    def func(x, axis):
+        """Check that temperature conditions are below 0 for seven days and above after."""
+        frozen = x == np.array([0, 0, 0, 0, 0, 0, 0, 1], bool)
+        return frozen.all(axis=axis)
+
+    tcond = (tas > frz).rolling(time=8).reduce(func)
+    pcond = (pr > t)
+
+    return (tcond * pcond * 1).resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tas='[temperature]', t90='[temperature]')
+def tg90p(tas, t90, freq='YS'):
+    r"""Number of days with daily mean temperature over the 90th percentile.
+
+    Number of days with daily mean temperature over the 90th percentile.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    t90 : xarray.DataArray
+      90th percentile of daily mean temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily mean temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t90 = percentile_doy(historical_tas, per=0.9)
+    >>> hot_days = tg90p(tas, t90)
+    """
+    if 'dayofyear' not in t90.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+
+    t90 = utils.convert_units_to(t90, tas)
+
+    # adjustment of t90 to tas doy range
+    t90 = utils.adjust_doy_calendar(t90, tas)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tas, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t90.sel(dayofyear=doy)
+
+    # compute the cold days
+    over = (tas > thresh)
+
+    return over.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tas='[temperature]', t10='[temperature]')
+def tg10p(tas, t10, freq='YS'):
+    r"""Number of days with daily mean temperature below the 10th percentile.
+
+    Number of days with daily mean temperature below the 10th percentile.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    t10 : xarray.DataArray
+      10th percentile of daily mean temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily mean temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t10 = percentile_doy(historical_tas, per=0.1)
+    >>> cold_days = tg10p(tas, t10)
+    """
+    if 'dayofyear' not in t10.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+
+    t10 = utils.convert_units_to(t10, tas)
+
+    # adjustment of t10 to tas doy range
+    t10 = utils.adjust_doy_calendar(t10, tas)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tas, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t10.sel(dayofyear=doy)
+
+    # compute the cold days
+    below = (tas < thresh)
+
+    return below.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', t90='[temperature]')
+def tn90p(tasmin, t90, freq='YS'):
+    r"""Number of days with daily minimum temperature over the 90th percentile.
+
+    Number of days with daily minimum temperature over the 90th percentile.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    t90 : xarray.DataArray
+      90th percentile of daily minimum temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily minimum temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t90 = percentile_doy(historical_tas, per=0.9)
+    >>> hot_days = tg90p(tas, t90)
+    """
+    if 'dayofyear' not in t90.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+    t90 = utils.convert_units_to(t90, tasmin)
+    # adjustment of t90 to tas doy range
+    t90 = utils.adjust_doy_calendar(t90, tasmin)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tasmin, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t90.sel(dayofyear=doy)
+
+    # compute the cold days
+    over = (tasmin > thresh)
+
+    return over.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', t10='[temperature]')
+def tn10p(tasmin, t10, freq='YS'):
+    r"""Number of days with daily minimum temperature below the 10th percentile.
+
+    Number of days with daily minimum temperature below the 10th percentile.
+
+    Parameters
+    ----------
+
+    tasmin : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    t10 : xarray.DataArray
+      10th percentile of daily minimum temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily minimum temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t10 = percentile_doy(historical_tas, per=0.1)
+    >>> cold_days = tg10p(tas, t10)
+    """
+    if 'dayofyear' not in t10.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+    t10 = utils.convert_units_to(t10, tasmin)
+
+    # adjustment of t10 to tas doy range
+    t10 = utils.adjust_doy_calendar(t10, tasmin)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tasmin, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t10.sel(dayofyear=doy)
+
+    # compute the cold days
+    below = (tasmin < thresh)
+
+    return below.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]', t90='[temperature]')
+def tx90p(tasmax, t90, freq='YS'):
+    r"""Number of days with daily maximum temperature over the 90th percentile.
+
+    Number of days with daily maximum temperature over the 90th percentile.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    t90 : xarray.DataArray
+      90th percentile of daily maximum temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily maximum temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 90th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t90 = percentile_doy(historical_tas, per=0.9)
+    >>> hot_days = tg90p(tas, t90)
+    """
+    if 'dayofyear' not in t90.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+
+    t90 = utils.convert_units_to(t90, tasmax)
+
+    # adjustment of t90 to tas doy range
+    t90 = utils.adjust_doy_calendar(t90, tasmax)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tasmax, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t90.sel(dayofyear=doy)
+
+    # compute the cold days
+    over = (tasmax > thresh)
+
+    return over.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]', t10='[temperature]')
+def tx10p(tasmax, t10, freq='YS'):
+    r"""Number of days with daily maximum temperature below the 10th percentile.
+
+    Number of days with daily maximum temperature below the 10th percentile.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    t10 : xarray.DataArray
+      10th percentile of daily maximum temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with daily maximum temperature below the 10th percentile [days]
+
+    Notes
+    -----
+    The 10th percentile should be computed for a 5 day window centered on each calendar day for a reference period.
+
+    Example
+    -------
+    >>> t10 = percentile_doy(historical_tas, per=0.1)
+    >>> cold_days = tg10p(tas, t10)
+    """
+    if 'dayofyear' not in t10.coords.keys():
+        raise AttributeError("t10 should have dayofyear coordinates.")
+
+    t10 = utils.convert_units_to(t10, tasmax)
+
+    # adjustment of t10 to tas doy range
+    t10 = utils.adjust_doy_calendar(t10, tasmax)
+
+    # create array of percentile with tas shape and coords
+    thresh = xr.full_like(tasmax, np.nan)
+    doy = thresh.time.dt.dayofyear.values
+    thresh.data = t10.sel(dayofyear=doy)
+
+    # compute the cold days
+    below = (tasmax < thresh)
+
+    return below.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', tasmax='[temperature]', thresh_tasmin='[temperature]',
+               thresh_tasmax='[temperature]')
+def tx_tn_days_above(tasmin, tasmax, thresh_tasmin='22 degC',
+                     thresh_tasmax='30 degC', freq='YS'):
+    r"""Number of days with both hot maximum and minimum daily temperatures.
+
+    The number of days per period with tasmin above a threshold and tasmax above another threshold.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    thresh_tasmin : str
+      Threshold temperature for tasmin on which to base evaluation [℃] or [K]. Default : '22 degC'
+    thresh_tasmax : str
+      Threshold temperature for tasmax on which to base evaluation [℃] or [K]. Default : '30 degC'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      the number of days with tasmin > thresh_tasmin and
+      tasmax > thresh_tasamax per period
+
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`, :math:`TN_{ij}`
+    the daily minimum temperature at day :math:`i` of period :math:`j`, :math:`TX_{thresh}` the threshold for maximum
+    daily temperature, and :math:`TN_{thresh}` the threshold for minimum daily temperature. Then counted is the number
+    of days where:
+
+    .. math::
+
+        TX_{ij} > TX_{thresh} [℃]
+
+    and where:
+
+    .. math::
+
+        TN_{ij} > TN_{thresh} [℃]
+
+    """
+    thresh_tasmax = utils.convert_units_to(thresh_tasmax, tasmax)
+    thresh_tasmin = utils.convert_units_to(thresh_tasmin, tasmin)
+    events = ((tasmin > (thresh_tasmin)) & (tasmax > (thresh_tasmax))) * 1
+    return events.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]', tx90='[temperature]')
+def warm_spell_duration_index(tasmax, tx90, window=6, freq='YS'):
+    r"""Warm spell duration index
+
+    Number of days with at least six consecutive days where the daily maximum temperature is above the 90th
+    percentile. The 90th percentile should be computed for a 5-day window centred on each calendar day in the
+    1961-1990 period.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    tx90 : float
+      90th percentile of daily maximum temperature [℃] or [K]
+    window : int
+      Minimum number of days with temperature below threshold to qualify as a warm spell.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Count of days with at least six consecutive days where the daily maximum temperature is above the 90th
+      percentile [days].
+
+    References
+    ----------
+    From the Expert Team on Climate Change Detection, Monitoring and Indices (ETCCDMI).
+    Used in Alexander, L. V., et al. (2006), Global observed changes in daily climate extremes of temperature and
+    precipitation, J. Geophys. Res., 111, D05109, doi: 10.1029/2005JD006290.
+
+    """
+    if 'dayofyear' not in tx90.coords.keys():
+        raise AttributeError("tx90 should have dayofyear coordinates.")
+
+    # The day of year value of the tasmax series.
+    doy = tasmax.indexes['time'].dayofyear
+
+    # adjustment of tx90 to tasmax doy range
+    tx90 = utils.adjust_doy_calendar(tx90, tasmax)
+
+    # Create an array with the shape and coords of tasmax, but with values set to tx90 according to the doy index.
+    thresh = xr.full_like(tasmax, np.nan)
+    thresh.data = tx90.sel(dayofyear=doy)
+
+    above = (tasmax > thresh)
+
+    return above.resample(time=freq).apply(rl.windowed_run_count, window=window, dim='time')
+
+
+@declare_units('', pr='[precipitation]', prsn='[precipitation]', tas='[temperature]')
+def winter_rain_ratio(pr, prsn=None, tas=None):
+    """Ratio of rainfall to total precipitation during winter
+
+    The ratio of total liquid precipitation over the total precipitation over the winter months (DJF. If solid
+    precipitation is not provided, then precipitation is assumed solid if the temperature is below 0°C.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
+    prsn : xarray.DataArray
+      Mean daily solid precipitation flux [Kg m-2 s-1] or [mm].
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    freq : str
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Ratio of rainfall to total precipitation during winter months (DJF)
+    """
+    ratio = liquid_precip_ratio(pr, prsn, tas, freq='QS-DEC')
+    winter = ratio.indexes['time'].month == 12
+    return ratio[winter]
diff --git a/xclim/indices/_simple.py b/xclim/indices/_simple.py
new file mode 100644
index 00000000..89ea3a2b
--- /dev/null
+++ b/xclim/indices/_simple.py
@@ -0,0 +1,551 @@
+import logging
+
+import xarray as xr
+
+from xclim import run_length as rl, utils
+from xclim.utils import declare_units, units
+
+logging.basicConfig(level=logging.DEBUG)
+logging.captureWarnings(True)
+
+xr.set_options(enable_cftimeindex=True)  # Set xarray to use cftimeindex
+
+
+# Frequencies : YS: year start, QS-DEC: seasons starting in december, MS: month start
+# See http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
+
+# -------------------------------------------------- #
+# ATTENTION: ASSUME ALL INDICES WRONG UNTIL TESTED ! #
+# -------------------------------------------------- #
+
+__all__ = ['tg_max', 'tg_mean', 'tg_min', 'tn_max', 'tn_mean', 'tn_min', 'tx_max', 'tx_mean', 'tx_min',
+           'base_flow_index', 'consecutive_frost_days', 'frost_days', 'ice_days', 'max_1day_precipitation_amount',
+           'precip_accumulation']
+
+
+@declare_units('[temperature]', tas='[temperature]')
+def tg_max(tas, freq='YS'):
+    r"""Highest mean temperature.
+
+    The maximum of daily mean temperature.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Maximum of daily minimum temperature.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then the maximum
+    daily mean temperature for period :math:`j` is:
+
+    .. math::
+
+        TNx_j = max(TN_{ij})
+    """
+
+    return tas.resample(time=freq).max(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tas='[temperature]')
+def tg_mean(tas, freq='YS'):
+    r"""Mean of daily average temperature.
+
+    Resample the original daily mean temperature series by taking the mean over each period.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The mean daily temperature at the given time frequency
+
+    Notes
+    -----
+    Let :math:`TN_i` be the mean daily temperature of day :math:`i`, then for a period :math:`p` starting at
+    day :math:`a` and finishing on day :math:`b`:
+
+    .. math::
+
+       TG_p = \frac{\sum_{i=a}^{b} TN_i}{b - a + 1}
+
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `tas.day.nc` the mean temperature
+    at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
+
+    >>> t = xr.open_dataset('tas.day.nc')
+    >>> tg = tm_mean(t, freq="QS-DEC")
+    """
+
+    arr = tas.resample(time=freq) if freq else tas
+    return arr.mean(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tas='[temperature]')
+def tg_min(tas, freq='YS'):
+    r"""Lowest mean temperature
+
+    Minimum of daily mean temperature.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Minimum of daily minimum temperature.
+
+    Notes
+    -----
+    Let :math:`TG_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then the minimum
+    daily mean temperature for period :math:`j` is:
+
+    .. math::
+
+        TGn_j = min(TG_{ij})
+    """
+
+    return tas.resample(time=freq).min(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmin='[temperature]')
+def tn_max(tasmin, freq='YS'):
+    r"""Highest minimum temperature.
+
+    The maximum of daily minimum temperature.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Maximum of daily minimum temperature.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then the maximum
+    daily minimum temperature for period :math:`j` is:
+
+    .. math::
+
+        TNx_j = max(TN_{ij})
+    """
+
+    return tasmin.resample(time=freq).max(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmin='[temperature]')
+def tn_mean(tasmin, freq='YS'):
+    r"""Mean minimum temperature.
+
+    Mean of daily minimum temperature.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Mean of daily minimum temperature.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then mean
+    values in period :math:`j` are given by:
+
+    .. math::
+
+        TN_{ij} = \frac{ \sum_{i=1}^{I} TN_{ij} }{I}
+    """
+
+    arr = tasmin.resample(time=freq) if freq else tasmin
+    return arr.mean(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmin='[temperature]')
+def tn_min(tasmin, freq='YS'):
+    r"""Lowest minimum temperature
+
+    Minimum of daily minimum temperature.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Minimum of daily minimum temperature.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the minimum temperature at day :math:`i` of period :math:`j`. Then the minimum
+    daily minimum temperature for period :math:`j` is:
+
+    .. math::
+
+        TNn_j = min(TN_{ij})
+    """
+
+    return tasmin.resample(time=freq).min(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmax='[temperature]')
+def tx_max(tasmax, freq='YS'):
+    r"""Highest max temperature
+
+    The maximum value of daily maximum temperature.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Maximum value of daily maximum temperature.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then the maximum
+    daily maximum temperature for period :math:`j` is:
+
+    .. math::
+
+        TXx_j = max(TX_{ij})
+    """
+
+    return tasmax.resample(time=freq).max(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmax='[temperature]')
+def tx_mean(tasmax, freq='YS'):
+    r"""Mean max temperature
+
+    The mean of daily maximum temperature.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Mean of daily maximum temperature.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then mean
+    values in period :math:`j` are given by:
+
+    .. math::
+
+        TX_{ij} = \frac{ \sum_{i=1}^{I} TX_{ij} }{I}
+    """
+
+    arr = tasmax.resample(time=freq) if freq else tasmax
+    return arr.mean(dim='time', keep_attrs=True)
+
+
+@declare_units('[temperature]', tasmax='[temperature]')
+def tx_min(tasmax, freq='YS'):
+    r"""Lowest max temperature
+
+    The minimum of daily maximum temperature.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Minimum of daily maximum temperature.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then the minimum
+    daily maximum temperature for period :math:`j` is:
+
+    .. math::
+
+        TXn_j = min(TX_{ij})
+    """
+
+    return tasmax.resample(time=freq).min(dim='time', keep_attrs=True)
+
+
+@declare_units('', q='[discharge]')
+def base_flow_index(q, freq='YS'):
+    r"""Base flow index
+
+    Return the base flow index, defined as the minimum 7-day average flow divided by the mean flow.
+
+    Parameters
+    ----------
+    q : xarray.DataArray
+      Rate of river discharge [m³/s]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArrray
+      Base flow index.
+
+    Notes
+    -----
+    Let :math:`\mathbf{q}=q_0, q_1, \ldots, q_n` be the sequence of daily discharge and :math:`\overline{\mathbf{q}}`
+    the mean flow over the period. The base flow index is given by:
+
+    .. math::
+
+       \frac{\min(\mathrm{CMA}_7(\mathbf{q}))}{\overline{\mathbf{q}}}
+
+
+    where :math:`\mathrm{CMA}_7` is the seven days moving average of the daily flow:
+
+    .. math::
+
+       \mathrm{CMA}_7(q_i) = \frac{\sum_{j=i-3}^{i+3} q_j}{7}
+
+    """
+
+    m7 = q.rolling(time=7, center=True).mean().resample(time=freq)
+    mq = q.resample(time=freq)
+
+    m7m = m7.min(dim='time')
+    return m7m / mq.mean(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]')
+def consecutive_frost_days(tasmin, freq='AS-JUL'):
+    r"""Maximum number of consecutive frost days (Tmin < 0℃).
+
+    Resample the daily minimum temperature series by computing the maximum number
+    of days below the freezing point over each period.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature values [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The maximum number of consecutive days below the freezing point.
+
+    Notes
+    -----
+    Let :math:`\mathbf{x}=x_0, x_1, \ldots, x_n` be a daily minimum temperature series and
+    :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where :math:`[p_i < 0\celsius] \neq [p_{i+1} <
+    0\celsius]`, that is, the days when the temperature crosses the freezing point.
+    Then the maximum number of consecutive frost days is given by
+
+    .. math::
+
+       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [x_{s_j} > 0\celsius]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
+    the start and end of the series, but the numerical algorithm does.
+    """
+    tu = units.parse_units(tasmin.attrs['units'].replace('-', '**-'))
+    fu = 'degC'
+    frz = 0
+    if fu != tu:
+        frz = units.convert(frz, fu, tu)
+    group = (tasmin < frz).resample(time=freq)
+    return group.apply(rl.longest_run, dim='time')
+
+
+@declare_units('days', tasmin='[temperature]')
+def frost_days(tasmin, freq='YS'):
+    r"""Frost days index
+
+    Number of days where daily minimum temperatures are below 0℃.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Frost days index.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TN_{ij} < 0℃
+    """
+    tu = units.parse_units(tasmin.attrs['units'].replace('-', '**-'))
+    fu = 'degC'
+    frz = 0
+    if fu != tu:
+        frz = units.convert(frz, fu, tu)
+    f = (tasmin < frz) * 1
+    return f.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]')
+def ice_days(tasmax, freq='YS'):
+    r"""Number of ice/freezing days
+
+    Number of days where daily maximum temperatures are below 0℃.
+
+    Parameters
+    ----------
+    tasmax : xarrray.DataArray
+      Maximum daily temperature [℃] or [K]
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of ice/freezing days.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TX_{ij} < 0℃
+    """
+    tu = units.parse_units(tasmax.attrs['units'].replace('-', '**-'))
+    fu = 'degC'
+    frz = 0
+    if fu != tu:
+        frz = units.convert(frz, fu, tu)
+    f = (tasmax < frz) * 1
+    return f.resample(time=freq).sum(dim='time')
+
+
+@declare_units('mm/day', pr='[precipitation]')
+def max_1day_precipitation_amount(pr, freq='YS'):
+    r"""Highest 1-day precipitation amount for a period (frequency).
+
+    Resample the original daily total precipitation temperature series by taking the max over each period.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Daily precipitation values [Kg m-2 s-1] or [mm]
+    freq : str, optional
+      Resampling frequency one of : 'YS' (yearly) ,'M' (monthly), or 'QS-DEC' (seasonal - quarters starting in december)
+
+    Returns
+    -------
+    xarray.DataArray
+      The highest 1-day precipitation value at the given time frequency.
+
+    Notes
+    -----
+    Let :math:`PR_i` be the mean daily precipitation of day `i`, then for a period `j`:
+
+    .. math::
+
+       PRx_{ij} = max(PR_{ij})
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `pr.day.nc` the highest 1-day total
+    at an annual frequency:
+
+    >>> pr = xr.open_dataset('pr.day.nc').pr
+    >>> rx1day = max_1day_precipitation_amount(pr, freq="YS")
+    """
+
+    out = pr.resample(time=freq).max(dim='time', keep_attrs=True)
+    return utils.convert_units_to(out, 'mm/day', 'hydro')
+
+
+@declare_units('mm', pr='[precipitation]')
+def precip_accumulation(pr, freq='YS'):
+    r"""Accumulated total (liquid + solid) precipitation.
+
+    Resample the original daily mean precipitation flux and accumulate over each period.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [Kg m-2 s-1] or [mm].
+    freq : str, optional
+      Resampling frequency as defined in
+      http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling.
+
+    Returns
+    -------
+    xarray.DataArray
+      The total daily precipitation at the given time frequency.
+
+    Notes
+    -----
+    Let :math:`PR_i` be the mean daily precipitation of day :math:`i`, then for a period :math:`j` starting at
+    day :math:`a` and finishing on day :math:`b`:
+
+    .. math::
+
+       PR_{ij} = \sum_{i=a}^{b} PR_i
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `pr_day.nc` the total
+    precipitation at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
+
+    >>> pr_day = xr.open_dataset('pr_day.nc').pr
+    >>> prcp_tot_seasonal = precip_accumulation(pr_day, freq="QS-DEC")
+    """
+
+    out = pr.resample(time=freq).sum(dim='time', keep_attrs=True)
+    return utils.pint_multiply(out, 1 * units.day, 'mm')
diff --git a/xclim/indices/_threshold.py b/xclim/indices/_threshold.py
new file mode 100644
index 00000000..103136e9
--- /dev/null
+++ b/xclim/indices/_threshold.py
@@ -0,0 +1,712 @@
+import logging
+
+import numpy as np
+import xarray as xr
+
+from xclim import utils, run_length as rl
+from xclim.utils import declare_units, units
+
+logging.basicConfig(level=logging.DEBUG)
+logging.captureWarnings(True)
+
+xr.set_options(enable_cftimeindex=True)  # Set xarray to use cftimeindex
+
+# Frequencies : YS: year start, QS-DEC: seasons starting in december, MS: month start
+# See http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
+
+# -------------------------------------------------- #
+# ATTENTION: ASSUME ALL INDICES WRONG UNTIL TESTED ! #
+# -------------------------------------------------- #
+
+__all__ = ['cold_spell_days', 'daily_pr_intensity', 'maximum_consecutive_wet_days', 'cooling_degree_days',
+           'freshet_start', 'growing_degree_days', 'growing_season_length', 'heat_wave_index', 'heating_degree_days',
+           'tn_days_below', 'tx_days_above', 'warm_day_frequency', 'warm_night_frequency', 'wetdays',
+           'maximum_consecutive_dry_days', 'max_n_day_precipitation_amount', 'tropical_nights']
+
+
+@declare_units('days', tas='[temperature]', thresh='[temperature]')
+def cold_spell_days(tas, thresh='-10 degC', window=5, freq='AS-JUL'):
+    r"""Cold spell days
+
+    The number of days that are part of a cold spell, defined as five or more consecutive days with mean daily
+    temperature below a threshold in °C.
+
+    Parameters
+    ----------
+    tas : xarrray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature below which a cold spell begins [℃] or [K]. Default : '-10 degC'
+    window : int
+      Minimum number of days with temperature below threshold to qualify as a cold spell.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Cold spell days.
+
+    Notes
+    -----
+    Let :math:`T_i` be the mean daily temperature on day :math:`i`, the number of cold spell days during
+    period :math:`\phi` is given by
+
+    .. math::
+
+       \sum_{i \in \phi} \prod_{j=i}^{i+5} [T_j < thresh]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
+
+    """
+    t = utils.convert_units_to(thresh, tas)
+    over = tas < t
+    group = over.resample(time=freq)
+
+    return group.apply(rl.windowed_run_count, window=window, dim='time')
+
+
+@declare_units('mm/day', pr='[precipitation]', thresh='[precipitation]')
+def daily_pr_intensity(pr, thresh='1 mm/day', freq='YS'):
+    r"""Average daily precipitation intensity
+
+    Return the average precipitation over wet days.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Daily precipitation [mm/d or kg/m²/s]
+    thresh : str
+      precipitation value over which a day is considered wet. Default : '1 mm/day'
+    freq : str, optional
+      Resampling frequency defining the periods
+      defined in http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling. Default : '1 mm/day'
+
+    Returns
+    -------
+    xarray.DataArray
+      The average precipitation over wet days for each period
+
+    Notes
+    -----
+    Let :math:`\mathbf{p} = p_0, p_1, \ldots, p_n` be the daily precipitation and :math:`thresh` be the precipitation
+    threshold defining wet days. Then the daily precipitation intensity is defined as
+
+    .. math::
+
+       \frac{\sum_{i=0}^n p_i [p_i \leq thresh]}{\sum_{i=0}^n [p_i \leq thresh]}
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `pr.day.nc` the average
+    precipitation fallen over days with precipitation >= 5 mm at seasonal
+    frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
+
+    >>> pr = xr.open_dataset('pr.day.nc')
+    >>> daily_int = daily_pr_intensity(pr, thresh='5 mm/day', freq="QS-DEC")
+
+    """
+    t = utils.convert_units_to(thresh, pr, 'hydro')
+
+    # put pr=0 for non wet-days
+    pr_wd = xr.where(pr >= t, pr, 0)
+    pr_wd.attrs['units'] = pr.units
+
+    # sum over wanted period
+    s = pr_wd.resample(time=freq).sum(dim='time', keep_attrs=True)
+    sd = utils.pint_multiply(s, 1 * units.day, 'mm')
+
+    # get number of wetdays over period
+    wd = wetdays(pr, thresh=thresh, freq=freq)
+    return sd / wd
+
+
+@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
+def maximum_consecutive_wet_days(pr, thresh='1 mm/day', freq='YS'):
+    r"""Consecutive wet days.
+
+    Returns the maximum number of consecutive wet days.
+
+    Parameters
+    ---------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [Kg m-2 s-1] or [mm]
+    thresh : str
+      Threshold precipitation on which to base evaluation [Kg m-2 s-1] or [mm]. Default : '1 mm/day'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The maximum number of consecutive wet days.
+
+    Notes
+    -----
+    Let :math:`\mathbf{x}=x_0, x_1, \ldots, x_n` be a daily precipitation series and
+    :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where :math:`[p_i > thresh] \neq [p_{i+1} >
+    thresh]`, that is, the days when the precipitation crosses the *wet day* threshold.
+    Then the maximum number of consecutive wet days is given by
+
+    .. math::
+
+
+       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [x_{s_j} > 0\celsius]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
+    the start and end of the series, but the numerical algorithm does.
+    """
+    thresh = utils.convert_units_to(thresh, pr, 'hydro')
+
+    group = (pr > thresh).resample(time=freq)
+    return group.apply(rl.longest_run, dim='time')
+
+
+@declare_units('C days', tas='[temperature]', thresh='[temperature]')
+def cooling_degree_days(tas, thresh='18 degC', freq='YS'):
+    r"""Cooling degree days
+
+    Sum of degree days above the temperature threshold at which spaces are cooled.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Temperature threshold above which air is cooled. Default : '18 degC'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Cooling degree days
+
+    Notes
+    -----
+    Let :math:`x_i` be the daily mean temperature at day :math:`i`. Then the cooling degree days above
+    temperature threshold :math:`thresh` over period :math:`\phi` is given by:
+
+    .. math::
+
+        \sum_{i \in \phi} (x_{i}-{thresh} [x_i > thresh]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false.
+    """
+    thresh = utils.convert_units_to(thresh, tas)
+
+    return tas.pipe(lambda x: x - thresh) \
+        .clip(min=0) \
+        .resample(time=freq) \
+        .sum(dim='time')
+
+
+@declare_units('', tas='[temperature]', thresh='[temperature]')
+def freshet_start(tas, thresh='0 degC', window=5, freq='YS'):
+    r"""First day consistently exceeding threshold temperature.
+
+    Returns first day of period where a temperature threshold is exceeded
+    over a given number of days.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default '0 degC'
+    window : int
+      Minimum number of days with temperature above threshold needed for evaluation
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    float
+      Day of the year when temperature exceeds threshold over a given number of days for the first time. If there are
+      no such day, return np.nan.
+
+    Notes
+    -----
+    Let :math:`x_i` be the daily mean temperature at day of the year :math:`i` for values of :math:`i` going from 1
+    to 365 or 366. The start date of the freshet is given by the smallest index :math:`i` for which
+
+    .. math::
+
+       \prod_{j=i}^{i+w} [x_j > thresh]
+
+    is true, where :math:`w` is the number of days the temperature threshold should be exceeded,  and :math:`[P]` is
+    1 if :math:`P` is true, and 0 if false.
+    """
+    thresh = utils.convert_units_to(thresh, tas)
+    over = (tas > thresh)
+    group = over.resample(time=freq)
+    return group.apply(rl.first_run_ufunc, window=window, index='dayofyear')
+
+
+@declare_units('C days', tas='[temperature]', thresh='[temperature]')
+def growing_degree_days(tas, thresh='4.0 degC', freq='YS'):
+    r"""Growing degree-days over threshold temperature value [℃].
+
+    The sum of degree-days over the threshold temperature.
+
+    Parameters
+    ---------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default: '4.0 degC'.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The sum of growing degree-days above 4℃
+
+    Notes
+    -----
+    Let :math:`TG_{ij}` be the daily mean temperature at day :math:`i` of period :math:`j`. Then the
+    growing degree days are:
+
+    .. math::
+
+        GD4_j = \sum_{i=1}^I (TG_{ij}-{4} | TG_{ij} > {4}℃)
+    """
+    thresh = utils.convert_units_to(thresh, tas)
+    return tas.pipe(lambda x: x - thresh) \
+        .clip(min=0) \
+        .resample(time=freq) \
+        .sum(dim='time')
+
+
+@declare_units('days', tas='[temperature]', thresh='[temperature]')
+def growing_season_length(tas, thresh='5.0 degC', window=6, freq='YS'):
+    r"""Growing season length.
+
+    The number of days between the first occurrence of at least
+    six consecutive days with mean daily temperature over 5℃ and
+    the first occurrence of at least six consecutive days with
+    mean daily temperature below 5℃ after July 1st in the northern
+    hemisphere and January 1st in the southern hemisphere.
+
+    Parameters
+    ---------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default: '5.0 degC'.
+    window : int
+      Minimum number of days with temperature above threshold to mark the beginning and end of growing season.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Growing season length.
+
+    Notes
+    -----
+    Let :math:`TG_{ij}` be the mean temperature at day :math:`i` of period :math:`j`. Then counted is
+    the number of days between the first occurrence of at least 6 consecutive days with:
+
+    .. math::
+
+        TG_{ij} > 5 ℃
+
+    and the first occurrence after 1 July of at least 6 consecutive days with:
+
+    .. math::
+
+        TG_{ij} < 5 ℃
+    """
+
+    # i = xr.DataArray(np.arange(tas.time.size), dims='time')
+    # ind = xr.broadcast(i, tas)[0]
+    #
+    # c = ((tas > thresh) * 1).rolling(time=window).sum()
+    # i1 = ind.where(c == window).resample(time=freq).min(dim='time')
+    #
+    # # Resample sets the time to T00:00.
+    # i11 = i1.reindex_like(c, method='ffill')
+    #
+    # # TODO: Adjust for southern hemisphere
+    #
+    # #i2 = ind.where(c == 0).where(tas.time.dt.month >= 7)
+    # # add check to make sure indice of end of growing season is after growing season start
+    # i2 = ind.where((c==0) & (ind > i11)).where(tas.time.dt.month >= 7)
+    #
+    # d = i2 - i11
+    #
+    # # take min value (first occurence after july)
+    # gsl = d.resample(time=freq).min(dim='time')
+    #
+    # # turn nan into 0
+    # gsl = xr.where(np.isnan(gsl), 0, gsl)
+
+    # compute growth season length on resampled data
+    thresh = utils.convert_units_to(thresh, tas)
+
+    c = ((tas > thresh) * 1).rolling(time=window).sum().chunk(tas.chunks)
+
+    def compute_gsl(c):
+        nt = c.time.size
+        i = xr.DataArray(np.arange(nt), dims='time').chunk({'time': 1})
+        ind = xr.broadcast(i, c)[0].chunk(c.chunks)
+        i1 = ind.where(c == window).min(dim='time')
+        i1 = xr.where(np.isnan(i1), nt, i1)
+        i11 = i1.reindex_like(c, method='ffill')
+        i2 = ind.where((c == 0) & (ind > i11)).where(c.time.dt.month >= 7)
+        i2 = xr.where(np.isnan(i2), nt, i2)
+        d = (i2 - i1).min(dim='time')
+        return d
+
+    gsl = c.resample(time=freq).apply(compute_gsl)
+
+    return gsl
+
+
+@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
+def heat_wave_index(tasmax, thresh='25.0 degC', window=5, freq='YS'):
+    r"""Heat wave index.
+
+    Number of days that are part of a heatwave, defined as five or more consecutive days over 25℃.
+
+    Parameters
+    ----------
+    tasmax : xarrray.DataArray
+      Maximum daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to designate a heatwave [℃] or [K]. Default: '25.0 degC'.
+    window : int
+      Minimum number of days with temperature above threshold to qualify as a heatwave.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    DataArray
+      Heat wave index.
+    """
+    thresh = utils.convert_units_to(thresh, tasmax)
+    over = tasmax > thresh
+    group = over.resample(time=freq)
+
+    return group.apply(rl.windowed_run_count, window=window, dim='time')
+
+
+@declare_units('C days', tas='[temperature]', thresh='[temperature]')
+def heating_degree_days(tas, thresh='17.0 degC', freq='YS'):
+    r"""Heating degree days
+
+    Sum of degree days below the temperature threshold at which spaces are heated.
+
+    Parameters
+    ----------
+    tas : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default: '17.0 degC'.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Heating degree days index.
+
+    Notes
+    -----
+    Let :math:`TG_{ij}` be the daily mean temperature at day :math:`i` of period :math:`j`. Then the
+    heating degree days are:
+
+    .. math::
+
+        HD17_j = \sum_{i=1}^{I} (17℃ - TG_{ij})
+    """
+    thresh = utils.convert_units_to(thresh, tas)
+
+    return tas.pipe(lambda x: thresh - x) \
+        .clip(0) \
+        .resample(time=freq) \
+        .sum(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
+def tn_days_below(tasmin, thresh='-10.0 degC', freq='YS'):
+    r"""Number of days with tmin below a threshold in
+
+    Number of days where daily minimum temperature is below a threshold.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K] . Default: '-10 degC'.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of days Tmin < threshold.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TX_{ij} < Threshold [℃]
+    """
+    thresh = utils.convert_units_to(thresh, tasmin)
+    f1 = utils.threshold_count(tasmin, '<', thresh, freq)
+    return f1
+
+
+@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
+def tx_days_above(tasmax, thresh='25.0 degC', freq='YS'):
+    r"""Number of summer days
+
+    Number of days where daily maximum temperature exceed a threshold.
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Maximum daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default: '25 degC'.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of summer days.
+
+    Notes
+    -----
+    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TX_{ij} > Threshold [℃]
+    """
+    thresh = utils.convert_units_to(thresh, tasmax)
+    f = (tasmax > (thresh)) * 1
+    return f.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmax='[temperature]', thresh='[temperature]')
+def warm_day_frequency(tasmax, thresh='30 degC', freq='YS'):
+    r"""Frequency of extreme warm days
+
+    Return the number of days with tasmax > thresh per period
+
+    Parameters
+    ----------
+    tasmax : xarray.DataArray
+      Mean daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default : '30 degC'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of days exceeding threshold.
+
+    Notes:
+    Let :math:`TX_{ij}` be the daily maximum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TN_{ij} > Threshold [℃]
+
+    """
+    thresh = utils.convert_units_to(thresh, tasmax)
+    events = (tasmax > thresh) * 1
+    return events.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
+def warm_night_frequency(tasmin, thresh='22 degC', freq='YS'):
+    r"""Frequency of extreme warm nights
+
+    Return the number of days with tasmin > thresh per period
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default : '22 degC'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The number of days with tasmin > thresh per period
+    """
+    thresh = utils.convert_units_to(thresh, tasmin, )
+    events = (tasmin > thresh) * 1
+    return events.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
+def wetdays(pr, thresh='1.0 mm/day', freq='YS'):
+    r"""Wet days
+
+    Return the total number of days during period with precipitation over threshold.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Daily precipitation [mm]
+    thresh : str
+      Precipitation value over which a day is considered wet. Default: '1 mm/day'.
+    freq : str, optional
+      Resampling frequency defining the periods
+      defined in http://pandas.pydata.org/pandas-docs/stable/timeseries.html#resampling.
+
+    Returns
+    -------
+    xarray.DataArray
+      The number of wet days for each period [day]
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `pr.day.nc` the number days
+    with precipitation over 5 mm at the seasonal frequency, ie DJF, MAM, JJA, SON, DJF, etc.:
+
+    >>> pr = xr.open_dataset('pr.day.nc')
+    >>> wd = wetdays(pr, pr_min = 5., freq="QS-DEC")
+    """
+    thresh = utils.convert_units_to(thresh, pr, 'hydro')
+
+    wd = (pr >= thresh) * 1
+    return wd.resample(time=freq).sum(dim='time')
+
+
+@declare_units('days', pr='[precipitation]', thresh='[precipitation]')
+def maximum_consecutive_dry_days(pr, thresh='1 mm/day', freq='YS'):
+    r"""Maximum number of consecutive dry days
+
+    Return the maximum number of consecutive days within the period where precipitation
+    is below a certain threshold.
+
+    Parameters
+    ----------
+    pr : xarray.DataArray
+      Mean daily precipitation flux [mm]
+    thresh : str
+      Threshold precipitation on which to base evaluation [mm]. Default : '1 mm/day'
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      The maximum number of consecutive dry days.
+
+    Notes
+    -----
+    Let :math:`\mathbf{p}=p_0, p_1, \ldots, p_n` be a daily precipitation series and :math:`thresh` the threshold
+    under which a day is considered dry. Then let :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where
+    :math:`[p_i < thresh] \neq [p_{i+1} < thresh]`, that is, the days when the temperature crosses the threshold.
+    Then the maximum number of consecutive dry days is given by
+
+    .. math::
+
+       \max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [p_{s_j} > thresh]
+
+    where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
+    the start and end of the series, but the numerical algorithm does.
+    """
+    t = utils.convert_units_to(thresh, pr, 'hydro')
+    group = (pr < t).resample(time=freq)
+
+    return group.apply(rl.longest_run, dim='time')
+
+
+@declare_units('mm', pr='[precipitation]')
+def max_n_day_precipitation_amount(pr, window=1, freq='YS'):
+    r"""Highest precipitation amount cumulated over a n-day moving window.
+
+    Calculate the n-day rolling sum of the original daily total precipitation series
+    and determine the maximum value over each period.
+
+    Parameters
+    ----------
+    da : xarray.DataArray
+      Daily precipitation values [Kg m-2 s-1] or [mm]
+    window : int
+      Window size in days.
+    freq : str, optional
+      Resampling frequency : default 'YS' (yearly)
+
+    Returns
+    -------
+    xarray.DataArray
+      The highest cumulated n-day precipitation value at the given time frequency.
+
+    Examples
+    --------
+    The following would compute for each grid cell of file `pr.day.nc` the highest 5-day total precipitation
+    at an annual frequency:
+
+    >>> da = xr.open_dataset('pr.day.nc').pr
+    >>> window = 5
+    >>> output = max_n_day_precipitation_amount(da, window, freq="YS")
+    """
+
+    # rolling sum of the values
+    arr = pr.rolling(time=window, center=False).sum()
+    out = arr.resample(time=freq).max(dim='time', keep_attrs=True)
+
+    out.attrs['units'] = pr.units
+    # Adjust values and units to make sure they are daily
+    return utils.pint_multiply(out, 1 * units.day, 'mm')
+
+
+@declare_units('days', tasmin='[temperature]', thresh='[temperature]')
+def tropical_nights(tasmin, thresh='20.0 degC', freq='YS'):
+    r"""Tropical nights
+
+    The number of days with minimum daily temperature above threshold.
+
+    Parameters
+    ----------
+    tasmin : xarray.DataArray
+      Minimum daily temperature [℃] or [K]
+    thresh : str
+      Threshold temperature on which to base evaluation [℃] or [K]. Default: '20 degC'.
+    freq : str, optional
+      Resampling frequency
+
+    Returns
+    -------
+    xarray.DataArray
+      Number of days with minimum daily temperature above threshold.
+
+    Notes
+    -----
+    Let :math:`TN_{ij}` be the daily minimum temperature at day :math:`i` of period :math:`j`. Then
+    counted is the number of days where:
+
+    .. math::
+
+        TN_{ij} > Threshold [℃]
+    """
+    thresh = utils.convert_units_to(thresh, tasmin)
+    return tasmin.pipe(lambda x: (tasmin > thresh) * 1) \
+        .resample(time=freq) \
+        .sum(dim='time')
diff --git a/xclim/streamflow.py b/xclim/streamflow.py
index 70612492..c176da23 100644
--- a/xclim/streamflow.py
+++ b/xclim/streamflow.py
@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 import numpy as np
+
+from xclim.indices import base_flow_index
 from xclim import checks
-from xclim import indices as _ind
 from xclim.utils import Indicator, wrapped_partial
 from xclim import generic
 # from boltons.funcutils import FunctionBuilder
@@ -36,7 +37,7 @@ class Stats(Streamflow):
 base_flow_index = Streamflow(identifier='base_flow_index',
                              units='',
                              long_name="Base flow index",
-                             compute=_ind.base_flow_index)
+                             compute=base_flow_index)
 
 
 freq_analysis = Stats(identifier='q{window}{mode}{indexer}',
diff --git a/xclim/subset.py b/xclim/subset.py
new file mode 100644
index 00000000..af53e00f
--- /dev/null
+++ b/xclim/subset.py
@@ -0,0 +1,152 @@
+import numpy as np
+from pyproj import Geod
+
+
+def subset_bbox(da, lon_bnds=None, lat_bnds=None, start_yr=None, end_yr=None):
+    """Subset a datarray or dataset spatially (and temporally) using a lat lon bounding box and years selection.
+
+    Return a subsetted data array for grid points falling within a spatial bounding box
+    defined by longitude and latitudinal bounds and for years falling within provided year bounds.
+
+    Parameters
+    ----------
+    arr : xarray.DataArray or xarray.Dataset
+      Input data.
+    lon_bnds : list of floats
+      List of maximum and minimum longitudinal bounds. Optional. Defaults to all longitudes in original data-array.
+    lat_bnds :  list of floats
+      List maximum and minimum latitudinal bounds. Optional. Defaults to all latitudes in original data-array.
+    start_yr : int
+      First year of the subset. Defaults to first year of input.
+    end_yr : int
+      Last year of the subset. Defaults to last year of input.
+
+    Returns
+    -------
+    xarray.DataArray or xarray.DataSet
+      subsetted data array or dataset
+
+    Examples
+    --------
+    >>> from xclim import utils
+    >>> ds = xr.open_dataset('pr.day.nc')
+    Subset lat lon and years
+    >>> prSub = utils.subset_bbox(ds.pr, lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1999)
+    Subset data array lat, lon and single year
+    >>> prSub = utils.subset_bbox(ds.pr, lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1990)
+    Subset dataarray single year keep entire lon, lat grid
+    >>> prSub = utils.subset_bbox(ds.pr,start_yr=1990,end_yr=1990) # one year only entire grid
+    Subset multiple variables in a single dataset
+    >>> ds = xr.open_mfdataset(['pr.day.nc','tas.day.nc'])
+    >>> dsSub = utils.subset_bbox(ds,lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1999)
+    """
+
+    if lon_bnds:
+
+        lon_bnds = np.asarray(lon_bnds)
+        if np.all(da.lon > 0) and np.any(lon_bnds < 0):
+            lon_bnds[lon_bnds < 0] += 360
+        da = da.where((da.lon >= lon_bnds.min()) & (da.lon <= lon_bnds.max()), drop=True)
+
+    if lat_bnds:
+        lat_bnds = np.asarray(lat_bnds)
+        da = da.where((da.lat >= lat_bnds.min()) & (da.lat <= lat_bnds.max()), drop=True)
+
+    if start_yr or end_yr:
+        if not start_yr:
+            start_yr = da.time.dt.year.min()
+        if not end_yr:
+            end_yr = da.time.dt.year.max()
+
+        if start_yr > end_yr:
+            raise ValueError("Start date is after end date.")
+
+        year_bnds = np.asarray([start_yr, end_yr])
+        da = da.where((da.time.dt.year >= year_bnds.min()) & (da.time.dt.year <= year_bnds.max()), drop=True)
+
+    return da
+
+
+def subset_gridpoint(da, lon, lat, start_yr=None, end_yr=None):
+    """Extract a nearest gridpoint from datarray based on lat lon coordinate.
+    Time series can optionally be subsetted by year(s)
+
+    Return a subsetted data array (or dataset) for the grid point falling nearest the input
+    longitude and latitudecoordinates. Optionally subset the data array for years falling
+    within provided year bounds
+
+    Parameters
+    ----------
+    da : xarray.DataArray or xarray.DataSet
+      Input data.
+    lon : float
+      Longitude coordinate.
+    lat:  float
+      Latitude coordinate.
+    start_yr : int
+      First year of the subset. Defaults to first year of input.
+    end_yr : int
+      Last year of the subset. Defaults to last year of input.
+
+    Returns
+    -------
+    xarray.DataArray or xarray.DataSet
+      Subsetted data array or dataset
+
+    Examples
+    --------
+    >>> from xclim import utils
+    >>> ds = xr.open_dataset('pr.day.nc')
+    Subset lat lon point and multiple years
+    >>> prSub = utils.subset_gridpoint(ds.pr, lon=-75,lat=45,start_yr=1990,end_yr=1999)
+    Subset lat, lon point and single year
+    >>> prSub = utils.subset_gridpoint(ds.pr, lon=-75,lat=45,start_yr=1990,end_yr=1990)
+     Subset multiple variables in a single dataset
+    >>> ds = xr.open_mfdataset(['pr.day.nc','tas.day.nc'])
+    >>> dsSub = utils.subset_gridpoint(ds, lon=-75,lat=45,start_yr=1990,end_yr=1999)
+    """
+
+    g = Geod(ellps='WGS84')  # WGS84 ellipsoid - decent globaly
+    # adjust for files with all postive longitudes if necessary
+    if np.all(da.lon > 0) and lon < 0:
+        lon += 360
+
+    if len(da.lon.shape) == 1 & len(da.lat.shape) == 1:
+        # create a 2d grid of lon, lat values
+        lon1, lat1 = np.meshgrid(np.asarray(da.lon.values), np.asarray(da.lat.values))
+
+    else:
+        lon1 = da.lon.values
+        lat1 = da.lat.values
+    shp_orig = lon1.shape
+    lon1 = np.reshape(lon1, lon1.size)
+    lat1 = np.reshape(lat1, lat1.size)
+    # calculate geodesic distance between grid points and point of interest
+    az12, az21, dist = g.inv(lon1, lat1, np.broadcast_to(lon, lon1.shape), np.broadcast_to(lat, lat1.shape))
+    dist = dist.reshape(shp_orig)
+
+    iy, ix = np.unravel_index(np.argmin(dist, axis=None), dist.shape)
+    xydims = [x for x in da.dims if 'time' not in x]
+
+    args = dict()
+    args[xydims[0]] = iy
+    args[xydims[1]] = ix
+    out = da.isel(**args)
+    if start_yr or end_yr:
+        if not start_yr:
+            start_yr = da.time.dt.year.min()
+        if not end_yr:
+            end_yr = da.time.dt.year.max()
+
+        if start_yr > end_yr:
+            raise ValueError("Start date is after end date.")
+
+        year_bnds = np.asarray([start_yr, end_yr])
+
+        if len(year_bnds) == 1:
+            time_cond = da.time.dt.year == year_bnds
+        else:
+            time_cond = (da.time.dt.year >= year_bnds.min()) & (da.time.dt.year <= year_bnds.max())
+        out = out.where(time_cond, drop=True)
+
+    return out
diff --git a/xclim/utils.py b/xclim/utils.py
index 666dabd9..40d0c401 100644
--- a/xclim/utils.py
+++ b/xclim/utils.py
@@ -4,23 +4,23 @@
 xclim xarray.DataArray utilities module
 """
 
-import numpy as np
-import six
-import re
-import pint
-import pandas as pd
-import xarray as xr
-from . import checks
-from inspect import signature
-import functools
 import abc
-from collections import defaultdict
-import datetime as dt
 import calendar
-from pyproj import Geod
+import datetime as dt
+import functools
+import re
 import warnings
+from collections import defaultdict
+from inspect import signature
+
+import numpy as np
+import pint
+import six
+import xarray as xr
 from boltons.funcutils import wraps
 
+from . import checks
+
 units = pint.UnitRegistry(autoconvert_offset_to_baseunit=True)
 units.define(pint.unit.UnitDefinition('percent', '%', (),
                                       pint.converters.ScaleConverter(0.01)))
@@ -287,275 +287,6 @@ def declare_units(out_units, **units_by_name):
     return dec
 
 
-def create_ensemble(ncfiles, mf_flag=False):
-    """Create an xarray datset of ensemble of climate simulation from a list of netcdf files. Input data is
-    concatenated along a newly created data dimension ('realization')
-
-    Returns a xarray dataset object containing input data from the list of netcdf files concatenated along
-    a new dimension (name:'realization'). In the case where input files have unequal time dimensions output
-    ensemble dataset is created for overlapping time-steps common to all input files
-
-    Parameters
-    ----------
-    ncfiles : sequence
-      List of netcdf file paths. If mf_flag is true ncfiles should be a list of lists where
-    each sublist contains input .nc files of a multifile dataset
-
-    mf_flag : Boolean . If true climate simulations are treated as multifile datasets before concatenation
-
-    Returns
-    -------
-    xarray dataset containing concatenated data from all input files
-
-    Notes
-    -----
-    Input netcdf files require equal spatial dimension size (e.g. lon, lat dimensions)
-    If input data contains multiple cftime calendar types they must be at monthly or coarser frequency
-
-    Examples
-    --------
-    >>> from xclim import utils
-    >>> import glob
-    >>> ncfiles = glob.glob('/*.nc')
-    >>> ens = utils.create_ensemble(ncfiles)
-    >>> print(ens)
-    Using multifile datasets:
-    simulation 1 is a list of .nc files (e.g. separated by time)
-    >>> ncfiles = glob.glob('dir/*.nc')
-    simulation 2 is also a list of .nc files
-    >>> ens = utils.create_ensemble(ncfiles)
-    """
-    dim = 'realization'
-    ds1 = []
-    start_end_flag = True
-    print('finding common time-steps')
-    for n in ncfiles:
-        if mf_flag:
-            ds = xr.open_mfdataset(n, concat_dim='time', decode_times=False, chunks={'time': 10})
-            ds['time'] = xr.open_mfdataset(n).time
-        else:
-            ds = xr.open_dataset(n, decode_times=False)
-            ds['time'] = xr.decode_cf(ds).time
-        # get times - use common
-        time1 = pd.to_datetime({'year': ds.time.dt.year, 'month': ds.time.dt.month, 'day': ds.time.dt.day})
-        if start_end_flag:
-            start1 = time1.values[0]
-            end1 = time1.values[-1]
-            start_end_flag = False
-        if time1.values.min() > start1:
-            start1 = time1.values.min()
-        if time1.values.max() < end1:
-            end1 = time1.values.max()
-
-    for n in ncfiles:
-        print('accessing file ', ncfiles.index(n) + 1, ' of ', len(ncfiles))
-        if mf_flag:
-            ds = xr.open_mfdataset(n, concat_dim='time', decode_times=False, chunks={'time': 10})
-            ds['time'] = xr.open_mfdataset(n).time
-        else:
-            ds = xr.open_dataset(n, decode_times=False, chunks={'time': 10})
-            ds['time'] = xr.decode_cf(ds).time
-
-        ds['time'].values = pd.to_datetime({'year': ds.time.dt.year, 'month': ds.time.dt.month, 'day': ds.time.dt.day})
-
-        ds = ds.where((ds.time >= start1) & (ds.time <= end1), drop=True)
-
-        ds1.append(ds.drop('time'))
-    print('concatenating files : adding dimension ', dim, )
-    ens = xr.concat(ds1, dim=dim)
-    # assign time coords
-    ens = ens.assign_coords(time=ds.time.values)
-    return ens
-
-
-def ensemble_percentiles(ens, values=(10, 50, 90), time_block=None):
-    """Calculate ensemble statistics between a results from an ensemble of climate simulations
-
-    Returns a dataset containing ensemble statistics for input climate simulations.
-    Alternatively calculate ensemble percentiles (default) or ensemble mean and standard deviation
-
-    Parameters
-    ----------
-    ens : Ensemble dataset (see xclim.utils.create_ensemble)
-    values : tuple of integers - percentile values to calculate  : default : (10, 50, 90)
-    time_block : integer
-      for large ensembles iteratively calculate percentiles in time-step blocks (n==time_block).
-       If not defined the function tries to estimate an appropriate value
-
-    Returns
-    -------
-    xarray dataset with containing data variables of requested ensemble statistics
-
-    Examples
-    --------
-    >>> from xclim import utils
-    >>> import glob
-    >>> ncfiles = glob.glob('/*tas*.nc')
-    Create ensemble dataset
-    >>> ens = utils.create_ensemble(ncfiles)
-    Calculate default ensemble percentiles
-    >>> ens_percs = utils.ensemble_statistics(ens)
-    >>> print(ens_percs['tas_p10'])
-    Calculate non-default percentiles (25th and 75th)
-    >>> ens_percs = utils.ensemble_statistics(ens, values=(25,75))
-    >>> print(ens_percs['tas_p25'])
-    Calculate by time blocks (n=10) if ensemble size is too large to load in memory
-    >>> ens_percs = utils.ensemble_statistics(ens, time_block=10)
-    >>> print(ens_percs['tas_p25'])
-
-    """
-
-    ds_out = ens.drop(ens.data_vars)
-    dims = list(ens.dims)
-    for v in ens.data_vars:
-        # Percentile calculation requires load to memory : automate size for large ensemble objects
-        if not time_block:
-            time_block = round(2E8 / (ens[v].size / ens[v].shape[dims.index('time')]), -1)  # 2E8
-
-        if time_block > len(ens[v].time):
-            out = calc_percentiles_simple(ens, v, values)
-
-        else:
-            # loop through blocks
-            Warning('large ensemble size detected : statistics will be calculated in blocks of ', int(time_block),
-                    ' time-steps')
-            out = calc_percentiles_blocks(ens, v, values, time_block)
-        for vv in out.data_vars:
-            ds_out[vv] = out[vv]
-    return ds_out
-
-
-def calc_percentiles_simple(ens, v, values):
-    ds_out = ens.drop(ens.data_vars)
-    dims = list(ens[v].dims)
-    outdims = [x for x in dims if 'realization' not in x]
-
-    print('loading ensemble data to memory')
-    arr = ens[v].load()  # percentile calc requires loading the array
-    coords = {}
-    for c in outdims:
-        coords[c] = arr[c]
-    for p in values:
-        outvar = v + '_p' + str(p)
-
-        out1 = calc_perc(arr, p)
-
-        ds_out[outvar] = xr.DataArray(out1, dims=outdims, coords=coords)
-        ds_out[outvar].attrs = ens[v].attrs
-        if 'description' in ds_out[outvar].attrs.keys():
-            ds_out[outvar].attrs['description'] = ds_out[outvar].attrs['description'] + ' : ' + str(p) + \
-                                                  'th percentile of ensemble'
-        else:
-            ds_out[outvar].attrs['description'] = str(p) + \
-                                                  'th percentile of ensemble'
-    return ds_out
-
-
-def calc_percentiles_blocks(ens, v, values, time_block):
-    ds_out = ens.drop(ens.data_vars)
-    dims = list(ens[v].dims)
-    outdims = [x for x in dims if 'realization' not in x]
-
-    blocks = list(range(0, len(ens.time) + 1, int(time_block)))
-    if blocks[-1] != len(ens[v].time):
-        blocks.append(len(ens[v].time))
-    arr_p_all = {}
-    for t in range(0, len(blocks) - 1):
-        print('Calculating block ', t + 1, ' of ', len(blocks) - 1)
-        time_sel = slice(blocks[t], blocks[t + 1])
-        arr = ens[v].isel(time=time_sel).load()  # percentile calc requires loading the array
-        coords = {}
-        for c in outdims:
-            coords[c] = arr[c]
-        for p in values:
-
-            out1 = calc_perc(arr, p)
-
-            if t == 0:
-                arr_p_all[str(p)] = xr.DataArray(out1, dims=outdims, coords=coords)
-            else:
-                arr_p_all[str(p)] = xr.concat([arr_p_all[str(p)],
-                                               xr.DataArray(out1, dims=outdims, coords=coords)], dim='time')
-    for p in values:
-        outvar = v + '_p' + str(p)
-        ds_out[outvar] = arr_p_all[str(p)]
-        ds_out[outvar].attrs = ens[v].attrs
-        if 'description' in ds_out[outvar].attrs.keys():
-            ds_out[outvar].attrs['description'] = ds_out[outvar].attrs['description'] + ' : ' + str(p) + \
-                                                  'th percentile of ensemble'
-        else:
-            ds_out[outvar].attrs['description'] = str(p) + \
-                                                  'th percentile of ensemble'
-    return ds_out
-
-
-def calc_perc(arr, p):
-    dims = arr.dims
-    # make sure time is the second dimension
-    if dims.index('time') != 1:
-        dims1 = [dims[dims.index('realization')], dims[dims.index('time')]]
-        for d in dims:
-            if d not in dims1:
-                dims1.append(d)
-        arr = arr.transpose(*dims1)
-        dims = dims1
-
-    nan_count = np.isnan(arr).sum(axis=dims.index('realization'))
-    out = np.percentile(arr, p, axis=dims.index('realization'))
-    if np.any((nan_count > 0) & (nan_count < arr.shape[dims.index('realization')])):
-        arr1 = arr.values.reshape(arr.shape[dims.index('realization')],
-                                  int(arr.size / arr.shape[dims.index('realization')]))
-        # only use nanpercentile where we need it (slow performace compared to standard) :
-        nan_index = np.where((nan_count > 0) & (nan_count < arr.shape[dims.index('realization')]))
-        t = np.ravel_multi_index(nan_index, nan_count.shape)
-        out[np.unravel_index(t, nan_count.shape)] = np.nanpercentile(arr1[:, t], p, axis=dims.index('realization'))
-
-    return out
-
-
-def ensemble_mean_std_max_min(ens):
-    """Calculate ensemble statistics between a results from an ensemble of climate simulations
-
-    Returns a dataset containing ensemble mean, standard-deviation,
-    minimum and maximum for input climate simulations.
-
-    Parameters
-    ----------
-    ens : Ensemble dataset (see xclim.utils.create_ensemble)
-
-    Returns
-    -------
-    xarray dataset with containing data variables of ensemble statistics
-
-    Examples
-    --------
-    >>> from xclim import utils
-    >>> import glob
-    >>> ncfiles = glob.glob('/*tas*.nc')
-    Create ensemble dataset
-    >>> ens = utils.create_ensemble(ncfiles)
-    Calculate ensemble statistics
-    >>> ens_means_std = utils.ensemble_mean_std_max_min(ens)
-    >>> print(ens_mean_std['tas_mean'])
-    """
-    dsOut = ens.drop(ens.data_vars)
-    for v in ens.data_vars:
-
-        dsOut[v + '_mean'] = ens[v].mean(dim='realization')
-        dsOut[v + '_stdev'] = ens[v].std(dim='realization')
-        dsOut[v + '_max'] = ens[v].max(dim='realization')
-        dsOut[v + '_min'] = ens[v].min(dim='realization')
-        for vv in dsOut.data_vars:
-            dsOut[vv].attrs = ens[v].attrs
-
-            if 'description' in dsOut[vv].attrs.keys():
-                vv.split()
-                dsOut[vv].attrs['description'] = dsOut[vv].attrs['description'] + ' : ' + vv.split('_')[
-                    -1] + ' of ensemble'
-
-    return dsOut
-
-
 def threshold_count(da, op, thresh, freq):
     """Count number of days above or below threshold.
 
@@ -717,155 +448,6 @@ def adjust_doy_calendar(source, target):
     return _interpolate_doy_calendar(source, doy_max)
 
 
-def subset_bbox(da, lon_bnds=None, lat_bnds=None, start_yr=None, end_yr=None):
-    """Subset a datarray or dataset spatially (and temporally) using a lat lon bounding box and years selection.
-
-    Return a subsetted data array for grid points falling within a spatial bounding box
-    defined by longitude and latitudinal bounds and for years falling within provided year bounds.
-
-    Parameters
-    ----------
-    arr : xarray.DataArray or xarray.Dataset
-      Input data.
-    lon_bnds : list of floats
-      List of maximum and minimum longitudinal bounds. Optional. Defaults to all longitudes in original data-array.
-    lat_bnds :  list of floats
-      List maximum and minimum latitudinal bounds. Optional. Defaults to all latitudes in original data-array.
-    start_yr : int
-      First year of the subset. Defaults to first year of input.
-    end_yr : int
-      Last year of the subset. Defaults to last year of input.
-
-    Returns
-    -------
-    xarray.DataArray or xarray.DataSet
-      subsetted data array or dataset
-
-    Examples
-    --------
-    >>> from xclim import utils
-    >>> ds = xr.open_dataset('pr.day.nc')
-    Subset lat lon and years
-    >>> prSub = utils.subset_bbox(ds.pr, lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1999)
-    Subset data array lat, lon and single year
-    >>> prSub = utils.subset_bbox(ds.pr, lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1990)
-    Subset dataarray single year keep entire lon, lat grid
-    >>> prSub = utils.subset_bbox(ds.pr,start_yr=1990,end_yr=1990) # one year only entire grid
-    Subset multiple variables in a single dataset
-    >>> ds = xr.open_mfdataset(['pr.day.nc','tas.day.nc'])
-    >>> dsSub = utils.subset_bbox(ds,lon_bnds=[-75,-70],lat_bnds=[40,45],start_yr=1990,end_yr=1999)
-    """
-
-    if lon_bnds:
-
-        lon_bnds = np.asarray(lon_bnds)
-        if np.all(da.lon > 0) and np.any(lon_bnds < 0):
-            lon_bnds[lon_bnds < 0] += 360
-        da = da.where((da.lon >= lon_bnds.min()) & (da.lon <= lon_bnds.max()), drop=True)
-
-    if lat_bnds:
-        lat_bnds = np.asarray(lat_bnds)
-        da = da.where((da.lat >= lat_bnds.min()) & (da.lat <= lat_bnds.max()), drop=True)
-
-    if start_yr or end_yr:
-        if not start_yr:
-            start_yr = da.time.dt.year.min()
-        if not end_yr:
-            end_yr = da.time.dt.year.max()
-
-        if start_yr > end_yr:
-            raise ValueError("Start date is after end date.")
-
-        year_bnds = np.asarray([start_yr, end_yr])
-        da = da.where((da.time.dt.year >= year_bnds.min()) & (da.time.dt.year <= year_bnds.max()), drop=True)
-
-    return da
-
-
-def subset_gridpoint(da, lon, lat, start_yr=None, end_yr=None):
-    """Extract a nearest gridpoint from datarray based on lat lon coordinate.
-    Time series can optionally be subsetted by year(s)
-
-    Return a subsetted data array (or dataset) for the grid point falling nearest the input
-    longitude and latitudecoordinates. Optionally subset the data array for years falling
-    within provided year bounds
-
-    Parameters
-    ----------
-    da : xarray.DataArray or xarray.DataSet
-      Input data.
-    lon : float
-      Longitude coordinate.
-    lat:  float
-      Latitude coordinate.
-    start_yr : int
-      First year of the subset. Defaults to first year of input.
-    end_yr : int
-      Last year of the subset. Defaults to last year of input.
-
-    Returns
-    -------
-    xarray.DataArray or xarray.DataSet
-      Subsetted data array or dataset
-
-    Examples
-    --------
-    >>> from xclim import utils
-    >>> ds = xr.open_dataset('pr.day.nc')
-    Subset lat lon point and multiple years
-    >>> prSub = utils.subset_gridpoint(ds.pr, lon=-75,lat=45,start_yr=1990,end_yr=1999)
-    Subset lat, lon point and single year
-    >>> prSub = utils.subset_gridpoint(ds.pr, lon=-75,lat=45,start_yr=1990,end_yr=1990)
-     Subset multiple variables in a single dataset
-    >>> ds = xr.open_mfdataset(['pr.day.nc','tas.day.nc'])
-    >>> dsSub = utils.subset_gridpoint(ds, lon=-75,lat=45,start_yr=1990,end_yr=1999)
-    """
-
-    g = Geod(ellps='WGS84')  # WGS84 ellipsoid - decent globaly
-    # adjust for files with all postive longitudes if necessary
-    if np.all(da.lon > 0) and lon < 0:
-        lon += 360
-
-    if len(da.lon.shape) == 1 & len(da.lat.shape) == 1:
-        # create a 2d grid of lon, lat values
-        lon1, lat1 = np.meshgrid(np.asarray(da.lon.values), np.asarray(da.lat.values))
-
-    else:
-        lon1 = da.lon.values
-        lat1 = da.lat.values
-    shp_orig = lon1.shape
-    lon1 = np.reshape(lon1, lon1.size)
-    lat1 = np.reshape(lat1, lat1.size)
-    # calculate geodesic distance between grid points and point of interest
-    az12, az21, dist = g.inv(lon1, lat1, np.broadcast_to(lon, lon1.shape), np.broadcast_to(lat, lat1.shape))
-    dist = dist.reshape(shp_orig)
-
-    iy, ix = np.unravel_index(np.argmin(dist, axis=None), dist.shape)
-    xydims = [x for x in da.dims if 'time' not in x]
-    args = dict()
-    args[xydims[0]] = iy
-    args[xydims[1]] = ix
-    out = da.isel(**args)
-    if start_yr or end_yr:
-        if not start_yr:
-            start_yr = da.time.dt.year.min()
-        if not end_yr:
-            end_yr = da.time.dt.year.max()
-
-        if start_yr > end_yr:
-            raise ValueError("Start date is after end date.")
-
-        year_bnds = np.asarray([start_yr, end_yr])
-
-        if len(year_bnds) == 1:
-            time_cond = da.time.dt.year == year_bnds
-        else:
-            time_cond = (da.time.dt.year >= year_bnds.min()) & (da.time.dt.year <= year_bnds.max())
-        out = out.where(time_cond, drop=True)
-
-    return out
-
-
 def get_daily_events(da, da_value, operator):
     r"""
     function that returns a 0/1 mask when a condition is True or False


Test patch:
diff --git a/tests/test_checks.py b/tests/test_checks.py
index 338cfff0..a0be5edb 100644
--- a/tests/test_checks.py
+++ b/tests/test_checks.py
@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 import pytest
 import xarray as xr
-from xclim.temperature import tg_mean
+from xclim.atmos import tg_mean
 from xclim.testing.common import tas_series, tasmin_series
 from xclim import checks
 
diff --git a/tests/test_generic.py b/tests/test_generic.py
index 81473725..d3591d64 100644
--- a/tests/test_generic.py
+++ b/tests/test_generic.py
@@ -1,8 +1,9 @@
-from xclim import generic
 import numpy as np
 import xarray as xr
 from scipy.stats import lognorm
 
+from xclim import generic
+
 
 class TestFA(object):
 
@@ -37,7 +38,7 @@ class TestFA(object):
         q = generic.fa(self.da, T, 'lognorm')
 
         p0 = lognorm.fit(self.da.values[:, 0, 0])
-        q0 = lognorm.ppf(1-1./T, *p0)
+        q0 = lognorm.ppf(1 - 1. / T, *p0)
         np.testing.assert_array_equal(q[0, 0, 0], q0)
 
 
diff --git a/tests/test_indices.py b/tests/test_indices.py
index af10f315..5ae63faf 100644
--- a/tests/test_indices.py
+++ b/tests/test_indices.py
@@ -50,7 +50,7 @@ class TestBaseFlowIndex:
         a[10:17] = 1
         q = q_series(a)
         out = xci.base_flow_index(q)
-        np.testing.assert_array_equal(out, 1./a.mean())
+        np.testing.assert_array_equal(out, 1. / a.mean())
 
 
 class TestMaxNDayPrecipitationAmount:
diff --git a/tests/test_precip.py b/tests/test_precip.py
index 975eeb32..3e091e5a 100644
--- a/tests/test_precip.py
+++ b/tests/test_precip.py
@@ -1,11 +1,11 @@
-from xclim import precip
-import xarray as xr
-import numpy as np
 import os
-import pandas as pd
+import sys
 
+import numpy as np
+import pandas as pd
 import pytest
-import sys
+import xarray as xr
+import xclim.atmos as atmos
 
 TESTS_HOME = os.path.abspath(os.path.dirname(__file__))
 TESTS_DATA = os.path.join(TESTS_HOME, 'testdata')
@@ -34,22 +34,22 @@ class TestRainOnFrozenGround():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
 
-        out1 = precip.rain_on_frozen_ground_days(pr, tas, freq='MS')
-        out2 = precip.rain_on_frozen_ground_days(prMM, tas, freq='MS')
-        out3 = precip.rain_on_frozen_ground_days(prMM, tasC, freq='MS')
-        out4 = precip.rain_on_frozen_ground_days(pr, tasC, freq='MS')
+        out1 = atmos.rain_on_frozen_ground_days(pr, tas, freq='MS')
+        out2 = atmos.rain_on_frozen_ground_days(prMM, tas, freq='MS')
+        out3 = atmos.rain_on_frozen_ground_days(prMM, tasC, freq='MS')
+        out4 = atmos.rain_on_frozen_ground_days(pr, tasC, freq='MS')
         pr.attrs['units'] = 'kg m-2 s-1'
-        out5 = precip.rain_on_frozen_ground_days(pr, tas, freq='MS')
-        out6 = precip.rain_on_frozen_ground_days(pr, tasC, freq='MS')
+        out5 = atmos.rain_on_frozen_ground_days(pr, tas, freq='MS')
+        out6 = atmos.rain_on_frozen_ground_days(pr, tasC, freq='MS')
         np.testing.assert_array_equal(out1, out2)
         np.testing.assert_array_equal(out1, out3)
         np.testing.assert_array_equal(out1, out4)
         np.testing.assert_array_equal(out1, out5)
         np.testing.assert_array_equal(out1, out6)
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
 
         # synthetic data
         tas1 = tas[0:31, 47, 8] * 0 + K2C - 1
@@ -59,7 +59,7 @@ class TestRainOnFrozenGround():
         tas1[10] += 5
         tas1[20] += 5
 
-        rfrz = precip.rain_on_frozen_ground_days(pr1, tas1, freq='MS')
+        rfrz = atmos.rain_on_frozen_ground_days(pr1, tas1, freq='MS')
 
         np.testing.assert_array_equal(rfrz, 2)
 
@@ -78,12 +78,12 @@ class TestPrecipAccumulation():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
 
-        out1 = precip.precip_accumulation(pr, freq='MS')
-        out2 = precip.precip_accumulation(prMM, freq='MS')
+        out1 = atmos.precip_accumulation(pr, freq='MS')
+        out2 = atmos.precip_accumulation(prMM, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.precip_accumulation(pr, freq='MS')
+        out3 = atmos.precip_accumulation(pr, freq='MS')
 
         np.testing.assert_array_almost_equal(out1, out2, 3)
         np.testing.assert_array_almost_equal(out1, out3)
@@ -95,9 +95,9 @@ class TestPrecipAccumulation():
 
         np.testing.assert_almost_equal(prTot, out1.values[0, 0, 0], 4)
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
 
 
 class TestWetDays():
@@ -114,12 +114,12 @@ class TestWetDays():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
         pr_min = '5 mm/d'
-        out1 = precip.wetdays(pr, thresh=pr_min, freq='MS')
-        out2 = precip.wetdays(prMM, thresh=pr_min, freq='MS')
+        out1 = atmos.wetdays(pr, thresh=pr_min, freq='MS')
+        out2 = atmos.wetdays(prMM, thresh=pr_min, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.wetdays(pr, thresh=pr_min, freq='MS')
+        out3 = atmos.wetdays(pr, thresh=pr_min, freq='MS')
 
         np.testing.assert_array_equal(out1, out2)
         np.testing.assert_array_equal(out1, out3)
@@ -129,12 +129,12 @@ class TestWetDays():
 
         wd1 = (x1 >= int(pr_min.split(' ')[0])).sum()
 
-        assert (wd1 == out1.values[0, 0, 0])
+        assert wd1 == out1.values[0, 0, 0]
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
         # make sure that vector with all nans gives nans whatever skipna
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
         # assert (np.isnan(wds.values[0, -1, -1]))
 
 
@@ -157,12 +157,12 @@ class TestDailyIntensity():
         pr_min = '2 mm/d'
         # dis = daily_pr_intensity(pr, pr_min=pr_min, freq='MS', skipna=True)
 
-        out1 = precip.daily_pr_intensity(pr, thresh=pr_min, freq='MS')
-        out2 = precip.daily_pr_intensity(prMM, thresh=pr_min, freq='MS')
+        out1 = atmos.daily_pr_intensity(pr, thresh=pr_min, freq='MS')
+        out2 = atmos.daily_pr_intensity(prMM, thresh=pr_min, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.daily_pr_intensity(pr, thresh=pr_min, freq='MS')
+        out3 = atmos.daily_pr_intensity(pr, thresh=pr_min, freq='MS')
 
         np.testing.assert_array_almost_equal(out1, out2, 3)
         np.testing.assert_array_almost_equal(out1, out3, 3)
@@ -173,11 +173,11 @@ class TestDailyIntensity():
         # buffer = np.ma.masked_invalid(x2)
         # di2 = buffer[buffer >= pr_min].mean()
 
-        assert (np.allclose(di1, out1.values[0, 0, 0]))
+        assert np.allclose(di1, out1.values[0, 0, 0])
         # assert (np.allclose(di1, dis.values[0, 0, 0]))
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
         # assert (np.allclose(di2, dis.values[0, 1, 0]))
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
         # assert (np.isnan(dis.values[0, -1, -1]))
 
 
@@ -196,12 +196,12 @@ class TestMax1Day():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
 
-        out1 = precip.max_1day_precipitation_amount(pr, freq='MS')
-        out2 = precip.max_1day_precipitation_amount(prMM, freq='MS')
+        out1 = atmos.max_1day_precipitation_amount(pr, freq='MS')
+        out2 = atmos.max_1day_precipitation_amount(prMM, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.max_1day_precipitation_amount(pr, freq='MS')
+        out3 = atmos.max_1day_precipitation_amount(pr, freq='MS')
 
         np.testing.assert_array_almost_equal(out1, out2, 3)
         np.testing.assert_array_almost_equal(out1, out3, 3)
@@ -209,11 +209,11 @@ class TestMax1Day():
         x1 = prMM[:31, 0, 0].values
         rx1 = x1.max()
 
-        assert (np.allclose(rx1, out1.values[0, 0, 0]))
+        assert np.allclose(rx1, out1.values[0, 0, 0])
         # assert (np.allclose(di1, dis.values[0, 0, 0]))
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
         # assert (np.allclose(di2, dis.values[0, 1, 0]))
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
         # assert (np.isnan(dis.values[0, -1, -1]))
 
 
@@ -232,12 +232,12 @@ class TestMaxNDay():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
         wind = 3
-        out1 = precip.max_n_day_precipitation_amount(pr, window=wind, freq='MS')
-        out2 = precip.max_n_day_precipitation_amount(prMM, window=wind, freq='MS')
+        out1 = atmos.max_n_day_precipitation_amount(pr, window=wind, freq='MS')
+        out2 = atmos.max_n_day_precipitation_amount(prMM, window=wind, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.max_n_day_precipitation_amount(pr, window=wind, freq='MS')
+        out3 = atmos.max_n_day_precipitation_amount(pr, window=wind, freq='MS')
 
         np.testing.assert_array_almost_equal(out1, out2, 3)
         np.testing.assert_array_almost_equal(out1, out3, 3)
@@ -246,11 +246,11 @@ class TestMaxNDay():
         df = pd.DataFrame({'pr': x1})
         rx3 = df.rolling(wind).sum().max()
 
-        assert (np.allclose(rx3, out1.values[0, 0, 0]))
+        assert np.allclose(rx3, out1.values[0, 0, 0])
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
 
 
 @pytest.mark.skipif(sys.version_info < (3, 5), reason="too slow to evaluate on python2.7")
@@ -268,12 +268,12 @@ class TestMaxConsecWetDays():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
         pr_min = '5 mm/d'
-        out1 = precip.maximum_consecutive_wet_days(pr, thresh=pr_min, freq='MS')
-        out2 = precip.maximum_consecutive_wet_days(prMM, thresh=pr_min, freq='MS')
+        out1 = atmos.maximum_consecutive_wet_days(pr, thresh=pr_min, freq='MS')
+        out2 = atmos.maximum_consecutive_wet_days(prMM, thresh=pr_min, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.maximum_consecutive_wet_days(pr, thresh=pr_min, freq='MS')
+        out3 = atmos.maximum_consecutive_wet_days(pr, thresh=pr_min, freq='MS')
 
         np.testing.assert_array_equal(out1, out2)
         np.testing.assert_array_equal(out1, out3)
@@ -282,14 +282,14 @@ class TestMaxConsecWetDays():
         x1 = prMM[:31, 0, 0] * 0.
         x1[5:10] = 10
         x1.attrs['units'] = 'mm/day'
-        cwd1 = precip.maximum_consecutive_wet_days(x1, freq='MS')
+        cwd1 = atmos.maximum_consecutive_wet_days(x1, freq='MS')
 
-        assert (cwd1 == 5)
+        assert cwd1 == 5
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
         # make sure that vector with all nans gives nans whatever skipna
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
         # assert (np.isnan(wds.values[0, -1, -1]))
 
 
@@ -308,12 +308,12 @@ class TestMaxConsecDryDays():
         prMM.values[10, 1, 0] = np.nan
         pr.values[10, 1, 0] = np.nan
         pr_min = '5 mm/d'
-        out1 = precip.maximum_consecutive_dry_days(pr, thresh=pr_min, freq='MS')
-        out2 = precip.maximum_consecutive_dry_days(prMM, thresh=pr_min, freq='MS')
+        out1 = atmos.maximum_consecutive_dry_days(pr, thresh=pr_min, freq='MS')
+        out2 = atmos.maximum_consecutive_dry_days(prMM, thresh=pr_min, freq='MS')
 
         # test kg m-2 s-1
         pr.attrs['units'] = 'kg m-2 s-1'
-        out3 = precip.maximum_consecutive_dry_days(pr, thresh=pr_min, freq='MS')
+        out3 = atmos.maximum_consecutive_dry_days(pr, thresh=pr_min, freq='MS')
 
         np.testing.assert_array_equal(out1, out2)
         np.testing.assert_array_equal(out1, out3)
@@ -322,12 +322,12 @@ class TestMaxConsecDryDays():
         x1 = prMM[:31, 0, 0] * 0. + 50.0
         x1[5:10] = 0
         x1.attrs['units'] = 'mm/day'
-        cdd1 = precip.maximum_consecutive_dry_days(x1, freq='MS')
+        cdd1 = atmos.maximum_consecutive_dry_days(x1, freq='MS')
 
-        assert (cdd1 == 5)
+        assert cdd1 == 5
 
-        assert (np.isnan(out1.values[0, 1, 0]))
+        assert np.isnan(out1.values[0, 1, 0])
 
         # make sure that vector with all nans gives nans whatever skipna
-        assert (np.isnan(out1.values[0, -1, -1]))
+        assert np.isnan(out1.values[0, -1, -1])
         # assert (np.isnan(wds.values[0, -1, -1]))
diff --git a/tests/test_temperature.py b/tests/test_temperature.py
index ea7a251c..e57ccf72 100644
--- a/tests/test_temperature.py
+++ b/tests/test_temperature.py
@@ -3,7 +3,7 @@ import os
 import numpy as np
 import xarray as xr
 
-import xclim.temperature as temp
+import xclim.atmos as atmos
 from xclim.testing.common import tas_series, tasmin_series, tasmax_series
 from xclim.utils import percentile_doy
 
@@ -27,7 +27,7 @@ class TestCSDI:
         tn = tasmin_series(tn)
         tn10 = percentile_doy(tn, per=.1)
 
-        out = temp.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
+        out = atmos.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
         assert out[0] == 10
 
     def test_convert_units(self, tasmin_series):
@@ -39,7 +39,7 @@ class TestCSDI:
         tn.attrs['units'] = 'C'
         tn10 = percentile_doy(tn, per=.1)
 
-        out = temp.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
+        out = atmos.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
         assert out[0] == 10
 
     def test_nan_presence(self, tasmin_series):
@@ -51,7 +51,7 @@ class TestCSDI:
         tn = tasmin_series(tn)
         tn10 = percentile_doy(tn, per=.1)
 
-        out = temp.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
+        out = atmos.cold_spell_duration_index(tn, tn10, freq='AS-JUL')
         assert np.isnan(out[0])
 
 
@@ -71,8 +71,8 @@ class TestDTR:
         # put a nan somewhere
         tasmin.values[32, 1, 0] = np.nan
         tasmin_C.values[32, 1, 0] = np.nan
-        dtr = temp.daily_temperature_range(tasmax, tasmin, freq='MS')
-        dtrC = temp.daily_temperature_range(tasmax_C, tasmin_C, freq='MS')
+        dtr = atmos.daily_temperature_range(tasmax, tasmin, freq='MS')
+        dtrC = atmos.daily_temperature_range(tasmax_C, tasmin_C, freq='MS')
         min1 = tasmin.values[:, 0, 0]
         max1 = tasmax.values[:, 0, 0]
 
@@ -103,8 +103,8 @@ class TestDTRVar:
         # put a nan somewhere
         tasmin.values[32, 1, 0] = np.nan
         tasmin_C.values[32, 1, 0] = np.nan
-        dtr = temp.daily_temperature_range_variability(tasmax, tasmin, freq='MS')
-        dtrC = temp.daily_temperature_range_variability(tasmax_C, tasmin_C, freq='MS')
+        dtr = atmos.daily_temperature_range_variability(tasmax, tasmin, freq='MS')
+        dtrC = atmos.daily_temperature_range_variability(tasmax_C, tasmin_C, freq='MS')
         min1 = tasmin.values[:, 0, 0]
         max1 = tasmax.values[:, 0, 0]
 
@@ -137,8 +137,8 @@ class TestETR:
         tasmin.values[32, 1, 0] = np.nan
         tasmin_C.values[32, 1, 0] = np.nan
 
-        etr = temp.extreme_temperature_range(tasmax, tasmin, freq='MS')
-        etrC = temp.extreme_temperature_range(tasmax_C, tasmin_C, freq='MS')
+        etr = atmos.extreme_temperature_range(tasmax, tasmin, freq='MS')
+        etrC = atmos.extreme_temperature_range(tasmax_C, tasmin_C, freq='MS')
         min1 = tasmin.values[:, 0, 0]
         max1 = tasmax.values[:, 0, 0]
 
@@ -163,8 +163,8 @@ class TestTmean:
         # put a nan somewhere
         tas.values[180, 1, 0] = np.nan
         tas_C.values[180, 1, 0] = np.nan
-        tmmean = temp.tg_mean(tas)
-        tmmeanC = temp.tg_mean(tas_C)
+        tmmean = atmos.tg_mean(tas)
+        tmmeanC = atmos.tg_mean(tas_C)
         x1 = tas.values[:, 0, 0]
         tmmean1 = x1.mean()
 
@@ -190,13 +190,13 @@ class TestTx:
         # put a nan somewhere
         tasmax.values[180, 1, 0] = np.nan
         tasmax_C.values[180, 1, 0] = np.nan
-        txmean = temp.tx_mean(tasmax)
-        txmax = temp.tx_max(tasmax)
-        txmin = temp.tx_min(tasmax)
+        txmean = atmos.tx_mean(tasmax)
+        txmax = atmos.tx_max(tasmax)
+        txmin = atmos.tx_min(tasmax)
 
-        txmeanC = temp.tx_mean(tasmax_C)
-        txmaxC = temp.tx_max(tasmax_C)
-        txminC = temp.tx_min(tasmax_C)
+        txmeanC = atmos.tx_mean(tasmax_C)
+        txmaxC = atmos.tx_max(tasmax_C)
+        txminC = atmos.tx_min(tasmax_C)
 
         no_nan = ~np.isnan(txmean).values & ~np.isnan(txmax).values & ~np.isnan(txmin).values
 
@@ -237,13 +237,13 @@ class TestTn:
         # put a nan somewhere
         tasmin.values[180, 1, 0] = np.nan
         tasmin_C.values[180, 1, 0] = np.nan
-        tnmean = temp.tn_mean(tasmin)
-        tnmax = temp.tn_max(tasmin)
-        tnmin = temp.tn_min(tasmin)
+        tnmean = atmos.tn_mean(tasmin)
+        tnmax = atmos.tn_max(tasmin)
+        tnmin = atmos.tn_min(tasmin)
 
-        tnmeanC = temp.tn_mean(tasmin_C)
-        tnmaxC = temp.tn_max(tasmin_C)
-        tnminC = temp.tn_min(tasmin_C)
+        tnmeanC = atmos.tn_mean(tasmin_C)
+        tnmaxC = atmos.tn_max(tasmin_C)
+        tnminC = atmos.tn_min(tasmin_C)
 
         no_nan = ~np.isnan(tnmean).values & ~np.isnan(tnmax).values & ~np.isnan(tnmin).values
 
@@ -281,7 +281,7 @@ class TestConsecutiveFrostDays:
         a[2] -= 20
 
         ts = tasmin_series(a)
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [1])
 
     def test_three_freeze_day(self, tasmin_series):
@@ -289,7 +289,7 @@ class TestConsecutiveFrostDays:
         a[2:5] -= 20
 
         ts = tasmin_series(a)
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [3])
 
     def test_two_equal_freeze_day(self, tasmin_series):
@@ -297,7 +297,7 @@ class TestConsecutiveFrostDays:
         a[2:5] -= 20
         a[6:9] -= 20
         ts = tasmin_series(a)
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [3])
 
     def test_two_events_freeze_day(self, tasmin_series):
@@ -305,7 +305,7 @@ class TestConsecutiveFrostDays:
         a[2:5] -= 20
         a[6:10] -= 20
         ts = tasmin_series(a)
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [4])
 
     def test_convert_units_freeze_day(self, tasmin_series):
@@ -314,7 +314,7 @@ class TestConsecutiveFrostDays:
         a[6:10] -= 20
         ts = tasmin_series(a)
         ts.attrs['units'] = 'C'
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [4])
 
     def test_one_nan_day(self, tasmin_series):
@@ -323,7 +323,7 @@ class TestConsecutiveFrostDays:
         a[-1] = np.nan
 
         ts = tasmin_series(a)
-        out = temp.consecutive_frost_days(ts)
+        out = atmos.consecutive_frost_days(ts)
         np.testing.assert_array_equal(out, [np.nan])
 
 
@@ -335,7 +335,7 @@ class TestColdSpellDays:
         a[40:43] -= 50  # too short -> 0
         a[80:100] -= 30  # at the end and beginning
         ts = tas_series(a)
-        out = temp.cold_spell_days(ts, thresh='-10 C', freq='MS')
+        out = atmos.cold_spell_days(ts, thresh='-10 C', freq='MS')
         np.testing.assert_array_equal(out, [10, 0, 12, 8, 0, 0, 0, 0, 0, 0, 0, 0])
 
     def test_convert_units(self, tas_series):
@@ -345,7 +345,7 @@ class TestColdSpellDays:
         a[80:100] -= 30  # at the end and beginning
         ts = tas_series(a)
         ts.attrs['units'] = 'C'
-        out = temp.cold_spell_days(ts, thresh='-10 C', freq='MS')
+        out = atmos.cold_spell_days(ts, thresh='-10 C', freq='MS')
         np.testing.assert_array_equal(out, [10, 0, 12, 8, 0, 0, 0, 0, 0, 0, 0, 0])
 
     def test_nan_presence(self, tas_series):
@@ -356,7 +356,7 @@ class TestColdSpellDays:
         a[-1] = np.nan
         ts = tas_series(a)
 
-        out = temp.cold_spell_days(ts, thresh='-10 C', freq='MS')
+        out = atmos.cold_spell_days(ts, thresh='-10 C', freq='MS')
         np.testing.assert_array_equal(out, [10, 0, 12, 8, 0, 0, 0, 0, 0, 0, 0, np.nan])
 
 
@@ -374,8 +374,8 @@ class TestFrostDays:
         tasminC.values[180, 1, 0] = np.nan
         # compute with both skipna options
         thresh = 273.16
-        fd = temp.frost_days(tasmin, freq='YS')
-        fdC = temp.frost_days(tasminC, freq='YS')
+        fd = atmos.frost_days(tasmin, freq='YS')
+        fdC = atmos.frost_days(tasminC, freq='YS')
         # fds = xci.frost_days(tasmin, thresh=thresh, freq='YS', skipna=True)
 
         x1 = tasmin.values[:, 0, 0]
@@ -406,8 +406,8 @@ class TestIceDays:
         tasC.values[180, 1, 0] = np.nan
         # compute with both skipna options
         thresh = 273.16
-        fd = temp.ice_days(tas, freq='YS')
-        fdC = temp.ice_days(tasC, freq='YS')
+        fd = atmos.ice_days(tas, freq='YS')
+        fdC = atmos.ice_days(tasC, freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -433,7 +433,7 @@ class TestCoolingDegreeDays:
 
         # compute with both skipna options
         thresh = 18 + K2C
-        cdd = temp.cooling_degree_days(tas, thresh='18 C', freq='YS')
+        cdd = atmos.cooling_degree_days(tas, thresh='18 C', freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -455,7 +455,7 @@ class TestCoolingDegreeDays:
 
         # compute with both skipna options
         thresh = 18
-        cdd = temp.cooling_degree_days(tas, thresh='18 C', freq='YS')
+        cdd = atmos.cooling_degree_days(tas, thresh='18 C', freq='YS')
 
         x1 = tas.values[:, 0, 0]
         # x2 = tas.values[:, 1, 0]
@@ -482,7 +482,7 @@ class TestHeatingDegreeDays:
 
         # compute with both skipna options
         thresh = 17 + K2C
-        hdd = temp.heating_degree_days(tas, freq='YS')
+        hdd = atmos.heating_degree_days(tas, freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -503,7 +503,7 @@ class TestHeatingDegreeDays:
         tas.attrs['units'] = 'C'
         # compute with both skipna options
         thresh = 17
-        hdd = temp.heating_degree_days(tas, freq='YS')
+        hdd = atmos.heating_degree_days(tas, freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -527,7 +527,7 @@ class TestGrowingDegreeDays:
 
         # compute with both skipna options
         thresh = K2C + 4
-        gdd = temp.growing_degree_days(tas, freq='YS')
+        gdd = atmos.growing_degree_days(tas, freq='YS')
         # gdds = xci.growing_degree_days(tas, thresh=thresh, freq='YS', skipna=True)
 
         x1 = tas.values[:, 0, 0]
@@ -557,24 +557,24 @@ class TestHeatWaveFrequency:
         txC = tasmax_series(tx1, start='1/1/2000')
         txC.attrs['units'] = 'C'
 
-        hwf = temp.heat_wave_frequency(tn, tx, thresh_tasmin='22 C',
-                                       thresh_tasmax='30 C')
-        hwfC = temp.heat_wave_frequency(tnC, txC, thresh_tasmin='22 C',
+        hwf = atmos.heat_wave_frequency(tn, tx, thresh_tasmin='22 C',
                                         thresh_tasmax='30 C')
+        hwfC = atmos.heat_wave_frequency(tnC, txC, thresh_tasmin='22 C',
+                                         thresh_tasmax='30 C')
         np.testing.assert_array_equal(hwf, hwfC)
         np.testing.assert_allclose(hwf.values[:1], 2)
 
-        hwf = temp.heat_wave_frequency(tn, tx, thresh_tasmin='22 C',
-                                       thresh_tasmax='30 C', window=4)
+        hwf = atmos.heat_wave_frequency(tn, tx, thresh_tasmin='22 C',
+                                        thresh_tasmax='30 C', window=4)
         np.testing.assert_allclose(hwf.values[:1], 1)
 
         # one long hw
-        hwf = temp.heat_wave_frequency(tn, tx, thresh_tasmin='10 C',
-                                       thresh_tasmax='10 C')
+        hwf = atmos.heat_wave_frequency(tn, tx, thresh_tasmin='10 C',
+                                        thresh_tasmax='10 C')
         np.testing.assert_allclose(hwf.values[:1], 1)
         # no hw
-        hwf = temp.heat_wave_frequency(tn, tx, thresh_tasmin='40 C',
-                                       thresh_tasmax='40 C')
+        hwf = atmos.heat_wave_frequency(tn, tx, thresh_tasmin='40 C',
+                                        thresh_tasmax='40 C')
         np.testing.assert_allclose(hwf.values[:1], 0)
 
 
@@ -592,24 +592,24 @@ class TestHeatWaveMaxLength:
         txC = tasmax_series(tx1, start='1/1/2000')
         txC.attrs['units'] = 'C'
 
-        hwf = temp.heat_wave_max_length(tn, tx, thresh_tasmin='22 C',
-                                        thresh_tasmax='30 C')
-        hwfC = temp.heat_wave_max_length(tnC, txC, thresh_tasmin='22 C',
+        hwf = atmos.heat_wave_max_length(tn, tx, thresh_tasmin='22 C',
                                          thresh_tasmax='30 C')
+        hwfC = atmos.heat_wave_max_length(tnC, txC, thresh_tasmin='22 C',
+                                          thresh_tasmax='30 C')
         np.testing.assert_array_equal(hwf, hwfC)
         np.testing.assert_allclose(hwf.values[:1], 4)
 
-        hwf = temp.heat_wave_max_length(tn, tx, thresh_tasmin='20 C',
-                                        thresh_tasmax='30 C', window=4)
+        hwf = atmos.heat_wave_max_length(tn, tx, thresh_tasmin='20 C',
+                                         thresh_tasmax='30 C', window=4)
         np.testing.assert_allclose(hwf.values[:1], 5)
 
         # one long hw
-        hwf = temp.heat_wave_max_length(tn, tx, thresh_tasmin='10 C',
-                                        thresh_tasmax='10 C')
+        hwf = atmos.heat_wave_max_length(tn, tx, thresh_tasmin='10 C',
+                                         thresh_tasmax='10 C')
         np.testing.assert_allclose(hwf.values[:1], 10)
         # no hw
-        hwf = temp.heat_wave_max_length(tn, tx, thresh_tasmin='40 C',
-                                        thresh_tasmax='40 C')
+        hwf = atmos.heat_wave_max_length(tn, tx, thresh_tasmin='40 C',
+                                         thresh_tasmax='40 C')
         np.testing.assert_allclose(hwf.values[:1], 0)
 
 
@@ -619,7 +619,7 @@ class TestHeatWaveIndex:
         tx = np.zeros(366)
         tx[:10] = np.array([29, 31, 31, 31, 29, 31, 31, 31, 31, 31])
         tx = tasmax_series(tx + K2C, start='1/1/2000')
-        hwi = temp.heat_wave_index(tx, freq='YS')
+        hwi = atmos.heat_wave_index(tx, freq='YS')
         np.testing.assert_array_equal(hwi, [10])
 
     def test_convert_units(self, tasmax_series):
@@ -627,7 +627,7 @@ class TestHeatWaveIndex:
         tx[:10] = np.array([29, 31, 31, 31, 29, 31, 31, 31, 31, 31])
         tx = tasmax_series(tx, start='1/1/2000')
         tx.attrs['units'] = 'C'
-        hwi = temp.heat_wave_index(tx, freq='YS')
+        hwi = atmos.heat_wave_index(tx, freq='YS')
         np.testing.assert_array_equal(hwi, [10])
 
     def test_nan_presence(self, tasmax_series):
@@ -636,7 +636,7 @@ class TestHeatWaveIndex:
         tx[-1] = np.nan
         tx = tasmax_series(tx + K2C, start='1/1/2000')
 
-        hwi = temp.heat_wave_index(tx, freq='YS')
+        hwi = atmos.heat_wave_index(tx, freq='YS')
         np.testing.assert_array_equal(hwi, [np.nan])
 
 
@@ -651,7 +651,7 @@ class TestDailyFreezeThaw:
         # put a nan somewhere
         tasmin.values[180, 1, 0] = np.nan
 
-        frzthw = temp.daily_freezethaw_cycles(tasmax, tasmin, freq='YS')
+        frzthw = atmos.daily_freezethaw_cycles(tasmax, tasmin, freq='YS')
 
         min1 = tasmin.values[:, 0, 0]
         max1 = tasmax.values[:, 0, 0]
@@ -674,7 +674,7 @@ class TestDailyFreezeThaw:
         # put a nan somewhere
         tasmin.values[180, 1, 0] = np.nan
 
-        frzthw = temp.daily_freezethaw_cycles(tasmax, tasmin, freq='YS')
+        frzthw = atmos.daily_freezethaw_cycles(tasmax, tasmin, freq='YS')
 
         min1 = tasmin.values[:, 0, 0]
         max1 = tasmax.values[:, 0, 0]
@@ -696,7 +696,7 @@ class TestGrowingSeasonLength:
         offset = np.random.uniform(low=5.5, high=23, size=(tt.sum().values,))
         ts[tt] = ts[tt] + offset
 
-        out = temp.growing_season_length(ts)
+        out = atmos.growing_season_length(ts)
 
         np.testing.assert_array_equal(out, tt.sum())
 
@@ -709,7 +709,7 @@ class TestGrowingSeasonLength:
         offset = np.random.uniform(low=5.5, high=23, size=(tt.sum().values,))
         ts[tt] = ts[tt] + offset
 
-        out = temp.growing_season_length(ts)
+        out = atmos.growing_season_length(ts)
 
         np.testing.assert_array_equal(out, tt.sum())
 
@@ -723,7 +723,7 @@ class TestGrowingSeasonLength:
         offset = np.random.uniform(low=5.5, high=23, size=(tt.sum().values,))
         ts[tt] = ts[tt] + offset
 
-        out = temp.growing_season_length(ts)
+        out = atmos.growing_season_length(ts)
 
         np.testing.assert_array_equal(out, [np.nan])
 
@@ -737,7 +737,7 @@ class TestGrowingSeasonLength:
         offset = np.random.uniform(low=5.5, high=23, size=(tt.sum().values,))
         ts[tt] = ts[tt] + offset
 
-        out = temp.growing_season_length(ts)
+        out = atmos.growing_season_length(ts)
 
         np.testing.assert_array_equal(out[3], tt[0:366].sum().values)
 
@@ -756,8 +756,8 @@ class TestTnDaysBelow:
         tasC.values[180, 1, 0] = np.nan
         # compute with both skipna options
         thresh = 273.16 + -10
-        fd = temp.tn_days_below(tas, freq='YS')
-        fdC = temp.tn_days_below(tasC, freq='YS')
+        fd = atmos.tn_days_below(tas, freq='YS')
+        fdC = atmos.tn_days_below(tasC, freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -786,8 +786,8 @@ class TestTxDaysAbove:
         tasC.values[180, 1, 0] = np.nan
         # compute with both skipna options
         thresh = 273.16 + 25
-        fd = temp.tx_days_above(tas, freq='YS')
-        fdC = temp.tx_days_above(tasC, freq='YS')
+        fd = atmos.tx_days_above(tas, freq='YS')
+        fdC = atmos.tx_days_above(tasC, freq='YS')
 
         x1 = tas.values[:, 0, 0]
 
@@ -816,8 +816,8 @@ class TestTropicalNights:
         tasC.values[180, 1, 0] = np.nan
         # compute with both skipna options
         thresh = 273.16 + 20
-        out = temp.tropical_nights(tas, freq='YS')
-        outC = temp.tropical_nights(tasC, freq='YS')
+        out = atmos.tropical_nights(tas, freq='YS')
+        outC = atmos.tropical_nights(tasC, freq='YS')
         # fds = xci.frost_days(tasmin, thresh=thresh, freq='YS', skipna=True)
 
         x1 = tas.values[:, 0, 0]
@@ -852,8 +852,8 @@ class TestTxTnDaysAbove:
         tasmin.values[180, 1, 0] = np.nan
         tasminC.values[180, 1, 0] = np.nan
 
-        out = temp.tx_tn_days_above(tasmin, tasmax, thresh_tasmax='25 C', thresh_tasmin='18 C')
-        outC = temp.tx_tn_days_above(tasminC, tasmaxC, thresh_tasmax='25 C', thresh_tasmin='18 C')
+        out = atmos.tx_tn_days_above(tasmin, tasmax, thresh_tasmax='25 C', thresh_tasmin='18 C')
+        outC = atmos.tx_tn_days_above(tasminC, tasmaxC, thresh_tasmax='25 C', thresh_tasmin='18 C')
         np.testing.assert_array_equal(out, outC, )
 
         min1 = tasmin.values[:, 53, 76]
@@ -882,8 +882,8 @@ class TestT90p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tg90p(tas, t90, freq='MS')
-        outC = temp.tg90p(tasC, t90, freq='MS')
+        out = atmos.tg90p(tas, t90, freq='MS')
+        outC = atmos.tg90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -893,8 +893,8 @@ class TestT90p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tg90p(tas, t90, freq='MS')
-        outC = temp.tg90p(tasC, t90, freq='MS')
+        out = atmos.tg90p(tas, t90, freq='MS')
+        outC = atmos.tg90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -913,8 +913,8 @@ class TestT90p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tn90p(tas, t90, freq='MS')
-        outC = temp.tn90p(tasC, t90, freq='MS')
+        out = atmos.tn90p(tas, t90, freq='MS')
+        outC = atmos.tn90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -924,8 +924,8 @@ class TestT90p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tn90p(tas, t90, freq='MS')
-        outC = temp.tn90p(tasC, t90, freq='MS')
+        out = atmos.tn90p(tas, t90, freq='MS')
+        outC = atmos.tn90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -944,8 +944,8 @@ class TestT90p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tx90p(tas, t90, freq='MS')
-        outC = temp.tx90p(tasC, t90, freq='MS')
+        out = atmos.tx90p(tas, t90, freq='MS')
+        outC = atmos.tx90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -955,8 +955,8 @@ class TestT90p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tx90p(tas, t90, freq='MS')
-        outC = temp.tx90p(tasC, t90, freq='MS')
+        out = atmos.tx90p(tas, t90, freq='MS')
+        outC = atmos.tx90p(tasC, t90, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 30
@@ -978,8 +978,8 @@ class TestT10p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tg10p(tas, t10, freq='MS')
-        outC = temp.tg10p(tasC, t10, freq='MS')
+        out = atmos.tg10p(tas, t10, freq='MS')
+        outC = atmos.tg10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
 
@@ -989,8 +989,8 @@ class TestT10p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tg10p(tas, t10, freq='MS')
-        outC = temp.tg10p(tasC, t10, freq='MS')
+        out = atmos.tg10p(tas, t10, freq='MS')
+        outC = atmos.tg10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 1
@@ -1009,8 +1009,8 @@ class TestT10p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tn10p(tas, t10, freq='MS')
-        outC = temp.tn10p(tasC, t10, freq='MS')
+        out = atmos.tn10p(tas, t10, freq='MS')
+        outC = atmos.tn10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 1
@@ -1019,8 +1019,8 @@ class TestT10p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tn10p(tas, t10, freq='MS')
-        outC = temp.tn10p(tasC, t10, freq='MS')
+        out = atmos.tn10p(tas, t10, freq='MS')
+        outC = atmos.tn10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 1
@@ -1039,8 +1039,8 @@ class TestT10p:
         # create cold spell in june
         tas[175:180] = 1
         tasC[175:180] = 1 - K2C
-        out = temp.tx10p(tas, t10, freq='MS')
-        outC = temp.tx10p(tasC, t10, freq='MS')
+        out = atmos.tx10p(tas, t10, freq='MS')
+        outC = atmos.tx10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 1
@@ -1049,8 +1049,8 @@ class TestT10p:
         # nan treatment
         tas[33] = np.nan
         tasC[33] = np.nan
-        out = temp.tx10p(tas, t10, freq='MS')
-        outC = temp.tx10p(tasC, t10, freq='MS')
+        out = atmos.tx10p(tas, t10, freq='MS')
+        outC = atmos.tx10p(tasC, t10, freq='MS')
 
         np.testing.assert_array_equal(out, outC)
         assert out[0] == 1
@@ -1059,5 +1059,5 @@ class TestT10p:
 
 
 def test_freshet_start(tas_series):
-    out = temp.freshet_start(tas_series(np.arange(-50, 350)+274, start='1/1/2000'), freq='YS')
+    out = atmos.freshet_start(tas_series(np.arange(-50, 350) + 274, start='1/1/2000'), freq='YS')
     assert out[0] == 51
diff --git a/tests/test_utils.py b/tests/test_utils.py
index a666b9c2..7770470e 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -25,12 +25,16 @@ import pandas as pd
 import pytest
 import xarray as xr
 import dask
+
+
+from xclim import ensembles
+from xclim import indices
+from xclim import subset
 from xclim import utils
 from xclim.utils import daily_downsampler, Indicator, format_kwargs, parse_doc, walk_map
 from xclim.utils import infer_doy_max, adjust_doy_calendar, percentile_doy
 from xclim.utils import units, pint2cfunits, units2pint
 from xclim.testing.common import tas_series, pr_series
-from xclim import indices as ind
 
 TAS_SERIES = tas_series
 PR_SERIES = pr_series
@@ -43,40 +47,40 @@ class TestEnsembleStats:
     nc_files = glob.glob(os.path.join(TESTS_DATA, 'EnsembleStats', '*.nc'))
 
     def test_create_ensemble(self):
-        ens = utils.create_ensemble(self.nc_files_simple)
+        ens = ensembles.create_ensemble(self.nc_files_simple)
         assert len(ens.realization) == len(self.nc_files_simple)
 
     def test_create_unequal_times(self):
-        ens = utils.create_ensemble(self.nc_files)
+        ens = ensembles.create_ensemble(self.nc_files)
         assert len(ens.realization) == len(self.nc_files)
         assert ens.time.dt.year.min() == 1970
         assert ens.time.dt.year.max() == 2050
 
     def test_calc_perc(self):
-        ens = utils.create_ensemble(self.nc_files_simple)
-        out1 = utils.ensemble_percentiles(ens)
+        ens = ensembles.create_ensemble(self.nc_files_simple)
+        out1 = ensembles.ensemble_percentiles(ens)
         np.testing.assert_array_equal(np.percentile(ens['tg_mean'][:, 0, 5, 5], 10), out1['tg_mean_p10'][0, 5, 5])
         np.testing.assert_array_equal(np.percentile(ens['tg_mean'][:, 0, 5, 5], 50), out1['tg_mean_p50'][0, 5, 5])
         np.testing.assert_array_equal(np.percentile(ens['tg_mean'][:, 0, 5, 5], 90), out1['tg_mean_p90'][0, 5, 5])
         assert np.all(out1['tg_mean_p90'] > out1['tg_mean_p50'])
         assert np.all(out1['tg_mean_p50'] > out1['tg_mean_p10'])
-        out1 = utils.ensemble_percentiles(ens, values=(25, 75))
+        out1 = ensembles.ensemble_percentiles(ens, values=(25, 75))
         assert np.all(out1['tg_mean_p75'] > out1['tg_mean_p25'])
 
     def test_calc_perc_blocks(self):
-        ens = utils.create_ensemble(self.nc_files_simple)
-        out1 = utils.ensemble_percentiles(ens)
-        out2 = utils.ensemble_percentiles(ens, values=(10, 50, 90), time_block=10)
+        ens = ensembles.create_ensemble(self.nc_files_simple)
+        out1 = ensembles.ensemble_percentiles(ens)
+        out2 = ensembles.ensemble_percentiles(ens, values=(10, 50, 90), time_block=10)
         np.testing.assert_array_equal(out1['tg_mean_p10'], out2['tg_mean_p10'])
         np.testing.assert_array_equal(out1['tg_mean_p50'], out2['tg_mean_p50'])
         np.testing.assert_array_equal(out1['tg_mean_p90'], out2['tg_mean_p90'])
 
     def test_calc_perc_nans(self):
-        ens = utils.create_ensemble(self.nc_files_simple).load()
+        ens = ensembles.create_ensemble(self.nc_files_simple).load()
 
         ens.tg_mean[2, 0, 5, 5] = np.nan
         ens.tg_mean[2, 7, 5, 5] = np.nan
-        out1 = utils.ensemble_percentiles(ens)
+        out1 = ensembles.ensemble_percentiles(ens)
         np.testing.assert_array_equal(np.percentile(ens['tg_mean'][:, 0, 5, 5], 10), np.nan)
         np.testing.assert_array_equal(np.percentile(ens['tg_mean'][:, 7, 5, 5], 10), np.nan)
         np.testing.assert_array_equal(np.nanpercentile(ens['tg_mean'][:, 0, 5, 5], 10), out1['tg_mean_p10'][0, 5, 5])
@@ -85,8 +89,8 @@ class TestEnsembleStats:
         assert np.all(out1['tg_mean_p50'] > out1['tg_mean_p10'])
 
     def test_calc_mean_std_min_max(self):
-        ens = utils.create_ensemble(self.nc_files_simple)
-        out1 = utils.ensemble_mean_std_max_min(ens)
+        ens = ensembles.create_ensemble(self.nc_files_simple)
+        out1 = ensembles.ensemble_mean_std_max_min(ens)
         np.testing.assert_array_equal(ens['tg_mean'][:, 0, 5, 5].mean(dim='realization'), out1.tg_mean_mean[0, 5, 5])
         np.testing.assert_array_equal(ens['tg_mean'][:, 0, 5, 5].std(dim='realization'), out1.tg_mean_stdev[0, 5, 5])
         np.testing.assert_array_equal(ens['tg_mean'][:, 0, 5, 5].max(dim='realization'), out1.tg_mean_max[0, 5, 5])
@@ -239,7 +243,7 @@ class TestIndicator:
 
         assert issubclass(cls, Indicator)
         da = pr_series(np.arange(365))
-        cls(compute=ind.wetdays)(da)
+        cls(compute=indices.wetdays)(da)
 
     def test_signature(self):
         from inspect2 import signature
@@ -283,7 +287,7 @@ class TestKwargs:
 class TestParseDoc:
 
     def test_simple(self):
-        parse_doc(ind.tg_mean.__doc__)
+        parse_doc(indices.tg_mean.__doc__)
 
 
 class TestPercentileDOY:
@@ -373,9 +377,9 @@ class TestConvertUnitsTo:
 
         with pytest.warns(FutureWarning):
             tas = tas_series(np.arange(365), start='1/1/2001')
-            out = ind.tx_days_above(tas, 30)
-            out1 = ind.tx_days_above(tas, '30 degC')
-            out2 = ind.tx_days_above(tas, '303.15 K')
+            out = indices.tx_days_above(tas, 30)
+            out1 = indices.tx_days_above(tas, '30 degC')
+            out2 = indices.tx_days_above(tas, '303.15 K')
             np.testing.assert_array_equal(out, out1)
             np.testing.assert_array_equal(out, out2)
 
@@ -411,7 +415,7 @@ class TestSubsetGridPoint:
         da = xr.open_mfdataset([self.nc_file, self.nc_file.replace('tasmax', 'tasmin')])
         lon = -72.4
         lat = 46.1
-        out = utils.subset_gridpoint(da, lon=lon, lat=lat)
+        out = subset.subset_gridpoint(da, lon=lon, lat=lat)
         np.testing.assert_almost_equal(out.lon, lon, 1)
         np.testing.assert_almost_equal(out.lat, lat, 1)
         np.testing.assert_array_equal(out.tasmin.shape, out.tasmax.shape)
@@ -420,7 +424,7 @@ class TestSubsetGridPoint:
         da = xr.open_dataset(self.nc_file).tasmax
         lon = -72.4
         lat = 46.1
-        out = utils.subset_gridpoint(da, lon=lon, lat=lat)
+        out = subset.subset_gridpoint(da, lon=lon, lat=lat)
         np.testing.assert_almost_equal(out.lon, lon, 1)
         np.testing.assert_almost_equal(out.lat, lat, 1)
 
@@ -429,7 +433,7 @@ class TestSubsetGridPoint:
         yr_st = 2050
         yr_ed = 2059
 
-        out = utils.subset_gridpoint(da, lon=lon, lat=lat, start_yr=yr_st, end_yr=yr_ed)
+        out = subset.subset_gridpoint(da, lon=lon, lat=lat, start_yr=yr_st, end_yr=yr_ed)
         np.testing.assert_almost_equal(out.lon, lon, 1)
         np.testing.assert_almost_equal(out.lat, lat, 1)
         np.testing.assert_array_equal(len(np.unique(out.time.dt.year)), 10)
@@ -440,7 +444,7 @@ class TestSubsetGridPoint:
         da = xr.open_dataset(self.nc_2dlonlat).tasmax
         lon = -72.4
         lat = 46.1
-        out = utils.subset_gridpoint(da, lon=lon, lat=lat)
+        out = subset.subset_gridpoint(da, lon=lon, lat=lat)
         np.testing.assert_almost_equal(out.lon, lon, 1)
         np.testing.assert_almost_equal(out.lat, lat, 1)
 
@@ -448,14 +452,14 @@ class TestSubsetGridPoint:
         da = xr.open_dataset(self.nc_poslons).tas
         lon = -72.4
         lat = 46.1
-        out = utils.subset_gridpoint(da, lon=lon, lat=lat)
+        out = subset.subset_gridpoint(da, lon=lon, lat=lat)
         np.testing.assert_almost_equal(out.lon, lon + 360, 1)
         np.testing.assert_almost_equal(out.lat, lat, 1)
 
     def test_raise(self):
         da = xr.open_dataset(self.nc_poslons).tas
         with pytest.raises(ValueError):
-            utils.subset_gridpoint(da, lon=-72.4, lat=46.1, start_yr=2056, end_yr=2055)
+            subset.subset_gridpoint(da, lon=-72.4, lat=46.1, start_yr=2056, end_yr=2055)
 
 
 class TestSubsetBbox:
@@ -467,7 +471,7 @@ class TestSubsetBbox:
 
     def test_dataset(self):
         da = xr.open_mfdataset([self.nc_file, self.nc_file.replace('tasmax', 'tasmin')])
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
         assert (np.all(out.lon >= np.min(self.lon)))
         assert (np.all(out.lon <= np.max(self.lon)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -477,7 +481,7 @@ class TestSubsetBbox:
     def test_simple(self):
         da = xr.open_dataset(self.nc_file).tasmax
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
         assert (np.all(out.lon >= np.min(self.lon)))
         assert (np.all(out.lon <= np.max(self.lon)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -488,7 +492,7 @@ class TestSubsetBbox:
         yr_st = 2050
         yr_ed = 2059
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=yr_st, end_yr=yr_ed)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=yr_st, end_yr=yr_ed)
         assert (np.all(out.lon >= np.min(self.lon)))
         assert (np.all(out.lon <= np.max(self.lon)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -496,7 +500,7 @@ class TestSubsetBbox:
         np.testing.assert_array_equal(out.time.dt.year.max(), yr_ed)
         np.testing.assert_array_equal(out.time.dt.year.min(), yr_st)
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=yr_st)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=yr_st)
         assert (np.all(out.lon >= np.min(self.lon)))
         assert (np.all(out.lon <= np.max(self.lon)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -504,7 +508,7 @@ class TestSubsetBbox:
         np.testing.assert_array_equal(out.time.dt.year.max(), da.time.dt.year.max())
         np.testing.assert_array_equal(out.time.dt.year.min(), yr_st)
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, end_yr=yr_ed)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, end_yr=yr_ed)
         assert (np.all(out.lon >= np.min(self.lon)))
         assert (np.all(out.lon <= np.max(self.lon)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -515,7 +519,7 @@ class TestSubsetBbox:
     def test_irregular(self):
         da = xr.open_dataset(self.nc_2dlonlat).tasmax
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
 
         # for irregular lat lon grids data matrix remains rectangular in native proj
         # but with data outside bbox assigned nans.  This means it can have lon and lats outside the bbox.
@@ -530,7 +534,7 @@ class TestSubsetBbox:
     def test_positive_lons(self):
         da = xr.open_dataset(self.nc_poslons).tas
 
-        out = utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
+        out = subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat)
         assert (np.all(out.lon >= np.min(np.asarray(self.lon) + 360)))
         assert (np.all(out.lon <= np.max(np.asarray(self.lon) + 360)))
         assert (np.all(out.lat >= np.min(self.lat)))
@@ -539,7 +543,7 @@ class TestSubsetBbox:
     def test_raise(self):
         da = xr.open_dataset(self.nc_poslons).tas
         with pytest.raises(ValueError):
-            utils.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=2056, end_yr=2055)
+            subset.subset_bbox(da, lon_bnds=self.lon, lat_bnds=self.lat, start_yr=2056, end_yr=2055)
 
 
 class TestThresholdCount: