From 328cbaa6bf0b9210e18fd24869c5aa3dede6e2da Mon Sep 17 00:00:00 2001
From: GYF <1337838189@qq.com>
Date: Thu, 10 Aug 2023 14:45:30 +0800
Subject: [PATCH] Update the document "Concept 2: Dynamical System"

---
 brainpy/_src/context.py                       |   4 +-
 brainpy/_src/dynsys.py                        |  10 +-
 .../brainpy_dynamical_system.ipynb            | 318 +++++++-----------
 .../brainpy_transform_concept-old.ipynb       |  55 ++-
 .../brainpy_transform_concept.ipynb           | 278 +++++++++------
 docs/tutorial_toolbox/optimizers.ipynb        |  94 +++++-
 6 files changed, 412 insertions(+), 347 deletions(-)

diff --git a/brainpy/_src/context.py b/brainpy/_src/context.py
index d413508f9..87724618a 100644
--- a/brainpy/_src/context.py
+++ b/brainpy/_src/context.py
@@ -58,8 +58,8 @@ def save(self, *args, **kwargs) -> None:
     """Save shared arguments in the global context."""
     assert len(args) % 2 == 0
     for i in range(0, len(args), 2):
-      identifier = args[i * 2]
-      data = args[i * 2 + 1]
+      identifier = args[i]
+      data = args[i + 1]
       self._arguments[identifier] = data
     for identifier, data in kwargs.items():
       self._arguments[identifier] = data
diff --git a/brainpy/_src/dynsys.py b/brainpy/_src/dynsys.py
index de917ca31..4b114acae 100644
--- a/brainpy/_src/dynsys.py
+++ b/brainpy/_src/dynsys.py
@@ -71,7 +71,7 @@ def update(self, x):
   return func
 
 
-class DynamicalSystem(bm.BrainPyObject, DelayRegister):
+class DynamicalSystem(bm.BrainPyObject, DelayRegister, ReceiveInputProj):
   """Base Dynamical System class.
 
   .. note::
@@ -120,6 +120,9 @@ def __init__(
                                f'which are parents of {self.supported_modes}, '
                                f'but we got {self.mode}.')
 
+    # Attribute for "ReceiveInputProj"
+    self.cur_inputs = bm.node_dict()
+
     # local delay variables:
     # Compatible for ``DelayRegister``
     # TODO: will be deprecated in the future
@@ -573,7 +576,7 @@ def reset_state(self, *args, **kwargs):
     pass
 
 
-class Dynamic(DynamicalSystem, ReceiveInputProj):
+class Dynamic(DynamicalSystem):
   """Base class to model dynamics.
 
   There are several essential attributes:
@@ -629,9 +632,6 @@ def __init__(
     # initialize
     super().__init__(name=name, mode=mode)
 
-    # Attribute for "ReceiveInputProj"
-    self.cur_inputs = bm.node_dict()
-
   @property
   def varshape(self):
     """The shape of variables in the neuron group."""
diff --git a/docs/core_concept/brainpy_dynamical_system.ipynb b/docs/core_concept/brainpy_dynamical_system.ipynb
index f463b1167..ab7f7d0a2 100644
--- a/docs/core_concept/brainpy_dynamical_system.ipynb
+++ b/docs/core_concept/brainpy_dynamical_system.ipynb
@@ -2,24 +2,21 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "# Concept 2: Dynamical System"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "@[Chaoming Wang](https://github.com/chaoming0625)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "BrainPy supports modelings in brain simulation and brain-inspired computing.\n",
     "\n",
@@ -29,18 +26,18 @@
     "1. what is ``brainpy.DynamicalSystem``?\n",
     "2. how to define ``brainpy.DynamicalSystem``?\n",
     "3. how to run ``brainpy.DynamicalSystem``?"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": "'2.4.0'"
+      "text/plain": [
+       "'2.4.3.post3'"
+      ]
      },
      "execution_count": 1,
      "metadata": {},
@@ -54,35 +51,25 @@
     "bm.set_platform('cpu')\n",
     "\n",
     "bp.__version__"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:38.622791Z",
-     "end_time": "2023-04-15T15:46:40.161986Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## What is ``DynamicalSystem``?"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "All models used in brain simulation and brain-inspired computing is ``DynamicalSystem``.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "\n",
     "A ``DynamicalSystem`` defines the updating rule of the model at single time step.\n",
@@ -90,40 +77,32 @@
     "1. For models with state, ``DynamicalSystem`` defines the state transition from $t$ to $t+dt$, i.e., $S(t+dt) = F\\left(S(t), x, t, dt\\right)$, where $S$ is the state, $x$ is input, $t$ is the time, and $dt$ is the time step. This is the case for recurrent neural networks (like GRU, LSTM), neuron models (like HH, LIF), or synapse models which are widely used in brain simulation.\n",
     "\n",
     "2. However, for models in deep learning, like convolution and fully-connected linear layers, ``DynamicalSystem`` defines the input-to-output mapping, i.e., $y=F\\left(x, t\\right)$."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "![](imgs/dynamical_system.png)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## How to define ``DynamicalSystem``?"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Keep in mind that the usage of ``DynamicalSystem`` has several constraints in BrainPy."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### 1. ``.update()`` function\n",
     "\n",
@@ -144,21 +123,19 @@
     "\n",
     "We call `s` as shared arguments because they are same and shared for all nodes/layers. On the contrary, different nodes/layers have different input `x`.\n",
     "\n",
-    "\n",
-    "However, for simplicity, BrainPy also provides ``DynamicalSystemNS`` for defining dynamical system without explicitly requiring shared arguments. For ``.update()`` function in ``DynamicalSystemNS``, users only need to pass individual input for this node/layer, and shared arguments can be accessed through a gloabl variable ``brainpy.share``.\n",
-    "\n",
-    "```\n",
-    "class YourModel(bp.DynamicalSystemNS):\n",
-    "  def update(self, x):\n",
-    "    s = bp.share  # shared arguments\n",
-    "```\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+    "Here, it is necessary to explain the usage of ``bp.share``.\n",
+    "- ``bp.share.save( )``: The function saves shared arguments in the global context. User can save shared arguments in tow ways, for example, if user want to set the current time ``t=100``, the current time step ``dt=0.1``,the user can use ``bp.share.save(\"t\",100,\"dt\",0.1)`` or                      ``bp.share.save(t=100,dt=0.1)``.\n",
+    "  \n",
+    "- ``bp.share.load( )``: The function gets the shared data by the ``key``, for example, ``bp.share.load(\"t\")``.\n",
+    "  \n",
+    "- ``bp.share.clear_shargs( )``: The function clears the specific shared arguments in the global context, for example, ``bp.share.clear_shargs(\"t\")``.\n",
+    "  \n",
+    "- ``bp.share.clear( )``: The function clears all shared arguments in the global context.\n"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "**Example: LIF neuron model for brain simulation**\n",
     "\n",
@@ -174,17 +151,15 @@
     "$$\n",
     "\n",
     "For the details of the model, users should refer to Wikipedia or other resource.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "class LIF_for_BrainSimulation(bp.DynamicalSystemNS):\n",
+    "class LIF_for_BrainSimulation(bp.DynamicalSystem):\n",
     "  def __init__(self, size, V_rest=0., V_th=1., tau=5., mode=None):\n",
     "    super().__init__(mode=mode)\n",
     "\n",
@@ -214,17 +189,11 @@
     "    self.V.value = bm.where(spike, self.V_rest, V)\n",
     "    self.spike.value = spike\n",
     "    return spike"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:40.161986Z",
-     "end_time": "2023-04-15T15:46:40.177681Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### 2. Computing mode\n",
     "\n",
@@ -233,13 +202,11 @@
     "Brain simulation usually builds models without batching dimension (we refer to it as *non-batching mode*, as seen in above LIF model), while brain-inspired computation trains models with a batch of data (*batching mode* or *training mode*).\n",
     "\n",
     "So, to write a model applicable to abroad applications in brain simulation and brain-inspired computing, you need to consider which mode your model supports, one of them, or both of them."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "**Example: LIF neuron model for both brain simulation and brain-inspired computing**\n",
     "\n",
@@ -256,20 +223,19 @@
     "$$\n",
     "g'(x) = \\frac{1}{(\\alpha * |x| + 1.) ^ 2}\n",
     "$$"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "class LIF(bp.DynamicalSystemNS):\n",
-    "  def __init__(self, size, f_surrogate=None, V_rest=0., V_th=1., tau=5.,mode=None):\n",
+    "class LIF(bp.DynamicalSystem):\n",
+    "  supported_modes = (bm.NonBatchingMode, bm.BatchingMode, bm.TrainingMode)\n",
+    "\n",
+    "  def __init__(self, size, f_surrogate=None, V_rest=0., V_th=1., tau=5., mode=None):\n",
     "    super().__init__(mode=mode)\n",
-    "    bp.check.is_subclass(self.mode, [bm.NonBatchingMode, bm.BatchingMode, bm.TrainingMode])\n",
     "\n",
     "    # Parameters\n",
     "    self.size = size\n",
@@ -282,7 +248,7 @@
     "    self.f_surrogate = f_surrogate\n",
     "\n",
     "    # integrate differential equation with exponential euler method\n",
-    "    self.integral = bp.odeint(f=lambda V, t, I: (-V + V_rest + I)/tau, method='exp_auto')\n",
+    "    self.integral = bp.odeint(f=lambda V, t, I: (-V + V_rest + I) / tau, method='exp_auto')\n",
     "\n",
     "    # Initialize a Variable:\n",
     "    # - if non-batching mode, batch axis of V is None\n",
@@ -306,49 +272,52 @@
     "    self.V.value = (1. - spike) * V + spike * self.V_rest\n",
     "    self.spike.value = spike\n",
     "    return spike"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:40.177681Z",
-     "end_time": "2023-04-15T15:46:40.225028Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### Model composition\n",
     "\n",
     "The ``LIF`` model we have defined above can be recursively composed to construct networks in brain simulation and brain-inspired computing."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "The following code snippet utilizes the LIF model to build an E/I balanced network ``EINet``, which is a classical network model in brain simulation."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "class EINet(bp.DynamicalSystemNS):\n",
+    "class Exponential(bp.Projection):\n",
+    "  def __init__(self, num_pre, post, prob, g_max, tau):\n",
+    "    super(Exponential, self).__init__()\n",
+    "    self.proj = bp.dyn.ProjAlignPostMg1(\n",
+    "      comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(prob, pre=num_pre, post=post.num), g_max),\n",
+    "      syn=bp.dyn.Expon.desc(post.num, tau=tau),\n",
+    "      out=bp.dyn.CUBA.desc(),\n",
+    "      post=post\n",
+    "    )\n",
+    "\n",
+    "  def update(self, x):\n",
+    "    return self.proj(x)\n",
+    "      \n",
+    "class EINet(bp.DynamicalSystem):\n",
     "  def __init__(self, num_exc, num_inh):\n",
     "    super().__init__()\n",
     "    self.E = LIF(num_exc, V_rest=-55, V_th=-50., tau=20.)\n",
     "    self.I = LIF(num_inh, V_rest=-55, V_th=-50., tau=20.)\n",
-    "    self.E2E = bp.experimental.Exponential(bp.conn.FixedProb(0.02, pre=num_exc, post=num_exc), g_max=1.62, tau=5.)\n",
-    "    self.E2I = bp.experimental.Exponential(bp.conn.FixedProb(0.02, pre=num_exc, post=num_inh), g_max=1.62, tau=5.)\n",
-    "    self.I2E = bp.experimental.Exponential(bp.conn.FixedProb(0.02, pre=num_inh, post=num_exc), g_max=-9.0, tau=10.)\n",
-    "    self.I2I = bp.experimental.Exponential(bp.conn.FixedProb(0.02, pre=num_inh, post=num_inh), g_max=-9.0, tau=10.)\n",
+    "    self.E2E = Exponential(prob=0.02, num_pre=num_exc, post=self.E, g_max=1.62, tau=5.)\n",
+    "    self.E2I = Exponential(prob=0.02, num_pre=num_exc, post=self.I, g_max=1.62, tau=5.)\n",
+    "    self.I2E = Exponential(prob=0.02, num_pre=num_inh, post=self.E, g_max=-9.0, tau=10.)\n",
+    "    self.I2I = Exponential(prob=0.02, num_pre=num_inh, post=self.I, g_max=-9.0, tau=10.)\n",
     "\n",
     "  def update(self, x):\n",
     "    # x is the background input\n",
@@ -361,38 +330,30 @@
     "\n",
     "with bm.environment(mode=bm.nonbatching_mode):\n",
     "  net1 = EINet(3200, 800)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:40.196185Z",
-     "end_time": "2023-04-15T15:46:41.828478Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Moreover, our LIF model can also be used in brain-inspired computing scenario. The following ``AINet`` uses the LIF model to construct a model for AI training."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# This network can be used in AI applications\n",
     "\n",
-    "class AINet(bp.DynamicalSystemNS):\n",
+    "class AINet(bp.DynamicalSystem):\n",
     "  def __init__(self, sizes):\n",
     "    super().__init__()\n",
     "    self.neu1 = LIF(sizes[0])\n",
-    "    self.syn1 = bp.layers.Dense(sizes[0], sizes[1])\n",
+    "    self.syn1 = bp.dnn.Dense(sizes[0], sizes[1])\n",
     "    self.neu2 = LIF(sizes[1])\n",
-    "    self.syn2 = bp.layers.Dense(sizes[1], sizes[2])\n",
+    "    self.syn2 = bp.dnn.Dense(sizes[1], sizes[2])\n",
     "    self.neu3 = LIF(sizes[2])\n",
     "\n",
     "  def update(self, x):\n",
@@ -400,72 +361,56 @@
     "\n",
     "with bm.environment(mode=bm.training_mode):\n",
     "  net2 = AINet([100, 50, 10])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:41.828478Z",
-     "end_time": "2023-04-15T15:46:42.243349Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## How to run ``DynamicalSystem``?"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "As we have stated above that ``DynamicalSystem`` only defines the updating rule at single time step, to run a ``DynamicalSystem`` instance over time, we need a for loop mechanism.\n",
     "\n",
     "![](./imgs/dynamical_system_and_dsrunner.png)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### 1. ``brainpy.math.for_loop``\n",
     "\n",
     "``for_loop`` is a structural control flow API which runs a function with the looping over the inputs. Moreover, this API just-in-time compile the looping process into the machine code.\n",
     "\n",
     "Suppose we have 200 time steps with the step size of 0.1, we can run the model with:"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
+   "metadata": {},
    "outputs": [],
    "source": [
     "def run_net2(t, currents):\n",
     "  bp.share.save(t=t)\n",
     "  return net2(currents)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:42.243349Z",
-     "end_time": "2023-04-15T15:46:42.259476Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": "(200, 10, 10)"
+      "text/plain": [
+       "(200, 10, 10)"
+      ]
      },
      "execution_count": 7,
      "metadata": {},
@@ -484,35 +429,29 @@
     "  out = bm.for_loop(run_net2, (times, currents))\n",
     "\n",
     "out.shape"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:42.259476Z",
-     "end_time": "2023-04-15T15:46:42.588576Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### 2. ``brainpy.LoopOverTime``\n",
     "\n",
     "Different from ``for_loop``, ``brainpy.LoopOverTime`` is used for constructing a dynamical system that automatically loops the model over time when receiving an input.\n",
     "\n",
     "``for_loop`` runs the model over time. While ``brainpy.LoopOverTime`` creates a model which will run the model over time when calling it."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": "(200, 10, 10)"
+      "text/plain": [
+       "(200, 10, 10)"
+      ]
      },
      "execution_count": 8,
      "metadata": {},
@@ -524,46 +463,42 @@
     "looper = bp.LoopOverTime(net2)\n",
     "out = looper(currents)\n",
     "out.shape"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:42.588576Z",
-     "end_time": "2023-04-15T15:46:42.839131Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### 3. ``brainpy.DSRunner``\n",
     "\n",
     "Another way to run the model in BrainPy is using the structural running object ``DSRunner`` and ``DSTrainer``. They provide more flexible way to monitoring the variables in a ``DynamicalSystem``. The details users should refer to the [DSRunner tutorial](../tutorial_simulation/simulation_dsrunner.ipynb).\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": "  0%|          | 0/1000 [00:00<?, ?it/s]",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "740610c7725647e9ae0999902a765bb3",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "71bd4c6ac98140b1ad848b4e4e68e265"
-      }
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1000 [00:00<?, ?it/s]"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "text/plain": "<Figure size 640x480 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9e4ytWV3mv6vKU21XQzd16A7KpfaIolGYAM7BiIjEAQGRyEDiaDVhGI04eBmJynUcQsSImPFHxmHgyETtMaMBR4MwCU1rBER00NixAaG52sL0yMUM2i0CjVzW7w/y1PnsZz/f9b676i3g7LNXsnNO7cv7vOv2/T7r+X7Xerdaa222KZuyKZuyKZuyKZtyCZftL/YNbMqmbMqmbMqmbMqmfLHLhhBtyqZsyqZsyqZsyiVfNoRoUzZlUzZlUzZlUy75siFEm7Ipm7Ipm7Ipm3LJlw0h2pRN2ZRN2ZRN2ZRLvmwI0aZsyqZsyqZsyqZc8mVDiDZlUzZlUzZlUzblki9f9sW+gYuhfO5zn5t98IMfnN35zneebW1tfbFvZ1M2ZVM2ZVM2ZVNGlNba7GMf+9js7ne/+2x7u68BbQjRiPLBD35wdq973euLfRubsimbsimbsimbcoxy6623zu55z3t2v7MhRCPKne9859ls9vkGvfLKK7/Id7Mpm7Ipm7Ipm7IpY8o//MM/zO51r3sd+fFe2RCiEUVhsiuvvHJDiDZlUzZlUzZlUy6yMibdZZNUvSmbsimbsimbsimXfNkQok3ZlE3ZlE3ZlE255MuGEG3KpmzKpmzKpmzKJV82hGhTNmVTNmVTNmVTLvmyIUSbsimbsimbsimbcsmXDSHalE3ZlE3ZlE3ZlEu+bAjRpmzKpmzKpmzKplzyZUOINmVTNmVTNmVTNuWSLxtCtCmbsimbsimbsimXfNkQok3ZlE3ZlE3ZlE255MuGEG3KpmzKpmzKpmzKJV82hGhTNmVTNmVTNmVTLvmyIUSbsimbsimbsimbcsmXDSH6IpcrrrhitrW1Nbviiiu+IHjXXnvtbHt7e7a7uzu7613vOrv22mtnd73rXWd3vetdZ7/8y788OdaXfdmXza699trZL//yL8/+2T/7Z7Nrr702/jsFNvFms9kS5i//8i8fvef/nwKvwuT7J8FNeD1Mx01/nwSvd82x7w1hrVqPsbhDeCfF5Gd3vetdZ1dcccXgHFu1zYbac3t7e3bFFVdMill9nub6Kr9fFbc391ZpqzHz4UEPetBsa2tr9qAHPaj8zirzbAhTdXvQgx40aq725v8Y3MpunsRG9DBX7bsvaGmbMlhuv/32NpvN2u233z75tWez2dHrtMv58+cX8Pw1n88nw5nP521ra6vNZrO2tbV19H9/bW9vHxtbOOfPn2+ttaNrbW9vt9Za29vbK+t69uzZNp/PR2M7VsJL7bu3t7dQ9yHchFPhVZjz+bydO3euzWaztru722azWdvZ2Tm6Nu8j4fTwWmvt7NmzC/2ndlZd9/b2jr6zs7PTDg8P23w+P3ov1bvCUh3VhmfOnGk7OztHmPP5vB0eHh7h6v3t7e2juqX27uE5purDsXr+/Pl25syZhTZObSps9n9V1D7b29vt8PBwAVP9x7rq+wlXvxsa38Q8d+7cwlzl73q4h4eHR1g7OzuD41vXVx8dHh4u9ekQLtu018/nz58v27HCdFy30WmO8t68XfU9vxfH1OeVXRau5pPXm2PaMfVK7UOsc+fOLbQjf++2wn87BpO/2dnZObJTOzs7g/PjuGUV/70hRCPKuhCiNNno2HrOcZXiTqD32tvbG3TMQzj6va555syZQfKnCT4W27Hm8/mRATpz5kxrrd++Y3HdqPO7csDCqzD9PRkb3ntFTobw6ND40nd5D8KlsWO9h7B6ddR3/TPeG9vQjXoPr4e5tbV15EzdabFN6bx4rb29vYjn7UpCU/Wr2lNOm86E/VGN76ovVc/z588vkGjWgWSC93p4eNgd36kObMu9vb0Fh9+rb+rnIUI6hKl/KxvJa3LukBB5u/pihO2rseTjhHVz4sP5zPHtCy+vP4ml6pkWjZwr/L3bitSXqc339vaOxhLHisiQf3fqsiFEE5d1IURayabXkCFbpVQrnfSik1oVn46OE3tra2vJYSVHmlY8FX6FJbzKuIzBJbYbZjo7Egx9fwhTDtEJAeua6lbhje1XjSddU9jE1bVYh52dnaX7G4spI3v27Nl25syZI6WltUVnQgKme/X26RGi5DBJfrwdW6vVPZIndwx+fb8n1U3vb21tHdVhCI9tsrW1FQlY1d+yI1rM0BFzbPeUFM7/g4ODpfeE7+O4tUWyV40t3gOVarUJMXd2dhbasBpbctZOdkkwUl+qLiR4IkT8O2F7XdLYrtrV689XZR9dHaRS5vPE20yYVAw5p71dqsXc1GVDiCYu60KIepN91RDSUKlWWWny+cpiFfwxOP6S8ffJN4RPB1LVx1dqXAU5wehhO5Y7LIaQPIQ1n88XnBav18Mei0fCRsdLJ+718FVyj1wdHBwsXJckkYb84OCgzREeJC6/J2fJ8dYL4dK5ej2lPrKN6US839zxaUzM5/Mjx64VtI8PV7H8Oqorf5v6LuHpdyTFyUnKLrCNPeTlv5HzrEI4bNeESyXR61s5eBIKV7uJ6aql2mcMIdJcEwHiNdTPxGPYOCmTnHfVYlU2JSk6VHEYtnZSmBZNGhOpvppz3jc+v9UGupYTbWKl8euqMgn9lGVDiCYu60KIfCXmRmwqhai15VWCT7gk7x4HX5Oypwixfm5QWIbwhdVrRxpbOh7l16T8jIQ9Fkt4CVPX0yovYbuKk2TsZLRkuGiIh3CZV6DPh+qmayusQPWD/ee4yZHyd7160thrFe71JOa5c+eO+kqraRr7IYVLKo7uSQ4kYXLFrrEy1GepD9O4Vg6RnFVSFTVWSLoqguJt6mNO1+b9O3kSFhU3d6RVH6b5S2fMXB537olEsE6pzl5H3ee5c+eWiItIB8PJzC8a8+IiVtdVSJfjU2RL+Xf8bTV2PKzIuchFit4XpsZnmn+O52PoJPmkvbIhRBOXdSFEPdIwtVTpq4TqlRSL4+D0VnZ6yXHp71VxqXaMNVpyqvqNQi5D2I61s7MzylgST0aqh03FxnGH8FKYkjK+43reErFIGnrt607N60pcji9ieVjD8dzhu3rTWlvA9bHO+mxvby8peO6E9H0qHK3lPKBEknwe896Fl1QYKUO8j0TkSEhV1xSiYVK9EwoSOP6W40J9qsK6ViFb4fn8l3pIctWzC6yXk76Uu5TsTVVHJpp7snsiCsLzxHp/idgzn4vjJ9lg3+DgeUVctPTmvMaPY6a564naIk1nzpw5wk5q2lRlQ4gmLutCiPb397vObcqBOGb1T2n2uMrUKkqKJqf+bW01VYpYq2ByN8VYXMc6PDyMybxVu9K4cFXn2L5ap6P3nTj+qnIThJFw+V7COjw87CoeXn/WlRgyuKwXlZUhPBIDdywpvEXHde7cuaW6EdtzmBJ2a4shbuEke6F5vb+/vzB2mMeV8JxgMMzF9tV9sK5SwbydVVKbighTzWAuCtvX60/lNNmsaswI00mpfy+RD5IDfU4lNY3/RJ52d3cjceb9c1wnVa4KYVPx4Wec556srzFY7UTkHKpwdR2NK4Xqfaei97OTLeEm5XOqsiFEE5d1IES9FVKaFCfBSSu5HqarFGMxfOU/Fo9YPWwnLY41Vt7WarXCTeTIsSoJu/dKW2h7Sg37Ygye5w3NZp93yiQM3q4kEglrPp8v4dK4Hh4eRoImMpDqwv8P4SkkyPcODw8XCAX/L4LL6zu2OwB3jL69myoUv+dONrVpa4s7npJKoGtVyldvHHtdvS1VfG6k8FiV+CsC4vOWdfMxneaiCFxSX/y76X3u/KryHX3cUBlM9+/ETXXw76fcP/98Pl/MxeLnLN6Wru5wHKe6sX5clHEeMNyVfs+2HDN/piwbQjRxWQdCVBlGDniGHU6KM4YQpZ0Lq2DQIKbYdYXJJEU/06PCaW05IXTMDi86E1+1MynSDYFjpfbsEYeEKxxPXnTFyPG4GvW4vzszdwauSknipzJIp3P27OKuI3cgusdqdZ6u76v7Hp5+59ftzRsqBlSBfFzyuz4HvC91jSpkyhwf1rm1tuB4fJVPx+42wTGTQiBC6mcDcUxVzja1a1J+EhlX4rO3ZeobKlYJk3Of7eHf9RCi+ouqm/e5xpnPB84DV1kq26z21664So1L1/DP2XYVKdTYd/I/Bs/bXHOdbenkkri+63PKsiFEE5d1IESSQSvDrokyBY6c6xAeJ8kq2ElRSdJ79aIT7uH2wlqr4A1hD4XPSKBWSbp0XK5Eq3rTkY9JVB8i2r6yd9wkpfeIbbUC5ZgiLrF9VZ3wkurlDjqFnhMunTzHelrtD9Vzb28v7vQippPoqh1JZIYwXZHj+CPRpuqYCIHPFyX66t5TXaskZrcbuid+RwrLKpgKpfbGc0UmmKfFNhrCFFkfkyiu33jOXNWXKsTkFvrqDCL/Oy1YU8TBlR1ePyWW9+b4lGVDiCYu60CIWhs+OJBbR6coQ5P83LlzS/kEp1U3vlwKX0WdGoPXS4IkUdTW2yFsOvTKmFSYnlw6hE1HM6S6adVa9S2vz1ACV9MkaHr16phyNziGeC6NSkrwpWKUHDjHRnLOVFHUL666eXsIy5OA/XpVjgrzuXSdtEVa7d4bn64E9TBJZnwHnbDoNCv1jsoIVRq1S9p56n0jJZt4idgqj4bjTqSFZ1V5XXsLASpB1XdIqFlPtW01T9WOThioDPr/Nc7SfNB9poRz9qsvXBMh4j2qOCnkvE6YXIyo71JbTxWpYNkQoonLpUKIOFGmKEMhLFc8tPo6Dn4K8fRwHdtX2WNJyhg8N3o8n2UMthv8VVQiGrEetj73LfKONzaR3K/L9nYlgo5eToSPxZDR5P+9P12lSHVO7SenKjxPIteKvDdXVJekStFh8F8PEVCZUJikGrt0nt6eIjdeB/+7teEwlY9b/es7NV2B8zDn7u7uUnt4joy/XOFR37E/1N5yrFTu9HuOaU9E5su/o3HYSzz2EJ7a0du1tf4OX7Wj2jgRTpEJfaaFTrLpwqzalu3ABZCwSLpVF9/O77iyWRWmzwPaPFeINwrRl3hZF0LUc2ancQ5Eb2LIUNKIn2RCjD2Lxc80cTk4OTcvY/OV9OLJsro+ww09bG5R7Rk3f89zWnj9hM3PZXATHg1huqeklui6NLokIVQK1Ucp70VG2evqakPC1ndT6KkXikyYfkaPKyStXVBHpf6QCDmZTo4trbJVR7ah57JUYZBEAtk27sh7mCSraS5wLuvlYTzuhKqcOp1xlUNUKTpUGTy8SIW4uufd3d0l9UUqkxPSoXYdshkHBwdl6E/1Tm3KOcXPhNlTa/ReOm+KKrLvfvM5xb4U5tAOypRr5/+fsmwI0cRlXQhRNUg1SXoJxlPjuSE66YRYZQcWjanjjbmHVbH0fxKRsdhDWMnI+tk3lMdTPgDxh+rjj01Ixs+3pHtui7D5vRTW8jryGIFUVzoGOgU6Ym0PTuOf15TakDCTSkGyWYWN9Fvi8+Ri1tedtu8Kc9zU795vTBJmSFQE1PNKEuYYBYCKEd9nQrYn647ZZZawOTZ8N5mUsup4AGI6kRFRreaYh7/Z97x3ESuVar7yGul0e92HwqT6W/dBTA87JfLn+VacM0kZ5thl3hPbtbcBJM1zkTmO59MoG0I0cVkXQtQ7h2jqQTmUnChjcdIJwfN6hvAqAzsWm1g7OzsrqUTexkPYjsX8DhnGIaytreXTqSsVys8DchWFIa0hXN2z49DQyogLNzn/akXs71Fp0uciAHIMDAN4aEL5ayRTHirh304a0lPi2Y50atzpRsy0TZs4PLphNrtwzABJLOuWCCb7gM6oclgpt4q5UMxnYfum+ul7aT6kfCu/N9+dmRYaao+eU1bdvW4i7t5mrsyozmpPYQ6RRt2fExHeix/ayXnPseV1TJjKMWpt8RmWibS5AptyfBheS+OL/SuyxOvrvpPCfBp5QywbQjRxWRdC1HPgvQePHqeMUVH82UDHUYeYGOrGrGcQHXMVZUgTnIaEDnYIN+H5347l+T8p3yC93EGlerIeKVeEuTJjwoW8P7axy/r8nITW1Z103kl68T6pCLW2SPr0Nw22tw0TtXvnAfHF/B3OpRRGEFFUuzCMITXF29nvw39PTA8he5uqvpynvSR5vlivKmRHvORgh0Je3sZO4NPcYmG7uKIylLTv5JchnmoTiLdrNTb9nhkSdxKX8rMqm+XXTuNc96H7Te3gu1A5j2lHPIFddUnty/Aoc/W8v0+rbAjRxGVdCNEYkuKG5bhl1ecraRWzKr5wenHyVEd9x1fxPbVIWKkdfdWVXvodt86m1R6xqoc+yhAmTF+Fsm4kBsJm0jJX+glPRrpHTKhUsF4cE1W9aPzlcHTPydCyrqwTc3ZIJmW8q91UKmwnrr65UpYD4Rj0UJ/yx9yBkMDo+hwXvuJ3hUgO2cei6uHvV4TYjwbgb3p5a0k9SW3DlX8ib0lNqXYeCS+NvbSLyYlb2uGXXlQuOG5cGemNmUSqe6pVauPWlneFup1g2/rCprVs89X+/j7JjC+k1E9cMDAnr5fDplyznv/xxdiU5aIhRC996UvbP//n/7zd+c53bne+853bN3/zN7frr7/+6PNPfvKT7Ud+5Efa2bNn2xVXXNGe8IQntA9/+MML1/jABz7QHvOYx7TLL7+8XXPNNe3pT396+/SnP73wnTe84Q3tgQ98YNvd3W1f/dVf3a677rqV7nNdCNGY1d9UhCgZujGvVfHH4LjzlfF0wzq0w05YQ+0op5ucim+d1TWlmAif71c4nnhMokdnzLpR9fH60Nm4fK+6eK4HQzA0kh6acSftbVglBvvDIN0p+ArbQ1ApNJT6S/8/PDxcykXxkIgcApNsnXAlp53q50nexPS60ul5witfapf0GZ00xyaJmDDT0QIpgVptISLgdVcb+TxUnZxoONHyunIh4yqQ17X6nHPd5xj7UnPIN2J44jNVSZ9LUmU4P/1eNX6F13vIrB+CmAi+CFM1DpxcKtdJ86lH4FWPNNZpP6pwKUOvzEOiHZqyXDSE6H/9r//VXvOa17T3vOc97d3vfnf7D//hP7QzZ860t7/97a211p761Ke2e93rXu11r3tdu/HGG9s3f/M3t2/5lm85+v1nPvOZdr/73a894hGPaDfddFO7/vrr29VXX92e85znHH3nlltuaXt7e+0nf/In280339xe/OIXt52dnXbDDTeMvs91IURDqg13JJ20JNm455D83JpVcDzkkq6fYvdufIawhTV0pghXOx5LV5InHUjCplQtgz5Uxyp/hJK2Oy+X4fnMtSHFiw7NQzwyuDTcJExMsNXf+n4vDMi20XUTLg0468EEULVF2tHGseKYrS07UTppV8M0vnlvyQGzDj4OhOu/pcLpp6GnXUsJbzZbPtmY46Ja3bvq5EnZvZcvPhhaS/3KcUzlp4eXfu+hxTSvnfir/TmuxhykSMWvmtMaL9ziP4bEayxXRDApVwqJ6nNXe4eUX0/MJx7VIo7BKj0hkTifc1OVi4YQpbK/v99+5Vd+pd12223tzJkz7bd/+7ePPnvnO9/ZZrNZe/Ob39xaa+36669v29vbC6rR+fPn25VXXtk+9alPtdZae+Yzn9nue9/7LmB87/d+b3vUox41+p7WhRANTbKpyxjDKON40tKrW2+Su/R8UiwZ3iqXIDm9MVhJ0aow3dBoZe75ASfBo0NsbZkgMHx09mx+3hWxPNRS9SPJQQoNETcpU8Kv+mZra2th8wHVGuJ6G/tzvpyk+fbl3lhNoa0KlwnIDMl6ndzh8G932I6ZyBCfpeaq3ND8486rakGQ2ki/c/XMXykfx4lUwuS8Zpvt7++PHqNs42qR42Evb+NVzhmr6pj6z21dbxyusnGDmByLaYGZxnCqx5TloiREn/nMZ9rLX/7ytru7297xjne0173udW02m7W///u/X/jewcFBe9GLXtRaa+25z31uu//977/w+S233NJms1n7i7/4i9Zaaw996EPb0572tIXv/Nqv/Vq78sory3u544472u233370uvXWW0c36KqFA+G0y5BqM3UMd0yIbsggT1W3nvPhNVZRisbWb+ykrxyS3uOKfxWj6fkPlcHxVfpYvEp5FC5DMFXd/IGPabVKp+G7t1zip3ql9+gwPCzHFStx/VBBhry8/1kn7hzi7+nUqxU5d8vxvpMD84T3RGR9tZ5CRK7upBwfhryU49LahTOXiMsQZrpvEQbWk+pN5YzZtmfOnDlSWhje8/v2s29I4KhcuJKY7pmKB8PEaTwwhyqFO/VZb4FFdZf36TtBdX8VpteV/VbZJx9X1Twn+WMb+mKCNiXNW/5mynJREaK3ve1t7Yorrmg7Ozvtqquuaq95zWtaa6395m/+5sIqROVBD3pQe+Yzn9laa+0pT3lKe+QjH7nw+cc//vE2m82OcpHuc5/7tBe84AUL33nNa17TZrNZ+8QnPhHv6XnPe17s+IudEPVCIL6in6JUWHwdHBwsOYfjqDarEiJfbTIsMITvBldtVmGdOXNmYXeFGzhdM+Hz/thXlYMkZhWSSthOXCq8ISLGuur5RR4Kcenc68GVc6+ObpQdl8a8t0vGVS53xpVzZv6Pqx50Tr6VmiXlbCRMhtrYt+mhmgytkhxyTI3pS40V/s1DGV0FlfNOoTQfw16n6n2FG/3/+pv18bwaERg/lJJjSu3uicZVbleyBZxXqT5uL5yk9JSYaju697XnZ7W2SLT89OvWFu1z2qCQCnP2vG18XvmGDp/LGrvVaeBTlYuKEH3qU59q733ve9uNN97Ynv3sZ7err766veMd7/iiEqJ1VYjGqgpTxXDHYM3ny2doHOdMCp9sQ+cSaeJ5uGEMfnLSve3onhPAOvt9OH4KR+hk28qh0Hh7/XrYNIoVXloleniI16+wkoFk/elIWccqL2YIl1h+TSXZa8ycO3duYfwk55jaOPWlh8uYv+Fqh89Bv0fVwXHVvyS03jdqH8/lGNotyPHjjt3HNQ99JMGnMsh2ZbIyX/5+VTeFC53I+8LCMZm/xvfZB2pjJwlsO8dOCyXeV0pK7+Uh9vrN6+jjU79JmOoLn7e8hrAcm+POjydI4Wu2TQqr+3XOnTu3gtUfVy4qQuTl4Q9/ePuhH/qhL2rIzMu65BD1JNLd3d2jVcYXghBRIvdV0nFWCWPi3QpfUJrXpHdjsCpWL3zGbbhVMjVXz8SnwxxLaBlm8dVyyk9Jh7RVeEP34MnaXLm3thgmq9qxCkklfIYfeG0/d4jX9PBIcmCuKiRy0lO9+F1Xgbgq7pHoFMJKSghDNlQAWWd3PrpftwF+DwmTqgrbuTdWE56ukeaRO3KRM5JlHq3g40NOOGGSMOvlD7blOT5+eCgJG8PJui/WZejARo4DXZN4Pk7Ux/zefJ4PDk2YZ86cOZqH/ggWn8e9nWs7OztLhKqaTyI5tLX8rfff1OWiJkTf/u3f3p785CcfJVX/zu/8ztFn73rXu9pstpxU/ZGPfOToOy972cvalVde2e64447W2ueTqu93v/stYBweHl6SSdU9QsRV2BciZJaMHQ3ZlHUjpjs2lVXwx2AlXDolx6jw+WiHZHTSvfB7zLXxPBrHTjvxKgeWZHPWlaGJhEvH6rhuaHkuTApjOG7KE6Gj9fZ2B0XnLgLlITY6Gu5SdAcvB0Q8tmvaPi8VqRfWY32JmXKO0vEMY8K+rgjoWiTNrFciuCSsqc2SauAKHt9P99TL3an6yQmA755KuTsp1ObfdaXZSfoYO+HXcvLBMaL6VWHqlGfk7eJhxN7cJybDtrxv/52HiSuliPc3ZbloCNGzn/3s9sY3vrH99V//dXvb297Wnv3sZ7etra32+7//+621z2+7Pzg4aK9//evbjTfe2B784Ae3Bz/4wUe/17b7Rz7yke0tb3lLu+GGG9o111wTt90/4xnPaO985zvbS17ykkt2231vMrrB+ELg+WQ7SULdKljuBJJqMhYrbaGukizdCFTKSYWl79BQukM8c+bMoOGVsVZx+V/XcTw+zNNDOilE6TJ65Yyl3OkzV+sqzMPDw9IAV4ohT+rVtdPTxV1VIzFtrT4t2fuc+VdyGPyers98L40Bx2xtnBKarkvVxlf63K5PlWfIkatuJNwc+1JE2Y88msDDP7RBlRKpxZqH+1yV0sKCCg/nWFJr0os7M6nyppPHnXz5nHZMtpUreH6ulasqsgcpH8zJZxoXQwSI8y3lYFVkPIXofNMMlUgn61P5HpaLhhD9wA/8wFEDXXPNNe3hD3/4ERlq7cLBjPv7+21vb689/vGPbx/60IcWrvH+97+/fed3fme7/PLL29VXX91+6qd+Kh7M+IAHPKDt7u62e9/73pfswYxDk3+K7e+r4PlLhvoLgXUSXO+z6rqJEHny4hB2Gh89hYpqG/vVDWrqa0+QTXipTsT00FBKGpaTSFitLToON7CV0uMOWL9L95uweF1XbKhYpBU2T1lPh1nqu3SavqvOt+W31pYwW1tUiLxuKQeGZEVto40MqZ4iEL2wC/tG4yapXPzb68ixT9JSYem3VK89HJZ2JTK8pP+zngy9+Tylw/e8rZR47wqS5/lUxJIKjeaSru9nE/FICN2jkxkp0En9JBl0Uu7fF6nUYqe30KjGBwlOhcvfXNKE6GIp60KIqhAHjdaUpVrlaTXHlYJPnlXL0ERVuGVnZ+fEuDRWPRVIztBxfRvwGCyFzIbqSVlbuHRGlNaH8Hx12GvbtJuLsn9SQOjwufoe89gXrSY98dNzL9xhMIeC99TD8gRr/d7rmxJHtcoWjvqiN26Um+OOLOGm/Jm0uk+nRLuz9B1crp4y9Mj29/twuyJn6vWUakMSm0I9HEuuLo3ZKechY7+2k2eGrfVdPTol2RCf8wy/8VypdK/MdUoq6f7+/iAREYlnKJP3zu9xrqRDFPf29pYU016/6sWjIvhbjVmqSm4jPFdu6rIhRBOXdSFEQ4Y/5bacpFSTJyWUarIeF38oTOQqBifgKuEyYQ05NTrPhDsW21fsVVs6JnEpw3PFm7CH8HpJwMScIwTnuK0tb02n4VUYR3hDmD1cJymS7/me4509e3ZhJV61r+O2tkiWk+NMxODg4GApt61SUxKuJ8Amx0uSuL+/v0Sud3d3BzFZP7VDL5mWY8bPetL1kyLUU46GtnGzDdQ2/ogStk8K6TGcnFSTXl2dWA61E7HYp44jApHywZJa1bt3tW9SLvkbkTXNBQ+Hprnoiel+z45NsupzeqqyIUQTl0uFEFVG8LhllcMDT3IGUWuLBqdHVNLuCHdqY7GGdgptb28vyM2eWzQGm1I680F6mHwEAUNOVEsqbOLJkRwcHIw6mVekVA6wwm1tOamTv3XlwHHc8PdwfWx4OEqGm0nM7rySg+N5LFRSvI+dqKTQkTtpV4h0jxUu6+K5QML1hF93fmp3/saJsi9gPPFb9+1OUFgpaVuElTk0riDq2lQXPJSqPvTrJ8JVKUL8LhU9treraEOHl6Yx6O2iduB8o1oqspYO3EzXFmbaKUbCp8+ldLP/NLZ815wWUBWmjzv+Nl2Tj9I5yYK4VzaEaOKyLoRoaDXHJN8pythwyxQTYsxKNeGumlBNrCGFqMJN55lU2CQSTsTG4rnT6GEP4XG1febMmW6CZIXb2mJSLMlZ7zwXOTknM+ncHToMJzusp+dV6Du8pmO6w5eToVOnkjKfL54SPpRzw7CeJ9d6gmuVg9GrH++Zfedjm0nllWLh12T/pt+ke21tOTTsahL7zutSJS1rvCUbR9VW9UyhWqqlXuekkri6QxtDNcRVq2S/Uu6Y109tzfeT6pTaIKldbof4HW6J92RqzrV0HhHDcqmNT4MIqWwI0cRlXQhRL6zkoYApytDhiDRyJy1jdlZNhSsn7I54DEFa9ZyNdM5LMqpjXmMUMOJxuztXkKtg9nCJxetyB0sKB3iSdaV8EtfDIRWeyLmriI7hbe9O0PH0e+XeMCcmkYvW8nOfiOsJ9Gk3WsKT4uDO0tulV38pCZVzY04M87u8XdP9cq4kG+X3WOG5asf7GwoNVzYjhTY9rympMkkN87olWyHy5oTZFzV+X/w8EbdqAdn7rWxXUkKZn+QKnNogEWjv29MoG0I0cVkXQlStumlYpixD8XZOlJNiD9XNX3REq2JzdbkK5mx2ITlzrCLGsJYblAo/ESeX3yts4iWHNLadmZTtDkP/Jxavmw6ZS5+lz4lLZcpzmCq8RBTOnl1MGk4OReOJ5ErfdSfJ+6natLVFVYDKCevOa9MpuTPyQ1ePg+l1kINP4TESHFdlkhNkEnLKl+ndO+vnyfaVsqL3FX5m+KxH9FJbkKBU80Pk3EP7Gm8Jkw/uTYSI6mhPQfKcKZJZtyH62++J85jvew6QXyvNG6ZHeJL+GJu4atkQoonLuhCiod07U6k1KmMUoqmw+byjMXhpm/PYwjyOVVWaMYmrCYvxfRqcVF/vZ55bNIRNPM930Yp1bH/KmNNoM7HTVRIqNFUdk1Rf4TrRcmdCRYFt5QQmqTfpUQmt5bNmPOzFUBhVADou5pTw+pxTupbqwYTuql+2ti48/2uO8I6SkNnfwvQ2dtKR8pN8XMrRueKg66T766kQFa6PsxR+S2f6qG+qsBlDgT2ildoqjWvaHR9/fpp4Iic+r5MS5MorcaXibG9vL5yrRIWImJxLbN+x9pZ9LWzmKXJhMGQTVy0bQjRxWQdCNMaRTUGIaCTHTJTjYKc8GDd4PSwmKPewU94LV/cyRsnA9nBp0KpcnoQlZ8/t9EO43HZPZ5qMvBvBhDefz0eRQDkX/o7XJrnz9mhtkZj1whru/Gl0UxKzJ7QnvCrXgRjextzKnH5DMiQ8D2Hx+z6mnTioDeVESBzlgNmuHANVKC/Vk+TNnRvVC5J2HyPVydGqJ98T2fL25/hR3yk8o80LVEN9PFXJvj5m0/zxRGPdn7DYppVCpGs5XmpftQNzgTimhecH6aajFVIifaonTxQnJkPXzCnT+B276K1221WP3pmybAjRxGUdCFHPwNPAToUzJvHXQxWrYlANGPvioxKUA1BhE6e11UNlLqv7qpUrfOIkLCbqpr9peNypJXm82u7L/qvweB0Z59TfTJpubfl5bcIiSVSbeE4Eryvn5/0go0vi4IqPFCIPaRGjR+iT0+uFSkQUSMTo3CpVh4SyRyY8iTUdNaD24n0oH8STmeXkK0zHdjLj7c/v+xgg2eAYSAqMruuLBG/nZFPY/1RDqBYmTJGSKtzJucxxk8YmFRH2e1Uftpn3J8NaKil53PMOuQDrhcq4qHV1TZhpXPgBrn7eUyJ/DFWe1k6zDSGauFwqhGgKhYhOrodV7SBZBYO5CWNWKu7Uh7b6O1ER1hhlhsm+7vgo9fvKV8WxklLihtcNuK6X+iJhnT9/4UC4dNDa1tbWknIhUuoYOzs7C3I4HbcMc8JKJDc9dNRXvtyuzft2VcsViISXwg8cb3QoHBtpCzbzQBKe2rTCo4Nwx061gk4pOTx/iTwydKf7cvWQ9WL4p1K2fNxUW+lJLn2RQAeve0v923tpXvt4oI3Sdan6VH2lues4vRyi/f39pTnu4WGqeT4Oq/qyrVpbfrYb3+N2ft2nX5NtUS38fMylsCgJdgoLa3wxh85D+pU9Pm7ZEKKJyzoQIl9J9ozkSXE0sXpY1WRbFUNljCLFmDXzE2hYhnBaG5/AzROpU6xcTqEnFfO7fv5Q9WBXEo3WFlUAd6heaMR8daxdTN5vqpdCFq66sM5VHg13ZXHspBOQGRIREebJ2wk3nfNT4XkdZ7PFx3NQ4aHSVu2UkhMVYU14Pl/oXEi6HNfHotqX/+digc7b68mzbhIm74e5R6mNPJFXeJ7s7YSATjk9L6y15Zwm/57IRlL/VE/HTORfoaGhUKoICNvL7zsRH8+HY19xPFfkhW3i4yeRZW8f2sIUKvPFlpOvpND2FhJV+I2fVbb4JGVDiCYu60CIWhvOI1qFlIwpPSwaM1cOjlOGFKmE6yu3sXLtmBW4OwsaDZJTOoCKlFVY6X1XTyibJ2xhCJ/fTYpUGkOel6Bx5Lhsbzr8ra2tpV1QVW6L3tdYSWe+JFw/c8e/4yG15EA5Tvxz3nNva7zXj+TMHVoVsmUbexiC/cadOz7+1N9+npKTMK+rq6zuNKna+hiplDfv08rhqp051nZ3d5fGgfeXkwLWM4UY+T2NSx/TnrPINk0LJs4Rqsc+d33Xleant4PumQTCr+VEjzv5kj3pEe3d3d2je6HKlWxSIsOpTZjjxxDi1GVDiCYulwohmnpADmHRiZ1ULj1uEndy1EOlMqDJCCbjT1wai4RNAzQ2cdvDh0lpIAEjPpWThJcUm0SeknN17NRnWm2nnAnHoxo2BpfqCh2PE43KcDNxuJer5QoF553XL4X/dA1XJ5wcez8l56629mTy1Je6hmOmsac6VvYjKdJUJdJDSj0c5+PYt76zPd2GsC+ozvqYErZIVO8UeL8u8TiHeDq97wpUPTnODg4OYtisSgpXGxPT5wH7m/WqCDh/Jzswny9uiydm1Zf6rj+vcUyEopfPeZKyIUQTl3UhRENOfEq5cgz5ms1mC7tsxio0juMroTFqkYeqeipNhZUMbTIw7kgcK2EnosYHPvbqls5v6e3kIAlKRtafZVTVLyVqckz5YYXCSqEvhpl69auIooezXG1hWFFkyXcpVZg+3tTGzIOh4zp//sIWetZPDiPtTGPoS9fqkX7P+5HT1fxyQpdW7NU1K5WSO+vo/FRUL6kjlf3xNtf4TO2v3VVqI/ZxOjKimpvnzp0r+zT1v5QoJ/Q8NkJjvWrPnhJVtQ0XMQw5kThWmIlA7uzsLLSVtzHDnuxD1X/sgZbpWBPH5EIjJYpPVTaEaOKyLoRoaBBPORjHGNwpsIWTVn9Dr1VlWmL54XMVRlqFj8F1LDqxoXwpEjUSBh1659iVQjSE59I/d+/wO64C0ignItZaPVZdqme4xYlFSuaVQtfDc+fkmL2D7TgmUvhBeMQ4e3b5YbJ+5pSv6r2u7pRJNr0P5aCI6U9p5/0m4qq6zkOuk4rvTnLH7QSSdWWbibQy58zHlvchd5JW9oa43Cihevl5WFy4Md+qV0fWyftdOzTVFomU8V68nUi40zxJ7cIFGcev+o74HuKk/fCFEEPOfiRICpuRwHN8TZ0/1NqGEE1e1oUQDSlEUw7GsXk2J8V2JWVIluVLRm4stmOlfBJeO/1/LG5SiPReZeRplPS3fzflSlXhuyE8qQ1+D6nfnWy11iKW7qsaOx5qG1J2nIBUYUPfOdfDTM5SY89JgLA83yPldvB6YzHprPhd5k55HypPir9JmHJQ1ZlQ6agAFn6WVCmGFD0k5ASI6oL63NuZ71W7t6iS8XMeNOghtHTkRDqbqQpFSRVMag37iWFDV7jSfOiFoqgGM1+K7ZsUJ7bJfD5fwu3ZAleYPIxJTCpcfrzE1GVDiCYu60KIhvJspmbnY/N6JMeeFEuTaiwp4jbU42K1Nu4RJXxxJ9aqWK2ND0fKkDIPYGgnxyp4PcLrxtwl/gpLZewJ4L3cJTkpOrbK6PbUUybXytnQuZPgOmHww/PYpkPtR0x3MPqOnxWjOpIMVWEvb2MPP7ra5H3PuebnyDieqzvE8Lb3JHVdX/+SWLC+fhhkb+HA9pLyxbHDdk6Lg5RDxXnmD29N7U+7xzamKqcFTNrgoGtU48dzrfxQTioz/JeLpqoNdUCkt5X3Y5rjFa6I7dRlQ4gmLutCiCo1gxNxyjIm8XgqbJeAq5cnNB4Hm8ZqTB1JRFJy5BgsGuWhk7hptNJKsYd9EjwnXCm/i9jEau2CalMldKcXE1UdN+VssN7EqxxONVaZp+PkMa2s2Z5UXfidIRLItmG+Dh0M68xwSFqc+PlYVZI0Fa5egn6PLOh+PNyVvpfCN06m0z2lVzrzpvd9kQERTV880MFXmwK8Xr2cLc8R8jFMclupRUmVTSE2KpkVht9DjxAl1axSlDzHLalipxEua21DiCYv60KIeo5NknlKuj1OGaMOMb+hCuGMwVHMekip4aMkelv9K3xiJUdfOTFKwh6jTyUlxVYr9TGYKhU2jTyNVa8902dMunSSwO87UXPHXpGRRBgqtUl/M3zoRrfCo+OodpSpXh528LyNdGhfL4G2Imh+L8xR8nZ0QpTIHs8b0m/TTiXWi4nuSWmjQuLKBQkX51yyE8rz8hCL26eh8ULyxvap7KA77USIenOQifBOrNJCTN9zu0PyN2aMpj5TW6Wda7IRCbeXe6Vrp3BhbwxVChDvL83PqcqGEE1c1oUQ9RycwjiMH58WlhsETV5PshxzDyQ2vdOqnTC5vE9DVOF7UvDQ6djKHahwW+sbQWKNwUuYnqeQsGngkoTvBk5jxXM2Kly2MQ0gPxtKUKcTd8yEy985ue3hkQSovYirgxSrNvLVd8/xOy7JL8eMJ8L62HAsr5+TE+40oyrg5xmRuM3nyw9+9ZW+fu/jlPlHHjrtKUTexnOEklxtcjzHoX1J48jJj89Bhl5T/yWS7/3o89TnhreF50pV9jMpZbJdnoifxkpFtirbkupV2Q1u8/cFVy/nb8qyIUQTl3UhRGNDH+5sjlN6DiDtQvJ496o5NkN1S8m/niPhOyW8DVwhSs7QnZgbUc+10HXo0LmtmIZzqM/02Ib5fL6wjZ2r1rTC9l0o84EwWaX2eK5OwvVk0d6WY/aJO2snsgxf8XpjHE+qWxqTJBIMe505c2Zh5UwVcpU8Myb2qh25e+zw8HBhLHkuiN7zsVIluftvSWi8P8+dO7eQwD42XDybLea5kNSQVOu6rnCovtz2PtSWwqNzTfNVSldSMNXuVe6Tt5nqw1ItKjhfqnbc2cnPB/T7p51MIUbOY//+mLZMux8559ivSTGl6sS+r+q2UYgugrIuhGho230ymCcpq+wycyl2Vfxe3dwo0AjQWafdGMdpR084Vf18CzSxPUFV+Mx/GFKIiMF2JDGpyFGVb1DVj/kpTjI8B8RxW1skzEO7l+SIe5jsr4Trz6jq4XkdE+bZs2cX+qm17GC2tz//EFWeyZMO/0s75byOjq925LWcYIp8psRld15UXHwsen94G/TGDEMtJHgMoaX5wmtQKfXclrSTTHOKChZtDBcF1XymskTips9dLfKHxbriTBXbE+a9Hc+evbDTLM177+fq2AW1fdqV54SNJEz3UO1mZE6kMF11Zb2onPp1+fDhDSG6CMq6EKIxCccpbn5aeFx9CPO4+D0sd5z+FGaVKrS0ar3S4x+UhLi9feFp276iTPg0xNWKkwbM39fKPqk2Cduda6+eNPa+rZt5UAmXdXEC5buT3JgnTNW1wnVH5/dAPK83nbc7F+VjcXXsc4pYXCXrRedI9cWJKsetruuPSfA6OwnXdXgPupZIifdlFZIimUp9l8Ym85qSWlm9PF+qlwyufEiSgh5mNZ/TWPUDHR3X8XjPrtzxsE4uEJy0pXlYjW2Ox0RWPSTsY6WnonL3nI87D73xGp6L5n3NOTHFQtzLhhBNXNaFEPXCWIzJ88GCp4Xn2Ht7e4Nbo4ewdnZ2onFLiYd6P60ihwgZQ2e9eHtVX6kNY7A9/p5WbT1MN1JOuvwe2AdDeL2E0SSnk2R6uInOlb91w0zikRxThcuEer2fdnopLDYWUyFG3qeHflpb3lnj48HxeN9pHKeD8+TAubBQ//r33Dkz7JhygLxerghW+URsJ29r/c7rkeZL5aj1WXVIon+f41pjLj0cln3b22Dgu9jc2Xsek6cL6F/P9emF02Q/hLmzs7OketP+bm1tLR0roO/x+p5bViWB+7jU+7SL6u80Vjg+uFngtFSiDSGauFwKhMhfU5QxOUvJEFIeXxVr6LEWNJiVs9HnVZEj3dvbOyJFY8/N4SreD4VL2MSiEtHDSwTGlQzH9ntgAiaJT8KpQk7EbW3RUSdDT4PJVSyvqd95vs4QrjtkOhUfjx668e8xSZjhT4YKnPC54sP79HmZVCQm9hKHxIa7fVhvhao8VOvXT31IUpUIpK6nQiLHfKOK8FRqxOHh4RGe5+lwzFbEXiGnZFvYtr3coOqQQVc8emSXas+QCpbq6KFMx9T/fQxX7eqhY59PbCeGwLy+KTSsRUbqS5/3XBT6mJpaJdoQoonLuhCisTu/plKIhnDc+ZxEIRpTL+J6e6yiEI1tR+UScSXokjEdXcL2lV8KgfQwue27tbx7Zki58JAWf8827eE6diX3ywincIHnwtBAj8XlbxPZcse9v7+/FM4QJhNu3UmlMULnJqeVVAw97LMid/5+da5WFQ5JiofnL6WjMFKdfKt6IthJZdze3l4iahy/abxpnqZ60Imm/lZOmBYxfL9SG72dPaRIzKp9SCq9Hfz/Hn4U9lCI3RdHiaQ7pvpNdUp5ShyjVT2pytM++bj3e66eNXdc+98rG0I0cVkXQtRLyp16IPqqJb3kbNKOrlWxhnZk8OUPKlwF22XvoVdKZh2TKyXDwSRM5k0MhRhoAFnHhE1HLryDg4OFUEBr/YM2PYdJjs0VCw9VuKzOVXDl2NzQOi6VMDkj9ZmSUUlE6PxTHZ2U+fc874cEiiFBqlrs96pdEyFK31U4hCcRe04Hx3ilVFSEqJpfUi2dKJDk99RAx6QT7qlRKXzG+vXIW4XJsVL1ARcIPod66o+HLHnP3kaJnCh/0OdrtajguPDPfcGQ7qtHwHqLwRR+5JzhvSeilojmFGVDiCYu60KIhpSNqZSh1sY/3NVDQqeJ5YZ1rCI0hOU5AMmg0iiTGFTYwuEKWBK+nHoViuiFIRO2sCjrO56cVEXEXL3xeyfp8pyC1hbDq/we65hyUFpbNuoenuCOHOYs8DqeW1Vh7u7uLmH6zjCOBfWthyo8t4TXS45bTqLXt6ozlQERUw9DapXe6z9hVvNLn6fEbo014fguOj02JykEbAOfRyQPDKdR7aRapxA6iXcvfNfaMsHW/9Mhmx5W5JEZIqhV6oCTnGpR5+3piwcumqp8Jz7wmbgJT+EsVz1Z5xRiq8KFbLceOSbulGVDiCYu60KIxuT0tLbaSdFVGaMQ8WnPNEir3sNQUqa/PNHPsXv3wLyMMVieCCvDORab5wklQpAMDHctVc8vcqMsMsCVbwpzVEaNeVTuJJx08fdptxQxZCRT29LZEzflSrnz5HUcz9vJ+9qf5M12S+eztLbseBjWUNE96Bwsx+R3VCd+lpSDtDuR403fTXOC1+VYUGK6+ncoZMfPPf+nGktKLOaOLY0ltm8ipmxTb0fVM6lPKSzJ629tbS3MT89tYtuPCW9XfZHuyfuKiw0S4bNnc35hRXa93X2Bxvqk8aXcPCmh1QYMYfp9UJ2bmgipbAjRxGVdCFHFzn13GZ3XSUo1MTjZq90Fq95Db+WRjDyTXodUGr+HsViVc2HYaMgQME/FDWtvtZvadAhb9ZWKVe0y6Rk91tVxSVY8/4Z/s41TGMNfJI0J15NSPSfI8fx3vVc1bnVtEVHf7ad+o6Opktb1fykQOzvLD37lip7j07dEk5QncpswSUKUK+ZJt/oNH1hKgqfxmBSMNIZdOeSDmHnPJB2pTdVe6UG2aVFEpcfVHY0VFU86Vl2cNHCh4PXkGEltU5ETKuu654pcJjuhNmK7pJOs07yg/XDMnn1wskbbO8UivCobQjRxWXdCRAPU2jQKUWvDhIg7MLyseg/JuFVhLBqPHuGq7iG1Yw9vVVwWGlq/1ph8Jq6sh0gmcwRcVeiF6FK/JqmduD0sb/ux6l+Fy9V6Whk7XqVI+bhNcyftGKNaKpVhCM9zSarkWOa2pLBFD8/7s8J0pYa7rRyPO0RdUeAY8nyq9HiRecg1EVlJ9quqY8L0beWu5lTkhXVLYTzdt591JrKVriviWdkVYgqL39X106nUQ8ncXj+fq1WoO+16rHaakTCmeUQVeKxdXKVsCNHEZV0IUW+lTaM+RRkTMqNBPAmOjE3PaSUjvyrp8zwTN+C9eq6K61jenpWRcYPnh7wlbL7P/ye8IXWITiHhjsHyvDIfL/q/h5aIS8eRVqCeY0M8x2RfJxKQSGeVHC4MOemkgCkxnGPY1QPmZZBckvz18JzAJ8ykAuj3zNnxvqvw0qKlam+GQb2+Kb/IVc+kuqlPvE5qI34/jXMmbvvveyoNf+fjjkpbGlesC0kc+ybl7mmcp7Fb5RmxHVwpq8KbPv4dk/3M96jonXbYbEOIJi7rQoh6K18/L+U0sThB/VlNq5IUOt6h0IonOjrhGFKlfBUz5lwnJZL6DiDHbi2v4rliqgxZMsCM7bNPE7awnJyOxaOB01ZqN3CuFjiWVrf+EN4kybNtpSA5LlUJ71P+xuuonCY36L4KZuigIp1sa47xdO6Ut6erf04cfLeQ47J+fn21fRo3/p6uyTZ2XGIlwqLFVqWe+f2pDolUSYHgHE5ES8U/q7akk0ixb6ujQJIylsidEwbvU86zc+fOHX3OEKHax3OW1P5JsWRdSML4mediJZvAdkt9W43FdD8e5tOckDrI3WhTlg0hmrisCyEaq9rQoJwEaz6fL0nh/vIzLVbFdxIzRFKqAwnn8+Hj4xNhGkOKiEscry/xe+RsTAjJH6ipkrBp6FLdV0lY97o6bgpfed3HtqkMPMmKt18KUQ4R2x5+hZmUzjSeEvlJc8Qdfcpn6Y1VH0tpt2O1K5AvP+F4aI4K11XK+TxvPdf9eRs70ezNTf89c2Gqwxk9BDSbXVAq3EaMwdTYns+Xk8zVFqlPSUz4vWQL/MG+FUHhvfic098iYTyXyDF5r1IQXdVyTJUqrJzOcvL8uqlVog0hmrisCyFqrZU5JxqkU8qWvgpJLypTx1GIHC85HL62t7cXzmxJT0Mfiz8Gz3EPDw+XVrhpld/Dqxx2L2lT110FewivOtDNH3LJ1WrVz34mVBWam88v7LxzZ+DnAakOY97zNlsF0+vK9vM689/eeOGKOrVFUjhZPAw4htRSWazOAPJ6+Lzh/4fGJ0lktQOWh14OjR/iVDu85NjZRun+OG8YNmLx/KsqpEQFxTGTuuWKon7ruxdle0hs9PLwl5N4/76fTO/kzTFTXc+cOXPUNnyYMfvRVS7aJJ4MPmXZEKKJyzoRoiEjPGVZRVmYAntVJeOkk29s3tBU2MLrJVL7Pfk2cOYynRSPhNCdSZLke6oG8wlaq4l7axdUCHd2TDDWfTPHgnXu4flW7iFMJ8ZpRxWTkltbVBh8nPgRCb7Cl6Px9md4h/WhOqPcFSfyYzAZfkz9rjGRFgqucJCY9NqXoSFvS7a1h6PURml3WYXJMSpn7SoJCYa3n4fhxmByfGrMeHurLlQSdeaQiFMv0T/1aTrCw1VVrw9THKqTvXuYVQ6Z/iXulGVDiCYulwohSo7qJKXaUXFa2NW1ewTiJJOvh6eVZa+9V8EeCndyFUrVpjJeQ9hDeDzokQoK+zPhptCSk4PW2pLzTJhO9pLR5e9p9JlX0doiuWVdSGC4evY2TuGLFM4QnhMob1diUiHxwxp7YRO93LGLNPlRBxWmts0zpJNyV/SZk6HZbLZE0tIYINlQDk+1vTvhpsUAn86eFDxX7USKkvLJcdi7F+KPwWQb+1ju9a8vAHSPrvJ7n6bNEb4hQd/37zkm5yBzgIhZKZ1MrHZyNGXZEKKJy6VCiKYeiGMfccGzS04Dr9pxdlLcCk+nGSfHMJstnr8xtvBaCVeYrS0eRkcjtEri/BCej5d0kCAfl9HDJda5c+e64SQvjnt4eHjkzLirxpUN3dsQHsMAFa6+4yc/ewI1k3N7ZLnqm0rV4enIfi2dzeR4HmYZi0ncandTCtF5mMbDTwmT3+d2fx+Pu7u7sT2dlPcwq7rqPvb29o5CZ71HIKVE7eNgcuFQbdcXBv+WWtYrFVF3ApfmheYx77MKKVZ1TKrdcVIWxpYNIZq4XCqEaMxkWqWMDWGlnJbTxJMBOMnutiE8SuHJ0K2KXa3IHfPs2bPRYDvukAEag0epO4UreF9cFae8E4YQqhUxz9RRPdwRzucXtpMzrOS5L3yUQW/FL/XE287PfGmtRVx+j05uzOnFqb+8vxOuH0SZVAbm2QxhJhWuteWdVkmBoxP06/TyrTxcw5yYFHpJfXju3LmlPJ+kgDGXpZc/5RsxxryofAuPiwOR5pTr5CQ+jU1X3hxTuBqLInRVvmFvkTObLT4EmyorxwUxqYARJ40n1dPv/6RlQ4gmLutCiMbs3plyMI5RiNLBa6dVN77cUK6CLcPm9y5j2ssdEvEbi02jnc5I8XDGWFyGNojN5GY5HndM3GZdkUIZXa4o044+GlkZR+9LGd+UIOxKh5ygbzn3bfMMF3lC7hhMD0HR4bBdqvHdy1nyfB5dx0NfCpPyWVb+HbUpj2HgNdlWFaY7ZKk9/rgG5rzwGtxVxLqmnK7Uvj6GqZj0xiFzg3wsOrFK4Sd+xl12TD6XcuR19nb1tqW90D2SqHNsqL46rZ5HePQUPNmP6swhvwdvK38ivY4CUPslopxCuwnblVNef6MQfYmXdSFEvZUNjf9UZchJS6adQiFaZdV2XJVGpVqxcXJXL6oqY7CJlXIpmAhatXHCrRQiVxsq5zqb9XOzfFt/Uoi8P7iidANP5+ZYvA8nmLqu79DhuKsSZ6laOSYJMds4jf1e3XWt+Xy+dB5LOreH7/n2cO9nEQBdV4oR29XzP6qzgqqEYfYvVZfUXk5mUoK5j/UxmKqDdnL6g0x9/Hg7EnNoG7vmCudACotWeTXVfOF9zeeL517RBvCcLvaNPzx4yFZ5grgfOcDxwk0Jqd39s54tcjWuIlVTlg0hmrisCyHqqSinwcyHkop1sN4U2L04u790hsdxcelwfML3cI9Dvpw8pZ0/Q21MZzWETYUorS5TomXVxkO4juWrdjqKnpFNuN7OFRlMeK31c6g8jyQdTOcKAdvA66PfeY5N2sHF/vDEXIZiiOd5LbzXMZjuyPVwWy2g/MgErx9DhfxMv69CM2mHE/vWyUNVxzGY1WMnmNjN/vX79c0Cnp+V+p2qlSf1c/yMweO1/aiCNF9THpjy6Vw1cnVVxXOJUvul+/Uxub+/v/BdLiymKBtCNHFZF0LkeP7iamaK0nNk7mimwB7Co4HS/5mMfFI8n9gJd5UkzyG83d3dboKnnENr+fDB4+ANkVwfyx6OGkqs9tDg4eFhF9NJqQpX8CRCY/BaWyTzrsB5W3ruhL4v9YChDVcn5KDPnz8flS7Oldb69oKqBP/PM2HcsY/B9HHgxcc0H2bqYaP0jC/vUw/vupPUZ5Uyyof8JiUjYVZkbh5Cyx7iVPiQZNSPPehhtlY/HzHVYTa7EF5KOTqOmRYNKv6Z8EiwfbOAcFNydKrnmNChE/opy0VDiF7wghe0c+fOtTvd6U7tmmuuaY973OPau971roXvPOxhD1tq4H/37/7dwnc+8IEPtMc85jHt8ssvb9dcc017+tOf3j796U8vfOcNb3hDe+ADH9h2d3fbV3/1V7frrrtu9H2uCyHqSbYamFMpNq0NK0SOrXs8Dn4yGum1u7tbOtGx+ExSHFu/hMst1hU+/9ZKfKievuqvVpipcLU/hOerSBlI5bJU442G3uvmj+6Yzxd3Cu3u7i4QTzqDIVzfuZPyMFJY8uDgYGm7O/t+yLEJx/EY+vDfeUKwFgyq+/7+/sKY8bAfnVHC83sVGUyLFJK8/f39pfHpde31t9dRY8D7lMqGqyFqyyq8xbGd2jVhqk6OK8JBR91TSD3sJpuaMH088n2SA/VftUkjzUtipiMx1B/+tPvWFk+z97HVC89LxZYtcFIoTNaDYbOplSGVi4YQPepRj2rXXXdde/vb397e8pa3tMc85jHt4OCg/eM//uPRdx72sIe1pzzlKe1DH/rQ0YsV+8xnPtPud7/7tUc84hHtpptuatdff327+uqr23Oe85yj79xyyy1tb2+v/eRP/mS7+eab24tf/OK2s7PTbrjhhlH3uS6EaEhB8ZXsScsqeT2+QlsVf6w65K+Dg4N4nR6+OxgZq2Qsql1MVCN6+PybK74U83eHou/6Azt7W2SZQ6RrCKuXLCkj7G2i/+/v7y85llQ3Xk/f9ZUo70GGv8KVc/FDIdmHdHq9xNoKk22afu8kKIX10jZ1XksqVOqTXthUSbmOx2vxPn0ctbaYmMtk9BQGkiNMzz1Lc1Sf+65EbwuGPFN9iTtGeXHMVBfOAY5Hd+g8zqLqf10/nYLO++QOQdoJJ837+/tHC4gqJJbqSRLm40svkn3H7SnSSvbW77x9HZNhttPIYVW5aAiRl7/9279ts9msvfGNbzx672EPe1h72tOeVv7m+uuvb9vb2+3DH/7w0Xvnz59vV155ZfvUpz7VWmvtmc98Zrvvfe+78Lvv/d7vbY961KPiNe+44452++23H71uvfXW0Q26auGAOu0ypGi0dnyFJpWhcI4b3pPgr7rLzA3SKvhcBTG+PnYFl3ArfE/+9Xh+MsB7e3vdR7RUhbkv586di9u3K+e7v78fd91VuHRwIhLE4wq5hzmfL+92SVvKPV+JeHQGfi96MYHZc7lcyXACSnzHq8iJfsv/p91wbC/iklAlPPVBb6wKU++nHXNVcnIiYIl06Pt8qKnn1ChZmvX13BgSTa9jRcRkn0TWuWNuNpstzO9enT0/Zj6fL4UidQ/VGPe+rtqThFT3U5E5r+dsNlsgqZ6I7WN9NpsdKcV+XdW5Uo/9QbUaf/59n7+noRJdtITove99b5vNZu0v//Ivj9572MMe1q6++up217vetd33vvdtz372s9vHP/7xo8+f+9zntvvf//4L17nlllvabDZrf/EXf9Faa+2hD33oEqn6tV/7tXbllVfG+3je854XO/liJ0Q9xcaVkilKheWy/BTka6xCNMUWz+OoUcfFpSrUa0d/cYWpVV9PGSKWrwrZV2OOUmDujCfcJiy2J/NfZKiHkrhTzg4JFx3GEF5yeLu7u0vO19uFdeRqnwpDUhEqFYxbxBOuK4QaU8nhJqWpCl04EUyKoeqWHHG6b92bE01dMznjtC2baicXJNXRBj1MJ64+b6rPqq3urOPZs2cXQmNazCQS15tv7BefCyTaiWyQbKW2dLXK84RSv1MF1bzhNUi8Kl/jhIgkj/NhynJREqLPfvaz7bu+67vaQx7ykIX3X/ayl7Ubbrihve1tb2u/8Ru/0e5xj3u0xz/+8UefP+UpT2mPfOQjF37z8Y9/vM1ms3b99de31lq7z33u017wghcsfOc1r3lNm81m7ROf+MTSvayrQpRWc5o4q+5+GlMqB5Yk/JMqU0P5UaprhbUKfk+18NcqD1FN2PpsTH4UjUpvtew4ep+/SfXrERM5/2TQhuqcCIjw/D7ceSYlYqhuPWUkOUpf8VchqITpDlljkH+nvnViplCQt7G3bVKoeB0Romo8+QF63m4J34laOoyymi+6dupTqna8B8erNgz0MFu7cBaU1F2G+Sqiofthbp1vT094+td3dRHLCQbJD/HUphWp83qyffxBs2mO+2eu+KV2pQom4uSEO4UU1Z7pvqcqFyUheupTn9rm83m79dZbu9973ete12azWXvf+97XWjsdQuRlXXKIHC85uykHYy8Zt9qFcRL8IdLgiarEOg5+D4tGQMbBn92zCvYYwpccJ5WhCie9n/BS+3I3F43mGFzH95ccrzs77qBywuNKWIWd6qLEfv+MakrCrAiSsJNiklb9jsl2IbGu8Kvwm4c5WqsTg101cLJV1bsaj72QIPvJz21KhI/4qX4+r4cw2acMLzouH6pK0iKVhiqg43nunIefXL2sSArtiY+vNCddlfV5yvZNxxZ4iNjr6XOEKpj3Oe/b8ZKieMkrRD/6oz/a7nnPe7Zbbrll8Lv/+I//2Gaz2VFC9GmEzLxcCoSIDmiqMjaHKK18TxOPEy8pCGOL5xuMwdSBaMfB9t1DlSNKq0aGOFwlq5Qjx0srfa6Sq3tJKob/ndpPBt0dGslEpQLwkRtetwpPu2ychDmBcUdUJcpWDpxtJydZnf9DMsP2Zpt7wniFx+TelE+oMeWYXocUMuzVT22RzrZxxcoXZom0pL7znJyEqZcwPccq3U8KZfrYZj9XoSJd18eOxqZ+P+YsM45jfT+1icYq562HWIeUbieLHBMiitzxx4WH92kKG6Z+vGQJ0ec+97n2oz/6o+3ud797e8973jPqN3/8x3/cZrNZe+tb39pau5BU/ZGPfOToOy972cvalVde2e64447W2ueTqu93v/stXOfw8LBMqvayLoRoSGXQimeqAdnD0osnvXICnxYecbnqcSc2dA/elmfOnBm1DZ8KwyrYCa+1LIcn48gt1Anb8R1P5zWlnUiOub29vXBasF+bK+JUNzf+3q4cJ+6gHDfVq5ffoO+JXKex6aEKjuG0tb8iDCJtukff2s97T7krJAv8TuXkSOaSA/brkKj7UQ4pqbzXh60tKjbqJyoyChuR1Hh7VTg85dvJdkpSTuOiGvve5h5CYx9W+TWOmRLOh065dzxeT7vNmODPOZ7UvbG7gH3s6/+6htq+OrhR82Ns2J82aYpy0RCiH/7hH25XXXVV+8M//MOFbfUKY73vfe9rz3/+89uNN97Y/vqv/7q9+tWvbve+973bt33btx1dQ9vuH/nIR7a3vOUt7YYbbmjXXHNN3Hb/jGc8o73zne9sL3nJSy7JbfdDqwFfaZ60DA18Jp36BF61jA0pucztJMyddYWVjAlzEtxJ0FALYwy2Exg3VJ6gnpIrE0Yin/qsMl6uyOgwOnescmhV3dw49/JZSLZ4yGL6bcL1eo3J/WIbMhRIFZPXSbhjxmO1pZrvuxPi770de6EbjcsUytQ4oQrm9XGHNdahMg8pkfeUt0bykNqslwytF4lplWzM+cV27o0RVwiZuE5bluYIcVwRd7JbvaowqedVkbD4Cd+0QUOvXo5pygdi3TyHbogQUT2fslw0hKhqGB2a+H/+z/9p3/Zt39bOnj3bLrvssvY1X/M17RnPeMZSxd7//ve37/zO72yXX355u/rqq9tP/dRPxYMZH/CAB7Td3d1273vf+5I8mLE30ZWcOOWAHOMQUm7EcfDHTnCe35GwxtzDWKyEy7DFGGwSmLFYPCnYd3oNqVB+3kwaJ0P4OvyORr9Xt6EwAV/e9iSFCdfrRdm/enlbt7Y4d+jc1caOW40RP1+IibPuGPx+5/MLW6gPDg6OcKgUed08MZ0hKU/a1vd4HZHzpJilsaAt1r6zy9tV+Vqsp4fR+H3tznRMvZ/C5U4i2a6qly+Mhsa4xtje3t7SDjf1v2+5Zz2dcOk+xoS/dc4S21R17GH6nNYYTfNgb28vnrjv48FVQ8+H8rr6uE/zfvNw14ukrAsh6q1aZaCmLGPzaqaYAGMVoilwNfHHbHs/KS6JxJgVlmPP5/mAtCG8Kp/BQyXpjBruOKGxHIPljtaJGQ25SN4YXFcC6LRTrpTPSxp2V0fm8/kSrq/kqb601pYcqeejuVohYkOH6ISSaswQnjtR5npR6dD12Fbu1HkPcpgpOTslq/cw0wYIx1Ufe0hPbe9Ov0pAl6Lh6mj6u7W2RGD5e+Lx9HTh+lhK7Tk0z6ncDGGmMaH7SEcWJDLPnXCuFPOavjDw9k3HJCTCNmXZEKKJy6VCiKZk5mMc+JDDHIsjQ9Pb7eKG+zi4rnL08PwE2VVxk6IyFKbwXXQyZGlnyxDWGDw5NTesVGrS4Yep7lSxaGzTc8R0bc/T4OqdhrpadQrTw47uEFwBcmcoddXr62Ml7XDSd4mn/DD1jSsurKs7fjpdhodSm3hfsl1UL/1O+Ew893CIfuN4uqcURnanzbpoNypPnxZudaggF3aJZLidY7+SfBKX5FH190MwPYzKl8jcEKba++zZC7tDdfozd7qRFFeLMses5hj72NVObzMPBTpmIjLEJIHn3HX1b0OIvsTLuhCiIYIy5UBMBjfhuUx+XJyx5EtGOCXBroI1lCRYGf+xCeSORYMytq40jL06U85PBqyHl6R39mXKy6BR9hATHXqVK1LJ/cLVtZgzRALlW/LpnHpONKlhqZ19XPO3/r0Kk+3Xq2siP6w/6+ere3dqrpqkuqazibx/EymryIKHrKrvMUm+6uPZbPG5ctW4ZdtVmG6XOD5bu0AaqYxV7cp7chIuIumYjsfxMmah4ikQXBTxXv2EfRKpZAs4Dnx+MvfNFwi6D9ogKpvsj03I7Eu8rAMhGhNScqNzEqwxTvvwcPFMmePipCTm6qXVnBuIIZz5/MIZN2OwkiNJ4Zq0ekxYyntSW+m9oZ0pNMbnz59fWNHTWMrw0WA53u7u7pIqlogvd5uwPh6a4jWoSmhcuErhmC6/M3RB55FyWjh2pKzxYL4KM7U5n3Te2uJiwHMnpDCobammuS1wB+KH9qWcDZ9/W1tbC+qC55ERU+1C1SKNdR+7zKnZ29tbUDf0Gzn56gnpvmMujWWSMJJbjVvlvqiNKxuUNlb0dh5KkaqUKilKJKWpXVtbflqAK47CdEWKeBynmldJsSEJ97B5UuyER0Kj+efKVfUMNT+yweuf/JDaju07ZdkQoonLOhCisYrNFwprCmzirKKacKfKGIXIV9wpeTUZhmQwZFgq7AqryukhyUkHpun37ujp1CqFKOG1tvjE9RR2Ii635Ooe2Q6ea8Dvso0or1fhNb6E6+EhHlxZ4bXWupjV4y3kUDycl0I6ad77k+y5ik+kSQ5R9U27udjmrJ+KJyMPqWXqOzowfq+aG0l9Uq5La4vnDfFv1Z+fp3GWxinDQhqfu7u7C+9zswGVPZFrbwPdX4+0sS/9ffUXE4ipLO3s7CzVp1KjEwFnP3I8JMKR+rdn16hqOyZ305FIeYjcCVFKtt4oRF/iZR0IUS/GPfVAHIPlk+I42J7AtwopWgXX8xz0G78en/YsI1GRokoarrASXgofuaLi+DJq1bZuliE8EktP0HXSoDpXOxmrRGo9Yy9hygBXddV3Uv2G8IhJhyQFhBjp/CnH9XlGx+vqgUgLjxsYyutggrs7tfQoDa+jkqVJmJPSo99X4UOFTXxecHzzWv4et+P7rqj5fPlp8anPRSjZ/h4uTmFNLgj03UQuSUR533T+3q5OCF0xTkrR0IsK3Xw+XwpBqZAAcs4nG60+T3i6P13DN2+ocFFXJbFz7jFSoP6YsmwI0cRlHQhRa/0kYF85TlGGVJQpJ8CYhOqpcGU0kzPokZHj4FKZqA5cTEm+NNQ0PkMEcCze9vZ2TPSczZZDawm3IrN+zgwdkCeXuvrTw/Wk5ipPhg4sqWXcus02cUVNCoPwSW7S71lH3WMPU4nX7pj9ftMKvNcuvqOK/85mF7bVVw9W9Vw5b9OhvqBy6aTVNwhwHKQxwzHXw6QS5CQ7hWx9vKcx7ngq7viJWy0iq7C4Xzthkmwy/E6SlGwYCSPHHNvV5zBJZcqL8nav7NiGEH2Jl3UhRD2CMvUus9bGnRztjuO4ZSz5cgNbKTVTYCVCsSpuUil6LzfgXHlyV0+FPYRX5ZTQMWssuTEkNh383JI8eyd+8/BLD9f0cPWdFBIbOj6BK1geDukqT5X87MqLk013eAolsd88kVYqQBVuYDucOXNmqY7qB4aSqBpQIRo6gV1zmPebxg6/o3ZlHfzgSK9bUnd03XSPDEmJwGkOEJMOPIVYEybDcLwP1dHxVDy8WCXfe75dGltUiNjexGRdGMZ1tSgpyV4/T37mOGYokvOZxNwVMe8zhjCnLBtCNHFZF0I09Kwvyp5TlDEOfKrTscc+x4yPDJCxWBVbWGMTuU+Cy4P4xoQh3ZDS+I/B7uGNJWXclcIQDbG1CudWX+6KYq6R12+IaDou66EkVb5Px5RyUra3t5f6vDr1WU5Qya9c9bJ+HpZxTG8jV+PUZuxv1q21C1vDGU7jAsRVpwqTzn9/f39BGUrt7OqAJzEnB6vr8z5FKhSCZTtTFUp9pvvyOqqeVYhdOWCeRO0kyY8H6Ck8JC5V8jPzfVxlYVuSkA/lEOk6qZ6+OOJYqlRFbwtvc+YFJlz1iXCdHG4UooukrAshqqRXj39PVXpOU6ue6sToVcvQbis6ayZSHgc7OZreS07/OLjCErlxvB4pSyGKIewhvCHiqaRTl9P1XlKIXEGiodzf319YSVb9rGuksIGHR1QqPHeWlYLk16KTdjJQOQI54ZRnVDlY4bojrMI27piqh9j2MOnU2CYkYaqfJ+5r3qV2TfeR6ss2pNNN7el19JCy2qg3d9wp6zpOzDjumVCc5mEiLiLQaWGoupKw8zecV46Z1Bq++Pw9ErZKNaKP0PeqZwwS31+8H8+l5MJtyrIhRBOXdSFEvdX9aRCiMSdVTxUyoxTfw6PDOi6uh6CG6kjclGg4Fqu1fC5NL1eJ5GMM9hg8Phqk15893BTaUvE2pWKUkrWJ62qYnFSFlfB8he7G3XciJYdXPfCyatP5/MKWdLU95w8T9IWrNk0Jqe7cEp6H5RKm5wLJMXIeeb96SFEvfccxnSj4b/1BsK4CJiLH++L1SZT5/Z2dxWMNUmibzj7Vj33tdUzjjGGm1K89IqVrp/wvV396OVBJnUrKKu+RShDvhX2R5qnmihOiCn+qsiFEE5d1IURDzpurkynKKonOJ8XWanjME+dPiuur1FXwZITGYrvSMmYVnxyfJ8hW2K6w9PCc8PqukyHcKvG0N069vX0lKyKke2aYyhWrMXjC6GFyhS08OiFv66E+lBNNCkuFS0WqteWH6SY8zzupMN35Ux0Q8dO99BQCVxVSjpfaN+W1JJIuXMdj+IXjlH3hRDKpSd7OleIyVMeEKXKhl5N+4lYETGO8h1kpaCIhVIV7Y6a32GS7ksBxk4cTWK+v74CcqmwI0cRlXQiR4/nkmip8pTLkuIfOrFilVKuoHi5XY6uuTobwkvEgVi+cVGH5DqwxL7/+ELavgnt4vh2ddU643s6OlVae/mptefU9BpcGnivVFOLwvh2LSVwSMiYnDzlU/aa1xQWFHE6Fm+rGHYHJgfn758/nA0vdwaW+01zi37y27svng9osEciU6FuN4xSGTOFCDzVVRJJ9wfsUdgqVJ8XYk6qTgsJdX7LFGrM9EsYcNrc9vtNsHpTE+XzxoEzOP+HxPvW5z/XZbDmkRsKa1OCKbE29KG9tQ4gmL5cCIXJjOUVhIqi/NGl9oh4XO60oh3BpSFdN7h5SFWQ8GF5KBs6TPxN+CnmsgsnrDGGPWQW7k/LVdYVbhdGq1b0bZDlRJ3QVrmNTqq/qI2d0EszWFtWvFOIcCicnQtfa4vb9oXpWL51rlPJOEibHOlWaCi8ptSnx2Z2j55QkBSctDnTPfg90tKmeTpIrO6J71/0IzxcoifRV7erEyNvQc5VEQojX62/uyHN1uVp0yH6wzn7aeNVG6Z56YbLkG05jh1lrG0I0eVkHQuSx9N7rpINSWNWk8V0ox8V2VaVHiLgzhqsVTUwlSCf8Sr0Zakddj0aPhoGrU4b8ElZFwLzOCVNF2L4qHDq/ZEw9ZXAd19/j38q5cGfmeRXJ0VFeT9f0OkvB8LOMHCPlKjmmS/4eoki4Q+3Hv3d3dxccP4kYCXylZiZVxP9OtoD95GOwh5uc6xglU/fBJGwn0mk8sb3o+N2O9BLw1bZJmfbxlPKlUvux39L4SuFbkqR0plRaoHBMVOT33LlzS2SNfaq54G2k7yWSq99WdazuiWSWbZ/ue6MQXQRlHQjRWDI0xaBcBesk2FQbkkGZCl84blTG4DEZ1nfYkKCxLgmLePzd0GGNkuwrkiFDRqdT4XmS7cHBwYLj8ERkOpb0HbU3x4t2XKU2k7rn5MdXrFqd8vwWkoBEgNh2c4QSEqYbdSax+vk5UlSclLDf/B7UBmxrXYfkiv3F1X8KgyQHlVTHnZ2dBRWKikYi2VKaXL1IOTH+4rjjmB4iYsTUc7DYhmqrRBYOD5cPd+yRPD+PKfUx+7FST3huVsoDo53h/GL7p3mb1E7fBcfjH1RX2jRel0c6eF/pukn9S33m7aK+Iwke6ocpyoYQTVzWgRCNCSmdNI+HWKselOhbSVfFOXv2wtkuvXAEjQOdQC9/ylc3vooas5vOz/bgWSbcDu9hJBIjGTGeCTNUx6QGMLeExp0ruYR3cHCwRFDSAYNudL2t2d9Ubugg+MwnnyOeJEuCMhQOoGFn6FA4586dW3KYjun5F2zjdDaLj1WNN7WBO5itra2FNlCbtpaPEPD55kSEJEkHMKaQWXJ2et9Jak8pmc1mCwsUnm7N7zCvzPFUeD898sAXt9w7ZnXPurY+T7hVH7M+rWXlOC0QXP3zYxJ8TiQSobHo89/zM33BwHkuXCpZup80d9OZT1S6kiLqC83kj5LSOkXZEKKJyzoQotaGk5ynTKoeQ8CmwHayMkTElD8hw6TnLFVhsR5WMkb+orpCJ1QlPvpKSlh0QEPtyidRUyHa27twYCCxScxUn1Xw3GDyfBmREB746M40bcuvMNMuM8+rUTtrdV/lqPH+2F8+hhKmEwRXiNLWfPaxK2dD9VR/0cF7CIPbtkVA1NfESKRA4zHNyUohU13UhiR5vJYIXsohcoWCuXZurzysRYefiE/CTASMykQvVOSLFoZemZuY5oX3QS8HKuUctba8Q4197ZhpnPH6nCNcPHkSuY/B1H6c+96fxKO9cUVvKr+TyoYQTVzWhRD5AK9ezuZPE2+qVQKdzRCmr4a4wh5TdycvFY6rG55km3IE0krKjUVPkfIHzFKBGYM9hMdcLL52d3cXSEBrObFYq085tCqZPY0RD8uIXPVwW1t0ihXhdMPPPkuYSalxxY+4TsTSPOCYTJgkYaqrcF1hpWOeW4hC32U/9jB5LaoLKdm8UlFSqCopHtVOvLR4IGGolLmE6dfmYoyf+TZwx/X75+KH7yXS4udUpTFK3EQcKzVU7eXkLJ34rWslQpJ+r35IO9tS2x4cHCyNzZQDdpplQ4gmLpcSIZpygI7N6WHewkkIUdoOOoRL4zC27jKMYx8XkjAdO+UMEYshiFXCkU5GhrCH8Bia9JfaXk8br3Bbq1UNN6qu2KRzYujYHLe1xTOqkuPza/IaFSadnhMv4jIsxi347mjcKSayMJ/Pj8KkamO2JecPHZbnZfG7/LvC5DymeuBhOh6fcXi4+OgGtYnjex4Mc9D4OA+SrpQT5aoDCWNSphKmqx96WLDerxQub68x77HNuTBQXSvctLNNr2oHmqtEvgtQYTriugrq/djacgjPd7a5fUzq0mk9JYFlQ4gmLutCiHohs/39/cllyworObExIavj1q2HexzsCmtMLpE/b2oIm+E5x9re3i7ziGgwZfzGYA/hnTt3bum5U+lFQuW4wk6771J70Xj3SK8n13sfUwWsFBOtZHuYVBh1/621BVzi9cZLRSA87DSb5dAdcYWVyIqcEes5FtOv1esvtS9zcdiudJJUHLx9neDwulVIRnhOfn1hpnHhmImsVonhDIW6Qqe/9VBdnvHm914dTeI703jvDBeSTPiY1fu9EFf1PsN2PkZ43Z2dnSMbRALpi++tra3uAvk0laINIZq4rAsh6p2/ohXVSYkJS4XFV9pqexz8Xt3Sq4pbj8FfFWsMboXP+D4J11iVyM8WGaob83ESnjuRnlMcwmXdmBjtu3DStvGKFFHBSgnps9mFc4V4vaH6OKbv5KoIF3fxyaHxe1TKUhvSme3t7S0QiuR4nMAwR4R4fo9svyGS1LMhzKdyzDRvXE0jrn8/qTTcnCC81vqHmbpymMY266T+3tnZWQh1cYxxrLN/KrXSx1bKg9JiJiU8c7wp9yclybMt+GKeIfE8B455kswRnM0ukDkPgQnbFaKhvDnd79RlQ4gmLutCiIYUjNYWj/w/aRljRB3ruPhpt1PvVeWujMHnluxkcIecRu/6jk+C4iGY6tpeT265HaqbOyCqCSn3Ijk53xJc4cqgamUpZUA4cnbJSVRt66EH4fquoWqHn/elJP20E4zqAZP6naQwjOBhyZQ8rGtW4TW2see8kAj08DwnRaQ02YgUdmE7KDmXfTxUR0/uT6TLHSpJM9UROuxKFZFi45hDCwvuyNQ9aKyQCCXVjISGmD5PndQRm2SyCjmnerLvU5962IxE1vPjPGfM68hQqYhWGi8akx6u8zaaumwI0cRlXQhRb+LLAX6hFSJNFOYmHAffrzeEpwm7agirteUdUKvkLfn5Nl4c350WjeNYTBlxnitUGR83mvx92oGT6k4n0cNNWKo7cyPYzgy1VbhyjHKKKdfIFQW1uxM81YHXqHbusN/G4rl6xbnoh0Py3qoTjqu8joTH71IJqDArdYb3wPAQwye8NhW5NM6rlwiCfu+hyv39/aX8OCeOq2KmtlTh+HLyynus5rO3pY9VjXf+XnND5M6VSsfshTZdGVSbce71drpxA0fKY2K7caFS7XjcKEQXSblUCFGagKeJ5y833KuUscYtkRk3OEP4VcgsGQO9p994zkDC4T2k5E8qE0kt0cpaDk2rNzeOCTslUXpoiytmf0ntYY6DqxgVCaDDEabybGi42R6q6xBu6pO03VpOVyvdNK70mecAUQWqxl5SNXjfFdHRLq2EOzTmSWa5y4j37HiyBVQY0iaCdK6Xj1fdJ9VGJ9s8Mb7aSi4Vg+Pf86X4PuuYVB5iVkonx7knAHtokn3sCpLe5/wXqdH/GZJTn3u+kN+nH4xKzF5o37F4zyRBHDeev0WS6f3l9oGEkePJ8U6jbAjRxGVdCNHQri/mcmj1dZIylPDbM9yr4vtW6TF4nl/RWhuFL0PBVc/YOrrx9VWR56LQIPqqMBnIZPhowHrYrS2PEeZypDBYernaQIfE1buULoXeUvKpO1wnlL7jpsI9d+7ckeP3/B4a/kQyfCXudZ/PF0/bpiomw08HJMyUc6TTtdPjRXycOa7vWKJiQoelfifpTKt7/TaNKSfqZ88unzXlioW+LzwSMZKPSmlIxI0hFy4+VNJ9VpgVrr8n2+D5Xd6Panc/f8iJYsr/0Snh/j4XRSn8RJLrZI5jhDlxtGO+K9XthStSFen0kJzumT6G4/m0wmWtbQjR5GVdCFHvYauz2ezIaXDSn6T0sIhJZ3lcfE6+IbWIuSPEbm0cIUoTPSkeFS6v4SE7KgfcIeOrOZGlIcx0Vkxv91caI8TrJZ7y+543o0KlgKdDp/yJ5JDdITghqnCpmnm+BsM6SXFwR+zJoZ6bw37zc6E4tog5FIZNeSfC9UNGNYZIEKgyVOGbs2eXj1SockGkUjF3iCEXrvwrxcfbu0dKZrPZAnFl2FgEL/V9NTbTbqpqDumaJDIqniuV5ocT1bNnl3O1/G8PobnypPpVdictlnRKufcFlapq7PvCQffI0C5Jsf5OSf5UOvU+t/NPXTaEaOKyLoSomvBuZL9QITMd6V85puNi7e/vl8oJz29Jq+Yx+OmaQ4SIuCQybggcPxnNdFBf9Uo5Uj0jNIRXERTv11Qc2+9T77vhJwYN8Pb29sJnFa7Xiw5QIRq2e9rezve8zml12+uTlKuXtrsnx8m5mrDUzomAeA6M5wfJqfsus6oeVDAZNqwSv/1aHqYeUrD5XQ+P6t6pbnhdZrNlMioyXtWTOUlpcTGUC1ZhOobv3mSSMhdSKacokVgu7NK4qurKUCyJHv9fqeO9owkYdk9tnRZnU5UNIZq4rAshGjpIkFLzScsY9YIT1rffr4Izn+dDEiuyoLIqdg+LeFWoUIWGs5KKHcufXq37Zpii50h62DR4VI8SnqsfQ21cYfN8ISqTcrQ0oH6+T7X9nbjuODyRs4fX2vKZQh5+SGEzjqHeIZoe6nLVsCK8Tpoci06F9fNwG/udCmly6n4Oja6nfB5ieWgsOUZvVypJbouqMeXER23qjl5tqPCQxhIJRm8s6ZWOSdACijYkqSEMAyfVSqpNqi/bM+GRFKUH+nqbsy883ObtxuJ1dEKawm/elySvlYp2WmVDiCYu60KIeqs9ho2mKEOKCQ3rSbAp0w/huUP0EMIqWPP5fKXt9sLlqrRXZ8eqJH0Z4OpepCT0sGl06aQqY6nv93KnVCrlhVh0CErmZaiA9+fjqiJEdNIpNNrD8zZJmMmoe/upvX2HmreFlDpvVyc1SblSG9MBOpE6d+5cxBuqp953x0n1gNcVfvqNnGzCS+MoOWtXgXz7fcoXIsmbz+cLv/X6tlYvGlNo1HcCqk2oYHp/OibHiM9hboVPyiWJS1JqOB7TGUfVYob20BcDKURKMppym6pwHNta8+40yoYQTVzWhRANOXBfGZykjFWIToqtCT+WEPnqfhXcMVjVKpO4fmbLGCwaEw8T9Yiu5y943gWx6DwqPOb+VAqRVntOgHhtd1T+gFa2oydd+9bkHq47IdXbCZE/ioMkqoepexYJSomqyclxDEklcIWI30l5VqoLv5d2/HgOFMOErhARQ/fluImw8b5TyE71rhQiYqS6+hhK1059RHImYsgQmfpd6lpvHqlevttT/9d3fFdk2v2VdjDu7OwsjEMSuhSqpkqXwnCcY7xvhtR4LY5lJ59prPfGTiKtfo+c55r3p1E2hGjisi6EaGiL7tSZ/quc83FS7LEEzCf4cXBlaFapH3G1xXYM9pBiU50FpPfcSA2pU0N4qd9SPpD3x1D+hW+F95wKOqFkqIdwXQ2kQ3DnLQWlh7m9feGxKXKmvI76WOFAJ+FOYuemOLpD8iRZOkO/VsqbSdu1SS6ogLiiQQWDIaBe3k1KzqdC43Mv1VWYdP4+NnTv6V7StnwPE6vPNA75WBqGgpxUVi8nsh7a8oWHkotVRx4F0MtLYl+3tqzIp3A4VVPObxEk1rEinyk0yIRvqmfevrze/v5+mag+ddkQoonLuhCioaTFqRWiVQjDSRWiobpNgethp1WPFaDxGcJOIa5UR7+HKozFhHnHdlm+h7e7uxvDBGl3Co0zV6o9LM8nms2ytF6RIv6WW3y5a02/1wrXnbcTq4TphJgEwbdWt7b8RHrfiu0qlfqnp0o6QdDq3dvA8fi+10GYJHHuzHxLuBw6VdBqV5xvE+cYdKfs96syFErkWGitLWFyvI/BdfVPBKC3888JvZMiT0CnosL+cTLtL43NKpzmeB5G1H1z7KttKpta3Q/bMZFAzh+/xuHh4YI9mLJsCNHEZV0IUTWpOBmmKkMrGxpXl39PA8eNiD90cQz2Klha3ZKwML4u9aDCdqydnZ1BfO4SYdIpjZSMDrFJkvi7hOc7crSt/Ny5c0tyf8LVb3luDLGS8uAG2+vgW33pRESEPCfJV+nuTDxcldrNiZRj00kKS87Rf9faotLDQ/m44nYy6o7Nc03kGL0Pk7pETPZNyl/xPvYckqRSeShN9oaOMh2LoOuq+Pe9PdnHTgb9aBFXplKIk/ORu/G8PejIq/r7vGSdXTHhIiLtJON4dDKXdvxxrHFsVSS12oKf1DguPnR/fkSAcNMcd9szZdkQoonLuhCioV1mUw7EMQpR2qlzHBx3ikN19JyLsdiO1cvd6eGmHTJDWNyV5ddN76VD8ehAic1VHJWahHd4eBjzpLiTKeUIJePO/A0qKLz+7u5ufDwBHR/b1cmHPvMHUnLnkeOlPBAPn9GoS0WoQhxzUzDnpi7JYbhC5IfipdCi36s7R5Ec3g8dVA9TjtqvyRObWV863TQ3/DoiG+7MpWik/DDNDe8f/p75KN4fHl4jQVdokFvD0xlOlTrJeTwmbOlJ4bzXvb29Mnldv2X9UhsmO5QIkZNilTT/dT+JLPk481xJznGSXo2zk26wqcqGEE1c1oUQVTFw5QZ8oXOItFpbdbdXKmPi+3QQvvJeBXssVsKVsee/PWxh+Zk7dFoJjyEil6172EN4Y+qe8hfS/2WIPcmzh1dt6/VwWIWl3J5qu7UIJNu1cjaOS2x3MtX2eREsx/AFhW9NJ2ZPnfFQkIhFhcn2Jabq6qdte/jKSQ8PXHXyKaeecm7coVcJ21USuepYbWf3v93J85Ewfl2/N+5ok6P3fDNvWx/HImRVParcR7WH17NakCocnOyGk05+h6Q/tavu1etIFYufyfZSHeN1piwbQjRxWXdCxIk9JSnqYdFYcrV+XFI0lqQwJ0Ar91Wxj0OI3KCMxT4OFlfBXH2Owe7hpZwJ/Z/5IzTkFSEaSgTW9f1+6DQ8l6WH21Pzqt03dD76vxSkhEtsV16qU+KrM3jOn1/OKaJTJabfc9r95Nf23/QwWdcU0iEWlRaOv0RkFTJjn7qC4b/xvuRZXLPZYjgwqSR+wrau2drwphPN4XSujzCrZH8PpYpgVvOJeIlgcqxVfVmNeRJoXxiwzzl+WMe0SNFnY1VstxcbQnQRlXUhRCnunQbvVGVMUnXK3zituvVwV8GujHW15T4ZubHYVLM8hFDtrqGhcwc3hF3hVSt81t0TQmnwhJvuIakYVPC488dJGMlHDzflYVR4c4QqK0yqPjLivnOHziKNF5JzEo7qUSZ0clzNJyfkfefJ07yf6pEO6dwmOs0q6VakRG1akWxdh+9xEwE/I251PScnieB4u/rOy6R66XuJePqZPzzd3UPjPuY1hhSC9EdZkCQklY/ziNepQrf8vYcGU7/4OPf5pnvrLajUrumQVx9nwp26bAjRxGVdCJHjpdeUCtHYnV+aHDLMp43nBu246tRxd7aRXIzFljNM5+IM1ZG4Mv46Q6jCdryKTCQcV1rSCbdaIdIJiZgwv6BHZJKRrXAZzqCi4PkMIlG98LJja854iEF18f52laKqIx2uHBWJU1IleEYU29S3cztZoHNUCF0OjeEXqgGueHifMrE9Od4UBuRuK/6fZNXvPbVnUgVFNr0unvvmW8o1R5y8+XU4ZkQahElSmsKCXMR4favQpBMN5sn5Zwyd+326elV9119uv1wJpG3x3D+NCS6iNoToIimXCiE6rjpTlbHhnjEHFU6JN1W9j4NHo7gKtoznzs7i4W1OCiqy5A53CLfCS0aRuSVunIlPJ0B8qjhJvXBM7tLzelW4XqchPHemvjPQw1CtLT5AVv/y2sJzB5fIAnMrGLJIW/NJglyZSru1KgWBig5VE/+ucFM9k7OXspDmnee0+bPFSBRIsHw+8UXytwpmqivHEO9pTNK0txdVMxEIJyO8b42X3vb3HmaVL0hip/4aoyQ7UXQ8zi/H5PhgyM6vN7UPam1DiCYv60KIhsJKU6pDq4SwXOo+DtbcEmHHvo6jDI3Bq3JGVqkzc2F6Z60kp5bw0io/YbVW51MkFSQZSK52PZ+ETkHYvV1DxBQhoeEdwmUisRyM35cbd77nmEktaO2CYkJlh2FGjYm55RS5QqQx6UTRE2X1PRKTtCPPk3x1rbGY3sayE73EdG8fz62iwtXaBbKq3JpEPKUEjbEnJAIJk/VnXRNZVEI3x2Oyb5oPrpKQHKT2rfJ9qnC4/y08P23d25b3oONA/AHb6qvqmIWKgHqeoC98SNoTUVcC9tQbe1rbEKLJy7oQosT6fVBOJVkOYaXXcSdDD2soryftFDoJXtpWyhdzUoawaVQqTM9DqFSr3d3dhSRgPwTNDViFR0LjZ51UbeHJxykPhtfwIxR4r76qdqdJXJIjlWToHU/f62G2tkgI5vP5gmNi/kfKB/I2rdQD9mmqa7VdvFc/koIxmD4WknLhq/30G1eeVIjLUF1riyqs142PffD21XVJgLn4SYoF1QnWx4m3VFFvZ41vhpu5g4q5ao6Z5ltF/lQXDxH6VnYRG9bdcVJuVPWsPs2FtOXe+5IhY8fU906Sx7lKuWgI0Qte8IJ27ty5dqc73aldc8017XGPe1x717vetfCdT37yk+1HfuRH2tmzZ9sVV1zRnvCEJ7QPf/jDC9/5wAc+0B7zmMe0yy+/vF1zzTXt6U9/evv0pz+98J03vOEN7YEPfGDb3d1tX/3VX92uu+660fe5LoRoaBfFlANy1SRnGafjYo0NX1W5N6tgV2TH29G3V/P/nlPQq5cMS8Kh0dTqrJL2ufqmQRQWV9UVHtuaBlkEhLtH1EZO/EhUXDlI9SOh8hW2nF3C9edUjRmTvgurwlQuEsM7bA9/ftYQXmv5qfFccbOudIhUtMYk9qct+2Mx6cypSPVwqYZ5Inpri2TcCT7Pp+FY7uXvOcn37d5e7+TEh5Lce/3Y2qJamMLkat+U86Wx3FPDPMeIdaI9YAhVtov3xDPAhsYNiRfJORfSJD+u7rHvKnK/VjlEH//4x1f6/qMe9ah23XXXtbe//e3tLW95S3vMYx7TDg4O2j/+4z8efeepT31qu9e97tVe97rXtRtvvLF98zd/c/uWb/mWo88/85nPtPvd737tEY94RLvpppva9ddf366++ur2nOc85+g7t9xyS9vb22s/+ZM/2W6++eb24he/uO3s7LQbbrhh1H2uCyEaQxqmlCwr5UAv//wkD/gbS4iSrL0q9hgsKhQJlySgh91TGiojSeeTVv0egloFj7kSclqe0+HkylfDqrdkcjee/vLda3ReY3HTyrZ60VgnTPYrQwWJTIpwDjk3foeYVOL4G1d0nJRV4Sz+vodZhcpciXBlR/eQ8kN8fqgQ14kOFZykhKTrM6w5ny+fKdXasgLI+3fS5m2fHtlDFZJjnC8+pFh21scdybiHW/2avnj1nYC+67G1ZSXKF0wkv96u+q5weX32Dck6657a7KRPKhhTTpUQ/ct/+S/b//2//3fp/T/7sz9r97nPfVa93EL527/92zabzdob3/jG1lprt912Wztz5kz77d/+7aPvvPOd72yz2ay9+c1vbq21dv3117ft7e0F1ej8+fPtyiuvbJ/61Kdaa60985nPbPe9730XsL73e7+3PepRjxp1X+tCiMbs1vlCKUR0YB5SWRXHjV7vRVl7VeyT5Co5rqsQQ1gMw4x9uZGm49Z1uVplciXxfAeZ/l+dWF3VRU7KDS2dXi8v6MyZM6XaknDp9CpCkvC41f/MmTOlvO/zxceUHEFrLbYl6897kHPoLShEIHyXjq/eRW7SdvMeJneaeT/47j05WebFDY1Vz+fp1dV3IAmPxCcddKjv+05L7sCiWuL1TGoS+9pJGetT5bJ5H6bxVNkFXwCorYXJeenfn81ybhDbzQmJ/94xnUzp/0MbLBhynMrf9MqpEqLHPOYx7ezZs+0Vr3hFa621z372s+15z3teO3PmTHva05628s2yvPe9722z2az95V/+ZWuttde97nVtNpu1v//7v1/43sHBQXvRi17UWmvtuc99brv//e+/8Pktt9zSZrNZ+4u/+IvWWmsPfehDl+7t137t19qVV14Z7+OOO+5ot99++9Hr1ltvHd2gqxYOlNMuPeNESXyKMyF8JZKMHHfRcCeNJ/ieBCc5Eq6uqzqne0hYQ0meacswV/4kCj35u7c7KL24/ZkYCZsG2J2HK0DJcThmaj/Pw0m/0/d7ISY6IR4JkHDpqN3psB989TqfzxccmvcFf8v6cZt4r/+pDqZ6iQB4W3Oe+D1RcWlt8TEJHiJNfZAwFepkUrJ/38cuQ7az2efVFOa1pN15Q2PaiYirLE5YPddrTCJ2NRY5divlbKg+HjJLbcxn5PXa03MFPZ9I7yUb4qrv4WH9QFWOGZ6pRALj167mqxM5t0vEO+nRK6mcesjsv/7X/3rk0B784Ae3u9/97u33fu/3jnOpo/LZz362fdd3fVd7yEMecvTeb/7mb7bd3d2l7z7oQQ9qz3zmM1trrT3lKU9pj3zkIxc+//jHP95ms1m7/vrrW2ut3ec+92kveMELFr7zmte8ps1ms/aJT3xi6frPe97zYudezIRoaBWWjPNx2XvP+ckIVNhzJHEO4dNQpaP2HZMqRHIoxOQ9eEiEzxer1CIektbaYhInjYO+IzxJzx4CYWgrGduEyXpUdXZCRMOk+vM3Hi6o5G5XDRz7zJkzcQt5a7WSqXaoMElKZOT9Wvv7+0uEyV+++ud4Tcac9ZUDceXB86jcmXiCskgXz/bxMck29bBrj2RUOXAiXFycqF01/p1cuoqRcFkHJ5+cx8Qec5K6z1XWg6Q3qXIkmMzbGdrgUBFKjh0nTNql5u+PCRMlcqW2GlLV+J3d3d0F+zeEm8aMk0QfB7KLGvuqn8aPh84rvOP6nap8QXKInv3sZx8pC3/yJ39y3Msclac+9altPp+3W2+99ei9LxYhWkeFaKyykM6QOC5WFWaoTjuWQRmrENFBDGH6y520dsYkhcgJGslLj9xpdc5tz+kgNOJ4voTnwZAsVfWSUfZk40RMeF0nZkkhSttlZ7PlJ8J7HVOuiZMX3YPn4Hj9mLDc2oXQmJPhRBz8fpyMyN44mWGCttpIeRZaHLI+juEJ9J4M7/NTqpL3q5yc7iPtpFObeFK9t0siRZ6Izuv59n3dF+dLLzzJ+3Wb532a2tj7slKIdE8VOeN9JrLp7ee7KYcWdD7euGmCO/7c8at+fsAlr+XHNWh+VnaP/ZUWTImMnj+/fAq532tq24pkV0obxzN/c1EpRH/3d3/XnvCEJ7Srrrqq/bf/9t/aE5/4xHbFFVe0l7zkJce62dZa+9Ef/dF2z3ves91yyy0L73+xQmZe1iGHaIxClCbMcbHG5rvI2RwnsS4pRHIOPUyGMdzBJPxKIeodAFe9tCPDt8M6RlKjuErVvymPZz6fLykcTCB1J0Mik5yEE5cxxjc5M2JLIWLYi4aXxLDngFpbVpSUo6A2Y86IFCInnp5L5onibrDn8+WHVepeOZ49ROZhFbWpKxner7qvVFddh3OX1/eQWbXKT22b6upzKK3+PaRDQsd7rxxiUrGcyKnvPDzqYXEfk0k18lByIu7C8zqzD9N4VZK5v+/hXicZ3AHKcKwreD5e9T1Pbk/9n0iM+pDXdLyU51ftNCSZIvGsFipTl1MlRHe/+93bQx7ykAXy8opXvKKdPXu2PeYxj1npWp/73Ofaj/7oj7a73/3u7T3vec/S50qq/p3f+Z2j9971rne12Ww5qfojH/nI0Xde9rKXtSuvvLLdcccdrbXPJ1Xf7373W7j24eHhJZdU3TN+nPi+GjhOSSsIf3GyHhe7WgX26khDJkxfIY7F4vbrtPtE7zGXIuFVf9OoykkIL4UgRLh4ajKdVapntZss4VX5E2fOnDnCdNKR6uS5QO7MmNtQbbFWmKjCdcVGWK0th3U9pDWESdw0prxuVIu8fkNzhQm7/iDTpPipfsROuSK9XC3VU/eWFlMcT14/hojpSFOb9a7Ll6u3njjO/uT4HoNZfa7HYCQi5GNG9+wktVqI8pgIqkPqc88rYn96GbsAZduQtBKXylvVpmPsu/cbr3n27NkFtUthxanVodZOmRA9//nPb5/97GeX3r/11lvbIx7xiJWu9cM//MPtqquuan/4h3/YPvShDx29GMZ66lOf2g4ODtrrX//6duONN7YHP/jB7cEPfvDR59p2/8hHPrK95S1vaTfccEO75ppr4rb7ZzzjGe2d73xne8lLXnJJbrvvKURDKsmqpWdsKfOPUWh6xVeBlXqh92V85vPFI/vHhOnGYunlYRRiuINyfH1Oh81V8JDxqXBdthYWt8DK6Dpej2h6/k6qkytEvkOKqs2Y8ESqK3H5uA2OOVdRfCdQz7lwfKR8JX9uFZOgSRBVL6lIaaz2MDW+GC5y8kFSwkeSpPypKmyheg1tbffQMutEouvzI9mhFCrqkQBd23fBpRBxIrpUKM+eXUw8TiTAw7+uEPHantTunzkprhZNrJ/vKExhyjRvfLeeq6ReZ1eQqLim66cxknKykh3jGLqoQmYsn/zkJ0/y89Lo8NBEHcy4v7/f9vb22uMf//j2oQ99aOE673//+9t3fud3tssvv7xdffXV7ad+6qfiwYwPeMAD2u7ubrv3ve99SR7MOLTbYkq5cswKQnHrk2ITa+iBq1yJ0CAcF6tKAFa9JF074RvCFo6Hu+YhD8Mxd3d3l569lRwlsY+DxxdDYD2CSYfhqoLnUcm5OQ7/rxygRGwrhyLiMAaPL4Y+nNR6m5J4ciXuzlu5axWmFEbtvvG8IneMTkB9fA7heT1dDRHhS2Gb1PZuX9LfKcTkYeVqZ1/Ccwfv1/b3khqTFmq9+pHIDNWbtsjHiufSJcLUU0DTXNF5X3xch48X3QP7tapjFWZzEktVS3Vlv/mO2ykjFCynSog++9nPtuc///nt7ne/e9vZ2Wl/9Vd/1Vpr7T/+x//YfuVXfmX1u70IyroQoiFZdUpCRKM/5nUSbI+xj8GlsV8Fm1hSO4bwmPCrHJIhbHfWMiBVaC5hulHTai1hj8HzR0Ak49jDJbacnq+6ZRzpkHj9lFuScklms1lJQofwqvySCtOv7SEUz8VobTGJOOXyJAdDIp+IFvs1ORrdixxhytGp6knn6Y6S1yRZYQhI1/Lf6TdVvlCF6TmHTiqo0vGVDi3UuK3sie41ERdhkUgk2+Z9ppePE9aLc4O5fU5eKjVefVfZ/ZSP5IuI+Xy+EJJmriGvpd9T+UyEqlLESfguKoXoZ37mZ9q9733v9hu/8Rvt8ssvPyJEr3jFK9o3f/M3r363F0FZF0LUC2O545qijCVElbS6ShmqW2UwfJU7FqtalQ29FLIZi81V4qpY7lSZq5Cw/bN0Td/JlZ5nVeEmNSM557mFlLzPhCn1jUcmOC7rxZ007qiJl8I1HgIipjD4+RwhO390RSKMyVG21ha2MnvYjStwOkDWjQnyFSkn5vnzFw7nZP6Mk61KbfY8MB8Dvnsvzd/0aBL1YXUAI1Udqs4p0V+FY1fKF9s4/dbnFomXyG6a7xUm57ifpeS723QP3h9OPET6XPmhWuPtqHZh6DcRR9U9EWe3H5XN4iJS95+ecTdVOVVC9NVf/dXtD/7gD1prrd3pTnc6IkTvfOc7213ucpdVL3dRlHUhRD5x/DWlQtRaP4lbEryM9Emxh+qml1Y5J8Edi0XjxsTkVZQprhJXxZRx6YV2ElZSJ9KLW/r1N41aD7eH5Y6eiljaleTJrZ6f5crQ3MKA7nRclRqDSdyh0HSqM39DhSDlhqS6kfj4QkSkzfOohjB5grhwSTaGtnvzM40BkjUqRB7S5LUYCq0ctM9JfdfvkZhsO44RHj3ANuIp3km1EhGhksrwk49r1VvEKz2aIyljrMfQoZn6PXETAdexDVRq/Hc9kqTxwfHGtAERHt6nFjTE02+nLKdKiL78y7+8vf/972+tLRKid7zjHe2KK65Y9XIXRVkXQjTk5KYmRCnEkib3FNhc2Q5h0hhwxbgK1nx+YWvu2BCdVkKr1DnluZw7d648gNIxdQ13YAm7ClGMxfN69XB7WK3Vil+6j+raHjpxB+/5QFV9HHNra2tJbUm43iYenqjalCqHv++4xEyqJRUKPo7EHW2F6dvUk0IhwqgDKYfmHBUoOUG/HydrJNDcBMAQGX/f2vKDRqlMONnUWHAClEJxQwqIb5Gn0kUbxXwg3psfHUAFhTbHCZaPV5IxVw1JCHk9V3LZHiKmaZwJk4n9yb6rzTiH0ungU5ZTJUTf+I3f2P7H//gfrbVFQvQzP/Mz7Vu/9VtXvdxFUdaFELXWJylTD0ZfhVavqeLGwvtC5S6J3AwRPxmAk7Q3QwLVLo+E2Vo+32QIu8IbS/5WwU0JnVUOWjrPpcKl4fZdUe7ciOfEuoepNiauO3iqLzT8uqZCRH5dz4NxB85SKQl0rh4WHIPp4TEnnQzhOSnxsKQrcQotJnKRnDUdpupLlcFt6VCYzevvdfDTv0lAUqhK165y7RKmruMEkPfPMJ7vzEqkLC0QUqgykXYPp3vYk+0+hOnX1vsp0f80iJDKqRKiV73qVe2qq65qL3zhC9ve3l77T//pP7Uf/MEfbLu7u+33f//3j3XDX+plXQhRbweWn0x70lI5tOTETjoZxhIvGrq0S2YVrLGPQfG6jo2VJ5JAyX5sCI0r216dPXegwkvOZRXcipDQudDZ+PWdDPqp57yuEqRTf/fw3Jg7ZkooddXCHz3h7ecqiztXVz24CYBzlruwSLjSScNV2LLCVF18HnsIi6oNxwVzcdTufh0VD6V5Po3GJBUTH4d++KXmURqXVHiFkerPser5WrRxDFP5HGH4Ol2jtbY0pj30qusznKnfeh39vlNukmO6QqgxyfbwhO40R/xQV44jV6W8/06LFJ36tvs/+qM/ao94xCPaNddc0y6//PL2kIc85MTPMvtSLutCiIYc55QDMq2e/JVWfqeF5QaqteWdDifBqnabuTEai5tCCJ5jMQZTzlClwk4JpAkvJVGPwRV22rorJ0UDqusdHh4uOEs6IY0fb2Nhp9UsDTMVIZIZhl/ljH3M+jW9/XiOkoec5FCY5O319zCH+qwa066AuWN3PH23h8ndlMleJMcpgpbatLXFsB3Hoo+bVEficEyybv5MMl5LO/p6JD4RQFe12Gck/CICHL890ksSkIgC5zeJdVrYuBrXq6fmpRMuT972+qbFxGx2YRs/281PR9e/rnIS0+3FVOULdg7RpVLWhRANqRqatFOFr3pYmiCaXMI9Dv4YLE5WP4VXE3EM/hgs4vjuJKohiTBwJexhg7GY7rC5Eq+wuXOrh5dWh6mujkts3zXnuRtONmhc6XDUj97Grkb5SljtWuWc6X5SXo0wnZj5uU8p2VWOgg7FD6BkeM6JH/uJ9dX3qMokYkM8jTPVM+VJMbyXcBnKSc9648vxqCLQmaqulTLlhKjC0w5DVz4T8ZCjrhYa+r/OguI49uuwbahW9pSRpEDxvjQPvJ60W540nRYDuk6PhPF7nljNsBf7sXcdfYcHX2qseGhxyoOBWTaEaOKyLoRoKMzCJMcpypATl9HlKuS4+GNDSDQKvtqqyMJJsNL5Kik81VomK8JaJSToya28HtubhscNaIXHujPJk+Mn4ab25urZd6vp/9y9MpvNFtQbGX/vD+8/D+co/DD0SAU6Inc4Tjod0xUTdxCsq19fmN4OKeSg8UOH46t1P8ySiw/ORW8HjpE05nkd7hZK5MnxfAHE73O34Bg879/ZbLZEgLx90pgYM5d1XylXiAe1kpym+2abDylxDAHzXkT6EzEjmfWwMhcMlTIlPIYiRYhoL0japAp6X7gyWSlX6REhU5TJCdFd7nKXtr+/P+q1jmVdCNHQKc5McjxpGZND5LFmxuFXwZmHnILK0PuWWa5+hhQiYtFQuAGrduskR0QD4AoRsQ4PD+OBjAzBVIYtER8aOCZv9vA8R6fq49SPiXBxe3zv2WG+jb7KVSEu29LbW46+UsN4Jo3q4JisD8MldDTV40c8X0T97EQ1kR8SLeI6fjXn0hk1vM5Q0m96EDMViurQUOafpPB8mqN+oGSFlxxs1U49IiAy57vE/PliaUs6bYiHR1OIkvbWz3ry/mIun89rEhPfwVopbRpLiZzs7u4uKZSpHhzfHmqslFeNpUSYfWxOWSYnRP/9v//3o9f/9//9f21/f7993/d9X/ulX/ql9ku/9Evt+77v+9r+/v7RE+jXrawLIRo6THDKAelOKL1kYJirsio2DUKF4caWR/Jz581Q3cdgJXKys3PhtGfPY/DVXIVVtWda7dJIebIjDbav2ObIuxnC032zLXjWksvqMt4kIaxjpbop76rCPDw8XPhMbSGcZPhT+CGpPT1Md+4kDK5GuOPk/bmyQuLnDvT8+cXdWE5UKgLo7el1JMGpdntJqeN8cQJRYal+Kk5wHVNzkXNKc6N3PILfN8c1MVP78Lvs22pcsg85n1pbVAdTEr2PI2H6ji5vSw/Dsr+d5KUkfM/p4n0SNxH4ZCP0fi9sRkwqZtVZRhcFIWJ5whOe0F784hcvvf/iF7+4Pe5xj1v1chdFWRdCNKQQnSRk5WVsro3k9OMezDWkEPVw+fsxdXfVxnepjD2rh9eqQnVJIfIkSBGehJGclJxSwpYET8eR8Dxfge3JEBh/WznDlEg9my0+i01Oo9eHxHXjTkc65Pir1bznk6gNOWZTgrmu5VgixXTU/lt3Gl5XLR5SIrv3UdqFpnZx0uI7jXSfifBVfcI2JCl2u6B6elI8f8t6tZbD8MxJSkqQh2SrrersfxJBH++0F76gcfWEmCQNIrC0OyQorrKIVOie2IfeR2qTpBrTxiQSI3U0zWuG6VhHx9bvnHwzbO796CHGKcupEqIrrriivfe97116/73vfe/mYMZjFA6K0y69laMm7ZQMvYfFFw32cbG9bkze6+HSeI/FT+3oBpyGqYfbWj+Zm2QpOb5k1Kp8iLT93LGH8FprsV15qm9KRPawBbF2dhZPsJWykkJHvpOltVbikjQ64U7jhe3vq23WhZ9LbXRnwHDDfL6cI5TCo0lJ4tz0ularbCeGvXBwNUeYyE3cREh8DPYO2kvtWm0A8FOdK/Iv50/i5fPHd+zxPjzJeyj8o3sRcUl5iL4oUFskVUmf9dpY90hSn0KzHHu6Nq/H/qgWN15nD5N7PVhXr5+r/pUP0sGeY44kWbWcKiE6ODhov/iLv7j0/i/+4i8uPNF2ncq6EKIh1cYd0UnLKmf1ULE4Dn6Kz485uZpOciy+h39olHuGpcL167rRSqt+9Zc7Iz11fmydHb+XH+QhAb52dnYGQ7JOSqq6qR21IuXK2JWn8+eHTyhneLIXeqG6QdWJ35WB95N/qz7RZ54gzeurLTxnw0lVD7dSBCo8laptPR+rygeswiWpzYnHdvYdXq5ESklifXsPOE7zxxUdz4GZz+cL4XvhVuMp1dltGAm/52ilx9z0xrArN3OErvyeVB8/BsBTInqYrhxSvSFuakNPxKYaOmahelEpRNddd13b2dlpj33sY9vP/uzPtp/92Z9tj33sY9uXfdmXteuuu+449/slXy4FQrS7uzu5ZDmUVC2joxUP1Ykp61ZhVudrDOEnQlQZTn+vdyhkwqeB9eulE47Td5TrIeeTsIkvJ5buXUZvqI2ZY8J8Jhpk1s1/q//TYVYhAN8tVOESn+FNN9Cez+Or2gqTYSHds3LVPIfJc3/o7Ko8lx5uIhesH1UEd4opT4qYfi/cYt9aW+oX5QayvsL0/CFdOz3HK+1WIkb6v+OpP0j0hemhm3SgIv/mrjKvs6tTFaYrR0M7Hjkm9Ttud6cKSjy2rdqDY77qb7apq09prFU2lKGxMX6Ar6kW5Cqnvu3+T//0T9u1117bHvjAB7YHPvCB7dprr21/+qd/epxLXRRlHQhRJY9qsiWHdRKsZND50pO0XYpdBZ/fTyu2NMl7+RQVvr8/BosGbwiXOG7UuOo7DqbXrXcPHCM9vMrApZ1SrJNjVnXj377TyMewhy/SWEo5DxWe19EVImHK4etsGh8rnqzvv08koocpZSqFTUio5LSq/vJwCu+zCg+5A/TckLQzjW0qR+xOnddOdR27zbwKbzEvyK/B8ZD6oHfGDvNjEp6rQ8T0cKaHu3rqCduZbeoqqo/7FEZN44Qvqkopx6u1RfKjF23AmAhBIr1Tl805RBOXdSBEFUHhqsHl9Kmx3Mj6qvm4OL7CTi+Fc5NBHVKEXLkZS074OBTi+kFnY7CqcEgPU7hsH9/C63VfFU8vXx3LKFdKR4UlRz/GKXiugYcM0thwRzCEx6RSti+vn+pbkUYdTTJEOBNJ7PXr2bPLp2Wzjv7ZUP+mfBzeNwmN3+fh4eGg2sI6cYyQTDupkKqRcsXGqCwJ0523h5tIyvb395fIZ5Uj6CqnY+pfX6Cw7ah2JhvHOZwUttS2wpWCqmv4ApXENc1fka2krhKPeVZsZ51unXZwTl1OnRB99rOfbe9+97vbm970pvbGN75x4bWOZR0I0RgVZSpCNKQQpZXQcbBdBRgyhulp3GO2+rtCNEYBo1Go5OlU5wqrp6J4fbjV3c9USXkpCT/hVU6eu8K4DZvGNSVZVlit1fkNfFK670TzHBw5Z8f2vuvhqR48XddDFekIhSqsyJ1+SaVwZ7K9vR0VRmF6KCNdL6kiVX96orDvoPJzu9LiIo3NRNg0/qm2sY6uLFakqmrzVMcK07FSHajGqP6pnytM31VJNZNjyK9HAuIHO+oajsmQqN7j7sakUDrB9jYVXiK8ml/cnSrC54sxfZbmwdDi9DjlVAnRm9/85vZVX/VVRxOVL50Zsm5lHQiRSi+e6/L/ScsqKoOHWk6Ct0rMOh00dxr1S8bDH/fQw6fR0z33VsRbW1vxLBO2dS9MmvAon4/Jn5IhpAEmQVS9SVr29/cXVp/b29sLpK4KVdChEJfkh3lU/C3zMfRyEpXqmJx8Wpl7uxBPdZRS62Ee/22vjVtbVp729vaOcl/o/FnHMZisq4iB15HfJaEThp85loiOEwPW0XN+vI+50Nra2lrI+SF5aG35uIF0rbR1Xp+rvfgd7ZLyIyRc8fIxxPeZLM4kaJIKEhKRLY5pHVbpuWg7O/XT6tl3JKQ8JyuRRX/uoC8s2H9+YjbVPs/Dm7KcKiG6//3v377ne76n3Xzzze3v//7v22233bbwWseyLoRoaCcDDetJyxjFRi8alVXxmRuTru3H6/tkXQXb83DSNRVHT5/RCPWcacKqVv8y9HI2UogYCmUSube3OzkqVFU4gOcI6dqss8geiWYvFEfDm4hcD3NnZ+eoro7rRn2VsegOVPWTQuRhBTmyg4ODBRVhbHg1JWaTpLnatbX1+W3xGt8MCfdw0rirMInNxQbHW1WHpHSQeJFQeSjHSTKJgY9rV+mqF+vIEBMJsV8rKT0ac2kcc+zwfSqiTuoqpU33rDCTHxtAIqF+SyRHdlH19Pp7/dQWKd+IqiSvqX50ckulujcPuWHCdyVOUU6VEO3t7cVziNa5rAshGlrVn1ShYakIQ5oUCmUdB79a8XAyVwRFTnUstrB6DtZXWL0EZFdKiO9YbhR7mK6C0NmovZMD4OqvwmP+BAkUHRjrLcctw145kuphqNvb2yWm/l/h6ne+00WksRoTvlpOmHRKSZVhu3s/pPp7HVWqsLBCDj6mEgETJlfrVEAqTIZPhpRBv15aiLC9nOwTS/fA3+p7yZY4YfM8OWISJ5Gz6t69Lama6jMeWukEhm1L8qO57zYqLbpop1TfdFCmVFW/Bu1MGieuqArTSaKHvrjTTPXWmPb21fdTAvxphc1OlRB9+7d/e3vta197rBu7WMu6EKJqkp8G/ionRyuv4rRx0muVyedPhE8v7v5g/Vatc8JKIYMK06V4DyslLM+xSnj8mwbUlSY6UDeyrmDRQfnulP39/QWCQUzHT7kUft8kTwnv4OBgIb+kh5nyLNL4UBuQsNIhpTqqJFzd51gVls5T9WKuR4WZtk2n09hJtNjH/A1DdcnxuerAsSz8pGxUYVSqHcRkorLnflUqTVrYpHHG3DWGQBOJdtuQEotT/6r+rmLxfohZER8SMxJ/V9oVuvaxlNqb9XPlPW088IUb72PKcqqE6JWvfGX7hm/4hnbddde1G2+8sb31rW9deK1juRQI0dQP5h2SsLkKO0nceAjHjTR3PjAkMjWWG1U5Tcb3V8GiijAmd0nXFy4VKcdO25jptBOevsPPKJHLCVWSuQw4k7tpKFOdEiZXp8T1sARDDEN4dDZJcSNma21JiUht0toiualCvFVi9v7+/sJ9emhR4cKk/KXQHckVlTc6v2ojgJwkFQt3+GnXE685JgGdITHWi+pSNVYqsl7NHT5vy5P1iddTZnQv8/niM/tay7sKq+R1FSf4TvwqAuKfEW82W9zh5ZhUEH23XG9uep4QQ2BeR+K6crSqTR5TTpUQacXAlwzQJql69cJBddqlJwVrIFLmPEkZk6+kiatyHHwZ/l7d+BqSZXv3QCz9m/IokmEfIwfT+CbiprDUGEythPVZD1fXVSiJMn7C6+XG9Oqa8mKYX8HPEl7PGJNwqQ09cZvGn/3sY1Vtr3usxq0wqD5U48fxXAGpPktO1N9L5LqHp0Rxv09X8nh/TMym4+e4rZQQ7u5LzrB6MQmefTuEN5vNFj5LobmeHdTY9/y0Hh7rqLnKxUcPl/OEai37zJU5PUKGdVRbqU+HUiRcGfL6eh19Rx6Jo37fw6Q66/Vl/Xq26jjlVAnR+9///u5rHcu6EKKesuAhlikGZW8y0nCpnAR/yNAl45XKmHvoYfUOVhva4p9WtPqXeQOrYKpvx+ZHJQPmLyYsn6SNmbvS2yFIUuOYKT8ojSnPk3HFKN2/Pk85Qom0eS4KyZefc1PVsUc06bD4SjlAPTwqLySJQ0cd8G8SEt/x5HOkwlN7rbKYSTusHI872CoiXM2Zno2kPaCSwjp6vhn7xK9NtXiIIHpIzNszYVZ11CKrynVLOVg+1hzP790frcLdopwvruRedArRpVjWhRD18iukRkwpWw4ZuDNnziyEOSj5r4o/JoxEo0dFIikVvXsYg1Wd08HYfsKmEXfj70bRr3/2bD6cjw6zSuTWPem6HnZyAze3kITXl6EprxvbL+X+VHkhjpnIg+PSyVP1qUJq7hhJKKrt5u4oPBzojkf3kIiA52LoGlXIhb9T4f1x55P3IZPp+TsPTaa+SCErqswpcdbx/H57IS06TMdL4yqNHcfztlZ7VwodCY/uxfuQ9+hj0ccNVa9qTHEXoRM5hkTTtvl0ZhHVvYp8M7SW2tTnoRNj1V194+SR1/HHiTipm6JMTohe/epXt3/6p386+n/vtY5lXQjRGEc+hTKkMka5oCE4SXL1KgpRWjWvUu+xWElCTsavhy2sFNrxl3aScSeMO6HeVv+xeLq+HCxDKjL0HlahAU1jziX7RPgODg4WthGLQJPEVbj+kuOr8OiI0tblylGwDXsrbZ8b586dWzr8UWcUUUHw84o4plXGhksODw9HYbpzZT8ynDkUkpLCJwwqf1wU6T3H4/UZ9lN7VDsHtdhLeVYibwznODbDRyQf1aIkqYeqE9vHlTZX1UgyvL/Vnj1io9+RoLOvNI75HbdZTnJ4v/wsHcOg73IRxoUgd6b2bNJJy+SEaGtrq33kIx85+n/12uQQrV44EE67jMnrmepgrCHjmLZfHmfbvasqQ45AdVTsWkrDmNVJUnCGsBgKEo7nB1UJlcTSZ2PIGNUFN4ApsdK/08Pr7eqjouD3zaRy9T1zEFTG5HhwDHGF77g0+Hx8AOtaheiGMOmI03Urx18RvYq4qV4pd6VSVHvhVf1OpYfZ2gVFkcci9MZsNf90TlKl6vn8ZF174ahqvKTzonqYJHa8Jnd89cgHk4crtdHVJxGMRGyEW4WS1Yeu7Po9kcymHDvfml8pbdwcINxq7JBgcQGofiN+uucveYXoUi/rQojGONOpBmTPwM9my0mCKeFuFRytwsZsw5/P5wtGgm3Tw3csrX6G8Ggc2AdJPXF5nVitDTs7GjBPqO5hC8sdjuP5abO9uqok48m28JWnhwaIU9U94fp497HNuvs2YYaXerlUwnAljvfpbTFmnHKlLiUhfYfXVPv5kQ8+TjXGvV8YJlXSruP1bIS3d0qwH9rFxvZW3klvY0BFwvhd2holKyeC0VNWvf9SPpt+4/Ml2V2RdB9Pjut4Ho6twlEeIlPdNU74XY4ZfS5iVyW0V3Xi92ez2YLS2LNdJL1Tlw0hmrisCyEacqRTHow1Rrb3iURjvQqOryaHDk6kUiLDP4YQOZYM5xiCIlzeJ0lHZQjZLlzVjSG3vrKmoyE285Q8ZNbD6x0Umeomx+PGMSWmkiRWmFVis9eLK1b1r+/Yq85R6tXZd4eRlPA3rsKpVH2Y8rESeZGzSbkks9nyo3h8jPfG7d7e55867rlW3o7qRx6u6c6aBMr7y3ETWfFx7Iomx4+Pb8esFmqeb+M7Sl051xjlvWoM+AOzPbxEHG9ztaE/pLkaM1ow+bikKsX3U5v0cjc5D6nqpLnXCyNXEYPTJEIqG0I0cbkUCJGMANWBk5YKyw2Ch3amrpsbXE5Ol63H4DuWwig9XBkuT5alA0/4/D5VLZKG5Mx8lxGdU7XbhyRlFbzZbPFcqbSSTLtTSCx7B7lVmNruOwbXiSjJUur/CvPMmTNHjoHKBe+X7eQKAQk3nTsxtPuI12itLdW1tUUH6ePSt4L7GOslshOTdXXVyh0ur+9bz71dfWs5+9QT9SvlzR12qusQpu8aFGlPc9wVXKk6vTp6P/GaDLf6ZoNkF0iA0y5NHwv+vr6fEvqTGka7zLb261Zb7kXsUui9UuGmLhtCNHG5FAjR1AOz58j4okM4Lv4qapQbz1WxE5ZvKXUH2ls9V7hJISKBSI6UTkWEJuVhyLC5GkWiWOFVqhATV5mX4CtAXj/9X06czrQat/w84TKvx8OFdBhu+FvrzxU5XOLy/pkr5P1EZYWYacWdHBnPbfF6aWz5WPMxX9UxYWpsyIFqnFc7zzh+0/b4hOnELPWZ+skVGQ8ppTE+hKk+o4P2ULhUHyqMabdma8tkmmOlZ3NZX+9fLtzGqo3pLCHdPwmfJzur33n0hC8axijUrL/Pb84Bz8GbumwI0cRlXQhR78C3oTNyVi1jJ4yvrlctHpKRUR2Dq9+PxXYsrarH4KVQQw+XBkQGsvdgyar+DKNUdSYx8d1VjpceneD1l2FLK0ASkYQlp8pVsK9miemnRKfxMLecHaoQnlSanKHulzhOctgGJBB6xAbJU2vL512lnCJXDJwQqA8TSWAoz8+1Uh3TuHXFpwr18P1Etlg/Epzq+XhjQjCqj7dJak8624SpZPvq2h724rglno/xNHZ6Kp7mlPeVrs0NAwmvwqzG6myWT633BQPb01Mpxux29bb10HK1Q+401KINIZq4rAsh6g1i30Vw0jKGEMlQJml9bHFpe+jloapVsFfBSvkBLn33woS99ktbcBOmn65bYZMQ8ffcXqzvp1yLRIiE46Sv2jVDB+RjwtuRmHRsxPWwgt83r+mr7hRSqVQfbvWnusHfO2lJK3IPkVENoEPy67JNVd/WFhOJRaSZK+JEp8L0l2+G0HXTmGMd03jl7jvWn22axhXHhEKgPqZTPyZ7l/LniOdESe1OZYpjPGF6bpCPR710nYoIJrwKk7tYE9nWWEr1TqR6qI7aTVmRzwor7dKcupw6IfrsZz/b3v3ud7c3velN7Y1vfOPCax3LpUCIOPmmGJRDu2i4nTW9f1Kc9D4TmRP2EDHqPdzVjabnWjgujQpXUB4aqdSn1lokIxVmD1vG+eDgoAyJqbCelOTTVvuEPWYM+iqRfemr5kT4+Bs5oB6e75pKCdc9TGKpcJt6b66pXegE0w4ijQ0qTyp0MumJ99UBgNvb2wuPaiAxoQrE3Um8J8+9Yf+pfUi2vS0qNU4O2ZPtK7Lm44VjPO188rHkYU/VmfOyh1eN1d74dhJLUrCqalLZgeolhWjs/KvqqDHizy/ji4830vPvqnlwWuVUCdGb3/zm9lVf9VVHoQK+NucQrV6S0zmtMnbCTCFbDq3OKmOjFe4UOO6QPHGczoHO7zhYlNWJyZW346atsWr7oXqJvKWcJuVbCI//72HLWA7h0SnRafWStVtbVtiqOvqulx5mpYARg7i9rd4kpI7pW4lZP4YzPOcmvfxwRSc+iUSIiPH+qXLq98kpMWnXE+5Zx6ptmOArRU7XTO1I4qSdmJ4Ar7aq1AaphD620v35GKB6R2WlRxqkcCSi523qW8l72L05zOtXdVPdfT4kbK9P6tNe39F2JMUt1TH963N0qP5jFlMnKadKiO5///u37/me72k333xz+/u///t22223LbzWsVwKhMiTUE9axhoDOYF0SN9YnCHy4MadzmCVsN2qWGNwW8vhs5Ng+YnNLo87NuX8XmjJ3+PqkAZRpI64ckpckTtx9LbS+56P4Pk8wnFcGfgUdus9y8pDMh420fZl4XCnUXJsfv9OBLzNq2Rwvw/VN4UheG0n/77zTZsCFMJKBMDbVfdTbXlPKgffU9Iwt7f3vs/doY7L9uzleqneVNm8rbwNU/iOc4pKoo/Nc+fOHY137W7zOcY6uPpFgs06cexUqgwJTPqO7tXncJpDbG/PvWK7jrFZvn3f5/wUi3Evp0qI9vb22nvf+95j3djFWtaFEA0l42p1MFVZRcY9aQ7T0GNChJESk1fFHmpHGTmu0hyXK+1em1N1GnoIJjFFFOh0xmDzfKYx8j8dQpWfJVyuMD1RW4ZbfVThuUMUcRjC5TVlwHmSNOvjxlptKWVHibW93Cz+niSml9eRMD13KeGyLak+iUzu7e0t1TERtx6mcElERCyprug3TkKrPBbWx8OSbEdXLlg3fs8JjpMPb0Nicq7pulRnqCCl+qS+93ZNhJM71dT2rK/fl8+/lPNGVS5tfKh26OkeGRZzW5nGq/qyGtcMB1Jxkl2sznuaopwqIfr2b//29trXvvZYN3axlnUhRGNUmykZeoVRTapVw2UsQySF+QKaoMfFHtOOLnWTjKySIzBWaSMmjS9XY2PyE3ifVbJmMnbE9KRWKlPJYXjIwNULfte3lKcQAnF1X0OHdfL6SVFS3V1dq3BJHHrYcohJJdK49HZ18ud1GVqly9n6nKwwWVc5ME+upqKTcnbSPfkOp0So6cyTapTmciIArHuF6UR6Z+fCA4S9Xf3MJhKoZHf4G4YwPUTqSklS/1xRr2zEzs6Fs5yc2FDl4uKpUjhZP19gcExV7c5rkwinHaFTl1MlRK985SvbN3zDN7Trrruu3Xjjje2tb33rwmsdy7oQoipurJefbHvSMuQIfNKdZHUwRrWhoaBBX1Uhqlakyfj699xZDClEjNenByj6q8oLkfEcwiYhqnaQJUwP5cj4SfbXdaWQeI4G1RVfkfpRB8JsbfmwQsc9f355R4/v8nK88+fPL4wPkkOqXClZmU6U15Ri4yEHJmnzfcdsLZ/t4+GTqs58MQfKc+w87FnlUnnCM9WbhOkP4tX9UjGhepMWLFV+UCJEIjdONv1ASWKybq60Clf19ZOhOS6rR3LofQ9j6n2NOSb5p/bk2E71J67qwce/qF1cYdPYTuSV9+S5c8neCZOqD/vEya2PzSnLqRIiT6TW4NkkVR+vcDCcdhkiRFOz8zGqzVTYQ3XjpE35IMfBqlSUnkPwc3PGYqXckyohlf9PSlEPe1U8GVU6Ohpr4dOBJqzWlsMY6SVbI+fP+iZcHxceAkp4/hsRmbQbyZ1T2gmlHBGSKcfzlbmrCFX/cSxzpZ/IOOdapQZ4ONXrSsJM1aqnABLTCZjuu2pfjkX2GXG9fhxj1e5Px/S2YFsKlyGfHgmpxpPn4qgunBsJU597nl3P5pHA0Qbp+iS4XjcPjVbk0NvViacvNL2NmZ930eYQvf/97+++1rGsCyEauxV+qjJGup8Ke0y+Cw05jcRxsVZJenbcsaoUt3SPJX00ODKuY7F7eGMVv2QE/RlNzBlSPgNDTmPaliGB2ezCriviugJE/ITn+WXuVDwJlc7a21kvPi7CV+GVY+u1PdVUtiPJivc18Soy5Pfizv3s2QsJyakdie1hv0QEeTxEj3hzjpIQpTr4+Esh14Tp+Xme6+IhnxTKSuFw5cdVhNBzu9Ju1IqIVASUmCmEd3h4uDCGEyFJoWcSO8fkQpOKmUgPx47fTwoFT1k2BzNOXNaFEA05tKnZ+ZBDo6E/KXbaXlphUko+Du7Y3JqESyM2BltYbkh7SoqHJdIKvsLu4a2y861SDoRLZzafLz4Q0xM+e+3sipjjuuNUrpg7hJ6Ck8Jc/nlry+GldM86P6jKP6KTcKLhOSxeN5HuITz97X2seyFGUhqqe5TzU586ZlJOVIZy5dJON6pZHgJT8fDVKpheb08+TmM75Z+xrJITSEWHY7o6OqTC9M8rEl7lyKW8RP9tCuGmxQXr5irVaZVTJ0Tve9/72o/92I+1hz/84e3hD394+/f//t+3973vfStf541vfGN77GMf277yK7+yzWaz9ru/+7sLnz/5yU9eashHPepRC9/56Ec/2q699tp25zvfuV111VXtB37gB9rHPvaxhe+89a1vbd/6rd/aLrvssnbPe96z/cIv/MJK97kuhGgoFDH1oBwz6T2R8rjFJ+nQrrOT4CZiUBm6lIOzymrIEz05VipMrsTopMZg9/BaW1biJJV7rg8dRcJ10sJrOlnzuhHT86ocV1hUo/ya7kT9fg4PDxfq7Q//VIiGodQqR2k2m8W293b1/tUBk15XvidHOAavtcXTrPUwV4ZTuH3br5lCW3q/2i3k3+d3WFcdBMlxrHQM75uhcZ3uu8LUGKnUZrYDSUdPtaJK65gcS9VWdG//NFbdxqgv09iSCpXa0XG934SdSFjKExJh9WMe1JauRp5WOVVCdMMNN7Td3d32Td/0Te0nfuIn2k/8xE+0b/qmb2qXXXZZ+/3f//2VrnX99de3n/7pn26vfOUr22yWCdGjH/3o9qEPfejo9Xd/93cL33n0ox/d7n//+7c//dM/bW9605va13zN1ywM+ttvv73d7W53a0984hPb29/+9vbyl7+8XX755e1lL3vZ6PtcF0LUW52MyWdZtVRYp4G7ysrrpLhJRaiUE9/xsiqusNywJwmdziPtahuDTYPmeJ6z4y8qKYmYVFievO0PzOy1s5OCCtcJ2P7+/oIDcWfqdU+5X+4cicu6ufPx/JTW2lJIjNfTy/M7/D6o8qTkZScLrnpVmGo/Eq+Uu6PrVHXsEd90/k5riwqP3mPf6X4qQpQccboX3a92byWlNJ2V5HiJaFT1TGFk/m5/f3/pPhJxSOHV3udSenrHeJDgpQT03u4wH3/qT57errOZOOZPK2x2qoToAQ94QHvWs5619P6znvWs9sAHPnDVy124kVkmRI973OPK39x8881tNpu1P//zPz9677WvfW3b2tpqf/M3f9Naa+2lL31p29/fb5/61KcW7vXrvu7ryuvecccd7fbbbz963XrrraMbdNXCQXXapXKgklC/0AoRd8WcdCKMzW/RasVl4VWwV8nl4Q4jb+Mx2D2sSgXzJOCEU2H7LiLvL2K6OsOzYXr9qveZZ0Ac/S3Vkn3r5EnkYwiX7ViFN6mSem5Syhty1Ym4Hg7wdmR9WlsO4bW2rG5ISWBd/XvCr8YMF4tjMVtrC7iesO1zz8/04bivcr58LAvXN14kZ0zSzz5MCxd9RpVjd3e3nGcVafAQLwvr4js5e4/G6S3qUl9xPvUWFNXiTUQlzQcqgN6Hfq9UwdKiideq8gM9z27KcqqE6LLLLmvvec97lt5/97vf3S677LJVL3fhRmaZEF111VXtmmuuaV/7tV/bnvrUp7b/9//+39Hnv/qrv9rucpe7LPzm05/+dNvZ2WmvfOUrW2utPelJT1oiVa9//evbbDZbUptUnve858VBua6EyI3QVKWHxckk43kS/FW23ZOgrJLPozKWELmzcGIko9zDpqGvMPxv3p9WvTI6Lu07Nh1ZD0+GnuSFW/1bW36eWC+sULUhlYiESQfJLf5OBseODykFPO/I28XroDZkfXnApdeX/eNOiflIfM/JgNo4Oabe+GQYxutYYbbWFnCHxn9KLnYl0NW7CpfXqOrGnED1RyJOVf4Qx+WYA17Vr35vuj+OZ1dOqKBxjLCN2WZphxnDh1KP2a6c26nN/GwyfsY5nMKNml8+nlR8rLt6KkKdctKIM2U5VUJ0z3ves/3P//k/l97/rd/6rXave91r1ctduJHZMiF6+ctf3l796le3t73tbe13f/d329d//de3Bz3oQe0zn/lMa621n/u5n2tf+7Vfu3Sta665pr30pS9trbX2Hd/xHe2HfuiHFj5/xzve0WazWbv55pvjvayrQjQUVppaIRq788u3mx6npDNzxryStD8Gy41XRVhc3k9GuIddhZWqhEXuXNG5UqtgVyGzXoKkDJ2HABzTsfkUdipG6hcSVr24MleOC3FpkHd2LjzHTEnJfE7aGDwZaD82wNvY68twmvfB+fOLj4pxJ0KFxZ2O43ridWvLhF1OyLeYe8iswiTJVA5XL7ldhF/O2s/EEnZSpbijLOUVpTGYlAxv0x4mlUXds7aNVwqR2pLjewjTibCIo/et/97bV/2c8NhWiQwxPJfa03cV+j07pm+vdx+jcSo89hUxWfeLSiH6mZ/5mXaXu9ylvfCFL2x/9Ed/1P7oj/6o/fzP/3y7y13u0p7//Ocf64Zby4TIy1/91V+12WzW/uAP/qC1dnqEyMu65BD1HFrvCenHKZUUm15VWGcsTmUoe/gME47Fdixdf39/v8ypSPc0JnSW4vcyzvv7+20+r09gZt4B70u/cxzm1lDaTnhnzy7voqrqKDIo4kKc1toSaSCxUf2rOtJ4EpcOeHd3d+nwPuZBpOThdNifk9/WFnfj+bZ3JejSeblKx5OG1TauJno9W1t0qp4AzMRojlGfXyS9TlJ8HJFcuHNlf/EoCp9X3J3kuUKtLYbRmP+S7s3VJ+7c5O4rYiflJY0jd/a9Ixg0Rjmm+bf3k/edt3Fri8/GI56UZScfwtP7PkYrTCowrkCT+Gu+E5db632OsA7etj4WtLBRSoFwXXGaopwqIfrc5z7XXvSiF7V73OMeRxW5xz3u0f7zf/7P7XOf+9yxbri1cYSotdauvvrq9su//MuttdMLmXlZF0I0xmFPxc6r1Ut6HTd0RZxegmd6pdXkEHYPK+FRrXGDRGKS8B0rEZF0fZ0Hkow565tyKbiCq/DkUL1OIoXu3IjrOQI0vk5svD56n4obnVLCFXYiRNX4FIEhJnOl9vf3jz6vVDOOZx58V41J9YVjUlmp8kGS422tLa302dacaxVmcmZVLgo/S/VjXk/Kn0qkju3h/VMRJdYx5bskZUu/FaHpHd/h/3eSRrLPe/cx5eNU82FseNfDij0VKM1jkReO49QuriC6rfRdkLqeX4uqpM9Hfx3nXLihcmqE6NOf/nT79V//9fbhD3+4tdbaP/zDP7R/+Id/ON5d+o3MhgnRrbfe2ra2ttqrX/3q1tqFpOobb7zx6Du/93u/F5Oq/+mf/unoO895znO6SdVe1oUQDYXMpmTnHmuuJpo7ruMqRNU24CFcGvyxCpEm+JgzeZKqkg5BqxQikqex+Q0y7h6r9/wC4fgqt4dX3QNXyFpR6rvE5RjznVhDeUspb4N1cFyeo+PjK4USaZTpfHycpjGuVby+4wRQ39PjDLx+VLYc09tMuWke5uLK3/s94REzKVR08O5c+ZgJOsHenOd4lFN3Bcd3UfXqy7GRyLtUI+bL6B68fXze8aGj3v8pidxxPYyX6unzXn/7c+L8xT5LBFnXZN5OlaPjC5HezjOGQF1d9MM3OVcTqdZ4SPbkolKILr/88slOpP7Yxz7WbrrppnbTTTe12WzWXvSiF7WbbrqpfeADH2gf+9jH2tOf/vT25je/uf31X/91+4M/+IP2jd/4je0+97lPu+OOO46u8ehHP7o98IEPbH/2Z3/W/viP/7jd5z73Wejw2267rd3tbndrT3rSk9rb3/729opXvKLt7e1ttt3by+PZp43nk+yk2Cle3sNMMvuqWKvkLFES9oPOetgkLGMTg7e2thaMKo1kIlonxWP9+P+E6/eQwnVjXx4ySlu+HYtjbQxepcrt7Cw+D8+JNfNuSNaFX6mXOzs78TMqZckp+hzycGRSCfj/1BZUG1VXV5qoGsgp8j6189CxhZfIIXPLiKf6MsFb49jP2vH/kxwnzMPDw4UQYFK8mHxOAp6eMah+SflT7EM+5d3za1yBIl5S7HwBkOyTh/p8THHsUB31UCVDxlS6EsFhWJgknAsA3yk5ZTlVQvSwhz1sVGhrTHnDG94QjcKTn/zk9olPfKI98pGPbNdcc81RfstTnvKUI3VK5aMf/Wg7PDxsd7rTndqVV17Zvv/7v797MOM97nGP9sIXvnCl+1wXQtQLIbl8e9p4NBxTYK/iTElIjrPVM2GNUW+chI0JExLLjeyq9U3JjY7t+RkMC/H/aacIX4l0ObbvDPIwlOo7pD6wDyqy57+t8Obz+VFYLiWXp5dCNCRE7jxcKXTVgg4rLSS8rVlXb0e1NQmZ55XRMclJJvI3NJ69vVPum+fEiGglhaj3EoYrixxTGjMiD6x3D9PrSkWP85YEnmqrEwuqWbrXXj1JEqkqkexyzpJgSGmRSpmUI9bTjzLgbjcnSxynvBcSJbZLNU6IqXHDc4l8/kxZTpUQ/dZv/Va7973v3V784he3//2///fmafcnLBw4p1l6IQJO5CkGowb2cRz3cXBWURe4ivLzbcbgtJYJkTtcJ0gJV4SDSZJuEPgbXwX7fVQhLq7gnfB4fxNPqkBlZFNYTjitLeZBpTCC2kxOm+1CR+tjRIbfx5d+l8JkKS+pwvMcJGKmvlfIRfeaVuf+YE46EV5Tq/ShUJFjsl1dpWG4ylf6+lwqi8JEnh/lqos7aO5+4/cr4kxSQcdf2QyG0lhnHh1AIrYKpveX8uHY/94eJEGeYOxzgadRV8qNEvs9tMW6qi059kWAnRSn5y36fWrTgYcx3VZQBdKc8oWaz9PKbui6TuQ1nk+jbJ52P3FZB0KUBmxl2L8QWJykx1WIiNOLfad6ygCMUYiEo+/zEDE6smTEK9yk0tCh6sXdSC7fV47DnT8NrRsnzyHi6jsl4tLYtVafk9Ta8om2nldALDewKcHVyV1KKGcb6P59Be9G2vE8IZmYrt6QKLnyN5vlh+Q6sfbcGh/bHtrQddXGvsvN8Ug8Of64Qlf99HfK70jqTiLK/KzaOcd2JVHzPk0Pk61IKYmv/5vGHxcgaSx5eJNE0O+Dn3m70cZwvqVHavB+fX5WuWVOfjmWeV8pz9JD6z4PSAQ9kZxhTJ+vJOdpMZ5CjKdVNk+7n7isAyEaUoiSWnBaWI57nDyeVXF88snYjc3jWUXxSuRjNrugbnBXC7Fd/ue1uBOEhimFYJKjcLk7nYEzn1/Yelzh+WnUyTlJIXJZn9/x3BM/iZdEi06RhtcJk6sEbph5zR4eHeQQJl9JreSqeza7sEuNzpsqFMeG52IRi4tPVxFYfx55wOu1dkGFIqEbCl85QewlgLsiqDaV80+k13ObqjFDkqJx7YojlRJPpPaQVxrHHPOz2fKZOiQTTlB93pOA+VyrXjzjqrXlE7A1rpPSzcUG+6uH50q1K5esl5+Gz/nuG0h6hGhnZ+dYtn+Vsnna/cRlHQhRa/Wx8ZqgU5YxCdVTYHvS59jXcXKHhOU7LIYwWM8xda7i+P6SMutGlH/zsMJUZ1eIkpMinisrVY5Na600/jSgXMnS2NN5MwmztRbDATLSrS2qVlThxuK11kZj6j2GY7zN3CGwT+UwXBHSeNO9ejuTEPH6KUGaKg4JSw+zqqvyTFI7ep0Zdqrw3Im6yuDzp7c48T50TO3w8+3+u7u7pW10IuCKkc9n73/fRk7Mau74bjRXiLe3txfmFu+P/Uu7lXD8RWKZbI/PRe9Ljscq3JpeXAicRjlVQvTrv/7r3dc6lnUhRD1FhfL3cRUbL2N2KaVQje51lXvwPJHeS5K+ru+kYAy+t+UY7ArH3yMG7zWFMIYw6XBT8mtPqUp5UAxNVk5ka2trqQ0rjLRLyEMUPk6ruookDOHK6LvKJqfgpGCor6WIEZsqXGvLj9gQrurv7erE1Mmo2wtPNE7hWrW36u+Pg0ikyzGZ46TFgben5pgT+yp0WNml6pgFb0/1ge/eTJi9MI7639uBIWxX/xQiU/t5yEzjR+OimrP+oFO1NYki+9jb3/uSbVuRRw8VVgQ0qcvcWeebGapFXFLukq2aupwqIbrLXe6y8Lriiiva1tZWu+yyy47k4HUr60KIWqsfp+Gxa02Ik5QqpKKXnubMe/KE3FXugZO3wpRhZYiC9+grvbFKzhjFiMQvbZ11LL8HkoghLBptGZlUZ6o3jt9Ti2TgKuPuZNJDQo5JFUtGs1JjqvvxZ6YJl+1NbJKE6rpKOOZ7vpXcH6ZJXO6EUr24g6lq14TpTrwi7cLWYzbU5quMG2KmkIyrPxovqtPBwcFCmC69KlVFn3Eep4USlcDDw8MygTs5+oSp+nioL5HpHrHyedHDY54Q56zqmEKpqV0TZmpbhtbZj1TC0i43XzyksH1Sj7xtOVY8UT/ZoCnKFzxk9p73vKc9/OEPbzfccMMUl/uSK+tCiHoKkU+EZGhXLWOfZcbXSRQiTy7tGWKXfFdRiJIKMKZujlthE4ef0cmOwevtRBEZ6KlFNMbp+lUieyLUvgvG68acHZUxmJ4Y70Qrnb/jO4yOqxiwHXv1ZW4L27hKONbWew/rtbZ4vpATO42fyjl6OIrqw9mzZ+MhhK0tkx+SJOZnef7IkK2hmpXq6nldrS3uXGT/VYSDdWVSuCfep1wkhhGZL8V+dlwujra2thZIcWofJ5hSmqgucnz16unXFSaJNx/RRFJC9SaFVNk3XgdtMmGSPjHdr6SQ8ar2fpXyRckh+vM///OVTn++mMq6EKIeUZCEOlUZctqU7E/yHLW0JbZXRxlQrobG4q6CxXrS8VMd6NU5GeGxzqY6j6eqc0rAHIPnqoqHLIjBNqPxdSw5v942Zv5dETo5FV2XJ0TP58vbhnt9OoSZyJzXl1hD8yM5PikETGTVPVDta205VzCFRpzkJUySluQoGcbhfVbzINXTFWTfneTk2tutel9Jv8kGpPOWEsl1oiy1kEqNt3XCTDlUHFu8nudTtbaoTDm5GTOGnAirP/1eSfTSHKzalKpTUlrVn64gMUS2doTopptuane+852nutyXVFkXQlTJ176bYYoyFELSSuikk6CX3Jle/rTnVbCJNZagpG3DY3Ada9Uwme8A6WGnBN8xeJ73kjAd242h7sfJ8RjMRBKq9nMS4+GBsfWUekH1zB2Y6isHR/Ih59gbr8oR8W3qvE/PE0mrfl2rtWW1LSkVqc992zYJL8mQE5mkhLoT9Rwf9gV3plFlqfDSBgZvr1Q3ho+lGklFckUnbQbwOqV+dRIsQup1SYuGHt4YQkki5QsRjmku2nr1S21IO66xqDkj39LL5WI7k5RNVU6VEL361a9eeL3qVa9q58+fb/e9733box/96GPd8Jd6WRdC1HNyVdjmNLA4mfRdSsSr4iTj2ntVv18Fq7XhpPFeEqyHjIawxkrlrmCpjXvYqQ3G4JFI9erKwl02rDcd4Ri1Ju3OIu5Qkj4xXC2pzpHhipaOb3t7uzuG2DbpDKvk6FQvqhXexsl5UBXgacLuAJM6QMxe+Fm4rhSRLPWUE+2EVL1659nw98RLzpQvJ5QMjZFc6h4SuWD/DyUMi5xXj65ge6n9qrqy34fwUqiX9+vqoXD5fRJ+J958KYG7CsnSrjhuIm5p08ZFpxAp7qrX9vZ2u9vd7tYODw/bBz/4wWPd8Jd6WRdC5HiVMZ6qjCEoviPjJKXKA/FVW2vL+U3Hwa7qp3mRDitMRHFMm/eMp2P61nuVVbCrtvS+k3N1x+nX8pyNZKR7ic36V1hM+uzhelgjGWh3nE7OHHM+XzyDpiKdVZJvcn4edhqzY6oi0snZ+Fj39paz8xzCNGaSMiVnX23DT0qQ140E3ccKQz29HBe2abqPCrOaH6ovyViFeXBwEMkZyU3C9Lry/is8Xa8aX3rf1R+VKv/PCZHn6PnckR1whYvHBfRsgPfPRUeILsVyKRGiL1QeUVq5HkchYhnjxBW68vePq04N4TmuG7hVVLlkAHvGpQojjcVOSfFjTgT3s1fccfnundbydng5hLQ9/ji4HN8MX5Dc+PkwPZLGMISXhK1jCzy0whAn+2Ye8jyquvZw02+pArGeVBg930Y5RV6oDKTxmLaGU5Eipu92Sm3MsG6lEMkhu/pRYboSw4eusn6+U7B6qa4kg45J1Y8JyYmcOtlIYUmOWeJ4GNLVRiace8jTk9c9JFvZIuFTreI96fvsY42LqcsXhBB96lOfau9617vapz/96eNe4qIp60KIhgjDSQmJl55C5AmElYEfW4YUFDrEFONeFasnsScDpd/4ab1jsVJ4yI2QY/rvSQIq7LF4q+BydchjABLWEAmocCnbE1eO2LHH4MlRVo7HFS6qFyTLfsxBazmHKO10GsJNoUESEz9fSDuf+Lcc75Caxb6iisS29EWCK266p16uihNiHy/elimhOm0F72FWYaDW8i67NPeT0tjDpBpDQqD2dGXJ2yT1F0lNT12qwq9up3ivlc0bOuk8HWRJW9FaixsTpiqnSog+/vGPt+///u9vOzs7bWdnp/3VX/1Va621H/uxH2s///M/v/rdXgRlXQhRz4GfBjPvrejTFtaTlLHkJMXUj4s1dtdXcohjC0MRfv5N7yWiR2e1at16BGQoQX8MLgmXVuQ9zBSCUrvI+VS4bEcl64qA+KF2vH4KVQ0RLK8bt5eLZPXOIEoOl/1PXDqgFKLwPCB/+KralX1PTA8Z+nd0LyJx6geqPE7uuMsxLdJ8DOi63OpPPA/xkIA5CaswmdSv/8s5c07Q6XsIyMenCJQwU6I5T0D3ULB/n4sKD+syD6uHqXrojCrVV3VLto1jSO2dwtBV27KuOzs7bX9//2jO+8L4pGkTqZwqIfrxH//x9i/+xb9ob3rTm9oVV1xxRIhe9apXtQc84AGr3+1FUNadEKUQxhSl57C5+uHK+rhlFUJ0UtyxWDQswuVOjDHYY5Wv9OIKPqkyq9ZN0nr6jE5vLO6QYslEWndcxGSOQ4VbrV41/tVHnhgrR0F83lNSplpbPpnadxCpnenceE3/vSt2VEcYghMpSqtxjkNXjdI9p9wZ/Z5EwxUakST+plIkWls8JoC7oNJBfyLNPiYYJqrCjT1MqkD8Dckdx4pUGhKIRBZZnJj63O7tmPVNBAoJpoT5HmY6ciDNL809tovGt7eH25JE9it1ifd93I01Q+VUCdHBwUF785vf3Fpr7U53utMRIXrve9+72XZ/jMJBcdplyAFNrRJVOArZ0JCeFHtM/lCKkXNFtQqWO+qqnlQvZEBXjZdXEn16+enEKnKcQ8oc8yX82p6sTePJbegpN6iqcyIqUm2qHVLsS1cmerhV3XhkQHK2dHoKPaa6JlzeM/9m8rM7KXe0JFkVLnfv9XZdCZufbW9//nEcCbNqY/VbyjMjwarqSCXL1Q3H9GTkitj6tnl39lyMkDwJU0SUCpHPc+5S88fNeFuInFSY3kaeRyY8jV1+V3VLu/l6mOy36igCLtzUD+wL/w3HPjE9obuyYaexGGc5VUJ0+eWXH5EgEqK3vOUt7corr1z1chdFWRdC5HinPTB7Cbg8KG8q7DEJv05mtBI6DnZPuSF5kIMhLpMNx2KvqhSlhGoZvDHYQ3g0fAwbsHidK4XMk1/HYDJXxoltwm3tgtH2s4UqPIYLPHTD6w7Vl865FxbUGKWC5ArXEK7XJ+2oHItZOfKES7z5fN594LIrHjw6g6Q11bXazJDUFr6S4uG7+RJR8rOIekq7/826JHU6kQjH03eqvDMfr6kviVUdjUCbMTbXSmOHY4FqDzFTblx1LMaU5VQJ0UMf+tD2X/7Lf2mtfZ4Q3XLLLa21z+cQPepRj1r1chdFuRQIUdoVcNLBOaTauGpx0nDWGJXIlQLm9nBSjpmgqzyaxHFTvssQ/qqPQmE8vjrXKGH38FJuB9+T2sA+YZ0Ttu5P1+850oRJB9bDJbaMs84Q6rWjVshVv47BTQ+vrV5cUY9J6E64TFJ1B57UEyZzO6b+TosHhlCk/CaS1JsT85DEK6fqdVU9pZIk9Un1rvqSc8z7PhFsT/hNYyEdEzCEmc7vovLkOUz+qnIKnYSpjf06fr9jyFAiUW63SWZT/Xj/nPtpXE9RTpUQvelNb2p3utOd2lOf+tT25V/+5e1pT3ta+47v+I52xRVXtBtvvPFYN/ylXtadECn+7VtwTzo4eyt9TYbWlsM5x8UfE1ZKYZVEUJLT9rJKUnUVWqmIQsIfiv97n1ZbpBPpHIOXnIwbyN4ukQrbsVgvv34VRhtDntnmFcFJZCE5gVVOWXeiTuyEl7aB87djcH1rs/fP2OR81pWLBxbOO91b2sKe2rpSP9SnXlcnWwmPp0BX84KqjN9TNTY9tKj2rULMrIvGQUqUJkEiOdCCxvPN3E77S+TGxzrJbsr9Ur+qjV21q8Jenk/GduX9eoK/SCfrcdEpRK219r73va/94A/+YHvQgx7Uvv7rv7498YlPbG9729uOc6mLoqwLIRpSUE6q0HjpHQ4nI0vDfxJ8D0tULxpZrqJ0jTEKkT7r7U7ydvXrOXaFz7agMRkKu1ThKRq7HjlsbXElrB0hQ+2b2lLFDS0/p8rAHWBjVLEUEuuFWejcteNmNruQ6Nobtz5XEm7V13JKzOOYW/iu96IzF05So7zvfM5RQRrzUl39MRo+j7i1PdU5kZ7eSc1jjhQgXtp1NqYv9VKCsPcfx6Y+Z86Z5mk1PzzJPNkGV6xns8UHtKZ8KvVH6suzZ5efK8Z8OM1Ttg/HsucO+XgbO348YV3/50aeXm7cFGVzMOPEZV0I0ZiY/lRliHylA+GOgy/j1csDcUPhTjHlRozBGmtsuQNFq7AhbMfy1eEqjoy4NMx8j+3BleFYPOYopXCgcHznkPqdzo8qQA+fiaGep+WEhdfp4Q2t9tWXvjONbep96w7VVQ4/FyjhejK078BzYp2UMN/xOIQpZcd3PzEUwkWNh2PTvBuaM9yEwPd5Xd+RRKKt+2R/9zDTtvWUuO+bAhwzhYd0TZ7F5GPJSbOfy5ZwUh+kc4NSfZ1Q8x57ShzxNH7GEHlf/GisyBf5bjbai6nKhhBNXNaFEPUG7hfyUEYahJM+4JUrjiE8YaZV7lRYOmOjh9va+O3vXA1X1+2dFcRVvUqlYLh8XzkPOhA3/rqOO0kVkkmSCN8GzSRt5Yz4/dCQOq4MrpMShS8qtY3KRFLhtre3l8iE34Mn5vLzg4ODpTySFN5IdXUnRYLJUJp/zx+t4KpEhVmNAV0jqRq7u7tHDtAfaquXJ4h736rd3DamxY/GOIkZ8ais9OrDenm7+288WbjC5H0mNYwkNvWBn16d8EhufGzM58sPoCbhSASOtlHznG3D9vcNB5UdImZqT6/L1OVUCJFYd+91GocqfSmUdSFEvZXS1Mx8DCGaApfOfAzeSXCJVU3soddYNcqxqp01lYHXa8zxAlz50dC7cfYcAL48abhSwBKWG3OSkV5Cswx3wk1buWlwvZ2Ix7GbcnA8POtKWgqn+dhTrgXDYPp8d3d3iTh6XeX0nJSk9tQ2eIZ6PMTDdhZmysVhzgz7shrjTBBmHakEVb9321ipwaqf47XWIqYTKhEmtR1JUpp3vnFgTBK0q16uyAzZS9qrFGLi73l/fv9coFSY2onqql6vfpoXTtocs4ocTJWmkcqpEKJXvepV5etZz3pWu/zyy9tll112ohv/Ui3rQoh6YaypFaKhkJkbipPguCEbeh13J5071TFYMiYyEGOTYpOCNAZPbSrHJ3wnIENYFV5vFZh2NjluhVUROf9/chIJ17eOO161k0r37ETAiWVFLpjX0hsrXL3rNz4fU6hGYYqDg4MjZ09lSGEJXmt3d/fonjkH3LElTF1XuCQ2lcLEJGLieR3TLiOGznvkxq/jJF6L84SpvvNxpNLbocf6pXtvbZkwcBy4UsnraNdcWriSXPtxJQnTr53qmvK6dG/sX+8b2pcKk+olCXIimD6Wpy5fsJDZu971rvav/tW/ajs7O+3f/Jt/097//vef5HJfsmUdCJEbgcq5TIU1RiHSZDwuNlfIqxAirsjHYHPlswohotORZK4+SLg94lARTDeefr4L8y3oyPzaThoqvDSGHFNt5YpLTxavtizPZjkMSccpXKoavZ1RSUHh3+fOnVuqpxMtb2NfsXtbE8N3E6V25b2nXBOGgYZW4JofdGAHBwexjrpvJr2yPqp75RR7eK6kyeaR6LAujpnGXjohejZbDN15rgvbtnemE+cr8ao5Kcfu+TxJCSJJ8BBqmnMiq9VxCW4HqvrQtlRkT33rYTDOC89pc8zWMvmrzodaNX1hlXLqhOhv/uZv2g/+4A+2M2fOtMc+9rHtL//yL49zmYumrAMhqlZXnORTDcoeFie9n8+xKjZx5kFKd6eXVr49UuA4now8lCC6v78fwwsJh0ZxPl/eds+6DuUwkbx5KCWRhGSkx+LR+ZCc8veqc0VO5vP5Qr5Erx/1PTo8z0nhv6m9eW97e3vdzQZydHKqnkw9h9LDlAFvaydNvTpqt1tKGOfq3ceI140P3ezlfNEOiHz6ZgefHz4+fEfSmBD2wcFBa60tHZKZbELCE1a1GEr5d6qX3lNOF8cu5yJJnJ8a3rOn/Fv9w7O2uIOM44cHGLpC05sPqV0rTNpfqVJj8HZ2dhbamd8VJttS80oKntRLhqHZl6cVNjs1QnTbbbe1Zz7zme3yyy9vD37wg9sf/dEfHfsmL6ayDoRoyEitqpoMYaVVSzJWLoevgu2GrJKAiem7OFR6+JVCNDavZ2dn8YGGqVSrOBI21XXM7jZdh490qMhftWpdBa/C1dhKuKw3laxV88FIOolbbeNdVVmsVtI08js7O/GxKWnsVOobHah/x5VGJvYy/8mJKft31dfQAsIT4dm+aa77HEz19DZgm5EoMIQ3pPgxoTk5faoWwtP3vD0rculnZ6Xds07MPByV+s5DZLp+OpPMw6s9TKpfrnpVRyEIm2PSF4kkrt4fXJxozqS5flL/4+VUCNEv/MIvtLNnz7Zv+IZvaK961atOdIMXW1kHQtRa34FrQqadQcctYx2b7u0k2C7Rj8VVWQXfV+urvlKp8OlQe4aqcipu7Iewx+AN1Xssrkj69vb2wq6w5MAr0uLbj2mQk2LjJKHaHUMH4wqSY6qwznSElfpXtStzKuh8ksrmZIDfSfklBwcH8dDG/f39uAvKFRq+x+8zkdfVHG6HF2Hl4YGpT0VKWA+vC+tMPD+OwTErp+0qSWrLNCc0b9SWUlycHKd5w++wbhxX3sfp4E6Fs4Yw1X9O7BxvaO5TFaRal3yMPidh4/xzleyiUIjUAN/93d/dHv/4x5evdSzrQoh6DnV3dzca+ZOUntOUYiJD3MutGVMqJ+OGRCtL4fpZJmPwx2DRcM3ni0mpifxU+FSO6DDGYHJFKyM5hL0qHleZx8WVgeV1htqVxtOVBCY7t5aTSnuqCQmavyoFTzgkGZ43xh1N6cRid7KO2doysWMbJsdKQpDaegwmcWkj+H1hc6ynseIhF78X4vYIEclqIjlUJTh+FUZ04s0QJEkf70FjS2Em4rGNk0LVW2T4mEwpDOnRJkML3KRGpnGT8BIp2t/fXzpHzOdNUt9IqJ3sDm1+mKKcCiF68pOf3P7tv/23g691LOtCiIYO0qryW45beqEIHdXAWPJJsMeEr7SDg7jcjTIWX4ZtKNTCBEXher6LSoXPcMxQ/dSHJCMuww9hHwfP65pCDQmX98nE6cq5CccNfg+3tcWFgEhS79lidNQJ0++d96GwXW98zIO66I7EHUhqsxQSdUKka6Tke58zFSZD4D6uxuZ+pToyfJMcoodddR8pRyeF3lSPZBtIeHzcKAQppUdzVyRZBKIKJTvx8xChxmtSVra2to7mAlXTdM2hhZmIlu/WS/bSd4Z6+7Meaeyw7tzUwPnidoUbLqoxMEXZHMw4cVkXQjTk3HrPoVq1jM2vodM7TrhME20oMTa9NEHHhsrGYFEhSN8TlgwuHXcPqwoH7u/vL2D62TEeukrYVG98BZ4MHtUuOmSvZ8IVGeW5N+4o6Wx09hEdMRUgdwoexnGHKJXGlQo6czrFhNnaIslieC3dQ9rFpjozVON5MY6ZwmPEosrBl3Kb+L1KuUxEOqlplcKWyDT7POU7+YJBxXfmVQTAx4FUOZIOKsNqdzptksExoXe2i1Q4kiiSByeSKb+oUmETAWR4m0SV45H1p1qmktrSFaqUuyRst+9+XEC1SzHVw+fNVBEKlQ0hmrhcKoTIDxw7SRnKd5FCxPDBcfBXyauhQiTDuwr2EFZ1pkcy+FW+QIVFh93boi7nNjbJlk6VuTGOlxIgU85JT6nphTV8J0/ljN3oJoWIDkRtO7ShwPFcIaKS2dpyeIxOgE5vPl/ehq3vqW0SpteDTpt1p0PR9Txs5WSIYyApYf7SvXpCrdrdc60YHvJrOnn0zzkP+Rnz2/wYBuJ5CHzMy1VMhsVIpkgsmW/EBU0vFJvmq8YnFyrc+OH1qDaDjHl58jQXBn6COvvWj7BIdazGjoeYOS6dyJ70qQVV2RCiics6EKIq6VgrGv1/igGp1W01Mfmk+9basfG5ih4T4knEQ9h7excOk/N70HtSX6qnd4/FbG05X0A4HnahgjU2aXxohUWDptWeZG6qEr2tzMkg9vpJTovX4WNF6Gz5nKNeWNIxiePOyhWghKf7ckwP7XquRXKMSXVLjtjVKjoSv+cxWJ7rkzDHjiVf5TuW2pxEQr/jvBrC4L34Fm1Xb4fwSNTGzBX9RnXzMKgTAY1J3zmlsdzbkZmUSc8NYz1aWw5bkbhrbPXmSEXAUk5YCgMylKU6pnBvbzypjUjqPZyneXbR5BBdymUdCFG1kqCszMlxGlhulOlUfHKugtNzAKyn47ZWJ6nyHvy9ISwZduIN4Xq7OdZxMCssOpVUz7F4rnQknGR0uaLX+37tKgdH4abkTNhW3rZOfHsOM4W46Jx1v1XisdetasueE/FHhMhB9vqSCl9yzMybG+rb1L5Us1xpSi93nqnNGfqhDaKTHQr1VHjejwwrO7n0EBHDjz2SkxQwz/WpEvxZr6TYpSfKexhR10l19dAWxyvb0UPYFSb7g5hawPnY1lzh/KcSlvDYJlOVDSGauKwDIUpJh/5aJZ9mCGuMQ5WxkTqRVr9jcHzFn4yWTz7Gw3WtRFzSZ2PO5UnKhCZ8tfL10A+xxqx4PSTmSdx01pSn+R5DAj3jqO+wkHQMye++86rqNzf0aWxQYaQjTUm1uucKMzkHN9JUW9XGHvajY0iOjfWvHlzLsefjSQ4vJYT3QhrqZ+/vNCe8rh467M1zqnxUHfl97kxztc2vy88TkeQhgLo/H2tsI1+MJWKjuehh0V7+mcLUnlOWyDnVML1XkeSkWtJepwR5twWu9A3ZE917dcAi7837y8eQK0TV6zRUog0hmrisAyFqrb/rK02mk5ShgT8VtnB6desRGOUsJGVoCKuHKaPr33HH6dcWvmMpD8nr48bZjbsncCbsKodoiIy5Q+O1XUVJB8nRAfAE6t4WZhpWGc6Ey+8Tm+GRnuPxfBnHpAPwJPbKuXqSdkWGRDZaWyZEVfL23t6FgyIdn8m1JHtOOJMKxfZMu7u44mefpjwhVxKowrjC5wu4+fzCkRCqh/JtEuHk2OPnHOPE5Dzz/iTJEonq9V+P4La2SGr1mb+nuaB70qKPhIzz1vvGxynHB993gsf2SXZAYyLNZ+aTcfx4NMBJph+1MYX/YdkQoonLuhCioTwbOZQpGPoYRconxXGwmd8zhJcMlohBCmH1sMbsNhOW8iTcgDKXqgo3OVZPeaPhYm4VE0RJQFSoWPnutl5+AM8doeKQdhN5P3OHEVfZdJLpRfWACpDj8nEEvH9PancHmBxMwpRTlEPm/yvFUoRjlVWyh6i4PdsP4xPR8rokgiYcvu9tI2Ki+nOO+ZPj3SEmvLNnF88E8vCuhzV9231KIK/GJ8nGGEyeT+TtmBKoxyrgzJNTSblhVIh8FxkVz3TthOkExFVTtnXKnUrXZb5XWiRRfax2gNK+aY4wedzVtCnKhhBNXNaFEA3lDkwdvx1jMKbCrpzMkCqmXUNTYGlCu7pQfX9MnYcUsERyiVnlUVTYY/BoYGkYfRXPNkl1pjrgoaBk+FOibqWoEZfv6fs9PIYRx2Cy3r0xyF1o/FxOie0qh5b6q8KtiGs6RJCkdAymj/tKJfUkafZ7ale1ZcIlntc1Jb97m6o+YzGrdqWSNnQGkUixkwJipl2QDG1p7A6lHqhNOb9ILvzaxCTpdQI8tMBMoWifc7pudWYU78EXUxtC9CVe1oUQDSWSTjkQV1FsTjIJhJOeiD7kGPzck16hItDbZbazs7PgiH0nCHMTqjonrKo9PYeBZ+9Q6aEz5uqRKhTzuKqQkhyph1+YI8J70vupPlx1U21zctFaKzE998R3jFE5YX/7Kj3Nwx4mx54/OZ4hJK7Aq/rJcflK3XPB5vML25b5QF2Ge1RPjs/klFIdqRxIgaJaUYXdvP2SE0+YPAuLc9PDUlQuPNyi+qVcqmQnFJIdmhup71mXRPqSeii7pO3ySR3SnHcisr293bXZIn26b57+z/cZave5z3muz1WXCpPznEcSJMXX75H5Vexz4nGsTFE2hGjisi6EqEcWTppIvQoWHcdJSdgYHMfskZGq9BSA3suN7hjchFXhJ8NMyb93lEF1TRmk1Ha+a8VDJronT04fwqKTo+q1v7+/EH4lpupGXHcgVY4YnTbbUHh0egmT6gJfnqOiwu+SIDEvhdfgPVaOkSt77+Nqt5KHLRyzUl2SIydmNf40BxKm14O/p4P0ucPva0z28IbmLgml6lQRPuIxFD4Ubkrtm8iJ/9YJGfF6YV+Oeapgntfjba+FinB9EVmFKHd2dhbmWFKdeooXQ9wbhehLvKwLIepJzFOz8jHnnIw5DHEsDh3y0Os4daUhVx5MlUNUtfNY3ISVkmXHvHpt7I7f87gSHg2k71Lq1XUIq1KkHIN/J2yRg5QIS7yK0PhOKIVAxiTS6/cpH81XzLy+K0hUZPg9x/JEWZYentojYY7ZQZnCrQmPRENtwjpVu8CG5i3DTik8rBykRE44Z4Wr79CWcC5XeCQHKXzl45jf5yGWQ2Ex4jGRujrjSgpROstsSAHixgQn/swZ9HHpRxlUYcNeXaf2QSobQjRxWRdCVBk7rXrGJBaPLWOSDg8ODo6+f1xsrpJ6CcBunLyMwSeWDM4YQ04D3AuTEd+xKFOPOUeGbTxULzozriCH8Hp9XJ06m1aOnmBdJf9T0qdDS7h+3ADb13E5ZpzweA5YWo3zCfIiC74S91BlRazkgIkpx5LUAzohr1uFl87rYS4J30v3qTb2kBrxfGyke/fx13tJefMQKcPD7lxT7kxPwTl37tyS/eCmC4aTfdwkskDCyv7UOElhXv+c4buhsak6OulxEtWzXRxTniSvz9KYEJlJ98NNGz3SeBr5Q61dRITojW98Y3vsYx/bvvIrv7LNZrP2u7/7uwuff+5zn2vPfe5z21d8xVe0L//yL28Pf/jD23ve856F73z0ox9t1157bbvzne/crrrqqvYDP/AD7WMf+9jCd9761re2b/3Wb22XXXZZu+c979l+4Rd+YaX7XBdC1DM4XNlNwdSTNJ5eCtUdFzutPMe8XJodg+9YPbVA+TJVO/vEd/wKyx2XY547dy4SXxrDHknpJWCmujA3yO8l4Q7J5zTos9ly3hfzM9L5K47rOU0kNI6lz/m3wi/EdCWFIS0pMCnvJLV5b2ySJKrt3EHx/uk0XcWpVvaO65iVM/aX9+0QcSUh4r2R0PZUMd0v54jOUdLfKRTHucV8LI2ZdK8e9vVFAtvcSRIVSbWtjguo7MjW1uKDrn2M+nZ870Mn4R4yTQTSx55jss/SpoCk9Hruo+ZA7wykKXyPl4uGEF1//fXtp3/6p9srX/nKNpstE6IXvvCF7aqrrmqvetWr2lvf+tb23d/93e2rvuqr2ic/+cmj7zz60Y9u97///duf/umftje96U3ta77maxbyYW6//fZ2t7vdrT3xiU9sb3/729vLX/7ydvnll7eXvexlo+/zUiBEnGBTsfQhI8rJn7anrlJ8dTuEqwnLiTwWX1ieKJ3qNmaXl694e1h0lhXxGVKQ3Oiw7mxH7iapVtCV00tKyhAp8ORZGfcKR86RbUxc5vP4VnNPgGUCdC9JWPfodaOTTOqI9yvb1NtOCdl8rpUcZHJeabyTcDgeV+38TXpGmIc6qxfrT8JLB53ykLzuVNgqe6F7qhSZtK3e74vvi0ilccxxW+Eyx6lSpZiX478bCjvr9062/F551ADb37/HTR+V2sN79hyrVEfdJ0PirkK5+u0vEsgpy0VDiFhms0VC9LnPfa59xVd8RftP/+k/Hb132223tcsuu6y9/OUvb621dvPNN7fZbNb+/M///Og7r33ta9vW1lb7m7/5m9Zaay996Uvb/v5++9SnPnX0nWc961nt677u60bf27oQojEhHhrBkw7OMc8X80l6XHw6zrGEiJO5UmjSPbiB6p1HlAwWDX/CJj7DSXxArH4zJufDd3P01CnurvEVND+viJ5enuhakQJei46F96T7cAde5QC54/V2ZNjDVTE60iqZ2VfPctKpbaQwOeFm/UjaUthX13dHovasTsImyU7jO4VF3DklpUCf89wlv1evY1K8eipEhZtUQY0N3QdtCPu5wiTJ8rnM3ZO695Q7x3HmpKyqS3WOENvCw6DsK81rhcUrTL9Xz2dK/a7CsUliRIKX2jbZA427ajPCaZCh1taEEP3VX/1Vm81m7aabblr43rd927e1H//xH2+ttfarv/qr7S53ucvC55/+9Kfbzs5Oe+UrX9laa+1JT3pSe9zjHrfwnde//vVtNpu1v/u7v4v3cscdd7Tbb7/96HXrrbeObtBVCwfFaZeeTE/jnRz0ccqYfB5O7sp4T1G39OJujWpXVLqHpBD4+UNutBw3SdsphOfyPH9fhc/m88WkYjfujkmDS2Lq9SMRS1uffSXpRrbK3fE68l568r5yinggZcLVNZhEy3YjMWAdqxW26kFc9hlfcpRUqFrLqhxz07x9fYwz3yuF0fy7FRnhOGI76+DOXs5H6juSCxIJV7pIrnm9KixDR53mHpVF4iWikvKEdF+ea8Xx0LMhSXmkQlZtAPB6OLllX/p81zV5ZhFDndU9zxEq1k45b3/1fXXfKgxFV/VMJNltyNS7nFnWghD9yZ/8SZvNZu2DH/zgwve+53u+p/3rf/2vW2ut/dzP/Vz72q/92qVrXXPNNe2lL31pa6217/iO72g/9EM/tPD5O97xjjabzdrNN98c7+V5z3teHEgXOyEak2fjuQDHLWNziCrDNhbfndMqr56Cke6hksx7r/Rd393SC6nwHj2kkZy1xpFwPddF71M2Tyu8w8PDJYVPDiW1n66j9xkKkDPT5+6QtOpn2IrEjPeRVLYKV9dODp0hKa7UScaq08FV2MbVWVHeP+oDJwh8T+PBMemgGOZhHydC4eFCEj3PueJvElHma3d3d6l+VIxERnyMMN/KCUpFLkkAvZ2ZwM/fcf70EufZFzyvKI1534GWCJMTbhJSrxPDmEll2dvbW8gZ8vnnW/B5Xe8vzgnaN79mb7G1t7e3kN7AEFnPLibSyvHnRytMWTaE6ISE6FJViDhwT1p6q6op8YUzRo2qVi/Mz+kRsZ5qU73Sal+GLOWIuGEklq/EqzqnlXkPOxl+riJpsNIKdTb7vFP2kJHn1dD48be+CubqtZL2Vc/WlkNvvEcSlaQs+PspjMG2pnLiTs4dIeuQFDs6Ccfc3t5eOjqgteVFjTsikcQ0/6QeJZLg90aCSwJV1Zfj2FUDXS+Rdx9TUv00hqk6krR6H3MMa3wz/6W3YKoIiZPzNPdJaJ2YOk7KO/O5r/GXnlfIueHqaYW3Sk4UFwHEI041t9J48rlD3GQX+J0py1oQoi9myMzLuuQQjVVtphiU58+PO9PEjfuq+C7PH0cpcmdf4ZOwJCOYXskJO6lIoULHWqWOydEL17FTGMVXc2PPpnEnLMeUVptc3VI9YohhKBdM/ZRwlePCFTxJDVfmvYfJ+th0wuH9q/q6ykUViw+yTblBbFNeo7XlJHt3wiJOiWT588eG6qw+5bzwtmZ9SQ7YD0PjxpNxHcvnjMiO54O54tXDdVWQc5xzJilVylOTuugErcqxI0HjnPO5x3bQ/z3p3+dUymPkHHa1lmOYC0Ff5KidqRzpcz0nMc0Vjn9Xf9zO8Jr67ZRlLQiRkqp/8Rd/8ei922+/PSZV33jjjUff+b3f+72YVP1P//RPR995znOec0kmVffiyjQCU8mWFd6QAT4OvocdUr16p646CRnC8pVTqmO1a8nv1VdsKUxHhzMG0xUfGuGEzTZ0B9fDY6I3f59wWQ+uSpnnM5Szcfbs2aUdiT1cfu6hi56aMgaTJLVqZzpsve9KX5Wn4b8bwlW4qcrVoqOrwoieKOvjMuWJeCLuUN5R+p3vgvMxQdKUbJX3Ye/QUMf0PmVfJxtGVY7E1EOT6fspTJawq4Rrf04iSQe/R1LBccL3087ano/w8ZuStTnuerljqe6eZzdVuWgI0cc+9rF20003tZtuuqnNZrP2ohe9qN10003tAx/4QGvt89vu73KXu7RXv/rV7W1ve1t73OMeF7fdP/CBD2x/9md/1v74j/+43ec+91no4Ntuu63d7W53a0960pPa29/+9vaKV7yi7e3tXZLb7oeM1HHJSFUqHL+PlFS8ahlyaml1e9x8qSEsYqa2SI5mCItt1ssFI6bj8gn3FfYqeDT01SrbcfkdrtAZZqmUzK2trSXFwq9Z4apevpqXs3Uc1rGH2dpyKJrhJh93lZPlyxOjE2ZFOlIumKu1CsH57kNXtXrjMfWNk6iesuiJ9qmu7LPWcg4kSa+/f/788rZ+5s84puP16uvhQ9oxDyOR3Hn+oLez8LTY6I0T1oWYToz96AHH4kKkSoxO16UqRVLpIUaSIeG57WX/MbF7inLREKI3vOENseGf/OQnt9YuHMx4t7vdrV122WXt4Q9/eHv3u9+9cI2PfvSj7fDwsN3pTndqV155Zfv+7//+7sGM97jHPdoLX/jCle5zXQjR0Lb7KUsvPJeSdU+Co4k8ZDz8O6vi+gqnwtIKnMR8VVzHGqPu0TCpeFJ1D8vDc2PwtOIlrrcNcROWS/XVOPV8Eq+r44pA9YxvwvPnz/UwW6sddYXXa1uGhxKmO3N/CbOH58m5clCJSDlp9r5K95/qzJy1FLbROOUp8o6f2pnEytvfQ3G6DtWdSglTqfqqys3xdnVF1HeY+oJk7LxjX7sKqPFCcuWqn+rbC2l6HUU+nTTpfZ+DHv7y/uAiKPXTVOWiIUQXS1kXQtRTFvgYjSlKjzCkc1pOilM5COLwno6DS6wx9dvd3T36rT/Ne1WsVQgKC/u8is1zZbwqIaJxVvHfJrJErJ5h9qfXV5gJV3V3rB5Z7z07zY1/auPkfBzP1TdenzkbzDfx9uthDuF5e+u3JIYc42xnEiIeteD9wvnhaoof/+CJ2izst8p+JTwPZ3OXGq/j88XHSXVWD+0NQ0X8nsiKcNzpOwHrhRp9TAovfZ+klJgpVNUjt8wf3N3dPfp9dTSBMNk2Y7bxD82vk5YNIZq4rAsh6q0Gek9FP07pOR2fvCcJmQ2tmJODpMFfBXsVLDeKfkbPULjOsZLhSw5C4RDlnjBfplJn+H85loTn2/69nr5araRxTwp1I8sk0p6qScOecFNeEvMuEp47NZ8znpfENvbDDJPyMptdSEZNeAmXTqJKOBdpSU5Vbbi1tXXkTFM4xjFTv/l30sKAOSROtPzlc8kVBZLCat554m8iCtVp1FtbWwvzjqpKtWvKE7lTwrGfkcUcI/WXE85e/UggfdwRk7/xvEkP06W+0z3KjqT56v3FHWNOONm+PTzOn6nLhhBNXNaFEPUcWjK+JymrKAzuyFbF2dnZWelUbBo7n8w9fCZ+9hK46YhoBHwLqqtALtWrXsJM2+iTgSImjVnKa5kj/+DcuXMLdRyDJ+Pb2qLBS+EC3YOuyZ1mUmJSboaPE2JWuJ434TkcxOqtkj1Z1kM9dER84rfvJnIVxHHovLhF3Z2EX4c7nrzv03u8552dC495cUxP6PZr+I4nnpWT8Dgn/Dr6v6u2dMBMVNdOPYZd0sv7m/9yvqgk0sdxwvmQiDXnWW8nn3anecK8Ew7WLx1BwUUWf0s7o/vf3t5eeOq96usqGhUtX/wpBK3fuOqe+iIlcSdb7eHLKcuGEE1c1oEQjVVspiBEQ1ju+LSakfOauk7C9C3gyWknfDkEkqie0Z/NPq8CVCtIV06I7Vh6uYJTYYrgcEt7Il5UTxxnLJ5CB75idieq/nVn7g5PmENnxtCR0EmmlfpsNott4P0+ZqwSk2QujQsPd3GlXR3gSKftqoccBR2r3uMxCwx5sq/HzpEUbqKTrwg9+6TCc5VEmJUaRjKQiJLwEqHlGTlVgjJzzFpbDEf6jk1X/irnr7ZLeK4m0t5ofHDXpt6vwmgpidvr64syt3E8iJI2SQTX7VBryxtESKq5eHD1ne0nG+XnRW1CZhdBWQdCNOTAp9jpNRaLxpdOZlV84oxRv9xopWTVhO+OPT2Q87i4ju1YCq8kZ9JrWxkll73dOLlCpP8fHBwMqkPagSUjx7qyXiS+vA8emEiDOJS0y3tPK1Q5HpJCkRitzqlSjWlTEnZXYbhNW3XWeNzf319ogxRmqhwe35cTY06IilbcBwcHUaEaMx9T+2rV7vkybMcUDnaSubu72yWefr8qvsVcNsofmeJ9KOfuxxukQ0rZtp4szERwDyGm+syhnuj6HibT7/wsrCqBWfMoHXWge/F6ujrqv9c4TQsHlTQHlWfqdSaBJqn3LfceSlM9fGE0ddkQoonLOhCiITWlSrg9LtbQypsG+LgkjI5+TGiHk24VbF91j6lbyvMYg7sqFjFkhPy02daWD0OrcojGnB9Dg09nXBlX1cFXjQlLjraqIzEVovI2Vp1cORmDJwOdQg7E9IPzvD+rflIbuCpCgsawkH6bjgdICpGTnwrPiaqc95kzZ47IN8kkr1fh0RmmAyNJfDgW2P7cZZbO8yGOCJiTCW515zx05cdJc484UumrVBlX/0SSqaIKU/dUnekjsic8f3wNVWVPhvcFUFKBU11J+nw+s/7e375tvzpWhe2SQop8nuWUZUOIJi7rQIhaG36W2ZQDcZVVKRONj4uzygnV7oDGYgsr5QhUr8rx+YpzCGusOuRtQUNWYSe1qDqF1o0h60nDrFW3YzO8RDLlKoHnXMxmy6fxSiVJuD7+6KxkkInnBryXl9Paco4c69vaYr6eHAYds+Pp88o5J6VHmFT4kpqQ6qc6DBECjRHOVcdLY9TJTEpCdkLH9nVFgXNV1+J4TnNc11EoinVKbZlCfUyi5gKlWjiIiKSQqf/G5wDrW6lt+ozhaf4ukfPUF+p7z5Gr6udhcNmZlP/pxF3ziHMqtfVx0ibGlA0hmrisCyEaUommHIirqA0eT18VZ6xq48Z5VexEIlZ5EZcOLmEnrCoxtPfiirvCrsiRvr9qqE51ZdG1mC/mBpDfqQhuWn0mXA/XOaFg/Tx53PNn0jECHqbw+vJzz//Z2tpaIEzuoBOm7jPV1ceR95sTzEQaK0w/MZmJtxy3Ph+8/5It0JhLDyB2Au1jSnhyxFXIKc1TT7pPY8DPReICReSpyhNi20vpqYiNh7d1Hz5u0+NlKnXJFzx+nx7OSsctpDbS9apQJH/byxVLhNTztaYsG0I0cVkXQuR4fJ3GlsehZE4lNU4xEeSk0jN9KkN8Euxq+/NY3FXyprjzaz6fr4TJc13GYDPPSd9xJzy2riwJu3ocBp1HddaNO4cxuK6IVHisY8JP9+O4VFFS29L5prDUmD4WpuempbGdkrGJqeTWofaV86py8FKol7vWeF1vh4SX8qi8X70uXkdek/ljvTqSdCS81pZJTsrN0VgbM2c8l6aH52Eqx+SCr6dmO7nvqUtsU+LpiAFvj6pdRb6rvp26bAjRxGVdCFFvYk6ZQ6QylNejXVFTELGxCpF2rIwlI6msmmtzElxi+UpvTJhQDnksLlUkz5PQozCGMOUEWIeEnbA87DMUmvT8ogqX7chVccIbqqPnbSVcD08yXNDahYRhPl5kqE2rNqbSxdX9EJ5jppydhEv1orULCx8qZalNHS+pNwzDpPmja6fw25g6VpjJfjBx3MN8rF+1C459MmbOsq1TPg0/rxRYXcf/HoOZDqvV/TKJO7Wr2mSoXamIzWYXdptOvRhn2RCiicu6EKJkDDgxpi49A8/JMQX2WEIkaZYGctXSa0c3qKyjO8pVsBIBqw7XS7tMPMF4qB1Te1YPBZ3NFpOqPQHVHegQVq8/Pc+CfdnD9RBLD89VsIRJddCVC88bc7WEeHzMCzHdobWWc6VSW3kuD7+jFbrGAH/nCcFU1VhXJ2C8BhXJhMnvMq+I4b2kvnLsJAfPdvY6usKZMFtrS/MpqR4aS+l9J6hqf2I62WMCexrzVJV9l9ZxMJnPM6R0VvlorjqKEM7ni8nYijqQpKc5fdplQ4gmLutCiIak26lZeg+LW62nwF5Flk5bxFfFGkOKeNaO57CMDVFS5RhTPx6WxnNp/L4q7FXx9KJB9/wNz5MYwkp5D2w3KmattUFc3+7f2vJZKulBp3Ra/D8xvC3Z1nJavvJvbTmc7OFex+9hprwOtlfCk+NzhYD9ybFDR5hCjbxvKTjpLC0PR3roxMeR91treUs4lSuvY8KkM9f1neh5aIi7uypSxhCWj3teS4ckcuu/ExARDWJWIeI0nhiSrJLD+XIVO32H+WNMzE6qnqvT1XdOotaPKRtCNHFZF0I0lP8xdRy3hzWbzZYSS09Sxua2bG1tLaxijoObtpZWLxoNGe1VErmZHzImr0RGTTg8yJD3XWGPwasOuWOOjm83TrgJi06Hzq6qq65T4bqiMQZPJLkK3bTWFtqY+VZJgUi7ylJyuOeI6P/ceeXhG1+Z65lTQ3hV7o3bA8/BUvvxQD9XciqykNSMNI88f8bPWfKxmJQX1rGH6WflzOcXDjZNeVUK81d15BgnphMMD4OLPHjf8Vl6rv5ygZEWaL45gOold6ix/1Q/jfUUkmbf9BaGmlsVoVMb835PgxRtCNHEZV0IUc+JM99gqlJhubObAnuVnB45z+PijsVK520oOTod0NjDqjDdESSHSGPjCbir4kniVzhQBk7Ey41xD7fC8iRYGU21J88Eai07O563JKPMvAUfg8STo9DKlwSaq15iupLSy+HwEIYOO3Ti7OcBeV3nYbeOnGTlGEng1JY8/JP19qTpdL1Uv2RXPO+HL5FXn5NJ3UwOOCVJ8wGo3p9cJKS5OJRET9KnkCefT6drev4R70Xv+bb1IdtCtZNJ1XwIq+O7AqY6+HjSi/fh4caKNPqLfUIVbkhZn3pR3tqGEE1e1oUQ9R6yeBqDsYc1NfZQ3abETVhVAnlP1RmDzeTfysn1Xn4q85BCVOG5k/fVqocIKNdXuMTy9kvhvoTJ1XoPl/kUvruJIRI32J4DJMPuYdcqTKTfeFioWmUreVVjxxUMD8O4kpfyvEQOqtDeEGYieCSJiRD1QonsO/aTh4/8IEaexO1zz3+va/fUIPYXw12ueFWPWtH3GQ7a2dlZwOSY0vd5be4g7c1pfcZ8S7WDkw/icZ7pGho7KUeI96l/vY3S+PYFgR/sqHupMKfcYONlQ4gmLutCiIbYue+WOWnpYaWwyEmwh+pW4SZncRys3o46d6qrYNO4jakf70fXlaNw5SVhV3gubyc5Xf/XajvhcpXJEIPnanC1qfc9V4FJ01wJO26PWOi6rl4Qw8kAnS23tqc+Vp09LKH2lFPkvVYhtYQ7Jrzo9RMmP0/qBDGdfHJMb29vL4VRU7jW2zXlliQlge+lHDDWg6qFkxkmsPv41r0lhTERFY1R9RuVIn6PY8MJM8kN+7YaR952+p6HoTgmva2owPVsCgkf2y+pz1Stqtwk2nfer/LW2DdTlw0hmrisCyEakyjruxdOUnqqTToJ2R3MqnXrSfeVc6KCwJVRD1/GecyZRz0n59jMCWGOh/5O9espUDIunkNDbKoAHtpKeLyGH6hHB1bhcvVOI9rLWeIK1R2cJ3WSJMio6+8qydxfVBs0F/jZ2bMXHsJJVYK4dH7uWCqHQpWBYRC2leO6o+U47tUxtZNjOjFlqMiVMiqEFZ6THI1vf8yHKwwkMFIaxuQMEpNEQ2PdyQlDX+lB0D37InLDUBPnse7D54z62vPghhTg1P6V+ut22NtYbeMKcJqHPVJOW8LcJ86d8+cvPMNwd3c3HuA5ddkQoonLpUSIaExOWoaMVkqGHArp9Oo2tLJKzkdSLQ3fED4nPa8tg9bDPXv27EKSqBsUN/xOVtzIuILhBoyrUxojStTE1LUqkkKZv6orcxYcl7tKaPjTClp1YKK0K0k+dvhdthnPdfHk5KoOvE7l7On4SCY19kWG2R6uIjDEx/mX1LAKl6twV8n8wccMmThxqxxh1S7ElhNMfZjafQw5Zb9y0UBy6O3JMejJ7lzs+TxKY4qJ+Lz/lLfEMeAKrO6jWtSwHTzxX/lPqX4MA1f5gb3xy/HGMZrmvj+qhWPAcZ1wciykOZzy5aYqG0I0cVkXQjREGLgrYIpBOWZXlBuF4ypEqW5j8my0IqHhHMJPUrUMhm95TgaBSgCxk0JEguJ15M4uvcdnE/kOKhIQrsSSCpXIAnewuUFzYz2Ey9UtyZU7DDkiN5z6rte1wuW9ebumUKI7JE+ipcP0vkpbo4lH58cQh2+7T33Re/CqdsDx+hxvdKQqHupkPVn/pE55X1VhY+KxLxn6YT+ma6nf/J7TvOgRAoapeJBjpYa6ItYLjXMRo+/5UROVDfbFIwmK31sVVkx1TCG/NGfd3qXFs+rn45e4vshSG3i4VESO8+24i+GhsiFEE5d1IURDIaUvxi6zqbCH6pZWrsfFHROa07WT6sFV51istCo9e/bsUtjOMWmAhdnDJl5Sh9xQysErKZQOpIdLg+mhGj8WgXUUKXNVZgiXKkxrrYuX+riHqd8kZ6ddf0669DdDRz5GnCi7SkZFkTbEnavXXcUxpTQkTHesOzs7S+ODSdAVZuXcfUHi39N1/J49l42PShmLSXXZySMJWupfhtacGKf5znbUGNSZRMku+b3zFG72j3/Pc6WYuO07QjVu0hjj9ah29RbXCvuRuHsuEkOLHprcKERf4mVdCFHv2HjFkacajGPCc56fcBzsnhSdXtwmKml4rCLVw0qrMBoNJnpyB0eF7VjJ4CXnQEwaIxpkx06OwfHSyk+Gm/fJHLQerp+6nOomTB8z6X4dl/kYvL9E6hyvtUV100kY75cY3FZNFdBJa1JivQ2kLCS1kO3Auog09MJrVT1IAvhdKh1OehOO19HVoTQnqRC4Isj7SmpH5bCrvvTrOfnjd7zfPNST5m66d99UUJEOx/J779nISiFPu9iSDUuKk4fGvJ5VHWkP0xyu6jvWDq9aNoRo4rIuhGhMCIvS9ElKMrb+ciN0nNWBcIbCgZy4rS1vWR2DTawx9Uu4Y7Edy+tX5U54H7N4mEr/UnGQYUwrRJ2Xo/eqZ0AlJcJxffs4f898CM/T4pjxlTFx1X5UKnqkLuX/uBOjU+Lnuh6l/ip/jjuyRBpSAruv7pPDZvv2CAAJKYmrJ1D7Sj0RBMdzkubhLBLFRBTUngyZ9cihjzPdM88TYngx7fzib2nzUojYbZMTN5KGw8Plh9UKy98bIni6p7So4H3wrCOfrxxDvK8qN9AVQR9X+rxaWEsJ88VRzzZzDDjeVGVDiCYu60KIxpzVMxUhGrsLxCcLncpYHE3+sWcRtVbvgBqL1VrdnskAs3/HYDtWlU8wFrO1xa29jNmnEN4QnhxEItkkf44rx6XVtxt+5RRUq/rWltWbhKvryXhzXJPQ6EndJGh0UolkuGN2R1LVuQqDeChK1/CzfnyuVI6DDsmVntSuFWZyfEkpYN3ZNurjlIDMPkkqoP+t71FlpKPu/Z6EkrlovJ+kmkhlTEpX+r7nlrFd3B6qb6oFRQ/v7NmzkUgxBEflK+3kctvFXCdfFPV2Zyr8y3t2zF5kgmFaLsymLBtCNHFZF0JUMXXFx08SuvIyRkHhjqNVTm9OOJWRqBIIk1w+VPch1WY2y4m87kwcOxl5x6pCK05u/MU6pRUfDS1VlKofvZ2q8ZRwaFQ9r6JSb8ZiOi7bL/VtpYTxiASOxd449t1yqT9Z3JHylGN+f2gcp7BU6ueU01KFjYcwRSCreULyxd+4ktK7v57TTLipfpVNUdtUSo4rIEm9rUhM2slWzSONlWrODvWfK0QVGR8KUybcdF9UkHiSuWP15gsVvIokbXKILoKyLoSoOjdHKzUN7ikY+hiFiDudjostwzD2TKAKYwy+YyWjOnQWS1Uc37HkSFI4JGHy3obalIoCjVK6NsljlbzLbdxVG1K5Ud2rYwt64SwSunQSsYeBXP5PeLxPEbbkTDwMKGeVDDuvl8KRqj/DB2x7Ofkqf62n3KR8MH6HCfiOmZL5vW99QeH1ozqXyKY7R4bPGFZOfTuEV2H6UQSqL+cir9fDG2oPV6d43RTC5ngeUz9fVPqp10kh0njh96jcef1cYdUcSDv+qhAe515vt97UZUOIJi7rQoiqAcizUnqrv1XK0KqPzq615VXt1Dh6aRty2po7hL8q1mx2YfVf4Vb4aVWYQg+JDIk4KE9kSPmT8eIBh3SUxOu1QfUMJ+Lq9wxRee4Fjak/PJTf4+MrHJft5Y7HnQwdxu7u7pLBrkJVwvVwpRPL1toCWWRIQQ7Q6+WYmp9sG985SYWJv+eKnJsn0hjzv/UdV03kDH1Lta7NZ2tR3eH9iiz4OGIoWbsdeY4U71vjp8Jj2/P+0vhl+JaYPlY47w4ODpYUGr8/H/M+T13pSe1JklipyT4vUh19TqZFzfnzF84Nc9zKDla78HxcpvvljtaDg4PS/h63bAjRxGXdCZGM3JSlFzeeEncszhS4x8VaFdfVARkcnpviycl8VfeZFBtiMSmW/yfeGFLoZ/VQ9aIR7K2Kz5/PD5h0h+RJ1SkE5tcbwnMlxpOFtRqv6r+1tbVEwNiuaneGJ5IK4JiJmKWwR2uLifsMzTJPYwhT7e2nKydi5nlBqY7z+XzhWvP58rEBuoZIpic2J9WSipfjpXm7t7cXnw2YktudkPD7FV66hhSVXv1JAnmvHuJzvHQSteabE3YPrfsWfB+f3s9J6WI7idSlzRBuA7wtT6tsCNHE5VIgROn8juOWanWSXr56OC0cd1j/f3tXG2VldZ33zMAgIwIzoiDRuSEJCVZRMaMp0tV2JZTGWBtjay0lSG21NSGJGJvEpFV+NIkxXU3bxHZM7UpXu2q+dMUmsWiWCwnW1BIQ/LZqowGXEbBBPoKgBk5/ZO3huc/d+7zvvfMOg3f2s9ZdMPfjfc7Xe/Zz9t7nvM3yMpeVs8Or/Fbqi4ZZv69/c2KsboUu4tTPrFwK9iSggWajxN4c/dtLvMYy8qTOIgRX+OgF4DrqxKveCU6qthJjrbbN8bHQYM6icLDmxqHAwtPJU6pPrFdjaR3mh4854LqlZId3UkqFfFxHNUro3bHGlF4f3x8YGGjgw/pjTgyGZ63wYVH78n2H5bb4UmoUKJ2dnUNlxD71xFlK9aElPIKA+SzxhPc7c1rhWPaQWmVCrxS3iTW/oNfLyvHi+lptYd3nuZwyvm953OD44jpViRBEFaNdBFHOw8Fx6eHAupk8TpzUhsPjixaRaAAAUlpJREFU7bLil+7AaJYXuayDzfBlhbK6u7vrxIY3iWA+jebpsNveMlYWJ297VU72TOBEhPkW1uTHhtAql/c4FDR4mIfAYgmNAp6YLCINRhTHtFUe3B6t7Znj04RVvAZfF0NQWgYO0WFOB18vpfoDMDmUhKLZCyWiF0Dfw/Gc40upMY/DEwUDAwN1hk3Fbe4cKRbaKsSxrPz8Mvx9T0/P0P2sCwLrRGOsn8Xn5e6wSFQe7VcrxM314/lA7y0ef3roorXD0BKv3C/obcT6KT+PRUy4to5b0O/gggCvjXk+3CdaP7yWCiJrt5nlecLfavuix1bbt0qEIKoY7SKIcka8SkGkN2FRiIkPC2uVR//NceFNiOKhLK/F5dWPczuQF8M6FjfnEikXGyGrXtaJ2N4q2BNlZflEpC45msuCOSZWPyNPSodWsBzO4DrxuMIcFvQmYc4Djo0iPsw38uqZ85RhebDO/Cw3DPlZY1f7htsV81HQOPGOMwyvMh+3CdaTxZu35VrHsf6rRh2fXs5tzsIYjTCPNRbTuCsRy2idBM5jTNsH64RthJ+zh0R5MQmbz+PCZH4Wzhg6Tanx+Wl8D3I79/f3m33CW9U9Ts/To7w4xnj3Gotxa671Eu7ZU4YhNWuXGr6a3WlchBBEFaNdBFHOFd3b21sqsbgsrNWS99KwRSv8OU8DT4T8QqPJ17PKwFyWu7qjo6PQW+WF7JDb4lJYniDvkEYrp4a5kctyW/PElnuopjdRKq/Wx6qXloMPkdOkSyv3g/uYefnp5Va/Yh9q/oPmXlhntljGjw1OLpEejQAaCl25q7Arc8gfJr2isfRCQWrwOd9D65nLD7F2JOEuMOTF62D+CIoab+cgjl2+rzk/y2p/9hCx91PHBM9B3B99fX2leXFjCnLyw5StvsSFEc+blodIf4t1wc0T6K3hDQtaR+TFecdrU/Qos4cIc4a8UCgKKa4vc1a5OE8pBFHlaBdBVCRQrAE7Ulz8Sqm1rfd4o2L+Q39/fza3xbv5cmVArpRSA5+VlKqThJUkzUBu5lI+FCTeKbW5icnixvwZnih5Refl7/AEaZUJPRzc7jwxopBAb44ntNBjYfUzJ7OjCGTPjho0vaYlKjGcye3AZcCVtRpmFKb6GQovS2gjl+Uh8gQU1gVDIsqJHger7TQsgoLZSvDn3/BWdxR+WBbPCGMIkI9r8I5osAwucnqLQvSY4hhVXs7rw7AT81r5OlYdOffI8sCw2Lfy8bS9+bo8l+g1cgsva8ckht68+YQFD3PimENxqnOYlcdUFUIQVYyxIoiq9BAVcfE5GSm1tvUeJ68yZxF5SaKKXBnYmJc9+4hj5DqpMpDbEg7IZ13TMibWCoy5lYtd+MxXxutXxOsJIuu5UZbr3WrHIl6RRje8tRMIhRB/ZuXyeG2CwsVKClfD4YWjtLycH4Xfw1wgTO61hBS3Z0r+Vm2sJyfzo0DROnOOF9aT7yVuJxQQ+D6GWDnPL3fP8UGM1ljIeXf4fuBwL5edc2Q8L7WWiccRcmJ/9Pf3myF3FhReO6jQRhFrbWu3rmHNj9iHHMa1+tviZM+Z5RWq0v4gQhBVjHYRRLmbqMpdZimV2wGGnofh8OhNVMSnkx96FFoJz+lvyvDhJFUUuslxla0fT9q4QvbqbE1EFh8LBc8Y5ni9SY9/j0nA+JmVm4C5OurBKmprXnmjd4hzS8pwcl29s3fUWKHB51W5LhA4lIflsAyQ5QFR744abxUYHAa0OHEHnFdfy6Cyp8PaLq/tavUHG030WFr3M3u41Ihb4cVc7g2Ofc9r1dnZWSdwsJ2sxQLWk0Uoc/LvkBP5MKzneQUVltjOeebYo4jjRtvOE8A5Tg4DWkchjIQYSikEUeVoF0GU8yhYHovhwuOyDOhwUbQVukpea6dL7qUGuhXe3MTnvawE7rLc1q4P78VGEQVBGV5vR5sn/nQLPYaJ1FBYvFa4UY0J50Fw2/E1kNMKe6kR0H7CkJG1sybXvsrJW//1Pe5b3rlUxKf5J2U5OeykXhrLMFrHFog0embYQ+jVFcvseSetRGurfNZ4YIGJwtYTfHptLzenLCfmeA0ODro5eZbQRXFUxMmhMKt9sX5eGNabg9iLp/c1JqLrvYfX4ANRcfxUiRBEFaNdBFEuwVgNUZUqPcelLzUww+VuRqBYN14z/EVcKiis9uaVcRG/tdrKcVp5Nt7EZXFr3ay8J6wDJlN2dTU+OoVDLxYvtqP+Xz0aeC1+aKX3iALm9Vat6vXw2lI/6+joqNtmjtu/2RBpLgS3GXpHMPE516aYeM45N9w2PM709zk+FZKcjIt8Fmdu3KPxrNVq5lZx9b6hV9gSIV5ddSxYj6LghG9sP4vT+jwnUjs7O7PhOh3jmLjN4TsrnISCzBN8VrkwlFWG0/P8eZye5wnvBeZTTg61oocL+9ibp6pYICNCEFWMdhFERbufOKl2uMhx8c2NIYtWUPZJ91hXvJm93JYcl7dTBSdma0JHT0VK9ZMItz0aLmt3GU+WuIJlbutBkMyNu2LK8OXqquXBSRsnTxyPuC0cxQrnzrAR0n+tpHU2FrjzxjPuGjr2OPkgOSyL/o3igFfJ2MZWXaw8ILwvOWeJ6427itTw8Nk6LOqsMcOcXrmxbpgoi+MEw/HarpoUzgYZ2wHLnruPeRzhuUDIaXkpeAyjQMLPcI7gkA/mIGlbcYjSG0/oLULPjDWu9MXJ+JyjxUnOzMdC2WpfL9xo1VE9jrxAwXsay5LzUHkLxuEgBFHFaBdBVCbs4q3mW0ERlzUxtCqIvJWOZVi4vvj7MvweFz8wUsMm+D6WQcUPrsC57dlo4Wvx4sXmsf068bMAxsnK4y7i8zwrOhlqXdGwpZTqxIvCcsezh8iqI36mdeUt48yL7+e8bjrpe5y4usZQBB7e6BlwDq/pd1VMeGIT8ys4BMJ5Rjg2cVeffhfFIIfXOHkdjS3n1eQS5r02t3KX+F7SdtVyqXfBu4fZG4VjWMcAnvZttS/uXLOS5K1cKq+O1tygdef3UURiOfQewh1e+DsWQLrA4bA8/46FNO6W412r1iYCrmPZRxlxyE8FG3oHURiGIDrC0S6CqGhXEnoOqkCZm4XDBK3ylxFE+PLcy2X4y3JZE7DnpfG4rTwRy4Dh9a2wCm5xzXEX8eFEiStNbhPlUS7LQ4SJ01gXNJrelvbe3t6UUr2gQ0HCvDp56/s8FpCvRomj+LmWn9sYDaZy8Q4zz3hZnhKLE/sHwxH4PcuYY1+iV4D72OO0xrz1exR3WD5PKKqIUgGAO6BY2GnZmZNFOrYl5x1pmdFLYj1mJRe60ut7deTyYTIyL5h0UZLzIFleRRV6yMn3JY8zFHsohK1FhDV/sEfI8h6zZ623t9f0anI/aVk9L/lwEYKoYrSLIMrtVBoJZV5mBYE373CQq5v1womqWe7cBFb0YqFQlouNaO6Fho3P/iniLsun4RfsRx5LGKpAr4olxjgRWP+PopKNzcDAQEPiLU7cVp6FGvoyfHpN9AbobixrxcuhGW1nTnpmfsvIWzk4KR3adt7V1dXgtdC6sucNjZH1BPciThwLGGq27gFtcz4ywLq29XsMB1k7z7jcajwtPqtdPU4cm54XlMOIKDZwd5Y3LvDFW/2t+YvvXfaiWBsudD7VcvJCwxMo2g5aFg59oXfSEu/odeR7FD1+GEbD/+s9xYumKhCCqGKMBUGEk0tVKPt8sSq4BwcHSwkwKz+gWW6dGHjFZ+08YUPU7G4zFA3WE8BznDjZc5K0x12GT0NUOc6UUgOvtY2aQyn8EFMUF96J0UW8LJJUpGDYAPlYvHE/p5RcXt5Gz33OOWtcRzU81jk0KaU6I6xtqB4CL7GbRR0aReTk+0c5sa6Y44F9piFLNNr6GwzHohi3xiX2kRUC6us7lFeECeGcd2O1q3J6Y9YSCyggMTxqiRwcZ7jAtHZd8Xd416OOQSuEhW3K5cAw3OLFi805GMWbFyZlW6HvY7msQycHBgbMeRi9hyzi9P7RuoSH6AhHuwiiolBP1WcR5bj4NdzziKxQgcVjrY6brbfVjkUiQQ0tTxJFdUZDjsmvOZGAW8ctXpH68ISC3dYWn7czBQ2b5XpH4WaFKTD8YBlri1O/m+PVUCEbG+wXy1jje1xP/TzH671QDFp1tDi13Ck1PqQVv+sliuvzzHJ1zHFa3pqUUl34zdrJhmEpHGM5TuseZU+LJbrQA4EJ9CxKijYFMLe2F45RFSMcfsSX9bwuq390PLBoRnGFeUuWR1BFov5evYhYZr5vuDyY1K1lYnHHgqXZo074ujyemklbaAYhiCrGWBFEIlLpYGzmZkFjM9y6WV4gNBrWpNiMGON21FWkxcf5D16ychEXuuNxBekZQG1PzbGwPElsIHHixlCP8nnCRA0Sel009GDtkMOy6GTLhh4nxxxnrdb4pG08q8dqI7yexcchA+sRDZoEjUJejVVu7Flb6XlMceglV1f9nb7nPWwXhQgnLuNY8DwGHJrU+rKHx8ovwX60cqe4rvwePukey82eIqvddUHAZbTyn/QzFRgsaDAXj/sC+8/yqFqLF70+e/nQw8WeIlyUoFjjenvzA4s3FICcvoC7BrEc6IWyxjm3AfYjimvkx5BcCCIHK1eubGjUt73tbUOf79u3L33wgx9MfX196eijj04XXnhh2rp1a901Nm/enN7znvekiRMnpuOOOy792Z/9WXrttdeaKke7CKIyeTaq1qtAs1vhRVoXZJyr0cqrLLfeuLmQoCb5ls37KZPTw9v9+drKyWfxWBMm5sp4KzTm44lfjZK12q/Vau7KmPNnUvKfPo8rZZFfJGqyh4FDK7iS5bpbY4T5+Df6xHEU07y7K6X67d2Wx8TKpdHfskFVQ1lUV87rsIwUPwrC2maf4+Q+wDmC+x2TyvW6ntHWhzpr/2P7Wm2IwgpFkyWEUIhYvBYnJubzGTooyDwPsXdf6uf4O/TioODCdsSwLbc/jnFrXkchx/2M44Q9qLjTlfN+cve0thWKPCvx2uPF/lZPUlVoK0F0yimnpBdeeGHo9eKLLw59fsUVV6STTjoprV69Om3YsCH98i//cjrnnHOGPv/5z3+eTj311LRw4cK0adOmtGrVqjRt2rT0yU9+sqlyhCBqDWU8UiL1K/BWbwZe1edeuKrFSagsN7vQrXropITCg8MIbIhzXF79uI15m7qu5pibd+aU5bNWnTwBqhFEzxR7cHAS9QymXps51Vjo7/BkYvZM8WrYC/lxXax2Ze8Atx/Xl8Wid9id/taqY1FdrbwaK9+EOa3x6nHyYsNLtrbGpHp9tW24/io0mJOPIeCcGRZefE0WWtwmzImeD17I6L2p9bJ40cPhhbE5T4g9I8iJdeXyWGeZMae2l/eIjJyHR+vL18Ndqt5iF8Uqe+JQjPF4R3EbHiIHK1euTKeffrr52c6dO9P48ePTrbfeOvTeE088kUQk3X///SmllFatWpU6OzvrvEaDg4Np8uTJ6ZVXXnF59+/fn3bt2jX0eu6550o3aLPAQTHS8IwOTxRVocy5R1Xxl6kb77hBY8Hu4jJc1grIMnhsMHTSwet43LgS5KRM3WlkTUqWEbG4eSXaCl9Hxy+2quPq3uoTnWj5ffRqqVHnCdzjRPGS48V68ee5BE8RafAEsmHmkCO2V0qNCf+ccMxeB2u7PofWvLrqZ8qnCc9W+Vm4eJzIm+tHLTuLH89bwd5A7FO8Nrax5XnIzSF6HWzzgYGBBgGH3jAsKxr2nAfImx8wlGeFBj3RqaKjSPhZ8x+Gcfme4ZAYfo5hXGvxjB4cnj/Yq8hjXcuk7YELRQypV7kgV7SVIOrp6UknnHBCmjVrVvqDP/iDtHnz5pRSSqtXr04ikl566aW63/T396cvfOELKaWUrr322gZB9cwzzyQRSRs3bszyWgPw9S6IyniIcPIZLoq48EAwdKW2wl+mbiqI2GOAxkHd0bky5Dwa1uqcV0y8MsTJmMNW+LfFxyEy5dRVoP7LeSt4XRQLuHL2jI2Xh8UrVxUrnC+DXgA2zM1yYi5NjpdzhHJ8/Fvua01Sxjqwt4Y3CeDvrfOpND9FPRaedy5XVywzX9uaZ7CPLaGonNpnnDPl5Xd5OXrWWMB6YrvwyeJ4T5QJQ3t5MBwOssYS/iaXLI4vHgPWeLfairfyN+Pl5jFgLap4cYG/tcqjn3ntg140i4+9hshvzVXcFlV7h1JqI0G0atWq9M1vfjM99NBD6a677krz589P/f39affu3emWW24ZigUjzjrrrPTxj388pZTS5ZdfnhYtWlT3+d69e5OIpFWrVrm87eohYj4ciLx7oQqUeVQIThrD5S+7zd+68SxxUoTcZIV/Y8jEuuE9cVKWz+LE9iwSeR6/xYMJ2zxx8rkpLO48DA42bjO32s/jTKnx1N4i3jJjhbcK873KYzbHaz2mRF941AAfZMjbybmu3H9l+HTXF9ZJxZYlrhUeL3uW1NODxhA3HnCytooPT2gwL4t1a5eb2gaLU8vORl/ryl4lq1yW56a7u7vOO8SCQYWLlftXxgNmeYownyjHaYkcfY/PFPPqzHzeWW45ThX+Xl1GAm0jiBgvvfRSmjx5cvqnf/qnERVEjLGQQ4TJg1Wp9DI5RFbSYqv8RXzWDhrmLGvEUyofErRCQOy1UHj8ZTxgOMHiZK7/R2GU49F2KeLhVSYadp341Kixh4a5+Tpe+/FKWx/42iwvXqPocRLsPdETeDk06Yky7jvO82JO3dXH5eC6qgFhXja61tkw3OYaKmRO3RmU4+X8GPXq8LUs46jA9tWt8xiOwXuH285qT61jM5zogcMQGe+c04WNlYfDXh7N9fI4NWyIBxJ6m0MsEaFeGw77WoscrYcKIMwJ4kWGl/OlY4znPt6tiX2G3/EezDxS3qGU2lgQpfSL5LFrrrlmRENmjHYRREWCoUqF3owBR8PTCo/e+GVPxsZ/0WXdDFdKeY8Nnx7LfLijxeJmLs9j43Eyh/d/z7NR5CHS/7NwUtHliQUWLAoWPfo3b9nnJGvMPUBe9ibhyhaNu36GfCk1nguT4+Tt4CgUkVdfHIZT0cFzAXsx+Fwo7a8cl34X31MPURlOzOFiTyNel42nlpVDJvybIk4cn9b8pSKxjBcMx5cKGuTEcY8hfL6GtxEAc8b4nlDw/VKr1eq4sMwqmHjuwNwmLz+J28/qKxZunEZgiUkr6Rz7EseKtbDgnE0O9Y4E2lYQ7dmzJ/X29qa/+7u/G0qqvu2224Y+/5//+Z8k0phUvW3btqHvfPnLX06TJ09O+/fvL83bDoKojECpShCVjYVbp9m2ymNNitaLd6+wK93jwQlZDXkRl8WL4ogNTC50ZvVfd3d3tp11AtOJE1dlaFSZK8fHwoCNgq5OUaDig0/5cDsFjgVc8XMd2Vuj5cBn4lk7W9hrw94R5GNxbXHiRI6CRNs69+w09HKoQefvaFl55Y9eC+wr7GMrZKvlQT4ew/oer9zxSAT2ZmII1Wqfzs7OunwgvvdSahTf6lXR9sRcGctDxC/0fCxevLhhcWL1Ke6G6+rqqvNQed5SzMnRtrI8gjivWuIYd0X29dXv4LLOw9Ln+HkeOhw/3oJK25F3r+E8x/eRlVPFfWnNYVgm6+gQFvRVC6O2EURXX311+v73v5+effbZ9IMf/CAtXLgwTZs2LW3fvj2l9Itt9/39/emee+5JGzZsSPPnz0/z588f+r1uu1+0aFF68MEH01133ZWOO+64MbntvoyHoaqBWIarCm5czZX1ELGRKcPrrZC9p2frpOXx4m4aiwcnFPxOjs/iZF6dsNlD44XPLD7MN9DkYuvgwpQajW0tExZFo5PrRzzIzss5YXFl8aHRsg6s5AmbhRZ/Xzm8Ps6F6HQMo5dK+0jrqUcIYJkR3MfWKc5WmbGt9T7SvlAjiNdC0Yy8+OKdgvyZlpOT/vmp6zlerpM19rVOmJ+F4SkUkpxDhZ5jnGe83DMU3igaOCnc4mRvjHdWD/cf1gt/z0cm6HhH0cyc+Cozj6Lo51zQXF0tQeXNH1WhbQTRxRdfnE444YTU3d2d3vCGN6SLL744/e///u/Q53owY29vb+rp6Unve9/70gsvvFB3jR//+Mfp3HPPTRMnTkzTpk1LV1999Zg8mJHd0t5NVoUo0psi57Hp6empu6Ewht4sj7Uq817YDjpZFXFbk0tR/XhVyry6AsY2t4QJvlfkdbPi+syb0qEzS6xHlpThY+PLK20tP4eh9Pq4em+2/3C1zWEAbUuuL/JiWCDHodfkkCqvmvme0c/xdG8WjbmEVRQC6EXj8AOOV2w7rXOufpz8jnVCY8RjAD0gWjf2khS90KtmhYytccc79rgfrBe3N3vz2OgyL/cfetly48YSX/qexcmJ21rXMnwYfkbvJHpyuG1RCHEorqhN9Xo4dvhe5pA1zm1logZV7nJWtI0gOlLQDoIopeaetVQFirgwlKI3w0jWTXejoEsdjU+VXDw549ZfTsbMtTl6jcrycf6LJxytOhfxacKrZXiwrhYvTpjKr1weH69+MaSgv7dW/ixgeTL2JmdNruUVu9bZ41RwPa0cFDY+Vk4I7rzCUJPFix4MrXPOuOE1OIxqhQLVuFkGvszigOuJSf764mtbW8Oxnbl+7LnxNjxYnHhOEn4PF0vch1Z4C/uJBZne9+gxQU4M3VtiFr1nGDbFcKa1ew2PO2DxpZzWWMEjD7AMKdkPMUaPJvcDLprQE2rttqxaDKUUgqhytIsgKlqFV53pXxTr5xyU4RwKWcYDhvVUXl1lNcPdrBFA3pTqD24r8so14yHCyRz5EUXt3QqfxcshHeW1VpUs1KycD31Z+Tg4aTMvt7flIeJtx2z8LM7BwfqTua12xNU71qO/v78hJMSGjNsfE7i5rpZnEfk0b43HInNyvTEUiG1ghXyLvBl8GJ/WkYUIX5vzaRRYVs33weugACjixPd1TDIv8+l3uJ2tdmDhipzoJda/+fcen5VEL1Lv3bLqymFk7+Rt9lKpd9aaZ3NnimFZsI5WYvZIJFeHIKoY7SKImM+6CapEmWeZWcmaI8mnk3MVvDnBoJMjTsoaGuRD4qrgQ04rvOJ5T4bD19/fX5ccbOVOlOXFvvOEggoPTkjmBGkOg1rc1q4xvAaWxeJkkaQ8bODQM1BUP31pKJOTbdnAYSIr83onY1t1VE4MK/LOnxyv5RWw5harjlon9FhhX+GY0v5kD4rHx/dBWU7m5fwt78Vb1a0kdM7jwc9zXll+TwUVt6vF6fWpJZi0vtb72v5cnv7+/jo+HfO5pHgrLKr/r0UO0ZGNdhFEubwCL9F3OCiaQHCFPVzuMufm6AqEczSa5bbOH7EmD/YEcXiuDDca9zITsuX54m29Oe5m+NTwpGR7vSxe5MaQBU+wnjGwjDR6nTxeziHyvCWYX8PtigZEJ30rdMXtz8ZFBTkaavY0YP8gJ4uflOpX7DUj/Gg9Yw89XEWc3H4cUuOXfo78zKdjh8ch1xV3Kir43lMDjjkxWmYWSzlO7DPtW08IdXV11ZXDC1WyMGYvCSckl83FwvvW4sT7mcOu6unxBJiG9Ph9HQvMhx5SHidWcrolYFVAhYfodYB2EUQ5I45PX64KOS6Mp3tJh1XVTW9aa2cJT/xVcOFEjasj5E0pleJG4+5NXh6nwkqi9riL+HiixF1QZXiRG40LH8GAiducH5LjLKqv14acKO55WHA7NgOND4pfy6Nh7QrC+mN5c5wp5c9MUgPIoRb2LiAnejeZE8vlJf6qweVNE9b3WIxgXZELhRkbZPWK4D2gwoM9KMjJuVF4Pg/2qTVmsO46t6jo4aMFlA/bwMshZD7M78L30cPEbYKbCax2x+R4FrWY18deTd4ZZwlC6z7DnZo8Fq02qBohiCpGuwiiolW/3thVIRca0BuxyLhVVTeenHQCxgTrstxlPEQ8+ViehTLc6IUoCrUwp6IZ7iI+K+6Pk2kRr06oalBwV41eJ5cgy94Va1eK5VHRFau+OKeHx2aZbesM5MVzjayEXCsBFtuUDbnHyWO/VmtMXOdQjr7wfeXkcc2c7KGyktXRG8EvzCPCMKDnCeQxqm3MuS2cpI515JAq969+HzcEcJ/qOOH29e49ayemFdLHXZnMh6eEe32I30VOa2xY/erxWcITf8vlQcHK84b2OXtfNbyNwg49d1UhBFHFaBdBxHzWq0qlXhSis2644fCXEUU8eeLKuFnuskncnEjcCrc10RRx4kSj/Oi5yHGX4bPOfinDm1KjhyqX04PvW0ZF+SxenICViw1a0fEQ1rhCY845GSyYcft+GSGthom9LxYn9pdldDEhmOupuSzIyWM6x5nSIW8c7r4rMz5RCFjti7uuEBzKwoP9rP5UQcLeaKvPua46jvjohaJ7A/sB85Y8Lxnn3TCfNWa9ccOctVrNPDtJhSGHtXA8oVi2EtTxb8zX0+sWhf+YD71TVSIEUcVoF0FkrTr5JqlSnZcVDHoTD2d10Ez8nW/kVlYmRW2JEzKviprl9ibTMpzqCcOzeXKJzvpemQnYMmBleJUHV/9otHOCiD03KIYsXhajtVr9OSxFE7eVU8ScnMOEq240KlqGovsCPZlYDi+fCBNXWYgxHyf9Yv+U4Uyp/gnyWD++ptWW6i1AQcTJ+DiOVGBbfZfLY+I5Dc/ase4lbE/sU+67Iu+JthnnCHHbWnXAMuJ4YnFijdeBgYG6vkyp8TEkuTmJvTS5MapeXfwOe5y80Ji+2LOLnsPwEB3haBdBVDR5VImygsEKeTTLU9aAF4VaynJ5E5w3IbP3o4z4KstlTe7oii6TuG5xeRMan1ysL33gKYcomNfiKpqAeceP/r+/v79hdW0ZGw63cMjEaj+e7PEz5OSycyI7cnnGUcuKScHshcBQo+a9cLm1TGzorLZloZDjxNw3777WPCEriVzryDkrKrCwLjqO+Fwiq7+4rfHlbT3X8cB9pmMERQXn5aAHw5pvUORxPa0kbeTiHK+cUMU2x3sL2wjFDXpytZ/5fCEso9bF4sT7Ceuogkg5+QR0PAOJd7zxmKoaIYgqRrsIopzRwUS8KlBWMAx3NYCegTJ8PHG1wlVmZcp8zbaz5X3w+s1z/7MhL+LCSdHLWVBjJdL4VHqtKxvVMlxFYxPPEOLyeLyWN8UyiFYdWQhYnF475erGooXfx+Mg+HOsK37GCdAcFsqFpsty6vVyu+O47Xg8ptS4288T/OzpKuorK7yoKPKkYXtg21mni6t4sp43luO07l/2ZioP/831s/i0L/E7OschZ85jheJ48eLF2TZNqf5ZapwD5B0VwALWapsq81hTCkFUOdpFEOWMuBezbxVlPUS4SmiFv9UQTyvJfK1w5XaH4DW9nBDl8lb6lijp6+trmMzZ5Y8c3rZyiw+NHQqQ3t7ehm3cVhvjbhxrxc2HJGp99P+YkKweIq+NcSsvtiP+xuKzVsD4YE3LoGo+jk76VuiFwymW8bLCq3jmDPPiae9qsPR3/LBOz+gUcVoeNcurgB4ir02t66HXET2NnueHj81IqXE3lXU/4djEvBpMFfDubU64ZsHG3kjl1LKyuMBke/Yicv/yXOp5XXkXl5VAjvdAbpFVqzUmunObopjOeZe8nYNWu2gbVIkQRBWjXQRRGZGiK6UqUPYsG1yJtsqvN3jZPCLrfIyy3DoBFR0EaeWfaPmUq4gbBRN7I6y66mRihRg4edLiLuLzVn+W4VU+zQOxuNnw9vX1NTwSwGtnvZY3sSOv/h9Fnxoy5EODnNsezPcSJqeiCEIviBVi4y3bRVuSLS8OPzMO87i8cYrtXmYbNPN6IRCrL7RNPSPc0dFhJtR64pHbjj1S6AXRts2NTa6nJSI4dwnHTHd3d13OmrVw4p2SfK9heb0xjHz4G2+OYU7sd4UlPD1vFpfXO0bA6gftW5w78agD5qoSIYgqRrsIIuazDEhVHqIyfHgDsPeiVTSTfJxLLi4Dnqisl3dOSyuesTJ8en1rZwmvZIu4LT5r9S/yi1UgJytzO3NSNXOjSLKMF79wZxSencMTMq/e2ZB4k3mOs1Y7tHvH2lqP3inlRXHGbYqGzCoLjlPkZaGC/Wp58lh85JKDua+Ql8UbCgyv7Wq1Wp1Hk/OEdC7gsYkhWus4CMuAW32rRzZgfpDW0xImeChkkVeYvTJ4H6h3Fr/reWs5HMe/xbbUccN9iB5S9FDp4oLrioJSy+blJio35+tZnCjIea5F0Y6h2OHmlFoIQVQxxpIgqhJlH6VRFXczfPoazg1oiY4yL/aOtMrX3d3tCkDMM7AMRZn21mRMneAsA+zVz/Jk5OqMfac7ZtSgcM4BGjgUbRZvSvbDT9HIqJjTsFetVivFicKCedk7xSt03u7O4lPfw9W+xZtS/cGMVo6UbjdnYcVG2uLk9kNeS/igt0Q/zz3uJKXGbexo7Pn/KTXmQlqeMB03eM9gKAY5PW+xJziwzVTwYJjSm9c8TmxjFqneYy5y4UzmtMQx1o/zpbzwFi6ouE3w3uJyWaFxFKae96oqhCCqGCGIqucaCe4yPLjrarjnXpStGyY+62TWCrdXF+uFK0GchJsRRFYdrIlQy4LJuSmlOt6iOuM11VjzRK3lxjNvOFk2pfrTtlOyzzhBI4IeLMsbwDty8Lu4yucdXl5IQ7+rvNaKXH/LfWflglk7y3icWAdjYhvo4zWYU/sC/7V4uY9q4A3CfCNuB+XkgxZzOX7cnhpiwTFj5eRoSJE59VBYjzfnLdTxp2OQ70m9z1iYoJjiOlqeN+5PHXuedww5USDjbkAOe/E9yGXB+98Ls1pjHg+BzYnLkYhQpBSCqHK0uyAaqcGYM9joYsbJbqT40GjrpNFqqEyR4+IJCnlT8pOpq+DjycnKbyjDW4aHz6HBXB0WXzlu3r3UDCfW1eK1uNHQ5Dx97IVCwcG8KSWXm+9zNNhewjKXw+NkXjZkuArn+lj1sji9/rMMshr4XB/yAZ1Wn3p9x+ND65y737VdLU7uU+TkEB3uZiwTutOwo16fQ8lcVxaNWjYrVMjX8zitpG3l5LbE4wqKwoTWb7BtLW+Ul0SN4biqEYKoYrS7INJBeTgFkXJWlTtUho+9NIdLEKFHw8oZqJpPJx5Oam6Wu4jDMuYYqrN4PG5vVWxtj8bJXY29eiPK8np8LI40lITtankicqKB2zKlVOedsLao8+q9v79/aIXN4triZQOJ5WfBVIYTV/c5safeGhRXeA4NtiuWm/OIMAeLeVmgcMhRQ3TcrpzMzKEp9BJ5ogdDjlzmMt4a/I6WE+vK/eLtBsw9RgQT5vE7OGa9vChMaGY+zvfiOqZUL+iw/6z2QY9T1bucESGIKsZYEEQ4qVcFazXAL2tFOJJ81gTWKndZLubFCbwZ7qLr5j7zttY3w2c9Nd0LJ7Dx0InO4+adV9YZOmpE0VhZLv8yvB4fu/X7+/sbOC0PC+fn5ARRDcJJ2jeWEUSx0dXVZfKiwURu6x5D4zUcTvYoY3upt4A9Dzw+tV2x7EW8Wk7m88Rpq5y5M5C0fTkZWIVNV1dXw8nbOU4cm7n5Qscl59t4YUu8vywx5oXKsD2RD+vNCyEcg9iGLFS5nuzB0xzFqhGCqGK0iyAq2gZf5YFY1ip0JLitOHnZlyZeluVmY5cTYNZzvtAo8Q6kIq4y9VNOazsrem68XVfsUWE+vmZn56En0Vv1RSOjBoPzjBT6GYdOrBUzJiRbY7qr69Dzu7SevLuODQwKMK43c+rvrfZg4aXfxcR0HoNsKNCTyLxWvyr0OuhJ8jwOvFq3OHVXl7dzTMcMtoUX1vG8J9gfeMAktxuOQfRa4eeY5+aFfDhvx0s2t+Yu9D5a73shJr7XkBPHiDXmrZAthtpywpHnE2w3FZbM5bU314/bR/OwOAeLPUQ6tqx8RB3PVYuiEEQVo10EUdGW9CqTqnOrHr2BrJVrqzyWi9x69ff3uyvKZrhSKvesNvViKC8a3FydmUv/LiMydXLCiYjPwEFuy2tj8VkCECdx3RGDB7GhkcFJj6GTLSenWkncuKNHvRHMi4KI83pwFcuH2eH3c5wY5tB2Qe8f5xQhH3uIrPwXvQZvYVYuTI5VWJ4A7RsOs1nGmzn1+9jGGFpCcYDhEc+rYs0/bNQxjI5tzFv0sVzWkQtWCJDnOky+5xA6C23ero7jUts0Nx/wnIGeIw7B4UKDhTCPMS9Xiz1EGD7X97T+KCSxPb0xgzk/Hi9z4jjRvlVhyIupKu1QSiGIKke7CKIiDxG7d4eDMh4i3ibbKk8zHiLNofBcvmW5UmoMuxTxptS4I6gsF7anJxasF662PG7PQ2QlTJcJS2pdLV7tdwZOtvp/NVT421wCNPJa7n2tMxoD9CahYcTrlvGscl954kANAgtTbFf11mD/Wp4XayVteTfQgKFB5O9YnJa44nGiBs4qI2/H5rYYHBxsCK9ZJx7zmUjYZ97ZRDyO9Zp9fX0NnjoUZnxfs/BDzxi2lfahl5+F9dfwb0qHBLr1qBBvvOAYz9331kGPyMkhPvQU8kIC+9rLJbLEJIpn7De+h5ivKoQgqhjtIoi81YS+DrcgqoK7lZCZlajbLFdKjYLIcjkzD+/+KcuFfHqN7u5u85wS5tRredwWl8eXSwDlsWzxspFUcDImr1otw2c9aBZ5c2Msx6eTOnq5eIK32hjDkczNSalq/KzEWk+UebzYd7nxZ4WGijitewq9ADkxpG2OgpEP6OQyY3/zmMG+s8KreC9yaAzryQaby8ZhJC/EagleDA3h0Qx8tAKKcy2bJeo4TIXtxn2jnhbNlfIEKHJaYh89nxzaQ3GGLzw92+LEfrPy5rDtImR2hKNdBJEX47YMxnBhGaSR4MaVWxkBZj37q6yHiFeJ1sTglUF5rcm2DJeXo+DF4tWIoDjwuPVzNrC5HAxObOUdO3jdonwMLKOWmcWb1lONhnqDcrz8wudR5fjUgKFhRQ68vpU8arUbh74846d8zGnVy/JclPHgobchx+mJSjV86GXD8ejdA2qAOY8My4yeGnwfQ1boQbIEN97jtdqhBG8Vnyyq+Z6zeLme3gvLZj2QVccCb43n7+P9aN3T/D572SwBZnl+OKTrhYxxPsjlJ+KY4UeMcEK4NVbLLk6bQQiiitEugsgSA2wwLE9BKyjjjcIbz8q/KMtTq9UK66Y3rH4fQy+84vX4mcvb5ZTj5VW3x81cuqqytjBzH/L5JmW4dSJslk/bwXPpIy+GFVBUYc6TthVen0MeyomTtMXLuUV4jdwqmUOq6Ang3BSrDQcHB+vGI+cZpdQYyrAEEudwoHDjMAYfgojJq57hYcOHYwfzq6xcO/Qe6vc0Z81KTNcyW3k+6HXR/sDy8ZjVcalixTu3SseINfdgGXAccLlRsHMeFfeZCh1v5yPWSdvXE0FaT+VlockLARavVkiYPVp4D+L8i/2J9xver7lFDt9ruBiwFiRaPxRtVSIEUcVoF0FU5EGpcgt8SsXb0jEMgPkKrfCXDc9ZKzMULGX4mwkFotFQNMONYQFtnyIvwPjx4xvc3TlufB/LXJZP+8+qK/OiAfLakcuC/GgI0PXu8Vp103HAxgPvQz45mR+gijuxrEmcPU5WUnauPdlDp3VTIc9byHGcpFTvDbZW/Sk1ijIVipijht/DNkY+zg/ROrMBZ7HBHgX8LdaV24X5arXG3VaeJwXPILPED44F7zwfLZ+XK8NtjYYef2MtNHRzQhFfR0dHnWeGOTEcaoVb2TOq3jaeg1g84li2rpeSnS6B7c5ispVT+5tBCKKK0S6CqOjZW1V6iFJqXjhgeKjquvGkrwZOV9a4MiviV65m6odeCRUrOrHkuNEAonjE6xbxpnQoAZPDQOxFwgd44q4X69re9mRMGOU64+pQ+wC9UDqxWqtRNtg4iVu8uLru6empqxsn1fM9gAmyzJlS/Y5NKx8Ld87gIXhYT/2cx66KDmtnnjdf8LPgLMHCdeQEas6X0rpyG/NY4rwoFU7ofeBcGMxnYfGk9wCPKxWfWh70OGD90fhaCc4Ky1vF3ib0vuD8xJ4Q7UcM6WLOmN5n2A7YXpaHm+dD7AfryAkMCeP3+/r6GsqK9yG/h3MQhsnYm6peK8uzw+2ofWIJYH4ETtUIQVQx2kUQHc5t9yk1J4iGe/4Ex+iLuPCmbvZm5ByGIj6L15rwclyYq9LsQ2x58sZrMTdOWFo+y2XPwhJfntdADYP1GbcFemBwwk+p3nvDO3M8Xj7sD42px+dx9vT0NPCmlEwjye3NYRAWC7hTjt/nlblyWvXlexq9PHydIk7ePMBGDcMq2M94hhILIh53KA44X4zrgy/lwna3cq60/5EXjzBQPsv7weFQvrb10jryfWZdn8cA3ie5cLfVD1g//W3ZXEf00HiLN2t8W3bD8355mwOwvFULoxBEFaNdBFGZbfdVDsayXhvdndXq4YxaNy9fwpsI9LyPZg5nVC7MJShTR1yx806UHDfvdsqFmrw+xTLisf04wSs4tybHZ+2yYU5O3EW3uRpbzBuxwhxsnLzy4O4kFHPYflpmzVtiPgwV4n1pjSvemaYGSscGGgGus5cPonX0OLGuKIT02tq/+v/Fixeb9z0brCJOFJDsubLOKLLCcZ4R9foUx46+0MOGYwYXCeiNxevxGMN7En+LnlL2xKjxtnLArPmOd2hZggK9btp/Wk700CCX1oH7i9uFvZ/8XSt/x+oP3QxgLcbYQ8rtznlLKvBwDsJcsqoX5iGIKsZYEUR4ww8XOaPGEwlOcq3wNOs1QZc9emDKclmrnBwX5wHpxJPjZi7MYyl6sfFgbwiuLNFjoxOoftfbvVamrriKx4nW8mZ4uWSWsWJvBYoqFn4oNK3cBYtPJ37k4PsGRRxO4igmWex6bWmd9aNlYEOi4UNPcKLoxHCV5xnmfCzm9AQrJlRbf/MY8+rNSdsiUldHFDpW4rCVg2f1YVGb4/2iCyQUJdaZZZaXQzlZTHgePAzbozcIQ9XYtlh+bWcUTCzwOFSmCwFsXytPzWo7DgHi/zEUbtXTCq/ib7j/QhAd4WgXQVQU2uGJbzgomhD5hsFVfDP8zfDopIC7ZvhclBy/cnntyO9z/gvv1rHOZGHR4HHp5MYiCXds8aSqEw2HALReaBA5RCZyaNuyle+AZwJ5O8CUB8vHkyvXUb0d+B5O4Giw2Kh3dnYOtasnsvR3+r5e09syrScHcyiCBTb+NqXUIDS0zHg9PppBv6MJ1JZws3Y1WR5BLD/2PRtc3gLPXsnOzs4GoYbcKJrUCKIHifud7x/Mn/IO77O8Teyt80JN/Bv2yPD9ZnFhGax8KO9snxrklum9hJ97XjKr/DqHaPvjmEJBZC0UPS+XjlX0tmvIjPucvU+YRuB5PMt4Ai2v9XARgqhitIsgyq341e2JxnE4KOsh4tyhZvl1Emrmwa4Wbxn+XEweDVgrvMyvEygKG2syKeJUgaTXzLUhhxH42rwzxWsHDlmgELNWhDlvFItDnIS7u7vN3BT0jijwGix48Bra717SdXd3tynCvYRRDjFpmdg7yO3K18I65Dg7OzvrBCsnz+K4tjhRhHh1Ym8Btg3/hvmsbf3sqeL2x88sEWX1n8WJ3jXcEKD/5uYRFT6WB8Sro0jjIz+se8QLPatAt0Q2igz0snHIjMtriRksK/cRtj1eA+9L5cTfaX0wf87zqqPXqWoxlFIIosrRLoIoJ1I0sbLKxLYyIRd+jEOr/LnckjK8zfDrd9iNXUaUebweP/7Nu8s44dWbyDGfpAjotWKj5B3WZ71wBW7xcj1Z2OCuNAwLcBtz/T1e5kNjiIbJ8pyw8bDyR7wckJRSg8jAduZcIGs3j84N1jZvK1yGddO6Y24Pi1LlZG+CxYlGldtehQF7INkgslfFSta3xpQlkjA/KxeezXFq2b1dkzrOarX6ZHjOSbJEAo4D9qxqOXObXSzBWKaOCp4zrPeRC8cE5m7p2EHxxWFxz8Om1/TmKhS6w12IWwhBVDHaRRCVOfukSpTJ68nteGoGOpk1s+OrVV41ZvrA1tyEbfGmVF74oUDR/+PEWpS4zjtTiniL+MokknurduS2jCYabfRceOOWvWY5bwHmonA92birccQ+4z5ko4xCEQ2Fer8sgcarbl7p873J+SDW6h/rlnsgKXoQvHHrGWt+tIZliDFsxnllGDpmgY2HQ/I4trwl7J3RXCuvXT1OL2SloS0UOtx+Vr4etpGW0Rq/KLwx5MV5cVauGr5Xq9Uf4qpAPhX36Anjh7haws7KR2OvEIcSrX7D8YcLHaxThMxeB2gXQVRksKtW52UEAoY9hsNfVghpErc1YTXL1YwAQ16ccIq4OS+nViu3zd9b4RXVuYivq6urwRCjocBJkAUPcrOASMkOSaLh58kWhRqu2i3vhHWfeSFQDDVwmM5qX1w953I+UBDydzjkYCVyMzcvOLx2tMrESbC4M445VfzjWMa+4fwZq0055KQLEstDZI1nzJlSTw3m33miuQwniyztU/S6sci0xBnOB3xcRkr2Dj71oDAHe/TwpHO+/7QN2OvJ4x7bV9tzcPBQ4rqKP8/b4/Vlbh7EsWf1oZXg7YX2W0UIoorRLoKoKLxStTIvEzLTG2C4HqKyXDqh8yTZClczITo2MmXrzJNJGQ6eoDxjVMRnCR9+Krs12aIhwlWnZ5R0AvQmcDQ8VtjI8rQwL5ZfYQktNSZYTzYOLC61Xp4Y0DrjhI/X49CnerE4dMTXxmugB4rrzDkqVt96nNqOvBOMPVDMyWMDc+FE6k/a9jxR6F1CocGC1fs99wOGq73fWH3b13dot1Yul4jfU48Mclpl5PFo3bt4TpMVqsT7AkPb6tVhMYbi2apHLr3CCt1jWVWsWuFs7z5HcR6C6AhHuwiiXMgM3alVCaMy2/xx++Vw+HUSy8Xj+eb08g7KhrHwROCyL10RWnW1+Dm0U7Z+ysWGPOeWxjwYdGmrW53rauX0aJ9y6MpyifMuuzLjhUMibDQt3lqt/lwZhX63p6fHTbK2OHGyt7wC6ClCLwNO+BoWtMYPhnM5/wh5WWSg2OQQCvNZok37A0/ZZuNoheq0ndErwveG9fwrHnfc5lg/9F6h8dS/eezwjja9DnJyiKe7u7tBDHkLA13QaNuPHz/ezEFC4+55Bvl3ysnCA//P3l8W2Hy/YftgnponCi3Rgp4zngfQU4oeL66rdZ/jfBMhs9cB2kUQlfUwVBU6syYSflmPNWiFv2zd8OZkr4X+XcSPqy/PqOXqi9dAb43Fj+/pxOlN0vzS71qPzbA8VNiG6tLWMlvt6z1QVw0Y584wN4YN0QvBHjyerL36erwpNZ74rSJHv8cegSJODE9of2AYB/tXx4p+3/Pk4BjRzzi0w54kNVB477CxVyODbWB5iCzjyCJT29iqv5ewbdURnwFntYMXklERrv/ygsbaIYV9luPEOQhfejaR5gxiYjOKXM/DWVRPbwxgjpK+eI7Ua7LnNtffvLuO6485fbjYwH61BDW3uyecLA8TzgVVIwRRxWgXQdRMkvNwkXO5WpOj3kDNeoj0Jm32cRZ8c+JE7vEjV7OeGvw/r850EuCkY+TiVSR7LcpM7JioyWJEBReKCSsEhrkk1qTIK139bS4BFb1R+j56j3gbOU/omp/FvCgC0UPEhknFjH6OK1huC/SwWLkn2g7WM+iQj5PI2UPl5TdZnhQuq5cvhH+ztwITga2dfOgNwXuWvUDozbTuS9yNiWEbKxmXPR9e/a37RcWi5bHhpGSug9XuPN5QhOmYRoHK94HeXznvE5eVc+/wXtFxg95I7BsrfOd5ePh7KDJRlCIn11HvKz4xnO95HG9Yxqqfo4kIQVQx2kUQFSXjont/uMh5bKwbknMSmuUpk2iMoQAsC4ZtcqKoGS6cKKxQEE6QFjdzWStJrxz9/f0Nkz5fC93T6LnJ8XHuRE/PoQemqpBmMaG/Y48B7rDhSRp5WPjhZIweAotXy4XveWIvl6vlcWIYTOvGIqmzs9O8HudLsHHgUB/vdsJrsXfLEgHYvirA+Vp6L+h9giHAlOyD/CxRjjspsWzsUfQEEY4N9sJa47JWa9w5pnW0OPG7GH7SvzGkiXXiNtQ+4pCllWxt9QMKdivEZNULhQT2jxXORqGPfcy5bpbnxhKOXpmwvbF+uhjQ9uQNG7hoxnBm1QhBVDHaRRAVnZMznJAVoygfRFeyONm1sutLRUUu2Zd50Q3tuaCtMjCXroiLBBKvrNBT43EzF3qVypx3hCt1XlFyna1tsRYfb3PnLdJoTLQO6PHKiR4Mm+J3WTxbBg7rx54uy1OgZUJRiB4gPsqAObF/OESnRpKf/G6F7LC+1nZy7k9M9uYdQWh01ZireGMRoQKc+84axyg41fOFYwXbH70znpcFXxo+zolva1cUehtRnGJ99NrefWGFYrk9OAeMxwz2EYcSeV61xCzegzwG2fOFZWZvjde+ReKF2xFFIApHXgxY3ngdjywi+Z7DeYE90iOFEEQVo10EUdEExe7S4QBdrRYXPscHJ7FmPUTKgxNmrp56c7O7uoyHyOIq064eb8475XHp98p4qdD4sgjDvkYunPCL+Do77QdaYh3QoFhb89HIWW1q5SHg2ME+5LbD9kMjZ41xFLnWfcHPnWKDiiEnFWFWXg8aOs8bp3kneA0+/0m9MNZWbc6Hs9okpfq5Bz1n7D1LqfFkbcxn4/7D9tY2tQy3XotDd5bgQG8Sj1ErPKfX9pLWMUyJzxKzPCI5XhZs3r2o11dOrGdKyayrAsUoj3UvdI/hNVz4Ye4W82L/DQ4ONgifMmkCOs9ZSd7M2coCuBWEIKoY7SKIcqsJngCq4ipjuNEwtMqDk2jZx3hwiKgZrpT8c2wsg8q8+DuLm7mQjw2c157WFl2L2+Iqw2ddWxOV+TNdEfIEy0aNcxeKcmi0bB4vJoOysUaDhG3AodWiE5w90a9tbeWCsBDF3+nOI24/7AMWZl1dXXUiiMOxKdXPNRiu8DhxTGgbWI/nQO8KtrM1xoo4OzoOnaasn3mJ6Fo2NrB67ZSSe3ApJ/YimJeFB86R6NVBwWO9sJ8tThXeLNot8c19wDzWjjcuOy4esY0VyOt51vAewQWQNYaQUxdTPEZHAiGIHNx4442pVqulCRMmpLPPPjutW7eu1O/aRRAVhbGqSqhOyU6UtF542nMrggjdsM3k9vBDUMtws8u3jGfIm6yKBBFzoQG1hA4bFXav804gTni2PDX6ndxJvjx+i3h11cp9zl6qMgmgeM8wL+4g47ChldiKRohXtzzBW5zqocCwUu4QP/TGYR01uZTHshUW0mvreMA2Zs8Fv4d18jg9D4bnfeCkX9wQwG2oXgPLwCrY+5dS/RyGHs6+vj7zaAUrWdsbRzr2kRfFHoeE0Yti5XgV7UDFBYC2r+WdQg72MvI8pGPRWzDh/M7fQW8YetxQLFmLI+/cIWxD/S2LLP0c26JqhCAy8PWvfz11d3enr3zlK+mxxx5Ll19+eZo6dWratm1b4W/bRRAVeRWqHJC8ArWMtrX1vRWe3ARg3Zy4umrmZmyWiw0fT345buZqRoD19vaaHgKP2/Kg1CgfoMxLV/xleFkMeiGVojorj8Vr9ZfW0wulWKt8LpvFabWhtRUZ87H0M8urwPXGgxM57wL7DP/W+4zL4OW6WJwozDkMiFwqFlgQ4D3AfCgWeccSjgmcm7BuOH+goEOvoOWdtYQ27j7U7+D3rDLg2MotxtALw99jEYK5Zzk+nMcsUektKDB8xWHUsnyWV8+rn77POx1RwOMcNxIIQWTg7LPPTsuXLx/6+8CBA2nmzJnp+uuvL/ztWBBERQ8dbRY4+L2X5R5ulcdzy1v11NVPs+5az6gXvdhbwAKpDFdRmIxf1krS48YJEA17UejR+hyvjdfixG0Wg563gDmshE5csSMve9S4bDlDwtf3PDaWCELvCXulNG8MQzlstD2vCgoINCAsBjmcp94afc8yWh4nr+I57wvFA9/X1s4nbkPtC0soWPco9hsmPrOXxLpXUNRYn6MXke85Fe4c2ioSAxze4jbgDQi8UNAyaB2L+LAu+nsvbI7jmvm0Hcry8SYO7n/93CqD1e5VIgQR4ZVXXkldXV3p9ttvr3v/kksuSb/927/d8P39+/enXbt2Db2ee+650g3aLHBQjTRyXhtNQqySq4wowol9ODy5ic6rb7PczJVLahwuL3N5fEWirFY7tNPE47a4vLbU/JqiUEBK9ULLEnhWna0ty8rp1ZXrhVy59vb40EBbRzVwnbQ+yIWfYRtrm3LYjpNtc8myaGi5nfFvq6zKV6vV6o5MKOK0VvFcf/w+l0EXBdrGuEDwxlJuvFqhF3zpONM66inUanw94271K47X3P2u17YOjrTSFTRUiXXg+4M/t9pIPX66CxS9L7xDEsUijkcVRNY9a71QIGGitud95WgA3wfWPVMVQhARnn/++SQi6b/+67/q3v/Yxz6Wzj777Ibvr1y50hwEr3dBlJJ/OONIJbZ5fDxhVAVrRaQv3RqLK7LhcmMIw+LlrcjD5eWQiWV42BNk5SOV5arRSt2boDkPB3/P3pQqOa2VZTO8Fl9KviGy2rUZXs9blzN82HdWH3rl8Lw5ZYyt9fsiXiuEiNewjC1ya/5Lrq7Ijf3vjYUiA8+cRWPG2tXncVrGHtu3zL1pjRfL04vX9+pq1a/MGPbalzm5HMiZu3azc0SzCEFEaFYQHU4Pka5Ae3t7K7+2Bz5Mb6SB4Rfe9jmSnLkdFO3EeTjbFicy5a063DoWOdlAWAnCr3dOzyCO5Fk0zKmGvZWQebOcbOxHup6WWB/perIwG+l6toJmBFFHSilJm+PVV1+Vnp4eue222+SCCy4Yen/ZsmWyc+dO+fa3v539/e7du2XKlCmya9cumTx58giXNhAIBAKBQBVoxn53HqYyjSq6u7vl7W9/u6xevXrovYMHD8rq1atl/vz5o1iyQCAQCAQCRwLGjXYBDhc++tGPyrJly2RgYEDOPvts+du//VvZu3evXHrppaNdtEAgEAgEAqOMMSOILr74YnnxxRfluuuuk61bt8oZZ5whd911l0yfPn20ixYIBAKBQGCUMSZyiIaLyCEKBAKBQOD1h8ghCgQCgUAgEGgCIYgCgUAgEAiMeYQgCgQCgUAgMOYRgigQCAQCgcCYRwiiQCAQCAQCYx4hiAKBQCAQCIx5hCAKBAKBQCAw5hGCKBAIBAKBwJhHCKJAIBAIBAJjHmPm0R3DgR7mvXv37lEuSSAQCAQCgbJQu13moRwhiEpgz549IiJy0kknjXJJAoFAIBAINIs9e/bIlClTst+JZ5mVwMGDB+UnP/mJHHPMMdLR0THaxWlr7N69W0466SR57rnn4rlxo4Bo/9FFtP/oItp/9DBSbZ9Skj179sjMmTOlszOfJRQeohLo7OyUE088cbSLMaYwefLkmJBGEdH+o4to/9FFtP/oYSTavsgzpIik6kAgEAgEAmMeIYgCgUAgEAiMeYQgChxRmDBhgqxcuVImTJgw2kUZk4j2H11E+48uov1HD0dC20dSdSAQCAQCgTGP8BAFAoFAIBAY8whBFAgEAoFAYMwjBFEgEAgEAoExjxBEgUAgEAgExjxCEAVGBddff72cddZZcswxx8jxxx8vF1xwgTz55JN139m/f78sX75cjj32WJk0aZL8zu/8jmzbtm2USty++NznPicdHR2yYsWKofei7UcWzz//vLz//e+XY489ViZOnChz586VDRs2DH2eUpLrrrtOTjjhBJk4caIsXLhQnn766VEscfvgwIEDcu2118qsWbNk4sSJ8uY3v1n+8i//su5ZV9H+1eHee++V888/X2bOnCkdHR3y7//+73Wfl2nrHTt2yJIlS2Ty5MkydepU+eM//mP52c9+VnlZQxAFRgVr166V5cuXy3//93/L3XffLa+99posWrRI9u7dO/Sdq666Sr773e/KrbfeKmvXrpWf/OQncuGFF45iqdsP69evly9/+cty2mmn1b0fbT9yeOmll2TBggUyfvx4ufPOO+Xxxx+Xv/7rv5be3t6h73z+85+XL37xi3LTTTfJunXr5Oijj5bf/M3flP37949iydsDN9xwgwwODsqNN94oTzzxhNxwww3y+c9/Xr70pS8NfSfavzrs3btXTj/9dPn7v/978/Mybb1kyRJ57LHH5O6775Y77rhD7r33XvmTP/mT6gubAoEjANu3b08iktauXZtSSmnnzp1p/Pjx6dZbbx36zhNPPJFEJN1///2jVcy2wp49e9Ls2bPT3XffnX7t134tXXnllSmlaPuRxic+8Yn0K7/yK+7nBw8eTDNmzEh/9Vd/NfTezp0704QJE9LXvva1w1HEtsZ5552X/uiP/qjuvQsvvDAtWbIkpRTtP5IQkXT77bcP/V2mrR9//PEkImn9+vVD37nzzjtTR0dHev755ystX3iIAkcEdu3aJSIifX19IiLywAMPyGuvvSYLFy4c+s6cOXOkv79f7r///lEpY7th+fLlct5559W1sUi0/UjjO9/5jgwMDMhFF10kxx9/vMybN09uvvnmoc+fffZZ2bp1a137T5kyRd7xjndE+1eAc845R1avXi1PPfWUiIg89NBDct9998m5554rItH+hxNl2vr++++XqVOnysDAwNB3Fi5cKJ2dnbJu3bpKyxMPdw2MOg4ePCgrVqyQBQsWyKmnnioiIlu3bpXu7m6ZOnVq3XenT58uW7duHYVSthe+/vWvy8aNG2X9+vUNn0XbjyyeeeYZGRwclI9+9KPyqU99StavXy8f+chHpLu7W5YtWzbUxtOnT6/7XbR/Nbjmmmtk9+7dMmfOHOnq6pIDBw7IZz7zGVmyZImISLT/YUSZtt66dascf/zxdZ+PGzdO+vr6Ku+PEESBUcfy5cvl0Ucflfvuu2+0izIm8Nxzz8mVV14pd999txx11FGjXZwxh4MHD8rAwIB89rOfFRGRefPmyaOPPio33XSTLFu2bJRL1/745je/Kbfccot89atflVNOOUUefPBBWbFihcycOTPaf4wjQmaBUcWHPvQhueOOO2TNmjVy4oknDr0/Y8YMefXVV2Xnzp1139+2bZvMmDHjMJeyvfDAAw/I9u3b5cwzz5Rx48bJuHHjZO3atfLFL35Rxo0bJ9OnT4+2H0GccMIJ8ku/9Et175188smyZcsWEZGhNuZdfdH+1eBjH/uYXHPNNfL7v//7MnfuXFm6dKlcddVVcv3114tItP/hRJm2njFjhmzfvr3u85///OeyY8eOyvsjBFFgVJBSkg996ENy++23yz333COzZs2q+/ztb3+7jB8/XlavXj303pNPPilbtmyR+fPnH+7ithXe9a53ySOPPCIPPvjg0GtgYECWLFky9P9o+5HDggULGo6YeOqpp6RWq4mIyKxZs2TGjBl17b97925Zt25dtH8FePnll6Wzs970dXV1ycGDB0Uk2v9wokxbz58/X3bu3CkPPPDA0HfuueceOXjwoLzjHe+otkCVpmgHAiXxgQ98IE2ZMiV9//vfTy+88MLQ6+WXXx76zhVXXJH6+/vTPffckzZs2JDmz5+f5s+fP4qlbl/gLrOUou1HEj/84Q/TuHHj0mc+85n09NNPp1tuuSX19PSkf/u3fxv6zuc+97k0derU9O1vfzs9/PDD6b3vfW+aNWtW2rdv3yiWvD2wbNmy9IY3vCHdcccd6dlnn03f+ta30rRp09LHP/7xoe9E+1eHPXv2pE2bNqVNmzYlEUlf+MIX0qZNm9LmzZtTSuXa+t3vfneaN29eWrduXbrvvvvS7Nmz0+LFiysvawiiwKhARMzXP//zPw99Z9++femDH/xg6u3tTT09Pel973tfeuGFF0av0G0MFkTR9iOL7373u+nUU09NEyZMSHPmzEn/+I//WPf5wYMH07XXXpumT5+eJkyYkN71rnelJ598cpRK217YvXt3uvLKK1N/f3866qij0pve9Kb053/+5+mVV14Z+k60f3VYs2aNOdcvW7YspVSurX/605+mxYsXp0mTJqXJkyenSy+9NO3Zs6fysnakBMdzBgKBQCAQCIxBRA5RIBAIBAKBMY8QRIFAIBAIBMY8QhAFAoFAIBAY8whBFAgEAoFAYMwjBFEgEAgEAoExjxBEgUAgEAgExjxCEAUCgUAgEBjzCEEUCAQCgUBgzCMEUSAQOGLxh3/4h3LBBReMGv/SpUuHnko/Enj88cflxBNPlL17944YRyAQKIc4qToQCIwKOjo6sp+vXLlSrrrqKkkpydSpUw9PoQAPPfSQvPOd75TNmzfLpEmTRoznd3/3d+X000+Xa6+9dsQ4AoFAMUIQBQKBUcHWrVuH/v+Nb3xDrrvuurqnwE+aNGlEhUgRLrvsMhk3bpzcdNNNI8rzH//xH3L55ZfLli1bZNy4cSPKFQgEfETILBAIjApmzJgx9JoyZYp0dHTUvTdp0qSGkNmv//qvy4c//GFZsWKF9Pb2yvTp0+Xmm2+WvXv3yqWXXirHHHOMvOUtb5E777yzjuvRRx+Vc889VyZNmiTTp0+XpUuXyv/93/+5ZTtw4IDcdtttcv7559e9/8Y3vlE+/elPyyWXXCKTJk2SWq0m3/nOd+TFF1+U9773vTJp0iQ57bTTZMOGDUO/2bx5s5x//vnS29srRx99tJxyyimyatWqoc9/4zd+Q3bs2CFr164dZosGAoHhIARRIBB4XeFf/uVfZNq0afLDH/5QPvzhD8sHPvABueiii+Scc86RjRs3yqJFi2Tp0qXy8ssvi4jIzp075Z3vfKfMmzdPNmzYIHfddZds27ZNfu/3fs/lePjhh2XXrl0yMDDQ8Nnf/M3fyIIFC2TTpk1y3nnnydKlS+WSSy6R97///bJx40Z585vfLJdccomo83358uXyyiuvyL333iuPPPKI3HDDDXWer+7ubjnjjDPkP//zPytuqUAg0AxCEAUCgdcVTj/9dPmLv/gLmT17tnzyk5+Uo446SqZNmyaXX365zJ49W6677jr56U9/Kg8//LCIiNx4440yb948+exnPytz5syRefPmyVe+8hVZs2aNPPXUUybH5s2bpaurS44//viGz97znvfIn/7pnw5x7d69W8466yy56KKL5K1vfat84hOfkCeeeEK2bdsmIiJbtmyRBQsWyNy5c+VNb3qT/NZv/Zb86q/+at01Z86cKZs3b664pQKBQDMIQRQIBF5XOO2004b+39XVJccee6zMnTt36L3p06eLiMj27dtF5BfJ0WvWrBnKSZo0aZLMmTNHRER+9KMfmRz79u2TCRMmmInfyK9cOf6PfOQj8ulPf1oWLFggK1euHBJqiIkTJw55tAKBwOggBFEgEHhdYfz48XV/d3R01L2nIubgwYMiIvKzn/1Mzj//fHnwwQfrXk8//XSDp0Yxbdo0efnll+XVV1/N8itXjv+yyy6TZ555RpYuXSqPPPKIDAwMyJe+9KW6a+7YsUOOO+64cg0QCARGBCGIAoFAW+PMM8+Uxx57TN74xjfKW97ylrrX0Ucfbf7mjDPOEJFfnBNUBU466SS54oor5Fvf+pZcffXVcvPNN9d9/uijj8q8efMq4QoEAq0hBFEgEGhrLF++XHbs2CGLFy+W9evXy49+9CP53ve+J5deeqkcOHDA/M1xxx0nZ555ptx3333D5l+xYoV873vfk2effVY2btwoa9askZNPPnno8x//+Mfy/PPPy8KFC4fNFQgEWkcIokAg0NaYOXOm/OAHP5ADBw7IokWLZO7cubJixQqZOnWqdHb6U+Bll10mt9xyy7D5Dxw4IMuXL5eTTz5Z3v3ud8tb3/pW+Yd/+Iehz7/2ta/JokWLpFarDZsrEAi0jjiYMRAIBAzs27dP3va2t8k3vvENmT9//ohwvPrqqzJ79mz56le/KgsWLBgRjkAgUA7hIQoEAgEDEydOlH/913/NHuA4XGzZskU+9alPhRgKBI4AhIcoEAgEAoHAmEd4iAKBQCAQCIx5hCAKBAKBQCAw5hGCKBAIBAKBwJhHCKJAIBAIBAJjHiGIAoFAIBAIjHmEIAoEAoFAIDDmEYIoEAgEAoHAmEcIokAgEAgEAmMeIYgCgUAgEAiMefw/mmX9TTIuWHgAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -575,42 +510,33 @@
     "  runner.run(inputs=bm.ones(1000) * 20.)\n",
     "\n",
     "bp.visualize.raster_plot(runner.mon['ts'], runner.mon['E.spike'])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:46:42.839131Z",
-     "end_time": "2023-04-15T15:46:43.981702Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [],
-   "metadata": {
-    "collapsed": false
-   }
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "brainpy",
    "language": "python",
-   "name": "python3"
+   "name": "brainpy"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 4
 }
diff --git a/docs/core_concept/brainpy_transform_concept-old.ipynb b/docs/core_concept/brainpy_transform_concept-old.ipynb
index ba4452b34..c8b3a771b 100644
--- a/docs/core_concept/brainpy_transform_concept-old.ipynb
+++ b/docs/core_concept/brainpy_transform_concept-old.ipynb
@@ -3,7 +3,10 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
    },
    "source": [
     "# Concept 1: Object-oriented Transformation"
@@ -45,10 +48,18 @@
   {
    "cell_type": "code",
    "execution_count": 5,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "'2.3.0'"
+      "text/plain": [
+       "'2.3.0'"
+      ]
      },
      "execution_count": 5,
      "metadata": {},
@@ -57,10 +68,7 @@
    ],
    "source": [
     "bp.__version__"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
@@ -270,7 +278,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      "text/plain": [
+       "dict_keys(['Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      ]
      },
      "execution_count": 9,
      "metadata": {},
@@ -318,7 +328,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['SuperLinear0.v1', 'Linear2.W', 'Linear2.b'])"
+      "text/plain": [
+       "dict_keys(['SuperLinear0.v1', 'Linear2.W', 'Linear2.b'])"
+      ]
      },
      "execution_count": 11,
      "metadata": {},
@@ -337,7 +349,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['SuperLinear0', 'Linear2'])"
+      "text/plain": [
+       "dict_keys(['SuperLinear0', 'Linear2'])"
+      ]
      },
      "execution_count": 12,
      "metadata": {},
@@ -445,7 +459,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "FunAsObject(nodes=[Sequential0],\n            num_of_vars=1)"
+      "text/plain": [
+       "FunAsObject(nodes=[Sequential0],\n",
+       "            num_of_vars=1)"
+      ]
      },
      "execution_count": 16,
      "metadata": {},
@@ -470,7 +487,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['loss0._var0', 'Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      "text/plain": [
+       "dict_keys(['loss0._var0', 'Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      ]
      },
      "execution_count": 17,
      "metadata": {},
@@ -538,7 +557,11 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "GradientTransform(target=loss0, \n                  num_of_grad_vars=4, \n                  num_of_dyn_vars=1)"
+      "text/plain": [
+       "GradientTransform(target=loss0, \n",
+       "                  num_of_grad_vars=4, \n",
+       "                  num_of_dyn_vars=1)"
+      ]
      },
      "execution_count": 18,
      "metadata": {},
@@ -573,7 +596,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "brainpy",
+   "display_name": "BrainPy",
    "language": "python",
    "name": "brainpy"
   },
@@ -587,7 +610,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.6.6"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,
@@ -627,5 +650,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 1
-}
\ No newline at end of file
+ "nbformat_minor": 4
+}
diff --git a/docs/core_concept/brainpy_transform_concept.ipynb b/docs/core_concept/brainpy_transform_concept.ipynb
index ea290794c..5c2707567 100644
--- a/docs/core_concept/brainpy_transform_concept.ipynb
+++ b/docs/core_concept/brainpy_transform_concept.ipynb
@@ -3,7 +3,10 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
    },
    "source": [
     "# Concept 1: Object-oriented Transformation"
@@ -34,8 +37,8 @@
    "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:06.895446Z",
-     "end_time": "2023-04-15T15:36:08.508950Z"
+     "end_time": "2023-04-15T15:36:08.508950Z",
+     "start_time": "2023-04-15T15:36:06.895446Z"
     }
    },
    "outputs": [],
@@ -49,10 +52,22 @@
   {
    "cell_type": "code",
    "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:08.524525Z",
+     "start_time": "2023-04-15T15:36:08.508950Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "'2.4.0'"
+      "text/plain": [
+       "'2.4.0'"
+      ]
      },
      "execution_count": 2,
      "metadata": {},
@@ -61,36 +76,45 @@
    ],
    "source": [
     "bp.__version__"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.508950Z",
-     "end_time": "2023-04-15T15:36:08.524525Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "## A simple example"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "Before diving into a real example, let's illustrate the OO transformation concept using a simple case."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:08.571464Z",
+     "start_time": "2023-04-15T15:36:08.524525Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [],
    "source": [
     "class Example:\n",
@@ -101,59 +125,73 @@
     "    @bm.cls_jit  # JIT compiled function\n",
     "    def update(self, inp):\n",
     "        self.dyn.value = self.dyn * inp + self.static"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.524525Z",
-     "end_time": "2023-04-15T15:36:08.571464Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
-   "outputs": [],
-   "source": [
-    "example = Example()"
-   ],
    "metadata": {
-    "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.540144Z",
-     "end_time": "2023-04-15T15:36:08.571464Z"
+     "end_time": "2023-04-15T15:36:08.571464Z",
+     "start_time": "2023-04-15T15:36:08.540144Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
     }
-   }
+   },
+   "outputs": [],
+   "source": [
+    "example = Example()"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "To use OO transformations provided in BrainPy, we should keep three things in mind."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "\n",
     "1, All **dynamically changed variables** should be declared as\n",
     "\n",
     "   - instance of ``brainpy.math.Variable``, (like ``self.dyn``)\n",
     "   - or the function argument, (like ``inp``)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:08.634321Z",
+     "start_time": "2023-04-15T15:36:08.571464Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "Variable(value=DeviceArray([1.]), dtype=float32)"
+      "text/plain": [
+       "Variable(value=DeviceArray([1.]), dtype=float32)"
+      ]
      },
      "execution_count": 5,
      "metadata": {},
@@ -163,22 +201,27 @@
    "source": [
     "example.update(1.)\n",
     "example.dyn"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.571464Z",
-     "end_time": "2023-04-15T15:36:08.634321Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:08.634321Z",
+     "start_time": "2023-04-15T15:36:08.603092Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "Variable(value=DeviceArray([2.]), dtype=float32)"
+      "text/plain": [
+       "Variable(value=DeviceArray([2.]), dtype=float32)"
+      ]
      },
      "execution_count": 6,
      "metadata": {},
@@ -188,31 +231,39 @@
    "source": [
     "example.update(2.)\n",
     "example.dyn"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.603092Z",
-     "end_time": "2023-04-15T15:36:08.634321Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "2, Other variables will be compiled as the **constants** during OO transformations. Changes made on these non-``Variable`` or non-``Argument`` will not show any impact after the function compiled."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:08.634321Z",
+     "start_time": "2023-04-15T15:36:08.618635Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "Variable(value=DeviceArray([2.]), dtype=float32)"
+      "text/plain": [
+       "Variable(value=DeviceArray([2.]), dtype=float32)"
+      ]
      },
      "execution_count": 7,
      "metadata": {},
@@ -223,17 +274,16 @@
     "example.static = 100.  # not work\n",
     "example.update(1.)\n",
     "example.dyn"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.618635Z",
-     "end_time": "2023-04-15T15:36:08.634321Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "source": [
     "3, All OO transformations provided in BrainPy can be obtained from our [API documentation](../apis/auto/math.rst). Simply speaking, these OO transformations include:\n",
     "\n",
@@ -241,10 +291,7 @@
     "   - just-in-time compilations\n",
     "   - control flow transformations\n",
     "   - ..."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
@@ -267,8 +314,8 @@
    "execution_count": 8,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.634321Z",
-     "end_time": "2023-04-15T15:36:08.889623Z"
+     "end_time": "2023-04-15T15:36:08.889623Z",
+     "start_time": "2023-04-15T15:36:08.634321Z"
     }
    },
    "outputs": [],
@@ -291,8 +338,8 @@
    "execution_count": 9,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:08.889623Z",
-     "end_time": "2023-04-15T15:36:09.171734Z"
+     "end_time": "2023-04-15T15:36:09.171734Z",
+     "start_time": "2023-04-15T15:36:08.889623Z"
     }
    },
    "outputs": [
@@ -338,6 +385,16 @@
   {
    "cell_type": "code",
    "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-15T15:36:09.202818Z",
+     "start_time": "2023-04-15T15:36:09.171734Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
    "outputs": [],
    "source": [
     "class Trainer(object):\n",
@@ -363,22 +420,15 @@
     "        grads, l = self.grad()\n",
     "        self.optimizer.update(grads)\n",
     "        return l"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:09.171734Z",
-     "end_time": "2023-04-15T15:36:09.202818Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:09.187298Z",
-     "end_time": "2023-04-15T15:36:10.033747Z"
+     "end_time": "2023-04-15T15:36:10.033747Z",
+     "start_time": "2023-04-15T15:36:09.187298Z"
     }
    },
    "outputs": [
@@ -456,14 +506,16 @@
    "execution_count": 12,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.038197Z",
-     "end_time": "2023-04-15T15:36:10.049555Z"
+     "end_time": "2023-04-15T15:36:10.049555Z",
+     "start_time": "2023-04-15T15:36:10.038197Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      "text/plain": [
+       "dict_keys(['Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])"
+      ]
      },
      "execution_count": 12,
      "metadata": {},
@@ -494,8 +546,8 @@
    "execution_count": 13,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.049555Z",
-     "end_time": "2023-04-15T15:36:10.190898Z"
+     "end_time": "2023-04-15T15:36:10.190898Z",
+     "start_time": "2023-04-15T15:36:10.049555Z"
     }
    },
    "outputs": [],
@@ -514,14 +566,16 @@
    "execution_count": 14,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.190898Z",
-     "end_time": "2023-04-15T15:36:10.206449Z"
+     "end_time": "2023-04-15T15:36:10.206449Z",
+     "start_time": "2023-04-15T15:36:10.190898Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['SuperLinear0.v1', 'Linear2.W', 'Linear2.b'])"
+      "text/plain": [
+       "dict_keys(['SuperLinear0.v1', 'Linear2.W', 'Linear2.b'])"
+      ]
      },
      "execution_count": 14,
      "metadata": {},
@@ -538,14 +592,16 @@
    "execution_count": 15,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.206449Z",
-     "end_time": "2023-04-15T15:36:10.253235Z"
+     "end_time": "2023-04-15T15:36:10.253235Z",
+     "start_time": "2023-04-15T15:36:10.206449Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "text/plain": "dict_keys(['SuperLinear0', 'Linear2'])"
+      "text/plain": [
+       "dict_keys(['SuperLinear0', 'Linear2'])"
+      ]
      },
      "execution_count": 15,
      "metadata": {},
@@ -569,8 +625,8 @@
    "execution_count": 16,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.222145Z",
-     "end_time": "2023-04-15T15:36:10.253235Z"
+     "end_time": "2023-04-15T15:36:10.253235Z",
+     "start_time": "2023-04-15T15:36:10.222145Z"
     }
    },
    "outputs": [],
@@ -587,8 +643,8 @@
    "execution_count": 17,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-04-15T15:36:10.237586Z",
-     "end_time": "2023-04-15T15:36:10.253235Z"
+     "end_time": "2023-04-15T15:36:10.253235Z",
+     "start_time": "2023-04-15T15:36:10.237586Z"
     }
    },
    "outputs": [
@@ -610,7 +666,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "brainpy",
+   "display_name": "BrainPy",
    "language": "python",
    "name": "brainpy"
   },
@@ -624,7 +680,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.6.6"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,
@@ -664,5 +720,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 1
+ "nbformat_minor": 4
 }
diff --git a/docs/tutorial_toolbox/optimizers.ipynb b/docs/tutorial_toolbox/optimizers.ipynb
index 1d9604ecb..78ff9cd6d 100644
--- a/docs/tutorial_toolbox/optimizers.ipynb
+++ b/docs/tutorial_toolbox/optimizers.ipynb
@@ -36,7 +36,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "'2.3.0'"
+      "text/plain": [
+       "'2.3.0'"
+      ]
      },
      "execution_count": 1,
      "metadata": {},
@@ -171,7 +173,16 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "{'a': Array([[0.6356058 , 0.10750175, 0.93578255, 0.2557603 ],\n        [0.77525663, 0.8615701 , 0.35919654, 0.6861898 ],\n        [0.9569112 , 0.98981357, 0.3033744 , 0.62852013],\n        [0.36589646, 0.86694443, 0.6335902 , 0.44947362],\n        [0.01782513, 0.11465573, 0.5505476 , 0.56196713]], dtype=float32),\n 'b': Array([[0.2326113 , 0.14437485, 0.6543677 ],\n        [0.46068823, 0.9811108 , 0.30460846],\n        [0.261765  , 0.71705794, 0.6173099 ]], dtype=float32)}"
+      "text/plain": [
+       "{'a': Array([[0.6356058 , 0.10750175, 0.93578255, 0.2557603 ],\n",
+       "        [0.77525663, 0.8615701 , 0.35919654, 0.6861898 ],\n",
+       "        [0.9569112 , 0.98981357, 0.3033744 , 0.62852013],\n",
+       "        [0.36589646, 0.86694443, 0.6335902 , 0.44947362],\n",
+       "        [0.01782513, 0.11465573, 0.5505476 , 0.56196713]], dtype=float32),\n",
+       " 'b': Array([[0.2326113 , 0.14437485, 0.6543677 ],\n",
+       "        [0.46068823, 0.9811108 , 0.30460846],\n",
+       "        [0.261765  , 0.71705794, 0.6173099 ]], dtype=float32)}"
+      ]
      },
      "execution_count": 5,
      "metadata": {},
@@ -192,7 +203,16 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "{'a': Array([[0.22753015, 0.0384828 , 0.33498552, 0.09155546],\n        [0.2775215 , 0.30841944, 0.12858291, 0.24563788],\n        [0.34254903, 0.3543272 , 0.10860006, 0.22499368],\n        [0.13098131, 0.3103433 , 0.22680864, 0.16089973],\n        [0.00638093, 0.04104374, 0.19708155, 0.20116945]], dtype=float32),\n 'b': Array([[0.14066657, 0.08730751, 0.39571446],\n        [0.27859107, 0.5933052 , 0.18420528],\n        [0.15829663, 0.433625  , 0.3733046 ]], dtype=float32)}"
+      "text/plain": [
+       "{'a': Array([[0.22753015, 0.0384828 , 0.33498552, 0.09155546],\n",
+       "        [0.2775215 , 0.30841944, 0.12858291, 0.24563788],\n",
+       "        [0.34254903, 0.3543272 , 0.10860006, 0.22499368],\n",
+       "        [0.13098131, 0.3103433 , 0.22680864, 0.16089973],\n",
+       "        [0.00638093, 0.04104374, 0.19708155, 0.20116945]], dtype=float32),\n",
+       " 'b': Array([[0.14066657, 0.08730751, 0.39571446],\n",
+       "        [0.27859107, 0.5933052 , 0.18420528],\n",
+       "        [0.15829663, 0.433625  , 0.3733046 ]], dtype=float32)}"
+      ]
      },
      "execution_count": 6,
      "metadata": {},
@@ -251,7 +271,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "{'Constant0.step': Variable([2], dtype=int32)}"
+      "text/plain": [
+       "{'Constant0.step': Variable([2], dtype=int32)}"
+      ]
      },
      "execution_count": 8,
      "metadata": {},
@@ -270,7 +292,17 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "{'Momentum0.a_v': Variable([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.]], dtype=float32),\n 'Momentum0.b_v': Variable([[0., 0., 0.],\n           [0., 0., 0.],\n           [0., 0., 0.]], dtype=float32),\n 'Constant1.step': Variable([0], dtype=int32)}"
+      "text/plain": [
+       "{'Momentum0.a_v': Variable([[0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.]], dtype=float32),\n",
+       " 'Momentum0.b_v': Variable([[0., 0., 0.],\n",
+       "           [0., 0., 0.],\n",
+       "           [0., 0., 0.]], dtype=float32),\n",
+       " 'Constant1.step': Variable([0], dtype=int32)}"
+      ]
      },
      "execution_count": 9,
      "metadata": {},
@@ -291,7 +323,25 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "{'Adam0.a_m': Variable([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.]], dtype=float32),\n 'Adam0.b_m': Variable([[0., 0., 0.],\n           [0., 0., 0.],\n           [0., 0., 0.]], dtype=float32),\n 'Adam0.a_v': Variable([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.]], dtype=float32),\n 'Adam0.b_v': Variable([[0., 0., 0.],\n           [0., 0., 0.],\n           [0., 0., 0.]], dtype=float32),\n 'Constant2.step': Variable([0], dtype=int32)}"
+      "text/plain": [
+       "{'Adam0.a_m': Variable([[0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.]], dtype=float32),\n",
+       " 'Adam0.b_m': Variable([[0., 0., 0.],\n",
+       "           [0., 0., 0.],\n",
+       "           [0., 0., 0.]], dtype=float32),\n",
+       " 'Adam0.a_v': Variable([[0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.],\n",
+       "           [0., 0., 0., 0.]], dtype=float32),\n",
+       " 'Adam0.b_v': Variable([[0., 0., 0.],\n",
+       "           [0., 0., 0.],\n",
+       "           [0., 0., 0.]], dtype=float32),\n",
+       " 'Constant2.step': Variable([0], dtype=int32)}"
+      ]
      },
      "execution_count": 10,
      "metadata": {},
@@ -397,8 +447,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -429,7 +481,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "Constant(0.001)"
+      "text/plain": [
+       "Constant(0.001)"
+      ]
      },
      "execution_count": 15,
      "metadata": {},
@@ -459,7 +513,9 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "0.001"
+      "text/plain": [
+       "0.001"
+      ]
      },
      "execution_count": 16,
      "metadata": {},
@@ -494,8 +550,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -518,8 +576,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAaUElEQVR4nO3dfbBlVXnn8e/vnCu+jYBKa5DGNJpWqlVGseXFcRzjSwlo7CTFzGC0wJcJRYRMomYilhmjNRlLjTGGhMCAouAYGWOc2DGdIowRKEcRGqMMjSJto9KA0iRKEBTs5pk/9r73nvt2zr7dfejb934/Vafuflv7rHWB+/DstfZaqSokSeqqt68rIEnavxg4JEmLYuCQJC2KgUOStCgGDknSokzs6wo8FA455JBas2bNvq6GJO1XrrvuuruqatXs4ysicKxZs4bNmzfv62pI0n4lyXfnO+6jKknSohg4JEmLYuCQJC2KgUOStCgGDknSoow1cCQ5IclNSbYmOXue80lyTnv++iRHD5y7KMmdSW6YVeZxSS5PcnP787HjbIMkaaaxBY4kfeBc4ERgHfDqJOtmXXYisLb9nA6cN3DuY8AJ89z6bODzVbUW+Hy7L0l6iIwz4zgG2FpV26rqAeBSYMOsazYAl1TjauDgJIcCVNVVwD/Pc98NwMXt9sXAL4+j8gD/58Yf8OdXbB3X7SVpvzTOwHEYcOvA/vb22GKvme2JVXUHQPvzCfNdlOT0JJuTbN6xY8eiKj7pym/t4MKrtu1WWUlarsYZODLPsdmrRnW5ZrdU1QVVtb6q1q9aNeeN+U76vbDrQRe6kqRB4wwc24HDB/ZXA7fvxjWz/WDycVb78849rOeCJgwckjTHOAPHtcDaJEckOQA4Bdg465qNwKnt6KrjgLsnH0MNsRE4rd0+Dfjs3qz0oH4/7DRwSNIMYwscVbUTOAu4DPgG8Kmq2pLkjCRntJdtArYBW4ELgTdNlk/ySeDLwNOTbE/yxvbUe4GXJbkZeFm7PxZmHJI011hnx62qTTTBYfDY+QPbBZy5QNlXL3D8n4CX7MVqLqjf67HzwaKqSObrjpGklcc3x4eY6DXBwqRDkqYZOIbot4Fj54MP7uOaSNLSYeAYYjLjsJ9DkqYZOIaYzjgMHJI0ycAxxFTGscvAIUmTDBxD9PvNr8eMQ5KmGTiGsI9DkuYycAzhqCpJmsvAMYQZhyTNZeAYwlFVkjSXgWOIiV7z6zHjkKRpBo4h2kFV7HQ4riRNMXAM0TfjkKQ5DBxDTDiqSpLmMHAM0Z+aHdeMQ5ImGTiGmMo47OOQpCkGjiH6vschSXMYOIaY6PsehyTNZuAYwlFVkjSXgWOICd8cl6Q5DBxDTPdxOBxXkiYZOIYw45CkuQwcQziqSpLmMnAMMTnJoe9xSNI0A8cQ/b4ZhyTNZuAYwj4OSZrLwDGEo6okaS4DxxBmHJI0l4FjCEdVSdJcBo4hpkZVGTgkaYqBY4g2bphxSNKAsQaOJCckuSnJ1iRnz3M+Sc5pz1+f5OhRZZM8O8nVSb6WZHOSY8ZVf9/jkKS5xhY4kvSBc4ETgXXAq5Osm3XZicDa9nM6cF6Hsu8H3l1Vzwbe2e6PRdvFwS5XAJSkKePMOI4BtlbVtqp6ALgU2DDrmg3AJdW4Gjg4yaEjyhZwYLt9EHD7uBqQhIleHI4rSQMmxnjvw4BbB/a3A8d2uOawEWV/G7gsyQdoAt/z5/vyJKfTZDE8+clP3q0GQDOyys5xSZo2zowj8xyb/Rd4oWuGlf0N4M1VdTjwZuAj8315VV1QVeurav2qVas6VnmuiV7YZR+HJE0ZZ+DYDhw+sL+auY+VFrpmWNnTgM+0239J81hrbMw4JGmmcQaOa4G1SY5IcgBwCrBx1jUbgVPb0VXHAXdX1R0jyt4O/Lt2+8XAzWNsAxP9nsNxJWnA2Po4qmpnkrOAy4A+cFFVbUlyRnv+fGATcBKwFbgPeP2wsu2tfx34kyQTwE9p+zHGxYxDkmYaZ+c4VbWJJjgMHjt/YLuAM7uWbY9/EXju3q3pwhxVJUkz+eb4CGYckjSTgWOEJuMwcEjSJAPHCGYckjSTgWOEiV7P9zgkaYCBYwQzDkmaycAxwkTfUVWSNMjAMYIZhyTNZOAYwVFVkjSTgWOEXsw4JGmQgWOEpo/DwCFJkwwcI/R7PTMOSRpg4BhhohceNHBI0hQDxwiOqpKkmQwcIzg7riTNZOAYwYxDkmYycIzgexySNJOBY4R+r8dOJzmUpCkGjhHMOCRpJgPHCP2+fRySNMjAMYKjqiRpJgPHCI6qkqSZRgaOJE9L8vkkN7T7RyX5vfFXbWmwj0OSZuqScVwIvB34GUBVXQ+cMs5KLSXOVSVJM3UJHI+qqmtmHds5jsosRWYckjRTl8BxV5KnAgWQ5GTgjrHWagnpt4GjyuAhSQATHa45E7gAODLJbcAtwGvGWqslZKIXAHY9WEz0s49rI0n7XpfAUVX10iSPBnpVdU+SI8ZdsaWi3waLnQ8WE/19XBlJWgK6PKr6K4Cqureq7mmPfXp8VVpa+pnOOCRJQzKOJEcCzwAOSvKrA6cOBB4x7ootFf3edMYhSRr+qOrpwCuBg4FfGjh+D/DrY6zTkjLZx+EqgJLUWDBwVNVngc8mOb6qvvwQ1mlJ6febp3lmHJLU6NLH8Y9Jzkzy50kumvx0uXmSE5LclGRrkrPnOZ8k57Tnr09ydJeySX6zPbclyfu71GV3DY6qkiR1CxwfB34OeDlwJbCa5nHVUEn6wLnAicA64NVJ1s267ERgbfs5HThvVNkkvwhsAI6qqmcAH+jQht023cfhRIeSBN0Cxy9U1X8F7q2qi4FXAM/qUO4YYGtVbauqB4BLaf7gD9oAXFKNq4GDkxw6ouxvAO+tqvsBqurODnXZbWYckjRTl8Dxs/bnj5I8EzgIWNOh3GHArQP729tjXa4ZVvZpwL9N8pUkVyZ53nxfnuT0JJuTbN6xY0eH6s7PUVWSNFOXwHFBkscCvwdsBG4E3teh3HyvWc/+67vQNcPKTgCPBY4D/gvwqSRzrq+qC6pqfVWtX7VqVYfqzm+i1/yKzDgkqTHyzfGq+nC7eRXwFIAkP9/h3tuBwwf2VwO3d7zmgCFltwOfqWbyqGuSPAgcAux+WjHEVMbhuuOSBIzIOJIcn+TkJE9o949K8hfAFzvc+1pgbZIjkhxAMxX7xlnXbARObUdXHQfcXVV3jCj718CL2/o8jSbI3NWhPrvFPg5JmmnYm+N/SPMC4NeAtyX5HPAm4D3AG0bduKp2JjkLuAzoAxdV1ZYkZ7Tnzwc2AScBW4H7gNcPK9ve+iLgonZhqQeA02qMU9dOz1XlqCpJguGPql4BPKeqftr2cdxOMwT25q43r6pNNMFh8Nj5A9tFM/tup7Lt8QeA13atw54y45CkmYY9qvpJVf0UoKp+CNy0mKCxXDiqSpJmGpZxPDXJYJ/EmsH9qnrV+Kq1dDiqSpJmGhY4Zr+s90fjrMhSZcYhSTMNm+TwyoeyIkvVdB+HneOSBN1eAFzRfI9DkmYycIzQd1SVJM1g4Bhhwj4OSZph5JQjSf6GuXNM3Q1sBv7H5JDd5Woy43hwfO8YStJ+pUvGsQ34MXBh+/kX4Ac0s9ReOL6qLQ2Tw3Ht45CkxsiMg+bt8RcO7P9Nkquq6oVJtixYapmYnHLEPg5JanTJOFYlefLkTrt9SLv7wFhqtYTYxyFJM3XJON4KfDHJt2nWyTgCeFOSRwMXj7NyS0Hf9zgkaYYu63FsSrIWOJImcHxzoEP8Q2Os25JgxiFJM3XJOACeS7Nc7ARwVBKq6pKx1WoJ8T0OSZqpy3DcjwNPpVmXY1d7uIAVETimRlUZOCQJ6JZxrAfWjXOxpKXMjEOSZuoyquoG4OfGXZGlasK5qiRphi4ZxyHAjUmuAe6fPLhS1uPo9ULiqCpJmtQlcLxr3JVY6iZ6sY9DklpdhuOu+HU5+r3YxyFJrQUDR5IvVtULktzDzEkOA1RVHTj22i0RE72eGYcktYatAPiC9udjHrrqLE1mHJI0rdMLgEn6wBMHr6+q742rUktN08dh57gkQbcXAH8T+H2aqdQn/3oWcNQY67WkmHFI0rQuGcdvAU+vqn8ad2WWqn4vvschSa0uLwDeSrPi34plxiFJ07pkHNuAK5L8LTNfAPzg2Gq1xEz0wq6VOeOKJM3RJXB8r/0c0H5WnL4vAErSlKGBox1NtbaqXvsQ1WdJmuj12GUfhyQBI/o4qmoXzdKxKzLTmGTGIUnTujyq+g7wf5NsBO6dPLii+jj6cZJDSWp1GVV1O/C59trHDHxGSnJCkpuSbE1y9jznk+Sc9vz1SY5eRNnfSVJJDulSlz1hxiFJ07pMcvju3blx2z9yLvAyYDtwbZKNVXXjwGUnAmvbz7HAecCxo8omObw995C8vT7hcFxJmtLlzfFVwO8CzwAeMXm8ql48ougxwNaq2tbe51JgAzAYODYAl7SrC16d5OAkh9Ksbz6s7B+3dfrsqPrvDWYckjSty6OqTwDfBI4A3k3T53Fth3KH0bw8OGl7e6zLNQuWTfIq4Laq+vqwL09yepLNSTbv2LGjQ3UXNtHrmXFIUqtL4Hh8VX0E+FlVXVlVbwCO61Au8xyb/dd3oWvmPZ7kUcA7gHeO+vKquqCq1lfV+lWrVo2s7DBmHJI0rcuoqp+1P+9I8gqazvLVHcptBw4f2F/dlu1yzQELHH8qTebz9SSTx7+a5Jiq+n6HOu2Wpo/DUVWSBN0Cxx8kOQh4K/CnwIHAmzuUuxZYm+QI4DbgFODXZl2zETir7cM4Fri7qu5IsmO+slW1BXjCZOEk3wHWV9VdHeqz25zkUJKmdRlV9bl2827gF7veuKp2JjkLuAzoAxdV1ZYkZ7Tnzwc2AScBW4H7gNcPK9u5VXtZ8x6HgUOSoNuoqqfRDJN9YlU9M8lRwKuq6g9Gla2qTTTBYfDY+QPbBZzZtew816wZVYe9oW/nuCRN6dI5fiHwdtq+jqq6nubR0YoxYee4JE3pEjgeVVXXzDq2cxyVWapcj0OSpnUJHHcleSrtUNokJwN3jLVWS0w/rjkuSZO6jKo6E7gAODLJbcAtwGvGWqslpm/nuCRNGZlxVNW2qnopsAo4sqpeAPzK2Gu2hDhXlSRN6/KoCoCqureq7ml33zKm+ixJvjkuSdM6B45Z5psSZNky45CkabsbOFbUX9F+r2fGIUmtBTvHk9zD/AEiwCPHVqMlyIxDkqYtGDiqqtMqfyvB5HscVUU7uaIkrVi7+6hqRZnoNcHCrEOSDByd9PtN4LCfQ5IMHJ2YcUjSNANHB/1e82sy45AkA0cnZhySNM3A0UG/N9nH4USHkmTg6MCMQ5KmGTg6mMo4XHdckgwcXUz0zTgkaZKBowNHVUnSNANHB/ZxSNI0A0cHvTiqSpImGTg6MOOQpGkGjg76do5L0hQDRwdmHJI0zcDRwfSb4wYOSTJwdDDRDsc145AkA0cnZhySNM3A0cF0H4fDcSXJwNGBc1VJ0jQDRwfOVSVJ08YaOJKckOSmJFuTnD3P+SQ5pz1/fZKjR5VN8odJvtle/7+THDzONsD0oyr7OCRpjIEjSR84FzgRWAe8Osm6WZedCKxtP6cD53UoeznwzKo6CvgW8PZxtWFS31FVkjRlnBnHMcDWqtpWVQ8AlwIbZl2zAbikGlcDByc5dFjZqvr7qtrZlr8aWD3GNgBmHJI0aJyB4zDg1oH97e2xLtd0KQvwBuDv5vvyJKcn2Zxk844dOxZZ9Zn6jqqSpCnjDByZ59js/2Vf6JqRZZO8A9gJfGK+L6+qC6pqfVWtX7VqVYfqLsyMQ5KmTYzx3tuBwwf2VwO3d7zmgGFlk5wGvBJ4SVWN/a9537mqJGnKODOOa4G1SY5IcgBwCrBx1jUbgVPb0VXHAXdX1R3DyiY5AXgb8Kqqum+M9Z8yOeWI73FI0hgzjqrameQs4DKgD1xUVVuSnNGePx/YBJwEbAXuA14/rGx76z8DHg5cnmaBpaur6oxxtQOcVl2SBo3zURVVtYkmOAweO39gu4Azu5Ztj//CXq7mSPZxSNI03xzvYHLpWEdVSZKBo5PpSQ73cUUkaQkwcHTQ64XEjEOSwMDR2UQv9nFIEgaOzvq9OKpKkjBwdDbR65lxSBIGjs7MOCSpYeDoqOnjsHNckgwcHZlxSFLDwNHRRC/OVSVJGDg66/fNOCQJDBydOapKkhoGjo7s45CkhoGjI0dVSVLDwNGRGYckNQwcHTlXlSQ1DBwdmXFIUsPA0dFEr+d7HJKEgaOzXs81xyUJDBydTfR67CoDhyQZODrq2zkuSYCBo7OJXlw6VpIwcHTWd5JDSQIMHJ1NOMmhJAEGjs76vZ6BQ5IwcHTmm+OS1DBwdOSb45LUMHB05Oy4ktQwcHRkxiFJDQNHR/ZxSFLDwNFRv9djl+9xSBIT47x5khOAPwH6wIer6r2zzqc9fxJwH/C6qvrqsLJJHgf8L2AN8B3gP1TVD8fZDmje4/jxAzt52QevHPdXSdJe855ffRbPW/O4vXrPsQWOJH3gXOBlwHbg2iQbq+rGgctOBNa2n2OB84BjR5Q9G/h8Vb03ydnt/tvG1Y5Jr3jWodz2o59QTnQoaT/yyIf19/o9x5lxHANsraptAEkuBTYAg4FjA3BJNX+Nr05ycJJDabKJhcpuAF7Ulr8YuIKHIHD868MP5txfO3rcXyNJS944+zgOA24d2N/eHutyzbCyT6yqOwDan0+Y78uTnJ5kc5LNO3bs2O1GSJJmGmfgyDzHZj/nWeiaLmWHqqoLqmp9Va1ftWrVYopKkoYYZ+DYDhw+sL8auL3jNcPK/qB9nEX78869WGdJ0gjjDBzXAmuTHJHkAOAUYOOsazYCp6ZxHHB3+/hpWNmNwGnt9mnAZ8fYBknSLGPrHK+qnUnOAi6jGVJ7UVVtSXJGe/58YBPNUNytNMNxXz+sbHvr9wKfSvJG4HvAvx9XGyRJc2UlDC9dv359bd68eV9XQ5L2K0muq6r1s4/75rgkaVEMHJKkRVkRj6qS7AC+u5vFDwHu2ovV2R/Y5pXBNq8Me9Lmn6+qOe8zrIjAsSeSbJ7vGd9yZptXBtu8MoyjzT6qkiQtioFDkrQoBo7RLtjXFdgHbPPKYJtXhr3eZvs4JEmLYsYhSVoUA4ckaVEMHEMkOSHJTUm2tqsN7veSHJ7kC0m+kWRLkt9qjz8uyeVJbm5/PnagzNvb38FNSV6+72q/Z5L0k/xjks+1+8u6ze3CaJ9O8s32n/fxK6DNb27/vb4hySeTPGK5tTnJRUnuTHLDwLFFtzHJc5P8v/bcOe1S3t1UlZ95PjSTK34beApwAPB1YN2+rtdeaNehwNHt9mOAbwHrgPcDZ7fHzwbe126va9v+cOCI9nfS39ft2M22vwX4C+Bz7f6ybjPNCpn/qd0+ADh4ObeZZrG3W4BHtvufAl633NoMvBA4Grhh4Nii2whcAxxPs/7R3wEndq2DGcfCppa+raoHgMnla/drVXVHVX213b4H+AbNf3AbaP7Q0P785XZ7A3BpVd1fVbfQzGR8zENa6b0gyWrgFcCHBw4v2zYnOZDmD8xHAKrqgar6Ecu4za0J4JFJJoBH0azjs6zaXFVXAf886/Ci2tiuZXRgVX25mihyyUCZkQwcC+uy9O1+Lcka4DnAV1h4Sd7l8nv4EPC7wIMDx5Zzm58C7AA+2j6e+3CSR7OM21xVtwEfoFlu4Q6a9X3+nmXc5gGLbeNh7fbs450YOBa2x8vXLmVJ/hXwV8BvV9W/DLt0nmP71e8hySuBO6vquq5F5jm2X7WZ5v+8jwbOq6rnAPfSPMJYyH7f5va5/gaaRzJPAh6d5LXDisxzbL9qcwdjWZ7bwLGwLkvf7peSPIwmaHyiqj7THl5oSd7l8Hv4N8CrknyH5pHji5P8T5Z3m7cD26vqK+3+p2kCyXJu80uBW6pqR1X9DPgM8HyWd5snLbaN29vt2cc7MXAsrMvSt/udduTER4BvVNUHB04ttCTvRuCUJA9PcgSwlqZTbb9RVW+vqtVVtYbmn+M/VNVrWd5t/j5wa5Knt4deAtzIMm4zzSOq45I8qv33/CU0fXjLuc2TFtXG9nHWPUmOa39Xp7KYZbj39QiBpfyhWdb2WzQjEd6xr+uzl9r0ApqU9Hrga+3nJODxwOeBm9ufjxso8472d3ATixh5sRQ/wIuYHlW1rNsMPBvY3P6z/mvgsSugze8GvgncAHycZjTRsmoz8EmaPpyf0WQOb9ydNgLr29/Tt4E/o51JpMvHKUckSYvioypJ0qIYOCRJi2LgkCQtioFDkrQoBg5J0qIYOKQFJHl8kq+1n+8nuW1g/4ARZdcnOWeR3/eGdrbS69vZXTe0x1+X5El70hZpb3I4rtRBkncBP66qDwwcm6iqnXvp/quBK2lmLr67nRJmVVXdkuQK4HeqavPe+C5pT5lxSIuQ5GNJPpjkC8D7khyT5EvtRIJfmnxTO8mLMr3ux7vaNRSuSLItyX+e59ZPAO4BfgxQVT9ug8bJNC9qfaLNdB7ZrqNwZZLrklw2MNXEFUk+1NbjhiRLfqZX7Z8MHNLiPQ14aVW9leYt5RdWM5HgO4H3LFDmSODlNNN2/347X9igrwM/AG5J8tEkvwRQVZ+mefv7NVX1bGAn8KfAyVX1XOAi4L8P3OfRVfV84E3tOWmvm9jXFZD2Q39ZVbva7YOAi5OspZnKZXZAmPS3VXU/cH+SO4EnMjCtdVXtSnIC8DyaOZb+OMlzq+pds+7zdOCZwOXtgm19muknJn2yvd9VSQ5McnA163BIe42BQ1q8ewe2/xvwhar6lXZ9kysWKHP/wPYu5vlvr5oOx2uAa5JcDnwUeNesywJsqarjF/ie2Z2WdmJqr/NRlbRnDgJua7dft7s3SfKkJEcPHHo28N12+x6aZX6hmahuVZLj23IPS/KMgXL/sT3+ApqFjO7e3TpJCzHjkPbM+2keVb0F+Ic9uM/DgA+0w25/SrN63xntuY8B5yf5Cc0a0ScD5yQ5iOa/4Q8BW9prf5jkS8CBwBv2oD7SghyOKy0TDtvVQ8VHVZKkRTHjkCQtihmHJGlRDBySpEUxcEiSFsXAIUlaFAOHJGlR/j+lSFQjb4zsmgAAAABJRU5ErkJggg==\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -574,9 +634,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "name": "python3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "display_name": "Python 3 (ipykernel)"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -588,7 +648,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.8"
+   "version": "3.9.1"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,