diff --git a/CHANGES.md b/CHANGES.md
index a07c55925..04563581a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added a `get_all_learnable_params` method to retrieve the named parameters of all PyTorch modules defined on the net, including of criteria if applicable
 - Added `MlflowLogger` callback for logging to Mlflow (#769)
 - Added `InputShapeSetter` callback for automatically setting the input dimension of the PyTorch module
+- Added a new module to support Gaussian Processes through [GPyTorch](https://gpytorch.ai/). To learn more about it, read the [GP documentation](https://skorch.readthedocs.io/en/latest/user/probabilistic.html) or take a look at the [GP notebook](https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb). This feature is experimental, i.e. the API could be changed in the future in a backwards incompatible way.
 
 ### Changed
 
diff --git a/README.rst b/README.rst
index c675adaad..a45a8303e 100644
--- a/README.rst
+++ b/README.rst
@@ -31,6 +31,7 @@ Resources
 
 - `Documentation <https://skorch.readthedocs.io/en/latest/?badge=latest>`_
 - `Source Code <https://github.com/skorch-dev/skorch/>`_
+- `Installation <https://github.com/skorch-dev/skorch#installation>`_
 
 ========
 Examples
@@ -127,6 +128,7 @@ skorch also provides many convenient features, among others:
 - `Parameter freezing/unfreezing <https://skorch.readthedocs.io/en/stable/callbacks.html#skorch.callbacks.Freezer>`_
 - `Progress bar <https://skorch.readthedocs.io/en/stable/callbacks.html#skorch.callbacks.ProgressBar>`_ (for CLI as well as jupyter)
 - `Automatic inference of CLI parameters <https://github.com/skorch-dev/skorch/tree/master/examples/cli>`_
+- `Integration with GPyTorch for Gaussian Processes <https://skorch.readthedocs.io/en/latest/user/probabilistic.html>`_
 
 ============
 Installation
diff --git a/docs/conf.py b/docs/conf.py
index e7274062c..9e72ee127 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -50,10 +50,11 @@
 
 intersphinx_mapping = {
     'pytorch': ('https://pytorch.org/docs/stable/', None),
-    'sklearn': ('http://scikit-learn.org/stable/', None),
-    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
+    'sklearn': ('https://scikit-learn.org/stable/', None),
+    'numpy': ('https://docs.scipy.org/doc/numpy/', None),
     'python': ('https://docs.python.org/3', None),
     'mlflow': ('https://mlflow.org/docs/latest/', None),
+    'gpytorch': ('https://docs.gpytorch.ai/en/stable/', None),
 }
 
 # Add any paths that contain templates here, relative to this directory.
@@ -118,7 +119,7 @@
 # html_theme_options = {}
 
 def setup(app):
-    app.add_stylesheet('css/my_theme.css')
+    app.add_css_file('css/my_theme.css')
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
diff --git a/docs/index.rst b/docs/index.rst
index 5af095b1d..ada43a759 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -52,6 +52,7 @@ User's Guide
    user/callbacks
    user/dataset
    user/save_load
+   user/probabilistic
    user/history
    user/toy
    user/helper
@@ -82,5 +83,5 @@ Indices and tables
 * :ref:`search`
 
 
-.. _pytorch: http://pytorch.org/
-.. _sklearn: http://scikit-learn.org/
+.. _pytorch: https://pytorch.org/
+.. _sklearn: https://scikit-learn.org/
diff --git a/docs/probabilistic.rst b/docs/probabilistic.rst
new file mode 100644
index 000000000..e5e3eed30
--- /dev/null
+++ b/docs/probabilistic.rst
@@ -0,0 +1,5 @@
+skorch.probabilistic
+====================
+
+.. automodule:: skorch.probabilistic
+	:members:
diff --git a/docs/skorch.rst b/docs/skorch.rst
index 41d6b2dd7..b19f2246c 100644
--- a/docs/skorch.rst
+++ b/docs/skorch.rst
@@ -11,6 +11,7 @@ skorch
    helper
    history
    net
+   probabilistic
    regressor
    scoring
    toy
diff --git a/docs/user/probabilistic.rst b/docs/user/probabilistic.rst
new file mode 100644
index 000000000..c55e1e87b
--- /dev/null
+++ b/docs/user/probabilistic.rst
@@ -0,0 +1,222 @@
+==================
+Gaussian Processes
+==================
+
+skorch integrates with GPyTorch_ to make it easy to train Gaussian Process (GP)
+models. You should already know how Gaussian Processes work. Please refer to
+other resources if you want to learn about them, this section assumes
+familiarity with the concept.
+
+GPyTorch adopts many patterns from PyTorch, thus making it easy to pick up for
+seasoned PyTorch users. Similarly, the skorch GPyTorch integration should look
+familiar to seasoned skorch users. However, GPs are a different beast than the
+more common, non-probabilistic machine learning techniques. It is important to
+understand the basic concepts before using them in practice.
+
+Installation
+------------
+
+In addition to the normal skorch dependencies and PyTorch, you need to install
+GPyTorch as well. It wasn't added as a normal dependency since most users
+probably are not interested in using skorch for GPs. To install GPyTorch, use
+either pip or conda:
+
+.. code:: bash
+
+    # using pip
+    pip install -U gpytorch
+    # using conda
+    conda install gpytorch -c gpytorch
+
+When to use GPyTorch with skorch
+--------------------------------
+
+Here we want to quickly explain when it would be a good idea for you to use
+GPyTorch with skorch. There are a couple of offerings in the Python ecosystem
+when it comes to Gaussian Processes. We cannot provide an exhaustive list of
+pros and cons of each possibility. There are, however, two obvious alternatives
+that are worth discussing: using the sklearn_ implementation and using GPyTorch
+without skorch.
+
+When to use skorch + GPyTorch over sklearn:
+
+* When you are more familiar with PyTorch than with sklearn
+* When the kernels provided by sklearn are not sufficient for your use case and
+  you would like to implement custom kernels with PyTorch
+* When you want to use the rich set of optimizers available in PyTorch
+* When sklearn is too slow and you want to use the GPU or scale across machines
+* When you like to use the skorch extras, e.g. callbacks
+
+When to use skorch + GPyTorch over pure GPyTorch
+
+* When you're already familiar with skorch and want an easy entry into GPs
+* When you like to use the skorch extras, e.g. callbacks and grid search
+* When you don't want to bother with writing your own training loop
+
+However, if you are researching GPs and would like to have control over every
+detail, using all the rich but very specific featues that GPyTorch has on offer,
+it is better to use it directly without skorch.
+
+Examples
+--------
+
+Exact Gaussian Processes
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Same as GPyTorch, skorch supports exact and approximate Gaussian Processes
+regression. For exact GPs, use the
+:class:`~skorch.probabilistic.ExactGPRegressor`. The likelihood has to be a
+:class:`~gpytorch.likelihoods.GaussianLikelihood` and the criterion
+:class:`~gpytorch.mlls.ExactMarginalLogLikelihood`, but those are the defaults
+and thus don't need to be specified. For exact GPs, the module needs to be an
+:class:`~gpytorch.models.ExactGP`. For this example, we use a simple RBF kernel.
+
+.. code:: python
+
+    import gpytorch
+    from skorch.probabilistic import ExactGPRegressor
+
+    class RbfModule(gpytorch.models.ExactGP):
+        def __init__(likelihood, self):
+            # detail: We don't set train_inputs and train_targets here skorch because
+            # will take care of that.
+            super().__init__()
+            self.mean_module = gpytorch.means.ConstantMean()
+            self.covar_module = gpytorch.kernels.RBFKernel()
+
+        def forward(self, x):
+            mean_x = self.mean_module(x)
+            covar_x = self.covar_module(x)
+            return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
+
+    gpr = ExactGPRegressor(RbfModule)
+    gpr.fit(X_train, y_train)
+    y_pred = gpr.predict(X_test)
+
+As you can see, this almost looks like a normal skorch regressor with a normal
+PyTorch module. We can fit as normal using the ``fit`` method and predict using
+the ``predict`` method.
+
+Inside the module, we determine the mean by using a mean function (just constant
+in this case) and the covariance matrix using the RBF kernel function. You
+should know about mean and kernel functions already. Having the mean and
+covariance matrix, we assume that the output distribution is a multivariate
+normal function, since exact GPs rely on this assumption. We could send the
+``x`` through an MLP for `Deep Kernel Learning
+<https://docs.gpytorch.ai/en/stable/examples/06_PyTorch_NN_Integration_DKL/index.html>`_
+but left it out to keep the example simple.
+
+One major difference to usual deep learning models is that we actually predict a
+distribution, not just a point estimate. That means that if we choose an
+appropriate model that fits the data well, we can express the **uncertainty** of
+the model:
+
+.. code:: python
+
+    y_pred, y_std = gpr.predict(X, return_std=True)
+    lower_conf_region = y_pred - y_std
+    upper_conf_region = y_pred + y_std
+
+Here we not only returned the mean of the prediction, ``y_pred``, but also its
+standard deviation, ``y_std``. This tells us how uncertain the model is about
+its prediction. E.g., it could be the case that the model is fairly certain when
+*interpolating* between data points but uncertain about *extrapolating*. This is
+not possible to know when models only learn point predictions.
+
+The obtain the confidence region, you can also use the ``confidence_region``
+method:
+
+.. code:: python
+
+    # 1 standard deviation
+    lower, upper = gpr.confidence_region(X, sigmas=1)
+
+    # 2 standard deviation, the default
+    lower, upper = gpr.confidence_region(X, sigmas=2)
+
+Furthermore, a GP allows you to sample from the distribution even *before
+fitting* it. The GP needs to be initialized, however:
+
+.. code:: python
+
+    gpr = ExactGPRegressor(...)
+    gpr.initialize()
+    samples = gpr.sample(X, n_samples=100)
+
+By visualizing the samples and comparing them to the true underlying
+distribution of the target, you can already get a feel about whether the model
+you built is capable of generating the distribution of the target. If fitting
+takes a long time, it is therefore recommended to check the distribution first,
+otherwise you may try to fit a model that is incapable of generating the true
+distribution and waste a lot of time.
+
+Approximate Gaussian Processes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For some situations, fitting an exact GP might be infeasible, e.g. because the
+distribution is not Gaussian or because you want to perform stochastic
+optimization with mini-batches. For this, GPyTorch provides facilities to train
+variational and approximate GPs. The module should inherit from
+:class:`~gpytorch.models.ApproximateGP` and should define a *variational
+strategy*. From the skorch side of things, use
+:class:`~skorch.probabilistic.GPRegressor`.
+
+.. code:: python
+
+    import gpytorch
+    from gpytorch.models import ApproximateGP
+    from gpytorch.variational import CholeskyVariationalDistribution
+    from gpytorch.variational import VariationalStrategy
+    from skorch.probabilistic import GPRegressor
+
+    class VariationalModule(ApproximateGP):
+        def __init__(self, inducing_points):
+            variational_distribution = CholeskyVariationalDistribution(inducing_points.size(0))
+            variational_strategy = VariationalStrategy(
+                self, inducing_points, variational_distribution, learn_inducing_locations=True,
+            )
+            super().__init__(variational_strategy)
+            self.mean_module = gpytorch.means.ConstantMean()
+            self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())
+
+        def forward(self, x):
+            mean_x = self.mean_module(x)
+            covar_x = self.covar_module(x)
+            return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
+
+    X, y = get_data(...)
+    X_incuding = X[:100]
+    X_train, y_train = X[100:], y[100:]
+    num_training_samples = len(X_train)
+
+    gpr = GPRegressor(
+        VariationalModule,
+        module__inducing_points=X_inducing,
+        criterion__num_data=num_training_samples,
+    )
+
+    gpr.fit(X_train, y_train)
+    y_pred = gpr.predict(X_train)
+
+As you can see, the variational strategy requires us to use inducing points. We
+split off 100 of our training data samples to use as inducing points, assuming
+that they are representative of the whole distribution. Apart from this, there
+is basically no difference to using exact GP regression.
+
+Finally, skorch also provides :class:`~skorch.probabilistic.GPBinaryClassifier`
+for binary classification with GPs. It uses a Bernoulli likelihood by default.
+However, using GPs for classification is not very common, GPs are most commonly
+used for regression tasks where data points have a known relationship to each
+other (e.g. in time series forecasts).
+
+Multiclass classification is not currently provided, but you can use
+:class:`~skorch.probabilistic.GPBinaryClassifier` in conjunction with
+:class:`~sklearn.multiclass.OneVsRestClassifier` to achieve the same result.
+
+Further examples
+----------------
+
+To see all of this in action, we provide a notebook that shows using skorch with GPs on real world data: `Gaussian Processes notebook <https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb)>`_.
+
+.. _GPyTorch: https://gpytorch.ai/
+.. _sklearn: https://scikit-learn.org/stable/modules/gaussian_process.html
diff --git a/docs/user/tutorials.rst b/docs/user/tutorials.rst
index 2e743d31c..7db3081b9 100644
--- a/docs/user/tutorials.rst
+++ b/docs/user/tutorials.rst
@@ -22,3 +22,5 @@ The following are examples and notebooks on how to use skorch.
 * `Seq2Seq Translation using skorch <https://github.com/skorch-dev/skorch/tree/master/examples/translation>`_ - Translation with a seqeuence to sequence network.
 
 * `Advanced Usage <https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Advanced_Usage.ipynb>`_ - Dives deep into the inner works of skorch. `Run in Google Colab 💻 <https://colab.research.google.com/github/skorch-dev/skorch/blob/master/notebooks/Advanced_Usage.ipynb>`_
+
+* `Gaussian Processes <https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb>`_ - Train Gaussian Processes with the help of GPyTorch `Run in Google Colab 💻 <https://colab.research.google.com/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb>`_
diff --git a/notebooks/Gaussian_Processes.ipynb b/notebooks/Gaussian_Processes.ipynb
new file mode 100644
index 000000000..6f15b4840
--- /dev/null
+++ b/notebooks/Gaussian_Processes.ipynb
@@ -0,0 +1,2436 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gaussian Processes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "skorch supports integration with the fantastic [GPyTorch](https://gpytorch.ai/) library. GPyTorch implements various Gaussian Process (GP) techniques on top of PyTorch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "GPyTorch adopts many patterns from PyTorch, thus making it easy to pick up for seasoned PyTorch users. Similarly, the skorch GPyTorch integration should look familiar to seasoned skorch users. However, GPs are a different beast than the more common, non-probabilistic machine learning techniques. It is important to understand the basic concepts before using them in practice."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook is not the place to learn about GPs in general, instead a basic understanding is assumed. If you're looking for an introduction to probabilistic programming and GPs, here are some pointers:\n",
+    "\n",
+    "- The GPyTorch [documentation](https://docs.gpytorch.ai/en/stable/)\n",
+    "- The book [Gaussian Processes for Machine Learning](http://gaussianprocess.org/gpml/chapters/) by Carl Edward Rasmussen and Christopher K. I. Williams\n",
+    "- The lecture series [Probabilistic Machine Learning](https://www.youtube.com/playlist?list=PL05umP7R6ij1tHaOFY96m5uX3J21a6yNd) by Philipp Hennig"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Below, we will show you how to use skorch for Gaussian Processes through GPyTorch. We assume that you are familiar with how skorch and PyTorch work and we will focus on how using GPs differs from using non-probabilistic deep learning techniques with skorch. For a discussion on when and when not to use GPyTorch with skorch, please have a look at our [documentation](https://skorch.readthedocs.io/en/latest/user/probabilistic.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<table align=\"left\"><td>\n",
+    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb\">\n",
+    "    <img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>  \n",
+    "</td><td>\n",
+    "<a target=\"_blank\" href=\"https://github.com/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a></td></table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you haven't already, you should install GPyTorch, since it is not installed automatically after installing skorch:\n",
+    "\n",
+    "```bash\n",
+    "# using pip\n",
+    "pip install -U gpytorch\n",
+    "# using conda\n",
+    "conda install gpytorch -c gpytorch\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! [ ! -z \"$COLAB_GPU\" ] && pip install torch \"skorch>=0.11\" gpytorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table of contents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* [Exact Gaussian Process Regression](#Exact-Gaussian-Process-Regression)\n",
+    "  * [Simple example: sine curve](#Simple-example:-sine-curve)\n",
+    "  * [GP regression with real world data](#Regression-with-real-world-data)\n",
+    "* [Stochastic Variational GP Regression](#Stochastic-Variational-GP-Regression)\n",
+    "* [Classification](#Classification)\n",
+    "  * [Binary classification](#Binary-classification)\n",
+    "  * [Multiclass classification](#Multiclass-Classification)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import os\n",
+    "import urllib.request"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "import gpytorch\n",
+    "from matplotlib import pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(0)\n",
+    "torch.cuda.manual_seed(0)\n",
+    "plt.style.use('seaborn')\n",
+    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu' "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Exact Gaussian Process Regression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "GPyTorch implmenets different methods to solve GPs. The most basic form is to use exact solutions. Variational GPs are described further below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simple example: sine curve"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The \"Hello world\" of GPs is predicting a sine curve with Gaussian noise added on top. We will start with this example."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First we synthesize our data. For training, we use a sine curve with Gaussian noise added on top. For validation, we just use the sine without noise, assuming this is the underlying ground truth. To make it difficult for the model, the training data will only contain very few data points for now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampling_frequency = 0.5\n",
+    "X_train = torch.arange(-8, 9, 1 / sampling_frequency).float()\n",
+    "y_train = torch.sin(X_train) + torch.randn(len(X_train)) * 0.2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_valid = torch.linspace(-10, 10, 100)\n",
+    "y_valid = torch.sin(X_valid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see below, there is a slight hint of periodicity in the training data but it could also just be noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f522f46d8d0>]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x396 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(X_train, y_train, 'o')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the module"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As usual with PyTorch, the core of your modeling approach is to define the module. In our case, instead of subclassing `torch.nn.Module`, we subclass `gpytorch.models.ExactGP` (which itself is a subclass of `torch.nn.Module`), since we want to do exact GP. As always, we need to define our own `__init__` method (don't forget to call `super().__init__`) and our own `forward` method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RbfModule(gpytorch.models.ExactGP):\n",
+    "    def __init__(self, likelihood, noise_init=None):\n",
+    "        # detail: We don't set train_inputs and train_targets here because skorch\n",
+    "        # will take care of that.\n",
+    "        super().__init__(train_inputs=None, train_targets=None, likelihood=likelihood)\n",
+    "        self.mean_module = gpytorch.means.ConstantMean()\n",
+    "        self.covar_module = gpytorch.kernels.RBFKernel()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, we don't want to go into too much details about GPs or GPyTorch. The important ingredients here are the _mean function_ and the _kernel function_. As the name suggests, the mean function is only there to determine the means of the Gaussian distribution. The kernel function is used to calculate the covariance matrix of the data points. Together, the means and covariance matrix are sufficient to define a Gaussian distribution.\n",
+    "\n",
+    "For the mean function `gpytorch.means.ConstantMean` will often do. Choosing the correct kernel, however, is where it gets interesting. This kernel should be chosen wisely so as to fit the problem as best as possible. The correct choice here is as crucial as choosing the correct Deep Learning architecture &mdash; when you choose an RNN for an image classification problem, you will have little luck. That being said, a good start is often to use the `RBFKernel` and then iterate from there. That's why we use the RBF for our toy example.\n",
+    "\n",
+    "The output of the `forward` method should always be a `gpytorch.distributions.MultivariateNormal` for `ExactGP`. It represents the prior latent distribution conditioned on the input data. The posterior is computed by applying a likelihood, which is `gpytorch.likelihoods.GaussianLikelihood` by default for GP regression."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### skorch `ExactGPRegressor`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's define our skorch model. For this, we import `ExactGPRegressor` and initialize it in much the same way as we would a `NeuralNet`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/vinh/work/skorch/skorch/probabilistic.py:35: SkorchWarning: The API of the Gaussian Process estimators is experimental and may change in the future\n",
+      "  \"change in the future\", SkorchWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from skorch.probabilistic import ExactGPRegressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gpr = ExactGPRegressor(\n",
+    "    RbfModule,\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=0.1,\n",
+    "    max_epochs=20,\n",
+    "    device=DEVICE,\n",
+    "    batch_size=-1,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see, we pass the `RbfModule` defined above as the first argument, as we always do. We also define the optimizer, learning rate (`lr`) and device as usual. We could pass our own `likelihood` argument, but since we use the default likelihood, we don't need to do that."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One oddity you might have noticed is `batch_size=-1`. -1 is a placeholder that means: take all the data at once, don't use batching. The reason for this is that the exact solution requires all data to be passed at the same time, it does not work on batches. The batch size is -1 by default but we set it here explicitly to make it clear that it is so.\n",
+    "\n",
+    "If you need to use batches (say, you don't have enough GPU memory to fit all your data), you can use variational GPs, as shown later in the notebook."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div class=\"alert alert-block alert-info\">\n",
+    "    <b>Info:</b>\n",
+    "    GPyTorch stores a reference to the training data (i.e X and y) on the module. This can make your model quite big if your training data is large. However, exact GPs are typically not used with large datasets - if you want to avoid this issue, take a look at the variational method described further below.\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sampling"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At this point, we can already show a new feature that is available thanks to GPs. They allow us to sample from the underlying distribution, conditioned on our data, even though we have not even called `fit` on the model. To do this, we initialize the `ExactGPRegressor` by calling `initialize()` and then use the `sample` method. The first argument to `sample` is the data to condition on, in this case the training data, and the second argument is the number of samples to draw."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We plot the result next to the ground truth and the training data for comparison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gpr.initialize()\n",
+    "\n",
+    "samples = gpr.sample(X_train, n_samples=50)\n",
+    "samples = samples.detach().numpy()  # turn into numpy array\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(X_train, samples.T, color='k', alpha=0.1)\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, 'r', label='true')\n",
+    "ax.set_xlim([-8.1, 8.1])\n",
+    "ax.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It can often be wise to plot a couple of samples _before_ starting a lengthy training process. These samples can be compared to the underlying data to see if the chosen model looks reasonable _a priori_. If the distribution of the target looks very different from the sampled distribution, it means it could not result from the assumed distribution. No matter how well you train, your model will never fit your data. In such a case, you probably need to find a better kernel function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fitting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As always, to train the model, we call the `fit` method and pass the training data and targets as arguments:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Re-initializing module.\n",
+      "Re-initializing criterion.\n",
+      "Re-initializing optimizer.\n",
+      "  epoch    train_loss     dur\n",
+      "-------  ------------  ------\n",
+      "      1        \u001b[36m1.2771\u001b[0m  0.0204\n",
+      "      2        \u001b[36m1.2650\u001b[0m  0.0097\n",
+      "      3        \u001b[36m1.2533\u001b[0m  0.0092\n",
+      "      4        \u001b[36m1.2416\u001b[0m  0.0129\n",
+      "      5        \u001b[36m1.2312\u001b[0m  0.0084\n",
+      "      6        \u001b[36m1.2211\u001b[0m  0.0138\n",
+      "      7        \u001b[36m1.2111\u001b[0m  0.0069\n",
+      "      8        \u001b[36m1.2017\u001b[0m  0.0132\n",
+      "      9        \u001b[36m1.1932\u001b[0m  0.0141\n",
+      "     10        \u001b[36m1.1850\u001b[0m  0.0088\n",
+      "     11        \u001b[36m1.1771\u001b[0m  0.0130\n",
+      "     12        \u001b[36m1.1698\u001b[0m  0.0092\n",
+      "     13        \u001b[36m1.1632\u001b[0m  0.0085\n",
+      "     14        \u001b[36m1.1570\u001b[0m  0.0047\n",
+      "     15        \u001b[36m1.1511\u001b[0m  0.0082\n",
+      "     16        \u001b[36m1.1456\u001b[0m  0.0169\n",
+      "     17        \u001b[36m1.1408\u001b[0m  0.0084\n",
+      "     18        \u001b[36m1.1363\u001b[0m  0.0101\n",
+      "     19        \u001b[36m1.1320\u001b[0m  0.0067\n",
+      "     20        \u001b[36m1.1281\u001b[0m  0.0075\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<class 'skorch.probabilistic.ExactGPRegressor'>[initialized](\n",
+       "  module_=RbfModule(\n",
+       "    (likelihood): GaussianLikelihood(\n",
+       "      (noise_covar): HomoskedasticNoise(\n",
+       "        (raw_noise_constraint): GreaterThan(1.000E-04)\n",
+       "      )\n",
+       "    )\n",
+       "    (mean_module): ConstantMean()\n",
+       "    (covar_module): RBFKernel(\n",
+       "      (raw_lengthscale_constraint): Positive()\n",
+       "      (distance_module): Distance()\n",
+       "    )\n",
+       "  ),\n",
+       ")"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gpr.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div class=\"alert alert-block alert-info\">\n",
+    "    <b>Info:</b>\n",
+    "    For GP regression, skorch does <i>not</i> perform a train/valid split by default. This is why you only see the train loss here, not the validation loss as usual. The reason for this decision is that a random split is most often not appropriate for GP regression. E.g. when you deal with a time series, random splitting would result in data leakage. Therefore, if you want validation scores, it is probably best to implement your own <code>train_split</code> or use <code>skorch.helper.predefined_split</code> if you already have split your data beforehand (see the example further below).\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the trained model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that our model is trained, we can repeat the sampling process from above. As you can see, the samples fit the data much better now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/vinh/anaconda3/envs/skorch/lib/python3.7/site-packages/gpytorch/models/exact_gp.py:275: GPInputWarning: The input matches the stored training data. Did you forget to call model.train()?\n",
+      "  GPInputWarning,\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "samples = gpr.sample(X_train, 50)\n",
+    "samples = samples.detach().numpy()  # turn into numpy array\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(X_train, samples.T, color='k', alpha=0.1)\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, 'r', label='true')\n",
+    "ax.set_xlim([-8.1, 8.1])\n",
+    "ax.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since the model represents a probability distribution, instead of just making point predictions as is most often the case for Deep Learning, we can use the distribution to give us confidence intervals. To do this, we can pass `return_std=True` to the `predict` call. This will return one standard deviation for the given data, which we can add/subtract from our prediction to get upper/lower confidence bounds:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f522f4309d0>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAHRCAYAAABpU38LAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3Qc9bUH8O8W9d57sWXLNq7gbowB05xCCCUhjdACSV4KEEp45NECAdNr6C04DZJQE0PAgMG9yrJsq/dVWa22952dmffHamXJVtkybaX7OSfnhJV25rfj0eydO/d3fyqe53kQQgghhBAyzanlHgAhhBBCCCFKQIExIYQQQgghoMCYEEIIIYQQABQYE0IIIYQQAoACY0IIIYQQQgBQYEwIIYQQQggAQCv3AIIMBrts+87KSobZ7JJt/7GGjld46HiFh45XeOh4hYeOV3joeIWHjld45DxeeXlpY75OGWMAWq1G7iHEFDpe4aHjFR46XuGh4xUeOl7hoeMVHjpe4VHi8aLAmBBCCCGEEFBgTAghhBBCCAAKjAkhhBBCCAFAgTEhhBBCCCEAKDAmhBBCCCEEAAXGhBBCCCGEAKDAmBBCCCGEEAAUGBNCCCGESObdd/+JM89cjaKiLJx55mq8++4/o9qe1+vFhx++F/Lvb978IbZv/zLs/Tz//DPYvPnDcX/e39+P7du/Cnu7SkOBMSGEEEKIBN5995/46U+vQX39UbAsi/r6o/jpT6+JKjg2mYxhBcZf//qFWLv2zIj3N56DB/ehrq5W8O1KTTFLQhNCCCGETGVPPvnYmK8/9dTjuPjiyyLa5ptvvoaOjna8/vrL4DgOR44chtvtxu2334mPP/4PGhqOweVyobJyBu644268+uqLyMnJQXl5Jf7ylzcRF6dFX18v1q8/D1deee2obW/d+hn+9KdXkZmZBYZhUFFRCZZl8cgjD2BgQA+r1YpVq9bgmmuux5///AY8Hg8WLlyElJRUvP76ywAAj8eD//u/e1FeXhHR55MaZYwJIYQQQiTQ1NQQ1uuh+PGPr0Fl5QxcffV1AICKihl44YXXkJeXh7S0NDz55HN44YXXcPRoHQyGgVHv1ev7cP/9D+OFF17HX//65knbfu65p/Hkk8/h8cefRWJiIgBgYECP+fMX4vHHn8Vzz72C9977JzQaDX70o6tw3nkbsHbtmWhvb8Ndd92Hp59+AWvXrsMXX2yJ+PNJjTLGhBBCCCESqK6ei/r6o2O+LpRgZjYhIRFmsxl3330HkpOT4Xa74ff7R/3uzJmzoNVqodVqkZCQOOpnJpMRKSkpyMjIBAAsWLAIAJCeno76+qM4eHA/UlJS4PMxJ40hLy8PTz75CJKSkmEwDGDhwsWCfT6xUcaYEEIIIUQCN95485iv33DDbyLepkqlBs9zw/+tVqsAALt378DAgB733vsArr/+F/B6PeB5/oT3jr/d9PQMOBxOmM1mAEBDwzEAwObN/0Zqahruvvt+fO97PxrerkqlGh7HQw/djzvuuBu/+909yM3Ni/izyYEyxoQQQgghEgjWET/11ONoampAdfVc3HDDbyKuLwaArKwsMIwfzz33NBISEoZfnzdvPt5441Vcf/1ViI+PR3FxCQYHDSFvV6vV4o477sLNN/8SaWkZ0GoDIePSpctxzz134PDhQ0hMTERpaRkGBw2oqpqFN998DdXVc3HBBV/H9ddfhbS0NGRl5YS1X7mp+BNvH2RiMNhl23deXpqs+481dLzCQ8crPHS8wkPHKzx0vMJDxys8dLzCI+fxystLG/N1KqUghBBCCCEEFBgTQgghhBACgAJjQgghhBBJMH5u8l8isqLAmBBCCCFEZCzHYeeRPvhZCo6VjAJjQgghhBCRteisMNu96OwPfbKZw83A5vKJOCpyIgqMCSGEEEJE5PIwaNJZAQCtPVZwITYEO9ZhwpeHetHRbxNzeGQECowJIYQQQkR0uM0IdqiEwuX1o8fgnPQ9ZrsXvYNOsCyHQ82D2NcwAMbPnvR7Xq8XH374nuBjnq4oMCaEEEIIEUm/yYV+o2vUay06y6TvO9ZhGvXfPQYHvqjphcnmGfW6yWSkwFhAtPIdIYQQQogQbr0V2W+9ffy/eR5JPhaVY5ROJMRroFGPnZ9kOR7n+PwAgLbV52HvlYElo10eBtsP92FuRRZml2ZApVLhzTdfQ0dHO15//WVwHIcjRw7D7Xbj9tvvxAMP3IuXXnoDAHD99Vfh3nsfQFpaOjZu/D2s1kBpx4033oqqqlnD+z54cD/+/Oc3EBcXh4EBPS666FIcPLgfLS1N+M53vo+LL74MNTUH8NJLz0Gj0aC4uAS33fY7eL0ebNx4PxwOO6xWCy688GJcfPFl+OUvr8fs2XPQ1tYKl8uB++57CIWFRUIcbVFQxpgQQgghRAQMy2O8BYYZ//h1xmOVTARxPI9jHSZYHIFJeT/+8TWorJyBq6++DgBQUTEDL7zw2qjloUd6883XsHTpCjzzzIu47bbf4dFHHzzpdwYGBvCHPzyCm2/+X7z55mu4887f49FHn8b7778Dnufx0EN/wAMPPIJnn30JeXn52Lz5Q+h0Opx77vl44ok/4uGHn8Rbb/1leHvz5s3HU089h2XLVuLTT/877mdTAsoYE0IIIYQI4ZFHYLrtLgCA08Pg8wM6sNz4AfCZS0qQlTY6gO0ZdGJfvX7SXelNrpPeCwDl5RVj/n4wQG9ra8HBg/vx2WefAADs9pO7ZMycWQWtVou0tDQUF5cgLi4OaWnp8Pm8sFjMMBoHceedtwMI1DivWLEKa9asxdtv/xVffvkFkpNT4Pf7h7dXXT0HAFBQUACj0TjpZ5MTBcaEEEIIIQKrazVOGBQDQLPOghXzCob/m+N5NHSaQ9q+3uzC3IosqFRq8Pzx3shqtQoAEB8fD7PZDJZl4XK50NfXCwCoqKjE+eefgvPP3wCz2TRmfbJKNf5+MzIykZ+fj40bH0dqaiq2b/8SSUnJ+NvfNmHBgkW4+OLLcPDgfuzatX3E9ibYoMJQYEwIIYQQIqB+kwv9Jtekv9dndMHhZpCaFAcA6NY7YA+xb7HF4YOXYZGVlQWG8eO5554eVT6Rk5OL5ctX4LrrfoySkjKUlpYBCJRebNx4Hz744B24XE5cc831YX02tVqNG264BbfeegN4nkdycgruvPNeqFQqPProg/jkk4+QkZEBjUYDny/2ejCr+PGKXyRmMITe8FpoeXlpsu4/1tDxCg8dr/DQ8QoPHa/w0PEKDx2v8ASP164j/dCbJw+MAaCyKB1LZuWC5Ths2a+D2+uf/E1Dls7JR1l+aqTDlZ2c51deXtqYr9PkO0IIIYQQgfhZDoNWd8i/3623w+tj0d5rDysoBgJ1xkRYVEpBCCGEECIQg8U9aW3xSCzHo7HbDF0Ii36MtS+e52OqhlfpKGNMCCGEECIQvTn0bHFQW68NPmb8Fm3j8TIszHZv2O8j46PAmBBCCCFEIAMSlzdQOYWwKDAmhBBCCBGA2e6BK8w64WjpLeFnqMn4KDAmhBBCCBFAbwR1wtGyOnzw+KQNxqcyCowJIYRMOQrpREqmmb5Bh+T75HkeAxHUNZ/o7rv/FwcP7sfu3Tvx/vvvjPt777//zqhV7Sby3nv/xKuvvhj12KREgTEhhBBFcHkY2EJc3GAyta1GMH5u8l8kRCA+hoXB4pFl35FM+BvPqlVrcNFFl4z7802bXgfLhj9RMFZQuzZCCCGy8zEsdh3VozA7GfNnZEe1LYebQWe/HRq1Cgtn5gg0QkImNmBx4y8v5WL3V2MvHBGppastuOzKvnF/fuTAVnxQvx+bEjhYrVZcffVPcNZZ5+CKK76LsrIKxMXF4dZb78DGjb+H1WoFANx4462oqpqFf/3rbfz73+8hJycXZnNgKerNmz9EZ2cHfv7zX+GNN17Btm1fgmVZfPvbl0Kr1cBkMuKee+7Agw8+hhdeeBa1tQfBcTwuv/yHWL/+XNTWHsJTTz2K9PR0qNUazJ+/YNR4N2/+EDt2fAWv1wur1YyLL/4utm37Eu3trfjFL27AGWechc8/34K33voL1Go1Fi1agp///FcYGNDj0Uc3wufzwmaz4qqrrsO6dWfhyiu/hyVLTkNrawsADC9VHSkKjAkhhMjKz3LYfUwPu8sHluNxSmVWVH1Z23qt4Hke7b02lBekISMlXsDREjI2vckNQJ5zzet1Y+PGZ6HlPbjuuiuxdu2ZcLvduOqqa1FdPRfPPfc0li5dgYsvvgzd3V144IF78cgjT+Ef//g73nzz71Cr1bj22h+N2mZTUwP27NmJl156AwzD4IUXnsUNN9yMN954Fffc8wB27dqBvr4ePP/8a/B6vfjpT6/G8uUr8cwzj+Oee/6A8vIKPProg2OO1+Vy4Ykn/oi9e7/Cyy+/ipdeegM1NQfwj3/8DYsXn4rXXnsRr7yyCYmJibjvvjuxb99uACp873s/xGmnLUNdXS1effVFrFt3FpxOJ8499wLcdNNtuPfe/8Pu3Ttw7rkXRHwsKTAmhBAiG47ncaDRAJMt8Aja5WFgtnuRnZ4Y0fYYP4suvWN424dbB3HGomLBxkvIWAJ1vi784DofLvqBTvL9l844BYNWL06pzEFaWjosFgsAoLy8EgDQ1taCgwf347PPPgEA2O12dHZ2YMaMmYiPDwTz8+bNH7XNrq5OzJs3HxqNBhqNBjfeeMuon7e1taCxsQG//OX1AAC/34/+/j4YDAMoL68AACxcuBg6XfdJ4509ew4AIC0tDZWVM6BSqZCWlgav1wedrhsWixm33PJrAIEguqenB4sWLcGf/vQq/vOf9wGoRtU5V1cHtpefXwCfL7pyLKoxJoQQIpvDrUb0GUfP5I9kBbCgjn47/Ozx2mKj1YMuvT3i7RESCrPdC28EC3QIRd/TBr3ZDZPJCKfTiaysLAAYfvJSUVGJ7373B3j22Zdw330bcf75G1BcXIKOjjZ4vR6wLIumpsZR26yoqERTUyM4joPf78eNN/4PfD4fVCo1eJ5HRUUlTj11GZ599iU8/fQLWL/+XJSUlCAnJwcdHe0AgPr6Y2OOd6InQkVFJcjPL8CTTz6HZ599CZdddjnmz1+AV155ARs2fAN33nkfTjtt2YlbjPDInYwyxoQQQmTR2GVGR5/tpNd7B51YODM77HIKbqh84kTHOswoyklGnFYT8VgJmYiQk98i4bRb8PKTv0OCxo+bb/4tNJrR5/qPf3wNNm68Dx988A5cLieuueZ6ZGVl4Sc/+Rl+9rNrkJmZhaSkpFHvmT17DlauXI2f//xacByHiy++DPHx8Vi8eAluueXXeOaZF1FTcwD/8z8/gdvtwrp1ZyM5OQV33nkf/vCHu5GcnILk5GSkpYVXc52VlYXLL/8hfvnL68GyLIqKirF+/Xk4++xz8NRTj2LTpteRn18wnBUXmopXSE8bg0G+O/q8vDRZ9x9r6HiFh45XeOh4hSdWj1dnvx01zYZxf752YRFyM5PG/flYdAYH9jcMjPmzmcUZWFSVE7PHSy50vEKztaYHFocXKSkJcDqlXaL5yIGtMBl6sG7DD3Hq7DxUFAo7+U9Mcp5feXljHycqpSCEECIpu8uH2pbBCX9HNxh+OUVrj3Xcn3X02WB1CtMKjpCRPD6/Ys4tvZmWh44WlVIQQgiRVIvOCm6Sh5V9RicWVeVAHWI5hcnmgdk+fqaO43kcbhnErEpq30aEpTe5ZV1QZsHSs4b/v8HiBsfxUKuFq7mdbihjTAghRDJurx/dhslXB/P6WAxaQq/bbJkgWxxktHnQ3jv57xESDiVlaRk/B0MYfzfkZBQYE0IIkUxrjxUcF1p2rSfE7hQuD4N+Y2jByaEmA1iOVsQjwuA4XnGBaCg3iWR8FBgTQgiRhI9h0dEf+kSbPpMrpCC6rdc2aWlGkNvrR3sfTSYjwjDaPIpbetxgccPqkHYC4FRCgTEhhBBJtPfZRvUYnoyPYTEwSTaO8XPoDLNPcbPOEtY4CBmP3qScMoqRKGscOZp8RwghRHR+lkPbGD2GJ9NjcKAwO3ncn3f028LO2Hl9LNp6baguywx7PIQEMX5uzHr5hi6zoPuZW54V9nt6Bp04pdKPzvZm7NjxFa699qcT/v7bb/8VRqMRP//5r0La/vvvv4NvfONb0GpHh5Hf+tYF+OCD/477vueffwYVFZX4+tcvDGk/cqCMMSGEENF16u0RrQzWb3KNWRPM8TyOdphwrCOyIKS1x6q4R+AktrT0WOH1ybfa3UQ4jkdbrw07d27DmjVrx/09r9eD3//+Trzzzj/C2v6mTa+DZZX52aNFGWNCCCGi4ngerbrIHu0yfg56kxvFuSnDr7k8fuxvHIDJ5ol4TF6GRVuvFXMiyMYR4vH5J+ybLYcdW95GSlomlqw8H0DgaUpDQz2uvvq6cd/j9fqwYcM3sGzZCnR2dpz0c7PZjLvv/l9wHAeW9eOWW+5Aff0RmExG3HPPHbj//ofx8MN/QHt7G0pKSuHzndzPeevWz/CnP72KzMwsMAyDiopKAMALLzyLo0dr4fP5cfnlP8Rppy3DL37xE/z5z/+ASqXCY489hGXLVuDMM88W5PiEigJjQgghotINOODy+iN+f8+gczgw7jM6UdM8CF8E2ecTtfRYMbM4nZaKJmFr6FJOnXrD4Z04tPsT2MwGaDRaNNTuxKqzL0FeYTm0iWkTLq2enp6OFStWYfPmD8f8eX39UaSkpOKee+5He3s7nE4HvvnNb+ONN17FPfc8gN27d8Ln8+Gll95Af38/tm797KRtPPfc03j55T8hPT0Dt956AwBg164d6Ovrwd///nfodIP46U+vxvLlK1FVNRu1tTU45ZQFqKk5gBtuuFmYgxQGCowJIYSIhuf5qCcC9Ztc8DEsGrrMEdUpj4fxc2jpsWFeBWWNSejsLh+6wuiuIra5i9Zg7qI1J2WM6/Z9jsKKhXA4nbj9tzcBAJYvX4krr7w25G2vWrUGOl0Xbr/9Zmi12pPe297einnz5gMACgsLkZ9fMOrnJpMRKSkpyMgI1PMvWLAIANDW1oLGxgZcccUV8Pn88Pv96O/vw4UXfhsfffRvGI1GrF277qQaZilQjTEhhBDR9JtcsEW5XC7LcvjsoE7QoDiordcaUe0zmb7qO80htweUU0fLYRRWzIfFyePZZ1/Cs8++FFZQDAA1NQeQk5OLJ574I6688lq8+OIfAQAqlRo8z6OiohJHjx4GAAwOGmAwGEa9Pz09Aw6HE2ZzYC5AQ8MxAEBFRSVOPXUZNm3ahKeffgHr15+LkpISLFu2As3NjfjPfz7AN795UbSHICKUMSaEDON5HjqDE6V5KRM+fiMkVM0R1hafSKxJToGssRXzK7NF2T6ZWkw2D3oHQ1t4Rmqnn/vd4f/P+v3gOBbxCYlo6bWiND81om3OmjUbd911B95++29Qq9XD9cqLFy/BLbf8Gs888yIOH67FddddicLCImRmju70otVqcccdd+Hmm3+JtLSM4Qzw6aevQ03NAfzgBz+AzWbHunVnIzk5UC511lnnYP/+vSgtLYtozNFS8XIu8D2CwSDfY4m8vDRZ9x9r6HiFJ5LjZbR6kJigQUpinEijGltbrw2HWweRl5mE06rzkJQg/b0znV/hUfLx6tLbcbDJMPkvSiglJQFO5+jFD7QaNc5bVoaEeKo1PpGSzy85bKvthXGCSZ9jnV9KsHZhEXIzk+QexknkPL/y8tLGfJ0yxoQoCMfxqGszor0v8Mg4OTEOOemJyM1IRG5moqiBstvrR32nCUBg5aTPD+qwuCo34kwDmd669HbUNA/KPYyQ+FkOzToLFszMkXsoRMH6jM4Jg2Ila+mxKjIwViIKjAlRCJfHj30Nepjt3hGvMXB5GHQPBO6oC7OTsWp+oSj7P9xqHNXXlfFz2N84gH6TC4uqchAfR9k0EppgUKyQB5IhaeuzISM1AWV0I0jGwPF8xD2zlUBvdsPm8iE9OV7uoSgeTb4jisb42WnRhF9vduHLQz2jguKxGCzuMRc7iFbvoBN9xrHr5nQGB76o6VHs0qdEWTr7Yy8oBgJPaw40DuBIuzHmxk7E16W3w+6KbhKpnHiex866fujNdB2fDGWMiSI53Azaeq3o0jsQp1VjyaxcFEywLKwY9GYX2npsSIjXICFOg4R4DRLjNEiM1yAzLQFaTfT3lTzPo7HLgsZuS0hfxizHw2z3IjdDuEdijJ9DXZtxwt9xe/3YdbQfBdnJmD8jm7IOZEyd/XYcaom9oHikFp0VdieDZXPzqL8xAc/z6DW6UN8Zu9niII/Pj11H+lFZlI4FM7IF+Q6biigwJooyaHGjpdcKvck9/OXqZznsOtqP8oI0LJyZLdmXVWe/fdy7a61GjeLcFJTnpyInIzHsDg6B1bxcaO+3wWgNr2bNaPUIGhjXd5rgDnHxBb3JBYPZjYrCNMytyEIClVeQIR39NtS2TI1sa+AJTi9WnlKANLoJnLb05kBAbJnkSV6s6eizwWBxY2l1HrLTE+UejuJQYExk53Az0Jtd6NY7YHGMfwHq0tthsLixeFYuCkXOHvsYFv0TlA74WQ5deju69HYkJ8ahLD8V5QWpE06OY/ws+owu9BqdMJjdYLnIAohBqwdzInrnyUw2D9r7wpsRzPE82vts0BkcmFOWhZnF6VCrqbXbdMTx/FD7Khfa+2xTIigOcrgZfFXbi6Vz8kW/3hBlMVo9ONZpCjtpEUucbgbbD/dhVmkG5pZn0TV8BAqMieQYPweDxY0BixsDZjdcHibk97q9fuw+2o+y/DQsnpUj2qOgnkEnuBADV5eHQWOXGU3dFiTGa6DVqKHRqKBVq6HVqJCdbYfR5ITB4g55mxMx2b3gOD7qCxnH8aiN4rE34+dwpN2Itl4rSvJTUZqbgozUhKjGRJTPy7DQm1wYMLuhN7um9BwAxs9hzzE9SvNSMLM4A1lpdH5PRRzHw+5mYHP60GNwTJgUmUo4nkdTtwW6AQfSUuKRkqhFckIckhK1SEnUIilBC41aBbVKBZUK06a3/bQPjJt1FnxR2xd138Hg+aJSqaDC8RNIrQI0GjUShmpTg/WqwTrV6VKryfM89GY32nsDj3CiXTWoe8COwuwklOSJM4NcN+AI+z08z49ZkmD3soL2tWRZDhaHN+pHYC09VlijXJEMAFxeP5q7LWjutiAtOR7FuSkoyUuZNuf2SE4PA8bPISMlfkp9iXh9LHSDDvQanDDZvVMqMzwZnufRPeBA94ADORmJmFWSgcLs5Cn17zsexs/B5vTBaPXAw7Dw+lgwfhYZqQnIzUiM2RpVh5tBv9EFq9MHm8sHu8snSNIiVrm8frhCKKdTjREgR/tX8M11s6LcgvCiCoxra2vx6KOPYtOmTaNe//zzz/HHP/4RWq0Wl156Kb773e+OswX5cRwPP8vBz4qb9RjrYbVKpUJpXirmVWQiWeKFHKTiZzl06u1o77XB4Q49MxwKk90rSmDs9DAwKbymbNDqiSow5nkezTqLgCMKsLt8aOzyobHLjMy0BKycVyDLIiFS8LMczHYvzHYvTHYPLHYfPL7Al0tCnAZ5mUnIz0pCXmZSTB4Dxs+hz+iEzuDAoMUTE0vgis1o9cBo9SAlKQ4zi9NRWZgGjTo2g8OJDFrdONg0CJeHGXfBCo1ahez0RORnJSE/KxkZKcq/Eea4wHWvqdsScSnbdMbzPAKXAeGOHc/zUQfXQov4av3yyy/jgw8+QFLS6ElADMPgwQcfxD//+U8kJSXh+9//Ps4++2zk5eVFPdipJpCJsKNn0IEZRemoLs2cMisvub1+tPRY0aW3i/ao1SRSo3XdgEPxGTGj1QNEsVqmw82I/gjcYvdiR10fTl9YFJOB4UT0Jhf2HNOPGyx6GRY6gwM6Q+DJQ3pKPKrLMlEq0hMOodW2DKJLb6fgYRxON4O6ViPMNi+Wzc2XeziC4XgeDZ1mNOusk14DWY6HweKGweLG0XYTkhPjcOaSYsVOyB20uFHbaozplmtEGhHf6paXl+OZZ5456fXW1laUl5cjIyMD8fHxWLp0Kfbv3x/VIKc6juPR2mPFlgPdaOg0i569FhvP89hTr0drj1XU4Mvq9InS01dnGLufr9DinTaU1uxEgj38zK3JHl0Gb7J+yUJxuBnsqOsLuetFLHB5GBxoMoR1/G1OH2qaBwV/aiKGzn472vtsogbF8Q4b0vp1gMJvQCejMzjQ2mOVexiCcLgZbKvtRVOIrSNP5PIwONZuEmFk0fEyLA42GbC9rk8ZQXGMn/PTQcRpnAsuuAA6ne6k1x0OB9LSjq8/nZKSAodj8nrNrKxkaGXoGdlv8wKDLqSkKGNSRbfRBU28FmsWFcs9lAmNt8Y4ADR3m8FwkOSYquPjkJcl3Ixxo9UNTqUSfOwnbq905xYsf+ZeJJkHwak1GFi0HLo156J79Tlw54W2sp02IQ45EbZt65TwnOcB1Labcc7yspBLhiY6v+TEshz27+1CXLwWcfHhXz6b++w4d3m54DPAhTpeDjeD9oE+Uc+N8q8+wson70ScywlPRhaMcxZhcO5iDM5dDNOchWBSxP+3F/LzdRicqKrIQV5W7C6326qz4EDTIPzjXLdDPV5Ghw+8VoN8Aa/J0Ri0uLGnrh9ehpX0O368fc349D0sff4PgFoNZ37x0P+Khv9/3/Iz4E9KkWycSqG0673gzzdTU1PhdB7PuDmdzlGB8njMMq3GYrUE9ivk5Kho1bcOoiQrUbF1x3l5aTAYxm7x5WVY7DzUAx/DSjKWlg4jVH7h9nW41Sj4uTCyRi/RasKaVzaiaucnYLVxqD//MmS3N6Lw0G4UHtqNZc/dj4FZ89Gx6lwc+fr3wCaM/2Xb1GbErNKMiMbU2WOR9Jx3Or14/4vmkMoqJjq/5FbTbICuP/KxOZ1e7IpTo7osU7AxCXW8eJ7Hjrp+WKxuAUZ1Mo3Pi5V/egzzP34bTGIS2ladi7y2YyjZ+yVK9n4ZGINKhZ6FK7Dl1sfAJItTdjJezWw0/ruzDWctKYnJUri6NuOEWe9wj9fWvZ0489QSqBUwOXF/wwBMFmljizGPF8dh2d+exanvvAZvcunoKEkAACAASURBVCpcmblI7e1EVlvDqF8zVlbj379/Bb6UdAlHLD+5rvfjBeSCB8ZVVVXo7OyExWJBcnIy9u/fj2uvvVbo3UxpHM+jpceKRVW5cg8lbMc6TJIFxQBgsgn3BcfxPHoGw+9GERKeR9W2zVjz2iNItFugn7MIX/3PPbCUzgQAJBv1qNi3FTN2f46io/uR33IUuS1H8dktjxxveXKCQZsbsxB+YMzxvCDdKMIVLKuI1Zrjzn47OqMIioMauswoyEpSXGu7tl4bBkUKitP7unDOY7cht70BpvJZ2HLzI7CWzgAAJJkHkd9ch7zmOpQc3oPSw3uw/vHf4pP/fQq8JjbOE7fXj/2NA1i9oFARAWGoGD+Ljj6boNu0On1o67VhVklkN+1C8bOcItquabxunPXMnZi5awushWX47++ehbW4AuB5JDhsSDX0IXWwDzN2fYrZX23GBQ/egM13PjdhUoSIS7CrzocffgiXy4XLL78ct99+O6699lrwPI9LL70UBQUFQu1m2ujUBxZPiKUMhNnuRZdepMBygn0KZcDshtcnfFCfaBzA2sf/D+UHtoFJSMTOq2/Fsa99D7zm+L+tK6cA9RsuR/2Gy5Fgt+K8h3+Dmbu3wPD+n3D421eNuV2j1ROY0RvmF7Hd6QMrUx27w81g99F+nH1aqSz7j5TF4cXh1kFBtsVxPA42GXDmkhLFNNW3u3w4JtKStzN2foJ1z92LeLcTDedcjJ3X3jbqS9+dlYvOFWejc8XZOPA9Py548AaU1+zAqjcew65rfyvKmMRgsLhR32nG/MpsuYcSMp3BKUoteUOnGSW5KbLeAPcbXbLP10kyG3D+xhuR33IUfacsxae3PQZv2tDTIpUK3rQMeNMyYJw5F11L10HNsqja8V+c+9ht+OS2x8FrlfnUeKqL6qwtLS3F22+/DQC48MILh19fv3491q9fH93IpjmW5dDWa8W8GLnI8jyP2tbIF4uIlMfnh8PNIDUp+gtIJL2LJ6NiWay771fIbTiMnoUrsO1nd8FeOHFQ6E3LwGc3P4yLb/0elv/laQxWnYLehStO+r1gj9FwM48Wh7wTUKxOH6xOX0y0dwICqyDuqx8QNICwOn2BIGqG/H/fHB8I1AW/WeJ5rHrjUSz891/AJCTii1/dj5azvjnxWzRafPabh/Ct312FBZv/BmtxBY597XvCjktELTorstMSUJQTG3Wi3SJc84BAtrauzYgV8+RLigU7wsglu6MRFzx4A1IH+9F49rew/ad3gosb/3uK12iw9Vf3I8FhQ/mBbTjzj3dj66/uB6ZgO0CloyOuYG19tphZVaqj3y7bevJCZI0ZP4c+ER67zfvkH8htOIzWNedj890vThoUB7kzc7DllkfBq9VY//hvkTLYP+bvDUbQss48wbLbUtEr4BFnKPihoNEZxuqMoWrpsSpiydnmbosoXUoq936Bhf/+C8ylM/Hew3+dNCgOYpJT8d//fRqujGysfu1hlNbsEHxsYhHzfBGaw82I1vISAHoHndDLNHfIx7AYsIhTFhSKvOY6XPi7q5E62I+9P/w1vvrFvRMGxUFcXBw+ve1x6KsXYfZXm7H69Ueoi4UMKDBWMMbPCVLTKDYvw6JepMewoRDi4t5ndAqeMUs2DWD5X56BLzUdu665bdxa4fEMzFmMXVffiiSbGec+egvUzMmZ3kgCK7luYEaS6wszXGa7V7Q6xWAQJefjXovDi8Zu4Rd60XjdWPX6I2C1Wnx62+PDtfShcuQX49PbnwSn0eKcx25DVleL4GMUC+PnRHn6JLRuvfjfLYdbjaK01JxMz6BTvpXsOA6nv/wg4j0ufPabh1B7yTVhXfv9iUn47x3PwFRWhQWb/4ZT//GSiIMlY6HAWOFaeqyKX6qyvsMs6YS7EwmxSp0YjxRXv/ow4t1O1FxzM9xZkU2krL/gu2g665vIbz6CNa8+dNLPg3XGoWI5DjYF9PI027xgBOwmIhaxV0B0ehi06OTrg1vXZhTl+rL4vTeQZujDkW/+CNaSyoi2MVC9CF/+6j7Eu5244IFfIcliFHaQIhpUwJOAiQSXuRab082guVv681vOMorKL/6NvNZjaFm7AW2nXxDRNrxpGfjorudhzy/Gsreex9xP/inwKMlEKDBWOI/PL8kFLFJmuxedEmQeJmJ3+qLKurm9fsG/yMr3fYmZu7egf+4StG64LPINqVTYfv3/YXDGHMz79F+o/uy9UT/2MizsrtAf29qcjCJutDiex4BF2cEDIN7qiiMZJdjHWDiOF+XpQZq+B4vffR3O7DzUXHZdVNtqO/0C7P/+L5Bm6MN5G2+EmlF+iQIQuC4qeQltg9UDl0SL7jTrLJJmjd1ev6DdisKh8bqx+PUn4I+Lx74f/jqqbbmy87H5rhfgScvEyjefQIJ9aiwkEwsoMI4BzbrIViKSQluvTfaxcTwfVY1kv8kl6GfQul1Y88pGcBottv/0/6KePMEmJGLLrY/Dk5qO019+ADlt9aN+Hk5gJdWKd6EYiIE6YymCVovDK8vfUGDlSOH3u+qNR6FlfNjz49+AEWCxgppLf4KWtRtQ0FyH2V/+W4ARis/PcoooWRpPt4Tdg1iOD+vmPVo6g0O276SFH/4ZKYP9qLvwR3DkR79Il62oHIcuuQbxbicW/PvPAoyQhIIC4xjgcDPoNSoziLAoYCIXEF1mzypwl4albz2PtME+1F50JczlswTZpr2gBF/c8AC0jA8r33xy1M/CqTNWyr8XAOjNbtlvqibicDOitO87EePnZFkqWoxzobRmByr3foG+U5aide0GYTaqUmHPj28Cq9Vi8buvQcUqvwQHELbHupAYP4deozTL3gcJfY2diM4g7WcLSjIPYsm7r8GdmYPai68RbLv1538HroxsLPjPXylrLBEKjGNEi074CTLR8rPyfKGPJZpaUIuAq2DltDVgwX/+AmthWdSPkU+kO20tehauREndnlFZ43DKQJQUGHt8flkWGgmVlB0j5MjkC53RVDMMVr/2MDi1Gjuv/W3Yk00n4sopQNNZ30JGfzdm7PpUsO2KadAmX1eEifQOCj/ReDJS/Z3bXD5YZbrGLfv7HxHncaPuil8JumqjPzEJh799FWWNJUSBcYww272ytp8Zi9XhU0zGz2yP7HE0x/OwC3TRVrEsznjh91BzHLZf/zuwCYmCbHek2m9fCQBY9N6fhl8L9nKejJ/l4JDwkWYolNy2TYr64iA5eksL3bZvwX/+jMzeThzbcDlMldWCbhsAai++GpxajSX/ejUmWliZbPKUyExGjjkrVomWn++RaT5OdkcTqj9/H6ayKrRuuFTw7VPWWFoUGMeQHpkblp9IyExrtHwMG1H22uFiBKuzPOXjt5DXegzN676B3sWrBNnmiXoWr4axshozd32CNH3P8OuhLOVrcShvQpDerKybvZGknBQndSbfz3KC1n0mG/U47R8vwZ2ehQOX/1yw7Y5kLyxD2+kXIKerGeX7vxJlH0LyMSxsCrsRdXkYWSZ72iTKGOsGZSij4Hms/NNjUHMc9lz5G1GWMaessbQoMI4hUk5gCIWUdWOhiKSmT6hHfGqGwZJ/vQJvcip2X3WzINsck0qF2ouuhJrjRl0gQ3nsL/eKd2Ox2L2ytvobj9cX2Y1WpKwOr6TdQoSe8Ldy05OI87ix74e/hi81XbDtnujQJdcCAJb865WYyBorYQGXkbr08kxMY/yc6IuemGweOGUo7Ss7uB2lh/ege8ka6E49XbT9DGeNN/+NssYio8A4htgV0H92JLlqucZjsof/JSTUZ6jc+zmSrSY0rf82PBniLvPbtuZ8OHILMeezd5FgD9SeD5jdk7asU+IseY7nMaDArLHUWTWW4yWtt7bYhdtXdnsDZm37CAOz5qNx/UWCbXcs5vJZ6Fh+Fgqa61B8ZJ+o+xKCXK34xiJV7+LxiJ1IkWPSnYr1Y+WbT4BTq7Hnyt+Iuq/hrLHLgQX//ouo+5ruKDCOIYyfg1ui3pOTEfpRrBDkzBjPG2rAXn9+FD2LQ8Rr41B34Y8Q5/XglI/fBhDoZ9zWa5vwfUpYCnosSlwFT8r64iApyymEPBfmbnkHAFBz2fVRtyYMxaFLg1njV0XfV7SUlDE22jyyLlUt5o0fx/PolaGMYs5n7yFL14bGcy4WrAPRRI5njanWWEwUGMcYpWSNbU6f4upVHW4m7NXUhLhYZ/R2ovjIPvTOXxbxKl/hajjnEnhT0jB/89+g8Qa+fFt6rON+fsbPwuVRxk3ViQYsymvbJkemT8qMvlD70njdmPXVZjiz89B9mniPkUcyzF4I3aJAd5a8pjpJ9hmpUCfGSkHuhaLEnIA3aPXA45P4+sbzOOXjt8FptKLV1Z+IssbSoMA4xiglS6vENls8z4fVts3l8QtS3zr3038BkCZbHORPSsaxC76LJJsZ1Vs/BBCY7NPSM3bW2KygDiIn8vpYRdU/+1lOlvNbqoy+l2EFyxzO2PUZElwONJ19kSiTjsZz6NKfAACWvENZ41DJvUy1TcS/caMMHZty2huQ09mEzmXr4M7KlWy/lDUWHwXGMcamkIyxkvrhjhROOYUQGQyNz4vqz9+HOz0LHSvXR729cBz9+vfBauOw8IM3hxc9aOu1wjtGsK/E+uKRlNS2zWyXdiJckMPFRLW0eaiEPBfmfvYuAKBx/bcF22Yo+uYvg37OIlTu24qszmZJ9x0uJdQZczwPt8xPjFxeYRIRY3HK8NnmfP4+AKDpbHHr6k9EWWPxUWAcY5SSMVZShm+kcGpDhZgMUrl7CxIdVjStvwhcXHzU2wuHOysXTWddiIz+blTs/QJAoA69eYzFYJR6IxOkpDpjOeqLgUDwIsW/k1D7yOjtRNGxA+hZuBL2wlJBthkylQqHLomNrLESMsYuj18RpW9iPYmRulxFzfhQte0juDJzBCkh2rv9Y9x703fws+8sxb03fQd7t3884e8Hs8bzN/8VGp+yr+2xiALjGKOEejWW5RRT63yicNpQCXGRPiU46e484Zu6h6LuWz8Gr1Jh8ftvDLevau+1nTRJU+kZY4vDJ8nyy6GQcylfIbtFjEeoVfbmDGWLG869WJDthatr6RkwVlRj5s5PkNbfLcsYQuH0MLJPmpZz0t1IYgXGUn++in1bkeiwonndN6IuIdq7/WO88sTt6OlqBsex6OlqxitP3D5hcOxPTELzmd9EgsuBspodUe2fnIwC4xjjY1jZL7IWiXuuhoPxcyE31Y/2Ip3V1YLC+hroFq+CvbAsqm1FylpSic7lZyG/+QgKjx0EEGj91dR9PGvs9bFwKaSbyXh4nldE1jhQpy5fhk+KjLEQtcwqP4PZX3wAT2qG5CVExwehwuFv/RhqjsPsoTp7pZI7a+x0K+PvX4yFPrw+Foxf2iWuq4NlFAK0J/xonO4qH7/z2oTva1n3dQBA1bbNUY+BjEaBcQyyy5w1NsuYUQuFIYSJGD6GhSvKLMPxSXffiWo70aq9KLBM9IL/HK8369Tbh7MoSm3TdiIl9DO2OX2Sf8mOJFQ2dzwuj1+QzHzFgW1ItprQfNY3JS8hGqlj5Xr44xNRteO/il7wY1DmOuOpnDGW+ilqslGP0tpdGJi9AJayqqi316drG/P13nFeDzJVzoG5dCbK93+FOJeyVsWNdRQYxyC5yxjkqsEMVSj9LKO9QGu8bsze+iFcmbnoXLYuqm1Fa2DuEpjKqlB2cPvwBZLjeDR2BbLGSi+jCFJC2zajzDd9Tg8z5uRJoQh1kzRn6Kaw8Rx5yiiC/EnJ6Fp6BjJ7O5Hd0SjrWCYi9zVTjhXhxmJ3+QR/2ih10D/7y/9AzXGCTborKp055uvF47w+TKVC6xlfg5bxoXLP54KMhQRQYByD5J6AJ/dFfjJmu3fScpNoA+OZOz5BgsuBhnMvBq+Ni2pbQmhfcx60jA/lB74afk034IDd5VP8xLsgH8PCI3OdsRLObTH/vYS4SUoZ7EfZoZ3QVy+SZFGDybSu3QAAqNr+X5lHMj67S9wbnsnI0bVhLBzHC57YkTRjzPOo/uJ9+OMT0Lr2AkE2+bWhBWtOtOGSayZ9b8vQuT+LyikERYFxDLLL2EOY43jFLQV9Ij6EVZCi7Ugx75N/glepZM+YBbWtPg8AMHPnp8OvcTyPhi6LYjuIjEXu+nkltNYSM8MvRKlG9efvQ8Xzijn3u089Hb6kFFTt+Fix5RQ8z8va7UQppRSA8OUUUgb9+Y21yOztRMeKs+FLSRdkmyvWbsBPbtqI0opqqDValFZU4yc3bcSKoaB3IvbCMuhnL0Rx3V4kmQcFGQ8BpOvITgQjZ42x3eUDq9CJdyP1DjpRVZIx7s9tUfQwzu5oREFzHbqWngFHfnHE2xGSpawKprIqlNbsQJzLASY5FQDQY4it2jM5Jwm6FNA9ABCvzpjn+ah7d6tYFnM+ew++xGS0ni5MxixabEIiOpefhdlf/Qf5zXUYqF4k95DGZLR6UJSTIvl+3V6/oiZLCx0YS5kxnvOFcJPuRlqxdkNIgfBYWtd9HQXNdZi58xMc/cYPBB3XdEUZ4xgUeOQszxd4rGQfTROUU7AcF1U5yrzhFm3SrXQXirY1559UThFr5AxM5a4vDhLrb8zuZqKeWFhctwdpg31oW3sB/EnJAo0sesHH2jN3KLecQq4JeEqpLw4Son/8SFJ9Pq3HjZk7PoEjtxC9C1ZIss9QtK05H5xajaptH8k9lCmDAuMYJVedcazUq/I8j17j2OUUNicTcbN7NePDrG0fwZFTIEhjdyG1rxkqp9jxicwjiZy8gbH8ZRQA4PH54RLh8bAQJRpztwz1Lj7nkqi3JaSeRavhSU3HzB2fDK8CqTQ2h0+SlQ1PpJT64iAhVhwNcnv9kh3Tyt2fId7tRNNZF4LXaCTZZyjcmTnoXbgSBc11iu7nHUsoMI5RcgXGYjVoF0OvYbzAOPLPUHxkP+JdDrSvPi/qxu5Cs5TOhKl8FkoP7YzZ9j1yllIoYeJdkBgt9qK9qU20mlCx7wuYymfBMHuBQKMSBhcXh45V5yDFbEBBQ43cwxkTJ1OdsdIyxoyfi7pVZpCUtdPDZRRnf0uyfYaq5YyvAQBmTbJiHgkNBcYxSo6WbRzPx1RgPF45RTQZi/L9WwEAHSvOingbYmpbPdSdYv+Xcg8lIm6vPNk+xs/K3u1lJDGezERbuzxj1xZo/H40rr8IUKkEGpVwWk9XfncKsftUj8WhoIl3QUJ9j0i1cEnqQA+Kj+xD3ylLZVvMaSKBft4JqPpqs2InoMYSCoxjlBxf4nYXA1aGR4GRGq+cIuIaN55Hxb4v4UnNgH7ukihHJ47hcooR3SliiVylFBaHT/YeyiMJ3ZmC4/ioVx0L3mx1rDxHiCEJrm/+UrgysjFj9xaoWGWVDwTJceOnlFXvRhKqzliqoL96aGXFRgVmiwGASU5F19J1yOppR067cvt5xwoKjGOUHBljpbdpG8uJbdv4KLLeuW31SDXq0b30DMWVUQTFejmFj5F+eVdA/jZxJ7I4vIIG6lZndN1ktB43io/sg7F8tmI6sZyI12jRvvo8JNnMKK7bK/dwxuSWeNI0z/OClS0ISbiMsTSfbeaOT+CPT0T7UFtMJQqWU9AS0dGjwDhGeRlWkKVdwxErHSlGMtm8ozp4OD2RT9ao2LsVANCx/CwBRiae4e4UMVpOIccXudwLi5yI8XOCtqGKtjSjpHYXtIwPXTKv8jiZ4cU+FNqdwiPxDZjbyyqyvWYsBcZp+h5k6drQs3CFojqxnKj7tLXwJqeiavvHABc7T3aViALjGCZ11jgWM8aBxT5cw/8dzWeo2L8VrDYOPUtWCzE00Yy12EcskWMxArnaH05EyHrUaLdVsT/QArBr+ZlCDEc0+jmL4cgpQOWez6FmlHcj75b4BkxJC3uM5PIwYPzRHQue5+GQoONG2YFtAIDupWeIvq9ocHHxaF99HlJNAyisPyj3cGIaBcYxTMqFPqIpQZDbyHKKSD9D6kAPcjqa0LNwBZgk6Zv0h8NaOgOm8lkoG1rsI9a4ZKiJVFrGGBB2Al5U2+I4lB3cBldGNgZmKasbxUnUarStOR8JTjtKD+2SezQn8TGspC3blBoYA9HXGXt8rCRzXsoPBgLjLoUHxgDQcsbXAQCzqKdxVCgwjmFSZoztbkaWHpxCMNo8wxnBSAPjin2BsoTOFWcLNi4xta05Hxo/MzzuWCJHeyml1RgDwq3oxfN8VNvKazmKZIsxkDFTK/8rI7jYR9UOZbaukvImTIkT74KiTbRIcZ3QetwoOrIPxopqOHMLRd9ftPpPOQ3O7DzM2PUp1Ixyb4qUTvlXOTIuKTtTCL1akZR4nkefMVBOEennqNi3FQAUX2MZFCynmLEr9sop5CmlUF7GWKhFPjw+NqolgSuGatW7lim7jCJosGo+bAWlqNi3FRqvW+7hnETKmzBFZ4yjDIyl6EhRXLcnUFu/dK3o+xociAPji64NIq/RoH3VuUh02JDfVCvQyKYfCoxjmJSBcayseDeeHoMTHp8/olrSeIcNRUcPYGDWfLiy80UYnfCspTNgLJ8dk+UUUk++43le8omsoXB7/YJ0pog2ECvf/xVYbRx0i1ZFPRZJqFRoPf0CxHncKD+4Xe7RnETajPHUDYylyIaXHwiWUYibEDEb43DXr+fib6+WRL0t3ZI1AICymp1Rb2u6osA4hnl8fngZaS6ycrSHE5LR5sGAObLsUVnNdqg5Fp0K70ZxovY158VkOYXUS9h6fGzES4SLieV4Qf6+o8k8pw70IqezCb0Kn5F/ovbV5wIIBPVKI1XGWKrJaZGyu3xRPckQsmvLmHgeZQe2wZOWCcPshaLuqr42FX5Gjb3bMuFxRxeW9c1fBn9cPEoP7RBodNMPBcYxTqqAVYmPmsPB8zwauy0RvTfYpi1W6ouDjnen+ETmkYRHqExpqJR8bgtRThHNMtvlBwKBZWeMlBAFGSvnwJ2ehZLa3YpbCUyqDihSTU6LFMfxUZVDiF0mkt3RiFTTALpPPR28RiPqvhqPpgIAfF4NavZkRLUtf2IS+k85DbntjUgyG4QY3rRDgXGMk6qcQsnBQ6gieayoZhiU1eyAraAU5rIqEUYlHmvpDJhLZ6Lk8B5ofLFTCsNxvKTnmxJbtQUJkV2MKjAOtmkT+VGy4NRq6JasRorZgKyuFrlHM4pUq98puYwiKNIx8jwv+pOl42UU4naj4Hmg8Ugq4hMC58XuL7Oi3qZuyekAoMjOLLGAAuMYJ0VgzHIcfBKVbChN0dF9iHc70bn8TEAV3cQIOeiWrIbW50FBY2xNxJBygpKSb/qiCWqDIj2WcW5nYLW7ymo484qiHofUehYH+o2X1iorOJBq9TupS5IiEWmdsNsrfja8/MA2cGrNcM2uWAb18TANxmP+EjtmznGioS4VZmN0K6t2nxoYcynVGUeEAuMYJ0UphRInJkkl2I0i1uqLg3RDwUFJ7W6ZRxIeIQLCUEm9Glk4BMkYRxggldTuhsbPoDNGulGcKHjulx5SVnDgkShjLEXXhmhFOkaxyygSrSbkN9dBP3cJfKnpou4rWEYxZ4EDq9aZwfMq7N0WXdbYUjoTjtxClNbugoqdvt/fkaLAOMZJkTFWckZNVDyPin1fwpOajv55p8o9moj0n7IUrDYOJQrLmk2GMsYBQtQYR3osy4fbtMVYGcUQd1YujJXVKDx2UFFt27xMdO3zQjWVSynEnnhXWrMTKp6XpE1b45HAglFzFjix7HQLNFou+nIKlQrdS9Yg0WFFbusxAUY5vVBgHOM8Pn/US2tOvg/lBg5iymlvQKpRj+7TzgCvie7Rllz8iUnQz1mM3PYGJNjMcg8nZFIGxlI92o5EtJlzb4QrralYFuUHtsGVmQtD1fyoxiAn3eLV0DI+FB2rkXsow3iel6SuPTZKKZSZMQ5OOu0+Tfz64qajqUhN96O4zIPUNBYLT7OjpysJ3R2JUW1bd2qgzriMulOEjQLjKcDmFPciIVVLOKWp2PsFAKBzxVnyDiRKuiWroeJ5lNTtlXsoIRNqcYtQKPnGL9obhEiPY17LESTZzIGJRzGw2t14gvWhiiunkOCci4WMsdvHguXCv3ETM2Os8jMoPbQT9vxi0SdcG/rjYTbGo3q+Y3gKy6ozAwmMaLPGPQtXgFNrqM44ArF7xSPD7G5x64yVXIMppsp9WwMLG4g8+UJsPUMLM8TSDGUqpQhg/NFNfJ2uZRRB+rlL4I9PVFwpkdjnt8fnj+hJgdR4no9oAp6Yi3sUNNYiweVA12lniD7hOlhfPHfB8UWYFi61ITnVj73bssBFcWliUtKgn7MYeS1HkGC3RjvUaYUC4ylA7DpjzzTMGKcY9cjpCCxswCSlyD2cqBhnzIUnNQMlh5XX03U8Uk2+87PK77gSTRAV6XGs2P8V/HHxwzdVsYqNT0Dv/KXI7m5FilEv93CGuUW+GZNiVTihhFsWwfO8qKtjDrcolOCmsPFIIDCunn88MI6L47FsjQVWcxzq61Kj2r5uyWqoOS5w7Scho8B4ChB7IoKSM2piKR4qO9Atju3AAAB4jQY9i1YidbAfGT0dcg8nJIyfA+MXP+MVC+d2NDcJkQTVqQM9yO5qCax2l5gU8b6VIvjEp0RBT0zEfgondg2ukMIN4t1eP1gRJy+WH9wOJiERffOXibYP4Hh9cVoGg6LS0X3mhSqnCNYZK62USOkoMJ4CxG6nNh3btRUd2QcA6F24QuaRCKNnKMAvjaHMgRTlFEpe3CMomsA4khrj8v1DCxvEaJu2E/UsUV4/Y/EzxrETGIeb2BFzmeu0fh2ydG3oXbgSbHyCaPsBgIG+eFhMcZgz33lSxUbVHBdyC7yo2ZMR1RLRgzPmwp2eFagzjpGnhUpAgfEUIHbWKxayaoLieRTX7YMnLROm8tlyj0YQwUfilF5/fwAAIABJREFUsdTPWJLAWKKestFwRxEIRBJUl9TtAXB8kQAl2bv9Y9x703fws+8sxb03fQd7t3886XssJTPgyC1ESe1uxfR0FfvcjoWOFEHhZrfFDPrLD0qz2h1wvIxizoj64iCVKpA1jnqJaLUauiVrkGI2ILuzOfLtTDMUGE8BPoYFL9LdIMfz064rRZpeh7TBPvTOXxbTM/JHcuQXw1JcgaIj+6Dyx0Y2SYo641i46ZO0lILjUHjsAOz5xXDkl0S8XzHs3f4xXnnidvR0NYPjWPR0NeOVJ26fPDhWqaBbvBqJDity2uulGewkxC6liIXFPYLCDXTFDIzLhpaB7pY5MAaAVeuGyim+iq6cYngVPGrbFrKp8a0/zXE8D59I9Zhen3hBt1IVD5dRLJd5JMLqWbQK8R4XCprq5B5KSKiUIiDSwDiSjhbZnU1IdNgCN4UK89G/Xh3z9Y/feW3S9+qGyinKFFJn7BExmQHEVilFuC3bxJpTo2Z8KDp2EMby2XDmFIiyjyCeD3SkSM9kUFDsHfN38ot8gSWiD0e3RHTP4tXgVSqUUdu2kFFgPEWIVQc83bLFwPGJd70LpkZ9cVAwOFBa66rxSBEYi13rKYRISykiOX7Bm8K+Bcq7KezTtY35eu84r4/6nYUrwanVipmExHG8aE8rvD5WkomrQgm3ZZtYZSJ5LUeh9XnQt0D8m8L+ngTYLHGYu8AxYUc4IZaI9mRkY3DmPBQ01CDO7Yx4O9MJBcZThFgt1WLhUbOgeB7FR/bBlZkLa0ml3KMRVN/8ZeDUmpipM5aklCIGenRHunpdJMev+Mh+AECvAgPjotKZY75ePM7rI3nTMmComo/8xsPQOsd+dC01sa6tsdSRIijUMXM8L9rnKz4aOPeluClsOnpym7axLD/dArWax6G9UdQZA+g+9XRo/P7hSeVkYhQYTxE+kS6ysfCoWUiZPe1IthgDZRQiN3eXGpOcioHqhchrPYp4h03u4UwqmklnoYqVG79IgtxwM8YqlkXhsQOwFpbBmVsY9v7E9rVLrx3z9Q2XXBPS+wM9XVkUKuTGUKxrq9jtO8UQ6pjdXj84kVq1FQ3dFPadcpoo2x9psvrioJQ0FnmFXvT3RNchQzdUZ1xWQ3XGoaDAeIoQK2M83Vq1TdUyiiDd4kDD9+IYWB7a42PBiVzfHis3fpHcJITbqi2noxEJLofo/VsjtWLtBvzkpo0oraiGWqNFaUU1fnLTRqxYuyGk9wfbthUd2C7mMEPmFqkjSix1pAgKtZRCzPrigsZaGMtnw5uWKco+ggL1xSnIzGaQXzT5qrUFxV44HVo47JqI9zkweyG8yamBwHiazRmKROQV3URRxApgY6EGU0jFdUMT7xT4KFkIPYtXYdlbz6P08G50rD5X7uFMiON5eLwskhPFuUx5GVbUhQKEFEnGONz3DPfulqDGMlIr1m4IORA+UTA4KDy4EwgtySwqt0g3ZbE08S4o1PIIsVb0k7K+uE+XALs1DivXmUN6KFlQFJicp+9NQOocV0T75DVa9CxahZm7tyCjrwvW4oqItjNdUMZ4ihBrkty0yhhzHIqO7oc9rwj2AmW1qhKKYdZ8eJNTFbUK2ETEnIAXK2UUgDSlFEqeeCcEXqNF78KVSOvrRnpfl9zDEa2+PRZrjEPNBIuVMR6uL5bgaclYy0BPJH+oa8VAX3TlFL2LVgIACoc+KxkfBcZThFgBbKw8ahZCoFWVNbDa3RSrLw4KBAcrkD7Qg7T+brmHMylRA+MYmHgXJHYphYr1o7C+BpbiCriy88PeV6xQUmcWsUopIlntUG4eX2gTTI02jyj7DwaLktQXHw2tvjhoZMY4GsHPVnTsYFTbmQ4oMJ4iqMY4eiXBMor5UzNjFhRcBa9UIZOQJiJmZ4qpnDFmOS6sp0i5bfWIdzsVW18slJ7FQ4HxYflr7MUopeA48Xrai4nn+UkDei/DwuacvCY3XGqGQWHDUH1xenSLaUyG4wIdKbJyfMgrCO2zBPscRxsYW0pnwp2ehUIKjCdFgfEUIUYAy/O8aAG3EgVrLPum2MIeJ+pZHFweWv6s2WTELaWIncxauMfB7Q1vAQklt2kTkj2/GM7cQhTWH5R9EpIYN2ZekRcOEdNkZRKDFrcony2v9YiE9cWJcNi0mDNJ/+KRMrP9iE9goY+ylAIqFfrnnYq0wT6kDvRGt60pjgLjKUKMZaF9fk601jhKo2L9KDp2AJbiCtFXPZKbrbAMtvwSFNfthYpV9o2PmIGxWI+yxeDxsWH9LbrCrDMdvimc4hljqFQwLFiKJJsZGT0dsg6FZcPL6ocilhdkmqw22mARp4zieJu2paJsfyRdRyIAYMbs0CfRqVSBVfAG+uKjvpfrHyqnoKzxxCgwniI4noePEfYRWiw9ao5WbmvgUfJUbdM2ikqFvgXLkeByIKurWe7RTIgyxgE8z4dVThFO0K/yMyhsqIG5ZAbcWbmRDC+mDCwIBECF9fIHB0JfY2M6MJ6k44TB6hZlv0VD9cX9EtQXB7O+4y0DPZ6CIi98Xg0spug69ASDfyWc+0o2rQNjlc2K0jeeQ5zTLvdQBCF02YM3hgKHaB2fkT/FM2ZD+uctAQAU1dfIPJKJUY3xceHcJISTMc5rPYY4j3vanPuGoc+phHNf6AmgsTwnZKJSCpeHEaUNXbC+2FQ+C56MbMG3f6JgZ4n8ojADY4HqjE0V1fAlpdAEvElM68A4bs8uVD77EKo++ofcQxGE0NmCWAscolF8JLiwx9SusQzqnxfIjhQoIDiYCOPnwPhpuXMgvG4DrjAyxsVHpnbv7hNZy6vgSc1QRNZM6Al4MZ0xnuBmTqwyiuH6YolKiAb6EqDVcsjOCS/IHw6Mo6wz5jUa6OcuQWZvB5Isxqi2NZVN68DYP38hACDvqPwXSCEInS2ItcAhUmrGh8L6QzCWz5Yka6AEtsIyuDJzUFhfI/skpMmEE+SFiuP4mAsiwsoYe0P/4p029cVBanVgEtJAL1KMelmHInSde6yd0yNN1LLNYBGrjOIAAKBXgnOf54GBvnjkFfqgDnMRu2CGeSDKjDFwvG2bEm4MlWpaB8ZccQk8hSXIOyb/DGUhUGAcmfymOslmJSvG0AzlFLMBafoeuUczITHqjD2+2Ju9L0aN8fCj5LIqRd8Ufr45F7++YgHe+XMhXM7ov7b6550KQP5JSMKXUsReq7YgnufHXM6a5/kpUV/ssGngcmrDLqMAhCulAGgCXiimdWAMALYly5BoNSOjt1PuoUSNZjhHpvjo0KPkhdNg4t0I/XOHgoMGZZdTiBMYx179fKilFIGltEP73byWYKsqZZdR7PkqEx6XBh+/W4A7/mce/vteHnzeyBfhCZYSyZ01E76UIvbO65HGqiO2uRhRaqfVDIOChkOS3RQG64sLIgiMU9NYpKT6o2/ZBsBQNR/++AQUHTsQ9bamqogCY47jcNddd+Hyyy/HFVdcgc7O0UHl66+/jm984xu44oorcMUVV6CtrU2QwYrBtiTwhVCo8FrLUAid4Y2llcGiUVy3D5xajb754rfrUZL+GHmkJsYEPHcMPg0J9QbB4/WDCzEbHgv1xR63Gp1tySif6cIlV/QCPPCvTcW481dzsX1LNiLpODg4cy6YhETZr/vCl1LEbsYYGLvOeFCkMorc1qOI80pXX6yPcOJdUEGxFwZ9QkTn+0hcXDwGZi9Edmcz4h226DY2RUUUGG/ZsgU+nw9vvfUWbr75ZmzcuHHUz48ePYqHHnoImzZtwqZNmzBz5kxBBiuGYGBcoPCsWSiEzhZMh8U9NF438ptqYZwxF76UdLmHIylTxWz4EpNRUH9I7qFMKJLlkCcTixljt88fUvlHODcSw91YFHxT2NaUDI5VYd4iBzZ824A/PNeADd8egMOuxZvPl+G+m6tht4ZXtMlr4zBQvQjZXS1IsFtEGvnkhD4PY7krBTB2Zwqx6ouLg8tAS1RCF2lHiqCCYi84VgXjQHzUY+k75TSoeB6FDcq+9sslosD4wIEDOOOMMwAAS5YswZEjR0b9/OjRo3jppZfw/e9/Hy+++GL0oxSRa2Y1fClpsmcOhCB0tmA61BgXNB6Gxu+XZPKF0vAaLQbmLEZWTzsSrSa5hzMusWqMYw3H8SGNO9SSC43Pi/ymwzBWVMOblhnt8ETTfCwFADD7FAcAICWVxSVX9OH+Z+tx2moLeruTsH9n+OMPPjEpkDE4YPzcuBPOwsX/P3vnHR7XWabve/qMRqM+I1m9uztxnIKd5jRwaGlAQvgBS1vK0kJnYel1lyVLZyEbAqElkAIJaaQ6xYkTO26y1ZtVZzTSSNPbOb8/RiPJtsqUMzNnpLmvi+siknXmk/TpzHPe73mfVxQJZHkx4/QsY0EUsc+kaLBHW/oGe8ACK0VlYmOto4JaEp9x1EqUs1MsSkJp0S6Xi/z8/Ln/VqlUhEIh1OrI5d7whjdw8803k5+fz0c/+lGeeuopLrvssmWvWVych1odZ6umBIzN+JnYdDaVLz9LacCJL4sD7tUaNWazSZJrBYJh9HrNkp83GpP/45QDNb2RhzrH9gtS+j3J9ec1ue1cqg/vo66/jaFdV2Z6OXMs/HkpJdzXUbSjTtn+TpZDb9RhLs474+MLfz7jM/6YvjdLz2HUAT+2FO/9ZOntKEChENl2TuiUdRqNcOO/THJwXxFD/SaMRlfM1zQadTi2XwB3/ZKariPYd78uFUuPibx8PYX5yf/8fYEQhrzkq4mLka79oVArT9nLtikvWp0GrcQvHxlqcxhHXTOqynUYpb38oj8v27gerU6gslqJUhn/N1TbEHmAmrIbMRoTE9dRXOech6BSU9VxSBZ/+1Lf35MlIWGcn5+P2+2e+29BEOZEsSiKvPvd78Zkinyjl156KcePH19RGE9NxT4iUUqmHR7Cm3dQ+fKzmA7ux/6aKzKyDinwegJYrTMoYh3CvgxOTwC3e/EjH6NRt+Tnso3io5En5sG6jfhS9D3J+ec12LSNbUDRq/vpOOviTC8HOPPn5fUEGLfOoJRgX0exTrhk+ztZjuGRaRSn5TqbzSZstvkhRSPjMzF9b8WvvADA4PpzZPuzCAYVdLXrqa73gcLLgrcdAApL/OjzwnQej/1vLLq/Bmo3IKjUlB55OaPf/9DoNIEiQ9LXmVnmnp0M6bx/eTwBRsemUasih9kdg1MpeW1Lx2HUfi/DG3dIfv3Ffl6iCGPDGiwVfrzexF6vqCRy/xsaUEmwZhW2xo2Yu9rw2x2E9Mnvv2RYeP9KJ0sJ8oSsFOeccw579+4F4NChQ7S2ts59zuVy8cY3vhG3240oirz00kts2bIlkZdJG7bN0Sak7LZTSDkWOhuPmuNGECjvPIKjsk7WUVWpxNq6BUGllnUyRSRlIRdFCLH5h2O1UlTMesujx6pypL87j1BQScvGxavBSiXUN3kYH9HjdsV34hjWGSLioPcEal9qfKyxIFWTcyBL9/RCTo9ss6Ysv3jWRpEmb/20Q43fp0rYXwxgrohUiaWwUkDESqQMh7B0HpHkequJhITxVVddhVar5aabbuK73/0uX/ziF3nggQe46667MJlM3HLLLbzrXe/i5ptvprm5mUsvvVTqdUvKZOtWwmr1qmjAk6phLtubOGKheKgXrcfF+PqzMr2UjBEVB2W97RkVByshdXRgKnzL6SAW0RvL96YIhzB3HWWquhG/qVCKpaWEqL+4dbN7yX/T0BI5bezvjr/qNbZxe0QcdB1NbIESINVeXC3N0tHItlBYYMqZmkp15bGoME5T491Ico13AHqDQFFJUEJhHHkoyPmMzyQhK4VSqeQb3/jGKR9ramqa+//XXnst1157bXIrSyNhnZ6Jxk2Yu9tQ+7wZP1ZIBn8gBMbkfWbZWlGLh2jTzVoWxhARB+VdR7F0HZVtlrOUwljKhqd0s5KIEkUxJqFVPNiN1uehV+Z7f67xbomKMUBDa0QY93Xlsfns2H3GEKmanfX331Fx4mDG9r5U0YGrJXc+mkxhn/EhCNIP4VGEgpR3HGKqujFtJ4XziRTJeYMt6/x0tuUT8CvQ6pL72YxtOBtRoWBdbtDHGaz5AR9RxjacjVIIZ7RyIAVSJVP4sjwoPhbKO2aF8YazM7ySzDI+OwWsXMZWIim77bMxqi3KSlYKfzBMOAYxUd5xGJD3Q2E4DN3tRtZV+zAVLv37b2yJCuP4W6jGo0Nujmdu7+esFKcSzTJOVUxb6UAXGp93bvphOhhPYrjHQqIT8KxjyVeNA/kFTNa1YOk6ijKYnGBfbeSE8Sxz4iDLc/2kskBI7emUI+Xth/EbTTiqGjK9lIwyNvtgIOdBH1JWw7JxuEeUlYRxrP7ibBDGJ/sM+H2quZi2pSgoClFqDtDXlUe8U779pkIma5uxdB5GETozQzcdSLUfV4+VIrKHbY7UxLRZOiKe2nTufeto5BQ3GSsFLBDGEkzAg0h/gTrgx9zTJsn1Vgs5YTxL9I8k2xvwpKr0rpZjuaUwOOwUjp2M/N6Va/vPwF9QzFR1I+WdR1CE5VlNlXI/ZvNEx3BYWPbhN1a/ann7YXz5hUxX1km1NMnpPB6JBG3ZtLS/OEpDiwfXjJqJ8fhtZGMbt6Px+yjrbY/7a6VAqv24Wu7ZLm8QfzDMjDs1VczoSaE1jcJ4fFSH3hCmoCi533W5hFnGEBn0AVCRs1OcwtpWBAvwFZYwVdWApeOwbMVBLEhWMc7iqlosWLKgYpZOxjZuR+PzUtrXkemlLIpUaSuQ/Xt7uapxLKkVhqkJCqzDWNdvk/VD4by/OBZhHPk3fV1nZjyvxNywgwydmETsL8nvbyn/RjKJLxBifNIT05THRCjvPILPVMT0utqUXP90BAFsYzos6/wkmzg5N+RDwooxkPMZn4Z874oZYHzD2Wh9HkoGujO9lISRqmqQzT7MWJhvvFvb/uIoY1GvpUyTWSStGGf53l5WGMdgpSjvTP9RcrwIAnSdMFJm8VNStrLFYWEDXrxEJ+Bl8rRQioe1bH/gW0j/WGpybQ1TNkzWEcZbt5G0So0Rx6SGYECZtI0CwFweQKEUJasYe4vLcFTWUd5+CEV49eyfZMkJ4wXMeS1lKg5iQYqKcSgsEAytjurDUpR3HEZQqrC1yDtjO12Mbcp8E9JySNt8l91vAN5lxG8sVgpLFqSxjJzU43GpY7JRANQ2eFGqxISEsbu0HKelMiKMJajcJoIUkW2rxUoBMJmiMdDls/5i6/ptKbn+YkRFbHmSiRQAao1ImSWAdUS6CYdjm85B63VTMtAp2TWznZwwXkA2dOevhBQNGKvpBrsYqoAfc89x7A3rszqaT0pc5kpcJZZIlneKjjCTQaq0Fch+YZyslWLuobBZvg+F8/nFscWvaXUi1XVeBvsMhILxVwLHNp6D3jVN8VBv3F8rBck2O4fCAuEsjSBMJ3MWutZ0Nt4ln2G8kPJ1fpwzGjxuaeTbnJUoZ6eYIyeMFzBTUYOnqDRSMZahOIiFQFBASHLtqz2RorT3BKpQUNYVs7SjUDC28RzypicpGB3M9GrOQMqKcbYO94ji8S9tLVjpe1MGA5GHwvpWWT8UdsXReBelocVDKKhkaEAf9+uNZthO4U3S3pPtD3vpYv6hcHPaXlOqRIooUidTjLdGqueWzuyOqpWSnDBeiELB+PqzMU7ayLeNZHo1CSGKYtIiYrXE/izFXFTVGs8vPp3xjdHYNvmdmITC0gzlEEUx66c6Ts34OdBhnfvfC0dGONBh5ZV264oWqLLZh8J0duTHiyhC53EjRSVBzOWxHz9HJ+D1dibRgJehKWDeJIsRUj44rlaUwSBlvSeYrGshZIh/jyTKXIZxpTTC2CJxMsXMulp8piLKu3KjoaPkhPFpjM2Jg+zNM072jT/bm5NWoiILPJaZIBp4L1ePvRRd9/5gOOkTlUzjD4Y5aXXN/a9/dIaTVhdDtpVtB9mQX2wd1TLj0NCy0RVXf1RDS+INeNOVdXgLiucaE9NNsvfc1W5/k4LSvnbUwUDa9751VEdefoh8kzS/o6jAlkoYo1Bgbd2KyTqCYWpCmmtmOTlhfBpyFwexkOxNclUfy4kilo7DuMoqcJdVZHo1smKqphl/Xr5svWZSvPknW5nLdsrb5S+M48kvXkh5pR9DXjihCXgoFFhbMicOki1m5ITxysxNOk1j4104DLZxrWQ2CpA+yxjAOmenyFWNISeMz8Bev56gTp/dDXjJ3mRXsTAuGDtJ3vSkrIVBphBVKsbXn0Xh2ElZVg4CISkirVb3aciyiCLlHYdxl5hxmddlejVLMtd4t8LEu9NRKqG+xYN1VIfbqYr7da2tWwGwdKXfa5msfW0137OlYi6RIo2Nd5M2LeGQUpJEiijFZUHUGkGSsdBRxltm937OZwzkhPEZiGoNtpatlJzsQeuayfRyEiL5ivHqFQ/ZcJScSaK+60yIg5WQ4s1/VZ+GrEC+bYQ8x0Rk76cpwzURuo7nYzSFqKiOv8rWOGun6O+O305hzWATUq5inHosnUfwFJXiLK9K22tKnUgBkQdAS4Wf8RGdZBkBtpYtiAoFlpzPGMgJ40WJDjuIHr1kG8neJFdz9SHXeLc8VhlXDgISZGuv5Sal6N5PZ8UsXuxWDXabltZNroSG8tU3J+4ztjVvjoiDDBwnJ5sdL2Wc4WrEODFGvn088vCTxofC8dlEinIJhTFEbEM+r4oZh1qS6wXz8pmqacLc3ZbVk3+lIieMFyHbG/CSb75bveKhvP0QQZ0ee11LppciSzIpDlZCiqrYWq6szfmLN8hXGHedmB0DHae/OEp0Al5vAsJ4Thz0ZEYcJLM3V/MpnxTMnxSmz18MqakYw/ywEGl9xlvR+H1ZPflXKnLCeBGi09DkeJwcC8kIW0EQJanMyRGte4bikz3YWrYiqjWZXo4sCRpNOKoaZsWBvESkFNXetVxZK+84TEijZaJhQ6aXsiSJ5BcvpKAwRKnFT19XXkLHzNaWrWh8XopP9iT0+smQjLiVIrFlNTM32GN9ek8Kx1MkjC3RZAqJsoxhfuiJHIsi6SYnjBchYCxgqrqRsm75iYNYSEZA+AJhxCyPs1oKS+dRFKKY8xevgLV1W8bEwXJIUjFexachy6H2eigZ6GSiaROCRrpxslLT05mHTh+mps6b8DUaWjy4nWps4/F/n3MNeFnmM17LJyGxUN55BEGlZqJxY1pf1zqqw1QQJM8o7YOL1EM+YGHzaU4Y54TxElhbtqD1eSjK0IjQZEimw3k132CzIapKDlhnT0zMMjsxkSrHeC1i6T6GUhBkvff9fgWjQ3pqGrwo4w+VmCOZPOO5BrwsSqYQhOSHOq1mVH4fpX3tTDSsJ6yLfypiooRCYLdqsUiYSBElFZFtjqoG/Hn5c+kda5mcMF4CW0vmonuSJZmx0KvZq7ZWEin2P/cIX7/lrXzorTv4+i1vZf9zj8T19VFxUC6zBjwpRO1aFRCWLNj7wwMGREFBbUPi1WKYT6boS2ACnqOqgYDBmFUV47X6sBcrkWmPobTvfbtViyAoJLdRAJgKQ+jzwpIKY5RKbC1bKRwdROd0SHfdLCQnjJdgPIOZlsmSzNjb1dp4pwiHsHQdYaq6kUB+QaaXkzL2P/cIt936BYYHuxCEMMODXdx26xfiEsdTNU0E9QbZec2SFbWCuHr98ysxl0ghY2E80GMAoK4pOWEcqTiLCVWMRZUKW/MWiod60brTG9eZ6L03J4yXJ1N7X+pR0AtRKKCiyod1TEsoKF3KxngGrURyIieMl2CqtpmgTo+581iml5IQiYqI1SqMSwa60fi8jK3ymLaH7/m/RT/+yL23x3wNUaXC1rSZouE+NG6nVEtLmmBIQBAS978HgqvXP78sgoCl8wgz5dV4i0ozvZolGeiNCNm6Rk9S19HqRGrqvZzsMxBMQDREvZbmrvTe+xOuGK/Se7ZURB/w010xjlZzU1ExBqiu8xEOKRnLTcCTnJwwXgJRpWaicRMlJ7vReBPrkM4kifrVVutNNppJbU1zXE+6GV3CEz8Sp1fe2roNhShi7m6TYlmSkUx1bK0mUhSN9KN3zcjaRgEw2GNAqwtTUZW8kGho8RAKKRnqj99TmqlBHwnfs3MV46WZnfboKrHgLqtI60tHG+OkzjCOUl3nA2B4QDrf9JyFNCeMcyyFtWULClGkrPt4ppcSN4lbKVanx9jcHan+RN/0VivrqhsX/XjlEh9fCqtMIwuTsVOsVX9xNjSdBvwKRk7qqan3JdV4F2W+Ac8Y99fO7f00i4Ocx1h6TNYR8hz2jBREosLYXCF98x1A1Wxyy8l+g2TX9JsKcVTWY+k6lpWJXFKRE8bLkMkO5WRJ9GaZTKKFnLF0HiOQl4+jsj7TS0kpV9/wvkU/vuf698Z1nUzGVi2HP6npYKtzb6/E/LRH+Qrj4UE9gqCgrik5G0WUhrnR0PGLBl9hCdMVNZH7fhqtN/5gOKGm6bW6r2PBMntSmImHQuuojsLiIHpDak6qUlExhsi9X+t1UzTcJ+l1s4mcMF4GWxY34CVcMfavvpus1j1D0Ug/tqbNJDRnNos4/6I9vP+W71Fd14pSpaa6rpX33/I9zr9oT1zX8RabcZrXpV0crEQgl/UaN5bOIwT0eUzVNGd6KUsy0BPxFyebSBHFss6PPi+cUAMeRMSB3jVD4eigJOuJBVFMLHZttdrfpCAaPZbuxrtgQMHkhCZl/mIAY36Y4rIAQwPSVYxh/iFiLdsppBm0vUpxl5bjLjFHqmaimNYZ68mSSBOdIIirUjxEfbLRI9LVzvkX7YlbCC+GtWUrTS88hml8GGdFtQQrSx5/KAkrxRoUEBq3k6LhPkY37UBUSeBRSBGDvZE399okEymiKJVQ3+Sh/agJj1sZ94AFa8s2WvY+hKXzCNOVdZKsKRZ8gTB6bXxvy6vxni0Vls4jhNV8wdj4AAAgAElEQVSatE97tI1pEUVFShIpFlJd5+PogQKc0ypMhdLsg4WnhR1XXi/JNbON1V0+kwBry1byHBMYJ8YyvZS4SORm6QuEVmXXvmW2u9y2RoSxVMhxElJyFeO113xn7j2BQhRlv/cHevPQaAXWVfsku+a8nSKRQR+ZaUJKpPq7Fvd1LKh9Xkr7O7FlYNpjqkZBn071rM9YyqpxNK4zasFai+SE8QpYs9ROkYgw9vhXaePdrDBeKxXjhQz2GhgfSexNwdoiP59xzmMcH/N7f2uGV7I0wYCC4UE9NfVepCxq1zdHhHHUphEPk3WthDTa9CdTJCKM1+BJSCyU9RxHKYQz0nA9OhTx/aYqkSJKdX3kQXJIQp+xqFJnLMtbLuSE8QrMiYM0Z1omSyI3y9XoL0YUMXcdxVVWgbfYnOnVpI0Jq4Zf/qCOb322lf/8cjN+X/x/6vaGDYTValk9FCaTLLEWhXH0dyfnivHwoB4hrKC2URobRZSoME7EZyxoNEw0bqRkoAu1T9p1LUe8ezRRX/JaIJpElIm9L9WwmpWIVoyHpfYZR7O8ZRbXmS5ywngFJho3ISiVshIHsRAIxT8W2rsKo9rybaPkTU+umWqxz6vkvj9U8JWPb+DgviLyC0I4pzXs/WdJ3NcK6/TY69dT2teBMpiayKF4SS7HeO0JCHP3MdzFZtwllkwvZUkGeqMiQppEiijFpSGKSoIJWSkgkkqkFMKU9aQvrjPeinEi9/m1QvQ9OxP3/oGePEyFQYpLgyl9Hcs6P2qNwMkE8rqXYy6Rq0M+Nrp0khPGKxAyRLq5y3qOowildpNLSSJjob2rsGI8VzFrXt3CWBDghaeK+Y+PbeDhe8sxFYR43ycH+PqP2tHpwzx6v4WAP/7mUVvLVlShIGV97SlYdfwEkvBTrrXKWp59HOOkLVIxk3Hj8GA0kULiijFEqsaOSQ1T9vj7zDPhsY83Rz5no1gac1cb3oJiXObKtL7utEPF5ISWuiZvyv/sVCqoqvUxelKPlLHDa30CXk4Yx4C1dSvqgJ+Swe5MLyUu4q2QrcbhHvOJFPL1WCZLOAw//FoTd/y0Fo9bxZtuHOMbP2nngosdmArC7N5jZ8ah4bkn4q8azx2pycRnnKi4DQsCwST8ydmIJUu89QO9BtQaaRvvoiTXgJf+CXjxCt21eAoSC4apCUwTo5H7fpofCvu6ItXbeolPQJaiqs5HKKScG0EtBb7CEmbKq2UX15kucsI4BuTYhBQL8d40V2PznaXrKIJSyUTjxkwvJWW0HTLR2ZbPhq1OvvmTdt70tnF0uvmb2VVvtqHRCjx6v4VgML43CZvM9n6iR8f+wNoSxTDfeCfn05JgMNJ4V13vRZ2C8NCozzgRYXxGXGcaiHfAUk4YL060IJIJf3FfZ0QYp9pfHGUumULCCXgA4+u3RbK8RwYkvW42kBPGMWCT6XjclYi3+rDamu8U4RDFXcdoV6l5/7su5uu3vJX9zz2S6WVJzvOzleAb3jlKSdmZdp+CwhCXvtbOlF3LvqeK47r2TEUNPlMR5TKJbBNFkWACdoq1KCAs3ccQFQpsTZsyvZQlGRnUEw4pqUuBjQLmfcsJDfpQKLC2bMM4ZcNoH5d4ZYsTd8U4Z6VYlLnGuww8FPZ2RYVxeirG85FtEvuMW9aunSInjGPAUdVAwGCUTdUsVuJp5FiNwz1G/vY7dKEgzwcDCEKY4cEubrv1C6tKHDunVRx+pZDqOu+yHs3XXmtFrRF4+D4LoXgOBhQKrC1bMFlHMDjsyS9YAhLZp2vNX6wIR5rGHFUNBI2mTC9nSea691MkjPOMAuWVPvp78hASODRId55xKCwQCse+0NV2z5aKuez65s1pf+2+Lj1FJUGKStJzAltVF41sk7ZivHDQx1ojJ4xjQFSpsDVvoWikH60re3L94hEDq3G4h/uhPwPw0mkff+Te29O/mBTx4t5ihLCCCy+fXNZKV1Qc4uIrJ7Fbdby0N76qcdRraZbJiUlCY3PXmIAoGu5D63VnRBjEw2BfahIpFtLQ4sHnUWEdjd+DmQmfcTwFjbW2r2NCFDF3H2O6oga/qTCtL+2YVDNl16StWgxgKghTVBJkSOJkism6VsJqDeaetRfZlhPGMRJtYIke0WQD8dxgV2MixfopGwD7T/v4yFBv+heTAkQRXniyBJVa4PxLplb893uus6JWCzx0T3lcHcxyqxwkIgbWmoCI3qfk3nQ60JOHWi2wrjp1gxCSyTO2NW1EUKrSepwcTxP0WtvXsVAwOojO7cxQfnFkj6VTGEPETuGY1OJySjchR9BosDesp2SgE1UgtYNK5EZOGMfIfHRP9gjjeG6a3lXYeLdLo8EFnP68W1ndmInlSM5Aj4HhQQNnnTuDqWDl33VxaZBdl09iG9Px8nNFMb9OtOooF499IIF0iWRi3rIRc1fmmo9iJRRUMDygp6rOh1qTutOq+uaITSORBrywzsBkXQtlvSfSFtcZj2845zE+k7mHwgz4i5MZ7KHVJC5qq2ftFMMS+4xtzVtQhUKU9HdKel25kxPGMTLXnS8TcRALcVWMV1lUm8brpjUY5ABwuiTac/17M7EkyXn+yUjT3YWXT8b8NXuus6JUiTx0TzlCjNsjYCxgqroRc3cbCinDMhMkETGw1iprlq6jhDRaJmtbMr2UJRk5qScUUqa8ulZT70WlFujrTsyDaWvZgjoYSFtcZzzJFP419sAXC3P+4gw8FPbPVYzjF8YlpsTj1qrqow14EvuMZx8uLFl0Ui4FOWEcI96iUpyWyrRG9ySLxx+7b3i1WSnKuo+jRMS74xKq61pRqtRU1W7k/bd8j/Mv2pPp5SVNwK9g/7PFFJUE2XS2M+avK7ME2XnpJGPDeg68GHvV2NqyBa3XTZEMbCiBUE4YL4fK76NkoAt74wYEjSbTy1mSuYl3KWq8i6LRilTX+RjqMxCKM64QwNYUOTFJ13jcuCrGa2hfx4q56xiCSo29fn1aX1cUYbDXQKklSEFh/IWmAqMWjToxSVYzF9kmdcU4vXtfLuSEcRxYW7aidzowjQ9leikxEQ4LMVskVttwj+gTruqyN3PLV+/hNZeMMz56DIXipgyvTBoO7S/E61Gxc/ckqjhP4K6+3opCKfKPv1pifsaba0KSgZUokSrZWhIQpX3tKIVwRo6S42Fw9ti5Ng15rw0tHkIhZUKRVta5uM707P1YhXEwJBCOI8FiLaAMRqZ02utaCOukFYkr4ZjUMOPQ0NiS2KAanVZFnj6xB1lLpR+1WpC8YjxdWUcgL38uE32tkBPGcWDNwjxjlzc2X9xq8xibu44ioODu8dfxlY9v4IWnSggFlfzu59WMDkk3IShTRG0Uuy6L3UYRxbIuwI6dDkYGDTE3JM1VDmTQoZxIKkVgDXkxow+FcvYXAwz0GVCpBSprpJ94dzrRKWSJ+Iwd1Q0EdXrK0lQ1i9VKsZYe9mKlZKATVSiYGRvFrFWnoSWxBz29Vo1Rn9iUG7Ua1tX4GTmpj9kiFxNKJbamzZFELnf2JHIlS04Yx0E2TsBzeWMTvKvNSjF+QmCX6iVuu3MLoZCCG98zzPs/OYDfp+J//7sOvz+9Y0KlZMKqof1oPs0bXZRXBhK6xs7dkRSLF5+JLbptsraZkEabNnGwHLlUiuUxd8o/kSIUikzqqqr1oUlh412U+pbEkylElZqJxk0UD/Wg9qY+bSDW3pC1ls0dC5ltvIvsrcbWxB70DFoVxgQrxhBJpggGlIwnEEu4HNGiSFnPCUmvK2dywjgO7I0bEVTqrPLbuLwrC6fVNNzD71dw/y8LuWjmn7wUPo8dOx1848ftXPHGCc6/2MHuPROMDBr4821VmV5qwux7ugRRVMTVdHc6m85yYioM8vLzRTH5LkW1BnvDBkoHujIe3RNvwkQwJBAWsqMvQAos3cfw5RfiLK/O9FKWZHRITyiYuol3p1NR6UdvCCdUMYaIOFAKAmW9qRcHsVop4mmuXitksvEumkjRkKCVQq9VkZdgxRjmJ+BJnkyRhVG1yZITxnEQ1uqw17VEPHzB9ET3JEssVorVNNzj7t9U8dA/66ljgP+57Bd88DMDFJfOV83f+i8j1DZ6eP7JUvY9Hd+gCzkgCPDCU8Xo9GF27JxO+DoqFZx/kQO3U03bodgmo9maN6MMhyjt70j4daUgEAzHtV9Xy0NfLOhmpigYH4q8mS038SXDRKtrtWnKe1WqItmyY8M6PO743/bmxEEarESx7u+1tK9jxdzdRsBgZLqyPq2vK4qRRIoyi598U2K+b51WhdGQeMU4ZRPw5uI6c8I4xxJMNG9GHQxQfDI90T3JEouVYrXYKKxjWp5/ooSG/BGOsYXmS87sStNoRP710wPo88L84VdVjJzMLr9xZ1s+dquOHbum0RuSa7x5zaXx2Slss8eTmW7EEESRYBxZxmvpyDn65mWVub94ME2JFAtpaPYiigr6uuOvqM0lU6Rh7wtibCd4a2lfx4LG7aRouI+Jpk2I8XYkJ4ndpsHtVCcU0waRDGOVUpmwxxgisYQgfTKFp7Qcd7FZFja6dJETxnGS7uieZPH6Q4SF5UXEaskw/sdfyhEEBZ8t+il6hR9b06ZF/52lIsC7P3KSgF/F//6gHr8ve/4MEskuXoraRi8VVT4Ov1IQUxVNTtE98VTL1lJlLXrcaZN5IsVAjwGlSpyrcqWDutkJeL0d8QsHZ3kVPlORrCLbclaKUzH3nkAhihn1F0f3WLzotREhb9CpUSZ40mMqDFNQFJS8YgyRe3/+pJU8+7jk15Yj2aMIZEK6o3uSRRTFFavGqyGRYnRIx4t7i6mq9fIe249xVDUQNC5tEdixc5rLX29jdEjPH39dlRXR1B63koMvFmJZ56d5gzvp6ykUkapxKKjk4L6VM42n19VGontkIIzj8RmvKWEc9VjOPsTIEeeMioGePOoaPWlpvIvSMNuA19OZQEVNocDavJkC6zD66eQfSlcilmSKtbSvY8E8mxaVEX/xrHe9PsGKsW526p1SocCQlM/Yx+SENiG70HLM+4wzf+9PBzlhHCfpju6RgpV8xqvBSvHA3eWIgoKbrzyE3u+O6Sj5Le8apb7Zw76nS+IakZwpXtpbTDCg5MLLJyWzj15w8aydYm8MdgoZRffEVTFeK5U1UcTS3cZMeTW+wpJMr2ZJDu0vRBAUnPOaxD3yiVBcGqSgKEhvR4IT8Oa6849LuaxF8cVwT84J41PJ7MS72UzuxkQrxvNiOBk7RXV9tAEvNRPwcsI4x6KIKjX2xo2R6B5f+vxxyeDyLJ9Mke3DPYYG9LzyfDF1TR5er3sMiO0oWa0R+cAtA6jVAn/7cwUymHa8JKIIzzxWilIlSmKjiFJqCdKyyRXxLttWbvyQS3RPPNPv1srYXNP4EHqnQ/aDPQ68EHkITaZ5NBEUikjV2G7T4JiKX3xEBVc6xuPG5jFeG/s6Vszdx3AXm3GXWNL6uqIYsVJY1vnJMyb2O9Hr5j3RiQ75gPlkipMS+4wnmiO2xLWSTJETxglgbd6StugeKVjtVooH7ioH4M03jlHeE1/VwFwR4MIrJrGN6XgplqpphujtyGNk0MA5F0xTUCTt7yvahLf/2ZW//3mfcWZvkPFUgddKk9J8xUy+NgqXU0X70Xzqmz2UlSeWwZ0M9c2JD/pIZ/NpLP7hbC9oSEmefRzjpC1yf0pzGottTIvXo5obIpMIes28MM5PShhHPPtSV4wDxgIclXWRivEKPUurgZwwTgA5NSHFgtu3eq0UAz0GXn2piMZWN1vOcWLuOkZIo8Ve1xLzNfZcZ0WlFnjor+WyrRo/81gpAJe81i75tXfsdKDWCLz4TPGKXmu5eM0CcaRSrJUjZ3MWTLw79FLERrFjpyMjrx8Vxn2d8QtjX2EJTvO6yN5PcVPCSntWEOJLZlntWGbvR9bW9A+16Y823iUjjLULK8aJWykqqvyo1EJCo89Xwta8BZ3HReHYScmvLTdywjgB5o6Ts0QYL+cxzvbhHn/7cwUA17x9DHXQT8lgN/b69Yjq2J+6S81BLrx8EuuYLqaqabpxOVW88kIR5ZU+1m9xSX79PKPAtnNnGB3SM9i3fKXBXWLBU1SW8ci2XMX4TCxdRxGUKiYaNmZ6KUtyYF8hkH4bRZTGVg9ancCBfUUJaVtb82YMM1Pk20akX9wCVqoGO1ewx6015ptOMzfYI9GoNpDOY6zWiKyr8jM8KPFoaBYUBLMkeCAZcsI4AZzl1fjyC9PiNZOCQDC8pJDI5uEePR15HDtYQOtmFxu2uijt70AZDjGRQEf+1dGq8T0WyW8oybLv6WJCQSWXXGVP2SlhzJnGCgXWli3kT1oxTNlSs5gYyHmMT0URClLa18FkXTNhnfTVIilwO1WcOGqirikzNgoAQ57ABRc7sY7q6DxujPvrbWlqQlrJSjE+lR39Leli7rRkiYjOVDLQk4dCIVKbRCa3bkHFOJkhHxDx0Qf8KtqP5Sd1ndNZSxPwcsI4ERQKbM2bKRgfQufMzJFgvCxVNc5mG8Xfo9Xim8ZQKObfrBJpPiq1BNm1e4rxET0vPy+fhApRhL2PlaLWCOy8bCplr7PlbCdGU4iXnyta0U4yIQMrUaxiVxTFNVExLhnsQR3wyzq/+NX9hQhhBTt2ZfaeuXtP5PWfe7w07q9NV9VspROR8an0TAzMCgQBc3cbUytEdKbopRnoMVBR5U9q4NJCK4VapTxFKMfLrtnm7Gf/Gf/+Xg57/XoElTrjNrp0kBPGCTLvM059dI8ULCmMs7SBo6PNyIkjJjae5aRlUyTTN9kM16tvGEepEnnwL+WyqRp3thkZH9GzY6eDfFPqFqXWiJx3oYMZh4YTR5Z/c4kOuclklnesYjcQEhCy9EQkHuYHe8i38e7ACxEbxbkZslFEWb/ZS3mljwP7CnG74hMgE02bEBWKlI+GDoUFQuHFhVYwFGZqxp/S188mikb60XrdGWk6HR/R4fepkvIXa9RK1KpTpZgxiQa8xlYPlTVeDr1cwMx04raM0wlrddjrWijta0cZXL5vKdvJCeMEmT9Sy45jhaUrxtknjAUB7vv9OiBSLY5i7m4jkJfPdGVdQtctswTZtXuS8RE9r7wgj6rxfNNd6ocKXHBJbHYKOTSfxuqLz2b/fDxEhZpchbEcbBRRFAq4+MpJQkFl3Ek0QYMRR1UD5p7jKFLcqbuUncLq8K2Jh71YmSuINGW/vzhKMj5jhQIuvmqScEjJvqek7ZmxNW9BHQxQMtgl6XXlRk4YJ4gcxEE8rCYrxUt7i+ntNLJjp4PG1siTusbtpGikn4nGjaBMfFtffb0VpVLkH3/NfNV4ZlrNqy8VUlnjlWTS3Uo0tnqwVPh59aXCZScn+U2FTFfUUNaT+u78pYi1Kz+wRoZ7mLvaCGn1TNU0ZXopizJno8hQGsXpvGb3FCq1wLP/LIl7C1tbtqDxeSka7kvN4mZZyk5hnczZKBYyn8aS/ofC9qOR07WkotoWsU0kk2UM8JpLplBrBJ59vFTSW3T0Z5wtuidRcsI4QbzFZbhKyyN/lFnw9L6UMM62LEyvR8k9d65DoxV4y7vmO8PNs5nSyVbMzBUBXrN7itEhPQdezGzV+IUniwmHlFzy2tQ13S1EoYCLrrITDCh56J7yZf+trXkzetcMBRmM7omlGrwWKsYqn5fikz1MNG5AVEl3dColmU6jOJ2CwhBnnTfD8KCB/u74Ml/TleW91FjoXOPdqZi72wir1djr16f1de1WDS89G0kLio4bT4TFhHEyFWMAoynMjp2OSJNpW/xNpkuRbSfliZITxklga95CnsOO0T6e6aWsiNsXXPT4LdusFP/4azkzDg1XX2el1DIv9qPHaVJM/Xr9DeORqvFfLBnLMhcE2PvPUjRaYS4xIh1cfvUEpeYAT/yjDOuodsl/J4dBH7H4jNdCIkVxzwmUQljeNoojJmobPZgr5BMzdvEVEXtSvE1484M+Up1Mcea9edodyLpiRipRBoOU9ncyWdeKoFn6fpUKHrnfQjik5PU3WFEm3iu3aKNdMh7jKJdcNduEl0CT6VI4qhoI6g2rPrItJ4yTIJvsFIIg4vGdeUPNJivF+IiWJ/5RRqk5wGuvsZ7yuejvQApxYKkIcMElU4ycNHDwxcKkr5cIJ47kMzGu4/yLphIeM5oIWp3IDe8cIRyKVOaXIl2xVcuRqxhHKO08CsjXX3zo5YJZG4U8qsVRNp7lpNQcYP9zRfi8sb8VTta1ElZrUt6At5iVYjxnoziFkoFOVKFg2vf+lF3D80+UUFbu5/yLkytcLOYxTmbIR5TmjW4qqnwc3FeIy5mEcl+AqFJha9pE8VAvGm/q7X2ZIieMkyCbhDGA+zQ7RbYN97jrN1WEQ0re+i8jaHWnVr/NPW14Cktwl1VI8lrRqvHdv6nCOSPNTSUe9qZw0t1K7Ng1TdMGN6++VET70cWP4ewNGxCUqozu/UAM1eBs2t+JUtqZueEGsXBgtpE10zFtp6NUwoWXT+L3qXgljohGQaPB3rCe0v5OVIHUpUMsJoytORvFKWQqjeXR+82EZqvFqiTfHhazUui1KlSq5ORZpMnUTiikXDmfPg5sTZtRiCKls/bF1UhOGCdBNEw8W/w2ztOEcTYN9zhywMSxgwVs2Opk+wWnVp4MDjv5E2ORfF2JzLjllQHefNMYjkkNd/y0Nq028im7msMvF1LT4KG+Of1vhAoF3PieYQDuvqNq0SbEkN7AVE0TZb3tKMKZOdqNRfSuhQzj0o4j+PILmKmoyfRSzsDtUnHiaD41DR4sMrJRRNl1+SQKpcizj5fE9XW25i0owyFK+jtTtLIzPcbBkMDkjC9lr5eNzJ8Upu+h0DGlZu8/Syk1B3jNpcmnBek1ZwpjhUKRtM8YIk2marXAs/+UrgkvOugjk3GdqSYnjJMgaDThqKzH3HOcjJlR4+D0BrxssVEEgwruvr0KpVLkpvcOn6F9pbRRLGTPdVY2bnNy9EABjz9YJum1l0IIw29/VosgKNi9Jz1Nd4tR3+xl5+5JhvoNPP/U4qLB1rIZdcBH8cmeNK8uQizT7+IZHZ2NaF0zmEYGmWjaJNlDoZQc3l9AOKTk3F3yslFEKSkLsvlsJ31dRoYGYp8YGL3XpHL66el71+bw5mLaTsPc3UZQb8BR1ZC213zsfguhoJKrrx9HLUGvq163+EWksFOYCsJsv2Ca0SE9PR15SV8P1kYDXk4YJ4mteTNaj4vC0cFML2VFTrdSZMtwjyceLMM6pmP3ngkqa888upSy8W4hSiW89+ODmAqD3Pv7dXF3ryfCfX9cx/HDJrbtmObCy1OfXbwc171jFK0uzP1/rMDrOfNWER30kalGDH8gZ6WYyy9ukqe/+JV9szYKmcS0LcbFV0bsSs/FUTW2psFjf3qOcW7a3alovG6Kh3qZaNiImKyfIUZmHGqeeayU4rKAZJNIF7NSgDQNeBDJNAbpJuG5zOvwFhRnjYU0ERISxoIg8JWvfIUbb7yRd77znQwMDJzy+SeffJIbbriBG2+8kbvvvluShcqVufnhWXCs4PScZqXIgoqxY1LNP/5aTn5BiDfduHj6RyqHGxQWh3jfJwYRwgp+9cO6ZfN9k+Xl54t49H4L5ZU+3vuJwWTimCWhqCTE1ddbcU5reHiR+LZMN+DFVDFe7cI4RaclUnDiSD7HD5uoafBiWSc/G0WUrTtmKCgK8uLeYoKB2Kru05V1BPLyU3rfDwTDp1jdcv7iUyntPYFCFOfeg9PBY383Ewwoufo6KxpN8tV7terMqXdRpBLGrZtdWCr8vPJCUdyTHhdFocDWvBmTbRT9dGaLN6kiobfexx9/nEAgwF133cWnP/1pvve97819LhgM8t3vfpfbb7+dO++8k7vuugubzSbZguXGXANeijuUpcAXCJ0yZtQj86i2UFDBH35Vjd+n4rqbRzHmLyJyRBFzdxtOSyX+Ammn/ETZdJaLPddZmRjX8fv/rU6J3/hkv57f/qwanT7MRz7fn9YkiuW46k02issCPP5gGbaxU+OQJmubCGl1Gdv7K4neWIeAZDNzwjiN4iAW+roM/Pz79SgVIm9993Cml7MsajXsumwSjysyUCcmlEpsTZsi44jdMylZlyDON0fPuANZF62ZatL9UOicVvH0I6UUlQQlO81bqloMyWcZR1Eq4aIrI/n0L+2VJpt/riC4SqvGCQnjAwcOcPHFFwNw9tlnc+zY/FNzT08PtbW1FBYWotVq2bFjB6+88oo0q5Uh9vr1CCp11myQhT5jOedhOqdV3Pr1Rg6/XEjzRteSNyKTdQS905Hyo+Q33zRG03o3rzxfzHNPxNeosxIup4pffL+egF/Fez8+yLrq1HW6x0skvm2U0CLxbaI60p1fMtCNyp/+atZKqRSrvVoMEZ+fp9SCp8SS6aXMMXJSx4+/1UggoOQDnxpgw1b5xzpdNJtpfP+fKpbN715I9J5T1pO67vyozzhnoziTOWGcJhvR4w+aCfhVvO5aKxqtNNWRxaLaokjhMY6y67IplCpRsia8ORvdKvUZJ/STd7lc5Ofnz/23SqUiFAqhVqtxuVyYTKa5zxmNRlwu14rXLC7OQ61OfyzW2IwfJjwYjbrELmDU4WhopayvHZNWkfaQ8XjR6LWYzZHfj7rHnvD3nfDPKwYGe3X899eqmbBquOCSGT74qVF0+sVfr3qoAwDH5rNTuiaAj39plH//SAN33V7FlrOCVNfHfjy81NrCYfjxt2uYsOq47uYJLrrcD6T2+4iX3a/18swjHg6+WMTD94S49u0TqGdP+aY2nkV5xxGqx/qY2LRdsteM5XepUinm9vJiTM34Ur4nMonBbsU4aePkzitk833axjT86Ju1uF1qPnDLqCz3M5y5vxqa4bp3THDfH8r4/pda+NRXh2ndtPzD3syWs+F+qBOfDAUAACAASURBVBrsYHrnJSlZZ55Jj7ksnyP9Uxn9Hctlfy2kvPc4voIihMZGjCluPHU5lTz1cBmFxSH2XONCq1v+5xHrz8tSlr/kPaxEEMlvtyGFBDca4dydTvY/V8Bf7qjlHR+wnhF5Gg/ubecAUNF3QpK9sdx9PBMkJIzz8/Nxu+erAIIgoJ5tzzz9c263+xShvBRTGXoinnZEXtftTrxKN964iZLu42jbj2Nv3CjV0lLCyWEHRnXkJmKdcCdUNTYadUn9vJbj0P4C/u9Htfh9Kt580yhveIuVUBhCSxSdCo4dAmC4dn3K1hTFYPTzro8M8ov/bODrn6llz7VWLnv9BLoVbjDL/bz++rt1HDtoZNuOaV533TBumRbX3vGvg/zo243c98cyXtmXx3s+dpLqOh8jdRvYAJiOHmSgbpMkrxXP/hodm17So2ed8qR8T2SSsiMHAZhs3SKL73PGoeY/v9TAlF3DW949wnkX2WS5n5faX1dfP0y+ycsfflXNtz9fw3s/Nsi5Fy6dpjFUExlBXHj8UMp+/qNjMxAM0z/sQBAyk0iRyvt9ouhmpsgfG+Lk2btwe1LrX/d6lPz5/6rweVW86W3DBEM+gsu8bcbz8wr4AthsziU/L4TCklker3n7MEMDGh5/sJi2Qwbe/8kBahoSi/9za4w4LZWUdBzF7fIlnYiz3M8glSwlyBOyUpxzzjns3bsXgEOHDtHa2jr3uaamJgYGBnA4HAQCAV555RW2b5eukiRH5o8V5G+niFop5DbcQxTh4Xst/OI/6xFF+OBn+nnjW60r/r2Zu9sQFYq0PZBsv2CGmz8wBCLc+/tKvvSRjTz1cCmhYOw3BkGAzjYjd/yshsf+Jp9mu+WorPXz1R92cOHldk725fGdz7XwyH1mxhsz3IC3zB5e7eOgoz9ze+vWDK8EPG4lP/pWI9YxHVdfP85r35ydfSUXXzXJx/69D7Va5Fc/rOeR+8xLHj27S8vxFJWmPJliYtqbMVEsV9KRXxwMKnj8wTK+9G8b2fd0CeYKP5e8Vtpms+WsFAB5EjXgAZgrAvz797u4/PU2Rof0fPcLLTz2d3PCSbO2ps0YZqbIt41Itka5kFDF+KqrruL555/npptuQhRFvvOd7/DAAw/g8Xi48cYb+cIXvsD73vc+RFHkhhtuoLz8zI721YR1QeB1+2vfkuHVLE9UGMtluIfPq6TtkIkXnirh6IECissC/Nvn+6ltXNmzqgiHKes9Hpnfblh8Qlsq2L3HzvkXT/HY3yw88Y8y/nRbNY/9zcKb3jbGBZdOLTkJaXxEy4vPlPDi3iLs1sjxU6nFL6tmu+XIMwq8+9+G2H7BNL/7RQ33/r6SQ/uvYKthOzWZimwLCuQtET8rpwe/VBAVB5OtmUuk8PsVtB8x8fC9Fk72GbjktRNce/NYxtYjBZu3O/nct7r5yXcauPf3ldjGdLz9A0NnZtYqFNiat1D3yjMYpmx4i82Sr8UXCOPxybcXJFOksvFOCMOLe4v5+58rmJzQos8Lc83bR7nyjRPo9NLep3XLNN8BGA1qJiSMANfqRG563wibtzv57c9q+OtvKzl20MR7PjZIcWl8+8zWvJnGff/E3N2Gy1Il3SJlQELCWKlU8o1vfOOUjzU1Nc39/8svv5zLL788uZVlEY7qRoI6PWVZUDF2+yLCOJPDPabsGg6/XMDhVwroOJpPKBQplTZtcPOhz/RTWBzbH2jRcB8anzcjUVV5RoFrbx7j8jdM8PC9Fp55pJQ7flbLn/6virz8MAZDGH2egMEQJt8E1jEVfV0R8a7Th9m5e5Kdu6do3eySdaV4Mbad6+Rr/9PBn35dxcvPF3Oe4gX+n/dOSl5S0HiuiDKNrQIRK9DiHrdVLYxFkbKeNqYragiYiiCNR90TVg1HDxRw9EAB7cfyCQUjG/i8C6e4+f1nDuDJRqrrfXzxe1385DsNPPt4KcMn9bz+hnG2bHee8vdqa95M3SvPYO5uY/C83ZKvwx8MM5WbdncGUgtj54yKsWE9Iyd1PPVwGSODBtRqgaveZGXP9VZMBam5lyyXSgHSRbadztZznHzlh5387mfVHDlQyNdvWU9Dq4cySyDyv/IApeYApZYAOp2AUiWiUp3qmLAuSKbo2/XalKwzU0jX9piFnDih5Ia3VOJyK0jY4T67UT4VtKEaDBJ8dz5KJSiUoFSKKJSg0wkUFIUoKApSWBSioChEYVGQ8ko/jes9aX0jCYYEvP5Q2od7BPwK9j9XzN7HSunvnp/AU13v5axzpznrvBlqG71xicRoR6w1g1FVBYUhbnzPCFe9ycbD91jobjfi8ymZntIwNqxCECK/XIVSZNNZTnbunuTs82ckrzykm3xTmA98apDtr5nmbz8v4DbvB+A/oaAoyLm7HJx3oYOGVk/KRf/AmJN1pYufFgTSPPVOEGBsWIdrRk1NgxdDXup+xwVjJ9G7Zhg6e1fKXiNKKKigu93IsYMmjr1qYuTk/KCbqlov286dYeuOGZrSfC9LNUUlIT77zR7u+GkNB18s4qffaaS80scVb5hg5+4pdHrhlCzvVAhj+7QvY+lBoggel4opm5bREQ3TUxqmHWpc02qMpjDmcn9EQFkC5JvC6fvdiyLmnjZcpeV4i+ObSBoKwWBvHj3teQwPGhgb0TE+rMPtmpdCCqXIrssmedONY5Sag8tcLXlWEsZSJlOcTkFhiH/7Yj/PPFrKg38pp+3VghW/RqEUUSpFlEpQKrag5kbEB5SEH50vTsS7D37SouDhh9xoZZRbsKaFsdEoUlUTYnoawgkZbeZ3QJ7djm7GgSOvloDGgCAoEITIzcU5o2ZsePHz3qb1bq55+2haI43c3mDahntMWDU882gZzz1egtulRqkU2bjNyVnnTXPWuTOUWhK/8chpuEFJWZB3fPDUvFZRhGBAgVJhwO/3YzStvgrmubumuU51P3n/eS8/av42j47v5MmHzDz5kJmSsgBvedfIsg1MyTI26cE+7aO08My/r1RXjJ0zKvq68ujrNNLbmUdfdx4+T+SNTqEQqajyU9/sob7ZQ0OLh6o6nyRDASD1e99u1XDs1QKOvWqi/Wg+fl/k+9JoBbbumGHrORExnGrhsJB8g+aMsfapRm8Q+NBnBzjZP84TD5rZ/2wRf/x1Nff/qYJLrpzkdZeczdVEbHSpIBOiWAjDPx8w8497yuf280roDWHKLAFaN7vYedkUtQ3elAllo32cPIedvguuWPHf+rxKejvz6D5hpLs98nca8M9/T0qliLnCT9MGNxVVfioq/bRsclFemZ6BNJmqGEdRKCLWwN177Hg9SiasWuxWLRNWLRPjWuw2LaGggnBYMadphHDkvwGKB/tQhELY160HBQlFwdXXa5e0H2aKNS2Ma2tFfvorK4MTyXevNz7/KFf88PO8ePWnOPrmd53x+VAInNNqZqY1zEypmXbM2gleLuSHX2tm/RYn1759jKYNqU/ncHqDKa8Ytx818sQ/zBw5UIAoKMgvCHH19eNc+jo7JWXSvLmZu9sIq9VM1rWu/I8zgEIR8XQZjWHc7tUniqPYWzazh1uoLf4KV377f2g/auLl54o4sK+QX99ah9c7xMVXpm5C0vH+SS4+q/KMj6dKGIfD8Otb6zi479Sw/PJKH9vPn8ZUEGKg18BATx6jQyXsezqSe603hHnbe0a48PLJpEVDqpqP/D4ld91eyXNPzI+PLa/0sWX7JJu3O2nd5Eoq5ikZtjaV8vIJ6ylDitJFTb2Pf/noSa7/f6M8/WgpzzxSyiP3W3j60VJ2lL6O83pejKiCLC+Zj49oueOntfR0GDEVBFl/notSs4DR5KewKEhhcQhTYQjXjIoJqw7beERATYxrsY1rGRqIPBRX1XrZddkkF1zioKBI2vea6LTB5R4K7VYNj/3dwnNPlBAMzB9bVdZ4adnopnmjm9pGL+byAGqJHlbjRaVSolkholaqIR+xYMgTqKn3UVMfu3Xnkp9+hfVP/Z2/fOIeHDVNK3/BIlyzuwWFzN4e17QwlpKVxuOq1VBcGjrF4H7RFZP0dxv4258raHu1gO9/ycSW7TNc8/Yx6ppSNzDB7Q2mdIrSi88UcfuP6wCob/Zw2dUTnLvLIVkoOoAyGKBkoJPJulbZZ0evdjwlFlwlFixdx1CrRLZsd7Jlu5Mr3jDB/3yzkTt/UYPfp+TKN06k5PXtMz7GJj1UlOSd8vFUpVL85Y5KDu4roqbBy1nnTdPY6qGh2XPGiYAQhrERHf3defR15bH/2WJ+9/MaThzO5x0fHEqq4dLc04agVGFv2CBZSvDwoJ5f/Xcdo0N6quu8XHyVnS3bnZgr5DHOudCopamqkI7BqYytoaAoxJtvHOfq66zs/Wcpd91exdvCd3IgcBam8SGcFTUZW1syCAI89XAZ9/5+HcGAkvMunOLtHxgm3xReJn7s1IitUAiOHzLx/JMlHDlQwF9+W8U9d1ayZfsMl+6J7CUpnhuWOy0ZHdLxyH0WXnq2GCGsoKQswLkXOiJieINbVqd2K1WLAbQaFRq1UrYTPG3Nm1n/1N8xdx1LWBjLkZwwlginpRKfqWjuaTZW6pu9fOLLfXS353H/H9dx7NUC2g6Z+ORXetm4beXBKIng8gZTVk2bsmv4022R0caf+I9emlNUAS8Z6EQVCsnCRpEDJpo3U7//KYyTVtylkRSa2kYvn/lGN7d+vYm7f1OF36fkDW+xpuT1T/RPUl5sQLHgnTcVe/yZx0p48iEzlTWR7205H7FSBZU1fipr/Oy6bIrXXWvltlvrePn5Yvq68vjApwZoaIn/AVgRDlHWc4KpmiZCekPSwlgU4bnHS/jz7VUEA0ouf72NG941KpntQwoUCgVajYqW6kIGxpwZn9qp0Ypc8YYJgkEF995ZyZv5O18//kxWCuOJcS13/KyGzrZ8jKYQ7/nYIOfuit/+pFZHGnO3nevEOaPi5eeKeeGpYo4cKOTIgUI2bHXy1n8ZiasiuRjREfQTTfMRnf3dBh6+18Kh/YWIooJ11T72XGflvIumzkwTkQl6TWz+AaNBg8MprxzpKNH3X3NPG12XX5Ph1UhHlvXDyxiFAmvzZgqsw+in4z82bt7g4TPf6OGjX+wF4C+/rUw4X3AlnN5gSlIpRBF+9/NqvB4Vb/uXkZSJYpj39FlTmGOZI3bmOpRPezCsrPHz2W91U2oO8Lc/rePe31dIMpL0dKbdAYZs8z79UFggLPGRe/tRI3+6rRqjKcS/faE/7ua6MkuQz3yzm6uvH8du0/L9L7Xw6P3x54gWn+xFHfBJ8lDocSv59a213PnLGjRagQ9/ro+b3jciK1EMoNUoUSoUqFVKNtQVrfwFaeJ119i48pxODnAut95zScru2ami45iRr3+qlc62fM4+f5qv/09HQqL4dEwFYS5//QRf/q8uvvxfnWzePkP7URPf+kwrd/ysBsdkgmpVEDD3HMdRWUfAWMDokI6ff7+e73y+lVdfKqKuycuHP9fHV2/tYOdu+YpiAL0utsWl2mecDJN1rYTV6qyY4RAPOWEsIbZZcVDWczzha2w718kFl0wx1G/gpb3FUi3tFLy+UEqqac89XkLboQI2b5/hohR6SmH+OG0iVzGWBctZiSwVAT77rW4s6/w8cl85d92emoe+9oGpuUEIUu9v66iW//1BPQqFyIc/25+wvUCthuveMcYnv9JLvinEPXdW8pNvN+B2xd59IlXj3VC/nm99tpVXni+mab2b//hBJ9svmEnqmqliYXWtttyEKU8e9imFAt72iSku40meGDuP+/6wLtNLihlRhHvurCTgV/Kejw3y4c/1S+4HhsjJ0Se+3McnvtzLuhofLzxZwpc/uoEH7i7H74tPghSODKD1uDhWcwl3/qKar92ynkP7C2la7+aTX+nhi9/rYvsFM1kRgRmLlQJSm0yRLIJGi71+PaX9HSiD8rBcSUEWbJ/sIfpGZelOrkP5mpvGUGsE7v9TBcGA9M0cgihKPtxjwqrh7jsqMeSFedeHh1Leg2LubiOgz8NR1ZDaF8oRE9FjTfMSe7+kLMhnv9lNZa2XJx8yc/8fKyRfg9sXpH8s4nv0SxjV5nEr+dn3GnC71LzjA8O0bk4+QWbjNhdf+WEnW7bP0HaogNt/XBvzw0L0KDkZYeycVvGT7zRgt2q5+vpxPv2N7rQmTMSLdoEwVioUbG4oyeBqTiNfz6+rP896Onj0fgvPPi6jtS1D9wkj/d15nHXeDDt3T6X8nr15u5P/+EEn7/zQSfQGgQfuquALH9rIn26ror/bENNJkqGtmy/xLa585TaefbyU8nV+PvL5Pj737W42neXKqt5HXYxWinwZV4whch9ShUKUDHRmeimSkRPGEjJXNUsyuqfUEuSKN0wwNaHlyYfiy2nMBIIAd/y0Fr9PxU3vG6a4NLVvsBqPi6LhPiaaNiHKLedljRIwFuCorMfcc5ylFF5hcYjPfKOHopIATz9alpKHvo6TU4TCgmQV42gCxeiQnivfaJP0JKSgMMRHv9jHprOcHD1QwCP3WWL6urLuNkIaLZO1zQm9rhCG235Ux5RdyzVvH+O6d4zJ+sgZzqyuVZTkYS4yLPGv009wfQ0P8gby8/z84VfVtB/Nz/SSVuSxv0cm9b32mtT4/hdDpYqM3f7WT9t5w1vGUCpFnnq4jO98vpWvfXI9D99rYcoeEYLhcKSZ7sC+Qv5+Vzm//EEd7/zNB/kOX8JoDPHOD5/kq7d2cPb5M1kliKOshooxREZDw9LBA9lIThhLiK+wBKelMrJBkqzIXn39OMb8EA/dU47LKW/x9/QjZXS25XPWedO85tLUd4ybe46jEMU560oOeWBr3ozW46JwZGDJf5NvCnP+xQ58HhVHD64cKB8v/kCYnuFpAhIlUtz7+3W0vVrAlu0zvOVdI5JccyFKFbzvkwMUlwX4258rOHFkeUGlCvgpHejC3rABUZ1YJenBv5Rz4rCJbTum2XNd+kRRMixWXdvcUHJKs2UmsTVvppkevnPV71EoRH75X3XMOOQraMaGdRx+uZDGVjdN61MfEXo6eoPANW8f5/u/Os5H/72Xc3c5sI1rue8P6/j8v27kIzea+PDbNvDVT2zgf39Qz4N3V3BwXxEqIci3FV/iWz9q4+IrJ2WXfxsPsXuM5buPYN5Cmqos70yQE8YSY2vajGFminxbcm+ieUaB179lHK9HxUN/LZdoddIzPqLlnjvXYTSFeOeHUm+hgPmKfK7xTl7YWpaPLIxy/kUOAPY/l5omqu7haZze5P1uLqeKxx80Y6nw8/5bBlI26tpUEOaDnx5AqRS57dZapuxLvxGW9negDCeexnLsVRP/+Gs5pRY/7/nYyazwYsKpVoooRfk6qs2LTz1MN9HTwis9D3Pt28fwuNW88kJhhle1NP98IFItvurNtoxWW9Vq2LbDyb9+eoD/uu04F13xCPACoVApcBj4DfBp9lx3N9//+WHGFOv41/p7UBfIw2OeDLGmUiy29+XEdGU9AX1ermKcY2msEj497d5jp9Ti56lHSpkYl9+NQAjDb35aSzCg5B0fGEpJ48ZiRH2suYqxvIjVY1/T4KWiysfRAwV4PdLfgoIhgb6R5JvI2l41IQoKLrxiMqnM4VhobPXw1neP4JzR8Ksf1hNa4k/J3HkUSGwMut2m4f/+pxaVSuSDnx6QVabrSix17LyxrgSVMvNV48naJkJaHebuY1xwSeTU7OCL8knPWMjMtJp9TxdTVu5n+/mpm0oZL8b8MH1dHwcuAoqAC4D3Aj/k2MH/oNl9Ak0oIPlQm0wRq5VCrVKiUslXqokqFRNNGyka7kPjTd8E31Qi3592lrLSoI940GhErrt5jHBImZJmpWR58ZliejuMnLvLkdKxv6dj7jqGp6hsLi83hzyw169HUKkpW2HvKxSRqnEwoOTQ/tRU1cJC8s2lRw9ErB5bd6QnqeGyq+2cd+EUPe1G7r3zzEl+MP/QEa84CAYV/O9/1+F2qbnxfcPUN6dugFAqWKpRKU+vpsZiSvNqzkRUa7A3rKdkoJtSo4um9W66ThhxTsuv2vf0w6WEgkquepMtZacgiTI61Lvox0eGelM+Bj2dqJSKuCrBOrW8pZqteQsKUUwqkUtOyPunnYVMNG5EUColO1Y490IHdU0e9j9XTH+3fJpNAA69HBE11948mrbXzLOPkz9pjVTMZOIvzBEhrNVhr2uhrK8dZXD5BszzLopU1V5OkZ0iWcLhiO2guCxAVW1yAwliRaGAd354iIoqH48/aObAvjMfGsxdx/DlFzCzrjaua//ljkr6u4y85tJJLrkqtVGKqUC3THVNLs1JtqbNKIUwpf0dbH/NNKKgSNmDX6L4/QqeeqQMY36IXZdlboLgUqyrblz045XVjXOnsKtBGOu08e1Zudsp5gZ9rBI7RU4YS0zIkIejupGynjYU4eStBUol3PDOiF/5r7+rTMlwhEQIhaD9aD7mCj+WdenLL5yrGuRsFLLE1rwFVShIyWDXsv+uvDJAXZOH40dMOGfkd9Pv7TDicavZtiO9He96g8CHPtuPTh/mtz+rYWx4fq6dzumgcOxkpFocx6L2P1vE04+UUVnr5R0fTE8fgNQsF20Va+xVqlk45OacCyInaAdfkpcw3vdUCW6nmt177Oj08ptGcvUN71v043uufy/m7mMEdXqmVsHo4VhtFFG0GnlLtZwwzrEituYtaPw+iob6JLnehq1utpwzQ2dbPscPyyMGqLfDiM+rYvPZzrS+btRfnGu8kye2ltkbZAwe+/MuciCEFRzcJ7+qcbptFAuprPHzzg8N4fOq+Ol3G+ZSaeaPkmPf+72defz25zXoDWE+/Nl+dLr/z957h0lylufed6XO3TPTPd2Tc97ZnU3avMqBlYQsEKyMZCQjkHx8jOAcGWPLHBsbLPsTNpZs/B0M/hQshC0QSCBkkKyAVtpV2hxmZifn2D05dA7fHzXVM7s709Ohwls9/bsurgvNVle9U/N21f0+7/08DyEr6wSgKCqm+CVFNEwINrruFuTm+VFa6UbbBRPci2SMLxwC3nrVDpYN4/pbJ5QezqrsPngIDz7yOIrLakEzLIrLavHgI4/jwM6rkTPYjYmqRkQYMnYIUiFhYcySsfhbiwV7ITyWnDXr2KsNMr6xaYYUq6db7+LLKpGyNddylvf1bd4ur3BwdAod7zbJet0M8eFaIQ7WY9eBGVBURLLqFKlw/pQZnCaMus0Lilx/99UzOPQpJ5yjWvzr35cjEKCii414d0smnBz+7+PlCAYpPPRIP/IK1dmZimNp0DES7EiJGM/ml8BnMEW3/HfsnUUoSOPcCTKe2edOWuAc02LvddOyJUonw+6Dh/DNJ17ED148iW8+8SJ2HzyE3C6+RKczDWwUQDIRYzLm+JpQFFzVjTC7RqGbVZ9V63IywlgCopUpRFw9VdQsQqsLoaOFjIhxy1kzGDYsShewuAmHYe9uwUxhOfxG8WvgZkidmaIKBHT6uCLGObYAqhsW0XXRGC3qTwKTTg4jg3rUb1lQNML6qd8bxY59M+hsNeH5fy1OqCKFe5HGv/xtJeZnOfzuA8PYslPenR0xWU/4xvIfywpNw1XdiKzRAWgW57Bj75Kd4iMyhPEbr/ANZG6+w6XwSBInmnRau0XhkYiDLkGPsZaQXZFYpJOdgvy7rUKmSqsR5DQpd8BbCcsCVXVujA7pMDer7FbS7DSDgR4DahoWodPL51PLHumDxr2Q8RcTTIRhMFG5CTlDPXGV7tl9cAaRCIUT75MTNRYaj2zZIb+NYiU0DXzxKwMor1nER+9a8XTrrZh3FMKbFbvlcDAI/PAfyzE6pMMNt7lww22TMo1YGtYVxgRF0wRxkNvVivwiHwpLPGg9Z4bXo+yrtrvdgO52I5p2zqKg2KfoWJLB3iksCtNFGKdZxBgrK3Kp306REcYSwJfuqYd1oAuMT7yMdmFbt6NF2aL250/x15fdX5xp7KEKnNWNoCIR2Hournvsjn0zoJkIUdUpzp9Uzl98ORptBA8/2odcqxt/4/sGns56OObxkQjwwlPF0c52d39B/G59crOeiGAZGiwhdV4FcSBEOLfvmUXAT6P5tLIl5d57wwaAb+ihRtKtRGeiuxwawsu1ASsixmnQAY/8u61SXNWNoENB2PraRTtnbaMgjJW1U1wQhPF2ZRLvhASvDGQyITT6iOMBabaEsKlpHv3dBoyPKN/Exuel0dZsQmGpBzZ77JJzcmHJDuLx21+ABbP40+6vo6vNsOaxb/7KjqNv2lBS4cGDjwwQV6c2GeKJlpESNb58O3nHPsFOoezCr6PFBJMlKK/1TSTSsURnolYKNUSMvVlWzDsK4ehqATHls5IkI4wlYmXpHrEoq3JDow2hvVk5YRwOA+dPG5FtDchW31XA0dmMEMthsrxO1utmSAxnnK2hBXYttYg+cSxHsjHFS9sFE4IBGk0ERItXsnv6CH6OzyIEGt//TgU+PpqNUx9m4dSHWTh+zIxTH2bhjV/Z8dLzBci2BvDwn/fKanOSknj8laT4jN22PCxa7dFFfHGZF/Z8Hy6cNsPvU0bUTU+ymHRpUFW3qEpd6UjDEp3paKUAeKuLbn4G5vEhpYeSEhlhLBETCWTnxwvLAtX1yvqMB3r0mJ9lsWnbvKwPWcbvg7W/A5MVdQhzykcWM6xNoqV7tu+ZBacJ4/ixbMUDDReWtrxJS1azdzXjRvodfP6BPizMsXj6n8rww++W44ffLcc/P1aEH363HD9/rhAabRgP/3kvcmxkRLvFIJ7oGikl2wC+0YdxygXD5Dgoiq9O4fMyaD2vjJ2iu53f4auqU1+0GFjZBj09/MU0TSVsjVCDlQJYUXhgyROuVtRfEJBQZvNL4DOa49pOToS6zQtoPWdGR4sRV+2Xv899tEzbNnkjata+DjDBYMKttO5uQwAAIABJREFUcDMowFLpntLTx6CbnVo3WUynD2PLzjmc/jAbQ3061G9WRh1HInz9YoMpiMpackQEFQwgt+cipkurcPC2eeQUdmN8RBf9d42Ghd/Pl9+q3zyPwlL1JVfFIh7RS4qVAuAjm+UnjsDR1YI+Wx527J3Bf//SgTMfZWHbLvl3IrrbloRxvVv2a4uBo6sZEYqCqyo9SnTqOAZUglElkuZ3LITFi6PjArqvvk3h0SSPOpYhamRl6Z4F8R6GSvuMW86aQdERNDTJW9/VkWnsoSpcNYllKO9eslMcV9BOMdSvw/SkBpu3z4Mh6D1kHegG6/dFXzqN2xZww20TMFl+jKNvXo8f/7AIR9+8HibLj9NOFAPxRYxJEg7O2iYAy5HO8moPcnL9OHfCgmBAfi9Dd7sRDBtGeZX6hDEVCiG3q4UvA2lUNoFRLHTaxOORNE2BU0HUeLKiHiGWVX3EmPw7rWJcVUuJGCLaKZT0GbsXafS0G1FV64XRHJL12ok2N8igLNG5H+eOyZYdc9AZQorWfFWy210sokmnKxaFx4+9jqeefBTDA50Ih0MYHujEU08+iuPHXldqmJIRl8eYIGHsqtqECEXB0XkeAJ8vtmPPLNyLrOzPbZ+PwkCvHmWVHnAa9SVEZQ/3QuN1x1W7Wy0kO1dJ734HACGtDlNltbD1toMOqLOhEJARxpLikiABT0mfcdsFM8JhCk1Xyd8NzN7VDJ/BhNmCUtmvnSFxlpvcxLco5DQRVNa44RrTYnFBmcfShVMWUHQEm2UuQ7gejs4rG3u89tLTqx77+svPyDImOYknsY4kYRwwmDBdUgV7dyuoEG9x2b5HmWYffZ0GhEMUqurJsQYlQjQgkkY7hYkm3gmQ5KOPhbNmC5hgALZe8SpyyY067rRKSTQ7P16EesadrfLWM245w29lNe2U9yGrWZhD9kg/XwqJzkxZNeCz5GA2v4QvzB+OrzpCSYUHADDQq5VyaKsyP8egp8OAylq37Lsh62HvbEZAp8dMcWX0Z6NDPaseO7LGz9UKx9Jg4vjOawipSiHgrNkCzutBzmA3AKC6fhHmrADOHrcgLOP06lryF1erVBhHLXRp0vEOSL7ChJoqUwDqTsDLqAwJ8eTYsWB18Al4Iqbb127ihbGc23KRCNB81gyDKYiqWnnLtK22lZyBfJy1TdAtzCFrdCCu44vLeWHc361b50jxaTljRiRCEVemjfMsImeoh9+eX2F8LlghkldSuMbP1Uq8kWCSIsbAspBzLPmMaYaPGs/Pcehsky+gsVyRQn3+YoDveBfUaDFVWq30UEQjna0UwHLbbkfHeYVHkjwZYSwxrpotMMxMwDgxJto5y6o80GhDsnbAGxvWYnpCg01b52VvGpCOdSw3AssZyvE9IEuWhPFAj/wRY1L9xbldraAikSsWhbd+5kurHn/ori/KMSzZiF8Yk/UqWy1qtnmpIVLXRXme2+Ew0NNugD3fB0t2UJZrignj88Da34WJinpEWE7p4YhGsnOVtDm+FrMFpfCaLKJX5JITddxpFSNEDvJEXD2xXARV9W6MDOpl8xk3nxHKtMnvv4y2gs4IY1VxedRsPfIKfWC5MPp75I0Yh0J8tZWcXL/sTWvWw9G1etLp7oOH8OAjj6O4rBYMw6K4rBYPPvI4dh88pMQwJSPexh2aJEpgSclMcSX8OsMlc7+8mo/a9nev3blQTMaGtHAvsqq1UeT2tIEOh9IuIJLuVgpQFFw1W2AZH4Judkrp0SRFpo6xxIzXbQXAR816DnxCtPPWNS7g4jkzOluN2LlP+nrGLWf4iNqmbfMAZPyCRiKwdzVjITcfnhy7fNfNkDJTZbUIarTR7Pz1YBigqNSLoX4dgkE+0VQORgZ1cC+y2LF3krjOYMuLwis9lrsPHsLug4dgNGqxuJh+ZdqA+CPGNMU3TfAFyPCHRxgGrprNKLpwHJrFOfiNFmRbg8i2BtDXpZdlDGpv7OGIMffVTNJWCpVEjAE+iFVy5n3Yu5oxuPMapYeTMOq50yplorIeYYaNO2oWL3WN8vmM/T4KnReNKC7zINsq75accWIMhpnJTP1iFRLmOExUNsDa3wnW64nrMyUVHgQD9CUNLKRmuJ+/luBxJgl7VzPc2blYtOUpPRRFSCSDn7SI2mrJ12VVbsxMaTAzLf2qr0vljT3sSzaUdMstSVbgqsVjDFza6EONZISxxIS0ekyW1yK356Kodf3k9Bl3tJoQ8NNo3C6/jWJ5K7lR9mtnSB1nbRPocBi5cdbyLi7jxelgr4zCeICP4BWVkWWjMEw5YZoc5wUWaaFsmUhE7JKXgMc3+ljptYzaKbqkt1N0txlhMAZRUEzWvI4XR1czPJYczOcVKT0U0aAoKgUrhXrkmkvlraHVc6dVjLO2CUwwgNzeNtHOudJnPD8r7Qvh4jk+Kt2ooL843aIGG4Vlj318D8iSCv4lPtgnz3YzsCJiTJi/ONPUJjGxG68fWS5cqySfllUJlVeknd9zMyycY1pU1rpVWeFSNzsFs3OEn/tptCjkWBp0kr8PaTsisfCZszFbUMo/w+Is10kSKvzKqI9xicqXCHaKjlZp7RS9XQZQdAQVtfJ71exdzYhQFCaqNsl+7QypE22PG2fkQIgYD8kpjAd0yLYGyKtfnGmDnpCVgrSsfU+2DfOOQn47ealcZ9lSW+Y+iSPG3e38+dXa2EPYgk+3uZ/KroZWRVYKgLdTaN0LyBrpV3ooCUPWkyRNiW6pSeQz7miRThiHQ8Bgrx4FxV5otfK2FKVCQdi7WjBdUoWAXt5mJumC1aIDwyj3NV+05WHB6kBe+/m4annrDWE4CvwY7NOLWfp77fEtMJie1KColDx/sbAFP1G9cReFarZSALw40M3PwDw+BAAwW0KwOXzo75Z2fne3qTvxLlq7Ps0S71KxQ3AcTVTllfVItFwnSWSEsQzM5xXDY8mBo13cCSL4jNsl9BmPjWjh8zIoq5RfOFj7O8H5vBhfWlhkSJxCmxF6hbeYnbVNCdXyLqv0YWGOxawMCUojA7yNgrQybQiHYe9qwUxhOfxGi9KjUYyEIsaEWSmAlSULL7VTzM9xmHJJV5u3q90Imo6gooa8BV88OKKJd+mVW5LK4o2mKHCseiSbs1bwGauvnrF67rKaoSg4a5tgnhiFYcop2mlZLoKqOjdGBqTzGQs1NwVvnJzktZ0DsFzyLkPiFOYaoNcqW5Ux0VrepZVLPuNe6e0Uw4IwJizxLnu4FxrPYvTlshFhGBpsArsdREaMYyTg9UlUzzjgpzDQrUdJhQdanfr8ncKicLagFD5zltKjEZVUfcIaFQnjqbI6BDmNKhPw1HOXVU40ciDy6qlWYp/xQA8vTgRvnJzkdfDC2JkRxkmRbdLCoOOg0ygtjBOzEpVV8jV55UjAExLvSIsYRz2WabaVnAi6BEUEicJ4srwOIZa9JGJcLiTgSeQz7u/RIxikVWujyBodgHZxPi0bOmlTFLZqSsALcxwmK+th7e8E41PXzkVGGMtEVBy0nxP1vHWbeWHc2SqNnaKvm0+8U6LGq6P9PLymLMwWlsl+7XSgMJefEwatsg/TaC3vOBt9CBFjORLwhgb0oOkIcSWt8tozuyWJWiNIFA0hjRaTFfWw9bWD8fMLvtJKIWIszfwW6hertePdcjWW9FsUalK0+6ipZBvAL+zpcAj27otKDyUh1HWXVYyruhFhmhY9Aa+0wgOaiUiyLccn3ukUSbzTT0/A4hyGs64prcr1yIkgjHUKWymEWt62nra4annnOoIwGIMY7JO2lnEkwnuMHQU+cBp55/d65LWfg19nwHRptdJDUYxEI8AkRowBXhwwwSBsS+U6DcYw8gq96O82SFLJqlvljT2Erfd0q0gBpF5ZQo2VKYD4qxKRQkYYy0RAb8R0STXs3a2gggHRzqvRRlBU6sVgrx4hkatNjY1o4fcx0a0/ORH8qJnEu+SwGDUw6fnkHqU9xgD/gGQDftj62tc9lqKA4nIvnKNa+LzSPaKmJjh43AxxNgrt/CxyhnrgqtmCCKP8304pEhW6HEuDoclbRK+WgFde7YHHzcA1phH1WpEI3wramutHjk2894yc5LWfQ5DTYLKiTumhiE7qEWN1CeNoLe+MMM6wFs7aLWD9Xtj6O0U9b1mVGwE/jdFBcSNsQuKdsPUnJ4LlJOMvTo5C27K1hghhnKDPuKTcg0iEiibHScFy4h1Z/jdBQG1kGwWQXJUJEqPG0bJVK/JLhJyNfpF3+pyjGizMsaq1UbAeN6z9HZiobkSYE3fRQAKpzk+1WSnmHYVwZ1lV1xpaXXdZ5YxHxYHYZdukyXIWujMpUpGi/RzCNJ2W22lyUJC7QhgTUMZqtahZLErKhdbQ0vmMh/uXWkETFjGO+ovrN7gwTkJEpBqRk4Jouc5LIsbSNProitoo1CmMHZ0XQIfDabsoTLWqhEZlVgpQFFw1W2CaHBe1IpfUZISxjEjV6GM5y1lcEdHfYwCtQOIdHQggt7sVU2U1COql7RCVjpj0HLKMy9EWDcco2uQDAObyS+A1Z8c994vLhQQ8OSLGZApjYTGxUUmmkx2JEWNQFJw1W2B2jUI/PQEAKCn3gqIjoreG7m4XGnuo01+c7kmnGy1iDCBaXURN9YzVd5dVzGxhGXxGs+gR46JSL1g2LGrEWMnEO1tfG9iAX/SHo9UibTIXKRTmXlmhxKC0nYKi4KzZDItzGLrZqXUPLyjxgmYikpZsG+7XQasLIdexfkKgXPDdHpsxVVK1oRt7AOljpQAAV+2lXkutLozCYi8GevUIi5gb0t1mhFYXIs4eFC/pLIw5lgadogee1Pkdi2gCnorsFBlhLCc0DWdtE7LGBuMSB/HCchEUl3sx1K9DICBO8snYMJ94p5SNAgCcteI+HEsc0rXOJokC25XCOJEOYlKRyI4Jx0VQWOzF8IBOVOEgEAzyyaUFJV7QBD0Frf1d4LyetBQGiZKMCCBVOIxH2+Muz/2yag98XgZjw1pRruFepDE2rEV5tRsMmbchNuEwHO3nMFtQCm+WVenRiI4Yc1NtyXcAX5ErQlFxl+skAYJeCRsDqRp9lFW5EQrS0Ra3qdLfo2TinZB8JF5FCqOOg9UszguIZAw6Djmr/J5kJOAl5jMuLueFg2tc/CSc8REdQkEaxcT5i88CAF+mcIOTzGKOVGG8LA6WhXF5lbg+474uAyIRChU16rRR5Az1QOtewFj9NqWHIgliiFo1db4TCBjNmCmq4CtyhYJKDycu1HeXVY6zRppGH0JkV6yi8YL3rbxamYixO8uK+bxi0c5ptehg0HGinY9UCnNXf8kSkYBXvfkKcRALKRPwSO14t7yVnJ7iIF4YmgKXRKIRqR5MQRzkdrWAWqqrKXZr6N5O/jyVteoUxnlt/KIwXXdLxFi0cSwNWoV1/cfrt4LzemDr61B6KHFB5lMkjXHWCkZ0sRPwxC3/09+9lHgns1fNODkO0+Q4v+0u4gPAlqUFx9Kq3IpKhMJVbBQAoNcpHzGORg46m6PiIBZCAp4UPmOSE+8y3R6TFxHJ+JLlwlnbBI3XjeyhHgD83GPYsGjBjN4O/tmv1ojx8m5JRhivBUVR4Ahd/MVirH47ACDv4hmFRxIf6rvDKsdvtGC6uDJucRAvBSVecJqwKMI4HAIG+/jEO43MiXdS1S8WEu8UT0KTEL2WXdVGAQB6DRm/9+XiIBZCNRRJhHE0YkxOkpJhygmzc4SPmKkwKiQmyZZdI9VKAQDjS1YiYVeA4yIoLvNiqE+PYIq5IZEIHzG22f3IylHHdvXl5LWdg89oxnRxpdJDkQSxdjNUV7INwFgDL4zzl3YFSCcjjBXAWbsFGq8bOYPdop2TYYCSCg+GB3Tw+1J7yEYT7xSyUQDibqdpOQYWA+9TNRAQOZWKApsR1BqCSum20ALjCfiMzZYQcmx+SUq2DQ/oYckOwJwlQWZfkkS99Ru8fjEA6JKNGJMsjJe8s/kromblVW4EAzSGU2zONDGuwfwcp9posX5mElljg3ytf5KyYUVErLlJql0oFvN5xXBn5/J2mYi8wbZkUN8dTgOkavRRXuVGOERhqD+1CJvgeStTKPEuzLBwVW0S7Zw5luUoajpHjAtta+8WGLRkCAahMkVe3Al4XsxMaTA/K974PW4aky4Nef7iTMe7KElbKQgWxjNFFfCaspDftiyMy0SqQS/4iytqVNrYQ9gpTNPEO0C8ihIkz/E1oSiMNWyDcdoF8/iw0qNZl4wwVoBo2SqRfcbRBLwUH7IDPcp0vGP8PuT2XsRERR1CWvGihLmW5ftBgtdWCrQaBraste8ZxzJgFW7yAQAzxZXw643Ia4sv+bREAjuFULmFOGHcfhZhmoGrulHpoShOsl5hmqbAkZq5T9MYa9gOs3MExslxAOIl4Kk+8W5JGI+lcdJpMg1rVkONVgpg2We8cmFIKoQ+QdIbQRwIW6diITxkU/UZK5V4l9vTCiYYjC4cxMK6ASLGZr1mTRuFAAkl2yIMg/G6rcge6YurlrfgM051F2QlQ9HEO3L8xYzfh9zui5isqENIK11TE7WQSlRMR4iffjUEO4WQhCRWbkhPhwE0E0FJBTlzOhHy2pYWhUtd0tIRsSLGarRSACvmvgp8xuq8wyonwjBwVW9GznAvNAtzop03r8AHrS6UUpvR0FLiXWGJEol34m8lMwyNbNMKYZymJdv0cVgl4jlGDqKJGHFkKC+XbBNvB2F4SWSTFDG29VwEEwxkbBRLpFJdgmThMLZpBwAg/+JpAOLkhgQCFAZ79Sgp98j+zBYDOuCHvbsVkxV1COrSd1EonseYjOd4okxW1CGg08f13Fcacp8gaY7wAhRK1IgBzQCllR6MDuvg9ST3px0b1sHvY1CqSMc78YVxjkl7SRvOdI0Yx5NcR0plirFNOwEsi4NY2PP90OpCGBLRSjE8oANFRVBQQo4wTudWuMmQiogg2YM5UdGAoEaH/IvLz/1Uc0OG+nQIBmnVJt7ldrduiEWhaMKYVKvQOkQYFs6aJr6Ry/yM0sOJiTrvcBowuhQ5KGhdXxwkQnmVG5EwlbQnM9rYo0rmh2wkgrz2c1i02rGYmy/aaW2WS8uXcSxN9IszWeLpEkZKZQpXdSNCLIf8OOY+TfP1XkeHdAj4Uy9hFonwwtie74eWoOhaRhhfSroK4zDHwVmzGdaBTmgW+d1CIZdD8AknSk8HX7tcrcJ4I8x9jqUvCdCkAsnzez3GGgQ7hbgNzsQmI4wVwlm3FWGGjUscJEI0yzlJO4WQeFdaKW/E2OQagWFmAuO14tZwta6SkJaOCXjxRINJsVKENFq4ajbD1tcOzr2w7vEl5R6EwxRGUixpBQAzUyzcCyxR9YuFReGC1SHqolDNpGKlIF04jDVsBxWJRMVBdT1fSaK92ZTU+ZYT79RZkSIqjDMVKWQ/l9xEG30Q7jPOCGOFCOr0cFU2wN7dCtYr3ku6bCnS29eVXPShT6HEuzwJGnvQFAWr+UoxlY52ingS60hIvhMYbdgOOhyO2mdiUVohXmvo4YElfzFBHe/MzhEYZib5ub/BG3sA/Pc2le1ikrvfAVd67O35fjjyfWi7YEIwid4cPR0GGExBOAr8Yg5THiIR5LWdxYItL60XhWIu1kj20K+Hq3YLwjRDfGUK9d7hNGBs0w7QoaCo9YwdBX7oDckl4IVCvPgoLJU/8W7ZXyxeRQqLUbNq6aZ0bPIRj5WCFI8xAIw1XJqEFAsh035ADGHcT16pNsdSnkGmsQePhmPWrbCy3udJxlnbhDBNXyIONm2bh9fDoLdj9ZbuazE/y2BiXIuKGrcq11Tm8SEYZqfSOloMiCtm1eoxBoCA3ojJ8lrYu1rA+H1KD2dN1HuH04BoElLrKdHOSVF81Hh8RAf3YmJ/3rFhHQJ+WpnGHh3nEWI5TFQ2iHZOoQ305Ri06VWZgqao+IQxIVYKgPcTRigqrgzlolIvaDoiUsSYnxNy74jEYiN4LBMh1YivWPVipSJgMGGqrBb2zuaoOGjcNg8AaDlrTuhcvV0qr1/ctjHmvlbE2sMcy4jmV1aC8fptYIIB5Ha3Kj2UNSH7CZLmjNVvQ4SiJEjAW4qw9SQmJITuS3I39mA9bth62zFR1YAwpxHtvJcn3gmkW8RYq4kvwsaxDDHNDwJGMx856LwAOhB7C5jTRJBf7MVQvw7hcGrXHR7Qg9OEYc8jZ9s5r/0cghotJsvrlR4KESTbDlqAdI8xwNspVoqDus0LYNhw4sJY5Yl3+cJuSZoLY43I9h61NvkAEivXqRRkvCU3KH6TBVOlNXB0XgAdCIh23rIkG3309/DHy514l992FnQ4hNFNV4l63rUjxukljBPxDpPU/GCsYQfYgB/27pZ1jy0p98DnZeAaS37hFAoBo0NaFJZ4QRPyXuE8i7D2d2KiahPCXHrtZCRLqlYItQhjYFkc6PRhVNW5MdCjT6j9eY/QCrpancLY0XYOAa0Ok+W1Sg9FUsSek2r2Gauh0UdSd9fr9eIrX/kK7r33Xjz00EOYmrqyg9Vjjz2Gu+66C/fddx/uu+8+zM/PpzzYdGRs0w6wfh9y4xAH8SIk4CUqjNubjWC5sOzbzAUtJwEAo43iCWOjjltTMKZbxDgeG4UASXaKaLODOHZMSqM+4+Q7hDlHtQgGaKL8xfbOZtDhcNpHzBIhkfm8GmKWxpKKZWG8PPcbt80jEqHQej6+qHE4DPR1GpBX6IXRHJJknFKiWZyDdbALrurNiLDpvSgU2xes5oix2+rAXF4x38Mh1S1AiUjqr/XCCy+gtrYW//mf/4lPfepT+P73v3/FMS0tLXjqqafw/PPP4/nnn4fZnNgW0UZBinrGNnsARnMQfQkk4A316zAyqMeWHXOyJ94VtJxEmGYwJmICxlrRYgBgGZr4zPVESCQKTGQCXhxzv6Qi9Q54grVIaDNNAkJ+gZhzX+2kGl2jKIp44eDJsWM2v4SPmi2JA8Fn3BqnnWJ8RAuPm1GtjcLR0QwqEtkQi0Kx3zdqjhgDfNRYtzCHnKEepYeyKknd3VOnTuHqq68GAFxzzTX48MMPL/n3cDiM/v5+fPOb38TnPvc5/PznP099pGnKsjgQNwGvvMqNiXEtFubj+0KeOJYNANh1UN6ONKzHDXt3K1zVjQjqk48GXk7uKvWLV5JOdopEosAklWzzZNswW1CK/PZzoEKxI14l5XyUN5UEPKHeK0lCorD5JCIUFY2eZxBHRKhh4TvWsB1a9wKsA10A+AWbOSuAlrNmROKITfR2kDefE2G5Gkv6LwrFXqiRXnllPcYIt1Os+5b82c9+hueee+6Sn9lstmgE2Gg0XmGTcLvd+PznP48HHngAoVAI999/PzZv3oz6+rWTS3JyDGAVWOWPzfmACTeMxtUTtSTHWIS5onIUtJ+FScciwohzD2oa/Gg5C4wPW5C3M/aDMxIBTn6QA50+hH3X+KDRrn8vxLpf+W0nQYeCmNi2W9S/QU2FDVmmtc+X7zDDL+MujpTzqzA/C3Z7fFGmWV8Ig5PkvEgntlyFqjdeRqGrHzNVyxVJLr9fRiOQ6whgsM8Ag0GbVGmq/m4TGDaC+s1haDQKfd9XwHg9cHRewHRVAziHHalsJiv2/JKAgjwL7LmJlS27nFyrEcEY4pKE+zW9dRfwzq9Q2nMBvsYtAICtV7lx7O0sTDotKKuMXc5qoJf/zjduDUj++0hx/qJOvkTnwvariPh7iMnlv09RQRaMevHsIo4ZL1xz5JY7W4/ZHXsAAMVd/ByI9/0lF+sK48OHD+Pw4cOX/Ozhhx/G4iLfZWdxcREWi+WSf9fr9bj//vuh1/PRnb1796KtrS2mMJ6eVuZlPTvDX3dxUblJNtKwHfVv/QLa1guYFKlcWWHpPIBctLdwqKqP/bv1dBjgGtNgzzVTCAS9CKxTZN5o1Ip2v3JOfQAAGKjdLto5tRwDv8cPl2ftygNBX1C2v7mY92s1PAteuFzxKUWv26foXL+cwZqtqHrjZWSf/hjD+ZUA1r5fxeVunD2ehZHhELJzEuuEEAhQ6O/WorjMg0DACxFzXZOm8PwJMMEAhjZdldLfROr5JTeL8x64IqmtWv1e/5r3hJT7NVDVhL0Acs6ewOINnwEA1G2ewbG3s3DyQy1y8+Zifr7zog6cJgyrYw6LEja9k+J+0QE/clvPYLKsFtO0HiDg7yEWq92vuVk33Avi2R88i2Q9xxNl0VoErykLtgun4AXgcimTg7aWIE/qL7Vjxw68++67AID33nsPO3fuvOTf+/r6cO+99yIUCiEQCOD06dNobGxM5lIbgtEG/v4ViGinEBLwOlvXj7wcP8rbKHbLbKMAgMIlf7GY22mx/MUC6ZSAp0vAHkGSlQJILAEv6jNOsAwhwFswgkGaqG3nwuYTAICRzeJWY1E7YlROUUNlitmCUngsOXwC3pJ3omEr3yJ9PZ+xz0tjuF+H0goPWLK+0nHh6DgP1u/bEHOfZWiwjMjJdyqY3zGhaYzXb4PFOQx6ZETp0VxBUn+te+65B52dnbjnnnvw05/+FA8//DAA4Nlnn8Xbb7+Nqqoq3HHHHbj77rtx33334c4770RNTY2oA08nEhEH8ZJjC6KydhEtZy0xE5bCIeDkB9kwmoNo2Crvqo31emDvaoWrahMC+tS2Tldii0cYEyYQUyEhjzFByXcAMJ9XjMUc+yXiYC1S6YBHor+4oPkEwjQdzTPIADA0JYo/WBXCgaIw1rAdpiknTC5eHFiygiitdKProhE+79qv5/5uPcJhCpW1EoaKJaTwwnEAwMiW3QqPRHqkWKSpPfkOAMYa+GAYd/zDdY6Un6Turl6vx/e+9z288MIL+NGPfgS73Q4AeOCBB3DjjTcCAB566CG89NJL+MlPfoJ77rlHvBGnIQuOQizk5vM1LePJuoiTT949DgD4r58CLmieAAAgAElEQVTlrXlMe4sJczMcdu6bkT3ykNd+FnQoKGqZNgCwGNf3cunTJGKs5RgwdPxfY46liWnyASAqDgwzk7CMDsQ8VCjZNtiXvDAmRUiwXg8cXS2YqGxAwGBSejjEkMjuRyzUEDEGVpZtW05Catw2j2CQRnvL2sECEhd6iVDYfJJfFG6ApFMpRCzpVVfiQdgl5j5KE2GcQXxGN+2Afm4a2cO9op2zcds8KmsXcebj7DWjxkpVowCAgual+sUib6fFYxdIl4hxMjVfibVTrNMJKccWgNEUTKoyRW+nAQZTEI4CMjre5bWd4ReFm3cpPRSiEGtHQw1VKYDV6xlviqNsm5qFMev1wNF5HhOVDfAbLet/QOVIsUgjve15PLiqGhHkNOkTMc4gPonUdI0XigLuWIoav/pi/hX/HghQOP1RFrKtftQ0yB9JK5DAXwzEJ/xYhiaqC1yyJBNhI81OEZ37F2PPfYri7RSuMS3ci/E/uubnGLjGtKiodidVzUIKCpcWhSMZYXwJYjWgUUvEeLKiHgGd/pJFYVWtG1pdaM320LPTLDpaTbBkB2C1E5BFmiB5bWfABDfOolAKW48qrELrEOY0mKhuBHvhPOAma4GXEcaEMLpJ/AQ8gI8+VNYt4uzxrGiDA4GWs2a4F1nsOjCDBHbjRSG6lVzVIKq/WKth4k50SIcEvGREro6g7ncAMFVaDZ/RvG7EGFj2GQ/3xx817iMwusb7ixmM1W9XeihEIdZuhlqEcYRh4axpQs5QD7Tz/K4dy0VQv2UB4yM6TIxf2gJ9bpbFE39dhYU5FtcdmiBmoZcIy4vC9PcXA9LMRZahwYic0KcE5++4D75PfwbQJd+4SQrUf2fThNmicj5DueWUqD5jPmo8BgB49cVLvcYnjipno5DKX5zIizUd7BTJRNhIixgLGcpZY4PQT7tiHlqaRAIeadvOnGdRkqY26YBowlijnlfb2CZ+cbSy2YHQBW9l1Hh+lsETf1WJ0SEdbvqkC7d/1invQEWisPk4wgwbtZGkO1IlyondZloJ+vfcgLl/+3fIHplbB7JGs5GhKIxu2gnTlBNmp7jlSzZtXUBV3SLOnViOGvu8NM6dtMCR70NZlfwtcgV/8YjIwjgRsZsOCXjJ2EFI8xgDy3aK9VqjL7eGTlwYlxMijPMungEdDm2IUlWJkoxnfjUYmrAk0xgIc1+IpALLPmNBGM/PMXjir6swMqjHDbe5cPgLI6qMFnOL88jtboWzZjOCuuS7WKoJqXYv0sFOQSrqeHJsEJbLtolrp6Ao4I7fvTRqfO6EBX4fg10HpxV5wBa0npLEX5yIME6HiHEytgixfJxiMiokIa0jjPMKfeA04bgrU0QiQG+XAfZ8H8yW2G2n5UKoX7xRPJaJIOZ3Ui3CYbxuK4IaLQrPfxz9mSPfD3u+D20XTJibYfHkt6owPKDHdYcm8LtfVKcoBoCCi2dAh8MbxkYBSCiMVbLwUyOZO0sQo3Fm5ydDQ9MCqur5qHF/jx7Hl6pR7L5afhsFX7+4mfcXi1yqKiErRRpEjJPzGJP3e09UNSKo0a4rjBkGKCrzYGRQi2BgfXXgHNXAvcASY6MAeGEcYlmM14m7KEwHxJybavEZhzRajDVsh22g8xIrUeO2eXg9DB77eg2G+vS49pYJ3PPgsGpFMbCyfvHGWRRKtUBTy/xWIxlhTBDTpTXwGUyiJ+ABl3qNf/bvhWg5a0ZxuQcFxfK3lXS0n+OzkjftXP/gBElE7KZDxDiZ6C+Jv3eY4zBetw22gU7opidiHlta4UEoSGNkcP2EjZ4OPrGTFGHMLc7D1tsGV/XG2UqOF4ahRX3Zq0k4DG3dBwAoOrccNRbsFDNTGlx90yTueUjdohjg/cVBTgNnbZPSQ5ENqUqrpUOTD1LJ3FmCiDC8tSBrdGDdJKRkaGhaQHXDAjpaTAgFaew+OC36NeKhsGWpfrHI/mIg8YgxpeI3DcvQ4JIo9M5/jryv/tA2Xhzkn/4g5nEl5V4AwGDf+sKYtMS75a3kjRMxixe9yLWH1SSMh7fuBQAUn/8o+rOGLQsoKPbiukMT+L3/MURaflLCaOdnYOvrwHj9NoQ0WqWHIxtSRYzTockHqaj8q5Z+jDbyUVRhy0lMVtY1BoBdB+S3UQBC/WJakqzkRIQxQ4sboZKbVBKVSEzAE4RxwaljMY9LJAGvt9MAhg2jpFz+BNPVKMj4i9dE7DmppiYIU6U1cGfbUHTuo2hVIq0ujG/9czvufWhY9aIYWJFwvYHmPsPQcZcPTRS1eOjVSBp83dILYUut5Kw03WDqtyxg77VTOHjjJGwO+YvDM74lf7EErXDZJLZi1ewzTkVIkCiMp8pq4c7ORf6ZD4FweM3jiso8oOjIuiXbAn4KQ/06lJR7wWnEK4GYCgUtJxFiOYxvoK3keBG74Y6WtLKEsaBpDDftgWFmAjkDXUqPRhIKm5f8xRtIGGsl3JnLWCmkI3NnCWOqvA7u7FwUnYstDpKFooAvfnUQ9//RkOjnjoe89vO8v1hhG4UAiX7beElFSBBXyxgAKApD2/ZCPz0Ba3/HmodptRHkF/ow1KeP+RUZ6NUjFKSJsVFoFuaQ29sGZ20TQlqyCtqTgNjVUkisvhKL4aYlO8U58lrkikHhhRMI6PRwVTcqPRTZ0EjYmjwTMZaOjDAmDYrC0LZ9MMxMwta3tjhQKwUS+ouTEblqjhin0sGOVNEg7JisJw5KKjzwepgrOoOtZNlfLH+789UoaD0FKhLJ1C9eA7F3MQw6TtTzSY3gMy4699E6R6oP/bQLOcO9GG3YgQirrr9LKkhp1ZMyGr3RydxZAhncfgAAUHz2fYVHIj6FUvqLkxC5ahbGqUR9xd62FothQRivYyUSPMOx7BS9HYQl3i35izfSVnIiiC6MVbYb5LY6MFVShYLW02D88lcLkpKNWrtbygS5TMRYOjLCmECGt+5FhKJQciZ2dr7aYHwe2DsvYLKiXnR/MZBkxFhlL8+VpBL1JbXrnzfLiqmqBuRfPAPWu3bCXDwJeL2dBhhNQTgK/KKPMxkKW04iyGngqtmi9FCIROyqFByrvuTa4a37wPq9l7SHTgcKLywtCrdsnMYegLStyTMeY+nI3FkC8Zmz4azejLz2c+AW55UejmgUNp8EEwxK9nBMymOssu3WlaTmMSZXMIzuPAgmGIjablZjPWE8P8tgwqlFeY2biNqvQqkqZ93WDVWqKhGkSAgldQG4FkNpaqcobD4Bn9GMyfK6uI436dX7XF6JlBFjNbU9VxuZu0ooQ9v3gw4FUbS0BZUOlJ56DwAwsONqSc6fbMRYrbWM061cm8DozoMAgOKza++YmC0h5Nj8a1opiKtf3MI37cnYKFaHYWhJtobVtiM0tmknQiyHovPpI4xNzmFYxocwumknIkx8f+OqoiyJRyUPUu9YqDmwQzIZYUwoQ4LP+Eya+IwjEZScOgaf0Yzx+q2SXCIZsUfTlOq2WwGApqiUhDErkRARg4lN2xDQ6deNmpVUeDA3w6Gz1XjFv/V2ktXxTvhdMsJ4daTawVBbDkFQp8d4/TbYey5CNzul9HBEQfAXx7tTqNeyKMw1qjZgsRKp7Q5qW/iphYwwJhRXVSO8JguKz3wQLfiuZnIGu2GeGMXgtgOIMOJ/mWmKSrpKg1FlL0+Ajxan+uIg9aEa5jQYadyFnOFeGF2jax531X6+Qc13v1mF5/+1GAvzy3//HpIixpEISk+9B6/JAmdtxl+8GlLtYBhVGFET7BRCk6fjx17Htx45jD88vBPfeuQwjh97XcnhJUyh0NgjTmFsNnDQcgxyzOq3HEkddFHju0sNZIQxoUQYBsNb98E8MYrs4V5RzqnkA7b0JG+jGNwpjY1Cp2VBJykU1RZVAvjfN1WMBPv4hretX7Zt77Uz+JNvd6GgxIujb9nwl1+px9G3rAiHgL5OAxz5PpjMIbmGvCa23naYJscxuOOgJIvCdEAqYUzq4i8Wy/WMP8LxY6/jqScfxfBAJ8LhEIYHOvHUk4+qRxxHIii88DE8lhxMl1TF9RGTni/BmJezfmdL0tFKnMuRsVJIQ0YYE8zgtv0AxLFTKP2ALT19FGGaxuD2/ZKcP5UKDWp8eaZioxAgOdowJMz9GD5jAKhtXMRf/EMHDv/+MIIBCs//awm+/bVaeNwMKmoJiBYDKD35LgBg4KprFR4JuUhlpVBb8h0ATFbUw2vORtG5D/Haz59a9ZjXX35G5lElR253K4xTLt4aGGfgwmzgxZ4jxyDl0GRByuQ7gOxnuJrJCGOCEaJmYpRte+2lp1f9uRwPWO38LBzt5+Cs2QKfJUeSa6QibtW46hYjwkbyNvNsQSnmHYUoOv8xqFAw5rEsC9z8OxP49vfacNWBaYwM8pEmImwUAMpOvosww0YXuhmuRIwdkNVQ46I3wjAY3rIbpslxWIZ6Vj1mZI2fk0bZCX5R2Lfrurg/Y17ayco2aYittx4PDE1JXjVCjbudaiAjjAnGbXVgsqwW+RdPg/F5UzrXqIIP2OKz74MOhyWzUQCpvQDVuOoWo6WzUU/w701RGNq6D9rFedi7W+P6SI4tiD/44wE88lfduO7QBPZeq3zykmHKCXt3K0Y37UDAaFZ6OMQilYBlGVqV4kpodPOZbNuq/15YXCnncJKm7MQRBDlNdAcoHswG3kpBURQcKrZTyJHcbNCpt6oSyWSEMeEMbd8P1u9DQeuplM5TsMaDVI4HbOmpowCAgZ3XSHaNVLZMSfbaroU4Vgqyf+947RSX09C0gHsfGobBGJZiWAlRIsz9q6Sb++mAVBFjQJ1RNSEB77NrCONDd31RzuEkhXl8GLb+Doxs2Y2gPj5bhIZjLvHlqlkYy1HtiKFpUd4FGS4lI4wJZ3CbOGXbbv3Ml1b9udQPWCoURPGZ97Fgy8NUWY1k10nFWqDXsmAZdX0Vkq3AsRK9lgVD8O89smUXwjSDonXaQ5NM2VLSaX/GXxwTKRvOqNFOsWgvwExhGRpGB/A/vvq3KC6rBc2wKC6rxYOPPI7dBw8pPcR1KT1xBADQn4SNQiAvR590UrXSyNWZTo0LP9LJ3FHCGa/na7qWnPkAqZR8Fx6kr7/8DEaGelBYXIlDd31R8geso+MCdAtzaN3/ibiTL5Ih1ZefSc9hZsEn0mikR6wsfpOOxewiGS2TL8dvtMBZsxmOzmZoFufgN1qUHlJCMD4vis5/jOniSsznlyg9HGKRuqa2WoXD8NZ9aHztJ7jdXoCdT7yo9HASpiyadBr/bonJcKkw5li+bNvkXGpWQiWQqz6+UcdhclZ994dk1PnE2ECEOQ7DW/ag/MQRmMeHMZ9XlPS5dh88JHukQbBRSOkvBlIXimoTxmJtnxn1HLHCGODtFPnt51B4/jj69t2k9HASoujCcbB+b8ZGsQ5Sd2FUqzAe2roXja/9BEXnPsTYph1KDychNAtzKGg5BWfNZritjrg/J/iLV5JnNWSEcQzUuCNCOuTuo2aIkqzXkgRKT72HoEaL4S3SdfzSckzKVgg1JeBpOQYMLc5Xl3SfcTz1jElFKNOWsVHERmqPpFqFw+jmXQhyGpQdP6L0UBKm5PRR0OFQQjYK4EorBaDeesZydRZV68KPZDLCWAUMiVjPWE5MzhFYB7owsnkXQlrpHm5i1CpVUwKemIlKRFemAN8B0mc084tCNXWAFLrdmbPhrG1SejREI7VwVWM5RgAI6I0Y2rYftoFOZA2J0+RJLoQybQkLY8OVf6ssk1byXQUpkEuwkh7cUCMZYawC5vOLMVNYhsILx0EHAkoPJ25KTgvVKKS1UYjxYjWpSBiLmahE+kM1wjAY2rYfZtcorH3tSg8nbnJ7LsI45VrqdpfJGo+FlBUpAP75oNaSVr37bgYAVH74psIjiR864EfJmfcxl1ccd7c7AGAYek0BrMbqFKtFv6UgEzEWn4wwVglD2/ZD43Ujr+2s0kOJm6i/eAfZ/mJAXcJY1Igx4cIYAHr23wIAqHr/DYVHEj/LNoqMv3g9UulaGQ80Tam2pFX/rmsR5DSo/EA9c7+w+SQ0nkU+WpzAgsSs59ZcwOSprAseRVGy7UKSXl1IjWTupkoQxGX58d8qPJL4YHweFDafwFRpNRYchZJeS4yIsYZjZEuWSBUxI8Z6LQOGJjuaNrj9APx6I6ref101dorSk+8hxLIJNTbYqIjRrGY91OozDhhMGNq2H9aBLtXYKcpOvAMA6Nt9XUKfixWcsGfrQRP+nFqJ3CVA1Tq/SSUjjFXC8JZd8FhyUPnBG+u2yCWBogsnwPp9GJA4WgyIl9WuFp+xmJ28KIoi3oMZ0urQv+s6mJ0jsHc2Kz2cdTFMjsPecxGjm3YiYDApPRzikcM/Svocj0XPfhXZKSIRlJ54F15TFsbrtyX00dX8xQIcS8Nm0aU6OtmQy0YhoKbkcTWQEcYqIcJy6Nl/MwwzkyhsPqH0cNZFzo5fogljlbw8xd56Jj0BDwC6D34CAPioMeFEOz1mqlHEhdRWCkDdPsyBq9Rjp8jtuQjTlBODO69GhEnsnptWKdW2EjXZKS6vxyw1al74kUhGGKuI7qtvBQBUv/cbhUeyDpEISk8fhddkgbN2i+SXE2sbyaQCgQiIn6xkUsFDdbhpH7wmCy8Owsq3eo7FcmODjDBeD46lwbEyCGMVbzWvtFNkD/UoPZyYCKXl+hKsRgHEjhgDgMOqngQ8uXNWMhFjcckIYxUxXrsV8/YClH/8WzA+cgueW/s7YJoYw9C2/QlHDRKFYWhoRfLcqiUBT+z2uWqwkIQ5Dn17boRxyoX8i2eUHs6aMD4PCi8cx1RJVUrNeDYKYtqCYqF24SDYKSo+INtOUXbiCEIsl7C3nqaodRfoFoNGNbt6clsp1LwjQiIZYawmaBrdB2+FxrOI0qVSaCRS/e6vAQB9e26Q/FpiRoLUIIxZRvwIm1pEQ/eBte0Ux4+9jm89chh/eHgnvvXIYRw/pozlouj8x7y3XsJoMcfSsGfro//Lsxqi/19tyGGjANQvHKJ2CoJ9xibnMGz9HRjeshtBfWK2B6Oeiyu5zq6Ssm0ZK4W6yQhjldG1ZKeoOvqawiNZHSoYQM17v4bXlJVwcfdkEPPFqobIqRSJSmr4vQFgdPNVcGdZUfHhW5ckoB4/9jqeevJRDA90IhwOYXigE089+agi4jja2EBCb709W48DWwqi/7txV2n0/6ulsoqAHBUpAN5+RKu0ljGgDjtFdO7vvj7hz8YblMgyxvYhkwDH0rLthAioJbihFjLCWGVMl9VgqrQapaeOQrM4p/RwrqDkzAcwzEyi++pbEeakf4gZtOKJOpaR/4GWKFLUY9VrWVWUQoowLHr33Qz93DQKLxyP/vy1l55e9fjXX35GrqEBAFiPG5UfvIGF3Hy4aqTz1ltiJCnJHalKFambewjQFCXbtaSCdDtF2YkjAJJLuF7PX5zocUpiUUC8syJaCjNkhLEq6br6NjDBACo+fFvpoVxB7Tu/AgC033CnLNcTeyuWdDuFFNFdmqJUk5zUE7VTLGfoj64RQRuRObJW+eEb0HgW0X7DnZJ2uzPHePHGEs0kIue8U3tUjeTqFLrZKRS0noazuhFuqyPhz8f73FXD/FZCGAPqqaqkBjLCWIVES1cdI8tOoZ2bRumpdzFZVovJinpZrim2tYB0YSzVVqJa7BRj9duwYHWg/OO3QQf8AICC4spVjy1c4+dSUffWLxChKHRcL+2i0BIjaqbUSzlZdDJ5jAF1V6YAVtgpBruRPdit9HAuofadV0CHgui65vakPm+OU/BqOIb4XT2LUavIddU+v0kiI4xVyIKjCGP121DYfAKGKafSw4lS/d5vwASD6LjhdxJqBZoKYifVkC6Ms03SPHRVE22gafQc+AS0i/MoPvshAODWz3xp1UMP3fVF2YaVPdiN/PZzGNq6T9JOjwwdu9WsGraaVyKXxxhQfwIeAPQc4NujE5WEFw6j/s2XEdTo0HntJxP+OEVRCc1b0ue4chFj9c9vUsgIY5XSdfWtoCIRVL7/30oPJUrdO68gzLDouvo22a4p9iqZ5GYXNEXBYpTmpUDy7305lzf72H3wEB585HEUl9WCZlgUl9XiwUcex+6Dh2QbU93bvwQAtN/0aUmvY9JzMZPI1LDVvBI5ut4JpEPmvmCnIMlnXHjhOLLGBtF94Bb4TZaEP6/XMAm1TyZ9V0Sp8aXD/CYF9bwNM1xC776bsf/pv0f10dfQfMd9Sg8Htp422Po60Lf7enizrLJcU4qEGpItBSYDB4aWZi2rhiYfAhNVjZjLK0bZiSNgfB6EtHrsPnhIViG8EjrgR827/wWPJQf9V10n6bXW23IWtpq9fvLbxvPNPeSLzaTDVnNAb8TQ9gMoP/4Osge7MVNSpfSQ0PDGzwEAF285nNTnE00YJXnxR1MUTAYNpjx+2a+diRiLRyZirFK8WVYMbd0Le3crskb6lR4Oat95BYB8SXcAX6FB7BJMJl3siJySZEnoXSN5QXAFFIXuA7eA83pQevqY0qNB2Ykj0M9No/O6OxDmpL2P8USjSN9qFpDbK5oOVgpguToFCXYK/bQL5SeOYLK8Fq6azUmdI15/8fLx5M5vg44Fo1CFn0zEWDwywljFdF3DWxaqjirbIpoO+FH93m/gzrJicPsB2a4rxTYsTVOybu8mQrZJukiJQWV1XnsO8NHhymPKW4nq3/oFAKD9xk9Jfq14RAHpW80CckdwdRpGFWUJ12PgqmsR1GhR/e6vQYVCio6l7u1fgg4FcfHmzyadV5JoXofZoAFF6LNKyXKJem16zG8SyAhjFdO/63oENTpUH30NiEQUG0fZyXehW5hF17WfRISV78EglYAlNQFPyuL2JC8IVmOqrAbTRRUoPX0UnHtBsXGYnMMoOv8Rxuq3YUaGKhjxRNdI3mpeiZwVKQA+yStd7BSd19yOrLFBlB1/R7FxUKEQ6t96GQGdPhqkSYZEI8AcSxP7rDLrlfvuUZS6nuEkkxHGKiaoN6Bv13XIGh1AbnerYuOo/S1vo+i4/ndkva5UW6Mk2gooikKWhBFjQF0JeKAodF17O1i/D/VvvazYMGp/+wqoSARtN0qbdAcADEPH5SMkeat5JXJWpBBIFzvFhd+5HxGKwtZX/l2xoEjx2Q9gdo2i6+CtCBhMSZ8nGTFJ6hxXOqiS8RmLQ0YYq5zupRbRQla83BimnCg++wGc1Y2YLq2W9dpSrY5JFIgGHQuOlTbCppqSbUtcvOUw/DoDml75ERi/T/brU6EQ6n77Cvx6I3r33yL59cwGLq4t5EQ9m0qhRHRLzE6ZSjJbVI7+q66Fo7MZ+a2nFRlD/ZsvAQDabvls0ufQckxSHdtI3RVRWrBnfMbikBHGKmdw+37M5RWj7re/hHFyXPbr17z7a9DhsORNDVZDqm1RpVf9qyGljUKAxEh5LHzmLFw8dDcMMxPRjotyUnTuQ5gmx9F99a0I6vSSXy9eMcCxtCosA2J3rYyHdIkYA8C5T30BAND0ynOyX9s4MYbSU+/BVbUJE1Wbkj5Pss9apQXoWij97shEjMUhI4xVToTlcOazD4IJBrD15WdkvngEtb99BUFOg24FSmVJJeSUfrithlSNPVaixofqhU9+HkFOg62/fBZUMCDrtYWku7ab7pLlegk1QVBBAp7YpRbjIZ2EsbN+G8bqtqLs1Huyd8Kre/sXoMNhXEwhWgwkv7tBYoKpVsNAw8m/2FtJJmIsDhlhnAZ0XnM75vKKUf/Wy7JGjR0d55E90oe+3TckVdg9FXQaVjIBa9CyxGX3Su0vBtQXMQYAT04u2m/8NMzOEVTJWKFCPzOJspPvYqKiDhOVDbJcM5HtY1K3mleiRFRbDZH0RDgvRI1/9SPZrkmFgqh76xfwG0zoPpBaQCTZKg7x2orkhIRa8GoMbpBIRhinAUpFjXe8+EMAQPvN8kTMVpKbpZPs3BRFEee3lcVKoWOJe9nEw/k7fx9hhsW2XzwDhMOyXLPmyKugQ0G03/hp2dqfJxJdI3WrWcCg4xLqdibeddNLOPRfdS1mCstR/d6vYZApKFJ66ihMU050XnMbgnpDSudKdp4ydHyJqHKiZKk2AdLuiVrJCOM0Qe6ocfGZ91Fy9gMMbd2Lkc27JL/e5dgkFMYAWQl4Og0rSzMEhqahTyIRRmkWHIXovOY25Az1oFyG8lWMz4tNr/0UQY1WtvbnHEsnJOpIT8CzS/z9XQudhgXDqG/xtyY0jfN33g8mGMTm37wgyyXrlzrdtd2cmo0CSK28GWl2CiVLtQlwrPJ2jnQgI4zTBDmjxlQoiD3PPYEIReHj+/9YtojZSqQWxiT5jOWwUQio0U4BAOc+/UVEKArbXnpK8vJVW3/5LMwTo2i+7V7ZLETJdAcjOfqfmy19suJakLDlLSZd19wOd7YNDW/8XPKa3lnDfSg5+wHG65owVV6b0rn0WjalCL6ZsGcVCRFjIP12RZQgI4zTiM5rbseco0jyqHHV6y/BOtiN9hs/lfLDMRm0GkZyDyVJwjhbxsgIaRaSeJktKkfv3ptg77mI4rMfSnYd89gQtv7iWSxa7Tjz2Ycku84V103wpcsyiUWY5UZKK9R6qHXxtxYhjRbNt98LjXshWkJNEiIRHPy3vwUVieD8nV9I+XQ2S2pzgLQEU1LeGWp9hpNERhinEXzU+CFJo8acewFNP/oeAjo9Tn7uy5JcYz1SfaDGA0lRpSwZKlIIkGQhSZSzd30JAPiosUTs/ffvgg348fH9f5yyvzIRklkIkpqAZzZoFO3QZSL0vqTCxVsOI6DTY/N//QfogDTVWWqOvIrC5hPov+pa9O2+PuXzWVN8jpM0vxmaIsbfm24JpkqQEcZpRue10kaNt/7iGehmp3D201+EJydX9PPHg9Q2CoCsqJKsVgqCFgSJMllZj4EdB1Fw8RBVRqoAACAASURBVLQkTQ+Kz7yP8hNHMLppp+zlCZOJjpGagKdktBhQ9xxfC7/JgrabPgPTlBNVx14T/fzauWnsfe4JBHR6vP/go6LY52yW1Bb8Jj1HTPUgo54c6xLJO0VqISOM0wwpo8Ym5wi2vPpjLObm48Idnxf13ImQmyW9P1GvZRXJmr8cDcfI+iInaUGQDGc/w0eNt778tKjnpQN+7H/6OwjTND740p/J7qu3JCFySYqorURJfzGg7l2RWFz45O8hTDPY9vIzYHxeUc+997knoJufwanf/SMs2gtSPh/H0iknz9E0RYx9gZRxAJnKFGKg/Js/g+hIFTXe9R/fAxvw49wDjyCkVeblpuGYpERCMpAgEuUo07YStZZsExiv346Rxp0oPfO+qFHjLf/1H8gaHUDrod+V3Vev5ZikqpKQ5sEE+FKISkeMc7P1qp7ja7FoL8DFWz6L7JE+HPj//k60JFTHuY9Re+RVTFTUo/n2e0Q5p9WiE+VvQMrij6REwEyTj9TJCOM0ZGXUeNd//IsoD0h7xwVUH3sdrqpN6Lv+kyKMMjmsFq1sLzUSogByC2OWoaFVebmfU5/7MsI0jRu/+ycwOYdTPp9hchzbf/5v8FhycOpz/1OEESZG0k0Q9BxowgSgxcApPr8MOg45Zvl8+3Ly8e//MVxVm1D3zq/QsFRWLRUYvw+7v/dXCNM0jv7hXyLCiBONFCtPhBS7EEm+dYOOJe57rzYywjhN6bz2dkyW16Lm3f/Cjhd/kNrJIhHs/ffvAgA++sKfALRy00YOG4WAiYAtKTkT7wRIedkky9imHfjwgT+FYXYKn/i7r4JbnE/pfHt+9CQ4rwcnfu+r8Bvl7fAIJB8Vo2mKiF2PlShtoxAosMmXOCknIY0Wb379H+Gx5GDfM9+Bo+N8Sufb+vLTsAz3o+XWz2GiulGkUYopjMkQpCQEUQRoilKk3Xo6kRHGaUqE5fDaX/xfzDmKsPPFH6Lx1/+Z9Llq33kF+e3n0LvnRoxt2iHiKBNHjooUAiSICjkT7wTyreoXDa23fQ7Nt90D62A3bnziz0CFgkmdJ7/lFKqPvQ5ndSPab7hT5FHGRypeTNIWOUrbKAQKbEalhyAZi/YC/PaRx0GFw7jxH/4E+pnJpM6TPdSDbb94Bu7cPJy6R7wKRAxNIdssznONlCYfpH3PUk1s3OhkhHEa48mx4zd/9QO4s3Ox/5m/R9V7v07sBJEItrzyHK75/rcQ0Olx/L7/Jc1A44RjaVmFotIPXYahFYlEFNmNabEV99EXvoaB7QdQcvYD7HvmHxL+vHlsCFf/4NsAgA8efFSxnZJUXrqkeDABPpIl545PLEx6TnabkpyMNO3ByXu/AtOUEzckszAMh3HwB4+BCQZx8o/+AgG9eAuJbJMWjEjfJaOOBaNwkjQpidorKbablB6CqiHrr5lBdObzS/DaX34fPqMZ1/3LN1Fy6r24PkcFA7j6B9/G3h89CXdOLl79m2cwV1Aq8WhjY7XoZBVs2Satolt1WUaNIgJVp2GRm01GZC8VIgyL3/7xdzBZWoPG13+KxgRa5pZ/9DY+/fXPIXukH+fu/H24arZIONLYpDIHSUrAyzJpwLHkvHLSOWoMAOc+9QX07rkRhS0nsfvH34v7c/rpCdz03a+j4OJp9O2+HkP7bxJ1XFYRdw0oilI88Y0kG4WAPUcPrUbduSJKQs5TKoNkTJXX4r+/8T2EWQ43fffr62braxbmcOtjX0b9W7/AREU9fvn4jzFZ2SDTaNdGThuFQIlDuZW3khGtdIk4BAwm/Pc3vgd3tg17n/2HdReGdMCPfU9/Bzf/w9fABIM48uVv4fj9j8g02ivRadiUktXkquASD6T4iwXS1WcchaLw7sPfwnRRBZp+9SNUvv/fsY+PRFBz5FV89n/fhYqP38ZYw3Yc+4P/I/qwckV+jivtMyZRGNMUhaLc9F74SUlKwvjNN9/E1772tVX/7cUXX8Rdd92Fu+++G++8804ql8kgAuP12/Hm178LOhTCJ/6fr6LgwglwnsUrjrOMDuDOP78fRReOo2/39Xj1sWfhtuUpMOIrUcKfWJpnUsxWoIS/WKDAZlR8i1IsFu0FeOPRf0KY5XDDE4+i6ZfPIr/1NBif55LjzOPDuOMvHsDm37yA6eJK/PI7P0anQr7i6JhSFLZGPQeGkCYIdkL8xQJZJm1aNvtYScBgwlt/+o/w6wy4/p++gdv++g+w6Tc/uaKMp9E1ikN/+zCu+5e/BBMM4P0vPYpXv/206E2cKIqCVWT/q8WocMSYoMXnStIluKEESacuPvbYYzh27BgaGq6MJLpcLjz//PN46aWX4PP5cO+99+LAgQPQaMjZ1tuIDO04iCNf+Rtc/8/fwCf/+iEAgNdkwYK9AAu5BVi05aHq2OvQLczi3J2/j+Of/1+KVqBYCcPQyFagQoNOw8KRo8fYlFv2a2cZlUug4Fga+VYDhl0Lio1BTFw1W3Dkq4/hhif/HHue/2cAQJhmMFleC1fNZizYC7H15aehdS+g47o78P5D30BQp3yEM+UmCBTfBGF20S/SiJIcB02l3AJYCgpyDegamlV6GJIyU1yJN//sSVz1n/8vii4cR9GF4zjw9ONwVjeib88NCGm02PnC96HxujG0dS+O/uFfYsFRJMlYLAYOHCvuFr/SEWMldjLjwWrRwajjsOiVpkV4OpO0MN6xYwduuukm/PSnP73i386fP4/t27dDo9FAo9GgtLQUbW1taGpqSmmwGVKn++pbEdAbUXrqPZhcozC5RpE1OoDc3nYAQJhh8d7//Cbab7pL4ZFeitWsVaz9Z2meWXZhTFOU4pGQYrsxbYQxAPTuuxkv1DYhv+0sHB0X4Og8D1tPG+w9FwEAQY0OR778LcWjxCsRI9vdbNAoLoxzzFriEpQAoNBmTHthDPDJeL9q2gPD5DjKThxBxUe/RUHLSTi6WgAAPqMZ7375r9Fx/Z2SdnW0SbBroKRdyJalUyRgEy/FdiPaB2eUHobqWFcY/+xnP8Nzzz13yc/+7u/+Drfddhs+/vjjVT+zsLAAs9kc/W+j0YiFhdgv2JwcA1iRV5LxMDbnAybcMCoYnZObyWtvxuS1Ny//IBKBZn4GRucofOYsuPOKsJ47Se77VV1mhd1uXv9ACbDaTOgem4fXH0r6HIner2yzFvl5WUlfTwysNhM6R+bhCyT/eyeLZPPLWIrx0lKM3/I7AHhPcXZPO3J62uDcchXmiyvWnftyUl5shT1n/ch1rO9G6bwf025lo0Y1ZTbFvr+rIYwlN9eEloFZeP3JlfNTHcZSDJTej4HP3A/N/AyKPj4C49gwum49DK/NsebcF+v7WC3RPMjumEAgGBb9vOuxe0vhqr8PKXNdo9dgaMqz/oEKQ8r9ElhXGB8+fBiHDx9O6KQmkwmLi8v+1cXFxUuE8mpMT8u/VQ0AszP8dRcXfYpcnxQWGQOmC6qW/iP2vTAatbLfLyYShsuVWqOGVMgxcOhKco4mc79sJo2iv6+ARc+ib0be76bc82u+uBaDxUttngl7DgS8frhcsUWb3W6OOVdC/oDizzcWyn5/V3L5/TLrGExOX5lvke4s0npM77t1xQ9WnyNifh+pUEiSeUBHIrLPcZOegwaRK36f9b6PcsNSwOwCWc+1y1Hqfq0lyCXZ22pqasKpU6fg8/kwPz+P7u5u1NbWSnGpDBsAhqYUb+FamifvirZUwWoYKynJJHAohkHLilLeTGkPJsPQsJrJ9GECQGG6V6cgBIOOg16ijmxKNNioKsoCpYJ678V2kvbA1IGos/TZZ59FaWkpbrzxRtx333249957EYlE8Mgjj0Cr3ThWhQzikmPWiVYQPlksRg1yzFpMz0u/8i7MNRJT2spq0cKg4+DOJHDIjlg1iI06vgFBMCT/VjOgbH5APORm6cGxtCJb8RsJKZPUrGYd+sfkizpqOUbRUp6JUGw3obVvGpFIROmhqIaUhPGePXuwZ8+e6H8/8MAD0f9/99134+67707l9BkyAJAmYSMZSvPMkgtjhqawucIq6TUSgaIoFNuN6MgkcMiOWOWWqKWapv3jCm1XErLIWwuappBvNWDQmT6JpiRiy5IuOFbsMKJ9YBpunzxe8fICC5HJpKuh17KwWXSYmCXfa0wK6vjLZtjQkCKMi+3S1/atLsqCgbDaqpl6mPKj17IoEnELtKpYuW1fJeqPJ0q6d8EjASnL9TE0jbrSHMnOf+m1KFQWWGS5llgUOzLzOxEywjgD0Ri0LKwK+4sFOJZBgVU6P6Jey6KmJFuy8yeLxahBFsElidKRqsIsURvLWAwa5MVR3UJsOJZGNiHf31g4cvRp09CGRLQcA4vEXveSPNP/396dBkl1Vn0A/9+l7+19m+ltuqdnn2EWlhmQBIKgoi8uxKRMCEsZVGKIqaQMMU7AVCWSCkGtklS5YeCDlOWXlKJ+0CpjrNIKhmjekJiNBN4aApMEEQYImelh9r7vh4Z2etbe+3b3/1dFJdO3p3noevr2uc89zzl5yacPea1F1265qsKi63QmveGZgHRLlkTc0ObT1S2rsD93m/Daat26+rdOxg0c+WOQRdTkYJ41BvNf/m9hfUXBOkemQpbEglw4lIt8NHcRBQELanK7aiwIAhoK8DnKlGKQ4HNxk2my9PktTGVPEAR0Nnt0t1LpcRhzkurgtht1vZkj5LEWxQ7sUlDrt2elGsVUlU5TXldvW6qdea/mkgmmU+ROvrrDBSstOZ3jXpcp5yvfucLFjeQxMCZdWhB2Ilipvw+yIAhZL6UmCAIW1ldk9TWzzaTKRZErWuxEUUB9Ve7yF5vytNoV8ljRWqufTaTJCFSYddm2uhS47fm7IGvL4apxIe66ZIvPbc7JBXcp4rtEuhP0WNGsw1zb68I+G1RD9nLMqr3WgtdpTkZXs6coxlnMgpXWnNV6BYBApQWWHG/urLAb0dlcmdO/IxdkScTKDj9vOWeZ2WjIa9tkr8uMSkf202KcVlX3FVbmIksimkJO3vlLAgNj0hWnVUVnU6WuP7xmo4xPdYVQlYUVbYMsoq02P7upM2VSZaxaFEBNEd0eLzaNodyuSImCgPpg7lakLSYDlrf5Cl53PF3X9zWwEkt2OKwqPr4okPeNX7k4pxZjbvFUzdVOrGj3wajk7uK7FBTn2YtKklGRsbxVX5vtZqMqEpa3+rCsxQslzdVjWRLRXucuqpOUJIrobPZgcWMldzlnmc9lhiNLTT3mUuOzpT1n56IYJKxo92f1bkohiKKApS0e1FcVfyBUSB6nCasWBnJ6B2Q2brsR/ix1NLSZFdzQ5tP1HpBUeF1mfKKzCl5uNp1V8XwjU0mTJRHLW70wG4trSoa8VlQ6jXi95xLOXRpM6necVhU1fhtCHmvR5nzVBexwWBT87zsXMDyan6L6pa4hx6vF18mSiDq/DSez2LRFFAUsb/XCatJXDe50CYKARQ0VUA0i3un9sNDDKTrVXis6mzwFvXhuq3Hj/OWhtDu+GRUZC2piG0iLobJKKoyKjBXtfvSc/Qjv9H6IaJRd8SYrriiESookifC7zaiqMMPnNhfFSvFMjIqMG9p8eP9CBKfP9WNsPBr7MxHFxLU2vLIkIuixoNZvL5k8XbfdiE90VuHYiT52VcqQ06rCm8f8xboqO3rOfoSJDL4QRUGAy6bC5zYjUGHOSw3ZfGsJu6AqEt44dYnBQ5Kaqp1oq3EVPB3OblEQ8lhS7mhokEU0Bh1oCDqK9jspGYIgoCnkRKXDhFf/rw8DV0cLPSTdKPvAWFUkuGwq5Gx8hjUNWuw/0DQt9l8AExNRjI5H2asck4LhSgt8LlNJnXiqvdZpt9uimgaH04wPLw+W1L/1OqMSyzvuvzqKsxci+KBvEIPDY4UeVtHJ9253oyIj5LWi9z+ptYlWDBK8ThN8bjN8LlNOUjL0ptZvh89lxulz/ej9zwBGxiYKPSRdur7KXqejrnCLGioQ8loRGRrD4NAYIkNjiAyNY2hkHAJi+ybMxmt/VBlmowFep6noGnhkwmVTsXZpCOMTUVwdHsfg8Biujozj6nDsz0Q0ei2muRbXIPa9hlnCmVSjHFkWMTGhr89U2QfGtX47PrbQhr6+1L4gUhXVNIyMTmBkbAIjoxMYHp3AlcgI3js/kNGqTbGwmRXUBmwIe21Fmz6QDlEQYFTkkgyKJ7ObFdhr3WitdePDgRF80BfB2b7BskmzEAUBNosCl02FSZEwODwe+yIeHsPI6NwnfbMqo6oANUYbgw68dz4y6wW7KAiwmQ1w2Yxw2VS47CpsJkPBVwILwaTKaKt1o7naiQ/6Ijh1tr/kV9hsZgU2swE+jw0jQ6MwKhJMqgxVkSCLAgRBgCgIEIRYKo0gQHebLg1yrLGFb8pevIloND5+ipElEXaLAnse9jlM5rYb0denr8WUsg+M80UUBJhUOWEjQg1saK52oufsRzjzn4H4bfecj0UUAO3aVV8u/x5BgL/CjLqAvajL3FBqXDYVLpuKtloXXjnZh39fTC73upgIgoBAhTn+b3Va1VkvfsbGo4gMjWF4dBzRaGzFBdcWXDRNg9VkKMgXtM2sYHmrFxMTGgQh9m8ShNjnVpZEOKxKyV/QpUqWRNT67aj123Hhw6t46/Rl9A+WVoAsSyJaa12oD9ghCAI8ntwvHOWb3gJ40hcGxgVmUmUsrK9AU8iBnrMf4fS53AfIPpcZY+PRnOaFVnttaKt1FWRHMumDJIpYtsCLN05dwplz/YUeTlalcsvYIIvX8sr1l1vObm/p87rMWGlR8MIb5xAZ0teKV7p8bjMWN1QW3SZoomziZZNOGBUZHXUV+J9l1VmpjzuXsM+atVI2M7le4J9BMYmCgCWNlVgQLo5azcloqXbqKo+SCseoyFjZEYA5R+c6kyrnJXVFVSQsa/FiRbufQTGVPQbGOqMqEjqbPDk70RoVOb6LPFevv2yBl7lblGBBjQuLG/XduCUZNX5b0bU6ptwyG2WsXBjIyYatuoA9py3CgVin0bVdIYRKpE4vUaYYGOuQQRaxuCk3LVVDXgtEQYDFaMh6kr0oCFi2wMOVYppRXcCOjy3wQirSxiD+CjMWNxZfq2PKPavJgJXt/qxvLPa5zWitceWsPrTZaEBnU2VZVBchShYDY53yucw5ab0b9v73Nf3u7K4at9W6c9KjnkpHVaUFN7b7i27l2G03YlkL74TQ7BxWFSva/VnbsGg2GuCwxDZAdjV7cvKZaa91cYMl0RT8ROhYR3122wW7bGrCKnE2N95UVVrQmKfOXVTcPE5TXptZZOp6S1gGEDQft92I5W2+rNwVmbxw4bYb0RDMbkpFhcOIoIfpE0RT8UyvYwZZwuLGiqy9XnjKCrTTqmQl8LaZFXQ2eTJ+HSof9Vn+ks8VxSBhRbsPKm81U5K8ThNasrDZ1O9OvHhsrXFlrbugIAhYVJ+97xaiUsLAWOcCFRaEsnBVL4kCQlOaCAiCkHE6hSyJ+Firt6yadlDmfK7iaCFc7bXCbMxNfieVrrqAPaO8XYMsTktLk0QRnU2VWUnnqfHZ4LDqr3wgkR4wmikCCxsqMt7xHKiwwCBPf41My7a117lhL4IAh/Qn17vts6HGn/08fyp9BllEfQYl/bwuc6wR0xRuuxENGaasGWQRrTWlUz6RKNsYGBcB1SBhUUNmu+HDvplXnT1OY9q5k2ZVzskGQSoP1V6rrnfDV9iNvOijtDUE7WnfSfO5Zs/BXxB2ZlRRqCXsyklpOaJSwcC4SAQrLWk3/jCr8qwtmSVRhHeOk/BcGkPOGVc1iJIhS6KuV2T1PDbSP4MspbVqLM6T4hZLqUivSoXNrGS0kk1UDhgYF5H2OndagWi11zrnSTSdPGOjIqPGzx3NlJn6gF2XJdAMspjzDpRU+hqCjpRXjV12dd47KS6bmlaTpo769L5DiMoJA+MiYjEaEuoQJ6t6nnQHn9uccnDSGHRAEjl9KDMmVdZlAFrttbI8G2VMMUioTXGFNtmFiuZqZ0qv63Ob4XPlpuMpUSnhmb/INFc7U6qRWeEwzts1STVIcNmT36GsGiTUBnibmbKjIai/+tc1ft5upuxoDDpSushKNjB2WlX4knyuKApYyPJsRElhYFxkzEY5pdzHZFeYA+7kV+2aa9gtibLHZVPhthsLPYw4t90IR5bbpVP5SmUhwWoypFTGsCXJVeOmoCNnbaWJSg2jmyLUFHJCSiIwlSURQU9yAW+yZdsMspiV4vVEk+mpdBsrrVC2NQWTO2enut/DbTdOq3c8lcVoQFOKaRdE5YyBcREyqTLq5lk1FgQBnc2epFd2k12pyLRwPdFMqiotMKvZa3+eLoOc/MUkUbJURUJtEnf60tkI3RyeO+hd2FDBO3xEKeCnpUg1hZxznuw66twIpripab5VY0kS0VClv3xQKn6iIKS8SSkXgh5uuqPciG1Ynn1/iGKQ4HaknlLkdZpmTUUKVFgy7m5KVG74DVCkVEVC3Sy3nxuDjrQ2NAXmOYHW+m0sDE85U+u3JXW7eT4mVU67jXoyq3pE6TCpMpqrnbNWAPI6TWmXLmyaoRueLInccEeUBgbGRaxphhqZQY8V7XXutF7PZVNR6TDNWOdSFAU06rB6AJUOxSCh2ptZbeywz4ZPdQWxsKEipeotAOC0qXBak6/OQpSqlrALn+gKzliiMNl9HjMJVFjgmDJ3m6udMBsLn55EVGz4qSliikFCfZUDJ9/7EECsNFtXc2VaHZGAWF7yqkUBjE9EcWVgBJcHRnCpfxiX+4cRrLTCpIMcUCptDVV2XOzvS/n3jIqMJU2VCbeNgx4r3js/kPRrcNMd5YPdrGB5qw8fDozg7TOX0XdlCKIozNkGOhnNIQdePnEBQKzDHRcyiNLDSKfINQbtePffH8GoyLih1ZeVphuyJKLSaULltTbSmqYhqmkZvy7RfGxmBf5KC3oGR5L+nWqvDQvr3dM2hdYF7EkHxrIkpp1+QZQOl03FTQsDuHBlCBcuX4VBzixNrarSAptZwcDVUSxuqGCHO6I0MTAucgZZQnudG16nKWfVIgRBgKTDtr1UmhbUuNHTezmp5y5r8SI0S/qFy6bCaVNxZWD+ILs2YEu5dS9RNnidJnidma0WA7HzdFPIgb4rQ/FFDSJKHb8JSkCt3w6zkcXbqTQErq18zSfosc4aFF9Xn0SlC9UgJd0ogUjPQl4rOrjhjigjDIyJSHcagnMHtLIkoiOJTaZBjwXqPHdSWsKujG9jE+mBKAjzzncimhsDYyLSnZDHOucXfEvYmdRmUEkUEZ5jU53NrCTdrpeIiEofA2Mi0h1ZElEzS01hm1lJqdFMbcA2a6WWjjp32rVjiYio9DAwJiJdqgvYZ9xZn+qOe4vRMGMpLK/LBB+7ghER0SQMjIlIl0yqjKqKxEYIIY81rR33dVM24YmCgI46blIiIqJEDIyJSLcmtzY3yGLaXR29LhMspv9Wbgn7bLBb5q98QURE5YWBMRHplsumosJuBBCrHpFu90VBEFDnj60aG2QRrTWurI2RiIhKBwNjItK1+qADDouC+qr5axLPJeyzQpJENIWcUBWWtCIiounY+Y6IdC1QYYbVKGdcPUIxSGgOOeatkUxEROWLgTER6ZooCHBY1ay8VkuYKRRERDQ7plIQEREREYGBMRERERERAAbGREREREQAGBgTEREREQFgYExEREREBICBMRERERERAAbGREREREQAGBgTEREREQFgYExEREREBICBMRERERERAAbGREREREQAGBgTEREREQFgYExEREREBICBMRERERERAAbGREREREQAGBgTEREREQFgYExEREREBICBMRERERERAAbGREREREQAAEHTNK3QgyAiIiIiKjSuGBMRERERgYExEREREREABsZERERERAAYGBMRERERAWBgTEREREQEgIExEREREREAQC70APLpL3/5C5599lns27cPAPDaa6/hySefhCRJWLVqFe6///6E5w8PD6O7uxuXLl2CxWLBD37wA7jd7kIMvWAOHjyIv//97wCA/v5+XLx4EUePHk14zp49e/Dqq6/CYrEAAPbv3w+bzZb3seqBpmlYvXo1amtrAQBLlizBQw89lPCcX//613jmmWcgyzLuvfdefPKTnyzASPVhYGAA3d3diEQiGBsbw65du9DZ2ZnwHM4vIBqNYvfu3Th58iQURcGePXtQU1MTP/7Xv/4VP/vZzyDLMm677TbccccdBRxt4Y2NjeGRRx7B2bNnMTo6invvvRdr166NHz906BAOHz4cP58//vjjqK+vL9RwdeHWW2+Nf65CoRC+973vxY9xfk33u9/9Dr///e8BACMjI3jnnXdw9OhR2O12AJxjk73++uv44Q9/iF/96lfo7e3Frl27IAgCmpqa8N3vfhei+N812vnOdXmhlYknnnhCW7dunbZjx474Y1/84he13t5eLRqNal//+te1t956K+F3fvGLX2g//vGPNU3TtD/+8Y/aE088kdcx68327du1I0eOTHt806ZN2qVLlwowIv05c+aMds8998x6/MKFC9r69eu1kZERrb+/P/7/5epHP/qRdujQIU3TNO3UqVParbfeOu05nF+a9uc//1nbuXOnpmma9q9//Uv7xje+ET82OjqqffrTn9auXLmijYyMaF/60pe0CxcuFGqounD48GFtz549mqZp2uXLl7U1a9YkHH/ooYe0N998swAj06fh4WHtlltumfEY59f8du/erT3zzDMJj3GOxRw8eFBbv369tmHDBk3TNO2ee+7R/vnPf2qapmmPPvqo9txzzyU8f65zXb6UTSpFV1cXdu/eHf85EolgdHQU4XAYgiBg1apV+Mc//pHwO6+88go+/vGPAwBWr1497Xg5ee6552C32+Pvx3XRaBS9vb147LHHsGnTJhw+fLhAI9SHYAUMrQAABX1JREFU48eP4/z587jzzjtx991349133004/sYbb6CzsxOKosBmsyEcDuPEiRMFGm3hffWrX8WmTZsAABMTE1BVNeE451fM5HPRkiVL8NZbb8WPnTp1CuFwGA6HA4qiYOnSpTh27FihhqoLn/3sZ/HAAw/Ef5YkKeH48ePHcfDgQWzevBkHDhzI9/B058SJExgaGsK2bduwdetWvPbaa/FjnF9ze/PNN9HT04ONGzcmPM45FhMOh/GTn/wk/vPx48exfPlyALG46sUXX0x4/lznunwpuVSK3/zmN/jlL3+Z8NjevXvx+c9/Hi+99FL8sUgkAqvVGv/ZYrHg/fffT/i9SCQSv7VksVgwMDCQw5EX3mzv3aJFi3DgwAE89dRT037n6tWr+PKXv4yvfe1rmJiYwNatW9HR0YEFCxbka9gFM9P79dhjj2H79u343Oc+h2PHjqG7uxu//e1v48cnzykgNq8ikUjexlxIc82vvr4+dHd345FHHkk4Xs7za7Kp5ytJkjA+Pg5Zlst6Ts3metpNJBLBN7/5TezYsSPh+Be+8AVs2bIFVqsV999/P/72t7+VdUqT0WjEXXfdhQ0bNuDMmTO4++678eyzz3J+JeHAgQO47777pj3OORazbt06fPDBB/GfNU2DIAgAZo6r5jrX5UvJBcYbNmzAhg0b5n2e1WrF4OBg/OfBwcF4btBMz5npeKmZ7b3r6emB3W6fMc/HZDJh69atMJlMAIAbb7wRJ06cKIvAZab3a2hoKL46tWzZMpw/fz7hRDDTvCuXfNnZ5tfJkyfxrW99Cw8//HB8JeG6cp5fk02dN9FoNP5FUc5zai7nzp3Dfffdhy1btuDmm2+OP65pGr7yla/E36M1a9bg7bffLsug5bq6ujrU1NRAEATU1dXB6XSir68PgUCA82sO/f39ePfdd3HjjTcmPM45NrvJ+cTzxV1A4rkuX8omlWIqq9UKg8GA9957D5qm4YUXXsCyZcsSntPV1YXnn38eAHDkyBEsXbq0EEMtuBdffBGrV6+e8diZM2ewZcsWTExMYGxsDK+++ira29vzPEL9+OlPfxpfFT1x4gSqqqriQTEALFq0CK+88gpGRkYwMDCAU6dOobm5uVDDLbienh488MAD2LdvH9asWTPtOOdXTFdXF44cOQIgtml48pxpaGhAb28vrly5gtHRURw7dmzaBsZyc/HiRWzbtg3d3d24/fbbE45FIhGsX78eg4OD0DQNL730Ejo6Ogo0Un04fPgwvv/97wMAzp8/j0gkAo/HA4Dzay4vv/wyVq5cOe1xzrHZtbW1xe/eHzlyZMa4a7ZzXb6U3IpxKh5//HF8+9vfxsTEBFatWoXFixcDALZt24ann34amzdvxs6dO7F582YYDIZ4NYtyc/r0adx0000Jjx06dAjhcBhr167FzTffjDvuuAMGgwG33HILmpqaCjTSwtu+fTu6u7vx/PPPQ5Kk+M7uye/XnXfeiS1btkDTNDz44IPT8mrLyb59+zA6Ooonn3wSQOyC9ec//znn1xSf+cxncPToUWzatAmapmHv3r34wx/+gKtXr2Ljxo3YtWsX7rrrLmiahttuuw0+n6/QQy6op59+Gv39/di/fz/2798PIHbHYmhoCBs3bsSDDz6IrVu3QlEUrFixYsaLsnJy++234zvf+Q42b94MQRCwd+9e/OlPf+L8msfp06cRCoXiP0/+THKOzWznzp149NFH8dRTT6G+vh7r1q0DADz88MPYsWPHjOe6fBM0TdPy/rcSEREREelM2aZSEBERERFNxsCYiIiIiAgMjImIiIiIADAwJiIiIiICwMCYiIiIiAgAA2MiIiIiIgAMjImIiIiIADAwJiIiIiICAPw/CYr3HY1eBjoAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_pred, y_std = gpr.predict(X_valid, return_std=True)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, color='red', label='true mean')\n",
+    "ax.plot(X_valid, y_pred, color='blue', label='predicted mean')\n",
+    "ax.fill_between(X_valid, y_pred - y_std, y_pred + y_std, alpha=0.5, label='+/- 1 std dev')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see, the confidence bounds are quite wide most of the time. Only at the training data points is the model more confident. This is exactly what we should expect: At the points where the model has seen some data, it is more confident, but between data points, it is less confident."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### More data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Below, we increase the sampling frequency from our sine function and train the same model again to show how a well fit model looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampling_frequency = 2\n",
+    "X_train = torch.arange(-8, 9, 1 / sampling_frequency).float()\n",
+    "y_train = torch.sin(X_train) + torch.randn(len(X_train)) * 0.2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  epoch    train_loss     dur\n",
+      "-------  ------------  ------\n",
+      "      1        \u001b[36m1.1546\u001b[0m  0.0054\n",
+      "      2        \u001b[36m1.1222\u001b[0m  0.0087\n",
+      "      3        \u001b[36m1.0879\u001b[0m  0.0079\n",
+      "      4        \u001b[36m1.0535\u001b[0m  0.0060\n",
+      "      5        \u001b[36m1.0188\u001b[0m  0.0093\n",
+      "      6        \u001b[36m0.9833\u001b[0m  0.0093\n",
+      "      7        \u001b[36m0.9474\u001b[0m  0.0089\n",
+      "      8        \u001b[36m0.9114\u001b[0m  0.0097\n",
+      "      9        \u001b[36m0.8754\u001b[0m  0.0068\n",
+      "     10        \u001b[36m0.8395\u001b[0m  0.0104\n",
+      "     11        \u001b[36m0.8038\u001b[0m  0.0056\n",
+      "     12        \u001b[36m0.7684\u001b[0m  0.0058\n",
+      "     13        \u001b[36m0.7337\u001b[0m  0.0103\n",
+      "     14        \u001b[36m0.7000\u001b[0m  0.0087\n",
+      "     15        \u001b[36m0.6673\u001b[0m  0.0062\n",
+      "     16        \u001b[36m0.6357\u001b[0m  0.0097\n",
+      "     17        \u001b[36m0.6054\u001b[0m  0.0067\n",
+      "     18        \u001b[36m0.5762\u001b[0m  0.0068\n",
+      "     19        \u001b[36m0.5479\u001b[0m  0.0071\n",
+      "     20        \u001b[36m0.5200\u001b[0m  0.0072\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<class 'skorch.probabilistic.ExactGPRegressor'>[initialized](\n",
+       "  module_=RbfModule(\n",
+       "    (likelihood): GaussianLikelihood(\n",
+       "      (noise_covar): HomoskedasticNoise(\n",
+       "        (raw_noise_constraint): GreaterThan(1.000E-04)\n",
+       "      )\n",
+       "    )\n",
+       "    (mean_module): ConstantMean()\n",
+       "    (covar_module): RBFKernel(\n",
+       "      (raw_lengthscale_constraint): Positive()\n",
+       "      (distance_module): Distance()\n",
+       "    )\n",
+       "  ),\n",
+       ")"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gpr = ExactGPRegressor(\n",
+    "    RbfModule,optimizer=torch.optim.Adam,\n",
+    "    lr=0.1,\n",
+    "    max_epochs=20,\n",
+    "    batch_size=-1,\n",
+    "    device=DEVICE,\n",
+    ")\n",
+    "gpr.fit(X_train.reshape(-1, 1), y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f522b265fd0>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_pred, y_std = gpr.predict(X_valid, return_std=True)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, color='red', label='true mean')\n",
+    "ax.plot(X_valid, y_pred, color='blue', label='predicted mean')\n",
+    "ax.fill_between(X_valid, y_pred - y_std, y_pred + y_std, alpha=0.5, label='+/- 1 std dev')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we can see that the confidence intervals are much narrower than above, even between data points. This means that the model is quite confident in _interpolating_ between data points. Notice, however, that the confidence bounds increase considerably at the left and right end, i.e. at values outside of the range of the training data. This means that the model is less confident in _extrapolating_ which is typically a good thing."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Confidence region"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another way skorch implements to quickly get the confidence interval is through the `confidence_region` method. This mirrors the method by the same name in GPyTorch. By default, it returns the lower and upper bound for 2 standard deviations, but this can be changed through the `sigmas` argument."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower, upper = gpr.confidence_region(X_valid, sigmas=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x396 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(upper, label='+2 std dev')\n",
+    "plt.plot(y_pred, label='mean')\n",
+    "plt.plot(lower, label='-2 std dev')\n",
+    "plt.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Grid search"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As always, one of the advantages of using skorch is the sklearn integration. That means that we can plug our regressor into `GridSearchCV` et al. However, there is a caveat to this, as explained below. But first, let's set up the grid search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import GridSearchCV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params = {\n",
+    "    'lr': [0.01, 0.02],\n",
+    "    'max_epochs': [10, 20],\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "gpr = ExactGPRegressor(\n",
+    "    RbfModule,\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=0.1,\n",
+    "    max_epochs=20,\n",
+    "    batch_size=-1,\n",
+    "    device=DEVICE,\n",
+    "    \n",
+    "    train_split=False,\n",
+    "    verbose=0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We turn off skorch-internal train/validation split, since the grid search already performs the data splitting for us. We also set the verbosity level to 0 to avoid too many print outputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = GridSearchCV(gpr, params, cv=3, scoring='neg_mean_squared_error', verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since we deal with a regression task, we choose an appropriate scoring function, in this case mean squared error. Now let's start the grid search to see the problem mentioned above:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fitting 3 folds for each of 4 candidates, totalling 12 fits\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
+      "[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:    0.9s finished\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "GridSearchCV(cv=3,\n",
+       "             estimator=<class 'skorch.probabilistic.ExactGPRegressor'>[uninitialized](\n",
+       "  module=<class '__main__.RbfModule'>,\n",
+       "),\n",
+       "             param_grid={'lr': [0.01, 0.02], 'max_epochs': [10, 20]},\n",
+       "             scoring='neg_mean_squared_error', verbose=1)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "search.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The grid search finished successfully and we found the best hyper-parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-0.5268993576367696"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "search.best_score_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'lr': 0.01, 'max_epochs': 20}"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "search.best_params_"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Regression with real world data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So far, we have only worked with toy data. To show how to work with real world data, we will reproduce an example from the GPyTorch docs:\n",
+    "\n",
+    "https://docs.gpytorch.ai/en/stable/examples/01_Exact_GPs/Spectral_Delta_GP_Regression.html\n",
+    "\n",
+    "This dataset contains the \"BART ridership on the 5 most commonly traveled stations in San Francisco\". \"BART\" is the \"Bay Area Rapid Transit\", i.e. public transit system in the San Francisco bay area.\n",
+    "\n",
+    "For more details, please consult the link."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First of all we need to download the data. This only needs to be done if the data has not already been downloaded."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path = os.path.join('datasets', 'BART_sample.pt')\n",
+    "url = 'https://drive.google.com/uc?export=download&id=1A6LqCHPA5lHa5S3lMH8mLMNEgeku8lRG'\n",
+    "if not os.path.isfile(path):\n",
+    "    print('Downloading BART sample dataset...')\n",
+    "    urllib.request.urlretrieve(url, path)\n",
+    "    \n",
+    "train_x, train_y, test_x, test_y = torch.load('../BART_sample.pt', map_location=DEVICE)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We need to scale the input data a bit, following the tutorial:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_x_min = train_x.min()\n",
+    "train_x_max = train_x.max()\n",
+    "\n",
+    "X_train = train_x - train_x_min\n",
+    "X_valid = test_x - train_x_min"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The target data also needs to be scaled. However, contrary to the tutorial, we will use sklearn's `StandardScaler` for this. Although it performs the same transformation as in the tutorial, it allows us to easily inverse transform the targets back to their original scale, which will be useful later."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.preprocessing import StandardScaler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We need to transpose here because the target data is sequence x sample\n",
+    "# but we want to scale over the samples, not over the sequence.\n",
+    "y_scaler = StandardScaler().fit(train_y.T)\n",
+    "y_train = torch.from_numpy(y_scaler.transform(train_y.T).T).float()\n",
+    "y_valid = torch.from_numpy(y_scaler.transform(test_y.T).T).float()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([5, 1440, 1]) torch.Size([5, 1440]) torch.Size([5, 240, 1]) torch.Size([5, 240])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(X_train.shape, y_train.shape, X_valid.shape, y_valid.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the module"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The module is effectively the same as in the tutorial."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SpectralDeltaGP(gpytorch.models.ExactGP):\n",
+    "    def __init__(self, X, y, likelihood, num_deltas, noise_init=None):\n",
+    "        super(SpectralDeltaGP, self).__init__(X, y, likelihood)\n",
+    "        self.mean_module = gpytorch.means.ConstantMean()\n",
+    "        base_covar_module = gpytorch.kernels.SpectralDeltaKernel(\n",
+    "            num_dims=X.size(-1),\n",
+    "            num_deltas=num_deltas,\n",
+    "        )\n",
+    "        self.covar_module = gpytorch.kernels.ScaleKernel(base_covar_module)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the likelihood"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we show an example of using a non default likelihood. We wrap the initialization of the likelihood inside a function because we want to use some specific methods, such as `register_prior`. This function can be passed as the `likelihood` parameter to `ExactGPRegressor`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_likelihood(\n",
+    "        noise_constraint=gpytorch.constraints.GreaterThan(1e-11),\n",
+    "        noise_prior=gpytorch.priors.HorseshoePrior(0.1),\n",
+    "        noise=1e-2,\n",
+    "):\n",
+    "    likelihood = gpytorch.likelihoods.GaussianLikelihood(\n",
+    "        noise_constraint=noise_constraint,\n",
+    "    )\n",
+    "    likelihood.register_prior(\"noise_prior\", noise_prior, \"noise\")\n",
+    "    likelihood.noise = noise\n",
+    "    return likelihood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gpr = ExactGPRegressor(\n",
+    "    SpectralDeltaGP,\n",
+    "    module__num_deltas=1500,\n",
+    "    module__X=X_train if DEVICE == 'cpu' else X_train.cuda(),\n",
+    "    module__y=y_train if DEVICE == 'cpu' else y_train.cuda(),\n",
+    "\n",
+    "    likelihood=get_likelihood,\n",
+    "\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=2e-4,\n",
+    "    max_epochs=50,\n",
+    "    batch_size=-1,\n",
+    "    device=DEVICE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, as explained above, we additionally need to pass `X` and `y` to the module and we need to set the batch size to -1, since we still deal with exact GPs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  epoch    train_loss     dur\n",
+      "-------  ------------  ------\n",
+      "      1        \u001b[36m2.7906\u001b[0m  2.0871\n",
+      "      2        \u001b[36m2.1317\u001b[0m  1.9986\n",
+      "      3        \u001b[36m1.6960\u001b[0m  3.0301\n",
+      "      4        \u001b[36m1.4273\u001b[0m  3.0680\n",
+      "      5        \u001b[36m1.2657\u001b[0m  3.5300\n",
+      "      6        \u001b[36m1.1890\u001b[0m  2.5725\n",
+      "      7        \u001b[36m1.1178\u001b[0m  2.0474\n",
+      "      8        \u001b[36m1.0708\u001b[0m  2.0823\n",
+      "      9        \u001b[36m1.0580\u001b[0m  2.0268\n",
+      "     10        \u001b[36m1.0362\u001b[0m  2.0235\n",
+      "     11        \u001b[36m1.0192\u001b[0m  1.8889\n",
+      "     12        \u001b[36m0.9654\u001b[0m  1.8637\n",
+      "     13        \u001b[36m0.9529\u001b[0m  1.8471\n",
+      "     14        \u001b[36m0.9309\u001b[0m  1.9733\n",
+      "     15        \u001b[36m0.9019\u001b[0m  2.1043\n",
+      "     16        0.9180  1.9568\n",
+      "     17        \u001b[36m0.8743\u001b[0m  1.9917\n",
+      "     18        \u001b[36m0.8694\u001b[0m  1.9267\n",
+      "     19        \u001b[36m0.8587\u001b[0m  2.1423\n",
+      "     20        \u001b[36m0.8542\u001b[0m  1.8739\n",
+      "     21        \u001b[36m0.8462\u001b[0m  1.8677\n",
+      "     22        \u001b[36m0.8018\u001b[0m  2.0562\n",
+      "     23        \u001b[36m0.7965\u001b[0m  2.0123\n",
+      "     24        \u001b[36m0.7790\u001b[0m  2.0773\n",
+      "     25        0.7978  2.1713\n",
+      "     26        \u001b[36m0.7567\u001b[0m  2.2295\n",
+      "     27        \u001b[36m0.7393\u001b[0m  2.2569\n",
+      "     28        \u001b[36m0.7321\u001b[0m  2.1236\n",
+      "     29        \u001b[36m0.7017\u001b[0m  1.8720\n",
+      "     30        \u001b[36m0.6973\u001b[0m  1.6813\n",
+      "     31        0.7043  1.9117\n",
+      "     32        0.7009  2.1291\n",
+      "     33        \u001b[36m0.6733\u001b[0m  2.0217\n",
+      "     34        \u001b[36m0.6713\u001b[0m  2.1509\n",
+      "     35        \u001b[36m0.6629\u001b[0m  1.8898\n",
+      "     36        0.6720  1.7500\n",
+      "     37        \u001b[36m0.6548\u001b[0m  1.8919\n",
+      "     38        \u001b[36m0.6356\u001b[0m  1.8814\n",
+      "     39        \u001b[36m0.6187\u001b[0m  2.0170\n",
+      "     40        0.6403  2.2680\n",
+      "     41        0.6381  1.9118\n",
+      "     42        0.6263  2.0442\n",
+      "     43        0.6327  2.0453\n",
+      "     44        0.6357  1.8428\n",
+      "     45        \u001b[36m0.5957\u001b[0m  1.7891\n",
+      "     46        0.5961  1.8859\n",
+      "     47        0.6135  1.8681\n",
+      "     48        0.6238  1.7084\n",
+      "     49        0.5978  1.7232\n",
+      "     50        \u001b[36m0.5919\u001b[0m  1.7004\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This context manager ensures that we dont try to use Cholesky. This is\n",
+    "# in following with the tutorial.\n",
+    "with gpytorch.settings.max_cholesky_size(0):\n",
+    "    gpr.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the trained model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, let's plot the predictions and the standard deviations for our 5 time series and see how well the model learned."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 26.5 s, sys: 6.6 s, total: 33.1 s\n",
+      "Wall time: 8.29 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "y_pred, y_std = gpr.predict(X_valid, return_std=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we make use of our [`StandardScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) to scale the targets back to their original scale. Remember to also scale the standard deviations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = y_scaler.inverse_transform(y_pred.T).T\n",
+    "y_std = y_scaler.inverse_transform(y_std.T).T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_bart(ax, X_train, y_train, X_valid, y_valid, y_pred, y_std):\n",
+    "    lower = y_pred - y_std\n",
+    "    upper = y_pred + y_std\n",
+    "\n",
+    "    ax.plot(X_train, y_train, 'k*', label='train')\n",
+    "    ax.plot(X_valid, y_valid, 'r*', label='valid')\n",
+    "    # Plot predictive means as blue line\n",
+    "    ax.plot(X_valid, y_pred, 'b')\n",
+    "    # Shade between the lower and upper confidence bounds\n",
+    "    ax.fill_between(X_valid, lower, upper, alpha=0.5, label='+/- 1 std dev')\n",
+    "    ax.tick_params(axis='both', which='major', labelsize=16)\n",
+    "    ax.tick_params(axis='both', which='minor', labelsize=16)\n",
+    "    ax.set_ylabel('Passenger Volume', fontsize=16)\n",
+    "    ax.set_xticks([])\n",
+    "    return ax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x2016 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(5, figsize=(14, 28))\n",
+    "y_train_unscaled = y_scaler.inverse_transform(y_train.T).T\n",
+    "y_valid_unscaled = y_scaler.inverse_transform(y_valid.T).T\n",
+    "for i, ax in enumerate(axes):\n",
+    "    ax = plot_bart(\n",
+    "        ax,\n",
+    "        X_train[i, -100:, 0],\n",
+    "        y_train_unscaled[i, -100:],\n",
+    "        X_valid[i, :, 0],\n",
+    "        y_valid_unscaled[i],\n",
+    "        y_pred[i],\n",
+    "        y_std[i],\n",
+    "    )\n",
+    "    ax.set_title(f\"Station {i + 1}\", fontsize=18)\n",
+    "\n",
+    "ax.set_xlabel('hours', fontsize=16)\n",
+    "plt.xlim([1250, 1680])\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Retrieving the covariance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you have worked with sklearn's [`GaussianProcessRegressor`](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html#sklearn.gaussian_process.GaussianProcessRegressor) in the past, you might know that it supports a way to retrieve the covariance by calling `regressor.predict(X, return_cov=True)`. This is not supported by skorch.\n",
+    "\n",
+    "It is, however, possible to use the `forward_iter` method to get the covariance indirectly. This will return the posterior distribution, which has a `covariance_matrix` attribute. Below, we show how to use this to plot the covariance of the first 20 data points of the first time series."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "posterior = next(gpr.forward_iter(X_valid))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MultivariateNormal(loc: torch.Size([5, 240]))"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "posterior"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([5, 240, 240])"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "posterior.covariance_matrix.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x396 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(posterior.covariance_matrix[0, :20, :20].detach().numpy())\n",
+    "plt.colorbar()\n",
+    "plt.grid(None)\n",
+    "plt.axis('off');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Stochastic Variational GP Regression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So far, we have dealt with exact GP regression. As the name suggest, this method is exact instead of relying on approximations. There are a few disadvantages, however. Without going into details, exact solutions are in general only possible for Gaussian distributions, so if you want to use another distribution, you cannot use exact GPs. Also, using variational GPs with GPyTorch allows us to use batching, so it allows us to work with larger datasets."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this part of the notebook, we rely on the following GPyTorch tutorial:\n",
+    "\n",
+    "https://docs.gpytorch.ai/en/stable/examples/04_Variational_and_Approximate_GPs/SVGP_Regression_CUDA.html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, we download a real world dataset (if it hasn't been downloaded already) and perform some minor preprocessing first, following the tutorial. Automatic download doesn't work (anymore), so please go to the following URL and then download the file to a `datasets` subfolder within this folder.\n",
+    "\n",
+    "https://drive.google.com/uc?export=download&id=1jhWL3YUHvXIaftia4qeAyDwVxo6j1alk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.io import loadmat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path = os.path.join('datasets', 'elevators.mat')\n",
+    "if not os.path.isfile(path):\n",
+    "    raise IOError(\"Please download the 'elevators.mat' file as described above\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = torch.Tensor(loadmat(path)['data'])\n",
+    "X = data[:, :-1]\n",
+    "X = X - X.min(0)[0]\n",
+    "X = 2 * (X / X.max(0)[0]) - 1\n",
+    "y = data[:, -1]\n",
+    "\n",
+    "# train/valid split\n",
+    "train_n = int(math.floor(0.8 * len(X)))\n",
+    "X_train = X[:train_n, :].contiguous()\n",
+    "y_train = y[:train_n].contiguous()\n",
+    "X_valid = X[train_n:, :].contiguous()\n",
+    "y_valid = y[train_n:].contiguous()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([13279, 18]) torch.Size([13279]) torch.Size([3320, 18]) torch.Size([3320])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(X_train.shape, y_train.shape, X_valid.shape, y_valid.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see, we deal with a bigger dataset now than before. Thankfully, we will be able to use batching to avoid potential memory issues."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the module"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This time around, since we don't use exact GPs, we actually need to subclass from GPyTorch's `ApproximateGP`. Additionally, we need to define a variational strategy. For more details, please refer to the corresponding [GPyTorch tutorial](https://docs.gpytorch.ai/en/stable/examples/04_Variational_and_Approximate_GPs/SVGP_Regression_CUDA.html).\n",
+    "\n",
+    "Apart from that, we have to define the mean function, the kernel function, and the output distribution, as usual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from gpytorch.models import ApproximateGP\n",
+    "from gpytorch.variational import CholeskyVariationalDistribution\n",
+    "from gpytorch.variational import VariationalStrategy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class VariationalModule(ApproximateGP):\n",
+    "    def __init__(self, inducing_points):\n",
+    "        variational_distribution = CholeskyVariationalDistribution(inducing_points.size(0))\n",
+    "        variational_strategy = VariationalStrategy(\n",
+    "            self, inducing_points, variational_distribution, learn_inducing_locations=True,\n",
+    "        )\n",
+    "        super().__init__(variational_strategy)\n",
+    "        self.mean_module = gpytorch.means.ConstantMean()\n",
+    "        self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the GPRegressor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since we deal with non-exact GP regression, we import skorch's `GPRegressor`. On top of that, this time around we will see how to obtain validation scores using a predefined split. Specifically, we are interested in the mean absolute error. Fortunately, skorch provides all the tools to make this easy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from skorch.probabilistic import GPRegressor\n",
+    "from skorch.callbacks import EpochScoring\n",
+    "from skorch.dataset import Dataset\n",
+    "from skorch.helper import predefined_split\n",
+    "from sklearn.metrics import mean_absolute_error"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First we define the train/validation split using the validation data we split off earlier. Note that the input to `predefined_split` should be a `Dataset`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_split = predefined_split(Dataset(X_valid, y_valid))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Second, we want to calculate the mean absolute error on the validation data, which we can achieve by using skorch's `EpochScoring` and the `mean_absolute_error` metric from sklearn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the \"name\" argument is only important for printing the output\n",
+    "mae_callback = EpochScoring(mean_absolute_error, name='valid_mae')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we initialize the `GPRegressor` using the module, train split, and callback we just defined:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gpr = GPRegressor(\n",
+    "    VariationalModule,\n",
+    "    module__inducing_points=X_train[:500] if DEVICE == 'cpu' else X_train.cuda()[:500],\n",
+    "\n",
+    "    criterion=gpytorch.mlls.VariationalELBO,\n",
+    "    criterion__num_data=int(0.8 * len(y_train)),\n",
+    "\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=0.01,\n",
+    "    batch_size=1024,\n",
+    "    train_split=train_split,\n",
+    "    callbacks=[mae_callback],\n",
+    "    device=DEVICE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some notes:\n",
+    "\n",
+    "- Our variational strategy requires some data as \"inducing points\", which we pass to the module as `module__inducing_points`. We will use 500 data points from our training data for this.\n",
+    "- We use a criterion to match our variational GP, in this case `VariationalELBO` (the default).\n",
+    "- We can now take advantage of batching by setting `batch_size=1024` instead of -1.\n",
+    "- We set <code>criterion__num_data=int(0.8 * len(y_train))</code>, i.e. to 80% of the total data. This is because above, we split off 20% of the training data for validation. If this number if different (e.g. because you perform a grid search), you should adjust the ratio accordingly."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "    <b>Warning:</b>\n",
+    "    If you run a grid search, sklearn will split <code>X</code> into several folds, some of which might not contain the samples <code>X[:500]</code>, which can lead to data leakage. In this case, you might want to set aside those inducing points completely, not using them for training at all.\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fitting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  epoch    train_loss    valid_loss    valid_mae     dur\n",
+      "-------  ------------  ------------  -----------  ------\n",
+      "      1        \u001b[36m1.0009\u001b[0m        \u001b[32m0.8361\u001b[0m       \u001b[35m0.1152\u001b[0m  1.5976\n",
+      "      2        \u001b[36m0.7821\u001b[0m        \u001b[32m0.7294\u001b[0m       \u001b[35m0.0883\u001b[0m  1.6898\n",
+      "      3        \u001b[36m0.6922\u001b[0m        \u001b[32m0.6524\u001b[0m       \u001b[35m0.0785\u001b[0m  1.6398\n",
+      "      4        \u001b[36m0.6210\u001b[0m        \u001b[32m0.5857\u001b[0m       \u001b[35m0.0763\u001b[0m  1.5395\n",
+      "      5        \u001b[36m0.5564\u001b[0m        \u001b[32m0.5228\u001b[0m       \u001b[35m0.0757\u001b[0m  1.5039\n",
+      "      6        \u001b[36m0.4937\u001b[0m        \u001b[32m0.4605\u001b[0m       0.0760  1.5208\n",
+      "      7        \u001b[36m0.4314\u001b[0m        \u001b[32m0.3982\u001b[0m       0.0759  1.5726\n",
+      "      8        \u001b[36m0.3690\u001b[0m        \u001b[32m0.3356\u001b[0m       \u001b[35m0.0754\u001b[0m  1.5846\n",
+      "      9        \u001b[36m0.3064\u001b[0m        \u001b[32m0.2728\u001b[0m       \u001b[35m0.0750\u001b[0m  1.5456\n",
+      "     10        \u001b[36m0.2436\u001b[0m        \u001b[32m0.2098\u001b[0m       \u001b[35m0.0746\u001b[0m  1.6207\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<class 'skorch.probabilistic.GPRegressor'>[initialized](\n",
+       "  module_=VariationalModule(\n",
+       "    (variational_strategy): VariationalStrategy(\n",
+       "      (_variational_distribution): CholeskyVariationalDistribution()\n",
+       "    )\n",
+       "    (mean_module): ConstantMean()\n",
+       "    (covar_module): ScaleKernel(\n",
+       "      (base_kernel): RBFKernel(\n",
+       "        (raw_lengthscale_constraint): Positive()\n",
+       "        (distance_module): Distance()\n",
+       "      )\n",
+       "      (raw_outputscale_constraint): Positive()\n",
+       "    )\n",
+       "  ),\n",
+       ")"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gpr.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the trained model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As always, we can take a look at the model prediction and the confidence intervals. We only show the first 50 predictions because the time series is really long."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred, y_std = gpr.predict(X_valid[:50], return_std=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(16, 8))\n",
+    "x_vec = np.arange(50)\n",
+    "ax.fill_between(x_vec, y_pred - y_std, y_pred + y_std, alpha=0.5, label='+/- 1 std dev')\n",
+    "ax.plot(x_vec, y_pred, label='prediction', color='blue')\n",
+    "ax.plot(x_vec, y_valid[:50], 'ko', label='true')\n",
+    "ax.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "GPs are most frequently used for regression, but it's possible to use them for classification as well. Since the output distribution cannot be a Gaussian in case of classification, we cannot use exact GPs for this. Instead, we again rely on variational GPs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Binary classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For binary classification, we can use skorch's `GPBinaryClassifier`, which uses `gpytorch.likelihoods.BernoulliLikelihood` by default. Bernoulli distributions can be used to model binary outcomes, which is exactly what we're interested in."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section is loosely based on the following GPyTorch tutorial:\n",
+    "\n",
+    "https://docs.gpytorch.ai/en/stable/examples/04_Variational_and_Approximate_GPs/Non_Gaussian_Likelihoods.html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, we will rely on a toy dataset based on the sine function with added noise for this section. However, instead of defining a regression target, we transform the target into a classification problem by assigning the label 1 to positive targets and 0 to negative targets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampling_frequency = 2\n",
+    "X_train = torch.arange(-8, 9, 1 / sampling_frequency).float()\n",
+    "y_train = torch.sin(X_train) + 0.5 * torch.rand(len(X_train)) - 0.25\n",
+    "y_train = (y_train > 0).long()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_valid = torch.linspace(-10, 10, 100)\n",
+    "y_valid = (torch.sin(X_valid) > 0).long()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f5206e76550>"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, color='red', label='true')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the module"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from gpytorch.variational import UnwhitenedVariationalStrategy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As in the previous example using variational GP, we need to define a variational strategy for our module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GPClassificationModule(ApproximateGP):\n",
+    "    def __init__(self, inducing_points):\n",
+    "        variational_distribution = CholeskyVariationalDistribution(inducing_points.size(0))\n",
+    "        variational_strategy = UnwhitenedVariationalStrategy(\n",
+    "            self, inducing_points, variational_distribution, learn_inducing_locations=False,\n",
+    "        )\n",
+    "        super().__init__(variational_strategy)\n",
+    "        self.mean_module = gpytorch.means.ConstantMean()\n",
+    "        self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        latent_pred = gpytorch.distributions.MultivariateNormal(mean_x, covar_x)\n",
+    "        return latent_pred"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the GPBinaryClassifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from skorch.probabilistic import GPBinaryClassifier\n",
+    "from sklearn.metrics import accuracy_score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This time around, instead of using skorch's `GPRegressor`, we will use `GPBinaryClassifier`. The rest is pretty much the same as above. As inducing points, we use the whole training dataset, since it's only so small. For bigger datasets, you might want to choose a subset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gpc = GPBinaryClassifier(\n",
+    "    GPClassificationModule,\n",
+    "    module__inducing_points=X_train if DEVICE == 'cpu' else X_train.cuda(),\n",
+    "    criterion__num_data=len(X_train),\n",
+    "\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=0.01,\n",
+    "    max_epochs=30,\n",
+    "    device=DEVICE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fitting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For classification, `GPBinaryClassifier` performs an internal, stratified train/validation split, as usual for skorch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  epoch    train_acc    train_loss    valid_acc    valid_loss     dur\n",
+      "-------  -----------  ------------  -----------  ------------  ------\n",
+      "      1       \u001b[36m0.4444\u001b[0m        \u001b[32m0.9079\u001b[0m       \u001b[35m0.5714\u001b[0m        \u001b[31m1.0306\u001b[0m  0.1186\n",
+      "      2       \u001b[36m1.0000\u001b[0m        1.0134       0.5714        \u001b[31m0.9842\u001b[0m  0.0186\n",
+      "      3       1.0000        0.9567       0.5714        \u001b[31m0.9721\u001b[0m  0.0196\n",
+      "      4       1.0000        0.9365       0.5714        0.9749  0.0229\n",
+      "      5       1.0000        0.9311       0.5714        \u001b[31m0.9715\u001b[0m  0.0224\n",
+      "      6       1.0000        0.9193       0.5714        \u001b[31m0.9549\u001b[0m  0.0229\n",
+      "      7       1.0000        \u001b[32m0.8940\u001b[0m       0.5714        \u001b[31m0.9396\u001b[0m  0.0204\n",
+      "      8       1.0000        \u001b[32m0.8700\u001b[0m       0.5714        \u001b[31m0.9385\u001b[0m  0.0171\n",
+      "      9       1.0000        \u001b[32m0.8603\u001b[0m       0.5714        0.9465  0.0186\n",
+      "     10       1.0000        \u001b[32m0.8602\u001b[0m       0.5714        0.9496  0.0167\n",
+      "     11       1.0000        \u001b[32m0.8555\u001b[0m       0.5714        0.9432  0.0188\n",
+      "     12       1.0000        \u001b[32m0.8414\u001b[0m       0.5714        \u001b[31m0.9351\u001b[0m  0.0215\n",
+      "     13       1.0000        \u001b[32m0.8258\u001b[0m       0.5714        \u001b[31m0.9328\u001b[0m  0.0249\n",
+      "     14       1.0000        \u001b[32m0.8157\u001b[0m       0.5714        0.9349  0.0221\n",
+      "     15       1.0000        \u001b[32m0.8101\u001b[0m       0.5714        0.9360  0.0191\n",
+      "     16       1.0000        \u001b[32m0.8033\u001b[0m       0.5714        0.9341  0.0227\n",
+      "     17       1.0000        \u001b[32m0.7935\u001b[0m       0.5714        \u001b[31m0.9319\u001b[0m  0.0210\n",
+      "     18       1.0000        \u001b[32m0.7835\u001b[0m       0.5714        \u001b[31m0.9318\u001b[0m  0.0251\n",
+      "     19       1.0000        \u001b[32m0.7758\u001b[0m       0.5714        0.9330  0.0282\n",
+      "     20       1.0000        \u001b[32m0.7697\u001b[0m       0.5714        0.9332  0.0352\n",
+      "     21       1.0000        \u001b[32m0.7627\u001b[0m       0.5714        0.9319  0.0329\n",
+      "     22       1.0000        \u001b[32m0.7545\u001b[0m       0.5714        \u001b[31m0.9309\u001b[0m  0.0293\n",
+      "     23       1.0000        \u001b[32m0.7467\u001b[0m       0.5714        0.9314  0.0269\n",
+      "     24       1.0000        \u001b[32m0.7405\u001b[0m       0.5714        0.9324  0.0290\n",
+      "     25       1.0000        \u001b[32m0.7348\u001b[0m       0.5714        0.9326  0.0238\n",
+      "     26       1.0000        \u001b[32m0.7284\u001b[0m       0.5714        0.9326  0.0311\n",
+      "     27       1.0000        \u001b[32m0.7219\u001b[0m       0.5714        0.9332  0.0290\n",
+      "     28       1.0000        \u001b[32m0.7161\u001b[0m       0.5714        0.9338  0.0270\n",
+      "     29       1.0000        \u001b[32m0.7104\u001b[0m       0.5714        0.9336  0.0204\n",
+      "     30       1.0000        \u001b[32m0.7042\u001b[0m       0.5714        0.9335  0.0226\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<class 'skorch.probabilistic.GPBinaryClassifier'>[initialized](\n",
+       "  module_=GPClassificationModule(\n",
+       "    (variational_strategy): UnwhitenedVariationalStrategy(\n",
+       "      (_variational_distribution): CholeskyVariationalDistribution()\n",
+       "    )\n",
+       "    (mean_module): ConstantMean()\n",
+       "    (covar_module): ScaleKernel(\n",
+       "      (base_kernel): RBFKernel(\n",
+       "        (raw_lengthscale_constraint): Positive()\n",
+       "        (distance_module): Distance()\n",
+       "      )\n",
+       "      (raw_outputscale_constraint): Positive()\n",
+       "    )\n",
+       "  ),\n",
+       ")"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gpc.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the trained model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f5206e76f10>"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_proba = gpc.predict_proba(X_valid)\n",
+    "y_proba = y_proba[:, 1]  # take probability for class=1\n",
+    "y_pred = gpc.predict(X_valid)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(X_train, y_train, 'ko', label='train data')\n",
+    "ax.plot(X_valid, y_valid, color='red', label='true')\n",
+    "ax.plot(X_valid, y_proba, color='blue', label='prediction')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here are the accuracy scores and training and validation data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9117647058823529"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy_score(y_train, gpc.predict(X_train))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.78"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy_score(y_valid, gpc.predict(X_valid))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see, the model performs reasonably on the dataset but the probabilities are not fantastic. Other kinds of models might do better."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multiclass Classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Currently, skorch does not directly support multiclass classification. We can still get there, however, by using sklearn's [`OneVsRestClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.multiclass.OneVsRestClassifier.html) with `GPBinaryClassifier`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.multiclass import OneVsRestClassifier"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we use a synthetic multiclass classification dataset provided by sklearn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import make_classification\n",
+    "from sklearn.model_selection import train_test_split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X, y = make_classification(n_samples=200, n_informative=10, n_classes=5, random_state=0)\n",
+    "X = X.astype(np.float32)\n",
+    "y = y.astype(np.int64)\n",
+    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We use the same module as previously and again define a `GPBinaryClassifier`. We set `verbose=0` to not get flooded by print outputs, and we set `train_split=False` since we're not interested in internal validation scores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gpc = GPBinaryClassifier(\n",
+    "    GPClassificationModule,\n",
+    "    # explicit conversion to torch tensor necessary\n",
+    "    module__inducing_points=torch.as_tensor(X_train) if DEVICE == 'cpu' else torch.as_tensor(X_train).cuda(),\n",
+    "    criterion__num_data=len(X_train),\n",
+    "\n",
+    "    optimizer=torch.optim.Adam,\n",
+    "    lr=0.05,\n",
+    "    max_epochs=200,\n",
+    "    verbose=0,\n",
+    "    train_split=False,\n",
+    "    device=DEVICE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we wrap our binary classifier inside sklearn's `OneVsRestClassifier`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clf = OneVsRestClassifier(gpc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fitting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "OneVsRestClassifier(estimator=<class 'skorch.probabilistic.GPBinaryClassifier'>[uninitialized](\n",
+       "  module=<class '__main__.GPClassificationModule'>,\n",
+       "  module__inducing_points=tensor([[-0.4209, -1.8626,  1.7317,  ..., -1.4448, -1.1847,  1.0305],\n",
+       "          [ 2.9429,  2.0599,  5.1854,  ...,  0.3005, -0.5200, -0.8204],\n",
+       "          [-0.2996, -1.3898,  1.9115,  ...,  1.2798,  2.5717,  0.2900],\n",
+       "          ...,\n",
+       "          [ 1.6054, -3.4834,  2.6305,  ..., -0.5219, -0.2894, -0.1725],\n",
+       "          [-1.0977, -0.1791, -1.6726,  ..., -0.9357,  1.5292, -0.0447],\n",
+       "          [ 5.3708, -2.4126, -0.8171,  ...,  0.6439,  0.1507,  1.7870]]),\n",
+       "))"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the trained model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here are the accuracy scores and training and validation data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8266666666666667"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf.score(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.66"
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf.score(X_valid, y_valid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The multiclass classifier does quite well on the training data but the score on the validation data leaves something to be desired. Given that we have 5 classes, a naive model would only be 20% accurate, so the given score is markedly better than that, but it's still not spectacular."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/README.md b/notebooks/README.md
index a9217007c..8176245ce 100644
--- a/notebooks/README.md
+++ b/notebooks/README.md
@@ -5,3 +5,4 @@
 * [MNIST](https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/MNIST.ipynb)
 * [MNIST using torchvision](https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/MNIST-torchvision.ipynb)
 * [Transfer Learning](https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Transfer_Learning.ipynb)
+* [Gaussian Processes](https://nbviewer.jupyter.org/github/skorch-dev/skorch/blob/master/notebooks/Gaussian_Processes.ipynb)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 30bf90f0c..f101dd89d 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,6 +1,7 @@
 fire
 flaky
 future>=0.17.1
+gpytorch>=1.5
 jupyter
 matplotlib>=2.0.2
 neptune-client>=0.4.103
diff --git a/skorch/probabilistic.py b/skorch/probabilistic.py
new file mode 100644
index 000000000..748d0a696
--- /dev/null
+++ b/skorch/probabilistic.py
@@ -0,0 +1,1015 @@
+"""Integrate GPyTorch for Gaussian Processes
+
+TODO: verify the assumptions being made and remove from here:
+
+- The criterion always takes likelihood and module as input arguments
+- Always optimize the negative objective function
+- Need elaboration on how batching works - are distributions disjoint?
+
+"""
+
+import pickle
+import re
+import warnings
+
+import gpytorch
+import numpy as np
+import torch
+
+from skorch.net import NeuralNet
+from skorch.dataset import CVSplit
+from skorch.dataset import unpack_data
+from skorch.callbacks import EpochScoring
+from skorch.callbacks import EpochTimer
+from skorch.callbacks import PassthroughScoring
+from skorch.callbacks import PrintLog
+from skorch.exceptions import SkorchWarning
+from skorch.utils import check_is_fitted
+from skorch.utils import get_dim
+from skorch.utils import is_dataset
+from skorch.utils import to_numpy
+from skorch.utils import to_tensor
+
+
+warnings.warn("The API of the Gaussian Process estimators is experimental and may "
+              "change in the future", SkorchWarning)
+
+__all__ = ['ExactGPRegressor', 'GPRegressor', 'GPBinaryClassifier']
+
+
+class GPBase(NeuralNet):
+    """Base class for all Gaussian Process estimators.
+
+    Most notably, a GPyTorch compatible criterion and likelihood should be
+    provided.
+
+    """
+    def __init__(
+            self,
+            module,
+            *args,
+            likelihood,
+            criterion,
+            train_split=None,
+            **kwargs
+    ):
+        self.likelihood = likelihood
+        super().__init__(
+            module,
+            *args,
+            criterion=criterion,
+            train_split=train_split,
+            **kwargs
+        )
+
+    def initialize_module(self):
+        """Initializes likelihood and module."""
+        # pylint: disable=attribute-defined-outside-init
+        ll_kwargs = self.get_params_for('likelihood')
+        self.likelihood_ = self.initialized_instance(self.likelihood, ll_kwargs)
+
+        super().initialize_module()
+        return self
+
+    def initialize_criterion(self):
+        """Initializes the criterion."""
+        # pylint: disable=attribute-defined-outside-init
+
+        # The criterion is always re-initialized here, since it depends on the
+        # likelihood and the module.
+        criterion_params = self.get_params_for('criterion')
+        # criterion takes likelihood as first argument
+        self.criterion_ = self.criterion(
+            likelihood=self.likelihood_,
+            model=self.module_,
+            **criterion_params
+        )
+        return self
+
+    def check_is_fitted(self, attributes=None, *args, **kwargs):
+        """Checks whether the GP is initialized.
+
+        Parameters
+        ----------
+        attributes : iterable of str or None (default=None)
+          All the attributes that are strictly required of a fitted net. By
+          default, those are the `module_` and `likelihood_` attributes.
+
+        Other arguments as in
+        ``sklearn.utils.validation.check_is_fitted``.
+
+        Raises
+        ------
+        skorch.exceptions.NotInitializedError
+          When the given attributes are not present.
+
+        """
+        if attributes is None:
+            attributes = ['module_', 'likelihood_']
+        check_is_fitted(self, attributes, *args, **kwargs)
+
+    def train_step_single(self, batch, **fit_params):
+        """Compute y_pred, loss value, and update net's gradients.
+
+        The module is set to be in train mode (e.g. dropout is
+        applied).
+
+        Parameters
+        ----------
+        batch
+          A single batch returned by the data loader.
+
+        **fit_params : dict
+          Additional parameters passed to the ``forward`` method of
+          the module and to the ``self.train_split`` call.
+
+        Returns
+        -------
+        step : dict
+          A dictionary ``{'loss': loss, 'y_pred': y_pred}``, where the
+          float ``loss`` is the result of the loss function and
+          ``y_pred`` the prediction generated by the PyTorch module.
+
+        """
+        step = super().train_step_single(batch, **fit_params)
+        # To obtain the posterior, the likelihood must be applied on the output
+        # of the module. This cannot be performed inside the module, because the
+        # GPyTorch criteria apply the likelihood on the module output
+        # themselves.
+        step['y_pred'] = self.likelihood_(step['y_pred'])
+        return step
+
+    # pylint: disable=unused-argument
+    def get_loss(self, y_pred, y_true, X=None, training=False):
+        """Return the loss for this batch.
+
+        Parameters
+        ----------
+        y_pred : torch tensor
+          Predicted target values
+
+        y_true : torch tensor
+          True target values.
+
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        training : bool (default=False)
+          Whether train mode should be used or not.
+
+        Returns
+        -------
+        loss : torch Tensor (scalar)
+          The loss to be minimized.
+
+        """
+        loss = super().get_loss(y_pred, y_true, X=X, training=training)
+        if loss.dim() != 0:
+            loss = loss.mean()
+        return -loss
+
+    def evaluation_step(self, batch, training=False):
+        """Perform a forward step to produce the output used for
+        prediction and scoring.
+
+        Therefore, the module is set to evaluation mode by default
+        beforehand which can be overridden to re-enable features
+        like dropout by setting ``training=True``.
+
+        Parameters
+        ----------
+        batch
+          A single batch returned by the data loader.
+
+        training : bool (default=False)
+          Whether to set the module to train mode or not.
+
+        Returns
+        -------
+        y_infer
+          The prediction generated by the module.
+
+        """
+        self.check_is_fitted()
+        Xi, _ = unpack_data(batch)
+        with torch.set_grad_enabled(training), gpytorch.settings.fast_pred_var():
+            self.module_.train(training)
+            y_infer = self.infer(Xi)
+            if isinstance(y_infer, tuple):  # multiple outputs:
+                return (self.likelihood_(y_infer[0]),) + y_infer[1:]
+            return self.likelihood_(y_infer)
+
+    def forward_iter(self, X, *args, **kwargs):
+        """Yield outputs of module forward calls on each batch of data.
+        The storage device of the yielded tensors is determined
+        by the ``device`` parameter.
+
+        Parameters
+        ----------
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        training : bool (default=False)
+          Whether to set the module to train mode or not.
+
+        device : string (default='cpu')
+          The device to store each inference result on.
+          This defaults to CPU memory since there is genereally
+          more memory available there. For performance reasons
+          this might be changed to a specific CUDA device,
+          e.g. 'cuda:0'.
+
+        Yields
+        ------
+        yp : torch tensor
+          Result from a forward call on an individual batch.
+
+        """
+        # GPyTorch caches a couple things that don't depend on the test points
+        # the first time a prediction is made so that the next time a prediction
+        # is made, it doesn't have O(n^3) complexity. These caches get deleted
+        # in some cases, like if the model gets put back in training mode, but
+        # forward_iter doesn't do that, so it's okay.
+        with gpytorch.settings.fast_pred_var():
+            return super().forward_iter(X, *args, **kwargs)
+
+    def forward(self, X, training=False, device='cpu'):
+        """Gather and concatenate the output from forward call with
+        input data.
+
+        The outputs from ``self.module_.forward`` are gathered on the
+        compute device specified by ``device`` and then concatenated
+        using PyTorch :func:`~torch.cat`. If multiple outputs are
+        returned by ``self.module_.forward``, each one of them must be
+        able to be concatenated this way.
+
+        Notes
+        -----
+        For Gaussian Process modules, the return value of the module is a
+        distribution. These distributions are collected in a list (which may
+        only contain a single element if just one batch was used). Distributions
+        *cannot* be concatenated. Therefore, this method will just return the
+        list of distributions.
+
+        Parameters
+        ----------
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        training : bool (default=False)
+          Whether to set the module to train mode or not.
+
+        device : string (default='cpu')
+          The device to store each inference result on.
+          This defaults to CPU memory since there is genereally
+          more memory available there. For performance reasons
+          this might be changed to a specific CUDA device,
+          e.g. 'cuda:0'.
+
+        Returns
+        -------
+        y_infer : list of gpytorch.distributions.Distribution
+          A list of distributions as generated by the module. The number of
+          elements in this list will depend on the sample size of X and the
+          batch size of the estimator.
+
+        """
+        y_infer = list(self.forward_iter(X, training=training, device=device))
+        return y_infer
+
+    def predict_proba(self, X):
+        raise AttributeError("'predict_proba' is not implemented for {}".format(
+            self.__class__.__name__
+        ))
+
+    def sample(self, X, n_samples, axis=-1):
+        """Return samples conditioned on input data.
+
+        The GP doesn't need to be fitted but it must be initialized.
+
+        By default, samples all calculated including gradients. If you don't
+        need the gradients, call ``sample`` inside ``torch.no_grad()``.
+
+        If the probability distribution does not support the ``rsample`` method
+        (i.e. sampling with gradients), try ``sample`` (i.e. without gradients)
+        instead. One such distribution, at the time of writing, is Bernoulli.
+
+        X : input data
+          The samples where the GP is evaluated.
+
+        n_samples : int
+          The number of samples to return
+
+        axis : int (default=-1)
+          The concatenation axis of the samples. Since samples can come in
+          batches, they must be concatenated.
+
+        Returns
+        -------
+        samples : torch.Tensor
+          Samples from the posterior distribution.
+
+        """
+        self.check_is_fitted()
+        samples = []
+        for p in self.forward_iter(X):
+            try:
+                sample = p.rsample(torch.Size([n_samples]))
+            except NotImplementedError:
+                # some distributions like Bernoulli have not implemented rsample
+                # (sampling with gradients), try sample instead.
+                sample = p.sample(torch.Size([n_samples]))
+            samples.append(sample)
+
+        return torch.cat(samples, axis=axis)
+
+    def confidence_region(self, X, sigmas=2):
+        """Returns 2 standard deviations above and below the mean.
+
+        X : input data
+          The samples where the GP is evaluated.
+
+        sigmas : int (default=2)
+          The number of standard deviations of the region.
+
+        Returns
+        -------
+        lower : torch.Tensor
+          The lower end of the confidence region.
+
+        upper : torch.Tensor
+          The upper end of the confidence region.
+
+        """
+        nonlin = self._get_predict_nonlinearity()
+        lower, upper = [], []
+        for yi in self.forward_iter(X):
+            posterior = yi[0] if isinstance(yi, tuple) else yi
+            mean = posterior.mean
+            std = posterior.stddev
+            std = std.mul_(sigmas)
+            lower.append(nonlin(mean.sub(std)))
+            upper.append(nonlin(mean.add(std)))
+
+        lower = torch.cat(lower)
+        upper = torch.cat(upper)
+        return lower, upper
+
+    def __getstate__(self):
+        try:
+            return super().__getstate__()
+        except pickle.PicklingError as exc:
+            msg = ("This GPyTorch model cannot be pickled. The reason is probably this:"
+                   " https://github.com/pytorch/pytorch/issues/38137. "
+                   "Try using 'dill' instead of 'pickle'.")
+            raise pickle.PicklingError(msg) from exc
+
+
+class _GPRegressorPredictMixin:
+    """Mixin class that provides a predict method for GP regressors."""
+    def predict(self, X, return_std=False, return_cov=False):
+        """Returns the predicted mean and optionally standard deviation.
+
+        Parameters
+        ----------
+        X : input data
+          Input data where the GP is evaluated.
+
+        return_std : bool (default=False)
+          If True, the standard-deviation of the predictive distribution at the
+          query points is returned along with the mean.
+
+        return_cov : bool (default=False)
+          This exists solely for sklearn compatibility and is not supported by
+          skorch.
+
+        Returns
+        -------
+        y_pred : numpy ndarray
+          Mean of predictive distribution at the query points.
+
+        y_std : numpy ndarray
+          Standard deviation of predictive distribution at query points. Only
+          returned when ``return_std`` is True.
+
+        """
+        if return_cov:
+            msg = ("The 'return_cov' argument is not supported. Please try: "
+                   "'posterior = next(gpr.forward_iter(X)); "
+                   "posterior.covariance_matrix'.")
+            raise NotImplementedError(msg)
+
+        if return_std:
+            return self._predict_with_std(X)
+        return self._predict(X)
+
+    def _predict_with_std(self, X):
+        nonlin = self._get_predict_nonlinearity()
+        y_preds, y_stds = [], []
+        for yi in self.forward_iter(X, training=False):
+            posterior = yi[0] if isinstance(yi, tuple) else yi
+            y_preds.append(to_numpy(nonlin(posterior.mean)))
+            y_stds.append(to_numpy(nonlin(posterior.stddev)))
+
+        y_pred = np.concatenate(y_preds, 0)
+        y_std = np.concatenate(y_stds, 0)
+        return y_pred, y_std
+
+    def _predict(self, X):
+        # When return_std is False, turn on skip_posterior_variances -- this
+        # avoids doing the math for the posterior variances altogether, which
+        # will save a great deal of compute.
+        nonlin = self._get_predict_nonlinearity()
+        y_preds = []
+        with gpytorch.settings.skip_posterior_variances():
+            for yi in self.forward_iter(X, training=False):
+                posterior = yi[0] if isinstance(yi, tuple) else yi
+                y_preds.append(to_numpy(nonlin(posterior.mean)))
+
+        y_pred = np.concatenate(y_preds, 0)
+        return y_pred
+
+
+exact_gp_regr_doc_start = """Exact Gaussian Process regressor
+
+    Use this specifically if you want to perform an exact solution to the
+    Gaussian Process. This implies that the module should by a
+    :class:`~gpytorch.models.ExactGP` module and you cannot use batching (i.e.
+    batch size should be -1).
+
+"""
+
+exact_gp_regr_module_text = """
+
+    Module : gpytorch.models.ExactGP (class or instance)
+      The module needs to return a
+      :class:`~gpytorch.distributions.MultivariateNormal` distribution.
+
+"""
+
+exact_gp_regr_criterion_text = """
+
+    likelihood : gpytorch.likelihoods.GaussianLikelihood (class or instance)
+      The likelihood used for the exact GP regressor. Usually doesn't need to be
+      changed.
+
+    criterion : gpytorch.mlls.ExactMarginalLogLikelihood
+      The objective function to learn the posterior of of the GP regressor.
+      Usually doesn't need to be changed.
+
+"""
+
+exact_gp_regr_batch_size_text = """
+
+    batch_size : int (default=-1)
+      Mini-batch size. For exact GPs, it must be set to -1, since the exact
+      solution cannot deal with batching. To make use of batching, use
+      :class:`.GPRegressor` in conjunction with a variational strategy.
+
+"""
+
+# this is the same text for exact and approximate GP regression
+gp_regr_train_split_text = """
+
+    train_split : None or callable (default=None)
+      If None, there is no train/validation split. Else, train_split should be a
+      function or callable that is called with X and y data and should return
+      the tuple ``dataset_train, dataset_valid``. The validation data may be
+      None. There is no default train split for GP regressors because random
+      splitting is typically not desired, e.g. because there is a temporal
+      relationship between samples.
+
+"""
+
+# this is the same text for all GPs
+gp_likelihood_attribute_text = """
+
+    likelihood_: torch module (instance)
+      The instantiated likelihood.
+
+"""
+
+
+def get_exact_gp_regr_doc(doc):
+    """Customizes the net docs to avoid duplication."""
+    params_start_idx = doc.find('    Parameters\n    ----------')
+    doc = doc[params_start_idx:]
+    doc = exact_gp_regr_doc_start + " " + doc
+
+    pattern = re.compile(r'(\n\s+)(module .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + exact_gp_regr_module_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(criterion .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + exact_gp_regr_criterion_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(batch_size .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + exact_gp_regr_batch_size_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(train_split .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_regr_train_split_text + doc[end:]
+
+    doc = doc + gp_likelihood_attribute_text
+
+    return doc
+
+
+class ExactGPRegressor(_GPRegressorPredictMixin, GPBase):
+    # pylint: disable=missing-docstring
+    __doc__ = get_exact_gp_regr_doc(NeuralNet.__doc__)
+
+    def __init__(
+            self,
+            module,
+            *args,
+            likelihood=gpytorch.likelihoods.GaussianLikelihood,
+            criterion=gpytorch.mlls.ExactMarginalLogLikelihood,
+            batch_size=-1,
+            **kwargs
+    ):
+        super().__init__(
+            module,
+            *args,
+            criterion=criterion,
+            likelihood=likelihood,
+            batch_size=batch_size,
+            **kwargs
+        )
+
+    def initialize_module(self):
+        """Initializes likelihood and module."""
+        # pylint: disable=attribute-defined-outside-init
+
+        # We need a custom implementation here because the module is initialized
+        # with likelihood as an argument, which would not be passed otherwise.
+        # We cannot use self.initialized_instance, since we need to know if
+        # likelihood was actually (re-)initialized or not.
+        likelihood = self.likelihood
+        ll_kwargs = self.get_params_for('likelihood')
+
+        module = self.module
+        module_kwargs = self.get_params_for('module')
+
+        initialized_ll = isinstance(likelihood, torch.nn.Module)
+        initialized_module = isinstance(module, torch.nn.Module)
+        initialized_both = initialized_ll and initialized_module
+
+        if initialized_ll and not ll_kwargs:
+            # likelihood already initialized and no params changed
+            self.likelihood_ = likelihood
+        else:
+            # likelihood needs to be initialized because it's not yet or because
+            # its arguments changed
+            if initialized_ll:
+                likelihood = type(likelihood)
+            self.likelihood_ = likelihood(**ll_kwargs)
+
+        # ExactGP requires likelihood to be passed
+        if 'likelihood' not in module_kwargs:
+            module_kwargs['likelihood'] = self.likelihood_
+
+        if initialized_both and not module_kwargs:
+            # module and likelihood were already initialized no no params changed
+            self.module_ = module
+        else:
+            # module needs to be initialized because it's not yet or because
+            # the likelihood and/or its arguments changed
+            if initialized_module:
+                module = type(module)
+            self.module_ = module(**module_kwargs)
+
+        if not isinstance(self.module_, gpytorch.models.ExactGP):
+            raise TypeError("{} requires 'module' to be a gpytorch.models.ExactGP."
+                            .format(self.__class__.__name__))
+        return self
+
+    def fit(self, X, y=None, **fit_params):
+        """Initialize and fit the module.
+
+        If the module was already initialized, by calling fit, the
+        module will be re-initialized (unless ``warm_start`` is True).
+
+        Parameters
+        ----------
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        y : target data, compatible with skorch.dataset.Dataset
+          The same data types as for ``X`` are supported. If your X is
+          a Dataset that contains the target, ``y`` may be set to
+          None.
+
+        **fit_params : dict
+          Additional parameters passed to the ``forward`` method of
+          the module and to the ``self.train_split`` call.
+
+        """
+        if not self.warm_start or not self.initialized_:
+            self.initialize()
+
+        # set training data of the ExactGP module
+        self.module_.set_train_data(
+            inputs=to_tensor(X, device=self.device),
+            targets=to_tensor(y, device=self.device),
+            strict=False,
+        )
+
+        self.partial_fit(X, y, **fit_params)
+        return self
+
+
+gp_regr_doc_start = """Gaussian Process regressor
+
+    Use this for variational and approximate Gaussian process regression. This
+    implies that the module should by a :class:`~gpytorch.models.ApproximateGP`
+    module.
+
+"""
+
+gp_regr_module_text = """
+
+    Module : gpytorch.models.ApproximateGP (class or instance)
+      The GPyTorch module; in contrast to exact GP, the return distribution does
+      not need to be Gaussian.
+
+"""
+
+gp_regr_criterion_text = """
+
+    likelihood : gpytorch.likelihoods.GaussianLikelihood (class or instance)
+      The likelihood used for the exact GP regressor. Usually doesn't need to be
+      changed.
+
+    criterion : gpytorch.mlls.VariationalELBO
+      The objective function to learn the approximate posterior of of the GP
+      regressor.
+
+"""
+
+
+def get_gp_regr_doc(doc):
+    """Customizes the net docs to avoid duplication."""
+    params_start_idx = doc.find('    Parameters\n    ----------')
+    doc = doc[params_start_idx:]
+    doc = gp_regr_doc_start + " " + doc
+
+    pattern = re.compile(r'(\n\s+)(module .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_regr_module_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(criterion .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_regr_criterion_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(train_split .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_regr_train_split_text + doc[end:]
+
+    doc = doc + gp_likelihood_attribute_text
+
+    return doc
+
+
+class GPRegressor(_GPRegressorPredictMixin, GPBase):
+    __doc__ = get_gp_regr_doc(NeuralNet.__doc__)
+
+    def __init__(
+            self,
+            module,
+            *args,
+            likelihood=gpytorch.likelihoods.GaussianLikelihood,
+            criterion=gpytorch.mlls.VariationalELBO,
+            **kwargs
+    ):
+        super().__init__(
+            module,
+            *args,
+            criterion=criterion,
+            likelihood=likelihood,
+            **kwargs
+        )
+
+
+gp_binary_clf_doc_start = """Gaussian Process binary classifier
+
+    Use this for variational and approximate Gaussian process binary
+    classification. This implies that the module should by a
+    :class:`~gpytorch.models.ApproximateGP` module.
+
+"""
+
+gp_binary_clf_module_text = """
+
+    Module : gpytorch.models.ApproximateGP (class or instance)
+      The GPyTorch module; in contrast to exact GP, the return distribution does
+      not need to be Gaussian.
+
+"""
+
+gp_binary_clf_criterion_text = """
+
+    likelihood : gpytorch.likelihoods.BernoulliLikelihood (class or instance)
+      The likelihood used for the exact GP binary classification. Usually
+      doesn't need to be changed.
+
+    criterion : gpytorch.mlls.VariationalELBO
+      The objective function to learn the approximate posterior of of the GP
+      binary classification.
+
+"""
+
+
+def get_gp_binary_clf_doc(doc):
+    """Customizes the net docs to avoid duplication."""
+    params_start_idx = doc.find('    Parameters\n    ----------')
+    doc = doc[params_start_idx:]
+    doc = gp_binary_clf_doc_start + " " + doc
+
+    pattern = re.compile(r'(\n\s+)(module .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_binary_clf_module_text + doc[end:]
+
+    pattern = re.compile(r'(\n\s+)(criterion .*\n)(\s.+){1,99}')
+    start, end = pattern.search(doc).span()
+    doc = doc[:start] + gp_binary_clf_criterion_text + doc[end:]
+
+    doc = doc + gp_likelihood_attribute_text
+
+    return doc
+
+
+class GPBinaryClassifier(GPBase):
+    __doc__ = get_gp_binary_clf_doc(NeuralNet.__doc__)
+
+    def __init__(
+            self,
+            module,
+            *args,
+            likelihood=gpytorch.likelihoods.BernoulliLikelihood,
+            criterion=gpytorch.mlls.VariationalELBO,
+            train_split=CVSplit(5, stratified=True),
+            threshold=0.5,
+            **kwargs
+    ):
+        super().__init__(
+            module,
+            *args,
+            criterion=criterion,
+            likelihood=likelihood,
+            train_split=train_split,
+            **kwargs
+        )
+        self.threshold = threshold
+
+    @property
+    def _default_callbacks(self):
+        return [
+            ('epoch_timer', EpochTimer()),
+            ('train_loss', PassthroughScoring(
+                name='train_loss',
+                on_train=True,
+            )),
+            ('valid_loss', PassthroughScoring(
+                name='valid_loss',
+            )),
+            # add train accuracy because by default, there is no valid split
+            ('train_acc', EpochScoring(
+                'accuracy',
+                name='train_acc',
+                lower_is_better=False,
+                on_train=True,
+            )),
+            ('valid_acc', EpochScoring(
+                'accuracy',
+                name='valid_acc',
+                lower_is_better=False,
+            )),
+            ('print_log', PrintLog()),
+        ]
+
+    @property
+    def classes_(self):
+        return [0, 1]
+
+    # pylint: disable=signature-differs
+    def check_data(self, X, y):
+        super().check_data(X, y)
+        if (not is_dataset(X)) and (get_dim(y) != 1):
+            raise ValueError("The target data should be 1-dimensional.")
+
+    def predict_proba(self, X):
+        """Return probability estimates for the samples.
+
+        If the module's forward method returns multiple outputs as a
+        tuple, it is assumed that the first output contains the
+        relevant information and the other values are ignored. If all
+        values are relevant, consider using
+        :meth:`.forward` instead.
+
+        Parameters
+        ----------
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        Returns
+        -------
+        y_proba : numpy ndarray
+          Probabilities for the samples, with the first column corresponding to
+          class 0 and the second to class 1.
+
+        """
+        nonlin = self._get_predict_nonlinearity()
+        y_probas = []
+        for yi in self.forward_iter(X, training=False):
+            posterior = yi[0] if isinstance(yi, tuple) else yi
+            y_probas.append(to_numpy(nonlin(posterior.mean)))
+
+        y_proba = np.concatenate(y_probas, 0).reshape(-1, 1)
+        return np.hstack((1 - y_proba, y_proba))
+
+    def predict(self, X):
+        """Return class labels for samples in X.
+
+        If the module's forward method returns multiple outputs as a
+        tuple, it is assumed that the first output contains the
+        relevant information and the other values are ignored. If all
+        values are relevant, consider using
+        :meth:`.forward` instead.
+
+        Parameters
+        ----------
+        X : input data, compatible with skorch.dataset.Dataset
+          By default, you should be able to pass:
+
+            * numpy arrays
+            * torch tensors
+            * pandas DataFrame or Series
+            * scipy sparse CSR matrices
+            * a dictionary of the former three
+            * a list/tuple of the former three
+            * a Dataset
+
+          If this doesn't work with your data, you have to pass a
+          ``Dataset`` that can deal with the data.
+
+        Returns
+        -------
+        y_pred : numpy ndarray
+          Predicted target values for ``X``.
+
+        """
+        y_proba = self.predict_proba(X)
+        return (y_proba[:, 1] > self.threshold).astype('uint8')
+
+
+# BB: I could never get any reasonable results using ``SoftmaxLikelihood``. In
+# fact, it always produces NaN. Probably I use it wrongly but there are no
+# complete examples that I could find. I leave the commented code here for now,
+# in the hopes that there is an easy fix in the future.
+
+# class _GPClassifier(GPBase):
+#     def __init__(
+#             self,
+#             module,
+#             *args,
+#             likelihood=gpytorch.likelihoods.SoftmaxLikelihood,
+#             criterion=gpytorch.mlls.VariationalELBO,
+#             train_split=CVSplit(5, stratified=True),
+#             classes=None,
+#             **kwargs
+#     ):
+#         super().__init__(
+#             module,
+#             *args,
+#             criterion=criterion,
+#             likelihood=likelihood,
+#             train_split=train_split,
+#             **kwargs
+#         )
+#         self.classes = classes
+
+#     @property
+#     def _default_callbacks(self):
+#         return [
+#             ('epoch_timer', EpochTimer()),
+#             ('train_loss', PassthroughScoring(
+#                 name='train_loss',
+#                 on_train=True,
+#             )),
+#             ('valid_loss', PassthroughScoring(
+#                 name='valid_loss',
+#             )),
+#             # add train accuracy because by default, there is no valid split
+#             ('train_acc', EpochScoring(
+#                 'accuracy',
+#                 name='train_acc',
+#                 lower_is_better=False,
+#                 on_train=True,
+#             )),
+#             ('valid_acc', EpochScoring(
+#                 'accuracy',
+#                 name='valid_acc',
+#                 lower_is_better=False,
+#             )),
+#             ('print_log', PrintLog()),
+#         ]
+
+#     @property
+#     def classes_(self):
+#         if self.classes is not None:
+#             if not len(self.classes):
+#                 raise AttributeError("{} has no attribute 'classes_'".format(
+#                     self.__class__.__name__))
+#             return self.classes
+#         return self.classes_inferred_
+
+#     # pylint: disable=signature-differs
+#     def check_data(self, X, y):
+#         if (
+#                 (y is None) and
+#                 (not is_dataset(X)) and
+#                 (self.iterator_train is DataLoader)
+#         ):
+#             msg = ("No y-values are given (y=None). You must either supply a "
+#                    "Dataset as X or implement your own DataLoader for "
+#                    "training (and your validation) and supply it using the "
+#                    "``iterator_train`` and ``iterator_valid`` parameters "
+#                    "respectively.")
+#             raise ValueError(msg)
+#         if y is not None:
+#             # pylint: disable=attribute-defined-outside-init
+#             self.classes_inferred_ = np.unique(y)
+
+#     def predict_proba(self, X):
+#         """TODO"""
+#         nonlin = self._get_predict_nonlinearity()
+#         y_probas = []
+#         for yi in self.forward_iter(X, training=False):
+#             posterior = yi[0] if isinstance(yi, tuple) else yi
+#             y_probas.append(to_numpy(nonlin(posterior.mean)))
+
+#         y_proba = np.concatenate(y_probas, 0)
+#         return y_proba
+
+#     def predict(self, X):
+#         """TODO
+#         """
+#         return self.predict_proba(X).argmax(axis=1)
diff --git a/skorch/tests/test_probabilistic.py b/skorch/tests/test_probabilistic.py
new file mode 100644
index 000000000..92fda0ff5
--- /dev/null
+++ b/skorch/tests/test_probabilistic.py
@@ -0,0 +1,689 @@
+"""Tests for probabilistic.py"""
+
+import copy
+import pickle
+import re
+from distutils.version import LooseVersion
+
+import numpy as np
+import pytest
+from sklearn.base import clone
+from sklearn.model_selection import GridSearchCV
+from sklearn.pipeline import Pipeline
+import torch
+from torch.testing import assert_allclose
+
+from skorch.utils import is_torch_data_type
+from skorch.utils import to_numpy
+
+
+gpytorch = pytest.importorskip('gpytorch')
+
+# extract pytorch version without possible '+something' suffix
+pytorch_version, _, _ = torch.__version__.partition('+')
+if LooseVersion(pytorch_version) == '1.7.1':
+    pytest.skip("gpytorch does not work with PyTorch 1.7.1", allow_module_level=True)
+
+
+def get_batch_size(dist):
+    """Return the shape of the distribution
+
+    The method/attribute required to determine the shape depends on the kind of
+    distrubtion.
+
+    """
+    shape = getattr(dist, 'shape', None)
+    if shape:
+        return shape[0]
+
+    get_base_samples = getattr(dist, 'get_base_samples', None)
+    if get_base_samples:
+        return get_base_samples().shape[0]
+
+    shape = getattr(dist, 'batch_shape', None)
+    if shape:
+        return shape[0]
+
+    raise AttributeError(f"Could not determine shape of {dist}")
+
+
+# PyTorch Modules are defined on the module root to make them pickleable.
+
+class RbfModule(gpytorch.models.ExactGP):
+    """Simple exact GP regression module"""
+    def __init__(self, likelihood):
+        super().__init__(None, None, likelihood)
+        self.mean_module = gpytorch.means.ConstantMean()
+        self.covar_module = gpytorch.kernels.RBFKernel()
+
+    def forward(self, x):
+        mean_x = self.mean_module(x)
+        covar_x = self.covar_module(x)
+        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
+
+
+class VariationalRegressionModule(gpytorch.models.ApproximateGP):
+    """GP regression for variational inference"""
+    def __init__(self, inducing_points, eps=1e-6):
+        variational_distribution = gpytorch.variational.CholeskyVariationalDistribution(
+            inducing_points.size(0))
+        variational_strategy = gpytorch.variational.VariationalStrategy(
+            self,
+            inducing_points,
+            variational_distribution,
+            learn_inducing_locations=True,
+        )
+        super().__init__(variational_strategy)
+        self.mean_module = gpytorch.means.ConstantMean()
+        self.covar_module = gpytorch.kernels.ScaleKernel(
+            gpytorch.kernels.RBFKernel(eps=eps))
+
+    def forward(self, x):
+        mean_x = self.mean_module(x)
+        covar_x = self.covar_module(x)
+        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
+
+
+class VariationalBinaryClassificationModule(gpytorch.models.ApproximateGP):
+    """GP classification for variational inference"""
+    def __init__(self, inducing_points, eps=1e-6):
+        variational_distribution = gpytorch.variational.CholeskyVariationalDistribution(
+            inducing_points.size(0))
+        variational_strategy = gpytorch.variational.UnwhitenedVariationalStrategy(
+            self,
+            inducing_points,
+            variational_distribution,
+            learn_inducing_locations=False,
+        )
+        super().__init__(variational_strategy)
+        self.mean_module = gpytorch.means.ConstantMean()
+        self.covar_module = gpytorch.kernels.ScaleKernel(
+            gpytorch.kernels.RBFKernel(eps=eps))
+
+    def forward(self, x):
+        mean_x = self.mean_module(x)
+        covar_x = self.covar_module(x)
+        latent_pred = gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
+        return latent_pred
+
+
+class BaseProbabilisticTests:
+    """Base class for all GP estimators.
+
+    This class defined all fixtures, most of which need to be implemented by the
+    respective subclass, as well as all the tests. The tests take care of using
+    attributes and properties that are true for all sorts of GPs (e.g. only
+    using parameters shared by all likelihoods).
+
+    """
+    #####################
+    # testing functions #
+    #####################
+
+    @staticmethod
+    def assert_values_differ(x):
+        x = to_numpy(x)
+        assert len(np.unique(x)) > 1
+
+    ##########################
+    # constants and fixtures #
+    ##########################
+
+    @property
+    def n_samples(self):
+        # expects int
+        return NotImplementedError
+
+    @property
+    def n_targets(self):
+        # expects int
+        raise NotImplementedError
+
+    @property
+    def supports_predict_proba(self):
+        # expects bool
+        raise NotImplementedError
+
+    @property
+    def supports_return_std(self):
+        # expects bool
+        # This only checks if the argument is allowed by predict, not whether it
+        # actually implements a solution
+        raise NotImplementedError
+
+    @property
+    def supports_return_cov(self):
+        # expects bool
+        # This only checks if the argument is allowed by predict, not whether it
+        # actually implements a solution
+        raise NotImplementedError
+
+    @property
+    def settable_params(self):
+        # expects dict of parameters that can be set with set_params
+        raise NotImplementedError
+
+    @property
+    def scoring(self):
+        # the default scoring function of this estimator, must be sklearn
+        # compatible
+        raise NotImplementedError
+
+    @pytest.fixture
+    def gp_cls(self):
+        raise NotImplementedError
+
+    @pytest.fixture
+    def module_cls(self):
+        raise NotImplementedError
+
+    @pytest.fixture
+    def module_multioutput_cls(self):
+        # since multioutput is not currently being tested, not an abstract
+        # method
+        pass
+
+    @pytest.fixture
+    def data(self):
+        raise NotImplementedError
+
+    @pytest.fixture
+    def gp(self, gp_cls, module_cls, data):
+        raise NotImplementedError
+
+    @pytest.fixture
+    def gp_fit(self, gp, data):
+        X, y = data
+        return gp.fit(X, y)
+
+    @pytest.fixture
+    def gp_multioutput(self, gp_cls, module_multioutput_cls, data):
+        # should be fitted; since it's not currently being tested, not an
+        # abstract method
+        pass
+
+    @pytest.fixture
+    def pipe(self, gp):
+        return Pipeline([
+            ('noop', None),
+            ('gp', gp),
+        ])
+
+    ######################
+    # saving and loading #
+    ######################
+
+    @pytest.mark.xfail(strict=True)
+    def test_pickling(self, gp_fit):
+        # Currently fails because of issues outside of our control, this test
+        # should alert us to when the issue has been fixed. Some issues have
+        # been fixed in https://github.com/cornellius-gp/gpytorch/pull/1336 but
+        # not all.
+        pickle.dumps(gp_fit)
+
+    def test_pickle_error_msg(self, gp_fit):
+        # Should eventually be replaced by a test that saves and loads the model
+        # using pickle and checks that the predictions are identical
+        msg = ("This GPyTorch model cannot be pickled. The reason is probably this:"
+               " https://github.com/pytorch/pytorch/issues/38137. "
+               "Try using 'dill' instead of 'pickle'.")
+        with pytest.raises(pickle.PicklingError, match=msg):
+            pickle.dumps(gp_fit)
+
+    def test_deepcopy(self, gp_fit):
+        # Should eventually be replaced by a test that saves and loads the model
+        # using deepcopy and checks that the predictions are identical
+        msg = ("This GPyTorch model cannot be pickled. The reason is probably this:"
+               " https://github.com/pytorch/pytorch/issues/38137. "
+               "Try using 'dill' instead of 'pickle'.")
+        with pytest.raises(pickle.PicklingError, match=msg):
+            copy.deepcopy(gp_fit)  # doesn't raise
+
+    def test_clone(self, gp_fit):
+        clone(gp_fit)  # doesn't raise
+
+    def test_save_load_params(self, gp_fit, tmpdir):
+        gp2 = clone(gp_fit).initialize()
+
+        # check first that parameters are not equal
+        for (_, p0), (_, p1) in zip(
+                gp_fit.get_all_learnable_params(), gp2.get_all_learnable_params(),
+        ):
+            assert not (p0 == p1).all()
+
+        # save and load params to gp2
+        p_module = tmpdir.join('module.pt')
+        p_likelihood = tmpdir.join('likelihood.pt')
+        with open(str(p_module), 'wb') as fm, open(str(p_likelihood), 'wb') as fll:
+            gp_fit.save_params(f_params=fm, f_likelihood=fll)
+        with open(str(p_module), 'rb') as fm, open(str(p_likelihood), 'rb') as fll:
+            gp2.load_params(f_params=fm, f_likelihood=fll)
+
+        # now parameters should be equal
+        for (n0, p0), (n1, p1) in zip(
+                gp_fit.get_all_learnable_params(), gp2.get_all_learnable_params(),
+        ):
+            assert n0 == n1
+            assert_allclose(p0, p1)
+
+    ##############
+    # functional #
+    ##############
+
+    def test_fit(self, gp_fit, recwarn):
+        # fitting does not raise anything and triggers no warning
+        assert not recwarn.list
+
+    def test_gp_learns(self, gp_fit):
+        history = gp_fit.history
+        assert history[0, 'train_loss'] > 0.5 * history[-1, 'train_loss']
+
+    def test_forward(self, gp_fit, data):
+        X = data[0]
+        y_forward = gp_fit.forward(X)
+
+        for yi in y_forward:
+            assert isinstance(yi, torch.distributions.distribution.Distribution)
+
+        total_shape = sum(get_batch_size(p) for p in y_forward)
+        assert total_shape == self.n_samples
+
+    def test_predict(self, gp_fit, data):
+        X = data[0]
+        y_pred = gp_fit.predict(X)
+
+        assert isinstance(y_pred, np.ndarray)
+        assert y_pred.shape == (self.n_samples,)
+        self.assert_values_differ(y_pred)
+
+    def test_predict_proba(self, gp_fit, data):
+        if not self.supports_predict_proba:
+            return
+
+        X = data[0]
+        y_proba = gp_fit.predict_proba(X)
+
+        assert isinstance(y_proba, np.ndarray)
+        assert y_proba.shape == (self.n_samples, self.n_targets)
+        self.assert_values_differ(y_proba)
+
+    @pytest.mark.skipif(not torch.cuda.is_available(), reason="no cuda device")
+    def test_fit_and_predict_with_cuda(self, gp, data):
+
+        gp.set_params(device='cuda')
+        X, y = data
+        gp.fit(X, y)
+        y_pred = gp.predict(X)
+        self.assert_values_differ(y_pred)
+
+    def test_in_sklearn_pipeline(self, pipe, data):
+        X, y = data
+        # none of this raises an error
+        pipe.fit(X, y)
+        pipe.predict(X)
+        pipe.set_params(**self.settable_params)
+
+    def test_grid_search_works(self, gp, data, recwarn):
+        X, y = data
+        params = {
+            'lr': [0.01, 0.02],
+            'max_epochs': [10, 20],
+            'likelihood__max_plate_nesting': [1, 2],
+        }
+        gp.set_params(verbose=0)
+        gs = GridSearchCV(gp, params, refit=True, cv=3, scoring=self.scoring)
+        gs.fit(X[:60], y[:60])  # for speed
+
+        # sklearn will catch fit failures and raise a warning, we should thus
+        # check that no warnings are generated
+        assert not recwarn.list
+
+    # Multioutput doesn't work because GPyTorch makes assumptions about the
+    # module output that are not compatible with multiple outputs. The tests are
+    # left in case this is fixed but they're not being executed.
+
+    @pytest.mark.skip
+    def test_fit_multioutput(self, gp_multioutput):
+        # doesn't raise
+        pass
+
+    @pytest.mark.skip
+    def test_multioutput_forward_iter(self, gp_multioutput, data):
+        X = data[0]
+        y_infer = next(gp_multioutput.forward_iter(X))
+
+        assert isinstance(y_infer, tuple)
+        assert len(y_infer) == 3
+        assert y_infer[0].shape[0] == min(len(X), gp_multioutput.batch_size)
+
+    @pytest.mark.skip
+    def test_multioutput_forward(self, gp_multioutput, data):
+        X = data[0]
+        y_infer = gp_multioutput.forward(X)
+
+        assert isinstance(y_infer, tuple)
+        assert len(y_infer) == 2
+        for arr in y_infer:
+            assert is_torch_data_type(arr)
+
+        for output in y_infer:
+            assert len(output) == self.n_samples
+
+    @pytest.mark.skip
+    def test_multioutput_predict(self, gp_multioutput, data):
+        X = data[0]
+
+        # does not raise
+        y_pred = gp_multioutput.predict(X)
+
+        # Expecting only 1 column containing predict class:
+        # (number of samples,)
+        assert y_pred.shape == (self.n_samples)
+        self.assert_values_differ(y_pred)
+
+    @pytest.mark.skip
+    def test_multioutput_predict_proba(self, gp_multioutput, data):
+        X = data[0]
+
+        # does not raise
+        y_proba = gp_multioutput.predict_proba(X)
+        self.assert_values_differ(y_proba)
+
+        # Expecting full output: (number of samples, number of output units)
+        assert y_proba.shape == (self.n_samples, self.n_targets)
+        # Probabilities, hence these limits
+        assert y_proba.min() >= 0
+        assert y_proba.max() <= 1
+
+    ##################
+    # initialization #
+    ##################
+
+    @pytest.mark.parametrize('kwargs,expected', [
+        ({}, ""),
+        ({
+            'likelihood__noise_prior': gpytorch.priors.NormalPrior(0, 1),
+            'likelihood__batch_shape': (345,),
+        }, ""),
+        ({
+            'likelihood__noise_prior': gpytorch.priors.NormalPrior(0, 1),
+            'optimizer__momentum': 0.567,
+        }, ""),
+    ])
+    def test_set_params_uninitialized_net_correct_message(
+            self, gp, kwargs, expected, capsys):
+        # When gp is initialized, if module or optimizer need to be
+        # re-initialized, alert the user to the fact what parameters
+        # were responsible for re-initialization. Note that when the
+        # module parameters but not optimizer parameters were changed,
+        # the optimizer is re-initialized but not because the
+        # optimizer parameters changed.
+        gp.set_params(**kwargs)
+        msg = capsys.readouterr()[0].strip()
+        assert msg == expected
+
+    @pytest.mark.parametrize('kwargs,expected', [
+        ({}, ""),
+        (
+            {'likelihood__max_plate_nesting': 2},
+            ("Re-initializing module because the following "
+             "parameters were re-set: likelihood__max_plate_nesting.\n"
+             "Re-initializing criterion.\n"
+             "Re-initializing optimizer.")
+        ),
+        (
+            {
+                'likelihood__max_plate_nesting': 2,
+                'optimizer__momentum': 0.567,
+            },
+            ("Re-initializing module because the following "
+             "parameters were re-set: likelihood__max_plate_nesting.\n"
+             "Re-initializing criterion.\n"
+             "Re-initializing optimizer.")
+        ),
+    ])
+    def test_set_params_initialized_net_correct_message(
+            self, gp, kwargs, expected, capsys):
+        # When gp is initialized, if module or optimizer need to be
+        # re-initialized, alert the user to the fact what parameters
+        # were responsible for re-initialization. Note that when the
+        # module parameters but not optimizer parameters were changed,
+        # the optimizer is re-initialized but not because the
+        # optimizer parameters changed.
+        gp.initialize().set_params(**kwargs)
+        msg = capsys.readouterr()[0].strip()
+        assert msg == expected
+
+    def test_likelihood_already_initialized_does_not_reinit(self, gp, gp_cls):
+        # When the likelihood is already initialized and no params changed, it
+        # should just be set as is instead of creating a new instance. In
+        # theory, the same should apply to modules but in all the examples here,
+        # modules require params, so we cannot test it.
+
+        gp_init = gp.initialize()
+        # create a new GP instance using this somewhat convoluted approach
+        # because we don't know what arguments are required to initialize from
+        # scratch
+        params = gp_init.get_params()
+        # set likelihood and likelihood to be initialized already
+        params['likelihood'] = gp_init.likelihood_
+        gp = gp_cls(**params).initialize()
+
+        assert gp.likelihood_ is gp_init.likelihood_
+
+    ##########################
+    # probabalistic specific #
+    ##########################
+
+    @pytest.mark.parametrize("n_samples", [1, 2, 10])
+    def test_sampling(self, gp, data, n_samples):
+        X, _ = data
+        samples = gp.initialize().sample(X, n_samples=n_samples)
+        assert samples.shape == (n_samples, len(X))
+
+        # check that values are not all the same -- this can happen when
+        # posterior variances are skipped via a setting
+        self.assert_values_differ(samples)
+
+    def test_confidence_region(self, gp_fit, data):
+        X, _ = data
+
+        # lower bound should always be lower than upper bound
+        lower_1, upper_1 = gp_fit.confidence_region(X, sigmas=1)
+        assert (lower_1 < upper_1).all()
+
+        lower_2, upper_2 = gp_fit.confidence_region(X, sigmas=2)
+        assert (lower_2 < upper_2).all()
+
+        # higher sigmas -> wider regions
+        assert (lower_2 < lower_1).all()
+        assert (upper_2 > upper_1).all()
+
+    def test_predict_return_std(self, gp_fit, data):
+        if not self.supports_return_std:
+            return
+
+        X, _ = data
+        y_proba, y_std = gp_fit.predict(X, return_std=True)
+
+        # not a lot we know for sure about the values of the standard deviation,
+        # hence only test shape and that they're positive
+        assert y_proba.shape == y_std.shape
+        assert (y_std > 0).all()
+        self.assert_values_differ(y_std)
+
+    def test_predict_return_cov(self, gp_fit, data):
+        if not self.supports_return_cov:
+            return
+
+        X, _ = data
+        msg = ("The 'return_cov' argument is not supported. Please try: "
+               "'posterior = next(gpr.forward_iter(X)); posterior.covariance_matrix'.")
+        with pytest.raises(NotImplementedError, match=re.escape(msg)):
+            gp_fit.predict(X, return_cov=True)
+
+
+class TestExactGPRegressor(BaseProbabilisticTests):
+    """Tests for ExactGPRegressor."""
+
+    ##########################
+    # constants and fixtures #
+    ##########################
+
+    n_samples = 34
+    n_targets = 1
+    supports_predict_proba = False
+    supports_return_std = True
+    supports_return_cov = True
+    settable_params = {'gp__likelihood__noise_prior': None}
+    scoring = 'neg_mean_squared_error'
+
+    @pytest.fixture
+    def data(self):
+        X = np.linspace(-8, 8.01, self.n_samples).astype(np.float32)
+        y = (np.sin(X) + np.random.randn(len(X)) * 0.2).astype(np.float32)
+        return X, y
+
+    @pytest.fixture
+    def gp_cls(self):
+        from skorch.probabilistic import ExactGPRegressor
+        return ExactGPRegressor
+
+    @pytest.fixture
+    def module_cls(self):
+        return RbfModule
+
+    @pytest.fixture
+    def gp(self, gp_cls, module_cls):
+        gpr = gp_cls(
+            module_cls,
+            optimizer=torch.optim.Adam,
+            lr=0.1,
+            max_epochs=20,
+        )
+        return gpr
+
+    # pickling and deepcopy work for ExactGPRegressor but not for the others, so
+    # override the expected failures here.
+
+    def test_pickling(self, gp_fit):
+        # does not raise
+        pickle.dumps(gp_fit)
+
+    def test_pickle_error_msg(self, gp_fit):
+        # Should eventually be replaced by a test that saves and loads the model
+        # using pickle and checks that the predictions are identical
+        # FIXME
+        pickle.dumps(gp_fit)
+
+    def test_deepcopy(self, gp_fit):
+        # FIXME
+        copy.deepcopy(gp_fit)  # doesn't raise
+
+    def test_wrong_module_type_raises(self, gp_cls):
+        # ExactGPRegressor requires the module to be an ExactGP, if it's not,
+        # raise an appropriate error message to the user.
+        class VariationalModule(gpytorch.models.ApproximateGP):
+            """Defined on root to make it pickleable"""
+            def __init__(self, likelihood):
+                pass
+
+            def forward(self, x):
+                pass
+
+        gp = gp_cls(VariationalModule)
+        msg = "ExactGPRegressor requires 'module' to be a gpytorch.models.ExactGP."
+        with pytest.raises(TypeError, match=msg):
+            gp.initialize()
+
+
+class TestGPRegressorVariational(BaseProbabilisticTests):
+    """Tests for GPRegressor."""
+
+    ##########################
+    # constants and fixtures #
+    ##########################
+
+    n_samples = 60
+    n_targets = 1
+    supports_predict_proba = False
+    supports_return_std = True
+    supports_return_cov = True
+    settable_params = {'gp__module__eps': 1e-5}
+    scoring = 'neg_mean_squared_error'
+
+    @pytest.fixture
+    def data(self):
+        X = np.linspace(-8, 8.01, self.n_samples).astype(np.float32)
+        y = (np.sin(X) + np.random.randn(len(X)) * 0.2).astype(np.float32)
+        return X, y
+
+    @pytest.fixture
+    def gp_cls(self):
+        from skorch.probabilistic import GPRegressor
+        return GPRegressor
+
+    @pytest.fixture
+    def module_cls(self):
+        return VariationalRegressionModule
+
+    @pytest.fixture
+    def gp(self, gp_cls, module_cls, data):
+        X, y = data
+        gpr = gp_cls(
+            module_cls,
+            module__inducing_points=torch.from_numpy(X[:10]),
+
+            criterion=gpytorch.mlls.VariationalELBO,
+            criterion__num_data=int(0.8 * len(y)),
+            batch_size=24,
+        )
+        # we want to make sure batching is properly tested
+        assert gpr.batch_size < self.n_samples
+        return gpr
+
+
+class TestGPBinaryClassifier(BaseProbabilisticTests):
+    """Tests for GPBinaryClassifier."""
+
+    ##########################
+    # constants and fixtures #
+    ##########################
+
+    n_samples = 50
+    n_targets = 2
+    supports_predict_proba = True
+    supports_return_std = False
+    supports_return_cov = False
+    settable_params = {'gp__module__eps': 1e-5}
+    scoring = 'neg_mean_squared_error'
+
+    @pytest.fixture
+    def data(self):
+        X = np.linspace(-8, 8.01, self.n_samples).astype(np.float32)
+        y = (np.sin(X) + np.random.randn(len(X)) * 0.2 > 0).astype(np.int64)
+        return X, y
+
+    @pytest.fixture
+    def gp_cls(self):
+        from skorch.probabilistic import GPBinaryClassifier
+        return GPBinaryClassifier
+
+    @pytest.fixture
+    def module_cls(self):
+        return VariationalBinaryClassificationModule
+
+    @pytest.fixture
+    def gp(self, gp_cls, module_cls, data):
+        X, y = data
+        gpc = gp_cls(
+            module_cls,
+            module__inducing_points=torch.from_numpy(X[:10]),
+
+            criterion=gpytorch.mlls.VariationalELBO,
+            criterion__num_data=int(0.8 * len(y)),
+            batch_size=24,
+        )
+        # we want to make sure batching is properly tested
+        assert gpc.batch_size < self.n_samples
+        return gpc
diff --git a/skorch/utils.py b/skorch/utils.py
index 4b016275b..c3b535ed2 100644
--- a/skorch/utils.py
+++ b/skorch/utils.py
@@ -30,6 +30,13 @@
 else:
     from sklearn.utils import safe_indexing
 
+GPYTORCH_INSTALLED = False
+try:
+    import gpytorch
+    GPYTORCH_INSTALLED = True
+except ImportError:
+    gpytorch = None
+
 
 class Ansi(Enum):
     BLUE = '\033[94m'
@@ -140,6 +147,9 @@ def to_numpy(X):
 def to_device(X, device):
     """Generic function to modify the device type of the tensor(s) or module.
 
+    PyTorch distribution objects are left untouched, since they don't support an
+    API to move between devices.
+
     Parameters
     ----------
     X : input data
@@ -165,6 +175,10 @@ def to_device(X, device):
     # PackedSequence class inherits from a namedtuple
     if isinstance(X, (tuple, list)) and (type(X) != PackedSequence):
         return type(X)(to_device(x, device) for x in X)
+
+    if isinstance(X, torch.distributions.distribution.Distribution):
+        return X
+
     return X.to(device)
 
 
@@ -584,6 +598,11 @@ def _sigmoid_then_2d(x):
     return y_proba
 
 
+# TODO only needed if multiclass GP classfication is added
+# def _transpose(x):
+    # return x.T
+
+
 def _infer_predict_nonlinearity(net):
     """Infers the correct nonlinearity to apply for this net
 
@@ -604,6 +623,16 @@ def _infer_predict_nonlinearity(net):
     if isinstance(criterion, BCEWithLogitsLoss):
         return _sigmoid_then_2d
 
+    # TODO only needed if multiclass GP classfication is added
+    # likelihood = getattr(net, 'likelihood_', None)
+    # if (
+    #         likelihood
+    #         and GPYTORCH_INSTALLED
+    #         and isinstance(likelihood, gpytorch.likelihoods.SoftmaxLikelihood)
+    # ):
+    #     # SoftmaxLikelihood returns batch second order
+    #     return _transpose
+
     return _identity