Repository: lava-nc/lava-dnf (language: python)

Issue:
Relational networks require an operation that sums across a diagonal of a DNF
Relational networks enable the representation of relative space. For instance, they enable representing the relative position of an object with respect to another object. This can be implemented with two DNFs, A and B, of the same dimensionality N that both project into a transformational DNF, T, of dimensionality 2*N. The output of T is then projected onto another DNF, C, which has the original dimensionality N. For C to express the relative position of A with respect to B, the projection from T to C must sum across the diagonal of T. This type of projection must be added to lava-dnf to support implementing relational networks.

The projection should probably be implemented as an operation `ProjectDiagonal`, to be used as part of the `connect()` function of lava-dnf.


Discussion / hints:

Fix patch:
diff --git a/src/lava/lib/dnf/operations/operations.py b/src/lava/lib/dnf/operations/operations.py
index 04c6b2e..ec591fc 100644
--- a/src/lava/lib/dnf/operations/operations.py
+++ b/src/lava/lib/dnf/operations/operations.py
@@ -9,10 +9,13 @@
 from lava.lib.dnf.utils.convenience import num_neurons
 from lava.lib.dnf.operations.shape_handlers import (
     AbstractShapeHandler,
-    KeepShapeHandler,
-    ReduceDimsHandler,
-    ExpandDimsHandler,
-    ReorderHandler)
+    KeepShapeShapeHandler,
+    ReduceDimsShapeHandler,
+    ExpandDimsShapeHandler,
+    ReorderDimsShapeHandler,
+    ReduceAlongDiagonalShapeHandler,
+    ExpandAlongDiagonalShapeHandler,
+    FlipShapeHandler)
 from lava.lib.dnf.operations.enums import ReduceMethod, BorderType
 from lava.lib.dnf.kernels.kernels import Kernel
 from lava.lib.dnf.utils.convenience import num_dims
@@ -110,7 +113,7 @@ class Weights(AbstractOperation):
 
     """
     def __init__(self, weight: float) -> None:
-        super().__init__(KeepShapeHandler())
+        super().__init__(KeepShapeShapeHandler())
         self.weight = weight
 
     def _compute_weights(self) -> np.ndarray:
@@ -136,7 +139,7 @@ def __init__(self,
                  reduce_dims: ty.Union[int, ty.Tuple[int, ...]],
                  reduce_method: ty.Optional[ReduceMethod] = ReduceMethod.SUM
                  ) -> None:
-        super().__init__(ReduceDimsHandler(reduce_dims))
+        super().__init__(ReduceDimsShapeHandler(reduce_dims))
         ReduceMethod.validate(reduce_method)
         self.reduce_method = reduce_method
 
@@ -145,7 +148,7 @@ def _compute_weights(self) -> np.ndarray:
         # that will not be removed
         in_axes_all = np.arange(num_dims(self.input_shape))
 
-        sh = ty.cast(ReduceDimsHandler, self._shape_handler)
+        sh = ty.cast(ReduceDimsShapeHandler, self._shape_handler)
         in_axes_kept = tuple(np.delete(in_axes_all, sh.reduce_dims))
 
         # Generate the weight matrix
@@ -168,7 +171,7 @@ class ExpandDims(AbstractOperation):
     """
     def __init__(self,
                  new_dims_shape: ty.Union[int, ty.Tuple[int, ...]]) -> None:
-        super().__init__(ExpandDimsHandler(new_dims_shape))
+        super().__init__(ExpandDimsShapeHandler(new_dims_shape))
 
     def _compute_weights(self) -> np.ndarray:
         # Indices of the output dimensions in the weight matrix that will
@@ -183,7 +186,7 @@ def _compute_weights(self) -> np.ndarray:
         return weights
 
 
-class Reorder(AbstractOperation):
+class ReorderDims(AbstractOperation):
     """
     Operation that reorders the dimensions in the input to a specified new
     order.
@@ -191,14 +194,14 @@ class Reorder(AbstractOperation):
     Parameters
     ----------
     order : tuple(int)
-        new order of the dimensions (see ReorderHandler)
+        new order of the dimensions (see ReorderDimsShapeHandler)
 
     """
     def __init__(self, order: ty.Tuple[int, ...]) -> None:
-        super().__init__(ReorderHandler(order))
+        super().__init__(ReorderDimsShapeHandler(order))
 
     def _compute_weights(self) -> np.ndarray:
-        sh = ty.cast(ReorderHandler,
+        sh = ty.cast(ReorderDimsShapeHandler,
                      self._shape_handler)
         weights = _project_dims(self.input_shape,
                                 self.output_shape,
@@ -330,7 +333,7 @@ def __init__(
                                            ty.List[BorderType]]]
             = BorderType.PADDED
     ) -> None:
-        super().__init__(KeepShapeHandler())
+        super().__init__(KeepShapeShapeHandler())
 
         self._kernel = self._validate_kernel(kernel)
         self._border_types = self._validate_border_types(border_types)
@@ -390,7 +393,7 @@ def _compute_weights(self) -> np.ndarray:
         # Input shape equals output shape
         shape = self.input_shape
         # Do not use num_dims() here to treat 0D like 1D
-        num_dims = len(shape)
+        _num_dims = len(shape)
         _num_neurons = num_neurons(shape)
 
         # Generate a dense connectivity matrix
@@ -399,13 +402,13 @@ def _compute_weights(self) -> np.ndarray:
         # Copy the weights of the kernel
         kernel_weights = np.copy(self.kernel.weights)
 
-        for i in range(num_dims):
+        for i in range(_num_dims):
             # Compute the size difference between the population and the
             # kernel in the current dimension
             size_diff = shape[i] - np.size(kernel_weights, axis=i)
 
             if size_diff != 0:
-                pad_width = np.zeros((num_dims, 2), dtype=int)
+                pad_width = np.zeros((_num_dims, 2), dtype=int)
                 pad_width[i, :] = int(np.floor(np.abs(size_diff) / 2.0))
                 # If the padding cannot be distributed evenly...
                 if is_odd(size_diff):
@@ -447,7 +450,7 @@ def _compute_weights(self) -> np.ndarray:
             conn_weights = kernel_weights
 
             # Shift the weights depending on the border method
-            for i in range(num_dims):
+            for i in range(_num_dims):
                 if self.border_types[i] == BorderType.CIRCULAR:
                     conn_weights = np.roll(conn_weights, -shift[i], axis=i)
                 elif self.border_types[i] == BorderType.PADDED:
@@ -467,7 +470,7 @@ def _compute_weights(self) -> np.ndarray:
                                                  axis=i)
 
             # Flatten kernel matrix
-            if num_dims > 1:
+            if _num_dims > 1:
                 conn_weights = np.ravel(conn_weights)
 
             # Fill the connectivity matrix
@@ -520,3 +523,122 @@ def _shift_fill(array: np.ndarray,
             return shifted_array
         else:
             return array
+
+
+class ReduceAlongDiagonal(AbstractOperation):
+    """
+    Creates connectivity that projects the output of a source population
+    along its diagonal. For instance, if the source population is a grid of
+    neurons of shape (40, 40), the operation will project (sum) the output of
+    that two-dimensional population along its diagonal, yielding a
+    one-dimensional output of shape (79,). The output size is computed by
+    79 = 40 * 2 - 1.
+    """
+    def __init__(self) -> None:
+        super().__init__(ReduceAlongDiagonalShapeHandler())
+
+    def _compute_weights(self) -> np.ndarray:
+        weights = np.zeros(self.output_shape + self.input_shape,
+                           dtype=np.int32)
+
+        # Extract the original shape of the source populations.
+        # This assumes that self.input_shape = shape + shape.
+        # For instance if the input shape is (40, 30, 40, 30),
+        # half_in_shape would be (40, 30).
+        half_in_shape = self.input_shape[0:num_dims(self.output_shape)]
+
+        # Iterate over all positions within the output shape.
+        # 'x' will be a tuple of the dimensionality of the output shape.
+        for x in np.ndindex(*self.output_shape):
+            x = np.array(x)
+            # Iterate over all positions within 'half_in_shape'.
+            # 'p' will be a tuple of the dimensionality of 'half_in_shape'
+            for p in np.ndindex(*half_in_shape):
+                p = np.array(p)
+
+                # Set weights[x, x-p, p] = 1, where 0 <= x-p < half_in_shape
+                d = x - p
+                if np.all(0 <= d) and np.all(d < np.array(half_in_shape)):
+                    idx = tuple(np.concatenate([x, d, p]))
+                    weights[idx] = 1
+
+        # Reshape weights matrix to 2D
+        return weights.reshape(num_neurons(self.output_shape),
+                               num_neurons(self.input_shape))
+
+
+class ExpandAlongDiagonal(AbstractOperation):
+    """
+    Creates connectivity that projects the output of a source population
+    onto the diagonal of the target population, where the target
+    population has twice the number of dimensions as the source
+    population. The dimensions of the source population can only have odd
+    sizes. For instance, if the source population is a grid of
+    neurons of shape (99, 79), the operation will project the output of
+    that two-dimensional population into a 4D target population of shape
+    (50, 40, 50, 40) along its diagonal. Each entry in the output shape is
+    computed by out_size = (in_size + 1) / 2.
+    """
+    def __init__(self) -> None:
+        super().__init__(ExpandAlongDiagonalShapeHandler())
+
+    def _compute_weights(self) -> np.ndarray:
+        weights = np.zeros(self.output_shape + self.input_shape,
+                           dtype=np.int32)
+
+        # Extract one half of the output shape, for instance if the output
+        # shape is (40, 30, 40, 30), half_out_shape would be (40, 30)
+        half_out_shape = self.output_shape[0:num_dims(self.input_shape)]
+
+        # Iterate over all positions within the input shape.
+        # 'x' will be a tuple of the dimensionality of 'input_shape'
+        for x in np.ndindex(*self.input_shape):
+            x = np.array(x)
+            # Iterate over all positions within 'half_out_shape'.
+            # 'p' will be a tuple of the dimensionality of 'half_out_shape'
+            for p in np.ndindex(*half_out_shape):
+                p = np.array(p)
+
+                # Set weights[x-p, p, x] = 1, where 0 <= x-p < half_out_shape
+                d = x - p
+                if np.all(0 <= d) and np.all(d < np.array(half_out_shape)):
+                    idx = tuple(np.concatenate([d, p, x]))
+                    weights[idx] = 1
+
+        # Reshape weights matrix to 2D
+        return weights.reshape(num_neurons(self.output_shape),
+                               num_neurons(self.input_shape))
+
+
+class Flip(AbstractOperation):
+    """
+    Creates connectivity that flips all specified dimensions.
+
+    Parameters
+    ----------
+    dims : tuple(int) or int
+        indices of the dimensions that are to be flipped
+    """
+    def __init__(
+        self,
+        dims: ty.Optional[ty.Union[int, ty.Tuple[int, ...]]] = None
+    ) -> None:
+        super().__init__(FlipShapeHandler(dims=dims))
+
+    def _compute_weights(self) -> np.ndarray:
+        shape = (num_neurons(self.output_shape), num_neurons(self.input_shape))
+        # Set up connectivity weights that project input to output one-to-one
+        weights = np.eye(*shape, dtype=np.int32)
+        # Reshape the connectivity matrix to explicitly represent the input
+        # dimensions
+        weights = weights.reshape((num_neurons(self.output_shape),)
+                                  + self.input_shape)
+        # Get the indices of the dimensions that are to be flipped from the
+        # shape handler and increase them all by one
+        sh = ty.cast(FlipShapeHandler, self._shape_handler)
+        dims = np.array(sh.dims) + 1
+        # Flip those dimensions
+        weights = np.flip(weights, axis=tuple(dims))
+
+        # Reshape the connectivity matrix back to 2D
+        return weights.reshape(shape)
diff --git a/src/lava/lib/dnf/operations/shape_handlers.py b/src/lava/lib/dnf/operations/shape_handlers.py
index a36db93..a7eccd5 100644
--- a/src/lava/lib/dnf/operations/shape_handlers.py
+++ b/src/lava/lib/dnf/operations/shape_handlers.py
@@ -6,11 +6,10 @@
 import typing as ty
 import numpy as np
 
-from lava.lib.dnf.utils.convenience import num_neurons
+from lava.lib.dnf.utils.convenience import num_neurons, num_dims
+from lava.lib.dnf.utils.math import is_odd
 from lava.lib.dnf.operations.exceptions import MisconfiguredOpError
 
-from lava.lib.dnf.utils.convenience import num_dims
-
 
 class AbstractShapeHandler(ABC):
     """
@@ -70,7 +69,7 @@ def _validate_input_shape(self,
         pass
 
 
-class KeepShapeHandler(AbstractShapeHandler):
+class KeepShapeShapeHandler(AbstractShapeHandler):
     """Shape handler for operations that do not change the shape of the
      input."""
     def _compute_output_shape(self) -> None:
@@ -84,7 +83,7 @@ def _validate_input_shape(self,
         pass
 
 
-class ReduceDimsHandler(AbstractShapeHandler):
+class ReduceDimsShapeHandler(AbstractShapeHandler):
     """
     Shape handler for operations that reduce the dimensionality of the
     input.
@@ -128,16 +127,10 @@ def _validate_args(self) -> None:
                              f"more entries than the shape of the input "
                              f"{self._input_shape}")
 
-        for idx in self.reduce_dims:
-            # Compute the positive index irrespective of the sign of 'idx'
-            idx_positive = len(self._input_shape) + idx if idx < 0 else idx
-            # Make sure the positive index is not out of bounds
-            if idx_positive < 0 or idx_positive >= len(self._input_shape):
-                raise IndexError(f"<reduce_dims> value {idx} is out of bounds "
-                                 f"for array of size {len(self._input_shape)}")
+        _check_index_bounds(self.reduce_dims, self._input_shape)
 
 
-class ExpandDimsHandler(AbstractShapeHandler):
+class ExpandDimsShapeHandler(AbstractShapeHandler):
     """Shape handler for operations that expand the dimensionality. New
     dimensions (axes) will be appended to the already existing ones of the
     input. Their sizes must be specified using the <new_dims_shape> argument.
@@ -187,7 +180,7 @@ def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
         pass
 
 
-class ReshapeHandler(AbstractShapeHandler):
+class ReshapeShapeHandler(AbstractShapeHandler):
     """Shape handler for operations that reshape the input, changing
     the shape but keeping the number of elements constant.
 
@@ -213,7 +206,7 @@ def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
         pass
 
 
-class ReorderHandler(AbstractShapeHandler):
+class ReorderDimsShapeHandler(AbstractShapeHandler):
     """Shape handler for operations that reorder the input shape.
 
     Parameters
@@ -247,13 +240,7 @@ def _validate_args(self) -> None:
                                        f"len({self._order}) != len("
                                        f"{self._input_shape})")
 
-        for idx in self._order:
-            # Compute the positive index irrespective of the sign of 'idx'
-            idx_positive = len(self._input_shape) + idx if idx < 0 else idx
-            # Make sure the positive index is not out of bounds
-            if idx_positive < 0 or idx_positive >= len(self._input_shape):
-                raise IndexError(f"<order> value {idx} is out of bounds "
-                                 f"for array of size {len(self._input_shape)}")
+        _check_index_bounds(self._order, self._input_shape)
 
     def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
         num_dims_in = num_dims(input_shape)
@@ -262,3 +249,115 @@ def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
             raise MisconfiguredOpError("the input dimensionality "
                                        "is smaller than 2; there are no "
                                        "dimensions to reorder")
+
+
+class ReduceAlongDiagonalShapeHandler(AbstractShapeHandler):
+    """Shape handler for the ReduceAlongDiagonal operation, which projects
+    diagonally from a multi-dimensional population.
+    """
+    def __init__(self) -> None:
+        super().__init__()
+
+    def _compute_output_shape(self) -> None:
+        num_dims_in = num_dims(self._input_shape)
+        shape = np.array(self._input_shape[0:int(num_dims_in / 2)])
+        self._output_shape = tuple(shape * 2 - 1)
+
+    def _validate_args(self) -> None:
+        pass
+
+    def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
+        num_dims_in = num_dims(input_shape)
+
+        if is_odd(num_dims_in):
+            raise MisconfiguredOpError("the input dimensionality must be even")
+
+        first_half = input_shape[0:int(num_dims_in / 2)]
+        second_half = input_shape[int(num_dims_in / 2):]
+
+        if first_half != second_half:
+            raise MisconfiguredOpError(
+                f"the first half of the input shape {first_half} must be "
+                f"identical to the second half {second_half}")
+
+
+class ExpandAlongDiagonalShapeHandler(AbstractShapeHandler):
+    """Shape handler for the ExpandAlongDiagonal operation, which projects
+    diagonally onto a multi-dimensional population.
+    """
+    def __init__(self) -> None:
+        super().__init__()
+
+    def _compute_output_shape(self) -> None:
+        half_shape = (np.array(self._input_shape) + 1) / 2
+        half_shape = tuple(half_shape.astype(int))
+        self._output_shape = half_shape + half_shape
+
+    def _validate_args(self) -> None:
+        pass
+
+    def _validate_input_shape(self, input_shape: ty.Tuple[int, ...]) -> None:
+        for size in input_shape:
+            if not is_odd(size):
+                raise MisconfiguredOpError("all dimensions of the input must "
+                                           f"have an odd size; {size} is not "
+                                           "odd")
+
+
+class FlipShapeHandler(KeepShapeShapeHandler):
+    """Shape handler for the Flip operation that flips specified dimensions.
+
+    Parameters
+    ----------
+    dims : tuple(int) or int
+        indices of the dimensions that are to be flipped
+    """
+    def __init__(
+        self,
+        dims: ty.Optional[ty.Union[int, ty.Tuple[int, ...]]] = None
+    ) -> None:
+        super().__init__()
+        self._dims = dims
+
+    @property
+    def dims(self) -> ty.Tuple[int, ...]:
+        """Return the <dims> that are to be flipped"""
+        return self._dims
+
+    def _validate_args(self) -> None:
+        """Validate the <dims> argument"""
+        num_dims_in = num_dims(self._input_shape)
+
+        if self._dims is None:
+            self._dims = tuple(range(num_dims_in))
+
+        if len(self._dims) > num_dims_in:
+            raise MisconfiguredOpError("<dims> may only have as many entries "
+                                       "as the input shape: "
+                                       f"len({self._dims}) > len("
+                                       f"{self._input_shape})")
+
+        _check_index_bounds(self._dims, self._input_shape)
+
+
+def _check_index_bounds(indices: ty.Tuple[int, ...],
+                        shape: ty.Tuple[int, ...]) -> None:
+    """Checks whether all of the given indices are not out of bounds for the
+    given shape. Throws an IndexError if violated.
+
+    Parameters
+    ----------
+    indices : tuple(int)
+        indices of the dimensions that are to be checked
+    shape : tuple(int)
+        shape of the array that the indices will address and that will be
+        checked against
+
+    """
+    for idx in indices:
+        # Compute the positive index irrespective of the sign of 'idx'
+        idx_positive = len(shape) + idx if idx < 0 else idx
+        # Make sure the positive index is not out of bounds
+        if idx_positive < 0 or idx_positive >= len(shape):
+            raise IndexError(f"index value {idx} is out of bounds "
+                             f"for array of size {len(shape)}")
diff --git a/tutorials/lava/lib/dnf/dnf_101/tutorial_dnf_101.ipynb b/tutorials/lava/lib/dnf/dnf_101/tutorial_dnf_101.ipynb
index 5faf750..be209a3 100644
--- a/tutorials/lava/lib/dnf/dnf_101/tutorial_dnf_101.ipynb
+++ b/tutorials/lava/lib/dnf/dnf_101/tutorial_dnf_101.ipynb
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -49,13 +49,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1e8b8f70>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from lava.lib.dnf.connect.connect import connect\n",
     "from lava.lib.dnf.operations.operations import Weights\n",
@@ -81,13 +92,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e7f4bf4f0>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from lava.lib.dnf.kernels.kernels import MultiPeakKernel\n",
     "from lava.lib.dnf.operations.operations import Convolution\n",
@@ -114,13 +136,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1c8524c0>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from lava.lib.dnf.kernels.kernels import SelectiveKernel\n",
     "\n",
@@ -150,7 +183,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -204,7 +237,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -227,13 +260,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1e8d4460>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# Make sure to specify 'mean' and 'stddev' as 2D vectors\n",
     "gauss_pattern = GaussPattern(shape=shape,\n",
@@ -265,13 +309,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1eb49070>"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "dnf1 = LIF(shape=(10,))\n",
     "dnf2 = LIF(shape=(10,))\n",
@@ -295,13 +350,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1edd92b0>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "dnf1 = LIF(shape=(10,))\n",
     "dnf2 = LIF(shape=(10,))\n",
@@ -322,13 +388,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1ede60a0>"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from lava.lib.dnf.operations.operations import ReduceDims\n",
     "from lava.lib.dnf.operations.enums import ReduceMethod\n",
@@ -354,13 +431,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1ede6b20>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from lava.lib.dnf.operations.operations import ExpandDims\n",
     "\n",
@@ -376,27 +464,133 @@
    "metadata": {},
    "source": [
     "### Reordering dimensions\n",
-    "To reorder dimensions, use the `Reorder` operation, specifying the indices of the dimension in their new order."
+    "To reorder dimensions, use the `ReorderDims` operation, specifying the indices of the dimension in their new order."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1edf8250>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "from lava.lib.dnf.operations.operations import Reorder\n",
+    "from lava.lib.dnf.operations.operations import ReorderDims\n",
     "\n",
     "\n",
     "dnf_1 = LIF(shape=(10, 20))\n",
     "dnf_2 = LIF(shape=(20, 10))\n",
     "\n",
     "# map dimensions (0, 1) of dnf_1 to dimensions (1, 0) of dnf_2\n",
-    "connect(dnf_1.s_out, dnf_2.a_in, ops=[Reorder(order=(1, 0))])"
+    "connect(dnf_1.s_out, dnf_2.a_in, ops=[ReorderDims(order=(1, 0))])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Flipping dimensions\n",
+    "To flip dimensions, use the `Flip` operation, specifying the indices of the dimensions that should be flipped. The operation will map the first neuron of the input population to the last of the output population, the second to the second last, and so on."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1edd1760>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from lava.lib.dnf.operations.operations import Flip\n",
+    "\n",
+    "dnf_1 = LIF(shape=(10, 20))\n",
+    "dnf_2 = LIF(shape=(10, 20))\n",
+    "\n",
+    "# connect the DNFs and flip the dimension of size 20\n",
+    "connect(dnf_1.s_out, dnf_2.a_in, ops=[Flip(dims=(1,))])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Projecting along a diagonal\n",
+    "The operation `ReduceAlongDiagonal` sums the output of a higher-dimensional population of neurons along its main diagonal diagonal onto a lower-dimensional population. The operation `ExpandAlongDiagonal` does the inverse and projects a ridge of input from a lower-dimensional population into a higher-dimensional population along its main diagonal.\n",
+    "They both enable building relational networks (see the dedicated\n",
+    "[tutorial on relational networks](../relational_networks/tutorial_relational_networks.ipynb \"Tutorial on relational networks\"))."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1e8dd790>"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from lava.lib.dnf.operations.operations import ReduceAlongDiagonal\n",
+    "\n",
+    "dnf_2d = LIF(shape=(40, 40))\n",
+    "relational_dnf_1d = LIF(shape=(79,))  # shape=(40 * 2 - 1,)\n",
+    "\n",
+    "connect(dnf_2d.s_out, relational_dnf_1d.a_in, ops=[ReduceAlongDiagonal()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1e8c1b50>"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from lava.lib.dnf.operations.operations import ExpandAlongDiagonal\n",
+    "\n",
+    "relational_dnf_1d = LIF(shape=(79,))\n",
+    "dnf_2d = LIF(shape=(40, 40))  # shape=((79+1)/2, (79+1)/2)\n",
+    "\n",
+    "\n",
+    "connect(relational_dnf_1d.s_out, dnf_2d.a_in, ops=[ExpandAlongDiagonal()])"
    ]
   },
   {
@@ -413,19 +607,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<lava.proc.dense.process.Dense at 0x25e1edfb880>"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "dnf_1d = LIF(shape=(10,))\n",
     "dnf_2d = LIF(shape=(20, 10))\n",
     "\n",
     "connect(dnf_1d.s_out, dnf_2d.a_in, ops=[ExpandDims(new_dims_shape=20),\n",
-    "                                        Reorder(order=(1, 0)),\n",
+    "                                        ReorderDims(order=(1, 0)),\n",
     "                                        Weights(20)])"
    ]
   },
@@ -446,7 +651,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
diff --git a/tutorials/lava/lib/dnf/relational_networks/diagram_relational_network.png b/tutorials/lava/lib/dnf/relational_networks/diagram_relational_network.png
new file mode 100644
index 0000000..583937a
Binary files /dev/null and b/tutorials/lava/lib/dnf/relational_networks/diagram_relational_network.png differ
diff --git a/tutorials/lava/lib/dnf/relational_networks/tutorial_relational_networks.ipynb b/tutorials/lava/lib/dnf/relational_networks/tutorial_relational_networks.ipynb
new file mode 100644
index 0000000..75b52f1
--- /dev/null
+++ b/tutorials/lava/lib/dnf/relational_networks/tutorial_relational_networks.ipynb
@@ -0,0 +1,333 @@
+{
+ "cells": [
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Copyright (C) 2021 Intel Corporation*<br>\n",
+    "*SPDX-License-Identifier: BSD-3-Clause*<br>\n",
+    "*See: https://spdx.org/licenses/*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "# Relational networks\n",
+    "\n",
+    "This tutorial demonstrates how to set up a relational network with lava-dnf.\n",
+    "\n",
+    "Relational networks are a network topology composed of DNFs that enables representing relational features, for example the difference/error between two represented values. In DFT, relational networks are one of the major building blocks of larger architectures, most often employed to implement coordinate transforms between different spaces (e.g., retinal vs. allocentric visual space).\n",
+    "\n",
+    "![Diagram relational network](./diagram_relational_network.png)\n",
+    "\n",
+    "The figure above illustrates the network topology. Two 1D DNFs, ‘target’ and ‘reference’, are input into a 2D-dimensional ‘transformation’ DNF that represents all possible combinations of the positions in the two DNFs. The 1D DNFs project into the ‘transformation’ DNF, forming subthreshold ridges of activation; only regions in which the ridges overlap form peaks. This activation projects along the diagonal onto the ‘relational’ DNF. The peaks that form there represent the peak-positions in the ‘target’ DNF relative to the position of the peak-position in the ‘reference’ DNF (center of the ‘relational’ DNF).\n",
+    "The diagram visualizes an example with one-dimensional input and output DNFs but the same concept can be applied to higher-dimensional input/output.\n",
+    "\n",
+    "In lava-dnf, relational networks can be constructed from basic Lava Processes, like the LIF Processes, and connectivity structures that can be generated with the `connect` function from lava-dnf. The following example demonstrates a relational network with one-dimensional input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from lava.magma.core.run_configs import Loihi1SimCfg\n",
+    "from lava.magma.core.run_conditions import RunSteps\n",
+    "from lava.proc.lif.process import LIF\n",
+    "from lava.proc.monitor.process import Monitor\n",
+    "\n",
+    "from lava.lib.dnf.connect.connect import connect\n",
+    "from lava.lib.dnf.inputs.gauss_pattern.process import GaussPattern\n",
+    "from lava.lib.dnf.inputs.rate_code_spike_gen.process import \\\n",
+    "    RateCodeSpikeGen\n",
+    "from lava.lib.dnf.operations.operations import (\n",
+    "    Weights,\n",
+    "    ExpandDims,\n",
+    "    ReorderDims,\n",
+    "    ReduceAlongDiagonal,\n",
+    "    ExpandAlongDiagonal,\n",
+    "    Flip)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "shape = (15,)\n",
+    "shape_relational = tuple(np.array(shape) * 2 - 1)\n",
+    "num_time_steps = 100\n",
+    "\n",
+    "# Set up Processes\n",
+    "gauss_target = GaussPattern(shape=shape, amplitude=5000, mean=8, stddev=0.1)\n",
+    "sg_target = RateCodeSpikeGen(shape=shape)\n",
+    "\n",
+    "gauss_reference = GaussPattern(shape=shape, amplitude=5000, mean=5, stddev=0.1)\n",
+    "sg_reference = RateCodeSpikeGen(shape=shape)\n",
+    "\n",
+    "target = LIF(shape=shape, du=409, dv=2045, vth=200)\n",
+    "reference = LIF(shape=shape, du=409, dv=2045, vth=200)\n",
+    "transformation = LIF(shape=shape + shape, du=409, dv=2045, vth=200)\n",
+    "relational = LIF(shape=shape_relational, du=409, dv=2045, vth=200)\n",
+    "\n",
+    "# Connect Processes\n",
+    "gauss_target.a_out.connect(sg_target.a_in)\n",
+    "connect(sg_target.s_out, target.a_in, ops=[Weights(25)])\n",
+    "\n",
+    "gauss_reference.a_out.connect(sg_reference.a_in)\n",
+    "connect(sg_reference.s_out, reference.a_in, ops=[Weights(25)])\n",
+    "\n",
+    "connect(target.s_out, transformation.a_in,\n",
+    "        ops=[ExpandDims(new_dims_shape=shape[0]),\n",
+    "             Weights(10)])\n",
+    "connect(reference.s_out, transformation.a_in,\n",
+    "        ops=[Flip(),\n",
+    "             ExpandDims(new_dims_shape=shape[0]),\n",
+    "             ReorderDims(order=(1, 0)),\n",
+    "             Weights(10)])\n",
+    "weights_reduce_diag = connect(transformation.s_out, relational.a_in,\n",
+    "                              ops=[ReduceAlongDiagonal(), Weights(25)])\n",
+    "weights_expand_diag = connect(relational.s_out, transformation.a_in,\n",
+    "                              ops=[ExpandAlongDiagonal(), Weights(5)])\n",
+    "\n",
+    "# Set up monitors\n",
+    "monitor_target = Monitor()\n",
+    "monitor_target.probe(target.s_out, num_time_steps)\n",
+    "\n",
+    "monitor_reference = Monitor()\n",
+    "monitor_reference.probe(reference.s_out, num_time_steps)\n",
+    "\n",
+    "monitor_transformation = Monitor()\n",
+    "monitor_transformation.probe(transformation.v, num_time_steps)\n",
+    "\n",
+    "monitor_relational = Monitor()\n",
+    "monitor_relational.probe(relational.s_out, num_time_steps)\n",
+    "\n",
+    "# Execution\n",
+    "try:\n",
+    "    target.run(condition=RunSteps(num_steps=num_time_steps),\n",
+    "               run_cfg=Loihi1SimCfg(select_tag='bit_accurate_loihi'))\n",
+    "\n",
+    "    # Extract data from monitors\n",
+    "    data_target = monitor_target.get_data() \\\n",
+    "        [target.name][target.s_out.name].astype(float)\n",
+    "\n",
+    "    data_reference = monitor_reference.get_data() \\\n",
+    "        [reference.name][reference.s_out.name].astype(float)\n",
+    "\n",
+    "    data_transformation = monitor_transformation.get_data() \\\n",
+    "        [transformation.name][transformation.v.name].astype(float)\n",
+    "\n",
+    "    data_relational = monitor_relational.get_data() \\\n",
+    "        [relational.name][relational.s_out.name].astype(float)\n",
+    "\n",
+    "    data_weights_reduce_diag = \\\n",
+    "        weights_reduce_diag.weights.get().astype(float)\n",
+    "    data_weights_expand_diag = \\\n",
+    "        weights_expand_diag.weights.get().astype(float)\n",
+    "finally:\n",
+    "    target.stop()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAALICAYAAABiqwZ2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAACIvUlEQVR4nOzdeXydZZ3+8c+VdN9butCmKS1QllKglKS4IILIplhcgIbRGXDDmRGXUWdEZ0bQGX/jMouOOqPoIKhIS1m0LAqICC5gk5a2tJSlFGiStrR039sk398f5wkc0mxtcs5zTnK9X6/zOufcz3YlhZNv7tz3/SgiMDMzMzOzjJK0A5iZmZmZFRIXyGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZmZmZWRYXyGZmZmZmWVwgm5mZmZllcYFsZlaAJO3MejRJ2pP1/v15ynC2pLp8XMvMrJD0STuAmZkdLCKGNL+W9CLwkYj4zaGcQ1KfiGjo7mxmZj2de5DNzIqIpFmSHpO0VdI6Sd+V1C9re0j6uKTngOeStn9I9l0r6SPJPscm2/pL+ndJayS9LOn7kgZKGgz8CpiQ1XM9IZUv2swsz1wgm5kVl0bg74DRwBuBc4G/bbHPu4EzgGmSLgQ+A7wdOBY4u8W+XwOOA2Yk28uAL0XELuAiYG1EDEkea3Pw9ZiZFRwXyGZmRSQiFkXE4xHREBEvAj8A3tpit3+LiM0RsQe4HPhxRKyIiN3A9c07SRJwNfB3yf47gP8HVOXjazEzK1Qeg2xmVkQkHQf8J1ABDCLzOb6oxW61Wa8nADVtbBuTnGNRplbOXAIo7cbIZmZFxz3IZmbF5X+Bp4GpETEM+CKZojZbZL1eB0zMel+e9foVYA9wUkSMSB7DsyYIZp/HzKzXcIFsZlZchgLbgZ2STgD+poP9bwM+KOlESYOAf27eEBFNwA+B/5I0FkBSmaQLkl1eBo6QNLy7vwgzs0LmAtnMrLh8DvgLYAeZ4nZeeztHxK+A/wYeBlYBjyeb9iXPn29ul7Qd+A1wfHLs08CtwOpk1QyvYmFmvYIi/Bc0M7PeQtKJwHKgv9dINjNrnXuQzcx6OEnvSdY7Hgl8HbjbxbGZWdtcIJuZ9XwfAzYAz5NZR7mjcctmZr2ah1iYmZmZmWVxD7KZmZmZWZYec6OQ0aNHx+TJk9OOYWZmZmZFYtGiRa9ExJiW7T2mQJ48eTI1NTUd72hmZmZmBkh6qbV2D7EwMzMzM8uSswJZ0o2SNkha3sZ2SfpvSaskLZM0M2vblZKeSx5X5iqjmZmZmVlLuexBvgm4sJ3tFwFTk8fVwP8CSBoFXAecAcwCrkvW7jQzMzMzy7mcFcgR8SiwuZ1dLgF+EhmPAyMkjQcuAB6MiM0RsQV4kPYLbTMzK3Lrtu3hom//nuX129KOYmaW6hjkMqA2631d0tZW+0EkXS2pRlLNxo0bcxbUzMxy69aFtaxct50b//BC2lHMzIp7kl5E3BARFRFRMWbMQSt0mJlZEWhsCubXZPpF7n1yHdv2HEg5kZn1dmkWyPVAedb7iUlbW+1mZtYDPfrcRtZt28vHzzmGfQ1NLFjij3wzS1eaBfIC4K+S1SzeAGyLiHXA/cD5kkYmk/POT9rMzKwHmrtwDUcM7senzj2OkyYM49aFtURE2rHMrBfL5TJvtwKPAcdLqpP0YUl/Lemvk13uA1YDq4AfAn8LEBGbgX8BqpPHV5I2MzPrYTbs2MtDKzfwvtMn0q9PCVWV5Ty1bjvL67enHc3MerGc3UkvIq7oYHsAH29j243AjbnIZWZmhePOxfU0NAVzKjMj62bPKOOr961kbvUaTp54csrpzKy3KupJemZmVrwignnVtcyaPIpjxgwBYPjAvrzj5PEsWLKW3fsbUk5oZr2VC2QzM0vFn1/YzAuv7Hq197hZVeUkduxr4N5l61JKZma9nQtkMzNLxbzqWoYO6MM7Th7/uvbKySM5esxg5lXXtnGkmVluuUA2M7O827b7APc9uY53zyhjYL/S122TRFVlOTUvbWHVhh0pJTSz3swFspmZ5d0vl9azr6HpoOEVzd47cyJ9SuReZDNLhQtkMzPLq4jg1oW1TC8bxvSy4a3uM3pIf86bNo47Ftezr6ExzwnNrLdzgWxmZnn1ZP02Vq7bzpzKSe3uN6eynM279vObpzbkKZmZWYYLZDMzy6u51bUM6FvCJTMmtLvfW6aOoWzEQOZWr8lTMjOzDBfIZmaWN7v3N7BgyVreefIEhg3o2+6+pSXisoqJ/GHVK9Ru3p2nhGZmLpDNzCyP7lm2jp37Gqia1frkvJYuq8jsN7/Gk/XMLH9cIJuZWd7Mq67lmDGDqThqZKf2LxsxkLOmjuG2mjoamyLH6czMMlwgm5lZXjz38g4WvbSFqspJSOr0cVfMKmf99r08+uzGHKYzM3uNC2QzM8uLedW19C0V75lZdkjHve2EcYwe0s+T9cwsb1wgm5lZzu1raOSOxXWcN20co4f0P6Rj+/Up4X0zJ/LQyg1s2LE3RwnNzF7jAtnMzHLuwadeZsvuAx2ufdyWyyvLaWgK7lhU383JzMwO5gLZzMxybl51LWUjBvKWY0cf1vHHjBnCrCmjmFe9hghP1jOz3HKBbGZmOVW7eTe/f+4VLq8op6Sk85PzWqqqLOfFTbv58wubuzGdmdnBXCCbmVlO3VZTiwSXVUzs0nkumj6eoQP6MHehJ+uZWW7ltECWdKGkZyStknRtK9v/S9KS5PGspK1Z2xqzti3IZU4zM8uNhsYm5tfU8dbjxjBhxMAunWtgv1LePaOM+5avZ9vuA92U0MzsYDkrkCWVAt8DLgKmAVdImpa9T0T8XUTMiIgZwHeAO7M272neFhGzc5XTzMxy59HnNrJ++16qDnNyXktVs8rZ39DEL5Z4sp6Z5U4ue5BnAasiYnVE7AfmApe0s/8VwK05zGNmZnk2d2Eto4f049wTx3bL+U6aMJyTy4Zz60JP1jOz3MllgVwG1Ga9r0vaDiLpKGAK8Nus5gGSaiQ9LundbRx3dbJPzcaNvsOSmVkh2bB9Lw89vYH3nT6RvqXd9+NmTmU5T6/fwbK6bd12TjOzbIUySa8KuD0iGrPajoqICuAvgG9JOqblQRFxQ0RURETFmDFj8pXVzMw64fbFdTQ2BXMqyrv1vLNnTGBg31LmVtd2vLOZ2WHIZYFcD2R/Kk5M2lpTRYvhFRFRnzyvBn4HnNb9Ec3MLBcignnVtZwxZRRHjxnSreceNqAv7zxlPAuW1LNrX0O3ntvMDHJbIFcDUyVNkdSPTBF80GoUkk4ARgKPZbWNlNQ/eT0aeDPwVA6zmplZN3p89WZe2rSbqlnd23vcrKqynF37G7n3yXU5Ob+Z9W4dFsiSBkn6Z0k/TN5PlXRxR8dFRANwDXA/sBK4LSJWSPqKpOxVKaqAufH62RYnAjWSlgIPA1+LCBfIZmZFYm71GoYO6MNF08fn5PynHzWSY8YM9prIZpYTfTqxz4+BRcAbk/f1wHzgno4OjIj7gPtatH2pxfvrWznuT8DJnchmZmYFZuvu/fxq+XqqKssZ0Lc0J9eQRFXlJL5630qefXkHx40bmpPrmFnv1JkhFsdExDeAAwARsRs4/HuFmplZj/aLJ+rZ39DUbWsft+W9M8voWyrmebKemXWzzhTI+yUNBAIgWU1iX05TmZlZUYoI5lbXcsrE4UybMCyn1zpiSH/On3Ykdy6uY19DY8cHmJl1UmcK5OuBXwPlkm4BHgI+n8tQZmZWnJbWbePp9TuYU5mbyXktzaksZ8vuAzyw4uW8XM/MeocOC+SIeAB4L3AVmaXYKiLi4RznMjOzIjSveg0D+5Yy+9QJebnemceOpmzEQA+zMLNu1ZlVLB6KiE0RcW9E3BMRr0h6KB/hzMyseOza18CCJWu5+JTxDB3QNy/XLCkRcyrL+cOqV6jdvDsv1zSznq/NAlnSAEmjgNHJusSjksdk2rhltJmZ9V73LlvHrv2NOVv7uC2Xnj6REsFtNe5FNrPu0V4P8sfILO92QvLc/Pgl8N3cRzMzs2Jya/Uajh07hJmTRub1uhNGDOStx43htppaGhqb8nptM+uZ2iyQI+LbETEF+FxEHB0RU5LHqRHhAtnMzF71zPodPLFmK1WV5Uj5Xwl0TuUkXt6+j0ee3Zj3a5tZz9PhjUIi4juSpgPTgAFZ7T/JZTAzMyse86pr6Vsq3jtzYirXP/fEsYwe0p+51bWce+K4VDKYWc/RmUl61wHfSR7nAN8AZrd7kJmZ9Rr7Ghq584k6zj/pSEYN7pdKhr6lJVx6+kR++/QGNmzfm0oGM+s5OrMO8qXAucD6iPggcCowPKepzMysaNy/4mW27j5AVZ7WPm7LnMpyGpuC+YvqUs1hZsWvMwXynohoAhokDQM2AOl+CpqZWcGYV72GiSMH8uZjRqeaY8rowZwxZRS31dTS1BSpZjGz4taZArlG0gjgh2RWsVgMPJbLUGZmVhzWbNrNH1dtYk5FOSUl+Z+c19IVsybx0qbdPP7CprSjmFkRa7dAVmYq8r9FxNaI+D5wHnBlMtTCzMx6udtqaikRXFqRzuS8li6cfiTDBvTxnfXMrEvaLZAjIoD7st6/GBHLcp7KzMwKXkNjE/MX1XL28WMZP3xg2nEAGNC3lPecVsavlq9n6+79accxsyLVmSEWiyVV5jyJmZkVld89s5GXt+9jTsqT81qaUzmJ/Q1N3PVEfdpRzKxIdaZAPgN4TNLzkpZJelKSe5HNzHq5udW1jB7Sn7edMDbtKK8zbcIwTpk4nLkLa8n8IdTM7NB0eKMQ4IKcpzAzs6Ly8va9PPzMBq4+62j6lnamryW/qion8cW7nmRp3TZmlI9IO46ZFZkOP9Ui4qXWHp05uaQLJT0jaZWka1vZfpWkjZKWJI+PZG27UtJzyePKQ/uyzMwsl25fVEdjU3B5RWENr2j2rlPHM7BvKXMXrkk7ipkVoZz92i+pFPgecBGZ21RfIWlaK7vOi4gZyeNHybGjgOvIDO+YBVwnaWSuspqZWec1NQXzqmt5w9GjmDJ6cNpxWjV0QF8uPmU8C5auZee+hrTjmFmRyeXfxWYBqyJidUTsB+YCl3Ty2AuAByNic0RsAR4ELsxRTjMzOwSPr97Ems27qaqclHaUdlXNKmf3/kbuXbY27ShmVmQ6VSBLOkrS25PXAyUN7cRhZUD2QpR1SVtL70sm/90uqflvdZ06VtLVkmok1WzcuLEzX4qZmXXR3Opahg/sy4XTj0w7SrtmThrJ1LFDmOs1kc3sEHVYIEv6KHA78IOkaSLwi266/t3A5Ig4hUwv8c2HcnBE3BARFRFRMWbMmG6KZGZmbdmyaz+/Xr6e95xWxoC+pWnHaZck5lSW88SarTyzfkfaccysiHSmB/njwJuB7QAR8RzQmTV96oHs2RsTk7ZXRcSmiNiXvP0RcHpnjzUzs/y764l69jc2Fdzax21578yJ9C0Vc6s9Wc/MOq8zBfK+ZAwxAJL6AJ1ZWLIamCppiqR+QBWwIHsHSeOz3s4GViav7wfOlzQymZx3ftJmZmYpichMzjt14nBOHD8s7TidMmpwP84/6UjueqKevQca045jZkWiMwXyI5K+CAyUdB4wn8zQiHZFRANwDZnCdiVwW0SskPQVSbOT3T4paYWkpcAngauSYzcD/0KmyK4GvpK0mZlZSpbUbuWZl3dQNauwJ+e1dEXlJLbuPsADT72cdhQzKxLq6C5DkkqAD5PpxRVwf0T8MA/ZDklFRUXU1NSkHcPMrMf6/O3LuHvZWhb+49sZ0r8z95kqDE1NwVnffJhJowbx84++Ie04ZlZAJC2KiIqW7Z3pQb4+In4YEZdFxKXAjZJu6f6IZmZWqHbua+DuZWu5+JTxRVUcA5SUiDkV5fzp+U28tGlX2nHMrAh0pkAul/QFgGQs8R3AczlNZWZmBeWepWvZvb+ROQW+9nFbLq2YSIngthov+WZmHetMgfwh4OSkSL4HeCQirs9pKjMzKyhzq2s5btwQZk4akXaUwzJ++EDOOX4s82vqaGhsSjuOmRW4NgtkSTMlzQROA74NzCHTc/xI0m5mZr3A0+u3s6R2K3MqJyEp7TiHbU5lORt27OPhZ3xjKTNrX3sDyf6jxfstwLSkPYC35SqUmZkVjrkLa+lXWsJ7TmvtZqjF45wTxjJmaH/mVa/hvGnj0o5jZgWszQI5Is7JZxAzMys8ew80ctcT9Zx/0jhGDe6Xdpwu6VtawqWnT+QHjzzP+m17OXL4gLQjmVmBam+IxQeS58+09shfRDMzS8v9K9azbc8BriiytY/bMqeinKaAOxbXpR3FzApYe5P0BifPQ9t4mJlZDzd3YS3lowbyxqOPSDtKt5g8ejBvPPoI5lavoampMzeFNbPeqL0hFj9Inr+cvzhmZlYoXnxlF4+t3sTnzj+OkpLinZzXUtWscj41dwmPrd7Em48dnXYcMytAHS7zJuloSXdL2ihpg6RfSjo6H+HMzCw9t9XUUiK49PTytKN0qwtOOpLhA/syt9prIptZ6zqzDvLPgduA8cAEYD5way5DmZlZuhoam5i/qI63nTC2x01mG9C3lPecVsb9y9ezZdf+tOOYWQHqTIE8KCJ+GhENyeNnQM/6tDQzs9f57dMb2LhjX9HeOa8jcyrL2d/YxJ1P1KcdxcwKUGcK5F9JulbSZElHSfoH4D5JoySNynVAMzPLv3nVtYwd2p9zjh+TdpScOHH8ME4tH8G86jVEeLKemb1eZwrky4GPAQ8DvwP+BqgCFgE1OUtmZmapWL9tLw8/s4FLT59In9LO/JgoTlWV5Tz78k6eqN2adhQzKzAdfvJFxJR2Hp6sZ2bWw9y+qJamyAxD6MnedeoEBvUrZd5CT9Yzs9dr70YhlZKOzHr/V8kKFv/toRVmZj1TU1Mwr6aWNx1zBEcdMbjjA4rYkP59eNcpE7h72Vp27mtIO46ZFZD2epB/AOwHkHQW8DXgJ8A24IbcRzMzs3z70/ObqN28p8f3HjebM6uc3fsbuXvp2rSjmFkBaa9ALo2IzcnrOcANEXFHRPwzcGzuo5mZWb7NrV7DiEF9ueCkIzveuQc4rXwEx40b4jWRzex12i2QJTXfae9c4LdZ29q8A182SRdKekbSKknXtrL9M5KekrRM0kOSjsra1ihpSfJY0JnrmZnZ4du8az8PrHiZ95xWxoC+pWnHyQtJVFVOYmntVlau2552HDMrEO0VyLcCj0j6JbAH+D2ApGPJDLNol6RS4HvARcA04ApJ01rs9gRQERGnALcD38jaticiZiSP2Z39gszM7PDcubiO/Y1NvWZ4RbP3nFZGv9IS5rkX2cwSbRbIEfFV4LPATcCZ8dpCkSXAJzpx7lnAqohYHRH7gbnAJS2u8XBE7E7ePg5MPLT4ZmbWHSKCedW1zCgfwQlHDks7Tl6NHNyPC6YfyZ2L69h7oDHtOGZWANpd5i0iHo+IuyJiV1bbsxGxuBPnLgOyfx2vS9ra8mHgV1nvB0iqkfS4pHe3doCkq5N9ajZu3NiJSGZm1prFa7by3IadVPWy3uNmVZXlbN/bwP0r1qcdxcwKQEGsAC/pA0AF8M2s5qMiogL4C+Bbko5peVxE3BARFRFRMWZMz7zbk5lZPsyrXsPgfqW869QJaUdJxRuPPoJJowYx12simxm5LZDrgeyuiIlJ2+tIejvwj8DsiNjX3B4R9cnzajJ38Dsth1nNzHqtHXsPcPfSdbzr1AkM7t+pOdg9TkmJmFNZzmOrN/HiK7s6PsDMerRcFsjVwFRJUyT1I3N76tetRiHpNDLrLc+OiA1Z7SMl9U9ejwbeDDyVw6xmZr3W3UvXsedAY6+bnNfSpadPpEQwr8a9yGa9Xc4K5IhoAK4B7gdWArdFxApJX5HUvCrFN4EhwPwWy7mdCNRIWgo8DHwtIlwgm5nlwLzqNRw/bigzykekHSVV44YN4G0njOX2RXUcaGxKO46ZpSinf0uLiPuA+1q0fSnr9dvbOO5PwMm5zGZmZvDU2u0srdvGde+ahqS046SuqnISv1lZw8NPb+D8XnKzFDM7WEFM0jMzs3TMq15Dvz4lvOe09hYZ6j3OPn4MY4f29531zHo5F8hmZr3U3gON3PVEPReedCQjBvVLO05B6FNawmUVE/ndMxtYt21P2nHMLCUukM3MeqlfL1/P9r0NvXbt47ZcXlFOU8DtNXVpRzGzlLhANjPrpeZWr+GoIwbxhqOPSDtKQTnqiMG8+dgjmFdTS1NTdHyAmfU4LpDNzHqhF17ZxeOrN3N5RTklJZ6c19KcyknUbdnDH59/Je0oZpYCF8hmZr3QvOpaSkvEpadPTDtKQTp/2jhGDOrryXpmvZQLZDOzXuZAYxO3L6rjnOPHMm7YgLTjFKQBfUt5z2llPLBiPZt37U87jpnlmQtkM7Ne5rdPb+CVnfu4YpYn57WnqnISBxqDOxd7sp5Zb+MC2cysl5m7cA3jhvXnrceNSTtKQTv+yKGcNmkEc6trifBkPbPexAWymVkvsnbrHh55diOXnV5On1L/COhIVWU5qzbsZPGaLWlHMbM88qejmVkvcvuiOpois9avdeziUyYwuF8pcxd6sp5Zb+IC2cysl2hqCuZV13LmsaOZdMSgtOMUhcH9+zB7xgTuWbaOHXsPpB3HzPLEBbKZWS/xh1WvUL91D3N857xDMqdyEnsONLJg6dq0o5hZnrhANjPrJeZV1zJiUF/OP2lc2lGKyqkTh3PCkUOZ5zWRzXoNF8hmZr3App37eOCp9bz3tIn071OadpyiIok5leUsq9vGirXb0o5jZnngAtnMrBe464l6DjQGVV77+LC857Qy+vUp4Tb3Ipv1Ci6Qzcx6uIjg1oVrmDlpBMeNG5p2nKI0YlA/Lpp+JHc9Uc/eA41pxzGzHHOBbGbWwy16aQvPb9xFVeWktKMUtTmV5Wzf28Cvlq9LO4qZ5VhOC2RJF0p6RtIqSde2sr2/pHnJ9j9Lmpy17QtJ+zOSLshlTjOznmxudS2D+5XyzlPGpx2lqL1hyhEcdcQgr4ls1gvkrECWVAp8D7gImAZcIWlai90+DGyJiGOB/wK+nhw7DagCTgIuBP4nOZ+ZmR2C7XsPcO+ydcyeUcbg/n3SjlPUSkoyk/X+/MJmVm/cmXYcM8uhXH5azgJWRcRqAElzgUuAp7L2uQS4Pnl9O/BdSUra50bEPuAFSauS8z2Ww7yHbPXGnazZvDvtGGZmbXp89Wb2HGikymsfd4tLZ07kPx54lu8+vIrZp05IO45Zj1E2YiBTC2iORC4L5DIg++9QdcAZbe0TEQ2StgFHJO2Ptzi2rOUFJF0NXA0waVL+x9bdsbiO7z38fN6va2Z2KE6aMIxTJg5PO0aPMHbYAM6fNo47F9dz5+L6tOOY9RhXvWky188+Ke0Yryrqv7dFxA3ADQAVFRWR7+v/xRlHce6JXnDfzArblCMGk/njnHWHf7/sVD561tFpxzDrUcYM6Z92hNfJZYFcD2T/TW9i0tbaPnWS+gDDgU2dPDZ1ZSMGUjZiYNoxzMwsjwb378PMSSPTjmFmOZTLVSyqgamSpkjqR2bS3YIW+ywArkxeXwr8NiIiaa9KVrmYAkwFFuYwq5mZmZkZkMMe5GRM8TXA/UApcGNErJD0FaAmIhYA/wf8NJmEt5lMEU2y321kJvQ1AB+PCK/MbmZmZmY5p0yHbfGrqKiImpqatGOYmZmZWZGQtCgiKg5q7ykFsqSNwEspXHo08EoK1z0cxZK1WHJC8WQtlpxQPFmLJSc4ay4US04onqzFkhOKJ2ux5IT0sh4VEWNaNvaYAjktkmpa+82jEBVL1mLJCcWTtVhyQvFkLZac4Ky5UCw5oXiyFktOKJ6sxZITCi9rTm81bWZmZmZWbFwgm5mZmZllcYHcdTekHeAQFEvWYskJxZO1WHJC8WQtlpzgrLlQLDmheLIWS04onqzFkhMKLKvHIJuZmZmZZXEPspmZmZlZFhfIZmZmZmZZXCB3gaQLJT0jaZWka9PO0xZJN0raIGl52lnaI6lc0sOSnpK0QtKn0s7UGkkDJC2UtDTJ+eW0M3VEUqmkJyTdk3aW9kh6UdKTkpZIKtg7/0gaIel2SU9LWinpjWlnao2k45PvZfNju6RPp52rNZL+Lvn/abmkWyUNSDtTWyR9Ksm5opC+n6191ksaJelBSc8lzyPTzNisjayXJd/TJkkFsdxXGzm/mfy/v0zSXZJGpBjxVW1k/Zck5xJJD0iakGbGZu3VJZI+KykkjU4jWzMXyIdJUinwPeAiYBpwhaRp6aZq003AhWmH6IQG4LMRMQ14A/DxAv2e7gPeFhGnAjOACyW9Id1IHfoUsDLtEJ10TkTMKKT1MFvxbeDXEXECcCoF+r2NiGeS7+UM4HRgN3BXuqkOJqkM+CRQERHTgVKgKt1UrZM0HfgoMIvMv/3Fko5NN9WrbuLgz/prgYciYirwUPK+ENzEwVmXA+8FHs17mrbdxME5HwSmR8QpwLPAF/Idqg03cXDWb0bEKclnwD3Al/Idqg030UpdIqkcOB9Yk+9ALblAPnyzgFURsToi9gNzgUtSztSqiHgU2Jx2jo5ExLqIWJy83kGm6ChLN9XBImNn8rZv8ijY2a6SJgLvBH6UdpaeQNJw4Czg/wAiYn9EbE01VOecCzwfEWnccbQz+gADJfUBBgFrU87TlhOBP0fE7ohoAB4hU9Slro3P+kuAm5PXNwPvzmemtrSWNSJWRsQzKUVqVRs5H0j+7QEeBybmPVgr2si6PevtYArkZ1U7dcl/Af9AAeR0gXz4yoDarPd1FGAxV6wkTQZOA/6ccpRWJUMWlgAbgAcjoiBzJr5F5gOnKeUcnRHAA5IWSbo67TBtmAJsBH6cDFv5kaTBaYfqhCrg1rRDtCYi6oF/J9NrtA7YFhEPpJuqTcuBt0g6QtIg4B1AecqZ2jMuItYlr9cD49IM0wN9CPhV2iHaI+mrkmqB91M4PcgHkXQJUB8RS9POAi6QrQBJGgLcAXy6xW+/BSMiGpM/WU0EZiV/di04ki4GNkTEorSzdNKZETGTzNClj0s6K+1AregDzAT+NyJOA3ZROH+2bpWkfsBsYH7aWVqTjIu9hMwvHxOAwZI+kG6q1kXESuDrwAPAr4ElQGOamTorMuu6pt4z11NI+kcyQwNvSTtLeyLiHyOinEzOa9LO05rkl80vUkAFvAvkw1fP63sNJiZt1gWS+pIpjm+JiDvTztOR5E/rD1O4Y7zfDMyW9CKZYUBvk/SzdCO1LelJJCI2kBkrOyvdRK2qA+qy/mpwO5mCuZBdBCyOiJfTDtKGtwMvRMTGiDgA3Am8KeVMbYqI/4uI0yPiLGALmXGoheplSeMBkucNKefpESRdBVwMvD+K54YStwDvSztEG44h8wvy0uTn1URgsaQj0wrkAvnwVQNTJU1JemeqgAUpZypqkkRmXOfKiPjPtPO0RdKY5lnLkgYC5wFPpxqqDRHxhYiYGBGTyfw3+tuIKMieOUmDJQ1tfk1mokbBrbwSEeuBWknHJ03nAk+lGKkzrqBAh1ck1gBvkDQo+Rw4lwKd+AggaWzyPInM+OOfp5uoXQuAK5PXVwK/TDFLjyDpQjLD1mZHxO6087RH0tSst5dQuD+rnoyIsRExOfl5VQfMTD5vU9EnrQsXu4hokHQNcD+ZGdc3RsSKlGO1StKtwNnAaEl1wHUR8X/ppmrVm4G/BJ5MxvcCfDEi7ksvUqvGAzcnK5mUALdFREEvn1YkxgF3Zeoj+gA/j4hfpxupTZ8Abkl+OV4NfDDlPG1Kftk4D/hY2lnaEhF/lnQ7sJjMn6yfoMBuO9vCHZKOAA4AHy+USZqtfdYDXwNuk/Rh4CXg8vQSvqaNrJuB7wBjgHslLYmIC9JL2WbOLwD9gQeTz6vHI+KvUwuZaCPrO5Jf5pvI/PunnhOKoy7xrabNzMzMzLJ4iIWZmZmZWRYXyGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZmZmZWRYXyGZmhyi5zfCS5LFeUn3W+37dfK0Rkv62O8+ZD8ktuKe10n6VpO+mkcnMrLO8DrKZ2SGKiE3ADABJ1wM7I+LfOzpOUp+IaDjEy40A/hb4n0M87rAdZs7XiYiPdFceM7N8cw+ymVk3kPRRSdWSlkq6Q9KgpP0mSd+X9GfgG5KOkfS4pCcl/auknVnn+PvkHMskfTlp/hpwTNI7/c0W15wsaaWkH0paIemB5O6OJNf5taRFkn4v6YSsPJdmnWNn8nx2st8C4ClJAyT9OMn5hKRzkv2uknRncu7nJH2jje/H7yRVJK8/KOlZSQvJ3BCoeZ9fSvqr5PXHJN3SpX8EM7Nu4h5kM7PucWdE/BBA0r8CHyZzVzCAicCbIqJR0j3AtyPiVkmv3tVK0vnAVGAWIGCBpLOAa4HpETGjjetOBa6IiI9Kug14H/AzMnei++uIeE7SGWR6oN/WwdcwM7nWC5I+C0REnJwU1w9IOi7ZbwZwGrAPeEbSdyKitrUTShoPfBk4HdgGPEzmTnkAVwN/lPQC8FngDR3kMzPLCxfIZmbdY3pSGI8AhpC5DX2z+RHRmLx+I/Du5PXPgeahGecnj+bicQiZ4ndNB9d9ISKWJK8XAZMlDQHeBMxPboULmVvjdmRhRLyQvD6TpMCPiKclvQQ0F8gPRcQ2AElPAUcBrRbIwBnA7yJiY7L/vObzRMTLkr5Epmh+T0Rs7kRGM7Occ4FsZtY9bgLeHRFLJV0FnJ21bVcnjhfwbxHxg9c1SpM7OG5f1utGYCCZ4XNb2+h1bki2I6kEyJ5U2JmcrV2zKz9LTgY2ARO6cA4zs27lMchmZt1jKLBOUl/g/e3s9ziZYRAAVVnt9wMfSnp/kVQmaSywIzl3p0XEduAFSZcl55KkU5PNL5IZ7gAwG+jbxml+3/x1JEMrJgHPHEqOxJ+BtyYrf/QFLmveIGkWcBGZ4RqfkzTlMM5vZtbtXCCbmXWPfyZTDP4ReLqd/T4NfEbSMuBYMuNyiYgHyAy5eEzSk8DtwNBkxYw/SlrecpJeB94PfFjSUmAFcEnS/kMyBetSMsM92uo1/h+gJMkyD7gqIva1sW+bImIdcD3wGJnvzUoASf2TLB+KiLVkxiDfqKwxIWZmaVFEpJ3BzKzXSFa32BMRIamKzAS7Szo6zszM8sdjkM3M8ut04LtJT+lW4EPpxjEzs5bcg2xmZmZmlsVjkM3MzMzMsrhANjMzMzPL4gLZzMzMzCyLC2QzMzMzsywukM3MzMzMsrhANjMzMzPL4gLZzMzMzCyLC2QzMzMzsywukM3MzMzMsrhANjMzMzPL4gLZzKwISBon6VFJOyT9R9p5zMx6sj5pBzAz600kvQiMAxqBncCvgWsiYmcHh14NvAIMi4jIaUgzs17OPchmZvn3rogYAswATgO+0IljjgKeOpziWJI7Q8zMDoELZDOzlETEeuB+MoUykt4g6U+StkpaKunspP0m4ErgHyTtlPR2SSWSrpX0vKRNkm6TNCrZf7KkkPRhSWuA3ybtH5K0UtIWSfdLOqo5S7L/X0t6Lrn+9yQpa/tHk2N3SHpK0sykfYKkOyRtlPSCpE/m4VtnZpZTLpDNzFIiaSJwEbBKUhlwL/CvwCjgc8AdksZExFXALcA3ImJIRPwG+ATwbuCtwARgC/C9Fpd4K3AicIGkS4AvAu8FxgC/B25tsf/FQCVwCnA5cEGS8zLgeuCvgGHAbGCTpBLgbmApUAacC3xa0gVd/NaYmaVKHspmZpY/yRjk0UAAQ8j07r4P+BgwPSL+Mmvf+4GfR8TNSS9yXUT8U7JtJZmxyw8l78cDa4CBwETgBeCYiFidbP8VcHtE/F/yvoTMGOgTI+IlSQG8JSL+kGy/DVgcEV9LctwXEd9u8bWcAcyPiElZbV8AjouID3bbN83MLM/cg2xmln/vjoihwNnACWQK5qOAy5LhDVslbQXOBMa3cY6jgLuy9l1JZuLfuKx9alvs/+2s/TcDItPz22x91uvdZAp4gHLg+TYyTGiR+YstMpiZFR1P3DAzS0lEPJL0DP878GfgpxHx0U4eXgt8KCL+2HKDpMnNl2ix/1cj4pbDiFoLHNNG+wsRMfUwzmlmVrDcg2xmlq5vAecBfwLeJekCSaWSBkg6Oxmn3JrvA19tnmgnaUwyzrgt3we+IOmkZP/hydjizvgR8DlJpyvj2OS6C4Edkj4vaWCSe7qkyk6e18ysILlANjNLUURsBH4CfBJonki3kUzv7N/T9uf0t4EFwAOSdgCPA2e0c527gK8DcyVtB5aTmSDYmYzzga8CPwd2AL8ARkVEI5mJfTPIjHl+hUwxPbwz5zUzK1SepGdmZmZmlsU9yGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZmZmZWZYesw7y6NGjY/LkyWnHMDMzM7MisWjRolciYkzL9h5TIE+ePJmampq0Y5iZmZlZkZD0UmvtORtiIelGSRskLW9juyT9t6RVkpZJmpm17UpJzyWPK3OV0czMzMyspVyOQb4JuLCd7RcBU5PH1cD/AkgaBVxHZsH7WcB1kkbmMKeZmZmZ2atyViBHxKPA5nZ2uQT4SWQ8DoyQNB64AHgwIjZHxBbgQdovtM2sh1iwdC2PPLsx7RhmZtbLpbmKRRmZW6k2q0va2mo/iKSrJdVIqtm40T9UzYrZ9r0H+Pzty/jCHctobPIdPs3MLD1FvcxbRNwQERURUTFmzEETEM2siNy9dC17DjSydttefv+cf+E1M7P0pFkg1wPlWe8nJm1ttZtZDzavupbjxg1h1OB+zKuu7fgAMzOzHEmzQF4A/FWymsUbgG0RsQ64Hzhf0shkct75SZuZ9VAr1m5jWd02/mLWJN43s4wHn3qZjTv2pR3LzMx6qVwu83Yr8BhwvKQ6SR+W9NeS/jrZ5T5gNbAK+CHwtwARsRn4F6A6eXwlaTOzHmpedS39+pTw7tPKmFNZTkNTcOfiurRjmZlZL5WzG4VExBUdbA/g421suxG4MRe5zKyw7D3QyF1P1HPR9CMZMagfIwb1o+KokcyrruXqs45GUtoRzcyslynqSXpmVvx+tXwdO/Y2UFU56dW2qlmTWP3KLqpf3JJiMjMz661cIJtZqm5dWMvkIwbxhqNHvdr2jpOPZGj/PsxduCbFZGZm1lu5QDaz1KzeuJOFL2zm8sry1w2lGNSvD7NnTODeJ9exbc+BFBOamVlv5ALZzFIzr6aW0hJx6cyJB22rqpzEvoYmFizxKo9mZpZfLpDNLBUHGpu4Y1Ed554wlrHDBhy0/eSJwzlpwjDmek1kMzPLMxfIZpaKh1a+zCs791M1q7zNfaoqy1mxdjtP1m3LYzIzM+vtXCCbWSrmVtdy5LABnDW17dvEz55RRv8+Jcyt9mQ9MzPLHxfIZpZ3a7fu4ZFnN3JZxUT6lLb9MTR8YF/eefJ4FixZy+79DXlMaGZmvZkLZDPLu/k1mbvkXV7R9vCKZlWzJrFjXwP3Pbk+17HMzMwAF8hmlmeNTcFtNbWceexoykcN6nD/yskjOXr0YK+JbGZmeeMC2czy6g+rXqF+6x7mVHbcewwgiTmV5dS8tIVVG3bkOJ2ZmZkLZDPLs3nVaxg5qC/nTRvX6WPeO3MifUrEPC/5ZmZmeeAC2czy5pWd+3jwqZd538yJ9O9T2unjxgztz3nTxnHH4nr2NzTlMKGZmZkLZDPLozsX13GgMTo9vCLbnMpyNu/az4NPvZyDZGZmZq9xgWxmeRERzK2u5fSjRjJ13NBDPv4tU8cwYfgAr4lsZmY55wLZzPKi5qUtrN6467B6jwFKS8RlFeX8YdUr1G7e3c3pzMzMXuMC2czyYu7CWob078PFp4w/7HNcnhTX8xfVdVcsMzOzg7hANrOc27bnAPc+uZbZMyYwqF+fwz5P2YiBnDV1DPNramlsim5MaGZm9pqcFsiSLpT0jKRVkq5tZft/SVqSPJ6VtDVrW2PWtgW5zGlmubVg6Vr2Hmii6jCHV2Srqixn3ba9PPrsxm5IZmZmdrDD78rpgKRS4HvAeUAdUC1pQUQ81bxPRPxd1v6fAE7LOsWeiJiRq3xmlj/zqtdw4vhhnFw2vMvnOvfEcRwxuB9zq9dwzgljuyGdmZnZ6+WyB3kWsCoiVkfEfmAucEk7+18B3JrDPGaWguX121hev50rZpUjqcvn69enhEtPn8hDKzewYcfebkhoZmb2erkskMuA7Nte1SVtB5F0FDAF+G1W8wBJNZIel/TuNo67OtmnZuNG/7nVrBDNrV5D/z4lXHJqq//7H5bLK8tpaAruWFTfbec0MzNrViiT9KqA2yOiMavtqIioAP4C+JakY1oeFBE3RERFRFSMGTMmX1nNrJP27G/kl0+s5R0nj2f4oL7ddt5jxgxh1uRRzKteQ4Qn65mZWffKZYFcD2TPyJmYtLWmihbDKyKiPnleDfyO149PNrMicN+T69ixr+Gw1z5uz5zKcl7ctJs/v7C5289tZma9Wy4L5GpgqqQpkvqRKYIPWo1C0gnASOCxrLaRkvonr0cDbwaeanmsmRW2edW1TBk9mDOmjOr2c7/j5PEMHdCHedW1He9sZmZ2CDoskCUNkvTPkn6YvJ8q6eKOjouIBuAa4H5gJXBbRKyQ9BVJs7N2rQLmxuv/TnoiUCNpKfAw8LXs1S/MrPCt2rCThS9uZk5l90zOa2lgv1LePaOM+55cx7bdB7r9/GZm1nt1Zpm3HwOLgDcm7+uB+cA9HR0YEfcB97Vo+1KL99e3ctyfgJM7kc3MCtRtNbX0KRHvndl9k/NamlNZzk8ff4lfLKnnyjdNztl1zMysd+nMEItjIuIbwAGAiNgNdH93kJn1GPsbmrhjUR3nnjiWsUMH5Ow608uGM71sGLcu9GQ9MzPrPp0pkPdLGggEQLKaxL6cpjKzovbQypfZtGs/VbMm5fxaVZWTeHr9Dp6s35bza5mZWe/QmQL5euDXQLmkW4CHgM/nMpSZFbdbq2sZP3wAZ03N/fKLs2dMYEDfEm5d6Ml6ZmbWPToskCPiAeC9wFVklmKriIiHc5zLzIpU3Zbd/P65jVxWUU5pSe5HYw0b0Jd3njyBBUvq2bWvIefXMzOznq8zq1g8FBGbIuLeiLgnIl6R9FA+wplZ8ZlfUwfA5RUT83bNqlnl7NrfyL1PrsvbNc3MrOdqs0CWNEDSKGB0si7xqOQxmTZuGW1mvVtjUzC/ppa3TB3DxJGD8nbdiqNGcsyYwV4T2czMukV7PcgfI7O82wnJc/Pjl8B3cx/NzIrNo89tZO22vVTl4M557ZFEVeUkFr20hWdf3pHXa5uZWc/TZoEcEd+OiCnA5yLi6IiYkjxOjQgXyGZ2kHkLaxk1uB9vP3Fc3q/9npll9C2Ve5HNzKzLOjNJ7zuSpku6XNJfNT/yEc7MisfGHfv4zcqXed/MMvr1yeVd7Fs3ekh/zps2jjsX17GvoTHv1zczs56jM5P0rgO+kzzOAb4BzG73IDPrde5cXEdDUzCnMvdrH7elqnISW3Yf4MGnXk4tg5mZFb/OdPNcCpwLrI+IDwKnAsNzmsrMikpEMK+6lsrJIzl27JDUcpx57GjKRgxkrtdENjOzLuhMgbwnIpqABknDgA1AfmfgmFlBW/jCZla/sivV3mOAkhJxeUU5f1j1CrWbd6eaxczMildnCuQaSSOAH5JZxWIx8FguQ5lZcZlXXcvQ/n14x8lHph2FyyomUiK4rca9yGZmdnjaLZAlCfi3iNgaEd8HzgOuTIZamJmxbc8B7n1yHZecNoFB/fqkHYcJIwby1uPGML+mjobGprTjmJlZEWq3QI6IAO7Lev9iRCzLeSozKxq/XFLPvoYmqlIeXpFtTuUk1m/fyyPPbkw7ipmZFaHODLFYLKky50nMrOhEBLcurOWkCcOYXlY4c3fPPXEso4f0Y67XRDYzs8PQmQL5DOAxSc9LWibpSUnuRTYzltdvZ+W67Xm/c15H+paW8L7TJ/LbpzewYfvetOOYmVmR6UyBfAFwDPA24F3AxcmzmfVyc6vXMKBvCbNnlKUd5SBVlZNobApuX1yXdhQzMysynbmT3kutPTpzckkXSnpG0ipJ17ay/SpJGyUtSR4fydp2paTnkseVh/ZlmVmu7d7fwC+XrOUdJ49n+MC+acc5yJTRgzljyijmVdfS1BRpxzEzsyKSs/vBSioFvgdcBEwDrpA0rZVd50XEjOTxo+TYUcB1ZIZ3zAKukzQyV1nN7NDdu2wdO/c1FNTkvJaqZpXz0qbdPP7CprSjmJlZEclZgUymsF0VEasjYj8wF7ikk8deADwYEZsjYgvwIHBhjnKa2WGYV13L0WMGUzm5cH93vWj6eIYN6MM8T9YzM7ND0KkCWdJRkt6evB4oaWgnDisDsn8q1SVtLb0vmfx3u6TmmT6dOlbS1ZJqJNVs3OjlnMzyZdWGHdS8tIWqynIyy6UXpgF9S3nPaWX8avl6tu7en3YcMzMrEh0WyJI+CtwO/CBpmgj8opuufzcwOSJOIdNLfPOhHBwRN0RERURUjBkzppsimVlH5i6spU+JeO/MiWlH6dCcyknsb2jirifq045iZmZFojM9yB8H3gxsB4iI54CxnTiuHshe+2li0vaqiNgUEfuStz8CTu/ssWaWjn0Njdz5RD3nTRvH6CH9047ToWkThnHKxOHMXVhL5t5HZmZm7etMgbwvGUMMgKQ+QGd+ylQDUyVNkdQPqAIWZO8gaXzW29nAyuT1/cD5kkYmk/POT9rMLGW/eWoDm3ftZ06BrX3cnjmV5Tzz8g6W1m1LO4qZmRWBzhTIj0j6IjBQ0nnAfDJDI9oVEQ3ANWQK25XAbRGxQtJXJM1OdvukpBWSlgKfBK5Kjt0M/AuZIrsa+ErSZmYpm1u9hrIRA3nL1OIZ1jT71AkM7FvKvOo1aUcxM7MioI7+5CipBPgwmV5cAfdHxA/zkO2QVFRURE1NTdoxzHq02s27OeubD/Opc6fy6bcfl3acQ/L385dy35PrWPiPb2dw/z5pxzEzswIgaVFEVLRs70wP8vUR8cOIuCwiLgVulHRL90c0s0I3vyazuMxlFcUzvKJZ1axydu1v5J5la9OOYmZmBa4zBXK5pC8AJGOJ7wCey2kqMys4jU3BbTV1nDV1DGUjBqYd55DNnDSSY8cOYa7XRDYzsw50pkD+EHByUiTfAzwSEdfnNJWZFZxHn93I+u17uWJW8fUeA0iiqrKcJ9Zs5Zn1O9KOY2ZmBazNAlnSTEkzgdOAbwNzyPQcP5K0m1kvcuvCNYwe0o+3nTAu7SiH7b0zJ9K3VMz1ZD0zM2tHezNV/qPF+y3AtKQ9gLflKpSZFZYNO/by0NMb+MiZU+jXJ5d3qM+tUYP7cf5JR3LXE/V8/sITGNC3NO1IZmZWgNoskCPinHwGMbPCdceiehqbgsuLaO3jtlRVlnPvsnU88NTLzD51QtpxzMysALVZIEv6QET8TNJnWtseEf+Zu1hmVigignnVa5g1ZRTHjBmSdpwue/Mxo5k4ciDzqte4QDYzs1a197fSwcnz0DYeZtYLPL56My9u2k1VD+g9BigpEXMqyvnjqk28tGlX2nHMzKwAtTfE4gfJ85fzF8fMCs286jUMHdCHi6aP73jnInFpxUT+6zfPcltNLX9/wQlpxzEzswLT4WwbSUdLulvSRkkbJP1S0tH5CGdm6dq2+wD3LV/Pu2eUMbBfz5nQNn74QM4+fizza+poaGxKO46ZmRWYzkxH/zlwGzAemADMB27NZSgzKwy/WFLP/oYmqop07eP2VFWWs2HHPn73zMa0o5iZWYHpTIE8KCJ+GhENyeNnwIBcBzOzdEUEty5cw8llwzlpwvC043S7c04Yy5ih/b0mspmZHaQzBfKvJF0rabKkoyT9A3CfpFGSRuU6oJmlY1ndNp5ev4M5PWRyXkt9S0u49PSJ/PbpDazftjftOGZmVkA6UyBfDnwMeBj4HfA3QBWwCKjJWTIzS9Xc6loG9i1l9oyeuxTanIpymgLuWFyXdhQzMysg7d1JD4CImJKPIGZWOHbta2DBknreecp4hg3om3acnJk8ejBvPPoI5lXX8jdvPYaSEqUdyczMCkCbPciSKiUdmfX+r5IVLP7bQyvMerZ7l61j1/7GHrP2cXuqZpWzZvNuHlu9Ke0oZmZWINobYvEDYD+ApLOArwE/AbYBN+Q+mpmlZW71Go4ZM5jTjxqZdpScu+CkIxk+sC9zq2vTjmJmZgWivQK5NCI2J6/nADdExB0R8c/AsbmPZmZpePblHSxes5WqyklIPX/IwYC+pbzntDLuX76eLbv2px3HzMwKQLsFsqTmMcrnAr/N2tbh2GUASRdKekbSKknXtrL9M5KekrRM0kOSjsra1ihpSfJY0JnrmVnXzauupW+peO/MsrSj5M2cynL2NzZx1xP1aUcxM7MC0F6BfCvwiKRfAnuA3wNIOpbMMIt2SSoFvgdcBEwDrpA0rcVuTwAVEXEKcDvwjaxteyJiRvKY3dkvyMwO376GRu5cXMf5047kiCH9046TNyeOH8ap5SOYW72GiEg7jpmZpazNAjkivgp8FrgJODNe+6lRAnyiE+eeBayKiNURsR+YC1zS4hoPR8Tu5O3jwMRDi29m3emBFS+zZfeBHrv2cXuqKst59uWdPFG7Ne0oZmaWsnbXQY6IxyPirojYldX2bEQs7sS5y4DsWS91SVtbPgz8Kuv9AEk1kh6X9O5OXM/MumhedS1lIwZy5rGj046Sd+86dQKD+pUyb6En65mZ9XaduVFIzkn6AFABfDOr+aiIqAD+AviWpGNaOe7qpIiu2bhxY57SmvVMtZt384dVrzCnsrxXrgc8pH8f3nXKBO5etpad+xrSjmNmZinKZYFcD2T/nXZi0vY6kt4O/CMwOyL2NbdHRH3yvJrMHfxOa3lsRNwQERURUTFmzJjuTW/Wy8yrrqVEcOnpvXek05xZ5eze38jdS9emHcXMzFKUywK5GpgqaYqkfmRuT/261SgknUZmveXZEbEhq32kpP7J69HAm4GncpjVrFdraGxi/qJa3nrcGCaMGJh2nNScVj6C48YN8ZrIZma9XM4K5IhoAK4B7gdWArdFxApJX5HUvCrFN4EhwPwWy7mdCNRIWgo8DHwtIlwgm+XII89u5OXt+5hTOSntKKmSxJzKSSyt3crKddvTjmNmZinp1HrGhysi7gPua9H2pazXb2/juD8BJ+cym5m9Zm51LaOH9OfcE8emHSV17zmtjK//6mnmVddy/eyT0o5jZmYpKIhJemaWng3b9/Lbpzdw6ekT6Vvqj4RRg/txwfQjueuJevYeaEw7jpmZpcA/Dc16ufmL6mhsil659nFbqirL2bbnAPevWJ92FDMzS4ELZLNerKkpuK2mljOmjGLK6MFpxykYbzz6CMpHDWSu10Q2M+uVXCCb9WKPv7CJlzbtpmqWe4+zlZSIORXlPLZ6Ey++sqvjA8zMrEdxgWzWi81dWMuwAX24aPr4tKMUnMsqyikRzKtxL7KZWW/jAtmsl9qyaz+/Xr6e95xWxoC+pWnHKTjjhg3gbSeM5fZFdRxobEo7jpmZ5ZELZLNe6hdL6tnf2NTr1z5uz5zKSWzcsY+Hn97Q8c5mZtZjuEA264UigrkLazll4nCmTRiWdpyCdc7xYxg7tD/zfGc9M7NexQWyWS+0pHYrz7y8gyr3HrerT2kJl1VM5OFnNrBu256045iZWZ64QDbrheZV1zKwbynvOtWT8zpyeUU5TQG319SlHcXMzPLEBbJZL7NzXwMLlq7l4lPGM3RA37TjFLyjjhjMm445gnk1tTQ1RdpxzMwsD1wgm/Uy9y5by+79jV77+BDMqSynbsse/vT8prSjmJlZHrhANutlbl1Yy9SxQ5g5aWTaUYrGBScdyYhBfbm1ek3aUczMLA9cIJv1Ik+v386S2q3MqSxHUtpxisaAvqW857QyHlixns279qcdx8zMcswFslkvMq+6lr6l4r0zJ6YdpejMqSznQGNw52JP1jMz6+lcIJv1EnsPNHLXE/Wcf9KRjBrcL+04ReeEI4cxo3wE86prifBkPTOznswFslkvcf+K9WzdfYArvPbxYbtiVjnPbdjJ4jVb0o5iZmY55ALZrJeYV13LxJEDedMxR6QdpWhdfMoEBvcrZe5C31nPzKwnc4Fs1gu8tGkXf3p+E3Mqyikp8eS8wzW4fx/edeoE7lm2jh17D6Qdx8zMciSnBbKkCyU9I2mVpGtb2d5f0rxk+58lTc7a9oWk/RlJF+Qyp1lPd1tNLSWCSys8Oa+r5lSWs+dAI3cvXZd2FDMzy5GcFciSSoHvARcB04ArJE1rsduHgS0RcSzwX8DXk2OnAVXAScCFwP8k5zOzQ9TQ2MT8mjrOOX4s44cPTDtO0ZtRPoITjhzKXK+JbGbWY/XJ4blnAasiYjWApLnAJcBTWftcAlyfvL4d+K4yi7NeAsyNiH3AC5JWJed7LId5D9l/PPAM//u759OOYdauABqbgjmVvnNed5DEnMpyvnz3Uxz7xfvSjmNm1iP85RuP4rp3nZR2jFflskAuA7JnstQBZ7S1T0Q0SNoGHJG0P97i2LKWF5B0NXA1wKRJ+Z+ZXzl5FE1v9XJPVvhGDOzHuSeOSztGj1FVOYmdexvY29CYdhQzsx6h0O7umssCOeci4gbgBoCKioq8V6pnHTeGs44bk+/LmlnKBvYr5RPnTk07hpmZ5UguJ+nVA9l/052YtLW6j6Q+wHBgUyePNTMzMzPrdrkskKuBqZKmSOpHZtLdghb7LACuTF5fCvw2MreoWgBUJatcTAGmAgtzmNXMzMzMDMjhEItkTPE1wP1AKXBjRKyQ9BWgJiIWAP8H/DSZhLeZTBFNst9tZCb0NQAfjwgP9jMzMzOznFOmw7b4SdoIvJTCpUcDr6Rw3cNRLFmLJScUT9ZiyQnFk7VYcoKz5kKx5ITiyVosOaF4shZLTkgv61ERcdCEsh5TIKdFUk1EVKSdozOKJWux5ITiyVosOaF4shZLTnDWXCiWnFA8WYslJxRP1mLJCYWX1beaNjMzMzPL4gLZzMzMzCyLC+SuuyHtAIegWLIWS04onqzFkhOKJ2ux5ARnzYViyQnFk7VYckLxZC2WnFBgWT0G2czMzMwsi3uQzczMzMyyuEA2MzMzM8viArkLJF0o6RlJqyRdm3aetki6UdIGScvTztIeSeWSHpb0lKQVkj6VdqbWSBogaaGkpUnOL6edqSOSSiU9IemetLO0R9KLkp6UtERSTdp52iJphKTbJT0taaWkN6adqTWSjk++l82P7ZI+nXau1kj6u+T/p+WSbpU0IO1MbZH0qSTnikL6frb2WS9plKQHJT2XPI9MM2OzNrJelnxPmyQVxHJfbeT8ZvL//jJJd0kakWLEV7WR9V+SnEskPSBpQpoZm7VXl0j6rKSQNDqNbM1cIB8mSaXA94CLgGnAFZKmpZuqTTcBF6YdohMagM9GxDTgDcDHC/R7ug94W0ScCswALpT0hnQjdehTwMq0Q3TSORExo5DWw2zFt4FfR8QJwKkU6Pc2Ip5JvpczgNOB3cBd6aY6mKQy4JNARURMJ3P31ap0U7VO0nTgo8AsMv/2F0s6Nt1Ur7qJgz/rrwUeioipwEPJ+0JwEwdnXQ68F3g072nadhMH53wQmB4RpwDPAl/Id6g23MTBWb8ZEacknwH3AF/Kd6g23EQrdYmkcuB8YE2+A7XkAvnwzQJWRcTqiNgPzAUuSTlTqyLiUTK38i5oEbEuIhYnr3eQKTrK0k11sMjYmbztmzwKdrarpInAO4EfpZ2lJ5A0HDgL+D+AiNgfEVtTDdU55wLPR0QadxztjD7AQEl9gEHA2pTztOVE4M8RsTsiGoBHyBR1qWvjs/4S4Obk9c3Au/OZqS2tZY2IlRHxTEqRWtVGzgeSf3uAx4GJeQ/Wijaybs96O5gC+VnVTl3yX8A/UAA5XSAfvjKgNut9HQVYzBUrSZOB04A/pxylVcmQhSXABuDBiCjInIlvkfnAaUo5R2cE8ICkRZKuTjtMG6YAG4EfJ8NWfiRpcNqhOqEKuDXtEK2JiHrg38n0Gq0DtkXEA+mmatNy4C2SjpA0CHgHUJ5ypvaMi4h1yev1wLg0w/RAHwJ+lXaI9kj6qqRa4P0UTg/yQSRdAtRHxNK0s4ALZCtAkoYAdwCfbvHbb8GIiMbkT1YTgVnJn10LjqSLgQ0RsSjtLJ10ZkTMJDN06eOSzko7UCv6ADOB/42I04BdFM6frVslqR8wG5ifdpbWJONiLyHzy8cEYLCkD6SbqnURsRL4OvAA8GtgCdCYZqbOisy6rqn3zPUUkv6RzNDAW9LO0p6I+MeIKCeT85q087Qm+WXzixRQAe8C+fDV8/peg4lJm3WBpL5kiuNbIuLOtPN0JPnT+sMU7hjvNwOzJb1IZhjQ2yT9LN1IbUt6EomIDWTGys5KN1Gr6oC6rL8a3E6mYC5kFwGLI+LltIO04e3ACxGxMSIOAHcCb0o5U5si4v8i4vSIOAvYQmYcaqF6WdJ4gOR5Q8p5egRJVwEXA++P4rmhxC3A+9IO0YZjyPyCvDT5eTURWCzpyLQCuUA+fNXAVElTkt6ZKmBBypmKmiSRGde5MiL+M+08bZE0pnnWsqSBwHnA06mGakNEfCEiJkbEZDL/jf42IgqyZ07SYElDm1+TmahRcCuvRMR6oFbS8UnTucBTKUbqjCso0OEViTXAGyQNSj4HzqVAJz4CSBqbPE8iM/745+kmatcC4Mrk9ZXAL1PM0iNIupDMsLXZEbE77TztkTQ16+0lFO7PqicjYmxETE5+XtUBM5PP21T0SevCxS4iGiRdA9xPZsb1jRGxIuVYrZJ0K3A2MFpSHXBdRPxfuqla9WbgL4Enk/G9AF+MiPvSi9Sq8cDNyUomJcBtEVHQy6cViXHAXZn6iD7AzyPi1+lGatMngFuSX45XAx9MOU+bkl82zgM+lnaWtkTEnyXdDiwm8yfrJyiw2862cIekI4ADwMcLZZJma5/1wNeA2yR9GHgJuDy9hK9pI+tm4DvAGOBeSUsi4oL0UraZ8wtAf+DB5PPq8Yj469RCJtrI+o7kl/kmMv/+qeeE4qhLfKtpMzMzM7MsHmJhZmZmZpbFBbKZmZmZWRYXyGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZWQuSGiUtkbRc0t3N6163s/8YSX9Obj39ljzF7BEkzZbU6p0IJe3Mdx4zM/Ayb2ZmB5G0MyKGJK9vBp6NiK+2s38V8PaI+MghXKM0IoriFsXtyeXXkf3vYGaWT+5BNjNr32NAGYCkYyT9WtIiSb+XdIKkGcA3gEuSXueBks6X9JikxZLmS2outl+U9HVJi4HLOtjvy0n7k5JOSNqHSPpx0rZM0vuS9lbPk03S75JrL5T0bHNPt6RSSd+UVJ2c82NJ+9mS7sk6/rvJ7XVb+zquSDItl/T1rGN2SvqqpKWSHpc0rpVcV0n6bvJ6SvJ1PCnpX7P2eY+kh5QxPsmf2i1ozaznc4FsZtaG5G6J5/LabeRvAD4REacDnwP+JyKWAF8C5kXEDGAw8E9kepRnAjXAZ7JOuylp/00H+72StP9vci2Afwa2RcTJEXEK8FtJozs4T7Y+ETEL+DSZu2wBfDg5ZyVQCXxU0pROfHuav45Hga8DbwNmAJWS3p3sM5jMXcZOTfb7aAfn/DbwvxFxMrCuuTEi7krefxz4IZm7bqV2C1oz6/l8q2kzs4MNTG53XgasJHNL2SHAm4D5ye1lIXO72ZbeAEwD/pjs149ML3SzeZ3c787keRHw3uT124Gq5h0iYoukizs4T7bsc05OXp8PnCLp0uT9cGAqsL+Nc7T8OiqB30XERgBJtwBnAb9IztHcC72IzC2v2/Nm4H3J65+SKbybfQJYTqbgvrWD85iZdYkLZDOzg+2JiBmSBgH3k+m5vAnYmvQSt0fAgxFxRRvbd3Vyv33JcyPtf1Z3dJ6OzikyveL3v+6k0pm8/q+MA1qcaxcdOxCvTXTp6Oto1tbEmIlAEzBOUklENHXiXGZmh8VDLMzM2hARu4FPAp8FdgMvSLoMIBkPe2orhz0OvFnSscl+gyUd14X9sj1IplgnOWbkYZ4n2/3A30jqmxx/nKTBwEvANEn9lVnF49w2jl8IvFXS6GRIyhXAI4dw/Wx/5LUe8vc3N0rqA9yYnHslbQ8hMTPrFi6QzczaERFPAMvIFGfvBz4saSmwAriklf03AlcBt0paRma4wwmHu18L/wqMTCbDLQXOOczzZPsR8BSwWNJy4AdkxirXAreRGdZwG/BEawdHxDrgWuBhYCmwKCJ+eQjXz/Yp4OOSniSZGJn4IvD7iPgDmeL4I5JOPMxrmJl1yMu8mZmZmZllcQ+ymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWxQWymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWxQWymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWxQWymVkXSBon6VFJOyT9R9p5WpL0RUk/ytG5x0h6WtLALp5nsqSQ1Ke7sh3CtT8h6ev5vq6ZFTYXyGZWtCTtzHo0SdqT9f79eYpxNfAKMCwiPpuna7ZK0tmS6rLbIuL/RcRHcnTJa4GbImKPpO9L+kkrmU6VtE/SqM6eVNLvJOUqc0s/BN4vaWyermdmRcAFspkVrYgY0vwA1gDvymq7pXm/HPdMHgU8FRFxqAem0WPaXST1B64EfpY03Qy8V9LgFrv+JXBPRGzOZ77Oioi9wK+Av0o7i5kVDhfIZtbjNPekSvq8pPXAjyWNlHSPpI2StiSvJ2Yd8ztJ/yLpj8lwiQckjU62DZD0M0mbJG2VVJ0MrbiJTJH4D0mv9dsl9Zf0LUlrk8e3kmKyrVzXS5qfnH+HpCclHSfpC5I2SKqVdH5Wzg9KWpnsu1rSx5L2wWQKvQlZvegTkvP/LOv42ZJWJF/H7ySdmLXtRUmfk7RM0jZJ8yQNaOPbfAawNSLqACLiMaAeeF/W+UqBvwB+IqlE0j9Jein5un4iaXgr/3ZfBd4CfDf5Gr6btH87+V5sl7RI0luyjhko6ebk33WlpH/I7klPvg93JP/2L0j6ZIvL/g54Zxtfp5n1Qi6QzaynOhIYRaaH92oyn3c/Tt5PAvYA321xzF8AHwTGAv2AzyXtVwLDgXLgCOCvgT0RcRVwC/CNpNf6N8A/Am8AZgCnArOAf2onF8C7gJ8CI4EngPuTvGXAV4AfZB2/AbgYGJZk/S9JMyNiF3ARsDarF31t9hcn6TjgVuDTwBjgPuBuSf2ydrscuBCYApwCXEXrTgaeadH2E17fE/t2oG9ynauSxznA0cAQDv7+ExH/CPweuCb5Gq5JNlWT+Z6OAn4OzM8q3q8DJifnPQ/4QNbXXALcDSwl8/08F/i0pAuyLruSzL+VmRngAtnMeq4m4LqI2BcReyJiU0TcERG7I2IH8FXgrS2O+XFEPBsRe4DbyBRkAAfIFMbHRkRjRCyKiO1tXPf9wFciYkNEbAS+TGaYQau5krbfR8T9EdEAzCdTvH4tIg4Ac4HJkkYARMS9EfF8ZDwCPECmx7Uz5gD3RsSDybn/HRgIvClrn/+OiLXJkIi7s74HLY0AdrRo+ynw1qye+b8Cfp5c6/3Af0bE6ojYCXwBqOrsMJOI+Fnyb9gQEf8B9AeOTzZfDvy/iNiS9Gj/d9ahlcCYiPhKROyPiNVkxh1XZe2zg8wvQGZmgAtkM+u5NibjSwGQNEjSD5I/8W8HHgVGJMMAmq3Per2bTC8nZAq/+4G5ybCJb0jq28Z1JwAvZb1/KWlrNVfi5azXe4BXIqIx6z3NWSRdJOlxSZslbQXeAYxuI0u72SKiCagl07ParK3vQUtbgKHZDRGxhsz39QOShgDvJtOrfNC1k9d9gHGdCZ4M/ViZDP3YSqagbf66JyRfR7Ps10eRGXaytfkBfLHFdYcC2zqTw8x6BxfIZtZTtZw091kyPY5nRMQw4KykXR2eKOJARHw5IqaR6W29mLYnda0lU5Q1m5S0tZWr05KxzHeQ6fkdFxEjyAxfaP4aOjr367JJEplhI/WHEWcZcFwr7TeT6TF/H/BCRCxq7dpkvi8NvP6Xg2av+zqS8cb/QKaneGTydW/jta97HTAx65DyrNe1SY4RWY+hEfGOrH1OJDMEw8wMcIFsZr3HUDK9sVuVWXLsus4eKOkcSScnvc3byQy5aGpj91uBf1JmjeDRwJd4baWHrupHZmjBRqBB0kXA+VnbXwaOaG3yW+I24J2Szk16wD8L7AP+dBhZFpLpgS9r0X4HmeL3y2SK5Wa3An8naUrSu/z/gHnJsJKWXiYznrjZUDLF9Eagj6QvkRmDnf11fUGZiZhlwDVZ2xYCO5KJkQMllUqaLqkya5+3kpngaGYGuEA2s97jW2TG274CPA78+hCOPRK4nUxxvBJ4hMywi9b8K1BDpof1SWBx0tZlydjpT5IpCLeQmVS4IGv702QK0dXJcIIJLY5/hswEtu+Q+T68i8zSePsPI8t+4CayJsQl7bvIFMkTyUxgbHYjme/Zo8ALwF7gE22c/tvApcmqFP9NZnjLr4FnyQzN2Mvrh1F8BahLzvsbMv9W+5I8jWR6/Gck218BfkQy5jiZ6PcOXl/Mm1kvp8NYutPMzAxJY8isOHFa1oTD1En6G6AqIlpOwmxt308A5RHxD7lPZmbFwgWymZkVNUnjyQzJeAyYCtwLfDcivpVmLjMrXkV7FyczM7NEPzJrRU8BtpJZGu9/0gxkZsXNPchmZmZmZlk8Sc/MzMzMLIuHWJhZr9NP/WMAg9OOUbCOO2V3u9ufXTYoT0kOzw62vBIRY9LOYWbFywWymfUIki4kszxYKfCjiPhaW/sOYDBn6Ny8ZSs299+/pN3tF0yYkZcch+s3cftLHe9lZtY2D7Ews6KX3MDje8BFwDTgCknT0k1lZmbFygWymfUEs4BVEbE6uYHFXOCSlDOZmVmRcoFsZj1BGa+/s1pd0vYqSVdLqpFUcyBzkzUzM7NWuUA2s14hIm6IiIqIqOhL/7TjmJlZAXOBbGY9QT1QnvV+YtJmZmZ2yFwgm1lPUA1MlTRFUj+gCliQciYzMytSXubNzIpeRDRIuga4n8wybzdGxIqUY5mZWZFygWxmPUJE3Afcl3YOMzMrfh5iYWZmZmaWxQWymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWxQWymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWxQWymZmZmVkWF8hmZmZmZllcIJuZmZmZZXGBbGZmZmaWpU/aAczMzA6FKk9uf4eFt+cniJn1WO5BNjMzMzPL4h5kM8s7SWOAjwKTyfociogPpZXJzMysmQtkM0vDL4HfA78BGlPOYmZm9joukM0sDYMi4vNphzAzM2uNxyCbWRrukfSOtEOYmZm1xgWymaXhU2SK5L2SdiSP7WmHMjMzAw+xMLMURMTQtDOYmZm1xQWymaVC0mzgrOTt7yLinjTzWOHoaJ3jqH4yT0nMrLfyEAszyztJXyMzzOKp5PEpSf+WbiozM7MM9yCbWRreAcyIiCYASTcDTwBfSDWVmZkZ7kE2s/SMyHo9PK0QZmZmLbkH2czS8G/AE5IeBkRmLPK16UYyMzPLcIFsZnkXEbdK+h1QmTR9PiLWpxjJzMzsVR5iYWZ5I+mE5HkmMB6oSx4TkjYzM7PUuQfZzPLpM8DVwH+0si2At+U3jpmZ2cFcIJtZ3kTE1cnLiyJib/Y2SQNSiGQp8DrHZlboPMTCzNLwp062mZmZ5Z17kM0sbyQdCZQBAyWdRmYFC4BhwKAunvtFYAfQCDREREVXzmdmZr2XC2Qzy6cLgKuAicB/ZrXvAL7YDec/JyJe6YbzmJlZL+YC2czyJiJuBm6W9L6IuCPtPGZmZq1xgWxmeSPpAxHxM2CypM+03B4R/9nKYZ0VwAOSAvhBRNzQ4tpXk1lBgwFdG81hZmY9nAtkM8unwcnzkByc+8yIqJc0FnhQ0tMR8WjzxqRgvgFgmEZFDq5vZmY9hAtkM8ubiPhB8vzlHJy7PnneIOkuYBbwaPtHmZmZHcwFspnlnaRvAP8K7AF+DZwC/F0y/OJwzjcYKImIHcnr84GvdFdeOzRe59jMip3XQTazNJwfEduBi4EXgWOBv+/C+cYBf5C0FFgI3BsRv+5ySjMz65Xcg2xmaWj+7HknMD8itklqb/92RcRq4NTuCGZmZuYC2czScI+kp8kMsfgbSWOAvR0cY2ZmlhceYmFmeRcR1wJvAioi4gCwC7gk3VRmZmYZ7kE2s7yT1Bf4AHBWMrTiEeD7qYYyMzNLuEA2szT8L9AX+J/k/V8mbR9JLZGZmVnCBbKZpaEyIrIn1f02WYHCzMwsdS6QzSwNjZKOiYjnASQdDTSmnMk6yescm1lP5wLZzNLw98DDklYDAo4CPphuJDMzswwXyGaWdxHxkKSpwPFJ0zMRsS/NTGZmZs1cIJtZ3kkaAPwtcCYQwO8lfT8ivBaymZmlzgWymaXhJ8AO4DvJ+78AfgpclloiMzOzhAtkM0vD9IiYlvX+YUlPpZbGzMwsi++kZ2ZpWCzpDc1vJJ0B1KSYx8zM7FXuQTazNJwO/EnSmuT9JOAZSU8CERGnpBfNzMx6OxfIZpaGC9O8+HGn7Ob++5ekGaGgXTBhRrvb71/70/wEOUyl49NOYGbFzgWymeVdRLyUdgYzM7O2eAyymZmZmVkWF8hmZmZmZllcIJtZ3kn6emfazMzM0uAC2czScF4rbRflPYWZmVkrPEnPzPJG0t+QucX00ZKWZW0aCvwxnVRmZmav5wLZzPLp58CvgH8Drs1q3xERm9OJZGZm9noukM0sbyJiG7ANuELSmcDUiPixpNGSpkTEC/nI8eyyQR2u9duTqfLkdrd3tM5x4X/vVqUdwMyKnMcgm1neSboO+DzwhaSpH/Cz9BKZmZm9xgWymaXhPcBsYBdARKwlMw7ZzMwsdS6QzSwN+yMigACQNDjlPGZmZq9ygWxmabhN0g+AEZI+CvwG+GHKmczMzABP0jOzFETEv0s6D9gOHA98KSIeTDmWmZkZ4ALZzFKSFMQuis3MrOC4QDazvJO0g2T8cZZtQA3w2YhYnf9UZmZmGS6QzSwN3wLqyNw4REAVcAywGLgRODutYD1BR+scR/WTeUpiZlacPEnPzNIwOyJ+EBE7ImJ7RNwAXBAR84CRbR0k6UZJGyQtz2obJelBSc8lz20eb2Zm1hkukM0sDbslXS6pJHlcDuxNtrUcepHtJuDCFm3XAg9FxFTgIV5/C2szM7ND5gLZzNLwfuAvgQ3Ay8nrD0gaCFzT1kER8SiwuUXzJcDNyeubgXd3d1gzM+tdPAbZzPJKUinwtxHxrjZ2+cMhnnJcRKxLXq8Hxh12ODMzM9yDbGZ5FhGNwJk5Overd+drSdLVkmok1RxgXy4ub2ZmPYR7kM0sDU9IWgDMB3Y1N0bEnYdxrpcljY+IdZLGkxm2cZBkIuANAMM0qr1xzmZm1su5QDazNAwANgFvy2oL4HAK5AXAlcDXkudfdjmdmZn1ai6QzSzvIuKDh3OcpFvJrJE8WlIdcB2Zwvg2SR8GXgIu766chcrrHJuZ5ZYLZDPLO0kDgA8DJ5HpTQYgIj7U3nERcUUbm87tvnRmZtbbeZKemaXhp8CRwAXAI8BEYEeqiczMzBIukM0sbyQ1/9Xq2Ij4Z2BXRNwMvBM4I71kZmZmr3GBbGb5tDB5PpA8b5U0HRgOjE0nkpmZ2et5DLKZpeEGSSOBfyKzCsUQ4J/TjWRmZpbhAtnM8mmspM8kr5tXsvhe8jw4hTxmZmYHcYFsZvlUSqa3WK1s8807zMysILhANrN8WhcRX0k7RKHzOsdmZunyJD0zy6fWeo7NzMwKigtkM8sn39DDzMwKngtkM8ubiNicdgYzM7OOuEA2MzMzM8viAtnMzMzMLIsLZDMzMzOzLC6QzczMzMyyeB1kM7M88zrHZmaFzT3IZmZmZmZZXCCbmZmZmWVxgWxmZmZmlsUFspmZmZlZFhfIZmZmZmZZXCCbmZmZmWVxgWxmZmZmlsXrIJuZdTOvc2xmVtzcg2xmZmZmlsUFspmZmZlZFhfIZmZmZmZZXCCbmZmZmWVxgWxmZmZmlsUFspmZmZlZFhfIZmZmZmZZvA6ymfU6x51+NA/WzE87RtF6sCntBO2TlHYEMytyioi0M5iZ5ZWkjcBLWU2jgVdSitMZzndojoqIMWmHMLPi5QLZzHo9STURUZF2jrY4n5lZfnkMspmZmZlZFhfIZmZmZmZZXCCbmcENaQfogPOZmeWRxyCbmZmZmWVxD7KZmZmZWRYXyGbWq0m6UNIzklZJujbtPC1JelHSk5KWSKopgDw3StogaXlW2yhJD0p6LnkemWZGM7OucoFsZr2WpFLge8BFwDTgCknT0k3VqnMiYkaBLKV2E3Bhi7ZrgYciYirwUPLezKxouUA2s95sFrAqIlZHxH5gLnBJypkKWkQ8Cmxu0XwJcHPy+mbg3fnMZGbW3Vwgm1lvVgbUZr2vS9oKSQAPSFok6eq0w7RhXESsS16vB8alGcbMrKv6pB3AzMzadWZE1EsaCzwo6emkF7cgRURI8vJIZlbU3INsZr1ZPVCe9X5i0lYwIqI+ed4A3EVmWEiheVnSeIDkeUPKeczMusQFspn1ZtXAVElTJPUDqoAFKWd6laTBkoY2vwbOB5a3f1QqFgBXJq+vBH6ZYhYzsy7zEAsz67UiokHSNcD9QClwY0SsSDlWtnHAXZIg83n984j4dZqBJN0KnA2MllQHXAd8DbhN0oeBl4DL00toZtZ1vpOemZmZmVkWD7EwMzMzM8viAtnMzMzMLIsLZDMzMzOzLC6QzczMzMyyuEA2MzMzM8viAtnM7BBIapS0RNJySXdLGtHB/mMk/VnSE5LekqeYeSdpgqTbk9czJL0ja9tsSdeml87M7NB4mTczs0MgaWdEDEle3ww8GxFfbWf/KuDtEfGRQ7hGaUQ0dj1tOiRdBVRExDVpZzEzOxzuQTYzO3yPAWUAko6R9GtJiyT9XtIJkmYA3wAuSXqdB0o6X9JjkhZLmi+pudh+UdLXJS0GLutgvy8n7U9KOiFpHyLpx0nbMknvS9pbPU82Sb+T9O2snvFZSfsoSb9Izve4pFOS9rcm+y5JesaHSpqcHNsP+AowJ9k+R9JVkr6bHDtZ0m+Tcz4kaVLSfpOk/5b0J0mrJV2aw383M7N2uUA2MzsMkkqBc3nt1tQ3AJ+IiNOBzwH/ExFLgC8B8yJiBjAY+CcyPcozgRrgM1mn3ZS0/6aD/V5J2v83uRbAPwPbIuLkiDgF+K2k0R2cJ9ugJOPfAjcmbV8GnkjO90XgJ0n754CPJ/u/BdjTfJKI2J/9NUfEvBbX+Q5wc3LOW4D/zto2HjgTuJjM3fnMzFLhW02bmR2agZKWkOk5Xgk8mPTKvgmYn9wWGqB/K8e+AZgG/DHZrx+ZXuhm8zq5353J8yLgvcnrtwNVzTtExBZJF3dwnmy3Jsc9KmlYMrb6TOB9SftvJR0haRjwR+A/Jd0C3BkRdVlfd0femJX5p2R62Jv9IiKagKckjevsCc3MupsLZDOzQ7MnImZIGgTcD3wcuAnYmvSotkfAgxFxRRvbd3Vyv33JcyPtf453dJ5sLSektDlBJSK+Jule4B1kiu8LgL2duEZH9mW97nTFbWbW3TzEwszsMETEbuCTwGeB3cALki4DUMaprRz2OPBmSccm+w2WdFwX9sv2IJlineSYkYd4njnJPmeSGaqxDfg98P6k/WwyQzu2SzomIp6MiK8D1cAJLc61AxjaxnX+xGs93e9PrmFmVlBcIJuZHaaIeAJYBlxBptj7sKSlwArgklb23whcBdwqaRmZ4Q4ti8tO79fCvwIjk4lyS4FzDvE8eyU9AXwf+HDSdj1wenLs14Ark/ZPJ9dZBhwAftXiXA8D05on6bXY9gngg8mxfwl8qoOvy8ws77zMm5lZLyfpd8DnIqIm7SxmZoXAPchmZmZmZlncg2xmZmZmlsU9yGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZmZmZWRYXyGZmZmZmWVwgm5mZmZllcYFsZmZmZpbFBbKZmZmZWRYXyGZmZmZmWVwgm5mZmZllcYFsZlYEJP1O0kcO89hJknZKKu3uXC2uc5WkP+TyGmZm+eAC2cwsjyS9KGlPUrCul3STpCE5uMbbm99HxJqIGBIRjd15HTOznsoFsplZ/r0rIoYAM4DTgC+kG8fMzLK5QDYzS0lErAfuJ1MoI+kNkv4kaaukpZLObu04ScdI+q2kTZJekXSLpBHJtp8Ck4C7k17qf5A0WVJI6pPsM0HSAkmbJa2S9NGsc18v6TZJP5G0Q9IKSRVZ26+V9Hyy7SlJ78nNd8fMLD0ukM3MUiJpInARsEpSGXAv8K/AKOBzwB2SxrR2KPBvwATgRKAcuB4gIv4SWEPSSx0R32jl+LlAXXL8pcD/k/S2rO2zk31GAAuA72Ztex54CzAc+DLwM0njD/VrNzMrZC6Qzczy7xeSdgC1wAbgOuADwH0RcV9ENEXEg0AN8I6WB0fEqoh4MCL2RcRG4D+Bt3bmwpLKgTcDn4+IvRGxBPgR8FdZu/0hydEI/BQ4Neva8yNibZJxHvAcMOuQvwNmZgXMBbKZWf69OyKGAmcDJwCjgaOAy5LhFVslbQXOBA7qnZU0TtJcSfWStgM/S87RGROAzRGxI6vtJaAs6/36rNe7gQFZwzP+StKSrIzTD+HaZmZFwQWymVlKIuIR4Cbg38n0Jv80IkZkPQZHxNdaOfT/AQGcHBHDyPQ+K/vU7Vx2LTBK0tCstklAfUd5JR0F/BC4BjgiIkYAy1tc28ys6LlANjNL17eA84A/Ae+SdIGkUkkDJJ2djFNuaSiwE9iWjF3++xbbXwaObu1iEVGbXOvfkmucAnyYTC90RwaTKb43Akj6IJkeZDOzHsUFsplZipIxxD8BPglcAnyRTAFaS6bwbe1z+svATGAbmYl9d7bY/m/APyXDID7XyvFXAJPJ9CbfBVwXEb/pRNangP8AHiNThJ8M/LGj48zMio0i2vtLnJmZmZlZ7+IeZDMzMzOzLC6QzczMzMyyuEA2MzMzM8viAtnMzMzMLEuftAN0l9GjR8fkyZPTjmFmZmZmRWLRokWvRMSYlu09pkCePHkyNTU1accwMzMzsyIh6aXW2j3EwszMzMwsiwtkMzMzM7MsLpDNzMzMzLK4QDYzsx7r8u8/xg2PPp92DDMrMi6QzcysR9q0cx8LX9zMQys3pB3FzIqMC2QzM+uRlq/dDsCKtdtpaoqU05hZMXGBbGZmPdLy+m0A7NzXwEubd6ecxsyKiQtkMzPrkVas3UbfUgGvFctmZp3hAtnMzHqk5fXbeetxY+lXWsLytS6QzazzXCCbmVmPs233AdZs3s1pk0Zw/JFDWVG/Pe1IZlZEXCCbmVmPs2Jdpsd4etlwppcNY/nabUR4op6ZdY4LZDMz63Gae4xPmjCMkyYMZ+vuA9Rv3ZNyKjMrFi6Qzcysx1m+dhvjhw9g9JD+TC8bnmnzMAsz6yQXyGZm1uMsr9/GSRMyhfEJRw6ltESs8EQ9M+skF8hmZtaj7NzXwOpXdjG9bBgAA/qWMnXsEJ70Um9m1kkukM3MrEdZuW47EXByMrQCMpP1ltd7op6ZdU4qBbKkCyU9I2mVpGvb2OdySU9JWiHp5/nOaGZmxan5piDTswvkCcN4Zed+NuzYl1YsMysiffJ9QUmlwPeA84A6oFrSgoh4KmufqcAXgDdHxBZJY/Od08zMitPy+u2MHtKfsUP7v9r22kS9bYwbNiCtaGZWJNLoQZ4FrIqI1RGxH5gLXNJin48C34uILQARsSHPGc3MrEitWLuN6WXDkPRq24njhyF5JQsz65w0CuQyoDbrfV3Slu044DhJf5T0uKQLWzuRpKsl1Uiq2bhxY47implZsdh7oJHnNuxk+oThr2sf3L8PR48e7FtOm1mnFOokvT7AVOBs4Argh5JGtNwpIm6IiIqIqBgzZkx+E5qZWcF5ev0OGpvi1RUssk0vG84Kr2RhZp2QRoFcD5RnvZ+YtGWrAxZExIGIeAF4lkzBbGZm1qbmCXontehBBpg+YThrt+1l005P1DOz9qVRIFcDUyVNkdQPqAIWtNjnF2R6j5E0msyQi9V5zGhmZkVoef02hg/sy8SRAw/adlLSq7x8rcchm1n78l4gR0QDcA1wP7ASuC0iVkj6iqTZyW73A5skPQU8DPx9RGzKd1YzMysuy9du4+Sy4a+boNesuVd5uYdZmFkH8r7MG0BE3Afc16LtS1mvA/hM8jAzM+vQ/oYmnlm/gw+dOaXV7cMH9uWoIwb5ltNm1qFCnaRnZmZ2SJ59eQcHGuOgFSyyTZ8w3Eu9mVmHXCCbmVmP0NwznH0HvZZOKhvGms272bb7QL5imVkRcoFsZmY9wvL67Qzp34ejRg1qc5/m3uUV6zzMwsza5gLZzMx6hOVrtzFtwjBKSg6eoNfspAmZlSxWeJiFmbXDBbKZmRW9hsYmVq7b3u74Y4AjhvRnwvABvqOembXLBbKZmRW95zfuYu+BplbvoNfSSWXDedJLvZlZO1wgm5lZ0Wte2/jkdiboNTu5bDgvvLKLnfsach3LzIqUC2QzMyt6y9duY0DfEo4eM6TDfaeXDSMCVq7zOGQza50LZDMzK3or6rczbfwwStuZoNdsuu+oZ2YdcIFsZmZFrakpWLF2W7vrH2cbO2wAY4b29w1DzKxNXSqQJQ2S9M+Sfpi8nyrp4u6JZmZm1rEXN+1i1/7GDlewyDZ9wjDfctrM2tTVHuQfA/uANybv64F/7eI5zczMOm352kxP8EmdWMGi2fSy4Ty3YSd7DzTmKpaZFbGuFsjHRMQ3gAMAEbEb6HgAmJmZWTdZUb+NfqUlTB07tNPHnDRhOI1NwdPrd+QwmZkVq64WyPslDQQCQNIxZHqUzczM8uLJ+m2cMH4o/fp0/kfayROHv3qsmVlLXS2Qrwd+DZRLugV4CPh8V0OZmZl1RkSwvH4bJx3C+GOACcMHMHJQX1a4QDazVvTpysER8YCkRcAbyAyt+FREvNItyczMzDpQt2UP2/c2dOoOetkkMb1suG85bWat6uoqFg9FxKaIuDci7omIVyQ91F3hzMzM2tO8lvGhrGDR7KQJw3lm/Q72NzR1dywzK3KHVSBLGiBpFDBa0khJo5LHZKCsWxOamZm1YfnabZSWiOOP7PwEvWbTy4ZxoDF49mVP1DOz1zvcIRYfAz4NTAAW8drKFduB73Y9lpmZWceW129n6tghDOhbesjHNvc6H8pNRsysdzisHuSI+HZETAE+FxFHR8SU5HFqRLhANjOznGueoHe4xe2kUYMY2r+P76hnZgfp6iS970iaDkwDBmS1/6SrwczMzNrz8vZ9bNq1n+kTDm2CXrOSEjFtwjBP1DOzg3R1kt51wHeSxznAN4DZ3ZDLzMysXc1rGDevaXw4Ti4bzsp122lo9EQ9M3tNV9dBvhQ4F1gfER8ETgU6/KSSdKGkZyStknRtO/u9T1JIquhiTjMz62GW129DghPHH14PMmRuOb33QBPPb9zVjcnMrNh1tUDeExFNQIOkYcAGoLy9AySVAt8DLiIzNOMKSdNa2W8o8Cngz13MaGZmPdCKtds4ZswQBvU7/NGCzesnL/cNQ8wsS1cL5BpJI4AfklnNYjHwWAfHzAJWRcTqiNgPzAUuaWW/fwG+DuztYkYzM+uBltdvP+zxx82mjB7CwL6lHodsZq9z2AWyJAH/FhFbI+L7wHnAlclQi/aUAbVZ7+tosXaypJlAeUTc20GGqyXVSKrZuHHjoX8RZmZWlDbu2Mf67Xu7vDxbaTJRb4VXsjCzLIddIEdEAPdlvX8xIpZ1NZCkEuA/gc92IsMNEVERERVjxozp6qXNzKxIrEh6fE86jDvotTR9wjBWrN1GU1N0+Vxm1jN0dYjFYkmVh3hMPa8fpzwxaWs2FJgO/E7Si8AbgAWeqGdmZs1WrM30+E7r4hALgJPKhrNrfyMvbvJEPTPL6GqBfAbwmKTnJS2T9KSkjnqRq4GpkqZI6gdUAQuaN0bEtogYHRGTI2Iy8DgwOyJqupjVzMx6iOX12zjqiEEMH9i3y+dqvqPe8rUeZmFmGV26UQhwwaEeEBENkq4B7gdKgRsjYoWkrwA1EbGg/TOYmVlv92T9Nk4tH9Et55o6bgj9+pSwvH4bs0+d0C3nNLPi1tU76b10mMfdR9b45aTtS23se/bhXMPMzHqmrbv3U7dlD+8/46huOV/f0hJOPHKol3ozs1d1dYiFmZlZXjWPP25ew7g7nFQ2nOX128jMPzez3s4FspmZFZXmnt7uWMGi2fQJw9m+t4G6LXu67ZxmVry6XCBLOkrS25PXA5M74JmZmeXE8rXbKRsxkFGD+3XbOX1HPTPL1qUCWdJHgduBHyRNE4FfdDGTmZlZm1bUb+OkbljeLdtx44bSp0S+o56ZAV3vQf448GZgO0BEPAeM7WooMzOz1uzYe4DVr+zq8h30WhrQt5Sp44ay3HfUMzO6XiDvi4j9zW8k9QE8w8HMzHJi5bodQPdO0Gs2fcIwT9QzM6DrBfIjkr4IDJR0HjAfuLvrsczMzA72ZDJGuLt7kAFOnjicTbv2s3773m4/t5kVl64WyNcCG4EngY8B90XEP3Y5lZmZWStW1G9j7ND+jB06oNvP3bwqhodZmFlXC+TrI+KHEXFZRFwK3Cjplu4IZmZm1tLytdty0nsMcOL4oZTIK1mYWdcL5HJJXwCQ1A+4A3iuy6nMzMxa2LO/kVUbdjK9m1ewaDaoXx+OGTOEFV7JwqzX62qB/CHg5KRIvgd4JCKu73IqMzOzFlau305TZO56lyvTy4Z7iIWZHV6BLGmmpJnAacC3gTlkeo4fSdrNzMy61YocTtBrdtKEYazfvpeNO/bl7BpmVvj6HOZx/9Hi/RZgWtIewNu6EsrMzKyl5fXbGTmoLxOGd/8EvWbNxfeKtds4+3gv62/WWx1WgRwR53R3EDMzs/Y0T9CTlLNrTEvGN69Yu90FslkvdlgFsqQPRMTPJH2mte0R8Z9di2VmZvaafQ2NPPvyDj7ylqNzep1hA/oyZfRgnqzzRD2z3uxwh1gMTp6HdlcQMzOztjy7ficHGoPpE3I3/rjZSROGsaR2a86vY2aF63CHWPwgef5y98YxMzM72PK1zRP0crPEW7bpZcO5Z9k6tu7ez4hB/XJ+PTMrPF1a5k3S0ZLulrRR0gZJv5SU279/mZlZr7O8fhtDB/Rh0qhBOb9Wcy/1irVe7s2st+rqOsg/B24DxgMTgPnArV0NZWZmlm352u2cNGFYTifoNTspmajnO+qZ9V5dLZAHRcRPI+L/t3fnQXaVdRrHv0+6k5C1k0AISYclEhGTZhEijIjIjJSCCkHFQcRRkBGrBlBHUSkdEXWsQpkaHfeh1MGFIQ6gDiKbCijFNkRIQicBDIuYRQiiHSCEkOQ3f5z3huOlu9N9z7lL+j6fqq4+d3vO27fvefvX733fe7akrx8C9fv8HTMzazvPb93GynUbGjL/GGDqhDF0TxlHr0eQzdpWrYv0Kq6VdB6wiOzzj08GrpE0DSAiniyYb2Zmbe7B9U+zecu2up4gpFpP9+TtJyYxs/ZTtED++/T9/VXXv4OsYPZ8ZDMzK6Ry6udGLNCr6JnVxfXLH+OpTc8zaZfRDduvmbWGQlMsImLOIF8DFseSjpV0v6RVaQS6+vYPS1ohaZmkX0nau0g7zcxs59W7po/xYzqYs9vEhu2zZ3Y2Wr3C0yzM2lJNBbKkV0raI3f53ekTLL5SmV4xyGM7gK8Dx5GdnvoUSfOq7nYPsCAiDgSuAL5YSzvNzGzn17umj3kzJ9Mxqv4L9Coq8509D9msPdU6gvyfwGYASUcBFwLfB/qAi3fw2MOAVRHxUERsJpu/vDB/h4i4KSI2pot3ALNrbKeZme3Etm4LVqzb0ND5xwDTJ41lxuSxnods1qZqLZA7cgvwTgYujogrI+JTwNwdPLYb+EPu8up03UDOAK7t7wZJZ0paLGnx+vXrh9h0MzPbWTz8xDNs3Lx1+0evNVLPrK7tJygxs/ZSc4EsqbLA73XAjbnbii78207Su4AFwEX93R4RF0fEgohYMH369LJ2a2ZmLWL59jPoNXYEGWB+dxerHn+aZzdvbfi+zay5ai2QLwN+Lel/gWeBWwAkzSWbZjGYNcCeucuz03V/RdIxwCeBEyLiuRrbaWZmO7HeNX2M6RzF3N0bt0CvomfWZLYFrPyj5yGbtZuaCuSI+DzwEeAS4MiIiFzeOTt4+F3ASyXNkTSG7CPhrsrfQdIryOY5nxARj9fSRjMz2/n1rtnAy/eYxOiOoue1Gr7KqLXnIZu1n5qnQ0TEHf1c98AQHrdF0tnA9UAH8N2IWC7ps8DiiLiKbErFRODydFrRRyPihFrbamZmO5+IoHdtH8cfNKsp+5/ZtQvTJozZ/jnMZtY+SpsvPBwRcQ1wTdV15+e2j2l4o8zMrKU8+uRGntq0hQOaMP8YQBI93V3c6xFks7bT+PeszMzMhmD7GfRmNadAzvY9mQcee4rntnihnlk7cYFsZmYtqXdtH52jxH57NH6BXkVPdxdbtgUP/PHpprXBzBrPBbKZmbWk3jV97DdjEmM7O5rWhhfOqOdpFmbtxAWymZm1nIhg+doN9HQ3/gQheXtOG8ekXTrp9Txks7biAtnMzFrOur5NPPnM5qacICRPUjqjnj/JwqyduEA2M7OWUxmxnd/EBXoVPd2TWbluA89v3dbspphZg7hANjOzltO7dgOjBPNmNneKBWQL9TZv2caD671Qz6xduEA2M7OW07umj7m7T2TcmOYt0KuoTPO4d7XnIZu1CxfIZmbWcnrX9DX184/z5uw6gQljOljuechmbcMFspmZtZTHN2zi8aeeY36TF+hVjBol5s2a7E+yMGsjLpDNzKylVEZqe2Y1f/5xxfxZXaxYt4Gt26LZTTGzBnCBbGZmLaUyUjuvhQrknu4uNm7eysNPPNPspphZA7hANjOzltK7to85u01g0i6jm92U7SonLFnuM+qZtQUXyGZm1lJ612xgfguNHgPMnT6RsZ2jPA/ZrE24QDYzs5bx52c2s+Yvzzb9DHrVOjtGsf/MyfSu8SdZmLUDF8hmZtYyetMUhgNarEAGOKB7Mr1r+4jwQj2zkc4FspmZtYzKCG2rTbEA6JnVxVObtvDokxub3RQzqzMXyGZm1jJ61/Yxe+o4powf0+ymvEhl2oenWZiNfC6QzcysZSxvoTPoVXvpjImM7tD2aSBmNnK5QDYzs5awYdPzPPKnjds/Uq3VjO3sYL8Zk/xJFmZtwAWymZm1hBXpDHqtcorp/vTM6mL52g1eqGc2wrlANjOzllAZmW3VKRaQnTDkyWc2s65vU7ObYmZ11JQCWdKxku6XtErSef3cPlbSj9Ltd0rapwnNNDOzBlq+dgMzJo9l+qSxzW7KgOZvX6jnaRZmI1nDC2RJHcDXgeOAecApkuZV3e0M4M8RMRf4EvCFxrbSzMwa7d41fS35+cd582ZOpmOUXCCbjXCdTdjnYcCqiHgIQNIiYCGwInefhcAFafsK4GuSFC026eve1X2sXOeP+zEzK2pbBA+uf5o3HTCz2U0Z1C6jO5g7fSI33b+e2VPHN7s5ZiPG3BkTOWSvqc1uxnbNKJC7gT/kLq8GDh/oPhGxRVIfsCvwRP5Oks4EzgTYa6+96tXeAV23fB1fv+nBhu/XzGykOnzOtGY3YYcOf8k0vn/77/nYlcua3RSzEeO0I/Zp+wK5NBFxMXAxwIIFCxo+unzmUfvyzsP3bvRuzcxGpLGdo9htYuvOP6749PHzef9r9212M8xGlAljOprdhL/SjAJ5DbBn7vLsdF1/91ktqRPoAv7UmOYNXde40XSNG93sZpiZWQN1jBLdU8Y1uxlmVkfN+BSLu4CXSpojaQzwDuCqqvtcBbwnbZ8E3Nhq84/NzMzMbGRq+AhymlN8NnA90AF8NyKWS/ossDgirgK+A/xA0irgSbIi2szMzMys7poyBzkirgGuqbru/Nz2JuDtjW6XmZmZmZlGyswFSeuB3zdh17tR9ekaLZzbzpn1ym3nzHrltnNmvXJ3lsx65bZzZr1y2zmzXrk7S2a9cuvV1h3ZOyKmV185YgrkZpG0OCIW7Ay57ZxZr9x2zqxXbjtn1it3Z8msV247Z9Yrt50z65W7s2TWK7deba1VU041bWZmZmbWqlwgm5mZmZnluEAu7uKdKLedM+uV286Z9cpt58x65e4smfXKbefMeuW2c2a9cneWzHrl1qutNfEcZDMzMzOzHI8gm5mZmZnluEA2MzMzM8txgTxMkvaXdLuk5ySd28/tHZLukXR10UxJu0j6P0lLJS2X9JkSMveUdJOkFSnzg0Uz023flfS4pN6h5g0x91hJ90taJem84WanjKmSfiJpWXo+e2rJqcrskvSz3O/m9KKZKfejkpakr15JWyVNKyH36JS5XNKvS8rry7X1/B0/asjZr5S0RdJJJeUtTL/7JZIWSzqyhMxTU+a9km6TdFAJmYP2LQVyCx9DVXk1H+uDZNbcLw2SWXP/OYTsYffzQ8h8JL2elkhaXFLmFElXSLpP0kpJryoh82W5436JpA2SPlRC7j+n31OvpMsk7VJC5gdT3vIibezvNS9pmqRfSPpd+j61hMy3p7ZukzTsjzsbIPOi9Ptflv4OTikh83O5PvUGSbPKaGvuto9ICkm7DTe3VBHhr2F8AbsDrwQ+D5zbz+0fBv4buLpoJiBgYtoeDdwJ/E3BzJnAIWl7EvAAMK/ozw4cBRwC9Jb1nJKdivxB4CXAGGDpUNtalX8R8Om0vT/wqxJeB58AvpC2p5OdEn1Mya+144EbS8iZAqwA9qo83yVkHj2c1/gwcjuAG8nOtHlSSZkTeWG9xYHAfSVkHgFMTdvHAXeWkDlo31Lg+Sx8DFVl1nysD5JZc780SGbN/ecQsofdzw8h8xFgt7LyUub3gH9M22OAKSXndwB/JDvRQpGcbuBhYFy6/D/AaQUze4BeYDzZWYN/CcytMetFr3ngi8B5afu8yt+DgpkvB14G3AwsKKmdrwc60/YXSmrn5Nz2B4BvldHWdP2ewPVkJ34r9XgY7pdHkIcpIh6PiLuA56tvkzQbeBPw7TIyI/N0ujg6fQ1pVeUgmesi4u60/RSwkqxzqjkz3fYbsiJx2AbJPQxYFREPRcRmYBGwsIZdzCMruoiI+4B9JM2opa05AUySJLIC7ElgS8HMaqcAl5WQ807gxxHxKGTPdwmZ9XIOcCVQWhsj4ulIPS8wgSEeQzvIvC0i/pwu3gHMLiFzwOOrgLKOoe2KHOuDZNbcLw2SWXP/OZha+/lGk9RFVoR8ByAiNkfEX0rezeuAByOijLPYdgLjJHWSFbVrC+a9nOwf140RsQX4NfDWWoIGeM0vJPsHhPT9xKKZEbEyIu6vpY2DZN6Qfn6ooa8aIHND7mJNfeog/ciXgI/Vklk2F8jl+jLZL3ZbWYHprbwlZAXDLyLizhKz9wFeQTay0oq6gT/kLq+mtj+aS0kdo6TDgL0pXtB8jawDXgvcC3wwIsr8vY8HjiUrFovaD5gq6WZJv5X07hIyAV6V3r6+VtL8omGSuoG3AN8s3rQXZb9F0n3Az4H3lhx/BnBtyZllKesYapgy+6U69Z9fpuR+PgnghnSMnllC3hxgPfBfaTrItyVNKCE37x2U8E98RKwB/g14FFgH9EXEDQVje4HXSNo19advJBudLMuMiFiXtv8IFB10aYT3UlJfJenzkv4AnAqUMsVO0kJgTUQsLSOvKBfIJZH0ZuDxiPhtmbkRsTUiDiYr6A5TCfNnASRNJCu+PlT13+BIdCEwJf2hPAe4B9haMPMNwBJgFnAw8DVJkwtm5h0P3BoRZYzUdQKHko16vQH4lKT9CmbeTfa26kHAV4GfFsyDrPD4eJn/aFRExE8iYn+yUZ7PlZUr6W/JCuSPl5XZzsrul8ruP+vVzydHRsQhZFN2zpJ0VMG8TrK3sL8ZEa8AniGbClAKSWOAE4DLS8iaSjYiO4esT50g6V1FMiNiJdmUghuA68j666L9/kD7ClpgxHMwkj5J9i7npWXkRcQnI2LPlHd20bz0T8wnKKnYLoML5CGQdFZuQcJAk9FfDZwg6RGytzH/TtIPC2Zul94au4lsVLFQpqTRZH+ELo2IHw+23+G2c6iGmLuGv/6Pf3a6blj5ZPMQT09/KN9NNmf4oSJtBs4im7YQEbGKbP7c/sPNrM7NPReFRmaq2roWuD4inomIJ4DfAMNeVNbPc/o0QERcA4yuZUFFVeYCYFE6hk4CviHpxOFmVufmX1/pbb2XFG2rpFmSDiR7m31hRPypzHaWqOZjqNGG0y8N11D6zyEaVj8/HGkUtTIF6idk02OKWA2szo2aX0FWMJflOODuiHishKxjgIcjYn1EPA/8mGyefyER8Z2IODQijgL+TDa3vSyPSZoJkL637NQ1SacBbwZOzU03K8ulwNtKyNmX7B+kpen4mg3cLWmPErJrM5wJy/76q4nkFzDAQhpqXMBUnUlWyE1J2+OAW4A3F8wU8H3gy2X/7MA+FFi4009bO8kK2Tm8sMBofg25U0gL6ID3Ad8v4ff/TeCCtD2DrOgoZUEB0EU2N2tCSXkvB36Vns/xZG899hTM3IMXFr4dRvbWqMpob8q8hPIW6c3NtfWQ9Lsq1FZgL2AVcERZP3Mue8C+pYasUo6hfnILHev95BXul/rJLNx/7iC/pn5+gKwJwKTc9m3AsSXk3gK8LPe6uqjEn38RcHpJWYcDy1P/JLI5veeUkLt7+r4XcB8FFilWv+bJFn/nF+l9sWhm7vqbqWGR3gDtPJZskfb0En/2l+a2zwGuKCO36rZHaPIivabteGf9SoXBamAD8Je0PbnqPsPqOAfKJFtxfw+wjKyoOb+EzCPJ3gpaRvaW0xLgjUV/drLRznVkC4xWA2eU8ZySzRt7gGwl/idr/J29KmXcTzYyMbWE18Essrfu7k2/m3eV+Bo7DVhU8uv2o6mT7CV7+7po3tlkf9CWki38KLVQpNwC+eOprUuA28neyi6a+W2yEanKMbS4hMwd9i015hY+hqryaj7WB8msuV8aJLPm/nOI+UdTXoH8knQsLU2v1cK/p5R7MLA4PQc/LaPvS7kTgD8BXSU+n58hK2J7gR8AY0vIvCX1e0uB1xXIedFrHtiVbODhd2SfkDGthMy3pO3ngMfI3vkrmrmKbB1C5bga1idODJB5Zfo9LQN+BnSX8ZxW3f4ITS6QfappMzMzM7Mcz0E2MzMzM8txgWxmZmZmluMC2czMzMwsxwWymZmZmVmOC2QzMzMzsxwXyGZmBUnamk720SvpZ5Km7OD+F0g6dwf3OVHSvNzlz0o6pqQmF5JOlHJF2j5Y0htzt50gqbQztpmZNYMLZDOz4p6NiIMjoofsJC9nlZB5IrC9QI6I8yPilyXkFhYRayPipHTxYLLPWq7cdlVEXNiUhpmZlcQFsplZuW4HugEk7SvpOkm/lXSLpBedjlzS+yTdJWmppCsljZd0BHACcFEamd5X0iWSTpJ0rKTLc48/WtLVafv1km6XdLekyyVN7Gd/N0v6j9yI92Hp+mmSfippmaQ70qm0kfTa3Omw75E0SdI+6bFjgM8CJ6fbT5Z0mqSvpcfuI+nGlPkrSXul6y+R9BVJt0l6SNJJ1e00M2smF8hmZiWR1AG8DrgqXXUx2SlzDwXOBb7Rz8N+HBGvjIiDgJVkZ5S6LWV8NI1MP5i7/y+BwyVNSJdPBhZJ2g34F+CYiDiE7AxqHx6gqeMj4mDgn4Dvpus+A9wTEQcCnyA79TOp3Wel+78GeLYSEhGbgfOBH6V2/qhqP18FvpcyLwW+krttJtkZ9N4MeMTZzFpKZ7MbYGY2AoyTtIRs5Hgl8Is0ensEcLmkyv3G9vPYHkn/CkwBJgLXD7ajiNgi6Trg+DQP+E3Ax4DXkk3JuDXtbwzZaHZ/LktZv5E0Oc2ZPhJ4W7r+Rkm7SpoM3Ar8u6RLyYr51bmfZ0deBbw1bf8A+GLutp9GxDZghaQZQw00M2sEF8hmZsU9GxEHSxpPVuCeBVwC/CWNvA7mEuDEiFgq6TTg6CHsbxFwNtl858UR8ZSyqvUXEXHKEB4fO7j8wg0RF0r6Odk841slvQHYNIR97Mhzue0hV9xmZo3gKRZmZiWJiI3AB4CPABuBhyW9HUCZg/p52CRgnaTRwKm5659Kt/Xn18AhwPvIimWAO4BXS5qb9jdB0n4DPP7kdJ8jgb6I6ANuqexf0tHAExGxQdK+EXFvRHwBuAuonkc9WDtvA96Rtk9N+zAza3kukM3MShQR9wDLgFPIisIzJC0FlgML+3nIp4A7yaYy3Je7fhHw0bQwbt+qfWwFrgaOS9+JiPXAacBlkpaRTa940aLAZJOke4BvAWek6y4ADk2PvRB4T7r+Q2lB3jLgeeDaqqybgHmVRXpVt50DnJ4e+w/ABwdoj5lZS1HEgO+smZnZCCPpZuDciFjc7LaYmbUqjyCbmZmZmeV4BNnMzMzMLMcjyGZmZmZmOS6QzczMzMxyXCCbmZmZmeW4QDYzMzMzy3GBbGZmZmaW8//tIF9vlvvIUAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 720x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot data\n",
+    "_num_neurons = shape[0]\n",
+    "_num_neurons_relational = shape_relational[0]\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "ax0 = plt.subplot(4, 1, 1)\n",
+    "ax0.plot(np.mean(data_target[50:70, :], axis=0))\n",
+    "ax0.set_xlabel('Target neuron idx')\n",
+    "ax0.set_ylabel('Spike rate')\n",
+    "ax0.set_xticks(range(_num_neurons))\n",
+    "ax0.set_title('Target')\n",
+    "\n",
+    "ax1 = plt.subplot(4, 1, 2)\n",
+    "ax1.plot(np.mean(data_reference[50:70, :], axis=0))\n",
+    "ax1.set_xlabel('Reference neuron idx')\n",
+    "ax1.set_ylabel('Spike rate')\n",
+    "ax1.set_xticks(range(_num_neurons))\n",
+    "ax1.set_title('Reference')\n",
+    "\n",
+    "ax2 = plt.subplot(4, 1, 3)\n",
+    "ax2.imshow(np.mean(data_transformation[50:70, :],\n",
+    "                   axis=0).reshape(shape + shape))\n",
+    "ax2.set_title('Transformation (Voltage)')\n",
+    "ax2.set_xlabel('Reference position')\n",
+    "ax2.set_ylabel('Target position')\n",
+    "ax2.set_xticks(range(0, _num_neurons, 5))\n",
+    "ax2.set_yticks(range(0, _num_neurons, 5))\n",
+    "\n",
+    "ax3 = plt.subplot(4, 1, 4)\n",
+    "ax3.plot(np.mean(data_relational[50:70], axis=0))\n",
+    "ax3.set_xlabel('Relative position')\n",
+    "ax3.set_ylabel('Spike rate')\n",
+    "ax3.set_title('Relational')\n",
+    "plt.xticks(ticks=range(_num_neurons_relational),\n",
+    "           labels=range(-int(_num_neurons_relational/2),\n",
+    "                        int(_num_neurons_relational/2) + 1))\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bidirectional connectivity\n",
+    "The diagram at the beginning of this tutorial depicts a relational network with connections that flow in only one direction, toward the relational DNF. Relational networks can also be set up with bidirectional connectivity, coupling all four DNFs in both directions. This enables reading out the target (or reference) position given both the relative position and the reference (or target) position.\n",
+    "\n",
+    "The Lava implementation demonstrates how to set up connectivity from the relational DNF to the transformation DNF, which results in the faint diagonal line in the plot of the transformation DNF. A complete bidirectional DNF would additionally have connections from the transformation DNF to the target and reference DNFs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Diagonal projection operations\n",
+    "\n",
+    "The two operations that enable the diagonal projections between the relational DNF and the transformation DNF are the `ReduceAlongDiagonal` (toward relational DNF) and `ExpandAlongDiagonal` (toward transformation DNF). The connectivity matrix produced by the operation `ReduceAlongDiagonal` sums the spike output of the transformation DNF along its diagonaland is shown below for the network demonstrated above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Neuron idx relational DNF')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x1008 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(14, 14))\n",
+    "plt.imshow(data_weights_reduce_diag)\n",
+    "plt.title('Connectivity matrix (diagonal read-out)')\n",
+    "plt.xlabel('Neuron idx transformation DNF')\n",
+    "plt.ylabel('Neuron idx relational DNF')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The operation `ExpandAlongDiagonal` produces a connectivity matrix that projects the spike output of the relational DNF into the transformation DNF along its diagonal. The connectivity matrix is shown below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Neuron idx transformation DNF')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x1008 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(14, 14))\n",
+    "plt.imshow(data_weights_expand_diag)\n",
+    "plt.title('Connectivity matrix (diagonal write-in)')\n",
+    "plt.xlabel('Neuron idx relational DNF')\n",
+    "plt.ylabel('Neuron idx transformation DNF')"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
\ No newline at end of file


Test patch:
diff --git a/tests/lava/lib/dnf/acceptance/test_connecting_with_ops.py b/tests/lava/lib/dnf/acceptance/test_connecting_with_ops.py
index c43a908..9b59a00 100644
--- a/tests/lava/lib/dnf/acceptance/test_connecting_with_ops.py
+++ b/tests/lava/lib/dnf/acceptance/test_connecting_with_ops.py
@@ -11,8 +11,13 @@
 
 from lava.lib.dnf.connect.connect import connect
 from lava.lib.dnf.kernels.kernels import SelectiveKernel, MultiPeakKernel
-from lava.lib.dnf.operations.operations import Weights, ReduceDims, Reorder, \
-    ExpandDims, Convolution
+from lava.lib.dnf.operations.operations import (
+    Weights,
+    ReduceDims,
+    ReorderDims,
+    ExpandDims,
+    Convolution
+)
 
 
 class TestConnectingWithOperations(unittest.TestCase):
@@ -30,7 +35,7 @@ def test_running_reorder(self) -> None:
 
         weight = 20
         connect(src.s_out, dst.a_in, ops=[Weights(weight),
-                                          Reorder(order=(1, 0))])
+                                          ReorderDims(order=(1, 0))])
         src.run(condition=RunSteps(num_steps=num_steps),
                 run_cfg=Loihi1SimCfg(select_tag='floating_pt'))
 
@@ -87,7 +92,7 @@ def test_connect_population_3d_to_2d_with_reduce_dims_and_reorder(self)\
         for dims, order, expected in zip(reduce_dims, orders, matrices):
             source = LIF(shape=(2, 2, 2))
             destination = LIF(shape=(2, 2))
-            reorder_op = Reorder(order=order)
+            reorder_op = ReorderDims(order=order)
             reduce_op = ReduceDims(reduce_dims=dims)
             computed = connect(source.s_out,
                                destination.a_in,
@@ -158,7 +163,7 @@ def test_connect_population_2d_to_3d_with_expand_dims_and_reorder(self)\
         for order, expected in zip(orders, matrices):
             source = LIF(shape=(2, 2))
             destination = LIF(shape=(2, 2, 2))
-            reorder_op = Reorder(order=order)
+            reorder_op = ReorderDims(order=order)
             expand_op = ExpandDims(new_dims_shape=(2,))
             computed = connect(source.s_out,
                                destination.a_in,
@@ -229,7 +234,7 @@ def test_connect_population_1d_to_3d_with_expand_dims_and_reorder(self) \
         for order, expected in zip(orders, matrices):
             source = LIF(shape=(2,))
             destination = LIF(shape=(2, 2, 2))
-            reorder_op = Reorder(order=order)
+            reorder_op = ReorderDims(order=order)
             expand_op = ExpandDims(new_dims_shape=(2, 2))
             computed = connect(source.s_out,
                                destination.a_in,
diff --git a/tests/lava/lib/dnf/connect/test_connect.py b/tests/lava/lib/dnf/connect/test_connect.py
index 1c0302e..b025b8b 100644
--- a/tests/lava/lib/dnf/connect/test_connect.py
+++ b/tests/lava/lib/dnf/connect/test_connect.py
@@ -13,7 +13,7 @@
 from lava.lib.dnf.connect.exceptions import MisconfiguredConnectError
 from lava.lib.dnf.operations.operations import AbstractOperation
 from lava.lib.dnf.operations.shape_handlers import AbstractShapeHandler,\
-    KeepShapeHandler
+    KeepShapeShapeHandler
 from lava.lib.dnf.operations.exceptions import MisconfiguredOpError
 from lava.lib.dnf.utils.convenience import num_neurons
 
@@ -29,7 +29,7 @@ def __init__(self, shape: ty.Tuple[int, ...] = (1,)) -> None:
 class MockNoChangeOperation(AbstractOperation):
     """Mock Operation that does not change shape"""
     def __init__(self) -> None:
-        super().__init__(shape_handler=KeepShapeHandler())
+        super().__init__(shape_handler=KeepShapeShapeHandler())
 
     def _compute_weights(self) -> np.ndarray:
         return np.eye(num_neurons(self.output_shape),
diff --git a/tests/lava/lib/dnf/operations/test_operations.py b/tests/lava/lib/dnf/operations/test_operations.py
index 8953ae4..452118b 100644
--- a/tests/lava/lib/dnf/operations/test_operations.py
+++ b/tests/lava/lib/dnf/operations/test_operations.py
@@ -5,6 +5,7 @@
 import unittest
 import numpy as np
 import typing as ty
+import itertools as it
 
 from lava.lib.dnf.operations.operations import (
     AbstractOperation,
@@ -12,10 +13,13 @@
     ReduceDims,
     ReduceMethod,
     ExpandDims,
-    Reorder,
-    Convolution)
+    ReorderDims,
+    Convolution,
+    ReduceAlongDiagonal,
+    ExpandAlongDiagonal,
+    Flip)
 from lava.lib.dnf.operations.enums import BorderType
-from lava.lib.dnf.operations.shape_handlers import KeepShapeHandler
+from lava.lib.dnf.operations.shape_handlers import KeepShapeShapeHandler
 from lava.lib.dnf.kernels.kernels import Kernel
 from lava.lib.dnf.utils.convenience import num_neurons
 
@@ -23,7 +27,7 @@
 class MockOperation(AbstractOperation):
     """Generic mock Operation"""
     def __init__(self) -> None:
-        super().__init__(shape_handler=KeepShapeHandler())
+        super().__init__(shape_handler=KeepShapeShapeHandler())
 
     def _compute_weights(self) -> np.ndarray:
         return np.ones((1, 1), dtype=np.int32)
@@ -333,13 +337,13 @@ def test_compute_weights_2d_to_3d(self) -> None:
 
 class TestReorder(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a Reorder operation can be instantiated."""
-        op = Reorder(order=(1, 0, 2))
-        self.assertIsInstance(op, Reorder)
+        """Tests whether a ReorderDims operation can be instantiated."""
+        op = ReorderDims(order=(1, 0, 2))
+        self.assertIsInstance(op, ReorderDims)
 
     def test_compute_weights_no_change_2d(self) -> None:
         """Tests 'reordering' a 2D input to the same order."""
-        op = Reorder(order=(0, 1))
+        op = ReorderDims(order=(0, 1))
         op.configure(input_shape=(3, 3))
         computed_weights = op.compute_weights()
         expected_weights = np.eye(9)
@@ -348,7 +352,7 @@ def test_compute_weights_no_change_2d(self) -> None:
 
     def test_compute_weights_reordered_2d(self) -> None:
         """Tests reordering a 2D input by switching the dimensions."""
-        op = Reorder(order=(1, 0))
+        op = ReorderDims(order=(1, 0))
         op.configure(input_shape=(3, 3))
         computed_weights = op.compute_weights()
         expected_weights = np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -424,7 +428,7 @@ def test_compute_weights_reordered_3d(self) -> None:
                       [0, 0, 0, 0, 0, 0, 0, 1]])]
 
         for order, expected in zip(orders, expected_weights):
-            op = Reorder(order=order)
+            op = ReorderDims(order=order)
             op.configure(input_shape=(2, 2, 2))
             computed = op.compute_weights()
 
@@ -1139,5 +1143,266 @@ def test_connectivity_matrix_2d_even_kernel_circular(self) -> None:
         )
 
 
+class TestReduceAlongDiagonal(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a ReduceAlongDiagonal operation can be instantiated."""
+        diag_op = ReduceAlongDiagonal()
+        self.assertIsInstance(diag_op, ReduceAlongDiagonal)
+
+    def test_compute_weights_directly(self) -> None:
+        """Tests whether computing weights produces the expected result for
+        different shapes. This directly compares against small predetermined
+        weight matrices."""
+        shapes = [(3,), (4,), (2, 2)]
+        expected_weights = [
+            np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 1, 0, 1, 0, 0, 0, 0, 0],
+                      [0, 0, 1, 0, 1, 0, 1, 0, 0],
+                      [0, 0, 0, 0, 0, 1, 0, 1, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 1]]),
+            np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]),
+            np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
+        ]
+
+        for shape, expected in zip(shapes, expected_weights):
+            diag_op = ReduceAlongDiagonal()
+            diag_op.configure(shape + shape)
+
+            computed = diag_op.compute_weights()
+
+            self.assertTrue(np.array_equal(computed, expected))
+
+    def test_compute_weights_indirectly(self) -> None:
+        """Tests computing weights indirectly by multiplying the computed
+        weight matrices with simple matrices. This is to be able to test
+        higher dimensional cases where direct testing of the weight matrices
+        would require pasting very large matrices into the source code."""
+        # go through a 1D, 2D, and 3D case
+        shapes = [(3,), (3, 4), (3, 4, 5)]
+
+        for shape in shapes:
+            # Construct a mock spike-input from a 'transformation DNF'
+            # that is twice the dimensionality of the input shape
+            spike_input_shape = shape + shape
+            spike_input = np.zeros(spike_input_shape,
+                                   dtype=np.int32)
+            # Generate an index such that the second element of the last
+            # dimension is 1:
+            # e.g., a 1D spike input would be: [0, 1, 0, 0],
+            # a 2D spike input would be: [[0, 0, 0], [0, 0, 0], [0, 1, 0]]
+            idx = np.zeros(spike_input.ndim, dtype=np.int32)
+            idx[-1] = 1
+            spike_input[tuple(idx)] = 1
+            # Flatten the input to enable matrix multiplication with the
+            # connectivity weight matrix
+            spike_input = spike_input.ravel()
+
+            # Create and configure the operation
+            diag_op = ReduceAlongDiagonal()
+            diag_op.configure(spike_input_shape)
+
+            # Use the operation to compute the connectivity weight matrix
+            weights = diag_op.compute_weights()
+
+            # Compute the output of the synaptic connections if the
+            # connectivity matrix were applied to the spike input
+            computed = np.matmul(weights, spike_input)
+
+            # Generate the expected output of the synaptic connections;
+            # the shape along every dimension must be twice the input minus 1,
+            # where all elements are zero except for the second entry of the
+            # last dimension
+            expected_shape = tuple(np.array(shape) * 2 - 1)
+            expected = np.zeros(expected_shape, dtype=np.int32)
+            expected_idx = np.zeros(expected.ndim, dtype=np.int32)
+            expected_idx[-1] = 1
+            expected[tuple(expected_idx)] = 1
+            expected = expected.ravel()
+
+            self.assertTrue(np.array_equal(computed, expected))
+
+
+class TestExpandAlongDiagonal(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a ExpandAlongDiagonal operation can be instantiated."""
+        diag_op = ExpandAlongDiagonal()
+        self.assertIsInstance(diag_op, ExpandAlongDiagonal)
+
+    def test_compute_weights_directly(self) -> None:
+        """Tests whether computing weights produces the expected result for
+        different shapes. This directly compares against small predetermined
+        weight matrices."""
+        shapes = [(3,), (5,), (3, 3)]
+        expected_weights = [
+            np.array([[1, 0, 0],
+                      [0, 1, 0],
+                      [0, 1, 0],
+                      [0, 0, 1]]),
+            np.array([[1, 0, 0, 0, 0],
+                      [0, 1, 0, 0, 0],
+                      [0, 0, 1, 0, 0],
+                      [0, 1, 0, 0, 0],
+                      [0, 0, 1, 0, 0],
+                      [0, 0, 0, 1, 0],
+                      [0, 0, 1, 0, 0],
+                      [0, 0, 0, 1, 0],
+                      [0, 0, 0, 0, 1]]),
+            np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 1, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 1, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 1, 0, 0, 0, 0],
+                      [0, 1, 0, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 1, 0, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 1, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 1, 0, 0, 0],
+                      [0, 0, 0, 1, 0, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 1, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 1, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 1, 0],
+                      [0, 0, 0, 0, 1, 0, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 1, 0, 0, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 1, 0],
+                      [0, 0, 0, 0, 0, 0, 0, 0, 1]])
+        ]
+
+        for shape, expected in zip(shapes, expected_weights):
+            diag_op = ExpandAlongDiagonal()
+            diag_op.configure(shape)
+
+            computed = diag_op.compute_weights()
+
+            self.assertTrue(np.array_equal(computed, expected))
+
+    def test_compute_weights_indirectly(self) -> None:
+        """Tests computing weights indirectly by multiplying the computed
+        weight matrices with simple matrices. This is to be able to test
+        higher dimensional cases where direct testing of the weight matrices
+        would require pasting very large matrices into the source code."""
+        # Go through a 1D, 2D, and 3D case
+        shapes = [(5,), (5, 7), (5, 7, 9)]
+
+        for shape in shapes:
+            # Construct a mock spike-input from a 'relational DNF'
+            spike_input = np.zeros(shape, dtype=np.int32)
+            # Generate an index such that the second element of the last
+            # dimension is 1:
+            # e.g., a 1D spike input would be: [0, 1, 0, 0],
+            # a 2D spike input would be: [[0, 0, 0], [0, 0, 0], [0, 1, 0]]
+            idx = np.zeros(spike_input.ndim, dtype=np.int32)
+            idx[-1] = 1
+            spike_input[tuple(idx)] = 1
+
+            # Create and configure the operation
+            diag_op = ExpandAlongDiagonal()
+            diag_op.configure(shape)
+
+            # Use the operation to compute the connectivity weight matrix
+            weights = diag_op.compute_weights()
+
+            # Compute the output of the synaptic connections if the
+            # connectivity matrix were applied to the spike input
+            computed = np.matmul(weights, spike_input.ravel())
+
+            # Generate the expected output of the synaptic connections;
+            # the shape along every dimension must be (input+1)*2,
+            # where all elements are zero except for the "line" projected
+            # diagonally through the matrix
+            half_shape = (np.array(shape) + 1) / 2
+            half_shape = tuple(half_shape.astype(int))
+            expected_shape = half_shape + half_shape
+            expected = np.zeros(expected_shape, dtype=np.int32)
+            # Get the position of the spike input
+            x = np.argwhere(spike_input)[0]
+            for p in np.ndindex(*half_shape):
+                p = np.array(p)
+
+                # Set expected[x-p, p] = 1, where 0 <= x-p < half_shape
+                d = x - p
+                if np.all(0 <= d) and np.all(d < np.array(half_shape)):
+                    i = tuple(np.concatenate([d, p]))
+                    expected[i] = 1
+            expected = expected.ravel()
+
+            self.assertTrue(np.array_equal(computed, expected))
+
+
+class TestFlip(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a Flip operation can be instantiated."""
+        flip_op = Flip()
+        self.assertIsInstance(flip_op, Flip)
+
+    def test_operation_defaults_to_flipping_all_dims(self) -> None:
+        """Tests whether the operation flips all dimensions when no
+        'dims' attribute is supplied."""
+        shape = (3, 4, 5)
+        spike_input = np.zeros(shape, dtype=np.int32)
+        spike_input[1, 1, 1] = 1
+
+        flip_op = Flip()
+        flip_op.configure(input_shape=shape)
+        weights = flip_op.compute_weights()
+        computed = np.matmul(spike_input.ravel(), weights)
+        computed = computed.reshape(shape)
+
+        expected = np.flip(spike_input, axis=(0, 1, 2))
+
+        self.assertTrue(np.array_equal(computed, expected))
+
+    def test_flipping_specific_dimensions(self) -> None:
+        """Tests whether the computed weight matrix flips the input along the
+        specified dimensions."""
+
+        def all_sub_sets(_set: ty.List) -> ty.Iterator:
+            """Creates a list of all possible subsets of a given set."""
+            sub_sets = it.chain.from_iterable(
+                it.combinations(_set, length) for length in range(len(_set) + 1)
+            )
+            return sub_sets
+
+        for shape in [(5,), (4, 5), (3, 4, 5)]:
+            # Construct a mock spike-input
+            spike_input = np.zeros(shape, dtype=np.int32)
+            # Generate an index such that the second element of the last
+            # dimension is 1:
+            # e.g., a 1D spike input would be: [0, 1, 0, 0],
+            # a 2D spike input would be: [[0, 0, 0], [0, 0, 0], [0, 1, 0]]
+            idx = np.zeros(spike_input.ndim, dtype=np.int32)
+            idx[-1] = 1
+            spike_input[tuple(idx)] = 1
+
+            # Go through all subsets of all indices of the shape
+            dim_indices = range(len(shape))
+            for dims in all_sub_sets(dim_indices):
+                # Set up a Flip operation
+                flip_op = Flip(dims=dims)
+                flip_op.configure(input_shape=shape)
+                # Compute it's connectivity matrix
+                weights = flip_op.compute_weights()
+                # Apply the connectivity matrix to the mock spike-input
+                computed = np.matmul(spike_input.ravel(), weights)
+                computed = computed.reshape(shape)
+
+                # Compute what we expect the Flip operation to do
+                expected = np.flip(spike_input, axis=dims)
+
+                # Compare the computed with the expected output
+                self.assertTrue(np.array_equal(computed, expected))
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/lava/lib/dnf/operations/test_shape_handlers.py b/tests/lava/lib/dnf/operations/test_shape_handlers.py
index ae0bbd0..579d72f 100644
--- a/tests/lava/lib/dnf/operations/test_shape_handlers.py
+++ b/tests/lava/lib/dnf/operations/test_shape_handlers.py
@@ -8,11 +8,14 @@
 
 from lava.lib.dnf.operations.shape_handlers import (
     AbstractShapeHandler,
-    KeepShapeHandler,
-    ReduceDimsHandler,
-    ReshapeHandler,
-    ExpandDimsHandler,
-    ReorderHandler)
+    KeepShapeShapeHandler,
+    ReduceDimsShapeHandler,
+    ReshapeShapeHandler,
+    ExpandDimsShapeHandler,
+    ReorderDimsShapeHandler,
+    ReduceAlongDiagonalShapeHandler,
+    ExpandAlongDiagonalShapeHandler,
+    FlipShapeHandler)
 from lava.lib.dnf.operations.exceptions import MisconfiguredOpError
 
 
@@ -72,117 +75,117 @@ def test_input_shape_getter(self) -> None:
         self.assertEqual(sh.input_shape, input_shape)
 
 
-class TestKeepShapeHandler(unittest.TestCase):
+class TestKeepShapeShapeHandler(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a KeepShapeHandler can be instantiated."""
-        sh = KeepShapeHandler()
-        self.assertIsInstance(sh, KeepShapeHandler)
+        """Tests whether a KeepShapeShapeHandler can be instantiated."""
+        sh = KeepShapeShapeHandler()
+        self.assertIsInstance(sh, KeepShapeShapeHandler)
 
     def test_compute_output_shape(self) -> None:
         """Tests whether the output shape is set correctly."""
-        sh = KeepShapeHandler()
+        sh = KeepShapeShapeHandler()
         input_shape = (2, 4)
         sh.configure(input_shape=input_shape)
         self.assertEqual(sh.output_shape, input_shape)
 
 
-class TestExpandDimsHandler(unittest.TestCase):
+class TestExpandDimsShapeHandler(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a ExpandDimsHandler can be instantiated."""
-        sh = ExpandDimsHandler(new_dims_shape=6)
-        self.assertIsInstance(sh, ExpandDimsHandler)
+        """Tests whether a ExpandDimsShapeHandler can be instantiated."""
+        sh = ExpandDimsShapeHandler(new_dims_shape=6)
+        self.assertIsInstance(sh, ExpandDimsShapeHandler)
 
     def test_compute_output_shape_expand_one_dim_with_int_argument(self)\
             -> None:
         """Tests whether the output shape is set correctly when a single
         dimension is added, using an integer to specify the shape."""
-        sh = ExpandDimsHandler(new_dims_shape=6)
+        sh = ExpandDimsShapeHandler(new_dims_shape=6)
         sh.configure(input_shape=(2, 4))
         self.assertEqual(sh.output_shape, (2, 4, 6))
 
     def test_compute_output_shape_expand_multiple_dims(self) -> None:
         """Tests whether the output shape is set correctly when multiple
          dimensions are added."""
-        sh = ExpandDimsHandler(new_dims_shape=(6, 8))
+        sh = ExpandDimsShapeHandler(new_dims_shape=(6, 8))
         sh.configure(input_shape=(2,))
         self.assertEqual(sh.output_shape, (2, 6, 8))
 
     def test_compute_output_shape_expand_from_0d(self) -> None:
         """Tests whether the output shape is set correctly when expanding
         from 0D to 1D."""
-        sh = ExpandDimsHandler(new_dims_shape=(10,))
+        sh = ExpandDimsShapeHandler(new_dims_shape=(10,))
         sh.configure(input_shape=(1,))
         self.assertEqual(sh.output_shape, (10,))
 
     def test_negative_shape_values_raise_error(self) -> None:
         """Tests whether an error is raised when <new_dims_shape> contains a
         negative value."""
-        sh = ExpandDimsHandler(new_dims_shape=(-6,))
+        sh = ExpandDimsShapeHandler(new_dims_shape=(-6,))
         with self.assertRaises(ValueError):
             sh.configure(input_shape=(2, 4))
 
     def test_zero_shape_values_raise_error(self) -> None:
         """Tests whether an error is raised when <new_dims_shape> contains a
         zero."""
-        sh = ExpandDimsHandler(new_dims_shape=(0,))
+        sh = ExpandDimsShapeHandler(new_dims_shape=(0,))
         with self.assertRaises(ValueError):
             sh.configure(input_shape=(2, 4))
 
     def test_empty_new_dims_shape_raises_error(self) -> None:
         """Tests whether an error is raised when <new_dims_shape> is empty."""
-        sh = ExpandDimsHandler(new_dims_shape=())
+        sh = ExpandDimsShapeHandler(new_dims_shape=())
         with self.assertRaises(ValueError):
             sh.configure(input_shape=(2, 4))
 
     def test_output_shape_larger_than_dim_3_raises_error(self) -> None:
         """Tests whether an error is raised when the computed output shape is
         larger than 3."""
-        sh = ExpandDimsHandler(new_dims_shape=(6, 8))
+        sh = ExpandDimsShapeHandler(new_dims_shape=(6, 8))
         with self.assertRaises(NotImplementedError):
             sh.configure(input_shape=(2, 4))
 
 
-class TestReduceDimsHandler(unittest.TestCase):
+class TestReduceDimsShapeHandler(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a ReduceDimsHandler can be instantiated."""
-        sh = ReduceDimsHandler(reduce_dims=1)
-        self.assertIsInstance(sh, ReduceDimsHandler)
+        """Tests whether a ReduceDimsShapeHandler can be instantiated."""
+        sh = ReduceDimsShapeHandler(reduce_dims=1)
+        self.assertIsInstance(sh, ReduceDimsShapeHandler)
 
     def test_compute_output_shape_remove_one_dim(self) -> None:
         """Tests whether the output shape is set correctly when a single
         dimension is removed."""
-        sh = ReduceDimsHandler(reduce_dims=1)
+        sh = ReduceDimsShapeHandler(reduce_dims=1)
         sh.configure(input_shape=(2, 4))
         self.assertEqual(sh.output_shape, (2,))
 
     def test_compute_output_shape_negative_index(self) -> None:
         """Tests whether the output shape is set correctly when a single
         dimension is removed, using a negative index."""
-        sh = ReduceDimsHandler(reduce_dims=-1)
+        sh = ReduceDimsShapeHandler(reduce_dims=-1)
         sh.configure(input_shape=(2, 4))
         self.assertEqual(sh.output_shape, (2,))
 
     def test_compute_output_shape_remove_multiple_dims(self) -> None:
         """Tests whether the output shape is set correctly when multiple
         dimensions are removed."""
-        sh = ReduceDimsHandler(reduce_dims=(0, -1))
+        sh = ReduceDimsShapeHandler(reduce_dims=(0, -1))
         sh.configure(input_shape=(2, 3, 4, 5))
         self.assertEqual(sh.output_shape, (3, 4))
 
     def test_compute_output_shape_remove_all(self) -> None:
         """Tests whether the output shape is set correctly when all
         dimensions are removed."""
-        sh = ReduceDimsHandler(reduce_dims=(0, 1, 2))
+        sh = ReduceDimsShapeHandler(reduce_dims=(0, 1, 2))
         sh.configure(input_shape=(2, 3, 4))
         self.assertEqual(sh.output_shape, (1,))
 
     def test_order_of_reduce_dims_does_not_impact_result(self) -> None:
         """Tests whether the order of <reduce_dims> does not matter."""
         input_shape = (3, 4, 5)
-        sh1 = ReduceDimsHandler(reduce_dims=(1, 2))
+        sh1 = ReduceDimsShapeHandler(reduce_dims=(1, 2))
         sh1.configure(input_shape=input_shape)
 
-        sh2 = ReduceDimsHandler(reduce_dims=(1, 2))
+        sh2 = ReduceDimsShapeHandler(reduce_dims=(1, 2))
         sh2.configure(input_shape=input_shape)
 
         self.assertTrue(np.array_equal(sh1.output_shape,
@@ -192,7 +195,7 @@ def test_reduce_dims_with_out_of_bounds_index_raises_error(self) -> None:
         """Tests whether an error is raised when <reduce_dims> contains an
         index that is out of bounds for the input shape."""
         with self.assertRaises(IndexError):
-            sh = ReduceDimsHandler(reduce_dims=2)
+            sh = ReduceDimsShapeHandler(reduce_dims=2)
             sh.configure(input_shape=(2, 4))
 
     def test_reduce_dims_with_negative_out_of_bounds_index_raises_error(self)\
@@ -200,41 +203,41 @@ def test_reduce_dims_with_negative_out_of_bounds_index_raises_error(self)\
         """Tests whether an error is raised when <reduce_dims> contains a
         negative index that is out of bounds for the input shape."""
         with self.assertRaises(IndexError):
-            sh = ReduceDimsHandler(reduce_dims=-3)
+            sh = ReduceDimsShapeHandler(reduce_dims=-3)
             sh.configure(input_shape=(2, 4))
 
     def test_empty_reduce_dims_raises_error(self) -> None:
         """Tests whether an error is raised when <reduce_dims> is an empty
         tuple."""
         with self.assertRaises(ValueError):
-            sh = ReduceDimsHandler(reduce_dims=())
+            sh = ReduceDimsShapeHandler(reduce_dims=())
             sh.configure(input_shape=(2, 4))
 
     def test_reduce_dims_with_too_many_entries_raises_error(self) -> None:
         """Tests whether an error is raised when <reduce_dims> has more
         elements than the dimensionality of the input."""
         with self.assertRaises(ValueError):
-            sh = ReduceDimsHandler(reduce_dims=(0, 0))
+            sh = ReduceDimsShapeHandler(reduce_dims=(0, 0))
             sh.configure(input_shape=(4,))
 
     def test_zero_dimensional_input_shape_raises_error(self) -> None:
         """Tests whether an error is raised when the input shape is already
         zero-dimensional."""
         with self.assertRaises(MisconfiguredOpError):
-            sh = ReduceDimsHandler(reduce_dims=0)
+            sh = ReduceDimsShapeHandler(reduce_dims=0)
             sh.configure(input_shape=(1,))
 
 
-class TestReshapeHandler(unittest.TestCase):
+class TestReshapeShapeHandler(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a ReshapeHandler can be instantiated."""
-        sh = ReshapeHandler(output_shape=(8,))
-        self.assertIsInstance(sh, ReshapeHandler)
+        """Tests whether a ReshapeShapeHandler can be instantiated."""
+        sh = ReshapeShapeHandler(output_shape=(8,))
+        self.assertIsInstance(sh, ReshapeShapeHandler)
 
     def test_compute_output_shape(self) -> None:
         """Tests whether the output shape is set correctly."""
         output_shape = (8,)
-        sh = ReshapeHandler(output_shape=output_shape)
+        sh = ReshapeShapeHandler(output_shape=output_shape)
         sh.configure(input_shape=(2, 4))
         self.assertEqual(sh.output_shape, output_shape)
 
@@ -244,72 +247,161 @@ def test_compute_output_shape_with_incorrect_num_neurons_raises_error(self)\
         the input and output shape does not match."""
         with self.assertRaises(MisconfiguredOpError):
             output_shape = (9,)
-            sh = ReshapeHandler(output_shape=output_shape)
+            sh = ReshapeShapeHandler(output_shape=output_shape)
             sh.configure(input_shape=(2, 4))
 
 
-class TestReorderHandlerShapeHandler(unittest.TestCase):
+class TestReorderShapeHandler(unittest.TestCase):
     def test_init(self) -> None:
-        """Tests whether a ReorderHandler can be instantiated."""
-        sh = ReorderHandler(order=(1, 0))
-        self.assertIsInstance(sh, ReorderHandler)
+        """Tests whether a ReorderDimsShapeHandler can be instantiated."""
+        sh = ReorderDimsShapeHandler(order=(1, 0))
+        self.assertIsInstance(sh, ReorderDimsShapeHandler)
 
     def test_order_with_more_elements_than_input_raises_error(self) -> None:
         """Tests whether an error is raised when the specified new <order>
         has more elements than the number of input dimensions."""
-        sh = ReorderHandler(order=(1, 0, 2))
+        sh = ReorderDimsShapeHandler(order=(1, 0, 2))
         with self.assertRaises(MisconfiguredOpError):
             sh.configure(input_shape=(2, 2))
 
     def test_order_with_less_elements_than_input_raises_error(self) -> None:
         """Tests whether an error is raised when the specified new <order>
         has less elements than the number of input dimensions."""
-        sh = ReorderHandler(order=(1,))
+        sh = ReorderDimsShapeHandler(order=(1,))
         with self.assertRaises(MisconfiguredOpError):
             sh.configure(input_shape=(2, 2))
 
     def test_negative_order_index_within_bounds_works(self) -> None:
         """Tests whether indices in <order> can be specified with negative
         numbers."""
-        sh = ReorderHandler(order=(0, -2))
+        sh = ReorderDimsShapeHandler(order=(0, -2))
         sh.configure(input_shape=(2, 2))
 
     def test_order_index_out_of_bounds_raises_error(self) -> None:
         """Tests whether an error is raised when an index in <order> is
         larger than the dimensionality of the input."""
-        sh = ReorderHandler(order=(0, 2))
+        sh = ReorderDimsShapeHandler(order=(0, 2))
         with self.assertRaises(IndexError):
             sh.configure(input_shape=(2, 2))
 
     def test_negative_order_index_out_of_bounds_raises_error(self) -> None:
         """Tests whether an error is raised when an index in <order> is
         negative and out of bounds."""
-        sh = ReorderHandler(order=(0, -3))
+        sh = ReorderDimsShapeHandler(order=(0, -3))
         with self.assertRaises(IndexError):
             sh.configure(input_shape=(2, 2))
 
     def test_input_dimensionality_0_raises_error(self) -> None:
         """Tests whether an error is raised when the input dimensionality is
         0, in which case reordering does not make sense."""
-        sh = ReorderHandler(order=(0,))
+        sh = ReorderDimsShapeHandler(order=(0,))
         with self.assertRaises(MisconfiguredOpError):
             sh.configure(input_shape=(1,))
 
     def test_input_dimensionality_1_raises_error(self) -> None:
         """Tests whether an error is raised when the input dimensionality is
         1, in which case reordering does not make sense."""
-        sh = ReorderHandler(order=(0,))
+        sh = ReorderDimsShapeHandler(order=(0,))
         with self.assertRaises(MisconfiguredOpError):
             sh.configure(input_shape=(5,))
 
     def test_reordering_2d(self) -> None:
         """Tests whether reordering a two-dimensional input works."""
-        sh = ReorderHandler(order=(1, 0))
+        sh = ReorderDimsShapeHandler(order=(1, 0))
         sh.configure(input_shape=(0, 1))
         self.assertEqual(sh.output_shape, (1, 0))
 
     def test_reordering_3d(self) -> None:
         """Tests whether reordering a three-dimensional input works."""
-        sh = ReorderHandler(order=(1, 2, 0))
+        sh = ReorderDimsShapeHandler(order=(1, 2, 0))
         sh.configure(input_shape=(0, 1, 2))
         self.assertEqual(sh.output_shape, (1, 2, 0))
+
+
+class TestReduceDiagonalShapeHandler(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a ReduceAlongDiagonalShapeHandler can be
+        instantiated."""
+        sh = ReduceAlongDiagonalShapeHandler()
+        self.assertIsInstance(sh, ReduceAlongDiagonalShapeHandler)
+
+    def test_odd_input_dimensionality_raises_exception(self) -> None:
+        """Tests whether an exception is raised when the number of input
+        dimensions is not even."""
+        sh = ReduceAlongDiagonalShapeHandler()
+        with self.assertRaises(MisconfiguredOpError):
+            sh.configure(input_shape=(4, 4, 4))
+
+    def test_asymmetric_input_shape_raises_exception(self) -> None:
+        """Tests whether an exception is raised when the shape of the input
+        population is not composed of a combination of two identical shapes.
+        For instance, a valid input shape would be (40, 30, 40, 30)."""
+        sh = ReduceAlongDiagonalShapeHandler()
+        with self.assertRaises(MisconfiguredOpError):
+            sh.configure(input_shape=(4, 3, 4, 2))
+
+    def test_computing_output_shape(self) -> None:
+        """Tests that the output shape is computed correctly."""
+        shapes = [(4,), (4, 3), (4, 3, 2)]
+
+        for shape in shapes:
+            sh = ReduceAlongDiagonalShapeHandler()
+            sh.configure(input_shape=shape + shape)
+            expected_shape = tuple(np.array(shape) * 2 - 1)
+            self.assertEqual(sh.output_shape, expected_shape)
+
+
+class TestExpandDiagonalShapeHandler(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a ExpandAlongDiagonalShapeHandler can be
+        instantiated."""
+        sh = ExpandAlongDiagonalShapeHandler()
+        self.assertIsInstance(sh, ExpandAlongDiagonalShapeHandler)
+
+    def test_even_dimensionality_size_raises_exception(self) -> None:
+        """Tests whether an exception is raised when a dimension has an even
+        size."""
+        sh = ExpandAlongDiagonalShapeHandler()
+        with self.assertRaises(MisconfiguredOpError):
+            sh.configure(input_shape=(4, 3))
+
+    def test_computing_output_shape(self) -> None:
+        """Tests that the output shape is computed correctly. For example,
+        for an input shape (7, 5), the expected output shape is (4, 3, 4, 3)."""
+        shapes = [(7,), (7, 5), (7, 5, 3)]
+
+        for shape in shapes:
+            sh = ExpandAlongDiagonalShapeHandler()
+            sh.configure(input_shape=shape)
+            half_shape = (np.array(shape) + 1) / 2
+            half_shape = tuple(half_shape.astype(int))
+            expected_shape = half_shape + half_shape
+            self.assertEqual(sh.output_shape, expected_shape)
+
+
+class TestFlipShapeHandler(unittest.TestCase):
+    def test_init(self) -> None:
+        """Tests whether a FlipShapeHandler can be instantiated."""
+        sh = FlipShapeHandler()
+        self.assertIsInstance(sh, FlipShapeHandler)
+
+    def test_too_many_dims_raises_exception(self) -> None:
+        """Tests whether a <dims> argument with too many entries
+        raises an exception."""
+        sh = FlipShapeHandler(dims=(0, 1, 1))
+        with self.assertRaises(MisconfiguredOpError):
+            sh.configure(input_shape=(3, 4))
+
+    def test_dims_out_of_bounds_raises_exception(self) -> None:
+        """Tests whether an exception is raised when a specified dimension
+        does not exist."""
+        sh = FlipShapeHandler(dims=(0, 2))
+        with self.assertRaises(IndexError):
+            sh.configure(input_shape=(3, 4))
+
+    def test_dims_defaults_to_all_dims(self) -> None:
+        """Tests whether all dims are selected for flipping if no <dims>
+        attribute is specified."""
+        sh = FlipShapeHandler(dims=None)
+        sh.configure(input_shape=(3, 4, 5))
+        self.assertEqual(sh.dims, (0, 1, 2))