diff --git a/mlp/data_providers.py b/mlp/data_providers.py
index 867a2f9..ebea079 100644
--- a/mlp/data_providers.py
+++ b/mlp/data_providers.py
@@ -75,6 +75,9 @@ class DataProvider(object):
         self.inputs = self.inputs[new_order]
         self.targets = self.targets[new_order]
 
+    def __next__(self):
+        return self.next()
+
     def next(self):
         """Returns next data batch or raises `StopIteration` if at end."""
         if self._curr_batch + 1 > self.num_batches:
@@ -133,13 +136,10 @@ class MNISTDataProvider(DataProvider):
         super(MNISTDataProvider, self).__init__(
             inputs, targets, batch_size, max_num_batches, shuffle_order, rng)
 
-    # def next(self):
-    #    """Returns next data batch or raises `StopIteration` if at end."""
-    #    inputs_batch, targets_batch = super(MNISTDataProvider, self).next()
-    #    return inputs_batch, self.to_one_of_k(targets_batch)
-    
-    def __next__(self):
-        return self.next()
+    def next(self):
+        """Returns next data batch or raises `StopIteration` if at end."""
+        inputs_batch, targets_batch = super(MNISTDataProvider, self).next()
+        return inputs_batch, self.to_one_of_k(targets_batch)
 
     def to_one_of_k(self, int_targets):
         """Converts integer coded class target to 1 of K coded targets.
@@ -156,21 +156,23 @@ class MNISTDataProvider(DataProvider):
             to zero except for the column corresponding to the correct class
             which is equal to one.
         """
-        raise NotImplementedError()
+        one_of_k_targets = np.zeros((int_targets.shape[0], self.num_classes))
+        one_of_k_targets[range(int_targets.shape[0]), int_targets] = 1
+        return one_of_k_targets
 
 
 class MetOfficeDataProvider(DataProvider):
     """South Scotland Met Office weather data provider."""
 
     def __init__(self, window_size, batch_size=10, max_num_batches=-1,
-                shuffle_order=True, rng=None):
-        """Create a new Met Offfice data provider object.
+                 shuffle_order=True, rng=None):
+        """Create a new Met Office data provider object.
 
         Args:
             window_size (int): Size of windows to split weather time series
-            data into. The constructed input features will be the first
-            `window_size - 1` entries in each window and the target outputs
-            the last entry in each window.
+               data into. The constructed input features will be the first
+               `window_size - 1` entries in each window and the target outputs
+               the last entry in each window.
             batch_size (int): Number of data points to include in each batch.
             max_num_batches (int): Maximum number of batches to iterate over
                 in an epoch. If `max_num_batches * batch_size > num_data` then
@@ -180,29 +182,74 @@ class MetOfficeDataProvider(DataProvider):
                 the data before each epoch.
             rng (RandomState): A seeded random number generator.
         """
-        self.window_size = window_size
-        assert window_size > 1, 'window_size must be at least 2.'
         data_path = os.path.join(
             os.environ['MLP_DATA_DIR'], 'HadSSP_daily_qc.txt')
         assert os.path.isfile(data_path), (
             'Data file does not exist at expected path: ' + data_path
         )
-        #TODO: load raw data from text file
-        
-        #TODO: filter out all missing datapoints and flatten to a vector
-        
-        #TODO: normalise data to zero mean, unit standard deviation
+        raw = np.loadtxt(data_path, skiprows=3, usecols=range(2, 32))
+        assert window_size > 1, 'window_size must be at least 2.'
+        self.window_size = window_size
+        # filter out all missing datapoints and flatten to a vector
+        filtered = raw[raw >= 0].flatten()
+        # normalise data to zero mean, unit standard deviation
+        mean = np.mean(filtered)
+        std = np.std(filtered)
+        normalised = (filtered - mean) / std
+        # create a view on to array corresponding to a rolling window
+        shape = (normalised.shape[-1] - self.window_size + 1, self.window_size)
+        strides = normalised.strides + (normalised.strides[-1],)
+        windowed = np.lib.stride_tricks.as_strided(
+            normalised, shape=shape, strides=strides)
+        # inputs are first (window_size - 1) entries in windows
+        inputs = windowed[:, :-1]
+        # targets are last entry in windows
+        targets = windowed[:, -1]
+        super(MetOfficeDataProvider, self).__init__(
+            inputs, targets, batch_size, max_num_batches, shuffle_order, rng)
 
-        #TODO: convert from flat sequence to windowed data
+class CCPPDataProvider(DataProvider):
 
-        #TODO: separate into inputs and targets
-        # inputs are the first (window_size - 1) entries in windows
-        # inputs = ...
-        # targets are the last entries in windows
-        # targets = ...
-        
-        # initialise base class with inputs and targets arrays (uncomment below)
-        # super(MetOfficeDataProvider, self).__init__(
-        #     inputs, targets, batch_size, max_num_batches, shuffle_order, rng)
-    def __next__(self):
-            return self.next()
\ No newline at end of file
+    def __init__(self, which_set='train', input_dims=None, batch_size=10,
+                 max_num_batches=-1, shuffle_order=True, rng=None):
+        """Create a new Combined Cycle Power Plant data provider object.
+
+        Args:
+            which_set: One of 'train' or 'valid'. Determines which portion of
+                data this object should provide.
+            input_dims: Which of the four input dimension to use. If `None` all
+                are used. If an iterable of integers are provided (consisting
+                of a subset of {0, 1, 2, 3}) then only the corresponding
+                input dimensions are included.
+            batch_size (int): Number of data points to include in each batch.
+            max_num_batches (int): Maximum number of batches to iterate over
+                in an epoch. If `max_num_batches * batch_size > num_data` then
+                only as many batches as the data can be split into will be
+                used. If set to -1 all of the data will be used.
+            shuffle_order (bool): Whether to randomly permute the order of
+                the data before each epoch.
+            rng (RandomState): A seeded random number generator.
+        """
+        data_path = os.path.join(
+            os.environ['MLP_DATA_DIR'], 'ccpp_data.npz')
+        assert os.path.isfile(data_path), (
+            'Data file does not exist at expected path: ' + data_path
+        )
+        # check a valid which_set was provided
+        assert which_set in ['train', 'valid'], (
+            'Expected which_set to be either train or valid '
+            'Got {0}'.format(which_set)
+        )
+        # check input_dims are valid
+        if not input_dims is not None:
+            input_dims = set(input_dims)
+            assert input_dims.issubset({0, 1, 2, 3}), (
+                'input_dims should be a subset of {0, 1, 2, 3}'
+            )
+        loaded = np.load(data_path)
+        inputs = loaded[which_set + '_inputs']
+        if input_dims is not None:
+            inputs = inputs[:, input_dims]
+        targets = loaded[which_set + '_targets']
+        super(CCPPDataProvider, self).__init__(
+            inputs, targets, batch_size, max_num_batches, shuffle_order, rng)
diff --git a/mlp/errors.py b/mlp/errors.py
new file mode 100644
index 0000000..e517e85
--- /dev/null
+++ b/mlp/errors.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""Error functions.
+
+This module defines error functions, with the aim of model training being to
+minimise the error function given a set of inputs and target outputs.
+
+The error functions will typically measure some concept of distance between the
+model outputs and target outputs, averaged over all data points in the data set
+or batch.
+"""
+
+import numpy as np
+
+
+class SumOfSquaredDiffsError(object):
+    """Sum of squared differences (squared Euclidean distance) error."""
+
+    def __call__(self, outputs, targets):
+        """Calculates error function given a batch of outputs and targets.
+
+        Args:
+            outputs: Array of model outputs of shape (batch_size, output_dim).
+            targets: Array of target outputs of shape (batch_size, output_dim).
+
+        Returns:
+            Scalar error function value.
+        """
+        #TODO write your code here
+        raise NotImplementedError()
+
+    def grad(self, outputs, targets):
+        """Calculates gradient of error function with respect to outputs.
+
+        Args:
+            outputs: Array of model outputs of shape (batch_size, output_dim).
+            targets: Array of target outputs of shape (batch_size, output_dim).
+
+        Returns:
+            Gradient of error function with respect to outputs. This should be
+            an array of shape (batch_size, output_dim).
+        """
+        #TODO write your code here
+        raise NotImplementedError()
+
+    def __repr__(self):
+        return 'SumOfSquaredDiffsError'
diff --git a/mlp/initialisers.py b/mlp/initialisers.py
new file mode 100644
index 0000000..243adc2
--- /dev/null
+++ b/mlp/initialisers.py
@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""Parameter initialisers.
+
+This module defines classes to initialise the parameters in a layer.
+"""
+
+import numpy as np
+from mlp import DEFAULT_SEED
+
+
+class ConstantInit(object):
+    """Constant parameter initialiser."""
+
+    def __init__(self, value):
+        """Construct a constant parameter initialiser.
+
+        Args:
+            value: Value to initialise parameter to.
+        """
+        self.value = value
+
+    def __call__(self, shape):
+        return np.ones(shape=shape) * self.value
+
+
+class UniformInit(object):
+    """Random uniform parameter initialiser."""
+
+    def __init__(self, low, high, rng=None):
+        """Construct a random uniform parameter initialiser.
+
+        Args:
+            low: Lower bound of interval to sample from.
+            high: Upper bound of interval to sample from.
+            rng (RandomState): Seeded random number generator.
+        """
+        self.low = low
+        self.high = high
+        if rng is None:
+            rng = np.random.RandomState(DEFAULT_SEED)
+        self.rng = rng
+
+    def __call__(self, shape):
+        return self.rng.uniform(low=self.low, high=self.high, size=shape)
+
+
+class NormalInit(object):
+    """Random normal parameter initialiser."""
+
+    def __init__(self, mean, std, rng=None):
+        """Construct a random uniform parameter initialiser.
+
+        Args:
+            mean: Mean of distribution to sample from.
+            std: Standard deviation of distribution to sample from.
+            rng (RandomState): Seeded random number generator.
+        """
+        self.mean = mean
+        self.std = std
+        if rng is None:
+            rng = np.random.RandomState(DEFAULT_SEED)
+        self.rng = rng
+
+    def __call__(self, shape):
+        return self.rng.normal(loc=self.mean, scale=self.std, size=shape)
diff --git a/mlp/layers.py b/mlp/layers.py
new file mode 100644
index 0000000..baa9345
--- /dev/null
+++ b/mlp/layers.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""Layer definitions.
+
+This module defines classes which encapsulate a single layer.
+
+These layers map input activations to output activation with the `fprop`
+method and map gradients with repsect to outputs to gradients with respect to
+their inputs with the `bprop` method.
+
+Some layers will have learnable parameters and so will additionally define
+methods for getting and setting parameter and calculating gradients with
+respect to the layer parameters.
+"""
+
+import numpy as np
+import mlp.initialisers as init
+
+
+class Layer(object):
+    """Abstract class defining the interface for a layer."""
+
+    def fprop(self, inputs):
+        """Forward propagates activations through the layer transformation.
+
+        Args:
+            inputs: Array of layer inputs of shape (batch_size, input_dim).
+
+        Returns:
+            outputs: Array of layer outputs of shape (batch_size, output_dim).
+        """
+        raise NotImplementedError()
+
+    def bprop(self, inputs, outputs, grads_wrt_outputs):
+        """Back propagates gradients through a layer.
+
+        Given gradients with respect to the outputs of the layer calculates the
+        gradients with respect to the layer inputs.
+
+        Args:
+            inputs: Array of layer inputs of shape (batch_size, input_dim).
+            outputs: Array of layer outputs calculated in forward pass of
+                shape (batch_size, output_dim).
+            grads_wrt_outputs: Array of gradients with respect to the layer
+                outputs of shape (batch_size, output_dim).
+
+        Returns:
+            Array of gradients with respect to the layer inputs of shape
+            (batch_size, input_dim).
+        """
+        raise NotImplementedError()
+
+
+class LayerWithParameters(Layer):
+    """Abstract class defining the interface for a layer with parameters."""
+
+    def grads_wrt_params(self, inputs, grads_wrt_outputs):
+        """Calculates gradients with respect to layer parameters.
+
+        Args:
+            inputs: Array of inputs to layer of shape (batch_size, input_dim).
+            grads_wrt_to_outputs: Array of gradients with respect to the layer
+                outputs of shape (batch_size, output_dim).
+
+        Returns:
+            List of arrays of gradients with respect to the layer parameters
+            with parameter gradients appearing in same order in tuple as
+            returned from `get_params` method.
+        """
+        raise NotImplementedError()
+
+    @property
+    def params(self):
+        """Returns a list of parameters of layer.
+
+        Returns:
+            List of current parameter values.
+        """
+        raise NotImplementedError()
+
+
+class AffineLayer(LayerWithParameters):
+    """Layer implementing an affine tranformation of its inputs.
+
+    This layer is parameterised by a weight matrix and bias vector.
+    """
+
+    def __init__(self, input_dim, output_dim,
+                 weights_initialiser=init.UniformInit(-0.1, 0.1),
+                 biases_initialiser=init.ConstantInit(0.),
+                 weights_cost=None, biases_cost=None):
+        """Initialises a parameterised affine layer.
+
+        Args:
+            input_dim (int): Dimension of inputs to the layer.
+            output_dim (int): Dimension of the layer outputs.
+            weights_initialiser: Initialiser for the weight parameters.
+            biases_initialiser: Initialiser for the bias parameters.
+        """
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.weights = weights_initialiser((self.output_dim, self.input_dim))
+        self.biases = biases_initialiser(self.output_dim)
+
+    def fprop(self, inputs):
+        """Forward propagates activations through the layer transformation.
+
+        For inputs `x`, outputs `y`, weights `W` and biases `b` the layer
+        corresponds to `y = W.dot(x) + b`.
+
+        Args:
+            inputs: Array of layer inputs of shape (batch_size, input_dim).
+
+        Returns:
+            outputs: Array of layer outputs of shape (batch_size, output_dim).
+        """
+        #TODO write your code here
+        raise NotImplementedError()
+
+    def grads_wrt_params(self, inputs, grads_wrt_outputs):
+        """Calculates gradients with respect to layer parameters.
+
+        Args:
+            inputs: array of inputs to layer of shape (batch_size, input_dim)
+            grads_wrt_to_outputs: array of gradients with respect to the layer
+                outputs of shape (batch_size, output_dim)
+
+        Returns:
+            list of arrays of gradients with respect to the layer parameters
+            `[grads_wrt_weights, grads_wrt_biases]`.
+        """
+        #TODO write your code here
+        raise NotImplementedError()
+
+    @property
+    def params(self):
+        """A list of layer parameter values: `[weights, biases]`."""
+        return [self.weights, self.biases]
+
+    def __repr__(self):
+        return 'AffineLayer(input_dim={0}, output_dim={1})'.format(
+            self.input_dim, self.output_dim)
diff --git a/mlp/learning_rules.py b/mlp/learning_rules.py
new file mode 100644
index 0000000..22f2bcb
--- /dev/null
+++ b/mlp/learning_rules.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+"""Learning rules.
+
+This module contains classes implementing gradient based learning rules.
+"""
+
+import numpy as np
+
+
+class GradientDescentLearningRule(object):
+    """Simple (stochastic) gradient descent learning rule.
+
+    For a scalar error function `E(p[0], p_[1] ... )` of some set of
+    potentially multidimensional parameters this attempts to find a local
+    minimum of the loss function by applying updates to each parameter of the
+    form
+
+        p[i] := p[i] - learning_rate * dE/dp[i]
+
+    With `learning_rate` a positive scaling parameter.
+
+    The error function used in successive applications of these updates may be
+    a stochastic estimator of the true error function (e.g. when the error with
+    respect to only a subset of data-points is calculated) in which case this
+    will correspond to a stochastic gradient descent learning rule.
+    """
+
+    def __init__(self, learning_rate=1e-3):
+        """Creates a new learning rule object.
+
+        Args:
+            learning_rate: A postive scalar to scale gradient updates to the
+                parameters by. This needs to be carefully set - if too large
+                the learning dynamic will be unstable and may diverge, while
+                if set too small learning will proceed very slowly.
+
+        """
+        assert learning_rate > 0., 'learning_rate should be positive.'
+        self.learning_rate = learning_rate
+
+    def initialise(self, params):
+        """Initialises the state of the learning rule for a set or parameters.
+
+        This must be called before `update_params` is first called.
+
+        Args:
+            params: A list of the parameters to be optimised. Note these will
+                be updated *in-place* to avoid reallocating arrays on each
+                update.
+        """
+        self.params = params
+
+    def reset(self):
+        """Resets any additional state variables to their intial values.
+
+        For this learning rule there are no additional state variables so we
+        do nothing here.
+        """
+        pass
+
+    def update_params(self, grads_wrt_params):
+        """Applies a single gradient descent update to all parameters.
+
+        All parameter updates are performed using in-place operations and so
+        nothing is returned.
+
+        Args:
+            grads_wrt_params: A list of gradients of the scalar loss function
+                with respect to each of the parameters passed to `initialise`
+                previously, with this list expected to be in the same order.
+        """
+        for param, grad in zip(self.params, grads_wrt_params):
+            param -= self.learning_rate * grad
+
+
+class MomentumLearningRule(GradientDescentLearningRule):
+    """Gradient descent with momentum learning rule.
+
+    This extends the basic gradient learning rule by introducing extra
+    momentum state variables for each parameter. These can help the learning
+    dynamic help overcome shallow local minima and speed convergence when
+    making multiple successive steps in a similar direction in parameter space.
+
+    For parameter p[i] and corresponding momentum m[i] the updates for a
+    scalar loss function `L` are of the form
+
+        m[i] := mom_coeff * m[i] - learning_rate * dL/dp[i]
+        p[i] := p[i] + m[i]
+
+    with `learning_rate` a positive scaling parameter for the gradient updates
+    and `mom_coeff` a value in [0, 1] that determines how much 'friction' there
+    is the system and so how quickly previous momentum contributions decay.
+    """
+
+    def __init__(self, learning_rate=1e-3, mom_coeff=0.9):
+        """Creates a new learning rule object.
+
+        Args:
+            learning_rate: A postive scalar to scale gradient updates to the
+                parameters by. This needs to be carefully set - if too large
+                the learning dynamic will be unstable and may diverge, while
+                if set too small learning will proceed very slowly.
+            mom_coeff: A scalar in the range [0, 1] inclusive. This determines
+                the contribution of the previous momentum value to the value
+                after each update. If equal to 0 the momentum is set to exactly
+                the negative scaled gradient each update and so this rule
+                collapses to standard gradient descent. If equal to 1 the
+                momentum will just be decremented by the scaled gradient at
+                each update. This is equivalent to simulating the dynamic in
+                a frictionless system. Due to energy conservation the loss
+                of 'potential energy' as the dynamics moves down the loss
+                function surface will lead to an increasingly large 'kinetic
+                energy' and so speed, meaning the updates will become
+                increasingly large, potentially unstably so. Typically a value
+                less than but close to 1 will avoid these issues and cause the
+                dynamic to converge to a local minima where the gradients are
+                by definition zero.
+        """
+        super(MomentumLearningRule, self).__init__(learning_rate)
+        assert mom_coeff >= 0. and mom_coeff <= 1., (
+            'mom_coeff should be in the range [0, 1].'
+        )
+        self.mom_coeff = mom_coeff
+
+    def initialise(self, params):
+        """Initialises the state of the learning rule for a set or parameters.
+
+        This must be called before `update_params` is first called.
+
+        Args:
+            params: A list of the parameters to be optimised. Note these will
+                be updated *in-place* to avoid reallocating arrays on each
+                update.
+        """
+        super(MomentumLearningRule, self).initialise(params)
+        self.moms = []
+        for param in self.params:
+            self.moms.append(np.zeros_like(param))
+
+    def reset(self):
+        """Resets any additional state variables to their intial values.
+
+        For this learning rule this corresponds to zeroing all the momenta.
+        """
+        for mom in zip(self.moms):
+            mom *= 0.
+
+    def update_params(self, grads_wrt_params):
+        """Applies a single update to all parameters.
+
+        All parameter updates are performed using in-place operations and so
+        nothing is returned.
+
+        Args:
+            grads_wrt_params: A list of gradients of the scalar loss function
+                with respect to each of the parameters passed to `initialise`
+                previously, with this list expected to be in the same order.
+        """
+        for param, mom, grad in zip(self.params, self.moms, grads_wrt_params):
+            mom *= self.mom_coeff
+            mom -= self.learning_rate * grad
+            param += mom
diff --git a/mlp/models.py b/mlp/models.py
new file mode 100644
index 0000000..86a0472
--- /dev/null
+++ b/mlp/models.py
@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""Model definitions.
+
+This module implements objects encapsulating learnable models of input-output
+relationships. The model objects implement methods for forward propagating
+the inputs through the transformation(s) defined by the model to produce
+outputs (and intermediate states) and for calculating gradients of scalar
+functions of the outputs with respect to the model parameters.
+"""
+
+from mlp.layers import LayerWithParameters
+
+
+class SingleLayerModel(object):
+    """A model consisting of a single transformation layer."""
+
+    def __init__(self, layer):
+        """Create a new single layer model instance.
+
+        Args:
+            layer: The layer object defining the model architecture.
+        """
+        self.layer = layer
+
+    @property
+    def params(self):
+        """A list of all of the parameters of the model."""
+        return self.layer.params
+
+    def fprop(self, inputs):
+        """Calculate the model outputs corresponding to a batch of inputs.
+
+        Args:
+            inputs: Batch of inputs to the model.
+
+        Returns:
+            List which is a concatenation of the model inputs and model
+            outputs, this being done for consistency of the interface with
+            multi-layer models for which `fprop` returns a list of
+            activations through all immediate layers of the model and including
+            the inputs and outputs.
+        """
+        activations = [inputs, self.layer.fprop(inputs)]
+        return activations
+
+    def grads_wrt_params(self, activations, grads_wrt_outputs):
+        """Calculates gradients with respect to the model parameters.
+
+        Args:
+            activations: List of all activations from forward pass through
+                model using `fprop`.
+            grads_wrt_outputs: Gradient with respect to the model outputs of
+               the scalar function parameter gradients are being calculated
+               for.
+
+        Returns:
+            List of gradients of the scalar function with respect to all model
+            parameters.
+        """
+        return self.layer.grads_wrt_params(activations[0], grads_wrt_outputs)
+
+    def params_cost(self):
+        """Calculates the parameter dependent cost term of the model."""
+        return self.layer.params_cost()
+
+    def __repr__(self):
+        return 'SingleLayerModel(' + str(layer) + ')'
diff --git a/mlp/optimisers.py b/mlp/optimisers.py
new file mode 100644
index 0000000..91d1f28
--- /dev/null
+++ b/mlp/optimisers.py
@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+"""Model optimisers.
+
+This module contains objects implementing (batched) stochastic gradient descent
+based optimisation of models.
+"""
+
+import time
+import logging
+from collections import OrderedDict
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+
+class Optimiser(object):
+    """Basic model optimiser."""
+
+    def __init__(self, model, error, learning_rule, train_dataset,
+                 valid_dataset=None, data_monitors=None):
+        """Create a new optimiser instance.
+
+        Args:
+            model: The model to optimise.
+            error: The scalar error function to minimise.
+            learning_rule: Gradient based learning rule to use to minimise
+                error.
+            train_dataset: Data provider for training set data batches.
+            valid_dataset: Data provider for validation set data batches.
+            data_monitors: Dictionary of functions evaluated on targets and
+                model outputs (averaged across both full training and
+                validation data sets) to monitor during training in addition
+                to the error. Keys should correspond to a string label for
+                the statistic being evaluated.
+        """
+        self.model = model
+        self.error = error
+        self.learning_rule = learning_rule
+        self.learning_rule.initialise(self.model.params)
+        self.train_dataset = train_dataset
+        self.valid_dataset = valid_dataset
+        self.data_monitors = OrderedDict([('error', error)])
+        if data_monitors is not None:
+            self.data_monitors.update(data_monitors)
+
+    def do_training_epoch(self):
+        """Do a single training epoch.
+
+        This iterates through all batches in training dataset, for each
+        calculating the gradient of the estimated error given the batch with
+        respect to all the model parameters and then updates the model
+        parameters according to the learning rule.
+        """
+        for inputs_batch, targets_batch in self.train_dataset:
+            activations = self.model.fprop(inputs_batch)
+            grads_wrt_outputs = self.error.grad(activations[-1], targets_batch)
+            grads_wrt_params = self.model.grads_wrt_params(
+                activations, grads_wrt_outputs)
+            self.learning_rule.update_params(grads_wrt_params)
+
+    def eval_monitors(self, dataset, label):
+        """Evaluates the monitors for the given dataset.
+
+        Args:
+            dataset: Dataset to perform evaluation with.
+            label: Tag to add to end of monitor keys to identify dataset.
+
+        Returns:
+            OrderedDict of monitor values evaluated on dataset.
+        """
+        data_mon_vals = OrderedDict([(key + label, 0.) for key
+                                     in self.data_monitors.keys()])
+        for inputs_batch, targets_batch in dataset:
+            activations = self.model.fprop(inputs_batch)
+            for key, data_monitor in self.data_monitors.items():
+                data_mon_vals[key + label] += data_monitor(
+                    activations[-1], targets_batch)
+        for key, data_monitor in self.data_monitors.items():
+            data_mon_vals[key + label] /= dataset.num_batches
+        return data_mon_vals
+
+    def get_epoch_stats(self):
+        """Computes training statistics for an epoch.
+
+        Returns:
+            An OrderedDict with keys corresponding to the statistic labels and
+            values corresponding to the value of the statistic.
+        """
+        epoch_stats = OrderedDict()
+        epoch_stats.update(self.eval_monitors(self.train_dataset, '(train)'))
+        if self.valid_dataset is not None:
+            epoch_stats.update(self.eval_monitors(
+                self.valid_dataset, '(valid)'))
+        return epoch_stats
+
+    def log_stats(self, epoch, epoch_time, stats):
+        """Outputs stats for a training epoch to a logger.
+
+        Args:
+            epoch (int): Epoch counter.
+            epoch_time: Time taken in seconds for the epoch to complete.
+            stats: Monitored stats for the epoch.
+        """
+        logger.info('Epoch {0}: {1:.1f}s to complete\n    {2}'.format(
+            epoch, epoch_time,
+            ', '.join(['{0}={1:.2e}'.format(k, v) for (k, v) in stats.items()])
+        ))
+
+    def train(self, num_epochs, stats_interval=5):
+        """Trains a model for a set number of epochs.
+
+        Args:
+            num_epochs: Number of epochs (complete passes through trainin
+                dataset) to train for.
+            stats_interval: Training statistics will be recorded and logged
+                every `stats_interval` epochs.
+
+        Returns:
+            Tuple with first value being an array of training run statistics
+            and the second being a dict mapping the labels for the statistics
+            recorded to their column index in the array.
+        """
+        run_stats = [list(self.get_epoch_stats().values())]
+        for epoch in range(1, num_epochs + 1):
+            start_time = time.process_time()
+            self.do_training_epoch()
+            epoch_time = time.process_time() - start_time
+            if epoch % stats_interval == 0:
+                stats = self.get_epoch_stats()
+                self.log_stats(epoch, epoch_time, stats)
+                run_stats.append(list(stats.values()))
+        return np.array(run_stats), {k: i for i, k in enumerate(stats.keys())}
+
diff --git a/notebooks/00_notebook.ipynb b/notebooks/00_notebook.ipynb
index 384dd8a..59fae18 100644
--- a/notebooks/00_notebook.ipynb
+++ b/notebooks/00_notebook.ipynb
@@ -239,4 +239,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
+}
\ No newline at end of file
diff --git a/notebooks/01_Introduction.ipynb b/notebooks/01_Introduction.ipynb
index f9ceab4..f3dc403 100644
--- a/notebooks/01_Introduction.ipynb
+++ b/notebooks/01_Introduction.ipynb
@@ -27,13 +27,48 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {
     "nbpresent": {
      "id": "978c1095-a9ce-4626-a113-e0be5fe51ecb"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAK4AAACuCAYAAACvDDbuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAFGUlEQVR4nO3dvUtjTRiG8cm6VSysBNsUFoqVBD+aiFiLlSiClQYEQdQ/wEbQ1g8ExRgrY6dgYWMhVmKnNhaSRtGInRYWNtl2YZ6BnD3Jmju5fuXDsDv7vhcDJxOPiXK5XHaAmF8/vQHgXxAuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJP3+6Q00m+/vb3N+fX3tzS4uLsy1+Xzem729vZlre3t7vdnx8bG5trOz05zXI05cSCJcSCJcSCJcSCJcSEqUy+XyT2+iUeVyOW+2u7trrr29vfVmof81iUQi1tqJiQlz7dHRkTmvR5y4kES4kES4kES4kMSVb0CUq9mlpSVz7d3dnTdLJpPm2kwm483W19fNtf39/d5sa2vLXGvtrVQqmWuVcOJCEuFCEuFCEuFCEuFCEle+AaGn9OXlZW8W+k9ofYl7Z2fHXNvX1xdhd76WlhZzbl35hj7ZKBaL3qy9vT3WvmqFExeSCBeSCBeSCBeSmurKN3SNOz8/780ODg7MtdbDzuTkpLl2f3/fm4UejCzPz8/m3LryjfKMnU6nzXlra2vFf8ZP48SFJMKFJMKFJMKFJMKFpKa68s1ms+b88PDQm42Ojpprp6amvNn4+HjFe/j6+jLnm5ub3mx7e9tc+/7+7s2i/JTvw8ODuZZ3hwE1RriQRLiQRLiQ1LAPZ4uLi94s9B3bjo4Ob/b6+lrx3xXlJ4KHh4fNtXFfq5RKpcy1hULBm8X97m894MSFJMKFJMKFJMKFJMKFpIb9Ivn9/b03s57GnXNuZmbGm52fn1f8d62srJhz62XNoT2E5pWutf69zkX74roSTlxIIlxIIlxIIlxIkn84C123fn5+erPQFera2lrFa6NczVpXyaHfuWsZGhoy53t7e96sUR/CQjhxIYlwIYlwIYlwIYlwIUn+i+QfHx/mvLu725uFnuijfFJgvaz55OTEXLuwsODNzs7OKt5DI/w0bq1w4kIS4UIS4UIS4UKS/JVvW1ubOX95eflvewg9IN7c3Hiz0EPfxsaGN+MhLIwTF5IIF5IIF5IIF5IIF5LkP1WoByMjI+bcegHz7OysuXZubq6qe2p0nLiQRLiQRLiQRLiQJP993FoJXeN2dXV5s9D3fMfGxrzZ6elpvI3BOceJC1GEC0mEC0mEC0mEC0lc+QZYL2V2zr7GDb2UeXV1tZpbwl84cSGJcCGJcCGJcCGJhzPn3OPjozeL8jt3rRctO+dcT09PvI0hiBMXkggXkggXkggXkggXkprqUwXrXV7OOTc9Pe3NQte4l5eX3iyTycTbGCLjxIUkwoUkwoUkwoWkpno4y+Vy5rxYLHqzVCplrk2n01XdE/4NJy4kES4kES4kES4kES4kNeynCtYnCPl83lxrXe8WCgVzbTKZjLcxVAUnLiQRLiQRLiQRLiTJv9j56enJnA8MDHizUqlkrr26uvJmfMe2vnHiQhLhQhLhQhLhQhLhQpL8lW/o1zpZL2DOZrPm2sHBwaruCbXHiQtJhAtJhAtJhAtJ8le+aE6cuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJD0B9JqFu5lRSB0AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Image target: [9]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Image target: [8]\n"
+     ]
+    }
+   ],
    "source": [
     "%matplotlib inline\n",
     "import numpy as np\n",
@@ -81,22 +116,96 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASIAAAEiCAYAAABdvt+2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADwVUlEQVR4nOx9d1RVx/f9fpXeO0gTRcACKJbYe4m99xI1xl5iNDGxJRo1UWKKmqix916IFbvYUGkqoIA06Z3X2z2/P8y7P4klwLuYT/Jlr/WWy8d9M/fOzD0zc+acvXlERKhFLWpRi38Q/H/6BmpRi1rUotYQ1aIWtfjHUWuIalGLWvzjqDVEtahFLf5x1BqiWtSiFv84ag1RLWpRi38ctYaoFrWoxT+OWkNUi1rU4h9HrSGqRS1q8Y+j1hDVohb/ARAR/s1JErWGqBa1+JeDYRhs3LgR33zzDcrKyv7p26kWag1RLWrxLwYRISIiAlu2bEFpaSl4PN4/fUvVgvCfvgFDodVqodVqwePxIBAIwOfzwefX2tf/dTAMA61WC4ZhwOPxIBKJavutGsjLy8O2bdvA5/PRt29fGBsb11hdGo0GACAUCjk3eP/qnlcoFNi7dy88PT3RoEEDrFmzBjExMSgrK4NOp/unb+9/FgzDQC6XQyqVQiqVQi6XQ6VSQavVvhc/g1qtRlxcHPr16wdTU1M0b94cqamp/2ofxz8BpVKJjRs34sSJE5gyZQpatWoFsVhcI3WpVCosWbIEn332GUpKSjgvn3NDpNPpoFQqoVQqa3RgExESEhKwYsUKFBQUICMjA0uXLkXbtm0xceJEPH78GFqtlrO6dDodVCoV5HI5JBIJSktLX/soFAqo1WpOn5lhGGg0GigUCigUCjAMY1B5RISsrCy0bNkSFhYWsLCwQEhICJYtW4aLFy8iLy8PSqXS4HreBqVSiUePHuHbb7/FrVu34Orqyt6T3hjW9CSib1OJRILy8nLWEP+boFarceLECezduxfDhw/HkCFDYGpqWmP1FRUVISsrCzk5OZDJZJyXz8nWjIjYlzQlJQWXL18GAAQHB6NZs2awtLSESCTidDknl8tx5coVpKamQigUwt7eHo6OjtBoNLh27Rrkcjl+++03uLu7V3vJr38uiUSC1NRU3Lp1C48fP0ZERASSkpJgYmICkUgEABAIBJg+fToaNWqEzp07QywWw9TUlP17ZaHT6aDRaNgtZ2FhIdLS0hAWFgY+n4+FCxfC2dm52m1JRJDL5QAAZ2dnMAyDjIwMrF27FmvXroWfnx/Gjx+Pfv36wdPTE8bGxpz1m0KhQHh4OBYtWoTMzExMnDgRH3/8MUpKSuDm5oYnT55AJpPBysoKDRo04Hyboe/PjIwMPH36FF999RWKi4vRpUsX9OnTB4MGDYJAIOC0zpoAEeH58+c4ePAgnJyc8Mknn8DOzq5G67SxsUHjxo1x7tw5SCQSEBGn77PBhkitViMnJwfHjx/Hnj17kJSUxA50IyMjdOvWDZMnT0aHDh1gYWHB2c0XFxfj5s2b4PP5aNasGZYsWYL27dtDrVZj48aN2Lx5M3bs2IEFCxbAzMysSmXrB2xxcTGOHj2Kw4cP48mTJxAKhXB0dIStrS3atWuHRo0awdHRkfV3aDQazJ49G8HBwXB2dsayZcvg5eX1t89MRFCr1VCr1UhJScHt27eRmJiIx48fg8fjITMzEwUFBSgrK8PIkSPh5ORU7Xbk8/nw9PTExo0bkZ+fj/LycsTFxSE2NhbZ2dnIzs7Gl19+iT179uDbb79F9+7dOTEISqUSV69exaJFi5CcnIyRI0diwYIFqFOnDlJTU/Hzzz9j9+7dKC0thaOjIzZv3sxZ3UQEjUaD4uJinD17Fps3b8bz589Zf+L+/fthamqKgQMHVqnMv0Lfh3owDMOuLGUyGRiGgVgshoODg0EGTyqVYu/evUhKSsLGjRsRFBRU4wbUxMQEQqEQIpEIRkZGnPuIDDJESqUSERERWLBgAeLj49mtkFgshpGRERQKBf744w/cu3cPy5Ytw7hx46psFN4ErVaLlJQUXLlyBc7OzpgzZw66d+8OofDl44wfPx6XLl3Chg0bMGjQIDRq1KhKqyKFQoGjR4/i7NmzOH/+PNzd3dGnTx80b94cXbt2haurK3g8HrsUzs7OxtGjR7Fnzx7Y2trC2NgYDRs2hLW19Ts7TG+AJBIJrl69itjYWDx48ABGRkYwNzeHhYUFSktLIZFIIJVKYWpqyomj0NjYGO3bt6/wnUwmw9OnT3H48GHs3bsX8fHxiIiIQKdOnQw2BvpxMnv2bBQXF6Nbt26YPn066tSpAwAICwvDmTNnUK9ePZiamuLhw4f4+OOPceLECbRq1apKfadSqVBaWgoTExNYWFhAo9GgoKAADx8+xN69e/H8+XO0a9cOI0eOhEqlQmJiIo4ePcqOnXdBq9WitLQUKpUKBQUFr/09ISEBkZGRICIIhUJ2G88wDC5duoTCwkL4+fnhjz/+qNQE9Sao1WpcvnwZx48fx6hRo9CsWbNK3TsXcHZ2hkqlglQq/d9ZEel0OiQmJmLKlClIT0+HWCyGp6cnfHx84O7uDnd3dzx//hz37t1DZmYmVqxYgS5dusDX19fgm2YYBsXFxVAqlWjSpAm8vb1Zf5R+m2Zvb4+SkhKEhoZi48aNMDc3r1TZWq0Wd+7cwZIlS2BkZIQ5c+bgww8/RGBgYIWZQL9qio6Oxueff47nz58jKCgI06dPR+fOnSs1a2i1WoSHh+Pu3bv4/fff4e/vj5UrV8Lf3x8CgQAKhQInTpzAypUrwTAMhg0bBldXV4Pb700wMTFBgwYN0Lt3b9y+fRtlZWWwtbU1+CRLrVbj9u3bmDp1KoqKijBmzBgsXLgQ7u7u7DUNGzbErFmz0KNHD1haWmLFihXYv38/fv/9dzRv3rxS96Dfcl66dAl79uxB27ZtMXz4cDx48ABHjx5FcnIymjZtivnz5yMwMBDGxsaIiorC5s2bYWRkhPnz579zVcEwDJKTk7F69Wrk5eXh0qVLEIlEFYy0ra0t3NzcIBQK4e3tDRsbG3ay6tChA86dO4enT5/i+PHjmDt3bpVXMfrxtmfPHjRt2hSjRo2CpaVllcqoLnQ6HXJzc2FtbQ1zc/P/nRWRVqvF7t27kZ6eDktLS/Tp0wdDhgxBUFAQrKysYGZmBolEgh07diA0NBRFRUXs8Z+hEIlECAgIgKenJ54/f47du3ejUaNGqFOnDmu1s7OzQUQICwvD+vXrq/RcBw8eRH5+Pnr27InJkydXeGn0KC0txcWLF7F+/XrY2Njgyy+/RN++feHq6lrpAUZESE5OhpmZGebNm4fGjRsjJCQERkZGAABzc3M4OTlBJBJBKBRiyJAhsLe353wQMAyDrKwsHDt2DIcOHUJCQgJ69uyJnj17GnQKwzAMMjMzsXr1auTn52PYsGHsduxVtG/fHh06dIBAIACPx8Py5cvx7NkzREREVNrxr9Pp8OTJE8yYMQN5eXkoLi7G48ePcenSJbRr1w7r1q1DcHAwazgkEgkOHz6MwsJCdOnS5W/9bkSEhw8f4sKFC7C0tMSAAQPg6OgIT09P9hp/f3/4+flBKBTC2dmZNUIqlQq7d+/G1atXwTAMmjdvXuU+JCJkZGTgyy+/hFqtxvr16+Ht7f3G6wBwPkYUCgXS0tJQp04dWFlZcVo2AICqCZlMRt7e3mRsbExDhw6ljIyMN1536tQp8vT0JJFIRMeOHSOlUlndKisgPT2dunXrRjwej/2YmpqSi4sLeXh4kImJCZmamtLQoUOpvLy80uVqtVq6d+8etWjRgiwsLGjs2LH04MEDKisrI4ZhiIiotLSUvv/+e/L19aXBgwdTbGwsaTQaTp7rr0hMTKR58+ZRs2bNaPz48ZSVlcXeh6FgGIakUilFR0fTzJkzyd7engIDA2nevHn04MEDg/tKJpPR0qVLycLCgtq0aUMPHz6s9L1PnDiR/Pz8SKVS/e21Wq2WEhMTac6cOWRubk4ASCwWU+PGjWnZsmX09OlTUqvVFX5z6tQp8vHxIXd3d7p06RJptdp31sEwDBUUFNCOHTvo3LlzlJWVRWVlZX97byqViiIjIykwMJCEQiENGDCAZDLZ3/7ur5BIJLR69Wry9fWlnTt3kkKhqFBHaWkpJScn08WLF+nevXuVareqICUlhUaMGEE///xzte7/71BtQySRSIjH45GFhQV9/vnnr3U0EZFGo6GdO3eSi4sLCQQCat++Pf3www9UVFRk0Muk0Wjoxo0b5OrqSmKxmExMTCoYJP2nY8eOFBsb+7eD7K9Qq9V0/fp16tSpE1lZWZGfnx99/fXXlJiYSFKplPbv30+NGzemqVOnUkpKSpXLrwokEgnt3LmT2rVrR2ZmZnTv3j3S6XQGl6vRaCg5OZlWrVpF7dq1Izs7Oxo+fDhdvXqVysrKDK6DYRhKS0ujRo0akZ+fHx08eLDCy/MuyOVyGjx4MPn6+v7tC6XVaunWrVvUv39/EggEZGZmRm3atKF58+bRmTNnqLy8/LWxVlJSQlOnTiUrKytauHBhpe+rqtDpdHT79m0aOnQomZubU6tWrSgyMrLK40Wr1VJkZCT5+PjQ1KlTqbS0lIhejo2oqCj69ddfacGCBdS7d28yNzenli1bVspIVgU3btygTp06VcpoVwfV3prxeDw4OzujsLAQN2/exLVr19CoUSMAL0/L1Go1oqKicPr0aZSVlbGh6Ldu3UKnTp1gZWVVLU8/EaGoqAhbtmyBRCLBsGHD4OnpiUuXLkEsFsPFxQWmpqbsMjg1NRV+fn5VqkskEuGDDz5AaGgoTp8+jfPnz+Pnn39GdHQ0goODcfPmTTRo0ABz586Fl5dXjUYE8/l8JCUl4eHDhxg+fDg8PDw4WXaXl5fj+++/x+7du6FWq+Hs7IzGjRujXr16MDExMfiZNBoNwsPDkZ2djb59+6J///6VdnrHxcUhJibmb2OZGIZBYmIiPv30U9y/fx8CgQAffPABvvvuO3h7e8PExOS1OtVqNY4ePYorV66gadOmmDhxYo0EAcpkMkRFReG7777DvXv30KZNG3z55ZcIDAys0lgkIpSWlmLTpk0wMTHByJEjYWlpCYVCgXPnziE0NBSPHz+GiYkJFAoF5HI58vPzOY0D02g0ePHiBXg8HszMzGomjaS6FkyhUNC0adOIz+eTWCymgIAAGj16NI0ePZpmzJhBH3/8Mfn4+JBIJCKhUEheXl5kYWFBfD6fNm3aVO1lv1qtpsuXL5OpqSm1atWKHj58SKWlpRQTE0OPHj2itLQ0ysnJoS1btpC3tzf5+/vTgwcPqmXFdTodlZeX04MHD+jLL78kT09PMjExIbFYTCtWrCCpVFqtZ3gXtFotyWQykkqlpFKpSKVS0ebNm8nV1ZVOnz79xpVndVBcXExTpkwhPp9PfD6frKysKCQkhCZMmEA///wzJSQkVHt5zzAM5eTkULt27cjExIRmzpxZ6d9mZ2fT6NGjycTEhDp37vzO51Wr1TRr1iwSCARkYmJCAwYMoPv3779ztX39+nVq0aIFWVlZ0a5duzhzFbwKmUxGe/fupZCQEDI2NqYhQ4bQgwcPqtWeKpWKjh07RtbW1jR58mSSSqWkVqvp2rVr1KpVKwoJCaHPP/+cjhw5QmvWrCFXV1fy9vamkpISTp9nxYoVNGTIEEpJSeGs3FdRbUOk1Wrpzp075OvrSyKRiB3QfD6fRCIRGRsbE5/PJ2traxo6dCidPn2aOnXqRHw+n1q1akUZGRnV2p4plUravXs38Xg8GjBgAGVlZb3xuvLychozZgyZmJjQkiVLDFp+63Q6KiwspC+++IJ9xtGjR3O2LdPpdCSRSCgnJ4fOnDlDX331FX3xxRcUGhpKv//+Ow0fPpzMzc1p5MiRFB8fT6WlpVRaWvrGbUdlodFoKC0tjTZv3kwzZ86k1q1bs31mY2ND3bp1o02bNlFJSUmV69BoNHTq1CkyMTEhV1dX2rt3b6V/GxYWRi4uLmRmZkY7d+58Z/sqlUry9/cnb29vWrVqFaWkpLxzS5mXl0fjx48nY2NjmjNnDuXn53Pmb9NDLpdTeHg4tW7dmoRCIbVv354iIiKqZYT0Br1z585Ut25dOn/+POl0OkpJSaHRo0fTiBEj6Pbt21RWVkYajYYyMjKoRYsWnBuitLQ0Gj16NH3//fc14h8iMmBrxufzERQUhAMHDuDSpUuIjY3FpUuX2L/b2dmhTZs26NKlC1q0aAFXV1fExcUhOjoasbGxOH36ND7++OMqL4u1Wi2SkpIAvFwyvu0kzsTEhD3aLCwsrOZTvgSfz4dQKATDMGwE9927d/Htt99i2bJlcHd3r/ZylWEY5OTkYNOmTcjIyEBUVBScnJzg7e2NU6dOgYhQUlIChUKBkydPIjc3F46Ojmwc09ChQ9G1a9cqx5IIhUJ4eHhg3LhxkMlkKCgoQGRkJNLS0nD58mXcvHkTjx8/xsOHD/HNN9/AxcWl0s9IREhPT4darYaVlRUCAwP/9jcajQZ3797Fb7/9BoVCgRkzZqB///7v3CIKhUJs3LgRpqamCAgIgIWFxTvLP3r0KC5evIiePXti1qxZsLOz43ybce/ePXz11Vd48uQJPvjgA6xcuRLNmjWrcoQ98HJspKWlISIiAo0bN4arqyvKyspw+vRplJaWYuHChQgODgYRISoqCgcPHsSLFy8wdepU9uSVC+hjh6ysrGosZskgH5GxsTGCgoLQoEEDyGSyCslwIpEIVlZWMDc3h1gsBo/HQ0hICKytrZGRkYFr167ho48+qrIh4vF4MDExAfDySPFNOUIajQaXL1/GtWvXoFKpOGk8hUKBwsJCtGvXDjNnzsTZs2exb98+mJubY8mSJbC3t69WuTweD7a2thg7diwePnwIGxsbDBw4EE5OTigvL4dOp8O9e/fw008/ITMzEzdv3sTQoUPh7e0NkUgEBweHar9M+j40NjaGra0tvLy8oNVqMWzYMHz77bdstPzUqVPh5ORULZ+eUCis1EuRkZGB77//HuHh4fj8888xa9YsWFlZvfPZBAIBG5j5rnvTarW4ffs2duzYgfLycowYMQJ16tTh1LenUChw4cIFLF++HI8ePcIHH3yA1atXo3nz5tX2QfF4PNjZ2cHHxwfPnj3DggUL4OTkhLi4OEgkEuzZswfnzp1Dbm4uHj58CKVSiUGDBmHy5MmcGSKZTIbz589DqVSicePGNRfBXSPrrLfgxo0b5OPjQ3w+n7p27VqtZZ5CoaBt27YRj8ejdu3a0ePHjyv8XaVS0YEDBygoKIhEIhHZ2tpSVFSUwVuouLg4atmyJW3YsIGUSiUlJCRQ7969yc7Ojh48eMDJKZNCoaDS0lJSKpWk0WhIq9WSRqOhK1eukJ+fH/F4PNq2bRvl5+dTeXk5lZeXc35Mq9VqKT4+nnr16kVCoZC8vb3p6dOnVXo+tVpNP/30E/H5fGrUqBE9e/bsrdcqFAraunUrtW/fnszMzGjkyJGUk5PD2ZZJq9XS7du3qVOnTmRsbEzz58/nfEsml8vp4MGD5OPjQwKBgFq3bk03b97kpG/kcjnt2LGD7O3tWX+sUCgkkUhEpqamZG5uTtbW1jRgwADav38/5ebmcnqqlZOTQxMmTKCRI0e+NUSHC/xjfES5ublsKH5VZnSRSISGDRvC1NQUaWlpiI+Ph7+/P7RaLdLT07FlyxYcOnQIubm5sLKywtGjR9GwYUODLblCoUBJSQns7e1hZGQEHx8fjB8/HgkJCTh06BB8fX3fuTX4O7y6OvkrgoKC0Lx5czx9+hSNGjWCnZ1djZzUFRUVYf/+/Th48CBiY2NRp04dbNmyBR4eHlWqj8fjoW7dujAyMkJ2djZOnTqFzz77rMI1CoUCsbGx2Lt3L06fPo3i4mJ8+umnmDhxokGrvL+ipKQEBw8exK1bt2BhYYG+ffvCxsaGs/IZhsHTp0+xevVq5ObmYtSoUfj8889Rv359Tk7jjI2NMWzYMDRo0AB79uyBWq3Gixcv8PDhQ/j7+6Nbt27o0KED/Pz8YGlpyXke2IsXL5CTk4PRo0fD0dGRs3JfQ42ZuDdAIpFQnz59SCAQkFgspqFDh1ZrdiotLaWFCxeSQCAgf39/mjhxIvXv35+8vLzIzMyMzMzMaNasWZSSksLZKdPdu3fJ19eXDh48yH6XmZlJffr0IS8vrxqdLdLS0qh///7E4/E4iyN6FQqFgmJiYmjmzJnk6OhIQqGQ3Nzc6Ny5c9Vy8jMMQ+Xl5bRw4UISiUTk6+tLM2bMoBUrVtCmTZtoxowZNHLkSPLz8yMzMzNq3bo1HTlyhJP4pVdRXFxMX331FVlYWJCzszOdPn2a0xWkTqejtLQ0GjlyJNWtW5fWrVtHOTk5NRJno9FoSCqVklQqpbKyMioqKqKysjKSy+Wk0Wg4d7rr6zxx4gT169ePoqKiaqQOPd6rIWIYhi5fvky+vr6sMerUqRPt3bu3SgNQo9HQnTt3yMvLq8JylcfjkY2NDe3cuZPKy8s5HdQJCQnUuXNnWrt2LftyPnr0iNq0aUP29vaUlpbGWV1/hVKppB9++IHs7e05MUQqlYoePXpEFy9epIiICBo2bBg5OzuTqakpG9h4584dg462dTodJSQksFtkExMTdhthampKxsbG1K5dO/rll18oOTmZlEol5wP90aNH1LJlS7K2tq6RiOCioiKaPHky1a1bl9auXVutE8b/VTAMQ4mJidS1a1caPHhwjR3b6/FeDRHRSyPyxRdfkL+/Pxtj5OPjU+VZRKVS0c2bN6lZs2bE4/HI2dmZpk6dSjExMTUyqLOzs2nChAnk7u5Oixcvpq1bt9KwYcPIxsaGxo0bR0VFRZzW9yrKy8vp448/Jj6fb7Ah0ul09OTJE/L29iZra2uysbEhY2Nj8vX1paVLl9KzZ89IoVBwMqtrNBpKSUmhLVu20Jw5c4jP55NAIKCQkBBasWIFPXv2jNRqNecrPKKXq7zNmzeTubk5tWjRgqKjozkdE3pD6+/vT0OGDKHs7Oz/jBEievl8Fy9eJLFYTN99912N9NGreO+GiOjlAC0tLaV9+/bRkiVLKDk5uVqdqNPpSKVSkVKpJJVKRRqNpsYaTKlU0r59+8jR0ZGMjY3JxMSERCIRubi4UHR0dI121PXr16lRo0ZkbGxMDx48MGjAMwxD+fn5NHr0aOLz+eTt7U0rVqyglJSUGlniMwzDOt2VSmWFvqqpF1en01FkZCR5e3uTu7s7HTt2jNNcQJVKRWfOnKEWLVpQjx496Pr16zWa5vNPQavVsgcnNQ0e0T9HFKwPQ+fxeP8K9QG1Wo2kpCR89913iI+PR9++fTF27Fh4eHjUKCdMbm4uNm3ahKCgIPTq1YsNX6guiAgMw7CZ2nw+/1/TB5UBEeHRo0cYPXo06tWrh3Xr1sHHx4eTshmGwbNnz9CmTRvY29tj06ZN6Ny583+m7f4p/KOG6N8IfXPRn8RQ72sAUg3RO/xXQa8IDnIdL7Ro0SKEh4fj8OHDVc5jrMWb8a+XE3rf0BuC920Qag1Q1VATk4RWq8X169cRHx+PK1euwMHBoVYCiSPUrohqUYta/OOoNee1qEUt/nHUbs1qwYL+1G97dZGsV9Ct3RrWoibxn18R6WV+anegf4/ExEQMHjwYtra2MDMzg7GxMbp164bnz59zxjf+vwCGYaBSqd6LGrBGo+FUdFM/WejHtVKp/E+M7/+0IdLpdPj999+xYsWKGlPy1Gq1rJ5VTaijMgwDtVpdQSJa/1GpVJwOQA8PD/z66684c+YMpk2bhuDgYERGRqJPnz7YvHkzq1f3b8eLFy/Qtm1bnD17tkYNrFwux6JFizBx4kQUFRVxUqZUKsWFCxcQGhqKOXPmwNfXF99++y1KSkpqXDJco9FALpfXjBIw14FJOp2OFAoFlZWVUUlJCSkUin8s4jQxMZGCgoKoW7dunIb3a7VaksvlVFRURKdPn6Z169bRunXr6NmzZySTydigPUOgb8fk5GRaunQpubm5EY/HIwDsZ+HChRVI/blGRkYG9e/fn4yNjUkoFNLWrVtrjBirJqFSqSpEi6enp1NISAitXLmyxviqiYgiIiIoICCARCIRhYeHc5L3+OzZM2rTpk2FcQCAxowZQxcvXiSJRFIj44FhGDpz5gz5+PjQgAEDKDs7m9PyOTVEOp2OcnJy6OuvvyZ3d3cSCoX0888/12hnvw0qlYoWLlxIfn5+FB0dbVDkK8MwpFarWQMbExNDs2bNYtVJ9GT95ubmNGfOHNq0aRPt2rWLiouLq11nQUEBbd68mVq1alWB/fKvn7Vr11ZrgOt0OtJqtX87aDMzM6lHjx5sOs6GDRv+VVHEGo2Gzp49SytXrqTc3Fwievkyt2jRgu7cuVNjz6LT6WjTpk3k7OxM3t7elJaWxomBkMvl9Pvvv5OdnR2rVmJnZ0cBAQE0ZswYOnDgABUVFXEe6V9WVkYzZsxgaYXj4+M5LZ8zZzXDMMjPz8ePP/6IAwcOwMvLC0KhEPHx8cjNzYWtrS2rAMul41O/RPxrPEdKSgquXbuGSZMmGRx0JpfLERMTg/v37+PWrVu4ceMGioqKKixPTUxMoFQqsWHDBpiYmEAsFuP58+dYunRplWJNdDodJBIJIiIisG3bNjx48ABisbgCoT3DMKyC6L59+zB69Oi/1eXSQ6PRQCaTobi4GOXl5XB1dYW1tfVbKSvq1KmDnj17IjIyEmVlZdi7dy8mTJjwVsVehUIBqVQKIyMjiMViKJVKCAQCiEQiaLVa1vnNMAzr29D7Oezs7KpMC/N3yMrKwt69eytoccXHx8PIyAhOTk41FgdUXFyMy5cvIz8/HzNnzoStrS0nz6Un0JdIJFi/fj1at26NHj16YMCAAcjNzcWwYcNw9+5drFq1itVV4wIpKSmIjo7mrLy/ghNDREQoLy/Hxo0bceLECcyaNQsDBgzAhg0bYGxsjGvXriE6OhqBgYEYOHDg30oxVxYMwyAvLw9arRZ16tRhy9RoNNiyZQtsbGwwZsyYarPV6V+SyMhIzJs3D3FxcQBesgEaGRnBxsYGjo6OEIvFaNGiBTIzM6HRaBAYGAhLS0tMnz69ykYoJycH33//PTZu3AjgpSJK586d8cEHH7DUt2VlZTh69Cji4+MRFxeH3bt3Y/78+e9MM9H30YMHD7B//37ExsYiNTUVvXv3xtSpU9G8efO30pkOGzYM27dvR1lZGZKTk5GUlITAwMDX+lAul2P//v3YuXMnAgMDERQUhJs3b8Le3h5+fn6sIrCjoyPKysrw9OlTqNVqREdHIykpCXv27MHAgQM5YxfUarV48OABcnJyMHz4cFhbWwMAnj9/DktLS1hYWNTIaaBOp8OlS5fw4MED2NjYwN/fn9MUIFNTU4wYMQJNmjRBo0aN4OjoiNzcXGzYsAGpqamsas6/CZy0jkqlwvHjxxEWFobPPvsMffv2xfnz55GYmIjly5dDLpfjxIkTOHToEPLz8zF9+nROBkFZWRnWr18PR0dHzJs3j131ZGRkIC4uDn379v1butF3QafT4dmzZ1i8eDHi4uJgamoKd3d3BAUFwd3dHcHBwax8saurK8rLy8EwDBwdHas80yqVSjx+/Bj79+/Hjh07wOPx4OHhgS5dumDKlCkICgpiDYVarYa9vT2WLFmC4uLiSpWv1Wrxxx9/4OOPP2Yd93w+HydPnoSTkxMaN278VkNkZWWFpk2bIikpCcXFxUhLS0OTJk0qtCv9yZu8bNkylJaWIjs7G+fOnavUvZWUlIBhGMTExKBPnz6cGCIiQlZWFv744w906NABnTp1Yst98OAB8vLyDK7jbcjJycGpU6eQlZWFcePGYciQIZWWUqosnJ2d4ezsDJlMhszMTMybNw/Hjh0D8HLi4FoiiWEY9pSxJsI5DDZEOp0OCQkJCA0NxdixYzFs2DDcv38f586dQ9++fREQEAATExN4enriyy+/xPfff4+AgAD06tWrWoTir9b75MkT3L59G59++inbMHqjKJfL0bt3b4NWQ/oTioSEBACAt7c3Jk2ahIEDB6JOnTqvbfeqO9iICHl5eRgyZAiKioqgUqng7++PBQsWoF+/fjA3N68wo4rFYvTq1QvHjx/HtWvXKl2PSqVijZCFhQVatWqFunXromfPnu9cxpuZmaFhw4YQiURQq9VvvY7P56N79+7w8vJCcHBwpe/r8OHDOHnyZKWvrwykUimOHDkCiUSCQYMGwdzcHMD/5zmvqS2ZUqnEoUOHcOHCBXh7e7P69Fy8uBKJ5LXtUWRkJC5fvow7d+4AAIYPHw5vb29On0+j0SA9PZ013s2bN2fbkysYbIhUKhVOnDgBa2trDBkyBHK5HGlpafjoo4/Qpk0blj61bt26aNmyJS5duoSffvoJLVq0gJOTU7U6iIhQXFyMM2fOoGHDhujYsSPb8MnJybh+/To+/PBDuLi4VLtD1Go1Lly4gFWrVqG8vBzAy63Hs2fPcPbsWTRo0ACenp6oU6eOwTO4XpkkMzMTPB4P/v7+WLx4Mfr27ftWA2Fvb8/64aoKY2NjfPjhh/jqq69gZ2cHU1NTgxM3eTwePvjgAwQGBsLU1LRK/ZqWlobz588bVP+rkEqlOHjwIM6ePYtJkybB19eXvZ/c3Fzk5+fD3d2dc8YEIkJ8fDxOnDgBmUyGTz/9FC1atOBkdaLT6RAZGYmuXbu+9Rp7e3t899138PT0NLi+VyGXyxEREYGMjAwYGRmhd+/esLW15bQOg3qCiCCRSHDnzh20bNkS7u7uUCqV6NOnDxwcHCoMbpVKhczMTCiVSly/fh1FRUWsLE5VoVAocOLECTx69Ahz5sxhjZ1SqURYWBgAYPTo0W91qFYGGo0GV65cYY0QAKSmpuK3335jpXy6du2KRYsWISgoyKDBJpPJsHv3bgAvY3kWLFjwTiNEREhMTERkZOQ7Vyh/hf5aCwsLdO7cGQEBAZVqf3ol4trW1haenp5v/J1eCbQqYBgGCoWCk+BCIkJZWRn279+PPXv2oH///q9t9bRaLXQ6HQICAgxakb+p7tzcXGzevBn37t1Dly5dMGDAAM4cxgqFAnfv3mX/7+npiYCAAPb/2dnZaNKkCXJzc+Hi4sLZ1oxhGKSnp+PRo0cAgM6dO6N9+/acb/0MMkQMwyAjIwPPnz/HZ599BiMjIxgZGVU4oQBedn5UVBSuX78OhUIBPp9fbYe1vmH27dvHOnF1Oh1UKhXu37+PsLAwBAYGwtzcnH15hEJhlesiorcGQRIRZDIZzp49C61Wix9++AE+Pj7VWn1pNBrcuXMH4eHhMDIyQpcuXdCvX793DuDs7Gzs2LEDKSkpMDExgaur698+n06nw5kzZwC8NBgikajSbZKamop79+5BrVYjICAA9evX58xHoCeDl8vlBp+YSaVShIaG4syZM+jXrx8mTZrEjkX96R0AVp+Oa3qQ48eP4+jRo7CwsMCoUaNQr149zihChEIhfH190aJFC7Rq1Qr9+vWDu7s7+/eSkhKYmpriyZMnEIlE7/T5VQVKpRKXL1/GgwcPAABdunRB/fr1OV9NGlSafgYUi8VvnQk1Gg2ioqLw/fffg2EYWFtbQyqVwtjYuFqDTiaT4bfffkNKSgqaN2+OzZs3o6SkBHK5HHfu3EFsbCw6duwIoVBo0MmBWCzGhAkT4OHh8drfpFIpHjx4gIcPH+Ls2bNwcXHBsmXLqrwVJCIUFRVhx44dyM/Ph4eHB3r27Pm3++89e/Zg//79kMvlaNy4cYWt6dug1Wpx5syZKrU5ESE5ORmrV6/GxYsXodVqMXLkSIOJ2f56X8XFxdBoNBUc8lWBXqRyw4YN2LBhA1xdXeHm5obU1FTcuXMHaWlpKCoqgkgkQlFREdLT09GoUSPOXia1Wo0HDx5gz549KCkpwcSJE9GlSxdOVw3Gxsbo1asX6tevDy8vL/YE8K9wcHDA0qVL4ejoiMWLFxvsJFcqlXj+/DnKy8tBRDA3N68Z/iVDA5FKSkqoX79+NGXKFFb+WR8AmJ+fT7t27aL27dtT48aN6eDBg9S1a1cyNjamwsLCKtel0+no0aNHZGtrS6amptSxY0caNmwYdevWjYKDg0koFNKoUaMoKirKYN5qhmFIpVKx+mGvfkpKSuj+/fs0ePBgEolEZGZmRitWrKDS0tIq1anVaikyMpJsbW3JxsaGFixY8E7ua61WS9HR0RQSEkICgYBsbW0rTYMqkUiIx+MRn88nJycn+v333995rwzDUEpKCo0dO5bMzc1ZqfCsrCxOI3clEgmNGjWKeDweRUZGVjnAUKvVUlxcHA0fPpyMjY2Jx+ORhYUFBQYGUkhICHl6epKJiQmJxWIyMTEhCwsLEgqFFBMTw1nQX0ZGBo0YMYLlX798+fI/FvRZWlpKwcHB5OvrSxKJxODyioqKaNasWcTn88nMzIz279/PuZYeEQcBjSYmJhgzZgwWLlwIqVSKVq1aoby8HFlZWcjPz0daWhoCAwMxYcIE+Pn5scGO1bWq+kRMS0tLDBgwAAEBAYiNjcWGDRsQFBSEWbNmsSc8hizzeTwexGLxW2e1oKAgfPfdd7C1tcXBgwfx22+/wcjICLNmzarSLKRQKFBWVobWrVtjwYIFsLGxeeN1Op0OUVFR+PbbbxEfHw8iwrx589CjR49Kz+z0J6tkeXk5IiIiMHToUDY26VXIZDI8efIEGzZswMmTJyGXy9GiRQv8+uuvnGqO6Z9Lq9XCyMioWltorVaL7du349ixYyAimJqagmEYJCQkwMjICPXq1UOvXr2g0+ng7OyMjIwMnD59mrP7l8lkOHnyJM6fPw93d3csWrQILVq0+MdYG8+ePYvs7OzXWBQMBY/HQ+PGjTmPidLD4BLFYjF69uyJkpISfPPNN7hw4QIAwNLSEm3btsU333yDkJAQ2Nra4saNG0hISMBHH31UrSUjn8+Hu7s7fvzxR3Y7KBQKERUVhZiYGEydOhUNGzbk3JH2JgiFQnh6eqJ+/foQiUTIzs6GXC6vdufb2trCwcHhrX9Xq9XYt28fwsPDYW5ujk8//RRjx46t9DZJKBRi8uTJ2L59O1QqFR49eoS0tDQ0aNAAYrEYcrkcEomE1Yg/ePAgnjx5AoVCgaVLl2LIkCE1Qov64sULZGVloX79+tXSohcIBBgxYgQaNmwIExMT1KtXDzweD4WFhXB1dYWNjQ0sLCxARBCLxdi7dy87Rg2FWq3G7du38eOPPwIAPv74YwwfPpyzo22lUon9+/djwIABlTqlKi0txaFDh1BYWMiZISorK0NmZiaAl8f27u7uNRL6YLAh4vF4MDc3x5gxY9C2bVsUFRVBLBbD3t4eNjY2MDc3h1gsBsMwOHnyJGQyGYYMGVLtI28jIyM4Ozuz/3/+/Dn27NkDd3d39OnTx6CTMuD/O+C3bduGL7744o3lqdVq5OTkICMjA3fv3oVEIgGAavu9gJeDTqFQvGZYtFotFAoFG2ujVCrx22+/oV+/fjAzM6v0oBAIBGjZsiV27NjBnrrNnz8fbdq0gaOjI548eYKYmBjodDrWp8Ln89GmTRuMGTPGoFXsuxAXF4e0tDTUrVsXYrG4yu0nFArRtGlTNtJb72PS6XRvXGFxFbWtPzRZu3YtcnNzMWbMGEycOJHT+BqVSoUvv/wSFy5cwFdffYUmTZq89dpLly5h48aN6NixIwIDA/Hzzz9zcg8vXrxgY5SaNm362kEUV+BkjaU/zvbz8wPDMODxeKwyhB7x8fG4d+8eunbtytnynmEYxMfHIyIiAnPnzkXjxo0Nttb68PwDBw6gW7dur61SSktLce7cOVy4cAF5eXkoLCyEVqsFALRu3bpay1YiQnR0NH788UfMmDGD3S4VFxfj2rVrOHnyJMLDw1FYWAgAaNy4MSwsLKr0rEKhEIMGDcK9e/ewfft2KBQKXLt2DQ8ePIBQKIRCoYBCoQDwMoRg9uzZGD9+PNzc3GBlZVVjW43MzEyUlpYaVIZIJHrNyV3TXNISiQQ//PADbt68CRcXF/To0eOdK9rqgP4MdD1x4gTS0tIwePBg9OvXD35+fpDJZEhMTEROTg7Onz+PkydPIjc3FzExMbh48SK6du3KSTS3Wq1mD5fs7e1rTK2G01L5fP4bBwAR4fbt28jKysIPP/xg8KpFj/z8fJw4cQIODg5o164dJ6c5Go0GGzZsQHp6OkaOHPnaANdoNJBIJJDJZGzSq6OjI7799lsEBQVV+4UtKirCxo0bIRQKMWnSJDx69AhbtmzBzZs3UVBQALVajZCQEEyYMAF169atsiHn8XiwtrbGsmXLAADbt28HwzAV4qSMjY3h6+uL5cuXo3PnzlVacVUXOp0ODMOgefPmnCZpvglarRaPHz+Gp6enQUmoCoUCv//+O/bu3QsTExOMHz8evXr14ryt9KvYe/fu4cGDB0hISMDGjRthY2MDlUrFbqXLy8uhVCoBAF27doWTkxO8vb05nTx69+6Nxo0bc1bea+Dc/f0GPHv2jHr27EnTpk2jkpISzsp9+vQptWrViqZMmcKZ0qpCoaAJEyaw1B5v+wiFQnJ3d6fAwEA6ffo0yeXyap0mSSQSWrFiBZmbm5NAICBra2vy8fEhZ2dnMjY2Zuk+WrZsSQ8fPjT4NFCn01FRURGtWrWK3Nzc2PL9/Pzohx9+oIyMDE54cyqLVatWkYmJCX333Xc1znWkUqlo4sSJ1LlzZ5YSpDooKyujUaNGkVgsphEjRnDOzaMHwzBUUlJC27Zte41/6K+fsWPH0pkzZ6p8cvsuSCQSWr16NYnFYurWrRslJiZyUu6bUOOc1TqdDqdOncK9e/cwYcIETmNQlEolGjRogClTprw1rqKqEIlE+PLLL9G8eXP8/vvvqFevHlq0aAGNRgORSAS5XI6GDRvCzMwMTZo0gY2NDUQiUbWXrGZmZpgzZw4YhsHXX3+N8vLyCqsUZ2dn9OnTBzNnzoSfn5/BQWp8Ph82Njb47LPPMHfu3Ap6aUKhsFonV4ZCv5V/HyAiuLm5GdSORkZGGDx4MIqLizFq1KgKPksuoV/Fjhs3DgMGDMCuXbuwZ88ejBgxAgCQnp4OoVAINzc3DB8+HG5ubpwmpJqZmSEwMBAikQhGRkY1exJYYybuT+Tk5NDw4cNpwIAB9OLFC07L1ul0NaKdrpdJVqlUpFarWcnkV//V6XSczTwMw5BUKqWzZ89Sz5492VWKubk5rVmzhiQSSY1rj/9T0K+I1q5d+17YH9VqNanVaoP7TqvVsmPjfUE/JjUazWufmmLpfPbsGXXr1o0mTJhQYys/ovewIiosLEROTg66du3Kucf9bT4pQ6En73pfsSD6CPUePXqge/fuFY5da+oZ/6+Cq/yy9zk+/sk669Wrx9K51OQ4rHFD1LBhQ1y9evU/pa1eU/i/anBqx8X/LvSTck2jxkf+m47ya1GLvyIyMpINH6jF/z3USk7Xoha1+Mfxf3MvUIta1OJ/CrWGqBa1qMU/jhp3Vtfi3wuNRsPmbNVUaP9/AXpieSKCQCCo9YlWA7UrokqCiKDVaqFUKiGTyVjZZ4VCUeNSv/8ENBoNVqxYAUdHR+zatctgyW56KebJtqOeyF+hUNSMhPF7AP3J4vn48WN8+umnmDRpEo4ePYrU1FTIZLL/3JioSfynpzkigkajYQe5XuivKr/X69qXlZUhKioKBw4cwMmTJ1nd+VatWmHOnDl/S+9aHehFCPWzLf3JHS0QCGBsbFyjqxStVstyXFd3dtffr1qtZg2ORqNBbGws7t+/DwAIDw+Hr68vFi9eDB8fH06eSV+vVqtlRRz1MThisZizMAm9jtuRI0dgYWGBa9eu4dChQzAzM8PMmTMxZcoU2Nvbw8jI6F8XmsEwDNRqNTv+9NDTQb/6PEqlkm3j6lLw1NipmVqthlarBcMw7EetVoPH48HGxua9LPXz8vJw5coVZGZmws7ODo0aNULz5s0rNSh0Oh2bVLtjxw4kJydDLpezmfavQiwWIzo6Gg0aNOBkSa7VaiGXy/HixQucO3cO6enpkMvl0Ol0uHv3Lho0aIAZM2agffv2nNFavAqGYRAdHY3FixcjMjISGzZswODBg6s0yOhPYYWYmBgcOnQIly5dQlJS0luvb968Ofbu3Vtt7m99nWq1GiUlJXj27BkuXryIS5cuIS8vD02aNEGLFi0wZsyYN0pBVRUajQa3b99G//790atXLyxbtgyxsbE4fvw4ZDIZZDIZysrK8MEHH2D27NmcGVng5djU6XTg8/lgGIZdqesnDjMzM4MSlnU6HV68eIFdu3YhLCwMDx8+ZP82b948zJgxg1VBUSgU2LBhA1JSUtC1a1cMHDiwes9ZE+HaCoWCLl68SF988QVNmzaNhg4dSp06dSILCwtycXGhnJycmqi2ArRaLc2YMYPs7e1JIBDQ3Llz6caNG5VKlWAYhrKzs6ljx45s4qlQKCQzMzOyt7cnX19fcnd3J7FYzKZjPH782OAwe4ZhSCaTUUREBA0fPpw8PDyoWbNmNG/ePDp58iRdv36ddu7cSR999BE5OjpSbGxsjaR+lJeX08qVK8nR0ZF69OhB0dHRlaKjfRUqlYo2b97M0tOampqSk5MT+fn5Uf369cnOzo5EIhGbRGxsbExhYWHVpiHVp8kcPXqUGjduTDY2NuTl5UU9evSg8ePHU48ePcje3p5Gjx5NeXl51arj1brS0tIoJCSE7O3tKTQ0lE0UVigUJJPJKD09nb766itq0aIF9erVi2JjY6vUhnq6ZZVKRTKZjCQSCZWUlFB+fj5FR0fT4cOH6dq1a3T06FH68ssvqVGjRiQQCIjH49G4ceOoqKioWuNRp9NRTk4OTZw4kR33xsbGZGxszPZXSEgIPX78mDIyMmjVqlVkY2PDJk6Xl5dXuU6iGkjx0KsZLFiwADk5OfD29oaTkxMyMzOhUCgQHBxcYwyKOp0OCoUCpaWlePHiBaRSKby8vCCVSrFjxw64urrigw8++NuZQq/wGhcXB41GA2NjY3h6eqJr166sksLNmzcRGhrKqWKoXC7Hzp07sX79etjZ2WH27NkYPHgwXF1d2TZr3749Bg0ahCdPnmD79u1Ys2YN5yqiBQUFuH79OgoLC1FYWAg7O7sqryD0ckw8Hg916tRB//79ERISguDgYMjlcuzduxdHjhxBWVkZtFotRCJRlfXQ/lpfREQEVqxYAYFAgClTpuDDDz+Ev78/rK2toVKpEBoait9++w3Z2dkGcWLpdeji4+MxZswYjB8/nt3y6/vCw8MDy5cvxyeffIIlS5bgs88+w6ZNm1C3bt2/HX/0p7jnrVu3oFKpkJiYiKKiImRmZkIikeDx48csHaz+GczNzWFqagqFQoF9+/Zh7ty5VeaR0te7d+9enD59GkZGRggMDISfnx+EQiHKysoQERHB0gjHxMQgKiqK3SUYQgzIqSHS640tXLgQBQUFCAwMxMqVK9GkSROEhoZi+/btmD9/PmcsdvSnD0gmk6GkpAQvXrzA9evXce3aNURGRkIqlcLKyorlZ6msQ1QgEKBBgwYYPXo0kpKS0KBBA3Tu3Bndu3eHQCDAixcvkJ2dXcGHYuiWTKPR4N69e/juu+/QsWNHfPrpp29VmtDXVVxczLlDVG8kHjx4ADMzM7Rp06Za/FEMw0Amk8HGxgazZ8/G9OnTWeYFqVQKd3d3WFlZoWvXrlCpVLh06RL27t2LkJCQauWDaTQaXLhwATk5Ofjkk08wfPhwWFhYQKfTQSKRQKlUwsXFBWZmZggLC4Ozs/Nr2nuVhVKpxLFjx+Dv74958+bBzs7ujdcJhUK4u7vjq6++wrBhw7B+/XqsWbOG1eF7G+hPuew+ffqw/wcq+uosLS3h4OCAOnXqwNbWFn5+fsjIyEBYWFgF9oaqgIiQlpaGzz//HEKhEG3btsWqVavQpEkT8Pl8SKVSLF++HDt27MCWLVsqPGdwcDC++uqrarNrcGaIlEolzp07hwULFiA/Px9t27bFt99+y1JoFBcXw93dHSEhIZysiJRKJdLS0vD48WPcunULt2/fRnx8PORyOezt7dGkSRPY29sjJCQEfn5+aNq0aaWleHk8HhwdHbFy5UoUFxfDxcUFRkZGkEgkiIiIwNatW3H69GlWg75Vq1YGJfTSn7JCa9asQXBwMFasWPFWtU6lUonIyEiUlJSgf//+nPraGIbB3bt3ceLECUilUrRo0QJz5sypsgYdEaG8vBxxcXGwsrJCmzZtKviy9Gq2n3/+OXr27AmdToeJEyfi/v371T6dEwgECAoKwqFDh7B9+3acO3cONjY2sLe3h729PXJzc3H79m3k5eVh2bJlcHJywrhx46psiBiGQWpqKg4cOIDu3bujbt26f/sbHx8fdOrUCdu3b8eQIUPQvn37KtXL4/FgaWmJoKAgeHh4wMjICHXr1kWzZs1Qr1492NrawtjYGFeuXMHNmzerbYhehYWFBT788EOEhIRAIBBAp9OhtLQUZWVlFQ5/vLy80K5dO8yePRv+/v7V9r1xNoqLi4vxyy+/QKfT4aOPPsLHH3+M4OBgCIVC3L17FzExMfjss884karVzxhz587FrVu3KpDWm5qa4qOPPsKIESPg4OAABweHahk+Pp8PS0tLWFhYQKlUIjExEUeOHMHWrVuRlZXFXqeX2tafMlXHeUxEKCwsRFRUFObNm1dBOO9V6Mna58+fj9atW6Nbt26cZZMzDIOSkhKcPHkSiYmJMDU1RZs2baotRMjj8WBkZITMzExs2rQJvr6+bN8bGRmha9euEAqF4PP5eP78OeRyuUH3b2RkhAEDBrBc0nK5HPn5+VCpVCgsLISTkxPGjx+P48eP4+nTpzA3N6/WKlar1eL+/fvg8Xho0qRJpV48Pp+PKVOm4OHDh/j999/RrFmzN6qn6MHj8WBnZ4cvv/yS/b+TkxM6d+6MOnXqQCQSQSAQVJiElEolYmNjIZFI4OrqWm0BUz2EQiEsLCxYI5Samopvv/0Wx44dg1KphK2tLTp37ozRo0ejXbt2sLGxMWxXUC3P0htQWlpK69evp02bNlVgS1QqlfTZZ59RUFAQpaSkcFKXVCql9evXs3pbfD6fdXqamZnRDz/8QFKp1OB6tFotvXjxgnbs2EHt27cngUDA1qf/CIVC6tWrF02YMIGOHDlCMpmsyk5CnU5HcXFxZGVlRcuXL38rx010dDR17tyZunbtSklJSZw6qouLi+nnn38mHx8fEggEFBwcTPfv36+yk1oPpVJJ69atIx6PR87OzrR27VrKz88npVJJWq2WZDIZpaSk0MmTJ2nAgAFkampKHh4elJCQwMlzqdVqKioqopycHMrJySGJRELPnj2jrl27komJCUVHR1erHoVCQV9//TX5+vpSTExMpX/HMAytWLGCnJ2dKTIyktO+0+l09PjxY2rZsiXx+XyaOnVqtca/Tqej2NhY4vP5ZGVlRR999BHdvXuX7ty5Qx999BGZmZkRj8cjFxcX+uabbyg5Obna4+Ov4MwQ6XQ6ksvlJJfLK3x/7949atasGa1evZoT46DRaOju3btUv379CgbB09OTGjduTBYWFuTv70/R0dEGkVZptVpKSUmhyZMnV6BUfdfH29ubdu7cWWWCL4ZhKCsri/r160ctW7akgwcP0t27d+nJkyeUn59PKpWK5HI5zZs3j9q0aUOXL1/mVOROq9XS+fPnycvLi3g8Hjk5OdGmTZsM6i+dTkdJSUnUp08fEgqF5OrqSlOmTKHQ0FA6evQorV27lgYNGkROTk7E5/MJABkbG9PixYtfG0NcQG9ArKysaOzYsdUS+CR6OQkOGDCAgoKCKDMzs0q/vXbtGtnZ2dGJEyc4JVRLSkqi2bNnk52dHdna2lJ4eHi16H5fNUQCgYDMzMyocePG1LJlS3bS79atG+3YsYNKSko4JWPjbGvG5/Nfc1QplUqEhYUhJSUFbdu25YQmlmEY5ObmIisrCyEhIejYsSOCg4Ph5uYGnU6HVatW4erVq3jw4IFBOlw6nQ5xcXHYtWsXG9AlFAphY2OD5s2bIyAggD0hyczMRFhYGNLT07F8+XL4+fmxe+vKgMfjwcHBAV9++SWWLVuG1atXw9jYGGZmZvD09ERwcDAsLS2RkJCAyZMno3Xr1pydPOp0Ojx//hy7du1Ceno6AKBNmzYGSzPpNejWrl0Lf39/7Nu3D1u3boWJiQlsbGwglUpRVlYGCwsL+Pr6IisrCxKJBBcvXsTcuXMNOoH5K4gISUlJuHr1KqysrDB9+vRq+/R4PB4sLCwgl8tRWFiIOnXqVPq37u7uEIvFkMlk1ar7TVAoFDhw4AD27NmDsrIydOjQodpy2voTzpUrV+Lq1au4f/8+njx5UuGarl27YsiQITAzM+M0jaVGowojIyNx6NAhDBkyBA0aNOAkulQoFKJVq1bYvXs3GjRoAHd3d1haWoLH46GoqAiOjo6sjhoZeKLE5/PZI9CAgAB06tQJ/v7+aNq0Kezs7NjnkclkePHiBa5cuYKMjAxs2rQJW7ZsqZIRFIlECAoKwi+//ILs7GykpqaivLwc0dHR+PXXX6FUKjF48GD07t2b0yBGqVSKo0eP4vLly+DxeHBzc0OPHj048eUZGRnB19cXn376KYyNjbFlyxbk5+ez/iBvb29MmjQJXbt2RXh4ODZs2IBnz55hx44dmD59OmeR6mVlZdi3bx8ePXqEL7/8Eo0bN2ZfVH3kfWU11QQCAQIDA3Hu3DncunWLPVGqDOzs7ODk5MTq4HGBZ8+e4cqVK5BIJBAKhRg8eDCsrKyqZST0wcZz5szBhx9+iE2bNmHr1q0VrsnLy4NareZMiUePGjNExcXFOHz4MLKzszFw4EBOBjbw0jg4ODigX79+rxG9l5aWori4GHw+Hy4uLgZFzwqFQrRr1w4XL14EEaG0tBSXL1+GVquFu7t7BSexubk5K09DRIiLi6uWETQyMkL9+vXh4+ODVq1agWEYlJWVYdeuXfjpp5/g5eVVbSfrm6BWq5GYmIgbN26gtLQUzs7O+Oijj9C7d2/ORA70/TV48GBcuHAB+fn5sLOzw4QJEzBy5EjUq1cPFhYW8PPzQ0FBAbZv347Q0FAMHz4cJiYmnIRF6FMvvLy88OGHH7IGjohw584d+Pj4wMXFpVJ18Xg8uLi4oKysDJGRkZgyZUqlDVF6ejpkMhmCg4M56cPnz5/jxx9/xMOHD8EwDD799FMMGzbMoIlKr1Ho5OTErtz0Rlur1eLYsWMwMzPDp59+yplgBYCaiazWaDR0+PBhcnR0pNGjRxtEmq+PNv47uSCZTEahoaHk6OhI1tbWdPPmTc4caTqdjm7dukVOTk7Ur18/evbsWYX7u3jxYgWf1YYNGziV5ImOjqbWrVvT8OHDOYtKV6lUFB0dTR999BFZW1uTQCCgAQMGUGxsLOdyQnK5nLZs2ULW1tbk5uZG33zzDWVnZ7/msN2wYQPZ2dkRj8ejpKQkg30QGo2GIiIiqHXr1mRhYUG//vprBf9TSUkJ9erVix4/flxp57FOp6OUlBRyc3Oj1q1bU0ZGRqV+V15eThMnTiR/f38qKyur1vO8ivz8fPrss8/IwsKC+Hw+tWnThp4+fcqJE5xhGHr27BmFhISQi4sLffbZZ7Rq1Sry9/cnHo9Hnp6elJSUZHA9r6JGMvFevHiB/fv3w9raGpMmTYKTk1O1y9JqtVi+fDm+/fbbd1KJ5ubm4ubNmygsLISvry9cXV055dqVyWQoKCioQGav0+lw5coVLFmyBGlpaey1/v7+nCY5ajQaaLVa9ribC6hUKpw5cwbHjx9HeXk52rdvj4ULF6JBgwac5wFqtVqkp6ejrKwMTZo0wdChQ+Hk5PTas3BNn1FYWIjdu3cjNjYWkyZNwuDBgytEoSclJSEuLq5CUuffgc/nw9nZGR9//DESEhJY1dx3gWEYrF+/HuHh4RUCOw3B/fv3sXPnTsjlclhaWmLu3Lnw9PTkZHyo1WpERUUhMTERnTp1wty5czFt2jT06NEDAoEAUqn0jTmXhoDzrZlWq8WDBw9w+/ZtLF68uNoyzHowDIMjR46gqKgICQkJGDhwIJo0aVIh1iYlJQUbN25EeHg4HB0dsXjxYri5uXG6hcnIyEC9evUwYcIEuLu7QyKRIDw8HKGhoYiKioJOp4O9vT0GDRpUJb9BZZCbm4v8/Hx069aNk3QOfSrJtm3bIJFI4Ofnh7lz5yI4OLhGkmgBVIjzelNCJsMwkEgk0Ol0MDMzMzg+SqlUIjw8HEeOHEHLli3x0Ucfwc7OrsKY2LVrF4qKiqpctpGREXr16oXQ0FDs3r0b9vb2GDFixGsR1mq1Go8fP8Yff/yB7du3Y+XKlRg0aJDBhr6srAxXr15FcXExLC0t8fnnn6Nbt26c9Z1EIkFYWBhr5KysrJCfn4/U1FQwDAM7OzvO07Q4N0RPnz7F0qVLMXz4cIwfP97gxhEIBPj222+xZ88e3L9/H/fv34eRkVGFF1KfX9auXTssWbIEzZo14/SFKi8vZ6Wft27digsXLiA7OxtRUVHIzc2FTqeDra0tRo8ejUWLFhkkZ/y2+hUKRaUdqu+CVqtlc4UyMjLg5uaGCRMmoG3btpznrL0JRUVFKCgogIuLC/tCFhQUYO/evdi8eTPKy8vRp0+f14xGVZGVlYU9e/bA2NgYkydPfuMqNT8/H1ZWVlUOxhMIBGjUqBHWrFmDzz//HEuXLsWpU6fQp08fDBw4EDweDxcvXsSVK1dw584dlJaWYsOGDejfv7/Bfi+pVIrdu3dj7969MDU1xfz58zF16tR3BkhWFVqtFmVlZez/09PTsXXrVly+fBkAMHLkSDg4OHBWHwBufURZWVk0bNgw6t+/P6WkpHAWZ6BWq0kmk1FhYSGdOHGCpk2bRv369SMPDw+ys7Ojbt260c8//0w5OTmc+YVehUwmo59++okEAgGJxWIyMTEhkUjE+oS8vLzo1KlTJJFIOBe6UyqVtGLFCnJ1daW7d+8a7ANQKpW0bds2EgqFZGpqSlOmTKH8/PwaFXDU+2q8vLxILBaTv78/DRs2jDZs2EBr1qyhkJAQ1tehj4MxpB/Ly8vpm2++YZ/vbfLSo0ePpm3btpFSqaxyHfps/zNnzlC/fv3I0dGRLCwsyNXVlVxdXcnHx4fatWtHM2bMoOjoaFIoFNV+Hj3Ky8spNDSU3NzciMfj0dixYykjI4PzMZeTk0N9+vQhPp9P7u7u1KxZM7Z/uH639eDMEMlkMvrll1/I2tqavvvuuxoZ2AzDkEajIaVSSXK5nEpLS6mkpIRkMhkn6p1vg1arpfDw8Apa9EKhkGxsbGjkyJGUkpJSIwZQq9XS1atXqXHjxqzBMBRKpZLOnj1LLVu2pMGDB1NZWVmNtdurKCsro+XLl7O0IHpaFVNTUzYy3srKik6dOmXQS6tUKunYsWNka2tLISEhdOfOnbc+3/Lly6mkpKTadenHo1QqpeTkZNq2bRu1bt2aWrRoQdeuXSOJREJKpZKTd0GlUtH58+fJw8ODBAIBeXh40K5duzgxcH9FSUkJzZw5kw1sfDWjYPny5dWm+ngXODNET58+JbFYTOPGjeMkgvp/DRKJhPbv30/BwcFsJHdERESNGsD09HQaNWoU2dvb08GDB6s1c78Jr8ppvy8wDEMKhYJu3LhBHTt2ZFNyeDweNWvWjG7fvk1JSUkGv1iFhYU0YcIEsrCwoBUrVryzvKtXr3L2Ir8qU65SqTifiEtKSmjOnDmsYVi9enWNyV1rNBq6fv06OTs7V8gcmDFjBuXl5dXIeOfEEEmlUlq2bBm1a9eOkpOTuSjyfxI6nY60Wm2N640TvZzZ169fTxYWFrR161bOjNA/Df0L+6puu1arJYZhOGnPoqIimjx5MnXq1ImePHnyzmtjYmL+Ne2qUqno8OHDJBAIKCgoiG7dulWj9UmlUlq3bh1rhCZNmkQ5OTk1NuY5oYrVBy1OmzYNEyZM4MBzVQvg/xPO18p1Vw2VbTf9Nf8GqNVqhIWF4eeff8aPP/5YITq8pqBvR4Abzq13gTPO6n9Tp9aiFv9W/Fffs1rJ6VrUohb/OP5dGie1qEUt/pP4T+ua1eJ/B/Sn1hi9ooZai38fiIiVB+Pz+ZylUb230UCviBXW7gb/7+HFixcYMWIEGjVqhJ07d6K4uPi9KOS+KlJZi+pDP5E8ffoUy5Ytg6enJ3755Ze/zbOrLN6bjyg3NxcTJ06Eqakpfv/9d24pBN4D9JzUDMNUOEHQJ8FylZCqn3F4PN4b1TT/jaqharUap0+fxvDhw9l2a9KkCRYsWIAOHTrA3t6+xiSmMjMzsXHjRrRp0wY9evSosXr+Cv2Lq9VqWSOoV5vlgmec/pTu1htz/erkr9Q4XKG0tBR37tzB999/j5s3b4KI8OGHH2L37t2wsbExuPz3NqITExORkpLyr1wNabVa3Lx5E76+vrCwsICLiwsCAgLQqFEjzJ49G2vWrEFMTAybtGkIFAoFoqKikJqayn6n0+mwaNEiDB48GLm5uYY+zlvBMAwUCgXKy8tZw8cFxGIxq3ahN9xxcXEYM2YMevTogTt37lRbvaMyyMzMRFRUFCv/VJNgGAZKpRL5+fkIDw/HlClT4ObmhhYtWmDp0qW4deuWwZnrehXigwcPYuDAgfD398esWbNw4MAB5OXlvVWRuDogIigUChw9ehQfffQRbty4AQsLC9SrVw9r1641SL3mrxXVODQaDc2ZM4dEIhENGzbMoLD69w2GYSgnJ4cmT55MAoGAbGxsyMPDgzw8PMjW1pbs7e3JwsKCxGIxDR8+nO7evUtSqbTagV/JycnUp08f2rdvH/tdQUEBjRo1ijp16lSB/4arqG6dTkcKhYJSU1Np+vTp5OLiQlu3buWUOzohIYGCg4OpZ8+e1L9/f/Ly8mJTZho3bky3b9+ukUjvjIwMtu2ePn3Kefl66CPHk5KSaPHixVS/fn1ydHQkX19fsrKyotDQUIqNjTU4pYZhGEpJSaFx48ax+V8ikYiMjY1JLBZTcHAwTZo0ia5fv85J1LhUKqWtW7eSm5sbCYVCcnJyou+++47zNI8ad1YTEfLy8pCSkgKtVosGDRpUeWlKf87MDMNArVZDo9Gw3yuVSiiVSgAvZ1tra2uDdL//CoZhWN4Ze3t7TJw4Eb179wbwkhPGxMQEWVlZSE1NxdOnT9GlSxesXLkS06dPr9Y2QCaT4dmzZxW+0y/vu3XrVmEZXFBQACcnJ4MdhuXl5Th8+DB27NiBmJgYqFQqaDQaqFQqEBGEQiFEIpFBS/769evj1q1bbL/ExcVh/fr1uHDhAp48eYJVq1bhl19+gYeHR41sPR88eICcnBzUr1+f862LnsLk8OHD+OWXXyCTydCmTRu0bdsWXbp0wRdffIE2bdogICDA4CBEhUKB+Ph4pKSksAKWgYGBcHNzQ0lJCSwsLHDu3DmcPHkShw4dQseOHas9PlQqFeLj4xEWFob8/HzUrVsXM2fOxPjx4/9WJLKqqHFDpFarsXnzZly5cgUA0KtXr0rTTRARJBIJysrKoFAoUFhYiIcPH7IvqlwuR3R0NOLi4sAwDEQiEebOnYv58+dXW4/rXWjSpAnGjx8PPz8/AEDbtm0r/D09PR2fffYZzpw5g8mTJ1fZENGf+356y5ZILpdXUKt1dHQ06Bn1KqhhYWFYs2YN0tPTIRAI4OTkhPv376OsrAwikQj+/v5o3769QYTpAoGgAiFY8+bNsWnTJixZsgTbt2/H2bNn4ePjgxUrVnA6yMViMUxMTCCRSFjKFq4jklUqFfbs2YNVq1ahZ8+emDRpEoKDg2FiYoL4+HgUFhYaPDlqtVqUlJQgJiYGP/30E+7cuQM3NzdMmTIFEydOZLmwzczMMGfOHOzatQu//fYbWrRoUa321Gg0SExMxLp163DmzBn4+vpi5syZGD16NKeUI3rUuCEqKSnBs2fPoFAoYG5uXiWeIIZhsHv3bhw+fBhZWVnIy8uDpaUlXF1dYWNjAyMjIzRq1AgNGjRAfn4+UlJS8Ouvv8LFxQWTJ0/mTNpaD2Nj43eu5jw9PbFw4UIkJSVVWzY5MzMTACp174YSzuXl5WHjxo3YtWsXcnJyIBAI4OfnhwkTJiAnJwebNm1CdnY2XF1dsXTpUnTq1AlOTk6cKThYWlpizJgxiIqKQmRkJDZs2IA5c+ZwysttY2MDb29vAMDjx4/Rq1cvzl+ksrIyJCYmonfv3liyZAnc3d3B4/FQVlaGTZs2wdPTE3Xq1Km2IdIzXC5duhQnT54EAPj6+mLWrFkYP348S2SvPwAaNmwYrl27hvDwcERGRqJTp05VqpthGGRkZGDVqlU4evQovLy8sHLlSvTp06fGnP01aogUCgWOHz+OGzduAAB69uwJZ2fnKjWKVCpFZmYm3NzcMHjwYAQEBKBJkyaws7ODSCSCmZkZdDodysvLcfr0aYSGhmLXrl3o2LEjGjduzCldbEJCAlJTU+Hj4/PWa5o3b47mzZtXq3y9nLSXlxf8/f2re5t/C5VKhYyMDBw/fhw//fQTVCoVnJyc0Lp1awwZMgS9e/fGs2fPcPnyZWRlZSErKwuzZ89G06ZNsWLFCnTo0IETQ8Hn8xEUFIROnTrhyZMnkEqlePbsGatmygUEAgGMjIxYw8A1xSkAVt5q/vz58PDwAPByi71v3z7cuHEDixYtqjbpnEajwZMnT7Bp0yYcPHgQfD4fLVq0wIIFC9C5c+c3qmm0b98ebdu2xd69exEaGor27dtX+p0jIpSUlGDHjh0IDw+Hk5MT5syZU+MnjjVqiJKTk3Ho0CHk5uaibt26mDRpEuzt7Ss9iPl8PsaPHw9/f394eHjAz8/vrXy/tra2GDJkCCIiInDs2DEkJycjICCAU0NUVFSE2NhYtGjRAmKxmJX+5QoymQzR0dHw8/NjB/Sr4OLoXqvVIj4+Hl9//TUePXoEhUKBevXq4ZNPPsHAgQPh5uYGsVgMHx8f9O/fH2VlZXjx4gVUKhXu3LmDq1evIigoiJMjW/0zeXl5wdTUFFKpFFFRUejQoQNnhkgmkyEnJ4eTst4GY2Nj2NraskyafD4f4eHh+PXXX9G1a1d8+OGH1TJE9Kd6zOrVq3H06FHweDx4eHjgo48+Qvfu3d8qt8Tn81G3bl0IhUJcvHixwnb+76BSqXD16lVs3boVWq0WI0aMwKhRoziXD/orasQQMQwDqVSKq1evIjExEZaWlpg6dSratGlTJauql27p379/pa63tbXlnsLyFeg1wAoLC2Fvb4+AgAAEBATA3t4eJiYmBhsJhUKBgoICdOrUqcIWVh+P8lcZo6pCq9UiLi4Oa9euRVhYGAQCARo0aIBZs2Zh7NixFbaD1tbWmD17Nlq1aoXQ0FBcv34dWq0WR48exZAhQyqtrU5/Hv8mJibi8ePHbJ82adKkgh+P/sz05tKwAy+3TTUd8qBUKpGRkYFjx46hfv36kMlk2LRpExo0aIDZs2cbtBXUaDTIycmBvb09unfvjvbt22Po0KF/q/kWGBgIIyMjVkOuss+SnZ2NTZs2oaioCF27dsXUqVNhb2//xuvLysqgVCphY2Nj8GqpRgyRQqFgCcNLSkowYMAADBo0iDPBvH8KDMMgMjISkZGREIvFcHJyQqtWrRAQEICxY8fCw8PDoBOK6OhoEBFCQkIq/E0mk6G8vBw6nQ4qlYoNeNRvOSoLjUaDrVu34vjx4xAIBPjggw+waNEitG7d+o0+KRsbG/To0QNFRUUwMTHB+fPnkZSUhIiICDRq1Ohv69b7oX7//Xf88ccfuH//Png8HpydnTFs2DD07dsXAQEBKCsrY2ftVq1a1Ti9BZcgItjY2ODDDz/EkydPsHXrVmRmZkIikWDp0qXV9g2p1WocPXoU5eXlEIlEaNSoEVavXg0bG5u/XZ2UlJTg7NmzkMvlVYoFU6vVOHnyJK5fv85qB77qhiAiFBYWIjs7G8nJybh16xbKy8sxdOhQdO7c2aBJkvMe1+l0yMjIwIEDBxAbGwsbGxsMHToUbm5u7zUiODIykpN9LY/Hg5OTE5o2bYrMzEx4e3ujUaNGICJcuXIFx44dw+nTp/H8+XOsWbMGTk5O1fKf6OW51Wo1K42Un5+PkpISxMfHIzExEXv27EFsbCzEYjGrJNGyZctKvbj6vX9xcTGICA0bNsQnn3yCLl26/O0A6tmzJ8RiMSIiIlBSUoILFy7gk08++ds6VSoVDhw4gNWrV0OlUrER6Xl5edi2bRsuXLiAkJAQpKWlQSqVgsfjsVuKfwsEAgHc3d0xbdo0nD9/HkuWLEFRURGWLFmC4ODgar2c+i3ZggUL2Hbr1KlTpeSti4uLsW3bNuzfv58Na6lsnVKpFDdv3gSfz0fTpk3RvXt3CAQCEBFkMhkePXqEAwcOICYmBgkJCSgpKQER4cGDB7h58+b/liFKT0/HkiVLcOvWLZiZmWHChAno2LFjjcnUvAqBQIA6derAwsICT58+hVKpNPgomM/nw9vbGxs2bEBxcTG8vb1hY2MDIkJCQgI2btyIc+fO4fDhw5g7dy4cHByqtSpSq9VITk5GWloaNmzYAHt7e5SWlkIsFuPFixdsDIyVlRXMzc3B5/MRExODkJCQSr24Wq0Wt27dQmRkJADA3t4eTZo0eevgUalUUKvVEIlEKCoqwsWLF6FUKllZ48oYW41Ggzt37kCtVsPJyQmdOnWCVqvFnTt3kJ2djadPn+Lp06fvjV/HysqqRowcn8+HVqtFRkYGSkpK4O/vjw4dOlR7B8AwDKKiolBaWsoeJHTu3Pmdv5HJZLhz5w4OHTqECxcuoLy8HDweDw4ODpVuX41Gg/LyclhaWqJNmzasZJdKpUJYWBhCQ0ORkJAAPp+P4OBg+Pv748aNG3jy5AkSEhIQEhJS7cUGp72iUqlw69YtnDhxAkSEYcOGYcaMGZzJTf8dhEIh6tWrx3kem4mJCZo1awYiqvDi2tvbIzIyElevXkVpaalBJzIWFhZYs2YNMjMz4eTkBFtbWwgEAojFYuzYsQMbNmzA0KFDMXz4cHaVp1AoKj0LMQyD27dvIyMjA8DLgMJ169axgooODg5wdnZmy46MjERmZiZMTU2Rm5uLP/74AwzDoEuXLujVq1elBpx+ljUxMcGgQYPw5ZdfQqfTITs7G6dPn8bOnTsr+G+6du3K+fZdp9OxAbA+Pj41Ipkkl8sRFhaGffv2oX///mjVqlWlfWhvgk6nw549e6BSqWBtbY1Zs2Zh1KhRr11XVlaG2NhY5OTkID4+HqdPn0Z8fDwrxjlixAgMHjy4UhMjj8eDsbExbGxs0LRpU4wYMQJGRkaQyWQ4deoUVq5ciadPn6J79+6YNGkSAgMDYW1tjUOHDmH58uU4evQogoKCqr0D4cwQqdVqxMfH48yZMyAiBAUFYerUqQb5TaoKfaR1TRzRvmkmFQqFVfbTvA1GRkZo1aoVWrRowdJk6Mtt3749Dh8+DDc3N1hYWLD3UpWTDCJCZmYmeDweu9c/dOgQe/8mJiYwNTVlDUxRURF7AqS/v1WrVmHQoEGVPjETCATw9fXFlStXEBMTg0uXLqFt27YICgqCSCTCzZs3K5xoxcfHc54PlpWVhdjYWADgRBfur5DJZDhy5Ah++uknNG/eHAsXLqzSBPEmMAyDM2fOAHgZa9W2bVsoFAqYmJggMzOTDei9du0aTp8+DZlMBqlUyuY6fvDBB2jZsiXmzp1b6ch7vaM6JiYG7du3h6urKyQSCf744w9s2rQJ+fn5GD16NGbPno3GjRvDyMgIDMOwO46qbAPfBM4MkVwux65du3D27FnUqVMHM2bMQMuWLTk7hq0MNBoNHj16hIKCgvdSn1qtZuksDAWPx3vrtkEfbW2IQReLxVizZg2MjY1x4MABAGBpWYCXaR7A/0+n4fF4MDU1hYeHB0xNTfHhhx9i+PDhcHFxqfTLLBaL0aVLFxw8eBAPHz7EokWL4OrqipCQECiVSsTHx1coKysrCxEREejVqxdMTU05MRpisZhdZZWWlkKn03E2JsvKyvDDDz/g8OHD6NixI7744gtYW1sjNzf3NdXX6pTN5/ORl5eHuXPnwsjICJaWligsLERhYSGAl89TVlZWoZ0GDx6ML7/8Et7e3rCwsKj0Vkk/GcnlcpSVlbFpPvfu3UNmZiY++eQTTJkyBa6urmz76XQ6REZGQqFQoEuXLgb5gDkxRBqNBjExMThx4gS0Wi369OmDfv36caLxXRXonWparRZeXl6cBGDpg//Mzc3h4uLCfq9Wq3Hq1CkcOXIEUqkUbdq0gaura4045AsLC9ms/+oaIz6fDy8vL3z++eewtrbGxYsXWec18DIWxtzcHCYmJjAyMsKAAQPQqVMnNGzYECYmJjAxMYGxsXGVjINIJEKXLl1w4MABLFmyBHfv3kVeXh5rgJRKJYyMjNCwYUPk5eUhNzcX8+fPh1QqxahRozjpPwcHB9SvXx+xsbFITU2FUqnkZHumUCiwb98+7Ny5E926dcOSJUtga2uL48ePQ6lUonHjxtUum8/nY9CgQTh//jyUSiWio6MBvJmv2traGs2aNWPDVpYvX14thz+Px4OdnR06d+6MS5cu4eeff0a/fv3A4/HQoUMHfPLJJ6+dAN66dQvh4eFQKpVo2bKlYTsfQ7NmtVotPX78mBo3bkwCgYAGDRpEWVlZNaoc+jYoFAqaPn068fl82r17t8FSMVKplNauXUtjxoypkLmtVqvp/v371KNHDxIKheTi4kLh4eGkUqkMfYQ3YsuWLRQcHEyPHj0yuCy9IGBBQQFFR0fTrl27aNeuXRQeHk4xMTGUkZHBuWilWq2mlJQUmj17Njk6OrLaXObm5rR+/XrKy8ujsLAwqlu3LqsuGh8fz8kY0mff83g8mjVrFhUVFRlcpk6no/j4ePLy8qJRo0ZRfn4+yeVyOnHiBE2cOJGio6MNzrAvKiqi5cuXk7u7ewWBQ4FAQCKRiLy8vKh9+/a0fv16ys7OJolEQhKJxCCtM5VKRefOnSNnZ2dydXWlwYMHU+/evWn16tUVtArz8vLo119/pcDAQBKJROTr62twNr7BKyJ9rMiTJ0/g7OyMvn37VjmNoyZgqMY48HLpmZKSghMnTrDxUDY2Nrh8+TL++OMP5OXlwd7eHps3b0bbtm3fG+mWIRAKhRAKhTAzM4ONjQ0aNmwI4P/Lxbzqm+IKIpEIXl5eWLFiBQYMGICrV6/CxcUF7dq1Yx3I3bp1w+HDhzFp0iR06NCB8zxBLiGXy7FhwwY4OjpiwYIFKCkpwa5duxAWFoaBAweiXr16BrUhj8eDtbU1pk+fjt69e2PFihWIi4sDEcHS0hK9evXCxx9/DBcXFwiFQs58X2KxGO3bt8c333yDadOmsX6quLg4yGQydOzYEc+ePUNYWBju3bsHtVqNcePGYdKkSQavMjnZmumD0Zo3b46ePXv+40bI3d0dPj4+nDjJ9WRhFy9exPXr1yEQCNijbQcHB2zcuBHdunWrkdMY4OUWMDs7G1KplPOy9YyB7wN8Ph8WFhZo37492rRpAx6PV4G72sjICEFBQbhz5w74fD5EIhEn48jR0ZFlS3Bzc+MkjIRhGJSWluLx48cYOHAgysvL4erqivnz52PIkCGcpEPw+XzY29vD1tYWhw4dqhCYqGdirIn3zMTEBBMmTMDo0aMrfK/vq3bt2mHChAns/ejvxdBxZLAhEolE6NSpE+RyOUuZ+k8jODiYE54eCwsL/PTTT5g/fz7CwsKQk5MDpVIJb29v2NnZoUuXLnB1da3Rl1lP1WFmZvavWHG9C3rj87b2+itVCBcwMjLCokWLsHDhQs4Mr1AoRN26daFQKKDT6TB79myMGjUK3t7enI7/v2uvmgCPx4NIJHqvh0zAf0zXrLCwEHPnzkVISAimTJnCWUwK/ZkHRa+cKOn/fR/BeK+qX/wXxfX+jdArWQBgt7O1fVN9/LtY2P8GKSkpSExM5PyF1ftO9LOTnnf5fQ28miRFr0X1oF/967dItX1jGP5Thkifqd+8efP/iS1iLWpRi8rhP7U1q0UtavHvxH9qRVSLWtTi34na/Ust/k9Af9jAMEyFo2euRDH/ephR67yuGmoN0b8E+lMa/QkawK0TW6fTsWW/ulvXO2T/rXiVQTE2Nhbr1q3Dw4cPQUS4ePEiOnbsaNBRtUqlQlFREeLj4xEeHg4ej4eAgAB0794d9vb27+2kU88w8G891DB4hBERNBoNtFrtO7lxjYyMajQ2QafTQa1Ws0qr+ojTfzq40lDodDpIpVKkpKTg6tWr+OOPP3D37l0IBAIsWLAAn332mcEBdGq1GmFhYdixYweKioqQkJDAJsHu2LEDw4cPr7GAzZqERqNBcnIydu3ahcOHDyM9PR0AdysWhmEQGxuLvn37QiaTwczMDCKRCDqdDsePH8ewYcPQp08fWFhY1KhxUKlUWLJkCczMzPDpp59yrjn2XmBQggi9zMdat24d+fj4kLOzM7m4uJCtrS1ZW1uTjY0NOTs7k7m5OR0+fLjGcrEUCgXdvXuXunbtSjwej/h8Po0cOZKTvKK/Qq1Wk0QioZKSEiorKyOpVEoqlYqTnKxXoVKpqKysjCIiIqhPnz5kampKTk5OVLduXfLw8CCxWEwikYiSk5MNzmuKiYmhli1bEo/HY9tP/5k5cybnqp6vQqvVklqtJpVKRRKJhEpLS0mj0Rhcrk6nozNnzpC5uTkJhcIKz6T/hIeHG6QuyzAMJScn07Rp02jdunWUlJREcrmcnj9/TkOGDCGBQECHDx82OOfx71BaWkrDhw+niRMn/qtUlF+FQSsi+pPXZtOmTQgICMCyZcsgEonw7NkzlJWVwcTEBA0aNMDZs2dRWloKtVrNeXSwUqnEyZMnsXTpUqSkpLAz3fXr11FeXs4ZKZtWq4VEIsGdO3ewZs0aREREoG7duggJCcHgwYPRq1cvTvS+iAhyuRyHDh3CN998g/LycpSXl8PBwQF79+5F8+bNkZWVhdGjR7NskYZAKpXi9OnTiI2NhaWlJczMzCCTySAQCAzmmPk7qFQqpKSkICMjA3l5eThw4ADu37+Pc+fOoVmzZgZFFOs5vc3MzMAwDMzNzWFubo7i4mJIJBIQEQoKCqrE6fymOnx8fLBp0yb2O51Oh8zMTCQnJ8PNze295F1mZGQgMzMT9erVM+h53gUiYrfveuVhPYOnubn5P5viwePxYG9vj9GjR+PJkyewtbWFt7c3AgMDK1zXqFEjCASCGtmaJScn46effkJ6ejrc3NxYjiCFQoGMjAy4ubkZVC8RQaVSITExEWvXrsWJEydYHuHnz5/j+fPnOHv2LHbu3InevXsbnMukUqlw/vx5fP3113jx4gWEQiE8PDywePFitGrVCmZmZigtLUX79u0NVkXV6XSIiYnBb7/9hvr162PIkCFo3bo1zp07B4FAgKtXr9bYS6TT6RAREYH58+cjISGhQqTysWPH0KRJE4MNUUhICNauXYvIyEiEhITA398fv/32Gw4fPgwAiIiIQL9+/TibHHU6HV68eIHt27cjIyMDa9euRUhISI2nS+jFRw0lsKc/nflarZZ1tWg0GigUCsjlchQWFiIpKQmPHj1CZmYmIiIi0KRJE+zevRt2dnYGTcIG+4hMTU0xd+5cfPHFF1i6dCk2bdr0mnxKTfkXGIZBcXExiouL0bp1a8yZMwfJycn4+eefkZ2djS1btiAwMBBWVlbVKl+n0yEvLw8XL17E5s2bce/ePZiZmcHX15elck1PT0dOTg5WrFiBZs2awcPDw+DMa5VKhfz8fABAw4YN8fnnn6N3796sL8jDwwPLly83OIVFoVDg1q1bkMlkWLZsGSZPngw+n48mTZrg+fPnePjwIezs7Dg3RgzDID09HVu3bsXjx49Rp04dmJqaIj09HVZWVnBzc+PEp2JlZYWxY8di7NixAF4aHoVCASMjI3zwwQdYuHAhZ7ltRITs7Gz89NNPuHLlCgYOHIgPP/ywxjm5GIZBUlISSkpKqs2XrtVqkZeXB7lcjvz8fLx48YIt89mzZ0hISEB6ejrrf9VnFuhpf8vLyw0mgjPYEPF4PFhZWWHq1KlYsGAB7t+/jy5duhhabKUgk8lw69YtKBQKzJgxAwMGDEBGRgauXLmCrKwsHDhwALNmzUJISEi1OkgqlWLx4sXYs2cPjIyM0Lx5c3Tq1Al9+/ZFnTp1IBQKsW/fPqxfvx6xsbG4f/8+XFxcDJphBQIBSwfr7OyMadOmoU+fPq85pLng5dZnxBsZGSE/Px8KhQJmZmbsyYu5uTk6duzI6XZaT0m6fv16nD9/Hr6+vli8eDHi4+OxefNmjB49mjNStFeh0Whw8eJFnD59Gnw+HwMHDoSTkxNnRlYikWDfvn04fvw42rZti88//xxOTk6clP139T569AgSiaRaz0N/8oqPHDkSGRkZFRz6AoEAZmZmMDExQb169WBpaQlzc3M4OzujoKAAd+7cgUKh4OQ5ODmX1UuqODs749ixY2jTpg2MjY2hUqlQWlrK7teFQiEnQoTAy4EVGxuL48ePQ6fTwdTUFFqtFpmZmexqAgAOHDiAxo0bV3n1oH9hTp06BbFYjN69e2PRokUICAio8JI0bdoUFhYWyMvLM/iZgJeUreHh4TA1NcW0adMwYsSIGlPZNDY2RuvWrVGvXj0cPnwY/v7+aN68ObZv347Tp0/DxsaG0xWRvk2///577Nq1Cy1btsTnn3+OgIAAnD17FjqdDl27doWVlRXnp0x61RCNRoPu3bujX79+nK3U1Wo1rly5gl9//RUBAQFYtGgRfHx83ssx+qNHjxAZGQkHBwc0bdq0Wq4BvSAqwzAIDg6Gvb09HBwcYG9vDzc3Nzg6OsLLywu2trawsrKCjY0Ntm7diujoaNSrV48T7ijOAkQsLCzQoUMHXLx4EXl5eRCJRLh+/TquXr0KIyMj2NnZwcLCAt27d0eDBg0MnvFkMhlOnz6NxMREDB48GAEBASgtLcXevXuRkJBQIUO+OlCpVDh27BjKysrQsmVLfPrppwgMDHytvNTUVEgkEnh6eiIwMNDgmBv9DKd/SYqLi1kdM66hlybu3LkzQkND8fPPP8PBwQHXrl2Dh4cHFi1ahHr16nFCQ6Ffxq9btw6HDx9Gjx49sHjxYjRq1AjXrl1DZGQk2rRpg6ZNm3IetySRSHDixAlW4mrMmDGcHXHrdDo8e/YMW7ZsgY2NDcaPHw9vb+/3EjaiV81JSUnBmDFjqrU94vF4sLCwwK+//oqMjAy4u7uzRsjY2PiNpGu5ubm4c+cOZDIZZs2axcnEwVlricViNG3aFMXFxdizZw+WLVuGn3/+meVucXBwQGpqKlauXIno6GiDCeflcjlSUlJgaWmJnj17wt3dHUVFRUhNTYW5uTl69uxp0L5VrVYjIiKCVdcICgp6rbGlUinu37+P4uJijBo1ihPOalNTU9StWxdZWVlYu3YtFi5ciBMnTqCgoIDdo3MJExMTdOjQAZ6enrh58yaOHz+O0tJSjBgxAq1ateKMSCw7Oxtr167Frl270LlzZ6xZswaNGzdm/WwSiQQtWrTg5OTxr3jw4AE2bNiA8vJyjBkzBu3ateNk66fRaBAfH4/Vq1cjNTUVCxYsQL9+/d4bu+Tz589x6dIlEBG6detW7XpFIhFatmyJoUOHolWrVvDx8YGVldUbFWqICGFhYbh16xZcXV3RtWtXTtqSs6lHzygHAPv370f37t2xbNkyNG/eHNbW1hAIBCgoKMD06dPx22+/4ZdffjGow4qLi3H9+nV4eXnBy8uL9a3Uq1cPH3zwAfr06YOZM2dy8lz6QLVXodVqce7cOVy+fBlarRZNmjThZCbX61jVqVMHOTk5iIqKwjfffIM7d+5g4MCBCA4OrpI6w7ugVqvx+PFjHDt2jJUn1lOeBAYGcrJ1eXU7tmfPHtja2mLQoEGsU1+pVCItLQ0KhYKz1ZceOp0OSqUSt2/fRnp6Opo2bYpJkyZxdqReXl6OdevW4fjx45g5cyYGDBjw3mTVVSoVLly4gDt37qBdu3asRFNNIzs7G+Hh4SgqKsL06dNhb2/PycTB6RrYwcEBixcvhkwmQ6tWrdiTJT3s7e3RvXt3HDlyxODZXX9M3717d3h5ebHlz5s3DzY2NjAyMjJ4ZjIxMYFKpUJcXBySkpLg5eUFnU6H1NRU3Lx5E7///jtSU1MNquOv0Ouc169fH3K5HKmpqThx4gROnjyJGzduoGfPnpgzZw4cHR0Nepn00ktffPEFrly5AiMjI1hYWEChUICIkJycjPbt21fbuBIRysvLER8fjz179mD37t1QKpUwMzPD6dOnkZ6eDg8PDxQWFuLcuXOQSqUGqZQQESQSCRISEtjvpFIpIiMjceLECTAMg969e3NGIazT6fD8+XNcvXoVPXv2xMSJE2vMl/cmpKSk4MyZM+DxeBg0aBBcXV1r3CelUqnYcejl5YVhw4Zx5mfj1BCZmpqiffv2Lwt+wwDm8Xho0KCBwR2m1WpRVFQE4KXIoH4WEovF8PHxAQBER0cjOzsbjRo1qlYdJiYmGD16NM6cOYPr169j4cKFaNKkCeRyOaKiovDo0SOUlpYCeGk8HBwcOPMLvEpwb2dnh3r16qFXr15YtmwZfv31V9jb22PatGkGzb7l5eXYtGkTrl27Bj8/P0yaNAlubm7Yu3cvLly4gB07dqBVq1bV8nsxDINnz57hl19+wb1795CSkoLAwEC0bt2aldA+deoUysvLkZeXh+LiYuh0OoSGhuL06dMQCoUYNWoUu3WrDORyOdauXcsSvgMvX5zc3Fy2n2xtbdlYGUP7SiaTYdeuXSzHs6+vb6V+p9PpUFpaCoZhIJPJUFxcjKZNm1apbq1WiwcPHuDu3bvo3LkzOnfu/F4k3dPS0nDu3DkUFxezq3bOxjwnpfyJd4kE6qFQKN6Zk1YZyOVyXLt27a35QnK5HAcOHEBWVla16xCLxejRoweWLFmCNWvW4OzZs7h06RIYhmFFCfVRrGZmZnBzc6sxXXVbW1u0adMGM2bMwIIFC7Br1y706dMH9evXr9ZA0Gg0iI6OxqlTp+Dr64sVK1agR48eEIlEcHZ2Rk5ODuLi4nDt2jX4+/tX6bmICDk5OViyZAn++OMPmJqaYsqUKZg4cSKcnJzA4/FYEb+SkhJs27YNhw8fRnBwMMv5LBAIKh0gp195hYeHY8eOHRWUY/+K33//HVlZWZg5cyZcXFyq/RLpt5vh4eHo1asXOnTo8E6DKZFIkJSUhBs3bqCkpARPnz6FTqeDkZERGjVqVGVD9Pz5c+zduxdarRbt2rWrkuhldcEwDG7duoX79++jfv36GDBgAKcxUu81rVqr1eLChQvVEoB7FXrRw7fhyZMnuH79OmQyGdq1a1ftuszNzTFjxgy4uLjg+vXriI2NhVKphJeXF7p3746bN28iLCwMtra2NeJkfRUCgQAdOnRAgwYNcPXqVXZ5XJ2ZUKVSITw8HFZWVli8eDF69erFDqqWLVtixIgRSE9Px9mzZzFy5MhKSzMREUpKSvDpp5/izJkzcHJywpw5czBx4kRYWlqyZVhZWcHFxYVNGg0LC0O3bt3wySefsAmi5ubmlTYUDMPg6tWrFcI2XoWlpSWEQiESEhKQlpaGjIwMDBw4kE3LqSpkMhlWrVoFPp+P/v37vxYwK5PJ8OTJEyQnJ+PevXt4/vw5MjMzodPpYG9vj9atW6Nfv37sUXhVoFKpEBERgevXr2Pw4MEYMmTIe0lITk1NxZkzZ1BcXIzZs2fD09OT05NBzg2RRCKBTCaDs7Pza3/Lzs7Go0ePMGfOnGp72hmGwYsXL3Dx4kVYWVmhbt26FcqSyWQ4deoUkpKS8MEHH6BVq1bVduLp9aVGjx6NQYMGQSqVQqvVwtTUFHK5HA8fPgQADBkypNrR25WFVCrFkSNHEB8fDwsLCzRo0KDavg6GYVBeXg4rKyvUr1+fNUL0J0G/n58fbG1tcffuXaSnp8PR0bFSxpxhGBw6dAhhYWFwd3fHunXr0Llz57e+7FqtFllZWZBKpbC1tYWtrW21tpsqlapC5C/wsu8aNWqE9u3bo0OHDrC3t8d3332H8PBwHD9+HEVFRWjatCm8vLyq/EIpFAocO3YM7dq1Q7NmzcDj8SCRSJCVlYXk5GScPXuWVbUlIgwcOBAjRoxA06ZNYWlpyeb0VedFLioqwvXr10FECA4Ofi+5bHK5HCdPnsSVK1fQqFEj9OvXj3OnPKeGSCqVYs+ePRAKhZgyZcprf1u9ejUCAgLQunVrg5ygCoUCBQUFsLW1fU0GOSEhAVevXoVIJMIPP/zAbgeqCz6fz0ou62cvHo+Hx48fIzs7GwAQEhJSo3v03Nxc/PDDD9i7dy8KCgowZ84cBAYGGux0ffr0KRYvXow+ffqgbt26SE1NxY0bN/Dw4UNkZ2dDpVLh+fPnlY7t0a9kxo4di2nTpsHf3/+d7ZKfn4/ExEQolUq0bt26WjO7ngLjxo0bFe6jVatWWLVqFYKDg1k6mDZt2iAiIgIymQwJCQkoKSmBp6dnleskImi1Wjx9+hS//PILtFotbty4wbaZPlB09OjR8PT0hJ2dHYyNjQ3WaiMiPH/+HCdOnECXLl3Qp0+f9+IbSk9PR3h4OMrLyzFo0KBqGe+/BZep/FlZWTR58mTatm1bhe+lUimtXr2aWrZsSbGxsQbJ4mq1Wrp16xbx+XwSCoUVaCpevHhBEyZMIEdHRwoNDa0gk8slNBoN/fLLL2RtbU1OTk4UFRVVZXlkhmFILpezFBEMw5BGoyGdTkdyuZyePHlCoaGhNHr0aPLz8yMLCwuyt7envXv3UmlpqUFyzBKJhBYsWEB8Pp9EIhHZ2tqSs7Mz2djYkEgkYmkyfHx8KC4urkr9pVAoSCqVVuo3Bw4cIGdnZ/Lz86OUlJRqPYtUKiVnZ2f2noVCIbVr144iIyNfo/h48eIF9enTh33uy5cvV4tyRKFQ0I4dO8jHx4esra3JwsKC3N3dadq0aXTmzBnKzMwkiURCGo2GU3oYhmHo0qVLxOPxaPHixaRQKDgr+20oLi6mhQsXkrGxMQ0ePNhg2pm3gdMVkZ4aQK1WQ6vVQigUori4GN988w1OnTqFPXv2ICAgwOCsahMTE9ja2qK4uBhhYWEoKiqCiYkJCgsL8fjxY8yfPx8TJ06ssZgOhmGQk5ODsrIyhIaGwtfXt0ozBP3pS+nbty8cHR3h4+MDtVqNkpISWFtbIykpCbGxsZDJZFCpVBCJROjTpw9mzJiBkJCQ11aBVYWpqSkmTJiAkydPIiUlhT1Voj+d78bGxujSpQuWLl1a5S1gVVY1UqkUKpUKTZs2rfZJqkgkwrRp0/D1118DAHx9fbF69Wo0bdr0tfu2t7dH7969ERUVhdzc3Aq0sVWBkZERRo4ciZ49e7JtZ2FhATs7O9bZXlP+Qn3CqVgsrnHmTCJiV0N8Ph9dunThLCH5r+D0SSwtLeHi4oIlS5bg6tWrqF+/PiIjIxEXF4ft27ejZcuWBjcen8+Hv78/fvzxR0ydOhVZWVk4ceIEACAwMBDffvstevfuDXNz8xobDHl5eUhOTgYA+Pn5VXl5rL+vrKws3L9/H3Z2dhg0aBC8vb1Z+org4GAAQJ06ddC+fXt4e3vDxMSEkxgYPp+PevXq4ciRIwgNDcWBAwfAMAxatGiB/v37o3PnzggICICpqWmNqYwyDAOVSgUiQtOmTasd8yUWi/HFF1/gs88+A/CybcVi8Rvv28jICJMmTcL48eNBRNV+mfW5k05OTnB0dGS/q+mTKx6Ph+bNm+Prr79GWVkZVCpVjRqjvLw8bNiwAXFxcRg9ejT69etXc1tBLpdXDMNQSUkJbdu2jTp16kStW7emhQsXUkJCgkFMeG9CQUEBzZgxgwQCAftZunQplZWV1cjS8VUkJydTv379SCQS0aVLl6q11WQYhlQqFSmVSlIqlaRWq0mj0bz20Wq1Bm3D3gWdTkdqtZq9B5VKxW4Paxrl5eU0a9Ys4vP59NNPP5FMJqvxOv8L0G/hud72/RX67aepqSkFBQXRzZs3a3RccB5HZG1tjQkTJmD8+PHs9zWhhGlnZ4effvoJP/74Y4V63keyobm5OaysrNC7d2/4+vpWa9Wgn7n/Sbyv9noThEIhLC0tYWpqCkdHx/eq7/5vRmVi9biAWq1GcnIyFAoFmjdvDj8/vxodK7UCi9UE/al28W8n5/8noW/DWumd/z2Ul5fju+++w7Vr17Bhw4Y3Jn1ziVpDVIta1OKt0E8UNY3a6bwWtajFW/G+Vqr/KUOkFyA0NJetFu8f9Gcyai3+b+I/YYjoT97dr7/+Gg4ODpg5cyaKi4v/6duqRSXBMAz27t2L/v37o6CggLNy6U8JHL38Ta0X4n8X/5iWsF6yxFBJY61Wi8LCQjx58gRarRbfffcd+vbtW+O5X/920J9pCn/lhdLrwdfESefbEBMTg59//hnBwcGcxakQEcrKyrB3717cvn0bISEhGDVqlMEpP7WoIdRYYMA7oFAoaMWKFWRhYUEHDx6sVByOPnbiVTAMQ0+fPqWePXtSr1696NmzZ5zeJ8MwpFarSSaTsekYSqWSFAoFKRQKUqlU7yXmpiZQVlZGCxYsIACswqu9vT19/vnndPXqVSoqKnovzyaTyejTTz+l3r17U1JSEmd1SiQS+uabb0goFJKJiQmJxWL6+OOPKScnh9P4G41GQzKZjBN12v/LeO8rIpVKhePHj+PXX3+Fg4NDpdQO6E/1U51OV4E2QS6X48KFC4iMjMRHH33EuXyLSqXCqVOnsHLlSjg7O6Nx48YAgIKCAggEAgQEBODDDz9E/fr130vyIZeQy+V49uwZ+Hw+jIyMYGNjA2tra1y+fBnHjx/H+PHjMX78eDg5OdUYBalGo8Hp06dx8eJFzJo1C25ubpyEQ+h0Oty/fx/ff/89PDw80Lt3bzx58gT79+9Hz5490adPH85iuGJjYzFu3Dj8+uuvLCng/3VQNU7aODdERASNRgPgZR7QqzfEMAyOHj2Kr776CtbW1ti5cycCAwP/dvDxeLzXRBt1Oh0ePnyIr7/+ms1X+us1XECfV/bkyRNcvnz5tb9v2rQJv/76Kzp16vReeGG4Ao/Hg7GxMby9vdGtWzeMGzcO/v7+MDc3R35+PsrLy7F582YMHDiQMz7uV6HVanH79m388ssvCA4ORv/+/Tkj2iosLMSOHTug0+nQv39/fPbZZzh9+jTi4+ORnJwMjUbDmSEyNjaGTCbDhQsX0LhxYxgZGcHIyOj/XICmXiG2vLwcSqUSderUqdLvOR1d9Cdb3t27d2Fubv4aPUZpaSlu3boFqVSKrl27IiAgoNqzrVQqxZkzZ1BaWorOnTuzuVlcwtjYGH379kVpaSmOHj2KoqIiyOVy9u9KpRJ5eXmYPn06jhw5gqCgIE5e2FdlflUqFYCXkchisZjVGje0HmNjY3z44YeYN28egoKCKvSTq6srXF1dIZfLsWPHDnz77becG/mMjAz8+OOPMDMzw4IFC1jhBS6gVqshl8vRpUsXDB8+HM7OzujRowfOnDmD48ePY9iwYZzxS3t7e+Orr77CDz/8gLt376JFixYYPHgwfH19YWZmVmWDpFQqIRKJ/qcNGf15wqkXJ1CpVCgqKkJycjK+/vprFBYWIiUlpUqrW04NkVKpxIkTJ7Bs2TJMnDixAgWmSqXCwYMH8ccffyA4OBjffPONQdnxMpkML168APDyxakp57S5uTmmTZuGiRMnIjc3t8JpXFxcHNatW4cnT57g4MGD8PPzq3byJhFBpVKxumbHjx/H+fPn8fz5cwCAjY0NfH194ePjg/Xr18PBwcGg57KyssK4cePeeT81dZwulUpx7NgxPHnyBN9++22102TeBltbWyxYsACmpqYsna6VlRWsra2RlZXF6emZqakphg0bhjp16uDatWu4ffs2Tp8+ja5du2LmzJks/W1lQETYu3cvGjZsCHt7e5iYmFRqy68/GbSwsIC5uTmnbanVaqFQKKDRaKBUKqHRaFjhioyMDFy9ehWPHz9GVlYWm67ToUOHf25rRkTIysrCvn37UFBQAGNjY7ZB9Nuo3377DVlZWVi9erVBMiQMw6CwsBAxMTFwc3NDq1atavyUzMjICJ6enhWItMzNzVmDkJmZWW2tNvoz/CAsLAzh4eEICwtj6SX4fD5sbGxYOo5z585hxowZrymkcI2ioiIUFhbCwcGB01MmhmFw//59bN26Fb169aoR4nczMzO0bNmywnfl5eUoLy9Hy5YtOR8rVlZW6NWrF3r16oWCggJcuXIF27Ztw7Jly/DDDz+8ka30TSAiHDp0CPHx8SgrK0PDhg1ZhZq/Xgf8/2BDpVKJ7OxsdO3aFYsWLeJs9apUKhEXF4dz586x7JM5OTng8/koKSmBRqNBnTp10KBBA4wbNw6BgYHw8fGpFm0yJ4aI/jwqPXLkCO7fvw9nZ2fUqVOHnVELCgqwbds2pKSkoEuXLujQoYNBDlC1Wo2oqCgkJiZi+PDhGDBgwHuVctFDp9Oxx989evSoto9Ip9MhOjoaU6ZMgUKhYDvR1dUVLVu2xAcffIBevXpBKBRiwYIF+O2331CvXj2DNaXozzgbhmHY/tDpdOyBQlFREQYMGMCps1oikeDy5cswMzPDsGHDqszZXB0QER4/fozHjx+jd+/eNao95uDggOHDh6OoqAiLFy/GF198UWlDxOPxsH37dpw7dw7379/H8+fPkZub+9brxWIxHBwcYGFhgezsbOzcuRNTpkzhzBBlZmbis88+w61bt0BEMDY2RkhICDp16gQ7OzuIRCI0a9YMfn5+LNd4dcGJIVIqlTh79ix+/PFHaLVaDB48mKWxVCqVCA8Px7Vr12BkZITly5fD2dnZoJuWyWS4du0aiIilcf0nkJWVhdzcXFhbWxskcKfT6ZCTkwONRgNHR0d06tQJrq6uaNKkCbp27QoHBwe27Pbt2yM0NBSPHz82SBgAeNlvUVFRSE9PR7169VgfX0JCAu7evYsOHTqge/funDrhk5KScPz4cfTv3x9NmjR5b9LMDx8+hFQqRZ06dWrc/yKRSJCYmAgXF5cqTZA8Hg/u7u6YMmUKxo4d+7erbL2MlUajwaxZs/DHH38gNTUVderUMXjyICKUlpYiOTkZRMRyZs2YMQN+fn6cM0cYbIg0Gg3i4uKwefNmKBQKdOrUCWPHjmVVG3JycvDHH38gNzcXo0aNQv369Q0eCH+n4qHVaqFSqdiZ/k3SuYaivLwcZ8+exYsXL9CgQQODdM1EIhHatm2L0NBQODs7o02bNrCzs4NAIHitrbp06cKuLg3l/s7Pz8eaNWtw8+ZNuLq6AnjpvzEzM8Po0aMxYsQITo28TCbD1atXQUTsliw9PR3JycmQy+WoX78+fHx8DH6J9FHU+rZ58eIFoqKi0LZtWzRs2LDGaTSePn2Ke/fuoXv37tWWPTcxMam0VpparYanpyeICBcuXECLFi0MakP9hHTx4kXI5XL4+/tj/PjxGDduXI0FhBrUIwzDICMjA2vWrMGDBw9Qv359fPLJJwgICACPx4NGo8HNmzf/X3vfHR5V1X29ZiYzKZOQSiqpkEBoAQKhCUIEpUlL6L0KIkUpoiigIkUpL02kSVFEmvQiHSQBQklCSUJ6720m08vd3x8490ekSGbugPhlPc88YmbmnDn3nrPvPvvsvRauX78OR0dHVg3TkFFtyoCeRR1Bf1Gw3rp1Czdu3IBMJkNAQAC6du2KBg0acDYBiYiVLFIqlWjcuLFJckJ8Ph9eXl7/KJGtUCgQExMDhUJhspwLwzAsy5+XlxdcXFzg5uaG+/fvo6qqCm+//Tan3gPDMEhKSsLOnTvx1ltvwdPTE5cuXcLPP/+Mq1evQiaToU+fPli/fr3RMRyDOsnt27eRm5uL4OBg1KlTBwcOHMCNGzewbNkyk73xl8G9e/eQmpqKSZMmvZKUDpFIhPbt22Pfvn3IyMgwKlbJMAyqqqqg0Wig1Wrx22+/sdLx48aNw1tvvWVW1lOTVqZWq8XRo0dx8uRJWFhYoGHDhvD29mb1pRITE1lRu169eiE/Px9RUVFo164d2rZta5TVNkw2g9Lrk1Aqlfjll1+wefNmpKenQ6PRwMnJCa1bt8bmzZvh7e3NyYVUqVS4ePEikpOTYWVlhT59+rySGFVOTg5+/vlnVFVVoX79+iYZVsM2YMmSJQAeB3jFYjFSUlKwbt06nD9/Hs2aNYO9vT0n10ypVOLixYsoKyuDt7c3Ll26hC1btrDqwBcvXkRsbCwrXllTMAyDoqIirFu3DikpKeDz+di0aRMcHR2RmJgIT09PtGnTxuyJpyUlJbhy5QqaNGmCjh07vjLyOy8vL9SpUwd379416hpqNBocOXIEbm5u8PX1xb59+2BtbY1p06ahXbt2Zr9uJrsIfD6fTWa6desWlixZwk7c5ORkVos8MTERO3bsQLNmzUzSbTfIuBiOtQ0oLCzEgQMH8OOPP6KoqAjBwcEoKipCcXExzp49i8LCQtSrV4+TRRUXF4d9+/ZBJpPBzc0NzZs3N/uE02q1OH/+PFJSUhAREWFyoNpwGhcWFlbt715eXtDpdNi4cSPS09M5kS0CHsdNYmNj0bJlS+j1emzevBlOTk4YMmQIsrKywDAMOnfubLQHoVarsXfvXhw9ehQff/wxgoOD8dVXX+HcuXMAHks+WVhYQK/Xv3A8hYWFyMjIQPv27Y36HXFxcbh9+zY+/PBDzkUIX4R69erBzc0Nt2/ffqp+8GVgYWGBDh06wNbWFpaWlmjSpAlOnz6N33//HQqFAq1atYKrq+u/0yMSCoUYPHgwVCoV0tPTER8fj/j4eOTm5rJW2d7eHiEhIWjTpg3eeusthIWFwcXFxejJzefzUbduXTg6OkIul6OqqgpXr17FmTNncPjwYajVakybNg1EhKNHj6K0tBRt27blTJbXoLSZkpICAOjVq5dZb5ABDx48wMGDB9GsWTN8/PHHZvPAhEIhgoKC2IUdEBDAiVekUCiQmJiIkpISZGZmQqlUom/fvsjLy8ORI0fg7OyMCRMmGB2TUiqV2Lp1K3x9fREZGYns7GyUlpayJSy3b9/G8uXLMXHiRISGhj6lXqvValFSUoK5c+eCz+cbZYgKCwtx8OBBBAYGolu3bq80096QQ2QsLCwsEBgYCODxtZgzZw6aN2+OkpISbNu2Da6urpg7dy4r8MA1TDJEfD4f7u7umD59OlQqFWQyGSoqKrB161Zs27aN5a8eO3YsPD09YW1t/VTZR00hEAgQFBSE999/H5s2bcKlS5cQHx+P/Px8yOVytGjRApWVlYiLi0NmZiZatGiBDRs2cBIbUKvVOHv2LH766SdoNBoEBwdj0qRJcHBwMKndfwIRISEhASkpKejfvz88PDzMevLj4eGBt99+Gzdv3oREIuEk78agfGEQpRSLxTh48CCkUikaN26MOXPmoHHjxkZvNzUaDZKTk+Hq6oqYmBisXbsWaWlp6NWrFwYMGID79+/j4MGDuHv3Lrp06fKU+sqDBw+QkJCAO3fuYOvWrTXu37AjuHbtGj744AN4e3u/NhphYxM2DUm1hoeRn58fNBoN7t+/j/Xr1+Onn37CnDlzzDPfuaygZRiGCgsLafr06SQSiWj48OH04MEDysvLI4VCwVk/Go2GLl68SB4eHqywnqGC3N7enpydncnd3Z3WrFlDqampnFRGKxQKOnPmDHXo0IH4fD5ZW1vT8uXLWXFHcyIrK4tGjBhBTZs2pejoaLNXejMMQ3fu3KHRo0dTWloaJ9XqVVVV9N1335G1tTXxeDxydnamzp070+eff04JCQmkUqlM6qe0tJT8/PzIzs6OAgICyMbGhoYNG0ZJSUmkVCqpsrKS1q9fTwEBAWRnZ0eurq7k7u7OvhwcHKh169Z04MABo4QLS0pKaPr06dS3b19KTEw0u5LM31FVVUX9+/cnBwcHys/Pr/H3lUolbdiwgcaOHUtnz56t9p5Go6EbN27Q4MGDKTo6mqufXA2cl3icOHECe/fuhV6vh4uLC0QiEeRyOafZrBYWFggLC8M333yDzz//HKWlpex7MpkM/fv3x4QJE/DWW28ZrTH+JBQKBU6ePIlVq1bh7t274PF4mDRpEsaMGWP2ILVer8fZs2cRHR2NqVOnomnTppzWsz0r+U2lUiE5ORnl5eWclUPY2Nhg+PDhSE5Oxq+//ooPPvgAU6ZMYWXDTfXwxGIxFixYgJ07d8LW1pZlDzCc/FlZWWHChAkYPHgwbt++jby8vGrfb926NerVq4c6deoYFZgtKyvD/fv30apVK3h6er5xnEdarRYbN25ERkYGCgsL4e3tzabaCIVChISEICAgAEeOHEFwcDDnXhGnhsggQVJRUQEAbBAyICCA060Ej8dja3xUKhUWLVqELl264J133oFQKET37t3h6elpcooAAEgkEmzatAkbNmxAUVERdDodBg8ejJkzZ5oUdH9ZyOVyxMfH4/3338eoUaNMigOoVCps2bIFf/75J7y9vSGTyfDWW2/B0tISfn5+sLa2ho2NDQ4fPowdO3agZcuWbD6YqeDz+fDw8EDPnj2xe/duPHr0CFqtljNDbmlpiZEjR2LQoEHg8Xhs/tiT98eQ/Nq9e/en6ugMCq3GoqSkBDk5ORg3bpxJ98hUyGQypKSkoG7dujV6YPF4PHh5eSEpKQmXL1/G8OHDMXHiRPTt2xdSqRRXrlzBH3/8gUGDBpklD4uzFvV6PZs1y+PxEBISgsGDB8PT09MsfDY8Hg+2traYNGkSRo8eDYFAwF4gCwsLkw2ETqfD/fv3MWLECOTk5EChUMDV1RVjx47F1KlTOePO+Sfk5+cjJSUFXbt2NTmNXiQSoV+/frh79y42b94MIsKBAweqqaNaWFhAKpWiqqoKS5cu5dST5fP56NOnD8vnxOWRsIHW5GUCxOaYjwzDgGEYWFtbv5bYkCEB0tLSEseOHWNPCV8WVlZWWLx4MXtPBAIBrl27htjYWLbKvmfPnhgxYoRZdgGcGSIejwc+nw+xWIz+/ftjzpw5CA0NNWtQ1bCAuD46p7/S21euXImkpCQ4Ojqif//++OCDDxAWFsaJoXsZVFVVYdeuXbhz5w4mTpxo8gLi8/nw9vbGjz/+iLVr1yIjIwN//PEHUlNTceTIEdSvXx9WVlbIz8/H3r170bVrV86vrTnu178Bjo6OqFu3LjIzM6HRaF75GAUCAbp37479+/cjPz+/xswJFhYWaNeuHQ4ePPjcz/D5fE52Gc8Cp7pmhnwiHo/Hch+/iZBIJOjQoQPy8/Px7rvvYuLEiejUqRNEItErHVN2djY+/fRTJCYmYvfu3WjevDmn7Rue4vSX0CHw2LjTX+URb+r9ex1Qq9XYtWsXKioqMG3atNeyPbt79y5GjhyJ7OxspKamvnSx7b8BnG72+Hz+f+JpV6dOHcTHxwP4P0/vdQQfMzMz8fDhQ3zyySdo1KgR5+2/Tsnp/xosLS0xceJEAHht1zQ4OBi+vr549OgRfv75Z8yYMeONoTCunYXPgEFf3BDAfB1GSCKR4NSpU8jLy4O7u/t/wsD/1/G6Dbu1tTUGDRqEevXq4euvvza6XOZ1oNYQ/Uuh0+kgl8vBMMwbdxRci9eH8ePHIzMzE1KpFHZ2dq/757w0OI0R1aIWtaiFMaj1iGpRi1q8drw2pVdzgf6iPyWiN/rkzpygv4jxDUe8tdepFq8b/4nZR39pqalUKiQlJWHq1KlwdXXF3r17oVQqazXP/wa5XI5FixbByckJ7du3R3R09Gv9PQzDQK1WQ6PR1N6rlwDDMKyahoHITKfTvbJr9+R6M7yMFY4w4I33iLRaLXJycrBmzRocP34ccrkcCoUCRIQpU6YgLy8PEydOhKOj478u6GuQgdHpdBAIBK8kT8kgGHn48GF069YNo0aNQsOGDc3a5z/9nrS0NIwbNw7169fHunXrzK7I8iZDo9EgKSkJBw4cQHJyMgQCAezs7NC+fXtERESYPUCt0+lQWFiI//3vf/jpp5/Ycq4ffvjBtKRbs5TSEpFer2f16p/1ehm9+5dBWloa9evXjwQCATk4OFB4eDiNHz+epkyZQgEBASQUCikqKoqz/riCSqWiqKgomj17NtnY2ND48eMpNTXV7P3K5XL65ptvqHXr1pSYmGj2/v4JGRkZ1LdvXxIIBNShQwfKzs5+5ZXrXECv15NKpaKqqipSKpVmG0N2djYNHjyY7OzsyMvLi3x9fcnOzo6cnJzo/v37Zr12Go2GLly4QF26dCErKyuW+YLP59Ply5dNWmNGe0RExLrSBnL6J5Ufi4uLWcrYZ8HS0hL+/v4QiUQvLST3LOj1eohEIjRs2BDjxo3D6NGjWeL5PXv2YO7cucjIyECbNm04LTdhGAYajYYVoDOw4gkEAjg7O7/Qs2EYBtevX8cXX3yBqKgoAMD+/fthb2+PefPmsRXPhvYMbVlaWppUcEh/Eebv3LkTTZs2faZm1quEWq3G1atXER8fz1bM11RHzUAdrNPpYGVlBaFQ+NyscEPmv+GzXM0HvV6PoqIiHDlyBLdu3UKHDh0wePBgs3h2Wq0WPB4PM2bMwPjx42FnZ4elS5dix44dyMvLQ8OGDTmtpaO/tmFKpRI3btzAF198gfj4eJYz3qAk0rJlS5Oup9GzWqfT4cSJE6ioqEDPnj0hFouRnp6Offv24erVq0hOTkZFRQWrBf73yWVYsHXr1sW0adMwZMgQo7YlHh4eWLBgASwsLODv719Ns8rPzw9WVlbYtm2bUfpcDMNApVKBiNhCP41GA5lMhpycHERHR+PevXs4evQoioqKADymWk1ISHhhij/DMNi6dStrhIDHVdNr1qzBmjVr4OLigsaNG7Nj8PDwAAC8//77qFevHuzt7WFnZ1fjG88wDAoLC5GXl4fOnTv/4/U2lH8A4Dy7nIhw+/ZtbN++HUVFRYiMjERERESNWQ1lMhkGDBiAlJQUDBgwAO3bt0dQUNAzaSoqKyuRkpKC+Ph4TJ8+nRO6DiJCUVERVqxYgfLycowbNw5Xr15FTEwMunTpwnmBrYuLCz788EN4e3vD398flZWVrEhEUFAQ5/3pdDrExMRgw4YNuH37NvLz89GkSRO4ubnh5s2bqFevHr7//nuT1V5MMkTbt2/H2bNnUb9+fbRr1w7Hjx+HVqtF3bp1ERgYCEdHR3h7e8Pb2/upzGCVSoW4uDhkZGRg+vTpGDRokFGGyNbWFiEhIS/8jDHSyQY12R07dgAAhg8fDoZhkJCQgB9++AEXL16EVqtl2zZM6JeZ2Hw+HyNHjoRcLkdCQgL0ej1kMhns7e2h0WhQWlqKq1evAgD7XwBYsWIFAGDKlClYsWJFjYX0GIZBZmYmPDw8MHbs2Odma+t0OlRUVCAvLw9qtRoAWNFMrrwIg0hmQkICNBoN/P39jfKKeTweS2d79+5dXLhwAUqlEhqNBgqFAsBjL8JQsCmTyWBra4tRo0ZxQh+sUChw+PBhVlDRIDt+6dIlNG3alH2IcIU6deqgc+fO0Gg0qKysxE8//YTExEQsWLCA877oL1WcAwcO4NChQ2AYBnZ2dvjoo48QFBSEadOmwc3NDR06dDDZABptiEQiET777DOcOXMGGRkZUKvVaNmyJUJDQxEeHg5/f3/Y29tDJBLBxsbmKa+IiKBQKJCWlobLly+bJUibm5sLtVpdY/oMww346aefsGjRIojFYhw4cABCoRAlJSXQarVo2bIlPD092QVVWFgIhmFeqtiRz+ejZ8+e6N69O65fvw6NRoP09HQ0atQIVVVVuHnzJqvblpKSgrt370KpVLLfLy4uNsq4arVa/PHHHyzh/7NgMI5btmxhKV10Oh3eeustrFu3Dn5+fpzcq9zcXJw/fx7l5eVwcXExmuPZ1tYWGzduhFarRUVFBQoKClBWVobKykrk5uaCYRjI5XKIRCLk5OTg2LFj6NevHzw8PEweh16vR3JyMi5duoTx48ezOmRubm6Qy+WQyWQmtf8sGGR/bt++jSNHjiAtLQ0zZ85Ez549OefIlkql2L59O/bs2QMigpOTE4YPH46ePXtWIyPkAiadmhmeYF5eXvj666/Rrl07iMViSCQSpKWlITU1FSqVCh4eHvD394enpyfq1asHkUgEHo8HsViM5s2bc15VDjym0Dh06BBKS0vRrl27Gj3J5XI5fvjhB2zfvp3Nt1Gr1QgJCUHr1q3h4uKCZs2asURSCxcuRElJCXg8Hnr16vXScRwLCwt06tQJwGPhRAN69eoFpVKJrKws/Pzzz0hKSmINkZOTE/r37282YvZr165hwYIFKCwsRFhYGMLDwyGRSLBjxw58//33WL16tcluuFqtxh9//IE///wTIpEIY8aMQfPmzY2Kfz3JQ2RnZwcfH5/nfnbXrl04fvw4+vTpw8npUlVVFX7//Xf4+/ujS5curGEzGD9j1DReBI1Gg6ysLOzduxcHDhyAt7c3Pv74Y3Ts2JFTGW2Dk3DixAl8//33kEgkcHV1xfjx4zF9+nS4ubmxophcweTje4FAgFatWqFv377IyMjA7t27cfToUaSnp0MsFrOTVqfToVmzZpgxYwbatWsHe3t7sx1Va7Va7Nu3D9euXUOdOnXQr1+/l3Yd9Xo9Hjx4gO+//x5qtRqBgYHo06cPevfujeDgYDg5ObELRq/X4+rVq7h16xYYhkH37t0xefJkkwtUlUolLly4gC+//BJxcXHs3xs1aoRx48aZzRBVVlbi999/h06nw4wZMzBw4ED4+vqyR8Znz56FRCKBlZWVSVuazMxMnDhxAhKJBE5OThg2bNgrESCoqqpiZZS48IZSUlIQHR2NhQsXQiQSsR7Qo0ePIJPJOI3X6HQ6JCYm4ttvv8XDhw/RvXt3TJkyBUFBQZyvI5VKhfPnz2P9+vWQSCRwcHDA8OHDMX36dLi7u4OIcPPmTVRUVMDf35+TPk02RCKRCLa2tjh79iw2bNiA+Ph4NGnSBOPHj0ebNm3g4OAAlUqF4uJiREVFYdmyZQgLC8PIkSPRuHFjs1SVSyQSHDp0CHq9HoMHD66RnhkRQaVSoW7dumjatCmmTJmC9u3bP7VQDPkv169fh1wuh7u7OxYsWAB/f3+TJ4ZKpcKFCxeqGSEA+PDDDzFx4kSTPRKGYZ56Whu2bZcuXcKsWbMwduxY9ilrIM06f/48qqqq4ObmZnTfer0e9+/fx82bNwEAjRs3fiV5QzqdDkVFRRCLxf94qvkyMAT+BQIB6tevD7lcjrNnzyIhIQFXr15Feno6xowZAz8/P07ialqtFjExMTh37hwaNmyIsLAwuLq6cp7EyDAMiouLsWPHDty6dQsODg4YNWoUZs2axd53pVKJ5OTkf5dHxDAM7t+/j1u3bkEikeCDDz5AREQEG7QzGACGYfD+++/jjz/+wFdffYU7d+7gf//7H5o1a8apRZdIJNi3bx8SEhLQr18/TJ8+vUa8ywKBAKGhodi6dSs8PDwQFBT0zIlUWVmJH3/8EefPn4der0e3bt0401UXi8Xo06cPzpw5g6SkJPbvDx48wNmzZ9GmTRu4ubkZPcErKiqQlpZWTZddLpfjxo0bsLKyQocOHaq5+jweD23atOHkCV9QUIATJ05AJpPBxcUFQ4cONcmwvSzkcjmys7NZilpTg9R8Ph/+/v5wcXFBTEwMAgMDkZ6ejp9//pkV/0xNTeWMpVQoFOKdd97BZ599hjt37mD37t24efMmOnTogK5du8LFxYWTdaRWq3Hy5Elcv34dABAWFoapU6dWe5jL5XLk5ORwSzNibAKSTqejmzdvEp/PJxsbG2rRogXt2LGDysrKSK/XP/d7SqWSDhw4QF5eXjRu3LgaS7fo9XqSy+WUmZlJR48epcOHD9ODBw+oqqqKiouLad26dRQUFES9e/emuLg4s0nvPHr0iHr06EECgYACAwMpOjqaNBoNZ+3LZDK6ceMGDR06lACwLzc3Nxo2bBhVVFTUuE2VSkXfffcdeXh40M6dO6u9V1BQQBMmTKChQ4dSdnb2U989efIkubi4UHJystFJcwzD0JkzZ8je3p74fD6NHj2aMjMzXzhfuEJ8fDx16tSJ+vfvb5TczrOgVCrp8uXLtGDBApoyZQoNHTqUwsPDafDgwRQcHEx79uwhlUrFSV9Ej6+fXC6npKQk2r59Ow0dOpQaN25M06dPp4cPH5o8/xiGoZycHGratCnx+XwKCgqi33777ak1evv2bWrRogXx+XwaN24cyWQyk/ol4kBOiMfjoXHjxli1ahXCwsL+MXZhZWWFvn37YuPGjThy5Ahmzpz50l6RwR1ev349EhMTERcXByJC/fr10aJFCyiVSpw9exaVlZVYsmQJGjVqZBbFAYVCgfPnz+P+/fsAHgfr/f39OY0JiMVitG3bFt9//z2aN2+Oixcv4tatWygqKsLevXthaWmJDRs21IjIXCAQICwsDDKZDA8fPoROp3vq+tjY2Dw1DplMhosXL8LS0tKk2JRUKsXly5fZWEpAQAAn26SXQWZmJrKzs9G/f3/OtoJWVlZo3749/P39kZOTA71eDzs7OzAMg5UrV8LLy4vTOWFQrwkKCoKvry+6deuG48ePY/fu3cjKysKaNWtMUmJVKpXYvn07EhMTYWVlhV69eqF3797V7jkR4f79+yguLgafz0fnzp05WWNGzwCDcqenpyc++ugjtG/f/qUnqUgkwvTp0wEAv/3220sdRdNfWcGLFy/Grl27oNPpEBkZif79+0OtVuPHH3/E7t27kZ2dDaVSiV27diE+Ph5ardbYIT4X0dHRWLVqFQoLC0FEePfdd81W41OvXj1Mnz4dW7Zswc6dOxEZGQkbGxvs3LkTq1atYvN8XgZ8Ph+urq6wsbFBdHQ0u4UAHrP7OTk5PXMbER8fj4sXL6J3795wcnIyaqKrVCqcPXuWPQr28vJCmzZtXokss16vR1ZWFsrLy+Hl5cXpw0kkEsHHxwcdO3ZE586d0bJlS1ZmysbGxixG1nBS6OPjg7Fjx2Lo0KGIjY3F7t27IZfLjW5XpVJh//79ICK4ubmha9euT6WjpKSk4OTJk6ioqIC9vT06duzIjbE11pViGIZkMhnFxMQY5ZpJJBIKCwsjPz8/Kigo+Ed3X6FQ0LRp08jNzY0+/PBDysvLo8rKSkpJSaFJkyaxSq8BAQHk7OxMfD6fmjVrRpcvX+Z0y1RYWEgTJkxga2wiIyMpLS2Nk+2FWq2mlJQUunz5MmVmZj7z/Tt37lDjxo0JADk6OlJCQkKN+i4pKaFu3bpRQEAAnTlzhv27Tqej5ORk+vLLL+n+/fvs3+/fv089e/ak4OBgk8ZZXFxM48ePJz6fT/b29vTFF18Ytb00Bmq1mr744gvi8/n022+/kVqtNmt/mZmZNHToUIqJiTFrPwbk5ORQz549qWvXrlRYWGh0OyUlJeTj48OunaioKPY9hmHo0aNHNGrUKLK1tSU+n0/dunWjsrIyLoZAJplrmUyGxMREo7wOW1tbNGnSBPn5+ZBIJC/8rOGk5eDBg2jdujUWL14MNzc3FBQU4LvvvsPZs2fRokULbN26FadOncLp06cxc+ZM5OXlYd++fZwF1ZRKJY4dO4aTJ08CeJxuP3LkSM40ziorK/HVV19h3bp1KC8vf+p9kUgEd3d39ilVUVGBioqKGp2c2NnZYdSoUSgrK8OePXtYLXqBQICAgAB88sknqF+/PlQqFW7cuIFFixbhzz//RN++feHp6WnUOIkIEomE9cC8vb3RvXv3GmeGmwKtVgsrKys4OTmZfStIT6iivAqUlJSgrKzM6Oz0Z6FOnTrsYYZGo8GDBw/wzTff4PDhw1AoFGjSpAlmz57NmcaZST6qSqXC+vXrsX//fgwePBh9+vSBvb39S50SyGQy3Lt3Dw0bNnypmh8D54m9vT10Oh127tyJ3377DTdv3kTHjh3xySefsAmVRITg4GCEhISgqKiIsxqpkpISXLx4ESUlJXBycsIXX3yB8PBwTlIQtFot7ty5g0OHDuG99957rhTMuXPnkJWVZXQ/IpEI77zzDpo3b46TJ0/C09MTs2fPhqOjI7tliYmJwb59+3Dp0iVkZ2dj8uTJmD17tkmFyTk5Obh16xYAoH379mjSpMkrJ2NzcHBA3bp1zaq1BwCFhYWQSqVmEXJ8ElqtFn/++Se+/fZbJCQkYNq0aZxtdfPy8nDixAncu3cPFy9exM2bN5GcnMzKlM+ePZuV2OIEprhTarWarl69Sq1btyZnZ2dq3bo1zZgxg86dO0eVlZXP/Z5SqaSPP/6YbGxsaNWqVS91slVWVkZt27YlHx8feu+998jFxYXs7e2pd+/edP36dVKr1U9t71QqFSkUCk62TQzDUHx8PHXo0IH4fD716NGDHj16xBntAsMwFBcXRwDI39+ftmzZQhKJhH2/oqKCNm3aREFBQcTn8wkA7dq1ixQKRY370mq1dOPGDWrWrBnZ29tT27ZtacSIETR+/Hjq0qULeXp6klgsJi8vL9q1axdVVlaaNE6NRkOnTp0iPp9Pjo6OtH79ek5Pk/4JlZWVNGXKFPLx8am27TQXzp49S6NHj6aUlBTO21apVJSfn0+nT5+mUaNGka+vL7m4uNCaNWtIIpGYdJ+kUimNHj2a+Hw+CYVCcnZ2JldXV7KxsSGBQEB8Pp89ca2qquKUcsRkPiKtVku5ubk0b948cnZ2Jmtra3J2dqbg4GCaMWMG7dy5k6KioqigoIBiY2Npx44d1L17d7KxsaFOnTpRaWnpSw1IqVTSwoULycLCgoRCITVu3JgOHTpE5eXlZjui/3v/GzduZHlYxowZQ3l5eZz2IZPJ6Pvvv2fjKN7e3uTv70/+/v7k5eVFdnZ2rBFq27YtXb9+3eixazQaSkhIoAkTJpCPjw9ZWVmRtbU12djY0JAhQ2jt2rWUnJxMKpXK5AknlUpp0aJFxOfzaebMmWbl63kW7t27R507d6bOnTtTWlqa2fs7c+YMjR8/3uS+9Ho9PXr0iMaNG0crVqyg+fPnU7du3cjT05OcnZ3JxcWFhgwZQleuXCG5XG7yNdXr9ZSbm0tDhgypxjXE5/PJ2tqapkyZQsnJyc986JsKTojRGIYhpVJJSUlJtGTJEurSpQsJBAISiURka2tLDg4O5OLiQo6OjmRra0sCgYBGjx5NeXl5L+2tMAxDarWa5HI5yeVyUigUpNVqX8mE1mq1dOXKFfLz8yOBQEBdunShu3fvck62xjAMaTQaOnbsWLXcob+/2rZtS9nZ2SYbYAOZl0KhYK+rXC4npVJJGo2Gs/wejUZDR44cIT6fT59//vkryRt6EhcvXqSAgABasWIFJzkv/4Rff/2Vhg0bZrIhMsw7oVBINjY2ZGVlRUFBQTR16lRavXo1paenk1Kp5HQeGozRggULKDg4mBwdHWnatGl09+5dqqqqMtu94+Qc03CcGBQUhE8//RRz5sxBfn4+oqOj2bR34HG+zdtvv41evXrB19e3Rhmu5tK5fxkwDIPc3Fzk5OQAAAYNGoSQkBDOYxwGoqnevXujpKQEK1aswMqVK9GoUSP06dMHHh4eaN26NVq1agWxWMxJdvCrUAIVCoXo06cPFArFKyfqp78C5UqlEra2tmaPDwGPM49rklbxPFhYWKBjx46oqqpi//ak8rA5FIj5fD48PT2xePFiLFy4sJoIhTnvG6fZfk8qpPr5+cHX1xdDhw596jOG15sEeuIURCgUmvWm8Pl8uLi4YPny5Vi2bBmA6tftTbt2wONTuVdhBP4OvV6P1NRUFBYWvrLr5uDgYHI9oAGv47oZ1vGrhNl6e1MXzL8Jr2Ph/tcgEAjg6+uLkJAQeHt7vxJvLCIiAhEREbXzvwaoVXqtAQyXqnaCvXkgotr79i9GrSGqRS1q8drxnxBYrEUtavFm45VEpP5OxPVfkjh+UmHTwsKi1v2vRS2MgNmtARHhjz/+QHBwMEQiEerVq4eYmBiTJWpfNwzHwlOmTIGtrS2aNm2KjIwMo0jt/3+GQT75SUUUc+JJdV1zRyUMY1OpVJzzV79KGMahVqtZiWmNRsPp/TKrIdLr9Sxta0ZGBmxsbKBUKnHp0iWTDJFB3FCtVkOpVEImk0GhUECpVEKtVpt9QhMRcnNzMX36dOzZswd6vR75+flISUkxy4Qz6Ku9Sm14+osy19x95uXl4bPPPsPnn3+OlJQUszygDMKfUqkU58+fx6ZNm7Bp0yZkZWVBrVabZXw6nQ6xsbH46KOP4O/vj6tXr3I2NiJihT1lMhk7/7mce0TEXrfExER8/vnnaN68OVxdXeHt7Y0RI0YgMTGRu/tlljRJepwlnJWVRYMHDyaBQEAeHh40f/58+uGHHyg2NtYoag69Xk8SiYTu3r1LX331Fc2fP5+6du1KPB6PfH19qWXLljR//nx69OiRWcsISktLacqUKSQUCkkgEJCbmxstXLiQqqqqzNJfeXk5jRw5ktauXUtyudzk9hiGIZVK9cJrJJPJaMyYMfT111+bNRv5woULFBwcTP7+/nTp0iXOKDoYhiGtVktKpZJiYmKof//+5OzsTCKRiC1bsLe3pxUrVlBZWRln2ck6nY7kcjmdPn2aunTpQiKRiHg8Hk2ePNnk62ioLiguLqa9e/dSWFgYm23fokULSklJ4WTO6/V6qqyspAsXLtBHH31EoaGh1LRpUxo9ejTt3r2b9u7dS82aNaOWLVtScXGxyf0RcVTi8XdotVoqLCykr776ipydncnX15e2bdtm8iKqqKigQYMGsRNJIBCQUChkX4bCPD6fT7t37zZLYaVCoaAdO3awvC2enp60fft2o4pPXwZ6vZ4ePHhA4eHh1KFDB8rKyjK5TZlMRuvXr6dly5Y913iWlZVR3759ydbWlvOaOgO0Wi0tX76c3NzcaP/+/ZzdL61WS8XFxRQdHU3z588nX19ftogzMDCQgoODycvLiy2d6NixI92/f9/k8gWtVktxcXE0bNgwsrW1ZTmyLCws6MCBAyYZWYZhqLKykn799Vfq1q3bU9rzfD6frly5YnLZD8MwVFpaSgsWLKAWLVrQhAkT6ObNm9Xqy8rKyqh37940cuTIFxa31wScGyKdTkf5+fk0depUsrKy4swIMQxDmZmZ5OjoSNbW1uTq6kqdOnWiIUOGsK/w8HByc3MjgUBAgwcPptLSUo5G9RiG2p+WLVuSQCAgT09P2rx5s1k9hoqKCpo0aRIBIFtbW0pISDC5zcLCQgoNDaWePXs+k5+a6LHBnTp1Kjk5OVFmZqZZvMvKykoaM2YM+fj4UHJyMidtMgxDeXl59NFHH5GjoyO7SB0cHGjp0qWUnJxMubm5dOrUKWrUqBG5u7uThYUFhYaGUn5+vtHj1Ol0lJCQQP369WMNkOHl4uJC8fHxJhkJhUJBW7ZsYUnJnvWaM2cOJSYmmlQAq9VqKSkpibZt20a5ublPGWelUknff/89hYSE0I0bNzgrOOf01EytViMzMxN79uzBoUOH0L59e8yaNQvh4eEmC8DxeDw4OTlh/vz5yMnJQXBwMCIjI+Hq6sp+prCwEF999RV+/vlnCAQCzrXas7KysHbtWsTHx8Pe3h6ffvopRowYwRk51LOgUCjYWqOBAwfCxcXFpPYYhkFlZSUYhkH79u1Rr169Z37O2toa/v7+EIlEKCkp4VRu2oB79+7h7t27nLZpCKxWVVVBIpGwdZDvvvsuhg0bBj8/PwCPhSqHDBkCsViMZcuW4f79+5gyZQp+//33Go+TiFBUVIT169fj+vXrCAsLQ35+PkpKSuDj44PS0lJ8+umn2Lhxo9FKuWq1Gg8fPgQRPbN8RK/XY82aNTh69Cjmzp2LUaNGGcVNZGFhgYYNG6Jhw4ZPjVGtVuPPP//ExYsXMWzYMM5UawCOj+9LSkowZ84cnDlzBvXq1cOcOXPQs2dPzgyCnZ0d5s2b99TfDcHroqIiFBYWQqvVIiAggDNiKiJCZWUldu/ejVOnTsHGxgYRERGIjIw0qxECHstLZ2ZmAgBLPGcK5HI5du7cCbVajXffffeF98bLywuWlpZmO+G8c+cO0tLS0Lx5c06KmdVqNRITE3Hu3DmcOXMGVlZWCA0NRfv27TFixIhqRtfa2hoff/wxkpOTsWrVKkgkEhQXFxvVr0wmw969e7Fv3z5069YNixcvxqVLl3Dnzh2MGTMGR44cwU8//YT169dj6dKlRtWhicVijB079pmS5kSE1NRUnDt3Dmlpadi7dy+GDBnCGUmaXq9HeXk5zp07h3379qFt27bsaTFn4MSv+guJiYnk6+tLAQEBtHnz5mrEXlyCYRhSKBRUXFxM2dnZdPv2bdq1axf16dOHDUYeP36cM65qpVJJe/bsIRcXFxIIBNS1a1eKi4ujqqoqys7OppSUFMrNzTVLgHzHjh1kbW1NdnZ2dPv2bZPaUqvVdPz4cXJ2dqaRI0f+I7/xgQMHyNvbmzZs2MB5vE2r1dIXX3xBAoGAFi5cSFKp1KT2GIah7OxsVubGxsaGBg4cSHFxcS+M/WzYsIGVN9qyZUuN40RKpZKOHj1K9evXp0aNGtHevXtJLpdTWVkZlZeXk06no6KiIgoJCSEej0epqamczhGlUklFRUW0du1a8vLyInt7e5o0aRJn4QK9Xk8ZGRk0f/58ioiIoA0bNlB5eTnn85wzj8ig963T6RAeHo7Bgwdzzkms1WqRn5+P4uJixMbGIjY2FmVlZXjw4AEyMzOrUS9cuHABdevWRePGjasJPdYUDMMgJycHe/fuRUVFBerWrYvOnTtDIpFg8+bNuHHjBsrKyuDh4YFevXqhX79+nFB0GCCTyaBUKtGpUyc4Ojoa3Q7DMMjIyMCXX34JZ2dnTJky5R+FDR89elSNgoJLFBQUIDk5GcHBwejevbtJT2/6S0768OHDyM3NhaOjI3r27InZs2ejefPmL7wXCQkJ0Gg04PP51QQnXwY6nQ4PHz7EypUroVAoMHfuXPTu3Rs2NjbVQhH29vZo3LgxEhISEB0dDV9fX062NCqVCjExMTh06BAOHz6MgoICDBw4EFOmTOGE3kWn0yEnJwebN29GYWEhZs+ejZYtW5pFeYUzQ6TX61FRUQGtVgudTse5jI9KpcK5c+ewe/duJCUlISsrq5p0io2NDby8vKDT6VBRUYEdO3bgwoULGDZsGGbMmGH0Fkoul+O3337D+fPnwePx4Ovri7KyMnz++ee4e/cuNBoNhEIhdDodzp8/DycnJ3Tr1o2TbaFSqURJSQkAoFOnTibFh7RaLXbv3o3k5GSMGTMGrVq1Mvn3GQu5XI4jR47g8uXLiIyMRKNGjUy6Xnq9HrGxsfj222+hVqsxePBgLFiwAL6+vi80QiUlJcjNzYVOp4OtrS3atGlTowdIVVUVtm/fjps3b2LUqFEYMWLEM2WlRCIRmjRpghMnTkAikZiUt6RWqyGRSFBeXo7Lly/j2LFjuHbtGuRyOdq3b4/p06ejadOmJhs6lUqFuLg4bN26FZaWlpg/fz4aNGhgNnoQzlrl8/mwt7eHhYUF5wlier0eDx8+xMyZM58ijrexsUHLli3x7rvvokWLFlCr1bh+/Tr279+PhIQErFixAi1btsQ777xT48mu1+uRmZmJX3/9FWq1GgKBANnZ2cjKykJRURECAwPxzjvvwMvLCwkJCTh+/DiWL1+O9u3bw97e3mSvKD8/H/Hx8QAeS/8auydnGAYpKSk4fPgw6tevj48++ogzvpyagoiQkJCAXbt2QSgUomPHjibHGrRaLQ4ePIjS0lI0aNAAo0ePhr+//wu/I5VKsWHDBkRFRYHH46Ffv35wd3d/6Xum0+nw6NEjnD59GkFBQRg+fPhzPSoigkKhMCnRVq/Xo6CgAMeOHUNcXBxycnIQExNTzbC1aNECTZs2NfkhqNfrkZycjK+//hoODg6YM2cOgoKC3gxiNJ1Oh/z8fKjVari6ulYLqkokEjx48AA2NjYIDg42yrVTKBSs7JClpSV8fX3RqlUrdOzYER06dECDBg1gY2MDIkLXrl3h5+eH77//Hrm5uVi8eDGaN28ODw+PGhkHlUqFw4cPIy0tDTwejxV5BB6rlH722Wfo3bs3xGIxoqKiEBUVhWvXrkGhUHCiJpqcnIyoqCj4+vqaJFnEMAxu376NjIwMBAcHQyKRICkp6YX8PFqtFkVFRdBoNEhPT4dWq+XE3S8rK8Mvv/yC+/fvY86cOejTp4/Jrr5KpcKpU6dgYWHBLsYXQa/X448//sDOnTtRUVGBBg0a4LPPPqvR016pVOLw4cOQSqUYPnw42rZt+9zTtuLiYty9exdqtRrt2rWr8amcXq9HRkYGli9fjt9//51dBwaGTa1WC71ej3PnzmH8+PGoU6eOSZ6LTqdDYmIirl27hoiICGRlZUEikcDPzw/Ozs5mUSfhdGtWUFAAtVqN0tJSVFVVwdnZGVKpFFu2bMGePXtgbW2N+fPn47333qvR5OPz+WjRogW2bNmC/Px8iMViNGnSBPXq1YOzszNEIlG1BeXk5IQxY8ZAJpNh5cqVuHXrFs6fP4/hw4fX6AYpFApcv379qdR5a2trjBgxAv3794eDgwMAvLSMUk1QUlKC0tJStGnTBk5OTka3IxAIEB4ejpEjR2Lfvn2YMWMG6tSpg/r167PXg/7GtaRSqXD58mWo1Wr8/vvvGDduHIKDg00eY0ZGBk6ePAk+n4+2bduaHEfU6XS4efMm8vPzIRKJ4Ofn90LVXSJCVFQU1q9fj8LCQgDApEmTEBAQUCNv6OHDh9i3bx8aNGiAoUOHPnfrL5VKsWbNGly/fh1isRgNGjSo8QNFp9Phzp07OHjwIDv3fHx8YGlpCQcHB0ilUhw8eBAPHjzAqlWrsGLFCqM16ACwBv29995DTEwMsrKyQETw8PBAy5Yt0aNHDwQFBXFKM8yZIbK0tESbNm1Qr149xMbG4v79+2jWrBn27NmDjRs3snzPmzZtQqdOnWpkiHg8HmxtbfH+++9Dr9ez/NUvutB2dnbo0qULtm7dioqKCqSnp9fINaa/juxv37791HuNGjVCr169qi2iu3fvspruXEAulyMtLQ0A0LhxY5MMEY/HQ7169fDVV1/hnXfeQWVlJWJiYlBZWfnc7yQlJaGwsBACgQBTpkxB3bp1Td5qqtVqJCUlobi4GAMHDuQkTsUwTLWAc1VVFbRa7Quf2jExMXj48CF0Oh2cnJzw7rvv1sjAKpVK/PDDDygvL8ewYcMQGBj4zM9ptVocOXIEe/bsQatWrTB16lSj8uksLCzQvn17LFy4EPb29ujZsyfEYjH4fD4EAgH0ej3q1auHRYsW4ciRI5g2bRrc3d2NNkQCgQD+/v5YvXo1ysrKAADl5eW4c+cOrl27hnPnzmHAgAEYOXIkZ1LrnBkigUCAoKAgDB06FCtWrMDGjRvh4uKC48ePQyAQYMiQIYiKikJGRoZReSkGYnkejwedTvdSF1kkEhm9eLRaLRITE1FeXl4t5lWnTh0MGjQITZs2BZ/PZ4PZGzduRHl5OVq1asVJ/KWqqgq5ubkAgKZNm5p8w/l8Pjw8PDBw4EAwDIPIyMgX3odff/0VK1euhFQqxaBBg1C3bl2TYwRyuRxxcXFwcXHB4MGDnysiWRMY4l/A44fP83KSdDodsrOzsWfPHuzfvx8ymQyurq4YOXIk/P39azQ2jUaDqKgouLq6PvfEz2CEVq5ciWbNmmHZsmUsA0VNIRAIUK9ePXzwwQfg8XhPGTMigkgkYoujuTgoEolE8Pb2hre3N4DHO562bdsiMjIShw4dwq5duyAQCDBq1ChO5junIXCpVIrY2Fio1WqcPn0anp6eiIyMxKBBgxAfH4/r16+b1L5arcaBAwdQUlKCqVOn/uMFyM/PN1puWqfTsYHiJ41ZvXr14OTkhJSUFMTFxeH8+fO4dOkSiouL0aJFC/z444+ws7Mz2XuQSqVsIiNX6hMGTxLAP3qk3t7eEAqFCAgIgJ2dnclGiGEYpKens8muXB1h6/V6HDhwAMDjLbOfnx/0ej0sLCyg0WiQlZWFEydOICEhAcnJybh37x6kUilcXV2xbt06vPPOOzU+USUiaLVaeHl5oX79+k+9L5fL8fvvv+O7776DhYUFlixZYvJJFp/Pf+bv1Gg0+Pnnn7Fq1SoUFRVh7NixnGyh/w6BQACxWAw/Pz+MHz8eFy9exJ07dzB06NB/nyESi8Vo164dEhMTkZqaipycHBw+fBgWFhbIy8tj822MhSEeEB0djY4dO6Jt27bP/WxcXBzWrl2LoqIi1K9fv8bxIUtLS/Tu3Rs//fQTsrOzATxeyBkZGViyZAksLS0hlUohkUhgZWWFefPmYdy4cZwtsJycHFy/fh2NGjWCj4+Pye0Zi/z8fE4yq9VqNWJiYpCSkoLw8HC21MJUCAQC9OnTBz///DMKCwsxf/58tG7dGnXq1IFcLsfDhw+RmJgIhULBchCNHDkSkydPRqtWrWBlZWX0Q0MoFFbzcOivMqD//e9/OHDgAFQqFVatWsVpKYQBOp0Ot2/fxu7du3HmzBlkZWUhPDwc8+fPh7Ozs9kI+gwemY2NDbeUN1xmR+r1epLL5fTLL7+wqqR8Pp/s7OxILBaTQCCgoKAgKioqMqp9hUJBK1euJCsrKwoJCaEtW7aQUqms9pn8/Hw6dOgQhYeHsxXK165dMyrLWiaT0YoVK8ja2pqt9je83NzcKDIykjZv3kwZGRkkl8s5FZ87fvw4AaDWrVtTXFwcZ+2+LPbv308+Pj4kFos5qb5/UsU2IiKC0tPTOfiVj+dcbGws+fr6svfI2tqaxGIxWVtbk4WFBfH5fHJycqJx48bRr7/+SoWFhSYVa5aUlJC3tzd5eXnRtm3bqLy8nGJjY2n27NnUqFEjEovF5OHhQTt27OBcmlmr1VJ2djatXLmSWrZsycpBu7q60pEjR0zKgNfr9VRVVUUSieS5c5lhGEpPT6du3brR7t27n1p/xsIsNCDFxcX0zTffUHh4OHXq1IlcXV1Zo7Rw4UKj08/1ej1lZmZSZGQkCQQCcnZ2ppYtW1Lbtm2pXbt21K5dOwoMDCRnZ2cSCoUUGBhIGzZsMLryn2EYkslkdOPGDRozZgwJhUIaO3Ys3bx5k7Kzs0kqlZpFfpfov2eIDHQmXbt2JTs7O5o+fToVFBRw8EsfK8nGxcXRtGnTyM3N7anX0KFDKSoqiqRSKWk0GpPvl0wmo08//ZQEAgE5ODiQt7c3ubq6krW1NVlbW9PkyZM5k2aWy+W0f/9+SkxMpPT0dFq7di21a9eO7OzsyMLCghwdHWnMmDF09epVk2WntVotxcTEUOPGjalfv370xRdf0C+//EIxMTEUGxtLJSUldOPGDerRoweFhoZyyspgFkNkIHBSKpWkVCqrSRqbenP0ej2VlJTQihUryMfHp5qX8iQfEZ/Pp2XLlpFUKjX5Yul0OlKpVCSXy0mlUpFOpzO71PXrNkRXrlyh4OBgzgwR0ePrWFxcTBs3bqTIyEi6efMmJ+0SVZfP/vuLa1lmhmEoPz+f+vTpU43uIyIigm7evMmpNHNlZSVFRESwWve2trZkYWFBXl5eNG/ePLp79y5JpVLOxqdWqyk1NZXWr19P06ZNo5EjR1KfPn0oNDSUXF1dyd3dnZXT5nIH8EbKCdHfaCw3bdqEY8eOoaKiAh4eHoiMjMTUqVPh5+dn0snZ60RpaSkWLlwIT09PzJkzxyz1PS+CTCbD9OnTkZ6ejkOHDplMP2IAEYFhGDAM80aLKNBfdK1PpoQYjtO5HJNer0dCQgIiIyORmpoKAOjYsSOWLl2K0NBQWFpacn4Nn7xHhv9/8r98Pp9zoYg30hA9CcNFe3IY5tIFf5UwjMswltcBQzDyTb+WbzoMD14D/gvz++944w1RLWpRizcfb6ZfXIta1OI/hVpDVIta1OK1o9YQ1aIWtXjteCWS07WoRS24BT1OvWEPat7kE0ig1iOqxUtCr9cbXbf3/yOICBqNBlqtlnOiQIZhkJqaii1btmDkyJEIDAzE77//Xo0q+U1DrSH6F8NwbKvX66vpjyuVSsjlcrPJJf8dOp0Oly9fxqRJk6BSqcze35sOIkJhYSHGjBmDNWvWQKFQcNp2ZmYmPv/8c3z44Ye4fPkyOnbsiL179yIvL4+zfvR6PdRqNRQKBWQyGeRyuVnlx2u3ZjWEwTjodDo2t8NgKAwaWlwkUWq1WlRUVCA7OxsqlQpisRgPHjzAw4cPceXKFcTHx2Py5MlYuHAhHB0dzZZTQkQoKCjApEmTWCP4qpMr3zRUVlZi4cKFOHToEIYPH86JVBLwfyIB+/btw6lTp2BpaYmePXti8eLFUCgUqFu3Lif9aDQaJCQkYMeOHTh+/DiysrJgZWWFuXPnYvr06XB0dOR8G2iSIaK/6BDUajVLZC8SiSAWi6uxt6nVauj1eiiVSvB4PM7YDHU6HdRqNbRaLRiGYY3A38UV9Xo95HI5bGxsjK6CNmTSSiQSJCQk4MqVK3jw4AEYhsG1a9dQWFgIV1dXfPXVVxg7dqzRi1Wn00EqlSIqKgpLlixBbGwsm+FqaWkJOzs7yGQy6PV6rF+/Hl5eXpgxYwanbHlPQqFQYN26dZBIJBgzZozZddz+CygoKEBaWhosLS1Rp04dzh4SOp0OV69exbJly6DT6TBw4EB8/vnnL6T8NaaPhIQEzJw5E3l5ebCwsIBYLIZcLsfq1auh0+kwZ84clpmUM5hSH6JWq+nUqVM0btw4AkAAKDg4mA4dOkTFxcVUUVFB5eXltH//fvr000/Jz8+PQkJCqLi42JRuSa/Xk1QqpaioKJo1axb179+fwsLC6PPPP6ekpKRq+mIMw9DDhw8pIiKCCgoKjKoR02q1VFFRQVevXqXRo0eTvb09ubm5UUBAAPn7+5ODgwNb5e3u7k5RUVFG1f5oNBq6ffs29ezZk2xsbEgkEpGXlxcFBgZSu3btaMqUKbRjxw6aPn06DR8+nOzs7MjKysrocRnAMMwzv88wDJ07d468vb2pXbt2VFpaanKNnaEvw0ur1ZJWq30l9XuvCvHx8dSpUyfq0aMHZWVlcTauqqoqWrZsGfF4POrQoQPdunWL03ovw/wLDQ2l4cOH08OHD+nRo0c0evRoVi9wwoQJRrNnvAgmeURqtRqfffYZSyAGAImJiZg6dSoaNGgAX19f6PV6XLx4EaWlpdW+Zyx0Oh0yMjKwc+dO7Nq1CyqVCsOHD0ejRo1w7NgxlJeXo1+/fggKCoKTkxPKy8sxbdo03L9/3ygvzFDPtnv3buzduxdEhC5duuD9999H48aNodVqcenSJfz000/Iy8tDcXExtm3bhtDQ0Br1p9fr8ejRIyxYsAC3b9+Gq6srmjdvjmHDhiEgIADu7u7w9PSEhYUFxo4dC61Wi9DQUDx8+BBZWVlwdXU16smr0WhQWFgIhmHg5eVVjWLV8BQsKCjAzJkzjdKHo7+2skqlElKpFFVVVdXuv0QigVarhY2NDaytreHs7AxnZ2dYW1ubpEWn0WhYT9IQ76An4hsCgQCWlpbsf7nyWgz6cbm5uazUOldtG9RWHR0dMWDAAAQHB3PmCRn0+z766CMEBQXh66+/hp+fHyorKxEUFMRyY5sLJm/NnhWIKy4uRnFxMaKjo01p/ikYBOWWLFmCGzduIDg4GO3bt8eMGTPg4eGBfv36Ye3atRg8eDAaN26MNm3a4Pz580hNTcWwYcNqzJyoUqlw9uxZLF68GNnZ2WjevDn69++PoUOHwsXFhZ0EQUFBiIqKQn5+PkJDQzFt2rQabwGVSiX27duH+Ph4DB8+HO+88w5atGgBT0/Pp/iXDUZLKpWibt26LK9wTWC4d7du3cLKlSvh7++Pr776iuXGZhgGcXFxSE1NRYMGDRAREfFS6g1EhIqKCuj1elRVVUGhUKCkpITliS4vLwfDMKhTp041wn7DvwMCAtCxY0e0aNEC7u7uL3UdiQgqlQoqlQoVFRXIzc3Fo0ePIJfLYWFhAYlE8hQ/t4ODAxo2bAiRSISgoCC4u7tzIgFVVVWFU6dOITMzE507d+aM05lhGFRWVrJMoH369OF0m6zVanH69GlIJBLMnz8ffn5+yMnJwQ8//IB79+6ha9euiImJYdMGuIZJhsjS0hLTp0/HjBkzuPo9z4VOp0NMTAwGDRoEqVSK9957DwsXLmSpTAUCAdq2bYvFixejYcOGuHHjBg4ePIiqqiq4ublh4sSJLy2DQkRQKpU4ffo0PvjgA1hYWGDixIn44IMP4OPjU83TqaysxI4dOxAfH4+goCCsXr0aISEhNfa+DIbBwcEB/fv3R3h4+DM/p1arERcXh3Xr1qGyshKzZs1CeHh4jZ6MBsWVAwcO4Pjx46hTpw769evHciHTX7JJ69atQ3FxMf73v//Bw8PjpfrQarX48ssvwTAM8vPzodVq4e3tDU9PT/Ts2RONGjWCh4fHcxdoeXk5UlJSsGfPHrRr1w6dOnV6br8Go5eRkYHr168jNzcXmZmZqKysZDX2HB0d4e7ujhYtWjxTKTcvLw/Xrl0Dn8/HkiVLTGJSJCIkJSXh1q1bAIC6detyRtmqUChw5MgRPHz4EK6urpy0+SQ0Gg127NgBe3t7uLu7IyUlBZs2bUJ2dja+/fZb6PV6fPzxx5z3a4BJhkgoFKJ3797IyclBTk4OK8/yJFxcXJCTk4N79+5BqVQa3Zder0dcXBwYhkGHDh0wbdq0pxY8j8dDw4YN8emnnyImJgYrVqyAk5MTunbtWiM9KY1Gg1OnTmHOnDmwsbHB1KlTMWHChGoTQK/Xo6SkBDt27MD69etRXl6OxYsXo2XLlkZNZoFAAE9PTwBgqWmfBBGhvLwcV65cwTfffIOkpCSEhITggw8+qFGgmmEYFBcX45tvvsGJEycQERGBmTNnVpPTUavV2Lt3L6Kjo9GtWzf079//pftgGAY//fQTxo4di759+yIwMBBNmzaFg4PDSxkysVgMb29vlJSUYPLkybh///5zT510Oh2+//57pKenQygUwt/fHyNGjECTJk1gb28PPp8Pa2vrFx4cMAyDY8eO4csvv8TXX3/9UmN8UVsPHz5EamoqnJycTJI6/zukUinOnz//1N8VCgWys7OreXwODg4ICAio0Wkdj8eDk5MTCgoK2Ic4EWHBggVo0aIFUlNT2cC7OU5oTTJEfD4fAQEBWLp0KUpLS5+5RbC3t0dycjJmz56NuLg4o/sSCoXo1asXioqK0K9fvxd6HVVVVYiOjoa1tTXmzJmDxo0bv/RNYRgGaWlpWLRoESQSCT766CPMmDGjmrcgk8nw4MED/PLLL6zCaFhYWI312p6ESCRC7969cevWLVy+fBn9+/dHnTp1wOfzWQWKzZs3Y8+ePRAKhZgwYQIGDx4MFxeXGk0MtVqNkydP4uTJk5g4cSKmTp1aTU1Dp9Ph7t27OHjwIOrWrYuZM2fWeAvg6emJiRMnomXLlkbHMPLy8hAaGvqPY/Pw8EDfvn0REBAAe3v7Gl1/g1T1iRMnMGfOHJO9F7VajfT0dMhkMgwfPrzG6iD/9FufDINotVoUFBTgyJEj2L9/P9LT09n3/Pz8sHTpUrRt2/alH4qWlpaYMmUKJkyYgKVLl6KwsJB9sAoEAtStWxdeXl6cjOWZ4Dz8/QycOXOG6tevTwDI29vbaIpQtVpNhYWFLzwpkEgktHbtWmratClt3769xpy6arWaVq9eTXw+n4KCgig2Npb0ej0plUrKzMykc+fO0ZdffklhYWEslzWfzzeqr79DpVLRyZMnKTw8nJYtW0YPHz6klJQUOnnyJA0dOpQcHBzIw8ODli9fTkVFRTU+MTFQ7Xbp0oVGjx5NhYWF1d5nGIaSk5Np2LBh5OjoSGvXrq0xra9Go6GPP/6Y5s6dazRrYEFBAfXp04fi4uL+cYw14Z6Wy+VUUlJCxcXFVFhYSBcuXKAePXrQtm3bjKYTNoBhGHrw4AG999575OzsTPv37zeJP/rvyM7OptDQUOLxeNS4cWNasmQJTZ8+ndzd3cnGxobCwsJo9OjR5OrqSjwej/r3709lZWUvfWLHMAyVlZXR7NmzKTAwkGxtbWn48OF04cIFyszMpIqKCvryyy9p+PDhlJOTw9m4DDB7QmNJSQl27tzJigV27drVaPkRkUgENze3575veNpv3boVb7/9Nvr27WtUfk1FRQWAx/GKn376CXXr1mUFD+Pj4yGVSlGnTh1YWVlBq9WiX79+6NGjh8m5PCKRCJ06dcKDBw+wZs0aXL16FQKBAImJicjOzoanpyc+/fRTDBo0CE5OTjV+2hIR8vLyEBsbi65duz7FulhRUYGtW7eyyXL+/v413mYKBAJMnDgRkydPRlFREbvdfFnI5XL21LFRo0b/OMbn/T76K+aWkZGBwsJCFBQUIDk5GUVFRWzeWUJCArKzsznJw1IqlTh79ixu3LiB0NDQ5+qrGQtra2s0atQId+/eRWZmJjZs2MAG4ydPnowRI0bAzc0NGRkZKCkpQVJSEuRy+TPjYs8Cj8eDg4MDvvzyS/Tu3RsnT55EbGwsPvnkEwQFBcHLywtxcXEoLi42y+mZ2Q3RmTNn2L3te++9V22bwyUYhsGdO3ewbt06tGrVCjNnzjQq45jP56N169bw8PBAQUEBNm7cyL4nFosRHh6O/v37Izc3F9u2bQOPx8P06dONPj5/EgbdMXd3dxQXF+OPP/5g32vevDk++eQTDBgwALa2tkb3IRQKwTAMa2yeDBonJibi999/h1QqhbW1NQ4cOIC2bdvWSOWVz+fDz88Pbdq0wenTpzFu3LiXNpgqlQpHjx6FSCTCuHHjaqyxTn+dnqWnp+PGjRuIi4tDbm4u7O3t4efnBycnJ1y9ehXx8fHo06cPvvzySzg4OMDX19fke1dSUoLr16+jqqoKdevW5fTYHgBsbGwQFhaGX3/9FUqlEkqlEp06dcLUqVPRvXt3ODo64tGjR2ysqEGDBjU+BeTz+bC3t0fnzp3RsmVLZGVlIS4uDvHx8Th58iRSU1MhFotx7949+Pn5mZRi8XeY1RApFArcuXOHzSF677330Lhx4xpPsJdBRkYG1q5dC0dHR8yYMQN+fn5G7fkFAgG6du2KEydOID8/Hzdv3oS3tzd71Ovu7g6ZTIYrV66gtLQUvXr1QsOGDTnRrVIoFDh+/DjWr18PoLqw4/vvv4/333/fpCNbQ0xv5MiR2LJlCxISEqrdC8MRuK+vL/r06cMavZpONisrK8yaNQuxsbHQ6XQv5Rno9Xrs378fly9fxqJFi176lM4AQxB+8+bNiI2NhZOTE5o0aYLIyEhYWFjgzp07SElJQaNGjfDBBx+gU6dO8PDw4OS+MQyD0tJSllO6WbNmJkmEPwtCoRANGzaEg4MDeyoYERGBfv36sTuM1NRUSCQSAMCYMWOM3nkIBAI4ODigTp06aNiwIfr27Ytu3bph6dKluHPnDlauXImysjKMGDGCk5QHAOaNEZ08eZI8PT0JAAUEBFB8fDynmaAGVFRU0IIFC8jOzo5Wr15t8n7fAK1WS1KplM3UZhiGdDodHTx4kLy8vMjR0ZF++eUXTrSdVCoVHTt2jPz9/UkoFJK3tzf169ePOnbsSDY2NhQZGcmJcoJOp6OCggI6ePAgLV68mMaOHUsBAQHE4/FILBbT6NGjKTo6msrLy43SgjNAr9eTTCZ7qd+r1WrpyJEjNGbMGDp+/Dip1eoa9yeXy2nJkiUUGhpKu3btopSUFLp+/Tpt2LCBRo8eTdOmTaNTp05RdnZ2tcx7LqBWq2nPnj1ka2tLDg4OdPLkSc6zxBmGoUePHlFYWBjxeDxq3bo13bhxg+1Hr9fTli1bWAklrlU2VCoVbdiwgdzc3EggEJCXlxcNHjyYYmNjTdKIM8BshighIYHCw8PZ0o9FixaRVCrlvB+VSkX79+8nPz8/6t27Nz169MispQIFBQU0adIkEgqFNGLECMrOzuakv5KSEuratSsJBALq3Lkz/fnnn1RcXEyJiYk0ZswYcnZ2ppUrV1JVVZXJfRnknqqqqig1NZUmT55MPB6PBg0aRImJiZxMrJeFXq+nkydPUsuWLWnDhg1GyT8xDEN5eXkUFBREnp6eNHHiRIqMjKQePXrQxx9/TGfOnKG8vDxSqVRmmRsymYyWL19OfD6fevbsScnJyZz3QUSUlZVF4eHhxOPxyN3dndasWUNZWVmUm5tLZ8+epc6dO5NQKKShQ4eSRCLhvH+DLl3fvn2padOmZGVlRYMHD6bKykqT2zaLISoqKqIPP/yQRCIRAaDAwEC6e/cu596QSqWiQ4cOkb+/P4WEhNDp06c5Pan4O9RqNW3bto0cHByoU6dOdO3aNaOe3s9CXl4eubq6UmBgIB07doz1RnQ6Hd26dYs6dOhAISEhlJyczNliMpz0tGvXjlxcXGjXrl0meUHGICMjgwYOHEizZ8+m4uJio8emVCrp/PnzNG/ePJo9ezZt3bqVkpKSqLKy0mwimAZkZmZS3759SSgU0qJFi4wWEP0n5OXlUUREBPF4PFZtuGnTptSsWTPy9vYmkUhEPB6P5s2bRwqFgvP+s7OzKSIigoYMGUIxMTE0depUcnV1pc2bN5u8DsxiiOLi4igkJITdkl24cIHzCa7T6ejGjRsUFhZGvXv3pmvXrpntiUf0+Fj64sWLFBQUREKhkBYvXszpUyc3N5ecnZ3ZY9cncefOHWrXrh2JRCJau3YtJ1tPnU5Hjx49omHDhpGNjQ3NnTvXLB7ri5CZmUkTJ06kuXPnUm5urkkPKoZhSKPRkFwuJ5lMRiqVyixhgGchOTmZOnXqRBYWFtS3b1+zeURKpZJ++eUXcnBwIKFQWE3c0fDq2bMnZWZmmmXsSqWSli5dSj4+PrRnzx5avXo1ubu709dff22yA8B5sDo1NRVz5szBgwcPAACDBg1CaGgopwFqjUaDuLg4rF69Gnl5eRg3bhwrNmcuKJVKXLx4EWlpaRg1ahQmTpzIWR0RANja2mLAgAE4e/YsVq1ahWbNmgF4fD1PnDiBe/fuAXh8jMtFkpxCocC+fftw5MgRhIeHY/z48SadxtUUeXl5+P7772FhYYFp06bVODj9d/B4PAiFQrMchPwTBAIBrKyswOPxcOXKFaSlpSEwMJDzfiwtLTFo0CC8/fbbuHv3LtLT0/Ho0SPY2trCy8sLAoEAgwYNgqurq1loYy0tLTFs2DBcvXoVc+bMAY/HQ3l5OTfrjiNjSUSPLeamTZtIIBAQAFq5cqVZ3OKKigqaPn06OTk50ccff8wJPcWLoNfr6e7du9S4cWOytbWlVatWUWZmJpWUlHAWT9FoNHT16lVq0aIF2djYkL29Pdnb25NYLCahUEh8Pp+GDRtGeXl5nIxVJpPRd999R8HBwXT+/PlX5j0QPb5/y5Yto2nTplFqauor7dsc0Ov1lJ2dTd999x2dO3fO7DE2A32KRqMhlUpFarWaNBoNaTQas1OpaLVa2rZtG3l5eRGfzycXFxdKT083uV9ODVFJSQlNnjyZAFD37t0pMTGRy+aJ6LGx27p1K7m4uFCHDh3MEnv6O8rLy2nWrFkkEAjI39+f2rZtS2PGjKGMjAxO+1EqlXT8+HFq0aIF8fl8EggE1LhxY/rmm28oNjaWKisrOdM4N0xmtVr9yg3B5cuX6YsvvqCcnJz/DAeR4Xq+6Ub1ZaBSqWjmzJnUrVs32rp1KyenxpwZIqVSSTt37iQ+n0/e3t505MgRsxxhZmZmUkBAAEVERFB2dvYrufFlZWU0bdo0tpzD09OTDh8+bJbArl6vZ8nCDC+9Xv+fWbBEjwm+jDkdq8W/BzqdjnQ6HWfrj9MYkU6nA8MwqF+/Pho0aMBpZin9RU0xfvx4jBs3DmPGjIG3tzdn7b8ITk5OWL9+PdatW8f+zVxVyHw+/42WhXkZvMpYVC3MA67oTQzgEXHLckRPkF2ZA0RktrZrUYtavB5wbohqUYta1KKm+E/LCdETtJb/9e3Om4Ann3m1Xq35YODqfpPm/JvzS2uIyspKrF27Fj4+Ppg4caJJ7JC1MB0qlQoZGRnYvHkztm/fjoqKCuh0utf9s/5zYBgGM2fORFBQEEpKSl6JACcX+E96RFKpFPPmzcMvv/wCImJZ5owB/aVnZhBTBKqTvT/5bz6fz2qQ1z7x/w8qlQpHjhzBrFmzUFpaCj6fj3v37mHx4sWcV6n/m6DT6aDT6cDn8yEUCo2aE/SXdiCfz/9HpgCGYbBv3z4cOnQIVlZWb4wRAl6BR0RErEKowWU0J9RqNX788Uf8/vvv4PF4LN+0MSRVRITS0lLMnj0bNjY2sLGxQVBQEFq1agUnJyc0bNgQLVq0gJOTE6ytrTFq1CgcPXoUpaWlb9QkMCeICCUlJdi9e7dRaiPmglarNeucZBgGe/bsQUBAAD788ENUVVUZ1Q6Px2Mfbv/UX0JCAr777jtUVVVhw4YNcHJyMvsDUaPRcCNFzUkSwDOg0+lIpVJRRUUFTZs2jXr37m0WisknYajEN9BazJs3r0Z0mX+HTCajxYsXs+KJIpGIxGLxUy8rKysSCARsntGuXbteaQW7KdDpdKRQKEgqlVJFRQVVVFRQZWUlyeVyUiqVJueJKBQK2rx5M7m7u5OFhQVZWVmRh4cHLV68mCoqKrgZhBH49ddfKSwszGSxz+ehsLCQxo8fTzY2NiQQCCg3N9cs/RA9voepqanUqVMnEovFnNUj/hO0Wi19/fXXtHHjxn9PrRn9xY4nl8uh0WiQl5eH27dv488//8SVK1fQqlUrs1pnjUaD06dP47PPPkNGRgYCAgIwcOBAkyR/DVpSRASxWIzOnTujSZMmT32uuLgYSUlJbBzqrbfe+tcHCukvT/X+/fvYu3cvzpw5g8TERACP69mGDRuGwMBA9OvXDwEBAUbXE+l0OiQnJ7NbsjZt2mDx4sVo27at0UIDpkKpVOLcuXMoKioyS/sajQY3btzAtWvXoFQqzaIVb4Ber0dKSgrmzp2LR48eYdasWRg7dqxZWFCfBBHhzp07+PnnnzF37lzT1zYHhpGIHnsPP/zwA/n4+JCtrS05OTmRq6srNWrUiCZOnEjJycmclSf8HSqViv7880/q1KkT8Xg88vf3p6ioKJO9Ep1OR9HR0WRra0sdOnSg2NjYZ35Oo9GQTCYjqVRKUqn0jUjz12q1dOHCBbK1tWU9uWe97OzsTCK0k0ql9Mknn5BAICBnZ2fatGkTxyOpOS5evEj+/v40cuRITvid/o579+5R586dWS953rx5nPfDMAzJ5XJKSkqiyMhIEovFtGzZMrOM51koLi6mfv36UaNGjTipf+TMI6qqqsLRo0dRUVGB9957D61bt4arqyvCwsLQoEEDsz39dDod4uPj8fnnnyMqKgoBAQFYvnw5WrVqZTINqEAggKurK6ysrCASiZ4bZzJH1TfDMFCpVJDJZGAYBtbW1mzA3cA7zePxoNPpYGlpCZ1OV2NqUJFIBEdHR3ZcarUaKpWq2n5fJBIZPTb6y+uSyWTVAvmvGoaDBoFAACJCbGwsVCoVmjVrxglV7JPQ6XR49OgRsrOz2fSRwMBAzvuRSqX46aefsGbNGpSXl2PQoEGvjEFBo9Fg3bp1uHz5MubOnctJLIqzq6PX6yGTydCsWTN88cUXCAkJMXugTK/XIycnB5s2bUJ0dDRcXV1ZFQKuDZ8hKAeAVYEQCoVmWVh6vR75+fk4cuQIrly5ArlcjkaNGrGKDP7+/pDL5RAKhSgsLETLli2RnZ2Nzp07Izg4+KWuu0AgQJMmTfDdd98hJycHwP9RjhiEMgUCAXr27Ak3NzejxmlYlNeuXavxd7mAwZinpKTA2toa/v7+kEgkiIqKgo+PDyIjIzlV2jBsQw8fPozi4mIAj/m7xWIxp2tBpVJh//79WLp0KRQKBYYOHYoFCxbA2dmZsz6ehFqtBgB2e56ZmYnz58/Dx8cH48eP52StcWaIdDodCgsLERAQACsrK0ilUpSXl0MikcDKygqOjo5wcnIyyXOgv44yRSIRiAhFRUVYs2YNDh8+DHt7e4wZMwa9evUymjT8RcjNzcWJEyegUqmQl5cHmUwGX19f9iZYWlrCx8fHpHgA/SXeGBcXh2PHjuHo0aPIycmBVqvF+fPnWa/iyc/zeDx4eHggNDQURUVFWLhw4Uv1xePx4OjoiKFDh7J/y8nJgUQiwYEDBwAAPXv2xODBg42ONzAMg9TUVKSkpDzz/fLycuTn57P5RD4+Pi+tCPtPUCgUSExMxNWrV7Fv3z74+/tj+fLluHPnDu7evYvRo0cbbWCfh9LSUnz//ff47bff2HvTs2dPk9JH/g6NRoObN29i06ZNUKlUiIiIwMKFC+Hr68tJ+3+HQqHAzZs34ejoiObNm0OtVmPfvn3Iz8/H2rVrOUu/4MQQMQyDkpISFBQUwMfHBzExMUhMTER8fDwSEhLg5OSENm3asIlWxrqpRAS9Xg8iglQqxfbt2/Hjjz/Czs4Oo0ePxocffgilUomYmBiIxWL4+vpy9jTKzc3FN998g+XLl0Or1YKIquWGODg4IDIyElOnTkX9+vVrPEaDCsXPP/+M9evXo2nTppg7dy5KS0uRn58PCwsLODg4wNLS8qnF06xZMzRr1gxubm4mjVUsFrNkbwKBAB9//DHeeusto+8XwzCQy+XsVk+v10Mul6OsrAxpaWlskFypVILH46Ffv3546623YGVlBU9PTzRs2BBWVlY1WsQMw6CqqgonTpzA0qVLkZKSgrCwMAQEBECtViMvLw9CoRDdunXjlEhPrVbjypUruHjxIoDHhr59+/b44osv0KBBA862Znl5eVizZg0ePnyIAQMG4MsvvzRr8XdqaiqWLl2KYcOGoUmTJoiPj8fRo0fRuXNndOjQgTuP0qQI019Qq9W0f/9+4vF45OzsTH5+fmRvb08dO3akadOm0dChQ8nd3Z3Gjx9v8pEtwzAkk8not99+Y1Uup06dSvfv36eoqCgaNWoUBQQEULt27WjPnj0mc/caVEft7e3Jy8uL2rVrR0OHDqWwsDDy9vYmb29v8vT0JJFIREKhkPr3708JCQk1Du7K5XJatWoVOTo6Eo/Ho65du9K5c+coMTGREhMTqbKykrRarVmpM8rKymjixIkslYsplKcMw1BxcTFNmjSJBAIBCQQCsrGxod69e9P06dOpfv36bDDX8L7hxePxqGnTpvT111/XSJyAYRiSSCS0bt068vX1JW9vb5oyZQrdunWL1Go1yWQy+vDDD6l169acH6dnZGRQREREtUD/8uXLOeWvViqVtHnzZhKJRBQWFkZXr141W5qITqej/Px8+vTTT6lFixb0559/klQqpXnz5pGrqyudPXuWUxocTsy0Xq9n4wpSqRQ+Pj6s8Ju/vz9KSkowffp0nDx5EosWLYKDg4PRfanValy6dAlr1qxhdcUiIiIQExODrVu3Ii4uDmq1GhkZGZDL5fD390ebNm2MfiI5Ojpi8eLFuHv3LurVqwdXV1fUrVsXxcXFrF6bTqfDzZs3sW3bNhw7dgw9e/ZEYGBgjXW5KioqWF2qqKgozJgxAwEBAahfvz6mTp2KwMBAs8bdDOkXANC5c2fY29ub1J5AIIBYLGavg0ajwZkzZ9j/5/P5EIlECA0Nhbu7OwDg+vXrKCgoQFJSEr755hvY2dlh6tSpL+W9qNVqnDp1CmvXroWFhQVmz56NiIgIODs7g8fj4fr167h69SpCQkI43b5LJBLs2bMHly9fZv/m4+PDKUWyVqtFfHw89uzZg3r16mHixInw9fVFSUkJKySalJQEGxsb+Pn5mdSvWq1GXFwcO5+tra1ZFdsTJ04gPDwcTZo04TQAz0lLOp0OqampsLCwwLvvvovPP/8cISEhrNqltbU1GjRogBs3bqCoqIjl1zWmH0NpwN27d9G0aVP06dMHt2/fxubNm6HRaNCkSRM0a9YMSUlJiIuLw4kTJ9CiRQujL5qlpSVatmyJ5s2bV7u5Pj4+7L+JCG+//TaKioqwZ88eo/qxsrLC6NGjwefzUVhYiLy8PKSlpeHWrVu4ePEiSkpKsGTJEvj5+ZktQG7YTltZWaFbt26oU6eO0e3xeDyIxWK0aNHiqfc8PT3x9ttvw93dHTY2NujRowcrJX7u3DnExsbi119/hUKhwM6dOzFq1Kh/NERarRYxMTH47rvvQERYuHAhBg4cCI1GgwcPHiApKQmbN2/Go0eP0LdvX84NxO7du1mpcgDo378/WrVqxdnWRSaT4eeff8bDhw/x7rvvoqKiAitWrIBEIoGHhwcEAgGio6Ph4eGB9evX10id90kY1HYN27/w8HC0bt0aCQkJuHjxIuRyOT799FOIxWJuKXm4cKuqqqroq6++or59+9KVK1eeyhfS6/W0dOlScnBwoKNHjxotPSKVSmnGjBnE4/HIx8eHVq9eTbt27SJ/f3/q27cvnT59mh48eEAFBQV06NAh8vX1pdGjR7+y3IodO3aQs7Mzbd68+aVdZoOw4s2bN1mtseLiYkpLS6PY2FjatWsXhYWFkZWVFc2bN48TDalnIS0tjYYOHUpWVlb03nvvUUpKisnbQK1WS/fu3aOuXbuSUCgkCwsLEggE1L17d4qOjqbKykqSSCTVrpVcLqdHjx6Rt7c3CYVCEgqFlJeX98J+GIahgoIC6ty5Mzk7O9OsWbPozJkztGzZMpowYQJ17tyZBg4cSPXr1yc+n0+//PILJ7JTGo2Gbt26Rd26dSNra2t2S9a3b1968OABZ9smtVpNZ86cIU9PT3J3d6euXbuSj48Pq9zB5/PJ39+f7OzsyMrKinbt2mX0+MrLyykyMpKcnJxo1qxZlJqaSuXl5fTNN9+QjY0N2dnZ0cCBA+n69eucSWkRcbQ1s7KywuTJk6FWq+Hm5vaUt6PX61FeXg69Xg97e3ujj4Jv376NAwcOQCwWIyIiAj179sSGDRtQp04dzJgxA507d4ZQKIRWq0VqaiqqqqpMCo7XFLm5uTWuKGcYBlFRUbhy5QpGjhyJ4cOHo27duqhbty4AoFGjRigpKUFqaioOHjyIyZMnm7xlehZSUlJw6dIlaDQaNG3aFC4uLqbnhlhYwNfXFx06dMDNmzehUqkAPNZxd3FxeeY4eDwe+Hw+GIYBwzBYuHDhP57MGLbGUVFREIlEuHz5MqKjo5GSkoLQ0FD07dsX7dq1w/bt25GTkwM/Pz9O5oRcLseOHTvYALUBDRs2RL169Tibd1qtFlFRUdDpdOjUqROysrKg1WoxevRodO7cGV5eXnBzc4NUKsXMmTNx+PBhDBgwwKhgvI2NDebMmYMBAwage/fucHFxQUZGBu7fvw9HR0fMmjULYWFhRh3IvAictGRhYcHu8Z8FnU6HkpISCAQCeHp6GrUt02q1OHLkCAoLC+Hn54d3330Xtra2qKioQO/evdGuXTsIhULWtdy+fTtcXFwwcODAGrvHRMTmDNXkZj569KjGdCNCoRCDBg3CnTt38M033+DSpUvsNsWABw8eQKVSQalUVmMB4BIqlYrNF7GysuJs+ycWizFkyBBcvnwZN27cAPD4mPvhw4cAHm/TxGIx5HI5SktLsX37dty6dQsVFRXg8Xh4++23//Ee8Hg8ODg4sHlD8fHxCAwMxLfffosePXrA1dUV5eXlUCgUCA4O5uTYXqPR4M8//8T+/fvZLQoRoWvXrhg0aBCnJRYMw0ChUKBBgwbo168foqOjMXjwYIwdOxZ2dnZsPltBQQGsrKzQoEEDo9MFLC0tERoaipCQEFhZWYFhGNy6dQtnz55Fr169MGTIEHh5eXFOlfxKXAWGYVg6BJFIZDQdgmEPbmlpCTs7Ozg4OGDatGlwd3eHTqfDkSNHcOzYMVy6dAlFRUVYv359jWMqRIS8vDx89tlnEAgEGDt2LMLCwv5xYlVWViIrKwt6vR6hoaEv3aeFhQWaNm2Kb7/9FhMmTMCpU6fYFAXDdTJkVo8aNQqurq4vPZaXRUVFBa5evQqZTMZ52wKBAH5+fujRowcePnyIqqoqPHz4EJ999hnq1KmDAQMGoHXr1oiNjcXFixdx69YtNmDfvn171KtX76X6aNmyJVavXo20tDQEBQXh7bffRmBgIKs3lpSUhMzMTDg6OsLS0tLkRcQwDHJyclBeXs62ZcgbCgkJMYu+Wnp6Oi5fvoyWLVuiV69esLe3BxEhPT0diYmJOHz4MEpKSjBy5EiTUhMsLCxYb8eQECoSiTBw4EC4u7ubJUZpdkNERHjw4AESEhJMcuWEQiH69++PvXv3orKyErdu3YKTkxPu3buH8+fPIzY2FjExMSgtLYWdnR0WLVqEyMjIGmd9ajQabNq0Cfv37wcAXL16FQ0aNICvry9CQkLg6ekJf39/aLVa5ObmAnh8ynD8+HHExsYiIiICQUFBNbpZhoD4qVOncP/+fVy5cgVRUVHVPtOjRw+MHz/epADy81BSUoJ79+6BYRjY2NjA09OT04UkFosxadIkyGQyrFy5EnK5HGlpaQAeLy5bW1solUpIJBLo9XrUrVsXX3zxBTp27Ahvb+9/NBo8Hg92dnb44IMPoNPpYGFhAZFIVM0r0Ov10Ov1aNGiBSfCmOXl5Vi+fDkAsEXRo0ePxvDhwznN1gYeGwYPDw+UlpZi//79OH/+PPbv3w8PDw9YWFggNTUVubm5qKysxGeffWaSR/R3JCcnY9++fQgPD0dYWJj5BCw5izY9BwqFgj7++GOytbWldevWGZ3XY8hLMRQTOjs7k6+vL7m4uJC9vT1ZWFgQj8ejjh070uXLl0kulxsVbFUqlTR8+PBq+SACgYCsrKzIycmJ3NzcyMfHh7y9vcnNzY3c3NzI1dWVrKysSCwW07Vr14wu7n1SNrmysrLaS6FQmKWYtry8nObPn082NjbE5/PJx8eHoqOjOc9X0uv1VFFRQefOnaPBgwezgWiBQEAWFhYkFApp9uzZdP36dUpKSiKFQsFpkXRVVRXNmDGDJkyYwAn1R1ZWFjs3+Hw+DR8+3GTZ7OfBEIz/8MMPqwWoDddQJBJRt27daMuWLVRWVsbZb5DL5bR69Wpyc3OjnTt3mpXaxiyGiGEY0uv1pNFoaP/+/eTn50fNmjWj5ORkkya4Xq8nmUxGEonkuS+ZTGbSBWMYhioqKmjv3r3UpUsXaty4MTk4OLywQt3CwoK6detG586d40Rs7lUiPz+fRo8ezY6lXbt2lJCQYJa+DCKECoXimfdOqVRyqpX19743bdpEw4YN44QXq7CwkJo1a0Y8Ho+6detGSUlJZmVd0Ov1pFQqnzvv5XI5p6rKDMPQvXv3KCwsjIYPH07Z2dmctPs8mGVrFhMTg5UrV6Kqqgq3bt2Cs7MzNm7cCD8/P5P25nw+H2KxmMNf+jR4PB7s7e0RGRmJ/v37Q6fTIS0tDUePHkVmZiauXbuGtLQ0hIeHo2nTpgCAd999Fx07doRYLOZc78ncoCcEBlxcXDBlyhT4+/ubpS8ej8fGH8xRD/hPfdvZ2YHP53PCnlmnTh2MHTsWK1aswDvvvAMfHx+zMgvw+XxYWVm9Mg4nvV6P9PR0FBcX49NPP4WXl5dZ+zOLIXJzcwMR4fz582jdujX+97//cZplam48uWCAx7VcTZo0YRctEVXjpf6viCKWlZUhKyvrP0tq369fPzZ+ZCqsra0xY8YMfPTRRy/FJ/2mgcfjwdLSEt26dUOnTp3MPr/NomtGRGAYhj35qSWT//ciPz8fR48eRVlZGW7fvo1hw4ZhwIABnAdc/y0w8DjVzsd/hmENv4r1WyuwWAt2q2J4cNQu0lq8atQaolrUohavHW9+YKMWtajFG49aQ1SLWtTitaPWENWiFrV47ag1RLWoRS1eO2oNUS1qUYvXjlpDVIta1OK1o9YQ1aIWtXjtqDVEtahFLV47ag1RLWpRi9eOWkNUi1rU4rXj/wHPqwpznC5RbgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# write your code here for iterating over five batches of \n",
     "# 100 data points each and displaying as 10x10 grids\n",
     "\n",
     "def show_batch_of_images(img_batch, fig_size=(3, 3)):\n",
-    "    #Expected shape of img_batch: (batch_size, im_height, im_width)\n",
-    "    raise NotImplementedError('Write me!')\n",
+    "    #Shape of img_batch: (batch_size, im_height, im_width)\n",
+    "    fig = plt.figure(figsize=fig_size)\n",
+    "    batch_size, im_height, im_width = img_batch.shape\n",
+    "    # calculate no. of columns per grid row to give square grid\n",
+    "    grid_size = int(batch_size**0.5)\n",
+    "    # intialise empty array to tile image grid into\n",
+    "    tiled = np.empty((im_height * grid_size, \n",
+    "                      im_width * batch_size // grid_size))\n",
+    "    # iterate over images in batch + indexes within batch\n",
+    "    for i, img in enumerate(img_batch):\n",
+    "        # calculate grid row and column indices\n",
+    "        r, c = i % grid_size, i // grid_size\n",
+    "        tiled[r * im_height:(r + 1) * im_height, \n",
+    "              c * im_height:(c + 1) * im_height] = img\n",
+    "    ax = fig.add_subplot(111)\n",
+    "    ax.imshow(tiled, cmap='Greys')\n",
+    "    ax.axis('off')\n",
+    "    fig.tight_layout()\n",
+    "    plt.show()\n",
+    "    return fig, ax\n",
     "\n",
     "batch_size = 100\n",
     "num_batches = 5\n",
     "\n",
-    "#TODO: initialize the MNISTDataProvider class and iterate over batches\n",
-    "# with the show_batch_of_images function"
+    "mnist_dp = data_providers.MNISTDataProvider(\n",
+    "    which_set='valid', batch_size=batch_size, \n",
+    "    max_num_batches=num_batches, shuffle_order=True)\n",
+    "\n",
+    "for inputs, target in mnist_dp:\n",
+    "    # reshape inputs from batch of vectors to batch of 2D arrays (images)\n",
+    "    show_batch_of_images(inputs.reshape((batch_size, 28, 28)))"
    ]
   },
   {
@@ -130,9 +239,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
+      " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]]\n",
+      "[[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n",
+      " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]]\n",
+      "[[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
+      " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n",
+      " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]]\n",
+      "[[0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n",
+      " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
+      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]]\n",
+      "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n",
+      " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
+      " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
+     ]
+    }
+   ],
    "source": [
     "import mlp.data_providers as data_providers\n",
     "import numpy as np\n",
@@ -164,10 +305,9 @@
     "\n",
     "**Your tasks**:\n",
     "\n",
-    "  * Implement the `MetOfficeDataProvider` class in `mlp/data_providers.py`. You only need to implement the `__init__()` function, following the instructions below:\n",
-    "    * You should read all of the data from the file ([`np.loadtxt`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html) may be useful for this) and then filter out the `-99.9` values and collapse the table to a one-dimensional array corresponding to a sequence of daily measurements for the whole period data is available for. [NumPy's boolean indexing feature](http://docs.scipy.org/doc/numpy/user/basics.indexing.html#boolean-or-mask-index-arrays) could be helpful here.\n",
-    "    * A common initial preprocessing step in machine learning tasks is to normalise data so that it has zero mean and a standard deviation of one. Normalise the data sequence so that its overall mean is zero and standard deviation one.\n",
-    "    * Each data point in the data provider should correspond to a window of length specified in the `__init__` method as `window_size` of this contiguous data sequence, with the model inputs being the first `window_size - 1` elements of the window and the target output being the last element of the window. For example if the original data sequence was `[1, 2, 3, 4, 5, 6]` and `window_size=3` then `input, target` pairs iterated over by the data provider should be\n",
+    "  * You should read all of the data from the file ([`np.loadtxt`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html) may be useful for this) and then filter out the `-99.9` values and collapse the table to a one-dimensional array corresponding to a sequence of daily measurements for the whole period data is available for. [NumPy's boolean indexing feature](http://docs.scipy.org/doc/numpy/user/basics.indexing.html#boolean-or-mask-index-arrays) could be helpful here.\n",
+    "  * A common initial preprocessing step in machine learning tasks is to normalise data so that it has zero mean and a standard deviation of one. Normalise the data sequence so that its overall mean is zero and standard deviation one.\n",
+    "  * Each data point in the data provider should correspond to a window of length specified in the `__init__` method as `window_size` of this contiguous data sequence, with the model inputs being the first `window_size - 1` elements of the window and the target output being the last element of the window. For example if the original data sequence was `[1, 2, 3, 4, 5, 6]` and `window_size=3` then `input, target` pairs iterated over by the data provider should be\n",
     "  ```\n",
     "  [1, 2], 3\n",
     "  [4, 5], 6\n",
@@ -185,13 +325,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {
     "nbpresent": {
      "id": "c8553a56-9f25-4198-8a1a-d7e9572b4382"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "import mlp.data_providers as data_providers\n",
diff --git a/notebooks/02_Single_layer_models.ipynb b/notebooks/02_Single_layer_models.ipynb
new file mode 100644
index 0000000..093ec41
--- /dev/null
+++ b/notebooks/02_Single_layer_models.ipynb
@@ -0,0 +1,1124 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Single layer models\n",
+    "\n",
+    "The objective of this lab is to implement a single-layer network model consisting of solely of an affine transformation of the inputs. The relevant material for this is covered in slides 12-23 of the first lecture.\n",
+    "\n",
+    "We will first implement the forward propagation of inputs to the network to produce predicted outputs. We will then move on to considering how to use gradients of an error function evaluated on the outputs to compute the gradients with respect to the model parameters to allow us to perform an iterative gradient-descent training procedure. In the final exercise you will use an interactive visualisation to explore the role of some of the different hyperparameters of gradient-descent based training methods.\n",
+    "\n",
+    "#### A note on random number generators\n",
+    "\n",
+    "It is generally a good practice (for machine learning applications **not** for cryptography!) to seed a pseudo-random number generator once at the beginning of each experiment. This makes it easier to reproduce results as the same random draws will produced each time the experiment is run (e.g. the same random initialisations used for parameters). Therefore generally when we need to generate random values during this course, we will create a seeded random number generator object as we do in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "seed = 27092016 \n",
+    "rng = np.random.RandomState(seed)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 1: linear and affine transforms\n",
+    "\n",
+    "Any *linear transform* (also called a linear map) on a finite-dimensional vector space can be parametrised by a matrix. For example if we consider $\\boldsymbol{x} \\in \\mathbb{R}^{D}$ as the input space of a model with $D$ dimensional real-valued inputs, then a matrix $\\mathbf{W} \\in \\mathbb{R}^{K\\times D}$ can be used to define a prediction model consisting solely of a linear transform of the inputs\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\boldsymbol{y} = \\mathbf{W} \\boldsymbol{x}\n",
+    "    \\qquad\n",
+    "    \\Leftrightarrow\n",
+    "    \\qquad\n",
+    "    y_k = \\sum_{d=1}^D \\left( W_{kd} x_d \\right) \\quad \\forall k \\in \\left\\lbrace 1 \\dots K\\right\\rbrace\n",
+    "\\end{equation}\n",
+    "\n",
+    "with $\\boldsymbol{y} \\in \\mathbb{R}^K$ the $K$-dimensional real-valued output of the model. Geometrically we can think of a linear transform as some combination of rotation, scaling, reflection and shearing of the input.\n",
+    "\n",
+    "An *affine transform* consists of a linear transform plus an additional translation on the output space parameterised by a vector $\\boldsymbol{b} \\in \\mathbb{R}^K$. A model consisting of an affine transformation of the inputs can then be defined as\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\boldsymbol{y} = \\mathbf{W}\\boldsymbol{x} + \\boldsymbol{b}\n",
+    "    \\qquad\n",
+    "    \\Leftrightarrow\n",
+    "    \\qquad\n",
+    "    y_k = \\sum_{d=1}^D \\left( W_{kd} x_d \\right) + b_k \\quad \\forall k \\in \\left\\lbrace 1 \\dots K\\right\\rbrace\n",
+    "\\end{equation}\n",
+    "\n",
+    "In machine learning we will usually refer to the matrix $\\mathbf{W}$ as a *weight matrix* and the vector $\\boldsymbol{b}$ as a *bias vector*.\n",
+    "\n",
+    "Generally, rather than working with a single data vector $\\boldsymbol{x}$ we will work with batches of datapoints $\\left\\lbrace \\boldsymbol{x}^{(b)}\\right\\rbrace_{b=1}^B$. We could calculate the outputs for each input in the batch sequentially\n",
+    "\n",
+    "\\begin{align}\n",
+    "    \\boldsymbol{y}^{(1)} &= \\mathbf{W}\\boldsymbol{x}^{(1)} + \\boldsymbol{b}\\\\\n",
+    "    \\boldsymbol{y}^{(2)} &= \\mathbf{W}\\boldsymbol{x}^{(2)} + \\boldsymbol{b}\\\\\n",
+    "    \\dots &\\\\\n",
+    "    \\boldsymbol{y}^{(B)} &= \\mathbf{W}\\boldsymbol{x}^{(B)} + \\boldsymbol{b}\\\\\n",
+    "\\end{align}\n",
+    "\n",
+    "by looping over each input in the batch and calculating the output. However, loops in Python are slow (particularly compared to compiled and typed languages such as C). This is due at least in part to the large overhead in dynamically inferring variable types. In consequence, we want to avoid having loops in which this overhead would be the dominant computational cost.\n",
+    "\n",
+    "For array-based numerical operations, one way of overcoming this bottleneck is to *vectorise* operations, that is, computing all of them at once. NumPy `ndarrays` are typed arrays for which operations, like basic elementwise arithmetic and linear algebra operations (*e.g.*  computing matrix-matrix or matrix-vector products) are implemented by calls to highly-optimised compiled libraries. Therefore, implementing code directly using NumPy operations on arrays rather than by looping over array elements usually leads to very substantial performance gains.\n",
+    "\n",
+    "As a simple example, we can consider adding up two arrays `a` and `b` and writing the result to a third array `c`. Let us start by initialising `a` and `b` with arbitrary values by running the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "size = 1000\n",
+    "a = np.random.randn(size)\n",
+    "b = np.random.randn(size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we are going to measure how long it takes to add up each pair of values in the two array and write the results to a third array using a loop-based implementation. We will use the `%%timeit` magic briefly mentioned in the previous lab notebook, specifying the number of times to loop the code as 100 and repeating it 3 times for better consistency. Run the cell below to get a print out of the average time taken."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit -n 100 -r 3\n",
+    "c = np.empty(size)\n",
+    "for i in range(size):\n",
+    "    c[i] = a[i] + b[i]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And now we will perform the corresponding summation with the overloaded addition operator of NumPy arrays. Again run the cell below to get a print out of the average time taken."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit -n 100 -r 3\n",
+    "c = a + b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first loop-based implementation should have taken on the order of milliseconds ( $10^{-3}$ s) while the vectorised implementation should have taken on the order of microseconds ( $10^{-6}$ s), i.e. a $\\sim1000\\times$ speedup. Hopefully this simple example should make it clear why we want to vectorise operations whenever possible!\n",
+    "\n",
+    "Getting back to our affine model, ideally rather than individually computing the output corresponding to each input we should compute the outputs for all inputs in a batch using a vectorised implementation. As you saw last week, data providers return batches of inputs as arrays of shape `(batch_size, input_dim)`. In the mathematical notation used earlier we can consider the input as a matrix $\\mathbf{X}$ of dimensionality $B \\times D$:\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\mathbf{X} = \\left[ \\boldsymbol{x}^{(1)} ~ \\boldsymbol{x}^{(2)} ~ \\dots ~ \\boldsymbol{x}^{(B)} \\right]^\\mathrm{T}\n",
+    "\\end{equation}\n",
+    "\n",
+    "i.e. the $b^{\\textrm{th}}$ input vector $\\boldsymbol{x}^{(b)}$ corresponds to the $b^{\\textrm{th}}$ row of $\\mathbf{X}$. Similarly, we can define the $B \\times K$ matrix of outputs $\\mathbf{Y}$ as\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\mathbf{Y} = \\left[ \\boldsymbol{y}^{(1)} ~ \\boldsymbol{y}^{(2)} ~ \\dots ~ \\boldsymbol{y}^{(B)} \\right]^\\mathrm{T}\n",
+    "\\end{equation}\n",
+    "\n",
+    "We can then express the relationship between $\\mathbf{X}$ and $\\mathbf{Y}$ using [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) and addition as\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\mathbf{Y} = \\mathbf{X} \\mathbf{W}^\\mathrm{T} + \\mathbf{B}\n",
+    "\\end{equation}\n",
+    "\n",
+    "where $\\mathbf{B} = \\left[ \\boldsymbol{b} ~ \\boldsymbol{b} ~ \\dots ~ \\boldsymbol{b} \\right]^\\mathrm{T}$ i.e. a $B \\times K$ matrix with each row corresponding to the same bias vector. The weight matrix needs to be transposed here as the inner dimensions of a matrix multiplication must match i.e. for $\\mathbf{C} = \\mathbf{A} \\mathbf{B}$ then if $\\mathbf{A}$ is of dimensionality $K \\times L$ and $\\mathbf{B}$ is of dimensionality $M \\times N$ then it must be the case that $L = M$ and $\\mathbf{C}$ will be of dimensionality $K \\times N$.\n",
+    "\n",
+    "**Your Tasks:**\n",
+    "\n",
+    "The first exercise for this lab is to implement *forward propagation* for a single-layer model consisting of an affine transformation of the inputs in the `fprop` function given as skeleton code in the cell below. This should work for a batch of inputs of shape `(batch_size, input_dim)` producing a batch of outputs of shape `(batch_size, output_dim)`.\n",
+    "  \n",
+    "You will probably want to use the NumPy `dot` function and [broadcasting features](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) to implement this efficiently. If you are not familiar with either of these, you may wish to read the [hints](#Hints:-Using-the-dot-function-and-broadcasting) section below which provides some tips before attempting the exercise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fprop(inputs, weights, biases):\n",
+    "    \"\"\"Forward propagates activations through the layer transformation.\n",
+    "\n",
+    "    For inputs `x`, outputs `y`, weights `W` and biases `b` the layer\n",
+    "    corresponds to `y = W x + b`.\n",
+    "\n",
+    "    Args:\n",
+    "        inputs: Array of layer inputs of shape (batch_size, input_dim).\n",
+    "        weights: Array of weight parameters of shape \n",
+    "            (output_dim, input_dim).\n",
+    "        biases: Array of bias parameters of shape (output_dim, ).\n",
+    "\n",
+    "    Returns:\n",
+    "        outputs: Array of layer outputs of shape (batch_size, output_dim).\n",
+    "    \"\"\"\n",
+    "    raise NotImplementedError(\"TODO: Implement this function.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you have implemented `fprop` in the cell above you can test your implementation by running the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = np.array([[0., -1., 2.], [-6., 3., 1.]])\n",
+    "weights = np.array([[2., -3., -1.], [-5., 7., 2.]])\n",
+    "biases = np.array([5., -3.])\n",
+    "true_outputs = np.array([[6., -6.], [-17., 50.]])\n",
+    "\n",
+    "if not np.allclose(fprop(inputs, weights, biases), true_outputs):\n",
+    "    print('Wrong outputs computed.')\n",
+    "else:\n",
+    "    print('All outputs correct!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Hints: Using the `dot` function and broadcasting\n",
+    "\n",
+    "For those new to NumPy below are some details on the `dot` function and broadcasting feature of NumPy that you may want to use for implementing the first exercise. If you are already familiar with these and have already completed the first exercise you can move on straight to [second exercise](#Exercise-2:-visualising-random-models).\n",
+    "\n",
+    "#### `numpy.dot` function\n",
+    "\n",
+    "Matrix-matrix, matrix-vector and vector-vector (dot) products can all be computed in NumPy using the [`dot`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html) operator which generalizes all of these operation. For example if `A` and `B` are both two dimensional arrays, then `C = np.dot(A, B)` or equivalently `C = A.dot(B)` will compute the matrix product of `A` and `B` assuming `A` and `B` have compatible dimensions. Similarly if `a` and `b` are one dimensional arrays then `c = np.dot(a, b)` (which is equivalent to `c = a.dot(b)`) will compute the [scalar / dot product](https://en.wikipedia.org/wiki/Dot_product) of the two arrays. If `A` is a two-dimensional array and `b` a one-dimensional array `np.dot(A, b)` (which is equivalent to `A.dot(b)`) will compute the matrix-vector product of `A` and `b`. Examples of all three of these product types are shown in the cell below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initiliase arrays with arbitrary values\n",
+    "A = np.arange(9).reshape((3, 3))\n",
+    "B = np.ones((3, 3)) * 2\n",
+    "a = np.array([-1., 0., 1.])\n",
+    "b = np.array([0.1, 0.2, 0.3])\n",
+    "print(A.dot(B))  # Matrix-matrix product\n",
+    "print(B.dot(A))  # Reversed product of above. A.dot(B) != B.dot(A) in general\n",
+    "print(A.dot(b))  # Matrix-vector product\n",
+    "print(b.dot(A))  # Again A.dot(b) != b.dot(A) unless A is symmetric i.e. A == A.T\n",
+    "print(a.dot(b))  # Vector-vector scalar product"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Broadcasting\n",
+    "\n",
+    "Another NumPy feature it will be helpful to get familiar with is [broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html). Broadcasting allows you to apply operations to arrays of different shapes by letting numpy infer the missing parts, for example to add a one-dimensional array to a two-dimensional array or multiply a multidimensional array by a scalar. The complete set of rules for broadcasting as explained in the official documentation page just linked to can sound a bit complex: you might find the [visual explanation on this page](http://www.scipy-lectures.org/intro/numpy/operations.html#broadcasting) more intuitive.\n",
+    "Keep in mind that the shapes must be compatible with one another, and that it may lead to erroneous results if the shapes are not as intended, so you are advised to make sure your arrays have the proper shapes.\n",
+    "The cell below gives a few examples:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initiliase arrays with arbitrary values\n",
+    "A = np.arange(6).reshape((3, 2))\n",
+    "b = np.array([0.1, 0.2])\n",
+    "c = np.array([-1., 0., 1.])\n",
+    "print(A + b)  # Add b elementwise to all rows of A\n",
+    "print((A.T + c).T)  # Add b elementwise to all columns of A\n",
+    "print(A * b)  # Multiply each row of A elementise by b "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 2: visualising random models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this exercise you will use your `fprop` implementation to visualise the outputs of a single-layer affine transform model with two-dimensional inputs and a one-dimensional output. In this simple case, we can visualise the joint input-output space on a 3D axis.\n",
+    "\n",
+    "For this task and the learning experiments later in the notebook we will use a regression dataset from the UCI machine learning repository. In particular we will use a version of the [Combined Cycle Power Plant dataset](http://archive.ics.uci.edu/ml/datasets/Combined+Cycle+Power+Plant), where the task is to predict the energy output of a power plant given observations of the local ambient conditions (e.g. temperature, pressure and humidity).\n",
+    "\n",
+    "The original dataset has four input dimensions and a single target output dimension. We have preprocessed the dataset by [whitening](https://en.wikipedia.org/wiki/Whitening_transformation) it. Geometrically, this process rotates the data so that it's [principle components](https://en.wikipedia.org/wiki/Principal_component_analysis) are aligned with the basis vectors, and then scales the data so that variance along each dimension is one (see [here](https://www.quora.com/What-is-the-use-of-Whitening-images-as-a-preprocessing-step-for-a-Convolutional-Neural-Network)).\n",
+    "\n",
+    "If the original dataset has a covariance $\\mathbf{C}$, a whitening transformation $\\mathbf{D}$ is one which satisfies:\n",
+    "\\begin{equation}\n",
+    "    \\mathbf{D}^{\\mathrm{T}} \\mathbf{C} \\mathbf{D} = \\mathbf{I},\n",
+    "\\end{equation}\n",
+    "where $\\mathbf{I}$ is the identity matrix.\n",
+    "\n",
+    "This can be considered a change of basis, where newly formed input features are decorrelated and have equivalent scale, which can lead to reduced learning times (see [here](https://proceedings.neurips.cc/paper/1990/file/758874998f5bd0c393da094e1967a72b-Paper.pdf)). We will only use the first two dimensions of the whitened inputs (corresponding to the first two principal components of the original inputs) so we can easily visualise the joint input-output space.\n",
+    "\n",
+    "The dataset has been wrapped in the `CCPPDataProvider` class in the `mlp.data_providers` module and the data included as a compressed file in the data directory as `ccpp_data.npz`. Running the cell below will initialise an instance of this class, get a single batch of inputs and targets, and import the necessary `matplotlib` objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "# import sys\n",
+    "# sys.path.append('/path/to/mlpractical')\n",
+    "from mpl_toolkits.mplot3d import Axes3D\n",
+    "from mlp.data_providers import CCPPDataProvider\n",
+    "\n",
+    "data_provider = CCPPDataProvider(\n",
+    "    which_set='train',\n",
+    "    input_dims=[0, 1],\n",
+    "    batch_size=5000, \n",
+    "    max_num_batches=1, \n",
+    "    shuffle_order=False\n",
+    ")\n",
+    "\n",
+    "input_dim, output_dim = 2, 1\n",
+    "\n",
+    "inputs, targets = data_provider.next()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now run the cell below to plot the predicted outputs of a randomly initialised model across the two dimensional input space as well as the true target outputs. This sort of visualisation can be a useful method (in low dimensions) to assess how well the model is likely to be able to fit the data and to judge appropriate initialisation scales for the parameters. Each time you re-run the cell a new set of random parameters will be sampled\n",
+    "\n",
+    "**Your Tasks:**\n",
+    "\n",
+    "Here you don't need to implement anything. Just run the cell for several times and try to answer the following questions:\n",
+    "\n",
+    "  * How do the weights and bias initialisation scale affect the sort of predicted input-output relationships?\n",
+    "  * Do you think a linear model is a good choice for this data?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weights_init_range = 0.5\n",
+    "biases_init_range = 0.1\n",
+    "\n",
+    "# Randomly initialise weights matrix\n",
+    "weights = rng.uniform(\n",
+    "    low=-weights_init_range, \n",
+    "    high=weights_init_range, \n",
+    "    size=(output_dim, input_dim)\n",
+    ")\n",
+    "\n",
+    "#  Randomly initialise biases vector\n",
+    "biases = rng.uniform(\n",
+    "    low=-biases_init_range, \n",
+    "    high=biases_init_range, \n",
+    "    size=output_dim\n",
+    ")\n",
+    "# Calculate predicted model outputs\n",
+    "outputs = fprop(inputs, weights, biases)\n",
+    "\n",
+    "# Plot target and predicted outputs against inputs on same axis\n",
+    "fig = plt.figure(figsize=(8, 8))\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], targets[:, 0], 'r.', ms=2)\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], outputs[:, 0], 'b.', ms=2)\n",
+    "ax.set_xlabel('Input dim 1')\n",
+    "ax.set_ylabel('Input dim 2')\n",
+    "ax.set_zlabel('Output')\n",
+    "ax.legend(['Targets', 'Predictions'], frameon=False)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 3: computing the error function and its gradient\n",
+    "\n",
+    "We will now consider the task of regression as covered in the first lecture. Given a set of inputs $\\left\\lbrace \\boldsymbol{x}^{(n)}\\right\\rbrace_{n=1}^N$, the aim in a regression problem is to produce outputs $\\left\\lbrace \\boldsymbol{y}^{(n)}\\right\\rbrace_{n=1}^N$ that are as 'close' as possible to a set of targets $\\left\\lbrace \\boldsymbol{t}^{(n)}\\right\\rbrace_{n=1}^N$. The measure of 'closeness' or distance between target and predicted outputs can vary and is usually a design choice. \n",
+    "\n",
+    "A very common choice is the squared Euclidean distance between the predicted and target outputs. This can be computed as the sum of the squared differences between each element in the target and predicted outputs. A widespread convention is to multiply this value by $\\frac{1}{2}$ as this gives a slightly nicer expression for the error gradient. The error for the $n^{\\textrm{th}}$ training example is then expresed by\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    E^{(n)} = \\frac{1}{2} \\sum_{k=1}^K \\left\\lbrace \\left( y^{(n)}_k - t^{(n)}_k \\right)^2 \\right\\rbrace.\n",
+    "\\end{equation}\n",
+    "\n",
+    "The overall error is defined as the *average* of this value across all training examples\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\bar{E} = \\frac{1}{N} \\sum_{n=1}^N \\left\\lbrace E^{(n)} \\right\\rbrace. \n",
+    "\\end{equation}\n",
+    "\n",
+    "*Note here we are using a slightly different convention from the lectures. There the overall error was considered to be the sum of the individual error terms rather than the mean. To differentiate between the two we will use $\\bar{E}$ to represent the average error here as opposed to sum of errors $E$ as used in the slides with $\\bar{E} = \\frac{E}{N}$. Normalising by the number of training examples is helpful to do in practice as this means we can more easily compare errors across data sets / batches of different sizes, and more importantly it means the size of our gradient updates will be independent of the number of training examples summed over.*\n",
+    "\n",
+    "Solving the regression problem means finding parameters of the model which minimise $\\bar{E}$. For our simple single-layer affine model here, that corresponds to finding weights $\\mathbf{W}$ and biases $\\boldsymbol{b}$ which minimise $\\bar{E}$. \n",
+    "\n",
+    "As mentioned in the lecture, in this case there is actually a closed form solution for the optimal weights and bias parameters. This is the linear least-squares solution those doing MLPR will have come across.\n",
+    "\n",
+    "However in general we will be interested in models where closed form solutions do not exist. Therefore, we will generally use iterative gradient descent based optimization methods to find parameters which (locally) minimise the error function. A basic requirement of being able to do gradient-descent based training is (unsuprisingly) the ability to evaluate gradients of the error function.\n",
+    "\n",
+    "Our end goal is to calculate gradients of the error function with respect to the model parameters $\\mathbf{W}$ and $\\boldsymbol{b}$. As a first step here we will consider the gradient of the error function with respect to the model outputs $\\left\\lbrace \\boldsymbol{y}^{(n)}\\right\\rbrace_{n=1}^N$. This can be written\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\frac{\\partial \\bar{E}}{\\partial \\boldsymbol{y}^{(n)}} = \\frac{1}{N} \\left( \\boldsymbol{y}^{(n)} - \\boldsymbol{t}^{(n)} \\right)\n",
+    "    \\qquad \\Leftrightarrow \\qquad\n",
+    "    \\frac{\\partial \\bar{E}}{\\partial y^{(n)}_k} = \\frac{1}{N} \\left( y^{(n)}_k - t^{(n)}_k \\right) \\quad \\forall k \\in \\left\\lbrace 1 \\dots K\\right\\rbrace\n",
+    "\\end{equation}\n",
+    "\n",
+    "*i.e.* the gradient of the error function with respect to the $n^{\\textrm{th}}$ model output is the difference between the $n^{\\textrm{th}}$ model and target outputs, corresponding to the $\\boldsymbol{\\delta}^{(n)}$ terms mentioned in the lecture slides.\n",
+    "\n",
+    "**Your Tasks:** \n",
+    "\n",
+    "Using the equations given above, implement functions computing the mean sum of squared differences error and its gradient with respect to the model outputs. You should implement the functions using the provided skeleton definitions in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def error(outputs, targets):\n",
+    "    \"\"\"Calculates error function given a batch of outputs and targets.\n",
+    "\n",
+    "    Args:\n",
+    "        outputs: Array of model outputs of shape (batch_size, output_dim).\n",
+    "        targets: Array of target outputs of shape (batch_size, output_dim).\n",
+    "\n",
+    "    Returns:\n",
+    "        Scalar error function value.\n",
+    "    \"\"\"\n",
+    "    raise NotImplementedError(\"TODO implement this function\")\n",
+    "    \n",
+    "def error_grad(outputs, targets):\n",
+    "    \"\"\"Calculates gradient of error function with respect to model outputs.\n",
+    "\n",
+    "    Args:\n",
+    "        outputs: Array of model outputs of shape (batch_size, output_dim).\n",
+    "        targets: Array of target outputs of shape (batch_size, output_dim).\n",
+    "\n",
+    "    Returns:\n",
+    "        Gradient of error function with respect to outputs.\n",
+    "        This will be an array of shape (batch_size, output_dim).\n",
+    "    \"\"\"\n",
+    "    raise NotImplementedError(\"TODO implement this function\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Check your implementation by running the test cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "outputs = np.array([[1., 2.], [-1., 0.], [6., -5.], [-1., 1.]])\n",
+    "targets = np.array([[0., 1.], [3., -2.], [7., -3.], [1., -2.]])\n",
+    "true_error = 5.\n",
+    "true_error_grad = np.array([[0.25, 0.25], [-1., 0.5], [-0.25, -0.5], [-0.5, 0.75]])\n",
+    "\n",
+    "if not error(outputs, targets) == true_error:\n",
+    "    print('Error calculated incorrectly.')\n",
+    "elif not np.allclose(error_grad(outputs, targets), true_error_grad):\n",
+    "    print('Error gradient calculated incorrectly.')\n",
+    "else:\n",
+    "    print('Error function and gradient computed correctly!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 4: computing gradients with respect to the parameters\n",
+    "\n",
+    "In the previous exercise you implemented a function computing the gradient of the error function with respect to the model outputs. For gradient-descent based training, we need to be able to evaluate the gradient of the error function with respect to the model parameters.\n",
+    "\n",
+    "Using the [chain rule for derivatives](https://en.wikipedia.org/wiki/Chain_rule#Higher_dimensions), we can write the partial deriviative of the error function with respect to single elements of the weight matrix and bias vector as\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\frac{\\partial E}{\\partial W_{kj}} = \\sum_{n=1}^N \\left\\lbrace \\frac{\\partial E}{\\partial y^{(n)}_k} \\frac{\\partial y^{(n)}_k}{\\partial W_{kj}} \\right\\rbrace\n",
+    "    \\quad \\textrm{and} \\quad\n",
+    "    \\frac{\\partial E}{\\partial b_k} = \\sum_{n=1}^N \\left\\lbrace \\frac{\\partial E}{\\partial y^{(n)}_k} \\frac{\\partial y^{(n)}_k}{\\partial b_k} \\right\\rbrace.\n",
+    "\\end{equation}\n",
+    "\n",
+    "From the definition of our model at the beginning we have \n",
+    "\n",
+    "\\begin{equation}\n",
+    "    y^{(n)}_k = \\sum_{d=1}^D \\left\\lbrace W_{kd} x^{(n)}_d \\right\\rbrace + b_k\n",
+    "    \\quad \\Rightarrow \\quad\n",
+    "    \\frac{\\partial y^{(n)}_k}{\\partial W_{kj}} = x^{(n)}_j\n",
+    "    \\quad \\textrm{and} \\quad\n",
+    "    \\frac{\\partial y^{(n)}_k}{\\partial b_k} = 1.\n",
+    "\\end{equation}\n",
+    "\n",
+    "Putting this together we get that\n",
+    "\n",
+    "\\begin{equation}\n",
+    "    \\frac{\\partial E}{\\partial W_{kj}} = \n",
+    "    \\sum_{n=1}^N \\left\\lbrace \\frac{\\partial E}{\\partial y^{(n)}_k} x^{(n)}_j \\right\\rbrace\n",
+    "    \\quad \\textrm{and} \\quad\n",
+    "    \\frac{\\partial E}{\\partial b_{k}} = \n",
+    "    \\sum_{n=1}^N \\left\\lbrace \\frac{\\partial E}{\\partial y^{(n)}_k} \\right\\rbrace.\n",
+    "\\end{equation}\n",
+    "\n",
+    "Although this may seem a bit of a roundabout way to get to these results, this method of decomposing the error gradient with respect to the parameters in terms of the gradient of the error function with respect to the model outputs and the derivatives of the model outputs with respect to the model parameters is the key element that allows calculating the parameter gradients of more complex models we will study later in the course.\n",
+    "\n",
+    "**Your Tasks:** \n",
+    "\n",
+    "Implement a function calculating the gradient of the error function with respect to the weight and bias parameters of the model given the already computed gradient of the error function with respect to the model outputs. You should implement this in the `grads_wrt_params` function in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def grads_wrt_params(inputs, grads_wrt_outputs):\n",
+    "    \"\"\"Calculates gradients with respect to model parameters.\n",
+    "\n",
+    "    Args:\n",
+    "        inputs: array of inputs to model of shape (batch_size, input_dim)\n",
+    "        grads_wrt_to_outputs: array of gradients of with respect to the model\n",
+    "            outputs of shape (batch_size, output_dim).\n",
+    "\n",
+    "    Returns:\n",
+    "        list of arrays of gradients with respect to the model parameters\n",
+    "        `[grads_wrt_weights, grads_wrt_biases]`.\n",
+    "    \"\"\"\n",
+    "    raise NotImplementedError(\"TODO implement this function\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Check your implementation by running the test cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = np.array([[1., 2., 3.], [-1., 4., -9.]])\n",
+    "grads_wrt_outputs = np.array([[-1., 1.], [2., -3.]])\n",
+    "true_grads_wrt_weights = np.array([[-3., 6., -21.], [4., -10., 30.]])\n",
+    "true_grads_wrt_biases = np.array([1., -2.])\n",
+    "\n",
+    "grads_wrt_weights, grads_wrt_biases = grads_wrt_params(\n",
+    "    inputs, grads_wrt_outputs)\n",
+    "\n",
+    "if not np.allclose(true_grads_wrt_weights, grads_wrt_weights):\n",
+    "    print('Gradients with respect to weights incorrect.')\n",
+    "elif not np.allclose(true_grads_wrt_biases, grads_wrt_biases):\n",
+    "    print('Gradients with respect to biases incorrect.')\n",
+    "else:\n",
+    "    print('All parameter gradients calculated correctly!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 5: wrapping the functions into reusable components\n",
+    "\n",
+    "In exercises 1, 3 and 4 you implemented methods to compute the predicted outputs of our model, evaluate the error function and its gradient on the outputs and finally to calculate the gradients of the error with respect to the model parameters. Together they constitute all the basic ingredients we need to implement a gradient-descent based iterative learning procedure.\n",
+    "\n",
+    "Although you could implement training code which directly uses the functions you defined, this would only be usable for this particular model architecture. In subsequent labs we will want to use the affine transform functions as the basis for more interesting multi-layer models. We will therefore wrap the implementations you just wrote in to reusable components that we can combine to build more complex models later in the course.\n",
+    "\n",
+    "**Your Tasks:**\n",
+    "\n",
+    "  * In the [`mlp.layers`](../mlp/layers.py) module, use your implementations of `fprop` and `grad_wrt_params` above to implement the corresponding methods in the skeleton `AffineLayer` class provided.\n",
+    "  * In the [`mlp.errors`](../mlp/errors.py) module use your implementation of `error` and `error_grad` to implement the `__call__` and `grad` methods respectively of the skeleton `SumOfSquaredDiffsError` class provided. Note `__call__` is a special Python method that allows an object to be used with a function call syntax.\n",
+    "  * All functions where you need to implement has been marked with a `#TODO` comment. You don't need to implement other functions right now.\n",
+    "\n",
+    "Run the cell below to use your completed `AffineLayer` and `SumOfSquaredDiffsError` implementations to train a single-layer model using batch gradient descent on the CCPP dataset. Remember to reload the notebook if you made changes to the `mlp` module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mlp.layers import AffineLayer\n",
+    "from mlp.errors import SumOfSquaredDiffsError\n",
+    "from mlp.models import SingleLayerModel\n",
+    "from mlp.initialisers import UniformInit, ConstantInit\n",
+    "from mlp.learning_rules import GradientDescentLearningRule\n",
+    "from mlp.optimisers import Optimiser\n",
+    "import logging\n",
+    "\n",
+    "# Seed a random number generator\n",
+    "seed = 27092016 \n",
+    "rng = np.random.RandomState(seed)\n",
+    "\n",
+    "# Set up a logger object to print info about the training run to stdout\n",
+    "logger = logging.getLogger()\n",
+    "logger.setLevel(logging.INFO)\n",
+    "logger.handlers = [logging.StreamHandler()]\n",
+    "\n",
+    "# Create data provider objects for the CCPP training set\n",
+    "train_data = CCPPDataProvider('train', [0, 1], batch_size=100, rng=rng)\n",
+    "input_dim, output_dim = 2, 1\n",
+    "\n",
+    "# Create a parameter initialiser which will sample random uniform values\n",
+    "# from [-0.1, 0.1]\n",
+    "param_init = UniformInit(-0.1, 0.1, rng=rng)\n",
+    "\n",
+    "# Create our single layer model\n",
+    "layer = AffineLayer(input_dim, output_dim, param_init, param_init)\n",
+    "model = SingleLayerModel(layer)\n",
+    "\n",
+    "# Initialise the error object\n",
+    "error = SumOfSquaredDiffsError()\n",
+    "\n",
+    "# Use a basic gradient descent learning rule with a small learning rate\n",
+    "learning_rule = GradientDescentLearningRule(learning_rate=1e-2)\n",
+    "\n",
+    "# Use the created objects to initialise a new Optimiser instance.\n",
+    "optimiser = Optimiser(model, error, learning_rule, train_data)\n",
+    "\n",
+    "# Run the optimiser for 5 epochs (full passes through the training set)\n",
+    "# printing statistics every epoch.\n",
+    "stats, keys, _ = optimiser.train(num_epochs=10, stats_interval=1)\n",
+    "\n",
+    "# Plot the change in the error over training.\n",
+    "fig = plt.figure(figsize=(8, 4))\n",
+    "ax = fig.add_subplot(111)\n",
+    "ax.plot(np.arange(1, stats.shape[0] + 1), stats[:, keys['error(train)']])\n",
+    "ax.set_xlabel('Epoch number')\n",
+    "ax.set_ylabel('Error')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using similar code to exercise 2, we can visualise the joint input-output space for the trained model. If you implemented the required methods correctly you should now see a much improved fit between predicted and target outputs when running the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_provider = CCPPDataProvider(\n",
+    "    which_set='train',\n",
+    "    input_dims=[0, 1],\n",
+    "    batch_size=5000, \n",
+    "    max_num_batches=1, \n",
+    "    shuffle_order=False\n",
+    ")\n",
+    "\n",
+    "inputs, targets = data_provider.next()\n",
+    "\n",
+    "# Calculate predicted model outputs\n",
+    "outputs = model.fprop(inputs)[-1]\n",
+    "\n",
+    "# Plot target and predicted outputs against inputs on same axis\n",
+    "fig = plt.figure(figsize=(8, 8))\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], targets[:, 0], 'r.', ms=2)\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], outputs[:, 0], 'b.', ms=2)\n",
+    "ax.set_xlabel('Input dim 1')\n",
+    "ax.set_ylabel('Input dim 2')\n",
+    "ax.set_zlabel('Output')\n",
+    "ax.legend(['Targets', 'Predictions'], frameon=False)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 6: visualising training trajectories in parameter space"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Running the cell below will display an interactive widget which plots the trajectories of gradient-based training of the single-layer affine model on the CCPP dataset in the three dimensional parameter space (two weights plus bias) from random initialisations. Also shown on the right is a plot of the evolution of the error function (evaluated on the current batch) over training. By moving the sliders you can alter the training hyperparameters to investigate the effect they have on how training procedes. The hyperparameters are as follows:\n",
+    "\n",
+    "- `n_epochs` : number of training epochs,\n",
+    "- `batch_size` : number of data points per batch,\n",
+    "- `log_lr` : logarithm of the learning rate,\n",
+    "- `n_inits` : number of different parameter initializations,\n",
+    "- `w_scale` : min/max initial weight value,\n",
+    "- `b_scale` : min/max initial bias value,\n",
+    "- `elev`/`azim` : spherical coordinates for camera position.\n",
+    "\n",
+    "When adjusting these hyperparameters, keep in mind that the magnitude of each (per batch) update is independent of the batch size. Increasing the batch size may there for necessitate a larger number of epochs to ensure convergence, or a larger learning rate.\n",
+    "\n",
+    "**Your Tasks:**\n",
+    "\n",
+    "No need to implement anything. Run the cell and explore the following questions:\n",
+    "\n",
+    "  * Are there multiple local minima in parameter space here? Why?\n",
+    "  * What are the effects of using very small learning rates? And very large learning ones?\n",
+    "  * How does the batch size affect learning?\n",
+    "  \n",
+    "**Note:** You don't need to understand how the code below works. The idea of this exercise is to help you understand the role of the various hyperparameters involved in gradient-descent based training methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from ipywidgets import interact\n",
+    "%matplotlib inline\n",
+    "\n",
+    "def setup_figure():\n",
+    "    # create figure and axes\n",
+    "    fig = plt.figure(figsize=(12, 6))\n",
+    "    ax1 = fig.add_axes([0., 0., 0.5, 1.], projection='3d')\n",
+    "    ax2 = fig.add_axes([0.6, 0.1, 0.4, 0.8])\n",
+    "    # set axes properties\n",
+    "    ax2.spines['right'].set_visible(False)\n",
+    "    ax2.spines['top'].set_visible(False)\n",
+    "    ax2.yaxis.set_ticks_position('left')\n",
+    "    ax2.xaxis.set_ticks_position('bottom')\n",
+    "    #ax2.set_yscale('log')\n",
+    "    ax1.set_xlim((-2, 2))\n",
+    "    ax1.set_ylim((-2, 2))\n",
+    "    ax1.set_zlim((-2, 2))\n",
+    "    #set axes labels and title\n",
+    "    ax1.set_title('Parameter trajectories over training')\n",
+    "    ax1.set_xlabel('Weight 1')\n",
+    "    ax1.set_ylabel('Weight 2')\n",
+    "    ax1.set_zlabel('Bias')\n",
+    "    ax2.set_title('Batch errors over training')\n",
+    "    ax2.set_xlabel('Batch update number')\n",
+    "    ax2.set_ylabel('Batch error')\n",
+    "    return fig, ax1, ax2\n",
+    "\n",
+    "def visualise_training(n_epochs=1, batch_size=200, log_lr=-1., n_inits=1,\n",
+    "                       w_scale=1., b_scale=1., elev=30., azim=0.):\n",
+    "    fig, ax1, ax2 = setup_figure()\n",
+    "    # create seeded random number generator\n",
+    "    rng = np.random.RandomState(1234)\n",
+    "    # create data provider\n",
+    "    data_provider = CCPPDataProvider(\n",
+    "        input_dims=[0, 1],\n",
+    "        batch_size=batch_size, \n",
+    "        shuffle_order=False,\n",
+    "    )\n",
+    "    learning_rate = 10 ** log_lr\n",
+    "    n_batches = data_provider.num_batches\n",
+    "    weights_traj = np.empty((n_inits, n_epochs * n_batches + 1, 1, 2))\n",
+    "    biases_traj = np.empty((n_inits, n_epochs * n_batches + 1, 1))\n",
+    "    errors_traj = np.empty((n_inits, n_epochs * n_batches))\n",
+    "    # randomly initialise parameters\n",
+    "    weights = rng.uniform(-w_scale, w_scale, (n_inits, 1, 2))\n",
+    "    biases = rng.uniform(-b_scale, b_scale, (n_inits, 1))\n",
+    "    # store initial parameters\n",
+    "    weights_traj[:, 0] = weights\n",
+    "    biases_traj[:, 0] = biases\n",
+    "    # iterate across different initialisations\n",
+    "    for i in range(n_inits):\n",
+    "        # iterate across epochs\n",
+    "        for e in range(n_epochs):\n",
+    "            # iterate across batches\n",
+    "            for b, (inputs, targets) in enumerate(data_provider):\n",
+    "                outputs = fprop(inputs, weights[i], biases[i])\n",
+    "                errors_traj[i, e * n_batches + b] = error(outputs, targets)\n",
+    "                grad_wrt_outputs = error_grad(outputs, targets)\n",
+    "                weights_grad, biases_grad = grads_wrt_params(inputs, grad_wrt_outputs)\n",
+    "                weights[i] -= learning_rate * weights_grad\n",
+    "                biases[i] -= learning_rate * biases_grad\n",
+    "                weights_traj[i, e * n_batches + b + 1] = weights[i]\n",
+    "                biases_traj[i, e * n_batches + b + 1] = biases[i]\n",
+    "    # choose a different color for each trajectory\n",
+    "    colors = plt.cm.jet(np.linspace(0, 1, n_inits))\n",
+    "    # plot all trajectories\n",
+    "    for i in range(n_inits):\n",
+    "        lines_1 = ax1.plot(\n",
+    "            weights_traj[i, :, 0, 0], \n",
+    "            weights_traj[i, :, 0, 1], \n",
+    "            biases_traj[i, :, 0], \n",
+    "            '-', c=colors[i], lw=2)\n",
+    "        lines_2 = ax2.plot(\n",
+    "            np.arange(n_batches * n_epochs),\n",
+    "            errors_traj[i],\n",
+    "            c=colors[i]\n",
+    "        )\n",
+    "    ax1.view_init(elev, azim)\n",
+    "    plt.show()\n",
+    "\n",
+    "w = interact(\n",
+    "    visualise_training,\n",
+    "    elev=(-90, 90, 2),\n",
+    "    azim=(-180, 180, 2), \n",
+    "    n_epochs=(1, 50), \n",
+    "    batch_size=(10, 1000, 100),\n",
+    "    log_lr=(-5., 1.),\n",
+    "    w_scale=(0., 4.),\n",
+    "    b_scale=(0., 4.),\n",
+    "    n_inits=(1, 10)\n",
+    ")\n",
+    "\n",
+    "for child in w.widget.children:\n",
+    "    child.layout.width = '100%'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hints:\n",
+    "- Remember an affine single layer model is an linear with respect to it's parameters, such that any given output $y$ can be expressed as $y = w_1 x_1 + w_2 x_2 + b$. Subsituting this into the loss function we have: \n",
+    "\\begin{equation}\n",
+    "    E =  \\sum_{n=1}^K \\frac{1}{2}  \\left( y^{(n)} - t^{(n)} \\right)^2 = \\sum_{n=1}^K \\frac{1}{2}  \\left( w_1 x_1^{(n)} + w_2 x_2^{(n)} + b - t^{(n)} \\right)^2.\n",
+    "\\end{equation}\n",
+    "The loss surface is therefore *quadratic* with respect to parameters $w_1, w_2, b$. What effect does this have on the number of minima?\n",
+    "\n",
+    "- Note that by using batch-wise updates, we are computing gradients of loss surface described by a subset $B < N$ of the training data:\n",
+    "\\begin{equation}\n",
+    "    E =  \\sum_{n=1}^B \\frac{1}{2}  \\left( y^{(n)} - t^{(n)} \\right)^2.\n",
+    "\\end{equation}\n",
+    "Hence, this gradient direction is only an approximation of the optimal update direction dictated by the full dataset. With very small batch sizes, what convergence behaviour would we therefore expect?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PyTorch\n",
+    "\n",
+    "PyTorch is a deep-learning framework that allows us to easily build and train neural networks. It is based on the concept of [tensors](https://pytorch.org/docs/stable/tensors.html), which are multidimensional arrays. In this section, we will use PyTorch to build a simple neural network and train it on the Combined Cycle Power Plant dataset dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset, DataLoader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To ensure [reproducibility](https://pytorch.org/docs/stable/notes/randomness.html), we wil set the seed of the random number generator to a fixed value.\n",
+    "\n",
+    "We will also use the same hyperparameters as in the previous section."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(seed)\n",
+    "\n",
+    "learning_rate = 1e-2\n",
+    "num_epochs = 10\n",
+    "batch_size = 100\n",
+    "input_dim = 2\n",
+    "output_dim = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To work with data in PyTorch, we need to create a [Dataset](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset) object. This object will be used by a [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) object to load the data in batches. The DataLoader object will also shuffle the data at each epoch. \n",
+    "\n",
+    "*Here, we do not shuffle the data by setting `shuffle=False` as we want to compare the results with the previous section. However, it is strongly advised to shuffle the data in the training set, but not in the validation or the test set. Can you think about why?*\n",
+    "\n",
+    "For a dataset to be used with PyTorch, it need to have the following methods:\n",
+    "- `__len__` : returns the size of the dataset,\n",
+    "- `__getitem__` : returns the $i^{\\textrm{th}}$ sample of the dataset.\n",
+    "\n",
+    "Also, the data needs to be converted to PyTorch tensors. This can be done by using the [TensorDataset](https://pytorch.org/docs/stable/data.html#torch.utils.data.TensorDataset) class or the `torch.from_numpy()` method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CCPPDataProvider(Dataset):\n",
+    "    \"\"\"Combined Cycle Power Plant dataset.\"\"\"\n",
+    "    \n",
+    "    def __init__(self, data_path, which_set='train', x_dims=None):\n",
+    "        super().__init__()\n",
+    "        self.data = np.load(data_path)\n",
+    "\n",
+    "        assert which_set in ['train', 'valid'], (\n",
+    "            'Expected which_set to be either train or valid '\n",
+    "            'Got {0}'.format(which_set)\n",
+    "        )\n",
+    "        self.x = self.data[which_set + '_inputs']\n",
+    "        if x_dims is not None:\n",
+    "            self.x = self.x[:, x_dims]\n",
+    "        self.x = torch.from_numpy(self.x).to(torch.float32)\n",
+    "        self.t = self.data[which_set + '_targets']\n",
+    "        self.t = torch.from_numpy(self.t).to(torch.float32)\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.x)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        return self.x[idx], self.t[idx]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `Linear` layer, also called a fully-connected layer perform the affine operation described above by combining the input data with the weights and biases."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SingleLayerModel(nn.Module):\n",
+    "    \"\"\"Single layer model.\"\"\"\n",
+    "    def __init__(self, input_dim, output_dim):\n",
+    "        super().__init__()\n",
+    "        self.layer = nn.Linear(input_dim, output_dim) \n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        return self.layer(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The weights and biases for each layer (neural network parameters) are initialized randomly but we can decide what distribution to sample from using the [`torch.init.module`](https://pytorch.org/docs/stable/nn.init.html). Here, we will use a uniform distribution for the weights and set the biases to 0."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def weights_init(m):\n",
+    "    \"\"\"Reinitialize model weights\"\"\"\n",
+    "    classname = m.__class__.__name__\n",
+    "    if classname.find('Linear') != -1:\n",
+    "        nn.init.uniform_(m.weight.data, -0.1, 0.1)\n",
+    "        nn.init.constant_(m.bias.data, 0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_path = os.path.join(os.environ['MLP_DATA_DIR'], 'ccpp_data.npz')\n",
+    "assert os.path.isfile(data_path), ('Data file does not exist at expected path: ' + data_path)\n",
+    "\n",
+    "dataset = CCPPDataProvider(data_path, which_set='train', x_dims=[0, 1])\n",
+    "\n",
+    "dataloader = DataLoader(dataset, batch_size=100, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The error between predictions and ground truth values is calculated using the means square error loss function. This function is implemented in PyTorch as [`torch.nn.MSELoss`](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html).\n",
+    "\n",
+    "There are many [optimisers](https://pytorch.org/docs/stable/optim.html#module-torch.optim) available in PyTorch. Here, we will use the [Adam](https://pytorch.org/docs/stable/optim.html#torch.optim.Adam) optimiser. This optimiser takes as input the parameters to optimise and the learning rate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = SingleLayerModel(input_dim, output_dim)\n",
+    "model.apply(weights_init)\n",
+    "\n",
+    "print(f\"Model structure: {model}\\n\\n\")\n",
+    "\n",
+    "loss = nn.MSELoss()  # Mean Squared Error loss\n",
+    "optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Adam optimiser"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The training loop will be similar to the one in the previous section. For every epoch, we will iterate through the datase by batches. For each batch, we will compute the predictions, the loss and the gradients. We will then update the parameters using the gradients and the optimiser.\n",
+    "\n",
+    "However, we will use the [`torch.optim.zero_grad()`](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html) method to set the gradients to zero before computing the gradients of the loss function with respect to the parameters. *Think about why we need to do this and what would happens if we do not?* \n",
+    "\n",
+    "We will also use the [`torch.optim.step()`](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.step.html) method to update the parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Keep track of the loss values over training\n",
+    "train_loss = [] \n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    epoch_loss = 0\n",
+    "\n",
+    "    for x, t in dataloader:\n",
+    "        y = model(x)\n",
+    "        E_value = loss(y, t)\n",
+    "        optimizer.zero_grad()\n",
+    "        E_value.backward()\n",
+    "        optimizer.step()\n",
+    "        epoch_loss += E_value.item()\n",
+    "    # Calculate average loss for this epoch\n",
+    "    avg_epoch_loss = epoch_loss / len(dataloader)\n",
+    "    print(f\"Epoch [{epoch+1}/{num_epochs}]\\tError(train): {avg_epoch_loss:.4f}\")\n",
+    "    train_loss.append(avg_epoch_loss)\n",
+    "\n",
+    "# Plot the change in the error over training.\n",
+    "fig = plt.figure(figsize=(8, 4))\n",
+    "ax = fig.add_subplot(111)\n",
+    "ax.plot(train_loss)\n",
+    "ax.set_xlabel('Epoch number')\n",
+    "ax.set_ylabel('Error')\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When the training is finished, we can compute the predictions and plot them along with the the ground truth values. \n",
+    "\n",
+    "Here, we will use the [`torch.no_grad()`](https://pytorch.org/docs/stable/generated/torch.no_grad.html) context manager to disable gradient calculation as we do not need it for the predictions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictions = []\n",
+    "inputs = []\n",
+    "targets = []\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    model.eval()\n",
+    "    for x, t in dataloader:\n",
+    "        inputs.append(x.numpy())\n",
+    "        targets.append(t.numpy())\n",
+    "        y = model(x)\n",
+    "        predictions.append(y.numpy())\n",
+    "        \n",
+    "predictions = np.concatenate(predictions, axis=0)\n",
+    "inputs = np.concatenate(inputs, axis=0)\n",
+    "targets = np.concatenate(targets, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot target and predicted outputs against inputs on same axis\n",
+    "fig = plt.figure(figsize=(8, 8))\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], targets[:, 0], 'r.', ms=2)\n",
+    "ax.plot(inputs[:, 0], inputs[:, 1], predictions[:, 0], 'b.', ms=2)\n",
+    "ax.set_xlabel('Input dim 1')\n",
+    "ax.set_ylabel('Input dim 2')\n",
+    "ax.set_zlabel('Output')\n",
+    "ax.legend(['Targets', 'Predictions'], frameon=False)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/res/._fprop-bprop-block-diagram.png b/notebooks/res/._fprop-bprop-block-diagram.png
new file mode 100644
index 0000000..939914a
Binary files /dev/null and b/notebooks/res/._fprop-bprop-block-diagram.png differ
diff --git a/notebooks/res/._jupyter-dashboard.png b/notebooks/res/._jupyter-dashboard.png
new file mode 100644
index 0000000..f0a4dc3
Binary files /dev/null and b/notebooks/res/._jupyter-dashboard.png differ
diff --git a/notebooks/res/._jupyter-notebook-interface.png b/notebooks/res/._jupyter-notebook-interface.png
new file mode 100644
index 0000000..dbda828
Binary files /dev/null and b/notebooks/res/._jupyter-notebook-interface.png differ
diff --git a/notebooks/res/._singleLayerNetBP-1.png b/notebooks/res/._singleLayerNetBP-1.png
new file mode 100644
index 0000000..ec10481
Binary files /dev/null and b/notebooks/res/._singleLayerNetBP-1.png differ
diff --git a/notebooks/res/._singleLayerNetPredict.png b/notebooks/res/._singleLayerNetPredict.png
new file mode 100644
index 0000000..750c3c3
Binary files /dev/null and b/notebooks/res/._singleLayerNetPredict.png differ
diff --git a/notebooks/res/._singleLayerNetWts-1.png b/notebooks/res/._singleLayerNetWts-1.png
new file mode 100644
index 0000000..1d943eb
Binary files /dev/null and b/notebooks/res/._singleLayerNetWts-1.png differ
diff --git a/notebooks/res/._singleLayerNetWtsEqns-1.png b/notebooks/res/._singleLayerNetWtsEqns-1.png
new file mode 100644
index 0000000..f714429
Binary files /dev/null and b/notebooks/res/._singleLayerNetWtsEqns-1.png differ
diff --git a/notebooks/res/fprop-bprop-block-diagram.pdf b/notebooks/res/fprop-bprop-block-diagram.pdf
new file mode 100644
index 0000000..6c5f0e0
Binary files /dev/null and b/notebooks/res/fprop-bprop-block-diagram.pdf differ
diff --git a/notebooks/res/fprop-bprop-block-diagram.png b/notebooks/res/fprop-bprop-block-diagram.png
new file mode 100644
index 0000000..17f6a8b
Binary files /dev/null and b/notebooks/res/fprop-bprop-block-diagram.png differ
diff --git a/notebooks/res/fprop-bprop-block-diagram.tex b/notebooks/res/fprop-bprop-block-diagram.tex
new file mode 100644
index 0000000..d2c2c7b
--- /dev/null
+++ b/notebooks/res/fprop-bprop-block-diagram.tex
@@ -0,0 +1,65 @@
+\documentclass[tikz]{standalone}
+
+\usepackage{amsmath}
+\usepackage{tikz}
+\usetikzlibrary{arrows}
+\usetikzlibrary{calc}
+\usepackage{ifthen}
+
+\newcommand{\vct}[1]{\boldsymbol{#1}}
+\newcommand{\pd}[2]{\frac{\partial #1}{\partial #2}}
+
+\tikzstyle{fprop} = [draw,fill=blue!20,minimum size=2em,align=center]
+\tikzstyle{bprop} = [draw,fill=red!20,minimum size=2em,align=center]
+
+\begin{document}
+
+\begin{tikzpicture}[xscale=1.75] %
+    % define number of layers
+    \def\nl{2};
+    % model input
+    \node at (0, 0) (input) {$\vct{x}$};
+    % draw fprop through model layers
+    \foreach \l in {0,...,\nl} {
+        \node[fprop] at (2 * \l + 1, 0) (fprop\l) {\texttt{layers[\l]} \\ \texttt{.fprop}};
+        \ifthenelse{\l > 0}{
+            \node at (2 * \l, 0) (hidden\l) {$\vct{h}_\l$};
+            \draw[->] (hidden\l) -- (fprop\l);
+            \draw[->] let \n1={\l - 1} in (fprop\n1) -- (hidden\l);
+        }{
+            \draw[->] (input) -- (fprop\l);
+        }
+    }
+    % model output
+    \node at (2 * \nl + 2, 0) (output) {$\mathbf{y}$};
+    % error function
+    \node[fprop] at (2 * \nl + 3, 0) (errorfunc) {\texttt{error}};
+    % error value
+    \node at (2 * \nl + 3, -1) (error) {$\bar{E}$};
+    % targets
+    \node at (2 * \nl + 4, -1) (tgt) {$\vct{t}$};
+    % error gradient
+    \node[bprop] at (2 * \nl + 3, -2) (errorgrad) {\texttt{error} \\ \texttt{.grad}};
+    % gradient wrt outputs
+    \node at (2 * \nl + 2, -2) (gradoutput) {$\pd{\bar{E}}{\vct{y}}$};
+    \draw[->] (fprop\nl) -- (output);
+    \draw[->] (output) -- (errorfunc);
+    \draw[->] (errorfunc) -- (error);
+    \draw[->] (error) -- (errorgrad);
+    \draw[->] (errorgrad) -- (gradoutput);
+    \draw[->] (tgt) |- (errorfunc);
+    \draw[->] (tgt) |- (errorgrad);
+    \foreach \l in {0,...,\nl} {
+        \node[bprop] at (2 * \l + 1, -2) (bprop\l) {\texttt{layers[\l]} \\ \texttt{.bprop}};
+        \ifthenelse{\l > 0}{
+            \node at (2 * \l, -2) (grad\l) {$\pd{\bar{E}}{\vct{h}_\l}$};
+            \draw[<-] (grad\l) -- (bprop\l);
+            \draw[<-] let \n1={\l - 1} in (bprop\n1) -- (grad\l);
+        }{}
+    }
+    \node at (0, -2) (gradinput) {$\pd{\bar{E}}{\vct{x}}$};
+    \draw[->] (bprop0) -- (gradinput);
+    \draw[->] (gradoutput) -- (bprop\nl);
+\end{tikzpicture}
+
+\end{document}
\ No newline at end of file