resample.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# packages in environment at /games/conda/conda3/envs/resample:\n",
      "#\n",
      "backports                 1.0                      py36_1    conda-forge\n",
      "backports.functools_lru_cache 1.5                      py36_0    conda-forge\n",
      "blas                      1.1                    openblas    conda-forge\n",
      "bleach                    2.1.3                      py_0    conda-forge\n",
      "bokeh                     0.12.14                  py36_0    conda-forge\n",
      "bottleneck                1.2.1                    py36_1    conda-forge\n",
      "ca-certificates           2018.1.18                     0    conda-forge\n",
      "cachetools                2.0.1                      py_0    conda-forge\n",
      "certifi                   2018.1.18                py36_0    conda-forge\n",
      "click                     6.7                        py_1    conda-forge\n",
      "click-plugins             1.0.3                    py36_0    conda-forge\n",
      "cloudpickle               0.5.2                      py_0    conda-forge\n",
      "curl                      7.55.1                        0    conda-forge\n",
      "cycler                    0.10.0                   py36_0    conda-forge\n",
      "cytoolz                   0.9.0.1                  py36_0    conda-forge\n",
      "dask                      0.17.1                     py_2    conda-forge\n",
      "dask-core                 0.17.1                     py_0    conda-forge\n",
      "dbus                      1.10.22                       0    conda-forge\n",
      "decorator                 4.2.1                    py36_0    conda-forge\n",
      "distributed               1.21.3                   py36_0    conda-forge\n",
      "entrypoints               0.2.3                    py36_1    conda-forge\n",
      "expat                     2.2.5                         0    conda-forge\n",
      "fontconfig                2.12.6                        0    conda-forge\n",
      "freetype                  2.8.1                         0    conda-forge\n",
      "gettext                   0.19.8.1                      0    conda-forge\n",
      "glib                      2.55.0                        0    conda-forge\n",
      "gmp                       6.1.2                         0    conda-forge\n",
      "gst-plugins-base          1.8.0                         0    conda-forge\n",
      "gstreamer                 1.8.0                         1    conda-forge\n",
      "h5netcdf                  0.5.0                      py_0    conda-forge\n",
      "h5py                      2.7.1                    py36_2    conda-forge\n",
      "hdf4                      4.2.13                        0    conda-forge\n",
      "hdf5                      1.10.1                        2    conda-forge\n",
      "heapdict                  1.0.0                    py36_0    conda-forge\n",
      "html5lib                  1.0.1                      py_0    conda-forge\n",
      "icu                       58.2                          0    conda-forge\n",
      "ipykernel                 4.8.2                    py36_0    conda-forge\n",
      "ipython                   6.2.1                    py36_1    conda-forge\n",
      "ipython_genutils          0.2.0                    py36_0    conda-forge\n",
      "ipywidgets                7.1.2                    py36_0    conda-forge\n",
      "jedi                      0.11.1                   py36_0    conda-forge\n",
      "jinja2                    2.10                     py36_0    conda-forge\n",
      "jpeg                      9b                            2    conda-forge\n",
      "jsonschema                2.6.0                    py36_1    conda-forge\n",
      "jupyter                   1.0.0                    py36_0    conda-forge\n",
      "jupyter_client            5.2.2                    py36_0    conda-forge\n",
      "jupyter_console           5.2.0                    py36_0    conda-forge\n",
      "jupyter_core              4.4.0                      py_0    conda-forge\n",
      "kiwisolver                1.0.1                    py36_1    conda-forge\n",
      "krb5                      1.14.2                        0    conda-forge\n",
      "lcmap-pyccd               2017.10.27                <pip>\n",
      "libffi                    3.2.1                         3    conda-forge\n",
      "libgfortran               3.0.0                         1    defaults\n",
      "libiconv                  1.15                          0    conda-forge\n",
      "libnetcdf                 4.5.0                         3    conda-forge\n",
      "libpng                    1.6.34                        0    conda-forge\n",
      "libsodium                 1.0.15                        1    conda-forge\n",
      "libssh2                   1.8.0                         2    conda-forge\n",
      "libxcb                    1.12                          1    conda-forge\n",
      "libxml2                   2.9.7                         0    conda-forge\n",
      "locket                    0.2.0                    py36_1    conda-forge\n",
      "markupsafe                1.0                      py36_0    conda-forge\n",
      "matplotlib                2.2.0                    py36_0    conda-forge\n",
      "mistune                   0.8.3                      py_0    conda-forge\n",
      "msgpack-python            0.5.5                    py36_0    conda-forge\n",
      "nbconvert                 5.3.1                      py_1    conda-forge\n",
      "nbformat                  4.4.0                    py36_0    conda-forge\n",
      "ncurses                   5.9                          10    conda-forge\n",
      "netcdf4                   1.3.1                    py36_2    conda-forge\n",
      "notebook                  5.4.0                    py36_0    conda-forge\n",
      "numpy                     1.14.1          py36_blas_openblas_200  [blas_openblas]  conda-forge\n",
      "openblas                  0.2.20                        7    conda-forge\n",
      "openssl                   1.0.2n                        0    conda-forge\n",
      "packaging                 17.1                       py_0    conda-forge\n",
      "pandas                    0.22.0                   py36_0    conda-forge\n",
      "pandoc                    2.1.2                         0    conda-forge\n",
      "pandocfilters             1.4.1                    py36_0    conda-forge\n",
      "parso                     0.1.1                      py_0    conda-forge\n",
      "partd                     0.3.8                    py36_0    conda-forge\n",
      "pcre                      8.39                          0    conda-forge\n",
      "pexpect                   4.4.0                    py36_0    conda-forge\n",
      "pickleshare               0.7.4                    py36_0    conda-forge\n",
      "pip                       9.0.1                    py36_1    conda-forge\n",
      "prompt_toolkit            1.0.15                   py36_0    conda-forge\n",
      "psutil                    5.4.3                    py36_0    conda-forge\n",
      "ptyprocess                0.5.2                    py36_0    conda-forge\n",
      "pygments                  2.2.0                    py36_0    conda-forge\n",
      "pyparsing                 2.2.0                    py36_0    conda-forge\n",
      "pyqt                      5.6.0                    py36_4    conda-forge\n",
      "python                    3.6.4                         0    conda-forge\n",
      "python-dateutil           2.6.1                    py36_0    conda-forge\n",
      "pytz                      2018.3                     py_0    conda-forge\n",
      "pyyaml                    3.12                     py36_1    conda-forge\n",
      "pyzmq                     17.0.0                   py36_3    conda-forge\n",
      "qt                        5.6.2                         7    conda-forge\n",
      "qtconsole                 4.3.1                    py36_0    conda-forge\n",
      "readline                  7.0                           0    conda-forge\n",
      "scikit-learn              0.19.1          py36_blas_openblas_201  [blas_openblas]  conda-forge\n",
      "scipy                     1.0.0           py36_blas_openblas_201  [blas_openblas]  conda-forge\n",
      "send2trash                1.5.0                      py_0    conda-forge\n",
      "setuptools                38.5.2                   py36_0    conda-forge\n",
      "simplegeneric             0.8.1                    py36_0    conda-forge\n",
      "sip                       4.18                     py36_1    conda-forge\n",
      "six                       1.11.0                   py36_1    conda-forge\n",
      "sortedcontainers          1.5.9                    py36_0    conda-forge\n",
      "sqlite                    3.20.1                        2    conda-forge\n",
      "tblib                     1.3.2                    py36_0    conda-forge\n",
      "terminado                 0.8.1                    py36_0    conda-forge\n",
      "testpath                  0.3.1                    py36_0    conda-forge\n",
      "tk                        8.6.7                         0    conda-forge\n",
      "toolz                     0.9.0                      py_0    conda-forge\n",
      "tornado                   4.5.3                    py36_0    conda-forge\n",
      "traitlets                 4.3.2                    py36_0    conda-forge\n",
      "wcwidth                   0.1.7                    py36_0    conda-forge\n",
      "webencodings              0.5                      py36_0    conda-forge\n",
      "wheel                     0.30.0                   py36_2    conda-forge\n",
      "widgetsnbextension        3.1.4                    py36_0    conda-forge\n",
      "xarray                    0.10.1                   py36_0    conda-forge\n",
      "xorg-libxau               1.0.8                         3    conda-forge\n",
      "xorg-libxdmcp             1.1.2                         3    conda-forge\n",
      "xz                        5.2.3                         0    conda-forge\n",
      "yaml                      0.1.7                         0    conda-forge\n",
      "zeromq                    4.2.3                         2    conda-forge\n",
      "zict                      0.1.3                      py_0    conda-forge\n",
      "zlib                      1.2.11                        0    conda-forge\n"
     ]
    }
   ],
   "source": [
    "# Show librarys installed for this demo\n",
    "! conda list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resampling ARD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One approach to achieving spatial-temporal consistency when using ARD is to resample the data to some standard (or regular) temporal interval before running anything.\n",
    "\n",
    "Resampling, often referred to as compositing within remote sensing literature, is the process of grouping observations by time and reducing this group according to some criteria. One commonly used example of this is generating monthly \"maximum NDVI\" composites, often at an annual or monthly time intervals. Even more sophisticated approaches, like the \"Best Available Pixel\" approach from Wulder _et al_, can be described by this logic.\n",
    "\n",
    "The resample operation can be considered to have the following parameters:\n",
    "\n",
    "* Dimension (in this example, the time dimension)\n",
    "* Interval\n",
    "* Resampling criteria (usually a band or index)\n",
    "* Reduction function (e.g., \"max\" or \"min\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime as dt\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import toolz\n",
    "import xarray as xr\n",
    "\n",
    "import ccd\n",
    "\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.Dataset>\n",
       "Dimensions:  (time: 2916, x: 10, y: 10)\n",
       "Coordinates:\n",
       "  * y        (y) float64 1.935e+06 1.935e+06 1.935e+06 1.935e+06 1.935e+06 ...\n",
       "  * x        (x) float64 -2.11e+06 -2.11e+06 -2.11e+06 -2.109e+06 -2.109e+06 ...\n",
       "    crs      int32 ...\n",
       "  * time     (time) datetime64[ns] 1982-11-15 1982-11-24 1982-12-01 ...\n",
       "Data variables:\n",
       "    blue     (time, y, x) float32 ...\n",
       "    green    (time, y, x) float32 ...\n",
       "    red      (time, y, x) float32 ...\n",
       "    nir      (time, y, x) float32 ...\n",
       "    swir1    (time, y, x) float32 ...\n",
       "    swir2    (time, y, x) float32 ...\n",
       "    bt       (time, y, x) float32 ...\n",
       "    cfmask   (time, y, x) float32 ...\n",
       "Attributes:\n",
       "    crs:          +datum=WGS84 +lat_0=23 +lat_1=29.5 +lat_2=45.5 +lon_0=-96 +...\n",
       "    crs_wkt:      PROJCS[\"unnamed\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[...\n",
       "    Conventions:  CF-1.6\n",
       "    spatial_ref:  PROJCS[\"unnamed\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[..."
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ard = xr.open_dataset('./h03v09_ard_example.nc')\n",
    "ard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select a pixel to use as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select\n",
    "pix = ard.isel(x=0, y=0)\n",
    "\n",
    "# Mask according to CFmask\n",
    "land_water = np.array([0, 1])\n",
    "pix = pix.where(np.in1d(pix['cfmask'], land_water))\n",
    "\n",
    "# Create \"ordinal\" date for later\n",
    "pix['ordinal'] = pix.get_index('time').map(lambda t: t.toordinal())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To resample, we can use [`xarray.DataArray.resample`](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.resample.html#xarray.DataArray.resample) (see also [`pandas.DataFrame.resample`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.resample.html)). See the [xarray guide on time series operations](http://xarray.pydata.org/en/stable/time-series.html#resampling-and-grouped-operations) for more information.\n",
    "\n",
    "However, we need to add a little more code ourselves to resample other bands/variables/etc by our desired criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "_RESAMPLE_BY_METHODS = ('min', 'max', 'first', 'last', 'median', )\n",
    "\n",
    "\n",
    "def resample_by(dataset, var, freq, dim, how='max',\n",
    "                keep_attrs=True, **resample_kwds):\n",
    "    \"\"\" Resample all variables in Dataset based on one ``var``\n",
    "    \n",
    "    For example, one could resample all Landsat bands based on the\n",
    "    maximum value in the ``ndvi`` variable.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    dataset : xarray.Dataset\n",
    "        Dataset containing variables to resample. Cannot resample any\n",
    "        data containing string or object datatypes.\n",
    "    var : str\n",
    "        Variable name in ``dataset``\n",
    "    freq : str\n",
    "        Offset frequency that specifies the step-size along the resampled dimension.\n",
    "        Should look like ``{N}{offset}`` where ``N`` is an (optional) integer multipler\n",
    "        (default 1) and ``offset`` is any pandas date offset alias. The full list of\n",
    "        offset aliases is documented in pandas [1]_.\n",
    "    dim : str\n",
    "        Dimension name to resample along (e.g., 'time')\n",
    "    how : str or callable\n",
    "        Resampling reduction method (e.g., 'mean'). The method must not alter data from\n",
    "        ``dataset``, so only operations like ``first`` or ``max`` are supported.\n",
    "    keep_attrs : bool, optional\n",
    "        If True, the object's attributes (`attrs`) will be copied from the original\n",
    "        object to the new one.\n",
    "    resample_kwds\n",
    "        Keyword options to pass to :py:meth:`xarray.Dataset.resample`\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xarray.Dataset\n",
    "        Resampled dataset, resampled according to ``var``\n",
    "\n",
    "    Raises\n",
    "    ------\n",
    "    ValueError\n",
    "        Raised when using an unsupported resampling method\n",
    "    TypeError\n",
    "        Raised if any dataset variables are string/bytes/object datatype\n",
    "\n",
    "    References\n",
    "    ----------\n",
    "    .. [1] http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases\n",
    "    \"\"\"\n",
    "    # Implementation note:\n",
    "    # xarray's \"argmin\" and \"argmax\" doesn't work with more than one dimension\n",
    "    # See https://github.com/pydata/xarray/issues/1388\n",
    "    # \n",
    "    # There should be  faster way than resampling and masking and resampling again,\n",
    "    # but will need to wait on some work within `xarray`\n",
    "    if how not in _RESAMPLE_BY_METHODS:\n",
    "        raise ValueError(\"Cannot resample by '{0}'. Please choose from: {1}\"\n",
    "                         .format(how, ', '.join(_RESAMPLE_BY_METHODS)))\n",
    "\n",
    "    # Without the ability to select based on argmin/argmax we need to use a\n",
    "    # workaround (masking the arrays), but this doesn't work on string data\n",
    "    is_str = [dv for dv in dataset.data_vars if\n",
    "              dataset[dv].dtype.type in (np.str_, np.bytes_, np.object_)]\n",
    "    if is_str:\n",
    "        raise TypeError('Cannot use `resample_by` with string or object '\n",
    "                        'datatypes (as used by {var})'\n",
    "                        .format(var=', '.join(['\"%s\"' % dv for dv in is_str])))\n",
    "\n",
    "    # Resample by criterion variable\n",
    "    kwds_re = toolz.merge({dim: freq}, resample_kwds)\n",
    "    var_re = getattr(dataset[[var]].resample(**kwds_re), how)()\n",
    "\n",
    "    # Now that we know what observations have been selected by the reduction,\n",
    "    # reindex the resampled data to look like the original dataset\n",
    "    var_reidx = var_re.reindex_like(dataset, method='ffill')\n",
    "\n",
    "    # Find where identical, and mask the rest so that it can be ignored when we resample\n",
    "    mask = (dataset[[var]] == var_reidx[[var]])[var]\n",
    "    ds_masked = dataset.where(mask)\n",
    "    \n",
    "    # Ideally we want to use 'first' instead of 'max', but it's not implemented on dask arrays\n",
    "    return ds_masked.resample(**kwds_re).max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we define the ratio of the NIR to the blue, which is pretty good at eliminating clouds and cloud shadows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "pix['sr_nir_blue'] = pix['nir'] / pix['blue']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = 'sr_nir_blue'\n",
    "\n",
    "resample_freq = '16D'\n",
    "resample_dim = 'time'\n",
    "resample_reduce = 'max'\n",
    "\n",
    "pix_re = resample_by(pix, criterion, resample_freq, resample_dim, how=resample_reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.Dataset>\n",
       "Dimensions:      (time: 791)\n",
       "Coordinates:\n",
       "  * time         (time) datetime64[ns] 1982-11-15 1982-12-01 1982-12-17 ...\n",
       "Data variables:\n",
       "    blue         (time) float64 nan 385.0 nan nan nan nan nan nan nan nan ...\n",
       "    green        (time) float64 nan 503.0 nan nan nan nan nan nan nan nan ...\n",
       "    red          (time) float64 nan 377.0 nan nan nan nan nan nan nan nan ...\n",
       "    nir          (time) float64 nan 528.0 nan nan nan nan nan nan nan nan ...\n",
       "    swir1        (time) float64 nan 223.0 nan nan nan nan nan nan nan nan ...\n",
       "    swir2        (time) float64 nan 179.0 nan nan nan nan nan nan nan nan ...\n",
       "    bt           (time) float64 nan 2.845e+03 nan nan nan nan nan nan nan ...\n",
       "    cfmask       (time) float64 nan 0.0 nan nan nan nan nan nan nan nan nan ...\n",
       "    ordinal      (time) float64 nan 7.239e+05 nan nan nan nan nan nan nan ...\n",
       "    sr_nir_blue  (time) float64 nan 1.371 nan nan nan nan nan nan nan nan ..."
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pix_re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb8aff56be0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAD8CAYAAAA2edOFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzsvXt4VOW58P2bmQSYQJRDiiWTBKzFzwr0tZdtlHfTLRaxCNkvdloXpbTBlm10q1jRigmgKMeIbpRSq0KtGkupj77zgkVLpWz71WwVZPv5FWn3bt0KSQZQOaghDJDMrPePmQkzmbXmnDnev+vKBfOs0/Osw7PudR8tuq4jCIIgCIIgZBdrtjsgCIIgCIIgiFAmCIIgCIKQE4hQJgiCIAiCkAOIUCYIgiAIgpADiFAmCIIgCIKQA4hQJgiCIAiCkAOIUCYIgiAIgpADiFAmCIIgCIKQA4hQJgiCIAiCkAOUZLsDMZByA4IgCIIg5BOWZDfMdaGMgwcPZuQ4FRUVHDlyJCPHyjbFMtZiGSfIWAuRYhknyFgLkWIZJ4SPtbKyMqV9iflSEARBEAQhBxChTBAEQRAEIQcQoUwQBEEQBCEHyHmfsr7ous6pU6fw+XxYLEn70kXw4Ycfcvr06bTtL5vouo7VamXQoEFpPUeCIAiCIPQfeSeUnTp1itLSUkpK0tv1kpISbDZbWveZTXp6ejh16hR2uz3bXREEQRAEIQ7yznzp8/nSLpAVIiUlJfh8vmx3oyBxuexcNn4IVY7PM9Fxhp3jVmF3ubLdLUEQBCHPyTuhTMxx8SPnKv24XHYW3jGEjuPnoGOljTHc9MkDvHTHHhHMBEEQhJTIO6FMELJJc3M5nu7SsLaTDGZJ932UNzdnqVeCIAhCISBCWQr87ne/w+Fw8N577wHQ3t7OBRdcwNSpU5k8eTK33XYb3d3dALz++utcdNFFXH311Xz961/H6XSyY8eObHZfSIKDB439DtuowZahRMeCIAhCYVLwQpnd5WJkbS2jqqoYWVubVhPTli1bqK2tZevWrb1to0ePZseOHezcuZNDhw7x29/+tndZbW0tr7zyCq+99hrLli1jyZIlvPbaa2nrj9D/VFZ6DdtraMObYiZnQRAEIT62z9rKREd3wLe3m+2ztsbeKA8oaKHM7nJx7sKFlLjdWHSdErebcxcuTItg1tXVxZ49e3jooYfChLIgNpuNr3zlKxw+fNhw+/Hjx7NgwQKefvrplPsiZI7Gxk7spd1hbWV0saL0PjobG7PUK0EQhOJh+6ytzG+tp43RAd/e0cxvrS8IwayghbLy5masHk9Ym9XjSYvvz/bt25k8eTIXXHABQ4cOZe/evWHLT506xdtvv83kyZNN9zF+/Phe06eQHzidHtasPUHVsM+w4KOG/Tw+9G5mrP0qHqcz290TBEEoeO5vnc5JBoe1nWQw97dOz1KP0kdBC2VmPj7p8P3ZsmULM2fOBGDmzJls2bIFgAMHDjB16lTGjx+Pw+Hg4osvTvlYQm7hdHrY9e4JOtyHecM9gCn7FolAJgiCEIN0pBNyuey0UWO4rJ3qdHQzq8RM+KVp2iDgT8DAwPovKKWWapr2NHAF8Glg1euVUu9ommYB1gHTgZOB9rcD+5oLLAmsv0Ip9Uw6B9MXb2UlJW63YXsqHDt2jNdff53/+q//wmKx4PV6sVgszJ07t9en7MMPP+Q73/kOr7zyCldffbXhft59913Gjh2bUl8EQRAEIdcJphMKRq8H0wk9ccctzIC4PmyD+wDjdE/VtAOlhsvyhXg0ZaeBbyil/gdwCTBN07TLA8vuUkpdEvh7J9B2DTA28NcAPAagadpwYClwGVALLNU0bVj6hhJJZ2Mjvj4Z7X12e8q+Py+99BLf/va32b17N7t27WLPnj3U1NRw6NCh3nXOO+88Fi1axPr16w338Ze//IVHHnmEuXPnptQXQRAEQch10pFOyGgfQcroYumkl1PuZ7aJKZQppXSl1InAz9LAnx5lk5lAS2C7N4GhmqaNAr4J7FBKHVNKHQd2ANNS6350PE4nn65ZQ4/DgW6x0ONw8OmaNSmbmrZu3co111wT1jZ9+vQIAWzatGl4PB527doFwO7du3tTYixevJhly5bx9a9/PaW+CIIgCEImScYMmY50Qmb7AJ25PMW3ZhlHx+cTcdUr0jTNBvwH8EXgUaXULk3T/gVYqWnavcBOoFEpdRpwAO0hm3cE2sza+xWP05l2f58XXnghom3evHnMmzcvrM1isfCHP/yh9/d//ud/prUfgiAIgpBJkjVDVlZ6cbsjRY5E0gkNHerj+HEjwczCy9Tx0+ZJee/fG5dQppTyApdomjYU+D+apo0HmoDDwABgA3A3sAxjY68epT0MTdMa8Js9UUpRUVERtvzDDz/st9qXhVZTc+DAgRHnD/zjNGovNIplnCBjLUSKZZwgY80nHnywFE93+Os8aIac8+AVDG5oACLHuXIl3NzQw8kzZ9+zFnxM5yUsM2bEPCebN1s58Zn58qDGLRvnNp3XNCEpRCn1iaZpfwSmKaUeCjSf1jTtKeAngd8dEBYCUQUcDLRP7tP+R4NjbMAv5AHoR44cCVt++vRpbDYzFWbylJSU0NPTk/b9ZpPTp0/T9/wBVFRUGLYXGsUyTpCxFiLFMk6QseYT7e2jDNvbqIH29t6x9R3n1Knwne+ew7Mtg9EDOhodK89wPf/wi5uYPmFDVC3X4sUj6faav/uDGrdsnNvQsVamGEgY06dM07TPBTRkaJpmB64C/jPgJ0Yg2vJa4N3AJi8C9ZqmWQIBAZ8qpQ4Bvweu1jRtWMDB/+pAmyAIgiAIeUAqVU127hzUK5AFOclgFvuWc86990bd1tyfDAZwumASeMcTfTkKeFXTtD8Db+F31t8GbNI0bS+wF6gAVgTWfxl4H3gP2AjcDKCUOgYsD+zjLWBZoE0QBEEQhDzAqKpJ0Ax5asqUqNtGc/a3Hj8edduhQ32my4bwWcEk8I5pvlRK/Rn4ikH7N0zW14FbTJb9Evhlgn0UBAG/g+0D99pwHx9CNW2sGPoQdcsvKoiJSBCE/MDp9PDWW6U821ISYYb8n796kxlfcyXs7G/Fx6+ZzZUmx3S57Jz41Dzpw3FGFMw8WNAZ/QUhHrY17WVijc8f3l3jY1vT3tgbZZhgxFPH8XMCtd78EU8v3bEnLbVcBUEQ4sXMDLnEt5xz7rnHdLvGxk7KOBnR7qWEBjaazr3NzeV0+8x1SNXWjjh7nvuIUJYCv/vd73A4HL31K9vb27nggguYOnUqkydP5rbbbqO726/mff3117nooot685Q5nU527Nhhuu/LLruMKVOmcNVVV/Htb3+bjo6zN111dTVTp07t/fvZz37WvwMtYLY17WVByyTavFV+YcdbxYKWSTknmKUj8aIgCEI6MDNDHmA0X/jk/zOdP+ewiXprC0apTk8ymJWbxiV0PPAnjV0xcFnsTucJBS+UuVx2amtHUlU1itrakbhc9tgbxcmWLVuora1l69azlemDZZZ27tzJoUOH+O1vf9u7rLa2lldeeYXXXnuNZcuWsWTJEl577TXT/T///PP84Q9/YOLEiaxbt663fdCgQezYsaP379Zbb03bmIqNlZvGGRa2NZscMs22pr1MqBqI25164kVBEIR0YObsDxbaGMOtLVfw3LSWsCV2l4uXfryLFt8PMCuT1O41DhQwO56NHjZwA98/VTheUQUtlLlcdhYuPBe3uwRdt+B2l7Bw4blpEcy6urrYs2cPDz30UJhQFsRms/GVr3yFw4cPG24/fvx4FixYwNNPPx3zWJdeeqnpfoTUMJsEzNrTRTwZsbc17eXWlis4po/AbBJLJPGiIAhCOmhs7MSCueN9N4O4/dWZYXNaeXMzS3zLIz6CQ6m2GX9g+s2eXWFtZXTxDPXMYXNBzYEFLZQ1N5fj8YQP0eOx0txcnvK+t2/fzuTJk7ngggsYOnQoe/eGq2tPnTrF22+/zeTJk033MX78+F7TZzReffVVvvnNb4btO9R8aSQUCvFhNgmYtQdJpsxI6Lbx+Iet3DSObgaZ7seCr2DCwAVByB+cTk+ET1lfjlER5lphO3jQn8vMhDK6WDxnn+nxHi+7ndHsx4KP0exnAzcwh83oEDPqM58oaKHMzA4dzT4dL1u2bGHmzJkAzJw5ky1btgBw4MABpk6dyvjx43E4HFx88cVJH+O6667jy1/+Mq2trXzrW9/qbe9rvgz2Q0icxXP2GX6BmU0OYCxUzf3kpyyab41LMIvXPyyWtk6HggkDFwQhv3A4YteZDHWt8FZWUkObyZo69bZfcd3X/m66r+8NeIH9nI8PG/s5nzlsBvw2hLLnny+YgKeCFsrM7NDm9vD4OHbsGK+//jo/+clPuOyyy3jsscd48cUX0XW916fs3//933n77bd55ZVXTPfz7rvvMnbsWLxeb6/W68EHH+xd/vzzz7Nr1y4uvPDCsHYhfdStnsDD9a3U2Dqw4KPG1sHD9a3UrZ5guo2RUKVj5QluYtvCd2IeM97CvLG0dTW0i0AmCEJWMMpXFsoIjoSZFX855Uk6GYyRkz9YaPF+P2o0ufXTT02PZfV4CibgqaCFssbGTuz2cLu33e6jsbEzpf2+9NJLfPvb32b37t3s2rWLPXv2UFNTw6FDh3rXOe+881i0aBHr16833Mdf/vIXHnnkEebOnYvNZuvVet111119+mvn/vvv54UXXuB4jOR6QnLUrZ7AG21WOtyHeaPNGlUgA3OhSsfKEs+SmMeLNyP24jn7KOWU4boDOM3SSS/HPJYgCEJ/4HR6WLP2BGWlp+kraA3gNOtKF/a6Vrhcdm7f/A2O8TnM/GNjRZP/yj6PMXyAFS9j+IBNzA5bXigBTwUtlDmdHtas+RSHoweLRcfh6GHNmk9xOj0p7Xfr1q1cc801YW3Tp0+PEMCmTZuGx+Nh165dAOzevbs3JcbixYtZtmwZX//612Me77zzzuPaa6/tDQro61O2atWqlMaTz6Ti25UI98z6mBrHSByOUejmOQxpj+IzEcToC7OMrgj/sLrVE/hZ/f/LcMtR/JOe/8+Klx/ZnuZbs1LT+AqCIKSKjpVQQcuCj3n8gu/+cECvJt/IumCEWTT5tqa93HTyEQ4wBh0rBxhDAxvDBLNCcfa36NHeMNlHP9jnAp08eZKysrK0H6gQC5Kbnat8L4gbJOjbFfqwl9HFE6W3MGPtVxnc0JCWcd4z62N+2fplwr/wdIy++GqsbbzRHrNQRkLZ+WON0+N0Fsw1jYdiGWuxjBNkrPlKbe1Iwwz9o9nPBzVXcOiNNwCoqhqFrkcPDAhu955jEh/t3h3WPrHGR5u3ynD9/ZyPDnTV1/PZ6tXJDSRFDAqSxx6sCQWtKRMKm0wlVH2mdRyRz5iFvir7MrpY/P2/xrVPp9PDrndP+E2m7gFM2bfIVCC7/cfnSuJYQRByCrvLFTV/Iu3tvb/j8+PWTetnmgU9BaM5LcCgnTvjOEbuI0KZkLfE6zCfKl7Mo3VH8HHcAQKJEtSQeX3Gj6kkjhUEIRtsn7WVL86fZbq8hjYYNqz3d6ygAD8WnuF6tmy2RLigmAU9hUZzFspcmHdCWY6bW3OKQj9X8TrMp0L0cksWPJTRUvoj3nlkS1oFMojthyGJYwVByDTbmvYyv7Xe1Gnfgo+VLALL2WXBoICqYZ8BPtPEs2YWgKsmHo3Ypowu/3ECFMpcmHdCmdVqLTjfr/6gp6cHqzXvLm9CTJlyCouBCTGdCVX95ZbM3QNOMpjbux/sFzNizHpvkjhWEIQMY1SaLhQd/DnEjh0Law+6bLjdh3m8fgfGqTEiLQAul53Nuy4OBBT4seBjLk/15irz2e0FMxfG9kjOMQYNGsSpU6c4ffo0FkvSvnQRDBw4kNOnT6dtf9lE13WsViuDBplng893XC47z28eGJZV2v+gPs21s3U+czqjTBvxE0+5paNU8Jz7H7kyDccLpbLSa+hEa6OHDZYbmb72cslTJghCRok1J44OmhSrq03XqVs9AcdO4/ltOEfDtF5+i0H4ejpWXqYOnfl4HQ46GxsLZi7MO6HMYrFgt6evqHiQQoqIKQbMHlSFxk93ruYzg236RjxOt/+Rl6x1dHQNN42ArLYdNIz6CcfCIlbzRurDCqOxsdM06lIEMkEQskG0OTFoUtQtFrzLlkXdT2NjJ3fcNoRuPdxFo5NzaDl/MdMCv6P5DmOxRERq5juFbd8SChazBzWoteqLUWmkxz1zae+qiFp/0qgMkxHtmH8V9mVb014m1vj8udVqfKZ+a6F+GBZ81LCfx4fezZnLLuOS26+Nub0gCEK6MZ4TdUbwcW89SnQd3+zZhtsHcTo9nGPw+XyGgdz/xj/1/s6E73AuIUKZkJeYh1hbuI11EdE7xk7z4eZvIyfTYBmm4RzBzAcCYpdECrKtaS8LWibR5q3yC4PeKha0TIoqmIWmzvD8r39ifmt9xPbPzX8zruMLgiCkwnVf+zsbuCGsOPivmMMRRvb6eHkdjrj2dVQfZtgeaiKNN9l2oRDTfKlp2iDgT8DAwPovKKWWapp2PvAbYDjwNvADpdQZTdMGAi3ApcBRYJZSan9gX03APMAL3KaU+n36hyQUA42NncyfPxQjJ/xjVPDSHXv4bnk5TJ0KxF+E3ijNRN3qCazcdIpjXmMfxrMFzGNHXxo5yZ5kMCs3jaMujryHZtsvefILTFkae3tBEIRUKG9uZg7uXgGsL0Gn+1g+vdua9mLh84afuv6PXL/OKFiBZ02jt9fVZJVlCTNn2/isAF044tGUnQa+oZT6H8AlwDRN0y4HHgAeVkqNBY7jF7YI/HtcKfVF4OHAemiadjHwXWAcMA34uaZp8b0pBaEPTqeHEZZjJkstLOm+D9u99/a2xFuE3kwlbu7cqieUn8xsP/EEFKRje0EQhFQwywemAz0OB5+uWROXv+vKTePCIiqDWPAFPnLPModN7PfV4MPGAc5njr6Jsuef75eSetkmplCmlNKVUicCP0sDfzrwDeCFQPszwLWB/88M/CawfIqmaZZA+2+UUqeVUh8A7wG1aRmFUJSs+sEeooVVh2aUNk5eGH86DdPkhZb2hPKTme0nXvNnqtsLgiCkgpkfl9fh4KPdu00Fsr6+tG0mH5I6RMyp5c3NWD3hNautHk9BVjSJy6dM0zSbpmnvAB8BO4D/Bj5RSgUThnUAQSOyA2gHCCz/FBgR2m6wjSAkTN3qCQwffMpwWQ1tYSHZRk7zN9mfoXrwkTAn+mAtyb5cNTFYFDwUnRn6toS+1oycZM+aP5PffsW89+PugyAIQrJ0Njbi65MBIVaeMCNfWrOEVjUGH5hm2rlCyeIfSlwpMZRSXuASTdOGAv8H+JLBasE3ltG5Nq7ebKDm0DStAWgIHJeKiop4upgyJSUlGTtWtsnVsW7ebOXeO0/RfrTM7zcwfC2z1l4aNYpn7aNWbm7o4eSZs7dyGV2sLL0ffeXKsHE2NPj/oAeoBL7HOkJ/rwUw9IX4Q9sojOpfvsx0Hn3wCgb7dxyT6zdeiX3Qmyx58gu0eyupth1kxbz3mbU+vixnZtvPeWxS0SRVztX7N90UyzhBxppXNDTgKy/Hcu+9fmtEdTW+ZcsYPHt279z53Pw3WfKkr3eO6vJ9NcIXVseKBV+YCTP4gVlRcXn4Mauroa2NCKqrc+JcpvOaJpSnTCn1iaZpfwQuB4ZqmlYS0IZVAUGRtQOoBjo0TSsBzgWOhbQHCd0m9BgbgA2Bn3qmcocVU56yXBxrMGWFp3sIAG2MoeHYavQbbmFGZ6epSnzqVHjgX8Pzj60Y+hDTl19Kj6albZzt7aMM24Nm0kSOM2XpFwNO+YfxK6u/aLh937xqwTxqU5Y6I7bv6enJuWvaX+Ti/dsfFMs4Qcaad0yd2htE1UtgTEGtWFAI8+c0M3Yz0YEaW0ev8LZ4zj6mLJ0QcX7sd93FuQsXhpkwfXY7n951F54cOJeh17QyxTQd8URffg7oDghkduAq/M77rwLfwR+BORfYGtjkxcDvNwLL/00ppWua9iLwa03T1uJXS4wFCivrm5A0Rslggykqvts8KarjqNPpwb/4BDAAWIQHY41Xsphl1++vXDlnhVR/Go9gHrUn7riFGSCJYwVByEmMyzAZGytrbAd5o83K2Q9MY//c4HxX3tyM7eBBvJWVBZXFP5R4fMpGAa9qmvZn4C1gh1JqG3A3cIemae/h9xl7MrD+k8CIQPsdQCOAUmofoIC/ANuBWwJmUUGImrU5F/wG+iNXTrQkskZ51cyK9QqCIOQK0SLVQymji6UTfxv3fj1OJx/t3s2hjo6oAQX5jkXXzRNi5gD6wQy9kAtCpRwnuTjW2tqRhpqo0eznPcekpEppRBunmWkw2oOezDZm9FXxg3+SCqbXqKoaha5Hfl1a8OG1lHCooyPusRYaxTLWYhknyFgLCX9kpXEZJhs9+LBSQxsrWcQsx5+SLpNkd7lyRnNmYL5MujC3ZPQXcoJMZm2+Z9bH3Db/3LCSS/WfrGfs/Flsn7XVdLu+2fWn7FuU8CTgctm5bPwQbmy52jSJLBRfaRFBEAoDfyS5sbLHhxUfNvZzPnPYnLQVxO5yce7ChZS43Vh0nRK3m3MXLiyIvGUilAlZJ6iB8nTbsNEDcaSoSJZtTXt5qnWCQdJCC0f5HPNb6/utlmRo/U2zD6mg6r/YSosIglAYxExVFEKyH5jlzc1s9lzLGD7AipcxfMBmz7Wcc889Se0vlxChTMgq4YKKFS8llOFhZel9SZsGzdjWtJebW6YYZpEOEqqtSnTfsYqMG9ffDCeYBNasGHm6hVRBEIRE2Na0l4lVPf65znGGnWOXRmio7m8+RdmA8BQ9ZXSxkkW9v2PlNovGc+4raGAjBxiDjpUDjKGBjfzmk2vyXlsmQpmQVdLl0B5LKAr6cHnjyAKTaMmieIuMx6q/2TeJbDrMpYIgCOmid67Ta3pdP246+Qgv/3hXmDDkdHr4+QbCPyrtP+a7w7ajWywJlWMyYpHtAUP3j8WsyvtAKBHKhKySjqhLM6Houflv9q5jHKZtTKIli6IVGQ/FvP6mTg0HEqqhKQiCkGnM5rrFvuURwtDs2b7ej8p31m9j9vDtWD/5JC1O+e1e42JAuRKtnwoilAlZJR0O7WYTxZInv9D7O17tVyIlj2Ltu2+7mZ/Ys6U/5J31vxWBTBCEnMZsrosmDPWHU36lo3ADoUQoE7JKOhza4xGKYmu/dGrYn5S2Kt4i4eInJghCPmM210UThvqjmHghB0KJUCZklWQElb7+Y8MtxwzXC51AjAp5hzKaA/y3Y1JS2qpEioyLn5ggCPmK2Vy30nqPqTDUH8XEC/kDN6Hal4LQH5iVSTLCqK5aKacYwGnOMLB3vWBhW/giQEDYaqXp2a9yTB9OaEqKVL+wgvteuWlcWA03MUcKglBI9M51z36Jdr3Kn0S7bCXTH7jMVBjyVlZS4nYbtqdCIu+NfEIy+gco9CzLoeTzWM2yRQ/nCENsp8KEous3XplQoe98/sLK52uaKMUy1mIZJ8hYC5HgOIM+ZRHFxFOIvsw10pnRXzRlQl5h5j92nOHsbTtMrMK2ULhfWIIgCLlGMRUTTwcilAl5RbXtoKGmzO8/Ji6SgiAIuYbH6RQhLE7kLSbkDS6XnRO2c+hbVy2RNBbB2pO92ajHrcr7DNCCIAi5xLamvYwt+yhqhRPBGBHKhLwgWI7p2JnQupE6I/iY9ZNa4nKqDy3p1JuN+pMHeOmOPRkTzOIpxyQIgpCvxFvhRDBGhDIhLzCuG2lhCF3Uf7Ay6X0kU9IpWZZeuY+bWqbKZCUIQsER/OC8seXquCqcCMaIUCbkBekox5SOfSTLtqa9PPm3yGLoMlkJgpDvhGrHzAIPE60pHKTYXE5EKBPygnSUY0rHPpJl5aZxEQJZkGQnK0EQhFwgntrCVhJ328gFl5NMI0KZkBekWlbD5bJz8vgZjIIEMlGaI5rglWgBdEEQhFwi9oeljpeShN02su1ykg1ipsTQNK0aaAE+D/iADUqpdZqm3QfcAHwcWHWRUurlwDZNwDzAC9ymlPp9oH0asA6wAb9QShXmWRXSjtPpzyTWN+nrjOWxy2oEv7bCH26dERzh4bJFzHig/0tzmKXysOALRI5K9n9BEPITs/nt7EdwuEkz6LZRtzr6frPpcpIt4tGU9QB3KqW+BFwO3KJp2sWBZQ8rpS4J/AUFsouB7wLjgGnAzzVNs2maZgMeBa4BLgZmh+xHEGKSbN3IaEECs4f9LiP5c4xqxlnwMe/CnVKOSRCEvMasJuYIy1FS8TGL5XJSiNHsMYUypdQhpdTbgf93An8FHFE2mQn8Ril1Win1AfAeUBv4e08p9b5S6gzwm8C6gtCv5MLXVt3qCTxc30qNrcNfQNfWweP1O7j/VXHyFwQhvzGc3xr+I1Bn2Jh43Daiua20nL+4IFNvJJTRX9O0McBXgF3APwC3appWD+zBr007jl9gezNksw7OCnHtfdovMzhGA9AAoJSioqIikS4mTUlJScaOlW2KZazBcVZXQ1tb5PIa2qC6OmPn4vqNV3L9RvArn0cG/ozZvNnKvXeeov1oGdW0sWr4WmatvRTf7NmG6xfLNYXiGWuxjBNkrIVA3/mtpKSSJU+au22smPc+FRWXR91nQwOUl1u4984TfebCK7lg3hTT1BvXb8zs+U3nNY1bKNM0bQjwv4HblVKfaZr2GLAcv9F4OfCvwI8w1lXqGGvlIqqhK6U2ABuCyzNVuLVYisRC8Yw1OM677or0KQt+bX1y1114cuRcbGvay8pN42jzVmIBdIYA0MYYGo6tRr/hFmZ0dhqaW4vlmkLxjLVYxgky1kKkoqKCqyYe5ZetDsLFAp1v8AfqJvyNI0e+GHM/U6fC1D8DfIa/VnEjHwHt3s8brt/ureTIkcMp9z8RDAqSJ01c0ZeappXiF8g2KaVcAEqpD5VSXqWUD9iI3zwJfg1YdcjmVcDBKO2C0K84nR7WrD1B1bDP/Kp19vP40LuZsbb/HfzjJTzPj9Uwn1khRxwJgpAfxOvH9dz8N3mmdRyRehoL73Hua1fTAAAgAElEQVRhynOZmfkz36PZ44m+tABPAn9VSq0NaR+llDoU+Pkt4N3A/18Efq1p2lqgEhgL7MZ/ZcZqmnY+4MYfDPC9dA1EEKLhdHrwy18n8H9tLcKT3S6FEU+en0KOOBIEIfcJfjwG5yq/H9cwoDUsYCm4ntdExEjHXLZ4zj4WtAwLmzfP1kHO3+CpeDRl/wD8APiGpmnvBP6mA2s0TduradqfgSuBBQBKqX2AAv4CbAduCWjUeoBbgd/jDxZQgXWFIibfszWnq//xRCJlIsmtIAiCGUYfj0ZVSWJ9ZCYyl9ldLkbW1jKqqoqRtbW986tRcMHD9a15H81u0fUIt65cQj+YIc1Asdj5IXfGapQ/rIwu6q3P8pL9O3R0De/NR1a3/KKETY39PU6z/j9RekvCptGJNT6TPD/x7TdXrmkmKJaxFss4QcaaL1Q5Pm9YmcSCjw63349rW9Nebmy5GrNUGInMkXaXi3MXLsTqOWvX8NntfLpmTc64noChT5nx4ONAMvoLWcMsW/MTvgbauypyvqxGOrNNm+UxAz0nfeAEQSg+YvlxBc2WZjKJjZ6E5rLy5uYwgQzA6vEUtG+tCGVC1jDLH5YvTu7pzH9mlsfM7T6UUKJcQRCE/sIsSazfjyu62bKMLn5evzOhucxsHg22m5k28xkRyoSsYZat2YhUHEP7y28t3QXO61ZP4I02q79iQZs1730jBEEoLGL5cZn7xupJ+XuZzaPeyspe02aJ241F1ylxuzl34cK8F8xEKBOyhlG2Zr/JLpJkBZ2g31fH8XOSModGE+hSLZIuCIKQb0T7eDQzb9bY3El9ZHY2NuKz28PafHY7nY2NBWvaFKFMyBpG+cNutLdgt50OWy8VQScVv69YAl0+5D8TBEHIFLHMm4nicTr5dM0aehwOdIuFHoej18k/lmkzX5HoywD5HBGTKLk8VpfLzr13D+T4ybNfRyM4wppJLzDtucRKpVZUVDBoUCm6Hul0asGH11LCoY4O0+1ra0fidkfm2RnNft5zTOKj3bsT6k9/ksvXNN0Uy1iLZZwgYy0kgpVJ2r2VVNPOKpqY5fgTnY2Naf1YHVlbS4nbHdHe43BkfG6W6EuhIAlqpo6fLMN/T/v/jvI55rfWJ1VoNhW/r0wVMo83Q7YgCEK2ieVcX7d6Au88sgVvWTkHGMMcNveLv1c002Y+I0KZkDMYmRqDGCUojIdU/L6SEegSDSoILa+kY6XNW8WtLVfw5S+U521CXUEQCpN4nevLm5uxnDwZ1pZuf69ops18RoQyISdwuey43caaqSDxZL3vSyp+X4kKdMkEFRiFkHcziKOny3M+T5sgCMVFvM71mfL38jidfLR7N4c6Ovho9+68F8hAhDIhBwgKM7HM8MM4mpRg4nR62PXuCX+0UAI5vxIV6JIJKohH0MzVPG2CIBQX8QpbQUvCJmYzhg+w4mUMH/CrQT/q9z7mOyKUCVknmtkyFAtkXDBJRKBLxgfNLIQ8kX0IgiBkgmh5w0LpbGxkk/X7NLCRA4xBx8oBxnCTZ534zMZAhDIh65gJM305xoicFkyS8UG7auJRIHYEtBQjFwQh28TrXO9xOlnEqriKlwvhiFAmZJ14M/vnumCSTFDB7z8YRyyzrSSkFQQhF0jEub7d5zDcRzK+wdEotOh1EcqErGMkzPSllFOcYAgD3G05G5GYTFCBuZZQl4S0giDkHPE618cqXp4OjKLXF7RMymvBTIQyIa0kU2cyKMyYm/F0LFg4SkXORyQmGlRgpiUczQHOOGqkGLkgCHnJinnvpzW7vxFG0ev5biIVoUxIG6nUmXQ6PdTYIrMzA9jwcoaBYW2JRCTmgnrbTFiV+pmCIOQLicyls9ZfHrV4eTowM4Wm20SaSUQoE9JGKnUmwbxumpfkM+vngno7mrA6h01SP1MQhJwnmbk0WvHyRI5rJghW0264jVl7PhCz9qWmadVAC/B5wAdsUEqt0zRtOPAcMAbYD2hKqeOaplmAdcB04CRwvVLq7cC+5gJLArteoZR6Jkb/pPZlP9BfY62qGpV0nckgYXXTbAdZPGcfy3ZOSaoGZUVFBWPLPqLNWxWxrMbWwRtt/ftN4nLZeeBeGx3HyzFy5k9nDU25fwuPYhknyFjzgYk1voTm0nSMMygIhpooy+jq1bi96vgJDWyMWL6BG7jS/VBKx06ETNe+7AHuVEp9CbgcuEXTtIuBRmCnUmossDPwG+AaYGzgrwF4DCAgxC0FLgNqgaWapg1LtuNC7pFKnckgRl9WqZj4Mq3eDn7VORyf57b559Jx/BzMnk/JPSYIQr6Qqbk0tLbmypaLovqMzXL8iQ3cwGj2Y8HHaPazgRuY5fhTWvuUSWIKZUqpQ0FNl1KqE/gr4ABmAkFN1zPAtYH/zwRalFK6UupNYKimaaOAbwI7lFLHlFLHgR3AtLSORsgq/eUflUqppExEAAUJVe+DFT3G45XrKT4EQRCCZGIu7Vtbs51qw/WCgmBnYyOz7VvYz/n4sLGf85lt35LX/rgJ2W80TRsDfAXYBZynlDoEfsENGBlYzQFhBt2OQJtZu1AgpCI8xbPvZEolmfmppTMCKIhRJJAZ4swvCEI+kYm5tG9tzRraDNcLCoKFWJQ80lHHBE3ThgD/G7hdKfWZpmlmqxrZavQo7X2P04Df7IlSioqKini7mBIlJSUZO1a26c+xNjT4//xW70pgLUCcokp6KSkp4fqNV2If9CZLnvxCr5/ainnvM2v9lWk/Xrs3nsdJp4YDrBq+lllrr8Q3e3ZS52bzZiv33nmK9qNlVNPGquE/YdbaS/HNnp3E3vKLYnlWi2WcIGPNBxKdS5MZZ193juls43FuDrM6lNHFinnvU1FxuX8evO962o/e7J8HPWuZVV7O4Ayf33Re07iEMk3TSvELZJuUUsHcBh9qmjZKKXUoYJ78KNDeAWE6xyrgYKB9cp/2P/Y9llJqA7Ah8FPPlENkvjpfJkOxjDU4zilLv8iUpQCH8SuHv9gv46+2GTvCBimjiydKbwloDhv9D0wS/QhGc3q6hwDQxhgajq1Gv+EWZnR25vVXYjwU2/1bDMhY84NE5tJkxjmyspIStz810iZm8ww/DBPILPj43oWvM2XpODZs6MqZedDA0T9pYpovA9GUTwJ/VUqtDVn0IjA38P+5wNaQ9npN0yyapl0OfBowb/4euFrTtGEBB/+rA22CUBAYqfct+PBrx9Jnyk019YggCEIuElpbc7FB7UwdK6/895cA83nw+u5fsG3hO5npcD8Qj0/ZPwA/AL6hado7gb/pQDMwVdO0vwNTA78BXgbeB94DNgI3AyiljgHLgbcCf8sCbUIRkwuJXdNF3eoJEckSH6/fgdt9KG4/uHgqIpiVZpJoTkEQ8plQH7E2agzXCTr5m82DXkq4ybMub98lMfOUZRnJU9YP5MpYY+WgSZVcGWe8nDVLnv36Czd5+gW62tqRSeVtKxTy7bomS7GME2SshUiq44yVF81sHuy7XibIdJ4yQegXEq1bVkhaNSPiNUtKaSZBEAqdWNGeRvNgKPlaakmEMiFrJJKMMBfKJfU38ZoljVKPbBjeJKWZBEHIa0I/vFduGsf3LnzdtHZmcB600WO4r/7IRZkJRCgTskYiyQgT1arlI4lUROibt+26Qw+JQCYIQt5i9OH95N+mMN36O46u/7lh7Uyn08PP63dmLBdlJhChTMgaiSQjzHS5pGwgZklBEPKZ0EClsQMPGgYqmWH04a1j5Ynuebx0xx7T/RgFWKXLLzkbiFAmZI1EHqZMlkvKFv1ZEUEQBKE/CQYqdRw/x6/pYgw3ffJAVIEqFLMPbB1rzHQ/RjWT85W4M/oLQn9Qt3oCdavhbDJC44dp8Zx9LGgZFhGp6deq5e8D2Ben04Nf/joBDAAW4Ym+iSAIQtbxByqFixTBQKXvNk+Kq06xWfLtYkr3I5oyIS8oNBW1IAhCIZFq/sTFc/YFkm1HYuRXW6iIUCbkDfmkoi709B2CIMRPKr5W+UIigUpG1K2ewA8n7Y0QzIrNr1aEMkFIM0ZRRLe2XMGXqwaIkCYIRUaqvlb5QjoClZY/9zl+uv7TovarFaFMENKMURRRN4M4qlcUbI41QRCMKZZatekKVOqb7idd5enyBRHKBCHNxJOmo9ByrAmCYEwx1aoNFaj+froyLoHKiO2ztjLR0R0QsrrZPmur6bqFpokUoUwQ0ky8aToKKceaIAjGpOprVWxsn7WV+a31tDE6IGSNZn5rvalgVmiaSBHKBCHNGCXFNSJUeCsk9bsgCGeRpNCJcX/rdMPqLfe3Tjdcv9A0kSKUCUKa6Zu+YzhHGMDpsHVCKxcUmvpdEISzSFLoxGin2rC9jRpDP9xC00SKUCYI/UBo+o697jOsr/+jaY61QlO/C4IQTrp8rYqBatpNllgMA6QKTRMpQpkgZIBoOdYKTf0uCIKQLEsnvWzq/mEUIFVomkgRygQhyxSa+l0QBCFZpj03k/WTWgDdcLlRgFQyaTRyFRHKBCHLpKp+d7nsjK08I0ECgiAUBNOem0mNzW24LN7o9nwlZkFyTdN+CdQBHymlxgfa7gNuAD4OrLZIKfVyYFkTMA/wArcppX4faJ8GrANswC+UUuIsIwj4v/IAHrjXhvv4EKppY8XQh5ixPLb6PRgkEPRJCwYJPHHHLcyAvP1aFAShuFk8Zx8LWoaFRWKeDZDK3RJ7qRJTKAOeBn4GtPRpf1gp9VBog6ZpFwPfBcYBlcAfNE27MLD4UWAq0AG8pWnai0qpv6TQd0EoGJxOD3756QQwAFiEJ47t/EEC4Y9xMEjgu82TRCgTBCEv8fvdtrJy0zjavZVU2w6yeM6+nK55nA5imi+VUn8CjsW5v5nAb5RSp5VSHwDvAbWBv/eUUu8rpc4AvwmsKwhCCkiQgCAIhUq0AKlCJR5NmRm3appWD+wB7lRKHQccwJsh63QE2oCwONcO4LIUji0IAv4gAbc78jGWIAFBEIT8I1mh7DFgOf7wiOXAvwI/AiwG6+oYa+QMQys0TWsAGgCUUlRUVCTZxcQoKSnJ2LGyTbGMtRjGuXIl3NzQw8kzZx/lMrpYWXo/rFxZkOMvhusKxTNOkLEWIsUyTkjvWJMSypRSHwb/r2naRmBb4GcHhKXjrQKCNhSz9r773gBsCPzUjxw5kkwXE6aiooJMHSvbFMtYi2GcU6fCA/9q58H7Smk/WtYbJDB9+aV8NHUqFOD4i+G6QvGME2SshUgq43S57BGBT3XLL8pZH9nQsVamaKFISijTNG2UUupQ4Oe3gHcD/38R+LWmaWvxO/qPBXbj16CN1TTtfMCNPxjge6l0XBAEP06nh4aGwRw5cphEggQEQRByjWKPKI8nJcZmYDJQoWlaB7AUmKxp2iX4TZD7gRsBlFL7NE1TwF+AHuAWpZQ3sJ9bgd/jT4nxS6XUvrSPRhAEQRCEvKXYI8pjCmVKqdkGzU9GWX8lsNKg/WXg5YR6JwiCIAhC0VDsEeWS0V8Q+gGXy85l44dIln1BEAqCTM1pxV52ToQyQUgzQZ+IjuPnoGPt9Yl46Y49IpgJgpB3ZHJOS7XsXL4jQpkgpBm/T0RpWFvQJ6K8WaqLCYKQX2RyTnM6PaxZe4KqYZ9hwUcN+3l86N3MWBu77FwhkEryWEEQDCh2nwhBEAqLTM9pyZadKwREUybkPPnmn5WsT0Qq49y82ZpX50gQhPwhG35e25r2MrHG55/Tanxsa9rbL8fJNUQoE3KafPTPSsYnIpVxulx2bm4gr86RIAj5g+mcZr2nX/y8tjXtZUHLJNq8Vf45zVvFgpZJRSGYiVAm5DT56J+VjE+E2Thv734w5jibm8vDyiwFt83lcyQIQv7gdHp4ZPa/UcMBLPgYzX42cANzbM/1y/FWbhrHSQaHtZ1kMCs3jeuX4+US4lMm5DT56p+VqE+E2TiPUsFz7n/kyiS2zfVzJAhC/vCjnfNowB3e2A3lzc1pd8Bv9xqbRP3th9N6rFxDNGVCTlMsOWvMxgkWFrE6qW0L7RwJgpA9zD7w+uPDr9pmvE+z9kJChDIhpymWnDWNjZ34q5ZF0k51zG3LBvSEtRXiORIEIXuYfeD1x4ff4jn7KKMrrK2MLhbPKfzqjCKUCTlNseSscTo9jLAcM1wW6+vQ6fTw8w0U/DkSBCF7dDY24rPbw9p8dnu/fPjVrZ7Aw/Wt1Ng6/HOarYOH61upWz0h7cfKNcSnTMh5iiVnzaof7GFBy6QwB9ezX4fRJ6PZs31MnXqCQj9HgiBkh+AHXnlzM7aDB/FWVtLZ2NhvH351qydQtxr8PmRWYs2BhYJoyoScJt9ylKVCMX8dCoKQ+3icTj7avZtDHR18tHu3aOL7AdGUCTlLMHdXMFVEMP/WE3fcwgwoyAmhWL8OBUEQBNGUCTlMPuYoEwRBEIRkEaFMyFnM8m8dkPxbgiAIQgEiQpmQs5jl37IAvxr0o8x2RhAEQRD6GRHKhJylsbETC76Idh0rS07fm4UeCYIgCEL/EdPRX9O0XwJ1wEdKqfGBtuHAc8AYYD+gKaWOa5pmAdYB04GTwPVKqbcD28wFlgR2u0Ip9Ux6hyIUGk6nh/nzhxoua/dVUejlNgRBEITiIh5N2dPAtD5tjcBOpdRYYGfgN8A1wNjAXwPwGPQKcUuBy4BaYKmmacNS7bxQ+NTY3IbtxVBuQxCE3MDucjGytpZRVVWMrK0t2LQ8+UyhXKOYQplS6k9A31TjM4GgpusZ4NqQ9hallK6UehMYqmnaKOCbwA6l1DGl1HFgB5GCniBEUMzlNgRByD52l4tzFy6kxO3GouuUuN2cu3Bh3r70C5FCukbJ+pSdp5Q6BBD4d2Sg3QG0h6zXEWgzaxeEqEhCVUEQskl5czNWT3h9DKvHI2l5cohCukbpTh5rMWjTo7RHoGlaA37TJ0opKioq0te7KJSUlGTsWNkm38Z6/cYruX4jQA9++X9k9A0C5Ns4U0HGWngUyzght8dqln7HdvBgUn3O5bGmk0yOM93XKFHSOdZkhbIPNU0bpZQ6FDBPfhRo7wCqQ9arAg4G2if3af+j0Y6VUhuADYGf+pEjR5LsYmJUVFSQqWNlm2IZa7GME2SshUixjBNye6wjKyspcUf6tnorK5Pqcy6PNZ1kcpzpvkaJEjrWysrKlPaVrPnyRWBu4P9zga0h7fWaplk0Tbsc+DRg3vw9cLWmacMCDv5XB9oEQRAEIWfpbGzEZ7eHtfnsdjobG022EDJNIV2jeFJibMav5arQNK0DfxRlM6A0TZsHtAHXBVZ/GX86jPfwp8T4IYBS6pimacuBtwLrLVNK9Q0eEARBEIScIlhjt7y5GdvBg3grK+lsbCzI2rv5SiFdI4uuG7p25Qr6wQyV0ykWlTIUz1iLZZwgYy1EimWcIGMtRIplnGBovjTyo48LyegvCIIgCIKQA4hQJgiCIAiCkAOIUCaknW1Ne5lY46PK8Xkm1vjY1rQ3210SBEEQhJwn3XnKhCJnW9NeFrRM4iSDAWjzVrGgZRggCV8FQRAEIRqiKRPSyspN43oFsiAnGczKTePC2kSbJgiCIAjhiKZMSCvtXuPEef72w4Bo0wRBEATBCNGUCWml2macwiS0PV5tmiAIgiAUEyKUCWll8Zx9lNEV1lZGF4vn7Ov9HV2bJgiCIAjFiQhlQlqpWz2Bh+tbqbF1YMFHja2Dh+vDzZLxaNMEQRAEodgQnzIh7dStnkDdavD7kFmBcD+xqyYe5anWSvSQb4Kz2jTxKRMEQRCKE9GUpRGJKIyNy2Vn866LwwQyCz7qeYbrvvb3LPZMEARBELKLCGVpIhhR2OatQscaiCicJIJZH5qby/F0l4a16Vj5HdMpb27OUq8EQRAEIfuIUJYmJKIwPg4etBm2t1GDLUPF5wVBEAQhFxGhLE1IRGF8VFZ6DdtraMNbKedKEARBKF5EKEsTElEYH42NndhLu8PayuhiRel9dDY2ZqlXgiAIgpB9RChLE/Hk5xLA6fSwZu0JqoZ95k+ZwX4eH3o3M9Z+FY/Tme3uCUJWCQ0WGlv2kfikCkKRISkx0oQ/D1crKzeNo91bSbXtIIvn7JOyQQY4nR788tcJYACwCE92uyQIWUfKjwmCIJqyNFK3egJvtFnpcB/mjTarTKSCIMSNBAvlNnaXi5G1tYyqqmJkbS12lyvlfeZKGqVc6YeQoqZM07T9QCfgBXqUUl/VNG048BwwBtgPaEqp45qmWYB1wHTgJHC9UurtVI4vCIKQy7hcdh6414b7+BCqaWPF0IeoW36Roak+erDQ4X7uaWFjd7kob27GdvAg3spKOhsbE3KXsLtcnLtwIVaPX6df4nZz7sKFAEm7XeSKZjRX+iH4SYem7Eql1CVKqa8GfjcCO5VSY4Gdgd8A1wBjA38NwGNpOLaQ47hcdi4bP8T/BeY4w85xq9LyhSkIuY7LZWfhHUPoOH6OP3chY7jpkwd46Y49hs+ABAv1D0GBqsTtxqLrvQJVIvNQeXNzr0AWxOrxpJRbMVc0o7nSD8FPf5gvZwLPBP7/DHBtSHuLUkpXSr0JDNU0bVQ/HF/IAkbC17amvQm9lAShkDBKlHySwSzpvs/wZS7BQv1DOgQqsxyKqeRWzJU0SrnSD8FPqkKZDryiadp/aJrWEGg7Tyl1CCDw78hAuwNoD9m2I9Am5DlmGoFFLZcm9FIShFwiGS1v6DZud2KJkutWT+Dh+lZqbB3+yGRbBw/XiwkpVVIRqILX06b3MIYP2MTssOWp5FbMFc1orvSjP8hHS02q0Zf/oJQ6qGnaSGCHpmn/GWVdi0Gb3rchINw1ACilqKioSLGL8VFSUpKxY2WbdI/1wQdL8XSHX96TDOYkZYbrB19K/X2+5ZoWJkqVsPj2c2g/WkY1bawavpZZay/FN3t27I3jZPNmK3ffCSfP+KfI4IfGhjtuZVZ5ueGx+m5jRg1tUF1teL2u33gl128E6KGkpJKenpER6xQi/Xr/VldDW5the7Rj9r2eBxhDAxsBmMNm9LIyWLky4X4Hx7pi3pvctGFYmOmwjC5WzHufiorLE9pnKvRXP7I9JyXzDCdLOsdq0fUIuSgpNE27D3+OgxuAyUqpQwHz5B+VUv+PpmlPBP6/ObD+fwXXi7Jb/WCGSu9UVFRw5MiRjBwr26R7rFVVo9B1M5k7sn00+3nPMYmPdu9OWx+MkGtaeLhcdu6+szxM8CmjiydKb0lrrrva2pG43ZHCVbR712ybUBLpa7FcU0jfWLc17Y1IS3Td1/4e5qQP4LPb+XTNmqjXINo98IHti3zyyCNJ3W+hYzXqb6Y1o9ua9tLUcinHGAHACMtRVv3gPyL6sX3WVu5vnU471VTTztJJLzPtuZmm+832/ZvMM5wsoWOt9GtPjV6IcZG0+VLTtMGappUH/w9cDbwLvAjMDaw2F9ga+P+LQL2maRZN0y4HPo0hkAl5glnpJP99GS70S/Z+IRWam8sjNFH9YRJPpkar2Tag51Si5Hw06cRDMIqwzVvld6PwVnFTy1SGz7+F8z1/YZNlDjrQ43DEFMgg+j2Az5eWa5jtNErBc3aMCvzztQWPbo9Yb/usrcxvraeN0QEXldHMb61n+6ytEevmCvlaZzkVn7LzgFZN0/5/YDfwklJqO9AMTNU07e/A1MBvgJeB94H3gI3AzSkcWwgh25NsY2MnBpboAMEPBp0RfJwTLyUhf0nnRBstN1MyNVrNthnNAc44anjDPYAp+xZlXSAr1OAboyhCHStgoY0xNOhPsKl0rmk6jL7z6HCOGR6nhjZ+de7NBSHYmkVe3twyJWxM97dON1zv/tbpGetrouRrneW0mS/7CTFfxiA4yYY61McykfTHWMePP4/jx800BX6G8zHvrX8uYy+lfL2myVAsY02XSaJvbibwPzdBx/pknqtktolGf1zTRM5fJk1r6RhrlePzASHMHLP7xOjaWTmDj1LCLVE6U9jBa5bJnNEH9LYO4DRPlt6Yd2bpaOcs9N4dMf9mw/Us+OhwG+fQy/Y40/08RiMnzJdCbpBo2H1/sWzZZxGFxvtyjAqJuhRSorGxk7IBPWFtyZjEY+VmilWj1UjLlg91XePVNBqZAhe0TMrpTO/xRAseoAab2x3RbjSP+hhA5LvVwqtMCRPIAM4wkNu7H8y7+S3aOQt9jwznqPH2YQkVcot8eB6NkNqXeU6u2M0HvLUbe89X8TA80GL8oZDLtnwh93E6PZSXl7NkwWdhWfJnLE9soo0ne75ZjdZoGdCdqyfkdF3XYWWnONYV6TNkQWdTST3fCPyOJrTWrc5AR5Ng8Zx93NRSGVVbZgF+zfeY7nKF3S/m/oCR+Ez2f5SKvJvfFs/Zx4KWYRHXOkgbNTznvoLPODdi2QBOc/+FT+OP7ctN8rHOsmjK8pxcsJvfM+tjbmqZyjF9BEFnUSNGcCSnbflCfjB7to9d757wO0cn6aeVSm6mVDKgZ73G4MmThs0+bNzY/Wiv43YyCUWzNbagL9hNLVPRY1iNdKzM5Rm2LXwnrN08WMkI82Pk2/wWzI1no8dweQ1tLLI9QDcDIpaV8xnf79rY311MmKw/YykiQlme09jYGWE2zGSEo8tl56nWCTF9OQZwmkdK75KoSyEnSCV7frIZ0HPBJHhcH2a6LNRxOxGh1eWyM+H8IdzYcnXGx9Y3cCEeVx4vJczz/CwsctBoHk2U4RyJmN9iCQjZDtICv2B2Q+lTWPCFtVvwMZ1ttHuNc7wfY0TOaQaNnrFbW67gy1UD8kZIE6Esz8m23by5uTyKQHY2FcAvht6Z87Z8IXFy4aWSDKlkz09Wy5YLNQZj9bGdaiB+oTUoFB07cw59BaJkx5aIpsPIFyweuhnEXa3f6b1XQ+dR8GEeTW5MKad4cNILYfObmYBQec5pqhyfZ4KjlDvnl2U9EnZb015aupwVL3EAABuESURBVL8XMY/rWHmGHzJs8CnD7XIxitHoGetmEEf1irzxjRShrABwOj0pm3OSJZovRg0Hwvr0/Ftj81qtLIRjlF6h/pP1DJ9/C192lOZ0DiOIL0eU3eViZG0to6qqGFlbi93l4uoL/hqhVYhHy5bNGoNB4bnNWxnR91Cs+Ng5bhXXfe3vPFzfynCO4BdQdOyWSG+cWEJRomNLVJsY3RcsumDVN/DI6fRwzz+9gdUk6bUZFnz8I3/i/tdnhM1tpgLCaf+H7DE+xxkGhi1PNEgrGVNd320WPXupqU/ZSQZzuqsbu+10WHuu5puM537L9WLrRS2Uhd6cY8s+SllIyFetQSr9NvPFsOBjhX1F7+9tTXu5teWKiK/GXH9xC+YYv5D9PoVH+Rz/0vqjvL6+dpeLcxcupMTtxqLrlLjdvPTjXfz6b/8zTKtgwcf3Lnw9ppYtmobN6Bm0bt5suH48L+LQ/YVqZMAa6LuxwOKlpFdbU/L++5zCTu811Su4qWUqjsBxl165z7S+Z6wxm5GoNjG6L1hsweo291mhIjhH+Yjf6R/8GqWdTKXNVxMmSLYlKWzHG6SVjDncaJuj+oiox+minLn6U1QPPpLzUYzx3m+5XGy9aIWydPt39GdSxniFpmQLKBtpO8bOnxXXC9XIF8OCjxt5nLo1l/S2NT37VboZFLZeXxOCkF/Eilg7w8CcTi4ZipGgU97cHFaaB2CJb7lhgtJX/vtLMY9hZhK8auJRFt4eacZ67oY/RjwbRh83N7ZczZcdpb3Pe99n2kgjE01gOclgftD9FA2tN5gkY/Uf9xd/uyrqfszMnWZzlMtlp83Ef8nsJZqaL5iFx7m5d85f9OylEXNUIvsK5SSDsUXRSEYjHrPgtqa93NwyJWFzuJHQG1t4tfC879u8P/SSrFhjEsHoGTMil4utF23y2Ik1Ptq8VRHtNbYO3mhLXFbtrzpb8SbAM1uv3vosL9m/Q0fX8N70AbMf+RofTZ0atd9+dMM6aH2TSl418Siv7Ds/LEVB3fKLwh5ah2MUZjXpux3V/VIHM9vJCzNJcKwul50H7rVFvRbpIp5aj9GSSyZLuq+rWSLZDYFQ/x+zjqOEFhuOvI/jHadRQtblv50Y0GKFEzp3BK9rx/Fyw+MH+6ADNnx4s5rtSGcER1gz6YWw2ojR5jL9hz/ixqcmmppCoyWedrns3P7jc/H6ktMx1LCf6aU7eLz7n0kh56cBvkChufj7VUYX9TzDy9Y62n1Vhkl7je7XUKLdi/Ek2DXGLyfUcCDuOSVb8294Lc/I6xmaJDpdpDN5bNEKZWY3Z7IvEbOi3BZ8eC0lHOroSKqfZi8+Gz34sPa+eBdZVhlO7P6J+uw4y+hiQ+mtTF97KR6nM0oxccK2Cd7EsTKhmxFNKPNZbEmfn2gUm1C2YUNXVAF+E3PSKrAZvWT7MpyPGWI7Tbu3kmGW41gGDODY6cFhx3/+rbEJZY5Px3UNFV6tJkLMcD6mk/K4tCd9n8fQ89pXEFs68bfMfXcRv/nkGhaxijZGYyboeS0lPPrTozHPc+6g0zJ0vuF9ZTaXjeBjPmFYVEFyACf5PB/RTk3EPbKtaS9Nz36VY/pwknsXBt+B6RTIwB8wYA37XYKXHs5ex1JOcQ6dHGME1bQx3fp7Wnzfjzq/mikUgkRTLETfNr7zEG9W/GzOv2bjtNHDz+t3pr0yhQhlaSBTmjIbPTxlv4kp7y2Le1+hk7geJe9XkDK6OElZzPWChH6Bx6PtAKixtPFGR0nS523ChcMMk1aO4GMOO74imrIUqaio4AtfsBpeSws+buIxnrb9Mx7vWTNWOkqOuFx27r17IMdPBn2PzmKjGxs+A9PZ2ePX8wwtzO3z1e/XtDw89H7Dl3s819XuclHe3Izt4EG8lZVh9Q6bms7h2ZbBMXNaEbfDd/h6oef1+bfGGn7ETKSVf2NqVK3FaPaz3L6CH3oez7LmK36izQPmH4DxnOe+6/jfW4PppJuBfe4xs/0l5sCfGsbHGsxnVHCMNmqooY2VLGIOZ30HR/MBbYyJ2C70vMYqjRTtA3lb015ubLnasG8AFnrQsZkuP9vP2BagbM6/ZkqA/tDcg5RZSgup5Ckywsy3wUsJN3nWxfRVc7nsjB87FIdjVFi+n3iurZka24wDjOYCdyvbmvbGKCZ+lja9CrvLZerb0eZ1RPVju7/5FAOs4edHcpelFzMfLx0rj3FzmEAG5pFeiUR0OZ0elj1wmmFlHoJResE/HzZTgSx4/I00GPq4HOVzSftkbp+1lUvm11HqbsOmd1Pqbu+NCF3+xVfiFMjiQQ9EMkb6E93e/SDbFr5j6vezk6tjmJF0jjCcf/Y8mnWBzJ9YNPYcEWv+NHfKj+daRJY7AgtdnJOAv1zweiVO4tsZ96GLcvZzPj5srGQRi1mFFS8VfMQQPg1oTSNp81Yy4fwhOByjTO9dGz0xLRbXfe3vTGEHZtdTpwRLPO+DDFeMSQSXy246hmpr+i0y6aZoNWWQ/oK7TU3n0NIyGKMHssbaxl3ryg3NR5uYwx0/Lqfbl+rkG/511td02ZdSTnHOwG6Onh5i2OdQbPRwyjGGCw6/GVV1Hk37kkl/JxBNWTz0Na8nap52uezc+eMhnPEla1qLrr0IaotuP/VAwDzlrwxxnf0lXrLW0d41POBDZe39N1pViXi1Jf5nJ7aWOrpWhriOldvoWPEFSgtFjqXXbBvH/HnPrI/5ZeuX++wnc9qr4L1U79mY0DHL6GIuT6GYFfAtTKW/Or9iDv/O/+RxjIt8G9PXFBrZR6NnNOwdZ+lglWUxc3y/MvyYCO2jBT2mFjdXNWVm1h8LPlpKf8Q39q9K+zHFfNkPpOMGim4K9GEv9Rr6+zQN+amhP5gx0ScxC16Dhykdk54Pn6WEhrG/58m/TUn5gc0ExSaUbdjQxfz5Q0nkegev1eONe03NkH50bHjxYqUmJLgjmuN5fMR6KevY6MFLX6GvP17moXNhvgtT/Y/fLP5zHrlwPUdefTVs2fZZW7m/9Rq/RiUgLFsD2tNsEBq48X02EZ+wDaM50Gti3MRsfsgvU4jQ9FPKKboZGEcfQvsS7SPDT1+Tv3FAQDz3uM5gOunC+NnOdZ8yczO5Dx82Plm/Pu2KABHK+oF03EDRnOb9Lxbj6Mw2apKMiDGif748g1+ZN3nWxTSXphrckC6KTSg7cuQI1Y7zEnjxhWpBILH7Jp33WSZ9fZLtQy70MRfxvz+CAvtwjnGaQXRhbDHIBkHh8efMD8y3xibCs+j8C4/yc+aHtY7hAw4Y+HvlFsFn2pKCEBzpvxfcZ00CFo5c05TZ6OEZ6pnl+FPaFQbiU5ajREuk6jV5ONqooZq2NPaiPyZCnRWl97Hk9L1x+a/lYvmNYuH6Se+SSIkYX69Tb6L3TTrvs1x4ecfO1ZRo6Z3cx0cJqdV7DN47/g9OK8eooIvY7hCZRMfKy9Shc7aMVHQsvExdn3345+rcxxJ4pq1JCmRGZk0LlqAnm60Ez//6p5zMURbkm+fvw+hZ9VJCAxt5zv2Pme9UAohQlkaiJVKtGtZpuE3wy6PU2pOJLibFcI4wY+1XafeZ+5IFydXyG8XC8uc+x48m/Zn46vflzoszPwSeXDpfqWGjh19Z6vlnyy/Ij3OfGkGBKt6koX0FMK/DkdMJR1PDHwAxmv2ma3gpyZvakX94wzg/GfiDbBaxOrMdShARytKIUXHwZ4bexqr1Pu5e5o0Q2IICTN3yi1i7Lr4oyExTRher69/G43SaTko2esj18hvFxGVfOByYkvJJiMinvuY/Pqx8j1/zMjMohnNfQxvYbHFnfB/O0d7/6xYLnY2NcW+bb9jw4sPGB5Yv+M9TDE4ymJW/il3BIlvEKqEUn7Y0e2Q81lrTtGnAOsAG/EIpFV/l1TzB6fTgl0dOAAOARXgAJ/5yLX2jD2cs9wswTjw0N5cnHD2XHoz9ZWz08Lj9x0xZ7c+xtnjOPha0DIsSmXd2vEL2WLlpXBp9FM3IRx+rfOxzKOH9L+UUAzgTcMgmZsRcKEEXg3Z3bO139kjP9Sqji5UsomvOnMA81crNLVPiSjWiWyx0/eAHeJxO6pwArb3RjMMsxxNMWJvuiNz0nB8vVnSrlU/WrWPxW//FgpbPxXRT8VtN0p/vK1VcLnsgGbT5c1BNG3bXtpxVHGRUU6Zpmg14FLgGuBiYrWnaxZnsQzZxOj3seveEaf2wxsbOuHLEpELffDtldHGT9QnsttMR7U+X/nNY/cq61RN4uL6VGluHXzNm60h7uQohdTJRbDfR+zTZ/FCxyTXtcir90SnhjOk+RnCE0ew/q5We9BR/c5/A7T6E230o7qOEuhjENsnFYwZPJ/4cdyP4mH/h0RjHDl/mv8d8jOBjRvBx73naQAMz60v5bLXfbFW3egKPrO+MmPNCOcYIehwOPvnpT3u3C277RpuVDvdh9naYb2+EDS/p/CgYzlGGW45yNjdgcoymDXTdL3gG53gORN1nev2g00Owwkg0YduCjxls45x77slgzxIj0+bLWuA9pdT7SqkzwG+AmTG2KRqcTg8/qO9KQTA7m7hzICf5v+2df5RU5XnHP7MDS3fBNGFTjK4MaKoRE6P5cahtiC3SGI2caGnmScCCWgsJtTZtPPVAjTU1ioqm0YMmihjWLQ36xGCb2DaBcqLkhBgVT1rSYGytBFipG0NQEArLzO0f7zvLzO7M7NyZu3fv7jyfc+6ZmTv3vff5vr/uc9/3ve/bymBH66pZ28l0HCzpblxxzzFW3n2opNu1UjdkcaX0w10t5pAlkKFutClypAcN8A5XsVebfLWc43/1GZv7nXk3GWntV6psV8AcNjE5vX+I45wNHVR6E2xguIIjEtBCrur1i0mRZxLlx46WD1uICzeeZx2X08cE5rCxzDUDhEf7Jx59qXNWybqSUD3dCw5Lhp2sTn2ay+a7m3D5LjmnPcNO1p7xxQr21EptcXfcTtfa9xpT+ArXVkyzFnIs5T4yBSc1vYc1sx6grzPDL1In8r+d7+OXq77CD3tamd1zZ4ljBX6oyd2HKubFqelX6H3mmSFbUzLpnqr/F2jnzSqtN+HjNkWe2xZtY/ueI/T07OWBRRvJpPcQ1okutCIWv5g197az2Zk6lWn8vOK1b2m7JbTNw83tt59QYSmyoOhbCw9zFY/svzj0pNSxEQRBbFs2m/1ENptdU/R7YTabvXfAMUuy2exz2Wz2uSAIgiNHjsSy5XK52K411NbV1RdkOg4EKXLBZHqDNEcDCAZs+ZLf7RwM1o2/Mujr6uo/T/eSp4JMeneQIhdk0ruD7iVPJU5rs6RpnFq7lzwVtHOwTJ5x+eQzs38atLaU5qlW/i9Yyn3BZF4blLfCbClywWdmbC6b72qxbzyHg44Jb7iwvBysm3xt0D37wUHHp8gFS1sfLMnvA8tNB70lNqxj/qDztHMwWMqqINOy6/g1Jy4uLUcVrj8ntSnITHrteDjmB+taryyjrUxZbfmjIN/aWjYSp/Fy2biZxstBAEG+vb3Evurxmg866A3WMb/kZMXnKKkn2BmsY36Qz2T6/+/r6gqWpu8P0vR5LQPzR+X8MpneYDK9ReGcPR30VtUYQJAfP75s3LdzsF9PPpNpqNyUi7N2Dg7Ks2HCp8gFkPPxlQsyLbv647hSHA1Ot1xJnJUrY5VsqnSdgVuaPpfWZfJTPpMpW15S5IKl3Fc2/410/ZtK1V5vTePlhvNOJa2esj5QLVus85SJSBb4qKr+if+9EJipqtdWCDKq5ikbLkoX3C2d0XzPm5NDz46fZK1R0iw6YbDWwkzeu3In90/emfGzrt+8eU7ZsYvFE8nedF2afUdPKPq3tlnwrz5jM3/7vXcPeWw1+8q1vkax+saUmTN5tOd8bmBFydqDtcxbFOb6Jceyi0t4gn9hbv/0N7e038rcO84B4C033kjL/v0lsdtSdgJoF79HOzMl63gOpDBp6+4ifQtSj5AqU88f6+ysa76mgXFx4Tt38PCLHx40qWorR1i16MmSeCqsSfpoz++yhNWDxqeuZjELWE+us7Nf5xPLt3Pr389gd3BKyXqR+bY2Xl+5suGxQY3mrVrDV1otY9WsbiZs3coN+S+W5Mv5E7/F67ffzjeePT2UfZUnjS1dn3U1i/lk55ay+altwwZ+/frrWX/4sv7yUpx3k3ifqXUdZ4h+Ls1RO3msiPw28AVV/aj/vRxAVSu9o2pO2TDQLFqbRSeE01ppkuNKFVXx8liVlx5yy8fM7rmrDuvDUW+6Fm40LYePv4oS1Y292jUrLYxe6Zh37t3KrvzgObGqLfZd7Xzpnp7yKZZKRXZTemL5dpZ3f4B9dADQkfolKxZuq+o8bNjQxspluf4HyxWpz3PpwvSgrsYCtcRl0qnkwEWtrZzjvPGlGaEcz0Ztirv+LYwpK+7CrLTUYNSrzoxmp2wc8CIwB+gBngUWqGqlVWzNKRsGmkVrs+iEcForPVHWUlE1EjYqGknX0XBjD7v+6FBMmTmTcT2Dxz7V21I2HFhZHXuMhM6B6yt/bPwmuvsWDCpLtSwTFYZRO6O/qh4D/gz4LrDD7arokBmGMQyUm+S41kl/GwmbBA7Pm0fvM8+wd8+emgZyjwRRv+V8YNky8m1tJfvybW2jIr0MIwwDZzi4cecl3LHqaE0vsSUFW/vS0yxPL9A8WptFJ4TXOvCJMsyYxEbCRkGzpGuUOpPeQtgsaQrNo7VZdEK0LWUjMVOpYRgjTKVJjoc7rDEyHJ43L1FOmGEY5bFllgzDMAzDMBKAOWWGYRiGYRgJwJwywzAMwzCMBGBOmWEYhmEYRgIwp8wwDMMwDCMBJH5KjJE2wDAMwzAMIwSjY/LYOkjFtYnItjivN5Jbs2htFp2mdWxuzaLTtI7NrVl0VtBaN0l3ygzDMAzDMJoCc8oMwzAMwzASgDllx1k90gbESLNobRadYFrHIs2iE0zrWKRZdEKEWpM+0N8wDMMwDKMpsJYywzAMwzCMBDCmFyQXka8Bc4FeVX2P33cOcD8wCdgJXK6qb4jIeGAN8H5cvHSr6m0i8mvAFmCC3/+Yqt4Uu5gqRKTzXcCjRac9DfgbVb07PiVDE1JrK/AA8EEgD3xWVZ/0YW4FFgFvU9VJcesYigh1PgmcBP1rhl+oqr3xKRmaCLV+ErgBSAP/rKrXxyylKiIyFegG3oGzfbWq3iMik3FlbzpOq6jqr0QkBdwDfAw4BFypqs+LyDRgA07neGCVqt4ft55qRKh1NvDlolOfCXxKVf8xNjFDUIfWM4G1uDr4BlW9q+hcg8pCUohY507gAJADjqnqB2OUMiQRa/0ssBj3VuaDQ91Tx3pLWRdw0YB9a4Blqno28DjwV35/Fpjg938A+LSITAeOABeo6jnAucBFInJeDLaHoYsGdarqz1T1XFU91+8/5MMljS5q17oYwO//CPAlESnk+W8DM4fd2vrpIhqd4Byac/2WKIfM00WDWkWkA7gTmKOq7wZOFJE5cRgfgmPAdao6AzgPuEZEzgKWAZtV9XRgs/8NcDFwut+WAF/1+/cCv+PL6m8By0Tk5Phk1EQkWlX1e0X10gW4emljrEqGJqzWfcCfA3eVOVcXg8tCUohSJ8Bsn7aJcsg8kWgVkffg6qyZwDnAXBE5vdqFx7RTpqpbcJFVzLtwLV8Am4A/9N8DYKKIjAPagKPAG6oaqOpBf8x4vyVqIF4UOgeEnQO8pKo/Hx6L6yek1rNwBQfvjOzHtbCgqk+r6t5hN7hOotI5GohI62nAi6r6C3/cvxWFSQSquldVn/ffDwA7gE7gUuBhf9jDwGX++6W4luxAVZ8G3ioiJ6nqUVU94o+ZQALr8ai0DjjtJ4B/VdVDwy4gBGG1qmqvqj4L9JU5V7mykAii1Jl0ItQ6A3haVQ+p6jHgKeAPql07cYU5Bn4CfNx/zwJT/ffHgDdxT6G7gLtUdR+AiKRF5MdAL7BJVX8Ur8l1EVpnEZ8C1sdhZERU0vrvwKUiMk5ETsW1AE4tE360UK/OtSLyYxG50XcTjQbCav1v4EwRme4fOC4jwWntW+HfB/wIOLHwgOA/p/jDOoHdRcH2+H2IyFQR+Q///x2q+kpMpoemUa1FJL5eqlHrqCcCnQGwUUS2iciSYTM0AhrU+hPgfBHpEJF2XPd81XqpGZ2yP8Y1RW4DTsC1FIFrXswBJwOnAteJyGkAqprzzeenADN9k2TSCa0TwI/Z+TjwjXjNbYhKWr+Gq9yfA+4GtuKapUcr9ei83Hf1fdhvC2O1uH5CaVXVXwFLceM9vo8b75HItBaRScA3gb9Q1YGt1MWUc6ADAFXdrarvBX4TuEJEToze0saJQqs/z0nA2cB3o7UwOkJoHdVEpPNDqvp+XLf1NSJyfmQGRkijWlV1B3AHrrX/O7iHyqr10pge6F8OVX0BuBBARM4ALvF/LQC+o6p9QK+I/ADXLfI/RWH3+4HTF+E84MTSgM6LgedV9dWYTa6bSlp9c/FfFo4Tka3Af42EjVFQj05V7fGfB0Tk6zinvDtey8NTp9Zv48YK4p++c/FaPTT+RZtvAv+gqhv87ld9t+Re73wUxv3tofSp+hSgpEVMVV8Rkf/EOdyPDa/14YhYqwCP+3orcYTUOmqJSmehZVdVe0XkcVy9tKV6qHiJUOtDwEP+nCtweb0iTddSJiJT/GcL8HncG17guvIuEJGUiEzEDe57QUR+Q0Te6sO0Ab8PvBC/5eEIq7Mo6HwS3kUwkEpaRaTda0REPoJrUfnpiBnaIGF1+i6+t/v943FvdSX6YaJAPWlaFOZtwJ/iXhZIDL7r+CFgh6r+XdFf3wKu8N+vAP6paP8iX1bPA173N4NTfF1U0Poh4GexiKiRqLQWhUtsvVSH1lFJVDpFZKKInFD4jnv4SlS9FGWaFtVLGWAeQ+TjMT15rIisB34PeDvwKnAT7hX7a/whG4Dlqhr4Zsq1uIHEKWCtqt4pIu/FDehL45xYVdWbYxUyBFHo9Odpx43rOE1VX49VRI2E1Dod192RB3qAqwsvL4jISlyr4cm4J/I1qvqF2IQMQRQ6fYW3BfdySho3+P1zqpqoFqQI03Q97g0ngJtV9ZG4NNSCiMzCda1ux9kP8Ne4sSoKZHAPTVlV3edvDPfiWuYPAVep6nPeGf0SrnsvBdyrqomaPT0qrf5c04EfAFNVNU/CqEPrO3Dd72/xxx8EzlI35cugsuBbWkacqHTitBXe7B8HfF1Vb41LRy1EnKbfBzpwLwF8TlU3V7v2mHbKDMMwDMMwRgtN131pGIZhGIaRRMwpMwzDMAzDSADmlBmGYRiGYSQAc8oMwzAMwzASgDllhmEYhmEYCcCcMsMwDMMwjARgTplhGIZhGEYCMKfMMAzDMAwjAfw/Z+V6tuB6E6AAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "plot_var = 'swir1'\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "x = pix.get_index('time').to_pydatetime()\n",
    "ax.plot(x, pix[plot_var], 'ro', label='ARD')\n",
    "\n",
    "x_re = pix_re.get_index('time').to_pydatetime()\n",
    "ax.plot(x_re, pix_re[plot_var], 'bo', label='ARD-RE')\n",
    "\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, resampling to 16 day frequency in this example data only affects observations post-1999 when there were two satellites acquiring data.\n",
    "\n",
    "This resampling would also help achieve consistency for pixels that are in the overlap across Landsat orbit paths. By carefully picking our selection criterion variable, we can help remove some amount of noise due to clouds or cloud shadows. The resampling process can also reduce the impact of BRDF effects by consistently selecting data from one view angle over another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CCD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the data resampled, we can compare the performance in CCD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The example data CFmask data have been converted to old Fmask format\n",
    "params = {\n",
    "    'QA_BITPACKED': False,\n",
    "    'QA_FILL': 255,\n",
    "    'QA_CLEAR': 0,\n",
    "    'QA_WATER': 1,\n",
    "    'QA_SHADOW': 2,\n",
    "    'QA_SNOW': 3,\n",
    "    'QA_CLOUD': 4\n",
    "}\n",
    "\n",
    "ccd_vars = ('ordinal', 'blue', 'green', 'red', 'nir', 'swir1', 'swir2', 'bt', 'cfmask')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/games/conda/conda3/envs/resample/lib/python3.6/site-packages/ccd/models/robust_fit.py:96: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n",
      "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n",
      "  beta, _, _, _ = numpy.linalg.lstsq(Xw, yw)\n"
     ]
    }
   ],
   "source": [
    "detect = ccd.detect(*(pix[v] for v in ccd_vars), params=params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/games/conda/conda3/envs/resample/lib/python3.6/site-packages/ccd/models/robust_fit.py:96: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n",
      "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n",
      "  beta, _, _, _ = numpy.linalg.lstsq(Xw, yw)\n"
     ]
    }
   ],
   "source": [
    "detect_re = ccd.detect(*(pix_re[v] for v in ccd_vars), params=params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb8d8215ef0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "plot_var = 'swir1'\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "# Original data\n",
    "x = pix.get_index('time').to_pydatetime()\n",
    "ax.plot(x, pix[plot_var], 'ro', label='ARD')\n",
    "\n",
    "for model in detect['change_models']:\n",
    "    break_day = dt.datetime.fromordinal(model['break_day'])\n",
    "    ax.axvline(break_day, c='r', ls='--')\n",
    "\n",
    "# Resampled data\n",
    "x_re = pix_re.get_index('time').to_pydatetime()\n",
    "ax.plot(x_re, pix_re[plot_var], 'bo', label='ARD-RE')\n",
    "\n",
    "for model in detect_re['change_models']:\n",
    "    break_day = dt.datetime.fromordinal(model['break_day'])\n",
    "    ax.axvline(break_day, c='b', ls='--')\n",
    "\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, resampling the data did not change the result of the CCD break detection modeling."
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}