diff --git a/notebooks/05.0-mc-leaderboard.ipynb b/notebooks/05.0-mc-leaderboard.ipynb
index b858019..018fbd5 100644
--- a/notebooks/05.0-mc-leaderboard.ipynb
+++ b/notebooks/05.0-mc-leaderboard.ipynb
@@ -14,14 +14,15 @@
     "\n",
     "In this notebook we are going to tackle a harder problem: \n",
     "- predicting the future on a timeseries\n",
-    "- using an LSTM\n",
+    "- by outputing sequence of predictions\n",
     "- with rough uncertainty (uncalibrated)\n",
-    "- outputing sequence of predictions\n",
+    "- using forecasted information (like weather report, week, or cycle of the moon)\n",
     "\n",
-    "<img src=\"../reports/figures/Seq2Seq for regression.png\" />\n",
+    "Not many papers benchmark movels for multivariate regression, much less seq prediction with uncertainty. So this notebook will try a range of models on a range of dataset.\n",
     "\n",
+    "We do this using a sequence to sqequence interface\n",
     "\n",
-    "https://medium.com/@boitemailjeanmid/smart-meters-in-london-part1-description-and-first-insights-jean-michel-d-db97af2de71b\n"
+    "<img src=\"../reports/figures/Seq2Seq for regression.png\" />\n"
    ]
   },
   {
@@ -49,14 +50,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 225,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-10-27T09:14:06.880212Z",
-     "start_time": "2020-10-27T09:14:05.387731Z"
+     "end_time": "2020-10-29T13:16:38.278892Z",
+     "start_time": "2020-10-29T13:16:38.196606Z"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    }
+   ],
    "source": [
     "# Imports\n",
     "import torch\n",
@@ -66,10 +76,11 @@
     "import torch\n",
     "import torch.utils.data\n",
     "\n",
+    "import xarray as xr\n",
     "import pandas as pd\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
-    "plt.rcParams['figure.figsize'] = (12.0, 3.0)\n",
+    "plt.rcParams['figure.figsize'] = (10.0, 2.0)\n",
     "plt.style.use('ggplot')\n",
     "\n",
     "from pathlib import Path\n",
@@ -1651,11 +1662,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 36,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-10-27T09:14:12.003600Z",
-     "start_time": "2020-10-27T09:14:11.917828Z"
+     "end_time": "2020-10-29T04:31:14.030628Z",
+     "start_time": "2020-10-29T04:31:13.125851Z"
     }
    },
    "outputs": [
@@ -1667,12 +1678,14 @@
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
-      "  and should_run_async(code)\n"
-     ]
+     "data": {
+      "text/plain": [
+       "96"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1686,7 +1699,8 @@
     "num_workers = 5\n",
     "freq = '30T'\n",
     "max_rows = 5e5\n",
-    "datasets_root = Path('../data/processed/')"
+    "datasets_root = Path('../data/processed/')\n",
+    "window_past"
    ]
   },
   {
@@ -1698,19 +1712,60 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 264,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-10-27T09:14:12.090684Z",
-     "start_time": "2020-10-27T09:14:12.009300Z"
+     "end_time": "2020-10-29T13:29:14.460346Z",
+     "start_time": "2020-10-29T13:29:14.371348Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    },
+    {
+     "ename": "AttributeError",
+     "evalue": "'dict' object has no attribute 'targets'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-264-921cceea9551>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mds_preds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtargets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m: 'dict' object has no attribute 'targets'"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 248,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T13:22:44.376665Z",
+     "start_time": "2020-10-29T13:22:44.288723Z"
     },
     "lines_to_end_of_cell_marker": 2,
     "lines_to_next_cell": 0
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    }
+   ],
    "source": [
-    "def plot_prediction(ds_preds, i):\n",
-    "    \"\"\"Plot a prediction into the future, at a single point in time.\"\"\"\n",
+    "def plot_prediction(ds_preds, i, ax=None, title='', std=False, label='pred', legend=False):\n",
+    "    \"\"\"Plot a prediction into the future, at a single point in time.\"\"\"    \n",
     "    d = ds_preds.isel(t_source=i)\n",
     "\n",
     "    # Get arrays\n",
@@ -1720,18 +1775,16 @@
     "    yt = d.y_true\n",
     "    now = d.t_source.squeeze()\n",
     "    \n",
-    "    \n",
-    "    plt.figure(figsize=(12, 4))\n",
-    "    \n",
-    "    plt.scatter(xf, yt, label='true', c='k', s=6)\n",
+    "    plt.scatter(xf, yt, c='k', s=6, label='true' if legend else None)\n",
     "    ylim = plt.ylim()\n",
     "\n",
     "    # plot prediction\n",
-    "    plt.fill_between(xf, yp-2*s, yp+2*s, alpha=0.25,\n",
-    "            facecolor=\"b\",\n",
-    "            interpolate=True,\n",
-    "            label=\"2 std\",)\n",
-    "    plt.plot(xf, yp, label='pred', c='b')\n",
+    "    if std:\n",
+    "        plt.fill_between(xf, yp-2*s, yp+2*s, alpha=0.25,\n",
+    "                facecolor=\"b\",\n",
+    "                interpolate=True,\n",
+    "                label=\"2 std\" if legend else None,)\n",
+    "    plt.plot(xf, yp, label=label)\n",
     "\n",
     "    # plot true\n",
     "    plt.scatter(\n",
@@ -1742,20 +1795,21 @@
     "    )\n",
     "    \n",
     "    # plot a red line for now\n",
-    "    plt.vlines(x=now, ymin=0, ymax=1, label='now', color='r')\n",
+    "    plt.vlines(x=now, ymin=ylim[0], ymax=ylim[1], color='grey', ls='--')\n",
     "    plt.ylim(*ylim)\n",
     "\n",
     "    now=pd.Timestamp(now.values)\n",
-    "    plt.title(f'Prediction NLL={d.nll.mean().item():2.2g}')\n",
-    "    plt.xlabel(f'{now.date()}')\n",
-    "    plt.ylabel('energy(kWh/hh)')\n",
-    "    plt.legend()\n",
-    "    plt.xticks(rotation=45)\n",
-    "    plt.show()\n",
-    "    \n",
+    "    plt.title(title or f'Prediction NLL={d.nll.mean().item():2.2g}')\n",
+    "    plt.xticks(rotation=0)    \n",
+    "    if legend:\n",
+    "        plt.legend()\n",
+    "    plt.xlabel(f'{now}')\n",
+    "    plt.ylabel(ds_preds.attrs.targets)\n",
+    "    return now\n",
+    "\n",
     "def plot_performance(ds_preds, full=False):\n",
     "    \"\"\"Multiple plots using xr_preds\"\"\"\n",
-    "    plot_prediction(ds_preds, 24)\n",
+    "    plot_prediction(ds_preds, 24, std=True, legend=True)\n",
     "\n",
     "    ds_preds.mean('t_source').plot.scatter('t_ahead_hours', 'nll') # Mean over all predictions\n",
     "    n = len(ds_preds.t_source)\n",
@@ -2003,7 +2057,7 @@
    "source": [
     "from seq2seq_time.data.data import IMOSCurrentsVel, AppliancesEnergyPrediction, BejingPM25, GasSensor, MetroInterstateTraffic\n",
     "\n",
-    "datasets = [IMOSCurrentsVel, BejingPM25, GasSensor, AppliancesEnergyPrediction, MetroInterstateTraffic]\n",
+    "datasets = [BejingPM25, GasSensor, AppliancesEnergyPrediction, MetroInterstateTraffic, IMOSCurrentsVel]\n",
     "datasets"
    ]
   },
@@ -14050,14 +14104,26 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 35,
+   "cell_type": "markdown",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2020-10-27T22:06:50.235348Z",
      "start_time": "2020-10-27T22:06:50.168117Z"
     }
    },
+   "source": [
+    "# Leaderboard"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T04:41:03.553104Z",
+     "start_time": "2020-10-29T04:41:03.032085Z"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -14069,21 +14135,359 @@
     }
    ],
    "source": [
-    "#   File \"/media/wassname/Storage5/projects2/3ST/seq2seq-time/seq2seq_time/models/transformer.py\", line 54, in forward\n",
-    "#     outputs = self.encoder(x, mask=mask#, src_key_padding_mask=x_key_padding_mask\n",
-    "#                              File \"/media/wassname/Storage5/projects2/3ST/seq2seq-time/seq2seq_time/models/transformer.py\", line 54, in forward\n",
-    "#     outputs = self.encoder(x, mask=mask#, src_key_padding_mask=x_key_padding_mask"
+    "def bold_min(data):\n",
+    "    '''\n",
+    "    highlight the maximum in a Series or DataFrame\n",
+    "    '''\n",
+    "    attr = 'font-weight: bold'\n",
+    "    #remove % and cast to float\n",
+    "    data = data.replace('%','', regex=True).astype(float)\n",
+    "    if data.ndim == 1:  # Series from .apply(axis=0) or axis=1\n",
+    "        is_min = data == data.min()\n",
+    "        return [attr if v else '' for v in is_min]\n",
+    "    else:  # from .apply(axis=None)\n",
+    "        is_min = data == data.min().min()\n",
+    "        return pd.DataFrame(np.where(is_min, attr, ''),\n",
+    "                            index=data.index, columns=data.columns)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we have the negative liklihood loss, over 96 units ahead"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 71,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-10-27T22:05:27.824869Z",
-     "start_time": "2020-10-27T22:05:27.734831Z"
+     "end_time": "2020-10-29T04:41:32.542586Z",
+     "start_time": "2020-10-29T04:41:32.442986Z"
     }
    },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Negative Log-Likelihood (NLL).\n",
+      "over 96 steps\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style  type=\"text/css\" >\n",
+       "#T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col0,#T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col2,#T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col4,#T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col1,#T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col3,#T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col4{\n",
+       "            font-weight:  bold;\n",
+       "        }</style><table id=\"T_04c496f8_19a1_11eb_a73d_002564adc49d\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >IMOSCurrentsVel</th>        <th class=\"col_heading level0 col1\" >BejingPM25</th>        <th class=\"col_heading level0 col2\" >GasSensor</th>        <th class=\"col_heading level0 col3\" >AppliancesEnergyPrediction</th>        <th class=\"col_heading level0 col4\" >MetroInterstateTraffic</th>    </tr></thead><tbody>\n",
+       "                <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row0\" class=\"row_heading level0 row0\" >BaselineLast</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col0\" class=\"data row0 col0\" >1.630000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col1\" class=\"data row0 col1\" >1.710000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col2\" class=\"data row0 col2\" >1.880000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col3\" class=\"data row0 col3\" >1.560000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow0_col4\" class=\"data row0 col4\" >1.760000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row1\" class=\"row_heading level0 row1\" >RANP</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col0\" class=\"data row1 col0\" >23.310000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col1\" class=\"data row1 col1\" >1.480000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col2\" class=\"data row1 col2\" >-2.240000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col3\" class=\"data row1 col3\" >1.310000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow1_col4\" class=\"data row1 col4\" >-0.270000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row2\" class=\"row_heading level0 row2\" >LSTM</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow2_col0\" class=\"data row2 col0\" >19.440000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow2_col1\" class=\"data row2 col1\" >1.410000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow2_col2\" class=\"data row2 col2\" >16.400000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow2_col3\" class=\"data row2 col3\" >1.940000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow2_col4\" class=\"data row2 col4\" >-0.170000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row3\" class=\"row_heading level0 row3\" >LSTMSeq2Seq</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col0\" class=\"data row3 col0\" >14.520000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col1\" class=\"data row3 col1\" >1.390000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col2\" class=\"data row3 col2\" >-1.530000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col3\" class=\"data row3 col3\" >1.570000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow3_col4\" class=\"data row3 col4\" >-0.250000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row4\" class=\"row_heading level0 row4\" >TransformerSeq2Seq</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow4_col0\" class=\"data row4 col0\" >46.980000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow4_col1\" class=\"data row4 col1\" >2.860000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow4_col2\" class=\"data row4 col2\" >nan</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow4_col3\" class=\"data row4 col3\" >2.330000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow4_col4\" class=\"data row4 col4\" >4.150000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_04c496f8_19a1_11eb_a73d_002564adc49dlevel0_row5\" class=\"row_heading level0 row5\" >TransformerProcess</th>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col0\" class=\"data row5 col0\" >7.350000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col1\" class=\"data row5 col1\" >1.440000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col2\" class=\"data row5 col2\" >0.630000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col3\" class=\"data row5 col3\" >1.080000</td>\n",
+       "                        <td id=\"T_04c496f8_19a1_11eb_a73d_002564adc49drow5_col4\" class=\"data row5 col4\" >-0.270000</td>\n",
+       "            </tr>\n",
+       "    </tbody></table>"
+      ],
+      "text/plain": [
+       "<pandas.io.formats.style.Styler at 0x7f567c9258d0>"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print(f'Negative Log-Likelihood (NLL).\\nover {window_future} steps')\n",
+    "d=df_results.xs('nll', level=1).T.round(2)\n",
+    "d.style.apply(bold_min)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T04:41:36.502593Z",
+     "start_time": "2020-10-29T04:41:36.405337Z"
+    },
+    "lines_to_next_cell": 0
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Symmetric mean absolute percentage error (SMAPE)\n",
+      "over 96 steps\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style  type=\"text/css\" >\n",
+       "#T_07206d14_19a1_11eb_a73d_002564adc49drow0_col0,#T_07206d14_19a1_11eb_a73d_002564adc49drow1_col2,#T_07206d14_19a1_11eb_a73d_002564adc49drow1_col4,#T_07206d14_19a1_11eb_a73d_002564adc49drow2_col1,#T_07206d14_19a1_11eb_a73d_002564adc49drow3_col1,#T_07206d14_19a1_11eb_a73d_002564adc49drow3_col3{\n",
+       "            font-weight:  bold;\n",
+       "        }</style><table id=\"T_07206d14_19a1_11eb_a73d_002564adc49d\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >IMOSCurrentsVel</th>        <th class=\"col_heading level0 col1\" >BejingPM25</th>        <th class=\"col_heading level0 col2\" >GasSensor</th>        <th class=\"col_heading level0 col3\" >AppliancesEnergyPrediction</th>        <th class=\"col_heading level0 col4\" >MetroInterstateTraffic</th>    </tr></thead><tbody>\n",
+       "                <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row0\" class=\"row_heading level0 row0\" >BaselineLast</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow0_col0\" class=\"data row0 col0\" >0.290000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow0_col1\" class=\"data row0 col1\" >0.280000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow0_col2\" class=\"data row0 col2\" >1.290000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow0_col3\" class=\"data row0 col3\" >0.120000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow0_col4\" class=\"data row0 col4\" >0.800000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row1\" class=\"row_heading level0 row1\" >RANP</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow1_col0\" class=\"data row1 col0\" >0.710000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow1_col1\" class=\"data row1 col1\" >0.230000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow1_col2\" class=\"data row1 col2\" >0.300000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow1_col3\" class=\"data row1 col3\" >0.090000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow1_col4\" class=\"data row1 col4\" >0.100000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row2\" class=\"row_heading level0 row2\" >LSTM</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow2_col0\" class=\"data row2 col0\" >0.720000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow2_col1\" class=\"data row2 col1\" >0.210000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow2_col2\" class=\"data row2 col2\" >0.560000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow2_col3\" class=\"data row2 col3\" >0.090000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow2_col4\" class=\"data row2 col4\" >0.110000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row3\" class=\"row_heading level0 row3\" >LSTMSeq2Seq</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow3_col0\" class=\"data row3 col0\" >0.720000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow3_col1\" class=\"data row3 col1\" >0.210000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow3_col2\" class=\"data row3 col2\" >0.340000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow3_col3\" class=\"data row3 col3\" >0.080000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow3_col4\" class=\"data row3 col4\" >0.110000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row4\" class=\"row_heading level0 row4\" >TransformerSeq2Seq</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow4_col0\" class=\"data row4 col0\" >0.770000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow4_col1\" class=\"data row4 col1\" >0.230000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow4_col2\" class=\"data row4 col2\" >nan</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow4_col3\" class=\"data row4 col3\" >0.090000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow4_col4\" class=\"data row4 col4\" >0.490000</td>\n",
+       "            </tr>\n",
+       "            <tr>\n",
+       "                        <th id=\"T_07206d14_19a1_11eb_a73d_002564adc49dlevel0_row5\" class=\"row_heading level0 row5\" >TransformerProcess</th>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow5_col0\" class=\"data row5 col0\" >0.700000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow5_col1\" class=\"data row5 col1\" >0.220000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow5_col2\" class=\"data row5 col2\" >0.630000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow5_col3\" class=\"data row5 col3\" >0.090000</td>\n",
+       "                        <td id=\"T_07206d14_19a1_11eb_a73d_002564adc49drow5_col4\" class=\"data row5 col4\" >0.110000</td>\n",
+       "            </tr>\n",
+       "    </tbody></table>"
+      ],
+      "text/plain": [
+       "<pandas.io.formats.style.Styler at 0x7f5678033450>"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print(f'Symmetric mean absolute percentage error (SMAPE)\\nover {window_future} steps')\n",
+    "d=df_results.xs('smape', level=1).T.round(2)\n",
+    "d.style.apply(bold_min)\n",
+    "# # Plots"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 156,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T12:53:22.666279Z",
+     "start_time": "2020-10-29T12:53:21.293504Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Load saved preds\n",
+    "results = defaultdict(dict)\n",
+    "for Dataset in datasets:\n",
+    "    dataset_name = Dataset.__name__\n",
+    "    for m_fn in models:\n",
+    "        pt_model = m_fn()\n",
+    "        model_name = type(pt_model).__name__\n",
+    "\n",
+    "        checkpoint_name = f\"{dataset_name}_{model_name}\"\n",
+    "        save_dir = Path(f\"../outputs\")/checkpoint_name\n",
+    "        fs = sorted(save_dir.glob(\"**/ds_preds.nc\"))\n",
+    "        if len(fs)>0:\n",
+    "            ds_preds = xr.open_dataset(fs[-1])\n",
+    "            results[dataset_name][model_name] = ds_preds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 244,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T13:21:10.358647Z",
+     "start_time": "2020-10-29T13:21:10.279535Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    }
+   ],
+   "source": [
+    "data_i = 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 245,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T13:21:14.552493Z",
+     "start_time": "2020-10-29T13:21:10.478701Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAloAAACuCAYAAADux6PMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABwIklEQVR4nO3dd3hUVfrA8e+dPumdhAQSIGBC771JEQR0rYCuFcRdV1cBC6w/BLtSBFFwFVaxrgsqgqJSpYqgFOktpBIS0tv0cn9/xAwJ6b1wPs/DQzJz77nnnrmZeeecc98jybIsIwiCIAiCINQ5RWNXQBAEQRAEoaUSgZYgCIIgCEI9EYGWIAiCIAhCPRGBliAIgiAIQj0RgZYgCIIgCEI9EYGWIAiCIAhCPRGBliAITU5ERASvvvqq6/eRI0fyyCOPNGKNBEEQakYEWoIg1JmHHnoISZJc/7y9vRk0aBA//vhjtcr5/fffmTVrluv39evXs3Tp0rquLh9//HGJ+rZq1YpJkyZx4sQJ1zYjR45EkiSefvrpUvu//fbbSJJEZGSk67GNGzcyYcIEgoODcXNzo0uXLixfvpziKQvj4+NLHLfo37x58+r8HAVBaFwi0BIEoU4NGzaMlJQUUlJSOHDgAL179+a2227j4sWLVS4jMDAQd3d31+9+fn54eXnVR3VRKpWu+m7YsIG0tDTGjRtHbm6ua5u2bdvyySefYLVaS+y7evVqwsPDSzy2a9cuBg0axPr16zl58iRPP/00c+fOZdGiRaWOvXHjRtexU1JSmDt3br2coyAIjUcEWoIg1CmNRkNwcDDBwcFER0fz5ptvYrPZOH78OAB2u50XX3yRdu3aodPp6NKlCx988EGJMiobOiz6/ZVXXiE4OBg/Pz8eeughDAaDaxun08nzzz9PYGAgHh4eTJ06lbfffhuVSlWqzkX1HTRoEMuWLXMFiUVGjx6Np6cn3377reuxffv2kZSUxN13312irGXLlvHCCy8wePBg2rdvz7Rp03jkkUdYt25dqeP6+fm5jh0cHIyHh0dVm1kQhGZCBFqCINQbq9XK6tWr0Wq19O7dG4BHHnmE9evX88EHH3DmzBnmz5/PnDlz+PDDD6tV9tdff01WVha7du3iv//9Lxs2bCjRa/T222/zzjvvsHTpUo4ePUr//v15+eWXKy1Xr9cDYLPZXI8pFAqmT5/O6tWrXY+tWrWKe++9t0TPW3lyc3MJCAgo9fi9995LQEAAffv2ZenSpSWOKQhCy1D6q50gCEIt7Nq1y9UzYzQacXNz49NPPyU8PJy4uDg+/fRTTp8+TVRUFADt2rXj3LlzvPvuu0yfPr3Kx2nbti3Lli0DICoqiqlTp7J161ZeeuklAN566y1mzZrF/fffD8Ds2bP57bff+Prrr8stMz09nQULFuDl5UX//v1LPDd9+nRefvllLl68iL+/P19//TX79u3ju+++q7Q9vvzyS9avX+96zMPDgyVLljB06FC0Wi27d+/mhRde4OjRo3z22WdVbgNBEJo+EWgJglCnBgwYwCeffAJAQUEBW7du5cEHH8Tb25u8vDxkWaZv374l9rHb7SiVymodp2fPniV+Dw0NZevWrQDk5eVx+fJlBg4cWGKbQYMGlQq0HA6HKzA0GAxERUXx9ddfExQUVGK7kJAQJkyYwIcffugaFu3du3eFgdaBAwe47bbbePHFF7nllltcjwcEBJSYXN+zZ088PT2ZPn06b775JqGhoVVvCEEQmjQRaAmCUKf0en2Ju/B69uzJjh07eO2113j88ccB2L9/P25ubiX2kySpWsfRaDSl9nc6nQCuO/yqUqZSqeSPP/5AkiSCgoLw9PQsd9tHH32U6dOn4+fnx5NPPllhubt27eKWW27hX//6F88//3yl9Rg8eDAACQkJItAShBZEBFqCINQ7lUqF0WikT58+ACQmJjJp0qR6O563tzetW7fm119/ZcKECa7Hi09wL654YFiR8ePHo9VqSUhI4N577y13ux9++IG7776bV155pcy0EGU5evQoAGFhYVXaXhCE5kEEWoIg1Cmr1UpqaipQOBS3ZcsWtmzZwksvvURkZCTTpk1jxowZLFq0iEGDBmEwGDh8+DDp6enMmTOnzurx9NNPs2DBAqKioujfvz8//PADW7durXbPWXEKhYITJ07gdDrL7fn66quv+Otf/8rcuXP561//6moLpVJJYGAgUJi/S6lU0rt3b3Q6HXv37uXZZ5/lrrvuom3btjWunyAITY8ItARBqFN79+4lJCQEKBxGbNeuHW+++SazZ88GCu/We+utt3jttdeIjY3Fy8uLLl268MQTT9RpPWbOnEl6ejpPPfUUZrOZSZMm8fTTT/PGG2/UqtyKhhYBVq5cic1m45VXXuGVV15xPR4eHk58fDxQGLAtWrSIuLg4ZFmmXbt2PPvsszz11FO1qpsgCE2PJBdPVywIgtAEhISEMGfOHGbOnFmn5U6bNo1jx45x+PDhOi1XEAShPKJHSxCEJqOgoID9+/dz5coVunfvXquyLl++zLfffsuNN96IUqnk+++/59NPP2XFihV1VFtBEITKiR4tQRCajBdffJF3332X+++/n7fffrtWZV25coUpU6Zw/PhxzGYzkZGR/POf/2TGjBl1U1lBEIQqEIGWIAiCIAhCPRFL8AiCIAiCINQTEWgJgiAIgiDUExFoCYIgCIIg1JMmfdfh5cuXq7xtQEAAGRkZ9Vib64doy9oR7Vd36rotV69eDXBdTogX12XViHaqO9dbW7Zu3brMx5t0oCUIgiAIwp+cVtSWy6gsySjsuRj9RiMrtI1dK6ESItASBEEQhKZIdqIyJ6E1nkNtikVtvoSEw/W0wmkhP+j2RqygUBUi0BIEQRCEJmT8sC5Mv6UTtw1rS1CgGzISdm0oRp+h2PRtsWvDcMvZh1vOXswe3bG5dWjsKgsVaFaBlizLmM1mnE5nqYVhr1y5gsViaaSatSzNuS1lWUahUKDT6Wq1eLDQMolromWQHEYU9lwc2pBKtw0NDXX9nJycXJ/Vqh1ZRmM8g1vOLxxZcysmi53NB5MZ1fVZrG5RyEp9ic0L/MaiMZzGK+0bsto+1XyHEGU7yE5QaBq7JvWmWQVaZrMZtVqNSlW62iqVCqVS2Qi1anmae1va7XbMZjN6vb7cbZrNm69Qpx555JHGroJQQ0prOrr8Y2iM51BZkpGQyQu6C7NXn8auWq2pjTF4ZG5BbbmEQ+XN3PcP89GmC2TnW0me9t+yd1KoyQ+6E5/k1bhnbqUg8JaGrXQtSE4z2oLTaAxn0BjP41R5khX+TGNXq940q0DL6XSWGWQJQnEqlarZ9sgJglCM7ECXfwR97m+oLZcKh9B0bTD6jkJtjsMz7Vvs6gDs+vDGrmmNKGw5eKZvQGs8h0PlzYyF+/lsy0UcDrlKXwBt+naYvfqhzz2A0Xc4TpV3A9S6hmQnGuMFdPlH0BpOI8l2HEpPHGo/1NZUcNpAoW7sWtaLZhW1iG5/oarEtSKU5XpO79CsyA50+Udxz/oZpT0bmyaYfP8JWDx74FR5AYXDh76XVuKT+jm5wfeitGWjslxCYc9D4TAgOS3ICh35hxbiVPlg07WhT59OJKQagEbuyZad6PJ+xyPjJySc5PvfjMl7EB//+G61izL4jkCX9zv6nF8xBIyvh8rWjmTPR5/3O/q831Hac3Aq3DB59cXs0RO7rg26/KOo075Gac/FoQlo7OrWi0oDLYfDwaFDhzhy5AgJCQkYDAbc3d0JDw+nV69e9OvXr1kPM1VXmzZtiIqKQpZllEolr776Kv369auz8mfOnMmYMWOYNGkSzzzzDI8++iidOnWqdjlr167l+PHjvPbaazWuy+bNm2nfvn2Njt/UieFCQWialNYMvNK+Qm1OxKYNJT/wVqxuN8A1X55kpRu5IQ/ie+k9fJNXAeCUNDjVPjiVHjjVPkgOMypbBkrjedxyfyFm7Z2cSchh/a5ElJZUHNrgBj8/yWHA68pXaI3nsOojyQu6Hafar0r7ljXlwan2w+LeBX3eQYx+NzaZuVpKaxpS7I8EpO1HwoFV34GCgAlY3KNBuhp6OP7shVM48nBwHQZa27ZtY/369YSFhREdHU2fPn3Q6XSYzWYuXbrEjh07+OSTT7j99tu56aabGqrOjUqn07Ft2zYAdu3axZtvvsk333xTL8dasmRJvZRbVZs3b2bMmDHNJtA6duyY6+eOHTs2Yk0EQagJXe7veGRsAklBbqvJWDx6lgqwinNogshpPQOVNRWbNgyHJhCkMhY8kR2oLKm8/OwD3Dq0DXPv64oyaTn7jl+h202zsLh3Bqn+OwxU5kS8U79EYc8nP+AWTN6DSpxfWV8AiwdX5TH6DkNnOIku7zAmn8F1WufqUthzcc/chi7/CEgqTF59MfkMKXxtylDUQ6mw5zZkNRtUhYFWSkoKb7zxBj4+PqWe69+/PwDZ2dl8//339VK5pi4/Px9v78Jo3GAw8PDDD5Obm4vdbue5555j3LhxGI1G/va3v5GSkoLT6eSpp57iL3/5C8ePH+ell17CYDDg5+fHsmXLaNWqVYny77rrLl544QV69OhBx44dmT59Otu3b0en07FmzRoCAwPJzMxk7ty5rj/Ql156qcIetrlz53Ls2DHMZjMTJ07kmWcKJyC+/vrrbN26FZVKxciRIxk3bhzbtm3jwIEDLF++nNWrVxMREVE/DdlAypsAX9bjYrK8IDQgWcY9axvu2Tux6juQF3QXTrVPlXa160Kx6yoJRiQldl0oz7+7A4A2XTpw79h2PHZ7FN6p/8Wh9MLkPRCTdz+oj14Vpw33rB245ezFqfImO+zv2HVhdVa8XdcWm64tbjm/YPIeWHawWd+cNtxyduOevQdkJ0afYeg73EZBbsXzZYvmlSnteQ1Ry0ZRYaD1wAMPVFqAr69vlbZrKcxmM2PHjsVisZCWlsa6desA0Gq1fPjhh3h6epKVlcUtt9zCTTfdxM6dOwkODuazzz4DIC8vD5vNxrx581izZg3+/v5s3LiRhQsXsnTp0nKPazQa6d27N3PnzuXVV1/liy++YObMmcyfP58ZM2bQv39/kpOTuffee9m9e3e55cyZMwdfX18cDgdTpkzh9OnThISE8NNPP7Fnzx4kSXIND48dO9Y1jNncfPPNN8ydO7fa+5X17VEEXYJQj2QZj4wfcMv9BZNXP/IDb6v3QCE9x8zyr87w7jdnuXJ2G245+/HI2op79s+Q3w+Vrk/lwVsVqY0X8UzfgMqWgcmzLwUBE0qlaqiqit5/jD5D8U79L/rcX//sKWu4YEtjOINn+vco7dmYPbpR4D8ep9oPvdoTqDjQkhVanArt9dujdS2j0cjly5cxm80lHu/atWudVqoqnP9bjZwUd/V3SUKW5VqVKbVph2JqxZNkiw8dHjp0iKeeeoqff/4ZWZZ58803OXjwIJIkkZqaSnp6OlFRUbzyyiu89tprjBkzhgEDBnD27FnOnTvH1KlTC+vudBIUFFThcTUaDWPHjgWgW7du7N27F4C9e/dy/vx513YFBQUUFBSUW87333/PF198gcPh4MqVK1y4cIFOnTqh1Wp55plnGD16NOPHN70JlRUpPmTYo0cPAI4fP14vxyoKukTA1TwpFI3wTV+okEfGJtxy92P0HkxBwKQKhwqrqrIvR8UfswJW92iU1jT0OfvRZx3Bz/krNm0bLO6dsbp3wq4JrnbgorSk4pH5E1rjeRwqX7JbT8fmFlntc6nqe43FvQs2bRs8MzahyzuE0W/0n0Oi9XfNSw4Tnunfois4gV0dRHbrR2qUPNWp9EZxvfZoFbdr1y4+/PBDdDodGs3VxGKSJLFixYp6qVxT17dvX7KyssjMzGTHjh1kZmby008/oVarGTBgABaLhQ4dOvDTTz/x888/88YbbzBixAjGjx9Pp06dqjXkqlKpXHfSKZVK7HY7UBikfffddxXmjCqSmJjIBx98wA8//ICPjw8zZ87EbDajUqn44Ycf2LdvHxs3buTjjz929dS1NBW96VZlaFFo3qZPn97YVRCK0eX9XudBVk05NEEUBN2GrtO9FMRvRZd3BI+sLZC1BVlS41D54lD7ICvckBUaZIUWGQVISmRJQpIBnChtGagsl1HZMnEqdBT434zRe1C5qQvqrMdcUpAd9ne0Bcdwz/oZ79QvsKv9MXkPxuzVp84nyauNF/FK+wqFPZ8Cv5sw+g4rMcm9OpwqL5SiRwu+/PJLZs+eTa9eveqzPlV2bc+TSqVyBR9VUVYvSHXFxMTgcDjw9fUlPz+fgIAA1Go1v/zyC5cuXQIgNTUVHx8f7rzzTtzd3Vm3bh2PP/44WVlZHDp0iL59+2Kz2YiNjeWGG26odh1GjBjBxx9/zGOPPQbAyZMny+1hzM/PR6/X4+XlRXp6Ojt37mTQoEEYDAZMJhOjR4+md+/eDB06FAAPDw8MBkON2qa+FX/9ynLnnXdy//33V6vM8t7kygrExHCiINSOypyIZ9pGrPpICgImNmqQVYLKDZPPUEw+Q1HY89EYL6CyXEZhz0Fpz0FhzUCSLUhOK8jOEmsPAjhUvti0rTF79cPk1Q9Z6dZwdZcUWDx7YfHojrbgFG45+/DM+B73rG2YvPpj8hlc61xbksOAR+YWdHmHcKj9yQ77R62HWR0qbzTGtFqV0ZRVOdByOp01DkhakqI5WlC43Mvbb7+NUqnkjjvu4MEHH+Tmm2+mS5cuREYWdhGfPXuWV199FUmSUKvVvPHGG2g0Gj744APmz59PXl4eDoeDRx55pEaB1iuvvMLzzz/PmDFjsNvtDBgwgIULFwKwbt06Nm/e7Nr2+++/p2vXrtx44420bdvWNWm+oKCAadOmYbFYkGWZl19+GYC//OUvPPvss3z44YesWrWq0SfDlxdcNdR1KXq5mj+RR6tpkOz5eKd8gVPlRW7wPXU+vFWdLz8VfWlyqjwxe/UGepdfgCwDMiA1nWBRUmLx7I7Fszsqc6JrXUS3nH1Y3KMxe/bC6n5D9XqgnFb0eb/jnrUDyWnB5DOEAr+xdbJ0jlPlhcJRALKjQe7+bGiSXMWJTZs2bcJkMnHnnXc22DyHy5cvl/jdaDTi5lb2t4PG6NFqqarblvWtst6rsl6/iq6VulDRm3NAQAAZGRn1duzrSV235fUcaDWl69Ir5XO0xnOFvSFVWK+wPl37t9yU2qkuKWzZuOXuR5v/B0pHAU6FDpuuHTZ9BDZdW+yaVqUn6cuFQ6G6/GPocw+gcBqx6juQH3gLDk2rsg9UTFXbUpd7EK/0DWREzG3a2e0r0bp16zIfrzCcLRqOKpKTk8N3332Hh4dHicf//e9/V1qBxx9/HJ1Oh0KhQKlU8uabb1a6T30SwVXTVpPgqiGJ4UJBqBltwUl0hlMU+I9v9CDreuJU+1IQMJEC//FojBfRGk6iNsWhNZ5xbeNQeuJUeSJLWpCkwiFTpxkZCat7NEafodh0EXXec3c1l1Zesw60ylNhoPXPf/6zTg+2YMECvLy86rRMoeHUthewsv0rC65qelxBEJoGyWHCI/07bNrWGH2GNnZ1gOvwS5OkxOreCat7YSJqhT0flSUZlfUKSmvan8sXWZFkOxaP7th0bbDq21c5e31NXM2llYudNvV2nMZSYaDVuXPnhqpHo2rpw4hlBTBN6Tybeu+VIAh1wyPjRxQOA7mtH2qRc3GqqindTONUeWJVRWF1j2q0OjiUV3u0WqIqz4Sz2+3s2rWL+Pj4Unm0nnjiiSqVUbTuXlEizKao6ENffLhXrKzgtDoBqwiuhMZwPa3L2tSojTHo8w9h8BmBXVv2XBbh+iQr3ZBRttikpVUOtFasWEFCQgJ9+vRxLTtTHa+88gp+fn7k5uby6quv0rp161I9Ztu3b2f79u0AvPnmmwQElFwK4cqVK6hU5Ve5oueqqy7LaoqKBzp9+vQp9XxZ5198u8OHD1e4bXmBVFEZxfcv7xi1odVqS10/DUWlUjXasVuaum7L5557rs7Kam4a9bp0WJCSNiLrgtB3moy+Du5Uqy/12U5abelcVi35vaJabXnJBzeVBX0LbI8qRxPHjh1jxYoVuLu71+hAfn6F47ve3t7069ePmJiYUoHWmDFjSvR0XXu3gsViKfcbaW3ulCurR6Z4IFCTHpumpLL5UNeea3XbsrbbFq9fXd3taLFYGu3OoZZ611JjqOu2TE1NBSA4OLjOymwuGvO69EjfhJslg+zQR7Fl1d/wUF0MyTVUOxXVryW/V1SnLX0kTyhII6cZt0eN7josLiAgAJvNVqODm81mZFlGr9djNps5fvw4d911V43Kqk/FP/DL65GZNGkSERERqNVq2rRpwzvvvFOih2/MmDF06tSJ9957z/XYzJkz2bt3L/v370er1ZKVlcXNN9/MwYMHSUpKYuTIkbRv3x6bzcaAAQN44403mvxSIWUFb1Vpv4r2F4T6VrQaw/WY3qGxqMyJ6HP3Y/QeiE3frrGrU6GmNHfqeuNUeaGytMw2rzDQOnnypOvn4cOHs3jxYm6++WZ8fHxKbFfZWoe5ubksWbIEAIfDwdChQ+nZs2fNatzINBoNK1asoEePHjz11FN8/PHHjBw5Eihc4kaWZQ4ePFgqj5NCoeB///sfDz74YKkyw8PD2bZtG3a7ncmTJ7N582YmTJhQ7bpVp8etvKCoruaoiUBKEATJYcLryjqcKi8M/uMq3b6lBzot8ZzqilPljdJwpjABbFNJ/FpHKgy0ysqP9eWXX5b4vSprHbZq1YrFixfXoHqNp7weG4VC4XquT58+nDlzNQfJrl27uPPOO7lw4QJbt27ltttucz33yCOPsHr1av7617+We0yVSkXfvn2Jj4+vVl3L6j2qSdBVVsBV3rY1PVZL1NI/HAShRmQHXqlforTlkB06A1mhq9buZa2+UNnfl/j7a74cKi8k2YbkNDXsskUNoMJAa+XKlQ1Vj2bH4XCwb98+7rnnHtdje/bsYdasWVy8eJE1a9aUCLRCQ0Pp378/33zzjWsJn2uZTCb27dvHM888U9/VFwRBqFfumVvQmi6QF3gHdn14Y1enSlpyZvimriiXlsKeh+N6CrSgMDt8z5496dWrF927d0enq963kvryn0NXiMu+mmZCkiSquJpQudr56nikb8XLChStdZiQkEBkZCTe3t706NGDP/74g9atWxMWFkZISAizZ88mJyenxDDrP//5Tx5++GFGjx5dosyEhATGjh2LJEmMGzeOUaNG1fgcyuqdqu6+KpWq3LsCBUFofGpTHNqCUxQETKjzdQLrgj5nP+45ezF6D8Ts3a/K+5W1gHtlRI9y85WZmcmJEyfIzMykfaDMuNaQnXoRz7atkFrQ8GGlgdbrr7/O0aNH2bNnDx988AERERH06tWL3r17lzvDviXT6XRs27aN/fv38+KLL7Jp0yZ69+7Nhg0biImJYcCAAUDhQs0//vgj9957r2vfdu3a0aVLF9eE3CJFc7Sqo7LhuoacY3U9DhcWJ97cm4+WkLZFabmCd8onKJwWLB5dsekjGrtKV8ky7lnbcc/+GYt7ZwoCJtWomJb0NyUCwZLsdjsXL17kxIkTXL58GYVCQVBQEDGJWYxrDScO7+Xs9rN06tSJbt26leisqElbNoX2r/Rdx9fXl1GjRjFq1CgcDgdnzpzhyJEjLF68GLvd7gq6unTpglqtbog6A5TqearPhZDL6h1yd3fn73//Oy+//DJz5sxh06ZNbN++nZCQwrW7fvnlF5YvX14i0AJ48skneeCBB+qlnoIgVOzhhx9u7CrUimQvwCflE2RJjYwNjeFs0wm0ZDue6d+jz/sNk2df8oNua7bZ35vCh3NLk56ezpkzZzh79ixmsxkvLy+GDBlC586d0ev1INuRL86nb7dwss56cOzYMY4ePUq7du3o1atXtXo5m5pqfb1TKpV07dqVrl278sADD5CWlsaRI0f46aefSExM5NZbb62vejY5PXr0oEePHmzcuJHvv/+e4OBgV5AFMHDgQJ544gmuXLlSYr8bbriBbt26ceLEiYausiBc906fPg000+XFZDveqZ+jcBSQHToDj8zNaI3nMDC+wt0aImhQ2jLxSv0fasslDD4jCu8wrIehn5pMkG9pZFnm4sWLnD59GrVajZubG15eXoSEhBAYGNikVj/Iy8vjyJEjnD17loyMDBQKBe3bt6dbt26EhYWVHB6UVDhV3rSxH+fB7kEY+kRwOkXJrqPJrF8fR6tWrejYsSMXLlwocYzyru+mFJhJcg0mNjmdzhK/11fOp8uXL5f4/dqUCcU1VI/W9TBMVp9t2VAqulbqi/gWXPfqemLy6tWrgeaZR8s9cyvu2TvJbXUPFs/u6LP34Jn5Exnhc3Cqfcrdr16vS1lGl38Ej/TvQZLID7oTi0fF6X5qoyECrYCAgBIZ3JvS3/KVK1fYu3cvly9fxtPTE6VSidFoxGq1AoWdIa1btyYiIoJ27dqVSsXUEPLz84mNjSUmJobLly8jyzJBQUFER0fTqVOnwt6rcihs2WgLTqIxXkBjjkOS7TglNVn2QI7EOfgjUUapD6B3797ccMMNqFSqKgVaDfUa1jphaWxsLB9++CGJiYmuF7XI2rVra1e7Ju56CK4EQWi6VOZLuGXvxuTZG4tnd4DCRYAzf0JrPIvJe2CD10lpvYJn2kY05jisunDyWk3BqfZt8HrUh8b+wL5WTk4Ov/76KxcuXECv13PjjTfSpUsXVyeHwWAgJSWFy5cvk5CQwN69e9m7dy/e3t5EREQQHh5OSEhImUsA1ZbdbiclJYXExEQSEhJcX4x8fX0ZOXIkYWFh+PpW7bpwqn0x+Q7D5DsMnFY0pjg+XzGHmweGcVOkJzdFQqYpl7grcew65mTP7xdoE+xNUmrTXiOxyj1aTz/9NH369GH48OGlXqzAwMB6qVxT6dG63rSEthQ9Wi2D6NECnDb8Lq1AcpjJajsTWflnj4As45+wBLsmkNzWD1VaTF21pcKeh1v2LvS5B5EVWgr8x2P26tsk736siWvbqTH/rg0GA7///jsnT55EoVC45kS3b9++wjrl5uYSHx9PQkICSUlJOBwOJEkiMDCQ4OBgAgMDCQwMxNvbu1rBl8ViITs7m8zMTDIyMkhNTSU9PR2n04lCoSAkJITw8HA6dOiAr69vnVxzRe0fFe7Nrz+8j9oUi9IYh4qrHT52p6IwD5fWD6fCDVmhRpY0SMggO0FSkB90e63qURW17tHKyMjgnnvuaVG3XApCXSp6wxN5eIS65J61A5U1jZyQh64GWQCShMU9Cn3eb+C0QrGFmusjOJAcBbhn7UKfdxBkJ2avvhT4j0VWetRJ+cJVJpOJI0eOcOzYMZxOJ507d2bAgAFVXmu4KO1Qjx49XD1OycnJXLp0iTNnznD8+HHXtjqdDg8PD3Q6HVqtFpVK5UqXZLPZsFqtmEwm8vPzS4xmqVQqgoKC6NWrF61btyY0NBSNpv4WCz+bkIvRdzj4DgfZyY2DutArOpSh/aLo3qk1HhozAV6peLmp0KklFNiRkQAFsqLue/Kqo8qBVr9+/Th27FizXTpHEAShuVHYsnDL2YfJszdW9xtKPW91vwG33P1oTLGFQ4mVqEkAJjkt6HP24Za9F0m2YvbsjcFvFE61X9VPpI7r1JAachjRaDRy9OhRjh8/js1m44YbbmDAgAG1mmulUqlo06YNbdq0AQon0+fk5JCRkUFeXh65ubkUFBRgsVjIysrC6XS6clJqNBo0Gg3e3t6Ehobi6emJj48P/v7+eHl5NciavGW2s6Rg54Grq7JYLBbOnj3LjpMnyczMRKFQuHrWIiIiGnx041oVBlrvvvuuqwfLZrOxZMkSoqKiSr3oTzzxRL1VUBAEoa7UxxyV+uSRuRUkBQb/m8p83qpvT4HRxrntS/jvtlheXPwhdm3V8hsWBQ3lBQwKez763F/R5x5A4TRhdu+Cwf8mHJqgmp1MHXM4HCgUikYbZams/aojLy+Po0ePcurUKex2O506daJfv374+/uXuX1tjilJEr6+vlWeN9UcaLVaevTowYQJEwgKCqJz5864ubkRFxeHJEmEhITwl7/8pUFTUBVXYaAVHBxc4vewsLB6rYwgCEJ9ak457FTmZHQFxzD4jsSp8sbhlMkw2riUa+VSnhWL3cngcE9+WHeaf9wexfKZAyB5FQ6Hk0P/mUSnPuOx6dpis2bgUJf9gX0thT0PjeEcWuMZNIbzgBOLe2eMviOw69rU6/lWlcViYe/eva5UHQqFAm9vb9q3b0+HDh1o1aphs4pXlkagvKBIlmVSU1M5duwYFy5cQJIkbrjhBvr06YOfX8W9hXa7THamHbtNxuEApRLcPZS4eypQKq/v6T1paWmkpaXx+eefk56eTmxsLNnZ2Y0WZEEN0zs0lKY4Gb6sPB4xMTHMnTuX3NxcrFYrAwYMYMKECbz22msAxMfHExwcjE6nIzo6mqlTp3L33XezZMkS11qJJ0+eZNy4cbzwwgv8/e9/r/fzqIiYDF87Tfn28Oamrue7/fbbbwD079+/zsqsa0abg+Q8Kx2yP8VbTuW1K/cTkyuRkm/F6ij9dp0fd4L0X79Dl3yQnpE+9IsOoH90IGMGtkPhtADglLRIbsFYJF+cKk/eWPwOZqsdbw8Ns5/8G0pbFipLCkpHPgAOlQ8W9y6YvAfi0AQ06PlXJDY2lp07d2I0GunatStubm7Y7XbS0tJITk7G6XTi6+tL9+7diY6OrtGcoapcc9XJ0XTt37/VauXChQucOHGCtLQ0NBoNXbp0oWfPnnh6epZbjsMhk55q53KildTLNhzlvEV7+SgJCFIR0EqFf5AKlarxAq+Gnq/a2MPQNZ4MP2vWLKKjo+ncuTPR0dHldmVez+bPn8+MGTMYN24cAGfOnCE6OpqRI0cCcNddd/HCCy+40kTs37+f6OhovvvuO1egtXHjxuaZRFEQmpGinHiNHWg5nDJpBhvJedZi/ywk51nJNjvo753M8qh4lif247RBJtRTTa8Qd0K9NIT9+c8hw864XLZ79cGzXTfCvDTsfm8eP67ZA7JM8qUklNY01OZEVNZU9OSiNsSjcBh4ZUYvAGQk5PxjOFQ+WN0isWtCsLpF4tAE10vC0eow2hxkGO1kGGykZuWReOIg1vQk7FovkkKG8EeOF0O9vbgp2ochXhrMZjOxsbEcP36c3bt3s3//fjp37kz37t3rfJisuokxnU4nycnJnDt3jgsXLmCz2VzpD6KiosoNCO12mbQUGymXbFz5M7hSqEDhCwovma6hevzd1djtMoZ8J/l5DrIyHMTHWIg9b0GhhMBWKlq1VhMUokbv1rh3hjqcMvlWBzlGO+lZdnKzHRhznShtEl5qJU6HjEIhodFKfLthLSmpF7l0+Rw/bfkKjbbyujfVL7WVBlp33HEHZ86cYf369SQnJ7sSjxX9u3Z48XqUlpZWIit8dHR0pfu0bt2agoIC0tPTCQgIYOfOnaUWmxYEoXmz2J0k51lJyrVwKc9KUm5hQHU534bdebV3ylOrJNRTQ+/WHoR6qblXtxmL5MNdI27hHlXpIY/iH+5Jly7xa1I+Xx7PoMN982ntqeG2aD+sTtBog3FoC9+jdQEBZBb1Lsh2JKet8G6sBk7LIMsyeRYHmUY7WSY7GUZbsZ/tZBltZBjtGG1OkGVCLUlEGmOQZCdXvDphb9WJVu5a/J0y353NYsOZLHoGu3F7Z396/NkpUDQkd+LECY4dO0abNm2IiooiMjKyzoeQyvtwt9vtJCcns2vXLmJiYjAajajVajp27EiXLl0IDg7G7pTJMTvIzjORbbaTY3KQk2/Hki2jzJdwtyhRImGWncTLZuJkM5ftVuQUIAUU56FfqAdjO/jQI8yNUGVhwOawy2Rm2Em7bCP1sp0rl02ACS8fJUHBhb1dvgF109tltjvJNdvJMTvINdvJNTvINTvIsdgxOzLJzjHiNILSJuFmV+IrqfBFhbJo/rcsk4GdKworwd4afNUqzCaZrtEjGDLgTgC2bMjDy1uBf5CKwGA1AUEqlI3YU1ddlQZaw4YNY9iwYUDhhL2zZ89y5swZtm7dyqpVq/Dx8eHf//53vVe0KZsxYwaTJ0+mb9++DB8+nClTpuDt7V3pfhMnTmTTpk107dqVbt261eutsULDaqrfrIT6YbA6/gykLFzKLfw/Kc9KWoGNonBKIUGwh5owby19Qz0I9dL8+U+Ll/bqsina/D/wvnKF3KDJqMsIsq6lkCSGtPViYJgnvybls/50Fu/9lspnx9IZ1MaDQW086dbqmrQAkgpZWf7bf02GYGwOJ7kWB9mmwg/bbJOdbLO98H+TnSyTg2yTjSyTo0SQCSABvnoV/m4qQr00dA92x9OaQ/6Fw5gMmQSFhDJ61CgC/Qt7pmRZpiDfSXp7G0cTDRxKKeD1ny8R5qdhbAcfBrUNYNy4cQwbNoyTJ09y+vRptm3bxq5duwgPD6ddu3ZERERUmKW8uhwOB+npGcQmJpF06RIZqSk47DYkpRKNb2tUoT3IcwtihwXWHzKRY76AwepEAgJQ00ahJUzSECRpcANMkoMMnRW7p4zOW0EnNx0D9B746VX46lU4ZZmfY3PZcTGXg5cK0KkU9GntTpcgNyJ8tIT7aunSSk+XXlCQ5+TK5cJesYvnLMSctSApwMtbiY+fEi8fJe4eClR6CbvKicFa+C/P6iDf4iDPUvh/rtlO3p+/55od5JntSA4JNxS4S0rcUeApqfBEibdCSQAKwrk6HOpUyyjcQOsh4emjJMBfRZC/motZZj4/lsHGjCzaeGu4v2cgc6aNwMPdl9DWnfjgvf+SkWYnIdZK3AVriZ664FA1Wl3TzuFWrbUOvby8CA4OJisri8zMTNLT0+v0Qq2Ok0eM5OU4XL8X5f2oDS8fJV17V39ez5QpUxgxYgS7du1iy5YtfP7552zbtq3SO5xuueUWHnvsMWJiYrjttts4dOhQTasuCEI9K3O4L7/w/2zT1QkzKoVEmJeGjv46RrX3po23hjZeWkI81aiVlXwgyHY8Mrdi04Rg8ajeihRKhcTQcC+GtPXkxBUjW2Jy2BOfz9aYXFQKiciAZMK9VAR7qPFzU+GnV6FXK9CqFKgVV3sH7E4ZfUgHFGoNCo2eA0n5GG1ODFYHBpuTAquDAsvVD+Dj52NRu3uj1JWd48lDo8BHp8LPTUXnQDf83FS8/cbLWHMzsOVlsH/HT/jqVCj/rIPBYODXX3/l9OnTuLu7M378eDp27Oia4J6RZuPMMTM5WYXv/xqUDMabwSpv8vLt7D9UwMeH0ugQqCMqQE9kcBSjO3XHlptBXMw54uLiiImJAQqzlwcHBxMUFISPjw++vr74+Phgd8pXz9n65zn/+S/XYCY/vwCDIR9LQR52Yx4KUy46Sy4KCpenMyjcyFa3IkMfSLbaD6esxNOgxNvuwEenJNJTR6C7Gg+LEpVBAX9+lHn4KghpraZ1mAZP78rvqHywVxD3dg/geKqRg5cK+O1SPr8k5rue1yglvLVKPLRKVAoJtUJC4Q3uViVediXuuSq8s5WouXpdyrKMGRkLTuzI2JGRAQXgq1DTStKiRkKFhEIC6ZqeJUkBbu4K3D0UBAa5o1BZ8fBS4uWtKHf4r3drD3qFuPNrUj6f/ZHB67uTuX/Nfm6L9qNfqAdKhUTHzoXz1DLTS/bUHT9kwjdASUiomuAwNe4eTWetxyKVBlpFi1eePn2amJgYWrVqxQ033MDw4cN59NFH8fAQyeqg8A7NqVOnMnXqVEaNGsW5c+fo3r17hfsEBQWhUqnYs2cPL7/8sgi0BKGWajMZ1mJ3kmt2kGWyk2mykWGwc8Vg40q+lZQCG1cKrNiLLfPqoVEQ6qVxzZ0qCqhaeahdQUN16XN/Q2nPJj/koTKH9KpyfpIk0T3Yne7B7lgdTo6mGDiTZiIx38EviXkUWJ1l7ldcl1mrXD+/safkcdzUCjw0Sjy1Cjy1KgyJp7Eb8rAXZGMz5GLLz8Ken8W+7Vvw1SvLDC6f/+Vb188BboW9dna7nWPHjvHbb7/hcDjo1asX/fv3d31hzcmyc/aEmfRUOzq9RNdeejx9FGh1CqwWmcw0O+mpNrwyVPSTPLicb2F7ei7fyFnF6t4Gd7+2ePrk423OwGDOJuPcRZRnzpSon11SYpPUfya8lAAZlexAKdtR/hlMSYAOcCrUoPdC7ReJm08AvkGt8PP2xkurxEenxFunQotEbqaDjCt20q/YMWQVlqHVSQS2UREUrCYwWFWleUjXUisV9An1oE+oB4/1b0WWyU5ctoWkXItrOK/A6sThlLE5C8/I4i6TLdkxqpzkKRW4SxLuThV6pwKNrMDHKaFwFA5bKgAlUuE1LYFSBSqVhFpdOJdKq1Wg0Uno3RTo3RRodZIrQKzOZHhJkhjc1ov+YZ5sv5jDupOZvLEnGT+9ipHtvOgR7E50oJ6gYDVBwWq69JLJy3GSmmwlNdnG6WNmTh8z4+mloFWomlat1fj6KZFq+LdYlyoNtJ5//nlCQ0P5y1/+wqxZs5rM8Na1PU+Neafczp07GTp0KGq1mrS0NLKzs6s8d+2ZZ54hMzOzSa24LggtUWq+ld/deiAjEbctAbtTxmRzYrI5ybc6MdtLByBuagWtPNS09dYwMMyD1l4aQj0Lh/w8tco6TSMgOS24Z/+MVd8eq1unOilTo1QwIMyTAWGerg89o81BlrFwTo3Z7uShGX9H+vP9Z/nydwp7PpQSGoWETq1Ar1KgVytw1yhxVytKBZH/uf+NMo/d64YIoPKAV5Zlzp07x6+//kp+fj4REREMGzbMNYE9P8/BuRNmUi7ZUGskOvfQERGpLTVHxz9QRacuOvJyHMSdt6BMkJis0uEVrMAe6CTb6SDTZMdkc2Kxu2FzBiEDZmSUDgtamwGVzYBO4UQ2G1A4bSglUEkyKqUCvVaLXqvG28Mdby9PPDw88PX1Ra/Xl7oOLBYnWel2MuPsJKQbycspvLaUqsJ6hnfQENhKXaVeq+qQJAl/NzX+bmr6hjbPThCVQmJ8R1/GdvDh0OUCNp/PYcOZLNafzkKlgDAvLa29NIR4qPHVq/ByV+LZTYm3TYklU8aQ4STmrIWYMxaUavDwU+Dhr6BHZ/dGS31RaaD1xBNPcObMGTZu3Mi6deuIiooiOjqaqKioaufVcjqdzJ07Fz8/P+bOnVvjSjcmk8lEnz59XL8/+uijpKSkMH/+fNc3r3nz5hEUVLWkfv369auXegqCUJIM+AW2KuyjkCR0Ksk1fOauUeKjVeGlU+L351yhADc1HpqGS4ipz9mHwmGgwH98le/4c8pOcs2JWBz5KCTVNf+UKCQlEkoUkgqTVYXVYUCtUBDsqSDEU4MkKcg+ttNV3qj2peeWltWLVl7PWlXTHiQnJyPLMvHx8Xz55ZdkZGQQGBjImDFjXBnMDfkOzp0yk5xoQ6mETl20tO+kQ6252jYF1jQu5/+BwZaOgj/PV1KibqeibZiCzHQnmRkycpISHx8VHYN1eHmpXdtJSK42kiQFEt74+PiSl5tf+LtU2KcjSRISChSSAlC4HpMxYrQZMRkgN1smJ9NJTpYDQx6AhEIp4eunpmNXNQFBanz8VIVJVv/sKavNteVw2skwnuNywR8YrRloVJ7olJ4oFZo/z0f6s56K0v+XeEwq+bOkKKxbsfNGklzbXf1ZAtf+0p+PF/bIFe4LSqOZfEt2YZtJ/Flu4bn3798fWQZkmV9/20uu5RK5lmTsTrOrTL1awe1dFNwSLZNhcJBmsJNrdpJncXIu04lDViDLheXJSH/+DEpvBT6o8UaFr0WDIllFry7jatzWtVWtPFrFJ8OfPXuWzMxMOnbsyLPPPlul/Tdt2sTFixcxmUxVCrSaYh6t60FLaMvGzqMl1jqsG3XZlgZrBltPLAMkgoKCrn7Y/fkhwZ+/XX2Mqz+7XPO7VOqHSpTxdisDsg1dwXESUnLZcSgVgHvuLUz98uWXX7o2veeeqa6fLY580g3nsDmNVTx2+Up8qP75YVv04ZuVmYUsg9MpE9wqGElScCnpUmG1nRAREU5h8AFFH6jnzp0HGWS58C7swoDiahtbrVYMBiM2qw2lUlm41t6f832dDjCbnFgLU4Ch0ynQuSlQKIq/RoXnn2cp/IxQKbQ4ZSeyXDSjqDm5GnwUtVPRmQLFHrvahgAO2YZTtqGQVLirg7A68rE6Cprh+V8lIaFUaAEZWXYiIyPLMjJOyvzbqXK5aiZ3+ajO6lmeWi8qDaUnw6elpXH06NEq7ZuZmcmRI0e444472LRpU3UOKwiCUGtO2YbJkQnI5Fnsf948I//5wfTnzzLXPEaxm2xKvtFf/UCr7gdA6aBM4bQgOa2kqe1E9y/MVfhHzFZkWSaq79Us4akFJ1z7qxQ62nj1J9A9Cg9NIA7ZjtNpxynbceIo/F92IMt2nLITd3c9eQW5hR9gshMZB7LsxIkTZCcyzmIfbn/+DuzcsKYwCFNAz3vHArDr+EkkqTAI6B3dAeSrbSYj0697qKt9XS0lyxiNBrJzcrBYLShVSny9g3D38ECSClMSGAqcWMyFw2x6Nwm9e+HcoLLa2l0dSHufkbT27I2nttXV10V24pQdhededI6yo3Bx5WQzqSlWsjOtgAOlyom7t4S7h4xaAyqNjLu7HoOxAKfTic3mwGpzYLU6sJjsmM0OnEXnJTnRuYGbu4TeHdw8JDQ6rp7zn21YVKfClnH+eQrF2uuatkMu1mbF/i/ZxqCUVAS6R9HKvTMqha7YuV99ba++pk5XwFLu4xStcVj8saLjXr0uiupZ+DOusoqOf7XOTjw8PcnLy3U9NmvmU4U9X39+t5Gkwi80VpOD1AQDaUlG7LbCssoaci6sM3/WsXQgVrJOsuvn2gRpdaHKk+HPnDnDuXPnsFgsREZGEhUVxZgxY+jUqWpzCT7++GPuu+8+TCZTrSvdVBUlQwRcyUmbQlmCIICnNgTDscJh/3tnzGjk2lylsOfin7AEs0d3vG6aWeG2tUkbUtPewT5zSy9b1H9W1dvP4XBw/vx5jhw5QmZmJp6eYfTt25fo6GhUKhX5uQ4unDaTnGRDoYCo9hoio3Xo9DW7ZV+SFCglBUquSY2hBs9I6BQJFrOTtBQ7OVl2sjMdZKY5KNmJH+j6SaUCrV6Br6cC9yAlnt4KvLyVeHgrGzXrelmKzr2afSj1JiAggAzF1Wvu922prp/LGoauTGFPK4Ci6p3ITUClr8ZLL73EDTfcQFRUFJMmTaJjx47VTvh2+PBh11pUp06dKne77du3s337dgDefPNNAgJKLv1w5coVVKryq1zRcw2tLutSPOgqPj+sPjWltqwJrVZb6vppKCqVqtGO3dJUpS2Lp1GxWCzlPlZcU3p9Pvq/O3lgfAe6Tfi/Kte/oKCAhIQEPD098fPzw93dvdL5Pg19Xebn53Po0CEOHTpEfn4+QUFB3HHHHXTr1g2lUklaqpljv2WTGGdApZLo2sOHLj19cHNvmPee0GumGNttTkwmBwqFEqfDgaQAnV6JStW0czQ1ZRVdc5Vdi03pb7S2Kr2iP/74YxQKBSaTqcycWRkZGZU2yLlz5zh06BBHjx7FarViMpl45513ePLJJ0tsN2bMGMaMGVOi7OIsFku5d+c1tXlF9VWXhjjHptaWNWGxWBptnpSYo1V3qtuWZW1b1ccag9KSwsMTIlm5/iwJqQZXvYr3XBWvq9Pp5Pjx4xw4cACr1ep63MvLy7Vah5eXV5nHaojrUpZlEhMTOXXqFLGxsTidTsLDw7nxxhsJDw8H4MzJNC6eM5OV7kCtkejURUtERy1aLRhNORgbedCjsJ0KU0KYS8e4QjVce82VdV2X10vbVP5Gq6PGc7QUisJo/s0332TevHklerOuXLnCyy+/zMqVKyss49577+Xee+8F4NSpU3z//felgqyWoC6H+IqXVbxHSxCEFkKW8cz4gZwCG69+crzSzRMTE9m7dy+ZmZm0bduW/v37Y7VaycnJIS4ujoMHD3Lw4EEiIiLo1asXYWFhDXLHpCzLZGZmcu7cOc6fP09+fj46nY7u3bvTrVs3fH19sdtk4mOsxF2wYMh3oneT6NJTR9v2WlTqZjQGJAg1UOU+2sjISBYvXsycOXNQKpVcvnyZV199lTvvvLM+6ydwNeg6duyYK+gS87aaj8ZeUb6lK6tNy2vn8np7GoPGcAaN6SKaDndx8uzScrfLyspi3759xMfH4+XlxcSJE2nfvn2JIKpnz57k5eVx+vRpTpw4wbfffou/vz9du3blhhtuQKfTValOlV2rRc9LksTvv/9ObGwssbGxZGdnI0kSbdu2ZciQIbRv3x6VSkVBvoNTR00kxlmw2yA+8QTbd33CkeNbSUpKrGpTCUKzVq30Du+//z5Go5G77rqL119/nXvuuYcRI0bUW+WaYnqHjh07cuHChRKPxcTEMHfuXHJzc7FarQwYMIAJEybw2muvARAfH09wcDA6nY7o6GimTp3K3XffzZIlS7jnnsJbuE+ePMm4ceOYPn06d955J3a7nQULFmCxWLBardx6660lhlWrGmiZTCYeffRREhISUCqVjB07lueff77cei9atKhFDB02pfQOItCquRY7DCvb8UtcBqjIavskSKWnROTn53Pw4EHOnDmDWq2mf//+dO/evdL5k3a7nXPnznH8+HHS09NRKpW0a9eO7t274+fnV+HfRXnXqt1uJyMjgxkzZhAeHk7btm3R6XQoFApCQ0Pp0KEDkZGRuLm54XTIpF62kXDRSsYVO5IEIWFq2nXS0q1HeJnlNyUt9pprBNdbW9ZJeoe//e1vLF++nOeff55//OMfDB48uE4q19zNnz+fGTNmMG5cYUK0M2fOEB0dzciRIwG46667eOGFF1zB0f79+4mOjua7775zBVobN26kffv2rjJnzpzJ+++/T5cuXXA4HK78YzXx97//nSFDhmC1WpkyZQo///wzo0aNKrPegtCS/fjjjwBMmDChUeuxfM5EXnu0NxOe2c7HG2aVeM5gMHD48GFOnDiBLMv06NGDvn37VvmLg0qlokuXLnTp0oW0tDTXfKmi9f18fHwIDAzE398fNzc33NzcXFNCwsPD0el0uLm58euvv5KTk0N2djZZWVk4nU7Gjh1LTk4O586dY86cOYSHh7sm7uflODh1zsSlBCtWi4zOTeKGrjrattfU+A5CQWgJKgy05s+fX2qM3263o9Vq2bJlC1u2bAEK70y8nqWlpRESEuL6PTo6utJ9WrduTUFBAenp6QQEBLBz584SdxRmZmbSqlVhbhilUulKo2E0Gpk3bx5nz57Fbrfz9NNPM27cOEwmE7Nnz+bChQtERkZy6dIlXnvtNXr06MGQIUMA0Gg0dOvWjZSUlArr7XA4eOWVV/j111+xWq08+OCD3H///ciyzLx58/jll19c2ZunTJnCpEmTatN8LV5T/eZ+PWoKr4XSeoX5D/Xgm10JbPv9aq99fn4+R48e5cSJEzidTqKiohgwYEClw50OR+GgRFnLiwQFBREUFMTIkSOx2WwcO3aMtLQ0rly5UqpnHmDq1KsJUQ8dOoSXlxe+vr6Eh4fTqlUrWrVqhaenp2sbk9HJxXNmLsXbyMtxIEkQHKqmbXsNga1USApJ9Ohe58TrX0mgNWrUqIaqR7M2Y8YMJk+eTN++fRk+fDhTpkzB27v0UhbXmjhxIps2baJr165069aNsLAw3N3d6dGjBzNmzGD48OEMGjSIkSNHcvfdd6PT6Vi+fDlDhgxh6dKl5ObmMnHiRIYNG8Znn32GXq9n+/btnD59mvHjx5c6Xm5uLtu2bWP69OkV1vuLL77A09OTH3/8EYvFwm233caIESM4efIkFy9eZMeOHaSnp3PjjTcyZcqUOm9PQWixZAdeV74m12jjybcPAleTOZ87d64wQWlUFP369cPHx6fcYkxGJ/ExFjLT7eRmOZBl8PRW4O2rIjhUTVCIypVJHQrnVLVu3brEWrV2ux2TyYTRaCwxVUCr1aLX69HpdGXe5W02OUm9ZOPyJRuZaYX7efsq6dpLT+twNdoaLIwsCC1ZhYFW0dBXU7Rnzx7S09Ndv0uSRDWmm5UpMDCQ4cOHV3u/KVOmMGLECHbt2sWWLVv4/PPP2bZtW4lcOGW55ZZbeOyxx4iJieG2227j0KFDrudmzZrF7bffzu7du9mwYQMbN27k66+/Zs+ePWzbto33338fKExjkJyczMGDB5k2bRoAnTt3LtWrZrfbefzxx5k2bZrrNuvy6r17925OnTrFDz/8ABR+046Li+PAgQPcdtttKJVKgoODXT1lgiBUjVvOPtSWS6g6PchXGx7n+PHjfPHFF6hUKrp27UqvXr0q/ZKWm23n4B4DVouMj5+Sdh21SArIzXaQmmwjKc6KVifRJkJDm/YaPDzLT4nj6elZooeqLLIsk5/r5MplG1cu28jOdADg4amgUxcdoeHqco8hXF9E71XZKgy0Dh06RN++fSstpKrbtWTBwcFMnTqVqVOnMmrUKM6dO0f37t0r3CcoKAiVSsWePXt4+eWXSwRaABEREURERPDXv/6V7t27k5WVhSzLrFq1isjIyFLlVXQr93PPPUe7du2YcU1G7LLqLcsyr776aqlAe8eOHQ22wG5LJN6Erm9qUyxumdtINgfzybrfMRpNeHp6MnjwYLp06VJmnsJrXUmxcXi/AbVGYvhNnnj5lAxwnE6ZtBQ7ibEWLp6zEHPWgl+gktC2GrQaW5XqKcsyhnwn2Zl2Mq7YyUizYzYVfon19lVyQ1cdIWFqPL2rFlyJa/36Jl7/SgKtX375hS+//JKhQ4fSuXNnWrdujV6vx2QykZKSwunTp9m7dy/h4eENHmhd2/PUmHfK7dy5k6FDh6JWq0lLSyM7O5vg4OAq7fvMM89w6NAhTp48SWpqKh06dAAKs+SPHj0aSZKIi4tDoVDg7e3NiBEjWLNmDa+++iqSJHHy5Em6du3KgAED+PbbbxkyZIhr4e8iCxcuJD8/nyVLllSp3iNHjuTTTz9lyJAhqNVqLl68SEhICAMHDuTzzz/nrrvuIiMjg/3793PbbbfVWTsKQkuUk5NDRuyv9HXfR4ZRwae/yQSHhtC5c2ciIiJcuQork3DRwonDJjy9lQwY7l7mBHOFQiI4VE1wqBqzycmleCuJcVZOHDZx4nAC7p6Fy8e4eSiu7i/LWK0yJqMTY4GTvJyry9FotBIBQSoCWqlo1VotJrULVSa+WF5VYaD11FNPkZiYyLZt21ixYgVpaWmu54KDg+nVqxczZ850TYy+HphMphKT1h999FFSUlKYP3++a6hw3rx5BAUFVam8fv36lZg3UeSbb77hxRdfRK/Xo1KpWLFiBUqlkpkzZ7JgwQLGjBmDLMuEhYXx6aef8sADDzB79mzGjBlD586d6dmzJ1CYIuOdd94hMjLSdXfhww8/zL333svu3bvLrPd9991HQkIC48ePR5Zl/Pz8+Oijj7j55pv55ZdfGD16NO3bt2fgwIG1aUpBaHANsayH0+nkypUrxMXFERsbi7szlYf6Z2GwaTgl3cQ99/esVuoRWZY5e9xMzFkLQSEq+gxyr1KST51eQWS0jg5RWgrynRjztSTE5pCX6+DKZRtOZ7GNJdDpJdzcFIRFaPD2VeLjp8LTWyF6sYUqKx5QVWcNw5auWnm0LBYLBoMBd3f3Sucf1YWmmEerqqqzKHR9LCB9bUqJ6qhqW86cOZMxY8Y0ybsOm1IerZoQ3wYLNZc8PBaLhcTEROLi4oiPj8dsNqOQYHwPJQNDLmNXeZPX5u84VdVLmOqwy/zxm5HLSTbCO2jo2ltfYpJ7dRRvS1mWsVkL3/olCZQqqcbltjTN5Zpr6q7H97Ba59E6dOgQvXv3xs/Pr84qJRQSWd4FEN8AG8K3334LwO23317rsoxGoys/1aVLl3A6neh0OsLDw4mO8KWr/gg6awIW987kBd2OrPSoVvlmk5Pf9xnIyXLQuYeO9jdo66x3SZIkNFoRWF1vGjL4SU5OFkHrn6ocaK1du5Z///vfDB48mOHDh9OxY8f6rFeLUh89VpX5+uuv6/0Yb7/9dr0fQxDqUm3f9O12O7GxsZw5c4bExERkWcbb25uePXvSrl07wgI0eOTsRJe/G9mmJi/oTsyefQq7jaohL8fBb3sLsFpk+g5xIySs9PQCQRCahyoHWosXLyY+Pp69e/fy1ltvodVqGT58OMOGDavyfKTriVgUWqhIZd8sr5eu9oaksOczo18SSbk6tPlHsenCcap8qxQE5efnc+zYMU6dOoXFYsHDw4M+ffrQsWNHAv080RrPoM/bjDrpIkhKTD5DMPgMR1ZVnDqhLCmXrBw9aEStlhg8ygMfv2ot4CEIQhNTrb/gonQD9913HydOnOCzzz5j3bp1REVFMWbMGIYMGVLlO2gEQShJBFf1oyio7dTGi++W30PXVgVor6wDwKlww65tjV3TCocmALvaH6fSA1nphqzQkZ6RyeHDR0mIj0GnctIjMpTOHQJp5QUq2yXUpoMo49KRkHGofDH63ojJe0C152JB4byp86fMnD9lwcdPSb+hZd9ZKAg1Jd5jGke1vyqlpqayd+9e9u7diyRJTJkyhYCAADZv3szBgwd55pln6qOezVpZw4WNMZwoNE/X46TS+nA+KY//HQ9BQubvD0xCbU5EZUlGZbmMPu83JLl0nqlAoHNHwDVTIg3sQBY4lJ7YtaFY3LthdeuATRcOUs0CI6vFydGDRtJS7IRFqOne163MJXUEQWh+qhxobd68mb1795KamsqgQYN44oknXOvvAQwYMIBHHnmkXirZUoghRKGICJgaj4xU2IulLXaHkOxE4cjHkBlP7Lk/yM1MwUOnIDQ0hJDgVijVemSlHqdCj1Pti0Pth6zQ1Ul9crLsHPrFgNks0623nvBIjUipIAgtSJUDrT/++INJkybRr18/VKrSu2m12hbdm5WVleVa1y89PR2lUum6A/OHH34oMxdWTcXExPDYY48hSRKrVq0iIiKizsquKqfTyYIFC/jll1+QJAmtVsv7779P27Ztq13W+vXree+99wBwc3PjjTfeoEuXLgAsX76cDRs2oFQqkSSJhQsX0rt37zo9l6ZO9FjVr6I2tZidbPvhIpI2odQ2BqOJgwcPc+rUKVQqFb16jeSGXr3QarVY67AuxV/rS0mXiDln4dwJMzq9xJBRHvj6i/lYgtDSVPmveu7cuZVu05KHwPz8/Ni2bRsAb731Fu7u7vz97393PW+328sMQMtTUVtt3ryZcePGVTlwlWUZWZbrbH6c3W7nu+++IzU1le3bt6NQKLh8+XKN81K1adOGr7/+Gh8fH37++WfmzJnDpk2bOHToENu3b2fz5s1otVqysrKwWuvyY61lKCv4EsFZ9VmtMgoC8dYH43TKKBQSFouFP/74gyNHjuBwOOjevTv9+vWr9xxs/r6t+XVXAZnpDkLC1HTvq0cjFmMWhBapypHBihUryi5ApcLf359+/fo1Ss9LY5o5cyY+Pj6cPHmSbt26ceutt7JgwQLMZjM6nY6lS5cSGRnJ2rVr2bZtGyaTifj4eG6++WZ69OiBw+Hg6aef5vjx4675bh06dOA///kPSqWSAwcO8PXXX/PBBx+wdu1aAO655x5mzJhBUlIS9913H4MHD+bw4cO89NJLzJkzh/79+3PkyBE6d+7M5MmTeeutt8jIyGDFihX06tULo9HIvHnzOHv2LHa7naeffppx48axdu1aduzYgcViwWQyMXr0aFq1auUK3oonYtu9ezdLlizBarUSHh7OsmXLcHd3Z+fOnSxYsAA/Pz+6detGQkICn376Kf369XPt27t3b1JSUgBIS0vDz8/Plfy2eI6248eP89JLL2EwGPDz82PZsmW0atWK48ePM3v2bPR6Pf3792fnzp38/PPP9f5aC82fp5cSo/04jozunDyah126yKFDhzCbzXTo0IEhQ4bg4+NTr3WQJAWjht3HrTf/k5xsBz376wmLEEOFgtCSVTnQ0uv17Nmzh759++Lv709mZiaHDx9m8ODBJCcns3HjRmbMmMGIESPqs75NTmxsLGvXrkWpVJKfn8/69etdC0UvXLiQ1atXA3Dq1Cm2bNmCRqNh+PDhPPzww2RmZpKamuoKFHJzc/H29ub+++939ZgdP36cdevWsWnTJmRZZtKkSQwaNAhvb28uXrzI0qVLeeONN0hKSiI+Pp4PPviARYsWMWHCBDZs2MCGDRvYunUr7777Lh999BHLly9nyJAhLF26lNzcXCZOnMiwYcMAOHz4MNu3bycwMJDExERuv/12Dh48yNChQ7nzzjvp2rUrWVlZLF++nLVr1+Lm5sbKlStZtWoVjz32GM8++yzr1q2jXbt2JXr7ivvf//7HjTfeCMCIESNYtmwZQ4cOZdiwYdx6660MGjQIm83GvHnzWLNmDf7+/mzcuJGFCxeydOlSZs+ezSuvvMKgQYN45ZVXGuAVrn9V7ZESCU1rx2w2k551CkmOJ+5KHuCkbdu2DBo0iFatWtX78bMy7Pz3o9PkZjsIClHRrY8bbu6iF0sQWroqB1opKSn861//IioqyvXY+fPnWbt2LS+88AJ//PEHH3/8cYMFWh7p36OypLh+lySJaqwmVCa7NoSCwFuqtc+kSZNQKgtXsc/Ly2PmzJnExcUhSRI229W7mIYOHYqXV+Et3506dSI5OZlOnTqRmJjIvHnzGD16dJlt99tvvzF+/HjXUMbNN9/MwYMHuemmmwgLCyux7mKbNm2Ijo52HWPo0KFIkkRUVBRJSUkA7Nmzh23btvH+++8DhUuHFH3QDx8+HF9fX6CwB2vPnj388ssv/PLLL0yZMoX3338fs9nM+fPn+ctf/gKAzWajT58+xMTE0LZtW9q3bw/AnXfeyeeff17iXIoWKS/Kzu3u7u66W3X//v089thj/Otf/6JHjx6cO3eOqVOnAoXzxYKCgsjLyyM3N5dBgwa5jrFz585qvV4tRVMfLqzt0GZl+9ekfIPBgM1mQ5JyCfTrgk7ZluFDI/ALqPqQf42OW+DgzHEzKUk2tDqJ3oPcaN1GLXqxBOE6UeV3mAsXLpTKBt++fXtiYmKAwjlHmZmZZe5rtVpZsGABdrsdh8PBwIEDmTx5ci2q3XQUn8uxePFiBg8ezIcffkhSUhJ33XWX67nik+UVCgV2ux0fHx+2bdvGrl27+Pjjj/n+++9ZunRpifIrCh6vnUdSfP1JhULhOqZCocDhcLjKW7VqFZGRkSX2PXLkSJnljRo1ilGjRhEYGMiWLVsYPnw4w4cPd01uL3Ly5MkKPzhOnz7Ns88+y2effVZiiFCpVDJ48GAGDx5MVFQUX331Fd27d6dTp058//33JcrIzc0VH05CjRUNU0uSxG13jOTXnQUc2F1A/2HuBASp6/x4+XkOYk6bSU60oVBApy5aOtygq9KC0IIgtBxVDrQiIiL48ssvmTx5MhqNBqvVyldffeWal5WWloaHR9lreanVahYsWIBOp8NutzN//nx69uxZIj1EdV3b89QUFpXOz88nODgYgHXr1lW6fVZWFmq1mokTJxIeHs6sWbNKbTNw4EBmzZrFE088gSzLbN68mXfeeafGdRwxYgRr1qzh1VdfRZIkTp48SdeuXUttd+LECQIDAwkODsbpdHL69Gk6d+5Mnz59+L//+z/i4uJo164dJpOJy5cvExkZSWJiIvHx8URERLBhwwZXWcnJycyYMYPly5fToUMH1+MxMTEoFApXL9ipU6cICwujQ4cOZGVlcejQIfr27YvNZiM2NpYbbrgBLy8vfvvtN/r37+/qGbteNPVeLKh8eLMmPUJ1NfFfkiTXnEO9m4LBozz4dVcBB/cY6D2w/GVuqjNk63TKpKXYSbhoIS3FjlIJ7Tpq6RClFclHhSZD3EzTsKocaD3++OO88847PPjgg3h4eFBQUECHDh148sknASgoKCg3j5YkSeh0hTlnHA4HDoejRfZMPPbYY8ycOZNVq1YxZMiQSrdPSUlh9uzZOJ1OAP71r3+V2qZbt27cfffdTJw4ESicDN+1a1fXUGB1zZw5kwULFjBmzBhkWSYsLIxPP/201HYZGRk8++yzrrsAe/bsyUMPPYROp2PZsmU8/vjjrueee+45OnTowKJFi3jggQfw8/Ojf//+nD17FoBly5aRnZ3N888/DxQGxT/99JNrYn5eXh4qlYqIiAgWLVqERqPhgw8+YP78+eTl5eFwOHjkkUe44YYbXPO09Ho9I0eOrFEbCLVXlTfquhgyDAgIKNFTW5cfEDq9gsE3enBwj4FDvxgJDrXRpZe+wnlTZR1TdspkZjhIvWTlcpINi1lGp5fo1EVLREctWnE3oSBc1yS5ChObnE4nu3btYujQoeTl5ZGdnY2vry8BAQFVPpDT6WTOnDmkpqYybtw47rvvvkr3uXz5confjUZjubddN4UerZaiLtpy//79vP/++2UGcXUlKSmJBx98sMy7Diu6Vurb9bBifXkBT23nVlUWaBVXk0Cr6FoZNWqU6zGnQyb2vIXzp8zIQHCompdefZIz5/ZjNOWV2P/SpUtYzDI3j7+TNqHRdOrQl769RmOzySiUEBSspk07DUEhKhSKpvVl8nq4LutCc2un2vYSF1fXvVvNrS1rq/jd+cVVKdACeOihh/j4449rXRGDwcCSJUt4+OGHSyW/3L59O9u3bwfgzTffLJVT6cqVK+W+6QpNyy+//MJ7773HF198UW/HSExM5L777mPPnj2lnrNYLA1yJ1lZroegv/jfocViqbdyr23L+jouQEG+jWOHskmMM2A2Fc5pNJsNBAX7oJAkbDYnFosDu+3qW2ZaegJDR3SjdRs3wtq6odY03d6r6+G6rAvNrZ1q+zdRn39Tza0ta6u8xOVVDrTeffddBg0aRN++fWtdma+++gqtVsutt95a4XaiR6txtIS2FD1adacx53PUdVv+97//BeDee+8tdxvZKTNi+K10iOiJt1cg9983HVkGlUpCpQY3DyWP/u2vJKdcIC8/o9nMcWlp12V9aW7tVN93+NZm/+bWlrVVXo9Wledo2Ww2li5dSqdOnfD39y8xx+qJJ56ocN+8vDyUSiXu7u5YrVZOnDjhSg8gCELzUVdBV2MFbwaDodJtJIXEnn3fV7jN9p1f11WVBKFWavv301y+KDRnVQ602rRpQ5s2bWp0kOzsbFauXInT6USWZQYNGlQi/5MgCIIgCEJLVOVA6+67767xQcLDw1m0aFGN9xcEoWFVZbJ7ZdvW9ljNRXOvv9Cy1ff1Ka75ylVrqfjjx4/zyy+/kJuby9y5c7l48SImk6nMPEyCILQ8dRVIVRa8CYIgtBRVvkXmp59+YvXq1YSEhHDmzBmgcIb9//73v3qrXFOSlZXF2LFjGTt2LD179qRPnz6u36+9O7K2YmJiGDt2LDfddBPx8fF1WnZVJSUl0aFDB8aOHcvIkSOZM2eOK9+XIAiCIAhVU+UerR9//JEXXniBoKAgNm7cCBR+E732zsCWys/Pj23btgHw1ltvuRZ9LmK321GpqtVBWK7Nmzczbtw4nnnmmSptL8sysiy7sl7XVtEdh+Hh4Wzbtg273c7kyZPZvHkzEyZMKLFdXZ2z0LBqmgerLM1pMm6PHj3qvEwxdCI0ZeL6bHxV/pQ0mUylEpRe7x+0M2fOxMfHh5MnT9KtWzduvfVWFixYgNlsRqfTsXTpUiIjI1m7di3btm3DZDIRHx/PzTffzLx583A4HDz99NMcP34cSZKYMmUKHTp04D//+Q9KpZIDBw7w9ddf88EHH7B27VqgMDP8jBkzSEpK4r777mPw4MEcPnyYl156iTlz5tC/f3+OHDlC586dmTx5Mm+99RYZGRmsWLGCXr16ubKxnz17FrvdztNPP824ceNYu3YtO3bswGKxYDKZeOutt1znqVKp6Nu3L/Hx8SW2MxqNrFq1iqeffprExER0Oh2LFi2ic+fOGAwG5s2b5zq3WbNmMXHiRHbv3s2SJUuwWq2Eh4ezbNky3N3def3119m6dSsqlYrhw4czf/58vv/+e5YtW4ZCocDLy4v169c31kst1EJTeqPv379/Y1dBEITrTJWjpOjoaDZs2MAdd9zheuynn36iS5cu9VKx5iI2Npa1a9eiVCrJz89n/fr1qFQq9uzZw8KFC1m9ejVQuI7fli1b0Gg0DB8+nIcffpjMzExSU1Nd2apzc3Px9vbm/vvvd/WYHT9+nHXr1rFp0yZkWWbSpEkMGjQIb29vLl68yNKlS3njjTdISkoiPj6eDz74gEWLFjFhwgQ2bNjAhg0b2Lp1K++++y4fffQRy5cvZ8iQISxdupTc3FwmTpzIsGHDADh8+DDbt28nMDCQuLg41zmaTCb27dvHM888Q3p6ums7X19f5s2bR9euXfnoo4/Yt28fTz31FNu2bePtt9/G09OTHTt2AJCTk0NWVhbLly9n7dq1uLm5sXLlSlatWsVDDz3ETz/9xJ49e5AkidzcXADefvttvvjiC0JCQlyPCeUTk7IrV7RSwQMPPFDm89f7xH5BAHEd17UqB1rTpk1j4cKF7NixA7PZzFNPPYWbmxtz5sypz/qV60jK5+SYE1y/S5JEFXOvlstHF07vkMqXBipu0qRJKJVKoDBf2MyZM4mLi0OSJGw2m2u7oUOH4uXlBUCnTp1ITk6mU6dOJCYmMm/ePEaPHs2IESNKlf/bb78xfvx4V/LNm2++mYMHD3LTTTcRFhZWIk1GmzZtiI6Odh1j6NChSJJEVFSUa23EPXv2sG3bNt5//32gMBNw0R/S8OHD8fX1dZWXkJDA2LFjkSSJcePGMWrUKNauXVtiu99++80VTA4dOpTs7Gzy8vLYu3cv77333tW29fFh27ZtnD9/3pVDzWaz0adPHzw9PdFqtTzzzDOMHj2aMWPGANC3b19mzZrFLbfcws0331yt10WoWF2uT9ic1HXma0EQhMpUOdDy9fXljTfeICYmhoyMDPz9/YmMjKyzeUHNVfHs44sXL2bw4MF8+OGHJCUlcdddd7meK56aX6FQYLfbXcHHrl27+Pjjj/n+++9ZunRpifIrCh6vzXxefCkFhULhOqZCocDhcLjKW7VqFZGRkSX2PXLkSKnyiuZoVXTcsupXFPReu3C4LMsMHz68RABW5IcffmDfvn1s3LiRNWvW8NVXX7Fw4UKOHDnCjh07uOmmm9i6dSt+fn5ltoVQc9fjt9fr8ZwFQWgc1ZpgJUkSHTt2pEOHDq7HnE5nowRb1/Y8NYVlY/Lz8wkODgZg3bp1lW6flZWFWq1m4sSJhIeHM2vWrFLbDBw4kFmzZvHEE08gyzKbN2/mnXfeqXEdR4wYwZo1a3j11VeRJImTJ0/WKj3HwIEDWb9+PbNmzWL//v34+fnh6enpOs7LL78MFA4d9unTh//7v/8jLi6Odu3aYTKZuHz5MsHBwZhMJkaPHk3v3r0ZOnQoAPHx8fTu3ZvevXuzbds2Ll++LAKtCoiAofaa08R+Qagv4jquW1UOtGJjY/nwww9JTEwslc6gaKL29e6xxx5j5syZrFq1iiFDhlS6fUpKCrNnz3alTfjXv/5Vaptu3bpx9913M3HiRKBwMnzXrl1dQ4HVNXPmTBYsWMCYMWOQZZmwsDDXvJWamD17NrNnz2bMmDHodDrefvttAJ566imef/55Ro0ahUKhYPbs2UyYMIFly5bx+OOPu66h5557Dg8PD6ZNm4bFYkGWZRYsWADAq6++SlxcHLIsM3To0Ot+PqAgCILQ/FR5Uemnn36aPn36MHz48BJDVACBgYH1UjmxqHTjaAlteb0vKt1Shsbqui2L5hPOmDGjzspsLprCddkcNOd2Kiv5b23//stLKFyVcptzW9ZErReVzsjI4J577ik170YQBKG5qEpPsyAIQl2qcqDVr18/jh07Rs+ePeuxOoIgVFdVe69aSi9XbXTu3LnUY6JdBEGoT1UOtGw2G0uWLCEqKgofH58Szz3xxBN1XS9BEGpBBAxlW7NmDQAPP/xwI9dEEOqeWDS6aapyoBUWFkZYWFh91qVStc2TJVw/xLUilKW5zz0UBKH5qfJkeIDjx4+zb98+8vLymDt3LhcvXsRkMtUqPUBFrp0MbzKZUKvVZS770xImcDcVzb0t7XY7NpsNvV7fKMe/3iaA1qe6bstj857C35hLfHwCgwYNqrNyr/Xrr7+W+Xh9HrMyarW6RBJloWzXczsVv27r4lptKm0ptWmHYmr93wBT68nwP/30Ez/++COjR4/m4MGDQGESzqKcTA1Bp9NhNpuxWCylJuVrtVqR9bmONOe2LFpcW6fTNXZVBEEQBKHqgdaPP/7ICy+8QFBQEBs3bgQKJ5Fe2+tUnyRJKreXQvQi1B3RlkJLdbBtYS62l9ZuI3n9zno7zpTybomvx2NWxk/8XVfJ9dxOxa/burhWr+e2LK7KgZbJZCIgIKDEY3a7vcxhPEEQmg5xV91VRT3h9d0O13s7C82TuG7rR5XXzomOjmbDhg0lHvvpp59Etm5BEJqNW265hVtuuaWxqyEIwnWkyt1R06ZNY+HChezYsQOz2cxTTz2Fm5sbc+bMqXTfjIwMVq5cSU5ODpIkMWbMGCZMmFCriguCIFRX0VqkgiAIDaXKgZavry9vvPEGFy9eJD09HX9/fyIjI6u0oLRSqeT++++nffv2mEwm5s6dS/fu3Rs9XYQgXA/EcMBVH330EVD4xVEQhJoR0xGqp1oTrCRJIjIyksjIyGodxNfXF19fXwD0ej2hoaFkZWWJQEsQhAblcDgauwqCIFxnqjxHq66kpaURFxdX7WBNEARBEAShuWnQWwbNZjNvvfUWDz30EG5ubqWe3759O9u3bwfgzTffLHWXY0VUKlW1thfKJ9qydkT71Z36asvr8fUR12XViHaqXFXzLIq2LNRggZbdbuett95i2LBhDBgwoMxtxowZw5gxY1y/Vyf/hsj9VHdEW9aOaL+6U19teT2+PuK6rBrRTnXnemvL8jLDN8jQoSzLvP/++4SGhjJp0qSGOKQgCIIgCEKjq9ZahzV19uxZ5s+fT9u2bV0JA++55x569+5d34cWBEEQBEFoNA3SoxUVFcW6detYsmQJixcvZvHixXUeZM2dO7dOy7ueibasHdF+dUe0Zd0RbVk1op3qjmjLQg1+16EgCIIgCML1QgRagiAIgiAI9aTFBFrF71YUake0Ze2I9qs7oi3rjmjLqhHtVHdEWxZqkMnwgiAIgiAI16MW06MlCIIgCILQ1DRoZvjiMjIyWLlyJTk5OUiSxJgxY5gwYQIFBQUsW7aM9PR0AgMDmTVrFh4eHuTn57N06VJiYmIYOXIk06dPd5X12muvkZOTg8PhICoqikceeaTMxa6//PJL9uzZQ0FBAZ999pnrcZvNxooVK4iNjcXT05OZM2cSFBTUIO1QF5pSW54+fZpPPvmEhIQEZs6cycCBAxukDWqjKbXfpk2b2LFjB0qlEi8vLx577DECAwMbpB3qQl22ZZGFCxeSlpbGW2+9VeYxY2NjWblyJVarlV69evHwww8jSVKzvBaLNKV2bOrXZFNqq61bt7JlyxYUCgU6nY6//e1vzWpN36bUlkUOHDjA0qVLeeONN+jQoUO9nXu9khtJVlaWfPHiRVmWZdloNMpPPvmknJSUJH/22Wfyt99+K8uyLH/77bfyZ599JsuyLJtMJvnMmTPyli1b5P/85z8lyjIYDLIsy7LT6ZQXL14s79u3r8xjnjt3Ts7KypLvu+++Eo9v3rxZ/uCDD2RZluV9+/bJS5curbPzbAhNqS2vXLkix8fHy++++67866+/1uVp1pum1H4nTpyQzWazLMuyvGXLluv6WpRlWT5w4ID89ttvy7Nnzy73mHPnzpXPnTsnO51O+bXXXpOPHDkiy3LzvBaLNKV2bOrXZFNqq6K/f1mW5d9//11+9dVX6+o0G0RTasuiOsyfP19+/vnn5ZiYmDo804bVaEOHvr6+tG/fHgC9Xk9oaChZWVn8/vvvjBgxAoARI0bw+++/A6DT6YiKikKj0ZQqq2jdRIfDgd1uLxENF9epUyd8fX1LPX7o0CFGjhwJwMCBAzl58iRyM5q61pTaMigoiPDw8HL3a4qaUvt17doVrVYLQMeOHcnKyqr9CTagumxLs9nMpk2buPPOO8s9XnZ2NiaTiU6dOiFJEsOHD3eV3RyvxSJNqR2b+jXZlNqq+Bq+ZrO52V17TaktAdauXcutt96KWq2uy9NscI02dFhcWloacXFxREZGkpub6/oA8vX1JS8vr0plvPbaa8TExNCzZ89qDxFkZWXh7+8PgFKpxM3Njfz8fLy8vKp3Ik1AY7dlc9eU2u/nn3+mZ8+eNd6/sdW2Lf/3v/9xyy23lPkmXqT43y6Av79/kwsEaqsptWNTvyabQltt3ryZH374Abvdzvz582txNo2rsdsyLi6OjIwM+vTpw/fff1/Ls2lcjT4Z3mw289Zbb/HQQw+V+DZQXf/3f//HBx98gM1m4+TJk9Xat6zeq+b2TQSaRls2Z02p/fbs2UNsbCy33nprjevRmGrblvHx8aSmptK/f/8Kt2tOPc810ZTasalfk02lrcaPH8+7777LX//6V7755ptq16MpaOy2dDqdfPLJJzzwwAPVPnZT1Kg9Wna7nbfeeothw4YxYMAAALy9vcnOzsbX15fs7Oxq9SppNBr69u3L77//TteuXZkzZw4Affv2ZcqUKeXu5+/vT2ZmJv7+/jgcDoxGIx4eHrU7uQbWVNqyuWpK7Xf8+HG+/fZbXnzxxWbZZV4XbXn+/Hni4uJ4/PHHcTgc5Obm8uKLLzJ//vwSbXnTTTeRmZnp2i8zMxM/P7/6O7kG1JTasalfk02prYoMHjyY1atX1+FZNoym0JZms5mkpCReeuklAHJycli0aBHPPfdcs5wQ32iBlizLvP/++4SGhjJp0iTX43379mX37t3cdttt7N69m379+lVYjtlsxmQy4evri8Ph4OjRo0RHR6NQKFi8eHGV6tKnTx927dpFp06dOHDgAF26dGlWPVpNqS2bo6bUfnFxcaxevZrnn38eb2/vWp1XY6irtrzpppu46aabgMIhjIULF/Liiy8ClGpLvV7P+fPn6dixI3v27GH8+PF1e1KNoCm1Y1O/JptSW6WkpBASEgLAkSNHXD83F02lLd3c3Pjwww9d27z44ovcf//9zTLIgkZMWHr27Fnmz59P27ZtXUHNPffcQ8eOHVm2bBkZGRkEBAQwe/ZsV+/S448/jtFoxG634+7uzrx58/Dw8GDhwoXYbDacTiddu3blwQcfRKlUljrm559/zr59+1yR+ahRo5g8eTJWq5UVK1YQFxeHh4cHM2fOpFWrVg3aHrXRlNoyJiaGJUuWYDAYUKvV+Pj4sHTp0gZtj+pqSu33yiuvkJiYiI+PDwABAQGub4DNQV21ZfFb4oveqMu7PfzixYu89957WK1WevbsybRp05AkqVlei0WaUjs29WuyKbXVmjVrOHHiBEqlEg8PD6ZNm0abNm3qvxHqSFNqy+JEoCUIgiAIgiCUqdEnwwuCIAiCILRUItASBEEQBEGoJyLQEgRBEARBqCci0BIEQRAEQagnItASBEEQBEGoJyLQEgRBEARBqCdNYq1DQRAajs1m4z//+Q8nTpygoKCA4OBg7rnnHnr16uXa5sSJE3z44YdkZGTQsWNH/vGPfxAYGAjAyZMn+eabb4iNjcXDw4OVK1eWeZzTp0/z4osvcscddzB16tRy65OWlsa///1vLly4QEBAANOmTaN79+5A4aKzq1atIjY2luzsbFasWEFQUFCF57dv3z7++9//kp+fT7du3fjHP/7hyvlTUFDA6tWrXUsj9ejRg0ceeaTMZUbsdjvLly8nNjaW9PR0FixYQJcuXVzPGwwG1qxZwx9//AEUJmmcPHlyjc6zsnpfy2azsXr1ag4ePIhGo+Evf/lLiQST8fHx/Pvf/yY5OZnQ0FAee+wxIiIiKmw3QRDqh+jREoTrjMPhwN/fnxdffJGPP/6YKVOmsGzZMtLS0gDIy8tjyZIlTJkyhY8++oj27dvz9ttvu/bX6XTceOON3H///eUew263s2bNGjp27FhpfZYvX05ERAQfffQRU6dOZenSpa5FayVJomfPnjz99NNVOrekpCRWrVrFE088werVq9FqtfznP/9xPf+///0Pg8HAu+++y7vvvktubi5fffVVueVFRUXxz3/+05Wss7hPPvkEq9XKypUref3119m7dy87d+6s0XlWVu9rffXVV6SmprJy5UoWLFjAxo0bXQGf3W5n0aJFDBs2jDVr1jBixAgWLVqE3W6vpPUEQagPItAShOuMTqdj8uTJBAUFoVAo6NOnD0FBQcTGxgLw22+/0aZNGwYNGoRGo+Huu+8mPj6e5ORkACIjIxk+fHiFPUubNm2iR48etG7dusK6XL58mbi4OCZPnoxGo2HgwIG0bduWAwcOAODj48O4ceOqnBF679699OnTh86dO6PT6ZgyZQoHDx7EZDIBhb1K/fr1w83NDTc3N/r168elS5fKLEulUjFx4kSioqJQKEq/VR4+fJhbb70VrVZLUFAQN954Y7mBVmXnWVm9r7V7927uvPNOPDw8CAsLY/To0ezatQuAU6dO4XA4mDhxImq1mgkTJiDL8nW1QLwgNCUi0BKE61xOTg4pKSmupUKSkpIIDw93Pa/T6QgODiYpKalK5aWnp7Nz507uuuuuSre9dOkSrVq1Qq/Xux4LDw8vN/ipSnnF6x4cHIxKpSIlJQWAcePGceTIEQoKCigoKODgwYP07NmzRscqS/E2evPNN9mwYYOrXhWdZ2X13rBhA2+++SZQOPyZnZ1dYvuIiAjXsYtev+LLmISHh1f59RMEoW6JOVqCcB2z2+28++67jBgxgtDQUKBwcWwvL68S27m5uWE2m6tU5po1a5gyZQo6na7Sbc1mc6n5UW5ubmRlZVXxDKpWXlHPULt27bDb7UyfPh2Arl27Mm7cuBodq0ePHmzYsIHHH3+c3Nxcdu7cicVicT0/d+7cSutVdJ6V1fu2224rUVbR88W3LXq8srIEQWhYokdLEK5TTqeTFStWoFKpmDZtmutxnU5X6kPZaDRWKXA6dOgQJpOJwYMHl/n87Nmzuf/++7n//vs5c+YMOp0Oo9FYYhuTyVSi56c8Z86ccZU1e/bscutevLxly5YREhLCJ598wieffEKrVq145513Kj1WWaZNm4ZGo+HJJ59k0aJFDBkyBH9//zK3rew8K6v3tWUVPV+k+OtT3utXlTYVBKHuiR4tQbgOybLM+++/T25uLv/6179Qqa6+FbRp04bdu3e7fjebzVy5csU1tFiRkydPEhsby4wZM4DCD3iFQkFiYiLPPfccS5cuLbH95cuXSUtLKxFUJCQkMGTIkEqPFR0dzWeffVbisbCwMBISEly/X7lyBZvNRkhICFB4N9706dNdQclNN93ECy+8UOmxyuLh4cGTTz7p+v2///1vuXPJwsLCKjzPyup97XF9fX1JSEhw3bWYkJDgen3atGnDpk2bkGXZNXyYmJjI+PHja3SegiDUjujREoTr0OrVq0lOTmbOnDloNJoSz/Xv35/ExEQOHDiA1Wrl66+/Jjw83DW06HQ6sVqtOBwOZFnGarW67mibMmUKy5cvZ/HixSxevJi+ffsyevRo/vGPf5RZj9atWxMREcFXX32F1Wrlt99+IyEhgYEDB7q2sVqt2Gw2oHCo02q1lntew4YN4/Dhw5w5cwaz2czatWsZMGCAK7iJjIzk559/xmq1YrVa2b59e4VpD2w2m+t4RceWZRmA1NRU8vPzcTqdHD16lB07dnDnnXfW6Dwrq/e1hg8fzjfffENBQQHJycns2LGDkSNHAtClSxcUCgU//fQTNpuNzZs3A4XDpIIgNDxJLnrXEAThupCens7jjz+OWq0ucTfdo48+yrBhwwA4fvw4H330Eenp6a48WkV3GZ46dYqXXnqpRJmdO3fmxRdfLHWslStX4u/vX2kerffee8+VX2r69Okl8kuVlZtq3bp15Za3b98+vvjiCwoKCkrlo0pLS+Ojjz7i/PnzyLJMZGQk06ZNK7PnCODxxx8nPT29xGNFubz279/PJ598gsFgICQkhL/+9a8lJta//vrrREVFcccdd1TpPCuq9/r16zl79izPP/88UHkerbi4ON5//30uXbpEWFgYf//732nXrl25bSYIQv0RgZYgCIIgCEI9EUOHgiAIgiAI9UQEWoIgCIIgCPVEBFqCIAiCIAj1RARagiAIgiAI9UQEWoIgCIIgCPVEBFqCIAiCIAj1RARagiAIgiAI9UQEWoIgCIIgCPVEBFqCIAiCIAj15P8B4Jdx5fx/+0QAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 720x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot mean of predictions\n",
+    "for dataset in results.keys():\n",
+    "    for model in results[dataset].keys():\n",
+    "        ds_preds = results[dataset][model]\n",
+    "        plot_prediction(ds_preds, data_i, label=f\"{model}\")\n",
+    "    plt.title(dataset)\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 262,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-10-29T13:28:27.910307Z",
+     "start_time": "2020-10-29T13:28:26.688378Z"
+    },
+    "scrolled": false
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -14095,130 +14499,35 @@
     },
     {
      "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>BaselineLast</th>\n",
-       "      <th>RANP</th>\n",
-       "      <th>LSTM</th>\n",
-       "      <th>LSTMSeq2Seq</th>\n",
-       "      <th>TransformerSeq2Seq</th>\n",
-       "      <th>TransformerProcess</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>IMOSCurrentsVel</th>\n",
-       "      <td>1.63</td>\n",
-       "      <td>23.31</td>\n",
-       "      <td>19.44</td>\n",
-       "      <td>14.52</td>\n",
-       "      <td>46.98</td>\n",
-       "      <td>7.35</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>BejingPM25</th>\n",
-       "      <td>1.71</td>\n",
-       "      <td>1.48</td>\n",
-       "      <td>1.41</td>\n",
-       "      <td>1.39</td>\n",
-       "      <td>2.86</td>\n",
-       "      <td>1.44</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>GasSensor</th>\n",
-       "      <td>1.88</td>\n",
-       "      <td>-2.24</td>\n",
-       "      <td>16.40</td>\n",
-       "      <td>-1.53</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.63</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>AppliancesEnergyPrediction</th>\n",
-       "      <td>1.56</td>\n",
-       "      <td>1.31</td>\n",
-       "      <td>1.94</td>\n",
-       "      <td>1.57</td>\n",
-       "      <td>2.33</td>\n",
-       "      <td>1.08</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>MetroInterstateTraffic</th>\n",
-       "      <td>1.76</td>\n",
-       "      <td>-0.27</td>\n",
-       "      <td>-0.17</td>\n",
-       "      <td>-0.25</td>\n",
-       "      <td>4.15</td>\n",
-       "      <td>-0.27</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
+      "image/png": "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\n",
       "text/plain": [
-       "                            BaselineLast   RANP   LSTM  LSTMSeq2Seq  \\\n",
-       "IMOSCurrentsVel                     1.63  23.31  19.44        14.52   \n",
-       "BejingPM25                          1.71   1.48   1.41         1.39   \n",
-       "GasSensor                           1.88  -2.24  16.40        -1.53   \n",
-       "AppliancesEnergyPrediction          1.56   1.31   1.94         1.57   \n",
-       "MetroInterstateTraffic              1.76  -0.27  -0.17        -0.25   \n",
-       "\n",
-       "                            TransformerSeq2Seq  TransformerProcess  \n",
-       "IMOSCurrentsVel                          46.98                7.35  \n",
-       "BejingPM25                                2.86                1.44  \n",
-       "GasSensor                                  NaN                0.63  \n",
-       "AppliancesEnergyPrediction                2.33                1.08  \n",
-       "MetroInterstateTraffic                    4.15               -0.27  "
+       "<Figure size 576x648 with 6 Axes>"
       ]
      },
-     "execution_count": 34,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "df_results.xs('nll', level=1).round(2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-10-27T13:01:42.420773Z",
-     "start_time": "2020-10-27T13:01:42.362236Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/wassname/anaconda/envs/seq2seq-time/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
-      "  and should_run_async(code)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# ds_preds.to_netcdf(trainer.logger.experiment.log_dir+'/ds_preds2.nc')"
+    "dataset='BejingPM25'\n",
+    "n = len(results[dataset].keys())\n",
+    "\n",
+    "plt.figure(figsize=(8, 1.5*n))\n",
+    "plt.suptitle(f'Plots with confidence for {dataset} ')\n",
+    "for i, model in enumerate(results[dataset].keys()):\n",
+    "    plt.subplot(n, 1, i+1)\n",
+    "    ds_preds = results[dataset][model]\n",
+    "    if i==n-1:\n",
+    "        # The last one has the legend\n",
+    "        plot_prediction(ds_preds, data_i, title=f\"{model}\", std=True, legend=True)\n",
+    "    else:\n",
+    "        plot_prediction(ds_preds, data_i, title=f\"{model}\", std=True, )\n",
+    "        \n",
+    "        # share the x axis\n",
+    "        locs, _ = plt.xticks()\n",
+    "        plt.xticks(locs, labels=[])\n",
+    "        plt.xlabel(None)\n",
+    "plt.subplots_adjust()"
    ]
   },
   {
@@ -14226,22 +14535,38 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-10-26T12:37:48.346152Z",
-     "start_time": "2020-10-26T12:37:48.248720Z"
-    },
-    "lines_to_next_cell": 2
+     "end_time": "2020-10-29T13:27:13.984227Z",
+     "start_time": "2020-10-29T13:27:13.901770Z"
+    }
    },
    "outputs": [],
    "source": []
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "lines_to_next_cell": 2
+    "ExecuteTime": {
+     "end_time": "2020-10-29T13:05:05.698677Z",
+     "start_time": "2020-10-29T13:05:05.618208Z"
+    }
    },
-   "source": [
-    "# Plots"
-   ]
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -14279,7 +14604,7 @@
     "height": "calc(100% - 180px)",
     "left": "10px",
     "top": "150px",
-    "width": "209.208px"
+    "width": "209.2px"
    },
    "toc_section_display": true,
    "toc_window_display": true
diff --git a/seq2seq_time/data/dataset.py b/seq2seq_time/data/dataset.py
index 837b043..4974602 100644
--- a/seq2seq_time/data/dataset.py
+++ b/seq2seq_time/data/dataset.py
@@ -31,6 +31,7 @@ class Seq2SeqDataSet(torch.utils.data.Dataset):
         assert df.index.freq is not None, 'should have freq'
         assert_no_objects(df)
 
+        self.freq = self.df.index.freq
         self.df = df.dropna(subset=columns_target).ffill()
 
         self.window_past = window_past
@@ -93,7 +94,8 @@ class Seq2SeqDataSet(torch.utils.data.Dataset):
         y_future = pd.DataFrame(y_future, columns=self.columns_target, index=t_future)
         return x_past, y_past, x_future, y_future
 
-
+    def show_batches(self, i=0):
+        raise Exception('not implemented')
         
     def __len__(self):
         return len(self._x) - (self.window_past + self.window_future)
diff --git a/seq2seq_time/predict.py b/seq2seq_time/predict.py
index 41b796c..5ff8a13 100644
--- a/seq2seq_time/predict.py
+++ b/seq2seq_time/predict.py
@@ -49,6 +49,7 @@ def predict(model, ds_test, batch_size, device='cpu', scaler=None):
                 "y_true": (["t_source", "t_ahead",], y_future),
             },
             coords={"t_source": t_source, "t_ahead": t_ahead, "t_behind": t_behind},
+            attrs={'freq': ds_test.freq, "model": str(model), "targets": ds_test.columns_target}
         )
         xrs.append(xr_out)