diff --git a/neural_processes/models/lstm_seqseq.py b/neural_processes/models/lstm_seqseq.py
index 3472cbd..e9ed616 100644
--- a/neural_processes/models/lstm_seqseq.py
+++ b/neural_processes/models/lstm_seqseq.py
@@ -143,6 +143,7 @@ class LSTMSeq2Seq_PL(PL_Seq2Seq):
         "learning_rate": 0.001,
         "lstm_layers": 4,
         'bidirectional': False
+        
     }
 
     @staticmethod
@@ -165,5 +166,6 @@ class LSTMSeq2Seq_PL(PL_Seq2Seq):
             "input_size_decoder": 17,
             "context_in_target": False,
             "output_size": 1,
+            'min_std': 0.005,
         }
         return trial
diff --git a/neural_processes/models/lstm_std.py b/neural_processes/models/lstm_std.py
index 9429a28..84c55b8 100644
--- a/neural_processes/models/lstm_std.py
+++ b/neural_processes/models/lstm_std.py
@@ -36,7 +36,7 @@ class LSTMNet(nn.Module):
         self._min_std = _min_std
 
         self.lstm1 = nn.LSTM(
-            x_dim=self.hparams.x_dim,
+            input_size=self.hparams.x_dim+self.hparams.y_dim,
             hidden_size=self.hparams.hidden_size,
             batch_first=True,
             num_layers=self.hparams.lstm_layers,
@@ -48,29 +48,70 @@ class LSTMNet(nn.Module):
         )
         self.mean = nn.Linear(self.hidden_out_size, 1)
         self.std = nn.Linear(self.hidden_out_size, 1)
+        self._use_lvar = 0
 
     def forward(self, context_x, context_y, target_x, target_y=None):
-        loss_scale = 1
         device = next(self.parameters()).device
-        x = torch.cat([context_x, context_y], -1).detach()
+        target_y_fake = (
+            torch.ones(context_y.shape[0], target_x.shape[1], context_y.shape[2]).float().to(device) * self.hparams.nan_value
+        )
+        loss_scale = 1
+        context = torch.cat([context_x, context_y], -1).detach()
+        target = torch.cat([target_x, target_y_fake], -1).detach()
+        x = torch.cat([context, target * 1], 1).detach()
 
         outputs, (h_out, _) = self.lstm1(x)
         # outputs: [B, T, num_direction * H]
-        y_pred = self.mean(outputs).squeeze(2)
-        log_sigma = self.std(outputs).squeeze(2)
-
-        loss = None
-        if target_y is not None:
-            loss = (
-                F.mse_loss(
-                    y_pred * loss_scale, y[:, -steps:, :] * loss_scale, reduction="none"
-                )
-                / loss_scale
+        steps = context_y.shape[1]
+        mean = self.mean(outputs)[:, steps:, :]#.squeeze(2)
+        log_sigma = self.std(outputs)[:, steps:,:]  #.squeeze(2)
+        
+        if self._use_lvar:
+            log_sigma = torch.clamp(
+                log_sigma, math.log(self._min_std), -math.log(self._min_std)
             )
+            sigma = torch.exp(log_sigma)
+        else:
+            sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma)
+        y_dist = torch.distributions.Normal(mean, sigma)
 
-            assert torch.isfinite(loss)
+        # Loss
+        loss_mse = loss_p = None
+        if target_y is not None:
+            loss_mse = F.mse_loss(mean, target_y, reduction="none")
+            if self._use_lvar:
+                loss_p = -log_prob_sigma(target_y, mean, log_sigma)
+            else:
+                loss_p = -y_dist.log_prob(target_y).mean(-1)
+            if self.hparams["context_in_target"]:
+                loss_p[: context_x.size(1)] /= 100
+                loss_mse[: context_x.size(1)] /= 100
+            # # Don't catch loss on context window
+            # mean = mean[:, self.hparams.num_context:]
+            # log_sigma = log_sigma[:, self.hparams.num_context:]
 
-        return y_pred, dict(loss=loss), dict()
+            # Weight loss nearer to prediction time?
+            weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]
+            loss_p = loss_p / torch.sqrt(weight)  # We want to weight nearer stuff more
+
+        y_pred = y_dist.rsample if self.training else y_dist.loc
+        return (
+            y_pred,
+            dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()),
+            dict(log_sigma=log_sigma, dist=y_dist),
+        )
+        # loss = None
+        # if target_y is not None:
+        #     loss = (
+        #         F.mse_loss(
+        #             y_pred * loss_scale, y[:, -steps:, :] * loss_scale, reduction="none"
+        #         )
+        #         / loss_scale
+        #     )
+
+        #     assert torch.isfinite(loss)
+
+        # return y_pred, dict(loss=loss), dict()
 
 
 class LSTM_PL_STD(PL_Seq2Seq):
@@ -79,7 +120,7 @@ class LSTM_PL_STD(PL_Seq2Seq):
 
     DEFAULT_ARGS = {
         "bidirectional": False,
-        "hidden_size_power": 4,
+        "hidden_size_power": 5,
         "learning_rate": 0.001,
         "lstm_dropout": 0.39,
         "lstm_layers": 4,
@@ -100,12 +141,12 @@ class LSTM_PL_STD(PL_Seq2Seq):
             "grad_clip": 40,
             "max_nb_epochs": 200,
             "num_workers": 4,
-            # "num_extra_target": 24 * 4,
             "vis_i": "670",
-            # "num_context": 24 * 4,
             "x_dim": 18,
+            "y_dim": 1,
             "context_in_target": False,
-            # "output_size": 1,
             "patience": 3,
+            'min_std': 0.005,
+            'nan_value': -99.9
         }
         return trial
diff --git a/neural_processes/models/transformer.py b/neural_processes/models/transformer.py
index 4f02dce..4831937 100644
--- a/neural_processes/models/transformer.py
+++ b/neural_processes/models/transformer.py
@@ -18,6 +18,7 @@ class NetTransformer(nn.Module):
         super().__init__()
         hparams = hparams_power(hparams)
         self.hparams = hparams
+        self._min_std = hparams.min_std
 
         hidden_out_size = self.hparams.hidden_out_size
         enc_x_dim = self.hparams.x_dim + self.hparams.y_dim
@@ -50,11 +51,13 @@ class NetTransformer(nn.Module):
         #     norm=decoder_norm
         # )
         self.mean = nn.Linear(hidden_out_size, self.hparams.y_dim)
+        self.std = nn.Linear(hidden_out_size, self.hparams.y_dim)
+        self._use_lvar = 0
 
     def forward(self, context_x, context_y, target_x, target_y=None):
         device = next(self.parameters()).device
         target_y_fake = (
-            torch.ones(context_y.shape).float().to(device) * self.hparams.nan_value
+            torch.ones(context_y.shape[0], target_x.shape[1], context_y.shape[2]).float().to(device) * self.hparams.nan_value
         )
         context = torch.cat([context_x, context_y], -1).detach()
         target = torch.cat([target_x, target_y_fake], -1).detach()
@@ -76,69 +79,107 @@ class NetTransformer(nn.Module):
         # print(outputs.shape, 'outputs')
 
         # Seems to help a little, especially with extrapolating out of bounds
-        steps = target_y.shape[1]
-        mean = self.mean(outputs)
-        mean_target = mean[:, -steps:, :]
-        mean_context = mean[:, :-steps, :]
+        steps = context_y.shape[1]
+        mean = self.mean(outputs)[:, steps:, :]
+        log_sigma = self.std(outputs)[:, steps:, :]
+        # mean_target = mean[:, -steps:, :]
+        # mean_context = mean[:, :-steps, :]
 
-        loss = None
+        if self._use_lvar:
+            log_sigma = torch.clamp(
+                log_sigma, math.log(self._min_std), -math.log(self._min_std)
+            )
+            sigma = torch.exp(log_sigma)
+        else:
+            sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma)
+        y_dist = torch.distributions.Normal(mean, sigma)
+
+        # Loss
+        loss_mse = loss_p = None
         if target_y is not None:
-            y = torch.cat([context_y, target_y], 1)
-            y_mask = torch.isfinite(y) & (y != self.hparams.nan_value)
-            y[~y_mask] = 0
-            y = y.detach()
+            loss_mse = F.mse_loss(mean, target_y, reduction="none")
+            if self._use_lvar:
+                loss_p = -log_prob_sigma(target_y, mean, log_sigma)
+            else:
+                loss_p = -y_dist.log_prob(target_y).mean(-1)
+            if self.hparams["context_in_target"]:
+                loss_p[: context_x.size(1)] /= 100
+                loss_mse[: context_x.size(1)] /= 100
+            # # Don't catch loss on context window
+            # mean = mean[:, self.hparams.num_context:]
+            # log_sigma = log_sigma[:, self.hparams.num_context:]
 
-            loss_scale = 100
-            # loss = F.mse_loss(mean * loss_scale, y * loss_scale, reduction='none') / loss_scale
+            # Weight loss nearer to prediction time?
+            weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]
+            loss_p = loss_p / torch.sqrt(weight)  # We want to weight nearer stuff more
 
-            loss_target = (
-                F.mse_loss(
-                    mean_target * loss_scale,
-                    y[:, -steps:, :] * loss_scale,
-                    reduction="none",
-                )
-                / loss_scale
-            )
-            loss_context = (
-                F.mse_loss(
-                    mean_context * loss_scale,
-                    y[:, :-steps, :] * loss_scale,
-                    reduction="none",
-                )
-                / loss_scale
-            )
+        y_pred = y_dist.rsample if self.training else y_dist.loc
+        return (
+            y_pred,
+            dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()),
+            dict(log_sigma=log_sigma, dist=y_dist),
+        )
+        # mean_target = mean[:, -steps:, :]
+        # mean_context = mean[:, :-steps, :]
 
-            y_mask_target = y_mask[:, -steps:, :].detach()
-            y_mask_context = y_mask[:, :-steps, :].detach()
-            # loss_target = loss[:, -steps:, :]
-            # loss_context = loss[:, :-steps, :]
-            # print(0, loss_context.sum(), loss_target.sum())
+        # loss = None
+        # if target_y is not None:
+        #     y = torch.cat([context_y, target_y], 1)
+        #     y_mask = torch.isfinite(y) & (y != self.hparams.nan_value)
+        #     y[~y_mask] = 0
+        #     y = y.detach()
 
-            weight = (
-                (torch.arange(loss_target.shape[1]) + 0.5)
-                .float()
-                .to(device)[None, :, None]
-            )
-            # weight /= weight.sum()
-            # print(1.0, loss_context.sum(), loss_target.sum())
-            loss_target = loss_target / torch.sqrt(
-                weight
-            )  # We want to weight nearer stuff more
-            # print(1.5, loss_context.sum(), y_mask_context.sum(), loss_target.sum(), y_mask_target.sum(), (loss_context * y_mask_context).sum())
-            loss_context = (loss_context * y_mask_context.float()).sum() / (
-                y_mask_context.sum() + 1.0
-            )
-            loss_target = (loss_target * y_mask_target.float()).sum() / (
-                y_mask_target.sum() + 1.0
-            )  # Mean over unmasked ones
-            # print(2, loss_context.sum(), loss_target.sum())
+        #     loss_scale = 100
+        #     # loss = F.mse_loss(mean * loss_scale, y * loss_scale, reduction='none') / loss_scale
 
-            # Perhaps predicting the past, as a secondary loss will help
-            loss = loss_context / 100.0 + loss_target
+        #     loss_target = (
+        #         F.mse_loss(
+        #             mean_target * loss_scale,
+        #             y[:, -steps:, :] * loss_scale,
+        #             reduction="none",
+        #         )
+        #         / loss_scale
+        #     )
+        #     loss_context = (
+        #         F.mse_loss(
+        #             mean_context * loss_scale,
+        #             y[:, :-steps, :] * loss_scale,
+        #             reduction="none",
+        #         )
+        #         / loss_scale
+        #     )
 
-            assert torch.isfinite(loss)
+        #     y_mask_target = y_mask[:, -steps:, :].detach()
+        #     y_mask_context = y_mask[:, :-steps, :].detach()
+        #     # loss_target = loss[:, -steps:, :]
+        #     # loss_context = loss[:, :-steps, :]
+        #     # print(0, loss_context.sum(), loss_target.sum())
 
-        return mean_target, dict(loss=loss), dict()
+        #     weight = (
+        #         (torch.arange(loss_target.shape[1]) + 0.5)
+        #         .float()
+        #         .to(device)[None, :, None]
+        #     )
+        #     # weight /= weight.sum()
+        #     # print(1.0, loss_context.sum(), loss_target.sum())
+        #     loss_target = loss_target / torch.sqrt(
+        #         weight
+        #     )  # We want to weight nearer stuff more
+        #     # print(1.5, loss_context.sum(), y_mask_context.sum(), loss_target.sum(), y_mask_target.sum(), (loss_context * y_mask_context).sum())
+        #     loss_context = (loss_context * y_mask_context.float()).sum() / (
+        #         y_mask_context.sum() + 1.0
+        #     )
+        #     loss_target = (loss_target * y_mask_target.float()).sum() / (
+        #         y_mask_target.sum() + 1.0
+        #     )  # Mean over unmasked ones
+        #     # print(2, loss_context.sum(), loss_target.sum())
+
+        #     # Perhaps predicting the past, as a secondary loss will help
+        #     loss = loss_context / 100.0 + loss_target
+
+        #     assert torch.isfinite(loss)
+
+        # return mean_target, dict(loss=loss), dict()
 
 
 class PL_Transformer(PL_Seq2Seq):
@@ -146,10 +187,10 @@ class PL_Transformer(PL_Seq2Seq):
         super().__init__(hparams, MODEL_CLS=MODEL_CLS, **kwargs)
 
     DEFAULT_ARGS = {
-        "attention_dropout": 0.4151003234623061,
-        "hidden_out_size_power": 2.0,
-        "hidden_size_power": 2.0,
-        "learning_rate": 0.0026738884132767185,
+        "attention_dropout": 0.4,
+        "hidden_out_size_power": 7.0,
+        "hidden_size_power": 7.0,
+        "learning_rate": 0.003,
         "nhead_power": 1.0,
         "nlayers": 2,
     }
@@ -186,9 +227,10 @@ class PL_Transformer(PL_Seq2Seq):
             "vis_i": 670,
             "x_dim": 6,
             "y_dim": 1,
-            "nan_value": -99.9,
             "context_in_target": False,
             "patience": 3,
+            'min_std': 0.005,
+            "nan_value": -99.9,
         }
         [trial.set_user_attr(k, v) for k, v in user_attrs_default.items()]
         [trial.set_user_attr(k, v) for k, v in user_attrs.items()]
diff --git a/neural_processes/models/transformer_seq2seq.py b/neural_processes/models/transformer_seq2seq.py
index 82d85aa..9bdf618 100644
--- a/neural_processes/models/transformer_seq2seq.py
+++ b/neural_processes/models/transformer_seq2seq.py
@@ -36,11 +36,11 @@ from ..utils import hparams_power
 
 
 class TransformerSeq2SeqNet(nn.Module):
-    def __init__(self, hparams, _min_std=0.05):
+    def __init__(self, hparams):
         super().__init__()
         hparams = hparams_power(hparams)
         self.hparams = hparams
-        self._min_std = _min_std
+        self._min_std = hparams.min_std
 
         hidden_out_size = self.hparams.hidden_out_size
         self.enc_norm = BatchNormSequence(self.hparams.input_size)
@@ -187,5 +187,6 @@ class TransformerSeq2Seq_PL(PL_Seq2Seq):
             "context_in_target": False,
             "output_size": 1,
             "patience": 3,
+            'min_std': 0.005,
         }
         return trial
diff --git a/smartmeters-ANP-RNN.ipynb b/smartmeters-ANP-RNN.ipynb
index c583b6c..02a2434 100644
--- a/smartmeters-ANP-RNN.ipynb
+++ b/smartmeters-ANP-RNN.ipynb
@@ -42,8 +42,8 @@
    "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:06.742326Z",
-     "start_time": "2020-04-11T07:44:04.317680Z"
+     "end_time": "2020-04-11T10:55:16.549550Z",
+     "start_time": "2020-04-11T10:55:14.083795Z"
     }
    },
    "outputs": [],
@@ -72,8 +72,8 @@
    "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:06.813887Z",
-     "start_time": "2020-04-11T07:44:06.746696Z"
+     "end_time": "2020-04-11T10:55:16.601275Z",
+     "start_time": "2020-04-11T10:55:16.553482Z"
     }
    },
    "outputs": [],
@@ -88,8 +88,8 @@
    "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:06.960994Z",
-     "start_time": "2020-04-11T07:44:06.817533Z"
+     "end_time": "2020-04-11T10:55:16.723806Z",
+     "start_time": "2020-04-11T10:55:16.604381Z"
     }
    },
    "outputs": [
@@ -127,8 +127,8 @@
    "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:07.024966Z",
-     "start_time": "2020-04-11T07:44:06.963509Z"
+     "end_time": "2020-04-11T10:55:16.777646Z",
+     "start_time": "2020-04-11T10:55:16.726460Z"
     }
    },
    "outputs": [],
@@ -143,8 +143,8 @@
    "execution_count": 5,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:07.096326Z",
-     "start_time": "2020-04-11T07:44:07.028521Z"
+     "end_time": "2020-04-11T10:55:16.831267Z",
+     "start_time": "2020-04-11T10:55:16.780549Z"
     }
    },
    "outputs": [],
@@ -166,8 +166,8 @@
    "execution_count": 6,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:16.212750Z",
-     "start_time": "2020-04-11T07:44:07.099377Z"
+     "end_time": "2020-04-11T10:55:25.924795Z",
+     "start_time": "2020-04-11T10:55:16.834009Z"
     }
    },
    "outputs": [],
@@ -177,37 +177,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:16.892973Z",
-     "start_time": "2020-04-11T07:44:16.216068Z"
+     "start_time": "2020-04-11T10:55:14.100Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f073aad64e0>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Show split\n",
     "df_train['energy(kWh/hh)'].plot(label='train')\n",
@@ -226,17 +202,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:16.949715Z",
-     "start_time": "2020-04-11T07:44:16.897483Z"
+     "start_time": "2020-04-11T10:55:14.100Z"
     }
    },
    "outputs": [],
    "source": [
     "default_user_attrs = {\n",
-    "    'context_in_target': True,\n",
+    "    'context_in_target': False,\n",
     "    'x_dim': 17,\n",
     "    'y_dim': 1,\n",
     "    'vis_i': '670',\n",
@@ -253,11 +228,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:17.012473Z",
-     "start_time": "2020-04-11T07:44:16.954012Z"
+     "start_time": "2020-04-11T10:55:14.100Z"
     }
    },
    "outputs": [],
@@ -279,392 +253,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:41.921146Z",
-     "start_time": "2020-04-11T07:44:17.015255Z"
+     "start_time": "2020-04-11T10:55:14.100Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial.number -40\n",
-      "trial <optuna.trial.FixedTrial object at 0x7f073b3cfe10> {'learning_rate': 0.002, 'attention_layers': 2, 'num_heads_power': 3, 'hidden_dim_power': 7, 'latent_dim_power': 7, 'n_latent_encoder_layers': 2, 'n_det_encoder_layers': 4, 'n_decoder_layers': 4, 'dropout': 0, 'attention_dropout': 0, 'latent_enc_self_attn_type': 'uniform', 'det_enc_self_attn_type': 'uniform', 'det_enc_cross_attn_type': 'multihead', 'batchnorm': False, 'use_self_attn': True, 'use_lvar': True, 'use_deterministic_path': True, 'use_rnn': False} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 200, 'num_workers': 3, 'num_context': 96, 'vis_i': '670', 'num_extra_target': 96, 'x_dim': 17, 'context_in_target': True, 'y_dim': 1, 'patience': 2, 'min_std': 0.005}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "INFO:root:\n",
-      "    | Name                                                                       | Type                 | Params\n",
-      "----------------------------------------------------------------------------------------------------------------\n",
-      "0   | _model                                                                     | NeuralProcess        | 1 M   \n",
-      "1   | _model.norm_x                                                              | BatchNormSequence    | 34    \n",
-      "2   | _model.norm_x.norm                                                         | BatchNorm1d          | 34    \n",
-      "3   | _model.norm_y                                                              | BatchNormSequence    | 2     \n",
-      "4   | _model.norm_y.norm                                                         | BatchNorm1d          | 2     \n",
-      "5   | _model._latent_encoder                                                     | LatentEncoder        | 68 K  \n",
-      "6   | _model._latent_encoder._encoder                                            | BatchMLP             | 18 K  \n",
-      "7   | _model._latent_encoder._encoder.initial                                    | NPBlockRelu2d        | 2 K   \n",
-      "8   | _model._latent_encoder._encoder.initial.linear                             | Linear               | 2 K   \n",
-      "9   | _model._latent_encoder._encoder.initial.act                                | ReLU                 | 0     \n",
-      "10  | _model._latent_encoder._encoder.initial.dropout                            | Dropout2d            | 0     \n",
-      "11  | _model._latent_encoder._encoder.encoder                                    | Sequential           | 0     \n",
-      "12  | _model._latent_encoder._encoder.final                                      | Linear               | 16 K  \n",
-      "13  | _model._latent_encoder._self_attention                                     | Attention            | 0     \n",
-      "14  | _model._latent_encoder._penultimate_layer                                  | Linear               | 16 K  \n",
-      "15  | _model._latent_encoder._mean                                               | Linear               | 16 K  \n",
-      "16  | _model._latent_encoder._log_var                                            | Linear               | 16 K  \n",
-      "17  | _model._deterministic_encoder                                              | DeterministicEncoder | 613 K \n",
-      "18  | _model._deterministic_encoder._d_encoder                                   | BatchMLP             | 51 K  \n",
-      "19  | _model._deterministic_encoder._d_encoder.initial                           | NPBlockRelu2d        | 2 K   \n",
-      "20  | _model._deterministic_encoder._d_encoder.initial.linear                    | Linear               | 2 K   \n",
-      "21  | _model._deterministic_encoder._d_encoder.initial.act                       | ReLU                 | 0     \n",
-      "22  | _model._deterministic_encoder._d_encoder.initial.dropout                   | Dropout2d            | 0     \n",
-      "23  | _model._deterministic_encoder._d_encoder.encoder                           | Sequential           | 32 K  \n",
-      "24  | _model._deterministic_encoder._d_encoder.encoder.0                         | NPBlockRelu2d        | 16 K  \n",
-      "25  | _model._deterministic_encoder._d_encoder.encoder.0.linear                  | Linear               | 16 K  \n",
-      "26  | _model._deterministic_encoder._d_encoder.encoder.0.act                     | ReLU                 | 0     \n",
-      "27  | _model._deterministic_encoder._d_encoder.encoder.0.dropout                 | Dropout2d            | 0     \n",
-      "28  | _model._deterministic_encoder._d_encoder.encoder.1                         | NPBlockRelu2d        | 16 K  \n",
-      "29  | _model._deterministic_encoder._d_encoder.encoder.1.linear                  | Linear               | 16 K  \n",
-      "30  | _model._deterministic_encoder._d_encoder.encoder.1.act                     | ReLU                 | 0     \n",
-      "31  | _model._deterministic_encoder._d_encoder.encoder.1.dropout                 | Dropout2d            | 0     \n",
-      "32  | _model._deterministic_encoder._d_encoder.final                             | Linear               | 16 K  \n",
-      "33  | _model._deterministic_encoder._self_attention                              | Attention            | 0     \n",
-      "34  | _model._deterministic_encoder._cross_attention                             | Attention            | 561 K \n",
-      "35  | _model._deterministic_encoder._cross_attention.batch_mlp_k                 | BatchMLP             | 18 K  \n",
-      "36  | _model._deterministic_encoder._cross_attention.batch_mlp_k.initial         | NPBlockRelu2d        | 2 K   \n",
-      "37  | _model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear  | Linear               | 2 K   \n",
-      "38  | _model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act     | ReLU                 | 0     \n",
-      "39  | _model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d            | 0     \n",
-      "40  | _model._deterministic_encoder._cross_attention.batch_mlp_k.encoder         | Sequential           | 0     \n",
-      "41  | _model._deterministic_encoder._cross_attention.batch_mlp_k.final           | Linear               | 16 K  \n",
-      "42  | _model._deterministic_encoder._cross_attention.batch_mlp_q                 | BatchMLP             | 18 K  \n",
-      "43  | _model._deterministic_encoder._cross_attention.batch_mlp_q.initial         | NPBlockRelu2d        | 2 K   \n",
-      "44  | _model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear  | Linear               | 2 K   \n",
-      "45  | _model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act     | ReLU                 | 0     \n",
-      "46  | _model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d            | 0     \n",
-      "47  | _model._deterministic_encoder._cross_attention.batch_mlp_q.encoder         | Sequential           | 0     \n",
-      "48  | _model._deterministic_encoder._cross_attention.batch_mlp_q.final           | Linear               | 16 K  \n",
-      "49  | _model._deterministic_encoder._cross_attention._W_k                        | ModuleList           | 131 K \n",
-      "50  | _model._deterministic_encoder._cross_attention._W_k.0                      | AttnLinear           | 16 K  \n",
-      "51  | _model._deterministic_encoder._cross_attention._W_k.0.linear               | Linear               | 16 K  \n",
-      "52  | _model._deterministic_encoder._cross_attention._W_k.1                      | AttnLinear           | 16 K  \n",
-      "53  | _model._deterministic_encoder._cross_attention._W_k.1.linear               | Linear               | 16 K  \n",
-      "54  | _model._deterministic_encoder._cross_attention._W_k.2                      | AttnLinear           | 16 K  \n",
-      "55  | _model._deterministic_encoder._cross_attention._W_k.2.linear               | Linear               | 16 K  \n",
-      "56  | _model._deterministic_encoder._cross_attention._W_k.3                      | AttnLinear           | 16 K  \n",
-      "57  | _model._deterministic_encoder._cross_attention._W_k.3.linear               | Linear               | 16 K  \n",
-      "58  | _model._deterministic_encoder._cross_attention._W_k.4                      | AttnLinear           | 16 K  \n",
-      "59  | _model._deterministic_encoder._cross_attention._W_k.4.linear               | Linear               | 16 K  \n",
-      "60  | _model._deterministic_encoder._cross_attention._W_k.5                      | AttnLinear           | 16 K  \n",
-      "61  | _model._deterministic_encoder._cross_attention._W_k.5.linear               | Linear               | 16 K  \n",
-      "62  | _model._deterministic_encoder._cross_attention._W_k.6                      | AttnLinear           | 16 K  \n",
-      "63  | _model._deterministic_encoder._cross_attention._W_k.6.linear               | Linear               | 16 K  \n",
-      "64  | _model._deterministic_encoder._cross_attention._W_k.7                      | AttnLinear           | 16 K  \n",
-      "65  | _model._deterministic_encoder._cross_attention._W_k.7.linear               | Linear               | 16 K  \n",
-      "66  | _model._deterministic_encoder._cross_attention._W_v                        | ModuleList           | 131 K \n",
-      "67  | _model._deterministic_encoder._cross_attention._W_v.0                      | AttnLinear           | 16 K  \n",
-      "68  | _model._deterministic_encoder._cross_attention._W_v.0.linear               | Linear               | 16 K  \n",
-      "69  | _model._deterministic_encoder._cross_attention._W_v.1                      | AttnLinear           | 16 K  \n",
-      "70  | _model._deterministic_encoder._cross_attention._W_v.1.linear               | Linear               | 16 K  \n",
-      "71  | _model._deterministic_encoder._cross_attention._W_v.2                      | AttnLinear           | 16 K  \n",
-      "72  | _model._deterministic_encoder._cross_attention._W_v.2.linear               | Linear               | 16 K  \n",
-      "73  | _model._deterministic_encoder._cross_attention._W_v.3                      | AttnLinear           | 16 K  \n",
-      "74  | _model._deterministic_encoder._cross_attention._W_v.3.linear               | Linear               | 16 K  \n",
-      "75  | _model._deterministic_encoder._cross_attention._W_v.4                      | AttnLinear           | 16 K  \n",
-      "76  | _model._deterministic_encoder._cross_attention._W_v.4.linear               | Linear               | 16 K  \n",
-      "77  | _model._deterministic_encoder._cross_attention._W_v.5                      | AttnLinear           | 16 K  \n",
-      "78  | _model._deterministic_encoder._cross_attention._W_v.5.linear               | Linear               | 16 K  \n",
-      "79  | _model._deterministic_encoder._cross_attention._W_v.6                      | AttnLinear           | 16 K  \n",
-      "80  | _model._deterministic_encoder._cross_attention._W_v.6.linear               | Linear               | 16 K  \n",
-      "81  | _model._deterministic_encoder._cross_attention._W_v.7                      | AttnLinear           | 16 K  \n",
-      "82  | _model._deterministic_encoder._cross_attention._W_v.7.linear               | Linear               | 16 K  \n",
-      "83  | _model._deterministic_encoder._cross_attention._W_q                        | ModuleList           | 131 K \n",
-      "84  | _model._deterministic_encoder._cross_attention._W_q.0                      | AttnLinear           | 16 K  \n",
-      "85  | _model._deterministic_encoder._cross_attention._W_q.0.linear               | Linear               | 16 K  \n",
-      "86  | _model._deterministic_encoder._cross_attention._W_q.1                      | AttnLinear           | 16 K  \n",
-      "87  | _model._deterministic_encoder._cross_attention._W_q.1.linear               | Linear               | 16 K  \n",
-      "88  | _model._deterministic_encoder._cross_attention._W_q.2                      | AttnLinear           | 16 K  \n",
-      "89  | _model._deterministic_encoder._cross_attention._W_q.2.linear               | Linear               | 16 K  \n",
-      "90  | _model._deterministic_encoder._cross_attention._W_q.3                      | AttnLinear           | 16 K  \n",
-      "91  | _model._deterministic_encoder._cross_attention._W_q.3.linear               | Linear               | 16 K  \n",
-      "92  | _model._deterministic_encoder._cross_attention._W_q.4                      | AttnLinear           | 16 K  \n",
-      "93  | _model._deterministic_encoder._cross_attention._W_q.4.linear               | Linear               | 16 K  \n",
-      "94  | _model._deterministic_encoder._cross_attention._W_q.5                      | AttnLinear           | 16 K  \n",
-      "95  | _model._deterministic_encoder._cross_attention._W_q.5.linear               | Linear               | 16 K  \n",
-      "96  | _model._deterministic_encoder._cross_attention._W_q.6                      | AttnLinear           | 16 K  \n",
-      "97  | _model._deterministic_encoder._cross_attention._W_q.6.linear               | Linear               | 16 K  \n",
-      "98  | _model._deterministic_encoder._cross_attention._W_q.7                      | AttnLinear           | 16 K  \n",
-      "99  | _model._deterministic_encoder._cross_attention._W_q.7.linear               | Linear               | 16 K  \n",
-      "100 | _model._deterministic_encoder._cross_attention._W                          | AttnLinear           | 131 K \n",
-      "101 | _model._deterministic_encoder._cross_attention._W.linear                   | Linear               | 131 K \n",
-      "102 | _model._decoder                                                            | Decoder              | 593 K \n",
-      "103 | _model._decoder._target_transform                                          | Linear               | 2 K   \n",
-      "104 | _model._decoder._decoder                                                   | BatchMLP             | 590 K \n",
-      "105 | _model._decoder._decoder.initial                                           | NPBlockRelu2d        | 147 K \n",
-      "106 | _model._decoder._decoder.initial.linear                                    | Linear               | 147 K \n",
-      "107 | _model._decoder._decoder.initial.act                                       | ReLU                 | 0     \n",
-      "108 | _model._decoder._decoder.initial.dropout                                   | Dropout2d            | 0     \n",
-      "109 | _model._decoder._decoder.encoder                                           | Sequential           | 294 K \n",
-      "110 | _model._decoder._decoder.encoder.0                                         | NPBlockRelu2d        | 147 K \n",
-      "111 | _model._decoder._decoder.encoder.0.linear                                  | Linear               | 147 K \n",
-      "112 | _model._decoder._decoder.encoder.0.act                                     | ReLU                 | 0     \n",
-      "113 | _model._decoder._decoder.encoder.0.dropout                                 | Dropout2d            | 0     \n",
-      "114 | _model._decoder._decoder.encoder.1                                         | NPBlockRelu2d        | 147 K \n",
-      "115 | _model._decoder._decoder.encoder.1.linear                                  | Linear               | 147 K \n",
-      "116 | _model._decoder._decoder.encoder.1.act                                     | ReLU                 | 0     \n",
-      "117 | _model._decoder._decoder.encoder.1.dropout                                 | Dropout2d            | 0     \n",
-      "118 | _model._decoder._decoder.final                                             | Linear               | 147 K \n",
-      "119 | _model._decoder._mean                                                      | Linear               | 385   \n",
-      "120 | _model._decoder._std                                                       | Linear               | 385   \n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "step 0, {'val_loss': '0.5680903792381287', 'val/loss_mse': '0.32917723059654236', 'val/loss_p': '0.5680903792381287', 'val/sigma': '1.0602203607559204'}\n",
-      "\r"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c4965ace04a1428d8d619490afefbbed",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:root:Detected KeyboardInterrupt, attempting graceful shutdown...\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeXyTRf7H39O7pZSj5Sy05UaQQ+VSUBBRwANBRdQqoALLqrjitSz420UFT3Y9UUFFERAQXTkUBUQFYVVURBDkEKSlFLD3mTbX/P6YPM3RJE3apEkhn9errybzTOaZTOaZz3yP+X6FlJIQQgghhBDOXYQFugMhhBBCCCEEFiEiCCGEEEI4xxEighBCCCGEcxwhIgghhBBCOMcRIoIQQgghhHMcISIIIYQQQjjHESKCIIAQYpwQ4oQQolQIcYEQYr8QYlg93HeYECLL3/fxoB+ThRA7At2PEEI4VxEiguDAAuA+KWW8lPJnKWVPKeXXAEKIuUKI5YHqmBDib0KIP4QQZUKI34QQXS3lsy3Epf3phBBmIUSS5Xq0EGKJEKJYCHFaCPFgoL5DbSGE6CuE+EkIUW7539eDz3QRQlTY/mZCiDZCiPVCiGwhhBRCpLn5fLQQ4m0hRIYQokQIsUcIMdqhzhVCiIOWfn0lhEi1uXazEOJ/lmtfO3wuSQixUwiRJ4QoFEJ8K4QYXMP3WSyEOGT5bSc7XJtkGZdiIUSWEOI5IUSEm7Y8qu9sDF20N9Myt4otcy3a4brTueukncuFEPssY5InhPhYCJFsc92ruVzD7xOUz0WICAIIm4cgFdgfyL44gxBiCnA3cA0QD1wL5AJIKZ+yEFe8lDIeeBb4WkqZa/n4XKAL6rtdDjwqhBhVz1+h1hBCRAHrgOVAM2ApsM5S7g4LgR8cyszA58CNHtw6AjgBDAWaAI8BH2jkYSHa/wL/BzQHfgRW23w+H3gReMZJ26XAXUALy3d6FtjgbvEGfgHuAXY7uRYHPAAkAQOBK4CH3bTlaX1nY2gHIcRIYJaljVSgI/C4zXWXc9cJDgAjpZRNgbbAEeB1m+tz8XAue/D7eNxWvUJKGfpz8gecB3wNFKIW6TGW8oHAaSDcpu44YK/ldRhqgh4F8oAPgOaWa2mARE3QTOBb1MMpgTLgqKXecWAEMArQAwZLvV+c9PPvwIcOZS8BL1te3wn8BpQAx4C/2NQbBmS5+P5hqAXpCg/GSljanmRTlg1cZfP+SWCVi89PBnbYvL8EtRAUWf5f4lD3mOX7/AGkW8o7A9ssn8kFVtfx978KOAkIm7JMYJSbz9xi+b3nAsudXI+w/NZpXvZlL3Cj5fU04H821xoBOqC7w2emoIjZVZthwHWW/rT0oA87gMk11HkQ2ODF96pWv6YxtKn3PvCUzfsrgNPezl0n7UYDTwMHajmX3f4+3rRVn38hicAJhBCRwAZgM9ASmAGsEEJ0k1J+j1q0h9t85DbUxMRSdyxqR9cWKEDtcGwxFEU0w6XaTQP0kVJ2sq0kpfwceAq1qMVLKfs46e4q4GohRGNL38OBm2368ydqN5SAIoUXhBAXejAM7Sx/5wtlv/hDCPG4EMLZnLkUNU4fWfrQDGiD2k1q+AXoWdNNhRDNgU+Bl4FE4D/Ap0KIRCFEI0v5aCllYxRh7LF89EnU79XM0u9XbNrcaxH7nf295qIrPVHkbhuDZa+r7yCESACeQC1uPoMQohXQFavE2BObcZVSlqE2HTWOrU2be4EKYD3wlpTyTx919zK8k2zt6ns5hnbjYHndSgiRSA1zVwiRYvntU2zunSKEKEQt2g8Dz1nKa5zLlraGOOuX7e9Tl+fC33AnEp7LGIQSJ5+RUpqBL4UQnwC3onYqKy2vt1gW4KuxirjTUfr+LFA6fiBTCHGHTftzLROkzpBSZgghdqOkkvdQBFUupfzOcv1Tm+rbhBCbUQu3M1HfFu0s/68CegFNUQttFvCmQ91JKKmk1PJeI7cimzpFQGMPvtI1wBEp5TLL+5VCiPtRu9c1KDXL+UKITCnlKeCUpZ4BJW63tYx9lfFZStnbg/s6It6h/zV9hyeBt6WUWUKIWtyuOiwbkhXAUinlQZt+5XjRr2qQUvYWQsSg5kxNqi5P+3oX0A8lidS2vjdj6Pj7aK8bozZg4GLuSikzLWVV0MosG5GpgO1427avvW5s81nbttz9PnV5LvyKkETgHG2BExYS0JABaAak94EbLMapG4DdUsoMy7VU4GNtx4lSy5iAVjZtnfBxf99HERPYSycIIUYLIb4TQuRb+nM1SkdbE3SW/89JKQullMeBRZbPV0EIEQeMR+nQNWiEkGBTloBS59SEtqixtkUGkGwhzwkosj0lhPhUCNHdUudRlIpql1BeV3d5cC93KMW+/+DiOwhlRB4BvFDHe9q2GQYsQ6kG76tNv9xBSlkhpVwJzBJC9LHc09b4n1JDE7Z9HYtSp4yWFhuRECLdpq3PPKjv7Rg6joP2ugQP564zSCnzsdqDIvB+Lrv7feryXPgVISJwjmygvYMaJAWlM0ZKeQC1OI3GYeFFLfKjpZRNbf5ipJQnbep4E/LVk7prgGFCiHaoXd77oDwUUOqaBUAry85lI2rBrAmHUIuQ7f2d9WUcykD5dVUlKQtQO3VbVVYfPFMbZKPI1Ba2Y79JSnklSsQ+iEU6kVKellJOlVK2Bf4CvCaE6AxgIYZSF39vuOjHfqC3sN+a9nbxHYah7D+ZQojTKOnwRouk5jUs93wbtXm4UUppcOhXH5u6jYBOLvrlCSJRhlakjfHfskP2pK+jUL/BdVLKfVq5lHKFTVuja6qP92NoNw6W12eklHl4PnddIQKl6kyoxVx2+fvU8bnwLwJtpAjGP5S4fAxl9I1ETdISbAxyKCPtV6jdR5JN+UzUophqed8CuN7yOg01ISMc7ieBzjbvjwMjLK+no9QcYTX0+TNgC/CzTVljlDQyFLX4jwbKgXmW68NwYSy2XH8P+MTSTjvUwnu3Q53NwBNOPvsMynjbDOiOegCcGlqxMRaj7AKFKIKNQEkAhSgpphVwPcoAF4byEtlm+dx4oJ3ldU/L79KxjnMgA/gbyoB4n+V9lJO6cUBrm78FwIdAC5s6MZZ+S6AbEOPm3m8A3wHxTq61QKkTbrS0+Szwnc31cEv5dGC75XWk5dogYIjlu8Wi5nAJSp3mbhxigJ0olUmMNhdRasg84DIPx9RlfU/G0KH+KJTTRg+UmudLlCrX47lrU/cGy28SZhnfD1BSfm3mck2/j8dt1edfQG8ezH+WxUTzQjkAjHO4noLSV3/qUB6GMnYdsjxkR7F4N1A7IkhEEUGB7eR00t87LO084lB+L3AGtZguQxmXPSWCBEv9EpSk80/svWiSAaNt322uRQNLgGLL/R90c5/J2HsNDQF+soz9T8AQS3kbm9+kEEW4PSzXnkNJDaWWMZ/mgzlwgeX+OpRN5QKba7OBz1x8bi4OHi+W38buz8VnUy3XKyzfRftLt6kzArWw6SxjkOYwlo73etdybSjKOFmCkuK2UcMibmnfsb1hlmtfWX5/2346HRNv6zsbQyd1HrTMrWLgHSDak7mLenZLgRTL+xkoD7QyFLmswrKR82QuW9q61MPfx+Pnoj7/tIEJIYQQQgjhHEXIRhBCCCGEcI4jRAQhhBBCCOc4QkQQQgghhHCOI0QEIYQQQgjnOEJEEEIIIYRwjqPBhZhISkqSaWlpdWpDr69eJgRERoLBABER6r0jjEYwm6uXBwOifBIoIIQQQjhb8dNPP+VKKVs4u9bgiCAtLY0ff/yx1p83GODkyerlQkDr1nDqFDRrBk2aVK+TlaXIINgQHg7t2we6FyGEEEIwQwjhGLqlCuecaqiy0nm5lFBQYF/HZAKdJWpJaWlwkgCovocQQggh1BbnHBE4UwtpqKiwr1NSArm5ihCKHONQhhBCCCGcJTjniMCVRGALo1Et/qWl6v/p00qlFKwISQQhhBBCXXBOEYGU7iUCWxQWWlVBwUwCECKCEEIIoW44p4jAYPB80SwJeITwEPyFYCf2EEKob/iVCIQQo4QQh4QQvwshZjm5niqE2GpJJfi1JZ6+3+CJWqih4myUCvzlqpuX5592QwihocJvRGDJnbsQFQO/B3CrEKKHQ7UFwHtSpRJ8ApW1yG/wVC0UQuBgS2ilpa7r1Rbl5cop4GwkzhBCqC38KREMAH6XUh6TUupRMb6vd6jTA5VQAlSscsfrPkWwun/6AmfLwma7+PuaCIqLlRcYnD3jFUL945dffuH777/HHKynS2sBfxJBMva5ebOw5vzV8AsqOxColIeNhRCJfuzTWYuzZWErKlLfxWRSEpzJ5Jt2CwshP9+qbjqLnuEQ6hlPP/00gwYN4o477qCwsDDQ3fEJAm0sfhgYKoT4GZU96SQqtaIdhBDThBA/CiF+zMnJqe8+huAH2C7EmvHWYFBSW0WF9UyHL6Q4o7H6OZCzhThDqH906tQJgPfff5/vvvsuwL3xDfwZYuIkYBv4oJ2lrApSymwsEoEQIh6VqLsaxUopFwOLAfr16xd6hJ2gIS1sRqPa7cfFWU90t2xpXfzLy62xngwGiI6u/b209h3HpyGNVwjBhfnz56PT6di5cycREQ0uSo9T+PNb/AB0EUJ0QBHALaiE5FUQQiQB+VJKM/APVC7PEM5CmM0QZpE/KyutRGAwqDAeJpPVq0uns9ati0RQVKRUQs4W/RAReAaDQdlqIiMhPj7QvVEwm82EhQVWmfGf//wnoPf3Nfw2mlJKI3AfsAn4DfhASrlfCPGEEGKMpdow4JAQ4jDQCpjvr/6c7Qj2hU1b/EH91xb9ykrV97Iya5kmMYBVbVRa6p1e32BwTQIQ/OMVCJjNioQNBmVYz85WARqLioLL0eL111+nb9++rF27tt7vnZmZSak/3NkCDL/SqpRyo5Syq5Syk5RyvqXsn1LK9ZbXH0opu1jqTJFSnsWe/r5HcbH1AQ3Ghc22T5WV1gB+tqSgLf4lJc4Pemnfr6zM+nkpa/6+eXnu6wTjeAUSOp1a9M+cUf/z84PX3XrdunX88ssvTJ48mQMHDtRYf+PGjTzwwANUaLrHOuCqq66icePG7N+/H+Cs8RwKtLE4hDqgpCS4g+GVlVlf6/XWhVyvV7tPW8nA1Wlfg0HVraiwfr683P3hwNJSq73BFc6S59cn0Ovhzz/de2gFE3Fu2LABgKKiIo4cOVJj/X//+9+89NJLvPPOO3W+d2xsLDExMeh0OpKTk7nwwgvr3GYw4OywdJzlMJlUzgFQC7+WK0Fb8BITg+tB1aDTKd1ydLRauM1m639Qfa8p3IPZrL6nlIoAQI1BXBzExFSvbzKp3WxNCMbxCgRMJkUCNY1HMI1XdHQ069atIysri169etVY/7777uP333/nsssuq/O9f/75Z6SU5OXlkZ2d7VTKKC6GhIQ636peESKCBoCcHJU0B5TYHhOjFlfbHXcwQpMCIiKsu01bt2tP4zkVF6v/ZrP6vF5vNSY7Ii/Ps91+MC1sgYDRqIi1sLBhSUdSSoQQjBkzpubKFowbN45x48b5rA9CCBITE8nIyKBNmzZIqTY0UVFqc1NQoDYqDcmhKKQaagAoLFQLqtGoFsWCAqueXa9XD3SwLWxms9UjyFbXrKl3wPPgb7aGSo1INCOzLQoLrVJDTQi28aovVFYqI3BWlv0Bu5oQDON1/PhxOnTowJw5c2qsazKZmDVrFt9++y3SD503GAStWqUQGRlJWZn1xLomvWpJrhoKQkTQAKDXq52uNrkKCuylgeLi4HhQbaHp8G1tA76ElOoeJpOSmP78017a8OTz5xp0OpWKtTZG4GAYr40bN5KRkcGRI0c4deoUmzZtYvfu3U7rbt++nWeffZb09HQAysrKWLRoEa+99lqt7//WW29x/vnns3DhQsrKrMELi4vVmBYWWp9Lf8x5f6IBCS/nLgwGNeni4tT74mJ7/XgwufZp0BYbKf0TPA6sNpLafP9gWNjqE0ajIszaIhjGa/r06Vx44YVER0ezadMm7rzzTiZOnMjSpUur1U1JSeGhhx4iOTkZIQSVlZVMnz6dJk2acM8999Tq/nv3HmT//v2UlJRQVgYffLCMr75ax4033s2wYaPtNiLBMF7eIEQEQQ5N/2gwWD1hpFQ7YMd6wYDCQkVYtl49/tJB14VgGpJevK4oK/NODRSsCAsLY9CgQQAUFxdz5ZVX0rNnT6d1O3XqxIIFC6reN2nShClTptC8efMqO4Mn0OuV7l9K+Mtf/o+xY28nJSUJoxEOHdrHJ598RPfuFzJs2Gi7zwXL8+gpQkQQ5LAV420nl6vXgYZOpyQWD5+zgCGYxsyfyM+3GtvrgmAbr6FDhzJ06FCP64eHh/Pmm296fZ/8fEUE4eHQqFETOnbsS2Sk2phdd90t9Op1Eeeff5HTz0oZ/M+BhpCNIMjhiT7XkwNW9QEtFajZ7Luoof5CMIyXr1FZaX+uxFckAIEfr2PHjjFlyhReeOGFGusWFhayceNGDh48WKd7mkxKCi8utrc/aU4O559/IddeO4G0tM5OPx/oMfMGISIIcjQEItBUDt6kAg00Gko/PYVer04FFxQoAjh1ynckAIEfr+PHj/P222+zfv16u/JKJycL9+zZwzXXXMOUKVPsynNzczl48CBlHvpd23qgVVbq+fvfp/Dqq2dnFJwQEQQ5PHGxDPRDqu1CG1Iq0ECPma+Rm2sl5OLihvVbeIKuXbuyePFi7r//fkDZCGJiYmjRokW1ujExMVx55ZVcfPHFduXjx4/nvPPO4/vvv3d7r4ICJQ3YEsGZMyf54IO3WblyUVVZcXERa9euYP36lU7baUhzLGQjCFJo+sVglwjMZutJymCNTeMMDekhrQklJe7H/rff9jJr1hSeeGIhffr0r9U9Aj1e7dq1Y+rUqVXv4+Pj0ev1SCkxmUyEa0fvgUGDBrF58+ZqbaSlpdGlSxe39ykuVhubkhL77xwXF8+//vUycXGNqsoKC/OYOfN2kpNTGTPm1mptBXrMvEGICIIUOTkqRr+nRBAo6PXVo4c2BDSkh9QRBQXQqJEyYhoMNR9eWrt2OXv3/sDf/nYrX3/9e63uGWzjFRYWRllZGTExMR57ALmKNVRZqbzw4uPtT7HbIjGxBZMnz3Aoa8m1106gdet2TtsNtjFzhxARBAhr165gwYI5ZGdn0rZtCg8/PJ/rrksnPNx6+tMbIgjUpNP6V1ISnOcZXKEhulJKqVRAZWVqvBMSrKk93eGGGyZy5kw2w4dfU6d7BxK//PILmZmZ9OrVi7S0NEAFgHMGnU5XI0FoBxKjotSYmkzeB3Bs1CieV15Z5fYeDQUhG0EAsHbtCmbPnsbJkxlIKTl5MoPZs6exbNkKQO1KtGibnqpbAk0EDclQDMHfV6Ox+klpjQTAGnfJk+/Rrdv5vPjicqfqi4aCJUuWMGbMGI9yEAwdOpT4+HiXp45BGdRPn4YTJzyzw2VkHGX79s1kZh7zptsNBiEiCAAWLJiDTmcfFEenK+e111QMFU08LSjwbJIGcnfbkNRBtghmIjCZ1CKlxZiSUqkKaxtk8Pjx38nJOVOn2PmBHq/zzjuPa665hq5du1aVzZs3j1GjRrFr1y67ukVFRZSXl5OYmGhXvmzZGrp27c5DD/2jKuChp99r48Y1TJo0khUr3rAr1+nKOXkyk4qK6jElAj1m3iBEBAFAdnam0/Lc3EzKyqwiqiay1oRAqIa0oG+eBo4LNgTzQ1paalWz5eUpUqhLpNn09OEMGNCazz//Lz/99L9atRHo8Zo+fTqffPIJV199dVXZzz//zKZNm8jMtH+eDh06RFFREe3btycvT0Xszc6G3NxKjhw5xNGjzp8/d2jTpj2DB19B587n2ZVPmjSKIUNS2bOnuidSoMfMG4RsBAFA27YpnDyZUa08MTGFrCyruiVYI2mazcpPXYt91BARzA+p7e9uNNbd9tK8eQuys09w773jGThwKKtWfe11G8E4Xo8++ihTpkxxmhwmISEBk8kaDRRg+PBr2LLlAImJLb2+19ix6Ywdm16tvHXrZFq1aovByY4oGMfMFfxKBEKIUcBLQDjwlpTyGYfrKcBSoKmlziwp5UZ/9ikY8PDD85k9e5qdeig6Oo4JE+bXKnxtfUsEmjrIU6IKRgTrQ2oy+V7dtmHDT+Tn53LTTYPp0qWHbxuvJ5SXlxMbG2tnAB44cKDbzzhG5W3SpBlNmjTzab9eftn5GQII3jnmDH5TDQkhwoGFwGigB3CrEMJxFj6GSmp/AXALUPsYsQ0IY8em89RTi2ne3HoYZsaMxQwZUn3HsWPHCmbMSOPWW8OYMSONHTtWVKtT30Tgg9SvAUegT2O7gr/ItXnzJL788hBPPlm7RyzQY9WjRw8iIiI4fvy423qbNn3BZZeNYN68lzxOfOQJTMEeM6WO8KeNYADwu5TymJRSD6wCrneoIwEtqVsTINuP/QkqXHbZSObOXVL1fsGCO6ot9Dt2rODNN6eRm5sBSHJzM3jzzWnVyCAQ9oGzAYFe3Bxhm44z2BDosTIajZjNZhJsckAePnyY119/nU2bNlXFA/ruuwN8881WDh06XM2Jory8jGee+Tvz5z/s9f1vuWUY3bvHemVjCfSYeQN/EkEycMLmfZalzBZzgduFEFnARmAGTiCEmCaE+FEI8WNOXYKqBxE++GAJ999/nU1J9YV+9eo56PX2K4NeX87q1dUzNNXnpGtIJ4jdIZgeVJ1OZQ3zdUKTL77YwLBhnXnuuX8AUFpawvjxlzJ0aCevM3cFcryysrLQ6/U0a2ZV7ezatYt77rmHd99dSn6+IoLRo8fz7rufc+ut06q1ERYWxqJFz/Hee6+6vdeePbuYN+8hO1fRsrISKisriI21N4xt2/Y51113EU8//Wi1doJpftWEQBuLbwXelVL+WwhxMbBMCHG+lNKOy6WUi4HFAP369WtAw+saUVFRTsu1hX7IkHRyc517N+Tl2ZfXNwk0xMNYzhBMD2pZmX8itp46dYKMjKMUFuYD6hDUkSP7KSoq4MyZbFq3dtybBS8iIyPt3nfu3JnJkyczdKjVk6hlyza0bNnG6eejo2P4+9+foXHjJpjNZsJcJL5+550XWb9+JVFRUTz66NMAfPrpz+h05URFRdvVrays4Ndfd9OyZdtq7QTT/KoJ/iSCk0B7m/ftLGW2uBsYBSCl/FYIEQMkAQ5pVxo2KitVsnlQ7oDNm8Nddz3AvHkPOt2VaQt9UlKKRS1kj8TEFLv39aXvDmbVRW0QTA+qv+wuN944iUsuuYLoaJXSTgjB0qWbaNu2PUlJrbxqK9ji6w8aNIhBgwaRleWZZ5UQgunT/15jvSlTHiIiIpJbbpmKwWAgMjISIYRdnCENAwZcxscff0+rVg2bCPypGvoB6CKE6CCEiEIZg9c71MkErgAQQpwHxABnh+7HBtnZ1kmRk6POCZhM1Rd0DVr5zTfPQ9ncrYiKUt5FtqgPIjCZIDPTu7zAwY5geVBNJv+F54iLa0SnTt1o1y61qqxPn/60aNHa4xg9GgI1XkeOHGH48OHMnDmzqsxsVs9RYaF17P75z/v4v/+7l5MnvT8nYItevVSimWHDOrNlyzq3dZs2bU7fvgNo08Z5vKGGAr8RgZTSCNwHbAJ+Q3kH7RdCPCGEGGOp9hAwVQjxC7ASmCy9VVw2AJSWWhf/oiIlFZSVwYQJ84mKso+XYrvQJyd3R0qlLxBCkJSUytSp1b2L6mPEtOByZxM0FZetSiYQB+QaihdWoH7/U6dO8dVXX/Hjjz9W9ePPP9XJ+1Onyvnllx84evQga9YsYfly915RBw/u46uvNpKX536/qdkCiooKKCsrZfLk0Tz66F1e9bshPS9+tRFYzgRsdCj7p83rA8Bgf/YhGKDTqcXfbFaTIz8fXnjhLjZtWkHbtudRUHCSkpI8kpJSmDBhftVCr9dXkJSUSmRkNP/5zyGX7deHRHC2GIhtIaX6TXQ6FXkS1GsHVbTf4U8vrFdfnU9paTGTJ99fZQ/Iz89l4cL56HTlPPXUohpaCDx69erFli1bCAuL5dQpayY8gGefncXSpa/w6KNPs3r1dvbt+5HkZOeSNsAzzzzKtm2f8/bbn1QLwrdz51b++9/3uP32e5g9ewFz575CREQEJ09msm3b5053/VJKXn11PoWFecyZ8287u0OICEKoQkWFNUCYBpMJsrJOYjTqiYqKYfFi57uT7t2HcO+9y1m69G8899y1PProJ07r1ceEO1tcRm2hLSiVlYoIDIazTyL48MN3yMg4yvjx1t1sVFQ0S5a8SFRUFI8//mo1I6wrBGpha9asGSNGjCA7u/o8PP/8C+natSeNGjWmd+9+9O7dz21bvXv3R0pJ48ZNql1buXIxn376AWlpXbjgAuthtWbNEnn7befPnhCCN99cQElJETNm/B9NmzbHbIawsBARhIBa7MPDre6ABoOyD2i4887XyMz8lcTE9s4bsODPP49x/PhusrOdh9yFkERQW2ixkrTFRa+v31DaWlIff47t3/42l1OnTtjtZuPjG/Ovf71M+/YdvGorkAtbWZnzcbrppsncdNNkj9t58MEnXF575JGnSEvrwo03TrIrj4tr5DaE9733ziEsLIzw8AikhOPHoWPHEBGEgPIJT0117WXTqlUnWrXqBMDKlbP55JPnMZuNJCWlVtkIli9/iKKiP4mMjKV798vc3s+fk85sbli5BjyFJhFoIbQrK/3jwunq3qdO+V8CGTfudqfljklWPEEgFra8PNi6dTsHDuyhX78hnH9+9bhCP//8He+88xLjxt3B5Zdf7aQVz5Ca2omHH54HwMmTmTz55APExyewYMG7bj83bdojlJZC48aK2P/8E9q2VfkiGgpC0Ud9CG33X1mpHnK9vmaxf8eOFWzc+B/MZrXS5uZm8MYbd7Jo0V0UFZ0BJAaDjoMHv3EaXgL894BqC+PZKA2AlQi0/3p9/RFBYWHDjdxaX9DrVQKezZvX8fjjf2Pnzq1O623fvokNG1bx1VeehSmTUqKvYVKHhYWxadPHbN++iSNHDrBixRt2p4orKqybvBJr2ysAACAASURBVPx85VEHiriAKltGQ0GICHwEk0mFuwVrPoHcXNcSwZIl9/LYYwNZuvRvGI32ik+TyYDRaD9RXZ0oBv+phsrL1cQORiJYu3YFQ4ak0bFjGEOGpLF2rXOSdAez2boYV1ZaicDfD3B5uXWO+BM5OWfYsmU9Bw/uq3atqKiAtWtX8NFHS922UVGh3J/Ly+tvYcvNVWpUbVHt338IEyfe51L/Hx0dS2xsHOPH31lj2598sppu3aL5+9/vBiAz8xhGo5GPPlrKsmWvceaMinKTlNSKhQvX8NprH/Ldd1/z2GN/5b//fa+qHS28NcD+/Sf4/vttHDyYSX6+9XpDIoKQashH0OnUzsBksj7kOTmujay7d39S7YRwTXBV318TrqJC9T/YDMVahjctequW4Q1wGirYFQwGqwtpWZm9O2lEhLruKw+iwkLvw4vXFXv2fM+0addz+eVXs2TJp3bXzpzJZubM22nXLq2aTtwWWVlqYa7vQ4u2p9dHjhzHyJHjXH7m7rtnMn78nSQmtnBZR0NsbCMMBgNlZSXs2vUNEyZcxvjxd7J//88cOLCHHj360qpVWyIjI7n66psA0OsrueWWqfTseVmV7a+gQLmFt2wJK1f+m88/f4lJk/7NqFEPAvWzofAlQkTgI2iTt6DASgTu4sZcdtlEfv99FxkZP1Nc7NkZuubNXSfJ9vWks3XRC7bAi64yvC1YMMcrIrAlONvXRqMiAl+5khqNnuUW9jUSEpoyfPg19O07qNq1Dh26MmrUjXTrdj5SSqeHy3Q6RQJQf33XvOy8QWRkpEckACrY48GDOqKjY9i9+1sA1qx5h7lzX+HXX3+ia9fz7eqXlsIllwznkkuGs2ePUvm0aKHKAQ4fhrZtu9Ot22AaNbL2IVij27pCiAh8BG2X58zFzRluvvlJwBph1DG4nDOMGfMPp+W+nHTl5SrhjJaBLBjhKsObq3JXcKWj13ZzOp1vDH6BIAGAgQMvY+BA504GkZGRvP76h06vFRQo8tLUHFB/C5uzzdPu3d/Svn0HkpJaeX0a2hHKVVax+wUXDOKJJxYyZMiVdOjQpVrdnTu38uWXPzNixLV069a9Sk1mOw4mE1x55XSuvHJ6tc8H6/PjDCEiqAO00ADR0VYi8Fbs1w6PvfPOfZSXO4/fEBYWzl//utRpvgJwPeG0na03KC5WO7JgkwJs4SrDW5MmzWv87NGjyqMj1rU3LiaTIglfeEpJad09BjN0Oqt6U5MCbKEdhvQ3HJ+fwsJ8brzxEho1imffPt8aVoQQ3HHHPS6vf/jhUtauXUZ5uYGrrrqTyMhEIiIiq2wDNSGYnyFHhIigDqioUA9O+/beE8DXX7+DwVDBgAE3MmRIOh06XMjjj19GaWk+tsFXo6LinIaVALXARERATIzzh1SnU7v78HA1Kc1m56qOigprG5WVahH0lkDqEw8/PJ9HH72zWnrAsrISHnvsHr7+eiPZ2Zm0bZvCww/Pr1IXlZUpu01+PvTv77p9o9F3HkSaa2ogUF5eRmxsnMtdtMlkIiPjKDk5OqCP2376mwg0V1pHtVBxcSG9e/cjNrZRnaUBUB5D999/KwUFuVx66UgKCnLp3bs/ycmpdOt2PjEx1h1C//6jqKxMZMOG51m1ajaPPLKBCy+81m3btn1sSEQQ8hqqA8rLrQZhb3ePS5b8lSVL7uHAga8BSE4+j8WLc7jnnvdISkqtFlvIbDZjtnlKysth5kxYsMD1PbRFHaz+8s6geThUVKj//kiX6EuMHZtOfHx1nY3BoOf999/g5MkMpJRVRmTNo+hPS0zbmh5Q7fv7YvELpMfV3XdfS9euUXz//Xan1z/+eDNXXNGNxx//W43f058kUFZmHW9HpKR0ZN26H2qVZ9kZhBB8881mdu7cyrJlC1m06DnuvXc8Y8cOqPIK0mx8F198GxMnvkDv3leRkNCS+HjnEmdW1gGmTGnGP/5xgV15QwrXHsT7vuBHRYV60LNrkVetWbNkiov/pHlzazz4HTtWsHr1HHJzM6viDg0alM5dd12LTrfZ4pWgDgJlZSmJ4MAB1zkCNN/4mBjXC5JGFjpdcC/+jtDi6zvCMWahTlfO00/PYfTodDuVhxYGwBlsSV3zIKotAkkE5eVlGI1GmjatvoBlZkJ8/IWEh0eSl5fJ889fR6dOA7jhhv9z2pY/bQT1HdF2wYKlREVFk5NzmtOnszh0aB//+99WrrzyesxmOHQIWre29uv++1e5bS8mJp6yskKio+3DVIeI4ByBZtg6c8b7z7700lG79zt2rGDx4qkYDKpRLVvZvn2g030CzKS8vKiqvra7lVL5MztOOi18grYQ6fX2seQLC6FpU+uBt9LShiHKrl27glmzpniVXSsnJ5M9e+wXMncfNxqru5LWFoEkgnXrdlFZWUFEhNIHmkxw+rT6zXNyoGnTVsyd+w2HD3/LsmUzMZtdTwB/EIHBoAzp7g7WufJoqgtGjLjO7r3tPfLy7M8EeYLmzZNZtCiH+PhmduUhIjhH4Mu0gqtXz6kiAQ16fTk//DAHSOeCC57n2msjeO89uPhiKxGA2t1pD6mWBEfTTduqhrQdsF6vxN+EBOt38HWKRH9AOz9QWen8uLYQwilBJCamVFvEzGZlO3EGW0KsKzkG+jCelpBGSjhypPruu3PngSQlpdGyZQdatHAde8jXNgKjsboHjjNMnDiSY8cOsXDhGvr2HeCz+2v2sJgYNW+08wHaITZvEBYWTkJCUrXys4oIhBBhQB+gLaADfpVSnlUZxLxBRYU125gvo0a6Skup06nyjIwIdu6Ezz5TC38LG7fpzEzrpCsuhkaNrAuYZoAzGKxEoOlji4qs6qCG4Orm7PyAhuTkVIYNu5o1a5ag11t1XNHR1RP5gOcPaV2IwFayCBSMRrVpKCpSf87QtGkr+vW73m07vp4fBQWetZmZeZTs7EwSEpr67N67d3/Lli1fkJcnGTHielq27IPZrGKDFRT47DYNQsLW4JIIhBCdgL8DI4AjqMxhMUBXIUQ5sAhY6phf+GxHaakybjVqVPuHw2w2k54eDgiWLdMTERHhMi1lVFQKer3ydPlWnX8hI8P+3idO2EsEBoOVrMxmq0eTFjxOIzBXC0Owwt05geTkVObNe41+/Qbz0EMTMZvNJCQ0ZerUV+nXr7rHlae/XV0e5kBKA0eOHOCxx/5K584Due665+rcni8lgspK9Qx5gi++OMjJkxm0a5fmm5ujwky8885LAOzdu4W5c78BlMRUW3z44eMcP76b2257jrZtuwGB3wR4A3deQ/OA5UAnKeVIKeXtUsqbpJS9gTFAE+CO+uhkMEGvVzusuoQJKC/X/KElERYFtMpWFmdXLyoqjlatrLvZfZaQMaWlcOyYtd6JE9ZFXnN9tPVdt33obMMuNzS0bes64ciuXcozZuzYdPbsKeDoURM//1xA//7Oz154KxHU5kxBIMc5OzuTXbu2s3//Ho/qf/PNctavfxa93rmO0Bc2AinVjvv0ac8/ExkZSVpa56rnxBe44ILL6NSpP5GR0XTteolP2vztt2389NN6O8m+IRGBy9GVUt7q5tqfwIs1NS6EGAW8BIQDb0kpn3G4/gJwueVtHNBSSuk7GdAPqKxUO+mYmNq3EReXwBtvnLEz/mrnBFavnkNeXiaJicpraNMm5wtZRYUy/kZFKb1vfr46KKXB9qG11f/rdA03pPTDD89n1qwpdjaC2Ng4WrZMpm/f/uj1eqKiooiKSiA7G5o0cb14eUsERUXQrJlSr2nnLDQbpjMPJM0OEyj07TuQhQu3kpvr5uScDVavnk1e3gkuvngCLVqkVbvuCyKoqAisFJqdrX6T8867gXnzbvBp22PHzmbkyPtITe1TVeZrdZo7T7e6wiOaFUJcAqTZ1pdSvufyA+oz4cBC4EogC/hBCLHekp5Sa2OmTf0ZwAXVGgoyaLu82ngKaQgLC6NJk5Y0adLSrnzIkPRqB8c+/th1O82aQfPm8PvvyuWtc+ea790QTrm6wtix6ezYsaUqYmZycqrdgTGAv/xlHFu2rKNHj+E8+eQXLtvyVjVUXq5OI8fFqTGMjlavtdg4cTbCnNmspMZA2V1KSiAnpxmtWg2nec2HrQEYOnQyer2OyEjnOxxf7G69nXu7d3/Lu+++TP/+l7o9AewOmhG4osJehepr9Oo1wum9fYnycmtKVV/DE2PxMqATsAfQvpoE3BIBMAD4XUp5zNLOKuB64ICL+rcC//KgzwFFfet9HVVQqanKRgDKYNy2rSKCI0c8M143JHHVGW66aTIZGUdp06YdL7+8str1vLwcpJTs37+Vf/7zSubM2eK0HW+IQDtlrJ3ULi9X7+PilNotLMxKBGaz2iQESuoymdR88FYtNX6868xdUHeJwNZW5Sn++OMIGzasIjw8otZEcPy4IiAhrP03mYzk5BxHCFGVHMof8CURGI32ubV9DU8kgn5AD+mN47ZCMnDC5n0WMNBZRSFEKtAB+NLLe9Q7fKH3PXRoJy+/fCtJSSk8/vgOt3W1hycyUqkkRo6ExYtVWcuW1qBoJSUNV+XjDQYNGsaaNd/Ylb3xxrO8/vozFBcX0aZNO7p1u5hDh74lK2u/y3a8UQ3ZuthqJ7S1wHTl5fbnDHJzA2sbyMpS9//uuzUUFp7iwguvo2VL71JSOkNdjcW1yWcwYMClvPjiCtq0cZ/O1RWMRuUO6vhbZ2buZfbsiwB49NFPueCC2mc103DmzDEOHtxOUlIqPXsqbbdGnr44BuFvSd4TIvgVaA2c8mM/bgE+lFI65VAhxDRgGkBKimuDob9hMvmG5U+dOkx+/glKS907LWuG37AwSefOiwkP78Qll4zgzTfVBLN1IT0XSMAZ1q5dwfPPz6k6DHXq1Alyc3MYMOAGhg51najEUyLQFntQY6z54Wshx7UYTlKq6/WVa8ARpaVK9aHp4L/66m327t1Ey5adPCKCiooyCgqyiY6OszvtrqEuEoEWhttbtG/fweu8yrZwRgIAjRtbff4bNfKNSfLgwW944407GTw43Y4IfAGDwaqO9BfcuY9uQKmAGgMHhBC7gKq9jpRyTA1tnwRsqbydpcwZbgHuddWQlHIxsBigX79+AfN499VOr2vXS7jqqvuIj090W09bVMLDK/jtt+nExycSHZ1L69YqSFfLltZIkQ3JZ9lTFBSo08+2O6rvvttObu5p+vQZiF6fakcCGgyGCo4d+4mZMz9y2bY3KjLb3912odeMwdrhpECRAKizJLbG6QEDbqR16y60adPVo89v3vwqK1fO4tprHyY9/flq1+tCAqdP1+9G5eRJJUG7suMlJaWwcqVEr68gPNw33kjJyedx6aV30K3bkKoyX0gEOTlWr7+AEAHgJpyZR/gB6CKE6IAigFuA2xwrCSG6A82Ab+t4P7/DV0TQtm037rzzlRrraSqJuDhJTEwnkpN7Aipy5uefQ/fu8D9LGtWzSSIwmRTRrVq1gjVr5pCTk0mbNincffd83n33GU6c+JXBg2/kvvs+5NQp52cLXB3Q0+Bro6FOFzhDfGVldQ+lK66Y6lUbzZu3o2XLjsTENHZ6vbYSgZbboDb4+efvOHHiD/r0GUBqqme6/KIiJRl5gqioOrj+OaBz5wF07mxvNq2rOs1g8Py8RV3hzn10W10allIahRD3AZtQ7qNLpJT7hRBPAD9KKddbqt4CrKqFDaLecOaM2n0HylDctGkczzzze1X5hAlw883KG0ILk3A2SAQVFfDbb2phc0zYk52dwbPPTqNFizQiI6Np3lwtDImJzg/ihYdHMG/eCGbN2khERFS1676ebcXFgfMSqk1YBEc481izRW0WNb2+bgvZ6tVvs3r1W8yfv6hGIiguVs+C7fmaQKOuRFCfrraeeA3dADwLtASE5U9KKWvM3SSl3AhsdCj7p8P7uV70NyDIy1OTzFcSwf79X/Lddx/SqVN/hg1zrcfWiMAxiYqtL7H2uqETQWWlNZIqqPMUjlnb9PpyTp06ZJekZ8KE+dUyvIWFhWMyGdi/fys5ORm0aVM9+5SvvacCuY1xTCRjNpvIyNhLQkISiYm1M7Q6ojYSQV3DNfTu3Z+yshI6dnSv3qqoUHMn0DCbTZw48SsxMfG0atWp1lKUXu/d6WtfwBMF2XPAdVLK3/zdmUCgJh2elMojR0p1eMsX2L59Gdu3v8u+fVs8IoK4OMmZM8coKyugY8d+dnU0ImjoqqFjx+wlLleqHbPZxJtvqkT1trvY1167Aykl8fHNmTTpZTZvXoiUkrAw51O8obvRgvIQKi6ubpsoLc1n9uwLiY9vzptv+kBcwPvxKiyseyDD226bxm23TauxnjeRQv2JtWufYs2aZXTt+gKPPdapViRgNiu1aH1vLDw5p3bmbCUBgwH++MP5NW33X1pqJQNfnRRt3/58kpJS6dzZfTRF7QEPCyvjgQc6M2dO9bRammqoIS9sOTnVxeCkJNfeYXp9OatXz6l6P2RIOk2btgHgqqvuZciQdJ544n88+eS3tGrl3OukIY8XqFOyGhE4wmCoICWlN+3a9fS4Pb2+gkceOZ8ZM9Jc1vFkzEwmJQn4O8eA2ay+f36+mj/BgM6dBxEVtZjDh69h06baSVGBUjG68xrSzmD/KIRYDazF3mvov37um99RWqpOgGqJWyIioF07RRAHDkDv3ooANLiLm+4Nrr32Ia699qEa62k7qvJy61DPmJHKhAlPVe2EG7pEUFKiDv04wpnKxxaOEsMzz/yC0ajnww/nsm7dM1x//Sy39w1ei5R75OQoVYi7XXBiYnueffYXr9qNjIzmzJmjGAwVVFSUERPTqFqdmohASwXqKxQW5hMdHUNMTGy1nAR5eYoIggEbNqhDfHfdNQIpVT+//hqmTPFunmkbzkDAnWrINntDOXCVzXsJNHgi0AY907KmCAFJSYocKiuVkTgQP8yuXbBliyIlWMGhQ3+tupabm2mnGmmIRCClNSHJ8ePO7Rsa0b3++iSnCVMSE9vZvU9ISOKHH9bx1VdvEhERRWRkLGvW/B8VFeoHjI9PZNKkl6rabYgSQV4eHD1ac73aQAjBP/+5jTZtujolAXBvh9LrnSe9rwtuvPESjh07xJYtB+jc+Ty7a94ErvM1pIQVK5SL6pgxsGaNFu5dVG0WT55Um8lBgzxrMy/PelAxEHBHBFuATVJK3ygZgxCO7n5SKl21ZqSpTQpKd7BNRdmsWVtuvnkew4ZNBuDnn5Vu8OqrVc6Bgwc1tdUcTKbqRtPVq+cwZEh6g1QNnTjh2dhecomKe+goGURGRnPLLU9Xqx8X14QWLTogpWTZsgfsrpWW5rFo0V2AIpmGJhGYzdYNi79Qk6rSXQA/f8RWioqKJiYmlrg4FVdBO2BpNNavIdURJ0/Cp5+q1waDVVPw44/qvxaGZONGuNO1CbAKlZWBkwQ0uCOC9sAaIUQksBX4DNgVzG6e3kBK537ftjpXX+6yHd0hCwpOsmjRnRw7tou77nqNd99VD1OfPtZFUk12509/Xp4qb0gSgcmkdo2eEuzs2Rdx4sSv9Oo1gv37v8Ro1NO4cRITJ75YzdXx2LEfeeml8YSFRRAZ6fzkjdGoryLQhkKcJSVqQxAR4bnX2ubNC9mw4TlGjpzBtdc+7LO+uNqt5ub6Z/599pm9euvYMWUT8HHmSo+g18N770HPnvbuuhoh2KKychqwmJ07PWs7GLIDujtH8CzwrBCiMSo5zV3AG0KI34DPUdJCHWJwBhZlZfW7i3bmDgmwZcsbdO06mKIitbDt3+9oAEwBqvvJJyYqY2pDOUeQk6MeZG+2EXl5JzCbjXTs2I9Zsz5zW7dRo0RKSjTdhOuVQiPQhrKdOXnS+xPL+fknyc3NdJlbwBXy8rJYu/YpwsLCuPPOV6tdd/a8FBX590R1cbFVZZKfr8rq67crLIRly2D0aDV3t25VBzjbtLGvJwRceils3w5RUSXo9e8Diz2OrxTIE+kaanQflVKWAB9b/hBC9ABGo6KPjvRr7/wALXF3fe8qXJ90laxaNYfKSkUE33/veH0+ERHTMBqtsyUqypp+MZjPEWg5E4xG70kA4JVXMjl4cBspKSrG+86dK1mz5v/o1GkAM2a8b1f38OGdxMQ0pqKihLCwMJeJ2DUCDWaJQNv5Gwy1874ZO3YOw4dPJSbGu1CVYWHhfPHF68TFNWHy5FeqGWgdfz+dzrepHZ0hMzNwJ7a1hf/wYWUPAPWdjx1Tz13XrkqF260b3HKLUnn27x/D6NE53Hmnmvc1zXktum2g4Wk+gmQg1ab+D1LKf/utV35EaWn9+x3v2LHC7eKk7VJBnay1RzpjxsCWLTMpKcmlefNkbr31mWpeQ8FGBJWVSrrRciV7SwK29pSkJJWk5+DBHRbPlspqdd966y9VEpercY6IiKoi0GAmgrw8tQDWNrZMTEwjYmK8D9bWtGlrJk16mXbteiClrEYEtmOmqfn8AZMJSkrymTjxamJjk93GjPIntENq2veMjraSdNeuMHEivP46XH+9yg3y1FMAkUAkQlhzhTuDlIoAfJn3vC7w5GTxs8AEVB4B23wE2/3YL7+hvvVxmm3A1eIE0LRpStXOz9mCefHF6Ywf7/z4f7Cqhg4dsj4E3i66jvaU3NwM3njjTkwm1aBOV8SOHSvssro5dzMVqKkKERHR/OUvbzcIryHtTEV9h7MWQjBq1AyX123nWF6e/+bc779DTk4R+/Z9T1JSqn9uUgP0+uo5jG+4QeUNP34c+vaFDh3gORfpoCMjrSeEnaG01DehQXwFTySCsUA3KWUDzXRrj/rWx7lepBSiouIYPnw+/3VwxrXdfcTFVf+chmCUCAoL6zbOzsZMIwEAna7EzoXWldpNCHj/feeiSLDaCHzhS75q1WwqK8u4/vp/0LRp61q1YTabCXPIi6jNsbIy/z1HZrMiQrO5DU888S1S1i9jl5crdU9UlNrIpKRAv35KOrjiCrjgAvjyS7jySuef//XXrXzxxSJgGRDtkggC7SXkCE9OFh9DyTtnBeqbCNxFwUxKSmXq1MV06FB9t3+BTdLOuDi1S3788ctYvvwRu3rB6DVUlzSeUHPkULA/XezqFLJmD3CGYCWCkpK6SyvffLOMzz9/uZoKzVPs3buZ2bMvJD//DCtXwocfWlUYJpN/d7KKBFRk0C5dBvksubynWLMGnn8eXn5Zve/RA8aPh3/9Cxo1gvbtYdIk15uz3NxMvv9+DVKqAXNGBJWVwWEXsIVLIhBCvCKEeBl1mGyPEGKREOJl7a/+uug7mEz1L267WqSSklJ55ZXjDBmSXm13IITahYBa6KOjYf/+rzh48Bt++MFedNCIIFhUHXp93Q2I7sJL2EKzrUyYMJ+oKPsn09agrvplr4wNlvHSkJOj1Ja+CGNy223Pcvvt/6ZJk1Zef1ZKyX//+wQZGb+wevVG1q+Hjz6CmTOVqiQ3179jp3kGBQr79qn/2jPZo4d3n+/RYxj337+KWEukSNv1prBQbZL8bWCvDdxJBD8CPwHrgSeB/1nea38NDoFw0/JkkdIOx2ieCS1aQMeO6nVcnCKGvn1Hc955Qxk82D6lg2YjCBaJwBcnPp2NmTNoO/4hQ9KZOnUxSUmpCCGqJK0hQ9IxGo2kp0cwaVIsFRVW95NAEcE777xE584R3H33tZSVWfuTm6vUD74wwA4efBvXXPNgreLtCyF44IGPuPXWZ2jWbHJVeWGhco/0l41NC1Kn2cpOnNjP2rVPsXu3E0d9H+DkyepxxoqLVblmIxdC5fzwBi1bduDiiycQG6siVGpEYDar9nW64DEQ28KdjaAI+J+U8s/66oy/EQgi0IyTS5feT2lpPomJKdxyy1N2B6I097g+fdTpxC5doHVruOoqlQcBYODAGxk48MZq7QfTyeKSEt+cxrY1AuflZdKoUXMqKkowGq3ytCOZuoqnH2GTUDgj4xe6dRsMBG68vv9+GyaTiS+//JSMjN/p0aMvoOaAyeS7eFZ1QdOmrRgz5u889ph6n5amDKT+UmdIqaQNWzvXH3/8xOrVc7j00ju48MJrfHo/oxHmzlUbsJtugrFjlWR96JC63r27OhcQEQGNnefpqRHatLMNXhkMz6gruCOC24GFQohylDSwE0UMv9ZLz/yAQB3cqCnph0YEvXsrz4SWLdVuxJPj6cFiLDaZlLeHr6DTFdOv3/UMGnQz3boNrnInzcvLJDFRuZO6G1NbPPXUblq16mjnVx8oG8Fjj73AsWOHaN++IzExSuopL/fd71dSksfrr09ixIi/1mkBLS1V/vLh4ZJevYRfiaC4uPr3b9euJ2PGzCItra/P7/f779Znbs0a2LMHbr1VGYlBEcHll9eu7ZKSPPbs2Yhefx3QlMJCa+yyusKfHo/uThbfBCCESAMusfz9RQiRgjpHcLX/uuUfBJtItnOnMkBpkzI+XrmkOYPRqOe779ZQXJzD1Vdb4+gECxGcOuVb+8uGDc+Rk3Mcg6GSbt0G10im7pCa2rtaWaCIoF27VDZv3m9X5ksPkk2bXuXnnz+ltDS/VkSQkwNvv63UlGqMdiBlDyDRb0TgzC7QseNFdOx4kV/up9kBundXEuyRI/DEE+pZ1Mpri7y8E7z22kSiovYCTX2Wy1pK9YyleGY+8xqenCw+LoSIAWItf9rrGiGEGAW8hEpV+ZaU8hkndW4G5qIcvn+RUlbLa9zQkZOTwZtvTqN582SmT18CqMmxcKEKga0t/vFuDoIajXoWLrwdgKuuuq9K5REMRGAwqEnqS3TocBEmk5G0tAtqrlwDnB1OGzq0dqTiD/iCCHS6EhYuvJ2oqFiGD5/KwIE3efX58nKVCW/xYvjVRuY3mT6joCAWSPSb2srfuQscoRHBNdeo2EHr18PatUpVpJ0Yri0SEloweHA6Bw82Ji/Pd5uj3Fz/2WEM/AAAIABJREFUqg3d5SOYDVwMtAAOAd8BrwLTpJQ1LjtCiHBgIXAlkAX8IIRYL6U8YFOnC/APYLCUskAI0bIuXyZYceLEPvbt20xERFQVERQUKJbX6axRJd0RQUxMPDExjQkPj6C8vJCEhCQgOA6UnTzp+/vPnPmhT9rZsWOF3WG03FxFykJA//71SwZffvkpu3d/y5VXXk9qaif27CmgV69OPiGCwsLT/PTTelq27MBLL9WcuPfAAdixQ7kp79ypQpu0a6di/MfHQ5MmkJNj5uGHp3PqVAo7d/peNaTTKRJ0tljm5GRQUVFCYmJ74uKa+OR+hw8rlevRo2rB79FDkd+ECSr8/NtvK2kgpg457Zs3T+a++5Yzf741tHRdIaVywmjWrO5tuYI7iWAiUAZsQNkIvpdSepNOeQDwu5TyGIAQYhVwPeqEsoapwEIpZQHA2WSYtkXz5u3o1GkA8fHNq8psM3LZqobc4Z13qvsWBloiKC0NbGz4mrB69Ry7w2igziCsWjWHhx6qXyLYtOljPvjgbXJzz7B69VskJ5/HggW+SbbbpEkrHnzwv3gSHNhkUqERcnPhq6+s5Vqil0mTYPBg0OvDiI5OqUo248sdaVGRs3AqVnz88Ty++uotpkxZxBVX1JyusiYcP64MxNrwdOtmfxbgiiuUdJBQYyZ2z6AZi+tKnjk5KoaRXh8gIpBSdhdCNEfZBoYBs4QQ8cAvKKPxOzW0nQycsHmfBQx0qNMVQAixE6U+miul/Nyrb9AAkJbWl3nz7KPJOaZmBKuO0hPYqjsgheLi+UD9Lmxa/gZ/4MyZozRq1Iy4uKbVTrh6A1eH0/LyMjGbrURaH7j88qtJTk5l2LDRbNiwithYH606QFxcAv37j/Oo7q5digSaNVNnVJKS4PbblUpICEUCQlhjHflqUdNgMNScYKdJk1YkJ/eo1VkIZ9i61d4u1Lu62YjWtTuEbQcpJTpdMVJGAzF1Ik+TyXXiJl/DrY1ASpkPfCKE+By4CLgM+AsqJHVNRODp/bugiKYdsF0I0UtKaac1FEJMA6YBpPjLWlLPcCSC8HAlpnqCb75ZbhdkDTIoKJjG2rUwdmz9kcGff/rPE+vBB7thNpuYO3dHlctnbZCUlEJurvMw3vVNBKNG3cDll99AdDSsXl1MaWn9hcA1GpUUkJ1tdZq44QYYMcJaJ9VJWJ+VK//B/v0tgAfrTAQGgzLMVlTUTCoTJsxjwoR5dbshynYVG0tVboAZM5Rx2lWIiLpCSsnddzcFVgK31MlB5cyZ+pP03dkIxqCkgcFAT2A/yoX0IZSqqCacRCW30dDOUmaLLJTKyQD8IYQ4jCKGH2wrSSkXA4sB+vXrF6TBAVzjzJmjZGb+SuvWnWnfXiUUdySCRo1qDo39yCO9yMr6lZiYxk7iF5WzYMGceiMCKX2fwc0WWuTL2sbK0eAs97F2BqG+PYcqK5WrYqtW+JwEDh/+llOnDtOlyyDatu0GqN9o3TpljM3NhZ9sjoHGx8Nll9Xc7o8/fkx2dnfgwTqrhgoLfXNy2lPs3QtPP608oAwGpQ66xM8RK8LCwkhIaIlOF26XvcxbmM2+d8BwB3cSwWTUwv8o8JOU0tv9wA9AFyFEBxQB3AI4egStBW4F3hFCJKFURX5SNgQOH388n23b3qFly4689JKSiR2JoCb7gIJaubQ8vI7IzvZzLkMb+NIjwplXz/LlvlFIay6nb7/9VyoqSoiISGHChKcCkqXss8+2UlaWgMl0UZ3UXc6wc+f7bN78KhMnvlhFBJmZsHq1tU5sLIwbp8ho+HAVWK0m3HzzPI4da8n69XVXDTlTh/oTW7eq/9piPHx4/dx30aIzLF6s7C+1kQgyM5W0XZ/RAtzZCG4AEEKMdiQBIcR0KeUb7hqWUhqFEPcBm1D6/yVSyv1CiCeAH6WU6y3XrhJCaCGuHzkbcyTHxjYhIiKKhIQuzJ2rdiW1IYLU1AvIyjqARgiOaNu2ftRmmjTgbAH31tffWchp28iivsCQIem89tpEYCtG43C3Ib/9BYPByMyZIxBCsHy5kc2bF/LZZy8ycuQMRo26v87td+48gPLy20lJsSq/9+xR/1NTlT1g3DjlGnnddZ63O3DgTTRqpFws67IwSemdm+jcuUMoKDjF7NlbaNWqo9f3Ky9XecCFgKlT1aZlyBCvm6k1amtXKSvzr6TtCp6Eof4/IUSllPJLACHEo8DlgFsiAJBSbgQ2OpT90+a1BB60/J21mDTpBSZNeoGffoIFC5SnjeaiJoR6SNwRQXQ0bN26gp07V+CKBCCOhx+e7+Kab/HHH7B5s3cLuCvScBZyWoss6gsi+OMP5d6altaP48cHISX88IM6SVpfEoHJBFlZlfTsORyz2URYWBiVleWcPv07OTnHfXKPSy+9g0svvcOuTCOCceNgoKObhhfwhbG4tNQ7IsnOPkRJSS5RUR4aziwoL1dusVqKyx49an9KuC7Q4oZ5O2b1qQ6yhSdEMAZlMH4EGAV0R7mBhuABpFRiXosW1oBip08rP21QcVz++MM9EcTGYgm57HoLGx29uF7sAzk56vt4s4C72/W78urJzc3g/vs78vLLddMUvvmmGt9Jk76vCjJ2+rRylezVq05NewTNLiBlIx57bGtV+aWXTuTCC6+jefNkv9y3tFT5zYeH1+175uZmcuDAb8DIOtkIvFUL/ec/hykqOu2119Dy5fYusfUpBWhYvHgKu3dfCkzyiggqK/2X9a0meHKyONdiOP4CFXX0JumJs3IDhy/UHqB2ny+8oHagmqHMNhH3eeephcpdcKtGjWqK0Z9KWFj9GIk1n3J3bpmOcEcarrx6AAoK6i4ja2ccPnLIdvjDDzBqVJ2brxF//ulcBdW0aSuaNvWNa6S6zx/ExycSHt6Y5csFhYVK4unRw31io5pw8OA3rFnzPLUlgspKyMjwPrx0fHwz4uO9c5wvKVHSACgpJi4OBgzw7r6+QFbWAYqKlJ+Mp0Tw22+BTVbjzmuoBPstaBTQEbhJCCGllL5zgg4y+FJvffy4+r9y5QZatWoPWINoRUerxai01L34GhPj2g1SYX69qDkMBiuZuXPLdIQ70rjnnmVOvHpiufjiCXTtWnu3UVBqAi1Ql3Zor1u3Mg4dasSuXf63EUhpJU5nOYB9BbPZxAMPdALgr3818MUX4VXX+tYxZlvbtt3p3XsYe/fWzgPm5En/5xgwm9Uium2b6mPfvnDvvarcm7M5vsKMGa+zbl1ztm71jAjKy+vfkO4Il64LUsrGUsoEm78YKWW8Vl6fnaxvuNvBegurgawrOl1Tu2sJCUpl9Ne/QrIbDUF4ONx+u/MY/cnJXYD0evE3tjX2eZJnQYO7DGJDhqTbRZhUuQTeZPr0dxg+fEqd+ussk5ZePxdQBjl/k2dBgXUh+PHHdUyaFMdrr00CoLKynJUrZ/Huu3U3FJeXF5OUlEpiYnsOH1Yk0LEjXHQRDB1at7Y7dryIu+56EfCeCAwGKxF6g99//5433riTbduW1lhXSpVNbPp0WLVKlY0cqVStvjol7A2EgMsv70Pr1koi8MSzLhjSVrqTCNKklMfdXBdAspQyyx8dCyS8UXvUBC0bkRBdMBrtt6BNPAyhEh4OI0emYzDARx/N4cwZFYr5wQfnM3JkOhddVD+GT9ud3ZAh6ZSXF/Pee/djMhlJSkp1qT5z7ssfW0UaZrNisfPPH8GcOVt81t/qRKAjIUHFyjYa/XdYp7xchTq2dR3U6YrR63VVOXjDwyNZv/5ZhAhj4sQXCAsLd9FazYiPb8bLLysDyMMPq7JJk+oWPM0WmrHYWyI4c6Z2UldGxl62bXsXIcIYOnSS0zrffKNOtcfFqThJoO7Vvr3zU8P+hBCKdIqKlIo3Pt7qDOLJmAU1EQDPCyHCgHUo20AOKvJoZ5TX0BXAv1CHws4qeKP2qAlWV8WwaqdwPSUCIdTEGjIknQceSGfPHrWQ9eljPYRmNqsHwU/aB4zG6u5/iYnJmExGwsMjeeWV4y4/q5HDkiX3oNMp3dLFF99SVf7AAx9y7NhPJCaqXdTOnSvZvn0pPXsOZ8yYR2vdZ40I2rfXjMOxzJr1MenparycPaQmkzWQX21RWFj9xPWll97BgAE3VJFeREQk6ekLiItrYvEkUjeVUvLxx/Po1m0IPXt65+6iZdiKjLRmuPMNKoFoDAYJeDbB/vyz9m6QPXoMZerUN2nVqpPT63q9cgKw/f3uv1+5yTZtWj+nxbUw3UajIoHWrRURJCTAtm2fc/CgCbjGI9VQUBOBlHK8EKIHKoDNXUAbVP7i31AuofOllqH5LIO706jewnHxjI216q29kQhiY5VNISJC/TcaYfv29Rw4sJuwsH9hNgtMJuvuzdc4fbr67q5ly0706TOaU6cOsXHji3Z5Ehyh5ROYO/dS/vjjJ7Zte5f9+7+skiL27fuCF164ASnNREXFotfryM/P8gkR9O+vVAdJKmArERFqMXEkArNZ7WLbtq31LQHn+l4hxP+zd97hUVXpH/+cyWQy6R0IJIQaOiJYQLGXddWfrrqKEBUrFiyrq64rdsW1rOuii7qosO4aEdG17KqooCJxRUSw0XtPgAAJ6WXO748zJ3NnMjW5dxIl3+fJM5M7t5w5c+95+/f1aowDcPbZv2+x35o1xcydqzKsZ88Ork4vW/ZfPvvsZXr0GERp6QZGjfoHEE///ubeBw88cBTwPfX1oQWBlMoaakuD+5ycAnJyApszK1eq3y4xUf2Op5wCY8a0/nqtQWqqmuOSEiV80tLU/ykpMH/+e3z5ZQ1wVkiLoK4u+n3U/SEU19BKIHLH+M8cWlN9/fU/Ula2nfT07kyY8HjYgeKtW2H+fEVv67so9O6tAsjV1ZEJAqfTk1kUF6eOf/zx29m0aR1CTAFiLRMEjY3+85vz8oZw5pm38qc/nU5R0R1BBQGoIPymTcuor1eSUAfh1679koULX2l2m9TX1yCEjezsAF16woRejDIzvTVkLQi0ttbYqLaVlyvB3RZBIGXbNLycnAGkpeWQmzsk5L6rVy9i6dJ3WLp0HnAJGzduAIYyaFDrr+8PGRld2Ls3vDqArVvbJgTCwfffq9fTToMLL4weX5SvEpeQ4KGHFkJ1FlTUHWdQUlLL/PmhF/mOYA1AeHUEhyR69x6J05kMSPr3H+03Nz5Qeum778L//qduFF8tOjtbLUDr10fuGtIZEHFxih6goGAY5eUHKC+XNDWpB1UzRpqJkpLA/vQePQbhdCaRmJjhfwc33nvvCd5++xG/QfhPPnm+xf5Suti27cdWjff999W8GwXB+vVf8/DDJ2G3x2G3q8CN1sa2blV9ovftU5WdGq0hpTt40H+8Zt68Z1i79itOP30yAweq5PaSkvXs2LGKHj0G0a1bPwBSU7vw/PPh+VROOeVaevYcznffDeXLLw9jt5vEvS0dtvzhvvs+5pJLoKnJFtD92NSk0qDNyINfuvRdbLYYBg8+sYUVBZ5CuREjrBcCKSmeTLm8PPUsVFSo7XFx6t7S8YAePdR4TjvtHOrrlTIYyCKorlbz1VG6JnYKggC4++5RzZqr1lQ1/KWXzpgxiTVr4KqrCiktVfv95Ke7c3a20hrWr1c3VjiIiVF/OgvC6VQ+yhdeUMnxQ4aY2/fWiJ07PTz1vpg371kaG+t58skVfjODPMIyUNprcLQmOF9drYqKwCM4MzNByiTq62uor68lwy2z6utVML+sTBHB7dun5rCmRml/JSWRWweBSNVWrfqCJUve8qKK/uijZ5k37xkuueQpzjor8uL6rl370LVrHxYuVP/n5qrxmi0IYmIEMTFqbhoaWnIUSancNUYh2ha88sot7N27hb/+dT0xMUnY7eo3eeklpeyUlKjftl8/c64XDDk5SvDV1CjNX0o1B1rh6tXLs68xtqQ/DxQj2LWr41gD0CkI/EJKSVOTsoOnTdtIly4eF0VxcRHPPz+xOein0dBQzfz5UzjllMLmlDnN1Z+Xp5pLgPJTH3usov8Nl/88JkbdjEaLQJew68/BfEFQUuLpnuYPb7xxDzU1FQghWixkvsIyOAT+qqbT0iL30RgDlHphysgAh6M/11//Cl269OF5twGiBQHAmjWe+ausVJpdOPECKWl2ydXXB3aLnH327Rx55Hn07z+6eVuvXoczYsSvycjIbd725psP8NVXczj//Ps49tjxIb9vQ4MaO8C991qXMmm3q+9ZX99SEJSUmCcEAEaM+DV79mymqqo7d92lnhmHw7v3xdChbQ/qh4OkJPX8HjignsGMDG8t3vgcapSX72fXrv1AH78WQX19+1UQB0JIQSCE+DfwMvCh9FWNf6FQxGD17Nu3k4wMz0qgFzdfIeDBVtat82iF2i3Up4/Kp66tVRaB3R5ZEwxfU9woCFwuFzExAhCmCoKqKlURGgxdu/altHQDffseRWNjI+DCblerhL9aDH9wOBI44YSJLFz4Sov9w/GTa2zfrlxtvrGM+HhdWevg+OMvAzxxlNpaz29knLuqKvWw1tWphdbfw66xZYv6bbOzg7cm7N9/tJcQADjhhMs54YTLcbmaWLx4LoMHn0Rp6QZ27lzN3/42ASEExxxzsd/zbdq0nO+//5CEhHNpaBhCXp51QuCbb96hoeEkILWFhltd7VFyzMJVVylJ/fLL6jfSFmlWlqoUXrlS9Ru2Gtryjo31VGcLEVo5eP/9udx332vA517zpWmp9+6NPK1WSuVuHjPGGgEYjkXwHHAF8IwQYi4wS0q5xvyhdAwE8/2HXtx6Nvsvjdi16wu6dOnB3r19ibSvjr8fXccIpky5ntdeewGbrRToYpogqKtTDUT83axGd4/NFoPL1cTDD5+Iy9XEhRc+zPnn3wOEosRQMNYeFBQcy5w5d3sdN2zYqQGPrahQC8WZZyoBcNddiq7D112QmdnyWD2nZWXK9PdFZaVHMFRVqYwQXzQ1qVRNTWHRlnadixfP5dlnx3PSSVcxceI0ystL+fHHT4LO4Q8/fMScOVPo23ckMIQh4cvMiFFXV4XLVQ2kegm60lKV+GBmhXZjo3Kp9unjaSZz9tkqHbWwUAVkowUj7YsxFhEqRTsrqys9e+axdau3YrB1a+sK7EDFRZ54Aj780JtLySyEwzU0H5gvhEhF9Q6YL4TYBrwIvOpuKvOLgD/f//TplzBjxjX885/VIRa3BGAqK1a0/GTt2rnAc8ya1RRxY2x/wTCbTWkoTqdmZlRuLDP4yysqFFmZv3P5zo+2jPTrqlVfNO8bnBJDCYFnn93M8uUf8OabDzJs2Kk8++wW/v73q0lOzuSMM27xssZ8sWiRarlYX6/SQ5ualKaoF3nN6qoFQXFxES+9dC11dVXYbHnAn6iu9p8Fpuko9HtfQbBvn3JTRDLfX3zxT2Jj4zjyyPOarSZQbsiYGPUYrljxKUlJGVx33T9oaqonPT3w9xfiNLKzz2Xv3l6A4hSyCsOHn05qagrl5R6fd309zSR+ZuKDD+qZPdtBYqKkpkbQv78SANFEfr5atMPrEdISp59+Ljk553LOOZ750pZAayAlzJ2r3kdCIR4Jwoq5CyEyUY1qrgaWA9OAkYB5ZaAdAIE0/oaGGqSUAakShIhBNVAr9Jsu5nRWkZ6eE7EQgMBZEcnJcMcdj7JiRRVdu6oFo7XVxVr7ra1V/uZAC1woi6ikZG3ze38UFBoORwLnnvtHXnvtD/zlL+fz1lsP8Mgjp1BcXMSQISfx1VdzmDw5l5tu6kVxcZHfc+xw97pbt04F3kF9/x/diUZHHqleu3b1CLC6uir3ftuASSxb5v/cRujCsNJS5aLYuTOwoAyGl16axDPPXOzlVty3bweXXhrHiy9ewzPPbOKpp5ShnZHRnezsXl4CwxfLlo1iz55BlJfHIwSmp4wakZKSTXy8in7qha21mm0ofP65KrypqlJqd3tQSGdkqAygYESQoaDdifo+CUQ+GA6+/VYJ3YwMVQ9jBcKJEbwNDAD+BfyflFJ7YecIIZZaM6z2QWCNXyClDFhoNnjwRL77bgpwKdATmEpqamFzDcFdd81kwIDWjSmQP1D5LpVk0cKiNRZBba1aPDMzVRZDMPdSKHePMcvH6E4zupGysvI555y7ePll7zu6sbGOF164AiEEjY317usFJvvTfuOqKg/FAHiE4VVXKYqFMWPg/vv9CbBqFiyYwoUXBlc3q6pUxkhbXCAuVxNjx15Kbe3B5t8MICkpk8TEdLp160dWlmoY/NJL15GcnMmFFz6MzWbD5XLx1VevM2rUuTidKlvASDE9ZozKXGmt9houfPn1daqqmaiogJKSLKCOrl1XkZExwtJCMbu95TOjCza7d29blb4OqNfVebsQI8VPP8ErbsqlSy9tG5NsMIQTI3hGSunXKyWlPMLk8bQrArkzsrJ6YrPZvBa3srKtpKfn0a/fcSxdOgvQqQRbgEnk5EB5udrfn485XISTJ93arCGXSy0oTU3hPdih3D2+FBy6mtgfZs68vsW2pqaWXkZjj4PKSqUdHXusxyKAlnQOGRkqcKoDioEEWHl56DhGXZ2yONriB7fZYpg06cUW2x0OJ8OHn05aWg5CCKqry1mw4O8A1NZW0dBQQ1NTI59/PpMLLniA3/72fgC++64OKePo06eWyZNbYWZGiMbGBior9wI5NDSoDBorqmGXL1dULMOHx/GHPwy3tEYgLk4pCitXej83eqFty7VXr/6RiROvBf5HfX3rg+mffQYzZqj3+fnWuYUgPNdQuhDifJ+/U4QQUQzbRAfhMGqOHVvIs89upqjIRVPTapYs+RyXy7cqpJodOzwF2amprU+2CnZDrlr1A0cf3Z2dO9cBoQWBcTGrq1MPge8iGgzB3D2gNHijO6eych9PP/1bXnnl1vAv4gfa0njrLXjhBXjttZbjNgpb3wBwYJeeLaDryQgzUyN9MXnyvygsfIKPPvob06aN45RTJjFhwhPMmzeNzz57meOOu5SMjB7k5BRw4ABs2ACLF6sE9NLS56wbmAE2Wwz796uAQElJI2vXhjggQsyfr9pJvvmm+n/kSEzv6eyLpCSVju1rqZuhcQsh2L1bzVdrm/k0Nnrm4ze/gYcftqZYVCMci+AqYAygrYITUSR0vYUQD0kp/xXoQCHEGah4QgzwkpTyMZ/PLweeRDW3B/iblPKlSL6AmfDV+DMze5KXN4wPPngaKSXHHXcJAJde6qSxMREoA/xXgR48uJW+faGiYiNXXNGX9PTuPPfcDr/7BkOwVLGmpkZ2796FooAKLggqKtTin52t9luxIvI2emPHFtLU1Mibb97v5e4xwujOycrKZ8mSt7DZYpg48enmfdTi6792wB+0paHz5XVT8sREzyI9apTKrCgra5ne58+lByBlk+n9kf2hvr6W6upyEhPTiI31/zSvWVPMDz98xA03/JPjjrsUhyOeAwd2UVBwDH/96wbs9jjuvFO5xGw2FQEvKIgOib3NZiMrqzt798LGja429zjwxaefKneXDtKPHGnu+f1B1+SkpCjFQacdm9G/oHfvAv773685++zWJ3AUF6ukhNzc6NBohHP6WGCQlPICKeUFwGDUE3w08IdABwkVQZ0O/Np9zHg3iZ0v5kgpR7j/2k0IaOzZs5nExHQmTHiSZ5/dzMaNS9m06Vuee+7SZm23sbEOyHYf4V/bzMrqycMPQ07OZEB12woW/AyEYDdAfn4/Jk26g+xs1enKVxDs3u3RnPfsUYuIbjzf2v6zr756GwcOlHDjja9RVNTY7Ns2QrtznM4kcnOH0qePtwcxWNtN3wBpbGwCxxwzlfp6T3GbHvsRR3h8sX37eipqc3O9TsHYsYVcc80Mv1TPre0zEQlWr17E9dd34/HHzwy4z6mnXsfNN7/O4MEnAnD44WfxzjuPcuutE9m40cGKFZ64iMslSEuD22570NJxG9G9ey/3u8AB7NagtlbVYthsqkK+S5ePeOEFVU9hJYwxlbw8VW8Cnte2wOFw0KuXWhdaIwh271Y0NQDnnBMdLqVwLIJcKWWp4f/dQJ6Ucp8QIpjhcxSwXkq5EUAI8Tqq1/HKVo82Cli69B22bPmO5OQs0tK6UVnpKRXV2u5ll03Dbj+VmTMBzgRewLiwCaHcSV9+WcTq1V+0OB7C10CD3QTJySn88Y9PUFysFnrfm66kRC2U/fopTdnlUr711tIDL1r0KpWVqinBq6/+HildQXsOb9++giefbMkXFCzofO21M70sMqdzKu+9V0hcXEtB16uXWkiWL1eVpsOGKe3uxBNbnnfs2EKmT7+05Qe0jsoiErhcjSQnZ5GSkh1wn8GDT2TXrnVs2/YTTU2N7NmzmfT0vuzbN4uHHoJu3WoBJ8cfL6moEBx1lHWU40YkJalAsS7CMyNF2YiNG9V92asX3HMP3HjjNaxcuQ2bzVrSA6Pmb7MpF9FPP5kXjPXNGgoXCxbArFnqXu/SJXqsquHM9udCiP8C7kxWLnBvSwQOBD6MHoAxTLIdZUX44gIhxPHAWuBWKWWL0IoQYhIwCaBnpBVZEaC4uIjdu1Ud++bNy9m8eXmLAGZ9fTUffPAXJky4GSgCXsFbuxWMGjWRsWMLuemmXmE3eA+ESILFjY3KBaRdJtXV6m/LFk82TSDeoFDQefgaBw7s4sUXJ5GUlOElLI0IJPQCB+XzvQLMLhdceaX67L331GtcnCdQ2aMHnHyy+o46RnDBBYG/g5l9JiLBiBG/ZsaM0PmWX389lzlzpnDOOX9g/PjH+P3v13HPPWq137nTCTRy+um7yc/PCppaaiYSE1WgUogqIJHy8v1AZL2Eg0HHG3QTnT/84UPKy0tIT/dT6WcSnM6WLlenU9VimKV9v/DCI8A9NDWFT15YUwOzZyshMHYsXHSRdbTyvgjna08GZqGa7Y4A/glMllJWSSnbmuX7H6CXlHK+oS0oAAAgAElEQVQ4qibBb286KeUMKeURUsojsrMDa1Vtgc411xpvZWVZwAWurGyru8/AFLR/3jBaNm/+ADCn01mocvIHH7yFrVtXASowtWGD0myMWTVtzfnW/Er+hBoQMIBcX1/Nq6/e3jynGuG2udy507Po69fTTvN83qOHsnjCzcqKpL2mGZgz5x5WrlwY1r719bWsW7cYgNzcoQBs2+at8qemLiU+/iC///1ArruuG2VlJnM7+EFCglrEduxQ3M8bN7aOETYQ1qk8h2ZBkJc3hKFDT7FE0CUlqYyyQKm2ZqZmzpv3JqqhT/hWweefKwVuwADVc9mipc4vggoCt5//UynlW1LKW91/b0oZVjLdDsDIr5mLJygMgJSyTEqpE9FeAkZFMHZTES43Dqhsk/ffLwICuUXU9mC9ekNfQ72G0iT+9a/nKC9XScp79qgFs6bGvGbYofiVqqr2cc01MwIeX15ewqOPnu61Tfvss7LyEUK4+xTPaLYEKipUoMxf5eqYMYpW4tRTFRtkJNDXdTh6AIL4+B5e1zUT69cv4Z13pvLEE2dRVRXMcNaQLFv2H2Ji7M1kczrt8OyzVW+LqVNH07VrX8rLS6mo2ENqalfTx+0LvTimpKjV0243p2ChsVEpK9oi6N/flNMGRXq6Ejjhsv62BTfccDcOh3qIwxEEDQ2KPgKiw6Pki1CNaZqEEC4hRKqUMtKl5RugvxCiN0oAXAxMMO4ghMgxFKidg+p+1i4IhxtHIR6XawL79zehAsX+XA0qWjlu3FSmT7/E67NgGqjN5nHhJCWpAq9QguCww45i1SonNTVKEHQ1eW0IJSB1A/pgdNP+FqxANQYuF9x/v/ruhx+ur6FiHLGx0LNn29owjh1byMsvlwM3kJv7HmPHntP6kwWBy9XExRf/iS5depOYGNpkcTjiOf74iSQmplNfX4vTmdgcHB84UGVFKdiZOfMgBw6URMU9pH3pgwYNZ+1ayM1tfUqPZmqtqFDpkLrIKi1Nab+7dq1j0aJ/kp9/GEcf/VsTRu8NrThYmYapcfbZFzFlikpsCCUIPv5YpYoePKjIKEe1gzocjgeqEvhRCPEJ0JxRLaW8OdhBUspGIcSNwEeo9NGZUsoVQoiHgKVSyveAm4UQ56DIcvahaCyijuLiIncVZ0utNz4+hZqag4AkNTWf8vKpxMaeQ3r6TnbvnooKXXhXGl988Z8AteisXfs/Fi36F7W1lS1I7HyRkOBJodOCIJRr6K23vmT8eFi82PxAHgQXkEahFqjqOlyNe9EiD92wXiCKi3GfW9UODBpkjs80OTmV2lpwOCyi6wQKCsZQUBBZpO/66/+BlMpF0KuXJ0tKh8VcLhf79+8gMzMvKA+TWXA6PYpIa4OfGi6XIgbcvVudt7xcCZmGBhXcFwK2bfuRt99+hCOOONd0QeBwWFeVGwh6zoLVErhc6t6uq1OWytVXR6/jmhHhPFb/dv9FDCnlB6j+xsZt9xne/xH4Y2vObRaCuT4cjgSuvPK55oVs6VJ46in1w7pcA4ABdO0KpaVTgJZspQBXXjmdK6+cHtZY4uOVIDD2HgjnptCLoxWNaQIFWG22GK9F3l8NRjChZ0RJCTz3nPr+xhiAxmGHwTHHmPeAnHhiIXPnQkHBieac0ESsW6eqSXXAPz5eCcimpkYuuUStLLNmVTbTTVgBTdhnzKzRabqRNLA3YssWj6urrk4FoO+5R11Du0FzcgZwwQUPkJNjnp/I4VBaeVuq+1uDAwf24XLFAYlBhaeOg2VlweOPRycTzB/CYR99RQgRD/T8JdJPv/LKLX5dH74LHXh3n9JMgscfX8jcuYWceSYkJz/OzJmTmT79Ei+K5XChTVaHw/PghVr8Skt3UlXlBDJaTToXDJFo+mPHFvLVV69jtzu4664P6dq1b1jX0H0PampUm0mguSNWVpb5PPtWpUIasW3bT1RVHaBHj0EkJ/vhwg6A1avVqy6U69lTLQ4xMXb69x/NunWLKS8vxelsg38sBHr3Vg17jBr0/v3bgDwWLPgn55wzMeJz6mLAUaMURchhh7XU0PPyhpCXZy6fdm6u/5axVmPTprXs358GDAx6n+k4WO/e7ScEIIysISHE/wHfAfPc/48QQrxn9cCsRnFxEddckxUwM0hKl9dC53K5qKhoudKeeSbcfDPk5BQxd+4UampUKGXv3i288MIV3HnnYSxa9GrI8WiyK1Cv+n0w19A77xRx7LH5LF+eBfRi5crIitXCwdixhVx++d/IzMzzG9j1xY8/zqekZB1r1nzJ9dfnMHFiAsuXf+B3Xw0jF0tTk/rOv/mN+r9veLIkImhBUFdnnSR44417efDB41i1KnTWkJQeWmtf+gZjYPOWW+by0ENf0bWrOUIgL6/l4mO3K+Hbv793LwenU92IdXWtq0TUAm7kSBXwj5abJj1duVnbwiTaGuTl9SEhQT3EwQTB5s3q1djysj0QjmvoAVRx2OcAUsrvhBDWqSNRQDhtFI2ZPRMnJlJfX83RR2/BWEmcmKj8nWPGwE03TWnhXmpqamDbth8oLn61mZ4iEGJiIrMI3nmniLvvntTcUhO2MH/+JPr2NZ8uYc2aRZSVbaN794E89VTweP5xx11KXV0V+fkjqKjYi8vV6Lei1wjf2oYBA5QgSEnxBIzNxLp1XwDH8+mn/+CKK642/wJA9+4DKCg4JqzMnqVL4S9/UZlQWhD06KGyaoyB8czM3OZEhLYiLs5DtVxXpxbLVavU4q/vOSNtek6O+h5jx14V8bWk9AiCYCy8mzd/h5SSnJwCU1xfKSnBu8tZBZWe2oWePdX3DhYj0BZBWxIgzEA4gqBBSlkuvFWHn3XLynBSRb0ze5RduX+/9y+amup5HyyoumHDNxQXFwVdoG02b0EghHoNJAj+/Ocp1NR4f4fGxsiK1cJFXZ2KYBsplAPBmEp6772fUlq6kf79WwZNpYRvvlHpfFoQDB8OP/yg2hHa7XD66S0OMwWJbud3U5N1Ubnx4x8LvZMb36sUfRYsUPOSmqr6Dy9ZAscdZ834MjLUq9HtNnhwYPeEtghaM2elpSo4nJISvM3jK6/czOrVi7jnnk8ZMqT1JUqxsWrxjTS92AzYbOr3q6z0KHOBLAKX6+dlEawQQkwAYoQQ/YGbgf9ZOyxrESpVNCkp02sx/fOfV5GcnMm0ad451EZBEIyiuapqX0hqiZgYz41jfA3kGtq5s+3FauHillveYPLkxrDrLDQGDjyOgQP9r2TLl8PTT6vFp6RELUC33KIeDM0ZZBX69BnGggUwduwV1l4oTGgrQPuxCwrUveUvcN4W2Gxqkayr879IBmucpJWUSOMqa9fCV1+p9wMGBPeDd+vWn+rqcjIyekR2ER8UFChBYAaBXDgQQgX1q6vVM6v7HNvtKrBeWVkJtKy/2L1bxcXS06MfzPZFOOL9JmAIqkxuNlAB/M7KQVmNQIVeoAKhEydO89qWnZ2P05nEwYPe+xp/vFAUzaHIzWw2jxVgtAwCWQTdu7e+WK01sNvtJCSEjtqWlW3nnXf+xL///XDQ/Vau9LxqXpWEBHPL/AMhLk5J2sbG9ovOSakWgerqlq4xXWVrBhITVZwlNlal3w4erOY5Up+5Vk6++24+FRXh9Vxcv17VhMybp/4PJeCvvfZlHn/8e3JyWj8BDof6bhkZ1tYL2Gye+zQuziN0tDBNSFAJAwA//bSoxfFVVfCFm4asd2/rxhkuQj5yUspqKeUUKeWRbpqHKVJKXwL+nxXGjZvq182RlJTpN1PomWeUr09nDcXGKtXNaBHoqtWYmMBOyWDautb8dWN6/T7Qonj77VOJj/cWPDEx1tElhIt33/0Tc+bczdy59zF+vGD8eOGXdVW3l9TwZQy1Elam22r84Q+HcfXVGQFZND/+WHVRe+01JRT69FHFRGBu28nERFWsNXKkWiDj4hTLZ6QZKtrXvndvCRUV4bUn+8TdyLZvXzjjDP9kgGZDu7yshtPpCXjHx6v3QniET0ICJCSoB7m21tuMOngQ7rwT3n5b/W9FQkSkCKdVZQFwO9DLuL+U8mTrhmUtxo4tZOvWH/jPf54ACJrq+c03yrRduvRDXK6TACcNDQuBE70EgT7v4sVz+fbbd/1eN5i2rgWBMVAczDX0m9+osd577w1UVlYA+Rx7bGTpquHij38cxb5927niiumMHh240Ke4uIjPP5/VYrtmXa2uhj17CjnjjJb0Ee0hCL799iPWrk2JuPArHFRW7qOqan9AxeDrr5UA0L0VCgpUTGTHDnMXBq35Gxf+UEWK/qAXuP79TyQjI7Q5UVnpcQndeKNHyFkNKwWBsbWl06mEY2Wleq/dQ3qeYmOhf/8BbNkChx3m3Vps3jxFoZKTo0gTTz3VujGHi3BiBHNRPMsvARbqUNHFr351E1JKYmJiufjiwFr0/v3qtaFhAOAE6oE52GzHUVDQ8om68cbX+Oabf/PCC1fgcnk0gVDkZlrzj4/3aF/BXEOghMERR4zljjtqWbx4gGUm5q5dq6mrq6a29mDQ/ebMmUJDQ43fz+rrq5k9ewq1tYX88IMq8snOVq/l5dHhf9EwWgRbt/5giSD4y1/WUF9f45deorFRpYsaUVCgFgbf7mpthVm9jPUCl5KSGzL1s6wMPvpI+emHDg1PCOzatZa77x5Ffv4IHnigpSvFH3JzleDMzFRB6PJy89NE4+OVCw+UK7iiQt2zWhDY7R7FLS3N87wK4b8au6ZGzQ3ApEnWx8PCRTiCoFFK+bzlI4kyMjNzKSx8IuR+B5r5wlR+V1qag+nTpzffDL5wOhM47rhLEEJEVGWrtTTjjRxOk4zc3Hz69VMUE1YUlAFcccVz7Nq1hqFDTwm6X6ggfG2t+lxTJxQUwIgR8OWX1qSJBoIWBFlZBQwbZqJD3oC4uATi4rxXzNpa5RY4eFAFbHV2C1hDuhYTY06jFfAIglCtF5ctU6mw2u0WrrZbVXWA2tpKGhrC8zrHxytB0KWLZyG2ojYhOVk9Vzr47HKpNUFfMyPDY23pbeCJ94ESBC6XcpUtXephGI1UCFhJSR3Oqf8jhLgBeBvNqwpIKfcFPuSXA20RaKSkqNZ9gTIsiouL3ARsinLihhv+FZa7RgsCowanr2EkozNCLyT6WKsEwQknhFdJGqq5vW83t379FO/62LFtGFwroB6oIg4cmMLvfuefGsQKzJihUkJHj1b/jx6t7icpvYu3zIKZWTN6Udu7dxcbNuygb98jWuzT1ARFReq1f3/VKOjII8M7f58+R/Dyy+VhCwL9nBgXXysQF6digdXVHuqXWsMQgwmfxsaDQDLvv/83HI4b+cc/PJ+dd15k47DZrHWfhiMI9Cpwh2GbRKvIP1N88827fPvtuwwZcnKLYi8plQDIyGgpCIKZnr6FapF0JNMmpdF/ayT8qqtreUxMDJSXV/LRR+8BEywNfoaDQL2BFRKAqWRkKP8oKEHQHvjppyJgEo2Nkf9O4aCxsYHp0y/B6Uzi2mtfBtQ99eOPapH88ku1X0GBNf7htDS1aJmpIesFd+fOjSxZ8l+/guCLLxR3TteucN99kWmwNpvNnZUWHp9INCqFY2LUX0KCx80TExN+qmdcnHqA9+4taQ6cn3EGnHSSh0gwXOTlWZwFFWoHKWVvP38/ayEAsHDhLBYunMX77/+5xWcffaQaQ3z9ta8gKGLFiuyAmTD+CtXC7YkbLIAX6IFSpr+DkhIVeW1oMF8SHDhQwhNPnM3MmZND7jt2bCGXXTYD0H2M9ZfKB2YAhZx8snoQhg1rvyKa+fNbNhQys3dxfX0Nixe/weLFbzRv27fPwyyrYRUHf2Kicj2YSUmuF6GkpBx69fLuXr9pEzzwALysZB4XXmh9Z61o1AgYF15jhXK4VkhKivLLDRlyJ2vWKHfWuHGRC4Hu3a0Ptgf8uYQQd0opn3C/v1BKOdfw2aNSyrutHZq16N17JNu2/ciAAS0LnnRq48qVxgYvSovUC4g/LbItHcmCBYUDlcnbbCpFrUePnuzYAY2NTXgWX3OwbdsKli9/H5vNHhaLal5eIeCtVRuzLQYPNjc9MlI4HHDggLXFePX1cdxwwxxsNo9g1sR6mtkzPt66ALl2KZrpNtGLYnp6H8aM8eiBTU0wfboK2gqh6FZa02d3yZJ/s2TJvznqqPM56qjzg+6r7vvIrxEukpK8K4NbC6dTPdTLlikr57jjghft+UPv3ub3GPGHYBbBxYb3vlTRZ1gwlqjiggvuY9q0DVxxxbMtPitz89CtXm1kLQytRbalI1lrLAKbTR133nmXuv8332GamJhO796jGDDg2LD2NxLIaVzq7hkfG9v+OdMZGZCebl0xXmUl3HZbHP/+90UMGDC+ebumEjjhBCUIzzzTusK5SBebSM7pW1m8cKESAl26qBjIzTe37ntt2vQtX35ZxPbtK7y2JyV5kzHGxHhTV1uBlBT1fdvqivENHkfqBnQ41LxGA8EMOBHgvb//f1HQPmyd3aK44UNrkYEom8PpSBZMECga4pYFUPoYLSisCBb36TOSRx9dGvb+ukq2e3flL+7dWz0A+/d7Z3hEEwkJKtgHShCcc85UXnmlZUMhM4rxtmxRKYI1NfDQQ6rRyLBhHotg8GC49to2XyYozMoUMsLTj8DFvn272LmzB/Pnq/7YoFwebUlVHT16HN27D6Rnz+Fe27t1U8HasjJ1/zQ2tnSxtRaBkjDsdkX70Fb3lnYBxcVVUFhYSV5eZM2EcnKiR00d7KvKAO/9/f+zw7ZtK7DbnWRk5BEX5+Drr1VMYNIkj0WgkZFRRFWVDX9lFEYtMtLmLLGxanFvbAyuRQmhbsqmJqWl6MCxPmbbtnVAf8rL9wFRKq30wa5darHQguDiixWXyrBhapzjxrXLsACl4VVXe6gARo8u5JVXQAjVUCiSJjqhsHOn5/2ePfCnP6mguI415ef7P84s2O3W+Oc9WUMl3HvvaOLitrHL3WS2f39PJlRrkZ8/nPx8byEghFqQY2I8PnKHw5yisZgYRbddWtpyu5EAsi34zW/g5Zcns2rVDNLT3wTODfvYaFoDEFwQHCaEqEBp//Hu97j/D8v4FEKcAUxDOa5fklL6pWQUQlwAvAkcKaUMX/1sAx588DiqqmaTlJTOc89l8PbbSmsbONBX8y5ix45J+BMC/rTIQL14/UHfdI2N4VkEoLQ9oyCw2eCDD14FHmTbtlVAeC6ccFBcXERR0R0cOFBCenp3Jkx43O93q62FKVPUzas1rPz88FMHrYQQKsOkpETNnXYtQCFxcRdz222fM2xY8PqISKDbbKoMqSyamq5tjjnZ7cHZN82AFdYAGONUcdjtg9i1S83j73+vrD4z3VxOp7qntBCwAg6Hmqu0NGOtkLm01XY7nHrqcRx2WB7du4dfNJCZqebUqu/uDwEFgZSyTcMQQsQA04HTgO3AN0KI96SUK332SwZuAb5uy/Uihc0WC5xEZaWDrVs9mtwPP/juOQWXK7wOZpHCblcLVU1NaEGgtbz4eM+Nq4/JyEhjxw6IjTUvguabCrt//46AKZbbt3vcIaC0qaws04bSJtjtngwTvUhq6uXa2joeffRUZs82z8DV99HAgQkMHryD0aOVkGxoUMFhq7NprIgPgMcicDozOeusj5k1S1UNmxX4//bb/9DQUMvQoacyeHA6Bw9amy6pF/yUFJUQomOBZgqCmBg45piLQ+9ogN2u4mjR7lts5eWOAtZLKTdKKeuB1/FvGz0MPA5Elcju6adLAXV3L1vmqZhcudJ3T/+xAd8OZq2BzRZeS0qbzSM0jLQTOlh85ZW3ApCXZ155biSpsEZ3CKjCl/ZowO0PdrunCbsWBB6OKAcxMbE0Nrau65Y/aIvgyitv5cILHyIvDya6K3GGmNuF0S+sFgSNjfDdd+r9iBGB948Uc+bczbRpF7F//1aSk1XTHCuK7DT0gm+zeaeimimoW+Pf79q14zavby16AMYcku3A0cYdhBAjgTwp5ftCCGPBmuUw9h/+n6G7gtZqtXmqqmFbVsuakWFi5CkJxzUUG+t573J5XENWBIsjSYX1Jwg6CvQDn5DgWSSTknQap51//rPetAevsVHFRYTwTvk75RSlPVu5sKWkKOoKqwSBkTdnhTuxZ/jwwPtHisMO+zU5OQPo2bNr8wJqZaDUqPknJ3sC0GZbBNXV5WzfvhKHI75F/YUvfO+baKLd9DYhhA34C/D7MPadJIRYKoRYumfPHlOubxQEHr+uB4MH63dTW7hczMow0Ys7hBcsNlY36mOM5FZNTea5OCJJhd2xQ72edprKdIg2ZUQwaCGZkOCxCJKSrGlgX1qqhHFWlovGxgoaGz3EPF27WusW6tZNWRxmkcz5wqhw1NdDt25VpjJ9XnfdE9x665v06RMdmlJj9pqxR7iZgsBmg1WrvuD++4/hjTfuCbpvTIwqsGyPrDqwVhDsAIwlM7nubRrJwFDgcyHEZmA08J4QokXtupRyhrsXwhHZ2dltHlh1dQUPP3xR0H2GDtXvCpkwYQZZWflhNW+PBLorWaigkLYC9E1it3uEAMB//vNPAJYseafNY9I4/PAzW2wLJAC1RXDyyYpwzDN37Q+9eBn71zoc5guC2lrPPMTF7eCqq1KZOfN6c04eBhITvXPurYAni6WRIUPWmHruPn1UgkE02kvqJA0jsrK8Y3FmQAhFbtm371Ehm+0cdlj7WQNgrWvoG6C/EKI3SgBcDEzQH0opy4HmkKIQ4nPg9mhkDZWVbaOpqSVhiKoXUO/z81UecFUVnHZaIWecYT4hmbYIwhEExniC743sWdTMsQiKi4tYuPAV31FwwgkTvQTgunVqcSgtVWM0m0LZDOjF37jAGLOwJk3qztFHn8jatf9rJgqMNJV00ybVY1j7mlNTy9m7N4m4uOj0SrTbrRUAGo8+CkuWbKJLlwry8swjipKyiaqqfWRmpmK3W6cS66puf1p/bKxHGJh5vb59D+eRR4LnwRibUbUXLBMEUspGIcSNwEeo9NGZUsoVQoiHgKVSyvesunYoZGf3ZvToG1m82Hv7yJGwyE2FnpkJjzyiUkmtSuPSMYJQPmoh1J/2//oKgnPPPZ9FiyAvr4qbburV6gVNw1+gGCTLl3/Q/N+mTYpYLCtLzVF2dnQWo0ihhaTxNzRqfk1N1SxePLe5d0RrCOi++ELNgXY3HnXUUO65J3jvBjMRrd682dlw3HHmN72orNzKkUf2oUePfIqLN5t+fg3dSaw+QG6A2fOoFbhQZJBWpfxGAktjBFLKD6SUBVLKvlLKqe5t9/kTAlLKE6NVQ+B0JpCWpiJdekFNS1NEXRoZGUpLsCr4pq9tdFMEgm/wTLMiaqSnJwFFbNp0nZsGWjYvaL7EeOEgnEDxqlV6X/VqdX58axFobvX2pKQ4rwZCEBkBnZSKYx48D3S0yfSsigv4wqrgrc1WTXp6JunpFkbTUYpKUlJ0G8XrOZNSIqV/i/0XLwg6MrT2pqmQc3NVyhp4+5OthE4JDaZJ+3v4dIxAQwmFlvUOrWXUDCdQ7NtqUs9dR4Get0CCQP++lZX+kw/CIaBralIcQnv3qsXlqafgj380t/l8OLCSgM0Im001ZH/zzQf48svXTDvvoEFDWLZsL++9Z60eaOzvEQ1oS/7OO4dz6aUO9u/f5Xe/aP1+wXBICoKvvnqD7777BlB9Yg8/HM46SwWs+vdXxGBWoeUCHlwj8CcIfF1DCxa8gL8UV2gdo+a4cVNxOIJnSmlBoBfUjmQRxMV5HvpQFkFaWusI6BYvhssvh2fdnIWjRqk4xPDh8MEHT/PggyewZMm/WzH68NGrl0fLtQrGJu02G5SVbeettx5kwYIZpl1Du2SEhfmixo5h0YJ2DdntDqSU7N+/0+9+HcEisLjOsWOhqQkeeKCI9et/R1NTGdCT0tKp3Hmnxxf80EPWjiEhwZOzrBejYO6nQIJAC5GioiLmzLkt4PGtqXcYO7aQzz+fxYoVnwKSrKx8xo2byvDhhbz8ssoO2rlTjeG22xQDZVu5ZsyEw6H+amoCW3Z67oXIQ4itXmZ7OOnBX36pMo40384Rhly3nTtXs3r1FxxzzHj/B5uEjAwVy7LSetUEbLW16l7s3XskZ599B/36HU11dQUPPXQ8Q4aczKWX/qXV14jGQuhwRI/ATUNbBLff/h4pKVkBA+GdgiDKmD27iDVrjKyTW3jnnUl06WJOZ6pwEB/vEQR6MY9UEBiDnVOmTKG+3n/D+LbUO9hsNkDSr99oHn74KwDeeQfmz1ftFqVU7rQRI8ytMI1sjN7srToop3lkILRFsH9/A/HxyYCkpuagO8j+aND7weVSFOWgLEiHw7tq+Oyz7+CYY8bTtat1LdiMxYhWQme16SK81NQuzb2+v/tuHlu2fM+WLd9TWPhn9z0TGDrhoabGQ+zW2Ajvv/8qr776HOeffxmFhdeZOn4jWWO0oS2CjIzA5rKm1m5vHFKC4M03W/YUaGhQfvRoCQIdHDYSzUXqGtLnAdi6NbDrpy31Dpdf/iwbNnxDly6eLBHNLKrjK73NTyCJCElJnrGkpHgYPh0OjzsjVIygT59jGTbsZN59908A3H//ooAxEo3t25Uwz8iABx9s+Rt169aPbt2s7cMZLb+ynj9dxW7EiBFn8Pzzu3C5XCGFACgX0ODBqoAzM1MtgtXVUFy8gWXLvuLYY83v25mWpn7rAHFaS6EtgmDoCNYAHGKCoLzc2s5U4UBrckZBEIpewh/0QtazZ0+2bGkZH8jKym+TcOvefQDduw/w2qYFgUZ7C4KUFI8g0DUg9fVqgTH2mfUHvcCdddYf2bHjbyQlZZKSkk1TU0PAYw4cgI0bFY0EKMK1aLsbNKK1gBjnUK/1FRV72bBhCcnJWfTrd1TY50pMVOfQ8aT9+8u48MKxXHbZjbzxxiK6djU/0F8T0/4AACAASURBVKQZZ9sLQkBl5T5mzryB2tpK7rzzv16fp4TXotlyHFKCwOnsSW2tNbxBwWB0YWiqCGNlcDAE2kdvnzp1KlddNYm6Om9L59xzze0k6nJ5Kme1RdPegkA/5Nr0dzqVIHA4QneY0oJg5cr/sWDBg8TFJfLUU6uCXu/vf1eEa9qVF4h588svX2P//l2MGXMRmZnW9KOMtkVg1G6//nouM2fewPHHT2wWBNXVFe7m84HhG9T+/vslbNiwmj17SrjsstA9sSNFOFX7VkK7hpzOZJYseQuXq4n6+hocjnji4lS6ekfIGIJDTBCkp09l1y5rOlMFQ3y8p2I5Nja82gGNUMKisLCQn36Cxx5TTVZiY5307DmM0aODU2iEwjPPjOfAgRLGjXuEAQOOZfduxdCakaGazmzd2v5tJ3WdR1WV98Kv3WbJycGPhSIWLlQLUGNjA8XFRQGtqAMH4Pvv1ftaN0+uh4/KG5988hxr1nxJv35HmS4ItOCLhkVgzE7TixpA796jcDji+eKLV8jIyGXTpm/58cdPeOaZTUG/r2/BVkpKGqeeeg6xFkW729vtooWn3R7LTTe9TmZmLjEx6rvm5kYuBKysaTpkBIGUUFGhH3K1aNrtPbjmmscsjw8kJHgEgaYDCFdTCcdqOP30Qh57rJA+fWCqSTJt2bL3qKurZteutQwYcGyzWyg3VzXh7gjwFQS+TduDmd379hUBk2hsVEpBU1M9M2ZczcGDZfz61ze32H/xYnUPZWWpuoGsLE/XLF8cc8wE+vY1Xwg4HMoKW7MmOpqkcX02WgT9+h3FuHFT+de/bqO8vITY2DikdLFu3eKA39lIA64xcuQYXnzxXdPHnZWlAtIdQRBo4Xn00Rc0b4+Pj7xfR2JicMWmrThkBEFpqVowEhMLSU4upKRELWjRYMo03pCxseHxC2mEIwg8dAmRjy0QRo8eR2npevr0UW3GNMNoRyoc04JAczY5nd754sEenK1b/SUO1DJ79l3NgqCpCT75RLWc1NTL48crqyglJfBvc/rpN7Txm3kQE+MRdmlpKpWze3drmUxjY5X1Z7yGcVED+NWvbmLQoBOIjXWSlJTB5MlFOJ2J7NixGpsthq5d+zYHkCsq9rJy5X8YOfJS7FZ35kEJyWhVWweD75yBujd79YostuR0WkthDoeQIFi7Vr3m5CiitJISayWsEUbtTQeLrRAELhf88MMnbNy4lKFDT6Vfv9b3irzuupmA6uP8wguecXQUQaBTaI2WgNPpnVIZbM2pq/OfINDQoFJxd+xQ31u3mQRlyY0caa2J7guHQ1keGzZ4evXmmWRoZGTAvn0tt6elKcETyCIAiImx07v3yBbHvvnm/Sxe/AbXXjuTE0+8ArsdHnvsdDZtWk5y8gGuuurW5n0rKw/idMabKhzi4jpOUyTjfJWVbef77+eQn5/EyJHXhn2OhATF8WR1UkIHmTLrscbNmtutm4ujj3aRkBCdjlHgCRAbG8yYFSMAj1BxuWDmzBuYM+duPvlkeusHbMC776oq4o0b1f/t3XRGL0761VhF7CsIgsHp9J8gYLfn89e/KqqI9evVYnn00ep3OPnk8ITA9u0r2bVrLS5X2000h0Npg06np7OaGYtCTIyyanyVISGUBZuZ6T2X/rRbf0hKyiAtrRtJSZm4XE106wYXXqjaNTb5mKyTJ19IQYGDL774uK1fpxnRFNLhQM/ZgQMlvPji7bzyyjNhH6torKOTmXbIWARaEOzf/xlPP30q2dl9GD58Q1Sura0A/YOGwziqEalFkJs7hMrKfaSnt151r62tZsGCGTgcBWza5N2XoL0tgtRU5aPXgsBoEXga04fG4MFTWbbMO3EAEmhsnMrXbtbgE06ASy9V56yra5mOWlxcxJw5U1qwvT7wwLFUVR3gxRf3kZTUNoJ9fa/072/ugqAD69rN1dCg0mJ1W0/wdmmGyomfPfsufvxxPrfcMocVKz7lqafO5a9/Xc/IkX25/vo7uf76O1sc09CgaEDT0lrX4SY93VM7otHecQEjjMKzb98hFBZex5AhLa2oQEhMjF7W0yEnCKRUJaHhFMCYBW0RGBtkh5soEYlF0NQEt9/e9uY0zz9fyZIl5wPqXMOGqcKf1NT29736CgJj8RiEn5fdu3chy5ZBQsIUqqu3olqSTuXCCwtJTVUCb+BAz/6+qajFxUW8+OKkZrpuI311ly59qakpx+Fou3qqr9taimQP+6X3di08dYe72NjgjW1CWQRbt/7Ipk3fsnnzcjIze1JdXU5DQylOZ+DUstde+5TGxsZWcQzZ7epeiItT972UqsivI1GhG4VnXl48jzzyfETHe3prW49DRhCcdJJKATz//MnEx19AXV2VpddzODy859oi0LUE2vwOB+E8I3pRNKNncU0NfPttFsprqIKmxx/fcdpP6ofDKEiND0y4gkBZUYUceWQhS5ao7223T2HevC7MmLE75PH+ejZottdnn90c3iDCQFtpJOLilPtnzx610Eup/P/+FsyMjMAVuKEsgvPOu4df/epGBgwYy9ix/0dMTBw5OXDttefRpUt3br31QeLjE4iNdXjFBFobH9DzYnQFtbeS4gstPOPilJ8/kuM0DX60cMjECG67DR5+WAWL09K60bWrtUnwvhQHDof3DxuuLzNS15BGfX1teBfwwfffQ1OT57aIiWk/LiFf6Hadvh2djGtJuOuK/i0WLlRCYMiQchobH6Wycm9Yx4fTs8EMtFUQxMYqa6JbN5WymJERmKfIZgvsighlERQUjGHhwn9w4415lJQsYMQIcDr3M3/+e7z55ixuvnk8Q4Yk8eOP5lBNR3ORbC2EUMJp6FA131VVlSxZsohvv/1f0OOys6OXyKJxyAiCaEOb8vrB8s0U8mcR+Gs/GalraN68Zxk/XnDDDaHL9UtLVXFUfb3qNnbvvYpVE1SANDZWsWq2t6blWygWH9/29EnjvHbrBjfdFM8VV0znjjv+G/ggA8Lp2WAGzBAE4B1H6dIl8nhDOMHisrJtVFeX06ePyihITU3n/fe/4/bbp5KZmU1MTAw7d24DYNu2Tfz2t8dy772tS7Vt79aO4UAID9cRwJdfLmDcuOOZNu3BgMf4ujqjBUtdQ0KIM4BpqFaVL0kpH/P5/DpgMtAEVAKTpJQrrRzT7bcPob6+mhtvfI2CgjGmnjsuTgUVwfNjGrNcjFqMv4XMbve4k2JjFY1DpHUESUkq8NbQUBf0mNJS+P3vlfYxYoTqP2zEuHFw9dUdIwsjJUW5NoyCoK0aodGFdPfdkJrqCJj/7xsUPvzwM6mtrWyxn8ORwP/9351MnpxHdnYvHnhgUdsGSdsXPH/Ht+ac4dyHDz30P5zOneTlJTNu3Ans3r2TTz9dy8CBw9i/v4wnn/wHDvfFS0p28O23/wvYtSsUfg4WgS8GDz6M4cOPYODA4QH30fellJJdu3bRpUuXqNReWHYFIUQMMB04DdgOfCOEeM9noX9NSvmCe/9zgL8AZ1g1pvnzi9ixQ13+L385j0suecrUqmKn0yMIfC2CcFJGjYJA8+lHYhFICUcddQFDh55CSkqXoMcsX64ER0kJzJunttlsRbhcqur6ttsk3br15+mn14YegMVITfUWBAkJbV8gTz4Ztm1T8Y/s7MAZQP6Cwp980jLol5SUycSJ0xg06HjeeWcqlZV+EvTDhI4vqaYmrT4NYO6CGcwiyM5W91N+fnccDsnatT9x4MA+du/eRdeu3Vu0oRw4cDhz5nxBTIi0GN1w3nfbz0EQ+D67ubm9ePfdbwLub8x6O3jwID169CA+Pp53332X0047zcKRWmsRHAWsl1JuBBBCvA6cCzQLAillhWH/RMAystiioiL+/OdJzf+Xl5dG3KQ8FBISoLzcwycE3jGCcASBhr7RI7UIHA4nDkcA7gMDNG+O5q4ZNKiIdesmebW7LC3dEJR/Jxqw2z0Ph3YROZ1tXyAzMlSVMPjPAJo+/RJeeula6utrkDJ0FN7pTGqep/vvX8S2bT+1aWz797c9XdS3t3VbEMw1FBenuvt5xiuYNetDunTJoUuXHL/HJCencNRRoblKUlJU7OvgQc823eK1oyOSMcbGeheO7d+/H4fDwZ133slAY/qaRbAyRtAD2Gb4f7t7mxeEEJOFEBuAJ9BpKhZgypQpLRg6W9vT1x90dgB42EVjYjwLllE4+IMuNgPvB9iKrKGGBk/z+QcegCuugN27pzTz7mhI6TJtfloLXT1s7O0cimI6HBjn1V8GEEBdXVVYQgBU8FgH6Lt27cMRR5wT0XiM90ZiosqRNys+YAaCCYKcnJb36YgRR9G9e55Xauh9993ISSf1Z9++8ALy4Clu69JFXScp6ecRH4DAz+7BgxXMmjUNl+GB7dZNMnnyNcxzm+f5+fnU1dXxwAMPkGdWKXkQtHuwWEo5XUrZF/gDcI+/fYQQk4QQS4UQS/fs8d9sPBQCNXAxK8tD1wro9+BtBYRKGW2LIDAGi4uLi7jkEgfjxwuuv747xcVFzfvV18P77yv+nLo6RVXQr5/q2xxoHqLZq8EfdCFefLxnATAK2NbCOK+BMoAig2TmzBta7RIy9nzWgqC1OfGJiZFVWYcDf+mjgwd7KFvCwbp1K9i8eT1Llxbz8cfv8OKLT7Fhw+qA+ysKZ/U+IUHNR1aWCsD+HODv2ZVSUlh4Mg899DvefvtVQN3Pn322gJdeeokJEyZQXl4e5ZFa6xraARhFWa57WyC8DvituJBSzgBmABxxxBGtch8FauBiVpaHTm0E71fjghWJRWCk/w0Fj2tIuTh0c5UDB3Z5ub/eeQfefttz3HBDzCorqyd797acn8TE1lV9mgUtXM2ICxhhnNdA3z1SLFw4iyVL3uLKK5+L2J2Wlqa+Y22tEnrGlqaRIiZGuZfqgucLRARfQeBwKLdNJI1V7rjjUWJjHQwadBi33DKBDz6YS05OLn37ers+dNJFIMXp5xAf0PCNcQghmDjxZmbP/jv9+yse89hYGDhwINOnTyctLY1UQ2FMWVkZb7zxBo2Njdx0002WjdNKi+AboL8QorcQwgFcDLxn3EEI0d/w71mAT+6KeZg6dWqLCkYzexEYc7MjiQtoGE1vYz53JBYBBC5yqqmBjz/2Pa6Im27qxfjxNmprK1HxfW/U1h70siqiDf3Qx8ebWzVqnNdx46bicJiTs1dTU8GLL04Ka850kZF2f6WmKm1eL7qRFCEZYbere8LsNERjvKE1KcUjR45h2LBR2O12TjvtXK688ncUFAxtsV9GhhKMHYkuwkycd94lzJ1bzPDhRwDqHs/NzeWGG25gwoQJXvvu2LGDG264gY8++qjVGVbhwDJBIKVsBG4EPgJWAW9IKVcIIR5yZwgB3CiEWCGE+A64DZho1XgKCwsZNep0bDY7IMjKym9TT19faDI58KY/iEQQGC0CLRjC7WKmhIh/F8fevVt5/XVVUTpggKoXOO64IubNm+TWhCWVlWVI2ZIkrbGxvl3iBPp767lMSTGXVdI4r2PHFnLNNTNISjKH6zfc2JP2retFVQsCjdZaQFbx07RVEBjxm98Ucu+9T1NQ4M38GBOjBH5aWutpNToS/D2/NpsNIQRSSl599XmuvPK31Ot0QR8MGzaMUaNGUV3dMoZlJixNUJVSfgB84LPtPsP7W6y8vi+efHIeJSXWnNtu96T7GQVBuA+l0QrwFQihoIWIy9UT8OfikHz8cRYwjXPPLWTwYHj+ef8BUn+IdpxAa8iVlZ65NLuozXdex44tbE4XnT79kjafP9Sc2WxKYzcueMnJqnakrbAq7dwoiFv7e3z00dv85z+vc9llN/rNGvIluvu5I9h3EELwr39NZ+3aFVx00UU88sgjDB06tMU+ixcvpqGhoVWcTOGi3YPFP3fo38ZYQRyoiCzUebRmr88VrkWg94VgLo4yhLiSykrlsogkQGp1T2fwXrycTs+CEEkabSQIZF2MHVtIVlZ+gGNivF6zsvIDWhGh5ky7bTIyPHQC2rffVlhlEZghCD7//EPef/8NfvrpW6/tmZn+u5j93BHqvr3uursYOHAQ7777LtOmTfO7j91uJ97iiTkkBEFRURHdunXjpJMEkyfnmebzNgaIjYu/MUYQaQMaY8ZQuBaB3hcK6d9/BqqQuyWkrOeNN5TLIhBFgi+i0dMZ1MKo583p9GjJVgUGg82rv5iBw5HA9de/wuzZkqKiRmbPljz77GYmTpzWYt+4uASuucb/nOngqn6uMzK8F1Uz3F9WCQJNmZCU1PpxXn317xk5cgy9exd4bU9IUBlBh5ogOO+8S3jmmWe4/PLLOfvss6MzKD/4xQuCoqIiJk2aRGlpKQD79m0PO5gXCsYAsdEiMGYNRUo3bcwYisQ1dMop6v2KFYVA4Nx37bIIJ0BqdhwlGGJjPVqy09mSosNsBJtXHTPIyspHiODxJH/73nrrDCZO9D9nus+xXvDMLPrS57PKgyCEouYeNKj15+jbdwBvvfU/TjrJ0+dCuzYTEjpOdzGzEOq3sNvhtNNOZdasWZx77rnRGZS/cbTblaOEKVOmtAi06GBeWxe4UJlCkQT79A3jGysI96G+5RYYMwYWLYIvvuhJVZX/dEjtstDf/fnnJ/rtpJWVlW8qnXIo6HmrqPDvGjILNpsqvAs1rzpmEA589+3e3ZPzvtdQOxUbq+oDrMjo0bCSlsbXDWoWfk7poGajo3z3X7wgsLKQzJgppB8O3Uw9UvhzDUUSIwDo3Vv99ekzlRdeuKK5nsCIgwf3cs01WVRWlmGzxbiFgMDI7hEtd5ARsbHecxgbq4SBGRqiXvz1uaurrQ1EagUgM9NbEOjiuNRU61wg0epoZSY6ymJoBULdZx3lu//CDLGW6NnTOrpgfxZBWztJ6d7GEJlryDcd8rrrZvkNZNbVVVFZWQZgsAQkShhE1x1khF74wVNNalaHJqNlZuzMZRX09VJTva+j6yCys63rpGWlILBqzqJArtluCDZnSUkdp0r6Fy8Ipk6dSkJCy8CfGRqvMVisH8DWanpa8w3UcCUU/KVDvvji3oAZMC0hm91B0RICRm3f4fD0GdDf22xBYOQrslIQaC3PZvP+Dvra6W1rYxwU0XANmY2OohVbgUBzlpSkXIcdJSbSQYZhHQoLC5kxYwb5+aEDf5HCn0XQ2ofFt4AKzNHuIkkTjXa9gLELk061NVIWREJfEAhGymIjR5GVD6BRmBsXfSv76RqDz1ahUxBEDn9zJoS1ykBr8As2yjwoLCyksLCQzz/H1IIyfxZBa+EvEBdJVXKghzQSHp1o1AsYkZKigsNSeubR+ICYsagZBYGmXgjVf7et8BUEmzap91YKgqQkb2vKCphBi+2PQ+lQcw2lpna8WM4v3iIwG8aH2V/fgdairQ9ZoOPD5dFpjwBxXJz6E8Izf2ZrSsbmLsZXqwSBDggb/9d1AlYKAofD+obnbZ0zh0MF0BMTPSSCwfok/9IghIdHqaPhFyyLrYGxC5nO+TfjAW/LQxZMw9UusNde+wP793uTvwphQ0oXWVn5zR25ogkdFzByaZmtHRoXmmgJAl9kZCgt2CpBoAWpka/Kquu0BToRQpPpSan4r37JMM5ZcrI57k4r0CkIIoTmEmpo8CwsZuSEW2URgEcYGLtwAcTGOtslQ0hDC4KGllmupkGn4BrdJlYIgvh41VrUn0aemQk7d1q3SEerY5cZFoHv+czmkOpoMM5ZR/6una6hCOGvdsCMnHCrH2R/XbjM7NAWLoxasRYEVnac0kFhHR/Q782e78zMwD0T4uLM4RAKhGgFW80WBIcC9JwZGQc6IjoFQYTwlylkhiBoSxZLOMHPQNlD0c4U0guiZmvVxWNWQc+L1RaB06lcHoEe9hz/rXtNwc9BEBiD9ocS9Jx1ZGsAOgVBxPBnEbTWNWRc/K22CAKRzFmVKWT8Psb3OhisF8z4eGsXCKNFYBQEZqePOp0qL1wXrPnCikpio7YZDbTlHv25NJw3Gzpu09F7K3QKgghhpkVgs0XWkjIYQh0fiFHTqkwhY42AsagqMdHbTLbbrdWW9Pzq7CR9TStiBJpLKFrIyFDfryNbBP4KJQ8l6OB4R8+M6gwWRwhdO2BcxFurXer+A+GQoIU6TzgkaqBiBWVlW8nM7GlZppDdrqykigr1f3o6HDjg8dP7xgWMQsNsGAWB7zazYORJimalqOZi6sgul+RkNfdmNNz5OSI5ueNUDwdDpyCIEMZOZG2FvkEaG6NjNkfCqNkW6CAweFNKa7dJQoK3hmSltuRPWHtae5qDQO4gqxFtl0Nr7lFtAR6q+DkIAbDYNSSEOEMIsUYIsV4IcZefz28TQqwUQvwghFgghAiXGCeqMGqTOkZgVtVrtFxD0YRREMTHewSBnseEBGuLq4wI9CCaMV/6O7SHIGgPn3uk1zO6UTvRsWGZIBBCxADTgV8Dg4HxQojBPrstB46QUg4H3gSesGo8bYExBqBdQ2ZYBGYJAqspEyKFw+FZHOPjPXOmF06rA8S+VN7+YIam1qOHJ/Mp2mgPWoZw7zHdba6jB0g74YGVFsFRwHop5UYpZT3wOuDVgkdK+ZmUUie3LwZyLRxPq+ErCMyyCIxVr780i0ALS6NlYLZFEOg7G8nlAu1jxnwlJKj6gU5B4I2UFJUua2XspxPmwkpB0APYZvh/u3tbIFwFfOjvAyHEJCHEUiHE0j179pg4xPBgfNCN+e9thdEiaKuG2t6+yLg4j5Zv1PyNgkDPmVlNyo2LoVEwG2M4gebFDEEeFwddu3YKAiP0s2EUxp3o+OgQP5UQ4hLgCOAEf59LKWcAM9z77hFChEenaR2ygL0h94o+OscVOTrq2DrHFRk66rig44wtYAzWSkGwA8gz/J/r3uYFIcSpwBTgBCllXaiTSimzTRthKyGEWCqlPKK9x+GLznFFjo46ts5xRYaOOi7o2GPTsNKh8A3QXwjRWwjhAC4G3jPuIIQ4HPg7cI6UcreFY+lEJzrRiU4EgGWCQErZCNwIfASsAt6QUq4QQjwkhDjHvduTQBIwVwjxnRDivQCn60QnOtGJTlgES2MEUsoPgA98tt1neH+qlde3EDPaewAB0DmuyNFRx9Y5rsjQUccFHXtsAAhp7ArSiU50ohOdOOTwMymA7kQnOtGJTliFTkHgB0KIru09Bn8QQkSR2zJ8CCEy23sMgdA5Z5FBCNHuWXn+0FGfSei4cxYJOgWBAUKIJCHEX4EPhRB/F0Kc395jAhBCJAghpgPzhBA3ubOtEEK06+/nnq+ngfeFEI8IIU5qz/EY0TlnkUEI4RRCPA985k7oONm9vSPMV4d7JqHjzllr8LMbsFUQQvQA/gUI4ExgIR2H++g2IBOYCDhRKbdIKV3tNSAhRH/gbaAJuBLYA9zdXuPxg845iwxXAl1QRZ2bgJlCCGc7z1dHfiahA85Za9EpCDyoBV6SUt4ipSwB3gC+E0IMb4/BCCGc7lc74ABek1KullI+Cexxa5XtqX1UATOklLdLKVeissN2CSHajS+qc84igxDC2BJIAF9JKcuklLOAr4BH3fu1F5NVh3om4WcxZ63CISsIhBADhBAvCCHiAaSUZcDnhl3ygD7AmiiPq0AIUQQ8K4Q4wl2PkQSMMex2HXCpECI3WtqHe76atTEp5U68uaESgIFSyu3RGI/P2DrnLLJx9RNCvAH8QwhxlhBCUwB2Mex2B3CeEKKvlFJGY2HrqM+ke2wdcs7MwiEpCIQQY1Em5ySUCwEhhJBSVhl2cwCbw6G9MHFc8SgXxvfAD8BkIcRVwOPAdUKILAAp5TbgVeCaKI3rLODfwO3C3VdCCGGXUlYadsugfR7QzjmLbFw24K/AT6hn4P+A+4B/AmcKIYYCuIXTu7hdV9LiPPOO+ky6x9Eh58xMHJKCAChD+fcKgCuEEPl+frTDgQ0AQohromSO9gWqpJRPSCmfBV4CzgPigefxLkxZi2J0jYYZWgoUoubrD0KIJClloxDCZrj2YGCFezwThBAFFo9Jo3POIkMOcACYKqV8F3gYOA3ojxKoU4QnQ2ceEC2Cx476TELHnTPTcEgKAinlKlSvhPXAJ8BD0MJ3fAqQKYR4C5iA8ldaPa6fgF5CiOPdm34AFgB3ooj5MoQQ9wshLgKuBmrcx1mqeUgplwKr3fM1D3jB/ZEwXHsskC2EeBu1ADZYOSbD2DrnLASMQk9KuQPF9Hua4f/ngUfdgrQKeFAIcTXKqtpnxZj8jKtDPZPG63akObMMUspf7B/K9E4x/C983wPJwHrgFJ9jP0Rpa7+1YFxZQFfjWACb+/1NwKuGz0YAL7uPKQAuAz4GCqMxLj/zlYLSjo40fBaHWoC/BS6y6LfMAY7x2dYR5qzFuDrCnLnHdZXPthj36+VAsWF7GioQOwJIR7k+Xrdwvq4K8Fm7PZPu8/cA/gw4OtKcReOv3Qdg2ReDe1Fkd68DD7i32Xz20T/y74D/ut+Pdy/MJ1o0rnuA1ajWnI8Zx+F+3w94C5jo/j8TRdzXzeL58jeuQPN1L/CZ+/0Z7tffWDy+FSjNeqT7f6OQapc5CzWu9poz97W+BW4L8LkN+BT4nWHbP4GhFs9V0HH5zFfUnkn3Na5DxQD+hko08L3322XOovXX7gOw4AdNRLGazgG6ojTCcqCX+/MWWq77/X73fi8DTgvG5QQeQ2kR2e6xVQMZ7s9thn1PR/lCRwIXAZ8BPS2ar6Dj8tnXOF+NwEFgGhBr4e9pcz+YH6LM7luBxPacszDGFeges3zOUBrtQX/n9xnLKFTu+2+AS9wL9GAL5yvguIKM0dJn0ngPAc8GWtTxWCpRnbNo/rX7AEz8QdPcr3bgRMBu+OxF4MoAx6WiBMcPwLFWjcv9Psfw/kRgNjDEZ399010PPOO+2dp9XIbPs9zzudyKcfmOzbDtb8Dt7kX0+Pae7PyB4QAABxdJREFUs3DGFa058/ktB6H6fyejlKArgdE+++vF71z4//bOLcSuq4zjv//MJLG0EtAotUSNY5M2bRODiBERKfYilSpq2xehtUVQGtIoaaH1QWoxVEGsFFKxD0KNDyrSF8VLQrXWXrAKJWkRClYSEVp6Ib1ZmjSZ/PvwrZNsw5xMxzmXdfb+frCZffZl5nfOOnu+vdda31rcBvwF+MS4vRrHDvWanMdtCniCuAk6v/zta2ncDHHiSWWon9m4lrELDKBA31kuxj3ANuDsxj4RXc7uBzb1OX8K2DgCr3PL9hni7vUA8APgb8Sjb++L1rzLna7Fq3H+zBAvzqbbDcD6sv1s4J6yvp24A/8GsLpXziP8zN6y17A/s3nKsuf1baLh+RHgVqIXyzWN75gG7TIIr8b5Q7km+5TlhrL9duCHZfvXiGS/2xvXx9QwfGpZJrrXkKSPEY/mLwA7iMaebY1Dpogv3hvMM00mxJADth8fgdeW8veOAo8Bs7ZvJO4uthdX3Eh2sj1Xi1fD6ajthwfp1cdtdcPtKeAVSdPAOcDXgc0uiVguV2pZH/Zn9pa9Gk4D/8z6lOX1ZfedRK+bi23fRkwQtaXhY4bEUrwafgO/Jvu4rQa+Unb3qhV/Zftu4GbgTErCmCdw2IjFUMXk9UvgJeAO27+A4yNNXlSy/o7YnpM0W9afVwxYtbx3/Bi83gYctn18Imvbv5V0E3HBHOio16nclhH97TcQVQX/IuqbLWmt7X+m13Gvi0tZvmz7O70Dbf9G0nbiH9+w+7jX6tXP7ZKy7wEiE/3Dxe2JkozY6gDQY2ICQcky/J87GdtPSvpPY98RomqomXl4EXCapF3EXdvNY/Q61DxH0nrizuTfwNNd8Po/3I4A+yQ9BDxoe4+kDxBzYA+0H3kLvD7YK8vGuecRZXmA8X3HRuq1SLfZsu8pSTuBWxRjUs0ST8P7B+1WIxNRNSRpWbNQT0pEea2xbw1xd9ZkFXAB0Qd4s+0/V+C1QtLVRM+mP9m+1vYbbfdaipvtb9neU9b32/6uY9iI9JrHS9KMpC8Q3af/aPu6Erxa7bUUN9t7iaqqh4Bf277ckTzWeqoPBJK2Avcpxvv+LEQdZzPzr7E+Czxatn1R0kpi2N81tgc6b+hSvIjBxnYT9cl3dcFrqW6Szhy0T5u9iJ43DwAfrew7NjSvpbpJOsv2Qdv32v7JoN1qptpAIOkdiuqcTwPfJBp4vlwev4833kja6BMNOecB6yT9HriKaA940vbrlXlN236uC14DcruCIdTVttjrSqKXy8GTq2Ta6DUgtyuIPI9u4gq6Ls23ANPESIS9PuKzwD2U/u1Ei/4u4EHgLOB9wCvEsLVDy3JNr/a4pVc7vGp3m4Rl7AKNgpwhEnPe29h2RmN9ikhIWVteXwJsOel3XJde4/Wq2S292uFVu9skLmMXKAWygejD/izw8z7HrAd+12ff8vQav1fNbunVDq/a3SZ1qaWN4AViaIBziSGFLwWQNN1o8X8PMccrkjarTPotSR5wz5b0aqVberXDq3a3iaSKQGD7GeCXtl8k6vV6M/zMEcNEAHwIWC7p+0QqeO/coWVJpld73NKrHV61u00qVQQCAJ/oqbILOCRpW9l+rET5TwKfAg7a/rjt+9OrPq+a3dKrHV61u00k466bmm8huoA9WtY3lp+fo9EwlF71e9Xsll7t8KrdbVKWsQuconD/ABwmRgFcNW6f9GqfW3q1w6t2t0lYqqka6qGY3HsH0eq/1fZn3BgMLb0mwwvqdUuvdnhB3W6TRC/5oiokXUaMdXN4wYNHSHotnlrd0mtx1OoFdbtNClUGgiRJkmR0VFc1lCRJkoyWDARJkiQdJwNBkiRJx8lAkCRJ0nEyECRJknScDARJsgCS5iTtlfQPSfsk3ajGjFd9zlkj6UujckySpZCBIEkW5nXbm2yfT4xrfxlw6wLnrAEyECQTQeYRJMkCSPqv7TMar2eBvwOrgPcDPwNOL7u32n5E0l+JbNf9wE+JYZO/B1wIrADusn33yN5EkpyCDARJsgAnB4Ky7SXgHOBV4JjtQ5LWEhOlfETShcBNti8vx38VeLftHZJWAA8DV9neP9I3kyTzMDNugSSZcJYBOyVtAuaAdX2OuxTYKOnK8nolsJZ4YkiSsZKBIEkWSakamgOeI9oKniUmQpkCDvU7DbjB9u6RSCbJIsjG4iRZBJLeBfwY2OmoV10JPGP7GHA1MF0OfRV4e+PU3cD1kpaV37NO0ukkSQXkE0GSLMxpkvYS1UBHicbhO8q+HwH3SrqGGBP/tbL9cWBO0j5iOsU7iZ5Ej5UZtJ4HPj+qN5AkpyIbi5MkSTpOVg0lSZJ0nAwESZIkHScDQZIkScfJQJAkSdJxMhAkSZJ0nAwESZIkHScDQZIkScfJQJAkSdJx3gQYJ2mTpR3VzwAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "1bc2d3b2edc1457eb306dc8c14a5a14b",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "KeyboardInterrupt, skipping rest of testing\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "trial, trainer, model = run_trial(\n",
-    "    name=\"anp-rnn\",\n",
-    "    params={\n",
-    "    },\n",
-    "    user_attrs = default_user_attrs,\n",
-    "    PL_MODEL_CLS=PL_NeuralProcess\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-04-11T07:47:21.606976Z",
-     "start_time": "2020-04-11T07:47:10.172286Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[autoreload of neural_processes.models.transformer failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 450, in superreload\n",
-      "    update_generic(old_obj, new_obj)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 387, in update_generic\n",
-      "    update(a, b)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 357, in update_class\n",
-      "    update_instances(old, new)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in update_instances\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in <genexpr>\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 295, in <genexpr>\n",
-      "    if not str(key).startswith('_')\n",
-      "KeyboardInterrupt\n",
-      "]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial.number -10\n",
-      "trial <optuna.trial.FixedTrial object at 0x7f073ae24390> {'learning_rate': 0.0026738884132767185, 'attention_dropout': 0.4151003234623061, 'hidden_size_power': 2.0, 'hidden_out_size_power': 2.0, 'nhead_power': 1.0, 'nlayers': 2} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 200, 'num_workers': 3, 'vis_i': '670', 'input_size': 6, 'output_size': 1, 'label_steps': 24, 'nan_value': -99.9, 'context_in_target': False, 'patience': 2, 'x_dim': 17, 'y_dim': 1, 'num_context': 96, 'num_extra_target': 96, 'min_std': 0.005}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "INFO:root:\n",
-      "   | Name                                       | Type                    | Params\n",
-      "-----------------------------------------------------------------------------------\n",
-      "0  | _model                                     | NetTransformer          | 361   \n",
-      "1  | _model.enc_emb                             | Linear                  | 76    \n",
-      "2  | _model.encoder                             | TransformerEncoder      | 280   \n",
-      "3  | _model.encoder.layers                      | ModuleList              | 272   \n",
-      "4  | _model.encoder.layers.0                    | TransformerEncoderLayer | 136   \n",
-      "5  | _model.encoder.layers.0.self_attn          | MultiheadAttention      | 80    \n",
-      "6  | _model.encoder.layers.0.self_attn.out_proj | Linear                  | 20    \n",
-      "7  | _model.encoder.layers.0.linear1            | Linear                  | 20    \n",
-      "8  | _model.encoder.layers.0.dropout            | Dropout                 | 0     \n",
-      "9  | _model.encoder.layers.0.linear2            | Linear                  | 20    \n",
-      "10 | _model.encoder.layers.0.norm1              | LayerNorm               | 8     \n",
-      "11 | _model.encoder.layers.0.norm2              | LayerNorm               | 8     \n",
-      "12 | _model.encoder.layers.0.dropout1           | Dropout                 | 0     \n",
-      "13 | _model.encoder.layers.0.dropout2           | Dropout                 | 0     \n",
-      "14 | _model.encoder.layers.1                    | TransformerEncoderLayer | 136   \n",
-      "15 | _model.encoder.layers.1.self_attn          | MultiheadAttention      | 80    \n",
-      "16 | _model.encoder.layers.1.self_attn.out_proj | Linear                  | 20    \n",
-      "17 | _model.encoder.layers.1.linear1            | Linear                  | 20    \n",
-      "18 | _model.encoder.layers.1.dropout            | Dropout                 | 0     \n",
-      "19 | _model.encoder.layers.1.linear2            | Linear                  | 20    \n",
-      "20 | _model.encoder.layers.1.norm1              | LayerNorm               | 8     \n",
-      "21 | _model.encoder.layers.1.norm2              | LayerNorm               | 8     \n",
-      "22 | _model.encoder.layers.1.dropout1           | Dropout                 | 0     \n",
-      "23 | _model.encoder.layers.1.dropout2           | Dropout                 | 0     \n",
-      "24 | _model.encoder.norm                        | LayerNorm               | 8     \n",
-      "25 | _model.mean                                | Linear                  | 5     \n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "83d29259a19547e891c1ffcc625e6784",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "ename": "NameError",
-     "evalue": "name 'softnorm' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-14-1d21071d511f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m                                   },\n\u001b[1;32m      4\u001b[0m                                   \u001b[0muser_attrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mdefault_user_attrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'context_in_target'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m                                   PL_MODEL_CLS=PL_Transformer)\n\u001b[0m",
-      "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/train.py\u001b[0m in \u001b[0;36mrun_trial\u001b[0;34m(name, PL_MODEL_CLS, params, user_attrs, MODEL_DIR, plot_from_loader)\u001b[0m\n\u001b[1;32m    113\u001b[0m     )\n\u001b[1;32m    114\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m         \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'KeyboardInterrupt, skipping rest of training'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, model, train_dataloader, val_dataloaders, test_dataloaders)\u001b[0m\n\u001b[1;32m    600\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    601\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 602\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    603\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    604\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse_tpu\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pragma: no cover\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/trainer/distrib_parts.py\u001b[0m in \u001b[0;36msingle_gpu_train\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m    468\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptimizers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    469\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 470\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_pretrain_routine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    471\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    472\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mtpu_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtpu_core_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_pretrain_routine\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m    807\u001b[0m                                          \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mval_dataloaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    808\u001b[0m                                          \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_sanity_val_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 809\u001b[0;31m                                          False)\n\u001b[0m\u001b[1;32m    810\u001b[0m             \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback_metrics\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meval_results\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/trainer/evaluation_loop.py\u001b[0m in \u001b[0;36mevaluate\u001b[0;34m(self, model, dataloaders, max_batches, test_mode)\u001b[0m\n\u001b[1;32m    260\u001b[0m                 \u001b[0;31m# RUN EVALUATION STEP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\u001b[0m                 \u001b[0;31m# -----------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 262\u001b[0;31m                 \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloader_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_mode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m                 \u001b[0;31m# on dp / ddp2 might still want to do something with the batch parts\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/trainer/evaluation_loop.py\u001b[0m in \u001b[0;36mevaluation_forward\u001b[0;34m(self, model, batch, batch_idx, dataloader_idx, test_mode)\u001b[0m\n\u001b[1;32m    437\u001b[0m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtest_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    438\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 439\u001b[0;31m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    441\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/lightning.py\u001b[0m in \u001b[0;36mvalidation_step\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m     46\u001b[0m         \u001b[0mcontext_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m         \u001b[0;32massert\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m         \u001b[0my_dist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextra\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcontext_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     49\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'loss_p'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# + loss_mse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m         tensorboard_logs = {\n",
-      "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/lightning.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mtraining_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/models/transformer.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, context_x, context_y, target_x, target_y)\u001b[0m\n\u001b[1;32m     78\u001b[0m         \u001b[0;31m# Seems to help a little, especially with extrapolating out of bounds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     79\u001b[0m         \u001b[0msteps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtarget_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 80\u001b[0;31m         \u001b[0mmean\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msoftnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     81\u001b[0m         \u001b[0mmean_target\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0msteps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     82\u001b[0m         \u001b[0mmean_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0msteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'softnorm' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "trial, trainer, model = run_trial(name=\"PL_Transformer\",\n",
-    "                                  params={\n",
-    "                                  },\n",
-    "                                  user_attrs={**default_user_attrs, 'context_in_target': False},\n",
-    "                                  PL_MODEL_CLS=PL_Transformer)"
+    "# trial, trainer, model = run_trial(\n",
+    "#     name=\"anp-rnn\",\n",
+    "#     params={\n",
+    "#     },\n",
+    "#     user_attrs = default_user_attrs,\n",
+    "#     PL_MODEL_CLS=PL_NeuralProcess\n",
+    "# )"
    ]
   },
   {
@@ -677,8 +280,23 @@
     }
    },
    "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2020-04-11T10:55:14.100Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
    "source": [
-    "%debug"
+    "# trial, trainer, model = run_trial(name=\"TransformerSeq2Seq_PL\",\n",
+    "#                                   params={},\n",
+    "#                                   user_attrs=default_user_attrs,\n",
+    "#                                   PL_MODEL_CLS=TransformerSeq2Seq_PL)"
    ]
   },
   {
@@ -686,16 +304,15 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:45:04.501510Z",
-     "start_time": "2020-04-11T07:44:56.100Z"
+     "start_time": "2020-04-11T10:55:14.100Z"
     }
    },
    "outputs": [],
    "source": [
-    "trial, trainer, model = run_trial(name=\"TransformerSeq2Seq_PL\",\n",
-    "                                  params={},\n",
-    "                                  user_attrs=default_user_attrs,\n",
-    "                                  PL_MODEL_CLS=TransformerSeq2Seq_PL)"
+    "# trial, trainer, model = run_trial(name=\"LSTMSeq2Seq_PL\",\n",
+    "#                                   params={},\n",
+    "#                                   user_attrs=default_user_attrs,\n",
+    "#                                   PL_MODEL_CLS=LSTMSeq2Seq_PL)"
    ]
   },
   {
@@ -703,9 +320,27 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.927221Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
-    }
+     "start_time": "2020-04-11T10:55:14.100Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# trial, trainer, model = run_trial(name=\"PL_Transformer\",\n",
+    "#                                   params={\n",
+    "#                                   },\n",
+    "#                                   user_attrs={**default_user_attrs, 'context_in_target': False},\n",
+    "#                                   PL_MODEL_CLS=PL_Transformer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2020-04-11T10:55:14.200Z"
+    },
+    "scrolled": true
    },
    "outputs": [],
    "source": [
@@ -715,23 +350,6 @@
     "                                  PL_MODEL_CLS=LSTM_PL_STD)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.929148Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "trial, trainer, model = run_trial(name=\"LSTMSeq2Seq_PL\",\n",
-    "                                  params={},\n",
-    "                                  user_attrs=default_user_attrs,\n",
-    "                                  PL_MODEL_CLS=LSTMSeq2Seq_PL)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -744,8 +362,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.931222Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -770,8 +387,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.933096Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -813,8 +429,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.934994Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -837,8 +452,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.937151Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -869,8 +483,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.938866Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -892,8 +505,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.940686Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -918,8 +530,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.942597Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -941,8 +552,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.944549Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     },
     "scrolled": true
    },
@@ -973,8 +583,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.946235Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -991,8 +600,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.947644Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -1005,8 +613,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.949512Z",
-     "start_time": "2020-04-11T07:44:04.400Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -1031,8 +638,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.951506Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.200Z"
     }
    },
    "outputs": [],
@@ -1048,8 +654,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.953489Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     },
     "scrolled": true
    },
@@ -1075,8 +680,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.955496Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     },
     "scrolled": true
    },
@@ -1093,8 +697,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.957266Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     }
    },
    "outputs": [],
@@ -1119,8 +722,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.958730Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     }
    },
    "outputs": [],
@@ -1136,8 +738,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.960832Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     }
    },
    "outputs": [],
@@ -1167,8 +768,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.962474Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     },
     "scrolled": true
    },
@@ -1193,8 +793,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.963959Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     },
     "scrolled": true
    },
@@ -1220,8 +819,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.965490Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     },
     "scrolled": true
    },
@@ -1273,8 +871,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.967171Z",
-     "start_time": "2020-04-11T07:44:04.500Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     }
    },
    "outputs": [],
@@ -1288,8 +885,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-11T07:44:51.981247Z",
-     "start_time": "2020-04-11T07:44:04.600Z"
+     "start_time": "2020-04-11T10:55:14.300Z"
     }
    },
    "outputs": [],