{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Test postsynaptic trace\n", "=======================\n", "\n", "Pre- and postsynaptic traces are used to calculate STDP weight updates, but are computed differently: postsynaptic traces are stored and maintained in the NEST C++ `ArchivingNode` class. Following [nest-simulator#1034](https://github.com/nest/nest-simulator/issues/1034), this notebook (and corresponding test script in `testsuite/regressiontests/issue-1034.py`) was created to specifically test the postsynaptic trace value, by comparing the NEST-obtained samples to a Python-generated reference timeseries.\n", "\n", "Construct a network of the form:\n", "- pre_spike_gen connects via static_synapse to pre_parrot\n", "- pre_parrot connects via stdp_synapse to post_parrot\n", "- post_spike_gen connects via static_synapse to post_parrot\n", "\n", "The spike times of the spike generators are defined in\n", "`pre_spike_times` and `post_spike_times`. From the perspective of the\n", "STDP synapse, spikes arrive with the following delays (with respect to\n", "the values in these lists):\n", "\n", "- for the presynaptic neuron: one synaptic delay in the static synapse\n", "- for the postsynaptic neuron: one synaptic delay in the static synapse\n", "- for the synapse itself: one dendritic delay between the post_parrot\n", " node and the synapse itself (see the C++ variable `dendritic_delay`)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib.ticker as plticker\n", "import nest\n", "import numpy as np\n", "import os\n", "import scipy as sp\n", "import scipy.stats\n", "import unittest" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NEST simulation\n", "---------------\n", "\n", "Construct and run the NEST network." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def run_post_trace_test_nest_(pre_spike_times, post_spike_times,\n", " resolution, delay, sim_time, tau_minus,\n", " show_all_nest_trace_samples=False,\n", " debug=False):\n", "\n", " if debug:\n", " print(\"Pre spike times: [\"\n", " + \", \".join([str(t) for t in pre_spike_times]) + \"]\")\n", " print(\"Post spike times: [\"\n", " + \", \".join([str(t) for t in post_spike_times]) + \"]\")\n", "\n", " nest.set_verbosity(\"M_WARNING\")\n", "\n", " nest.ResetKernel()\n", " nest.resolution = resolution\n", "\n", " wr = nest.Create(\"weight_recorder\")\n", " nest.CopyModel(\"stdp_synapse\", \"stdp_synapse_rec\",\n", " {\"weight_recorder\": wr, \"weight\": 1.})\n", "\n", " # create spike_generators with these times\n", " pre_sg_ps = nest.Create(\"spike_generator\",\n", " params={\"spike_times\": pre_spike_times,\n", " \"precise_times\": True})\n", " post_sg_ps = nest.Create(\"spike_generator\",\n", " params={\"spike_times\": post_spike_times,\n", " \"precise_times\": True})\n", "\n", " # create parrot neurons and connect spike_generators\n", " pre_parrot_ps = nest.Create(\"parrot_neuron_ps\")\n", " post_parrot_ps = nest.Create(\"parrot_neuron_ps\",\n", " params={\"tau_minus\": tau_minus})\n", "\n", " nest.Connect(pre_sg_ps, pre_parrot_ps, syn_spec={\"delay\": delay})\n", " nest.Connect(post_sg_ps, post_parrot_ps,syn_spec={\"delay\": delay})\n", "\n", " # create spike recorder --- debugging only\n", " spikes = nest.Create(\"spike_recorder\")\n", " nest.Connect(pre_parrot_ps + post_parrot_ps, spikes)\n", "\n", " # connect both parrot neurons with a stdp synapse onto port 1\n", " # so spikes transmitted through the stdp connection are\n", " # not repeated postsynaptically.\n", " nest.Connect(\n", " pre_parrot_ps, post_parrot_ps,\n", " syn_spec={'synapse_model': 'stdp_synapse_rec',\n", " 'receptor_type': 1,\n", " 'delay': delay})\n", "\n", " if debug:\n", " print(\"[py] Total simulation time: \" + str(sim_time) + \" ms\")\n", "\n", " n_steps = int(np.ceil(sim_time / delay))\n", " trace_nest = []\n", " trace_nest_t = []\n", "\n", " t = nest.biological_time\n", " trace_nest_t.append(t)\n", "\n", " post_tr = post_parrot_ps.post_trace\n", " trace_nest.append(post_tr)\n", "\n", " for step in range(n_steps):\n", " if debug:\n", " print(\"\\n[py] simulating for \" + str(delay) + \" ms\")\n", " nest.Simulate(delay)\n", " t = nest.biological_time\n", " nearby_pre_spike = np.any(\n", " np.abs(t - np.array(pre_spike_times) - delay) < resolution/2.)\n", " if show_all_nest_trace_samples or nearby_pre_spike:\n", " trace_nest_t.append(t)\n", " post_tr = post_parrot_ps.post_trace\n", " trace_nest.append(post_tr)\n", " if debug:\n", " print(\"[py] Received NEST trace: \" +\n", " str(post_tr) + \" at time t = \" + str(t))\n", "\n", " return trace_nest_t, trace_nest" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python simulation\n", "-----------------\n", "\n", "Generate the Python reference timeseries." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def run_post_trace_test_python_reference_(pre_spike_times,\n", " post_spike_times, resolution,\n", " delay, dendritic_delay, sim_time,\n", " tau_minus, debug=False):\n", " \"\"\"\n", " compute Python known-good reference of postsynaptic trace\n", " \"\"\"\n", "\n", " n_timepoints = 1000 * int(np.ceil(sim_time))\n", " trace_python_ref = np.zeros(n_timepoints)\n", "\n", " n_spikes = len(post_spike_times)\n", " for sp_idx in range(n_spikes):\n", " t_sp = post_spike_times[sp_idx] + delay + dendritic_delay\n", " for i in range(n_timepoints):\n", " t = (i / float(n_timepoints - 1)) * sim_time\n", " if t > t_sp:\n", " trace_python_ref[i] += np.exp(-(t - t_sp) / tau_minus)\n", "\n", " n_spikes = len(pre_spike_times)\n", " for sp_idx in range(n_spikes):\n", " t_sp = pre_spike_times[sp_idx] + delay\n", " i = int(np.round(t_sp / sim_time\n", " * float(len(trace_python_ref) - 1)))\n", " if debug:\n", " print(\"* At t_sp = \" + str(t_sp)\n", " + \", post_trace should be \" + str(trace_python_ref[i]))\n", "\n", " return trace_python_ref" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Run the test\n", "------------\n", "\n", "First, define some pre/post spike patterns." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# spike test pattern 1: minimal reproducing example of the original bug\n", "pre_spike_times1 = np.array([2., 3., 10.])\n", "post_spike_times1 = np.array([1., 2., 3.])\n", "\n", "# spike test pattern 2: generate some random integer spike times\n", "t_sp_min = 1.\n", "t_sp_max = 50\n", "n_spikes = 10\n", "pre_spike_times2 = np.sort(\n", " np.unique(\n", " np.ceil(\n", " sp.stats.uniform.rvs(\n", " t_sp_min, t_sp_max - t_sp_min, n_spikes))))\n", "n_spikes = 50\n", "post_spike_times2 = np.sort(\n", " np.unique(\n", " np.ceil(\n", " sp.stats.uniform.rvs(\n", " t_sp_min, t_sp_max - t_sp_min, n_spikes))))\n", "tau_minus = 2. # [ms]\n", "\n", "# for each parameter set, run the test\n", "# spike test pattern 3 is a pre/post-reversed version of test pattern 2\n", "pre_spike_times = [pre_spike_times1,\n", " pre_spike_times2,\n", " post_spike_times2]\n", "post_spike_times = [post_spike_times1,\n", " post_spike_times2,\n", " pre_spike_times2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define a function that will validate equality between the Python-generated and the NEST-generated timeseries." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "trace_match_atol = 1E-3\n", "trace_match_rtol = 1E-3\n", "\n", "def nest_trace_matches_ref_trace(trace_nest_t, trace_nest,\n", " trace_python_ref, pre_spike_times,\n", " post_spike_times, resolution, delay,\n", " dendritic_delay, trace_match_atol,\n", " trace_match_rtol, sim_time,\n", " debug=False):\n", " \"\"\"\n", " Trace values are returned from NEST at regular intervals, but only\n", " updated at presynaptic spike times.\n", "\n", " To match the NEST samples with the continuous reference trace, step\n", " backwards in time from the sampled value, to find the last time at\n", " which the trace value was updated, namely the time of occurrence of\n", " the last presynaptic spike.\n", " \"\"\"\n", "\n", " n_timepoints = len(trace_nest_t)\n", " for i in range(n_timepoints)[1:]:\n", " t = trace_nest_t[i]\n", " if debug:\n", " print(\"* Finding ref for NEST timepoint t = \" + str(t)\n", " + \", NEST trace = \" + str(trace_nest[i]))\n", "\n", " traces_match = False\n", " for i_search, t_search in enumerate(\n", " reversed(np.array(pre_spike_times) + delay)):\n", " if t_search <= t:\n", " _trace_at_t_search = trace_python_ref[int(np.round(\n", " t_search / sim_time\n", " * float(len(trace_python_ref) - 1)))]\n", " traces_match = np.allclose(\n", " _trace_at_t_search,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " post_spike_occurred_at_t_search = np.any(\n", " (t_search - (np.array(post_spike_times)\n", " + delay\n", " + dendritic_delay))**2\n", " < resolution/2.)\n", "\n", " if debug:\n", " print(\"\\t* Testing \" + str(t_search) + \"...\")\n", " print(\"\\t traces_match = \" + str(traces_match))\n", " print(\"\\t post_spike_occurred_at_t_search = \"\n", " + str(post_spike_occurred_at_t_search))\n", "\n", " if (not traces_match) and post_spike_occurred_at_t_search:\n", " traces_match = np.allclose(\n", " _trace_at_t_search + 1,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " if debug:\n", " print(\"\\t traces_match = \" + str(traces_match)\n", " + \" (nest trace = \" + str(trace_nest[i])\n", " + \", ref trace = \"\n", " + str(_trace_at_t_search + 1)\n", " + \")\")\n", " if traces_match:\n", " _trace_at_t_search += 1.\n", "\n", " if (not traces_match) and post_spike_occurred_at_t_search:\n", " traces_match = np.allclose(\n", " _trace_at_t_search - 1,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " if debug:\n", " print(\"\\t traces_match = \" + str(traces_match)\n", " + \" (nest trace = \" + str(trace_nest[i])\n", " + \", ref trace = \"\n", " + str(_trace_at_t_search - 1)\n", " + \")\")\n", " if traces_match:\n", " _trace_at_t_search -= 1.\n", "\n", " break\n", "\n", " if (not traces_match) and i_search == len(pre_spike_times) - 1:\n", " if debug:\n", " print(\"\\tthe time before the first pre spike\")\n", " # the time before the first pre spike\n", " traces_match = trace_nest[i] == 0.\n", "\n", " if not traces_match:\n", " return False\n", "\n", " return True\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plotting function:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def plot_run(trace_nest_t, trace_nest, trace_python_ref,\n", " pre_spike_times, post_spike_times, resolution, delay,\n", " dendritic_delay, trace_match_atol, trace_match_rtol,\n", " sim_time, title_snip=\"\", debug=False):\n", "\n", " fig, ax = plt.subplots(nrows=3, dpi=120)\n", " ax1, ax2, ax3 = ax\n", "\n", " #\n", " # pre spikes\n", " #\n", "\n", " ax1.set_ylim([0., 1.])\n", " ax1.set_ylabel(\"Pre spikes\")\n", " n_spikes = len(pre_spike_times)\n", " for i in range(n_spikes):\n", " ax1.plot(2 * [pre_spike_times[i] + delay],\n", " ax1.get_ylim(),\n", " linewidth=2, color=\"blue\", alpha=.4)\n", "\n", " #\n", " # post spikes\n", " #\n", "\n", " ax2.set_ylim([0., 1.])\n", " ax2.set_ylabel(\"Post spikes\")\n", " n_spikes = len(post_spike_times)\n", " for i in range(n_spikes):\n", " ax2.plot(2 * [post_spike_times[i] + delay + dendritic_delay],\n", " [0, 1],\n", " linewidth=2, color=\"red\", alpha=.4)\n", "\n", " #\n", " # traces\n", " #\n", "\n", " ax3.set_ylabel(\"Synaptic trace\")\n", " ax3.set_ylim([0., np.amax(trace_python_ref)])\n", " ax3.plot(np.linspace(0., sim_time, len(trace_python_ref)),\n", " trace_python_ref,\n", " label=\"Expected\", color=\"cyan\", alpha=.6)\n", " ax3.scatter(trace_nest_t, trace_nest,\n", " marker=\".\", alpha=.5, color=\"orange\", label=\"NEST\")\n", " ax3.legend()\n", "\n", " #\n", " # Trace values are returned from NEST at regular intervals, but only\n", " # updated at presynaptic spike times.\n", " #\n", " # Step backwards in time from the sampled value, to find the last\n", " # time at which the trace value was updated, namely the time of\n", " # occurrence of the last presynaptic spike.\n", " #\n", "\n", " pre_spike_times = np.array(pre_spike_times)\n", " n_timepoints = len(trace_nest_t)\n", " for i in range(n_timepoints):\n", " t = trace_nest_t[i]\n", " if debug:\n", " print(\"* Finding ref for NEST timepoint t = \"\n", " + str(t) + \", trace = \" + str(trace_nest[i]))\n", " for t_search in reversed(pre_spike_times + delay):\n", " if t_search <= t:\n", " if debug:\n", " print(\"\\t* Testing \" + str(t_search) + \"...\")\n", " _idx = int(np.round(t_search / sim_time\n", " * float(len(trace_python_ref) - 1)))\n", " _trace_at_t_search = trace_python_ref[_idx]\n", " traces_match = np.allclose(_trace_at_t_search,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " if debug:\n", " print(\"\\t traces_match = \" + str(traces_match))\n", " if not traces_match:\n", " post_spike_occurred_at_t_search = np.any(\n", " (t_search - (np.array(post_spike_times)\n", " + delay + dendritic_delay))**2 < resolution/2.)\n", " if debug:\n", " print(\"\\t post_spike_occurred_at_t_search = \"\n", " + str(post_spike_occurred_at_t_search))\n", " if post_spike_occurred_at_t_search:\n", " traces_match = np.allclose(\n", " _trace_at_t_search + 1,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " if debug:\n", " print(\"\\t traces_match = \" + str(traces_match)\n", " + \" (nest trace = \" + str(trace_nest[i])\n", " + \", ref trace = \"\n", " + str(_trace_at_t_search+1) + \")\")\n", " \n", " if traces_match:\n", " _trace_at_t_search += 1.\n", "\n", " if not traces_match:\n", " traces_match = np.allclose(\n", " _trace_at_t_search - 1,\n", " trace_nest[i],\n", " atol=trace_match_atol,\n", " rtol=trace_match_rtol)\n", " \n", " if debug:\n", " print(\"\\t traces_match = \"\n", " + str(traces_match)\n", " + \" (nest trace = \"\n", " + str(trace_nest[i])\n", " + \", ref trace = \"\n", " + str(_trace_at_t_search-1) + \")\")\n", " \n", " if traces_match:\n", " _trace_at_t_search -= 1.\n", "\n", " ax3.scatter(t_search, _trace_at_t_search, 100, marker=\".\",\n", " color=\"#A7FF00FF\", facecolor=\"none\")\n", " ax3.plot([trace_nest_t[i], t_search],\n", " [trace_nest[i], _trace_at_t_search],\n", " linewidth=.5, color=\"#0000007F\")\n", " break\n", "\n", " for _ax in ax:\n", " _ax.xaxis.set_major_locator(\n", " plticker.MultipleLocator(base=10*delay))\n", " _ax.xaxis.set_minor_locator(\n", " plticker.MultipleLocator(base=delay))\n", " _ax.grid(which=\"major\", axis=\"both\")\n", " _ax.grid(which=\"minor\", axis=\"x\", linestyle=\":\", alpha=.4)\n", " _ax.set_xlim(0., sim_time)\n", "\n", " ax3.set_xlabel(\"Time [ms]\")\n", " fig.suptitle(\"\"\"Postsynaptic trace testbench. Spike times are\\n\"\"\"\n", " \"\"\"shown from the perspective of the STDP synapse \"\"\" + title_snip)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, run the test and make the plots while we go.\n", "\n", "The plots should be interpreted as follows. Pre- and postsynaptic spikes are shown in the top two subplots, at the time at which they arrive at the synapse (i.e. from the perspective of the synapse, taking dendritic and axonal delays into account).\n", "\n", "The bottom subplot shows the reference/known-good timeseries generated (numerically) in Python (**cyan colour**). The values returned from NEST are shown using **orange circles**. They are plotted as points rather than as a continuous line, because we can only retrieve the value at the resolution of the minimum synaptic delay (i.e. fetch trace value; simulate for a timestep `delay`; repeat). Moreover, the postsynaptic trace value is only updated in NEST during the processing of a presynaptic spike, so unless a presynaptic spike was processed in the last delay interval, the value will remain unchanged. To allow comparison between the Python- and NEST-generated values, we thus search for the previous time at which NEST would have updated the trace value, which is the time of arrival of the last presynaptic spike. This value is marked by an **open green circle**. If all is well, all green circles should always overlap an orange circle, and all **black lines** (which simply connect subsequent postsynaptic trace values returned by NEST) should be perfectly horizontal." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAAHiCAYAAABBfsy0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAASdAAAEnQB3mYfeAAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydeZgdVbW339VTRjJCmCGgTAFEEQREJAgIKIoTCl6UII7oJ14HRK9KuCqoKHjFC9cBDIOAIqCogGggyIwyCMg8hCmBJGRoyNh9zvr+WPukK9V1us+p3d3nVGe9z3Oe6t57165Vv9pVtWqPoqo4juM4juM4zmDT0mgDHMdxHMdxnPUDdzwdx3Ecx3GcIcEdT8dxHMdxHGdIcMfTcRzHcRzHGRLc8XQcx3Ecx3GGBHc8HcdxHMdxnCHBHU/HcRzHcRxnSHDH03Ecx3EcxxkS3PF0HMdxHMdxhgR3PB3HcRzHcZwhwR1Px3Ecx3EcZ0hwx9NxGoSIzBIRFZGpjbbFGXhEZK6IzG20HTGE8jmn0XbEIiJTw7nMSoU35T0oIjOCXTMabYvjDDTueA4DwgMq+SuJyCIRuUFE/mMI7ZgZjj99qI7ZzDRSDxGZIyI61Mcdahr5gl5fNB4KRGQHEfmFiDwhIitFZLmIPC0i14vIt0Rk40bbOJCIyPRQbmc22hbHGWraGm2AM6CcGrbtwA7Ae4ADROSNqvrFxpnlVOFrwPeAFxptiOM0ChF5G/BnYCRwO3AdsAKYCrweOBi4DXgp4jAvADsBy2JsHUKuAu4A5jfaEMcZaNzxHEao6szk/yJyIPBX4Asi8hNVndsIu5xsVHU+/mJxnJ9hTucMVb0gHSkirwOWxBxAVbuAR2LyGEpUdRnFcZIdpz5U1X8F/wFqlzIz7qEQf2Qq/IPA37GH20rgAawGbkRGHq8DLgXmAquBhcA9wI+B9pBmbsWO9C+Rz8bAD4FHgeXA0vD3LGDbkObQsN/5Vc5nBLAo/EaEsBlhnxnAAcAc4BWgE6tJ2Skjn+2x2sZ/hvNZDTwD/BzYIiP99HCMmcA+wN+Cdq8AfwH2SKWvRY9ZIWxqxvHeBPwGq6lZjTmo1wMf7KcsTK12XGBOyr65wDjgzPB3FzAzxG8GfAu4FXgRWAPMAy7J0jOP3cBewO8S+T+HOSGb1Vju5/RxrlMT6dqAE7AapE6sNu1e4HNAS0a+7wZmB9tXh/O+CTghp8bjgZ8GTVZh9+TnAalyXjXrktCgDfg68Hiw+Tng+0BHlWPsCJxPzz29ALgZ+EzGs2UOsCF2b1Q0+Tdw3AA8u6aEYyytc7+6tE1cs1mp8Fnp8hLCdwt5dgIHZ2g3K2i8GquJvQTYoUbbK8fM+k1PP9OqnPdY4Kxgw0rgPuA9ifJeKQurgCeBz/VhzyHANdgzdXVIfwYwISNtv++CGs5/BnAF8FSwvRN7zhzTz33egT2THg3HTl/Lo4EbsY+UVcDDwDfIeKf5r7E/r/Ec/kjYru2LJiKnYU7mIuyB+SpwGHAacIiIHKxWQ1Cpbbgz7H818DTmrLwWe5l/A3NYfow17e8PXIA9mHqMEBmNPVxeg9XC/jHYtjVwBPaifQpz4p4EPiQi/6n25Z/k/cBk4EequjoVd3jI61rg/4BpwDuAPUVkmqouSqR9H/Bp7EF1G/aC3xn4OPAuEdlDVbOawPcK2v0N+N+gw/uAt4rI21X15pCuTz36QkQ+AZwLlDDNH8de0Htgmv+2j92XYl0uZmDanpqIS9vQAdwATMKcw07s+gK8FTgZ0+cKrIxsB3wAeLeI7Kuq/8prt4gcB/wCe4Fcjb1At6NH/71V9dk+zhPsBb4Uu+Z/wF6+SR0QkXasrB2CvbAuwV5KBwBnY9fzIwm7Pok5eS+G/RaFc3gdcBxwDvVr/DdgAnBZ+P/9wP9g3WE+m0wcocslwH5Y2e/Eyv1JwfbjUsd4J3A59hF3HeZITMCcrZOwa5hkAnbvrsHu05FYOThfRMqaUUtZB8uAbmCsiGyq1gpQK3VpWyuhpehK7OP4rap6XyLu0BBXKVdPAFtgz4B3isgBqnpPP4f4fdgei33QzEnEza3BxHbsGToJK/cdmNN1hYi8HbvX9sLKwmrgSOBsEVmoqr9Jneu3sPK7GPgT9gHyOuDLwDtEZB9V7Qxpa30X9Me52AfC37EPmclYeb1IRHZQ1W9W2e8KYM9wXr8PtlbO4zzgY8Dz2PVZCuwNfBs4MLzTumuwzRkKGu35+i/+R5UaT+AgoBx+W4ewfUL6Z4FNEmnbsAepAl9PhP8ohB2Rkf9EEjVGWG3g2q/2VNp3hbizMuI6gA0S/385pO31lU7P1+/2ibAZIawbODCV/vQQd1IqfHOya3ffjjlO56bCp9NTK/G5VNwRIfzxWvUI8bPoXTs3DXt4LwZ2ztinV21slbznZJWJRPzccOy/AWMy4qckr0kifDfMCb02FV6z3Vht8xrspb15Kt3bgv5X1XielWs/o0p85RqcDbQmwluB89JlG7gbe1lPychrw5wa35Isa5jD8GSIe2uMLvTcD3cDkxLhY0I+Jda9zzfEnL01wP79la9Emf9lSr9p2P32UC3XqZ9r+LtwjCexe38vYHQ/+9Sr7VRqqPEEjgnaPER4ZibSTsRq0xYB01JxO2P3xT01nvP0cNyZ9ZTrxHn/MXXe+4XwxcA/SNRWAtuGc7o3ldcBYZ/bSNVuJo5/ViKs5ndBP+f+moywDqyVoSuj7FfK+P2k7sGUrVcCo1JxM0PcibHl1H8D92u4Af4bgIvY83KYGX7fDQ/z7hB+ZiLtL0LYJzPy2R57UT2VCKs8bN5egx2Vm3x6RlzF8TythnwmE5r/U+E7hDxuSIVXHjwXZ+S1TYj7XR163p/UIIRVXhTrOJeJ+MrDcf9a9Ajxs+jteJ4dwv4zskzMoTanaLcceV+N1Rq2J8JqthtrIlTgnVXirwplt5fjm5G2cu1nZMS1YE7CfKAtI34C9lH220TY3VhN18QB1Hi/Puz+VYwuiXJ3UEb6U0Pc4YmwL4Ww/6nxWmvQY1xG3E0hvt/r1M8xJmK1WWV6nmUl4F/Ad4CNB0DbqfTjeAJfDTbcnHX9gRND2s/2U66n1XDO04lzPLOct6dC3Nsy4m4MZSf58XBVSN/rQzHE3wssSPxf87sgZzl4X8j/o6nwShnv5fAm7Owiu2tAK/YMuGswbPZfvp83tQ8vTglbxZoabgbOU9WLE2l2D9sb0jur6mMi8jywjYhMUNWlWH+9E4Hfi8jvsBqyW1X1yTptuwnrM3WyiOyO9Sm6FbhPVUspO14Wkd8CHxWRN6vqbSHqk2H7f1WO8c+MsOfCdmIyUEQE+A/sAb9biG9NJFlT5Rg3q2o5I3wO1qz+Buxc87J32F4bkUetrMKc7ExCk+ynsabyDek9GHFDegZH1WP3PmG7v4jsmRE/BbsW22OOYF62xz5iHge+YZe8Fyux0c4Vfo29YP8tIr/BruWtqrowpw3dWI1Smjlh+4ZEWIwutZb9POXrcQ3NrVXyn4D1dc6Fqi4B3h/m0jwEK297Yk2+rwM+IyKHquo/UrvWo21/nIV1jbkC62u4KiNN5frsVmUapO3DdiesxnSwWFrl+TsP+9DOumdewMrOJvTMorEP5rAdKSJHZuzTAWwkIpNV9WUG6F0gIlthTv6BwFbAqFSSzavseldGXqOx5/cibBBt1n6rWfcedxqMO57DCFXNvOtSjA/ban2p5mMPg/HYA+4uEdkP+C+sX9dHAETkUeBUVb20Rts6RWRvrBbm3dgLBmCRiJwDfEdDv9LAOcBHgU8Bt4nICKxP1AJ6+kilWZpx3O7wMGpNRZ0JfCGc71+wh/HKEDcD67uXRbUpXV4M2/FV4mtlQtgOxRRLCzRUC6QRkc9jfeWWYP3JnsUG5Sj2gt4N6yNYoR67J4ftV/pJN7aGvGo5znb0fJT1eRxVPVNEFmF91j6PlREVkZuAr6hqloPXF4vSH1aBrPKSW5fwkZim0qctWfbzlK+svKvlnxu1WTd+Fn6IyBbYc+BdWEvN61O71KNtf7w1bP9UxemEnuvziX7yii23/VFttHs3gPbuF782DusfWmEy5gP0dW+Anc/LA/EuEJFtMQdyIlYxcn04nxJW63ws6z5XkryYETYRGyuwUQ3n4TQJ7niuf1QeSptgfaHSbJpKh6reDhwenL83YiPP/x9wSeiw/rdaDqyqzwPHh9rGaVi/tc9iIxVbgG8m0t4pIvcAHxSRL2CDnyYD31fVarWRNSEiUzCn4kHgzar6Sir+6D52rzaR9SZhGzsFSuUlvzmDP/1LNaezDftAeBHYXVMDPkRkn4zd6rG7otH4KjVpA0XlOFep6vtq3UlVLwQuFJEJwJuB92IDF/4iIjup6oI+M1iXDUWkNcNByiovQ6FL8jo9MEjHGBBU9XkROQr7+NktUfNWoR5t++M92Cj/80SkXVV/kZGmkt9uqlq1paBALMO6DU2qdYcBeBd8EXuOH6eqs5IR4bl7bB/HznpeVa7Jvaq6e0a804T4ykXrH/eG7fR0hIi8Fhuh+XRWDYqqrlbV21T1W5jjBjawpkLlBdBnDYga/1bVs7HJocEe/GnOxUbQfhRrZles5iOWbbGyf32G07lFiK/GW0Qk676ZHrb3JsJq0iPFHWF7WB37ZFECEJE8tVEbYjVjt2U4nWPp6a6RpB67K2n3y2Fbmr40foQwujWMbq8LVV2qqteo6iewvoCTWNfmWjRuw5zXNNPDNlleBlKXagxU+RoqVlO920s92vbHc1it56PAz0Qka0T8UJXboeIOYKKI7FzvjjW8C6rx2rC9IiNu/xx2vIpN7bWziNTsQDuNxR3P9Y/zw/YbIrJRJTC8PH+IlYnzEuH7iUhWk1Wl5m9FIqxSG7FVOrGI7CLZ6yFn5VPhEuyL9iTsofTXHH1Ls5gbtm9JOg3BqfoFfbcEbIc1w65FRI4I9j2BNR9VqKpHH5yLNYt9U0SmpSODY1wLeY5dYQF2Pd4YNKkcux1rft8wY5967P4p1rfsLBHZPiNtR2jSq4Wq56k2fcrZWC3+T0Qk3ZcMEdk0aa+IHBpqfNNMCduaynuK00MNUeUYk7CpZwB+lUg3kLpU4wJsuqXPiMhb05F1lK+qiMiOIrJjjWnHiMg3pfqSmF/AmnofStV2VqhV234JH1n7YzXBPxWRL6WS/Ar7kDlFRN6UcS4tUvvyuDH350BxVtj+QkQ2S0eGa7N34v963gXVmBu201PHOgSbMiwPZ2L9Uc8PrRTrICITw7gCp0nwpvb1DFW9TUR+gDlzD4ZO4suxGpBdsOlJzkjs8iXg7SIyBxs1+So2dchhWBPYzxNpb8RGhZ4uIruEeFT1O9jUTmeKyG1YTdQCrHb1iLBP8pgVW1eIyAX0fFH/LPb8Q74vishlwFHAfSJyPdYf7GBswM199O5PVuE64Ecichg26rYyj+cq4PjUwKO+9Khm20MicgI2gOpeEfkDNjhmMjbo4hVsGpT+mI3N33eliFyD9V99RlUv6m9HVS2LyE+weTwfCDZ0hONOCud1QGqfmu1W1UdE5GPYR9C/ReQ64DGs/9lWWI3SQmyi7v64HXvhfSE4HZU+uGeHvm7fxvqjfhqbB/MGrH/jFOwjYl+sz1plMMhlwCoRuQV7SUqwZ09s0EayKbEWjedjfdYeFJGrwzl+AHOGz1HVvyc0HEhdMlHVRSLyYWzWixtF5FpsgNk4bCDPltgAlRgeDtta+py3A/+NOXN3YffeEqyc7Qvsij2fPp2xb83a1oqqLhSRA7B+3z8UkZGq+t0Q97KIfICwnKWIzMZq28rY9dkHK+8jazjUo1g5PEpE1mB9qBW4SFWfqdfuPKjqbBE5GZty7vFQhp/GHP2tMSf8Fqw5Hep7F1TjHGxe2ctF5ApMg13CMX4LfCjHeZwvIm/EKgSeFJG/YHpOwsryW7GPhqwy5DSCwRou77+h+0H2PJ797HMU9lB5BXOa/o29gEem0r0du2kfwmofl2MPzZ+QmucupD8Ge3msTNqFjSo8k3VXCpqLvQDf3Iedu4V85pExJU5IM4O+53JUEivKhLDR2LRTT4Tzfw6bEH4yGdPkkL1yUWfQ73pgzyrHztQjxM0iNZ1SIm4frDlqAT2rBl0HfKDG69uKLQjwFFaLto4GQfu5fezfhvXHeijY/iJwEfZCGhC7MadiFrZi1GpsDsIHsQ+MXlPC9GHroZgD+mpFY9adokqwgRCzwzHWYC+8W7AVXrZMpP005lg8hTm0i7Em25NITRtUq8bYR83/0rOa08P0vXJRzbrQx5RO9D3V1M7AhcGmNZjDfhOpadbS55SKyywH1PE8wlpYDsWeDXeG8tKF3Vf3YwsxZJWzurSl/pWLxmGzbijw7Yy8fkrPykCd2Mf0RYTVg2o89z1DmVxGz1RS0/u6dvRx3/ZTFjLPM8S9BXP65oWysBB7Zp1JYkU26nwX9HHeb8ZmVVkSrvMtWFer6WRMMdXXeaXSHU7PJPhrsGfWXdiUXDvWap//Bv8n4YI5TlMiIjOwh913tPqKFkNhx3Sspu9UVZ3ZKDscxwERmQugqlMba4njOPXifTydpiX0tfsi1ndwQJrZHcdxHMdpHN7H02k6ROQtWP+i6Viz40/VpmJyHMdxHKfAuOPpNCMHYZMBL8ZGmZ/UWHMcx3EcxxkIvI+n4ziO4ziOMyR4H0/HcRzHcRxnSHDH03Ecx3EcxxkSmtLxFJE5IrJe9QEQkXYROVVEHheR1SKiIpK1jOSwQURmhfOc2mhbnIFFRKaHazuz0bbEICJvF5HbRGRJOJ/fR+Y3M+QzfYBMdJyGIyIfC+W614pOfewzIO95EZlbmV7LGTzEuE9Ebu4/dd80peO5nvIl4FvYJL4/BE7FJiUuLP6SHb6IyNRwbWc12pbBInwQ/QFb/eRX2D15WT/7zAi6zBhs+/IiIkeKyHUiskBEukTkZRF5SEQuFpFjQ5rK9a3nNz3sOycV3h0c90dE5LcicpwklmJN2TYjI9/VIvJ0+FDttRyr01jCtfwO8EdVvavR9gxnqtwfyV/dqzOJyLEicpeIvCoiy8L9e3g6ndqAoFOwpaY/EHMePqq9eTgcW3nlYFVd02hjHCeSu7DVqhY12pAIDsKWP/ySql7SaGMGAhH5OfAJbDWqP2NLJI4BtgXehU1hdgG2JvmpGVmcErZZcXNT/19Az7Kj4zAH/iBsmdHTROR4Vb2miqn/Aiq1y+ODXccCHxSRt6nqHdXP0hliPo8tU/q9RhuyHvEHbHWpNP+sJxMR+SFW6fU8NoNMB7aq4R9F5P+p6k+T6VX1DyLyMPBdEblCc45Od8ezedgMeNmdTmc4oKorKHiNPXZPgrVCFB4R2RdzOp8H9knPjSsi7ZiDh6ouxZaHTedxSojvFZfBLFWdk9p/JPai+2/gKhE5WLPXVL8veQwREazW+VhsbfEDaji+M8iISCu2zOzjqnpbo+1Zj/i9qs6KyUBE3ozdi09iSz4vCeFnAHcDPxSRP6nq3NSuF2AfGQdiS0fXzZA2tYvIu0VktojMD80n80TkJhE5oUr6NhH5eqLf43Mi8n0R6aiS/sDQhLRYRFaJyGMi8j0RGZ9Kd2molt4uFX5hCJ+dCt8gNEn9PRG2tklNRA4I1dOviEiniPxZRHaqUZNZYv1ctgG2TlSZzw3xa5s0RWR7EflNaCIrS6IJW0S2C/a/ICJrgrYXps8xpF3bBC4iR4vI3SKyIuxzpoiMCOneFs6rMzSVXSQik2s8r7n01I7cmGwOqJL+UyLyQLhuL4nIz9PXLZF2CxH5qYg8FcrFyyJytYjsWYttIY+krjuKyO9DuVkuIreIyNv72PdoEbkxaLJKRB4WkW9UdEul1aDhJiLyy3B9ShKaYkVkYxH5oYg8Go69NPw9S0S2TeSzts+kiOwjIn8TaxZ5RUT+IiJ7VLG1TUROEJE7wnVcISL3isjnRCTz/heRN4Vy9kLQd76IXC8iHwzxM7GaMoBjZd2mnsp59erjKdbUukZENqxy3JPDPp9NhUdf70ReHxSRvwftVoYy97XktavYTk+tXrL8Tu8j7zmYcwTwq5QuUzPSf0CsiWtFKHuXicjmVfKeJCKnh7K2Mtg/u69ymsG+YXtF1oIMqtqlqn+tI7+6UdVVqvpdrGm2A/ifGvdT4Jzwb039CKWG9024L0pZ1yfEfzlcvy8lwuaG32gROUNEng35PyEiXxURychnhohcEcrwynAv3ioix1Q5bqW7wggR+Y5YV4PVIvKkiJwiGe9AEdlPRP4oIs+HtC+G8zslI+3oUO7vE3vuvCoit4vI0bVom+BgYEvgN9USiMhRYu+YlWLvrotEZLNq6cM+h4jINSKyKHHeZ4jIhFqMEpHxIvIVEbkh6LFGRBaG58beqbQTwz34ZNa1C2n+FK7HG2s5fkGoNMt/t+J0AgRH83+BEcBxGftVuhsdn/vIQ7UoPPBJQIH5wM+B04BfYk1y/0ilnRPS/jakPx/4MfBYCP9VRv6fAsrAKyH994A7Qvp/AxMSaT8ewj+dyuO5EL4SGJkIPzyEn5IImxHCfgd0AVcDZ2DNVwosADasQZf3YDULS8NvZvh9IcRPDfndDCwB7gTOAv4P2D2k2RNYFs7/90HbK4FSCN8jdcyZIc8rgBXAJcCPgAdC+CzgvcDqkM8PgdtC3LU1Xu8vJK7jrMR5zUykmZW4zsuAi4Md94TwGzLy3R1rvi0D1wbbZgXtVgPvqNG+iq43BV1vxmpSZoXrXwI+lLHfeWG/58LfPwJuDWE3Am2p9ArcjzU5Pgicjb1sDwNGA0+ENNeHc/kRVqaWAIcn8ple0T+c55/Ddf4ttqToSmC/1LHbgevCfo+EMvNjrBlTgYsyzu8TIb/VwOX03Kf3AXMStvw45HFf8toCr0/Zm7zeXwth/6/KNXkoHHfyQF/vkNdp4fgLgXOx+/XBEDYHaE+UjZlkl9+pfeQ/A7v/NGyTukxI3Xu/BVaF7RnA30P4w8CIVL5bY46+hnRnYc/QeUGXT9R4/seHPK6JeI4rwQ/sI01Ft+l9pNkAe/YosHPGc3VWxj57hbhXa7CzpvcN8NGQ7rtV8nkkXKcNE2FzgReAW4CnsOV8/zeErfOeSOyzEqtFmoU9Z36O1Twr8O0+NPxDuM4/wZ4NlefFHwnzcIf0h2LPrCVYjdRp2P1+E/BSKu8J9Dxj78aeSf+byPs7dZSHH4Z9DqkS/58hfknQ6fvYM2Mu4TmUsc+3wj4vh3M5A/gLPe/ycan0c4G5qbC9gTVYjdzPMH/gEqw7WxdwaCr9+SH/gzPs2QJ7Jv4z730zUL/E/fFj7B17MvARYIsceVXK36YZcfuEuJv72HdhsgzWdewhFOxu7EUxJSNuw9T/lZvubmBSInxMuDlKwCaJ8K1D3p3Ajqm8zgl5/TwRtm0IuzwRtgM9DoACBybizgph+yXCKgWgO5k2xJ0e4k6qQ59eN08InxryUuC0jHjBXlYK/Ecq7kP0OB0tifCZIXwZsFMifES4sUvYTb9/Iq4F+GvY7/U1nlPlONOrxM8K8c8CWyXC2+h5Eb8pFf4E9iLYP5XXZtiDfz6pF3eVYyd1PSMVtwf2cFpC4iGXuOZXAqOqnOuJqfDKMS6kt1P6rhB3VoZ9HcAGif+nJ/L6XCrtESH88SrX+WygNRHeSo8DfUQifFo478UknIFE/BaJvyv6zaqib8XemYmwzUPZ6vUAxz6eFKuNG4zrXXmQPsu6z4427CWuwNfrKb9VjlMpIzP6uSc6gV1TcZeEuA+mwudgDuZRqfAJ2Et8JbBxDbZtjjnsin0ofxjYjjpeHpUy2E+aObXohn3sKXBchn6zUmkFc0IUmF2DnTW9b7Bn3qJQjtqrlOFfp8LnhvBrSDwHgCn0VCCk83pNhh0dwGzsntu8ioaPARMT4SOB20PcRxLhV4Sw3fo63/D/LDLeTyHv60JZq/UZX6ncmZwRNzVcg8UkPtiwd0nFXk3tc0AIv41EZVGqbJyVCp9Lb8dzfPq8Q/gWmCP/cCp8j5D37zL2mRniav3Am866H539/uq4/yoapH/d2IfGyBrzGRP2e6VK/IYh/qUq8VeF+Gm12r7O/nl2ynUgexAsT95EfaSt3HQHZcSdGuKStUH/RXXHbCL2kF9J4gWF1SAsomf1phNCHnuHi3haIu392JdSR0YBuDjjmNtUK8R9nHOvmyeETw15vUjGCxZrPlPgtir5Vh7ub02EVW6krC/tytfmhRlxx4a4Y2s8p8pxpleJnxXiP54RdxwpJ4seB+uMKvmdGOL7rQVL6LqUhIOXYduxibB7sZfEhIz0raE83ZUKV6q/ACuOZ69ym5F2OhnOZcY9s3/4v4WeF2pbRvoJ2Avmt4mws0Me/1mHfrP6sXdmKrzyYbdzKvynIfzdg3S9fxHSfjIjbnvMIX6qnvJb5TgzqM3x7FWrRM9L94eJsN1IfSSn9qlodEKN9h1AT81W5deJORzHkPhAqbJ/L2ehj7LYp25Yk906DlBCv2RN+lnYvadYLeneNZxnPe+bM0Le70+FX0rq2RnC54bw12bkVXGOd6nxerwvpP9oFQ0/krFP5d66MRFWceS27+d4k7H32z+qxFfK2w9qtH8esKZKXOW9fGpG3LbhntNUeMWh6fXhG+LvBRZkXI+5tdgb0v8kHGOrVPg/sOd78sO0FWvd6gTG1pj/zNT91e+vDtv3Bz6HPbNGY4O6jqTnnr6kxnw2C+mfrxLfHuJXV4k/N8QfWqvtyd9QDi76NdZU8G8R+Q3WBHCrqi7sY5+sEVrPhe3ERNjuYXtDOrGqLhGRe4G3Ajti1fuVtB8DXo8V5rcB81X1DhG5G+s4i4hsBOwCXK/ZA39qtTGWf6nq6ozwqueeCH8L8AasFjFJlu2VgRR3Z8S9ELZb9GFnHmrVcJ+w3Vqy54es9GfdCauNqIV7VPWVjPA5mKP9BuACERmNPZQXAV+o0hVodTh2mrmquiAj/CZM05NFZPdg863YwIpSFXtvVtVyFXv3D/behD2YJmOO6jeq2LsyZW+l79O1VY49EMzC+oUdC5wEEPqrHYU13SSv20Be776eEY+JyKD1d2wAACAASURBVPPANiIyQW1gzWBTb5kfX0WDjcK2pj7lqnqjiGyPfbBWysu+wCHhd6yIHF7lWTPQVAqlZsTtFn5gzsB84CLge6r6UA151/O+ORcbZPEpzIFDrB/ye7GasazBT8tU9YmM8Mxnv4hsBXwVe69sBYxK7ZfZtzfYneZmzHl8QyLs15gTe2c43xux80335d0Tc6aqzbHbHrY1lSfsGbOkSlzlnut1Dqr6lIg8h7VWJtkHu95HisiRGXl2ABuJyGRVfbkvw8QG050Y8pwS9k2yOdYCUuEcrMn9Y1hXBYB3YO+7c1X11b6OV0FtUNzMWtLWi6rexLp6rgAuF5E7MN/maBH5vqr+KzODHIesEr44bDP76/fHkDmeqnqmiCzCahY/j/VPUBG5CfiKqvZ6EFd5AXSHbWsirDIIZX6Vw1fCkx2TZ2MF7EAR+Rf2FXltIu4kscEtb8MekOsMOErQy0ZV7Q4v+tbeyXPzYpXwPOdeYVlGWHcNce0ZcTHUep0rA5uyHkhJMucIrMJLVcIrelf0nYiVg43oGTRVK5nXTlU7Q0f3U4F3Yy9+gEUicg5WK9aV096KVtv1Y29Sq0oZeSEr4QBxFVZ7cIyIfC042Idj9v5YVbsTaQfyetdyn2wV0g2F41lvmT84/KpRc5kPHy43h19lxPjBWG3dQcBnsD5kg01lgEmWM3iBqs7Im3E975vgBP0FOEREXqOqT2I1ryOw/oFZVCsjva6h2CDBu7BnyM1Yrf8yrMZvKvYR1mtgYqDX/a6qJRF5GXOmKmFXis29+CXsvfapcOy7ga9pz6CxSnnaM/yqUWt5Wok10WdRuef6emalHc/JmF/S3zN2LNYdLBMReS/WV34V1kXsSawGvIy96/ent+aXYR8rnxCR74X75FMhrlo5aApU9TkRuQb4D6ySrT/Hs/J+zxzAmwjP8gOg58NpZc1GJhjS6ZRU9ULgwjAy7c3YF+XHgL+IyE5VaoVqoSLOJlgfxTSbptJBT83HQeHvyfQ4lzdgAyEOINR8Ur1Gcaio9uWRPPcsss69qFTO4QhVvXqA8ty4SnhFz2Wp7b2quntG+r6odu0INRLHh5f/NOxD57NYl4cW4JuR9l6lqu+r0c7Ky3RzBmkqJFVdKSK/xQb4HYw18R4boi9IJR/I6528T57MiG/W+6Riz4mq+pPBOIBa29n1IvINbADO2xhkx1NENgAqI4TvHIxj1Pm+ORcboPMJbMDGxzGn5cIBMOWL2PvlOE1NgRNGkR+btVNgY9atlatMYTQZ+4Bbi6r+GfiziIzBBmIdjn1E/ElE3hBqiivl6SxV/WLuM+phAbCdiLRnfCRXjrUx2e/lrHfWMqwr0aRIu76NDS7aQ1UfTkaIyM8wx3MdwrNpFjYg6u0i8iBWJu6spwZRbOaL6fUYq7VNT9YflQ+4MTUcb7mIvABsLiKbqmr6g7zSmvRYlSwqHzC5fLaGrFykqktV9RpV/QTW9DYJ2C8iy3vDdno6Ijx0Xo89RNYWQFV9ERtFux9WuKDHubwVazY9EHsIL0kco9moeu6p8HsG3ZLeVJqLB6rmtzJpdExZSbN7eAmmmR629wKEZpZ/AzuLSOxDsRdq/FtVz6anZitrydS3SPY0SOvYizmOS4G9xeZnrIWKvofVkDbm2s4K22NDk+ZhwP2qmp4QeSCvd1/PiNdizWlPD0AzexHKfDUqXU4y+2UMMF/Bak3uTTsGA02N75s/YQ7ecWJTVO2A9X+u1oxcD68N2ysy4no5QDXE74dVGmW+k1R1uareEBzL07Am5so9fRdW6zdQ5en+sN0hI67yzul1DqEWeMuMfe4AJorIzpF2vRZ4KMPpbMG6nlWj0nfxU9jHRyv113ZOx2ps6/kNBHuF7VM1pq/4O4dmxB2WSpNmR6wcPVDjsdZhyBxPETlURLJqWCvNBSsisr8Y6xfy/8JLJMm3sVUzLs7ot3QD1kH3RGwC3GfBvnywkYMfBF6DTSOT1a+uGbgVeJSMZazC/2/FvlpuaYBtlaaQrQYovz9gtVWfFZF3ZCUQm+NydB15jsdqF5N57IE1WSzDmoYrnIk9xM/Pmk8uzAdXc22oiOwi2fMHVmo1s+6J7bDmw2Q+R2AP9ycIzaehyfpsrCbvJyKS7lOGiGwq6y5BeC7WVPhNyViaUESSfXuXEDroZ51bX6jqrVjf0yOwGpl2epzRJAN5vc8P22+EftuV/VuxKWFasJH+sQxomQ9NwjcD7xORj2WlEZFdRWRKVlwq3aEi8r6sDxGxZQ+/EP7N6tM4IIjISBH5OjbwZA3WDD4Yx6nrfROe7z8P8ZWy8n8DZM7csJ2esvEQzLnpi2+KyNr+omIT8J8e/v1VIvzArHuc1LMk1PL+GthDRL6ZpZGIvEZEtunHrgpzwnbvjLhf0/NenprIvwUb0JXlf5wVtr+QjLk+RWSMpObhrMJcrCZ2bR6hVekUrGUpE1V9HGv5PByb53IpfcxRWiWPmaoq9fxqzVtEen0wiPE1rC/rIqwVKRm/qdhc1elm9Ur5/q9UGZuKtbqtJlHGEvEjCGNj8n6oD2VT+2XAKhG5hZ5l1PbD+pncTc4Z8AFUda6IfAGbi+ye0JS3EHsZ74PV/nw1Y9fZ2AixKdgUOem46Ym/mxJVVbH1lf8K/EZE/oCd7w5Yjdkr2IjJRjjON2JfRaeLyC6ETuiq+p08malql4i8D5vT7c8ichs2+nUF9vW8JzZaclNq/5D5O/BxEdkLc+I3xaahagE+paprm7NU9XyxCYRPAJ4M/cKexWpQtsGc/F/RMzFvfxwEnBnO4xGs2WILzCErYw/nNNcBPxKRw7B+PK/FBhWsAo5PXedvYwM0Pg28S0RuwPpvTsEc2H0xB+ChcH4PiU2u/X/AvaEsPY41q+yBlaUDQtpXReROYD8R+TX2cVMCrlbV++mfC4N938Sc3V5LUg7k9VbV20TkB9iApgdF5HdYn6/DsMGDt5Ctd73cHmz5QqgZr/RvO1tV8zbjfxj7SD5PRD6PNU0vxcrK6zD796H/Zq8dsRf7EhG5Gbu23SGfd2J9fO/EZhgYCGZIz4T7Y7GP+Ldi98t84GOqOlgfxHneN7/EPkI3Bx5Q1dsHyJZzsFk6LheRK7B7cBespum32POmGg9jA6Qq80Ufgen4Z2ywVYUfAVPFFjGYizn1b8Ra7J6hZ9JvsHfedtjqUR8JGr2E9bndCdPoaHoWieiL32PdMg7B9FtLeC+fHGy7V2zQ07KQdgJWW/q61D6zwz6nA4+L9Vt8Gis/W2Pv9FvIrqVLUpnr+t6geRf2vJuGTZ/2rj72PQd7Nm+M3bcxlWIDzd9F5DFsBP4LWMXJvlh5WoFNqdiZ2ud0rDvHcSQ+8MMz8UysK8j9oYx1YOVxEjbf8twMG6aHdFk1+LWhOYbC5/lhL7+rsGrgFdioqHuxF8EGqbRzqDLFAH1MVwK8Heu4vQTz1p8AfkDG9Dch/QTClA7Akam4yrx/SmKuy1rsCPFKmHC7Rn3m0vd0SrP62X8H7EE0n55RoBcDO2SknUmV6U760Xc6GVPk9GPXMfTMNbjO1BH0TFk0tZ5jYY7T97DJv1dgU109jnUmP4aM6YP60hV72P4hlJsVmAOaOSFy2PdwrGluAfaAfxFrwvoOveeRrVoOwnHPxEY4Lwxldm44jzdX0yOUzb9hfbxeCWV+zyrHEGyC4dnYPbeGnsmvvw5smbHPPthDpXJ+8zCH9wOpdK/FHuIvY47y2nLTX1nBagQr994f+7lW0dc7kddR4dxfwZz1f2POd6/578gxnVLY71DMAX2VnmfI1BruvbVlMiNug3C97g75rsReyH/GJksfU4NdG2J9HC/FPjaWYM+KhdhH4gkkpoyrkke/07/QMxVQ5deNOcqPYLVHM6rZSx8TyNd5DWp+36T2q0zn89k+0sylyvQ91a4v1sf0hqD5K6EMvqfafZLQcAT2XHkaez48hdXapRcZ+GC4ro+H8tGJ3S/fBTbKsLMDc0Bvw5zB1dhH9Gys5rvXvJz9aLaKKlNXYU7sPSHNQuy9tBl9v+ffgjnl87Bn0ELsPXImvRdEybweoSzdh31gLgp27lrtGiX2aw3HU6pM69SoH/ZxfFPQZVUo249gH4vbVtlnFn37KsdijuzyUDZvIjFdZUb6S6gyRWCtv8oclo6zXhGaE54mcvTsUBFqjm7E5sSb2VhrHGf4EZqAn8BqujbV3jVHQ2nLHGxO3qHobxuF2JrftwJfVNWz+kvf7IT+p09g01ENRd/qwhC69MzF5gvtr5tIVRoyuMhxHMdxmowPYF1mLmyk01k0VPU2bHndr9bZv75Z+TLWUjRQXU6GE1/HWqrSs63UxZBOp+Q4juM4zUToUzgJ67KwHOvW4dTHl7FuHNuQPXVSUyM2wX9lCdnjsP7zlzfUqCYjDM6aj62mVW0+5Jpwx9NxHMdZnzkd6+v6EDa5/DMNtqdwqM0IM7PRdkSwLVYOVmADdT+jzTuTTUNQ65f5/YHIy/t4Oo7jOI7jOENC0/XxFJENROQHInK9iCwUkWprylbbf4qIzBKRRSKyQkRuF5ED+9/TcRzHcRzHGUyazvHE5gz8JDaNxO/r2TFMbDobW3HoRGzOs5eA60Rk/wG203Ecx3Ecx6mDZuzj+Qw2H5iKLadXz5D947GJVN+sYfJfEbkR6yj8A3qWlHIcx3Ecx3GGmKar8dRAzt3fCzyqiRUn1JYOvBh4k4hsPhA2Oo7jOI7jOPXTjDWeMexCWKs6RWUJv52xVVt6ESZG3SgVPBbYHlsBYs0A2eg4juM4jjMYdGBLCt+k+ZfpHVSGm+M5GVsaLc3iRHw1TsCWInMcx3EcxykyRwBXN9qILIab4wm2JmmeuHPoPWHsjsDvzj//fKZNmxZt2PpGuVxm5cqVjBo1ipaWoevV0dkJs2f3FO0DD+xm3Lih238gaJR2w4HOTvjb31rp6lpDe3sHBx1UGvLrV3S8/OXHtYvD9YvjiSee4JhjjgF4rtG2VGO4OZ4vk12rOSlss2pDAVDVBcCCZJhN1A/Tpk1jr718XFJRWLIEnn665/899oCJE4duf6ex+PVzHGd9ZezYsZU/m7Z74HD7nHgA2DUjvBL24BDast5TLpdZsWIF5bIvAFEvrl0c5XKZNWtWu3458fKXH9cuDtcvjiLoNtwcz6uAHUVkbfWkiLQBxwB3quq8hlm2HtLd3c2CBQvo7u5utCmFw7WLo1wu09n5SiEews2Il7/8uHZxuH5xlEqlRpvQL03Z1C4ihwFjgA1C0DQR+UD4+xpVXSEi5wHHAq9JrK17PvBZ4HIRORlrOj8B2AE4aMhOwAGgvb2drbbaam2XBad2XLs4WltbmTRpkuuXEy9/+XHt4nD94mhra0q3bh2a1cJzga0T/x8ZfgDbAHOB1vBbWzpVdXVYHvMHwNnAaOA+4DBVvWnwzXaSiIg/PHLi2sXh+sXh+uXHtYvD9YujCNo1ZVO7qk5VVanymxvSzEj+n9j3JVU9VlUnq+ooVd1HVf/WiPNY3+nq6mL+/Pl0dXU12pTC4drFUSp1s2zZUkolb67Lg5e//Lh2cbh+cRRBt6Z0PJ3hgYgwYsSIQnyBNRuuXSxCW1s7iQYRpw68/OXHtYvD9YujCLo1a1O7Mwxoa2tj0qRJ/Sd0euHaxdHa2sqYMWMabUZh8fKXH9cuDtcvjiL08fQaT2fQKJfLrFq1ykcW58C1i6NcLtPV1eX65cTLX35cuzhcvziKoJs7ns6g0d3dzYsvvujTYuTAtYujXC6zbNmyQjyEmxEvf/lx7eJw/eLw6ZSc9Zr29na22GILWltbG21K4XDt4mhtbWXixIm+5F5OvPzlx7WLw/WLowhN7bktFJGRQIeqdibCPgjsDvxVVWcPgH1OgRGRQtwEzYhrF4eI+IsrAi9/+XHt4nD94ijC4KKY6oCLgJ9U/hGRzwOXAScB14vIOyJtcwpOd3c3L730kjeZ5MC1i6NUKtHZ2VmIZqdmxMtffly7OFy/OIqgW4zj+SbgusT/nwcuBiYAVwJfjsjbGSZ4U2d+XLs4ivDl38x4+cuPaxeH6ze8ianP3gh4AUBEtgG2BY5W1c6wnOWFA2CfU2Da2trYaKONGm1GIXHt4mhtbWWDDTboP6GTiZe//Lh2cbh+cRShm0LMZ8UKYHz4ez/gVeCf4f9VwNiIvJ1hgKqyZs0aVLXRphQO1y4OVaW7u9v1y4mXv/y4dnG4fnEUQbcYx/MB4LMisitwAnCj9pzxVsCLscY5xaarq4t58+YVYgmvZsO1i6NUKrF06VLv45kTL3/5ce3icP3iKEIfz5g62W8DfwLuA9YAByXi3gncE5G3Mwxob29ns802o729vdGmFA7XLo7W1lYmTJjgI9tz4uUvP65dHK5fHEVoas9toareICI7AW8E7lPVpxLRN2AOqbMeIyJ0dHQ02oxC4trF4VOyxOHlLz+uXRyuXxxFGFQZNXRMVZ9R1StTTieq+jNVvTPONKfodHd3s3DhwkJU/Tcbrl0cpVKJV155xZvac+LlLz+uXRyuXxxF0C3K8RSRESLyKRG5VET+KiLbhfAjRGTbgTHRKTK+ZGF+XLs4itDJvpnx8pcf1y4O1294E7Ny0YbAjcDO2ECijYHK/CXvAQ7BBh056yltbW1svPHGjTajkLh2cbS2tjJu3LhGm1FYvPzlx7WLw/WLowhdjGJqPH+ATRa/BzaKPdmx4EZg/4i8nWGAT2mTH9cuDlWlVCq5fjnx8pcf1y4O1y+OIugW43geDnxLVe8B0mf6PLBFRN7OMKCrq4vnn3/ep8XIgWsXR6lUYsmSJd7HMyde/vLj2sXh+sUx3Pt4jgOeqRLXTtxUTc4woK2tjU022aQQVf/NhmsXR0tLC+PHj/el93Li5S8/rl0crl8cRZhCLuap/DSwT5W4NwGPRuTtDANaWloYOXKkv/xz4NrF0dLSQnt7u+uXEy9/+XHt4nD94iiCbjEW/hr4qogcQU//ThWRPYETgYtijXOKTXd3N4sXLy5E1X+z4drFUSqVWL58uTe158TLX35cuzhcvziKoFtMXfb3gX2Bq4AlIewvwGTgOuB/4kxzio6qsnr16kJ0dm42XLtYlO7uLmBEow0pJF7+8uPaxeH6xVEE3WJWLuoSkXcAH8KWyNwYWIQto3mZqvpEXOs57e3tbLrppo02o5C4dnG0trYxfvyERptRWLz85ce1i8P1i6MIS41G9d5Vc60vC791EJERqro6Jn+n2KgqqoqIFGIZr2bCtYsjqd+6M705teDlLz+uXRyuXxxFqPHM3cdTRE7pI64duDJv3s7woKuri2effdanxciBaxdHqVRi8eLF3sczJ17+8uPaxeH6xVGEPp4xg4u+ISIfSQeKSAtwKfCWiLydYUBbWxtTpkzxaTFy4NrF0dLSwrhxGxRihGcz4uUvP65dHK5fHEWYTinmyp4I/EJEnlPVOQBi9eIXAIeFn7Me09LSwujRoxttRiFx7eJoaWmho8MHFuXFy19+XLs4XL84ivCxndtCVT0H+ClwpYjsFILPBT4IvF9V/z4A9jkFplQqsXTpUm/uzIFrF0e5XGbFihWUyz7GMQ9e/vLj2sXh+sVRBN2iXGNV/TJwA3CtiJwLHA98WFWvGwjjnGJTLpdZvny5v/xz4NrFoVoOU7K4fnnw8pcf1y4O1y+OIug2EJ0ojsGcz08Ax6nqFQOQpzMMaG9vZ/PNN2+0GYXEtYujtbWNiRMnNtqMwuLlLz+uXRyuXxzDbjolEbm6SpRik8gfKSJHVsJU9YgY4xzHcRzHcZzhQ701nq/DnMwsXgV2Tfzf/JNJOYPKmjVrmD9/PptuuikdHR2NNqdQuHZxdHd3s2zZMsaPH8/ANOysX3j5y49rF4frF0cRpqGq64msqlMHyQ5nGNLW1sbkyZN9WowcuHZxtLS0MGbMmEKM8GxGvPzlx7WLw/WLY7hPp+Q4fdLS0sLYsWMbbUYhce3iaGlpYeTIkY02o7B4+cuPaxeH6xdHET62m99Cp7CUSiU6OzsLMb1Ds+HaxVEul1m5cmUhRng2I17+8uPaxeH6xVEE3epyPEWkJCJvCn+Xw//Vfs2/bpMzqJTLZZYtW+Yv/xy4dnGomuPp0ynlw8tffly7OFy/OIqgW71N7f8NPJ/42wcQOVVpb29nyy23bLQZhcS1i6O1tY1JkyY12ozC4uUvP65dHK5fHMNuOiVVPTXx98wBt8ZxHMdxHMcZtngfT2fQ6Orq4rnnnivE9A7NhmsXR6nUzeLFiymVvMdPHrz85ce1i8P1i6MIukU5niIyVUR+JiKPicjLYfszEdlmoAx0iktLSwvjx48vxCi7ZsO1i0OkhVGjRiHi+uXBy19+XLs4XL84iqBbbgtF5PXAvcAM4AXg+rCdAdwb4vPkO1ZEfiwi80RklYjcJyJH1bDfDBHRKr9N8tjixNHa2sq4ceMKMa9Ys+HaxdHSYo5nER7CzYiXv/y4dnG4fnEUQbeYeTx/DCwEDlLVZyuBIrI18FfgLOCAHPleCewJnAw8BnwYuFREWlT1khr2Pw54JBX2cg47nEjK5TIrVqxg9OjR7gDUiWsXR7lcZs2aNWHlE9evXrz85ce1i8P1i2M4jmpP8ibg+KTTCaCqz4jITOCX9WYoIu8ADgY+rKqXhuAbgzN7hoj8RlX7m6TqQVX9Z73Hdgae7u5uXn75ZTo6Onzpszpx7eIol8ssX748rH7iL6968fKXH9cuDtcvjmE3j2eKZeGXxVKgM0ee78XWfL88Ff4rYDNgrxx5Og2io6ODrbfe2h8eOXDt4vBl9+Lw8pcf1y4O1y+OIkynFON4XgJ8vErcJ4BLq8T1xS7Aw6qaHop6fyK+P/4UJrBfLCJXikgt+ziO4ziO4ziDTEx1wD3AB0TkLszJfBHYBDgamAJcLiLvqyRW1StryHMy8FRG+OJEfDVeBL4L3IHVtu6K9RO9Q0T2VdV/9XVgEZkCbJQKfg3AypUr6ezMU4G7ftPdbVPaTJo0aUhrnjo7YeXK9sT/XdTT3zp2/4GgUdoNBzo7YfnyVpYvX86YMWPo7CwN+fUrOl7+8uPaxeH6xbFsWbWG6OYh5qpeFLZbAntUiZfwtwK1Pvr7Wg2papyqXgdclwj6u4j8GXgAW2XpiH6OewJwSlbEAw88UIiL6RivvtrOo49utvb/W26Zx9ixtc9tFru/01hefbWdxx/36+c4zvrHs88+23+iBhPjeOYZsd4fL5Ndq1lZ+25xRlxVVHWuiNwC7F1D8nPo3bf0NcAfdt11V3bfffd6Du00kCVLYNGinhrLt7xlWyZOHLr9ncbi189xnPWVhx9+uNEm9Etux1NVbxpIQwIPAEeLSFuqn+euYftgjjwF6Hd+AVVdACxYZ0exCttRo0Yxbty4HIdevymXy6xatYqRI0cO6bQYpRKMGtXz/7hxo6jn8sXuPxA0SrvhQKkEI0aU6e7uoq2tvSHXr+h4+cuPaxeH6xfH6NGjG21CvwzoVRWRvUTk0yKyU84srgLGAu9PhR8LzAPurNOebYB9sX6fzhDT3d3NggUL6O72ZQvrxbWLo1wu09n5SiHmtGtGvPzlx7WLw/WLowjTKeWu8RSRXwJtqjoj/H8U8GushnGNiBygqrfXk6eqXisifwXOFZFxwBPYYKVDgWMqc3iKyHmYM/oaVX0mhP0N+Ds2Ar4yuOgkrF/oN/Oep5Of9vZ2ttpqq7U1x07tuHZxtLa2MmnSJNcvJ17+8uPaxeH6xVGEAVkxNZ4HADck/v8v4C/A64HbgK/nzPd92MCk/8YGC+0FHK2qv06kaQ2/ZMl8APgQcGGw46Rg3x6qmqeJ3olERGhpafEHSA5cuzhcvzhcv/y4dnG4fnEUQbcYx3MToFLbuBmwM3C6qt4P/A/ZI937RVVfVdUTVXVTVR2hqrup6mWpNDNUVVR1biLsP1V1Z1Udp6rtqrq5qn5EVR/Le4JOHF1dXcyfP5+uLh9RXC+uXRylUjfLli2lVPLmujx4+cuPaxeH6xdHEXSLcTy7gJHh732BVfT0pVwCTIjI2xkGiAgjRowoxBdYs+HaxSK0tbWzbqOIUyte/vLj2sXh+sVRBN1iOgM8AnxERG4DjgduVdWKq70FsDDWOKfYtLW1MWnSpP4TOr1w7eJobW1lzJgxjTajsHj5y49rF4frF8dw7+P5I2zgz1LgYOAnibgD6Vnm0llPqUyL4SOL68e1i6NcLtPV1eX65cTLX35cuzhcvziKoFtux1NVL8ea2L8CTFfVPyain8cmZHfWY7q7u3nxxRd9WowcuHZxlMtlli1bVoiHcDPi5S8/rl0crl8cw3o6JQBVvYOMOTJVNXPpSWf9or29nS222IJWXyi7bly7OFpbW5k4caJPQJ0TL3/5ce3icP3iKEJTe/Nb6BQWESnETdCMuHZxiIi/uCLw8pcf1y4O1y+OIgwu8uoAZ9Do7u7mpZde8iaTHLh2cZRKJTo7OwvR7NSMePnLj2sXh+sXRxF0c8fTGVS8qTM/rl0cRfjyb2a8/OXHtYvD9RveeH22M2i0tbWx0UYbNdqMQuLaxdHa2soGG2zQaDMKi5e//Lh2cbh+cRShm4J/VjiDhqqyZs0aVLXRphQO1y4OVaW7u9v1y4mXv/y4dnG4fnEUQbdox1NExovIISLyHyIycSCMcoYHXV1dzJs3rxBLeDUbrl0cpVKJpUuXeh/PnHj5y49rF4frF8ew7+MpIt8E5gHXAhcC24Tw2SJycrx5TpFpb29ns802o729vdGmFA7XLo7W1lYmTJjgI9tz4uUvP65dHK5fHMO6qV1ETgBOAc4D3sm6iyL/KYQ56zEiQkdHhw/yyIFrF0dlShbXLx9e/vLj2sXh+sVRBN1iajw/B5ypqp8Hrk/FPQ5sF5G3Mwzo7u5m4cKFhaj6bzZcuzhKLYLg5QAAIABJREFUpRKvvPKKN7XnxMtffly7OFy/OIqgW4zjuS3wlypxrwATIvJ2hgm+ZGF+XLs4itDJvpnx8pcf1y4O1294E9MZYBmwcZW4qcCCiLydYUBbWxsbb1ytiDh94drF0drayrhx4xptRmHx8pcf1y4O1y+OYd3HE5gNnCQiYxJhKiJtwGeoXhvqrCf4lDb5ce3iUFVKpZLrlxMvf/lx7eJw/eIogm4xjue3gK2Bh4AfAYr1+7wLeC3w7WjrnELT1dXF888/79Ni5MC1i6NUKrFkyRLv45kTL3/5ce3icP3iGNZ9PFX1CWBf4GHgBGxU+0eBRcB+qvrsgFjoFJa2tjY22WSTQlT9NxuuXRwtLS2MHz/el97LiZe//Lh2cbh+cRRhCrncV1ZEOoCHVfVQERkBTAaWqOrKAbPOKTQtLS2MHDmy0WYUEtcujpaWFnc6I/Dylx/XLg7XL44iPPdyWSgiI4GVwHsAVHW1qs5zp9NJ0t3dzeLFiwtR9d9suHZxlEolli9f7k3tOfHylx/XLg7XL44i6JbL8VTVVcDLwPKBNccZTqgqq1evLkRn52bDtYtF6e7uwrqeO/Xi5S8/rl0crl8cRdAtphPFH4H30nvyeMcBbOmzTTfdtNFmFBLXLo7W1jbGj/ephPPi5S8/rl0crl8cRVhqNMbxvAw4T0TOB64E5pOqXlDVeyLydwqOqqKqiEghlvFqJly7OJL6rbuar1MLXv7y49rF4frFUYQaz5heqH8BtgBmAH/AplH6R/j9M2yd9Ziuri6effZZnxYjB65dHKVSicWLF3sfz5x4+cuPaxeH6xdHEfp4xtR4fgzvQOX0QVtbG1OmTPFpMXLg2sXR0tLCuHEbFGKEZzPi5S8/rl0crl8cw3o6JVWdNYB2OMOQlpYWRo8e3WgzColrF0dLSwsdHSMabUZh8fKXH9cuDtcvjiJ8bNdtoYiMEpGjReRkETleRDYaDMOc4lMqlVi6dKk3d+bAtYujXC6zYsUKyuVyo00pJF7+8uPaxeH6xVEE3epyPEVkM+AB4GLgNOAXwGMisvcg2OYUnHK5zPLly/3lnwPXLg7VcpiSxfXLg5e//Lh2cbh+cRRBt3qb2r8DbB62dwDbAf8FnAu8YWBNc4pOe3s7m2++eaPNKCSuXRytrW1MnDix0WYUFi9/+XHt4nD94hiO0ykdDJymqt8O/18rIk8CV4vIxqr60sCa5ziO4ziO4wwX6u3juQnw91TYHGyivI0HwiBn+LBmzRqeeeYZ1qxZ02hTCodrF0d3dzcvv/xyIaYWaUa8/OXHtYvD9YujCNNQ1et4tmJrtCdZFbY+94GzDm1tbUyePNmnxciBaxdHS0sLY8aMKcQIz2bEy19+XLs4XL84hut0SjuISLIaoXKWO6ZXGfCVi9ZvWlpaGDt2bKPNKCSuXRwtLS2MHDmy0WYUFi9/+XHt4nD94ijCx3Yex3NWlfCLEn8LNrl887vezqBRKpVYvnw5Y8aMKcRXWDPh2sVRLtuo9hEjRhC3QNv6iZe//Lh2cbh+cRRhOqV6Hc/jBsUKZ1hSLpdZtmwZo0aN8gdInbh2caiWWblyJR0d7bjjWT9e/vLj2sXh+sUx7KZTUtULBssQZ/jR3t7Olltu2WgzColrF0draxuTJk1qtBmFxctffly7OFy/OIownZJXBTiO4ziO4zhDgjuezqDR1dXFc889V4jpHZoN1y6OUqmbxYsXUyr5dEp58PKXH9cuDtcvjiLo5o6nM2i0tLQwfvz4QoyyazZcuzhEWhg1ahQirl8evPzlx7WLw/WLowi6+URZzqDR2trKuHHjGm1GIXHt4mhpMcfTyYeXv/y4dnG4fnEUYUBW07nGIjJWRH4sIvNEZJWI3CciR9W47xQRmSUii0RkhYjcLiIHDrbNTjblcplXX321EKPsmg3XLo5yucyqVatcv5x4+cuPaxeH6xdHEXRrOscTuBI4FjgVOAz4B3CpiHy4r51EZAQwGzgQOBE4AngJuE5E9h9Ui51MfNnC/Lh2cZTLZZYvX16Ih3Az4uUvP65dHK5fHMNxHs9BRUTeARwMfFhVLw3BN4rI1sAZIvIbVa2m6vHALsCbVfX2kN+NwL+AHwB7Da71TpqOjg623nrrRptRSFy7OCrL7jn58PKXH9cuDtcvDp9OqX7eC7wKXJ4K/xWwGX07j+8FHq04nQCq2g1cDLxJRDYfYFsdx3Ecx3GcOmiqGk+sxvLh4DAmuT8Rf1sf+96cEV7Zd2fghWoHFpEpwEap4B0BHnrooT5MdqpRKpVYtmwZ48ePH9IOz52d8NRTPUX7n//spp6+6rH7DwSN0m440NkJTz7ZwooVKxk9ehT//Gd5yK9f0fHylx/XLg7XL47HH3+88mdHI+3oC1HVRtuwFhF5DHhKVQ9NhW8KzAO+rqqnV9l3DXC+qn46Fb4P5qwmm++z9p8JnBJ3Bo7jOI7jOA3nCFW9utFGZNFsNZ4AfXnC/XnJMfueQ+8m/l2BS4EPAI/0s7+TzYNYbbRTP65dHK5fHK5ffly7OFy//HQA9wA3NdqQajSb4/kykDUioLLo8uJB2hdVXQAsSIaJSOXPR1T1333t72QjIrh2+XDt4nD94nD98uPaxeH6xRH0W9ZoO6rRbIOLHgB2EpG0Q7xr2D7Yz767ZoTXsq8zeJzaaAMKjGsXh+sXh+uXH9cuDtcvjqbWr9n6eB4GXAMcpaq/SYRfC7wO2KradEoi8hmsuXxvVb0zhLUB9wGvqureOezZmVDl719fjuM4juM4cTRVU7uqXisifwXOFZFxwBPA0cChwDEVp1NEzsMmmX+Nqj4Tdj8f+CxwuYicjDWbnwDsABw0tGfiOI7jOI7jpGkqxzPwPuC7wH9j/TMfAY5W1csSaVrDb20nTFVdHZbH/AFwNjAaq+08TFXzdrJdiFVZL8y5v+M4juM4jhNoqqZ2x3Ecx3EcZ/jSbIOLHMdxHMdxnGGKO56O4ziO4zjOkOCOp+M4juM4jjMkuOPpOI7jOI7jDAnueGYgImNF5MciMk9EVonIfSJyVKPtchzHcRzHKTLNOJ1SM3AlsCdwMvAY8GHgUhFpUdVLGmqZ4ziO4zhOQfHplFKIyDuAPwMfVtVLE+HXAzvTx+pJjuM4juM4TnW8qb037wVeBS5Phf8K2AzYa8gtchzHcRzHGQY0neMpIhuIyA9E5HoRWSgiKiIz69h/iojMEpFFIrJCRG4PKxrVyi7Aw6ranQq/PxHvOI7jOI7j1EnTOZ7AZOCTwAjg9/XsKCIjgNnAgcCJwBHAS8B1IrJ/HcdfnBG+OBHvOI7jOI7j1EkzDi56BpioqioiGwIfr2Pf47EayTer6u0AInIj8C9sDfdam8n76vjqnWIdx3Ecx3Fy0HQ1nhrIuft7gUcrTmfIrxu4GHiTiGxeQx4vk12rOSlss2pDHcdxHMdxnH5oxhrPGHYBbs4Ir/TP3Bl4IWtHEZkCbAQ8D7xDRF4HjAK2Bx7Emu8BlovIzgNptOM4juM4zgDQAWwJ3KSqyxptTBbDzfGM6Z95AnBK4v9/VUl3cQ67HMdxHMdxhoojgKsbbUQWw83xhPz9M8+hZwqln2O1p5cAnz7//POZNm3aAJm3/lAul1m5ciWjRo2ipaXpenU0NVHadXbSNnv22n+7DzwQxo0rzv4DgJe9OFy//Lh2cbh+cTzxxBMcc8wxAM812pZqDDfHM3f/TFVdACwAEJFDgO9iKxYxbdo09trLp+90CsKSJfD00z3/77EHTJxYnP0dx3GcXIwdO7by55pG2tEXw+1z4gFg14zwStiDtWSiqq+q6onA9AGya72kXC6zYsUKyuVyo00pHK5dHK5fHK5ffly7OFy/OIqg23BzPK8CdhSRtdWTItIGHAPcqarzGmbZekh3dzcLFiyguzs9F7/TH65dHK5fHK5ffly7OFy/OEql5l/Ruymb2kXkMGAMsEEImiYiHwh/X6OqK0TkPOD/s3fncVJVZ/7HP091VTU00KwN3YBsjkYFXJCoKBqJYlyi/jQal5mMGk0mGkezONFknKBGo5IYTTSaGJM4MaLGxOg4RI0rLhFH44YYxI1NaBoaaKBpums5vz9OddP03vdU172neN6vV7266t6qWw9fq9tT957lHGB3Y8zy3L7fAF8HHhSRK7CXzi8CPgUcXbB/gAIgkUgwbtw4RCTsUryj2bnR/NxofsFpdm40PzfxeCSbdTuJaoV3AONbPT49dwOYCCwDSnK3lk+nMaYxtzzmXOBWoAx4EzjOGLOg78tWrYmI/vEISLNzo/m50fyC0+zcaH5ufMgukpfajTETjDHSyW1Z7jnntn7c6rVrjTHnGGOGG2P6G2NmGGOeCuPfsatLpVKsWbOGVCoVdine0ezcaH5uNL/gNDs3mp8bH3KLZMNTFQcRobS01ItvYFGj2bnR/NxofsFpdm40Pzc+5Ba44SkinxWR01s9HiUifxGRahH5nYj0y0+JylfxeJxhw4Z50eckajQ7N5qfG80vOM3OjebnxofcXM54XgO0nlV9LnA48DfgNOA/HI6tikA2m2X79u1eTO8QNZqdG83PjeYXnGbnRvNz40NuLg3PPYHXoWXKolOAy40xpwLfB85yL0/5LJ1OU11drdNiBKDZudH83Gh+wWl2bjQ/Nz5Mp+TS8CwHNuXuH4id/qh5XdD/A8Y5HFsVgUQiwdixY0kkEmGX4h3Nzo3m50bzC06zc6P5uSn2S+01wB65+0cDy40xq3KPBwHRH1ql+pSIEI/HvejsHDWanRvNz43mF5xm50bzc+NDbi4Nz8eBH4rITcC3gIdb7dsLO9em2oWl02nWrl2rl0wC0OzcaH5uNL/gNDs3mp8bH3JzOSf7Pezl9K9gL61f22rf2dhBRmoXF4vpjF1BaXZuND83ml9wmp0bza+4BW54GmPWA8d2snsWsD3osVVxiMfjVFRUhF2GlzQ7N5qfG80vOM3Ojebnptj7eLYQkf4iMiY3uh1jzGZjTFM+jq38ZYyhqakJY0zYpXhHs3Oj+bnR/ILT7Nxofm58yM2p4Skis0TkZWALsBzYN7f95yJyah7qUx5LpVKsXr3aiyW8okazc6P5udH8gtPs3Gh+bnzo4+m0chHwV6Af8OM2x1oPnOtUmfJeIpFg9OjROi1GAJqdG83PjeYXnGbnRvNzU+yX2q8B/mKMOQC4ss2+t4D9HY6tioCIkEwmvZjeIWo0OzeanxvNLzjNzo3m58aH3FwangcAv8zdb9upYB0w0uHYqgik02nWrVvnxan/qNHs3Gh+bjS/4DQ7N5qfGx9yc2l4poHOzoWPxPb7VLs4H9aNjSrNzo3m50bzC06zc6P5FTeXhuerwJc62Xca8LLDsVURiMfjjBo1yos+J1Gj2bnR/NxofsFpdm40Pzc+5OZS4Q3AEyLyZ+B32MvtB4vIl7ENz1l5qE95zBhDJpOhpKTEi34nUaLZudH83Gh+wWl2bjQ/N0U9nZIx5ingHOBw4E+AAD/Hrlp0rjHmxbxUqLyVSqVYtWqVTosRgGbnRvNzo/kFp9m50fzc+NDH0+mcrDHm9yLyJ+BQYBR2GqWXjDH1+ShO+S0ej1NZWenFqf+o0ezcaH5uNL/gNDs3mp+bkpKSsEvoVuD/siIywhiz3hjTADzdwf5pxpjXnapTXovFYvTr1y/sMryk2bnR/NxofsFpdm40Pzc+rHPvUuGjItLhp0NEJgNPOBxbFYF0Os2GDRu8OPUfNZqdG83PjeYXnGbnRvNz40NuLg3PUcC9bTeKyD8BTwL/cDi2KgLGGBobG73o7Bw1mp0bzc+N5hecZudG83PjQ24uDc/jgSNF5CfNG0RkHPay+2rgBMfalOcSiQRVVVW69FkAmp0bzc+N5hecZudG83PjQ26B+3gaY5aIyKnYKZWWAQ9gG51bgGOMMTqB/C7OGIMxBhHRaTF6SbNzo/m50fyC0+zcaH5uiv2MJ8aYBcAFwE3Awtzmo40xG1wLU/5LpVKsWLFCp8UIQLNzo/m50fyC0+zcaH5ufOjj2aszniIyrIPNfwFuBf4ZOBZoan6eNkB3bfF4nJEjR+q0GAFodm40PzeaX3CanRvNz00xTqe0HrtCUUcEeK3NtugnoPpMLBajrKws7DK8pNm50fzcaH7BaXZuND83Pkyn1NuG5zV03vBUaieZTIYtW7YwaNAgL76FRYlm50bzc6P5BafZudH83GQymbBL6FavGp7GmKv6qA5VhLLZLPX19QwYMED/gPSSZudG83Oj+QWn2bnR/Nxks9mwS+iWdqJQfSaRSDBmzJiwy/CSZudG83Oj+QWn2bnR/NwU3XRKIvKvwHxjTG3ufpeMMb8LXJlSSimllCoqvT3jeTdwCFCbu98VA2jDcxfW1NTEmjVrqKqqIplMhl2OVzQ7N5qfG80vOM3OjebnxodpqHrb8JwIrGl1X6lOxeNxhg8frtNiBKDZudH83Gh+wWl2bjQ/Nz70i+3t4KLlHd1XqiOxWIyBAweGXYaXNDs3mp8bzS84zc6N5ufGh+mUnCsUkX4icqiInJj72S8fhSn/ZTIZNm/e7MX0DlGj2bnR/NxofsFpdm40Pzc+5ObU8BSRb2Evvb8APJL7WS0i385Dbcpz2WyWuro6L6Z3iBrNzo3m50bzC06zc6P5ufEht8CdKETk34EfA08C84BqoBK7dOZcEUkZY36WlyqVlxKJBLvttlvYZXhJs3Oj+bnR/ILT7Nxofm6KbjqlNr4B/N4Y03Zapf8Wkd8DlwLa8FRKKaWUUoDbpfbRwL2d7Lsnt1/twlKpFCtXrvRieoeo0ezcaH5uNL/gNDs3mp8bH3JzaXguBUZ1sq8K+MDh2KoIxGIxBg8e7MUou6jR7Nxofm40v+A0OzeanxsfcnOpcA5wtYhMab1RRPbN7ft+kIOKyEARuUVEVovIdhF5U0TO7MHrzhUR08mtMkgtyk1JSQnl5eVezCsWNZqdG83PjeYXnGbnRvNz40NuLn08v5x7/Zsispgdg4smA6uB80TkvNxzjTHm5B4e9yHg08AV2LOqZwP3iUjMGDOvB68/D1jSZlttD99b5VE2m2Xbtm2UlZV58S0sSjQ7N5qfG80vOM3OjebnpqhHtQP7AmlgJVCeu5F7DDC11XNNTw4oIscDs4GzjTH35TY/KyLjgR+JyAPGmO4mqXrHGPNaT95P9a10Ok1tbS3JZFKXPuslzc6N5udG8wtOs3Oj+bnxYR7PwA1PY8yEPNbR7BRgK/Bgm+2/xU7ZdDDwtz54X9UHkskk48ePD7sML2l2bjQ/N5pfcJqdG83PTbFPp9QXpgD/MMak22x/u9X+7hqe/ysiFUAd8BzwfWPMO929sYiMBCrabN4doKGhgc2bN3d3CKWiYfNmEg0NLQ9TmzdDb/r9hP16pZRSgWzdujXsErrlMoH8vsAQY8zzuccDgbnANOCvwBxjTI8usbcyHPiog+0bWu3vTDVwHbAQ2Iy91H8FsFBEDjPGvNXNe1+EHRTVzqJFi6irq+vm5UpFQ2LrVka/917L49UvvkiqF2sfh/16pZRSwaxYsSLsErrlcsbzJ8DrwPO5x9cBXwEWAd8F1gG3BjhuV43VTvcZYx4HHm+16XkRmZ+r5xqgu8FNt9P+Ev/uwCNTp05l2rRp3bxctZXNZqmvr2fAgAHaSbyXnLLbuJHE+vUtDyfNnAlDh/rz+jzQz54bzS84zc6N5udm8eLFYZfQLZeG5xTgNgAREexSmXOMMT8UkWuxo9572/CspeOzmsNyPzd0sK9TxphlIvIicEgPnlsD1LTeZv9Z0L9/f8rLyzt6merGkCFDwi7BW4Gzy2Sgf/+Wh/3Ly6E3n9+wX58n+tlzo/kFp9m50fyC86Gt4vJ1YgjQfFpjP2Ao8Ifc46eBSQGOuQjYW0TaNoibR8h321ezAwJEf36BItQ8LYYP0ztEjWbnRvNzo/kFp9m50fzc+JCbS8OzFtgtd38WsNYY07xaURLb4OutPwMDgS+02X4Odm7QV3pzMBGZCByG7fepCiydTlNTU0M63XasmOqOZudG83Oj+QWn2bnR/NwU9XRKwAvAVSIyAvgmML/Vvj3YMZ9njxljHhORJ4E7RKQcu+zmWcCxwL80z+EpIr/GNkZ3N8Ysz217Ctvf9G12DC76DrZf6H8F+hcqJ4lEgnHjxrV0WVA9p9m50fzcaH7BaXZuND838XjUJitqz6XC7wKPAT8FPsQO4Gl2OsHPMp6KHah0DbZv5xLgLGPM/a2eU5K7tf5kLgLOAC4D+mP7az4D/MAYszRgLcqBiOgfj4A0OzeanxvNLzjNzo3m58aH7FwmkP8Y2EtEhhlj2g76uRg7vVGQ424FLs3dOnvOucC5bbZ9M8j7qb6TSqVYv349I0aM8GJS2yjR7Nxofm40v+A0Ozean5tUKhV2Cd1yPifbQaMTY8wi1+Mq/4kIpaWlXnwDixrNzo3m50bzC06zc6P5ufEht+h3BlDeisfjDBs2rPsnqnY0OzeanxvNLzjNzo3m58aHPp46O6vqM9lslu3bt3sxvUPUaHZuND83ml9wmp0bzc+ND7lpw1P1mXQ6TXV1tU6LEYBm50bzc6P5BafZudH83BT7dEpKdSmRSDB27FhKSkrCLsU7mp0bzc+N5hecZudG83NT1JfaReQIERnYyb6BInJE8LJUMRAR4vG4F52do0azc6P5udH8gtPs3Gh+bnzIzeVS+7PAPp3s+1Ruv9qFpdNp1q5dq5dMAtDs3Gh+bjS/4DQ7N5qfGx9yc2l4dtWsTqDroysgFtNuxEFpdm40PzeaX3CanRvNr7j1qjNAbhnLIa02VYrIuDZP649dzjLQBPKqeMTjcSoqKsIuw0uanRvNz43mF5xm50bzc+NDH8/eVvhN4Pu5+wb4cyfPE+CHQYtSxcEYQyqVIpFIeNHvJEo0OzeanxvNLzjNzo3m58YYE3YJ3eptw/OvwFZsw3IucCuwos1zGoFFxpgF7uUpn6VSKVavXs3o0aNJJpNhl+MVzc6N5udG8wtOs3Oj+bnxoY9nrxqexpiXgZcBRGQA8CtjzOq+KEz5L5FIMHr0aF1vNwDNzo3m50bzC06zc6P5uSnGS+0tjDFXt90mIv2ACcD7xpjoz2Kq+pSI6DfWgDQ7N5qfG80vOM3OjebnxofuCS7zeP67iPxXq8cHAiuBxcBSEdktD/Upj6XTadatW+fFqf+o0ezcaH5uNL/gNDs3mp8bH3JzmbPgAmBTq8c3AhuwA5AEuNLh2KpI+LBubFRpdm40PzeaX3CanRvNr7i5dAYYBywBEJFBwBHAmcaYh0RkI3BNHupTHovH44waNSrsMryk2bnR/NxofsFpdm40Pzc+9PF0OeNZCqRy92fkjvVU7vEyoNLh2KoIGGNIp9NeTO8QNZqdG83PjeYXnGbnRvNz40NuLg3PFcDhufsnA28aYzbnHlcAmzt8ldplpFIpVq1aRSqV6v7JaieanRvNz43mF5xm50bzc+NDH0+Xc7K/B+aIyP8D9gMua7VvOrDUpTDlv3g8TmVlpRen/qNGs3Oj+bnR/ILT7Nxofm5KSkrCLqFbLv9lrwPSwKHYFYxubbVvCvAnh2OrIhCLxejXr1/YZXhJs3Oj+bnR/ILT7Nxofm58WOfeZR5PA9zQyb6TAlekikY6nWbz5s2Ul5frt9de0uzcaH5uNL/gNDs3mp+bYr/UDrSMaJ8BDAfWAwuNMVtcj6v8Z4yhsbHRi87OUaPZudH83Gh+wWl2bjQ/Nz7k5tTwFJHLgDlAGXbuTgNsE5E5xpif5KE+5bFEIkFVVVXYZXhJs3Oj+bnR/ILT7Nxofm58WGo0cMNTRP4VmAs8BtwNrAZGA+cAPxKRdcaYe/JRpPKTMQZjDCLixTJeUaLZudH83Gh+wWl2bjQ/Nz6c8XTphfpNYJ4x5gRjzIPGmJdyPz8P3Jfbr3ZhqVSKFStW6LQYAWh2bjQ/N5pfcJqdG83PjQ99PF0annthp1TqyO+BvR2OrYpAPB5n5MiR2kE8AM3OjebnRvMLTrNzo/m5KfbplBqAYZ3sG5bbr3ZhsViMsrKysMvwkmbnRvNzo/kFp9m50fzc+DCdkkuFLwBXicjo1htFpBL4PvC8S2HKf5lMhk2bNpHJZMIuxTuanRvNz43mF5xm50bzc+NDbi4Nz+8Bo4APRORREblTRB4FPsSu0/69fBSo/JXNZqmvryebzYZdinc0OzeanxvNLzjNzo3m58aH3FwmkF8sIgcBVwGzsPN41gIPA1cbY3TJzF1cIpFgzJgxYZfhJc3OjebnRvMLTrNzo/m5KerplACMMe8BZ+WpFqWUUkopVcR6faldRPqLyFkicoWInC8iFX1RmPJfU1MTy5cvp6mpKexSvKPZudH83Gh+wWl2bjQ/Nz5MQ9WrM565gUTPAxOxKxUB/FhEjjPGLMx3ccpv8Xic4cOH67QYAWh2bjQ/N5pfcJqdG83PjQ/TKfX2jOe1wJjczxOAbwBNwB15rksVgVgsxsCBA72Y3iFqNDs3mp8bzS84zc6N5ufGh9x6W+Fs4IfGmDnGmMeMMT8DvgzsKyKj8l+e8lkmk2Hz5s1eTO8QNZqdG83PjeYXnGbnRvNz40NuvW14VtJ+fs7nsJfdteGpdpLNZqmrq/Nieoeo0ezcaH5uNL/gNDs3mp8bH3LrbSeKEtqvSLQ94LFUkUskEuy2225hl+Elzc6N5udG8wtOs3Oj+bkp1umUPiUirVehb+7JupeI7PREY8zrQQtTSimllFLFJUjD8+5Ott/T6r4Ahh2NUrULSqVSVFdXU1lZ6cW3sCjR7Nxofm40v+A0Ozean5uim04JOK9PqlBFKRaLMXjwYC9G2UWNZudG83Oj+QWn2bnR/Nz4kFuvGp7GmP/uq0KaichA7HRNXwSGAUuAG4wx9/fgtSOBucDngTLgLeCnUAewAAAgAElEQVRKY8zTfVex6kxJSQnl5eVhl+Elzc6N5udG8wtOs3Oj+bkpxnk8C+Eh4BzgauA44FXgPhE5u6sXiUgp8DRwFHApcDKwFnhcRD7TpxWrDmWzWbZu3erFKLuo0ezcaH5uNL/gNDs3mp8bH3KL1Eh0ETkeO1fo2caY+3KbnxWR8cCPROQBY0xnk1SdD0wBDjXGvJw73rPYs55zgYP7tnrVVjqdpra2lmQySTKZDLscr2h2bjQ/N5pfcJqdG83PTTHO49nXTgG2Ag+22f5bYDRdNx5PAd5rbnQCGGPSwO+Bg0RkTJ5rVd1IJpOMHz9e/3gEoNm50fzcaH7BaXZuND83PgzIilrDcwrwj1yDsbW3W+3v6rVvd7C9edtkx9qUUkoppZSDSF1qB4YDH3WwfUOr/V29dkMH23vy2uaBSRVtNu8F8O6773b1UtWJTCZDXV0dgwcP9qLDc5Q4Zbd5M/GPdvwapV97DXrTWT/s1+eBfvbcaH7BaXZuND8377//fvPdyJ4yjlrDE+z8n0H2ub72ImBORzu+/OUvd/NSpSLsxhv9fr1SSqne2g14I+wiOhK1hmctHZ+ZHJb72dEZzXy8FuB22vctnQrcB5yGndZJ9d47dN1FQnVOs3Oj+bnR/ILT7NxofsElgdeBBWEX0pmoNTwXAWeJSLxNP8+puZ/vdPPaqR1s78lrMcbUADWtt7VaAnSJMWZxV69XHRMRNLtgNDs3mp8bzS84zc6N5ucml19d2HV0JmqDi/4MDAS+0Gb7OcBq4JVuXruXiLSMfBeROPAvwCvGmNV5rlX1zNVhF+Axzc6N5udG8wtOs3Oj+bmJdH5iTHddHwtLRP4KTAcuBz4AzgK+AvyLMebe3HN+jW2M7m6MWZ7bVgr8HSgHrsCevbwIOBE42hjT69POIjKZ3Cl//fallFJKKeUmapfaAU4FrgOuYceSmWe1WTKzJHdruRZujGkUkaOwk8Xfil0y803guCCNTqWUUkoplV+RO+MZJbkpli4Cbs/1AVVKKaWUUgFpw1MppZRSShVE1AYXKaWUUkqpIqUNT6WUUkopVRDa8FRKKaWUUgWhDU+llFJKKVUQ2vDsgIgMFJFbRGS1iGwXkTdF5Myw61JKKaWU8lkU5/GMgoeAT2Mnol8KnA3cJyIxY8y8UCtTSimllPKUTqfUhogcD8wHzjbG3Ndq+1+BycA4Y0wmrPqUUkoppXyll9rbOwXYCjzYZvtvgdHAwe1eoZRSSimluhVqw1NEKkTkehF5WUSW5tZGR0T+TUQOCKmsKcA/jDHpNtvfbrVfKaWUUkr1UmgNTxGZCLwFXAIYYHegNLd739z2MAwHNnSwfUOr/UoppZRSqpfCPOM5F9gE7AEcAUirfS8Ch4VRVE5XHV+1U6xSSimlVABhjmo/CrjQGLNaREra7FuD7U8Zhlo6Pqs5LPezo7OhSimllFKqG2E2PPvReSNuAJAtYC2tLQLOEpF4ro7PACuxDWWA+ua+qEoppZRSEZIEdgMWGGPqwi6mI2E2PN8Djgae7GDfEcA7hS2nxZ+BrwBfABqAR9rs/33BK1JKKaWU6rmTgf8Ju4iOhNnw/BXwExFZDdyb25YUkdOAi4CLwyjKGPOYiDwJ3AH8HGDevHnsu+++YZTjtUwmQ319PQMGDKCkpG1vCtUVn7NbD9zW6vFVIdTgc35RoPkFp9m50fzcvPfee3zhC18Ae6U2kkJreBpjbheR/YGbgZtym1/EDjL6lTHmv8OqDTgVuA74GsCkSZOYPFmvrivVE9Xs6BANtsN0ZUi1KKXULqop7AI6E+o8nsaYrwKHAtcDd2FHuh9ujPlayHVtNcZcChwZZh2+y2azbNu2jWw2rO66/iqm7N4I4T2LKb8waH7BaXZuND83PuQW+spFxpiFxpj/MsZ81RjzPWPM38KuSeVHOp2mpqaGdLrtXPyqO8WU3ZshvGcx5RcGzS84zc6N5ucmk4n+it5hTiB/iIh8sZN9XxQRXZrSc4lEgnHjxpFIJMIuxTvFlN0y7IS9hVRM+YVB8wtOs3Oj+bmJx8McutMzYZ7x/CEwtZN9+wDXFrAW1QdEhFgshoh0/2S1k2LL7q0Cv1+x5Vdoml9wmp0bzc+ND7mF2TTelx2Ditp6BTuyXXkslUqxfv16RowYod9ee6nYsnsTOyFuoRRbfoWm+QXnkl06nWbjxo1s3boVY3bNRfKy2SyNjY2UlpYSi4XeGzASRITS0lLKy8sZMGBAl43LVCpVwMqCCfO/6gCgs04cWWBQAWtRfaD5l8WHb2BRUyzZDcj9XAJsK+D7Fkt+YdH8gguanTGGVatWsX79ei8aD31FP3vtZTIZ6urqWLlyJTU1NV1+KfEhtzDPeH4MzAKe6GDfLGB5YctR+RaPxxk2bFj3T1TtFEt2+wMvYb9JvgXMKND7Fkt+YdH8ggua3ZYtW2hoaGDw4MFUVVV50YBQhdPU1MSaNWvYsGEDAwYMYODAgR0+T/t4du1+4Jsicl7rjSJyLvAN4L4wilL5k81m2b59uxfTO0RNsWT3KaD5z+NrBXzfYskvLJpfcEGz27x5MwAjR47cpRudxhiy2ewu29WgM8lkkqqqKmDHZ6UjPvzOhtnwvAF7MuTXIlIvIu+LSD3w69z260OsTeVBOp2murpap8UIoFiyiwHTcvffBeoL9L7Fkl9YNL/ggmaXSqWIx+NenLHqS8YYUqmUNjw7kEwmSSQSNDY2dvocnU6pC8aYJmA2cA7wMPbS+8O5x8fk9iuPJRIJxo4dq4MTAiim7D6d+5kFXi/QexZTfmHQ/IILmp0xRgfTYPsoJpPJXfqsb1dEpMtGuQ9fXEKt0BiTAe7J3VSREREvfgmiyOfs2v5J/CdgMFCHvdx+eAFq8Dm/KND8gnPJThtbmkF3usvHh/z065XqM+l0mrVr1+rlugCKJTvB/pE5MPf4PaDz3kn5Uyz5hUXzC06zc6OX2t348LkLteEpIkeIyB9FZLGIfNTm9mGYtan80EtHwRVTds2X2w3w9wK9ZzHlFwbNLzjNTqnOhblk5kzgaexVuL2xU/19AozDzu/5fFi1qfyIx+NUVFToJbsAii27iUDzBDOvFuD9ii2/QtP8gtPsOnb33XcjIp3ennvuOcBeKk4kEpG8ZLxt2zauuuqqllrz6bnnntsph6B8+NyFWeHVwG+BC4EUcKUx5nUR2Rd4HHgoxNpUHjRfMonqH5EoK7bsBJgO/BX4EFgPjOjD9yu2/ApN8wtOs+vab3/7W/baa6922/fZZx/A5meMaWmQRsm2bdu4+uqrATjyyCPDLaYTPnRRCLPhOQX4MTvGIpQAGGPeFpEfAN8HHg2pNpUHqVSK1atXM3r0aJLJZNjleCXs7OqALcDYPB7zEGzDE2Ah8Pk8HrutsPPzneYXnGbXtSlTpjB9+vRO92vD3Y328exaGbDVGJMFGtn5BMgSYJ9QqlJ5k0gkGD16tE7JEkCY2WWAH+Rui/N43DHYfjQAL9N+9Hs+6WfPjeYXnGYX3P33309JSQl33nnnTo3OOXPmUFJSwpNPPgnAsmXLEBHmzp3Lddddx7hx4+jXrx/Tp0/n6aefbnfc999/n7PPPpuRI0dSWlrK3nvvzc9//vN2z9u0aRPf/va3mTRpEqWlpYwcOZLjjz+eJUuWsGzZMioqKgC4+uqrW87Innvuub1+nyVLlnDsscdSVlbGiBEj+NrXvsaWLVtc4wP0Unt3VgCjcvffBU4AHss9/gxQG0ZRKn+a52NTvRdmdltyN4CfAb/M47FnYH/x1wMfAHvk8dit6WfPjeYXXL6z+wOwMm9Hc7cb8EWH12cymXZn5USEkpISzjzzTBYsWMBll13GjBkzmD59Os888wzXXnst3/ve95g9e/ZOr7vtttsYP348t9xyC9lslrlz53LcccexYMECZsywC/S+++67HHrooYwbN46bbrqJyspKnnjiCS655BLWr1/PnDlzALtk6cyZM1m2bBmXX345Bx98MFu3buX5559nzZo1HHrooTz++OMce+yxnH/++VxwwQUALY3Rnr7P2rVr+cxnPkMikeD2229n1KhR3HvvvVx88cUOqe6cZdSF2fB8DjgS+CPwK+B2Edkbe/bzGOCm0CpTeZFOp9m4cSNDhw714ltYlEQpu03AkDwd6yDsL3wGe9azrxqeUcrPR5pfcPnObiWw1L2syDjkkEPabSspKWlpjN58880sXLiQL37xi8yfP5+zzz6bww8/nKuuuqrd6zKZDE8++ST9+vUD4HOf+xwTJkzg+9//fsvZ0W9961sMGjSIF198kfLycgBmz55NY2MjN9xwA5dccglDhw7llltuYfHixTz55JMcffTRLe9x6qmnttw/8EA7MdzYsWPb/Tt6+j4333wz69at44033mC//fYD4LjjjuOYY45hxYoVgTJtzYdL7WH+RZlDbqCrMeYXIlIG/DP2Cty1wHUh1qbyxId1Y6MqKtm9DByXp2MNBKYCb2Inkz8DKM3TsduKSn6+0vyCy2d2u+XtSPnhWs/vfvc79t577522tT5LV1payrx58zjkkEOYNm0a5eXl3HfffZSUlLQ71qmnntrS6AQYNGgQJ554Ivfddx+ZTIZUKsXTTz/NhRdeSFlZ2U6NsuOPP57bbruNhQsXctxxx/HYY4+x55577tTo7Knt27f3+H2effZZJk+e3NLobHb22We3NJaLXSgNTxEpwTY6a5q3GWN+AvwkjHpU34jH44waNar7J6p2opTd34BjsSPT8+FQbMOzMffz4Dwdt7Uo5ecjzS+4fGfnclk7ivbee+8uBxeJCHvvvTeHH3448+fP58ILL6SqqqrD51ZWVna4rampia1bt7J161bS6TS33nort956a4fHWL9+PQDr1q1j3LhxHT6nO7W1tT1+n9raWiZOnNijf0sQPlyhCKtCwfbrPJEd/TpVkTHGkMlkKCkp8aLfSZREKbsa4H1gzzwdbzL2zOdW4CX6puEZpfx8pPkFp9m5McZw1113MX/+fA466CBuu+02zjjjDA4+uP1fiurq6g63JZNJBg4cSCKRoKSkhC996Ut8/etf7/D9mhuBFRUVrFq1KlDNQ4cO7fH7DB8+vNO688GH6ZRCGdVujEkD1WG9vyqMVCrFqlWrSKVSYZfinahl91IejxXHTq0EdgnNtXk8drOo5ecbzS84zc7N22+/zaWXXsqXvvQlXnjhBfbdd1/OOOMMNm7c2O65Dz30ENu3b295vGXLFh599FEOP/xwSkpKKCsrY9asWbzxxhvsu+++TJ8+vd1t+PDhgO1nuXTpUp555plOaysttR2DGhoadtrem/eZNWsWixcv5q233trpGPPmzQsWWBvax7Nr9wP/CswPsQbVh+LxOJWVlV6c+o+aqGX3d+BMoH+ejncE8FTu/vPA6Xk6brOo5ecbzS84za5r77zzToeNo913352ysjLOPPNMJk6cyO23304ymeQPf/gD06ZN47zzzuPhhx/e6TUlJSXMnj2bb33rW2SzWW688UY2b97cMsk7wE9/+lNmzpzJ4YcfzoUXXsiECRPYsmULH3zwAY8++mhLQ/Mb3/gGDzzwACeffDJXXHEFBx10EA0NDSxYsIDPf/7zzJo1i0GDBjF+/HgeeeQRjjrqKIYNG8aIESOYMGFCr97nN7/5DSeccALXXntty6j2JUuW5CXfjvrCRk2YvxlvAmeIyDPYVYrW0GZqP2OMrl7ksVgstlPHb9VzUcnuAOAN7NJir2CnociHUcCnsGc8Xwb+H5DPWQ+jkp+vNL/gNLuunXfeeR1u/9WvfsWCBQtYsWIFr776KgMHDgRg0qRJ3HXXXZx++unccsstfOMb32h5zcUXX8z27du55JJLqKmpYfLkycyfP5/DDjus5Tn77LMPr7/+Oj/4wQ+48sorqampYciQIeyxxx4cf/zxLc9rHpF+1VVXceedd3L11VczdOhQPv3pT/PVr3615Xm//vWv+Y//+A9OOukkGhsbOeecc7j77rt7/D6VlZUsWLCASy+9tGUw0imnnMJtt93GySef7JxvLBb9C8kSVn8AEelu2J8xxoTadBeRycA7Cxcu7LB/iepaOp1m8+bNlJeX67f/Xgozu03A5bn7Z2NXG1oPVGGnouiu19oa4Krc/a9gl8rsyGvYedQAzmPH5fd80M+eG80vuKDZffTRR4BtaO3KetJHdtmyZUycOJEf/ehHXHbZZQWuMFzdfU7eeust9t9/f4Apxph8rgGSN2H+Rfksfbt4iQqZMYbGxkYvOjtHTVSyi2FXc/gTtkH5HtB+leVg9gcGYSerf578Njyjkp+vNL/gNDs3xhiy2SyxWEwHZwXgw+cutIanMea5sN5bFUYikeh0GgzVtShldxjwP9jL7c+Rv4ZnHJiJndbiQ2AV+VsbPkr5+UjzC06zcxOLxXTVLAc+LNUaWmcAEflIRPbrZN8UEfmo0DWp/Gr+5urDN7CoiVJ2A7ArDoHtmL0hj8eeyY5L98/l8bhRys9Hml9wmp0bY0zLrTMTJkzAGLPLXWbvCR8+d2H2Qp1A54uW9APGF64U1RdSqRQrVqzQaUUCiFp2R+Z+Guxl8XwZgV3JCGAhdm7PfIhafr7R/ILT7NwYY2hqavKiARVFPkynFPbwp84+WZOwXb+Ux+LxOCNHjtTBCQFELbtx2F9KgBexl93zpXmBuhT5a9RGLT/faH7BaXZuRIR4PK79OwPS6ZTaEJFzgHNabbpDRDa3eVp/YD9gQcEKU30iFotRVlYWdhleimJ2s4CPsN8IFwKH5+m4e2LXf14JPAscg/sfpijm5xPNLzjNzo2IeNF4iiofplMqdIVlQEXuZoAhrR433xLAA8C/Fbg2lWeZTIZNmzaRyWTCLsU7UczuQGBo7v6T5G9KCmHHWc/NwP/l4ZhRzM8nml9wmp0bYwzpdFovtQfkw+euoA1PY8wdxpipxpipwArgC82PW92mG2POM8asKGRtKv+y2Sz19fVks91N2araimJ2JcDs3P21wFtdPLe3pgODc/efwr1RG8X8fKL5BafZudHBWW58+NyFdk7WGDPRGJPP/3epiEkkEowZM8aL6R2iJqrZzcRetgB4Io/HjWMv5QN8ArguHhfV/Hyh+QWn2blpnk7Jh0vGUeTD507/yyqleqwUO6E82P6eH+bx2EcAzbP3/SWPx1VKKRUd2vBUfaapqYnly5fT1NQUdineiXJ2n2XH4J/H83jcAexo1C4F3nc4VpTz84HmF5xm17G7774bEaFfv34sX7683f4jjzySKVOmkM1maWxsZMKECYhIh7cjjzxyp9e+8sornHLKKYwbN47S0lJGjRrFjBkz+Pa3v73Te3d3mzBhQgGS6Fs+TOOl8z2oPhOPxxk+fLhOKxJAlLMrB2YALwBvY0ej79Zqv0vPrNnYke1p7IpGewQ8TpTz84HmF5xm17XGxkauvPJK7rnnng73N0+nBHDYYYfx4x//uN1zysvLW+7Pnz+fk046iSOPPJK5c+dSVVXFmjVreO2117j//vu56aabOOGEE3j55Zd3OsaMGTM47bTTWhqnAKWlnU0t7g8fZgTQ3wzVZ2KxGAMHDgy7DC9FPbtjgZeALPAocFEnz+vtTHyDsdM0PQssBpZhV5rorajnF3WaX3CaXdeOPfZY5s2bx2WXXcZ++7VfvLD1dEpDhgzhkEMO6fJ4c+fOZeLEiTzxxBM7NfbPPPNM5s6dC0BFRQUVFRXtXjtq1Khuj+8bH/rGRr9C5a1MJsPmzZu9mN4haqKe3QjsWU+wo9tX5vHYx2BH0EPwvp5Rzy/qNL/gNLuufec732H48OFcfvnlHe43xvQqu9raWkaMGNHhGWYfGmH55sPnLsy12vcUkc90su8zIhL0KpuKiGw2S11dnRfTO0SND9kdz44/II/m8bjDcG/U+pBflGl+wUUuu4ZqWPFHeP8O+7OhOtRyBg0axJVXXskTTzzBM888025/64Zn85yebW+tp1qaMWMGr7zyCpdccgmvvPKKF30c+1JkPnddCPPrwE+AkzvZdyJwUwFrUX0gkUiw2267eTG9Q9T4kN0I4NDc/bewE/Pmy3Hs+OP05wCv9yG/KNP8gotUdg3VsPQ2+PgeWPU/9ufS20JvfH7ta19j0qRJXH755e3m62yeTgngL3/5C4lEot3tuuuua3n+DTfcwMyZM7n11ls55JBDGDBgAIcddhg33HADW7duLei/Kwoi8bnrRpgNz0/T+dLMC3L7lVIR1vqs5yN5PO4IdizJuRg7yl0p1UvrXoRNi2DARBh+MAyYYB+vezHUspLJJNdeey2vvfYaf/jDHzp93syZM3n11Vfb3c4///yW5wwfPpwXXniBV199lRtuuIGTTz6ZpUuX8t3vfpepU6eyfv36QvyTVC+E2fAcDHT2daSBHavzKU+lUilWrly5y1/6CCLM7HozKn04cFju/jvAe3ms4wTs+rlgz3r2pi797LnR/IKLVHaN6yDbBMkh9nFyqH3cuC7curCDf6ZNm8Z//ud/7pRVNpttmYpq8ODBTJ8+vd2tqqqq3fGmT5/O5ZdfzoMPPsjq1av55je/ybJly1oGGO0qIvG560aYDc9PgIM62XcQsKa3BxSRQSIyV0T+KiLrRMSIyFUuRargYrEYgwcP3iU7eLuKSnY9GZV+Ijsmfv8T+VvDfTA71nD/CDt1U09FJT9faX7BRSq70gqIJaFpk33ctNE+Lm0/wrvQRIQbb7yRDz/8kDvvvHOn7a5TAiUSCebMmQPAO++843Qs30Tic9eNMCt8GLhCRGa13igiRwKXE6xr13Dgq9gFVh52LVC5KSkpoby83It5xaLGp+wGY0eiAywHXsvjsY9hxxKdD2Onb+oJn/KLIs0vuEhlVzEThkyF+o+h9hWoX2YfV8wMuzIAjj76aGbPns0111zT0h+ztw3PNWs6Pkf1j3/8A4DRo0e7F+qRSHzuuhHmPJ7XAJ8DnhKRpcAqYCywJ/AucFWAYy4HhhpjjIiMAC7IU60qgGw2y7Zt2ygrK/PiW1iU+JbdbGzH7C3kd7nLMuycoQ8Bq7GT1nc4FUYbvuUXNZpfcJHKrn8l7Hmx7dPZuM6e6ayYabdHxI033siBBx5ITU0NkydPxhjTMjJ706ZNLFy4sN1rSktLOeCAAwD43Oc+x9ixYznxxBPZa6+9yGazvPnmm9x0000MHDiQSy+9tKD/nrD5MKo9tIanMaZORA4Bvon9f8t4YB0wB7jFGNPr4Wim7fA4Fap0Ok1tbS3JZLJllKLqGd+y6wecBNzbB8f+LLZRW4sdwDQdu7xmV3zLL2o0v+Ail13/Shh3WthVdOqAAw7grLPOYt68ecCOKZQAXnrpJWbMmNHuNWPGjGHVqlUAXHnllTzyyCPcfPPNrFmzhsbGRqqqqjj66KP57ne/y9577124f0wE+DCPpxRrWy13xnMdcLUx5qqAx5gMvLNw4UIOPvjgfJanVJ/6B/YSwix6/+1yI3BF7v6XgJ5elMtgL2O0nqjlq8CBvXz/jrwB/CJ3fxZwZh6OqVSUfPTRRwBMmjQp5EpUlHX3OVm8eDFTpkwBmGKMWVy4ynpOl8zMEZGRQNse17sDNDQ0sHnz5sIXpVQAWeCnpaU0irAok+GCXo5y3Aw09esHQH0qxeZefIM+PhbjF63O8mxtamJzHi79TAImJJMsjcV4EjigsZGqIv3SrHZNqVSKeDzuxRkrFZ7mM8KdtUl8mLu0oA1PEfkN8ANjzMe5+10xxpjzu3lOPl2EvczfzqJFi6irqytgKUoFl4rF+HjqVMD2iyxfupSKhoYev35rIsHqffYB4PWVK9m+YUOv3r9+r72oKy0F4P9WrGDTxo29en1nKvv1Y8Gee2JEuHHrVk768MNerwWvVFQNGzaMiooKtmzZEnYpKsJSqRTr1q1jyZIlHe5fsSKfS3n0jUKf8ZwF/DR3/7N0PfNKoU9n3A482Gbb7sAjU6dOZdq0aQUux3/ZbJb6+noGDBgQfid7z7hk1wjMz52xBFhRWclpTU09nsJiI/BU7vXTKiqY0cszMFNF+HEySaMIJw0fntczkyYe54V4HAMMmjiRT3dSm3723Gh+wQXNbs2aNcTjcQYNGtSH1UVf8+CiWCyGiH61bKu2tpaRI0ey3377dbh/8eJIXl3fSUEbnsaYia3uTyjke3fHGFMD1LTe1vyh79+/P+Xl5WGU5b0hQ4aEXYK3gmbXyI55NQHWAm/068esTp7fVqbV6wckk/T2k18O/BBoAkbmeXDFmcASoA6Yn0xyENDZ/6b1s+dG8wsuSHbNK+z4MB2OCo+IkEgkOm2T+NBWCe2rrIiME5EOFxUVkbiIjCt0TSq/mqcV8WF6h6jJd3YPA5vycqSeGQKM7IPjlrFjYFE97S9RNNPPnhvNLziX7Ip1sG9vGGPIZDKaRSe6y8WH39kwr6F8DBzQyb79cvt7TUSOE5HTsAuqAOwjIqflbmVdvVblVzqdpqampmVqDNVz+cpur9zP7cDvKXz/lb5wAPYPBMAr2LXc29LPnhvNL7ig2cViMW1wsWPwzK6eQ0eaG+VddUHwYXBamA3PrjpvlBD8/5F3YE+ENA9eOj33+EH65iSM6kQikWDcuHEkEh2e2FZdyFd2k9mxLu0i4GXXwiJAgLOwc4eCbVC3HTqlnz03ml9wQbMrLS0lk8lQU1OzSze6RIRkMqn9O9tIp9OsWbOGTCbDwIEDO31ePB79yYrCrrDdb5eIlALHAesDHTBifUd3ZSKifzwCymd2ZwLvYftFPgB8Cru2rM+GAqcC84ANwP3Aea3262fPjeYXXNDsRo0aRWNjIxs2bKCuro6SkhL9b6BaBls1n0EvKytj6NChnT7fh89MQc94isgcEcmISAbb6FzY/LjV9m3A97GLlCiPpVIp1qxZQ6qX80iq/P03luAAABjaSURBVGY3APjX3P3twO8ojkvuR2DP6AIsBP7eap9+9txofsEFzS4WizFu3DiGDBmyS5/xy2azNDQ0eNFXsRBEpGW2gzFjxjBu3Lguz2r68Dtb6DOe/4edtkiw82b+ETvotrVG7FXBeYUtTeWbiFBaWrrL/gF1ke/spmBXIHoROyr8aeDontSRl3fvGwKcA1yNHWj0e+z8Z0PQz54rzS84l+xisRhVVVV9UJU/midHLy8v9+KycdT48Dtb6OmUHgMeAxCRAcA1xphAg4hU9MXjcYYNGxZ2GV7qi+xOxy6lWQs8BPwTMCGv71B4g4F/AX6JvVTyKxrYh4PZGn8PhsEQpvJZnieBjivsDf3dDU6zc6P5ufGhsR7a4CJjzHna6Cxu2WyW7du36yWTAPoiu37AV7C/9BngTmxjzXfTgBnAWp7mCX7Hc4zHZNOY7WVszL7BnxjAq1wYdple0d/d4DQ7N5qfGx9yC3VJChGZICK/FJGlIlKb+/lLEZnY/atV1KXTaaqrq3VKlgD6KruJwBdy92spnv6eU7iOOC8A8KY5kdSW86hYdhqSGgAGPuQXvM8dIVfpiYZq0sseovrtB0gvewgaqsOuyB+anRvNz01DNZlPngq7im6Fdk5WRPYHnsXOCf037NiASuBc4AwROdIY82ZY9Sl3iUSCsWPH6kocAfRldkdhR7m/DbwBPAkck/d3KawPmMNRVPCX7PWM3jiZ17eN4nM191NRPYtHDn2a7cl6XudS9tAzn11rqIalt5HYuIix2Swl22Kw5U3Y82LoXxl2ddGm2bnR/Nzk8ouveSnsSroV5hnPW4B1wB7GmFnGmLOMMbOAPbFLV94cYm0qD5pH4/nQ2Tlq+jI7wX67a55S6SHgnby/S6FlGEo1362pgsZatvWr4K49LiA1aHdOePkIMGCI/mjP0K17ETYtQgZOJD7iQGTgBNi0yG5XXdPs3Gh+bprzKxsbdiXdCrMX6kHA+caYFa03GmOWi8hVwF2hVKXyJp1OU1tby/Dhw73o8BwlfZ3dAOBCYC52TfVfAd/FXnLwTSN1uXvCoVs+YnlTHdf97G1+/7/P8CMyDEptpT432/x30JV4u5TeAuntmFiSweUDSZYYJFMPyTeg9Pqwq4u2xnXQVIcpeZVYPMmk0QOJNdVC2SoY9Mewq4u+Le/DttVkkx8yYsQI9h4/kJJtH8OQP8LImrCri76a52HTB6yqHxF2Jd0KszVQl7t1ZBOwuYC1qD4Si4XajdhrfZ3dbthJ13+Jnd/z58AVffqOfaOUwbl7hlTpAL64+q988r1zePuayymVembXPk52rx+AwJms6PJYu7wVf4SP7yHdf3c2mtEMlU+IN3wEE78E404Lu7po0+zcdJhfCUw8TfPriRUj4eMG3lozmOsjftouzFbBPOCCTvZ9BbivgLWoPhCPx6moqNCznQEUKrtpwOdz92uwk+w29ek79g3BLk/4v2O/RcmQyVy04l4mNCwmlt7Mrz41jvflYGIti2yqTlXMhCFTiTd8SMW2p23DachUu111TbNzo/m5ac5v+8qwK+lWmC2C14HTROT/sI3MauyVvrOwa6o/KCKnNj/ZGPNQKFWqwIwxpFIpEomE9vPspUJm93lgDXZ03wf42cdlGj/n73yVxlgt9+/7Q4Zsn8RemRW8NuAsjPTnec5hBnuGXWb09a+EPS/G1LxIqmE9if4jkJEzdXBHT2h2bjQ/Ny35DQeeC7uaLoXZ8Lwn93M3YHon+5v/j2sAHRrtmVQqxerVqxk9ejTJZDLscrxSyOwEe8l9C7AUvLwYvQdfoZ6PWMINIIZNJdUk1u7O7OTdPJb8CkOYycPsx0Ts6kaqC/0rSVWdZD9/Vfq72yuanRvNz03/StIVs8KuolthNjyjn45ykkgkGD16NIlEIuxSvFPo7BLYNWx/DKwqyDvm3/5cz/5cz4ucxtrEUzB6EQcnjmYWX+cXQAq4FbgMiP64z3Dp725wmp0bzc+ND13bQqvQGLMgrPdWhSEi+o01oDCy6w9cAnwP8HnK/5n80Z7GbRXfvwL/DTRg53H7JjAmjOI8ob+7wWl2bjQ/Nz50a9Mhx6rPpNNp1q1bpysXBRBWdoOBq4AKoBS7nruP2uZ3KHaterBdCm4Cot8FPzz6uxucZudG83PjQ26hnpMVkT2AfwP2xp5wac0YY44qfFUqn3xYNzaqwsquArgGe2m6NJQK8qNtfkcDWeBPQD3wE+AbwPiCV+YH/d0NTrNzo/kVtzCXzJwCLAQ+wZ5YeRsYgb0CthL4MKzaVH7E43FGjRoVdhleCju7GH43OjvL7xjsH70HgG3YxueFwF4FrS76wv78+Uyzc6P5ufGhj2eYl9p/CDwBTMb2yDrfGLMbcCLQD7gyxNpUHhhjSKfTGGPCLsU7mp2brvL7LPDPufvbgZ8BrxSwNh/o5y84zc6N5ufGh9zCbHhOw/b3bz6nHgMwxszHDq7V9dk8l0qlWLVqFamUrpHdW5qdm+7yOwK7ekUJkAF+AzyGnbdN6efPhWbnRvNz40MfzzAbnkOBDcaYLLY72dBW+17DNkyVx+LxOJWVlV6c+o8al+y08dSz/D6N7ePZ3Ln8YeBu7B+jXZ3+7gan2bnR/NyUlER/yvMwG56fYPt0gl0w5YhW+/YFtha8IpVXsViMfv366XrtAeQru+hPrNE3eprfnsB32PGtdyEwF6jt2/IiT393g9Ps3Gh+bnzILcwKX8TOcgJwL3CFiNwlIrdjL7M/GlplKi/S6TQbNmzw4tR/1Gh2bnqT32js3KV75B6vwHZA/0fflRd5+vkLTrNzo/m58SG3MM9lX4f9mw9wI3ad9n/GXin8A3aBEeUxYwyNjY1edHaOGs3OTW/zK8dOKv9H4Bns5ZafArOBkwl53rkQ6OcvOM3Ojebnxofcwly56ENyUyYZYzLYRVMuCaselX+JRIKqqqqwy/CSZucmSH4lwBnYeT3vBZqAv2LPfF6A/Wa8q9DPX3CanRvNz40PS41GvzOA8pYxhmw268U3sKjR7Ny45HcIdi635onlVwLXYhuhu8q01vr5C06zc6P5ufEht1AbniIyQUS+IyI/F5HftLn9OszalLtUKsWKFSt0WowANDs3rvmNwg46+hx2gFYKu+LR9dg+oMVOP3/BaXZuND832sezCyJyAvAQ9gpXDdDY5inRb7arLsXjcUaOHKnTYgSg2bnJR35x4FRgKnAPsBbb6LweOwn9CUCZe6mRpJ+/4DQ7N5qfGx+mUwp7cNFLwJnGmJoQ61B9JBaLUVZWrP9r7luanZt85rcH8F/AX4DHsZfbn8JOvXQScDjF12dJP3/BaXZuND83Op1S1/YAbtRGZ/HKZDJs2rSJTCYTdine0ezc5Du/BHZ0+5XA7rltW4F5wA+AtymuSzT6+QtOs3Oj+bnxIbcwG57LgYEhvr/qY9lslvr6erLZXWVIRv5odm76Kr8xwH8AXwWG57atBn6OvQS/iOJogOrnLzjNzo3m58aH3MK81P5D4DIRecwYsy3EOlQfSSQSjBkzJuwyvKTZuenL/AQ4ELu82jPYNd4bsN+kbwMmAMcC++HvJXj9/AWn2bnR/Nz4MJ1SmA3Pg4CRwAci8iztV6kzxphLC1+WUkp1L4Ed9X448DS23+d2YBnwC+x6wJ8FDgP6hVOiUkpFTpgNz4tb3T+rg/0G0Ianx5qamlizZg1VVVUkk8mwy/GKZuemkPmVAScCR2EboM8A24D12CXY/geYAcwExvZpJfmjn7/gNDs3mp8bH6ahCnPlIl+vQqkeisfjDB8+XKfFCECzcxNGfs0N0GOAl7GN0BrsWdBnc7fx2Abop4H+Baus9/TzF5xm50bzc6PTKaldWiwWY+BAHT8WRL6ykzzU4qMwP3ulwJHAEdjBRs9il90E2w90OfAAMAWYjp0nNGqX4vV3NzjNzo3m58aH6ZTCnEB+EbYv/j06uKg4ZTIZ6uvrGTBggBffwqJEs3MThfxi2AFG+2E7sP8NO3HxRiANvJm7JbCN0AOAfYBBYRTbRhTy85Vm50bzc6PTKXVtHXAH8ImI3Cwie4RYi+oD2WyWuro6L6Z3iBrNzk3U8huOvQz/Q2zH9UPZsepRCngD+A12qqYbgP/FnhkNa2qmqOXnE83OjebnxofcJMwF5UVkH+wgo3/B/h1+CrjNGPO/oRXViohMBt5ZuHAhBx98cNjlKNUj29kxKu904OgQa1GdSwNLgNewZz4bOnjOAOCfgD2xK27shr9TNCml+t7ixYuZMmUKwBRjzOKw6+lIqH08jTHvAheJyOXAecCFwCMishy4Hfi1MWZjmDUqpVRfiGMvsU8BMsCHwDu52ye559QDb+VuYPuC7o6dK3QCdrDS4EIVrJRSeRCJwUXGmC3Az0TkD8C9wCxgLnCViPwS+C/tB+qfVCpFdXU1lZWVXkxqGyWanRvf8ivBntXcEzgV2w90MbA0d2v+9r09t731aYwh2AboeGB07laB25lR3/KLEs3OjebnRqdT6iERmQF8HTgN2+XpDuzAz5OxZ0HHAGeGVqAKJBaLMXjwYC9G2UWNZufG9/yGYqddmont51mLbYC+D3wErGVH/89NudtbrV4fB6qwjdAq7EodI7EN0p6MoPc9vzBpdm40Pzc+5BbmqPZ+wNnYBuf+2L70/wncZYypyz3teRF5C7sUck+POxC4FvgiMAzbjeoGY8z9eSxf9UBJSQnl5eVhl9FrWVKs40Wa2MgAJjCUA5ACT0zka3ZRUUz5CXYVpBHYQUlgz3yuwK6S1HxrvfRbGliZu7U1ENsAbb4Nw541HZq79ae48is0zc6N5ufGh5kAwjzj+Qn2793zwBeAR0zHI53ew/ax76mHsPMzX4E9SXA2cJ+IxIwx89xKVr2RzWbZtm0bZWVlXnwLMxg+4Bcs5gdsZ03L9iHsxwHcwiiOLFgtvmUXNcWeXz92XJpvth1YDazJ/fwkd39Tm9duzd0+7uTYSWCwMQxoaqIikWBwLEY5tsE6qNXPQdg5S3fVuWI7U+yfvb6m+bnxYVR7mA3PPwM/NcYs6upJxphX6GF3JRE5HpgNnG2MuS+3+VkRGQ/8SEQeMMZEf5KrIpFOp6mtrSWZTHqx9Nm7XM8i/pP+jGEKVzOQ3VnP3/iYu1nAMXyGxxnFZwtSi2/ZRc2umF8/YFLu1loDdu66trcabKO07bf9JqA6m2VbUxNl8ThdnT+JYxugZdgzpW1/Nt9vftwP21hNtvqZpLgar7viZy+fND83PszjGeaSmRf0wWFPwX6Zf7DN9t8C84CDsfM49866v0HDeOhf6VzgLqOhmuS6FxnftA6qK6BiZqTza2A17/B9BjOVo3ieJEMAmMA/sztf5WkO4+/8O8fxTt9fdvcsuyhKJpOMHz8+7DIioT8wLndrKw3UYRugG3O3TcDGkhI2DhrEJmALtuN9R9KtXucigW2Itm2UlmL/JxXPPaej+x09bt5WkrvFcrfWj9tu7+xnb3/b9bPnRvNz48OArKgMLhoGfAc7s8gnwM8Czj81BfiHMSbdZvvbrfb3uuH518wGPqp5HqqOgeSQAGXtYpo2Qc3zUL8CTBpS9WCykc5vFa+ygtP5FN9iE21r3I+PuZ01PMYq3mfQThc48ywP2bX98CvVmTh2cvvhXTzHYM+CbsF+q9/S6tb8eBv2zGpDm/s9nSU6lbtt7fW/oO8JOxqosVaPpc2to23d7e/JNmjf+JU227rb3/Y5hdjfUV090Zdf63t77CjV0lOr+ui4+VTQhqeI/Bj4ojFmXKttA4BXsdPSNf+3OFNEDjLGvNfLtxiOHfTZ1oZW+zurrXnQZ2t7ATy9YQh//3ArrF6oZ556oqEaGrZiSsbSZPqTlAakOtr51bGFBvZnBSC82W5/I6PYyP68zwf0ow9n9spzdu+lUgzyoM9PvmUyGerq6hg8eLAXne2jprv8SrAd9Lv6KtTcYG0EtovQKEJTbltzQ7MJSOe2p4CUyM4/c/sz2LlO07mfGZHIfsEy2SxNTU0kk0lE+yj2mubnpu7995vvRrafQqHPeB4KtB1dfjEwEbgZuBq7XPGfsIODzgvwHl19ye5q30XAnI52LPjyZQHKUCp8j4RdgFJKqTDshl2NN3IK3fCcBNzSZtuJ2L7u38kN/FkoIj/BNkh7q5aOz2oOy/3c0MG+ZrfTvm/oVOA+7PyiSwLUo+xCLFPCLsJTmp0bzc+N5hecZudG8wsuCbwOLAi7kM4UuuE5BHbMUyMicezURw+3GW3+Bnbe495aBJwlIvE2/Tyn5n6+09kLjTE12IGeLURaemEsieqap1EnImh2wWh2bjQ/N5pfcJqdG83PTS6/uu6fGY5Cd6BYy84NymnYwYevtXleFts1qLf+jJ1m7gtttp+DndrulQDHVG6uDrsAj2l2bjQ/N5pfcJqdG83PTaTzk47nbO+jNxN5CDvt2zHGGCMiP8VeUv//7d1/qN11Hcfx50tuTGrKMMMssfVXxtIIFDUIlphJKJWSdKekFYV/hPpHmgWBLDQGy4ZEkURGlCuNiaRZ/qBmRI4kbK2suOUotWhzKHfZtOW7P77f5eGc0/L+2Oe4e58POJzz/Zxzz+d971+v+3l/v5/vaVX1y4HPXQ5cVVUnzWOOe4FTgU8BM8A08DHgkqr69hy/aw39kr//fUmSJC1M61b7BuBnwO+T7AbOAH46GDp759Nd6T4fFwDXA+t58ZaZ094yU5IkabKattr7uxC9l67tfRTwNbpN3/8ryWuBE5jnBblVtbeqrqyq46tqRVW9dQGhcxfdkvWuef68JEmSek1b7ZIkSVq+3J1VkiRJTRg8JUmS1ITBU5IkSU0YPCVJktSEwXOMJCuTbEryZJJ9SR5J8sFJ1yVJknQ4a72P5+FiC92tPK8F/gCsAzYnOaKqbp1oZZIkSYcpt1MakuQ9wN3AuqraPDB+L7AGOHHovvKSJEl6CWy1j3o/sBe4fWj8FuB1wOnNK5IkSVoCDJ6j3gI8WlX7h8a3D7wvSZKkOTJ4jno1sGfM+J6B9yVJkjRHBs/xDnbiqyfFSpIkzYPBc9RTjF/VPKZ/HrcaKkmSpP/D4Dnq18CbkwxvNXVy/7yjcT2SJElLgsFz1B3ASuDCofFLgSeBbc0rkiRJWgLcQH5IVd2T5D7gK0mOBmaAaeBc4BL38JQkSZofN5AfI8lK4HrgIrpzO38HfL6qvjPRwiRJkg5jBk9JkiQ14TmekiRJasLgKUmSpCYMnpIkSWrC4ClJkqQmDJ6SJElqwuApSZKkJgyekiRJasLgKUmSpCYMnpIkSWrC4ClpyUhSL/GxNsnq/vVlk677gCQ7B2r8UuO5Vw39jT7Zcn5Jy8PUpAuQpEV05tDxZ4F3AmcNjf8WeK7//B8b1DUXPwA+B/yt8byzdH+P44EtjeeWtEwYPCUtGVX10OBxkl3AC8PjA/7X+CTtOki9h0xV/Rt4KMnq1nNLWj5stUtalsa12pNc14+dkuT2JM8k2ZPkxiRTSd6U5IdJZvu2+DVjvvfoJBuTPJbk+SRPJNmU5FULqHVtX9e6JBuS/DXJ3iTfT3JckqOS3Jxkd/+4JcnKoe/4QJJt/e/0bJI/Jfn6fGuSpPlwxVOSRt0GfAv4KvAu4BrgFcDZwJeBjcA6YEOSmaraApDklcBW4ATgBmA7sAZYD5yc5OyqqgXUdQPwY+AyYHVfx2ZgP/ArYBp4W/+5WeCKvq4zge/2j+uAfcAbGD0FQZIOKYOnJI26uapu7F/fn+Qc4BPABVV1B0CSnwDnARfz4jmRVwCnAKdX1cP92ANJngC+B5wL3LOAurZX1YcPHCQ5CbgKuKmqru6H7+uD5sV9PQBvBwJcXlXPDHzfNxZQiyTNma12SRp119Dxo0AxEBqraj8wQ7dyeMB5wA7gkb41P5VkCvhR//NrD0FdAHePGT9moN3+i/75tiQXJXn9AuuQpHkxeErSqD1Dx88Dz1bVvjHjRw4cH0e34vmvoccs3YrjsYegroONHwlQVQ8C76Prcn0TeDzJjiTTC6xHkubEVrskLZ7dwD+Bjxzk/YmoqjuBO5OsAM4APg3cmmRnVf18UnVJWl4MnpK0eO4CPgM8VVWPTbqYcarqOWBrkqeBd9NdjGTwlNSEwVOSFs8m4ELgwSRfpLuq/QjgROAc4AtVta11UUnW011p/wDwOLAKuJLuNICtreuRtHwZPCVpkVTVP5K8A7gW+DjwRrrW+5+B+4GdEyptG3AqsAF4DfA08DBwVlX9ZkI1SVqGsrAt5SRJiyXJTroVyI/S3XHphcbzT9FdpT8DXF1VG1vOL2np86p2SXp5+RBdC/ymlpMmWdXPO9NyXknLi612SXr5OB9Y0b/+e+O5Z4HTBo7/0nh+ScuArXZJkiQ1YatdkiRJTRg8JUmS1ITBU5IkSU0YPCVJktSEwVOSJElNGDwlSZLUhMFTkiRJTRg8JUmS1ITBU5IkSU0YPCVJktTEfwBUZ84yxlmELgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "resolution = .1 # [ms]\n", "delays = np.array([1., 5.]) # [ms]\n", "\n", "# settings for plotting debug information\n", "show_all_nest_trace_samples = True\n", "\n", "for delay in delays:\n", " dendritic_delay = delay\n", " for spike_times_idx in range(len(pre_spike_times)):\n", " max_t_sp = max(np.amax(pre_spike_times[spike_times_idx]),\n", " np.amax(post_spike_times[spike_times_idx]))\n", " sim_time = max_t_sp + 5 * delay\n", " trace_nest_t, trace_nest = run_post_trace_test_nest_(\n", " pre_spike_times[spike_times_idx],\n", " post_spike_times[spike_times_idx],\n", " resolution, delay, sim_time, tau_minus,\n", " show_all_nest_trace_samples)\n", " trace_python_ref = run_post_trace_test_python_reference_(\n", " pre_spike_times[spike_times_idx],\n", " post_spike_times[spike_times_idx],\n", " resolution, delay, dendritic_delay, sim_time, tau_minus)\n", "\n", " title_snip = \"(delay = \" \\\n", " + str(delay) \\\n", " + \")\"\n", " plot_run(\n", " trace_nest_t, trace_nest, trace_python_ref,\n", " pre_spike_times[spike_times_idx],\n", " post_spike_times[spike_times_idx], resolution, delay,\n", " dendritic_delay, trace_match_atol, trace_match_rtol,\n", " sim_time, title_snip)\n", " assert nest_trace_matches_ref_trace(\n", " trace_nest_t,\n", " trace_nest,\n", " trace_python_ref,\n", " pre_spike_times[spike_times_idx],\n", " post_spike_times[spike_times_idx],\n", " resolution, delay, dendritic_delay,\n", " trace_match_atol,\n", " trace_match_rtol,\n", " sim_time,\n", " debug=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "-----------------------------\n", "### License\n", "\n", "This file is part of NEST. Copyright (C) 2004 The NEST Initiative\n", "\n", "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.\n", "\n", "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." ] } ], "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.7.6" } }, "nbformat": 4, "nbformat_minor": 2 }