From 21952bbb5ac1908274f98f665a84d372d6c48283 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 1 Jul 2021 14:21:27 +0200
Subject: [PATCH 01/30] test notebook using Arbor

---
 examples/Example_Arbor_swc_hybridLFPy.ipynb | 907 ++++++++++++++++++++
 examples/morphologies/single_cell.swc       |  16 +
 2 files changed, 923 insertions(+)
 create mode 100644 examples/Example_Arbor_swc_hybridLFPy.ipynb
 create mode 100644 examples/morphologies/single_cell.swc

diff --git a/examples/Example_Arbor_swc_hybridLFPy.ipynb b/examples/Example_Arbor_swc_hybridLFPy.ipynb
new file mode 100644
index 0000000..a7503d1
--- /dev/null
+++ b/examples/Example_Arbor_swc_hybridLFPy.ipynb
@@ -0,0 +1,907 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example: Arbor plus .swc morphology file\n",
+    "\n",
+    "Example utilizing the **`LFPykit`** module for predictions of extracellular potentials using \n",
+    "the line source approximation implementation `LineSourcePotential` with a passive neuron model set up in Arbor (https://arbor.readthedocs.io, https://github.com/arbor-sim/arbor). \n",
+    "\n",
+    "The neuron receives sinusoid synaptic current input in one arbitrary chosen control volume (CV). \n",
+    "Its morphology is defined in the file `single_cell.swc`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## arbor may be installed using pip:\n",
+    "#!pip install git+https://github.com/espenhgn/arbor.git@isyn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## if running on mybinder or similar, uncomment and run the following to install LFPykit. \n",
+    "## Then restart the kernel.\n",
+    "#!pip install .."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import modules\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import arbor\n",
+    "import lfpykit\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.gridspec import GridSpec\n",
+    "from matplotlib.collections import PolyCollection\n",
+    "import pandas as pd\n",
+    "import scipy.stats as st\n",
+    "from LFPy.alias_method import alias_method\n",
+    "from LFPy.inputgenerators import get_activation_times_from_distribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_polygon(x, y, d):\n",
+    "    \"\"\"create a outline for each segment defined by 1D arrays `x`, `y`, `d`\n",
+    "    in x,y-plane which can be drawn using `plt.Polygon`\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x: ndarray\n",
+    "    y: ndarray\n",
+    "    d: ndarray\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    x, y: nested list\n",
+    "    \"\"\"\n",
+    "    dx = np.diff(x)\n",
+    "    dy = np.diff(y)\n",
+    "    theta = np.arctan2(dy, dx)\n",
+    "\n",
+    "    xp = np.r_[(x + 0.5 * d * np.sin(theta)).ravel(), (x - 0.5 * d * np.sin(theta)).ravel()[::-1]]\n",
+    "    yp = np.r_[(y - 0.5 * d * np.cos(theta)).ravel(), (y + 0.5 * d * np.cos(theta)).ravel()[::-1]]\n",
+    "    \n",
+    "    return list(zip(xp, yp))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def colorbar(fig, ax, im,\n",
+    "             width=0.01,\n",
+    "             height=1.0,\n",
+    "             hoffset=0.01,\n",
+    "             voffset=0.0,\n",
+    "             orientation='vertical'):\n",
+    "    '''\n",
+    "    draw matplotlib colorbar without resizing the axes object\n",
+    "    '''\n",
+    "    rect = np.array(ax.get_position().bounds)\n",
+    "    rect = np.array(ax.get_position().bounds)\n",
+    "    caxrect = [0] * 4\n",
+    "    caxrect[0] = rect[0] + rect[2] + hoffset * rect[2]\n",
+    "    caxrect[1] = rect[1] + voffset * rect[3]\n",
+    "    caxrect[2] = rect[2] * width\n",
+    "    caxrect[3] = rect[3] * height\n",
+    "    cax = fig.add_axes(caxrect)\n",
+    "    cb = fig.colorbar(im, cax=cax, orientation=orientation)\n",
+    "    return cb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class BaseRecipe (arbor.recipe):\n",
+    "    def __init__(self, cell):\n",
+    "        super().__init__()\n",
+    "     \n",
+    "        self.the_cell = cell\n",
+    "\n",
+    "        self.vprobe_id = (0, 0)\n",
+    "        self.iprobe_id = (0, 1)\n",
+    "        self.cprobe_id = (0, 2)\n",
+    "\n",
+    "        self.the_props = arbor.neuron_cable_properties()\n",
+    "        self.the_cat = arbor.default_catalogue()\n",
+    "        self.the_props.register(self.the_cat)\n",
+    "       \n",
+    "    def num_cells(self):\n",
+    "        return 1\n",
+    "\n",
+    "    def num_sources(self, gid):\n",
+    "        return 0\n",
+    "\n",
+    "    def num_targets(self, gid):\n",
+    "        return 0\n",
+    "\n",
+    "    def connections_on(self, gid):\n",
+    "        return []\n",
+    "\n",
+    "    def event_generators(self, gid):\n",
+    "        return []\n",
+    "    \n",
+    "    def cell_kind(self, gid):\n",
+    "        return arbor.cell_kind.cable\n",
+    "\n",
+    "    def cell_description(self, gid):\n",
+    "        return self.the_cell\n",
+    "\n",
+    "    def global_properties(self, kind):\n",
+    "        return self.the_props\n",
+    "    \n",
+    "    def probes(self, gid):\n",
+    "        return [\n",
+    "            arbor.cable_probe_membrane_voltage_cell(),\n",
+    "            arbor.cable_probe_total_current_cell(),\n",
+    "            arbor.cable_probe_stimulus_current_cell()\n",
+    "        ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Recipe(BaseRecipe):\n",
+    "    def __init__(self, cell, n_syn=1, times=[[1.]], weights=[1.]):\n",
+    "        super().__init__(cell)\n",
+    "        \n",
+    "        assert(len(times) == len(weights)), 'len(times) != len(weights)'\n",
+    "        self.times = times\n",
+    "        self.weights = weights\n",
+    "\n",
+    "    def num_targets(self, gid):\n",
+    "        return len(self.times)\n",
+    "        \n",
+    "    def event_generators(self, gid):\n",
+    "        events = []\n",
+    "        for i, (w, t) in enumerate(zip(self.weights, self.times)):\n",
+    "            events += [arbor.event_generator(i, w, \n",
+    "                                             arbor.explicit_schedule(t))]\n",
+    "        \n",
+    "        return events\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameters, cell decor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parameters\n",
+    "morphology_file = os.path.join('morphologies', 'single_cell.swc')\n",
+    "\n",
+    "# CV discretization\n",
+    "max_cv_length = 10  # µm, max length of CV.\n",
+    "\n",
+    "# simulation duration\n",
+    "tfinal = 500\n",
+    "\n",
+    "# number of synapses\n",
+    "n_syn = 20\n",
+    "\n",
+    "# synapse model and kwargs\n",
+    "synapse = 'expisyn'\n",
+    "synapse_params = {'tau': 5}\n",
+    "\n",
+    "# "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cell decor\n",
+    "decor = arbor.decor()\n",
+    "\n",
+    "# set initial voltage, temperature, axial resistivity, membrane capacitance\n",
+    "decor.set_property(\n",
+    "    Vm=-65,  # Initial membrane voltage [mV]\n",
+    "    tempK=300,  # Temperature [Kelvin]\n",
+    "    rL=10000,  # Axial resistivity [Ω cm]\n",
+    "    cm=0.01,  # Membrane capacitance [F/m**2]\n",
+    ")\n",
+    "\n",
+    "# set passive mechanism all over\n",
+    "pas = arbor.mechanism('pas/e=-65')  # passive mech w. leak reversal potential (mV)\n",
+    "pas.set('g', 0.0001)  # leak conductivity (S/cm2)\n",
+    "decor.paint('(all)', pas)\n",
+    "\n",
+    "# number of CVs per branch\n",
+    "policy = arbor.cv_policy_max_extent(max_cv_length)\n",
+    "decor.discretization(policy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define morphology (needed for arbor.place_pwlin etc.)\n",
+    "morphology = arbor.load_swc_arbor(morphology_file)\n",
+    "\n",
+    "# Label dictionary\n",
+    "defs = {}\n",
+    "labels = arbor.label_dict(defs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define isometry\n",
+    "iso = arbor.isometry()  # create isometry\n",
+    "iso_rot = iso.rotate(theta=np.pi/2, x=0, y=0, z=1)  # rotate isometry around axis\n",
+    "# iso_rot = iso.rotate(theta=np.pi/2, x=0, y=0, z=1)  # rotate isometry around axis\n",
+    "iso_trans = iso_rot.translate(x=0, y=0, z=0)  # translate isometry along axis\n",
+    "\n",
+    "p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### set up dummy cell to first find possible synapse locations (per CV)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create cell and set properties\n",
+    "cell = arbor.cable_cell(morphology, labels, decor)\n",
+    "\n",
+    "# instantiate recipe with cell\n",
+    "recipe = BaseRecipe(cell)\n",
+    "\n",
+    "# instantiate simulation\n",
+    "context = arbor.context()\n",
+    "domains = arbor.partition_load_balance(recipe, context)\n",
+    "sim = arbor.simulation(recipe, domains, context)\n",
+    "\n",
+    "# set up sampling on probes\n",
+    "schedule = arbor.regular_schedule(0.1)\n",
+    "i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "\n",
+    "# need meta data locating each CV\n",
+    "_, I_m_meta = sim.samples(i_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check samples w. probe handle (probe_recording_data, meta_data)\n",
+    "# sim.samples(i_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gather geometry of CVs and assign segments to each CV, \n",
+    "# get segment geometries and mapping to CV indices\n",
+    "x, y, z, d = [np.array([], dtype=float).reshape((0, 2))] * 4\n",
+    "CV_ind = np.array([], dtype=int)  # tracks which CV owns segment\n",
+    "for i, m in enumerate(I_m_meta):\n",
+    "    segs = p.segments([m])\n",
+    "    for j, seg in enumerate(segs):\n",
+    "        x = np.row_stack([x, [seg.prox.x, seg.dist.x]])\n",
+    "        y = np.row_stack([y, [seg.prox.y, seg.dist.y]])\n",
+    "        z = np.row_stack([z, [seg.prox.z, seg.dist.z]])\n",
+    "        d = np.row_stack([d, [seg.prox.radius * 2, seg.dist.radius * 2]])\n",
+    "        CV_ind = np.r_[CV_ind, i]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define a list of loc_sets with relative location in between proximal and distal points of each CV\n",
+    "loc_sets = [\n",
+    "    '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CellGeometry object\n",
+    "cell_geometry = lfpykit.CellGeometry(\n",
+    "    x=x,\n",
+    "    y=y,\n",
+    "    z=z,\n",
+    "    d=d\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# compute areas per CV\n",
+    "areas = []\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    areas = np.r_[areas, cell_geometry.area[inds].sum()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# center of mass (COM) per segment -- https://mathworld.wolfram.com/ConicalFrustum.html gives geometric centroid as\n",
+    "# \\overline{z}} = h * (R1**2 + 2 * R1*R2 + 3 * R2**2) / (4 * (R1**2 + R1 * R2 + R2**2))\n",
+    "R = cell_geometry.d / 2\n",
+    "# relative COMs per segment\n",
+    "h_bar_seg = cell_geometry.length * (R[:, 0]**2 + 2 * R[:, 0] * R[:, 1] + 3 * R[:, 1]**2\n",
+    "                                    ) / (4 * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2))\n",
+    "# carthesian coordinates\n",
+    "r_bar_seg =  np.c_[cell_geometry.x[:, 0] + h_bar_seg * (cell_geometry.x[:, 1] - cell_geometry.x[:, 0]\n",
+    "                                                        ) / cell_geometry.length,\n",
+    "                   cell_geometry.y[:, 0] + h_bar_seg * (cell_geometry.y[:, 1] - cell_geometry.y[:, 0]\n",
+    "                                                        ) / cell_geometry.length,\n",
+    "                   cell_geometry.z[:, 0] + h_bar_seg * (cell_geometry.z[:, 1] - cell_geometry.z[:, 0]\n",
+    "                                                        ) / cell_geometry.length]\n",
+    "# Volumes / mass\n",
+    "# V = 1 / 3 * π * h * (R1**2 + R1 * R2 + R2**2)\n",
+    "V_seg = np.pi * cell_geometry.length * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2) / 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# COM per CV\n",
+    "r_bar = np.zeros((0, 3))\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    if inds.sum() <= 1:\n",
+    "        r_ = (r_bar_seg[inds, ] * V_seg[inds] / V_seg[inds].sum()).mean(axis=0)\n",
+    "    else:\n",
+    "        # compute mean position weighted by volume/mass (mass monopole location)\n",
+    "        r_ = (r_bar_seg[inds, ].T * V_seg[inds] / V_seg[inds].sum()).sum(axis=-1)\n",
+    "    r_bar = np.vstack((r_bar, r_))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x149f7a4f0>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2400x2400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# test morphology plot\n",
+    "fig, ax = plt.subplots(1, 1, figsize=(12, 12), dpi=200)\n",
+    "\n",
+    "\n",
+    "# add outline of each CV\n",
+    "zips = []\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    zips.append(create_polygon(x[inds, ], y[inds, ], d[inds, ]*5))\n",
+    "polycol = PolyCollection(zips,\n",
+    "                         edgecolors='gray',\n",
+    "                         facecolors='none',\n",
+    "                         linewidths=2, label='_nolabel_')    \n",
+    "ax.add_collection(polycol)\n",
+    "\n",
+    "\n",
+    "# outline of segments making up each CV:\n",
+    "if True:\n",
+    "    zips = []\n",
+    "    for x_, y_, d_ in zip(x, y, d*5):\n",
+    "        zips.append(create_polygon(x_, y_, d_))\n",
+    "    polycol = PolyCollection(zips,\n",
+    "                             edgecolors='k',\n",
+    "                             facecolors='none',\n",
+    "                             linewidths=0.25, label='_nolabel_')\n",
+    "    ax.add_collection(polycol)\n",
+    "\n",
+    "# plot COM of each CV (sanity test)\n",
+    "ax.plot(r_bar[:, 0], r_bar[:, 1], 'go', label='COM(CV)')\n",
+    "\n",
+    "# plot COM of each segment (sanity test)\n",
+    "ax.plot(r_bar_seg[:, 0], r_bar_seg[:, 1], 'r.', label='COM(seg)')\n",
+    "    \n",
+    "    \n",
+    "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
+    "ax.set_ylabel(r'$y$ ($\\mu$m)')\n",
+    "ax.set_aspect('equal')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# draw locsets accd to y-position weighted by area and some function of y\n",
+    "def get_rand_idx_area_and_distribution_norm(areas, \n",
+    "                                            depth,\n",
+    "                                            n_syn=1,\n",
+    "                                            fun=[st.norm], \n",
+    "                                            funargs=[dict(loc=200, scale=50)], \n",
+    "                                            funweights=[1.]):\n",
+    "    '''Return n_syn CV indices with random probability normalized by membrane area\n",
+    "    multiplied with the value of probability density function constructed as\n",
+    "    weigthed sum of `scipy.stats._continuous_dists` function instances\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    areas: 1D ndarray\n",
+    "        Area of each CV\n",
+    "    depth: 1D ndarray\n",
+    "        depth of each CV\n",
+    "    n_syn: int\n",
+    "        number of random indices\n",
+    "    fun: iterable of scipy.stats._continuous_distns.*_gen\n",
+    "        iterable of callable methods in scipy.stats module\n",
+    "    funargs: iterable of dicts\n",
+    "        keyword arguments to each element in `fun`\n",
+    "    funweights: list of floats\n",
+    "        scaling\n",
+    "        \n",
+    "    Returns\n",
+    "    -------\n",
+    "    ndarray\n",
+    "        random indices of size `n_syn` that can be \n",
+    "    '''\n",
+    "    # probabilities for connecting to CV \n",
+    "    p = areas.copy()\n",
+    "    mod = np.zeros(areas.size)\n",
+    "    for f, args, w in zip(fun, funargs, funweights):\n",
+    "        df = f(**args)\n",
+    "        mod += df.pdf(x=r_bar[:, 1]) * w\n",
+    "\n",
+    "    # multiply probs by spatial weighting factor\n",
+    "    p *= mod\n",
+    "    # normalize\n",
+    "    p /= p.sum()\n",
+    "    # find CV inds\n",
+    "    return alias_method(np.arange(areas.size), p, n_syn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([ 5.,  3., 10., 16., 16., 21., 16.,  7.,  4.,  2.]),\n",
+       " array([ 87.85863035, 107.79819931, 127.73776827, 147.67733723,\n",
+       "        167.61690619, 187.55647515, 207.4960441 , 227.43561306,\n",
+       "        247.37518202, 267.31475098, 287.25431994]),\n",
+       " <BarContainer object of 10 artists>)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# sanity check\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 1], n_syn=100, \n",
+    "                                               fun=[st.norm], \n",
+    "                                               funargs=[dict(loc=200, scale=50)], \n",
+    "                                               funweights=[1.])\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, sharey=True)\n",
+    "# areas per depth\n",
+    "axes[0].plot(areas, r_bar[:, 1], '.')\n",
+    "# num. synapses hist. across depth\n",
+    "axes[1].hist(r_bar[inds][:, 1], orientation='horizontal')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Proper cell simulation using cell instrumented with synapses distributed accd. to CV area and depth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# randomly chosen loc_sets\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 1], n_syn=n_syn)\n",
+    "random_loc_sets = np.array(loc_sets)[inds]\n",
+    "\n",
+    "# create synapses at each loc_set\n",
+    "for loc_set in random_loc_sets:\n",
+    "    decor.place(loc_set, arbor.mechanism(synapse, synapse_params))\n",
+    "\n",
+    "# synapse activation times (Poisson like)\n",
+    "times = get_activation_times_from_distribution(\n",
+    "    n_syn, tstart=0, tstop=tfinal, \n",
+    "    distribution=st.expon, rvs_args=dict(loc=0, scale=20))\n",
+    "\n",
+    "# synapse weights\n",
+    "weight_params = dict(loc=0, scale=1E-4)\n",
+    "weights = st.norm.rvs(size=n_syn, **weight_params)\n",
+    "    \n",
+    "# number of CVs per branch\n",
+    "policy = arbor.cv_policy_max_extent(max_cv_length)\n",
+    "decor.discretization(policy)\n",
+    "\n",
+    "# create cell and set properties\n",
+    "cell = arbor.cable_cell(morphology, labels, decor)\n",
+    "\n",
+    "# instantiate recipe with cell\n",
+    "recipe = Recipe(cell, weights=weights, times=times)\n",
+    "\n",
+    "# instantiate simulation\n",
+    "context = arbor.context()\n",
+    "domains = arbor.partition_load_balance(recipe, context)\n",
+    "sim = arbor.simulation(recipe, domains, context)\n",
+    "\n",
+    "# set up sampling on probes\n",
+    "schedule = arbor.regular_schedule(0.1)\n",
+    "v_handle = sim.sample(recipe.vprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "c_handle = sim.sample(recipe.cprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "\n",
+    "# run simulation for 500 ms of simulated activity and collect results.\n",
+    "sim.run(tfinal=tfinal)\n",
+    "\n",
+    "# extract time, V_m and I_m for each compartment\n",
+    "V_m_samples, V_m_meta = sim.samples(v_handle)[0]\n",
+    "I_m_samples, I_m_meta = sim.samples(i_handle)[0]\n",
+    "I_c_samples, I_c_meta = sim.samples(c_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# drop recorded V_m values and corresponding meta data of \n",
+    "# zero-sized CVs (branch-point potentials)\n",
+    "inds = np.array([m.dist != m.prox for m in V_m_meta])\n",
+    "V_m_samples = V_m_samples[:, np.r_[True, inds]]\n",
+    "V_m_meta = np.array(V_m_meta)[inds].tolist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# note: the cables comprising the metadata for each probe\n",
+    "# should be the same, as well as the reported sample times.\n",
+    "assert V_m_meta==I_m_meta\n",
+    "assert (V_m_samples[:, 0]==I_m_samples[:, 0]).all()\n",
+    "\n",
+    "# prep recorded data for plotting\n",
+    "time = V_m_samples[:, 0]\n",
+    "V_m = V_m_samples[:, 1:].T\n",
+    "I_m = I_m_samples[:, 1:].T\n",
+    "I_c = I_c_samples[:, 1:].T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "###############################################################################\n",
+    "# compute extracellular potential using segment information\n",
+    "###############################################################################\n",
+    "# membrane voltages, transmemrbane current and corresponding times\n",
+    "cell_geometry.V_m = V_m  # mV\n",
+    "cell_geometry.I_m = I_m + I_c  # nA, sum stimulation and transmembrane current to mimic sinusoid synapse\n",
+    "cell_geometry.time = time  # ms\n",
+    "\n",
+    "# locations where extracellular potential is predicted \n",
+    "dx = 1\n",
+    "dz = 1\n",
+    "axis = np.round([x.min()-50, x.max()+50, y.min()-10, y.max()+10])\n",
+    "# axis = np.round(axis)\n",
+    "X, Y = np.meshgrid(np.linspace(axis[0], axis[1], int(np.diff(axis[:2]) // dx) + 1), \n",
+    "                   np.linspace(axis[2], axis[3], int(np.diff(axis[2:]) // dz) + 1))\n",
+    "Z = np.zeros_like(X)\n",
+    "\n",
+    "# LineSourcePotential object, get mapping for all segments per CV\n",
+    "lsp = lfpykit.LineSourcePotential(cell=cell_geometry, \n",
+    "                                  x=X.flatten(), \n",
+    "                                  y=Y.flatten(), \n",
+    "                                  z=Z.flatten())\n",
+    "M_tmp = lsp.get_transformation_matrix()\n",
+    "\n",
+    "# Define response matrix from M with columns weighted by area of each frusta\n",
+    "M = np.zeros((lsp.x.size, I_m.shape[0]))\n",
+    "for i in range(I_m.shape[0]):\n",
+    "    inds = CV_ind == i\n",
+    "    M[:, i] = M_tmp[:, inds] @ (cell_geometry.area[inds] / cell_geometry.area[inds].sum())\n",
+    "\n",
+    "# Extracellular potential using segment information at last time step \n",
+    "# in x,y-plane coordinates   \n",
+    "V_e = M @ cell_geometry.I_m[:, -1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting\n",
+    "Plot the morphology and extracellular potential prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2400x3200 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1, figsize=(12, 16), dpi=200)\n",
+    "\n",
+    "# plot pcolormesh plot of V_e\n",
+    "im_V_e = ax.pcolormesh(X, Y, V_e.reshape(X.shape), \n",
+    "                        shading='auto', cmap='RdBu', \n",
+    "                        vmin=-abs(V_e).max() / 2, vmax=abs(V_e).max() / 2)\n",
+    "cb = colorbar(fig, ax, im_V_e, height=0.45, voffset=0.55, width=0.02)\n",
+    "cb.set_label('$V_e$ (mV)')\n",
+    "\n",
+    "\n",
+    "# add outline of each CV\n",
+    "norm = plt.Normalize(vmin=-65.2, vmax=-64.8)\n",
+    "colors = [plt.cm.viridis(norm(v)) for v in cell_geometry.V_m[:, -1]]\n",
+    "zips = []\n",
+    "for i in range(I_m.shape[0]):\n",
+    "    inds = CV_ind == i\n",
+    "    zips.append(create_polygon(x[inds, ], y[inds, ], d[inds, ]))\n",
+    "polycol = PolyCollection(zips,\n",
+    "                         edgecolors='k',\n",
+    "                         facecolors=colors,\n",
+    "                         linewidths=0.25)    \n",
+    "im_V_m = ax.add_collection(polycol)\n",
+    "\n",
+    "cb2 = colorbar(fig, ax, im_V_m, height=0.45, width=0.02)\n",
+    "cb2.set_ticks([0, 0.5, 1])\n",
+    "cb2.set_ticklabels([-65.2, -65, -64.8])\n",
+    "cb2.set_label(r'$V_m$ (mV)')\n",
+    "\n",
+    "# outline of segments making up each CV:\n",
+    "if False:\n",
+    "    zips = []\n",
+    "    for x_, y_, d_ in zip(x, y, d):\n",
+    "        zips.append(create_polygon(x_, y_, d_))\n",
+    "    polycol = PolyCollection(zips,\n",
+    "                             edgecolors='k',\n",
+    "                             facecolors='none',\n",
+    "                             linewidths=0.5)\n",
+    "    ax.add_collection(polycol)\n",
+    "\n",
+    "    \n",
+    "ax.set_xlim(X.min(), X.max())\n",
+    "ax.set_ylim(Y.min(), Y.max())\n",
+    "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
+    "ax.set_ylabel(r'$y$ ($\\mu$m)')\n",
+    "ax.set_aspect('equal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 4999.5, 71.5, -0.5)"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x144 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.matshow(cell_geometry.I_m)\n",
+    "plt.colorbar()\n",
+    "plt.axis('tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 4999.5, 71.5, -0.5)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0QAAACSCAYAAABllgqBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAACZCklEQVR4nO39e5Cty1UfCP5W5rf3rqpzzr1X0r1XuhJgQYAcxgzGbWEzY+PmNR7c3WHBRNOBJ8DqMW7ZREPY0SZAtifCD8IRGsI23RPtgb6mNa0ePHYrGgwExmZAbtnuDg8gsI3BWCGgaRBcJF3dx3lU1d7fl7nmj8yV38r88tuPOnXOqTonfxFVe+/vke/XWuuXK4mZ0dDQ0NDQ0NDQ0NDQ8CTCPOoENDQ0NDQ0NDQ0NDQ0PCo0gaihoaGhoaGhoaGh4YlFE4gaGhoaGhoaGhoaGp5YNIGooaGhoaGhoaGhoeGJRROIGhoaGhoaGhoaGhqeWDSBqKGhoaGhoaGhoaHhicVDEYiI6KuJ6KNE9MtE9N6HEWfD1QYRvZ+IPklEv6CuvZGIfoKIPhY/36Du/YXYfj5KRP8ndf33EdG/iff+H0REDzsvDQ8XRPSZRPQ/EdEvEdEvEtGfjddb+2nYCiI6IqKfJqJ/HdvOX43XW9tp2AkiskT0L4noR+Pv1m4aGh4TPHCBiIgsgL8N4I8C+HwAf5yIPv9Bx9tw5fHfAfjq4tp7AXyImT8PwIfib8T28vUAfnd85/8Z2xUAfA+A9wD4vPhXhtnw+GEA8OeZ+XcB+BIA/3lsI639NOzCGsBXMPPvAfBFAL6aiL4Ere007Ic/C+CX1O/WbhoaHhM8DAvR7wfwy8z8q8y8AfD3AbzrIcTbcIXBzP8MwCvF5XcB+ED8/gEAX6Ou/31mXjPz/wrglwH8fiJ6AcBTzPwvOJww/N+rdxoeUzDzS8z8c/H7HYQFytvQ2k/DDnDA3fhzEf8Yre007AARfQaA/xDA96nLrd00NDwmeBgC0dsA/Ib6/fF4raGhxJuZ+SUgLHoBPB+vz7Wht8Xv5fWGJwRE9HYAvxfAT6G1n4Y9EGlP/wrAJwH8BDO3ttOwD/5LAN8OwKtrrd00NDwmeBgCUY0fyw8h3obHB3NtqLWtJxhEdBPADwD4c8x8e9ujlWut/TyhYGbHzF8E4DMQtPZfsOXx1nYaQET/EYBPMvPP7vtK5VprNw0NVxgPQyD6OIDPVL8/A8BvPYR4G64fPhEpBYifn4zX59rQx+P38nrDYw4iWiAIQ3+XmX8wXm7tp2FvMPNrAD6MsIejtZ2GbfiDAP4YEf0aAu3/K4jo+9HaTUPDY4OHIRD9DIDPI6LPJqIlwkbDH3kI8TZcP/wIgHfH7+8G8MPq+tcT0YqIPhthI+pPR4rCHSL6kuip50+odxoeU8S6/m8B/BIz/y11q7Wfhq0goueI6Jn4/RjAVwH4d2htp2ELmPkvMPNnMPPbEdYw/4SZvwGt3TQ0PDboHnQEzDwQ0bcA+HEAFsD7mfkXH3S8DVcbRPT3AHwZgGeJ6OMA/jKA9wH4IBF9E4BfB/B1AMDMv0hEHwTwbxE8jP3nzOxiUN+M4LHuGMA/in8Njzf+IIBvBPBv4l4QAPiLaO2nYTdeAPCB6PHLAPggM/8oEf0LtLbTcDjamNPQ8JiAgqOThoaGhoaGhoaGhoaGJw8P5WDWhoaGhoaGhoaGhoaGq4gmEDU0NDQ0NDQ0NDQ0PLFoAlFDQ0NDQ0NDQ0NDwxOLJhA1NDQ0NDQ0NDQ0NDyxaAJRQ0NDQ0NDQ0NDQ8MTi/sSiIjoq4noo0T0y0T03j2ef8/9xNfw5KK1nYaLorWdhouitZ2Gi6C1m4aG64cLC0TxHIe/DeCPAvh8AH+ciD5/x2ttkGi4KFrbabgoWttpuCha22m4CFq7aWi4ZrgfC9HvB/DLzPyrzLwB8PcBvOtyktXQ0NDQ0NDQ0NDQ0PDg0d3Hu28D8Bvq98cB/IHyoWg6DtqSzv6+4899azsJtuFgLJ57Gq3tNFwEre00XBSt7TRcBK3dNFwU/Sdfw3D7lB51Og7BH/nyE/70Ky679nM/v/lxZv7qR5SkC+F+BKJahU0GAGZ+EcCLAHD8uW/lz/4bD8aSTHTxsed+3n2YuFY95JJxkRpifnJK7Lq04Yb9cNlt9yq2j0fZPx9FeTxJ49HDwEXq8KrWwYNoj48ypw+qd11mnq7eiBjwK//F9z3qJByMl19x+Of/+C3ZtZtv/fVnH1FyLoz7EYg+DuAz1e/PAPBb95eci+Gig8lVXCTUcDWH8N0wqnz9fU5EhKs7gD1qHNKOt9VCK9+rg1qdXmQxd5XHOCJ+6AvUR1kejyK/+6Ask6uYRo3LUH5elTw+boKQ4CqkYRckjVd3hLw+YDB69o86GfeN+xGIfgbA5xHRZwP4TQBfD+D/cimpamhoaGhoaGhoaGi40vAAztntfO6q48ICETMPRPQtAH4cgAXwfmb+xUtL2Z64iIblKmtNS+yraRFrzP1aYg6F2bMsa8896LReVY3sZWHfdrxvCTSN2dXGvpr8azW+PaQ+elXK5FGOSXuPF1fUYnSZdfio54bH1TJ0HdHYJ/cPBqN/DErxfixEYOYfA/Bjl5SWvfGkUuT2ET7mntklfOwr2FwmDhWSLjJwPU48c8GuPN1v6ufevx6959EtDB52+VyX8WwXdD4O7XsPowwuW1HwoBbjD6osHhXN7EHX7aPI12XnaVfKLzqvP2zF6qPG/QhFl1VS13k0Zwb665yBiPsSiBoaGhoaGhoaGhoankwwCP1jIERfC4HoUK3K3POPurrmcqHTpTU6s/nYUh5z2i6rtGGXpaU6NJx9NHG1g7G0tqoM4UEoJebydVFN4sOiR1ymla+mIXzU/ecy8CAsoVJW+5TPw1SiXZX6OiTPD8zKceDzZTvxTAeFsSsX19G6d9lUusum/M7hInWxK2/35djhwm/mKNvoZbYpe8Xp5ofkdVs+tq0t9sH9zif3G/9VAQM4Z/uok3HfuJIC0WXtCyob2EUab7kwPCSM8t1dVDgqPk3lhZ2L9bSXqB7X3Pu1uA7FzollssjYHSYzbfVWdxE6y66szgquB1IsDhXMt+VhW1su49m3/8zloyzzGg6lVDwoSuYhwuuDWITOldVc+TzsSa+WtosoVPbBRfJ8MAX2wOdL7GqHc2WzzwLxYSpuHmY7etDjIXC51K995t2HJbDeD/19a7gz4/9F5/HaXPyo91lJGi4rjDIvu9YWGoeOo/tgbu6gaygZeRA2aAJRQ0NDQ0NDQ0NDQ8MTCAbQc43fc71wpQSig85T2UP7vg/9bA6iTbioZmCX5riWNiKGIW0h2j/9WvvhmWDpcsz+h2iyqpSKCvVEYEk9J/eV7k7T+8r62Nf6dhHosGq536U5y7R3F4x3DnPWxHBvPh2C0mJXagZ3USq39YtduGwvUQ8rrkNwP+Uzh32tcbsoNPuUyaFaf/3cRayK27T3F+3Tc+nYaqG4j/qaq/OaxegyLdk1XFa7m7N2XWQ8lGey31uevSgVbFvfuwxmwTYcYuG637GpHPPz34eFLeVSm4tDZPuFt43tYWg/Noh+fhf2XYNp+C21vYsVMWeRezC4fnRaBuGcF486GfeNKyMQXdQlKLBbCCrf0R3ukI66LQ0atUVlbbCuCUKGOH0C+0+KrASFRO+YER4OGZz3GWBnKWAVc7RV1zTNLwmKKjQZwA4RjLZh38nifhYyNWHoopNU7V2K7SPcy+PctpCYUirHiXBOIC1xv/vPLmsiuQx652VhW3lp3A/15KJKiW3U290BTYXlEvu0h10C075C0qF9qDpPVK4dVDZ7KhC2jVGXLeRtw/3s8ZyjEhEOE4q2KYf2EVwvY8zYRo3aJezVntuFbUrU+81PbcyfHf/j51yMslYQbFsz7ILd8fiu+3O4CMV1n7nOc678qSmCDh1LDxXSanPHo6YoXhTMhP4x2EO008ZFRO8nok8S0S+oa28kop8goo/Fzzc82GQ2NDQ0NDQ0NDQ0NFwlMAgb7rK/64h9Uv3fAfivAfz36tp7AXyImd9HRO+Nv7/jook4hMqRXVPfdzkmmN8sGz73Na/uo1Es353TpJaWIWs8KOalzM8cRo1H+EwaPGV1sUUY+1qfdmln9tFaznngKtMokrmX+0zJ1K61j6Umcs5StK/5O0vTDs3urtxSUa771uFc/JNwVZumShvJLH9l2IWGVHsdzNtKXUtVatRK7LY0zt87xMvT/WtYD7cSlu+WtM85raPGw6Lw7Ws9BHZrgXfRbndZE3X8tXtlunb14fuhVOv2V7cUzYedWWyLnrVtrH8Q1uzLoJXXcIila5+xsIx/zlq+zZJ3qGVzTuP+IGjXh1outq1H9rEKlLS4zEKk0rNvOwYq1rFizbCtD++b9os4Zpj23S1zeZkeIKP5ZYwZjOsL6ce19UUtLXNbGfbJw5SmPmXDpPReQ7ocEJwqPA6UuZ0WImb+ZwBeKS6/C8AH4vcPAPiay01WQ0NDQ0NDQ0NDQ8NVBgPoucv+riMumuo3M/NLAMDMLxHR8xdNwKGbo+d4yOV+HH1tm6a+to8FqEvv2zYvzr07x1UNYSBYhYhhidHF753xKqwtGp+k5SCQaB2Y4ONfaRkq0641TRo6nfdjJSrTVd4Dphat0lJkQLNanH03dO/aT1DTDmne+T6a3Zp16BDe+Lb9GDXLUPpU8enPEnP7osZy1hFO811q1EpchFu9tW0VaTjU2gZsL9Nd7lbn+o6+t0vreFmY47WX2La/QH6H9NUtx7X4Sm1rFt8Wnfo2fvyc9vQynEKMYU3f27Z3cpsFLXO5vWWe2LUvwRTvzsU7l8a5azXcr3VlV/prViIZo2tzdq3/bhtHds0/9T5bOhc6vD5qONQiUP7WeaqGtSUdtTarrULlnuOt7bjyWzNMkjVFpWsnLusZ/bj6Plf2+7SLLD97rC/q8eRz7q74yzxoi9VkPKnUu6XDLJVXBeFg1svfQ0RE3wrgWwAMAP4hM3+7uvdZAP4tgL/CzH+j8u5fAfCfAfhUvPQXmfnHtsX3wMU4InoPgPcAQPfc08W9/Se8uU5SCkLlYmAbPaw0E+tFoS+e3bUgq5llQ5j5IqkcHK3xWBgPazw6Cp/bOpsexPUnM2FgAx/TYtS9uUE1DaJqavOqpAx4MonsOyhoT3dacEvpiGmW/KR0qoHLx0msJhTptOxaMG6jz5SD4Rw1bxu0MCTt7hDax7Y0SBh6ULbxu26TuyZECyVcFEKzFow0tlENavkvsQ89ZtfEphftWgDchnJCn1OiSDw1wUCuzMVXEyY9RqrnZUIvVufCril/agIzsH3CLcdEjTlBsIYJtWxHG69dqy0qd2FufKotRnctvMpFzbZ5Qtf7NprvIYvrbePWPu+P720X/oHdgt2+QsQcTW7fOq0tPmuYOxdq29y7T33UvMDW8rbr3pxyYnZ8ruRn0qcxFYI68vOCVpEnQCjS8TpoFHCZsjXDo8K2dVaZx1q7JpV2nZ991hchzDH8XcrHXXnQ6QJyJUJVEakfvGZ4EE4ViOjLEdhoX8jM64rh5bsB/KMdwXx3TViaw0UFok8Q0QvROvQCgE/OPcjMLwJ4EQCOP/eth6kKGhoaGhoaGhoaGhquJDwI5/7S9xB9M4D3MfMaAJg5yRlE9DUAfhXAvcuM8KIC0Y8AeDeA98XPH76fROykzWFeY6MtQ3ObDXdtKE6SO00dEYiGbJcjAv2+aHu80q6VliHR9C+sw9I4LKxDRx6dcVvLorQQeTbBMsQEeMBT1PqotOj8G2JY8jvLZe4+MKXxGcp1xZ5N0j5p2px2YCHp1GZsid8QwwOzVqJU5hUtc+33tg3Vc5ukS82oRs0iVVqH5s6HqG7Wr2hna+3FxDYjVkRDnFnx5rWPo2ZQ6kU0gnP0Sm1lqVENynzpspi7L+W07f6YZp5Yaba1yfL9fdOoaSO1MLb1ERk3RssQ5xrqHdr0uTSWGt1djmHkfT1OWZrXtJf01TLeXVYzPbZIGidh6fcKq9k+/bjsA/tgG71I39/HcgmMltSQ5in9BsCkX8w5gymxj7VhlyOIlM6Ze7V35upsl2Wllhet8Z7ErdKmx8QybbW62McSLPWQ5YGnG+jL+gC2j+27xrNt1Kq5vGmrfomyXWVxYdpm09iPsHaQ7+UcPIZvMtaHbs+kWRw0PxfMWdG2YZtVcu5eOb7XtgvMWYAlnJKRktZAaq4r1xchrDz8cs7dxRAq05PSq9Kl2TDbmBnXEQzU9g09S0QfUb9fjAaSffEOAF9KRH8dwDmAb2PmnyGiGwhO3P6PAL5tRxjfQkR/AsBHAPx5Zn5128M7BSIi+nsAvgwhcx8H8JcRBKEPEtE3Afh1AF+3K5yLQi80p2mrn99TCkLVRUH89KqhMqaLmDLMGjxTmhzk/bCIHxf0Jbda9gyJMLQ0Azo12EHFVy7O5HcQhDgJQkA0fSMMCuXgInkRU3sIc+ySnk0KRwbZ2qKuHKR1msOC26eOXxuQ04Ic40AsFLqsTjAVijLQeC7I3H6R0iPbBCp/c4uZbQvbMt45AV1Qo0bUFiM1ipw1Hp3xSaAFENpMai9TwTSET1vLXSaL2gSj66I8z2MbtlG0SgF9DrrMZX+d7tcldVRQekjaFUdtcb5r7NDjhhaESgqETus+wuNE0NjyjlbWlGOept7qvqnzXZaDlJvOV/mMzksKgXiydNELganXpzH98r4+36fm0elQoahcTM4twOfKSJRKJbV3zEOsI8qVYKOwqD04Tilbks+xXKZ5L9O7LzW1zP8YhxK0J3WyxRMXcqFIt+lSKKoJQtZs94ipURPktyksyjxrgdWo72nhXwh5Gvt4TNtFWRXMtdtyjE3rBUkDxjKUMU/ek3lW+rZeM9QQxvx87vIwaW2Q5mgAJka8bb7fF7U+NqdgKu9pBV/5/F7KMAAWahyL85zbUrdle6itJefmkXL8qLWpcq93jbKe0gKArqGnuZk9RC8z8zu3vUdEPwngLZVbfwlBPnkDgC8B8MUIMsfnAPirCFS4u0Rb++z3APhOhG71nQD+JoA/ue2FnQIRM//xmVtfuevdhoaGhoaGhoaGhobHE8wXo8wx81fN3SOibwbwg8zMAH6aiDyAZwH8AQD/MRF9F4BnAHgiOmfm/7oI+xMqrL8D4Ed3pedK+Mbbtilea5rC73oY+1hy5rDNBFyGWdOi70uNES0EUbAOreyQqHKl5QYAFpE+J9oNGzUoHkHjYZgxsIEhxuANYIDBm0xLIpA4QxxuYp4O+cnzId7utmlVDTEWxmUaVieWoagd8Uoj4mEy8/w2iwUhaDKT9aii8dSa2BpsoWUrkVEcJX9qk+U22kvd0UQeZy3eCe1MpSWZ6eOZVF10uLEwLrMgijVol1WxLP+BbfruvMnLXWujZyx2+tq0QJT2uJLvWlnsAxkDlsbl5SqaN6GJVsqxVib6OSAff2rWprk0lXQPoE6BEG2lNXWChB5ftKY4sw6hMvaotqL7c2kNLvPmY59L15XGWGvXy/SKYw7pn7X8lO0js0qoMPSzIavTsiy1stoascvqWKv/koJT0/omr5jKyl5SiUrvXDY+I1YXKvKnx685y7E8WytTnde5/lNakrbVvcQn31Obo7q1y6Bu6aptCC8pwwvrJm237AuZhUDVVemMR/fj1BaLa4mqDmT1kcpffdfsAkm7bpPbLHq7IGmTMBwivbYYXyaW1fgp477Ot6XAEAjrBY9lWjv4GOdYI6EvT9ME5GWb4iWG4WIsKN7bJ8+S3tJRU836M1qIkdI1Z1HTYZZpr1m09FyV8rclL6V1qIxf4inbcTnWyrWStif9qLbOqYV93fCAvMz9EICvAPBhInoHgCWC1elL5YHoSe5uKQzFey+IN2wAXwvgF3ZF+EgFon3M1mQ8rJlSHmqLEUFJZ5lb0O7T0WVRmn7TPJWqpA/MgZkweIOVlfT7LF/y3elJWAlLBoE+1iNU4IAgFBkOQo90wFJIEBN7R3UzeynAlCgXFis7oCOPlRmyQblnkwlEjgmDt7N0usGbJBgNMIkqp8tDFtgZtaAyuctvICwu9GG3kodanYl3PhGMwoJo2nZYxanDkIHUqolsrnWVZvIa3UqoIyI0H9k+0eN03YWyr3PIpQ6kPgY26NgHoZkNBrXYc+Vkugfm9o7ss2jbBt135bemzOm4mCm0R6pPjNkiON6u5a+2gC8VAnN9Ql8v61bSKe9rwSdrA8WEqNu53jdWpreLwnK5cDCVPq77XEb/kvgLAVOHmy2k1fuzSgb1Ke+le0r4SgJOMZ7PKaE0aoqOcuE1p8gS5ZMhD00tHctppPEa4qwz1yjAejG+TUDqCuG11u40dPq3LRY1RHmi06jTqutQBFy5n9plKRwBE2GiFCA0PU4rdEoBTe9h1XNNVwiDOt3ZWBP7uihI9tkfKcKeptHNeS8tkYQaX1PY5s/ossjWKAjz+TbaI6nvC+sm7VjabBfr99j2aT4I/cmPylLC2NczhdHY3nXcSYk0IxTNKoDmxtJKcXpQoOap3/K8eMsr0yXxiBJXx1mj4zOP9DjdxmXNxeq52nyxbQ9b2c+kHYc1lUvfdXrkTysiZb6djDEQhUIl8isOBh6EQPR+AO8nol8AsAHw7mgtmgURfR+A72XmjwD4LiL6opi8XwPwp3dFeCUsRA0NDQ0NDQ0NDQ0N1wuMIPRdapjMGwDfsOOZv1L8/lPq+zceGucjF4i20eUAwHkDwMOaUeuitUsAkuZHWxG0lQioazQyq0LlmlwfvBm1A8X9pDktfysNxJz2aWADyz40JB81ZFFFF9IuuRLa3KjZyWhpnGt8dX4FmUk3WhQ0HajUKg0xrtIqVLNGeBCgtE4hXJ/CMyDATDVWnhmDt8mqNXiDDn5iVtblX7aQOesQENpOjRZTsxJNaQIhLAmfMf4O8ej4DLxocAfAmjzeXRv7tYYuaSPjZ2oj3mYaM132UjeLgj7hiRW1kmFiOKEuGJlXQp9vAN2GUcM2Xksb/JFbJrXWs1YGtT5fbmIHkCihzNOzsUqLh9zL+m1xT/+W+p08583Ozek16LuMqcWLKs8Jam2zBk3PSL/B6Iyb3EvprlloKbceBIvBjs3PGC0mNZqL9moo8Uoc2nJUo21J2ku60CT/M94VteVn7t1yjDTkxjmETWENQvYsMB5wKWFVPVup/GmLmORP0i5jsKbPZPkkrjrIAHJqXFYGhYVQ6hqE5JG0pCon64nKV+lVT3tPLZ1GCFW4E8cvMc1zHk2lfer45fpc/yopdAObkUal+/KWsiypVOJEpxpfaUEo7hNNnYEIyjk/WYfUOJC1w0rbmLMO1fp2GmNi39zmRKCGlCZgtOJQ/Znqe2rMrlleUn6LMJMFBSate9KzAJwPPXBD4/xXruFKi6dA2oGM72XbKNeeNQc1NeptFj6AjbPwRvKfewkurXFzkLrujL+WThU8E9bukYsT940rlYNdwlGJbYvMEmUn3UcYkmvbBulyIaUXWzVBSE9wh6QfyAe5co8OME4Y+UJpXFgsjcPKDmnhlOczhhcX0bISkAV3Z1xccOcCkexryoQkNuiMqy7K00LfW3gKZTt4gwGjYEQ8Cn8eYZAQc7eULTAOeDvpDjMLpzHvNH1Hh49RGGKe0uacIxjjQUQYMC7ahUtvja8urDS0UCRpqrk/LcvfIOzh6shhofaGJdM8DAZvsQCh9zaE6bqs7D3G/WfibajW3nV5a4ExgyrruYlF8je7YI1xyaI4E2AIVdpFuq/SKTSVLGw9IVbe07+d5KNSDzoPOp/6ffkuQhEV7+tn59qmnozLRa+U6dI46D0FsqdvQjEp6KuAC4Imxv5YLk4nkIVXvFW6gJd4auVQlrVexFiMwkxtD4wOZ6SO+klZyaLRUr5olLyHMMaxU8IchVYX75mMaqT3auTpCVTUMo+1/Am0Z8jSA1VGLSy8Sk7zOu4rLFHWv6TFRLpsSVUuvX2WbYcwUuly6lwQjqzxWFlX7Iutz3PlnJoENuR0ra3CEU/bGDBVkOl8JOUEAPDU9fa2vYTpmvR5mnqqmxOsQjrUfFEZMwl5X9KeREMfH+nuun3n84GpCyNxTJ/L16T9FH28RKmQChenQlFNCBaU9efiOFQeOuJgdu4BlrTMje2lECRzl+RFaJ6h3KfHWmyDtAGJW+bVXdD7jGS8k7Hv+lLm9hP+rjKulEDU0NDQ0NDQ0NDQ0HBdcPmUuUeBayEQ7Tq7QJ6Z07KW2GYdmtNi7BPeNpqcZ8Aajh7DPBbWKa8xLmkIahYYQU3DmTQT8VpNc2gQNucvzYCFaJiUPywHk8KQDfg2WnY8G6zMEB0ohHTqdzUcTLhXbIAUK4VJmlSDBXn0bBKFCx65VtYjd7KQ0jO1wknZ1spdyrCk4KQ2ULUgAN6PdERtGZLvZVzMBkSBSsdK48TEIArWCk35LFMp2ksNaRNL47CMDiy0Rz8gOLY4NptQR2aAVW2nZwvHBr2xWPsuaBRjHUjdBisRQzxZDN5MykToBpJn0bCJVk9S09F4VpIpyrwrtOueKKM9afpb+FTlMdP/a5aIOS2v1hzW+uv03XiNRi1eek6nQzSLJu+zZTp2WYTLeyVdxhblp7XF8v3Y9liZYXf/NmIFIfRkk9VliG1+YJtZmJP2XllMxHI7dxZKzSJfWgKSFTNSW8vwat6atBVoMSkTh5UZsKCpUwHPwQuSHuMGNhn1WG/MFzqvIc7KOKOkxjIUK5vEJQuDMc9UpHOatpK+ZqPlb9UNaTyX9uA5OBRIdV3MEZ5N5qFU53Ugm2hzYbSeWop0/WnPgnKdgMwjnSHGUTfgxmKDk26DpRmwilbLvA3kjnbkWkhPTuWcs1LP9dfyfq3PiZVIl2MNpZWhdn/O++QcSo92guA902PVDcmJSZnujhxOuj6r75IBotkYoY+NdHtEOhpI8j3mQ1tbhUKr+3jNqj+xPIs1qVKcNctxidK6A8yXfS0ETYfD5PsYR8kAAIAuHm5rTbSwR4ts2d90GZRhlNfnrPolJGyJM1j4XVzxXC94fjwoczttXET0mUT0PxHRLxHRLxLRn43X30hEP0FEH4ufb3jwyW1oaGhoaGhoaGhouApghD19+u86Yh+RbgDw55n554joFoCfJaKfAPCfAvgQM7+PiN4L4L0AvuPQBNSc6AmHcnRjnG82LDUUafN7fF82sW7dJ6K+16xD8ntOI5DnYV4zoTdaWuNx1EVrS7QM5WfLTB0WlFYhAIVlKHfpuDQDjmyuOVyaATftGse2x4KCZWo8zyjwyXtv0bNFxzZZcwZvYYzDjW6Nm3aNI9MX5w2Z8TNagqplycFRwgLbeaaGfHDOIJosRK5toRXUliG5NriKZciMbrDnuOzA2BaC1YPgfdQcewPvSwuRPFy2J4qWjKCZYyKw8egqbYrK8kHevuTeyg64sVhXtYOyt+up7gwndoOb9hxH1Kc262DQc6jTtV9gQQusqYPxXWb9W3sLE3c4eD+n1adkEXJ+dG2qtW7Cxe6itlPadOJHV7TitWtzmuosXZV9QyVXXGuD9XNz7SerS60RhFhrxnwyjXsHlsRpz4ROn8QnjkFqbrO1pnlurBrzM9IRDDGW5HDU9clqeGx73OrOcWI2qY/r/iltYfAm9dOBLZZmwOAtejbJYmB8sE6M1hmlvYfBAIPOeJx0GxzbftZy0qVro+t3+S1WCs+Ewdg0bt3o1pnlR59rNrDB0gzJElZaqm/aNU7sOuQfPuZzzLv8nfsFBm+w9ovRSq3ikv1UQLDm3LCbZCEf68Wkd3uTW9SHuLFaW9yWZhitHwqeKJ0dp/fvLY3L+n7OfvDZeJ6XlYmWsJB++T6wTXsIjbeT8+tSe4RYQMY06v1Qk3PiABx1A96wOsWbVvfwVHeOE7vJ0qXTNLZDm+adgU369EwYPNI8MIaxfWNFrc9InwvWsGk45V7ImmWoZoViTB2u7NrzXFon5OlV55J1bZmOUFB7v5hw0m1ws9vg2GyqVi/57NnCwKBHcNLh9Dip1wzq+1K1LTmHUPfx8syisg/osMa9ZdH6ROMRFKFtcWpLcq10h12WlV5PydlW9XKtW4G4eE47RTIm7PGVOeu466sWbz0PlnnO4oqf0sa6bpiUXwlDYQ/wSbfBkRWWx2HWxyuBOG5ed+wUiOLBRi/F73eI6JcAvA3AuwB8WXzsAwA+jAMFohr1CBg9fsg95ymsM5kSdUojDYZx4SHLl32EIB3/pLNhu2m9Rt2S68xho324H67fXG7w9PIMR3aYbHyu5WfnIaeJbjDSTm4u1niqW2dOE55d3MUbunu4YdbJHOthsOEuWzTLYkEoVj7SsN62ehW3zDkWNKSJv0/vdpMFR++tomyEyRAe6AHYUDPZAg/QC0IfnTIECo/jcREbFuRmdhKTCVrgPOA8wXVmch6RLJglTAAYnAmLE09wLnxCxQFWAlEBioO1p3iKURSOetUWtCcmLbCXwpBcf3p1hjcsT3HTroNZXTwOxgXtTbvGmxev45YNdbOMk9Um1su5X+CcF7AYaQs9Wzivz4UKbWjjO2xcqDvnTSz7URASGqEIihx/M4e8d53D8aLHyWKDpc1pfdoTnp4MN85m/avmLSh5tZo5o0Q/o6/XqHEylsxNmrNQcXXGw8dzwMqzRkpkQpoPlBadZnlmYcutxMie6wtK1o3FBje7NW50m3QG2FuWt/Hmxes4Mn1qJxvVP895gbVfpNPEZTG69h16YzGwxdp1STACUJ3M5fdJt8Gzy3s4tptEox2peSM9TR8i7dmnMLo4gQ5sYJjxptU9PLM4w9P2LNEDZexY+y59vmV5G093p2nBrfvRZy0+jROzxhIODmGM2rDFKa9SX7jnV1j7BU79EqdumfIfwopCTqTzGlg8szzDGxf3cGI21XSd+iU2vkPvLeRsuGU6L27MX60MS4WDtH1mwo3FGs8d3cVNu8bKDOldB4MTs8GbF6+HvJKDg0lj8jkvsvFcxuOeLdbUYWCLjjzW3k7oytoroO6/WnhlDsKsCEZEjDcd3cPvuvXbeNvyVTxj72EZaT9hjolzSkybtMF1HJ9EMA1pC4KR0HgHb9PiWs7IKal0te+S8j6OL3KvHM/0HMKYLpp3gaH8FezxjsQhijUiYNWtcdz1iWooi2E97z+3vIunuvOgkFSKhyRoxr5smMNvT/DEsGD0flSWDt4k5WkY3w3u9qukmKq1xYmSGF31cNXauO0QPKRqyH0XlQW1OsnCVXVDhTJR36tR2bXwk9VDvH606rM568j2iYqa0ls4ohl8LjSWc5fOI4bdZWWI8dTyHLe6NZ7qzgLl18zPB1cVHsDmSRCINIjo7QB+L4CfAvBmOQWWmV8ioudn3nkPgPcAQPfc0/eV2IaGhoaGhoaGhoaGqwEu9lJeV+wtEBHRTQA/AODPMfNt2tM3IDO/COBFADj+3LfyeH1eI+O92qROHEz0njPLkaaiac3C4EzaYL+P6+4xPWOANbeS26xEcxYL53KJ+YWT1/HM4gzHtk8aVQlbKAVaqzp4CyfaBIxaHu021fnx+3PHd/FZx6/ilj1PmyR7tvjf3/gYnrP3sEA4yfqcLc6jxu6eX+HUr9T35Uix8h0+a/UKPv/o47hlzmHBcKCkhbwX3zv1QQN76ldBG41FRqUrMaY/aFBFc6XLWjRY66FD7w0GFywbLprXtXl8m9VGLEtCvdR16xkxXAPnDNxgAk3OEeCjxompbkKQbCXKBADD8J5AQvGM8TljgnneeBBs3Mg5fz6RXP/M41fxpsU9nNh1uhc0vkFj/ntPfg1v617LKEbn0Rpw6lc4N6FO79EKhjx6trAIZxGduQU23ibL0Np16J2F45waJ/Q4H8vIx3Jh7VCBCcvFgGeOznDSbTKqVEaNUtpJ0ag5ntLe5HvSJkYryd6OUgpNpbZuldpEeUbKvYZsHIhnTIm2cnChjVrjJ/VZUilqzmFES0qV61K+ok2VvLz15ut44eh13OzWSZP/h25+FM+Z09GCC4NTv8A9Xk76eLIGI1iLTDyTChaA6yKFatp35drgDX7HySt48+I2VmYcy0aLRJdZAMSpSqLNMeCie2WhxP6uGy/hGXuKI+oBKCtntCqc+iV6tvgDN345jUVi+dqwxZvsPXzBkrCiBQCLNfc49ee4xx53vMEdXuCOP8Idf4zbLnyuTI+77iilUyzYol33xHjHyW/jLd3rySLlQGmsu+OPsHAOp26JMyxD/ryy6meWoJxqM2cVlbb71uPbeOvqtUQB9Gyi1cvif3f0cXym6vc9G5yzxT1e4tSvQp/3y1TnYpVZkMPad+jIwlCHTaTPiUVG0glst2JpvGF1is+98Sl87VM/h7d2A04ojOPn7HDOjFMmnPoOtzm0wdv+KKVR5ppTt8SpX+LMLWJDQ9rdLI4tgO20udI6JNp3ccST0X23zCH7WocCI2C0XIRrW8anwqrOTFitejx/cgdvWIY1gbA6ZKxcuw43ujU+/+S3cMuepfnXs4ntvgt1yx16Cn3u1C3hieAoWPDCOmBcW8iaQcblnu3EiqHbZwnNYCjdltes9PosuHJMkzqZqw9mGinrQuem0S21zENZqWfzwHzdAcDTz9zBs8d3cXOxzo4UKa10gAGMy9pioPCpLRVFHwamLsNrlMBbR2f4HSev4Gl7hiMTKLCabnptwLi2+4Y09hKIiGiBIAz9XWb+wXj5E0T0QrQOvQDgk/tGustjVxhsZKAhsOF08KUsHITbLws2Hcbgc9NqbaCqXfPOZIJWur5FrioXWpI/SY/O18deew5Pr85xc7GOZ4fke4ZKjr0WfqSzaQEoLZTiO79592lsXIebi5xmcccd4YXlazgxGywpXHds0iImo8spisrGd/jY2fM45y50WNpkg0WNBiH0jD7ztDTuUxJaxMbbJAgNasEHIOVv4yzO+y4JLeV+Hl3WY73mdSxUtiCUjNO550CLG3obFvprC/QG5ChMyIx4HhLGg0Zp/GPi0SUJcRiHDQfqu2F4EwUiJRyZuJgWCohVAr5ujyIsffTOm/HG1T3c7DZV7vY/d78zozN6mKxedd3ecUe4Mxzh5fUN3N4c4XxYYO0sBmczqqCesAUcr08ERSCtQO70J/hY32G5GNBZN9n3p2lrIQ9jPdX63JjXvB/pctpHgGGmIOgpYa5Kb9GCLfLJXrcxaU/y2SMsKIwZx6eQpzxt08MWp/fK8SqkPSgDPI9t/1defRNeXx/j1vI80W//sf9CPL+8PenjmtZ6rmlUsd/1bNP+knIvh6bm6jFnYIOP3n4zXjm6Eff85F4lZaEl4YpCR74DYx+X8H/p3gt4ZnFW3acoaV37BX7q3ufijd3d+JzQsjr8Wv8cPu0+hWfsKZZCGcQiCU1a+XPHHePUL3HHHWHtO5y5ZdoPpMcpz4RfuvcCXl7eirTU0Ad7tjj1S9wdVrjrVtj4DmvXZcodvTiUMVuXj9RvpgyQTyZ89PbzeOXoBLcW50mBJouqu+4Iv758FU+Zs0xQ0/VcUudq+6acquORQjtdEG+jsr5yfgO/bJ7Dj9rfg89efQpvsnfjXsagkNuwRQ+Lc7/MBPLzuJjXwlCtHPXcIHVSKk20EKTTLPkbx7dxbCvnkW0ox5mpIDRem8MwxPFHFvBMOB0s/ld6E14+WuNkEfaQSLkNbNC7UCevbG5EReom9TXPNKGorn2X6JupDKVfu/BZ0qGni/QxzTqPRo2L++ybmisLqb/NMM7pel5HLBuW/jAYsKNRMUkIYzXHebrY95rJ61xcL+bxlz79NO7cWOFktcFRN6Q9T/qcMGA3xVXT/+Q5jW3bIj59doKP0XNJKF6ZHht//by1ifB73bGPlzkC8N8C+CVm/lvq1o8AeHf8/m4AP3z5yWtoaGhoaGhoaGhouIpgccyl/q4j9hFF/yCAbwTwb4joX8VrfxHA+wB8kIi+CcCvA/i6fSMdvXehqq0Vj11iJUob6qJmVqxFiFr+0hIDIHu+1M6WMWoJnpV2dmc+RDtQaDiS9klpg0CMV++c4HyzwOvLI6yswyJuPi/PyAGQNDqaRqG1iEIhK2l6532HZeewUN7VXjp7Cr+xfANuLc7TOR0T2g5yDWnQOsl5HRY37BondoMV5RsOZdPu2ncTaozWBmtPUedDoGtpa1ep9Ru8wb31EptNB5/qGNt3wJOyEEVtPRGHs2IMgyhYaJwz8M7AbSx4bUAbg+6egd0gWIh4DI8NwCZYg1iO6InXxJo+3tefDLbBMsSGQSa2W+MDrY4AZ7yyOEytCy+f3sDadTjuRq253lRryOPlzU3c6oL22hX6Da3df2VzglfPT/DK2QlO1wv0vQ39sNTAiRYu5h/EQG8AR6lsJj2Dwnvrux3OOwY6D+oYZD3IYNToVepFW1zECYnus2K1SlGpvlzr20Ded4fBou8t2EXahe7XNGaG4neiMY2TNifPmrGuuMxXVqe5g5htdV2jAw/O4HyzgHOUUUP6TYfN0OF4eYyjbsDCOnzi7BaeWp4nj2jLwgtb7awxsdzovlnScqUPD95g7bpAc4lWt3PXhc3g1mUbwgFkG5FLq8OUTkb4xNlTeHVzgqVxaVOxduog4Z25BT65uBW86Znck9mrww08bU9xYtZZWnq2yYHM2i9wxx3hrlvhLDpVmHo5G/P/qfObOHML3JRN7/BY+wVuDyucDstEORV6sB6vJX9QTahGmxFo+vUr7hi9szhZHOPI9uocJManNh6v9idpo30Yz8dxQSyA2rpWWgKlPBMTQVnstPYbKt1zdNZPn9/Az+Nt+OTRLbxpcQ+37DlWps8cX/TcwYEyZw/nfoF7wwpnbhGtG1PWwLZynStTfW3dd9j0Xd6H0vPp8YxZkKzF6R7n12l8p7QW1SBMhNoYdJuPcb5ZYLkYsOxcmJ+Up1Nmwiunx7ix7HHc9dm5VHoOH3xwjFMrt97ZZN0tKWoA1PplTNe2cZaAZP0vmQ1j+WNSJ/K7dxabdRcsdh4jHQ4I1iEf5yJPoI0BOYDiM2H+ZdBA4U+mljh+c7T+BIbH+JtlHjLymzH0C7w+GNxbLrFcumAdiuwGWTtJXkvo9u+EAj5jcdTjeo1t9MnTWzgdljiyA466PrFrrhOYkZxTXWfs42Xuf0ZlDRTxlReJ1A1xsayEiHJAoihElMKRXlQwE4beZgM3YmJrCy4tJAFjQ/VqQKNKg57Dpu+yvOj0+96AnckWU94aDIPF2XqBxSIIRNZwOhxMOp9jwmbognc9na+Y583QRUFwOhifuyVADGsZ1nqYaAJ+dXGMk0UfF0sOnToErkS5gDl3HY7sUXDzalw6oHV81mSCVM07njx7t1+l/SpawANyWtXte0fozxbggYJZvDR/Z5XNis7GaVELqXMDeM8j1eCsAxyhe62D2QDL1wnL2wzTA0Cgv7EFfEdgC3BH8BbgLgysvgPYEthyvBa/x0/YQPOEC0KTCEYwDDIEH+lk3lBOt4r5Em9kbrOA8wav01Gq51J4fnV9guOuT4ORUBp03Rowfv31Z/D67RP4uwtQH8qUGLAbQlo3p8lD0g3AMLo7BmZAEuzTpCPN3gD2jGD6WG4Lhl8CvovlQ3FyEoHRxvqysUzkU/4QBAsWmp6u7jixSR8nVXY1Ot363hK8NmMbKoW9OMGmiVbakGH4ja3QLoJABGLwkPfvkAeTntF5mRuHHNTvGJTU2917RxjWFhCBFSFtjoChtzjvllgsB3Sdg/cGC+uwWgzJtb+4AzeUu50vx0vpwwCqAgwz4WxYBC+EblRenA8d7tpVdqikppuUXpfKTwkbAF7rl/Ac9n3YuPiv7bG7TUd4vT9KY5g+pPJT5iaObY+TeFCxPl4ACELTXbfC7eEIZ26BIVJ3A0XZVvO9RqAhnQ7LFOcnTp/C7c0qU0rtiyzv8VO/rReqr3uD036BZVSeLY1LZXK3X+Gk66tjsq7TUuAthd+NoqjV9jPV6q0URM6HDp8+v4GN6/Da8hhPdeuM3qW98wm9yzPhzC/x2uYY565LQpAoyUohSMe9TQAqr5+eroLiSxRdxTydKmBm7giVQ5miRN5jmgpHJYg4zGPnwdOqrC84hu17wnlvsFl0KRzfm1FZTGF8vLNw6BYOi85h2bmwcI/9jYhj37STtugZUamilIoYwwYA11u1RydXDiWhJymtOBu/5sYuXS+6TTMTTu+sYnlM53USxRsAe07ozvL5iS2DLWFxh0AOSdgJc2+Yf9gwTE+58tLGZ2ic19gAPBj0C4th6YMCz4a9vmHPL6u9v6MQKPUq+Unrlmn1S7ITas8wB2XE0oaDmK8n9YweC4Ho+uegoaGhoaGhoaGhoeGhgxnovcn+LgNE9K1E9FEi+kUi+q547e1EdEZE/yr+fe/Mu28kop8goo/Fzzfsiu+R7N6ynQf5YBqd066VZmoNvcHaWB81DUU4W96r6+bGO1UnDMUz3pukoTZ+ZBsJTBfPpCmsPOwITh2Eaa3H4Ex2Ts0cJP3yjN4gmuK1PmmCwkGbBgMA9IHucmoWiU4n2tw5b2caQUsatJWidS4pMuV5SUBOr/DxfCHnPbwhIJr3J2fRMLBa9cEM21uwM6MZXSpA8syxdhhRs0fJgkFRewQfrnsKWjGzdPCDwfCUA20IfmEwHFOgzA1j08ksIZEux9HkPlZK+Ucxvvw7YzzIEAA8EYgDhW6khErbU5pPb0YqGaYauHPjcWYXqU3IM6LNku+rxYAbN89xahhubYFIleMFRYuRClRpTAHAnTB8TyAnVlQkSoKUgVsFC1miKfig7QtmKHmOAObQ9y3HOKNmTZehQTr4kExObSnBUv/K/KMdInRHPZy18IOyEilry5x2GACo85kVO4Q9PlPeLy3PYAJHazdnJ2VRRgMuf4vXudVRD6F4srYSpbwThsGkd3vYRONdW4uF8YGWG7X0yWI4YxXWn9qjmOdwDpSN9/SZIYM34KFDT7a6IXkSj27bKj9EnGhCvTdZO87KFMDadSk/6Q/BQY3Q9xbk0RkXvUfljmsGbzMriVf0Ik0ZkzR6F/IptLWFDYdpboiTVn7XGSop/pk5b6SImtSeBgpa/3Wk8iysT+epndkF7vViORrS2V9d5QyTuUO9xUKmvY7VLDJlXek8AmHsP+0XweLkLe7aVThk0g7VuULeEaukIU4RURpApphrVXPWIc/A0fEGa9PBOxvoWeVcUsbBSCN1GLPj+B2vs0pfeookXmmreTl1Rz0GEyzKXDoCiPMER++kLPOYsuDAE1zs586Z4EnX2nA2XaR3jXWXl0M4nzDOhWWeJR9isZdCVtYujs9JXoXunTN2RpZKPnvF/qOc9QCAWfjAfnGUW78BcMfB0s4EdxKsQTSE+CVwBtDfZJhhrEehxMmc7ZacU+ZkbAYAj7Fu+zCpsyMwWcAwnA1WOaF8h3XeaDXSbA5pM7vWsdvu++joYmMszodu5yHEVxH8ACxERPTlCOedfiEzr4ujfX6Fmb9oRxDvBfAhZn4fEb03/t56VuojEYjCAs+A48Il66h6sVKBHGg2CkXBjDvu3xmfLRvt1BPMOIBpIavm0UqnZhjsuE+Ii/t6khdqTWUycTEM7w2c8TDGRLoIZWmodSRDDDZepYGz8shdCodJtufA3RXztvYEpg8t1WbhbE+TZxh0OHfjomeOiqMFIGDqpSXlQb1notl/cOPEbC0D7OEIYRLR+84GVehJvqVxIR8FI5FL0qLXhItkGbxyYGMwdAy/NLBrAvWAiZ7miBHM8jIQSzhZZYY/8nEC83Eu83ERbETYkAlWZDi5Z9JAbuLJg66gSAXvdGPb1AtwIsY6mvXFa12g1uVCEYCwkDvqsTE+tD9H4HMLpkhTKD32SBYtxzzF8hgIJpYLQcoWgRInaRPhxsWpNJ77mPbkeChSdb74CgETEPsP6UIvx4WJsCEJCmVjLQNwQbASvnpNyKmELQuUNBmPQSdaSbq/BawWFLV06t+JAhvrrlu40D5MsY9OFizewMHDGIzjAcKBxINh9N4EWhmNvHhg7Ns1b0pAXUCyxIAI3jy6MAYCzVP49Pt4odJlIxg9ZyKmEVn7le+yJ0J+E5CoQ53xsFEwkr0WXSYM+rR3RtPKSmGoVOh4ih7vlALJEgPWhTLwBh7jftd0iLTqUy4uxifzixKgM/o1MdxgQIZhrcU6Ln7DX5cEUKHTaYFUhMAaTVLyvB7Cvp0k2Bb1XbaFbXVHxGEx5w3WtsOpcUk4NcRZHWhIm5NDyufimsM2YQgIYx4vCc6FshykL9aEoiiE7CMUEcp+DQAyd0uZhE9rGVg4OMMh3nL/tAiEHAU2uTc2CzCbNM+zJzjrMZhIi6e6QlM8h2ZrlUr9EhDG2ijA16h/9TFMwpK5KD4LpeCQ/VNZPcV1CiFwlGTQEhiZO+OU5MK8o7PoOsDLNbUOIE2vo/wz3TOxyH2oVOpNqodAu2PAAt5yoHVHynspIHFFANB9Wpejd2b6XBrXAGPCOnDwPq2brhv8zPrhPvDNAN7HzGsAYOa9PVlHvAvAl8XvHwDwYewQiK5nyTc0NDQ0NDQ0NDQ0PFKIUwX9dwl4B4AvJaKfIqJ/SkRfrO59NhH9y3j9S2fefzMzvxTSxy8BeH7muYRHYiESj1ITK4syE9ecLYj2TVt7hHJSXt+GMZz8PX0vpSeleVRPWOuT5oUI8D4ebpg0TKL5gah3pmlA0FBEPR4ADyZKepddFLagma9rpsq8ijYnWZ6IMTgL5qBVFQuN1rgaYgj5Qr4TMQwb9J4nlJUatm2mNhTOljLqemfjmRo+HCqHTrQxPHqa8zFPRnmj0dGT+qykK9V1NH2HDZcG3jJ4YUA9gQYEC4iPVhGPTJuXNE/Ry5w2yVfNBUnjF9uap/Auj1o2QmhHid6g7SVFHepIgpUREIsrRc01s9TnqFm3hrHsgpfAIZapMwwfPSDBjeWZbf4FgqbME7gDqAPYYfTIp5SGmc2jKJeqhW1SRqKJHfvTxHJTez1GWBsfjAEAByYTqI8c6RSSuLxIlZZPfS+bEhXP1tpglr5cwzr2V/0wT8YvYxhd5+E95+eYZIGHNmAMJ498wXoTPFYJrcbyeACstgRvwxy9K4xYEk+w1rD0aapvsp5z6iBIdGGxOjFgEA+upajBVuExj/eEYimHMDs2sGQzRw8lnUx7watBOxZwTOMYqMZMcchjjU9WIp0XolFDb62HV78n5aro1zqP4EibjOOHj3VrDcGZSDMkm+iR2iHFtnlELGpyeGZJX5YyyNIyA2aKcwql9PTeYU2jJUs7fijPrdLWSe0IY1t8c79LT15yaLJo5YN3Mz1/FHGp/p9d3kMBXjo5EhjrU9zQ81jxKFk/rhnKdDHAHvCQPh7mc3ECoJ0bALGMFeU4jC2c2tQYrmYu7JNHebBYVxQDaRh7PbpFpIqKdZQAWvhgjRGLWEmJl/waBmy0qnl9j0Adpzk6XSvXAykxCM4UVBLZMBKzoTZ/M3JaN8U8RmbHHJtoMl9Fi5KksfaMMHnG8r1eYAQ6Z4Fniegj6veLzPyifoCIfhLAWypB/iUE+eQNAL4EwBcjeLX+HAAvAfgsZv40Ef0+AD9ERL+bmW/fbz6u3wlQDQ0NDQ0NDQ0NDQ2PHlxVdL3MzO/c+hrzV83dI6JvBvCDzMwAfpqIPIBnmflTAIRG97NE9CsI1qSPFEF8goheYOaXiOgFADspdzsFIiI6AvDPAKzi8/8jM/9lInojgP8BwNsB/BqA/4SZX90V3hguMIrymV45WV72D4vTO0E7XBextSVovFa3Ekm4+jl9TaffRC2M/KUokoYbU22PhOmRrEQhbJPFW7pSzfINKItanv+cszvV3iDy3EP4wTolWl4izp4WzaFoaD0xPFHmUrWm+aule25PlDxj4/4y52NYdtwQzZ6iM4JouaDK2TIqf9tAYq1I+Tdg8sExgDHJAjJaiDgLUvjPSVkmlqNtEG0kcbKsjMo2yuqzzuOWh7ffcwgWHms8PBgGYokMbWMhljhtvRkM2EQrkex/KuOQdEfrGBkpm7FQeMxCOh9itBLVNa+Z1k4MQtKWQWOZVHO+G7LP0MODWO3TYJ50i/Gl8V1J4lzYtfu7xq/SEq21rNq6JRt4TVS+SR7K/q3fD5pGHw3PYssxyTkCQ/Vp7LZGawvvrIGPYxuLY4RYKJx6R8epw9WQPI+OCcJ1E0OpuZwxwGgpAsIGeiYMFBwhJMsHaKvDh3L/UC2dElf6LXFCLGfjxna5F3MGgIu5gmK8qr2IJUOngUN/lHe8R1G3NuwpBWApuPPvjAczJxf+NXfIWRnS9v07tXG7dqaKOMrxUSPuDaGLZSr1UTtTrcRF9hPNQax3Mpc4F6wsTIiWGlQ6cPzYw4qaOUDQl1W9yhgExL0nZhx/yrLV+xNrlmexEhq1dkDcRzh3hpKJlvEwNoyDXnLiEK8Q6nW9bU1VWony8WvcM+7jCxTnCRjCuOlW8qusV2q+lPk2sReitTRkXaxLPM4fak4KGSjST+q2QT5HZVYiVU+e8mdmrIG6bMaykCzNlaMeu68n+PL3EP0QgK8A8GEiegeAJYCXieg5AK8ws4sWo88D8KuV938EwLsRzkx9N4Af3hXhPhaiNYCvYOa7RLQA8D8T0T8C8H/GgR4cNII5lfda5Mxt0hUqSEn1ks3DtbMssvMVys20MxNhuSG59kzNO48OVygqssFZwjzuejy1OB8PU4yLiBC2nNtg0nkbcwcp6sPsJD2pnFUZhHIJm41r+ZDPIzukSUnKadwcO53I9HPjX0gjgBSf3COmsGkyfjfxTxY21hA8B1olFkDt0LOS0igUMY29JjQVlvbSw0WZcPGs1KeOv+bMoFbOtU3Ls/Qk1XYW1qWN44dQFssN4zWPUsBUoGUVVtmmSD1fS0PNOYe0o3JTf+3MGkmfUIG25XFuwSceyHS6a8/Js3P9p/S+ls5tYemPY3plrCjDKgWCUnFRS9cu+i+AyRgIAKtu2Nr+yrTo+9vGQpZyQtyAWlGAaP54bdFcy5Mub+nH0pe2QdqviWXpY/rEU13vbHK4UAtL2keKlyV/owBmVDye589Oq+XXxrICcW1tW09POmsMqUy2QfLlovMcfU3e36cd5XnSAtvU69xU4TZiVBqOY4S+pvNWQtptjWqZwgdSeYoDy8z5B9R4RQzPgY7NcSyZS6+8PzeX6GcnY6EKw1I+38o8L9g2HpdxpTFeUTGFfihztPaiKPNR6fVVj7PlHF0eyjuJm+rCablmmFOK1sLVYcg9OTdNUHqH1NfLNiL5GeKhpvK7PNfKST4xHevKbQPisMTOxKc/qwoDNafV5lsJrXzzN7d4Gr6qYJ46jrgEvB/A+4noFwBsALybmZmI/jCAv0ZEA4L+988w8ysAQETfB+B7mfkjCILQB4nomwD8OoCv2xXhPgezMoC78eci/jEu4MGhoaGhoaGhoaGhoeHxAV+yHMfMGwDfULn+AwB+YOadP6W+fxrAVx4S5157iIjIAvhZAJ8L4G8z808RUebBofARviO8UfNAhXZFY06rJRsJl92QztQRLYp8P7J9OlkcAMozcoJGZLSyiCahBks+uW8VlJoWre0RLUSwqgYT8cJ4rLphch5IRx4DGxgfNBtak6O1PJtCyyMaHX3C98Am0dhEK5ioLAgaj6UZslPegVybNKhPA840Gkvj0sno5Xt9PN8DJBqRvGyTe96KhaLUsGsN5S7tpCBYEbaf46ShNV67rENlvPpT6EHEhGXnUvvT1hMdX9KezeRDpyNEQnAgGAJMNwStlQludrUGLX9f3IhOqTE1bZUQKEqtrLRhx7m1RixVC+MyLWJp7QGmbp09E7p4RsxkY7VygZwsMAXNqeYauiM/seDWLJqywb4jZa2M4Wm3v9oiWmpWB2+w8R0smeCG2dn0rFh2h+jevtautBWxtEDKM+U727T7xgQKXSLGxbbnvEl0KY2JBrhSttoqotNXalVrloSybrK4Z3Mxpk2frVKbF+bi0JY5HXOp5dXPi8Vgrp4NAkU3fB/Hgl1jlR4vNC1Op7/MW6LURHoXEQe6K00t4WU5uKwc4rU4ZpTXgdGd+VzZSn5cdOCRjXdFPsrvOo1CmXLAZJ7fZq8S1+LlM9panac3t2zpe3Pzh7ZelWnvrM/akn6ijNsaj4Vqq4YYC5MzMISVMYZhZtuZPK/XMxKWAWNphzT2r9Qc4NmEeIt4+jgXlAwTcSjSRxf0gzfpmji/OLJDmuuB/OwoXRay7pCxNh23odcTcX2jx/30THGvxkTRY/Wx7RObRqdrYJPlxzNhMOP6yMdOZqTclaWbiLGQOo/zxI1ug5Nug5UdJusyKSu9DtPrwRDPOKaW862MHV2s36xv7DbmXkHQg6DMPXTsJRAxswPwRUT0DIB/QERfsG8ERPQeAO8BgO65pwGMZmRr6tSicdCR35KOscAX1uNk0SeqmYQri/5nFmdYmZE2MngDh7CYkU5TDgaJ3iUdMTbmk24z2wFLwUQWR1owAoCTxQY3F+uMQ60XYxIuCBPKnAwqUjbazC2CkIuHex0v+lQWetEt8Z50G9zsNmnglLCkLEw8rE/KTPJ2ZAO174ZdYxHf7dmiZ4uN7wDXwZM64FAJhzr9LItdzC8s9p2IBcaERWYXFzf6iblJdI4GUBPCpoKQfmNcWHXWZYOqDjMttuOAqOunlpYyn44RhGo7JGG/xChsSlw23dMCeymIAjnNIwtTpcPESWNhHW4tzrPDIBdKOJubhKU9H9vQb9Pzse3JRJP65MwkI3kVrLohnXciaR68xVGXT5wdeRzbjRoTLHo2WJkha9NCu1iaARY+jRtr12HtO3Te49wtsHGAN2NZSjk7TwDyNpPK2ehNV/OLudpCTtclgCSIA9Nx1DNNzlTQ5bjqhiTQyr0gWBGGyPfXQlHZX108bFHac00omvOWNN3Hqe5Zri6IUz+exDGWa1AG5eWwsgNW3ZAWeXr8BIAj22fjfVqkUhjPERdOTtWjjFGeMSkDGav0d53OmvfU8FsOfaTqfpQyv4La3JjaXPYcpT1GMB4GNBmjSsEu1bev50XnZ8wHIG1fBKLx+y6ROGDZje9MKLy6X6g0Z/nmbUosCZty73M6fusmNN2JEineO1n0mdCwNA4n3WaiiE3hIFDBkyAQaeOIB/8CSMK7rGX0muGZ5VkalwQu7g+8addYxbWQzOk9WyzIVa+vfRjPBm+xpg6bWN7Htsex7atzvYasDRwTVmYY42BK42jvLdbeYvAWnXFYGZe9L4pUof7ZKAyFtZtPfVXmBkOMNy7v4cRsYCl4k5S0rX2X1ncS58YzDCwG4tCfDdIhy1ooWlmHlR2SQvXI9njL8R08050qBXCIa/BmEt/G+6mSvRj7awoVrbCRdkqTEf8agFE9l+m64aAcMPNrCNS4r0b04AAA2zw4MPOLzPxOZn5n99TJ/aW2oaGhoaGhoaGhoeHqwBd/1xD7eJl7DkDPzK8R0TGArwLwf8cFPDikSK3Dwo5awGwDMpBvigSSVyU5CRwAbq3WeNPRPRzbXnmtYRzbDW7aNd62ehULckFSh8HaL3DuF1hzFz6jdL92HdbUYTAeG2fjCec5peYtR7en2g8fNAQDG6xdh4E9BhLnBsGD2+gJCHj++A6e6tbojEtayp7NxBysrUPjaeqjiRbAxDLUx982brbX5nqh0YgG/c2rOzixm6S5T9oiCtoiyeNInQsakRurDd66eg0nZgNDPmpIFjh1y5Tung2gzOU6jdoioTWsJdUk10iOWr1ttKFF1yf65FTrGTe60+gNSu5pzKVFns2ObahoSBcrh6Mu1+aF8h/TINoHrcHcBq0NNcR4anWOpxbnoc0ri4y0jWTKF5pPdHmYaah4aqETioCmG3omaE9XnglH3YCjrsdTy3M8u7qXLLOhTYQciQYNAFZmSNpL6TM9G7x19XrSiPVJi9hh7Rfo2Uy0bpmlqFJ3N7t1ojUka6fxeH51J2k4HQyeXdzFidmkeM/9Aqd+iTcvbqc23fsOa+5wYjZYmT72U4tTv8TdYYW7bgUMq5AuyukjgRo6Wjh1W0nlPENVmmt/datkgLWc6GWlZTTVofouQThv8Ey0ngmkjAdv0MFjgMmoWJJOnUc/01d3Yc6DIhGw7FywPNLobU5bVmvwDCwjdalsw7eW5zjpNslZjYyrG2dx0vW40a3TPRnTDTHgAE8UaIdiGdmjDEbrEAC5ljJZmoUitUx+Lkbt+dymfsnvWG7z1LDyPjNA1mda0JImxzJOewPvC+tQmZ8KUl6IwdFDpFiNdjl3MIYB6+G57iyhZBKUFqFtFMVyDO+60ZKvy7mzDk+tzidOgML8ZeK4SomN8fTyLHv2DctT3LTrYjy0aa7XzJTwEjDAAJEqubAuzdVHdkhjvY20u7csb2NhBngOlF0PSmOoXvP03OGcw5j6bBfGQQeT5m1ZC526Jc7cMllobnYb3LBrPL+8jVvmHIY4WWBO3QqLtA4aLTPnfoEXlq/BguFieiSOM7fAOn6+cXlvYnGSPrcyQ7KqhbE3t2itfYfeWNy0a7z96GUckYzjHc45jOOyHjn1Sxi3wEaPtR7xDDAeqXJq3XlzucaR7VO9Pb+6iy+48XHcsucAZH3T4dSvcM4dTt0Kp36JM7eI5eexoQ6DZ8ADG7aZt0htHXKRDk7EgcUQmRaS32tJmWM8MZS5FwB8IO4jMgA+yMw/SkT/Agd6cBAcL4aRu61M4tqUSEBw8RwXkq4YGIdIEevJJpPmDbtOg9GpX+KIQqeSzicDx6AX6IV3q1vdejTVxkX+mVuoRWVOMQvC0EjxkbCzhTBxEL68ywSfcqDU5aCpHbVBWQtCgxuFjvO+w8LmgsHN5Saamz1e3tzEse0zypwsQiUvG9dh420m0PyWfxr3hiVuJaHOpPxvvMW5W6B3NhPSdOd3fkrF0JPWzsXEDAjA2Xmon4V1iYZZg56M57jmWhDPXeOWi8M87NP1Es5TJuhnz2M77aOWFj3JOwDrocPGhqVCye3Wh0xqIWLw+V4Xx8rTToz7xrJPZntNrZN0ywLw3maB3huc9kucDstE53jL0e1M8Bi8xTOL03TNg3DuF4Hm4Re461Zpgi6FJU1pTX2gqJtyH9prm2McWe3FaaSzLhUt7PX+GDfsJvVvoWu81h+nCVhoHgDSNUnXmVvgdFhiPURFirMYnMXgInW2sjDWWCzCPjc95jn1juPp+9sEjWUXaJrac6WEq1FSNZw3ePX8eKsCoaR2SB9OJ5E7yS929lW9SA5fKk/GNN85W6U9HLJYnRMAdF5tbMPlXqC7/SqNfeH5uCh1Fvf6FW53R5O9mSUNWa6VQpAIDXLgJEPKAkjulHnMW14oHEpGUcrMKu6FNX6yz0cLLvranAInfIbnvA+HX3pPWC2GSdhawJB2nOo3jt9ZnipIe5tSfiL1L87lRAzZW5LVfnqBYdIekjyPNUFoG01R8p6VQ1E2y+UAE2n7GdXWWdzdrLI9ibofaKXenfUqjTGS/3O3CJS5mT0waX1Q2b/smXDDrNMC+Y3LoPAV2q5nwpo7eC9rCKMEC4NP9k+N47C6d+qWWJkho5itfYeeLc7cIpv7z90Ct80RXutP8FSXC3s9Wzy7uBvG7iiQuZiHl/tbQRgDZXHo8D+xvoUFjR449TrqeLVJdf50d5YJTudYAACOqU8Cioj1oVxMJqBJ+cr6Tit4y33e0obublborU00zcEbeHwmnulOZ+mGZ26JtQ9bBmRvaW38kDm31oZfN0fZPngp62uJJ0EgYuafB/B7K9cP9uDQ0NDQ0NDQ0NDQ0PCYgAnkngCB6EHgrA+SdE2TDky16SUVhZnw2ukxemdxvOjTJsRXzUna0Hhsb2ZOFTRNTbTRegO3aGw+vT5J2lbRlp4Oy4kzhJLKNlqdRq2PaBc9Ez5xegu3u6PZcHR+5d6Y7vFesow5g8HZXFvrCRvTwVrZLBo0c6frJY6XPazxeH1zjJUd0lkG2xw0aM0o0RJ3+2WgFEatUWmpko3Wc5rumgVI6huIJlethdyhck4HyLLFeg0M1qq8jxSimrMAKVuJhnme/jOnFdVa+763YAZ6G+gNouXN49Pv0uR7SW0rLVSfuncD9/pl1ubnznyQttU7mzRUczTFO+cG51030YjWNOLnxsNaj3ubRfCqR4zbmyMc2ZHyAAAvb25kdNZ8Y+xx1XuRPldrToOqLXjy+2xYoPc2Ueb0dfFAJ+3g9dL5QtwoXNt0L2kXi8LZsMDGWWyG6LnImVyTDowWggJEgBss+t7GAxrHNrRNk11rudJyTmNZiZciG8OdsyxoS9R6sLA09fJZs4hKO0n5dSZYHbyygmBMe2YB0tYIUnQQuZb1A4DXCwzWw5jxPJ59KCR3zldZG5Z0n9EieXKSa7o/1LzZaat2SYtzzoQDojlahuRQSDWuIVpToMtGg1T+KfwxMc7PlrCdg7Vd8B6oym7O6i3WnzlrIsd0ynN37x3B2DzsMSxKdevlgGav8lODpB8Y6XEUDtIkfQ+7xnbCxhGcI1gbx8/YnmtjYc4uQDafZMHr/qjiPDtdoV+4LB4JT/qGMdONECVVL1HVFf3/rFtkHjjl2bkxWlugXt8cJy91G28zT2+OCYvoobPmIfb2EN6tObKpvTM6Hhg/w7Med2mF1+1R8mgn1r07/dHEIY7kS4//ekvBxgUrioRdOpWStYbcuzesMqcKes0WHD48HSxe0XI2eJPRrYW1InnaRt2Xz9M+sB/E2h4sZhavdceRtji2Ec2MkTWkZseUY0y5doX6vLdeJmbL9bcQPeoE3D8eiUA0xJPErTGzB+ZJo9CLbD34Oxca3lmkiMmAtOpWaUBJHloqi8bSbC3CzNp11dPMtavwUkipDWylkHDbr3BmF1l6dJrm5puSZiX0nGGwGIa4MHEycYVne8MgMwpERIxNHwSlu8Ynqo12K5o6sh+pE04WPjFxZ+tlWqiIAOG9gXM0pc0UnTpbPJX3aguJGogV/wbR5TXAnsHewnuGcxS9NeWejfSiqlwIpIVOpJWU6a8JRCUfngEMCAsUZzyIbHVC3QYtOOq2Hu6F8h+8mbR5oH6gqlBA9MJuupggDMTonfZIB1W/OW1GFjzG+MDDNxwG9c4ll9xA8Pq1NC6jAuj0mUq/30WN089IHgFg4yx6ZzOal64n7QZdewCUdq7LL3mIVPEMUQjqB5uEAulzqd/VFo1xQRi+B/qQ782UMlZpX/qU+zG8cRFNxPDegj2hTwLEKODIq2ktKGXqx7aeL7jH8sqilEWUM3CDhXcEP5hAj0gnxNfyzdliXy+Ux4dUImW8J4Z3BDLhedJp2tKXvQ/Cf01wqC1MZeySMEqhMClIShqkJ3AUFlL+NVXEhz2vY8EX2Y3lEQpfl1OMzxGcDeO3IRnH63U0jhU004ZiPobYTj3BGwMyPAqquhocgQcDOJU3jvnR4RbCXCjkkKcsb4bH/Am9UgmQYyXG/BDAzsB1PuS7KML6vFEI5XlClTBUvOsY3lMq51JAp9SX5oVRIMybxuRKsE08DLg23gD5OkTnT8adniys8TgbFmFvpGq/4XiA6SHxo1Diq0JYrQ9ohbCm4svzNh5RoNdoej/yGJa8M8ZdExTEq1ttvXc2LBL18O6wqiqoRGjqyGX7brRr7zI/aS1TCEClR08ihvOUHazeO4t1100OjN0Wh6bGeVGIF2OIBlFYY+n15ZwC9kqjHAevKR6JQNTQ0NDQ0NDQ0NDQcP0xcyzitcIjEYg8E+ANmHPKRo1iJLSwmscb5wystVhHq4UlzrTn5Wa10vJT0tL0uUE1aAtRlhfkWh5mSpQ20UYCFmuKByliqtEvtSZ12gth03dwg8HQ21GbJ9xNRtLYseGgoYua1sEyjA1lve5cpJZJ+KNFQOJLWvBS+yba6VKTiPyZ7DtxeHab5oMB8iofRVhzWlUmBgyBPYM8gw3BG6X1JW0tmpYtoKgiPKZx1xkqNS1OoNMwHImVysxq3MvwJM60UZuR/PonJacPaR2KNl87S2OkmppkEZhoqIo8pHbNFCx6nsDO5Ja7WPbOhDZFhrE2HKk+0VJB4zljc4csltrTMu06PbU+pp+Ta4MzoxZQyjfGpcuopAyieFbGAqmPvrfwvQH3Y5snT8EaoBOmrACg2AeLjNfoO5N39SOFVRQU+rRYXQZPMFHDSJH+o7XaJVXVu2DlKdMs1gKx5CTLTLRsOWfgNxbYmJDvkkpF49+0r1IsC3UttTUVRmxfHMMhoTKltOVpTNESw0+P5UrvZuOcWDtj+9bln2nyozUoG9/ib5Ly0+UQ80Kqr+hsSh7YAJTKA2Hs0uOZI7BlkGV4Zekv64QI8C53eKDzAkSLjzNAr/KhhuEUr4kJ7Qk0hPyRx1TjK3kgim0wvhvzFfa503iNMQ5w5TyVpZfGNA8MHmg8EGSun+gxqex/KJ4Bxkwna1S09JmxnMXay4zMiibWSh1FstrFcV5baHedswjM06IcgB7jmLUeuolVRVsTACSKnHyvrR10mgFkFiGxTGkLij5oVlvZASSK7twaxkTrysiSGanaOh16vUfEOFfeMjvjc4qhKiO5r/vryPKZWoJKmmMqG13wHJx/eD/OFQPZjEZnIzOmV+Wm4yhpccNg6+wZ5O2oZLXs46nzKoKahaihoaGhoaGhoaGh4YlEVBBddzwSgSjsD4gKK6akWeCKJmW96UZNGDBu8gSCptqZxLWW/S16Y3t5TsfcBvty4zkw1WDo9G/jFY9ueHPLVtA8TK0GOvzyZG/huQNh4/6wsWBnwKc2aPNKC41opk3UQkbtFhskbrp3FLT7kh8pV/lBgD/rQgPXmjXR4DLBnBuQ0sqKVjfFz0pTaDg8z/lz0MGnA4LGfKT8EKKWDlNNM1F4icSaxcHyGDWxolFl0mWbW2b6TRe0hTWtna4rUbIqrb2UG8W0+ORuVtTFWkNXr+dUhkyZdYh1AcWikU3dob3LfiVU29R63cE7O9Ugq/gkDX4wwKBOKGFk+wiyQlBtig2D7dimZJOyUf2xdDJRah/l+xwyrV7NOsvB3fww2ApHe+xLUuaZpbnybL+Jrm2jlYDPOlBPMMOoOc/oAdJ0lBUgDDbxj6JFZ9sGddUnkqWXiv4i7V00/SY86xH6ByE4OiDjQSRlg9SGmAnu3E6tuqawyoglJmotxTpGpxamx/yYkywFsQ/IsWQmlJmMB5kmn6kYZ1TepYxjf097BpPWHqlPbrU+S9vSlk+x/hRJSeUv5abSRtGCEqzZSFagMYDxc5IaQ3H4DP2GQDFYBoGKvMRxxXKsm5DfMIaFsiUAbmPDuKXqQfJLBPC5Ba0NTK/LN861sV5kjqANoTujMKarfEm7DtYgCn2exnfZ0NjOJTzIGBjrfDCh3HQ967rRbYKCtR+EVNaSNy7bz5z1SGPS1yi/LhYEz8Da5q8ZHudQVa6I6w1QaAdEDB/HYbESOWMmbJAsFVvGO31f72nZtjdSY25zfrmXs3YEQ82aoi3shpCd71OzXAHA3fPVZK+efk7vz0p5LeIJaaiXjziQAaDSW09/1kW3jBNpaI7WIkPjviJrPMgbrPsu7Fct5g9Z62n05924x1TP+zK+xvGcKFimZC/btdxDBDTK3P2CY0NJHa/yTNf5wFKRTZlEWUfP5laWRaUBE8MwgdknYUSbf0vUTNi6M5pitN3WaIk4bC43PrxZCDbyTC0M2excu9d1LngMMoA7InA/egHKNvLGRcM4kCNb2LNM9Grj6uj9KX4sfBQSVCGk8D38CiN1pBRizPiwpIOXPC7Mi7gAyHmuk4XWmH4oagmmEynyPKZFY0gECACDVdmOC2TbOXiywTlDpdyzyUuvPwhhwq+AY5zlBnppi7qetScpY+ImaePDgcRFsdTae16oY5q7zmNAXbhKAUSYzoOluuU5z/niWQ3sWR1IvqIg5zNV0dgXx4lVghvzrpUhc5SPkKR6P1xYN6F9lqg5Eqg9ZzsHihRKMoBbObAx4C4qIBxPhYJYJlowKhdxQVGA9J5sVueZ9jVp22Xbj3nQC3gmju2G83dlDFy6oFApFEt6safpYwBAXahPPgJ8Z+r5L/NuVH/N0s/1fHFxLaVrvEa198t3arf0MyKsSd9VC5uSvgoO+QgdLZQt29AGOGr0UrRaGOJp00jNjOJYp8op3K/ki1EdJ1J2Oh9vFi/KcwsPJk51NnFkoNvlMjxCjgDP0+KU6pb0ixAtQlBqm/k7AIDOgyHUW647aSjfIwZ3mJkPOP+NyjNZBDPPqPQSAbzwGbVQt9nMO2I5jAKpz3lPcQwHZO6vjd21tU5IRxwPYxk5n4+T+n0nc0kRxmSMjHHv672stjZJQgZCOxKBxel2GfsIEA64HZyNGfWz6yV93WE8kNfNd+dw3+cK65rgJPRnPbzMrbt0eqRMPcczMD3g2cBQEMSc5zjDjeGYuNbTyyUT11Cza4r9quNagGTsuOaY65cTEJElon9JRD8af7+RiH6CiD4WP9/w4JLZ0NDQ0NDQ0NDQ0HDVQD7/u444xEL0ZwH8EoCn4u/3AvgQM7+PiN4bf3/HvoGNmvJR66w1GGmDnvFR6paN4YDhirZLhes9gpYGyJw36HM6SlPvLjPlnOl2DhQ1tcZ4+Oias4xjl9l8+jxgOx/UJyvAG5NcwLLnuqawprkrNcootNTItY/VjeALH+gS2jKVBZCnI2n7ahq/LNMzYe3SllfCYkakpvDESiT3gUBzAHt4UlSRmaqhIh1BQ5+3xarickvzKrW/xnBq65KQiVZVaY7jlSwe5rBR01qGJ58sP1mbmqTJYzQTITqrgKq3olBKTWlSRY5WIo59QBTEJUVWW4tC+ivtuIJaX7KRKuY9be3TISrOyl0/G8qfYZjB3sAuPbxh8BD7myUwMyaWWVUuXLZLrdVOVI4t/b+0GhHyMKh4Bqq9S7RZGHE8je1h4v5YhT2xRBgGrAdW0TrgQv7nrWSVvNf6qtIsp4B4en+bdr7E3O3SykvSzMu5RIcjliFtLSKMVD7mkXanxrY5V89TBxnRuqITrsuqBEvxxHFbzumZWXxQF8ZoqTPENjvJaEyHJwCDWtDMjMWc3lHpnVgEizi6sc1t3TQu+RaWQW3O2NYGdsypZV6yshZLV82kI2HPxM1qfgn5C+uQQKObpm2OzlZ11sP5/GFIWWaUVQbYvaaoHYGQZZHGcdFgdDhVuoP2qlI0e0bSZUjFZTDOZxXotaBDPkfoNJUI5ZKv/eZwv1YinWdTWOXC80hrPAnbWo9wspIaR3SaVJ8njG3oWoIfjBBERN8K4FsQTjX5h8z87UT0dgRZ5KPxsf8fM/+Zyrt/BcB/BuBT8dJfZOYf2xbfXgIREX0GgP8QwF8H8F/Ey+8C8GXx+wcAfBgHCERA3hFK07J0VkJcsEIaG7K/aZjhLS0UyUJs9Gq3/wJsmxBTek0pr4vJduwoOyYDlYe5BbSYZgEXBI3oSShQYNSEN6E3ob6AonwNMkakZve06BsXMDIpThYFGnpyTIffYLoIyxI1k/EZGo3OG1XyWIO0kYwWZBjGqyzsOTKF9S1nv4HdE9NseKk/AFAUv3LxrKl/Eqv2UKP3KBk9IakFoAzCCZbT9qeRrjM+P1nolWUe61ZoW6EPCl00CCvSzymGIzQ6p+IqvU1uQ0ZrzSZgysqjBi0MTSgpIpSSD32rM0GQsLL/BPFsle3jR7XdykKv+vyeYdA8hSx01Tplk4yHgVH0yEpCUtvR7yHNeGwpCEU1JUyZ7pmxZ0JDkrQX7XciGAKzdJNq0ZX5l8WHvKAVABqxkbJEJcKR4ewMorRfUr8neZhbANYEh2odpxdmA5vQdvUkKh2NovJK72GrCMKMGJbXipB8nxTr9Ka6RUHR5uoziUuYxpEyM/o756vYScYPvD4H1Y9IxVdthzvan6Acl0UwysaZYs6oCSdzZ9J4NQ9nwlG8Ju/W4Lb0V0NTxW8Zztb0yDsI+5FEqArP6DlrHpNtFDNlcL/7bA4VivRcBSCNrfnckTdYI3RBT+N4U0uLStN1Bs15+rxoeERfjiBnfCEzr4noeXX7V5j5i/YI5ruZ+W/sG+e+lLn/EsC3I/cj8WZmfgkA4ufzlfdARO8hoo8Q0UeG26f7pquhoaGhoaGhoaGh4aqDi7/7xzcDeB8zrwGAmT95KaFuwU4LERH9RwA+ycw/S0RfdmgEzPwigBcB4Phz3zpbTNraMlEcZVpuLixF26R8YFTrcDJ/smixd2ik99VM7NJW5Jra8dmL+JuXTeHWAkE3Y8DGj+dqaIpHeonTuxON8oz2kYDxfApt3YHSmsrZDdHb1dZOYNT9rfme0XYWecmpJ/sVZOnooHRooDdQT6wnW1A+ta+mR1sCy7SMViJAW4rmwxrv5ZaiXHtFujoZmWax1JyT0D9inwua8vhvpt1km8CBzEo0ehYSj4ucad+kDEoqxD7QNI/CJpDSlV1V5VCjzYVrsUQMYMgBZEbvZJkWXfrJTOLKNpo0/zPPzoWBMZx9raGlh6NwxopHOKwLSaOsy6ekhconEUbqk6HcKj1DHUxhFP21agEq49ZhQLUJmnm2fG5yI9fKZ+0dyC096Zoe+6TdK8tQrf5jeWylROo06bIpr81B6pUK2m5WdzFtFDpl8nil01ymQy5b1POmwwa20CNn8inWk326dy2cMsy5W4cYEDLrXEgbleWI3e1P0+bG1lV29vylcr2j72ZbCPTzNepasY65H/ZSxtqJcZVnDW2bi0qLkYQpmFtDZeNw/L7rXMj7sRTtYyUKD6q08Ejnq68l0qgS0hippMkrHW9xsnCdwahR5p4loo+o3y9GeWBfvAPAlxLRXwdwDuDbmPln4r3PJqJ/CeA2gP8bM//zmTC+hYj+BICPAPjzzPzqtgj3ocz9QQB/jIj+AwBHAJ4iou8H8AkieoGZXyKiFwBcSHor6So1+opg2uDmaTF6b0UIM6friGB00QXYLpS0uTH9WviTZ2vv757wrUXYH+LF3TPUBFZMeMDWCUQP3dosXC4Y8kU0sjgzD2XVhKvM7YO5BZb+vs8CUQRgfUkv3LVQhDAYl3SxC+E+2lRO50qprj5b5qXsQ1OvatPJWaZlvVDk+M6cUFxLb7ip9m2lSadcHND4jbZ7mpyEn+W9MrkAWdnnZajDLAWB2jikxxhRQHAuGElh6QVxNVGot+FtmBMYSsWARlH+1fcLL4bb0pLdMqPra+g9hnP5ryz2D9oTVNZ7uRjVi5Pq89uFo9Te4yJsMuRI+yeMY4KMC+Ueo1oZzLWJubFMlxdVaMCs+qV6tXZkRZ5+EUiKNOu0SRgi7EU32alUtrVrnX6qfJe0pHFNvVcbY3eMnbMCz0XG3BmBp0qJn2l/NcxRmsuxWsdR6zoAqvt4ZoUjTL3ilth3700KL47RtX3e29Kk9yLJWD8XbykUldsoSswdal/eT2nBfnJ4CZ0WqoSbxUFjfefz7Li2qK7NUgCXuw59WCCgRpl7mZnfufU9op8E8JbKrb+EIJ+8AcCXAPhiAB8kos8B8BKAz2LmTxPR7wPwQ0T0u5n5dhHG9wD4ToTC/04AfxPAn9yWnp2UOWb+C8z8Gcz8dgBfD+CfMPM3APgRAO+Oj70bwA/vCquhoaGhoaGhoaGh4TEB40Je5pj5q5j5Cyp/Pwzg4wB+kAN+GkFF8ywzr5n50/H9nwXwKwjWpDLsTzCzY2YP4O8A+P270nM/5xC9D0Fi+yYAvw7g6y4aUM1KBOTahFybAoj0LdrfXR5MsrCjtkPTdOYcJJRhXRSZXn6iRZHw9wxL5V8cRwgLZtRcYkqdk4SUmKE/SVoTraagZwSdB4/a0xjfznyoMHY+N0ZUua80j+U727Ajv1mbStawA+v+ApqemnW0bPcXoVnqcESDpS192oKiLUW1eh91XpWEzFkrZikkuadJ0b6ZSn88pO+JNnOuv2VJninTkjYihy56BMuK1xvItfesaE3YbhE4rBKnNLJck30R63ZwpqKspqpPZ89VfgcPZ9Gi4ot+X+Z/Lt+Vdr49wdtv19/Zo1xKS1qptVbhiA8oGffEPQMpq3KilxGPzV3KZFc6tXWogq3sifLZInwCRctPZazWL6f647Ee0zyyJRM7rH1Ti556OFlgK89vw7b6PXS4roQ1Z53cByXDI9sSUFiJ5P7EOVMR7Rxtbco84cLZTC1904uHetKtWWjm1lF6TK5R8vT7tTK5H0vRNuyizZXpml2KVMLR67RyUMxs0fLeNbUOCR6Al7kfAvAVAD5MRO8AsATwMhE9B+AVZnbRYvR5AH51kp7IYIs/vxbAL+yK8CCBiJk/jOBNDlFC+8pD3teQPQSEsSHXBqXBGzgX/tLeIXXIKRkPYzidEG3iyc7W+HTCsC1OjC47jpiCGUgnN8ccp2d0GrfyZ5kwOIPe2THdnsbOTeMJzSG8sTzGcsmvpbIYLPrehpPjNxYYKB6kh7xTEYoD8zjYAi2DrA8n0NvR1SMzwM5ksyg7M4ZbrmMZoN4AjlInoPiPJW+E9McmuujVHaYsQhdOSZeJOtEWUhgqH5TnjQnRZWqY9OUUcSkPkrIsyj7VWTxNmws3wts8DNZGxeStSLJueBJXrW6lTTln4J0Nh4tyjL+ck004td6YUI+63dfyNQw2tb9J7yonIx/bg6Pgpje6dCftRZAwepQiBizHdhX7nvEwduyTxvjsBHJgnKCJOPPcs+vA5IweIgv4+Ok8YfAmHYBc7olJe5biieLyl5UtjXXBsU343oDPLWhDoNjfyEfHXsUsPbZVjodXqnbqCWZA/TBjeT8+y9J/dd8t2jykzRv55NTG04nnsTxGr4EEHkzykDfGP/bX0HdUH6LQLnxvgY0J5RDLIFsDpz6q0lmOQbF/sqJjSbviSnmgkl/pY+M4Iye9q/5SLjDiWoQHAwyqTfs8Tjk4l1jdk/BEcBLtpycYPV4Byl21ct+vyiO1ifidLY/1nJ4Zx2opv2zMiHUkY7eT9pQ15PjpCTwQMJix3SlkB6oCoA3B9LGdl663i3apD2dlO7bFLEwZIxDaHQ1jvWfyp8x5Wf/RD+i8cZqTynEpPB7nUU95G5N3pXx0Wg2HuqgcVgwz9gnouS2GJ3NLbSyWdci+WwL0M4CMj9NxEghjJWE6ZpbPTfdFhjVO7w2cN3AyzsX5oTbnSTySF2t4ds0m6Rq8QR/XbGXYeu2Xxqt4XY5GcXHOSuN8JY9y33N41iEf9w9Fvi4b823iWlLS2TuTyix1tZgGHf8wWHg3cyh6UgxU1ibXUTBi3N/GtTreD+D9RPQLADYA3s3MTER/GMBfI6IB4TzfP8PMrwAAEX0fgO9l5o8A+C4i+qKYul8D8Kd3RXg/FqKGhoaGhoaGhoaGhicY5pLdbjPzBsA3VK7/AIAfmHnnT6nv33honI9UINL0NWC6oUmk9CA5A0kVZHwmcWvJPOxXY7h49glgEg1HNC21TXGOR41EzQLklHZjG5wnrPsO/aaDG6J1SLz7YKqBFY1n0vQkDVOurfDeoO8t3NoCfdB0kvxlGmdKmjzRLMPI+RnBusYGIO+DxjRaAcZd9Ega1ckOTwoa7qRJdMUzSXtISXuYpcNXtCQE0EAwm2ghKqxInDSo8btRYcpvCZs45ZXFUhQVimSi5jdplwsrgsQnF7j4hLRXeV6rx+U+oA+C1XyUkQYgcefUgGEwGDYduFd1Uikr0SB7Y6K1TzSUPrWbLE2ekncciT+kB1NIvQ8G6AlmY0IdJ2uCWDAolL3lUcvdeTjL8JZgoke5YCkycMbXLaEYtX1aG7oPQl8dtY45JYWKZ0PmvKfQL104YJVVGSfrnjqc0fcWdNdicWpgzwnUY5YWEDT+8c/ozxCHPQfsOcH2yDVp0q4pPBvC4DEsqLI2FMs79mehrVmE7/EAVRcL2/cm1KVT5RH7tRz0m5wjxPynvhv7DxNCm+yDdciIhUiNF7F4Q7uWdBmAOZxHla5J3NFSIxaI3FogfZrDmU805hOU5ztZzgDwJuY1GwuRWT+6UwO7wThmSpwG8LHMZVyTLpxbLVS19QSSQ0xjnKbHOIaRDpvG9tCFeg3xUWoraSyz4Y8ZcYyTMgDkMFb2lA5lDTSeaWcmEislATYSdCpj2vgCgxcADwTjARoAo61KJGN7sFCzxehhNA6yHOmDwbpDMiAGi9xAmXVRh1laz0jnX6eXEJgEvYEZYriFpYlNiMM45POTHrdkXrGcrFsyjmWILislLdGHSKgDjGM9Ia47YkfgOO7LOsSa8ZBq/VmyBADAe5OdFURAssxoy7p4yXWcH2K6lT4W1zdnfYd1vwiMBJ+Pg2PE4xpEDh2Vz8HlaSrpeeUYnNZcRZrkl17/OQ/0LjJhooUpS5aypjhn4AczOrbBOI5ra55mbpRh6LLXTAIiSnO1YcryrNPEyMPQiwJrx+erDqdUvBLGQd4RrxIejIXooaNZiBoaGhoaGhoaGhoaDobIodcdj0wgyjbViXak0Cok19VRw+K9Pn9oDEtrnSVsxPddPCUaJmoglGZ+1ya82ibDXe4szzcLnN05CvsOImdatLGJJ26j9cRy4v97sRgZDsaOqPUXrcXmfAG+18GsDagfOfzwmGg7RQOWNHmiqRUthWXwYGHuWZg15VpvzRFPVgkkLak9NehOKWhDC01f0ox3PGq7adSWjyoapSxhwJ5RCHMYw2RThKn/1DXRgKZ08vjHYqURPnpUeJLWVpVc6JQuGhtZ2Q6SRqfSAJQmKmlNaWzvGvrasO7G+nUYC0jVQeLtW45lYML+HcMgGzb6p706WvsIKDfMlTSndEet2JmBPTNR4620sMmSMVo/Ql2H/SqIFiMX9xQxEzwxjKXErQcoaeDSJtWo5Qz8f90/Z9KKet8kKa/xV4bNeoHh3gK0MYBT/VI08GnvT2gz3SsLHH+CsLjDsGuGGeL4Yihq+cd26DsCd4Dv8u/cMewZ4fhTjOVtj27NoW3G8vMd4BYEv0D8o/gXw+/CeOE7GsvcBusJYjsAR6uOBZhN0GCvLcypDRYd6VO6WMSaQzS2LcvKwhO15gyYux3MeejzxlE+5sR+7dOeFx0e4n4YxDwzqDfo7pkw7miKhSr/0L5IWcWgtPhiHRJrEQMbA3PPwm7GMPVYSAysPk1YvcJYnDHIxXq0edkzEbozDtYHSL1KPcbnupCXxV0O1qZIVrAbxuKUYfoYdmwHviO4JcHp+l3KPXmOwR3l45pFsJDFsQ3RSsFMo4ViZv7K5sPOR8sI5UwADRnrOVgA7dk4vmtLGUv9llZMjulEYSXyFOa0c4Pu1MBskO9lkjrP5go5206N6zSWgTmP88+msDSltsfoTgndObK2oOcP6Ve+k2syjkmfkLLGWPas5lRGlSEwKfsIGed3OW4wBBjrx71R6hltHSrDFQYMVNWWLBi5frZZ4PbdY7jzLjIRxjLU+6bEWj7dsxqs/86YcC2lPcY/Y+UomTm1tZesB8/OlnBnXdjvp/Mh/d0AGAjmNPR5+DH9LOOgVfVZ7rVUa61s36+yHBltgWUT5nDkVT5ZFhR1TEQwRtasdeaRfjeFMfvU1UbF7fa1wyOnzGUeR+J1QsWHPMnhrPpck/y+NnkihiFWcOfDhEcy8Edz8xzmPK7s8sRy9tJNLF8xuaChBuQw+cliisEdB4qEDZ1RTPdkPciGyc8QY/EbKyzuUJhU9CQVB29fCApcUDLGSTaU3PJTFsefIlhZoNlxgSYTP3c0pjkuUp76VWB514fGTyFe3+ULOrcMv9nGhYZMPNlGVgAUaCc3fwNY3NMLFQrhygKiG7+XYcqiFGoBxsA4iSkBKTleUNWuWwClgkUSREKCZtpJMahPwqpQIubQ/WaoX7tBGnlD/uJioYs0G10nqu2wMcm5gQz6iT6wpZ2Xnr/o1RWOXzLoThGpQzwucruxXjjVT7we0xPSFD69D2lJE7cS8HN6AuDlO/LJdR9kG4dVnsoJyP/2EY5ei4JeLBahMUm/1O39bf90wMnHXgHdvhuUCsYARyvw8Qr+ZAl3vIA7tnArg+GI4FaEYRU+/RJwq9A33vjvHJ7+X34N7tOvgp2DWS5AN05AN2+AbxzD3VzB3VhgOLEYjkNYw1HsR6uiD3RjGxBBDEL98ZSEmuPfWGBxO9C4AIQxIlsEjv09jEOhf4/1GMJbvGZx/NsEe85xPONiYawEBgm343DNRWHGh+tkgOOXLI4+zTAbDnWQ0kWj0CHC4ILUeEkjxUmomtFJw9FvLrB6NQglgIQZhdIFcPwJxrP/y0vw/9tvgvsNqOtgTk5At26Cb57A3zrCcHOJxcunMJ9+LZTXagk+OYK/scJwY4Hh2GI4CXVz9IrD0SdPQb0DjIFfWtiPfRzutdcAMjBHK9CNG6CbJ/A3juFureBOuqx+3QpwK4JbAn6phKOF6vexfyfBKDDAxzGNKB+nUIwzFBfuIlDqg1mzMSD0mcXLoa67Mw50QBHcdXkmIU7SzFFIlDlZCUVRoD75LYvFHURhUYReETDrc4VWNlCi0zFu/KbB8rYSPFX78Yug5HjmV3rYs0hT6whuaWJZU1bmbinCqSgiRDhTNFT5HicVFoUNjUU30stknZKPZZoSXPP+JlR++d7Z6dhVrV8FLRQB0yqWZ1797aeweKVDJ+sTGumiYSxkpdSM/axjeBsp2jY6eIjCkVDpZPwGU5ZvnWZLucBQKryIGK/dPgF+8xirsyg8YxRu9Phy/NsGR6+EdgrSdRjH3gXAC8AvOG+nieat1lrKKQ1FYZC9CEeU5iih0NWojnreKoXWmmOIxw6MB+Fl7qGjUeYaGhoaGhoaGhoaGi6EJ0YgIqJfA3AHwcXdwMzvJKI3AvgfALwdwaXdf8LMrx6agKo/+i2mZXGukEnpxbOlpF5zQzlXdzW/+Idg+fwp1qsj0JlJG5CzjZ2J9hStJco6JJuER1P1qI3p37ZBf6eDOTcjtUyHm0zeSvOtXLfqTxBj85yDX1p0Z+Pm4Mx5gaZEJGoDcOfthMVdk1HmRIuorVGjVWm0WOVpiBaAFXD3d1h0d2mkvPBYViVFzut0JeoYkLl9hZRFNI1XqrA0f2fUOdn0qp6dQ1Vjl2mQyufr7w5v3WC43cGem1QfkojcscRICUCiePBIeagmct6SVabFPbvGqV0qWlOFmmJ5tDRozVsX6QmKCpqciGhKQK0+lGXORS0jCq3nIajVi33hDOc3l6Bzk1wLZ/lSlEQY4KX/Q4cbn/k8jl59DotTP1owTdCWu6iRLClvbgX1m/Hq77TY3PocHL/s0J06GBcpwJ2BW5qkrXZKa52018laovqUooSMrqkx1jMBZy8M6G9Y2HWgomZ9SrWjRJEVK1GX12P/nIdbdujOKo5UivAg/VTCq/TNsxcchhsm0LKGMaxEy53r50K7TdYhpDZ2/sKA4cSiO6+PZXc/i+CO3oKTTz6P5e0BZvBwuvxXwYpw+pYlFnefgumjdcFSsnjrutk81eHs2afQraNVmwD75s/D8nYP2nh4ZrA18AsDtzLw0UIxrIr6XSDUcaJwqXyqemVVr6VFN20el/up/Y91ROCg3Ta55bTcdD68dY07x0t09wh2nTu5SYwEW/R/WxmPZIyPxzzcezvB3rGwayQKbqJHqnkjmxdl/lLjOAi4+1k+WNLP1TEN0HMe8Oo7FuhOOVhHtbW9oLOO1q7Y7k3R1qKVRMYzkmMrbDxeQLnatjYcL2CMz1xl18YiWfNo19na6ZOml5VOnvT1LExMUXMedev5u7i7OgafdaMb9NS21Pwc+3+W52QZyt2LlzSvmqtqnV95poQhxsmbXscnOo/1vSV4bYITDbGwpDUS4/SzGJtnorObwpqZ2qVm4mjLslqDgNT8pK1+FQgzSc6l01ZAo4552WfOKo+N0PV80TnvkeIJtBB9OTO/rH6/F8CHmPl9RPTe+Ps7LpKIQw5h7IxHZ3024Agmg8SWcLafJVR/Zh/haLUcgKfP0R91cL1N517MeT9KE5/itZqFh7EOVg28i4XD5shi2HRw0cscmJDtUZJ0lgtkyuMIfx7DGxlDH7z2lGcA6QU41Hd/DPTPIC4oJX6Jd8wbq/iysylo+r1/A2O4aUbvdZIOVuFhTEN2xosWsmbKU9NKEo1MoxRgyvt7HG4wtzeHyrCL6/K5PNmg7zwG8SLoEcpXR60nLUmnKT4LWkJ6bYfgJrCdg3tmg/44pIP6QihC3EfR6cmFZ6kHJqVpFIZqigqBFowAjMLRBaDDt8RY3jxDf7zBZtPBDRZePM3J/jpgZFQSY/OCR3+zw+IuwZ52sBuMi/hSwIiLKL8E/DKnafS3GJunCHfvdbBnIZyw2OTR85UZF216n8NEMaG58dmeB1b9m4Fjh8EyXD+e/1Lz7pXakwW488BiXACJQsatHDYbC2xiu1ReEJX+QI0zavEi14WKsgQ2C56c65T19ZgfLaSW58Zk/dyqvGqhTe0V7G8R7r3NwJ6toqc5NW6p8idn8r2MaqE9LrCA9RsAo8qVGDCbDqbn3NOc1KstKGdWhZkpjwrhTymx0rhpRqVCtpDT9YB8YTcevAwQ4sLberWoDfc3ywHDukO/tqMnUzV/scW076s0ydlrxjJs52CtB9/YoH+qQ9+bcL7dpKNWxkiq55FXDpsTC9qoutZ7bogx3Ij73fqKUKcVflrhpso+KUUWDHQepvNpH023cOg6h055Weusw8q6tBg2hXjiQRNBZmnU88RYmgGd8eldecczYfA2/R58PNtH3deLak3P0oKVPHO0GGCfOUV/y2IYDLwzyQspj8UMY8b6q1EAx/qqzCGGsbS6jBgdeSysQ0ceJlaIj24bPQgdhecNMZ5anePOZoV7myXO+y6c5yPnxqn8DDdN1k7lfCvW64zauBH70z57iTTKdaqsRaX+V3aYCESeKTxHrhB0DQYOZe+8gcdYt7vo9VcRBDwWe4gqo9PeeBeAD8TvHwDwNfedmoaGhoaGhoaGhoaG6wEOCj79dx2xr4WIAfx/KYiu/w0zvwjgzcz8EgAw80tE9Pz9Jqbmn1+DiHFjtcGqGyZSuGhK0nd1jwvtjI5LY1sd1p+v664XCwciwHU+nGgcNapzvui1VcIsPI6O+qBNKSxh/cKgP7IYBht88MdzBEaPaiH8SaoKSkXSuHUevCRwPJelevaQfMZ3uuMBtnPBa0o85ZrllHh1HsAkCYX2MkvkAuClBx9RKiuqWdXiZ2YBq33XDgVozG9moQEwZ73BjnuHYC7cMnxrPWg1wHUO3tmxzdQ8QxX1suvshZFSsztPRAwsHMgy/BDP6xGLQNy0b46GRKGoneegw5/TJm4rbwCZpuyiQ6uO4tbROowbYGy8xcZZ9M5icAaDDyePMwPemxh/SINbOWxuWWBtQBvleU9TVmNkbAF34pNjiUQbJGC4RRg26iyfSNnLJo5kHdnTIlqx/GYW0SMHXjDYI3iUkrGn7FMA6HjAYjXAWk7nZ2jPVd4bDIMJljXVLr1o5yvjGlD0e/neefAqtitJV0m3kD4t7xb5Lds8WwYvfN5WJfEU8jd4Gs9wE6u4WGJ11B6Z5RvASOkj+R5U0focIvKIVi9M20eN9qooYxO6WK2ORbMtfVs03NqqovOhM6CtRkw4Pt5g2bnJ2SpuabA5sugHi6G3+ZldnmCPh8xqMIenTs6xjFYTIJwts3EWR3HuHuJ5O84buDiP6Hlc+h+Qz73MgF+4kK5hnFvhkbVv8hQ8SUpfLaxI2kqqKYqp3FcO3colKwkRcLzscXO1xtK4LO/PrM5wbHt05EMeQHDKsjPEvA1sMXiDk26Dk26DRbSU3OjWuGnXWBgHF60GPVusfYeBLdauQ88Gg7cYOIxXEpZnSu8QE0yxBhKrhK7jZ2/eAwAM3oQx0Bv0zqQzkJgJTx2fYxHbhoZ2EjC3znp6dY5VNySrCAA8vTjHjW6dfkvZ9N5iYRxudedYkEt5v+dWuDsscbdf4XRYhjKIaZU2M3iDoWin2oqk6/uQObJ2PpH+DYQziWQturIDnj26i2Pbwypmg+TxjYt76GI/GLxBzxYDW/TeYu0tBm+xiZ8Dm+tJmQOeKMrcH2Tm34pCz08Q0b/bNwIieg+A9wBA99zTe70zJxgxE+6tl1gPnToYLBeMyjBKk3G4Vo9vLh218LeBiNF1Dsb4ILjY0Em1abr+HgCmcCiZJwx+NKknb3wYD/zyhuMibhwE0iRSC78WaVxIpHRteTHRLpiCW0rDMOyTcMRqgNzq2SyFqyKzcRL0FUFgZrFVLpr0oBfSO79g0F7g5vb1jNd2Z2UXSkGofiichzFh/4QsOidtpkxeUTd64VMKQrvyKc+ExU5oe74b64Jrk80OlAfQjt/zdGee4tTz9TTunjAI+V7Cs34Bx5QmLAKwsGHCtp7hvIfzBmx95iLVWg/XObiVhR8IbijoqgWtMacR5rQMWA9eGjih0er3S4FXFmta4AdyWlx6rj7hAwBZl9XdRCmT3kU8tNnBe4KNh3lKFNZ40CIIS8wUj0AYw9s27pT1Is+xL9oWVNq2CFT1fs1pDJnkV4qu80EY81EJJAtlvVje0c8yIU2nl1VdKoGZKnXLqd40nQc5zbBCi922qJOk1YSgrBzj9U3fJc9kJQ3KxPmLiGHS4Z3jIZly7EVOf82L62yzQG9N2lchOB+6bD4L8YW8S9Y53ePYxsa0hTHEw1gPb4MgwNl8oYQpP84nUkeziiUpL6kbDn2dEeZXYxj3/BKbwSZBUvJ1PiywsA4L4yaL2UxZG2lua9fhbr9KFLFPr29gaQcsjcvoZF69E4SfkWalBaFDlMHMhLubZUqnV3UA4wFv4GP9bWLdzY23tb1NzITX10dYDqGMhAZ4OixxZPuU5/K91zbH6IxLQqIIgIYYnfFgdjGdDGfCWG19uDd0QUB2uq1W0pvN/VLfqAs8c3Ol0Es9E043Cwze4Nx0WLsOq6IOBXf6Vbyel7nUZSk4X0swYJ4Uyhwz/1b8/CSAfwDg9wP4BBG9AADx85Mz777IzO9k5nd2T51cTqobGhoaGhoaGhoaGh4pCIjW9vHvOmKnhYiIbgAwzHwnfv8jAP4agB8B8G4A74ufP3zZiSs1xBRN7UGzZdKBrfse4LivJSh/f/7eLm1oONzLx8O5CCZqrkot7dSphFBRTDjYsqAnBA8vwaLADFibh1NSDPbBLitItumcpnQJ0aqns0xrlrA5S4+6zyZquJTFKuVnTmsLrfUp8qOpIthPO5S9vwf2slgUpvia4wPxJmUMT7TwtXYD5FaXMbB9NF3b0hqeZWIQhzOIxAogIZSv76Ndq0E0zfm1qbVo7n6ZBrlj1aZnuec5p5OK5SPcJ1jD8Dy2Zc8EY+IGY+vhukBTZaacBlvQszR1raQ1sXWBIsrqfc6tTNVC1pYA9T1ZC9J3eX4sCwbC+VRFnyzbo3iQmttEbZiSCk000fV+P1oSakj3K+2qxLZ2JvmcRqDCLNrSOMb6ZKXKKMcq4hrVdpqX+KktFLpdiFVibh5Rlq+9LH8pbWPes7HtgH7onAmOcoizviPQ85f3yqKjvYtlViJlyQEiDZXhPGVzdHn+n8zRFK1EieKl8qHnSDmLkMjDyFxZ1Hk2d7C+VplLCutZ1r84WBw8/Egr9GZ0iGA8NoRkMZI+U6M9aapZTzbrW2JJsWlNw5N3as4USvpazXtZ/hsYnM3rqugjJl5zfnR8sG2NJeGOPww2ACwHSqShsKek93aSR0mf5L8rLCmDtyldQjuDN/HQegZROCjWEsNZH9ucm+TrUGxjikjbZ6ZANYz10DubOcrQdiphM9WsY2XdTnvi9cB13TeksQ9l7s0A/gGF1tAB+P8w8z8mop8B8EEi+iYAvw7g6x5cMgPSAY/S+V0YVDz2WXhdTOjJwjggrQITaW36QFlNAwg0uO0mae/Dgg3I86lPiq6lUy9Owu9p2GEB5JNHmDJ+LgbcOWhhTC+O8s9dJcjqWaTJq7pgknzVBi79vUIh2bZQqC1+7tfrC9F0kbkNPqY1HERcCkXTxWZNcTBNw3za5tOtFnzMk7gPoRpsQ00oGu/tzlu6h7oLVB1CjdJijQ+CH1P8BDzzeM34JBhx58J+B69oomoBphNTp2pOF64ToWCHQFHSn3T+J2Wk86/6THmI5NxhkqHMJNw63SUszHJBUoQlZJ8qy5Xxojz0sMS+Cxw9tkq8IxVUC0VThYPs57M25FUWb7VxsHw/U2BE2k5V4NomHAGpIqtKnh0KnvRceb9yL6RZyr3u3apUgOnfc/2qRl13PF+3Zb2mfS9FvlSqkmAEICkcM8URUO1Xs9TjaRQTwQjEWR0bE8aI0GfiwtzofrN7/NPPbhOmBKW3un2FoFQETAinB0zre0KB4/HYg30PyQ6ZmgpzhsYDuhGpcAKp7874tCfRgFGubkz0jijUvnDRwxDBUWCZetVWa2UC5OujEtvGGKMEXukDMjYyE/q4B2uuHmvtou5+ezYJVxeMcEjuNcdOgYiZfxXA76lc/zSAr3wQiWpoaGhoaGhoaGhouOLgB2MhIqJvBfAtAAYA/5CZvz1e/0IA/w2ApxB0yF/MzOfFu2/EgWelHnIO0ZWAaBlE85PM6vdhHp3EcdH3ZtIQNAOSbqT0h3f2DTflNF1fdkM6BE7Hr89R0mZ1roS37AbcWPaZ//xyk6ZTv0UbrONj0Z7FT1ZxjJ+7y0nTv8LzU01v/kIRzowWa5dHs32f2YZtz1sbLHDWcPZsrpFTYWnLHFDZZIzi/Wl4h6Rv7nldH7m1qHx2v7i2a//nrUT5c9OHhI6wjBvBl9ZNPFECFe1q1FyKNjpRBLdYihhBM+wL69AcpXFM5FiOwQslF+NAbgWcWll3l81YHnM3QiCLhUvaztVienaGLiMBM+GoG1JZ1zZyy5kapcVIwivHHz02dNZnm+913vX4lVu8yzSW747l23Vu4qBGp0t+Hy0G3FhucNT1iaKjN7HLWSGD8sjlvIFnTDylzVFeJxbvHeNYZhCsWLzD9ZlnMN8eck16HlMtjGWsfyCnUJXroLm5eJeFb9f4JffHtI3jHxVjZAhPWwLl0VwjH96uxFfEjaKsgjfKcNgU0WiZcD6nme4ad02l3uYOdNWYWHOK69u2CpSW221IYfN+h2TLuTza4pWFFcPRtMlFV3G2gOnZTRoyBglDSKz81jgsrINeMemxqly/TCxIxFl70G1uJY5GquuHce0k+ZM87rsyHY2Xl7eWfZi47H1DRPTlCMf7fCEzr8WTNRF1AL4fwDcy878mojcB6CtBHHxW6v2cQ9TQ0NDQ0NDQ0NDQ8ISCmB/EOUTfDOB9zLwGgOjUDQh+DH6emf91vP5plo1jOd6FA89KvXYWIiCX2llJ9o8iDfti1LinELLr+8c7avw20YVp6TZ1V/p0nL2zuLsmdJEzXwun3Cugw99mFdMWhlxPsg+3eowntxplqdthldsd/uHvHd7OvDfomeA879T+zWn+dHnKJmOxOJZp27c9XTSvpavsB1Fmh4CZ4AGsBwtLjMEZbNQG123Yxr/3RdnKhu9xfxcgFo7RsjPlr8v7KU5Pad+GRvhZWo6QfV4UY53FzfRxHDnvO9gKJ76G035RHSNCuKMGNo9XafYRev70/fiuN6N3ceKqZrhmKRh/ZynKnveexvOdeHpWmzy3HiycX+G86yZaayDfvK7HRglDu44mmu7/q+1vmiC2sTlcxOK97dlyLNFODDR6N+79eBBnpezay1vOlTVLkX5Ot/nxczpG7upbu/c3MgAayxHI2ti2ssr35oT3XXxzlyMDjV1HieyaE/bZR73PM5vBwnnK2BBze2kEvTewM+sYDW2RBjDph3pNM//++H0f6DFmM4yOMLK93JWg5vKx13z0cJeyl4YH4Hb7HQC+lIj+OoBzAN/GzD8TrzMR/TiA5wD8fWb+rsr7B5+Vei0FIkG+WK5Pnvcb/mUin8yzmC4UniwE5yb5fWIQ+se42N5OiZijrMwtXuS5/HstHXMT+7TM5haaF8E+799/OwIAVVe4GMWzXAzWynKuHC8Dh4T7oIWgElIuDiPlcIgbnbWnuV3vA6hOmlmbA4CMepVv8t6H5ib0nunitl6HtbZ/ESQPgjF+701cvE8pLjXBpTY+CGrjxERAguoDhdKElSBQeiLL81BfGOfX9BuaOjUuWmubr9N42BN64xMleftG6Dx9SZhLyg9AHOuM722jTR/edy6q4Kk9M0dflfkGUHW4fxL3xqG5r4+FPHs/V9QdpmyYF47SE5M25sqxI3txvGKKdr2Ps6h6WuqJPOSMm/sZvV30LgiM6d9HgMg8Ws7key8HElvyOTemZ2nBNP9Sn47jAbi6/VTTWndS4io9xlAxds6m/gojFE559Vki+oj6/SIzv6gfIKKfBPCWSoh/CUE+eQOALwHwxQhO3D4nXv9D8dopgA8R0c8y84fuNxvXWiBqaGhoaGhoaGhoaHh0qNDkXmbmd257h5m/ajY8om8G8IMcpOufJiIP4FkAHwfwT5n55fjcjwH49wCUAtEniOiFaB2aPStV49oLRNtoO5dt4bkM1ChyuSvUw8IrN4fuo1GqmdNFsw5g1pV5rTwPPVl5zqI3ZzXS7+gwHnTdPggLxzYN9UWwWzMu8d5XNDvjv5yw7j+MpHFHbjWdoynWLARzYQLbraDxV7qmrTzbrNc1bbym+jx4uiEwoftIOirpTo5XcIjFbX9rT6m93xV2GVbtfu2cq21jiIyHcqzDtg3y2zTOYknU6dD0tLn03s/YdllW3G1Wouz3gXHeD3bRwPUz5ZxKWT2UFsbd4c/FJ++V/Xm2bWG+vKqb8AsL0r7YZ15+ULWWLClASv8hFpVDLfpA3aq//7vTNr31faj8AROLlNky7gPTfE0NK9cPxIC5/Iz8EICvAPBhInoHgCWAlwH8OIBvJ6ITABsA/z6A7668f/BZqddeIBJcJo3qUeIiC8OSRnURlHQVPZjtHcbM9boQuHsxWqOD1d6fpOOCE9uDwraDR+vPHybc79o7dBnCxjQ9lxPOZadtUgaRslK255Kesg377m2Yp4XuWuDXy6HcAyFx7cK+E3EZvxbYJdXTybu+ENjlpS69MpOufags+2KfcXCX4MU8ejGlLfksMZfvso3ky96Ho/A5dKzb53ywQ9N6eBoOV7jto3C8XGVOqTgc491F7ayFM5eyQ5WPWZou/GYRzp5pKJUrhwgQXPSRQxUklzWu70JdrNsj3J3jydVT5O8DunyB6P0A3k9Ev4Ag+Lw7WoteJaK/BeBnEKrhx5j5HwIAEX0fgO9l5o8gCEIHnZW6l0BERM8A+D4AXxAT8CcBfBQH+vhuaGhoaGhoaGhoaHhMEM6ouOQgeQPgG2bufT+C6+3y+p9S3w8+K3VfC9F/BeAfM/N/TERLACcA/iIO9PH9sPC4WIsOxTb64CHvh0AeXrnt0pyNz+W/56wUj7rO97V6zNXXRbXDD4NKOMY1vbav1ehBWKxKlLSo0tqRaSwPDbtyrXR4IWkIv2vp0+9uj+9QSu3FNmJPqUOz7am2WXhHeT7sHrnPmLLPPCGWIrl/SLspQ5xrIxdxjHIRK/NFsOt8sEPnnIcxPm0bBy+TdbC7jsq+u7297YrjUcxq98U4idhm+apaVLhwWnABdkmJfa1BO+lyu+pwjzh0SmrpelAU9weNB3Ew68PGToGIiJ4C8IcB/KdAkto2RPQuAF8WH/sAgA/jighEGts60+OKyxAIH4VQeTj9Yvx+FQaRiy70L7OsH6ZQNI37kUQ7izkBRa7NUjxrYe0R3z7ez8Z7ewRYjaNI1yW2+30XcLPXLy8pl4Z9+8OueSITEi8xPbv2AV5VpU+Jq6aE3Lfe951DLj6PzilE9iuviwhi94MHMXdsy+uhtLN9qc6H0uEuUqIXrZtH3zseABig4frnbJ+DWT8HwKcA/L+I6F8S0fcR0Q0UPr4BVH18E9F7iOgjRPSR4fbppSW8oaGhoaGhoaGhoeHRgrzP/q4j9hGIOgSXdt/DzL8XwD0EetxeYOYXmfmdzPzO7qmTCybz8iAbh58UXEZe77fMHoaTg3C+yoVevRRcVtyXUV9XQUN7lVAr021tmit/94MHWR+X3e7ntOTbPLJd9fH0YhTCer4eVH7n0njVrK774Kq0iUPr/UHNIbusuIeWlzx/mWX8sOpsn7RvG3flYNZdfwel6aCnd4Sl8ncV+sDDAjGDXP53HbHPHqKPA/g4M/9U/P0/IghEB/v4fhi4rMXHNo7vg13g7Bf2depqB5fXJdBwnqTBSGObi+CGB4/5he38HpXLifeQZx9d23h0dM7teX7w7s33oW89PkLRVcFF6vWqlfdltM1dWTokjoc5elwkrrm8Xka627w6AwYwXE+rkMZOCxEz/zaA3yCi3xkvfSWAf4vRxzewp4/vhoaGhoaGhoaGhobHB48DZW5fL3PfCuDvRg9zvwrg/4ogTB3k4/s6YV/vRIL7OR+kfOaQjXn3o8yaeEG6j7CuEp5U6xCwf/t52HgSnZvswqNqp4+ijVz1Pvkgrf9XPe8NVxuXMXbe73rhOo3W1ymtjw2YgWsqBGnsJRAx878C8M7KrYN8fDc0NDQ0NDQ0NDQ0PD6gx4Ayt6+F6NrgUWnIL3uDI3CYC8eLno2xz71Hod9sWp6L4ypYiXb1h12ntT/OuAoWg4exH1LHc11w2eVy3fLfcPVxP230EFbI4z8SN1wamAHXBKIriauwILwMHJKPuYHuMkphWxgPYrq/nzS3BUjAw1rwzsV72e8/Dv0ZuHrt80GcH3PV8ngRXEb/eRzKoeHq4lLa6GUlpqHhSaHMNTQ0NDQ0NDQ0NDQ0ZGAGnHvUqbhvPLYC0ZNoJcreewBpOSSeQ3Sj17+Wri4eZj94kBrx+3FbfBVwHawFF928fR3ydlEcakF7nMui4WriUbEBnkRc1KHWYw8GMDSB6ErjSReKHiUeRWrbYqSOBz1hXpVy35WO67638GHjOqf9QaCVR8NVRhOMHhwehNfhxwtPkJe5hoaGhoaGhoaGhoaGDIzHgjK382BWIvqdRPSv1N9tIvpzRPRGIvoJIvpY/HzDw0jwoWCmx0Kz97jko+HRQdrQZbSjywzrYUGn+WH9NTQ0NDxMtPHncnGRcnzi5gRm8DBkf5cBIvpWIvooEf0iEX2Xuv6FRPQv4vV/Q0RHlXf/ChH9ppJd/oNd8e20EDHzRwF8UYzAAvhNAP8AwHsBfIiZ30dE742/v2PfjD5sPC7m5HbA5RSP7SDzANHKrKGhoeHxRlsvXAyPej/stcQlu90moi8H8C4AX8jMayJ6Pl7vAHw/gG9k5n9NRG8C0M8E893M/Df2jXOnhajAVwL4FWb+32JCPxCvfwDA1xwYVkNDQ0NDQ0NDQ0PDdYV4mdN/949vBvA+Zl6HKPiT8fofAfDzzPyv4/VPM/OlRHioQPT1AP5e/P5mZn4pJuglAM9fRoIeNB43s+UTYY7dgicxzw0NDQ0NDYfiYa8XHgVN+aL5e5LXUfcPBjuX/QF4log+ov7ec2Cg7wDwpUT0U0T0T4noi9V1JqIfJ6KfI6Jv3xLGtxDRzxPR+/fZ1rO3UwUiWgL4YwD+wr7vxPfeA+A9ANA99/Qhrz5QXEfPbfvgcaEG7oM2cDU0NDQ0NFwMh7qV3zesq4KrmKbHEcwA95N9Qy8z8zu3vUdEPwngLZVbfwlBPnkDgC8B8MUAPkhEnxOv/6F47RTAh4joZ5n5Q0UY3wPgOxFcPnwngL8J4E9uS88hXub+KICfY+ZPxN+fIKIXmPklInoBwCdrLzHziwBeBIDjz33r479Kb2hoaGhoaGhoaHgSwCxWoQNf46+au0dE3wzgB5mZAfw0EXkAzwL4OIB/yswvx+d+DMC/ByATiJSsAiL6OwB+dFd6DhGI/jhGuhwA/AiAdwN4X/z84V0BnP/KS3d/6Wv/6kcPiLOhQfAsgJcfdSIariVa22m4KFrbabgIWrtpuCh+x6NOwKG4g1d//Cf9B58tLt9v+/8hAF8B4MNE9A4AyxjmjwP4diI6AbAB8O8D+O7yZTHYxJ9fC+AXdkVIQfja8VCI+DcAfA4zvx6vvQnABwF8FoBfB/B1zPzKjnA+ssuE1tBQQ2s7DRdFazsNF0VrOw0XQWs3DQ33h7hN5/0IXq43AL6Nmf9JvPcNCNt3GMCPMfO3x+vfB+B7mfkjRPT/ju8ygF8D8KeVgFSPcx+B6LLQBomGi6K1nYaLorWdhouitZ2Gi6C1m4aG64dDvcw1NDQ0NDQ0NDQ0NDQ8NnjYAtGLDzm+hscHre00XBSt7TRcFK3tNFwErd00NFwzPFTKXENDQ0NDQ0NDQ0NDw1VCo8w1NDQ0NDQ0NDQ0NDyxaAJRQ0NDQ0NDQ0NDQ8MTiyYQNTQ0NDQ0NDQ0NDQ8sWgCUUNDQ0NDQ0NDQ0PDE4smEDU0NDQ0NDQ0NDQ0PLH4/wNMKcKSh8q4jgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1152x144 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.matshow(cell_geometry.V_m)\n",
+    "plt.colorbar()\n",
+    "plt.axis('tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/morphologies/single_cell.swc b/examples/morphologies/single_cell.swc
new file mode 100644
index 0000000..cdbacf6
--- /dev/null
+++ b/examples/morphologies/single_cell.swc
@@ -0,0 +1,16 @@
+# id,  tag,      x,      y,      z,      r,    parent
+    1     1     0.0     0.0     0.0     2.0        -1  # seg0 prox / seg9 prox
+    2     1    40.0     0.0     0.0     2.0         1  # seg0 dist
+    3     3    40.0     0.0     0.0     0.8         2  # seg1 prox
+    4     3    80.0     0.0     0.0     0.8         3  # seg1 dist / seg2 prox
+    5     3   120.0    -5.     0.0     0.8         4  # seg2 dist / seg3 prox
+    6     3   200.0    40.0     0.0     0.4         5  # seg3 dist / seg4 prox
+    7     3   260.0    60.0     0.0     0.2         6  # seg4 dist
+    8     3   120.0    -5.     0.0     0.5         5  # seg5 prox
+    9     3   190.0   -30.0     0.0     0.5         8  # seg5 dist / seg6 prox / seg7 prox
+   10     4   240.0   -70.0     0.0     0.2         9  # seg6 dist
+   11     4   230.0   -10.0     0.0     0.2         9  # seg7 dist / seg8 prox
+   12     4   360.0   -20.0     0.0     0.2        11  # seg8 dist
+   13     2   -70.0     0.0     0.0     0.4         1  # seg9 dist / seg10 prox
+   14     2  -100.0     0.0     0.0     0.4        13  # seg10 dist
+   
\ No newline at end of file

From 373b64711e7e5fe56751914d81ff896e85586f76 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Fri, 2 Jul 2021 14:20:27 +0200
Subject: [PATCH 02/30] fixes for Arbor@master changes

---
 examples/Example_Arbor_swc_hybridLFPy.ipynb | 143 +++++++++++---------
 1 file changed, 76 insertions(+), 67 deletions(-)

diff --git a/examples/Example_Arbor_swc_hybridLFPy.ipynb b/examples/Example_Arbor_swc_hybridLFPy.ipynb
index a7503d1..8ed0cae 100644
--- a/examples/Example_Arbor_swc_hybridLFPy.ipynb
+++ b/examples/Example_Arbor_swc_hybridLFPy.ipynb
@@ -57,7 +57,6 @@
     "import matplotlib.pyplot as plt\n",
     "from matplotlib.gridspec import GridSpec\n",
     "from matplotlib.collections import PolyCollection\n",
-    "import pandas as pd\n",
     "import scipy.stats as st\n",
     "from LFPy.alias_method import alias_method\n",
     "from LFPy.inputgenerators import get_activation_times_from_distribution"
@@ -192,10 +191,19 @@
     "    def event_generators(self, gid):\n",
     "        events = []\n",
     "        for i, (w, t) in enumerate(zip(self.weights, self.times)):\n",
-    "            events += [arbor.event_generator(i, w, \n",
+    "            events += [arbor.event_generator(f'{i}', w, \n",
     "                                             arbor.explicit_schedule(t))]\n",
     "        \n",
-    "        return events\n"
+    "        return events"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "arbor.event_generator?"
    ]
   },
   {
@@ -207,12 +215,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Parameters\n",
-    "morphology_file = os.path.join('morphologies', 'single_cell.swc')\n",
+    "morphology_file = os.path.join('morphologies', 'ex.swc')\n",
     "\n",
     "# CV discretization\n",
     "max_cv_length = 10  # µm, max length of CV.\n",
@@ -227,12 +235,13 @@
     "synapse = 'expisyn'\n",
     "synapse_params = {'tau': 5}\n",
     "\n",
-    "# "
+    "# synapse weight dist\n",
+    "weight_params = dict(loc=0, scale=1E-3)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -259,7 +268,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -268,12 +277,13 @@
     "\n",
     "# Label dictionary\n",
     "defs = {}\n",
-    "labels = arbor.label_dict(defs)"
+    "labels = arbor.label_dict(defs)\n",
+    "# labels['all'] = '(all)'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -295,7 +305,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -320,7 +330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -330,7 +340,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -350,7 +360,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -362,7 +372,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -377,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -390,7 +400,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -414,7 +424,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -432,7 +442,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 22,
    "metadata": {
     "scrolled": false
    },
@@ -440,16 +450,16 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x149f7a4f0>"
+       "<matplotlib.legend.Legend at 0x13d79b400>"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 2400x2400 with 1 Axes>"
       ]
@@ -469,7 +479,7 @@
     "zips = []\n",
     "for i in range(len(loc_sets)):\n",
     "    inds = CV_ind == i\n",
-    "    zips.append(create_polygon(x[inds, ], y[inds, ], d[inds, ]*5))\n",
+    "    zips.append(create_polygon(x[inds, ], z[inds, ], d[inds, ]))\n",
     "polycol = PolyCollection(zips,\n",
     "                         edgecolors='gray',\n",
     "                         facecolors='none',\n",
@@ -480,8 +490,8 @@
     "# outline of segments making up each CV:\n",
     "if True:\n",
     "    zips = []\n",
-    "    for x_, y_, d_ in zip(x, y, d*5):\n",
-    "        zips.append(create_polygon(x_, y_, d_))\n",
+    "    for x_, z_, d_ in zip(x, z, d):\n",
+    "        zips.append(create_polygon(x_, z_, d_))\n",
     "    polycol = PolyCollection(zips,\n",
     "                             edgecolors='k',\n",
     "                             facecolors='none',\n",
@@ -489,10 +499,10 @@
     "    ax.add_collection(polycol)\n",
     "\n",
     "# plot COM of each CV (sanity test)\n",
-    "ax.plot(r_bar[:, 0], r_bar[:, 1], 'go', label='COM(CV)')\n",
+    "ax.plot(r_bar[:, 0], r_bar[:, 2], 'go', label='COM(CV)')\n",
     "\n",
     "# plot COM of each segment (sanity test)\n",
-    "ax.plot(r_bar_seg[:, 0], r_bar_seg[:, 1], 'r.', label='COM(seg)')\n",
+    "ax.plot(r_bar_seg[:, 0], r_bar_seg[:, 2], 'r.', label='COM(seg)')\n",
     "    \n",
     "    \n",
     "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
@@ -503,7 +513,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -543,7 +553,7 @@
     "    mod = np.zeros(areas.size)\n",
     "    for f, args, w in zip(fun, funargs, funweights):\n",
     "        df = f(**args)\n",
-    "        mod += df.pdf(x=r_bar[:, 1]) * w\n",
+    "        mod += df.pdf(x=depth) * w\n",
     "\n",
     "    # multiply probs by spatial weighting factor\n",
     "    p *= mod\n",
@@ -555,26 +565,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(array([ 5.,  3., 10., 16., 16., 21., 16.,  7.,  4.,  2.]),\n",
-       " array([ 87.85863035, 107.79819931, 127.73776827, 147.67733723,\n",
-       "        167.61690619, 187.55647515, 207.4960441 , 227.43561306,\n",
-       "        247.37518202, 267.31475098, 287.25431994]),\n",
+       "(array([ 2.,  4.,  3., 10., 18., 20., 22., 11.,  8.,  2.]),\n",
+       " array([ 39.11764706,  66.70588235,  94.29411765, 121.88235294,\n",
+       "        149.47058824, 177.05882353, 204.64705882, 232.23529412,\n",
+       "        259.82352941, 287.41176471, 315.        ]),\n",
        " <BarContainer object of 10 artists>)"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -587,16 +597,16 @@
    ],
    "source": [
     "# sanity check\n",
-    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 1], n_syn=100, \n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=100, \n",
     "                                               fun=[st.norm], \n",
     "                                               funargs=[dict(loc=200, scale=50)], \n",
     "                                               funweights=[1.])\n",
     "\n",
     "fig, axes = plt.subplots(1, 2, sharey=True)\n",
     "# areas per depth\n",
-    "axes[0].plot(areas, r_bar[:, 1], '.')\n",
+    "axes[0].plot(areas, r_bar[:, 2], '.')\n",
     "# num. synapses hist. across depth\n",
-    "axes[1].hist(r_bar[inds][:, 1], orientation='horizontal')"
+    "axes[1].hist(r_bar[inds][:, 2], orientation='horizontal')"
    ]
   },
   {
@@ -608,17 +618,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
     "# randomly chosen loc_sets\n",
-    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 1], n_syn=n_syn)\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=n_syn)\n",
     "random_loc_sets = np.array(loc_sets)[inds]\n",
     "\n",
     "# create synapses at each loc_set\n",
-    "for loc_set in random_loc_sets:\n",
-    "    decor.place(loc_set, arbor.mechanism(synapse, synapse_params))\n",
+    "for i, loc_set in enumerate(random_loc_sets):\n",
+    "    decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')\n",
     "\n",
     "# synapse activation times (Poisson like)\n",
     "times = get_activation_times_from_distribution(\n",
@@ -626,7 +636,6 @@
     "    distribution=st.expon, rvs_args=dict(loc=0, scale=20))\n",
     "\n",
     "# synapse weights\n",
-    "weight_params = dict(loc=0, scale=1E-4)\n",
     "weights = st.norm.rvs(size=n_syn, **weight_params)\n",
     "    \n",
     "# number of CVs per branch\n",
@@ -661,7 +670,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -674,7 +683,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -692,7 +701,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -707,11 +716,11 @@
     "# locations where extracellular potential is predicted \n",
     "dx = 1\n",
     "dz = 1\n",
-    "axis = np.round([x.min()-50, x.max()+50, y.min()-10, y.max()+10])\n",
+    "axis = np.round([x.min()-50, x.max()+50, z.min()-10, z.max()+10])\n",
     "# axis = np.round(axis)\n",
-    "X, Y = np.meshgrid(np.linspace(axis[0], axis[1], int(np.diff(axis[:2]) // dx) + 1), \n",
+    "X, Z = np.meshgrid(np.linspace(axis[0], axis[1], int(np.diff(axis[:2]) // dx) + 1), \n",
     "                   np.linspace(axis[2], axis[3], int(np.diff(axis[2:]) // dz) + 1))\n",
-    "Z = np.zeros_like(X)\n",
+    "Y = np.zeros_like(X)\n",
     "\n",
     "# LineSourcePotential object, get mapping for all segments per CV\n",
     "lsp = lfpykit.LineSourcePotential(cell=cell_geometry, \n",
@@ -727,7 +736,7 @@
     "    M[:, i] = M_tmp[:, inds] @ (cell_geometry.area[inds] / cell_geometry.area[inds].sum())\n",
     "\n",
     "# Extracellular potential using segment information at last time step \n",
-    "# in x,y-plane coordinates   \n",
+    "# in x,z-plane coordinates   \n",
     "V_e = M @ cell_geometry.I_m[:, -1]"
    ]
   },
@@ -741,14 +750,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 29,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB8oAAAoQCAYAAADai6osAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzde7w0WVkf+t/Te+4DAoo4wCgoqCCKGiXRiFzUEBUTL+BdI0eUozHESxS8JJ+ouXgEiaLH++EgJh6JiIhBSYxR8G6GBCNGUFDAGWAERRAGZsZ5e50/do+z3971vrt3T3dX9V7f7+fTn75VrXqqurr3rnpqradaawEAAAAAAACAXszGDgAAAAAAAAAAdkmiHAAAAAAAAICuSJQDAAAAAAAA0BWJcgAAAAAAAAC6IlEOAAAAAAAAQFckygEAAAAAAADoikQ5AAAAAAAAAF2RKAcAAAAAAACgKxLlAAAAAAAAAHRFohwAAAAAAACArkiUAwAAAAAAANAViXIAAAAAAAAAuiJRDgAAAAAAAEBXJMoBAAAAAAAA6IpEOQAAAAAAAABdkSgHAAAAAAAAoCsS5QAAAAAAAAB0RaIcAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALoiUQ4AAAAAAAA7VlX3qqpPq6pvr6oXV9WfV1Vb3H5s7Pg25cg6nXR7ydix0pdLxg4AAAAAAAAAOvRnYwcAPZMoBwAAAAAAgHFdn+SVSR4zdiBb9INJfuAi79+0q0AgkSgHAAAAAACAMXx7kuuSXNda+7Oqun+S144b0la9ubX2+2MHAbeTKAcAAAAAAIAda639y7FjgJ7Nxg4AAAAAAAAAWF9VXVJVT6yqX6iqN1bVLVX151X1q1X1NVV1xdgxwtToUQ4AAAAAAAB7qqoekOTnknzI0lvvleTjF7d/XFWPba29etfxwVTpUQ4AAAAAAAB7qKruneQ3cpgkf0eSZyT5lCR/K8mjk3xHkncl+cAk/7mq7jZSqEny2VX1h1X17qp6R1W9uqqeU1WPHjEmOlattbFjAAAAAAAAgK5V1f2TvHbx9DmttSesMM9/SvJpSa5P8qjW2p8MTPORSX4tydVJ/nVr7V9sKuZVVNUqycifTfKE1trbtxwO/A09ygEAAAAAAGDPVNWH5jBJniT/ZChJniSttZcn+f7F0y/dRWxL3pXkuUm+PIfDwH9kksck+TdJ/mIxzWckeWFVXTpCfHRKjXIAAAAAAADYP5++uH9Xkp8/YdpfTfKUJPepqvdtrV2/1cjOd9/W2tsGXv+vVfV9SV6cw+T5I5N8ZZLv3WFsdEyPcgAAAAAAANg/H724vyrJbVXVLnRL8qIj811ztJGq+qSLzXuK2/2HgrxAkvz29/4syeOT3Lp46clrbgs4NYlyAAAAAAAA2D/3WnO+qzYaxZ20GDL+vy6ePrCq7jNmPPTD0OsAAAAAAACwfw4W969N8g9PMd9rl57/ZpIHbyCeN9yJef8gyWMXj++b5I13Phy4OIlyAAAAAAAA2D9/sbh/nySvaq3dtk4jrbV3JXnVxqJaT428fDpk6HUAAAAAAADYPy9f3F+V5OPGDGQDPuTIY73J2QmJcgAAAAAAANg/Lzzy+CmjRXEnVdUHJPl7i6d/0lq7M0O4w8okygEAAAAAAGDPtNauS/KLi6efWlXfdrHpq+r+VfX524/svGX+g6q6YCnoqnqfJD+d5NLFS9+/k8AgSbXWxo4BAAAAAAAAulJVD0/ywCMv3TPJ0xePfyPJ/3N0+tbajw20cZ8kL0ty78VLv5Pk/03yiiQ3J3mvJA9N8slJPiHJz7bWHr+xlThBVb0uh0nw5yf5rSSvS/LuHK7ro5J8xSLGJPn1JJ/UWrtlV/HRN4lyAAAAAAAA2LGq+rEkX7Lq9K21ukA790vyvCQPW6GZZ7fWvnTVZd5Zi0T5/VaY9PlJvqy19ratBgRHXHCoAwAAAAAAAGDaWmuvr6q/k+TTk3xukr+T5H1y2JP7bUlencPe3D+X5Nd2HN6XJHlkko9N8gE57En+HknemeT6JL+Z5Dmttd/acVygRzkAAAAAAAAAfZmNHQAAAAAAAAAA7JJEOQAAAAAAAABdkSgHAAAAAAAAoCsS5QAAAAAAAAB05ZKxA6A/VXV5kg9bPH1LknMjhgMAAAAAwHEHSd578fgVrbVbxgwG2I6quiTJNWPHcRE3ttZuGzsIziaJcsbwYUmuGzsIAAAAAABW8rAkLxs7CGArrkly/dhBXMT7Jrlh7CA4mwy9DgAAAAAAAEBX9ChnDG+5/cGv/uqv5t7XTHlEDwAAAACA/rzpxhvziEc84vanb7nYtMDZcPBBn5a65Kqxw0i77V0590cvGjsMOiBRzhj+pib5va+5Jtdee+2YsQAAAAAAcHHnTp4E2Hd1yVWpy64eOwzYGUOvAwAAAAAAANAViXIAAAAAAAAAumLodQAAAAAAAOhczQ5Ss4Oxw0imEANd0KMcAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALqiRjkAAAAAAAB0rmazidQo18+X3bCnAQAAAAAAANAViXIAAAAAAAAAumLodQAAgCRp87EjSMq1zAAAAAC7IFEOAAAAAAAAnavZwURqlE8gBrqguwIAAAAAAAAAXZEoBwAAAAAAAKArEuUAAAAAAAAAdEWNcgAA4Gxp87EjWN+6sZdroAEAALhzqiZSo7wmEANdcDYFAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALqiRjkAALA/9rn++Datsl3UMQcAAAD4GxLlAAAAAAAA0LuDWergYOwo0g5c6M1u2NMAAAAAAAAA6IpEOQAAAAAAAABdkSgHAAAAAAAAoCtqlAMAANPQ5mNHcLatsn3LtdQAAAC9ms0OMpuNX6M8U4iBLjgLAgAAAAAAAEBXJMoBAAAAAAAA6IpEOQAAAAAAAABdUaMcAAAAAAAAOlezg9QE6oNPIQb6IFEOAADsXpuPHQFDhj6XMhAZAAAAcPY44wEAAAAAAABAVyTKAQAAAAAAAOiKodcBAAAAAACgc1WzSdQHLyXA2BGJcgAAYLPUHz9bVvk8ncQAAAAA9oyzGQAAAAAAAAB0RaIcAAAAAAAAgK5IlI+sqp5WVe3I7VErzPPJVfUzVXVDVd2yuP+ZqvrkUyz3qqr6hqr671X11qp6Z1W9sqq+q6re786sEwAAAAAAAMCUqVE+oqr68CRfe4rpK8kPJXnS0lv3TfKZST6zqn4kyVe01tpF2nlAkp9P8sFLbz1ocfuyqvqC1tovrBobAAAAAAAA+6tms9Rs/D62U4iBPtjTRlJVsyQ/msOLFd684mz/OnckyV+e5POT/O3F/csXrz8pyb+6yHLvkuRFuSNJ/qNJPjHJ303yLUnemeRuSZ5XVQ9dMS4AAHrV5sdv9Md+AAAAAOwZifLx/NMkD0vyqiTPOmniqnpgkqcsnr4syce11p7bWruutfbcJA9fvJ4kT130Gh/y9TnsNZ4kT2mtPam19suttd9qrf3bJI9JcluSq5J8zxrrBQAAAAAAADBpEuUjqKr3zR29vr8yya0rzPa1uWOo/Ce31t599M3W2ruSPHnx9JIkXzOw3EuTfPXi6SuTPGN5mtbab+WOxP2jq+qjVogNAAAAAAAAYG9IlI/jB5LcJclzWmsvOWniRW3yT188fVVr7beHplu8/oeLp5+xmO+oRyW5++Lxc1q74HiIP3bk8WedFB8AAAAAAAD7rWYHk7nBLkiU71hVfU6ST0vy1iTfsOJs75/kvovHLz1h2tvfvzbJ/Zfe+/iB6Ya8LMlNi8cPXyE+AAAAAAAAgL1xycmTsClVdfckz1w8fWpr7S0rzvrgI49fdcK0R99/cJLXnrad1tptVfXHSR66NM9KquraEya55rRtAgAwERcclAiWDO0r5VptAAAAYBokynfraTlMEv9m7qgDvor3PfL4hhOmvf4C8x19flNr7W0rtPPQJO9dVZe31m45McrhGAAAAAAAAAAmRaJ8R6rq4Um+LMltSb6itdZOMftdjzx+5wnT3nTk8V0u0M5JbQy1c5pEOQAAnFmP/czPzpvf+vZTz3ev97xbfv4Fz9tCRAAAAHDn1Ww2ifrgNTMaGbshUb4DVXVZkh9JUkm+u7X2ilM2ccWRx7eeMO3RhPaVF2jnpDZOauckyz3Zl12T5LpTtgkAAJPw5re+PZd9xONPP9/v/vQWogEAAABgHRLlu/HNOaz1/adJvm2N+W8+8viyE6a9/Mjjd1+gnZPaOKmdi2qtXXR4+Ko6TXMAAIxFPXI2bXmfUrMcAAAAGImzEltWVQ9K8k2Lp09urd10sekv4B1HHi8Pp77s6iOPl4dYv72dk9o4qR0AAAAAAACAvaVH+fZ9bQ57cP9Jkquq6vMGpvnQI48/oaquWTz+T4vE+tEe2teesLyjw55fv/TeDUn+TpKrq+rurbW3rdDOW1pr6pMDAAAAAACcYVUH06hRXuPHQB8kyrfv9iHMPyDJT64w/b848vj9k9yU5A+OvPagE+Y/+v4rl977gySPOzLdbw81UFWXJHnABdoAAAAAAAAA2GuGXt8Pr03yxsXjR54w7SMW929I8rql9379yOOLtfPRuWPo9d9YIT4AAAAAAACAvSFRvmWttSe01upityTfdmSWRx9573WLNlqSFy7ef1BVfczQshav396j/IWL+Y56SZK3Lx5/SVXVBcJ+wpHHL1hlPQEA2HNtfvzGsOX/slmf/Q4AAIAJqaqnVVU7cnvU2DGxPRLl++N7kty2ePx9VXXl0TcXz79v8fS2xfTnaa3dmuR7F08fnOTrl6epqo9N8sTF05e21q67s4EDAAAAAADAlFXVhyf52rHjYHfUKN8TrbU/qqrvSvKNORwa/Teq6juT/HEO64k/NclHLiZ/emvt1Rdo6ulJPjfJByV5WlU9MMlzk7w7yaOTfHMO94t3J/ma7awNAAAAAAAAk3JwkDo4GDuKZIQYqmqW5EdzmCN7c5J77TwIdk6ifL98Sw6/mF+aw6T4cwemeVaSf36hBlpr76iqxyb5hSQfmORJi9tRf5XkC1trv7uBmAEAAAAAAGDK/mmShyV5VQ7LEn/TuOGwC4Ze3yOttXlr7YlJHpvDmuVvTHLr4v6FST61tfZlrV28sF9r7TU5TLQ/NcnLkrwtybuS/GGS707y0Nbai7a1HgAAAAAAADAFVfW+Sf7V4ulX5jD3Rgf0KJ+A1tq3JvnWU0z/CznsEX5nlnlTkqctbgAA9Obi11bCeIb2zXKNNwAAAFvzA0nukuQ5rbWXVNWjxg2HXZEoBwAAAAAAgM7VbJaajV+jvGa7u1i6qj4nyacleWuSb9jZgpkEiXIAAAAAAABgiq6pqotO0Fq7YZ2Gq+ruSZ65ePrU1tpb1mmH/SVRDgAAAAAAAEzRdStMc/FM+oU9Lck1SX4zybPWbIM9JlEOAABnnXrka6tNbrt2fntN3e3VLX8Oth0AAAB3QlU9PMmXJbktyVe01trIITECiXIAAAAAAADoXM0OJlKj/LwYHpbkxo22X3VZkh/JYU/0726tvWKT7bM/JMoBAAAAAACAKbpx3RrkF/HNSR6c5E+TfNuG22aPGK8OAAAAAAAAOPOq6kFJvmnx9MmttZvGjIdx6VEOAAAAAAAA9OBrk1yW5E+SXFVVnzcwzYceefwJVXXN4vF/klg/WyTKAQDgLGnzsSOA7Rvaz8uAaQAAAHfGrA4ym0CN8lZbjeHyxf0HJPnJFab/F0cev38SifIzxJkEAAAAAAAAALoiUQ4AAAAAAACcea21J7TW6mK3JN92ZJZHH3nvdSOFzZZIlAMAAAAAAADQFTXKAQBgn6lJDoeWvwtqlgMAAAAXIVEOAAAAAAAAnavZLDU7GDuM1MyFz+yGPQ0AAAAAAACArkiUAwAAAAAAACRprX1ra60Wt5eMHQ/bI1EOAAAAAAAAQFfUKAcAgH3R5mNHAPtj6PtSrhUHAAC4kJodTKRG+fgx0AdnCQAAAAAAAADoikQ5AAAAAAAAAF2RKAcAAAAAAACgK2qUAwAAAAAAQOfUKKc3EuUAADBFbT52BN2pHW/zoeW1MujXVg19xrY5AAAAdMkZAQAAAAAAAAC6IlEOAAAAAAAAQFcMvQ4AAAAAAACdq9lsEvXBa6afL7shUQ4AAFOgJjmMY/m7p2Y5AAAAdMEZAAAAAAAAAAC6IlEOAAAAAAAAQFckygEAAAAAAADoihrlAAAAAAAA0Ls6SM0Oxo4iqQnEQBf0KAcAAAAAAACgKxLlAAAAAAAAAHTF0OsAAACn8GdvuiG3XP89p57vckdfAAAAAJPhVA0AAMApXHPva3PZRzzu1PPd+rvP30I0AAAAsBl1cJA6GL8++BRioA+GXgcAAAAAAACgK3qUAwDArrX52BEAFzL0/SzXmAMAAMBZ42gfAAAAAAAAgK7oUQ4AAAAAAACdq9ksNRu/PnjN9PNlN+xpAAAAAAAAAHRFj3IAANgm9cgnqyb42QzF1NTHHp+65QAAAHDmOLIHAAAAAAAAoCt6lAMAAAAAAEDnanYwkRrl48dAH/QoBwAAAAAAAKArEuUAAAAAAAAAdMXQ6wAAsEltPnYEwC4sf9fLdegAAACwTxzJAwAAAAAAANAVPcoBAAAAAACgc1UHqdnB2GGkavwY6IMe5QAAAAAAAAB0RaIcAAAAAAAAgK4Yeh0AANbV5mNHAEzF0O9BuTYdAAAApkqiHAAAAAAAADo3m1Vmsxo7jEnEQB9c3g4AAAAAAABAVyTKAQAAAAAAAOiKRDkAAAAAAAAAXVGjHAAAAAAAADpXs0pNoD74FGKgD3qUAwAAAAAAANAViXIAAAAAAAAAuiJRDgAAAAAAAEBX1CgHAIBVtfnYEbCm2uPPbjn2Vq533htD+53PDwAAmKiqpGr8+uATCIFOOEIHAAAAAAAAoCsS5QAAAAAAAAB0RaIcAAAAAAAAgK5IlAMAAAAAAADQlUvGDgAAACapzceOADiLln9byvXrAADANNSsMpvV2GGkJhADfXBEDgAAAAAAAEBXJMoBAAAAAAAA6IpEOQAAAAAAAABdUaMcAADUIwfGMvT7o245AAAwgqqaRH3wqvFjoA+OvgEAAAAAAADoikQ5AAAAAAAAAF2RKAcAAAAAAACgK2qUAwAAAAAAQOdqNpEa5ROIgT7oUQ4AAAAAAABAVyTKAQAAAAAAAOiKRDkAAAAAAAAAXVGjHAAAAAAAADo3q8qsxq8PPoUY6IMe5QAAAAAAAAB0RY9yAAD60+ZjRwBwYUO/UeU6dwAAANgkR9oAAAAAAAAAdEWPcgAAgFO48U035Jbrn3nq+S539AUAAAAwGU7VAAAAnMI19742l33E4049362/+/wtRAMAAACbUbNKzWrsMCYRA32QKAcA4GxTj7w7dcY/86H1a+pXn33Ln7vPHAAAAO4UR9YAAAAAAAAAdEWiHAAAAAAAAICuGHodAAAAAAAAOqdGOb3RoxwAAAAAAACArkiUAwAAAAAAANAViXIAAAAAAAAAuqJGOQAAAAAAAHSuqjKbQH3wqvFjoA96lAMAAAAAAADQFT3KAQA4O9p87AgAdmPo965cCw8AAACrchQNAAAAAAAAQFf0KAcAAAAAAIDO1WwaA1VNIQb6YFcDAAAAAAAAoCsS5QAAAAAAAAB0xdDrAADsrzYfOwImoOwHx7ZBM05dn4a+C/YFAAAAGOSIGQAAAAAAAICu6FEOAAAAAAAAnauqVNXYYUwiBvqgRzkAAAAAAAAAXZEoBwAAAAAAAKArEuUAAAAAAAAAdEWNcgAAAAAAAOjcbJbMZuPXB5/p5suO2NUAAAAAAAAA6IpEOQAAAAAAAABdMfQ6AAD7oc3HjgBg/yz/dpbr5QEAACCRKAcAAAAAAIDu1axSE6hRPoUY6INLyQEAAAAAAADoikQ5AAAAAAAAAF2RKAcAAAAAAACgK2qUAwAwPW0+dgRwEW3sAGB9Q7+v5Rp6AAAgqZpIjfIaPwb64GgYAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALoiUQ4AAAAAAABAVy4ZOwAAAIBVVZuPHcJeGNpOrVwnDQAAwIXNqjKrGjuMScRAH5wpAQAAAAAAAKArEuUAAAAAAAAAdEWiHAAAAAAAAICuqFEOAMD41J0GGM/yb7B69gAA0KdZpWYTqA8+hRjogqNfAAAAAAAAALoiUQ4AAAAAAABAVyTKAQAAAAAAAOiKGuUAAAAAAADQuZpIjfIpxEAf9CgHAAAAAAAAoCsS5QAAAAAAAAB0xdDrAAAAp3DjG9+QW65/5qnnu9zRFwAAAMBkOFUDAABwCtfc57657MMff+r5bv1fz99CNAAAALAZs1llNoH64FOIgT4Yeh0AAAAAAACAruhRDgDAbrX52BGwJ8q+slFD27OVa6cZMPTds68AAABwxjjSBQAAAAAAAKArEuUAAAAAAAAAdMXQ6wAAAAAAANC5qkpVjR3GJGKgDxLlAABsjxrT7LuN7sPt/PbUfGafqFsOAADAGeOoFgAAAAAAAICuSJQDAAAAAAAA0BVDrwMAAAAAAEDnqqZRYUmJcnZlArs7AAAAAAAAAOyORDkAAAAAAAAAXZEoBwAAAAAAAKArapQDAAAAAABA52azymw2foHwKcRAH/QoBwAAAAAAAKArEuUAAAAAAAAAdMXQ6wAAbE6bjx0Be6zsPzu3vM1buZaaU1j+ztp/AAAA2CMS5QAAAAAAANC5miU1gfrgrsFlV+xqAAAAAAAAAHRFohwAAAAAAACArkiUAwAAAAAAANAViXIAAAAAAAAAunLJ2AEAAAAAAAAAI6tKVY0dRTKFGOiCHuUAAAAAAAAAdEWiHAAAAAAAAICuGHodAID1tPnYEbDHyv4zSUOfSyvXV7Oioe+1/QcAAICJkigHAAAAAACAzs1mldls/PrgU4iBPri0GwAAAAAAAICuSJQDAAAAAAAA0BWJcgAAAAAAAAC6okY5AAAAAAAAdK6qUhOoD141fgz0QY9yAAAAAAAAALoiUQ4AAAAAAABAVyTKAQAAAAAAAOiKGuUAAJyszceOAIB9NPT3o1yzDwAAU3QwqxxMoEb5FGKgD45OAQAAAAAAAOiKRDkAAAAAAAAAXZEoBwAAAAAAAKArEuUAAAAAAAAAdOWSsQMAAADOvmrzsUNgTUOfXSvXXAMAAJw1s1nlYFZjh5HZBGKgD85uAAAAAAAAANAViXIAAAAAAAAAuiJRDgAAAAAAAEBX1CgHAOA49aTp0a73+6Hlqf1ND5b3ffs9AABMwsFEapRPIQb64GgUAAAAAAAAgK5IlAMAAAAAAADQFUOvAwAAnMKNb3xDbrn+maee7/KDLQQDAAAAwFokygEAAE7hmvvcN5d/2ONPPd8tr/jpLUQDAAAAm3FQE6lRXuPHQB8kygEAgI2qNh87BLZs+TNupaoXAAAAsF+czQAAAAAAAACgKxLlAAAAAAAAAHTF0OsAAAAAAADQudlsGjXKZxOIgT7oUQ4AAAAAAABAV/QoBwDoXZuPHQEAPRv6O1Su6wcAAGC7HHkCAAAAAAAA0BWJcgAAAAAAAAC6Yuh1AAAAAAAA6Nwls+SSWY0dRi7RzZcdkSgHAADWVmrck+H9oKkxDQAAAEyYMxcAAAAAAAAAdEWiHAAAAAAAAICuGHodAAAAAAAAOncwqxxMoEb5FGKgD3qUAwAAAAAAANAVPcoBAHrT5mNHAAAXN/S3qlzrDwAAwOY4ygQAAAAAAACgK3qUAwAAAAAAQOdmE6lRPptADPRBj3IAAAAAAAAAuiJRDgAAAAAAAEBXDL0OAACsrNp87BA2Z4rrMhRT7ef1zUP7StvTdQEAAADOHolyAAAAAAAA6NxBzXIwG/8C5wMXWbMj9jQAAAAAAAAAuiJRDgAAAAAAAEBXDL0OAAAATN9y3XvDMQIAAHAnOKoEAAAAAAAAoCt6lAMAAAAAAEDnDmaVg1mNHcYkYqAPepQDAAAAAAAA0BWJcgAAAAAAAAC6Yuh1AICzrM3HjoA9VvYfNmx5n2rl2m0AAABgHBLlAAAAAAAA0LnZRGqUzyYQA31w+T4AAAAAAAAAXZEoBwAAAAAAAKArEuUAAAAAAAAAdEWNcgAAAAAAAOjcwURqlE8hBvqgRzkAAAAAAAAAXZEoBwAAAAAAAKArEuUAAAAAAAAAdEWNcgCAs6LNx46APVZnff/Z5/Vbjr3OzvXOQ/tdO0Prx5YNfa/tPwAAsLaDqhzU+PXBpxADfXAECQAAAAAAAEBXJMoBAAAAAAAA6IpEOQAAAAAAAABdUaMcAAAAAAAAOjer5GA2fn3wCYRAJ/QoBwAAAAAAAKArEuUAAAAAAAAAdMXQ6wAAAKdw4xvfkFuuf+ap57v8YAvBAAAAALAWiXIAAIBTuOY+980VD3n8qee7+X//9BaiAQAAAGAdEuUAAAAAAADQuYNZ5WBWY4cxiRjog0Q5AAB0qNp87BD2Vxs7gLNtaN9sNRshEgAAAOAsc7YBAAAAAAAAgK5IlAMAAAAAAADQFUOvAwAAAAAAQOcumVUumUB98CnEQB8kygEA9pUa0wBwvqG/jWrcAwAAMMDRIgAAAAAAAABdkSgHAAAAAAAAoCuGXgcAAAAAAIDOzWaVgwnUB59NIAb6oEc5AAAAAAAAAF3RoxwAAM64avOxQ9its76+Q+tXZ/sa6OV9uJ3x9QUAAAC2z9kFAAAAAAAAALqiRzkAAAAAAAB07mAiNcqnEAN90KMcAAAAAAAAgK7oUQ4AsA/Oes1lNqa7euR0aWg/V7ecC1reX+wrAADQvar6W0k+OcnHJ/nQJPdK8tdJ3pjkN5M8q7X2a+NFyC5IlAMAAAAAAABdqKqXJnnEwFuXJfnAxe1LqurfJ/my1tqtu4yP3ZEoBwAAAAAAAHpx38X9G5M8L8mvJfnTJAdJPjbJP1tM88U5zKV+wQgxsgMS5QAAAAAAANC5g6oczGrsMHJQW4/hVUm+OcnzW2vnlt777UVP8t9I8kFJPr+qftAw7GeTwlwAAAAAAABAF1prn9Za+6mBJPnt7/95DnuV3+7xu4mMXdOjHAAA2G9tvsW22wbbWmpvk1fIL2+Dck00AAAA3AkvOfL4AWMFwXY5ewIAAAAAAABwh8uOPN7iFfqMSY9yAAAAAAAA6NxsNo0a5bPzY7imThiRrbV2wxbCeOSRx6/aQvtMgEQ5AAAAAAAAMEXXrTDNRrP7VTVL8o1HXvqpTbbPdBh6HQAAAAAAAODQ1yb524vHL2itvWzMYNgePcoBAGCPVVMmC5Lj34VWrgsHAAA4Ax6W5MZdLayqHpnk/1o8fXOSr9zVstk9iXIAAAAAAADo3MFEapQvxXDjlmqQH1NVD0nyghzmT29J8jmttT/bxbIZh0vsAQAAAAAAgG5V1fsn+cUk90hyLsnnt9ZeOm5UbJtEOQAAAAAAANClqrpPkl9Kcp8kLcmXttZeMG5U7IJEOQAAAAAAANCdqrpnkv+a5AMWLz25tfbjI4bEDqlRDgAAAAAAAJ2baI3yramquyX5L0k+ZPHSN7bWvn8nC2cS9CgHAAAAAAAAulFVVyX5+SR/a/HSv2mtfeeIITECiXIAAAAAAACgC1V1WZIXJPm4xUvPbK398xFDYiSGXgcAAAAAAAB68ZNJHrN4/MtJnlVVH3qR6W9trf3R9sNi1yTKAQCmps3HjoCJKvuG78eqhrZT9TWg2ND3pXW2DbgA3w8AAOjdZx15/AlJfu+E6V+f5P5bi4bRSJQDAAAAAABA52aVHMxq7DAygRDohEQ5AAAAAAAA0IXWmlQ8SRJjiwEAAAAAAADQFYlyAAAAAAAAALpi6HUAAAAAAADo3MGsJlGjfAox0Ac9ygEAAAAAAADoikQ5AAAAAAAAAF2RKAcAAAAAAACgK2qUAwDABFWbjx3C+Ha9DVobf3m1xTpsQ9uz+rp2euh71TrbBgAAABeiRjm9cUYAAAAAAAAAgK5IlAMAAAAAAADQFUOvAwAAnMKNb3pDbrn+maee73JHXwAAAACT4VQNAADAKVxz7/vmyg95/Knne/cf/PQWogEAAIDNmE2kRvlsAjHQB4lyAICxtfnYEQBA34b+FpdqdQAAAGeZoz4AAAAAAAAAuiJRDgAAAAAAAEBXJMoBAAAAAAAA6Ioa5QAAAAAAANC5g6ocVI0dxiRioA8S5QAAMAHV5mOHMD7bYPeWt3n1N+jY8nevdbgNAAAAoEfOAAAAAAAAAADQFYlyAAAAAAAAALpi6HUAAAAAAADo3KwqswnUB59CDPRBj3IAAAAAAAAAuiJRDgAAAAAAAEBXJMoBAAAAAAAA6Ioa5QAAAAAAANC5WZKDCZQH18uXXbGvAQAAAAAAANAVPcoBAGDHqs3HDmF8U9gGrY0dwXFDMdUOL+cf+lyqr+urh76frbNtAAAAAD1wtA8AAAAAAABAV/QoBwAAAAAAgM7NZpXZbPwi5VOIgT7oUQ4AAAAAAABAVyTKAQAAAAAAAOiKRDkAAAAAAAAAXZEoBwAAAAAAAKArl4wdAAAAAAAAADCug6ocVI0dxiRioA96lAMAAAAAAADQFT3KAQB2qc3HjoAdK5/5Idthfw19dtXXNddD3+PW2Tbo0vLn7jMHAAA4UxzlAQAAAAAAANAVPcoBAAAAAACgc7OqzCZQH3wKMdAHPcoBAAAAAAAA6IpEOQAAAAAAAABdMfQ6AABw9rW25nzzDcdxpL1a8brl5dgNQQcAAABwp0mUAwAAAAAAQOdmlRxM4Nrs2QRioA+GXgcAAAAAAACgKxLlAAAAAAAAAHRFohwAAAAAAACArqhRDgAAG1RtPnYI47MNzr7lz7j6uwZ7+bveOtwGAADA2TKbJbMJFAifObxiR+xqAAAAAAAAAHRFohwAAAAAAACArkiUAwAAAAAAANAViXIAAAAAAAAAunLJ2AEAAAAAAAAA45pVZVY1dhiTiIE+6FEOAAAAAAAAQFckygEAAAAAAADoikQ5AAAAAAAAAF1RoxwAANZUbT52COOb4jZobewItmto/cau3za0H1Rf12UP/R60zrYBAACw3w6SHEygPPjB2AHQDUftAAAAAAAAAHRFj3IAAIBTuPFNN+SW65956vkuv+SM93QHAAAA2CMS5QAAAKdwzTXX5uoHPe7U8930qudvIRoAAAAA1iFRDgAAAAAAAJ2rqsxq/CLlNYEY6IMa5QAAAAAAAAB0RaIcAAAAAAAAgK5IlAMAAAAAAADQFTXKAQAAAAAAoHMHs8rBbPz64FOIgT5IlAMAbEubjx0BG1Y+02nu161tqJ0dr9vQ8mrNQb+Wt0FN4KTCJtdvTw39ZrTOtsGZYp8GAAA4UxzRAQAAAAAAANAViXIAAAAAAAAAuiJRDgAAAAAAAEBX1CgHAAAAAACAzs2qMqsaO4xJxEAf9CgHAAA4hUobOwQAAAAA7iSJcgAAAAAAAAC6IlEOAAAAAAAAQFfUKAcAAAAAAIDOHdThbWxTiIE+SJQDAMCAavOxQxjfFLdBUx98JUPbqSZwpmF5n6r+Bjlb/m1pHW4DAAAAmAJH5AAAAAAAAAB0RaIcAAAAAAAAgK4Yeh0AAAAAAAA6V1WZTaBsV00gBvqgRzkAAAAAAAAAXdGjHAAA6FObjx3BcUMxleubAQAAADbNGRcAAAAAAAAAuqJHOQAAAAAAAHTuYFY5mI1fH3wKMdAHPcoBAAAAAAAA6IpEOQAAAAAAAABdMfQ6AACQtPnYERzX2tgRpDa4XSrtvPZa7fi65aHtWSMPZze0fXe9XQAAAIAuOQMBAAAAAAAAQFf0KAcAAAAAAIDOzZLMRh54LNHLl92xrwEAAAAAAADQFT3KAQDo3ibrUAOcxtDvz87r1wMAAECHHH0DAAAAAAAA0BU9ygEAAAAAAKBzs6oc1PhFymcTiIE+6FEOAAAAAAAAQFckygEAAAAAAADoiqHXAQCgR20+dgTHtbbFtie4vqtajr02eL3z8jafwvB2Q5/VJtcZAAAAIBLlAAAAAAAA0L1Z1STqg08hBvrgsnwAAAAAAAAAuiJRDgAAAAAAAEBXJMoBAAAAAAAA6Ioa5QAAdKfafOwQdqu39eXsWd6H62xf8z30G9XO+DoDAADjO5gd3sY2hRjog10NAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALqiRjkAALB7rY0dwTG7rl0/yTrUQ59L1e7jAAAAANgyiXIAAAAAAADo3KyS2QQulp6NHwKdMPQ6AAAAAAAAAF3RoxwAAOAU3vSmN+TW65956vkuc/QFAAAAMBlO1QAAAJzCva+5b+7ywMefer53vuantxANAAAAAOuQKAcAgLOkzceOYHxnfRsMrV91VlXLNgAAANi4WVUOJlGjfPwY6IMzCQAAAAAAAAB0RaIcAAAAAAAAgK5IlAMAAAAAAADQFTXKAQAAAAAAoHOzqknUB59CDPRBohwAgDOt2nzsEEiS1saOgHUNfXZOWuzc8m9ZKwPEAQAAwJ3hyBoAAAAAAACArkiUAwAAAAAAANAVQ68DAAAAAABA5w4qOZhAF9sD1b7YEYlyAADYZ2qwb3cbbLrto+1tssb0cpw91q+2DQAAAIBTcOYAAAAAAAAAgK5IlAMAAAAAAADQFYlyAAAAAAAAALqiRjkAAAAAAAB0blaVWdXYYUwiBvogUQ4AAGxWa2NHsJJq87FDOGYoplYTHAhs+TN2EgMAAADYMxM84wIAAAAAAAAA2yNRDgAAAAAAAEBXDL0OAAAAAAAAvauJVNaaQgx0QY9yAAAAAAAAALqiRzkAALA/2nzsCPbD0HYq10kDAAAA3M6ZEgAAAAAAAAC6okc5AAAAAAAAdG6WymwCBcKnEAN90KMcAAAAAAAAgK7oUQ4AwJlRZ71+9RTXr7WxI2AKhvaDGrkHwBmv0z70e9fO0PoBAADAtjmKBgAAAAAAAKArepQDAAAAAABA56rGHxzs9jhgF/QoBwAAAAAAAKArEuUAAAAAAAAAdMXQ6wAAwDS1+caaqlXa2uDyVjK0vDp+LfNy7G1gmk0uDwAAAKAHzooAAAAAAAAA0BU9ygEAAAAAAKBzszq8jW0KMdAHPcoBAAAAAAAA6Ioe5QAAMEW7rpe9qtbGjoB9MbSv1MjdAtRpBwAAABacEQAAAAAAAACgK3qUAwAAAAAAQOeqxh8I7PY4YBf0KAcAAAAAAACgKxLlAAAAAAAAAHTF0OsAAMA0tPlGmqkNtZNkYzENtlfrXbc8tH5tzbaOrd+67QAAAADsGYlyAAAAAAAA6NwslVnGLxA+hRjog+4CAAAAAAAAAHRFohwAAAAAAACArkiUAwAAAAAAANAVNcoBALalBq5JbPPdx3GG1VnanlNcl9bGjmC7JrnNB2Ia+i3ZV8v7VE2g7tzyNt/j7T30m9j2eH0mx7YEAOCsq2kcpilRzq44ygMAAAAAAACgK3qUAwAAnMKNN74ht9zwzFPPd7mjLwAAAIDJcKoGAADgFK655j55j/s97tTz/dXrn7+FaAAAAABYh0Q5AACwexusD77zWvUTLN2+vA3Wrkt91mukAwAAACxIlAMAAAAAAEDnZnV4G9sUYqAPugYAAAAAAAAA0BWJcgAAAAAAAAC6IlEOAAAAAAAAQFfUKAcAAJLWxo5gfG0+/vKqs2uZh/a7UowOAABgDLW4jW0KMdCHzs7CAAAAAAAAANA7iXIAAAAAAAAAuiJRDgAAAAAAAEBX1CgHAAAAAACAzs2qMqvxK4RPIQb6IFEOAAC71uZjR7B7G1rnWredXc832NZSe7XiAF/LMaww39B2aqsu76TlrxjD3uptfQEAAKBTjvYBAAAAAAAA6IpEOQAAAAAAAABdMfQ6AAAAAAAAdK6STKE8+ARCoBMS5YyqTeEXFwCgR62NHQEMG9o3HTcAAAAAG2bodQAAAAAAAAC6IlEOAAAAAAAAQFckygEAAAAAAADoihrlAAAAAAAA0LlZptHDdgox0AeJckbXqk6cplrbQSQAAGxEm2+kmVq3nVXn21CcGzUUU81OP82Aoe3ZVphv0HJb67YDAMAkDJ2jXeW8LQDsM2czAAAAAAAAAOiKRDkAAAAAAAAAXTH0OgAAAAAAAPSuKjWFsgtTiIEu6FEOAAAAAAAAQFf0KGcvtBWvHqrWthwJANxJNXCdYpvvPg52Zwqf7zb/R5rC+jG+of1g6Pdu7faX9uFd9y7Y9voxTT5jAM6AVc+rAkCPHPUBAAAAAAAA0BU9ygEAAAAAAKBzszq8jW0KMZwlVXXPJPdN8t5J3ivJu5O8ZXH7k9b6HS5QohwAAAAAAADgDKiquyb59CSPSvLxSR54kclvqqrfTvJrSX6+tfY/tx/hdEiUc6asUnNHHXMAgGmqdS9g3tSFz0PtzDd8UfXR9oYKYa1bE3k59hXbWd7mTU1mAIC9of44AEdV1Ucl+eokj0tyxe0vnzDbXZJ84uL2rVX1h0m+P8mPtdZu2lasUyFRDgAAAAAAALCHFgnyf53kMbe/tLh/U5LrkvyPJG9O8tYkf5nkyiTvmeQeST4oycOSPDTJpUkelOR7c5g0f3qSZ7bWbtnNmuyeRDkAAAAAAAB0rurwNrYpxLAvqurZSb44d4xb9z+T/ESS57fW/vQU7VyW5BFJviDJZ+awlvl3JPnKqvri1tqvbzTwiTCuHgAAAAAAAMD++ZIktyX50SQPaq19dGvtu0+TJE+S1tqtrbVfaq19aZJrkvyjJH+Y5H5JPmHTQU+FHuUAAAAAAAAA++cHk3xHa+2GTTW4GGr9P1TVTyT57CQHm2p7aiTK6U5bYcyOam0HkQAAbMG2/49p8400UxtqZ2UbXd6O/1dcjr22NzDY0OfS1l3e0DbfVOxD+7mx+QCAM2SVc5gA0Fr7qi223ZL81LbanwJDrwMAAAAAAADQFYnyLauq96iqz6uqZ1TVS6vqNVX19qq6tareXFUvqaqnVNV7rdjeJ1fVz1TVDVV1y+L+Z6rqk08R01VV9Q1V9d+r6q1V9c6qemVVfVdVvd/6awsAAAAAAMA+mk3oxuqq6nur6qPHjmMfGXp9+/52kp+8wHvvneSRi9s3VNUXtdb+y9CEVVVJfijJk5beum+Sz0zymVX1I0m+YjEUwqCqekCSn0/ywUtvPWhx+7Kq+oLW2i9cfLUAAAAAAACAkf2TJF9VVX+Y5MeT/ERr7fqRY9oLLsrYjetzuGN+dZLPSvKxST4uyecmeV6Sc0numeTnquqhF2jjX+eOJPnLk3x+DpPwn794nsX7/+pCQVTVXZK8KHckyX80yScm+btJviXJO5PcLcnzLhIHAAAAAAAAMB2Vw/zfv0ny2qr6b1X1j6rq6pHjmjQ9yrfvV1prFxvO/Keq6jOSvCDJZUn+ZZLHHZ2gqh6Y5CmLpy9L8ojW2rsXz6+rqp9L8tIkH53kqVX17NbaHw8s6+tz2Gs8SZ7SWnv6kfd+q6p+JcmvJrkqyfck+YTVVvHsaVUnTlMX7rgPAKdTS9cutvk4ccA+2OT3Y4rftaGYln8jdtkOAAAbtcp5RwA4pU9K8kU5zC/eNYdJ80ctbt9fVS9I8u+T/NLFRqXukTMlW9ZaO7fCND+b5FWLp48YmORrc8dFDU8+kiS/ff53JXny4uklSb5muYGqujSHPdqT5JVJnjEQx28ledbi6aOr6qNOih0AAAAAAID9V1WTubG61tovt9a+NMn7JPmCJC/O4WjWleTqJF+Y5D8nub6qvrOqPnS0YCdGonw6blrcX3H0xUVt8k9fPH1Va+23h2ZevP6Hi6efUcd/RR6V5O6Lx89p7YLdZ37syOPPOjFqAAAAAAAAYFSttZtba89trT02ybVJvi7J/8xhwryS3CeHo0//r6r6n1X11VV1r/EiHp9E+QRU1YOTfMTi6auW3n7/JPddPH7pCU3d/v61Se6/9N7HD0w35GW5I2n/8BOWBwAAAAAAAExIa+3NrbXvaa19dJKHJPnOJNfnjqT5hyf5d0luqKoXVdXnVNXl40U8DonykVTVVVX1gVX1dUl+JcnB4q1nLk364COPl5Poy46+/+Cl91Zqp7V2W5Lb65svt8ERrWqlGwDQmTY//7bPltflTqxPtfl5t60uf9355vNjt+W4V459OLDz2xlY3mrN7Ha7bHQbnOXvB/utZsdvAHBKzhUCMEWttVe21r6ptXa/JJ+Q5NlJ3pHDhPklST4lyU8mubGqfriquulIe8nJk7ApVfWEHO58F/JdSX5i6bX3PfL4hhMWcf0F5jv6/KbW2ttWaOehSd67qi5vrd1ywvTnqaprT5jkmtO0BwAAAAAAwHbN6vA2tinEcFa11l6S5CVV9VVJPiPJFyf5eznMGd8tyZcneWI6ySF3sZJ74HeTfEVr7XcG3rvrkcfvPKGdm448vssF2jmpjaF2TpUoz/kJewAAAAAAAGAiWms3J3lukudW1UMWjz8kdwzN3gWJ8t362RzWAE+SK5M8IMnnJPnMJD9RVV/TWnvR0jxXHHl86wntH01oX3mBdk5q46R2AACgazfe+Mb86fXfd+r5Lru0bSEaAAAAgNNZ1CP/hznsUf7302nOuMuVHstiyPO3HXnpuhxeqfHFSZ6T5IVV9cTW2o8dmebmI48vO2ERlx95/O6l925v56Q2TmpnFcvDvi+7JofrDgAAe+fe73Of3P0+jzv1fG974/O3EA0AAADAaqrqETlMjj8+yXvc/vLi/m1JnpfDnGUXJMonoLX276vq03LYu/z/rqoXttb+cvH2O45Mujyc+rKrjzxeHmL99nZOauOkdk7UWrtoLfWqbkZsSJK0Fda3mt5FAMCa/B+RtPnYEYxveRvUbJw4xrT8XejsuAMA2K5VzvEBnAV+7c6eqvrgHCbHvzDJ+93+8uL+tiS/mMPk+M+11k5bjnmvdXj2ZLJeuLi/OsmnHHn9aNL52hPaONqTe7lO+O3tXF1Vd1+xnbf09oUAAAAAAACAfVZV96yqJ1fVf0/yB0m+Kcn9ckcN8v+V5OuSXNta+7TW2vN6zAnqUT4dbzny+H5HHv/BkccPOqGNo++/cum9P0jyuCPT/fZQA1V1SQ5rpw+1AQAAAAAAAEzMou74p+ew9/hjckce+Pbe429K8v8leU5r7fd3H+H0SJRPx32PPD463Plrk7wxyX2SPPKENh6xuH9DktctvffrRx4/MhdIlCf56Nwx9PpvnLA8AAAAAAAAYCRV9cjcUXf8rre/vLh/dw5Htf7xJL/Ymvp1R0mUT8dnH3n8itsftNZaVb0wyVcmeVBVfUxr7ViSu6o+Jnf0KH9ha8eKVb4kyduT3C3Jl1TV0wamSZInHHn8glOvBWtRxxyA8wzVFvY/LNu2wX2s1m1rm/v5Pn+Htll/fM22lz/jtm5MQ59Lj/XVAYBRqT8OwJ77lSQtdyTHW5Jfy2Fy/Kdaa+8YK7CpcwZiy6rqCVV1xQnTfG2ST108fV3O7/2dJN+T5LbF4++rqiuX5r8yyfctnt62mP48rbVbk3zv4umDk3z9QBwfm+SJi6cvba1dd7G4AQAAAAAAOBtmNZ0bp1ZJ/jjJv0zygNbaI1trz5Ikvzg9yrfvW5M8o6qen8ME+B/ncGj1uyb5sCRfmOTjFtPemuTLW2u3HW2gtfZHVfVdSb4xh0Oj/0ZVfeeirQckeWqSj1xM/vTW2qsvEMvTk3xukg9K8rSqemCS5+Zw2IVHJ/nmHO4T707yNXdqrQEAAAAAAIBt+5EkP95a+82xA9k3EuW78Z5Jvnxxu5Abknxpa+2XLvD+tyS5V5IvzWFS/LkD0zwryT+/0AJaa++oqscm+YUkH5jkSYvbUX+V5Atba797kVgBAAAAAACAkbXWvmLsGPaVRPn2fWKST8phj+0HJ3mfJO+V5OYkf5bkd5O8KIc1At51oUZaa/MkT1z0TH9SkocluWeSP09yXZIfbq29+KRgWmuvqaqPTPJVOayL/sAklyW5PocJ9Ge21l6/1poCAAAAAAAA7AGJ8i1rrf1xDodI/+ENtfcLOUxo35k2bkrytMWNPdFqtaIc1dqWIwEAGFGbb2aaJJmfP10NzTf42mrNDzrS3tB/d4Ohz2YnT1RrTAO98l0A6Maq59MAOFSV1AR+OycQwplRVZckeWySj0/yATksDX1wwmyttfaJ245tCiTKAQAAAAAAAM6QqnpUkmcneb+jL19klrZ4v5semRLlAAAAAAAAAGdEVX1EkhfnsPxy5bAk9KuTvC3JikPxnX0S5QAAAAAAAABnx7cmuTzJLUm+LsmzW2s3jxrRBEmUAwAAAAAAQOdmdXgb2xRiOAMensMh1P9Na+0Hxw5mqiTK4YxpdfJfkGrdlJcAgLNlgn/Dq605Wte687FdQ59LzU6cbWg/aCvMt1VD35cV/lcGAPbDKufAAKBjVyzu//OoUUzcyGcuAAAAAAAAANig1y3uLx0ziKmTKAcAAAAAAAA4O352cf+IMYOYOolyAAAAAAAA6FxN6Mad9swkb0ry9VV1/5FjmSw1yqFD6pgD7KGhWr9qPHNn7MP+s2qMq0w3Pz7NSvXVN/k/UVtqb+BfssFa38svzVb4PVj1N2PsOuJD9iVO9of9B2DS1BoHgM1rrb2lqj41yYuS/E5VfUuS57XW3j5yaJMiUQ4AAAAAAABwhrTWfq+qHpHkd5L8cJIfqqo/T/Kuk2dtD9h6gBMgUQ4AAAAAAABwhlTV45I8K8ldc8eo9vdaYdZuhhyWKAcAAAAAAAC6VFXvl+SfJnlskvdLckuS1yT5qSQ/0Fo7qQf25FTVxyZ5bpKDxUuvT/J7Sd6WZA/q8e2GRDkAAAAAAAB0bpbKrGrsMDLL7mKoqscm+Ykkdzvy8lVJHra4fVlVfWpr7U92FtRm/PMcJsnfnuQLWmsvHjmeSZIoBwa1Ff8YVutmBA4AIEm1NS86XmW+ddteNt9ijJs0tLyanTzf0PrNVphvlRiGlr9mnEP7Sltl/QCAM2PV80sAMIaq+vAc9hq/Ksk7k3xHkl9JcmWSz0vy5Uk+OMnPV9XDWmvvHCvWNXxUDodQ/5eS5BcmUQ4AAAAAAAD05ntymCS/LcljWmu/deS9X66qVyd5WpIHJfm6JN++8wjXd/Xi/tdHjWLiXM4PAAAAAAAAdKOqHpbkUYunz1pKkt/uGUleuXj8NVV16S5i25DXLu6vGjWKiZMoBwAAAAAAgN5VUhO47ahE+WccefzsoQlaa/MkP754eo/ckVjfBz+Twy3598cOZMokygEAAAAAAICefPzi/qYk/+Mi0730yOOHby+cjXtGklfnsCf8R48dzFSpUQ7cKa1Of2lXtbaFSAA6VEvXPLb5OHHAsm3ui2u2XevGtOl1OdpeHaw0y3Lsbfm7f9Jy/qahDV4nvdz+JtuGO8O+CLAT65wPAoA1XVMn/N1prd2wRrsPXty/prV220Wme9XAPJPXWntHVX1ikucl+dWq+u4k/zHJH7XWbh43uumQKAcAAAAAAACm6LoVpjnVFVxVdUWSey6eXjTJ3lr7y6q6KcnVSd73NMsZU1WdO/o0yTcubjnpwoMkrbXWRQ65i5UEAAAAAAAALqxam8SIsDuI4a5HHr9zhelvT5TfZTvhbMVyNtxwMAMkygEAAAAAAIApeliSGzfc5hVHHt+6wvS3LO6v3HAc2/RtYwewDyTKgZ1btY7VFK5cA4AzYdd1vVexSturLn++ofrjK//vsaH/UQaXt2Zt8eVtMBuYZ5W65Vuubb5WvfVETXQA2CH1xwGYmBvXrEF+MUdrdF+2wvSXL+7fveE4tqa1JlG+AmcXAAAAAAAAgF6848jjVYZTv3pxv8ow7ewRPcoBAAAAAACge23tUek2a7ujzbbWbq6qP09yzyTXXmzaqrpH7kiUX7/VwNg5PcoBAAAAAACAnrxycf/AqrpYx+IHDczDGSFRDgAAAAAAAPTk1xf3Vyf5qItM98gjj39je+Gsp6o+e8vtX1tVf3ebyxiTRDkwWa3qxBsAR9Ts+O2MazU773amtHb8RjKfH78tqTY/dsvgbXkbH59msK21tTViOh7XSjGtsJ26dMa/V8u/iWfud3FZh3/3AE5jlfMqzrUA0LGfPfL4/xiaoKpmSf7R4unbkvzKdkNay3+sqldsOmFeVe9XVT+Y5DVJPmmTbU+Jo0gAAAAAAACgG621/57k1xZPn1hVHzsw2T9L8uDF42e21v56J8GdzquTPCTJc6vqdVX1b6vqIes0VFVXV9UXVdWLc5ggf1KSg8XjM+liY+4DAAAAAAAAHbjzI6ltLo4d+eocDqd+ZZJfrKp/m8Ne41cm+bwcJoqT5I+SPGNXQZ3SQ5L80yTfmOT9kjw1yVOr6tVJfjvJdUlenuTNSf5ycbsyyXsmuUeSD0rysCR/e3G7IsntQ8y8OMlTW2u/v6uV2TWJcgAAAAAAAKArrbWXV9XnJvkPSd4jyb8dmOyPkjy2tfaOnQa3otbabUn+XVX9cJJ/nOSrcpgw/6AkH5jki1ds6vbk+LkkL0zy9Nba72w43Mkx9DoAAAAAAADQndbaf0ry0CTfncOk+LtyWI/8ZTnsnf2RrbXJDz3eWruptfb0JB+Q5FOSPDvJ63OYAD/pdnOSlyZ5SpL7tdYe30OSPNGjHNhzrerEaaq1HUQCAJ1adTi0VaZbc2i1Y0OybXKItk0P93a0vVrzuuWBmJb/I2qrtr3c1tB8Q9tgebpVpgEANmaV8yEAwGpaa69P8nWL215rrc2T/JfFLVV13yR/N8m1Sd47h0Ou35zkLYvbK5K8bKL117dOohwAAAAAAAB61+abv2B83TjYiNbaG5I8b+w4pkqiHAAA4BTe9Gdvyutv+L5Tz3fZpVsIBgAAAIC1SJQDAACcwn3udU3e870+89TzvfUvXrCFaAAAAABYh0Q5cOatW7dLbXPgTFi13jDdO1bne9tWWd58oBb3unEO/V1famuw7cHX1gthub2h5Q03vfQ9XuF/m8G2hzbdbNxa44Nxqm3Ohdg3gE6oPw4AsBsS5QAAAAAAANC71oYvNB8jDtgBl2MDAAAAAAAA0BWJcgAAAAAAAAC6IlEOAAAAAAAAQFfUKAe4gFa10nSlXgoAPWnzzUwzZL7mfMvLG/rbPBBTHZtvYPmD67Lm3/621N5QTCstbeh656W2asVrope3+WzF+ZZjH1re0LZbNS4AOANWPa8AAJPR5usf0286DtgBZykAAAAAAAAA6IpEOQAAAAAAAABdkSgHAAAAAAAA6FRVXV1Vdxk7jl2TKAcAAAAAAADoTFU9vqpemeSvkry9qv5y7Jh26ZKxAwDYd63qxGmqtR1EArCiWrpWss3HiWML2vK6JakztH4rmer6rhHX4Gc3+Fo7cZqV2lp1vrW189prK7a9/J/G8H8Vy/v+wLoMRTTwnTk+0UCcq8y3TVOMacdW+uz22VlfP2CvrXIeAAD2UbU2ifMozqfvRlV9epKfSvK2JM9L8oFJPuLI+38nyROTPL219uoRQtw6R54AAAAAAAAAffmWJH+R5MNaa5+X5OeW3n95ksclecKO49oZiXIAAAAAAACAvnxYkue11t4w9GZr7dYkv5rkk3Ya1Q5JlAMAAAAAAAD05ZYkN58wzQ1J3ncHsYxCjXKAHVi3fplaLMBODNWBnUA9Ks64+fb2sdVrm5//Ws1vOz7NuXMbiup4e4M1w2cnH6KtXWt8FUOfy8z11WyZeuTASNQaB4AlbT6Nc0JTiKEPv5fk40+Y5qYk77WDWEbhaBQAAAAAAACgL89J8lFV9X9eZJoHJ/mrHcWzc3qUAwAAAAAAAPTl2Uk+N8kPVNVDklx29M2qenSSxyb5hRFi2wmJcgAAAAAAAICOtNbmVfUPkvxYkn+SpCVJVf1Mknsm+ZjFa08bK8ZtM/Q6AAAAAAAA9O72GuVTuLGyqvqsdedtrd3SWvv8JH8vyc/lsCb5ZyR5eJLXJnl8a+3XNxHnFOlRDjBhrWqt+aq1DUcCABewwYPXWm5rqO2hv3ErzXf8tZrfdv4L89XmG4xhVUfbmx//O1+57dhrbbbCYduxOIeuiR7YBsvN1JrXUg9tp3XbAoANWPd4GgBgD/10Vf16kn/WWrtunQZaa/8tyX9Lkqq6W5Jqrb1tcyFOkzMXAAAAAAAAAPvr45L8dlX9RFXd78401Fp7ew9J8kSiHAAAAAAAAGBf/Ycc1hKvJJ+X5JVV9R1V9R7jhjV9EuUAAAAAAADQu7HrkqtRvpbW2j9K8lFJ/msOk+VXJHlKktdU1T+uqoMx45syiXIAAAAAAACAPdVa+1+ttb+f5DFJfjeHCfN7Jvm+JK+oqn8wYniTdcnYAQCwea3qxGmqtR1EAuytWrqeco+v5G3L65Kktrk+Z2jbrR37Ntd5oO1jn+fQ8odemy+9Nj93vO1ztw4FcZEAL6K189pruWy1+erk7bm8DQYj3OQF5Mvbc+B7ttH5pmjHsQ/9lu2ts7QuwNatcnwLAMCh1tovJflbVfVFSb49yf2TfHCSn62qlyb5Z621l48Y4qQ4OgUAAAAAAAA4I1pr/yHJg5J8Q5K/zGEP80cmua6qnlNV144Z31RIlAMAAAAAAACcIa21W1trz0jygCTfleSWHOaGvyjJH1bVv6qqu4wZ49gkygEAAAAAAKB3rR2WKRv7pmzoRrXW3t5ae0qSD0ry73NYse3KJN+c5DVV9aSqPmtkqVEO0Kl167ypbQ6dGvpfeZ9rb++Dod/pff4NXqoHPlgn/lit8RXXd4Ua5XXutoGYzi1Nc7weebv15oHlrVujfH5eezVQonyobvnyntAOBg7jVqn9PRj30ucyMMXgV322p8fP6tzuXp/nWoABao0DAIyrtXZDki+pqmckeVqSxyS5V5IfTPLkqnpKa+3FY8a4a45YAQAAAAAAADrQWvu91tonJ/mkJC/P4XXzD0nyoqr6xap66KgB7pBEOQAAAAAAAEBHWmu/3Fr7qCRfmOS1OUyYf1KSl40a2A4Zeh0AAAAAAAA6V20+XCpthDjYrqq6S5IHJ/mQxf1rkrz/4u2DseLaNYlyAAAAAAAAgDOmqt4z5yfEP2Rxu++YcU2FRDkAp9Kq1pqvWttwJMDoaqCKz55c8duWYnel8kQNfC6Dn9XSa4PTzM8db2t+2/nN3Hrz8abffdPA4tbcX1obbO+8mC4//r1a/gtas4FpVtgGg3+Jq5uLxPfK8m/U3tjXuIE7bd3jRAAANqOqrsn5ifDbH7/30ORLz1uS1yf530duXZAoBwAAAAAAANhDVfUXSe4+9NbAazfkMBH++7kjKf4HrbWLX9l/RkmUAwAAAAAAQO/afBqjBU4hhv1yj4HX3pTze4j/fpL/3Vp7xy4DmzqJcgAAAAAAAID99JKc30P8f7fW/nLUiPaERDkAO6G2OXRiuT6tK4B3b49rx2eV3/wVapRnoIb4YM3uv77l/Oe3HK9RPn/XwIXWA/XOV9Hm8/Pam80G6oMPvFaXnf+ZDtZIr6XXhrbT4L6xtM33pcSsWtjT4HOAM0etcQCA/dNa+4SxY9hXjmoBAAAAAAAA6Ioe5QAAAAAAANC71lYb7W0XccAO6FEOAAAAAAAAQFckygEAAAAAAADoiqHXAZi0VrXWfGV4HpiGGrgus813H8cJ2kCctak492QbTNGqn8Gx6ebnjk80v+3YS+2Wd58/yc03HZvm3Nv/4vh85wbaX8X83PntXXLpsUlms4F9cXm6of11ab6hv4JD23No32fAFrfT3nwG+xInkGT94ygAAOiJI10AAAAAAAAAuqJHOQAAwCnc+Na35vo///5Tz3fpwZo90QEAAGAX2nwao+BNIQa6IFEOAABwCve++z3yPvf8/FPP92dv/Y9biAYAAACAdRh6HQAAAAAAAICu6FEOwJnUqtaar1rbcCTAMTVwraYhtVYz9Nu2r79b637mQ/PNz3+tBqZpt/318fmWXmvvvul40+/4y+OvnVtzCPX5/Lz2Zlfd9fg0l11x7KXl2Gt2/DCuLW2DzAa209B373hD6803RWv+L0D29zOHPbfuMQwAALAeiXIAAAAAAADoXLU2ePH5GHHALrhMHAAAAAAAAICuSJQDAAAAAAAA0BVDrwPAEWqbw0iW6+FOYJivNlCjd2PDj+1LnfZ9iXPZYB3z43XFl2t/t1tvPjbNX7/jXcfnO7feNmjz+XntHdzj+PKGaqnXcuz78BlcyD7Uvt5yjEO/LaObYkyw59QbBwCA6ZMoBwAAAAAAgN61+TQuzp5CDHTBZeMAAAAAAAAAdEWiHAAAAAAAAICuSJQDAAAAAAAA0BU1ygFgA1rVRtqp1jbSDuy9GriecwL1qdpSXDWBmFYy0e25lqG4V/ntnJ8baOr819ptf31smttuvmW95Q1p7bz2hpa3HFOSwdhPjGlfP98LGdqH98Dyb8YkTDEmmLBN/Z8PALAX1CinM46QAQAAAAAAAOiKRDkAAAAAAAAAXZEoBwAAAAAAAKArapQDAAAAAABA9yZSozxTiIEeSJQDwIS0qrXmq9Y2HAlMUA0MhjTywVsbiKnWjWm5rVXbWf7dWPP3YKPrsorBz/Pc9pY3ZH7u4s+TzG+97dhrbd1t3JbaG1je4Gu7NPS5bNHQfre2Nf+GbmqdN7oumzTVuGCL1v2fGgAA6IsjZgAAAAAAAAC6IlEOAAAAAAAAQFckygEAAAAAAADoihrlAHAGbLIOo3rn7JV163rvgwnWZJ+Eoe2yqd/AXdcH3+TylreButTDzvp2Oevrx5mmrjgAwPiqzVMTOPcwhRjog6NoAAAAAAAAALoiUQ4AAAAAAABAVyTKAQAAAAAAAOiKGuUAAAAAAADQu3lL5hOoDz5vY0dAJyTKAYDztKqttV3NP7lsWQ0MmNR2e4DXlmKoHS8/Q9/hoe/e8rZaNc6hbbyK5dnODSxvKfblbZkkG/2Fmh1c/HmSOthgDLXU3sDyBl/bkKHtObi/LJsNzTe7+PMLvbaKVebb4t+qVQ1uz10ae/l0aZv/JwIAAOyaI2sAAAAAAAAAuiJRDgAAAAAAAEBXDL0OAAAAAAAAvWttuHzbGHHADuhRDgAAAAAAAEBX9CgHAHamVW2srXJlKauqFa4NbfOtLb4NLL/WXd7QuqzS1tB3b4Xv0EZj31TbQ9tgNlthmoOBps5/rS659Phslw4cMq35W1ZV57U3tLzlmA6DOFieaGCaFbbBCoY+l01au/11tvkG12Xb2+WYXS+PM2+T/4MBAACcFY6+AQAAAAAAAOiKHuUAAAAAAADQuzbf6qh7p4oDdkCPcgAAAAAAAAC6okc5ALCXtllrU/3zDq1b+3tNW61bvuX658uxr/9NHIhzOYYa+C4OxHlse86OH+YM1gNfeq0uu+LYNJdefeVACOtdb1xV57U3tLxV4mwD63dsGwx9nqu+ts58q3wuq7a9rg21pR45Y1BDHAAAYPcckQMAAAAAAADQFYlyAAAAAAAAALpi6HUAAAAAAADoXLX5+qXhNhwH7IIe5QAAAAAAAAB0RY9yAIAlrWqny6vWdro8VlQrXFO6wSuc2wrLW+mK6qF2huZb3s+H9sNV21rH7Hjby01XHV/W0Haq5deGvsMHlx6f7/Irzn9+5dXHprnkLnc5Pt/Bmtcbz2bntTe0vOWYkhyPfWj9lrbB4P40MN+x6QY+l41a5Xu1ym/wKu0MWOV7tlG7Xh4btev/BwAAANgtR+0AAAAAAAAAdEWPcgAAAAAAAOhdm2909Lw7FQfsgB7lAAAAAAAAAHRFohwAAAAAAACArhh6HQBgZK1qa21Xa1trmyQ1cN3pFocHawPLq1WWt0qcQ/vh0P6z1NbQHrb2Hr0cZhuIuwaWODv/sKYdDGyTgXWpy644v5krrj7e9N3e6/h8BwfH219BzWbntTe0vOWYkqQdXLb0fOAwbmkbDH7mQ6/NZidPs8JrQ/vm4HzHpllxb1mlrSWDMW3TrpfHVv9+AgAAcPZJlAMAAAAAAEDvWptGfXAdP9gRiXIAAIBTuPGtf5E/ffMPnXq+yy6dwMkGAAAAAJJIlAMAAJzKNXe5a97nzz/m1PO9+R7XbSEaAAAAANYhUQ4AcIbtun6rmuhZrU7xBocxW67DvFLN8uR4nEPzrVK3fGB9N1W3fLAm+1C59eVphtZlqG75JZefP9/V7zEw27njMQzVCF/FwUEO7vHeF13ecky3z3ee5XrkSdrya7PjddRXqiO+Yq3xY22tWp97ld+kNWt9b7UmufrjK1EzHAAAgH0iUQ4AAAAAAAC9a+eSgQvGR4kDdsBl8QAAAAAAAAB0RaIcAAAAAAAAgK5IlAMAAAAAAADQFTXKAQDYmFa1tbarta21vXO1wvWqbb5W022VtpPUcvtD8w3FsPwZD30uA20tT7XSnnJw/HClnbttIKTz42yz9Q5zhmKa3XXoxYO12s9sltld73HH8i678tgk7dLLj792cNn5z4fWb+lzGdwPBrbnsc9q6LMbamuV/WyV34MV99dV9+u1bLPtCdrm7zQAAADsE4lyAAAAAAAA6Fybz9Pm6124v+k4YBf6unQeAAAAAAAAgO5JlAMAAAAAAADQFYlyAAAAAAAAALqiRjkAAHuhVW2t7Wpta22vrVa8prWtV7erLbVfQ+2sFMPAfEPbc6mtoS2+0id8cPwQZrmtoXbW/oSHtsHsYP22Lr/6b562Sy49Nkk7uOz4a7OldR5Y/rFpBrbT4Losfy4rTDNo6Pu56j68ZDCGdWyqnRFs8/cOAADggubzZH5u7CgO44Ad2N8zBwAAAAAAAACwBolyAAAAAAAAALoiUQ4AAAAAAABAV9QoBwCge3td/3zdOsxLNclXrQt9rJb54Hyr1BI7Pt8qtcYHLdXjbrPjbde5244vbzn2detzr6oq7dLL73i+Sj3y5FhN8rZK/fEV12W1bbDCJ7Hidlq7/vgE642rIw4AAJw583MTqVE+gRjowvTONgAAAAAAAADAFkmUAwAAAAAAANAViXIAAAAAAAAAuqJGOQAAAAAAAHSuzc+lnRu/PnhTo5wdkSgHAIAtalUba6ta21hbqRUGl2rz4y+tMN9qa3y87dTB+ctqA8saiKmWXxuKeyiE5XUZ+KwG12WVbTeokoPL7ojp4NJjU7TZwCHabGl5Q9MsxTT4OQ2+tsKntcL6rrJfrNv2Jm3y+wgAAADsN0OvAwAAAAAAANAViXIAAAAAAAAAuiJRDgAAAAAAAEBX1CgHAIA9sc36yoP1z9esH71KJfVN1TFPBmqZD9UxHwzi/OlWrgC/7udQdV5d8sF65Acr1B9foUb5yjFuqv74BmuNqyMOAAAwkvn88Da2KcRAF/QoBwAAAAAAAKArEuUAAAAAAAAAdEWiHAAAAAAAAICuqFEOAAAAAAAAvZvPk/m5saNQo5ydkSgHAP5/9v49Trf0Lgh8f8/7VtXevbs7nZB02yHhGoiJ4UQuCRcV5HLOjHgZL8DgMIKD8kGFUUGRoIdzBpxxHMS7o6gMBzzqyOWMih8ugwNqFIUQRAQ0CSSQG+nQnZBOp3v33rvqXc/5o6rT9T7rt3etWvu9Va3v9/Opz6711HP5rWet99311rPW+gFELWVlfZUBD66qJalTmw/CSZ3S1jkesO181HglqVO7bF/GzlWJunfw7Oas/3GsJmW9eciOVbZ/bd8D6gzpJ+97decPAAAAwCZ49DoAAAAAAAAAk2KhHAAAAAAAAIBJ8eh1AAAAAAAAmLjaLaLuQI7yXYiBaXBHOQAAAAAAAACT4o5yAAAmr9ZtR3DJlDKy3Xx5MzkwtSTX+tau6adfp7R1jjs7s++SjTdy96KUiPnBs+PNko9j2dw1MaRzcEab26ljj1Xbj9fQSq3osAAAAAB34I5yAAAAAAAAACbFHeUAAAAAAAAwdbWL6JInsm0jDtgAd5QDAAAAAAAAMCnuKAcA4MKSF3m9urETnDSbjUi6XAcmAy+z+dmV6tm5zbM85vkMjE8gvZSXPIk7zT/ey1F+9viDD93IQzz63GiMOS+mYJXvbaYYAAAAcu4oBwAAAAAAAGBSLJQDAAAAAAAAMCkevQ4AAAAAAAATV7suarfYdhhRu35qNFgHd5QDAAAAAAAAMCnuKAcAYOtq3XYE29dd0EkYGvVijftXRnY9K/PlfmbzXp1SsmuLy7gBo0Sd739wqybjZdPUOzcGzOUunE1DZmkXz/tZGXt8d9OYKb5kUwAAAAApd5QDAAAAAAAAMCnuKAcAADiHRx57V7ytvv3c7Q4e8/ELAACAHdYtjr+2bRdiYBL8pQYAAOAcHn7whfHgm19y7naPPfiWNUQDAAAAwBgevQ4AAAAAAADApLijHACAlal12xFsX7eDk7DOiLrd293Bajszyb7MyzxpWUaOWKI71d9i4ORd1DmejZ2mAdbY9ejX8KysM6rNGvs2dommAAAAgAmwUA4AAAAAAABT13XHX9u2CzEwCR69DgAAAAAAAMCkWCgHAAAAAAAAYFI8eh0AgDPtYNrtrdh2/vFVjr6qvNd15JysMu/22K6GpFPukkuLe7nNB6pR4/DUjg/NUT5mtFWmih6ba7xbYRRtDOs85mMNfX+4TLnMW0PfDi7xFAAAAHCBWCgHAAAAAACAiavdIupise0wonbbj4Fp8Oh1AAAAAAAAACbFQjkAAAAAAAAAk2KhHAAAAAAAAIBJkaMcAGDiat12BNvX7cAkrCqCbmRHdeQcDB1vSLVNxz7EIut6dJwRt051uM64Symj2s2SZtkcDOl9NnKistiHnBtZ7K0hEY2bueGGvN/MRh6/i6Kdgku+uwAAAOwoC+UAAAAAAAAwdV0X0S22HcVxHLABHr0OAAAAAAAAwKRYKAcAAAAAAABgUiyUAwAAAAAAADApcpQDAExMrduOYLO6Le/wKkfvVthZHTAvQ8YbGlLb16Dxs/EGDJjFPWS8TClJ/6N6Op6rW4tn4xgfUz+oWVuU9J3tS3vl9CIJadB4iSHnT9ZPNi9ZDKsarzf+2VUiImJAV6MNed+aDZiTi2LoS+ES7TIAAOymbrEjOcp3IAYmwR3lAAAAAAAAAEyKhXIAAAAAAAAAJsVCOQAAAAAAAACTIkc5AMAlJh/55q0qgrH5yIfmvV5V/vGhcbZxDck/PjTXeNtXNgXZuTEk9JLUGnua1Rpxa/FstGNzYWd5ttvczdkV0Vme71raOv12s3TOz04Wvao85hERswGzNTaP+ZA4M21Xm06fnZ3Tlylveabd5Uu+uwAAsHG166J22Sf2zccBm+COcgAAAAAAAAAmxUI5AAAAAAAAAJNioRwAAAAAAACASZGjHAAAAAAAAKau6yK6xbajOI4DNsBCOQDABVXrtiPYvm7Dk7DO0bqRndcBczCk76HDt31l42cfZ9tqWUxtX0P6iYhYtO0G1BkaU2bsaVdrxNNHd248K/2y0pTNkzptu3nbKCJKcpTbfSlJu5rF1PSVPaqsi37DNs5sNpLhescmm6f2/Mn2JTOk7yGGnhYjux8ke0+cDZyHi2joa/ESTwEAAAB3waPXAQAAAAAAAJgUC+UAAAAAAAAATIqFcgAAAAAAAAAmRY5yAAAAAAAAmLq6iOgW247iOA7YAAvlAAAXQK3bjmD7ug1PwjpH60Z2XgfMwdC+h1TL+mpj6LK+k3ZtX9m+tH0tkgAWSd+Lpq9FElRbJ+v/MOn8sOt3NvZc7GqNx28cfnB7f9Z/wNf+vPTK5rPlsqRKzJuuuqxOUhZN37P0uPQbtpFn4w3pa5a0y2a3rZadm21f2TlWSjYJ5+/7brTdr7DrVHu+zgbMwWXTngoTnAIAAAASHr0OAAAAAAAAwKRYKAcAAAAAAABgUjx6HQAAAAAAACaudl3UJAXZNuKATbBQDgCwY+Qjl488Ylg+8qH9ryofeUQ/j/iQfORZX1mu8fa4D8lHHhFxtDi7zvXDRa/s5lF3Zp0bR/0P54cjD+pRV+NXnrz1we2re/0HfF3bn/fKrjT1sjq1NkmX50MyfUfvYNUkefM8OYN6ucaT0YbkLU/znw/IW56lmG4PS9rPDuYtH3ikViZ7f51a3vLsfWtiUwAAAEB49DoAAAAAAAAAE2OhHAAAAAAAAIBJ8eh1AAAAAAAAmLqui+j6acm2EgdsgDvKAQAAAAAAAJgUd5QDAGxZrduOYPu6SzQJ3chdqQPmYEjfQ4dv+8rGz67fbqtlMQ3pKzvmi9pu9+scJRe2HzZXmt846kd+/bDf8Mlby2Xve/qwV+e912/1ym4txl3Zfth18Uvvu/7B7edfO+jVed49+72y++r8zL6v7rXXQCfXRM+zs6M02/06pbR1ImbNsel6/eRXZXdNtbaf2/bVFA3Zk+zcbPuJ6J+v2f5m2v6zvi+K9vU4GzgHl0n2FjzBaQAAAJgUd5QDAAAAAAAAMCnuKAcAAAAAAICp6xY7kqN8B2JgEtxRDgAAAAAAAMCkWCgHAAAAAAAAYFI8eh0AYINq3XYE29ftwCSsKoJuZEd1w3MwNs4hsn3pknqLJogspLarRdLRIhnvxtFyxeuH/Ue0PXmrX/a+pw+Xth954kavzn/65ff3yp6+edQPbICbh138h7e974Pbr3jRA6P6GWK2X3plpeuXzZpLp2u/Su/YHTdcrjjLzumSdDZSG8JsdV33ZOd0GbAvA6ZpeAxJ2Rp3uSd7n56t8HheFO00THAKAAAALjV3lAMAAAAAAAAwKe4oBwAAOIenn3xPvG72L87drj4xX0M0AAAAsCLdIuqi/0S2bcQBm2ChHAAA4Bzuue8F8fHvecW52/3cc96whmgAAAAAGMNCOQAAl9r2M6KPMzSv+Nj9a/MwZ3nFs7TTQ+LK2rVFQ/KPZ/nIDxdnl9086nf+ZJJX/L3Xby1tv+2913t1fvGdT/THS3KgD3F41C31d9/V/V6dg71+dqz9JtF1u31cttzucJbl2e7H1KuW5DGfJwm7eocm6TvN2X32cGm+8yE5wgeEtNI84ps2ZP8AAACA4eQoBwAAAAAAAGBS3FEOAAAAAAAAU9d1x1/btgsxMAnuKAcAAAAAAABgUiyUAwAAAAAAADApHr0OALAmtW47gu3rLtkkdCN2p65wDob0lMW40hiavrKHoQ057l2yN23sWTeHyePXbi6Wy24c9etcP1z0yt5//XBp+5HHn+7VefzRp/pxHh72yoZYLLql/h55wbVenYfuv9Ire86V5Y9t9+zPe3X2512zXfp1ar9dO+el9Cd9Hv2+2mNcSr/OLDuASb0h+uddMl5TlJ2F40bPX0PZPrey12Mb50WRva5nI4/nRbXCUxoAAIAdYKEcAAAAAAAApq7rIrr+heZbiQM2wKPXAQAAAAAAAJgUC+UAAAAAAAAATIpHrwMArMglS8d9IV3kQzAm//ldjddsZ+fvkJiGnvdD8o+3ZYeLfqW8bHlv2pzlERE3krIP3Dha3r7ezz3+1BPXe2Xd4qhXNkS36Jb6y8ZrY4rox57t39Wm7HDRvyb6cJbkH28SLA89D9oU6Ol5kORubvvKrtzuknbrvMK7F9MFyTm9yhzsjNee+3KWAwAAXBwWygEAAAAAAGDiareIugM5ynchBqbBo9cBAAAAAAAAmBQL5QAAAAAAAABMioVyAAAAAAAAACZFjnIAAFamq3XbIaxMN3JX6obnYGyco8cbUCcLaci0dE3L7HzKyhZN0WFbEBG3jvqRP324nPPs1s2jXp2jp5/sldU6ZBYStS71l43XxhTRjz3bv7Zo6Ny1cz6P0quTHbvar5b03Tc/u9lo7WthNiDGu9G+1ksZNuCm41yn9pyaDZwDAAAA2AUWygEAAAAAAGDiatdF7UZeHL7iOGATPHodAAAAAAAAgEmxUA4AAAAAAADApFgoBwAAAAAAAGBS5CgHABih1m1HwEXWDTh/xp5idYUn5yr7amVzMHa4bkDDRTJgW9Yt+nW6o1vjgkrUqEv9ZeMNiTMzZA7SmJpm2VDzMqrr24zXDFDGdZ6dm2VAX9ksta2yOZitcA643LKX4sjTHAAANq52Nepi+/nB65A/nMAKuKMcAAAAAAAAgEmxUA4AAAAAAADApFgoBwAAAAAAAGBS5CgHADiDfOS5sTmRV2n7EVwMWXaxIbmpB/WdnAdZX92KjtZiwHk39tzMclyX2XxUX2n/TX9DcmpnBuVkX+HrMzt2pS7HXpI68wH7l+YDz+qVs+swLAf7OmXn5kyCbnnLAQC4MOqi240c5TsQA9Pg7wsAAAAAAAAATIqFcgAAAAAAAAAmxUI5AAAAAAAAAJMiRzkAAAAAAABMXO26qN3284PvQgxMg4VyAADgUpmV0iubz84um+8lda7c0ysrSf+DlNlSf+l4A+LM9g8AAACA87FQDgAAAAAAALACpZQPj4jfFhGfGREfHxEvjoh5RLwnIv59RHxnRHxPrfVoSyFywkI5AAAAAAAAwF0qpfzZiPj6iMgeB/eik6//KiL+RCnl82qtb99kfCybbTsAAAAAAAAAgEvgQ+N4kfypiPgHEfGlEfGbIuJVEfHFEfH6k3qviogfLqXct40gOeaOcgAAAAAAAJi42nVRF922w4jabT+Gu/DeiHhNRHxLrfUDzc/+fSnlH0XE/x4R/3VEfGxEfHVE/I+bDZFnWCgHAGjUuu0I2LTOMb8w5qX/5LJZUzZPHm52sNd/mNY9+/Ol7av37PfqXLm3f2F3mc17ZUOUWVnqLxuvjSmiH3u2f/05yJ7wxi7K3n9mDt+l1/6u4SULAACXQ631NWf8fFFK+YqI+F0RcRARnx8WyrfGo9cBAAAAAAAANqDW+t6I+JmTzZdsM5aps1AOAAAAAAAAsDlXTv690M+Zv+g8eh0AAAAAAAAmri52JEf5cgwPlzNyFdVa37nWgFaslPJQRLz8ZPON24xl6iyUAwDASFVC+5VqP/e2ebdvV9bm7N6b9x+ctT/rlz332nKO8Offd9Cr894XXOuVPbrXrzfEbD6LB071l43XxhTRjz3bv3YOhs6dvMgAAADsuNcPqHPRPt3+qXh2jfa7txnI1Hn0OgAAAAAAAMCalVI+JSK+6mTznRHxt7YXDe4oBwAAAAAAAHbRqyPi3dsOYhVKKb8mIv5/cbw+WyPi99dar283qmmzUA4AAAAAAAATVxdddIvFtsNoc5S/ex05yEspexFxuIKuvrTW+h0Dxrs/Ir4/Il58UvRnaq3/YgXjcxc8eh0AAAAAAABgDUopVyPieyPik06K/nKt9X/ZYkiccEc5AACwUrPSL6t1ubCW2quz6Bf1zJNLffebwv1Z16tzbX/eK3vg2v7S9sMP3NOr8/gL7++V/dLBuI9Re/NZPHSqv2y8NqaIfuz7yQS3c5DN0xDZsZtFvzCrN3W19k/gUkwUAADALqq1HpVSXr6Crh650w9P7lz/7oj4rJOi/63W+idXMC4rYKEcAAAAAAAAmJRa6xvX2X8pZRYRfz8ifsdJ0XdFxB9a55icj4VyAACAc7jx5GPxutn504h1H+jf1Q4AAAC7otYuatd/Sts24rgk/k5E/N6T778vIr64XqKduwwslAMAAJzD1fsejE987yvO3e4/3v+f1xANAAAAsGtKKX85Ir7sZPNHIuLza62HWwyJxMjMdQAAAAAAAACcVkr5hoj46pPNfxcRv7PWenN7EXE77igHACat1m1HwEVWSumV1YmdVLNkDhYj52AWy33NZ/1+Zl1/vP3ZctnVvf71wIddv6/7ryx/HHrhc6/26uzN+uP99P64R6gf7M/i4170wAe3H3zOlTNjioi40uxPtn/tHGTHZZ5cJt3O+VjZeFOTvR/AUNnbplMKAAAunlLKH42I/+Fk85cj4msj4qPO+Mz4Jnebb4eFcgAAAAAAAIC793mnvn9RRPzogDYfFRFvXUs03JGFcgAAAAAAAJi4uuiiLrpth7ETMTANFsoBAAAAAAAA7lKt9TO3HQPDWSgHAIBLLklNHW2q77ROlr96ZP7xNhVXlpmrrZPm2U7K2nr7STLuq3v9uLva5Bq/96BX574kZ/hBkiN8iP35LD7qwXs/uN3mHo+IuJbkP29zkmf7187BkHmKSI5LcmBWmSe5zcmWpIBPxxs34wAAAAC35+8NAAAAAAAAAEyKO8oBAAAAAABg4uQoZ2rcUQ4AAAAAAADApFgoBwAAAAAAAGBSPHodAIDJm5V+WVc3H8cqlNLfmVpXtzPtlbaLLIYVjZXsSuzP+4WLulzW1X6dK/OzrxHeT06Ew/3+3O1lJ8wA81Lieffs33G8/STONva8XbnjdkQ+n2MN6WqdV2Vn5/lFNfJ0AgAAAO6ShXIAAAAAAACYuNrVqN3284PXi3r3AheOR68DAAAAAAAAMCkWygEAAAAAAACYFAvlAAAAAAAAAEyKHOUAALBhs9Iva9NvJVViFzN0lYGBtvtca79hLXVAnX7f8yaI/Xm/0iJr2Fw3PEt25krWKutqgFmJuO/gzh/B9pPO2/3J9q+dg2xfZslZ1Q43pE4mPQ920JAwxx5fAACAi67ruugW289R3u1AnnSmwR3lAAAAAAAAAEyKhXIAAAAAAAAAJsVCOQAAAAAAAACTIkc5ADApdReTPMNdaPMpt7nOV9l3RMRiQP9ZfuxF8+LLclq3RUPqZONl4+/PsmuEx+U8K6MTcpc0B/lpWf7xNvY0/3hTls7dgLKhu5bFMKzdqGZb7xu2IfudZfTbDwAAAD0WygEAAAAAAGDi6qKLuhh3Ufmq44BN8Oh1AAAAAAAAACbFQjkAAAAAAAAAk2KhHAAAAAAAAIBJkaMcAIALqzTbdStRLCtlOapatx9VG1NExKyJq+tXiSz0tq+2n4iIRRbDHSM86aupVUvSdxLTvLn8t6v90bpZv2Fbr1vzZcSlRMxnd56JeXKs2v0bUieTDd3OeWbYsUvaJXH266yur03byZi2HQAAAHChyVHO1LijHAAAAAAAAIBJsVAOAAAAAAAAwKRYKAcAAAAAAABgUuQoBwCARJbPuVtjuvF2vGysLP9wW23TcWfyvNNN/vEko3yWf/ysfiIi+inJh+3wosmvvkgmqktysI/NO19rjcNTedZmWe74ZO72B2Sebvsakns87+fsviPyY7xJZ6R6j4jh+bqH9LVKmx4PAABgsFqjdjuQH3zk5244L3eUAwAAAAAAADApFsoBAAAAAAAAmBQL5QAAAAAAAABMihzlAAAAAAAAMHF10UVdbD9H+S7EwDRYKAcAYJRZKb2yrtYtRPKsfkQR240ooiTzVLc8TxH9uGZJTF0yoe0jqbpk1rO+Fu34aUznrxMRvYOcnZvZZ+yuaXfYFkTEzaM28n67oWqNuH74bH9X9ua9OvPZ2bFfmWeTsCybpyFlZ/d8rD0PsvM82ZXeeNkjzrK+tm0nY9p2AInstQcAAAC7yqPXAQAAAAAAAJgUC+UAAAAAAAAATIqFcgAAAAAAAAAmRY5yAAAAAAAAmLi66KIuum2HsRMxMA0WygEAYKBZWd7u6ubGut14bbUspKF9DVGGDDiyXRtnrf3AF0nDtu+uDgvqsPngff1w0avzxI3DfgwD+8/ave/pZ/t7ztV+nXlyrK7Mlx8Elu1f6U1w36x3tuTnRr/vs+ussl1mUJwr6meVNj0eAAAAMJxHrwMAAAAAAAAwKRbKAQAAAAAAAJgUj14HAAAAAACAietqF123/fzgXd1+DEyDhXIAAC61LEXwqlKLj839neWTrgPyXg8Zb+z+ZjHNkpjaj6ppTFku7Kavmow3JPd3Nt5iwA5meb0Pm8l78tZRr8473vd0r+zm4bgP7EeLutTfRzy/vzNX9/oP/Rqac/20sbmxZ9l5kNRrz5eh47V9DcmtnllnPvKxMa07H/kupjvPzhcAAAC4KDx6HQAAAAAAAIBJsVAOAAAAAAAAwKR49DoAAMA5PPn+R+N1s0fO3a48Pl9DNAAAALAaddFFXWw/P/guxMA0WCgHAAA4h/seeChe8e6Xnbvdm577pjVEAwAAAMAYFsoBAFiZWSlL212tW4rk4inN3NWBczdbbhZd0qz0i4a1K/2WsyauLuk8y+/UNVGU6A9YmqJk+HxfmtL2PIyIWCTzedhcoX79cNGr8873Pd0ru3XUrzfEYdct9ffgc66cGVNEP/Zs/9o5SOduwHzm7ZLxSlun3y47D7K+zuo7Ij/uQ9oNMSQmAAAA4PKRoxwAAAAAAACASXFHOQAAAAAAAEzccY7ycU9RW3UcsAnuKAcAAAAAAABgUiyUAwAAAAAAADApHr0OAMDazErplXW1biGSZW1Uq4xo1nTejey8JHNXB8xdO/7tYmirDW7XxDVLYuqSvtordNNdaYKoSQC19jsvZdwkL5pmT9/qP17u0Sdu9Mq6kQd10dWl/rLx2piGak+XWe8I58d43hRmV1Jn7frjZXWShkP6PrNV3m6IITENNTaGIdbY9WjZ+zkAAABcZO4oBwAAAAAAAGBS3FEOAAAAAAAAE1e7LmrXbTuMnYiBaXBHOQAAAAAAAACT4o5yAAAmL8u8u6q85UNzfw+xzrzl2RwMapfENCRv+ZB28yzHfZKPvI1znlwOnPU1b4oWyYG5dZRcxT7y+NW63F82XhvTcdlyYbZ/7Rxk6aSzOWi7yo5L1teQdplenINajcsHLh85AAAAcCfuKAcAAAAAAABgUtxRDgAAAAAAABNXuy7qYvv5weUoZ1PcUQ4AAAAAAADApFgoBwAAAAAAAGBSPHodAICNmpXSK+tq3UIkd9aPMmJVUc6yzhvdwMFKMp+tmsxvG0M2XtbzoNiTlrM2huSS3UW33K4kMz5Pxq/NHMyTIPeThu25eLDXDyrra6zS9JeNl70+2tizmObtHCRhZ6dKe/7Mk+OSXV3dths6TUOqDelryHk/1AoP8SAbHm6U7DwEAACAy8ZCOQAAAAAAAEzdYjdylMcuxMAkePQ6AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCkyFEOAMDWzUpZ2u5q3VIkd1bOrhKrinw2ZLCI6AYMWEq/s9rM8SrHy/rqmtmbZce4vYy3SzpKLvWtzazv1367a/vzM8vuPeh/PLr/ar8smc5BZrOy1F823pA495MJns/a7aROEnjbLruSOjt/2u6HTsnQ82xIDOsaa6wND7dS7XswAAAwTd2iRrcD+cG7xW7+XYjLxx3lAAAAAAAAAEyKhXIAAAAAAAAAJsVCOQAAAAAAAACTIkc5ADApbRrWHU2FPXlD8+XuYi7zTeYxjxiWhznLKz4m53NExGxA9Nl48/a1l4xfmnazWb+jWZJ/fMjVv13t17r/ynLu7weSfOQPP3BPr6yMTH49n5Wl/rLx2pgiIg6aROIH7WRGxEETU56jvB9Tex5kuzZkb4dOydjzbux4q3KRM3jLP35xOXQAAADrZaEcAAAAAAAAJq7WLmrXbTuMqHX7MTANHr0OAAAAAAAAwKRYKAcAAAAAAABgUiyUAwAAAAAAADApcpQDAHBhzUpZ2u5q3VIk51POrhKr3JPZkAETXRJEKWd3Nk+q1AHHpm1Wk7FKGlO7nbSLJL/Z1f2lzRtH/Tof/dC9vbL9vXHXG+/PZ0v9PXTvQa/Oc5uYIiLu2Vven4N5f/y2aJ7MQXYetEVDz5Uh58EQY8/NVdqBEFamfU8EAAA4j7rooi62nx98F2JgGtxRDgAAAAAAAMCkWCgHAAAAAAAAYFIslAMAAAAAAAAwKXKUAwAAAAAAwMTVRY26qNsOYydiYBoslAMAcGnMShlUr6u7/4Fr2J6sTjYjs1UGMeDYzJvtbuBhag/nInlu1v6sX7g/W244f86VXp0shnv220iHubI3i1c8dP8Ht1+UjHfvXj/Og/ny3M2TA9NUiTLwtbDSY7wiOxjSxg19LwMAAADG8+h1AAAAAAAAACbFQjkAAAAAAAAAk+LR6wAAAAAAADBxXddFt+i2HUZ03fZjYBoslAMAk5algb0A6au5S6vK/3sRcp0Pte6MyGPmvM27fXvjom+P3/21n3v8OQf9smsjc5QfzEu84sFrp/rpP+Ar2+ddzFd9mc79ddrFY8ducqoAAABsnkevAwAAAAAAADApFsoBAAAAAAAAmBQL5QAAAAAAAABMihzlAAAAAAAAMHG1q1G7uu0wdiIGpsFCOQAAjDQrZdshbN3YKSh1wIfe2iXt+mW9et2i36476rdrysrhzV6Vew+v98r2u8N+XwPsdYfx4JNv/eB23b/Wq1P3r/QbzpY/ttVZ8jFuNl/eLv2Hh9WkLKvXb9c/yPMBB37IIQYAAADYFo9eBwAAAAAAAGBS3FEOAABwDo+899F42/yRc7c7eM/87EoAAAAAbISFcgAAgHN44fMfihd84GXnbveeF7xxDdEAAADAatRFRLfYfh6t2s+oBmvh0esAAAAAAAAATIo7ygEAGqUsb9ftX0gLK9ee56P7GfoCqV3TrjuzTvbiK91Rv11TVo5u9dsd3eyX3Xxqebj3P9qrc+vNP9MrO/rA4/0YBqg3nopbr/vBD24ffMwre3VmDzzUb3fl3uXtvSv9OnsHTUfJR72srD0RSnIt9dCys/q+C96HuWxW+PIAAABgJHeUAwAAAAAAADAp7igHAAAAAACAiauLLuoieQLcFuKATXBHOQAAAAAAAACT4o5yAAC4wNaZ53ZQ/vEs13jaV5t/PGnXLZbbDMhHHtHPSZ7lI5/d+EC/q/e/Z2n78B0/36vz7h/9qV7Z4ZP9/oc4evrmUn8v3D/o1dn/sP68zB54wdJ2d/X+fufNfPZylkeeF762ecuzdOT9ohiSMrwMuC67DjyBx5zn8poDAAAAd+KOcgAAAAAAAAAmxR3lAAAAAAAAMHG1q1EX2388V+22HwPT4I5yAAAAAAAAACbFQjkAAAAAAAAAk+LR6wAAZyilX1Y9AYq7kJ1TG49hyElcuwH9JHXSsnpmndIdLRe02xFRjm4lZTeXt2893R/++vt7ZYv3PrK0ff3t7+jVec8b3t0rO7y16JUNsbh5tNTfAy/pj3fftft7ZWV/f3l7Nu5jXE2atadielaUfmkpzfEr/Wuwh7xNloHXbtcRL5pVvs6853M3duE9HwAAgD53lAMAAAAAAAAwKe4oBwAAAAAAgInrFjW6xfYfqbULMTAN7igHAAAAAAAAYFLcUQ4AMIK85UTsZt7ZQbnHMwPykR/339Qbko88qTckt3lZ9HOUR9fPD14Wy3nLy9GNXp3F00/1u3ry8aXtpx97vFfniXd8oFd2OHKOu6Nuqb9svGsv7pd1Tz9/aXt+9d5+5/P50mZN8phn81mb3OLZccn3tr3mOsk5n7Rqx0vPnyTf+ZDzekwe86HGdu3/henZxf8XAAAAyLmjHAAAAAAAAIBJcUc5AAAAAAAATFxddFEXw544t+44YBPcUQ4AAAAAAADApFgoBwAAAAAAAGBSPHodAGBFSjm7Tq3rj4NlQ47LRVFWeQLVsx9jVrI6A9oN6ivrZ3F0Zp3SHfXKYrFYbnZ02KtSb93ol91cLjt8ql/n5hM3e2VdjYgR51Xt6lJ/2XhtTBH92LP9i73lOSjz/jzV2bzfrp3z0r+WOtvVmtTrV0qO35B+snNjwHhDXh91w28I6xzO/yebd5n+PwEAAMBCOQAAAAAAAExeV2t03favyu1cGcyGePQ6AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCkyFEOALBBpZxdZ4ppmIbMy9SUVZ4ItRsw3tl18r6TOLO+2rKkTi+GsX0f3epXOTzslXVHy2V1sei3W/RjGH1k6nJ/2XhtTBFJ7Mn+DZnfbD7bOa9Dz4NeveQa7AEv7Oy8qyXpq62X1Rkge13VC/oGtM6w/T8EAAATtajp5+BtxAGb4I5yAAAAAAAAACbFQjkAAAAAAAAAk2KhHAAAAAAAAIBJkaMcAGDHyJM6TSvLST4wx/SgnOQD81yvrO8xdQYq83m/bLZ83fDsYL9XZ++e/kem0S/RWVnqLxuvjSkij32UdD7nZ9dJ8oH3cpunecWzc+XsXOOD8pYPjHOI9rV3UXOWr5IpAAAAYAoslAMAAAAAAMDEdYsa3WJ1F63fTRywCR69DgAAAAAAAMCkWCgHAAAAAAAAYFIslAMAAAAAAAAwKXKUAwDAGpW65rxadcu5w7Y9fmY275ft7feKysHVpe2D+6/16tz7UL9s/60lYsRhnc3LUn/ZeG1MEdGPPdu/bcvOg7Lh67LbGEaOP/Q1W0sZ1T8AAMCuql2NugP5wWu3/RiYBneUAwAAAAAAADApFsoBAAAAAAAAmBQL5QAAAAAAAABMihzlAAAAAAAAMHF1sSM5yncgBqbBQjkAAKxQqWv8MFe7Uc3KkHYj+94JZflBWWVvv1dldnC1X3b/85a2rz30vF6d53/sh/TKDn5qFnF43iAj5vvzpf6y8dqYIvqxZ/tXywV9WFh23iX70p7Dg/Z3YN9jta/1WsrK+gYAAADW74L+NQUAAAAAAAAAxrFQDgAAAAAAAMCkePQ6AAAAAAAATFy36KJbbD812y7EwDRYKAcAgJHWmo+cPJ90VjafL2/vXek3u+feXtns/ucubV/50Bf16jz0qpu9soPv+6mIx/thnGV+dT8eetVL7zheG1NEEnuyf705GDp3rEz2fiBvOQAAAOwufykBAAAAAAAAYFIslAMAAAAAAAAwKR69DgAAcA6/cv3J+OXyw+dut/+kR/UDAAAA7AoL5QAAAOfwa67dFw8//hvO3e5X7nvdGqIBAACA1ai1Ru22f5F3rduPgWmwUA4AAAOVTX5Qq92oZmVkuzyGzX4wrWU5M1Qp/X2ps+QjTLvP8367cuVar2z+QFNnNu/Vuf/a/f121/5ZxOP9MM4yu3I17v+4X//s9r3P6de5/7m9sjb2Ot/v1WnnJZ2nUvrtyoazcbXnVBLTENl5PmhfstfHGucge8+oI/cZAAAAWC05ygEAAAAAAACYFAvlAAAAAAAAAEyKR68DAAAAAADAxNVFjW6x/fzgdQdiYBrcUQ4AAAAAAADApLijHAAAEqVe8quXa7fd8Ut2zW53dp2SHJfZ8seamn3KmSV9Ne3mV671qsxf8KH9EA6uJAOcrewfxP5HvOyOdeqsH3zd2z+zTrsv+dwNuE56SJ11y87NXYhrRdr3llrKliIBAACAabs8f20AAAAAAAAAgAHcUQ4AAAAAAAATVxc16mLLT6ALOcrZHHeUAwAAAAAAADAp7igHAIBdsO2c4bugySM+NFV17zrzrFKW13t+cOd+IqI2dW7b1xCzeSzue/CDm2Vxa1i7Zn/qkPzjs3mvStouy90+Ne2JdonyoQMAAAC35y8AAAAAAAAAAEyKO8oBAAAAAABg4mpXdyI/eO22HwPT4I5yAAAAAAAAACbFQjkAAAAAAAAAk+LR6wAATF6pF/eRXqV22w5hmDLiGt2kSba7va5r6beL+ZnD1Vny8Wj/alJv5PXGZRb16v3P9nN4o1+lOxrd92k1m+8s7rZe1m7MsduC9rWQzsEOyt5/aumfwwAAAMBqWSgHAAAAAACAiesWNbrZ9m8m6HYgTzrTcDEusQcAAAAAAACAFbFQDgAAAAAAAMCkWCgHAAAAAAAAYFLkKAcAYHJK3XKuq9ptd/w1q6V/PW4Zss9Ju56kSm0Lu2Ss2YC+5we9om7/nrPbDVRLWeovi6gubp3d0dj9y+Z3yJwnsmN8aWTn6ob3N3uPqqVsNAYAAAC47CyUAwAAAAAAwMTVrouaXZy9hThgEy7xbQAAAAAAAAAA0GehHAAAAAAAAIBJ8eh1AABg87Kcz21u6LF5oecD282WPw7V+X6vSlfmvbLxKe7LUn8lGS/NQt0dLW8P3b9e5yPzmAMAAABcQhbKAQAAAAAAYOK6RY1uNvrq8JXGAZvgdgEAAAAAAAAAJsVCOQAAAAAAAACTYqEcAAAAAAAAgEmRoxwAgEutVHmtRiulX9bOZ0muva1dv6ipV5I6vb6G1BkqadfGlNXpkvNn/BlVl/qbD4kpIsqs+diWzctYA+Yzi2lMP8f1knOKQdr3smouAQCAFatdjboD+cFrt/0YmAZ3lAMAAAAAAAAwKRbKAQAAAAAAAJgUC+UAAAAAAAAATIoc5QAAAAAAADB1iy5q6bYdRcRiB2JgEiyUAwDAOlUf7jK19B9uVdq5Suqs1Mj+y4rDWO48iWmD85IdFyJ/HZsrAAAAuNB8sgcAAAAAAABgUiyUb0Ap5RNLKX+mlPKDpZR3lFJullKeLKX8fCnlO0opn37O/n5LKeUfl1LeedLXO0+2f8s5+rhWSvlTpZSfKKX86kk8byil/MVSyoeffy8BAAAAAAAALgaPXl+zUsprI+Izkh8dRMTHnnz9/lLK34+IL6u13rpDXyUi/nZEfHnzoxdFxO+OiN9dSvm7EfGHa631Dv28JCK+PyJ+bfOjl518fVkp5YtqrT9wx50DAAAAAAAAuIAslK/fi07+fVdEfE9E/JuIeHtEzCPi0yLiT57U+eI4Ph5fdIe+/qd4dpH8P0TEX4iIt0TESyLiayPiE05+/lhEfH3WQSnlvoj4vnh2kfxbI+I7I+LpiPisiPjTEfFARHxPKeXTaq0/c669BQDYonL7awXZpCF5tjdsbO7t+SzJSD46SXlZ7m8xrFUbey+X+zbIz7112ftdLaNPTgAAgOgWEV3Z/t9WuoGfl+FuWShfvzdGxJ+JiP+j1tq+tH/85E7yfxsRL42I/6aU8i211n/TdlJK+Zg4XgyPiPjJiPiMWuvTJ9uvL6X8s4h4bUS8KiJeU0r59lrrW5J4viaO7xqPiPjaWus3n/rZj5VS/mVE/OuIuBYRfzUiPvt8uwsAAAAAAACw29wGsGa11t9ea/3uZJH8mZ+/J47vKn/G59+mq6+OZy9s+KOnFsmf6ed6RPzRk829iPiqtoNSyn5E/PGTzTdExF9K4vmxiPi2k83PKqV80m3iAQAAAAAAALiQLJTvhn916vuXtD88yU3+O08231hr/fGsk5PyN51s/q6Tdqd9ZkQ89+T7v1frbZ/Z+B2nvv89twsaAAAAAAAA4CLy6PXdcHDq+2zx+qPi2Vznrz2jr9fGcf7xF0fER0bEL5362ac39W7nJyPiqYi4NyJ+0xnjAQAAAAAAcMHVrkZdbD9Hee22HwPTYKF8N/zmU9+/Mfn5y8/4edzm5y+P5YXyQf3UWo9KKW+JiFc2bQYppbz4jCoPn7dPAAAuv1qWH3hVbvsApPPL+up97E6Gyx7B1T62abgas8XhqfGS7ExJnKuch95wxUPGAAAAgGmyUL5lpZRZRHzdqaLvTqp92Knv33lGl++4TbvT20/VWh8f0M8rI+LBUsqVWuvNM+rfLgYAAAAAAACAnWKhfPu+OiI++eT7f1Jr/cmkzv2nvn/yjP6eOvX9fbfp56w+sn7Os1AOAACX1rsffSTevnf+a0MPHvXxCwAAAGBX+EvNFpVSfnNE/C8nm49GxB+5TdWrp76/dUa3pxe077lNP2f1cVY/Z2nvZG89HBGvP2efAACwEx5+6IXx4Jtfcu52jz30ljVEAwAAAKvR1Rpd3X5+8F2IgWmwUL4lpZRXRMQ/ieNjcDMi/uta66/cpvqNU98fnNH1lVPfP32bfs7q46x+7qjWesfHw5cyPqsjAADTkeXPXmve8qzv7ihpN+4De6k1ytH2HtQkHzkAAADAs/ylZAtKKR8VEf88Ip4XEYuI+G9qra+9Q5MPnPq+fZx6695T37ePWH+mn7P6OKsfAAAAAAAAgAvLQvmGlVI+NCJ+OCI+NCJqRPyBWus/OaPZ6Tu0X3xG3dOPPW8TJz7Tz72llOcO7OexWqv85AAAAAAAAMCl4dHrG1RKeUFE/F8R8dEnRX+01vr/HdD0P5/6/mVn1D398zck/XzeqXo/fps49yLimaSLbR8AAAAAAABcMotaY7ED+cF3IQamwR3lG1JKeSAifigift1J0dfVWv/mwOa/FBHvOvn+N59R9zNO/v3liHhr87MfPfX9nfp5VTz76PV/OyA+AAAAAAAAgAvDQvkGlFKuRcT3R8QnnhT9uVrrNw1tX2utEfG9J5svK6V86m3G+dR49o7y7z1pd9q/ioj3n3z/+0sp5TZD/nenvj/rsfAAAExJKctfg9vNlr92Qe3O/lrc6n+NvbK91qafAePXbrX7PEZ77IYev/ZcOc/5AgAAALBmO/IXqsurlHIQx4vNv/Gk6K/VWr9+RFd/NSKOTr7/G6WUe5px7omIv3GyeXRSf0mt9VZE/PWTzZdHxNck8X5aRPzBk83X1lpfPyJWAAAAAAAAgJ0lR/n6/aOI+C9Ovv8XEfFtpZSPu0P9W7XWn28La60/X0r5ixHxdXH8aPR/W0r5poh4SxznE39NRHzCSfVvrrX+wm36/+aI+MKIeGlE/IVSysdExHdGxNMR8VkR8Wfi+Lx4OiK+auhOAgAAAAAAAFwUFsrX7/ec+v6zI+Jnzqj/toj4yNv87P8ZEQ9FxB+I40Xx70zqfFtE3PaO9VrrB0opvy0ifiAiPjYivvzk67QnIuK/rbX+9BmxAgAAAAAAcAl0NWIxMtvYquOATfDo9Quk1trVWv9gRPy2OM5Z/q6IuHXy7/dGxG+ttX5ZrXdOZFhrfXMcL7S/JiJ+MiIej4jrEfGmiPgrEfHKWuv3rWs/AAAAAAAAALbJHeVrVmsta+jzB+L4jvC76eOpiPgLJ18AAKzKna9ZZFuy49KWJXXK4ijrbGwQS/2lvZQB1zIPqcP6teeL4wIAAAAXik/yAAAAAAAAAEyKO8oBAAAAAABg4ha1xqJuP0H4LsTANLijHAAAAAAAAIBJcUc5AAAXVnGF8XhtPuXLlFt97L50A/KYR0TczXl3ur9svPmAa5mzmC5TfuzLtC8blr0n1lK2EAkAAADsPn+BAAAAAAAAAGBS3FEOAAAAAAAAE7eox1/btgsxMA3uKAcAAAAAAABgUiyUAwAAAAAAADApHr0OAABcfrUbVtars+LnvZ3V35CYiuudAQAAAO6WhXIAAAAAAACYuK7WWKz6gvGRccAmuBUBAAAAAAAAgEmxUA4AAAAAAADApFgoBwAAAAAAAGBSLJQDAAAAAAAAMCl72w4AAAAAAAAA2K5FRCzqtqM4jgM2wR3lAAAAAAAAAEyKhXIAAAAAAAAAJsWj1wEAACKi1G7r41XXMgMAAABshIVyAAAAAAAAmLhFrbGo209SvgsxMA1uVwAAAAAAAABgUiyUAwAAAAAAADApFsoBAAAAAAAAmBQ5ygEAuLBqKUvbRQ4r7kIt/euISyw2Oh7cjfY9EQAA4Dy6GrHYgT+tdDsQA9PgLzMAAAAAAAAATIqFcgAAAAAAAAAmxUI5AAAAAAAAAJMiRzkAAAAAAABM3GJHcpTvQgxMgzvKAQCAnVRq1/tK1W75a6VBlPxrFf2t0oA5GDyfAAAAwMqVUj63lFJPfX3DtmOaOgvlAAAAAAAAAGtSSrk3Ir5l23GwzEI5AAAAAAAAwPr8jxHxERHx6LYD4VkWygEAAAAAAADWoJTyiRHxxyLiZkR8/ZbD4ZS9bQcAAACXSmmuRZUHene1xyq7jLiu+Nri02POkr7bmNhdjhUAAHDJLGqNRa3bDmMnYliVUso8Ir41IuYR8Wcj4he2GxGn+WQPAAAAAAAAsHpfHRGfGBE/HxHftOVYaFgoBwAAAAAAAFihUspHRsQ3nmx+Ra315hbDIeHR6wAAAOfwyGO/Em/b++Vztzt4zMcvAAAAOKeHSyl3rFBrfeeGYjmvb4mIaxHxD2utP7LtYOjzlxoAAIBzeOGDvyZe8IsvPXe79zz482uIBgAAAFajqxGLHUgP3i3H8PoBTe68kr4FpZQviojfEhGPR8Sf3G403I6FcgBgY+oO/KJ9xgWoAEtqybJVjX0jKbfpD2Ccdf9u5fcmAAA4v1LKh0TEXznZ/NO11l/ZZjzcnoVyAAAAAAAAYBe9OiLeve0gzukvRsRDEfG6iPi7W46FO7BQDgAAAAAAAOyid68jB3kpZS8iDlfQ1ZfWWr/jVL+fGRFfGhGLiPjDtdZuBWOwJhbKAQAAAAAAYOIWtcZiB3In7kIMY5RSrkTE3znZ/Ou11p/eYjgMYKEcAAAAAAAAmIxa61Ep5eUr6OqRU9//noh4aUQcRcR/LqX83qT+rzv1/cedqvO6WusvrSAezsFCOQBwRxf0As7bGrM/paw+Dpici/qksdlst/vbhOzYlQu4H7DDdvX3rVXF5XcpAAB2Ua31jSvu8srJv3sR8a0D6n/eyVfE8ePaLZRvmL9uAAAAAAAAADApFsoBAAAAAABg4hZ1d74uolrrd9Ray52+IuKzTjX5xlM/+44thT1pFsoBAAAAAAAAmBQ5ygFgwnY1H+auGTpP8m9uX00OQnGi5y5qzvB1yvJup/m51zgecqIPlL3fsX3+y8kNmRenNAAAsGn+2gAAAAAAAADApFgoBwAAAAAAAGBSPHodAAAAAAAAJq6rEYsdyCfUbT+Etam1/qtYXVI37pI7ygEAAAAAAACYFHeUA8AltQMXf07OkDkvrhflolvjm0up3YDxV1Tnbtqtagqy8cqAa5mHtBvYdzvndcj4Q2XnijdBLjC/W63X0Pn1NgIAAKyKO8oBAAAAAAAAmBR3lAMAAAAAAMDELSJisQNPUlpsOwAmwx3lAAAAAAAAAEyKhXIAAAAAAAAAJsWj1wHgEqg78EgkhhlyrEpZfxxARNRu2xH0ZTEV1zfDNvj9ajf5XQoAAFgVC+UAAAAAAAAwcYtaYxHbv2J04apVNsStCQAAAAAAAABMioVyAAAAAAAAACbFo9cBYMd50tD0ZMdcrs3xajJ5ZZMvrCy/9C7mxt5FQ+dpSL0hdboNHJezxpgNOF+GnFNDzzv5z4fZgXnK3ssYx+9Wl5885gAAwBAWygEAAAAAAGDiakTswqX9rm1lU7Z/WTwAAAAAAAAAbJCFcgAAAAAAAAAmxUI5AAAAAAAAAJMiRzkA7JAqAQ+3MeTcKGX9ccAg9eyMZmVAnZWO360yprFv1vXMMQaFkF3uXFZzDXQWX836buutaHy4W36XYqjsXPG7FAAATIuFcgAAAAAAAJi4Ra2xGH1x+GrjgE1w2T8AAAAAAAAAk2KhHAAAAAAAAIBJ8eh1ANgQTwxi3eTaHK42E1O8QC+OLIl3WzYgH3lEko877XvF50a3OBVA/wWavWR7OcKz/RtyCbQ84hdG+x5Fzls3q+Z3KQAAmBYL5QAAAAAAADBxixqxOLva2i1cFMuGuKUAAAAAAAAAgEmxUA4AAAAAAADApFgoBwAAAAAAAGBS5CgHgDWo8uiwI4aci6WsPw4aJbletXajuqpNX2VkPzuhjX2F+5LOS9dkXkvqlO6o325sXLVGWdx6dnOWfBwr/Rdte7q0x3z4+APiHtv3ZWIOdoLfpdgV7bno9yYA4DLrao1FbP+X8c4HAjbEXwAAAAAAAAAAmBQL5QAAAAAAAABMioVyAAAAAAAAACZFjnIAAAAAAACYuEWNWGw7iDiOAzbBQjkArED1yxsXWHb+lrL5OLapJjtcLvsLuzQPl6rdeodbVf9ZP91yWTrWgLLSHfWqlMWtpN0dI7yDmvd3usYs+YhWl8/P7OXZ273s2WHtMR8om886sq9hA47re60xrVH2/jM1l/3tlstl6PnqpQ0AALvvYv4lAQAAAAAAAABGckc5AADAOTzy3kfjbfNHzt3u4D3zNUQDAAAAwBgWygEAAM7hhc9/KF7wgZedu917XvDGNUQDAAAAwBgWygHgnOTRZAqGnOeXPffmJPOWb9IKc6L3cminecwX/XZtTvIsR/nhzX5fY2Ovdam/LKd2mn+8LUgSaLXt6tgsW9m+XdDc37tqajnJvW0yVe25P7GXPgBwQS1qjUX/U+hW4oBN8BcPAAAAAAAAACbFQjkAAAAAAAAAk2KhHAAAAAAAAIBJkaMcAAAAAAAAJq6rEYttBxHHccAmWCgHgDuofimD2xry+ihl/XFcGqV52FPtthPHNrX7nM1BN2BekpOzZH01ZWVxlIyXlI3+z6Eu9ZeNV9vzIPqx15o8GKx9rWXzNOR5Ysn4l94U93lN/N4Et5e9PvyeBAAA2+UvAgAAAAAAAABMioVyAAAAAAAAACbFo9cBAAAAAABg4ha1xiK2n1NpIa8TG+KOcgAAAAAAAAAmxR3lAHCKixVhtbLXVCmbj2NVahN88aYRUbttR9CPIYtpSFm36Fe5dWNYX0PUutzf/GBY34P2r3lhlQ1fE53FtOkYdlD7nnGRebuD1WtfV5foLQMAAC4Ef7kAAAAAAAAAYFLcUQ4AAAAAAAATt4iIxQ48Tar/vDdYD3eUAwAAAAAAADAp7igHYLLk2oTtGPLauyg5OrP8wyvLW57ldx6QG7sm7cou5BFfkdH7krQri6Pl7e6oV6cmectHq7GUBz0bLxbzfrMRub6zeaqX6DrpMXMSEWvNm36R85H7nQgAAIApslAOAAAAAAAAE3d9Rx56vitxcPlZKAcAAAAAAICJ+yfx7m2HABt1eZ69BwAAAAAAAAADuKMcAAAAAAAApundEfFh2w7iDtzmztpYKAdgEmrddgTAeWSv2VI2H8cYtQm0eAMar+uG1WvmuNSkXVpWz6xTDw+zAYfFlbQ73V+5OiCmJK5s/2ptHhaWvV6y+Zx7yNhY7Wv9ovCWBLvrIv/+AwBcXLXWo4h457bjgG3wVxEAAAAAAAAAJsVCOQAAAAAAAACTYqEcAAAAAAAAgEmxUA4AAAAAAADApOxtOwAAWIdatx0BsGpDXtelrD+OrSrJda6123wcp206piF9Dx2/rdct+nWysrH/ydS63F/a94r2L6uTHatVWWffY+1iTGvm9x+4fLLX9aX/fQcAADZken85AAAAAAAAAGDSLJQDAAAAAAAAMCkWygEAAAAAAACYFDnKAQC4NIbm591kbs+aDFY2nEi4JrmaS5vDehfyn48db0C73v4mZbXr16lHh/2yuzh8p/vLxsvibPcvHb53POcDAxpwHqzTwPGyc3iTstfxxmOQfxw40b4f7MBbFAAAXEjuKAcAAAAAAABgUiyUAwAAAAAAADApFsoBAAAAAAAAmBQL5QAAAAAAAABMyt62AwCAu1XrtiMALpr2faOUDY+fDFjGvpmV5trX2o3rZ/B4Tey7+CaczUGXlLX1jm71qyRlESP3udbl/rK+96/0y9rYZ2s+xquy6RdW+1oYKXt9btouvqyA3ZW9Z+zAWxkAAOw8d5QDAAAAAAAAMCkWygEAAAAAAACYFAvlAAAAAAAAAEyKhXIAAAAAAAAAJmVv2wEAwHnUuu0IgMto6HtLKWuMoem8rPkNr5bla2ZL7dY63joNij2bz6ZdXSz6VQ4Ph/U1QK11qb9svHRfBozXtqsxP3+AO6I9N9c/3hpf2Nl4fpcBNiB7r9nw2x0AAOw8d5QDAAAAAAAAMCkWygEAAAAAAACYFAvlAAAAAAAAAEyKHOUA7DR5PIFdMuQ9aVX5P7O8yYPylmf5ncfmH19lX5s0NMauyRF+lOQjP7o1vv9+w+X+svHamNJuLsAxuJ1V5R8f2c8685H7nQUAAAAuFneUAwAAAAAAADApFsoBAAAAAAAAmBSPXgcAADiHRx5/PN4++5Fztzt43/oe+w0AAADA+VgoBwAAOIcXPve58eAjn3Tudo8976dXHwwAAAAAo1goBwCAFap1ebus8CbimnRW2gEzJcm4VLum736d0tTJ+852sN9XG2Xady+GAeMPlYxXu2YOukW/zq0bSV8D5jyNoS71l47XJfs85DiMlZ0b7fBZnbZs5Ime9p0ZWm+p7/XewT/2NADYlnX+jgIAABeRHOUAAAAAAAAATIqFcgAAAAAAAAAmxUI5AAAAAAAAAJMiRzkAO0OuT+AyGvreNjZPaJuHeVDO8oh+zuehebDHtjurn7vpa1WS/OD16LBfdjc5yk/3l+Uj37YRucBX3tfIdqvKSe73EWAqsvc7ecsBAJgSd5QDAAAAAAAAMCkWygEAAAAAAACYFAvlAAAAAAAAAEyKhXIAAAAAAAAAJmVv2wEAAAARtZ5dp5QB/SSVypDO077619WW2o3qa5RZcl3vKofvFkubtdnO6qxyzI2Md1o2nxuWnVPj+hnwYsjajXspAAAAAJfQ9v9SAgAAAAAAAAAbZKEcAAAAAAAAgEmxUA4AAAAAAADApFgoBwAAAAAAAGBS9rYdAADTVeu2IwCG6rxgIyJiVspWx88Ow5CQalKptJ2V5Bra2iV9LdfLh++3a6/Rzc6o0saQjJ/FOSymFdrBl0M7B+nxzDT1ev3crq/2nBpwXIaMfzvZOXxmmx08ThHeTyO2/14K3N7Y3zUAAOAickc5AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCkyFEOwEZIxwnbIRfuaq1qPleZn3dISNlwQ3I+l+y62iZveJaHelDe8jRJ+cg822f1czuz+bj+12lITKucl0F5xJMjOiS3+YAYxuQej9j87xXeS1drF99LAQAAmB53lAMAAAAAAAAwKRbKAQAAAAAAAJgUC+UAAAAAAAAATIqFcgAAAAAAAAAmZW/bAQAAME5X67ZDYKSxx25Wyqh2Q4bLuq5JYWmvta3dqJii9K/ZbcMsWZ2krFcvqZOWXRQj9i+bp3TOh/Q9Vjre2efwOt/avG9eLkOP59j3TuBY+1LzkgIA4LK4wH8tAgAAAAAAAIDzs1AOAAAAAAAAwKRYKAcAAAAAAABgUiyUAwAAAAAAADApe9sOAIDLp9ZtRwAXW+dFxG2MPTdmpZxZJ+s6a1abwpJce5tF2e+qS2o1fZXkut5ZUtY1vWftkp0pTV9lNk9iWp9svDamiP6cD9q/bJ7Sdu2cJwc9aVd77QbEnRj7dud9kvMYcr4MeZ8EAADgcnFHOQAAAAAAAACTYqEcAAAAAAAAgEmxUA4AAAAAAADApMhRDgCwQfLqXn5jj/A6s+OOzm0+JKos9/eAvOV5z8t5y3t5sCOizPofYeqsyXfeLZJ2Wb7zzeYkHySLqYk9m5fazks2T0Nymw/JR57Uy/KRDzntdvE9cRdfw6yfPOYwXPZy8fIAAOAickc5AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCkWCgHAAAAAAAAYFL2th0AABdfrduOAHZT58WxEy7KUdh2nCUpG3IOz5KWNSkrs3lTqX/NbumO2s77apcE0VRsx4qIOut/9CmlbTf0OuIVHa1svDamSGJP9q/XV9JP2q6pl81TLckxbqcgmZKx74Hbfi2Mtem4s9cs65Wd07Pk9QEAAMDF4I5yAAAAAAAAACbFQjkAAAAAAAAAk2KhHAAAAAAAAIBJsVAOAAAAAAAAwKTsbTsAAIDLoqt12yFcamZ3vcbO79DzfhZluaCUpNLyx5PSHfWq1Fn/I0ypXVOn69dJ2rV9lb2DfkyZFZ2M2XjZ/rXzMrpO6V8n3daryXHJDvGQ4+41u15j5zd55XEX2tfCLHtvgwnI/lvwcgAAYNe5oxwAAAAAAACASXFHOQAAwDm8+wNPxDtmP3LudgfvX0MwAAAAAIxioRwAAOAcHr7/OfHQY5987naPPfBTa4gGAAAAgDEslANwLlIwwzH5yFfrMs9md5l37jZmSU7SRfOaKcm8tLl9ZwPzbPeq1H6O8rpIcpvv7S9v7+/36sRs3u/rzAju4FR/6Xh7/bJevvF5km99ftBsJ30nc9c1Gau75IQdsr/O84tjyKG6oLu2E7LfD+QtBwAA2E1bWygvpbwgIl4UEQ9GxPMj4umIeOzk6xdrTf66BQAAAAAAAAB3aWML5aWU+yPid0bEZ0bEp0fEx9yh+lOllB+PiH8TEd9fa/WMQgAAAAAAAABWYu0L5aWUT4qIPx4RnxcRV58pPqPZfRHxOSdf31BKeVNE/M2I+I5a61PrihUAAAAAAACAy29tC+UnC+T/U0T8F88Unfz7SES8PiL+fUQ8GhG/GhHvi4h7IuJDIuJ5EfHSiHh1RLwyIvYj4mUR8dfjeNH8myPir9Vab64rdgAAAAAAAAAur7UslJdSvj0ivjgiZidFPxUR/zAi/o9a69vP0c9BRHxGRHxRRPzuOM5l/ucj4o+UUr641vqjKw0cACDR1brtEC6Vizyb3ZaDrxfkXFwkYZZy1kOlImpzdnRJnflsPi6o2u+tLm4tbc8OrvbqlKzs7F3JlbLUX9Z3Nz/oldX9K8vbe/12db6/vJ3M0yI5gXtzPvAUuyjnYmvIeTjU2PeD2epCWJts1y5A2Dsr+z1itsJzEXZVe+o77QEA2DWzs6uM8vsj4igivjUiXlZrfVWt9a+cZ5E8IqLWeqvW+sO11j8QEQ9HxJdExJsi4iMi4rNXHTQAAAAAAAAAl9+6Hr3+LRHx52ut71xVhyePWv8HpZR/GBFfEBEjbyUBAAAAAAAAYMrWslBea/3KdfR70neNiO9eV/8AAAAAAAAAXG7revQ6AAAAAAAAAOykdT16HYBLoNZtRwDb0Tn5R7uoM9dtOPC64XNs0/uXGrDPtQzoJimbl+WsTLMsSVO92i/aP1rePri3V6dcTcpmI683LrOl/rLx6v49/bK95djrfL9Xp2vmYJEc9Kys188unCsDzAacK5mxr71SRg6YGDLHY/dvnYbM3A6GvbPa3zVmKzzHAAAAGMYd5QAAAAAAAABMylbuKC+l7EXEb4uIT4+Ij46I+yMiu+/jtFpr/Zx1xwYAAAAAAADA5bbxhfJSymdGxLdHxIefLr5Dk3ry8wvyEEAAAAAAAAAAdtlGF8pLKR8fET8YEQdxvPh9IyJ+ISIej4huk7EAAETIR343LsrMXab846vcl7FdrXM+FwP6XiTzW5q92Z/3M0ztHVw7s+9ydLNXNn/g+f2KaRL0s5X5fKm/eqWfo7y7cl+/rIn9KDkIh0fLH6eyqdyF/ONjc2+3zcbuyzpzm8tjnp93OxjmTsp+H5G3nMsmeyt1mgMAsE2bvqP8GyLiSkTcjIg/ERHfXmu9seEYAAAAAAAAAJiwTS+U/6Y4vsj8z9Vav2XDYwMAAAAAAABA9J9JuF5XT/79Pzc8LgAAAAAAAABExOYXyt968u/+hscFAAAAAAAAgIjY/KPX/2lEvDwiPiMifmzDYwMARFfrtkO4kC7KrHUbDrSu8HwaG/vYCIaMN2T/upHjr/KlWMry9lGyc3uz0iu7un9tuZ9r/b2ZP+/h/njzkR+jZntRTvW3uPa8XpVFE1NExI3D5biy/WsjX+f8DpVdlb1o4ioDO08O35myJkPO+zFjReSvl6H7N0a2L2NjX6dsyncwzJ2U/c4yW+M5BQAAMDWbvqP8r0XEIxHxNaWUj9zw2AAAAAAAAACw2YXyWutjEfFbI+LpiHhdKeXLSikPbDIGAAAAAAAAAKZt049ej1rrz5RSPiMiXhcRfyci/nYp5T0Rcf3spvUlaw8QAAAAAAAAgEtt4wvlpZTPi4hvi4j74zg1WYmIhwY0vSipMQEAAAAAAADYYRtdKC+lfFpEfGdEzE+K3hYRPxMRj0dEt8lYAOirLknikumc1KNdlJnrNhxoXdE5NTbuIc2G9j1kX4b8gp51k8UwZryh092+1mel9OqU0u/s5mK57Nr+vb069zzwcH/Avf1hgbXm81ic6u/pvf54128uemWHzYTmc372HGTaakNzc5Wm4SwZrhsQwmzgQe7i7M7aGLKeh8xKdv5m+zdEdt63c7dKq4x9ndowdzDEnTX2tQ4AAEDfpu8o//o4XiR/f0R8Ua31Bzc8PgAAAAAAAAATN/SGgVX5pDi+ePx/sEgOAAAAAAAAwDZseqH8mWcL/uiGxwUAAAAAAACAiNj8o9d/KSJeERHXNjwuAHDJyUc+3kWZOfnIx/ef7cuq8o8P7butlr1mF72+k/GTmVk0Aw49dm1q3ydv9SN/4Mr9vbI6H5ejfBGzeHz2bH/vf+qoV6fNRx4xLFd7uy/zWb/RLMkE3WuXpDtOc77H2XnTs1zcbb7sIXnMI/q5zLO+26nLcnPvYt7ydeYsjxg2L9s29rgAF1/+/8fm4wAAYJo2fUf5P47jz7v/5YbHBQAAAAAAAICI2PxC+V+KiF+IiK8qpbxqw2MDAAAAAAAAwGYXymutH4iIz4mIn4uIf11K+XOllFeWUq5uMg4AAAAAAAAApmujOcpLKYvTmxHxdSdfQ/Ky1VrrpnOqAwAAAAAAAHDJbHrhuV0NP3N1HACA1arbDmCAbsNB1rq6AcfGPqTZkL6zfemGjJ/0nY3X9p/1vUgatiWLpOGi6XtInYiIm0fLFW8c9RveTDo7bMoWyf5e2+8/hOtWVnGAm4saP/fY9Q9uXz/sxzRPPiHtz5djuDLvx3R1r6mz16+T9d12VZMLmOez/v6WtmjWbzdLz8XletkjzrJrqNuZyvpuL77Ozt8kzN65OfRDatt/1vcQ2Wt2wIXkow2dl23LXmU7GObWdcn5M1vj+QMAAHCZbHqh/Bs3PB4AAAAAAAAALNnoQnmt1UI5AAAAAAAAAFuVPekOAAAAAAAAAC6tTT96HYAdscJ0vLAVWU5O+i7KLF3UnOTbzkceMSxneN7u7PGyeWrTc2evxSyFd1vtMBmwzT9+66hf5/rh4syyrM4TN496Ze+9fmtp+7EnbvbqPPqBftn7rh/Gi3qlZ3vixmH8w5985we3H7r/Sq/Og8/plz3/2sHS9nOu9D/GXduf33H7dmUHe01e7zS1cb+wlwI5y0uf5TuP9nxNcptnETTVsvO8zVue5fkekp97bG7sVeb+3nbe8l3MWc5w8pYDAAAMs9E7ykspX1BKeekmxwQAAAAAAACA0zZ9R/l3RUQtpVyPiJ+NiJ8+9fUztdYbbYNSyhdGxOdExLfVWl+3sUgBAAAAAAAAuJS28ej1EhH3RsSnRsSnnCrvSim/EMeL5v/x5N//FBEPR8SXRcTHRMRnbzJQAAAAAAAAAC6fTS+U/7qI+PiTr0+IiF8fEQ+d/GweES+LiF8bEV+YtH3V+sMDAAAAAAAA4LLb6EJ5rfWNEfHGiPjOZ8pKKS+M40Xzjz/599UR8eFJ81/YQIgAAFwytdaV9dWN6GpokyF9j92XrFk7XtZ3l/TVNfWyiLLxDpsBF0mlW0fLZdcPF706T9466pV94NZyvfc9fdir867Hn+6V/eJjTy5tv/nt7+/Veecb3tEf7/EnemVDXH/yZvzz7/+PH9x+8cs/rFfnYz78gV7ZRz9439L2hz73nl6d592zv7TdHqfbmy9tHWSfEJMTYX9WlrZr6dfJYihlueIsPe/6nc16/fTHa2XndDt+RP+1MEv6zmZzQAjp6zrrf4h2f7J9ueza6ZzeDMA0tG/fE3y7AwBgQ7bx6PUltdZHIuKRiPiBZ8pKKa+IiNdExO+LiFsR8Tcj4q9tJUAAAAAAAAAALpWtL5Rnaq3/KSK+pJTy7yLib0XEx9Ra377lsAAAAOLo8In4sfiRc7db3HBLHAAAAMCu2MmF8mfUWv92KeW/iojfXkr5ilrr39p2TAAAwLTt7T8nPu3mp5y73U9c/enVBwMAAADAKG2qt130nXGceuxLtx0IAAAAAAAAABffTt9RfuIdJ//+2q1GAQBsTVfrtkO4EC7KLHUXJNCxca5q9+rA877rtUvqJGVt/20/t+urLVokDRdJw7ZokQR1c7FY2r5+uOjVycqeuHG4tP0rT9zo1fnFx57slb357e9f2n77z76lV+exN/54r2y/ZrN1tqNbT8ev/Ny//uB2d/SpSa2XnNnPfNZ/hPu83Hk7ImJWknazdnveb5eM1zvG3dl9R/TPg6RZzJLzp4vlitkV321fWZ3sdVWSeRmi7WloL+2pn0zv1mXvGbsYZ/YuuYNh7oT2d6ns/QAAAGBqNnpHeSnlw0Y0e/Dk38M71gIAAAAAAACAATZ9R/lbSynvi4ifjoj/cPL10xHxxlpve1vG55/8+9q1RwcAAAAAAADApbfphfISER8SEZ8dEZ91qvxGKeVn43jR/Kcj4i0RcW9EfF4cL5S/NyL+9CYDBQAAAAAAAOBy2vRC+ZdGxK+PiI+PiFfG8aJ5RMQ9EfHJEfHqpM0iIv73iHhpKeVGrfVtG4gT4FKR3hnYlk3nIx+a13vbxs7LuMzYw+S5zZNc0W2O6SRLcLZ/bU7rw0W/0o2j5T28mSRAv37YL3vi5tHS9qNP3OzVedevPt0r+9VHPrC0neUjX6dsvPte8FCv7F33HSxtP3DPQa/OfVeXP9pd2evnGt+f9+du/2g5T/H+rJ+da1aSvN51uV0ZUCciojTnyyzLKL2i1MnZ62VI7rELk597hfnWh7go8wIAAABDbXShvNb6905vn+Qsf2bh/Jl/PzqW/zQyj4j//uQrSilPRMTPRcTPPPNVa/2xNYcOAAAAAAAAwCWx6TvKl9Ra3xER74iI73umrJRybxwvmj/z9fER8XERce2kygMR8Rsj4jc8001seT8AAAAAAAAAuDh2boG51vpURPy7k6+IiCjHz497afTvPn/h5iMEAAAAAAAA4CLbuYXyTD1Ovvamk6/vfqa8lPKCOF40BwAAAAAAAIBBLsRC+e3UWt8TET+y7TgAgNXpat12CBeGmYqoKzpfupHdrPIYjN2Xtlm2L1nf3ZC+B4yXhZ2Vta/tw64fweGiqbPo17l5tOiVvf/64dL2rz51s1fnqSf6ZU++59F+oFuWxfTUr7lvaftXn9vfl+dfP1jafs6V/ke9w8XszLLsuOzX0iurTVl6HvSLIumqJzs3Z80AXfQ7aveuDBgrov/6KEMbtv0kZUN6yl6zs3EhpK/1sftzUY09DlOT/b41m9i5wsWR/R/jdAUAYBX6fylZgVLKF6yj31P9v7iU8hvOrgkAAAAAAAAAy9ayUB4R31VK+dlVL5iXUj68lPItEfHmiPi/r7JvAAAAAAAAAKZhXQvlvxARr4iI7yylvLWU8j+XUl4xpqNSyr2llN9XSvnBOF4g//KImJ98DwAAAAAAAADnsq4c5a+IiD8WEV8XER8eEa+JiNeUUn4hIn48Il4fEf8hIh6NiPedfN0TER8SEc+LiJdGxKsj4pNPvq7Gs2nFfjAiXlNr/bk1xQ4AAAAAAADAJbaWhfJa61FE/OVSyt+JiK+IiK+M4wXzl0bEx0bEFw/s6pnF8UVEfG9EfHOt9XUrDhcAgBXp6rYj2D0XZU66urpAu+j3tejuvJ3FcJhMXlZ262i5s+u3Fr06N58+7Jc9+av9ILYsi+nm0x+2tJ3tXzsHQ+eunfPsuGRl89lyu/kHP7qdT3bezcu4vtYpex3Pdi9MAAAA4BzW9ej1iIiotT5Va/3miPjoiPjciPj2iHhbHC+An/V1IyJeGxFfGxEfUWv9fIvkAAAAAAAAANytdT16fUmttYuIHzr5ilLKiyLiN0TEiyPiwTh+5PqNiHjs5OtnI+Ina6392z4AAAAAAAAA4C5sZKG8VWv95Yj4nm2MDQAAAAAAAMC0bWWhHADgGavMi3yZmaXpSdJCr9SQl16Wl7nNP57VyfpuX+vZa3/RFHVZPvIkYfbNJj93m687IqJrO4+Ixc2n+4FuWRZTG3u2f705SOYpm8/enCfHJSurtTR1elWilH5hadrNkzzf6bm5onzg2etqrfnILrn2uO9q3vb2lNrRMAEAANgwfxMAAAAAAAAAYFIslAMAAAAAAAAwKRbKAQAAAAAAAJgUC+UAAAAAAAAATMretgMAYPVq3XYEAKtXV/jm1o3sattvr97fI+az0ivba8qyOiW5RHi2d7CyuFYli6mNfewcTE32eikbnpbsJTskhOw9auwhbd87y6YngQujS140M+cLAABwibmjHAAAAAAAAIBJsVAOAAAAAAAAwKRYKAcAAAAAAABgUja6UF5K+VOllP1NjgkAAAAAAAAAp+1teLxviog/VEr52lrrP97w2AAArFBXtx3BbhoyL7VudvK6jY423rwsb89mJamTlDX1Dvb61wPvX+l/9Dm494FzRrh+WUxt7Nn+tXOQzVM+n+eNcDvac3i+xrGy12dJ5rN9rSfTOznZ+595AdahfatO3qYBAOBMm370+iIiPjoivqeU8tpSyidueHwAAAAAAAAAJm7TC+WvjIgfiogSEb8pIn6ilPLtpZQP3XAcAAAAAAAAAEzURhfKa61vqLV+bkT89oj4+ZPxvyQi3lRK+X+VUu7ZZDwAAAAAAAAATM+mc5RHRESt9QdKKT8UEV8ZEf/viPiQiPiGiPjyUsqfrrX+g23EBQCsV7fhvMwXlVli1bKrYxdrHC/LEzprCtvtrGw/SW6cld1zsJyx+rnXDnp1Hr223yu79vwXLm2/9829KhvXxhQRcbWJPdu/dg6Gzt2Y4xKx+Vywm34UGpdb9v+s9MYAAADTs7W/N9RaF7XWvx4RHxsR/2sc/63uRRHx90opP1FK+Y3big0AAAAAAACAy2vrF+bXWt9Xa/1jEfHr49n85a+KiH9dSvmuUspHbjM+AAAAAAAAAC6XrS+UP+NU/vLfGhFvjOMF88+PiDeUUv58KeX+rQYIAAAAAAAAwKWwMwvlz6i1/p8R8X+LiD8VEUcRcSUivjYifqGU8uWlbDobHgAAAAAAAACXyd62A4iIOFn8fkVEvDqOH7v+6oh4ZRzHV+P47vKHIuJbIuIrSin/fa31R7cULgAATMIsuUS11uXCWmqvzqJfFPPZnbePy5b73k8qXdmb98oeuLa/vH19v1fnuQ9c7ZVdf/Depe0nPvzlvTrvf/sb+oGuyAPJeM9tYorox/7APf39a+cgm6dsPts5z49Lv6yVnSuz6Bdm9YDd1dXlN/SZexcAAIBLZCsL5aWUj41nF8RfHREfHxHXTlc59X2NiDdExKMR8ZvjeAH9taWUvx0Rf6LWenMTMQMAAAAAAABwOWx0obyU8n/F8QL5c04XN9XeGxE/ERE/fvL1ulrrEyftXx0RfyGOF8z/cER8Qinl/1FrfWrdsQMAAAAAAABwOWz6jvLPabaPIuJn4tlF8R+vtb75do1rra+PiM8qpXxZRPzNiPiUiPiaiPjG9YQLAAAAAAAAwGWz6YXyd8WpRfGI+Mla643zdlJr/d9KKR8aEd8QEV8YFsoBAAAAAAAAGGijC+W11hevsLt/FscL5R+5wj4BAGASSpsAqa6u71kvu1JEbYr2Z7Nenf1Zbbb7/VzZ67e7/8ryx5qHnnOlV+fWUXdmWdd9XK9O7Ra9sqff8M97ZUPM9w7inhe/9IPbL/64/ngveOH9vbKPeP69S9vZ/rVzkM1TNp9tWXZcZr2TJT/Gq5IMBwAAALBy/b+CXBwfOPm3/1ciAAAAAAAAALiNTT96fZXeFRF/KCI+YduBAAAA07E4+kD8WP3h87e7WeJgDfEAAAAAcH4XdqG81vp0RHzrtuMAAACmZb53f3xa92nnbve6K/9+DdEAAAAAMMaFXSgH4FhdYU5ZgF1RvbmlstzNq5qqLA/1Ium8rZalk87ibIv250n+8bqcGSobfzFkf/tpvuMgydl97WC+tP3oc+/p1XnoRZ/eK/upn/j7EY8NiKNx5d574hM/99n+XpiNd38/s9TDz726tP3ce/Z7de47WP5od21/3quT5S1vy7Ljkh7P9jwYUCeTnXerItd5Lnt/LSYLAACACbrIOcoBAAAAAAAA4NwslAMAAAAAAAAwKRbKAQAAAAAAAJgUC+UAAAAAAAAATMretgMAAC6nrtZth3BhXISZ6i5CkBdIKaVXVnfwNdOPMmLWFNaa7EvJ9qU0dfo19mfL1/Fe3ev3M0/mbt4U7bdBRsS1/Xmv7PnXDpa2X7roenWu7PXb/dK1/V7ZEM+5uh+/71M/4oPbN48WvTr78/61zFf2lsuuJHWuNnWy/d1vJyr6cz5L57df1k7xLDlbksOQnlO7Jnt9cvmd/a4FAADAZeOOcgAAAAAAAAAmxUI5AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCk7G07AAAAuExmZXm7qyP7Scq6cV1FKaVXNqvLgXX9KjGLfuGiaZd0HfOkXcRyu3nSsDSfTuazea/OjdKfhVnT17X9/qQfJgeiPVb7s/6sP//afq/syt64642v7s3ikz70OR/cfu/1w16dw66/f23o+23g0Z+D/Xm/ztUk7nnTV3bMk+F6xy87DzJtnFm7bHazc3iMVV4pns0Lfdl7oLm7uLqavZc6oAAAwMXkjnIAAAAAAAAAJsVCOQAAAAAAAACTYqEcAAAAAAAAgEmRoxwAAC6wNjVsmtt8ZJ70dLxmO8s1nOVS7+Utn/WDKvXsnbm2389b3u2N28E2P/c9SQ7vD7naH28e48bbm0U8fO+zH8EOkjziTx/1Z28x4gBmOYPTfPJN4ZB85FlfWbt1Zi1Ox5MmGWCyavJfpf8XAAA4izvKAQAAAAAAAJgUC+UAAAAAAAAATIqFcgAAAAAAAAAmxUI5AAAAAAAAAJOyt+0AAACgVUrpldVatxDJ5dXO8SyZ365/GGIWy4Vd0m6WtOua7Xn0K5Wy3Nes9ut06WnQ7EsyfnJKxUFT8d79/nXE95bDfl/dIgviTCXqUn9HB/2PY/MkzlvNTmcvhXxelg2Zl/b4ZnWyvpIqMUsa9sfLYsp6Y1XMLwAAABxzRzkAAAAAAAAAk2KhHAAAAAAAAIBJsVAOAAAAAAAAwKTIUQ4AAAO1mX1XmTW9zRuc5WTPrnJtc3+n+aSzdk33Wd7iIXnLs5zWWd7yNvd2kn48SlOYzW+Ww7uX9zqpM0/276Dp7J4kR3m5/oF+Z7Wd9WFKrVFuPNvfPdee36uzSHZ61hQusuPSFGV5zNOYBszdkIzWQ/KRR/TPxaH5sns50Qc0G3pV+DpzdssGDgAAALvLHeUAAAAAAAAATIqFcgAAAAAAAAAmxUI5AAAAAAAAAJNioRwAAAAAAACASdnbdgAAAHCZzUq/rKubj6PVxjU0pvZK2y7Zv1kkhW272h9w3jY7u5vUPJn0eemXHTQD7ifjlaObyQgjD2DtlvrLxmtjiugfm5IMv+hVGhNgbpbMXSurMvaq7Ow1s227GBMAAABwd9xRDgAAAAAAAMCkWCgHAAAAAAAAYFIslAMAAAAAAAAwKRbKAQAAAAAAAJiUvW0HAAAAmzYry9td3U4cd1JK6ZXV2g+0vfK1S/vql7VdtXNy3FdS2I6fxNSd3Szm6f6d3S7TdpX1PU8uEe7VqtnspSMOrHeGZLyS9N2LPZvgps6q5nKo7Ars7BzutRs43pC4hlwFPiSmXTB0Xi6Cy7QvAAAAXC7uKAcAAAAAAABgUiyUAwAAAAAAADApFsoBAAAAAAAAmBQ5ygGAlejGJsTlQkjzVzvkaabqIdMydj6H5C3ProQdkrc8ewkPiTOLKctbPsjIXMZtDFnc2bz06pV+rbp3JRtweHBN/0v9JePNytl56Gs6/HJhHXQmrs7Q3N9D8lVvOx/52JzaUnEDAADAxeKOcgAAAAAAAAAmxUI5AAAAAAAAAJNioRwAAAAAAACASbFQDgAAAAAAAMCk7G07AAAAIGJWlre7usK+k7Ku2S6lX6cmMbRxZroYUGmF2piyfcm0c3yU7O/+1fuTAefDBmjUUqKe6i8bb8hxz/avPcbbPgZDDT1W67zCe2zsAAAAwMXmjnIAAAAAAAAAJsUd5QAAAOfwyGPvjrftvfPc7Q4e219DNAAAAACMYaEcAADgHF744MPxgrd87LnbPfbgm9cQDQAAAABjePQ6AAAAAAAAAJPijnIAAC6EUkqvrNa6kr5n/a6jG9l129VqIrzDeM28DJ2T9orZLu377H6y4bL53EVt6EfJQa+zg35ZGXe9cS0lbp3qb5GNN6rnvl04BkPOn8zYq7mz94h1WtVo6z5Wm54XpqdL/iOYOe8AAIALwB3lAAAAAAAAAEyKhXIAAAAAAAAAJsVCOQAAAAAAAACTIkc5AACsUZaldUge6rF508fmch96BW2by3xsGtqx6eVXmfa2zRHeJZ3fWvSzt4/NX19rxNOHz/Y39lhlxuaTX1XfQ63qSu2xebfH5gOXbRkAAAAuH3eUAwAAAAAAADApFsoBAAAAAAAAmBQL5QAAAAAAAABMioVyAAAAAAAAACZlb9sBAADALpqVfllXNx/HaWNjKiVp2Kh12M4NudK2G1BnQEhr14szmYNFsjMDp6rfLiIOT/U3n61uzodY55yv8grsIefrENnrZRfsalwAAAAwNe4oBwAAAAAAAGBSLJQDAAAAAAAAMCkWygEAAAAAAACYFAvlAAAAAAAAAEzK3rYDAADgYpqVfllXNxtDKctB1LrhAEZKpi7GRt4eh7HHoJ3L2xkyx7t4NW43oE62a4ukcPRZVpf7m9X+nGeHoY19F+d3qKHn2RjZe9IYq4xwVTENtc75HWLT+wsAAAB34yL/jQUAAAAAAAAAzs1COQAAAAAAAMBtlFJeUEr52lLKvy2lvLuUcrOU8q5SyutKKd9cSvm0c/Z3rZTyi6WUevL11hXFWUopX1BK+aellHeUUm6UUq6fjPWdpZT/chXjXBYevQ4AAAAAAACQKKV8QUR8S0Q8v/nRC0++PjkiPjYiftc5uv2zEfFRq4jvGaWUByLin0bEZyY//qiTry8spXxXRHxJrfXWKse/iCyUAwDAQKvKB55pU/uuKmf57aw7l3lr2/njs0dptbm/szlZddin+8vGmyfTu4uPAdt0Lux15r6WVhsAAIDbKaV8SUR8exx/PH80jhfMfzQifjUiHo6Il0TE74iIw3P0+QkR8VURceOk3f0rCvcfxbOL5L8UEd8cET8bEfsR8UkR8ZqIeEFEfGFEvDcivnJF415YFsoBAAAAAAAATimlvDwi/m4cL5L/m4j4HbXW9ydV/0Yp5WBgn/OI+NaImEfEN0bEH4wVLJSXUj4pIj73ZPMXI+Lja60fOFXlX5ZSvjsi/mNEPDci/nAp5RtqrY/d7dgX2S7enAAAAAAAAACwTX8jIq5ExHsi4vfcZpE8IiLO8RjzPx7Hd3e/KSK+6a4jfNZvPPX9X20WySMiotb69ji+Oz7ieI34U1Y4/oVkoRwAAAAAAADgRCnlZRHxOSeb/2ut9T0r6PMj4jg3eUTEH1lxjvDTd7T/4h3qveXU91dWOP6F5NHrAAAAAAAAAM/6glPff88z35RSnhfHeb5/tdb63nP2+bci4t6I+Pu11n959yEu+flT33/0Heq95DZtJslCOQAAl0YppVdWa13beLP+cNGtaLik61jlnmSxt1a1LxH5sVmXdR7zXbXJ+V2lIefhKq1zuI3vywU95rvKbAIAMFWllL2IeHjbcdzGwxHxWEQs7lSp1vrONYz9qSf/vj8i3lBK+W8j4msj4pXPVCil/FJE/L2I+Eu11ifv1Fkp5fdGxG+NiPdFxNesId4fioi3RsRHRsQfL6X8f2qtTzUxvDgi/ruTzR+rtf7sGuK4UCyUAwAAAAAAwDQ9HBHv2HYQd2kd177+upN/3xrHucq/8v/P3p3HR1XefR//XifJTAIxgkAIirVgrAvaKgraqiDKvi8iEsCod+/edanSFh6xm727aB+ootj6PM/d2gohoLLv+6pVWwnYqmhbwVhlCUERE0hmhjnn+QOqZOYAk5mTZCbzeb9e14tk5pzv/ObMmWEyvznnclmmk6SfSrrVGNPPcZy9rsUdPwr9yRO/TnEc54CnlUpyHCdwopm/TMePGv+rMWaapLckZen4vOj/S1JrHb9Pd3ldQypijnIAAAAAAAAAAAAA+MI5J/69RMeb5J9K+rakfEnZkrpJWnVimcslzTPGnKrvOk1Se0mvSvpdA9Urx3FekXSVpMclfUnS/5X0sqRNkn4tqYWkRyR1cxzn7w1VRyrhiHIAAAAAAAAAAAAgzb226nx1yM9o6jK070BY1w34/CD3bpL2N0EZLU/869fxU78PcBzntZOu32aMGSxpuaQBkr4haaSk+SeHGGN6SLpb0jFJ33YacL44c3yOrltPjCyXRXIl3S7pAx0/ZXzao1EOAAAAAAAAAAAApLkO+RnqeK5bf7VJ7fdyDnJjzHk6fvpxN4ccx9lz4udafdEsnxfRJJckOY5jG2Mm63ijXJLG6qRGuTHGL+l/dPzU8E85jvM3D+6CqxNHsz8vafSJi56V9FtJ70jKkHSljp96faik54wxX3Uc5/sNVU+qoFEOAADQxCInUWqwr5U2AiviztipfGfi1JDbIJYJt7zc5JH3xUsNuW8c/wL1mVkRX+J2XFaLMSpmJ+e5bV+3c7TFen8aSkPuB15q7DJTZbs0JLYBJMlq4tcoAAAAoJ5+Kan4FNfNlHTniZ+r9EWjfJXr0pIcx3nbGLNH0nk6fvT7yX4o6WIdnwP+p/GVG7N79UWT/KeO4/x3xPV/kjTMGDNL0gRJ3zPGbHQcZ0UD15XUaJQDAAAAAAAAAAAAac6WI1t2U5chOzkOI/lQUsGJn890RPuHOt4oz4+4/KET/66XNPgUX4T/dzO+pTHm9hM/H3AcZ2P9ytV/nPi3StKvTrPcD3S8US5J35REoxwAAAAAAAAAAAAAmjPHce7UF0eNn87b+uII8TNN3P7v649FXO478e9dJ8bptJU098TPWyTVt1F+6Yl/dzqOEzjVQo7jfGSMqZDUXtIl9byNZsftzH4AAAAAAAAAAAAAkK62nvTzhWdYtvOJf/ecdqmG9e8mfSwHSf97IvrIxn7a4YhyAAAANGtup7VynMY7hZfbHL4NOj93jMs19UnMGntuY7dtHrlvZLhsFdtl/4m7dCNlnJSX4Ton+pnT03Fe6Ka+y8mwzZt6rnoAAAAASDNLJYV0vKk8UtL/dVvIGNNTUpsTv7508nWO45zxDzljTLmkCyR94DjOl+MvV+9LulzS5caYVo7jfHqK27tc0jknrZPWOKIcAAAAAAAAAAAAAE5wHOdjSb8/8Wufk+YP/5wx5ixJT5500f9rqHqMMZuNMc6J8WWXRZad+Ncv6Qnj8m1rY0y2pBknXbTc+0pTC0eUAwAAAAAAAAAAAGku7NgKO3ZTl5EUNZzwiKRBkr4kqcQYc72khZI+k3SFpIf0xTzf/8dxnNebpMrjnpD0H5LydXw+9IuMMf9X0rs6Pof6VZIekHTZieXfkfRc45eZXGiUAwAAAAAAAAAAAMBJHMepNMb01/HTsBdKuv/EiPQHSQ82Zm2RHMc5aIzpp+ON/E6Sbjgx3LwhabjjOMFGKi9p0SgHAAAAAAAAAAAAgAiO47xjjLlS0j2SbpV0kaRcSQck/UnS/3McZ1PTVfgFx3HeMMZcIalY0jBJX9Xx+cgdHa93h6R5kl5wHCfUZIUmERrlAADAE1bEtDe24zRRJcCZRU7T5DTy/mpFzRIl2Y38lHEpIS5elu1VTW4yXMKjao+evsttKffFYmAkZVkn1eS2I5xivcYS7+PZmDU2tBgflgblMpUcAAAAAKCJOI5zRNKvTwyvs78c43I3xbjcEUnPnBg4AxrlAAAAAAAAAAAAQJqz5cj29Cvx8dcBNAbrzIsAAAAAAAAAAAAAANB80CgHAAAAAAAAAAAAAKQVGuUAAAAAAAAAAAAAgLTCHOUAAABoMJaJvsxOwmmmjIku1HEat1C3bRUpKbddUxfgIpZtGauMjOiweOONJJ9Lnhe82jeS8fH0kpf7hlfcXn+SUTJuOwAAAADecmTLlt3UZchJghqQHjiiHAAAAAAAAAAAAACQVjiiHAAAAADqYX/lPn2Y+WG918uq5M8vAAAAAACAZMEnNQAAAABQDwXtOih/14X1Xu9Au10NUA0AAAAAAADiQaMcAAAgybhNA5uEU1M3e8kwb3mkVJ3HPFZezYEc65zPkbfntpblkhXvlNLGGPkyvpj9ynbZn9wevlgeU8ujVwn2n4aXKnOSN2c8AgAAAIC7sOMo3MSfffy7DqAxMEc5AAAAAAAAAAAAACCt0CgHAAAAAAAAAAAAAKQVGuUAAAAAAAAAAAAAgLRCoxwAAAAAAAAAAAAAkFYym7oAAAAApBfLRF9mO41fRzyMqVu84yRf4W7btzmJfAzcxLoNIhfLcFnRCoeiV4z7cXeUYX+RZzKyopYIuzwZYrk/dtS9cbn1GOpu7vtPY4tlf01G7AcAAABAerLlyFbTf9aRDDUgPXBEOQAAAAAAAAAAAAAgrdAoBwAAAAAAAAAAAACkFRrlAAAAAAAAAAAAAIC0whzlAAAAQJzc5h9OxnnLU0W88znHMp+y2yKRc5IbOxy9kMtlcU/f7Dh18oyJ/t5yhpURdVnkvOVue1jkNnCZ6jym7cv+G79UnY8cAJoDXoIBAPCGLSmcBPOD201dANIGR5QDAAAAAAAAAAAAANIKjXIAAAAAAAAAAAAAQFqhUQ4AAAAAAAAAAAAASCvMUQ4AAAAAAAAAAACkOVuO7KSYo7zpa0B6oFEOAACAJmeZur/bKfz3kDF174zjpPCd8VDkdolX5L7ieluu60VfaiIeG+PY0cvYx1zS4ntMTWSeleESHX3Sr8jabZd9KvISt+0Uy/Mq1seJ/dq7fToZxPK8AgAAAACgueHU6wAAAAAAAAAAAACAtEKjHAAAAAAAAAAAAACQVjj1OgAAAAAAAAAAAJDmwo6jcBJMtZUMNSA9cEQ5AAAAAAAAAAAAACCtcEQ5AABACjAulzXn79ZaLnfYTtE7bIzboxfNSdFvS8d6/+Lhth+41hC1XvSKrmXadt3fHTt6GdfLYqvL1cl5Md6esTLq/G65vCLYEfuPW4lePq9iedzZp5NTrM+r5iQN7zIAAAAAIAYcUQ4AAAAAAAAAAAAASCs0ygEAAAAAAAAAAAAAaYVTrwMAAAAAAAAAAABpzj4xmloy1ID0QKMcAFKc2zSaKTolKACktXjnRfZqHuhkmJc5lrmT463SxLKdGvs/0BhvL7J2J4at4LZELPOWxztnuWsN7NNAs2PxvAIAAADQjHDqdQAAAAAAAAAAAABAWqFRDgAAAAAAAAAAAABIK5x6HQAAAAAAAAAAAEhzthyFXSfuavw6gMbAEeUAAAAAAAAAAAAAgLTCEeUAAKBBWMZEXWY7fBsU8bOidynZ7FIyLs+1VOD2eMafVTfMdZO47CvGsc8c7rpMvDuec4q8L7jV5Ji63292u3+W6l4Y7+ttMjzPUnWfTlZePtcAAAAAAGhOOKIcAAAAAAAAAAAAAJBWOKIcAAAAAAAAAAAASHNhSeEkOHtfuKkLQNrgiHIAAAAAAAAAAAAAQFqhUQ4AAAAAAAAAAAAASCuceh0AACBFmYjfk+DMWI3OitgIdjpuhBQR+VjFIo5VGknyVnY6blXH8pRxe+x4riWneJ5nzQ2bAAAAAAAQKxrlAAAAAAAAAAAAQJqzT4ymlgw1ID1w6nUAAAAAAAAAAAAAQFqhUQ4AAAAAAAAAAAAASCuceh0AAACAp5rVPMnGy+8WG4/zmk7kY8yc5Y2vWT3PAKCeDK+BAAAA8EDz+JQGAAAAAAAAAAAAAIAYcUQ5AAAAAAAAAAAAkOZsGYXV9KdusZOgBqQHjigHAAAAAAAAAAAAAKQVGuUAAAAAAAAAAAAAgLTCqdcBAADQbFguZ+ayncavI524bfN4xRJlGe9u0DF1vzdsjB29kHH5bnEiJZyc53JfImuKl9t2sp3oJ0PkUvE+XXjuAQAAAACAVEOjHAAAAAAAAAAAAEhztpMcX3pOhhqQHmiUAwAAAEA97Kvcrw8yP6r3er5K/vwCAAAAAABIFnxSAwAAAAD10KFdgdruuqje6x1s914DVAMAAAAAAIB4eDMBHgAAAAAAAAAAAAAAKYIjygEAAJoJ43IZUzpJlsuGYa4rxMoxbt8tdnu2xZB1yjzgzNxey9Idm6ThWYatDAAAkE7CMgonwTvtZKgB6YFPaQAAAAAAAAAAAAAAaYVGOQAAAAAAAAAAAAAgrdAoBwAAAAAAAAAAAACkFeYoB4BmKHIqQYe5eJEk3Oa5tNlB0QQi5/plzvLYNet5kt3mDzfRO0dCu8vJt9HM5yt321d4rsWmWT/PAAAAACQt5ihHumnen8wAAAAAAAAAAAAAABCBRjkAAAAAAAAAAAAAIK3QKAcAAAAAAAAAAAAApBUa5QAAAAAAAAAAAACAtJLZ1AUAAACg4RiXy5xGryL5WS4bymZDuW6XtGM83ghe56WYyH2K5xnPs/pgUwEAAAANy3Ek22n6d94OfyuikXBEOQAAAAAAAAAAAAAgrdAoBwAAAAAAAAAAAACkFRrlAAAAAAAAAAAAAIC0whzlAAAAAAAAAAAAQJoLyyispp+jPBlqQHqgUQ4AAAC4sFz+JrOdxq8DddlO9INgmTP/Ae24LGMiTrDl9vAax465tvpyjMsJvlwuc6v9TNy2E5KD22sLAODU4vhvEAAAAIgJp14HAAAAAAAAAAAAAKQVGuUAAAAAAAAAAAAAgLTCqdcBAAAAAAAAAACANBeWpXASHGObDDUgPdAoBwAATSpybmHm1UUyi5xbuDnNWd6c5k12exmJe35Tt3nE42WMJ3nN6WXSbb/jeQU0jcj3ZAAAAADQ3PGVDAAAAAAAAAAAAABAWqFRDgAAAAAAAAAAAABIK5x6HQAAAAAAAAAAAEhzjmNkO00/JY+TBDUgPXBEOQAAAAAAAAAAAAAgrXBEOQCkAePyBTzHafw6ACSHyJcEXg7iZ7m8vtopskHdageSQao+r3hOeYvNCQAAAABoaBxRDgAAAAAAAAAAAABIKzTKAQAAAAAAAAAAAABphVOvAwAAAAAAAAAAAGkuLKNwEkyElAw1ID3QKAcAAAA8FDlPcSrMrZyuHFP3wTJuJ9xy7IYrwETfXmRNSA7MPw4AAAAAQPPDqdcBAAAAAAAAAAAAAGmFRjkAAAAAAAAAAAAAIK1w6nUAAAAAAAAAAAAgzYUdS2Gn6Y+xTYYakB7Y0wAAAAAAAAAAAAAAaYUjygEAANKccbnMafQqmi/LbQO7sNnoUftdjJtOtlN3TctEr+m4bF+XxaLXMy7fLY5lxfrknWmdGPaNyG0Qc3ZcazW+yOdRQz5fYn3Owjts8sbn9joJJAt2TwAAADQWjigHAAAAAAAAAAAAAKQVjigHAAAAAAAAAAAA0pwtIzsJjrG1Oe8UGknT7+1pwBiTb4wZbIz5mTFmlTHmoDHGOTGeiyOvvzFmoTHmI2NM4MS/C40x/euR0cIYM9kY8xdjzCfGmGpjzDvGmF8bY75U35oAAAAAAAAAAAAAIFVwRHnjqPAixBhjJP1fSd+KuOo8SSMkjTDG/I+kbzvOqScpNMZcKGmFpIsjrrrkxPimMabIcZyVXtQNAAAAAAAAAAAAAMmEI8ob34eS1sa57i/0RZN8h6Sxkrqf+HfHicu/JennpwowxuRKWq4vmuS/k3SLpG9I+qGkaklnS5pnjPlqnHUCSAHGRA8gGVjGRA0AaAyOMVFDxooeiTgpx/X20OgsU3cAAAAAAID0QKO8cfxM0hBJBY7jfEnSf9U3wBhTKOl/nfh1m6TrHcd53nGc1x3HeV7SDScul6SHThw17maSjh81Lkn/y3GcbzmOs9FxnFcdx3lUUl9JxyS1kPRkfesE0PwEAgGNv/tuvbFjx5kXBgAAAADgFCoqKnTbuHHav39/U5cCAABc2DIKJ8FgjnI0FhrljcBxnEccx1nuOE4ip2D/rr44Vf53HMepibiNo5K+c+LXTEkTIwOMMVmSHjzx6zuSHnep9VVJz574tZcx5uoEagaQ4mzbVlHxndoWzFDRvfdr/Yb1TV0SAAAAACAF7dq1S32Hj9AbvrM1dMzt+uyzz5q6JAAAAKQ5GuUp4MTc5MNO/Pqu4zivuS134vK/n/h1+In1TnaTpFYnfp7pOI59ipt87qSfR9a3XgDNg+M4um/id/X3jJZq2aWr/ANu03d++guVzJnT1KUBAAAAAFJI2fYyDRs3QfbNQ5R7yRU68tXrNHzM7QoEAk1dGgAAANIYjfLU0EnSeSd+3nKGZf99fUdJX4647kaX5dxsk3TkxM83xFAfgGboF//7f+uljyrkv/z4iSWsLJ9y+t+qx/44W1OfmN7E1QFA88M8ydEclxEL23Gihmu+U3ckg8ia3OqK9f5FZbuMVGE7dQcAIHWsXrNWE+5/UBn9Rykrr5Ukyd/xAh04/yKNLb5Ttn2q4zgAAACAhkWjPDVcetLP755h2ZOvvzTiuphyHMc5JmnXKTLOyBjT8XRDUkF9MwE0rj/MnKm5m1+W75oedS43Voayew3WrC2v6MFJk+UkS1cBAAAAAJB0nisp0Xcf/ZV8A0crI6dFnet8F16if2Tl6p4HH+RvSwAAADQJGuWp4fyTfv7oDMt+eIr1Tv79iOM4n8aY084Y4z/Dsm7rnm68Xs88AI1oxapV+vUfZyn7xgGKnsFBMsbIf93N2rD3oG4vLlYoFGqCKgEAAAAAyezRqVM1dfYLyu4/SlaWz3UZ3+Vd9fLeg/r5r37VyNUBAAA3YcdKmgE0hsymLgAxOeukn6vPsOyRk37OPUXOmTLccpg0CkgDr297XZN+9ktlD7xNxjr9mxH/Fd319j/f1qCRo7Rw7hzl5ka+5AAA0DztP7BP/8r88MwLRvAd4M8vAEDzZ9u27v/u97Tlw/3y9xro+gXsk/m63agXtqzSeR2e03/ceWfjFAkAAACIRnmqyD7p5+AZlj25oZ1zipwzZZwp50wij2SPVCCOKgeSznvvvac7739A/n6jZWVmxbSO/6Iu2pPdQn2GDNXSF19Qu3btGrhKAACaXkF+B7V778J6r1eZv+vMCwEAkMKCwaCK7rpL75oc+a/tGdM6xhj5evTXr58rUUH79ho8cEADVwkAAAAcR6M8NdSe9LP7uaq+cPJp0mtOkXOmjDPlnJbjOKc9PfyZvkkMoPHt379fI8ffoYxeQ5WRXb/vxmSf30lV/mz1HTZcC0tnq1OnTg1UJYDGFPm/NbNGNj92xINqpchbNLd9MZbSbZe5T62I96Wu06O6vneNd2MZOSflxTodq1vtZ5LKz9nIfRPNT4q83ACop6qqKg0fc7v2n3eh/IWX1mtdY1ny9xmmyT//pfLbtlH37t0bqEoAAADgC5zkPzVUnfTzmc5t3PKknyNPsf7vnFjOj3y6HADNyGeffaaht92u8Df6KiuvVVwZ/vwOCvcYpCFji/TGjh3eFggAAAAASGoVFRXqM2SoKi68ot5N8n+zMrOU1W+k7vzOg3rvvfc8rhAAAMTClkmaATQGGuWp4eQjtDueYdmTT3seOXHiv3NaGmNaxZhT6TgO85MDzZTjOBo2eoyOXH6d/G3bJ5SVdXZrZfYdpaJ779f6Des9qhAAAAAAkMx27dqlfiNGquqanvJ1vCChrIzsHGX0HqaR4ybok08+8ahCAAAAwB2N8tSw86SfLznDsidf/048OcaYTEn/nnQxMgNAM2KM0SUXf0XaVy4njtO6RsrIaSn/gNv0nZ/+QiVz5nhQIQAAAAAgWZVtL9PQceMV7jVY/naJffn638L79yi/bVtlZ2d7kgcAAACcCo3y1PC+pL0nfu55hmV7nPh3j6TyiOtePunn0+Vcoy9Ovf6nGOoDkMKeeepJ3d79SgW2rpRj2wnnWVk+5fS/VY/9cbamPjHdgwoBAAAAAMlm9Zq1Gn/fA8rsf2vc03hFCv5tm7rUHtLKRQvUokULTzIBAACAU6FRngKc44d5Ljnx6yXGmOvcljtx+b+PFF/iRB8eulnS4RM/FxtjTjXJw50n/byo3gUDSCnGGP344SmaNHa0atctlH0slHimlaHsXoM1a8sreuD7kzw5Wh3pzTImagDwlu1Ej1ThRIxY2Y5TZ7hmO9EjoVrPkBNZ06nqispVfNugqaXyfgekEt5HwWvPlZTou4/+Sv5BtykjJ/GGtuM4Cry2STfl5+mFklny+XweVAkAAOrLlqVwEgyb9iUaCXta6nhS0rETPz9tjMk5+coTvz994tdjJ5avw3GcoKQZJ369VNKkyGWMMV+X9B8nft3iOM7riRYOIDXcfWexpj00SYFVLypcW5NwnjFG/utu1sZ9H+v24mKFQok34AEAAAAATevRqVM1dfYLyu4/SlZW4g1tx7YV2LRC46/vpt8+OV2WxceVAAAAaByZTV1AOjDG3CCp8KSL2p70c6Ex5s6Tl3cc57nIDMdx/mGM+bWkKTp+avQ/GWP+t6RdOj6f+EOSrjqx+DTHcf55inKmSRoj6SuSphpjCiU9L6lGUi9JP9Dx/aJG0sSY7ySAZmHQgAHKb9dWd97/gOybhynrrLMTzvRf0V1v//NtDRo5SgvnzlFubq4HlQIAAAAAGpNt27r/e9/Tln/tl7/XQJ36RIX1yAwFFVi3WA9/65sqHj/OgyoBAACA2NEobxzflFR8iuuuPzFO9twplv2hpHxJd+t4U/x5l2WelfSjUxXiOE6VMWaQpJWSLpL0rRPjZJ9JGuc4zhunygHQfHW7ppuWzC7RrROKFfhGH/nbtk84039RF+3JbqE+Q4Zq6YsvqF27dh5UCgAAAABoDMFgUEV33aV3TY781/b0JDNcc0ShtYs142c/Vd8+vT3JBAAAAOqDcxmlEMdxbMdx/kPSIB2fs3yvpOCJf5dIGug4zjcdx7HPkPOejjfaH5K0TdKnko5K+ruk6ZK+6jjO8oa6HwCSlzHHx0UXFWrN4gVquW2zAns+8CQ7+/xOqrryBvUdNlzvv/++J5kAgIblNn90KswnHTlfd6xlxjs/eLy8mo88SR+GlN1/AAB1VVVVacDwEXqnRRv5rrjak8zQ4UM6tnqBSn87gyY5AABJJOxYSTOAxsCe1ggcx7nTcRwT64ghb6XjOMMdxznPcRz/iX+HO46zqh41HXEcZ6rjON0cx2ntOE5Lx3EucRzne47jeNMVA5DSCgoKtG7ZUuXv+psCu971JNOf30HhHoM0ZGyR3tixw5NMAAAAAEDDqKioUO8hQ1Vx4eXyF17qSWbgwH5lbF6hZXNK1bVrV08yAQAAgHjQKAcAnFJeXp5WLV6kr1QfUOCtMk8ys85urcy+o1R073e0fsN6TzIBAAAAAN7atWuX+g4foepresjX8cueZAY/KtdZZVu1dvEide7c2ZNMAAAAIF40ygEAp+X3+zV/TqlubNNSta9vkePBaWgzclrKP2C0HvjvX6pkzhwPqgQAAAAAeKVse5mGjhsv++Yh8rcr8CQz8N5OdXh/p9YvX6b8/HxPMgEAAIBE0CgHAJyRZVl65qkndXv3K1W7daUc2048M8un7H6j9Ks/ztbUJ6Z7UCUAAAAAIFFr1q7ThPsfVGb/W5WV18qTzODftumymkNasXCBcnNzPckEAAAAEkWjHAAQE2OMfjxliiaNHa3adQtlHwslnmllyN9rsGZteUUPfH+SJ0erA2gYxmXAW7ZTd6SKyLpPNZqa4zJiYTtO1Eikinhy4qm7oaXCYx6rVK07VfD/B5Banisp0cRfPibfwNHKyGmRcJ7jOAq8tkk3tT9bL5bMkt/vkzH6fAAAgORiy8iWlQSDNwpoHDTKAQD1cndxsaY9NEmBVS8qXFuTcJ4xRv7rbtbGfR9rbHGxQqHEG/AAAAAAgPp5dOpUTZ39grL7j5KV5Us4z7FtBTat0Pjru+s3Tzwhy+JjSAAAACQX3qECAOpt0IABmjljukJr5ilUddiTTP8V3fVWZp76DxuugwcPepIJAAAAADi9cDisb957r0pf2y5/r4EyHjS07VBQtavna8odRXp40iQPqgQAAAC8R6McABCXbtd005LZJbI2LVPgYIUnmVmdvqI3//FP9R08RJWVlZ5kAgAAAADcBYNB3TpunBYuWSLr0q/JeHA+9HDNEQVXzNNTP/qh7hg3zoMqAQAAgIZBoxwAELfCwkKtXrRALbdtVmDPBwllObatigWzlHvJ1xT8eh/1HTZc77//vkeVAgAAAABOVlVVpYEjRuofZ+Wr3ZAx2j/39wrXHE0oM3T4kI6tXqDZv52hvn16e1QpAABoLLZjFE6CYTvMUY7GQaMcAHBKxkSPSAUFBVq3bKnyd/1Ngd1/j+t2HMfRx6vmyde6jVpff7P8+R0U7jFIQ8YW6Y0dOxK8F2iuLGPqDADJzXbOPBqbEzHqt2bDiKypsTdLLI9TUzxWAGIX+R6J90lwU1FRod5Dhmp/58vlL7xULTtdpLO/3kv75/5edigYV2agcr8yNq/Qsjml6tq1q7cFAwAAAA2ARjkAIGF5eXlatXiRvlJVocBbZfVe//BLa2UHAmrTd/jnl2Wd3VqZfUep6N77tX7Deg+rBQAAAID0tXv3bvUbMVLV1/SUr+MFn1+e99Wr1fLiK3Rg/iw5tl2vzOBH5Tpr21atXbxInTt39rpkAAAAoEHQKAcAeMLv92v+nFLd2Kalal/fIseJ7XCz6h2v6ei/dil/5B1R12XktJR/wG36zk9/oZI5c7wuGQAAAADSStn2Mg0tGq9wr8Hyt2sfdX2r63sp65y2+nj5izH/TRd4b6c6vL9T65cvU35+vtclAwAAAA2GRjkAwDOWZemZp57U7d2vVO3WlWc8CqHmH2/rUNkrKij61qkzs3zK6X+rHvvjbE19YrrXJQMAAABAWlizdp0m3P+gMvqPUlZeq1Mu16bfcNmhoA5vWXPGzODftumymkNasXCBcnNzPawWAAA0hbCspBlAY2BPAwB4yhijH0+ZokljR6t23ULZx0Kuy9V+9L4ObFqh8+64V5aVefpMK0PZvQZr1pZX9MD3J8V8ZAMAILXEOj92Q82X7TY/uJdzhjdkdqSm3pYAgOTyXEmJJv7yMfkGjlZGToszLp8/6g7V/Gu3qre/6nq94zgKvLZJvdq30guzZsnn83ldMgAAANDgaJQDABrE3cXFmvbQJAVWvahwbU2d6wKVFapY9oLOHftfsnzZMeUZY+S/7mZt3PexxhYXKxRyb8ADAAAAAL7w6NSpmjr7BWX3HyUrK/aGdvvx39KnZa+p5u9v1bncsW0FNq3Q+Ou76+knHpdl8fEiAAAAUhPvZAEADWbQgAGaOWO6QmvmKVR1WJIU+uxT7V/wnNqPLFZW3tn1zvRf0V1vZeZp0MhRqq6u9rpkAAAAAGgWbNvWvRMnqvS17fL3GihTz4a2ZWXq3OJ7VLlxpWo/fP94Ziio2tXzNeWOIj08aVJDlA0AAAA0GhrlAIAG1e2abloyu0TWpmWq+ahc+154Vm37jVB2+w5xZ/ov6qI951+iPkOGqrKy0sNqAQAAACD1BYNB3TZhgrYerJb/2p4yxsSVY/myde64/9KBpS/o6L/eV3DlPD31ox/qjnHjPK4YAAAkA9uxkmYAjYE9DQDQ4AoLC7V60QLVbFiiFoWXqmWnryScmX1+J1VdeYP6Dhuu999/34MqAQAAACD1VVVVacDwEXqnRRv5rrg64bzMvLPVpv8IfbJ0rmb/Zob69untQZUAAABA06NRDgBoFAUFBfrrX/6iCzPCCux615NMf34HhXsM0pCxRXpjxw5PMgGgMdhO9ED83LZnLCNejf1wNeZ9A9sTqcUyJmogvVVUVKj3kKGquPAK+Qsv9SQzcGC/ct56Xa9t2aKuXbvGvJ4xdQcAAACQbGiUAwAaTV5enlYtXqSvVB9Q4K0yTzKzzm6tzL6jVHTv/Vq/cYMnmQAAAACQanbt2qV+I0aq+pqe8nW8wJPM4EflOqtsq9YuXqTOnTt7kgkAAAAkCxrlAIBG5ff7NX9OqW5s01K1r2+R4yR+mFZGTkv5B9ym7zzyc82eO9eDKgEAAAAgdZRtL9OwcRMU7jVY/nbtPckM/HOnOry/U+uXL1N+fr4nmQAAAEAyoVEOAGh0lmXpmaee1O3dr1Tt1pVybDvxzCyfcvrfqkf/UKKpT0z3oEoAAAAASH5r1q7T+PsfVEb/UcrKa+VJZvBv23RZ7SGtWLhAubm5nmQCAIDkF5aVNANoDOxpAIAmYYzRj6dM0aSxo1W7bqHsY6HEM60MZfcarFlbXtGDkyZ7crQ6AAAAACSr50pKNPGXj8k/cLQycloknOc4jgKvbVKv9q30wqxZ8vl8HlQJAAAAJCca5QCAejEmeiTi7uJiTXtokgKrXlS4tsaD+oz8192sDXsP6vbiYoVCiTfgkRosY6IGGpZxGUAqsZ0zj6a+/YauAfAS/y8AjevRqVM1dfbzyu4/SlZW4g1tx7YV2Lhc46/vrqefeFyWxceGAAAAaN54xwsAaHKDBgzQzBnTFVozT6HPPvUk039Fd72dmadBI0epurrak0wAAAAAaGq2beveiRNV+lqZ/L0GyXjQ0LZDQdWunq8pxeP18KRJHlQJAAAAJD8a5QCApNDtmm5aMrtEZvMyBQ5WeJLpv6iL9px/ifoMGarKykpPMgEAAACgqQSDQd02YYK2HqyW/9qbZDw4i1K45oiCK+bpqR/9UHeMK/KgSgAAkKpsSWHHNPmwm3pDIG3QKAcAJI3CwkKtWbRQLbdtVmDPB55kZp/fSVVX3qC+w4arvLzck0wAAAAAaGxVVVUaMHyE3mnRRr4rrvYkM3T4kMKrF2j2b2eob5/enmQCAAAAqYJGOQAgqRQUFGjdsqXK3/U3BXa960mmP7+Dwj0GafDtY/XGjh2eZAJArJhzOrV5/fixH6QmnscAmlpFRYV6DxmqiguvkL/wUk8yAwf2K2PzCi2dU6quXbsmlGVM9AAAAACSHY1yAEDSycvL06rFi/SV6gMKvFXmSWbW2a2V2XeUiu69X+s3bvAkEwAAAAAa2q5du9RvxEhVX9NTvo4XeJIZ/KhcZ5Vt1drFi9S5c2dPMgEAAIBUQ6McAJCU/H6/5s8p1Y1tWirw+hY5TuKHbmXktJR/wG36ziM/1+y5cz2oEgAAAAAaTtn2Mg0bN0HhXoPlb9fek8zAP3eqw/s7tX75MuXn53uSCQAAmgdbVtIMoDGwpwEAkpZlWXrmqSc1pvuVqt26Uo5tJ56Z5VNO/1v16B9KNPWJ6R5UCQAAAADeW71mrcbf/6Ay+o9SVl4rTzKDf9umLrWHtGLhAuXm5nqSCQAAAKQqGuUAgKRmjNGPp0zRpLGjVbt2gexjocQzrQxl9xqsZ9du0sgxt3tytDoAAAAAeOW/f/Zz3fujn8g/cLQycloknOc4jgKvbdJN+Wfr+Vmz5PP5PKgSAAAASG00ygEACTOm7mgIdxcXa9qUyQqselHh2pqE85xQUId2/0M79h3U7cXFCoUSb8ADAAAADckyps5A8/To1KmavWGzDlfsV/hIdcJ5jm0rsHG5xn+jm34z/QlZFh8HAgAAABKNcgBAChk0YIBmzpiu0Jp5ClUdjjvHCYe1f/5zyu1ylc4ZMEpvZ+Zp0MhRqq5O/EMoAAAAAIiHbdu6d+JElb5aptz+o9Ru8Gjte/5ZHTsa/98pdiio2tXzNaV4vB6ePNnDagEAQHMUdqykGUBjyGzqAgAAqI9u13TTktkluvWOYgW+3kf+tu3rtb7jOKpc/ryyCzqqdfcekiT/RV20J7uF+gwZqqUvvqB27do1ROkAgGZi/4F9+jDzw3qvl3WAP78AAO6CwaCK7rpL75oc+a+9SZLU4kud1frGvto/91mdO+Hbsnz+emWGa44otHaxZvzsp+rTu7fnNQMAAACpjk9qAAApp7CwUKsXLtCwMbfryBXXyX/eBTGv++nG5TLG6JybB9W5PPv8TqryZ6vvsOFaNKdUX/7ylz2uGgDQXBTkd1D+exfWe70D+bsaoBoAQKqrqqrS8DG3a/+5F8pfeGmd68667Guyqz9TxYvPqWDsN2UyMmLKDB0+JGfjMs1+5rfq2rVrQ5QNAAAApDzOXQAASEkFBQVat2yp8nf9TYFd78a0TtXrL6m2Yp/aDS1yvd6f30HhHoM0eMxYvbFjh5flAgAAAECUiooK9R4yVBWdL49qkv/b2d1vVHaHjjq4ZK4cxzljZuDAfmVuXqGlc0ppkgMAAACnQaMcAJCy8vLytGrxIl1cfUCBt8pOu+zRd/6qw2+Wqf3t3zztcllnt1Zm31Equvd+rd+4wcty0QQsY6IG0NBsp+5IR47jNOuheB9Xp/luGwBA/e3atUt9h49Q9dU95Ov45dMu2/rmQTIZGfp0/fLTLhf8qFxnlW3VmsWL1LlzZw+r/YIx0QMAAABIRTTKAQApze/3a96cUt1wTgsFXt/i+mF97Qfv6eDWtTr3jntlWWf+ry+jRUv5B9ym7zzyc82eO7chygYAAACQxsq2l2lo0XjZvYbI364gpnXaDh2rwIF9qvrzVtfrA//cqYLdb2v98mXKz8/3slwAAJAmbJmkGUBjoFEOAEh5lmXp/8x4SmO6X6narSvl2Pbn1wUq9qpi5XydO/4eWZm+2DOzfMrpf6se/UOJpj4xvSHKBgAAAJCGVq9Zq/H3PaDM/rcqK69VvdbNv/2b+uytHarZ+Uady4N/26YutYe0ctFC5ebmelcsAAAA0IzRKAcANAvGGP14yhRNGjtatesWyj4WUvDTT7R/UYkKRt+lzJb1/7DIWBnK7jVYM7e8ogcnTebUsgAAAAAS8lxJib776K/kH3ibMnJa1Ht9y7LU4Y57dHDrOtWW/1OO4yjw2ibdlH+2np81Sz5f7F8OBgAAANJdZlMXAACAl+4uLlb7/Hx9/79/oY8r9qndwNHyt20fd54xRtnX3awNf/uLxhYXq+TZZ5WVleVhxQCQWvjSENzEul+YZjSRrR1xl63mc9cANJBHp07V7A1bld1vlEwMU0KdipXpU4cJ92jvzN/o7I4X6JvDh+jhyZM9rBQAAABIDxxRDgBodgYNGKBfPfy/1OqsPGW1buNJpv+r3fVWZp4GjRyl6upqTzIBAAAANH+2beveByeq9NXt8t80MKEm+b9ZWT6dc25HTejfmyY5AADwjO1YCifBsB3al2gc7GkAgGZp+LBhWrVwvqzNyxQ4WOFJpv+iLtpz/iXqM2SoKisrPckEAAAA0HwFg0HdNmGCtn5cLf+1PT05s0a45qiCK+fpNz/7qX76458kXiQAAACQpmiUAwCarcLCQq1euEAtt21WYM8HnmRmn99JVVfeoL7Dhqu8vNyTTAAAAADNT1VVlQYMH6F3ctrId/nVnmSGDh9SeM18lf52hvr26eNJJgAAAJCuaJQDAJq1goICrVu2VPm7/qbA7r97kunP76Bwj0EafPtYvbFjhyeZAAAAAJqPiooK9R4yVBWdr5C/8FJPMgOV+5W5ZYWWzinVVV27epIJAAAApDMa5QAAzxkTPZpSXl6eVi1epIurKhR4q8yTzKyzWyuz7ygV3Xu/1m/c4EkmACQbx3GiRqqyHe9GU9eRyprL/oTjTMSAtyxjogZSw65du9RvxEhVX91Tvo4XeJIZ/KhcZ5Vt1ZrFi9S5c2dPMgEAACKFZRSWlQSD975oHDTKAQBpwe/3a96cUt1wTgsFXt/iyYfzGTkt5R9wmx545OcqnTvXgyoBAAAApLKy7WUaNm6CwjcNlr9de08yg+/tVMH7b2v98mXKz8/3JBMAAAAAjXIAQBqxLEv/Z8ZTGtP9StVuXSnHthPPzPIpu/+t+uUfSjT1iekeVAkAAAAgFa1es1YT7n9QGf1GKSuvlSeZwTe36bLaQ1q5aKFyc3M9yQQAAABwHI1yAEBaMcbox1OmaNLY0apdt1D2sVDimVaGsnsN1qwtr+jBSZM5lSwAAACQZp4rKdF3H/2VfANGKyOnRcJ5juMo8Nom9WrfSs/PmiWfz+dBlQAAAABORqMcAJCW7i4u1rSHJimw6kWFa2sSzjPGyH/dzdqw96DGFhcrFEq8AY+GwVyfDSvd5qtN5fmj3eYfT7b5o5NlXvFk05y2QSz7YTLsiwBwOo9Onaqps19Qdr9RsrISb2g7tq3g5hUaf0N3Pf3E47Kspv34zpi6AwAANF+2Y5JmAI2BRjkAIG0NGjBAM2dMV2jNPIWqDnuS6b+iu97KzNOgkaNUXV3tSSYAAACA5GPbtu59cKJKX9su/00DZTxoaNuhoAJrFuihO8bp4UmTPKgSAAAAwKnQKAcApLVu13TTktklsjYvU+BghSeZ/ou6aM/5l6jPkKGqrKz0JBMAAABA8ggGg7ptwgRt/bha/u49ZTw41Dpcc1TBVfP01I9/oDvGFXlQJQAAAIDToVEOAEh7hYWFWr1wgVpu26zAng88ycw+v5OqrrxBfYcN1/vvv+9JJgAAAICmV1VVpQHDR+idnDbyXX61J5mhw4cUXrNApb+ZoT69e3uSCQAAAOD0aJQDACCpoKBA65YtVfvdbyqw611PMv35HRTuMUhDxo7TGzt2eJIJAAAAoOlUVFSoz5Chquh8hfyFl3qSGajcr8wtK7Rsbqmu6trVk0wAAAAAZ0ajHADQKIyJHskmLy9PqxYv0sVHKhV4q8yTzKyzWyuz70gV3Xu/1m/c4EkmANSX4zhRo6nZzplHY3PqMRoqvyHFss2T4XFwk2z7r5tk3XYAvLNr1y71GzFSVVf3lK/jBZ5kBj8qV972l7Rm8SJ16tTJk0wAAIB42bIUToJh075EI2FPAwDgJD6fT/NKZ+vGNi0VeH2LJx/GZ+S0VEaPgRo9tkglc+Z4UCUAAACAxlS2vUzX9bxJRy++Uv527T3JDL63Ux3Kd2rdsqXKz8/3JBMAAABA7GiUAwAQwbIsPfPUk7r92qtUu3WlHNtOKC8cqFXFgplq23+UHvvjbE19YrpHlQIAAABoaKvXrNWE+x9Uu9F36pMNyxX8pDLhzOCb23RZ4FOtWLhAubm5HlQJAAAAoL5olAMA4MIYox899JAmjR2t2nULZR8LxZXjhI9p/7w/KO/K65R38RXKvmmwZm5+RQ9Ompy0p44FAAAAcNxzJSX67qO/km/AaGW3P1fthhdp/4t/1LHqz+LKcxxHgT9vVq/2rfT8zJny+XweVwwAAAAgVjTKAQA4jbuLi/XrKZMVWPWiwrU19VrXcWwdWFyqnPMv1Nldvy7peAM++7qbteGjgxpbXKxQKL4GPAAAAICG9ejUqZo6+wVl9xslK+t4Qzvn3C+p9c2DtO/5Z2UHauuV59i2AptXaPz13fT0E4/LsvhYDgAAJBfbsZJmAI2BPQ0AgDMY2L+/Zs6YrtCaeQpVHY55vU/WLlFGdgud06Nf1HX+r3bXWxl5GjRylKqrq70sF/VkGRM1AHjPduqOhuTEOZJBMtYe+dg19OMHpCPejyQX27Z174MTVfrqdvlvGigT0dA+6ytdlNf169r/wh/khI/FlhkKKrBmgR4uHqeHJ01qiLI9YUz0AAAAAJorGuUAAMSg2zXdtGR2iazNyxQ4WHHG5T97daNChz9R24GjT7mM/6Iu2tvxEvUdMlSVlYnPcwgAAAAgMcFgULdNmKCtH1fLf21PmVN0is/uep1yLrhQBxbNluPYp80M1xxVcNU8PfXjH2hCUVFDlA0AAAAgDjTKAQCIUWFhoVYvXKCWZVsU2PPBKZc7+laZqv7+tvJH3XXGTP/5nfTZ125Q32HDVV5e7mG1AAAAAOqjqqpKA4aP0Ds5beS7/OozLt+6Zz9ltmipT1YvkuO4n24jdPiQwmsWqPS3T6tP795elwwAAAAgATTKAQCoh4KCAq1bukTtd7+pwK53o66v2f13ffzqJnUYd0/Mcw768zsofOMgDb69SG/s2OF1yQAAAADOoKKiQn2GDFVF5yvkL7w05vXaDBytY1WHVfXqpqjrApX7lbl1pZbNLdVVV13lZbkAAAANIiyTNANoDDTKAQBNJlXnvsvLy9OqxYt08ZFKBd4q+/zy2r0f6sDaxeow/l5ZmZn1ysw6u7Uy+4xU0T33a/3GDV6XDCCNOI4TNRqS2/zVDTmndWPP1+31fWmoeb6TYbs06jz0jbyfA2jedu3apX4jRqrq6p7ydbyg3uu3u/VOVf/jbR3927bPLwt+VK687S9pzaKF6tSpk5flAgAAAPAIjXIAAOLg8/k0r3S2erTNVeD1LQp+UqmKJaXqMOY/lZndIq7MjJyW8g+4TQ888nOVzp3rccUAAAAAIpVtL9PQovEK3zRY/nbt48qwLEsF4+/RJ69tUe2uvyv43k6d+8E7WrdsqfLz8z2uGAAAAIBXaJQDABAny7L0zFNP6vbuV+qjmb9V/pCx8rU6J7HMLJ+y+92qX/6hRFOfmO5RpQAAAAAirV6zVuPve0CZ/W9VVl6rhLKszEwV3HGPKlbO14WH92vFwgXKzc31plAAAAAADaJ+54UFAABRfjRlitrn52v6zFLZ7c+VlZmVUJ6xMpR902DN3LxJe/bu1ZPTpsqk0rnpAQAAgCT3XEmJ/vfv/yj/wNtkZfkSznMcR+E3/qzbR4/WjMd/rYyMDA+qBAAAaFy2Y8l2mv4Y22SoAemBPQ0AAA/8591369cPT1Zg9YsK19YknGeMUfZ1N2vDRwc1trhYoVDIgyoBAAAAPDp1qqbOfkHZ/UZ50yS3bQU2r9D4G7rrt09Op0kOAAAApAga5QAAeGRg//6aOWO6QmvnKVR12JNM/1e7662MPA0aOUrV1dWeZAKIn+3UHcnAcZw6o6E15DZwYhjxiqw71tGQGrumhty+bhp7ezb2cyEWjb0NkDosY+oMNA7btnXvxIkqfXW7/DcNlLES/1jMDgVVu3q+Hi4ep4cnTfKgysZjTPQAAAAA0gmNcgAAPNTtmm5aMrtE1uZlChys8CTTf1EX7el4ifoMGarKykpPMgEAAIB0EgwGdduECdp6sFr+a3t6MrVRuOaIgivnacZPfqgJRUUeVAkAAACgMdEoBwDAY4WFhVq9aIFalm1RYM8HnmRmn99JVV+7QX2HDVd5ebknmQAAAEA6qKqq0oDhI/ROThv5Lr/ak8zQ4UMKr1mo0meeVp/evT3JBAAAANC4aJQDANAACgoKtG7ZErV//00Fdr3rSaY/v4PCNw7S4DFj9caOHZ5kAgAAAM1ZRUWF+gwZqorOl8tfeKknmYED+5W5daWWzS3VVVdd5UkmAABAMrAlhWWafNhNvSGQNmiUAwDQQPLy8rRq8SJdfLRSgbfLPMnMOru1MvuMUtE992v9xg2eZAIAAADN0a5du9R3+AhVXd1Dvo5f9iQz+FG58na8pDWLFqpTp06eZAIAAABoGjTKAQBJw5jokep8Pp/mlc7WjW1aKvD6FjmOk3BmRouW8g+4TQ888nOVzp3rQZWIZBlTZwDpynaih1cclxEvtzrjqdtxnJhGIrzI9ur+utbnMrzUUPsTAEQq216moUXjZfcaIn+7Ak8yg+/tVIfynVq3bKny8/M9yQQAAADQdGiUAwDQwCzL0jNPPanbr7tKtVtXyrETP3mQleVTdr9b9cs/lGja9OkeVAkAAAA0D2vWrtOE+x9UZv9blZXXypPM4JvbdFngU61YuEC5ubmeZAIAAABoWjTKAQBoBMYY/eihhzSpaLRq1y2UfSyUeKaVoeybBuu5Ta/owUmTPTlaHQAAAEhlz5WUaOIvH5NvwGhl5LRIOM9xHAVe26Re7Vvp+Zkz5fP5PKgSAAAgOdmOlTQDaAzsaQAANKK7i4v164cnK7D6RYVraxLOM8Yo+7qbteGjgxpbXKxQKPEGPAAAAJCKHp06VVNnv6DsfqNkZSXe0HZsW4HNKzT+hu56+onHZVl8jAYAAAA0J7zDBwAkteY2Z7kkDezfXzNnTFdo7TyFqg57kun/ane9lZGnQSNHqbq62pNMAMnH6/myG1M8817HMhe3l/OPu9bgMhJxphyv5kj3dNu5jFSQys8XAPVj27bunThRpa9ul/+mgTIeNLTtUFC1q+fr4eJxenjSJA+qbHrN8W8rAAAAIBE0ygEAaALdrummJbNLZG1epsDBCk8y/Rd10Z6Ol6jPkKGqrKz0JBMAAABIZsFgULdNmKCtlVXyX9tTxoMOcLjmiIIr52nGT36oCUVFHlQJAAAAIBnRKAcAoIkUFhZq9aIFalm2WYE9H3iSmX1+J1V97Xr1GjhY27a97kkmAAAAkIw++eQT9ezbT+/ktJHvims8yQwdPqTwmoWa/dsZ6tO7tyeZAAAAqSLsWEkzgMaQ2dQFAACQzgoKCrRu2VKNuH2sKgK18ne+OOFMK7uF9h6o0IT/ulfPP/s7fe3KKxMvFADwuYrKffoo88N6r5dVyZ9fAOCViooKDb1tjHa9/77yL+/mSWagcr98r67Xwrml6tSpkyeZAAAAAJIXn9QAANDE8vLytGrxIo0tvlN/f7ta/i5Xx50Vrq3RvhefVdvew+Uv6Kix375PMx79mXrffIuHFQNAemvfroPa77qw3utVtNvVANUAQPrZvXu3Ro6foGPX9da53+ivvaX/R+1H3yV/u/ZxZwY/Klfe269ryeJFys/P97BaAAAAAMmKcxcAAJAEfD6f5pXO1o1tWirw+hY5jlPvDPtYSPtefFatu/dQbueLldmipbL736YHHvm5SufObYCq04dlTNRAbIzLQHKynegRL8dlxFNDzLfnOGccrrcXw3C9vdhLO61Ybt+thnjvr2sN8W5z1f/xjeX2E9nv0LB4PY8f7yO8Vba9TEPGjpPdc7D87QqUlXe22o8sVsX85xT67NO4MoPv7VSH8p1at2xps2mSGxM9AAAAANRFoxwAgCRhWZaeeepJ3X7dVardulKOfaoWTTTHtlWxcJZyL7xMeVd8cepJK8unnL636pfPztK06dMbomwAAACgUaxZu07j73tAWf1uVVZeq88vz27fQW37Dtf+559VuOZovTKDb27TZYFPtWLhAuXm5npcMQAAQGpxZGQnwXD4ai4aCY1yAACSiDFGP3roIU0qGq3adQtlHwudcR3HcfTxqnnytTpHrb9xc3SmlaGcm4Zo5qZX9OCkyXEdrQ4AAAA0pedKSvTdXz6m7AG3KSOnRdT1LTtfrFbX9tT+F56N+T104LVN6tW+lZ6fOVM+n68hygYAAACQxGiUAwCQhO4uLta0KZMUWP2iwrU1p1328MtrZQcCattnxCmXMcYo+9qbtfGjgxpbXKxQ6MwfHgIAAADJ4NGpUzW15Hll9x0lK+vUDe28r16jloVddGD+zNOencmxbQU3r9D4G7rr6Scel2Xx8RgAAACQjvhLAACAJDVowADNnDFdobXzFKo67LpM9Ruv6Wj5e2o3bHxMmf4ruustK0+DRo5SdXW1l+UCAAAAnrJtW/dOnKg5r25X9k2DZGJoaLe+/mb5WrfVxyvnuZ5JyQ4FVbt6vh66Y5wenjSpIcoGAAAAkCJolAMAUoox0aM563ZNNy2ZXSJr8zIFDlbUua7mn2/r07JX1KHov+p1FEz2RV2097xL1GfIUFVWVnpdMgCPOI4TNbxkO3VHvByXEc/tx1pDLNvFjnFEZ8c24uXEcBtu4rsv8e0/cT8uLiNe8dYQi4Z+XgHwTjAY1JgJE7S1skr+7j1l6vHGv03f4XICAX320to6l4drjiq4ap5m/OSHumNckdclAwAAAEgxNMoBAEhyhYWFWr1ogVqWbVFgzweSpNo95arcuELnjb9XlpVZ78zs8zup+qvXq++w4SovL/e4YgAAACB+VVVVGjB8hN7JaSP/5dfElZE/8g4d/WCXqne8JkkKHT6k8JoFmv2bGerTu7eX5QIAADQbYcdKmgE0BvY0AABSQEFBgdYtW6L2wynNjQABAABJREFU77+pz7a9rIplz6vD7d+S5cuOO9Off67sGwZp8JixemPHDg+rBQAAAOJTUVGhPkOGqqLT5fJfeGlCWQVF39Kn217R4T9vVeaWFVo2t1Rdu3b1qFIAAAAAqY5GOQAAKSIvL0+rFi9Su4/36JwrrpYvr1XCmVlnt1Zm71Equud+rd+4IfEiAQAAgDjt2rVLfYePUHXXHvJ3/HLCeZaVqbY3D5beeUNrFi9Sp06dEi8SAAAAQLNBoxwAgBTi8/n08qaNuuXC81W7bYsnc6tmtmip7P636YFHfq7SuXM9qBJAcxbvPNQNNR+5dOb5uo9nnXm4zY3tOl92Ai+9Z8qOd4702LZB6s5bDqQKy5iogdiUbS/T0KLxcm4aIn+7Ak8yA+/t1Hn73tNft72u/Px8TzKTkTHRAwAAAMCZ0SgHACDFWJalZ556UmO6X6nal1bJsU/VEqlHZpZPOX1v1S+fLdG06dM9qBIAAACIzZq16zTh/geV1e9WZXlw1iRJCry1TZcFDmnFwgXKzc31JBMAAKC5s2VkO0kwxDf/0DholAMAkIKMMfrxw1P0/aJbVbN+oexjocQzrQzl3DRYMze9ogcnTfbkaHUAAADgdJ4rKdF3f/mY/P1HKyOnRcJ5juMo8OfN6tW+lZ6fNUs+n8+DKgEAAAA0RzTKAQBIYXcXF2valEmqXTNP4dqahPOMMcq+9mZt/OigxhYXKxRKvAEPAAAAuHl06lRNm/2CsvuOkpWVeEPbsW0FNq/QuBu66eknHpdl8bEXAAAAgFPjLwYAAFLcoAEDNHPGEwqtm69Q1WFPMv1XdNdbVp4GjRyl6upqTzIBAAAASbJtW/dNnKg5r26Xv+dAGQ8a2nYoqNq1C/RQ8Tg9PGmSB1UCAAAAaO4ym7oAAAASZVymrEm3s4Z3u6abFs+epVsnFCtwXR/527ZPODP7oi7al9NCfYcM1ZIXX1C7du08qLT5sFx2PDvddjykDLuRd814by+WKR9s1/XOnB1LTW6373Z7cXOk8Em34dYWimUetljaSbZLjNt6kffZuP2n6pYfsamsBp4+rrFvD0DDCQaDGnfXXXpHOfJ37+lJZrjmqILrF+mpn/1UfXr39iQTAAAgHYVlFE6CY2zDzFGORtL0ezsAAPBEYWGhVi9aoBbbtyiw5wNPMv0dO6nqqzeo77DhKi8v9yQTAAAA6amqqkoDho/QOzlt5L/8ak8yQ4cP6djaBZr9mxk0yQEAAADUC41yAACakYKCAq1btkT55W+qdvffPcn053eQfcMgDR4zVm/s2OFJJgAAANJLRUWF+gwZqopOl8t/4aWeZAYq9ytj6wotm1uqrl27epIJAAAAIH3QKAcAoJnJy8vTqsWLdPHRAwrsLPMkM+vs1srsPUpF99yv9Rs3eJIJAACA9LBr1y71HT5C1V17yN/xy55kBj4q11k7XtKaxYvUqVMnTzIBAAAApBca5QAANEM+n0/zSmfrhjYtVbttS0zz/p5JZouWyu5/mx545OcqnTvXgyoBAADQ3JVtL9OwovFybhoif7sCTzID7+1Uhw92at2ypcrPz/ckEwAAAJLjGNlJMByHOcrROGiUAwCaJWPqjnRkWZaeeepJ3X7tVap9aaUc2048M8unnL636tFnSzT1iekeVAkkL9uJHunGcRmeZTtO1IhkuwzHiR5R67k8dm63F44Ysd5eItvh5By324usKexSdyz7plvdbrcXvd6ZH5dENNT+lErS/XUF6WX1mrUaf98Dyux3q7LyWnmSGXhzmy4LfqoVCxcoNzfXk8xUw986AAAAgDdolAMA0IwZY/SjKQ/p+0WjVbN+oexjocQzrQxl3zRYsza/ogcnTfa8iQIAAIDU91xJib736K+UPeA2ZeS0SDjPcRwF/rxJvQpa6fmZM+Xz+TyoEgAAAEA6o1EOAEAauLu4WNOmTFLt6hcVrq1JOM8Yo+xrb9bGjw5qbHGxQqHEG/AAAABoHh6dOlXTZr+g7L6jZGUl3tB2bFuBzSs07obuevqJx2VZfJwFAAAAIHH8ZQEAQJoYNGCAZj49XaG18xSqOuxJpv+K7ir7NKBrvv4NVVdXe5IJAACA1GTbtkaOuU3/b/5i+XsOlPGgoW2HgqpdM18PFY/Tw5MmeVAlAAAAABxHoxwAgDTS7ZpuWlxaIrNlmQIHKxLOCx3+RIfe+LNqC7+mvkOHqbKy0oMqU5dlTJ0B1EdDzgvdkGKdyz2W+3em+bNjrcFtnu1Y5h8P2070cJkzPF6OIuYgd7m9WOYWd71/cc57Hcs2j2k++Rj3g2SUqs89JAf+7/9CMBjUmAkT9HenhY5W7lfgX7sSzgzXHFFg1Tw99ZMf6o5xRR5UmXoi5yNP890MAAA0MFtW0gygMbCnAQCQZgoLC7V60QK1KNuswJ4P4s45dvSI9s77g9oNGK2zLr9aVZdfr77Dhqu8vNy7YgEAAJD0qqqqNHDESL2b3UY5X7tW5xXdo4qVCxSo2Bt3ZujwIR1bu1CzfztDfXr39rBaAAAAADiORjkAAGmooKBA65YvVX75m6rd/fd6r2+Hgto37/dq/Y0+anl+Z0mSP7+D7OsHafCYIr2xY4fXJQMAACAJVVRUqM+Qoaq44HL5O18qScpskasOt96l/YtKFPr0k3pnBir3y9q6Qsvmlqpr165elwwAAAAAkmiUAwCQtvLy8rRq8SJdfPSAAjvLYl7PscPav+A55V5ylfIu/Vqd67LObq2s3iNVdO93tH7jBq9LBgAAQBLZtWuX+g0fqSNX9ZT/vAvqXOdvk6/8AaO178U/6NjR6pgzAx+V66wdL2nt4kXq1KmT1yUDAAAAwOdolAMAkMZ8Pp/mlc7WDW1aqnbbljPOzeo4jiqXvyB//nlq3b2H6zIZOS2V3Xe0HnjkFyqdO7chygYAAEATK9tepmHjJsjpMVj+tu1dl2lxfme1/kYf7XvhWdnBwBkzA+/tVIcPdmrdsqXKz8/3umQAAACcQdgxSTOAxkCjHACQFoyJHjjOsiw989STuv3aq1T70ko5tn3KZQ9tXiEZqU2vQafPzPIpp88oPfqHEk2bPt3rkgGchu1Ej1g4LqMh2S4jqiYnerjdP8dx6gy3bLessONEDEWNkO1EjXi3jaO6eW63F12TE70NXO9fxDZw3U7RI57HxUvx7nfx7ueIjXEZwMnWrF2nCfdPVFbvUcrKa3XaZfMu+5rOuuwq7Z//nBw7fMrlAm9u02XBT7Vi4QLl5uZ6XDEAAAAARKNRDgAAZIzRj6Y8pO8XjVbN+oWyj4Wilqkqe1mBij3KH1wUW6aVoewegzVz0yt6cNLkMx6tDgAAgOT3XEmJvvuLx5Tdb7QyclrEtE7rbj2U3b6jKpc9H/We0HEcBf68Sb0KWun5mTPl8/kaomwAAAAAiEKjHAAAfO7u4mL9+uHJql39osK1NZ9ffuTdv+rTN7ep/ej/rFeeMUbZ3W/Wxo8OamzxnQqFohvwAAAASA2PTp2qaSUvKKfPKFmZWfVat02vQTLG6NONKz6/zLFtBTav0LgbuuvpJx6XZfExFQAAAIDGw18gAACgjoH9+2vm09MVXDtPoarDqv3Xezr40lqdV3Rv3B9e+i/vrretszRo5ChVV1d7XDEAAAAakm3bum/iRM15dbuyewyUifM9Yf7gItVW7FXV6y/JDgVVu2a+ptw5Tg9PmuRxxQAAAIiH7ZikGUBjoFEOAACidLumm5aUlii0foH2r5qv827/tqysxE6D6S/son3nXaK+Q4aqsrLSo0oBAADQkILBoMZMmKCtB6qVfU1PGZPYh5YFt31Th9/cpo/n/o+e/PEPNaEotml9AAAAAMBrNMoBAICrwsJCLZ5Tqi+ff77Cn33iSaa/YydVXXGD+g4brvLyck8yk5llTNSAZFwGUoft1B1uHMeJGrFwnLoj8rZsxz3bluqMyBzHkcKOEz1s1RnHbCd6hBU1Yr0/0XcwIsvl9iJrCtvRtbvdv+ht4LKdXLdn3RHzXYnh8XW7PSCVpeP/61VVVRo4YqTe9beRv8vVnmSGqw+r7Tlt9D/TH1ffPr09yWwujIkeAAAAABoOjXIAAHBKX/nKV7Rx1Urll7+p2t1/9yTTn99B9vWDNHhMkf76xhueZAIAAMBbFRUV6jNkqCouuFz+Cy/1JDNQuV/WSyu0/Pk56t+/vyeZAAAAABAvGuUAAOC08vLytGrxIl1cc0CBnWWeZGad3VpZvUdq7D33a/3GDZ5kAgAAwBu7d+9Wv+EjdeSqnvKfd4EnmbV7ypX715e0ZvEiderUyZNMAAAAeMtxLNlJMByH9iUaB3saAAA4I5/Pp3mls3VD25aq3bYl/tMOnyQjp6Wy+47WA4/8QqVz53pQJQAAABJVtr1MQ4vGy+kxWP627T3JrN21Ux3+tVPrli1Vfn6+J5kAAAAAkCga5QCAtMUcgPVjWZaeeepJ3X7dVap9aaUc2048M8unnD6j9OgfSjRt+nQPqgSQrCLn0PZS9NzmjsuIni/7THOWh22p9pgdNeL9qpAjp05OLPORh11rj75/8c41HovIx87rxw9A8lizdp0m3D9RWb1HKSuvlSeZgbe26bLgp1qxcIFyc3M9yWwu+FsEAAAAaFo0ygEAQMyMMfrRlIf0/XGjVbNhoexjocQzrQxl9xismZte0YOTJntytDoAAADq57mSEn33F48pu99oZeS0SDjPcRzV/mWTburQSs/Pmimfz+dBlQAAAADgHRrlAACg3u4uLta0KZNUu3aewrU1CecZY5Td/WZt/OigxhYXKxRKvAEPAACA2Dw2bZqmlbygnD6jZGVmJZzn2LZqt6zQ+Bu66+knHpdl8fETAAAAgOTDXyoAACAugwYM0MwZTyi0fr5CVYc9yfRf3l1vWXkaPOpWHTlyxJNMAAAAuLNtW/dNnKjSV8qU3WOgjAcNbTsUVM26BXroznGaMnmSB1UCAACgsYRlkmYAjYFGOQAAiFu3a7pp8exZMluXKXCwwpPM7MIu2nvuxeozZKgqKys9yQQAAEBdwWBQYyZM0NYD1cq+pqeMB5Nkh2uOqnbNPD354x/ojnFFHlQJAAAAAA0ns6kLAAAgmUR+Psh02WdWWFio1YsWaNiY23W0y3Xyn3tBwpn+jp1U5ctWv+EjtLB0tr785S8nXiiApOL2+mo7kctEL2S7ZNkRy7m9dIddssIRYbXHotMPB6KngghHFhqjsBOZF3164+zM6O8yG1P39iyXZlbkNnBreFmu27Pucm7fpPagd4aTWGzPlOH2XGsuqqqqNOL2sapo31n+Cy/1JDP02SGFtyzX7Gd+o65du3qSCQAAAAANiSPKAQBAwgoKCrRu2VLll7+p2t1/9yTTn99B4W8M1OAxRfrrG294kgkAAJDuKioq1GfIUFVccLlnTfJA5X5ZL63QsrmlNMkBAAAApAyOKAcAAJ7Iy8vTqsWLNLb4Tv1jZ7X8l12dcGbW2a1l9R6psffcrxm//G/1vvkWDyoFgMR8/PF+Hcj4qN7rZRzkzy8ATWv37t0aOW6Cwtf1kb9te08ya/eU66x3XteSxYuUn5/vSSYAAACahu1IttP0Z1aK80RuQL3xSQ0AAPCMz+fTvNLZum/id/XSti3yX90j4fkuM3JaKrvvaD3wyC/0w4oDGjd2rEfVAkB82rQp0AUfXFTv9f7V9r0GqAYAYlO2vUzF935HGT2HyJ/XypPM2l071eFAuRYtW6rc3FxPMgEAAACgsXDqdQAATsOY6IHTsyxLzzz1pMZce6VqX14lx3abUbiemVk+5fQZpV8+W6L//uWjHlTZdCxjogaSk2WiB6I5jhM1Gvb2okeksB093NYLO06dEQiHo0Z1MHpEzm0ee+1OnRy324usKew40XW73L94tpOXGns/AFA/8xYs0IT7HlRW71HK8qhJHnh7my4LHNKKhQtokseAvysAAACA5EOjHAAAeM4Yox8/PEXfL7pVNRsWyj4WSjzTypB18ZV66re/0cTJk2nCAAAAxOC5khLd8+BEhTteqIycFgnnOY6j2r9s1k0FrfR8ySz5fD4PqgQAAACAxkejHAAANJi7i4s1bcok1a6dp3BtTUJZwU8qtX/ZHJ1/+33a8K+DGntHsUKhxBvwAAAAzdVj06ZpWskL+tJ/TNKhbX9Sze6/J5Tn2LZqt6zQ+Bu66eknHpdl8bESAABAc2I7VtIMoDGwpwEAgAY1aMAAzZzxhELr5ytUdTiujGPVVdq74I9qP2isfK3OUXaX7nrb5GnwyFt15MgRjysGAABIbbZt676JE1X6pzJl3zhQVpZP5467RxXrFqt274fxZYaCqlm3QA/dOU5TJk/yuGIAAAAAaHw0ygEAQIPrdk03LZ49S2brMgUOVtRr3XCgVnvn/15tewxSiw5f+vzy7MIu2tfhYvUZMlSVlZVelwwAAJCSgsGgxoyfoK0V1cq+pqfMicmwM7Nb6Nzb/lP7l81R8JP6vXcK1xxVYM08PfWTH+iOcUUNUTYAAAAANDoa5QAAoFEUFhZq9aIFarF9swJ7P4hpHSd8TPsW/EFnf/U6nXVRl6jr/R07qbrL9eo7bLjKy8s9rhiNyUQMNDwnYiQj22W4ieW+2E70CIWdM46joXDUsOPcYrajOjmx3H4o7ETVHfc2cBnJKPK+JOv+2ZzwGixZxkSNVFRVVaWBI0bq3ew28ne5Oup6X6tz1H7IWO1b8Ecdq/4spszQZ4cUWjdfJb+doT69e3tdcrNlTN0BAAAAIPnQKAcAAI2moKBA65YvVbv3/6baM8yR6Ti2KpbOVovzO6vVlV8/5XL+dh3kfH2Qhowp0l/feMPjigEAAFJDRUWF+gweqoovXS5/50tPuVxOhy/pnJ6DtPfFZxUO1J42M1C5X9ZLK7R0bqm6du3qdckAAABIMo6M7CQYTtp+hReNjUY5AABoVHl5eVq1eJG+crRCgXe2n3K5T9YvUUZ2S7W5vv8ZM7PObq2sm0dq7Lfv0/qNG7wsFwAAIOnt3r1b/YaP1JGresp/3gVnXP6si7ro7Cuv0775f5ATPua6TO2ecuW+sVVrFi9S586dvS4ZAAAAAJocjXIAANDo/H6/5s8p1Q1tWqi2bKscp+6JdQ//eaNChz9Rfr/RMWdm5LRUTp/b9MBPfq7SuXO9LhkAACAplW0v09Ci8XJuHCx/2/Yxr3f2VV9Xiy9dqIols+U4dSdjqN21Ux3+tVPrli9Tfn6+1yUDAAAAQFKgUQ4AAJqEZVl65qknNab711T78io59vEPaI+8Xabqf7yt9sPvqn9mlk8tet+qR39fomnTp3tdMgAAQFJZs3adJtz3oLJuGaWsvFb1Xv+cG/opI6elPl63+PPLAm9v02WBQ1qxcIFyc3O9KxYAAAAAkkxmUxcAAECqMS5T5EQcEI0YGWP044en6LxzZ+rXf5glfflSffzaJp0/YaIsK77v8xkrQzk9Bmvmxk36aM9ePTltqozbg5ZErIj6bHYoJAk7RXdFW9GFuz2tIp9rIZc7HAq7ZcW3YRynbp7b7bk9/yMvcrt/GSkyf1vkXbZSo2wgKT1XUqKpv/ujsvuOlpXlizunXf/R2jf/WR1+baP8lqVeF3bUU7+eFvd7sXSU5G81AQAAAJwCf/UAAIAmd3dxsX49ZZIq1i5UhxF3ycpM7Lt8xhjldLtZGz88qLF3FCsUCnlUKQAAQNN7bNo0TSt5QTm9RyXUJP+39iOK9ekbf9HQr12sp594nCY5AABAmgo7JmkG0Bj4ywcAACSFgQMGaPWyJQr/aYVCVZ96kpndpbveNnkaPPJWHTlyxJNMAACApmLbtu6bOFGlfypT9o0DZTxoaNuhoGrXL9Tjv3pMj/7sZx5UCQAAAACpgUY5AABIGt2u6abFpSVyXlqmwMcVnmRmF3bRvg4Xq8+QoaqsrPQkEwAAoLEFg0GNmTBBWyuqlX1NT0+mlgnXHFHt2nl66pEf6o5xRR5UCQAAAACpg0Y5AAAeMKbuQPwKCwu1ZvFC5ezYrMDeDzzJ9HfspOou16vfsBEqLy/3JBOA9xzHqTPc2I7jMlRnuK4nJ2qEnYhhR4+QbUeN+Kdur5vndntRNTnRdbtvl8gRvZ1cK4phmwPNjWVM1Eh2VVVVGjhipN71t5G/y9WeZIY+O6TQ+gWa/dsZ6tO7tyeZAAAAAJBKaJQDAICkU1BQoHXLl6pt+d9U+/67nmT623WQ/fWBGjKmSH994w1PMgEAABpaRUWF+gweqoovXS5/50s9yQxU7pf18gotnVuqrl27epIJAACA1Gc7VtIMoDGwpwEAgKSUl5enVUsW6aKaAwq8U+ZJZtbZrZV180gVfft+rd+4wZNMAACAhrJ79271Gz5SR67qKf95F3iSWbunXLl/3ao1ixepc+fOnmQCAAAAQCqiUQ4AAJKW3+/X/Dmlur5tS9Vu3+LJaYEzcloqu89oPfDIL1Q6d64HVQIAAHivbHuZhhaNl9NjsPxt23uSWbtrpzp8uFPrli9Tfn6+J5kAAAAAkKpolAMAgKRmWZaemfGkbrv2StX8aaUc2048M8unFreM0qPPlmja9OkeVAkAAOCdNWvXacL9E5V1yyhlndXKk8zA29t0WfCQVixcoNzcXE8yAQAAACCV0SgHAKABGBM9ED9jjH788BR9f9xoHd24UPaxUOKZVoZybhysmRtf0YOTJntytLpXLGOiRroxLgONzzLRIxU4TvSIhe04UcP9BrypM+bbi7z5OO9fMkjF/am54fU1+T1XUqLv/uIxZfcdrYycFgnnOY6j2r9s0k0dWun5klny+XweVJm+eJ8PAACaM1tGtpMEg79U0EholAMAgJRxd3Gxpj08STXrXlS4tibhPGOMcrrdrI0fHlRR8Z0KhRJvwAMAAMTr0alTNa3kBeX0HiUrMyvhPMe2Vbt1ucbf2F1PP/G4LIuPgQAAAADg3/gLCQAApJRBAwZo5tPTFdwwT6GqTz3JzO7SXW+ZszR45ChVV1d7kgkAABAr27Z138SJmvPKdmXfOFDGg4a2HQqqZt18PXTneE2ZPMmDKgEAAACgeaFRDgAAUk63a7ppcWmJ9PJyBT6u8CQz+8Iu2tfhEvUdOkyVlZWeZAIAAJxJMBjUmAkTtLWiWtnX9JTx4Fze4Zojql0zT0/+5Ie6Y1yRB1UCAAAAQPNDoxwAAKSkwsJCrV60QDk7Nqt2zweeZPo7dlJ1l+vVb9gIlZeXe5IJAABwKlVVVRo4YqTe9beRv8vVnmSGPjuk0PoFmv3MDPXt09uTTAAAAKQHR8fnB2/q4TBHORoJjXIAAJCyCgoKtG75UrX74G+qff9dTzL97TrI/vpADRlTpL++8YYnmV6wjIkaQCJMxEgGxpg6I/6c6BGLmJ9nHm2weJ/X8d4/9yxvtrmXIvfN5KgqPpaJHmh8yfr/Z0VFhfoMHqqKL10uf+dLPckMVO6X9fIKLZ1bqq5du3qSme68er0FAAAAkHxolAMAgJSWl5enVUsW6aKaAwq8U+ZJZtbZrZV180gNGzdBs2fP9iQTAADg3959911de2MPHbmqp/znXeBJZu1H5cr961atWbxInTt39iQTAAAAAJozGuUAACDl+f1+zZ9TquvbtlTt9i1yHCfhzNAnlTpSXa1fPvM7lc6d60GVAAAAUtn2Mt1afLdqTYZCH73vSWbtrp0q+PBtrVu+TPn5+Z5kAgAAAEBzR6McAAA0C5Zl6ZkZT+q2a69Uzcsr5dh23FmBgxXat/J5nTvqW2rZe7Qe/V2Jpk2f7mG1AAAgHa1Zu0533PegfLeM0nlj79GhHa+o5p9vJ5QZeOt1XRY8pJWLFio3N9ejSgEAAACg+aNRDgBAI/FyTlm4M8boxw9P0ffHj9bRjQtkHwvVOyNU9an2LpmpDkMmyJfXSsbKUM6NgzVrw6t6cNJkT45WR+pqyLmGk3Gu6GTkNq93LI+LJRM1MkzEsKJHlmVFjQRmT6+T43Z7UTWZ6Lrdt0vkiG/+83TEcw+N5bmSEn33548pu/doZWS3kGVlquPYe3Vg8wrV7qn/keWO46j2L5t007mt9XzJLPl8vgaoOr3wfh0AAKQ725FsxyTBaOotgXRBoxwAADQ7dxcXa9rDk1Wz7kWFa2tiXi9cW6O9C55V25uGKTv/vM8vN8Yo+5pe2vjBQY29o1ihUP0b8AAAIH09Nm2aps16QS1uGSUr64uGtuXL1nm3/Zf2r3hRgYMVMec5tq3arcs1/sbuevqJx2VZfLwDAAAAAPXFX1IAAKBZGjRggGY+PV3BDfMUqvr0jMvbx0Lau+BZteraQ2d1uth1mewu3fW28jR45K06cuSIxxUDAIDmxrZt3Tdxoua8XKacGwbKuDS0s846Wx2G3aF9i2bG9p4lFFTNuvl66M7xmjJ5UgNUDQAAAADpgUY5AABotrpd002LS0ukl5cr8PGpj9JybFv7l8xSy06X6uzLu502M/vCLtpXcLH6DB6qyspKr0sGAADNRDAY1JjxE7R1f7Wyr+552lP7Z7froHa3DNPeec+e9mw44Zojql0zT0/+5Ie6Y1xRQ5QNAAAAAGmDRjkAAGjWCgsLtXrRAuXs2KzaPR9EXe84jg6unaesvHN0znW3xJTpP6+Tqi+7Xv2GjVB5ebnHFQMAgFRXVVWlgcNH6l1fG2VfdnVM6+R++WKdc01P7Zv3rOxj0dO8hD47pND6BZr9zAz17dPb65IBAAAA2Y6VNANoDOxpAAA0IWPqDjSMgoICrVu+VO0++Jtq33+3znWfvrJO4UBA7W4ZUa9Mf7sOsq8bqCFjivTXN97wsNrYWcbUGc2dcRloesaYqOEVy2XEtp6JGpGvt8ZIWRmm7rCihz/Tihrx3kdjVCfH7faiasqIrt3t/jXk9oztvjXcfoDEpNvrZuT/jU3x/2NFRYX6DB6qii9druzOl9Zr3bzLr1HLCy9TxeJZcmz788sDlftlvbxCy56fo65du3pdclpy+38BAAAAQHqhUQ4AANJCXl6eVi1ZpItqDijwTpkkqfpvf9aRf72n/EHj48rMymutrJtGauy379P6DRu8LBcAAKSg3bt3q9/wkTr6tZ7KPveCuDLOue5mZZ19jg6unifHcVT7Ubla/nWr1ixepE6dOnlcMQAAAACkLxrlAAAgbfj9fs2fU6rr27bUwZVz9Mn2P+nc0d+SZcX/ligjp6VybrlNDzzyc5XOnethtQAAIJWUbS/T0LHjpesHy9+2fUJZ7W4ZITsY0IElJSr48G2tX75M+fn5HlUKAAAAAJBolAMAgDRjWZaemfGkel95udp8uVDGg7dDVpZPLW6+VY/+rkTTnpjuQZUAACCVrFm7ThPue1C+W0YpK6+VJ5mtCi9TYeuztHLRQuXm5nqSCQAAAJyO7ZikGUBjoFEOAADSjjFGv/u//0eT7rhdRzctlH0slHimlaGcGwdr5sZXNHHyZDmO40GlAAAg2T1XUqLv/vwx5fQerYzsFgnnOY6j2m2bdNO5rbRhzWr5fD4PqgQAAAAARKJRDgBAEjEmeqDh3H1nsab9YJJqNryocG1NwnnGGOVcc7M2lB/U2DuKFQol3oAH6ssy0aM5cXudNIoYLsu4bRfLmDojKyN6tMjKiBqW4tuollGdHLfbi6zp+Khbd7zboDlp7vs5Usdj06Zp2qwX1OKWUbKyEm9oO7atmpeWa9yN3fX0E48nND0MAAAAAOD0+IsLAACktUEDBmjmjOkKbpqnUNWnnmRmd+mut5WnwSNv1ZEjRzzJBAAAycO2bd03caLmvFymnBsGynjQ0LZDQR3dMF8P3TVeUyZP8qBKAAAAAMDp0CgHAABpr1u3blpcWiK9slyBjys8ycy+sIv2FVysPoOHqrKy0pNMAADQ9ILBoMaMn6Ct+6uVfXVPGQ9O2RCuOaKadfP05E9+qDvGFXlQJQAAAFB/tkzSDKAx0CgHAACQVFhYqNWLFijnr5tVu/cDTzL953VS9WXXq9+wESovL/ckEwAANJ2qqioNHD5S7/raKPuyqz3JDH12SMGNCzT7mRnq26e3J5kAAAAAgDPLbOoCAADA6bkdpOQ4jV9HOigoKNC65Us1/LbbVRmoUXanSxLO9LfroNB1AzVkTJFm/79n9LUrr0y80FOwXHYWu5nvLJH3uLHvrdu8yLZHRbgdoeg04OPp9l1tt1uLvM+x3t/Ib+jaLjcYtYxbVS7bIHLfd1wqz3DZnpkRN9giKyNqmVDYJSvOrxtbxugs3xe34XZ7mS47VWTtbvud2/M/kts+FZnlFhPvt6tjmTe8sY8R8OLI31NJhnnSk6CERhXLfu+liooKDR8zVtWXdFf2uRd4kllbuV+Z29Zr6dxSde7c2ZNMuGvk3QUAAABACuCIcgAAgJPk5eVp9dLF+kqwUoF3yzzJzMprraybRmrst+/T+g0bPMkEAACNZ/fu3eo3fKSOfLWHd03yPeVq+betWrNkEU1yAAAAAGgCNMoBAAAi+Hw+zSudrevbtVTN9i2eHMWbkdNSObfcpgce+YXmPP+8B1UCAIDGULa9TEPHjpeuHyx/2/aeZNbu2qmCj3Zq/Yplys/P9yQTAAAAAFA/nHodAADAhWVZembGk/rl/56quRtWKufrA2SsxL5jaGX51OLmUfrl/8zSnr37NPl73/WoWgCN6eOP9+tAxkf1Xi/zIH9+Aalmzdp1+u4j/63sW0YpI7uFJ5m1O7fp0oyAZi9aIJ/P50kmAAAA4AXHMbKdpp+zxkmCGpAe+KQGAADgFIwx+tGUh3RuQYF+/ews5fQcJiszK7FMK0M5Nw7WzI2btGffXk2fOrVB58wF4L02bQp0wQcX1Xu9D9u+1wDVAGgoz5WUaOr//FE5vUfLykq8oe04jgJlm3VT4fl66tfTZCX4BTwAAAAAQGL4qwwAgBRkTN2BhnX3ncWa9oNJqtnwosK1NQnnGWOUc83N2lB+UGPvKFYoFPKgSneWMVEDaGjGmKjhFctlRL4mGrmMyGWMlGHVHVmWFTVyfZlRI8OK7/5YRnVy3G4vsqYMK77757advNRQjy9wOo35/9lj06Zp2qwX1OKWUd40yW1bNS8t17gbu+vpJx6nSd7A3F7zAQAAACASf5kBAADEYNCAAZo5Y7qCm+YpVPWpJ5nZXbrrbeVp0IhROnLkiCeZAAAgfrZt6/7vfldzXipTzg0DE552RZLsUFBHN8zXQ3eN15TJkzyoEgAAAADgBRrlAAAAMerWrZsWl5ZIryxX4OMKTzKzL+yi/R0uUZ/BQ1VZWelJJgAAqL9gMKjbJ9yhLfuqlH1NT0/OlhCuOaKadfP05E9+qDvGFXlQJQAAANBw7BNzlCfDABoDjXIAAIB6KCws1OpFC5Tz180K7P3Ak0z/eZ1U2aKNrup+rcrLyz3JBAAAsauqqtLXe/TQKzv/qezLrvYkM/TZIQU3LtDsZ2aob5/enmQCAAAAALxDoxwAAKCeCgoKtG75UrX78E3Vvv9uwnk1H76nT9/apjaDijVkTJH++sYbiRcJAABiUlFRob5Dhin41ZvkhAL6rOylhDNrK/fL/GmFls4tVdeuXT2oEgAAAADgNRrlAAA0A8ZEDzSsvLw8rVqySF8JVirwblncOYEDe7V/7QKdf+u35T8nX1k9Rqro2/dr/YYNHlabPozLaGyWqTuSQWRNyVCX5TIiX8fc6jbGRI2oLGOiRoaRyzB1RmaGokZOlhU1rDj3LCNTJ8ft9iJrynCp3e3+RW9Ll+3kuj0jtrnL45IMkm3/lZq+pmR4vWsOdu/erX7DR+rIFT2Ufe4FKhj5n/r07TId+ftf486s3VOu3De3as2SRercubOH1cIN74MBAAAAxCtZPvcAAABIOT6fT/NKZ+v6di1Vu32LHMep1/rBw59o77ISnTv0TmW2PEuSlJnTUjm9RuvBR36hOc8/3xBlAwAASWVlZRo6drz0jcHyt2kvSbIsSx3H3KuDf1qrmn+9V+/M2l071f6jt7Vu+TLl5+d7XTIAAADQoJp6XnLmKEdjo1EOAACQAMuy9MyMJzXmG1ep5pWVcmw7pvWO1RzR3kXPqn2f0co+8eH855lZPrW4aZQe/d0sTXtiekOUDQBAWluzdp3uuH+ifL1GKeusVnWus7J8Om/0t7V/zXwFDuyNObN25zZdeuyQVi5aqNzcXI8rBgAAAAB4jUY5AABAgowx+tGUh/T9caN1dNNC2cdCp13eDgW1d+Hvdc61vdWyo/spWY2VoZxvDNasDa9o4uTJ9T5aHQAAuHuupETf+8WvlH3LaGVkt3BdJrPlWTp3+F3au7REwU8/OW2e4ziq3bZJPTucredLZsnn8zVE2QAAAAAAj9EoBwCgmWKuxsZ3953F+vUPJqtmw4sK19a4LuPYYe1b8kflfeVKnX3xVafNM8Yo5+qbtbH8oIqK71QodPoGfKwi5zZG6nCbd7pBb89lRIp1/vN46nabdzaWecvd5iOPZd7yLMvENOKdDNrEcBux1O62TDzzkce6+8Sy38W8H+j0+5OXGvv5Am+5PWe98Ni0aZo28wXl3DRSVmbWaZf1t2mv/L6jtXfhszp2tNp1Gce2VfPSchXd2E2/mf6ELIuPWRoa73EBAAAAeIW/4AAAADw0cEB/zZwxXcFN8xSqOlznOsdxdGDV88ppd55aX90z5szsS7vrbecsDR55q44cOeJ1yQAANHu2beu+iRM156Uy5Vw/UCbGhnbLjp11znV9tXfBs7KDgbqZoaCObpivh+4ar4cnT26IsgEAAIBG1dTzkjNHORobjXIAAACPdevWTYtLS6RXlinwccXnlx96aYVkjNrcOLjemdmdumhf+4vVZ/BQVVZWelkuAADNWjAY1JjxE7R1X7Wyu/as99kF8i75ms66+CrtW/ycnHBYkhSuOaKadfP05E9+qDvGFTVE2QAAAACABkajHAAAoAEUFhZq9aIFyvnrZgX2fqCqHS+ptmKPCvrH/2F69rmddOTS69Vv2AiVl5d7VywAAM1UVVWVBg4fqXez2ij70qvjzml9TQ9l53fUgVXPK/TZIQU3LtDsZ2aob5/eHlYLAAAAAGhMNMoBAAAaSEFBgdYtX6qcd17RJ3/9szqM+M+EM/1tO8juPlBDxhTpr2+8kXiRAAA0UxUVFeozeKgqOl6u7E6XJpzXpscghYNBfbzwWS2dW6quXbt6UCUAAAAAoKnQKAcAIE0YEz3Q8PLy8rRl3VrdcF13Bf+5w5NMX15rZfUYqaJv36/1GzYknGcZEzWaE+MyGpNlokcyiLemWLZlvPfZihixirwtY0zUyDCKHpapO0z0yLQUNRJ5CE/Ocbu9qJqs6Nrd7l+8j6dX29xNvM+9ZHzOJENNTfk61tAa4v+h3bt3q9/wkTr61Z7KPvcCD6qUaveW60tnt9Rf/vSyOnfu7EkmTo/3rwAAAAAaEo1yAACABpadna35c0p1fX5L1ezYIsdxEs7MzGmpnF6j9eAjv1Dp3LkeVAkAQPNQVlamoWPHS98YLH+b9p5k1u7eqfYfva11K5apQ4cOnmQCAAAAycaRZMs0+Uj8kzMgNjTKAQAAGoFlWXpmxpMac/1Vqnl1pRzbTjwzy6cWN43SY78v0bQnpntQJQAAqW3N2nW64/6J8vUapayzWnmSWbtzmy4NH9LKxQuVm5vrSSYAAAAAoOnRKAcAAGgkxhj9aMpD+t740Tq6ZaHsY6HEM60M5XxjsGZteEUPTprsydHqAACkoudKSvTdnz+m7FtGKyO7RcJ5juOotmyTep53tp4vmSWfz+dBlQAAAACAZEGjHAAAoJHdfWexpv5gko5ufFHh2pqE84wxyrn6Zm364KDG3lGsUCjxBjwAAKnk0alTNW3mC2rRa5SszKyE8xzbVs2fVqioRzf9ZvoTsiw+PgEAAACA5iazqQsAAABNx5joyzgguXEMGjBA+W3b6q77HlDWDcOUlXt2wpnZl3bXzt1va/CIUVrw/BxOD5smTMQTOVXOKhBZtxRdu1tbyo7hdctyWcZW9IVWxIpu2RkudbosFhMjKcOtuJNrclsvooYzRJxYJ7bsM91WKknl2hE/27b1ne99T1t371fO9QM92Q/sUFA1WxZryj3/qTvGFXlQJWLBUxgAAKDp2Y6R7TT9G7NkqAHpga9EAwAANJFu3bpp8ZwSOa8sU+DjCk8yszt30b6CS9R38FBVVlZ6kgkAQDIKBoMaM36Ctu6rVnbXnp40ycM1R1SzYZ6efOSHNMkBAAAAoJmjUQ4AANCECgsLtXrxAmW/uVm1+z/wJDP73E46ctkN6jt0uMrLyz3JBAAgmVRVVWng8JF6N6uNsi+92pPM0GeHFNy0QLOfmaG+fXp7kgkAAAAASF40ygEAAJpYQUGB1i1fqnYfvqna8nc9yfS37SDn2kEaMqZIb+zY4UkmAADJoKKiQn0GD1VFx8uV3elSTzJrD+6XeXWFlj5fqq5du3qSCQAAAABIbjTKAQBAHcbUHWgceXl5WrVkkS4KVar272WeZPryWiurx0iNu+c7Wr9hQ73WtYypM5obEzEam2Wih1eMMVGjIWuK3JanWi2W7FjqtlxG5OuW23C7f5G3l+Ey3G4vESfnuN2e2+MXXXcM9zfGumPa5jHsG7HuB/Fkx1K3l/OTN+TzM1bxbs9Ukcj/Mbt27VL/4SN19Ks9lX3uBZ7UU7u3XC3f3Ko1Sxapc+fOnmTizHjPCQAAkHxsmc/nKW/S0ez+CkKyolEOAACQJHw+n+aVztb1+S1Vs2OLHMdJODMzp6Vyeo3Wg4/8QqVz53pQJQAATaOsrEzDiibI+cZg+du09ySzdvdOtf/oba1fsUz5+fmeZAIAAAAAUgONcgAAgCRiWZaemfGkbvvGlap5daUc2048M8unFjeN0qO/K9HUx6d7UCUAAI1r9Zq1uuO+B+XrNUpZZ7XyJLN25zZdGj6klYsXKjc315NMAAAAAEDqoFEOAACQZIwx+vHDU/S98aN1dMtC2cdCiWdaGWpx/WCVbHxFD06a7MnR6gAANIbnSkr0vV/8Stm3jFZGdouE8xzHUW3ZJvU872w9XzJLPp/PgyoBAAAAAKmGRjkAAECSuvvOYk39wSQd3fiiwrU1CecZY5Rz9c3a9MFBDRgyTKFQ4g14AAAa0v0Tv6tpM59Xi16jZGUl3tB2bFs1Ly9XUY9u+s30J2RZfCwCAAAA/FuTz01+0gAaA38RAgCA0zImeqDxDBowQDOfnq7A5nkKVX3qSeYxk6Htb72twSNGqbq6OqZ1LGOiRnNiXEZjs0zdkQwia4q1rli2ZyzZxpio4VpnxHCtyeW1zK2GyOFaQ7yPT0ReLLdvxfgaHNs2OPP2jPUxj/f5kgr7eWNLhtefhhTv/x+2beveByZq0aq1OhoIyXjQ0LZDQR3dOF8P3T1eD0+enHAeYsf7SQAAAADJiEY5AABAkuvWrZsWzymR8+pyBT6uSCir5oN/6OBfNumC2ydqf/tL1HfwUFVWVnpUKQAAiQsGgxozfoL+tL9aHW+7X6HDn+jwXzYmlBmuOaKaDfP05CM/1B3jijyqFAAAAACQymiUAwAApIDCwkKtXrxA2W9uVu3+D+LKqN3/ofZvXKTzR90jKzNT2R066eilN6jf0OF6//33vS0YAIA4VFVVaeDwEfpHRhtlX3y1JKnDkLtU9c+3Vf1OWVyZoc8OKbhpgWY/M0N9+/T2slwAAAAAQAqjUQ4AAJAiCgoKtG75UrX9199UW/5uvdYNfnpQe1eVquOwbyozp+Xnl/vbdJDTbZCGjhmnN3bs8LpkAABiVlFRoT6Dh6ry3CuU/eVLP7/csix1vPUeffznTaop/3u9MmsP7pd5dYWWPl+qrl27el0yAAAAACCF0SgHAAD1xjyTTScvL0+rlizSRcEDqv17bEfWHTtSpT1L/qgOfYvka9Um6npfXmv5bhypom/fr/Xr18dcS3Oft7w5iXWu71jEO59zLHMwxztneOSInK/7VMPttSxyZFjRI15GdXNiuX1jYr0vMWyXGLZvLI9drA97vHPcu9bg0f6LhpXI/wu7du1S/+EjVdOlp7I7XBCdnZmp80ffq4qNi1W7/8OYMmv3lqvlm1u1Zskide7cOeZakDjeJwIAAKQm2zFJM4DGQKMcAAAgxfj9fs2bU6rr81uqZscWOY5zymXDwVp9tPj3avuNAWrR4UunXC4zp6Va3nSbHnzkF5o9Z05DlA0AgKtt27Zp2NjxMtcOVnab9qdcLjO7hToO+0/tW1Gq4KHK02bW7t6pgj07tX7FMuXn53tdMgAAAACgGaBRDgAAkIIsy9IzM57Ubd+4UjWvrpRj21HL2OFj2rvkj2rV5VrlXXj5mTOzfGrZ81Y99rvZmvr49IYoGwCAOlavWavi+ycqu+etyjqr1RmX97U6Rx36FWnv4j/q2JEq12Vqd27TpeFDWrFogXJzcz2uGAAAAADQXNAoBwAASFHGGP344Sn63vjROrploexjoc+vcxxbFStL1eLcTmr91W/EnmllqOU3Bqtkwyt64HuTTnu0OgAAiXiupETf//mv1OKm0crIbhHzei06fEltrx+kPQt+r3Cg9vPLHcdRbdkm9TwvT8+XzJLP52uIsgEAAAAAzQSNcgAAgBR3953FmvqDSTq68UWFa2skSR9vXqIMf47afr1/vfOMMWrR9WZt+dfHGntHsUKh0JlXAgCgHh6dOlW/fu4Ftew5SlZW/RvaeRd2UasrrtO+xX+UEz4mx7ZV8/JyFfXopt9Mny7L4uMOAAAAoN4cIycJhpijHI0ks6kLAAAAzYOJeP/KgciNa9CAAcpv21Z33feAas5qq+Cnn+i8Yf+RUGb2Jd218/23NWj4SC18YW5Mp6+1InYEO4V3BLc/yRrz3lguBdgeFmAiHqt4zx4Qb53xbt9Ybi/yvp0yK877nMif6/G07mK9P3VuJ84i471v8d6eaw1x3N9YeVlnvJKgBM9EvubHwrZt3T/xe3r5/f1q8fWBCT3erb/6ddlHDmv/8tnKa9lCU+75pu4YNy7uPMSnAZ+yAAAAANCg+Io1AABAM9GtWzctnD1TgV1v65zrB3mSmdOpi/a3v1R9Bw9VZWWlJ5kAgPQUDAY1ZvwEvby/WjlX9vTkSxGtruohVX2iH973nzTJAQAAAAD1QqMcAACgGfnKV76iba+9opydW1S7/wNPMnPO7aSjl96gfkOH6/333/ckEwCQXqqqqjRg2Aj9I6ONci6+2pPM4GeHVLtlvpa++ILGjS3yJBMAAAAAkD5olAMAADQzBQUFWrf8/7N33+FRVvn7x+8zCZMeEkoI0kNooihgsIsNFBJAqtIt67rrusqquOKuW35+11VWxLbrNhUJvRdBqgKWdZUmCCIIBKkhgQCpJGHO74/gChIgyTzJTDLv13WdK2XOc89nSiYz85nnOQtUd98m5e/Z5khmSN2GsknJ6n33UG3csMGRTABAYEhPT1e3lN7KbHS5Qpu3cySzIPOQ9PkiLZg2WZ06dXIkEwAAAAh0Hhm/GUBVoFEOAABQA0VHR+v9+XPVquiw8r9Z50imOzpW7hv7aejPfqkVK1Y4kgkAqNl27typO/v0U377rgpt2MyRzIIDaQrfukZL589VQkKCI5kAAAAAgMBDoxwAAFQKY84dqFohISGaOWWyro+PUP7G1bLWep0ZHBah8JsH6rHf/0mTpkxxoMrqxfxoVDWXOXc4xRhzzqjqOn98/ZY2ynp+ZTn/0i6zU9dBWZTl/EurocKXtwyjrJy6H1bmdV6Zfy9l5c117G9cxpwzLmbt2rW6a8hwmWtSFFq3gSN15O/eqrhDW7V80ULFxcU5komy4/kdAAAAgJqERjkAAEAN5nK59LfXXtHA669U3n8Xy3o83mfWciuia3+98O9JGjtuvANVAgBqmiVLl2nkI6MUclN/1YqKcSQzf9tatbVZWjR3tiIjIx3JBAAAAAAErmBfFwAAAIDKZYzRs2OeVqOG72rcWxMVfn0fuYJreZfpClL4tSlKXfmh9u3fr1fH/aXS974F/EV6xkHtC95b7u1qZfDyC4FhQmqq/vKPdxR+yyCv/99IkrVW+RtW6ebWjfXquJfkcvGZfwAAAKAyeKyRx/r+/R1/qAGBgXdqAAAAAsT9945UgwZxGv3HPyn8hn4KCg3zKs8Yo/BOt2r1ts81eMRIpb79lmrV8r4hAvi7BvUbqsHOluXeLr3+zkqoBvAvz784VlOWrVFE1/4yDjS0rcejvM8Wa9idt+jp0U86UCEAAAAAACX4GDYAAKgyrGvpe8k9eujd18erYM1MFeUcdyQztG0XbfVEK/mufsrJyTnrtIqsaVud+MP6w5W5BnNlrlte4ZpKGRU5f2/WMffGxXIqWuc551PKqCgn1/quzDXgWY/cORV57PZ4PHr40VGa9vF6hV/b05EmuaeoUDmrZ+mp+4fQJK8CpT1P43kbAAAAgJqMRjkAAECASUpK0rwpqfJ8tlAnj6Y7khnWor0ONWin7im9lZGR4UgmAKB6KCws1KChw/TxoRyFXdnVkQ9BFOfnKvfDmXrl97/RiKFDHagSAAAAAICz0SgHAAAIQImJiVoyb7ZCvlqlgkN7HMkMu6SF8trdoO6979Lu3bsdyQQA+Lfs7Gz16NNXO4LrKaxNZ0cyC09k6eSa2Zr05mvq3u12RzIBAAAAXJy1xm8GUBVolAMAAASo+Ph4LX9vgeru26T8PdscyQyp21BKSlbvu4do44YNjmQCAPxTenq6uqX0VmajyxXavJ0jmQWZh6TPF2nBtMnq1KmTI5kAAAAAAJSGRjkAAEAAi46O1vvz56pV0WHlf7POkUx3dKzcN/bX0J/9UitWrHAkEwDgX3bu3Kk7+vRTfvuuCm3YzJHMggNpCt+6Rkvnz1VCQoIjmQAAAAAAnA+NcgAA4FPGnD1Q9UJCQjRzymRdHx+h/I2rZa31OjM4LELhNw/UY7//k1InTznrNJcx54yaxPxoVDWXOXc4yRhz0VHROita94+v89KGUzV5e306ke3U5S1LPWWuqQz3CyfWrb5Q3VXN13/rTirvY/LatWvVZ8hwua5JUWjdBo7UkL97q+IObdXyRQsVFxfnSCbO78fPv2rYv2IAAAAAKBMa5QAAAJDL5dLfXntFA6+/Unn/XSzr8XifWcutiK799dTv/qinxoxxoEoAgK8tfG+R7khOUciN/VQrKsaRzIJta9XWZmnR3NmKjIx0JBMAAAAAgIuhUQ4AAABJJXuEPjvmaT0+bKBy18yRp7jI68ycr9dJwbX0/oYdevTxJx3ZWx0A4BsTUlP19AvjFJVwmY58ssjrx3RrrfLWf6ibGsdoWupEud1uhyoFAAAAUBEeK3ms8YPh62sCgYJGOQAAAM5y/70jNfY3Typ31QydKsivcE7u7q06svFjNen7kCI63abVaUc0eMRIFRV534AHAFSt518cq5cmTFfkjf0Vf2t/nSrIV9Z/l1c4z3o8yvvPIg29uYteHz9OLhdvTwAAAAAAqhavRAEAAHCO5B499O7r41WwZqaKco6Xe/v8g2lK/+g9Nen3sFyuYElSWNsu+vpUtJLv6qecnBynSwYAVAKPx6OHHx2laR+tV8TVPWVON7Qb3jlcud/tUPaW/5Y/s6hQuatn6an7h+rp0U86XTIAAAAAAGVCoxwAAPgVY8o2UPmSkpI0b0qqPJ8t1Mmj6WXe7uTRdB1YNk1N+vxUwSGhZ50W1ry90uu3U/eU3srIyPjf713GXHRUV6aUUdVc5txRmYwx54yKKK3uil6W0m6HsozKVJk1OXndlVq7A7dveVTl/bc0/vB37JTyPL4WFhbq7qHD9cmBHIVf0fWs29rlcqlxv4d0ZMPHyt29tcznX5yfq9wPZ2r873+jEUOHeHVZUHY8jwIAAACAc9EoBwAAwHklJiZqybzZCvlqlQoO7bno/KKc49r/3rtqdOdwuaNiSp0TdkkL5be5Qd1736Xdu3c7XDEAwAnZ2dnq2aevtrvqKqxN51LnuFzBatL/F0pf857yD6ZdNLPwRJYKP5qjSW++pu7dbne4YgAAAADestb4zQCqAo1yAAAAXFB8fLyWv7dA9fZvUsF335x33qmCfO2b/2/F3dhbYfUbXTAzpG5Dmc7J6n33EG3csMHpkgEAXkhPT1e35N7KbHi5wpq3u+Dc4JBQNbnrpzqwdJoKjpz/6CMFRw5Jny/SgmmT1alTJ6dLBgAAAACg3GiUAwAA4KKio6O1eN5cJRamK/+bdeec7iku0r4Fb6nOFTcpqlnbMmW6o2MVckN/DX3oEa1YscLpkgEAFbBz507d0aefCi7tqtCGzcq0jTsqRo16DNeB995VUfaxc04vOJCm8C1rtHT+XLVo0cLhigEAAAAAqBga5QAAoFpirc2qFxISoplTJuv6+AjlbVwta60kyXo8Orh4oqKatVPMpUnlygwOjVBE10F67Hf/p0mTp1xwLuuWO6sy168uTWnrlju1znWlrsV9nuFEVkVV5drjTt9WFbksVb0muT/8fTqpPI+ba9euVZ97himoS4pC6zYo1/mE1W+kuJv6aN/8t3SqIP9/v8/fvVVxh7Zq+aKFiouLq9BlQPn8+DlSNf53CQAAAACVikY5AAAAyszlculvr72iQddfqbz/Lpb1eHT4g1mqFVVHdZNuq1hmLbcibxqgF/41SWPHjXe4YgBAWSxZukwjfzFKYTcNUK2omAplRDVrozpX3qR989+Sp7hIBdvWqq3N0qK5sxUZGelswQAAAAAcZ62Rxw8Ga5SjqtAoBwAAQLkYY/TsmKf1+LCB+m7KyzqVn6cGXft6l+kKUsS1KZq04lM9+viT/9tbHQBQ+SakpuqJ515QxM0DFRQa7lVWzKVJimzeTmmTxummxjGaljpRbrfboUoBAAAAAHAOjXIAAABUyP33jtTY5/6oqJDgsw6zW1HGGIV3vFWr045o8PCRKioqcqBKAMCFPP/iWL30zjRF3thfrmDvG9rW41FocZ4eHDlCr48fJ5eLtx0AAAAAAP6JV6wAAACosBHDh+ndv76i/I9mqijnmCOZYW276GtPtFL69ldOTo4jmQCAs3k8Hj386ChN+2i9Iq5JlnGgoe0pLlTOmln69QPD9Pz/PedAlQAAAAAAVB4a5QAAoEYw5tyBqpGUlKR5U1N16vP3VHA03ZHMsObtdaheW3VP6a2MjIzzznMZc9aozkwZRlVzmXNHZTLGXHRUVGmXpSyjMlV1TZV5/ZZVVV6/pfHHvzMn/fgx8XyPi4WFhbp76HB9ciBH4Vd0deS2Ly7IVe6qmRr/h99o+NAhXuehdKU93+H5DwAAAJxiJVnrB8PXVwQCBo1yAAAAeC0xMVFL5s1WyJZVKji0x5HMsEtaKL/NDere+y7t3r3bkUwACHTZ2dnq2aevtrvqKqxNZ0cyC7OzVPDRbKW++Zq6d7vdkUwAAAAAACobjXIAAAA4Ij4+XssXLVCdA5uU/902RzJD6jaU6Zys3ncP0cYNGxzJBIBAlZ6erm7JvZXZ8HKFNW/nSGZB5iHZLxZp4fQp6tSpkyOZAAAAAABUBRrlAAAAcEx0dLTenz9XiUWHlb99nSOZ7uhYhdzQX0MfekQrVq50JBMAAs3OnTt1R59+Kri0q0IbNnMkM/9gmsK2rdHS+XPVokULRzIBAAAAAKgqNMoBAADgqJCQEM2cOlnXNYxQ3perZa33K0sFh0YoousgPfbsc5o8ZaoDVQJA4Fi3bp3uGjxcQV1SFFq3gSOZ+Wlb1SB9q5YvWqi4uDhHMgEAAAAAqEo0ygEAQI1lzMUHKofL5dLfXntFA2+4UrmfL5b1eLzPrOVW5E0D9Od/pmrsuPGlzzHmnFGTmFJGVXOZi4/KZIy56HCS05evsq6nqr5efqws94vKvm/8mD/8vVSmsj7eLVm6TCMefkyhN/ZXragYR847f9tatVGW3ps7W5GRkY5k4lw8bwEAAEBV88j4zQCqAo1yAAAAVApjjJ4d87QeHz5QOR/Pkae4yPtMV5Airk3RpBWf6rEnRjuytzoA1FQTUlP1xHMvKOLmgQoKDfc6z1qrvI0f6qamMZqWOlFut9uBKgEAAAAA8A0a5QAAAKhU9987UmN/86RyV8/QqYJ8r/OMMQrveKtW7c7U4OEjVVTkfQMeAGqa518cq5femabIG/vLFex9Q9t6PMr97D0NubmLXh8/Ti4XbycAAAAAAKo3XtkCAACg0iX36KEJb4xX/kczVZRzzJHMsLZd9LUnWil9+ysnJ8eRTACo7jwejx5+dJSmrVmniGuSZRxoaHuKC5WzZpZ+/cAwPT36SQeqBAAAAADA92iUAwCAgMb6n1UnKSlJ86am6tR/F6rgaLojmWHN2+tQvbbqntJbGRkZpc4pbR3fmrSOeWnrMPt6XWZfr1VdlvW6q3oN77Lyx9p9fXuWxh/v906q6ONWYWGh7h46XJ8cyFH4lTc7ct8oLshV7qqZGv+H32j40CFe56FEac8/eD4CAAAAX7PW+M0AqgKNcgAAAFSZxMRELZk/RyFbVqng0B5HMsMuaaG81jeoe++7lJaW5kgmAFQ32dnZ6tGnr7a76iqsTWdHMguzs1Tw0Wylvvmaune73ZFMAAAAAAD8BY1yAAAAVKn4+HgtX7RAdQ5sUv532xzJDK3XUKZzsnoNGqxVH37oSCYAVBfffvutbu+ZoiMNL1dY83aOZBZkHpL9YpEWTJusTp06OZIJAAAAAIA/oVEOAACAKhcdHa33589VYtFh5W9f50imOzpWeSExGnLfA1qxcqUjmQDg73bu3Knku/rru4yjCmnQ2JHM/INpCtu2Rkvnz1VCQoIjmQAAAAAA+Bsa5QAAAPCJkJAQzZw6Wdc1jFDel6tlrfUq7/jmT1SQeVBN+j2mx377nCZPmepQpQDgn9atW6c+9wxTZNd7FB7XVIeWT/f6sTQ/basapG/V8kULFRcX51ClAAAAAKoDjzV+M4CqQKMcAADgR4y5+IAzXC6X/vbaKxp4w5XK/XyxrMdToZycnZuVteVzNU55UK5abkXdMEB//meqxo4bX7Y6jDln1CSmlOFrLlOxUZmMMWUaFb4CzcXPozL543VeVv52/3VSRR9/lixdpuE/f1Rh1w+QOypGcdelSFY68uniCteSv22t2ihL782drcjIyArn4Gw8jwAAAAAA/0SjHAAAAD5ljNGzY57W48MHKuej2fIUF5Vr+/z9O3X4P++rWZ9fyOUqeXprXEGK7JKiScs/1agnRnu9hyUA+JMJqal64v+9oKibBik4NPx/v7+k2xDlH96n45s+LleetVZ5Gz/UTU1ra1rqRLndbqdLBgAAAADA79AoBwAAgF+4/96RGvvb0cpdPUOnCvLLtE1B5gEdWDlTzfr8XK4fNXaMMYq44lat2pmpwcNHqqiofA14APBHz784Vi+9PU1R1/eXK/jchnbjlAeVtXWtcr7dVKY86/Eo97P3NLhrkl4f//L/PnAEAAAAAEBNxytgAAAA+I3kHj004Y3xyv9opopyjl9wbuGJLO1/P1WNe9yn4PCo884La9NF24qjldK3v3JycpwuGQCqhMfj0cOPjtK01esU2SVZ5jwNbZfLpWZ9Htbhz5Yqf9+3F84sLlTOmln69QPDNOap0ZVRNgAAAIBqxFr/GUBVoFEOAAAAv5KUlKR5U1N16vOFKjiaXuqc4vxc7V34luJvGqDQOg0umhnWrL3S67RV9+TeysjIcLpkAKhUhYWFunvocH26P0cRHW6+6Hr2Lrdbzfr8TAc+mK2CzAOlzikuyFXuqpka/4ffaPjQIZVRNgAAAAAAfo1GOQAAQAUYc+6AcxITE7Vk3myFbFmlgkN7zjrNU1SofQvfUr3OtymyccsyZ4Y1bKH81jfojl53KS0t7aLzXcZcdFRnpgzDH7lMxUZNUpOug7LcD/209DJx4nEkOztbPfv01Q7VVVirzmU+7+DwKDXuea/2L05V4YmjZ51WmJ2lgo9mK/XN19S92+3lvlz4QWnPB3h+AAAAAADVA41yAAAA+KX4+HgtX7RAdQ5sUv532yRJ1nNK+xdPUO2WVyimVcdyZ4bWaSjTKVm9Bg7Wxg0bnC4ZAByVnp6ubsm9ldngcoU1a1fu7UNjGyj+5gHau+BtFefnSpIKMg/JfrFIC6ZNVqdOnZwuGQAAAACAaoNGOQAAAPxWdHS03p8/V4lFh5W/fZ0OrZiu0DoNVefKrhXOdEfFKvS6/hr60CNasXKlg9UCgHN27typO/v008m2XRUW36zCOZGNWqr+Vbdp34K3lPfddoVtW6Ol8+cqISHBwWoBAAAAAKh+aJQDAADAr4WEhGjm1MlqVStPRccyVf/aFK8zg0MjFHnDID322+c0ecpUB6oEAOesW7dOdw0eLlfnFIXWaeB1Xu1WHRVap4HM159o+aKFiouLc6BKAAAAADWONbJ+MGRZwwhVg0Y5AACAQ1intPK4XC7NnDJZP39gpHLWLpb1eLzPrOVW1A0D9Od/pmrsuPEVy2Ad82qznrQ/ruvtjzVVVE26r5RVZf39L1m6TCN+/phCr+svd1SMI7Xmb1+rLq0a64tPP1ZkZKQjmYGA/+sAAAAAULPRKAcAAEC1YIzRs2Oe1uMjBir70znyFBd5n+kKUmSXFE1a/qlGPTFa1loHKgWAipmQmqon/t8LirxpoIJDw73Os9Yq98sPdWPT2pqWOlFut9uBKgEAAAAAqBlolAMAAKBauf/ekRr72yeV8/EMnTqZ73WeMUYRV9yqVbsyNXj4SBUVed+AB4Dyev7FsRr39nRFXd9frmDvG9rW41Hu54s0+JYkvf7Ky3K5ePkPAAAAAMCZgn1dAAAAAFBeyT16KK5ePd338KMK7dJHtSJre50Z1rqLtu3ZopS+/TV72hQOT4zzOnT4oPYG7y33drUO8/IL5/J4PHpk1OP6+NtDiujSU8aB43l7iguV8+k8Pf2LBzV86BAHqgQAAAAQCP63Rrgf1AFUBd6pAQAAQLWUlJSkeVNTNWDoSJ3q0E2hdRp4nRnWrL3SD4are3JvzZ81XfXr13egUtQ08XGNFL+3Xbm3OxT3dSVUg+qssLBQQ0fepx2FYYro0NWRzOKCXOV9Ok/j//QHde92uyOZAAAAAADURBx7DQAAoAoZc/GBsktMTNSS+bPl3rZKBel7HMkMa9hC+a1v0B297tLu3bu9znMZU6ZRk5gKDn/kMueOit5c5kc5/qgm3XYVVVV/s9nZ2erZp692qK7CWnV2oHKpMDtLBZ/MVurfX6NJXk78PwYAAACAwEOjHAAAANVafHy8li9aoNiDm5S/d5sjmaF1Gsp0SlbvQUO0ccMGRzIB4Hvp6enqltxbmQ0uV1iz8h+doDQFRw7Js26R5k+frE6dOjmSCQAAAABATUajHAAAANVedHS03l8wVy1PHVbet+scyXRHxSr0uv4a+tAjWrFihSOZALBz507d2aefTrbtqrD4Zo5k5h9KU+j2NVq6YK4SEhIcyQQAAAAQeDzW+M0AqgKNcgAAANQIISEhmjl1sq5tGK7czatlrfU6Mzg0QpE3DNJjv/s/TZoyxYEqAQSytWvXqs89w+TqnKLQOg0cycxP26r6h7do+aKFiouLcyQTAAAAAIBAQKMcAADAz5RlHXPWTi2dy+XSm6+/qoE3XqmctYtlPR7vM2u5FXX9AL3wz0kaO268A1We53wCbB3z0rA+tnO4Lkvny7+zJUuXaeQvRins+gFyR8U4kpm/fa1au7K0aN4cRUZGOpJZE/E/FQAAAABQGhrlAAAAqFGMMXp2zNN6fMRAZX86W57iIu8zXUGK7JKiScs/1agnRjuytzqAwDEhNVVP/L8XFHnjQAWHhnudZ61V7pcf6samtTVt0kS53W4HqgQAAAAAILDQKAcAAECNdP+9IzX2t6OV8/EMnTqZ73WeMUYRV9yqVbsyNXj4SBUVed+AB1DzPf/iWI17e7qiru8vV7D3DW3r8Sjn8/c0+JYkvf7Ky3K5eFkPAAAAwBnW+s8AqgKvqAEAAFBjJffooQlvjFfeJzNVlHPckcyw1l20rThaKX37Kycnx5FMADWPx+PRw4+O0vTV6xXRpaeMAw1tT3Ghsj+epV//ZJjGPDXagSoBAAAAAAhcNMoBAABQoyUlJWne1FQVr12ogqPpjmSGNWuv9Dpt1bHL1crIyHAkE0DNUVhYqK63ddOa3UcU3qGrjAOLYBcX5CpnzUyN/+NvNHzoEAeqBAAAAAAgsNEoBwAAqKaMufhAicTERC2ZP1vubatUkL7HkczsnV+qIChSd/S6S7t373Yk82JcxlRo1HSmEgd1+yd//lvIzs5Wzz59tT/P6Oj2L+U5Vex1ZmF2lvI/ma3Uv7+m7t1ud6DKmqEs/wcD4CEQAAAAAFBBNMoBAAAQEOLj47V80QLFHtyk/L3bvMrK2rhKhccy1fSOexV0RbJ6DxqqjRs2OFQpgOoqPT1d3ZN760j9yxV/U3+FN2yhg8unyFpPhTMLjhySZ90iLZg+WZ06dXKwWgAAAAAAAhuNcgAAAASM6Ohovb9grlqeOqy8b9dVKCN7x3od37lJje+4X5LkjopV+NX9NPSnj2jFihVOlgugGtm5c6fu7NNPJ1t1VViDZpKkuKQ7FVQrVBkfL6hQZv6hNIV+s0ZLF8xVQkKCk+UCAAAAwDmslaw1fjB8fU0gUNAoBwAAQEAJCQnRzKmTdd0lEcrdvFq2HK++cvdt1+F1H6h5ysNyuX54Kh0cGqHo6wZp1LP/p0mTp1RG2QD82Nq1a9XnnmEK6pii0DoNzjqt4c2DVHjsiLI2fFiuzPy0rYrL2KrlixcqLi7OyXIBAAAAAIBolAMAACAAuVwu/e21VzTwxiuVs3axrOfih0XOz9ing6vnqkWvn8sVHHxuZi23oq8doBf/MUljx42vjLIB+KElS5dp5MOjFH7NALkjY0qd0+jO+3R852Zlby/bkSzyt69Va1eW3ps7W5GRkQ5WCwAAAAAAvkejHAAAoAYz5uIjUBlj9OyYp/X4iIHK/nS2PMVF55178vgR7V82Wc16PKDg0IjzZ7qCFJWUosnLPtWoJ0aXa2/1yuQypkIDkillOJWH6n/fnDAxVU/88QVFXT9QwaHh553ncrnUrNfDOrzuQ+Xu3X7eedZa5X75oW5sWlvTJk2U2+2ujLL9Tln+V/H/CwAAAADgNBrlAAAACGj33ztSY387Wjkfz9Cpk/nnnF6cl629i99Wo5vvVkjtehfNM8Yo8vJbterbTA0ePlJFRedvwAOovp5/cazGvTNd0df2lyv44g1tV3Cwmvf+uQ6unqv8w/vOOd16PMr573safEuSXn/l5bOWdwAAAACAqmDl67XJTw8+Xo4qwitvAAAABLzkHj004Y3xyvtkpopyjv3v96cKT+q7RW8pLqmHIuKblyszolUXfVMYrZS7+isnJ8fZggH4jMfj0cOPjtL0VesV2bmnTDka2sGhEWra8yfav2yyTh7L/CGzuFDZH8/SUw8O1ZinRldG2QAAAAAA4EdolAMAAACSkpKSNG9qqorXLlTB0XR5ThVr3+K3Fdumi2JaXFahzPCm7XU4tq26J/dWRkaGwxUDqGqFhYW6e+hwfbo3RxGXdZWpwPG/Q2rX1SW3Dtbexe+oOC9bxQW5ylkzU+P/+BuNGDq0EqoGAAAAAAClCfZ1AQAAAPCtiq7z6ifLbzsqMTFRS+bPUZ+B92hf5jFFxDdX3fbXeZUZHt9CBe5Q3dHrLs2ZNlnNmzd3ptgq4ORa0J6aeIcJYP60TnhVyc7OVt9B9+hIdEuFJ7bzKiuiQVPFdemh7xb+W/Xq1lHqP/+mTp06OVSpfwnAuwoAAAAAoJpgj3IAAADgDPHx8VqyYK7io0IUGd/CkczQOg0VdEWyeg0crI0bNjiSCaDqpKenq3tybx2pf7nCmnrXJP9eSHQ91YkK17t/f6PGNskBAAAAVC/WjwZQFWiUAwAAAD8SGxurTz9aowQdVt7OdY5kuqNiFX51fw396SNasXKlI5kAKt/OnTt1Z59+Otmqq8IaNHMkM/9QmkK+XaPVK5bpqquuciQTAAAAAACUD41yAAAAoBQhISGaOXWyrmkcoZwtq2UdOHR4cGiEoq8bpFG/fU6Tp0x1oEoAlWndunXqc88wBXVMUWidBo5k5u3ZqvpHtmr54oWKi4tzJBMAAAAAAJQfjXIAAADgPFwul/722isaeNOVyl6/WNbj8T6zllvR1w7QC39P1dhx4x2oEkBlWLJ0mUb8/FGFXzNA7sgYRzLzdqxV6+AsvTdvtiIjIx3JBAAAAAAAFRPs6wIAAABQPRlTse0c2DG7Shlj9NsxT+uShu9q3D/fVXSXu+QKruVdpitIUUkpmrz0Qx04cEDjXxorU9ErtJpwVeHl81S3O5kDqvL6DQQTJqbqL39/R1HXD5Ir2O11nrVWeV+t0k1tG+vVl1+Sy1X9PrPOXQwAAACo+aw1stb3T/79oQYEhur36hwAAADwgfvvHamxz47WiU9nqPhkvtd5xhhFdrhVq3ZkavDwkSoqKnKgSgDeev7FsRr3znRFX9vfmSa5x6Octe/pnluT9PorL1fLJjkAAAAAADURr9ABAACAMkru0UMT/jpeuZ/NVFHucUcyI1p30TeF0Uq5q79ycnIcyQRQfh6PR794bJSmr1qvyM49ZRxoaHuKC3XiP7P01IPDNOap0Q5UCQAAAAAAnEKjHAAAACiHpKQkzZuaqqL1C1WQle5IZnjT9joc21bdk3srIyPDkUwAZVdYWKi7hw7XJ9/lKOKyro4shVBckKvsT2Zq/B9/o+FDhzhQJQAAAAAAcBKNcgAAAKCcEhMT9f782Qrevkr5h/c4khke30InW96gO3rdpbS0NEcyAVxcdna2evbpq289dRWe2NmRzMLsLOV/Nlupf39N3bvd7kgmAAAAAABwFo1yAAAAVCljKjb8TXx8vJYvWqDY9E3K27vNkczQOg0VdEWyeg0YrI0bNjiSGYhcxlTq8MfaUDHp6enqntxbR+pdprCm7RzJLDhySKc2LtL86ZPVqVMnRzKdVFMegwEAAABUAutHA6gCNMoBAACACoqOjtbiBXOVoMPK27nOkUx3VKzCr+mvoT99RCtWrnQkE8C5du7cqTt699XJVjcpLL65I5n5h9IU8u0aLV0wVwkJCY5kAgAAAACAykGjHAAAAPBCSEiIZk6drKsbhStny2pZ6/3HnoNDIxR93SA99tvnNHnKVAeqBHCmdevWqc89wxTcqZdC68Q7kpm3Z6vqZW7R8sULFRcX50gmAAAAAACoPDTKAQAAAC+5XC69+fqrGnjTlcpev1jW4/E+s5Zbta8doBf+nqq/vDzegSoBSNLSZcs14uePKfyaAXJHxjiSmbdjrVoHZ2nR/DmKjIx0JBMAAAAAAFQuGuUAAACoFiq6rm5VrbVrjNFvxzytX40cqBP/nSNPcZH3ma4gRSWlaNKST/XY4086src6EMgmvDtRj//hz4q6fqCCQ8O9zrPWKnfzh7qxeW1NmzRRbrfbgSqdfbxjrXEAAAAAZWaNrB8MWV68oGrQKAcAAAAcdP+9I/Xib5/UiU9nqPhkvtd5xhhFXHazps2eq959+6moyPsGPBCInnv+z/rVk08qonNPuYK9b2hbj0c5axfpnluT9PorL8vl4uU1AAAAAADVCa/kAQAAAIcl9+ihCX8dr7zPZqoo97hXWdZaHfp4tiLjE7Q/qJFS7uqvnJwchyoFaj6Px6NfPDpKs1d/qYZJKdr7/jteH/HBU1yoE/+ZpaceHKoxT412qFIAAAAAAFCVaJQDAAAAlSApKUlzp6aqaP1CFWSlVzjn6IYVOpWfq4bX9lN4k/bKiGqr7sm9lZGR4WC1QM1UWFiou4cO16dp2Yq8tKvqtElSdJN22r88VdbjqVBmcUGusj+ZqfF/eEbDhw5xuGIAAAAAAFBVaJQDAAAAlSQxMVHvz5+tWttXKf/wnnJvf/ybz5W9d7sa3TLif78Lj2+hwmbX646Uu5SWluZgtUDNkp2drZ69+2pncV1FtLzqf7+vf+VtckfGKv2j2bLWliuzMDtL+Z/NVurfX1P37t2cLhkAAAAAfMpa/xlAVaBRDgAAgIBjTNWN+Ph4LVu0QLHpm5S375sy15jz3VZlbPpIzXo8dM7ax6F1LlHw5cnqNWCwNm7Y4PTVA1R76enp6p7cW0frXKbwxu3OOb3htX11qiBPR9cvL3NmwdFDOrVxkeZPn6xOnTpV6uMGAAAAAACofDTKAQAAgEoWHR2txQvmKsGmK2/nuovOz0/fo4OfvqcWyb+QyxVc6hx3ZKwiruqvoQ8+ohUrVzpdMlBt7dy5U3f06qvChJsU3qD5eec1umW4svfu0Iltn180M/9QmkJ2rNHSBXOVkJDgYLUAAAAAAMBXaJQDAAAAVSAkJEQzp07WNY3ClbNl9XkP+VyQdVh7P5yq5nf+VMHu0AtmBodGqPY1gzTqN89p8pSplVE2UK2sW7dOd909TO4reiksNv6Cc10ul5r3fEiZmz9Wzp6t552Xv3er6h3ZouWLFyouLs7pkgEAAAAAgI/QKAcAAACqiMvl0t9ef1UDbrxC2esXy3o8Z51elHtc3y2doCY3D5c7MqZsmcFu1e4yQC+8maq/vDy+EqoGqoely5Zr5M8eU0SXAWX/+3EFq3nywzr06ULlp6edc3rejrVq5crSonlzFBkZ6WzBAAAAAOBnrDV+M4CqQKMcAAAAqELGGD37zBiNGjFAJ/47R57iIknSqZP5Slv8luKv7q3weo3Kl+kKUnSnFE16/1ONemL0efdWB2qqCRNT9cTv/6zoawYqOCS8XNsGu0PVvMdD2vfBNBVkpUuSrLXK3fyhbmxeW9MmTZTb7a6MsgEAAAAAgA/RKAcAAAAqkTGlj5/cf6/G/vZJZX86Q0V52drz/luqd+kNqt2kbQXPxyiq/a1avT1TQ4aPVHFx0XnP28kBSJV/P7vQeP7FsXr5remq3aW/XMEVa2i7I2PU5Nbh2rv0XRVmZyln7SINvi1Jb7z6soKCXNz3AQAAAACogYJ9XQAAAAAQqJJ79lD9enXVs/ddim5xpeq06eJ1ZkTLLvpm7xYl9+mvOTOmcLho1Fgej0e/HPW4Pt52SFEde8p42b0Or9tI8Vf11M7Zr+i18eM1YvhQhyoFAAAAAAD+iEY5AAAA4ENdunTRp2tWadCw+1RwLF2hMQ28zgxv0l4Z6eHq1rO3Fsyervr16ztQKb53KOOgvrN7y72dO4OXX04pLCzUkBH36du8MEVe2tWRzOKTebL7vtTUSanqcecdjmQCAAAAAAD/xTs1AAAAgI+1bt1aSxbMVp8B9yi/6TUKq9/M68zwBi1U4A5V95S7NHf6ZDVv3tz7QiFJir+kieLNbeXe7pBdWQnVBJ7s7GzdNeAeHY1qqYiEdo5kFuZkKX/jQqX+86/q1KmTI5kAAAAAUO1YUzJ8zR9qQEBgjXIAAADAD8THx2v54gWKydykvP3fOJIZGttQwZclK6X/YG3YsMGRzB/z5drUvhxcV75Zrzs9PV3devbW0TqXKbyxM03y/KxDKt68SAtmTKZJDgAAAABAAKFRDgAAAPiJ6Ohovb9wrhJc6crdvc6RTHdkrCKu6q+hP3lEK1ayRzOqr507d+qOlL4qTLhJ4Q2aO5KZl54m9641WrpwrhISEhzJBAAAAAAA1QONcgAAAMCPhISEaOa0ybqmSbhyvl4ta63XmcGhEap9zSA99sxzmjRlqgNVAlVr3bp16jNomGpd0UthsfGOZObv26q6WVu04v2FiouLcyQTAAAAAABUHzTKAQAAAD/jcrn05huvasDNVyp742JZj8f7zGC3ancZoBf+lqqxL413oEqgaixZukzDH3pUEV0GyB0Z40hm3s61SqyVpcUL5igyMtKRTAAAAACo7qz1nwFUBRrlAAAAgB8yxujZZ57Wr+4bqBNr58hTXOR9pitI0Z1SNGnJp3rs8dGO7K0OVKYJE1P1xO9fUO1rBik4JNzrPGutcrZ8qOsTamva5Ilyu90OVAkAAAAAAKojGuUAAACAH7v/vpF68dkndeK/M1R8Mt/rPGOMotrfqtXbMzV42EgVFXnfgAcqw59eGKtx/56u2l36yxXsfUPbejzK3rBI99yepDdefVkuFy+HAQAAAAAIZLwzAAAAAPi55J49NOHN8cr9YqaKco87khnRsou+yY9Wcp/+ysnJcSQTcILH49EvHh2lGR+sV1THnjIONLQ9xYU6/vksPfXToRrz69EOVAkAAAAAAKo7GuUAAABANZCUlKR501NVuGmhCo6lO5IZ3qS9MqPbqnvP3srIyHAkE/BGYWGhBg0Zrk/SchR5aVcZY7zOLC7I1YnPZmr8c7/R8GFDHKgSAAAAAGoo60cDqAI0ygEAAIBqIjExUUsWzFbwzlXKz9jjSGZYgxY62fwGdU+5S2lpaY5kAhWRnZ2tHr36amdxXUUkdHYkszAnS7lfzFbqP15T9263O5IJAAAAAABqBhrlAAAAQDUSHx+v5YsXKCZzk/L2f+NIZmhsQwVflqxeA4Zow4YNjmQC5ZGenq5uPXsrq+7lCm/czpHM/KxDKt68SAtmTlanzp0cyQQAAAAAADUHjXIAAACgmomOjtb7C+cqwZWu3N3rHMl0R8YqvHM/Df3JI1qxcqUjmUBZ7Ny5U3f06qeihK4Ki2vmSGZeeprcu9Zo6cK5SkhIcCQTAAAAAADULDTKAQAAgGooJCREM6dN1rVNI5Tz9WpZ6/0CXsGhEap9zSA9OuY5/enPLzhQJXBh8+fPV0r/warVIUWhsQ0cyczft1X1jm3VivcXKi4uzpFMAAAAAAgE1hq/GUBVoFEOAAAAVFMul0t/e/0VDbj5SmVvXCzr8XidaVxBOn78hP4xYZrGvjTegSqB0i1Zskyjf/ucMo8ckSu4liOZeTvXKrFWlhbNn63IyEhHMgEAAAAAQM1EoxwAAACoxowxevaZp/Wr+wbqxNo58hQXVTjLWqsDH89QWEwDNb3tQU1e/Kkee3y0I3urA2eaMDFVT/7+BdW/frgaXH6r0pb+W56iwgrnWWuVs+VD3dAyRtMmT5Tb7XawWgAAAAAAUBPRKAcAAABqgPvvG6kXn31SJ/47Q8Un8yuUkbnufenUKTW8qpeMMYpud4vWfJ2pwcNGqqio4g34GofPDXjl+RfGaty/pimmcz+5gmspNqGjYptfqe9WTJD1nCp3nvV4lL1hkQZ366LXXxknl4uXuQAAAAAA4OJ4BwEAAACoIZJ79tCEN8cr94uZKso9Xq5tj237RLkZ36nJjUPP+n1kQpK250QppU9/5eTkOFkuAozH49EvHh2lGSvWqXaHnjJnNLTrt79JYbHxOrBmermOYOApLtTxz2fpqZ8O1dNPPVkZZQMAAAAAgBqKRjkAAABQgyQlJWne9FQVblqogmPpZdome89mHdn2uZrf9mCpp0c0bq/MiDbq3rO3MjIynCwXAaKwsFB3Dxmu/+zMVlTbrjLGnDOn4VW9JI9VxrrFZcosLsjVic9mavxzv9HwYUOcLhkAAAAAApP1gwFUERrlAAAAQA2TmJioJQtmK3jnKuVn7Lng3LxDu3Twi/fV8s6HL3jI6vC4FipqfL26J9+ltLQ0hytGTZadna0evfpq58k6imjR+YJzm9w0RHmH9ypr6ycXnFeYk6W8tXOU+o/X1L3b7U6WCwAAAAAAAgSNcgAAAKAGio+P1/LFCxR7ZLPy9m8rdU7B0YPa+9EMJXR/SK5g90UzQ2Mbyt2up1L6DdaGDRucLhk1UHp6urr16K1jtdsrolG7Mm3T/PYHdXT758pO21zq6flHD6l48yItmDlZnTp3crJcAAAAAAAQQGiUAwAAADVUdHS03l84VwlBGcrdve6s0wpzsrTng4lqfvO9codHlznTHRmrqI79NOwnj2jFypVOl3xRxlqfjwqzvq2/qu3cuVN3pPRVcbMbFR7XvMzbuVwutbzzYR1c+77yDu4867S89DSFpH2kpQvnqkWLFg5XDAAAAAAAAgmNcgAAAKAGc7vdmjl1kq5tGqGcr1fLWqviglylLXtLja/pr7DYBuXODA6NUMxVA/XYmOc0ecrUSqga1d26devUZ9AwhVyWorDY+HJv7wp2K6H7z7T3o5kqOHJAkpS3d6vqHduq5YsXKC4uzumSAQAAACDgWWv8ZgBVgUY5AAAAUMO5XC797fVXNPCWjjq+4T3tWfaWGlx2i6LiW1Y8M9it2M799cJfJ+ov48Y7WC2qu6VLl2vEQ48pqlN/uSNiKpzjDo9S81vu1Z4PUpW1+UO1DjmmRfNnKzIy0rliAQAAAABAwKJRDgAAAAQAY4x+O+bXGtTtOoXUClbtppd7n+kKUu0rUjRp0ad67PHRsj44vDf8y4SJqXrid39WzFUDFRwS7nVeaEycYi9JUOvaVlMnvSu32+1AlQAAAAAAADTKAQAAgIDy+9/9Vm+++hcdWzdTxSfzvc4zxii63S1a83WmBg8bqaKiIgeqRHX0/AtjNe5f0xTTuZ9cwbW8zrMej45vWqwHBvbUvDkz5XLx8hUAAAAAADiHdxoAAACAANOzx52a8OZ4ZW+YpcK8445kRiYkaXtOlFL69FdudraMtZUyUHGVdZvYU6f0yC9HacaKdardoaeMAw1tT3GRjq2brV8/NFRPP/WkA5ceAAAAAHBR1o8GUAVolAMAAAABKCkpSfOmp+rkV++p4Fi6I5kRjdsrM6KNuiX3UUZGhiOZ8G+FhYUaNGSEPtmVrai2XWWM8Tqz+GSejn0xQy//3280bNgQB6oEAAAAAAA4F41yAAAAIEAlJiZqycLZCtqzWvmZexzJDI9rocLG16t7Sl+lpaU5kgn/lJ2drR69+2lnYR1FtujsSGZhTpZy1s/RpH+9oe7dbnckEwAAAAAAoDQ0ygEAAIAAFh8fr2WLF6j2sa+Ue+AbRzLDYhuqVrueShkwRBs3bnQkE/4lPT1dt/fso6za7RXRqJ0jmflZh1S4dbEWzJqsjp06OpIJAAAAAABwPjTKAQAAgAB05hrTtaOitGTBHLWolaHctPWO5LsjYxV5ZT8N+ckjWrHyA0cy4R927dqlO3r1V3GzGxUe19yRzLzDaXJ/95GWLZyjhObNWZseAAAAAHzC+NEAKh+NcgAAAAByu92aNTVVVzcPV/Y3a2QdaE4Gh0Yo5qqBevSZ5zR5yjQHqoSvrVu3Xr0GDpP7smSFxcY7kpm7/2vVyd6q5YsXKC4uzpFMAAAAAACAi6FRDgAAAECS5HK59Obrr2jgrVfqxOb3ZT0e7zOD3Yrt3F/P/+1djX35Fe+LhM8sWbpcwx96VFGd+8sdEeNIZu7utWoVekyL581WZGSkI5kAAAAAAABlQaMcAAAAwP8YY/TbMb/WqPsH6Nj6ufIUF3mf6QpSzBW9NGnRJ3r08dGO7K2OqjVhYqoe//0LikkapOCQcK/zrLXK/nqVrm8Vo2mTJsjtdjtQJQAAAAAAQNnRKAcAAABwjgfuHamxv39Cx9bOVPHJfK/zjDGKbner1mzL1D3D71VRkfcNeFSN5198SS/9a7piO/eTK7iW13nW49HxTYt1T/cuemP8OLlcvCwFAAAAAABVj3ckAAAAgGrMWFuhURbJPXro3TfHK3vDLBXmHXek3siELtqeE6XkuwYoNzfXkUxUDo/Ho188+itNX7FWta/oKeNAQ9tTXKRj62brqZ8O0ZinnijzdpV1HwcAAAAAnMH60QCqAI1yAAAAAOeVlHSV5k+bqJNfvaeCY+mOZEY0bq/MiDa6vWdvZWRkOJIJZxUWFmrQkBH6ZFe2otp2lTHG68zik3k6vnamxj/3jEYMG+JAlQAAAAAAABVHoxwAAADABSUmJmrpglkK2rNa+Zl7HMkMj2uhwsbXq3tKX6WlpTmSCWdkZ2erR+/+2llYR5EtOjuSWZiTpZz1czTxH6+qe7fbHckEAAAAAADwBo1yAAAAABcVHx+v5Yvmq3bWZuUe+MaRzLDYhnIl3qak627Uxo0bHcmEd9LT03XFVVfrUFC8Ihq1cyQzP+uQCrcu1sKZk9S5UydHMgEAAAAAALxFoxwAAADwA5W51rhToqOjtWThXLWolaHctPVe53lOFevA5/MUm3C1hv7kl1qx8gMHqiwH66nYqOrzrCK7du1S95R+Cm12ndK//EBF+dleZ+YdTpP7u4+0bOEctWjRwoEqy646/E0BAAAAgF/x9brkrFGOKkajHAAAAECZud1uzZqaqqubhyv7mzWyFWwsWuvRvo+nKrJ+M8Vfdptirhygx8Y8p8lTpjlcMcpi3br16jVgmMLapqheQmc1vOJO7V7xlk4VnaxwZu7+r1Une6uWL16guLg4B6sFAAAAAADwHo1yAAAAAOXicrn05uuvaMAtV+jE5vdlPeXf6/nQ2oVyBbnVsEMPSVJQsFt1ruyvF/46UWPHveJwxbiQJUuXa/hPH1XtK/rLHREjSYptcpnqJXRR2sp35DlVXO7M3N1rlRiapcXzZisyMtLhigEAAAAAALxHoxwAAABAuRlj9OwzT2vU/QN0bP1ceYqLyrztka2rdfJ4hppec/fZma4gxVyWosmLPtWjj4+u8N7qKLsJE1P1xO9eUJ2OgxQcEn7WafVaX6eo+s2196MpsmU8BLy1Vtlfr9L1rWI0fdK7crvdlVE2AAAAAACA12iUAwAAAKiwB+4dqbG/f0LH183SqcL8i84/kbZBWbs3qflN95d6ujFGtVvfoo++PqJ7ht2roqKyN+BRPs+/+JLG/WO66lzRT67gWqXOie9wp4KDQ3Xoi4UXzbMej45vWqx7unfRG+PHyeXi5SYAAAAAVCtWkjV+MHx9RSBQ8M4FAAAA4CBjbYVGdZbco4cm/O1lZa+frcK84+edl3Nwhw5+uVKJtz100SZqVLMkfZsdpeQ+A5Sbm/vDCdbj3KgunLzM1iPPqWL94pe/0oxlaxVzWU+Zi9wWTa4epJPHM3Vky6rzzvEUF+nYujl66qdDNOapJxy+AqpWIP4NAwAAAAAQiGiUAwAAAPBaUtJVmjftXZ386j0VHEs/5/T8I/u077O5anXbw3IFl+1w3BGXtNfRsDbq1rOPMjIynC45IBUWFmrQ0JH6z7fZim7VVcaYMm3X/Kb7lJW2Wcd3rz/ntOKTeTq+dqbGPzdGI4YNcbpkAAAAAACAShHs6wIAAAAA1AyJiYlaumCWeg8YrPzGVyusXjNJ0skTR5S2erJa3vyAgkPDL5JytvD6LZRfK1Tdk/tq7oxJat6saWWUXi4H0/drz8l3y72dO6RsTenKkp2drb6DhiorJEGRzdqVa1uXy6XEW3+ub5a+qqDQKEU2bCVJKszJUt7m9zTxn2+oc6dOlVE2AAAAAABApaBRDgAAAMAx8fHxWrF4vvoMHKxjhQVyx16i3R+8o6bX3q3Q6HoVygyLaaiTrXuqV/8hSn3rr7ryiiscrrp8GjRuopiGd5V7u2MH5zleS1mlp6erz4AhKm7QRRH1m1cowxUcrFa3/Vzbl7+hpl2HyLiCdWrHSi2YMUkJCQnOFgwAAAAAqHLWlgxf84caEBg49DoAAAAAR0VHR2vJgjlqHpyubxf/VQ073KmoCjZnvxcSGauoDv015IFfasXKD5wpNEDs2rVLd/QeoFONb1K4l7dDcGi4Errerz2rJsvs+lDLFs6hSQ4AAAAAAKolGuUAAABAKYy1FRooERISollTJ6nnnd0UVHhU1oHrJjgkXLEdB+qxZ/6kyVOnOVBlzbdu3Xr1HjRCoW1SFBYT70jmqdwMXX5pWy2eN0txcXGOZNYEPGYAAAAAAFC90CgHAAAAUCmCgoI08e1/qf+tV+jY1iWyHo/3mcFu1bmyv1746ySNHfeqA1XWXEuWLdfwh0YpukN/uSNiHMnM+W6dEsKztGzxAprkAAAAAACgWqNRDgAAAKDSGGP07DNPa9QD/ZX15Vx5ThV5n+kKUsxlKZq86FM9+sSvHdlbvaaZMHGSnvjdWNXpOEjBIeFe51lrdWLHal3furamT35XbrfbgSoBAAAAAAB8h0Y5AAAAgEr3wL0j9eIfnlDWhlkqLsz3Os8Yo9ptbtVHWzN1z/D7VFTkfQO+pvjTCy9p3D+nq84V/eQKruV1nvV4dGzLYt19R5Jef2WcXC5eRgIAAABAjWT9aKBGMMbUM8ZcYYy53RhztzGmtzHmWmNMojHG528wBPu6AAAAAKCqsS5wJbOlH2I9+c47FFe3ru77+a8U2b6X3OG1vT6rqOZd9O2BLUq+a6DmTJ+kyMhIrzPPZM5zWZzIsw6/HvR4PPrlqNH6ZOtBxVyWLGOM95nFRcraPF+/fuR+jRg2+Ly3rXz/2rbaqujjkXXg9gUAAAAAwEnGmChJfSTdLOlGSYkXmJ5rjPlM0keSFllr11d+hWfj3QwAAAAAVSYp6SrNm/aOCr5eqPzj6Y5kRlzSXkfD2qpb8l3KyMhwJLO6KSws1KChI/Wfb7MV3aqrI03y4pN5yto4U+Of+3VJkxwAAAAAAKAUxpjOxpiJkg5JelfSfZJaSTIXGJGSbpP0B0lfGGO2GmN+YYyJqKq62aMcAAAAQJVKTEzUkgWz1HvAYOU1vEbh9Zp5nRlev4Xya4Wqe0p/zZ0+Uc2bN/e+0GoiOztbdw0comOhLRXZrJ0jmSdzs5S79T1N/Ofr6typoyOZAAAAAACgZjHGdJb0f5K6f/+r018PSvpC0jpJhyUdlZQlKUxSHUmxklpLSpLUQVItSW0lvSbpD8aYv0h61Vp7sjLrp1EOAAAAoMrFxzfQisXzdNfAITpeVKCIhm28zgyLaaiTrXuq14BhSn3rr7ryiiscqNS/paenq8+AISpu0EUR9Zs7kpl/7JCKdq3UghkTlZCQ4EgmAAAAAKAasKZk+Jo/1ICLMsa8I2m4fjiC+XpJkyXNttZ+V44ct6SbJA2R1FdSXUl/lvRzY8xwa+3HjhZ+Bg69DgAAAMAnoqOj9f6C2WoWkq6cvc4sQxUSGauoDv019IFfasXKDxzJ9Fe7du3SHb0H6FTjmxTuUJM8LyNNQfvXaNnCWTTJAQAAAADAhYyUVCzpX5LaWmuvstaOL0+TXJKstYXW2hXW2vslxUsaIekbSc0k3ep00WeiUQ4AAIBqy1hboQEHWc+5oxxCQkI0a2qqujQP04lv18g6cPsEh4QrpuNAPfbMnzR56rTzzjPWc9FRmcpy/uerYd269eo9aIRC26QoLCbekXpyD36tmLytWrF4vuLi4sq3sZf3A5Qfj3cAAAAAAB97U1KitfYha+12JwKttSettZMktZd0j6QdTuSeD41yAAAAAD7lcrn05uvj1f/WK3Rs6xJZj/dN1qBgt+pc2V8v/HWSxo571YEq/ceSZcs14me/UnSH/nJHxDiSmfPdOiWEZ2nxvJmKjIx0JBMAAAAAANRc1tpfWGv3VVK2tdbOsNZOrYz879EoBwAAAOBzxhg9O+Ypjbq/n7K+nCvPqSLvM11BirksRZMXfapHn/i1I3ur+9qEiZP0xO/GKvbKgQoOCfc6z1qrEztW6/rW0Zo+6R253W4HqgQAAAAAVEdGkrF+MHx9RSBg0CgHAAAA4DceuHeEXvz948raMEvFhfle5xljVLvNrfpoa6YGD79fRUXeN+B95U8vvqRx/5qhOlf0kyu4ltd51uPRsS2LdfcdnfX6+JfkcvHyEAAAAAAAlJ0x5jVjzFW+rqOieCcEAAAAgF9J7nGnJvztJZ34crYK8447khnVvIt2ZEfpjl59lZmZ6UhmVTl16pTuf/BhzVy+XjHte8o40ND2FBfp6JdzNPqhwRoz+gkHqgQAAAAAAAHoEUn/NcZsNcY8bYxp4uuCyoNGOQAAAHzOWFuhAR+wnrNHJUlKukrzpr2jgq8XKv94uiOZIfUStHnLN7ojpa8yDx92JLOyFRYWatDgEZq38D3VimsnY7w/AF3xyTxlbZypl5/7tUYMG+xAlefx4/tKJd5fcH48tgIAAAAAKpmR1EbSnyTtNsasNMaMMMZE+Liui6JRDgAAAMAvJSYmasmCWXLtXa28zD1eZXlOFWvXqrfVoPVNCm56q7r16q/daWnOFFpJsrOz1aPPIO3Jr6+WN9yr3WsmeL2H/cncLGVvmq2J/3hFd3S73aFKAQAAAAA1gvWjgeridkkTJOWopGHuknSzpHckHTLGTDTGdDNOfPK/EtAoBwAAAOC34uMbaPmiuYrO3qzcg99UKMNaj/Z8nKraDdqoXkKSwmo3VGjLnuo1YIQ2bNzobMEOSU8/rNuT++l4+KWKjG+riNhL1PiK3tr14VsVXrs9/9ghnfxmsRbMTFXnTh0drhgAAAAAAAQaa+0H1tr7JTWQNETS+5JOqaRpHiFpqKQlkvYaY140xlzms2JLQaMcAAAAgF+Ljo7WkgWz1SzksHK+W1+uba212v/FHLnDaqth+9v+9/uQiFjVbt9PQx8cpRUrP3S6ZK/s3LVL3XsPlG14kyLqNv/f72MuaaP6rW7QrlVvy3OquFyZeRlpCt7/kZYtnKUWLVo4XDEAAAAAAAhk1toCa+00a22ypMaSHpe0XiUNcyPpEklPSvrSGLPeGPOYMSbOdxWXoFEOAAAAx7DWeDVW2nrSfrTGtNvt1qypE9WlRahOfLtGtoz3m8ytK1VckKMmnfqec1pwSLjqXj5Qjz3zvCZNne50yRWydt169bn7XoW3SlFY7QbnnF4/IUm149toz8epsp6y3R65B79WbN4WLV88T3FxPn4N6sf3MfyAx3IAAAAAQEVZaw9ba1+x1l4lqb2kFyXt1Q9N8yskvSxpnzHmPWPMIGNMiC9qpVEOAAAAoFpwuVz6+2sva8AtHXRsy/sXbRQf2/WFju3/Rs2vGX7+zOBaqnt5P73418ka+/JrTpdcLkuWrdCInz2h2u37yR1e+7zzGl56m9xhMdq/ds5FPzCQvWetWoYf1eK5MxQZGel0yQAAAAAAAOdlrf3aWjvGWttM0q0qWbs8WyUN82BJPSRNVcl65v8wxtxQlfXRKAcAAABQbRhj9OyY0frV/f2U9eUceU4VlTov+8A2Hfr6I7W6+adyuS78sse4ghTbLlmT3/uPHn3i6TLvre6kdyZO1hPPjlXdDgMU7A6/6Pwmne7SqYJcZWxZWerp1lqd2P6hbmgdrempb8vtdjtdMgAAAACgprHGfwZqHGvtKmvtA5Lide565rUlPShpVVXWRKMcAAAAQLXzwL3DNfZ3v1LWhpkqLsw/67S8zD3au26BWt/yc7lcwWXKM8YoJvEWfbz1iAaP+ImKikpvwFeGP704Ti//a4bqXt5PrqBaZd6u2TXDdOLgN8ra9flZv7cej45tWaR77kjSG+P/ctEPCgAAAAAAAFSVH61n3lHSFknf77VQpZ+S4B0TAAAAANVSco87NeGvf9HxL2epMO+4JKngRIbSPp2mVjf9RMHu0HJnRjVJ0o7jUerZ927l5OQ4XfJZPB6PHn7sSc1cvkGxbXvKlLOh7XK5lNj1p0r/+mNlH/i6JLO4SEc3ztZTD92jMaN/VRllAwAAAAAAVJgxJsQYM9AYs0DSekmX+qqWsu1eAQAAgIBmfHAoalQye+H1vX3BVKCmLklXacHUt9V/6AMqaHSN9n0xVy2uHaqQiNgK1xEZf6myMsN1e3I/LZw5SfXr1zt7QkX/HKz+d70XFhZqyL0PadexUNVOuKnCtbpcwWp9y8+1beXraiyjogPrNP5Pz+qObredM7cs1681fvBZ6tLq9Ie6cFEV/V9hDYdVBAAAAICazhhzk6ThkgZIiv7+16e/HpM0U9K7VVkTjXIAAAAA1VpiYqKWLpiha266XfWaX6WI2EZeZ0bUa678WiHq1nug5k59Ry2aN/e+0NOys7N1190jdKxWS0U1aet1XrA7VM2SBmnv51O1ZMFsde7U0YEqAQAAAAABx6riHw53kj/UAEcYY9qopDk+VFLT7399+muxpGUqaY4vsNaerOr6+Fg+AAAAgGovvkEDbfriEzWKyFFO+jZHMsNqN1Roy2T1HnSvNmz80pHM9MOHdXvKAB0Pb6/IeO+b5JKUd/yQPPs/1n8/WkmTHAAAAAAA+JQxpp4x5pfGmM8lbZU0RlIzlTTIjaQvJT0uqbG1NsVaO9MXTXKJRjkAAACAGiI6OlpLFsxSs7AMZe9b70hmSESMoi/tp6E//ZVWfPChV1knTxaoe++7ZRvepIi6zR2pLzczTUGHPtayhbOU0KKFI5kAAAAAAADlcXrd8UHGmIWS9kt6RVJn/dAcPyhpnKQO1tqO1tpXrLWHfVbwaTTKAQAAANQYbrdbs6a8q6SWYTq2c41sBddMPlNwSLjqXj5Qjz3zgiZNnVGhjBPH9+nA4cMKa5WssNoNvK5JknIOfa2Ygq1asWiO4uLqO5IJAAAAAABQVsaYrsaYf0tKlzRVUk9JtVTSHC+QNO3075pYa0dba7/yWbGloFEOAAAQYIy15R6o5qzn3FGDuVwu/f21lzXg9iuVtW2JrMf7y+sKrqW6l/fTi3+boswjGeXa9mjmdqXtWq7Wtz6kkPAYr2uRpOy965QQmaXF82YoMjLSkUy/FkD330BUkf9L/G8CAAAAKoH1o4Hq4kNJ90mK1g9rj38k6UFJ8dbaIdbaJdb654t5GuUAAAAAahxjjJ4d86RGPdBPR76aK8+pIu8zXUGKbZcsRTXSru3vl2lv9fT9G3Tw0Fq1ummkgt3hXtdgrdXxnat1XdtoTZ/0ttxut9eZAAAAAAAAXjCSdkr6vaSW1tqu1tq3rLXZPq7romiUAwAAAKixHrh3uMb+/lc6ummWigvzvc4zxqhJx14Kjq2j7VtmyeM5dd65e3ev0bHcPWp5/VC5gmt5fd7W41HW14t1951X6Y3xf5HLxcs5AAAAAADgU/+UdIO1tpW19jlrbZqvCyoP3lkBAAAAUKMl97hT7/ztLzq2ZbYK8447ktmg9XWKbnapvv5ysk4VnzzrNGs92rntPRUFF6tZl34yDjS0PcVFOvLVHI3++T0aM/pXXucBAAAAAAB4y1r7M2vtp76uo6JolAMAAFRTrOmKUlWT9ciN9ZwzKlOXpKs0f+rbytvxnvKPH3Yks07TDoprf5O2bJykwpM5kiSPp1jffDVT7noN1KhDNxljLpJyccWFeTqyeaZefu7XGjF0sNd5F1LVt0uFVZP7OSoX//cAAAAAh/l6XXLWKEcVC/Z1AQAAAABQFRITE7V0wQz1HjBMecVXK7xuU68zoxu0VPBV4dr6xRQltumltG+XqV7rLoptcpkDFUsnc48p+5uFSv3na+rcqaMjmQAAAAAAAJXNGBMsKVnSjZISJEVJCrrIZtZae1tl1/Y9GuUAAAAAAkZ8gwZasWi27ho0TMeL8xTZoK3XmeGxDdWkcy9t/WSSWlxzt6LjWjhQqZR3/JCK0lZqwYx31TIhwZFMAAAAAACAymaMuVnSO5LO3EvhQofds6dPr9LjCdAoBwAAABBQoqOjtWTBLN0z4gGl7ctXVGPv9tQuyM7U3o0L1brrfQqr3cCRGnMz0xSU+YWWLZyhuDhnMgEAAAAAACqbMeZKSe9Lcquk+V0gaYekY5L8au00GuUAAAAAAo7b7dasye/o54+N1n+3faToFjdUaD3x3KP79N2GRUq4drBCwmMcqS3n0NeKLd6teYtmKzIy0pFMAAAAAACAKvIHSSGSTkp6XNI71toCn1Z0Hi5fFwAAABDojLUVGoAkyXrOHn7KWM9Zo8r9+HqyHrlcLv39tZfU/7YOytq2RNZTvrqOH9yufZuWqNWNwx1rkmfvXaeEyKNaPHfaD01yH9/GP77tfHL7lUU1+VtA1eP/LAAAAFBG1vjPQHV2g0oOof4na+2b/tokl2iUAwAAAAhgxhg9+/QTGvVAXx35aq48p4rKtF12RpoOblutVjeMVLA73Os6rLU6vnO1rmsbrempb8ntdnudCQAAAAAA4AOhp78u8WkVZUCjHAAAAEDAe2DkMI39/a90dNMsFRfmX3R+eExDyVoV5GR6fd7W41HW14t1952d9cbLL8rl4mUaAAAAAACottJOf63lyyLKgndgAAAAAEBS8p3d9c5fx+rYV7NVmHf8gnODaoWo5XVDtGfdPJ3MzarweXqKi3Tkqzka/bO7NebJURXOAQAAAAAA8BPzTn+9yZdFlAWNcgAAAAA4rUtSZ82f+pbydryn/OOHLzi3VmikWlw9SLs+m6aik7nlPq/iwjwd2TxTL/+/0Rox9J6KlgwAAAAAgCOM9Z+Bau1VSQclPWmMae7jWi6IRjkAAIBDjLUVGkBNY6znnFGdJCa21NL506QDq5R35LsLzg2NrKumHXtr56dTdKq4sMzncTLvmI5vmaPUv7+sO7rd5m3JVa46375AWfE/HQAAAADKz1qbIamnpHxJ/zXG/MQYU9vHZZWKRjkAAAAA/Eh8gwZa8d4sReVuUk76tgvOjajTSA3b3awdH02U9Zy6aHbe8UMq+Hax5k97R507XelQxQAAAAAAAP7BWrtJPxx6/R+SjhhjDhljdl1k7KzKOoOr8swAAAAA4GKS+96tjMxjvi5DkuTxeHTgm/cV0/yo4lpdd955eVkHVHAsXd9+OkWJ1w+TMabUeScO79K+dbPVpFETDb734coqu9zq14vRornTfV0GAAAAAACoAYwx/SW9JSlKkjk94sqwaZUeqotGOQAAAAC/kpF5TBGt+vu6jP9p09qjtC/f0/6vVuqS9ree0wQ/+t1m5WcdVMeUMTq44xPt37xMjTvccU7O0b1fKXPXF2p386MKqhVSVeWXScaO2b4uAQAAAADga1ZV3KY8D3+oARVmjLlW0jRJQad/tUfSJknHJPnV+m00ygEAAC6CNUfhN1gL2ieMcan5Fb104JvV2rNuvpp16i3jKlnFKvvwbmXuXqfW1w6XMS5d0vpG7dm0SOnbP1WD1j/sgX54x2fKzkhT62uGyxXEy7AqUdrfi2H1MVSuij5nsOc5CgUAAAAAVEO/VUmT/LikIdba931cz3nxLgEAAAAAXIQxRo3a3qzImCba+Z+p8pwqUt6xg9r/1XK16jJYLlfQ/+Y2vbyncjP36uh3m2Wt1b7Ny1RwIkOJSYNokgMAAAAAgJqus0qOC/B7f26SS+xRDgAAAABlFte8s2qFRmrHmnflOVWk1tcMO+cw6sYYJVw1QNv/k6rMPesVXae5Lrmiu48qBgAAAAAAqFIRp79+7NMqyoBGOQAAAACUQ2x8G9UKjVKtWqGqFRpV6hyXK0itugxW9tHvFNOgVRVXCAAAAAAAnGSMqSfpfkl9JLWUFCvpiKS9ktZImmOt/U8p290r6Z0yns191toJTtTrY7sltZcU7utCLoZGOQAAAACUU2TMJRedE1QrhCY5AAAAAADVnDFmoKQ3JdX90UkNT48uklpJuqtqK/NbcyRdJukO+fle5TTKAQBAQDHW+roEoGysx9cVlImpJnWicpV2P7DG5YNKLqK0+6s/1omAU9HnJ9YYhysBAAAAcCZjzAiV7BHuknRYJQ3zjyUdlRSvkr3Le0kqKkPcHZIOXOD0fV4V6z/GSRosaZQxZr61dq2vCzofGuUAAAAAAAAAAAAAcAZjTDtJ/1RJk/wjSb2stcdLmfq6McZdhsjt1to0B0v0S9babGPMbZJmSlpjjBkvabpKLn+Bb6s7G41yAAAAAAAAAAAAADjb65JCJGVK6neeJrkkyVpbWGVV+TljzKkzf5T09Okhc/GjYllrbZX1r2mUAwAAAAAAAAAAAAHOSDJ+sGqhPywwZIxpK+m20z++Ya3N9GU91cyPb0J/uElLRaMcAAAAAAAAAAAAAH4w8IzvZ37/jTEmVlI9SUettUeqvKrq4Y++LqCsaJQDAIBqyVg/+Hgr4CTr8XUFQGD68d+ecfmmDqACKvp8yF78cIcAAACAv4i/2OG6rbX7KuF8rzn99bikr40xQyU9JanD9xOMMbslvStpnLU2pwyZE06vex4r6YSkbyWtkPSmtXa/k8X7krWWRjkAAAAAAAAAAAAAeOGLMsypjE+CXnr6a5pK1ir/RSlzWkj6g6QBxpg7rLUHLpLZ9Yzv654eV0t6whgzylr7D68qRrnxUXkAAAAAAAAAAAAg0FnjP8P36pz+2lYlTfJjkn4mKU5SqKQkSe+fnnOZpJnGnPcQZbskvSSpv6Qup8c9Kjmkuz2d93djzE8dvxS4IPYoBwAAAAAAAAAAAOCPkiQd8sH5Rpz+GiLplKQe1trPzjh9rTEmRdJ7knpIuk5SP0mzfpQzV9K71p6zbtIXkqafzpgjqZak8caYBdZaX1zegESjHAAA+BRrjSMgVeP1yE1l1l6Nr5cawXocXZ+7tPuKrQ7rf5d2P6wOdQPl4OTzL9Y7BwAAQCU75OQa5MaYRipZI7w0WWesFV6gH5rlM3/UJJckWWs9xpjRKmmUS9Jg/ahRbq09fqF6rLXvGWP+KOn/JIVLekDSn8pyWXzNGDPQWjuzEvMbS2pqrf20ss6DV/sAAAAAAAAAAAAAAsGfJG0+zzizQZ19xvfv6zystVskfd9cT6pgTf9SySHYpbPXMfd3040xm40xA50MNcY0Nca8KelbSbc7mf1jNMoBAAAAAAAAAACAQGf9aPje3jO+v9ge7d/PjavIGVlrD0vKPP1jo4pk+MgOSe0lTTPGpBljnjfGtK9IkDEmwhgzzBjzvkoa5D+VFHT6+0rDodcBAAAAAAAAAAAA1HjW2nsl3VuGqVv0wx7iQReZ+/3pxRWrSpJUHdc0ai/pUUlPS2oq6deSfm2M2SHpM5Wsw75B0mFJWadHmKQ6Kjn8fWuVXMddTo9Q/XA9vC/p19baryrzAtAoBwAAAAAAAAAAAIAfrNEPDfWWkpZfYG7C6a/7LzDnvIwxcZLqnv7xQEUyfMFaWyzpZWPMPyQ9LOkXKmmYt5bUStLwMkZ93xw/JWm+pL9Ya//rcLml4tDrAACg3Iy1jg0AAABUXzwHBAAAQA21QFLR6e/7nW+SMaarfmhyf1TB8/qpfmgWr65ghs9Ya3OttX9RyQcGekh6R9IelVymi40ClVzmpyQ1s9YOqKomucQe5QAAAAAAAAAAAAD8ZX1wP6jBWnvEGPNvST+X1M0Yc4+1dtqZc4wxUZJeOeNX//jR6c0lxVprN5zvfIwxKZKePf1jgUqazNWStdYjaenpIWNMI0nXSWosqb5KDrleICnj9Ngsaa21tqjUwCpAoxwAAAAAAAAAAAAAzvZ7SckqOZx4qjHmeklzJJ2QdLlK1uRue3rum9baL360fXNJHxpj/iNpoaSNKlmv26hk7+sBp8f3e5M/aa2t0OHb/dHpyzLT13VcCI1yAAAAAAAAAAAAADiDtTbDGHOnSg7DnijpkdPjx96W9NgFoq49Pc4nT9KvrLX/rGitqBga5QAABDDWhwSqgPX4ugIA3irt79i4qr4OoAap6PNQa8zFJwEAAAAOsdZ+bYy5UiWHYB8gqZWkSJXsGf6JpH9Yaz88z+brJA1TSZP8KkkNJdVTSX82S9IWSSsl/dtae7gSLwbOg0Y5AAAAAAAAAAAAAJTCWpsr6aXTozzbZUuafHrAD9EoBwAAAAAAAAAAAAKcsSXD1/yhBgQGjhUHAAAAAAAAAAAAAAgoNMoBAAAAAAAAAAAAAAGFQ68DAFADGMvxiAC/YT2+rsAxpgZdFviHH9+nrKnGn93+8d9Hdb4sQDVS0ee91hiHKwEAAABQ3dEoBwAAAAAAAAAAAAKdPT18zR9qQEDgI+8AAAAAAAAAAAAAgIBCoxwAAAAAAAAAAAAAEFBolAMAAAAAAAAAAAAAAgprlAMA4EeMZQEeAAHCenxdAUpT2u1i+Hw1gOrPqefZ1hhHcgAAAPwSa5SjChljbpbUTVKkpL2SvpS03lp7pKpqoFEOAAAAAAAAAAAAAKgSxphfSnpF0pmfRLWnT9svaYOk9ZI2WGsXVFYdNMoDmDGmqaRHJSVLairppKRvJc2Q9DdrbZ4PywMAAAAAAAAAAABQ8zwuKUfSw5I2S2os6QpJHU+PFEm9VNI8D6qsImiUByhjTLKkyZJqn/HrcElJp8dPjDE9rbW7fFEfAAAAAAAAAAAAgBqpnqQJ1trJp3/eJGnx9ycaY6JU0jC/sjKLoFEegIwxV6hkr/FwlXxa48+SPpQUJukeSQ9KaiNpkTEmyVqb46taAaC6Yq1xIECwzjaA77G+OxAQKvo8n7XNAQBAdWBsyfA1f6gBle4rSSHnO9Famy1pzelRaWiUB6ZXVNIkL5bU3Vr7nzNO+8AYs0PSWEltVXLog/9X5RUCAAAAAAAAAAAAqIlek/SSMaa2tfa4r4rg4+0BxhiTJOnm0z++9aMm+ffGSfr69PejjDG1qqI2AAAAAAAAAAAAADWbtXaqpAWS5hlj4nxVB43ywHPXGd+/U9oEa61H0sTTP8bqh8Y6AAAAAAAAAAAAAHhrk6ROknYYY1KNMfcaYzoYY4KqqgAOvR54bjz9NVfSugvMW33G9zdIWl5pFQEAAAAAAAAAAAAICMaYP0t6SpI5/auhp4eVdNIY85Wk9ZLWWWv/VVl10CgPPO1Of/3WWlt8gXnbStmmTIwxjS8yJb48eQBQlYy1vi4BAHzCWI+vS0AAKu1+Zw0HPgNQ81T0dYY15uKTAAAAnGJNyfA1f6gBle1eSRmSBqhkz/JmkjqqZA/zjpKulHSVShrnNMrhPWNMqKR6p3/cd6G51tosY0yupAhJTcp5VnsrUB4AAAAAAAAAAACAmi9C0r+stR+f/nnz6fH90tAyxrRSSdO80tAoDyxRZ3yfU4b53zfKIyunHAAAAOBcBw/uV+HeV31dRkBxB/NpfQAAAAAAUGXW6Yede0tlrd0haUdlFkGjPLCEnvF9YRnmnzz9Nayc53OxPdDjJX1RzkwAAAAEiPhLGimidX9flxFQcrfP9nUJAAAAAAAgcLwoaYox5hJr7QFfFUGjPLAUnPG9uwzzQ05/zS/PmVhrL3hYd8P6WgAAAAAAAAAAAP7H+roABIgESWskLTXGDLTWbvNFETTKA0v2Gd+X5XDqEae/luUw7QDgV4zlGR2ASmA9vq4AQHVS2mOGcVV9HQCqLSdf11h2XAAAAID/eEMlH8swkjYbYz6WtFLSBkkbqmovcxrlAcRaW2CMyVTJMf8bX2iuMSZWPzTK91Z2bQAAAAAAAAAAAAACwt2SrpB0paSOkrqeHlaSjDEZKmmar7fW/qayiqBRHni+lnSjpERjTLC1tvg889r+aBsAAAAAAAAAAAAAkCQZY/pZa+eUdztr7UxJM8/IqaeShnlHlTTPr5TUTVJ3STTK4ZiPVdIoj5DUWdJ/zzOv6xnff1LZRQEAAAAAAAAAAMB3jC0ZvuYPNaDMZp0+bPoT1tovKhpirc2UtPz0kCQZY8IkdfC+xPNjcbTAM++M7+8rbYIxxiVpxOkfj0n6sHJLAoDzM9ZWaAAAAPgl6zl7AEAV4bUVAAAAKsn1kj4zxkw2xjRzKtRam2+tPd8Ov46gUR5grLWfS/ro9I8PGGOuLWXaE5Lanf7+VWttUZUUBwAAAAAAAAAAAKC6mKSSdcWNpHskfW2M+bMxJtq3ZZUNjfLA9JikfJUcen+ZMWaMMeYaY8wtxph/SBp7et52SeN8VSQAAAAAAAAAAAAA/2StHaGSpZ6Xq6RZHirpKUnfGmMeNsYE+bK+i6FRHoCstRsk3S3phKRISc9L+o+kDyT99PS07ZKSrbXZPikSAAAAAAAAAAAAVcf60UC1Ya390lp7h6TukjaqpGFeT9LrkjYbY3r5sLwLolEeoKy1CyV1kDReJU3xPJWsR75W0q8ldbTWfuuzAgEAAAAAAAAAAABUC9baFdbaTpJGSEpTScO8jaR5xpgPjDEdfVlfaWiUBzBr7R5r7ePW2jbW2ghrbay1NslaO9Zam+fr+gDULMbaCg0A8BnrOXcAAAAEGF7LAQAAoDystZMktZU0WlKWShrmXSV9YYx51xjT2Jf1nYlGOQAAAAAAAAAAAADAEdbaQmvtOEktJb0k6aRK+tLDJH1jjHnOGBPpyxolGuUAAAAAAAAAAAAAAIdZa49ba5+S1FpSqkpWoA+T9Iykb40xPzXG+KxfTaMcAAAAAAAAAAAACHRWMn4wxCouNY61dp+1dqSkTpKWqeRw7HGS3pT0pTGmhy/qolEOAAAAAAAAAAAAAKhU1tpN1to7Jd0uaYNKGubtJb1njFlmjOlQlfUEV+WZAQCqF2P56B4A1FTGenxdAlCq0u6b1ndHYat8pf0t1uTLCyBgOPV60hrjSA4AAAD8h7X2A0mdjTGDJf2fpBYqaZ6vleSuqjpolAMAAAAAAAAAAAAAKp0xJlJSO0mXnv76rUoa5ZIUVJW10CgHAAAAAAAAAAAAAp2/rA/uDzXAa8aYOjq7IX7p6dHIl3WdiUY5AAAAAAAAAAAAAKDcjDHxOrsR/v339Uub/qOfraQ9kracMaoMjXIACACsNQ4AF8F63QAAAH6poq9nWdscAACg8hljjkiKKe2kUn63TyWN8K/0Q1N8q7U2t9IKvAga5QAAAAAAAAAAAACA8oot5XcHdfYe4l9J2mKtza7KwsqCRjkAAAAAAAAAAAAQ6FijHOW3SmfvIb7FWpvl04rKgUY5AAAAAAAAAAAAAKBcrLW3+roGb7h8XQAAAAAAAAAAAAAAAFWJPcoBoBoxlmPOAAAAAABwMU6+frbGOJYFAAAA/0GjHAAAAAAAAAAAAAhwxpYMX/OHGhAYOPQ6AAAAAAAAAAAAACCg0CgHAAAAAAAAAAAAAAQUGuUAAAAAAAAAAAAAgIDCGuUAUAWMZVEVAPAr1uPrCgDg/Ep7jDJ8zh0AfKWir+mtMQ5XAgAAACfxShsAAAAAAAAAAAAAEFBolAMAAAAAAAAAAAAAAgqNcgAAAAAAAAAAAABAQGGNcgAoB9YaBwAAAAAAZcHa5gAAAP6NRjkAAAAAAAAAAAAQ6Ozp4Wv+UAMCAodeBwAAAAAAAAAAAAAEFBrlAAAAAAAAAAAAAICAQqMcAAAAAAAAAAAAABBQWKMcQEAylkVOACBgWI+vKwAA7/34sczwuXcAqKmces/CGuNIDgAgcBhbMnzNH2pAYOCVNQAAAACUU/q3nynr4LYLzsk/cVjfbXpf1nOqiqoCAAAAAABAWdEoBwAAAIAystbquy8X62ReltK//VTZR/aUOq8w/7h2rZ0td3i0dvxnsk4VF1ZxpQAAAAAAALgQGuUAAAAAUAYezynt+mKm3BG11eTKHmp53RDt3bRE+ScOnzWvuDBf3342TS269FeD1tcrLvFabf/kXRWdzPVR5QAAAAAAAPgxGuUAAAAAcBGnik9qx6eTFHNJWzVofb0kKbhWqFpeN1i7185WYf5xSZLnVLG+/WyKmnS4U2HRcZKk2g1bqckVPbXjk4k6mZvls8sAAAAAAMBFWT8YQBWhUQ6gWjPWVmgAAACUVdHJXG3/eKLi29ygOk07nHWaOyxazbsM0LefTVPRyVzt/Hy6GrS6TpH1m501L6JOI7W4ZpB2/neaco8drMryAQBAgOI9EwAAgAujUQ4AAAAA51GQc1Q7PklV044pim7QstQ5YdH11eSKO7X1w78rKq6lYhq1K3VeaGRdJd4wXN9tXKjjh3dWZtkAAAAAAAC4iGBfFwAAAAAAZ4qrW1uHt8/2dRnKz8tV+uFMtbzxXoVE1Lng3Mh6zdTkih46krZBcS27yLhK/0xyrdBItbpppL5dM0G5aR+qdkxsZZRebnF1a/u6BAAAAAAAgCpFoxwAAACAX1k0Z5qvS9DKD1fpl0/9Ua1ueUi1QiLKtE1so0tVfDJPe9YvULPOfWSMKXVeUHCIWt38E2VtfU9DByZr1CM/c7J0AAAAAAAAlAGHXgfgF1g3CwDgCOs5dwBlZa1krSZPm6FfPv286nQYWOYm+ffqJ1wld3htHdj6wQXnuVxBqtO+t96evUpPPv2srMdTcv5AWfF4BwCoJLxHAwABzPrRAKoAjXIAAAAAOO0vr7yhP78xWfU69FdQsLtCGQ3b3azighxl7PrigvOMMYptfbtWbjyoYQ/8XMXFxRU6PwAAAAAAAJQfjXIAAAAAAc9aq1FP/VaTFv5HdS5NkXEFVTjLGKOmnXrp+KEdOnZg20XnRze7Rl9nhqrXgKHKy8ur8PkCAAAAAACg7GiUAwAAAAhoRUVFGnLvT7X6qwzFtLr1vGuLl8epopM6VZhf5oZ71CWXKyOopbqlDNCRI0e9Pn8AAAAAAABcGI1yAAAAAAErNzdXyf0Ga3tWpKKbdnEkszD/hHZ8PFGNLuum2vGtyrxdRP2WKqx3tbr1GqDv9u51pBYAAAAAAMrKWP8ZQFWgUQ7AK8ZaRwYAAEBVy8w8ottT+uuou7UiG7Z3JDP/xGHt/HSyml/VT5H1mpZ7+/DYRqrV4g717D9Mm7/6ypGaAAAAqgLvCQEAgOqGRjkAAACAgJO2Z49u7zVAp+KuV0S9BEcyszP2KG3tXLW8bqjCoutXOCc0sq6i2/XV3fc9olVrPnakNgAAAAAAAJyNRjkAAACAgPLlpk1KGTBSoS17KCymoSOZuenf6OjWhYpv0ka1QqO8zqsVGqk6lw/Uw6P/qBmz5zpQIQAAAAAAAM5EoxwAAABAwFj54SoNfuAxRbfvq5CIOo5k5uzfoCah6dq24T/qc/OlOvbNMlnr8To3qFaI6nYYoP/38tt65Y2/O1ApAAAAAAAXYP1oAFWARjkASawjBQAAqphxnTsq2eRpM/XLp59XnQ4DVSskwus8a62O7/pIVzUP0ewpExQaFqbnfveMHh7WQ0c2z5PnVLHX5+FyBalO+956e/YqjX7m97KV/fzLB7cLAAAIbBV9T4r3qQAAgLd41wMAAABAjfeXV17Xn9+YpHod+iso2O11nvV4dOybJep7y2X6++vj5HL98NLqZw/er+ef+YWObJql4qICr8/LGKPY1rdrxfr9Gv7Az1Vc7H0DHgAAAAAAINDRKAcAAABQY1lrNeqp32jSgv+ozqUpMq4grzM9p4p15Kt5evS+u/T7Z0bLGHPOnD69kvXW63/Ssc2zVJh/wuvzlKToZtdoa0aIevUfory8PEcyAQAAAAAAAhWNcgAAAAA1UlFRkQaPfFCrN2coptWtpTa0y6u4MF9HNs3Ui88+qp/cO/yCc6+9+mrNmfRP5X6zQAUnMrw+b0mKuuRyZQS1VLeUATpy5KgjmQAAAAAASJKx/jOAqkCjHAAAAECNk5ubq+R+g7XjWJSim3ZxJLMw77iOfTVb7/z1RaX0vLNM27Rp01pL5k2VZ98Hyju615E6Iuq3VGG9q9Wt1wB9t9eZTAAAAAAAgEBDoxyoYYy1FRoAAFRL1nP2ACRlZh7R7Sn9ddTdWpEN2zuSmX/isPK2L9S8Kf/W1UlXlWvbSxo21PKFMxV+fL1yD+9wpJ7w2Eaq1eIO9ew3TJu/+sqRTNQAP35M5HERABBgeF8MAACUB41yAAAAADVG2p49ur3XAJ2Ku14R9RIcycw7+p3svg+1ZP40tWqVWKGMmJgYLV0wU5cE7VP2/i8dqSs0sq6iL+2ru+97RKvWfOxIJgAAAAAAQKCgUQ4AAACgRvhi7VqlDBip0JY9FBbT0JHM3PRvFJn9pVYumq2G8fFeZYWGhmru9Im6srHRid2fyDqw91Kt0EjVuXygHh79R02eNsPrPAAAAAAAgEBBoxwAAABAtbfyw1W6o/cA5SlKIRF1HMnM2b9BTULTtWT+DEVHRzuSGRQUpLfefFUpN7TWse3LZB04NHZQrRC56rTVw489qVfe+LsDVQIAAAAAApL1owFUARrlAAAAAKq1ydNm6pdjnleblCeVn52uw9s/8SrPWqvjuz7SVc1DNHvKBIWEhDhUaQljjJ773Rg9PLSHjn41X55TxV7lZWfu0cEty9Uu5XG9NXeVRj/ze0f2VgcAAAAAAKjJaJQDfspYW6EBAABQbRnX2aMM/vLKG3r+r6mq02mAgt1hatH1Xh3Zs05H926qUAnW49Gxb5ao3y2X6e+vj5PLVXkvmX724P3605iHdWTTLBUXFVQooyA7U3s+n66EW+5XrbAoxbTrpuUb92v4Az9XcXEZGvAVuM4BAABqGt6DAwAgMPFOCAAAAIBqx1qrUU/9RqmL/qPYDr1lXEGSSg5DnnDrAzrw1XJlZ6SVK9NzqlhHvpqnR++7S797ZrSMMZVQ+dn69ErWv1/7P2VtnqXC/BPl2ra4IE/ffvSOmt8wVKFRdf/3+6iEa7XlaKhSBgxRXl6e0yUDAAAAAADUCDTKAQAAAFQrRUVFGjzyQa3akqnabW49p6FdKzRSLW+5T3u+mKGCE5llyiwuzNeRTTP14rOP6if3Dq+Mss/rumuu0dxJ/1TuNwtUcCKjTNt4igu1fdWbanr1XQqv2/ic0yMbX64Md6K69RqgI0eOOl0yAAAAAKAm8vW65KxRjipGoxwAAABAtZGbm6ue/e7RN9lRimrR5bzzQqLqqvkNQ/Xtx2+rsCDngpmFecd17KvZeuevLyql551Ol1wmbdq01pJ5U3Vq70rlHd13wbkej0fbV/1DDTvcpsj41uedFx7XUgUNrlG33gP13d69TpcMAAAAAABQrdEoByoZa40DAABU0I/Wz848kqXbUvrrSFhbRTa67KKbh9dtrKZX99OOVf+Qp7iw1Dn5Jw4rb/tCzZvyb12ddJXTl6BcLmnYUCvem6Xw4+uUe3jHeeft+uQd1WlxhWo363jRzPA6jRSceId69h+mzVu2siY5AACAQ3jPDwCA6o93RgAAAAD4vbQ9e3R7Sn8VN7pBEXEJZd4uMr6VLulwm7av+rs8Hs9Zp+Ud/U5234daumC6WrVKdLrkComJidHSBTN1SdA+Ze//8pzTv/tihkJr11e9tl3LnBkSVVeRHfrp7vse1qo1HzlZLgAAAAAAQLVFoxwAAACAX/ty0yalDBwud5seCotpWO7tazfrqLotOmrXx2//73c56dsUmf2lVi6arfgGDZws12uhoaGaO32irmxsdGL3J7Kn9zw68NX7OnWqUA079S53Zq3QSMV0HKSHR/9BM2bNcbpkAAAAAEANYKz/DKAq0CgHAAAA4LdWfrBKgx94VFGX91NIZJ0K59Rte5PCYhpozxfTlb1vg5qGpGvJ/BmKjo52sFrnBAUF6a03X1XKDa11bPsypW//RDmZ36nJ9UNkjKlYZq0QxXYaqD++8pZeeeNNhysGAAAAAACoXmiUAwAAAPBLk6fN0C+f+T/FdBqo4NAIr/PiO/VSzpF9al33pGZPfVchISEOVFl5jDF67ndj9NA93XVw6wo1v2mEXK4grzJdriDFduijt+es0uhnnv3f3uoAAAAAAACBhkY5UEbG2goNAAAAlN9fxr+m5/+aqjodBygo2O11nvV4dHzLEj36s/s19d1/yeWqPi+FfvGzBzXx33/X8U3zdaqwwOs8Y4xqt7tdyzcc0PAHfqbi4mIHqoTfsp6zBwAA8CneYwQAwH9Un3eHAAAAANR41lqNGj1GqYv+o9jLe8l4uQe1JHlOFSvry7l67N4++t2Y0RU+dLkv9emVrH+/+n86vnGmivKzHcmMSrhGW46EKKX/YOXl5TmSCQAAAACoxqwfDaAK0CgHAAAA4BeKioo0eORPtGpLpmq3udWRhnZxYb6y1s/Qi795VD+5d7gDVfrOdddcozmp/1TeV/NUcCLDkczIxpcrw91S3VL66ciRI45kAgAAAAAAVAc0ygEAAAD4XG5urnr2vVvfnIhSVIsujmQW5h3XiY2z9M4bLyql552OZPpamzattWTeVNndK5R3ZJ8jmeFxLVXQ4Bp16zVA3+3d60gmAAAAAACAv6NRDgAAAMCnMjOP6LbkvjoS1kaRjdo7kpl//LDyty7UvMn/1tVJVzmS6S8uadhQKxbOUsSRtcpN3+5IZnidRgpOvEM9+w3V5q++ciQTAAAAAADAn9EoR8Ax1lZoAAAAH7OecwcqzBrXWcNXdqel6faU/ipudIMi4hIcycw78p3Mng+1bMEMtWrdWjKuio/K5EVdMbF1tGzhbDXWfuXs/dKRckKi6iqyQ1/dfd/DWrXmI0cyK+LH901f3j8BAAD8Be9pAgDgPN5xAAAAAOATX27apJSBw+Vu00NhMQ0dycw99I2ij32plYvmKL5BA0cy/VVoaKjmTk9Vx0uMsnd+IuvAG6G1QiMV03GQHh79B82YNceBKgEAAAAA1Yr1gwFUERrlAAAAAKrcyg9WafADjyq6Q3+FRNZxJDNn7wY1q5WuJfNnKjo62pFMfxcUFKS33nxNva5rreNbl8o6cKSFoFohiu00UH985S298sabDlQJAAAAAADgf2iUAwAAAKhSk6fN0C+f+T/FdBqo4NAIr/OstTqx4yMlNQ3R7CnvKiQkxIEqqw9jjJ773TP6xdBkZW2cJ8+pYq8zXa4gxXboo7fnrtKTY551ZG91AAAAAAAAf0KjHNUW6/IAAABUP38Z/5r+/NdU1ek4QEHBbq/zrMej41uWqN/N7fWP11+Wy+XwSxxv1jev4vXPf/bg/Xp+zCPK2jBTpwoLvM4zxqh229u1YuMBDX/gZyou9r4BDwAAgKrFe6gAAJwfjXIAAAAAlc5aq1Gjxyh10X8Uc3kvGVeQ15n/n707j4+qvvc//j4zSWaSQAigEBLRigSoikuVQMClQlAICQGyIForSrB4XaptXQALXi+9equ2oLgriopCAtnQQpCETbopSACroFVIQLaEPZOZzGTO74/7u95rRQXmS5gkr+fjcf7JnPPqpy5xcj6cTLApoANVxfrl+FGaPuUBWZZlYNKWLStzhF6e+Z86uKFQ/obDRprtewzQx3UuZWSPk8fjMdIEAAAAAIQfyw6fA2gOLMoBAAAAnFJ+v1/jbs7Xyo9r1aH3YCML7UBjgw6sL9B/PfRL5d/ycwNTth4DUweo+M2X5dlcKu/hfUaa7c7qq31R52loxhjV1dUZaQIAAAAAAJxOLMoBAAAAnDL19fUaMWasthxur/bnphhpNnoO6/CGhXp19uPKSB9upNna9O7dS0tLF8j+crk8dTuMNGO6nCdv1wEampmj6poaI00AAAAAAIDThUU5AAAAgFNiz969umzgT1Xr7q12SRcYaTYc2quGf5Sp5K1X1D/lciPN1iqxWzctf6dIsfs/VP2erUaaMZ2SFNHzOl0zbKQqV6400gQAAAAAADgdWJTjtLNs+6QOAAAAhK8vt23TdVl5OhKM1MGazUaanrpqWdtXaFlZgZKTk400W7v4+HgtK1uks7RTR2uqjDSP1m7XEW+T7rhvmlauXmOkCQAAgPDCPVigjbLD6ACaAYtyAAAAAEZVbdyozLyfK/L8dJ3z05/Le3iv9vxjZUjN+t1bFHewShXvFimha1czg7YRbrdbxQve0KWJlo78c63sEG54Ht79ufZ+vELnDp2gDv3y9G8P/LsKFhYZnBYAAAAAAKB5sCgHAAAAYExF5UqNy79bsZeOUVS7jrIcTp1zzc06WLNJ+7/86KSaR6s/0jkRu7W0tFBxcXGGJ24bnE6nXnnuKWUO7KVD/yiXbQdPuOE5uFs7/l6kc9NuVYQrRs5Il+Ivz9G/z5qjmbOfOwVTAwAAAAAAnDosygEAAAAYMW9+ge6a+jt16JerCHfs1193RETq3LQJ2vNxpQ7v/vy4e7Zt6/Bna9TvHJcWvf26XC7XqRi7zbAsS/8xbYruuHGEDmwoUbApcNzXNnoOa9vquTrnmp8rql3H/206nOpw6UjNKV2p30z+bUhPqwMAAAAAADQnFuUAAAAAQvb4H5/So8++qfjLs+WIiPrW6xGuGJ2bdqt2/L1IngO7frBn20Ed+nipxvz0Ar3w9B/kcPCjiymTJt6q/5x8pw58VKimRu8Pnt8UaNTnFS+o+6BcRXdM+NbrlmWp/flpem/TV7ppwiQFAse/gAcAAAAAhA/LDp8DaA7cbcJpZfHECQAAQFiwLce3juO6zrZ1z/2T9fqf/qK4SzJkOZzfeW5Uu44655qfa9ua19XoOfyd5wWbAjqwoUS/HD9K06c8IMuyTvj/D75fVuYIvTLrUR3csFD+hu/5exEM6vNlzyrpsmGK7drje5vtzhugzQddysgeJ4/Hc1xznOw/dwAAAAAAAKHiLgQAAACAk+L3+3X9zfla8Umt4s4ffFwL7eiOCeo+KFefV7ygwDGeZg40NujA+gL9/re/VP4tPz8VY+P/Sx3QX8VvviTP5lJ5D+875jlfVr6kM3r3U/uz+x5XM7Z7X+2JPk9DM8eorq7O5LgAAAAAAABGsSgHAAAAcMLq6+s1YsxYbamPU7seKSd0bWzXHkq6bJj+ufx5BYP/+2u6Gz2HdXjDQr06+/caMXyY6ZFxDL1799LS0gWyv1wuT13NN16rfv9NxXTpro69B51QM6breWpIHKChmTmqrqn54QsAAAAAAABOAxblAAAAAE5IbW2d0jLGaF+7Poo96/yTarQ/u6/O6J2iLytfliQ1HNqrhn+UqeStV9Q/pZ/JcfEDErt10/J3ihS7f53qd2+VJH21brHkjFCXS4efVDO6U5Icfa5TevaN2rR5s8lxAQAAAACnih1GB9AMWJQDAAAg/NjBbx8IC9u2b1fayGz5ug9STJdzQ2p17D1QMV3O0T8rX5KjeqWWlRUoOTnZ0KQ4EfHx8VpWtkhnWTtV/ee31HB4j5IG5Yb0+fCu9p0Vc8lojb31Dq1cvcbgtAgJ318BAAAAAJDEohwAAADAcarauFEZuTcp8sfpiu7YzUizXcK56hTj1PJ3Fimha1cjTZwct9ut4gVv6Mdnd1ans3pKVug/LkZGt1Pc5bn6t/v/XQULiwxMCQAAAAAAYAaLcgAAAAA/qKJypcbl363YS8coql1HI82j29brR449WvfnlYqLizPSRGicTqeWlBRq9BUX6PDmctkGnjZ2RroU3y9H/z5rjmbOfs7AlAAAAAAAAKFjUQ4AAADge82bX6C7pv5OHfrlKsIdG3LPtm0d2bJG/bu7VfT263K5XAamhCmWZek/pk3RneNG6OC6EgWbAqE3HU51uHSk5pSu1H1Tfivb5gPnAAAAAADA6cWiHAAAAMB3evyPT+nRZ99U/OXZckREhdyzg0Ed3rhE2VddoBee/oMcDn4kCVeTJt6qRx+8Uwc/LFRTozfknmVZan9+mpZt/Eo3TZikQCD0BTwAAAAAwCA7jA6gGXBXCgAAAMC32Late+6fotf/9BfFXZIhy+EMuRkM+HVwfbHuuXm0pk95QJZlGZgUp1JW5gi98sf/1OEPC+X3HDbSbHfeAG0+6FJGzjh5PB4jTQAAAAAAgBPFohwAAADAN/j9fo37+QSt+Mc+xZ0/2MhCu6mxQQc/LNTvp/5S+bf83MCUaC4DUweo+M2X1bCxVN5D+4w0Y7v31R7XeRqaMVp1dXVGmgAAAAAAACeCRTkAAACAr9XX1ytjdJ621LdXu/NSjDQb6w/p8LqFeu3p3ysjfbiRJppX7969VF6yQNbny9VQu8NIMybhPHkT++vajDGqrqkx0gQAAAAAADheLMoBAAAASJJqa2s1dMQo7WvXW7FnnW+k6T24V77Ni1U67xX1T+lnpInTI7FbNy1/p0jt9n0oz66tRprRnZLk6HOdRmTfoM2bPzbSBAAAAACcHCuMDqA5sCgHAAAAoO3bt2toZrZ83Qcppsu5RpoNtdVyfLFCy0oLlJycbKSJ0ys+Pl7Lyhape3Cn6qurjDRd7Tsr5uJRGnvLJK1cvdpIEwAAAAAA4IewKAcAAADauKqNG5WRc6Mifzxc0R27GWnWf/Wp4uo2qOLdIiV07WqkifDgdrtVvOAN/aSrpaOfrZVt2yE3I6PbKe7yXP3bfQ+rYGGRgSkBAAAAAAC+H4tyAAAAoA2rqFyhcRPuVOylYxTVrqOR5tFt6/Ujxx6Vly5UXFyckSbCi9Pp1CvPPaWRA3rp8OZy2XYw9GakSx375eiRmS9r5tPPGpgSAAAAAADgu7EoBwAAANqotxcU6O4pMxTfL1cR7tiQe7Zt68iWNerf3a2it1+Xy+UyMCXClWVZ+o9pU3TnuBE6uK5EwaZA6E2HUx0uHak5JSt03+SHjDytDgAAAAA4TnYYHUAzYFEOAAAAtEFP/PEp/W72XMVfni1HRFTIPTsY1OGNS5R91QV64ek/yOHgR422YtLEW/Xog3fq4IeFamr0htyzLEtxF6TpvaqduunW2xQIhL6ABwAAAAAA+FfcvQIAAADaENu2de99D+r1d9eqwyWZshzOkJvBpoAOri/WL8eP0bSpk2VZloFJ0ZKMHJmpl2c+qsPrFsrfcMRIs13PAfr4oEsjc66Xx+Mx0gQAAAAAAPgfLMoBAACANsLv92v4yDF6u2ix4s4fbGSh3dTYoIMfFOi/HrpX+bfcbGBKtFQDU1NV9ObLaqgqlffQPiPN2O599XH1fl2SMkj79+830gQAAAAAAJBYlAMAAABtQn19vUaMydNu99mKPuMs7fxrUcjNxvpDOrJukV6b/YQy0ocbmBItXe/evbW0tED6vEINtTtC7u3/7O/yHa1TzCXpSssYreqaGgNTAgAAAACOyZasMDj4jHI0FxblAAAAQCtXW1uroRmjtbd9b8V0v0AJA0fL33BEe6qWn3TTe3CvfJsXq/itOUpJ6WdwWrR0id26afm7xWq3b508u7eedOfQji3a98lanTP0VsV0OUfW+cM0IvsGbd78scFpAQAAAABAW8WiHAAAAGjFtm/frqGZ2fKeM1AxCT0kSZbl0FmDf6Yju7aqbuvfT7jZUFstx5crtLSkUMnJyaZHRisQHx+v8sVFOqtph+qrq074ek/dTu36oEw/ui5fTle0JMkV11nuy0Yr75ZJWrl6jemRAQAAAABAG8OiHAAAAGilqjZu1IjcG+W8cLjcnRK/8ZrDGaFzrp2g2k/X6lDNp8fd9Hy1RXF1VVr+bom6dUs45jm25fjWgdbleP7+ut1uFRe8pUu7Skc/W3vc7cajB7R91Zs6e+h4RcbGfeO1yOh2aj8gT/92/3QVLAz94wMAAAAAAEDbxR0rAAAAoBWqqFyhcfl3KubybEW173TMc5xRbv3ounztWrdY9cfxedJHt3+kc5x7tLRskeLi4n7wfMDpdOqV559RRv9kHd5ULtsOfu/5gUavvnjvZZ3903Fyx3c5djPSpQ79c/Xvs17WzNnPnoqxAQAAAABAG8CiHAAAAGhl3lpQoLumzlBc/zxFuGO/99zI2DidnTZe1avnqfHogWOeY9u2jmxdo/5nubTo7TfkcrlOxdhopSzL0oyHf6t/u2GEDq4rVbApcMzzgsGAvlj6rBIHjFR0l3O+v+l0Ku7yLL1SulL3TXlItm2fitEBAAAAoG2xw+gAmgGLcgAAAKAVeeKPT+l3z76uDv1z5IiMOq5r3PFddPZPx+mL915WoNH7jdfsYFCHNy1V9pUX6vnZM+Vw8CMETs6kiRP0nw/eqYMfFqrpX/45CwaD+rL8BZ3Z9yq1697nuHqWZal93zQt27RTN024TYHAsRfwAAAAAAAAx8JdLgAAAKAVsG1b9973oOYuWau4n2TKcjhP6ProLucoKXWkvlj6rILB/144BpsCOri+WL+8ebSmTX1QlmWd/Hx8ZnmLZfIz57NGZujlmY/q8LqF8jcc+frrNaveUPvuvdUhud8JN2OTU7X5kFsjc66Xx+M56dkAAAAAAEDbwh0qAAAAoIXz+/26YfwEVW7Zp/YXDjnphXbsWX10Zt+r9GX5Cwr4PDr4QYH+66F7lX/LzYYnRls2MDVVi954SQ1VpfIe2qev/lqkiJh26nxx2kk3Y87pq13RPXRt5mjt37/f4LQAAAAAAKC1YlEOAAAAtGD19fUaMSZPn3raK7Zn/5B7HZL7KTbhXG1b+oxem/2EMtKHG5gS+KY+ffpoSckC1W8oVsOhvUoYOCak31ggSdHdeqr+rAFKyxit6poaQ5MCAAAAQBtzuj+bnM8nRzNiUQ4AAAC0ULW1tRqaMVr74voouvsFRpreg3sV27hfS0sXKiXlxH8NNnC8khITtaL8XSWfnaCGXZ8baUZ3TpJ1/jCNyL5Bmzd/bKQJAAAAAABaJxblAAAAQAu0fft2Dc3MlvecgYrueq6RZsO+akV8VqmlJYW65JJLjDSB75OQkKBli4vV3V8jz7YNRpquuM5yXzZaebferpWr1xhpAgAAAACA1odFOQAAANDCVG3cqBG5N8p5YbrcnRKNND07P1WHvR9p+bsl6tYtwUjz+9iW46QOnLxw/WvudrtVUvCWfnKmpaOfvi/bDv337EVGt1P7/rn6twceVsHCIgNTAgAAAACA1oY7TQAAAEALUlG5QuPy71TM5dmKat/RSLP+i/U6196t8rIixcXFGWkCJ8LpdOqV52drZP9eOlJVLtsOht6MdKlDSo7+fdbLmjn7WQNTAgAAAEDrZtnhcwDNgUU5AAAA0ELMm79Ad02dobj+eYpwx4bcs21bRz9ZpQFnubRo/ptyuVwGpgROjmVZmjH9Id05boQO/b1YwaZA6E2nU3GXZ2lO6UrdN+UhI0+rAwAAAACA1oFFOQAAANACPPHHp/Toc2+qQ/8cOSKjQu7ZwaCObFiinCv76vmnZ8rh4EcDhIdJEyfo0Qfu0uG/Fqip0Rtyz7IsteubpmWbvtJNE25TIBD6Ah4AAAAAALR83A0DAAAAwpht27r3vgc1d8latf9JhiyHM+RmMODXoQ+KdM/NozVtyoOyLMvApIA5WSMz9PLMR3XkbwXyew4bacYmD9DmQ25lZo+Vx+Mx0gQAAAAAAC0Xi3IAAAAgTPn9fo27eYIqt9Sq/YVDjCy0m3wNOvTXAv1+6r3KH3+zgSmbl205OE7yaGkGpqaq6I2X5V1fIu+hfUaaMef01e6Y8zQ0Y7Tq6uqMNAEAAACg1bDD6ACaQcu7WwIAAAC0AfX19coYk6ctDe0V2zPFSNNff0hH/16o12Y/roz04UaawKnUp08fLS0pkGPLcjXsqzHSjO7WU57uAzQ0c4yqa8w0AQAAAABAy8OiHAAAAAgztbW1GpoxWnvj+ii6+wVGmt6De9W4oUwlb72q/ilmFu9Ac0hKTNTyd4oVt3udPDu3GmlGd06Sdf4wjci+QZs3f2ykCQAAAAAAWhYW5QAAAEAY2b59u4ZmZst7zkBFdz3XSLNh73ZFfFappSWFSk5ONtIEmlN8fLzKFxepe6BGnm0bjDRdcZ3lvmy08m69XStXrzHSBAAAAAAALQeLcgAAACBMVG3cqBG5N8p5YbrcnRKNND07P1WHfRu0/N0SdeuWYKQJnA5ut1slBW/pJ2daOvrp+7Lt0D+0LjK6ndr3z9W/PfCwChYWGZgSAAAAAAC0FCzKAQAAgDBQUblC4/LvVMzl2Ypq39FIs/6L9TrX3q3ysiLFxcUZaQKnk9Pp1CvPz9bI/r10pGqpbDsYejPSpQ4pOfr3WS9r5uxnDUwJAAAAAC2TZYfPATQHFuUAAADAafaHmU/pzin/obj+eYpwx4bcs21bRz9ZpQFnubRo/ptyuVwGpgTCg2VZmjH9Id05LkOH/l6sYFMg9KbTqbjLszSndKXyJ91h5Gl1AAAAAAAQ3liUAwAAAKfR4398So8/86IOHzkiR2RUyD07GNSRDUuUc2VfPf/0TDkcvOVH6zRp4gQ9+sBdOvzXAjU1ekPuWZalep9fpeUVumnCbQoEQl/AAwAAAACA8MVdMwAAAOA0sG1b99z/oF5fulZnj7pLro5dtHPN/JCawYBfhz4o0j0/H61pUx6UZVmGpgXCU9bIDL0881Ed+VuB/J7DIbVq/7FW9Xu3qceYX2rjUbcys8fK4/EYmhQAAAAAAIQbFuUAAABAM/P7/Rp38wRVbq1V7MVDZFmWzkwdqWDArz0f/umkmk2+Bh3+W6F+P/Ve5d9ys+GJgfA1MDVVxW++It9HpfIe2ndSjYNfbtaBrR+o+7BbZTmdivlRX33V/jwNzRyturo6wxMDAAAAQJiyw+gAmgGLcgAAAKAZ1dfXK2NMnj7xtVdMr5Svv25ZlhIH36D6fdWq/fj9E2r66w/p6N8L9erTv1dG+nDTIwNhr3fv3lpaUiDHluVq2FdzQtfW79mmveuW6Oz0CXJGub7+enRiTx09Z4CGjhyj6poTawIAAAAAgPDHohwAAABoJrW1tUrLGK3dHfso+pwLvvW65XSq+3W36MDnH+rgto3H1fQe3KvGDWUqeetV9U9J+eELgFYqsVs3LX+nWHG718mzc+txXeM9tE87Vs9X9+G3KjKm/bdejz4jSXbfYRqRc4M2b/7Y9MgAAAAAAOA0YlEOAAAANIPt27dr6MhsNfQYqOiEc7/zPGeUS+ek52vvunLV7972vc2GvdsV8VmlyksXKjk52fDEQMsTHx+v8sVF6h6okWfbhu89N+Ct1/Zlc3RW2s/k6tD5O89zxXWWK2W08ibcrpWr1xieGAAAAAAAnC4sygEAAIBTrGrjRo3IvVHWRcPl7pz4g+dHRLdT92G3asea+d/5mcuenZ+qw74NWv5uiRISupoeGWix3G63Sgre0k/OtHT00/dl29/+cLtgoFFfvvusEq8cregzz/rBZkR0O8UOzNXtD0xXwaKiUzE2AAAAAJx2lh0+B9AcWJQDAAAAp1BF5QqNm3in3AOyFRXX6bivc3XorLPSfqbty+Yo4K3/xmv1X6zXufZulZcVKS4uzvTIQIvndDr1yvOzNbJ/Lx2pWirbDn79WjAY1Jd/el5dLktT7Fm9jr8Z6VLcwFz9+1Mva+bsZ0/F2AAAAAAAoBmxKAcAAABOkbcWFOiuh2ao3cA8RbhjT/j66DPPUtJVY/Tlu88pGGiUbds6+skqDTjLpUXz35TL5ToFUwOtg2VZmjH9Id05LkOH/l6sYFNAklTz3hzF97xY7XteeuJNp1PtUrL0ctlK3TfloWM+rQ4AAAAAAFqGiNM9AAAAANAaPf7Hp/Ra6TK1H5gjy+E86U5MUrK6XDZEX/7pOZ1xVk+NvTZVv538gCzLMjgt0HpNmjhB3bp21eTfPaEjfluujmeq40VXn3TPsiy1uyRN5Zv/ol0TbtNrLz6niAh+tAYAAAAAoKXhiXIAAADAINu2dc/9D+r1pWvVrl9mSEvy/xH7owvlkK0bh1+haVMeZEkOnKCskRl64ckZatj9pTpefI2RZkyfVG086tbInOvl8XiMNAEAAADgtLLD6ACaAYtyAAAAwBC/368bxk9Q5dZaxV48xMhCu8nXoCNrC/XSU09qygP3GZgSaJuuvOIKrV3xnvwflsp3cJ+RZsyP+mpnux66NnO09u/fb6QJAAAAAACaB4tyAAAAwID6+npljMnTP7ztFdMrxUjTX39I9X8u1GtP/14Z6cONNIG2rHfv3lpaUiDnP5arYW+NkWZ0Yk8dOWeA0jJHq7rGTBMAAAAAAJx6LMoBAACAENXW1iotY7R2x/dW9DkXGGl6D+xVYF2ZSt96Vf1TzCzeAUiJ3bpp+TvF6vDVOjXs2GqkGX1Gkuy+wzQi5wZt3vyxkSYAAAAAADi1WJQDAAAAIdi+fbuGjsxWQ4+Biu7Ww0jTu3e7Ij+tVHnJQiUnJxtpAvhf8fHxWlZWpLMba+T5YoORpiuus1wpo5V36yStXL3GSBMAAAAAAJw6LMoBAACAk1S1caNG5N4o66LhcndONNJs2PGp4ndtUMW7JUpI6GqkCeDb3G63Sha8pcs6W6r/5H3Zth1yMyK6nWIH5en2B6arsKjYwJQAAAAA0IzsMDqAZsCiHAAAADgJFZUrNG7inXIPyFZUXCcjTc/n63Vu026VlxUpLi7OSBPAd3M6nZrz/GxlXd5LR9cvlW0HQ29GuhQ3MFcPz3pJs555zsCUAAAAAADgVGBRDgAAAJygtxYU6K6HZqjdwDxFuGND7tm2rfqPVyk10aWit9+Uy+UyMCWA42FZlmZMf0h3Xp+hI38tVrApEHrT6VS7lCy9VLpC9015yMjT6gAAAAAAwCwW5QAAAMAJePyPT+l3z72u9gNz5IiMCrlnB4M6um6Jcgf11fNPz5TDwVt04HS4feIE/ef9d+nI+wVqavSG3LMsS+0uSVP55p26acJtCgRCX8ADAAAAAABzuAsHAAAAHAfbtnXP/Q/q9aVr1a5fpiyHM+RmMODXkb8W6d6bRmvalAdlWZaBSQGcrFGZGXpl5qOq/3OB/PWHjTRj+qRq41G3RuZcL4/HY6QJAAAAAKeCZYfPATQHFuUAAADAD/D7/bph/ARVbt2n2IuHGFloN/kadGRtgX4/5V7l33KzgSkBmDAwNVVFr7+sxg9L5Du4z0gz5kd9tbNdD12bOVr79+830gQAAAAAAKFhUQ4AAAB8j/r6emWMydM/vO0V06u/kaa//pDq/1yo155+XBnpw400AZjTp08fLS0ukPMfy9Wwt8ZIMzqxp46cM0BpmaNVXWOmCQAAAAAATh6LcgAAAOA71NbWKi1jtHbH91b0ORcYaXoP7FVgXZlK33pV/VNSjDQBmJeUmKjl7xSrw1fr1LBzq5Fm9BlJsvsO04icG7R588dGmgAAAAAA4OSwKAcAAACOYfv27Ro6MlsNPQYqulsPI03v3mpFbqnU0uJCJScnG2kCOHXi4+O1rKxIZ/tq1PDFBiNNV1xnuVJGK+/WSVq5eo2RJgAAAAAYY4fBATQTFuUAAADAv/joo4/U78qfSn2Hyd050UizYcenit/1kSreKVG3bglGmgBOPbfbrZIFb+knnS3Vf/K+bDv0uzYR0e0UOyhP19+cr2dfeNHAlAAAAAAA4ESxKAcAAAD+j4rKFbph0i/V4fz+2r260EjT8/l6ndu0W+VlRYqLizPSBNB8nE6n5jw/W1mX99LRj8pl28GQm7UflCvqjG6a/XaJZj3znIEpAQAAAADAiWBRDgAAAPx/by0o0J2/naF2V+Wp008GK6bb2dq5/I2T7tm2rfqPVyk10aWit9+Uy+UyOC2A5mRZlmZMf0h3jh2hI38tVrApcNKtuqqV8h3co4QhY9UuNUsvLV6h+6Y8ZORpdQAAAAAAcHxYlAMAAACSHv/jU5rx/Otqf2WOHJFRkqTO/YfLiojUnj+XnXDPDgZ1dN0S5Qy8UM8/PVMOB2+9gdbg9okT9J/336Uj7xeoqdF7wtcf+Gy9Dn2xUUnDb5blcMqyLMX+JE1LP9mpmybcpkDg5BfwAAAAABAKy7bD5gCaA3frAAAA0KbZtq177n9Qc5etVbsBmbIczq9fsyxLCYNz5Tu4R3UbVh53Mxjw68hfi3TPz0Zp+tTJsizrFEwO4HQZlZmhV2Y+qvo/F8hff/i4rzuy85+q+6hS3TMnfP0Hcv5HzI9TVeVxaWTu9fJ4PKZHBgAAAAAA/4JFOQAAANosv9+vG8ZPUMXntYq9dMgxF9qWw6mk9Jt16MuNOvDZ+h9sNvkadGRtgX4/5V5NvHX8KZgaQDgYmJqqotdflv/DUvkO7vvB873792j3moXqnjlBEe7YY54T0+Mi7YjroWtHjtb+/ftNjwwAAAAAAP4PFuUAAAAIP5bj24dh9fX1GpGdp48b2yumT8r3nuuIiFL3zAmq+6hSR3Z8/p3n+esPqf7PhXrt6ceVkT7c9MgAwkyfPn20pHiBnP9Yroa9Nd95XmP9YdWUv6ruw29WVPuO39uMTuqpI+cOUFrmaFXXfHfzpDXD91cAAAAAAFoCfiIGAABAm1NbW6u0jNHa3am3os+94LiuiXDHqnvmBO1+f5Ea6nZ963Xvgb0KrCtT6Vuvqn/K9y/eAbQeSYmJWv5OsTp8tU4NO7d+6/VgY6Oq33leiUPy5OqccFxN95lJsi8ZphE5N2jz5o9NjwwAAAAAAMSiHAAAAG3M9u3bNTQrW55eAxWd2OOEro1q31Hdh9+sHcvmqvH/fC6xd2+1IrdUamlxoZKTk02PDCDMxcfHa1lZkc721ajhiw1ffz0YDGrb4mfUNXWYYk70+02HzopKHa3cCZO0cvUawxMDAAAAwDHYYXQAzYBFOQAAANqMqo0bNSLvRunS4XJ3TjyphqtzghKH5Kn6necVbGxUw45PFb/rIy1fXKxu3Y7vaVEArY/b7VbJgrf0k86W6j95X7Ztq+bdF9Xp/BS163HRSTUjYtqp3VV5uv3B6SpYVGR4YgAAAAAA2jYW5QAAAGgTKipX6PqJd8o1MFtRcZ1CasUk9lBCarq+KJqpc5t2q7ysSB06dDA0KYCWyul0as7zs5V1eS9tL5qpmITu6tB3UEhNR6RL7a/M1cNPv6yZs581NCkAAAAAAIg43QMAAAAAp9q8+Qv0u6dfVLur8uSIjAq5Z9u2rPr9GnzVIM1//VU5HPz5UwD/zbIszZj+kBwOaeF77ysYCMgREdqP3pbTqXapWXr5nQrt/Oor/f53/yHLsgxNDAAAAABA28QdPQAAALRqj//xKf3uhTfU7socM0vyYFD1HyxR9oALtOCN11iSAzimR377kP7zvjt1dE2BmnzekHuWZSn2J2kq/2SnbppwmwKBgIEpAQAAAOB/WXb4HEBz4K4eAAAAWiXbtnXP/Q9q7rK1ajcgU5bDGXIzGPDr6Noi3XPjKD08dTJPdAL4XqMyM/TKHx6VZ02B/PWHjTSjf5yqjQ1uZeaMlcfjMdIEAAAAAKAtYlEOAACAVsfv92vczRNU8XmtYi8dYmSh3eRr0NHVBfr95Hs18ZbxoQ8JoE0YmJqqotdflv9vpfId2GekGX1uX+3scJ6GZo5WXV2dkSYAAAAAAG0Ni3IAAAC0KvX19RqRnad/+Nsrpk+Kkab/6CF51hTqtaceV0b6cCNNAG1Hnz59tLRogSI2L5d3T42RZnRSTx3tMUBDR45RdY2ZJgAAAAAAbQmLcgAAALQatbW1SssYpd2deiv63AuMNL0H9irw9zKVzntV/VPMLN4BtD1JiYlavrhYHWrWqWHHViNN95lJsi8ZpvSccdq0abORJgAAAIA2zA6jA2gGLMoBAADQKmzbtk1pI8fI02uQohN7GGl691Qr6uNKlRcXKjk52UgTQNsVHx+vZWVFOsdTo4bPNxhpRnXoLFfqGOXl366Vq9cYaQIAAAAA0BawKAcAAECLV7Vxo0bk/UzWT9Ll7pxopNlQ/ak67vhIyxcXq1u3BCNNAHC73SpZ8JYu62TJs/l92Xboj0pExLRTu6vydPuD01WwqMjAlAAAAAAAtH4sygEAANCiVVSu0LiJd8o9KFtRcZ2MNBs+W68e/t0qLytShw4djDQB4H84nU7NeW62si7rpfoPy2XbwZCbjkiX2l+Zq4efflkzZz9rYEoAAAAAAFo3FuUAAABoGSzHt4558xfort/OUOxVeYqIjg35f8K2bXk2rlL/Li4Vvf2mXC6XgcEB4Nssy9KM6Q/pztx0HVlbrGAgEHrT6VS71Cy9/M5K/WbyQ0aeVgcAAADQdlh2+BxAc2BRDgAAgBbp8T/O0u9eeEPtrsyRIzIq5J4dDKr+gyXKTr1QL86eKYeDt8oATr3bb8vXo/fdpaOrC9Tk84bcsyxLsT9J07JPd+pnE25TwMACHgAAAACA1oi7fwAAAGhRbNvWL39zv+aWr1W7AZmyHM6Qm8GAX0fWFumeG0fp4amTZVmWgUkB4PiMyszQK398VJ41BfLXHzbSjP5xqjY1uJWZM1Yej8dIEwAAAACA1oRFOQAAAFoMv9+vcTffosp/1ir20sFGFtpNvgYdXV2gxyffq4m3jA99SAA4CQNTU1X0+svy/61UvgP7jDSjz+2rnR3O09DM0aqrqzPSBAAAAACgtWBRDgAAgBbhwIEDSh+VrU/87RXTJ8VI03/0kDxrCvXaU48rI324kSYAnKw+ffpoadECRWxeLu+eGiPN6KSeOtpjgNIyR2vL1q1GmgAAAAAAtAYsygEAABD29u3bp59el671mzYr6uzeRpreA3sV+HuZSue9qv4pZhbvABCqpMRELV9crA4169Sww8xi231mkvYc8eqaYRnatGmTkSYAAACAVsgOowNoBizKAQAAENa2bdumoSNHy750qM687KeqKX5ewWAwpKZ3T7WiPq5UeXGhkpOTDU0KAGbEx8drWVmRzvHUyPP5hpB7e1YVKbJ9B3UdNUl5EyZp5arVoQ8JAAAAAEALx6IcAAAAYWvDhg0akXeD7MvT5TojUe3PT1G7c3prV/nrJ91sqP5UHXd8pIp3StStW4LBaQHAHLfbrZIFb+nyTpY8m9+XbZ/cIxW1HyxX49GDOvOn2YqIaaeYn+bp9genaUHhQsMTAwAAAADQsrAoBwAAQFhaXlGpcb+4U1FXZCsqrtPXX4/vlyZndKz2rFp0ws2Gz9arh3+3ysuKFBcXZ3JcADDO6XRqznOzlXVZL9V/WC7bPrHfpnHgk7/raPUWdRt+kyzHf//474h0KfbqXP37My9r5uxnTsXYAAAAAAC0CCzKAQAAEHbmzV+gu6b9h2KuzlNEdOw3XrMsS2dek63Go4dU+8F7x9WzbVuejas0oKtLRW+/KZfLdSrGBgDjLMvSjOkP6c68ETqytljBQOC4rjuy/VPtr1qjpJG3yhER+c2m06mYgVl66Z0V+s3kqSf9tDoAAACA1sWyw+cAmgOLcgAAAISVx2fO0u9emKvYq3LkiIw65jmW5VC34T/X0eqtOvCPv31vzw4GVf/BEmWnXqgXnp4ph4O3wABantsnTtCj992lo6sL1OTzfu+5nn07tWdNmc4amS+nK/qY51iWpZjL0rT005362a35ChznAh4AAAAAgNaCu4QAAAAIC7Zt65f33a/XytcqJjVTlsP5vec7IiKUNPJW7d+4Vke2f3rMc4IBv468X6R7bhylh6dOlmVZp2J0AGgWozIz9MofH5VnTYH89YePeU7j4YPaWf6GkjLGK7Jdhx9sRp8/QBu9bmVk58nj8ZgeGQAAAACAsMWiHAAAAKed3+/XuJtvUeU/axXzk8HHvdB2uqJ11sh87Xm/TJ59O7/xWpOvQUdXF+jxKfdq4i3jT8HUAND8Bqamquj1l+X/a4l8B/Z947WAz6vqxS8q6dpxcnXqctxNd4++2tmxh4ZmZKmurs70yAAAAAAAhCUW5QAAADit6uvrNWJ0jj4OtJf7xyknfH1kuzgljRivnUvfUOPhA5Ik/9FD8qwp1GtPPa6M9OGmRwaA06pPnz5aWlygiM3L5d1TI0kKBgOqLnpGXa/MkDvhnBNuupN66nDPAUrLHKXqmhrTIwMAAABoCewwOoBmwKIcAAAAp01tba2GjBipXWf2lvvcC0664+rURUnXjVN12Yuq312twN/LVDrvVfVPOfHFOwC0BEmJiVq+uFgdatbJU71FNSUvqPOlVyr2R+efdNN9ZpKCPxmm9Oyx2rRpk8FpAQAAAAAIPyzKAQAAcFps27ZNaZmj5Ok9SO7EHiH33AnnqOMFKTry/iKVFxcqOTnZwJQAEL7i4+O1rKxI7XdsUER0rNqfH/ofDorq0FmRg8Yob8IkrVy12sCUAAAAAACEJxblAAAAaHZVVVUakXeD7MvT5Toj0UjTW71FZ9mHtenDv6lbtwQjTQAId263W2sqlmlo/0vVsOl92Xbov6MwIqadYn6ap9sfnKaChYsMTAkAAAAAQPhhUQ4AAIBmVVG5QtffdoeirshWVFwnI82Gret1XuNulZcWKS4uzkgTAFoKp9OpOc/N1qjLesnzQblsOxhy0xHpUuzVuZr+9EuaOfsZA1MCAAAAaAks+/QfQHNhUQ4AAIBmM2/+At350COKuTpPEdGxIfds25anapUGdnWr6O15crlcBqYEgJbHsizNmD5Nd+VlqH5NsYKBQOhNp1Oxg7L00jsr9JvJU408rQ4AAAAAQLhgUQ4AAIBm8fjMWfrdC3MVe3WOHJFRIffsYFCevy1RbmpfvfD0LDkcvLUFgNsn5uvR++5W/aoCNfm8Ifcsy1LMZWla+ukO/ezWfAUMLOABAAAAAAgH3E0EAADAKWXbtn553/16rXytYlIzZTmcITeDAb/q1xTp3hvH6OGpU2RZloFJAaB1GDUyU3P++F/yri6Qv/6wkWb0+ana6HUpIztPHo/HSBMAAAAAgNOJRTkAAABOGb/fr3E336KKf+5TzE8GG1loN/kaVL+yQI9P+ZUm3jo+9CEBoBUamJqqotfnqOkvpfId2Gek6e5xkXZ27KGhGVmqq6sz0gQAAAAA4HRhUQ4AAIBTor6+XiPG5OrjQHtF/7i/kab/6CF5VxVq7tNPKiM93UgTAFqrPn36aGlRgSI3Lpd3T42Rpjuppw73HKC0zNGqrjHTBAAAABAmbDt8DqAZsCgHAACAcbW1tRoyYqR2ndFL7nMvMNL07d+r4N/KVPrWXPVPSTn2SZbj2wcAtEbH+f0uKSlJFe+UquP2dfLWbDXyP+0+M0nBn1yn9Oyx2rRpk5EmAAAAAADNjTuHAAAAMGrbtm1KyxwlT+9Bcif2MNL07qmWa3OlyosXKjk52UgTANqK+Ph4LVtcoh/V71DDZxuMNKM6dFbkoDHKmzBJK1etMtIEAAAAAKA5sSgHAACAMVVVVRqRd4Psy9PlOiPRSNNbvUWdaz7S8ndK1a1bNyNNAGhr3G63SgreVr+Olho2vS/bwK8yjIhpp+ir8zTpwekqWLjIwJQAAAAAADQfFuUAAAAwoqJyha6/7Q5FXZGtqLhORpoNW9frvMbdKi8rUYcOHYw0AaCtcjqdmvP8sxp1WS95PiiXbQdDb0a51O7qXE1/+iXNnP2MgSkBAAAAnC6WHT4H0BxYlAMAACBk8+Yv0J0PPaKYq/MUER0bcs+2bTVUrVZqF5eK3p4nl8tlYEoAgGVZmjF9mu7KHaH6NcUKBgKhN51OxQ7K0kvvVOo3k6caeVodAAAAAIBTjUU5AAAAQvL4zFma8fxcxV6dI0dkVMg9OxiU529LlJN6oV6c/ZQcjhDfslqObx8A0NIY/j52+20T9ej9d8uzulBNPm/o41mWYi4bqqWf7tBNEyYqYGABDwAAAADAqcRdQgAAAJwU27aVc/0NenlxpWIHZspyOENuBgN+1b9fpHtvHKOHp06RZVkGJgUAHMuozEy98ofH5F1dIH/9YSPN6PNTtcETqf5XXiWPx2OkCQAAAADAqcCiHAAAACfM7/dr3M23aN3O/ar752bZTf6Qm02+BtWvLNDjk3+libeOD31IAMAPGpiaqqLX56jpL6XyHdhnpHng4w+0T26lZWSprq7OSBMAAABAM7DD6ACaAYtyAAAAnJD6+nqNGJOrzcH26nzNKJ3ZP001i55XMBg86ab/6CF5VxVq7tNPKiM93eC0AIAf0qdPHy0tKlDkxuXy7qkJqbVn+QJFxp+hLkPzdLjXAKWNHKXqmtCaAAAAAACcCizKAQAAcNxqa2uVlpGlr7r2lrvHBZKk2N6XqkPvi7XrnTkn1fTt36umv5ap9K256p+SYnLc78ZnlgPANyQlJaninVLFb/9Q3pqtJ9Wo/csSNfl96vzTkZIkd5ckNV02TMOzx2rTpk0mxwUAAAAAIGTcFQQAAMBx2bZtm9IyR+nojwfKnXjuN17rcNnViup4hnYvX3BCTe+eark2V2pZyUIlJyebHBcAcILi4+P13uJS/ah+hxo+33BC1+6v+rM8u7ap6/AbZP2fP4AUFd9ZkVeNUV7+7Vq5apXhiQEAAAAAOHksygEAAPCDqqqqNGLsjQr2HyHXGYnHPKfz1SMV9PtU+5clx9X0Vm9R55oNWv5Oqbp162ZyXADASXK73SopeFv94i15N6+Vbf/whwMe+nyzDn3yNyVm3SqHM+Jbr0fEtFP0Nbm6fcrDWrBw0akYGwAAAIABVjB8DqA5sCgHAADA96qoXKHrb7tDkVeNUVRcx+88z7IcShh+ozy7tml/1Z+/t9mwdb3Oa9yt8rJidejQwfTIAIAQOJ1OzXn+WWX9JFmeD8pl2999l6p+1zbV/XWJzhqVL2eU6zvPc0S5FPPTHD08+yXNnP3MqRgbAAAAAIATwqIcAAAA32ne/AW687ePKHpwniKiY3/wfMvpVGLWrTr8yd916PNvfx6tbdtq2LhGqV1cKnp7nlyu716qAABOH8uyNGP6NN2VO0L1a4oVDAS+dY7vUK12vzdfSVm3KiK2/Q83nU7FXJmlF9+t1G8mTz2up9UBAAAAADhVWJQDAADgmB6fOUszXpyrmGty5IiMOu7rnFEuJY2aoLq/LlX9rm1ff90OBuX52xLlDLhAL85+Sg4Hb0UB4Jgsx7eP0+T22ybqP++7W57VhWryeb/+esBbrx2lrygx/WeKiu983D3LshTTb6iWbtmhmyZMVOAYC3gAAAAAAJoDdycBAADwDbZt6577HtBry9YqZlCmLIfzhBsRse2VlHWrdr83X76D+xQM+FX/frHuvXGMHp46RZZlnYLJAQCnwuiRmXrlD4/Ju7pA/vrDCgYaVbPoOXUbPFrurmedVNN9Yao2+FzKyM6Tx+MxPDEAAAAAAD8s4nQPAAAAgPDh9/t104SJ2uyxFH354JBaUfGdlZj+M+0sm6MzuiXpyYenKCM93dCkAIDmNDA1VUWvz1H2TbdoZ91+ndl/iKLP6RVS031eX+3YEa20jCwtLpyvzp2P/8l0AAAAAKeA/f+P0y0cZkCbwBPlAAAAkCTV19drxJhcbQ62l/v8/kaaztg4dYjvoN8/dD9LcgBo4fr06aN3Ct5ShxiXnPFnGGm6z+qpw70GKG3kKFXX1BhpAgAAAABwPFiUAwAAQLW1tUrLyNJXXXvL3eMCI03f/r2y/1yq8qJCZY0caaQJADi9zj33XH34/mp1+nKdvNVbjTTdXZLUdNkwDc8eq02bNhlpAgAAAADwQ1iUAwAAtHHbtm1TWuYoHf3xQLkTzzXS9O2ulntjpcqLFyo5OdlI85SyHN8+AKA5tMDvP/Hx8VpWVqJzj+6Q97MNRppR8Z0VedUY5eXfrpWrVhlpAgAAAADwfcL/J3AAAACcMlVVVRqRd4OCKelynZFopOndvkWdqzdo+eJSdevWzUgTABBe3G63Sha8rX5xlrwb18q2Q/8QwYiYdoq+JleTJk/XgoWLDEwJAAAA4ERYdvgcQHNgUQ4AANBGVVSu0PW33aHIq7MV1aGTkaZ3y3r19O5WeWmxOnToYKQJAAhPTqdTc55/VqMuTVbD38pl28GQm44ol2KvydXDs1/SzNnPGJgSAAAAAIBjY1EOAADQBs2bv0B3/vYRRQ/OU0R0bMg927bVsGGNUs9wqejteXK5XAamBACEO8uyNGP6NN2VM0KeVcUKBgKhN51OxVyZpRffrdSvJ0818rQ6AAAAAAD/ikU5AABAG/P4zFma8eJcxVyTI0dkVMg9OxhUw1+XKLf/BXpx9lNyOFrJW8xjfW5wC/scYQBhqJV+H7n9ton6z9/crYYVhWryeUPuWZalmH5DVb5lh352a74CBhbwAAAAAAD8X63np3IAAAB8L9u29cv77tdry9YqZlCmLIcz5GYw4JdnVZHuHTdGD0+dIsuyDEwKAGiJRo/M1Ct/eEzeFQXy1x820nRfmKqqRrcysvPk8XiMNAEAAAB8B9sOnwNoBizKAQAA2gC/369xN9+iii/3KfrywUYW2k2+BnkqC/T45F9p4q3jQx8SANDiDUxNVfHrcxRcWyrfgX1Gmu7z+mpH5x5Ky8hSXV2dkSYAAAAAACzKAQAAWrn6+nqNGJOrzcH2cp/f30jTf/SQfCsKNfepJ5WRnm6kCQBoHfr06aOliwrk+mi5vLtrjDTdZ/XU4V4DlDZylKprzDQBAAAAAG0bi3IAAIBWrLa2VkMyRuqrLr3k7nGBkaZv/14F15apdN5c9U9JMdIEALQuSUlJWv5OqTp++aG81VuNNN1dktR02TANzx6rTZs2GWkCAAAAANouFuUAAACt1LZt25SWOUr1Px4kd1IPI03f7mq5N1ZqWclCJScnG2m2aJbj2weAtulY3w/a+PeI+Ph4vbe4VOce3SHvZxuMNKPiOyvyqjHKy5+klatWGWkCAAAA+G+WHT4H0Bza1k/pAAAAbURVVZVG5N2gYEq6XGckGml6t32qztUbtHxxqbp162akCQBo3dxut0oWvK1+cZa8G9fKtkO/4xUR007R1+Rp0uTpWrBwkYEpAQAAAABtEYtyAACAVqaicoWuv+0ORV6dragOnYw0vVvWq6dvj8pLi9WhQwcjTQBA2+B0OjXn+Wc16tJkNfytXLYdDLnpiHIp9ppcPTz7Jc2c/YyBKQEAAAAAbQ2LcgAAgFbkzbffVvYNNypywHBFRMeG3LNtWw0bViv1DJeK3p4nl8tlYEoAQFtjWZZmTJ+mu3JGyLO6RMFAIPSm06noKzL1yGO/16S7f2nkaXUAAAAAQNvBohwAAKCVeHzmLP3upTfULX2cdpa8omBjY0g9OxhUw1+XKLf/hXpx9lNyOHjrCAAIze23TdSjv7lLDSsK1eTzhtzbVfySOl9+ldbsPKif3ZqvgIEFPAAAAACgbeBuJwAAQAtn27Z+ed/9evW9tYq+MlMxZyeryxXDVFP4jILBk/v1tsGAX55VRbp33Bg9PHWKLMsyPHUrZjm+eQBonfh3/aSNyszUK394TN4VBfLXHz7pzu4l8+RO6K64SwbJ3TdVGxpdysjOk8fjMTgtAAAA0MbYYXAAzYSf5gEAAFowv9+vcTffouVf7lN0v8FfL7Rjki9Sx74p2lX04gk3m3wN8lQW6PHJv9LEW8cbnhgAAGlgaqqKX5+j4NpS+Q7sO+Hra1cvlixLHa9I//pr7uSLVHNGD6VlZqmurs7kuAAAAACAVohFOQAAQAtVX1+vEWNytdluL/eF/b/1evtLBsnd7Wzt/tObx930Hz0k34pCzX3qSWWkp//wBQAAnKQ+ffpo6aICuT5aLu/umuO+bv+6lfLW7lKXYWO/9RtP3N176lCvAUrLHKXqmuNvAgAAAADaHhblAAAALVBtba2GZIzUzq695Drvgu88r+MVwyWHQ/tWl/1g07d/r4Jry1Q6b676p6SYHBcAgGNKSkrS8ndK1fHLD+Wt3vqD5x/69CMd2VqlblnjZTmcxzzH3TVJgZRhGp4zVps2bTI9MgAAAACglWBRDgAA0MJs27ZNaSNH6ej5g+Q+q8f3nmtZlroMGytf7W7tX7fyO8/z7a6We2OllpUsVHJysuGJ27h//Rzj7zoAhAf+nW128fHxem9xqc49ukPerRu+87z6mn9q/98rlDgmX47IqO9tRsV3VsTVY5SXP0krV60yPDEAAADQOll2+BxAc+CnewAAgBakqqpKI/JuUFP/dLnOTDyuayyHU92yxuvI1o069Mn6b73u3fapOm3/SMsXl6pbt26mRwYA4Ae53W6VLHhb/TpY8m58X7b9zTtj3ro92rN8oZLGTFBEdOxxNSNi2sk9JE+TJk/XgoWLTsXYAAAAAIAWjEU5AABAC1FRuULX/+IORVyTragOnU7oWkdklJLGTND+DypVX/PPr7/u3bJePX17tKysRB06dDA9MgAAx83pdGrO889q1KW91PC3ctl2UJIUOHpYX5W9qsSRNykyruMJNR1RLsUMydXDz7ykmbOfORVjAwAAAABaKBblAAAALcC8+Qt057RH5B6Sd9xP0v0rZ3SsksZM0J6KhfLW7VHDR6uUeoZLRW/Pk8vlMjwxAAAnzrIszZg+TXfljJBnVbGaGjyqWfS8ul2Xe9y/SeVbTadT0Vdl6cU/VerXk6d+62l1AAAAAEDbxKIcAAAgzD0+c5ZmvDhX0YNzfvAzWX9IZFxHJWbcpB2LXlDugL56cfZTcjh4SwgACC+33zZRj953t7bP+4M6pwyW+6zzQupZlqXolKFaunWHfnZrvgKBgKFJAQAAgFbEtsPnAJoBd0UBAADClG3buue+B/Tqe2sVfWWmLIcz5GYw4Fdg85/1u4en6+GpU2RZloFJYYTl+OYBoHnw717YGpWZqcI3X5dz+z8UOHrYSNPdN1VVfrcycvLk8XiMNAEAAAAALRN3AQAAAMKQ3+/XuJtv0Xtf7lV0v8FGFtpNvgY1LC/QEw/+SndM+oWBKQEAOLWGDB6s4tfnKPh+qXz79xlpunr2VU3nHkrLzFJdXZ2RJgAAAACg5WFRDgAAEGbq6+s1YkyuNtvt5b6wv5Gm/8ghNVYUau5TTyojPd1IEwCA5tCnTx8tXVQg10fL5d1dY6Tp7t5Th3oNUFrmKFXXmGkCAAAAAFoWFuUAAABhpLa2VkMyRmpn115ynXeBkaavbq+0tkyl8+aqf0qKkSYAAM0pKSlJFYtL1fmLdfJu32qk6e6apEDKMA3PGatNmzYZaQIAAAAtmWWHzwE0BxblAAAAYWL79u1KGzlaR88fJPdZPYw0fbuqFV1VqfLihUpOTjbSBADgdIiPj9eyshL1OLJDvq0bjDSj4jsr4uoxysufpJWrVhlpAgAAAABaBhblAAAAYaCqqkrpeTeoqf9wuc5MNNL0bvtUZ2zfoOWLS9WtWzcjTTQjy3F8B4Bj49+hVsntdqtkwdvq196St2qtbDv0R00iYtrJPSRPkyZP14LChQamBAAAAAC0BNwVAAAAOM0qKlfo+l/coYifjlFUh05Gmt5P1yu5YY/KS4vVoUMHI00AAMKB0+nUnOef1ehLktXw13LZdjDkpiPKpZghuXr42Zc1c/YzBqYEAAAAAIQ7FuUAAACn0bz5C3TntEfkHpKniOjYkHu2bcv70WoN7OxS0dvz5HK5DEwJAEB4sSxLM6ZP093ZI9SwskTBQCD0ptOp6Kuy9OKfKvXryVONPK0OAAAAAAhfLMoBAABOk8dnztKMF+cqenCOHJFRIffsYFDePy9RbsqFenH2U3I4eKsHAGjdbr9toh79zV3yVhaqyecNuWdZlqJThmrp1h362a35ChhYwAMAAAAthh1GB9AMuHsKAADQzGzb1j33PaBX31ur6CszZTmcITeDAb88K4t077gxenjqFFmWZWBStAjH+znMfC4zWjL+Gcf3GJWZqVeefEy+igIFjh420nT3TVWV362MnDx5PB4jTQAAAABAeOHuAQAAQDPy+/0aN/5WvfflXkX3G2xkod3ka1DD8gI98eCvNPHW8aEPCQBACzMwNVXFr89R8P1S+fbvM9J09eyrms49lJaZpbq6OiNNAAAAAED4YFEOAADQTOrr6zViTK422+3kvrC/kab/yCE1VhRq7lNPKiM93UgTAICWqE+fPlq6qECuj5bLt7vGSNPdvacO9RqgtJGjVF1jpgkAAAAACA8sygEAAJpBbW2t0jKytLNrb7l6XGCk6avbK60tU+m8ueqfkmKkCQBAS5aUlKSKxaXq9MU6ebdvNdJ0d01SoN8wDc8Zq02bNhlpAgAAAOHIssPnAJoDi3IAAIBT7MMPP9RP0zN05PyBcp91rpGmb1e1oqsqVV68UMnJyUaaAAC0BvHx8VpWVqIeR3bIu2WDkWZUfGdFXD1GubfepnlvvWWkCQAAAAA4vViUAwAAnEJVVVW68Rf/pq927ZblijHS9G77VGds36CKd8rUrVs3I020QZbj5A4gFPxzh2bidrtVsuBtpcRZ8latlW2H/kiKw+1WXV2tHvzdf2l+4UIDUwIAAAAATifuOAAAAJwiFStW6Ppf3CH3tWPVbcT1+mrhCwp4vSE1vZ+uV3LDHpWXFisuLs7QpAAAtD5Op1Nznn9Woy9JVsNfy2XbwZNuBYNBfVXwgjr95AqdmXOb/v25lzVz9jMGpwUAAAAANDcW5QAAAKfAvPkLdOdvH5F7aJ4iomPlTvyRulyTqZ0FzygYDJxwz7ZteT9arYGdXSp6e55cLtcpmBoAgNbFsizNmD5Nd2ePUMPKEgUDJ/7fYEna++4biv1Rstpd1F+W06noq7P04pJK/XryVCNPqwMAAABhIWiHzwE0AxblAAAAhj0+c5ZmvDRX0Wk5ckRGff31mPPOV+fLrtRXBS8oGDz+p9rsYFDePy9RbsqFenH2U3I4eAsHAMCJuP22iXr0N3fJW1moJt+J/XaXfZXFcrqiFZ869OuvWZal6P5DtfSzHfrZrfkKnOQCHgAAAABw+nCXFQAAwBDbtnXP/Q/o1eVrFX1VpiyH81vntOubonY/Stbed944rmYwEJBnZZHuHTdGD0+dIsuyTI8NAECbMCozU688+Zh8lYUK1B85rmsO/K1C/sMHdMa1Ocf8b7D7olRVBdzKyMmTx+MxPTIAAAAA4BRiUQ4AAGCA3+/XuPG36r1texWdMvh7F9odUofKGR2jfRVF39ts8jWooaJATzz4K028dbzhiYGTZDnMHGg5TP095+87wsDA1FQVz31FwTUl8u3f973nHtz8gY5+8YkSRt4k63t+m4srua9qzuyhtMws1dXVmR4ZAAAAAHCKcKcCAAAgRPX19RoxJleb7Fi5L+z/g+dblqUzhmbLf+Sg9v91+THP8R85pMaKQs2d9YQy0tNNjwwAQJvVp08fLV1UINf65fLtrjnmOUe+3KJD61crMXuCHBGRP9h0d++pQ30GKC1zlKprjt0EAAAAwp4dRgfQDFiUAwAAhKC2tlZpmVnamdBL7p4XHvd1lsOhhJE3qX7bpzq06e/feM1Xt1daW6bSeXPVPyXF9MgAALR5SUlJqninVJ2+WCfv9q3feM27d6dqV5YqMTtfTnf0cTfdXZMUGDBMw3PGatOmTaZHBgAAAAAYxqIcAADgJG3fvl1pWaN15PyBcnfvccLXOyIilThmgg5+9L6OfPmpJMm3q1rRVZUqL16o5ORk0yMDAID/Lz4+XsvKStTjyA55t2yQJDUePqhdi99Q4qibFdm+wwk3o+I7K+KaMcrLn6SVq1YZnhgAAAAAYBKLcgAAgJNQVVWl9Lwb1DRguFxdEk+643RHKzF7gmpXlunQ+vd1xvYNqninTN26dTM4LRCGTH7uNcepPYBWzO12q2TB20qJs+RZt1JfLXxR3UZcL1fnrifdjIhpJ/fQPE2aMl0FCxcZnBYAAAAAYBJ3PQAAAE5QxYoVuv4Xdyhi8BhFdegUci+yfQd1uuAn6nygRuWlxYqLizMwJQAAOB5Op1Nznn9W/bu2V+yZXeTqdnbITUeUSzFpuZr+7EuaOfsZA1MCAAAAAExjUQ4AAHAC5s1foDt/+4jcQ/MUER0bcs+2bTWsX6XB5yXqL6tWyOVyGZgSAACcCMuy9NrLL2ny7fnyVBYrGAiE3nQ6FX11ll5cUqlfT54q27YNTAoAAACcOpYkyw6D43T/hUCbwaIcAADgOD0+c5ZmvDRX0Wk5ckRGhdyzg0F51y7R2JSL9MJTs+Rw8NYMAIDT6fb8fD32m7vV8F6BmnzekHuWZSm6/1At/WyHfnZrvgIGFvAAAAAAADO4GwsAAPADbNvWPfc/oFeXr1X0VZmyHM6Qm8GAX57KIv1qXLamT5ksy+LPygIAEA5GZWZqzh/+S77lBQocPWyk6b4oVRsCLmXk5Mnj8RhpAgAAAABCw6IcAADge/j9fo27+Ra9t22volMGG1loN3kb1PBegZ548FfKv+VmA1MCAACTBqamqnjuHAVXl8q3f5+Rpjv5ItWc2UNpmVmqq6sz0gQAAAAAnDwW5QAAAN+hvr5eI8bkapPayX1hfyNN/5FDaqwo1NxZTyojPd1IEwAAmNenTx8tXVQg17rl8u6qMdJ0d++pQ30GKG3kKFXXmGkCAAAAxtiSbDsMjtP9FwJtBYtyAACAY6itrVVaZpZ2JvSSu+eFRpq+ur3S+2UqfXOu+qekGGkCAIBTJykpSRWLS9X5n+vk3bbVSNPdNUmB/sM0PGesNm3aZKQJAAAAADhxLMoBAAD+xfbt25WWNVpHzh8od/ceRpq+r6oV/VGlyosWKjk52UgTAACcevHx8VpWVqIeh3fIu2WDkWZUfGdFXDNGefmTtHLVKiNNAAAAAMCJYVEOAADwf1RVVSk97wY1DRguV5dEI03vl1vUedtHqninTN26dTPSBAAAzcftdqtkwdtKaWfJu+F92XbovwsyIqad3EPzNGnKdC1YuMjAlAAAAACAE8GiHAAA4P+rWLFC1//iDkUMHqOoDp2MNL2frFeyZ7eWlZYoLi7OSBMAADQ/p9OpOc8/q9EX95L3L+Wy7WDITUeUSzFpuXr4mZc0c/YzBqYEAAAAQmBLVhgcfEY5mguLcgAAAEnz5i/QHb99RO6heYqIjg25Z9u2Gtav1qAz3Cp6e55cLpeBKQEAwOlkWZZmTJ+mu3Iy5KksVjAQCL3pdCr6p1l6cUmlfj15qpGn1QEAAAAAP4xFOQAAaPMenzlLM16aq5i0HDkio0Lu2cGgvGuXaGxKX73w1Cw5HLzlAgCgNbk9P1+P/eZueZcXqsnnDblnWZai+w/V0s926KYJExUwsIAHAAAAAHw/7toCAIA2y7Zt3XP/A3p1+VpFX5Upy+EMuRkM+NWwoli/uiFb06dMlmVZBiYFAADhZlRmpl558jH5lhcocPSwkab7olR95I9SRk6ePB6PkSYAAAAA4NhYlAMAgDbJ7/dr3M236L1texWdMtjIQrvJ2yDve4V6/IF7lT/+ZgNTAgCAcDYwNVUlr7+q4OpS+fbvM9J0J1+kmjN7KC0zS3V1dUaaAAAAwHGxw+gAmgGLcgAA0ObU19fr8kFX6u+1R+W+sL+Rpv/IITVWLNTcp55URnq6kSYAAAh/vXv3VnlRoVzrlsu7q8ZI0929p/b/6GJdlDJA1TVmmgAAAACAb2JRDgAA2pTa2loNyRgpT48LdXDzOjUeDP1JLV/dXun9MpW++ZpS+vUzMCUAAGhJEhMTVbG4VJ3/uU6+7VtD7gUDAdVWlij6J1dqeM5Ybdq0ycCUAAAAAID/i0U5AABoM7Zt26a0kaN0pO8gtb/wciWMvFE7F76sgKf+pJu+r6oV/VGllhUvUnJyssFpAQBASxIfH69lZSXqcXinvFs2nHQnGAxq5/xn1XnANYq7OEXOwWOUmz9JK1etMjcsAAAAAIBFOQAAaBuqqqqUPvYGNQ1Kl6tLoiTJnXCWEq4drZ0LnlMw0HjCTe+XW3TGtg2qeKdMCQkJpkcGAAAtjNvtVvH8t5TS3pJ3w/uy7RP/cMXdxa8qrndfxV5wmSQpIrad3NfladKU6VqwcJHpkQEAAACgzWJRDgAAWr2KFSs09hd3KGJItiI7dPrGa+4f9VLn1MHaOf95BYPB4276Pl2vZM9ulZcWKy4uzvTIAACghXI6nZrz3LMafXEvef9SLts+/vcXe5cWKCq+k+L6X/ONrzuiXIq+NlfTn31JM2c/Y3pkAAAAQJJk2XbYHEBzYFEOAABatXnzF+iO3z4i93V5ioiJPeY5sef/RHF9LtKe4jk/2LNtW971azSws1tFb8+Ty+UyPTIAAGjhLMvSjOnTdFdOhhpWlCgYCPzgNXXvL1WTr0Gd0rKO3XQ6FX1Nll5cUqnfTJl6Uk+rAwAAAAD+F4tyAADQaj0+c5ZmvDxX0dfmyBEZ9b3nxqX8VJEdz9DepQXfeY4dDMq7donGplyoF56aJYeDt1IAAOC73Z6fr0d/fZe8ywvV5PN+53kHP/qLGnZ8qa4jb5Rlfff7C8uy5E4dqiWf7dBN+RMVOI4FPAAAAADg2Li7CwAAWh3btnXP/Q/o1Yq1cl+dKcvhPK7rOg0ZqaZGr+rWLPnWa8GAXw0rivWrG7I1bcpkWZZlemwAANAKjcrM1CtPPibf8gIFjh7+1utHPtusQ5v+poTsW2Q5I46r6bo4VR/5o5SRkyePx2N6ZAAAAABoE1iUAwCAVsXv92vczbdo2fa9cvcffEILbctyqGvmDWrYuU0HP/rz119v8jbI+16hHn/gXuWPv/lUjA0AAFqxgampKnn9VQVXl8q3f9/XX/d8Va26NUuUmDtBTpf7hJquXheppksPpWVmqa6uzvTIAAAAaIuCYXQAzYBFOQAAaDXq6+uVPiZHG612cvftf1INyxmhbjm36tDGv+nw1s3yHzmkxoqFmvvUk8pITzc8MQAAaCt69+6t8qJCudYtl3dXjRoP1mnPn95Wt+xbFBHb/qSarrN76tD5A5Q2cpSqa2oMTwwAAAAArRuLcgAA0CrU1tZqSMZI7UzsLXfyhSG1HFEuJeblq27NnxRYUaTSN19TSr9+hiYFAABtVWJioioWl6rT5+u0s/BFJWTeoKiOZ4TUdHVNkj91mIbnjtWmTZsMTQoAAAAArR+LcgAA0OJt27ZNaSNH6UjfQXJ372Gk2XTogM5JSlTRm3OVnJxspAkAABAfH6+lJYt0ad++sg6b+ZXpUfGd5bxmjPImTtLKVauMNAEAAACgtWNRDgAAWrSqqiqlj71BTYPS5eqSaKTp+2KLzvyySquW/kl9+vQx0gQAAPgfsbGxWra4VP3bOeT7aK1s2w65GRHbTq5r8zRpynQVLFxkYEoAAAC0NZZth80BNAcW5QAAoMWqWLFC1//iDkUMyVZkh05Gmr5P1iu5frfKS4oUFxdnpAkAAPCvnE6nXnn2GY2+uJe8fy6XbQdDbjqiXIq+NlfTn31JM2c/Y2BKAAAAAGi9WJQDAIAWad78Bbrjt4/IdV2eImJiQ+7Zti3fujUa1MmtorfnyeVyGZgSAADgu1mWpRnTfqu7szPkrShRMBAIvel0yn1Nll5cUqlfT55q5Gl1AAAAAGiNWJQDAIAW5/GZszTj5bmKvjZHjsiokHt2MCjf+0s0tt+FeuGpWXI4eIsEAACaz+35+Xr013fJu6xQTT5vyD3LsuROHaqln+/QTfkTFTCwgAcAAACA1oa7wAAAoMWwbVv33P+AXq1YK/fVmbIczpCbwYBfDRXF+tW4bE2bMlmWZRmYFAAA4MSMyszUnCcfU+OyAgWOHjbSdF2cqo/8UcrIyZPH4zHSBAAAQCtmh9EBNAMW5QAAoEXw+/0ad/MtWrZ9r9z9BxtZaDd5G+RdVqgnHrhX+eNvNjAlAADAyRuYmqqS11+VvbJUjfv3GWm6el2kmi49NDQzS3V1dUaaAAAAANAasCgHAABhr76+XiOyc7XJ0V7uvv2NNP1HDsm/fKFen/WkMtLTjTQBAABC1bt3b5UXFcr1wXL5dtUYabrO7qmD5w9Q2sjRqq4x0wQAAACAlo5FOQAACGu1tbUakjFSO7r1kqvnBUaavrq9slaXqfSN15TSr5+RJgAAgCmJiYmqWFyqzp+tk2/bViNNV9ck+VOv0/Dcsdq0aZORJgAAAAC0ZCzKAQBA2Nq2bZvSRo7Skb6D5O7ew0jT91W1YtZValnxIiUnJxtpAgAAmBYfH69lZSXqcWinfFs2GGlGxXeW85oxyps4SStXrTLSBAAAAICWimDZ0e4AAGODSURBVEU5AAAIS1VVVUofe4OaBqXL1SXRSNP3xRad+WWVKt4pU0JCgpEmAADAqeJ2u1Uy/y31b+eQ76O1sm075GZEbDu5rs3TpCnTVbBwkYEpAQAA0HrYkh0Gh0J/3wscDxblAAAg7FSsWKHrf3GHIoZkK7JDJyNN3yfrlVy/W+UlRYqLizPSBAAAONWcTqdeefYZjb64l7x/LpdtB0NuOqJcir42V9Ofe0kzZz9jYEoAAAAAaHlYlAMAgLAyb/4C3THtEbmuy1NETGzIPdu25Vu3RoM6uVX09jy5XC4DUwIAADQfy7I0Y9pvdXd2hhoqShQMBEJvOp1y/zRLLy5dod9MnmrkaXUAAAAAaElYlAMAgLDxu98/rhkvz1X00Bw5IqNC7tnBoLzvL1Fevwv1wlOz5HDw1gcAALRct+fn67Ff3yXvskI1+bwh9yzLkntAmpZ8vkPjxt8in89nYEoAAAAAaBm4WwwAAE4727Z193336/d/+IOCPS6Q5XCG3AwG/GqoKNavx2Vr+pTJsizLwKQAAACn16jMTL36h/9S43uFChw9bKTpPO9ClVdUatjoMfJ4PEaaAAAAaHksO3wOoDmwKAcAAKeV3+/X9eNv0fKafep+893aV75Q3n17Qmo2eRvkXVaoJx/8lfLH32xoUgAAgPCQOmCASubOkb2yVI3794XUCjY2auf855WQkac9Z/9YaZlZqqurMzQpAAAAAIQvFuUAAOC0qa+v14jsXG1ytJfrov6K7NBRCaNv0u7i1xQ4euSkmv4jh+RfvlCvz3pSI4YPNzwxAABAeOjdu7fKiwrl/rBCvl01J9UIBoPa+dazOuPKa+U+u6dcZ/fUwQsGKC1rtKprTq4JAAAAAC0Fi3IAAHBa1NbWakjGSO1I7CVX8gVff93VJVFd07O1c/7zCjY2nlDTV7dX1uoylb05Vyn9+pkeGQAAIKwkJiZqeVmJOn+2Tr5tW0/4+t2FLyn+4ssV8+OLv/6aKyFJjanXaXjuWG3atMnkuAAAAAAQVliUAwCAZrdt2zaljRylwxcPkuvsHt963X12T51x1bXa+fazCgaDx9X0fVWtmHWVWla8SD179jQ9MgAAQFiKj4/XsrIS9Ti0U75PNxz3dXsXvyV31yS1u+yKb70W1bGzHEPGKHfiJK1ctcrgtAAAAAhrth0+B9AMWJQDAIBmVVVVpfSxNyhwRbpcXRK/87yYPhcr/qJ+2lPw0g82fV9s0ZlfbFDFO2VKSEgwOS4AAEDYc7vdKpn/lvq3d8j30fuyf+DGYt2KdyRLir9mxHeeExHbTq5heZo0dboKFi4yPTIAAAAAnHYsygEAQLOpWLFCYyfdoYih2YqM7/SD57e7bJBc3c7S3sXzvvMc3z/WK7l+t8pLixUXF2dyXAAAgBbD6XTqlWef0eiLe8v753LZ9rF/K8/BD1bJt/crnZExVpZlfW/TEeWS+7pcTXv2Jf1x9jOnYmwAAAAAOG1YlAMAgGYxb/4C3THtEbmG5ckZE3vc18X/NF2yLNWtWPyNr9u2Le+61RrU2a2it+fJ5XKZHhkAAKBFsSxLM6b9VndnZ6iholjBQOAbrx/+x0c68skGdc0ZL8vhPL6m0yn3kCy9tHSFfjNl6g8+rQ4AAAAALQWLcgAAcMo9PnOWZrw8V+7rcuSIjDqhay3L0hkZY+Xbu0sH//7fn5FpB4Pyvr9EY/v11QtPzZLDwVsaAACA/3F7fr4e+/Xd8i4rVJPPK0mqr/5CB/6yXN3y8k/q/ZhrYJr+9PkO3ZQ/UYF/WcADAACgdbCC4XMAzYG7ygAA4JSxbVv33P+AXq1cK9c1mcf95NK/shxOdc0ZryOfVunQpg/VUFGsX4/L1vQpk3/wV4YCAAC0RaMyM/XqH/5Lje8Vqr76n9q3tFDdciec0G/2+VeuS1K1PhCljJw8eTweg9MCAAAAQPNjUQ4AAE4Jv9+v68ffomXVe+UaMDjkhbYjMkpdsm5U3ap39eSDv1L++JsNTQoAANA6pQ4YoJK5c3SwfKE6/XS4IuM7hdx09b5I1Qk9lJaZpbq6OgNTAgAAAMDpwaIcAAAYV19fr/QxOdrkaC/XRf2NNP1HDsle8yctW1ymEcOHG2kCAAC0dr1799ZHf1mr+G3/kG9XjZGm6+yeOnjBAKVljVZ1jZkmAAAAADQ3FuUAAMCo2tpaDckYqZ1JveVKvsBI01e3V46VZSp7c65S+vUz0gQAAGgrEhMTtbysRGdsWSffl1uNNF0JSWpMvU7Dc8dq06ZNRpoAAAAA0JxYlAMAAGO2b9+utJGjdPjiQXKd3cNI0/dVtWI/qNSy4kXq2bOnkSYAAEBbEx8fr2VlJTrv4E75Pt1gpBnVsbMcQ8Yod+IkrVy1ykgTAAAAp5Fth88BNAMW5QAAwIiqqiqlj71BgSvS5eqSaKTp+2KLuvxzgyreKVNCQoKRJgAAQFvldrtVMv8tDYh1yLd+rWwDNyAjYtvJNSxPk6ZOV8HCRQamBAAAAIDmwaIcAACErGLFCo2ddIecaWMUGd/JSNP38Xr1OrJb5SXFiouLM9IEAABo65xOp1559hmNuaiXfO+Xy7aDITcdUS65r8vVtGdf0h9nP2NgSgAAAAA49ViUAwCAkMybv0B3THtErmF5csbEhtyzbVu+D9foik5uFb09Ty6Xy8CUAAAA+B+WZWnGtN/q7uwMeZeXKBgIhN50OuUekqUXl1bqN1OmGnlaHQAAAABOJRblAADgpD0+c5b+4+W5cl+XI0dkVMg9OxiUb/USjb38Qr3w1Cw5HLxVAQAAOFVuz8/XY7+6S77yQjX5vCH3LMuSe+BQ/enzHbopf6ICBhbwAAAAaEZ2GB1AM+DuMwAAOGG2beue+x/Qq5Vr5b4mU5bDGXIzGPDLu7xYvx6XrelTJsuyLAOTAgAA4PuMyszUq0/+l/zlhQocPWyk6bokVesDUcrIyZPH4zHSBAAAAADTWJQDAIAT4vf7df34W7Sseq9cAwYbWWg3eRvkW1qoJx/4lfLH32xgSgAAAByv1AEDVDJ3juwVpWrcv89I09X7IlUn9FBaZpbq6uqMNAEAAADAJBblAADguNXX12tEdq42OdrLdVF/I03/kUMKLFuo12c9qRHDhxtpAgAA4MT07t1byxYVyv235fLtqjHSdJ3dUwcvGKC0rNGqrjHTBAAAAABTWJQDAIDjUltbq7TMLO1I7CVX8gVGmr66vXKsLFPpG68ppV8/I00AAACcnMTERFUsLtUZW9bJt22rkaYrIUmNqddpeO5Ybd682UgTAAAAp4Zl22FzAM2BRTkAAPhB27dvV9rIUTp00UC5zu5hpOn7qlqxH1RqWfEiJScnG2kCAAAgNPHx8VpWVqLzDuyU79MNRppRHTvLMWSMcvJ/oZWrVhlpAgAAAECoWJQDAIDvVVVVpfSxNyhwRbpcXRKNNH1fbFGXf25QxTtlSkhIMNIEAACAGW63WyXz39KAWId869fKNvBET0RsO7mG5WnS1OkqWLjIwJQAAAAAEBoW5QAA4DvNfeMNZd34cznTxigyvpORpu/j9ep1ZLfKS4oVFxdnpAkAAACznE6nXnn2GY25qJd875fLtoMhNx1RLrmvy9XkP8zSL3/9GwNTAgAAAMDJY1EOAACOad78Bfrd8y/rSEODvLt3hNyzbVu+D9foik5uFb09Ty6Xy8CUAAAAOFUsy9KMab/V3dkZ8i4vUTAQCLkZ8BzVgR01Wrx+k34zZaqRp9UBAABgiG2HzwE0AxblAADgWx6fOUv/8fJriknPU7exE1T7Xqm8e3aedM8OBuVbvURjL79QLzw1Sw4Hb0EAAABaitvz8/XYr+6Sr7xQTT7vSXeCjV7teusFdc0cqw7XjtafPt+hm/InKmBgAQ8AAAAAJ4q71AAA4Gu2beue+x/Qq5Vr5R48UpbDqcj2HZSQc7P2FL+hxsMHT7gZDATkXV6sX4/L1vQpk2VZlvnBAQAAcEqNyszUnCcek7+8UIGjR074+mAwoK/eeFZnDMmQ+6wfSZJcl6ZqfVOUMnLy5PF4DE8MAAAAAN+PRTkAAJAk+f1+jbvlVi2r3itX6uBvLLRdZ3RV15HXa/fbLyrgPf6niJq8DfItLdAT99+r/PE3n4qxAQAA0EwGpqaqZO4c2StK1Lh/33FfFwwGtXveC4q/fJBiks//xmuu3hepOqGH0kZmaf/+/aZHBgAAAIDvxKIcAACovr5eI7JztdHRTq6L+x/zHHfSj3TGkAztmveMgsEf/vWY/iOHFFi2UK/PelIZ6emmRwYAAMBp0Lt3by1bVCj335bLt6vmuK6pLX1Tsecmq90lx36f6Tqnpw5eMEBDRo5Sdc3xNQEAAAAgVCzKAQBo42pra5WWmaUdSb3kSr7ge8+NST5fnfpdqd3zXlAwGPzO83x1e+VYWabSN15TSr9+pkcGAADAaZSYmKiKxaU6Y8s6+bZt/d5z65aVyOFyK+6Kod97nishSY0Dr9Pw3LHavHmzyXEBAABwvGxJwTA47FP9fxT4byzKAQBow7Zv3660kaN06KKBcp3d47iuib04RbHnJmtfyRvHfN33VbViP6jUsuJFSk5ONjkuAAAAwkR8fLyWlZXovAM75ft0wzHPOfCXCvkP7Vfn4Tnf+Fif7xLVsbMcaWOUk/8LrVy1yvDEAAAAAPBNLMoBAGijqqqqlD72BgWuTJera+IJXRt3xVA5o2NUu6z4G1/3fbFFXf5ZpYp3ypSQkGByXAAAAIQZt9utkvlvqX+MJd/6tbLt/3305/DGD+T57BN1GXOTLMfx336KiG0n1/A8TZo6XQULF52KsQEAAABAEotyAADapIoVKzR20h1yDh2jyPhOJ3y9ZVnqPCxbgUMHdODPFZKkxn+sV6+ju1VeUqS4uDjTIwMAACAMOZ1OzXnuWY3pmyzf++Wy7aDqv9iig39frYSxE+SIiDzhpiPKJfewXE177iX9cfYzp2BqAAAAAGBRDgBAmzNv/gLdMe0RuYbnyRkTe9Idy+FQlzE3yfP5J6ornadBHd0qemueXC6XwWkBAAAQ7izL0ozp03R3doaOvvO2at8rVbexE+R0R5980+mUe0iWXlq6QvdNmfqNp9UBAABwali2HTYH0BxYlAMA0IY8PnOWZrwyV+5hOXJERoXcsxxOxZ91toZcfL5eeGqWHCfwazUBAADQutyen687x+Wp45ld5HC5Q+5ZliXXoDS9+88duil/ogKBgIEpAQAAAOC/cTcbAIA2wLZt3XP/A3q1cq1c12TKcjhDbgYDAXnfK9b9PxurV198QZZlGZgUAAAALdk9d9+lN57+o/xLCxU4esRI03VJqtY3RSkjJ08ej8dIEwAAAABYlAMA0Mr5/X5dP/4WLaveK1fqYCML7SZvg3xLCvTE/fcqf/zNBqYEAABAazEwNVUlc+fIrixRY90+I01X74tUndBDaSOzVFdXZ6QJAAAAoG1jUQ4AQCtWX1+vEdm52uRsL9fF/Y00/UcOKVC+UK/PelIZ6elGmgAAAGhdevfurWWLCuX+23L5dtUYabrO6amDFwxQWtZoVdeYaQIAAOD/sCXZdhgcp/svBNoKFuUAALRStbW1SsvM0o6kXnIlX2Ck6avdK8eKMpW+8ZpS+vUz0gQAAEDrlJiYqIrFpTpjyzr5tm010nQlJKlx4HVKz71emzdvNtIEAAAA0DaxKAcAoBXavn270rJG69BFA+U6u4eRpm9ntWI/rFR50UIlJycbaQIAAKB1i4+P17LSEvWo2yHfpxuMNKM6dpaVNlo5+b/QytWrjTQBAAAAtD0sygEAaGWqqqqUPvYGBa4YLlfXRCPNxi+2qMs/N6hicZm6detmpAkAAIC2we12q3TB2+ofbcm3fq2RZkRsO7mG52nSlGkqWLjISBMAAABA28KiHACAVqRixQqNnXSHnEPHKDK+k5Gm7x/r1evIHpWXFCsuLs5IEwAAAG2L0+nUnOee1ZgLk+VdUy7bDobcdES55B6Wq+nPvaQ/zn7GwJQAAABt3Gn/bPL/cwDNgEU5AACtxLz5C3THtEfkGp4nZ0xsyD3btuX7cI2uiHdr0VtvyuVyGZgSAAAAbZVlWZoxfZruHjNC3vdKZDcFQm86nXINydJLS1fovilTZXNTFQAAAMBxYlEOAEAr8PjMWZrxyly5h+XIERkVcs8OBuVbvURjL7tQLzw1Sw4HbxkAAABgxu35+XrsV3fJu6RQTT5vyD3LsuQalKZ3/7lDN+VPVCAQ+gIeAAAAQOvHXW8AAFow27Z1z/0P6NXKtXJdkynL4Qy5GQwE5H2vWL++PlvTp0yWZVkGJgUAAAD+16jMTM154jH5lxYqcPSIkabrklStb3IpIydPHo/HSBMAAABA68WiHACAFsrv9+v68bdoWfU+uVIHG1loN3kb5FtSoCfuv1f54282MCUAAABwbANTU1Uyd47syhI11u0z0nT17qvqhB5KG5mluro6I00AAAAArROLcgAAWqD6+nqNyM7VJmd7uS5OMdL0HzmkQPlCvT7rSWWkpxtpAgAAAN+nd+/eWraoUO6/LZdvV42Rpuucnjp4wQClZY1WdY2ZJgAAQJsQDKMDaAYsygEAaGFqa2uVlpmlHWf1liv5AiNNX+1eOVaUqfSN15TSr5+RJgAAAHA8EhMTVbG4VGdsWSffl1uNNF0JSWocNEzpuddr06ZNRpoAAAAAWhcW5QAAtCDbt2/XRSn9VeOMlqv7uUaavp3Viv2wUsuKFyk5OdlIEwAAADgR8fHxWlZaovMO7JTv0w1GmlHxneS7oJ+uvm6YVq5ebaQJAAAAoPVgUQ4AQAtRVVWl9LE3qMOom+T9cquObNkcctP3xRZ1+ecGVSwuU0JCgoEpAQAAgJPjdrtVMv8t9Y+25Fu/VrZth9RrPFCnuvdK1GXsBE2aOl0FCxcZmhQAAABAa8CiHACAFqBixQqNnXSHHNeOkatLghLG5Wv/yiVq2Fl90k3fx+vV68hulZcUKy4uzuC0AAAAwMlxOp2a89yzGnNhsnxrymXbJ/cBlQFPvXYteFldR90od9dEuYblaNrzL+mPs58xPDEAAEDrYdl22BxAc2BRDgBAmJs3f4HumP6IotLz5IyJlSRFxLZXQt4t2lv2lhoP1J1Qz7Zt+T5coys6ulX01jy5XK5TMTYAAABwUizL0ozp03R3doa875UoGAic0PXBQEC75j2nLteNliux+383nU65hmTpxWUrdN+UqSE/rQ4AAACg5WNRDgBAGHt85izNeOV1uYblyBEZ9Y3Xojqdoa6jbtSuBS8r4Kk/rp4dDMq3eonGXnahXnhqlhwO3goAAAAgPN2en6/HfnWXfEsL1eTzHtc1wWBQu958Th1Tr5G7R69vvGZZllwD0/TuFzt1U/5EBU5wAQ8AAACgdeHuOAAAYci2bd1z/wOas2KtogZnyHI4j3meK7G7ulw3WrvmPfeDT9oEA3553yvWr8dma/qUybIs61SMDgAAABgzKjNTc554TP6lBQocPfyD5+9d+Kra9blAsX0v+85zoi4ZoPVBlzJy8uTxeEyOCwAAAKAFYVEOAECY8fv9un78LVpWs0+u1ME/uNB29+ilTgOv0a43n1UweOzPcGzyNsi3pFBP3H+v8m+5+VSMDQAAAJwSA1NTVTL3VdmVpWqs2/ed59X+qVCR8Z0Ulzr4B5tRvftqe7ceShuZpbq6E/soIwAAgFbLtsPnAJoBi3IAAMJIfX29RmTnalNEe0VdnHLc18VceJna9+mrvQtf/dZr/iOHFChfqLkzn1BGerrJcQEAAIBm0bt3by1bVCj335bLt6vmW6/vX71UTQ0edbw267ibrnN66sCFA5SWNVrVNd9uAgAAAGjdWJQDABAmamtrlZaZpZqzeisq+YITvr596jWKjO+kfe8WfP01X+1eOVaUqfSN19Q/5fgX7wAAAEC4SUxMVMXiUp2xZZ18X279+uuH1/9FDdu/0Jmjb5RlnditLldCknyDrtPwvOu1efNm0yMDAAAACGMsygEACAPbt29XWtZoHbx4oFxnn3vSnY7XZinobdD+1Uvl21mt2A8rtax4kZKTkw1OCwAAAJwe8fHxWlZaovMO7JTv0w06svVjHfror0oYe6ssZ8RJNaM6dpaVNlq5Eydp5erVhicGAAAAEK5YlAMAcJpVVVUpfewN8l+VLlfXxJBaluXQmaNv1NHPPlHcpj+rYnGZEhISDE0KAAAAnH5ut1sl899SP1dQtUuLlHB9vhwud0jNiNh2ihyeq0lTp6tg4SJDkwIAALQ0YfDZ5Lb933MAzYBFOQAAp1HFihUaO+kOOa4do8gOHY00Gz/dqEE/uUQVf3pXcXFxRpoAAABAOHE6nXr1+ef1i/wJCqxfK9sOhtx0RLnkGpajac+/pD/OfsbAlAAAAADCGYtyAABOk7cWFOiO6Y8oKj1PzpjYkHu2bavxgzW6Mt6tkvlvKzY29CYAAAAQrhwOh/7rPx7RL8dkyPdeieymQMhNy+mUa0iWXixfofumTJVt8zQTAAAA0FqxKAcA4DR4fOYsPfLya3INy5EjMirknh0MqnH1Eo297EK98NQsORz8Jx4AAABtw+35+Xrs3rvk+1OhmnzekHuWZck1KE3vfrFDN+VPVCAQ+gIeAAAAQPjhLjoAAM3Itm3dc/8DmrNirVyDM2U5nCE3g4GAfMuK9eux2Zo+ZbIsyzIwKQAAANByjMrM1JwnHlNgSaECR48YaUZdkqr1QZcyc8fK4/EYaQIAAAAIHyzKAQBoJn6/X+NuuVXlNXvlSh1sZKHd5G1Q458K9MT99yp//M0GpgQAAABapoGpqSqZO0eqKFFj3T4jzajefbUt4VwNHTlK+/fvN9IEAAAIW7YdPgfQDFiUAwDQDOrr6zUiO1cbne3kuri/kWbgyCE1LV2ouTOfUEZ6upEmAAAA0JL17t1byxYVKvqvy+XbVWOk6Tqnp/Zf2F9DRo5SdY2ZJgAAAIDTj0U5AACnWG1trdIys1RzVm9FJV9gpNlYu1eOyjKVvvGa+qekGGkCAAAArUFiYqIqFpfqzE/XyfflViNNV0KSfIOu0/C867V582YjTQAAAACnF4tyAABOoe3btysta7QOXjxQrrPPNdL07axW7AeVWla8SMnJyUaaAAAAQGsSHx+vZaUl6rl/pxo/2WCkGdWxs6y00cqdOEkrV6820gQAAABw+rAoBwDgFKmqqlL62Bvkv3K4XF0TjTQbv9iirp9vUMXiMiUkJBhpAgAAAK2R2+1Wyfy31D/aUuO6tUaaEbHtFDk8V5OmTlPhoiIjTQAAgLARDKMDaAYsygEAOAUqVqzQ2El3yHHtGEXGdzLSbPx4vXod3qPykmLFxcUZaQIAAACtmdPp1JznntWYC5PlW10u2w79rqsjyiXXsFz99rkXNfOZZw1MCQAAAOB0YFEOAIBhby0o0B3TH1FUep6cMbEh92zbVuMHa3RFvFtFb70pl8tlYEoAAACgbbAsSzOmT9PdY0bI916J7KZA6E2nU64hWXphaaXumzJVtm0bmBQAAABAc2JRDgCAQY/PnKVHXn5NrmE5ckRGhdyzg0E1rl6isZddqBeemiWHg/90AwAAACfj9vx8PXbvXfL9qVBNPm/IPcuy5BqUpne/2KGb8icqEAh9AQ8AAACg+XC3HQAAA2zb1j33P6A5K9bKNThTlsMZcjMYCMi3rFi/Hput6VMmy7IsA5MCAAAAbdeozEzNeeIxBZYUKnD0iJFm1CWpWh90KTN3rDwej5EmAADA6WDZdtgcQHNgUQ4AQIgaGxs1YnS2ymv2ypU62MhCu8nboMY/FeiJ++9V/vibDUwJAAAAQJIGpqaq+LVXpIoSNdbtM9KM6t1X2xLO1VXXDlN1dbWRJgAAAIBTi0U5AAAhqK+v14icXP1988dqaAj91zdKUuDIIQWWFmruzCeUkZ5upAkAAADgf/Xp00flCwsU/dfl8u2qMdJsshz6YscOZV5/g6przDQBAAAAnDosygEAOEm1tbVKy8zSju69lTj+Dh39xwYd+fijkJqNtXvlqCxT2Rtz1T8lxdCkAAAAAP5VUlKSKhaX6sxP18n35WchtXy1e1T7bqG6jctX4Op0Dc+7Xps3bzY0KQAAAIBTgUU5AAAnYfv27Ur7f+3de7xd8534/9f7nOTskwuCuCRxK4JWFZ1KRN1KVBMiEbmoTtsoaakZbXXoDFPUmOn4lt9oO6hLkWaEJuSmLgkhUoa6a+PaUgR1iYiQyDk5OZ/fH3tnznac+1k5t/16Ph77sT9rr8967/fGxzp7vffns8Yey8p9DiC3w86U9a5g0FdPZuUDi1jz6kttiln1+qv0e+QeFsy+maFDh2acsSRJkqT6BgwYwMJ5c9nl3WVUP/tkm2LUfPgBb826jm2O+zq9B2xB7wFbEEccy8Spp7B4yZJsE5YkSdqYUuo6D6kDWCiXJKmVnnrqKUZPPoF1B48it83g/3u9vG8/tj3+JJbfNouqd95qVczql55nm788yaJb5zNo0KCsU5YkSZLUiMrKSub99kaG9wmqH3ugVcfWVlfzt/+5gq2PmvCx7wa9+vWn9+iJnHLOecy6ZXbWKUuSJEnKgIVySZJaYdG99zL5lNMoO3I8vQds8Yn9vTfbnG2O+zpv3XwdNR9+0KKY1U8/zm6r3mLB3DlsuummWacsSZIkqRnl5eVce8XljP/sUKqWLCCl2maPqa2t5W/TL2fgIUdSueOun9hfVpEjN2oCP77iKi697PKNkbYkSZKkdrBQLklSC8347UxOO+8CKo6aRHnffo32y20zmK2Pmsjf/udX1FZXN9ovpUT1I7/nwAGVzJ7xP+RyuY2RtiRJkqQWiAguPO9cTh9/FFV3zSWtr2my/9s3Xc1me3+BPp/Zu/GY5eXkRo7lygX3cObZ55BcRlSSJEnqMiyUS5LUAj+79OdccM315EZNoKx3RbP9K3fchYGHfoW/Tb+c2tpPzkZJtbVUL7mDSZ/fkyt/8XPKyjwlS5IkSV3BqSefzH/+4B+pun0W66vWNthn+bwZVG4zhP77HdhsvIgg98WR3PbX1/n6yVOpqWm6AC9JkiSpY3hVXpKkJqSU+P5ZP+Laex8gd/gYoqy8xcf2+fRebLb3frx909Ufe722poaqhXM4Y9J4zj/nbCIi67QlSZIktcO4MWO49uL/pOaOWZ+4pdKKRbeRgM0OP6pVMSv22Z/HU44xEyezZs2aDLOVJEnKSG3qOg+pA1golySpEevWreOrJ36LBa+9Te6Aw9pU0O6/3xep3HY73pk3A4D1az+i+vaZXHzWD5h64pSMM5YkSZKUlQNGjGDO9b+GRXOpXvEOACv/sISqt15n4DGT2/T9oGL3vXh50M4cccw4VqxYkXXKkiRJklrBQrkkSQ1YvXo1Rx03kT+W9ye39/B2xdrssNEALL/9ZtbfeTPTLr2Yo0ePziJNSZIkSRvRHnvswYKbZ9Lnwbt57/d38eHTT7DNpCmtWmmqvtyOu7Bir+Ecfsw4Xl22LMNsJUmSJLWGhXJJkupZvnw5I8eMZdn2u1Gx257tjhcRbHrAYdS88iLzpl/P8GHDMshSkiRJUkcYMmQIi26dR+Xrf2Xz/Q+mrHdFu2Pmth1C9UFfYdSk41m6dGkGWUqSJElqLQvlkiQVeeWVVxg59lhW7nMAuR12ziRm1euv0v/RxTzx0P8ydOjQTGJKkiRJ6jgDBgzgqYf+l90/eo/qZ57MJGbvAVsQRxzLxKmnsHjJkkxiSpIktUsCUuoCj87+B6FSYaFckqSCp556itGTT2DdwaPIbTM4k5jVLz7P1i88waJb5zNo0KBMYkqSJEnqeJWVlcy76UaG9wmqH72flNp/BbdXv/70Hj2RU845j1m3zM4gS0mSJEktZaFckiRg0b33MvmU0yg7cjy9B2yRScyqpY8zdNWbLJw3l0033TSTmJIkSZI6T3l5OddecTnj99qN6iULSKm23THLKnLkRk3gx1dcxaWXXZ5BlpIkSZJawkK5JKnkzfjtTE477wIqjppEed9+7Y6XUqLq4SUcuFmOOTNuIJfLZZClJEmSpK4gIrjw3HM5/dijWLtgDrU1Ne2PWV5ObuRYrlxwD2eefU4ms9UlSZIkNc1CuSSppP3s0p9zwTXXkxs1gbLeFe2Ol2prqbrvDiZ//rNc9ctfUFbmqVaSJEnqiU6dOpWLzjidqttnsr5qbbvjRQS5L47ktr++wddPnkpNBgV4SZKk1unse5MXHt6kXB3Eq/eSpJKUUuL7Z/2Ia+99gNzhY4iy8nbHrK1ZR9WC2fxw0njOP+dsIiKDTCVJkiR1VePGjOG6iy+i5vaZ1Hy4KpOYFfsM5/GUY8zEyaxZsyaTmJIkSZI+yUK5JKnkrFu3jq+e+C0WvvYOuQMOy6SgvX7tR1TdNpOLzzqDqSdOaX+SkiRJkrqFA0aMYM7118Ld86h+951MYlbsvhcvD9qZI44Zx4oVKzKJKUmSJOnjLJRLkkrK6tWrOeq4ifyxV38q9h6WScyaD96n5o5Z/ObSSzh69OhMYkqSJEnqPvbYYw8W3DyTPg/dTdUbyzKJmdtxF1bsNZzDjxnHq8uyiSlJkiSpjoVySVLJWL58OSPHjGXZ9rtTMXTPTGJWL3+bsnvmM3/6NIYPy6bwLkmSJKn7GTJkCIvmz2Or5x6j6qUXMomZ23YIVQceyahJx7N06dJMYkqSJDWqs+9N/rH7lEsbn4VySVJJeOWVVxg59lhW7nMAuR0+lUnMqtdfpd/D97DglpsZOnRoJjElSZIkdV8DBgxg4by57LLiNaqfeTKTmBWbb0kccSwTp57C4iVLMokpSZIkyUK5JKkEPPXUU4yefALrDhlNbpvBmcSsfvF5tn7hCRbdOp9BgwZlElOSJElS91dZWcm8m25keJ+g+tH7SRnMiOrVrz+9R0/klHPOY+bNt2SQpSRJkiQL5ZKkHm3Rvfcy+dTTKDtyPL032zyTmFVLH2foqjdZOG8um266aSYxJUmSJPUc5eXlXHvF5Yzfazeqliwgpdp2xyyryJEbNYFzf3U1//Xfl2WQpSRJklTaLJRLknqsGb+dyWnnXUDF6EmU9+3X7ngpJaoeXsJBAyqZM+MGcrlcBllKkiRJ6okiggvPPZfvjT+atQvmUFtT0/6Y5eXkRo7lqoX3cubZ52QyW12SJEkqVRbKJUk90g//+V8447zzyY2aQFnvinbHS7W1VN13B5M//1mu/MXPKSvzFCpJkiSpeaeefDIXnXE6VbfPZH3V2nbHiwhyXxzJTYvv5/CjjqYmgwK8JEkSALWp6zykDuBVfklSj5JS4vtn/Yjbnvkz9OnH+w8ubnfM2pp1VC2YzQ8njef8c84mItqfqCRJkqSSMW7MGK67+CJqbp9JzYer2h1v9UvPs+atN3htwDaMmTiZNWvWZJClJEmSVFoslEuSeox169bx1RO/xcLX3qHyiyPZesI3WP3nZ1n11CNtjrl+7UdU3TaTi886g6knTskuWUmSJEkl5YARI5hz/bVw11yq332nzXHWvvU67945j22PP4m+ew/j5UGf4ohjxrFixYoMs5UkSZJ6PgvlkqQeYfXq1Rx13ET+2Ks/FXsPA6CsV2+2Pf4k3v/DEla/+HyrY9Z88D41d8ziN5dewtGjR2edsiRJkqQSs8cee7Dglln0efBuqt5Y1urj161ayds3T2ebid+k96YDAMjtuCsr9hrO4ceM49VlrY8pSZIklSoL5ZKkbm/58uWMHDOWZdvvRsXQPT+2r7yyD4O+ejLvLpzH2rdeb3HM6uVvE4vmM3/6NIYPG5Z1ypIkSZJK1JAhQ1h06zwGPvcYVS+90OLjaqvX8uYNV7H1MceT22qbj+3LbTuEqgOPZPSk41m6dGnWKUuSpFKRarvOQ+oAFsolSd3aK6+8wsixx7JynwPI7bBzg316bbIZ20z8Jm/fPJ11q1Y2G7PqtVfo+/A9LJx9M0OHDs04Y0mSJEmlbsCAAdw1by67rHiNqmeebLZ/bW0Nb0y7nIGHH03l9js12Kdi8y3hiGOZMPU7LF6yJNuEJUmSpB7IQrkkqdt66qmnGD35BNYdPIrcNoOb7JsbuA1bH3M8b95wFTVr1zbar/rF59n6z09yz63zGTRoUNYpS5IkSRIAlZWVzLvpRvbvE1Q/ej8ppQb7pZR4a/qVbP6FA+iz22eajNmrX38qRk/ilHPOZdYtszdG2pIkSVKPYaFcktQtLbr3XiafehplR46n94AtWnRM5fY7MfDwo3nzN5dRW1vzif1VSx9n6Ko3WThvLptuumnWKUuSJEnSx5SXl3PtFZczfq/dqLrvTlIDy4y+c8t0+u60K/323b9FMcsqcuRGTeTHV1zFpZddnnXKkiRJUo9hoVyS1O3M+O1MTjvvAipGT6K8b79WHdtnt8+w+X4H8tb0K6mtzV+ESilR9fASDhpQyZwZN5DL5TZG2pIkSZL0CRHBheeey/eOG8PaBXOoran7Ue+7d86hLJdj04O/3LqY5eXkRo7lyjvv4cyzz2l0trokSdLHpNR1HlIHsFAuSepWfnbpz7ngmuvJjZpAWe+KNsXot+9w+n5qKMtnTyfV1lJ13x0c/3d7ceUvfk5ZmadGSZIkSR3v1JNP5qIzTqfq9pmsr1rLyvsXsW7lCrY8aiIR0ep4EUHuwJHc9tLrfP3kqdTUfHJVLUmSJKmUWQ2QJHULKSW+f9aPuPbeB8gdPoYoK29XvE0POoKyyj68dd0v+KfJx3He2f/SpotPkiRJkpSVcWPGcN3FF/HhrOtY/edn2HrCN4h2/pi3Yt/9eTzlGDNxMmvWrMkoU0mSJKn7s1AuSery1q1bx1dP/BYLX3uH3AGHZVLQrq1aS7/167jgrDM5eco3M8hSkiRJktrvgBEjmHbZL9lqs02peX9lJjErdt+Llwd9iiOOGceKFSsyiSlJkiR1dxbKJUld2urVqznquIn8sbw/FXsPyyRmzQfvU3PHLH5z6SV8++STMokpSZIkSVk5+OCDuXvOLfR58G6q3liWSczcjruyYq/hHH7MOF5dlk1MSZLUw9SmrvOQOoCFcklSl7V8+XJGjhnLsu13o2K3PTOJWb38bWLRfOZPn8bwYdkU3iVJkiQpa4MHD2bRrfMY+NxjVL30QiYxc9sOoerAIxk16XiWLl2aSUxJkiSpu7JQLknqkl555RVGjj2WlfscQG6HnTOJWfX6q/R9+B4Wzr6ZoUOHZhJTkiRJkjaWAQMGcNe8ueyy4jWqnnkyk5gVm29JHHEsE6Z+h8VLlmQSU5IkSeqOLJRLkrqcp556itGTT2DdwaPIbTM4k5jVLz7P1i88wT23zmfQoEGZxJQkSZKkja2yspJ5N93I/n2C6kfvJ6X2L0Xaq19/KkZP4pRzzmXWLbMzyFKSJEnqfiyUS5K6lEX33svkU0+j7Mjx9B6wRSYxq5Y+ztBVb7Jw3lw23XTTTGJKkiRJUkcpLy/n2isuZ/xeu1G1ZAEp1bY7ZllFjtyoifz4iqu49LLLM8hSkiRJ6l4slEuSuowZv53JaeddQMXoSZT37dfueCklqh5ewkEDKpkz4wZyuVwGWUqSJElSx4sILjz3XL43/mjWLphDbU1N+2OWl5MbOZYr77yHM88+J5PZ6pIkqRtLqes8pA5goVyS1CVc/PNfcME115MbNYGy3hXtjpdqa6m67w4mf/6zXPmLn1NW5ilPkiRJUvd36sknc9EZp1N1+0zWV61td7yIIHfgSG576XW+PvXb1GRQgJckSZK6A6sGkqROlVLiBz/6Z359z/3kDh9DlJW3O2ZtzTqqFszmh5PGc/45ZxMRGWQqSZIkSV3DuDFjuO7ii6i5fSY1H67KJGbFvvvz2PrejJk4mTVr1mQSU5IkSerKLJRLkjrNunXr+OqJ32LBsrfJHXBYJgXt9Ws/ouq2mVx81hlMPXFK+5OUJEmSpC7ogBEjmDvtOrh7HtXvvpNJzNwen+PlQZ/iiGPGsWLFikxiSpIkSV2VhXJJUqdYvXo1Rx03kT+W96di72GZxKz54H1q7pjFby69hKNHj84kpiRJkiR1VbvvvjsLb5lFnwfvpuqNZZnEzO24Kyv2Gs7hx4zj1WXZxJQkSd1IZ9+b3PuTqwNZKJckdbjly5czcsxYlm2/GxW77ZlJzOrlbxOL5jN/+jSGD8um8C5JkiRJXd3gwYNZdOs8Bj73GFUvvZBJzNy2Q6g68EhGTTqepUuXZhJTkiRJ6moslEuSOtQrr7zCyLHHsnKfA8jtsHMmMatef5W+D9/Dwtk3M3To0ExiSpIkSVJ3MWDAAO6aN5dd33udqmeezCRmxeZbEkccy4Sp32HxkiWZxJQkSZK6EgvlkqQO89BDDzF68gmsO3gUuW0GZxKz+sXn2fqFJ1g0fx6DBg3KJKYkSZIkdTeVlZXMvXEG+/cJqh+9n5TBsqW9+vWnYvQkTjnnXKbfMCODLCVJkqSuw0K5JKlD3LN4MUdPmMTKKKf3gC0yiVm19HGGrnqThfPmstlmm2USU5IkSZK6q/Lycq694nLG77UbVUsWkFJtu2OWVeRYu812/MMZZ3DpZZdnkKUkSeqyOvve5N6nXB3MQrkkaaOb8duZfPfcnzD4lB+Satbx3uI72xUvpUTVw0s4cLMcc2bcQC6XyyhTSZIkSereIoILzz2X740/mrUL5lBbU9OueB88/zQfPvkIO5z2z1y54B7OPOdfM5mtLkmSJHU2C+WSpI3q4p//gn/79TRyoyZQVpFjq2O/xkevvsSqxx5sU7xUW0vVfXcw+fOf5apf/oKyMk9lkiRJklTfqSefzEVnnE71HbNYX7W2TTE+euNV3rvnNrY94WTKKyvJHTiS2156ja9P/TY17SzAS5IkSZ3N6oIkaaNIKfGDH/0zv773fioOP5ooLwcgevVi2+O/xarHH+KD559uVczamnVULZjDDyeN5/xzziYiNkbqkiRJktQjjBszhmt/9p/U3D6Tmg9XterY6vfe5Z05N7Lt5BPp1X+T/3u9Yt/9eby2gjGTJrNmzZqsU5YkSZI6jIVySVLm1q1bx1dP/BZ3LnuL3AGHfaKgXZarZNsTTua9e27jo9dfbVHM9Ws/ouq2mVx81g+YeuKUjZC1JEmSJPU8B4wYwdxp18Hd86h+950WHVOzdg1v3ngNWx97AhVbbvWJ/RV77MXLgz7FEWPHsWLFiqxTliRJnaW2tus8pA5goVySlKnVq1dz1HET+WOv/uT2Gd5ov179N2Hb47/FO/NupPq9d5uMWfPB+9TcMYvfXHoJR48enXXKkiRJktSj7b777iy8ZRZ9HrqbqjeWNdm3tqaGN6ddztZfGUflkO0b7ZfbcVdWfHY4I8eO49VlTceUJEmSuiIL5ZKkzCxfvpyRY8aybIfdqdhtz2b7V2wxkG2OPYE3b7yGmjWrG+xTvfxtYtF85k+fxvBhw7JOWZIkSZJKwuDBg1k0fx5bPfcYVS+90GCf2tpa3px+BZsfcCiVu+zebMzcoCGsPfBIRk06nqVLl2adsiRJkrRRWSiXJGXilVdeYeTYY1m57wHkdvhUi4/LDd6erUcdy9+mX0FtTc3H9lW9/ip9H76HhbNvZujQoVmnLEmSJEklZcCAASycN5dd33udqmee/MT+d2ZdR//d96Tf577Q4pgVm29JfPlYJk49hcX33ZdhtpIkSdLGZaFcktRuTz31FKMnn8C6Q0aT22Zwq4+v3Hk3tvjil3hz+uXUFu4/U/3i82z9whMsmj+PQYMGZZ2yJEmSJJWkyspK5t44gxF9y6h+9H5SSgC8+7tZ9N5sczY54EutjtmrX396HzWRU358PrNumZ11ypIkqaOk1HUeUgewUC5JapdF997L5FP/gbKvjKf3gM3bHKffXn/HJnvsxTszr6Nq6eMMXfUmC+fNZbPNNsswW0mSJElSeXk5v778MsZ/bneqlizgvcV3UvPRajY/chwR0aaYZRU5cqMm8OMrruLSyy7POGNJkiQpexbKJUltNuO3MzntvAuoGD2R8r792h2v/4hDWb/mQz5bu4Y5M24gl8tlkKUkSZIkqb6I4MIf/5hTj/4yKx9/iK3GHk+Ute9SYZSXkztiLFfeuYh/Ovuc/5utLkmSJHVFFsolSW3ys0t/zgXXXE9u1ATKKiraHS/V1lK1+A6++82vM/N/plPWzgs0kiRJkqTmfe+732XaNVdTdeds1q9d2+54EUHuoCO4/a+v8fWTp1JTU5NBlpIkSVL2rEJIklolpcT3z/oR1y5+gNzIMUR5ebtj1q5bR9WCOfxw0njOP/vsNi/1J0mSJElqvXFjxnDdxRdRc/tMaj5YlUnMin1H8HjKMWbSZNasWZNJTEmSJClLFsolSS22bt06vnrit1jw2tvkDjgsk4L2+rUfUXXbTC4+8wdMPXFK+5OUJEmSJLXaASNGMHfadXD3PKrffSeTmBV77MXLgz7FEceMY8WKFZnElCRJG1FKXechdQAL5ZKkFlm9ejVHHTeRp3r1J7fP8Exi1qx6n5rbZ/GbSy/h6NGjM4kpSZIkSWqb3XffnYW3zKLPg3dT9cayTGLmdtyVFXsN5/BjxvLqsmxiSpIkSVmwUC5Jatby5csZOWYsy3bYndxue2YSs3r528Q985k/fRrDhw3LJKYkSZIkqX0GDx7Movnz2OrZx6h66YVMYuYGDaHqoK8watLxLF26NJOYkiRJUntZKJckNenll1/m8LHjWLnvAeR2+FQmMatef5W+f7iHhbfczNChQzOJKUmSJEnKxoABA1g4by67vPsa1U8/mUnMis23JL58LBOmnsLi++7LJKYkSZLUHhbKJUmNeuqppxh9/AnUHDKa3DaDM4lZ/eLzbPPCkyyaP49BgwZlElOSJEmSlK3Kykrm3XQjw/sE1Y/cT8rgXqG9+vWn4qiJfOdfz+O3N9+SQZaSJClTtanrPKQOYKFcktSgRffey+RTTqP8K8fRe8AWmcSsWvo4Q99/kwVz57DZZptlElOSJEmStHGUl5dz7RWXM36v3ai+bwGptrbdMcsqclSOnsh5v7qa//rvyzLIUpIkSWobC+WSpE+44abfctp5F1Bx1CTK+/Zrd7yUEtUP/54DN80xZ8YN5HK5DLKUJEmSJG1sEcGF557L6eOPZu2COdTW1LQ/Znk5uSPGctWCe/jh2edkMltdkiRJai0L5ZKkj/nZpT/n3349jdyoCZRVVLQ7XqqtpWrxHUz6/J5c9ctfUFbmqUeSJEmSuptTTz6Zi844narbZrJ+7dp2x4sIcgcdwR1/fY2/P+lkajIowEuSJEmtYbWiA0RE/4g4OCL+KSJmRsRfIyIVHi+3Id6eEfGriPhLRHwUEe9ExJKI+E5E9GpFnOMjYkFE/C0i1kbEyxExPSL2b21Okrq/lBKnn3kW1y5+gNzIMUR5ebtj1q5bR9WC2fxw0njOP/tsIiKDTCVJkiRJnWHcmDFcd/FF1Nw+k5oPVmUSs2LfETxBJUdPmMSaNWsyiSlJktompdou85A6goXyjnErcB/wM2AisFNbA0XEScBjwHeAXYBKYCBwEPAr4PcRsWUzMSoj4lbgRuDLwLZADtgR+HvggYj4cVtzlNT9rFu3juOnnMhdr79D7oDDMilor1/7EVW3zeTiM89g6olT2p+kJEmSJKnTHTBiBHOnXQd3z6P63XcyiVmxx168MmRnRh4zlnfffTeTmJIkSVJzLJR3jOKK03vAXcCHrQ4ScSRwFfmi9lvA6cBwYBQwu9Btf2B2RDT17/bXwNGF9r3AOGAYcBLwIvn/Li6IiJNbm6Ok7mf16tWMPm4Cf+y9Cbl9hmcSs2bV+9TcPovfXHoJR48enUlMSZIkSVLXsPvuu7Pwlln0efBuqt5YlknM3I678t5e+zNy7DheXZZNTEmSJKkpFso7xgzga8DQlNIWKaUvA636eWxhSfX/Jv/vbBXwxZTSL1NKD6eU7kwpHQdcXuh+MPmZ4Q3FOQQ4obB5K3BESmleSumRlNK15Avtrxb2/7+IGNCaPCV1LyklDht9FK9tvzu53fbMJGb18reJRfOZP30aw4cNyySmJEmSJKlrGTx4MIvmz2OrZx+j6qUXMomZGzSEqoO+wpfHjeett97KJKYkSZLUGAvlHSCldFVKaUZK6S/tCHMssGuh/dOU0osN9DmT/Iz1De2GnFV4Xg98N6W0vl6uy4EfFTY3Jz/LXFIPFRF8ccQIYsXbmcSrev1V+v7hHhbOvpmhQ4dmElOSJEmS1DUNGDCAhfPmssu7r1H99JOZxEyrVrLDdkPYYostMoknSZJaIQG1qfMfqbP/QahUWCjvPsYVta9vqENKaQ0ws7D52Yj4WJUqIvoDhxc270opvdbIe80mP2sdYHxbkpXUfVzy0/9gn8oyqp5b2q44VS8+x9bPP8Gi+fMYNGhQRtlJkiRJkrqyyspK5t10I8P7BNWP3E9Kbb+yXfXmGwx49gnmzLiB3r17Z5ilJEmS9EkWyruPgwrPz6eU3myi331F7QPr7RtG/v7m9ft9TEqpGnhowzER4TcTqQeLCH5z9VXssOJ1ql5paLGK5lUtfZzd3n+LhfPmstlmm2WcoSRJkiSpKysvL+faKy5n/F67Ub1kAam2ttUx1q1cQe4P93DrzJvo16/fRshSkiRJ+jgL5d1AYSb4doXN55rpXrz/0/X2fbqRfk3F6QW0av3kiNiuqQewbWviSdr4evXqxZwZNzDguSeoevP1Fh+XUqLqD/dx4KY55sy4gVwu1/xBkiRJkqQeJyK48NxzOf3Yo1m7YA61NTUtPrZm9Yeke37HvBk3MHDgwI2YpSRJklTHQnn3sB0QhXZjy6VvsKyovX29fcXb7YnTnGXNPB5pZTxJHaBv377c+tubyP1hMeveW9Fs/1RbS9XiO5j8d3tx1S9/QVmZpxRJkiRJKnWnnnwyF51xOlW3zWT92rXN9q+trqJm4RxuvPIKdtxxxw7IUJIkScqzqtE9bFLU/rCZvquL2v03UhxJPdTAgQOZd+MNcO/vqFnd+P8matetY+2ds/nhpPGcf/bZRESjfSVJkiRJpWXcmDFcd/FF1Nw+k5oPVjXaL61fT/XCuVz+039n77337sAMJUlSg1LqOg+pA1go7x4qi9rVzfStKmr32UhxmrN9M4/9WhlPUgfacYcduPGqX1GzcC611VWf2L9+7UdU3TaTS846g6knTun4BCVJkiRJXd4BI0Yw5/pr4a65VL/7zif2p5Souud3nHvaqRx26KEdn6AkSZJKnoXygojoFREpg8eUjZBe8TpVFc30Lb5B8EcbKU6TUkqvNfUA3mxNPEkd73Of+xyX//RCqhfMIa1f/3+v16x6n5rbZ/GbSy/h6NGjOzFDSZIkSVJXt8cee7Dglln0efBuqt5Y9rF91f97D1OPHsUJkyd1UnaSJEkqdRbKu4cPitrNLYPer6hdf93krOJIKgGHHXoo559+GlWLfkdKierlbxP3zGf+9GkMHzass9OTJEmSJHUDQ4YMYdH8eWz17GNUvfQCAFVP/IGv7LELP/ze6Z2cnSRJkkpZr85OoKtIKdVExKczCPW3DGLU91pRe7tm+m5f1F5Wb1/9OI+2MY6kEnH8xIm88bc3uWz2LWyearj1lpsZNGhQZ6clSZIkSepGBgwYwMJ5c5nw9W/wzF+eZfj2g/j//vOnnZ2WJEmqr7YWqO3sLAp5SBufhfIiKaXnOjuHhqSUPoyIZeSL13s00714/7P19j3TSL+m4tQAf2k2SUk91hmn/yODt92GUUceyWabbdbZ6UiSJEmSuqHKykrm3XQj02+4ga999atERGenJEmSpBLn0uvdx/2F590jYtsm+h1S1H6g3r5HgOoG+n1MRFQA+284JqVU3VhfSaXh+EmTLJJLkiRJktqlvLycKd/4Br179+7sVCRJkiQL5d3I3KL2lIY6RERfYFJh85mU0gvF+1NKHwCLCpsjI6KxZdzHA5sW2nPakqwkSZIkSZIkSZIkdVUWyruPOcCLhfa/RMQuDfT5GbB5UbshFxeeewGXRUR58c6IGAhcVNhcCVzT1oQlSZIkSZIkSZLUTaTUdR5SB/Ae5R0gInYFDqz3cv8NzxExpd6+O1NKbxa/kFJaFxGnA7eSn+39QERcCDxMvjg+FTiu0P1+YHpDuaSU7omIm4DjgWOAuyLiUuANYC/gHGCHQvd/Tim914qPKkmSJEmSJEmSJEldnoXyjnEgcF0j+7ZsYN+XgDfrd0wp3R4RpwD/DWwD/LKBeA8Dx6aU1jeRz7fIF9tHF97rS/X21wL/llK6sokYkiRJkiRJkiRJktQtufR6N5NSuhr4O+Bq4CVgLfAu+VnkpwJfTCktbybGRymlo4CvAXcBbwPVwDJgBnBgSun8jfUZJEmSJEmSJEmSJKkzOaO8A6SUrgeuzzDeUuDbGcSZQb4wLkmSJEmSJEmSpBKWamtJ1HZ2GqTazs9BpcEZ5ZIkSZIkSZIkSZKkkmKhXJIkSZIkSZIkSZJUUiyUS5IkSZIkSZIkSZJKioVySZIkSZIkSZIkSVJJ6dXZCUiSJEmSJEmSJEnqZCnlH52tK+SgkuCMckmSJEmSJEmSJElSSbFQLkmSJEmSJEmSJEkqKRbKJUmSJEmSJEmSJEklxXuUS5IkSZIkSZIkSaUuJajtAvcH9x7l6iDOKJckSZIkSZIkSZIklRQL5ZIkSZIkSZIkSZKkkmKhXJIkSZIkSZIkSZJUUrxHuSRJkiRJkiRJklTqUgJqOzsL71GuDuOMckmSJEmSJEmSJElSSbFQLkmSJEmSJEmSJEkqKRbKJUmSJEmSJEmSJEklxXuUS5IkSZIkSZIkSSUu1SZSdP79wZP3KFcHcUa5JEmSJEmSJEmSJKmkWCiXJEmSJEmSJEmSJJUUC+WSJEmSJEmSJEmSpJJioVySJEmSJEmSJEmSVFJ6dXYCkiRJkiRJkiRJkjpZqgVqOzuLQh7SxueMckmSJEmSJEmSJElSSbFQLkmSJEmSJEmSJEkqKRbKJUmSJEmSJEmSJKkRETEwIs6KiAci4s2IqIqINyLiDxHxs4gY0chxUyIitfAxpZ057h4RP4iIuRHx14j4KCLWFNq/jYijIiLa8x49jfcolyRJkiRJkiRJkkpcqk2kSJ2dBil1fg7FImIicAWwZb1dgwqPYcBQYFzHZlYnIqYB32hk906FxyRgQUQcn1Ja2TGZdW0WyiVJkiRJkiRJkiSpnoj4BnAd+VW63yZfML8fWAFsC+wCjAHWtSDckcAbTex/rR2pDik8rwBuBhYDLwM1wL7AGcDuhRxujYhDUkq17Xi/HsFCuSRJkiRJkiRJkiQViYhPA1eRL5L/HhiTUnq/ga6/jIiKFoR8IaX0coYpFnsN+A4wLaVUVW/fIxHxP8AC4MDC42vA9I2US7fhPcolSZIkSZIkSZIk6eN+CeSA5cD4RorkAKSUqjssq4bff0pK6aoGiuQb9q8BTi16aULHZNa1OaNckiRJkiRJkiRJKnWpFugCq3F3gRXBI2IP4PDC5n+nlJZ3Zj5ZSCktjYjlwEDyS8aXPAvlkiRJkiRJkiRJklRnYlF71oZGRGxOvtC8IqX0bodn1X4blojv/F8jdAEWytUZyjc0/vbmm52ZhyRJkiRJkiSpAfWu3ZY31k9Sz1HFWkidnUUhjzrbRkST/VNKr22ENPYvPL8PPBsRXwPOAj63oUNE/BWYBlySUvqwBTGvL9z3fHNgFfAX4G7gipTS61km35CI2BfYtLD53MZ+v+4gUuoC/8WrpETEF4BHOjsPSZIkSZIkSVKL7JdSerSzk5CUvYjYDljW2Xm0R0qp6Up6GxSK4DsBTwH3A6c10X0pcGRK6Y0G4kwBrmvm7dYC308pXdmmZFsoImZRd2/yiSmlmzfm+3UHZZ2dgErS1p2dgCRJkiRJkiSpxbymK6nUbFF43oN8kXwlcAr5/x9WAvsBdxT6fBaYFRGN1V1fAi4GjgOGFR7Hk1/SPRXi/Soivp35pyiIiOOoK5I/Btyysd6rO3FGuTpcROwMvFjY3B/Y6MtJSGqxbalb8WE/wPsjSF2H41Pq2hyjUtfl+JS6Lsen1LUNAR4qtHdJKb3UmclI2jgiohf5c3JXtC3wDrC+qU4bY+n1iKih7rYT64EDU0oP1etTBvwOGFV46ROztCNiM2BVaqQgGxFHA7OB3sAa8v+/zfRvoojYA3gY2AT4CPhCSumZLN+ju/Ie5eoM1UXt1zfSvSMktUG9e7286fiUug7Hp9S1OUalrsvxKXVdjk+pa6s3Rqsb6yepe0sp1QBd9Ry8MQrgQ8jfI7wh7xXdK3wt0K/QnlW/SA6QUqqNiDOpK5R/Fbi5Xp/3m8onpfS7iPgJcCHQFzgJ+PeWfJaWiIjB5Ge+b0J+9vpJFsnruPS6JEmSJEmSJEmSpFLw78CfGnkUF6g/KGrfQSNSSk9Tt3Lyfm3M6WryRWyAQ9oY4xMiYgtgIfl7rQN8L6V0Y1bxewIL5ZIkSZIkSZIkSZJUZ1lRu7mZ7Rv6bt2WN0opvQ0sL2wOaUuM+iJiE+BOYM/CSz9OKf0yi9g9iYVySZIkSZIkSZIkST1eSmlKSikaeUwp6vp0Ubucpm3YX9OO1KL5Li0MFNEHuJW6Ge4/SyldmFX8nsRCuSRJkiRJkiRJkiTVWVLU3qWZvjsXnl9vslcjImJrYMvC5httiVEUqzdwC3VLuP8qpXRWe2L2ZBbKJUmSJEmSJEmSJKnOfGBdoT2+sU4RcQh1Re7ft/G9vk3djPL72hiDiCgHZgCjCi9NB77b1nilwEK5JEmSJEmSJEmSJBWklN4FrilsHhERx9fvU7gP+KVFL11Zb/9OEbFvU+8TEUcDPy5srgWua6Tf4ohIhcdODewP4GpgQuGlW4ATU0qpqfcvdb06OwFJkiRJkiRJkiRJ6mLOA44CdgCmR8QXgdnAKmAv4EfAHoW+V6SUHql3/E7AvRHxIPl7hj8JvE1+9vjO5IvaE6ibTf5PKaU2Ld8OXAycWGgvBf4D+HS+ft6wlNLSNr5XjxH+kECSJEmSJEmSJEmSPi4iPk1+GfZdm+h2LXBKSmld8YsRcShwbwveZg3wg5TSVU3ksZi6+45/KqX0cr39LwM7tuC9/k9KqfEqeolwRrkkSZIkSZIkSZIk1ZNSejYi9gFOJT/7eyjQn/zM8AeAK1NKjRXDHwP+HhgBfAEYBAwkX599D3gaWARck1J6eyN+DDXCGeWSJEmSJEmSJEmSpJJS1tkJSJIkSZIkSZIkSZLUkSyUS5IkSZIkSZIkSZJKioVySZIkSZIkSZIkSVJJsVAuSZIkSZIkSZIkSSopFsolSZIkSZIkSZIkSSXFQrkkSZIkSZIkSZIkqaRYKJckSZIkSZIkSZIklRQL5ZIkSZIkSZIkSZKkkmKhXJIkSZIkSZIkSZJUUiyUKzMR0T8iDo6If4qImRHx14hIhcfLLYyxU9ExzT2ub2HM4yNiQUT8LSLWRsTLETE9IvZvz+eVupMsxme9eHtGxK8i4i8R8VFEvBMRSyLiOxHRqxVxHJ9SC0TE4paeH1sYL5MxLCkvInaIiIsj4tmIWB0RKyLi4cJ5t29n5yf1JK34vri4BbG+EhGzI+K1iKgqPM+OiK90wEeRup2I2Doijo6ICyLijohY3tprNPXitXsMRkTfiDizcN5dEREfFs7HF0fEDq3NSequshifETGlFefZKS2I5/iUJHV5kVKLrqdKzYqIe4FDG9n9SkpppxbE2An4awvfclpKaUoTsSqBWcDRjXSpBc5PKf1bC99P6rayGJ9FsU4CLgNyjXR5CDg6pfRuEzEcn1IrFC72H9KSvimlaCZWu8ewpDoRcRRwA7BZI12eB0anlF7quKyknqulPwoD7kspHdpIjAB+BXy7ieOvAk5JXjSR/k8z46/JazT14mQyBiNiF+A2YPdGurwPnJBSur0leUndWRbjs1D8vq6Fb3liSun6JmI5PiVJ3YIzhpSl4gvz7wGPAiOA/m2M96/AvCb2v9fM8b+mrgh3L/Bz4A1gL+BsYBfggoj4W0rpmjbmKHUXmYzPiDiS/AWLMuAt4N+BPwBbAFOB8cD+wOyI+FJKqbaRUI5PqW0eBU5s68EZjmFJQETsDcwE+gIfAj8lf17rAxxPflztDtwWEfullD7srFylHugK4PIm9q9uYt+F1BXongD+H/Ai+b9BzwL2Lex/h/z3UkmftAx4FvhyG45t9xiMiP7A76grwl0N3AR8BHwJ+BfyP2KbFREjUkp/bEOeUnfVnvG5wZHkr9M05rXGdjg+JUndiTPKlZmI+Db5C4QPp5T+UnjtZWBH2jajvMlfJjYT5xBgcWHzVuDYlNL6ov0DgceAHcgXDXdOKa1sy3tJ3UFG47MX+S9auwKrgM+nlF6s1+cy4LuFzW+mlH7TQBzHp9RKRTPKG50d14IYmYxhSXWKVmypAQ5OKT1Yb/+Z5C/+A5yXUrqgYzOUep6iGXM/SSmd34bjdyV/PuxF/gdoB6eUPira3xe4D/gC+bG9R/3zpVSqIuInwCPAIymlt+pdw2npjNVMxmBEnA+cV9g8K6X0s3r7RwBLCu9zb0rpsJZ/Uqn7yWh8TqFuRvmnUkovtzGX83F8SpK6Ce9RrsyklK5KKc3YUITrZGcVntcD3y0uwgGklJYDPypsbg6c1IG5SR0uo/F5LPkCG8BPG7lgeCZ1qz2c2Ugcx6fUObIaw5KAiNiPutua/Lp+kbzgEvLFAIDvR0TvjshNUpN+QN3qev9YXKADSCmtAf6xsNkL+H7HpSZ1bSml81JKv0spvdWOMO0eg4Xz6fcKm8+SP9/Wz/VB8iuZAXwpIv6uHTlLXV5G47PdHJ+SpO7GQrl6nMLyPocXNu9KKTW2FNBs8jPqIL/UrKSmjStqX99Qh8JFjZmFzc9GxNDi/Y5PqVONK2pf31CH5sawpI8ZV9Ru8F6OhdsXbFiZYXPqCuuSOkHhvshjC5vPpZQeaqhf4fXnC5vjCsdJaqcMx+ChwIBCe1oTtwu6vqjt90qpYxyK41OS1I1YKFdPNAzIFdr3NdYppVQNbPhSNswZPlKzDio8P59SerOJfsXj7sB6+xyfUufJYgxLqrNhTK0mf8uQxjimpK7jU8CQQrvRv0Xr7d8O2GljJSSVmKzG4EEN9GvIo+TP0+A5WOoojk9JUrdioVxd2T9GxF8joioi3o+IpyPiVxHx+WaO+3RR+7lm+m7Y3wtw1pzUiMJM8O0Kmy0dV/Dx8Vh/2/Eptd4eEfFIRHwQEWsj4rWImBcR32jqByUZjmFJdTaMj7+klGqa6OeYkjaOiRHxfER8VDgv/jkipkXEl5o4pi1/i9Y/TlLbZTUGWxSncH7ecLshx7HUOtdHxFsRUR0RyyPioYi4MCKGNHOc41OS1K1YKFdX9nnyvxquADYFPgN8B3isUDDPNXLc9kXtxpZ13mBZI8dJ+rjtgA3L3bVnXDk+pfbZBvgC0J/86gxDgGOAacCTEdHYBYasxrAkICIqgYGFzSbHVErpPepmyzimpOx8BtgNqCR/XtwV+AZwT0TMiYjNGjjGv0WlzpXVGNywvTqltLKFcbZq4jqSpE86BNga6A1sCQwHzgH+EhHfaeI4x6ckqVvp1dkJSA1YCcwBFgN/BtYCg4AvAyeRvwjyHWAT4GsNHL9JUfvDZt5rdVG7f5uylUpDVuPK8Sm1TS2wCLgdeAp4l/x4+jz5c+KnyRcM7o2IYSmlV+sd79iTstWaMQX5cdUPx5SUhTXAfPLnxefIj8GtyF/QP4X8xfxxwLyIOCKltK7oWM+HUufK+ntlS8/BxXGqWnCMVMpeAmYDD1JXyN4ZOA6YQP4Har+KiJRSuqqB4x2fkqRuxUK5upo3gCEppTX1Xn8CuD0iLgPuBnYAToiI36aU5tfrW1nUrm7m/Yr/AOvTloSlEpHVuHJ8Sm0zvpFf4/8+Ii4Hrga+SX7G+aXA+Hr9HHtStlozpqBuXDmmpPYb0sg58a6I+CVwB7Av+cL5qcAvivp4PpQ6V9bfK1tzDm4ojqSPmwNMSymleq8/Avw2Io4mX0TvDfxXRMxPKb1Zr6/jU5LUrbj0eomJiF4RkTJ4TNkY+aWUqhsokhfv/zMfn0X+jw10W1vUrmjmLYuX9fmo+QyljaeLj8+sxpXjUz3WxhzDTS1ZV5gpdzJ19387toH7xjn2pGy1ZkxB3bhyTEnt1Mw58S3ys902XJyv/33R86HUubL+Xtmac3BDcSQVSSm930CRvHj/74CfFDb7kl/5sz7HpySpW7FQrm4npXQ/8HRh88CIqP/f8QdF7eaWyOtX1G7JkkBSqcpqXDk+pY0gpVQD/LropUPqdXHsSdlqzZiCunHlmJI2spTSS8Bdhc1dI2Jw0W7Ph1Lnyvp7ZWvOwQ3FkdR6VwMbiun1v3eC41OS1M249HqJSSnVRMSnMwj1twxitMczwJ7kl/PZEninaN9rRe3tgEebiLN9UXtZo72kDtDFx2f9cdWUpsaV41M9VhcYw88UtevPKM9qDEsCUkprI2I5MJBmxlREbE7dRUDHlNQxngGOKrSHkL/FF3g+lDpblt8rhwP9ImJAUytNFMV5J6Xk/Y+ldkopvV34O3grPvm9ExyfkqRuxkJ5CUopPdd8ry4vmthXXCjYo5k4G/bXAH9pV0ZSBrrq+EwpfRgRy8h/iWnpuAJ4tt4+x6d6tE4ew42eGzMcw5LqPAscRH7Gaq/Cyg4NcUxJHa+xc2Jb/hYFx66UlazG4DPAcUX9HmooQET0AnZpJIaktmvuuqzjU5LUbbj0urqrzxSeq4B36+17hLp70jW0BBAAEVEB7L/hmJRSdWN9JQFwf+F594jYtol+xePugXr7HJ/SxvOZovYbDezPYgxLqrNhTPUD/q6Jfo4pqeM1dk78a9F2o3+LFhxceH4deDmbtKSSl9UYvL+o3VScL1C3qovnYCkDEbE1+dU9oenvneD4lCR1AxbK1e1ExIHUXfi4P6VUW7w/pfQBsKiwOTIiGlvOazywaaE9J/NEpZ5nblF7SkMdIqIvMKmw+UxK6YXi/Y5PaeMo/Br/W0UvLWmg29yi9pRG4jQ5hiV9zNyi9okNdYiIMuAbhc2VwL0bNyVJEbEzcERh86WU0usb9qWUEjCvsLlHROxf//hCjP2pm806r3CcpHbKcAwuBt4vtL8ZEY3Nbp1S1PZ7pZSNb1M3o/y+BvYvxvEpSepGLJSrS4mIcU38AUVE7ArcUPTS5Y10vbjw3Au4LCLK68UZCFxU2FwJXNOmhKXSMgd4sdD+l4jYpYE+PwM2L2o3xPEptUJEfCkiBjSxvzf5cbLhYuKtKaWG7qWa1RiWBKSUHgZ+X9g8KSJGNNDth8CnC+2fp5TWdUhyUg8VEWMKPw5rbP82wM1A78JLlzXQ7VLyt/YB+GVE9KkXow/wy8JmTaG/pOxcSjvHYGHFsV8UNj8N/FP9PoXz8kmFzftSSo+0N3GpJ4uInSJi32b6HA38uLC5Friufh/HpySpuwl/GK2sFIrYB9Z7+WLyy/G8yyf/MLozpfRmvRiJ/L2IZwMPA6+RX159MPBl4GTqluWZmVKa3EQ+NwLHFzbvJf/l6g1gL+Ac6u6Dc0pK6coWfUipm8pifBbijAZuJf9Dq7eAC8mP1c2BqdTdh+p+4NCU0vpG8nF8Si0UEdeTH1vzyf86/3lgFdCf/HLP36GuEPc2sH9K6a+NxMpkDEvKK1xMfADoA3wI/Af581of8ue5bxe6vgB8obCyiqQ2ioiXyRfBbwEeJL8c80fAQOBQ4BTqloO9HxiZUqpqIM5PgX8ubD5B/keaL5L/G/RHwIZCwU9TSmdn/0mk7qmwwt+uRS8NpO7HlQ9Q70fOKaXrG4nT7jEYEZsAjwK7FV66CriJ/P8TvgScTf7v5Y+AA1JKT7bgI0rdVnvHZ0QcSv7v2AfJf2d8kvz3ywB2BiYUHhsmOP1DSqmhH6Q5PiVJ3YqFcmUmIqbQwC8Jm/CllNLiejFa+h/kFcAPGrroURSrD/nZBKMb6VIL/FtK6fwWvqfUbWUxPotiTQX+G6ho5NiHgaNSSsubyMfxKbVQoVD+zRZ0/RNwfErpmWbitXsMS6oTEWOA/6HuliH1vUB+TP2l47KSeqZCoXzHFnS9BTg5pbSykThlwNV8/LYl9f0a+Hb9W31JpawVf5cCkFJqcMXArMZg4QfhtwNDG+myCvhaSul3LctY6r7aOz6LCuXNWUP+muxVzeTj+JQkdQuNLlkmdZJjgBHAcPIXQAaSn0G+CniJ/PKW16aUljYXKKX0EXBURJxA/r43ewMDyM+g+z3w3ymlB7P/CFLPllK6OiIeBE4HDie/4sNq4Fnyt0a4JqVU00QIx6fUOheR/zX/COAzwFbAFuRXXHmL/C/1bwbmtGQGeBZjWFKdlNKtEfE54HvAUcB2QDX5VZJmkT+nrenEFKWe5JvAIeTPiTuT/764KfkVHZYB/wtMa+7vyELh7aSIuIX8yg/7FWItBx4Brkwp3bGxPoRU6rIagymlvxRWdzkNmEh+Nm0F+f8f3E7+tievbJxPIfU4jwF/T/4c+wVgEPlx2Qt4D3gaWET+++LbzQVzfEqSugtnlEuSJEmSJEmSJEmSSkpZZycgSZIkSZIkSZIkSVJHslAuSZIkSZIkSZIkSSopFsolSZIkSZIkSZIkSSXFQrkkSZIkSZIkSZIkqaRYKJckSZIkSZIkSZIklRQL5ZIkSZIkSZIkSZKkkmKhXJIkSZIkSZIkSZJUUiyUS5IkSZIkSZIkSZJKioVySZIkSZIkSZIkSVJJsVAuSZIkSZIkSZIkSSopFsolSZIkSZIkSZIkSSXFQrkkSZIkSZIkSZIkqaRYKJckSZIkSZIkSZIklRQL5ZIkSZIkSZIkSZKkkmKhXJIkSZIkSZIkSZJUUiyUS5IkSZIkSZIkSZJKioVySZIkSZIkSZIkSVJJsVAuSZIkSZIkSZIkSSopFsolSZIkqUhE9I6I5yMiRcTkzs4nCxFxeeHzTOvsXCRJkiRJkrqCSCl1dg6SJEmS1GVExBnAJcCzwGdTSrWdnFK7RcT2wF+A3sDwlNIjnZySJEmSJElSp3JGuSRJkiQVRER/4F8Kmxf0hCI5QEppGTANCODCTk5HkiRJkiSp01kolyRJkqQ6pwIDgWXAzE7OJWuXFJ6/HBH7dWomkiRJkiRJncxCuSRJkiQBEVEO/ENh88aeMpt8g5TS88Djhc3vdWYukiRJkiRJnc1CuSRJkiTlHQHsUGj/T2cmshHdUHg+LiI269RMJEmSJEmSOpGFckmSJEldWkT0i4i3IiJFxEsR0buRfpURcX+hX1VEHNrKt5pUeP5zSulPzeQ0pfA+KSJ2bKLfp4v6Ta637/wN+wrbmxZe+1NEfFj4zLdHxAH1jts6Ii6MiKcjYnVEvBsR8yJi3xZ8xlsKz5XA2Bb0lyRJkiRJ6pEslEuSJEnq0lJKq4H/KGx+CphSv09EBDAd+CKQgG+mlBa38q2+VHh+qAV99y48v5dSeqWJfvsUtZ9qrFNEbA88ApwHfBboB2wNjAKWRMTEQr/PkV8+/RzgM0BfYAvgGODBiDisqaQLuf6tsHloU30lSZIkSZJ6MgvlkiRJkrqDXwGvFtrnRERFvf2XABMK7TNTSje1JnhEbAfsVNh8pAWH7FN4frKF/dYALzTRbxawHfBT4BBgP+AHwCqgHPh1RHwK+B3Qh3yh/EBgOPniejWQA65r4J9NfRs+30HN9JMkSZIkSeqxenV2ApIkSZLUnJRSVURcAFwD7Ah8i3zxnIj4HvmiMsClKaVL2vAWxcubP9GC/p9rYd8Ny6H/KaVU20S/fYBDUkp/KHrt0Yh4AbgN2AT4AxDAsJTSi0X9Ho6I5cBl5O+xfhQwp4n3eoz8DPRdI2LrlNLbzXwGSZIkSZKkHscZ5ZIkSZK6i+upm5V9dkRURMR44P8rvDYL+GEbY29X1G6ycBwRO5Bf7hyaL5RvWKL9yWb6XVqvSA5ASul2YMPS7lsB/1qvSL7BdcDaQru5meLFn29IM30lSZIkSZJ6JAvlkiRJkrqFlNJ64NzC5vbA5cAN5L/XLAG+3sys7aZsVdR+r5m+exe1n2ysU0QMJn+f8Sb7FTS1VPwfC88JmNlQh5TSR8CfC5s7N/NeK4raWzXaS5IkSZIkqQezUC5JkiSpO5lJXdH5JKASeBoYm1KqakfcLYrazRXK9yk8rwWea6LfvkXtJ5uJ2dT9y1cWnpenlJrKbUO/TZp5r+IYWzbTV5IkSZIkqUeyUC5JkiSp20gpJeDqopfeBkallFa2M/TaonafZvpumFH+p5RSTRP99ik811I3K7xBKaU1TezeMEu+qT7F/cqb6Vf8+T5qpq8kSZIkSVKPZKFckiRJUrcREUOBnxS91A9oz0zyDd4pam/RaK+8fQrPTzbTb8OM8j83UwjvaMWf751Ge0mSJEmSJPVgFsolSZIkdQsRsTVwJzAQeLfwcj/gnAzCFxeMN28ih/7U3QP8yWZi7tfCfh2t+PNZKJckSZIkSSXJQrkkSZKkLi8i+gG3kS9Sfwh8GZhb2P2diNihnW/xp6L2bk302xuIQvvFxjpFxGeBDTk91b7UMrfh860GXurMRCRJkiRJkjqLhXJJkiRJXVpE9AJmAV8AaoBJKaXHgfOABOQK7fZ4lLr7de/XRL+9i9r9muh3VlH7yTbmtLFs+HwPNXOPdUmSJEmSpB7LQrkkSZKkru5XwKhC+9SU0h0AKaU/ArcUXv9mRDQ1E7xJKaVq4OHC5rAmuhYXyo9rqENEnAJ8veilp9uaV9YiIgd8rrD5+87MRZIkSZIkqTNZKJckSZLUZUXE+cBJhc1/SyldU6/L+UAtUA78Wzvf7rbC87CI2KSRPvsUnmuBEyJiVkRMjojDIuKbEXE7cAWwruiY8RFxfDtzy8rBQO9C+7amOkqSJEmSJPVkFsolSZIkdUkRcRJ1S6pPSymdW79PSulpYGZhc2JE7NOOt5wBrAcqgWMbyKcM+Gxh83JgBTABuAlYBFxPfub7bcBlRYf+FzCyHXll6YTC8/MppUc7NRNJkiRJkqROZKFckiRJUpcTEaPJL7kOcDcwtYnuPyFf4A7g39v6niml14F5hc2vNdBlN6BvUU4HFvqvBFYDjwOnA8cAl5K/N/lqYAnw67bmlZWIKP4BwOWdmYskSZIkSVJni5RSZ+cgSZIkSV1CROwPPEi+8L5rSunlon2Tyc8eB9g5pfTXjs+w7SLi74Hp5GfC75RS+qCTU5IkSZIkSeo0ziiXJEmSpIKU0kPAHeTvef4v9XbvU3heBbzccVm1X2HZ+LMLmxdbJJckSZIkSaXOQrkkSZIkfdyPyM8oPzEidih6fe/C89LU/Zbmmgh8GlhGfll4SZIkSZKkktarsxOQJEmSpK4kpfSniJgC7ArsALxa2LVP4fmPnZBWe5WTv5f7PSmljzo7GUmSJEmSpM7mPcolSZIkqRkRsRXwdmHzuymlKzozH0mSJEmSJLWPS69LkiRJUvP2Lmp3xxnlkiRJkiRJKuKMckmSJEmSJEmSJElSSXFGuSRJkiRJkiRJkiSppFgolyRJkiRJkiRJkiSVFAvlkiRJkiRJkiRJkqSSYqFckiRJkiRJkiRJklRSLJRLkiRJkiRJkiRJkkqKhXJJkiRJkiRJkiRJUkmxUC5JkiRJkiRJkiRJKikWyiVJkiRJkiRJkiRJJcVCuSRJkiRJkiRJkiSppFgolyRJkiRJkiRJkiSVFAvlkiRJkiRJkiRJkqSSYqFckiRJkiRJkiRJklRSLJRLkiRJkiRJkiRJkkqKhXJJkiRJkiRJkiRJUkmxUC5JkiRJkiRJkiRJKikWyiVJkiRJkiRJkiRJJcVCuSRJkiRJkiRJkiSppFgolyRJkiRJkiRJkiSVFAvlkiRJkiRJkiRJkqSSYqFckiRJkiRJkiRJklRS/n/Y7ZEjq9phtAAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 2400x3200 with 3 Axes>"
       ]
@@ -763,7 +772,7 @@
     "fig, ax = plt.subplots(1, 1, figsize=(12, 16), dpi=200)\n",
     "\n",
     "# plot pcolormesh plot of V_e\n",
-    "im_V_e = ax.pcolormesh(X, Y, V_e.reshape(X.shape), \n",
+    "im_V_e = ax.pcolormesh(X, Z, V_e.reshape(X.shape), \n",
     "                        shading='auto', cmap='RdBu', \n",
     "                        vmin=-abs(V_e).max() / 2, vmax=abs(V_e).max() / 2)\n",
     "cb = colorbar(fig, ax, im_V_e, height=0.45, voffset=0.55, width=0.02)\n",
@@ -776,7 +785,7 @@
     "zips = []\n",
     "for i in range(I_m.shape[0]):\n",
     "    inds = CV_ind == i\n",
-    "    zips.append(create_polygon(x[inds, ], y[inds, ], d[inds, ]))\n",
+    "    zips.append(create_polygon(x[inds, ], z[inds, ], d[inds, ]))\n",
     "polycol = PolyCollection(zips,\n",
     "                         edgecolors='k',\n",
     "                         facecolors=colors,\n",
@@ -791,8 +800,8 @@
     "# outline of segments making up each CV:\n",
     "if False:\n",
     "    zips = []\n",
-    "    for x_, y_, d_ in zip(x, y, d):\n",
-    "        zips.append(create_polygon(x_, y_, d_))\n",
+    "    for x_, z_, d_ in zip(x, z, d):\n",
+    "        zips.append(create_polygon(x_, z_, d_))\n",
     "    polycol = PolyCollection(zips,\n",
     "                             edgecolors='k',\n",
     "                             facecolors='none',\n",
@@ -801,7 +810,7 @@
     "\n",
     "    \n",
     "ax.set_xlim(X.min(), X.max())\n",
-    "ax.set_ylim(Y.min(), Y.max())\n",
+    "ax.set_ylim(Z.min(), Z.max())\n",
     "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
     "ax.set_ylabel(r'$y$ ($\\mu$m)')\n",
     "ax.set_aspect('equal')"
@@ -809,22 +818,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(-0.5, 4999.5, 71.5, -0.5)"
+       "(-0.5, 4999.5, 108.5, -0.5)"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1EAAACSCAYAAACkEUAtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABm+UlEQVR4nO29fbA9x1nf+X1m5pz79nuVrDfrJywbhI1geVVsiLNZAjGRgUSuTTllsgQn5V1VtuzEFKkCObuprezCRtndymKqCEQFJCJhcZRkKbzg4HWcuPKyBmwZAxbGkbBlSUjWu376vd17zkw/+8d0zzzT0z0v55x777n3Pp+qU+ecmZ7up7uffvp1uomZoSiKoiiKoiiKogwjOWwBFEVRFEVRFEVRjhLaiVIURVEURVEURRmBdqIURVEURVEURVFGoJ0oRVEURVEURVGUEWgnSlEURVEURVEUZQTaiVIURVEURVEURRnBgXSiiOhuIvoCET1GRPcdRJjKekNEv0BEzxHR58S164joY0T0qP0+L+59wOrPF4joz4nr30ZEv2/v/RQR0UHHRTlYiOg2Ivp3RPR5InqEiN5vr6v+KJ0Q0SYR/TYR/a7Vnb9rr6vuKL0QUUpEv0NEv2b/q94oyglm3ztRRJQC+GkAbwdwJ4AfIKI79ztcZe35JwDu9q7dB+DjzHwHgI/b/7D68i4AX2+f+YdWrwDgZwDcC+AO+/H9VI4fOYC/xcxfB+DbAbzX6ojqj9LHHoDvYuZvAvDNAO4mom+H6o4yjPcD+Lz4r3qjKCeYg5iJejOAx5j5i8w8A/AhAPccQLjKGsPM/x7AS97lewA8aH8/COAd4vqHmHmPmb8E4DEAbyaiWwCcYeZPcnlq9C+KZ5RjCjM/w8yfsb8voWzU3ArVH6UHLrls/07sh6G6o/RARBcAfB+AnxOXVW8U5QRzEJ2oWwE8Kf4/Za8pis9NzPwMUDaUAdxor8d06Fb727+unBCI6HYA3wLgt6D6owzALsn6LIDnAHyMmVV3lCH8JIAfBWDENdUbRTnBHEQnKrTelw8gXOX4ENMh1a0TDBGdAvCvAPwwM7/a5TRwTfXnhMLMBTN/M4ALKGcHvqHDueqOAiL6fgDPMfPDQx8JXFO9UZRjxkF0op4CcJv4fwHA0wcQrnL0eNYud4D9fs5ej+nQU/a3f1055hDRBGUH6peY+f+2l1V/lMEw8ysAPoHynRTVHaWLtwL4C0T0OMpXEr6LiP4ZVG8U5URzEJ2oTwG4g4heT0RTlC9bfvgAwlWOHh8G8G77+90AflVcfxcRbRDR61G+jPvbdvnEJSL6drvD0Q+JZ5Rjis3rnwfweWb+B+KW6o/SCRHdQETn7O8tAH8WwB9CdUfpgJk/wMwXmPl2lG2Yf8vMPwjVG0U50WT7HQAz50T0PgAfBZAC+AVmfmS/w1XWGyL6ZQDfCeA1RPQUgP8JwP0AHiKi9wB4AsA7AYCZHyGihwD8Acqd2d7LzIX16r9HudPfFoB/bT/K8eatAP4KgN+377YAwN+G6o/Szy0AHrQ7pSUAHmLmXyOiT0J1RxmP2hxFOcFQuUGMoiiKoiiKoiiKMoQDOWxXURRFURRFURTluKCdKEVRFEVRFEVRlBFoJ0pRFEVRFEVRFGUE2olSFEVRFEVRFEUZgXaiFEVRFEVRFEVRRrBUJ4qI7iaiLxDRY0R03wD39y4TnnJyUd1RFkV1R1kU1R1lEVRvFOVksHAnyp6z8dMA3g7gTgA/QER39jymhkVZFNUdZVFUd5RFUd1RFkH1RlFOAMvMRL0ZwGPM/EVmngH4EIB7ViOWoiiKoiiKoijKepIt8eytAJ4U/58C8BbfkZ3WLkdlsvTbNl53QU/3VUaTXncOqjvKIqjuKIuiuqMsguqNsij5iy+juHyFDluOMXzPn9nmF18qGtc+83uzjzLz3Yck0oGxTCcqlMkto8HMDwB4AAA2XneBb/7A+5cIciTLqGGX+evzd6zpPFLF5YDQ6ifOQejLfqX/cdX1ddTX/UzrdYxvF/uRFkctDY4aY/PsKOTH0Di5uBxXe7kOrEs7zZPjK3/vg/sU0P7xwksF/sNv3Ny4duq1T7zmkMQ5UJbpRD0F4Dbx/wKAp5cTZ4Xsl8IP8ZewvEEfEs5RqDSU1XJQlaoMZxV6po2Bg2W/03sVNu6gUN0rcelwFPJtkTxb9/iNiZPq7P6yLh2oYwKDMWdz2GIcCst0oj4F4A4iej2APwbwLgB/eSVSKYqiKIqiKIqy1hgAu1z0ujuOLNyJYuaciN4H4KMAUgC/wMyPrEyyZTjMWahV+Dk0nHUfeVOOB8vMOugI3sGi6V2jaRGvX9a5zjiO+XYQcYqFsc55rRwLGIz5CVW0ZWaiwMwfAfCRFcmyOhZZTzwk/6WbVS13YrTlPIm6eBLjvAghfVnWv/2kz/+xFf8i70ksml59dmQddTZmoxb14yjjx2O/3pFdZ46i3F3l7ijGB1jOlox9j0oJsy7psy5yrBBmYH4M4zWEpTpRiqIoiqIoiqKcTBiEXV7mxKSjy8ntRC3ba15Vr/ugZxUOa6mEHIk7oSMWK2HZ/Fu3tB8rjz+zNHYG2TFmKey6pdmyHLf4DCWmO8dpxuM4clzyYtEVJ6tefRDyfwhj6+4uOz303iKsm76smzz7AAOYayfqGLDI7jeLGgXJKt4X6ZL9OOyOForrcTYuq26YrSr/DqMTu4jsXR2foX4PWdY7pEwflUb22HcpQ6xjvBalLz2G6MVRT491j0fIHvn5suqdQg+SZXVsrA4vkj5ddUJXXowNY5F7y4Z1ELskD/XjqOnuCAwIM6SHLcahcLw6UYqiKIqiKIqiHAg6E3XUWWa0YOjIfN9IyqLnDgw9dyrEmGn4IdeGTrmv6rDhg5wVOajNO1Y9ur3o7o19o5tDNnxYRr+WxQ9/mXNjFg2/7/6qdWgddkEM6ehhzgSMnQXcj1HtwxpBHmNn/TyKzSAcRlyGzqYMWba2zrNSy8zSDJ1577u3aD03ZEbwKLJo+T2IOu0YUb4TNTlsMQ6Fo9WJGlvQV9VwHtrRGdsZa/wWD/MKS/CY6XgZh2Wm8dfNWHR1RFYp55jlVIt03Pd7uaofRp+c+13JuvCP6lLQZRpHfctr+jqYq1qCGNLBg0j7g1z+s24suyxzaNoddj52uR060CM5yPgsMsAzNO1XqftjB8MW2dl4lSwa7n7W4we1nPsI2zVmwpxP5nK+3vk3IvoFInqOiD4nrl1HRB8jokft9/n9FVNRFEVRFEVRlHWCQZhx1vicFIYsYvwnAO72rt0H4OPMfAeAj9v/+wehufwtthSOvE/In5j/feH6/i+LPwvVkH3gMEffiFVI9mX8PAr4OjBmeUifU6bWJ+jPkLAXGVFchKOen5LYLO6Q5xYpC4u6d8/Ib//6IvTpWJ/e7Uecx5S1MWGvki6bsB/yL8NByrDfcV7E7676fT/CGyJLSJ79km1Mm4a4/vT5OUbHYzKMoc8OBeMzMoxVPdvlT58t9duli9qSdbA9S2BQLueTn5NCbyeKmf89gJe8y/cAeND+fhDAO1YrlqIoiqIoiqIo60y5sUTW+JwUFo3pTcz8DAAw8zNEdOMKZRrGMqNVq3gfZag/IT+kXwlH4sDj3o0au8aaOvynAW4WYZE0G+v/fngbSQOmQN6tQk+kP6HRx1qABTweEOYq3Up3Xe8RdL0DtMrZG//emPcupPuDfll5lbOaqyJoV3D476stMtourx/Gu0L79Y7F0LpuPzZJCf3237lZ5QY3q2TsjETs+tAznmJlKeiWA2GMqKu70rTPXvoMeTdz2Q2CDoqxM2N9bdBF25pHEMbJfSdq37uLRHQvgHsBIL3unHfTc7yqHWqWZZXTzDG/5RK+hGtja0RgvmF0xtNdizXoOg0h14Xb9893F5Tfa8THGvUrNJ6uE8NDlzk2Hha/Rz4e6zwNCmuo+zGdX9lpk/nn6OoUS6er2LlPfi/TUBgTbtczXQ21oX7JZ8c+H/LrMOkq25Ub8XvVL2Yvu4nPIp2Mg0j3oY3/IX703VtFGPvQCfHtYssuj22INz0fbsf2i0UGiGK2yP12dfyYjk7wuqi/E5FWffX5WMakwbIdxSrdViT/wMGuYLviIActjxG6scR4niWiWwDAfj8Xc8jMDzDzXcx8V3pqZ8HgFEVRFEVRFEVZJwwIu2bS+AyBiO4moi8Q0WNE1NpbgUp+yt7/PSL61r5nYxvfEdHbiOhhIvp9+/1dK4j6wp2oDwN4t/39bgC/OtqHMSMdg0Y5/NGwgS9dAgezjbOMhxtNShlIGZRymROhUTsnfxpb9tcXLjd/Ozm60pVi8nA7Hgi4AwKzY4FE7hklam3eEAur6/pYNyL8XlzpaeVtx8jsoMC9Z5yfCdp51xf22HCHuukabd6v8KOzoysMt2skcox/sVHXUNnrs3Fd5XXR8tB3340uD7W/q2RMPIfc7yoXffkbm5k8iFlKX19CeRHTp0XDjIkSs8fwbGXILnV67P2WdV6fe///fs9SdZVp/7ckumTfEltJ4uutrAO62gPL1AEy/EXdd+Zfhw0PtUZD7se07VqPdrQr/Hi4fPPbO4vStdLqsGztimCMfyeKiFIAPw3g7QDuBPADRHSn5+ztAO6wn3sB/MyAZ2Mb370A4M8z83+Bst/yTxeMboMhW5z/MoBPAngjET1FRO8BcD+AtxHRowDeZv/vL4MaGks2IoP+Ll5goyQojWDCbf9jU8uh929aonqVmV8pJRBhen4HPQzIIwu9M+ihSmI/DEKoAR+6H/vf9ax0ssy0/dhGbazSTbj+XVWaHR20VRp7R2tcgg7n/QSnswnGxW3ZQZRV25IYQ3bXCv12z/p2pDFYMrBDv0jDu6uML9o46LPxftjL2JmQzY3JsKAtCT6zrG3s7VCN1NshRWSInyG5kpDNWrBDGwpvARay7/vZuA3Z8ESkhSvTqUhLmdfr1vCO2ZKkI38b8RLlUj47RD86wlgq34PlX8q5D+3EI4R7J0p+BvBmAI8x8xeZeQbgQyg3rZPcA+AXueQ3AZyzq9+6nr0HgY3vmPl3mPlpe/0RAJtEtLFQhAW93UVm/oHIre9eNnBFURRFURRFUY4mzDR4CZ/gVgBPiv9PAXjLADe39jw7ZOO7vwjgd5h5b6zQPoe3D6FbLiL/hxi460x6MavccwIgsY+1Zl1i4UhRvNkXE3iII79jODcEpK+mmFxKUEzL0XVOAE6s3GLkI7tMAJX3i43ApKE3SsIEkJwhAsAGzVErOZtQfTciXzo2jPRSWvnPVk45xc2Zqf2rviPx99MwNMvRR+LJL57lUMApAwbd+rOIHA6XtgnX8aO2n2NJL6XgpMwuM2WAAZ4wyFBgRLijfPj5bCEO+QNkF2V+l/nMUscIpYK1lnXaYGRZW+XoaMpAQUiFfGV4tVyhss4ThNOAAtd8GGU5Mt61GNJP37ZZsotpLWvClfzZldKxtFtsZ904AdjqQChMTjlsn4x9oFW2xe9YOrh7Pba3io/UFZkfQDNPema7mLj7JXVhQzsZ8jJ4Zsp044CbkK74v6UsY8p7EskvJ5avI0mtCw0ZqnQOBJ4JmcbWUx24sIIbS0Rm19JXhU1x5XbD2WXhkIDGCqDGREz5YHrJ1oG2jJgNAxJp2RCrxxYRU1SPqrpE5C3NCem1pGFrXH3dyh8vLThU1nwdC5UNWT8TI7mcgQrUNsH3JxLX0ouuWSDpsN+vPmRbTNqF7Iptz6Q2GNFGM9P2jBpPUOtJgmZbw8fKnVxJkcwoWC/E7BMRWVk8nTFU52sozARAASAr6ydXT40qZ1327ggR2Z3vNUT0afH/AWZ+QPwPxXyIRsdSbVDKE9HXA/j7AL5niPs+Dncz9wFRnj6feZ0irxHiDOq2aT270G5uDqrDB6zhEuFJI+rcNxoOaN6r3CSM4kyB4lyO7PlJq3DLBuL8nKnSKLucIJkLGZK2UaCEwUTgFNW0NhFV4U6eE+ElXjr68UgYxbapG9wBQz95OQMMsPEylfKk5cdkZeOu1SiUYcn0CqWZ/9vmBRk0Kq86PUR+WL8nLxKooJYsLR0CWmnfkisgj0vbyQtpJc/GKwST1mnBKde/Xdg9jc5i22D6UlnTbH0lASfA9CKDM4KZoPxYPyeXyv+c2XTPAJNyS0eqit7pitMLGe6pWt86qdLJ752102gVZC9MysaDs9FVHER8ktKQy12qNp7NynKaBspvSBc9HZy8aAOsGrJCl13YSeR5Px0IyM8WwUbUbMu75lURk1fSpt4DVRmfvDABjNWvjCs947StY0CPnPK3sfFvxbHW32LLNJ8L5X3gWtQuD9Gf3vvcbIBGGkHpxQzpLjV0QnZcpTwsBo4W1W8X5+lzWXeaboq0SbhacD+4rLGtMxt63S7/IbsT9XdMnD05i7NFayBr8rKnzzbM6csEzqwuJ+1ya6bCbwI2Xkpr3U88m5dQbWdlfsKLc0D/qw4W1+nOU0Y+teV3bMO3o05rXBODFpMXsupeWbeWHQ1nA7OLCaio7zfqNlm/JM5WRmQhtAcgpR1KvOsRnZMUZ/JWeQOA2U5gAME+O32pjJjM7/RllGXU1nNAWceZibN37bqOMwZPbJ5JXe7SdUJ8IKBjEGnyfAZiILucISmA9BqQ5AwzadfTVVsgNlDm2mzkBDtaMBDqRL3AzHd1PPYUgNvE/wsAnh7oZtrx7LNEdIudhWpsfEdEFwD8CoAfYuY/6ozUQBbdWEJRFEVRFEVRlBMMg5Bz2vgM4FMA7iCi1xPRFMC7UG5aJ/kwgB+yu/R9O4CLdqle17PBje+I6ByAXwfwAWb+TwtH1mN9jxW2nfHZjTlaU7ihgUx5ZkIXoWc7lonMbszLKdqhfnThjXQUN8/A/vSvXBbn3DIwv7EoR3HkqN7QpQEAkDDmt8yaS1hcOKHlLHbEmhEYobHhzW+cAwVhfhPXsrk4+EuB/DQOyR5ALh2Z3ZA35Rb3Wb5Qan/ObuJmOH66eb+pT8cqh82/pY6WF+ev4XCaSn/lSHkoPAJmN88BQ5jfZsAF4WrKpa6YZvyvTbjxP5qvPelNTHUa+oPeQ8pVNaon82HkiFpoIp+B/Pp5PYIZy8cAezfP+936ZUdcn93slf2QH62Ry0gY/khwSAdIuBX+zm+w8ZdpYH8W5wP2ScoRK99dMIDU6rXp0KG0I6/9Ueu+9B+iP/5Isu8mNJocKYvFmQLFqfC9YL6EljZGZg6DZTxWn/lpmsjf/gxBIK4NP8oZlNlN8/ZSxYjN68T3v8udmDVrPUP2grORN8ztsqembPnZSJ3hfifNa7s7RbNMBMNtX+88PD2GQXs31qHpGCsLLk6NGbEyDRpl3t9UhwnzU3l9P1aPh+Tw//vD6CPqvXg4EYexJf1s63bP1uTn6rr0WmaaOhPwoyVnT56zS9fa0bB4WOY35IABZjdzczlf1+sfsTpE2r4juDmFYcJeMa47wcw5Eb0PwEcBpAB+gZkfIaK/bu//LICPAPheAI8BuArgr3U9a72+H8BDdhO8JwC8015/H4CvAfB3iOjv2Gvfw8zRI5qGsL6dqP1gEd0MNVAW9ddVNvYZ9iu6ViFGbRByGmbEQg0Rt4PXmEYtO8/Q3BlH+uHSRjbiqwaH+x7ZkO6ioP7KS94rKLxbj/OjslniHaEhedmqFAPpEKOrES3vF1RO+9uwuK9yq9616Gns+eFEGldDOk6twwpDDbvacbtBN1Q18mR8xRJrVAzVHWBY2R8iBzCssxXDr5RdGSPUMrbSnvo7dEM6UzFIfNg6XqasS9vowg4NxLR2AhV2qbF7YyT+jqF525ArYAOlOz+v/WuM5nsWIaT7RFzz06Or8dvxzlUvoUf7bC7B7jbrwrcXq8Y92vVGsGxGOlCxa33xHNiYDt0LdqhaNi1wLUaoA+NIfb3iunPkwnGH9Tr6bGKs4+b/jr3zE+pgxcJZBL9OCg3WuPoeKOPb58cicsk0lJ30IbbRDWjnTkbfTg+0ib7tO4IwgDmPX9jGzB9B2VGS135W/GYA7x36rL3+IgIb3zHzjwP48dFC9nCyOlGKoiiKoiiKoqwIGrqE79ixnp0o8n4PGBVIrpUv4gd3Mur6Lb0hHj+y0jdCJ924cx7YjsQZ99s6301bI0jJHlV+OR3t2vigXpIlRv1TNGdf+pZ8NeLA9UiZv1NZNVJWz6jRHiHZS+pBGJEXTCh3zqlkRTWC3njp349XFT2Kjo6lV5M62vbDE/HKrHsHPrLEjYiG5aX/LKHepY+A1sjTkB0CQzABaSV0Q08qEpSbibD77okD7Kxb2tRzlya9s0+hkVjnZ0NPImnQFqY9OyV+J7t1ZrMc6Y7hD6YabtmP3tHmhgdo2x+/TLsR4r5Zr5GzssluUtq1GYEKlC+RVy9Ply/ZV+XL6nowPQNxZ39UO0bXclB5llksXqGd6GR6+qPxclQ8ZpvcIaOG2ulbjeijO36y7Lr/odk5Rn2eHwJh+u77cJNI15qNjdAL7+7l+KCdrlYWIJz2BYFmod1cm3VF6zcBDG5uJuTFL7gzX8qgSVnA2VBZH7iZyeAsQYdehZBu/HwaMRu01Pl/XvjJNZG+rv6KbSjl/5ZeJsbaR69O9svGXhJOexmEHz9T2g+W8lBT39jNvnAgbyF00I/DkHLg7xwaeYaYalvd5V/oflC/vMei9gnt5Xxj6sDK1o7Qq5C++rbvCLLIcr7jQu/8GxHdRkT/jog+T0SPENH77fXriOhjRPSo/T6//+IqiqIoiqIoirIOMICck8bnpDCk65gD+FvM/BkiOg3gYSL6GIC/CuDjzHw/Ed0H4D4APzY04OiLfkCjt56+kjVnNapRH1QjE+XobPmAG2Xv9D8qlHQsvhcdHPBHwSemHKlzM1DeS7G8YVqji8UkInNkNJc2jN2AANXadNoot2blImk/E8PFO2OQPVOlNdMRmEXgDYNi09QzNJ4bsx2RvZrJqa9TaCQzkhfFdnt77uxyivQaVaP4cjvU6pUJNzrXOCE+rGPBGU4nJ1ndkzCQXEqRzKny0+lpw18Iv+UgtZ1lir1ATJOiHj17ZYqkiKSVJ+/kleasXWP2rmv79Wak67Ryo/XuxVoZMS7PiiG3Xtz5lzCyy0lga+I6rdnNoAKjZ6EqpC61omBnZmJ2ITRy6o0upxez1nr2kO5kr7ghbJHuNq2NtMJuS2W7YUgxZfjn8/BmUZcvqxfJdg42VJZxcV3mQ8O+StsUGLlNX0laZ+2xiJPZLsKb1Eg/5LleVk+kH1K3eGpfLPA30PD8RMalDZWJbdORMmv7Gu8oBkbC/e/E+y9+09TUZdAfRRa6ldoyBVkXibhWZ/41jjvgOi/IPuzEd9tpy9kv9z3lcua5EOku40y2LonFO4adlWicl+P50SorSVmvZRs5TJHC5IjXEzEZhsrnu+lxnwXPleuwb6J8kM2LCvfbpo/ZMuPkRmCmJ2HQ1ACvZuV5V4G6rjwig4AJl7M1oZn7SgzvYgoU29wuQ4Ktp8QRLnKr+BRIr1mZbN2ZFIRkVutw6yiNBI1t5UPn30m7B9TXiKh3No/lTLOMy6JttKkpwyuoPIfwcoZW2z9UT/uyVW7qhCZDSK9Ezl2U9i9jMJnavvjnpx0VmJAbXc4XxG4n6E7/vUREn0d5WvA9AL7TOnsQwCcwohMVwi0jSK/Ummw2vHVAXYWF7LIuV5F4hrI0jJFCykByJYkb2a6p+ogsyWUXcDltbjYNMKfwshDfT/auRQqWNIrp6RmMIbBJGxXrZCPHfC+r/QlVvH64KJcU8WYBniXli52mv2PjvEx25ZK+2l0jLcXzlBOSOTUbF1KsUH6Q9KKdIfmZorHDj4x/FQ/7ccsBG40acZZQ2X7yMsM1qlycryYgu7Sv6qhNuTxU2T5SLs+q40lVfMpAElFx5RvUme7ZRo58LwMKAp/OwTkFG6CVjlgDPT/HoFmZ3nXaDuw8Aa2ykOwlMKdzYJaArLxS1mJLHIopru+5ncqkjALZeUh2pax12NHOLXl+hipaaofdaiT67ZIrdQc0ycs8KRsbFO0QUsLIdxotmUb46bVE5IHVDVOZDjQOOAYw2Z4j38saG9Nk06Is47Lh7Zdv+13pOiL5TYzidGD9pYhCdnqOYpZanUOrk8Fg5Oebu2nSPEGSwzZERVIQgIkB76blUjcZtLQdbtlLkdSddQOkV1IUZ/PKTpHsXPRBAM0INK/TuKFjp+fgvbTeDMHFxbPh+Zmi0qNkl6yNqdN1ftYI48iN8MNyMTBLy7hUu56WX+nZHPleWqZ5YHOf8KHcztt4xZVcdpniLbt2+hEaYDk/A5iQpoxijrIT72SWNstryMcO7gUCZbALWa69x6pz2bg73lGvh2wAgnj4ksp+yzprO0eSMfj8DGaettONgfTsHABg5klrcLRXrpAMHtdeNw9vEAVgfs7z03/cD8v7P9uOdPpk/VsJZ28Rt+WUdku27eSznv3y/Q3JP9maI5+lpR1Nyh07aZaAZgN1xeVnZc5dHcXglEv9E/KH8iY9NwMbgpknoCvZYkv/1wADYKadqH6I6HYA3wLgtwDcZDtYsIda3Rh55l4A9wJAet25ZWRVFEVRFEVRFGVNYBByc3KW8EkGd6KI6BSAfwXgh5n5VaJhvWVmfgDAAwCw8boLDPSPChU7ZtToh1yWU7gR367BrMgsUHG66Bw1CNEVFxkPMoRbfz0FJ0CxQSimhGIDKKb16db+ydbu05gmF6Pw/ujL6f+whVNPFzAZNcK4+WOvgjcmMKc2MT89Rb6TYL6dIN8s75spoZjWMhh7aryZMK7/rQm2np/DbDDyTfeMfc4/mTuzsqfWLwJIju5CjKxDzCIwwJPmjE1jtmzgC7vBWYS+F9ttGMUWN98rDU3bB8KUYfO2CD+iv8VUjEhLd/a32ax/3/obKTgh5BtlOhfTMq9cmr/2lwDiOfLtCfLtFPkWId9Mar2yeWoyNGbHylPf7awJbHZQOZMik4cgkl+OALqL7tqUce6zU5x+KodJS/3ON8rwG3L4p7dndtDV32Ck+tTpZDY5mqa9+JMqkfzzCc1QyTLtVCuXGyjE7EdoyZj9n58povcqf6mW4fr/ZwvpHpfl25Xxj74M3pjCnNlCfmqK+akMuSjjMh+KgK1pLrdBtZSyUR5EWbz5X24ADBt+25aZrLQHJittlwuvWhXg2YXb/kUGzoB80/rp605WBn3rL12D2WDMtzMUW2X85tuEM48ztr74IsypTRSnNjA/LcrERm3nKtnckiRZFuxsMIStvfDQpMxja/dcWeSsafvMtE5LV94acRXbNbPb5lwWNpvHjtf+6wnIMIqJs+W1/Lf80wI0n6HYcfmcIt+klj3nrG2XQ8tmnZxmWgvTKG8xCDjz8CZOP1lg+1ceRrKzg+S68zDnTyE/s4n81ATznUTIJtJM6mAi5HOyxZYVx+qCUJlmrmcMOeymy5Y0jr5oee492zcDFLBBm49u4vo/KJp5PAFM5nQMOPVkgrOPXUGxmTXKdL7p2dfMpmNW62EjPb28rmysW78Wsq3s2UVG66yuTh3xl8C6rJPpQeIeBdpTIt3kkv0qX2MzTZFyJbnhV7ZAhbCjm2U5l7pZ2Qprw5BQZ51Vlnf7f0CfYue3t3HmibLNNt8qw35ut/+5tYNxot6DkhB3HkBjHRFNAPwagI8y8z+w174A4DvtLNQtAD7BzG/s8mfjdRf45g+8v17aA7QUnH0j2YU3TR9cyx14JspAo1g5l1PSoc6e18BPz85RzNxyB2fcQ9Y/EL4wRrFdetKzc5icwPOkcRbH5OxeOW2dJ2gd2OvH1Qt3cn4PRZHAzCNyS1mHGLRQnvnPMOwyFteA5Nro+34H0qGBfE76DdTv6Zi6jehXOEM7UF33O3WyQ8/SszMYt2TKP1uFgcn5XeSzrMzXojtfaU5lubOHRrJrLPp5F0rj3MsH/z4BdGYGk9tln/4BtRxpkMTSRcotBkgWSUf5LlZI9q4lOyQ6MCEZyIgDiv0GsS9Tl+yyIeHL7uyIkD+7bhf5PC3Luc3TyZnZsDIeakyGkiDgprF0+PyeWM430CaEsO7Ss3MUe2lbj6XcCZCe9myozaP0zAwA6vLSsaTRz1cA0R0Ls3OzMp6FK4Ool6x6ZaBlBzpseAyXxtl1u9H8nJ4v71VLwGRnW8ZV0tfIh9DvoTqCMt/YAJvbM+ztTsWys0g+er9DeVHJsiwUKEPiXoyVhC2DcnnkwnVJspMjmZi6bnU2Xi7fPj0HJVzmdehdR6BhY0PyU2gg0T3at1NnrP6LPRPSee86yfOUfLvstxUKqt+hIlT2NmrXXV4b73qA9PweinlS15+h9liXTUdHWyYWruckOVMv13T27Cv/y09h7/Gn+iznWnHmjTfxn/jZ/6Zx7d9+1//5MDPfdUgiHRhDducjAD8P4POuA2X5MIB329/vBvCrqxdPURRFURRFUZR1hEGYm7TxOSkMWc73VgB/BcDvE9Fn7bW/DeB+AA8R0XsAPAHgnUMCDL1gGWTAKG5jSpfsaDcGzEYNoat76WQrAH+Eq3ph1i3fEP4Ue2l4tMOD5NKP6vwA4VcRHpkvrmb1OSqZHZ5ioMgTkN09jYF6pKZKY29kSKT9/NIUmIglaPK+k8FfqtQapar9d3HrG+1LZlQui0l5kPtOhL6RG/FLGDQvz0xK96hc/rDB1eYArfRfBhe+Pzrf43Wxa4tnYBYKAOZXpvVsUhHQKREmFVSeGeJ2SEvLl18rXeuIb1KQd4ZXQNgXNoCtwGYE1NTnQci8cn64sh0L38XVK7dUUL2r09g8jY3Iu2sGILT99+MR9CsyMt94fE6NpU2O+eVpWS5kOb02afpF9o9fbmNpF5JJmgVPT/KrWTxP/VH/ARRXxcY3IdnsvWLmDstqBlBcmpQ7kxovvtIfOQvlE8mD/FrW8ovm3gzk0LgOUDunS/PdrF4WRAwkBJjy3uzKtLTnsPfKAtLMaz+8gTanc8YyQHFpAtosMJ/Z/GvMbBDA7n/bM1m+q+BXOQvENq9SoLWZUeyRZcMPHc9l6xeIGRUAwG4K09h8o7xBdhkcZwxcy4BNuwsrkTh7jetnqNbroPyijcTEbRvpNiIZosd9ehGrI2RdlIs88d2LMxcTl25uYx2gWtHQ8EM878pPtWNuYMdnR6hsB+MTa4sy6s1uJF3tO88/c3kCbIidTo8ozECh70SFYeb/iHix+e6xAXLCoJ3C+g3InWhiu/nElJI3i3KLUADlFtwBP0J+9u1+4uTpug+Ad4qqMvPjkpytt59mu6yhcmsLTPlN7WUPZ3IkqdjeWrplIDmTl2WRyziznQZmBjZPzUDEMIZgiqQ00rD9JjK2MiYws1ga4MdZpI+hcolWq5IW//Pu5Gwk3U4Osu/elGkTyH8Gtt7wKiZpgcIk5adIqjgxE0zRTpdOHXLh7eTYPlMuOn7jDc8BAL713JM4n13By/kOXp5v46X5Di7NN3Bptokr8yn28gyzPEVhEuS5lcMk5ZbSIu1bckgZqo6UbJmGEkj8to1o2ioqfWiEB5Q6lTCynVm5058hGJuu0u2Nt7+IO849j610jiv5Bi7PN3Atn2Arm2O3yLCbT7Br4zkvUhSFTfMiwe03vVgeppdnmBUp9uYZcnHfMOGm617F2Y1dFCbBtXxSuzMJJmkBIkZepFVeFgWBTZmWMh8b+rBtkNgOvCtDg/JcpPHO6y8iJUbBVMfJz7+In8m5cucxl+7kuUvP5nWQfjxE2R2kCwG2br9UlgFP9vqdNBcPYGunLvdVvth7dTx70qxDHD6Vg1zHjal6p8n9L/3npt9eXnRBGwWSrM5rZqu7Lftg4+7ezahkQLmMrOGpjZywW7xdlEc2OLn76iBDdeM3Kf06dftFZGkBY5KqrEjb1JvmXfWQG4fYS5tbOstn5qgOXm/I20pUtO+5IJ396MqfIY06A/BuirnrZIfi2lV/20N6g3WBk6Gv3u6Qc+cNF8u6T5YhL5+i9ZD0e2g6BcaRNr/qErLUNGRwdjohtvU4YbqxC2bC9uZepVvGkC3X3TqWbjZtUWX7DSHbskvGAvUCuHkffroMaaOF0iZWB6O0a0liwDY9ZFtlOs2r+N509hK2JzPMTYpr87JOmecpcpPg6254FrMiw7V8gmu27prnaVlPFwm2N2eNtkNRtOtskD0qQF5jbupelaiR/DcAcRJ/lcBPj1A6zZLhgxxrC2knSlEURVEURVEUZSjMwPyEdqIGbSyxKjZed4Fvue+He1/6Gzql7i/nG/v8olSjd/5yPhkXec8NbASm0oP+59R8xr/vLa2R7qqX3aUshOZMUoyuEc3GLj2ePyOSu4pbIH5uGQNQnrVS7U4Y2+QB7WudeU9l2lFeplGyl5TL+WZ2x52M22H6+jVGz4YNwrcfc0szXD7KnYxkkJV+cb37VyhMLs9yqpbzVbs22WURfhp7cUx2k3pZmR8/l1975fKKMg2b+ieX7QzeXMJ7zskylobsgfh1+dtVzkL3R8kXysuGUN2yt8q43TCks5wKvzsJDaqG4jpkyfMQOKDzQPdMSgx/1zsvDUjMVg3Kr4C+JLtJa9mv71/ohXNp3wbtBtmVvkOXEHWMgHe+FD8Gl0aJn/Ydsrk8d/Z1FXIESHaT9tIxKbMv1j60HYLl2Mog87nagMKVZefGL+sBXL0a1MFAW8TBNGxJdzOwjnviUfJndGTdnobTQ8qa7Nl6Weaf/dAetdNUhiOWBbZmeXwb5mbZRtbXoaXBQ3d5bTpohv2Vn/gg9r58tDaW2L7jtfy1P/mexrXf/f4fPxEbSxz4TBQTo9oePaImnVuLSr+SwMFsBwC7JQgZ4pWXvxVo9TB6Cyt77zsE/Y5BaL8/wvZHys016/6SCUI8Pn3rfJ0/PXAazzPOuDqIskgpuDQCQBl/2aCX4fboA7t3xhjlQc5MKDa5aXSl++mASIXkWAKemGYHTuqSk98PT7rx04NQbiGfcrWMwflhQu8x+fJs1DrDTocm7kL5KabU3E3REyHscU+4KcffYRkIT7hd5rz/sV2tQmW4YZu8+0PtViVD139Y3fMq/sYSNgTuLdpzlwQ6L365JSaw8To8leMRYTk1su9sthpE0j8W+uXpX+O+jANx436vbQ3J7+mLmZqgXsr8r8qJ8IOnpplXnv3l1MRtqd8gjQntF7ZYvhDAmbAzXR2eQDBBnG1puI/753aGG1VuRtIo/2TrmEEPrsgNbDn2d3O0yHJUlYGgPocMhGicZ229rvK35wBXDkVkUTMiym5dV9RLNsFAkdGgdpPZRHsrdFcMXD7KDrhoPwT9d+8v+WVpYsqlxFb2oUsZ2b1KEijLUgZOTJ2voaWCPkeq+1Rjlqyrjyq6nE9RFEVRFEVRlNHoxhIHzQo7rEztmY39HNkCAJovriyMwMj4WD8icY4EWDN3c+GLhx1bLjaG6PKp3JNPjurIcN3IWmgUvCeMOjDYUS+7gQdRe7CPAdpLmksJ5PNjwhuB1K/WmR950r4+ID+ZGJS0pxho5o3eh77FqFl57goBe8JNa7lEnTf+8pKx6SR1faFyHZsRDjD0LKuGO3/gf4W2p5ppDw0Uy9lmKUeovMC71xtw5HLA7gRnxhb0n+ZJUG/aSx0J2KXwvaG2bZm0IERXQVS7hxVUnq8mnczbMjbKR96sV3rPTBwS1454dtmZ0VR12vjKZV+X3/uzxfOA3ixSf4zB1TWtQNBaOVLliddGqFStK3l907VEOwW8fBpUO+HO3HrFpv/BdlDMlvjXQnbZbz/4zCNthlnSmMQfelYp7Qbq4pC7IqnLfpf72Cz0EYBRbhJyEtGZKEVRFEVRFEVRxsOodoI+aQw5bHeTiH6biH6XiB4hor9rr19HRB8jokft9/mhga565Gm/N5JYJRRaOxt02O1PLM7VS8xdmz8sk1wc+Ixx30Votse/Ju8tSGOkyX2SckOE8kVVcV++1Ns1qrtCA9Klz0zcvj8kPwn1i7RD01i68d2GngnMSq3i5XUX50Wer84/GZg9Q+Xd79nuhgyRNG/ZEr+Mjyl7I+QJ6t+Ss1wA2huX+P6Hwgn975Kla6aui4Cfo1/AD+hhl7711hVdcR2QJyvX3zF1gmOf212t8j/CFuybDI5QWQ7ca9wf0WZYeiZpyTqtc0anKx9C9UysbQAMz9u+8NzfgW20oXVStFy3HPZ6tda4reKrLeNPCENmovYAfBczXyaiCYD/SET/GsB/DeDjzHw/Ed0H4D4APzYoVAoU8JgCtZZy2G+3E5V7ec/3wG2gIBV2SEcilPcJN/xp7Gg4VPH97ioxaJZgcjHB9jOEJGdkV4FiChQbBDMBzBQwGcApkF0rH3P/3cekbHepKUV0O8yVs9qE7Krdjc7uymayMj4cMEIuipPLhM0XysNuXXilPPY5d/Aq1WH5fviH4E1eKZfqlIcOogrf7a5TySP9CS3pCUzHtw4K7Kuk5VKF0LKAgZVHeilBUti0T1EfZDsgPfqWIbXi5Dp0Vv6m5wEijc3ooYpO5kgZIVBjJ6lB4Q7Nk56G8eSVtKHjbnllpUNpOE7uemUbnK5W6Yf6Orzrzm+INJfpwRTVk8mrKagQ8lbfYmfE2qN2PvuE7KV0H3hm8nJapZHcfbEvzXpl6WIFjYDqbKSYny4f+mSHcCdfJpf579UhvfXDIh2pkFsnp/+os4ex8KMej3Dj5W9wUwGMb0A3DoWXaRyLayOw+v7kYirqBjT11q10kzZ1iL7G6owYscPjQ3GR9jCkl1zar42XCSaVdYWtL1x9KG2E2yHW3+UU9cHelBOyS0mjTJus2Vmr0mnA7n71M5EOX8h+j6lnGe26w3t+8kpaye3iL+vT2obaNJBL+hcdHHGP+3YHEJtBINyOjNmggB2J6puvP0cUZsCc0OV8vbHmksv278R+GMA9AB601x8E8I79EFBRFEVRFEVRlPWkPKS5/pwUBr0TRUQpgIcBfA2An2bm3yKim5j5GQBg5meI6MbBoYZGqP0evH/fJ7O5ZNAcKXAjeW47Z9OcRer0MyZbymU41RbOPX44r+Ts1aSw8lhZmcAbBrObDGav5fIFTKD+9mWQs2FiVLy1HCRtuptt2/9uxHVq6rgYb3TF+jm7Hpi9xrp31ydcpnlBzWeHzO4BmN1QtEbzffmHEBzRcaPqQ6aQe/JtjDz5uaKpI87/oSPbY2CUW8VWJ6t3+Nkzs9NCjjw63fZmXQDUI/duVqygpm7J57uS0Y3whfIrIOv8uqI9wi3JuLmNr9RZGY7LI9+tK9+gOpwkrFOdy2rsrfm5sK4DaI88LqMXHUNg8+vybj2cRNKsB3+b88rbVS0NC60gqAKJ/Abio9yZLTPw6gG2YSVo1xEh3V8B1Vb6sYT2Z1W6knRImQ65jV13txeMb2N5a1ed3iV3Asyvz8M2dAH16oxLaAZAln13plefzvn66tsYKsvi/HrUdrsrPlIueeZZtUyk1GdOGfMN0yzDTtf99HPbn/t1dkgGV5c6G13ZeJE+lXzCD2dDu9paMbtv/Z1fnze3gvfbJ0B9vEZht4bvsV+D9dnPx8yAJgacJ+F2ZJ8+DtVXGe7AduV6crKW8EkGzb8xc8HM3wzgAoA3E9E3DA2AiO4lok8T0aeLy1dsqIzW8qYREBOSzaI+98hhGz60UYBSEQbQaTjc0hxyDUKf6vwSr5Lo88s5IwZNTHta3VBppOa2cyV7775RMG1j0Vq7O+HaiMvnqoMhGSTPIgmERSw7ekKGzCCZmGAjkAyVH45//DC6lkN1EdwRa7No6pQfL/kZ6XcnLr+41Dl0vdMxguC7Lgnb9A/EU4bjV/qBNG/lTYefjTTZKIDEprdcDuaXNcDqXMBPRj0A0iW7fw+B+65S98/Okg1oIT5tFOF4eu7K/PTP9EF9OKhBWK+cO3dopgu3SmfE8w49eRR+oEPvezrysfPGOgjqZUS/xlDbXk8uKXefjBEdJnl2jOdXmceBtJMy+eGHbErfJxDfQXEIORuSFr6cMj49+td6doQN7XwPN/Q/RGjpWeS5rvLSq4MUsXlTE7ZnIS822za/ZWNcWQx1CEJIHfDLgqxj/MHjkHuX9+7cwUB7qJVu1u4l1ta3bETM3gRsaEv3fDe+v348Qp3yqQFlXltqFXbIa9vQ1NT1rS9vV1heGenUz5TD9u4owgCbpPE5KYyKKTO/AuATAO4G8CwR3QIA9vu5yDMPMPNdzHxXempnOWkVRVEURVEURVkfjPc5IfQu5yOiGwDMmfkVItoC8GcB/H0AHwbwbgD32+9fHRxqynaaeJjz0IjC5iNbSHIABJi0/J6fYYCBjZcn2HqOYdyGCJNyowbOSrfsNktwmzKkVpQEKLbQmm4++/sZkKDeaMH5E3pBlNB4IRYAii3G6Yc3AdTPmKx0x5PyhdDqhfPIy/PNl44DQxfE2PzjCTafF/5bOednuUrrc1/I4uki4lNuQFGny9nPpLju89dgpgb5Vop8i1BsEPINQrEBmKndDGMSSJsBcWtFKzRTSUIfxPWdz20i3avjXaVtVudNS4akvQlEQ4aO8Ou/tQ6f+t3NcjOBNKIf7qXiHhlc+FTJUX4l1xJsPTYp3bgXkZ3/Sb8ONvTIj+MGA3lSjaI1ziYSZfTU5zeQXQW2n0sxuVSg2Eww3ybMT6UwGdU6lwHz01bnKllqGc5+JrV5JXQmi6cXp6WschOTKp0K4MzvZ1V+VxuhpMC5xxKYDCimBDMFzn7JgBNCvpU0dPf8ozmKDSDfIuSb5efMEwXIFMi3U+RbSenW+lNMRbkRchsrd/WiuLdpCm8xYGdteyuZkK558MS07WjotzcyCgBnPju1G9HU6dWrr16ZaOmUuE+gzrITjPKccObz00q3Q5voVOnr6XixbZozgFb3zjy8Uf4VNtH5f+rJFMmcYSaEYmrt4RSNDXWC5QsYbssim+P4NqyU0cvPQP610iwy2t7apbUa8QdQRPzpCs+fZRg6eh7QvajTjby9nH3gs6PJuDzHy2P6zARbz9EgHdz+wwzZFS7tgK1Lzzxe+unXjcWGZyuy0j5IfQYBxY5bogdwQtUrAMSE6ZNTbD5Pta3z6tpz/zkpbaqwUWYCnPuj8plSHqHr9r6M3+lPJSADnPniHCBr/7aTyi7OzpJICxH2owlMav2W/os4n7VyFNO2DPlOvWlVvsWgajlkbVOKLYPs+SlOPRHIn6SZR83NOnrqW2Kce3ijsocmK9Ps9O89B97eQHF6E/NTWSMd/DRu6orNV2n7AxtoZZcy7DxBdZvBfqqzzI4SjIWW8xHR3QA+CCAF8HPMfL93n+z97wVwFcBfZebPdD1LRNcB+OcAbgfwOIC/xMwv23sfAPAelFbwbzLzR0cL7cehsdNcOJLfiHLjCFvc8RAz/89EdD2AhwB8FYAnALyTmV/q8mvjdRf45g+8H6e+lFWdH78jEmwIAi0F3HghQTJH1UjjBNh5uix8s9OlklcFq9Hg9BoIXmV86vGk1SCTDcKq3TyiQzB9JUG6W/9vyuR1MgKFrVEhC4+9v+DNAtV7HGJaefvJDElehjk/JRpCoXDctzM41q3ZLkAbBjwr1whTQfWSAsnIhtNgIn4xMWgnB8+Tev02hFwDOuqNBkRPeKHwAYC2C3BOC8tQyRELJ2Vs/XFWrRl35aRVYXj6XMqIYMXh2HkyBZmO8mL9z0/b9fibBcClDtAe4dSTSV2p2edOPVmGbybNysZkQG51kEM6GNP/yO6GnHC5BMe9q8d1OvJWUTaU3PVtoSfCre8ODGCrAOYRXa96cIEGsvsdyMrNZ1Jk18LpHBrQCVX8Mi12nkhLGxDrBPl+yQbJtunvzPkNZ7l8qGu3yUDch2zzy8TAhinzoq9R73HqS+V4oJ+u89PunSgPYhSnTNyOlQJVbnvpshf+vYjbncft7mSh/BwzQNJablXH4/SXUnDiDzTZci7th99ZDOkhmnI04ubHsSsJrdutP06RzGS867rdT4NGXGP1pZPPlw3AqcfTaoBGhpVvl+E06lY/DOuX2SlQvV/s7I6si1y8A3GP2XqpA6e/bMBp3emYn7EDVVLupG6w59u28+FhdgqgoHo5spMrAO+UtjDZymFmacNWgjvK2Q7Xq+/89LdpV8kRKNunrF5yVsbbDbDJztb0IiOdAfkWqkE42fmI7nzYV7cA4O2iHsDgsj6nzJRp4NUNwfZCI3M70likDWem7My7NLbPfOV//SD2vvzUKltP+87G7Rf45v/x/Y1rT/x3P/owM98Ve8butfCfAbwNwFMAPgXgB5j5D4Sb7wXwN1B2ot4C4IPM/JauZ4nofwPwktg5/Dwz/xgR3QnglwG8GcBrAfwbAF/LzIFhpeH0zkQx8+8B+JbA9RcBfPcygSuKoiiKoiiKckSxg6ojeTOAx5j5iwBARB9Cuev3Hwg39wD4RS5ne36TiM7Z14du73j2HgDfaZ9/EOUrSD9mr3+ImfcAfImIHrMyfHKs4JJBu/OtmstvmrV6341vAUWmCPfeeA0mtyM+dvR/94683k1F7qg3JBw7JHHxm2b1bIIbRfJ3+eoZzfFHKvZumYOmppypiO2uFtM/Lwwq6utcrgup780TcOaNEDNw9Wv3yuVaBvWuXCYwuhKKmxw5cZtU2FE6Ik/oUBzcNdPhJhDPMbNYvJvG3VPA776wR1DNeuwlq5t5C+gFFYS9r70GM3ejg2gO+QV0cugM2+Wvm5WjbYUYUQ2MoHLKpf4AQFYujeMp8Oo3zmv9ss/ufk1RjsjKTUqcfCPLUy/eqG416yGX6xDAszTovpz5qN2BAeyldjga4uM9J5ebiHDKe2il9bXba7tHftxjRHSKiXH56/ea6e7750yBlFuUQ065XF8QGS2vRKj0YYCCB5x07tzn6SvLmVzvfheX3zRrzmC555w9dLMF0vZyOw2aL4gHAh9jSzp0IRqHUL0YCbdVvkOzPyweJuDVr5u36p/Kn1AjaMkZx8GyArj6NbOmbXP5FSKWD12zAMLNpTtnrRlPFxZnplmeQuUIKGV1G+gwgcHl7LU7T8/t8OfXQRxPp8oWG8LVNwVWN4R24HNyTkxZR7t70qZlXO9m5+u6ZFbKb2ZpML8u32ltjj/T5tt0E6l/Uq6Llfi+9PW17l99UyFWlgh3G6b87V4H8dppSy35ZDR2ZeScgMT653bQg4hzKKhQlnaV/YJKPVmi/bFWtGdBX0NEnxb/H2DmB8T/WwE8Kf4/hXK2CT1ubu15NrZz+K0AfjPg11IcSicq+j5UqMEbMbzmWlYrvXNaNZLQbrxJ/7sMbe7ttUFW3jFb+HqNEpolpb3raaz0Qa7jQ1z2+gllRwpoNvh8ZqKBL42f/Q5WcDLOhDLcGVXrHBrvHwyxXYMqe3F/QMOjqohcZRWjryPVU7kPok+GocT0nwCzl4bdRGVCnY4xo08o9QNoN+y9dCHjtjGm+r0KQwC19YfngXLkwvPL05By2YXr/LlGkNQL353zX4bh7ZxFTEAOcFr6Sa6TJZ315XVAx2kvBSfcXFYzxo8qbPuwzbcuYVoNC2s/GlsJD+kYGCoHcKwu+QM4Y2jZG5m240czSwIdKGJqnFdCfuehqA8vbckTilqsQe9sr8/AzlMjDmPoG5gyskxYgQIDeGzrE/L869TxwL1oB8pfNhqz73tJ4yiPVjnx9bXrXuy+u+70ReJk9Lc3F78bcXTHIkiWbRiLAR32ZWQIGxbIgFjZcfZ2SCfDoOw82PfNW2no3p2Fd92z6cHOb6yOdO2LRrwD7maJOEpEpM2SnRAmDtYVPHfvCXt5MLRcOxvb15E6DsgOdM0LXcv5MKwr2tVy6Xt2kfBGczidKEVRFEVRFEVRjjyh9/F6eArAbeL/BQBPD3Qz7Xj2WSK6xc5CyZ3Dh4Q3msPpRHXt4uGPfriRUznSRChHbJL26AH8UWiCONDM+S/uOT/l6FawvxoY9fBHt+RvfxQr90ZhYrMDrXBrP9yuLZxQtRMcAeUSPt/vluwuXdCId2yZhT9wRYbK3cAI9SyEfeF3SP/ezZw14i1nSTpmg3oP8hwyIxYaqXSTJTkaZ2KEXoIPyiBHHGMjbF2jUHIyJrSEzn8uT2r99kcVCa3pdMqpuTlLJGwYgOZJffaGk4Mpfo6FXMomy7NTHKlnUkYWz8cYOkMi4kJulJLq2RdmT3aZF5G8rm0LVyPoNC//uxfcK3cdZU76K5dLkZs88s9zk145+YnjugeER3ZFGoeW05QbiNhZpWRA2QJAszKcJKf6he2BA6hB/309F2WIDHWmTUdAlR+NsF2eu1lZv4wYL31FPcEJN2byyG7Ow1PTlFv4VY2mSz3poZIhVKZdOC2bDlRnAHb4S3OqlywCrfcWqo1xRH3Z2sjFKzP+s33QnGp/nfCBckmGyuRz92w5DMbdEdDhSu9jNhkIlx1Tl3tO2n4OPlA6dJis+/brv65nnb13+SHbNPXUWPndOvctkABDZ6NcJoTki60ikLIAdkYLzTj7bSLfX4dbDeRWPfi6EjlzK5o/3qKIQbPGdjVCdS0pHVGe1Lrh5aPbQbXeGVPkn3DfsjeJl55HlOjS2zifAnAHEb0ewB8DeBeAv+y5+TCA99l3nt4C4KLtHD3f8eyHEd45/MMA/i8i+gcoN5a4A8BvjxXaR2eiFEVRFEVRFEUZT2CAqvcR5pyI3gfgoyiHeX6BmR8hor9u7/8sgI+g3JnvMZRbnP+1rmet1/cDeIiI3gO7c7h95hEiegjl5hM5gPcuuzMfcFidqBEDjdd/9UsoDGFepCiKBGlqwEwoigTMgDFUnpBs17+zeAma3Wi6HFmvRmnQGL3krQKUMNKJATOqFzTLbzeEACTTogqjuuf5z5umHabfSU8Y5F6y9Gch5MuuW+V20mwIZ259FdsbM8zyDG+56cu4UkxxcbaJK/MNXJlPMStSzPMUuUlQFOXHFDZtrP9uL382hCQr0zKxJ7SzKcOBIbzhtuewl2eYFSlm1s8sMchNgpQY3/Hax/HqfBOvzjdxZT7Fbp5hlmel2yJBlhoUlRyEb7z1aVzNp7g6n2KvSLE3z5AmjMLKU5gEeZEgz1OwIRiTVPlJxsrvv1Drj2hX+hUYZXTu5XVb6K9/w8swjErHXLoZ+6I7G7LvV7TzmjaKpq5JuZjsafFc5WFbF22+cP2cHP1ujVp1DVVNTT36x8DNb3gBAKp8KUyCPE9gDCGxo1+u/LzhphcwSQtcyye4Op9gdzZBlhrs5e00QUCfmuWNvdFJFnkVkd8fbYw5jYwinnv9y0gTLnVI6D8bKvPR6jYXVJ5Ez9ZWmHbe3XL7CyAAsyLFtdkE33TT07iaT3BlvoFr+QRpYjArUuzOM8yLFLlNI6m3EH6zofa23R3xKreQt79DtqEPl+TE8M+XOvc1L8GYMo2MKe2o0wEjbJ60bWcvXMTGJMefvPFLuFxs4OJ8C5etzdnNM+zNM+QmqdKhsjnV9s9N3Xc2pmJqwnEMla9I+RmUtvK+GEX2R5Cr6wWBN+pZp+tfdxFZWmBvXtq6PPfsRJHYjTEC8sl4+eJtFW35YvWCkP/GO15AYZKqbDtbW+og4Y23Pos/cd2XAQAvzk7hFZtvCRlczafYzSfWbqf4tpuewtvOfw5Pz8/jmdk5vDTbwcuz0v1Vm8/zPBU2sgwHrt71dEbKf+62l5AmXNVNeZ7CGGroCRtCOinT2l2742ufQ8EJrs0nZV1k65b5PC3jGLHNLf3qa29Ypzfe8QLmRYK8KNOzKh9FgjQrrFzNuina1pD5lTAoM9H06dURF5eNoumGYW2tFy4AZAxKTVMuWPd2QwaujEwkXWR4nv80LSrZ2mEAF17/IuYmQUIMw4RZQ3fKtHV6WuUdUKeRsx3yfcPYO1ChmS3Jwge/tm3K2dsuYpIVpR7a+BhDyDKDSVpUdY8xhG+45RnsFhPRPkrb9YWomyrd9WfOjggLLOcDM38EZUdJXvtZ8ZsBvHfos/Z6dOdwZv4JAD8xXtI4vedErRJ3TlQZcodDIVIyS5pLxlxDmGyl5/szZEYxEOVqKYbzN+ZfpCJu+dUKQPhLaL8EH4Kay02S3aQ69yCZozqroTVlHJo2lvK6b38HHVlHz6hOd/dxaW+XOLlDUINLPrwOC82pOqeh5Sb0gvSAfI2m3dDGtyXZS5pxjfnhhe0vGwnpTWu5UAed50/IMGL9EC+sznh5eU57VC4LTcR9Xy/Et9TlxncXi5iagc9UcQ0ty/Q6aBRYyhNMN9shTfaoceZItSpm6Bk5Lh6huIT0vKsTiY5yHQjT31iCZi4uTb3o0lFnd6qlYd4ZeZ3lNuB358YSwo+qjPXIV/kZoVFWQw0wX+5G5wxVHJPd8lyaxnI36U9X/nalUciGhOTxaNWNnr80JyQzgplwbz2R7CXVEnGQF8dA+ffp05+qroj5I+qXqr7bS5pL1SP1bTPSaOZfSN6IzjfS02sHdOphSPXktUUa8SF98ZdIx9IjVqdKArahulUtR6N4Gyu0XFs6ccurRfmRfkefDeVfyI1zN6B+GLUUs6fdUepywO4B4TZPpHx22fCjeE7U5oXb+MLf/JHGtT/6sR/pPCfquDC4z0tEKRH9DhH9mv1/HRF9jIgetd/n909MRVEURVEURVHWDTLNz0lhzMTh+wF8Xvy/D8DHmfkOAB+3/4cTGkUIXGu9ZCxGX4Kji4zuEYrIdSZuvUwalbPvXmiUAmLkh/tHVkPueGplpPqU8qhcNrzGaFNghJVDo8kIpLt8luyIZUfYrcuhF4Tdf/9F9QGzUEDH6DMHPh1Uo50jxn6qsClwTcgweASs8iTyaQgcftQPq7XhSCgc53YSmFWRbvxR7tbSxcinR+ZVEYprUEagN58baUEAZ6hnX9AxE1F5EPB0SL4OpKX3HTre0gm7dNeXtWUr5DPW7riZylb8e/LW97dhczrSobGpQ88yxr5yFgyzq2yg7c5MObzpQsh9R9mJhocOnQ3FqWcDDk4YZtphd0Xec8rds1ANjwNR6NGf6IqFANWsTxaJXyzvfL97ylhLL730HHzuUEhMmX+LlPNQm6bruv/sgDCZeHA7ZLT//uYLls56ww+rq30z0JYDI+vgkDziU9UNXbNK7nrXpi8xG77P9eS+wdqJ6oSILgD4PgA/Jy7fg/I0YNjvdywkQZ/yyAZ2wAh3VjojG9NAR4EboeAcq2TRLDxjG9iccJUe5S5ZonLqINS4D8orcekeqoAJ9SGDQysIp2l9jfqRFc5SB+w5+jpxB8SgndJGNLJaedgVr9COayMauaMHGoYw5rnIjnEh/ehNZ7+SbJS1QINwKCMa06PKdCUognrRiG+sXHf46+xOIx2kjH0dyJi81U3xPaLR25JziD0dmm8h3Q8sg2w9M+TaqvDrxsD9wfVEV/7G/A8QzCNCU+9inTq/nuzbBbKrQxy6HnDXkLfj/qAdYlfdCO7qJC3rh3RiO1N+pyq4a+WQzh3Qnd9dsnb9D93bz05HqK3U1ebxr/fo70raLmsEFc3PSWHoTNRPAvhRNFf3Nk4FBnBj4DkQ0b1E9Gki+nRx+coysiqKoiiKoiiKsk6MnLA4LvR2oojo+wE8x8wPLxIAMz/AzHcx813pqZ3xzw98ebn5EA49EwdPlY+lmglCd7p4QfctAWrJ2zeK1zUK6MsSen6oHwMGa5Yd0Wkt9Rnz3D7IMlpvIvo+Ol5+fgzI1+As5yrK39gkGDk7FBt9bfkVKm89o9udhNJ4rH1bgCqeA8IaNZswQtbOWfgVxdnP1+jIep+ex9z15d9YuxhyMtCG9Oq8r7td4ffp+BJ0ytnn9wJ2OepH7LZcmt03WzWEVTckQ36N9X/VttmfkfLCWLjtM0bGg2rjdbSV/O8GA8rQsZmNYpzY5XxDtjh/K4C/QETfC2ATwBki+meInwq8cuQuTSGiu6/IS126uo+FsU/2hfwbVBMHLg3YpUbuzNPbuADaaTfkmUXv7yNj80kaz2WWaPb5H5JpzG5DS+vfwEbf6PK3D2VulWWt4ddYL9e4XhxqP/w8rZ4jdOfdyEGIg25ErKQ8LKK7+xTN3viM7eCvwF2nfVr3shFJy1E7vDU8XVKow/Z/CUK7G7rf+zLAvN/4S/sCg28t/Vmm/jxCEHCilvBJemeimPkDzHyBmW9HeSrwv2XmH0R9KjDQPBVYURRFURRFUZTjjs5ELUTwVOD9YukRxEPs6MdGZJbxrzFTNGY2aGwYfazByOIqZ3+GxDm4/GufCM1Ijd6Q5BBG/NtCHFAwHTN4i/jVevEciMflAJN4GZ1b2ezk0Jn+HlmAYfl1ELO8g1gDmycZlJ8yzxZZYeDfH8la2KABHBU5jxpHfaZlKMEz8UY+c1Q5SR0nyahOFDN/AsAn7O/oqcC9DLFRVq9onqCxG5arBAjdO6UAqE/FjPtfOS3qpTvRA+aA+CFzTl5DoLx00DiQMkFzG/VQuenxN9klG2+A8u6DL4PvHPgzzXPn2LtPaB+OS6i2FaGCQDnah/1KP0RlzcTlQYaE5o5+XIflwm0dYup/u0e9jmkwz0LI1yLsc8ksaR8E7EPN5xr+yTRfcNka5VTraiT+TNw9d+wZsWQvaR6sKv3j5v8qv4H6sGgbN/afd9ekf0Poa3SH0qoj/eQyCP+gTKCdH2SoTCOp7wG37rBdyglUAEleHlBb7l5m3Ve7TQbSwSuDVBBoTqU5SkSZkc/J70hDN7ruXroV9gKFcGO/y3xGY5e5vko8vZqUz+beVthdxxZE5CW2crlTiz2b3kq7AUtdqnz1dLThZk51+fBtpixTeaOgN/yjGdVuPb+IUcsw0o65w5+jNiwS/cpuRXY+pTk1D0h2bhty1uWntsPcOFw6WP96cegivVYKyG5nWd9PYZOkTtEsaW6V7eogU8vZuOd+51RX/R154G9BXYUXsG+VTfSJ5GsD9r473FYHpofqoq7n/XyJDawa1G0ded0vt3657AovIFejrIh7UR2XzxZNB8F3GTkSj8Azg5fL9cgF2Hj5elsF2rwWbEMF5BtVh64rzv6dQJaZiVIURVEURVEU5QSTnNB3og6nE9W3pEAOGrgzSkIHl/X14MdsFBA72M8nQecskhu9dqNudQBoj+6MWA5Dc2qOZLgRYTv6HhzZINQjeT45lSN6gRFBJgbkYb7uesYgN6OUiVHDRDzn3HvBcsrNA1HFjBzl5cm98hyshn9+vDwaZ5tUFztGDl3QaTl0YjZMOy8aI9V2WNMfUVx22YcM0/nVNUPQFxw1f5stMyxdGOCpXcZiR5Sqw1VjI5FA2++uMFJu5HnDXVe6+qOdMhiR72bTBN00/MgJZNwsUnzmkicMMJDuUthWWd2o0id4SHf9EM0IiR2ZlWWk8byMp0yH1E+ztv+D4urKaBqPd+N597egqszIZ5kCz8RGWiU5IcndjJwbUo6LM2QEubK5qVdPiLRId8s/JgUY1r4JN0xcrSDwz4KqZNiw4jbS1skAwB5aG5wRi9k0ROo2iTwEVi7rnbC4HPAjq3W5Eb6cCbWYDYPEJNWsa9eM0ajlR9UMiKhr3PVQuQJqeW28Zd2czBM7Y4Vg+gIo9YsAEgdkB2cC/LLt0pnE7IV107v7Wldd7uqcSD5KeKMATUzlhhl13cPiOd8etApu0HtbVgiNFSQy/KEzJLKOD+gvT4CgPQ61Tfx6MKf2eWx+9Kp4NHUqWL6G6quvD/5MOwM8RT3jEmrfSQJtqKA8fe3ho4DORCmKoiiKoiiKogzHjbecRA6vExUauQllgp35ke8sVV6E3keQxEaKQrj3fYZsz9rhV3qVwJkd2WRvUN33e8jog3WT7hJMhvYITVGO2lTbD7tRYzuKRkUSTKfs1RRIAJOVI7hy7Xl1Wrw3QkKGMLlMKKblqDTBjgTZNfZu62QOJVDi5WFeykszQnqNYCYAUiuLHSEjouboZyxbDIVHxn38iZ08qV8k9vWRPY8iI3ar2t48u1KmAWeo3lmR8S/FD4yexjBWttCsTgeTi+V7VGYCcE71LHBoNJpG+N1452uA/I6OJPXzPfQSr9Qbl8bI7Cyun5Zu1Dkp31PZeJmQbwHFph0Rp/o+SMzSFNRMFy+O2SVCOiPkWy5PuRwpz91zFB/tjr2LUUU6fDm7au1FxuWMD7tZr/5nJell+z5LxvUMhf8epOdXVznIrlA5YzTx7OOiMx1o2lzY9JWyTK4kmFwi5Ntczk64my4/rfvsajnLbibCJlq75s6GIRDSq2RtJ1fveabXklK3nP/erEvnTEZjJB7tfCn6Myr6Art7B9CGR6DynTTPthITsqt2hsIZQM98VO+wjnzHJJnZPK+FbbmJzdARkygndV6bjMEQMxZOtnk562smHH8dOiK7Cy/oRs689GVHLGn8fAz4Q3spsJf2t20WJLuSgFOU6eNsoL+SxEfqZEw//Wsyi6W+yBk0adtc/l5OQUaUQdfOgEgPBrLLibVvCM+uL5pHffGScerzJLZqaVF51pyTusX5esxEdShQ7FyTRoGPGbchiunPrHZVDgP8e91bnsLpyS5mJsNekWEvz7CbZ5jnKXKToCjKDxuCMQnYAMwEmO6p+29462OYpgV28wmu2Y/zd16k1l8CmwTG2BdrDYENNf0sI4lbvuUr+KrTLyPnBFfzaennfIJZkVZ+5nkCUyQwTJVff+rb/jOypMCVfANX8wmuzDcasuQmQZ6nMIZgigTMVMbRELhImnFjAKcLfOtXPw7DhN2ijJefZjH/4OTy/UQzrhV+R4hd47jdQYudpbNfO/N97Z98HBkZzEyKvaKM/yzPMMtTFJXelPnbSoOQ3rCNn7/8Ixip+uepb3wRt525CAPCXp7hWl7qxEzomcsLpxfgflkGL4H05ewo033ndPj3X/+WJ3F6astmJG6ybP7S9/0MXpsWeL4gPF2cxpPz6/Hs/Cyem53GS/MdXJxt4sp8A1fmU+x15NU7v+OTeO91n8RVBr5SbOOP8/N4en4ez83O4MX5Di7Ot/DqbBNX51Ob77U8eZ5UZdqlc6tMyzy2UX7Tn/wStrMZZkWKq/kUu/kEe0WKvXnWiGujTHEzL8HAjd/8Ar767AuYmQxX8ymuVDLW8c1zqxOmTDuYtj9Ozte95SnctHUJM5NWdmcvz4Lp5/zzdczXra/5ji/j3PRa5adffv6rNz+G+2/+T9igDM8UV/F0sYEn59fj6fl5PDs/g+dnp3BxvoW7r/8cbshexYv5KTybn8UL89N4abaDi/NNXJ5vVPnz5hu/jNs3X8SlYhMv59u4ON/CD97w/yEF4yv5WXzFPTvfwUuzbVy2OiLzNs/TdvoLm9YqP1L3XUPfDarEyg+hPUDklSlXRpgY57/1edy4cxm5Saq6y9UH0g4PrrtsuN/4px5Flpiq7qrzp/a3VSfKtDC1f9/4X/4RpkmB3SKr6guZrhtZge+/7XPYMxlezbfwar5h03+js85kJphCxEVurjNk2XEXsn3S0xHjxMvTUKelLyy/4yu49a6ncf3mFeQmLdPQ2gVfL9lQo97vKn99da2rZ4cwff0l3HnTV6r2QKwu/NPf9hiun1zBVTPFpfkmLtl8vjqf9tu5keWsBQ2LEyPQuTuuMHR3PkVRFEVRFEVRlDGc1E4UDelRE9HjAC6hXAiQM/NdRHQdgH8O4HYAjwP4S8z8cpc/G6+7wDd/4P0LChqZZl8zsktptemDv5WwozcOgdGLpr9tP2PLzWKkV9JyWVGK5tbQPUtqsstpuZTCLbvzttcd9CK4HOEpgHQ3CcdtTJqtiMM61yG7HMnfvjQIiRtyNnDZYXolBXG5XKa1lM+GN3g7+RCHVXwpUIa6NjEBsPlsBjNhmGkkPUJlLpAuk4spaG6XqEy88K1sq9apIfpUyewIyJ5etS/yh44zCDzTF4/sclpuWrKMfYz5mYXjml5JyiXDG1zariyc/5VNjNyv0uSK3QjHLXFMGNmVpNy0QlxbZoniqojZs5A82eW0HJBPe8r+oICFv5fSuvyEjiEYQXYpLdM4pte2PmmU1wXqKD8OS9M3w97nfkU4uxB6NWDhbbeHrB7oq6fs/WQ3qTeJ8dolUr5WmR+6IdUq09Vvf/XMCg8N+yt/74PY+/JTR2oOa/uG2/hNf/FHGtd+5x/9yMPMfNchiXRgjJmJ+jPM/IL4fx+AjzPz/UR0n/3/YyuVTlAVDLnOdA37U8W2aZ9jATQMSe97VySecf5umXqHowH0dTrNlgmvtbdyxp4vdkx4Fxbvua6wG+8TpUCx0X5/TPop49Pl7yo4rMZOsWnCywcCaRBcytrD0HhF9UL6s1+V0n5CVnf9s5M69HZ2zpTrvBvxDdSGXZUpA/m2QTJ3eSf8EQNYcvnoKnQwai+8Bk1lixLPjcVscvtcpw767E6xLfSrwz52+dHyc8uE3x2zfhbbBmZKTbsVSH+z6fnD1c2GTI0yYmUsNrmZti0VORj75RN6dxNAsB5t5E3DE9R6HdGTFiIdGrronXPny9WXNsWWab8DK2UM1SdS/o66rUEonjG7F7se8973+wDtabHtdv4DYjawYeO7OgYx/Pj4gze+HyI9zKapzyvzwpVlqFXmG/0/L3/3I01D5zXG0sx3e1TqzBEQcGLfieo6urOPewA8aH8/COAdS0ujKIqiKIqiKMrRgAEy3PicFIbORDGA/5eIGMA/YuYHANzEzM8AADM/Q0Q37peQDmICXZXDqBBTuKhHNv2R4dDvACsZIXRLXmKjVz2jrZSTODk+8DyoO85eHGMbJJSjdhE5pTNv1oz2qLn2lZwc8rcd/ezavU3+T7neHCI0eui5P6hZqQMlRTky3pMfQM9M5pJwwmXQsYnSeYIkt25Fvtf/u/WxK177mZfJtXJZWmPyo0dvy+UkFE6LwDUqqDnj5D4sJnIYYFN6C6Y6XJFelX4vk1ZddijkfDdpnn8i8rQKisUMwKrsjiQ2S9YDp2zTMywLGKC5sFtklwCRjY84T6gevHYZh0Z6VLugemfjsItTI8FEnA5hVr0hnzcjlVyVh1yJ78YMi9Tl8ka623yuVYbKQJDsJdVv+YBfPuQSUSZUO5I29Myrw9md2weE9ShhtN5SGJkPtJfUI+tW1kqHpL1w150oSX2vcVakeCaZU2O1ChVUF9UqXbiVvnW6LdHOISC5RrWeBvKQYM+1A4JuonK4R3apLkf2mWRe29FWnhvUOzAK2WUac2O5Xh12mW7Wb6crcmYtkBarKHM0t7tGWptenePp6QYTRFqK+wnH03TohiVrxkl9J2poJ+qtzPy07Sh9jIj+cGgARHQvgHsBIL3u3HgJBUwM3g5M0a5RO7raTbBVIYXd+w0Fzrg+RDEQR5KVx8CyFjMalZwjnjXb9lBTblZCK5EjdPto2pPRLKs3K8UZ9oD3PDEopu7P/gS/H5gtsYxlhO62dsuS+I27jFGIA1AbS0xY7CLZ4UdUjpF5PVSfnL9mU9SAnt0p2yeLFcSQ3NHyvkxZD+msM5UpozhVlPnetWU8odn47pLH9SV899KDAfHZ13IcoNqNz69HPV2N2eJiJ6InHsW0aPlPTPXzfn02QOaG+9C73LIxP6TMyst+PbxhSi+kP5tSqIifA9olxTTQyR7x/LIUp1yHP57+hX8A/QhZKt0Sz5mtiF+M8HK3QTY60FkGojZulfCEG4ddNzo/XvzMNoLXoxzFgWEGEl3OF4eZn7bfzwH4FQBvBvAsEd0CAPb7ucizDzDzXcx8V3pqZzVSK4qiKIqiKIpyqBDsjKL4nBR6O1FEtENEp91vAN8D4HMAPgzg3dbZuwH86n4J2SA0mrtmNA7K86aoQzRGXBidcZR+uwMg3afTfeRe36eFaT+/LMH0GpBux42l9Ga/5bCfapR6nctgSIekzF7Z6fXLLSXp0c1G2njeVi9rJ95nH/O6S59acR9gdwan2SJyUX1vkXC64ipnVlo7uvnuqXTDyQBbGIrDAraLmPatLEeRh/B6VLoaK0dDiJUB7/rYOmhwXRHI11FlLJQ+sTISmM2rwgzh/I491/f8snSkf8UyjeBQfLriGJlNGmQHInqwKlsVReYho56FCsnXtwLhmLDqd6KI6Doi+hgRPWq/z0fc3U1EXyCix+wmd73PE9EHrPsvENGfs9e2iejXiegPiegRIrp/iJxDZqJuAvAfieh3Afw2gF9n5t8AcD+AtxHRowDeZv/vPxz4rCFjCnDLXU8cK78D09ajGyF+I3GQwBF5uh5Z8v6RZkTDal8N/wi65DjwBt8QuhpVXct70N+Qi/ofa7APDGd0FBfsSLUaovJ9ni69DFX8S3Z2pFx9ci7iZ29np8ddtV2yfJ9ljIxLdKoOvFx11KGdHZgh9e4+1tGjdWXRZB3T1hgbx1gH7SAYMFjScDdGrtCgVV+45LkJXB86yLuv9WdXWV7z9ui+wwDlzc8KcDuA3wHg4/Z/AyJKAfw0gLcDuBPADxDRnV3P2/vvAvD1AO4G8A+tPwDwfzDzmwB8C4C3EtHb+4TsfSeKmb8I4JsC118E8N19zyuKoiiKoiiKcgxh7MeOfPcA+E77+0EAn0D7GKU3A3jM9lNARB+yz/1Bx/P3APgQM+8B+BIRPQbgzcz8SQD/DgCYeUZEnwFwoU/IMedEKQvgj4qscmem1nkK/uh764HAtTk19/dvjNi6a2I0PuTPEqOsjZd5iddzlmNJ3C4+9YXI765rMb9HnrMyFuffuucLFVQtQSEj0ptG6DF6rg+VpeMcGmJqnrsUCzdSxvryoWtZr3tW2g2S5wL1pBXl0nZF3Hm/h+w0CLgyUkWy08/OazH/Q2fPBC4ls6TcITWwC1twN62YvH0yxlb/7HN5HosMX+Z/ecH7Dt3r8XMZDsU29YkuZ2LG+uVH4wjOajTqupB+hLLK35Cgzz533CND4XPoBtjWXvzZFV/OiD+HXYYPin14D2rIDuC3AnhS/H8KwFt6nr8VwG96z9wqPSWicwD+PIAP9gmpnShFURRFURRFUUZDHHwP6jVE9Gnx/wF7PFL9HNG/AXBzwMv/YWjQgWtDhzqCzxBRBuCXAfyUm+HqQjtRB8wqRyWCW6GPZWrPK5B+HOLAyXEcteFMxOmIRm/d84VTLs/agvfuRuVgNeEM3hq9Y0YIEytQwMmQGdtFqfyYuAtobtPbEwRv7KMed6TJ6vxHfxwz711T9r4jrGI2ZO3L2Crqm32gL93GbqO+nDCH9Oya0Kjrqos9D00jbhZJD0L8HLplmYjfxyCvVk1gi/MXmPmurmeY+c/G7hHRs0R0i51Fiu0A/hSA28T/CwCetr9jz3c9AwAPAHiUmX+yS3bHoC3OlTVlFS8ynuSXIQ+Kk/7S6UEw5iXwZYJZZPOWlifofbF7lbvhjQm/9zn5vUr2u3wM9X9BHVom39ZlM5lejqgNG7sDoLIEi9jhVXWgVvFsn79HtAzsOwyg4OZneYbsAP4pAHcQ0euJaIpyw4gP9zz/YQDvIqINIno9gDtQbpoHIvpxAGcB/PBQIbUTpSiKoiiKoijKQqx6i3NEdgAnotcS0UcAgJlzAO8D8FEAnwfwEDM/0vW8vf8Qys0nfgPAe5m5IKILKJcR3gngM0T0WSL6b/uE1OV8io6sKMeLA9bnIz2SPVb0IxzVwfgvxi/j1VHWDUU5CLSIHHmIgWQ1s08VsR3AmflpAN8r/n8EwEeGPm/v/QSAn/CuPYUFrL52ohRFURTFRxt3iqIog6AVd6KOCoOW8xHROSL6l/Yk388T0XcMPU1YURRFURRFUZRjCDNgvM8JYeg7UR8E8Bv2JN9vQrn2sPc0YUVRFEVRFEVRji/78E7UkaC3E0VEZwD8aQA/DwDMPGPmV1Ce+vugdfYggHfsj4iKoiiKoiiKoqwdDFDOjc9JYchM1BsAPA/gHxPR7xDRzxHRDrzTgAGEThMGEd1LRJ8mok8Xl6+sTHBFURRFURRFUQ4XMqbxOSkM6URlAL4VwM8w87cAuIIRS/eY+QFmvouZ70pP7SwopqIoiqIoiqIo6wQxg4rm56QwZHe+pwA8xcy/Zf//S5SdqCGnCa8Hi2xVO1QHfL8X1Z0VbKd7rDg5ZXAx9lNfDjLth8ZjhdtO7wvrqq+rTK91jeMYVpUexyEtjgpD8uwo5cci8VlXu3eUWURn9iMfjpLuxmAA+cmZfZL0zkQx81cAPElEb7SXvhvlIVVDThNWFEVRFEVRFOWYclKX8w09J+pvAPglIpoC+CKAv4ayA/YQEb0HwBMA3rk/Iq4A2dPvGklYZERgVaMI6z7SfpAch5GZ/WY/9OUw0n3Zw15D8e/zc+zsV+z5o6CnQ21f13PHiVC8NF3Wm+OW5qtoZ2g7YXGW0adF7emq5Vg3mIET1HGSDOpEMfNnAdwVuBU8DVhRFEVRFEVRlOMPndDlfENnoo4P6977Z6x+lKkrzusyorXu+bKurGJk7Cin/WHMHh/V9Dqqcu83mi7KUWOVMyJ9/q8D6zjrs25pdJgwA4V2opR1YRVLtYYW8EU30FgUNTz7h6atoijKyeIkDKStu3yKLudTFEVRFEVRFEUZDDNQFIctxaGgnah1Zp1GX9ZJFkVRFEVRmmg9rRwGDCDXTpSiKIqiKIqiKMpAdHc+RVEURVEURVGU4TBO7HK+3sN2ieiNRPRZ8XmViH6YiK4joo8R0aP2+/xBCKwoiqIoiqIoyhrADM7zxuek0NuJYuYvMPM3M/M3A/g2AFcB/AqA+wB8nJnvAPBx+19RFEVRFEVRlJNCYZqfE0JvJ8rjuwH8ETN/GcA9AB601x8E8I4VyqUoiqIoiqIoyjrjdueTnxPC2Hei3gXgl+3vm5j5GQBg5meI6MaVSqYoiqIoiqIoyhrD4BPUcZIMnokioimAvwDgX4wJgIjuJaJPE9Gni8tXxsqnKIqiKIqiKMoawgzwPG98TgpjlvO9HcBnmPlZ+/9ZIroFAOz3c6GHmPkBZr6Lme9KT+0sJ62iKIqiKIqiKOsBlzNR8nNSIOZhp7MR0YcAfJSZ/7H9/78DeJGZ7yei+wBcx8w/2uPHJQBfWFJm5WTyGgAvHLYQypFEdUdZFNUdZRFUb5RFeR0z33DYQoyBiH4Dpc5LXmDmuw9DnoNkUCeKiLYBPAngDcx80V67HsBDAL4KwBMA3snML/X482lmvmtpqZUTh+qOsiiqO8qiqO4oi6B6oygng0EbSzDzVQDXe9deRLlbn6IoiqIoiqIoyolh7BbniqIoiqIoiqIoJ5qD7kQ9cMDhKccH1R1lUVR3lEVR3VEWQfVGUU4AgzeWUBRFURRFURRFUXQ5n6IoiqIoiqIoyii0E6UoiqIoiqIoijIC7UQpiqIoiqIoiqKMQDtRiqIoiqIoiqIoI9BOlKIoiqIoiqIoygj+f5zuS920pRdsAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x144 with 2 Axes>"
       ]
@@ -843,22 +852,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(-0.5, 4999.5, 71.5, -0.5)"
+       "(-0.5, 4999.5, 108.5, -0.5)"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x144 with 2 Axes>"
       ]
@@ -899,7 +908,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.2"
+   "version": "3.9.4"
   }
  },
  "nbformat": 4,

From 846fd458df73f71a34d33ac7c34cdb8c3dc00bbe Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Mon, 2 Aug 2021 14:08:07 +0200
Subject: [PATCH 03/30] scripts comparing arbor and lfpy performance

---
 examples/benchmarks/alphaisyn.mod           |   84 ++
 examples/benchmarks/brunel_alpha_nest.py    |  438 ++++++++
 examples/benchmarks/example_brunel.py       |  462 +++++++++
 examples/benchmarks/example_brunel_arbor.py | 1024 +++++++++++++++++++
 examples/benchmarks/plot_benchmarks.py      |   43 +
 examples/benchmarks/requirements.txt        |    0
 examples/benchmarks/run_benchmarks.py       |  116 +++
 hybridLFPy/population.py                    |   24 +-
 8 files changed, 2188 insertions(+), 3 deletions(-)
 create mode 100644 examples/benchmarks/alphaisyn.mod
 create mode 100755 examples/benchmarks/brunel_alpha_nest.py
 create mode 100644 examples/benchmarks/example_brunel.py
 create mode 100644 examples/benchmarks/example_brunel_arbor.py
 create mode 100644 examples/benchmarks/plot_benchmarks.py
 create mode 100644 examples/benchmarks/requirements.txt
 create mode 100644 examples/benchmarks/run_benchmarks.py

diff --git a/examples/benchmarks/alphaisyn.mod b/examples/benchmarks/alphaisyn.mod
new file mode 100644
index 0000000..ff3f37d
--- /dev/null
+++ b/examples/benchmarks/alphaisyn.mod
@@ -0,0 +1,84 @@
+TITLE Alpha-function synaptic current, with NET_RECEIVE
+
+COMMENT
+This model works with variable time-step methods (although it may not
+be very accurate) but at the expense of having to maintain the queues
+of spike times and weights.
+
+Andrew P. Davison, UNIC, CNRS, May 2006
+ENDCOMMENT
+
+DEFINE MAX_SPIKES 1000
+DEFINE CUTOFF 20
+
+NEURON {
+	POINT_PROCESS AlphaISyn
+	RANGE tau, i, q
+	NONSPECIFIC_CURRENT i
+}
+
+UNITS {
+	(nA) = (nanoamp)
+}
+
+PARAMETER {
+	tau = 5 (ms) <1e-9,1e9>
+
+}
+
+ASSIGNED {
+	i (nA)
+	q
+	onset_times[MAX_SPIKES] (ms)
+	weight_list[MAX_SPIKES] (nA)
+}
+
+INITIAL {
+	i  = 0
+	q  = 0 : queue index
+}
+
+BREAKPOINT {
+	LOCAL k, expired_spikes, x
+	i = 0
+	expired_spikes = 0
+	FROM k=0 TO q-1 {
+		x = (t - onset_times[k])/tau
+		if (x > CUTOFF) {
+			expired_spikes = expired_spikes + 1
+		} else {
+			i = i - weight_list[k] * alpha(x)
+		}
+	}
+	update_queue(expired_spikes)
+}
+
+FUNCTION update_queue(n) {
+	LOCAL k
+	:if (n > 0) { printf("Queue changed. t = %4.2f onset_times=[",t) }
+	FROM k=0 TO q-n-1 {
+		onset_times[k] = onset_times[k+n]
+		weight_list[k] = weight_list[k+n]
+		:if (n > 0) { printf("%4.2f ",onset_times[k]) }
+	}
+	:if (n > 0) { printf("]\n") }
+	q = q-n
+}
+
+FUNCTION alpha(x) {
+	if (x < 0) {
+		alpha = 0
+	} else {
+		alpha = x * exp(1 - x)
+	}
+}
+
+NET_RECEIVE(weight (nA)) {
+	onset_times[q] = t
+	weight_list[q] = weight
+	if (q >= MAX_SPIKES-1) {
+		printf("Error in AlphaISyn. Spike queue is full\n")
+	} else {
+		q = q + 1
+	}
+}
diff --git a/examples/benchmarks/brunel_alpha_nest.py b/examples/benchmarks/brunel_alpha_nest.py
new file mode 100755
index 0000000..33a3128
--- /dev/null
+++ b/examples/benchmarks/brunel_alpha_nest.py
@@ -0,0 +1,438 @@
+#!/usr/env/bin python
+# -*- coding: utf-8 -*-
+#
+# brunel_alpha_nest.py
+#
+# This file is part of NEST.
+#
+# Copyright (C) 2004 The NEST Initiative
+#
+# NEST is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# NEST is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with NEST.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Modified as an example with hybridLFPy (https:/github.com/INM-6/hybridLFPy)
+# for calculating local field potentials from spiking point-neuron networks
+
+"""
+Random balanced network (alpha synapses) connected with NEST
+------------------------------------------------------------
+
+This script simulates an excitatory and an inhibitory population on
+the basis of the network used in
+
+Brunel N, Dynamics of Sparsely Connected Networks of Excitatory and
+Inhibitory Spiking Neurons, Journal of Computational Neuroscience 8,
+183-208 (2000).
+
+In contrast to brunel-alpha-numpy.py, this variant uses NEST's builtin
+connection routines to draw the random connections instead of NumPy.
+
+When connecting the network customary synapse models are used, which
+allow for querying the number of created synapses. Using spike
+detectors the average firing rates of the neurons in the populations
+are established. The building as well as the simulation time of the
+network are recorded.
+"""
+
+"""
+Importing all necessary modules for simulation, analysis and plotting.
+"""
+
+
+'''
+Definition of functions used in this example. First, define the
+Lambert W function implemented in SLI. The second function
+computes the maximum of the postsynaptic potential for a synaptic
+input current of unit amplitude (1 pA) using the Lambert W
+function. Thus function will later be used to calibrate the synaptic
+weights.
+'''
+
+
+
+
+from scipy.optimize import fsolve
+import nest
+import nest.raster_plot
+import os
+import time
+from numpy import exp, random
+def LambertWm1(x):
+    nest.ll_api.sli_push(x)
+    nest.ll_api.sli_run('LambertWm1')
+    y = nest.ll_api.sli_pop()
+    return y
+
+
+def ComputePSPnorm(tauMem, CMem, tauSyn):
+    a = (tauMem / tauSyn)
+    b = (1.0 / tauSyn - 1.0 / tauMem)
+
+    # time of maximum
+    t_max = 1.0 / b * (-LambertWm1(-exp(-1.0 / a) / a) - 1.0 / a)
+
+    # maximum of PSP for current of unit amplitude
+    return exp(1.0) / (tauSyn * CMem * b) * ((exp(-t_max / tauMem) - \
+               exp(-t_max / tauSyn)) / b - t_max * exp(-t_max / tauSyn))
+
+
+'''
+Assigning the current time to a variable in order to determine the
+build time of the network.
+'''
+
+startbuild = time.time()
+
+'''
+Assigning the simulation parameters to variables.
+'''
+
+dt = 0.1    # the resolution in ms
+simtime = 1000.0  # Simulation time in ms
+delay = 1.5    # synaptic delay in ms
+
+'''
+Definition of the parameters crucial for asynchronous irregular firing
+of the neurons.
+'''
+
+g = 6.0  # ratio inhibitory weight/excitatory weight
+eta = 2.0  # external rate relative to threshold rate
+epsilon = 0.1  # connection probability
+
+'''
+Definition of the number of neurons in the network and the number of
+neuron recorded from.
+
+Note: We record here all spike events.
+'''
+
+order = 128
+NE = 4 * order  # number of excitatory neurons
+NI = 1 * order  # number of inhibitory neurons
+N_neurons = NE + NI   # number of neurons in total
+
+'''
+flag for using Poisson or equivalent DC current external drive
+'''
+
+Poisson = False
+
+'''
+Definition of connectivity parameter
+'''
+
+CE = int(epsilon * NE)  # number of excitatory synapses per neuron
+CI = int(epsilon * NI)  # number of inhibitory synapses per neuron
+C_tot = int(CI + CE)      # total number of synapses per neuron
+
+'''
+Initialization of the parameters of the integrate and fire neuron and
+the synapses. The parameter of the neuron are stored in a dictionary.
+The synaptic currents are normalized such that the amplitude of the
+PSP is J.
+'''
+
+tauSyn = 0.5        # synaptic time constant in ms
+tauMem = 20.0       # time constant of membrane potential in ms
+CMem = 250.0        # capacitance of membrane in in pF
+theta = 20.0       # membrane threshold potential in mV
+J = 1.0        # postsynaptic amplitude in mV
+J_unit = ComputePSPnorm(tauMem, CMem, tauSyn)
+J_ex = J / J_unit  # amplitude of excitatory postsynaptic current
+J_in = -g * J_ex    # amplitude of inhibitory postsynaptic current
+
+'''
+Definition of threshold rate, which is the external rate needed to fix
+the membrane potential around its threshold, the external firing rate
+and the rate of the poisson generator which is multiplied by the
+in-degree CE and converted to Hz by multiplication by 1000.
+'''
+
+nu_th = (theta * CMem) / (J_ex * CE * exp(1) * tauMem * tauSyn)
+nu_ex = eta * nu_th
+p_rate = 1000.0 * nu_ex * CE
+
+'''
+Adjust parameters accordingly if Poisson background input is used
+'''
+
+if Poisson:
+    # use zero dc input amplitude to the neurons
+    dc_amplitude = 0.
+else:
+    # compute equivalent DC current amplitude instead of Poisson input assuming
+    # alpha current synapse
+    factor = 0.4  # CHECK
+    dc_amplitude = p_rate * J_ex / 1000 / tauSyn * factor
+
+'''
+Parameters for "iaf_psc_alpha" cell model
+'''
+
+neuron_params = {"C_m": CMem,
+                 "tau_m": tauMem,
+                 "tau_syn_ex": tauSyn,
+                 "tau_syn_in": tauSyn,
+                 "t_ref": 2.0,
+                 "E_L": 0.0,
+                 "V_reset": 0.0,
+                 "V_th": 20.0,
+                 "V_m": 0.0,
+                 "V_th": theta,
+                 "I_e": dc_amplitude, }
+'''
+Destination of file output
+'''
+
+spike_output_path = os.path.join('simulation_output_example_brunel',
+                                 'spiking_output_path')
+
+'''
+File prefix for spike detectors
+'''
+
+label = 'brunel-py'
+
+'''
+Main simulation procedure function
+'''
+
+
+def simulate():
+    '''instantiate and execute network simulation'''
+    # separate model execution from parameters for safe import from other files
+    nest.ResetKernel()
+
+    '''
+    Configuration of the simulation kernel by the previously defined time
+    resolution used in the simulation. Setting "print_time" to True prints
+    the already processed simulation time as well as its percentage of the
+    total simulation time.
+    '''
+
+    nest.SetKernelStatus({"resolution": dt, "print_time": True,
+                          "overwrite_files": True})
+
+    print("Building network")
+
+    '''
+    Configuration of the model `iaf_psc_alpha` and `poisson_generator`
+    using SetDefaults(). This function expects the model to be the
+    inserted as a string and the parameter to be specified in a
+    dictionary. All instances of theses models created after this point
+    will have the properties specified in the dictionary by default.
+    '''
+
+    nest.SetDefaults("iaf_psc_alpha", neuron_params)
+    nest.SetDefaults("poisson_generator", {"rate": p_rate})
+
+    '''
+    Creation of the nodes using `Create`. We store the returned handles in
+    variables for later reference. Here the excitatory and inhibitory, as
+    well as the poisson generator and two spike detectors. The spike
+    detectors will later be used to record excitatory and inhibitory
+    spikes.
+    '''
+
+    nodes_ex = nest.Create("iaf_psc_alpha", NE)
+    nodes_in = nest.Create("iaf_psc_alpha", NI)
+    noise = nest.Create("poisson_generator")
+    espikes = nest.Create("spike_recorder")
+    ispikes = nest.Create("spike_recorder")
+
+    print("first exc node: {}".format(nodes_ex[0]))
+    print("first inh node: {}".format(nodes_in[0]))
+
+    '''
+    distribute membrane potentials
+    '''
+    nest.SetStatus(nodes_ex, "V_m",
+                   random.rand(len(nodes_ex)) * neuron_params["V_th"])
+    nest.SetStatus(nodes_in, "V_m",
+                   random.rand(len(nodes_in)) * neuron_params["V_th"])
+
+    '''
+    Configuration of the spike detectors recording excitatory and
+    inhibitory spikes using `SetStatus`, which expects a list of node
+    handles and a list of parameter dictionaries. Setting the variable
+    "to_file" to True ensures that the spikes will be recorded in a .gdf
+    file starting with the string assigned to label. Setting "withtime"
+    and "withgid" to True ensures that each spike is saved to file by
+    stating the gid of the spiking neuron and the spike time in one line.
+    '''
+
+    nest.SetStatus(espikes, [{
+        "label": os.path.join(spike_output_path, label + "-EX"),
+        "record_to": 'ascii',
+    }])
+
+    nest.SetStatus(ispikes, [{
+        "label": os.path.join(spike_output_path, label + "-IN"),
+        "record_to": 'ascii', }])
+
+    print("Connecting devices")
+
+    '''
+    Definition of a synapse using `CopyModel`, which expects the model
+    name of a pre-defined synapse, the name of the customary synapse and
+    an optional parameter dictionary. The parameters defined in the
+    dictionary will be the default parameter for the customary
+    synapse. Here we define one synapse for the excitatory and one for the
+    inhibitory connections giving the previously defined weights and equal
+    delays.
+    '''
+
+    nest.CopyModel(
+        "static_synapse", "excitatory", {
+            "weight": J_ex, "delay": delay})
+    nest.CopyModel(
+        "static_synapse", "inhibitory", {
+            "weight": J_in, "delay": delay})
+
+    '''
+    Connecting the previously defined poisson generator to the excitatory
+    and inhibitory neurons using the excitatory synapse. Since the poisson
+    generator is connected to all neurons in the population the default
+    rule ('all_to_all') of Connect() is used. The synaptic properties are
+    inserted via syn_spec which expects a dictionary when defining
+    multiple variables or a string when simply using a pre-defined
+    synapse.
+    '''
+
+    if Poisson:
+        nest.Connect(noise, nodes_ex, 'all_to_all', "excitatory")
+        nest.Connect(noise, nodes_in, 'all_to_all', "excitatory")
+
+    '''
+    Connecting the first N_neurons nodes of the excitatory and inhibitory
+    population to the associated spike detectors using excitatory
+    synapses. Here the same shortcut for the specification of the synapse
+    as defined above is used.
+    '''
+
+    nest.Connect(nodes_ex, espikes, 'all_to_all', "excitatory")
+    nest.Connect(nodes_in, ispikes, 'all_to_all', "excitatory")
+
+    print("Connecting network")
+
+    print("Excitatory connections")
+
+    '''
+    Connecting the excitatory population to all neurons using the
+    pre-defined excitatory synapse. Beforehand, the connection parameter
+    are defined in a dictionary. Here we use the connection rule
+    'fixed_indegree', which requires the definition of the indegree. Since
+    the synapse specification is reduced to assigning the pre-defined
+    excitatory synapse it suffices to insert a string.
+    '''
+
+    conn_params_ex = {'rule': 'fixed_indegree', 'indegree': CE}
+    nest.Connect(nodes_ex, nodes_ex + nodes_in, conn_params_ex, "excitatory")
+
+    print("Inhibitory connections")
+
+    '''
+    Connecting the inhibitory population to all neurons using the
+    pre-defined inhibitory synapse. The connection parameter as well as
+    the synapse paramtere are defined analogously to the connection from
+    the excitatory population defined above.
+    '''
+
+    conn_params_in = {'rule': 'fixed_indegree', 'indegree': CI}
+    nest.Connect(nodes_in, nodes_ex + nodes_in, conn_params_in, "inhibitory")
+
+    '''
+    Storage of the time point after the buildup of the network in a
+    variable.
+    '''
+
+    endbuild = time.time()
+
+    '''
+    Simulation of the network.
+    '''
+
+    print("Simulating")
+
+    nest.Simulate(simtime)
+
+    '''
+    Storage of the time point after the simulation of the network in a
+    variable.
+    '''
+
+    endsimulate = time.time()
+
+    '''
+    Reading out the total number of spikes received from the spike
+    detector connected to the excitatory population and the inhibitory
+    population.
+    '''
+
+    events_ex = nest.GetStatus(espikes, "n_events")[0]
+    events_in = nest.GetStatus(ispikes, "n_events")[0]
+
+    '''
+    Calculation of the average firing rate of the excitatory and the
+    inhibitory neurons by dividing the total number of recorded spikes by
+    the number of neurons recorded from and the simulation time. The
+    multiplication by 1000.0 converts the unit 1/ms to 1/s=Hz.
+    '''
+
+    rate_ex = events_ex / simtime * 1000.0 / N_neurons
+    rate_in = events_in / simtime * 1000.0 / N_neurons
+
+    '''
+    Reading out the number of connections established using the excitatory
+    and inhibitory synapse model. The numbers are summed up resulting in
+    the total number of synapses.
+    '''
+
+    num_synapses = nest.GetDefaults("excitatory")["num_connections"] +\
+        nest.GetDefaults("inhibitory")["num_connections"]
+
+    '''
+    Establishing the time it took to build and simulate the network by
+    taking the difference of the pre-defined time variables.
+    '''
+
+    build_time = endbuild - startbuild
+    sim_time = endsimulate - endbuild
+
+    '''
+    Printing the network properties, firing rates and building times.
+    '''
+
+    print("Brunel network simulation (Python)")
+    print("Number of neurons : {0}".format(N_neurons))
+    print("Number of synapses: {0}".format(num_synapses))
+    print("       Exitatory  : {0}".format(int(CE * N_neurons) + N_neurons))
+    print("       Inhibitory : {0}".format(int(CI * N_neurons)))
+    print("Excitatory rate   : %.2f Hz" % rate_ex)
+    print("Inhibitory rate   : %.2f Hz" % rate_in)
+    print("Building time     : %.2f s" % build_time)
+    print("Simulation time   : %.2f s" % sim_time)
+
+    '''
+    Plot a raster of the excitatory neurons and a histogram.
+    '''
+
+    if False:
+        nest.raster_plot.from_device(espikes, hist=True)
+        nest.raster_plot.from_device(ispikes, hist=True)
+        nest.raster_plot.show()
+
+
+if __name__ == '__main__':
+    simulate()
diff --git a/examples/benchmarks/example_brunel.py b/examples/benchmarks/example_brunel.py
new file mode 100644
index 0000000..61a7713
--- /dev/null
+++ b/examples/benchmarks/example_brunel.py
@@ -0,0 +1,462 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+Hybrid LFP scheme example script, applying the methodology with a model
+implementation similar to:
+
+Nicolas Brunel. "Dynamics of Sparsely Connected Networks of Excitatory and
+Inhibitory Spiking Neurons". J Comput Neurosci, May 2000, Volume 8,
+Issue 3, pp 183-208
+
+
+Synopsis of the main simulation procedure:
+1. Loading of parameterset
+    a. network parameters
+    b. parameters for hybrid scheme
+2. Set up file destinations for different simulation output
+3. network simulation
+    a. execute network simulation using NEST (www.nest-initiative.org)
+    b. merge network output (spikes, currents, voltages)
+4. Create a object-representation that uses sqlite3 of all the spiking output
+5. Iterate over post-synaptic populations:
+    a. Create Population object with appropriate parameters for
+       each specific population
+    b. Run all computations for populations
+    c. Postprocess simulation output of all cells in population
+6. Postprocess all cell- and population-specific output data
+7. Create a tarball for all non-redundant simulation output
+
+The full simulation can be evoked by issuing a mpirun call, such as
+mpirun -np 4 python example_brunel.py
+
+Not recommended, but running it serially should also work, e.g., calling
+python example_brunel.py
+
+'''
+# from example_plotting import *
+import brunel_alpha_nest as BN
+import lfpykit
+from mpi4py import MPI
+import h5py
+from parameters import ParameterSet
+from hybridLFPy import PostProcess, Population, CachedNetwork, setup_file_dest
+import nest  # import not used, but we load NEST anyway in order determine if
+import neuron  # NEURON compiled with MPI must be imported before NEST/mpi4py
+from time import time
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import os
+import sys
+import numpy as np
+if 'DISPLAY' not in os.environ:
+    import matplotlib
+    matplotlib.use('Agg')
+import matplotlib.style
+matplotlib.style.use('classic')
+# to avoid being aware of MPI
+# network is run in parallel
+
+
+########## matplotlib settings ###########################################
+plt.close('all')
+plt.rcParams.update({'figure.figsize': [10.0, 8.0]})
+
+#######################################
+# Capture command line values
+#######################################
+# load parameter file
+md5 = sys.argv[1]
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+# set some seed values
+SEED = pset.GLOBALSEED
+SIMULATIONSEED = pset.GLOBALSEED + 1234
+np.random.seed(SEED)
+
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# if True, execute full model. If False, do only the plotting.
+# Simulation results must exist.
+properrun = True
+
+
+# check if mod file for synapse model specified in alphaisyn.mod is loaded
+if not hasattr(neuron.h, 'AlphaISyn'):
+    if RANK == 0:
+        os.system('nrnivmodl')
+    COMM.Barrier()
+    neuron.load_mechanisms('.')
+
+
+##########################################################################
+# PARAMETERS
+##########################################################################
+
+# Set up parameters using the NeuroTools.parameters.ParameterSet class.
+
+# Access parameters defined in example script implementing the network using
+# pynest, brunel_alpha_nest.py, adapted from the NEST v2.4.1 release. This will
+# not execute the network model, but see below.
+
+
+# set up file destinations differentiating between certain output
+savefolder = md5
+BN.spike_output_path = os.path.join(savefolder, 'spiking_output_path')
+PS = ParameterSet(dict(
+    # Main folder of simulation output
+    savefolder=savefolder,  # 'simulation_output_example_brunel',
+
+    # make a local copy of main files used in simulations
+    sim_scripts_path=os.path.join(savefolder, 'sim_scripts'),
+
+    # destination of single-cell output during simulation
+    cells_path=os.path.join(savefolder, 'cells'),
+
+    # destination of cell- and population-specific signals, i.e., compund LFPs,
+    # CSDs etc.
+    populations_path=os.path.join(savefolder, 'populations'),
+
+    # location of spike output from the network model
+    spike_output_path=BN.spike_output_path,
+
+    # destination of figure file output generated during model execution
+    figures_path=os.path.join(savefolder, 'figures')
+))
+
+
+# population (and cell type) specific parameters
+PS.update(dict(
+    # no cell type specificity within each E-I population
+    # hence X == x and Y == X
+    X=["EX", "IN"],
+
+    # population-specific LFPy.Cell parameters
+    cellParams=dict(
+        # excitory cells
+        EX=dict(
+            morphology='morphologies/ex.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            nsegs_method='fixed_length',  # 'lambda_f',
+            max_nsegs_length=10.,
+            # lambda_f=100,
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        ),
+        # inhibitory cells
+        IN=dict(
+            morphology='morphologies/in.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            nsegs_method='fixed_length',  # 'lambda_f',
+            max_nsegs_length=10.,
+            # lambda_f=100,
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        )),
+
+    # assuming excitatory cells are pyramidal
+    rand_rot_axis=dict(
+        EX=['z'],
+        IN=['x', 'y', 'z'],
+    ),
+
+
+    # kwargs passed to LFPy.Cell.simulate().
+    # It can be empty, but if `rec_imem=True`, the signal predictions will be
+    # performed using recorded transmembrane currents.
+    simulationParams=dict(rec_imem=True),
+
+    # set up parameters corresponding to cylindrical model populations
+    populationParams=dict(
+        EX=dict(
+            number=BN.NE,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+        IN=dict(
+            number=BN.NI,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+    ),
+
+    # set the boundaries between the "upper" and "lower" layer
+    layerBoundaries=[[0., -300],
+                     [-300, -500]],
+
+    # set the geometry of the virtual recording device
+    electrodeParams=dict(
+        # contact locations:
+        x=[0] * 6,
+        y=[0] * 6,
+        z=[x * -100. for x in range(6)],
+        # extracellular conductivity:
+        sigma=0.3,
+        # contact surface normals, radius, n-point averaging
+        N=[[1, 0, 0]] * 6,
+        r=5,
+        n=20,
+        seedvalue=None,
+        # dendrite line sources, soma as sphere source (Linden2014)
+        method='root_as_point',
+    ),
+
+    # parameters for LFPykit.LaminarCurrentSourceDensity
+    CSDParams=dict(
+        z=np.array([[-(i + 1) * 100, -i * 100] for i in range(6)]) + 50.,
+        r=np.ones(6) * 100  # same as population radius
+    ),
+
+    # runtime, cell-specific attributes and output that will be stored
+    savelist=[],
+
+    # time resolution of saved signals
+    dt_output=1.
+))
+
+
+# for each population, define layer- and population-specific connectivity
+# parameters
+PS.update(dict(
+    # number of connections from each presynaptic population onto each
+    # layer per postsynaptic population, preserving overall indegree
+    k_yXL=dict(
+        EX=[[int(0.5 * BN.CE), 0],
+            [int(0.5 * BN.CE), BN.CI]],
+        IN=[[0, 0],
+            [BN.CE, BN.CI]],
+    ),
+
+    # set up table of synapse weights from each possible presynaptic population
+    J_yX=dict(
+        EX=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+        IN=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+    ),
+
+    # set up synapse parameters as derived from the network
+    synParams=dict(
+        EX=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['apic', 'dend'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+        IN=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['dend', 'soma'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+    ),
+
+    # set up table of synapse time constants from each presynaptic populations
+    tau_yX=dict(
+        EX=[BN.tauSyn, BN.tauSyn],
+        IN=[BN.tauSyn, BN.tauSyn]
+    ),
+
+    # set up delays, here using fixed delays of network
+    synDelayLoc=dict(
+        EX=[BN.delay, BN.delay],
+        IN=[BN.delay, BN.delay],
+    ),
+    # no distribution of delays
+    synDelayScale=dict(
+        EX=[None, None],
+        IN=[None, None],
+    ),
+))
+
+
+# putative mappting between population type and cell type specificity,
+# but here all presynaptic senders are also postsynaptic targets
+PS.update(dict(
+    mapping_Yy=list(zip(PS.X, PS.X))
+))
+
+
+# In[2]:
+
+
+##########################################################################
+# MAIN simulation procedure                                              #
+##########################################################################
+
+# tic toc
+tic = time()
+
+######### Perform network simulation #####################################
+if properrun:
+    # set up the file destination, removing old results by default
+    setup_file_dest(PS, clearDestination=True)
+
+if properrun:
+    # execute network simulation
+    BN.simulate()
+
+# wait for the network simulation to finish, resync MPI threads
+COMM.Barrier()
+
+# Create an object representation containing the spiking activity of the network
+# simulation output that uses sqlite3. Again, kwargs are derived from the brunel
+# network instance.
+networkSim = CachedNetwork(
+    simtime=BN.simtime,
+    dt=BN.dt,
+    spike_output_path=BN.spike_output_path,
+    label=BN.label,
+    ext='dat',
+    GIDs={'EX': [1, BN.NE], 'IN': [BN.NE + 1, BN.NI]},
+    X=['EX', 'IN'],
+    cmap='rainbow_r',
+    skiprows=3,
+)
+
+
+if RANK == 0:
+    toc = time() - tic
+    print('NEST simulation and gdf file processing done in  %.3f seconds' % toc)
+
+
+# Set up LFPykit measurement probes for LFPs and CSDs
+if properrun:
+    probes = []
+    probes.append(lfpykit.RecExtElectrode(cell=None, **PS.electrodeParams))
+    probes.append(
+        lfpykit.LaminarCurrentSourceDensity(
+            cell=None, **PS.CSDParams))
+
+
+# In[3]:
+
+# measure population simulation times including setup etc.
+ticc = time()
+
+# arbor sim.run cumulative time
+ticc_run = np.array(0.)
+
+# %%prun -s cumulative -q -l 20 -T prun0
+####### Set up populations ###############################################
+if properrun:
+    # iterate over each cell type, and create populationulation object
+    for i, Y in enumerate(PS.X):
+        # create population:
+        pop = Population(
+            cellParams=PS.cellParams[Y],
+            rand_rot_axis=PS.rand_rot_axis[Y],
+            simulationParams=PS.simulationParams,
+            populationParams=PS.populationParams[Y],
+            y=Y,
+            layerBoundaries=PS.layerBoundaries,
+            savelist=PS.savelist,
+            savefolder=PS.savefolder,
+            probes=probes,
+            dt_output=PS.dt_output,
+            POPULATIONSEED=SIMULATIONSEED + i,
+            X=PS.X,
+            networkSim=networkSim,
+            k_yXL=PS.k_yXL[Y],
+            synParams=PS.synParams[Y],
+            synDelayLoc=PS.synDelayLoc[Y],
+            synDelayScale=PS.synDelayScale[Y],
+            J_yX=PS.J_yX[Y],
+            tau_yX=PS.tau_yX[Y],
+        )
+
+        # run population simulation and collect the data
+        pop.run()
+        pop.collect_data()
+
+        # arbor sim.run cumulative time
+        ticc_run += pop._cumulative_sim_time
+
+        # object no longer needed
+        del pop
+
+# tic toc
+tocc = time() - ticc
+if RANK == 0:
+    with open(os.path.join(savefolder, 'time_pop.txt'), 'w') as f:
+        f.write(f'{tocc}')
+
+if RANK == 0:
+    tocc_run = np.zeros_like(ticc_run)
+else:
+    tocc_run = None
+
+COMM.Reduce(ticc_run, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join(savefolder, 'time_run.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+# In[4]:
+
+
+# print(open('prun0', 'r').read())
+
+
+# In[5]:
+
+
+####### Postprocess the simulation output ################################
+
+
+# reset seed, but output should be deterministic from now on
+np.random.seed(SIMULATIONSEED)
+
+if properrun:
+    # do some postprocessing on the collected data, i.e., superposition
+    # of population LFPs, CSDs etc
+    postproc = PostProcess(y=PS.X,
+                           dt_output=PS.dt_output,
+                           savefolder=PS.savefolder,
+                           mapping_Yy=PS.mapping_Yy,
+                           savelist=PS.savelist,
+                           probes=probes,
+                           cells_subfolder=os.path.split(PS.cells_path)[-1],
+                           populations_subfolder=os.path.split(PS.populations_path)[-1],
+                           figures_subfolder=os.path.split(PS.figures_path)[-1])
+
+    # run through the procedure
+    postproc.run()
+
+    # create tar-archive with output for plotting, ssh-ing etc.
+    postproc.create_tar_archive()
+
+
+COMM.Barrier()
+
+# tic toc
+print('Execution time: %.3f seconds' % (time() - tic))
diff --git a/examples/benchmarks/example_brunel_arbor.py b/examples/benchmarks/example_brunel_arbor.py
new file mode 100644
index 0000000..621e06d
--- /dev/null
+++ b/examples/benchmarks/example_brunel_arbor.py
@@ -0,0 +1,1024 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+# %matplotlib inline
+
+
+# Hybrid LFP scheme example script, applying the methodology with a model
+# implementation similar to:
+#
+# Nicolas Brunel. "Dynamics of Sparsely Connected Networks of Excitatory and
+# Inhibitory Spiking Neurons". J Comput Neurosci, May 2000, Volume 8,
+# Issue 3, pp 183-208
+#
+#
+# Synopsis of the main simulation procedure:
+#
+#     1. Loading of parameterset
+#         a. network parameters
+#         b. parameters for hybrid scheme
+#     2. Set up file destinations for different simulation output
+#     3. network simulation
+#         a. execute network simulation using NEST (www.nest-initiative.org)
+#         b. merge network output (spikes, currents, voltages)
+#     4. Create a object-representation that uses sqlite3 of all the spiking output
+#     5. Iterate over post-synaptic populations:
+#         a. Create Population object with appropriate parameters for each specific population
+#         b. Run all computations for populations
+#         c. Postprocess simulation output of all cells in population
+#     6. Postprocess all cell- and population-specific output data
+#     7. Create a tarball for all non-redundant simulation output
+#
+# The full simulation can be evoked by issuing a mpirun call, such as
+# mpirun -np 4 python example_brunel.py
+#
+# Not recommended, but running it serially should also work, e.g., calling
+# python example_brunel.py
+
+# In[2]:
+
+
+# from example_plotting import *
+import brunel_alpha_nest as BN
+import lfpykit
+from mpi4py import MPI
+import h5py
+from parameters import ParameterSet
+from hybridLFPy import PostProcess, Population, CachedNetwork, setup_file_dest
+import nest  # import not used, but we load NEST anyway in order determine if
+import neuron  # NEURON compiled with MPI must be imported before NEST/mpi4py
+from time import time
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import os
+import sys
+import numpy as np
+import scipy.stats as st
+import scipy.signal as ss
+from LFPy.alias_method import alias_method
+import arbor
+if 'DISPLAY' not in os.environ:
+    import matplotlib
+    matplotlib.use('Agg')
+import matplotlib.style
+matplotlib.style.use('classic')
+# to avoid being aware of MPI
+# network is run in parallel
+
+
+# In[3]:
+
+
+########## matplotlib settings ###########################################
+# plt.close('all')
+plt.rcParams.update({'figure.figsize': [10.0, 8.0]})
+
+#######################################
+# Capture command line values
+#######################################
+# load parameter file
+md5 = sys.argv[1]
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+# set some seed values
+SEED = pset.GLOBALSEED
+SIMULATIONSEED = pset.GLOBALSEED + 1234
+np.random.seed(SEED)
+
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# if True, execute full model. If False, do only the plotting.
+# Simulation results must exist.
+properrun = True
+
+##########################################################################
+# PARAMETERS
+##########################################################################
+
+# Set up parameters using the NeuroTools.parameters.ParameterSet class.
+
+# Access parameters defined in example script implementing the network using
+# pynest, brunel_alpha_nest.py, adapted from the NEST v2.4.1 release. This will
+# not execute the network model, but see below.
+
+
+# set up file destinations differentiating between certain output
+savefolder = md5
+BN.spike_output_path = os.path.join(savefolder, 'spiking_output_path')
+PS = ParameterSet(dict(
+    # Main folder of simulation output
+    savefolder=savefolder,
+
+    # make a local copy of main files used in simulations
+    sim_scripts_path=os.path.join(savefolder,
+                                  'sim_scripts'),
+
+    # destination of single-cell output during simulation
+    cells_path=os.path.join(savefolder, 'cells'),
+
+    # destination of cell- and population-specific signals, i.e., compund LFPs,
+    # CSDs etc.
+    populations_path=os.path.join(savefolder,
+                                  'populations'),
+
+    # location of spike output from the network model
+    spike_output_path=BN.spike_output_path,
+
+    # destination of figure file output generated during model execution
+    figures_path=os.path.join(savefolder, 'figures')
+))
+
+
+# population (and cell type) specific parameters
+PS.update(dict(
+    # no cell type specificity within each E-I population
+    # hence X == x and Y == X
+    X=["EX", "IN"],
+
+    # population-specific LFPy.Cell parameters
+    cellParams=dict(
+        # excitory cells
+        EX=dict(
+            morphology='morphologies/ex.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            # nsegs_method='lambda_f',
+            # lambda_f=100,
+            max_cv_length=10,  # µm
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        ),
+        # inhibitory cells
+        IN=dict(
+            morphology='morphologies/in.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            # nsegs_method='lambda_f',
+            # lambda_f=100,
+            max_cv_length=10,  # µm
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        )),
+
+    # assuming excitatory cells are pyramidal
+    rand_rot_axis=dict(
+        EX=['z'],
+        IN=['x', 'y', 'z'],
+    ),
+
+
+    # kwargs passed to LFPy.Cell.simulate().
+    # It can be empty, but if `rec_imem=True`, the signal predictions will be
+    # performed using recorded transmembrane currents.
+    simulationParams=dict(rec_imem=True),
+
+    # set up parameters corresponding to cylindrical model populations
+    populationParams=dict(
+        EX=dict(
+            number=BN.NE,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+        IN=dict(
+            number=BN.NI,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+    ),
+
+    # set the boundaries between the "upper" and "lower" layer
+    layerBoundaries=[[0., -300],
+                     [-300, -500]],
+
+    # set the geometry of the virtual recording device
+    electrodeParams=dict(
+        # contact locations:
+        x=[0] * 6,
+        y=[0] * 6,
+        z=[x * -100. for x in range(6)],
+        # extracellular conductivity:
+        sigma=0.3,
+        # contact surface normals, radius, n-point averaging
+        N=[[1, 0, 0]] * 6,
+        r=5,
+        n=20,
+        seedvalue=None,
+        # dendrite line sources, soma as sphere source (Linden2014)
+        method='root_as_point',
+    ),
+
+    # parameters for LFPykit.LaminarCurrentSourceDensity
+    CSDParams=dict(
+        z=np.array([[-(i + 1) * 100, -i * 100] for i in range(6)]) + 50.,
+        r=np.ones(6) * 100  # same as population radius
+    ),
+
+    # runtime, cell-specific attributes and output that will be stored
+    savelist=[],
+
+    # time resolution of saved signals
+    dt_output=1.
+))
+
+
+# for each population, define layer- and population-specific connectivity
+# parameters
+PS.update(dict(
+    # number of connections from each presynaptic population onto each
+    # layer per postsynaptic population, preserving overall indegree
+    k_yXL=dict(
+        EX=[[int(0.5 * BN.CE), 0],
+            [int(0.5 * BN.CE), BN.CI]],
+        IN=[[0, 0],
+            [BN.CE, BN.CI]],
+    ),
+
+    # set up table of synapse weights from each possible presynaptic population
+    J_yX=dict(
+        EX=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+        IN=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+    ),
+
+    # set up synapse parameters as derived from the network
+    synParams=dict(
+        EX=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['apic', 'dend'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+        IN=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['dend', 'soma'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+    ),
+
+    # set up table of synapse time constants from each presynaptic populations
+    tau_yX=dict(
+        EX=[BN.tauSyn, BN.tauSyn],
+        IN=[BN.tauSyn, BN.tauSyn]
+    ),
+
+    # set up delays, here using fixed delays of network
+    synDelayLoc=dict(
+        EX=[BN.delay, BN.delay],
+        IN=[BN.delay, BN.delay],
+    ),
+    # no distribution of delays
+    synDelayScale=dict(
+        EX=[None, None],
+        IN=[None, None],
+    ),
+))
+
+
+# putative mappting between population type and cell type specificity,
+# but here all presynaptic senders are also postsynaptic targets
+PS.update(dict(
+    mapping_Yy=list(zip(PS.X, PS.X))
+))
+
+
+# In[4]:
+
+
+##########################################################################
+# MAIN simulation procedure                                              #
+##########################################################################
+
+# tic toc
+tic = time()
+
+######### Perform network simulation #####################################
+if properrun:
+    # set up the file destination, removing old results by default
+    setup_file_dest(PS, clearDestination=True)
+
+if properrun:
+    # execute network simulation
+    BN.simulate()
+
+# wait for the network simulation to finish, resync MPI threads
+COMM.Barrier()
+
+# Create an object representation containing the spiking activity of the network
+# simulation output that uses sqlite3. Again, kwargs are derived from the brunel
+# network instance.
+networkSim = CachedNetwork(
+    simtime=BN.simtime,
+    dt=BN.dt,
+    spike_output_path=BN.spike_output_path,
+    label=BN.label,
+    ext='dat',
+    GIDs={'EX': [1, BN.NE], 'IN': [BN.NE + 1, BN.NI]},
+    X=['EX', 'IN'],
+    cmap='rainbow_r',
+    skiprows=3,
+)
+
+
+# In[5]:
+
+
+if RANK == 0:
+    toc = time() - tic
+    print('NEST simulation and gdf file processing done in  %.3f seconds' % toc)
+
+
+# Set up LFPykit measurement probes for LFPs and CSDs
+if properrun:
+    probes = []
+    probes.append(lfpykit.RecExtElectrode(cell=None, **PS.electrodeParams))
+    probes.append(
+        lfpykit.LaminarCurrentSourceDensity(
+            cell=None, **PS.CSDParams))
+
+
+# In[6]:
+
+
+# draw locsets accd to y-position weighted by area and some function of y
+def get_rand_idx_area_and_distribution_norm(areas,
+                                            depth,
+                                            n_syn=1,
+                                            fun=[st.norm],
+                                            funargs=[dict(loc=200, scale=50)],
+                                            funweights=[1.]):
+    '''Return n_syn CV indices with random probability normalized by membrane area
+    multiplied with the value of probability density function constructed as
+    weigthed sum of `scipy.stats._continuous_dists` function instances
+
+    Parameters
+    ----------
+    areas: 1D ndarray
+        Area of each CV
+    depth: 1D ndarray
+        depth of each CV
+    n_syn: int
+        number of random indices
+    fun: iterable of scipy.stats._continuous_distns.*_gen
+        iterable of callable methods in scipy.stats module
+    funargs: iterable of dicts
+        keyword arguments to each element in `fun`
+    funweights: list of floats
+        scaling
+
+    Returns
+    -------
+    ndarray
+        random indices of size `n_syn` that can be
+    '''
+    # probabilities for connecting to CV
+    p = areas.copy()
+    mod = np.zeros(areas.size)
+    for f, args, w in zip(fun, funargs, funweights):
+        df = f(**args)
+        mod += df.pdf(x=depth) * w
+
+    # multiply probs by spatial weighting factor
+    p *= mod
+    # normalize
+    p /= p.sum()
+    # find CV inds
+    return alias_method(np.arange(areas.size), p, n_syn)
+
+
+# In[7]:
+
+
+class BaseRecipe (arbor.recipe):
+    def __init__(self, cell):
+        super().__init__()
+
+        self.the_cell = cell
+
+        self.iprobe_id = (0, 0)
+
+        self.the_props = arbor.neuron_cable_properties()
+        self.the_cat = arbor.default_catalogue()
+        self.the_props.register(self.the_cat)
+
+    def num_cells(self):
+        return 1
+
+    def num_sources(self, gid):
+        return 0
+
+    def num_targets(self, gid):
+        return 0
+
+    def connections_on(self, gid):
+        return []
+
+    def event_generators(self, gid):
+        return []
+
+    def cell_kind(self, gid):
+        return arbor.cell_kind.cable
+
+    def cell_description(self, gid):
+        return self.the_cell
+
+    def global_properties(self, kind):
+        return self.the_props
+
+    def probes(self, gid):
+        return [
+            arbor.cable_probe_total_current_cell(),
+        ]
+
+
+# In[8]:
+
+
+class Recipe(BaseRecipe):
+    def __init__(self, cell, times=[[1.]], weights=[1.]):
+        super().__init__(cell)
+
+        assert(len(times) == len(weights)), 'len(times) != len(weights)'
+        self.times = times
+        self.weights = weights
+
+    def num_targets(self, gid):
+        return len(self.times)
+
+    def event_generators(self, gid):
+        events = []
+        for i, (w, t) in enumerate(zip(self.weights, self.times)):
+            events += [arbor.event_generator(f'{i}', w,
+                                             arbor.explicit_schedule(t))]
+
+        return events
+
+
+# In[9]:
+
+
+class ArborPopulation(Population):
+    def __init__(self, **kwargs):
+        Population.__init__(self, **kwargs)
+
+    def get_synidx(self, cellindex):
+        """
+        Local function, draw and return synapse locations corresponding
+        to a single cell, using a random seed set as
+        `POPULATIONSEED` + `cellindex`.
+
+
+        Parameters
+        ----------
+        cellindex : int
+            Index of cell object.
+
+
+        Returns
+        -------
+        synidx : dict
+            `LFPy.Cell` compartment indices
+
+
+        See also
+        --------
+        Population.get_all_synIdx, Population.fetchSynIdxCell
+
+        """
+        # create a cell instance
+        cell = self.cellsim(cellindex, return_just_cell=True)
+
+        # compute areas and center of mass of each CV
+        CV_areas = []
+        for i in range(len(cell._loc_sets)):
+            inds = cell._CV_ind == i
+            CV_areas = np.r_[CV_areas, cell.area[inds].sum()]
+
+        # center of mass (COM) per segment -- https://mathworld.wolfram.com/ConicalFrustum.html
+        # gives geometric centroid as
+        # \overline{z}} = h * (R1**2 + 2 * R1*R2 + 3 * R2**2) / (4 * (R1**2 + R1 * R2 + R2**2))
+        R = cell.d / 2
+        # relative COMs per segment
+        h_bar_seg = cell.length * (R[:, 0]**2 + 2 * R[:, 0] * R[:, 1] + 3 * R[:, 1]**2
+                                   ) / (4 * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2))
+        # carthesian coordinates
+        r_bar_seg =  np.c_[cell.x[:, 0] + h_bar_seg * (cell.x[:, 1] - cell.x[:, 0]
+                                                                ) / cell.length,
+                           cell.y[:, 0] + h_bar_seg * (cell.y[:, 1] - cell.y[:, 0]
+                                                                ) / cell.length,
+                           cell.z[:, 0] + h_bar_seg * (cell.z[:, 1] - cell.z[:, 0]
+                                                                ) / cell.length]
+        # Volumes / mass
+        # V = 1 / 3 * π * h * (R1**2 + R1 * R2 + R2**2)
+        V_seg = np.pi * cell.length * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2) / 3
+
+        # Center of mass per CV
+        r_bar = np.zeros((0, 3))
+        for i in range(len(cell._loc_sets)):
+            inds = cell._CV_ind == i
+            if inds.sum() <= 1:
+                r_ = (r_bar_seg[inds, ] * V_seg[inds] / V_seg[inds].sum()).mean(axis=0)
+            else:
+                # compute mean position weighted by volume/mass (mass monopole location)
+                r_ = (r_bar_seg[inds, ].T * V_seg[inds] / V_seg[inds].sum()).sum(axis=-1)
+            r_bar = np.vstack((r_bar, r_))
+
+
+        # local containers
+        synidx = {}
+
+        # get synaptic placements and cells from the network,
+        # then set spike times,
+        for i, X in enumerate(self.X):
+            synidx[X] = self.fetchSynIdxCell(# cell=cell,
+                                             areas=CV_areas,
+                                             depth=r_bar[:, 2],
+                                             nidx=self.k_yXL[:, i],
+                                             synParams=self.synParams.copy())
+        # clean up hoc namespace
+        # cell.__del__()
+
+        return synidx
+
+    def fetchSynIdxCell(self,
+                        areas,
+                        depth,
+                        nidx, synParams):
+        """
+        Find possible synaptic placements for each cell
+        As synapses are placed within layers with bounds determined by
+        self.layerBoundaries, it will check this matrix accordingly, and
+        use the probabilities from `self.connProbLayer to distribute.
+
+        For each layer, the synapses are placed with probability normalized
+        by membrane area of each compartment
+
+
+        Parameters
+        ----------
+        areas:
+        depth:
+        nidx : numpy.ndarray
+            Numbers of synapses per presynaptic population X.
+        synParams : which `LFPy.Synapse` parameters to use.
+
+
+        Returns
+        -------
+        syn_idx : list
+            List of arrays of synapse placements per connection.
+
+
+        See also
+        --------
+        Population.get_all_synIdx, Population.get_synIdx, LFPy.Synapse
+
+        """
+        # segment indices in each layer is stored here, list of np.array
+        syn_idx = []
+        # loop over layer bounds, find synapse locations
+        for i, zz in enumerate(self.layerBoundaries):
+            if nidx[i] == 0:
+                syn_idx.append(np.array([], dtype=int))
+            else:
+                syn_idx.append(
+                    get_rand_idx_area_and_distribution_norm(
+                        areas, depth,
+                        n_syn=nidx[i],
+                        fun=[st.uniform],
+                        funargs=[dict(loc=zz.min(), scale=abs(zz.max()-zz.min()))],
+                        funweights=[1.],
+                    ).astype('int16'))
+
+        return syn_idx
+
+    def insert_all_synapses(self, **kwargs):
+        pass
+
+    def insert_synapses(self, **kwargs):
+        pass
+
+    def cellsim(self, cellindex, return_just_cell=False):
+        """
+        Do the actual simulations of LFP, using synaptic spike times from
+        network simulation.
+
+
+        Parameters
+        ----------
+        cellindex : int
+            cell index between 0 and population size-1.
+        return_just_cell : bool
+            If True, return only the `LFPy.Cell` object
+            if False, run full simulation, return None.
+
+
+        Returns
+        -------
+        None or `LFPy.Cell` object
+
+
+        See also
+        --------
+        hybridLFPy.csd, LFPy.Cell, LFPy.Synapse, LFPy.RecExtElectrode
+        """
+        tic = time()
+
+        '''
+        cell = LFPy.Cell(**self.cellParams)
+        cell.set_pos(**self.pop_soma_pos[cellindex])
+        cell.set_rotation(**self.rotations[cellindex])
+        '''
+
+        ##### ARBOR
+
+        # cell decor
+        decor = arbor.decor()
+
+        # set initial voltage, temperature, axial resistivity, membrane capacitance
+        decor.set_property(
+            Vm=self.cellParams['v_init'],  # Initial membrane voltage [mV]
+            tempK=300,  # Temperature [Kelvin]
+            rL=self.cellParams['Ra'],  # Axial resistivity [Ω cm]
+            cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance [F/m**2]
+        )
+
+        # set passive mechanism all over
+        pas = arbor.mechanism(
+            'pas/e={}'.format(self.cellParams['passive_parameters']['e_pas'])
+            )  # passive mech w. leak reversal potential (mV)
+        pas.set('g', self.cellParams['passive_parameters']['g_pas'])  # leak conductivity (S/cm2)
+        decor.paint('(all)', pas)
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # define morphology (needed for arbor.place_pwlin etc.)
+        morphology = arbor.load_swc_arbor(self.cellParams['morphology'])
+
+        # Label dictionary
+        defs = {}
+        labels = arbor.label_dict(defs)
+
+        # define isometry
+        iso = arbor.isometry()  # create isometry
+        for key, val in self.rotations[cellindex].items():
+            args = {
+                'theta': float(val),
+                'axis': tuple((np.array(['x', 'y', 'z']) == key).astype('float'))}
+            iso_rot = iso.rotate(**args)
+        iso_trans = iso.translate(**self.pop_soma_pos[cellindex])
+
+        # place_pwlin
+        p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry
+
+        # need cell geometry object
+        cell = self._get_cell(p, morphology, labels, decor)
+
+        if return_just_cell:
+            # return only the CellGeometry object (for plotting etc.)
+            return cell
+        else:
+            # proper simulation procedure inserting synapses, record transmembrane currents,
+            # make extracellular predictions
+
+            # get transmembrane currents
+            I_m = self._get_I_m(cell, cellindex, decor, morphology, labels)
+
+            # compute signal of each probe
+            for probe in self.probes:
+                probe.cell = cell
+
+                M = self._get_transformation_matrix_for_CV(cell, probe, I_m)
+
+                probe.data = M @ I_m
+
+            # downsample probe.data attribute and unset cell
+            for probe in self.probes:
+                probe.data = ss.decimate(probe.data,
+                                         q=self.decimatefrac
+                                         ).astype(np.float32)
+                probe.cell = None
+
+            # put all necessary cell output in output dict
+            for attrbt in self.savelist:
+                attr = getattr(cell, attrbt)
+                if isinstance(attr, np.ndarray):
+                    self.output[cellindex][attrbt] = attr.astype('float32')
+                else:
+                    try:
+                        self.output[cellindex][attrbt] = attr
+                    except BaseException:
+                        self.output[cellindex][attrbt] = str(attr)
+                self.output[cellindex]['srate'] = 1E3 / self.dt_output
+
+            # collect probe output
+            for probe in self.probes:
+                self.output[cellindex][probe.__class__.__name__] =                     probe.data.copy()
+
+            print('cell %s population %s in %.2f s' % (cellindex, self.y,
+                                                       time() - tic))
+
+    def _get_cell(self, p, morphology, labels, decor):
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cell
+        recipe = BaseRecipe(cable_cell)
+
+        # instantiate simulation
+        context = arbor.context()
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # need meta data locating each CV
+        _, I_m_meta = sim.samples(i_handle)[0]
+
+        # Gather geometry of CVs and assign segments to each CV,
+        # get segment geometries and mapping to CV indices
+        x, y, z, d = [np.array([], dtype=float).reshape((0, 2))] * 4
+        CV_ind = np.array([], dtype=int)  # tracks which CV owns segment
+        for i, m in enumerate(I_m_meta):
+            segs = p.segments([m])
+            for j, seg in enumerate(segs):
+                x = np.row_stack([x, [seg.prox.x, seg.dist.x]])
+                y = np.row_stack([y, [seg.prox.y, seg.dist.y]])
+                z = np.row_stack([z, [seg.prox.z, seg.dist.z]])
+                d = np.row_stack([d, [seg.prox.radius * 2, seg.dist.radius * 2]])
+                CV_ind = np.r_[CV_ind, i]
+
+        # define a list of loc_sets with relative location in between proximal and distal points of each CV
+        loc_sets = np.array([
+            '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta
+        ])
+
+        # CellGeometry object
+        cell = lfpykit.CellGeometry(
+            x=x,
+            y=y,
+            z=z,
+            d=d
+        )
+
+        # set some needed attributes:
+        cell._CV_ind = CV_ind
+        cell._loc_sets = loc_sets
+
+        return cell
+
+    def _get_times_weights_taus_CV_inds(self, cellindex):
+        times = np.array([])
+        weights = np.array([])
+        taus = np.array([])
+        CV_inds = np.array([], dtype=int)
+
+        # iterate over presynaptic network populations
+        for i, X in enumerate(self.X):
+            for j, idx in enumerate(self.synIdx[cellindex][X]):
+                weights = np.hstack((weights, np.ones(idx.size) * self.J_yX[i]))
+                taus = np.hstack((taus, np.ones(idx.size) * self.tau_yX[i]))
+                CV_inds = np.hstack((CV_inds, idx))
+
+                if self.synDelays is not None:
+                    synDelays = self.synDelays[cellindex][X][j]
+                else:
+                    synDelays = None
+
+
+                try:
+                    spikes = self.networkSim.dbs[X].select(self.SpCells[cellindex][X][j])
+                except AttributeError:
+                    raise AssertionError(
+                        'could not open CachedNetwork database objects')
+
+                # convert to object array for slicing
+                spikes = np.array(spikes, dtype=object)
+
+                # apply synaptic delays
+                if synDelays is not None and idx.size > 0:
+                    for k, delay in enumerate(synDelays):
+                        if spikes[k].size > 0:
+                            spikes[k] += delay
+
+                times = np.hstack((times, spikes))
+
+        # TODO: remove redundant synapses by combining spike trains
+        # where weights and taus and CV_inds are equal
+        times_ = []
+        weights_ = np.array([])
+        taus_ = np.array([])
+        CV_inds_ = np.array([], dtype=int)
+
+        for tau in np.unique(taus):
+            i_0 = taus == tau
+            for w in np.unique(weights):
+                i_1 = weights == w
+                for CV_i in np.unique(CV_inds):
+                    i_2 = CV_inds == CV_i
+                    i_3 = i_0 & i_1 & i_2
+                    if i_3.sum() > 0:
+                        st = np.concatenate(times[i_3])
+                        st.sort()
+                        times_.append(st)
+                        weights_ = np.r_[weights_, w]
+                        taus_ = np.r_[taus_, tau]
+                        CV_inds_ = np.r_[CV_inds_, CV_i]
+
+        times_ = np.array(times_, dtype=object)
+
+        return times_, weights_, taus_, CV_inds_
+
+    def _get_I_m(self, cell, cellindex, decor, morphology, labels):
+        # Recipe requires "flat" lists of times and weights for each "connection"
+        # plus time constants, CV indices
+        times, weights, taus, CV_inds = self._get_times_weights_taus_CV_inds(cellindex)
+
+        # synapse loc_sets (CV midpoints)
+        syn_loc_sets = cell._loc_sets[CV_inds]
+
+        # create synapses at each loc_set
+        if self.synParams['syntype'] == 'AlphaISyn':
+            synapse = 'alphaisyn'   # workaround
+            for i, (loc_set, tau) in enumerate(zip(syn_loc_sets, taus)):
+                synapse_params = {'tau': tau}
+                decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')
+        else:
+            raise NotImplementedError
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cable_cell
+        recipe = Recipe(cable_cell, weights=weights, times=times)
+
+        # instantiate simulation
+        context = arbor.context()
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # run simulation and collect results.
+        # sim.run(tfinal=self.cellParams['tstop'])
+        self._bench_sim_run(sim)
+
+        # extract I_m for each CV
+        I_m_samples, _ = sim.samples(i_handle)[0]
+
+        # transmembrane currents in nA
+        return I_m_samples[:, 1:].T
+
+    def _bench_sim_run(self, sim):
+        tic = time()
+        sim.run(tfinal=self.cellParams['tstop'] + self.dt, dt=self.dt)
+        toc = time()
+        self._cumulative_sim_time += toc - tic
+
+    def _get_transformation_matrix_for_CV(self, cell, probe, I_m):
+        # mapping per segment (frusta)
+        M_tmp = probe.get_transformation_matrix()
+
+        # Define response matrix from M with columns weighted by area of each frusta
+        M = np.zeros((probe.z.shape[0], I_m.shape[0]))
+        for i in range(I_m.shape[0]):
+            inds = cell._CV_ind == i
+            M[:, i] = M_tmp[:, inds] @ (cell.area[inds] / cell.area[inds].sum())
+
+        return M
+
+
+# In[10]:
+
+
+# %%prun -s cumulative -q -l 20 -T prun0
+
+# measure population simulation times including setup etc.
+ticc = time()
+
+# arbor sim.run cumulative time
+ticc_run = np.array(0.)
+
+####### Set up populations ###############################################
+if properrun:
+    # iterate over each cell type, and create populationulation object
+    for i, Y in enumerate(PS.X):
+        # create population:
+        pop = ArborPopulation(
+            cellParams=PS.cellParams[Y],
+            rand_rot_axis=PS.rand_rot_axis[Y],
+            simulationParams=PS.simulationParams,
+            populationParams=PS.populationParams[Y],
+            y=Y,
+            layerBoundaries=PS.layerBoundaries,
+            savelist=PS.savelist,
+            savefolder=PS.savefolder,
+            probes=probes,
+            dt_output=PS.dt_output,
+            POPULATIONSEED=SIMULATIONSEED + i,
+            X=PS.X,
+            networkSim=networkSim,
+            k_yXL=PS.k_yXL[Y],
+            synParams=PS.synParams[Y],
+            synDelayLoc=PS.synDelayLoc[Y],
+            synDelayScale=PS.synDelayScale[Y],
+            J_yX=PS.J_yX[Y],
+            tau_yX=PS.tau_yX[Y],
+        )
+
+        # run population simulation and collect the data
+        pop.run()
+        pop.collect_data()
+
+        # arbor sim.run cumulative time
+        ticc_run += pop._cumulative_sim_time
+
+        # object no longer needed
+        del pop
+
+# tic toc
+tocc = time() - ticc
+if RANK == 0:
+    with open(os.path.join(savefolder, 'time_pop.txt'), 'w') as f:
+        f.write(f'{tocc}')
+
+if RANK == 0:
+    tocc_run = np.zeros_like(ticc_run)
+else:
+    tocc_run = None
+
+COMM.Reduce(ticc_run, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join(savefolder, 'time_run.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+
+# In[11]:
+
+
+####### Postprocess the simulation output ################################
+
+# reset seed, but output should be deterministic from now on
+np.random.seed(SIMULATIONSEED)
+
+if properrun:
+    # do some postprocessing on the collected data, i.e., superposition
+    # of population LFPs, CSDs etc
+    postproc = PostProcess(y=PS.X,
+                           dt_output=PS.dt_output,
+                           savefolder=PS.savefolder,
+                           mapping_Yy=PS.mapping_Yy,
+                           savelist=PS.savelist,
+                           probes=probes,
+                           cells_subfolder=os.path.split(PS.cells_path)[-1],
+                           populations_subfolder=os.path.split(PS.populations_path)[-1],
+                           figures_subfolder=os.path.split(PS.figures_path)[-1])
+
+    # run through the procedure
+    postproc.run()
+
+    # create tar-archive with output for plotting, ssh-ing etc.
+    postproc.create_tar_archive()
+
+
+COMM.Barrier()
+
+# tic toc
+print('Execution time: %.3f seconds' % (time() - tic))
diff --git a/examples/benchmarks/plot_benchmarks.py b/examples/benchmarks/plot_benchmarks.py
new file mode 100644
index 0000000..d78b8ea
--- /dev/null
+++ b/examples/benchmarks/plot_benchmarks.py
@@ -0,0 +1,43 @@
+import os
+import numpy as np
+import hashlib
+import json
+from parameters import ParameterSpace, ParameterSet
+import matplotlib.pyplot as plt
+
+import brunel_alpha_nest as BN
+
+
+PS0 = ParameterSpace('PS0.txt')
+keys = PS0.range_keys()
+
+fig, ax = plt.subplots(1, 1, figsize=(8, 8))
+ax.set_title(f'# neurons: {}; host: {}'os.environ['HOST'])
+
+for i, SIM_SCRIPT in enumerate(PS0['SIM_SCRIPT']):
+    times_pop = []
+    times_run = []
+    NTASKS = []
+    for j, N in enumerate(PS0['NTASKS']):
+        NTASKS.append(N)
+        pset = ParameterSet(dict(NTASKS=N,
+                                 SIM_SCRIPT=SIM_SCRIPT,
+                                 GLOBALSEED=PS0['GLOBALSEED']))
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        with open(os.path.join(md5, 'time_pop.txt'), 'r') as f:
+            times_pop.append(float(f.readline()))
+
+        with open(os.path.join(md5, 'time_run.txt'), 'r') as f:
+            times_run.append(float(f.readline()))
+
+    label = f"{'LFPy' if SIM_SCRIPT == 'example_brunel.py' else 'Arbor'} pop"
+    ax.loglog(NTASKS, times_pop, '-o', label=label, base=2)
+
+    label = f"{'LFPy' if SIM_SCRIPT == 'example_brunel.py' else 'Arbor'} run"
+    ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
+
+ax.legend()
+ax.set_xlabel('NTASKS')
+ax.set_ylabel('time (ms)')
diff --git a/examples/benchmarks/requirements.txt b/examples/benchmarks/requirements.txt
new file mode 100644
index 0000000..e69de29
diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
new file mode 100644
index 0000000..943c0c9
--- /dev/null
+++ b/examples/benchmarks/run_benchmarks.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''Define ParameterSpace for benchmarking of scaling with different MPI pools
+'''
+import os
+import numpy as np
+import operator
+import pickle
+import hashlib
+# import parameters as ps
+import subprocess as sp
+import json
+from parameters import ParameterSpace, ParameterSet, ParameterRange
+import matplotlib.pyplot as plt
+
+PSPACES = dict()
+
+# check scaling with MPI pool size
+PS0 = ParameterSpace(dict(
+    # allow different seeds for different network iterations
+    GLOBALSEED=1234,
+
+    # MPI pool size
+    NTASKS=ParameterRange([1, 2, 4, 8]),
+
+    # population size scaling (multiplied with values in
+    # populationParams['POP_SIZE']):
+    # POPSCALING=ParameterRange([1.]),
+
+    # simulation scripts:
+    SIM_SCRIPT=ParameterRange(['example_brunel.py', 'example_brunel_arbor.py'])
+))
+
+PS0.save('PS0.txt')
+PSPACES.update(dict(PS0=PS0))
+
+jobscript_local = '''#!/bin/bash
+# from here on we can run whatever command we want
+unset DISPLAY # DISPLAY somehow problematic with Slurm
+mpirun -n {} python {} {}
+'''
+
+job_script_jusuf = """#!/bin/bash
+##################################################################
+#SBATCH --account {}
+#SBATCH --job-name {}
+#SBATCH --time {}
+#SBATCH -o logs/{}_stdout.txt
+#SBATCH -e logs/{}_error.txt
+#SBATCH -N {}
+#SBATCH --ntasks {}
+##################################################################
+# from here on we can run whatever command we want
+unset DISPLAY # DISPLAY somehow problematic with Slurm
+srun --mpi=pmi2 python -u {} {}
+"""
+
+# create output directories, wipe if they exist
+for dir in ['jobs', 'parameters', 'logs', 'output']:
+    if not os.path.isdir(dir):
+        os.mkdir(dir)
+
+
+# slurm job settings (shared)
+ACCOUNT = 'icei-hbp-2020-0004'
+TIME = '00:10:00'
+LNODES = 1
+
+env = os.environ
+
+if 'HOSTNAME' in env.keys() and env['HOSTNAME'].rfind('jusuf') >= 0:
+    # container for job IDs
+    jobIDs = []
+    for pset in PS0.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # create job script
+        with open(os.path.join('jobs', '{}.job'.format(md5)), 'w') as f:
+            f.writelines(job.format(
+                ACCOUNT,
+                md5,
+                TIME,
+                md5,
+                md5,
+                LNODES,
+                NTASKS,
+                pset.SIM_SCRIPT,
+                md5
+            ))
+        cmd = ' '.join(['sbatch',
+                        '{}'.format(os.path.join('jobs',
+                                    '{}.job'.format(md5)))])
+        print(cmd)
+        output = sp.getoutput(cmd)
+        # output = sp.getoutput(
+        #     'sbatch {}'.format(os.path.join('jobs', '{}.job'.format(md5))))
+        jobid = output.split(' ')[-1]
+        jobIDs.append((md5, jobid))
+else:
+    for pset in PS0.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # run model serially
+        cmd = 'mpirun -n {} python {} {}'.format(pset.NTASKS, pset.SIM_SCRIPT, md5)
+        print(cmd)
+        sp.run(cmd.split(' '))
diff --git a/hybridLFPy/population.py b/hybridLFPy/population.py
index e7d995c..e7739e0 100644
--- a/hybridLFPy/population.py
+++ b/hybridLFPy/population.py
@@ -934,6 +934,7 @@ def __init__(self,
         tic = time()
 
         PopulationSuper.__init__(self, **kwargs)
+
         # set some class attributes
         self.X = X
         self.networkSim = networkSim
@@ -946,6 +947,9 @@ def __init__(self,
         self.J_yX = J_yX
         self.tau_yX = tau_yX
 
+        # for computing the cumulative simulation times
+        self._cumulative_sim_time = 0.
+
         # Now loop over all cells in the population and assess
         # - number of synapses in each z-interval (from layerbounds)
         # - placement of synapses in each z-interval
@@ -954,13 +958,22 @@ def __init__(self,
         # - postsynaptic compartment indices
         # - presynaptic cell indices
         # - synapse delays per connection
-        self.synIdx = self.get_all_synIdx()
-        self.SpCells = self.get_all_SpCells()
-        self.synDelays = self.get_all_synDelays()
+        # self.synIdx = self.get_all_synIdx()
+        # self.SpCells = self.get_all_SpCells()
+        # self.synDelays = self.get_all_synDelays()
+        self._init_activations()
 
         if RANK == 0:
             print("population initialized in %.2f seconds" % (time() - tic))
 
+    def _init_activations(self):
+        """
+        private method for instantiating incoming events
+        """
+        self.synIdx = self.get_all_synIdx()
+        self.SpCells = self.get_all_SpCells()
+        self.synDelays = self.get_all_synDelays()
+
     def get_all_synIdx(self):
         """
         Auxilliary function to set up class attributes containing
@@ -1280,6 +1293,8 @@ def cellsim(self, cellindex, return_just_cell=False):
             for probe in self.probes:
                 probe.cell = cell
 
+
+            ticc = time()
             if 'rec_imem' in self.simulationParams.keys():
                 try:
                     assert self.simulationParams['rec_imem']
@@ -1293,6 +1308,9 @@ def cellsim(self, cellindex, return_just_cell=False):
             else:
                 cell.simulate(probes=self.probes, **self.simulationParams)
 
+            tocc = time()
+            self._cumulative_sim_time += tocc - ticc
+
             # make predictions
             # cell.simulate(probes=self.probes, **self.simulationParams)
 

From b701e9395a4c9344a1cd667c0f22a7f4a0ca191b Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Mon, 2 Aug 2021 14:59:58 +0200
Subject: [PATCH 04/30] fixes

---
 examples/benchmarks/brunel_alpha_nest.py | 4 ++--
 examples/benchmarks/plot_benchmarks.py   | 8 +++++++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/examples/benchmarks/brunel_alpha_nest.py b/examples/benchmarks/brunel_alpha_nest.py
index 33a3128..1b3f8e2 100755
--- a/examples/benchmarks/brunel_alpha_nest.py
+++ b/examples/benchmarks/brunel_alpha_nest.py
@@ -117,7 +117,7 @@ def ComputePSPnorm(tauMem, CMem, tauSyn):
 Note: We record here all spike events.
 '''
 
-order = 128
+order = 256
 NE = 4 * order  # number of excitatory neurons
 NI = 1 * order  # number of inhibitory neurons
 N_neurons = NE + NI   # number of neurons in total
@@ -147,7 +147,7 @@ def ComputePSPnorm(tauMem, CMem, tauSyn):
 tauMem = 20.0       # time constant of membrane potential in ms
 CMem = 250.0        # capacitance of membrane in in pF
 theta = 20.0       # membrane threshold potential in mV
-J = 1.0        # postsynaptic amplitude in mV
+J = 1.0 * 100 / order        # postsynaptic amplitude in mV + 1/K weight scaling
 J_unit = ComputePSPnorm(tauMem, CMem, tauSyn)
 J_ex = J / J_unit  # amplitude of excitatory postsynaptic current
 J_in = -g * J_ex    # amplitude of inhibitory postsynaptic current
diff --git a/examples/benchmarks/plot_benchmarks.py b/examples/benchmarks/plot_benchmarks.py
index d78b8ea..d94af41 100644
--- a/examples/benchmarks/plot_benchmarks.py
+++ b/examples/benchmarks/plot_benchmarks.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 import os
 import numpy as np
 import hashlib
@@ -12,7 +14,7 @@
 keys = PS0.range_keys()
 
 fig, ax = plt.subplots(1, 1, figsize=(8, 8))
-ax.set_title(f'# neurons: {}; host: {}'os.environ['HOST'])
+ax.set_title(f"network size: {5 * BN.order}; host: {os.environ['HOST']}")
 
 for i, SIM_SCRIPT in enumerate(PS0['SIM_SCRIPT']):
     times_pop = []
@@ -41,3 +43,7 @@
 ax.legend()
 ax.set_xlabel('NTASKS')
 ax.set_ylabel('time (ms)')
+
+fig.savefig('PS0.pdf')
+
+plt.show()

From 9857f84b05707f1aaaf715cc85d2aba91dc84e1c Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Mon, 2 Aug 2021 15:14:53 +0200
Subject: [PATCH 05/30] fix

---
 examples/benchmarks/run_benchmarks.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
index 943c0c9..bc67148 100644
--- a/examples/benchmarks/run_benchmarks.py
+++ b/examples/benchmarks/run_benchmarks.py
@@ -21,7 +21,7 @@
     GLOBALSEED=1234,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32]),
 
     # population size scaling (multiplied with values in
     # populationParams['POP_SIZE']):
@@ -47,7 +47,7 @@
 #SBATCH --time {}
 #SBATCH -o logs/{}_stdout.txt
 #SBATCH -e logs/{}_error.txt
-#SBATCH -N {}
+###SBATCH -N {}
 #SBATCH --ntasks {}
 ##################################################################
 # from here on we can run whatever command we want
@@ -81,14 +81,14 @@
 
         # create job script
         with open(os.path.join('jobs', '{}.job'.format(md5)), 'w') as f:
-            f.writelines(job.format(
+            f.writelines(job_script_jusuf.format(
                 ACCOUNT,
                 md5,
                 TIME,
                 md5,
                 md5,
                 LNODES,
-                NTASKS,
+                pset.NTASKS,
                 pset.SIM_SCRIPT,
                 md5
             ))

From d0d88a0ef1a6bfa58c4caf0e3b6a719e7ab889e4 Mon Sep 17 00:00:00 2001
From: Espen Hagen <espehage@fys.uio.no>
Date: Mon, 2 Aug 2021 16:15:05 +0200
Subject: [PATCH 06/30] title fix

---
 examples/benchmarks/plot_benchmarks.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/examples/benchmarks/plot_benchmarks.py b/examples/benchmarks/plot_benchmarks.py
index d94af41..e6f2cf8 100644
--- a/examples/benchmarks/plot_benchmarks.py
+++ b/examples/benchmarks/plot_benchmarks.py
@@ -14,7 +14,12 @@
 keys = PS0.range_keys()
 
 fig, ax = plt.subplots(1, 1, figsize=(8, 8))
-ax.set_title(f"network size: {5 * BN.order}; host: {os.environ['HOST']}")
+for h in ['HOST', 'HOSTNAME']:
+    if h in os.environ:
+        host = os.environ[h]
+        break
+
+ax.set_title(f"network size: {5 * BN.order}; host: {host}")
 
 for i, SIM_SCRIPT in enumerate(PS0['SIM_SCRIPT']):
     times_pop = []

From 3e1ae86356bd5c917ab7d8c878f1e543ee846c2c Mon Sep 17 00:00:00 2001
From: Espen Hagen <espehage@fys.uio.no>
Date: Mon, 2 Aug 2021 16:17:20 +0200
Subject: [PATCH 07/30] jureca fixes

---
 examples/benchmarks/run_benchmarks.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
index bc67148..986aa44 100644
--- a/examples/benchmarks/run_benchmarks.py
+++ b/examples/benchmarks/run_benchmarks.py
@@ -21,7 +21,7 @@
     GLOBALSEED=1234,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128]),
 
     # population size scaling (multiplied with values in
     # populationParams['POP_SIZE']):
@@ -49,6 +49,7 @@
 #SBATCH -e logs/{}_error.txt
 ###SBATCH -N {}
 #SBATCH --ntasks {}
+#SBATCH --cpus-per-task=2
 ##################################################################
 # from here on we can run whatever command we want
 unset DISPLAY # DISPLAY somehow problematic with Slurm
@@ -62,13 +63,15 @@
 
 
 # slurm job settings (shared)
-ACCOUNT = 'icei-hbp-2020-0004'
+ACCOUNT = 'jinb33'  #'icei-hbp-2020-0004'
 TIME = '00:10:00'
 LNODES = 1
 
 env = os.environ
 
-if 'HOSTNAME' in env.keys() and env['HOSTNAME'].rfind('jusuf') >= 0:
+if 'HOSTNAME' in env.keys() and \
+   env['HOSTNAME'].rfind('jr') >= 0 or \
+   env['HOSTNAME'].rfind('jusuf') >= 0:
     # container for job IDs
     jobIDs = []
     for pset in PS0.iter_inner():

From c3eb30524651936d4952c7af19afbdbc6743fa6a Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Mon, 2 Aug 2021 16:21:36 +0200
Subject: [PATCH 08/30] fix

---
 examples/benchmarks/run_benchmarks.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
index 986aa44..ec71bce 100644
--- a/examples/benchmarks/run_benchmarks.py
+++ b/examples/benchmarks/run_benchmarks.py
@@ -62,16 +62,17 @@
         os.mkdir(dir)
 
 
-# slurm job settings (shared)
-ACCOUNT = 'jinb33'  #'icei-hbp-2020-0004'
-TIME = '00:10:00'
-LNODES = 1
-
 env = os.environ
 
 if 'HOSTNAME' in env.keys() and \
    env['HOSTNAME'].rfind('jr') >= 0 or \
    env['HOSTNAME'].rfind('jusuf') >= 0:
+
+    # slurm job settings (shared)
+    ACCOUNT = 'jinb33' if env['HOSTNAME'].rfind('jr') >= 0 else 'icei-hbp-2020-0004'
+    TIME = '00:10:00'
+    LNODES = 1
+
     # container for job IDs
     jobIDs = []
     for pset in PS0.iter_inner():

From ee2f7584780adb349dd6698eafd652acd13dd68e Mon Sep 17 00:00:00 2001
From: Espen Hagen <espehage@fys.uio.no>
Date: Tue, 3 Aug 2021 11:38:21 +0200
Subject: [PATCH 09/30] symlink morphologies

---
 examples/benchmarks/morphologies | 1 +
 1 file changed, 1 insertion(+)
 create mode 120000 examples/benchmarks/morphologies

diff --git a/examples/benchmarks/morphologies b/examples/benchmarks/morphologies
new file mode 120000
index 0000000..5afc3a0
--- /dev/null
+++ b/examples/benchmarks/morphologies
@@ -0,0 +1 @@
+../morphologies
\ No newline at end of file

From 6634aef57b6ee8f80a5d87c0638a5ddfffc53882 Mon Sep 17 00:00:00 2001
From: Espen Hagen <espehage@fys.uio.no>
Date: Tue, 3 Aug 2021 11:39:02 +0200
Subject: [PATCH 10/30] misc fixes

---
 examples/benchmarks/brunel_alpha_nest.py    |  4 ++--
 examples/benchmarks/example_brunel_arbor.py |  4 ++--
 examples/benchmarks/run_benchmarks.py       | 15 ++++++++++++---
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/examples/benchmarks/brunel_alpha_nest.py b/examples/benchmarks/brunel_alpha_nest.py
index 1b3f8e2..f85d1f3 100755
--- a/examples/benchmarks/brunel_alpha_nest.py
+++ b/examples/benchmarks/brunel_alpha_nest.py
@@ -98,7 +98,7 @@ def ComputePSPnorm(tauMem, CMem, tauSyn):
 '''
 
 dt = 0.1    # the resolution in ms
-simtime = 1000.0  # Simulation time in ms
+simtime = 2000.0  # Simulation time in ms
 delay = 1.5    # synaptic delay in ms
 
 '''
@@ -117,7 +117,7 @@ def ComputePSPnorm(tauMem, CMem, tauSyn):
 Note: We record here all spike events.
 '''
 
-order = 256
+order = 512
 NE = 4 * order  # number of excitatory neurons
 NI = 1 * order  # number of inhibitory neurons
 N_neurons = NE + NI   # number of neurons in total
diff --git a/examples/benchmarks/example_brunel_arbor.py b/examples/benchmarks/example_brunel_arbor.py
index 621e06d..ffec80a 100644
--- a/examples/benchmarks/example_brunel_arbor.py
+++ b/examples/benchmarks/example_brunel_arbor.py
@@ -754,7 +754,7 @@ def _get_cell(self, p, morphology, labels, decor):
         recipe = BaseRecipe(cable_cell)
 
         # instantiate simulation
-        context = arbor.context()
+        context = arbor.context(2, None)
         domains = arbor.partition_load_balance(recipe, context)
         sim = arbor.simulation(recipe, domains, context)
 
@@ -887,7 +887,7 @@ def _get_I_m(self, cell, cellindex, decor, morphology, labels):
         recipe = Recipe(cable_cell, weights=weights, times=times)
 
         # instantiate simulation
-        context = arbor.context()
+        context = arbor.context(2, None)
         domains = arbor.partition_load_balance(recipe, context)
         sim = arbor.simulation(recipe, domains, context)
 
diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
index ec71bce..4b54b8a 100644
--- a/examples/benchmarks/run_benchmarks.py
+++ b/examples/benchmarks/run_benchmarks.py
@@ -21,7 +21,7 @@
     GLOBALSEED=1234,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128]),
+    NTASKS=ParameterRange([4, 8, 16, 32, 64, 128, 256, 512]),
 
     # population size scaling (multiplied with values in
     # populationParams['POP_SIZE']):
@@ -53,6 +53,7 @@
 ##################################################################
 # from here on we can run whatever command we want
 unset DISPLAY # DISPLAY somehow problematic with Slurm
+# export OMP_NUM_THREADS=2
 srun --mpi=pmi2 python -u {} {}
 """
 
@@ -70,9 +71,9 @@
 
     # slurm job settings (shared)
     ACCOUNT = 'jinb33' if env['HOSTNAME'].rfind('jr') >= 0 else 'icei-hbp-2020-0004'
-    TIME = '00:10:00'
+    #TIME = '00:10:00'
     LNODES = 1
-
+    
     # container for job IDs
     jobIDs = []
     for pset in PS0.iter_inner():
@@ -80,6 +81,14 @@
         js = json.dumps(pset, sort_keys=True).encode()
         md5 = hashlib.md5(js).hexdigest()
 
+        # walltime (360 seconds per 1 MPI threads and popscaling 1 and                                     
+        # neuron count 512*5)                                                                                          
+        wt = 360 * 1. / pset.NTASKS + 180
+        wt = '%i:%.2i:%.2i' % (wt // 3600,
+                                   (wt - wt // 3600 * 3600) // 60,
+                                   (wt - wt // 60 * 60))
+        TIME = wt
+
         # save parameter file
         pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
 

From e2257d68802daa494334262e3d1120bbc2829f7c Mon Sep 17 00:00:00 2001
From: Espen Hagen <espehage@fys.uio.no>
Date: Tue, 3 Aug 2021 11:44:35 +0200
Subject: [PATCH 11/30] increase min job duration

---
 examples/benchmarks/run_benchmarks.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
index 4b54b8a..af90cef 100644
--- a/examples/benchmarks/run_benchmarks.py
+++ b/examples/benchmarks/run_benchmarks.py
@@ -82,8 +82,8 @@
         md5 = hashlib.md5(js).hexdigest()
 
         # walltime (360 seconds per 1 MPI threads and popscaling 1 and                                     
-        # neuron count 512*5)                                                                                          
-        wt = 360 * 1. / pset.NTASKS + 180
+        # neuron count 512*5)                                                                              
+        wt = 360 * 1. / pset.NTASKS + 240
         wt = '%i:%.2i:%.2i' % (wt // 3600,
                                    (wt - wt // 3600 * 3600) // 60,
                                    (wt - wt // 60 * 60))

From 4785328b449c19ce16709afd76bd29cdc48d1d42 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 4 Aug 2021 15:32:50 +0200
Subject: [PATCH 12/30] test arbor reproducer

---
 examples/benchmarks/arbor_reproducer.py      | 435 +++++++++++++++++++
 examples/benchmarks/plot_arbor_reproducer.py |  47 ++
 examples/benchmarks/run_arbor_reproducer.py  | 117 +++++
 3 files changed, 599 insertions(+)
 create mode 100644 examples/benchmarks/arbor_reproducer.py
 create mode 100644 examples/benchmarks/plot_arbor_reproducer.py
 create mode 100644 examples/benchmarks/run_arbor_reproducer.py

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
new file mode 100644
index 0000000..9c1eadb
--- /dev/null
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -0,0 +1,435 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+# %matplotlib inline
+
+
+# In[2]:
+
+
+from mpi4py import MPI
+from time import time
+import os
+import sys
+import numpy as np
+import arbor
+import scipy.stats
+from parameters import ParameterSet
+
+# In[3]:
+
+
+#######################################
+# Capture command line values
+#######################################
+md5 = sys.argv[1]
+
+# load parameter file
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# set some seed values
+SEED = pset.GLOBALSEED
+np.random.seed(SEED)
+
+
+# In[4]:
+
+
+tstop = 5000
+dt = 0.1
+cellParams = dict(
+            morphology='morphologies/ex.swc',
+            v_init=-65.,
+            cm=1.0,
+            Ra=150,
+            g_pas=1. / (10. * 1E3),  # assume cm=1
+            e_pas=-65,
+            max_cv_length=10,  # µm
+        )
+population_size = pset.POPULATION_SIZE
+synapse_count = 500
+nthreads = pset.NTHREADS
+
+
+# In[5]:
+
+
+def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
+                                           distribution=scipy.stats.expon,
+                                           rvs_args=dict(loc=0, scale=1),
+                                           maxiter=1E6):
+    """
+    Construct a length n list of ndarrays containing continously increasing
+    random numbers on the interval [tstart, tstop], with intervals drawn from
+    a chosen continuous random variable distribution subclassed from
+    scipy.stats.rv_continous, e.g., scipy.stats.expon or scipy.stats.gamma.
+
+    The most likely initial first entry is
+    ``tstart + method.rvs(size=inf, **rvs_args).mean()``
+
+    Parameters
+    ----------
+    n: int
+        number of ndarrays in list
+    tstart: float
+        minimum allowed value in ndarrays
+    tstop: float
+        maximum allowed value in ndarrays
+    distribution: object
+        subclass of scipy.stats.rv_continous. Distributions
+        producing negative values should be avoided if continously increasing
+        values should be obtained, i.e., the probability density function
+        ``(distribution.pdf(**rvs_args))`` should be ``0`` for ``x < 0``,
+        which is not explicitly tested for.
+    rvs_args: dict
+        parameters for method.rvs method. If "size" is in dict, then tstop will
+        be ignored, and each ndarray in output list will be
+        ``distribution.rvs(**rvs_args).cumsum() + tstart``. If size is not
+        given in dict, then values up to tstop will be included
+    maxiter: int
+        maximum number of iterations
+
+
+    Returns
+    -------
+    list of ndarrays
+        length n list of arrays containing data
+
+    Raises
+    ------
+    AssertionError
+        if distribution does not have the 'rvs' attribute
+    StopIteration
+        if number of while-loop iterations reaches maxiter
+
+
+    Examples
+    --------
+    Create n sets of activation times with intervals drawn from the exponential
+    distribution, with rate expectation lambda 10 s^-1 (thus
+    scale=1000 / lambda). Here we assume output in units of ms
+
+    >>> from LFPy.inputgenerators import get_activation_times_from_distribution
+    >>> import scipy.stats as st
+    >>> import matplotlib.pyplot as plt
+    >>> times = get_activation_times_from_distribution(n=10, tstart=0.,
+    >>>                                                tstop=1000.,
+    >>>                                                distribution=st.expon,
+    >>>                                                rvs_args=dict(loc=0.,
+    >>>                                                scale=100.))
+    """
+    assert hasattr(distribution, 'rvs'),         'distribution={} must have the attribute "rvs"'.format(distribution)
+
+    times = []
+    if 'size' in rvs_args.keys():
+        for i in range(n):
+            times += [distribution.rvs(**rvs_args).cumsum() + tstart]
+    else:
+        for i in range(n):
+            values = distribution.rvs(size=1000, **rvs_args).cumsum() + tstart
+            iter = 0
+            while values[-1] < tstop and iter < maxiter:
+                values = np.r_[values, distribution.rvs(
+                    size=1000, **rvs_args).cumsum() + values[-1]]
+                iter += 1
+
+            if iter == maxiter:
+                raise StopIteration('maximum number of iterations reach. Con')
+
+            times += [values[values < tstop]]
+
+    return times
+
+
+# In[6]:
+
+
+class BaseRecipe (arbor.recipe):
+    def __init__(self, cell):
+        super().__init__()
+
+        self.the_cell = cell
+
+        self.iprobe_id = (0, 0)
+
+        self.the_props = arbor.neuron_cable_properties()
+        self.the_cat = arbor.default_catalogue()
+        self.the_props.register(self.the_cat)
+
+    def num_cells(self):
+        return 1
+
+    def num_sources(self, gid):
+        return 0
+
+    def num_targets(self, gid):
+        return 0
+
+    def connections_on(self, gid):
+        return []
+
+    def event_generators(self, gid):
+        return []
+
+    def cell_kind(self, gid):
+        return arbor.cell_kind.cable
+
+    def cell_description(self, gid):
+        return self.the_cell
+
+    def global_properties(self, kind):
+        return self.the_props
+
+    def probes(self, gid):
+        return [
+            arbor.cable_probe_total_current_cell(),
+        ]
+
+
+# In[7]:
+
+
+class Recipe(BaseRecipe):
+    def __init__(self, cell, times=[[1.]], weights=[1.]):
+        super().__init__(cell)
+
+        assert(len(times) == len(weights)), 'len(times) != len(weights)'
+        self.times = times
+        self.weights = weights
+
+    def num_targets(self, gid):
+        return len(self.times)
+
+    def event_generators(self, gid):
+        events = []
+        for i, (w, t) in enumerate(zip(self.weights, self.times)):
+            events += [arbor.event_generator(f'{i}', w,
+                                             arbor.explicit_schedule(t))]
+
+        return events
+
+
+# In[8]:
+
+
+class DummyCell(object):
+    def __init__(self, loc_sets):
+        self.loc_sets = loc_sets
+
+
+# In[22]:
+
+
+class ArborPopulation(object):
+    def __init__(self, cellParams,
+                 dt=0.1, tstop=1000,
+                 population_size=1280,
+                 synapse_count=100,
+                 synapse_rate=20.,
+                 nthreads=2):
+        self.cellParams=cellParams
+        self.dt = dt
+        self.tstop = tstop
+        self.population_size = population_size
+        self.synapse_count = synapse_count
+        self.synapse_rate = synapse_rate
+        self.nthreads = nthreads
+
+        self.cellindices = np.arange(self.population_size)
+        self.rank_cellindices = self.cellindices[self.cellindices % SIZE == RANK]
+        # just set all cell locations and rotations the same
+        self.cell_position = {'x': 1., 'y': 2., 'z': 3.}
+        self.cell_rotation = {'z': np.pi}
+
+        # cumulative sim time
+        self.cumul_sim_time = np.array(0.)
+
+    def cellsim(self, cellindex):
+        """
+
+        Parameters
+        ----------
+        cellindex : int
+            cell index between 0 and population size-1.
+
+        Returns
+        -------
+        None
+
+
+        See also
+        --------
+        """
+        tic = time()
+
+        # cell decor
+        decor = arbor.decor()
+
+        # set initial voltage, temperature, axial resistivity, membrane capacitance
+        decor.set_property(
+            Vm=self.cellParams['v_init'],  # Initial membrane voltage [mV]
+            tempK=300,  # Temperature [Kelvin]
+            rL=self.cellParams['Ra'],  # Axial resistivity [Ω cm]
+            cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance [F/m**2]
+        )
+
+        # set passive mechanism all over
+        pas = arbor.mechanism(
+            'pas/e={}'.format(self.cellParams['e_pas'])
+            )  # passive mech w. leak reversal potential (mV)
+        pas.set('g', self.cellParams['g_pas'])  # leak conductivity (S/cm2)
+        decor.paint('(all)', pas)
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # define morphology (needed for arbor.place_pwlin etc.)
+        morphology = arbor.load_swc_arbor(self.cellParams['morphology'])
+
+        # Label dictionary
+        defs = {}
+        labels = arbor.label_dict(defs)
+
+        # define isometry
+        iso = arbor.isometry()  # create isometry
+        for key, val in self.cell_rotation.items():
+            args = {
+                'theta': float(val),
+                'axis': tuple((np.array(['x', 'y', 'z']) == key).astype('float'))}
+            iso_rot = iso.rotate(**args)
+        iso_trans = iso.translate(**self.cell_position)
+
+        # place_pwlin
+        p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry
+
+        # need dummycell geometry object
+        loc_sets = self.get_loc_sets(p, morphology, labels, decor)
+
+        # get transmembrane currents
+        return self.get_I_m(loc_sets, cellindex, decor, morphology, labels)
+
+    def get_loc_sets(self, p, morphology, labels, decor):
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cell
+        recipe = BaseRecipe(cable_cell)
+
+        # instantiate simulation
+        context = arbor.context()
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # need meta data locating each CV
+        _, I_m_meta = sim.samples(i_handle)[0]
+
+        # define a list of loc_sets with relative location in between proximal and distal points of each CV
+        loc_sets = np.array([
+            '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta
+        ])
+
+        return loc_sets
+
+    def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
+        times = get_activation_times_from_distribution(n=self.synapse_count,
+                                                       tstart=0.,
+                                                       tstop=self.tstop,
+                                                       distribution=scipy.stats.expon,
+                                                       rvs_args=dict(loc=0.,
+                                                                     scale=1000 / self.synapse_rate)
+                                                      )
+        weights = np.random.randn(self.synapse_count)
+        syn_loc_sets = np.random.choice(loc_sets, size=self.synapse_count)
+
+        # create synapses at each loc_set
+        synapse = 'alphaisyn'   # workaround
+        synapse_params = {'tau': 5.}
+        for i, loc_set in enumerate(syn_loc_sets):
+            decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cable_cell
+        recipe = Recipe(cable_cell, weights=weights, times=times)
+
+        # instantiate simulation
+        context = arbor.context(self.nthreads, None)
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # run simulation of transmembrane currents
+        tic = time()
+        self._bench_sim_run(sim)
+        toc = time()
+        self.cumul_sim_time += toc - tic
+
+        # extract I_m for each CV
+        I_m_samples, _ = sim.samples(i_handle)[0]
+
+        # transmembrane currents in nA
+        return I_m_samples[:, 1:]
+
+    def _bench_sim_run(self, sim):
+        sim.run(tfinal=self.tstop, dt=self.dt)
+
+    def run(self):
+        for cellindex in self.rank_cellindices:
+            self.cellsim(cellindex)
+
+
+# In[23]:
+
+
+# %%prun -s cumulative -q -l 20 -T prun
+pop = ArborPopulation(
+    cellParams=cellParams,
+    dt=dt,
+    tstop=tstop,
+    population_size=population_size,
+    synapse_count=synapse_count,
+    nthreads=nthreads
+)
+
+# run population simulation and collect the data
+pop.run()
+
+
+# compute mean time spent calling arbor.simulation.run() per MPI process
+if RANK == 0:
+    tocc_run = np.array(0.)
+else:
+    tocc_run = None
+
+COMM.Reduce(pop.cumul_sim_time, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join('logs', f'MPI_SIZE_{SIZE}_NTHREADS_{nthreads}.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+    print(SIZE, nthreads, tocc_run)
+
+# clean exit?
+COMM.Barrier()
diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
new file mode 100644
index 0000000..f90e2b4
--- /dev/null
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import numpy as np
+import hashlib
+import json
+from parameters import ParameterSpace, ParameterSet
+import matplotlib.pyplot as plt
+
+
+PS_reproducer = ParameterSpace('PS_reproducer.txt')
+keys = PS_reproducer.range_keys()
+
+fig, ax = plt.subplots(1, 1, figsize=(8, 8))
+for h in ['HOST', 'HOSTNAME']:
+    if h in os.environ:
+        host = os.environ[h]
+        break
+
+# ax.set_title(f"network size: {5 * BN.order}; host: {host}")
+
+for i, NTHREADS in enumerate(PS_reproducer['NTHREADS']):
+    times_run = []
+    NTASKS = []
+    for j, N in enumerate(PS_reproducer['NTASKS']):
+        NTASKS.append(N)
+        pset = ParameterSet(dict(NTASKS=N,
+                                 NTHREADS=NTHREADS,
+                                 GLOBALSEED=PS_reproducer['GLOBALSEED'],
+                                 POPULATION_SIZE=PS_reproducer['POPULATION_SIZE'],
+                                 ))
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        with open(os.path.join('logs', f'MPI_SIZE_{N}_NTHREADS_{NTHREADS}.txt'), 'r') as f:
+            times_run.append(float(f.readline()))
+
+    label = f"nthreads: {NTHREADS}"
+    ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
+
+ax.legend()
+ax.set_xlabel('NTASKS')
+ax.set_ylabel('time (ms)')
+
+fig.savefig('PS_reproducer.pdf')
+
+plt.show()
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
new file mode 100644
index 0000000..73f6289
--- /dev/null
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''Define ParameterSpace for benchmarking of scaling with different MPI pools
+'''
+import os
+import numpy as np
+import operator
+import pickle
+import hashlib
+import subprocess as sp
+import json
+from parameters import ParameterSpace, ParameterSet, ParameterRange
+
+PSPACES = dict()
+
+# check scaling with MPI pool size
+PS_reproducer = ParameterSpace(dict(
+    # allow different seeds for different network iterations
+    GLOBALSEED=1234,
+
+    # number of Neurons
+    POPULATION_SIZE=256,
+
+    # MPI pool size
+    NTASKS=ParameterRange([2, 4, 8, 16, 32, 64, 128]),
+
+    NTHREADS=ParameterRange([1, 2]),
+
+    # simulation scripts:
+    SIM_SCRIPT='arbor_reproducer.py'
+))
+
+PS_reproducer.save('PS_reproducer.txt')
+PSPACES.update(dict(PS_reproducer=PS_reproducer))
+
+job_script_hpc = """#!/bin/bash
+##################################################################
+#SBATCH --account {}
+#SBATCH --job-name {}
+#SBATCH --time {}
+#SBATCH -o logs/{}_stdout.txt
+#SBATCH -e logs/{}_error.txt
+#SBATCH --ntasks {}
+#SBATCH --cpus-per-task={}
+##################################################################
+# from here on we can run whatever command we want
+unset DISPLAY # DISPLAY somehow problematic with Slurm
+srun --mpi=pmi2 python -u {} {}
+"""
+
+# create output directories, wipe if they exist
+for dir in ['jobs', 'parameters', 'logs', 'output']:
+    if not os.path.isdir(dir):
+        os.mkdir(dir)
+
+
+env = os.environ
+
+if 'HOSTNAME' in env.keys():
+    if env['HOSTNAME'].rfind('jr') >= 0 or env['HOSTNAME'].rfind('jusuf') >= 0:
+
+        # slurm job settings (shared)
+        ACCOUNT = 'jinb33' if env['HOSTNAME'].rfind('jr') >= 0 else 'icei-hbp-2020-0004'
+
+        # container for job IDs
+        jobIDs = []
+        for pset in PS_reproducer.iter_inner():
+            # sorted json dictionary
+            js = json.dumps(pset, sort_keys=True).encode()
+            md5 = hashlib.md5(js).hexdigest()
+
+            # walltime (360 seconds per 1 MPI threads and popscaling 1 and
+            # neuron count 512*5)
+            wt = 360 * 1. / pset.NTASKS + 240
+            wt = '%i:%.2i:%.2i' % (wt // 3600,
+                                       (wt - wt // 3600 * 3600) // 60,
+                                       (wt - wt // 60 * 60))
+            TIME = wt
+
+            # save parameter file
+            pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+            # create job script
+            with open(os.path.join('jobs', '{}.job'.format(md5)), 'w') as f:
+                f.writelines(job_script_hpc.format(
+                    ACCOUNT,
+                    md5,
+                    TIME,
+                    md5,
+                    md5,
+                    pset.NTASKS,
+                    pset.NTHREADS,
+                    pset.SIM_SCRIPT,
+                    md5
+                ))
+            cmd = ' '.join(['sbatch',
+                            '{}'.format(os.path.join('jobs',
+                                        '{}.job'.format(md5)))])
+            print(cmd)
+            output = sp.getoutput(cmd)
+            jobid = output.split(' ')[-1]
+            jobIDs.append((md5, jobid))
+    else:
+        raise NotImplementedError
+else:
+    for pset in PS_reproducer.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # run model serially
+        cmd = 'mpirun -n {} python {} {}'.format(pset.NTASKS, pset.SIM_SCRIPT, md5)
+        print(cmd)
+        sp.run(cmd.split(' '))

From ba6956be902d1939f42966e43801494aeca1fbe8 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 4 Aug 2021 15:43:37 +0200
Subject: [PATCH 13/30] things

---
 examples/benchmarks/arbor_reproducer.py     | 61 +--------------------
 examples/benchmarks/run_arbor_reproducer.py |  4 +-
 2 files changed, 5 insertions(+), 60 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 9c1eadb..61896e0 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -68,64 +68,7 @@ def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
                                            rvs_args=dict(loc=0, scale=1),
                                            maxiter=1E6):
     """
-    Construct a length n list of ndarrays containing continously increasing
-    random numbers on the interval [tstart, tstop], with intervals drawn from
-    a chosen continuous random variable distribution subclassed from
-    scipy.stats.rv_continous, e.g., scipy.stats.expon or scipy.stats.gamma.
-
-    The most likely initial first entry is
-    ``tstart + method.rvs(size=inf, **rvs_args).mean()``
-
-    Parameters
-    ----------
-    n: int
-        number of ndarrays in list
-    tstart: float
-        minimum allowed value in ndarrays
-    tstop: float
-        maximum allowed value in ndarrays
-    distribution: object
-        subclass of scipy.stats.rv_continous. Distributions
-        producing negative values should be avoided if continously increasing
-        values should be obtained, i.e., the probability density function
-        ``(distribution.pdf(**rvs_args))`` should be ``0`` for ``x < 0``,
-        which is not explicitly tested for.
-    rvs_args: dict
-        parameters for method.rvs method. If "size" is in dict, then tstop will
-        be ignored, and each ndarray in output list will be
-        ``distribution.rvs(**rvs_args).cumsum() + tstart``. If size is not
-        given in dict, then values up to tstop will be included
-    maxiter: int
-        maximum number of iterations
-
-
-    Returns
-    -------
-    list of ndarrays
-        length n list of arrays containing data
-
-    Raises
-    ------
-    AssertionError
-        if distribution does not have the 'rvs' attribute
-    StopIteration
-        if number of while-loop iterations reaches maxiter
-
-
-    Examples
-    --------
-    Create n sets of activation times with intervals drawn from the exponential
-    distribution, with rate expectation lambda 10 s^-1 (thus
-    scale=1000 / lambda). Here we assume output in units of ms
-
-    >>> from LFPy.inputgenerators import get_activation_times_from_distribution
-    >>> import scipy.stats as st
-    >>> import matplotlib.pyplot as plt
-    >>> times = get_activation_times_from_distribution(n=10, tstart=0.,
-    >>>                                                tstop=1000.,
-    >>>                                                distribution=st.expon,
-    >>>                                                rvs_args=dict(loc=0.,
-    >>>                                                scale=100.))
+    https://lfpy.readthedocs.io/en/latest/classes.html#LFPy.inputgenerators.get_activation_times_from_distribution
     """
     assert hasattr(distribution, 'rvs'),         'distribution={} must have the attribute "rvs"'.format(distribution)
 
@@ -345,6 +288,8 @@ def get_loc_sets(self, p, morphology, labels, decor):
         return loc_sets
 
     def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
+        # fetch synaptic activation times, synapse weights, and random locations
+        # corresponding to each CV midpoint.
         times = get_activation_times_from_distribution(n=self.synapse_count,
                                                        tstart=0.,
                                                        tstop=self.tstop,
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index 73f6289..a74bdf7 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -19,10 +19,10 @@
     GLOBALSEED=1234,
 
     # number of Neurons
-    POPULATION_SIZE=256,
+    POPULATION_SIZE=512,
 
     # MPI pool size
-    NTASKS=ParameterRange([2, 4, 8, 16, 32, 64, 128]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256]),
 
     NTHREADS=ParameterRange([1, 2]),
 

From 301547c0627d91be733f065efd5e251e6f9d2826 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 5 Aug 2021 18:11:18 +0200
Subject: [PATCH 14/30] arbor.context(1, None)

---
 examples/benchmarks/arbor_reproducer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 61896e0..224cc25 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -317,7 +317,7 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         recipe = Recipe(cable_cell, weights=weights, times=times)
 
         # instantiate simulation
-        context = arbor.context(self.nthreads, None)
+        context = arbor.context(1, None)
         domains = arbor.partition_load_balance(recipe, context)
         sim = arbor.simulation(recipe, domains, context)
 

From 9f45158fdb0d4f81b3d2ea8146a023f070c1e1e1 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 5 Aug 2021 18:12:49 +0200
Subject: [PATCH 15/30] arbor.context(1, None)

---
 examples/benchmarks/example_brunel_arbor.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/benchmarks/example_brunel_arbor.py b/examples/benchmarks/example_brunel_arbor.py
index ffec80a..cb2a301 100644
--- a/examples/benchmarks/example_brunel_arbor.py
+++ b/examples/benchmarks/example_brunel_arbor.py
@@ -754,7 +754,7 @@ def _get_cell(self, p, morphology, labels, decor):
         recipe = BaseRecipe(cable_cell)
 
         # instantiate simulation
-        context = arbor.context(2, None)
+        context = arbor.context(1, None)
         domains = arbor.partition_load_balance(recipe, context)
         sim = arbor.simulation(recipe, domains, context)
 
@@ -887,7 +887,7 @@ def _get_I_m(self, cell, cellindex, decor, morphology, labels):
         recipe = Recipe(cable_cell, weights=weights, times=times)
 
         # instantiate simulation
-        context = arbor.context(2, None)
+        context = arbor.context(1, None)
         domains = arbor.partition_load_balance(recipe, context)
         sim = arbor.simulation(recipe, domains, context)
 

From 888b3d0da8108ebe7c463db49db7aacadaf42b83 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 18 Aug 2021 22:36:38 +0200
Subject: [PATCH 16/30] backup

---
 examples/Example_Arbor_swc_hybridLFPy.ipynb | 393 ++++++++++++++++++--
 1 file changed, 360 insertions(+), 33 deletions(-)

diff --git a/examples/Example_Arbor_swc_hybridLFPy.ipynb b/examples/Example_Arbor_swc_hybridLFPy.ipynb
index 8ed0cae..7322194 100644
--- a/examples/Example_Arbor_swc_hybridLFPy.ipynb
+++ b/examples/Example_Arbor_swc_hybridLFPy.ipynb
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -24,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -45,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -64,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -94,7 +94,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -121,7 +121,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -173,12 +173,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
     "class Recipe(BaseRecipe):\n",
-    "    def __init__(self, cell, n_syn=1, times=[[1.]], weights=[1.]):\n",
+    "    def __init__(self, cell, times=[[1.]], weights=[1.]):\n",
     "        super().__init__(cell)\n",
     "        \n",
     "        assert(len(times) == len(weights)), 'len(times) != len(weights)'\n",
@@ -197,15 +197,6 @@
     "        return events"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "arbor.event_generator?"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -215,7 +206,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -234,6 +225,8 @@
     "# synapse model and kwargs\n",
     "synapse = 'expisyn'\n",
     "synapse_params = {'tau': 5}\n",
+    "# synapse = 'alphaisyn'\n",
+    "# synapse_params = {'tau': 5}\n",
     "\n",
     "# synapse weight dist\n",
     "weight_params = dict(loc=0, scale=1E-3)\n"
@@ -241,7 +234,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -268,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -276,14 +269,19 @@
     "morphology = arbor.load_swc_arbor(morphology_file)\n",
     "\n",
     "# Label dictionary\n",
-    "defs = {}\n",
+    "defs = {\n",
+    "    'soma': '(tag 1)',\n",
+    "    'axon': '(tag 2)',\n",
+    "    'dend': '(tag 3)',\n",
+    "    'apic': '(tag 4)'\n",
+    "}\n",
     "labels = arbor.label_dict(defs)\n",
     "# labels['all'] = '(all)'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -296,6 +294,26 @@
     "p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "morphology.se"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -305,7 +323,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -328,6 +346,135 @@
     "_, I_m_meta = sim.samples(i_handle)[0]"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "([(cable 0 0 0.5),\n",
+       "  (cable 0 0.5 1),\n",
+       "  (cable 3 0 0.025641),\n",
+       "  (cable 3 0.025641 0.0512821),\n",
+       "  (cable 3 0.0512821 0.0769231),\n",
+       "  (cable 3 0.0769231 0.102564),\n",
+       "  (cable 3 0.102564 0.128205),\n",
+       "  (cable 3 0.128205 0.153846),\n",
+       "  (cable 3 0.153846 0.179487),\n",
+       "  (cable 3 0.179487 0.205128),\n",
+       "  (cable 3 0.205128 0.230769),\n",
+       "  (cable 3 0.230769 0.25641),\n",
+       "  (cable 3 0.25641 0.282051),\n",
+       "  (cable 3 0.282051 0.307692),\n",
+       "  (cable 3 0.307692 0.333333),\n",
+       "  (cable 3 0.333333 0.358974),\n",
+       "  (cable 3 0.358974 0.384615),\n",
+       "  (cable 3 0.384615 0.410256),\n",
+       "  (cable 3 0.410256 0.435897),\n",
+       "  (cable 3 0.435897 0.461538),\n",
+       "  (cable 3 0.461538 0.487179),\n",
+       "  (cable 3 0.487179 0.512821),\n",
+       "  (cable 3 0.512821 0.538462),\n",
+       "  (cable 3 0.538462 0.564103),\n",
+       "  (cable 3 0.564103 0.589744),\n",
+       "  (cable 3 0.589744 0.615385),\n",
+       "  (cable 3 0.615385 0.641026),\n",
+       "  (cable 3 0.641026 0.666667),\n",
+       "  (cable 3 0.666667 0.692308),\n",
+       "  (cable 3 0.692308 0.717949),\n",
+       "  (cable 3 0.717949 0.74359),\n",
+       "  (cable 3 0.74359 0.769231),\n",
+       "  (cable 3 0.769231 0.794872),\n",
+       "  (cable 3 0.794872 0.820513),\n",
+       "  (cable 3 0.820513 0.846154),\n",
+       "  (cable 3 0.846154 0.871795),\n",
+       "  (cable 3 0.871795 0.897436),\n",
+       "  (cable 3 0.897436 0.923077),\n",
+       "  (cable 3 0.923077 0.948718),\n",
+       "  (cable 3 0.948718 0.974359),\n",
+       "  (cable 3 0.974359 1),\n",
+       "  (cable 4 0 0.0588235),\n",
+       "  (cable 4 0.0588235 0.117647),\n",
+       "  (cable 4 0.117647 0.176471),\n",
+       "  (cable 4 0.176471 0.235294),\n",
+       "  (cable 4 0.235294 0.294118),\n",
+       "  (cable 4 0.294118 0.352941),\n",
+       "  (cable 4 0.352941 0.411765),\n",
+       "  (cable 4 0.411765 0.470588),\n",
+       "  (cable 4 0.470588 0.529412),\n",
+       "  (cable 4 0.529412 0.588235),\n",
+       "  (cable 4 0.588235 0.647059),\n",
+       "  (cable 4 0.647059 0.705882),\n",
+       "  (cable 4 0.705882 0.764706),\n",
+       "  (cable 4 0.764706 0.823529),\n",
+       "  (cable 4 0.823529 0.882353),\n",
+       "  (cable 4 0.882353 0.941176),\n",
+       "  (cable 4 0.941176 1),\n",
+       "  (cable 5 0 0.0588235),\n",
+       "  (cable 5 0.0588235 0.117647),\n",
+       "  (cable 5 0.117647 0.176471),\n",
+       "  (cable 5 0.176471 0.235294),\n",
+       "  (cable 5 0.235294 0.294118),\n",
+       "  (cable 5 0.294118 0.352941),\n",
+       "  (cable 5 0.352941 0.411765),\n",
+       "  (cable 5 0.411765 0.470588),\n",
+       "  (cable 5 0.470588 0.529412),\n",
+       "  (cable 5 0.529412 0.588235),\n",
+       "  (cable 5 0.588235 0.647059),\n",
+       "  (cable 5 0.647059 0.705882),\n",
+       "  (cable 5 0.705882 0.764706),\n",
+       "  (cable 5 0.764706 0.823529),\n",
+       "  (cable 5 0.823529 0.882353),\n",
+       "  (cable 5 0.882353 0.941176),\n",
+       "  (cable 5 0.941176 1),\n",
+       "  (cable 1 0 0.0588235),\n",
+       "  (cable 1 0.0588235 0.117647),\n",
+       "  (cable 1 0.117647 0.176471),\n",
+       "  (cable 1 0.176471 0.235294),\n",
+       "  (cable 1 0.235294 0.294118),\n",
+       "  (cable 1 0.294118 0.352941),\n",
+       "  (cable 1 0.352941 0.411765),\n",
+       "  (cable 1 0.411765 0.470588),\n",
+       "  (cable 1 0.470588 0.529412),\n",
+       "  (cable 1 0.529412 0.588235),\n",
+       "  (cable 1 0.588235 0.647059),\n",
+       "  (cable 1 0.647059 0.705882),\n",
+       "  (cable 1 0.705882 0.764706),\n",
+       "  (cable 1 0.764706 0.823529),\n",
+       "  (cable 1 0.823529 0.882353),\n",
+       "  (cable 1 0.882353 0.941176),\n",
+       "  (cable 1 0.941176 1),\n",
+       "  (cable 2 0 0.0588235),\n",
+       "  (cable 2 0.0588235 0.117647),\n",
+       "  (cable 2 0.117647 0.176471),\n",
+       "  (cable 2 0.176471 0.235294),\n",
+       "  (cable 2 0.235294 0.294118),\n",
+       "  (cable 2 0.294118 0.352941),\n",
+       "  (cable 2 0.352941 0.411765),\n",
+       "  (cable 2 0.411765 0.470588),\n",
+       "  (cable 2 0.470588 0.529412),\n",
+       "  (cable 2 0.529412 0.588235),\n",
+       "  (cable 2 0.588235 0.647059),\n",
+       "  (cable 2 0.647059 0.705882),\n",
+       "  (cable 2 0.705882 0.764706),\n",
+       "  (cable 2 0.764706 0.823529),\n",
+       "  (cable 2 0.823529 0.882353),\n",
+       "  (cable 2 0.882353 0.941176),\n",
+       "  (cable 2 0.941176 1)],\n",
+       " (0, 1))"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "I_m_meta, recipe.iprobe_id"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 15,
@@ -370,6 +517,154 @@
     "]"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['(location 0 0.25)',\n",
+       " '(location 0 0.75)',\n",
+       " '(location 3 0.01282051282051282)',\n",
+       " '(location 3 0.038461538461538464)',\n",
+       " '(location 3 0.0641025641025641)',\n",
+       " '(location 3 0.08974358974358974)',\n",
+       " '(location 3 0.11538461538461538)',\n",
+       " '(location 3 0.14102564102564102)',\n",
+       " '(location 3 0.16666666666666669)',\n",
+       " '(location 3 0.1923076923076923)',\n",
+       " '(location 3 0.21794871794871795)',\n",
+       " '(location 3 0.24358974358974356)',\n",
+       " '(location 3 0.2692307692307692)',\n",
+       " '(location 3 0.2948717948717949)',\n",
+       " '(location 3 0.3205128205128205)',\n",
+       " '(location 3 0.34615384615384615)',\n",
+       " '(location 3 0.3717948717948718)',\n",
+       " '(location 3 0.3974358974358974)',\n",
+       " '(location 3 0.4230769230769231)',\n",
+       " '(location 3 0.4487179487179487)',\n",
+       " '(location 3 0.47435897435897434)',\n",
+       " '(location 3 0.5)',\n",
+       " '(location 3 0.5256410256410255)',\n",
+       " '(location 3 0.5512820512820513)',\n",
+       " '(location 3 0.5769230769230769)',\n",
+       " '(location 3 0.6025641025641026)',\n",
+       " '(location 3 0.6282051282051282)',\n",
+       " '(location 3 0.6538461538461537)',\n",
+       " '(location 3 0.6794871794871795)',\n",
+       " '(location 3 0.7051282051282051)',\n",
+       " '(location 3 0.7307692307692308)',\n",
+       " '(location 3 0.7564102564102564)',\n",
+       " '(location 3 0.7820512820512819)',\n",
+       " '(location 3 0.8076923076923077)',\n",
+       " '(location 3 0.8333333333333333)',\n",
+       " '(location 3 0.858974358974359)',\n",
+       " '(location 3 0.8846153846153846)',\n",
+       " '(location 3 0.9102564102564101)',\n",
+       " '(location 3 0.9358974358974359)',\n",
+       " '(location 3 0.9615384615384615)',\n",
+       " '(location 3 0.9871794871794872)',\n",
+       " '(location 4 0.029411764705882353)',\n",
+       " '(location 4 0.08823529411764705)',\n",
+       " '(location 4 0.14705882352941174)',\n",
+       " '(location 4 0.20588235294117646)',\n",
+       " '(location 4 0.2647058823529412)',\n",
+       " '(location 4 0.32352941176470584)',\n",
+       " '(location 4 0.38235294117647056)',\n",
+       " '(location 4 0.4411764705882353)',\n",
+       " '(location 4 0.5)',\n",
+       " '(location 4 0.5588235294117647)',\n",
+       " '(location 4 0.6176470588235294)',\n",
+       " '(location 4 0.6764705882352942)',\n",
+       " '(location 4 0.7352941176470588)',\n",
+       " '(location 4 0.7941176470588235)',\n",
+       " '(location 4 0.8529411764705882)',\n",
+       " '(location 4 0.9117647058823529)',\n",
+       " '(location 4 0.9705882352941176)',\n",
+       " '(location 5 0.029411764705882353)',\n",
+       " '(location 5 0.08823529411764705)',\n",
+       " '(location 5 0.14705882352941174)',\n",
+       " '(location 5 0.20588235294117646)',\n",
+       " '(location 5 0.2647058823529412)',\n",
+       " '(location 5 0.32352941176470584)',\n",
+       " '(location 5 0.38235294117647056)',\n",
+       " '(location 5 0.4411764705882353)',\n",
+       " '(location 5 0.5)',\n",
+       " '(location 5 0.5588235294117647)',\n",
+       " '(location 5 0.6176470588235294)',\n",
+       " '(location 5 0.6764705882352942)',\n",
+       " '(location 5 0.7352941176470588)',\n",
+       " '(location 5 0.7941176470588235)',\n",
+       " '(location 5 0.8529411764705882)',\n",
+       " '(location 5 0.9117647058823529)',\n",
+       " '(location 5 0.9705882352941176)',\n",
+       " '(location 1 0.029411764705882353)',\n",
+       " '(location 1 0.08823529411764705)',\n",
+       " '(location 1 0.14705882352941174)',\n",
+       " '(location 1 0.20588235294117646)',\n",
+       " '(location 1 0.2647058823529412)',\n",
+       " '(location 1 0.32352941176470584)',\n",
+       " '(location 1 0.38235294117647056)',\n",
+       " '(location 1 0.4411764705882353)',\n",
+       " '(location 1 0.5)',\n",
+       " '(location 1 0.5588235294117647)',\n",
+       " '(location 1 0.6176470588235294)',\n",
+       " '(location 1 0.6764705882352942)',\n",
+       " '(location 1 0.7352941176470588)',\n",
+       " '(location 1 0.7941176470588235)',\n",
+       " '(location 1 0.8529411764705882)',\n",
+       " '(location 1 0.9117647058823529)',\n",
+       " '(location 1 0.9705882352941176)',\n",
+       " '(location 2 0.029411764705882353)',\n",
+       " '(location 2 0.08823529411764705)',\n",
+       " '(location 2 0.14705882352941174)',\n",
+       " '(location 2 0.20588235294117646)',\n",
+       " '(location 2 0.2647058823529412)',\n",
+       " '(location 2 0.32352941176470584)',\n",
+       " '(location 2 0.38235294117647056)',\n",
+       " '(location 2 0.4411764705882353)',\n",
+       " '(location 2 0.5)',\n",
+       " '(location 2 0.5588235294117647)',\n",
+       " '(location 2 0.6176470588235294)',\n",
+       " '(location 2 0.6764705882352942)',\n",
+       " '(location 2 0.7352941176470588)',\n",
+       " '(location 2 0.7941176470588235)',\n",
+       " '(location 2 0.8529411764705882)',\n",
+       " '(location 2 0.9117647058823529)',\n",
+       " '(location 2 0.9705882352941176)']"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loc_sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(cable 1 0 1), (cable 2 0 1), (cable 4 0 1), (cable 5 0 1)]"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cell.cables('dend')"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 18,
@@ -450,7 +745,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x13d79b400>"
+       "<matplotlib.legend.Legend at 0x14a1c8760>"
       ]
      },
      "execution_count": 22,
@@ -571,10 +866,8 @@
     {
      "data": {
       "text/plain": [
-       "(array([ 2.,  4.,  3., 10., 18., 20., 22., 11.,  8.,  2.]),\n",
-       " array([ 39.11764706,  66.70588235,  94.29411765, 121.88235294,\n",
-       "        149.47058824, 177.05882353, 204.64705882, 232.23529412,\n",
-       "        259.82352941, 287.41176471, 315.        ]),\n",
+       "(array([12., 13., 12., 10.,  6., 11.,  8.,  8.,  7., 13.]),\n",
+       " array([205., 214., 223., 232., 241., 250., 259., 268., 277., 286., 295.]),\n",
        " <BarContainer object of 10 artists>)"
       ]
      },
@@ -584,7 +877,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -597,10 +890,18 @@
    ],
    "source": [
     "# sanity check\n",
+    "'''\n",
     "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=100, \n",
     "                                               fun=[st.norm], \n",
     "                                               funargs=[dict(loc=200, scale=50)], \n",
     "                                               funweights=[1.])\n",
+    "'''\n",
+    "\n",
+    "# sanity check\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=100, \n",
+    "                                               fun=[st.uniform], \n",
+    "                                               funargs=[dict(loc=200, scale=100)], \n",
+    "                                               funweights=[1.])\n",
     "\n",
     "fig, axes = plt.subplots(1, 2, sharey=True)\n",
     "# areas per depth\n",
@@ -757,7 +1058,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 2400x3200 with 3 Axes>"
       ]
@@ -833,7 +1134,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x144 with 2 Axes>"
       ]
@@ -867,7 +1168,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x144 with 2 Axes>"
       ]
@@ -884,6 +1185,32 @@
     "plt.axis('tight')"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       ...,\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.]])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "I_c"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

From 11465cc56f080e2ffacd8f9c396c1abaf0ea9541 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Fri, 19 Nov 2021 13:46:53 +0100
Subject: [PATCH 17/30] backup

---
 examples/benchmarks/run_arbor_reproducer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index a74bdf7..b58441b 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -24,7 +24,7 @@
     # MPI pool size
     NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256]),
 
-    NTHREADS=ParameterRange([1, 2]),
+    NTHREADS=ParameterRange([1]),
 
     # simulation scripts:
     SIM_SCRIPT='arbor_reproducer.py'

From 7924ccd7705cdbea4cd9410bba091fd0b645b77a Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 09:01:46 +0200
Subject: [PATCH 18/30] convert to weak scaling test

---
 examples/benchmarks/arbor_reproducer.py     | 43 ++++++++++-----------
 examples/benchmarks/run_arbor_reproducer.py |  7 ++--
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 224cc25..9f90dd7 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -55,7 +55,7 @@
             e_pas=-65,
             max_cv_length=10,  # µm
         )
-population_size = pset.POPULATION_SIZE
+population_size = pset.POPULATION_SIZE * SIZE
 synapse_count = 500
 nthreads = pset.NTHREADS
 
@@ -105,8 +105,8 @@ def __init__(self, cell):
         self.iprobe_id = (0, 0)
 
         self.the_props = arbor.neuron_cable_properties()
-        self.the_cat = arbor.default_catalogue()
-        self.the_props.register(self.the_cat)
+        # self.the_cat = arbor.default_catalogue()
+        # self.the_props.register(self.the_cat)
 
     def num_cells(self):
         return 1
@@ -215,23 +215,20 @@ def cellsim(self, cellindex):
         tic = time()
 
         # cell decor
-        decor = arbor.decor()
-
-        # set initial voltage, temperature, axial resistivity, membrane capacitance
-        decor.set_property(
-            Vm=self.cellParams['v_init'],  # Initial membrane voltage [mV]
-            tempK=300,  # Temperature [Kelvin]
-            rL=self.cellParams['Ra'],  # Axial resistivity [Ω cm]
-            cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance [F/m**2]
+        decor = (
+                arbor.decor()
+                # set initial voltage, temperature, axial resistivity, membrane capacitance
+                .set_property(
+                    Vm=self.cellParams['v_init'],  # Initial membrane voltage (mV)
+                    tempK=300,  # Temperature (Kelvin)
+                    rL=self.cellParams['Ra'],  # Axial resistivity (Ω cm)
+                    cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance (F/m**2)
+                )
+                # set passive mechanism all over
+                # passive mech w. leak reversal potential (mV)
+                .paint("(all)", arbor.density(f"pas/e={self.cellParams['e_pas']}", {"g": self.cellParams['g_pas']}))
         )
 
-        # set passive mechanism all over
-        pas = arbor.mechanism(
-            'pas/e={}'.format(self.cellParams['e_pas'])
-            )  # passive mech w. leak reversal potential (mV)
-        pas.set('g', self.cellParams['g_pas'])  # leak conductivity (S/cm2)
-        decor.paint('(all)', pas)
-
         # number of CVs per branch
         policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
         decor.discretization(policy)
@@ -271,7 +268,8 @@ def get_loc_sets(self, p, morphology, labels, decor):
         # instantiate simulation
         context = arbor.context()
         domains = arbor.partition_load_balance(recipe, context)
-        sim = arbor.simulation(recipe, domains, context)
+        # sim = arbor.simulation(recipe, domains, context)
+        sim = arbor.simulation(recipe, context, domains)
 
         # set up sampling on probes
         schedule = arbor.regular_schedule(self.dt)
@@ -301,10 +299,11 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         syn_loc_sets = np.random.choice(loc_sets, size=self.synapse_count)
 
         # create synapses at each loc_set
-        synapse = 'alphaisyn'   # workaround
+        # synapse = 'alphaisyn'   # workaround
+        synapse = 'expsyn_curr'
         synapse_params = {'tau': 5.}
         for i, loc_set in enumerate(syn_loc_sets):
-            decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')
+            decor.place(loc_set, arbor.synapse(synapse, synapse_params), f'{i}')
 
         # number of CVs per branch
         policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
@@ -319,7 +318,7 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         # instantiate simulation
         context = arbor.context(1, None)
         domains = arbor.partition_load_balance(recipe, context)
-        sim = arbor.simulation(recipe, domains, context)
+        sim = arbor.simulation(recipe, context, domains)
 
         # set up sampling on probes
         schedule = arbor.regular_schedule(self.dt)
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index b58441b..14e375f 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -18,11 +18,12 @@
     # allow different seeds for different network iterations
     GLOBALSEED=1234,
 
-    # number of Neurons
-    POPULATION_SIZE=512,
+    # number of neurons per thread
+    POPULATION_SIZE=32,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128]),
+    # NTASKS=ParameterRange([1, 2, 4, 8]),
 
     NTHREADS=ParameterRange([1]),
 

From bb896b3301777ab5fd8d1e67042db0f081052ded Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 10:50:24 +0200
Subject: [PATCH 19/30] pretty

---
 examples/benchmarks/PS_reproducer.pdf        | Bin 0 -> 10728 bytes
 examples/benchmarks/plot_arbor_reproducer.py |   2 ++
 2 files changed, 2 insertions(+)
 create mode 100644 examples/benchmarks/PS_reproducer.pdf

diff --git a/examples/benchmarks/PS_reproducer.pdf b/examples/benchmarks/PS_reproducer.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..484ede028a9fefeeabfc235d8257dbefbb6b3fe2
GIT binary patch
literal 10728
zcmb_?2{@GB7x2%POj22s?G=(Nvv2l2vJXk38e=fUSY}AtED@oy6(to)qEJdvsU(!p
zMpCILgjDtl-+f1l`2LUQd%o9m-8<)QXS?T|_dQq1*4R`Xt${-*<-dmVN)c!X1^K#d
zLuhM5NL#8Wodsb4gaRQQcKXpFq!E=(_4f6IbafGQraL^4G;M-OFng^%o64p`xXDST
zzDzcRoow4u*=%|M6T-tk5lGtrUz$Cg4Q&GZ7@LCi>A`FWY3>8|H2hr~{jSX+R|skE
zMRjK|Jt4y6bSE3PZFCwNB61f0iw=4^0R~K_FPjCSQIi-L0c_|@03c8PwxYW;sD{45
z00(#ko=D&nu$e7201TWY9f73KS-yb*G{6g(*gw30*)xq1@S;<kGi7)KS|OyVH(-V_
zo#yKfcxOpxda}JB^dv(8$}DyOo$7-KPQT@7<ts&8daHlK*VQtH2}S`?J&&2rJQ~h-
zib7=*r4bwb-ON<H`5(9TDeSna6_ANDdGG90;DJlu+5h;(quwoYgq95w9Ya;yuN=>P
zoFy<MRDW?0{PUFR;mg?6X3%RT{$N*AYj1Oy-py92{<{1+=*PmCMGEfZ(&}E@)f(~7
znc0^;Hz3Taty<U0;5x5Ix^DI3TYb97-%@Gqi#DvvDe{fdr-G?0(%0tKZRI6M?P5_`
zdZ|nJm=ia>tocNLV1MoU_qFfxeQQ5=Y>g=C-r-?jQFa^KL(zC^p(pHmW}Kd!tkGHa
z&SpD{uDRJrQG<2glly{GPJ(cx-T6h_7f^EYgXzEa>95FG8E<(BM`IYmoeydw8lVwD
zgR?od_UanNqEP}D+)hRvw^ew5Wc;hNZJXeFW&6uXFKv`guGKo><;rJO(EFie@F}9~
zkeh$d*rUOxx36|v^y)b)Eq$mHV;0));?kI2Fq)CI*o(Br#Z5H#dz{IV-FDTL&U-ZP
zoRCy*Fo`b8xs$tUT|K39_*`?yll)adDTWE&F<hEIR(#yFadd!Me$`j}XBE-n<l$Xf
z@g=+|t0zQVSN$x!THbP4TqiDVu(Z5J$tieIJkf8BZMDntl(1AK*$LkA==!s^wGO>`
zi*{)zy*Q%!rtS$&fJ~~1v6nh?VMk1}f867{Cz;9n{TGf@S6zJ)-NP_m;v-HxJf0%A
zq=a^9(}=P}veb!Nu4A8jAL%LQF1?~a-mSJR!mYoyqGq4?68Re|O`^~K=(Dxik5Rpd
zHnPfWFQ`qqRpO33fPcB6!GGQJkY`eY@-JGL6YQ4v!%4CJBR-;IuWDXwlqR&%TdH*w
z7QZSy6<_@LsPyRDMY}|z-d!C~9T)m_@Zqv=CjAk?>aL3BXK5O8?nKl6?K1zZ**tXD
zPQQyfQroyfA`#J4-HhvL+u^eCetaeFvT?DYZI-#T$l~q929c4C3E%rk>rMoHB<Z=3
zUj?@9avo-9r6Qe6iU&nbiheQAJ#Jk43q7XCZvXGDs<HL9PeI7z*E?UNFEc6RKDXfV
zdUe}-#@Tf=%kJpTu$Wtvu|gU;so^X>kQ;mInVF3A{V>y2$1GOg=uSW6DIp@9*XzFF
zmOG=$LqGM})10scb^PxPmXV?k4yefbTLh}`xm~=FOdwpBZsx@<IA4HpQCYD!$D>t~
zOulqj&M>Q|7VQxFX{+kH%|AaWZ@=ZYr~Leq4YaF{6{%KhT5q#<{~8#lGW<V!FY+%M
zYy0$#Uuqzu46~2ts%Bs!YzcoK<=-}ubHrg=KqjE3>?Fqs!LUt`>mS&3<N3dA1{n<-
znm_geA6K^c4r-zCu5;IyjgUfzV=_gD#(kpIC0^@v#q@h`bw7DPp}0-_@;N_yON#aR
z9fI4=5@obHl^&1bYC<$t3@q^<6uWkUC(%wZ;ehe6M=72kx9rvx^p$p-gOvH2H4<(n
zitz@*cTl`0!`AN?${W1SdDdmvSFUbe`hI6bLFUT_PjS2vttuAk$dsrqi8YB(F%Oo`
zF+32gIdsEiFXJjcsGv-PeZCeEtEccT>?coy)(W-RxM5(cJs*=xB>scjU6_456P9-u
zk|J$~axdsU9V=Hi-ra*;*b{QuFWXXNXxZ+t@$`YGB-`R@OG&R+S8l&lyb*CsAzAtO
z(>%Aq4wEHs<Z3dO3(kSmbO-dmWQxW8BUFmk(-Q^@yUXo6xidDteY7*ZCVPZ6LEzRB
zQ!6y&e#*_C791mg!S2$Ck_~FJ^4A@=wBt`zl^t>Z>X0pWo#4|p=5%Eh;;5-wWOLPR
zIi>dCZNH?rbtD+~;w(*t6nXs18$0Sll2i_~hT?pz<&?~qWb&15syKvPgfR=DR3x7K
zRd|WdQR0jMi)N*$kmGpn)96dA%L5Ub;`!rzid`bZx#7zg4`?0vN=q=(HiI833rfB@
ze?kvlzM%hra97$}8T($;g!h9)vLex6!b+y{Nv#vBtihJje!J{IQqtz(V@c=lsLH2T
zI^RPZ*=+peo?{^3a54QqY<|;il=U-HfgRgQZ>bIq_SY)LwMYj!t~+;^EcAt*L=JZ^
z&|2kvuWf1nTb=NPRAPCodbsK_a+CXyA~_SOu80pm((_cVh$;OtO3^O*uwvp=>(9~t
zU*r67tM@9*AsyKH&PQbkgc&M>#o`=Lwhef0VUMU)h)<?R5h_tG`nu66kN89$ab2mk
ztPNG8+1o1~<vK#Z;3J+bl|0Smx4?Mcf(<MFqih$wGY2McSTr9@u&9~ZtCMKK<UtD>
z4eLf~EWPuiIio*&b!qC`eJ#pLT?eI`#Z9&yEw$WeFM9-+w0~dMSHGf@-?hB!Jv`ny
zXC90BnB37I=Jq9XcXO?&>qh0u&-*<zOFHey68r?K3#anb&c4wI7HV3Rv1w?T-pz*7
zvd{4v0z~$PEV>GgcH!r~r@MZ|Vcu=CboHj>?UK{pY`ng+lYec@O4>1rjy3~<u66gk
zoTF2AnD7{U`Cj~Rm%x{nx7(^O^XI14X{mS=cC#rOOo;>Xven<ufBl&Ca=T&uNTI6I
zfZ59^Y=H6?uLqx=SARG%{x+W1;_xLe`TlnW%tno^H|;e|+}y1L@)@z~t%q$zpWUdq
zCAf6Z+r&tPmGI*8mWsMX+mCvS2e13VC!6(Vm4%RFbIW<_zKhz;4a0KIO>DV2cn^oC
z^Wi-aJ5vh?gbgTL6plB+)N}#joWA2hc?q*S4b{f-#}+9rbo&^(ae@AdOcMX4RR>gg
zY8Nmf&+`{SpX1fz&#YOd7VQlyLr%3s!5j#|LGgSL!eIX~8aCuaUU|VsJ0o>b>zB9a
zm*?bMBfK2lSDKh+edMcr%`*|1wBR%ag+h<27H4<J<DI=_W%*F?5|InT?_^gd$1b8q
zCHOVww=pvgNlXN#)I0I_5k?Mf+`RPVJ<G-o;+`5Ud^AS-eR2&m&Q+u+KJa3Wz0+FM
z8NvPRYZb{5%OQK9<`CvnCn-TWBerj-MJ<TDSEzdtAzogrV`NQ8I3XglXJ;SxiU5NN
z*Eb`wCS{#Ukd%OUqn+EA^pE?u+zMjLUR^EBGCXdeAtL{{Yt6Z($8GbkWSyqi`Q_^7
zbmpJh_i>Ah`W*a%-vZ{vFC2M>1a)k+4jIb}c9SEKUlqSA_{o~)seAObUg9~fVr#kg
z8dkAkS=d@ZbaFwP(#6x4!pdU}zcD{_N8E$*j3`iD$dYJw&pASZh^9<BR*y=g9lB$J
zUXb3!KBvRKiv05)Vn0iY-s5Pd9CKmiq0iVuDj92boeCCL>#ZhiQcl!qhu%{tF*RpT
zB|p^jd6<mQ^mxLnCVb<ayNDI(QJFa<PBIzuS@vAe%02no)mfUI?pAgA3Te&HY+BMr
zr2R^^ymGfrsbb64j-(gYMUcfxhudNZ{8sU=I(vpi7;BJ}G8yNSdjo}2-YoA}E_}>$
zpJc21#3=vx0q2!-a1efRnhyujgqe=r<Vcl2A22_C7r2#Bp@_l!s{SS2;{{Oz&kRDA
z8w$GF+$(h1;7?^&94=AEF5b6R^2>uC7~0JjPLOgZk6=Pf-jnPfL6wph2HIb^UCPRI
zL29lPu1##q(^uH7dATa-+BNJLd$U}Re4og~nl&9vDwoEEFZ!btxo^)8H`{$ae&+BR
z)$Ov|UTxU#x@=vGu0{^V`pqpK=l8c#@^oJH>B$CZexHNb`Nmm9%nWV8VoGdLwuLw@
z;V5xn^*t7Ftp4rXm>Y%~5@v$;A97t03@uhl50CZ?O@(}xRzl*&MQJgT#xm(#36I{b
z<M~giMZ9JXeC8WeVeq6G2$>{U1n@!&jfXSB6+(ZtYbULvqi;+Q7T38Gf{vXZ+rLiX
zoUmGl=uXt0n(vR@uXXJpJ8DVsiJGiVty$k$#GR*Qe?M(|%(iYCz5V(#tp$}*b*|)G
zcmJ%oK!?CJewOtqgLZF5gEl7bSt~?Gyv%1wd%t_=Q?Xpx^u)z4Lc=kTjk5jP%3i4X
zE5CC5o|HUQzmwiWPb^SEykmwUsqL})-GX5c9@`JJ3-`3O1$BgN_1(G5ta)j5g8Xus
z@Su|}6CWB!Z%z0|Y1Lnqyd>TCVMl6XP}LT<L@^du>}!?t9osdWn<O>gCSj}E&;5+5
zyRr3HS%hWZs9t0Jk8vJZ6^|dYS&5x*42UMowB;s8w1j!&1&wxDpHUc5;L)x3z^D+0
zeQ7VfDR-VZK@nvl;m==%$8?4txTf@mukRwSC+$}kfr%Gx=M4;X%x?2artG;<$w*;;
z^CGZR7hM#Q@em40&XPR6R8#D2Z)SVIxi592Mt*}^2Fu;vkWa*f)jX70`1rH^>rsMM
zW@%~7cy`t6{HDFCJ?p8AjTVmtN=}w}=nK5IC%?+m(UU`H4$VR9d_zmpKcxP7UD(RI
zch!)tUGlxR<%^dpF|RAX(Q%OxNK;{AD~uLo2&zT7`iBi1MJ;k!YkTNqPZssX?a#dN
zgXbvyeM^!vdh$O+b#rkWuJD)xwfV+XXgq3$M(fy+g(^^jEn|qiP-vjjwYNztJCBU-
zyV!YJhIiTN;Ofg+G(I78n0b|S%&}s*U$}UEwTR;iA%>MGH9vxR*Z~7a^9{P2(k<n$
z@@+O7X%y9#vT_g4sEU@ko>bGx(?{7<6xhktyL7#x>lHy-(Zy0f9V#!rGDPgtAc_`~
zxc1a~i*7DHk&&mP`@S&yg7$E2tweEN&t|^RVdopHq4EFt=fjT{1M-aej)yPeZK%Jj
zZFBJS0rtdpr5rxNR8);}vv@>8oRQ_$o>ba<B?p^}x{3-VrRL<Nxwb@J8!t;iY<jlE
zyOgfmbnTL0^2O(TCy!LW+315amVB%om6g*YX8i-nN;;n+Nf)Zlw|`?@{V-fCRpNO-
zYyI_$0cS*Huc=mKYE?!DoRDOUjP+#`UAMdrM!lFreDe*6(1e-dGdV&Q=0PvyW!(x_
zHggFd&VO|E?vIIF{>HVLUEDb7QgN$?A);QoT}7s6N*lI!s;x^jzAK(6W1B;Z)>>_5
zX+}#lyCxf<aNOyNYigRqnk$s|#f-{(<;~77s*U6Q;(x_-EpYf{^Vuc&t5rlnBKpU2
zhnrdvapohNO<p^rd&iAYMUq1Tz9y^q_Qw?EHs7w_8dW=tXd+ehFSZOPcF#fRd;={I
z@Xydwb&5qmB_!CwLb#sBj_|i@cd<)@Z%tfFOfoSQ+B$&#7!|W__eQ8BtMPtGe64=u
z`+~gM$a=GuYR%|JM`Euhsz>fJR%=J!*S;U#m-kIpb~L}X<_iA<Wb=+CszcBB)8*SL
zC0|j+s;FY^PKAN;7j^~PXIJDZzHEz~(5+;t^Q!MQZ3x}ceyZTmyU|2(#&D|7vr8d`
zmRc9G3#GknSesXEarV5SDO=B9Gj!?YGD;b@XygrS9qaw-XO5=D;z0znZ7$xvhsK=N
zHAFI9Ob;p?IhDIo`*e0q?JC5F!|AdCYj~)ik6&U3NUitJ$*9Gjh%LdIdvxD6D@wb!
z)0K2(T+rU*>Q3eQfXwH)3;T*ZEgBlgmojc0-RQ+WA#yW&fBge%8|&K}u-)=xF@an+
z=M8rmqG@gdEy7#u?d*?-NRI#f{^gt2-f=E9)^64uVwrC|ho0#Vv4mn<RA_~$(Iwn}
zGM{)TbF4h?I0u~Z>EBpP4qFKE$^%!Mo_Xj_m0X8ErYn*)(HnY_DMHhUbO^f<env-Q
zJI_fmIeE!z-%4_i9x~ae>kvY5TvGGyK>mYA@~=;;eGNBX6D4mOo4O)Foz5%?Z6Pea
zd^yGb?4iQgEY#tlVsA0oEt#8E1}5r7++Txy-Bv17eYUaeZD#E4ec4=SfjOv|Zy<xk
z%{-@g3Yp1^7VI8F?14g=Eq%?9S;DXK#ktL*JpOD-vX-+$(4zy94p)2Fqs1w&go*7t
z=#lpYYVw48DN$zUZ#v4q=u5*Cl;Ayit0`yiwP&~c*M#d;oXuHOHF~Y6;A6GSVOb|J
zg)_!?FqQW^R~)VTQs}X1?@`8`!@>L0RU6f-ocJhGZ%DldhtKR(zq}y&R@%{n2pPv1
z@x2D$POpvMGql{n33}2iZSEHrW1A2f6!ywYki1JR$WCqmyBaOh`AW*<wLzFtVk)_^
zls(Wo(ol4I{AC=mTyss=Cg+W`r@B(T$q&>pT_H{b?Ec28h()-*%wHWZ1ch<*_{0bN
z7hjR1GSloFgG-E(7C%N;$@dFoR7eV}`=KpbeppFFCb_y*Xz`hSTV%81(g|<5KV|Cq
zi17=3xKgqCMwr+-iS3EQT)CE=VO<ji->%+nYLb)b4Sg_&aONM?&2$p#cIE**1`EsT
zRR{Ka<h0U`sUB#bXj=G?f5GBdeYW$5({ZODwGB5vCggclv|`cWt$YXesy6vJwd*@T
z<}_RUnV@eW1F|puQw3_18VdzI@|XOIQ+eH4`5rClS<*y*zO=`+Kqt+hCg0`0l8A)m
z3#x*rkX{-_qnM>bggQ)}j!};=9amt558)!s<RdSf$gblx5RSWK8czri{dpF7m>sn~
z{ye&erS7w(-ioxnp~orzdwa61tG|Y_1TtTGV35EgVaLe-u5Wf{jJafxbvdau*rKCO
z{8`(s$2H&YIc%*w(Ztjzy!g<1GrH|(TtP?2=r5ivTQ^0|<{?nq`Ms84(D)h06>mot
z0^wZGu-Lf1VjMEqCUf=U@$$!UPaI|Mx<nNx%cp&(B%PQ4Xs;WRrjcIyx~X;>uH$I2
zIxF=0wVTL`iFaZ=q9g7yQm=Cz*XA;6dUD>*NJ6&Z`C0qbg|B&a50)^OyrEqUJ9bUJ
zBL;F?EvaVkIM+l(+^1eS8(+RTR_g7s-Z$0uXCEA09=3qXktE&J+4MC<$7a<NwixDl
z9{$mC0TGjx+M|cgy%6bk#y!OdKYy?+e;dzDtud7KfB%X2KjL;jwJ!Ne`+eV{fh!9(
z{21ptwbtS2Z2q998%jeei_XcgAq}nU?2H{%jp^H{j)C@6CJSWhyr=<ijt!*0I5{!|
z(u4`}P;d%OTN{BiW_WneL6Qs3YHfnB7zoMoqtZa)4h13o;Ov(--2>#~IL!ctrxzQ-
zksxFUJ-`=2`Z7T_i@gK1*j@p2Is{%)kThR!UnYWphmZyk5&XA+hyZF0flw4_53+j@
znFt}NAQcDJcZZO4(857TF9^v1Ei#1kfsjlHjRr7~HUsFh5w3{eImbVE1M`eDWdyL;
zFl|6jkTCIvlL<U^Gzx=;)NvrnM-$07kYxk*9Axs~A;xqTEr8+2_6>l5)^M_qFxZO9
z4q$MSe;Ozh99o0FKP@oTlKOim3?2|<P4xj(&tfzJX&>mu=Hy1<3@M;?GEq7ymkkVe
zwil4VWI7b!Kb0Vu9)=jOXmGNTi~(#gqWYQ9IqU}H!Fa<x>KH76lS}ku0Z9QK%#ZB<
zE5_y^hs&TDFg?BLFc+<;!5lmxG!_T+z@AO_afIQ237N(~q|+b#rjauhK5l{tK*0YW
z3gZ8D4J?Qda6p<k5U7%{B#3||AjsgIgGfR_7@(L~GKy3108h9d9*-rUCu=Mb9{;}z
zVyYht#=-?&W2)f6$2p+jfB_&GLLh;K$RvnJ1i!)g!h_9;aKU3B3>l9A1tQ=<#u*P5
z0a{B0=Zi=J2%tb4uHk+xC?KOv1oPoF$s{tUCt+~SAqGoCz%`5nOcY!QXe?(g9uPjc
z1{e$W<+MRyived7E_foDQ<I4RUjQedF@V6yeQ{u4JUCKVGCU6l;XzFT%z|r9!NB7P
z945duygx^1FarS&fUyX8Pdu2zVagP8aLv&)cqbhE0|m1PMjIv#u0i3*1>SD5An<@h
z&P<rUe;WY7$t5s=Vz>v!3Sd5^22<jis)5K5Q;2Y|!V%Fh*&Os?J(z(iOcO_$fI`8u
z{;UEcg+d`XeZLnV6Ufk1ffZp=2VgyzSvb4~dI9Uiw8GH`SSO|mM^}F91gsC!3yc@%
zH&_GKji~}tPC(&-3<0jN4$M)=Bp?%5FMuhWUZ!+ns)m^Y<c{FfaC=(e$a=CL9`mQb
zdI3unuKy-Er$^uh5MUkW4uu7ThT|m)>?AmeJkYX-fIKH}SU?!~ivoaAAs|}NLQJ|C
z2s3F*ffE6u=8T|27}zU<v0gx%CtC~%^Lrm3z|lz<6XJX<0xQ7|42Xy`=dZH^jQk6k
z^m&~3ez0%=1gPY60t@`xg-rTOpzRzuxaRVE>q(yoBs2*JZW8+&0gm_NL^u>UcKPiK
zW_(%z3OKpo-~K7v3g5^vKm+Fuyo3Q*e9AlixpRZ00sjgwj5NSZ4MYFWVc4l*C=KAO
zC++>;J3R1uaEGq$G;F6iuD>Y4DF6PJ{1-S~>{jrR=P=}NKL;@N1$xShlOT0qPr)DT
zy8qWD8X&&Ep4Zejz-KC2n7SAQHu{q<_c>x9v>y^Q8P+jDel@o+p?5#sem%|d!&nKA
zzrN)gT*Gbcy>{b?U#-vH8Br9lu)fkB^6bddQp>pIpI%&EU3J<{y|FHkbiTg9kH(HI
z5<U04u`@X9L>J+0lHQNPjq;{?(n1CMcZnOVa#2AqIMBKX*-|mFEMxQYJ93%vduh%_
zW3vOf>EFwYd;@`(2LxF#+~H^poMKpa01GBXGI<Z{FXuqw_z%C4M&J$+o8ikehOb?%
zHrB+TFc=gGO~9aWSR7szg;7SKlvNOu<3I$o8iYN5-o9*ah8q-w)xc|D)gUi6+mEG*
zMEd;c((n!N1d~7j=^jV}H<_l-@^klq+^DqeK!1O)pfXKCf&=It2o!|FAb_R*{QyUY
z2gk+(`U8Wt9DX3?6pRcTjelV%VD<lnp<&AaKhx%7K$2n>40w}&VOZ3xeNiY7wEi;=
zg@r8z{QTVmjh($73UGS%xY_HGv9LLqxgL=SQd9rJ@E`#D7ls1H{~s8Mgqk%DjYG|%
z1C1xl+80fPEhzj<qm2X-o&UfvnA!VcaInptITu5ky)W=#v-pR_;AicNg|FQGvmTZN
z8-|&CV96jz`Ui%?kY>?_!_TG-M*u<2zjMj6`G-ftUS#IJKxt>q1t`xRM*@M|KXVBv
z!YmmPa3BEucN~#CYY#F31Wtd(u>+_KZ+ZadN~Sr}!x!S5f8doUzP_;8;P@GPMhJL$
Y`<=d`2CzBDkW5065lTuXHl~RG1I9)}$N&HU

literal 0
HcmV?d00001

diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
index f90e2b4..281efc9 100644
--- a/examples/benchmarks/plot_arbor_reproducer.py
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -37,6 +37,8 @@
 
     label = f"nthreads: {NTHREADS}"
     ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
+    ax.set_xticks(NTASKS)
+    ax.set_xticklabels([f'{2**n}' for n in NTASKS])
 
 ax.legend()
 ax.set_xlabel('NTASKS')

From 34cf92d115aa81b7e0498db6151a78e387e0db73 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 10:52:00 +0200
Subject: [PATCH 20/30] removed file

---
 examples/benchmarks/PS_reproducer.pdf | Bin 10728 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 examples/benchmarks/PS_reproducer.pdf

diff --git a/examples/benchmarks/PS_reproducer.pdf b/examples/benchmarks/PS_reproducer.pdf
deleted file mode 100644
index 484ede028a9fefeeabfc235d8257dbefbb6b3fe2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10728
zcmb_?2{@GB7x2%POj22s?G=(Nvv2l2vJXk38e=fUSY}AtED@oy6(to)qEJdvsU(!p
zMpCILgjDtl-+f1l`2LUQd%o9m-8<)QXS?T|_dQq1*4R`Xt${-*<-dmVN)c!X1^K#d
zLuhM5NL#8Wodsb4gaRQQcKXpFq!E=(_4f6IbafGQraL^4G;M-OFng^%o64p`xXDST
zzDzcRoow4u*=%|M6T-tk5lGtrUz$Cg4Q&GZ7@LCi>A`FWY3>8|H2hr~{jSX+R|skE
zMRjK|Jt4y6bSE3PZFCwNB61f0iw=4^0R~K_FPjCSQIi-L0c_|@03c8PwxYW;sD{45
z00(#ko=D&nu$e7201TWY9f73KS-yb*G{6g(*gw30*)xq1@S;<kGi7)KS|OyVH(-V_
zo#yKfcxOpxda}JB^dv(8$}DyOo$7-KPQT@7<ts&8daHlK*VQtH2}S`?J&&2rJQ~h-
zib7=*r4bwb-ON<H`5(9TDeSna6_ANDdGG90;DJlu+5h;(quwoYgq95w9Ya;yuN=>P
zoFy<MRDW?0{PUFR;mg?6X3%RT{$N*AYj1Oy-py92{<{1+=*PmCMGEfZ(&}E@)f(~7
znc0^;Hz3Taty<U0;5x5Ix^DI3TYb97-%@Gqi#DvvDe{fdr-G?0(%0tKZRI6M?P5_`
zdZ|nJm=ia>tocNLV1MoU_qFfxeQQ5=Y>g=C-r-?jQFa^KL(zC^p(pHmW}Kd!tkGHa
z&SpD{uDRJrQG<2glly{GPJ(cx-T6h_7f^EYgXzEa>95FG8E<(BM`IYmoeydw8lVwD
zgR?od_UanNqEP}D+)hRvw^ew5Wc;hNZJXeFW&6uXFKv`guGKo><;rJO(EFie@F}9~
zkeh$d*rUOxx36|v^y)b)Eq$mHV;0));?kI2Fq)CI*o(Br#Z5H#dz{IV-FDTL&U-ZP
zoRCy*Fo`b8xs$tUT|K39_*`?yll)adDTWE&F<hEIR(#yFadd!Me$`j}XBE-n<l$Xf
z@g=+|t0zQVSN$x!THbP4TqiDVu(Z5J$tieIJkf8BZMDntl(1AK*$LkA==!s^wGO>`
zi*{)zy*Q%!rtS$&fJ~~1v6nh?VMk1}f867{Cz;9n{TGf@S6zJ)-NP_m;v-HxJf0%A
zq=a^9(}=P}veb!Nu4A8jAL%LQF1?~a-mSJR!mYoyqGq4?68Re|O`^~K=(Dxik5Rpd
zHnPfWFQ`qqRpO33fPcB6!GGQJkY`eY@-JGL6YQ4v!%4CJBR-;IuWDXwlqR&%TdH*w
z7QZSy6<_@LsPyRDMY}|z-d!C~9T)m_@Zqv=CjAk?>aL3BXK5O8?nKl6?K1zZ**tXD
zPQQyfQroyfA`#J4-HhvL+u^eCetaeFvT?DYZI-#T$l~q929c4C3E%rk>rMoHB<Z=3
zUj?@9avo-9r6Qe6iU&nbiheQAJ#Jk43q7XCZvXGDs<HL9PeI7z*E?UNFEc6RKDXfV
zdUe}-#@Tf=%kJpTu$Wtvu|gU;so^X>kQ;mInVF3A{V>y2$1GOg=uSW6DIp@9*XzFF
zmOG=$LqGM})10scb^PxPmXV?k4yefbTLh}`xm~=FOdwpBZsx@<IA4HpQCYD!$D>t~
zOulqj&M>Q|7VQxFX{+kH%|AaWZ@=ZYr~Leq4YaF{6{%KhT5q#<{~8#lGW<V!FY+%M
zYy0$#Uuqzu46~2ts%Bs!YzcoK<=-}ubHrg=KqjE3>?Fqs!LUt`>mS&3<N3dA1{n<-
znm_geA6K^c4r-zCu5;IyjgUfzV=_gD#(kpIC0^@v#q@h`bw7DPp}0-_@;N_yON#aR
z9fI4=5@obHl^&1bYC<$t3@q^<6uWkUC(%wZ;ehe6M=72kx9rvx^p$p-gOvH2H4<(n
zitz@*cTl`0!`AN?${W1SdDdmvSFUbe`hI6bLFUT_PjS2vttuAk$dsrqi8YB(F%Oo`
zF+32gIdsEiFXJjcsGv-PeZCeEtEccT>?coy)(W-RxM5(cJs*=xB>scjU6_456P9-u
zk|J$~axdsU9V=Hi-ra*;*b{QuFWXXNXxZ+t@$`YGB-`R@OG&R+S8l&lyb*CsAzAtO
z(>%Aq4wEHs<Z3dO3(kSmbO-dmWQxW8BUFmk(-Q^@yUXo6xidDteY7*ZCVPZ6LEzRB
zQ!6y&e#*_C791mg!S2$Ck_~FJ^4A@=wBt`zl^t>Z>X0pWo#4|p=5%Eh;;5-wWOLPR
zIi>dCZNH?rbtD+~;w(*t6nXs18$0Sll2i_~hT?pz<&?~qWb&15syKvPgfR=DR3x7K
zRd|WdQR0jMi)N*$kmGpn)96dA%L5Ub;`!rzid`bZx#7zg4`?0vN=q=(HiI833rfB@
ze?kvlzM%hra97$}8T($;g!h9)vLex6!b+y{Nv#vBtihJje!J{IQqtz(V@c=lsLH2T
zI^RPZ*=+peo?{^3a54QqY<|;il=U-HfgRgQZ>bIq_SY)LwMYj!t~+;^EcAt*L=JZ^
z&|2kvuWf1nTb=NPRAPCodbsK_a+CXyA~_SOu80pm((_cVh$;OtO3^O*uwvp=>(9~t
zU*r67tM@9*AsyKH&PQbkgc&M>#o`=Lwhef0VUMU)h)<?R5h_tG`nu66kN89$ab2mk
ztPNG8+1o1~<vK#Z;3J+bl|0Smx4?Mcf(<MFqih$wGY2McSTr9@u&9~ZtCMKK<UtD>
z4eLf~EWPuiIio*&b!qC`eJ#pLT?eI`#Z9&yEw$WeFM9-+w0~dMSHGf@-?hB!Jv`ny
zXC90BnB37I=Jq9XcXO?&>qh0u&-*<zOFHey68r?K3#anb&c4wI7HV3Rv1w?T-pz*7
zvd{4v0z~$PEV>GgcH!r~r@MZ|Vcu=CboHj>?UK{pY`ng+lYec@O4>1rjy3~<u66gk
zoTF2AnD7{U`Cj~Rm%x{nx7(^O^XI14X{mS=cC#rOOo;>Xven<ufBl&Ca=T&uNTI6I
zfZ59^Y=H6?uLqx=SARG%{x+W1;_xLe`TlnW%tno^H|;e|+}y1L@)@z~t%q$zpWUdq
zCAf6Z+r&tPmGI*8mWsMX+mCvS2e13VC!6(Vm4%RFbIW<_zKhz;4a0KIO>DV2cn^oC
z^Wi-aJ5vh?gbgTL6plB+)N}#joWA2hc?q*S4b{f-#}+9rbo&^(ae@AdOcMX4RR>gg
zY8Nmf&+`{SpX1fz&#YOd7VQlyLr%3s!5j#|LGgSL!eIX~8aCuaUU|VsJ0o>b>zB9a
zm*?bMBfK2lSDKh+edMcr%`*|1wBR%ag+h<27H4<J<DI=_W%*F?5|InT?_^gd$1b8q
zCHOVww=pvgNlXN#)I0I_5k?Mf+`RPVJ<G-o;+`5Ud^AS-eR2&m&Q+u+KJa3Wz0+FM
z8NvPRYZb{5%OQK9<`CvnCn-TWBerj-MJ<TDSEzdtAzogrV`NQ8I3XglXJ;SxiU5NN
z*Eb`wCS{#Ukd%OUqn+EA^pE?u+zMjLUR^EBGCXdeAtL{{Yt6Z($8GbkWSyqi`Q_^7
zbmpJh_i>Ah`W*a%-vZ{vFC2M>1a)k+4jIb}c9SEKUlqSA_{o~)seAObUg9~fVr#kg
z8dkAkS=d@ZbaFwP(#6x4!pdU}zcD{_N8E$*j3`iD$dYJw&pASZh^9<BR*y=g9lB$J
zUXb3!KBvRKiv05)Vn0iY-s5Pd9CKmiq0iVuDj92boeCCL>#ZhiQcl!qhu%{tF*RpT
zB|p^jd6<mQ^mxLnCVb<ayNDI(QJFa<PBIzuS@vAe%02no)mfUI?pAgA3Te&HY+BMr
zr2R^^ymGfrsbb64j-(gYMUcfxhudNZ{8sU=I(vpi7;BJ}G8yNSdjo}2-YoA}E_}>$
zpJc21#3=vx0q2!-a1efRnhyujgqe=r<Vcl2A22_C7r2#Bp@_l!s{SS2;{{Oz&kRDA
z8w$GF+$(h1;7?^&94=AEF5b6R^2>uC7~0JjPLOgZk6=Pf-jnPfL6wph2HIb^UCPRI
zL29lPu1##q(^uH7dATa-+BNJLd$U}Re4og~nl&9vDwoEEFZ!btxo^)8H`{$ae&+BR
z)$Ov|UTxU#x@=vGu0{^V`pqpK=l8c#@^oJH>B$CZexHNb`Nmm9%nWV8VoGdLwuLw@
z;V5xn^*t7Ftp4rXm>Y%~5@v$;A97t03@uhl50CZ?O@(}xRzl*&MQJgT#xm(#36I{b
z<M~giMZ9JXeC8WeVeq6G2$>{U1n@!&jfXSB6+(ZtYbULvqi;+Q7T38Gf{vXZ+rLiX
zoUmGl=uXt0n(vR@uXXJpJ8DVsiJGiVty$k$#GR*Qe?M(|%(iYCz5V(#tp$}*b*|)G
zcmJ%oK!?CJewOtqgLZF5gEl7bSt~?Gyv%1wd%t_=Q?Xpx^u)z4Lc=kTjk5jP%3i4X
zE5CC5o|HUQzmwiWPb^SEykmwUsqL})-GX5c9@`JJ3-`3O1$BgN_1(G5ta)j5g8Xus
z@Su|}6CWB!Z%z0|Y1Lnqyd>TCVMl6XP}LT<L@^du>}!?t9osdWn<O>gCSj}E&;5+5
zyRr3HS%hWZs9t0Jk8vJZ6^|dYS&5x*42UMowB;s8w1j!&1&wxDpHUc5;L)x3z^D+0
zeQ7VfDR-VZK@nvl;m==%$8?4txTf@mukRwSC+$}kfr%Gx=M4;X%x?2artG;<$w*;;
z^CGZR7hM#Q@em40&XPR6R8#D2Z)SVIxi592Mt*}^2Fu;vkWa*f)jX70`1rH^>rsMM
zW@%~7cy`t6{HDFCJ?p8AjTVmtN=}w}=nK5IC%?+m(UU`H4$VR9d_zmpKcxP7UD(RI
zch!)tUGlxR<%^dpF|RAX(Q%OxNK;{AD~uLo2&zT7`iBi1MJ;k!YkTNqPZssX?a#dN
zgXbvyeM^!vdh$O+b#rkWuJD)xwfV+XXgq3$M(fy+g(^^jEn|qiP-vjjwYNztJCBU-
zyV!YJhIiTN;Ofg+G(I78n0b|S%&}s*U$}UEwTR;iA%>MGH9vxR*Z~7a^9{P2(k<n$
z@@+O7X%y9#vT_g4sEU@ko>bGx(?{7<6xhktyL7#x>lHy-(Zy0f9V#!rGDPgtAc_`~
zxc1a~i*7DHk&&mP`@S&yg7$E2tweEN&t|^RVdopHq4EFt=fjT{1M-aej)yPeZK%Jj
zZFBJS0rtdpr5rxNR8);}vv@>8oRQ_$o>ba<B?p^}x{3-VrRL<Nxwb@J8!t;iY<jlE
zyOgfmbnTL0^2O(TCy!LW+315amVB%om6g*YX8i-nN;;n+Nf)Zlw|`?@{V-fCRpNO-
zYyI_$0cS*Huc=mKYE?!DoRDOUjP+#`UAMdrM!lFreDe*6(1e-dGdV&Q=0PvyW!(x_
zHggFd&VO|E?vIIF{>HVLUEDb7QgN$?A);QoT}7s6N*lI!s;x^jzAK(6W1B;Z)>>_5
zX+}#lyCxf<aNOyNYigRqnk$s|#f-{(<;~77s*U6Q;(x_-EpYf{^Vuc&t5rlnBKpU2
zhnrdvapohNO<p^rd&iAYMUq1Tz9y^q_Qw?EHs7w_8dW=tXd+ehFSZOPcF#fRd;={I
z@Xydwb&5qmB_!CwLb#sBj_|i@cd<)@Z%tfFOfoSQ+B$&#7!|W__eQ8BtMPtGe64=u
z`+~gM$a=GuYR%|JM`Euhsz>fJR%=J!*S;U#m-kIpb~L}X<_iA<Wb=+CszcBB)8*SL
zC0|j+s;FY^PKAN;7j^~PXIJDZzHEz~(5+;t^Q!MQZ3x}ceyZTmyU|2(#&D|7vr8d`
zmRc9G3#GknSesXEarV5SDO=B9Gj!?YGD;b@XygrS9qaw-XO5=D;z0znZ7$xvhsK=N
zHAFI9Ob;p?IhDIo`*e0q?JC5F!|AdCYj~)ik6&U3NUitJ$*9Gjh%LdIdvxD6D@wb!
z)0K2(T+rU*>Q3eQfXwH)3;T*ZEgBlgmojc0-RQ+WA#yW&fBge%8|&K}u-)=xF@an+
z=M8rmqG@gdEy7#u?d*?-NRI#f{^gt2-f=E9)^64uVwrC|ho0#Vv4mn<RA_~$(Iwn}
zGM{)TbF4h?I0u~Z>EBpP4qFKE$^%!Mo_Xj_m0X8ErYn*)(HnY_DMHhUbO^f<env-Q
zJI_fmIeE!z-%4_i9x~ae>kvY5TvGGyK>mYA@~=;;eGNBX6D4mOo4O)Foz5%?Z6Pea
zd^yGb?4iQgEY#tlVsA0oEt#8E1}5r7++Txy-Bv17eYUaeZD#E4ec4=SfjOv|Zy<xk
z%{-@g3Yp1^7VI8F?14g=Eq%?9S;DXK#ktL*JpOD-vX-+$(4zy94p)2Fqs1w&go*7t
z=#lpYYVw48DN$zUZ#v4q=u5*Cl;Ayit0`yiwP&~c*M#d;oXuHOHF~Y6;A6GSVOb|J
zg)_!?FqQW^R~)VTQs}X1?@`8`!@>L0RU6f-ocJhGZ%DldhtKR(zq}y&R@%{n2pPv1
z@x2D$POpvMGql{n33}2iZSEHrW1A2f6!ywYki1JR$WCqmyBaOh`AW*<wLzFtVk)_^
zls(Wo(ol4I{AC=mTyss=Cg+W`r@B(T$q&>pT_H{b?Ec28h()-*%wHWZ1ch<*_{0bN
z7hjR1GSloFgG-E(7C%N;$@dFoR7eV}`=KpbeppFFCb_y*Xz`hSTV%81(g|<5KV|Cq
zi17=3xKgqCMwr+-iS3EQT)CE=VO<ji->%+nYLb)b4Sg_&aONM?&2$p#cIE**1`EsT
zRR{Ka<h0U`sUB#bXj=G?f5GBdeYW$5({ZODwGB5vCggclv|`cWt$YXesy6vJwd*@T
z<}_RUnV@eW1F|puQw3_18VdzI@|XOIQ+eH4`5rClS<*y*zO=`+Kqt+hCg0`0l8A)m
z3#x*rkX{-_qnM>bggQ)}j!};=9amt558)!s<RdSf$gblx5RSWK8czri{dpF7m>sn~
z{ye&erS7w(-ioxnp~orzdwa61tG|Y_1TtTGV35EgVaLe-u5Wf{jJafxbvdau*rKCO
z{8`(s$2H&YIc%*w(Ztjzy!g<1GrH|(TtP?2=r5ivTQ^0|<{?nq`Ms84(D)h06>mot
z0^wZGu-Lf1VjMEqCUf=U@$$!UPaI|Mx<nNx%cp&(B%PQ4Xs;WRrjcIyx~X;>uH$I2
zIxF=0wVTL`iFaZ=q9g7yQm=Cz*XA;6dUD>*NJ6&Z`C0qbg|B&a50)^OyrEqUJ9bUJ
zBL;F?EvaVkIM+l(+^1eS8(+RTR_g7s-Z$0uXCEA09=3qXktE&J+4MC<$7a<NwixDl
z9{$mC0TGjx+M|cgy%6bk#y!OdKYy?+e;dzDtud7KfB%X2KjL;jwJ!Ne`+eV{fh!9(
z{21ptwbtS2Z2q998%jeei_XcgAq}nU?2H{%jp^H{j)C@6CJSWhyr=<ijt!*0I5{!|
z(u4`}P;d%OTN{BiW_WneL6Qs3YHfnB7zoMoqtZa)4h13o;Ov(--2>#~IL!ctrxzQ-
zksxFUJ-`=2`Z7T_i@gK1*j@p2Is{%)kThR!UnYWphmZyk5&XA+hyZF0flw4_53+j@
znFt}NAQcDJcZZO4(857TF9^v1Ei#1kfsjlHjRr7~HUsFh5w3{eImbVE1M`eDWdyL;
zFl|6jkTCIvlL<U^Gzx=;)NvrnM-$07kYxk*9Axs~A;xqTEr8+2_6>l5)^M_qFxZO9
z4q$MSe;Ozh99o0FKP@oTlKOim3?2|<P4xj(&tfzJX&>mu=Hy1<3@M;?GEq7ymkkVe
zwil4VWI7b!Kb0Vu9)=jOXmGNTi~(#gqWYQ9IqU}H!Fa<x>KH76lS}ku0Z9QK%#ZB<
zE5_y^hs&TDFg?BLFc+<;!5lmxG!_T+z@AO_afIQ237N(~q|+b#rjauhK5l{tK*0YW
z3gZ8D4J?Qda6p<k5U7%{B#3||AjsgIgGfR_7@(L~GKy3108h9d9*-rUCu=Mb9{;}z
zVyYht#=-?&W2)f6$2p+jfB_&GLLh;K$RvnJ1i!)g!h_9;aKU3B3>l9A1tQ=<#u*P5
z0a{B0=Zi=J2%tb4uHk+xC?KOv1oPoF$s{tUCt+~SAqGoCz%`5nOcY!QXe?(g9uPjc
z1{e$W<+MRyived7E_foDQ<I4RUjQedF@V6yeQ{u4JUCKVGCU6l;XzFT%z|r9!NB7P
z945duygx^1FarS&fUyX8Pdu2zVagP8aLv&)cqbhE0|m1PMjIv#u0i3*1>SD5An<@h
z&P<rUe;WY7$t5s=Vz>v!3Sd5^22<jis)5K5Q;2Y|!V%Fh*&Os?J(z(iOcO_$fI`8u
z{;UEcg+d`XeZLnV6Ufk1ffZp=2VgyzSvb4~dI9Uiw8GH`SSO|mM^}F91gsC!3yc@%
zH&_GKji~}tPC(&-3<0jN4$M)=Bp?%5FMuhWUZ!+ns)m^Y<c{FfaC=(e$a=CL9`mQb
zdI3unuKy-Er$^uh5MUkW4uu7ThT|m)>?AmeJkYX-fIKH}SU?!~ivoaAAs|}NLQJ|C
z2s3F*ffE6u=8T|27}zU<v0gx%CtC~%^Lrm3z|lz<6XJX<0xQ7|42Xy`=dZH^jQk6k
z^m&~3ez0%=1gPY60t@`xg-rTOpzRzuxaRVE>q(yoBs2*JZW8+&0gm_NL^u>UcKPiK
zW_(%z3OKpo-~K7v3g5^vKm+Fuyo3Q*e9AlixpRZ00sjgwj5NSZ4MYFWVc4l*C=KAO
zC++>;J3R1uaEGq$G;F6iuD>Y4DF6PJ{1-S~>{jrR=P=}NKL;@N1$xShlOT0qPr)DT
zy8qWD8X&&Ep4Zejz-KC2n7SAQHu{q<_c>x9v>y^Q8P+jDel@o+p?5#sem%|d!&nKA
zzrN)gT*Gbcy>{b?U#-vH8Br9lu)fkB^6bddQp>pIpI%&EU3J<{y|FHkbiTg9kH(HI
z5<U04u`@X9L>J+0lHQNPjq;{?(n1CMcZnOVa#2AqIMBKX*-|mFEMxQYJ93%vduh%_
zW3vOf>EFwYd;@`(2LxF#+~H^poMKpa01GBXGI<Z{FXuqw_z%C4M&J$+o8ikehOb?%
zHrB+TFc=gGO~9aWSR7szg;7SKlvNOu<3I$o8iYN5-o9*ah8q-w)xc|D)gUi6+mEG*
zMEd;c((n!N1d~7j=^jV}H<_l-@^klq+^DqeK!1O)pfXKCf&=It2o!|FAb_R*{QyUY
z2gk+(`U8Wt9DX3?6pRcTjelV%VD<lnp<&AaKhx%7K$2n>40w}&VOZ3xeNiY7wEi;=
zg@r8z{QTVmjh($73UGS%xY_HGv9LLqxgL=SQd9rJ@E`#D7ls1H{~s8Mgqk%DjYG|%
z1C1xl+80fPEhzj<qm2X-o&UfvnA!VcaInptITu5ky)W=#v-pR_;AicNg|FQGvmTZN
z8-|&CV96jz`Ui%?kY>?_!_TG-M*u<2zjMj6`G-ftUS#IJKxt>q1t`xRM*@M|KXVBv
z!YmmPa3BEucN~#CYY#F31Wtd(u>+_KZ+ZadN~Sr}!x!S5f8doUzP_;8;P@GPMhJL$
Y`<=d`2CzBDkW5065lTuXHl~RG1I9)}$N&HU


From f3bcc82ce681723354bfe8f0dc76d674cca7457d Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 10:53:28 +0200
Subject: [PATCH 21/30] fix

---
 examples/benchmarks/plot_arbor_reproducer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
index 281efc9..2aab4f6 100644
--- a/examples/benchmarks/plot_arbor_reproducer.py
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -38,7 +38,7 @@
     label = f"nthreads: {NTHREADS}"
     ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
     ax.set_xticks(NTASKS)
-    ax.set_xticklabels([f'{2**n}' for n in NTASKS])
+    ax.set_xticklabels([f'{n}' for n in NTASKS])
 
 ax.legend()
 ax.set_xlabel('NTASKS')

From 5d7fa0caa18af1d534678e9b3a6fb12eec1ee034 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 11:18:16 +0200
Subject: [PATCH 22/30] test without multithreading

---
 examples/benchmarks/arbor_reproducer.py      |  3 ++-
 examples/benchmarks/plot_arbor_reproducer.py |  2 +-
 examples/benchmarks/run_arbor_reproducer.py  | 10 +++++-----
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 9f90dd7..a902508 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -272,7 +272,8 @@ def get_loc_sets(self, p, morphology, labels, decor):
         sim = arbor.simulation(recipe, context, domains)
 
         # set up sampling on probes
-        schedule = arbor.regular_schedule(self.dt)
+        # schedule = arbor.regular_schedule(self.dt)
+        schedule = arbor.regular_schedule(1.)
         i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
 
         # need meta data locating each CV
diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
index 2aab4f6..b5d87cb 100644
--- a/examples/benchmarks/plot_arbor_reproducer.py
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -41,7 +41,7 @@
     ax.set_xticklabels([f'{n}' for n in NTASKS])
 
 ax.legend()
-ax.set_xlabel('NTASKS')
+ax.set_xlabel('# MPI processes"')
 ax.set_ylabel('time (ms)')
 
 fig.savefig('PS_reproducer.pdf')
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index 14e375f..86e54a8 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -22,10 +22,9 @@
     POPULATION_SIZE=32,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128]),
-    # NTASKS=ParameterRange([1, 2, 4, 8]),
-
-    NTHREADS=ParameterRange([1]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]),
+    
+    NTHREADS=ParameterRange([1, 2]),
 
     # simulation scripts:
     SIM_SCRIPT='arbor_reproducer.py'
@@ -72,7 +71,8 @@
 
             # walltime (360 seconds per 1 MPI threads and popscaling 1 and
             # neuron count 512*5)
-            wt = 360 * 1. / pset.NTASKS + 240
+            # wt = 360 * 1. / pset.NTASKS + 240
+            wt = 600
             wt = '%i:%.2i:%.2i' % (wt // 3600,
                                        (wt - wt // 3600 * 3600) // 60,
                                        (wt - wt // 60 * 60))

From 93ad9e34d5f1262e4c969efb57d3795dca2164ea Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 13:37:51 +0200
Subject: [PATCH 23/30] don't create arbor.context

---
 examples/benchmarks/arbor_reproducer.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index a902508..de546e7 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -317,9 +317,10 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         recipe = Recipe(cable_cell, weights=weights, times=times)
 
         # instantiate simulation
-        context = arbor.context(1, None)
-        domains = arbor.partition_load_balance(recipe, context)
-        sim = arbor.simulation(recipe, context, domains)
+        # context = arbor.context(1, None)
+        # domains = arbor.partition_load_balance(recipe, context)
+        # sim = arbor.simulation(recipe, context, domains)
+        sim = arbor.simulation(recipe)
 
         # set up sampling on probes
         schedule = arbor.regular_schedule(self.dt)

From 742551cb3eb8dd6f949bf8f57586ebee0ffa0233 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 16:09:53 +0200
Subject: [PATCH 24/30] test

---
 examples/benchmarks/run_arbor_reproducer.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index 86e54a8..ef772e3 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -23,8 +23,9 @@
 
     # MPI pool size
     NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]),
+    # NTASKS=ParameterRange([1, 2, 4, 8]),
     
-    NTHREADS=ParameterRange([1, 2]),
+    NTHREADS=ParameterRange([1, 2, 4, 8]),
 
     # simulation scripts:
     SIM_SCRIPT='arbor_reproducer.py'

From 2f6d2a5c9ce4481ee9575201d6dd69d89c46f251 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 23:22:38 +0200
Subject: [PATCH 25/30] cleanup

---
 examples/benchmarks/arbor_reproducer.py      | 91 ++++++--------------
 examples/benchmarks/plot_arbor_reproducer.py | 10 +--
 examples/benchmarks/run_arbor_reproducer.py  | 21 ++---
 3 files changed, 35 insertions(+), 87 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index de546e7..7de068f 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -1,15 +1,8 @@
 #!/usr/bin/env python
 # coding: utf-8
-
-# In[1]:
-
-
-# %matplotlib inline
-
-
-# In[2]:
-
-
+'''Record transmembrane currents from populations of neurons 
+in an embarrassengly trivial manner
+'''
 from mpi4py import MPI
 from time import time
 import os
@@ -19,9 +12,6 @@
 import scipy.stats
 from parameters import ParameterSet
 
-# In[3]:
-
-
 #######################################
 # Capture command line values
 #######################################
@@ -30,7 +20,6 @@
 # load parameter file
 pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
 
-
 ################# Initialization of MPI stuff ############################
 COMM = MPI.COMM_WORLD
 SIZE = COMM.Get_size()
@@ -40,10 +29,7 @@
 SEED = pset.GLOBALSEED
 np.random.seed(SEED)
 
-
-# In[4]:
-
-
+# some parameters
 tstop = 5000
 dt = 0.1
 cellParams = dict(
@@ -57,10 +43,7 @@
         )
 population_size = pset.POPULATION_SIZE * SIZE
 synapse_count = 500
-nthreads = pset.NTHREADS
-
-
-# In[5]:
+CPUs_per_task = pset.CPUS_PER_TASK
 
 
 def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
@@ -70,7 +53,7 @@ def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
     """
     https://lfpy.readthedocs.io/en/latest/classes.html#LFPy.inputgenerators.get_activation_times_from_distribution
     """
-    assert hasattr(distribution, 'rvs'),         'distribution={} must have the attribute "rvs"'.format(distribution)
+    assert hasattr(distribution, 'rvs'), 'distribution={} must have the attribute "rvs"'.format(distribution)
 
     times = []
     if 'size' in rvs_args.keys():
@@ -93,9 +76,6 @@ def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
     return times
 
 
-# In[6]:
-
-
 class BaseRecipe (arbor.recipe):
     def __init__(self, cell):
         super().__init__()
@@ -105,8 +85,6 @@ def __init__(self, cell):
         self.iprobe_id = (0, 0)
 
         self.the_props = arbor.neuron_cable_properties()
-        # self.the_cat = arbor.default_catalogue()
-        # self.the_props.register(self.the_cat)
 
     def num_cells(self):
         return 1
@@ -138,9 +116,6 @@ def probes(self, gid):
         ]
 
 
-# In[7]:
-
-
 class Recipe(BaseRecipe):
     def __init__(self, cell, times=[[1.]], weights=[1.]):
         super().__init__(cell)
@@ -161,31 +136,23 @@ def event_generators(self, gid):
         return events
 
 
-# In[8]:
-
-
 class DummyCell(object):
     def __init__(self, loc_sets):
         self.loc_sets = loc_sets
 
 
-# In[22]:
-
-
 class ArborPopulation(object):
     def __init__(self, cellParams,
                  dt=0.1, tstop=1000,
                  population_size=1280,
                  synapse_count=100,
-                 synapse_rate=20.,
-                 nthreads=2):
+                 synapse_rate=20.):
         self.cellParams=cellParams
         self.dt = dt
         self.tstop = tstop
         self.population_size = population_size
         self.synapse_count = synapse_count
         self.synapse_rate = synapse_rate
-        self.nthreads = nthreads
 
         self.cellindices = np.arange(self.population_size)
         self.rank_cellindices = self.cellindices[self.cellindices % SIZE == RANK]
@@ -207,10 +174,6 @@ def cellsim(self, cellindex):
         Returns
         -------
         None
-
-
-        See also
-        --------
         """
         tic = time()
 
@@ -226,7 +189,9 @@ def cellsim(self, cellindex):
                 )
                 # set passive mechanism all over
                 # passive mech w. leak reversal potential (mV)
-                .paint("(all)", arbor.density(f"pas/e={self.cellParams['e_pas']}", {"g": self.cellParams['g_pas']}))
+                .paint("(all)", 
+                       arbor.density(f"pas/e={self.cellParams['e_pas']}", 
+                                     {"g": self.cellParams['g_pas']}))
         )
 
         # number of CVs per branch
@@ -258,6 +223,11 @@ def cellsim(self, cellindex):
         # get transmembrane currents
         return self.get_I_m(loc_sets, cellindex, decor, morphology, labels)
 
+    def instantiate_sim(self, recipe):
+        context = arbor.context(threads=1, gpu_id=None, mpi=None)
+        domains = arbor.partition_load_balance(recipe, context)
+        return arbor.simulation(recipe, context, domains)
+
     def get_loc_sets(self, p, morphology, labels, decor):
         # create cell and set properties
         cable_cell = arbor.cable_cell(morphology, labels, decor)
@@ -266,13 +236,9 @@ def get_loc_sets(self, p, morphology, labels, decor):
         recipe = BaseRecipe(cable_cell)
 
         # instantiate simulation
-        context = arbor.context()
-        domains = arbor.partition_load_balance(recipe, context)
-        # sim = arbor.simulation(recipe, domains, context)
-        sim = arbor.simulation(recipe, context, domains)
+        sim = self.instantiate_sim(recipe)
 
         # set up sampling on probes
-        # schedule = arbor.regular_schedule(self.dt)
         schedule = arbor.regular_schedule(1.)
         i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
 
@@ -300,7 +266,6 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         syn_loc_sets = np.random.choice(loc_sets, size=self.synapse_count)
 
         # create synapses at each loc_set
-        # synapse = 'alphaisyn'   # workaround
         synapse = 'expsyn_curr'
         synapse_params = {'tau': 5.}
         for i, loc_set in enumerate(syn_loc_sets):
@@ -317,16 +282,13 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         recipe = Recipe(cable_cell, weights=weights, times=times)
 
         # instantiate simulation
-        # context = arbor.context(1, None)
-        # domains = arbor.partition_load_balance(recipe, context)
-        # sim = arbor.simulation(recipe, context, domains)
-        sim = arbor.simulation(recipe)
+        sim = self.instantiate_sim(recipe)
 
         # set up sampling on probes
-        schedule = arbor.regular_schedule(self.dt)
+        schedule = arbor.regular_schedule(1)
         i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
 
-        # run simulation of transmembrane currents
+        # run simulation of transmembrane currents with timing
         tic = time()
         self._bench_sim_run(sim)
         toc = time()
@@ -343,26 +305,21 @@ def _bench_sim_run(self, sim):
 
     def run(self):
         for cellindex in self.rank_cellindices:
-            self.cellsim(cellindex)
+            _ = self.cellsim(cellindex)
 
-
-# In[23]:
-
-
-# %%prun -s cumulative -q -l 20 -T prun
+# create population
 pop = ArborPopulation(
     cellParams=cellParams,
     dt=dt,
     tstop=tstop,
     population_size=population_size,
     synapse_count=synapse_count,
-    nthreads=nthreads
+    CPUs_per_task=CPUs_per_task
 )
 
 # run population simulation and collect the data
 pop.run()
 
-
 # compute mean time spent calling arbor.simulation.run() per MPI process
 if RANK == 0:
     tocc_run = np.array(0.)
@@ -372,10 +329,10 @@ def run(self):
 COMM.Reduce(pop.cumul_sim_time, tocc_run, op=MPI.SUM, root=0)
 if RANK == 0:
     tocc_run /= SIZE
-    with open(os.path.join('logs', f'MPI_SIZE_{SIZE}_NTHREADS_{nthreads}.txt'), 'w') as f:
+    with open(os.path.join('logs', f'NTASKS_{SIZE}_CPUS_PER_TASK_{CPUs_per_task}.txt'), 'w') as f:
         f.write(f'{float(tocc_run)}')
 
-    print(SIZE, nthreads, tocc_run)
+    print(SIZE, CPUs_per_task, tocc_run)
 
 # clean exit?
 COMM.Barrier()
diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
index b5d87cb..4ed4c78 100644
--- a/examples/benchmarks/plot_arbor_reproducer.py
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -17,25 +17,23 @@
         host = os.environ[h]
         break
 
-# ax.set_title(f"network size: {5 * BN.order}; host: {host}")
-
-for i, NTHREADS in enumerate(PS_reproducer['NTHREADS']):
+for i, CPUS_PER_TASK in enumerate(PS_reproducer['CPUS_PER_TASK']):
     times_run = []
     NTASKS = []
     for j, N in enumerate(PS_reproducer['NTASKS']):
         NTASKS.append(N)
         pset = ParameterSet(dict(NTASKS=N,
-                                 NTHREADS=NTHREADS,
+                                 CPUS_PER_TASK=CPUS_PER_TASK,
                                  GLOBALSEED=PS_reproducer['GLOBALSEED'],
                                  POPULATION_SIZE=PS_reproducer['POPULATION_SIZE'],
                                  ))
         js = json.dumps(pset, sort_keys=True).encode()
         md5 = hashlib.md5(js).hexdigest()
 
-        with open(os.path.join('logs', f'MPI_SIZE_{N}_NTHREADS_{NTHREADS}.txt'), 'r') as f:
+        with open(os.path.join('logs', f'NTASKS_{N}_CPUS_PER_TASK_{CPUS_PER_TASK}.txt'), 'r') as f:
             times_run.append(float(f.readline()))
 
-    label = f"nthreads: {NTHREADS}"
+    label = f"CPUs per task: {CPUS_PER_TASK}"
     ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
     ax.set_xticks(NTASKS)
     ax.set_xticklabels([f'{n}' for n in NTASKS])
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index ef772e3..3b850b8 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -1,11 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-'''Define ParameterSpace for benchmarking of scaling with different MPI pools
+'''Define ParameterSpace for weak scaling with different MPI pools
 '''
 import os
 import numpy as np
-import operator
-import pickle
 import hashlib
 import subprocess as sp
 import json
@@ -18,14 +16,14 @@
     # allow different seeds for different network iterations
     GLOBALSEED=1234,
 
-    # number of neurons per thread
+    # number of neurons per MPI thread
     POPULATION_SIZE=32,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]),
-    # NTASKS=ParameterRange([1, 2, 4, 8]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 10, 12, 16, 32, 64, 128, 256, 512]),
     
-    NTHREADS=ParameterRange([1, 2, 4, 8]),
+    # number of cores per MPI thread
+    CPUS_PER_TASK=ParameterRange([1, 2, 4, 8]),
 
     # simulation scripts:
     SIM_SCRIPT='arbor_reproducer.py'
@@ -44,8 +42,6 @@
 #SBATCH --ntasks {}
 #SBATCH --cpus-per-task={}
 ##################################################################
-# from here on we can run whatever command we want
-unset DISPLAY # DISPLAY somehow problematic with Slurm
 srun --mpi=pmi2 python -u {} {}
 """
 
@@ -54,7 +50,6 @@
     if not os.path.isdir(dir):
         os.mkdir(dir)
 
-
 env = os.environ
 
 if 'HOSTNAME' in env.keys():
@@ -70,9 +65,7 @@
             js = json.dumps(pset, sort_keys=True).encode()
             md5 = hashlib.md5(js).hexdigest()
 
-            # walltime (360 seconds per 1 MPI threads and popscaling 1 and
-            # neuron count 512*5)
-            # wt = 360 * 1. / pset.NTASKS + 240
+            # walltime
             wt = 600
             wt = '%i:%.2i:%.2i' % (wt // 3600,
                                        (wt - wt // 3600 * 3600) // 60,
@@ -91,7 +84,7 @@
                     md5,
                     md5,
                     pset.NTASKS,
-                    pset.NTHREADS,
+                    pset.CPUS_PER_TASK,
                     pset.SIM_SCRIPT,
                     md5
                 ))

From 2e4fd0ae792c77826e5295da0e3a004608ffe27d Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 23:27:37 +0200
Subject: [PATCH 26/30] fix

---
 examples/benchmarks/arbor_reproducer.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 7de068f..3a67795 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -314,7 +314,6 @@ def run(self):
     tstop=tstop,
     population_size=population_size,
     synapse_count=synapse_count,
-    CPUs_per_task=CPUs_per_task
 )
 
 # run population simulation and collect the data

From b8a4d8a179f36eb908309ea563be72158b2c012b Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Wed, 17 Aug 2022 23:35:26 +0200
Subject: [PATCH 27/30] lakd

---
 examples/benchmarks/plot_arbor_reproducer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
index 4ed4c78..11a5498 100644
--- a/examples/benchmarks/plot_arbor_reproducer.py
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -39,7 +39,7 @@
     ax.set_xticklabels([f'{n}' for n in NTASKS])
 
 ax.legend()
-ax.set_xlabel('# MPI processes"')
+ax.set_xlabel('# MPI tasks')
 ax.set_ylabel('time (ms)')
 
 fig.savefig('PS_reproducer.pdf')

From 3239ca03edece485c8b637a602025fb1cde9d565 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 18 Aug 2022 09:21:53 +0200
Subject: [PATCH 28/30] test arbor.simulation.reset()

---
 examples/benchmarks/arbor_reproducer.py     | 6 ++++++
 examples/benchmarks/run_arbor_reproducer.py | 4 ++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
index 3a67795..7b1d62b 100644
--- a/examples/benchmarks/arbor_reproducer.py
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -250,6 +250,9 @@ def get_loc_sets(self, p, morphology, labels, decor):
             '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta
         ])
 
+        # clear
+        sim.reset()
+
         return loc_sets
 
     def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
@@ -297,6 +300,9 @@ def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
         # extract I_m for each CV
         I_m_samples, _ = sim.samples(i_handle)[0]
 
+        # clear
+        sim.reset()
+
         # transmembrane currents in nA
         return I_m_samples[:, 1:]
 
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index 3b850b8..0dc22f3 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -7,7 +7,7 @@
 import hashlib
 import subprocess as sp
 import json
-from parameters import ParameterSpace, ParameterSet, ParameterRange
+from parameters import ParameterSpace, ParameterRange
 
 PSPACES = dict()
 
@@ -66,7 +66,7 @@
             md5 = hashlib.md5(js).hexdigest()
 
             # walltime
-            wt = 600
+            wt = 300  # s
             wt = '%i:%.2i:%.2i' % (wt // 3600,
                                        (wt - wt // 3600 * 3600) // 60,
                                        (wt - wt // 60 * 60))

From 8ef07a5456baf67a1e24b048a1dec137745bbf2d Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 18 Aug 2022 09:33:36 +0200
Subject: [PATCH 29/30] sanity test

---
 examples/benchmarks/run_arbor_reproducer.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index 0dc22f3..f2a4d17 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -17,7 +17,7 @@
     GLOBALSEED=1234,
 
     # number of neurons per MPI thread
-    POPULATION_SIZE=32,
+    POPULATION_SIZE=64,
 
     # MPI pool size
     NTASKS=ParameterRange([1, 2, 4, 8, 10, 12, 16, 32, 64, 128, 256, 512]),
@@ -26,7 +26,7 @@
     CPUS_PER_TASK=ParameterRange([1, 2, 4, 8]),
 
     # simulation scripts:
-    SIM_SCRIPT='arbor_reproducer.py'
+    SIM_SCRIPT='arbor_reproducer.py' 
 ))
 
 PS_reproducer.save('PS_reproducer.txt')

From 18a8dab200c59983e613eb8fc92bb935be08edc1 Mon Sep 17 00:00:00 2001
From: Espen Hagen <2492641+espenhgn@users.noreply.github.com>
Date: Thu, 25 Aug 2022 23:35:38 +0200
Subject: [PATCH 30/30] ntasks

---
 examples/benchmarks/run_arbor_reproducer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
index f2a4d17..34ac4ce 100644
--- a/examples/benchmarks/run_arbor_reproducer.py
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -20,7 +20,7 @@
     POPULATION_SIZE=64,
 
     # MPI pool size
-    NTASKS=ParameterRange([1, 2, 4, 8, 10, 12, 16, 32, 64, 128, 256, 512]),
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]),
     
     # number of cores per MPI thread
     CPUS_PER_TASK=ParameterRange([1, 2, 4, 8]),