diff --git a/doc/source/conf.py b/doc/source/conf.py
index 5b644945347b99abc22429eb002a4553060ce70f..94f146ef5b0fadb9d1f875a6ef2ce25a3113c6ce 100755
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -19,9 +19,7 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../../src/'))
-sys.path.insert(0, os.path.abspath('../../src/database/'))
-
+sys.path.insert(0, os.path.abspath('../../tutorials'))
 # -- General configuration ------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
@@ -33,6 +31,7 @@ sys.path.insert(0, os.path.abspath('../../src/database/'))
 # ones.
 extensions = ['matplotlib.sphinxext.only_directives',
               'matplotlib.sphinxext.plot_directive',
+              'IPython.sphinxext.ipython_directive',
               'sphinx.ext.autodoc',
               'sphinx.ext.doctest',
               'sphinx.ext.intersphinx',
@@ -40,7 +39,8 @@ extensions = ['matplotlib.sphinxext.only_directives',
               'sphinx.ext.coverage',
               'sphinx.ext.mathjax',
               'sphinx.ext.viewcode',
-              'sphinx.ext.inheritance_diagram']
+              'sphinx.ext.inheritance_diagram',
+              'nbsphinx']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
diff --git a/doc/source/overview/database.rst b/doc/source/overview/database.rst
index 54d674f256c736e01ee4cfa50f2482525c81fc4d..56911a4796407ba166abcf80221ebe8abe2f12a6 100644
--- a/doc/source/overview/database.rst
+++ b/doc/source/overview/database.rst
@@ -4,11 +4,12 @@ Database
 Database are generated by the rendering module, and contains all \
 images and there corresponding position-orientations.
 
-* position_orientation: containing all position and orientation of where \
-images were rendered. The position-orientation is described by \
-['x','y','z','alpha_0','alpha_1','alpha_2']
-* image: containing all images ever rendered. Each channel of each image \
-are normalised, so to use the full coding range.
+* position_orientation: containing all position and orientation \
+  of where images were rendered. The position-orientation is \
+  described by ['x','y','z','alpha_0','alpha_1','alpha_2']
+* image: containing all images ever rendered. \
+  Each channel of each image are normalised, so to use the \
+  full coding range.
 * normalisation: the normalisation constantes
 
 
diff --git a/tutorials/01-building-arena.ipynb b/doc/source/tutorials/01-building-arena.ipynb
similarity index 99%
rename from tutorials/01-building-arena.ipynb
rename to doc/source/tutorials/01-building-arena.ipynb
index fce583998d8256a1a8d54bb59976d9e1b1db8fd1..ae0ce66374e9d9a80b88e7b7352366123aaf0a3c 100644
--- a/tutorials/01-building-arena.ipynb
+++ b/doc/source/tutorials/01-building-arena.ipynb
@@ -20,16 +20,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Design the arena"
+    "## Design the arena"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#  Generetting random patterns\n",
+    "##  Generetting random patterns\n",
     "\n",
-    "## rectangular"
+    "### rectangular"
    ]
   },
   {
@@ -68,7 +68,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## pattern uses and convertions\n",
+    "### pattern uses and convertions\n",
     "\n",
     "The image saved as a png image can be used in blender for example to cover the objects with pattern.\n",
     "\n",
@@ -96,7 +96,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/02-recording-animal-trajectory.ipynb b/doc/source/tutorials/02-recording-animal-trajectory.ipynb
similarity index 93%
rename from tutorials/02-recording-animal-trajectory.ipynb
rename to doc/source/tutorials/02-recording-animal-trajectory.ipynb
index cc29212c1b636a71092f1d45d606e629e5b06e95..76e812dbf0250bcb7ecafa6650b5459f9079af83 100644
--- a/tutorials/02-recording-animal-trajectory.ipynb
+++ b/doc/source/tutorials/02-recording-animal-trajectory.ipynb
@@ -6,14 +6,14 @@
    "source": [
     "# Recording animal trajectory\n",
     "\n",
-    "# Conversion to navipy trajectories\n",
+    "## Conversion to navipy trajectories\n",
     "\n",
     "### From Matlab to navipy"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -118,7 +118,7 @@
        "4  4.647302 -214.431592   7.461187  2.82896       0       0"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -128,7 +128,13 @@
     "import numpy as np\n",
     "import os\n",
     "from navipy.tools.trajectory import Trajectory\n",
-    "trajfile = '../navipy/resources/sample_experiment/Lobecke_JEB_2018/Y101_OBFlight_0001.mat'\n",
+    "import pkg_resources\n",
+    "# Use the trafile from the resources\n",
+    "# You can adapt this code, by changing trajfile \n",
+    "# with your own trajectory file\n",
+    "trajfile = pkg_resources.resource_filename(\n",
+    "    'navipy',\n",
+    "    'resources/sample_experiment/Lobecke_JEB_2018/Y101_OBFlight_0001.mat')\n",
     "csvtrajfile, _ = os.path.splitext(trajfile)\n",
     "csvtrajfile = csvtrajfile+'.csv'\n",
     "mymat = loadmat(trajfile)\n",
diff --git a/doc/source/tutorials/03-rendering-along-trajectory.ipynb b/doc/source/tutorials/03-rendering-along-trajectory.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..332b5f68f4b44fcaf4a9e96bca52e12bde173545
--- /dev/null
+++ b/doc/source/tutorials/03-rendering-along-trajectory.ipynb
@@ -0,0 +1,176 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Recording along a trajectory\n",
+    "\n",
+    "In this tutorial, you will learn to take advantage of navipy and the rendering modules (blender) to render what has been seen by the animal along its trajectory. \n",
+    "\n",
+    "To render along a trajectory, you will need to have:\n",
+    "* the environment (a blender file)\n",
+    "* the trajectory formatted for navipy (see 02-recording-animal-trajectory)\n",
+    "\n",
+    "## Checking the position of the animal within the environment\n",
+    "\n",
+    "Rendering a trajectory will take time, and thus we want to check - prior to rendering - the correctness of the animal within the environment. The best way to check, is to overlay the trajectory within the blender world, and by rotating the environment, one could look for: part of the trajectory crossing objects, a wrong height, etc... \n",
+    "\n",
+    "To overlay the trajectory within your blender environment you can use the following command:\n",
+    "\n",
+    "```bash\n",
+    "blendoverlaytraj --blenderworld='pathtomyworld.blend' \n",
+    "                 --trajectory='pathtomytrajectory.csv'\n",
+    "```\n",
+    "\n",
+    "here ```pathtomyworld.blend``` and ```'pathtomytrajectory.csv'``` are the path to your blender environment and your trajectory respectively.\n",
+    "\n",
+    "> The overlayed trajectory will not be rendered, because it is a simple line and its rendering is disable. If you want\n",
+    "> to render the trajectory, you can bevel the trajectory with a circle for example. It will create a extrude the circle\n",
+    "> along the trajectory and thus creating a 3D shaped. (Don't forget to enable rendering)\n",
+    "\n",
+    "## Rendering the trajectory in a database\n",
+    "\n",
+    "Once we know that the trajectory is correctly placed within the environment, it is time to render along the trajectory. We, however, recommand to render only the first view frame of your trajectory first in order to check for the orientation. Indeed we only checked the position of the animal, but not its orientation. Navipy supports all 24 Euler convention, and also quaternion. You need to figure out which one you used. Sadly we did not find until now an easy way to do it... Having said that, if you \"only\" tracked the yaw of the animal, you can safely use the 'rzyx' convention, here alpha_0 of your trajectory correspond to the yaw of the animal and all other angles are set to 0. \n",
+    "\n",
+    "```bash\n",
+    "blendalongtraj --output-file='pathtodatabase.db' \n",
+    "               --blenderworld='pathtomyworld.blend' \n",
+    "               --trajectory='pathtomytrajectory.csv'\n",
+    "```\n",
+    "\n",
+    "here ```pathtomyworld.blend```, ```'pathtomytrajectory.csv'```, ```pathtodatabase.db``` are the path to your blender environment, to your trajectory, and to the file to store the iamges respectively.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Database to list of images\n",
+    "\n",
+    "The database store all position-orientation and images along the trajectory in a single file. On the one hand, it is convenient, because you always know at which position and in which orientation an image has been rendered. On the other hand, we can not easily visualise the images. \n",
+    "\n",
+    "To convert the database into an image sequence or list, you can run the following script in a ipython notebook (Don't forget to change the variable ```database``` to the path of your trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the necessary modules\n",
+    "from navipy.database import DataBaseLoad\n",
+    "from matplotlib.image import imsave\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Load the database, and specify the\n",
+    "# the output directory to save the list\n",
+    "# of images\n",
+    "import pkg_resources\n",
+    "# Use the trafile from the resources\n",
+    "# You can adapt this code, by changing trajfile \n",
+    "# with your own trajectory file\n",
+    "database = pkg_resources.resource_filename(\n",
+    "    'navipy',\n",
+    "    'resources/database.db')\n",
+    "database_dir, _ = os.path.splitext(database)\n",
+    "if not os.path.exists(database_dir):\n",
+    "    os.makedirs(database_dir)\n",
+    "database_template = os.path.join(database_dir, 'frame_{}.png')\n",
+    "mydb = DataBaseLoad(database)\n",
+    "\n",
+    "for rowid in mydb.posorients.index:\n",
+    "    my_scene = mydb.scene(rowid=rowid)\n",
+    "    \n",
+    "    to_plot_im = my_scene[:, :, :3, 0]\n",
+    "    to_plot_im -= to_plot_im.min()\n",
+    "    to_plot_im /= to_plot_im.max()\n",
+    "    to_plot_im = to_plot_im * 255\n",
+    "    \n",
+    "    to_plot_im = to_plot_im.astype(np.uint8)\n",
+    "    \n",
+    "    to_plot_dist = my_scene[:, :, 3, 0]\n",
+    "    \n",
+    "    imsave(database_template.format(rowid), to_plot_im[::-1,...] )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting an image from the database"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/bolirev/.virtualenv/toolbox-navigation/lib/python3.6/site-packages/matplotlib-2.1.0-py3.6-linux-x86_64.egg/matplotlib/figure.py:418: UserWarning: matplotlib is currently using a non-GUI backend, so cannot show the figure\n",
+      "  \"matplotlib is currently using a non-GUI backend, \"\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAADhCAYAAACJOFesAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x7f8a37bd5eb8>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "my_scene = mydb.scene(rowid=2)\n",
+    "f, axarr = plt.subplots(1, 2, figsize=(15, 4))\n",
+    "\n",
+    "to_plot_im = my_scene[:, :, :3, 0].astype(float)\n",
+    "to_plot_im -= to_plot_im.min()\n",
+    "to_plot_im /= to_plot_im.max()\n",
+    "to_plot_im = to_plot_im * 255\n",
+    "to_plot_im = to_plot_im.astype(np.uint8)\n",
+    "to_plot_dist = my_scene[:, :, 3, 0]\n",
+    "\n",
+    "ax = axarr[0]\n",
+    "ax.imshow(to_plot_im)\n",
+    "ax.invert_yaxis()\n",
+    "\n",
+    "ax = axarr[1]\n",
+    "ax.imshow(to_plot_dist)\n",
+    "ax.invert_yaxis()\n",
+    "\n",
+    "f.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/doc/source/tutorials/index.rst b/doc/source/tutorials/index.rst
index 719a9a33df75788345396cfd88a661a7baa1b0e1..2cb79febcb5b2b243bd9488c6c7d1e18413faab1 100644
--- a/doc/source/tutorials/index.rst
+++ b/doc/source/tutorials/index.rst
@@ -1,68 +1,11 @@
 Tutorials
 =========
 
-.. The image ratio is: width: 350px; height: 350/4 + (2x5) ~= 98px
-
-.. only:: builder_html and (not singlehtml)
-
-   .. container:: tocdescr
-
-
-       .. container:: descr
-
-         .. figure:: /tutorials/compound_eye.jpeg
-            :target: interface/index.html
-
-         :doc:`/interface/index`
-            Average skyline vector homing (grid)
-
-       .. container:: descr
-
-         .. figure:: /tutorials/compound_eye.jpeg
-            :target: interface/index.html
-
-         :doc:`/interface/index`
-            Following the rotational image difference (close loop)
-
-       .. container:: descr
-
-         .. figure:: /tutorials/compound_eye.jpeg
-            :target: interface/index.html
-
-         :doc:`/interface/index`
-            Photo-taxis with a compound eye (close loop)
-
-       .. container:: descr
-
-         .. figure:: /tutorials/compound_eye.jpeg
-            :target: interface/index.html
-
-         :doc:`/interface/index`
-            Finding attracting points (graph)
-
-       .. container:: descr
-
-         .. figure:: /tutorials/examples/database.svg
-            :target: database.html
-
-         :doc:`/tutorials/database`
-            Creating a database for offline methods
-
-       .. container:: descr
-
-         .. figure:: /tutorials/examples/renderimage.svg
-            :target: renderimage.html
-
-         :doc:`/tutorials/renderimage`
-            Generating images and movies from insect trajectory
-
-.. only:: latex or epub or singlehtml
-
-   .. toctree::
-      :maxdepth: 1
-
-      database.rst
-      renderimage.rst
+.. toctree::
+   
+   01-building-arena.ipynb
+   02-recording-animal-trajectory.ipynb
+   03-rendering-along-trajectory.ipynb
       
 Average place-code vector homing
 --------------------------------
diff --git a/navipy/comparing/__init__.py b/navipy/comparing/__init__.py
index a918ca387d40c6c41f68e1dffcf351a2c8e328c6..ee04adc1d00ab1e198ba5e8d695815900d9d9bbd 100644
--- a/navipy/comparing/__init__.py
+++ b/navipy/comparing/__init__.py
@@ -2,7 +2,9 @@
 Comparing
 """
 import numpy as np
+import pandas as pd
 from navipy.scene import is_ibpc, is_obpc, check_scene
+from navipy.scene import __spherical_indeces__
 
 
 def simple_imagediff(current, memory):
@@ -80,6 +82,9 @@ the current and memorised place code.
                        should be image based')
     check_scene(current)
     check_scene(memory)
+    # ridf is a NxM matrix,
+    # because one value per azimuth (N) and n values per channel
+    # (M)
     ridf = np.zeros((current.shape[1], current.shape[2]))
     for azimuth_i in range(0, current.shape[1]):
         rot_im = np.roll(current, azimuth_i, axis=1)
@@ -142,3 +147,51 @@ The intput parameters are the following:
 
 def gradient(current, memory):
     return 0
+
+
+def weighted_irdf(current,
+                  mem_scenes,
+                  viewing_directions):
+    """Weighted image rotational difference
+
+    Return an homing vector direction based on an \
+    Image rotational difference weighted between \
+    some reference snapshots
+
+    :param current: actual scene, np.array
+    :param mem_scenes: list of memorised of views
+    :returns: dx, dy, dz, dyaw, dpitch, droll.
+    :rtypes: pd.Series
+    """
+    if not isinstance(mem_scenes, (list, tuple)):
+        msg = 'mem_scenes should be of type'
+        msg += 'list or tuple and not {}'
+        msg = msg.format(type(mem_scenes))
+        raise TypeError(mem_scenes)
+    for scene in mem_scenes:
+        check_scene(scene)
+    check_scene(current)
+
+    # A dataframe to store
+    # the minimum of the irdf and the angle
+    # at which the minimum takes place
+    df_svp = pd.DataFrame(index=range(0, len(mem_scenes)),
+                          columns=['irdf', 'angle'])
+
+    for i, scene in enumerate(mem_scenes):
+        irdf = rot_imagediff(current, scene)
+        idx = np.argmin(irdf[..., 0])
+        value = np.min(irdf[..., 0])
+        df_svp.loc[i, 'angle'] = \
+            viewing_directions[idx,
+                               __spherical_indeces__['azimuth']]
+        df_svp.loc[i, 'irdf'] = value
+
+    min_irdf = df_svp.irdf.min()
+    # Take the best svp irdf and make the ratio
+    # for each others that gives the weighted irdf
+    w_svp = min_irdf / df_svp.irdf
+    # Weighting of the vector direction based on circular statistics
+    j = complex(0, 1)
+    H = w_svp * np.exp(df_svp.angle * j)
+    return np.sum(H)
diff --git a/navipy/database/__init__.py b/navipy/database/__init__.py
index 431b5253ef1203a851fc0c4c7ddf020779b2a4a6..0b8fd1974743d6b057ef6f92339e6a2bfd71bfe9 100644
--- a/navipy/database/__init__.py
+++ b/navipy/database/__init__.py
@@ -262,7 +262,12 @@ class DataBase():
             raise Exception(msg)
         found_convention = False
         index = posorient.index
-        convention = index.levels[0][-1]
+        if isinstance(index, pd.MultiIndex):
+            convention = index.levels[0][-1]
+        else:
+            msg = 'Old database without convention column'
+            self._logger.warnings(msg)
+            convention = 'rxyz'
         if (convention in mconst._AXES2TUPLE.keys()) or \
            convention == 'quaternion':
             found_convention = True
diff --git a/navipy/models/dewar_2014.py b/navipy/models/dewar_2014.py
new file mode 100644
index 0000000000000000000000000000000000000000..7be2d7b6dff8c5f330a05f954021f13b125f38f9
--- /dev/null
+++ b/navipy/models/dewar_2014.py
@@ -0,0 +1,69 @@
+from navipy import Brain
+from navipy.comparing import weighted_irdf
+import pandas as pd
+import numpy as np
+from navipy.maths.coordinates import spherical_to_cartesian
+# 0) Define a class heriting from Brain
+
+
+def processing(scene, channel):
+    """ Return the image difference
+
+    * inverse of distance (i.e. distance -> nearness)
+    """
+    # Invert distance to nearness
+    scene[..., 3, :] = 1 / scene[..., 3, :]
+    return scene[..., channel, :]
+
+
+def comparing(current, memories, viewing_directions):
+    """ Calculate homing vector with multi-snaphot irdf
+
+    Used in:
+    * Dewar, A. D., Philippides, A., & Graham, P. (2014). \
+      What is the relationship between visual environment and \
+      the form of ant learning-walks? An in silico investigation \
+      of insect navigation.
+    """
+    if (current.shape[2] != 1) or (memories[0].shape[2] != 1):
+        msg = 'Current view {} and the memory {} \n'
+        msg += 'should be a NxMx1x1 matrix'
+        msg = msg.format(current.shape, memories[0].shape)
+        raise NameError(msg)
+    # homing_vect_cp is a complex number
+    homing_vect_cp = \
+        weighted_irdf(current, memories, viewing_directions)
+    direction = np.angle(homing_vect_cp, deg=False)
+    minval = np.norm(homing_vect_cp)
+    homing_vect = spherical_to_cartesian(elevation=0,
+                                         azimuth=direction,
+                                         radius=minval)
+    return homing_vect
+
+
+class DewarBrain(Brain):
+    def __init__(self,
+                 memories,
+                 renderer=None,
+                 channel=0):
+        Brain.__init__(self, renderer=renderer)
+        # Init memory
+        self.channel = channel
+        self.memories = memories
+
+    def velocity(self):
+        index = self.posorient.index
+        convention = index.levels[0][-1]
+        current = processing(self.vision.scene,
+                             self.channel)
+        homing_vector = comparing(current,
+                                  self.memory,
+                                  self.vision.viewing_directions,
+                                  )
+        homing_vector = np.squeeze(homing_vector)
+        indeces = [('location', 'dx'), ('location', 'dy'),
+                   ('location', 'dz'), (convention, 'dalpha_0'),
+                   (convention, 'dalpha_1'), (convention, 'dalpha_2')]
+        velocity = pd.Series(data=0, index=pd.MultiIndex.from_tuples(indeces))
+        velocity.loc['location'] = homing_vector
+        return velocity
diff --git a/navipy/models/hafner_2000.py b/navipy/models/hafner_2000.py
index 3c94b921d17c379fc4430e082c89fd6b27524b1c..d2c3c921653083c346920fd1037d0f374fb0ddbf 100644
--- a/navipy/models/hafner_2000.py
+++ b/navipy/models/hafner_2000.py
@@ -18,12 +18,12 @@ def processing(scene, viewing_directions, channel):
     * Müller et al. 2018
     * Basten and Mallot 2010
     refer as COMANV in :
-    * Hafter 2000,
+    * Hafner 2000,
     * Bertrand 2015
     center of mass of average nearness vector
     """
     # Invert distance to nearness
-    scene[..., 3, :] = 1/scene[..., 3, :]
+    scene[..., 3, :] = 1 / scene[..., 3, :]
     # Calculate the skyline
     scene = skyline(scene)
     # skyline viewing direction
@@ -38,7 +38,7 @@ def comparing(current, memory):
 
     homing vector  = current vector - memory vector
     """
-    return current-memory
+    return current - memory
 
 
 class ASVBrain(Brain):
diff --git a/navipy/models/irdf_2003.py b/navipy/models/irdf_2003.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7c0918beac06a87b01650d9fd519b4caba47e37
--- /dev/null
+++ b/navipy/models/irdf_2003.py
@@ -0,0 +1,79 @@
+from navipy import Brain
+from navipy.comparing import rot_imagediff
+import pandas as pd
+import numpy as np
+from navipy.scene import __spherical_indeces__
+from navipy.maths.coordinates import spherical_to_cartesian
+# 0) Define a class heriting from Brain
+
+
+def processing(scene, channel):
+    """ Return the image difference
+
+    * inverse of distance (i.e. distance -> nearness)
+    """
+    # Invert distance to nearness
+    scene[..., 3, :] = 1 / scene[..., 3, :]
+    return scene[..., channel, :]
+
+
+def comparing(current, memory, viewing_directions):
+    """ Calculate homing vector with irdf
+
+    irdf: Image rotation difference function
+    The image difference is root mean square
+
+    Used in:
+    * Zeil, J., Hofmann, M., & Chahl, J. (2003). \
+      Catchment Areas of Panoramic Snapshots in Outdoor Scenes.
+    * Baddeley, B., Graham, P., Husbands, P., & Philippides, A. (2012).\
+      A Model of Ant Route Navigation Driven by Scene Familiarity.
+    * Ardin, P., Peng, F., Mangan, M., Lagogiannis, K., & Webb, B. (2016).\
+      Using an Insect Mushroom Body Circuit to Encode Route \
+      Memory in Complex Natural Environments.
+    """
+    if (current.shape[2] != 1) or (memory.shape[2] != 1):
+        msg = 'Current view {} and the memory {} \n'
+        msg += 'should be a NxMx1x1 matrix'
+        msg = msg.format(current.shape, memory.shape)
+        raise NameError(msg)
+    irdf = rot_imagediff(current, memory)
+    # [..., 0] because processing
+    # select one channel, and therefore
+    # irdf should is only a Nx1 matrix
+    idx = np.argmin(irdf[..., 0])
+    minval = np.min(irdf[..., 0])
+    direction = viewing_directions[idx,
+                                   __spherical_indeces__['azimuth']]
+    homing_vect = spherical_to_cartesian(elevation=0,
+                                         azimuth=direction,
+                                         radius=minval)
+    return homing_vect
+
+
+class IRDFBrain(Brain):
+    def __init__(self,
+                 memory,
+                 renderer=None,
+                 channel=0):
+        Brain.__init__(self, renderer=renderer)
+        # Init memory
+        self.channel = channel
+        self.memory = memory
+
+    def velocity(self):
+        index = self.posorient.index
+        convention = index.levels[0][-1]
+        current = processing(self.vision.scene,
+                             self.channel)
+        homing_vector = comparing(current,
+                                  self.memory,
+                                  self.vision.viewing_directions,
+                                  )
+        homing_vector = np.squeeze(homing_vector)
+        indeces = [('location', 'dx'), ('location', 'dy'),
+                   ('location', 'dz'), (convention, 'dalpha_0'),
+                   (convention, 'dalpha_1'), (convention, 'dalpha_2')]
+        velocity = pd.Series(data=0, index=pd.MultiIndex.from_tuples(indeces))
+        velocity.loc['location'] = homing_vector
+        return velocity
diff --git a/navipy/processing/pcode.py b/navipy/processing/pcode.py
index f542c173ff8fb2a0e84323ce722a7f8dd00210d9..bae8ca43a45be1171b3aa2d7dc7ce4fa57c8ccc0 100644
--- a/navipy/processing/pcode.py
+++ b/navipy/processing/pcode.py
@@ -2,6 +2,7 @@
 place code derived from scene
 """
 import numpy as np
+import pandas as pd
 from scipy.ndimage import maximum_filter, minimum_filter
 from navipy.scene import __spherical_indeces__
 from navipy.scene import __cartesian_indeces__
@@ -133,7 +134,7 @@ def pcv(place_code, viewing_directions):
                        should be 1'.format(place_code.shape[component_dim]))
     elevation = viewing_directions[..., __spherical_indeces__['elevation']]
     azimuth = viewing_directions[..., __spherical_indeces__['azimuth']]
-    if (np.any(elevation < -np.pi/2) or np.any(elevation > np.pi/2)):
+    if (np.any(elevation < -np.pi / 2) or np.any(elevation > np.pi / 2)):
         # if (np.any(elevation < -2*np.pi) or np.any(elevation > 2*np.pi)):
         raise ValueError(" Elevation must be radians in range [-2*pi;2*pi]")
     if (np.max(elevation) - np.min(elevation) > 2 * np.pi):
@@ -184,3 +185,58 @@ def apcv(place_code, viewing_directions):
         return (scaled_lv.sum(axis=0))[np.newaxis, ...]
     else:
         raise TypeError('place code is neither an ibpc nor obpc')
+
+
+def nposorient_around_ref(mydb,
+                          position_df,
+                          ref_pos,
+                          nb_snapshot,
+                          radius,
+                          blender_view):
+    """Return  set of views around and oriented towards memorized location
+    :param mydb: Database environment
+    :param position_df: dataframe with the positions of the grid
+    :param ref_pos: df with x, y and z position of the reference snapshot
+    :param nb_snapshot: number of wanted set of views (multiple of 2)
+    :param radius: distance from memorized location to take snapshots 
+    :param blender_view: viewing axis camera id y=90, if x=0
+    :returns: list  of reoriented image array, snaphots positions
+    :rtypes:  array of np.array, pd.DataFrame
+    """
+
+    svp_all = pd.DataFrame(columns=['x', 'y', 'z', 'frame'])
+    # angle of rotation
+    ang_deg = 360 / nb_snapshot
+    ang = np.deg2rad(ang_deg)
+    # make the different view
+    for i in range(0, nb_snapshot):
+        x = ref_pos.x + radius * np.cos(ang * i)
+        y = ref_pos.y + radius * np.sin(ang * i)
+        z = ref_pos.z
+        svp_frame = pd.Series(index=['frame', 'x', 'y', 'z'])
+        distance_arr = pd.Series(index=position_df.index)
+        for index, pos in position_df.dropna().iterrows():
+            distance = (pos.x - x)**2
+            distance += (pos.y - y)**2
+            distance += (pos.z - z)**2
+            distance_arr[index] = distance
+        svp_frame.frame = int(distance_arr.dropna().argmin())
+        svp_frame.x = position_df.x[svp_frame.frame]
+        svp_frame.y = position_df.y[svp_frame.frame]
+        svp_frame.z = position_df.z[svp_frame.frame]
+        svp_all.loc[i] = [svp_frame.x, svp_frame.y,
+                          svp_frame.z, int(svp_frame.frame)]
+    reoriented_mem = []
+    rot = list()
+
+    for i, j in svp_all.iterrows():
+        ide = int(j.frame)
+        image = mydb.scene(rowid=ide)
+        alpha = np.floor(np.rad2deg(np.arctan2(
+            (ref_pos.y - j.y), (ref_pos.x - j.x))))
+        alpha = alpha + blender_view  # because y view on blender
+        rot.append(alpha)
+        alpha = int(alpha)
+        svp_reorient = np.roll(image, alpha, 1)
+        reoriented_mem.append(svp_reorient)
+    return reoriented_mem, svp_all
diff --git a/setup.py b/setup.py
index 4068f783e699c11cfb09204abcceef1f5a4cdf28..44587fd0658a5535f5987f6a517b33836da9cc4e 100644
--- a/setup.py
+++ b/setup.py
@@ -3,6 +3,8 @@
 (called navipy)
 """
 from setuptools import setup, find_packages
+import glob
+import os
 
 excluded = []
 
@@ -22,6 +24,18 @@ def create_package_list(base_package):
              if not exclude_package(pkg)])
 
 
+def package_data_files(base_package):
+    os.chdir(base_package)
+    filelist = glob.glob(os.path.join('resources',
+                                      '*'))
+    filelist.extend(glob.glob(os.path.join('resources',
+                                           '**', '*'),
+                              recursive=True))
+    os.chdir('../')
+    print(filelist)
+    return filelist
+
+
 setup_dict = {'name': 'navipy',
               'version': '0.1',
               'author': "Olivier J.N. Bertrand",
@@ -50,10 +64,7 @@ setup_dict = {'name': 'navipy',
                                    'Pillow',
                                    'tables'],
               'package_data': {'navipy':
-                               ['resources/*.db',
-                                'resources/*.blend',
-                                'resources/*.csv',
-                                'resources/configs/*.yaml']},
+                               package_data_files("navipy")},
               'include_package_data': True,
               'entry_points': {
                   'console_scripts': [
diff --git a/tutorials/03-rendering-along-trajectory.ipynb b/tutorials/03-rendering-along-trajectory.ipynb
deleted file mode 100644
index 29a7a5abb76e30c86a2d1d6b4ad880af0bf4b136..0000000000000000000000000000000000000000
--- a/tutorials/03-rendering-along-trajectory.ipynb
+++ /dev/null
@@ -1,170 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Recording along a trajectory\n",
-    "\n",
-    "In this tutorial, you will learn to take advantage of navipy and the rendering modules (blender) to render what has been seen by the animal along its trajectory. \n",
-    "\n",
-    "To render along a trajectory, you will need to have:\n",
-    "* the environment (a blender file)\n",
-    "* the trajectory formatted for navipy (see 02-recording-animal-trajectory)\n",
-    "\n",
-    "## Checking the position of the animal within the environment\n",
-    "\n",
-    "Rendering a trajectory will take time, and thus we want to check - prior to rendering - the correctness of the animal within the environment. The best way to check, is to overlay the trajectory within the blender world, and by rotating the environment, one could look for: part of the trajectory crossing objects, a wrong height, etc... \n",
-    "\n",
-    "To overlay the trajectory within your blender environment you can use the following command:\n",
-    "\n",
-    "```bash\n",
-    "blendoverlaytraj --blenderworld='pathtomyworld.blend' \n",
-    "                 --trajectory='pathtomytrajectory.csv'\n",
-    "```\n",
-    "\n",
-    "here ```pathtomyworld.blend``` and ```'pathtomytrajectory.csv'``` are the path to your blender environment and your trajectory respectively.\n",
-    "\n",
-    "> The overlayed trajectory will not be rendered, because it is a simple line and its rendering is disable. If you want\n",
-    "> to render the trajectory, you can bevel the trajectory with a circle for example. It will create a extrude the circle\n",
-    "> along the trajectory and thus creating a 3D shaped. (Don't forget to enable rendering)\n",
-    "\n",
-    "## Rendering the trajectory in a database\n",
-    "\n",
-    "Once we know that the trajectory is correctly placed within the environment, it is time to render along the trajectory. We, however, recommand to render only the first view frame of your trajectory first in order to check for the orientation. Indeed we only checked the position of the animal, but not its orientation. Navipy supports all 24 Euler convention, and also quaternion. You need to figure out which one you used. Sadly we did not find until now an easy way to do it... Having said that, if you \"only\" tracked the yaw of the animal, you can safely use the 'rzyx' convention, here alpha_0 of your trajectory correspond to the yaw of the animal and all other angles are set to 0. \n",
-    "\n",
-    "```bash\n",
-    "blendalongtraj --output-file='pathtodatabase.db' \n",
-    "               --blenderworld='pathtomyworld.blend' \n",
-    "               --trajectory='pathtomytrajectory.csv'\n",
-    "```\n",
-    "\n",
-    "here ```pathtomyworld.blend```, ```'pathtomytrajectory.csv'```, ```pathtodatabase.db``` are the path to your blender environment, to your trajectory, and to the file to store the iamges respectively.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Database to list of images\n",
-    "\n",
-    "The database store all position-orientation and images along the trajectory in a single file. On the one hand, it is convenient, because you always know at which position and in which orientation an image has been rendered. On the other hand, we can not easily visualise the images. \n",
-    "\n",
-    "To convert the database into an image sequence or list, you can run the following script in a ipython notebook (Don't forget to change the variable ```database``` to the path of your trajectory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load the necessary modules\n",
-    "from navipy.database import DataBaseLoad\n",
-    "from matplotlib.image import imsave\n",
-    "import numpy as np\n",
-    "import os\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Load the database, and specify the\n",
-    "# the output directory to save the list\n",
-    "# of images\n",
-    "database = '/sample_experiment/Lobecke_JEB_2018/rendertraj.db'\n",
-    "database_dir, _ = os.path.splitext(database)\n",
-    "if not os.path.exists(database_dir):\n",
-    "    os.makedirs(database_dir)\n",
-    "database_template = os.path.join(database_dir, 'frame_{}.png')\n",
-    "mydb = DataBaseLoad(database)\n",
-    "\n",
-    "for rowid in mydb.posorients.index:\n",
-    "    my_scene = mydb.scene(rowid=rowid)\n",
-    "    \n",
-    "    to_plot_im = my_scene[:, :, :3, 0]\n",
-    "    to_plot_im -= to_plot_im.min()\n",
-    "    to_plot_im /= to_plot_im.max()\n",
-    "    to_plot_im = to_plot_im * 255\n",
-    "    \n",
-    "    to_plot_im = to_plot_im.astype(np.uint8)\n",
-    "    \n",
-    "    to_plot_dist = my_scene[:, :, 3, 0]\n",
-    "    \n",
-    "    imsave(database_template.format(rowid), to_plot_im[::-1,...] )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Plotting an image from the database"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
-      "/home/bolirev/.virtualenvs/toolbox-navigation/lib/python3.6/site-packages/matplotlib-2.2.2-py3.6-linux-x86_64.egg/matplotlib/figure.py:459: UserWarning: matplotlib is currently using a non-GUI backend, so cannot show the figure\n",
-      "  \"matplotlib is currently using a non-GUI backend, \"\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAADhCAYAAACJOFesAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvVmMZFl63/f7zjk3InKtqqzM2vfq6n2WHnbPcEYjbhZHFk14TPlFIgzYhgECBm3DhA0BNh/4RMAPhmUDAkwQMEHwwRIEaERSkgHDFDmaocjpWTjT0zNdvVd37VVZS1auEXHPOZ8f7onIG5GRVZnVWVvX+QGJjLjruTfucv7n20RVyWQymUwmk8lkMpnM44951A3IZDKZTCaTyWQymczWyAIuk8lkMplMJpPJZJ4QsoDLZDKZTCaTyWQymSeELOAymUwmk8lkMplM5gkhC7hMJpPJZDKZTCaTeULIAi6TyWQymUwmk8lknhCygMtkMplMJpPJZDKZJ4Qs4DKZTCaTyWQymUzmCSELuEwmk8lkMplMJpN5QsgCLpPJZDKZTCaTyWSeENyjbgCAiOijbkMmk8lkHho3VHXuUTfiScFOTKibmXnUzchkMpnMA8bfukVYWZF7LfdYCLhMJpPJPFV8/Kgb8CThZmY4/Fv//aNuRiaTyWQeMJf+8f++peWygMtkMplM5nHnnuOxmUwmk3layDFwmUwmk8lkMplMJvOEkAVcJpPJZDKZTCaTyTwhZAGXyWQymUwmk8lkMk8IWcBlMplMJpPJZDKZzBNCTmKSyWQymcxjjuYkJplMJpNJZAtcJpPJZDKZTCaTyTwhZAGXyWQymU+Etbb/v/c5k8lkMpnMg+GxcKFstloc2L+f5eVllpeX8d4TQnjUzcpkMpnMEHWBNjk5SavVotVqUThHa2ysP292dnbDusvLy5Te88aPfvRQ2vqpQch14DKZTOZpYIvP+sdCwJ04fpzf+73fY2l5meA9V65cYf7GDX74wx9y9uxZ3n/vPYAs6jJbotfBdM4xOTlJu91mcnKyP79wjtJ7ANrtNu12uz+v0+lgrc3XWiYzRLPZ5OiRIxw5epQvf+UrnHnmGSanpmi1WuzZvRvnHD7dV865/n/vff87gPeeL3/5y4/kGJ5Umrcjp77Rqb4kvxkV4dzXG4+uUZlMJpMZyck/6SKq1ZeYJva+34Obt+O9F+IxEXDGGCYnJ/ud7CNHjgDwtV/+Zbz3nD17FoB/9ad/yr/61//6kbUz8/hhraXVajE7O8vJkyd54YUXOHDwIAcPHGBubo7JyUm897Rarf46vU5m73PpPcF75ufnub2wwM35eX785pucPXuWixcvZjGXeer53Oc/z6//+q/zxddewzk3cD/VqQu1zaaNWiZzDxTEp5d6Gp0VEU79izaI9EXdh/9J89G0L/PEcPJPu9X1NNyZ3KzPOBRooyIgcO4/zoMHmUydk3/SRYKCKqKsC7barbbhvhvF1nTe4yHgNsM5h3OOV155BYAzZ87w7vvv887bbz/ilmUeB/bu3csvf+1r/Mqv/ApHjxyh1WptGOnfTmexN3AA8Gt//+/Tbrd57733+Pa3v803vvENVlZW+ta9LOoyTwt79+7lt3/7tzl54sSjbsrTiyrGr/ewVQAjCKlDbSpVd+obHT78T7OIywxy8o9TxxLWO5fp8z2pv+pEEBQVBizCH/5avuYyTzen/kUHiZV46w+QxOr+2tb9to3lHmsBN0wvziKTaTab/M7v/M5dXbE+6Uj/5OQkr7zyCq+88gqvvfYav/Vbv5WFW+apYyy5SGYeMT0BZ5IRLlaiTUTWSwxYk8sNZPqc+peVcKt3LKFmBYhb7FD2MH3zL1UvFYjCqX/RQa3w4a9lq1zm6URCrO6zWLO+DbtQsjULnHwaLHDDeO+xWcBlEkePHt22lW2rDG/zxMmTtFotVlZWdnxfmczjjL2Ly2Tm4SAKEkLVcY70O9CV9U0RSWJOtxY7kXk6EF91Kgc6ljA4wr9Vq4DIukUhXW89SzBRcqHCzFNN715DFWJNqA3/30Hu2fMVkT8AfhW4rqov16b/t8BvUhnY/42q/qM0/X8C/qs0/b9T1f93x1udeepxzmGTi20mk3lw9BL9ZBE3mofyjlRFgtb6yFpZ4gYEHaiVrQ/fZj71SNDKMlC3CGzTGrBOGjBIn/vXn5KuOZOvvcxTi0SFoNU99UnvtR10ofxD4J8Af9RviMgvAl8HPqeqHRHZl6a/CPwD4CXgEPBnIvKsqu6I35lzLrtQZvqEWjKSTCbzYBiOLc1s4A95GO/IGPuWDyBZPNatcADS96/MZKjiJmPcMYuAQH+woH79SU+75Wsv85QiPlb3VOjFvT0GFjhV/ZaInBia/F8D/4uqdtIy19P0rwP/LE0/JyLvA18E/nonGtvLGJipcMDTejayO20m83Col9nIbOShvCOV5L6WOgFGqg6BVIlMeokmdNNUgpmnkhj7WfHuNx6njvZi32B90EAq98l87WWeauoDJQP329A99hhkoXwW+Nsi8rtAG/gfVfV7wGHgO7XlLqZpO0Kr1XqirS6WqmSCjdWDLgCT/dGs6hebtJYzxnApRhBhRYTdInRUaYjQipErInzFGD72nvdUKUTo5U+8ESNlmnZbNXnXCF3Vvtj7NDg5POnXQibzJJEtcNtmh9+RWnUQeu+LoOuJJIz0p0sgW0EyffribTOrwPDnu25M1tcXgVATdEaz9TfzdBNBYrLCxU9wn1ULb2mp+30rO2AG+FngNeCfi8ip7WxARH4D+A2AAwcObGmddrv92FpdLFAAYgzTqhTGUIiw31r2irDoHNNAU5WpGClUuQIcTOuLKivAx8CrzvEFEa6GwGFjUGAJuKXKSec4X5aMiXDKWv5Da3lPlU4SM8+oYgB1jueABeCq9xTWYqyl8J7vx8heY5j3nosx0oiRFREkRlZTex53kZctcJnMw8PnwZLtsqPvyJabHhzVlXUL3LqYA+yT2Yme/Z4ZqpVUm7nJy2g71iOVu5yUYa/U2vQbrz3hViUdEZfTY7sZKIetvyTrmwgahaoHuyOtzmSeOCRGCOl5Ub/XNnlOybbvv43cbw/4IvANVVXguyISgVngEnC0ttyRNG0Dqvr7wO8DvPjii1s6ksdhFLgexi8iWOC4MVgRvtJo0BGhawyvNho0Q+CPVTkUIy+IUIbAkvco0AV2A830YnHGcCdG/iNj+Mh7xoADwPUYcaocSMKwHQLHgaUQ+Ly1fC8EPmNMX3idB1rOcRSYd47dZcmEcywCGiOLqnyxKGiEwH5j+KVmE6PKORGaIfRjLJZD4IMkNJdj5FqM9BypHndxl8lkMo+YHX1H7moe0PoLX01/oXXxBhAi+hgmkpj9nk2JNKrv69kQe9914PvAMsPcx+HJ8EpDQqMn3GRo3tx3zMDywwJPBW689hiXlgm6bhWA0ZaBUd+HGbjGatecqdYVERTzWF57mcxDIcSRwm2DUHsMXCj/GPhF4C9E5FmgAdwA/hT4v0Xkf6MK0D4DfPc+97EB7/1DS2LS8/S2QBPYCxxtNHi+0SCkH8BQHeQt71FjGBdhyRjmRPj/ypIDqkyr0gUuhkA3Riat5agql2Nkl3PMJXfKWzEyAXRUmRXhVowsAqdFWFHllvesimBV6ahiRHjHe54T4XaMzJvqRXMSuCDCorUUwPLYGCshUMTIx94zOzHBSgjstpbbMbIGtI2h6RzTIoynB/ORsmQqRvbGyEVVfLIItlSZB2wIvJNG5R/VIzu7UGYymceUnX9H1l78UutE98Vcf+YnbPknYPa7g0INGBJuuqmIG5g2NH3k/E9IXYwNC7d1QacD4q2+nKb4w33fsevb6om6Lz4eom7ApeuTuE/WLb+973Xrr0n7yha4zNNKzcot9ztQsk22UkbgnwK/AMyKyEXgd4A/AP5ARH5CZUz6z9NI409F5J8Db1Hl1/jNncpACZUFrt1uY63dkYLKtXDcAaaBFxsNCmBOhCmqt6+1FgmBsSSWNASaxtAyhhcaDb4FuBi5CpwUoSVCF/is9/zUGE6JoKq8J8IXneOs93xkLQDPWUsoS6IxvA3ss5aWKtMiNK1lTIT3Y+QgcNEYDqtyXpUCuM76kK4UBZMiRBGmk0g76Bxvq3KwKJi0liNFwU1jONXtcsVadnlPOwTuxEijKICUmZoqJm+vKtPJnXPaWhZF6MTI163lz7tdroTASgishcDDTHfwsF0osxtZ5mkkZ/69Ow/nHambvvwlpvmAPmQXytnX1wVbXZANW9Tubn2rbbAuUnfQArcB2XiaBgRdzeLUF3My/F3733vCTkUQgbnv2P5+VODGlx6RoKuLtxECbrtuXBsGC3pEqhHtLOAyTyt18baZ++SWBdwOxcCp6j/cZNZ/tsnyvwv87pb2vk16cU8xBJpp2jgQRQjATFFQqLIG7G5WS3TKkqjKpDGUSfSNGwPO4UPAOcfVdps91nJQhANAocozwFUR1HuOiPCjJGLGioK1tB0nwqq13DSGeSpBdxqIMbKWxNp+71mLEWMMe1U5DxwVYV6VlgjX07YWreWFZpN3Vfl8jCyK8LExdKni4p43hsMx4lPCktvGcAK4GSN/q9Hgp8mSt1AUuKKg8J5gLa8BrwPOWl5S5cMQ+F5Z8lyrxfLYGCYEWsBijBw2hltpOweLAilLFo3BliWuKGjGyLkYmRBhRpUAvDY+jqryYVnSUIWy5HXvud1L1KKKBSaoejG9y9JTXXxNYJnK0tlh65k1H4WYarVadDqdh77fTOZRkjP/3p2H9o7ckuvNg/WHmP2uXRdrA/+HLGt3E2ujRNrdXCcfUgxcv8KZ1HaaxNm6hU2GlkvhiDVRN1LQ/bXtizkepoUuapX8BgYtAz22eb3ULb+gqKknYdtM3WUyTwF18baZgNuBuLc6+Y7LZDKZTCaTyWQymSeEJ8o3xjnHVyYnOTU5yWFVPjCGiRh5zjluWct0UbBclrRC4I4ITRFuAmPOccyYfqZGjIEQKJtNrqryvLUUMXK80eCNdpvnYuSKKgI0ioLXVZkQwcbIYozs6rlQGsNaCOwKARMjR4BzwFFV9msVPPwO1VjeQWBZhN2q3AJeMIbbqv2kKO0QeD8EbgGfFeHdGHlWhOtJwd8S4bIIUzGyIMIxVeaaTT42hu9532+TxIh0OgRrWfCed4GiKJjxnneLgpkYWZuYABHueM+xouh/PthosJBG6yZUaVrLxaLg2aLgXKfDbFFwuduloErAcrHbJaqyls7vorU802wi3S5j3S4A090uFlgQoUjHKiIsp+MaA6wIZ1WZVGVJhNeA7wNtEcq03IUYmTaG1RgJzqGPwK0ru1BmnjastRTO5Wv/cWB49HbE8KtEZW8vYUiPrSQG2SojrG4bLG7KSLfIkZY56tOGrUMbdy/3mRRyOInJSFfAmiVuwGI3YIXToeXS5148omxikatZ4zS5WG7qjrgF6u6eN794l3uzZg0YcO2qz98Oveynva+RoYQ6D9YCnMk8rgxY37aS7fVu994Wb6MnS8BRZXycbjZZBJ5ThRD4QJVXY6TTbnNTlbmiIHQ6LCX3vViWnPWeVnrINlW5GSOT7TazIuwSwVrLmysrvGgtkSruYykJiFeNoV2WfNBqcTAETie3xzuq3FRl3BiuUZUQ2BcjB6zlFuC85wDwsQgNKhdBgDsh8AYQUwwbwH4R5oG9xvADqpi4G6n9u4B5EU4bw3WRKkOltbwTAi9Yy8V0HgDmQgBreS8EXioKVkPAeU/XWjplyWqjwe7VVa6rMmcM0m5z3nuOpSyYU+kctY2hFMGp8mYIxGaTZ4uCw+PjXFpaYkaVw9ZyWYTZEOioMhcClspF9UgSWD/pdnnFGDqqnBThHJW75OF0vF1gSoTngWZR0KRyC/1Fa3knRo6l9hRU7phBBB8jtiiw7Tbe+8ciO2km82mkF2uc77FHzJDrISLrHQPDQHIJE7gvl8StMCzaBuPe1tu4aZzbsFirt7MuzkaJtx10D+3ta4NrZS15yYDAki0Ku5qg67lLMkrMGbn/32Eofm/2O27DfHrtGpVQ4X6SmIxsh6Tt9/an5Bi4zFNLXbzFbd5jw0mCtsiT9VZ2jo86HZa9Z0yV8RirrIzGcN17Sudox8ilsmRBlb+typWUfv8NEY6kk6SqnDCG11XZJYKkWmunemUARJgvSw6LEKzlaghMNhqMlSWS4tcApo1hIgTejpF9WtV32xMjEbgtwrgxrAEtVdpJjB0WYZkq9uuAtdxOh9Y0BqfKMWs5JMK/8Z4viKAivKfKAaoi3XPGMGUMy0m8/U2MqHN8NVng3k4j5T9TFIhIZSEDJsqStgin19a4YC2HVCm7Xa4CDRHOdbs8X5Y0Gw0AbgJYy55Wi8lOh9kYecN7Xmq1ONJsggg/VmWq0+GkMbSN4YOyxMbIGeBcasdzwDwwLsK7IrykyjURxlW5RHUBHhOhnbJtrsbIKWAxBJ4xhovp/DRSQheNkdtUQnfcuYfascyd2Ewm88iov+Trn6MOWOMkhVcNCJ6Rgmibu5dRsW9VuzYIOerfB8VaX6gNiMy7t/Wu0z8BMnwS6vos1gTbVoRdXdCJ9j9vEHM9YXUfYmeU4JSB+fVjY3Q8zv3E5QzEum3WOAWTLXCZp5Rh8XY/AyXbHFB54nqkR1otVoAPVDkuwpUQmAOCCJNlSRkCYgzPxMg8UIbAImBEiKkDXqQkIS8Zw6oqS86xGiO22aRRlkyqslgUtIHdqtxOiUiOirAKrKWTfN17WqrsBYoQWKISZh9TCZYypem/HSOHgDVjWEgCccwYlo3hYGrTezEyBvw4BLoiNERYAj4CjhrDNamG7oIIl2PEiGC85zPWsgR8M7k+HhLBqzLvPQveY43hiCrGGE5by52y5GZZsss5bqpiYmROhBkRLqqy3K7ySK6qcjDVsls1hp96z4kYWQiBcVVcCBxV5Q6wFCPiPRPpAt4rQkyC0hnD3xLhTWDOWlpUL2sV4WAIOFXaVCJvryprIpxXZRy4HUK/0PmEKrdE2AXsEWF1B0dj70XPfSy7kWWeRspk5c7W7kfJiM5AXcj1RJEBE3ZWuPXXS9vbYGnb4Eapoy1rd7G+bSjTNqqNO/3Ml41WMB3WR72GbKqS0n9Tsz5JTVUlMVf9l5qo28SNU2vrjWpyL9voqPm13faE3oD1bStuXZuxwX130JUSkWpf2QKXeVrpibe7Cbe4VR/wrd2fT9Tb2HuPhMDtToemKlec41KMPBcjd0TYpUpTlT0xMq/KpAiTwNUQOGBM/+TdFmEPYFRBhMWyZHdR0DWGqMqytZyKkTlVbnrPXCpbsApMiPBOejieTkIDVd6lyoZ5xFqeMYaPY2QfsA8oVflco8EPY2TGWjpAG3hBhB+kY5uIkVMivA/cMYaDQFeEXdbSDgEV4ZAxXAZebbV4tyz5WIRTIoyFwPHk6iTGVH+qfN4YbsZIVOUaVRGiDlVMXDtl8nTGcFWV49YyXpaEVNbgYIx8qMpR79FkFeyEwJ0QOOQc88awUpYsxsiYCB+p8pL3LBnDeVXG0oV7OR3/KnDRe44Bd4DPAP9Sq2yfi94zSxK9VC6ju4ArIv2MlAeBKWN4FyhFOJJ+24dB7rRmnna897RarXsvmHlw1F/+xmwq5EZZuGCLwm3YTXPE/E3LBtQtbKOsa0NulBvaVNv3Xdu6E5nchgUINQtjvxHrAm/QslU/gPrKvW3XRN+AZa7mZjlCPN6V0Z6eG4Vc3VJYt8D1r48dcJ8ccN8dFnL3t8lM5lPBKCv3lkXb9nmieqbOOXZ3u3RC4BJViYAvGsMSsCLChaLAliUngPnkOtg0hq4Ii1Q13QBeAi6q9qdPG0PHWkwqpr3W6aAiXKWynn0Z6IjwQYzcsJbnkyVmMSXmWE7iai1GroswFyMCRGu5XhQ4VV53jl0xMqmVa8URY/ggRk6nH/cHztFVZU+ziS1LziaXwUMhcLjR4EIIFM7xTAhc7HZZEGE3MNPt8hNraSaL1x5rueg9f68o+LH33KYqITBnDNF7dquyAFxPrqNfNoZ3VPkBcHJsjLWUfGTCOfYB+43hoxjphMAaMNNocMkYDhnDZ4qCj4BLnQ6HvCday5z3fMz6COABKtHoVTmeBO8RKmH38+l3vQLMpJi4I8kSWKhyRYSX0jI/BTRGAnBGhNc7Hb4GD03E5VpYmaeVfO0/JqQBR2C9U9ATcjWxtS7gBjvodxVFI+eNsj7VrW7rwqwu2ka6Q/bnbWzbQLviNtq8abuHGCUqwuCKdf0FDAiTAWE3LOq02r6osqmYG7bM1a1y22GEoF6PwRua2Ps37NbVm1Znq0KuFmfZ/16PwwQku1BmnlaGXSeHhdsD8Bp7ot7M3numQ+B9VaIxnARQ5ZS1zIbAB90ue4H5lClyTASTil4jwo10Qr0IC8BuEc5Yy9shcCwE3u10sM7xsnMstNssqzKnyl+pMifCQWtpAyHFiR2MsXKxpLIQXbCWBRE6IhxNy06HwC6tar5dsJbrqpxR5WKMFKr9bb0K3KKqa3et0eCrMdJW5WqyhO1tNLisyrS1qCpjIhz1nuvWMp3cEAEWVTlSFPyIytI2ldwxr6py0jkWgKkYWXaOGRH+JsXsHYuRtbJkbyrkfcs5vhAC3/WeqArGMBYjB9bWaIqwNDbG7aLgsLWIc6yurrJHlZsiFOmYoXq/LQHTIiyKsKCK16qGXIfKRXRfah/GcIkqyUkwhldrv/2e5Bp6icpN9WhR9F1iHwZldh/LPKXkOnCPEcMWsrqQ603udyQGV70vMSRD0zextg1Y2UZZ2Ooulz1qomKzrJkbmnM/naBNVqnHk60LtPQ/1MRbb6Ek6voZJuuiDvpxbqPEnJra9LqQ2+6BbOI6Ofh9aMInickZ2P3QtTcs5OywCTOTeYoYsHSv1168+yob58uIgZrNeKJ6pBa43G4zB0yK8FEIzKmyljJMNlQ5IcIFERZj5LYxTHvPHWtZFWF/esl1qFwbb8fIRIzMGkMApq2tCoGHUL23ktvk4bTvm8llcTG1ZxFYiZHSGJqqeGOwACJVwhJjuK7KiiqqyinvuabKqggHRFgQIaTOUSMEihhZsJYpVe5YyxXveUaEa2XJOyFwvCjwqpwPgX1QiTEqC+BUEhfjMXIzBM4Yw4ciNJyj5T0vOccF4MWi4I0QaIRAFGGPMVyPEazlhkj/pfYz3vN6CBTecye5SRpgGuioMt7tQrfLfFFw0Xt+dmqK2z03K+/5cG0NgEPe84IqV4GXgfdVMVplk1wwhl2qSBJ+R9P0A+l8G1V+ktqzFCP7ga+J0FVlTZXJdk+2PhxyDFzmaaQQyYMXjxpdf9n3X/ADHeh1IbeZCyXchwAaXrxnbet9rom5QbfKEeIsjhBxG0TmsHXo3k281zFtVsR7YL2+4BpcZ0DYBd3UUte30m0m5kZZ5bbRUeu3Yfj0jNJM9QnDLl3D52q77l29gYJh9930P1vgMk89I8TbKKG2GVp/pt6DJ+qtHICZyUl+ECMnVfmyMbylypQIXWNYEeE9Y6okG6m22zWgMAZJ5QEAlq2lKEuaRVEl1ADmjWEyBFbSMruM4aJUmSTbwKGi4JBzXAF8WQKVtexDY2iIEBsN5lXZEwKzxvC293yZKmZuylpmQuB95ziT0vVbVaIIJv3Y0yIsOMdhVd43hoMhcLzZ5K0QeLEsmVUF77mVYr+sc1CWrBjD563lQnJ9dMBxa5mPkYMpIUhU5XqMfM5arDHsGhtj2RiWOx0KVezKCue1ioMz6aVyzTlmU1xdTMlYjgM3nGMxRoiRaeCG9xy3lvdWV+mocmh8HFotPpfEzvzqKlDVsWtolfDlnAiHgLEYWQGWgS+pcl0VL8JtqWrurQEvpvNzjqrcwDvAnqJgd4x0Wi3GdvQK2xwHnLSWc+n7yt0WzmQ+BUwCn3GOU0VBKw9ePDaMFHIDLpQjXBhr3G8ttfo2+8Kt7hp5FyvbcBmBatrm7byrKNtm+4drwAEba+htEG69A1ufryJJpNXWq4u6uphD0jqsb0/SNmLNItfbx2bWzxFt7H/ttWd4nf6xMJhUYTPXru0wKg6zJ+IiyCeobZfJPIlM/fux9DzU6v7YjnAbFc9rtj6w80QJOAPcaLcpqGKinicVmhWhNIbnVSmN4Q6V2DtsLbPWciNGQreLTaNHLeBOUTBmLSdC4KwxHC5LbouwBlyiqmU212yyqMqUMdwRoWMM52Pky8nN8GIInBJh1RgWVXlZlXlVVlXpABdjJBrDeFkyKYIzhpkYeS9GWkArRnbVBNOUtZwV4WCMHBbh/Rj5u8ZwoyhYCIE2MCZVTbmJsuT9EDipynuqPJcerEsirIpwU5UrMfJ8jFy3lr3dLh8m65ioUljLXlUkBC6MjzPV6eBgXcDFiHMOjZHnUqbLBnCxLNlvDKvABVWOh8DhEPipVoW/w+oqHWs51+lVvavE1wRVrbtzwOeAZVWaVOKtqcoFquLga6rVPBEmkrUSqgt1jSqmbtF7LrdalYh9SBTArxQFl9I+vxMjH6Rzbth2nyKTeSxxVH3A41S1KGetZbLRqDLjPuK2PfVEHXi5Dwi5eudcR4i0T+iWOCBs7ibc7mJl20ywbdj/Zg/T+3H724zQ2/lgZ0nQQXGnQ8c+IJBqVrphC51hwCrXi5eTXuzbBlPe1ullr9xw3obaNjJBzE7E5dTjMIdiMKf/stU/L0tfXd3+tjOZJ4Spfz/eL94tkQ331gbxttXkS9tI0vRECTgBXFFQFAUvAhoje52rkl1Yy3nvuQy86Bzve4/GiMTIHq1ixHrP5a4qh1NijgVjcGUJIsw5x5lOh06KY1swhmeAaVVmGw1ulSWrwFvJMnUiuRZejpFdwA1jqnIC3nNMhKa17HWOO8awmuL33rSW/WXJHuA2cCUJgrXkzjnXaPCRc8yHwBSwkIpgLzjHTLIi7lElxsiJGFkMgS8Yw7UUS7fkPRMhMAnMOMctY2gawziwq9PhxWaT78fIXIxc8R7TaLAnBKaLgnaMrKX2aLvNsnNoo8Et4NLaWlUIvdFgufewTufhPRH2xwjesztG9oZQxbRRibL6kmv6AAAgAElEQVRbwGVVzonQEmElRppp/hKVW+YSlUjaB7xD9R4yIsz2fnupSgfMUMU4HgXiQ7QKWBGu9V5YwGkR9onwsSq3YqTN5gOpmcyjxlHdX21gT/rv0l+DKh4YqoGWl4xhHnjOOe6EwCz3GXuU2XnqL/ck5lR1IG5iZB24Hvf5M26o5ZaE26bukaME2ight0FobmzgAw2rUt2YBCQwaNGsi7pRgg7Q9KFvsIvat8opui7ketusrbulZo74fQd2WF+2bt3rWQZgy3E5925MzX2yLuJ6bUtulFN/OQ4CK1/N/iqZTxcTfzmBRF2PAR5KHDUg3nYia+4m3FPAicgfAL8KXFfVl4fm/Q/A/wrMqeoNqd4i/wfwK8Aq8F+o6t/sVGOD94wnt7n3tCp6PSXCPuCDbpfCWk6J8Jb34D1WhCvAiyK8awy703Z2AZe6XRaNYSpGxkW4FQKHQqBrDB4ovKcZI8Y5bIx8XJZc9p7Tqiwk4aJU1rxpVToxcgB4yxgmRNgrVaIUDYFCquLd06oc6Xa5BJTGUBhDMz2Yx9Pnt7znuaKgpcrc+Dg3RGh1uxwUYTUEbIyVhc0YTlrLXmPw1rKYhNcuKsvYs6q8pcpkjHhg1VquiXBWlZ/1niveM1UULFC5Y055zw86Hc6kY9srVSKWt4qCbqfDsbExmsCk93zsHGshVMduTD/Gb1yEy6osxchkOq5FqtF8pSrGHVQxInygSgkcFMGosl+ED6nctuZE2CXCnhjpXTx7YuRF4F2tSg90Y8Q8RAHXLkvGUnkGSC9U5/gHxnAuCbibIkxpFce36D2aLLJrWiVu6QIeKB9aqzNPI5NUMaRHrMUBe6n6eePp+jxmDD+NkWeAS6ocStZwgLdEmKF6jjjv2ZPiedU5oveYHAu3gYfzjhzRCahZ5PrWOIbi0u6y+kA77zJ/IIX+3Sxud7G0bSraatMfSu23EdRj1/q7HT5hsSagzODxVdaudetc3dVyUyG33fC3Uda2tP9+U3rCMgwtA5uKt+3E5gCDCRZ6lrfawOag5bc6JxN/ObEudIeOe+2ry9vafybzIBj7yyqf+V2TKQ0NSkmvZMuQx0P/nhol3PTh14H7Q+CfAH9UnygiR4GvAedrk/8ecCb9fQn4P9P/HSFQJdC4mTJQzhvDjCoaI3dUmaJKo/93VfmRMdwEZmPkIvQzUULVaZktCsa855oxWBEONpsUZclNVVxymTxjDD8FDhjDnmRdulSWTKSH1YEk0s6I8AFw1VrmnGPCWtasJcTIiio3YmQ1Rsad45YIR41hn7W8EQKt1CGKwK4YeV4VHwJd4N+128yp0giBRVW+YC1nVTlOlYnxpirjxtCS9WQoi9Yy7Rw3vOcE8HGMHAuBwlpKVZoh8Dbw2aLgQozsL0ta1vLh2BhfgL7Fa957vt/tcqjRYEqEee9pq7IEzKkSneO8CDEJxCXn+q5Xb6TEJwAzVGUCPqvKj0XoUiUnOSZCS5XzqhwGUOXl5GI5J1V5Buccc2k7+1VZFOE08DpV2YH79EC5L6xzrKhyJv1eZ1R50xhKVQrnaFBlypwRwXvPTKPB9RAwVNdsJyWnWfCeMVW+z/pL+UqMdERoqzJUQimTGYlQibSXUt3GAmhayz5VCmNopPvpJzHiY2S3MYTkuj0fAsdFuCHCdHK5LtO1OK1V0iUnwi3gJLBPFeM9JteB24w/5GG8I+sv/16w0ZBbZTWttthmD5NtdNyHt3FP4TbK+jaitMGGtu2gxXD7DO5oWNQNCLo4eL57gm7dCrf+fVMhNyIyb/h83FXk9U159fV1cFpPbH/CpAoDu+2J9+H4yyTiZOjaq9w9dV1cDh3T+LfXCwH1j7cm9rpfXbqvdmYyo2h+e6r6UPckqH2/q2v3wLwk2mLtczJkABvF25aF2/a4p4BT1W+JyIkRs/4x8I+AP6lN+zrwR1odxXdEZLeIHFTVKzvRWIAx4JBzHIkRk0aOvbWcSpkmOyK87hwzxjDhPReMYa/3XAsBmtU485wIZadD0zkOGIMX4Xy3y/4YMVRWM5tE0fPWshYjl5PLXLSWO0nAzceqWPdZ4MVGg+8Zw2es5SeNBqfbbSaApnM0vcdA1YGKkYupMzUrVTZKgAshsBojV0PgiPdMWkuXaoh2jeqZ9hOqTJkxWRN3q3ItRpasZV86P1OpZtwisGQtzzabdMqSD0Q4TOWW+EyMfL8s2ZVKCfxVimu7XpbcTPF9rxYFX/KeH3a7fAwEa7kZI4ec47YIZQjsdo4pVaaaTca8Z8H7qkC4cxyv+QMrlYiLVMXPvQhLqpyistB10/E1qLJqNlVZprKy9R7fu6Uq8v03wM+n32DVOXbt1IV1D8ZEeK0oeD0lZZmzlv2xKiB/LEaWgevG0ASajQY/8p5Za5lTxcTIgRi5bS3HioJrIfAzVAluoLLIRWNYs5aLqkx3u/x1WdKmypia4+syBZUX1wnnOCBCyxj2iRDSC+OAczSBdowsh8CKKj8MgQMizFvLDVW+MjbGe+02U8C8tcwAqzFyMFmRobr3LDCe6kBeT1ltP/cQrd1PGo/kHalxpIjTulvjg3BHvIdw2yDY+u2trTc0bf37xt09LNddHTkcOCQ266KFmuBIgm7LQq5XY+4eI5AbE5SM8pccIfTSvganjXDtqnMvN6+hQYIN8Zf9c7NujVBTs0z0DmaoXQOuoUMCDoHmt6YGpvWye4afu3P39maeauy3djGQFRcGvw/9Hz34NLTR4XnJAie1ax4Yqrm4jd5b/T7aIvflDyMiXwcuqeobQzULDgMXat8vpmk7IuCazuGtxRUF50JgP3ChLHnWWi45x2eLgptU8VRtYwhjY+wJgdjpMNZqcTtlj/zAOWRsjNMhcKMoaJQl+2JkIgRuaVUA/Fiy4GmM+BBoWMv5EPCqVUZI4Jq1jImwW4RvG8NRET5wjr0x8kNjeA1YKkvmgSljKNMIeDtGCqri4OdT9siVlFJ/yloa3rMYAqRsi3dipHSOMWM41mgwGQKX0o+9t9HgjnN0kqhcLktOAQsivN/pUDjHbVVOU2WMbFnL+7Gqk/dCiuE6bQyqys0QmE0Wph/FyJi17ImRWVWmjeFQUdCwlpVul2nnuFkU3FBl1lpuFQVjZcnJGDlbliymDt8d1b7I6mqVMVSohMkNKsGGCBeokpyMq/J+Endd1X6SF5GqWPoeYEmVRWsfampzAd5QZTxZPMaBjjHsd46FskREeBa4Yy1NKsFpUyzmYecItQ6yNhoYVbqp/cvAmRCYN4ZTznFEhJeLgpsiLAEXul3eKUsWyGLuacJSDRw87xzHpKpZ+Q5wMLnyLsTInjTg0okRl5ImTYpU15u1dEU4kly83vKeVREOqrI/Ruao3H4bqtj0TAtUiaEisBAjE8mivOocE4/oPDyJPJR3ZK9zIKZWUFkGY9Pq7EAsRr0DdFfhNiQURorKDZa9Ee17gPEjfYyM3PeAqBM2HlOa37fOpdi5XszcSCEH68lOtpFtrtrAkHDstaNvjau7N6blalnx7jupwvCyQ4l0+iIuxqojW29GL1fLsDjb0Pj1eSOtdfX1Bdw3d/XFHAL687e3fiyZTx/f2rM+qNQTaiME3GaCbXTs7ib76m17wPqW7q97ibd7DUhtc8Bq2z1gERkH/mcq15D7RkR+A/gNgAMHDmxtJeeYGR+nbDZpdbtcD4EzzSbzqZj1CpUbYqvZZLYo6DqHB24ll6CVJCpOec9B51hyjhPW0rWWtRDYFQKlMWAM+1Ns3BTwvrUcMIY155gSYTaJpcvAuLVcKksOGkNhLcves0uVXygKVlWZoOromxDoiLAigk0j5Auq/Y79lAiTyZVpHtiliu922Z3cDo+lGnPnU2zePmu5ZAy7jMHFWCViAdrWcq7bpWMM6hxXul1uG8Nua/GdDuI9U8AdEd4WoesczwBtrQqAv5li4MYbDYIxdLtdXFHw5toaJ8fH8c5xvSzxxrAWI5OtFh+UJXvKkvbEBO+KcLgs+SBloTwKdEWYEGFOlQ+oEoKcSKJtTKpSB8eSC+EuKvfISNWBnUpP8TvAsjFcACas5RnA1TJdPmiaqozFyCvJjeyjGDlQFFwuS/Y5x7wxRGDf2BiXypJV59gDtKzFAFdUKdttOkXBaWO4bm2/2PmUCG2gkQTqT1U50mgwSyVif845vlCWnAuB8yFwU5XbKStp5tPFGDBpDKdFeDGVKFmjih9dUuVLxnA5RuaprLYh3QO3jWEpCbZJEfaLsJzcI6213C5LJrRKfhTT9m5qleV1NblSQmXhX6Vy+91vDO8ZwzPbHBV82nkQ78iWmRx8ud/lN6m7OA5M2wl0VOdHNwi3Td0j7yXaRoiKB10bWjdJ5V1v2wYxB+vHWpvXF3NxtJCrJzsZud8t0HPF3HggujFesT+r9uWTiuL6YAE1EQf9Egm9z5hkLO6JrXqbpC4+a/NGWOsGRJ3U1u19/uae/mcE7M/d+mTHmHnsCd+aWbf41oVYTcBtcIncRLBtGvu2ya0iA9Y33bjcsHh7QJ4E91O14zRVaMQbIvIRcAT4GxE5QJWB/2ht2SNp2gZU9fdV9VVVfXXPnj330YxMJpPJZB47dvwd2TA5/jCTyWQy62zbAqeqb0I/5Ir0gno1Zdj6U+C/EZF/RhWYfWcn499MjIQQWEquhru85ybQNIaWc1wsCloxMpOWW+10aCcr2nXg9Pg4ADfW1iiMwcRICZxvNPis9yy123SBGAJXjWFahDtUqfyPAyYlKemk0aBTInwUI6cmJ2lby1gILHvPIWv5QSoVcEqEiyFw2ntuGVO5ZKb1d4twMx3b3hi5FCNTIngqi9usMXw/BPZZW5UpAG6not4fqIIxfMY5zqr267ftUuV8irnb7xxrMXLYGIqVFQ5TuS4uxYgVoZWSbHzkPdONBqvWciKNFHSMYQ04Zy2fN4b5RoMyBMpul2eAt1V5GThiDN9RZWJ8nBgCR4HbzSbPpHjDW8vLrFFZsCZFaIhwFZinGmC7QpUl77Aq16isbAosinDAGGbTcb0vwp1kuRsrCqaavbx5D4c7QKfZ5K/ald1LkxvsZ4zhx9ZSAkWMXI6RaWs5XBQsAgtlyYz3HARuj42x5j23Gg12FwUrydq5luoELobANKDGoCHQtpbdwC7ncCFwWAQxhr+TMn9eUuUH3S4ryYq7/JDiRTI7Sws4YS1OlTPWMm0MYyJcLUtmjOGUMdwS4Ya1tIHDIix7z36gTOVDFgExpoobNQaT4mwnQ+C9GDkeAqvJMmeS9S2ocpTq2TiWrqHbxoC1jMfIHeCA97RSBtrM1ngo78iBuKPBeDgJI54DW3g0jHQjHLL0DY5i19wmhy1vd4lvk7tYg+5qbdvp51vPqjPqdA23qzbUvTFerndC1muvKen3iYOxcRvcKe+XMKL8ASPcMrfiNrnVOJ3hKt3DCXRUkzU2TevNMukM1XctQ+e9FuM2YJXrz9e+lU5FBuPl6la5Xozcv5vpT2v9wo2tHV/msaf9zdmRVrbR0+7uJnn3BCa1nY64ZYatb4PLD6Sk3OYRbo+tlBH4p8AvALMichH4HVX9vzZZ/P+hSo/8PlX+jf9yh9oJVEktLnW7HAVuWku30eBwWXIlBArgpAgT4+O8V5Y4VY45h1jL+dVVvgRcT52dGWvxMXKm2eSs95yKkY+N4bRW2ZJa1tKNkctUwf7TInRFGFOlFQK9qibnreVUCLgYmQKuGMOUCFdD4NkYuRgj51MdujGqhAB7jOGwCIsxckOV08mt87oxTBnDkghjVHXTOin5xRkRrnS7rBnDXq3S1Kv3HABWYqQlwqUkBnY5x34RDoXAfLfLDJVoU+e4HiO7Y6SIEVUlijDe7dJMcXzfBY6lGK8F7/HG8HKz2a/Ldgt4zVp2G4NX5UPvMTGyryiYLEtElY9TgpmQthO1SopwjSrW62T6nQQ4BPw5VabKj3ousKnzesgY3qHqmEJV4HufMVVdO1UabOxcPEgM8Kz3vJW+H2y1uGYtpigIq6tMiDBtDPuc45wIY87Rspa5FMc2Yy2nY+TDVAx80nvm0jnqlao45RwflCV7VVlLbm3LItwJgSvJHfdnRLikVVbLkyKcaDT4KD0krrbbfBgCd0LImSwfc3pX7innOOgcR1QZpxLhdwBnLUdSTFszPX+a6Rn0kxDYr0pLlfF030+q0jCGFeCWMZQh8HPARWMY954GlSv5PHBSFaMKqlwHxlWrGo9AJy3rRJhV5bYqN1Tvy1XjaeGRvSOHRRxUnexRHY6tdCRGrTc8sd4x2sxtckSc27ZE2w7HiWygf842848aLIJdxZKtTxjWMeuCblDI1d0pq/XqLpTK6MQpW2fk2iOE3Y5lxqtfYz2SiOu5UVZukzWR2k9iMvR/+Pyun7r15ZT+sQy4S6qmz0JPJ28m5BDo/MVs361z8peube+YM48Fy3++fyDu7J7CbcilssfA93u4T94tBm5YvFUZKXVr4m0rLsxbfMRtJQvlP7zH/BO1zwr85tZ2fX/sD4Fba2vsd47Se6xzrAG+KNCi4O21NQ4bw8Wy5Gqjwa1ul9BsIt6zmqwn7bLENJtcTxkfO80m0zFWhbiBoFXNrhkRbOooTaUOzS3n2JM63lMx8oa1vFSWzIuwJMIxoBMC12JkV4w0qMTLHuc4CkzHyB1jWKSylmmKp5uIkQVVZkU4GyMtYxh3jgvW8l6M3IqRZ4EbSVDejJFmUXA5RhrWsislM1gyhm6y0LgYmQH2pbipuRghRm6qsjsE7jhHN0bGmk2uW8vPWEuRRuKjMRwT4XK7TVOVM8aw0mzyjvfMGQMh8PnxcS7HyIpzrKZgabOyQnN8nCspOcss1bVYAq1kNTphDEaEbwLPApdFmBVhTauaaUWyTO5VpRcduSjChRB4XpVmskjKQ0xiMilCaS1fXKnk+5oqV4CrqkhKXHI5BIqVFWaaTa6EwESjwe21NY46x2pRcD5G9opwAnhzbIyZlNHyZqvFhZSttOM9LmUZnVLlJlV84tFWC0JgPkYIAVTpOMdB4FY618enpjhQltyOkbc7HdZSJstRDIUjZHYAS5XHAKqSEouqNFIMa6/+YUuVFxsNnk3361iMLKfrXEU4CBTOEVW57hylCFedw3vPUaryHvsBEeFHwDPpJbFXhDsx8r73/IK1XAHOqlKmwZplqvpwJfTrYx4GTqnyFvQTDU06hzjHfBp4EWtpdDpZwN2Fh/KOVDbEHqUNMhwPt5MFvDeNWbub1W0L1ratlRDYYqPvpUOGL967CLcN8+8h5uqxcsNCbkOSkygjrXH3y2YCcOTU+82MN3LHQ0KubonrdWYBeoJVa20aPpesi7Pe/L6gGxUjV4+lS1a5/j42EXL1bJjL/3Z/ZREU2P2LVz/Zecg8MBa+eaBWHJv1emtKP3X/ZsJtMNFSbaM18bblGLjheb1pw+JtK8+zB5CQ6YmqyjrhPW3vMSHQVaVMAf5NoO09Z0Pgy87xk06HaWPoes80cCIEflyWnEwP6IUQ2O09UYR3Wy2e0aqumRpDjJGbxvCsCGsiHAyBBRFuJovIUoy4JOCuAKeTJW06RpohcEsEEyMzxtCJkUKVBWO4o8qCCE6E6dSxnhXhYGrTu8ZQqHIlBI4Yw2ngp2XJcWPwIbBXlWuqEAJjab3FGFmxFrWW1SRmnjOGVox8aC0TMXKDqtO2SuUW+WxKzd8R4bgxWGOYdY6PYuRco9HvyN0sS26mYtT7AURw1nLaOW50u0w1Gsx7z0FjuB4jR4A/E6HhHGe7XZ5PwrQJvAG8INXTdFaq2nkW+DLVu/dNqs7lZ0S4IEInWQdupbT8UFkEvuYc12LkW+02h1otfvFBXGSbsAgsGtN3n70TI1+IkXetZU8IlNZitKrBteY9p5wjOsftZpOQLCW7rWVChIWyZG+73d+WXVnhTLPJBeD5sTHUe1a6XX6U3G3/A+c4B4RGgz3ecxvYm37zc0kgQPXemkxW5F8dG2Ox0eBCu83+dO24JOynjGHGGN5PGU7HkjvoYvrN1mJkjSp1PVQPiSWeXsE3TSV6uun8CHDaOTTdg1NFUVmURZhL1/mUMVwUYX9RcLYsOdRq0eh2WWy3OSDC7WQ5O5ium5kY+ThGFkQ4kn6vzxnDhzGyp93mOtAGXlXllggOmEj3SK+NkylZ0dshcEeEfarcoEqM0qQadDioyo+BYyJ8oFV22jnolyO4FgK7Gw0ONxoE72kDzVaLtnPkKKzHhBGuawOWuFEdjp1y5alZ3TYTbpslJrmnaBvZ6bnfhm5jGz2BN7x/ka2LuXsIuUqU6Ehr3H0hm/+m9e1uyDx5N/F2L2G7Yfma627a18YkJumYay6S/c0OizMYSE5St8ANCDoZWq4u5NJXNTWdV8+MKWmawMJfHOhvaxT7fmlkaGrmPrj+54c3TLuXhat33w6IpGHRVBNu/W3WhR1wT9E2MOA02I5NGWrHXcujPMBMuk+UgGsDz4+P8z1rmXSOVee4FQLjIhwOAY2RjvccLktWnKORrGIXi4ITRdEvVutbLYiRTlkSVflJo8G+GGkagzjHl0R4syx50Tk+co7bMXIImAwBAVZT58sBjRg5rsqV1HE+YS3XUk2msVYL5z2vUBXdXgqB50X4EBhTZYEq3T8ASUx9JQRej5FzVO+VrvesiLBLq3gVFyN7gKsiLCdBcCAdC1TuU0eco5Gsf7HZZBIIZcmsMXwAFN5zwxjGtcqCaWJkrNHgGLCcLHCTxnDaOeZDoKXKhyGwr93mWrNJO0YEmG42ubK4SGNigvNFwQHvOTI2xkSMfJSy45UiVfHgFNu2StVh/FiVd1Vpi/BzIlwD5lWZV+UI4IGfVeWnqYM6JsJ1EZaN4WXnKIwhrq09iMtsJC0qd9BuuoaOpfIQFmgVBd1YFWrfJcKdVotz3jNVFNiyxKrSbjQYE8F3u6w6h+l0uJy2tavR4C1VvtpoVNczVVmJl2MkxMhNEW57z2oIHDeGpRBwyYJztCxZSOL9VrfLYee41e2yt9mkKcJ0UXBYlVljuBkjQZVVVVrG8PmioKPKhRj5nLV8lH77mzEyZQzXYuSwtSwCN0LgGuDLkrXk1umT2A48+YxTWc9awApwQoQjznHYGC4ZwzPWMpNcsC9ai/eeMaAwhsNUAn8p1VGcAqTR4GXglnM8WxQ822zSGh/n+zducCTFtgFcjpGXRLgighXBJovcjDF0qASVWsvnRPieKkvAYgjsorqPYnLB9o0Ge0LgiHPckKo24W2t3G4RIcbImCo30/14hWrA5ByVFe9sOg+7gfGiwKUyJsXaGmtliQ2fhl/5U8QoEQf9zvbolPw7sN97WN3WLXTr+7977bfhzs7dd7+TdeH6Lvij9mnYIN42LSMwQsj13Pt65QcGrHEiA7Fx99XuzVYdJex6bbuftObDywyLuZ6IS9djvePcF09119G6aOtvY4Q1TmsijcFp9eW0vk5PyPVcOYescZD05pCg28y9YP7fbhQdmxZXT9OP/p2PN1ng08mFPztefRg5aFT7vIVlBojr8/oiqS6WhsTbZsLtXnXgNnefHH5ObWx3vT0y7D7ZP44HJ97gCRNwwTk+shYzPk47pcMei5EDIlwLgT0xcslaVIQF79nvHK1U5+26Kid6HbCi4FQI7FKl4T0zrRb/P3tv8iRJcqX5/Z6qmrl77BEZGbnvWVmZtQEoNBronu6eZnNGuimkkBdSZC4UofAwfwJFhvwTeOdhDpS5UIQ8kULeutkzPc0mMAAaQHWhUAty35fIjD3C3c1U9fGg6p7uHh5LZmXVoDilIi7hYW6m+mxz18++977vXoxYVTwpTel4jOx4zzkRrhqDzdLdXVV+L09mPiOd1xVVtkW4bC3bWRikLgqoayY0SeN/FiM/Ij0FP+sc21kkZSVfKM9i8mZrGcNp75mOkaeqnLSW58Ax6JvtroiwZAzGOVat5bYqF3ry/zHyY1XmRfDGcKXbZc05WtZyu9tlxlqmMzBrhEBRljwMASfCBLCYxUHWq4q1XIOzZAw3iwLbaNAyJomaeA+qLLZaPNjZoZqaYtYYnsRI9L7vGbUDvJtTIi2wSjLsnhHhvAjPgY/JbI8xLKjSJdXbneKljYBk4HKi2eR2jCyXJeebza+NFdAMVLbz8dmpKkxmOdqdDs1Gg1ZZJul27zk5M0N3e5tZY9Bmk9J7XlQVk1XFmirHi4Iqg+6zIki3y/NGg8p7XqhyoizREHhQ17ztHA2TjJufdbuUzmG8Z8VaNkmpvADvFAXPMljbDoHCOSbrGiHVVDrguQgLIjxSZS4mA/LCWh6pcjKDCkwyt6+BU84RY+RyUbBuDIvAv64qzgPLIqyEwPOqYpvkRdbJ5+8wbTArpvc1N5iGOPhb6UigvpHX9fnv685Jbd6+CZyxlqa1/DFwPQQmjWEBaJtkxXENWImRt/O2d7znUlFwr9OhEQJ3gKtFwYoIi8C9bpelLDzzuN3miHPc2NpiqSg43molRj/fryEEnmVhoocibAG1MZx3jo9j5Iq1dIxhiySINBkCWyIcA9aspZv7aWVAvWYtp0V47j2bMTIFoKkGdweSv6IIZV5+XJWaBNwAmiI470GSiMqGKtQ1lWqfkf22/Y60cSmVDIKoMdu8AQCUJkn7A7d92bZDgLZXAmoHrbsHg7SvaMtgTOPA3MC444Bcj5gaYuNkfG3cKzWzD/M2CuyGQNIbkjUfeVDQ77u/w4r09mtAvGRcLeWQiXfvh6D/2f7LemmWvbTJ/qo9RNcDcr0UysFQB9Iqh8zGD9p1GbmuBw9B/nv/r84NfdazNbj8T28dbpDf4Xbjry6OBUEwftnQcsZ/PrZlcNTfdjRlMu4B3Hr9j/w/DqTtBnK6a50992FknCEbgcF+9gJvXzaFeaB9owCcBTQEqhi5RdJirr2nMoZZ58BairrmeYwsAXe9J+brZvoAACAASURBVHrP+9YyBbTzF8aC92w2m9z0nkljeFjXnI6RzRj5LEb+IgQeSvIl6xjDbU21LLMhsBgjv8kT5kKEk6p4Y3gH2IiRR8ZwNARuhsAREaoY8cA71rIWAtvW8pQ02X27LNnK9UvzIsyK8FCEZWN4RKpHMSJsZlamaS1tTXVRJWkyS10j1vJRnny/B1zqPS0vCjasZVGEmzFy1Rh2NAkXnLGWG9ZyJQQWnMN1OhjnuJvZnAoonaOVGcOGtQTv2XaOtRB4qsrFusY4x/lmkzIEWtbyyFpq71nP8czn1NAJVW6LcFFSbdCcMfwihL6gyXESGzGTxzuhSWm0Byo+JqWMtUNgYXKSy80mRU5l/TqakMDx25nxeFiWiCqbGRxv1zUXnOOuCPN5cv/7ExN0ul0ed7sp9VGVeecwpBTMi/k6+nxnhyONBjMirE1O0oyR4D2/Bs42m2x5T7CWK81m/3tiUZWNbpezRcH9DATXjKHhHDvGsC1CFzAiXFRNJqvW4kQospDNixg56hzLIpwpCp7kfhxJROMk8KIoEO9p5brNx6q8bwydEHjLGO6J8H3ncNbSUeVFjPQqCx5kQ/ptEuDqtQmS31hlDOeNYUuVRRJIp64xIkzFyNN8fq8YQ8cY2jmV+H6M7AAXnONejLzXaHA9+yze7nZp5PrYdghDqZ+GlKp7WoQrzlECR0Woc+1r23veEmEW+ESE2bKkIUIZApdUeZDv1UaMzKgmYZGiYA64GwLOGKq65vtlyfVul6a1zJBqbo+K8LyqOFIUPIkRm8/9jPc8iZEmsFiWzMVIU5WVGGmosuUcRYw8UOUk8ECVPzGG6yRhnCL/YGyocp3E7K+KYIA/NoYX+Rh0SbKIO8AL0vfNCRHuhkBhDD3XpO8bw1z2G1ywlovW0rWWr+9O+7bt2UZS1vZsg/ODPSbqX8pb7VXA2ysAtz1B25cFna8A8Ia830bB3LhUywFmbheQG2XjxqVUHrYdxBay+/jtmaL5JlhMVcYB40GAKlFSbAOM13AKpY5h4vID25eLXq4/sGyQgWPwfxl8MJiYv6EUSvOSGeyDuINw9CDrN7isdxuMgM0hUZa8/MZfXhxi/XpjvvtPf3vA4C/bb/7qyqHXHddeZazeeOMEQ3rtdb3UDvzuGQBq/fV1kPEaA972A24HgbZx+7RH7P31+qBSh8fqtS+j9voK7RsF4ALQ6HY53WiwFQLtquJYs0lQZdo5bntPEOEHIty1lhPGMG0tU40Gz9ttyjxBnSlLHnrPyUYjTcK6XZ4Yw4IIC97zACjyRCjGyGKM3CNNPJ1IX3ikFSOfkJQBb+UJ1JEQUl1ejFTGEIBFa9mOkQq4JKlub845amM4mVPh1r3nCPBbEli6aC03Y+SOKhebTR7GSGkMH3jPF97TJKVXTmVVRvKEkDzmDlCGQKeqWMyiISsxMh8jqzFytCh4W4QNES57zwNruQG8mwHKOtCylgVgu9lknSSQck6VLxoNTgL3vedht8uZZpOZEGh3uzQnJ3kuwrV8zh4CP5NU1zOtSfjjGXA+Rs6IsAJ8D7hPuhi3gRN5/F/GmOrhgPPG4BoNihj51dYWfzA5mViEr6l1SUIPv83xbFcVpycnadU1G4BOTPBvq4oFa5PpeqvF590uLedYUMWqctV7Pu10uNhq0cjsF8C2tbgQ2IkxAcG5ObY6Hb5vLR7YVOWEc3zSbiOa6iSrGBFV7nS7/ePQDQGsZdM5lkiqn4UqNkZO5jq6EthwjpOaUim7AKr8fbfLbP7x3BahqCpmyjI9IJEkILNYFKyTxFpOGsNRTSI8O5LM6SdFWMjpyZAA1lqMnMz1qSdyDd5x53DOseYcJ41hMkY+856JGJl0ju0YMSJ9ZnFRk0Ljqiod4J9Yyw3nOGIM7wL3ioLvTkzwrNvlB40G51X5W1VmrOVRCMxkIHh+e5uNGJmJkSo/5LlPEouBpADZzODnFFBKSs1ejhFrDK28Xh0CT0KgmQFbKEtmGg22Oh02rOWjEHi/0WCrqujktEYpSwrvubezw4xqYrmAFyFwwRgekFjeZk513BahoUl4KFrLqgjWGGZF+NR7ThrD7bpmKse0pMpqFkpqqlKocleTomWZ92kO+JTEOh4DrudjdA54kK+hpzFyPQTmRVgCnnnPNf1WhfJ3pu2jBJg+110T9EODtXET+10pcy8nPa8F3A4D2g4DML4MCNlrn0Y+3wXmRoHc4LY9ICcDVgLj2LiBlMoDgcN+MQ7GugeoS5L+yivLmo+ItOwbU5+NjBBNZtvyokybDWZYDLFqaaVhUDeQf6kDx3IorfLlpsOM3MvVdoG4fv8ZzA0xcAcdj8FLeRRZjqZ5jvztM4U68n9e59O/vNJn6YYO1BhQsVca4qGapLF27cdgvP0PM7O0H3DbAxS9FhgaOb5DQiUwtt5tiKEbifNg9k1H/h8f437fmz3wJmOOz9cF3uAbBuBKkhfXZGapvAgvVNGypKwqzgG/Ap5OTNB0jufdLuet5dcxqf+t50nTMe+ZK0vawOW65vMQoNNBQ+CcKnOSvkaWrOVZCDSs5YIq0zHyLD95B8BazgK/AU6I8J2YvJOmSGxCzJPTiRB4CBhjaGvySpmOEe89tzMYLIuCG8YgmYV6UNecyT5gmtMtPyWxiC1juBUCp0kpiZOqfYGW2yHQiklE5UYIXFPlU1VmjEFIAOmyMayLMF2WzOd0Ou89k0XRP0aLMXK00eBWWXIsRrQs2XSOTeByu809Y3h7YoKGMThVnnnPvHNUwHNjeJL7iaTJ8I6keqkJ4Dsk24QJY1iKkRVINYjAbVXeBZ5lJuRIPvfHVXniPTes5XiMbHU6HP8a63J6QjkXcxpuI0Y+63TYcI4flCVfbG9zzVp2Wi2edjrUVcVcWTLV6bAaI5dV+X9iZEqEZ+02S9ZSZWBxNQTuk0RtJlSpNjdZBs41mzzY2WFKlZsizDnHoqZayDsx4vJx+02OcV6E6W6Xs1mMZidmgZIY8aqJZcss3E1VvlvXlNbypK5pq2JyPMezQEozRpaLgpMhEENgLXuUFTFSh8C6tUQRJoEJY1gWYaqq+ul43Rg5Rnrw8vvO0VRlylq+UOVoZgp3QmCnqljIIKMjAsZwWoQqX0MbwOfe864Iq6rEsqRRFKx6z3ZMqq5LwLRJPot3Gw0Wq4qpomCu1WI632MPtrdp5Jq+YzFSZ8C2qZrAG4l5/gdVJvLDkufW8siYdA/k/VJjOCrCtirnreVxBtPHSLWjO84xQfoOOJ9FfUJVccVaJlSZqGtWeiDXGErnOKZJfbXrHCYENo1hEnjiPbauEWNoxCSw1LWWk9kqYiLvW1uE08awEQKe5Od2TJUpY7ivyvsi/ERSLa0BPlVlgfSg5Dapng6gtJamCAH4TQhIjDwsS85/yfvn2/aG2z5s3N7iAK8x+xvdZnQSNAredq0/HrztrjHZI7Y3wRYdps+hlEDdtbwvUDIKmAZZuQE2rp8uOcrGjYC4196FPpDYY19eJX12vzqdg8DcCBOXGLj8HhLo6r3vbTIa7uAKA4BuMO3ypf3Cy3WGgFyv3144Q6+XqFJNPuqD6ZMHnIaxwiu9YHRgnRzIYB1fP4bevz0gN66bvUDR6PvROA5og4xgb8B9awsPAG57gbZDA6EDgREva8x662fwNr4ObiSGcTHyEvztFesrAc4eeBtiBb8+4NZr3ygAVwETU1OsOkfV6bAkQt1s8rYx3I5JSe+8CKvGsFPXNKzFeM/xEDA5PQpI9UGqnC1LHpKeUJ/pdJIggwjPgJMxstztsm0tWyQWYFkVJ8LZPGmKqszG5Bd3Kz/1viySGLzs7XQbcPlLLmYGYlqEx7m+7MM8kftrY7gYI7PW0ul2mQqB+zGyJUKdJ8LvG8MEcNc5LuTJ2nkSo/Us71tNuiePxciHmeE6E5Oa4Y4Ic8bwnARIHlYVR8qSoyI8dI7z3W5fGXG7rnlhDBeBu60WnRB4x1rudDr8stXiH1UVpfeIKm3nWBRhuaow7TbfnZ/nWRYxEREmjGEzRo6KJIsAY3gYAkuqzBrD3RA4kWO/5BylJlXPOWPoubZMOYcHJkU4H2MC1iFQfyVX2u7WIDFX7fV1ILGTp63liffcE+FaFiL5boy8sJZ7ISDdLtdVORIj93LK2mkR7sfIZ3XNxXys54xhPUbWioLTdU1HhBnvCd5zotWi3thglsScPFTlunOclSSIMmtMP2V2lgSen1UV963lDLApwtN8TR+razYkpUt+r6q4TmI772aAMpm/gBrep1TdVosjIWCco6vKtPesxEiXJNzyLEYa2ffPh8DbzvFpXTOV4zkD1M7RzXF3QmBBlU1JJu3TIfDEGL7TaNAIgWekNOEF4Ea+vyEBwKukNMEJY/giBDp1zZIkZdiqqnjYbFI4hzWG+W6XBeARsN7t4vI9tu0cxMhJa1nJbN4FSQbx86ocAe6r8t085rIID0JgwhjuZ+EcgNNVxXXv2VBlQRXXatGMSdjnrvc0Y+SIMWx4T9M55lWZaLfZ7D+tVm7kY/2WSBJFyrWGqNK0lsVmk3nveRAji6psq3LFWrZJRt6fq3KNJGYESX10NUbEGMoYmQyBqMqmKteM4boqV0kPcI6p8msRpkgPnh6K9AWenCpTmurdWqocM8lbruYb9mPxH0IbMfAGxgub7Nruyw17IHgbHfdVgNuhGKLDxblnG4d7x4C2oeWHYeX2YOP2A3Gv3PpxjNmF/UDduPaqAgt71FwOBzEMrPps48Aqu1g4GMUXY5ZlAL0HkBsHjkbZOACJugvEHdTGCq8MjD+0T71lPTA3Emdvvwb7HPKtOyQoepW2K/69QOfAOAeCoj3A5r4g6JDxDwKjfjxR906Z3CPe9F6Hxj102ue4femvp3uP8SbtOg7RvlG/yRbYqWtmJBklizE8V2WtKNKk0Rgeq/KW9ywAH4XAb4BTIWAy6wSgxrBoDI80GXMbYGZ6mjs7O7RIrEalSswiAAb4SJX3nEOBG3lCOJdr4loiHBdhGsA5NkVoAKsxMkcSJfgOoKp8bgwnneMDVX4rwt0c038kwr8JgXeBhiTPsYukidNqWbLmPVOqXA+BM5mFewDYGLktwndyP8dEWLeWZVU2gLMA1jIBdLMwwoK1zITA0czMdESY8B7nHD6nmUZr2fSeT0PgcozgHLc2N1k2himgnJ3l3s4O6hwTdc1OCDhredjpcOfJE47kH5GLInRiZMlarCptYzhmTPKYCoEnJEauEOFurv37GLjqHM+M4VRmhUSEoyaJS6w4x5YqG5JMz7+O1hSh5T2NPIk3MTIpwjtFwa0YeRIjk0XBg6piJ6cTYgwLIXCx2WSl2+WF99w0hktFwdEQeJYZJhMC3WaTSyT/vZ1Oh7dE+Gh7m3MihKKAquJ5ZmveF2HdOWaris8zQIQEOK6GwF1rmSTLxxtD1xguek/HGE6EQCdGAnBGhGcxcgFoNBp9RcP1GNnKcVjnOF5VPHAOo6kW9JoId73nmDGcVuWBCCvGMBUCAbicWcrP83UxQ2J6fr/ZxAHL1vJcU7rgBZIoT20MUYQ5a3nsPTsimFyPueM9lsRsr8fIvDFgDEuqXFdlyVqWNNl0bITAc8A6l2xHut2+qfxpEV4UBVves22SVcg977mkykOgTZqUldaySmI5T+Sx5pzjau7nBnC1qrgPvDCG9e1tJjN7flWSoup8CGzEyHPviblmbjtGpkX4GLiY+wqqSbE2BNrWYo2hIvldrufztxwCx2Pkr7pdpoBfq3JJ0q9+j6Fes5YWcA64KcK6MTRC4DJwVZXPMhv3KKdMXgQ2Y2RVhEvG8Kt87idDYDs/6PnQGD4TYYH0QOrb9jvYxjFxe7BmB7V9RT1G1zkIvB2UKnlY4PZVzIH2qSPbFcvAQ5eh/9mDlesBucOCuFdt+7CHo6lo+273ZdTx9rGx6O8bA+CF3Wzj6OjjGLqhLXogSDWDtJdjjII3GeljEC8qu0HcfudBxwU2ENy+Qiv9AQeW9QDnwDZDnx0S8LwyAzemv12gs7fssMBtDxC351i7Atsv6IH+DwnehlMndeD97jHHM3SjMYwPcGwsr/M99QYUKr9Rv8oBOFlV3KtrNqzlg9lZzmxt8csQ+LDZZKuuuUpiaXZEWDCG6yFwvtVi0vu+bPsqsJQZtyPWsmEMTzod5kmy3dMkmftWnuB+n5QCuB0CS8BCjmdFlVskYDYh0pfo/h6J5TumyufAc1WWY+SoKqdEiKr8a+CSKju5r5vAJWvRPPH6VV1zPKcsvq3KA2tBlQs5jbMIgRkRZqzlj0NgI/dTWctWFtS4r0qz1eJ6jMw7x7Qqp0OgmdPIlqyFuuaXxnDOOdZJwA1SuuqfOMePY2TTe06HwLr3zDWbFDGyubVFR5W298S65lxma1aM4X1rsZmBe2YMzbyfM85xPQT+KE/q2yL8I+AOKf3vsSQfrf8e+AkJ1GkGJ9EYjqjy6xCwzvFOBvFfV1uzFqzl8wxw/yAf34mqYmZiAqPKlvcoMAmseU9hDHNFwfPMVM6oUsTIvapiyxguZKDzLEZOe8+Tbpc1YzhWFGyXJRNVhfeehRgxxvACuCrC7apiDTjtHN/pdPqTrE9i5NMslvO+cywbwwngqSqNzD6tiCAhsKnKjHMcA+ayAMla3teSlJZ7UYTrOf13KUYuZt+5U9ZiSF+S7RiZDYFgDCvec6nR6IuYrADviCTBEWuRsmQjRjAG0+1yemqKWpWnVZVMzEPgkSrLIlwoCu52kg350cxcd1Q5L8KGMbgY8RlY1THykSp/GCMbInSt5az33BfhTKPB7QxOrlnLjPcsG4MTIQJni4IXqgRNvpLbwC9F+PNGA/GeLskke6uu+bvczwkRHgEzJtUBPieJoXxGsugIqkmxFpj1nlOqKSUyP3Q4Av3aztk89i1ruUSySmmQ7Emek0DlB/meVO95AZzJdYJTxjCRz/066fvjc++ZBm6EwPukh16fSVLHrEQ4GpMA1FIGZkaEXwF/mu+lOzESQ6AU4UkGy6UItfffrB+L/9+1V/yxHzfPfw3GZ7wdwRgPuMH3+4G3wwC3Q0yGvoydwCgo3TXmXjVug/8PLOsLlfT6eRUQ97ptCFiMzpYHase+KmnzURDXG0tH2DLtYYThMfcDdHvgjZGUyZdjDC/fG8QNvh8EcfsdjcOwb4MIcRfLNgqQRtYfqosbs9Ovkn74qvuwS2xldJsRkDK4fPT9vnEfBswNBZbHHnxIdBjw1o9LdwPP0bHH7ffIfXRwDdwwUBzehz2+xA597x1uvW/Ub7IFHoeQpO1D4KP1dczMDEe851ZdJ9VCTV5HZaPBo7U13nMOnONhCKm+BjiVmbUb29vUznGBVN+0FQKiyhNSkX+Ikbec4+chcFxT6tdNSKp+JFGFM8ZQAhMifCrCn6iyQvoOfyjCE1Ka1JpJaowzpLS286rJHDjv2xlr2QwBr8q6CB9mRbpfAzMh8IfAR4AXoSPJ5+k+qWZo29r+RG5ZFbWWLzIYXDOGP3WOm0XBhPc8spYZa5kF1uua2hhadY10OpRlyWret3VSytoxVZ56z7IqJ0VY8p4HOzvUziEiNFstCpPEHNa7XY5by6wqN3M/x6zlV6q8q8qSCBed47MMbs/E5HFWqLKeVQ83Vfk/SKleR3NtEYDGyA2XvP0mvOdWVTGt+rUJmRjvuRIjy5mBK0h1cCLCI+85X5YseE8MgVURLoiwFgKlMazGyCnneBICl53jZlXxtjH9Gq+ZEPgtsOgcP7SWZzGyWlWcy+mYP6kqfmQtU97TNIYZ0jyhBp5Y22fgjpEMt0+IEFQxMXI9Rr5DSvGNMdLMSood51j3HmcMIUbuZAYb4HQGM6tlyVRICqiPYkRjxKiy0W4z6xwdVXZCoALOGANliTEmgTSg2WjwMAROOsdyXfP33S6TeYyrk5O8MIZLdc1OjDhjmDSGOqs4zhjDTAYV85ImPGuZHTruHN2iYC1G5lot7m9tcS0EbmdGdsE5KArmqooXdc2FZjKbqGLspyb+JkvkHyM90LliDB8BZ53jhiob+SHEdoycCIGWc7yf96uRmauOMTzzPqUuxsgkUGuS5j+hyo4IDzNT242RZRHeMoZ16Au9bKiCtZwg3bsTmpjzdRKQPkcy6d4pS9ZFKGPkYxF+zxg2VPsPOKwID+uaIkacKh/mPh/ESNSUltnQxLafJIH6dWNok9IveyLXi5DElzSlh99R5US3ixs36f22fb1trxS20VTKoQnLAROBV5nMGxkP3gbH6CvHHQDUdjFC44d8k75v+/U5BOr2qnED9kqv3MXGjVoPkEDLKIg7bNsFOsdtOppCOQ50vklfqlHxHJEhI+8e8zSIV6AHHPYGdPtgpv7yl++HGb9REIcybCMw+PkgE3dQGwRsvbEHd6z3eV42Ct4GUykHydf+auPA1DjgMRLTvm2PA7gr7XN02Qgg2g2Qhj/bK+axcR/m8svAaJcYyQHgbSzrpiMxHADcDp2y2htPx7BvX6Mf3DcKwClwqiz5NzHyFkndkapK7E67zQtjiN6zUZYU1nJkcpKn3S6NPMG+l42fuzFSGMNloFRlo9VibmuLSVUeAfPAiwxE1mPkYk7521LlQp4EAUyo0lZlRZUnJik9/oMmoY5WTqW6Yi3PRLAkGe9KhGVrOZFTpk7Gl+bJb1nLixBYcY5NVa57zxURfhUj02XJceeovOeY99zN4g0/Kgqe51Q6gNPAbKPBuiqTxnDHGH6jyqL3fNHtcsVaVuuae5Lqh57GyPeN4XlmyiQzTC2SYfmLLNSyLJJUJOuarjFJuc9azobA47pmKUZ+Wde8bS33JHniQVL5e985qhj5DJAYsaT0rTXAavKs65AmqjMitDML+TxGzg4A02Pec90YPDDlPVL14O9X3+r8NPVCPl8uA+UVVeZjZKbd5r4IE9YyXdfUqnStZaeuOQe0neNcWWKriuNlybMQaOa+nsfIOWPYiUkh1MdIZS2fqvJn1nLMWrQswRhqVTZi5AjJ7NuL8CCf+yMZwGyrgirPRPihMfxDCAQRrgDrzqH5HCyo8mkI/LkIWyJo7ueUtfy7fD5Mo8F0jJw3hkKSb99UL83Re5Zj5AfWsqHK5aJIsvT5mL3nkqm0V+WHIXA/BHaspQAeVxXRGO4XBfOq3NraYt4k+4OdnKo6nwHcZoysAhfLkpDTbteriveLgtW65mSjgQkhiXiIcCcz8RMh0JYkrAJwBbhuDAY40WjwOO/jNIkx/yHwqfeccI6n+eHGe4BR5WZdcyWfr6fGsJ4fSHxcVVwVYS1GVJIC7n1JqdEqwklJXo/T+UFFNIaWSP/cB2OwzuFFOJLTlk9A8n7MbLpxjglNthoqwgWSf1wUQfL9YbMy7RFreaHKmrUUIix7z4+Ae9ZCjIl5jJH5ENhRpbYWjZE/yuf+eowYa5kLgZ+LcBZ47BzxK5hIf9tes41jPwbaXqzZGxm310bB22Hr3A4B3N6oB1y/0/2n6WPtA+BgC4HeslE2Lo5sk38/RkHcYdth0lt30Vi7jvUex+qwtTrjRHN2pVMOrK4vkyf7i0fTBBkBdAPs4dBqPTA4yFbRA0AZPA+MNQiYBkHlLobuFS6116ndGxxz9P1QnzL84b5A4rAx74GEh4Db4LLB92OA3FhQNxLPm4i7X1M2Ou5B4G1MnEMxD8Z3SNC2L1vYA2+98fe6v75CM+9vhDq0hJBewGoGNTs5Navwng/abVoxEmKkkdUl2d7mmgjWWtZISpFqLWotlCW1tTyvKj6rKta2t1nUpNZ4UpVPeuOKcAO4C+xkts0bwyrpqf02MKdKy1r+sTFcEElMmEiaKFmbhFdIRsAPneN5WTKhyi1VloDfxshvY0Sd4zlwuyzpqPJ2CExIUoObFWFdk5F0uyiQssQ5x1SjkSbzmtLzZlRpxMhGVq2rgeMumZkvA10RWjFSqnIqBOa851wI3LOW49ayltOkHGlC60Jgyidj6eMZzG4Al0PgSVXRCoHnnQ7tnR2e53qbdreL8Z5P6ppP6pqTIkzEyBmyGmWMvKfJUmBDkjT6hgjeWgqbfN9aItzP+/Isv0rgjiqNvJ/Tzn0l5RF7NckMVsyKjEGTamGDZKS9FSPNGJmpKkpjeBYCcxmklcbwoN1mJdcZUlWICKbRwDQanDKGI8Bz7+nEJHM/4z0TIfCTEOiGwHJVcTHXs90xhnZR8F5Z0rKWk2XJybKkS0rbOyfCWlXxoxB4KsKiCJeBLWN4am0ymbfJ3+u0CH+jmoQvRJgUYUWEmQwOFzUJbiwbw62qolLlelUlj8Ci4GhmGp96n+wsQqDtHG3n+JSUBhuM4VcxJnZQFa/KrPfMGJOEgjSZik/ESNt7VJWjWZX1hjFYa9mMkbsxct8YjLVcAGaritudDlVVgfc88Z63QmDRe1brmk4IuLpmp9tlp9vlfgjc8j6ZjotwuixZD4G6rmmQHhLMZhA1ocoJEUpVfhkjZ1S5m2NYCoHZEGhWFW+rciMm77ZNVT4xhqZJ1goNUhppI59fC6yFwJIIPn+XLDjHVq71fFRVTKoym6+3rvdYY/h1Zu9WrGWmKLgQAtMxeU4GTSmY08C6CCHGVI/nHE+d41KjwUdFwQNAjGFRJH3fiPA+yfuuBdyxljvWclmSzcmyKkc02V+8U5Zfm1jQt+2QbXRSoHH3RDzqy9eYJvp6r0OBt/wQidH/+7GxC7ylp+77THYG+xzt76A2bts9th8bx5h49wKmY43Ux00YB8/PYV57xDk23pGJ657tVYQWxl1jY5rEkYktI5P9kdeuayu/hpcPr7sLYAxM4sdO+IdiGuxLx8Z02FdPzn60HkoGJveDy/rjxpHP99g/4t7jHfo1MtZB/R0U0+C+MDLO3sdp+Frd77Xncd3zr+6Kc2jb3nXZez9wTcporIwciz2vWR2+xgfGGWpfxX3cBQAAIABJREFUIXiDbwiA6wEvAY46R2Nnh0uqXOl2ORsCG5rSlY6VJat1zTnvOdJocMN7Zr3nvCo77TZHjOGIMfgYWaxrlozhJLDUaLAJXFPlZ8D3SczQJyLMFgVv2WQ6fJdUi9XIr2MiiDFMivBjUkplW1OtjsTIogiFMbSM4ahJlgLP6xobAjPe83mMHC8KjhcFp63lZ5rSFBdEeJZB2xmSSmZUTSxgXfeB3DVVvLU8sJZzIpwTYbrZZMdaNATWRFjrdtksS/zEBKeM4aamOiwTIw9zjc+JEHjS7fJOCLTzPsw7x5SkGrQpTSp489Yy5xxFTsG81+0mQ3KT/Klui7AJ6Ql+jMzldK5N4G9CYNN7PiCpA0ZrWbSW88ZgTbIUaMfIA5J/3enMLtSq1Kq8qGsuhcBZVX4bk13D1uiF8hW3KrOWMyI815Q+OBEC13Pt1SkgWMs8sFMUTFrLgjGsh8CxDOx/YZIM/IIqVQhUITBjkiDNEWuZNIaOCKed47K1bFUVD2LkOyJ85D0dSKqrdc2P221Ka1kGloHvFAWFKi9CYK7RoB0jVhVnLbeMYUaV72WgdlaEM/m6XDBJ3KKVX6shcFaEFzGyGQKXVTmqyrxJyqeXmk0a1lK0Wiy0WrSd44y1/EOnw4t8bZkYuZotP7Y1KTyWIoltBM4VBWWnQ8N7HnS7YC0bIvyTomAms8QfWsuH1tIwhku5bnPaGCQLsXzhPUveU9V1suuIkX+oKnwIPPAeGwJ4T01KN42aVBVnVXEkD7bJbMT9IDNbT2LkXRGe1TVKFjLRlE44Q2LsNlQ5pcpiCMT8QKJW5Uq+BlZU2SL5NH4XkBj7acSNXOv4JCbhm/uqECPdEFgwhmlJqZnHnMPHyAngz4oCJ8KHpFrcNRFaRcFVazmZXxsilCJ455hwjo73HFOl5RyuLLlSFFyylrvec1GVEyRT9v8E+C4p62Ae+LcizGgyDQeYdclf8xuVqvEfStvvie/IZ2OB2JdpB4G3cev21j8McPsyYO1V2j797wnkxm0/8n4siOutw2se/wNA3Z5grrftUByHA2Nj27gHBQMxDE7095oYj50gM7r85bnZD8gNv385me/1vYth2dWXJoDRe+0HMPI6hwZzuyb+44Hb0PEa+fwwAOlQYHOvvsb0OwqSiGPiHbN/u0DOACjbFwSPAOxxx+0g8Db+3A72N/5aGr02d8XI8L7sAmwD6w3dG18xeINDADgR+Z9F5JmIfDKw7H8Ukc9F5GMR+d9FZG7gs38hIjdE5AsR+fM3GWwdAo9ipCwKCu/x1nK3qrhbVVwIgSc7O2i3y2Knw4tul7ecY8Naqk6Ht6zlWVXxrKroxshSjBjvWVdFvOcz73khwvsi3CWxZmeMwYbAFFBYiyOJDvRYmGlVnsWYwJIqR61lkWSq27aWiQySNrpdTuX3b3nPqbqmocpCXTOZX4/rmt8vCi7GyDUR7lvLJRHuiGCs5bvNZvIJc44t51h0jjVVnoXAC2P6rMcW2bNMhEsh8H5R0Ox0iFVF4RzHraVbFGyIcMEY5o1Jwhzes6PK2fxa9Z47WTb+lAgnrOWpJuXAzRBoVRVnu12WqorgHJ8B32800MlJ5oyhbrWoWy3ueQ/e81+LUAA/jZELqlSa2LR1UgpbHQJGU83dLCm9bxloW0vbWq5Zy3NjiCTPqqKqmH+TF9cBzZKUDQfB+0auL/puTCbtq5Jqne6RUi49KQ21k5d/ECNnQuBBUUBZ4mLExWT4frQoaIngvWfWJlP1iaLg9yYnmSkKKud4pyggC8nMxch8UXDRuf6DiZUYWQ+BZWAyRhCh7RyoJm9CaylVmVPlRYz80lo+tpauCD/I9aMnVZnO6ZwSk7F47T2m02Fbk9/gk5hUFUtNaaJTznHHGM6WJUdaLaZCYCoEtKp4kRnlZZFkhK1Kt6pY2d5mlmQ1cFmEpgg+Rv7vuqbodiEEnlYVT6uKY7m/U8ByCDRVkyCIJgXH2Rh5FCOb3S4zdc2VEPggp5tODaQZfRQj7Rh5ls/LYlXRqWtmrOXPrOWLELgSkzjIj0xSfzwLECNvZ4A4ESPrMbID/JhkAbFMuoaNKre8p+M9l7xnW5UHIbAWI7Oq3I6RVU0pt5283tt5fxre825RMNlosG0MrRA4YS23gJ8bw6ZzdICTwKq1/L0kpcn7MXI/xlQbWBTsNJvJ3sQ5OiI8iBEXAkWMrNU1JgSaJJGTtgg/VmUrRq7XNdfrmndC4HYIfJ6ZzsfAiRj56n+Kvrntd+k3ciiuwUnJuDYOJB32Ba8H3obi2we47de+TNz79b3HOrvijOwGooOf7wXiRo7RKzOf49oegO7lRHPMhm9C3nxcH/3J9PDxGjuB73+294R9GHi9PGbp/5fbj77fBeJ66+8xud890T/4dRA4Gep7kLEaA1L22vf9lr/Wa5TNGzPOOKZyr2O13zEZPS4HXtd7HItXAm9jrwftv/YDboMxpOX7s9ujDPO/r3YYBu5fAX8xsuyvgPdU9QPgt8C/ABCRd4B/Brybt/mfRMS+sWi/bd+2b9u37dv2bfvdav+Kb38jv23ftm/bt+3b9jW2AzNjVPVvReT8yLK/HPj33wH/ZX7/XwD/q6p2gdsicgP4fZIq/JduYi3H6xqqikciSFXxxDmOq/L3nQ5TzrHR7fKJMUxtb2Oc46gkw9qVqmIhK+B1Q+Dnqixay5z3NDsd5lWZkyQFvmgtNTDjPW1j2I6RJ8C8MbRDYCKjbk/yBwvWcjELb/jMgj2IkdPGcC2LBWwYw4wIJkZWQ2Arpwh2s9jHlRCoRXgUIwsxUjpHpyjYCYG62UwiDjHSaDSYrWvueY/EpIJ4ToSPM9NwRZVF4KkkwQlrLduqHI+R4zHyxBh8VXFUhDvA6Sxxr6QU0J4gRov0tH/RGB7ESFeVJU3GxfeB7RiZLQq2SYp584A6x0XveV5VNEIyc54jyerfiMnz65i13NKkQNk1hl8Ax41hNh/PdZOMiOdyytjxfO4fZMW8kON66hzeua9PhRLo1jUmH5/tzGA2VPkY+JExfAH9VLrPjUG854b3/IEqT00yL58rS2atpcxMMMBjEYoYiSI0jOG+ppTF7bpmwxiOWMtPe3VUExMsVhVhdpaVnR2eeM+z3E+QZMr8ByLsxEgIATWGyjnOiPBZCExYy2SMLKhyxCdvwQeqPIqRt/L9YYyh6RxlVbGtyskYKZzjj53jF0DZ6fDcOe44x7QxxMxOn9NkRTCTj9l972l5zwVr2XAOHwKTkOr8JCmzXiKlLS4Yw3HvuaBKW4SnIbCZ4/meMaw0Gkx7z06+NrZJTPdCjNwEovccI7HPj41BRLiWa+96Kp2nraVZ18nWwSSVy5ZP/ni/9p4dY7gYI78JgT+zlkXvcTEyD/wSsDmeToz8QJMC6iaJnfUiPI6RFqm+blWVD1T5JcmA/Vg+Jguq3FXlQk+2n5QKPGmTN96EKpW1iAif1DWXjUFU2QqBdrNJx3vOqvIbYNN7juZ+j1rLPWMovWfLGKarit8rS+4awzNVNr3npzFyEZiJEUOqy/1TEX5iDC5f16dC4ElOHe+GwHQIOGO+Nr/Fb2L79/obOUYMY1/G7StoY9m30bH2EzkZt/5hP3udNtqfyN7rDHw2ZBfQa+PESgbe7xI16a0zuO4h2+h53eX1Bocz2/4q2lhbAfoCIoNW3ioyxMIBDIqbDCkyDnWneZn0uu9vN/q+p045JGoy8F5fdrpLrHHP+2d41wZCH9i3kd5Gx9297fBngyvsiuOguHqf73PqR8cZsjfIywZZrP0YrkG2alx8uxjQw7QBRmxXGuwh2beX2+mecewV29ha0j3aULrw6HqHSJ/UN/C99iZKG/5b4H/L70+Rfqx67UFetquJyD8H/jnA8ePHx62yqzWAF+02T1RpijDvPS0RyrqGGFnvdrkGrMWIrSqWvWfGWroxqe49ygqL78TICikVaTvXsIkmdclJVSIkoQWSlcAEcE2Edoyg2p/MHAXui2CAhRjpkOpe1BjeVeVSXfN/qXLRGDZVqUiTuWauh8IYLuST+CBGym6XMivgLQDFxASrzqXUNhHuxkhd10zlmAC2vYey5HyeEHrguipviTDdavH3JNGRu9ay5hzGeyZyjdyfAJ+QANFRVT4XSQbBJJ8qn8HllCpngV+oMmMMLe8prE0pgmWZzIiN4dO6Zg6Yd47NfKy7MTJtLU9ItUFWleMkQNa0lv8K+CkJfJgQEjAEngAdVUKOpylCJ8fxGUlyv/b+awNwm8BWs8n85iaQgOlPYlLJnI2RNe+Zi5EVVVqqFJ0OlQj/2Bj+MgQ+LAq8MSx7j3rP5bLE94BXXRMz0K6NwajSNIb1GKnqmtJa3qpr7pYlE+02nxUFP+h0klm7MRzL5+lSTB5rtQgzwHUR/tMY+XEIVMZwVYR1ScqCGAMxclOERowsFQX/b74Wz8dI13sEeC8rSy4Yw+2QTO8Xs8x/KULodqlEmC8KflbXHM31gJDsEXxRMJXTXyuSIM/NqkpCHZ0Ot8qSTgiseM/5EHhBskFYFemD989E8HXd9567rcocUORjbVW5JsJDkpx+pcr7qvwq9/Uk79diTLYUM9YyLcJWVbFKSpV+rspSWdKsa6ZD4C5JddaT6uMK0sMDSHWwf52BXSNGTH4Y8y6wQwJ0D4GfivBHxlCp8kSSBYACPzSGX+dz1jKG08bwuTG81Wgk9VXn6Ha7XHKOhZyy+8xaOp0ONTCtyp80Gqx5z6l8rD8BFjWZhWsImBi51emwYS1TxnA/BK7FyIamGtfTqqzmhw7nvedBBqc/FuFYUbCe77Uu8CgErvINKZj+3Wxf+jeyKZOHG2k0te2wk4T91hsEGr31Ru0CXhe87TXu15maNDjWKKgaAXJj1Sq/DIg7TNsD6O0L6AYnkEPqoW9Q+musifzLt4MS/4Nt7DEcAB/jgNywCmXvuA5jloNA3OB6/b/KobFFvwOGj/04MDcOyO2Kda//RwDS2IHGhTYeR+2/zUjX41IMh0HR4GfDAx4EOA8DjIfGGBfD64C3IYC2O77DgLbdVgEjfR7yXj40aDvkal8KwInI/0DCDP/Lq26rqv8S+JcA77zzzqHC7QI7xjDf7TKT2bD1TodCXsr031HlWozc9B7yJP+xKo9C4FSeNN2IkYYxvBMjD0nAToEZVRYkebPNa/KDWwJuAdMiTJKOayfHc4vEPC2GwE0RYmb7WhnofUySxX8G1DGyJEmqvZMnZZMhsJ37apYls1lgZaYsuZNr5aabTWxds+49C9YmfyjVJAjhHN+dnOSm95zIYMAaQ8cYnohwTIRrqnSs5WiMrDSbnFdlyxhOOseNumamKJjxnodVhfOe7XyM2sDlPOFcBX6bAd2MCKUxtFSpvOeI9xigbjZZAlrNJr+sKi5mj7P1zJZcspa/iZEPNT1Hm801ZH+rSnCO48Yk1T5N5tAd4ESWRAeYMMn2oVLle8DTGJOi49fUjntP6HS4nX9wloHTIjiSOEdNAvFTMfKZCO9I8gycKAq+EwKo0hBhTlPtXxsoe6Dbe04VBc/rmqM2mYVve48vCiZJIP3XIfAHMfK02WRalfsxcs5aQgisZLB8T5KE/RHggnNUIjz0Pikc1jXeOWaBNecgMy0NY7hrDN8jMTOQHgCclyR0clsTM90RYTmzdOvGpPhipCCZTjdFaHpPMIYP8379HTBZ19TW0nGOK95DlqjfVuX9GLnfbrMOHMtAa0mEe6T7r5WP9Q7QsZbvi/B33S5LznG/rplQTUqrpO8GSA9eAnA3M5DbuS8g1enl+7uoKqYaDYy1PIyRS2XJzariUxJAe6HKJDCbWcKnIv2HCZ9p8mprqVKJcEyTmfdD4G1Vfkp62PQDk8zX29ZymlQjeVaVj1UpM0NdFgW+KGiqshoCZ6xlBnhG8o/8glSD1nAu3dsi/Lzb5Xy3y7xI3zTdqrJW11xWZUuVtfzw42II/HUIHCN92T8n2SncUOVUjASTrBt6D5I2gRsk4/aCpFz6rYDJ67c39Rs5axdVVfu2EUNtLPvxBoHRHoBsX/B2GHuAcbEcNr4vIxCwHzs1AtiGlo8sG2LkXhfEHaaNOyZjth0CPmP7eQXw9oo2B4Mx9KPtgZ1Bb7ihlceAuTFADnaTS4Ns3KC1wH4grtfP4HrjGLj92q4zsSdzOADkBuMbY4MwuF9DC18TAO233l4fDTJwo4BtNyO3D3DbCyztN/iYIEf7fFXwNg4Ej1825iJjDGDbFZ8Ogcy0PG+0x3fTm2DcRttr/zaLyH8D/GfAf6wvI3tI0iXotdN52Rtr880mTVV+VlWcIj2NnrOWhyJIXdOIkXURuiLgPW85xw7wgXPczWFOkiadOyZJ1htjKIzhsQjnjeG6CNMinNEkdT+b05tQRbJwAKRJ46QIlbVMaEotDCKYougLFcxrehbziPQFdUqEZ8agJNPcBxnozACb1uJFeBQCjiTYMLGzwxZpEnvFWp5WFSY/VV9wjnt1zVpREGPv4omcJ7EFd60lxpgMj5tNmiIsO5fSyFRZEaHtPVeAM0XBU+/ZyT8MjRhZzifviAinjWGLZOg8kVPhSmt56j1eFVeWeICq4ooqjTyJb3c6hCys8YfG0M5M4hTJ/PyH2WT9riorMfKBtaxayykRPo+xz7BtiDBLmqgGoKlK23sab/Li2qe5ouDn3nM6Hx+jyiXgnkn+f76ueQjUGQCvhADWcqeuOeNcmlSHwHvOURnDp1XFidx3YQzPRVgtCtbqmhACjbJkuaqYkqR4eQVY8Z5r3S4/s5aGCKeBXztHma8hQuCqc7wgmVa3bPKpWyalfC6RmMNVVR6b5Kd3xTkmVbEhcDGzMMds8v6LmakOxiRrC2tpO0fwHrGWlnNsd7tcKQoex0jD2sQy5mtxWoRGWbLT7aYvhRjpWMsJY5gNgV/EyGyMnMuMYSPHtkZS5Pxtvl+PGUPbGJ6GwKJzTAJFCMwawz0SU6uqXBThPgmIWk1iPED/IYlTpZtBtGaRkxf5XntcVRwX4Xx+eHKnqpgpCpaM4bMsUtTM/VzMaY0TMXI0X48zwMeavPdmM/h7osnjsCHCd0X4SWb22iSGG6CVxZCWYmTDORZi5Ki1PDCGpyLMhEDXWpoxcgN4r6ogJt/AR0CVr7eFmMRwbgBL3jNrDK38MOEM6WHIJ8BbJCuWmnRP2Rxn7z7aNkkttxThcV2zYy1LzvWzB75th29fxW/kniBueKX9//8y7U2At1cFbm9azW20v3FAZRyQG7PsUCBudN3B9V63DR6vXePkVV4FmYw7xoPL9gJz41i4/mcDACpfE0NAbnDIATA3CuRgkH3rrUufjTssiOt1N/r5odsIqByzCzn+wTiHWchxwG1XDHuBoDdwGwylpI4bfC/w1gdLuns9Bj/f3d++/4+LcRSQ9ZfvPmGHAW8Hsm77AbcD4u2xbweB668CvMFrfo2IyF8A/x3wn6vqzsBH/yfwz0SkISIXSPOFn335MFMz3nO7rnkhqf7oUlFwKsuez6pijGFBhA1VjmR1N2KSAX8RY98rsTKGTUmpj+0YMapEVS7miZORpPD2xFrmjWFJlYvAlgjWe45A/+UgGecCV0lS8zZGnpIm840MWmpJdU7dGNkJgUskUFdKkv/eDIHzIXApBM6IJINdEWxV0aoqzmRAsxMjd0KgBG7lFNITeRI+qcm7aYUk07+jqY5qpqrwdc3TdpvQ7WLyhO2IKjMkifWnIbDaaIBz6VUUrEnyBWs3GnxelrQaDRZt8oyblpSyFlR5X1I94kYILMbkh3ZXtf+q88XbUeWuCC6n1W1IqjmcNgabx3oRI7PeU6pyXpMX1wkRPrDJz+9WBh638uT462qr1nLBOWJmWpuSLCSawCVVSmM4Yy3TxlACR4qCGeCycyyQWKJGjLTrmmcx0oW+PcYL1dRnBrDOWlaritNlybuZ7SxJXwK3NEnYN43hkQhT7TaNuk4vVWxdQ12zDix7z0YInDOGd63lYoz/H3vv8hxXkqX5/Y673xsReBIgQPCdfCaTyXxWZlV1PaanpkctjTaSZqHFbLSUyUz/gHZazT+gjVaSzWgjmTYyySSzaY2qqx/V1V2VldWVmcwX30+QBAmCeEfc6+5HC3cgA4EIAGSSrEqJxywMQMS9fv36vTfgn3/nfB+/DYFPVOk4x8GiYBE4IsIta6lEqESYVmXNGNQYxppNnhiDVWUpBBY7HYY01ejN1zUta7kTI7edY6QoMMZwXVOaYxkjj2JktNHAZDZq1Xu+cg7jHC4vaJxTpSClAa4Dh5yjLopkNwAcqmva7TZ386JFrcqSc9w2hmGTDMYfZjbqDvB6vi8s6XlfFmFZhPMi7DOG1aJg1VpmRXDeMx0CEyEwr8psVTEWAj+2lpYIF0PAFgXvNRqb4/Ma6YvtiSqzIjxUZS1GjqrSyosTB1U3mb92jPwf3rOc+yMi/MAYfmCSyu09ksrtNPALTebqZVly1DnWM6A6BBzM6rcHRNAQ6IgwkY9z1Rg0JlXTMl+DIMnY/ZEIn4SAxsiQMSyK4IyhIcISacLkSTTRn5DY8ddUOZSVLDUEXqlsPF28yP+Re0/D0V2A0TO8djpWn9im4tYPXA7q4w4eds81djrOILDZ9f42hcrefQed30Y7T/ParZ2u2BNjs9cx3ut22qP21xPdkvFbJss9IGELy9M7Ed/2t/YHHTtEb1rejq/ePvb0qZ+S4lYFx8GqjP360E8dsvd4z/LqPYd+x9kVvPXZjt5jsHW/fmO5Wz+39aln362s3MZxBoC3fufR08ct92O/a88317Ev+7ZDvCjwBntg4ETkfwZ+BkyJyB3gvyUpajWAf59XA/9BVf8rVf1cRP5X4AvSfOC/VtXQv+Vni7c7HT7SxPCoCGdUGbWW5TyxmTeGMRIDcUyEX3jPIWM4bAwH88SuDiFJtecJzHlrWSGZ7kZJ5tlLxlCEwGVgUpKX1VxOK/L5gnwoSYb7NLCqKZ2qrcmkOoRAIUI0hnMhYDMwe6KavLty+ua5zFaskRi9lgjzwIi1nCkKrlcV+5zjxvo6+0SYzvvVrRbnjaHtHEPe095ID9XkufVQUp1d1WyyT5W1dptjziWT7nab+6qbhRfrRcH1DCQ3BB9GMvBcU2XSGH6uSZRhVJV5Uv1RJ0b2W8vHqpTeMwUsFkUyAc/tTEpKL+xoqh0cyd5Zd3NqmtY194A/dY6vgYUYGVZlzXvuAQdzOwpM5+s2ZC3fN4YnmuoUX0YMe89N4ES+9mOktNjjpIKWAyIsWcuY97iiYJ8qt0wStpkzhlMinDOG5aKgo8rrzWZi6YCzzSYHjOFqWXIzRs6RBCamvOdmjOwLgbUQaDjHhEl+hLW1jACHGw2+yO2MWMvXdc24MdyPkVqTXcMV73lfhMUYmSlL/qzR4GNVau9pGcN97zmqymw+12VV1kPAFQWrdc2FnG45ESOvO8fndc19azntHI+y3L0xhit1zai1NFupSvRwCBhr6ZBtOKxlPQSOQXpeNQmofAG8nceyNsmc+pi1XM79uV/XvKVK8J7FDEBmrGXeOZZV0Rh5x3uWYvJw+12MTJOAi83PM5BSoyVZccx7zyngDef4sq5ZNIZDMTKRmfgyJvn9NeBgVXHHGC7k7487IXA7Rt6WlCZ7zhiWgWZm5EpNKZWBxHhOqnKHBOqWM4jcEAuCBOyLomAuBD5QZTYzbg3vGS8K1quKJ+026yL4suRhXWOsZdI5JtspoXuIJAbTEGFZk8/br4G3NYkarQBvGsNIjKyLcIKU3r2gykeq2Hxu/06Et4zhNyFwyDmOW0ujLBnO4/cqtscf4n/kNiauW7xiICB62qP0j23s2yAA0xv9wFu/eBrQttfJ0V4W+wYJgGwco7cN1c33dmXi8s9vzcJ1n2+/c+rt68Y59UuffBZw3DddN7Nw/drTrQxY6lvXr73MnH6zzZYx1a276uY2bGfi6GbfNn5q3m+rsIn2YdU2u95Ll3VHD3u1jX3r29c8Dj3bKFuGZOv59jv2s+CB3pTU7v73jsFO4A22AKqBDOE28LND3wZ8thVM6nbQtuV4O4C3zfa6ByC/17uIsK0Puwz2xnFfYtpkd+xFhfJf9Xn7f9hh+38N/Otv06lBEZ2DZpMflSVzeVX4L41h3Dk6klLKIJtte8/vVfkvckrXsurmYBpV7sRIBEaco1GW3K0qJoFrMfLPRSiBeWuZzfU6DVVey2xdmb9Ufm8Mr2ti/qZEMM5xLgSux8iMMRSqrIhspghOk/zZoqaUqQg8yW0ZEeZC2KzBK4zhV2tr/LgosLm/SzGyrspQs8mjqmI5q0DaEGjm9Lch4FBZEkWojOHL9XUOOsd0q8Xs2hrrqhwrCsa9JxpDM0bWvOc15xi2llYnVxOJMOEcJgRaxvBeVTFuDKjyOCSj7X/iHNcBFyPjuUaHuuZxCExk4CUkYDofAsdM8k+7L0IzBM4CH4fADRGqqmLZJDXKq6rMizAKjORrutTpsA9YCoG2MTwJgdc2UgdfQqx4T8taljbSZ43hM1XGNaXWBWO44z2HAI2RX8fIpLVUITAlwqi1/L1zXPAeEeFep8PRMiWIrqkmAY5Wi0Mh8HfLy3zYanE5BCY7HWZFeL3ZZMkYvoqR92Pk45z6t2otJ3If50LYVC1sibBmLQ3SXGFJkzdhaS1fes9bWXzmkSSzeUdKS4XECh+0lsWQFFdrVSZIgj6z3nPBORZEuB8CoyKMxsj1quJMrr3cn+/Fq8YwA9wLgUlrGQuBI0VBHSO/AU4bw/sxcp1UZ3lHhAmgAC7XNcMbCy4iLMSIzbWRxAhlyYRzhE6HNVIa4FheIFFN6cxnRVi0lpDPa1iEWaBRVTTzc/jzEJiLkUMiHMks4cjGPWYMEyFQxuSJ9zCP83sivG4tn4WwmaI6le+J+5pqZydi8mZ7BBxbjeeaAAAgAElEQVQUSeqYwI+s5Yb33MltjRhD9J550qLARWOYAhDheqPBWIysbtxD+fn7sNnkEjBWVdzN52aNYSgzhGN5cn9GU6XIWZLY0n1Vxk1Sw12WpIh7WJVRvlF7NaQ64rNFQcjs70NrafNKxGRQ/DH9j+wbz1G3Yq/gbdd6t34Tmz0yPM8U/fYbBOp2AnLPAuJ6tu2rZvksMQhYdn82KL4Ns7lDfVwCTqntbkC1tW/dO+Qf/YDcoBq57vTHfiCuq90EILuxSpewyUD09M25bOt6P1DXD7T1pntu9rULxPX2r7udHcDQwPcGRZ9UyS2plL2bd4G3vimTvX3s/UnP50/Z574Maj/QtrltH2DWCz779GEQeOuvkjugP73xMjIGuuI7VZ/eCIFVY/h1ZrbeM4b3NKWVnS0KvsyTy0etFkW7zUxVMUta7V8SYSFP+M9n5u24MXylyj1VCmtZBt4H/s8YOUqalI0Cp0T4xxBokADF8dyfG5rqXz7NaWr3vWcYeE2EFe/pGMM17zknySB8URWnKbVsiTR5a2TmbFWSel4nG/aqpJql+RBY8J7TxuCKgpUQmAuB1bJkRlNa25AqIxl4TZcly6q0ypL9MXKh1eKhCHUIKDDq3KZwwZOcUrU/1/gtOsfDLIjxgwwqmtZyOUYmypIlVaL3TJJX+1W5m1nJt6zl74xhsar4vipf54dgPB9nDPAx8shazqviVbkYI4vAe5qUP00IzObxPh0jl1W5lf85jamyqspZUi3TvCrSfHlVOevOISKM5f6MeM8TEmM6ZQyltQyHkNJOY+R0UaR6OE3pu7diZLTT4UEG1oeLgna+ZgtAPTRE0W5TFgX/YaPBkiqjMWKKgmPG4L3ncIx0JBm7H6hrmiIsdjrcy2P9wwxQrCqXSUDyWIwUmtQtp4uChRhZLgouh5DsJrxnuq4ZcY65/HxUItzxnoa1NFQh12MNO8e+ELhD+gcwJKl27bG1dLxnOQOEDQA3Alyta7CWpaqiub5OLULTWt5R5YgIK5ntek1SWuoCSQSopcpsbuew91hrWTaG6RDoGMPNquJQp4MYw3FNacMLmpQT10nKqsOq1DmFGuBrYDKrfVpVRoxBVZkSYSpfhyawLsJjwHlPU5XrIoxqYrYhpe8uq3JMkqJnAJZIAjtnSOIm1zIDjrU8FEky/ar8nfccFGEk98kZw6i1RKBqNDgdAresxXU6qLUs5no2l2tNR1ot5ouCdowcUeVSXlA4K0JRlkzk750oguYaxg5J+OhRjIwZw31j+Jkx3FXlL43hT1Q36wStCK+bZOLd8Z654WGKotiiwvkq/jhi13q4XYDbczWh/TbgbadJz4tcwd4JAMFgcZinBXH99tn4/Gmj3ypK9xg9D2D4PGMT2Gy9jv3UJ6EHyPWAq82x3QnE0cO+7TQcPeBux+hqe+t59JxDd9/6gTh6GEnZ2o+9MlrbuqcDxrffvjuxbxvb9xx7N3ZrIGPYb91ktwHvAWu957aVhdNt/dkNvH0r4NYTG+xbX7D/Ir+7cnynAFxHlYvWclZSul8VY/KD06TqZjWp+7WrimXv8d7z0HvamUF4kic7N22StS9i5G1rueY9+2NkUoRPRPgQIEb2xcg6MJdXstGUGrXxT7MJXCVN2PaHgBjDCUk1I3clKRS+lQUQrAiHVPlchHMkpuySpnQrgKMhecPdJ4GVd0W4XRQUIXA8BO46h8mTYyPCm95zCXi/1eKrmFQ1IaWgfZHZyPUYWQWMc8n3yhjEGNR7TmtK1cIYahL7MhqTmiDA16q8L0K0ljIEJkk35FcinGw0uOQ9dQZUX6nyt94zBBwIgWVrMRmY1nXNYUiMCPDIez4xJtUiapJ/f2BSnWEDOKRKla/TQRJQ3Lj2+4C5DHRLoOX9S5tUloBpt1nM1+vzzFx0gLuqnAmBlgjBOUZFWM0MhzjHaAiMeE9lLcPeEyTV0W3cj7UINqcirrXb3Mz3yDzwPWO4FGNin0PgifeMec9Ba5lyjmuQvBGB34nwdqPBxU6HI9ZSaWIHG3kCMV/XVCJMWUvM1/2nqkkm33vWcyrmEWv5QpV3rMVai4mRA9ayEiNrqgzHyLz3rAIrziGqnHMOcY5WZq4AFuua09YyOzxMXVUcVcWEgI2Rr/K99shaFlVZJolq/Bi4aQyLqpsgZ0GS2MZYCMkKQ5NNwBWSmMkQibUbIdW7jZDmOUZkUywE4J8Zw/XMUDVJzzUxUliLFeFOCMlrj2SdMW4t9zR78gExt7UcIxPWsg587T0/tRZRZTmz6p0MTodIIHcl3y/v5kWiORFmc1vnjGGUlOIYvWfJOfaLsOYcpQjDxlB7zwhw31pcXTPmHA2SRceFzOI+CIFTIjy2Fo2RqMqItbwRI5/GiKriTLI0GFflN5khPCDC70j1kgA/9p4b1nIy12ne856ZtTVq1VcM3HcldgAGzwW0bbSx8fNFgLeXMPnZdqy+ICt/1g3k+m0/CMT1fp5/PjML131tdwJzOwL75zC2veC2K41S8vs7gactgiXQF8htgji++WxXEEcXWO4GRmy+tY2F2zWFsrt/XX1J59G1rfbdZCu+2wRs+fy72LhtjFbP70/z7Pbbtu9Y94x7v7TJbXVx3W3sEbjtBbRt6Uf3OXQBusEsXL/fv9l/c9u9gLdBfd2yPS/3O2pAfKcAnHWO12LksUmqfZOqjIgkYZCYTHS995ywlhVjuEwqQpgVYTlGTueJ5WcxclyVVWO4QzLBvRgjr6kynFf0L+WUxRERCk1+UKsivAubLMxXqryR2bymptStuRipgJPAXE65DKrMqdImTTRXNQkMnIFNRUufJ75LwNvG8Pu6BlWOWostS1STB9tIjLxpLXfqOk2u65rD1vIoqz6OilBISuf8rKo4HSOOrO6nyhvtNmsksQdjDEVZMgmMes8XznE4j/VpEe5l5mDR++RHVdecVeVeXdMSYVKEeWs5mM+lUOVis4npdHiUwcBojPyAxFAMkybjXpUzktQ4A4nR/C0p1axQpTCGyzEyHL/xu7PAkCod0k17a22NQ80mxfO9xQZGBcxk42pIdgfnY+RLVQ6TzMwPa0q1nQ/JhHpSUj3SNLAQQkpfzfuK6ub9+PsQOFlVPFBNtg7G8LCqOK2JSXsM/Mh7FoDv59S9oyHwsfc4/abg+z2TTdobDY4Cj/K1viuyWT/4BLijypvWsq6JQR22SUq/LNJoLsfIm8Yw7xzDOXWwXdccs5ZlVd6NkSckkDOZzznEyFpVMV8UnMzn9Y61/HWMFCsrHFtf52oIvG8MczFyRJJSbAc44BxrqhxT5a8k1YD+K2v52zz2P5JUgzoPjHWBmTdD4B9FWCMtphwW4Y4mT8IamM4A5Xoen19KSo3u5Pv6jDFMFQVHgJuabB7GVFnJz2RTlRFSSvY+1WRNAow7R1OEdRGOO7cJFMeN4WoIDOV0xiVV1gC1lmljeASctRYFDudjrIRA7RxHRLghyQJCAYwhhMCnuQbxpiSfxIXhYR7XNd4YYqNBJz9nHzjHb7xnVITz1vLrGDmgykcxMklSx30jRkZFuBUCbzvHTQBrKXI6M/k+dsbwgKSKW3uPaTaJZfkKwP0Rxl5UKZ8r07ZDW0+tNPk8wdugfZ4GJO0G5HZj43r/huejODkoNiajg4Dc5oT9OebQPk1oV0pjd/SZpPf1g+u1H9gEbVtBXPdnW47b5zJ2M3Xb9uuz7bZTGpBCuQ3IDWDjelnBXpXKLf3q2mbQZ3uOQemodPW1e/NnAW97AW17AHJ7F6HZynxJvzHbBbztOrZ/eIy2Y3ynANyGXPe+uqbMwgG1KkOkuh3JAKgTAosxckyTwMmICJ9VFfvzl8RZY1g2yYi4ZQwYw7G6Zhh4pMoD75mKkSlVLqsySTLtvknyNftlnnyNWguS/LEiyQx7owZlSXVTH3pIlZOSzIBnSSBmWASfwR8koBlj5HtlyRfAuirnRHgkwohzjKuiznHPexYzgGp6T7ssEec4kidyj53jhDEse8+HzSafVxWHVClishNAUzrdUIzMec+RToe5RoO1PJY38hgNFwUPQuCEcxxxjvuLizyOkZoE7lZINgLBWk4BH4XAuU6HAnhsDEfzg3FbhMeSzKKvkVQFIYG5FmyC3rNAkRnIRgZvK6qb20v+bL8mE/e3m02GvX9pwgpjwEewmUZ3wFruS/IG/EqSKurDzG5EYNp7Iikd8G5RMC6Ci5F7IrzlHBe9ZygDnXHgZl1zttHgmqYaS3GOy8bwfghMA/eriomq4k7uQ9T0tT9hvvkP11LloioHQ+CKKs2i4H5VcSpGhiSlV+7LNgY2BB6LsGCTIftojJs+idFa1o1hf6NBHSPF6irW2gQWQuCiMQwDY9ayaAxVXrRYNgatKm7ke7HdaKT0SBIo/NAYPs/39XVNappPshhR6T0rqnzPORZUeaS66Uu3YMwm4ySker4nJHuAaU3s9phzaK7JCzFyQpUvRDhvzKY5/SUS820lqTPe8p79IvxljBwG9mmqWbV5YWFVBJsBId4zlRdJDmiqc7sPHHaOT4Ei+yEukIRSOtYSSEqVR/I1jsbw27pOLHO+boUmNtkaw7QxXDOGk7kfS97znjG0jOG1EDjoHP+7KuIch4qCxbrelP+/U9cMkcBp8J4DIkyIcNg5LqkyHgK3NKVv7wMuxsjhLKY0QfJ+g2S3YnLd4Aci3HAOjKHM33Gv4o88ekDRU4G3ftsOAkAb2+71ptgLeNtrX1/UOfXusw2M7QHEbRxCd0ilzD+f5trsyNYNYuX6tf88a3Se0StuJ7ZlC5ATdqyN2wAhW5kt+qdSbh5oY7vtJt8DY0s/u06jD3jsTZ3cBuK6+rXRdj9xk+4x2TzGTl3sxSG9l2Ub4Owa7wHgrXvfbwXeBq2t7AHMbW6nvT+3js1O7OUga4Adx3eHvm0Bjxvpk73j/zTfUbGrg+bpVnu+UwDOhsBt56iNYZ9z2BgJVUVUpSxLOrleaMF7RJWmtVyrKgT4sEv1z8RI01pmTDIl9qpY5xgJAZPV7Pap8jUwIsLneXX+lCSVyQ/yl8yGstwYMKXKb0kTslqVWpJ/1zGS/cAVSald65mBeqjKQRJLAXBJhHuqmLrmUFGwlI2Yixg55j3/4BzfrypmVTnbbLLkPSMx8riqGKoq6syelMB6WfIoBM5WFVOktLK3nGMk96URAivA2yJct5ZDrRZfLC8zndO2AA7kVMvlGPHAm8PDPKprOu02DWNok2qBXO73Ye+5JMLJTodGUfA438A/UOW3mcm4oMpc7sOcKqhiSSB3HHhdlasZABlSyuXGrb2gie28lSfVN0LgXLv90rypOsA7qtzI18sAK5pS8cYk1cbdI9VNjsQkJV8BkyTGd9paqhh5IsLdGDlYFJsegPvLkq9i5PMN5st72sbwdq77aq2vcy0EDjjHgSxH3wHeEOFqjExnYDGryVphOSYFRRFJghwxsl4UdJxjTIT1EFgWYdhaplU50mqxtLbGg/x8SIxMNRq0SfdB1WzydrvNTWvREJLXWwhMG0MjRr6wluOaUkr3kZ5TgNW6pqxrlsuS69ay7j1lUVB5z2vG0DSGD43hoxgZU2XGWr72nmkRMAbNY30nRi6ocg84Lin9dFiEZZJJ9wQJbI07h4+RkJ+/k3wjEgSJIcVaHovwA9I/ry+Aw8ZQek+dGbBIut9OidA2ht/ltNWV3M6aMUnxNgP2JU21d5eAM8ZwSJW/VWVMNYFckpfdTe+ZjpE1ERY3+mQtX6pyPEYmneMHdc114GiMrHufFo5iZFiEf7CWA8PDFCJ4axmua1y+h+ZJxvJGlU+t5YAIM85xtd1m3iQxlteN4Wvgngh/VhR8DSx6zxkS6w+JqbuSmcX7QMMkQahCddMs/VX88cde1NP2FP226/PerlYB3fGs4O1pJkV7bWcnYNQPnO0G4rp+f25iJfRhTwbFi2T89hCioPn6ipFvUhr7gLZBQK4XxEEPG9cL4jaOuwUgbb12mwwZ21mwXaMH/GxrsycVcUcQ17XNZtM9rN5OwGJX0LPDdtvYw14g13PsQXVug8Dbt06j7NpvL4sbg+vwus7hacFbn8Puud9PG7HP6le/93aI71RWjFrLa2VJ2WgwI8I6ScmudI7fiVA6x1VgyDkmigKcY8I5zhcFszFuTrQhMQKPSWlgN6qKtiYZ9QVNJrwHSIqR10T4qbUcBRY1+ZhdBi4DoyGwGiMrMfIXwFRe2T+Xf54k+aSti/AWSTN6iJTm+IYxiLVcEuGSCBPWckiENrDkkwH48TxJ/JX3DHvPHUnpYgshsBoCt+uaGWuZIomdzIeA8579IXDYWi6GwKj3NLzns2wdUJNq494Mgc+9Z0KEhdVVjpKYr32q7FPl1+02MyQz8VHg33U6LIbAk2aT29ayj/S/YrKuWROhLEv+zDmaRcFqnsyPAg80pdidJDGoBXBSk7T5LPCEpML4miYj72lgGXhLhBuAz0zltDHclCQ2oSIclaRS+TJjzlpaIdAKgSMxMqHK94zheFmyWBS8ay33RJg1hmHn6MRk+fAjVRYANck3bgW4kVMWy6IAVd5tNtP1NibVTqmyvL7OZ50OQzYZd694z6wmYY4owppJfob3vee+95wQ4UBRcKwo+H6jQUtSHea6ST57R2PyIdxPYoFnQqATAp+vr9ORxByPqWKs5VFds7y0xLX1dSaqir/2nkch8CivIK9Yu2kGfU6Sd5zJCxOP82vIe9ZJ7PJ4CIw4xyESqGoaw1ewKXn/QJJa6yFVVkjeaYdFOCzCm8A14PXMlBngCPAzkzwBH5CerU5Z8lCE9bzAsF8S+7ucGfcowlKMhBj52Fo+t5baGEZVOWoM+0RYFOG2CCPG8KUI47kW9mQG602SLcDDGJkMgZWq4gIppfMQMJdZtDdJtaxHQuBCfn8yX/+2JLXNCWDWe94yhgWSo/PbwOOqYrLToZ1TwxvGcD1GTonwel1TdzqU2WR7pCwZyTL/RoTH+fo+VOXvqopF5xjNQPKiMUxbyxlr+RtrWSMJAt2JkVt5ceQLa7lgLfuLggXgUgg8yn6Br+K7EQMnP3nR7LkBoX5zjecN3p53nwe1v9PnvbGbJ1rffXo++xbns81br9+x+l2bF6GQt4c2B/qDDXhv2+R6EJPSvQ39JvT92ZGNfbrTBHd69e3rlv7uAGb6vd+nzY1zHuR/t2tfBr26YlsbW46x1XtvUF3ZruBtt/HZS/9799v2c2tju6VObjle9za92+02XrvFXp+vGJ8aqA2K7xQDZ4Abdc1qCHzsHKdVmTOGWoRpIHjP/kaDufV1RkOgESMPnGNOldEQCHnQgrW8bgwX6xqTV9PfUOWTGDlPYk5ukzzM7pPqs6aADyQZ3l7MN8AhkifcLElwY4Jkiv0YeD9GLhrDeF7lnwLaJOGODQGJEji9oUIZI2M2mSKbXP/yUJIku2iqMUJTTdR/UNfctpajIlzrdDjhHCNVSiY8WBR8HpLHlgmBVqtFu93mPRE+d47JuuZKWbJS1xxxji/X18E5DjtH0W5zMSs7RiCGQEuz5YG1qDHcryq+J0LLOWZUuR0jRoRxY7jsfZJ2B3wW1jCqVCRRlCmS0MQSyW/vzTwGs5rS3d4TIQLvinAvRg5ktgUSkBvOAMPldl9mNLxH6pqHmV0az6bet7NgRKHKfWuZ8p4jGViUxhCBT41hNUZuAqdUeWItTRHaXffjobrmcYycMoaFsmQkRtas5cfAxbU17sXIm0WBZvGaE5pEXd5Q5WrXosRqVdEpiuQVJym106tiMmMVgAnn8MCVdpuxLJIxIbJ5X6smJk9IixRrzjGdBTDeMoZPM8OoxmCKAh8CTzJAOiPJhB6gVdesGMPVGJkJAU9K4bxtk2l4KcJCCDRC4GCuM2vHSOEcDU32HACfh8A+YMVaFjLAK0S4X9dMxYgaw20RTFXxgSRRDmNtksonseSQnr/DZckXmQk9aC2xrnliDA9UGc3Xa0xSGqKPkY/yOFtrN9vZsAnYMJSnqhIrbQznjWE2RmJOwb6e79tmCJuqr6+JcH2D7XSOy5LSNpeN4XOSUuwj7xnR5HfZjJFh51iqa+aAiaKgbLepvGcpP2eHRHgckg3JXRGms1jOQRHm8ndlUdc8yoB2ynseaUrfHLGW+Xwvvr1xw9c1j73n9Ww5Yp/TP5xX8fxjL3VwL7Lgfs+pgE8D3l7y9/tApcjdPttlm+fJwvVrG3Zg5P6YH9mNyzugHm3buOXPtoib7FAP99Qs2w7RN22yzzn0VZ7sw8R177s15XM7+HhWKf6+23f1c8u59I5d7/GfBrx1H+4Z+74thbPvNj3t9fl9izF3d9s77LPZdr/oZSe70ie3MOQ7Lq4834fyuwXgJEll72s0MCHwyHv2GcMbztGOkSdlCd6jqhwAHpFWtSdDoCIV50Oq93hIriUSgaLgWqdDC7iba3oOAV+q8p9nMHEE+JUq7xrDa/kC3SZ9R27URf1KlRlSOpMhgYxF4F9Iqj/aSKs7IMJdTabYX2wII4iw6D2jwHBmEMY6HQ6UJQ9DoCwKjHP809y/1apiJDNCV+ua8/nLbn19nSZw2VreDoEH3qOSTJzbwN0QOJ598+Y1CXAc02RH8NB7ji2mtXZXliyRRBeu5dWZ1XabD62lajYTewest9sc855HJFAzB7TKkmaWyB+S5IHlMvDaZ0yyJwAeGsO4KmeN4QopLXCdJPIyKrJZ4wTwFXAa+AvSBPu0CAeaTZ54D+7F38YbDI+urwPQkKTQuRgCxMhqBmUz1rJmLffrmrP5Ou+zlhXveTergd6qaz4E5vM1m7DJSH4tRq7a5Jc2OjTEvU6HybU1Psjpwtd8Mt7+obV8kuvanhRFSg0E9sfIIxEWQ+D7JPGSSlOK37gmEZz7kqT6p4FmUdCpa1ox8sAY6tzOvDGprcwAhVz7OBYjX4fAPklS8/e856QxfO19ss6oa26VJa38JWWdS2qOpDTe5Rh5AEyUJWdD4F5Zop1OYhtVuR6TJcXbwF+J8F5WWDwVk2XF15K8506TDN/XYuQAiemVEPAhMO8cU8bgQ6BFMpbfEJ4Z855KkuDOOlnYh/S/65wxPFJlxhiamlQxv/ae09YSM2N4K4/P+RD4vSp/agyvA1+S2Gsrgs21m2sxbrL2T+qaprUczWzfoveb93XDWkaM4U4+dxOTmbiXZEexFJLx/VhmE5vO8WfA/2IM55zD5O+PSeeY9Z4m6bunWRTpHEWYF+H/9p7DQNMYbue021MhsCopTftQvheXSOq8ayIMqUJINibjL2gS+iqeImJ86hqJ5w6ENtrbjX3by3H/WMBb73H73ev9ANo2Jcaubfpuz/ZauI3jDTrnPTx3uwK5PcZOE89dFwg2G+nCAlmRslvpcWBtVt96sqcEcXSBpm9OaouQynY8NUBEhK4duv/sB+a29Hl3ECc9+25mYHalYj6XGjJ6x2LrOe2koNkL5L4VeNuhnzsu/nQfYwAbNsgy4LmCt+f1ffQCFkG/UymUlSoPjOGXIRBFGCsKnqhyyXuuW0vhPcRIq9HgkaSUSlXFG8OCMXwmwmeSTJWbxlA2GqyVJSGE5McWI1djUm27agyHJXm3FcBfkVL9HsfIGrAGXFblgKaarSOq/JAE5n6oSR1zCTgmqUYMTYp9a8AVVfYZg8bIT/JrNATeiknMI3pPS4Sq2WQpRhYyo6OahB0WSBL6Z7xPfl2q3PCeG95zTYTxuuZwVTFvDJJr5SQEfpBVCz9tt7kiwjlrN1UdV+qaTl2zagyrxnCj2aQeGuK9RoP9meX8oCy5BVxaWcHHyEoIHCbJ6NsYueM9xwAtCu46x13nOEiaFD6RVE/0Zb6WY5LUMi+ThB9OkZiNNU2WDZUI3yMpZRpjOJXZz5PGMCHCXeDGSwJvAB3nEGCfCPtENlMOx51DypJxY5hSZcgkNdHzwD1jWHKO1RB421rGSAIcp5wjxIgJARMCK6qoMZw2hrFOh/kQeLS+zmSMzDvHJyThHeccD0VYyeO9oMqBDC6axiDOoWXJUFFwu9nkSFFgypIp57gjwqIxDJcla8Cq99zK9hBk5mlNlTVV3oyRSWMYjZET+R46kYWB9pHSgm9mRmmiqjZTCheLglqTx59XZb3TYbmuGQW8tYw5hwFiXXPLe650OjzW5KU4q8pbIrQkGdofBia9ZzKDrnmSt9uPrMWrUoeAt5Yl56hjUpBdzs/XQVKacluVd1UpvKfwybg+VhWrwClrKSWl5DZFWJAkKtCJkYW84PJuVo9sGMP/pspMCMyEQBM4BnwUI39HEuSZEqEhwm1VzqiyKikF+CeaUpLFe2rvWY+RNWMoms30spaLpMWpj+qaS5JqZcdi5KYmC4PHwM0QeAwMe88XpDrLe86x1miw1mgw5xxnGw3GgQvAzfz9Ny5JrfeNGJNVgaZa0oIkAvMkRh4BG6lkTRKruK8oGBkZYXpkhPmhISYzq/oq/sDxNJOAvYKovb76xDOzb88LvH2Lvu/Y5l5jTymEu2yz4yR27+exa2rlwEPo04kuPP0BNn/dMZ2uz+/bzmljst53AWHr78+ldkm7Xj2xLXXyKUDOwJRIdgY/A9MpB0Tf7XvOZyDj1qfPffvZ9XffY23pj2559Y2dzk/7p8XumDrZp/1+v2+/Hs/w3fGS4zsF4F7Fq3gVr+JVvIpX8Spexat4Fa/i/8/xnQJwBviZKn/uHPPAgrWsGYOLkYNZbW/Oe1azH9LDGFl1jlFrWc1CBCdVORYCbZLseiMko+06BC4C76pSaUqFbABfk1IlTwIPJYmIdDIDc8FafpfTHa9IUoA7GCO3VbkrwogId4BzwBmSOMe+/HdHk3jDFVWuqHLPJG+7uyTWqcw1S7YokkdTTq9sx0grBCat5asYmcksY+UclXN457gFHGi1aHiPrSqWM1t2sKpYNpcUEe4AACAASURBVIYzjQavFwWfxshpIITAIvCGtVxoNLjQaPC+CIc6HT7pdHjiHFaEm97jRRIDEQKVKlPOEWPkniqFtcnAutPBqmJVuQuckW/EKN7JDNayKhojJ0n1TCLCa6QFkWkR3lPl74HbqtzWpPS5KsIj4DVVgvcMv+D7rTs2WJZRaxm1lkXnmLOWe4ALAQOMq+JjZLyquAIcspaxGLHGcAP4Iq907jOGq6o8ymmKWlXMdTosOsflGNnnPZc6HVqZDT1iLR1rmbGWybLkpiqTxlA5R6nKVH5dMYZ3RZgpCka8574Is3VN6RyTxqT+qCIh8H4WWbkuqe7wUYz80Bh+aJIy623veSzCSlUxGgJlXdNUTbVmpHTNdoz8fQiMhkAdI5O5HrAT42bbDWOYzul7dQicipEp7ymc40+AmaoihsBJa9nnHGecY4GkDPlXIfBXITBiLXPOsSzCZVU+lGRG/ifGUGdmqS1J1GYmK6c+FiEYw2q2c4gkIZQDxhCN4Rfecz0E1DkaJonOjFvLnDE8JKnJPiTVs1YivBnCpvDILVXWSQqj48DXIty1NhmIx8hDVQ5psjf5mCSIdMA5rhrDcE6XallLK/vqTVnLZKvFEWs5VJb8NkY0p1Y2RHizLClEOE2qBf2i0+EtY9gP1MPD1MPDLA4PE4eG+LrZxOeaxQcxsgwciZE5Uk3kHeCStdzSZE5+QJPFSTu/bjnHjLUsAGedY7muOaXJM1Nz3d6r+A7EXlmdZ2nzeaRP7tT+XrZ72v4/LSPXb5un3e9FrN7vkYn7Zvt8sb6lgMnOdT0b7Mfe2eGdGKhtv7MDi6nbPx+UatcriNHb/q4M5gA27qlTDfuct+yy3VMLgezGGMKO7fdutxf2rW+/Ntt7NnZ4pxjIYPakT/YKtPRu37+twX3tW/+226m9oBry71QNXCMEPhVhMkZGigJTVQyLcMVaTucarlZds14UPPGeKWt5kCcv07Bpdk2MzALnrWUpRs6q0raWQ9ZyVxVi5E9IBuBTpDqsWeA1EeZIE3mAs5qyp9dzvUgtwkPVTWBxQJVrIvwNcILkYVbnieGUMTwQ4VTe9qsYec8YPiYBmDbJ5LdjkieVE+FWXdOyFrwnqHLIGI6GwF39xmT4dWtxIgyHAEXBrRh5T4TrIlxuNjkQI06EpVYLqooHdY14T2ktXwNlFkV4pyi4C0x0OhzpdLgF3A6BCyGgIlypKo43GpQivFaWRO95QEpzlapiPZ/XbRHGSRPdX2tKjzwKzGhKAxwlKVPeyUp8RZ5kLohwRHWzBuBzUq3TWRKAfrMo8M69NCPvVghYkkgNJDXRN5yjEwILqjwIgU9iJITASWMIIlzynn2kif4TVWIIrBqTpPCN2ayDeiQpR384Rt4tS6IxnI0RU9f8gLQ4MKrKmjGMiHC82eRWu82MMTyO3/hzHbXJkP6DoSHuxciE9zSc4xIJ/LZIPoczuebzOFDHyAkRPomRB7k/JWnB4YucnnsFmFflPPBb7ylFuCnCQU3iCY9VaZBS8t4Gvsr34qgxDBvDnVz7dTpGZmPkXlFgSGmCj/N9vFH/eFuV9aJgCTie0/aaqslHT1MdpagiMRJEOJDP/YGmusllY1gX4WEIzMAWwZsNG42VGCEDlQP5WWvmFEgV4WyM/EqEB6o4Vd5WZdEYHuUv4XGSIMp9TWIvZ0QoY+SeMbRjZJxUz/k6SQDJWksLeAu4LEKzLLmXz204i78cEOG2Mbw5PEw7BG53Olhg1jkOiTCZr4EVYZ8x3Miqs8dzTdS5ouDX2Wpi1hiaITDZ6bA/RtYzEHxNk42HNYZ7qrypym9EOKPKn+fn7DdAo9nkXgjsC4E5EZqrqxysayTXJL6KP3D0qYXbmGCL7FBPlTZ8bt14rumTzwqqnjW6/rc81Tb93tuDH9pmnVZvHdyzxi7771U85WlSJ/ckljN457793V6zRt96uLTtVsGS3lq4/vtAr6XA1s/YZjXe777eNpYbm/TWvnX1YWA9XNf+W0VMetrufq/fsXeL7u32YH+wbZ9eILgX8NYXOPZ73gf2els/vwHdOhC0DWp/N+C/5Tibn23f57mk476A2JWBE5H/UUTmRORi13uTIvLvReRy/jmR3xcR+e9E5IqIfCoi33uena3Lkra1mOFhTjQajBQFo87xgXOMxchUCIzFyKF2m3FJSnJHRFiua846hwUsWUTEez6tKqZCgCzacIbEtB0F7mQgt0JizlyelE9Zy4wIMyL8MgO8mcw0rJFEUYZNkv2eBEpNTNt1SXU2vyPVoSxkUHgxvxBh2VreMIZChBM+mYnP1TWNGGmGQMt7ZjudJAuuSfnwU1U6xnAhv4ZiZL8qZafDZIy0qopfqTKrii0KgnM0mk1iXbNfU03heKvF/qLgfLPJgTyZvNnpEIAl57jtPc1Oh/fqmlqVRxnMIIKxliFVFpxjwiR/vpa1vO0cbzvHfhKAOa6KlyRMMgE8luSF9ZEma4YxkpDLPVJ9kVPlM6ChyYZgnyYLhMskcZp7RbFpYvwyonaOjrUMGcOQScqOc1k19EmMrFcV78bI8XxtD8TIsXytV7xnIQSO5bHwISSj6BhZzSzJeFlyPkbKEBjyngVVblvL55qMzmedY9kYJsuSjgiHGw3u1DVNSbWBHljwnhVj+O3iIk9IvmSLuVburew7d8J7PlhfZyjXfbZF+Adj2G9t8vzKjN+NGFkRYVlSTVbHGO6qspYZ2P3G0LKWJzGZax+QJI2/7D1jJOPz8RCYiZG7WRTjVozJEy8ERqqKh1ldclkTA/7rGNnvHAdj5LxzjFnLmLU8cg7xnmFjmIiRKyQxjl9n4PiQBPI8qR5zKoO9G3nBYMY5ZpzjVFkyQqqPOwaMOEflPeeBhzGpWTZiZJG02PIOMB0CXhNr31RNYJLEpCPCCeBEjHyeFzfeMoYjJHuSQpX3Namw7guB+7nN0hhm6pqZuk4iSMbwW+950mjwydoalSZGvXCORoxc01THp3UNdU0jL26oMZt1gv/X0lISdXKOd4eGWAiBL73npvd8XdcMk8DiOsk776gqd2PkXIxcB34eIz+PSel2wnsKEW4B3282qVstlp/z6un/l+KP6X/kwFB9cfUc3e3udoxnAW8vqu8vst2XES/ymg485M7H22QjNibdsWvSPaC/uzJxezzFHT3MvmUMZJB2AVt7BmB7AW/f5pz67DvYUmCXfvT0c9B7fcdsD+ew67XTrX3a0fetX/+eArw9tZVAv3hB7BvsLYXy3wD/oue9/wb4uaqeBX6e/wb4j0kkyVngvwT+++fTzRQ+BE55T9tabFGwHiOfhcCDquJeCBywFmstc9bSAB6rYr3nqioXvWd/jOyPkUuqvF4U/BPn6BQFF0PgoSqXVRGTbAUqEtPjVVmylnuq7M/CIxugYlqVlgj3VVmMkQkRjlvLY9KE9haJhRvNAGWSJNYRSQBmhARaxkX4J9ayosrDEPi43eaJMaypMh4jTe9ZEqEpwk+N4X5ds0iadB4XwcXIvCS1uaBKI0Yuq/JVjBxyjuOqnGo26eQUNrLcuHrPKWDZWg5WFXfqGrxPL00CGfskGSR3VPkCWK5ryhgZNYa5Todl72kD73vPeF1zv6qYtpbZTofZTgebQdsvSZPaI6rcUWVYk1H6G5JSTVvAVeBNUoraI03m3x1VOprS0faTBSqAq97zMhO6FlWZ9j6ZtKtystnkgCYDeBuT+MwnMVlAtEJIgjeaGKMjmlQgx4HDMXIvRt4FfuAcP3AODYFPOh3uxsgTVUpVfiiChMBj7/lxTpcrvOfJ+jqNuqaqaw4DQ1XFiCojqiyL8I4xECNvqfIkJvXIPw2Ben2dAzHiQ+AXGejdqGsaJNGLURECyWbAh8DVEJgmpQ1PAt/PbNrRzEwtxMhloLaWdUlql/eyVcfp/BqTlPK6GAIlCWR+CDyOkVHvmfKeByGgqnSs5WwGu+NFgZEkrW+zgM7hoqAZIwcl2RvM54WROzEiqsyIMExKveyEwL8kse4tY1jxnhXvuVnXrIgwZgxL1jIVIyPGcC//vpaVbRdDYEyV1RB4TZV2ZsI3UjEvAjfy8/g70gLPz0S4rorLY35MhF+IJF86VSpjmBLhE+c4YS2hKAhFASFwNwTeco4qBGKjwUMRaudoOYcWBY/qGhMj76rSipFQ18xVFWfqmrv5dVqEnzjH3U6H366uclSEPzWGs8bwn4jQsZa/AQ45R1uE/ZnVvWYMb1mLliValnhr+cf8nTUCfLy6SszX71UMjH/DH8n/yL7xhwTf39Z77GX0fadjDAKcve8POs+X1f++wGjnY79Q4ZKdD9x3orx1m/679qbC7Spmsm1/tgGAzX26XwP3HwBKutvv14d+bBU9fRkELAb1qbfP/V6D9ul3nH7b7tL/wSqUTw/cnjr69K/7936eet2xF/D21F16yc/UrgBOVf+GVArSHf8p8G/z7/8W+M+63v+fNMU/APtE5NDz6mzhHNEYrgJza2vMi+Cs5by1HC4K7oSQakr4xiD3C1XOZtPaZU1KdU6ENVUux0hVVbREuCPCSIzMxchFVYIqURVEmA+BDzJQKo3ho/z6xBg6qhzWVMfmgdnMSGieEK+I0IqRQpXfklbB50W4QAJ0tQh1ZieKEBhW5ZQxLGpirFSES5kVWdBUtzKWWYpOBglrJBnzRozUIvw9yUvtmPcsxMjtEDgeI7eBW5BMgusazXL0+4HhZpOxsmS10WC10WBUkhJfndOvloxhWJUnIkxlZcUTMfKwqjgB3AGmrGXCGIa9Z78x7DeGTlEwJsLPSIbLMyQVQ1Hln5Nqkp6QzK0tSZHyp6QJcFOTDcMicI/kpfdAhBs57Ws8p+q9jGhKMhRv5teVToeFnK40aS1zpNrFa3XNWRJoGyLVxV0jgc9FTazriCqLGUj9wnv2q/IfZRVQ6pr7uT7rsCqnvOevOx2mVVkqS/aZJN9vVJlRTZ5jIRBD4D2SX10RAp+FwIwx3I1JHVSBKkZuZabpRAi8awytDBgXQtgEp0ve82ekdMthVVyuiTqqyfKhQ1o8KEjy9RuM3ISkNMSV/LoJzNU1J+uaa1XFwXz9fiLJN7CTmb8gwoT3yb7DWoaBNWM222mEAPmZrTOjNxNTLagj1ao2M7C74z0rqvxavrHqWCWld04Dy40GDzN7u1YUjAKtGDkjSenyDQBV7sWYmGXSvXjemM0auLPAmDEcdY4TkpRU11T5p8BNVVqqGOD7IuxX5Sd53CGlVl5UpQW0gFP5OSUE3mw2adc171jLz7znmAhzMfITa7llDF8aQ4vEtF71ntmqoiClIJ9R5WFVMRQCnaricafD1RAYBW5YmxRvRbimynxdsxQjB4zhtHPct5YLZcmFsmTCGE4XBUdixHrPlConjaH8Q4KAP/L4Y/of2adzz7e9PGF+pnqWQWDoabZ/UfEy+9Ft6r05ydT+r6eJ79oz+jQT5t1ObVfQ1mc8dQe2ZxcwN0gdc/N4Xe/1BTk7tt2z3aC+7SV2Or8+xxsI0NjhvLZsvzPA7W2736vfdntRwd2RfdulL88E3nSP9W8vMJ61Bm5GVe/l3++T5uUAR0iaHxtxJ793j+cQ6+02UlWU6+vcqSr2q9IQ4bMYGXWOU6SV+dFOh6siPAmB14yhrcoocE1Sou/3RBg1BjUGV9c8EWFSBEeS5w6kOiBR5fckj6jlXNvSBOZyO+dIsvDrqvwYuJEn7VaSxHwhkmp7VJkmpWU9EOEsyYbAqHIoT+zmjeEW8C+N4R+B+RCIxnBMhN/HyOO8zx1jeCcEboXAjLUsZ8GC2xnMnDaGjgj/6D3kdLeDwJwmOwQDrJUlxnsOlCUrITDrPfMiDFu7WVM0YS2XOx1GjMGFwJ/GyK08DstZQOQ24Lznr0NgOk+4O8bQKUsmsrH4+ZjELCDVVTkS6zibj1OpUonwkAR25lS5DlxS5Ryp9g8SkzKhSRyiBqbLkviSLAQgpUIuWsv+XHtSqPKR97xjLTFGDjvHaBbMWNDEyC6S7BKGSPdlk1QP1QTuhMDRXAe1EAJOBG8th0S4URQcCIFZaznYaDDebvP/VBVvlSUzGTTaEHiQx2woi0vc8p4KuBAjCyHQKQpCjAyLcM97fliWfB0j68DHqgypsqpZeEWV+fwl5r3nKjAigrU2CZSo8hci/FiV8yIMibAqwuV8/xakWtCTxlDl/lzIYzEpgjHJCHw/aRHBOcdsp4OzljeA69byblHw+8zcjRXF5rU/ZAzXMoirST5lFRCNQYDJGJmzlqEQKEhplD8FbhrDbVXey+38jTGM1jXnGw0+d47gHAvNJnW7ze9UuWAMS8ZgY2SKVDf4INuL3IqRx/na/1RTHeuiKsPW8kZM9iPrpBqkAPye9MXXMIZfxcgF4Koq7xvD/WYTn9taqioOOccvvefP8/NTh4ApCiQE3lNNrK0xTDrHIxGa1nIqRhabTXwe/xVjGKprxFqG8sJPdI7LJIZdMzD/ibXMh8CTuuZqjMxby4fG8Lvczv34/7L3Zk92XVl632/tfc69N2cgJ8wzCJLgzGIVq7qruqpa3ZLa3VaHox8UdoStcNjhB/vJr3ryo/8DW/aL9WSFQrbDclsOydGW1d01sopFEhwxD4kxM5Fz3uHsvZYf1s4sFgsgAAKcyrkibhDMvHnGfe7d3/7W933KTK9HbrXIMXIzZ1oi7NrRvz1qfb7fkfoQmXCPOqG/1wToQUu8vzGJ/di/vw7M2732KY+g8frk+z+uhbvHtu6rS3tY8Pgox/aAehym4LG0cL+9sd84r3tpyT5Z99XCcY9rfJ9tPNoxbu34Id73EPv6Ld3fx372qeDtcR6Je53Dx473sfb7iMD7YcDRvY1mHuJYtt/7MfbtftvfqocFbx/7TPttoHufP/oc2yfhCbhQmn8SPPLQEpH/QkR+ISK/WFpaeqi/6ZT/vpozx8xY6Pe5ZcZYVbFpxllzbdhVM/aKcLywXVNALwSO4Rq3XgjkqmJQ1/SCO+8NmoY+bnSQRbghQsT1WH3cvGLdjHVVxsprTzEQ2SPCm+IBwbvLh0eNT4bWCgOjZlwBvoEbIFxWD/zdYgXVvL3wV2Xlf9yMQ6rU4i1svZw5HgLPivCTwuht5IzlTKXKfnMm8C38mTxaVazHyBV1p8pY1xyra9qtFt1+nwbY6PeZTYk9ZoymxGoBczdS4mfLy0yqejB6SlzCAectK4YvZszmzJHCECwDKynxfIxM9noeZI5P4DeB90RYx1spVQQLgWMiRDNeUSXixiB7RYgiVCFwVdyV83q572+Jt6XuF+GllFh91EH3GKW4To2qgqqiEuE7VcVqu02/gKCAA9RF8yywA+YarBQ8y24zBHbVNW+HwHKM7AP2AcNlMWHUjMvBzTI67TadnLmRM3vrmlMiXM+ZuyHwsxi5FCOXyvVJhR1MqhwMgbrV4pwqk4MBUzhb1gNu5EyTM3ubhudV2S/CN4BYwKaqoqr08dlmwB02J81NPP6AXxuPbJi3uU6XsbdeWgcXCtC5W9jpLMLPxVuLY4w8H9xhdQM4VNfsqSpCCIyJ8DYOys7mzHzToCmhKfGhKrtxMDQWAi+Ku5omwMp1f1qE2GoxIcIPC3P3RzjrNldeLxWGeG4wYKyqONTt0h8M6OMGMOdEWA8BVWVXaXn8Zs7sw9nhgyIcFOFuae2cEOGyKmeAF0LgKK7dFDzA/rwZ/ew5f3O4OdHuEPhhVbHcNCw3Dddj5C1VJmNkXpWhumaj02FJhB/nTBbhl+VeXFAP3N4TI2fqmo2UyOpB61fMuFxVLKiyJsJyjMwW1p6c2Z8zF1T526bByticBfaqcr1pmC6voZSYqCpm65oowr52m1FVOp/zF9Hvcj2J78iB9T6HI4PtvuD73d4H/f5x6n6Tnq8ik/Q4x/SkzudhtvNVvHY8IROIRwQST9x44j6M073qYdiqT9vuo4KoB7FYj7zdB/z83m2fn868PbSe7CHO9b7vf9Tr/KBtb9XjLkh9TvVZAdztrbaP8t875efXccyzVQf59fz7N8rM/gcze83MXtu9e/fD7bXTwWLk/ZSY6XQ4OTTESyHQV2U2Z8ZCYCDCydFRdheb96Pm4coRGBIPCh6LkRgC1u/TiHDBjOPgTn94q+VBc6vwcaCjyi0Rxgv7caq8ruAtUD8pgGsC+MCMb5rHCfxAhMY84HsDB4eXgMkQOBYjT4uwEAILIbAkwkZpT+uK0BXhIn6DhgpTcykEghmv1jVrVUUVAvuBTkrb7WYzImiZXO8S4RsiXFdltd/n4mDAkcGAthmvlra6aznTVUXE3fl6OMCcGRlhUoRuv0+rabiryrwIp2NkkDM/C4Egwi+AwWDAH5ZJ4c+bhhXxkO5ahFt4y+AzuKbwdRH2Ac+JxyQEEe6KOxoGM1rAGVVWy2Q1lpeJkEU4IsKiGf/C7AvNwBgS4e0QtsFSt6pYN+OIGUfFWwJvmjEuwrIZKyLbYe6HQ+BQXfN6VXFdhGdaLU6EwJkYORMjC2UlfTlndg8G3voYAp0YIWc6KXE4BGZCYFWEEzEyJsLLuDNqKNduKSVn0lLiiLnWsAZ2qXIKdzWtzNsKP0yJ4ZS4VgBYxM01WoUpW8SNZ9Zy5npKLKbEHRyQi3ngdxChJa49u5AzoWk4LcJIea3iTPYk8O9EsBiZx4Pdt4xRUOWN8sF/pFyHfVXlIfHltU+VVtMwjru5Lotw07zNMQEbIfCuGXdzpo/TG/PiOtZF1e32mQ9z5moIXAea9XXONA3tlFgpQPsl82iHXgiYGQNV3irP0m3V7diHYTNOqnLHjCN4O+V7OM2CGe+ZsUuVWVVGQuBYCDRVxWRVoe02PwMOtdscareZxdten0kJQmC9rrmaErHT4U+Hh+nFyNN1zVxVMdpqcTdGQomUiHjb8nSMtHKmOxggqljTsJoSQ6rsVtc9LoowCIGXQ2BdFcPbvdWMJgTWcC3fFB4r8ra6028rBKYmJrAdAPeo9US/I1vSuddb7l8Pmsh/FlD2OEPgKwosfqse9Ti/6PP6qoM4+1gb3Scm7Pe3wv8UBuQzLX18tr95KIBxT2bIfvP3j3Jcn7g+D/U3PFzb4adGDzxEfVpr5W+/98Hg7YnWJ7f/CJ9Nn8a+3bO+ouANPjuA+5fAPyr//kfA//6xn/8nxWnr28DKx9pIHruafp/5lNyWvdtlyIzhlMg5s9FqsRQCvaEhULdEr4sm7poI460WvbqmV9csFve96yEwb25oshkjNwvrNoprslIIHASeEjcz2SztUbW5w1wftz1/Bmfo3jfjm7iD5QcinC9MwTXxVsbncb1OhbcG3hBhOmemc2YlZ/aqOxJeMGMqRp4S4WqMzIbA3qqClFgoIDKHgITADeCjVotd4oYjY6oMh0Ab6BeTiOXBgH7TkJuGd3MmqXKr1eJAVbGn03F9VM6uByzmCQdUWRkMmEiJRrwNsANkVaoQ+J4IKyFwpExub5txUZVqMKApE9+3zOiLsATcKsBtE5AQeNOMm8AruKtkVQBPH2czfj94vt5rIrwmwnlVOsAu8RyyA0DofU6r0veoJgT2bG7yCzN+YW5WMRoC8ylxI2e0sE2L4kYi58s5TQbPHdMY+ZvgTqUt3L7fCjA9KcJloA7uAtkaDBjp90lNwwEzWlXFRyKYKodECMVso1Ill/1m8fbCGzmzmBLrVcWkCJdUqcwYUWW6XMPFGLEYeS8Eogjdoq3aX157y7gfxXV93xRhlyrd4tj6lAi3Q+BAOd+LZaHgpBm9wsatq3p/tgg9VabE9XFd3MxEzejmzIoqUzkz0u/T7veZSolZ89bo61ocLHs9ls0NPObMuBwj+3G92vEQ2IODxEHOnIyRXTkzlTNdM46EsK0zrcxIObMXGDfjFeBY0QzuaxqyuhlNXRwgr8TIYeAVESQEZsoCSU+ED0X4lrh29UTO/LGV9mngdVWSGRfwcbqnXM8bqnzQ73MkJa50u1zpdrGceb2quNlqcT0lbvf7/MXQEJ2q4q1ul8Wc+YkIB2PkdAh0Ckt6QpUhES6FwKUQaJtxIGcmmobfN2NYleXBgA1VjhTWshUjLVW6BbCn4Ll0XaAdI+0Sq0Cr5c65qmwCI03D+tdlAv7VqS/lOxJ4OPD2GHVvN76P/exhJjxPmH0TtXu+fifr6/YsfuI+PAyIu29tM0D3b5G71/jcBjP28fyuT/zuE+99FCbrfvu8/zE+JGC7z98+Sj0QxH3a/j5t/58BCN6z7BOvh6wH6nCfxHX6in+GPEyMwP8M/AR4WkTmROQ/A/5b4I9F5BzwR+X/Af4Vnpd7Hvgfgf/ySR5sjTNiy1XFcM6sbW7yV6o81WqxbzAgVxUhJa7kzIlibLIUI/2qwqqK0Xab0Xab2apy2/Om4XUR7pQ2qt3l4PfibWktEa6GwB0RnsY1Lw3ws/I6ibfADYnwtLkT4Dn16IGjhZ2SEDzzSoR/Le7K1xOhmzMTZtzCV+7/vrl75AtFb9TNGQUODAa01YPKx4HhnFHx+IIA3CiM2GrR79wFema8nxJPq3IgZ54LgU1VDgKHVDFVNrtd1lNivt+njzsFPm9GXF8nrq/z9mDAmOo2G4i4bnA9RmcWiq5nVYSq1dpuOd1XVdxOyXt/1Y1ZzIxeuaZrIWzr8c6LcFVkuy37Mm5GMYzrpEZFmCtM0qS4k2fAQUajymjnEVelH6PU3Cnx5ZR4OSWCKmtNs83UfpAzB/H7vRoCs1XFaowMF/v/m6qMxciMmbek4WzHFJ4RdzwEzpfrhSqtlFhKCatrkiqHqoqxEPhQlWYw4OUQ+CkgKTGbM7M5M15cK+djZDRn1qqKA+Y5azeAD4DbKTGiyoQIw6oQIxsx0omRyyFwuTCrF3Fa4KUQ+AC3zZ8AGjP+b1zPeTUl+qqei2jGXXFt43ERjotwQIR+zjxVwNK1AsCyKhtlHD3upQAAIABJREFUEeR6GR8xRi6X7YamYU+3y1h5kTMnmoZcNH4vA8TIGLAmzlxP4iy35sycCBeAE7jecgAMgMPA8Zy5OhjQ7vXQwYAfNQ0vDga8ORjAYOBxBCnxphl7gBVxM5Q/FNfD3Y4eVh9xzevviZvavFdYyV34Z8iW1f85Vd7Ombs5c1aVV0PgLDDZajHZarEmwj+PkeGRERIwnhILZvxqY4PJ4WEsRsZbLY7WNR/kzF1V0mDAcq/HctMwkTMTOfN2zoyGwHRVcTYE14GEQEfcCGUVGI2R91st9lcVmzgLfhlflBkrzGw242K/T2y1OFHG3NnB4MtzrPsa1FfpO/KB9TtGpD4IqH0mIPc44PLj+7rnpL787HHvwwMnr48IqB+3nvA+Hjrva+v9D2Mf/6i/u9dxPMzf3ufnT4KF+qzbeKS/e+Tz+gQD+bD7etj3PuJ3z0M7YD5woeur/533QBcIM/sP7/Orv3OP9xrwXz3uQd232m325sxESiRVDlQVvbpmNkY2RfgTPBC7Lm2JI6qMtNtUMaIh0JSQ6mURps14WpW5AlCWVF3DghuKdEJgAv+Wnc2Zc3hr4R0zvisOOZbNmBNhVpVhPJy6wtm7UdyFTs3dJJdw05OxEKhV6ZnRLewSeH9NAm4Aw+ZxAkdDYF6EI6q8FyPPiHDHPL7gbrvNwZz5jhnnY9w+t04IpJyZxoHcAnBpMOC7VcXlumYU1zWtmRG6XcbqmlUznhOBnHmpXOozxWq+LcLtAp4sJWrgzRA4AfRUGTXjVko8I8KNGFlUZbScL/hEdpcZN0TIqqyHwDhuV/9HIqzmzChwVZVB2c91EV4S1/5slO38gRnv4BopROiLsPnkRtYDa8txcbn26PCjOXNbhAtNw+Gq4rB6SPXuGBk1jz64FQLruNPokBkjJSPtnCqHQmClbHs8RhaK6+RHqhwPgZm65lbTMJwzK2ZslOvabhpyu82HwK5+nwtVxVDZzp4Yvf01e4j1GfH201uqPBMja8CBuuZOaaV8o5hkrBV2rCkfaBoCoyGwmBJPmbdKnhHhNM6gnhK3xh/CGdQPU0LFsxDb5s6Y4NlsM+bOm3Vh8CZCYARv55wS13duMT/LuG50qTBEp8qz0cuZD0Xoq4IIx0Q4Z96+ejlnpmNkFGcOL+bMUZzp/pUZB9RNUQD2qPJuCPxJCPxIlR+oMoOzZhQm85q50copYCBubNQ1407OPFvMWc6HwMsxsgFcMjenGccdNm8CkyKcFTd6mcMdSSfNPEpEhJGUCKUtuhMj++qa10Lgnw4GPDs0xI/VA93XNzdpt9uM5cyHOTNjxu6ceSNn2qociJHb5Vo/W9puh6qKwWDAN9ttuk3DrZxZEW9T3hMjl5uGTXHtZLsYtBxrtbhd2leTecv39V6PkaEhRns9uiMjtEP4Ms22vtL1pX1H6kMYmXye9SWD+kcBZqKGPSBs+2tXZp/J2ORJLMY8rpHJvYw8Puv5PPJ+PqdtPGx4+j3NTrZ+9ils2OMCwN86j48fx6ds+3H2+yhtoZ/8/W+1cD4Kk/iIx/NVDep+UH1xNn5PoCQlPkqJUznzYYwMjY1R9/v8SpWYMy+YMQm8Z8YPQ2Cu32cab9GTsjoOcL1puKjKc3VNSzw7bb+4tuqAuKbnp6rsD4HXzPVFm/hE72kRzpbtNMCEKvPmgcI3cMv7CTPeFeFbwF+bcbQcw6virn09PA+uMuN82dauEFhVxWLkggh7U2LZjI4IN1WZCoFZYBk4b4b2+7Sqil5wY4etD46ZMhGeKJPNKgT+fRH+JgSONQ0aI72UGK8qhkJgs99nMUbmUmI5RqS4WbZDYBdwR5UDwHKMrKmbqpxWpQmBBXP910E8c29ElU6MrOAB3OCA8owqp0JguLjhWYy8aMa/M9cQHcXbMzfKNR03b1c9brY9sTxXmLpxYFq8bS/1el/YAN408/iEcl5jBcSEVourvR598/gKE6EqoOlAjPRxcD4bPfT6HPC0Ku+ZMVUm3xshcKKwscMxsibCUr/P6RC4njPj4o6P6zlTx0gsTMkzVcXFMjkHEBGmxbVnqh4kfhlfaBhWJRQQ1JTrPVUWEw6YcaO4F4KzbWrGoRB4y4yZqmI2JW4C+wogmyxs6ge4s+bNnMllUaJXzmsT16J9Q4SVnNlUd2o8Iq6P7BUnyNmm4Yoq34qRH4uwW5WbZtu6q1QWWE6a0QuBYZw1mhfhKTPPpcMDqk8W9jABL5pnOy6W7QxUqVT5q5T4oxh5J2c0RqaBI7ghSqsA2g4+9veau6RugWRwTWzAtW/Z3L1zBthrrjsFeMXcuOS4uDHKMD62f9I0fBDC9rj907rm560W/8vaGi+HwIoqz+bMpari9VaLD2LkTmEy+6q8Wa7P02XhpFuA4LwIB0Lg2uYmnapiLSUqc53uM3jY+UtNs+1+Opmzu+m226xVFceLo+sVVTrmrr376poswlPt9g4D97tQXxb79rBj5xHG2Gdpj9z6m4cCcp8DmNip36wnAa5+q+4Fjp5A3fdYH7C/hzrHhzjmJwUwHh6MfoaNPwrz9hnrCwNaXwP2Db5mAK4B9rdaNMCBqmI2Z860WmjODKtyNiWSCAdbLW73+6wCw03Da6pcare3g5+jKi+LByUv5szVVotTORPMmDW3CH8uBHo5bztf7se//06K8G/Lz15S5ap5e+DzwHs489YAqLIh3nZ4VpU9Ivw/ZhzAJ/8LOIAb22LgVBmJkQURXjGjqiqWcVfGCyLczpnhGN20QZVngXVVBuatfTNlIve3gwHfF7cjz2as4u6Nx3GQNQE8U9e8IcJJ1W2922RdM5TzNhAciLAiwhj+vB3PHnaeyzEvq/KUei7enHno91oI3DWjabe3Xev2Fiavo55R97Z5O915HLgdEzc6GRZh2IwzZRJ8U91RcW85nmEc4O3GbeL/Ts5c/oJiBFJKRDNWm4ap8rN3VOlUFXcKq9Y2N7u4OxhwLAT2xMhyYSwPiDtwYsZ6CKQYCTkzU67Rqiq/TIlUtF3rMbJLlffNmI6RSpUTwBtVxa4yRlfVDTxGxdlkgPdFWGkaZkKAGFk1t/zfFOGMGftxQLduRleVGTN39cTdGvVjq/l3VdlX9nE4Z34B7BFhpSySdEQI4q2863gr44IZe0oLKXhu3yiwWtjv75drdDQEJEbewsfWhzGSBgMWm4ZOYeUOmfF2Oa/JquIbqpwtzOGVAsR2hcDPRDioSix/1wO+ByziTO5IAbUAb+bMCeD7IfD/5sxB8bDwNwqLBrCrLKoo8Jp5eP1pMzbE9X7gzGKDs4XrOGjvmrEowivAr8q26qLjPFHMW06L8G+APwthmzkZtNscB3aPjvL2wgLHmoYTExOM58y/FeEfqHLBjBA8//JEzkzgC0K7Q6BVnoGBCJcGA45WFXerilulpfJgjKgZU+Ka37HgcSXSavF+SrxQPmfmyrV+JUbOmnGw3eaXZgyFwLf6fbLIF2oatFO/w/W7thjwMGBvBxA+cj0IND004/V5H8+96pOg7FGB5aM+Ip98/2c9zgfUo+jfPquByteFDXtgBpx+/itmXysAV1UV7VaLtXabQ3XNxVaLaTMkepDygZSYx1faqWtmivbnUghYStwtF3S8tFwuNg1jMfJSjNR1zTxwDjigyijuynYN188MA0cKuNuaxN/EJ68n8RXuGr+g+3GnvSyCmG2boHw7BN5Q5VUR5s3jB7Ymjh9WFd8TdzAcF+GNouvplf8X/Dlr4RqgOTP6TcNYXXM3Z7f8B/aJhyKfwdm6o3XNeZzV2hMjjXnWWle8ffF2SuwdGmIMH5CT5QNxETeFmARupcT1ch5zZkgIWIwMmfGuKscKiBtpGk53OiyZMV++pH8EvBg8mLyFA+AFXMM2qcpCuZ7ngDHcCfS4CB/i2sKtAGQr9+GbZTL9dl3TSYkvQgVXFVOLkbpmqEy8J8241DRM1TVjgwFdIMTIS8U8YzVnNoIHZS9RmFkRvhsCoQC4q+UaPSvCvAiHCnt3UxUN7hjYBfp1zbnswdzkzJ2cMRzQdlW5WLYzizOekyGwUlU0QL/bpRbhmBl3cG3mERG6pY034GBgSlwrBs5yWox8oMofmvFLMybK5H+s6KkEZ/HeUWUfviixKsJH6gYeAFOFhfy5Kn8EvC3eTpvx52W/eEj3kiqvi5v+dEV4Xz2o+9kyFi8C10Q4XFWsqvIuxX0TeBZ/DsWMsyIYbpizHzgVAv8X8M1yz55R5X3gtirjAGYcFm9zvlhVjJptt1LvpuS8FaA6ibdIA9ww4wNVXsBdZfviLb1tM/6FCK+ZcSRGbodAxl0rpnEmdEKEW02zPfEY7/eJIyPcaRr2jY5yW4SUEtbv8z0zfq7KcIwMl2O9BgyqimdVeTOE7UCxwyEwrMoYcKvfZ6qqGBdh0G5zp2k4IoLGyHfUYwcuVxV/Dtzp95mqa7bsgC6FwKQI86pIr8dkVTE3NMSk2W+wkDv1NavfIe3b45qTPFY75VcNiH3a8fyuAeX71f1AyOfExn1u9SRZrydx7g8Ftr6EMfbJ1tLP8tn2GMf9yXbOL+UalPpaATgpk9erMaJ1zd3CBuxuGlLODJqG3XXNSFXREtnOQBqUiWe7sFTTwFqvx+FOh7Mp0caBg+CW95eBodI6tRYC0+o5ZW/hwdQL5QNzWoSOGbdx1u1lET4wYwXPg1vGWxoXzPgGHvr9xyL8HI8SaMwdMgH6ZnyEm6KYCEdVuYG3dv0iZ34/BOZDYKKwGIspcSpGUs68mDPny3bUjPdLKxYiLDcNL1QV3ZxZDoEcI2OqPF3MEsZEOKDKBbwF7f0yGAeFLTybM0eAfs6IuO5sRYROziRgrKqocuYQhU3JmVN1zXoBXi8XsHw3Jb5RVWhhrNbxwPMjZvwKuIu3AE7iMQ6nRJDScgcOTrbcC1Or5REHX6CJSc6ZH6XEUGkxfT4E/r4IP+732cBZwT3ASoycKuxrypm2eOzAM8BSCMyDt0dWFe+WNlcz41CMnCmTdImRxX6fkaqibrWQEBjPmUMxsgn0BgPqEFg3oxHZ1nilnHmmrvkgRrqqHCg/f1fdwOYV4HzORBx4nCjX8zshcMaMxXI8d3Hd3kQIXFZlVtzh9KMy9g+qojGyFzhY2ih/bMbrhRVfKWNorLBbr+DB7IeAlRD46xB42YzNouUaE+E94EDO9EWYDYFpvG0WYMHc3fXnqsya8XxhwK6VMXoXB517imnHoDxXQyHwIj6eALr44spTZdJzNXoI+y317Lrvibcaq7q2E3EH2cvl+l0sx3NXhD/EjYm2jEKuifCMlTZaMz4w17xNx8i3c+a6CLvF3XBv5rz9BTJtxl/3emRVJlMi1TXP9fu8ocp8zswC/Ri5nRIvmrEYAlVh42ZD4PAWEFSPNfgwZxZy5rkYuVxV7FGlX9ccLI60H+GfVXdD4IoIvRh5djDgRgG5BsSRESQEXsqZiykx3elsR5ns1E7t1E59bvVVA8hPuD7J4j0Mq/eZdWRPsp7Evr6M4/0sjN/XpH0SvmYALoiwq+hmFvt9DsXIqggb5kYLI3XNSlUxad6COB0C4zFywYzVEDhQJqhnBwPG223GQ+BEq8Uwzgh0zDUjM/jixRDQL22Ku0V4QQQtK+wAPxfhWAhsmluIf4C3jEVc97QFVA4AV/CJXTsEXsfbr3oiHCnnNlZMLYYKezWJj701cXOWAdBW5XZppzsYPaR7uDAiY1vMkLjOKcYI5jb+l9Tt56dypi7AckWVVNcsAbGAzpgz41ttdCFwIyXaRb+2ZRwyHTxHK6mHP58w46II+8x1f9/HA8LrjwHKQWn7etcMFbdiv6PqUUQhMFbOeyu37E65jv3CxoEbQdzEdVX0+1xttZgtYOqLqF2qjMfIsbLPc1XFpabhAD52nqNM3FV5MQRu5cyLwE8LyLiD56z1UuJQVTGfM8+XbS+aG54cAyRGTufMlRjJQGswYC5GJASu5cz5koG4JyXEjGkRFraoejNumIvL2yIspsRJXC82LsKCCK+b8ZG4Wcy4GdfNM/V2FSYV3BU1imtCDdd05hDIIryEM38TeOvnoLBmz5WFjgVzPSjAL/G2ywvAggit8pz+OXicBZ7TdlKEJgQG6iHiA1V6MTJS7v2fi/CWKqdDYKUYtMyV/a+J8MMQOIebE3VVeUmEvhntnLkYAqe2nlfg90XYKx7GvR8YMWMoRk6mxPkQGBZvE71oxgY+vifMWfAtXeco8FO8RXKPCIfN9W43RahU2Y+DvFbOaFWxFiMB165WgwHrwF+UczuXEt8Lgb+ZmKDTNDTdLr9KiReAhZzZ6HQ8WFxdH3syRoZD4H0z2lXFXLlnu3Nmf0o8A5yra4aAY70ePRFGYqRf11wzY6SqOJwSI60WN1Rpej2u4O3cAKfMqMwIKdEX4XRVcT2l7S6AndqpndqpnfpYfVWZvvsc1+eiPdypL6V2ZA07tVM7tVM7tVM7tVM7tVM7tVNfk/paMXAGXOp2iTHyLBDGxuiurXFChCspsVlasJIIZ/p9XhLhXw4GzNY1B2PkYrHaX69rnsUzsVZHR7GcGUmJZ0Wwonu5iVvgdwuDMkxhUXBWDVwDtCLCIVyT9ifAuzgqbpXj/T7wRgiMF3bpgrkb5n689atfVtDXChvSEw+0vmmeL/Z982iC22bczplQVbxRNDyzOLN3IAQ6pcVpLATaTcO7qjxvxhpwqBgdLIpw24wXzFhptdgQ4e8CF2Nkf0qsA1fKSvxzIkyZ693+t5yxEDgOzJfjXy76rg9ipDLP8zpQ2LRF89Bl8MiBF83YrCoOmVGFwEbOCK4Zs9L6NRY8KPlASlzD88ZeEqEp23lLPOR7TIRJca3TRFVtt1h+3rUcAsc2N7lSGLixnJkXYU09Vy8BR1JiubA/YsbdquK4KpjRNiOqslnXTABBlfmy7RHxEOyquEpmVSaK0UdXlXbOtOqaBPywqriq6uHbhRn9drn3F0tbYlXuw52qYk2EQ1XFlBkfxUiv1WK+32coBFZE+F4I/ChnFoqTJHgOIiGwv7RNtkV4OgSGcyaronXNeAi8kRKnqopJVa7FyLwqz8mvtXT7VRkKgWFzV8OuCCfrmndUqeuaQ3jL8t66ZrFpaKvSN+M08KEIG+Xe/5sQ+IdVxfWcOVRVqLoLZKdpeCEEPsQ1hv2c2SMe2v28CHOqfFeVt8r1+W6JGLhbVSyZsVSYz1qEmRjphEAfeKqquGbGWM5MF/a+B9tunz+oKn5mxqQqI8D7ZhyuazbMsLrm5zlzSIQ3cuY/EGF3YcMvVBULMTKRM++Wz6ITo6PcrGv+LAR+PjrKWr/Pcl2zP0Y+2txktxkzMbK/3eZSzkhd895gwN9rtbginmEJrh+dripyShw144wql4E/K2NvtxkdM8+6rCoW1tc5JR4t8LeqDJfPoVjXXGm1CDkzOzxMJwSODAYMct5mVndqp3Zqp3Zqp3bqy62vFYAbqDI5Okp3Y4MlVdSM9uYmZ2JkrttlnxnPxMj1nHldhCvA3zNjbjBgIWd2bWngUqKuKk4AVzc2WC46kPdKy1i7vALwbTy0ewZYKnqhf1cmlkPi7o4fiLAPeMeMqoALwSeVP8W1ZUvAzQLGDuHtXLNmPPOxbY3HSDcEjqpyNQQOl1Yuw7Vx83ib45+I8GMzls04UVX8ylx/BbCgHjkgxWUvmHHXPItuMkbaZuSqYiJ4xtstVRYLKB4AL5Tj2Sg6o91m/EFds6mK4S2PdQF22YwfmvFOmaj3Cui8iuutAL4tQqoqCIEqe8jyHhFebrUYzZl3Q+B53AY9iLBWVUwA+3Pmqgh1AZS7RYgx0gqBo1XFzVaL+ewZcl9EtUW42GrxzPAw4Nq/3TlzJEbaxUhkAHzLjI/KRPmuCDO4mc0rBVDM4O1/r7TbtMq5bZixLsJTqsTg1v67QmAqBDbxNkNLCQXa7TYLqhxOiTwyQsx5G8Q+K24+0Sog8niM9EZG3MxHlVZVcTlGTnY6dMsxvmnGs8BSSoyUjLvpEDhnHrT9fAHOC+buoDEElnHN37eqCkSYbRrPHzQjFRMMgPkYaeEGG3W7zXLJLTsmbuqzgrcG3wGkrpkIgaWUONRqMRoj1wtYfr9oBxfrmpgSWT2KYzRGeiHQMuOoGU+nhInwnnpg+GppDT1dxnQ3Rs6J8N2cmasqngKWVVkG1quKZMaJEBiEwL4S+9CPkVg0tCPlOn+kSmi1qJoGEY8hqULghhm7Wi32DgYcrmsmzVjLmbWc3SUzBGww4GDRngHMbW7Sz5nO8DBPNw0aAuubm4ROh7/banE9Z5ZzpmfGszGyUgxJtp7rH5Tt9MUNkfaGgIrr8b6Faw4ngPerin9YVbyZkscDhMDNELgJ/LEql8u9nzGj3+uRY4TBwAPaR0bY9QU5vu7UTu3U17eqjebLPoSd2qn/39TX6lt5FJheXETW1mipcmtlhYPm7mhHRRhvGrpNw0jOjKry/RC4kjPHxLPdrpWJ3FQIrOIGAqeBWwUM/SBG3sXNATZDoMZ1WC+YsSLuINgR4U/s16YIQyEwJMJu8/DtIVw7t1m0QF1z57meKp2ix6liZAL4Xghsqbj2466Rb4qwN0aO4HbkdWHb+macDgGqiqtmfEOE9aJ/+7bINuM1K8JVM37QatE14ySuWdooYOBFES4U98Y9ZmDGgZwZ4DqlLee/d8pk/KkCzFII3AYOqzIeArdzZoSSjQccxAOOJ3Lm24VFAtf/NcHdQEdD4JS4rf2REGhC4DvBLdWDGSPBXfUOi9AKgT1m2yAnUIKVRVgzIw0N0fkCNXB3Y+TZ2VlGNzxavAme7XUFeBU4DK7fahpGRJjCgVAW2dYfHQXmU2K2aZjv97lWWJjNoSG+2TR8FAJ765psbowjIkQz+qos1DVP5cxQVbGrgMEmZ/6gqjhbtrMWAj8U4ZcpMabqWrVWiztmTBfANBECg6qiNmO+6LWWVTlRdHng7qPD4tlncyIcMmMdBwnr5pb7gi8WrJnrGkfMOBEjKyLkMoaOiXBFPNS6g4efX46R6yKMpsRuYCZ4QLSpckuEsariX6fE6ZSYK9d+jxnrZuSmYQnXpSHC8mDAyRB4G18A6Ivr8Q7GyGjRpk6pRwyAu0COmWsAN3HTl5EQmFGlFwIdM86GwDEzbomACE+rcgeYi5HdZSweCYGFlBgEN5I5XFWQM0+LsJQSnRA4lzPfCoFr5jrOuRi5AczWNddx51pwc8B+p8OtnJkLgafMmBgZgZR4O2dGcqYdIy3z+IQN3EV3sexvo5zbsCqXRZg0427RyVa4w6upstk0zBV2dLnXY6IA6U0zLgEj5Xm9jkdT7AqBJTPu1DWHh4bQlOi1dzi4r0OF1c0v+xC+8vWZnOue1L6/wH190XYMcX7lC97jTu3UV6O+DOuTrxWA6+ETUAWmqsoZuJzJwHAIaAgMRDgSI7UZyYwjVUVP3Jp9OwcOZ78u46YYh8pktR8CM+bBvJPBM8jO4Xbo+4oD35LZdr5DG88z21dW+xdC4GBZkW/jzMKpEDgLHDOjEyMmQhThsIizHOWYjuLZWyeKacqmCL9nxtUQOFYYkRwj0yUMexNYTokjOJholZX490U8p83c9W8JOCGe6bZRwNikCNdz5kg5zvdUOSLCddi2/x8W4ZmcuYJP6g4A3zHjZlnhn8LbR7MZlSrvlBy9W2asq2e+AdQ5o6pMlut1HWcJbqhu29KbGVGEmznzqqpPdkv72khp7ZoMHkVwNQSeiZGDIfD2F8gKjOfM1MIC8wUsDQHTdc1603A5RmgaXqlrFsuEuxJhud9nvADtPSLcxWMhWngm34vlGq2sr3OjqngmJdJgwIK5C2dKiU5dcy1nj8GIETGPgIiqHA6BN0rrKvgCxZVi7DMxGLA7RtZSQkRIZSGgDVQiLKoyJW5ok0X4kRkHy7lOlZ+tAkdT4qYIe1VZw50rl8XNbK6JcFSEGyGwD9hUZTSEbVAxX8bgJVWiGYs4UNit7pA6DlgxM4nqsQb7RbbH9PPlOVsyd18cF2E6Rqaril7OWM5cVMVy5lQBeftE2CjX4pQqiyHwfjme/WaEGJkJwV0sY2SQM7frmpNmXDVjJgRGc0bLvVoQoY0b/Rws13nBjNmq4sPCSt4OgYNV5QY9qrRKlERj7mSbxR1VJ1OiVuUfxMjfludsXwiMpMTAPEvxFlBXFcfEIxfarRb7gNviURArBXwe73T4KASOFtCdy3nPiKAp0a8qWuUzjpR4BbgkwqwZCY9IUFVOhLD9rAIM1zXtlNgMgZtmvCBCripWH+/x2akvsKzbe/CbdmqnPofaGXs7tVNfXH2tAFydM4dCQFstAq7VaYXAraKlWjW3xV/EV7YtZ1ClrYpVFbNlAnYuJZ4XD0BulcnLnBldcxvwGg/JXhZhU5Xx4o53CzglwtkClvaJZ2rdEWHCDFElxMhucYvyY1XFVREO4O2fW26ZWYShwiTlwiLNAzNF/9U3Yy+wKkJlxmYBdEMp0RT2bJ8IneC6sffNaJftvB4CYsZ7OKNWA++FQNuMQ+rBw7dyZn8InMG1etP4BHEIB3zgOVhngImcOWDGXvG2t83iKLmCB0IfM+NvRDhdWJpDIbAW43a72VaL3HFVfinCUZxJHQCtnFkLnnXWxpmNG8B0AXVTVcWgTHSXzVv6Dplnl0kIzC4usj49Ta/dJqVEdT9AlxI8BNirc6b5hF16q98nqnLt4kW+EQLjBcD1YqTV67FmxkzJgTvbNGDe8lqpMlkWEYZCoFJlt3g7YmXGsQKyKdfnqX6fZVUmzBgSD97eC+Rej74qh3CG1vC21lkRhou+zsp2qCrOqyLAIAQ2cL3mbnFXSgmBy8Bec6dKC66jGwJOloUDgF+Y8WzOXDFjFm+rMzzvpF9V9HPmo5yZAUIIPFPuyRowkjNr5drNAEsiNLjjZa/c54PieWZNYYQAgKQaAAAgAElEQVQCMBMjS2UMxfK+9XIv9gCLOTNeVTQ5082ZdVVeB95S5Ygqi+LuplVKrObM3hB4R5X9Ikh5xtshsBIj8wUQTomwLsIhVZZEmMDZSELgdIxEEVKMXMGB691yfZbwnLw9BdTuwkHmlCqDukZiZL8ZZ/DPkru4Ru2OuaPlTX79wdszjy/J5X5fA4ZUmcPB7lpK3MSfx/Pl3lcifNDv80phxQEui/AazpIeUqXd7zMPnl8XAldKp8CGucY3ivBUXdMCRnPe1vftzZnlMn6/FQJDMXIzRja7XeqRrad6p77SNdhpY9upL6l2xt5O7ZRXCJ97mPdXBsCFlIgiNGZIzlRmyOYmtrnJzJw3U1167z2Ym6MbI52yMj5fVewx4zwO6O4WkDEKYK79Wg2BfoycKvvaV1V8qMozItwy1211xMN/1/BJVbewXAeBzeAmBuPAhRg5tsUwVBW1CK0ymX4W1zfN4WYbY6p8OwQaVS6bMWW23Q6pBVg+XbZ1vuzrWmndulNATMCDg/cUQDkBfFAm3luM4tPA2a3tqDJS2kavxujtm01DV5WbqoyV9qqbZm7nj08yB/gkcqhsJxd2YRMHkhMFFLbK+UURFDdtmSwT/Q3gTs6sl+0BbIoHLp/FM+3awIYItbhhTEeEi2ZMhcB+M8+DKxPdVkosl+1E9WwuC4EBYBsbHP7H/5gwNcXczAyLe/ZwaPdu5nftYmxigrlOh4mhIfpVReh0fh3c2G47SEiJmDOxBIKTM2xusnT3LjObm0zOz3N9ZYWTKyvcXFjgO0tLXFhdZW/ZTj8llsw4tnV8OXO3APRobkGfzBiPkXbOtFPiHeAb4iHlR/EWWfBFgeHC0swXJiyDj93S6raOM9ARoKq4oMpwq8Vk0SYCHMdjJxozj5YQb3/s4u2nu1XZJ26SA4B6mHrbjF+YbdvtHxdvrZs2YwQI5tbyQ2bcUqUVAofKc6UirOCgO4lwM0bGyvFcVmXEjJfwiI4+hfkRYVaE3tbYM9fjzYqQKa0ITcNo+fAblOfrSr9PKwTWQ2A6Ru6U8bQUArMintOWM6dK+/O3qspDyst2embM5MwgZ2J5pvcWprEGDsTILXwxYywl2iEwnzNHY6Rnts10dkOg1zR0qmo7WmAkRlbLQkm/6OdOAnPZQ9cXcqZWZaicT7vcg9shsAR8OwSWRTBVhquKMTMWVNlvxqIqwyIczJmVGBkC/sKM8/rrnMRXy3WcCYENM3oxMiQelzAaAgdK2+ztcu5tERZi5I4quzod9hWw3MTIeEoMgGEzbsXIeq/H6b/8S66//DLLk5NMj42x0emQ6hrB8xmHRH5r8UNSwna0c1985fzg9+zUTj3pUgN2xt5O7dQXVbK9ev9Z/ljkvwb+c3zOdQb4T3G/jX+Gd2L9EviPzWxw340Ar87M2P/0wx+yZ22NSVVu9fvsW1mhGgxYXltjtbBLh0W4VjKJDJhX5Sl8otiYhxrvxVede7gupsZbnkbwVWVwRqEjwociHDXPXbtlxgRwDA+6vW3GXlXuiDAaI5fNOFpVrAOpTORmcBe9D1VpAQvAcIwQI/2cOSXi2hzAQuCAKqoKqlxSpWPGFj7fY+7Ud7VMuDZxN8cRVfaUv5k3NxY5UvbVVSWbMSXeIgm/DhCfLRqgBm9l2yvCCXFt2gUzuoW9aZfzmMOZgolyPCbCGN5Kea0wlccLuzkoLXEDHHR+JMKesq9WaSPdOp6b6sYdC+KGJHVhXY6Xe/NX5hqhY2ZcwwG4iDBRgMjW9ZkCbuDtrlttf/uBt0U4VbSEyYz9IXCnrmmVe9THgfZUGUP7yr1djZE6BAIesN5X5VDTsAzsVWXFjHEzlqqKXr9Pg4OPoXI8rcKcjAI9VSZwRnJZXO8lUtptcQZpHjhkxnX8YXkeZ1u2jnELvG8CKt5GGER4FzhdANU8ziIdN2/tGynX8Eo51+kYWTDXNXaDm6GcNuO2GRuFmWvhE+4KB3xvmDEZI40I0+V4LuEOq0dwA5VIyTAErpZ7MsCz727ESA/YZcZ6WVTY0i0OpURdFgnG8HblbgEvC2YcFMFEkDKWXhbhqsg2+I3leTUzVsWdIsdFWAyBo8AdVdoxcjlnTpixqsp1EV4AzsTISAjOapXjmVDPLqxx1m9ahIMh8KsyDtrlmq7HyGrOHMM/R66F4CxmOZ5cFhqOmmcg7hFhKUaei5F3yvjeD5ASyylxNGdul4Wplhm1KjfLMT1nxvtAv6p4QZULde0sbIwkEcYLwJuMkRvq7qOzKVHjCztburx1M/aEQCpOvOspsa+q6Ig7z05VFVVVuVNmcIOcczE6e5jS9r3fXT4fKuBAuRa3zRgNgXFgo92mpYrs2sXs0BCjY2N8ZMbo2Bih3eZOYelG65oUAu2hIayqaLpdZ3P7fRabhul/8k9+aWav8TteT+o7ciJO27eH/+xzPtqd2qmd2qmd+rLrp5t/yUpeeKBc9jMDOBE5APwtcNrMuiLyz4F/Bfx7wP9qZv9MRP574G0z++8+bVvP1bX9zcQEV4BjIXC2TOqmRVw3VtrWdqmyKq7xumTGRNHFnBPhWIxcNxfwb1nSi7lV+OEY2WXeugTeLnlEhKWcafwikMRt8ysRdqnypiqHgdWqYsbMHenKyv7eMpGbwyeX02aslUnzvhhZxR3yroTAaIwcrWsumZs/3G4aDuEsXMd+rTs6V3RB66oOOnNmXwiEnMEMTQkBOjlz2NwmHLPtdsvbBTAt4eHJEziA7YobuOzHDTdOq3JL3fZ+KwTwIHAbb7+aLeNhRbzNs4ezkieLIYOaO14GHGx1xVvX5nCArQW8bc1GVISBuLnCapm0f6jKjLjpRMcMDW5i0i5/NwVcKvd/K9ZgpEzoJ6ywW+ItgAE3kqmKvrCLA6JpMy7EyAlV9pbrDXDOjFb52Y3yvouqzJbr18VF5lvM123zEGfMQ9h7BSwNir7q6QJGTpjxnhkjZgyLcL2Mi/dwwHASb7UTYL0wNW+VYzolsh3ePo/P7tbL2DuKszRj6qHVYsZzIbBU2uyG9NdxBFus1nF/6FxnVlp3R8vYGMbjJIZxVmwF2C/eSji+NRbNeFmEt1WZxpntpMqF8u9VM14FLuKLGW1cv7nPXF+1FQq9YM4ILYeAFDB1B2+/3XJpPRzcun8cd+0cF+GyKgfNmTr4tTh4MgQPGcfBxU/K2B/HAV9j3mp8EuiJG96kMl7AFz3Gyr5ngRQjMzFyCUCcSW9E6MYI4gxzx9zt8Wmz7WfjTTN2izAWI3VKfCTCsbJYI2Z0U2Icb3fcFOGuqrdXqzJcjmWrGfGGeWvpUM5IcCOVxozLIv7ZECP7cOA8XNesizAJhMJsbT1noSxsTBWgRQHObREG6sZD62VRYtU8CqRdPh9umW2zlH2c7d7AF6cOiPBOWSh6NQRui7AHOCfCaHDn0X3luV/FF88AbuTMkLnG9yC+KHZLhFZKrk1eXPydB3BP8jtyIk7bt4f+9PM/6J3aqZ3aqZ36Uuun3f/zoQDc4/a3VMCQiDT43PAm8IfAf1R+/0+B/wb41C8ncIZmUoT3VZkUYV+MnFel3TS0yntCmfBfAU6WSfI5XLh/FTcy2Ys7QKq5Hm4T+LBpsI8xDLP4JDCXyfwYbq6xZbTwEbArBEbNmE+JlQIMJnNmE7hSJpZjIkix378IfAvX9SzH6MxRVRGBqzmzKkIdArOtFodUuZQSi4VZAWfoNoATpbVLcP3QpAgfqPLNMmmvRXi3gL/9wEppWdxiqgY445PxyacWrdItc0OJm4CaMVzOvy1u1PICvhScyrl1cPbhqBk/KeCkY54rdwvPmzsQIx184r0KXI6R8a3zKf9dNWeqbokzgIbn0l0OgZPmrV4HzfgAB5ADcZZwXARV5Wg5nnG89fIKDrqGVUkhIOU45/F4hr0xsiCe43favAWsbcavynYOijBXgFYbB0qdAr47ZewtmhHNyEDbnH00M66Zt9aCG5icUuUcbmhyrgDZmzgbNSLCeXPjiwlzV8kZcSOZi7hWcKi0OkkIjBSgcLJM6Kdw0Pd/mPF7RfP1FN76+k65x3cLMNsCA6Mi7DVjToRnzRm7XThwj+U8N0Q8e82MuyI8Bd6OGdwkBuBl4AIeobFm5q2QwIvA5XI/r+Iuk7/MmSNl/3M4eNsCXntCQGNECrgZUaVbxkBPhNdC4Ffm7pyrIrRzZgMYipHrZX/gLczBjCvmrqQ982yz1wrzerMAjZViXrSOg5OPyjO3tUhyQNw4aKJcjyTCj8rzr+bs6m4R0mDArLgT6u0YmRWhCoE3ynZaZp6ZlxIbZgynxCK+SLCBL2TcUGW9nPf3RFgqiz9r5prWLan/mvx/7L1JcGRplp333f854JhnIAKICMSckZGRQ2VVNWvoJtmmblHa0LihcUuZFr2TaSma1lpwoY22bS2TUSvJKJPEhYaWRHY1u7u6psyszMohIjLmABBAYJ4Bd///q8W5zxGU1FNlFpnK8mtWVpkZgefP3/vfwz3/Ofcc45o7j5OyIjtJ7qaDZt1Nl03k1tlfCpMAZuy2WsyYdVncm2YspMRykevmSxPTeQ54EJsD7fi8A7QB0wT6S2HWJY8lrsuyO6+75LLbwLiLOX8WOXvPTZLWKtbvTszXTZdCq35/mDESz+XPEeN+MSU2TQzqr1F9Ob8j3X/l8xS96lWvetWrr0D5X49Y+6UBnLsvm9l/iXq5Y+D/QBhgx91rf/clZGD4lx/LjImBATZcMshTd+7nzGxfHy9dGU8AT0vBAtQ8d1mCUwrmzsXTU55E83NskmEZYkqG3elUFfNxnGVk799nkjfumTEejEYLWcJbyCcXgQ9L4Q6wbLK/P40m5eeNBhdjDmYmJVqdDs8CZFpVcQXYbTQ4RfMkJWeqUniSMxuoETyIY03GeWz19XEQ80RVKfSXwtWqYrUULGdKSgyWwomZjE+qivulcDW+25HLqW68yA3vMK7bpBlbObMWLMBWgKQRd66Y3O+GzdQgoqbtMfA+6jpOXe6Jo/G/Y9dMX8eMFXduBUv0IzMu+5k5zB008/NxLJK6IbySs4LMS2E5wOABAjm7VcWQGf19fexHs/ckXC6vuOSfp319tN0ZSIklU95aQg3jqmnGbs+MN4GP3ZmL5mfAnW+b8XmRwcV2gP2jAMITwKI7a6ZZtn5gK2emU2KSM6C8V4o2BeIYA6aoiAN3HiVl5H0jGuyhAC0t4DBYrVYwF6Dw9KFo7PfdWXHnjQCNt13ywTHUzI/Fd9wHLqbECGcB00sudvR5XOvh2Hi4HnOD7fjzB+48NTE8z91ZTIlN5FYKcDfOpzZkGUEvit0A/gTQXol1/TIl+k0um7MIkIIC5n+ANlvGERC74s5Pc2bGjBLXoI2YWhoNdkyOlxfMuB/XeqwUrgd4/7YZ91zs4gel8DuEgUgAkwroN9N7w8R+JTubD70c74YXKfHMjOtxXSzeJdsulpiUOI44kgzalIk11AjmP8czO5QSVVzbR8TcZ6gAcrw3EmL8hpGtfw3gFs0wYNq1mXTNnZQSoy6WrGMyPRpDAGzHna2cmQL2q4rZOM4x8DhnrgVoHE1JRkMB5Op3zmsIuK0BN11ziUvujMU9G8yZUTMapVBy5mFsdNRy0nW02dYMwDtmMkZZB25XFUvxHhptNFhBmzLFnZWqkqICurEOX/f6Un9HcrYp1qte9apXvfr61l/3Tf9LAzgzmwT+AfrdvgP8c+A//Bv8/O8BvwewUFW8NKMfGSbkUjhfSxFT6jYFp80m1xCjNYZcDJfN6HfNdQzHDMjtqmLTTDuWMVg/gRoPAErhCLhSZC7SpxPighmrSbbaO8FWTKTEdSTha1QVB68AuMtmXI5G5Vtm/LCquB6M3H40udMp0SmF/ZxZjZmkJ5HrNFcKB9EUbrkz3Ggw5pIlTjQayqQrhUYpXMqZD03ysNroYcNl6z/PGbC4heacViJAuC9m0PqAo74+Jt2ZihmvkyJjkINo0haAT+M4Y0WGCx7XZz6O8cIlMx12sVRbprm45JphGyuFF3GsuNHsAjfcOU2JkWjMJ6OZmzMZdWTUxBeXw2I7JU6KZgVBIOI1V2j42+58FmtgKGf6AmytoObwihlPXPLA91KS5CxOpy9muq4UORcOhYz2gklut+3O4wAuj0rh3fjeO2g+sJZibsZ3WI0/z0m5dnNFxhJXTWzcQP05ZuyYCZgTjW19jVxmJx2X7fx5BKL6Yq1mJJXcQFLBy2Z8hqRpy9A1nhlETfZ8yBk/qyruIEZ5CDGDDSQBbpnxiTu3TLK/jjvL8d36A5i+SIkqjtsX6+44Kbet45p5rML4YzglbptxYmIwAR6ZoiioKlKArF1XtMeAGc9KYTQ++zsuN9MpkyR62IzTV2R9j0Ja/EF8RqMU3jbJBCfM+MCdljuLZnzmMgvayZkB4MUrz+uWO9dSYgN4Pdb9Bsrs20GbKh0z7rtTpUQJEL/R6XQNhzyOe4jy12bcWTdJjkcQwCspsexOpxTWAhyNmSSLU1XV3SgZqiq80eBpztxB87zrpTCAAOdEKVxBXf62O0Mp0QjZ6UBS6DjA006HC/H5J+70dTrsujOZErhz6M5vos2cA3cmi/LtrpqxZdZlUTfieTk05em1Y93vm5i367FpMBTrYQ3NEh678zKeC2J9dEyS7AFk5rIbQPbNvjo85etdX+bvyAGGwiSiV73qVa961asvJqH8XeCxu68DmNn/CPwmMGFmjdhhrHvM/1e5++8Dvw/wdrPpDYs5IDP2U2IdWXVPmXEUUp1Jl6xnK3anD1Fj2QwWYKwUnpoYvMo00zKG5rkOYu4LNLczGT8zEk3cJrDQaDBVCr+IpmPQjP1owD83k7ytFFoBCg/dedZus1hV/MCduf5+js14WAqDwQgMlkILsU43XLMt2eUueWAKtSY+6xixLNt9fbwM4LVVCtPutFPiDjKCaLtTGg2ZZbgzEX8HYMVkfT5mxnpKDJfCXilcDHBU7/z350wqhbtF0QLjSIpX7/LOBAB9UQrni0wXLrt3HQxPzPjQnWaRgctMAJR+JEus5aqrSB7ah7ahx9x5K+SitbFFM+79FZNMazolJtxpl8Lr0aBOmPEYNYaPzXgrJT4phREzbroCmOdduXFHJvZtziURPYTu9543uRUOu+z3d2M2aNM1TzUXrGUL+H7c9+wywTkx5XyBJGLtWCeHZpot6nSYD1lgMwDa1QA4BclSWxbzgcEiEWt4JWf6UuKOO3+EgPt1d/6VO3cQwO9HjM8kmjXqmHEpwAbx3/rRfNRjd86Z8ZFrdmscMWjZjIkAq5MuOeRdFxNWzwF+CkzFNVoJ8LmJzFSGkNnNUUr0xc90zLgRoHLJrMuYH7rkjPOdDh0gVxXHObOMZMwtBCjGXIzg2wG8vwcM+lmI+6o7FZrVwyVTrFJiw8Te1WDI3XnhTl9KzJgY6kHoSig/due1lBQQXuTs+MiM7yDTmQ3TDJzF8zqUMy1TWPYYdC37OxGmflKKXF5dDp4/jM2HWlq4azL36e90ZJJkijRYd+9mr13JmeVWixEz3i+FyXCZHEPMbaOquFuUkTcGXC6aedxzZ/SVyIZ50yybxTX62J1vx7qqA72fIuA1gMD1OGJyk5+ZBe1HruZk3PMLsTFzKSUmkJnKXmw0lABzkwGMxxqNbiD4m5WCy8dLYbCq2C2FhZRohsz116S+tN+RY2n61+ai9apXvepVr/7q+iIA7hnwXTMbQvKQ3wF+BvwR8A+Ry9Y/Bv7FX3Wg7M5BzlxAO803ENPh7Ta7rwCvDODOjZB8NaqK02AEpmIH+LejcSsmiVe/SeJzodHo2pvvubNpmrmZTokH7oxUFYdo13vAjPHYuV5GO/WH0HVjm23JOqDfjGZVsRZswPLJieaKzLq706TE1Zw5cOdhMF4prOVPgz0CMVdDObPf6TDUbqs5TolnKdGXFMB9LyUxbKUw5zJlmTYZiNRmHxulcC1YJqJ5ew2FdVt8t5cuKVzLZP5STHNhKQAEyOGvlMJrKbFXCsWM90rhXIRJXzEFfw+VwpA7Sy4XzfPIxXD1FaB33YylAMsG7CZZnW+4jEpGTQYMWykxnxKtquIJsqZ/EvesjVjUG0kOnQ2Tjf0dMz5BjOTFAP6NlFgshV0Tu3RUSrf5PjS5BuaU2HRn3l2mKTlzE3gZjOlQKdw141aslw2TDHInvteou+IlzLoOjXtIwjefEo+RFPceMusYQFliT4qcEM29O3N2OSVWS2EgZ36KNiSOkTHNazHnNxTg4o4ZnVhb48gUpJYI9iEQM2TGvVK0Pt3ZRkC5L4D9oDufuqIpNoocNA2653MtNkFaaNNk3jRPthRg+Grc4ytVxUeu+ar3S+FWkfFPfc/qecjnaIPiMGdapdDvzlSAuz60cbCJNiY2U+LYJG3+Vr254WL73kcyz2O0STBVKTC9GSzlOTOGc6aJTHDm0AbCXJxPheb9LqHNg1OkXfsT4N83zcuOoMDvZSK2wcU0T1RV14XysN3mxMIpNe7BC9OGUceUsXbBxeCfulxAZ1NiD81vEgwaiDG+YZohvWbGas5cRLEie7FmtoFvo9iJHQTmO2YcBoAEmSBdc7mgjsWzchLndz4pG/IAvUMPzXjLJc1dj+uyHvdqNCVO3XkWGwUbcU0yegZXQj66bpqvWwU+A241GhwCp7G5tRXnv1FVzCBZ7V0T0/fg1wfAfWm/I8HBezNwvepVr3r19a9f/Qzcj83sf0B9VQf1F78P/C/Af2dm/0X8t//6rzpWQozNhitr6bOcNf+DmrudaAosdo2foObtCIUSLxVlJ52P3eEB01ySowZsMsn1bz2anS13Fkvh0CTvs6qig2Q+4wHkXqCmpa+qOC1yvzwsMpKopWZ9ZrQCuJyYcuk6pbBRVYy6M19VpJw5RfLNC1XFgSuL6gg4SYkSu/XDrjmS0/jnLXdOGg1GzRiL79XMmcNoAJei+drvdDjPGXN2hOazjl0RBDOICTnnCsL+vNNhETWFpykpX8zl3nnRnR/EPXnTjFajwao78wG4vhfMTkGgpO1Os9FgtRRapdDncrgbRKAcxAptdzpcAj6L73KSM42UmDDjNCWWiQyzAKWTpTDhLsYrjnMhJZ6G9DW782FSbtwLM66hOcpDBKrvI4OZWZNT3kFVdZmBxZCOTQfzeIJmyGYjV8xcLF5GLGXXXdM1L1QzeS0kVXwa6+2pi40bMDFW76J5xJZrVnMxAK+7zHWGEIsEar6LSV5nSAbbNONT5Mp6ZJrpW0dsUyPW3BaQS+mafWyjrfwrOfMNFJvxLGS7PwOaVcWwOw8RYHuZEjeB1SJzjOfxfBzF/d9BYPhPzZiItTmCNllmgR93OvwdM/7YnRvxrK0HcwwCBQ30kplApjwT8UxX8TnHhItkXJOraKNkwL1r/38YoPQ33PkAuBXP/otSmKsqtlKi4cqqa6Wk+IZSGDWxoHWW4N8348/c6U+Je0AphatI7vtjF2N5YMajpHDyE5Mj5lPgDWAx3kM/yZnvpMR7peClcDslHrsk0PvuDFUVv8iZ30iJNZfhykmsrZTSv+HU+cidxQBXzbg2P4vnpjJjG20W7KH3DVXFVNH86n5K3Ry4K8BPXPLadRdTXgWA81g7Hsc9jXs+nBL78dlX47tlxMoNxXqaQwYvV+JYS8gsasQkGZ1EL/8lMxbinQuKeEmlcJISS6Xwbkqcxpzp6/+PvLiva32ZvyN71ate9apXvXq1vlAO3JdVb/b3+786f57DUjgK1qR2SXtixuvRWO4ia/yrJtfJczlTmbFP4FUzjkphuxTGU+JiND4N6M6BACyU0mUcNgNUOGqYGimRUmIrZsDmkqzLh4I5GYhAXIDdUthHO9ylKL7gxL3bMIJmtGb7+9nImUtmfGbGW50OH7gz0OkwEcc6KIWFRkMzRiYZ1HJK3KwqPJirKeBxp0M/YnReuKRY42akACgHOTOIGLm/a9Zl/U5cphSHRcHNw0iCehHtou8Cv4F2/kGzMCXJwe8ZYYGfEqsuCeRRzjxxZySuU0ays35gvxTacZwGYQxjxjOXs+Ne7OJ34hxmq4p9dxaCeXmK2KUhxG6AZvC2gWuu3Cw3yfcmqop7RaYX5814bDKeARlVtIGjnBkMsLRTilw6XYYh3zPj5yaHxM2kjLVT0yzRfVeEQG25UOfqQYQXIzZ0CxgphYkAPTcQIOg3BaC3kHGFm/E94OMkx8fa8fNWfM9VJFO02GxIcR6fpsQCau73gYvuvHTnMjLYKfW6zpk9l1vja4g5nAhWZiKYvIw2G84j4DiOZKlTwQIRz9EpkvheQqZAu4gJG48/X3VFBlxExhY3gY9zZiqeXRCAbJvY3YtxnBOXvDmZcdEkmawQiLO4zy/ietTSx9P4szZidSaRLHcv3g37saa2gNGi+Ie2O58UGdUcxHFm4no/in9uxPo4RIB1Jc55Dnm/T8QmwG6A9HoD6LoZm0XW+hfNWMmZ4s4i8JEZ0yb3yxLP5p47NxHz1HTnmjs/iXt2Kf68jdhOUqIVG1Ufo7m5NgK8i3FfTpHbbcVZbuMDZL6z4TLDuWCSjVus87fN2E0JSmGPAJMBcBOSxILcdzsob7CKz9lEzLqnxH5c70kTI9ysKo6qikbOjMX1BGUjbiFW/LQU2jnTQhmcg2acX1r62scIfJk1lqb8u43/4N/1afSqV73qVa9+xfWjzh+yV7Z+5TECX0ol0/zUZlXRD3KPy5nJqmKznMlGjoqMDI7QbvhhKeTYub+OANmPSuF2o8GnRc51c2iO7KgURmomr6pYiuZ4xuSieLGqeF4KN1PC3Xnjlbmtd4C7Sa5us9GsAZw3g2i4B3JWA2ySUh2hcO7NqqKVM/2ogVtw5/OY8epUVXe+b6bR4P0AbPtAzpkJdzaK3CTbVcVBkSvlo5iJecPkJPgz9+4cUHY5W/KMfa0AACAASURBVN5yZwPt2h8HK3CSM15VPEOud2PAcsyRbbis/Gv3yLeAz3PmoKpk/GHGZoDQ1U6HFWQq0owZskXoZrCNmzEZx/moBnWm3LZhP7PUT9GcniDwPGCauxrjLLOsBhXDVcWzUjhpNBh0GZTsI1DxzfjZu8BwzmwnWa63XbLa89C1/79qRpUSzXDb+xABgvWk/KyTlCQnS3IWzAGSa4BZy3Dr+ILT/n5u58z9qmIa2fs/c807TblkdMklWV1358cmiduMS1oH2pRoBrA5jO9lZpxLicel8K1SGEmJn8RM1lRKzLqzikBRzXi1U+JcMMsvCEdIkysqKeGlcIrmofoDfAyY8dBl/f9uHOdjBBiumPGkqrjmcmlsBOg8At5FDpa7pXABWcUPumSLH8cz+w0EgpMrD60TzXupn8v4syrA4ziSUh4F8LoX5zNrCiyfRA6PdWzGEDI3GXPFSjQC1KzGPbttMjkZiuu8H/dhHElwifW6WFUcmUx1DquKpVjbLSDFBsq4n4W4P3dJZi+ZcTdn3kqJDXdFZcS1PEWOp08CPK+6M+JyiH2EZgxBrpIjwRo+S4kLphnJx4j5Go51M2HGL9y5WVVMxPV6gTY/QDOTGegLmeoOkq2+ZsZ6KTxw5Sg2TOqEnBKDCBTWbrwgWfWQGS9MOY1zKXE5JbZc7NpYrNETM2ZSYg059jbM2DTryl6fxxp7UgrXGw1WI0Q8Qzc+o1d/g3LwnolJr3rVq159/euv+ar/SgC4DvA5kgHtFwVaJyTReocz84Bj5Fq4anIPdDNey5kHrpyvVXe+W1W87HS4mBJPEWvVTImtqmI4moshYM7Fau1FU9cPXK8qnrmytfqBk5xZQ+ABd2ZdIbt1Q7iEmuGMAEp2zQuduPK/npuYnY4ZVuQod4qabu90uA08jHNaTYkbwEN3zpeCRzNcSxE3Ox06r+yqv+XOJ50OA2bcjusHamynzXiQEt9uNHjizmyjwV7O9EcjfDF23p+681uxw14RhjBxnCUzdqI5v21y5dxzZ91l1DCDWLvzyKjlflWxYJpHu50SD6JJG4KudfoECrFeMLlMGgJCG8igojLjKBjPAbSL3xfMwFYpcjGMa3jdZXJRkGywZm2HAvzvB7PxlsnS/UmAipW499vuzKOssg8DNLaQLLFpmmurXBLAjfjzh2ieENRc7wWw6QRgW4sm95IpQPvInYmQua0HANyNZvkQuvOPjVJYj4b6cc5iOwOo9yMmrJ0zx66ZvbulsGiSr03HOiY+o5iC269VFXs589TkKOkuQ5J5NMe3G2zNbdMMVo5NFFDjvWqSdLpLGnoSUtfbwL2Q2x66pHp7JnOXDdS415b0p7Guvo0a/5eIRXsZALzhCpb2eN5WzRhyzZt63Mt6DW2il9XFAKP7wXr3IWnmVXfWSuGBSXbbn2RWkt27MkNHlvl/z8Qo3i+FcylxFBsgbQRMSInnpXAjJQ7j+d2JPyfW/HGSk+VsrJlajj1g1mVWmybXxv5grKswHhrgTD5rOfPCFSEwb5Jk18e8bWKp63zBywFQd+K7NEwmQyDZ9X2XDHS8qpgphRmT0+heo8ECYtpOzGi4M5cSz5EM9Vq8U0FuovfMuBLX5dg0Q+xmTIZUtX5XrARwnoy5xUYp/Glco/GUmCyF2ybm/QKaidyDblZcr3rVq171qle9+uXq1ypRtVe96lWvetWrXvWqV73qVa/+/1xfCQbOgbdDsvO5GaMuK/DpUiAlScCQy9wScL0U1qqKk3abHyCpV3bnjhk/7XS4nhLLRVlKBUmoxkwyQRBLUIDXUqJVCmMp8dJkyT6A5G3bLkONC2YM5MwsYqx2ETME0JfkgNk0hU/3u2ZZRsOR7RywVpT1NlwKA674g9dQntWTkEuB2JgLcS1GEVO06s5cu80yYvpOXSHWgygA+xtmLLsz7M5+7GovIHbnN4GXOTMVMzXeaLAVDMduyOGGzXjhmpkZM7lBfhLHuQTcDIfNlhknaJe/ZZI9HqbEnGtWazUl3or5l2+6zFgGI+tpt9NhJNjRydiBP3Vl0V0CNlNiJCWapqDmHXeuJ2Vy7cZsIsiA41wwgFUpbIfUy5FM8LQUGq5ZvwE0C7XqTkmJVApTcZwDoKREw4yPQ5I6gebb5kJG+S/RTNs504wWpkzBC9DNAHyJ2K8R4M/NeMeda2a8hxjFc2hOaMNlXb+O2JlTZKTyGWfGM2uIKboTkrmfuHM1vitxb94LVq+d5BTaDoOM/ViTINfLfZOEdzdn9syYd+XJFZNkmGC9rrnzx2hm66JrZu79+G6XU6IdjOYDZPLyxCWT7ZTCLeB5KWwFQ/e2GdvBUtfunCAp6ECc2/9WlGfWj2bLinvXXfYQyW774r9dRXLH83F9dk25cI4Y4gZiLT+L52kIMdBzptm++aSIgwF3Pq2/N3Tt+X+EjFHeivfJsDsfm2YnU8xvfiMl1s24lRKfBJvcH8fJyPU2mXGcZCjUBC5DNzB9wGV600DOo3Nx7+uYgprF92DLVlOiiaTTOy6WfysY2EOTs+0OMhzqd8VfTLxyHEwzhQfuLMRztW/GhVIYdDnfThS5sU4lGQg9LYWhquIUuvcCd24BW50OJ8BmVXHVJctOpbAW17iYpMFHcZ2mg4mdindjf86KXyiFhVI4ypmNlOiP90OvetWrXvWqV7365esrAeCSyyExI3nSgEnW15cSnwC/E43l/x5ht8ulMOXK7XpRCqsIAD5yudVtu7LRjlPiJGdOzRgz62aYHQApJTbNmA051qQZg0iK93GAm+kAZMtoFusCUKqK/VoiZkZfNEG3UuKla75r2CW1nAbesbC5TwoZXwaqUrhixlLOXVlny4yPkMvf++58NyR4lhLXYq7lCXLre8ckkXR3rgP3EYgFydb6TdlgCbkxNl1ujZjmVqbcFZ5dCjlmvS648yjkWwATVcUWMB0yssNSWKgq1k3zYOOmAPVUVVyJ73wCbLoznRJPajAQrp7DHkHbKMuqMuOTUriI4gK2q4pTV8hyE0kUO2Zd+VsHSeVux6zhEJqH6kcA7qiquBlGIQfuHAH/njvvAX0BMohjbMWauZUSnwYg2TbNCg2YYg+OUmIwJb7lMk0ZC0nuRDSoV1FjPejOFTRX9RAFdy+aLNZfIFOZH6J5yY7JnGI9rkd9Th/G+T51SRINwOTqZ8APSmEuJa6lJIOPAAMjASAn4jjjKbES1+Yk5knrapgxEMD30J29lBiK9TueEj9EEmbiHtY2+3fMyBGx4C4305+4czkl5oDHKfGpO8U171eb0xDfcxKZs7xpxhaSZzbd2UdmL5+YyQCoFE6Ab5qxGkChlizWACyZ8XPgapEr7CWTpDiZ5KQ7cZ334lyPXKHzl+LnP3fJpedQnt4yMg55acZgzqyb5gstno8DM35YCjNJ0RK1vHgoNi4G4v0wFUB2Hc1y1mv3qBTeQAZAp/F3GylxaMZ0HGupKCZlwJ3BlDiNubJmKUyZshhLKTRCijsQ1/dcXNstO3PW7UMbU/eBi1XFZCkcpESJZ+BpfH6Jz2zH87VTSjeXbjjue73G53Nm2YxvxHc+Z5JxHpqxXQodl9R7P2fm/GxO8Ik746WwHsD7oBQux/vDU0/40ate9apXverVF6mvBIDLZqw3GqQi6++9IgOSg2hKTmKXedCdtZRop3B7LIU3ogl5UIrCb1GD2zTjzZzZDaYCs64F/M2q4lPXXMegGZ4zVgofoZmoPXded2UhjSIjhr9lxlZV0TTrsjnrSU54fcCzUhg2zV1NxQxbCxmrNJMy5WoL9p0iQ5UmmiMBmA+2ZR253NXZWN5uM4yiExrAGy4WawGxLc+BkZhBAeXJ7aTEuCmL7tS9C6CaKXFcSjdk+tCdcwgstaLxHI3mqhN/rxnXaKuqaLjYrWQyLLhgCm8GNYNNBFR30dwOcY4NoJEzBWWc0dfHw1IYqyoGTYHgiwF4HxdlW02jEOD7AZiqAEvHyPHw0GUw0kJMz1Uz1lCsRAFwZxMxIsNmXTfLfZeRTNuM9ZyZdmcnmtprppmhKprOjst8o26WawMOYr1NmPE4WLxdxAqdBphZc6cvGvvFANEdlBc2j4xL/ji+2yRAgJ8XRSHwp658tSfA9wI0m2vGzc24WQqnpo2Oeqaobcov3IifHXdZ8Z+i+aNzaJ5vz4w30CxazWovohgNCFdCoPUKKMix/lZjE2AnNimslC54m3XnJKWuC+ggkTFWZCc/58qkm0Hs8gvkSlg7K77rctdsAd9y766tZJrBnDfj+8BdBMD2EUO+b8ZQkaPmcQC4t+OcP3CxayAGf9dlCDJoYowapsy2UXcemaJCLpqiKJIrkL1VFMdRbyYMJ7mIzsX9GYx1dTGeuS3E5F03YylYtNG4np/G8WvAdMPk0tlvBp0OfQFcb5nxJCVuI9C1YsYld5YQsHoSz1Izntdp9K6Zriq+j6JOVmOdLcY9nKmqbnzAQ+B1tMlwLeb5AAaqilxkkrQL7KdEP2KVM9p8Won5uIspMV4Kn6CNt20/cyAdKDJSGYnnv1lVnKREIyWy9WbgetWrXvWqV736IvWVAHANkM20GVdjN/hpkbPZQafD02hS3qkq7ufMAPCg0+EbSdbh/WYMB2h57s50NLze18e+ycRhx89sXZYCdI25cxCMwJFr0H6kKB/s5ynxLmpY54AHJnODyZA7QbAqKdHOmRkz5cvFMd9150cmUwJvt+kHVkrhZjT3VzsdNoAr0cQ/RY3zALCdEsc5MxqMx+cuOd21aH7aLgfLYZeEqcOZVG0bAY+X0ZyuItnYrBkj7mykxElRjEJfSvzrkFm+5s6VFBlawMeu7Ke+OO48YqnqzLDrCHh8yyR97CAZYE5ymtwIMFBSYi1nzqfEFUJiZoaZGLy9UphNCufOCCQ1U6LlzmfBQIDs+mcCbIyHRHYmAN2iOxeKnEaPzajcuYvYw+lo9Ovoh72USKYQ97mUuA8s58xkGE3Mp8SLokDqEw+ZHGJ3apMJ4nqvBxO87M73zXjfnSsuWeMwMnkZNJlGPDExNr9lcr7sR6HkIAnhQc4cm2IHziPG90MTQ3ZkxnXE+DYRs/WBSbZ2MZ1lgR26s1yKMuqQW+IgIa10l+OhSbb73F0Ms4v9q02EQPEYJZigC3FvZwPUWoD9jOSME5w5Q7YQ83UY9+zQnRm0IfG4FNZcEtdWXL+nLqavgQxNnqGNiUEzfga89Uqj3zSZAz0xGehUCDTcM+ObZtxNynrcLooBGEBpyRNx/4mfGQugvGnGZHz/Y5Np0qVS2DBlr/XFczOMHEz7AyyDNmtqJvUEbRpkZJAyGcD9RRx7BIGfk7heA2G+tBH3/nOTdHQCRab8VpxzuxQSYi9PqopJd16kxCiwGe+AR7G5AIoBGHBn0J1/jUDmoTvvVhUv4lwvIUCVzLjhUhnUge31L4KTuI8tM+ZNknLPmX13SqNBC22s3Koqfl4K9xCTeoDMcZ7FcUpV8Q3OgsAnTWYm7s5VevVLVS/Iu1e96lWvehX1lQBw2Z0cjfzjYBbqGaSKMwbuWSmMIDe421VFMVmoH6fE8wBRKSWG3LGq4jFyZAQ1LvuvNN8T7qwEy7RnYqSux+e1kURpK3aiK8TsdUrBqoqZOE7lzqYr4+nD2JHvlEK/aWZoMpry4aI5uLFSWEY5VG6ymX8eAO5WNPhPU2I8Z5I7rVJYQU53TZdT3WhVsQp0IprgtKrouGZUQLNEKSlnbdWd7yS5G/4Jcp8ENcOp0WDYnZvRjG+jBreWdk268tDW4xoehaRsIgDAeik8S4k33ZmJmamdlDhBQLR22XvdZZM+D/yfsWu/58qpsgDXKT4fYDHJhbIVDWkrjtNsNGi6cylm2vr6+ljpdNgGZkvhQ3c8JXaiOb3DmcxyLgAtiL37FOgk5QT2pcSIa35tM8m50EvhAyR/3Q/GYirWaA1wz5txPgBSnck37JICD7ikj/vIjv4hAjqzJraxhWaItuPeH6DZx10E7LZMTFETGEhy/vs8JVKs40EkA0yxzrozXi4WqOWS6zWjSV9ysVzDAQCO4u+PmVFyZh4BrzpC4nxKnAbYW4rPzIgt2zWjP57RNoBZN5bgxMXyNeMa7SIgdN9loV+7F7bc2TJJIDsuZvIkwOkOcAcBl5U4zwPT3JXHzx+aZITLphD3dQvWPu73C5d76AJipS7EcV4iuePnAfRHURD6cEqcmrGBXGmbZlwBlkI+PGOasdyqn40AeZVJ5rqcM30mlvXIjIkAZB3ksnoOgdkLdibNrefqbhNRDyh25KEZVSl4VbEf0sntTkfPNHpGmyH/HjHrzmROxDU7DLa/7ZqdTK/chwOAqmIGRU7sBxCdcG06gcDWg6riqCgv7jju8Ygp064TGxTPgmFcLYVWrM3zLvYa9A6onV1B75xVF/uZejECvepVr3rVq159ofpKALhBZByy0ulwYsow+8QlGavlfqAm8wQ1z23gnjvfQ2HZ+0g2NIAklBOoGW7HbMuQSSoJYp5qu/ND1PyMAVspsVQKs6b5rHlX/tNk/PeFlHj2SvMxjJrRjaqCUjhCjdoImtOp86KKO8Px50fufAs1f4fuXXZgPZrsoZxpmlikdReb+MBliz5lxgdo3qqee3oRjdf3a5BrMtzYSzJyeILmZq4jlu82YnyapbAcbMR5gg0x4yiOcy+a9mHEtB2bjCS24t+HU+JeHLMTM0mz8bMX4t6AmLwxMx4D11A486kZVBU7pXAvPn82mMF2SgxEQ+5m3Hrl+jxGUtPlpIDx2api3IxFd564WK8HwHvBwhyZ5iHbsW6Ic993xQIcoAaepFnLIeCyO6cp8YYpH23cZB5RzFg0GeyAwMAhaqhfR/KxvZTYKzLFmYk1/RRtCNSAZ5JgnOPnQaDljcg87ASDOZGSZu/c2a0qmtH8brzys7MuieP5+jgm0xRDAG/VlJH4GmJ3GqixPudnoe4JzSu9ZtbdKKnjDyoU77BGMFJm2iiwmA81sUdPEPCvEBjZDWDajySbg/HntdSubcrCG3HJ9A6RxK/fjE13Zsw4597N3DtEz9UNUwZZbUZUz+m1i8LZ67nAOQT6hlzs4pU4TuXOA3e+geSj+yY26g56jgZNc4pT7pwEuN1G4OM2dM03ZuL4e0XmOB6bLw3g05AAvwt8iN5JUwHI1xH4HHJt+oAATjOu+Ulcs5YZc6XQCfZ1CpmmrHU6CkFHz+WAnTHkJcnUpLhMSN43zasdVRVTOWNJBiJTKfEEeKNoHnI3Zw5eOQ5xz1tmmtVzZ7PRYDkAfZ2PWKpKQe5VxYOcGUbmUDPxfhw042Ecd9iMl2EudZIz79GrXvWqV73qVa++SH0lANwpMk54w5SldYwavXXg3VL4RTRs0yYjhkHgsTu/BSwnBUnPx674WJGpSKfTIUdg92TsGreDzRmNXfk9tPu8F7v/YzkzFJ8/i4DdgEkWtO+Ol8KiO5txnAo5CrYCbIDAzEW0G16VwnFRUPYI8DJ2rY+BUgov/SyAuwLl35WCmWaxLphxYjK+2DbNzVwPULKHmt4xl/yzlnUeI6ZiOnbVT6Ihbptmrz5Cc2mvR6PaCaByLiXum9GJ5nsaMQjuYsFOAlAfBHPxshSGq4phJNksdpad9oKz/Lohl7yslmOtFZmzjEF3ZukAybuOqqrLOHZC6vhpfe9RDtZDd0Zy5rCqWANeT4lHOXdNHiYQkLlgcpm8EQHtt+J7eVUxWwoXXFK3VlKo+gGSae6lxGopDMX5mp0xQ3vQzVyrSuFOgJm7LmfAOTNGU2KjFB4hJ8PaxOMqMtHYrteWyUAHlH24hYx1agZnHDFIGwHCDsxYKTKCGA4J7HOT4Um9wdE206ybGZ+72LBVzgDIpwFojkph0r2bJ7YQ4K7OAjsXQP2EmLOK820FoH4/ZLR1PtoUmmnDvbvGQWBqOp6dTQQ6MONtBBpfupiqhKSEA65MuMevgDWIzD3T7N8xemktuXODM5lr7W54Lr7TcZz3InSz0ubj/PtindSOpX/uzutmbJgxE+c6EcDT4vMfBEADuWIemnEVvaMuxkbMCtqgqOWUY/H3LyJnymTGRAD8h7Gu54K9Ho3nZDQ2cjzJsOZmrLtO3Md54LNSaFQVk2iGDuCnyIXzEWJm6+uwEeu8Mus+4yMuefeVUlgKgFhvSx3Hdz9nklc2q4qL7jxHjqVvufMIeD1nEnBYClNFBi8Lps0mAHJmwcTgr5lxKTY3DEnhe9WrXvWqV73q1S9fXwkAB2rmt3LmuJZ5lcIN4JmLBQO6jf42atQ+LYWhAE+daFSSGcs5k1JiNliv69EkHcfu8CZyfTtATfJBNIs7yERjCvhbZjwzY92dN1zGGEuusNzauns/mlbMuo3UQSkcBAjcdc0A7bjYtPkAKxul8HopOHRnqvpMUrQGsObOnZADTgK7KXUZjqfR5A6agrangymppY/7pZDc2asqhkoRKwJsB9gaSYl33LmHdsaH3BmsKnZcQchXAlS0XfK7QzTH0jQ59V1wzSqdC3fJw2AuDLFMHteMaJor1EiuFxnUjLvcKK3TYT4lhs1YN2MkZx6ZcT7JkKVCs1g347q2UqLV6TCeZGLTQLK9Oth7MNZHA9m5fwosRqM4nxLb8b1GAgwQ0tL9YP2OXbNQs+5caDTkUokMKWYQO7cFXZfOqQBvLeC2Ow8CqG+CYgfiHO6YmNaPTZLLB3EtD+N4AAtVxWFcm+fu7FQV23HvLqMGPiGAt+jOtkn2u+HOb5t1XQPXEMP3IDYBRgPoO/BJKWQEJh4i2eG3EUu0iWbQapfWOvbB3BmINXgYa3jcjG8RzJcrDP3QJZHsi2ezZikPkOHIMNpo6JhxXAo/RXLeZQSiJhGL2YqfOYrGv5bVno/18ASBr624LgvIhKOJWLA3EJDMiHVcckka9+I4rXiOa3OfIRPjdtWdZWAiZw4RA3bNjF+4ZhZ/6GL1NuN7TSRFnBwicDJompPdQZsMK7EB8DDWzp5rNnYSvRPei2cfFEmya5qlHXHnczP+rjsfuXMhyaJ/EL1DXk9yzB0shWelMFBVvOdnrOn5quIEPTedeKYnX5E1j1aV5n6BizFPO2DGFZc5CnEP6vW05U5KCYqiFQbivfbd+B5PS+H1uMdjyPSlvvcW13Yw1u9yKVhKzJjpndmrXvWqV73qVa9+6fpKALj6JCokFdothSp+ydemHaDGcDt2kzsxM9cIQFO77XVc80yNUthHO9iPc2YQWAsAN11VLJtxHLv219Fc0LZLsjhnxrNS6DPN4jVS4jOX495bJkMGUBN5gIxPdoP9mDbN4Eyhnfkl4C3UXB/mrGwo924DXzNwN915SRiFoCb/CIGigVJ4AVxJiRtEQ+/ObErcjd3vP4vjTKGG+VzO/Dg++5kZt91ZdcUE7AMzZkwF4G0h2elwSl2r9BxSxhySsAdFWVb30a7/SsxBDZlMIvZQs9ofoPKDAANvB2iZjZmbZ8A102zV+0UW/gsxF9TvTglJ13xSFlzNCO4iiV2rFEZSYqUUxgI0HAHDOTMYDN64ifE8cc117diZGYabZpVOEbCtqooJl6StmRJ9ReY5f1JkaNGPZKIXEIir57tqkHERuZFWCFRPoJnM2jFyBbE9+6jBHymypT9xJ8V3SwEmB1wufqsuGe5FNF+3Ecded+encf6jwHcQ2K8lhcUl1+sHrBRtVKCNhhvAw5R4GtdmBG1WLCAp8X4wKiA5oblmGw/RM7kRjX4jrt0uatqPgOGQYg65M+Ey1wABx0W0QdKJ85oL4LTN2abDGGKYGrF2txCorN0K+xC79CyuyWsIhK3Fvd5H8tyP4vMeuGIz3CTFnI/PKS527RQZ33zmYrlXY7OiEc/cBPA/ufNNMz4qpWsQVDOd511y3osByk+AZ0jSemgye9lyuY9uI6fMdST53Iufr+3/axn2ITAZc5l/YmK5++LZ7w/A/sg1Y3nejCshZVyLc5pC77ntqpI0NZjQqhS2UmKh0eBFp0PDxPw6sJESk0nxGHUmoZcim3+X7LuDgPObJnbvc9ccZMslM900oy+em7VYmyDGeceMuzkzB1xrNNiJtTVEr3rVq171qle9+iL1hQCcmU0AfwC8ifq1/xi4B/z3aPTkCfCP3H37LzgEILldq9Uip8RYNESLJkv+k9j9BjXkDZNDWx+wk7OszKOJG3Zn1hRufSXYlA4hMyRYE9SEb8TfHUAmC5cCHMxE871rCmd+bnLEdNRsvXQZX4BYwn2XKcWISw527M5sNOIr7pyWwqfR2LdjF37fnT0XY1hnZv2hK0i6oOy2g2h0Nt3JJoavzyRRqpvC4s5CSgyVwl6AgQumOallBN6WUTDzy1LYjzmr6zFDtpoz++nM1nvBrCvtGov/b5rxvNNhBMkd7wBbrRZ/BvzDlHjkMqcYcGen02G6qmi73BgB/lfgfCk8MmO6KO/twGWQcimAGGYsV5UkVzED9izA11ENvnLmJCXGUqK4cz5Az0EpnDdjJyWxgO4sRQO8Z2IY9xoN2gHeF6qKBgIIzZxZNGOjKIOsCiZkwSLvKpr7EyQXXIrvCXCSM41Gg/2cuVRVjMW1bkcTP11VNIOVMyQ1G0vKG5xwmapcDYZwz8Vu1WzHWymR3dkopRtl8XlsEIzGeS7nzGVTdl1tAf8OmvM6iXU76s6NlHiQFNw8gCTBEy4pbEmJA8RebsVmCIhReyNYyX3X/GWKZr6N5rRyrEuK4js+D5C4bdZt0LeQhHMdAeABd6qUeOqa05uONfXAxdz0IYfFaRcbeDvO56MAnefiGk8imeAoYulOAmBWcV9vmnHfJMncsbPZzC3kormGGKSLCJStupw/W66w8k0zLsc7ZQiB1DXOZun6XSzfhnt3LY2gl+mxa9PmHdM832Acp5Zqjsd5zsSxCgJHz5Fkdc8k8xw0yWBn0YbPFTMeu/IaXyIJVWhveQAAIABJREFUb4oNFKCbjXg+Z20olMJRUtxDArY7HToI4O7krHMF5opiR+rMwD3XRtWKS/66Hu/f+6UwmeTquu6akewDPnNXRlz97orjtOLvnW80OM2ZY1fAeLMU9vzXh4H7sn5H9qpXvepVr3r1apl/gV+mZvbPgD9x9z8ws37UQ/znwJa7/1Mz+yfApLv/Z3/Zce709fkfTE7SQLv4oy43tnHU6HxcgwokYXuB2K9jJA1qIVnTWpGr5L7JnGM8pD85AMNQAK9VJLsy1NC2kBHCMGI7hlCO0bhpDmQ32KHRlHhSSte6exY1f5XLqGMXgZVa1jXlzoYugCR40fS23UkueVr9W/swfsYRS3QrJT5GwAHUOF8NO/H7AQoW4rsduezLQSYJ+4ghmY3jXjE5cK6kxFUkoTtEjN6myxa+LwDBn7fkG7dgxqOc2Wy1aKLG7GXOHLpme3aL3PkAcIV3nwbrswL8RvzZDmqAa+e+kTi3QehmZl0NmddQANcxs64BR32tn5gxVlXMDAzQj1iZtU6H32g0eJ4SN1+5Xt+NWZ9xxP6Mm3VnBCdKYRTNMa2V0t0oqNxZMMkRl5FZygoK+35SNHc5GaAMNEc4WQovUmKzFC6hJtpNeXXDCLicutOPmI15M566M+bOFpINg2aODpFJyGlsTjyN9dCJBvzYjHl3tlzzmxl46GLKakOMnVjHiymx7jIZGTXjZYCJdxoNBoFfAN9w53OUV3ZE5ITV6zpYn7ux4TBclOk1TsQnIKA67s5mMNWjrty2c9Bl8izOcy/uaTO+00O0ufB+sMffdhmhbLjYpXfM+BF08+TaZnxumjnbQxLPbQScrsc9tlhTK+jZnUXPeQcxasQ5D8Zzsufa3JlBjFyJc2siVtPN6DfNnB2bJK91sHiLCOwGfhP4LM593mRUcwHJChcCGHUQA1tMeYSjAeJALNto/J2nJsYQMywlMgJbM/HPF9zZjnt73YzTlNivnzN3hkMqfsmM5Vj3B6Uw2GiwUwo5JJT96D1TBcia4izjbsy0ATZmkjpux7UZibW44HKbze5dB9Hh2Fzog65yYiXW5qgZV4APS6EVz/fFlLiztvaeu3+br3l9Wb8jx2zKv5N+99/CGfeqV73qVa/+XdaPy//Fnm/9lYGpvzQDZ2bjwN8B/iMAd4/4IPsHwG/HX/tnwA+Av/SXU0FSuasBmI6ABXdaAbxqNicjgLVQCkspcdk033KKTDXqGbG3XSHcY8FEXEfyu1re02dyyls0uSO+Y4ZFEz0U7MAAaiD/CDXY++6M58w3CcMGZH1+1Z0PXIYhi6hxaZsxVQqHJpvt8WBy9k0B3Ycmd7ZDP5NAjSJp4cNgSp65TA/OA8elcBoAqZ6HmjPjYZF1+mF8P1DTOlmKbPxd7OA9d/py5ooZH+VM1enwWc5su7NeFM2wVQp/yFnTvIQAwWJcL0MMxYjLyr8JXdZkxZ2TUrjvktdNmXW/1/kA49M1yI3muI2ayDG0K78VjMkMZ7ERjWAdQI11o9Nh/eSE8arixGRn/89T4rsp8Ucuw4XBquK9pDy7bzabrAGnjQYLAbzuunOxqjiXs75PXO8WYlYehESzzifbLIVG3NMqZw4CCC7F2puJa3/ickwddWfNjGwKl+7YWQD5IWrkLyG5cM163HXJFWddOXptF3P0zQB6TZMk+GH8zCGAO98EPkazXiC57WJV8dKVt9U0yfkumOSED3LmYqPBcM48MbG/58zIsfZrZmQyjnnBJTlcRWzZJpIFH5YiFgttEiQXI3UVgfXa0dAQMLhskhAOIHB8E/jEZVTS55JF34jrPWxyWm3FswnaZCGOvRP3aw+YCtaw3ozJKLz8emxMTLrYqgvx84/jWuZYy6MBjt1lQnIObbLcRGBvOd4/Oy6zk0E7C6cngM8H6FncjPt63zVjhhlPiuZpp2KtDAfIG0QmLiDAj1k3A3PXjMuuaIKBJOfZQ5c9/8dx7aZN2Yuz7mezdO5cd2c9mOr1OMecEkOdDgOl6N0WwP0aeu8Ox1qrwekxcDs2Moo7OTYjHsZ59yPlwXDcqyPXRtQhYgrrDakmAoircW8WU2Ij3sm1WuDrXl/m78he9apXvepVr16tLyKhrE3Y/hszewd4D/hPgXPu/iL+zipnJMpfWCma0bul0BfN5CjaVZ5PqSszHEY71RsBbFbcuWqaM2rEB51H4GPfJTcbDzB3tRTuRwPW75rlaUdzsox20M8hRusgPu9ZNOuHLilTGwUeWzRfQ6XwInbT91BDO4AYt5UAowumrK4JO5uXGUINVxM1QaDGad2ME8QqPERzLbgYwI57d2f/FpJWGmo056CbJ/e6Ow9LwXPmXs48dmc7Z3ZL4UoASEPAYzmu9TFqjs9xxlZsouZ8E8lDa5OQ11JiN3be14kZRcLgw2QPn6Erx3uIwMq9OO+MdvObqNF/CF2J2ctomG+h5rFCgAEEepMZL6MJXTEFWS+686gUtoH5UljKWTlsZjxttXge62st5IqHZow0m/zMNf8019/PNPCBO5NmDJbCcDTtnWiCN935blXxuRk5pJizJgOIzVJ4DtxMCh9/FsCtjQwq3qhBfEgSZ2MN77t3zU7eSMrGW0WMXQNloa3Hd7sY9+UCAprDAeyeBTCoDXTW3ClxvUpVUaDrDlrn7g13OpCUt1iQbG8q1mUjjrNcCpvubKXEuDu/acqvSy6WbSAlXo/7ULNX7VhXjVhXICOLGwg4TaLmf4oz58uapZwEfhrPSGWSzc762azUs3gmqgAuhyZmrGYDDUkiL6PNnBeuzZ/JAEcv49noxJpbQYxwM861iu/ZRoYpG8GyzwMHAWIbyLwDBHRfmJwvx03yx9fQ5lG/y+RnEj1X/WY897N53hTvnUtxrZ/HzwyhjZnXkyJOGsB6zpyamLTaefTQJX/toPfPdhznWyYJeNvELI+g96X5mZHNeDDoV03zvxCbMyEhBm1gvUiJSyYX16FYZ9dC6vzInUtVhRflQDYCCLdNBk0jfmZgMx3XeAgZ69xIiff9LB7i16C+tN+RvepVr3rVq169Wl8EwDWAbwL/ibv/2Mz+K+CfvPoX3N3N7P9To2lmvwf8Hig4eCkam5lgDnLsKONnM3B3ETi6WO9Ao+YtucxIanbKzLiI2LoGsBPSvhpUNF1mDwfxecNmNGP+7bE7d0xmHQMuVm3b5Q64gBqohWiaBgJQzELXsTGlxIcRjnyHM8OQGSTFWvMIXjZTIx7ntBjHPECSrORiItsui/+jaBhzUX5by52l01MxfqWw/grDtIpAatsk1zTO5v9wsX5jnM331DKvdfg3duJPEZBeQY3+DALNW3GtbyEguoqaxQkEcM+b8Sy+11WTJOtvx/8fmCzOH7jiDRwxF1OxW99wmZ70a/3wLM5nysWW/L0U+Wgxe/XSNB81BZK3BihtuLNaVVxHbId3tA0wCOy12wwjwP280WAZSM0m+1XFujtNl8nEnEl6eDslXuRMX0q8/gpYqoHsW0Cn3eYR8G5KrASA2HPJDF8Cl16ZIVuKDYiH8d0cAZDvRPNOztwHvs+Z5HQ/rkHb5Ap5z2Sws2jWZYRHU2IdSR2H4rhtk9RvM77XqRkLwQzNI+b1MJ6Hdqyh0fjZuXgm/2ckWb4S4OAQuR5uI/D4MsDPHAJafxrXaCrW1xh6Djfi39+I9bME3EDP9RumzMJDM94EHtjZfOggAhFNM26b5v5a8SxdQs/7aKzZOuOvmHHfnXdjjYAAH7EZ0UCAasrk/rpsJolz/HPNzG3Gfchm3WzDes2CWOrBYJCPXQYt+y7G7jBA+l5s8lgpnEuJNfR8g0xZ+tAw1A9R5MHFeF8cpcR5QiYd32mjyLzn2IyXwbKDmMAFIrokZlwfuOZyawBn8S5ddikGGiZmvPnK91lDktnP0MZLAn7XnR+hudghYKPTUaRDp8MVU1D8ZFJMQO3S2kTv5/ddDF8fsFdkWlS7gv4a1Jf2O3KAoZ575xet+ndgr/7m1Vt7verVV65+6Rk4MzsP/Mjdr8S//230y+kG8Nvu/sLM5oEfuPutv/hI8K1Gw//bkZHuLvAAZ3lbGbm9gZqlJZccbbCqxEpFA3nZZEs+hJrkMdP8x/mUuFcK4+5dS/rjaL5Ho/kYRI3KhCl3bNaMBcQKXENA7UQXi08DQAJcMmMumuamOx9Gg9RxZWzhmlVJwJOcuZQSm6hBfhLN0G58z0HUoLWA69GQ3jVlNm27M+DO006H3Zw5Vwqn7vykyEXwAIEmEJM4EwzSU+CdYH5GomErCHy0ECBb4yw82N27TnuvIeakZgyn4/xqJ9ARJC19EtdnKwCux72rbckHOJOtDaHGbgxlmI3HZ1So+U+IsTgNsHYQ/wMBiK2UuBQgpt+MR6XwZkoc2JlbZInjFzMGUuJBzpw3YyXW+TUEig6qir4ip9LjAFyLjQZ9wQwdp8RMo8FMVVFSYi82BeoA9buIxTl4RSJ7JZr4U9Sg7wWjNBSgcgzJH1uoib0e320trm/tuHlSCgPB1gyZXE0dMXI3zNg140597VGoOMBr7jwwYyHuPWZcdOdFrP2dAN8jiO0dzJlsMux4jJg9UAD5VqyHFOc+F2t1CAH9fde82qw7P3HnTcRMNTkLKE8IVCzFfV+J7zyLgH5/XPs+BCCGzHgPeDeuz2ocp9800/oijr0YmwAl/v24yAFxgjOg/3Gcc70hQRxzJMDmIAJ88wiMthB4vIbky200L7kb74c6mxIE5jbi+3wHugydm6S0gyY2bNjEeq7EO2MXPU+vueICQMD1LpIaHwZI/O24DhdN0tc9YD/Jgr+JNoRGgUfQNfkZC5DYZ8ZJzFGOmBjkhybGso1UDZUp+gCXZLkV14BYM6dxTacCRNdzgROmjaMBM0WGlEIrfn441sZwXKNT4JE730yJj0vhCno3tOJZfW1n52s/A/dl/o4csyn/jv3Or/qUv77VA29fvHogrle9+rdSP/Z/+audgXP3VTN7bma33P0e8Dso+upT4B8D/zT+/1/8Vcc6DYCybcZl1Ng9jpMbAj6zM+njiGle5GYpbEaT2URudAlJJl+aGLU14EHOjLqsxGu79YQa0BcxK9ZGkqdPXLNDM6g5G0fN8W3XjMwJAiN7cT5LKJh6NKVuM70ZjU47WI3iMgmpG9BTPwvX7uOswRyJRn04jnEE3G+1WO10aCE28LxLGnhKMDKoqW6gJgoEpj5DocUzKH+tCgA6j3bqa4v6deTYhytioGVnjn2ncR9qA4Nhs25DPYxkassIeOy65oFOULNd+ZlMaspklNCxMyfOxyFNHUBNcRPAlGs25mI9f4GA7qvTMu+6AoX34l62TbNHT1ws44gZr5fCSkpiP3LmKrCZM1fjMzOyfWvkzP/N3pv8SHZlaX6/c5+Zm/k8h3tEeIwMkkkmM5PJqhy6slDdVd3QQmoIWmkvNKCdIEAQpP9AgFaSNoLQkBZaCFJLarWAbi1aUqGra8qJmSSTMxnz4BHh8+xuw7tHi+9cM2YLVVmVJDODpF3A4BHubs/uu8Pz893vO9+5EPfVsWA3TcYku2Z0+n02ej0OgamqYqqq2B0bG0hMZ6tKElZgN6vu2ljOPHWVdzgL8O05c5gSU0iqO2tiaJYZliToxlgcxfd2TczkAgqsy1w9Zyq4be6D2l7jSEoHaFxzVrHrkNzdjfcdutNx5WAdxLjPJJVq2M2q5/XDuLc1JGHdL+sjPrMfe2vOxY4/hAGLXdZhYWJBAGMz1lGFQNol4CbaW1sxx1cQw3Y+DmI+4JfNRxwZeGyidX0chziPY81dNBW4P8iqNfZxXXM+gMKGGd+N6yQkx5xyH7DzR0Sx9jhQ6RDA3B1PiRVgOmf20QESSMo55s7XkOvmHFrn7wRQO4i9P4NklZ04IEgBlu8x1Mw9ClOdCrGTL6L8vGuxb15C++8w5wFYrwPY7ZoNclYPXUz4jBmtlHgC3HCnlxInMZ4zAbq33VW7L+Zn052XY5777mK3IxfzpovtK2VRTmNNPox+17EGSx3Bk+jPrjvfMONRGPx0XUqHRXfe5avRPsu/kaP2a7YRcPvsmo1qOI7aqD1L7dPWgfuPgP8p3LVuA/8BipP+VzP7R4gU+fc/5WeM2qiN2qiN2qh9Edvob+SojdqojdqofebtU5UR+KzaN6vK/+epKWbMeCNOn+eQDG4fBk5rc0TRXzPWzdhDbpWDE+Z4352s2ljfR0xNB520t4v7WUqMu/KrLoTsaQqdJJ+ZrL77OXNkxndNJilnwSLVwGs2dHx8gBL/98x4HrGEH0c/zyM5VsN94ES47ZJujqN6U2vRp013XgD+otfjbjhqZpeT3oFJJrqAGLZS9Pixy+jjfLByIEbjBEUIOe77bozpdLBsRRbXQ3KsfVcdrZVgM4nr/9CdfxAW//uI3TyOz69jPM4QO7iGGIpjM/quPEYQ07OFZHmbFm53ZgO55Wb0s4rxn0cRzT5iaWaiP03EjqTo90KwbF2TTLEBdHPmm1XFv4KBO+eqKZ/yNExM9qMG1kJcf52o74ds32eAm1FHazolznLmtZS46c7DGG+ARlXxaqPBTKPBVFIx5OtmPMgqcF6MHbLJwXPM5TRZZIZdhuzrsqso8mN35sKA4shsYHk/Z8brWfXuOsFubroMNMyHNfdOXSUlvLDZ7rwV7y8Fzy8i9vbUbMCeHsYcfFL+1kMuox0zzrmMMKaQNNRNxiwrKdHNmWkzPg6Z3GnMKfHvRszFXcQu3Yo5XUJy6FW0d7eRvX4dfckMT5eaSJ64Hbb8rfjZOJIENhGz/YoZf+rOhCv3bNed6ykNcvvOTNLLKZTL2Y5rt5CMdQXJfzsxP624/iuo3lmpl3joyi3DJFtcMElo9+NelmOvr7gkq5PuPDJJc3MwVXXc2wFisW8D34l5aQJvm/ECkhxml/x51iR1nTVJrZfNBgXBiyMoZkylxCOXjHuSYTH1F8z4SRi0jJucQeucecVUtqGM9Zg7jZQGtS8P65q1GJcPyufE7564FAUt90HB8tKccDSNPryD8h/PzHjl4OBLL6H8LNtIQvlrtBH79vm1ZyBuHLVR+7K2z11C+Vk2g0Gux4LZQCq0GLKgkt+1CYN8p+2cWTTldNURPGzUtequmfEdV45Q151TV27arbjOSsilXgDImXsBSh4BV3KmEcHWefdB3kgjJdoIjGzGw+syQyljI4DihyFTy67izC0UDB+H9Kxtst7GnYe93sBO/DBnfhr3eBrvezUAwAUEtIprXwNJTJcDsBoyPgHJ315AUsm1GIOrBDhFgetzKIBrI0mjm6SrEwylmA9R4H0QP++iIHcCBZ2XzLgfn1eFbGwuvl5DBgogkHsMYMrDOYhrFve+VRQInplytIqRygwK/kqtudplmjFuKlHQivdUMabbcc2PQ7rVRXLEfSTbOwr3yC4qW3CcEhsBQJbjelNmfIhylDZSYjvMaB7kzEZKzJiRAwxMunO322Wy1+MIuFJV3Gk26afEDTO2o98LAYJ6JulfO4DsfKwdkMzuGvCNnPmRGS/GXB8iI4xpZPRznDM1AultBAa8rgdGL49d8tNjd1bceZISrQDrFsDhfZSA465C8h0YFJYuro8fAs8FwNmqawHuGNsLyNzkGBgPgGIB4NsBPkotsKlYc10EUkqtwz7wVsxxkVjOoz20ZcqvvMwwt28d5ceNhUHHZbQnj2IvNUw5XT/LqrXXiQOSJZNt/VnMxbkArR/lDCmxn1WGYxcGh0CrwP/F0Gb/wGS+U8c1QUBzI8a5YTJd2TUZ09yNcXsaByUWhy9lny6bzI6m4lrHLrfMl9D+2nPnRTNeDRDeikOD3VjPiwCu3Mh3XLJMYvxmAkge5oyb8SoqLdFOiX7OvAWDshQVOnjpx7yWBKy+Gc3YmxOx3uZMucKzqBr1zXg+FXl1Fdc8+8QYzbnzUfx7MfpxJZ7npf7hqI3a59ZG4O3zbTaSU47aqP222zMB4MqJd4XAxxNTjslx5KCUwHIHARFPiddy5g5hj41KEEwj0JHd+VN3rkWwPINys34nrvMhAgSr8bnfCeBxK2fls6Bg08xomJi+30en3C0Y1Kc6NtUuO4jvnyHweAn4KNiSGZe1+3kEXJ7WNU+iBtueD0sWzKMg+hT4Q5OV+p+58z13bqPA7yY63d9LiZWsouVjKHj8TjxMH0XfZxjmETpD0HfVjNuIDdly5VIdBAvzAkOHuK8Dd+Lezwd4mgxW4zkz3nfl8e3Etc8FAFtAbEp5tF+K39lFLMOEyejjNgJqPRdbdxzA8m3k6kiM6WHc1w4CLl0Xg7nlsmJ/CoPcJw/A1nFnLMBvBfzQlHtDrJ+NqqLpzvWw0l9qNJjv93nXndWcuZsSk658xFxVdOqahShV0AkA1zBjoa45aDTYjnyzOXfuurNVVZw1Gqwgs5Q/RP7hyZ2DlFhyuR02o08XwoV1LCUuxfg1IghvxO9OuxjjbwBPwn2yrmvqT4x124bmN9MIYHViLWQUSB+h/VZcJJuI1XzkQ5OfbyH3wNcCfD6NdbiC9tFRAOSHMYfl/ycIRF6I/pzGPm7GfLViHU/GtcrePI+Y7Hbcy0mMV8mBmzDlernZoDxIRmUn1sx4N/ZFZcak2cCs5ACxRQUIVohxHA/joWNTrtsheg68HevsZSK3LtZLip8Xk6WWyUxk0VRQ/OfxOy20j4/jQOTEdMB0LkpMNBEoT668MoCVKOkwaTZ4lj2M6624cvXGTbmp29GH5+Pg4vvAj2INzcXcHJiYurGsIvO9nNnLmXMBrr8XfchR6mLRjI9jfYH21y4C0LcQK1mMd5oMmfEFk3HRnMmo5XzM23aM0XtmzAeA7bjY6BP0jCvuoqM2ap95GwG331wbgbhRG7Xfaku/7Q6AguFbZsylxK1Iuj+tKvYCQIwxtJW/aEa3rvm5y1nxSc7s5sy8yzGvg4K0M1etsIQCqUOXZf9OBFJTZoPSAxvx/QUU3DYi2HCXccN1d97LmdsoeFmN175LsnaCAp42ClCOc+YgZ/7AnaY7H/d6/KTX4y87HX7a73Mhgst9xGCtIamUmaRVRfY4j06uT0zSwznkTPdinNo/QoFVzpl1d9YjuN1HwdQlxL4Vo4IXEdiacjkT3oWBGYYhdvFhvD5CJhHLDF0Ea5fD336AuAP3QS2xjQBgHmPai9cRMjRI7nzbjIsuM4MVBLTHA4TOoICxD/x5XGMTgY5FBDgPYx0YCqxvBnDKCEAepcShOxs+LMFQA/MpMY+C6yZidmdjjufMeL3f520Y1ASczHkAip5G+YE54MWUmG40mG40ODSjU1XsoCD8I2ArZ+aBxX6fR2dn3Op2OT0748/rGlxF5cejpEW593GTS+EUAlV74YyZGZYD+MDFBF/KmY2c2UOS3i1UaGo3Xu1PzO8jj4L0pvpc2/F1OsZk0cQCTsYhQoWY31N3PsiZy+7cQqD5VTN+EuPRi89ejrG0lFiK/r5gxoWUcJPJRgs4X1WkuL9LZmwFUOmATEAQQGggBmocGaP8LmJvnyCWZ8tlvLES67IZ4GgDyaiXYh3Nu9jHpwABzspafBhjkhAwuWDGnomxm0TgErT/ZxGYm4g1kZBZysXYi9fiHkpdP4vfP4cAnMe9TphxGL/XizW9GWvvBEmsz5tYuTbDg6DKZRIzg0DxSezfM+QIeTdn3kQGMFdibh66c5IzYy4jkuWcSTEeYzmz486WOxaHEDPAE3cWXYzqMdqvTTN+Gmuij6TTBbAvIfB2M/Z+K/pdx2HJZLzOxdzuI2AJcg/dT4nT9Ez82Rm1L1sbgbfffBuN+aiN2m+tPRMMXALWUuJuMCXZZFe9D7wKgzpXV4H1uh4Eas0I2s5QILHAUL71LXQa3Iygb8fkDAnDoHUK5aSNBSBaQAHWw2BmbptymS4gILUStbyKbOlKnPbfd9m2zyAXt0fu7NQ1/2e/z477QHo2jYLyD12SuRcYsifHLjlaB+WStWMs7ric4z52FXg2k2zyxIymOx8ihmItrrMVXxfi6y3Epq0jpq6KvmQUXL0SP2sg0FjFvdUo6Cz19ppIXnUa/Sj3X4pSTyMZp6Mg/Hz8jqHgbg4F/vsM2YozFKxPAYdxrRsoEN5BgKbkCt0PQFACxTaSjB0jVmobBZzfSYljFOSPBaC7VtccxX1dBX7hzngwXGNmLOXMG2b8wJW7dBOB37GqohdA9wKwW9ccx3XOxZq67s4dM76FGMqtquJJXfO8GbPubKZE3etx7I6lRKeqsJToBvABsR6HJvlZyyK/zOUMOu6qZVbqGB6aimOTVVj5DpITg9wm33Tn60gu3Ix7ucAQPJwGWGnGen0b+EGss+IyuoKC9Wsxvn2XLLBOidmc+cDETDfdVfjejKsmdvYAWI4AvZEzj9xZjJysKQSiWwGcPnZJAnvocKCO9TIXhxPFgfQMgfe1WBeHMHBOLQXKtxHYOkYs+Iw7H6REhWqrUa4ba/A5M+66asbVZnyTYd20912M+Qzai0em0gylWXw/I1fLiehjB1TfMeZqmVAMxEGSR9/qnAeyzpOcOQgwndEenQ6gOeHOB8DXTJLNXXcuRh+WgeWcBzXurgE/c+fbKbFU1zwxlROYi36dxnrsAUfhMDkVz4I76LlCWefAq/FM2wYuudjTG8g+8SoCs7vuPI57fBCS9tK6KFdvKdba3bjW1+Er40I5ar+hNgIRv91Wxt9HbNyojdpvsj0TJiYvNhr+z2ZnmXJJ+o7dWY7A+RgFfRD5We6MIRB16qrRVGpNTZkMSUpQshvgp+uyOm/Eg2YdyZM2GeZ97SCb7Tr+fxWxYgfu9FNiwiUHKu8pbcZUyqAJfFjX3O/3OcqZZgRwDxFIKkzCGQqkz6GAptj298x4151XTSYgh/H73ejHrItdbCIp4jQKMDdcuSn7cW83GOafFSOYI8T4rJhxzyU7u+XOFcSdLKUjAAAgAElEQVQuvISA3zhDCdQyOo0vOToQ8kqT2Uk/mJQ2Yvc6KOfoSYx5AV4zDJmJmyZJ4JUI/jZsWB+uGEqcxnsqBCpLofMjM64hQHrJZLxy0ZSrM5MSKViNuq65WlXcQ8DgPAIHEwEqOiiQXjLjh/0+L6ZEivt9Kz6j685sSpK3xkFBNuWLzUR/HgPNeG+7qrhY19wGWo0GrZyZSInbdc3lqhqYPNwBZnMe5MjNhLHKarDNz0fQXExdnnfJOO8g1rOYYJTyAcexX4okrUYHGDMmSeOOq9B1L8BhDwGO5xAA6aN9sO6Ssb4Q93bfnX1TuY7ZmJuaYR2xtkkWV5nRNuWsHQRLc819UAPw1CUVXI37KWzNx4hVnUZy11IGBBer+Fysg5IjeC0lxuKwYirA2pQ7rwFvmCTLD2PvJ5cZ0B0Xw+mxb4l5zyY2vrC++4hxm3YfMIO9OOgwlCd2iEBnqZVWjE6uMWSp67iv75nx83gGbaE8ssmUOHOx3m2TJHUtrnXelBv2ftxvUQdMI3nkNbR/2mg/d+M5VjEEkaDn5ItmYv9c5j5biDG7Hnv1w7jGE7TnLCUVc0d16ECHMHMx/o4Oh7rooOt7JkXEKcrxW4j7fmDK97tqNpDh/shl2tML851NM/o5S9oMfOsrUAfus2wjE5O/oo3A27PVnoF4ctRG7YvevlAmJgmxG2NmgwC15G39HXc+iofCFYscF5ecqoWCjY4750yufSUPZ82Mlin/aiqCuDIahgLGNTPu5MxKgLxFFGTeRwHyJjJQyQH2piMoLIBy252tnDnLmZs5M50zS9GnZDLWaCOWY8blVLkIg5p3NUPGbMKdP0SM1Hr0o+TmtOOku40C5bU4kQcZiEzG54AA2WWT6cBegFxjyBrcQFKrJRTITQK/QGzgNjKkAMm8FpFhQ5E3jsW83EIyxCOTBr5GAe0VBLZ3GToa3o3PPmCY69SHAQPxcoCWSbOBlK44AD5CJ/3E97biGrvuzKTElstx8CxnXjPjT1JiPCX2CTYU2EyJVs48Chbmgtkgb6thMmKZBXJKPBcB5pOUuOWShD5Jiam6ZraqWIo5BTEWVxCbanXNHmKR38yZxZwFqOuak6qCqqJd17RzppMStRnTx8f8IsZosdUiNZv865S4bsYEYq+2U+JP6ppLAU42EKhrmA0KMvcRUAIF5ROxzs2VIziBjGs6iBEpboIWIG08Dhom3XknrnOcElfRocB1xJjMIMDYjZp2CckyT1x5cjNmnKK9UxxRLfpUWN2nLgapEyDjDkNznoVY7wuxr5+aDdbiYQC7xbLm45DgposxPYwDlCsob/NtdPhxwZQjWUKKdbSvs8kc5ClixB65ZL0fxjNgEQG74wAk3Riv4oha1uYeAlxtMx642Lufuw+KZs8DnZQ4iPW+GJ9/0WwATg+A/xexg2Px2Y4A2VUE0M4HQNpDbN5UjPkCwzzK9QCm5mJpT1wS7NPYN3X0dS6eiSBwWWSO5Tk0Z2L+92Pe5nOWzDTGetuMGzHeJ0i6vBQAtOPOh9GfWTNSzhwBD9xp5sxyPJeKi+WojdqnaiPw9uy1T87JCMyN2qh9ru2ZSEZoosDlcRRCbnsUHc6Zt9w5jbyJTeQgtx6/30RBetckOzt15XJ0kFxvL2fWch64s23G67yLQTqOIGcmgt2SO7aKQMqqO7ddeSNjCGQdRs7dbs683+vxz7td7tU1R3VNCxlMLMIgkDlFwfFkAC1HQVIHnaaX3KyMjE/uIlbuOZc8bQqd8O9EANWNftcuOdQJCoj3UEB5BZ2oVyiIfS4YimKg0CHs0YHn43NP4v/HyHXvIEBOyf25F2PUQmByMd4zjsBqy+Rct+vOuZRYQ455rQCPrbjefZR79QABNUOGNaW4dmF7nsAAhJWcmjYKZC3urZUzUylxUFU0TDlalz4RWCYUtM4HcCv5S10zJgLkXQlA0zKxSFspceLKA3vBjE6492VTqYKP3EkpkVJi1Z0/d+d8GNIcoqLpVyLv6Aow3WhQ58xEv8+TumY+wNe6Sy7bcJWY+BedDjuHh0yenNA9O+O036frzmZdcw6xbpfdueLOiYl9LBb3qyjgdwScH8XeaQJ/6WLF2qZcu404HLnoyhOczZk5E3N5M36vHcD2sYl9+1GM/QkyWymmOAfB6oyZSjj0Y87X4vfbwMUApM3Yj7NmvG3G3wX2zJg25Z91Y20+786iGb+I/V0OHjrIWKQfc9NGByR9My4CuynxdcSAuTtzcbjwusuB8gixyWsm440+OuToB3g7F0D4RTPq+H0CmOzG3pg0STUt3rfIMEdsL8CVxX4n3jOHAGwpZH6IgH+Rg66hZ8GqSd7djoOZDXR49KoZ4ylRxby/gg6nxk2mIY8Z5ve13Xk+9kor1ksde33axdIbYuwvuJwtr8f3rrlTxat2HRYVtcMuAszTKBduJ2d+FGv3AgJnj5DU3WCQS1eYVYu1MGWSmxcQPGqj9qnaCLw9+200R6M2ap9reyYAHC5J0XgECk/ixL1vypXp50w/Zy4AKxG03XeXgyEKGKbC5r2GgcHH5QhOxwJ0ZLOBpHDClfPjKMA6DHZgM4LeHjqxP4eCv1N3fpYzJ70eH8XroN9nMWfW3PGUZH+fErfithbiNWPGpjvvBxDsE454MDAzGEcB0ioCYLdRQA1inJZNdeZawFbc1zECgUcIoJVck5dRoJhRKYGbhdWJALvkoD1EQear8e8UQdkF5MBX6qTNopy7Y8QY1AgY9gKYngVwTmbcCaaiG2BpKYDdTATyvZiP4r6ZI3C9Ev06RYFlm5CIxusUBteeDpDRqmsW3TlwMYqDWn8uxjQBvariELGLpdbYk7qGqF/WQkF/L2daOfNRzENxSvw60E6J2znTQMHwtDtPzFg2o240WKgqNmOOtoBOs8kDM/Yil/LIjJWqIqXEUkp8HCYp0/F6HuVh9Xs93jw95f85PubhyQnz/T7NuMcHMT/jAWJuuySVBx5GOtHfKzG3p8j4ZcN9wFB1AqiWsgUrsR9uBZh6mhJPAwzNIFZnmSGwywxdSldM5S0WCWdKJG2tTXmFYwHMthCbthl780rMU4rDjP2cuRv78F5cZxmBtQspcSElaiTtm04JM9WA3HaxUEcmdmjDjDkznkuJdrBeCykxG31vx9zMxN74KXINLev4FBmlrJhxamLdt+M9EzHXZU2fmJFMBx2dOJA4F+N9nZBfM3SEPYnvl4OCVTMepsTDlAa1E5umnMKLAQ4TAtVH7uyYcsn6Ziya8TCA3hzDA5clk0ttH7GFZy4DpYuxf8652Oq2q54hwJ/FYUMPmTBdRpJai/VU9uM+eia9H+N32eWs+xRYyJkJd97ImZlYV9diX9/MmUuxtw7CXMXc2cxF+Dlqo/a3bGYjYPBFaqO5GrVR+9zaMwHgCnuwhdioa6acnTvoVH45JZZTYgudbD+NoKMyFRmuIwC7RVjjx4lz1+QENxkBXJUzVVahZEPudY6K0zZRkHLFxChcRcHmz905yJmn/T6prjlg6NS4UlUcpcSmO826Vi5Y9M2Qm+IpCnorM56PotiFVboRp/GHiHUqssmOGedNBhWbSDZ1AQWEc8hd8ftxoj0dY3jkzlEEXm/G9/vuvIdAxz0EJm8j8LiKQOlejN0kCjA7hM08Q3e9BzCojTeGwNUd4CWTjO2qSZJWAPF78Tm3EdBeiD6vuQxQZpAJTYXA9hEChSfx1YNluUPkACLp5FgEqT0kSRtLiYtmXE1JDFKAqLMIymfN2MmZybhujViyGyZ53nbOA0byzIyDquJyVdFLiXUz9k2ytBYCv/243k7OzAKH/b7yyHo9LqTEH+fMqam8wF6/L+lgAIIzd97PmW7OTFYVDxEjtGYqRXHmYnHmou/r/T4/OT3l6PSUTq+HxVyVEgnfRGUCeu68ZsZr0dcOCvzvunMhQPcYAm2ThOV9SpzYsLzD9QAoX0eA9X6M1YGL7enH1+La2TBJExMhsXXZyd9EIK4VY1okwo0ASsfoMODAh8W3z5vs5rdcOa/JjPmY2/fcec/FPjVNhc63UFkLEKvXQgck+7Gu3zWxjfMmqfMZclVsBvhaMEkEz8eaPjTjXozDCgJ1fXQg1DZZ8i/EHr5vxv0AcDmKis+b8tE6phqChhxcx2P/lP15i2Fe6SbDg5u1eG9Oie2y/+IeTuM+OjGWP4/xn0DgeuYToPKhCTS34msz3HyP0OHUj+Ng6oMA+tdyZjX2512XIcyTWKPukoOuBAh09Nw5jjFuIvbvJGf9Acl5kAe4njPrAdCmTJJJol/lWdAaBXWj9uu00br5YrYR6B61Uftc2jORA+co4Fwwk3sgOtnvBsOzFwHBiknqdBIgq+QAFemPp8Qr6MS5QiDhGMnKunG6Dgqk1gMkjMHADbDk3e0AT+qa7Kq9dTGkZhsoAC3Ft+cCaGHGo5x5OfrSR4HttEta9y10ir2OQFNlkkoSgSzoBP82AqwnJslnG+UIfUQYfbgMNdbM+JFL+rVsNnAXBAWgxfb7kGHR3BsmCd0kApWd6H8bAaQZBIxKbk4BPTnGa9fFzt2K900jx7wG8McuY5JyjQZiHECB72oE9fdQPuKHcf1zrgLJkzFmfWRRvmhiUJsxjwDvxHwummp3VRHMu4mBmIm53ACakU+56ZIybiP5JQjg3w5w8xbwGjIIOQwQdS4AYNudhX6fR4QzYlWxHWwY6HBgzowzYKuq6LjzHSD3+7wBXGu1mHBnpq7ZqipmUxrkFDZcTOyjuNYWkpbiYhhXXKzLrCu3aKfT4aTXY67RYKyqODbjSQCHZMbdT9Sm65pxDoGyD1xS0D2XZLN2H+SBVhZGJEgCiNkgV+xGBN4vxtpYjD63TLlePeT8+XaskY34/zpyQiz8ymWiILzJuGMK5dGdxvu6KNdymZDixprfNB26vBLXKcXdH5nxYvy8Qszge4hpz7E3UvxuHYBh0Wwga1xy5f31Yi0XhvFlM6YCIC4h9nnSJcN0GxaxPhdrqOWSDS6Y2LJGPBsw1bsr9vozCEA5DBxui/S7MJnrsdf/vhkfmiTCJ648sZsol+zFWMM34utB/HsRKQaItf8IPct2AtAumA5HFtDzYQ7txdvRly3gGyZJbz/urW3GC6gO306M45jLLGcFucXm+PweOnjqm8x/DuNwgbj3BmIIT10M/FzcXynXMGqj9ivbaK18eZqN6saN2qh9lu2ZAHAGg7pixyaXucqd8+H+mMNB8H3kUDeGAsMxlEtzjIKNNXdum4re3kcBRhXBECbjBIC/QEzfLeC7KBAdDxZgPViZR5HL1k6J5yJQNDM+AP6t+KNyL2dmTczHuQgii233dgR9bSRr3I/7LNbkS4gduB59+gViHrdMxhKbiFlYQTK4GVPR4Cn3gWX+ZLAWFTJsAAV4Z/GgXESBchsBl+Iut0wUM0dyycICriIgSdzDhCnfrtRf66Pg/mkwLvsRIM+b8oX2XO6N+z6USB6hvJ1SrHsKsZuGQPQMCiSXzQb5PJuIuVhGoABUM2wDAcqU0iDP64YZ77mMXWp3khntlOjFeJX5KG6WYzE+t5FUsmNilJbRwUCxcW8BTxsNenXNsjs/AV5Libdq+WvO5UwjgllyZj9KDrSritWcWe732TPjQVVRAe/nTNtsAGKPUJBPrImj6F+RdZ53Ge9MuZwcWzlzv9PhMCUmGw26jQbHJpZpOdwsH7qkn2fA3QAf91H+Vj/WxlqMYSfGoZhwzDGk4x8js4oFVwmMb5tkgsWoZip+XrlcYOdNDNAcYpUOPjHWrQDSG0i2PBP9mUR7boOhMUc7gEcjQFc5THiRoWvmQqy/6ZSYi32xh54DxTikildt4RwZe2M6rn/BjEsBNnLOvG1iuBvB8rdiLJZdMsK3AMwGFv4TRH2zlHgQh0QrsWYfI2BVuUxaSoHrCbT3CoNd9kcPHdIU45UNBMorhjmAH5oOWjoI9L4WfTqOfQgCaC/Fuu3HmnoY91AHW7jB8KBmyYyX0CFCyW0k+lCjvdEyGavcMB12TKI/GI9jfA7jsGAHPeNqs8FhWMlDPjQZwXyMni9vuQ9MoEZt1P7aNgJvX75W5nQE5EZt1D51eyYAXJ+wfE+J3WCJKhtKvA5js8+b8Q4K5ktx7yMErBYAgkW5ifLAtlCwtgl0ch6cxM8Ttefi6+UAb+265kOGxY9Bwe4/jSC2G++5Hz9rmHEYkqOUEjvAeASjU4j92oqApW1iQiyCsw4CcYO6bSYW6QE66S+s0K0I6CdjjEpw1jTJF8+jE/BSK6+FnOlK7lqXsEpHgVfJ6ZsxyfpOIvC+jMBScbPccRlsbMe4nyIjk4cM6201TbW0JmDgkHc12J5iJ96IIHgtgsvirHmKAGsnwEUjgtHiYHkHBZOfDAgP494O3fl6AP2D+Jwpl3xwPWeaAV6WgffcBzlmoHysV0yMyRZiMJ43Mb/bAYCmq4p7ruLH56qKLeB3UYH2ywGWHgVbdJQzV5EcNweYuNFo0M2ZFQRGDZhIibNej5Oq4jRnzn9i7lvAt8xk2BPg7hySkh4FiP8ZMtl46g69HvP9PrfMuNpqsRn3NhvrrBwSFCCyglibAh7aAfDLIYLH2jiO/kwBv2PG6zHuTxAQOzMxrm/kLAdEM35sxg9iPscJl9S4zp4Z54P1mnXneuzpx4gVKmY5l+O6r7sklVNmbEfOa5mzCRjk4BlwmjOLUfOvSGCbrrysHPe5iJjSAkyfljFy51+byhtkM14ysbpHAd5P3RlPiZtxCLKK9kO5r4NYsxMIjJ4FkH8jZ+ZNDN8xYqofx8HJnbjnGjHRBQy+iRxge+gwpbDT9xFT10Js9jsEKI05WUMAqqyheQTYLsY9tdGeqFPisUu62Iw1V0qZPI452SDKOCCA/hDJlS8iOXQp8F3KmHwt7mvKnQOTPLLjkvOexFqcNLHYbSQ97ecsOSuMANyo/fVtBNy+/M1GbNyojdqnbZ86B87MKjN7w8z+Rfz/mpn92Mxumtk/MbOxX3WNCgGd+yi47JrxsSkPDpNMcDmCvBUEYo7NWEdg5iKS9NTxnm8zBFnnUMDSMxs4v9Xx/ac588/7ff6k1+PNfp8jd/Zz5sCVjD9mRidnXk6JHTMu1jWTyCTAXPKzUxTIjUfw7ojR6yJXvKbJiGU7rlfakcuq+8SUU9MJ8DIXQW0nmL8WypV66M47KJDaQ4BsCZ3uz/uwVECxDi8FkneI/DYEqiZRENyJ4HTD5cx5E+XMFTfLOoDvFAwcM49M+Tib8fkHAcqm49oW90xco4wHwJ8gRq0bgK7k2jWRtO8AuOVOP1iZiyig3XcXmEUgt4rx3vShCUYKoHkz5rkO0LwPfLuqaFQV7TC3WIwgvzCTM2aD3L0LCIR0cqaZMyklHgONfp9bOXPmykHrBHC+bMY3U6Jhytmad7Gu94F+o8Ftdy6HY+nTfp8zM76dM2tVRW3Go3gtoRy1eXQYcSHWbDaxsbcQC3UU/TtAwbflzI9PT+nEK9U1xy5msh1zvmThbBrr9iZyDgQGboNbCOhMx2siJdV7i8/bj/Geq2vtx5TEOJnxDTN+EoWpV0xs+JN4zcR41C4zjdddZT6eZ1gu4jICqtswyJXYdEn6niLQtRzruJT2aJmxY8ZDGBR1dxcLexXJZcfLGmV42PNC3Mt7Zlx0yYwzOiDq2LBswXgAze+aDZxYlxAzlmzIJj1C+2861tPFlLTfgY2qUlFvUy5lyR+dibVWckRX0aHNg1i/Hve4G33/WvysjQ52ziMmbTxAZMk3vBlz+MBkFtMgjHFiDSzE2E7E83UaPY/GGIKq4oY7Ff0sbr/7sTeej+fRu0iK+Th+rzwvZ0wmNnUA2nVT3uRszqpFlxKLKfGUr1b7LP5GfmXaCLx9dZqNcuNGbdQ+TfssTEz+Y6RuLO2/BP4rd7+B4pB/9KsukM2oU6KJTn+LE90CCvIvxms/alBNmYwTXjHl7WybDD9WUP7IuTjxr824hU6VKxgEhBl4o99nu99nMoBUy+TGN5sSY3G9Y8T4tFG+1t0oyjwXr1N35gIYHLuKJt8minub7Pv3I9ifRIBmn7D2NjErlcmivodO3+/60K6/sA076ET7mya3uXGUt7SFAsC7DF0oS6HdFINf7t1NUs+9+P8cAsIvR1B2Ln6nmBmcoYCVCMJm4rS/QsxZz4zLcQ/jSA5ZWIUFFBQfBqNy4M53Y2w68dkvRx9/kTNjiBl5Mfox4cqJO3SZnjQICafLpXQxgNyeD+tVPXU5NK4G2D911Z66nzPduh6UfjiN+5l2ma88cNmmT7jkXmexhropsdvv08uZJyZW6BDJ7BopcRJOh+/nzJEpT3PXhqUHDvt9Gi4nvr4781VFB3hYVWzVNfdzHpiGbCLjigoBtz2XNPUQsT2ljEJhLtdij2wEi7ZT1+zUNdtnZ7xxfEyv3yeh/Km9YCZPgfGUuBDrfyHmrYGYnH4E9dOIbbqJ3GBXU+LFlHjB5KR5EHNziljHWeD7VcWiq45cybucRSDuNjqUODMbGKB8EJ8zFevLY79NmiShl0xy51L64WOGLHJGQOWSyfHUkPy4AbzjzkRcK5sOfKY/scfeR2zWSwhwLSCJYxPVNeyZJLSnJuOWh+78XqzxtkmOeh89i0rx9zGTw2Ypb9GNz5pHgOs4QOVSAM6PY98txWsSAafrpgOmIh8+H3vkz+PnfbMB830CgxqT26ai8BdjbNoB4OrYi/sICN5Ez4PzsZbW4/P3Y67KAdAmQ5a81K375HrpmXEZMYrzpvzT62H6U/L6iPEZc+X77pTnW87sBmv3FWuf+m/kl759FYJ5S5/u9WVtX/Z5H7VR+5zap3oqmNka8O8A/33834A/Av73+JX/Efj3ftV1ahTUzKMT3TUU/PwkwMoH8SJn7iM7+aM46e4hdmAKBSPTKfEABR0NBBg+dme3rnkYryf9PnUUSu4h+d54gAUH9kIKdexOrir2IxA5CZlQAUvPB2P3NNisHmICJ5CZSIwJHyImroCODgJlmA0KB6+h4K9pkiTNoyC0PNr2QUWzA1wtoEDygKF1fJFaziGg2kGOeER/OnGd0wC+LZMde6llVRH5SXHSX/J25mJcuijo+xCZsewgBtEiaJ2M9xSTmQZwO2cOgbfdJSeLk/uNmPfnTXlJZzAoU1Dmrln+qJsknCWnbd2V19RHeVRTURKgh8xWPMDjaUocRyHiXYZOg88jwHQnwP5qjAl1rWLYwEZd04o8q0spMZ4zvZTYjIB9IiWuuIxzzJWzeCfmbhI4qWtmcqZlxnV3ntQ141VFr9/HTU6B7+bMu1Ge4HqwU5Nx349iL5wGSL2NANE5U/7efACDI8SkPUY5R8+7s3N6ys2jI252u1SIeWqhvKzi9HnTwoI/DgVWAsAexnXNjBspceTObs5sBABpFKCZErsmxq0K4HSK2K9SjmAauBTzeYhyKudi7vZM+YDb0bc/MBUN33XVL7sUTpknse9mEdDsBqA6jLFI6LmxYMZrCORXsZZqU1H2dQRYJmIvbKDDgXUYODX2TO6Uv4uYyiI1TCifsBXvn4j3bMT9HCPwNxngbwaVErlsxr1Y72cm05mlAHS/E+ukZWItu9HvA+A76NkyE+OygHJ1i7x13mwAUu8iY5alWMdzMb5X4trL6NlwCT2XSo7eNxDL1mXoKFnW9TKSo56aDjMeoUOihwFgz3xoCHVkYtqe5MyxOzMudj2h51vXjLHYA8emQ5BFU8mQr0r7rP5GfqnblyWA/7wB2JcZ4H1Z1sCojdpvsH3aHLj/GvjPGLplLwJ77t6P/5e0jF/ZziEANIHAx5Q71xkWwQUFM08icJ+Kf/+O6bR8yZ2P43e20Ml4HQzIerAhpYjslqlIcTdn9s2oUqLtco9bCJanR9SNy5ljM/YjECl5TqBT8OXo47bL2fBhznRNrEIVp+QtQh4I/CAl/jz+vcXQjW4fgaNjokBvgNedkHcld6ZNUsxDlwveGQrMnjI0+/hmXLMYZLxskqTdQ+DnYozXfgS/ROC85z4ICAEemBiZwugtwKDPRabZi/so7N4RCqpvMXS/XIrPOTbjcjCAY9G/Ugh5DLF9xfJ+DcnuNizcOpEc71z8/zyqIzbDMAh94s5lE+PUMOUh1q6cw2NXDhAIXLZcsszxlASSEGifTemX6uNdyJk7ZqzVterrmXHa19JuAT9x5xtmvGHGcwhgbdU1dc4sNps0zLhf14yb8X3gnX6f2+78vjsfBsMEYfUeY70SjOC4qci0m+R8v4c22T1XEe4V5AJ67RNzferOowCQh+50Tk/Z6nSYazZpjY3hJlv8bhxYJJMV/U2XGUmRtuX4rOOY2x2TQU8j5vIQGdEUAHMc4z9nxmbOvBrXeS8l2jmzgcyHnAC5DGV7J8DrBJhneOAxD4McuBdint4AXkGA5nzM0Q5iMd90lZCYQs+GLeCDWHOtWNMPYVDUfiJyVu+i0iGl/zfjIOeqBbsfa7RIj0HM2xOUy1YORsbRYcLLwF8SxbhjXRyb8TV33mUIok7iWnuuYuMLMe8FqO2aWOQOejYeuyTms/FcuYCk1WXfP4j+f4xkqQ0EtjcZsmmtAIn3TOqAXtzDvPsA3K6bDjS68f5Zd6ZMDranJqnwWLxnzOS62TcbuFXuxZqez5ndOCBbQocnbjLNKc+Gr0j7zP5GfunaFzFof5aB0l/VN/+C1F0s68FHuXGjNmp/k/ZrP43M7B8CG+7+s1/z/f+hmb1uZq/vjwq7jtqojdqojdqXqH2WfyN7dD7j3o3aqI3aqI3aF7l9GgbuB8C/a2b/NuEHAfw3wJyZNeKEcQ2pcP5/zd3/MfCPAV5pNPwxDCzmu0ji1kBMS3EQfOI+YH5W4sS34043TvUbcWJt7uzVNRt1zSOGCfrb8dkpZxZSwt0HVuw55E/7DF3nLqQkZzWXI+NxSFDNKlAAACAASURBVCU/irIGz5kc526jHKo9d56khOfMS8FcNIIF+jo6Jb8d93hkcoEs0HXRne1gT7bi1JsYhy7KFyq/e9UkV7voyifpukwEQOzCOZMhwzRyS9xD0sgqmKcpU45RsVU/QTKxMYb15MZRTsx3zAbSxz2Um3docpg7MRVSP3Dl+e2gOmAvW9TFQjLOI3T6byZTjp24djdO5HFnFQZswQ7DXJ7n4jpFuleh0/xpdLJ/G+UltVC+YTfGuRmLb8zl5Fnc8VqIPZk1OeftxDi0EYM1HnOQoz/jJinZYkq80e/LwRExixPAz3Lm640G6wxz9JYAD2ntbEpM1TVvAs2UeMmMd/t9rpsN6gkuIPbrghlvuuSC2Yf5ZC/G3thBhhHngmE8AT42G7A5ryEGezHG5CTW0manw+/1ejyuKr42NkajqmjF+Jo7X0Nyw0IRjAdLSbAxTeQk2DSV6LgUbrGPY57a7oMCz3VKbMd9XQ7J8wJiVu+bnCKPY432XMYthRV65Mr9W4t1Vlxjd1EC0bX4WuSMmPIrdxAbN+7OuynxXbTXrwIbcZ/EuGxHv7+FpLgNJO+9EOzdYbBWDVdO3Ep81gfxfhCTuBZzUYxQOrG3fvwJ5rqD2LsXgH9lxvOxpopUmPi5BYv1HCqs3QtGbpuhjLms/1NXvbt2rOPyTGjGGi8mOr3Yk3MwYMowSYmLE20LPUPaZrwbc5YRGz5hxp2cOYfkk42YuwS8nTM3UqKO/bvKUDXwXBzGJbNBfcFbrtzUsZiXHb4y7TP7GzljC18uWuKLwL49y2zb36b9m/fxrDNyIyZu1Ebtb9TMP4NNYmZ/D/hP3f0fmtn/BvxTd/9fzOy/A37h7v/tX/f+bzUa/l9MTbGGgpUpFNDOIJlWkYg9ZVhLrYVy276NJFXXUS7cW3XNWF2z6SpHUHIw9j8BgE5QUPzQJXE8dDkTXkeyzO+YituehCzrcQQiJ+60XTlJoCCl6a66VAEAd1BZgsOUeNGdN93ZRXknD02yyKfuA9v+op3ZColaqbk2gQLFg+jDYQTs3fh+yTeZtWGNL5DpCkRtLo96Zkg6NsvQla+DJE3HKJfvMbJrLxbfpbD2EZJlvomCwQNTzTc35ZzV0b8iy7wWn3Ea/WgjA4axCEgzCvQvR/Bd8oy2UIB8iILVkm9UIpvzDF0Yd9DJw6W4jw0kt+vG3F5HQLTjzjlkZ19AzmNXPuMhMmNppwQ587gAmgBHs+FA2YxrXnHluZW12Gg0aLqKpm+jeoHFxW+/rplvNOhGUL9qMnjYrWvMjO2UaJ2dsRBjNMfQvKKUUUjRj07MVx1z/IdIovd9ZHAxx1CbVZwd3wFW3eUEaSZX1visceCk0WB+bIzpRoMXTfl2FbAaJRKe5sxqHFI8cedrpny1J+5834xfxLhcQnvoicvA5zjAbyeC+BYM8jUxlcawWDsFbE9VFd26lv1+zFkdY1ZHn8dMZT1yrJcimy1utIsBBDFjPcDNNQTQpmEA3rvxTCiumi/Fv6dch0BLrtzaDWQgso3ATsmpLTLDxQA8LTN2XWUCWrFO5hF4K26OO6im30Mz5l3GR6c+LJw9jgBQB3iQMy3g76bEBy5ZowdAnQIeB4g7H98fN/ul0ihPY6wLOOy5cvMO3AfP0UMEIOdjvRyiA4fyngOUx9hyya57KG+0HWvyoTvXAqRPBSh7zyWvTK5yK8RntEx5pqux3zICs8fAhf39n7n77/IVaZ/2b+SMLfj37O//Jrr6+bZnHbh9WUDb36Y9y4BuBOJG7SvYfux/zIHv/MqH5efxtPrPgf/EzG6imPx/+FVvOEN/7At4GzMZV6yYkt7PXPXdcJmVzLnqtv0+YmAO+n1e7/d5s99nsa45jOBmyuQKuA1M1TWbKFB+AXhU14wHcDuN0+8KOesduHMUQdaWKf/tNGc6ruK8OwyBWuXO76TEkitH5RrwXEqMo1PpjskU5BgBr5eD1ajj84rF+XkT07aCAtRNohAxCjaPGQbNTVfuWd9kLHGMXBWnXazYGcqZaZhMH67E11KDqxUn9aco6PwLkyHBdYZudDn6tWzDvLOxuL++iR1tIYfBU8QoHgfgMGAl5u847uso7n/ZZFX/yGUi0YzrFWDUN5kcTKKgdjlep3HdRQTglwl2KUBa+dwKBdBbweDcRyB4Jt7XjvH/ZuTyLCAAdM6daybThaUA5uM5M+/KF/sQsaDnU+J8Smz3+1TIGdXiOod1Td+d06ridl3LYCMlnriz1e+TXa6Rr/qwoPlV5Oi3GvdWR38X3bntKqnQRk6KbeBfMrSwn0VBerGhP3HV6Tsf7MsLphymQrMvxDqc6/fpn56ye3zMj/p9dmO/lILu46ZcsLs587zJNCWbsRpAah6BmV0U1J83sUvTZuwE8CgM2SqQU2InZ8bdaaXEpKn24EsmN1mqihoxsqtmrFUV4wicHZuY3zpA1njMYwMZn1yLPVw+ezZnMONmrJlOHNzk6M9OzNXfNZXE6MXYbrocU4lDj/fRocKH6KCjFfumZTYoIdJ2Oa8WN8+SY7sS+yXF+q5NZQvK+uykxMtmvGxisCz6MGXKsf1xvG/OTHlkAfqfR2DroYt5L8Xsm7H+J8z4CLGB94GjlOiamLmeO2+hZ8sZAsMlX+02w+cQ6NmR4h6+FmN3hhi/AzMe5EwTHaBtxu++YCovccvk5ruOnmHnYpyLWdND/gq66avV/tZ/I78U7VkEb18mI5Bftz3LY2BDI7NRG7VR++X2mTBwn7a91Gj4P5meZhmdevdQgFGkbMvxe09QUFa5s2DGT/t9Xgb+rN+nVVVM1zU9FKB94M43kWHJPgp0L8V1HqFE/8fu9OK633PJn86Z5IUVYoLuRB24fs58GIFnYQYumORBrQhMz7vznkvi1kMBXz9n2iaXxg9z5rKJyXuMQEqRZRkCYhMmad1zAcSO3LmByguMowB7F7FMXcRCFIdIkGSwlFm4jYLPmXhfkYjOoaCyuO2tmtwor8VYgABXP/p0AQWepybmZDIepsvIuv27JmnWQXx2A7kJgsD4IpKk9glJoquGW5NhnboxFCTOmdjPF+J0/2b0pxXj2kVApWHGpMsAYt6dpybp3Vn09TbwgjtPYv5LcD1pYjFSvPfAnZmUWDbjOGd6EeTnMDRZBnZz5nyjoeLFcZ0KwCULnYk+992ZazQYc+ckXBjNJWFt5MwmksquAxP9Pl5L3DeOQNp49K0wzdfjPl5yZycA8evu/BEBLgIQbkafOsArprp2pRbeIwT6JwOc3Il5fAVJTZ83w1JirtWi3RDU264qZgIwTseaqRBYO3Kxxw9c0uaWuwq9x7p4GAcdIJZ4Lu6pZcZtl8PkQkrcdbkljgUAuxVgaDYCfnNnMVjA3ZxVvD7ucTw+/5Kp7lk7Z9opDeTWbbRvDqPPZd83XQxgcU9cch8cahhyWPw2Ooyo0bOmFOw+ZVjkfhw9o5om85P9GONDdKjRiM8aMx1+nIv1d4wOY4qUk7junMkkZtydWRMD2AhQPR2HN2cxxkvx83Y8D8o+a8Uzp+/OyyFxXUeS0JfjPruI8e/HtYj+9gIclzWUzGQYlTPTKZFzpjaZutQBZuvY15vutENqvs/QfXcnSlYUc6YHCAyeIJnt13Z3v1IM3KdtX2gG7lkLvp81kPIst2eNnXsG4tVRG7XPu/1NGbhnAsB9vdHw/2NqisdI1lacyt7ImZMI5EEBbSMCmh92OkxUFWNm3KprapczW41kQHMpcZAzu0AVhYZL8D1vxq2cGQsL+HkzUs4kBEIysrffRAHNFGIg3suZ79vQhbIfoOQMFMwzzFV7jEDHi2bcNuWfVfH7jgLDjtnA9bFY72eXXHMfgTFHweyYSVZYyhAsIac6XPLNo7hOYgjmKgSAWxEIriPwdoQC5ZMAsDcQUOii/DpQgHmGAq5r0Z++K2ewQkHqHEPgmZFk7YpJVrYW19lzH8zfYYzliZlyBhk6UF5CEr2nDG3hP/mnI7tyg/Zc9dsyCjxPEcg4jaC0H2OyQzhgBhgvMrrLiJUrxZenUyIxtJE/DVDWDgv9zQClU7F+dqM/RYJam/FSztQpsZ8z62ZcrirawFldc1BVVC5G98ydhaqiX9fU3S5l73VNrOOhS9J7EgH0vokJLPPpMfdrMZbbpvyz0jYJ+Wis8UbM4bGpWPi2yyl0FjGR4zF+FZLPLsUYPd9s0mq12Gs0mGIo9b0W62SeocX+dgDFwgofx3qCIdvTcSelxJQ7HyC2ObvkjfspsZIzv0iJVXd2AwjciPVA3FNxbjSUb3rOoi4fArPjCFBNuKSuE4j9PPBh3bEVVykLA2ZjLEutyTkkBWzGOF6KdV7YuwWGuVuTiDndQfLdBQs3xvjczLCAfQMxckVu/EGMdzN+/v24z4NYXycBckuO2qwZzXDLXUa5eOeI5wSwE/c2Fb9fckp7Abgeu9N057WU2Ii13Yn+jbvz2IwrLvlzmbNzyO20jP0BOsh4P/bpI/T8eRLXG4u+z8cBD4hpezkOdmDI8N0hyhp8xSSUn7Z94QDcswTaRoDts2nPEph7BuLWURu1z6v9NiWUf+uWUHB2HgUcj91522VUMo9AW8OdP+33+WfdLtvdLu+b8WN37rtz3SQ17KfE3ZD3nOXMmKu8wL6p8O9CvO7mzDwKSq65c1DXLEfw1wr24SQlzpAEqO3Kc5uPQG0nZ3Zyxly23B3END2GQVDcCyB215U3d8+Ve7VukmEVk42myRziHGIWCTanmAnMoNP3Dgqed1Dw1I/gvkkAIxsWm54zsUJbNqyhtm2q8bVnMijwGPcJUxHnHSRvXHfX51vkHaEgdQMBwcKUnaAgMCNmokZAbzv6Xa6zZCr2e2zKA/sk85fMWDPJObeQjGw15nLbfSCrJH5+hoLLO+48CjBS6tSdxv/nApSuodymM8RCrCLp4f243kJcq+8qyl65sx3Ar1j4d4FWFCnO0a9jl5mNeeQ+uXLATnKmA1yqKro5U+XMQUoywwhZ35o7CzmrVIUNpX0l33DPjBRzXQwrxlxy4UUAk4SwlGko+VFF2rcc83gY8/E01ks/1uMcAhstlIeZTCzKE2SA0syZZs7sdTq8f3jIB3t7tDsdlhEAecxQ6nkOBfaXEZiYMeWZbsFAqlwh8NdLaVD6YjGA9kGsh42cuRfX6SP267xJ6tmJV6kvN+HDciEW4/Iwng/rCFQdBECbQQB60Ywbdc2NuuZOzF0r7v0g1lU77m0t9sbfM7FZFUPmrEh4Lfr5eqylwgiXXNSSY3Y+vj4wHQSdILC1iMDWBTMumHHPJI80xJLuo/3uKE903lVG5BCBn1YAz+3Ya6X4usd83Im9VWS4E/FcOAB+Fn3di33xMXA1AG8p/n0Yz7dFGNR6OwHeM2M1njfz8TmLZnw/nl9Pgc1g6up4br0RY/sEyZpLTuGnrV0zas94exbA27MqCfwit2dpTG0kqxy1UXtm/pYWyV4DAat1d36aM+N1TS826lEwJLdSYjVnplKSrKuuuWRG24xvpcQjBE6OEEty3lVktuR8rJrYp8JGLQKPc+bUjIO6pmli5KYiQGwiYNaNYGoy+nxI5J4FINtAroDLKPDbCzZhniiu7c5zCIiYDVkzYACgjqJ/NQwYqjZyWJwJsHUXnbYX4HuN4Yn5vKkO20sMwVUx/1hkKLecRkEgLhOSVSSHmo4xaiJQehzAqBX9mTUZljTi/xMIWC6hIP8MBa/rcZ1SQ+4JARajz21T3tG4ibErboRzcd05k6yzius4ko0VsLOMAs4Un99H4OQg6vDNxPWL4U1hAUEBv5vMO8ZdeWbZJL3rmCSIhe2ZBHAfGIkUd9D7cUBwYpLHdgnGM3LjJhoN+jnTSEl5T+4cp0TfjKlGA+v3f+kPUMPEABaDiYfx+Y/RIcKJ+yBH7Wr099vuvI1AKDEWmIo59+L3l+Lnd2JNnLhY1Bx7AjMuoFyvpehLis9rufPGyQmbJycsjY3RrCp+v9Viy4xHOTNhKgS+asZHLvORH5jxfpiYbJgxkxJTOQ+MUsxVk68X6+gaYiCLfPA0Z7YQ4Pxu9OdpSjytayZT4iRn1YCMtTiB9toR8FEA5csuZsnMWK9rzsV1LrvMNuYQcJtDe7YX62sz1uovYr0sIgnvGAyMREAMUiuucxiHOGcxX6vAbPTTYt5xObc2Ebu6xFA6fSd+p+VOdtUyPEXPrTN0qHETeM2dHwKvpETHdaD17ZR4M+b+IvC+Oy+Z8s/OIQBfoUOTLSSvLczfWszPezkzaapTB3r2nMU+2EAy2NUAlu/GGmmbJNpTwP+dM3+UEr9AioDpuM5JjFMPPQ+euuStCzHuo/YlbL/tgPpZABZflfbJsf5tMnNlzfmIkRu1r157ZgBcBwXgTXf+Zb+vAMflvPhRqRPnKn5cApODumYBBfCvuMuYxJRX00ASugcoWDqLE3vi39dTgrpm04y5OBm/D3w/JW7VNadmA+nkbkos1DVdkxmAfeIPVQ4g1ghwN4/AjyOjjPs54yjAu2TGAxeT10TB2aCMAAruKper4UJ8L6Mg6MW4F4KNGYtr7MTpfJG/bcbnGwr0C5NQZI6FsTtkKKV8GzECJZgFAbxZFGjPmnLFiNN4C8D3IMDPc5/4OS7Z5/W4zhECea0YkwL6So7jvqso9QMEYDvIhOM4Pucg5uwcki+24uS/E/fTcOUT/h0Ts7NlkqXOmBjRMSRdK1KzKyjQvOcyrejH55zkzEYAiVaA9KYpL24qJe7FtUoQ3zJjJxxO50w269su+VsG3q1r2q7yCJgxkRK7OXPBjEf9vnK64t7aJma32M9343UD5XA2EIu4GPM3hcB2MbApxZ/HI6juxTpdDjB3CHwHeDcC7wUUYH8Y66QX41UkgqeI5fsDE+O6785Cr8dhr8efnp0xPTbGd1stdlGgX6MDAnfnPRi4tM64s50zE/EZz4eM7370y9D+Saig9kzOfNOMN1yS4ffiOv265oYZj8NgJhHscRwA3DHjQqzFa7E/m6jY9HUTGwyS/pW1NuHKIftG/LxtcnpdLvsCfkkqfAaDcgT7CJCsAG/FWm/Gvj1BIPUBQ7OVXvRnJcaplHggvrdvxn0E4rsBtq+7s2mGIXB2alIRNF0M/1hK2juxri3WS2K4h9fcWTexbxcQWFyK5+NPkLvsbkiI78R7ily3h54Ju+ig5zmXLLpCoLWfErU716uKP0F7tgFMFiCYEhMx1xVwI661wrBg/Kh9SdpvE7iNQNtvvz0LYC5ij1Ebta9SeyYAXHanV9f80MWwbdY1Z40GDVMdpkuxMVdQkNNKiY/cuVFVvNXrsWjGGzkzUVXK+3HnVTPeRwHTLPBmsAUAX3cfSC0bEYw8zXngxEeYJ7yfM+dd5QSumKRIqa4HoOtBsBidABRziD3pIWB0z506JY4RILtjcjEkmKHb/olcMRT47SMp114AiXsudqqPgrNTGLjxdSJQny/gDp1230cuejVDILbD0AxmBgWQc3G9c5/4eQm+J2Ag0TpzSbHcxVwtApspcRTB+R6Svo3FdYvRCgzB5ISJaVtAOVkdBMZacf+zcf9PIlCdd+cWQ/ORZszlmhnvBPg6C/bjOeCmy5xiEQGv2zHG2/wyA7cV4KAVAXsO0NYArkTAXNi0bcR+TSPQ9FHOzEZ/zyHg1yUcIXNmxmSbfinApJvxJGeVLADaVcV6r8fTGOsc19oK0DtrxmXgHnJJLPlLxyZJWgF5J/G723GPhTnbKMAzQMBVJJMbA95Ghhctkz1/350XU6KH2L5OXBsU7K+a8ge34ntnOZNN8svtbpefdrtsjY3xXKNBv6oGrO6Wy7iEuOef58xJSlyIPXs9Pj+bcqf2EGCacaeREh/0+8ykxOVP/EG+Z8YHLhZ01yUbdcQoPnAZuXisz1MEbsdMks69GFtgMDYea7IO4NyL97wAg1IRW2Xdoj0xa8ZG9OcSKkOyEdesY+yXA8R1Xc6oZzEGWwgMNXNm18TQFxb/fqyFiybZ7ssIeD6M9bEQa+7duP9zwFJKbLoUBcV06BD4/ZS458q3PDa5T17LeSDjXEQP/A4qk3BiOgy7FgcPMCxlsWTDHMk5GLh6vhBrMaOyBsllarOPDiJKuemT+JwUsspdE/M4FuMzal+CNgJuo/Zvtt9mzTkbsXGj9tVqzwSA6wDrESCeN0nMJkOCVEUuGsDHjQZVXdPImemqYr3fZ7LRoFfXfKOqJPlBeUvvRGC2HYF0cmc5mDwDFaLNmTeBb7mzEazAjsnd8AmSHG27zFHWXcV+T5HDJcjwo47rdaMw+DYMGKKznNlHgVMHBnlSk5ETdD4lHkWf+mYD6/7CaOyaGL0WCvSOEdt1HKfzHf6/9t40RrIsu+/7nftebJmRkWvtVV3V+zL7cDikCIIWRNsc8svIAGHQ/mAKEEDANgHpAwEOLcCgPxiWDVgGDMgWaIgSvUDUZluEIZsaikPR1miWnpme7p7ppfY1M6sq9yUyIt67xx/OeZHZNV3VVV1VufX9A4mMjIx4ce+7L969/3vO+f8tqvcDTAwBbHe7Ik3TToTexxaJm35+tsQkyEezjCJGS7F0MtRw8jriBOduCNT8xjhZrzMQ4XaeMydWk7TaaFDmOWsixDxnwqMuq+4pVgcIgaMhmPBGUdAoClZ8kX0qRt6LkVZREGNkpii4UZa0ypIZP4cAZVly2x9vlCUNtj0Dq4X0abXawVWMeG1gpFfYVhBcFUu7y7BF93F2+GfFSCME7jrRnMYWpRcx1cppjyCBEc5+jIx51KTyopvxx884iSt9/N6PEYmRQkws5F+o8mk/1mfE0mIFWzwPgD/zsaoETrpYamMVze34c+IkBIzknxKLpB7DaugqcYmbaul5d1T5RTH1xpt+nVfqj4t+nEoS/3WxWrBPqfKWX28vYXVTcyKc6/dZ6vcp85xWnrMQAq9m2TCS974IbbcEUD/upo/BOYzYdLAFfRThWIzcFEtNnIuRE36cLTXPtvYOwtVjW33zAnBELdI4ipHWn/Hv7Xm2ZetfYzu6lmOppes+9uKv/Vk/9opfH6dUuYJtzFRk9sdY9OqIWKrpNKYS+5xfV4vYpkblC/dz2P0D2faKrDzlWj7mz2A1cJfUVB3b2Pd4DrsPfEosGn0HE2ApsA2QU/7dnMNStu9i4iGCpcsSAorVs22q15WK1dy+722/wLYf5QIW3S8wgtfy62wFq0Nc9+sqAq+IReTfF8scmNZtj8yBWsrkcW/3ppotxndjZDbuYcpVwuNjr4jbASFtEh79/Pw/114fPv7KMw+n7aPxABCVaswSkUtIeOLYFyqUZ7NM/4dWiysAqtRCoASOx8jzYr5DYKmS1UIbNRn4lzBBgRMhWHqRWoF+ZYQ9hS1QOqrc8OO0gGe9TmUthGFa2Ri2YH7TU90qkYyBmsjFEkZwGn7OIrawf8UVC69jKURXfZF+W5VzITAKzHt6ZxfbLT8hbtrtxxr4LvlzqqyEYJLhmLnvGO4fBUOFTrA0rsaORRZsq1BewyIwYOTtjpgq4UWPKLVCoFuvUwuBolZjs9lkvNnkZtOoTq3ZZAMYrdfpZhkxzxm4oqIARZaRx0gRAiFGohtiV9HLj4UYh8qMokojRhN2AbaKgqNlSX9rCy1LGt0u2usx1usx3+/z/NYWW2VJjkVVqxS7Jrb4nJLtmrzqXFXT7FkxsZktX/iedPXCCa+nnIShrHw2bGqk6e0MYgIxDRHyGBn1a6QmVntU9wVuDziWZfTKksXBYEgqj3sbV/14iHsH+kL5FBYh63vESsFSacUir8/6OVrAopsvYddsDa9D86jTlm9SrImlmVZCIVMYaawW35uY8XyVEriOEeKrwOexCOFALK1u3a/pzI9T5DlTNau0ugW8nGUU7v02GSN/IuZ/thgjkyGwhAmoXMFEZ2oY4eqxTSqCmsQ+3s7c2xqx6z33tlZG8Ef8GE1/fXVFVlHsEouMXcFIfykyrKuLO85JFYmrRFyq1L/cr4Xn/fl3/T3V/z674+8SI94NJzeqyoJsK+tW3oY9/y5X/biplqKpPgaFHyv36+RnsVq9qka0wGpEj/q5qGGR6FEsYlipe76pyohalLQtFjWcxVJ1we5HE1iU750Yafv9Ykwsulx5MnYw4nlHTRW2APBrFmwDKAMGZcm31X0Gi4LNLGMG+PWNjaRC+QjYNyqUu03e9hlpkyAfIFv7HV955kv7j+jtdprlPljjJiQ8Ch5WhXJfROAUuOTKkEFMQOSuCLMipmxWRWHynG5RUMKwjuxHWUanLFmOkUU1lbqNEHge+LYTs8oUetLJxSBGSyUSoeV1TNewhf+LvriaF1OfrKTbK5W/uuqwdmlZTMDirkdd+iKMhkAnRs6IecpdxqIkEoLtZIulhkV/fbUAq/zt3hfhFEYiLsTIBEZEFn23+4S68p7IUDwlwjD9bR1LqVvIMkaB23nOrSyj3miw2OkQWi2WnahpnqMhUOY5xMj8PeRLY2Sw8zlPh6pIWuG/Y/WaxyFv/v7hFRsjvXzH5dloWLpYp/OBt8x7KuybgwF5jNQGAwb9PmPdLtnaGo31dU7GyK2+VfdoWRo5ipHjHqW7iilPnhLhll9vhT+ujJdbanVilVjMUSzyN4Ypp3bU0kxzF+GYFiErS+66VUVHhNEsY05NAj/4NQc29lUa54SYuMoxv0ZqGIlYD4Etj1oGNXXPUpWfEuGHfg1N+THeVxMEqa77i1h0EExcpko1HMeIWXUNVZYEA0ywYgz7np1WU3v9tFhd4YIIR917rRLiGfMF+0ZR8FZRABZV+r4I5/Kc5Xqdfgic9E2WEyEw4ZGk7+LWBCLc9Xq323xQtv+2b4h82p+v7CBG/fy8AFzzc9L3PrT9d+UDdwsjRytqtZJjWG1hFxOLWcc2Pdaw6N6Mn5cNjDS96Me5ihGvebEo62m2i5mg2AAAIABJREFU/RUbWMpn0yOFq1ikrOVj0RZTXa0UVnP/7Mrsu7oflCJDJdHciVn1+hpWszapOtyYuOH9botFjBuq9NSEUTaAjRCoYV5sNb/GmsBF37SoInnXsAjrW6p2L/N7G04oZ4HnxOp+61j0+IaPQ0N16Eu3CNwqCtpZZtYOZcmxLKOmOhzXhAOE3SRue0za/vjG9/b0858kPops/tLpn9qlluzAbtfM7bx2E5lLOETYFxG457NMf6deN5PnGIdy96fFUriqr98mMF2WtPBoXAhkvoC/zran04oqz4fAIEaux4hkGY2yHNZbVYu8yvy25bvQHbH6lH8TI88DCyHQERORqGMRgmseiQMThrjji7im14Qtua/VXV8Yv+BpkhEr/p/JMroxUseieVVkYRx43UnFWgjUfTHUKUvmxdI6R7x/LbH6qLoI0yFwrV6n7lGPkWaTpfFxuqOjDFotYp5ThICEAH6+ysclWgcJTtZbPYuJdMuS9sYGx9fX6W1t0d3Y4Ei/b89j0Z6+yFD58zR2vi9jGw0VESpEWI+RWgicjJGbqsyEMPS9a2GpglWEboARteNO2ucHA6Z97Dsi3FBL53tBrFZQxNLc+mpCFIWa6MspbFHfwSKtp9lOJayppdaewFL6JsTSHjv+nuCPO2qS/s+LpW4+i0VTKgGLLbV0wLvYJkMfE3+ZU6v3PIsLdYhwViySPIbV0n0GhvWYdT9uB0spnRMxf7pajRdEuJtlNEKwNNkQeEWVb2PRm+dVh+mqo2LpnmNi6pklJpNfd5J6B6uHm8UI20x1/jGSXal0HsNEf57DyNqqt23So5J1VW6IqXJuej9O+Wtr/hvMLqOl2/WBNzDiV2AbUCuqnMXI0DEfzxIjnVt+XisVyuvAF7Asgpf8HOd+7XRUhxH1u2r1g4t+/i9j6eEv+XHGsEyDvirPhsAlLJq/4NdOByNpVz0SN4URuCkRvq86jCzXxOqORz26ekSVCxghm/ZzVlkBbDrJ7JQlF1RZ25Ee+Wy9zpQrwvZ8Y+NaCEwUBatZxl9dX08RuEfAnkXgdou47TJpO0wk7WlhV8ldisolJAxxoIy8T2eZ/k6zSUuElRjpq6nCRczXa9PbOOMLzinVoRS/+oJ7FVtEzahyCVuIRyztaAuLblXxnJaaN9ykCF1fsPywLDkaAlPAUoymTAhMq6VG1rCoSC8E6rKt+LjlxCqI1Yxl2EKug+1KX8PMovvehhq2IKtji7W2k6kZtfqWk2I1IxtqKZSrbmewIMJilpFlGe12m7WREbamplgcGaHMc6JHqzL4ZBG0x0E08/bOxgYbW1vMdLuE1VWmtrbo9vuc9EhSEc30feBjBEaWQgiMxzj0/KthC+9jWGSwUkwUsZTIeWyB3I6R52Mc1q7NYdfDFEa0+thC+QyWCnxTLQWt75//FzwaVXn5Vdf1SSx18FVg0V/7nAjfBXBCN4VZTkxg5KqLEYsG22mm81gK5hyWXjqFRaXAolE5lgJ8U022ftWjPF2PZn3aX/sGLjuPi4bgapVikc9BCGiMnGw0uCTCc1lGy20XxneQihVvy3NYeuArYkI2wc/RrFqk/Ra2KfMMlh4pfg/4lPfr+2optS/4+RXfsHkfSzEs/b3LMFQEfd6Pta6Wsgr2vV5iO5224edFse/9TbEoumDk8bj//7b/PsZ2VPAKnu7oxxvFIqgdMen+F4ELMXLSz8ui328aIh8g3a86wX1XrZ6wUEt1zn0Toe+fccvbeNoJ63UsDbPqS4bdl17xTYsRLO2zUs2torr/uiiYCYE3YuQzWEpxtxKfAS6q+cnVsswEajzqOQoMsozfXF1NBO4RsOsE7pAQt0TUnjyeOrHbTTK3D9a/CQn34kClUGZq9UIb/nsrRkYxsZC2yHDne6Cm0nZVLAWuiS1KKt+1huqwVmRVLFWxiJHRLKOryiknNlsxckp16EN2ETgSAhtqvl4b/veIKu9i4gd3sXSrUoSrvss85iSw8q9rYmqMHSdmq9jirqGmFHnN+9rFFmDHxFJEwRa/pZpgwrof92qtxkqtRrfToTEywuLEBHmzSQ+Q/MOHrvzQZxM+FCEQgeWxMRgb447X9N0Esn6fa5ubjC0vc3Z5maVulwmP/gJQlkaYXE69VOUMRsQGaoqKipGPmiq5R07mypK5EJjfsaFQic5c8/fXsc2IBScmVT1RpaZZYIvoUY/uFL7YKvz6/yYWbWkB5514jPrfNzHycQIjMWfFZPRfFrO4ALvORzDCtIhFo17Dot5djEC1MDGLqxgRuqHKOEbQ/pX36ySWGnkdIzcjYkIadf/e1cuSZRHWBwNijKyLcC0EXstzrnsKMMBECLT8/10/L5P+WQWW0lgZlD+D1YYOfBOoxzb5PIZ9/y6JDDdYLqhywvv4JUyts7of1bDUyGew+0klqlKp21YWHeu46bUTxoZ/prBdj9b0qN0x/9zKRqDr4/B5bKPpIpa2uoZF/5ZUGfHrNPPPXBWr2ct84wCMmF1WU9+ddxLXAKsV9uvpFnaP6ni/O2IiST1VVnzsa2K2ISt+PXWBS2VJEGG5LPlcCJRZxgB42+tzR0LgNpaSXtVRTohwKs/pxshcrcZYWdJxKxYp011q32G3CBs8NdKWyNru4N7z/MQJ3W6mWFbXfSJyCQcQ+4LAiS9IotcenRYrsP85bAF5wr9kTU9POqo6lONuAj8uSz4bAtdjZDkETqulrXXx+iUYplmCLbDWfYG2gC0smx7FO4IJfByJkVKVbgjcEGFKLaVrFMhdYXHUFzjBSWcVfbsjluo18F3upiqzvthawXayg5jqX1W7tiVCv9XiTKvF98bHmZuYIIyMoCHQdwVHsB33PbZLPbQodkQuy3qdsl5nodNh4cwZaqo0+n3Cmo3E+NoaG+vrtDc2GC9LxjDy3MOiYicxFcCjWP3WXTVp/7MhMOWTRbXYbToBGsFqrjrYhsGLvpC/gaVKDpwE9NXUBEex9M6rfpzjYmIslXphhkV038MiOV0YXsOrYoqWAyeJN9n2EqwM22dUeV+VL4jwHYw8drFU4FmMWJV+fZdY1HsR+w6AqRNWnoiV8mfDN2oqz7wjqlyMkSlVbqryArDY63Ge7UjyWaCeZYy67UE7yywl1EnnqyJD38MC+CkRvi9CM0amQximUE56/zZFOBEjP8AI5hyWFvgtNaXOPnZjnMKI2i1MrGPg7w9q9h9bGOk+g6lMNrB7yWtqaYrLfs6qqOCsRyvbbIucHPPz8oa/Vv06WlUz0D4iVq/2PCZaUtX2TQBvA0era0mEl7GsgONiYiiZX1sLqrzu18Ip3xQ7qcqbMXI6BO6IoN63siy5ClZ37DVrVRS4zDKuY9HIhggtsfrIm2XJlggnQ+CH3p6Xotm6zMfIoN/nRgjELGMmBAaDyqkuYc9xQCNtiaztH9xvLJ4IsdstMpeIXMIBxMe+q4rIGRH5hoj8WER+JCJ/zZ+fEpGvi8h5/z355JqbkJCQkJCw/5HmyISEhISEp4WPXQMnIieAE6r6fREZA74H/GXgrwCLqvo3ReRrwKSq/vaDjvVclulvjYzQiZEx34nfFGEtRqbYTjf6FKa2djXL+IKYefdxNUGGl9RUAOc9dbKHpSW9h9XcSIxU+75b2A57C9tNnxehpiZVvhQCEzGahLynGd3GhAvO++71hJ+zRY9iREwYYh5TjOxjkcHgu/ZdLIp4x9PdogidkRGujY6yMGlzdzYyAs0mZa02TIlL2IeoPKxCgKKg1e8ztbVFa36eyW6Xfq+HFAU1F67p4HVxasbLKx69WS2K7dRgrG5tBYs4v4hdW6VaHdtrbtUwFOXADZ2xdMjq+3ECi8BEj0Cjpvg44hGqJtt1WmARoqNYCuCmbtd4NVQ5Lyb2sYxd368B38KVHdXqz+6KMK4mrrEgbvCuJn4B9v2aZNtDbcOPcxmrs3sGEx55QYSXVfk/MZXEVSx98y1vZ0NM+CWLkX4IQ/uKl0PgrRA4KUI/BE6JMOVqncfFLBxyzFMOTNl1zNu3jImXXMHuB0dUOR0CeHTxBhYBnVMFVb4QwrD+sYqS1bCo2V3/+ywW8drE0r+PiYkNTbIdXVvGIn5Veui/hdXgHffnt3xMKn+4po/pCeze96oIb3qkcl7E6i99TI+ICZIcFatbzPzaWPfof1TlZoxMZBk3i4LbMTLm6bxVJsDLIqxkGaJKL0YzV4+RE3lOLEs6avWTP8ZSJ5uuujoWAiv+ejCvy9tFwQtZxo/Lkuc8GnsXKMqS3+52D30N3JOcI594DdwBirylaNvhwBNNtdyNOrkUjUvYIzz1GjhVncXWX6jqmoi8g5VtfBX4i/6yP8A8iR84OfWBXlFwzRXpjoowXZYczTJWYxya3n4rBD6PSbRfKEvOYalI05haXiUYUahyVZVnfDHXitH8kXzSKsqSzSyj9IXuEaDpcu99oJllxBjphMCiuqKc18pUCzowIYvbqoyKDMUp1FM2b3p6UnDCdqnZpDs6SjY9Tb/d5nyjMRQege20s4R9jp0CMXlON8+5OTJCbWKCOaBfFGSbm5xaXmZteZlTm5vU+n2uOvEXvD7KlUbBvLd6WErgDJYaN6NmBbCkpkZ6Hau5PKcmT18ZRe9cHl3G7SQ8dXcgpqCaYyTsJRH+1FMXN7FUuy01VdWjTnjA0vF6avLxJ8TELG5iNgMjTqYqgY8lMf9CVRMdeVm2rRYmRFjEyNoalpK4gZGXMYzYbYqpuP4bMcXDS96WAQw9xWpqIimTYjV048BkjFxxI/V3VfkUlqJ4TUxE5o7L5q+zna44kedcjZGztRrBnz+q5uP4jlq97C2xOtdPqXJelddEGIjwtrcfjES/jNUEVn6TXcxW5I6acumMmO9iy/s+IcI1T7P8DObXB7bJs4KJjYw4OQJL8z7h572LEbmfEuFf+ZhsYmm1C/76G2p1hdNiVg8NVZbKknlgNEbyLGNRlWXgYq8H9TojGHE8I8JtJ7k/EOFMUaCqtPKcRVU+A1wuCo44CVtwMheLgrkQ+GIIXBbhpRDY8u/HtLezwDbego/dRIxDFd/Djic5Rz4R7AZpS4Qt4T74sHH92KRuN1IrU1plwj7HE6mBE5FzmBr2t4FjPnGBbSof+6j3Z2qeRcfLkq1KTVGVq0XBaK1G5kXvR9Vk/I9hJG5FTXmt6YvQBragLUR4TqyYf0KVm2Lebn3/IjazjJ4veJZ9B7mFiUJ0VdnEjGxr2K72Xd9Fz0QYi3EY8WhjC68SW0BFf/9MCEyMj3NldJTuxARZu81GvU7fa+ce2y8tYd9h4PVZ1OtQr3NhYoIsRpYGA0bW1xlZXCSsrtLs9wmDgVkF+HvPep1TZdL8ipjaat8JnYjwgkfU3nUiOIEt3itRCrBNgDZGWvr++mdFuKgmZPEWpkq55JsOdVW6YnVRcxihAhOv+KyYCuyWmspr24naJvBlEV7HSNtrYuqaBfCGKj+l215mNzGCgpgIi2IETsTq625jpHAVE9LIMVL4jpoYyFlvT2W83lPliAi3xQRFVtVMqSvz7TmPom+JMFsUzGO1iJVS48mi4M+Bc4MBW06EX81z85MLgTdUeT7L6GGRsDYWMZoJgaaYtQnAT6vyjp+vZQAx64HgJPYCRjrr2D0l902fY2q1Y0exOkKwetZJPx+XRXhBlTUswlViKrh5jFwPgW+qckKVhSzjQlky7sQWjFC+qcozZcnVPGe+LE2hM8s45dfRu2XJZJZxJM+plyWrqszXatxV5S/tiL7ewTa7jsTIS6q8H4LZOojVWL4MvCrCSr2OFAW3VDmpZutw25Vba2L+hJ/Dajfx/82wXYv4ScLjzpGP8cFP7dDbn/F481kibJ9c7Bz7xyZzT5vIQSJzCfsKj03gRKQN/FPgr6vqquy42FVVReRDr3gR+Q3gN8AK8kdDoCbCSlGwnmVMZxljwExZDlPNgpqJddMltSstM8WEIgaqTKqyrko7y1grSzayjC3f9e1723IsLauGebEdV5Ppv6mmxldFNxrYAu44thgdxMizIkPz4gwzzt0QIeQ55cQEy+02dyYmYGSEQQgfEMZI+GShDIGy0aDfaLA8OcktoFUU9Le2eGZ5meZdi3nNbWxAjKhbD7yhytEsYxAjAxGWnbCV2LV4IgSuxUiPba85YCikUmLRtfcxAtMWEwmqFBs/JcKb2IYEakI8NRiKdKz4hsgivhmCiZ+cBi6p8raTkioy1VZTfDzipG/V+z8K3BDhrFqactM3TeZVh9YCix4FP4WtZO9gqZWLWKQLb/crWCijrya6su7vz7FI1Tx2H5nECODnvB1HsBUzfszPeP9+Afhz4GpRMOafpcB3BgOa2Pd+AhMX+WwIfDNGfsbPz9/D/B3XMA+9WbE06ZdVece9AXu+ubTkaeExy7gVI001e5BR36jquULjJTWPyD/x8euoMohx6Ak5q8q8mifg+GDAWow8EwILvin0ToysYSRuWhVC4H0/ziWP8p3MMoIqt4A8BMZDoBcjWVly0Y+z5vfAuSyjjSlbjoXA94uCyaLghUaD9mDANRFqRYGEwJIqi2riLMt+vwuqvFKW3BBhPATmioJTIbAZI+c+YQTuScyRzWEeykN94OM09yE/4+PPa4mwJXwYHlvdcjejcsPPSYQuYe/wWD5wIlID/i/gj1X1b/lz7wF/UVVnvQbgz1T15Qcd52QI+pv1OkFM3rsyqj4jwrUYhzvwMx41QIQtMQnst8qSV7OMLVUuqvKSCLewhdyECJdipK7btWxgBDDHVC8rifZl38mvYWlRi9jOfc0XmG1V5lTZDIFmowHA6vg49bEx5tpteq0WWZ4z8HqlmIhbwkfBI8tjvR75+jpjS0uMrK7S3txk0hf/YFEqPLqrarV0M1g0bS1G7uyInmyJMO0E7BxwHk9VxDYkprHr+4ce8fqsyFDlcs6bNaJWVzrjrx3FPNQ+K5baGDBSdUuEox55ueOkLJftGtHMU+g6mLH4l0R4B/Nh+zrwObaJ2JpafVcVyXsROO/9+hxWJ1ipWS4B31Hl5709E8D3vQ9HMen96KQKtk2zN9iW/19jW+J/GpPAH1FLz1z0c7YKQ6uSBtuG6RNqhuZbmPrkmJi6ZBVdqtJNR4HSN3xEhAmMsJ4GbjmB26rVaLiC7ZSnbHdFmBKh73WP+Dk6hXnbbWSZEXXdTucu/R7VD8EyGjCD+L7bLzQ8bXwTi/iux0g9y3hBrQ6w6ed6EjhfFNSyDFVlJc85FyN3/T3TWcbxwYDXs4xRv2dW11xfdbjZVqWyTwHHYmQtRkIIvOcE93c/ATVw8OTmyAfWwO0WIf6YpC0RtoQnhY8VpdstX7lE5hKeEJ56DZzYNuLfBd6pJibHHwG/DvxN//3PPupYmQitLONkjNzJMpZjZN0XA00ROj5Brbtc9VFgIUbqwIt5zm220yfrWcZxzIx7ymvf8ixjTXUoJ970HeOJENjEFmpTmK/VrD+upL7XRNjKMtZHR+l2OtyZmaHXbAKg9wiOVLeJRN4SHgpV1KPZhJERVmZmiKp0ul0yNxV/7u5dOoMB82XJglp67qgqHcyQuxQxPzA8nddT3Uq1eqdpGEr7H8WiWGOYb1ob+K4qU6pcDYFJP84GFsELajWhfaz+bh1brK+pcgpoebpdCyNlFzGyM7vjO9HASFAmwhyWdvmmmMhGH4ucHcfIxntYLtkzvqlS+a69qeajWFNl1t97HLirypoI7wLHnEj1/ZyMidX3Ndm2a5jFiNBJzFLkc/6/WeBZtVTOPm7GjaWSnvHHLayOC2BOzCdvHbMNqDnhLDCPOsHMzN8X84QUMRGZWVVO7ng9uKgHXneIWRb8tJh4imD3n78C/AO11O4YAiPYxlLf34+Pacff18OyDdpY+qeo0qvVeAbzwOyr2aOcdiuFQQgc9c2CWREaec6qCBMxElR5L0Ze8ojj1aJgVYQxNX/D+Rhph0ApVntYpfMOMPGYrloK7noIRFVm8pws7tKCao/xJOfIDzn4k2jiQ3zOo89libAlPC18rCjdvddwis4lHBI8jgrlzwP/L1ZaU30j/jMsY+kfYZlQV4F/X1UXH3SsM1mmv9Vo0AqBxRipx8i616CJ6jBVsi2mpLbuj0cB/P9rIhAC3bJkTMxXa1rMa+0ZN9WuTJhzVVZ9wdTGBEcEGFelnmXMhsB6p8Og3aY+Osqddhut14ftLRNBS9gtxEhtc5Ox1VWOrKwwurLC6GDAYlHQwyI+0RfEJQwNnMfU6qNKEcYwFcQFNaPvSSx60xXhDGZ8/YzI0Mz5VUxIZcoJQY4RnTNi6Zx9GNbm3fRo1DGMIFaRLbD6uVGMTGSYUmz1vZvEatYmxHzhSk/VfBMjU7PAaZ8QV7EUyiW2yRR8UMRlDKtDfdGJ5goWgbzEdoFRFYHrYURtAiNyHRh6OK5gkbwqyjgPnHWiuOXHOeLnb8Ffl2FG3n01f8pbaqmiK6qcY1t98wqmMLoGdJ28XwmB9Tzny3jappoCb+FR1FExcabTGPm8ARwPgTsxUvo4gBGvyotvPMvY8uhuPwRGXRH1WJbxellSw4j2lI/bWyHwrF9DGyFw1WvfRkLg9Rg5FwKzwKkYmVTz8FsToR0CJ1R5W5VbqjznolEAIUZGnTyiSqbKVJ5zO0ZuAf/VJyAC9yTnyI5M6c+Ef/sptpYUYUs48Ni3EbpE5hIeAbuhQvn/cX9P6UfSOy7UREKKGE26WoRGjDwfApcwsQKwCANY3doAWxituXn3wBcgxz0NawSGcuZvY+lm531R0wqBjqebRVV6ec50u8218XE2JibYarUosixF0hL2HiEwaLdZbLdZOH4cKQrGej0m19boLC/TXV/nWN9kOtYGA/pYqqF4inEQQWMEsZrPCYwojFVRIYwIzbMtLvEd/25UEvYKvARc94hWdFLYV1NobWIkEDED6dy/ry2RYWrmKeCyt+muf+4zYgIoZz0VsoqKLXra4bKfgrPAd7DVbu6fU/oxb/qGjgCnxGrwSm/zVYzYzftxKsXIk5hIyQAjMmtq4iInnXRELNWxhZHIjn9eFelcFFN7DP6+u55KuIRFxiaAZ1TJZVvWf00VFWEJqyes6nFfrNUYxMi7qpxRZS3LUO/ni1iK5izwcgh8Q5VPZxlzZUk/RrqeEglG2GshcKcsuYgR9qYrRP4A6MbIRlnyXAgsx0geI5u1GnlZckaVC36vm4iR+mDAtUaDk2VJO0ayPOe0pz5eKUs6IjwvpgS8EQIdEc4CW2XJmB+nm2UUMbISI/U8ZyRGflCWPO8bDJ8EPMk58qkhRdgSDhEeO0KXonMJe4GfuD4e7m1PRIXycZEBzRi55ounHlaTcgUjadWEX+2Ai5qk/1XfrZ7GyFoH20H/OeBbvgvdzDJGscVFXqlA5jl363WK8XFWJyZYHx3lcp4PU9CSSmTCfoSEAPU6a/U6a2NjcPIkjRj5sRO49uoqL965w7W1NU72+5QumtHB5PqrLf42Fh3LMVKzKmal8V41qYjQUvMs7HjK4i0sbbH6Pt7EhID6fpymCKtYZG3cb0ZrGFE7gn13x7C0w+ewG897bEe9WpgX3W1vZyUmBNsplIUqZ0W4jhGscRH6Th7qGAF8Abt/HPPX5CLDFMrKh2wcuIYRvQl/zV019cwxjBTWPGp4C4uyXVMdiph8D7u/NsVq/8YwIZeWv35CZJgaObWj/w0/36+J8KZvOI16Suk5J61raj6BP1arvZ0CXg2BC9gmVCxLChEWsoxmjBz3e9pNVW6XJa+GwIQIDVVWypLvxsh0WVpdHbAZAj3vm8bI654qWYktjanSbzSg30dqNSaAkbJkoyxZ9/etx8iGCIMsoxUj3RiZyTJLl/Rr6JKatUPMczJVNmPkCJamPp7ur3uLRyRtibAlHFQ8snXBXqVbDj8vEbtDjyeY/r4vCJxgOSWNGOmI+aYdUTP0bmE7/gD9GIdk7kd4fY0I6yKsxsiECM0QeNt3xOv1Ohujoyy1WtzsdOh2rEIjE2Ezzz9A1ARXtdyt2oKEhCeAXgjgNZmrzSbfO3oU+n2WBgOOr66Sd7t0V1fJNzc51+8zHwJjZcm0CBcxUjaiJmRR1Xj1MBIyh30vNjEp/yWMlJyAoYE9YmIhCsP60Uo8ZBKLks1iJC3D0izfxNI0pzDitYSpQE6Kec5NYPL8VT3VHW/LhJgQURuL3m15+95V5fMe/Tvi7T3l/bnJdprlMhbtu+tp1yuYTcgcpsDZxQhWZd+w4ce/iaVIXvPjTGFk8RSW4ngUeAeL7B3F7ksrqnxKBBHhAnafqky/g38OwHyMnAiBS0XBC3k+JMTHRMjynF6M3IyRV7KMK1gU9KSaRcEviPD2YADA81lGTU1Nt42lznaLgk6eMxICJ1WZx8jXIEZGxdRLj2GRyFHfBNjMcwZFwUlg3s3mR0VYDoHJsmQzBLayjCxGtgYDxj0bYiFGmlnGsmc5PCvmp7dWFNRE2MDqBQeqj6KnmPC4eASylohawicBjxSl2y1CN/y8ROwOFZ4yn9gXBE6xRdGaWF3bLTfvHscWdlX12YbXgxzJMsoYWfNIwXqWsRUCFxsNRmo11jod1tttNlotimZzWLNWpUD1EklLOMyo1xnU61wfHbW/Y6RWllzb2oJul8biIrK5yZlul4uDAS+HwFaMQ7XGG6pcxQhJA7fLwIjWqP8e4MIeuJcZVlfWYvumcodtG44ZQMVMpsfVPOD6fuwV4ItYdK70Y2yxbWswg3lA3vXj3cZqya5i943jYuqWOUY+C8xUO6ryLEa28NeuqEnyj1T3GoxwnsJq1Kb880b9eCvY/ekK2750q1h9XeFtXcDq5KKnSK569PI6pohZmabf8GNMAD/we9FIjOReg1j3aOmCmkBIazCgyDKeF+F6WbLsEbdZEVSVSyIsVpEzj1BmQLco0BAYzXPuFAVH85wlsdqGlTYeAAAR2klEQVTDk6rUvaYtALM+7sf9OFc9RbKfZWyqckrNhuC41/cpIGVJS4SxELiDpaBOhkChymk/zpIqizFSOmmb8euhw3ZKfMJTQCJsCQmPhEeK0t3v+5WI3ScXe8gn9gWBi9giqu6S6GNiYgmEQENkGBlox4hmGUtZRkuEG6Oj9NptFtptVprNYSRCRD6gDlmhTMQt4ZOIEBiEwGKtBmNjMDNDUGVuMKDW6/H+ygphfZ1212JnYWuLRlmyXBSImEdbTxWyDC1LRsTEgUoRbvvifBVLnZxV8wMDu7nUMWI2jilQ1jEyeAdLpVwQU9FcxQjZWUzpckXNlBvs/jCKbbyc8dee9GNsYF51J8Q87dbUDLoXVTku5jk35d/797A6uuNsm3u3XI2xh3m6FZiaY0VWpz21cgDc8fY0/KeHpZFeUeWYyNCqoe4bTavASAjMumJujqlZfB5YdaJTqXTOY8RmWZWWp343RKiXJe+IcFKENREux8gXgWshcN7PJX4eSlXGVLkMTLmS74kQuFgUTGYZJ0TYdBGRFkbEXwL+tSo1P05HrIZYvB7wboxkHj2sh8ByWTKjypwIk2rG4mNYSm4W47DecAEj9e0dY9j2+sXFtOh4fKQ0yISEp4bHTr2E3RFHedg1bbrnPhoOCFfYNwSuFGFEzN/thgg93wU+3mqx5ZGEq6OjdEdG0GaTPMvoVzVtQC1GBqm2IiHho+G1pmQZvWaTm+PjgG2gAGT9PtLvM10UFMvL1Ltder0eq1tbTLoIRgBwgQ7FapvmnDRVfosdTBVxgBGdnpo0/kCs5u6SKqdVGRWrU5vG0hebMTLAiA1YyvMyFvVb9+Mrds84ouZZtxQjHbbtDj6NRc9yj4SBqVs2nQj1VXnWyVcMgSUnKlNY7V7L07fvhMAdVYv870gxvYqR0krQJQOWRDgRI6tiNXAzqjS9Vm8qBE5gtWoBq2sDEylpO/kMHkG75dG4k34+jsTILY9wjQA/CoG6p5NXgjErHrXbiJGzWcZCUXBGzCdQQ2CzLGllGYtOxlqYb+CSKq+FMFQy3cBSWeuqLBcFvSxjXJVLMXI7Rqb8XNYxwlliJHw0RquZ9P8fBTZUGVWra6xI74aT+ISPgYcgbYmoJSQ8Hdzvu/VI0brd8qS7F49DSA4L+TsgpOxRNuf2BYGTEFiemWGlXmeu1SK2WmijwSDPWcpzBv66naqQffiAYXYibwkJj4fqNt31aPYmwNQUswAxojEyPxhQ39xkamsLVlbItrYYLwrW+306qlxzIgK2WJ/xOrSlEOjGSFQTHqqUH29g3+VpMQXJzOu4JtUMy8HET247UboZIw0Rxr3W67KTpiUnZoLZHZwvS8ZDIHikEEwNs4uRvL6YfUH0yFkry8jVlC/vel1aocpdVVohsLEjsnhRlbMhcCVGzorXAIqZZd8R4ThwLARWVIe1fyPAW2Jm3guYWiVAJwRWvE8tMe+6nw6B86rmbRkjt50kz4TAnJosf1TljAhz1f0vxmGt8FKMTIsZv58HXlNl0ZV6pz0KNhDhqtfC9WMcCkR9Gpgvy6GB+ERZDs3SxzByK5ha5W1MFCWUJSpmZl4JxkziVhaeQbEuQi8ERoE7WQa93se5RBNIJC0hYT/hQd/HnyB3D7M43yuSdz8cFOJzUPAx7Vo+9FAf1wfuSWK809Evf/nL5DBUQ0tISNgfuG90O0aIkbYqUpbEfp9Gr8eWL847m5vMbG1RFgW9GDlblqzHSHcwYMHTITcwJcgZMYXDq2qKk3dVOeIfM4fVa30OuOL1axsYoaiLcCVGTnjUfgaLLL3rqX1rMCSUnRA4Dlx28nhLlZdFuC7ClJOeOVVeFeGS166dDYG5GClgKP0/5iRqzttxHDjlUazcj7Hqn9dX80AbYMTytlp9XMOPVceM1k/4zy3/vJeyjHfLknNYFFBiZMtTw4+osu6Ru6qed9TTL+tOdJdUOSemktn31MmjYmIkG2XJrAifERMyqVJL8fO8iZG0EUz4pY6R+7r/3YMhQQRY9/O5lee0c9sT3KzVWK3Xia0WtVaLQb3OQq0GtRr9POdf/tmfHXofuCeJL32uqd/54zN73YyEhIQniH3rW5fw8fCEvDS//EvXef2HW0/PB+5JQgFCoNjrhiQkJPwE7hvdDgFCYB0gy6DZpOcEBYwIzHlqXg2YLQqCKtLv0ytL4mDAer/Psc1N1gYDtno9tCyhLO04hd0RemJiRd+KkVfynDUX/iixetd2CKxiIkdHgHexWq5VTLly0pt7G7gqQtsJ2VkxhUhVZVFM1bKWZfx5jBwJgVOqXFXlRgicwwgjmO1CA4gx8qxH4C5j4kqrakbnkyLcASZDYEpNtGUOU3SszMTBFDpPY2Iq60AvRo6LcCdGppxknlLzgmvGaJFMJ2pRza8P70OJeWrejRGyjB/788HPTYZZNQQRPoWRsVxNgKSybMg8Ololp/dFWAuBfp5TZhkTtRqbtRrrtRrrzSbjISDNJpfrdfr1+jCKm+W5pel+yLWT9nMTEhISHj6a/gGi93FIQiJ9j4YnFCV72tkSKdyVkJCQkJCQkJCQkJBwQLAvInAJCQkHHB5p+Qn116pGCxjUXb6iYW6OlWLhJaz2rfSUvNGypBEjl9xTrFUUZGVJU5Vv9vu0BgNir8dYjKwCeVGQxYgWBd90MZNczVT6Rlmy4m3KY2RBzUi6K0IWI8fKkrJW45JH3Y6WJbUso+ZCJKrKNObjVkW7mkVBkec0VNlSZV2ESa8la3q92pKa+qWImWqv4jYHIZiJtve1W5ashcBMjBahw8RBFoATLgpyy0VXqvf2MeGnHpYuCpZ6Oe0plX1MzfM8MJHnLIfAkRC4m2Vs5TnkOZeyDK3VqDebrAB1F4Tq57n1NcugVmO9UgLOc3oiXA3BUmd9bNfvSa+tRj/t9yYkJCQ8GXycSM5jR+0eFU86yrcbbX4I7Oea40TgEhIS9hylyLBYeiMENnb8b7BDrAgwAuF/hxiH4idgKYS5iJFBVXLVIZnIXWyjLAryGKllGVd6PXJMRfMucLPfZ4DV4mlRMA40ioJ3RYaS+GOYAuVsWRJdxGMTU3DULOOoKhoCFwYDmm7AnXmq6ZiLlrRqJtyvZck7QEdNyn8xy1gDapVgCWaAPZtltGOkVq9T85TPWq02rMsLqlzIMup5Tl+EN0MYpjNW6emNECx1syJhO87p5o7zvfNxgKGI1PaT2+9L4lEJCQkJ+w+7RTyGRHEXCdd+JlW7iUTgEhIS9jXivSRhx9/V/0r/W3Y8Bj5QV9u/53EfoDI7d1TkJYuRckdtWIiRdf+shXuiTjXVoek4wK3KjgEoq9c5YZrdEb3aiTm2yehPvBfQGOk9BFl6UB3xB3QfE/FKSEhISHhMJDK1d3hqs7iIfEVE3hORCyLytaf1OQkJCQlPGuU9BCc+IOo0+LC00RA+eIzqsf/vwxCr/937XsxqJeHwIM2PCQkJCQmPg6eyKhCRDPjbwC8DrwH/gYi89jQ+KyEhISEh4aAgzY8JCQkJCY+Lp7Wt+2XggqpeUtU+8IfAV5/SZyUkJCQkJBwUpPkxISEhIeGx8LQI3Cng+o6/b/hzCQkJCQkJn2Sk+TEhISEh4bGwZ4UVIvIbIvK6iLw+GPyEzllCQkJCQsInFjvnyDsL5Ue/ISEhISHhE4OnpUJ5Eziz4+/T/twQqvp7wO8BiMidP/n61zeAu0+pPXuFGQ5Xnw5bfyD16aAg9elg4GH7dPZpN2Qf4yPnR/iJOXItO3Hhvd1p3q7hk3z9HySkPu1/HLb+wCe7Tw81P0plKPskISI58D7wi9jE9F3gP1TVHz3gPa+r6peeeGP2EIetT4etP5D6dFCQ+nQwcBj79KSR5kdD6tPBQOrT/sdh6w+kPj0MnkoETlULEflN4I8xS6Pff9DklJCQkJCQ8ElAmh8TEhISEh4XT83IW1X/OfDPn9bxExISEhISDiLS/JiQkJCQ8DjYT+6wv7fXDXgKOGx9Omz9gdSng4LUp4OBw9in/YDDeF5Tnw4GUp/2Pw5bfyD16SPxVGrgEhISEhISEhISEhISEp489lMELiEhISEhISEhISEhIeEB2HMCJyJfEZH3ROSCiHxtr9vzcSEiV0TkLRF5Q0Re9+emROTrInLef0/udTsfBBH5fRG5LSJv73juQ/sghv/ex+1NEfni3rX8/rhPn35XRG76WL0hIr+y43+/4316T0R+aW9afX+IyBkR+YaI/FhEfiQif82fP7Dj9IA+HeRxaorId0Tkh96n/8Kff1ZEvu1t/4ciUvfnG/73Bf//ub1s/4fhAX36+yJyecc4fd6f3/fX3kFAmiP3Dw7bHHnY5kdIc+SO9+zrsTpsc+SezI+qumc/mALXReA5oA78EHhtL9v0GH25Aszc89x/A3zNH38N+K/3up0f0YdfAL4IvP1RfQB+Bfi/AQF+Fvj2Xrf/Efr0u8BvfchrX/NrsAE869dmttd9uKeNJ4Av+uMxTI78tYM8Tg/o00EeJwHa/rgGfNvP/z8Cfs2f/zvAf+yP/xPg7/jjXwP+4V734RH69PeBX/2Q1+/7a2+//6Q5cn/9HLY58rDNj97ONEcegLE6bHPkXsyPex2B+zJwQVUvqWof+EPgq3vcpieJrwJ/4I//APjLe9iWj4Sq/jmweM/T9+vDV4H/WQ3fAiZE5MTutPThcZ8+3Q9fBf5QVXuqehm4gF2j+waqOquq3/fHa8A7wCkO8Dg9oE/3w0EYJ1XVdf+z5j8K/CXgn/jz945TNX7/BPhFEZFdau5D4QF9uh/2/bV3AJDmyH2EwzZHHrb5EdIc6dj3Y3XY5si9mB/3msCdAq7v+PsGD74o9zMU+Bci8j0R+Q1/7piqzvrjOeDY3jTtsXC/Phz0sftND1v//o60nQPVJ08h+AK203MoxumePsEBHicRyUTkDeA28HVsF3RZVQt/yc52D/vk/18Bpne3xR+Ne/ukqtU4/Zc+Tv+diDT8uQMxTvsch+kcpjny4Izdgb3v7kSaI4fYl306bHPkbs+Pe03gDhN+XlW/CPwy8J+KyC/s/KdazPRAS34ehj44/kfgeeDzwCzw3+5tcx4dItIG/inw11V1def/Duo4fUifDvQ4qWqpqp8HTmO7n6/scZMeG/f2SUQ+DfwO1refBqaA397DJibsX6Q58mDgQN93K6Q5cv/jsM2Ruz0/7jWBuwmc2fH3aX/uwEFVb/rv28D/gV2M81VI1H/f3rsWfmzcrw8HduxUdd6/aBH4n9hOLTgQfRKRGnYT/99U9X/3pw/0OH1Ynw76OFVQ1WXgG8BfwNIkcv/XznYP++T/HwcWdrmpD40dffqKp/eoqvaAv8cBHad9ikNzDtMceTDG7jDcd9MceTD6VOGwzZG7NT/uNYH7LvCiq87UscLEP9rjNj0yRGRURMaqx8C/C7yN9eXX/WW/DvyzvWnhY+F+ffgj4D9yJZ2fBVZ2pCfsa9yTZ/zvYWMF1qdfc7WjZ4EXge/sdvseBM/5/rvAO6r6t3b868CO0/36dMDH6YiITPjjFvDvYHUL3wB+1V927zhV4/erwJ/6LvG+wX369O6ORZFg9Qo7x2lfX3sHAGmO3P84sPfeD8NBvu9CmiP98b4fq8M2R+7J/Kh7r9zyK5iizkXgb+x1ez5mH57DFH9+CPyo6geWn/svgfPAnwBTe93Wj+jHP8DC8AMsH/ev3q8PmHLO3/Zxewv40l63/xH69L94m9/0L9GJHa//G96n94Bf3uv2f0h/fh5L/XgTeMN/fuUgj9MD+nSQx+mzwA+87W8D/7k//xw2kV4A/jHQ8Oeb/vcF//9ze92HR+jTn/o4vQ38r2wrce37a+8g/KQ5cv/8HLY58rDNj97GNEcegLE6bHPkXsyP4gdKSEhISEhISEhISEhI2OfY6xTKhISEhISEhISEhISEhIdEInAJCQkJCQkJCQkJCQkHBInAJSQkJCQkJCQkJCQkHBAkApeQkJCQkJCQkJCQkHBAkAhcQkJCQkJCQkJCQkLCAUEicAkJCQkJCQkJCQkJCQcEicAlJCQkJCQkJCQkJCQcECQCl5CQkJCQkJCQkJCQcEDw/wORfU7I4fDLvAAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 1080x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "my_scene = mydb.scene(rowid=2)\n",
-    "f, axarr = plt.subplots(1, 2, figsize=(15, 4))\n",
-    "\n",
-    "to_plot_im = my_scene[:, :, :3, 0].astype(float)\n",
-    "to_plot_im -= to_plot_im.min()\n",
-    "to_plot_im /= to_plot_im.max()\n",
-    "to_plot_im = to_plot_im * 255\n",
-    "to_plot_im = to_plot_im.astype(np.uint8)\n",
-    "to_plot_dist = my_scene[:, :, 3, 0]\n",
-    "\n",
-    "ax = axarr[0]\n",
-    "ax.imshow(to_plot_im)\n",
-    "ax.invert_yaxis()\n",
-    "\n",
-    "ax = axarr[1]\n",
-    "ax.imshow(to_plot_dist)\n",
-    "ax.invert_yaxis()\n",
-    "\n",
-    "f.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}