From d1d3d2541f250e9e3f3cc785b4cee0e36989c44b Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Thu, 22 Feb 2024 01:34:07 -0800 Subject: [PATCH 1/6] add GL model tutorial notebook --- .../gl_model/gl_model_tutorial.ipynb | 1310 +++++++++++++++++ doc/tutorials/tutorials_list.rst | 4 + 2 files changed, 1314 insertions(+) create mode 100644 doc/tutorials/gl_model/gl_model_tutorial.ipynb diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb new file mode 100644 index 000000000..0eea8f98b --- /dev/null +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -0,0 +1,1310 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Galves-Löcherbach Model\n", + "\n", + "\"GL model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function Φ(V) of membrane potential V. By subsuming all sources of randomness into a single function, the Galves-Löcherbach (GL) neuron model simplifies the analysis and simulation of noisy spiking neural networks.\" [DOI: 10.1038/srep35831]\n", + "\n", + "Reproduce the results of: Antonio Galves, Eva Löcherbach, Christophe Pouzat, Errico Presutti, \"A system of interacting neurons with short term synaptic facilitation\". arXiv:1903.01270v3 13 Sep 2019\n", + "\n", + "Tsodyks-Markram model formally equivalent for synapse (when set to no depression, only facilitation)\n", + "\n", + "Morrison A., Diesmann M., Gerstner W. (2008) Phenomenological models of synaptic plasticity based on spike timing. Biological Cybernetics 98:459–478.\n", + "DOI: 10.1007/s00422-008-0233-1.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Preliminaries\n", + "-------------" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from typing import Dict, Optional\n", + "\n", + "import matplotlib as mpl\n", + "\n", + "mpl.rcParams['axes.grid'] = True\n", + "mpl.rcParams['grid.color'] = 'k'\n", + "mpl.rcParams['grid.linestyle'] = ':'\n", + "mpl.rcParams['grid.linewidth'] = 0.5\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import nest\n", + "import numpy as np\n", + "import os\n", + "import random\n", + "\n", + "from pynestml.frontend.pynestml_frontend import generate_nest_target\n", + "\n", + "import logging\n", + "logging.getLogger('matplotlib.font_manager').disabled = True" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def fI_curve(neuron_model: str, t_stop: float = 1000., custom_model_opts: Optional[Dict] = None):\n", + " I_stim_vec = np.linspace(0, 1E-9, 40) # [A]\n", + " rate = float(\"nan\") * np.ones_like(I_stim_vec)\n", + "\n", + " for i, I_stim in enumerate(I_stim_vec):\n", + " nest.ResetKernel()\n", + " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", + "\n", + " dc = nest.Create(\"dc_generator\", params={\"amplitude\": 1E12 * I_stim}) # 1E12: convert A to pA\n", + " nest.Connect(dc, neuron)\n", + "\n", + "# multimeter = nest.Create('multimeter')\n", + "# nest.SetStatus(multimeter, {\"record_from\": [\"U\"]})\n", + "# nest.Connect(multimeter, neuron)\n", + "\n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr)\n", + "\n", + " nest.Simulate(t_stop)\n", + "\n", + "# Vms = multimeter.events[\"U\"]\n", + "# ts = multimeter.events[\"times\"]\n", + "\n", + " rate[i] = sr.n_events / t_stop * 1000\n", + " \n", + " return I_stim_vec, rate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Normalized model with calcium dynamics\n", + "---------------------------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `R` variable represents the calcium concentration of the presynaptic neuron. For convenience (and at the cost of some redundancy), we store it here in the NEST synapse object." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_ca_synapse_model = '''\n", + "synapse syn_gl_ca:\n", + " state:\n", + " R_pre real = 0.\n", + "\n", + " parameters:\n", + " the_delay ms = 1 ms @nest::delay # !!! cannot have a variable called \"delay\"\n", + " lmbda real = 2.1555489309487914 # residual calcium decay rate\n", + "\n", + " onReceive(incoming_spikes):\n", + " R_pre += 1\n", + " deliver_spike(R_pre - 1, the_delay)\n", + "\n", + " input:\n", + " incoming_spikes real <- spike\n", + " \n", + " output:\n", + " spike\n", + " \n", + " update:\n", + " R_pre *= exp(-lmbda * 1E-3 * resolution()) # leakage\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Neuron:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_ca_neuron_model = '''\n", + "neuron gl_ca:\n", + " state:\n", + " U real = 0 # membrane potential\n", + "\n", + " parameters:\n", + " a real = 3.\n", + " alpha_over_N real = 1.0777744654743957 # synaptic strength\n", + " beta real = 50 # membrane potential leak\n", + " reset_after_spike boolean = true\n", + "\n", + " input:\n", + " incoming_spikes real <- spike\n", + "\n", + " output:\n", + " spike\n", + "\n", + " function phi(U real) real:\n", + " if U <= 0:\n", + " return 0\n", + "\n", + " #tmp real = (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", + " #println(\"phi({U}) = {tmp}\")\n", + " return (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", + "\n", + " equations:\n", + " kernel K = delta(t)\n", + " \n", + " # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n", + " U' = -U / (1E3/beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", + "\n", + " update:\n", + " # integrate spike input\n", + " integrate_odes()\n", + "\n", + " # emit spike?\n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * phi(U):\n", + " emit_spike()\n", + " if reset_after_spike:\n", + " U = 0 # reset membrane potential\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1,GLOBAL, INFO]: List of files that will be processed:\n", + "[2,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml\n", + "[3,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml\n", + "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/tmp/nestml-gl-ca-target'\n", + "[5,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml'!\n", + "[6,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", + "[7,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[8,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[9,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[10,gl_ca_nestml, WARNING, [30:9;30:23]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", + "[11,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[12,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[13,gl_ca_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", + "[14,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[15,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml'!\n", + "[16,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n", + "[17,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[18,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[19,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n", + "[20,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[21,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[22,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[23,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", + "[24,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", + "[25,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[26,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[27,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[28,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[29,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[30,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[31,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n", + "[32,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"a\": \"3.0\",\n", + " \"alpha_over_N\": \"1.0777744654743957\",\n", + " \"beta\": \"50\",\n", + " \"reset_after_spike\": \"true\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n", + "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", + "INFO:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "DEBUG:Splitting expression -0.001*U*beta (symbols [U, U])\n", + "DEBUG:\tlinear factors: Matrix([[-0.001*beta], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "DEBUG:Splitting expression -0.001*U*beta (symbols Matrix([[U]]))\n", + "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0.0]])\n", + "INFO:Dependency analysis...\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n", + "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_before.dot\n", + "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph_before.dot'\n", + "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_before.dot']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[33,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[34,GLOBAL, INFO]: Analysing/transforming neuron 'gl_ca_nestml'\n", + "[35,gl_ca_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_ca_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Generating propagators for the following symbols: U\n", + "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0]])\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " },\n", + " \"parameters\": {\n", + " \"beta\": \"50.0000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"U\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"U\": \"U*__P__U__U\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[36,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", + "[37,gl_ca_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[38,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[39,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[40,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[41,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[42,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_ca_nestml.\n", + "[43,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_ca_nestml'\n", + "[44,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.cpp\n", + "[45,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.h\n", + "[46,gl_ca_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n", + "[47,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/syn_gl_ca_nestml.h\n", + "[48,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n", + "[49,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/CMakeLists.txt\n", + "[50,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.h\n", + "[51,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.cpp\n", + "[52,GLOBAL, INFO]: Successfully generated NEST module code in '/tmp/nestml-gl-ca-target' !\n" + ] + } + ], + "source": [ + "with open(\"nestml_gl_ca_synapse_model.nestml\", \"w\") as nestml_model_file:\n", + " print(nestml_gl_ca_synapse_model, file=nestml_model_file)\n", + "\n", + "with open(\"nestml_gl_ca_model.nestml\", \"w\") as nestml_model_file:\n", + " print(nestml_gl_ca_neuron_model, file=nestml_model_file)\n", + "\n", + "generate_nest_target(input_path=[\"nestml_gl_ca_model.nestml\", \"nestml_gl_ca_synapse_model.nestml\"],\n", + " target_path=\"/tmp/nestml-gl-ca-target\",\n", + " module_name=\"nestml_gl_ca_module\",\n", + " suffix=\"_nestml\",\n", + " logging_level=\"DEBUG\"#WARNING # try \"INFO\" for more debug information\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "nest.Install(\"nestml_gl_ca_module\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Postsynaptic response\n", + "\n", + "Note that due to the residual calcium dynamics, the synapse is facilitating.\n", + "\n", + "The decay should correspond to the $\\beta$ parameter.\n", + "\n", + "When a neuron spikes, it increases the potential of each postsynaptic partner by $\\alpha R/N$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def measure_postsynaptic_response(neuron_model: str,\n", + " synapse_model: str,\n", + " t_stop: float = 2250.,\n", + " V_m_specifier: str = \"V_m\",\n", + " custom_model_opts: Optional[Dict] = None):\n", + " spike_times = np.array([100., 200., 250., 2000.])\n", + "\n", + " nest.ResetKernel()\n", + " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", + " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", + " #dc = nest.Create(\"dc_generator\", params={\"amplitude\": 1E12 * I_stim}) # 1E12: convert A to pA\n", + " #nest.Connect(dc, neuron)\n", + " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", + " nest.Connect(spike_generator, neuron, syn_spec={'synapse_model': synapse_model})\n", + "\n", + " multimeter = nest.Create('multimeter')\n", + " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier]})\n", + " nest.Connect(multimeter, neuron)\n", + "\n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr)\n", + "\n", + " nest.Simulate(t_stop)\n", + "\n", + " ts = multimeter.events[\"times\"]\n", + " Vms = multimeter.events[V_m_specifier]\n", + " \n", + " return ts, Vms" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ts, Vms_gl = measure_postsynaptic_response(\"gl_ca_nestml\", \"syn_gl_ca_nestml\", V_m_specifier=\"U\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.set_xlabel(\"$t$ [ms]\")\n", + "ax.plot(ts, Vms_gl, label=\"gl\")\n", + "ax.set_ylabel(\"U\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Firing rate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This should correspond to the Phi(U) function in the neuron (see plot below for the theoretical curve)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "nest.ResetKernel()\n", + "nest.resolution = 1. # check that results are independent of resolution...\n", + "\n", + "a = 3.\n", + "\n", + "t_stop = 25000.\n", + "\n", + "U_range = np.linspace(0., 10., 12)\n", + "n_spikes = np.nan * np.ones_like(U_range)\n", + "for i, U in enumerate(U_range):\n", + " neuron = nest.Create(\"gl_ca_nestml\", params={\"reset_after_spike\": False})\n", + " neuron.beta = 1E-99 # a very low value, to prevent the membrane potential from decaying\n", + " neuron.U = U\n", + " neuron.a = a\n", + "\n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr)\n", + "\n", + " nest.Simulate(t_stop)\n", + "\n", + " n_spikes[i] = len(sr.events[\"times\"])\n", + "\n", + "spike_rate = n_spikes / (t_stop / 1E3)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "_U = np.linspace(0., 10., 100)\n", + "Phi_of_U = (4 * a) / (1 + np.exp(a - _U)) - (4 * a) / (1 + np.exp(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(_U, Phi_of_U, label=\"theoretical\")\n", + "ax.set_xlabel(\"$U$\")\n", + "\n", + "ax.plot(U_range, spike_rate, marker=\"o\", label=\"numeric\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$U$\")\n", + "ax.set_ylabel(\"Firing rate [Hz]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Network dynamics" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "foo=None\n", + "def run_simulation_in_chunks(sim_chunks, sim_time, syn_recordables, neurons):\n", + " global foo\n", + " sim_time_per_chunk = sim_time / sim_chunks\n", + "\n", + " # Init log to collect the values of all recordables\n", + " log = {}\n", + " log[\"t\"] = []\n", + "\n", + " # Initialize all the arrays\n", + " # Additional one entry is to store the trace value before the simulation begins\n", + " for rec in syn_recordables:\n", + " log[rec] = (sim_chunks + 1) * [[]]\n", + "\n", + " # Get the value of trace values before the simulation\n", + " syn = nest.GetConnections(target=neurons, synapse_model=\"syn_gl_ca_nestml\")\n", + " print(str(len(syn)) + \" synapses in the network\")\n", + " foo=syn\n", + " for rec in syn_recordables:\n", + " log[rec][0] = syn.get(rec)\n", + " \n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Run the simulation in chunks\n", + " for i in range(sim_chunks):\n", + " sim_start_time = i * sim_time_per_chunk\n", + " sim_end_time = sim_start_time + sim_time_per_chunk\n", + "\n", + " nest.Simulate(np.round(sim_time/sim_chunks))\n", + " \n", + " # log current values\n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Get the value of trace after the simulation\n", + " for rec in syn_recordables:\n", + " log[rec][i + 1] = syn.get(rec).copy()\n", + " \n", + " #nest.Cleanup()\n", + " \n", + " return log\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "N = 100 # Number of neurons in network XXX: 1000 in the original paper\n", + "conn_prob = 1.\n", + "\n", + "a = 2.\n", + "\n", + "beta = 50.\n", + "lmbda = 10.\n", + "alpha = beta * lmbda\n", + "\n", + "U_0 = 1.#0.79555 # initial membrane potential\n", + "R_0 = .2#1. # initial residual calcium\n", + "\n", + "U_range = .1 * U_0\n", + "R_range = .1 * R_0" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9900 synapses in the network\n" + ] + }, + { + "data": { + "text/plain": [ + "'nest.Simulate(sim_time)\\n\\nneuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\\n\\nfig, ax = plt.subplots(nrows=2)\\n\\nU_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\\n# R_avg = np.zeros_like(U_avg)\\nfor neuron_id in range(1, N+1):\\n idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\\n times = multimeter.get(\"events\")[\"times\"][idx]\\n U = multimeter.get(\"events\")[\"U\"][idx]\\n #R = multimeter.get(\"events\")[\"R\"][idx]\\n \\n U_avg += U / N\\n #R_avg += R / N\\n\\n if neuron_id < 100:\\n ax[0].plot(U, label=\"U\")\\n# ax[1].plot(R, label=\"R\")\\n\\nax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[0].set_ylabel(\"U\")\\n# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[1].set_ylabel(\"R\")\\n\\nfor _ax in ax:\\n _ax.set_xlim(0, sim_time)\\nax[-1].set_xlabel(\"Time [ms]\")'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nest.ResetKernel()\n", + "nest.resolution = .1 # [ms]\n", + "\n", + "sim_time = 500. # [ms] XXX: 120 second original paper\n", + "chunk_length = 10. # [ms]\n", + "n_chunks = int(sim_time / chunk_length)\n", + "syn_recordables = [\"R_pre\"]\n", + "\n", + "pop = nest.Create(\"gl_ca_nestml\", N)\n", + "pop.a = a\n", + "pop.alpha_over_N = alpha / N\n", + "pop.beta = beta\n", + "pop.U = [U_0 + U_range * (random.random() - .5) for _ in range(N)]\n", + "\n", + "conn_spec_dict = {'rule': 'pairwise_bernoulli', 'p': conn_prob, 'allow_autapses': False}\n", + "nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': 'syn_gl_ca_nestml', 'lmbda': lmbda})\n", + "\n", + "#syn_recordables = []\n", + "#nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': 'static_synapse'})\n", + "\n", + "\n", + "syn = nest.GetConnections(target=pop, synapse_model=\"syn_gl_ca_nestml\")\n", + "N_syn = len(syn)\n", + "syn.R_pre = [R_0 + R_range * (random.random() - .5) for _ in range(N_syn)]\n", + "\n", + "multimeter = nest.Create(\"multimeter\")\n", + "multimeter.set({\"record_from\": [\"U\"], \"interval\": nest.resolution})\n", + "nest.Connect(multimeter, pop)\n", + "\n", + "sr = nest.Create('spike_recorder')\n", + "nest.Connect(pop, sr)\n", + "\n", + "log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, pop)\n", + "\n", + "\n", + "\"\"\"nest.Simulate(sim_time)\n", + "\n", + "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", + "\n", + "fig, ax = plt.subplots(nrows=2)\n", + "\n", + "U_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\n", + "# R_avg = np.zeros_like(U_avg)\n", + "for neuron_id in range(1, N+1):\n", + " idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\n", + " times = multimeter.get(\"events\")[\"times\"][idx]\n", + " U = multimeter.get(\"events\")[\"U\"][idx]\n", + " #R = multimeter.get(\"events\")[\"R\"][idx]\n", + " \n", + " U_avg += U / N\n", + " #R_avg += R / N\n", + "\n", + " if neuron_id < 100:\n", + " ax[0].plot(U, label=\"U\")\n", + "# ax[1].plot(R, label=\"R\")\n", + "\n", + "ax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", + "ax[0].set_ylabel(\"U\")\n", + "# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", + "ax[1].set_ylabel(\"R\")\n", + "\n", + "for _ax in ax:\n", + " _ax.set_xlim(0, sim_time)\n", + "ax[-1].set_xlabel(\"Time [ms]\")\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'R')" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "times = log[\"t\"]\n", + "R_pre = np.array(log[\"R_pre\"])\n", + "R_pre_avg = np.mean(R_pre, axis=1)\n", + "\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(times, R_pre[:, ::N], alpha=.5) # XXX: plot only every N-th line\n", + "ax.set_xlim(0, sim_time)\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "ax.plot(times, R_pre_avg, linewidth=4, linestyle=\"--\", c=\"black\", label=\"mean\")\n", + "ax.legend()\n", + "fig.suptitle(\"R\")" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Neuron')" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(sr.events[\"times\"], sr.events[\"senders\"])\n", + "ax.set_ylim(0, N)\n", + "ax.set_xlim(0, sim_time)\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "ax.set_ylabel(\"Neuron\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Network average firing rate: 7.22 Hz\n" + ] + } + ], + "source": [ + "avg_firing_rate = len(sr.events[\"times\"]) / N / (sim_time / 1E3)\n", + "print(\"Network average firing rate: \" + str(avg_firing_rate) + \" Hz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'U')" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "U_avg = np.zeros(len(np.unique(multimeter.get(\"events\")[\"times\"])))\n", + "for neuron_id in range(1, N+1):\n", + " idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\n", + " times = multimeter.get(\"events\")[\"times\"][idx]\n", + " U = multimeter.get(\"events\")[\"U\"][idx]\n", + " \n", + " U_avg += U / N\n", + "\n", + " if neuron_id < 100:\n", + " ax.plot(times, U, label=\"U\")\n", + "\n", + "ax.plot(times, U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", + "ax.set_ylabel(\"U\")\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "fig.suptitle(\"U\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison to theory" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.01, 6)" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", + " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", + " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", + "DEBUG:vmin 0.1 vmax 150.00000000000003\n", + "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", + " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", + " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", + " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", + " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", + " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", + "DEBUG:vmin 0.01 vmax 6.0\n", + "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def phi(x):\n", + " return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n", + "\n", + "def nullcline1(x):\n", + " return phi(x)/lmbda\n", + "\n", + "def nullcline2(x):\n", + " return beta/alpha*x/phi(x)\n", + "\n", + "U_vec = np.logspace(np.log10(.1), np.log10(150), 100)\n", + "\n", + "nullcline1_vec = nullcline1(U_vec)\n", + "nullcline2_vec = nullcline2(U_vec)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.loglog(U_vec, nullcline1_vec)\n", + "ax.loglog(U_vec, nullcline2_vec)\n", + "\n", + "U_avg_intrp = np.interp(np.linspace(0, len(U_avg), 100),\n", + " np.arange(len(U_avg)),\n", + " U_avg)\n", + "\n", + "R_pre_intrp = np.interp(np.linspace(0, len(R_pre_avg), 100),\n", + " np.arange(len(R_pre_avg)),\n", + " R_pre_avg)\n", + "\n", + "R_pre_intrp[ R_pre_intrp <= 1] = 1.000001\n", + "\n", + "#ax.loglog(U_avg[::200], R_pre_avg[:50] - 1)\n", + "ax.loglog(U_avg_intrp, R_pre_intrp - 1)\n", + "ax.loglog(U_avg[-1], R_pre_avg[-1] - 1, marker=\"o\")\n", + "\n", + "#ax.scatter(U_avg[:199], R_pre_avg[:199])\n", + "\n", + "ax.set_xlabel('Membrane potential')\n", + "ax.set_ylabel('Residual calcium')\n", + "ax.set_xlim(np.amin(U_vec), np.amax(U_vec))\n", + "ax.set_ylim(.01, 6)\n", + "\n", + "#ax.plot(U_avg, R_avg)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", + " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", + " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", + " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", + " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", + " 1.000001 , 1.000001 , 1.000001 , 1.00300352, 1.01745214,\n", + " 1.04660356, 1.07771535, 1.0945982 , 1.11059174, 1.13160081,\n", + " 1.1537244 , 1.19368034, 1.2296995 , 1.23619288, 1.24299194,\n", + " 1.25121745, 1.25996716, 1.27042049, 1.27861199, 1.28137508,\n", + " 1.28204592, 1.27888097, 1.28195025, 1.2939256 , 1.31626105,\n", + " 1.3502516 , 1.37491056, 1.39127477, 1.40875991, 1.4270297 ,\n", + " 1.43653067, 1.44124865, 1.45098255, 1.46280642, 1.46616047,\n", + " 1.46690843, 1.47431492, 1.48314824, 1.48885841, 1.49415215,\n", + " 1.51117633, 1.52893365, 1.54096831, 1.55291985, 1.56354141,\n", + " 1.57463788, 1.5892962 , 1.60229652, 1.60755957, 1.61317211,\n", + " 1.61992048, 1.6245497 , 1.62409297, 1.62706259, 1.63631383,\n", + " 1.64291825, 1.64574151, 1.65316801, 1.66577316, 1.67533165,\n", + " 1.68218202, 1.6861765 , 1.68817186, 1.68556492, 1.68044764,\n", + " 1.68633867, 1.69681649, 1.70022491, 1.70145813, 1.69743879,\n", + " 1.6922939 , 1.69586305, 1.70059406, 1.70087235, 1.70087235])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "R_pre_intrp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acknowledgements\n", + "\n", + "...\n", + "\n", + "\n", + "## References\n", + "\n", + "...\n", + "\n", + "\n", + "## Copyright\n", + "\n", + "This file is part of NEST.\n", + "\n", + "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.\n", + "\n", + "You should have received a copy of the GNU General Public License along with NEST. If not, see .\n" + ] + } + ], + "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/doc/tutorials/tutorials_list.rst b/doc/tutorials/tutorials_list.rst index 788125fbe..8861d28ce 100644 --- a/doc/tutorials/tutorials_list.rst +++ b/doc/tutorials/tutorials_list.rst @@ -17,6 +17,10 @@ Creating neuron models Implement the Ornstein-Uhlenbeck process in NESTML and use it to inject a noise current into a neuron. +* :doc:`Galves-Löcherbach (GL) model ` + + In the GL model, firing of the neuron is a stochastic event, whose probability of occurrence is a function of the membrane potential. + Creating synapse models ----------------------- From 895a3fcfe9d0fc280e643574972b465125ba9bf5 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Thu, 22 Feb 2024 02:55:57 -0800 Subject: [PATCH 2/6] add GL model tutorial notebook --- .../gl_model/gl_model_tutorial.ipynb | 986 +++++------------- 1 file changed, 256 insertions(+), 730 deletions(-) diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb index 0eea8f98b..fb6683afb 100644 --- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -48,46 +48,232 @@ "import os\n", "import random\n", "\n", - "from pynestml.frontend.pynestml_frontend import generate_nest_target\n", + "from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils\n", "\n", "import logging\n", "logging.getLogger('matplotlib.font_manager').disabled = True" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GL model with physical units\n", + "----------------------------\n" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "def fI_curve(neuron_model: str, t_stop: float = 1000., custom_model_opts: Optional[Dict] = None):\n", - " I_stim_vec = np.linspace(0, 1E-9, 40) # [A]\n", - " rate = float(\"nan\") * np.ones_like(I_stim_vec)\n", - "\n", - " for i, I_stim in enumerate(I_stim_vec):\n", - " nest.ResetKernel()\n", - " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", - "\n", - " dc = nest.Create(\"dc_generator\", params={\"amplitude\": 1E12 * I_stim}) # 1E12: convert A to pA\n", - " nest.Connect(dc, neuron)\n", - "\n", - "# multimeter = nest.Create('multimeter')\n", - "# nest.SetStatus(multimeter, {\"record_from\": [\"U\"]})\n", - "# nest.Connect(multimeter, neuron)\n", + "# Neuron parameters\n", + "params = {\n", + " 'tau_m' : 10.0,\n", + " 't_ref' : 2.0,\n", + " 'C_m' : 250.0,\n", + " 'V_r' : -65.0,\n", + " 'V_reset' : -65.0,\n", + " 'a' : 1.2,\n", + " 'b' : 27.0,\n", + " 'V_b' : -51.3\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_exp_model = \"\"\"\n", + "neuron gl_exp:\n", + " state:\n", + " refr_spikes_buffer mV = 0 mV\n", + " refr_tick integer = 0 # Counts number of tick during the refractory period\n", + " V_m mV = V_r # Membrane potential\n", + "\n", + " equations:\n", + " kernel G = delta(t)\n", + " V_m' = -(V_m - V_r) / tau_m + (mV / ms) * convolve(G, spikes) + (I_e + I_stim) / C_m\n", + "\n", + " parameters:\n", + " tau_m ms = 10 ms # Membrane time constant\n", + " C_m pF = 250 pF # Capacity of the membrane\n", + " t_ref ms = 2 ms # Duration of refractory period\n", + " tau_syn ms = 0.5 ms # Time constant of synaptic current\n", + " V_r mV = -65 mV # Resting membrane potential\n", + " V_reset mV = -65 mV # Reset potential of the membrane\n", + " b real = 27 # Parameter for the exponential curve\n", + " a mV = 5 mV # Parameter for the exponential curve\n", + " V_b mV = -51.3 mV # Membrane potential at which phi(V)=1/b\n", + " with_refr_input boolean = false # If true, do not discard input during refractory period.\n", + " reset_after_spike boolean = true\n", + "\n", + " # constant external input current\n", + " I_e pA = 0 pA\n", + "\n", + " internals:\n", + " RefractoryCounts integer = steps(t_ref) # refractory time in steps\n", + "\n", + " input:\n", + " spikes <- spike\n", + " I_stim pA <- continuous\n", + "\n", + " output:\n", + " spike\n", + "\n", + " function phi(V_m mV) real:\n", + " return ((1/b) * exp((V_m - V_b)/mV/a))\n", + "\n", + " update:\n", + " if refr_tick == 0: # neuron not refractory\n", + " integrate_odes()\n", + "\n", + " # if we have accumulated spikes from refractory period,\n", + " # add and reset accumulator\n", + " if with_refr_input and refr_spikes_buffer != 0.0 mV:\n", + " V_m += refr_spikes_buffer\n", + " refr_spikes_buffer = 0.0 mV\n", + "\n", + " else: # neuron is absolute refractory\n", + " # read spikes from buffer and accumulate them, discounting\n", + " # for decay until end of refractory period\n", + " # the buffer is clear automatically\n", + " if with_refr_input:\n", + " refr_spikes_buffer += spikes * exp(-refr_tick * h / tau_m) * mV * s\n", + " refr_tick -= 1\n", + "\n", + " tmp real = phi(V_m)\n", + " println(\"{V_m} ---> {tmp}\")\n", + " \n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * phi(V_m):\n", + " refr_tick = RefractoryCounts\n", + " if reset_after_spike:\n", + " V_m = V_reset\n", + " emit_spike()\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "module_name, neuron_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", + " nestml_neuron_model=nestml_gl_exp_model,\n", + " logging_level=\"INFO\" # try \"INFO\" for more debug information\n", + ")\n", "\n", + "nest.Install(module_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def measure_numerical_Phi_function(neuron_model_name, U_min=0., U_max=10., neuron_model_params=None, neuron_membrane_potential_name=\"U\"):\n", + " nest.ResetKernel()\n", + " nest.resolution = 1. # check that results are independent of resolution...\n", + " \n", + " t_stop = 25000.\n", + " \n", + " U_range = np.linspace(U_min, U_max, 12)\n", + " n_spikes = np.nan * np.ones_like(U_range)\n", + " for i, U in enumerate(U_range):\n", + " neuron = nest.Create(neuron_model_name)\n", + " if neuron_model_params:\n", + " neuron.set(neuron_model_params)\n", + " \n", + " neuron.set({neuron_membrane_potential_name: U})\n", + " assert neuron.get(neuron_membrane_potential_name) == U\n", + " \n", " sr = nest.Create('spike_recorder')\n", " nest.Connect(neuron, sr)\n", - "\n", + " \n", " nest.Simulate(t_stop)\n", + " assert neuron.get(neuron_membrane_potential_name) == U\n", + " \n", + " n_spikes[i] = len(sr.events[\"times\"])\n", + " \n", + " spike_rate = n_spikes / (t_stop / 1E3)\n", "\n", - "# Vms = multimeter.events[\"U\"]\n", - "# ts = multimeter.events[\"times\"]\n", + " return U_range, spike_rate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "\n", - " rate[i] = sr.n_events / t_stop * 1000\n", - " \n", - " return I_stim_vec, rate" + "# theoretical Phi vs U\n", + "U_range_theory = np.linspace(-60., -45., 100)\n", + "Phi_of_U_theory = (1 / params['b']) * np.exp((U_range_theory - params['V_b']) / params['a'])\n", + "\n", + "# numerical Phi vs U\n", + "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " U_min=-60.,\n", + " U_max=-45.,\n", + " neuron_model_params={\"reset_after_spike\": False,\n", + " \"a\": params['a'],\n", + " \"b\": params['b'],\n", + " \"V_b\": params['V_b'],\n", + " \"tau_m\": 1E99},\n", + " neuron_membrane_potential_name=\"V_m\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", + "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$U$\")\n", + "ax.set_ylabel(\"Firing rate [Hz]\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "spike_rate_numeric" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -105,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +309,7 @@ " deliver_spike(R_pre - 1, the_delay)\n", "\n", " input:\n", - " incoming_spikes real <- spike\n", + " incoming_spikes <- spike\n", " \n", " output:\n", " spike\n", @@ -142,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -158,7 +344,7 @@ " reset_after_spike boolean = true\n", "\n", " input:\n", - " incoming_spikes real <- spike\n", + " incoming_spikes <- spike\n", "\n", " output:\n", " spike\n", @@ -175,7 +361,7 @@ " kernel K = delta(t)\n", " \n", " # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n", - " U' = -U / (1E3/beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", + " U' = -U / (1E3 / beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", "\n", " update:\n", " # integrate spike input\n", @@ -191,195 +377,17 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml\n", - "[3,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml\n", - "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/tmp/nestml-gl-ca-target'\n", - "[5,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml'!\n", - "[6,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", - "[7,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[8,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[9,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[10,gl_ca_nestml, WARNING, [30:9;30:23]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", - "[11,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[12,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[13,gl_ca_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", - "[14,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[15,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml'!\n", - "[16,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n", - "[17,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[18,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[19,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n", - "[20,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[21,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[22,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[23,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", - "[24,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", - "[25,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[26,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[27,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[28,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[29,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[30,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[31,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n", - "[32,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", - " },\n", - " \"parameters\": {\n", - " \"a\": \"3.0\",\n", - " \"alpha_over_N\": \"1.0777744654743957\",\n", - " \"beta\": \"50\",\n", - " \"reset_after_spike\": \"true\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n", - "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "DEBUG:Splitting expression -0.001*U*beta (symbols [U, U])\n", - "DEBUG:\tlinear factors: Matrix([[-0.001*beta], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "DEBUG:Splitting expression -0.001*U*beta (symbols Matrix([[U]]))\n", - "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0.0]])\n", - "INFO:Dependency analysis...\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n", - "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_before.dot\n", - "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph_before.dot'\n", - "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_before.dot']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[33,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[34,GLOBAL, INFO]: Analysing/transforming neuron 'gl_ca_nestml'\n", - "[35,gl_ca_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_ca_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", - "INFO:Generating propagators for the following symbols: U\n", - "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0]])\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " },\n", - " \"parameters\": {\n", - " \"beta\": \"50.0000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"U\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"U\": \"U*__P__U__U\"\n", - " }\n", - " }\n", - "]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[36,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n", - "[37,gl_ca_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[38,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[39,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[40,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[41,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[42,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_ca_nestml.\n", - "[43,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_ca_nestml'\n", - "[44,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.cpp\n", - "[45,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.h\n", - "[46,gl_ca_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n", - "[47,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/syn_gl_ca_nestml.h\n", - "[48,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n", - "[49,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/CMakeLists.txt\n", - "[50,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.h\n", - "[51,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.cpp\n", - "[52,GLOBAL, INFO]: Successfully generated NEST module code in '/tmp/nestml-gl-ca-target' !\n" - ] - } - ], - "source": [ - "with open(\"nestml_gl_ca_synapse_model.nestml\", \"w\") as nestml_model_file:\n", - " print(nestml_gl_ca_synapse_model, file=nestml_model_file)\n", - "\n", - "with open(\"nestml_gl_ca_model.nestml\", \"w\") as nestml_model_file:\n", - " print(nestml_gl_ca_neuron_model, file=nestml_model_file)\n", - "\n", - "generate_nest_target(input_path=[\"nestml_gl_ca_model.nestml\", \"nestml_gl_ca_synapse_model.nestml\"],\n", - " target_path=\"/tmp/nestml-gl-ca-target\",\n", - " module_name=\"nestml_gl_ca_module\",\n", - " suffix=\"_nestml\",\n", - " logging_level=\"DEBUG\"#WARNING # try \"INFO\" for more debug information\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "nest.Install(\"nestml_gl_ca_module\")\n" + "module_name, neuron_model_name, synapse_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", + " nestml_neuron_model=nestml_gl_ca_neuron_model,\n", + " nestml_synapse_model=nestml_gl_ca_synapse_model,\n", + " logging_level=\"INFO\" # try \"INFO\" for more debug information\n", + ")\n", + "\n", + "nest.Install(module_name)" ] }, { @@ -397,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -433,32 +441,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ts, Vms_gl = measure_postsynaptic_response(\"gl_ca_nestml\", \"syn_gl_ca_nestml\", V_m_specifier=\"U\")\n", "\n", @@ -485,79 +470,31 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "nest.ResetKernel()\n", - "nest.resolution = 1. # check that results are independent of resolution...\n", - "\n", - "a = 3.\n", - "\n", - "t_stop = 25000.\n", - "\n", - "U_range = np.linspace(0., 10., 12)\n", - "n_spikes = np.nan * np.ones_like(U_range)\n", - "for i, U in enumerate(U_range):\n", - " neuron = nest.Create(\"gl_ca_nestml\", params={\"reset_after_spike\": False})\n", - " neuron.beta = 1E-99 # a very low value, to prevent the membrane potential from decaying\n", - " neuron.U = U\n", - " neuron.a = a\n", - "\n", - " sr = nest.Create('spike_recorder')\n", - " nest.Connect(neuron, sr)\n", - "\n", - " nest.Simulate(t_stop)\n", - "\n", - " n_spikes[i] = len(sr.events[\"times\"])\n", - "\n", - "spike_rate = n_spikes / (t_stop / 1E3)" + "#theoretical Phi vs U\n", + "a = 3\n", + "U_range_theory = np.linspace(0., 10., 100)\n", + "Phi_of_U_theory = (4 * a) / (1 + np.exp(a - U_range_theory)) - (4 * a) / (1 + np.exp(a))\n", + "\n", + "# numerical Phi vs U\n", + "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " neuron_model_params={\"reset_after_spike\": False,\n", + " \"beta\": 1E-99, # a very low value, to prevent the membrane potential from decaying\n", + " \"a\": 3.})" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "_U = np.linspace(0., 10., 100)\n", - "Phi_of_U = (4 * a) / (1 + np.exp(a - _U)) - (4 * a) / (1 + np.exp(a))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Firing rate [Hz]')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "fig, ax = plt.subplots()\n", - "ax.plot(_U, Phi_of_U, label=\"theoretical\")\n", - "ax.set_xlabel(\"$U$\")\n", - "\n", - "ax.plot(U_range, spike_rate, marker=\"o\", label=\"numeric\")\n", + "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", + "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", "ax.legend()\n", "ax.set_xlabel(\"$U$\")\n", "ax.set_ylabel(\"Firing rate [Hz]\")" @@ -572,7 +509,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -620,7 +557,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -642,27 +579,9 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "9900 synapses in the network\n" - ] - }, - { - "data": { - "text/plain": [ - "'nest.Simulate(sim_time)\\n\\nneuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\\n\\nfig, ax = plt.subplots(nrows=2)\\n\\nU_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\\n# R_avg = np.zeros_like(U_avg)\\nfor neuron_id in range(1, N+1):\\n idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\\n times = multimeter.get(\"events\")[\"times\"][idx]\\n U = multimeter.get(\"events\")[\"U\"][idx]\\n #R = multimeter.get(\"events\")[\"R\"][idx]\\n \\n U_avg += U / N\\n #R_avg += R / N\\n\\n if neuron_id < 100:\\n ax[0].plot(U, label=\"U\")\\n# ax[1].plot(R, label=\"R\")\\n\\nax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[0].set_ylabel(\"U\")\\n# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[1].set_ylabel(\"R\")\\n\\nfor _ax in ax:\\n _ax.set_xlim(0, sim_time)\\nax[-1].set_xlabel(\"Time [ms]\")'" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "nest.ResetKernel()\n", "nest.resolution = .1 # [ms]\n", @@ -732,32 +651,9 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'R')" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "times = log[\"t\"]\n", "R_pre = np.array(log[\"R_pre\"])\n", @@ -775,32 +671,9 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Neuron')" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots()\n", "ax.scatter(sr.events[\"times\"], sr.events[\"senders\"])\n", @@ -812,17 +685,9 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Network average firing rate: 7.22 Hz\n" - ] - } - ], + "outputs": [], "source": [ "avg_firing_rate = len(sr.events[\"times\"]) / N / (sim_time / 1E3)\n", "print(\"Network average firing rate: \" + str(avg_firing_rate) + \" Hz\")" @@ -830,32 +695,9 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'U')" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", "\n", @@ -887,295 +729,9 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.01, 6)" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n", - " 2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n", - " 2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n", - "DEBUG:vmin 0.1 vmax 150.00000000000003\n", - "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n", - " 2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n", - " 2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n", - " 2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n", - " 2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n", - " 2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n", - "DEBUG:vmin 0.01 vmax 6.0\n", - "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def phi(x):\n", " return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n", @@ -1221,39 +777,9 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", - " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", - " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", - " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", - " 1.000001 , 1.000001 , 1.000001 , 1.000001 , 1.000001 ,\n", - " 1.000001 , 1.000001 , 1.000001 , 1.00300352, 1.01745214,\n", - " 1.04660356, 1.07771535, 1.0945982 , 1.11059174, 1.13160081,\n", - " 1.1537244 , 1.19368034, 1.2296995 , 1.23619288, 1.24299194,\n", - " 1.25121745, 1.25996716, 1.27042049, 1.27861199, 1.28137508,\n", - " 1.28204592, 1.27888097, 1.28195025, 1.2939256 , 1.31626105,\n", - " 1.3502516 , 1.37491056, 1.39127477, 1.40875991, 1.4270297 ,\n", - " 1.43653067, 1.44124865, 1.45098255, 1.46280642, 1.46616047,\n", - " 1.46690843, 1.47431492, 1.48314824, 1.48885841, 1.49415215,\n", - " 1.51117633, 1.52893365, 1.54096831, 1.55291985, 1.56354141,\n", - " 1.57463788, 1.5892962 , 1.60229652, 1.60755957, 1.61317211,\n", - " 1.61992048, 1.6245497 , 1.62409297, 1.62706259, 1.63631383,\n", - " 1.64291825, 1.64574151, 1.65316801, 1.66577316, 1.67533165,\n", - " 1.68218202, 1.6861765 , 1.68817186, 1.68556492, 1.68044764,\n", - " 1.68633867, 1.69681649, 1.70022491, 1.70145813, 1.69743879,\n", - " 1.6922939 , 1.69586305, 1.70059406, 1.70087235, 1.70087235])" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "R_pre_intrp" ] @@ -1302,7 +828,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.2" + "version": "3.11.4" } }, "nbformat": 4, From aad44cc3dbc148f028b365f9967b52852723df5d Mon Sep 17 00:00:00 2001 From: Pooja Babu Date: Mon, 26 Feb 2024 12:07:41 +0100 Subject: [PATCH 3/6] Update GL model notebook --- .../gl_model/gl_model_tutorial.ipynb | 2983 ++++++++++++++++- 1 file changed, 2901 insertions(+), 82 deletions(-) diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb index fb6683afb..89c9bd591 100644 --- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -27,9 +27,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.6.0\n", + " Built: Feb 22 2024 10:55:27\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n" + ] + } + ], "source": [ "%matplotlib inline\n", "from typing import Dict, Optional\n", @@ -64,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -83,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +147,7 @@ " spike\n", "\n", " function phi(V_m mV) real:\n", - " return ((1/b) * exp((V_m - V_b)/mV/a))\n", + " return ((1/b) * exp((V_m - V_b)/a))\n", "\n", " update:\n", " if refr_tick == 0: # neuron not refractory\n", @@ -144,9 +166,6 @@ " if with_refr_input:\n", " refr_spikes_buffer += spikes * exp(-refr_tick * h / tau_m) * mV * s\n", " refr_tick -= 1\n", - "\n", - " tmp real = phi(V_m)\n", - " println(\"{V_m} ---> {tmp}\")\n", " \n", " if random_uniform(0, 1) <= 1E-3 * resolution() * phi(V_m):\n", " refr_tick = RefractoryCounts\n", @@ -158,9 +177,246 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1,GLOBAL, INFO]: List of files that will be processed:\n", + "[2,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/gl_expe8800e269e8c4716bc83b2ace5aa5263.nestml\n", + "[3,GLOBAL, INFO]: Target platform code will be generated in directory: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target'\n", + "[4,GLOBAL, INFO]: Target platform code will be installed in directory: '/var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_'\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.6.0\n", + " Built: Feb 22 2024 10:55:27\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "[5,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.6.0\n", + "[6,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[9,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /Users/pooja/conda/nestml_dev\n", + "[10,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/gl_expe8800e269e8c4716bc83b2ace5aa5263.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[12,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[13,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", + "[14,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", + "[15,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [10:73;10:73]]: Implicit magnitude conversion from pA to pA buffer with factor 1.0 \n", + "[16,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [10:15;10:68]]: Implicit magnitude conversion from mV / ms to pA / pF with factor 1.0 \n", + "[17,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[18,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [59:11;59:64]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([59:11;59:64])\n", + "[20,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[21,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", + "[22,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Analysing input:\n", + "INFO:root:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"V_m' = (-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\",\n", + " \"initial_values\": {\n", + " \"V_m\": \"V_r\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"C_m\": \"250\",\n", + " \"I_e\": \"0\",\n", + " \"V_b\": \"(-51.3)\",\n", + " \"V_r\": \"(-65)\",\n", + " \"V_reset\": \"(-65)\",\n", + " \"a\": \"5\",\n", + " \"b\": \"27\",\n", + " \"reset_after_spike\": \"true\",\n", + " \"t_ref\": \"2\",\n", + " \"tau_m\": \"10\",\n", + " \"tau_syn\": \"0.5\",\n", + " \"with_refr_input\": \"false\"\n", + " }\n", + "}\n", + "INFO:root:Processing global options...\n", + "INFO:root:Processing input shapes...\n", + "INFO:root:\n", + "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", + "INFO:root:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:root:All known variables: [V_m], all parameters used in ODEs: {I_e, tau_m, V_r, I_stim, C_m}\n", + "INFO:root:No numerical value specified for parameter \"I_stim\"\n", + "INFO:root:\n", + "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", + "INFO:root:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:root:Finding analytically solvable equations...\n", + "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:root:Generating propagators for the following symbols: V_m\n", + "INFO:root:update_expr[V_m] = V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\n", + "INFO:root:In ode-toolbox: returning outdict = \n", + "INFO:root:[\n", + " {\n", + " \"initial_values\": {\n", + " \"V_m\": \"V_r\"\n", + " },\n", + " \"parameters\": {\n", + " \"C_m\": \"250.000000000000\",\n", + " \"I_e\": \"0\",\n", + " \"V_r\": \"-65.0000000000000\",\n", + " \"tau_m\": \"10.0000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__V_m__V_m\": \"exp(-__h/tau_m)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"V_m\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"V_m\": \"V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[23,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[24,GLOBAL, INFO]: Analysing/transforming neuron 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml'\n", + "[25,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [2:0;63:0]]: Starts processing of the model 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml'\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[27,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[28,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", + "[29,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[30,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp\n", + "[31,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h\n", + "[32,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [2:0;63:0]]: Successfully generated code for the model: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "[33,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/CMakeLists.txt\n", + "[34,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.h\n", + "[35,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.cpp\n", + "[36,GLOBAL, INFO]: Successfully generated NEST module code in '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "\u001b[33mCMake Warning (dev) at CMakeLists.txt:93 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\u001b[0m\n", + "-- The CXX compiler identification is AppleClang 15.0.0.15000100\n", + "-- Detecting CXX compiler ABI info\n", + "-- Detecting CXX compiler ABI info - done\n", + "-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ - skipped\n", + "-- Detecting CXX compile features\n", + "-- Detecting CXX compile features - done\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0mnestml_e8800e269e8c4716bc83b2ace5aa5263_module Configuration Summary\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mC++ compiler : /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++\u001b[0m\n", + "\u001b[0mBuild static libs : OFF\u001b[0m\n", + "\u001b[0mC++ compiler flags : \u001b[0m\n", + "\u001b[0mNEST compiler flags : -std=c++11 -Wall -Xclang -fopenmp -O2\u001b[0m\n", + "\u001b[0mNEST include dirs : -I/Users/pooja/conda/nestml_dev/include/nest -I/usr/local/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk/usr/include -I/usr/local/Cellar/gsl/2.7/include -I/Users/pooja/miniconda3/envs/nest_3.6/include\u001b[0m\n", + "\u001b[0mNEST libraries flags : -L/Users/pooja/conda/nestml_dev/lib/nest -lnest -lsli -Xclang -fopenmp /usr/local/lib/libltdl.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libreadline.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libncurses.dylib /usr/local/Cellar/gsl/2.7/lib/libgsl.dylib /usr/local/Cellar/gsl/2.7/lib/libgslcblas.dylib\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mYou can now build and install 'nestml_e8800e269e8c4716bc83b2ace5aa5263_module' using\u001b[0m\n", + "\u001b[0m make\u001b[0m\n", + "\u001b[0m make install\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mThe library file libnestml_e8800e269e8c4716bc83b2ace5aa5263_module.so will be installed to\u001b[0m\n", + "\u001b[0m /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_\u001b[0m\n", + "\u001b[0mThe module can be loaded into NEST using\u001b[0m\n", + "\u001b[0m (nestml_e8800e269e8c4716bc83b2ace5aa5263_module) Install (in SLI)\u001b[0m\n", + "\u001b[0m nest.Install(nestml_e8800e269e8c4716bc83b2ace5aa5263_module) (in PyNEST)\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[33mCMake Warning (dev) in CMakeLists.txt:\n", + " No cmake_minimum_required command is present. A line of code such as\n", + "\n", + " cmake_minimum_required(VERSION 3.28)\n", + "\n", + " should be added at the top of the file. The version specified may be lower\n", + " if you wish to support older CMake versions for this project. For more\n", + " information run \"cmake --help-policy CMP0000\".\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\u001b[0m\n", + "-- Configuring done (1.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /Users/pooja/nestml/master/doc/tutorials/gl_model/target\n", + "[ 33%] \u001b[32mBuilding CXX object CMakeFiles/nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module.dir/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.o\u001b[0m\n", + "[ 66%] \u001b[32mBuilding CXX object CMakeFiles/nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module.dir/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.o\u001b[0m\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:43:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h:216:17: warning: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml::get_C_m' hides overloaded virtual function [-Woverloaded-virtual]\n", + " inline double get_C_m() const\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/node.h:747:18: note: hidden overloaded virtual function 'nest::Node::get_C_m' declared here: different number of parameters (1 vs 0)\n", + " virtual double get_C_m( int comp );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.cpp:47:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h:216:17: warning: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml::get_C_m' hides overloaded virtual function [-Woverloaded-virtual]\n", + " inline double get_C_m() const\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/node.h:747:18: note: hidden overloaded virtual function 'nest::Node::get_C_m' declared here: different number of parameters (1 vs 0)\n", + " virtual double get_C_m( int comp );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:166:16: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:294:10: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " ^\n", + "1 warning generated.\n", + "3 warnings generated.\n", + "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_e8800e269e8c4716bc83b2ace5aa5263_module.so\u001b[0m\n", + "[100%] Built target nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module\n", + "[100%] Built target nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module\n", + "\u001b[36mInstall the project...\u001b[0m\n", + "-- Install configuration: \"\"\n", + "-- Installing: /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.so\n", + "\n", + "Feb 26 11:15:24 Install [Info]: \n", + " loaded module nestml_e8800e269e8c4716bc83b2ace5aa5263_module\n" + ] + } + ], "source": [ "module_name, neuron_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", " nestml_neuron_model=nestml_gl_exp_model,\n", @@ -172,14 +428,7 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -214,9 +463,188 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 26 11:15:24 correlation_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Feb 26 11:15:24 correlomatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Feb 26 11:15:24 correlospinmatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.1 to 1 ms\n", + "\n", + "Feb 26 11:15:24 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:15:24 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:15:24 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:15:24 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:15:24 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 1 ms.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 2 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 2\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 6 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 6\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 8 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 8\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 10 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 10\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 12 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 12\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 14 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 14\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 16 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 16\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 18 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 18\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 20 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 20\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 22 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 22\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + " Preparing 24 nodes for simulation.\n", + "\n", + "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 24\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + } + ], "source": [ "\n", "# theoretical Phi vs U\n", @@ -237,9 +665,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", @@ -250,29 +701,237 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "spike_rate_numeric" + "## Computing reliability of the single neuron model" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "\n" + "def evaluate_neuron(neuron_name, nneurons=1, neuron_parms=None, stimulus_type=\"constant\", poisson_fr=0.0,\n", + " mu=500., sigma=0., t_sim=300., plot=False, rseed=1000, dt=0.1, input_freq=0.0):\n", + " \"\"\"\n", + " Run a simulation in NEST for the specified neuron. Inject a stepwise\n", + " current and plot the membrane potential dynamics and spikes generated.\n", + " \"\"\"\n", + " nest.ResetKernel()\n", + " nest.SetKernelStatus({'rng_seed': rseed,\n", + " 'resolution': dt})\n", + " neuron = nest.Create(neuron_name, nneurons)\n", + " if neuron_parms:\n", + " for k, v in neuron_parms.items():\n", + " nest.SetStatus(neuron, k, v)\n", + " nest.SetStatus(neuron,{'V_m':np.random.uniform(-65.0, -50.0)})\n", + " nest.SetStatus(neuron, \"I_e\", mu)\n", + " # nest.SetStatus(neuron, {\"reset_after_spike\": False})\n", + "\n", + " if stimulus_type == \"noise\":\n", + " # Create a noise generator\n", + " noise = nest.Create(\"noise_generator\")\n", + " # Set the parameters of the noise generator\n", + " noise_params = {\"mean\": mu, \n", + " \"std\": sigma, \n", + " \"dt\": dt,\n", + " \"frequency\":input_freq}\n", + " nest.SetStatus(noise, noise_params)\n", + " nest.Connect(noise, neuron)\n", + "\n", + " elif stimulus_type == \"poisson_spikes\":\n", + " # Create a Poisson generator device\n", + " poisson = nest.Create(\"poisson_generator\", params={\"rate\": poisson_fr})\n", + "\n", + " # Create a parrot neuron\n", + " parrot = nest.Create(\"parrot_neuron\")\n", + "\n", + " # Connect the Poisson generator to the parrot neuron\n", + " nest.Connect(poisson, parrot)\n", + "\n", + " # Connect the parrot neuron to each neuron\n", + " nest.Connect(parrot, neuron)\n", + " else:\n", + " raise Exception(\"Unknown stimulus type: \" + str(stimulus_type))\n", + "\n", + " multimeter = nest.Create(\"multimeter\")\n", + " multimeter.set({\"record_from\": [\"V_m\"],\n", + " \"interval\": dt})\n", + " spike_recorder = nest.Create(\"spike_recorder\")\n", + " nest.Connect(multimeter, neuron)\n", + " nest.Connect(neuron, spike_recorder)\n", + "\n", + " nest.Simulate(t_sim)\n", + "\n", + " dmm = nest.GetStatus(multimeter)[0]\n", + " Voltages = dmm[\"events\"][\"V_m\"]\n", + " tv = dmm[\"events\"][\"times\"]\n", + " \n", + " dSD = nest.GetStatus(spike_recorder, keys='events')[0]\n", + " ns = dSD['senders']\n", + " ts = dSD[\"times\"]\n", + "\n", + " _idx = [np.argmin((tv - spike_time)**2) - 1 for spike_time in ts]\n", + " V_m_at_spike_times = Voltages[_idx]\n", + "\n", + " if plot:\n", + " fig, ax = plt.subplots()\n", + " ax.plot(tv, Voltages)\n", + " ax.scatter(ts, V_m_at_spike_times)\n", + " ax.set_xlabel(\"Time [ms]\")\n", + " ax.set_ylabel(\"V_m [mV]\")\n", + " ax.grid()\n", + "\n", + " return ts, ns" ] }, { - "cell_type": "code", - "execution_count": null, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "### Constant input current" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 26 11:18:29 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 0.1 ms.\n", + "\n", + "Feb 26 11:18:29 NodeManager::prepare_nodes [Info]: \n", + " Preparing 54 nodes for simulation.\n", + "\n", + "Feb 26 11:18:29 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 54\n", + " Simulation time (ms): 500\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:18:29 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:18:29 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:18:29 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 0.1 ms.\n", + "\n", + "Feb 26 11:18:29 NodeManager::prepare_nodes [Info]: \n", + " Preparing 54 nodes for simulation.\n", + "\n", + "Feb 26 11:18:29 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 54\n", + " Simulation time (ms): 500\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:18:29 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dt = 0.1\n", + "nneurons = 50\n", + "\n", + "ts_const, ns_const = evaluate_neuron(neuron_model_name, nneurons=nneurons, neuron_parms=params, stimulus_type='poisson_spikes',\\\n", + " mu=550., t_sim=500.0, dt=dt, poisson_fr = 0.0)\n", + "\n", + "ts_noise, ns_noise = evaluate_neuron(neuron_model_name, nneurons=nneurons, neuron_parms=params, stimulus_type='poisson_spikes',\\\n", + " mu=550., t_sim=500.0, dt=dt, poisson_fr = 1000.0)\n", + "\n", + "# PSTH parameters\n", + "t_start = 0.0\n", + "t_stop = 500.0\n", + "t_step = 1.0\n", + "t_bins = np.arange(t_start, t_stop + t_step, t_step)\n", + "\n", + "# Calculate the PSTH\n", + "psth_const, _ = np.histogram(ts_const, bins=t_bins)\n", + "psth_const = psth_const / len(ts_const) / (dt*1e-3) # divide by number of trials and time bin size\n", + "\n", + "psth_noise, _ = np.histogram(ts_noise, bins=t_bins)\n", + "psth_noise = psth_noise / len(ts_noise) / (dt*1e-3) # divide by number of trials and time bin size\n", + "\n", + "plt.figure(figsize=(10,4))\n", + "# Raster plot\n", + "plt.subplot2grid((3,2),(0,0), rowspan=2)\n", + "plt.plot(ts_const, ns_const, '.')\n", + "plt.xlim(100, 500)\n", + "plt.ylabel('#Trial')\n", + "plt.title('Constant input current')\n", + "\n", + "plt.subplot2grid((3,2),(0,1), rowspan=2)\n", + "plt.plot(ts_noise, ns_noise, '.')\n", + "plt.xlim(100, 500)\n", + "plt.ylabel('#Trial')\n", + "plt.title('Poissonian input')\n", + "\n", + "# Plot the PSTH\n", + "plt.subplot2grid((3,2),(2,0), rowspan=1)\n", + "plt.plot(t_bins[:-1], psth_const)\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Firing rate (Hz)')\n", + "plt.xlim(100, 500)\n", + "\n", + "plt.subplot2grid((3,2),(2,1), rowspan=1)\n", + "plt.plot(t_bins[:-1], psth_noise)\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Firing rate (Hz)')\n", + "plt.xlim(100, 500)\n", + "plt.tight_layout()" + ] }, { "cell_type": "markdown", @@ -291,7 +950,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -328,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -352,9 +1011,6 @@ " function phi(U real) real:\n", " if U <= 0:\n", " return 0\n", - "\n", - " #tmp real = (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", - " #println(\"phi({U}) = {tmp}\")\n", " return (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", "\n", " equations:\n", @@ -377,9 +1033,589 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 32, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1,GLOBAL, INFO]: List of files that will be processed:\n", + "[2,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml\n", + "[3,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml\n", + "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo'\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.6.0\n", + " Built: Feb 22 2024 10:55:27\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.6.0\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[9,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[10,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /Users/pooja/conda/nestml_dev\n", + "[11,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[13,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[14,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[15,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[16,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [30:9;30:25]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", + "[17,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[18,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[19,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", + "[20,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[21,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[23,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[24,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[26,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[27,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[28,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[29,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[30,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[31,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[33,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[34,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[36,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[37,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[38,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[39,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [30:9;30:25]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", + "[40,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[41,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[42,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", + "[43,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[45,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[46,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[47,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: []\n", + "[48,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: []\n", + "[49,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with suffixed external variable references\n", + "[50,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", + "[51,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", + "[52,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", + "[54,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[55,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", + "[56,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[57,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[58,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[59,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Analysing input:\n", + "INFO:root:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"a\": \"3.0\",\n", + " \"alpha_over_N\": \"1.0777744654743957\",\n", + " \"beta\": \"50\",\n", + " \"reset_after_spike\": \"true\"\n", + " }\n", + "}\n", + "INFO:root:Processing global options...\n", + "INFO:root:Processing input shapes...\n", + "INFO:root:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:All known variables: [U], all parameters used in ODEs: {beta}\n", + "INFO:root:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:Finding analytically solvable equations...\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:Generating propagators for the following symbols: U\n", + "INFO:root:update_expr[U] = U*__P__U__U\n", + "INFO:root:In ode-toolbox: returning outdict = \n", + "INFO:root:[\n", + " {\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " },\n", + " \"parameters\": {\n", + " \"beta\": \"50.0000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"U\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"U\": \"U*__P__U__U\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[61,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[62,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[63,GLOBAL, INFO]: Successfully constructed neuron-synapse pair gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\n", + "[64,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", + "[65,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Analysing input:\n", + "INFO:root:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"a\": \"3.0\",\n", + " \"alpha_over_N\": \"1.0777744654743957\",\n", + " \"beta\": \"50\",\n", + " \"reset_after_spike\": \"true\"\n", + " }\n", + "}\n", + "INFO:root:Processing global options...\n", + "INFO:root:Processing input shapes...\n", + "INFO:root:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:All known variables: [U], all parameters used in ODEs: {beta}\n", + "INFO:root:\n", + "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", + "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:Finding analytically solvable equations...\n", + "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:root:Generating propagators for the following symbols: U\n", + "INFO:root:update_expr[U] = U*__P__U__U\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[67,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[68,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[69,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[70,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[71,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[72,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", + "[73,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:In ode-toolbox: returning outdict = \n", + "INFO:root:[\n", + " {\n", + " \"initial_values\": {\n", + " \"U\": \"0\"\n", + " },\n", + " \"parameters\": {\n", + " \"beta\": \"50.0000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"U\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"U\": \"U*__P__U__U\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[75,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[76,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", + "[77,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[78,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[79,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[80,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.\n", + "[81,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[83,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[84,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[86,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[87,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[88,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp\n", + "[89,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", + "[90,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", + "[91,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp\n", + "[92,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", + "[93,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "Generating code for the synapse syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.\n", + "[94,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", + "[95,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "[96,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/CMakeLists.txt\n", + "[97,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.h\n", + "[98,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp\n", + "[99,GLOBAL, INFO]: Successfully generated NEST module code in '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", + "\u001b[33mCMake Warning (dev) at CMakeLists.txt:95 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\u001b[0m\n", + "-- The CXX compiler identification is AppleClang 15.0.0.15000100\n", + "-- Detecting CXX compiler ABI info\n", + "-- Detecting CXX compiler ABI info - done\n", + "-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ - skipped\n", + "-- Detecting CXX compile features\n", + "-- Detecting CXX compile features - done\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0mnestml_c582d906cfdd4f76a2f0e5036501ac82_module Configuration Summary\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mC++ compiler : /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++\u001b[0m\n", + "\u001b[0mBuild static libs : OFF\u001b[0m\n", + "\u001b[0mC++ compiler flags : \u001b[0m\n", + "\u001b[0mNEST compiler flags : -std=c++11 -Wall -Xclang -fopenmp -O2\u001b[0m\n", + "\u001b[0mNEST include dirs : -I/Users/pooja/conda/nestml_dev/include/nest -I/usr/local/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk/usr/include -I/usr/local/Cellar/gsl/2.7/include -I/Users/pooja/miniconda3/envs/nest_3.6/include\u001b[0m\n", + "\u001b[0mNEST libraries flags : -L/Users/pooja/conda/nestml_dev/lib/nest -lnest -lsli -Xclang -fopenmp /usr/local/lib/libltdl.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libreadline.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libncurses.dylib /usr/local/Cellar/gsl/2.7/lib/libgsl.dylib /usr/local/Cellar/gsl/2.7/lib/libgslcblas.dylib\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0m-------------------------------------------------------\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mYou can now build and install 'nestml_c582d906cfdd4f76a2f0e5036501ac82_module' using\u001b[0m\n", + "\u001b[0m make\u001b[0m\n", + "\u001b[0m make install\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[0mThe library file libnestml_c582d906cfdd4f76a2f0e5036501ac82_module.so will be installed to\u001b[0m\n", + "\u001b[0m /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo\u001b[0m\n", + "\u001b[0mThe module can be loaded into NEST using\u001b[0m\n", + "\u001b[0m (nestml_c582d906cfdd4f76a2f0e5036501ac82_module) Install (in SLI)\u001b[0m\n", + "\u001b[0m nest.Install(nestml_c582d906cfdd4f76a2f0e5036501ac82_module) (in PyNEST)\u001b[0m\n", + "\u001b[0m\u001b[0m\n", + "\u001b[33mCMake Warning (dev) in CMakeLists.txt:\n", + " No cmake_minimum_required command is present. A line of code such as\n", + "\n", + " cmake_minimum_required(VERSION 3.28)\n", + "\n", + " should be added at the top of the file. The version specified may be lower\n", + " if you wish to support older CMake versions for this project. For more\n", + " information run \"cmake --help-policy CMP0000\".\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\u001b[0m\n", + "-- Configuring done (1.2s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /Users/pooja/nestml/master/doc/tutorials/gl_model/target\n", + "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.o\u001b[0m\n", + "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.o\u001b[0m\n", + "[ 75%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.o\u001b[0m\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:43:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:181:8: warning: 'register_stdp_connection' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]\n", + " void register_stdp_connection( double t_first_read, double delay );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/node.h:481:16: note: overridden virtual function is here\n", + " virtual void register_stdp_connection( double, double );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:154:16: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:245:10: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:159:16: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:256:10: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:49:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:181:8: warning: 'register_stdp_connection' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]\n", + " void register_stdp_connection( double t_first_read, double delay );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/node.h:481:16: note: overridden virtual function is here\n", + " virtual void register_stdp_connection( double, double );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:332:18: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:417:18: warning: unused variable '_tr_t' [-Wunused-variable]\n", + " const double _tr_t = __t_spike - __dendritic_delay;\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:532:16: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:543:16: warning: unused variable '__resolution' [-Wunused-variable]\n", + " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:334:10: warning: unused variable 'get_thread' [-Wunused-variable]\n", + " auto get_thread = [tid]()\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", + " C_[ lcid ].send( e, tid, cp );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", + " explicit Connector( const synindex syn_id )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", + " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:400:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:420:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:450:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:596:8: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:395:9: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::update_internal_state_' requested here\n", + " update_internal_state_(t_lastspike_, (start->t_ + __dendritic_delay) - t_lastspike_, cp);\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", + " C_[ lcid ].send( e, tid, cp );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", + " explicit Connector( const synindex syn_id )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", + " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:320:7: warning: expression result unused [-Wunused-value]\n", + " dynamic_cast(t);\n", + " ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:286:14: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::check_connection' requested here\n", + " connection.check_connection( src, tgt, receptor_type, get_common_properties() );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:334:10: warning: unused variable 'get_thread' [-Wunused-variable]\n", + " auto get_thread = [tid]()\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", + " C_[ lcid ].send( e, tid, cp );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", + " explicit Connector( const synindex syn_id )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", + " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:400:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:420:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:450:14: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:596:8: warning: unused variable 'get_t' [-Wunused-variable]\n", + " auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:395:9: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::update_internal_state_' requested here\n", + " update_internal_state_(t_lastspike_, (start->t_ + __dendritic_delay) - t_lastspike_, cp);\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", + " C_[ lcid ].send( e, tid, cp );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", + " explicit Connector( const synindex syn_id )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", + " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:320:7: warning: expression result unused [-Wunused-value]\n", + " dynamic_cast(t);\n", + " ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:286:14: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::check_connection' requested here\n", + " connection.check_connection( src, tgt, receptor_type, get_common_properties() );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", + " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", + " GenericConnectorModel( const std::string name )\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", + " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", + " ^\n", + "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", + " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", + " ^\n", + "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", + " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", + " ^\n", + "2 warnings generated.\n", + "3 warnings generated.\n", + "17 warnings generated.\n", + "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_c582d906cfdd4f76a2f0e5036501ac82_module.so\u001b[0m\n", + "[100%] Built target nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module\n", + "[100%] Built target nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module\n", + "\u001b[36mInstall the project...\u001b[0m\n", + "-- Install configuration: \"\"\n", + "-- Installing: /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.so\n", + "\n", + "Feb 26 11:22:03 Install [Info]: \n", + " loaded module nestml_c582d906cfdd4f76a2f0e5036501ac82_module\n" + ] + } + ], "source": [ "module_name, neuron_model_name, synapse_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", " nestml_neuron_model=nestml_gl_ca_neuron_model,\n", @@ -405,7 +1641,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -441,11 +1677,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 26 11:22:08 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Feb 26 11:22:08 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 2250\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:08 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHCCAYAAAAHCnZ4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB0EUlEQVR4nO3de1xUdf4/8NdwVwPyCphoZl7TzExTW822smx161dbbbuZlrXrtluZ214o91JfDNBQUgyEQEIN0OUiXhJIGwFRInACQ2gEuclFLjIDAsNlzu8PZWTkDmf4fM6Z9/PxmMdDhs858x5eMbz7nM85RyEIggBCCCGEEDNiwboAQgghhJChRg0QIYQQQswONUCEEEIIMTvUABFCCCHE7FADRAghhBCzQw0QIYQQQswONUCEEEIIMTvUABFCCCHE7FADRAghhBCzQw0QIYQQQswONUC9SExMxOrVqzF+/HgoFArExMSY/DWvXLmCV199FaNHj8bw4cPxwAMPID093eSvSwghhJgLaoB6cf36dcydOxe+vr5D8nrXrl3DI488Amtra3zzzTfIzs6Gt7c37rzzziF5fUIIIcQcKOhmqH2nUCgQHR2N5557zvBcc3MzNm/ejAMHDqC2thazZ8+Gl5cXli9fPqDX+Oc//4kzZ84gKSlJnKIJIYQQ0gnNAA3S66+/jjNnziA8PByZmZl48cUX8fTTT0OtVg9of7GxsXjooYfw4osvYty4cZg3bx4CAwNFrpoQQggxbzQD1A+3zwDl5eVh6tSpKCkpwfjx4w3jnnjiCSxcuBCffvppv1/Dzs4OALBp0ya8+OKL+P7777Fx40bs2bMHr732mijvgxBCCDF3VqwLkLKMjAwIgoBp06YZPa/T6TB69GgAQEFBASZPntzjfv785z8b1hjp9Xo89NBDhuZp3rx5+Omnn+Dn50cNECGEECISaoAGQa/Xw9LSEunp6bC0tDT63h133AEAuOuuu3Dx4sUe9zNy5EjDv11cXDBr1iyj78+cORORkZEiVU0IIYQQaoAGYd68eWhra8PVq1exdOnSLsdYW1tjxowZfd7nI488gtzcXKPnfv75Z0yaNGlQtRJCCCHkFmqAelFfX49Lly4Zvr58+TJUKhVGjRqFadOm4fe//z1ee+01eHt7Y968eaiqqsKpU6cwZ84cPPPMM/1+vffffx9LlizBp59+ipdeegnff/89AgICEBAQIObbIoQQQswaLYLuhVKpxGOPPdbp+bVr1yIkJAQtLS1wd3dHaGgorly5gtGjR2Px4sX4+OOPMWfOnAG95tGjR+Hm5ga1Wo3Jkydj06ZNeOuttwb7VgghhBByEzVAhBBCCDE7dB0gQgghhJgdaoAIIYQQYnZoEXQX9Ho9SktLYW9vD4VCwbocQgghhPSBIAioq6vD+PHjYWHRyxyPwNDp06eFVatWCS4uLgIAITo6usfxa9euFQB0esyaNcswZu/evV2OaWxs7HNdxcXFXe6DHvSgBz3oQQ968P8oLi7u9W890xmg9jutv/7663jhhRd6Hf/555/D09PT8HVrayvmzp2LF1980Wicg4NDp2vptN9ioi/s7e0BAMXFxXBwcOjzdn119OhRrFq1SvT9koGhPPhCefCF8uAPZdI9rVYLV1dXw9/xnjBtgFauXImVK1f2ebyjoyMcHR0NX8fExODatWt4/fXXjcYpFAo4OzsPuK72w14ODg4maYDuvPNOk+yXDAzlwRfKgy+UB38ok971ZfmKpBdBBwUF4Yknnuh0leT6+npMmjQJEyZMwKpVq3D+/Pke96PT6aDVao0epuTk5GTS/ZP+oTz4QnnwhfLgD2UiDsk2QGVlZfjmm2/w5ptvGj0/Y8YMhISEIDY2FmFhYbCzs8MjjzwCtVrd7b48PDwMs0uOjo5wdXUFAOTn52Pr1q3Q6XRwd3cHALi7u6O0tBRBQUFIS0tDXFwcoqKikJ2djZ07d0Kr1RqNrampwe7du5GZmYnY2FgcO3YM0dHR2LNnDyorK43GNjQ0wNvbG7m5uTh48CBOnjyJlJQUhISEoLi42GhsW1sbPDw8UFhYiH379iE5ORlKpRLh4eFQq9XYtm0bmpqajLYpLy9HYGAg0tLScOLECURHR+PChQvYtWsXNBqN0dja2lr4+voiKysLMTExOH78ONLT0xEQEICKigqjsY2NjfD29oZarUZERAROnTqFM2fOIDQ0FEVFRdiyZQv0ej3c3d2h1+uxZcsWFBUVITQ0FGfOnMGpU6cQEREBtVoNb29vNDY2Gu2/oqICAQEBSE9Px/HjxxETE4OsrCz4+vqitrbWaKxGo8GuXbtw4cIFREdH48SJE0hLS0NgYCDKy8uNxjY1NWHbtm04fvw4wsPDoVQqkZycjH379qGwsBAeHh5oa2sz2qa4uBghISFISUnByZMncfDgQeTm5sLb2xsNDQ1GYysrK7Fnzx5kZGTg2LFjiI2NRWZmJnbv3o2amhqjsVqtFjt37kR2djaioqIQFxeHtLQ0BAUFobS01GisTqfD1q1bkZeXh7CwMCiVSiQlJWH//v0oKCiAp6cnWltbjbYpKSnB3r17ce7cOSQkJODQoUPIycnBjh07UF9fbzS2qqoK/v7+UKlUOHr0KI4cOQKVSgU/Pz9UV1cbja2rq4OPjw+ys7MRGRmJ+Ph4pKamIjg4uFPdLS0t8PLyQn5+Pg4cOIDExEQkJibiwIEDyM/Ph5eXF1paWvDJJ58Y/a4FBwcjNTUV8fHxiIyMRHZ2Nnx8fFBXV2e0/+rqavj5+UGlUuHIkSM4evQoVCoV/P39UVVVZTS2vr4eO3bsQE5ODg4dOoSEhAScO3cOe/fuRUlJidHY1tZWeHp6oqCgAPv370dSUhKUSiXCwsKQl5dnks+IjIwMbj4jYmNjzf4zQq1Wc/UZERgYaNafEbf/rnX8jDh8+DD6ipsLISoUCkRHR+O5557r03gPDw94e3ujtLQUNjY23Y7T6/V48MEHsWzZMuzcubPLMTqdDjqdzvB1+zFEjUZjkmnGiooK6uA5QnnwhfLgC+XBH8qke1qtFo6Ojn36+y3JGSBBEBAcHIw1a9b02PwAgIWFBRYsWNDjDJCtra1hvY+p1v10FBgYaNL9k/6hPPhCefCF8uDP7Zno9Xo0NTWZzUOv14vyc5TkDFD7/bmysrIwe/bsHscKgoCFCxdizpw5CA4O7lMt/ekgCSGEEFaam5tx+fJl0ZoCKbCwsMDkyZO7nADpz99vpmeB9XSn9YkTJ8LNzQ1XrlxBaGio0XZBQUF4+OGHu2x+Pv74YyxatAhTp041HDNVqVTYvXu3yd9PX7m7u2Pz5s2syyA3UR58oTz4Qnnwpz0TQRBQVlYGS0tLuLq69n7hPxlov1BxWVkZJk6cOKiLFTOdAertTuvr1q1DQUEBlEql4XsajQYuLi74/PPPu7xD+vvvv4+oqCiUl5fD0dER8+bNw3//+18sXry4z3WZegaosbERw4YNE32/ZGAoD75QHnyhPPjTnklLSwsuXbqE8ePHG10iRu40Gg1KS0tx7733wtra2uh7klkDtHz5cgiC0OkREhICAAgJCTFqfoAb1wJqaGjosvkBgB07dqCwsBA6nQ5Xr15FXFxcv5qfofDFF1+wLoF0QHnwhfLgC+XBn/ZM2traAKDXtbBy0/5+29//QMl/voxDv/71r1mXQDqgPPhCefCF8uDP7ZmY2z0rxXq/1AAxkJGRwboE0gHlwRfKgy+UB38oE3FQA8TA2LFjWZdAOqA8+EJ58IXy4I85ZHL33XfDx8fHpK9BDRADtra2rEsgHVAefKE8+EJ58IcyEQc1QAzk5eWxLmHQsko0yCk37T3Thooc8pATyoMvlAd/KBNxML0OkLlavnw56xIGRdPYgtW+yQCAvE+fgaWFtBfgST0PuaE8+EJ58Ke7TARBQGPL4M6MGqhh1pb9WpxcV1eHDRs2ICYmBg4ODvj73/+Ow4cP44EHHjD5oa921AAxsG/fPnz00UesyxiwmuvNhn+3tOlhaWHJsJrBk3oeckN58IXy4E93mTS2tGHWv+MYVARkf/IUhtv0vaXYtGkTzpw5g9jYWDg5OeHf//43MjIy8MADD5iuyNtQA8SAm5sb6xIGxarDjI+ejzupDIrU85AbyoMvlAd/pJ5JXV0dvvrqK3z99dd4/PHHAQB79+7F+PHjh7QOaoAY+PTTTyV9aXmLDg1Qq176DZDU85AbyoMvlAd/ustkmLUlsj95ikFFN167r/Lz89HS0oKFCxcannN0dMT06dNNUVq3qAFi4MMPP2RdwqAYzQDJoAGSeh5yQ3nwhfLgT3eZKBSKfh2GYqX9Dly3rxka6jtz0VlgDHh4eLAuYVAsFPKaAZJ6HnJDefCF8uCP1DOZMmUKrK2t8f333xue02q1UKvVQ1oH/62iDK1Zs4Z1CYPS8aQvOawBknoeckN58IXy4I/UM7G3t8fatWvxt7/9DaNGjcK4cePwn//8BxYWFkN6Ww+aAWLg9hu8Splez7qCwZNTHnJAefCF8uCPHDLZvn07Fi9ejFWrVuGJJ57AI488gpkzZ8LOzm7IaqAZIAamTJnCugTRtMqgA5JTHnJAefCF8uCPHDKxt7fHgQMHDF9fv34dH3/8Mf7whz8AAAoKCkxeAzVADOh0OtYliEYG/Y+s8pADyoMvlAd/5JDJ+fPnkZOTg4ULF0Kj0eCTTz4BADz77LNDVgM1QAxUVlayLkE0cpgBklMeckB58IXy4I9cMvnss8+Qm5sLGxsbzJ8/H0lJSRgzZsyQvT41QAw8+OCDrEsQjRwWQcspDzmgPPhCefBHDpnMmzcP6enpTGugRdAMxMbGsi5BNHI4DV5OecgB5cEXyoM/lIk4qAFi4O2332ZdwqB0bHnaZNAAST0PuaE8+EJ58Of2TIb6AoKsifV+qQFiwNvbm3UJopHBEiBZ5SEHlAdfKA/+tGdiaXnj9hPNzc09DZed9vfb/v4HSiGYW+vYB1qtFo6OjtBoNHBwcGBdDneq6nV4yP1bAEDMnx/BA653si2IEELMkCAIKCoqQktLC8aPHw8LC/nPaej1epSWlsLa2hoTJ07sdOHE/vz9pkXQDLi7u8vm5oJyOAQmpzzkgPLgC+XBn/ZMFAoFXFxccPnyZRQWFrIua8hYWFh02fz0FzVADLz11lusSxCNHBogOeUhB5QHXygP/nTMxMbGBlOnTjWrw2A2NjaizHbJf76MQ4cPH2Zdgmjk0ADJKQ85oDz4Qnnw5/ZMLCwsYGdnZzYPsQ71UQPEwPz581mXMCgdV43JoQGSeh5yQ3nwhfLgD2UiDmqAGKioqGBdgmjaZLCGXk55yAHlwRfKgz+UiTioAWJATsdq22RwHryc8pADyoMvlAd/KBNxUAPEgBzu5NuuTfr9j6zykAPKgy+UB38oE3FQA8TA6dOnWZcgGjnMAMkpDzmgPPhCefCHMhEHNUAMvPrqq6xLEI0cZoDklIccUB58oTz4Q5mIgxogBnx9fVmXMChCh7uByWERtNTzkBvKgy+UB38oE3HQrTC6QLfC6NnVuiYs3HISALDj5bn4f/MmMK6IEEII6d/fb5oBYsDd3Z11CaKRwyEwOeUhB5QHXygP/lAm4qAZoC6YegZIo9HA0dFR9P0OlY4zQF4vzMHLCyYyrmhwpJ6H3FAefKE8+EOZdI9mgDgXGhrKugTRyGEGSE55yAHlwRfKgz+UiTioAWLgscceY12CaORwGryc8pADyoMvlAd/KBNxUAPEgFqtZl2CaORwLzA55SEHlAdfKA/+UCbioAaIgWHDhrEuYXA69DytMmiAJJ+HzFAefKE8+EOZiIMaIAZGjx7NugTR6GWwhl5OecgB5cEXyoM/lIk4mDZAiYmJWL16NcaPHw+FQoGYmJgexyuVSigUik6PnJwco3GRkZGYNWsWbG1tMWvWLERHR5vwXfSfSqViXYJo5LAIWk55yAHlwRfKgz+UiTiYNkDXr1/H3Llz+31Vy9zcXJSVlRkeU6dONXzv7NmzePnll7FmzRr8+OOPWLNmDV566SWkpqaKXf6ArV69mnUJopHDImg55SEHlAdfKA/+UCbiYNoArVy5Eu7u7nj++ef7td24cePg7OxseFhaWhq+5+PjgyeffBJubm6YMWMG3Nzc8Pjjj8PHx0fk6gfuyy+/ZF2CaOQwAySnPOSA8uAL5cEfykQcklwDNG/ePLi4uODxxx/Hd999Z/S9s2fPYsWKFUbPPfXUU0hJSel2fzqdDlqt1uhhSps3bzbp/oeSHGaA5JSHHFAefKE8+EOZiENSDZCLiwsCAgIQGRmJqKgoTJ8+HY8//jgSExMNY8rLy+Hk5GS0nZOTE8rLy7vdr4eHBxwdHQ0PV1dXAEB+fj62bt0KnU5nuPS4u7s7SktLERQUhLS0NMTFxSEqKgrZ2dnYuXMntFqt0diamhrs3r0bmZmZiI2NxbFjx/D2229jz549qKysNBrb0NAAb29v5Obm4uDBgzh58iRSUlIQEhKC4uJio7FtbW3w8PBAYWEh9u3bh+TkZCiVSoSHh0OtVmPbtm1oamoy2qa8vByBgYFIS0vDiRMnEB0djQsXLmDXrl3QaDRGY2tra+Hr64usrCzExMTg+PHjSE9PR0BAAK5WVhp+dqeTktHY2Ahvb2+o1WpERETg1KlTOHPmDEJDQ1FUVIQtW7ZAr9fD3d0der0eW7ZsQVFREUJDQ3HmzBmcOnUKERERUKvV8Pb2RmNjo1EtFRUVCAgIQHp6Oo4fP46YmBhkZWXB19cXtbW1RmM1Gg127dqFCxcuIDo6GidOnEBaWhoCAwNRXl5uNLapqQnbtm3D+++/j/DwcCiVSiQnJ2Pfvn0oLCyEh4cH2trajLYpLi5GSEgIUlJScPLkSRw8eBC5ubnw9vZGQ0OD0djKykrs2bMHGRkZOHbsGGJjY5GZmYndu3ejpqbGaKxWq8XOnTuRnZ2NqKgoxMXFIS0tDUFBQSgtLTUaq9PpsHXrVuTl5SEsLAxKpRJJSUnYv38/CgoK4OnpidbWVqNtSkpKsHfvXpw7dw4JCQk4dOgQcnJysGPHDtTX1xuNraqqgr+/P1QqFY4ePYojR45ApVLBz88P1dXVRmPr6urg4+OD7OxsREZGIj4+HqmpqQgODu5Ud0tLC7y8vJCfn48DBw4gMTERiYmJOHDgAPLz8+Hl5YWWlhY88cQTRr9rwcHBSE1NRXx8PCIjI5GdnQ0fHx/U1dUZ7b+6uhp+fn5QqVQ4cuQIjh49CpVKBX9/f1RVVRmNra+vx44dO5CTk4NDhw4hISEB586dw969e1FSUmI0trW1FZ6enigoKMD+/fuRlJQEpVKJsLAw5OXlmeQzIiMjg5vPiHfeeaffnxEVFRVGY6X+GaFWq7n6jHjllVfM+jPi9t+1jp8Rhw8fRl9xcysMhUKB6OhoPPfcc/3abvXq1VAoFIiNjQUA2NjY4KuvvsIrr7xiGHPgwAGsX78eTU1NXe5Dp9NBp9MZvtZqtXB1dTXZrTCamppgZ2cn+n6HSoW2CQ9/euNWGH989B64rZzJuKLBkXoeckN58IXy4A9l0j2zuhXGokWLjC4K5ezs3Gm25+rVq51mhTqytbWFg4OD0cOUdu3aZdL9DyW9DK4DJKc85IDy4AvlwR/KRBySb4DOnz8PFxcXw9eLFy9GQkKC0Zj4+HgsWbJkqEvrVn9nuXgmhwshyikPOaA8+EJ58IcyEYcVyxevr6/HpUuXDF9fvnwZKpUKo0aNwsSJE+Hm5oYrV64Ybvzm4+ODu+++G/fddx+am5uxf/9+REZGIjIy0rCP9957D8uWLYOXlxeeffZZHD58GN9++y2Sk5OH/P11Jz093ejUfSmTwwyQnPKQA8qDL5QHfygTcTBtgH744Qejm7pt2rQJALB27VqEhISgrKwMRUVFhu83Nzfjgw8+wJUrVzBs2DDcd999OHbsGJ555hnDmCVLliA8PBybN2/Gv/71L0yZMgURERF4+OGHh+6N9cLZ2Zl1CaJp42MJ2aDIKQ85oDz4QnnwhzIRB9MGaPny5ehpDXZISIjR13//+9/x97//vdf9/uY3v8FvfvObwZZnMlZWTH/sg9YxMjncDFXqecgN5cEXyoM/lIk4JL8GSIouX77MugTRyKEBklMeckB58IXy4A9lIg5qgBhYtmwZ6xJEI4dF0HLKQw4oD75QHvyhTMRBDRADX3/9NesSRCOHRdByykMOKA++UB78oUzEwc2FEHnSnwspDURbW5vR/cukplzThEUeNy6EuOp+F/j+7kHGFQ2O1POQG8qDL5QHfyiT7pnVhRClyMPDg3UJotHLoH+WUx5yQHnwhfLgD2UiDpoB6oKpZ4CkruMM0IpZTgh47SHGFRFCCCE0A8S99hu5SZWAWz2zHGaApJ6H3FAefKE8+EOZiIMaIAbWrl3LugTRyOE0eDnlIQeUB18oD/5QJuKgBoiBkydPsi5BNHI4DV5OecgB5cEXyoM/lIk4qAFiYNq0aaxLEI0cDoHJKQ85oDz4QnnwhzIRBzVADDQ2NrIuQTStbdJvgOSUhxxQHnyhPPhDmYiDGiAGqqurWZcgGjnMAMkpDzmgPPhCefCHMhEHNUAMzJ07l3UJg9Kx55HDGiCp5yE3lAdfKA/+UCbioAaIgaNHj7IuQTRyuBWGnPKQA8qDL5QHfygTcdCFELtg6gshNjQ0YPjw4aLvd6iU1jZiiecpAMB94x1w7N2ljCsaHKnnITeUB18oD/5QJt2jCyFybvv27axLEI0crgMkpzzkgPLgC+XBH8pEHDQD1AW6FUbPOs4ATXO6A/HvP8q4IkIIIYRmgLgnp8uYy2ERtJzykAPKgy+UB38oE3FQA8TAH//4R9YlDErHlkcOi6ClnofcUB58oTz4Q5mIgxogBqKioliXIBo5zADJKQ85oDz4QnnwhzIRBzVADCxYsIB1CaKRwwyQnPKQA8qDL5QHfygTcVADxEBZWRnrEkQjhxkgOeUhB5QHXygP/lAm4qAGiIG2tjbWJYhGDrfCkFMeckB58IXy4A9lIg5qgBi4++67WZcgGjnMAMkpDzmgPPhCefCHMhEHNUAMJCUlsS5BNHK4EKKc8pADyoMvlAd/KBNxUAPEwCuvvMK6hEHpeO1MOSyClnoeckN58IXy4A9lIg5qgBj44osvWJcgGjkcApNTHnJAefCF8uAPZSIOuhVGF+hWGD0rudaAX3h9BwCwtlRAveUZxhURQgghdCsM7snpMuZymAGSUx5yQHnwhfLgD2UiDpoB6oKpZ4C0Wq2kZ5Y6zgABQP6nz8DCQsGwosGReh5yQ3nwhfLgD2XSPZoB4lxISAjrEkTVJvEeWm55SB3lwRfKgz+UiTioAWLgiSeeYF3CoNze77S2SbsBknoeckN58IXy4A9lIg5qgBjIyclhXYKoWvV61iUMitzykDrKgy+UB38oE3FQA8TAiBEjWJcgKqlfDFFueUgd5cEXyoM/lIk4qAFiYNSoUaxLEFWLxA+ByS0PqaM8+EJ58IcyEQc1QAxkZmayLkFUUp8BklseUkd58IXy4A9lIg5qgBhYuXIl6xJE1dIm7TVAcstD6igPvlAe/KFMxEENEAPBwcGsSxCV1GeA5JaH1FEefKE8+EOZiIMuhNgFuhVGz4prGrB0660LIX67aRnuHWfPsCJCCCFEQhdCTExMxOrVqzF+/HgoFArExMT0OD4qKgpPPvkkxo4dCwcHByxevBhxcXFGY0JCQqBQKDo9mpqaTPhO+kdulzGX+u0w5JaH1FEefKE8+EOZiINpA3T9+nXMnTsXvr6+fRqfmJiIJ598EsePH0d6ejoee+wxrF69GufPnzca5+DggLKyMqOHnZ2dKd7CgPztb39jXYKopH4hRLnlIXWUB18oD/5QJuJg2gCtXLkS7u7ueP755/s03sfHB3//+9+xYMECTJ06FZ9++immTp2KI0eOGI1TKBRwdnY2evDk888/Z12CqKQ+AyS3PKSO8uAL5cEfykQckl4ErdfrUVdX1+maCPX19Zg0aRImTJiAVatWdZohup1Op4NWqzV6mNILL7xg0v0PtTaJXwlabnlIHeXBF8qDP5SJOCTdAHl7e+P69et46aWXDM/NmDEDISEhiI2NRVhYGOzs7PDII49ArVZ3ux8PDw84OjoaHq6urgCA/Px8bN26FTqdznDM1d3dHaWlpQgKCkJaWhri4uIQFRWF7Oxs7Ny5E1qt1mhsTU0Ndu/ejczMTMTGxuLYsWOIiIjAnj17UFlZaTS2oaEB3t7eyM3NxcGDB3Hy5EmkpKQgJCQExcXFRmPb2trg4eGBwsJC7Nu3D8nJyVAqlQgPD4darca2bdvQ1NRktE15eTkCAwORlpaGEydOIDo6GhcuXMCuXbug0WiMxtbW1sLX1xdZWVmIiYkxHHYMCAhAVVWV0c+vvqEJ3t7eUKvViIiIwKlTp3DmzBmEhoaiqKgIW7ZsgV6vh7u7O/R6PbZs2YKioiKEhobizJkzOHXqFCIiIqBWq+Ht7Y3GxkajWioqKhAQEID09HQcP34cMTExyMrKgq+vL2pra43GajQa7Nq1CxcuXEB0dDROnDiBtLQ0BAYGory83GhsU1MTtm3bhsOHDyM8PBxKpRLJycnYt28fCgsL4eHhgba2NqNtiouLERISgpSUFJw8eRIHDx5Ebm4uvL290dDQYDS2srISe/bsQUZGBo4dO4bY2FhkZmZi9+7dqKmpMRqr1Wqxc+dOZGdnIyoqCnFxcUhLS0NQUBBKS0uNxup0OmzduhV5eXkICwuDUqlEUlIS9u/fj4KCAnh6eqK1tdVom5KSEuzduxfnzp1DQkICDh06hJycHOzYsQP19fVGY6uqquDv7w+VSoWjR4/iyJEjUKlU8PPzQ3V1tdHYuro6+Pj4IDs7G5GRkYiPj0dqaiqCg4M71d3S0gIvLy/k5+fjwIEDSExMRGJiIg4cOID8/Hx4eXmhpaUFbm5uRr9rwcHBSE1NRXx8PCIjI5GdnQ0fHx/U1dUZ7b+6uhp+fn5QqVQ4cuQIjh49CpVKBX9/f1RVVRmNra+vx44dO5CTk4NDhw4hISEB586dw969e1FSUmI0trW1FZ6enigoKMD+/fuRlJQEpVKJsLAw5OXlmeQzIiMjg5vPiMjIyH5/RlRUVBiNbWxslPRnhFqt5uozwtfX16w/I27/Xev4GXH48GH0FTdngSkUCkRHR+O5557r0/iwsDC8+eabOHz4cI83htPr9XjwwQexbNky7Ny5s8sxOp0OOp3O8LVWq4Wrq6vJzgJTKpVYvny56PsdKkXVDVi27dZZYAfefBiP3DuGYUWDI/U85Iby4AvlwR/KpHv9OQvMaohqElVERATWr1+PQ4cO9XpXXAsLCyxYsKDHGSBbW1vY2tqKXWa3LC0th+y1hoLUL4QotzykjvLgC+XBH8pEHJI7BBYWFoZ169bh66+/xq9+9atexwuCAJVKBRcXlyGorm8KCwtZlyAqqV8IUW55SB3lwRfKgz+UiTiYzgDV19fj0qVLhq8vX74MlUqFUaNGYeLEiXBzc8OVK1cQGhoK4Ebz89prr+Hzzz/HokWLUF5eDgAYNmwYHB0dAQAff/wxFi1ahKlTpxqOmapUKuzevXvo32A3fvGLX7AuQVRSvxmq3PKQOsqDL5QHfygTcTCdAfrhhx8wb948zJs3DwCwadMmzJs3D//+978BAGVlZSgqKjKM37NnD1pbW/HnP/8ZLi4uhsd7771nGFNbW4s//OEPmDlzJlasWIErV64gMTERCxcuHNo314Pw8HDWJYhK6jNAcstD6igPvlAe/KFMxMHNImiemPpWGK2trbCykuTyKwCdF0F//tsH8OwDdzGsaHCknofcUB58oTz4Q5l0TzK3wjBXnp6erEsYFAHGPbPUrwQt9TzkhvLgC+XBH8pEHDQD1AW6GWrPCquv49FtSsPXW1+4Hy8tcGVXECGEEAKaAeKe3G5k1yLxK0HLLQ+pozz4QnnwhzIRBzVADKxbt451CaKS+iJoueUhdZQHXygP/lAm4qAGiIGEhATWJYhK6qfByy0PqaM8+EJ58IcyEQc1QAzMnDmTdQmikvrNUOWWh9RRHnyhPPhDmYiDGiAG6urqWJcwKLcvm5f6DJDU85AbyoMvlAd/KBNxUAPEQG1tLesSRCX1NUByy0PqKA++UB78oUzEQQ0QA3PmzGFdgqhaJX4zVLnlIXWUB18oD/5QJuKgBoiBb775hnUJomqV+AyQ3PKQOsqDL5QHfygTcdCFELtg6gsh1tfX44477hB9v0OloOo6ln+mNHz9x2X3wO0Z6S7Kk3oeckN58IXy4A9l0j26ECLnfHx8WJcgKqkvgpZbHlJHefCF8uAPZSIOmgHqAt0Ko2e3zwCtXTwJHz87m11BhBBCCGgGiHtSv4z57R1zi8TXAEk9D7mhPPhCefCHMhEHNUAMbNiwgXUJomqT+CEwueUhdZQHXygP/lAm4qAGiIH//e9/rEsQldRvhiq3PKSO8uAL5cEfykQc1AAxsGjRItYliErqF0KUWx5SR3nwhfLgD2UiDmqAGCgpKWFdgqikfh0gueUhdZQHXygP/lAm4qAGiAG5nXgn9StByy0PqaM8+EJ58IcyEQc1QAy4urqyLmFQbv/lk/ohMKnnITeUB18oD/5QJuKgBoiBs2fPsi5BVFK/EKLc8pA6yoMvlAd/KBNxUAPEwEsvvcS6BFFJfQZIbnlIHeXBF8qDP5SJOKgBYsDPz491CaJqkfgaILnlIXWUB18oD/5QJuKgW2F0gW6F0bP8ynr80vu04euHJo3E//60hGFFhBBCCN0Kg3tyu4w53QqDiIny4AvlwR/KRBw0A9QFU88A1dXVwd7eXvT9DpW8yno83mEGaPZdDjj6zlKGFQ2O1POQG8qDL5QHfyiT7tEMEOeCgoJYlyCqVomfBSa3PKSO8uAL5cEfykQc1AAxsGLFCtYliErqV4KWWx5SR3nwhfLgD2UiDmqAGLh48SLrEkQl9dPg5ZaH1FEefKE8+EOZiIMaIAbkduxW6qfByy0PqaM8+EJ58IcyEQc1QAw4OjqyLkFUUp8BklseUkd58IXy4A9lIg5qgBj46aefWJcwKLefNyj1W2FIPQ+5oTz4QnnwhzIRBzVADDz99NOsSxBVm17ah8DklofUUR58oTz4Q5mIgxogBoKDg1mXICqpnwYvtzykjvLgC+XBH8pEHHQhxC7QrTB6dulqPZ7YfutCiMOsLXHx/+j/SAghhLBFF0LknNwuYy71RdByy0PqKA++UB78oUzEQTNAXTD1DFBLSwusra1F3+9QuX0GSKEALnv8imFFgyP1POSG8uAL5cEfyqR7NAPEue3bt7MuQVSCIO1ZILnlIXWUB18oD/5QJuJg2gAlJiZi9erVGD9+PBQKBWJiYnrd5vTp05g/fz7s7Oxwzz33wN/fv9OYyMhIzJo1C7a2tpg1axaio6NNUP3Avfjii6xLGKQbzY6VhcLwjJQvhij9POSF8uAL5cEfykQcTBug69evY+7cufD19e3T+MuXL+OZZ57B0qVLcf78eXz44Yd49913ERkZaRhz9uxZvPzyy1izZg1+/PFHrFmzBi+99BJSU1NN9Tb67ezZs6xLEIW15a3/fKR8PzC55CEXlAdfKA/+UCbisGL54itXrsTKlSv7PN7f3x8TJ06Ej48PAGDmzJn44Ycf8Nlnn+GFF14AAPj4+ODJJ5+Em5sbAMDNzQ2nT5+Gj48PwsLCRH8PA+Hq6sq6BFFYWSqAlhv/bmnVA7Zs6xkoueQhF5QHXygP/lAm4pDUGqCzZ892ugvuU089hR9++AEtLS09jklJSRmyOs2FpYUC7UfBpHwIjBBCiPlhOgPUX+Xl5XBycjJ6zsnJCa2traiqqoKLi0u3Y8rLy7vdr06ng06nM3yt1WrFLfw2xcXFJt3/UFHgxmEwXaseLRI+BCaXPOSC8uAL5cEfykQckpoBAgCFQmH0dftZ/B2f72rM7c915OHhAUdHR8OjfXoxPz8fW7duhU6nM1x3wd3dHaWlpQgKCkJaWhri4uIQFRWF7Oxs7Ny5E1qt1mhsTU0Ndu/ejczMTMTGxuLYsWOwt7fHnj17UFlZaTS2oaEB3t7eyM3NxcGDB3Hy5EmkpKQgJCQExcXFRmPb2trg4eGBwsJC7Nu3D8nJyVAqlQgPD4darca2bdvQ1NRktE15eTkCAwORlpaGEydOIDo6GhcuXMCuXbug0WiMxtbW1sLX1xdZWVmIiYnB8ePHkZ6ejoCAAFRVVRt+dvrWGzNv/gGBUKvViIiIwKlTp3DmzBmEhoaiqKgIW7ZsgV6vh7u7O/R6PbZs2YKioiKEhobizJkzOHXqFCIiIqBWq+Ht7Y3GxkajWioqKhAQEID09HQcP34cMTExyMrKgq+vL2pra43GajQa7Nq1CxcuXEB0dDROnDiBtLQ0BAYGory83GhsU1MTtm3bBmdnZ4SHh0OpVCI5ORn79u1DYWEhPDw80NbWZrRNcXExQkJCkJKSgpMnT+LgwYPIzc2Ft7c3GhoajMZWVlZiz549yMjIwLFjxxAbG4vMzEzs3r0bNTU1RmO1Wi127tyJ7OxsREVFIS4uDmlpaQgKCkJpaanRWJ1Oh61btyIvLw9hYWFQKpVISkrC/v37UVBQAE9PT7S2thptU1JSgr179+LcuXNISEjAoUOHkJOTgx07dqC+vt5obFVVFfz9/aFSqXD06FEcOXIEKpUKfn5+qK6uNhpbV1cHHx8fZGdnIzIyEvHx8UhNTUVwcHCnultaWuDl5YX8/HwcOHAAiYmJSExMxIEDB5Cfnw8vLy+0tLQgPT3d6HctODgYqampiI+PR2RkJLKzs+Hj44O6ujqj/VdXV8PPzw8qlQpHjhzB0aNHoVKp4O/vj6qqKqOx9fX12LFjB3JycnDo0CEkJCTg3Llz2Lt3L0pKSozGtra2wtPTEwUFBdi/fz+SkpKgVCoRFhaGvLw8k3xGZGRkcPMZMWrUqH5/RlRUVBiNbWxshLe3t2Q/I9RqNVefEVqt1qw/I27/Xev4GXH48GH0mcAJAEJ0dHSPY5YuXSq8++67Rs9FRUUJVlZWQnNzsyAIguDq6ips377daMz27duFiRMndrvfpqYmQaPRGB7FxcUCAEGj0QzszfTC09PTJPsdKj+Xa4VJ/zgqPPBxnPDAx3HCpH8cFX4u17Iua8CknofcUB58oTz4Q5l0T6PR9Pnvt6RmgBYvXoyEhASj5+Lj4/HQQw8ZLgrV3ZglS5Z0u19bW1s4ODgYPUxp06ZNJt3/UGo/E0zKd4SXUx5yQHnwhfLgD2UiDqYNUH19PVQqFVQqFYAbp7mrVCoUFRUBuHEG12uvvWYYv2HDBhQWFmLTpk24ePEigoODERQUhA8++MAw5r333kN8fDy8vLyQk5MDLy8vfPvtt9i4ceNQvrUeeXl5sS5BNLcaIOkugpZTHnJAefCF8uAPZSIOprfCUCqVeOyxxzo9v3btWoSEhGDdunUoKCiAUqk0fO/06dN4//338dNPP2H8+PH4xz/+gQ0bNhht/7///Q+bN29Gfn4+pkyZgi1btuD555/vc110M9SeqSvq8OSORIwcbg3HYdYoqG7A/zYsxkN3j2JdGiGEEDMmmVthLF++HIIgdHqEhIQAAEJCQoyaHwB49NFHkZGRAZ1Oh8uXL3dqfgDgN7/5DXJyctDc3IyLFy/2q/kZCnK6kV37DFCzhGeA5JSHHFAefKE8+EOZiENSa4Dk4o033mBdgigUCoWhAWqV8BogueQhF5QHXygP/lAm4qAGiIETJ06wLmFQOrY61pY3Li8g5TVAUs9DbigPvlAe/KFMxEENEAP33Xcf6xJEI4dF0HLKQw4oD75QHvyhTMRBDRADGo2GdQmikcNp8HLKQw4oD75QHvyhTMRBDRADdXV1rEsQjZUMDoHJKQ85oDz4QnnwhzIRBzVADMycOZN1CaKxkcEhMDnlIQeUB18oD/5QJuKgBoiB+Ph41iWIov1mqIC0D4HJJQ+5oDz4QnnwhzIRBzVADKxfv551CaKxtpL+DJCc8pADyoMvlAd/KBNxUAPEwOeff866hEHpeO1wawvprwGSeh5yQ3nwhfLgD2UiDqa3wuAV3QqjZ7nldXjKJxGjR9jgiZlOiPihGH97ajr+/Ni9rEsjhBBixiRzKwxzJafLmFtbSX8GSE55yAHlwRfKgz+UiTioAWLgT3/6E+sSRGNlIf01QHLKQw4oD75QHvyhTMRBDRADBw8eZF2CKBQKwMZK+meBySUPuaA8+EJ58IcyEQc1QAwsXryYdQmikcO9wOSUhxxQHnyhPPhDmYiDGiAGiouLWZcwKEKH26HK4RCY1POQG8qDL5QHfygTcVADxIBCoWBdgmgMh8BapXsITE55yAHlwRfKgz+UiTioAWJgwoQJrEsQjeEQmF66M0ByykMOKA++UB78oUzEQQ0QA+fOnWNdgmjkcCsMOeUhB5QHXygP/lAm4qAGiIHf/OY3rEsQiQJW7Q1Qq3RngOSThzxQHnyhPPhDmYiDGiAG/P39WZcgGhsZnAUmpzzkgPLgC+XBH8pEHHQrjC7QrTB6drFMi5WfJ2HMHbb48JkZ2HTwRyybNhahbyxkXRohhBAzRrfC4JycLmMuh0NgcspDDigPvlAe/KFMxEENEAMbN25kXYJo5HAITE55yAHlwRfKgz+UiTj61QBZWFjA0tKy02PkyJFYtGgRoqKiTFWnrAQGBrIuQTSGs8D00j2SKqc85IDy4AvlwR/KRBxW/RkcHR3d5fO1tbX4/vvv8eqrr+Krr77Ciy++KEpxcrVy5UrWJYhCoZDHITC55CEXlAdfKA/+UCbi6FcD9Oyzz3b7vbVr12LWrFn47LPPqAHqRVZWFmbMmMG6DFHI4V5gcspDDigPvlAe/KFMxCHqGqAVK1bg559/FnOXsnTnnXeyLkE0NjdngFolfAhMTnnIAeXBF8qDP5SJOERtgBobG2FnZyfmLmXJ3t6edQmD0vHCCe1rgJolfAhM6nnIDeXBF8qDP5SJOERtgAIDAzFv3jwxdylLFy9eZF2CaKxkcAhMTnnIAeXBF8qDP5SJOPq1BmjTpk1dPq/RaPDDDz8gLy8PSUlJohQmZ08++STrEkRjY7gXmHQbIDnlIQeUB18oD/5QJuLo1wzQ+fPnu3xUVVXh6aefxk8//UQzQH0QEhLCugTRtB8Ca5XwzVDllIccUB58oTz4Q5mIg26F0QVzvRWGIAj4S9h5ODvY4V+rZnU7LrtUi2d2JmGcvS2i3l6CX3h9B1srC+S606mZhBBC2KFbYXCO18uY51bU4VhmGYKSL6OvfbEcDoHxmoe5ojz4QnnwhzIRBzVADPzzn/9kXUKXFFAY/t3Tae0Cbn2v/RCYXgDaJHoqPK95mCvKgy+UB38oE3FQA8TAZ599xrqELtlY3frPoa+ntVt32Eaqs0C85mGuKA++UB78oUzEQQ0QA7/97W9Zl9Cl9qs6A31vgNoPgQGArkWaDRCveZgryoMvlAd/KBNxUAPEQHJyMusSumRpcasB0vV1BshSAcXNzXRtbaYoy+R4zcNcUR58oTz4Q5mIgxogBiZNmsS6hF71ZQZIoQAUCoVhFkiqV4OWQh7mhPLgC+XBH8pEHNQAMdDG6UxJxxO/mvtRY/vaob7OGvGG1zzMFeXBF8qDP5SJOJg3QF988QUmT54MOzs7zJ8/v8crSa9btw4KhaLT47777jOMCQkJ6XJMU1PTULydPikrK2NdQq96amZuP0Pe1soSgHRngKSQhzmhPPhCefCHMhEH0wYoIiICGzduxEcffYTz589j6dKlWLlyJYqKiroc//nnn6OsrMzwKC4uxqhRo/Diiy8ajXNwcDAaV1ZWxtVNWhcuXMi6hF71p5mxtZL2ITAp5GFOKA++UB78oUzEwbQB2r59O9avX48333wTM2fOhI+PD1xdXeHn59fleEdHRzg7OxseP/zwA65du4bXX3/daJxCoTAa5+zsPBRvp88iIyNZl9CljhM7/Tmc1X4IrFmip8Hzmoe5ojz4QnnwhzIRB7MGqLm5Genp6VixYoXR8ytWrEBKSkqf9hEUFIQnnnii04Kw+vp6TJo0CRMmTMCqVatw/vz5Hvej0+mg1WqNHqb03nvvmXT/YujPbE77ImipngYvhTzMCeXBF8qDP5SJOJg1QFVVVWhra4OTk5PR805OTigvL+91+7KyMnzzzTd48803jZ6fMWMGQkJCEBsbi7CwMNjZ2eGRRx6BWq3udl8eHh5wdHQ0PFxdXQEA+fn52Lp1K3Q6neHS4+7u7igtLUVQUBDS0tIQFxeHqKgoZGdnY+fOndBqtUZja2pqsHv3bmRmZiI2NhbHjh3D+++/jz179qCystJobENDA7y9vZGbm4uDBw/i5MmTSElJQUhICIqLi43GtrW1wcPDA4WFhdi3bx+Sk5OhVCoRHh4OtVqNbdu2oampyWib8vJyBAYGIi0tDSdOnEB0dDQuXLiAXbt2QaPRYNfOnYafyTVNHXx9fZGVlYWYmBgcP34c6enpCAgIQE1NDYAbV452d3eH9Y0lQCgoKkZERAROnTqFM2fOIDQ0FEVFRdiyZQv0ej3c3d2h1+uxZcsWFBUVITQ0FGfOnMGpU6cQEREBtVoNb29vNDY2GtVdUVGBgIAApKen4/jx44iJiUFWVhZ8fX1RW1trNFaj0WDXrl24cOECoqOjceLECaSlpSEwMBDl5eVGY5uamrBt2zb885//RHh4OJRKJZKTk7Fv3z4UFhbCw8MDbW1tRtsUFxcjJCQEKSkpOHnyJA4ePIjc3Fx4e3ujoaHBaGxlZSX27NmDjIwMHDt2DLGxscjMzMTu3btRU1NjNFar1WLnzp3Izs5GVFQU4uLikJaWhqCgIJSWlhqN1el02Lp1K/Ly8hAWFgalUomkpCTs378fBQUF8PT0RGtrq9E2JSUl2Lt3L86dO4eEhAQcOnQIOTk52LFjB+rr643GVlVVwd/fHyqVCkePHsWRI0egUqng5+eH6upqo7F1dXXw8fFBdnY2IiMjER8fj9TUVAQHB3equ6WlBV5eXsjPz8eBAweQmJiIxMREHDhwAPn5+fDy8kJLSwt+9atfGf2uBQcHIzU1FfHx8YiMjER2djZ8fHxQV1dntP/q6mr4+flBpVLhyJEjOHr0KFQqFfz9/VFVVWU0tr6+Hjt27EBOTg4OHTqEhIQEnDt3Dnv37kVJSYnR2NbWVnh6eqKgoAD79+9HUlISlEolwsLCkJeXZ5LPiIyMDG4+Iz744APDZ0THsbW1td1+RlRUVBiNbWxshLe3N9RqtSQ/I9RqNVefEevWrTPrz4jbf9c6fkYcPnwYfcXsZqilpaW46667kJKSgsWLFxue37JlC/bt24ecnJwet/fw8IC3tzdKS0thY2PT7Ti9Xo8HH3wQy5Ytw84Of+A70ul00Ol0hq+1Wi1cXV3N7maoJdca8Auv7wAAX/z+QTwzx6XLcReuaLBqVzKcHexw7sPH8Ru/FPxQeA3+rz6Ip2d3vQ0hhBBiapK4GeqYMWNgaWnZabbn6tWrnWaFbicIAoKDg7FmzZoemx8AsLCwwIIFC3qcAbK1tYWDg4PRw5SkcCM7Xav5nAYvhTzMCeXBF8qDP5SJOJg1QDY2Npg/fz4SEhKMnk9ISMCSJUt63Pb06dO4dOkS1q9f3+vrCIIAlUoFFxd+ZibeeOMN1iX0aiBngUm1AZJCHuaE8uAL5cEfykQcTM8C27RpE7788ksEBwfj4sWLeP/991FUVIQNGzYAANzc3PDaa6912i4oKAgPP/wwZs+e3el7H3/8MeLi4pCfnw+VSoX169dDpVIZ9smDb775hnUJXTK6EOJAzgKTaAPEax7mivLgC+XBH8pEHFYsX/zll19GdXU1PvnkE5SVlWH27Nk4fvy44ayusrKyTtcE0mg0iIyMxOeff97lPmtra/GHP/wB5eXlcHR0xLx585CYmMjVdRPuv/9+1iX0qn+nwVv2exueSCEPc0J58IXy4A9lIg6mDRAAvP3223j77be7/F5ISEin5xwdHdHQ0NDt/nbs2IEdO3aIVZ5JtJ9FxbO+NDPtN0GV+r3ApJCHOaE8+EJ58IcyEQfzW2GYo+vXr7MuoVf9WgNkLe0GSAp5mBPKgy+UB38oE3FQA8TAjBkzWJfQq/5c1dlwIcR+nDnGEynkYU4oD75QHvyhTMRBDRAD3377LesSetXTbE7nm6FKewZICnmYE8qDL5QHfygTcVADxMC6detYl9Cr/szm2Er8XmBSyMOcUB58oTz4Q5mIgxogBrq7IjVrgz0NXqr3AuM1D3NFefCF8uAPZSIOaoAY2Lx5M+sSetWXBujmSWCSvxu8FPIwJ5QHXygP/lAm4qAGiAEpXMa8P82M7c3rAEl1DZAU8jAnlAdfKA/+UCbioAaIge6ue8SagFvHwPpzOOvWvcCkeRYYr3mYK8qDL5QHfygTcVADxEBYWBjrEnrV0wxQx0YJ6HgavDRngKSQhzmhPPhCefCHMhEHNUAMLF26lHUJverfrTCkfRq8FPIwJ5QHXygP/lAm4qAGiIGCggLWJXRpoGeBSf1u8LzmYa4oD75QHvyhTMRBDRADlpaWrEvolTnNAEkhD3NCefCF8uAPZSIOaoAYcHFxYV1Cr5r7sKBZcfNuqFI/DV4KeZgTyoMvlAd/KBNxUAPEQFpaGusSutRxafNAToOX6llgvOZhrigPvlAe/KFMxEENEAPPP/886xJ6NZA1QFI9BCaFPMwJ5cEXyoM/lIk4qAFiYM+ePaxL6FV/boYq9TVAUsjDnFAefKE8+EOZiIMaIAZ4vYy50KGz6dciaIlfB4jXPMwV5cEXyoM/lIk4qAFiQAqXMe/XITBrac8ASSEPc0J58IXy4A9lIg5qgBjYtGkT6xJ61aoX0NrHhdDtM0CtegFteqGX0fyRQh7mhPLgC+XBH8pEHNQAMeDn58e6hC7d3ro09XFGx9b61jUppHgmGK95mCvKgy+UB38oE3FQA8TAqlWrWJfQJ00tfWtm7Kxu/WfU1I+bqPJCKnmYC8qDL5QHfygTcVADxMCPP/7IuoQ+aWzuugG6fabIytIC1pY3LorY16aJJ1LJw1xQHnyhPPhDmYiDGiAGRo8ezbqELt1+ent/DmfZ3bwYYqMEGyBe8zBXlAdfKA/+UCbioAaIgWHDhrEuoU/6czjLzsby5jbSa4Ckkoe5oDz4QnnwhzIRBzVADPz888+sS+iT3mZzbt4KDABgd/NUeCmuAZJKHuaC8uAL5cEfykQc1AAx8Pjjj7MuoRvGx8D6M5szzFq6M0D85mGeKA++UB78oUzEQQ0QA1999RXrEvqkX4fAJNwASSUPc0F58IXy4A9lIg5qgBiQymXMu2tmhNtXS+PWImgpHgKTSh7mgvLgC+XBH8pEHNQAMSCVy5j354yu9kXQUjwLTCp5mAvKgy+UB38oE3FQA8SAm5sb6xK61Ok0+P40QFbti6Cl1wDxmoe5ojz4QnnwhzIRBzVADGzdupV1CX3S2+GsjmeBDZPwafBSycNcUB58oTz4Q5mIgxogBn73u9+xLqFP+tPM3FoDJL0GSCp5mAvKgy+UB38oE3FQA8RAYmIi6xK6dPvS5n6tAZLwdYB4zcNcUR58oTz4Q5mIgxogBiZPnsy6hD4ZyJWgpbgIWip5mAvKgy+UB38oE3FQA8RAa2sr6xL6pKmbe4F1Pgle2ofApJKHuaA8+EJ58IcyEQc1QAyUl5ezLqFLt58F1q8rQdtI9zpAvOZhrigPvlAe/KFMxEENEAPz589nXUKf9NYAKXDrNDApnwYvlTzMBeXBF8qDP5SJOKgBYiAmJoZ1CX1iLrfCkEoe5oLy4AvlwR/KRBzUADHwzjvvsC6hS8Jgbobafgism3VDPOM1D3NFefCF8uAPZSIO5g3QF198gcmTJ8POzg7z589HUlJSt2OVSiUUCkWnR05OjtG4yMhIzJo1C7a2tpg1axaio6NN/Tb65bPPPmNdQp/0pwGyvbkIurFZeg2QVPIwF5QHXygP/lAm4mDaAEVERGDjxo346KOPcP78eSxduhQrV65EUVFRj9vl5uairKzM8Jg6darhe2fPnsXLL7+MNWvW4Mcff8SaNWvw0ksvITU11dRvp8+kciO7xm4OgXVxL1RJL4KWSh7mgvLgC+XBH8pEHEwboO3bt2P9+vV48803MXPmTPj4+MDV1RV+fn49bjdu3Dg4OzsbHpaWlobv+fj44Mknn4SbmxtmzJgBNzc3PP744/Dx8THxu+k7Xm9kZ673AuM1D3NFefCF8uAPZSIOZg1Qc3Mz0tPTsWLFCqPnV6xYgZSUlB63nTdvHlxcXPD444/ju+++M/re2bNnO+3zqaee6nGfOp0OWq3W6GFKb775pkn3L5Z+3QpDwougpZKHuaA8+EJ58IcyEQezBqiqqgptbW1wcnIyet7Jyanbaxy4uLggICAAkZGRiIqKwvTp0/H4448bXRa8vLy8X/sEAA8PDzg6Ohoerq6uAID8/Hxs3boVOp3O0HG7u7ujtLQUQUFBSEtLQ1xcHKKiopCdnY2dO3dCq9Uaja2pqcHu3buRmZmJ2NhYHDt2DL6+vtizZw8qKyuNxjY0NMDb2xu5ubk4ePAgTp48iZSUFISEhKC4uNhobFtbGzw8PFBYWIh9+/YhOTkZSqUS4eHhUKvV2LZtG5qamoy2KS8vR2BgINLS0nDixAlER0fjwoUL2LVrFzQaDQICAox+LtfqriMrKwsxMTE4fvw40tPTERAQgGs1NQBu3AzV3d0djY2NiPh6HwBAc70Rp06dwpkzZxAaGoqioiJs2bIFer0e7u7u0Ov12LJlC4qKihAaGoozZ87g1KlTiIiIgFqthre3NxobG43qrqioQEBAANLT03H8+HHExMQgKysLvr6+qK2tNRqr0Wiwa9cuXLhwAdHR0Thx4gTS0tIQGBiI8vJyo7FNTU3Ytm0bvvzyS4SHh0OpVCI5ORn79u1DYWEhPDw80NbWZrRNcXExQkJCkJKSgpMnT+LgwYPIzc2Ft7c3GhoajMZWVlZiz549yMjIwLFjxxAbG4vMzEzs3r0bNTU1RmO1Wi127tyJ7OxsREVFIS4uDmlpaQgKCkJpaanRWJ1Oh61btyIvLw9hYWFQKpVISkrC/v37UVBQAE9PT7S2thptU1JSgr179+LcuXNISEjAoUOHkJOTgx07dqC+vt5obFVVFfz9/aFSqXD06FEcOXIEKpUKfn5+qK6uNhpbV1cHHx8fZGdnIzIyEvHx8UhNTUVwcHCnultaWuDl5YX8/HwcOHAAiYmJSExMxIEDB5Cfnw8vLy+0tLRgw4YNRr9rwcHBSE1NRXx8PCIjI5GdnQ0fHx/U1dUZ7b+6uhp+fn5QqVQ4cuQIjh49CpVKBX9/f1RVVRmNra+vx44dO5CTk4NDhw4hISEB586dw969e1FSUmI0trW1FZ6enigoKMD+/fuRlJQEpVKJsLAw5OXlmeQzIiMjg5vPCH9/f8NnRMextbW18PX17fIzoqKiwmhsY2MjvL29oVarERERIbnPCLVazdVnxMcff2zWnxG3/651/Iw4fPgw+kohCF2t6DC90tJS3HXXXUhJScHixYsNz2/ZsgX79u3rtLC5O6tXr4ZCoUBsbCwAwMbGBl999RVeeeUVw5gDBw5g/fr1aGpq6nIfOp0OOp3O8LVWq4Wrqys0Gg0cHBwG8vZ6lJaWhgULFoi+38HKLtXimZ23FqEPs7bExf97utO49MJreMEvBZNGD8fpvz0GACiqbsCybd91uw3PeM3DXFEefKE8+EOZdE+r1cLR0bFPf7+ZzQCNGTMGlpaWnWZmrl692mkGpyeLFi2CWq02fO3s7Nzvfdra2sLBwcHoYUrV1dUm3f9gWdy8vmFTaxv62h/b2Vj0exte8J6HuaE8+EJ58IcyEQezBsjGxgbz589HQkKC0fMJCQlYsmRJn/dz/vx5uLi4GL5evHhxp33Gx8f3a5+m1tjYyLqEHo2wsQJwY1F012d1dW5wht1cAyQIgK5VWmeC8Z6HuaE8+EJ58IcyEYcVyxfftGkT1qxZg4ceegiLFy9GQEAAioqKDGsA3NzccOXKFYSGhgK4cYbX3Xffjfvuuw/Nzc3Yv38/IiMjERkZadjne++9h2XLlsHLywvPPvssDh8+jG+//RbJyclM3mNXOp62z5P2CyHaWluivrkVggBcb241nOLek+E2t/5TamhuMyyKlgJe8zBXlAdfKA/+UCbiYHoa/MsvvwwfHx988skneOCBB5CYmIjjx49j0qRJAICysjKjawI1Nzfjgw8+wP3334+lS5ciOTkZx44dw/PPP28Ys2TJEoSHh2Pv3r24//77ERISgoiICDz88MND/v66c/uZa7yxUADDbzYwDbq+ndVlaaGAnfWN/5yu66R1p2Le8zA3lAdfKA/+UCbiYLYImmf9WUQ1EBqNBo6OjqLvd7B+KtXgVzuT4eRgC70AVNbp8M17SzHTxfhnkF5Ygxf8zuLu0cOhvLkIGgDm/18Cqq83I27jMkx3th/q8geM1zzMFeXBF8qDP5RJ9ySxCNqc7dq1i3UJXerYCo+4edirobnvsznDbW9sc70f2/CA1zzMFeXBF8qDP5SJOKgBYkAKlzFvX9NzvY+HwIBbi6f7etiMF1LIw5xQHnyhPPhDmYiDGiAGeL+MuQIKjLDtfgaou4Omw22kOQPEex7mhvLgC+XBH8pEHNQAMfCXv/yFdQm9GtAMkO3NGSCJNUBSyMOcUB58oTz4Q5mIgxogBvbv38+6hF71NAPUHcMMkMQOgUkhD3NCefCF8uAPZSIOaoAYePTRR1mX0COFosMMUHP3zYxCoTD62rAGSGIzQLznYW4oD75QHvyhTMRBDRADeXl5rEvoleEssH5c08dwFpjEZoCkkIc5oTz4QnnwhzIRBzVADNjY2LAuoUsdFzcP68MM0O2kOgPEax7mivLgC+XBH8pEHNQAMdCfm72yoMAArwM0gKaJB7znYW4oD75QHvyhTMRBDRAD6enprEvo1XDb7s8C6+7S4SMMh8CkNQMkhTzMCeXBF8qDP5SJOKgBYuDZZ59lXUKXhA6tzaBmgCS2BojXPMwV5cEXyoM/lIk4qAFiIDAwkHUJPVIoFIYZoIaezgK77euBnDrPA97zMDeUB18oD/5QJuKgBogBKVzGfIThqs59n82R6hogKeRhTigPvlAe/KFMxEENEAO8Xsa841lgww339er7bM5ATp3nAa95mCvKgy+UB38oE3FQA8TAX//6V9Yl9OrW4ayB3ApDWjNAUsjDnFAefKE8+EOZiIMaIAa++OIL1iX06tbhrL7fDNVwFpjE1gBJIQ9zQnnwhfLgD2UiDmqAGPj1r3/NuoQudexrBnJK+63DZtKaAeI1D3NFefCF8uAPZSIOaoAYyMjIYF1Cr9oPZ7W0CWhq6aahue00sPYrQTe36dHcqjdleaKSQh7mhPLgC+XBH8pEHNQAMTB27FjWJfRIoQDusLFC+71O65r6NgvUPmsEAPUSWgjNex7mhvLgC+XBH8pEHNQAMWBra8u6hC4JHRb3WFgocMfNWSBtU0uftreytDCcCaZt7Ns2POA1D3NFefCF8uAPZSIOaoAYkMqdfB3srAH0fQYIAOwHsA1rUsnDXFAefKE8+EOZiIMaIAaWL1/OuoQetR/6sre7MQNUd9sMkNDdaWAAHIb1b9aIB7znYW4oD75QHvyhTMRBDRAD+/btY11Cl25va9pngLSNA5kBkk4DxGse5ory4AvlwR/KRBzUADHg5ubGuoQ+6W4GqCcON7fpT9PEmlTyMBeUB18oD/5QJuKgBoiBTz/9lHUJPVLcPL/9VgPUdTNz+81Qb2xzc9ZIQjNAvOdhbigPvlAe/KFMxEENEAMffvgh6xK6dPvSnoE0M7fWAElnBojXPMwV5cEXyoM/lIk4qAFiwMPDg3UJfdLezAzsLDDpzABJJQ9zQXnwhfLgD2UiDmqAGFizZg3rEnp06yywAcwADWDhNGu852FuKA++UB78oUzEQQ0QA0qlknUJfWLfzYLm7k+CH9jCadakkoe5oDz4QnnwhzIRBzVADEyZMoV1Cd0wbm0GcjjLYZj0LoTIbx7mifLgC+XBH8pEHNQAMaDT6ViX0KP2s7scejsLTNH5PDDDrJGEZoB4z8PcUB58oTz4Q5mIgxogBiorK1mX0CeDWQMkpRkgqeRhLigPvlAe/KFMxEENEAMPPvgg6xK6dPtp8L3NAHXFQYIzQLzmYa4oD75QHvyhTMRBDRADsbGxrEvoUfuhrVvreVqg1/e09PmWjjdD7emeYTzhPQ9zQ3nwhfLgD2UiDmqAGHj77bdZl9AnjjcbIL1gPAvUU1/Tvk2bXkC9ThqHwaSSh7mgPPhCefCHMhEHNUAMeHt7sy6hS7f3NXbWlhhuYwkAuNbQ3Kd9DLOxhJ31jf+sahukcRiM1zzMFeXBF8qDP5SJOKgBYmDz5s2sS+izkcNtAAA1XTRAXd0LDABGtW9zvW9NE2tSysMcUB58oTz4Q5mIgxogBtzd3VmX0KOOjc2oETeamWv9aGZGjui+aeIR73mYG8qDL5QHfygTcVADxMBbb73FuoQudbW2p72ZudaPw1nts0b9aZpY4jUPc0V58IXy4A9lIg7mDdAXX3yByZMnw87ODvPnz0dSUlK3Y6OiovDkk09i7NixcHBwwOLFixEXF2c0JiQkBAqFotOjqanJ1G+lzw4fPsy6hD4bOfzGouYBzQBJpAGSUh7mgPLgC+XBH8pEHEwboIiICGzcuBEfffQRzp8/j6VLl2LlypUoKirqcnxiYiKefPJJHD9+HOnp6XjsscewevVqnD9/3micg4MDysrKjB52dnZD8Zb6ZP78+axL6FmHY2BdrQESerwbGDDqZtMklUXQ3OdhZigPvlAe/KFMxGHF8sW3b9+O9evX48033wQA+Pj4IC4uDn5+fvDw8Og03sfHx+jrTz/9FIcPH8aRI0cwb948w/MKhQLOzs4mrX0wKioqWJfQpa6u29O+Bqi2H+t5pLYGiNc8zBXlwRfKgz+UiTiYzQA1NzcjPT0dK1asMHp+xYoVSElJ6dM+9Ho96urqMGrUKKPn6+vrMWnSJEyYMAGrVq3qNEN0O51OB61Wa/QwpeZmaTQGwK1DYF0dzuriVmAABrZwmiUp5WEOKA++UB78oUzEwawBqqqqQltbG5ycnIyed3JyQnl5eZ/24e3tjevXr+Oll14yPDdjxgyEhIQgNjYWYWFhsLOzwyOPPAK1Wt3tfjw8PODo6Gh4uLq6AgDy8/OxdetW6HQ6w6p7d3d3lJaWIigoCGlpaYiLi0NUVBSys7Oxc+dOaLVao7E1NTXYvXs3MjMzERsbi2PHjkGn02HPnj2orKw0GtvQ0ABvb2/k5ubi4MGDOHnyJFJSUhASEoLi4mKjsW1tbfDw8EBhYSH27duH5ORkKJVKhIeHQ61WY9u2bWhqajLapry8HIGBgUhLS8OJEycQHR2NCxcuYNeuXdBoNAjdFwoAqK6qRm1tLXx9fVFXfSOLvJIKpKenIyAgANeuXTP87Nzd3dHY2Ahvb2+o1WpERESg9PLPAICL+cUoKirCli1boNfr4e7uDr1ejy1btqCoqAihoaE4c+YMTp06hYiICKjVanh7e6OxsdGo7oqKCgQEBCA9PR3Hjx9HTEwMsrKy4Ovri9raWqOxGo0Gu3btwoULFxAdHY0TJ04gLS0NgYGBKC8vNxrb1NSEbdu2wcrKCuHh4VAqlUhOTsa+fftQWFgIDw8PtLW1GW1TXFyMkJAQpKSk4OTJkzh48CByc3Ph7e2NhoYGo7GVlZXYs2cPMjIycOzYMcTGxiIzMxO7d+9GTU2N0VitVoudO3ciOzsbUVFRiIuLQ1paGoKCglBaWmo0VqfTYevWrcjLy0NYWBiUSiWSkpKwf/9+FBQUwNPTE62trUbblJSUYO/evTh37hwSEhJw6NAh5OTkYMeOHaivrzcaW1VVBX9/f6hUKhw9ehRHjhyBSqWCn58fqqurjcbW1dXBx8cH2dnZiIyMRHx8PFJTUxEcHNyp7paWFnh5eSE/Px8HDhxAYmIiEhMTceDAAeTn58PLywstLS04efKk0e9acHAwUlNTER8fj8jISGRnZ8PHxwd1dXVG+6+uroafnx9UKhWOHDmCo0ePQqVSwd/fH1VVVUZj6+vrsWPHDuTk5ODQoUNISEjAuXPnsHfvXpSUlBiNbW1thaenJwoKCrB//34kJSVBqVQiLCwMeXl5JvmMyMjI4OYzQq/XGz4jOo5t/4zIyspCTEyMYWlCQEAAKioqjMbe/hlx6tQpnDlzBqGhoZL4jFCr1Vx9Rly+fNmsPyNu/13r+BnRr/VRAiNXrlwRAAgpKSlGz7u7uwvTp0/vdfuvv/5aGD58uJCQkNDjuLa2NmHu3LnCO++80+2YpqYmQaPRGB7FxcUCAEGj0fTtzfTTrl27TLLfwTqbVyVM+sdR4ZeffWd47oy6Upj0j6PCE97KW89duvHck9uVXexFEJLVPX+fN7zmYa4oD75QHvyhTLqn0Wj6/Peb2RqgMWPGwNLSstNsz9WrVzvNCt0uIiIC69evx6FDh/DEE0/0ONbCwgILFizocQbI1tYWtra2fS9+kF599dUhe63BunUafN+nXO80HDaTxiJoKeVhDigPvlAe/KFMxMHsEJiNjQ3mz5+PhIQEo+cTEhKwZMmSbrcLCwvDunXr8PXXX+NXv/pVr68jCAJUKhVcXFwGXbNYfH19WZfQI0WHxT2jOlwHqK83RB3VoWkSJHBDVN7zMDeUB18oD/5QJuJgehbYpk2bsGbNGjz00ENYvHgxAgICUFRUhA0bNgAA3NzccOXKFYSG3libEhYWhtdeew2ff/45Fi1aZJg9GjZsGBwdHQEAH3/8MRYtWoSpU6cajpmqVCrs3r2bzZvsAq+XMe+qVxk1wgYKxY2bm15raMboO2w73zSsi22AG9vUNrQYZpF4xWse5ory4AvlwR/KRBxMrwP08ssvw8fHB5988gkeeOABJCYm4vjx45g0aRIAoKyszOiaQHv27EFrayv+/Oc/w8XFxfB47733DGNqa2vxhz/8ATNnzsSKFStw5coVJCYmYuHChUP+/rojpcuYW1taGO7tVaHVGX1P0c3dwGytLA2Hwa7W6bocwxMp5WEOKA++UB78oUzEoRCkcIxiiGm1Wjg6OkKj0cDBwUH0/Ws0GsOMFU/O5lXjlcBzmDruDiRsetTw/NM+icgpr0PI6wuwfPo4pFyqwu++TMV0J3vEvb+sy309tSMRuRV1CH1jIZZNGztUb2FAeM3DXFEefKE8+EOZdK8/f7+Z3wrDHLUf0uNNd1d4dnK4cRXt/szmjHOw7fc2rPCah7miPPhCefCHMhEHNUAMPPbYY6xL6Jdx9jeamcr+NED2N5qmCi0/92DrjtTykDvKgy+UB38oE3FQA8RAT6fk8+D2Kzy3z+b0p5lp36Y/TRMrvOdhbigPvlAe/KFMxEENEAPDhg1jXUK/tM/mXL25CLovi8ac7PvfNLEitTzkjvLgC+XBH8pEHNQAMTB69GjWJXStm86m/RDY1bq+NzMDWTfECrd5mCnKgy+UB38oE3FQA8SASqViXUKPbj+9fVw3zUx3N0O9sY10ZoB4z8PcUB58oTz4Q5mIgxogBlavXs26hH65NQOk6/OVnQ2HzfqxDStSy0PuKA++UB78oUzEQQ0QA19++SXrErrUXZvi5GAHhQJobtWjqr5v9wRrnwFqbtWj5nrf7yPGAq95mCvKgy+UB38oE3FQA8SA1C5jbmNlAZebh8GKrzX0aRtbK0s43WyCSq41mqw2MUgtD7mjPPhCefCHMhEHNUAM8H4Z867W9kwYORzAjWamr0e0XG9u09emiRXe8zA3lAdfKA/+UCbioAaIgQ8++IB1CV3qqbGZMPLGaZfFNX1vZlxH3WyAavieAeI1D3NFefCF8uAPZSIOaoAY2LVrF+sS+m3CqFszQH3e5mbTVML5DJAU85AzyoMvlAd/KBNxUAPEwHPPPce6hH4bSDNz6xAY3zNAUsxDzigPvlAe/KFMxEENEAPp6emsS+hSdzdDBW41M/2aARp1s2nqx2EzFnjNw1xRHnyhPPhDmYiDGiAGnJ2dWZfQb+0zQFeuNaKtj6ugOzZNej2/1wKSYh5yRnnwhfLgD2UiDmqAGLCysmJdQo8UXZwGNv7OYbCxskBzm77Ph8FcHO1gY3ljm1INv4fBeM/D3FAefKE8+EOZiIMaIAYuX77MuoQu9TSxY2mhwJSxdwAA1BX1fdqflaUF7hk74sY2V/u2DQu85mGuKA++UB78oUzEQQ0QA8uWLWNdwoDcO+5GA3TpZjPT1UxRd9uoK+pMV9ggSTUPuaI8+EJ58IcyEQc1QAx8/fXXrEvoUXdtzdT2ZuZq35uZqePsb2zTx1kjFnjPw9xQHnyhPPhDmYiDGiAG/v73v7MuoUu9LVNun82p0Op6GXnLVKf2ponfBojXPMwV5cEXyoM/lIk4qAFiwMPDg3UJA9I+AzSQbS5dref2rvBSzUOuKA++UB78oUzEQQ0QA7zfyK67pT13jxkBW6v+/SczafQI2FhaoF7Xyu0tMXjPw9xQHnyhPPhDmYiDGiAGeL2RXW8zNNaWFrhvvEO/9mljZYFZN7dRldQOtDST4jUPc0V58IXy4A9lIg5qgBhYu3Yt6xIG7P4Jdxr+3fs5YDc84Hpjmx+La8UuRxRSzkOOKA++UB78oUzEQQ0QAydPnmRdQo96Oru9vZnpj7mujgD4bYB4z8PcUB58oTz4Q5mIgxogBqZNm8a6hC71ZYny/RMcDf9ubtP3ab9zb84aZV3RoLm1b9sMJV7zMFeUB18oD/5QJuKgBoiBxkY+FwP3xeQxIwz/vtTHU9vvHj0Co0fYQNeqx/mia6YqbcCknIccUR58oTz4Q5mIgxogBqqrq1mX0CNFD6t7FAoFRg637tf+LCwUeOTeMQCA5EtVg6rNFHjPw9xQHnyhPPhDmYiDGiAG5s6dy7qEQXl6tku/t1k69UYDlKjmrwGSeh5yQ3nwhfLgD2UiDmqAGDh69CjrErrWx+sUfvjMDDw2fSw8n5/T510vnToWAJBVUouq+r5fSXoocJuHmaI8+EJ58CWnXIuvYuJZlyEL1AAx8Kc//Yl1CYNib2eNva8vxG8XTuzzNs6Odrh/giP0AnA8q8yE1fWf1POQG8qDL5QHP3StbXjaJwlfX7uHu/+RlCJqgBjYvn076xJ61IebvA/Ir+eOBwAcVpWa5gUGiPc8zA3lwRfKgx+NzW2Gf8ecv8KwEnmgBogBXi9jLvT1GNgArbp/PBQKIL3wGi71447ypsZrHuaK8uAL5cGPlrZbn9FRGVe4vb+iVFADxIC5Xsbc2dEOT8x0AgAEJRewLaYDc82DV5QHXygPfrTpbzU82WVanMuvYViN9FEDxMAf//hH1iX0yERHwAAAby29BwAQmVGCK7V8XMuC9zzMDeXBF8qDH6164wvJ+n6nZlSJPFADxEBUVBTrEro0FLOpC+4eiYcnj0Jzqx6e3+SY/gX7gNc8zBXlwRfKgx+tHQ6BWVkocOZSNeJ/KmdYkbRRA8TAggULWJfAjEKhwL9WzYJCARz5sRTfcHBGmDnnwSPKgy+UBz9abx4Cu8NGgT8suzGb/u/DP6GazggbEGqAGCgrY/9Hv0emOg3sptl3ORp+ef/+v0xklWhM+nq94T4PM0N58IXy4IdhDZAg4J1fTsXkMSNQrm3C2wcyjM4QI33DvAH64osvMHnyZNjZ2WH+/PlISkrqcfzp06cxf/582NnZ4Z577oG/v3+nMZGRkZg1axZsbW0xa9YsREdHm6r8AWlr4/M/1KE8oeCDFdOxcPIo1OlasSY4FSkMb5HBax7mivLgC+XBj/Y1QBYQMMzGEnvWzMcIG0ukXq7B2r3f07WB+olpAxQREYGNGzfio48+wvnz57F06VKsXLkSRUVFXY6/fPkynnnmGSxduhTnz5/Hhx9+iHfffReRkZGGMWfPnsXLL7+MNWvW4Mcff8SaNWvw0ksvITU1dajeVq/uvvtu1iUwZ21pgaC1D+EB1ztR29CCV4NS8VF0Fq5qm4a8FsqDL5QHXygPfrSvAbK1tgIATHOyR8gbC2Fva4XvL9fgaZ9EhH1fhOZWfU+7ITcxbYC2b9+O9evX480338TMmTPh4+MDV1dX+Pn5dTne398fEydOhI+PD2bOnIk333wTb7zxBj777DPDGB8fHzz55JNwc3PDjBkz4Obmhscffxw+Pj5D9K5619ssF2umPQB2i72dNcL/sAgvPTQBegE4kFqExZ6nsD4kDfvOFuBimRZNLab/v0/e8zA3lAdfKA9+tK8Batbd+h/FBXePwqE/LcZ0J3tU1TfDLSoLiz1OYnNMFo5llqG0tpGuF9QNK1Yv3NzcjPT0dPzzn/80en7FihVISUnpcpuzZ89ixYoVRs899dRTCAoKQktLC6ytrXH27Fm8//77ncbw0ABV1ukQn10O65m/xIHUQtbldHKxTDvkr2lnbYmtv5mL5x+cgM/icvFD4TWczLmKkzlXAdxYjnTXncMw1t4Wdw6zxsjhNrjDzgrWlhawsbKAtaUFbK0sYG2pgAIKw/IlheLWPe0VihtNnUKhMPwbN7+vUIDbPMwV5cEXyoMfhdUNAIA7HeyNnp/h7IDDf3kEX6cWwe90HirrdNh/rgj7z904mmJrZYEJI4fBycEO9nZWsLezhr2d1Y3PUAsLWFooYG2pgJWlBawsFLDosA7U8Jlq+Lr773VcP6ro/FQnY+6wxVP3OffnRyAqZg1QVVUV2tra4OTkZPS8k5MTysu7Pq2vvLy8y/Gtra2oqqqCi4tLt2O62ycA6HQ66HS3jp1qtaZpBIqvNeCj6Asm2beYbCyHfmJw0T2j8b8/LcGlq3U4nlWOc/nVyCrRoE7XipJrjSi5xsc1gwghhLV6TecLINpZW+KNX0zGa4sn4UxeNb7NrkB64TXklGuha9Ujr/I68iqvM6i2ew9OvNM8G6B2itvaQ0EQOj3X2/jbn+/vPj08PPDxxx93ej4/Px/x8fF47733sG3bNmzevBnu7u5444038M033+D+++9HTU0Nrl+/jhkzZuDbb7/FunXrsHPnTsPYt99+G2FhYVi6dCnSLxZg7mhL2NrZovZaLcaPH4/Lly9j+vTpyM3Nxb333ovLly/D2dkZGo0GNjY2sLS0RH19PcaOHYuioiLD2GnTpkGtVmOC6wRUV1Vj+PDhEAQBTbomjLzzTpSWlmHKlClQq9WGbe6++26UlZfB0dERzc3N0LfpMeKOEaiqrILrRFfk5+Vj1swZUFxKQm3tTOzfvx+PPvoo8vLyYGNjAycnJ6Snp+PZZ59FYGCg4T3+9a9/xRdffIFf//rXyMjIwNixY2Fra4u8vDwsX74c+/btg5ubGz799FN8+OGH8PDwwJo1a6BUKjFlyhTodDpUVlbiwQcfRGxsLN5++21oz0bgwH8/wub/88Kjq36DuNMpGOc6GeXVWlxvboO940gUFBVjyrTpUGVewOw5c5GZlYVp06cjPz8fTk5OqKurg4WlFWxsbHDt5s87Pz8fM2bOxMWLOZg6dSry8vPg4jIetbXXYGdnB4VCgevXGzBmzBgUFxdj2rRpyM3NxYwZ05GTk4tJkybi6tVK2N9xB9r0bWjWNcPR0RFl5eW4557JUKsvGcZOnjwZpaWlGDnyTjQ16SAIAoYPH47q6ipMmOB6o5abY++dMgWFRYUYN24c6urqYHmzbo1GA2dnJxQUFBrGTps2FZcu5eGuu8bj2rWbdUOBhsYGjB49GiUlJZg6dSpyc3/uUPckXL1aAXt7B7S2tqClpQUODo6oqCjH3XdPxqVLt+q+557JuHLlCkaNGoXGxkYIAjB8+DDUVNfgrgl3IT//8q26752CgoJCODmNQ522DlbWVrCyskZdnRZOTrfXPQ2XLqlx110TUFNTjWHDhgMAGhsbMGrUaFy5UoJ7752Kn3++Vffdd09CRcWtultbWmHvYI+Kiqu4++5JuHQpz7jukisYNXoUGhoaoVAAw4YNQ01NDe666/a670VBwWU4OTlDq9XA2traUPe4cU4oLLxV9/TpN3/XJkxAdXU1hg8bDgECmpqaMHLkSFy5Uop7752Cn39WG9VdXl5h+F1ra2uFvb09rl69ikkTJ+FSXse670FJSTFGjx6DhoYGKBQK2NnZGv6bvXz5Vt1Tp96L/PzLcGn/jLC1gaWFJerq6zFu3FgUFhZ1qHs6fv75Z7i6uqKqqgojRtz8jGhqwp13jkRZWSmm3DMFP6s71n03ysvL4Oh4J5qbdWhr0+OOO0agsrIKEydORF6HuqdMuQfFRcUYM3YMrtdfh8LCokPdLrh8uaBD3VORn58PFxcX1NbWwtbWBhYWlrh+vR5jxoxFcXERpk278Tl1o+5cuLpORFVVJUaMuAN6fRt0umbceeedKCsrwz333AN1h7onT74bpaVlt37X9MafbXl5+R3qnoKioiKMHTsG9fXXYWlpARsbW2g0tXB2dkFBwa26p/XjM6L9c3bixImorKzEHXfcgba2NjQ33/iMKC8vx+TJN37X2se2f0bcOfJO6Dp8RlRVV8F1wgTk59/6+zDl5meE07hxuM+uBXFxcRg1ahQyMzOxcuVKBAcHY/PmzfD0+BR/+9vfkBqzF7teeAEp50pgO9IJNToF8q5cxYTJU5GSdh4PLFyMM2dT8dCChTj3fRrunTYdxSVXcIeDI5pbWtHS3AxHxztRVlaKyVOm4Oeff8asmbOQfTEbU+6ZguKSEoy++bsGAHY3f9cm3DUBefnGP+/CwlufbVZWVrC2toZWq8WssTZwd3c3/C35xz/+ge3bt+PFF1/E2bNn4erqCgAoLi7G4sWLcejQIWzatAleXl5Gf49PnDiB++67DxqNBhUVFd3+re9EYESn0wmWlpZCVFSU0fPvvvuusGzZsi63Wbp0qfDuu+8aPRcVFSVYWVkJzc3NgiAIgqurq7B9+3ajMdu3bxcmTpzYbS1NTU2CRqMxPIqLiwUAgkajGchb69X//d//mWS/ZGAoD75QHnyhPPhDmXRPo9H0+e83s0XQNjY2mD9/PhISEoyeT0hIwJIlS7rcZvHixZ3Gx8fH46GHHoK1tXWPY7rbJwDY2trCwcHB6GFK7777rkn3T/qH8uAL5cEXyoM/lIk4mJ4FtmnTJnz55ZcIDg7GxYsX8f7776OoqAgbNmwAALi5ueG1114zjN+wYQMKCwuxadMmXLx4EcHBwQgKCsIHH3xgGPPee+8hPj4eXl5eyMnJgZeXF7799lts3LhxqN9et0JCQliXQDqgPPhCefCF8uAPZSIOpmuAXn75ZVRXV+OTTz5BWVkZZs+ejePHj2PSpEkAblyBtOM1gSZPnozjx4/j/fffx+7duzF+/Hjs3LkTL7zwgmHMkiVLEB4ejs2bN+Nf//oXpkyZgoiICDz88MND/v6688QTT7AugXRAefCF8uAL5cEfykQcCkGgCwTcTqvVwtHRERqNxiSHw6KiovD888+Lvl8yMJQHXygPvlAe/KFMutefv9/Mb4VhjkaMGMG6BNIB5cEXyoMvlAd/KBNxUAPEwKhRo1iXQDqgPPhCefCF8uAPZSIOaoAYyMzMZF0C6YDy4AvlwRfKgz+UiTioAWJg5cqVrEsgHVAefKE8+EJ58IcyEQc1QAwEBwezLoF0QHnwhfLgC+XBH8pEHHQWWBdMfRYYIYQQQsRHZ4Fxzt3dnXUJpAPKgy+UB18oD/5QJuKgGaAumHoGSKfTwdbWVvT9koGhPPhCefCF8uAPZdI9mgHi3Oeff866BNIB5cEXyoMvlAd/KBNxML0VBq/aJ8W0Wq1J9r9ixQqT7Zv0H+XBF8qDL5QHfyiT7rX/XPpycIsaoC7U1dUBAFxdXRlXQgghhJD+qqurg6OjY49jaA1QF/R6PUpLS2Fvbw+FQiHqvrVaLVxdXVFcXExnmHGA8uAL5cEXyoM/lEnPBEFAXV0dxo8fDwuLnlf50AxQFywsLDBhwgSTvoaDgwP9x8sRyoMvlAdfKA/+UCbd623mpx0tgiaEEEKI2aEGiBBCCCFmhxqgIWZra4v//Oc/dA0HTlAefKE8+EJ58IcyEQ8tgiaEEEKI2aEZIEIIIYSYHWqACCGEEGJ2qAEihBBCiNmhBogQQgghZocaoCH0xRdfYPLkybCzs8P8+fORlJTEuiRZ+u9//wuFQmH0cHZ2NnxfEAT897//xfjx4zFs2DAsX74cP/30k9E+dDod3nnnHYwZMwYjRozAr3/9a5SUlAz1W5GkxMRErF69GuPHj4dCoUBMTIzR98X6+V+7dg1r1qyBo6MjHB0dsWbNGtTW1pr43UlPb3msW7eu0+/LokWLjMZQHuLx8PDAggULYG9vj3HjxuG5555Dbm6u0Rj6HRka1AANkYiICGzcuBEfffQRzp8/j6VLl2LlypUoKipiXZos3XfffSgrKzM8srKyDN/bunUrtm/fDl9fX6SlpcHZ2RlPPvmk4R5wALBx40ZER0cjPDwcycnJqK+vx6pVq9DW1sbi7UjK9evXMXfuXPj6+nb5fbF+/r/73e+gUqlw4sQJnDhxAiqVCmvWrDH5+5Oa3vIAgKefftro9+X48eNG36c8xHP69Gn8+c9/xrlz55CQkIDW1lasWLEC169fN4yh35EhIpAhsXDhQmHDhg1Gz82YMUP45z//yagi+frPf/4jzJ07t8vv6fV6wdnZWfD09DQ819TUJDg6Ogr+/v6CIAhCbW2tYG1tLYSHhxvGXLlyRbCwsBBOnDhh0trlBoAQHR1t+Fqsn392drYAQDh37pxhzNmzZwUAQk5OjonflXTdnocgCMLatWuFZ599ttttKA/Tunr1qgBAOH36tCAI9DsylGgGaAg0NzcjPT0dK1asMHp+xYoVSElJYVSVvKnVaowfPx6TJ0/Gb3/7W+Tn5wMALl++jPLycqMsbG1t8eijjxqySE9PR0tLi9GY8ePHY/bs2ZTXIIn18z979iwcHR3x8MMPG8YsWrQIjo6OlNEAKJVKjBs3DtOmTcNbb72Fq1evGr5HeZiWRqMBAIwaNQoA/Y4MJWqAhkBVVRXa2trg5ORk9LyTkxPKy8sZVSVfDz/8MEJDQxEXF4fAwECUl5djyZIlqK6uNvy8e8qivLwcNjY2GDlyZLdjyMCI9fMvLy/HuHHjOu1/3LhxlFE/rVy5EgcOHMCpU6fg7e2NtLQ0/PKXv4ROpwNAeZiSIAjYtGkTfvGLX2D27NkA6HdkKNHd4IeQQqEw+loQhE7PkcFbuXKl4d9z5szB4sWLMWXKFHz11VeGxZ0DyYLyEo8YP/+uxlNG/ffyyy8b/j179mw89NBDmDRpEo4dO4bnn3++2+0oj8H7y1/+gszMTCQnJ3f6Hv2OmB7NAA2BMWPGwNLSslPXffXq1U5dPhHfiBEjMGfOHKjVasPZYD1l4ezsjObmZly7dq3bMWRgxPr5Ozs7o6KiotP+KysrKaNBcnFxwaRJk6BWqwFQHqbyzjvvIDY2Ft999x0mTJhgeJ5+R4YONUBDwMbGBvPnz0dCQoLR8wkJCViyZAmjqsyHTqfDxYsX4eLigsmTJ8PZ2dkoi+bmZpw+fdqQxfz582FtbW00pqysDBcuXKC8Bkmsn//ixYuh0Wjw/fffG8akpqZCo9FQRoNUXV2N4uJiuLi4AKA8xCYIAv7yl78gKioKp06dwuTJk42+T78jQ4jJ0mszFB4eLlhbWwtBQUFCdna2sHHjRmHEiBFCQUEB69Jk569//augVCqF/Px84dy5c8KqVasEe3t7w8/a09NTcHR0FKKiooSsrCzhlVdeEVxcXAStVmvYx4YNG4QJEyYI3377rZCRkSH88pe/FObOnSu0trayeluSUVdXJ5w/f144f/68AEDYvn27cP78eaGwsFAQBPF+/k8//bRw//33C2fPnhXOnj0rzJkzR1i1atWQv1/e9ZRHXV2d8Ne//lVISUkRLl++LHz33XfC4sWLhbvuuovyMJE//elPgqOjo6BUKoWysjLDo6GhwTCGfkeGBjVAQ2j37t3CpEmTBBsbG+HBBx80nPZIxPXyyy8LLi4ugrW1tTB+/Hjh+eefF3766SfD9/V6vfCf//xHcHZ2FmxtbYVly5YJWVlZRvtobGwU/vKXvwijRo0Shg0bJqxatUooKioa6rciSd99950AoNNj7dq1giCI9/Ovrq4Wfv/73wv29vaCvb298Pvf/164du3aEL1L6egpj4aGBmHFihXC2LFjBWtra2HixInC2rVrO/2sKQ/xdJUFAGHv3r2GMfQ7MjQUgiAIQz3rRAghhBDCEq0BIoQQQojZoQaIEEIIIWaHGiBCCCGEmB1qgAghhBBidqgBIoQQQojZoQaIEEIIIWaHGiBCCCGEmB1qgAghhBBidqgBIoQQQojZoQaIECIby5cvh0KhgEKhgEqlMulrrVu3zvBaMTExJn0tQoj4qAEihEjGxo0b8dxzz/U45q233kJZWRlmz55t0lo+//xzlJWVmfQ1CCGmQw0QIUQy0tLSsHDhwh7HDB8+HM7OzrCysjJpLY6OjnB2djbpaxBCTIcaIEII91paWmBjY4OUlBR89NFHUCgUePjhh/u8/fLly/HOO+9g48aNGDlyJJycnBAQEIDr16/j9ddfh729PaZMmYJvvvnGsM3//vc/zJkzB8OGDcPo0aPxxBNP4Pr166Z4e4QQBqgBIoRwz9LSEsnJyQAAlUqFsrIyxMXF9WsfX331FcaMGYPvv/8e77zzDv70pz/hxRdfxJIlS5CRkYGnnnoKa9asQUNDA8rKyvDKK6/gjTfewMWLF6FUKvH8889DEARTvD1CCAOmnSMmhBARWFhYoLS0FKNHj8bcuXMHtI+5c+di8+bNAAA3Nzd4enpizJgxeOuttwAA//73v+Hn54fMzEzY2NigtbUVzz//PCZNmgQAmDNnjjhvhhDCBZoBIoRIwvnz5wfc/ADA/fffb/i3paUlRo8ebdTUODk5AQCuXr2KuXPn4vHHH8ecOXPw4osvIjAwENeuXRt48YQQ7lADRAiRBJVKNagGyNra2uhrhUJh9JxCoQAA6PV6WFpaIiEhAd988w1mzZqFXbt2Yfr06bh8+fKAX58QwhdqgAghkpCVlWU0i2NqCoUCjzzyCD7++GOcP38eNjY2iI6OHrLXJ4SYFq0BIoRIgl6vR2ZmJkpLSzFixAg4Ojqa7LVSU1Nx8uRJrFixAuPGjUNqaioqKysxc+ZMk70mIWRo0QwQIUQS3N3dERERgbvuuguffPKJSV/LwcEBiYmJeOaZZzBt2jRs3rwZ3t7eWLlypUlflxAydGgGiBAiCa+++ipeffXVAW2rVCo7PVdQUNDpuY6nuZ84cWJAr0UIkQaaASKEyMoXX3yBO+64A1lZWSZ9nQ0bNuCOO+4w6WsQQkxHIdCVvQghMnHlyhU0NjYCACZOnAgbGxuTvdbVq1eh1WoBAC4uLhgxYoTJXosQIj5qgAghhBBidugQGCGEEELMDjVAhBBCCDE71AARQgghxOxQA0QIIYQQs0MNECGEEELMDjVAhBBCCDE71AARQgghxOxQA0QIIYQQs0MNECGEEELMDjVAhBBCCDE7/x+UTaKbgyPprQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "ts, Vms_gl = measure_postsynaptic_response(\"gl_ca_nestml\", \"syn_gl_ca_nestml\", V_m_specifier=\"U\")\n", + "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name, synapse_model_name, V_m_specifier=\"U\")\n", "\n", "fig, ax = plt.subplots()\n", "ax.set_xlabel(\"$t$ [ms]\")\n", @@ -470,9 +1745,198 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 35, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 26 11:22:14 correlation_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Feb 26 11:22:14 correlomatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Feb 26 11:22:14 correlospinmatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.1 to 1 ms\n", + "\n", + "Feb 26 11:22:14 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 11:22:14 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 1 ms.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 2 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 2\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 6 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 6\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 8 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 8\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 10 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 10\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 12 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 12\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 14 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 14\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 16 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 16\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 18 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 18\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 20 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 20\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 22 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 22\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 24 nodes for simulation.\n", + "\n", + "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 24\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + } + ], "source": [ "#theoretical Phi vs U\n", "a = 3\n", @@ -488,9 +1952,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", @@ -509,7 +1994,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -528,7 +2013,7 @@ " log[rec] = (sim_chunks + 1) * [[]]\n", "\n", " # Get the value of trace values before the simulation\n", - " syn = nest.GetConnections(target=neurons, synapse_model=\"syn_gl_ca_nestml\")\n", + " syn = nest.GetConnections(target=neurons, synapse_model=synapse_model_name)\n", " print(str(len(syn)) + \" synapses in the network\")\n", " foo=syn\n", " for rec in syn_recordables:\n", @@ -557,7 +2042,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -579,32 +2064,1283 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 63, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 26 12:06:13 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Feb 26 12:06:13 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 0.1 ms.\n", + "9900 synapses in the network\n", + "\n", + "Feb 26 12:06:13 ConnectionManager [Warning]: \n", + " New connections created, connection descriptors previously obtained using \n", + " 'GetConnections' are now invalid.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + " Preparing 102 nodes for simulation.\n", + "\n", + "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 102\n", + " Simulation time (ms): 10\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "text/plain": [ + "'nest.Simulate(sim_time)\\n\\nneuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\\n\\nfig, ax = plt.subplots(nrows=2)\\n\\nU_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\\n# R_avg = np.zeros_like(U_avg)\\nfor neuron_id in range(1, N+1):\\n idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\\n times = multimeter.get(\"events\")[\"times\"][idx]\\n U = multimeter.get(\"events\")[\"U\"][idx]\\n #R = multimeter.get(\"events\")[\"R\"][idx]\\n \\n U_avg += U / N\\n #R_avg += R / N\\n\\n if neuron_id < 100:\\n ax[0].plot(U, label=\"U\")\\n# ax[1].plot(R, label=\"R\")\\n\\nax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[0].set_ylabel(\"U\")\\n# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[1].set_ylabel(\"R\")\\n\\nfor _ax in ax:\\n _ax.set_xlim(0, sim_time)\\nax[-1].set_xlabel(\"Time [ms]\")'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nest.ResetKernel()\n", "nest.resolution = .1 # [ms]\n", "\n", - "sim_time = 500. # [ms] XXX: 120 second original paper\n", + "sim_time = 1000. # [ms] XXX: 120 second original paper\n", "chunk_length = 10. # [ms]\n", "n_chunks = int(sim_time / chunk_length)\n", "syn_recordables = [\"R_pre\"]\n", "\n", - "pop = nest.Create(\"gl_ca_nestml\", N)\n", + "pop = nest.Create(neuron_model_name, N)\n", "pop.a = a\n", "pop.alpha_over_N = alpha / N\n", "pop.beta = beta\n", "pop.U = [U_0 + U_range * (random.random() - .5) for _ in range(N)]\n", "\n", "conn_spec_dict = {'rule': 'pairwise_bernoulli', 'p': conn_prob, 'allow_autapses': False}\n", - "nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': 'syn_gl_ca_nestml', 'lmbda': lmbda})\n", + "nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': synapse_model_name, 'lmbda': lmbda})\n", "\n", "#syn_recordables = []\n", "#nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': 'static_synapse'})\n", "\n", "\n", - "syn = nest.GetConnections(target=pop, synapse_model=\"syn_gl_ca_nestml\")\n", + "syn = nest.GetConnections(target=pop, synapse_model=synapse_model_name)\n", "N_syn = len(syn)\n", "syn.R_pre = [R_0 + R_range * (random.random() - .5) for _ in range(N_syn)]\n", "\n", @@ -651,9 +3387,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'R')" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "times = log[\"t\"]\n", "R_pre = np.array(log[\"R_pre\"])\n", @@ -671,9 +3428,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Neuron')" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "ax.scatter(sr.events[\"times\"], sr.events[\"senders\"])\n", @@ -685,9 +3463,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Network average firing rate: 7.1 Hz\n" + ] + } + ], "source": [ "avg_firing_rate = len(sr.events[\"times\"]) / N / (sim_time / 1E3)\n", "print(\"Network average firing rate: \" + str(avg_firing_rate) + \" Hz\")" @@ -695,9 +3481,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'U')" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", "\n", @@ -729,9 +3536,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0.01, 6)" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def phi(x):\n", " return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n", @@ -775,15 +3603,6 @@ "#ax.plot(U_avg, R_avg)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "R_pre_intrp" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -814,7 +3633,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -828,7 +3647,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.7" } }, "nbformat": 4, From 2aa40865de48b8c0bb74abec930fa00d2603745f Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Tue, 27 Feb 2024 07:09:05 -0800 Subject: [PATCH 4/6] add GL model tutorial notebook --- .../gl_model/gl_model_tutorial.ipynb | 2492 ++++++++--------- 1 file changed, 1136 insertions(+), 1356 deletions(-) diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb index 89c9bd591..b34032270 100644 --- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -4,17 +4,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "# Galves-Löcherbach Model in NESTML\n", "\n", - "# Galves-Löcherbach Model\n", + "_In vivo_, neurons display variability in their spiking behavior: continuous fluctuations of the membrane potential can be observed, and they exhibit spontaneous firing and different responses to the same repeated input stimulus.\n", "\n", - "\"GL model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function Φ(V) of membrane potential V. By subsuming all sources of randomness into a single function, the Galves-Löcherbach (GL) neuron model simplifies the analysis and simulation of noisy spiking neural networks.\" [DOI: 10.1038/srep35831]\n", + "To capture these phenomena, the Galves-Löcherbach (GL) model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function $Φ(V)$ of membrane potential $V$. By subsuming all sources of randomness into a single function, the GL neuron model simplifies the analysis and simulation of noisy spiking neural networks [1].\n", "\n", - "Reproduce the results of: Antonio Galves, Eva Löcherbach, Christophe Pouzat, Errico Presutti, \"A system of interacting neurons with short term synaptic facilitation\". arXiv:1903.01270v3 13 Sep 2019\n", - "\n", - "Tsodyks-Markram model formally equivalent for synapse (when set to no depression, only facilitation)\n", - "\n", - "Morrison A., Diesmann M., Gerstner W. (2008) Phenomenological models of synaptic plasticity based on spike timing. Biological Cybernetics 98:459–478.\n", - "DOI: 10.1007/s00422-008-0233-1.\n" + "By combining the GL neuron model with a synapse model featuring short term synaptic facilitation, we reproduce the results on short-term memory dynamics in state space from [2]. The synapse model is formally equivalent to the Tsodyks-Markram model [3] when set to no depression, only facilitation." ] }, { @@ -30,6 +26,14 @@ "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/charl/.local/lib/python3.11/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -38,8 +42,8 @@ " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0\n", - " Built: Feb 22 2024 10:55:27\n", + " Version: 3.5.0-rc1\n", + " Built: Feb 21 2024 09:04:08\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -80,8 +84,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "GL model with physical units\n", - "----------------------------\n" + "GL model with biophysical units\n", + "-------------------------------\n", + "\n", + "We formulate the GL model as a linear integrate-and-fire model with membrane time constant $\\tau_\\text{m}$, resting potential $V_\\text{m}$ and an instantaneous jump in the postsynaptic membrane potential (Dirac delta function postsynaptic kernel)." ] }, { @@ -105,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -129,7 +135,7 @@ " V_reset mV = -65 mV # Reset potential of the membrane\n", " b real = 27 # Parameter for the exponential curve\n", " a mV = 5 mV # Parameter for the exponential curve\n", - " V_b mV = -51.3 mV # Membrane potential at which phi(V)=1/b\n", + " V_b mV = -51.3 mV # Membrane potential at which Phi(V)=1/b\n", " with_refr_input boolean = false # If true, do not discard input during refractory period.\n", " reset_after_spike boolean = true\n", "\n", @@ -146,8 +152,8 @@ " output:\n", " spike\n", "\n", - " function phi(V_m mV) real:\n", - " return ((1/b) * exp((V_m - V_b)/a))\n", + " function Phi(V_m mV) real:\n", + " return (1 / b) * exp((V_m - V_b) / a)\n", "\n", " update:\n", " if refr_tick == 0: # neuron not refractory\n", @@ -167,7 +173,7 @@ " refr_spikes_buffer += spikes * exp(-refr_tick * h / tau_m) * mV * s\n", " refr_tick -= 1\n", " \n", - " if random_uniform(0, 1) <= 1E-3 * resolution() * phi(V_m):\n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * Phi(V_m):\n", " refr_tick = RefractoryCounts\n", " if reset_after_spike:\n", " V_m = V_reset\n", @@ -177,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": { "scrolled": true }, @@ -187,15 +193,15 @@ "output_type": "stream", "text": [ "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/gl_expe8800e269e8c4716bc83b2ace5aa5263.nestml\n", - "[3,GLOBAL, INFO]: Target platform code will be generated in directory: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target'\n", - "[4,GLOBAL, INFO]: Target platform code will be installed in directory: '/var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_'\n", + "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_expa19b5725d62e4d56acf2da2f0101ed40.nestml\n", + "[3,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target'\n", + "[4,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_x2vykd5h'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0\n", - " Built: Feb 22 2024 10:55:27\n", + " Version: 3.5.0-rc1\n", + " Built: Feb 21 2024 09:04:08\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -205,32 +211,32 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "[5,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.6.0\n", - "[6,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[9,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /Users/pooja/conda/nestml_dev\n", - "[10,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/gl_expe8800e269e8c4716bc83b2ace5aa5263.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[12,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[13,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", - "[14,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", - "[15,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [10:73;10:73]]: Implicit magnitude conversion from pA to pA buffer with factor 1.0 \n", - "[16,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [10:15;10:68]]: Implicit magnitude conversion from mV / ms to pA / pF with factor 1.0 \n", - "[17,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[18,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [59:11;59:64]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([59:11;59:64])\n", - "[20,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[21,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", - "[22,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n" + "[5,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.5.0-rc1\n", + "[6,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[9,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", + "[10,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_expa19b5725d62e4d56acf2da2f0101ed40.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[12,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[13,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", + "[14,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", + "[15,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [10:73;10:73]]: Implicit magnitude conversion from pA to pA buffer with factor 1.0 \n", + "[16,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [10:15;10:68]]: Implicit magnitude conversion from mV / ms to pA / pF with factor 1.0 \n", + "[17,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[18,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [59:11;59:64]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([59:11;59:64])\n", + "[20,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[21,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", + "[22,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:root:Analysing input:\n", - "INFO:root:{\n", + "INFO:Analysing input:\n", + "INFO:{\n", " \"dynamics\": [\n", " {\n", " \"expression\": \"V_m' = (-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\",\n", @@ -257,24 +263,42 @@ " \"with_refr_input\": \"false\"\n", " }\n", "}\n", - "INFO:root:Processing global options...\n", - "INFO:root:Processing input shapes...\n", - "INFO:root:\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", - "INFO:root:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:root:All known variables: [V_m], all parameters used in ODEs: {I_e, tau_m, V_r, I_stim, C_m}\n", - "INFO:root:No numerical value specified for parameter \"I_stim\"\n", - "INFO:root:\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:All known variables: [V_m], all parameters used in ODEs: {I_stim, V_r, I_e, C_m, tau_m}\n", + "INFO:No numerical value specified for parameter \"I_stim\"\n", + "INFO:\n", "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", - "INFO:root:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:root:Finding analytically solvable equations...\n", - "INFO:root:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:root:Generating propagators for the following symbols: V_m\n", - "INFO:root:update_expr[V_m] = V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\n", - "INFO:root:In ode-toolbox: returning outdict = \n", - "INFO:root:[\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "INFO:Generating propagators for the following symbols: V_m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[23,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[24,GLOBAL, INFO]: Analysing/transforming neuron 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml'\n", + "[25,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [2:0;63:0]]: Starts processing of the model 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:update_expr[V_m] = V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", " {\n", " \"initial_values\": {\n", " \"V_m\": \"V_r\"\n", @@ -303,117 +327,103 @@ "name": "stdout", "output_type": "stream", "text": [ - "[23,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[24,GLOBAL, INFO]: Analysing/transforming neuron 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml'\n", - "[25,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [2:0;63:0]]: Starts processing of the model 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml'\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[27,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[28,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", - "[29,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[30,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp\n", - "[31,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h\n", - "[32,gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml, INFO, [2:0;63:0]]: Successfully generated code for the model: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "[33,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/CMakeLists.txt\n", - "[34,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.h\n", - "[35,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.cpp\n", - "[36,GLOBAL, INFO]: Successfully generated NEST module code in '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "\u001b[33mCMake Warning (dev) at CMakeLists.txt:93 (project):\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[27,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", + "[28,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", + "[29,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[30,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp\n", + "[31,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.h\n", + "[32,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [2:0;63:0]]: Successfully generated code for the model: 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "[33,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.cpp\n", + "[34,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.h\n", + "[35,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/CMakeLists.txt\n", + "[36,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "CMake Warning (dev) at CMakeLists.txt:93 (project):\n", " cmake_minimum_required() should be called prior to this top-level project()\n", " call. Please see the cmake-commands(7) manual for usage documentation of\n", " both commands.\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\u001b[0m\n", - "-- The CXX compiler identification is AppleClang 15.0.0.15000100\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", - "-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ - skipped\n", + "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", "-- Detecting CXX compile features\n", "-- Detecting CXX compile features - done\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0mnestml_e8800e269e8c4716bc83b2ace5aa5263_module Configuration Summary\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mC++ compiler : /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++\u001b[0m\n", - "\u001b[0mBuild static libs : OFF\u001b[0m\n", - "\u001b[0mC++ compiler flags : \u001b[0m\n", - "\u001b[0mNEST compiler flags : -std=c++11 -Wall -Xclang -fopenmp -O2\u001b[0m\n", - "\u001b[0mNEST include dirs : -I/Users/pooja/conda/nestml_dev/include/nest -I/usr/local/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk/usr/include -I/usr/local/Cellar/gsl/2.7/include -I/Users/pooja/miniconda3/envs/nest_3.6/include\u001b[0m\n", - "\u001b[0mNEST libraries flags : -L/Users/pooja/conda/nestml_dev/lib/nest -lnest -lsli -Xclang -fopenmp /usr/local/lib/libltdl.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libreadline.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libncurses.dylib /usr/local/Cellar/gsl/2.7/lib/libgsl.dylib /usr/local/Cellar/gsl/2.7/lib/libgslcblas.dylib\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mYou can now build and install 'nestml_e8800e269e8c4716bc83b2ace5aa5263_module' using\u001b[0m\n", - "\u001b[0m make\u001b[0m\n", - "\u001b[0m make install\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mThe library file libnestml_e8800e269e8c4716bc83b2ace5aa5263_module.so will be installed to\u001b[0m\n", - "\u001b[0m /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_\u001b[0m\n", - "\u001b[0mThe module can be loaded into NEST using\u001b[0m\n", - "\u001b[0m (nestml_e8800e269e8c4716bc83b2ace5aa5263_module) Install (in SLI)\u001b[0m\n", - "\u001b[0m nest.Install(nestml_e8800e269e8c4716bc83b2ace5aa5263_module) (in PyNEST)\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[33mCMake Warning (dev) in CMakeLists.txt:\n", + "\n", + "-------------------------------------------------------\n", + "nestml_a19b5725d62e4d56acf2da2f0101ed40_module Configuration Summary\n", + "-------------------------------------------------------\n", + "\n", + "C++ compiler : /usr/bin/c++\n", + "Build static libs : OFF\n", + "C++ compiler flags : \n", + "NEST compiler flags : -std=c++11 -Wall -fopenmp -O2 -fdiagnostics-color=auto -g\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli -fopenmp /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "You can now build and install 'nestml_a19b5725d62e4d56acf2da2f0101ed40_module' using\n", + " make\n", + " make install\n", + "\n", + "The library file libnestml_a19b5725d62e4d56acf2da2f0101ed40_module.so will be installed to\n", + " /tmp/nestml_target_x2vykd5h\n", + "The module can be loaded into NEST using\n", + " (nestml_a19b5725d62e4d56acf2da2f0101ed40_module) Install (in SLI)\n", + " nest.Install(nestml_a19b5725d62e4d56acf2da2f0101ed40_module) (in PyNEST)\n", + "\n", + "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.28)\n", + " cmake_minimum_required(VERSION 3.26)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\u001b[0m\n", - "-- Configuring done (1.1s)\n", + "\n", + "-- Configuring done (0.2s)\n", "-- Generating done (0.0s)\n", - "-- Build files have been written to: /Users/pooja/nestml/master/doc/tutorials/gl_model/target\n", - "[ 33%] \u001b[32mBuilding CXX object CMakeFiles/nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module.dir/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.o\u001b[0m\n", - "[ 66%] \u001b[32mBuilding CXX object CMakeFiles/nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module.dir/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.o\u001b[0m\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:43:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h:216:17: warning: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml::get_C_m' hides overloaded virtual function [-Woverloaded-virtual]\n", - " inline double get_C_m() const\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/node.h:747:18: note: hidden overloaded virtual function 'nest::Node::get_C_m' declared here: different number of parameters (1 vs 0)\n", - " virtual double get_C_m( int comp );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.cpp:47:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.h:216:17: warning: 'gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml::get_C_m' hides overloaded virtual function [-Woverloaded-virtual]\n", - " inline double get_C_m() const\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/node.h:747:18: note: hidden overloaded virtual function 'nest::Node::get_C_m' declared here: different number of parameters (1 vs 0)\n", - " virtual double get_C_m( int comp );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:166:16: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml.cpp:294:10: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " ^\n", - "1 warning generated.\n", - "3 warnings generated.\n", - "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_e8800e269e8c4716bc83b2ace5aa5263_module.so\u001b[0m\n", - "[100%] Built target nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module\n", - "[100%] Built target nestml_e8800e269e8c4716bc83b2ace5aa5263_module_module\n", - "\u001b[36mInstall the project...\u001b[0m\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 33%] Building CXX object CMakeFiles/nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module.dir/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.o\n", + "[ 66%] Building CXX object CMakeFiles/nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module.dir/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp: In member function ‘void gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:166:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 166 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp: In member function ‘virtual void gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:296:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 296 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:294:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 294 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "[100%] Linking CXX shared module nestml_a19b5725d62e4d56acf2da2f0101ed40_module.so\n", + "[100%] Built target nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module\n", + "[100%] Built target nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module\n", + "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_0vgm91p_/nestml_e8800e269e8c4716bc83b2ace5aa5263_module.so\n", + "-- Installing: /tmp/nestml_target_x2vykd5h/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.so\n", "\n", - "Feb 26 11:15:24 Install [Info]: \n", - " loaded module nestml_e8800e269e8c4716bc83b2ace5aa5263_module\n" + "Feb 27 06:34:06 Install [Info]: \n", + " loaded module nestml_a19b5725d62e4d56acf2da2f0101ed40_module\n" ] } ], @@ -426,9 +436,18 @@ "nest.Install(module_name)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Firing rate\n", + "\n", + "This should correspond to the `Phi(U)` function in the neuron (see plot below for the theoretical curve)." + ] + }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -463,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -471,218 +490,180 @@ "output_type": "stream", "text": [ "\n", - "Feb 26 11:15:24 correlation_detector [Info]: \n", + "Feb 27 06:34:06 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 26 11:15:24 correlomatrix_detector [Info]: \n", + "Feb 27 06:34:06 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 26 11:15:24 correlospinmatrix_detector [Info]: \n", + "Feb 27 06:34:06 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Feb 26 11:15:24 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:15:24 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + "Feb 27 06:34:06 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:15:24 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:15:24 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:15:24 SimulationManager::set_status [Info]: \n", + "Feb 27 06:34:06 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:06 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:15:24 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Feb 26 11:15:24 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:15:24 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] - } - ], - "source": [ - "\n", - "# theoretical Phi vs U\n", - "U_range_theory = np.linspace(-60., -45., 100)\n", - "Phi_of_U_theory = (1 / params['b']) * np.exp((U_range_theory - params['V_b']) / params['a'])\n", - "\n", - "# numerical Phi vs U\n", - "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", - " U_min=-60.,\n", - " U_max=-45.,\n", - " neuron_model_params={\"reset_after_spike\": False,\n", - " \"a\": params['a'],\n", - " \"b\": params['b'],\n", - " \"V_b\": params['V_b'],\n", - " \"tau_m\": 1E99},\n", - " neuron_membrane_potential_name=\"V_m\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "scrolled": true - }, - "outputs": [ + }, { "data": { "text/plain": [ "Text(0, 0.5, 'Firing rate [Hz]')" ] }, - "execution_count": 19, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -692,6 +673,22 @@ } ], "source": [ + "\n", + "# theoretical Phi vs U\n", + "U_range_theory = np.linspace(-60., -45., 100)\n", + "Phi_of_U_theory = (1 / params['b']) * np.exp((U_range_theory - params['V_b']) / params['a'])\n", + "\n", + "# numerical Phi vs U\n", + "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " U_min=-60.,\n", + " U_max=-45.,\n", + " neuron_model_params={\"reset_after_spike\": False,\n", + " \"a\": params['a'],\n", + " \"b\": params['b'],\n", + " \"V_b\": params['V_b'],\n", + " \"tau_m\": 1E99},\n", + " neuron_membrane_potential_name=\"V_m\")\n", + "\n", "fig, ax = plt.subplots()\n", "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", @@ -704,12 +701,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Computing reliability of the single neuron model" + "## Computing reliability of the single neuron model\n", + "\n", + "Here we plot the spike times for the neurons as a raster plot to study the stochastic behavior of the neuron model. First, we give the neurons a constant input current and then a Poissonian input.\n", + "\n", + "We observe that with the constant input current, the spike times across trials are highly variable, and the firing rate at the bottom is “flat” indicating that the spike times are not reliably reproduced over trials. With the Poissonian input, the corresponding firing rate panel shows several peaks indicating that the spike times tend to be more repeatable across trials." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -787,17 +788,9 @@ " return ts, ns" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Constant input current" - ] - }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 8, "metadata": { "scrolled": true }, @@ -807,72 +800,48 @@ "output_type": "stream", "text": [ "\n", - "Feb 26 11:18:29 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", + "Feb 27 06:34:07 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:18:29 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 SimulationManager::set_status [Info]: \n", + "Feb 27 06:34:07 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Feb 26 11:18:29 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 54 nodes for simulation.\n", "\n", - "Feb 26 11:18:29 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 54\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:18:29 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:18:29 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", + "Feb 27 06:34:07 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:18:29 SimulationManager::set_status [Info]: \n", + "Feb 27 06:34:07 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Feb 26 11:18:29 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 54 nodes for simulation.\n", "\n", - "Feb 26 11:18:29 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 54\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:18:29 SimulationManager::run [Info]: \n", + "Feb 27 06:34:07 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -938,43 +907,55 @@ "metadata": {}, "source": [ "Normalized model with calcium dynamics\n", - "---------------------------------------------------" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `R` variable represents the calcium concentration of the presynaptic neuron. For convenience (and at the cost of some redundancy), we store it here in the NEST synapse object." + "--------------------------------------\n", + "\n", + "For convenience, we normalize the parameters and dynamical equations of the previous model with biophysical units, to make a model where all variables and parameters are scalars." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "nestml_gl_ca_synapse_model = '''\n", - "synapse syn_gl_ca:\n", - " state:\n", - " R_pre real = 0.\n", + "nestml_gl_ca_neuron_model = '''\n", + "neuron gl_ca:\n", + " state:\n", + " U real = 0 # membrane potential\n", "\n", - " parameters:\n", - " the_delay ms = 1 ms @nest::delay # !!! cannot have a variable called \"delay\"\n", - " lmbda real = 2.1555489309487914 # residual calcium decay rate\n", + " parameters:\n", + " a real = 3.\n", + " alpha_over_N real = 1.0777744654743957 # synaptic strength\n", + " beta real = 50 # membrane potential leak\n", + " reset_after_spike boolean = true\n", "\n", - " onReceive(incoming_spikes):\n", - " R_pre += 1\n", - " deliver_spike(R_pre - 1, the_delay)\n", + " input:\n", + " incoming_spikes <- spike\n", "\n", - " input:\n", - " incoming_spikes <- spike\n", - " \n", - " output:\n", - " spike\n", - " \n", - " update:\n", - " R_pre *= exp(-lmbda * 1E-3 * resolution()) # leakage\n", + " output:\n", + " spike\n", + "\n", + " function Phi(U real) real:\n", + " if U <= 0:\n", + " return 0\n", + "\n", + " return (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", + "\n", + " equations:\n", + " kernel K = delta(t)\n", + " \n", + " # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n", + " U' = -U / (1E3 / beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", + "\n", + " update:\n", + " # integrate spike input\n", + " integrate_odes()\n", + "\n", + " # emit spike?\n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * Phi(U):\n", + " emit_spike()\n", + " if reset_after_spike:\n", + " U = 0 # reset membrane potential\n", "'''" ] }, @@ -982,58 +963,49 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Neuron:" + "We now formulate the facilitating synapse model. The `R_pre` variable represents the calcium concentration of the presynaptic neuron. For convenience (and at the cost of some redundancy), we store it here in the NEST synapse object. The decay time constant of the calcium concentration is given by the `lmbda` parameter." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "nestml_gl_ca_neuron_model = '''\n", - "neuron gl_ca:\n", - " state:\n", - " U real = 0 # membrane potential\n", - "\n", - " parameters:\n", - " a real = 3.\n", - " alpha_over_N real = 1.0777744654743957 # synaptic strength\n", - " beta real = 50 # membrane potential leak\n", - " reset_after_spike boolean = true\n", - "\n", - " input:\n", - " incoming_spikes <- spike\n", + "nestml_gl_ca_synapse_model = '''\n", + "synapse syn_gl_ca:\n", + " state:\n", + " R_pre real = 0.\n", "\n", - " output:\n", - " spike\n", + " parameters:\n", + " the_delay ms = 1 ms @nest::delay # !!! cannot have a variable called \"delay\"\n", + " lmbda real = 2.1555489309487914 # residual calcium decay rate\n", "\n", - " function phi(U real) real:\n", - " if U <= 0:\n", - " return 0\n", - " return (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", + " onReceive(incoming_spikes):\n", + " R_pre += 1\n", + " deliver_spike(R_pre - 1, the_delay)\n", "\n", - " equations:\n", - " kernel K = delta(t)\n", - " \n", - " # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n", - " U' = -U / (1E3 / beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", - "\n", - " update:\n", - " # integrate spike input\n", - " integrate_odes()\n", - "\n", - " # emit spike?\n", - " if random_uniform(0, 1) <= 1E-3 * resolution() * phi(U):\n", - " emit_spike()\n", - " if reset_after_spike:\n", - " U = 0 # reset membrane potential\n", + " input:\n", + " incoming_spikes <- spike\n", + " \n", + " output:\n", + " spike\n", + " \n", + " update:\n", + " R_pre *= exp(-lmbda * 1E-3 * resolution()) # leakage\n", "'''" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the neuron and synapse models defined, we generate the code and load the extension module into NEST:" + ] + }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 11, "metadata": { "scrolled": true }, @@ -1043,16 +1015,16 @@ "output_type": "stream", "text": [ "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml\n", - "[3,GLOBAL, INFO]: /Users/pooja/nestml/master/doc/tutorials/gl_model/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml\n", - "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo'\n", + "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml\n", + "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml\n", + "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_8zmlqzuo'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0\n", - " Built: Feb 22 2024 10:55:27\n", + " Version: 3.5.0-rc1\n", + " Built: Feb 21 2024 09:04:08\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -1062,65 +1034,61 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.6.0\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[9,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/Users/pooja/.local/lib/python3.11/site-packages/NESTML-7.0.0.post0.dev0-py3.11.egg/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[10,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /Users/pooja/conda/nestml_dev\n", - "[11,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[13,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[14,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[15,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[16,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [30:9;30:25]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", - "[17,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[18,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[19,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", - "[20,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[21,GLOBAL, INFO]: Start processing '/Users/pooja/nestml/master/doc/tutorials/gl_model/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[23,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[24,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[26,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[27,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[28,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[29,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[30,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[31,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[33,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[34,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[36,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[37,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[38,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[39,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [30:9;30:25]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", - "[40,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[41,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[42,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n", - "[43,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[45,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[46,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.5.0-rc1\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[9,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[10,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", + "[11,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[13,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[14,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", + "[15,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[16,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [28:13;28:29]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", + "[17,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[18,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[19,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [35:11;35:62]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([35:11;35:62])\n", + "[20,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[21,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml'!\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[23,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[24,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[26,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[27,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", + "[28,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[29,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[30,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[31,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[33,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[34,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[36,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[37,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", + "[38,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[39,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [28:13;28:29]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", + "[40,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[41,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[42,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [35:11;35:62]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([35:11;35:62])\n", + "[43,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[45,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[46,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", "[47,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: []\n", "[48,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: []\n", "[49,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with suffixed external variable references\n", "[50,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", "[51,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", "[52,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", - "[54,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[55,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n", - "[56,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[57,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[58,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[59,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n" + "[54,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[55,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:root:Analysing input:\n", - "INFO:root:{\n", + "INFO:Analysing input:\n", + "INFO:{\n", " \"dynamics\": [\n", " {\n", " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", @@ -1139,23 +1107,47 @@ " \"reset_after_spike\": \"true\"\n", " }\n", "}\n", - "INFO:root:Processing global options...\n", - "INFO:root:Processing input shapes...\n", - "INFO:root:\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:All known variables: [U], all parameters used in ODEs: {beta}\n", - "INFO:root:\n", + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", + "INFO:\n", "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:Finding analytically solvable equations...\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:Generating propagators for the following symbols: U\n", - "INFO:root:update_expr[U] = U*__P__U__U\n", - "INFO:root:In ode-toolbox: returning outdict = \n", - "INFO:root:[\n", + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[56,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[57,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[58,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[59,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[61,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[62,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[63,GLOBAL, INFO]: Successfully constructed neuron-synapse pair gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml\n", + "[64,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", + "[65,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Starts processing of the model 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Generating propagators for the following symbols: U\n", + "INFO:update_expr[U] = U*__P__U__U\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", " {\n", " \"initial_values\": {\n", " \"U\": \"0\"\n", @@ -1174,34 +1166,9 @@ " \"U\": \"U*__P__U__U\"\n", " }\n", " }\n", - "]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[61,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[62,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[63,GLOBAL, INFO]: Successfully constructed neuron-synapse pair gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\n", - "[64,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", - "[65,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Analysing input:\n", - "INFO:root:{\n", + "]\n", + "INFO:Analysing input:\n", + "INFO:{\n", " \"dynamics\": [\n", " {\n", " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", @@ -1220,46 +1187,57 @@ " \"reset_after_spike\": \"true\"\n", " }\n", "}\n", - "INFO:root:Processing global options...\n", - "INFO:root:Processing input shapes...\n", - "INFO:root:\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:All known variables: [U], all parameters used in ODEs: {beta}\n", - "INFO:root:\n", + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", + "INFO:\n", "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:root:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:Finding analytically solvable equations...\n", - "INFO:root:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:root:Generating propagators for the following symbols: U\n", - "INFO:root:update_expr[U] = U*__P__U__U\n" + "INFO:\tReturning shape: Shape \"U\" of order 1\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "INFO:Shape U: reconstituting expression -0.001*U*beta\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "[67,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[68,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[69,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[70,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[71,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[72,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", - "[73,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n" + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[67,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[68,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[69,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[70,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[71,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[72,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", + "[73,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Starts processing of the model 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:root:In ode-toolbox: returning outdict = \n", - "INFO:root:[\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "INFO:Generating propagators for the following symbols: U\n", + "INFO:update_expr[U] = U*__P__U__U\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", " {\n", " \"initial_values\": {\n", " \"U\": \"0\"\n", @@ -1285,334 +1263,220 @@ "name": "stdout", "output_type": "stream", "text": [ - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[75,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[76,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n", - "[77,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[78,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[79,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[80,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.\n", - "[81,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml'\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[83,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[84,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[86,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[87,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[88,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp\n", - "[89,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", - "[90,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.0!=4.10.1\n", - "[91,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp\n", - "[92,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", - "[93,gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "Generating code for the synapse syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.\n", - "[94,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h\n", - "[95,syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml' in: '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "[96,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/CMakeLists.txt\n", - "[97,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.h\n", - "[98,GLOBAL, INFO]: Rendering template /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp\n", - "[99,GLOBAL, INFO]: Successfully generated NEST module code in '/Users/pooja/nestml/master/doc/tutorials/gl_model/target' !\n", - "\u001b[33mCMake Warning (dev) at CMakeLists.txt:95 (project):\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[75,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[76,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", + "[77,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[78,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[79,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[80,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.\n", + "[81,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[83,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[84,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[86,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", + "[87,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[88,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp\n", + "[89,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", + "[90,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Successfully generated code for the model: 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", + "[91,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp\n", + "[92,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", + "[93,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Successfully generated code for the model: 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "Generating code for the synapse syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.\n", + "[94,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", + "[95,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "[96,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp\n", + "[97,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.h\n", + "[98,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/CMakeLists.txt\n", + "[99,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", + "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", " cmake_minimum_required() should be called prior to this top-level project()\n", " call. Please see the cmake-commands(7) manual for usage documentation of\n", " both commands.\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\u001b[0m\n", - "-- The CXX compiler identification is AppleClang 15.0.0.15000100\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", - "-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ - skipped\n", + "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", "-- Detecting CXX compile features\n", "-- Detecting CXX compile features - done\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0mnestml_c582d906cfdd4f76a2f0e5036501ac82_module Configuration Summary\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mC++ compiler : /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++\u001b[0m\n", - "\u001b[0mBuild static libs : OFF\u001b[0m\n", - "\u001b[0mC++ compiler flags : \u001b[0m\n", - "\u001b[0mNEST compiler flags : -std=c++11 -Wall -Xclang -fopenmp -O2\u001b[0m\n", - "\u001b[0mNEST include dirs : -I/Users/pooja/conda/nestml_dev/include/nest -I/usr/local/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk/usr/include -I/usr/local/Cellar/gsl/2.7/include -I/Users/pooja/miniconda3/envs/nest_3.6/include\u001b[0m\n", - "\u001b[0mNEST libraries flags : -L/Users/pooja/conda/nestml_dev/lib/nest -lnest -lsli -Xclang -fopenmp /usr/local/lib/libltdl.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libreadline.dylib /Users/pooja/miniconda3/envs/nest_3.6/lib/libncurses.dylib /usr/local/Cellar/gsl/2.7/lib/libgsl.dylib /usr/local/Cellar/gsl/2.7/lib/libgslcblas.dylib\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0m-------------------------------------------------------\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mYou can now build and install 'nestml_c582d906cfdd4f76a2f0e5036501ac82_module' using\u001b[0m\n", - "\u001b[0m make\u001b[0m\n", - "\u001b[0m make install\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[0mThe library file libnestml_c582d906cfdd4f76a2f0e5036501ac82_module.so will be installed to\u001b[0m\n", - "\u001b[0m /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo\u001b[0m\n", - "\u001b[0mThe module can be loaded into NEST using\u001b[0m\n", - "\u001b[0m (nestml_c582d906cfdd4f76a2f0e5036501ac82_module) Install (in SLI)\u001b[0m\n", - "\u001b[0m nest.Install(nestml_c582d906cfdd4f76a2f0e5036501ac82_module) (in PyNEST)\u001b[0m\n", - "\u001b[0m\u001b[0m\n", - "\u001b[33mCMake Warning (dev) in CMakeLists.txt:\n", + "\n", + "-------------------------------------------------------\n", + "nestml_c0c551c19f05412b9d0d08b928dbfe0f_module Configuration Summary\n", + "-------------------------------------------------------\n", + "\n", + "C++ compiler : /usr/bin/c++\n", + "Build static libs : OFF\n", + "C++ compiler flags : \n", + "NEST compiler flags : -std=c++11 -Wall -fopenmp -O2 -fdiagnostics-color=auto -g\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli -fopenmp /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "You can now build and install 'nestml_c0c551c19f05412b9d0d08b928dbfe0f_module' using\n", + " make\n", + " make install\n", + "\n", + "The library file libnestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so will be installed to\n", + " /tmp/nestml_target_8zmlqzuo\n", + "The module can be loaded into NEST using\n", + " (nestml_c0c551c19f05412b9d0d08b928dbfe0f_module) Install (in SLI)\n", + " nest.Install(nestml_c0c551c19f05412b9d0d08b928dbfe0f_module) (in PyNEST)\n", + "\n", + "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.28)\n", + " cmake_minimum_required(VERSION 3.26)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\u001b[0m\n", - "-- Configuring done (1.2s)\n", + "\n", + "-- Configuring done (0.1s)\n", "-- Generating done (0.0s)\n", - "-- Build files have been written to: /Users/pooja/nestml/master/doc/tutorials/gl_model/target\n", - "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.o\u001b[0m\n", - "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.o\u001b[0m\n", - "[ 75%] \u001b[32mBuilding CXX object CMakeFiles/nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module.dir/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.o\u001b[0m\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:43:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:181:8: warning: 'register_stdp_connection' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]\n", - " void register_stdp_connection( double t_first_read, double delay );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/node.h:481:16: note: overridden virtual function is here\n", - " virtual void register_stdp_connection( double, double );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:154:16: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:245:10: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:159:16: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.cpp:256:10: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:49:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:181:8: warning: 'register_stdp_connection' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]\n", - " void register_stdp_connection( double t_first_read, double delay );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/node.h:481:16: note: overridden virtual function is here\n", - " virtual void register_stdp_connection( double, double );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:332:18: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:417:18: warning: unused variable '_tr_t' [-Wunused-variable]\n", - " const double _tr_t = __t_spike - __dendritic_delay;\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:532:16: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:543:16: warning: unused variable '__resolution' [-Wunused-variable]\n", - " const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:334:10: warning: unused variable 'get_thread' [-Wunused-variable]\n", - " auto get_thread = [tid]()\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", - " C_[ lcid ].send( e, tid, cp );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", - " explicit Connector( const synindex syn_id )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", - " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:400:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:420:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:450:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:596:8: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:395:9: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::update_internal_state_' requested here\n", - " update_internal_state_(t_lastspike_, (start->t_ + __dendritic_delay) - t_lastspike_, cp);\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", - " C_[ lcid ].send( e, tid, cp );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", - " explicit Connector( const synindex syn_id )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", - " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:320:7: warning: expression result unused [-Wunused-value]\n", - " dynamic_cast(t);\n", - " ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:286:14: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::check_connection' requested here\n", - " connection.check_connection( src, tgt, receptor_type, get_common_properties() );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:61:28: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " ConnectorModel* cf = new GenericConnectorModel< ConnectionT< TargetIdentifierPtrRport > >( name );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:334:10: warning: unused variable 'get_thread' [-Wunused-variable]\n", - " auto get_thread = [tid]()\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", - " C_[ lcid ].send( e, tid, cp );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", - " explicit Connector( const synindex syn_id )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", - " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:400:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:420:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:450:14: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model \n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:596:8: warning: unused variable 'get_t' [-Wunused-variable]\n", - " auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:395:9: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::update_internal_state_' requested here\n", - " update_internal_state_(t_lastspike_, (start->t_ + __dendritic_delay) - t_lastspike_, cp);\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:381:18: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::send' requested here\n", - " C_[ lcid ].send( e, tid, cp );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_base.h:223:12: note: in instantiation of member function 'nest::Connector>::send_to_all' requested here\n", - " explicit Connector( const synindex syn_id )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:281:45: note: in instantiation of member function 'nest::Connector>::Connector' requested here\n", - " thread_local_connectors[ syn_id ] = new Connector< ConnectionT >( syn_id );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "In file included from /Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:52:\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml.h:320:7: warning: expression result unused [-Wunused-value]\n", - " dynamic_cast(t);\n", - " ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:286:14: note: in instantiation of member function 'nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml::check_connection' requested here\n", - " connection.check_connection( src, tgt, receptor_type, get_common_properties() );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model_impl.h:262:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection_' requested here\n", - " add_connection_( src, tgt, thread_local_connectors, syn_id, connection, actual_receptor_type );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/connector_model.h:156:3: note: in instantiation of member function 'nest::GenericConnectorModel>::add_connection' requested here\n", - " GenericConnectorModel( const std::string name )\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/model_manager_impl.h:67:14: note: in instantiation of member function 'nest::GenericConnectorModel>::GenericConnectorModel' requested here\n", - " cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + \"_hpc\" );\n", - " ^\n", - "/Users/pooja/conda/nestml_dev/include/nest/nest_impl.h:35:26: note: in instantiation of function template specialization 'nest::ModelManager::register_connection_model' requested here\n", - " kernel().model_manager.register_connection_model< ConnectorModelT >( name );\n", - " ^\n", - "/Users/pooja/nestml/master/doc/tutorials/gl_model/target/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.cpp:111:11: note: in instantiation of function template specialization 'nest::register_connection_model' requested here\n", - " nest::register_connection_model< nest::syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml >( \"syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml\" );\n", - " ^\n", - "2 warnings generated.\n", - "3 warnings generated.\n", - "17 warnings generated.\n", - "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_c582d906cfdd4f76a2f0e5036501ac82_module.so\u001b[0m\n", - "[100%] Built target nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module\n", - "[100%] Built target nestml_c582d906cfdd4f76a2f0e5036501ac82_module_module\n", - "\u001b[36mInstall the project...\u001b[0m\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 50%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:154:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 154 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘virtual void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:247:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 247 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:245:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 245 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:159:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 159 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘virtual void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:258:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 258 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:256:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 256 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "In file included from /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:52:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:61:24: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:543:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 543 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:10: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:543:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:552:3: required from ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:61:24: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:532:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 532 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:552:3: required from ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:10: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:532:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:400:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 400 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:420:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 420 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:450:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 450 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:332:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 332 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:334:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 334 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:417:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 417 | const double _tr_t = __t_spike - __dendritic_delay;\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:400:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 400 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:420:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 420 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:450:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 450 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:332:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 332 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:334:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 334 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:417:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 417 | const double _tr_t = __t_spike - __dendritic_delay;\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update_internal_state_(double, double, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:395:9: required from ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:596:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 596 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update_internal_state_(double, double, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:395:9: required from ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:596:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "[100%] Linking CXX shared module nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so\n", + "[100%] Built target nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module\n", + "[100%] Built target nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module\n", + "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /var/folders/2j/fb047q1177v9f56f_jktrb4c0000gn/T/nestml_target_xxmy68eo/nestml_c582d906cfdd4f76a2f0e5036501ac82_module.so\n", + "-- Installing: /tmp/nestml_target_8zmlqzuo/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so\n", "\n", - "Feb 26 11:22:03 Install [Info]: \n", - " loaded module nestml_c582d906cfdd4f76a2f0e5036501ac82_module\n" + "Feb 27 06:34:21 Install [Info]: \n", + " loaded module nestml_c0c551c19f05412b9d0d08b928dbfe0f_module\n" ] } ], @@ -1630,122 +1494,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Postsynaptic response\n", + "### Firing rate\n", "\n", - "Note that due to the residual calcium dynamics, the synapse is facilitating.\n", - "\n", - "The decay should correspond to the $\\beta$ parameter.\n", - "\n", - "When a neuron spikes, it increases the potential of each postsynaptic partner by $\\alpha R/N$." + "This should correspond to the `Phi(U)` function in the neuron (see plot below for the theoretical curve)." ] }, { "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "def measure_postsynaptic_response(neuron_model: str,\n", - " synapse_model: str,\n", - " t_stop: float = 2250.,\n", - " V_m_specifier: str = \"V_m\",\n", - " custom_model_opts: Optional[Dict] = None):\n", - " spike_times = np.array([100., 200., 250., 2000.])\n", - "\n", - " nest.ResetKernel()\n", - " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", - " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", - " #dc = nest.Create(\"dc_generator\", params={\"amplitude\": 1E12 * I_stim}) # 1E12: convert A to pA\n", - " #nest.Connect(dc, neuron)\n", - " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", - " nest.Connect(spike_generator, neuron, syn_spec={'synapse_model': synapse_model})\n", - "\n", - " multimeter = nest.Create('multimeter')\n", - " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier]})\n", - " nest.Connect(multimeter, neuron)\n", - "\n", - " sr = nest.Create('spike_recorder')\n", - " nest.Connect(neuron, sr)\n", - "\n", - " nest.Simulate(t_stop)\n", - "\n", - " ts = multimeter.events[\"times\"]\n", - " Vms = multimeter.events[V_m_specifier]\n", - " \n", - " return ts, Vms" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Feb 26 11:22:08 NodeManager::prepare_nodes [Info]: \n", - " Preparing 4 nodes for simulation.\n", - "\n", - "Feb 26 11:22:08 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 4\n", - " Simulation time (ms): 2250\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Feb 26 11:22:08 SimulationManager::run [Info]: \n", - " Simulation finished.\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name, synapse_model_name, V_m_specifier=\"U\")\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.set_xlabel(\"$t$ [ms]\")\n", - "ax.plot(ts, Vms_gl, label=\"gl\")\n", - "ax.set_ylabel(\"U\")\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Firing rate" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This should correspond to the Phi(U) function in the neuron (see plot below for the theoretical curve)." - ] - }, - { - "cell_type": "code", - "execution_count": 35, + "execution_count": 12, "metadata": { "scrolled": true }, @@ -1755,186 +1511,194 @@ "output_type": "stream", "text": [ "\n", - "Feb 26 11:22:14 correlation_detector [Info]: \n", + "Feb 27 06:34:21 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 26 11:22:14 correlomatrix_detector [Info]: \n", + "Feb 27 06:34:21 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 26 11:22:14 correlospinmatrix_detector [Info]: \n", + "Feb 27 06:34:21 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Feb 26 11:22:14 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:22:14 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:22:14 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 11:22:14 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:22:14 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:22:14 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 11:22:14 SimulationManager::set_status [Info]: \n", + "Feb 27 06:34:21 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 11:22:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Feb 26 11:22:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 11:22:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1947,27 +1711,96 @@ "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", " neuron_model_params={\"reset_after_spike\": False,\n", " \"beta\": 1E-99, # a very low value, to prevent the membrane potential from decaying\n", - " \"a\": 3.})" + " \"a\": 3.})\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", + "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$U$\")\n", + "ax.set_ylabel(\"Firing rate [Hz]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Postsynaptic response\n", + "\n", + "When a neuron spikes, it increases the potential of each postsynaptic partner by $\\alpha R/N$. Note that due to the residual calcium dynamics, the synapse is facilitating." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def measure_postsynaptic_response(neuron_model: str,\n", + " synapse_model: str,\n", + " t_stop: float = 2250.,\n", + " V_m_specifier: str = \"V_m\",\n", + " custom_model_opts: Optional[Dict] = None):\n", + "\n", + " spike_times = np.array([100., 200., 250., 2000.])\n", + " \n", + " nest.ResetKernel()\n", + " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", + " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", + " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", + " nest.Connect(spike_generator, neuron, syn_spec={'synapse_model': synapse_model})\n", + "\n", + " multimeter = nest.Create('multimeter')\n", + " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier]})\n", + " nest.Connect(multimeter, neuron)\n", + "\n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr)\n", + "\n", + " nest.Simulate(t_stop)\n", + "\n", + " ts = multimeter.events[\"times\"]\n", + " Vms = multimeter.events[V_m_specifier]\n", + " \n", + " return ts, Vms" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 14, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 2250\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, { "data": { "text/plain": [ - "Text(0, 0.5, 'Firing rate [Hz]')" + "" ] }, - "execution_count": 36, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1977,30 +1810,31 @@ } ], "source": [ + "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name, synapse_model_name, V_m_specifier=\"U\")\n", + "\n", "fig, ax = plt.subplots()\n", - "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", - "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", - "ax.legend()\n", - "ax.set_xlabel(\"$U$\")\n", - "ax.set_ylabel(\"Firing rate [Hz]\")" + "ax.set_xlabel(\"$t$ [ms]\")\n", + "ax.plot(ts, Vms_gl, label=\"gl\")\n", + "ax.set_ylabel(\"U\")\n", + "ax.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Network dynamics" + "### Network dynamics\n", + "\n", + "We now set up the network with 100 neurons and check that it reaches a non-quiescent equilibrium state, following [4]." ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "foo=None\n", "def run_simulation_in_chunks(sim_chunks, sim_time, syn_recordables, neurons):\n", - " global foo\n", " sim_time_per_chunk = sim_time / sim_chunks\n", "\n", " # Init log to collect the values of all recordables\n", @@ -2015,7 +1849,6 @@ " # Get the value of trace values before the simulation\n", " syn = nest.GetConnections(target=neurons, synapse_model=synapse_model_name)\n", " print(str(len(syn)) + \" synapses in the network\")\n", - " foo=syn\n", " for rec in syn_recordables:\n", " log[rec][0] = syn.get(rec)\n", " \n", @@ -2042,7 +1875,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -2055,8 +1888,8 @@ "lmbda = 10.\n", "alpha = beta * lmbda\n", "\n", - "U_0 = 1.#0.79555 # initial membrane potential\n", - "R_0 = .2#1. # initial residual calcium\n", + "U_0 = 1. #0.79555 # initial membrane potential\n", + "R_0 = .2 #1. # initial residual calcium\n", "\n", "U_range = .1 * U_0\n", "R_range = .1 * R_0" @@ -2064,7 +1897,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 17, "metadata": { "scrolled": true }, @@ -2074,1255 +1907,1233 @@ "output_type": "stream", "text": [ "\n", - "Feb 26 12:06:13 gl_exp5da07fc067fa4f639f92889196944663_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 12:06:13 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 12:06:13 gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml__with_syn_gl_ca5bc3b424b39f483c8fc6aa7320ab1d07_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 26 12:06:13 gl_expe8800e269e8c4716bc83b2ace5aa5263_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 12:06:13 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 12:06:13 gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml__with_syn_gl_cac582d906cfdd4f76a2f0e5036501ac82_nestml [Warning]: \n", + "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 26 12:06:13 SimulationManager::set_status [Info]: \n", + "Feb 27 06:34:21 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", - "9900 synapses in the network\n", "\n", - "Feb 26 12:06:13 ConnectionManager [Warning]: \n", + "Feb 27 06:34:21 ConnectionManager [Warning]: \n", + "9900 synapses in the network\n", " New connections created, connection descriptors previously obtained using \n", " 'GetConnections' are now invalid.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:13 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:13 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:13 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:22 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:14 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:14 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:14 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:15 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:15 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:15 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:23 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:16 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:16 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:16 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:24 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:17 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:17 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:17 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:25 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:18 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:18 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:18 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 26 12:06:19 NodeManager::prepare_nodes [Info]: \n", + "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 26 12:06:19 SimulationManager::start_updating_ [Info]: \n", + "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 26 12:06:19 SimulationManager::run [Info]: \n", + "Feb 27 06:34:26 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] - }, - { - "data": { - "text/plain": [ - "'nest.Simulate(sim_time)\\n\\nneuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\\n\\nfig, ax = plt.subplots(nrows=2)\\n\\nU_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\\n# R_avg = np.zeros_like(U_avg)\\nfor neuron_id in range(1, N+1):\\n idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\\n times = multimeter.get(\"events\")[\"times\"][idx]\\n U = multimeter.get(\"events\")[\"U\"][idx]\\n #R = multimeter.get(\"events\")[\"R\"][idx]\\n \\n U_avg += U / N\\n #R_avg += R / N\\n\\n if neuron_id < 100:\\n ax[0].plot(U, label=\"U\")\\n# ax[1].plot(R, label=\"R\")\\n\\nax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[0].set_ylabel(\"U\")\\n# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[1].set_ylabel(\"R\")\\n\\nfor _ax in ax:\\n _ax.set_xlim(0, sim_time)\\nax[-1].set_xlabel(\"Time [ms]\")'" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ "nest.ResetKernel()\n", "nest.resolution = .1 # [ms]\n", "\n", - "sim_time = 1000. # [ms] XXX: 120 second original paper\n", + "sim_time = 1000. # [ms] (was 120 seconds in original paper)\n", "chunk_length = 10. # [ms]\n", "n_chunks = int(sim_time / chunk_length)\n", "syn_recordables = [\"R_pre\"]\n", @@ -3336,10 +3147,6 @@ "conn_spec_dict = {'rule': 'pairwise_bernoulli', 'p': conn_prob, 'allow_autapses': False}\n", "nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': synapse_model_name, 'lmbda': lmbda})\n", "\n", - "#syn_recordables = []\n", - "#nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': 'static_synapse'})\n", - "\n", - "\n", "syn = nest.GetConnections(target=pop, synapse_model=synapse_model_name)\n", "N_syn = len(syn)\n", "syn.R_pre = [R_0 + R_range * (random.random() - .5) for _ in range(N_syn)]\n", @@ -3351,43 +3158,12 @@ "sr = nest.Create('spike_recorder')\n", "nest.Connect(pop, sr)\n", "\n", - "log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, pop)\n", - "\n", - "\n", - "\"\"\"nest.Simulate(sim_time)\n", - "\n", - "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", - "\n", - "fig, ax = plt.subplots(nrows=2)\n", - "\n", - "U_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\n", - "# R_avg = np.zeros_like(U_avg)\n", - "for neuron_id in range(1, N+1):\n", - " idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\n", - " times = multimeter.get(\"events\")[\"times\"][idx]\n", - " U = multimeter.get(\"events\")[\"U\"][idx]\n", - " #R = multimeter.get(\"events\")[\"R\"][idx]\n", - " \n", - " U_avg += U / N\n", - " #R_avg += R / N\n", - "\n", - " if neuron_id < 100:\n", - " ax[0].plot(U, label=\"U\")\n", - "# ax[1].plot(R, label=\"R\")\n", - "\n", - "ax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", - "ax[0].set_ylabel(\"U\")\n", - "# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", - "ax[1].set_ylabel(\"R\")\n", - "\n", - "for _ax in ax:\n", - " _ax.set_xlim(0, sim_time)\n", - "ax[-1].set_xlabel(\"Time [ms]\")\"\"\"" + "log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, pop)" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -3396,13 +3172,13 @@ "Text(0.5, 0.98, 'R')" ] }, - "execution_count": 64, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3416,7 +3192,6 @@ "R_pre = np.array(log[\"R_pre\"])\n", "R_pre_avg = np.mean(R_pre, axis=1)\n", "\n", - "\n", "fig, ax = plt.subplots()\n", "ax.plot(times, R_pre[:, ::N], alpha=.5) # XXX: plot only every N-th line\n", "ax.set_xlim(0, sim_time)\n", @@ -3428,7 +3203,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -3437,13 +3212,13 @@ "Text(0, 0.5, 'Neuron')" ] }, - "execution_count": 65, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAG2CAYAAABiR7IfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADPXklEQVR4nOydeXxVxfn/PzcQAkQSCAgJliUqViG4IYiEglqwKIra/tqKS6Va3KiKK1rlK2oEAmWpgCAIIiJElEU2kX1LCKRJI8SwhrBJwpKd7Mv9/RFPvPfmLDNzZs6Zeznv18tXy73nzHnmeWbmnszzzPO43G63Gw4ODg4ODg4ODroE2S2Ag4ODg4ODg4M/4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQYOtL086dO/HAAw+gY8eOcLlcWLVqldf3brcb48aNQ8eOHdGiRQvceeed+Omnn7yuqaysxIsvvoh27dohNDQUw4YNw5kzZyzshYODg4ODg8PlgK0vTaWlpbjpppswc+ZM1e8nTZqEqVOnYubMmUhJSUFkZCQGDx6MkpKShmtGjx6NlStXIiEhAbt378alS5dw//33o7a21qpuODg4ODg4OFwGuGQp2OtyubBy5Uo89NBDAOp3mTp27IjRo0djzJgxAOp3lTp06ID4+Hg8++yzKCoqwpVXXokvv/wSf/3rXwEAZ8+eRadOnbB+/Xr84Q9/sKs7Dg4ODg4ODgFGU7sF0CI7Oxu5ubm45557Gj4LCQnBwIEDkZSUhGeffRapqamorq72uqZjx46IiYlBUlKS5ktTZWUlKisrG/5dV1eH/Px8tG3bFi6XS1ynHBwcHBwcHLjhdrtRUlKCjh07IihIvPNM2pem3NxcAECHDh28Pu/QoQNOnjzZcE2zZs3Qpk2bRtco96sxYcIEvP/++5wldnBwcHBwcLCD06dP4ze/+Y3w50j70qTgu/PjdrsNd4OMrnn77bfx6quvNvy7qKgInTt3xunTpxEWFsYs677j+XjqixTm+9VQejH1rzdhcPdIrm3bwabMXLz69Y/w9Ql79rOjOw89evTg9kxSuyx4sjf6XB3B7bksmJFVRD9/+uknrrawC38aA3qItgernkjmNc/1SwZ7yjQ3ROjfbJtW2ai4uBidOnVCq1atmNugQdqXpsjIemPk5uYiKiqq4fPz58837D5FRkaiqqoKBQUFXrtN58+fR79+/TTbDgkJQUhISKPPw8LCTL003XVjK1zVPgu5RRWNBhpQP9g6hIUAcOFcsfo1argA/HvbaTzUpxuaBPmv+7C2zo1/b0uBK6Ql1Hqh9PON3xbjjjvu4PZcErtEhjfHXTd2sV2/ZmQV0c9z585xtYVd+NMY0EO0PVj0RDqvea5fMthTlrkhQv882rTaRlaF1kibpyk6OhqRkZHYtGlTw2dVVVXYsWNHwwtRr169EBwc7HVNTk4OMjIydF+aRNEkyIX3Huiu+p1iznHDemDcsO5enxnhBpBTVIHkrDzTMoqkts6NPVl5+C79Z+zJykNtnfdU2Zedj5yiCs37lX5mF1RqXsOCp13UdO4GMHboDboT16hvVsiq/Pu9B7qrymrmXi2aNWtGfC0PROnZrG6ssr8Rij1k0hPpvN6Xnc9FRlY5WdDTs9VzQ0seEfrn0aZVNrIaW3eaLl26hGPHjjX8Ozs7G+np6YiIiEDnzp0xevRojB8/Ht26dUO3bt0wfvx4tGzZEo8++igAIDw8HE8//TRee+01tG3bFhEREXj99dfRs2dPDBo0yK5uIbxlMArLqr0+a90yGBP+2BNDYup3zWY/fiveX5OpOzB9GbUkDRP/9GsbMrEhI6dRf6LCm+O9B7o3yHu+hLCvLcK5yzckJkpX5x+uO4igIJeqbkn6ZoWskQTPNHOvGr4xhSIRrWdW3Vhtfz06dOggnZ5I5zXx/BckJy1GerZybujJc18MmduNRv+8bCraRnZga8qB7du346677mr0+ZNPPomFCxfC7Xbj/fffx6effoqCggLcfvvtmDVrFmJiYhquraiowBtvvIElS5agvLwcv//97/HJJ5+gU6dOxHIUFxcjPDwcRUVFptxzGzJy8PziNE2325zHb/UaJMpfCYnHLmDmtiyiZ7hQ/8Il02DT6rfy94Mi756sPAyfl2zY3l9bHUb8O68aXsfC+v05eGFJWqPPfWVVIO2bCJTxcb6kAu1bNUef6Aiq7XXWez2ZO3cunnnmGer7aLFSzzS6sdP+arz03mSsqewulZ5I5/XSkX1xxzVtucjGIicNJHY/lbTGkrlhJA/pDziN/nnbVISNFHj9fpMiTZ4mO+Gh9No6N/rHb9XcOVL8t7vH3N1osCj3avl+SdshlZPn4KXpNwDdfirXLh/RAx2jzAeN+va1V5c2GDh5G7GNzNiUJ579aBcaAriAi5cqvewnalE6d+6c8L+oZdGz7HLV1rnR593lyKtrYSgPAGE/UmpyxU7citxi7V2HiNBgJL89CM2aShsR0gCp3c2sUzTz1UgeRSat3w6WcWr0m2TXnFTD6pcmaQPB/Q0aH7Dvm7ni+31+ceMdEJp2jBCxrU/bb6WfvpPc08e9YP5nePfdd5nkUVDra0RoMPJLqzXv8ZXVjE15odYPT6LCm2PYTVFY/WOOEHfNvHnzTNvCCBn07A9y7cvOR9bu79C63yO68szcegwJKacscyduysxFRY1+BYb80moMnLzNL1wypHYfN/ljzJ06nrp92nXYSB5FJjVYY4c8f5P01mq7X5jsQP7Xfj/BrA9Y8f22bhHM9XkKyvau7+TLLarA84vTsCEjh6o9WjmU65R+RoY39/o+Mrx5g2uBxwuTWl/1XpjUZLUrVkNBqx+e5BRV4NOd2dztqiD6hQmwX89mn2eVXOdLKjRfmDyZtvmIsPHgizJGfWM41RAlA29I7Tn0b6Oo22ZZh82ML891lRaStfpyxNlp4kT7Vs2NLzK4bkhMFFo1D8Zjn+3l9jygfqv1/TWZqn+NuFH/l8P7azIxuHsk9V8OLP0eEhOFwd0jNben4+LimH+s9fpKiiIrD5uyYrYfZu2qYMYWpNipZx7Ps0qu9q2aozApgejFyRde48ET2jEqQgYRkNpz3aJZePBm8p0m1nWYZXy1bhGMWY/dir5XtzWlZ6O1+nLEeWniRJ/oCESFNzf0AfeJ1k/i1ffqtlza8cSMm8HI987a7yZBLk2Xxmuvvab6OUkcAMlWtha+svaJjkBkWHPNWA0WW5Biph8KWnaliacwYwtSeM0d3sgmV5/oCPx20HCcL3MzvUzzdieyjFGrXJpmxiep3ae+RPfHBOs6bCSPGoXl1QhyuXTjpEj147lWiwzo9heclyZO8PIBi/Als7oZSHzvIuT95JNPGv1Yk8YBsG5lq8mqF6sh2q/P0+Xj2RZtPIUZW5Aia/yEbHI1CXLhxpK92Nykj6o8pD+ovMaWmXZEujTNjk9Su386Z7bmHxVqsK7DevKwPI9VPzKl3rATJ6aJI7x8wLx9ySxuBhrfO295hw0b5vVvGllI+xoR6p2YzldWo1iN1i2Dhfr1ebp8lLZY4inM2IIGWeMnZJPrzWce15TnlUHdiNrgNbbMtCPKpclrfJLY3XduGGHG3aslD207rPoRNe/9EWeniTO8fMA8fcm0bgYW3ztPedPS0tCtWzcmWUj7uuONu5B6skBVVpJYjZCmQUJrAbJsyfviaVfWeAoztqBF1vgJmeRKS0vDX//6V1V5ACAh5bRl7kSWMSrSpcl7fBrZ3XNukGDW3avIk5yVh1FL0lBYrv4HnVY7rPoRPe/9DeeliRE9365evA4NPNuhcTOw+t55yXvllVc2/H9SWRYmZqNdqxC0b9UcY4d2x6gl+n1t1jRIU1aSWI3c4kqhcRlNglwYO7S7aiJOEpS+P9K7E9buP4uLJZVMNmWxBaletOaQlWkFSDGSS0T+M7X2FHtoyWO1O/GR3p0xbfMRomt5yKCnZxEpIvTs7jk3SNsya58mQS7EdmuHiX/q2ZCihrQdVv3w0CvJ/PCXeCnnpYkBf/Tt0qSzt/uotWcxZdJnfLjuYMP/jwpvjmcGRDfKXUSaut/u/gP1Y+zDdZmG10WFN0fMVWHYcvA8fMuPhTZrgmmbj1I917dPLLYguc4f55AWvPui114rlULjnlhVtsIof1jrlvWpUzzd22ZlMNKz1fNWrei7Ebzsw9IOq37M6pVkfvjTeuC8NFGilc5e8e3KnL+C1M1g91HrrKwsxMbGMj8jt6gCc3dmY9ajt6BNaAj1Xy5299+oHM/o31+L6CuvQPtWzVFQWoVRSxpf6wZQWqWfcFAN3z6x2MLoOn+eQ77w7otRe38K+9UeWoh2JxqNz1cGdcM/7653W/GSgUTPVs9bz7lBg10hHKz6MaNXErsB8Kv1wHlpoiAQfLsk7g9RR61Jt1/vvPNOYlnUUGzx4bqDTGn+7TxqbhRP5QLw9X/PeJWl4VEHSatPNLYw0kttnRvJWXl4a/kBW+aQCBcaz/WApL2tRe1QW+cmOoUrqs6b0fhMSDmNf97djZsMpHre8cZdls5bz7lBix0hHKzzl/U+EruNW/0TAJdf/aY6p+cooPHt+jOK7x341UeuwBqXsCEjB/3jt2L4vGS8nJCO4fOS0T9+q+qpiy+//JJIFj3M2EJE/0mhGWM8cjkB+n0itYWRXhT7PzZ/r2YAKyBuDtGMP1J4rwck7WXv2WDr+mLHGkj6zNSTBZbOW8+54Q+wzl/W+0jslltcqVuzUMbfVOeliQIZYl2sgudRa9rjqm+//TaRLCSw2sKuo+abM3OJrjtfUsFtnOn1idQWem2QlIPxhecckqWEEI/rwu74s63rix1rIM0zrZy3vnPDH2DVD8t9dowBK3DccxTYHetiNTx87ywujPHjxzcq3eEry8WSSq/gby3M2MLqo+a1dW6sTP+Z6FqzY2zs0BsaThvq9YnEFnptsJaD4TWHZCshZPa6oj3L0P6ZfkTticCONZD2mVbNW7W54Q+w6kdUDBUJMv2mOi9NFMhWVsEKzPreWY6r/utf/9KVRYmNad0imDpXCS0s/WeNndmXnU9UVLhtaLOGfrHmyRkRG00kk5EtjGBxIXr2zywijqEr8F4PSNr77T1PoM7txnfpP9tyLNuONZDlmVakrtCaG7KjtT6RrFu8Y6g6hIUAcOFcsf/8pjovTRTIVlbBH2DZzp8wYQLeeecd1euMjjoD9trCzNFZUl09eHPHhn7RlFdg0YueLUhg2Vb37J9ZRLqTeK8HRu25AZzatgSPXfr1xdrqY9l2rIGyrrtm54YdaK1Pw26KapSixezYIrHbuGE9AEA62+rhxDRRIltZBdlh2c5/4oknVK8hjY2xyxZmY2dIdRXe4tcSMFrjsXXL4IZcOQosetGyBSks2+o8M62LdifxXg+02gv/xZZNfjvQ63M7yljYsQbKuO6anRtWo7U+5RRV4NOd2UJKpJDYTUbb6uFyu908Tiz7NcXFxQgPD0dRURHCwsKI7vGX7KV2U1vnRv/4rYZb656pARYtWoS//e1vqu3ovTC1bhGMWY/dir5Xt7XcFkbyqfVTrY3YiVuQW1yp+6wolXbUxiNgPk+Omi1oMLK/L2p9MwPL+GN9jqiM4O1CQ/DaNz8it7gClzK24IqY3wvpgxkZrVoDZVp3zc4NKyFZP9Wwcn6w2pbl99sMjnuOEVnLPci0qABsW+vXXHNNo3ZIYmMKy6sR5HIR58ThqScesTNNglwY3qezYRZvkhI2vPqnZgsaSCu02+HawS//vi+mPrjVzBhQWw/M2MCzvT1ZeQ3Hspu2bvxXt5m4LD2M5LdjDZRp3TU7NwDryu+wpifhNbZI54csttXDeWkKIGRNRU+b8r+ysvFOi+wlPHjJ17VdqOl2ePZPzRa0aNnfE95lPkieH+QC6tzA/MQTmJ94gutc4WkDT1u7a7UPCvBO0yDjWiITZueGleV3KmvqTMnK+8i/P48v56UpQJC9NAXNcdULFy40+kz2Eh4nLpZykc9sP3n3T80WLPjav11oCOACLl6qtGRH1PP5mzJzsSDxRKNafbzmCm8beNq6rqyI6DozyL6WyIKZuWF1+Z3Rg7oxywrwPfLv7+PLCQQPAIxy0QD1uWhqfX8lLEbZon3w5qtwxzXacUe33npro8+U46taP6su1P+lonc0VZSeauvcWLrvlOF1RvIB5vopon9qtmDF0/6x3doh9tp2hmOBJ02CXOgTHYHvM9QTiPKYKyJs4DkmmnVo7BIiGfukyL6W1Na5sScrD9+l/4w9WXm2rmmsc6O2zo1xq/npmMRmS/edQmSY9rqiBc+xBcg/vkhwXpoCgEAr77J69epGn/EobSJKT/uy8w2DtwHgkd6diWqGsfZTRP/UbOHPiJ4rItr3HBPlx/Z6fcc7FkzmtUREKRwzsM6NmVuPci0dQlquZHifzgDIy1GJiDOUeXyR4rw0BQCBVt7lhRdeUP3c7NFUUXoivb5ru5ZE17H2U0T/tGzhr4ieK6LaV8ZEtzv/5PU572PZsq4lokrhmIFlbmzIyDE86KHA2xZd27VUXVeiwpvj2QHRiLLgyL+s44sGJ6YpAAi08i5TpkzRLE9gpkRCuytCiJ5Pep2CCP2z9FOEHHq28EdEzxWR7Q+JicK+lZ9h8MgXhJ2OlXEtEVkKxwy0c0PpBykiyvTccU1bzXXlzSE3CD95LeP4osV5aQoAAq28i9FCxHzsmNRNTulON9I/AESEBiO3uAJ7svKIFyPafooYBzK/MLEc1yaxVWRYCPNcET0X/2/sWKb7SLFyLSG1n8hSOGbkpJ0bNMf+aeKIaG2mta5Ykc6BZP61bhGMOrcbtXVuKXMfOu65AIBHvI9MxMXFCWn3YinZEWHS6xT09K+QX1qNV74WG4chYhyIsoVZWONbSGxVUVOHTZnqweJGiJ6Lou1h1VpCYz87XTp6ctLagkY+lvI7gPzrP8n8KyyvxmOf7bU1Xk0P56UpQPC3VPR6jBw5Uki7ol0navpXQ2QcBu9xIMoWZjAb36LoKNynzIxCUVm1KfuInItW2EP0WkJrP7tcOkZyXtN/GFV7pPK9Mug6buV3ZFz/SddKO+PV9HDKqMD6NOwikS0jOAtz587FM888w71dK0pqKPrPLSrHh+sOIr+0SvU60aUveI0DUbZghUe5GqWd2IlbNU8x8RwLPOeilfYQIT+L/awqhUMrp+vwZhxdPpX4mSQlhSLDQpD41u+lGnOiqK1zIzkrD6OWpKGwXD1pK4ltnTIqDqaQqcwAK7169RLSrhXV0hX978nK03xhAn6Nw1iYmI12rUKoFzirSlyIsgUNnn29WFJJFd+iV1aC9Ni3Xjt6mLWB2jM97SH6B1LEWkIan5SclYegIFdD38YO7Y5RS8TNWxY5K8K7UsVRkaw/44b18HpZpLGvv70w7cvOx57jFzVfmADx8WosOC9NDtJx7tw5YW3TlnRhhTR+4cN1Bxv+P2kZAStLEIi0BQlqfSXhfEkFl7ISRu2IcntoPfPe8Bz06tXLb8tQkM4L392HqPDmeGZANFb/mCN03tLIWVdawJw6wmj9obWvP40HljktUwoC56XJQTqqqrR3aHhgJm0BKSzxFSRlBKwuQSDaFnpo9ZWEExfLMH3zEdNlJYzaEREvomfjmSmHENw1E3N3ZvtlGQrSeeG7+5BbVIG5O7Mx69Fb0CY0RPhuComc7toa5vhHvfWHdo77U1kS1jktUwoC56VJB3/a7gwkeFQPN0K0G5PkaK0vRjlneOWrUWIJ9hy/CKBeD32vVi9lYoUt1NDrqx4uAB3CQrB03yldPSllJc4Va8fJkLTDOz+QkY2btonC3F2NX5hEysQTlnkB/Nq3D9cdZIpdol3LSY7xR3Xqwpx6QWv9oZ3jVuawMvt7yDKnZUyX47w0aeBP252Bxo4dO9CzZ0+7xTCFXvyCHno+fB75ajZk5OCtFQdQWPbrX/Iztx1D65bBmPjHno3Gtl22oMlpo6As38P7dNbNuqyUlXhl0HWYvvmIZnwJSTu84y2M+l1x6gCaXdnVUpl4wjovAPa+sazlJPFHsaHnub+Y0s5xq3JY8fg9pJ3TsqVLUHBSDqggY8r+y4nHH3/cbhG4QJOGwBc1H77ZfDUbMnLw3OI0rxcmhcKyajynMrbtsgVLDINyvLpru1Ci67XKStC2wzPewqitK3rcxaUdO9GaF61bqKeA8IWmb2bWcqNj/OPfHEUsBym0c9yKHFa8fg9pZZAxXQLg7DQ1QtaU/ZcTM2fOlDoTNQ2+8QsXSyq9gr+1UPPhm8lXU19Z/SfDe33Htl22IO3r2KE3NDp9uCcrj/gZemUlaNrhhVFbxWlr0brfI6bbsRu1uJ6a2jo8sWCf4b2kZY54rOV68UdxcXHc5wbtHBedw4rn7yGpDP+861rEXttO2nAY56XJB7tT9vsjvGO/AuWFScEzfqG2zo3PdmczlakwU+Ki/oi9caZz37FtxhZ648JozJD2dURsdKOxxqushB0lRXKLyhER2gwFpVWqzzR6YfKVSea4TF+9Jx69SHajgU9P6XPisQtc1nKt8SFinaIdc6LHKM/fQ1JZXxl8XcOzZRy3zkuTD4FQhdlKRMR+ifgLThbM5Ioycy/NePW8ltUWeuMCgOGYsUtPItoxguYIdmFSguGLkyKTv8Vl8ihzZOVxdhHrFO2YEz1Gef4eksq6KTNX6nHrxDT5EAhVmK1CVOzXiy++yEM8aTFT8oD1Xprx6nktiy30xsVzi9PwHOGYsUNPotrRQktXWoT1ekDzu7ahzRpk8se4TLNrL60uaZ/ri6h1inbMiRyjvH8PjWQFIP24dcqowDsNe+gVrSxP2e+P8CpnocaMGTMC/sUJMOc6YckWHDtxi6GLLsrHZrS2MBoXemiNGSv1JLod3zaNdBURGox37uuOj9YfREFpFYpS16i+OEWEBiP57UFo1jRI6NwUiZlyKSzjzqweRK9TMmQEF1XCRk1WAEzj1imjYjNWbcn7ImPsgZZMtXVuLEzMFhb7dddd+ieEZNQVC2ZyRdHe2yTIhXHDeuC5xWm6140deoOXLo1s4QtLqgAFrTFjpZ5Et+MJia7yS6vRsXULjH84Bs8vTkOLzt7pHxRLjX+4J5o1DSJqV9a4TDNrrx3H2WnnBi0sc5y3PUX9HqrJuicrj3jc9omOaPgNCIV2GRYROC9NKlhVakNBxtgDLZmG3RTVqJSBHizxAkePHkVMTAyVXLL4u2VmSEwU5jx+a6M8TZ58uO4ggoJcDbrUs4UaPGL9Lpd4QZp4kQdvvgqzH78VL0/8LyrRteE7tTXJn+MyWddeluPsZtcM2rnhr8hWempTZi5eXZbeIEtdZRmX55PivDRpYEWpDUDOFPhaMuUUVeDTndlUbbHEC7Ro0YJKLhnLBciKMq5nbDmK6VsaJ2701aWWLbTgEet3ucQL0saLDImJwtRH+yDit3101yR/j8tkWXvtOM5OOzf8GZlKTy1IPMHtmSw4L006iC61IWNOKNbyFb6YOeratq358gIO+nz939Oqn/vqUs0WerCWyQDkLJkgEpbj4u2vbIfenI52y6xn2rWX5jg7r/WBdm74OzKUngpyAXU2R2E7p+dshCb2QBaZSDAbL5Cenk4tl5auauvc2JOVh+/Sf8aerDzUEsw4lntoEN2+ETS6TE9Pb5B3ZdoZzN91HCv/py23EgMB/DoOFFwa/9/z37KVTBAJia589aE2N3i06+/Y0WcSW/DC7JpBe7/Va5QSp3pvTGTDH26eKP+2+4UJcHaabEXG2AMezzLr637ggcang1h0xRL/JDpmSoaYLBpdhnbro3miRUtuoxgIoHGeJlHxgrJDGy+iNjd4tBsIWN1nUluYxeyaQXu/1WuU2vNcLsDzXH9keHPcFxOJ+Ta75gAn5QAA648sKuzJysPwecmG1y0d2deyUy6kMmkxdugNqlmaaVBLGkerK634J0UqtfgnlntoEN0+KaS6fGXQdRj3wQcI10mm6IK23GYygl9ukOqDNqHi5ahnq/psRRJes2sG7f1Wr1Faz1N4OrYrBnWPbDgtp7Zu1VWW4fT0v1j2++28NMG+lyZROTBEyqSFiBw7NHJ5Ph+gz/chOrcNz/bN6rSqpg59J2xBfmmVpiwdwkIAuJBbbLwr5Zvb6XJBhhcSGWQQjQz5imjhIYPZNYP2fpJ1gefvEa18Wr8BVr80Oe45G7ErJxSrTFpoycq6zav2FxyNrmjyfSg7eKJz2/Bqn9dWvd7CCADD+3TGtM1Hicp2yJjzRzR2uVk954YMrl7RyOxa0tpp4iWD2TWD5v6i8ir8a+UB5Jdq5zzind+Ltn8sv00icALBbUZ0mQaeMkWFN8ezA6IRRSCrmTIOr7/+OpVcvs9niX8SHV/Go32zpTFIykwouuzaLhQAEN7nj0Ryb8rMJbouELCzRIkyN/yxTAottH20Widq6xRPGcyuGTR5j55fnKb7wsTSLq92PK/T+g2wEmenSQKsygnFS6Y3h9ygK6vZ9AAzZszAG2+8QS2XAkueGtG5bcy2b1anJKkkIkKDseONu9CsaRD2ZOUBAIpT1yD89j8Zyv1d+lm8MzSwTmSpYXfqixkzZuDV114P+PQbtHq2wy6+6xRvGcyuGaT3r0o/S7Vrwyu/F2v/fH8DQlGNwdO5iESE89IkCb45MJQjn761eax8sdLKy2GUr8PstvJDDz1ELZdnDEG70BBEhjXHuWLyPDWic9uYbV/0Vj1QX7Ljyz0nMCI2ukHe6m59de9RyCutavRsGWJLeGPGDjz08dBDD/ltmRQaaPrYJzpCaFknLXzXKd52MbtmkNzfJjRY01VP+zw91MY+Tf/U7ld0WFxcTC2PGZyXJglR84m3bhkMAF7lL2SNXzC7rZyamopu3boRP09LX8pfdySxYqLjy8y2b9VW/YfrDuKz3dl474HueO+B7njiXz8gOOIq6mcHarwNqx146SM1NRUtrv8dV1llhLWkBq92SfBdp2hkJnlpMrtmkNz/8M1XUR3jZ1kD9cY+Sf82ZeZKtZY4MU2SoeUTLyyrblQvTNb4BbPbypGRkcTP0tJX0S+6Cv/lZbOhbZ1YMdHxZWbat2qrHvh1XAHAGw/fjojQYIM7vJ8RyPE2LHbgqY/IyEi/L5NCAk1JDZpkvDx14rtO0chManOza5LR/YO6k621bUObMa2BRmMfgK58AKRbS5ydJomgLWEia/yC2W3lpk3JhiVJDEHzpkH46h+34+KlSiKXiOj4Mtb2RW/Ve+I5ribGtsfoJ2KJjiIr2+iBHG9Dawfe+mjatGlAlEkxgndJDRE68V2nFJmNXuJobW52TdK7v7bObajniNBg7Hn792jWlG6PhXTs7x5zt6p8QH3qGKP71z9/G5VcZnF2miSCpYSJHaVWjDBb0iA7m6woMEkMQW5xJYJcLjx481UNx1b1YI07oSk7oMRkkcqk3KOlU6C+r4/07sR8v1p7OUUV2LIvA82aBmH8wzFwqdzra087SgNZWfKBdmzz1kd2dvZlUSaFpI80L0wAf534rlOeMuvha3OS8cuyZpDcb6RnF4DxD/ekfmEC6Ma+mnyk96eeKKCWzQzOTpNEmPG3yxa/YKakwYABA4iewTtNAGvciVXxO1o6VZi2+SgSUk5rPtfofjU6db9V915fe1pdGsiO2Cmasc1bH8rcuBzKpOj1kaakhiidqK1TQ2Ki8HRsVyLZzpdUSBH7J2osWRWHeeGStb99zkuTRJjxt8sYv8C6rbxkyRK8/fbbhu3zjO3QSuev+M61/Pms97Gi6HTm1mOYtvlIo++NnqvcvzAxGx+uO2j4vLSta4H7bve6l3e6B1as1r0npGObtz4854aMqUp4o9XHfdn5RC8mPMo6aaG1Tg3qTvZCd+JiGaZvPmLL+PVFxFiyKg7zyius/e1zyqjAvjIqvrCUMNFKbe/Px71ra2vRpEkT4+s4laFhLVcguvQKb3nV2jDS3Y7XB6JZMPnfVlaVBrJL97Tw1gfp3Ah0iMfvG3ch9WSBkHVQyxYkshmVKZJl/JrB7NgnvX/987chok1ry36/nZgmiaCNO9Hy1W/IyEH/+K0YPi8ZLyekY/i8ZPSP3+o3p5YmTJhAdB2v2A7WuBM74nd4PZdUd5PiJ1LJZlW8jV26p4W3PkjnRqBDotdhN0Vh4ORtwtZBLVuQyDa8T2fduo6yjF8zmB37ssbuOS9NkqF1RLR1y+CGXE0KvMuXyAJN5XAeaQJYfe9Wx+/wfi6J7liquFtRGsgu3bPAUx8s9ghU9PT6zIBozN3ZOOElz3VQzxZGNlfKFBkhw/g1g+iUCXbE7jkxTRKi5V8G9DOCB8pxb61CmFqY9cez+t7typfD87lGuqO1BWm7ZvG3XEW89MFqj0BFTa+9urTBwMnbhK+DRrbQs7lSpsgIWcavGUSmTLAD56VJUrRKlYgsXyILTz75JPU9RqVd9GDNe2NXvhzez9XTnZotSOPlzNjECH/MVcRDHyxzI9Dx1euerDxL1kFfW2jNC7Vn8By/pPPRzjhXs2Nf5FpCi9TuuZqaGrz77ruIjo5GixYtcPXVV+ODDz5AXV1dwzVutxvjxo1Dx44d0aJFC9x555346aefbJTaPvzJZaHHli1bLH0eq+/cLp+7lc/1tYUs8XKyxjuIxuq54Y9YtQ562oJ2XvAav6TPlWXeBgJSvzTFx8djzpw5mDlzJg4ePIhJkyZh8uTJmDFjRsM1kyZNwtSpUzFz5kykpKQgMjISgwcPRklJiY2S24O/uSy0uO666yx/Jqvv3C6fu1XP9bSFbPFyMsY7iMaOueFvWLUOKrZgnRdmxy/pc2Wbt/6O1O65PXv24MEHH8TQoUMBAF27dsXSpUvx3//+F0D9LtP06dPxzjvv4I9//CMA4IsvvkCHDh2wZMkSPPvss7bJbgf+6LJQo7y83JbnsvrO7fK5W/FcxRayxsvJFu8gGrvmhj9h1TpYXl5uel6wjl/S5959fQcp560/I/VLU//+/TFnzhwcOXIE1113HX788Ufs3r0b06dPB1Cfxj43Nxf33HNPwz0hISEYOHAgkpKSNF+aKisrUVlZ2fDv4uJiof2wCrNVsWUhL48sSFIErL5zu3zuop+r2ELmeDkzOqCN87A7/5na3LBbJjOIkN2qdTAvL4/LvGAZv6TP/XKPfkFjf4lzlQmp3XNjxozB8OHDcf311yM4OBi33HILRo8ejeHDhwMAcnNzAQAdOnTwuq9Dhw4N36kxYcIEhIeHN/zXqVN9za7jx49j0qRJqKysRFxcHID6ExJnz57F/PnzkZKSgh9++AErVqxAZmYmPv74YxQXF3tdm5+fj1mzZmH//v1YvXo11q1bh7S0NHz66ae4cOGC17VlZWWYMmUKDh8+jGXLlmHLli1ISkrCwoULcfr0aa9ra2trMWHCBJw8eRJffvkldu/eje3btyMhIQFHjx7F5MmTUVFRgf+umo/Zj9+KmtRvUXupACXpG1CZcwTNz+3H41Hn8BvkYcaMGSgqKvJqv7CwEDNnzsSBAwewatUqrF+/HqmpqZg7dy7OnTvndW15eTmmTJmCo0eP4uuvv8bWrVuRmJiIRYsW4dSpU/joo49QV1eHuLg41NXV4aOPPsKpU6ewaNEiJCYmYuvWrfj6669x9OhRTJkyBeXl5V7tX3XVVZg7dy5SU1Oxfv16rFq1CgcOHMDMmTNRWFjodW1RURFmzJiBjIwMrFy5Ehs2bEBKSgrmzZuH3Nxcr2srKiowefJkHD16FAkJCdi+fTt2796NL7/8EidPnsSECRNQW1vrdc/p06excOFCJCUlYcuWLVi2bBkOHz6MKVOmoKyszOvaCxcu4NNPP0VaWhrWrVuH1atXY//+/Zg1axby8/O9ri0uLsbHH3+MzMxMrFixAj/88ANSUlIwf/58nD171uvayspKTJo0CVlZWVi6dCm2b9+OXbt2YfHixThx4gQmTpyImpoar3vOnDmDzz//HMnJydi0aRO++eYbHDp0CNOmTcOlS5e8rr148SLmzJmD9PR0rF27FmvWrEF6ejpmz56Nzp07Iy4uDudLKlCYlIC6yjIUp3yHqounUHo4EeXZaag8exiX9m9ETUkeZk6Nb2i3uroa8fHxOH78OL766ivs3LkTO3fuxFdffYXjx48jPj4e1dXVjebaggULsHfvXmzcuBHLly9HZmYmpk+fjpKSEq9r8/LyMHv2bKSnp2PNmjVYu3Yt0tPTMWfOHFy8eNHr2kuXLmHatGk4dOgQvvnmG2zatAnTvlqL6/7yJv48ZS2efOktDJ+XjK5/eArr0k9j4sSJOHHiBBYvXoxdu3Zh+/bteGvSJ7jtzcW47x+v46XFKbj376PRP34rnnxxjGVrRFlZmdca8eSLY9A/fivu/ftovLQkFfc99Sp6v7UUb0yYoblGeLafm5uLefPmISUlBRs2bMDKlSuRkZFhyRqxfv/P6PqHp/DI3CSMeOlt/HnKavz2r29hypffGa4R586d010jPNfBuspSFKeuQdWFE2h25r94umsR2pafMb1G3HTTTZg5NR41xRdw6cBmVJw5iPIT6Sg9uAvVeWdQvG8F6qrr5835kgqua8ShrBMoTEoAABQmJcBdU42ivd+iuiAHpZk7UHFqPypOZ2DNiq9RU3QORcnfwF1X63VPTfFFXNq/CZU/H8LGTRuZ14i8vDyva0tKSjB9+nRkZmZi+fLl2LhxI/bu3YsFCxY0Wtt4rBHfffed5m+9CKTOCJ6QkIA33ngDkydPRo8ePZCeno7Ro0dj6tSpePLJJ5GUlITY2FicPXsWUVG/+n9HjhyJ06dPY8OGDartqu00derUyfaM4Dzx578+p0yZgtdee81uMRzwqy32ZOVh+Lxkw+uXjuzrF3+xapVgUWaIVv4z0utF4Tk3ZJGJBatkF7kOTpkyBf0eGmHLvCCdj2OH3kBULslf5q0aVlf0kNo998Ybb+Ctt97CI488AgDo2bNnw9v+k08+icjISAD1O06eL03nz59vtPvkSUhICEJCQsQKbzM0W76yvWA9//zzlj1Ltr7LhmKLQImXA8jiQcat/gmtmgfj4qVKRLRohn+tzJAiLkSxh6wxZmr4zrFeXdpYJrtI9/Xzzz+PkOYtpE478sQdXfHZ7uyAmLeyILV7rqysDEFB3iI2adKkIeVAdHQ0IiMjsWnTpobvq6qqsGPHDvTr189SWf0VGY+iTp061ZLnyNh32VBsEUhH/EniQXKLK/HYZ3vxckI6nvh8H/JLq3Svt6rkhWIPfykjozbH+k7Y7BeyGzF16lTp0440axoUMPNWFqR+aXrggQfw0UcfYd26dThx4gRWrlyJqVOn4uGHHwYAuFwujB49GuPHj2/wxY8YMQItW7bEo48+arP08iPrUVQrMh7L2nfZ8LRFoBzxF5WnzIr8Z4o9/CEnm9Ycyy+tJrpf9nxyii1kTzsSKPNWFqR2z82YMQNjx47FCy+8gPPnz6Njx4549tln8X//938N17z55psoLy/HCy+8gIKCAtx+++3YuHEjWrVqZaPk8iPz9r7oUhEy9102fG0RCEf8ReUpsyL/mWIP2XOy6c0xUmTPJ+c5N2RPOxII81YWpA4EtwqrA8lkwK7AXpIYogsXLuDKK6/k9kxfAi2omTeeNgquuoQ/3HYdUd6Yfdn5yC0qR35pFSKuCEFkmLULM005if7xWzXjPGhR4kJ2j7lbeF+VuWHUBytlUoN0jqlht+ykiF6nHMhwAsEdLMGO7f0NGTl4f02m13Z9VHhzvPdAd68t4hUrVghNTOoPrg278LVRSfr3uG7gw41spHePJ2r2tUJuvWfr5fFhxaq4EGVuyJ6TjXXuyCA7KaLXKQc5kTqmyUEcVm/v08QQ9e7dm8sztZDdtWEXajZqFtlNN85Ly64KORbEiLHEp2nFedDSNrSZpXEhnnND5lgV0rkTEdrM698yyE6K6HXKQU6cnabLFCuPkNPGEOXkiA3CDqTj87zQslFtaYFmnBdN3IqoGDEz8Wm+cR7tQkPw2jc/4lwxmdsuIjQYe97+PZo1te5vT9+5IWusCukc2/HGXUg9WSCV7KSIXqcc5MR5aZIcUXmErNzepy01UFtba/qZClr6k8m14Slju9AQwAVcvFQp9EfEVy91bre6jX5J76FWbsHIrgrKvclZeYjt1o5jL8yXd/HN4zNumLHbTrHG+Id7WvrCBEB1bthVwkcP0jnWrGmQdLKTomYLkXPZ7pxydj9fFpyXJomhidNgQdne931GJOc4FNoYoq5du3J5rpH+rOg7i4yeiIgJUntm6xbBqtc2DW/v9W9PW9LGrYxakoaJf+rJtS+849O0xoUnVo8RT3jNDSuQZY6JwtcWIuey6N8C2Z8vE85Lk6RolRlQ4jR4+f2t2N6njSHatWsXbrzxRlPPJNWfna4NLRn15BX1zMJy9dw5lWd+QrP20Q3/9rQlbcxXYXk1177QyEAjq5rbzordPxJ4zA0rsXuOicTTFiLnslW/BbI+XzaclAOQL+WAcpxY6y8WfzmSq0B7PDo/Px8REezxRP6gPyMZPeElL80zG+4pL0GTFq1UZWBpj7fuZT96zxuzc8OBH4otRM5lu9cyu59PgtW/387pOR1q69zYk5WH79J/xp6sPNTWmXu/JG3PX0okkEJbauCTTz4x9Tx/0B9pPBBgTl7PMbcwMZvqBQcASv63TjPOS7ErzVJJ2hfSuaI3tpTnPdK7E4WEcmN2bphFzS6810l/QbGFyLls91pm9/NlxHHPacDbh0vTXiDmEaKJbzCbDdwf9MfybNp7jGIstGjdIrjBXde63yO6MSgkMUBq6PWFdu4ZyTBt81EkpJwOiPgLK0oMaaEaC9eyPhausOxX9+7lEutCW9LGE95rlN2lgfzpt8gszk6TCrzrktG2F6h5hIbERGH3mLuxdGRf/OeRm7F0ZF/sHnN3o8U1Li7O1HP8QX8sz6a5xyh/kh6zHr21wUb3VCWq2sgTT7uOuvMaomdo9YV17ikyvDLoOtXvA6WmoNm5wYqWXQrLqr1emIDA0bURii1EzmW71zK7ny8jzkuTD0Z5X9wA3lp+AInHLhJtQxu1B9TnkfFsS8lxouf2iPLTPELK8egHb74Kd1zTVtUP/tJLL5l6hpH+XOCrPxb3BImNFWjlNVP3Kyq8Ofpe07bBRv8e9xZRrIJi11fv+S2z7lnmii9L951S/Zz0ftkxOzcA+vFKO54CRddGKLYQOZetXstke76MOC9NPpD4pwvLq/HYZ3vRP36r4V9TLD5hzzgNLYbdFBUQga1qLFy40NT9tDFUZtiQkYP+8VsxfF4yXk5Ix/B5yUTjwigWx4y8NDEWvviOK1pbmNG92fiJmVuPIrc4sOMvzM4NlvHKMp4CQddGKLYQOZetXMtkfL6MOC9NPtD4Zkm2oVl9wkNiovDMgGiNq4G5O7MDdvt70KBBptuwosSEWTcuSSkPFnnNxBf4jisWW7Dq3kz8xIaMHEzbfJT5fn/BzNxgHa9m9OXPujbC0xai5rJe21aVnLH7+bLhBIL7QOObNSrTQNOe73W1dW6s/lH/R1dUaQq7OXToELp3199pI0Fkjhgz5Tv0ZOSRE8hsfIGn3Ky2YNG9mbny/ppMYtn8Of6C1R5mxqsZffmzro3wtYXI/F5257uy+/ky4bw0eVBb50Zdndvr9JARRmUaWOucmS0PwYoMqfJDQ0O5tSWqxARP+/CW0WjM6eErtxlb0PZL1FzxxN/jL1jtYWa8sownf63fSLP+qdmCdszTPM/ucjl2P18WnJcmD+6ZtgMXKpsw3au1Dc1a58yOo56ypMr3h+R9Mh/F1RtzpChyW2kL0XNF635/gtUeZsYr63jyN13Trn9m54Ys660DHU5MkwfniiuZ79XbhmbxCVt91JN3mgUz7N+/37JnsSL7UVySGAs9FLmttoXIufLKoOv8/seI1R5mxyvteHpmQLRf6Zpl/TMzN2Rabx3ocHaaCDCqeE6yDU3rE2Z1VbDAKz6HF/fee6/wZ5jFSvuwooy55Kw8jFqSRuxy9nRh2WEL3nMFACLDQvDPu68VJ7RFsNqDx3ilGU+rf8zBm0Nu8IudJtb1j9UWsq23DnQ4O00EKIPb7JFLkhxFntdaddRTtlT5CxYssOQ5LCg5btbuP4tHencGoF2+Qwb3RJMgF2K7tcPEP/UkvueR3p0b5LbLFjznigvAuGE9dNvwl1IgrPbgtZ40CXIhKMhl+ALuD+kGFJtP23SYaf1jtYVM662/jHuZcHaaCHkqtiu+z8g1LAHCE5rSI2aQLT7HzlIRemiVkaiqqUNZVa3XtUp5CVkYEhOFp2O7Yn7iCcNru7Zr2fD/ZbWFL2bmij/FlpixB6/1RLb1ggWWEkO+/WG1hSz686dxLxPOSxMhg7tH4p2h3S0/WWbFUU/Z4nPi4uKk+7FWYhB8/w7zLSGhUFRWjecXp0mVx2RQ90iilyZPO8toCy1Y5oqWXZXYEpnsB5i3B4/1RLb1ghYtmxvh2x9WW8igP38b9zLhcrvdl/1+XHFxMcLDw9Fp9DIEhbT0+k7x9e8ec3ejhUWG4/k8qK1zo3/8VsN4BzUdiKCyshIhISFM94qwiaIf2qzIVuvNCBY7m7GFGTmtmFdGduVhP959Uexh59oj23pBA8tc1uoP69ywW39WjHtSOXjktFJ+v4uKihAWFiZMXgVnp8kDGl9/IG1tsh71FsV//vMfvPnmm9T3ibIJa1kSUbm0WGGxM6stWLFyXonOhSaiL//5z39w431P2Lr2yLZe0EA7l/X6wzo37NafXTkAPTFyj8r8W+oEgnvQPsz7rwatY86BeFxUplT5f/rTn6jvEWkTs7EFMsV20NqZxRasWD2vRMaWiOpLu56/k2LtkWm9oIHWlnr9MTM37NSf3TFVWnPDE5l/S52dJg82vjIQh/JqdLe8A/m4qCyp8vft24drrrmG+HrRNjEbWyBbbAeNnWltwYod80pUbImovtTWuTHhi7Vwd+3HtV1WZFkvaCC15T/vuhax17bT7Y/ZuWGX/uyMqdKbG57I/FvqvDR5QJIm3qqtTbtiFmRIlR8V1fivLD19sNqEVMesZUlkyNWkBamd1WwhAjtcBiJybdXWubEwMVtIX/Zl56Mk6Apo/ZTZ4Q6WYb0gQZnruUXliAhthoLSKl2bvzL4OsP1lsfcsEN/duaYo3GPyhbeoOC8NFFixdZmIMVLsdCkiXcpGyN9sNiERscsZSRkj+0gxdcWorDDZcA7toT2GDttX86XVAAu44gKmdzBMkBqF+q8exbNDd7YGVPFMjZlG89OTBMlorc2AzFeipaTJ082/H8SfdDahEXHWjEIUeHN8eyAaET5WWwHKZ62EIldLgNesSUkcRq+0PalfavmqCm+wL3dQIbGLrQ2t2puiMCumCqWsSnbeHZ2migRubUZyPFSNPTv3x8AuT52vHEXsU3M6FgvBuHNITf4VWwHKYotRGOny8BsbAlpnIYCa1/6REeg0w23oBDqu50yu4PtgMQuEaHBGHt/D0SG0c9Zq+aGKOyIqaIJdZB1PDs7TZSILG8iU3p9O0lISABAro/UkwVENgFAFW+ihlZ5D5qyH/6EYgueqJVusLJskBpm7EcTp2GmL02CXLil6ievdni0G6iQ2CW/tBqRYc2Z5qyIuWE1Vq9bevPcE5nHs/PSxICorU27j4LKwuuvvw6ATh9GNgGA/vFb8eG6g8RtOvxqC15syMhB//itGD4vGS8npGP4vGT0j9+KDRk5l8UxdrN9mfvvD/xSR3Ygej3lPTcuF7TmuScyj2fHPceIiK1NGdLry8DEiRPx7rvvUutDyyabMnOpyyYEuo5JUWzBA9LSDYF6jH3s0BswIjbaVF8Ue/ibjuxA9HrKc25cbvjOczMZwa3GKaMC69Owa2F3en3Z4KEP2rIJgaJj2Ur88CzdIGvf7J63sunFDnxLc7z2zY84V+ysp4GMU0blMsbu9PqyoBTC5KEPq+JNZIJnygpeBXt55WGSMR2HlfNWyx4y6sVq1HTQumVwwwEP3nbxp2LWDvxwYpokw1/jOngyYsSIhv9vVh9WxpvIAO+UFZ62MAOP+BKZ03FYNW/V7CGzXqxCSwdFZdUAgPCWwV6f87ALr7nh4F84O00S4o9xHTzZtGkT/v73vzf824w+rIw3sRsRKSt8bcGK2fgSf0jHYcW89bWHP+hFNCQ6aN40CF/943auMTO85oaDf+G8NEmGb1zC/Td25L7YiY59MNv+DTfcoNkWrT5I8//4+wsTIKYUiactzGA2D5MMldlJEF0Ww9ce/qIXkZDoILe4EkEuFx68+Spuz+U1Nxz8C+elSSKsiEsQ/Qwe7ZeUlHBr63KKExNxxFqxhVnM2sFJx1GPrz0cvdinA15zw8G/cGKaJMGKuATRz+DVfmFhIVdZL5c4MRFHrAsLCxmlaYwZOzjpOOrxtYejF/t0wHNuOPgPzk6TBFgRlyD6GTzb794jBv/4jq+sl0OcmIhSJD179uQmH8BuBzvLrMiErz0cvdinA95zw8E/cHaaJMCK8imin0HTvloZDU/mfrVciKyBWupEQUQpku+//55KBiPbKnLS2oF330jktAMjuXztYXf5GRpE6ZxEB2OH1teG5PFspR+TP0uQauw4WIOz0yQBVvjkRT+D9L5Nmbl4dVm6bpzSHUP/gu9WHxUmayCjuMB8Y8EiGePWRo4cSXyt6Hg5Xn2TNacRiVxq9uBtcxHYOTaG3RSFD9cd5PJsz37U1cVgy7xkKcaOg3U4GcFhf0bwPVl5GD4v2fC6pSP7Mp+AEf0M0vbVUP4aVOJannn1X9jYLNbwPjP6CHR4nZAkTeCnVSLF17Y8MNM3K+WkgVQuPXvImhHczrFRUFqFUUv4PNu3H4VJCWjd7xHbx87ljtW/385LE/gpnXXRMluGgeS5oko9KM/OLSrHh+sOoqC0SrPGW5AL0NrJ9nw+ACnKUohA1h82M/AskSISWeWUVS4e2Nk33qV7AtVGtMi2hjllVPwUM9vPZo5jkz5XxNF7tWeroTxPz/XvGae0ZelsvPfQ0wGXJkBWt5AeJDtN/pIrSFY5aeTasnS2X5XusFPnPJ+t1pay00Tblj/jj2sYb5xAcA7wOB7Pchyb9rk8j95rPVuNyPDmeDq2K1G750sq8NxzzwVcmgB/LXXx3HPPGV7jL7mCZJWTRi4Se8iEnTrn+Wy1a1rdfC/zM/0Rf13DeOPsNJmE51F7muPYrM/lcfRe79kKEaHBGHt/D0SG1be/Lzsf8xNPGLbdvlVzfPvtNw0vToGQJsCfS118++23hj/U/pIrSFY5aeRS5oa/YKfOeT5b7Zqyw4lodct9TM/0N/x5DeON89JkEt7bz6RlGMw812ypB6NnA0B+aTUiw5o3PIcml0qLvn25ySoDpLZamJiNdq1CpHo57OthCy38IVdQbZ0bdXVutG4RjMLyatVr7JKTdW74A7Rjg2e8DM9xqdZWSMfrmdoShchYI1ld23bguOdMQnPUniebCduTZdubJp/MmTNnOEgpD6T6+nDdQbyckI7h85LRP36rFNvdJLaQPVfQhowc9I/fisfm79V9YQLskTOQ5wZN3xQ7DZ+XzGUe8ByXam3VlFxkaksEvHXni6yubTtwXppMQroduyDxBLcBvCEjh8jVBci17U0apxRoBzpZbCBLnACpLWSNQSONvbNbzkCeGyR9ExUvw3NcNm7LzdwWT6yINZLVtW0HjnvOJMq2LckJMh4+X8W3TEKQC+jVpQ3zs7Qws+1NEqfUqVMn7jLbiZG+1JAlToDGFrLFoJHE3rVuEYxZj92KvlfbnyE+kOeGXt9Ex8vwHJeebSX/Nxh9b+sl7RjnuYb4gwveKpydJhMoPuR7YyINr+VRCgUgiydSqHMDqScLTD1PDbPb3lplNJTyBHOWfR9Q5Qn09KUHrzFjhj179lBdL1OpGpK5UlhejSCXy/YXJgUj/dHYQ7ZSMWp9q61zY2FitvAyUjzHpdJW8/ws6cc4rzVEdhe8lTg7TYyQ5ijyxazPl/Z+UT5m3qUbPPVZW94VGwKsPIGWvkiwM07gL3/5i23PNksgxmGQ2sMf8unQrqGy2UmGuWHlGPeHcj1W4Lw0MaBVFoAEsz5f2vtF+ph5bXv76rPkf+vRut8jDT55f8zLpIavvi6WVOLDdQcN77MzTmD2bP9KpuhJIMZhkNhDa32SaT6xrKGy2UmGuWH1GJfNBW8HThkV0KVhN0qnrwWvNPukz/eXtP6Xc3kCUaVtHOq5HPXrD/OJdg2VQWZZuRzHuC9Wl1FxYpoI8IwNMPK/q8Hi89WKR1B8yySt+IOPWas8gQKJT1622A1S/CFOIC4uzrZnm8Uf9EuLkT2Sj+dZEuPiC+kcJIlh8kRmO8kwN4ziJd0A7oup3xkysy4q9l2Zdgbzdx3Hyv/511rLE2enCfpvqqyxS57QxhKQxCPoySVb7IIe36X/jJcT0r0+q6ssQ1BIS6/P/vPIzXjw5qsa3e8PsRtGyNyHkpIStGrVylYZzCKzfmnRs8eGjBy8tfyAZi4qT56K7Yr/e6AHF5lI9cuylspsJ5nmhppufQuks+pS9t8aq3eanJcmaCvdTOwSADwd2xWDukdS+Xy1nqnc7RmPoJzeyy0qR35pFSKuCGkoWyLbX2Va7MnKw/B5yV6fFad8h7DeD3p9tnRk30aZZml0JTuyVQ5XmD59OkaPHm23GKaRVb+0aNmDZa2aw2F+kM5BFvnGDr0BI2KjpbWTbHNDGeObMnOxQCWPH8u6SGI3F2WbvLH6pckJBNeAJMeLHi4A6zNy8a+hdC45mpwbvEqM2PmDopb/o3n0LQ3fa+X/CLRaSHaUiyGx+z333EN1vazYXY6Hl+487eHZNu1axWN+kM7Bu6/vQCWfMudleGHSs5uaLeykSZALfaIj8OqydNXvaddFmnHlT2utWZyXJg1o8iGpwVKLx476Pna7LhSf/POL0+BCfR+r806jWbvOuvEMTi0kc5Da/eDBg+jevbvt48Sf4ak7xR6esKxVPOYH6Rz8cs8Jv4xhMrKbmi3shue6SDquLre11gkE14BXThCadqzOK2NF+n0SfMsTBDVrAUC/PEEg5uCxChq7t2rVSppx4o/w1p1aDI2ZMW7FvSfzy4jbtLskiQKJ3WSJZ/KE57ooS05A2XB2mjTgldeCph0rc27I5t7yzP+xO6kO/fv11XVhBGIOHiugtfsVrcLwmkTjxJ8QMcfCw8MbfWZmjFtxb5eIlsYXQZ4YJlK7TblTfPwMLTzXRZlyAsqEs9Pkwb7j+Q1HZnt1aYOo8OZUZS98aRvajKoWjxLfo/VMF+q3h3nU97Eq/T4NStxJ2+oLhuUJrNQVC7KmQSC1e3JWHgBg3Y59to8TWXVphJk5ptXnAwcyGn1uNBfU4DE/SJ4bERqM1i2bISK0meFc5fnCZGbMkNpt3Y59HCTlC891UWmLhNYtglHndlsyN+1eD6Tfafr5558xZswYfP/99ygvL8d1112H+fPno1evXgDqq36///77mDt3LgoKCnD77bdj1qxZ6NGD/jjtU1+kNBx1jwpvjmE3RWHuzuyGWBtaHry5I9UioBbfo8Db1y+ze2vIkCGG11ipK1pkjv8hteeoJWmY+KeeuPbWWGBrLrd2aZFZl0awzjGtPg+7KQrfZl2BvGPJXp+/90B3zbmgBq/5oTcHFfJLq/HaNz8Kl8UTs2OG1G7X3hrLLKMoeK6Lnm0ZjanC8mo89tle4XNTzbZXhtQKeZYWUu80FRQUIDY2FsHBwfj++++RmZmJKVOmoHXr1g3XTJo0CVOnTsXMmTORkpKCyMhIDB48GCUlJaaenVtUgbk7s/HMgOiGWBuFiNBgojYGdzcu5OuLb3yPAm9fv8zurQULFhBdZ5WuaJA9/ofUnoXl1Xh+cRq+Xfol13ZpkF2XRrDMMa0+5xRV4NOd2chKXOv1uaILAKpzoXXLYLRu6b1e8ZwfWnOQFN5zlceYIbXbng3LmWQUDc91UWmLdMdJ5NzUsu354kruz9JD6jxNb731FhITE7Fr1y7V791uNzp27IjRo0djzJgxAIDKykp06NAB8fHxePbZZ4meo+R56DR6mVdSReXo64437kLqyYKGY6e9urTBwMnbNFPXA/V/2ZhJXS/6eHcgpd+X5Si8P5Ww0Bu7Ci4AHcJCALhwrtjaceIPujSCdo7xKNEEoNFcUPuMt848c8Z9uO4g8kurNK+NCA3G2Pt7cM8px2vMBMrayHNd9LTvxUuVmLktC0UaSVRF6EfPtnWVZTg9/S9OGRUAWL16NW677Tb8+c9/Rvv27XHLLbdg3rx5Dd9nZ2cjNzfXK19GSEgIBg4ciKSkJM12KysrUVxc7PWfGorvOvVkAe64pi0evPkq9ImOQOrJAtwbE9kQFOiJ65f/zGw36w12Xv5cmUtM0JYnUGKh7r+xIwBg7f6ztvi6ZYwT88XT7ka4ARza8AWG9+kMwNpxYocuzcwttXtp5xjJEW/PEkMKnrpQ5sKDN1/VcPzbij8olOdGhrfQfWEC6l12kWHNDeMWaeE1ZkjtNmH8R+zCWoDvWDDrir3jmrZ4+NbfIOaq1povTADd3PScN4lHLyLx2EXV+Wc2BRBPpH5pOn78OGbPno1u3brhhx9+wHPPPYeXXnoJixYtAgDk5tbHWnTo0MHrvg4dOjR8p8aECRMQHh7e8F+nTp0AANWFuSja+y3cNdUNi1NhUgIOZZ3A/Pnz8Z+E7xHzdDwefH0q5ny3E8X/XQ13VZnXte2Cq3Bfkx/Rse4CVq9ejXXr1iEtLQ2ffvopLly40PBCEBcXh7KyMkyZMgWHDx/GsmXLsGXLFkxdvBrX/WUM/jxlDZ586S0Mn5eMrn94Cut+PIO/j/4Xer+1FA+8PB7P/vsrPDx2Lq5/dCzmr0vE5MmTUVFR4dV+bm4u5s2bh5SUFGzYsAErV65ERkYGZsyYgaKiIvx31XzMfvxW1KR+i7qKSyhOXYOqCyfQ7OdU/L1zAa6sPIu5c+fi3LlzXu2Wl5djypQpOHr0KL7++mts3boViYmJWLRoEU6dOoWPPvoIdXV1iIuLQ11dHT766COcOnUKixYtQmJiIrZu3Yqvv/4aR48exZQpU1BeXu7V/ogRIzB37lykpqZi/fr1WLVqFQ4cOICZM2eisLDQ69qioiLMmDEDc1ZuQ/e/fYCH3p6F56Ytw/2jxqHPu9/iyRfHNFxbUVGByZMn4+jRo0hISMD27duxe/dufPnllzh58iQmTJiA2tpar/ZPnz6NhQsXIikpCVu2bMGyZctw+PBhTJkyBWVlZV7XHj35M0rSv0dl7jGUZaWg7OheVJ3PRknaWtSWlzSMk5lT41FcXIyPP/4YmZmZWLFiBX744QekpKRg/vz5OHv2rFe7lZWVmDRpErKysrB06VJs374du3btwuLFi3HixAlMnDgRNTU1XvecOXMGn3/+OZKTk7Fp0yZ88803OHToEKZNm4b+XVthQOlOtG4RjMKkBNSWFaHkf+tRde44yo7tQ9mxvag6dxwl/1uPK268B6sXzvh1nFSWoTjlO1RdPIXg0/vwj6uL0ab0FBYsWNBI7urqasTHx+P48eP46quvsHPnTuzcuRNfffUVjh8/jvj4eFRXV3vdc/bsWSxYsAC7k5JQnp2G0sOJqLp4CsUp36Gu0nuu1ZYX44v5c5Geno41a9Zg7dq1SE9Px5w5c3Dx4kWvdi9duoRp06bh0KFD+Oabb7Bp0yYkJyfj888/x5kzZ/Dki2PQP34r7v37aLy0JBX3Pf0abntrCd6cMBO7du3C9u3bsXTpUmRlZWHSpEmorKxsaP/JF8egzzvLcP8/P8Bz05bhobdnofsT7+PT73bgyNZv8O+HuqEm9VsPuUuAzB/wZu/mqDqe0rBGfPn5Z6gtK/LqY111BYr3rUB13hmUHtyFkMhuqDhzEJcObEZN8QWva3MKSzFhwgScPHkSX375Jf69aBV6PjsVw16JxwufrMN9/3gD/eI2eM0JozXCU4eFhYWYOXMmDhw4gFWrVmH9+vVITU31WiPOl1T8Indlvdz5P6P04E6Un/wRFWcycSljC2qKz2PWtEmm1ohz5841WiP2pf0PxalrUFdxyVuHlaUNa1vZkSRs2PA9UlJSMG/ePOTm5nq1q6wR14Rcwl/bnkKLvEOoOPMTLmVsRU3RedT+bwVmDr8J/101H2PGjKFeIy5cuIBPP/0UaWlpWLduHVavXo39+/dj1qxZyM/P97rWzjXi0qVLXtdevHgRc+bMQXp6OtatW+u1RtSWF/vou36NSE3fj+XLl2Pjxo3Yu3dvozXiyRfHoN/4jbjv6dfxwpwNePDVifjTe/Px7OTFeGD0BNw2ZjGeeuUdVFdXY+bU+Ib2a0rycGn/RlSePVy/Rhz1righGqndc82aNcNtt93mtWv00ksvISUlBXv27EFSUhJiY2Nx9uxZREX96qcdOXIkTp8+jQ0bNqi2W1lZicrKX/2gxcXF6NSpUyP3nMLSkX1RVF6lGxDHUjLFF72SBFrP5VEyRBb3lkJ8fHyDu5UEWcqpqJWEUUOtJIwdJB67iMc+26t7TVHytwjv+/8w5/FbG1JCWDFOrNSlmfFDei/JHCPps2IPNTx1YdecsHMOiHi2nt1o16lAgYeeScuzAPVjNbxFM81nWu2ek/r0XFRUVKOMqzfccAOWL68PwIuMrA+0zs3N9XppOn/+fKPdJ09CQkIQEhJi+HzFN6vEMOm9uNCWTPHFKDeIFjxy5dhdYsKXP//5z8TXypRvSq0kjC+eR3N5xwDRxrL0vbotosKb6257t7y+v5cOzYwTmpdzI11qlddhkYl1/NDea6S7PtERiAxrjtxifXv44qsLO+cEb7vZPWZ87aa4k86XVOCaPoO4z2NZ8bRDu9D6GqdGcY5aeiYtz+I5Vne8cZfh2moVUr80xcbG4vDhw16fHTlyBF26dAEAREdHIzIyEps2bcItt9wCAKiqqsKOHTsQHx9v6tmevuvUkwXCS3aY8dkGWhr7PXv24Oqrrya6VqZyKiRHsEUczVU7hqucmCos+zX2wPeZirzP/XL6So3Knw8iuHWkaR3SHgO3KqWEmfHDe+xtysxFRY3+8WnFHgossVEi5wRPu8k2ZnzlufTTNkxJLvSL9Bdm0FpflJcaWj3T/NZ5xhUb2dYqpI5peuWVV5CcnIzx48fj2LFjWLJkCebOnYtRo0YBAFwuF0aPHo3x48c3+OJHjBiBli1b4tFHHzX1bM/jmVbkNOKR5yZQ0tgrMWYkyJZvivQINq+juVrHcAvLqr1emLSeOSQmCk/HdtVsv2nYlQ3/n1WHrMfArUgpYWb88Bx7io58babQpmUwnh0QjQ5RV3l9rqYLu+cED7vJNmbU5GkadqXfpL9gRcsORb+M03CGdBYs4+58SYWmbduHGXuNeCL1TlPv3r2xcuVKvP322/jggw8QHR2N6dOn47HHHmu45s0330R5eTleeOGFhuSWGzduZKoLtODJ3ihFcKNtYCtyGvHIc3O5pLH3RMZ8U0pJmOSsPIxakoZClZMmPNwktNXttZ45qHsk5ieeMLyfRYdmXUWe5XVExFKZGT+8xh6JHUOaBuHNITegb8sLaN4pRlcX7a4g+xEhvY4FM3aTbczIFAJgJST9bt40CF/943ZcvFRJrGeWdUS5R82217dtiogPqJtkRuqXJgC4//77cf/992t+73K5MG7cOIwbN870s/pcHaEaSCY6vqK2zo26Onf9aSado5xa8Irv0INHsDhpG6dPnyZu06rYF1I8+3ixpFLXnmbdJLyq2+vpsKb4gikd8nAViYy5MzN+eI295ON5hnbMLa7Evux8nP35DB67c6DutVRv0QJhtZtsY0ZLnpriC8Ty+CMkdsgtrkSQy4UHb75K8zpfSGI/FdTmkK9ttVIGiUL6lyYZEOkrV/MX6yEyvkMLHqUsaNq44447iGWTqZwKrS0VWN0kvNzBejpsftUNANh1aLeryAgz44fH2NuQkYO3lh8gkvV8SQXR3LhYSpYhecuhc4jt1o7oWiuRbcxoPSfkl7lhdJ2/IsoOJLGfgP35ArWQOqZJJkT4yrX8xWo8OyAac2woGcKjLAFtG9988w2VjDKUU6GxpS+srkOe7mAtHQadSDalQxndp76YGT9m7m2IYyLcXW7fqjnR3CDV5YLEE1LG4sg2ZrSeU3ZoN9F1/opIO5DEftpZDksPqfM0WYVSRoUkzwOvnEa0JROUsiyANRl+SWQkSZfP0kZ1dTWCg8nq+/k+y458UzzKX5gZQzTHcI2e6avDW37TCs1DmlHLRiqjWR3wxMz4ob2XZsx46qiutsZwbpC2LZPuPZFtzGjJ466tgatJU2n1aBYr7OCbygAuUMVHAXS/3zxwdpoo4ZWanjYeRatMgshJyqMsAUsbJOkitMpWWKUbT1hii1i3nj37vS87H2OHqpd7YH2mrw7/PXkSsWxa7WmVbZFt+93M+KG9l3bMKDoymhvKj9C9MZG61wFylPVRo0mQC2OHdtf8oQasHTNaZVWK9n5ruTy8ymiRYEWpLc95E9utHWKvbWf5+k2LE9NkE6zHLq2Eh0+bpY13331X91oeMVY8YbFLJIO8Wv1+ZkA0Vv+YY5inieWZRrYgJbxlcKPj9K1bBmPCH3tKt/1uBaRjpnXLYEz00JGePayOqRPFhowcfLguU/U7ljHMA8Wd5Knf1v0esVQeO9Y9tX4D9tlBBpyXJpswc+zSKnj4tFnaiIuL0/xx0Eq/r8RH2eEDJ+3j2KE3oF2rECbXoV6/5+7MxqxHb0Gb0BDu1e31bGFGbgAo0MhJdDlAOmZmDb/VK1hbyx4kZSnMymIFRv0YO/QG236ofY+7r1s0C7PHfGTZIRO71j3RaT/8DeeliRO0MQ1mj11aAY8j1SxtPPXUUw3/39fnPW61NflSRJRvGBEbzT0fk9LvD9cdVI0tMHsE2tMWtBjlHwrU/DYkkI6Zvj72U7MHbb4u32dYva5oQTJePlx3EH+IifIaL1bGMnoed+/d/p+WueTszhMlW6ktO3FimjiwISMH/eO3Yvi8ZLyckI7h85LRP36r7skUPX+xGnbEffDwabO0oRRa9tXrY/P36tbl4hWjQWtP0b5/HrFlrGgVvSbBTrllh3XMqNnDypg6kbCMF5a1lxdm5gYNzjySC+aXprq6Ohw5cgS7d+/Gzp07vf67nDBzJF/xF/umovflmQHRtm5Jmz3OT9tGjx49TB3hNxOjIVv5BsDevDU9evRgvle2fDuywTJm1OzBGlMn23Fu2vHCIx2KGczMDRqceSQXTO655ORkPProozh58iR8Mxa4XC7U1uoXnQwUeGybDu4eiXGrMwFox3es/jEHbw65wba/CHn4tGnayC8oxAdbLzEnLGaN0ZCtfIOCnWUxioqKmO+VLd+OjNCOGTV7WBFTZwU040UGl5WZuUGDM4/kguml6bnnnsNtt92GdevWISoqCi6XXJPPKsym+6+tc2NhYrauywkEbVjhz9fzaZPKQOoX/19WDnKKrjS8zhezMRq8yzf46qVXlzZIPVlAbysby2KUlJQw3ytbiRtZoYkXUbOH6Jg6q6AZLzzmqlnMzA0a+kRHIDKsuebvxOUwj+zKwacG00vT0aNH8e233+Laa6/lLY9fYWbblPZ4MGkbVh+9FyFDWGQX4HQZ1T08YjR4V6331UuQC/BMq0KqJ9KyGKTX0XDDDTcYX6SBTCVuAgU1ewSKnmn6IYPLyszcoGFTZi4qatS9N/5kX1Zk+J3zhCmm6fbbb8exY8d4y+J3sG6bssTrkLZhlT9fpAzH/pdEfQ+PGA1e2+BaevHNQ0eqJzu35zdu3GjqfhlK3AQSWvYIFD2T9kMGl5XZuUFCQ6kdjfQcrVsG+5V9aZHhd84XpjIqK1euxLvvvos33ngDPXv2bJTW/8Ybb+QmoBWwpmFnSTNPW3KDpQ0r0vqLlKGwqBj3fpKiq9cOYSGY8pebqVPu68GjbAAP+4qQi5WSkhK0atXKdDsyba/7M0b2CBQ9G/VDhlIrvOaGFiRrSWRYCBLf+r1f2tgI0t+Y9c/fhog2rS0ro8LknvvTn/4EwDtniMvlgtvtvqwCwVm2xWmOB7O2ofjzk7PymKqYkyy8PGMKfJ+3ackneO/hf+jqddywHoi9lm+Fdh5uDtrj36RxUna5X/7zn/9wyQpuV56XQHmJUDCyR6Dk0/GNDUzOysOe4xcB1H/eu2sEHundGdM2H2l0r96c4DkePG3B0q7RPSRrSW5xJdMaa3Ye8KgZZwTpb0zqiQLTz6KB6aUpOzubtxx+C22aeRofu9k2Ri1Jw8Q/0ZWpIPUf84opUH9eP/QBbEnfb7ZsAGsMhdF9dpUz4FVGxQ5ki4XggT/bg4UNGTl4a8UBL/fUzG3H4HIBWj4SrTnBezwotmBpl+QesWsse7+N4nF5zTHS/l+4ZG2qBSb3XKDBo0oy6Zv8nqw8DJ+XbNje2KE3aJ52IW0DqP+ri9TnrZWqX5HAsx1SGZaO7Kv5V5DW84qSEtC63yOY/fittqXvZ/3LjMY2nujpiYdcrJgto2IXNGPZn/BXe7CwISMHzy1Oo7rnlUHd8M+7uzVOCipgPMTFxeG2h56mbpdUFpFrLGu/Scr18JpjpP3/7JEeGHxLtGXuOebklllZWXjxxRcxaNAgDB48GC+99BKysrJ4yuZXkFY5V47Vav3MuVD/pq53PLj+CCp5Tp7312QaVsM2ynvi2w5pP7SOweo974pb7mt4HgDmyvNmYK14b6QXX4z0xEsuVp5//nmh7YuAdiz7E/5oDxZq69wYt/onqntcABJSTqu2JWI8PPPsc9Tt0sgico1l6TdpuR5ec4y0/726tmF+BgtML00//PADunfvjn379uHGG29ETEwM9u7dix49emDTpk28ZQwoeJUmGd6nM9HzSFPsk/qPp206gj1ZeQ1yesqtQNIPveeVHdptujRAbZ0be7Ly8F36z9iTlUf00qh1PU1btOVx3KjfVZQ1zmbZsmV2i0ANr7ITtGPICvzRHizsy85HbjFdCg0tu4oqQzJ59ufU7dKss/uy8zF2qJg1Vks+PWjiNXmUdhFdnooVppimt956C6+88gomTpzY6PMxY8Zg8ODBXIQLVHjEp3RtF0r1TCP/MKn/eOa2Y5i57ViD35q1H3rPC+l4PbVcntD68PWuB0AdD6BlX988TQofrjuIoCCXlO6iO+64w24RqOERCyJrPJQ/2oMFM/mVfO8VldOp429vAv6nXclBrV2WdfaZAdFY/WMO1zVW5HVm7/GE5LeyuLjY1DNoYXppOnjwoOpfPE899RSmT59uVqbLArMlN2jzjxhdT9uekidj9uO3YveYu6n7ofe8mpILaNbhaia5tHzunvJ6LjR612vFU2i15YmafS9eqsSLS//H1J5dnD59GjfffLPdYlBhNocP7RiyEn+0Bwtm8iv53isqp1NN0QUAranaZVln5+7MxqxHb0Gb0BBua6zI68ze44uo8lSsML00XXnllUhPT0e3bt28Pk9PT0f79u25CBYIGAXtmjkerPh7jbZLlVwWvbq0wZ6sPE1ZjEoY+OJb34m2H/rPcxGXBvA9+jputXE9qruv74DUkwXILSrHh+sO6vr81SCtbeV7bLp//FZT7VmB75jl4ZGyOnjdTPkWGWqa6XG5lKxS4jZpXHRadhVVzue6yDBE5emvmZFhIV7tsq6zH647SJ1zine/aWRn1akWMqXSYHppGjlyJJ555hkcP34c/fr1g8vlwu7duxEfH4/XXnuNt4x+iejtfc/cPUYDeNhNURg4eZuuLHq5gLQwU99J73lNW9XnXzLyV9OWolHk7TthC/JLq6jk1WqLtO8y1MoyQk2fYaVnEXJ1DvOYtcPNZSavlex2+s1vfmP5M+2gSZAL44b1ID49p2dXUXnOunTuhPeu7qC7ZlbU1GFTZq4t6yzvfpPKbme8kRUwBYKPHTsW//d//4cZM2Zg4MCBGDBgAGbOnIlx48bhnXfe4S2j32FV6nfF3xsVrr4FqvjD5+7MJpJFq4SBEax+a63nNS/IMnSBsJSiUTD7wuSJDHEDPNDS589H9jOPWTtLILCWFZHdTsnJ9Oks/JUhMVGY8/itaN0yuNF3vhtuRnYVUWYmOTm5od1wFRkBoKis2tZ1lne/SWT3t9I9tFDnaaqpqcFXX32FP/zhD4iMjGyo9CwynbxoeORpUrCjxIni/sgtKkd+aRUirghBZFi9S853h4lEFqW9xGMXMHObcRoJ0hxDRvIr7purW9WhQ/srda+nKVUiEtK+88i5Igo9fdaWFaFpy3DqMStDqR9FDhrXoMx2AoCLFy+iXTu+mfBlRysjeOrJAmqXL09XsWKL2jo3YiduRW6xvOusP2YEJ4Xn7zcJ1O65pk2b4vnnn8fBgwcB+PfLkgjs2N7X8vfuycpjkkVpr090BJan/cw9FsBIfqMEfrSlSkTAOx6AdwwADXr6LEn/Hq37PUI9ZmmOVsde247bQqv240Azz2S2EwB8Mns2Bj/6ghQBsQBZjTizP9ZNglyI7dauUUkolvWTZ2zMnDlz8O677/6SHkHudZZ3TBBre4FQ1ogppun222/H//73P3Tp0oW3PH6PTNv7ZmWxq+aZUcZjK3Tn2V/R8QB2xwDo6bN1v0eIrqNp0xPfFBZmtvR5xE/JbKcNGTn4vmk/LPDYCbMzDYKRvmVN28ALZZ3y13XWagJlPDDFNL3wwgt47bXXMHPmTOzZswf79+/3+u9yRuTxTVp4yCIiFsCIuLg43e9ZdBcRqh5zoEVkeHPMefxWzLEgHsDuGAA9fRYmJRBdR9OmGmbjnHjGT8loJ6V/B79f6PW5FfFhevJo6XvC+kzb4tmsQlmn/HWdtRI74xt5w1R7Liio8buWy+WC2+2Gy+VCbW0tF+GsQkRMk9FWq+hYDt6yWLmteunSJVxxxRWa31fV1OH6sd/rHod3AVj0VB/kl1Whfatf47v0jstGhAZj7P09EBnm3T+R8QAybFHrjZO6qnI0adaCOaaJ9Gg1wD43RMVPyWInz/7VVZUjqFkLr++tXFN85dFCK5ErYL28olDWKX9dZ61CdHyj1TFNTDtN2dnZjf47fvx4w/9ezsiU+t1IFjeAR3p3wtr9Z7EnKw9VNXWaZSOsrHk2b9483e9TTxYY5g9yA2jaJKhB3mZNg3R14QIw/uGeePiWxv3j3Xer68eRyKOlm0s//gCAfszSlpMB2EsviCqTIYudPPun2MMTHiUrSFDKykzbdNgwplBvflolrxFmy+Qo6xTPNV+WMccTUfPTLphimpxYJn14lEkRLYtyRHba5qMNn/n+dWiXv/nee+/V/Z41hkAmu8iGlm4639gPExndA1ptGkEbsyZTHKEINmfmNvz/Flf30rxOZP9oc6KRYKc9eMTXeK5TztqiTaDNT6aXpkWLFul+/7e//Y1JmEBCptTvvrKcuFiG6ZuPNHbF+HxgV9mIAwcO4Prrr9f83kwMgUx2kQ013Zz67xZTtvdsk/RoNe8SQaztysCGjBzMTzzR8O+qCycR3LaT6rWi+qdVVsYsdtmDV5kc33XKWVvUCbT5yfTS9PLLL3v9u7q6GmVlZWjWrBlatmzpvDT9AumxTCv82Iosin+ZpVQKT5n0+ty6dWvde1mPhfs+8/4bO16WC5qe7n3H7KXjbUw/T/TRatnTBLCilHTxJCikcaFu3/7xXE/0ysroEeQC3G71rNF22MMzl51e6SSa9U5tnWI5ih+IcUye8J6fvvq6vi3TawwzTE8rKCho9NnRo0fx/PPP44033jAt1OWE1ccwaXMcicgrZdRno9xfLEd0A+W4q1lo9cAzD5uoo9WBemRbba76BoED9f1V+sd7nNOuF4qGR/6uvhKBDPagcS3SrHc85sblsC7xnJ9q+royxNqDZ0yB4Gp069YNEydObLQL5aCNHccwWf3GvPzNJH1WEqfqQXNEN5COu5qBRQ8ktqBB1NHqQDyyrTbnqvNON/rsqdiuDXmReI9z2nmv6Pvt+7pLYQ/Wcksk/TY7Ny6ndYnH/NTS13mKos484Lqv1aRJE5w9e5ZnkwGLXdXUWf3GPPzNpH1OeGwQUXskMQSyV623ClY9DB48mLssomI/Ai2mRG3ONe96S6PPBnePFDbOSef9P++6tlFmd7vtwepaBMj6bWZuXI7rkpnxYKQvK2F6aVq9erXXv91uN3JycjBz5kzExsZyESzQsauaupF/WY3wFk1R53ajts5tagKT9vmj6bMxd+p4ojaNYghkrlpvZSwDqx4WLlxomKGdBbNlHbR0x7tchBnM2ldtrl7K2NyQpd0zFkTUOCeNR3ll8HWqfbOz3AZLuSWa+DAzc0PmdUkkrONBhtJZCkwvTQ899JDXv10uF6688krcfffdmDJlCg+5Ah67jmF6+pdJKSqvwWOf7TXtayfty9C/jWJq38wzrT7uanUsA6seRLwwmcUf4kBElXTxfGECfo0FETXO7YgX42Vf2r769sdIDjNzQ9Z1SVZk0gNTTFNdXZ3Xf7W1tcjNzcWSJUsQFSXHoiU7dh7DHBIThWcGRFPfl2PS107al3WLZjG1b+aZVh53tSOWgVUPRiVtrMYf4kBElnRRytr4xoKIHOdWxovx1B1tXz37QyKHmbkh47okMzLpwVRMU1VVFbKzs3HNNdegaVNrj/35O3Yek66tc2P1j+w/Lqy+dtI+z3jtfWbZWJ9p1fFnu2IZWPXw1ltvcZPBLP4QByJCRs9YkJz/F4OoNlc0cleJHudWxCfx1h1JKIJa6SRSOba/OYa0a9Sy+WuaDFGwhJWIgmmnqaysDE899RRatmyJHj164NSpUwCAl156CRMnTuQqYKBiZ7kVM/5hMynvSfs8bSo/Fy9tKRmllILZEgta2FVSgHW8/fvf/+Yqhxn8oRyD6JIuRzYvbYhh8hybVqwnZkt8GM0p3roz0olW6SRSOR598R3Nvhj1VaZyWySIWg9JIdGXVTBtD7399tvYv38/tm/fjiFDhjR8PmjQILz33ntS/XUqM3al3ufhH2Ztg6TP11/xiGn5SJ6pVkomKrw5ht0UhdU/5giJmbEzloFlvD3yCF9bmMEf4kBEyxh1y92Nip96jk1ZS3mQxCmJ0B2LTkjb3xt0PVIT0gF494U0Jktme3kiSwyhElYyb1c23B7vbC6L35qYXppWrVqFr7/+Gn379oXLQ+Lu3bsjK8u4TILDr9hxLJeHf9hMG0Z93r17N7p27WpaRr1napWSySmqwKc7sxvdz6ukjN2xDLTjTYQtWLFbdzyfzSLjhowcvD5zGUJ73OX1ue/YlC3tAmnZElG6o9UJafsVZzJxRXgHAL/25ZkB9Uk9SUu0yGgvT3iVnOEli5puLd70YntpunDhAtq3b9/o89LSUq+XKAeyo7OeJU72Zedj7f6zRJOH9Vhun+gIRIY1R24x/V+7vHztekdPSQtC0/afpZSMAq+YGZ6xDCz2p71HpuLc/hAHQhJ7EcUgoxJn0yTsykbfqY1NWY6p08QpmbGv0bim0Qlp/ExTD1so183b1fhHXflea/2QyV6eyBRDaCbnFm+YXpp69+6NdevW4cUXXwSAhhelefPm4Y477uAnnZ9Ds61JuwVqZst0U2YuKmrYU8+L9rXX1hrLZqb/rDFdPHKn8DrCzdJ/lntIbGEV/lAuhSSlx7CbothzDrnrVL+XNa8PbT4iFvvydh/pjTNv4RvbQm/XQ1YbaSFTLimZ8jQxBYJPmDAB77zzDp5//nnU1NTgP//5DwYPHoyFCxfio48+4i2jX0JzdJb2mK2ZY7nKvYVl1arfhzZrgta/xPr4EmVRCYScHP2TfWaPJZuNeTF7v9kj3Cz9Z9WZkS2sxh/KpRil9Ji7M5s6NYIy5movNa77qXadLNDGKdHaV1QKCi05PDGyhRay2UgLmWIIZdIZ005Tv379kJiYiH//+9+45pprsHHjRtx6663Ys2cPevbsyVtGv4NmWxO//H/SLVAzW6YkW5ytmjfFzjfvRurJAuQWlSO/tAoRV4R4HckVTZ8+fTS/47FlbDbmhUfMDGssA0v/zehMzxZ2IXscCElKD1q3hjLmmkVdR3SdLLDEKZHaV7T7yFeOiyWV+HDdr/XmjGyhhWw20kKmGEKZdMacXKlnz5744osveMoSMNAenaXZAjWzZUqyxZlbXInUkwW2bh8vX74cb775pup3PLaM+0RHICI0GPml6rttWvCOmWGJZWDpP+k9CxOzMSI22usHRs8WJIgqFcMjDoSHbGptiHBrKHE2h/cmIvj2/9foexniudRgjVMisa8V7iNPOWrr3Phsd3ZDX8qOJCLcxxZBLsDtVnfpyWojLayKISSZhzLlaaJ6aQoKCjIM9Ha5XKipqTEllL8jYltTudZM2zJtt+rx8ssva37How9Nglx4+OarMD/xBLFMssTMsPSf9J4P1x3EZ7uzvWJB9GxhhCxHldXgIZtWG/fFRBLdTzPPlDib5/IelDaeS40GuTVivNxgl9vq9cw31ims14MN3ynSj/xd/ek5f7KRFlbEEJLOQxJZrIIqpmnlypVYsWKF6n+vv/46QkJCEBysHg9zOUGzrUm7BWpmy1Sm7VY9Jk+erPkdrz4M6k72w6YgS8wMS/9p7OkbC6JnCz1kLnfCQza9NkhfxlmOzg+s3CN1PJeV2LGeecY6Fe1b3vC5YoO37+sufcwdDSJjCGnnoZYs7cNCmGVgweV2u03tdh06dAhvv/021qxZg8ceewwffvghOnfuzEs+SyguLkZ4eDiKiooQFhZmuj3lSLvRtubuMXcDAPG1SkwTzfWscsn61xCvPhi1A6iXWLAblv6T9NWoDRYZtVwndo4zHrIZtQGQuWnM6FfWeC5fRI4FO9czIxv4k41I4N0fM+PCV5br2zZFRJvW3H6/jWA6PQcAZ8+exciRI3HjjTeipqYG6enp+OKLL/zuhUkNsynj9VK+A/UL6X0xkQ0xTTTp9M2k3/eX1P16hTB59cGzHV9c0C6xYAYepQho+q88b+3+s3ikd2fVe9TwjAVhKUoqutyJGT3ykI0kNrDO/Wswsidm51lcXJzpciZWQhNP52tPmUuRNAlyYcvS2Zo28CcbkaD05/4bOwJAo7JTtJiZh3brljoQvKioCOPHj8eMGTNw8803Y8uWLfjd734nQjZb4BWHoZUiP8hVv6DOTzyB+YknGtqmSadvJv2+P6Tuf+qpp3S/59mH8JbBjdIvtG4ZjAl/7Mm9ejuv+B6S/qs9T0kloZVuwpfzJRWGttC6j+d1npjVIw/ZSNt4KrYrvs/I5TrPWOxhJzTxdAo0pYzsXM/8zRZm4bmG+Ut8rRpU7rlJkyYhPj4ekZGRGD9+PB588EHjm/wAxT337Z7DeH3V0UZbvcp7LIsPV9lK3JSZiwUqsQ6ebdMeozazZSrz9vH8+fPx9NNPG15npg9a5QEU5nCMP9B6lplxBWj3X+95bgD/79ar8G3az4btLx3ZF5nbVxHZwpM9WXkYPi+ZqH2aU0089MhDNpo2lNN0vOYZ6dyQBVJdkaBnZzvWM3+zhRl4r2E81wje4TVGUO00vfXWW2jRogWuvfZafPHFF5opB1asWMFFOKuZ+P0huNGk0edmcn40CXKhT3QEXl2Wrvq9b9s0PyJmjl3LmrofAG688Uaq8jO0GOWrMpvfhfRZZnPJqPWf5Hm7j11EZFhznCs2PkrcNP9GKpkAMUeVSfo1bvVPaNU8GBcvVTIfXSaRjaYN3vPsxhu97SHqZYFXuzyPistWisTXFgqiX+B82+/VpQ1STxYY5rQy8wf2uNV81zB/KImkBdVL09/+9reAri13rrgSQSEtVb8zk/NDpnT0/sDGtGN4aXOxsKPqVtrDatuTPC+3uBKvDLoO0zcfMTxKnJ9PH3ck4qgyab8e+2xvw2esR5eNZLOznIunPUSldODZLnFJEkJkWivV5oboNBtq7SshH1rPMyvTzK1HdeuUstjEH0oiaUEVCL5w4UJ8/vnnhv8FMiw+Vn/231rNhowc/GdDhtCj6lbaw2rbk7bTtV1LoqPEpaWlTHLwPqrMoh/ao8s0stlVzkWxh6iUDiLaJSlJQosMa6Xv3BCdZkOrfd9YbM/nmZVpQ0YOpm0+SiQfrU38oSSSGswZwS9XWHJ++Et+JLtRXDBN2/6m0Xc8q2q3u4IsrwfpdXpYbXua591xTVvDOLrrr7+eWRae5U5Y9KM3ZnjIZkc5l+uvv16Yy1ekK9moJAktMqyVnnNDdEkXkhJYvs8bt/onAC5mmZRnksJiE9lLIqnhvDR50CEsBBcr+afA92f/rZUoLpiKE+lo1q5x6gq9ch9UkPoIOOTrt9r2tM8zigXZvHkzundXT81AAq9YE9bYGM8x065ViNeizEM2q2NpNm/ejKKQDkJcvqJdyXolSUgRsVayxvt4zg0W3dE8lyTNhe/zcosrDa/RsyfNM6NM2IR0DslyeMl5afLgrXuvx+urjnL3sfqz/9ZKlO3dK3oO0r1OrdwHDRdL9RcT2uv0sNr2vJ83YsQILnKZxWxsjO+RdlnSa9AyYsQIbDteQnQtrbvESlcyiz1FzBcz8T6ec4NWd7TPFemO1Gqb5pmif7/09NWvc6iw56rBnNwyEBncPVKYj9Vf/bdWomzvFqeuNrzWTJyA1S4zq23P83kff/wxV9nMwCs2RoZSLqx8/PHHwsavLPMiKrw5nh0QjSjB88VsvI/n3KDRHctzRbojtdomfeYrg64T+vtlpK9NmbnCnq2G6TIqgYBvngeR24CybDHKiFXlPuwqv2C17QN1rHn2q11oCF775kfN9AlaiLKxFYgav7LNC9HrMM/yLqS62/HGXRg4eRv1c2nXRhKM+kjyzMiwECS+9Xthc4jETu1CavHfDx6Uv4xKICMyTbvdKeBlRtmyL0xKoC73QYqyEN8bEymkzIUeVtqe1w8OSxkVHuVi9PDUY2y3dhg3TLtkkRZGY0d0H1hRyqiwlA+RtSyJ1rwQOV9IY5BeX5aOxGMXVe3vOTdIdZd6soCpfIhRaS4W3NC3J0mfhvfpbLqkit64JLHTOYPYLd741U7ThAkT8K9//Qsvv/wypk+fDgBwu914//33MXfuXBQUFOD222/HrFmz0KNHD+J2rc4o6qDPN4mZmLozhzgI8T+P3IwHb77K8DqWHCf+CM9cMfn5+YiIIA/wFJ2nhua5JKiNHbv6QIKnPWjkFHWtv/Jd+s94OSGd+PrWLYMx0ae0ktrcMNId6XO11jSSNax1i2AUlhuXSnoqtiv+7wHj30nSkkwsY4SHvuoqy3B6+l8s+/32m5emlJQU/OUvf0FYWBjuuuuuhpem+Ph4fPTRR1i4cCGuu+46xMXFYefOnTh8+DBatWpF1Lbz0iQXs2bNwnPPv4CFidlEx5JJUu0blU15OrYrBnWP9HsXFu9yB7NmzcKoUaNseTYtnrtrpEfafceO3X0wwtceJDuKLH0KVNeuAmt5F8/ySlpzQ093PMqHGGUEr3O7vZK8sjxD75knLpZh+uYjpucIybgMb9HMUF9WvzT5hXvu0qVLeOyxxzBv3jy0adOm4XO3243p06fjnXfewR//+EfExMTgiy++QFlZGZYsWWKjxA5m+N3vfocmQS6MiK0PBtVaql0gO+pKUjZlfUau3/8wGOWKAerzstBso5MW4xbxbFo83TksY0eGPhjhaw8jFxZrnwI9jEBJYUHbK09dac0NPd0ZPZdkTfNtv1nTIK9/9726LZd1U+2Z99/YEQkpp0zPEdJx2atLG8O+dAgzn0+PBr94aRo1ahSGDh2KQYO8j6JnZ2cjNzcX99xzT8NnISEhGDhwIJKSkjTbq6ysRHFxsdd/MuPr862qqaOKt5A1PkOLEydOAOAXY0GTQ8WfEdFPxRZ2PNsMLGNHlj7ozVdSeyjI0ifZYI0RUnJ+1da5qW1h9FxecWMin8FrPJG2k3qywLAvb93LnoCXBelfmhISEpCWloYJEyY0+i43t/6oYYcOHbw+79ChQ8N3akyYMAHh4eEN/3Xq1AkAcPz4cUyaNAmVlZUNQX5xcXE4e/Ys5s+fj5SUFPzwww9YsWIFMjMz8fHHH6O4uNjr2vz8fMyaNQv79+/H6tWrsW7dOqSlpeHTTz/FhQsXvK4tKyvDlClTcPjwYSxbtgxbtmxBUlISFi5ciNOnTyMuLg4bMnLQ9Q9P4ZFPEzHi5X/hz/9ejasefgMPvzcfz05ahGGvxKPXG4vwj9fGoqKiwqv93NxcvDzu37j5xU/w0NuzMPKDT/Cn8Qm49sEXsXzPYa9rCwsLMXPmTBw4cACrVq3C+vXrkZqairlz5+LcuXNe15aXl2PKlCk4evQovv76a2zduhWJiYlYtGgRTp06hY8++gh1dXWIi4tDXV0dPvroI5w6dQqLFi1CYmIitm7diq+//hpHjx7FlClTUF5e7tV+cXEx5s6di9TUVNSd+h+eiDqHsPKzKE5dg7qKSyhMSkBkeHMMKN2JOzq1xIwZM5CRkYGVK1diw4YNSElJwbx585Cbm4u4uDicL6lAYVIC3DVVKNq7HNX5P6M0cwcqTu1HxZmfcCljK2qKzuOT6f9GbW2tlyynT5/GwoULkZSUhC1btmDZsmU4fPgwpkyZgrKyMq9rL1y4gE8//RRpaWlYt24dVq9ejf3792PWrFnIz89v1MePP/4YmZmZWLFiBX744QekpKRg/vz5OHv2rNe1lZWVmDRpErKysrB06VJs374du3btwuLFi3HixAlMnDgRNTU1mDk1HgBQmJSAmuKLuLR/Eyp/PoTy7P+h9NBuVOedRnHKKpw8l+fV/sWLFzFnzhykp6dj7dq1WLNmDdLT0zF79myUlpZ6XVtSUoLp06cjMzMTy5cvx8aNG7F3714s+XIhakryUJiU0CCDu7YGRcnforowF5d+2oaK0xnYtn07vvrqKxw/fhzx8fGorq5uNNcWLFiAvXv3YuPGjVi+fDkyMzMxffp0lJSUeF2bl5eH2bNnIz09HWvWrMHatWuRnp6OOXPm4OLFi/jvqvmY/fitqEn9FnVV5ShOWYXqvNMIPrUXI68uQetLJ/H555/jzJkz3uOkrhZFyd+gpuhcg9wVp/ajNHMHqgtyMGfGVGFrRMLODHT9w1MYPi8ZT770Fv76yXZcff/z+GzNLixbtgwHDhxotEYo7dbW1mLChAk4efIkvvzyS+zevRtbtm2tlzv/ZxTtXQ53TZWXjWovFaAkfQMSk5OxYcMGrFy5EhkZGZgxYwaKioqkXSPOnTvXsEasX78eq1atwoEDBzBz5kwUFhZ6XVtUVKS6RpzesxYfDfkNalK//XXMGqwRRXuW4YM19TZKP1PEtEacTFyN125tipCcdJQd3Yuq89koSVuLdsFVGFC6E0NiokyvEc0vHsaoG6rR5Phu1BSdQ1HyN3DX1aIm9VvMfvxW/HfVfJw5cwaff/45kpOTsWnTJnzzzTc4dOgQpk2bhkuXLqmuEcn/TUXZsX0oO7YXVeeOo+R/61FbXuw1puoqy/DZnJmN1ogFCxY0yN0w11TWiIrTGbj00zZUF+ZizsdT8PvftsOA0p2IDG9ev7aV5OHS/o0ILc7GP64uRtlRY1ckT6SOaTp9+jRuu+02bNy4ETfddBMA4M4778TNN9+M6dOnIykpCbGxsTh79iyion71oY4cORKnT5/Ghg0bVNutrKxEZeWvEffFxcXo1KmTdDFNRnE4Clq+ZNnjM7RIS0vDrbfe6vWZmRgLHnEE/oCIfqrZwqpn84J07NjdB5L52r4qh8geCnb3yR+orXMTx08quABU5h7Dgtf/wryGWhE3xvsZvMYTSztafbE6JlnqjOCpqak4f/48evXq1fBZbW0tdu7ciZkzZ+Lw4cMA6necPF+azp8/32j3yZOQkBCEhPD1g/IenCy1hjzrCImuhWQGI12lpKTg1ltv5aZTO8vYWBlQy7OfitxfrtiEJ8K7GMrN+mwj/fDQH2mZBrvHCcl8/Vvro1QvTU4JJ2OaBLnwxB1dEbfuIFWFparco6bWUDMleEjnBe8yP7zGU5/oCESGNUdusX6+Ks92rC5ZpIXUL02///3vceDAAa/P/v73v+P666/HmDFjcPXVVyMyMhKbNm3CLbfcAgCoqqrCjh07EB8fb5mcIo7ostQa8qwjJLqOFCskuvrjH//IVad2lbGx+ug2r356yl1b1gnr5yUbys3ybCP9+Kv+WCCdr11+fxdVu04JJzJSTxZQJ41scV0/addQUfAaT5syc1FRU6v6nezjUuqYplatWiEmJsbrv9DQULRt2xYxMTFwuVwYPXo0xo8f3+CLHzFiBFq2bIlHH33UEhnNpuLXgrXWkHKflXWkSCHV1esf/Ju7Tq0uZSJqXBhhtp++cpekf08sN82zjfQzYX2mX+qPFdJ5+NUX86nbdko4GcOyDipzQ8Y1VCS81hjPHE+etG4ZLPW4lHqniYQ333wT5eXleOGFFxqSW27cuJE4R5MZRLrAWGsNKfdZXUfKCFJd3X19BxzpeA/cKn91m9XpkJgoDO4eaUkcgZ2uUdZ+qsndut8jVHKTPJvkuPG8Xdl+pz8zkM7Df746hql9O/rkT7Csg8rckG0NtSLkguca40tI0yAM7h7JV2CO+N1L0/bt273+7XK5MG7cOIwbN85yWUS6wIx8x774+oBli2Ug1dWXe07g4PcLGxYkretYt8St8IvL4Bpl6aea3IVJCV4vTiRyGz2bxPWslxVDVv2ZgXS+blryCe4YO5bpGbLEhLAiskYd7XoL1M+Nawb/Tbo11Cp3Ia81xpfc4krLXZ40+N1Lk0yIdIHp+Y59UfMByxbLQKqDk/llCOv9ELf27EBG1ygJavKo2cKs3Lz6LZv+zEA6XwdcfYcN0tmPVhzPsJuisPrHHNPxPTTrrUJY74fw4M0dpVtDZZ4XgdAHqWOaZEe0C0zLd+w7R7V8yTLFMpDqoEtES1z633pu7dmBbK5RUtTkUbOFWbl59Vs2/ZmFZL7Onj3bJunsQyuOJ6eoAp/uzOYW36Olfy0u/W+9pW6kExdLia6TeV7469roibPTZAIrXGBqvmPfWkN629GyxDKQ6uqJO7pixs2/QxHU/9rzhyPSsrlGSVGTu8U1fRq+5yU3iSskyAW43f47Blgxmq/333+/zRJaC03qFQUz8T2K/pOz8jBqSZpu4dvON//OsjFYW+fG0n2nDK+jLY9iNf66Nnri7DSZwIqU+Mpz1GoN3X9jRwDA2v1ndcujyFBHilRXzZoG4b6OlYbXWdUHlhI0RiUa3ADGDr1BuiBcNbmrzmd7/ZvXeNYbCy4AI38Xrfm9WTlkLyukN19//PFH6eXnCW3qFQUlvmfapiPUOmoS5EJst3aY+KeeDePRE+Wz+zpWWjaH92XnI7e40vC6R3p3lm5d8cSq30yRODtNJlG2dH397ZGC82bYmauDlSExUXhmQHT9ySiPNczlqv+RVOT+/S3XYkCH7pbr1BczOtYaFwofrjuIoCCXdLbylTuoRf0pVN66J5k3t3Ruw30M+OO88SSrGOgfv9Vv5afFbGzLzG3HMHPbMSYdGY3R4HPWuZBI9dC1XUvBkpjHrt9MXkhdRsUqeKRhtzLzs7+WR9ErC+PCr3InJSWhX79+luqUVFZaHa/fn4MXlqQ1+lx2Wym637lrNwb8rr8w3VuREVzBX+eNwoaMHPx94lcI+c0NXp/7i/wskJbbMMKMjrTGoLJOWUEglsPhNbedMip+iufxS5bBQHqPTLk6fOVizc2joMh95MgR9OvXz7Yj0mZ07KmHdqEh+GBtpuoz7C5lY4Si+8O7CoTawMjGvMaArPOGFEX+6oKfG700+eY5U+Id24WGAC7g4qVKph8lO/9oUWBJBaCGGRtrjUFlnbKCQIgF8kXRqzLO1u4/6xf5w5yXJs6wbP/T3CNbrg6ATH4auX//+9+LFlkXVh2r6UEPu0rZ0GC3LXgh47yhQZG/eZebVL9X5O87YQvyS6tUr6FxUcnixmRJBaAFbxtbOTdkSyHDC1nGGQ1OIDhHWFLc094jW54LUvlp5P7iiy+4y0kDi4619MDzeXZgty14Idu8oUWR61LGFt3rtF6YAPKj+DKU6vBEKxVAVHhzPDsgGlGEKQIUeNnY6rkhUwoZHsg2zkhxdpo4wbL9z3KPTHkuaOSnkfvdd9/lKSY1tDpmORbN8jw7sNsWvJBp3rCgyKWVKZ8EEheVrG5MvVQMbw65Afuy85F47AJmbssybIuXje2YG7KkkDGLrOOMBGeniRM02/9m7lF821rDyAX1XB0ijinTyE8jd1xcnGnZzECrY9Zj0Vq2kgm7bcELmeaNEWrPVOQvSkow1bbamuIJy5pkFZ6pGPpER2Bfdj6+S/+5YX15ZfBvmWysh5797ZobMqSQIUVLfzKPMyOcnSZOsGz/s9zD4tsW5TemkZ9G7rfffptZJh7Q6phlu99f4hDstgUvZJo3eug9870HuuO5gj+bju0BtMesP7gxjXTEK+7HyP6BMjdEoae/ypo6ojZkdJc7O02cYNn+Z3UZ0Pi2RfqNaeUnlXvSpEnMMvGCRscs2/3+Eocggy14Icu80cLomQBwV1VyI/kjQoOpn6U1ZmV3Y5LoiEfcD4n9A2lu8MZIf/5cEsbJ0wR+eZr6x281PBK6e8zdXjFNtPf4PtPomL9vIjya9kX0mUTukydPokuXLtTyiIDk2DWJHjqEhWDKX25mPv5tFzLZghd2zxstmUie+dUj16BLly6NyioNnLyN6Fg+yZpiZk0SCY1dADDH/dDY4urorgw9CWxI9NchLASAC+eKzY8zq/M0OTtNnCApnXFfTH0An+LXNZtS3si3LdpvzCq/kdw7d+5kkocE2hiVJkEu9ImOQPtWzXG+pMLLfp7XGOlh3LAeiL22nV/EIXgi0hZ2Yfe8UYP0mQuXf69aVklv7VEgXVNkLXNBqqNpm440xDmxzDcaW7ASyKVwSPSXW1yJ4X06A5BvnBnhxDRxRCs9fJALqHMD8xNPYH7iCS+/OGlpERasiE8QkRI/OjqaWR49RObQ8vfSAFqIsoXM2BHXQ9pWi7aRqp8ble0ByMeirGOZVEdmSqfQPEfLFkb4Y24iGmhKvsg4zoxwXpo443kkdFNmLhYknoDvHxGKX3f247cCAObuzG60RVnnrv/8ls5tmAePVfEJvI/B1tTUmJJHDa0SGp628NUz7T2BchzYExG2kB074npI2wprpu0c8B1/ZjKCyziWafWtN7d5PEfPFlqwrEP+Bs38ueOattKNMyOclyYBKC6dV5elq36v5KEYt/onAC6i0iIsg8jK1Ps8S57k5uZyaUfBqhxaMpSd4I1iCxn6ZpUMdpSsIH1mG9d53XZ4zkO7yhhpQVtShTbfjzK+covKERHaDAWlVaZsoda+v+YmooHETp6pH2QbZ0Y4L02CIPXr6mE27b+/pt7v1asX1/ZYSmjQ3hOoW+69evWSom9WymDHvCF95jUhnbk909/w1BEppGsoaQkkM7bw91I+pJDYadhNUdL97pDiBIILwo54BzX8MfX+qlWruLYnOoeWv5YDICF+ziLb+2aHfu2YNyTP5D03/A0lBpQWvflMUwLJjC38IQcWL4zsNHdntt+ui85OkyDsiHfQQsb4BD1efPFFru2JzKHVLjQEr3/7Y0BuudfWuXEgvB/cZY0T0VnVNztdGnbMG6Nn8p4b/kZtnRurf6T/sdWazyQlkCJCgzH2/h6IDDNnC9lzYPGExE7+ui46O02CICnbEBkWgsgwvmn/1fCMBWkXGoI6txtr95+lPupq1THZf//731zbYymhQXoPXPDbcgBG7MvOx+HNSzS/bzh6nZgtbExYffzfd4wDsLxkhV5KBN5zw99gKVkUERqMXl3aMLeXX1qNyLDmurYgWRtZS/n4IzzmraxpGZydJkGQxCiMG9YDAITGThj56knjQqyMKeFdCJMlRoX0nouX9OPSFPxxy/18SQVRgdgP1x1s+P+8x4SVLg0ZYreMCJQCyqyw2Dm/tBoDJ29TtaOZ8aXYgnTc+GuMKQtm563Mc9HZaRIISYyCyNgJEl89SVyI1TElIgphsuiZ5J5A3nJv36o5CikLxPIeE1bp11/i0gKlgDIrrHbWsqOZ8RUXF0c9bvwxxpQFM3qVfS46ZVQgPg07aSkOnrETRqnsPdFLWW9HSYnc3FxERrIljjOCRc9698hcdsIstXVu9Hn3W+TXtaQqEMuzz1bo144xzorIueEPGI0HPdTsaGZ8/Xw2B//vC+1dfKN11V9iTFkwU2KLdi46ZVQCEKOyDaTX0EDj+9fzL9tRUmLNmjXc2vLFU899oiOwLzsf36X/jMSjF5F47KKq/1zPNmbLTsjqtwfq+9a/2UkA+uU5fNEbEyxlbESX9WAZ43bZjWRuyDymzGJUrkoPNTuaGV8zPk8gLutCs6Zo4WvXqpo6ae3Mqlc7fm9ocWKaAhQW37/aPXYck7355pu5taUFr1gv4NfjtbSlcGT22ys8PnQg7m3xG6IcNr74jgnW/oou67E5kyyZqtIfO+1mNDf8YUyZRWs8tG4RjMLyasP7fccl6/hq1/U64ICxvGbLugDqdlXKcynIZmcWvfpDWgbnpSlAYfH9q91jR8xOXl4et7bU0Cpl4AlNWYMNGTnUpXD8pZxCXl4ehgzp7XUM/mJJpVfwtxaeY8Jsf0Ud/9+QkYP5iSeIrm3fqrntdtObG3bLZiVq46HO7cZjn+01vFdtrWIZX00qSwGEEsvMagctu+qV55LFzrR69YcYUeelKUChKTmgVxbCjpIS5eXl3NryhSQvC0CeA4ikPR4lWuxCsYVnqYPaOjc+251NPCZ49Zd3uQVFLiOU/vTq0gYDJ2+z1W5ac8OfxhQvfMdDbZ3b1FpFO746hzcVWtYFIF+vWNu3Ahq92vF7Q4sT0xSgkPr+jfz2Ru24de5lpVu3bqbu14vp4BXrRdqeWhs099gdn6JmC9p4BbvjFLR0SDoWlDGeerKAqB96eavM2lNrbtitYxnwHJe+iDjS/9vfXkcdX6UX56QGbV4qFjvbvcZ4Qrq2AGiQed9xa8e0s9MUwGj5lD0hiQtR2nlrxQEUlnnHDLRuGcxVZgDYtm0bYmJimO41iungFetF8p3WdaT3bMrMxavL0m2NT9GyBU28gp1xCnrjobKmcaZzNZ6K7YohMVH4Lv1nouu18lbxiDfSsoc/xIJYRXjLYNV1asIfe3KdN9u2bcOLL75ouMaqQRrnxGov0vtkjIEzWlsAeJ2wq6sss1Q+56UpwPH1KbcLDQFcwMVLldRxIUVljYMsi8qqufvR//a3vzHdRxLTwSvWi+Q7retI71mgEmtjddyCni1I4xXsilMwGg+jB5HtaA7uHsksn/KsZwZEq8a90dpTyx7+EAsiGr1YxQKVtcssii0850HisQuYuS2LuA0j+7Pai+Q+mWPgtNaWTZm5hvGoonHcczZjxdao5/HW2G7tEHttO+qjrnrxEkC9H92M7J56eOP9eOq2SGXs1aWNbikDT0jKGogo0QLUn4xRg5e+SZkxY4bu9yRHp+0oH0EyHpbuO0VVxojEbmrPcgP1Jyt1ZCG1p5Y9LqcSHWoYxf4osT4854ynLZR58Mrg3yIyjPxFx8j+LGOOxM40azqP3yiWNnzXFkUmuxMrOC9NNrIhIwf947di+LxkvJyQjuHzktE/fqvtGU99ER0v4auHjc1iqfVAKmPqyQIusV4KLPlISO7RW1OsjE/hUbbDilxLvpCMh9ziSgzv05lYLqUfLIs2L3tq2cMOHcuEHTFdarbYlJmLippaqnb0ZNOL09Likd6dDe1Mqq+ZW4+Z/o3i9TvHUndQBM5Lk03InireE5HxEmp6KExKoNYDjYxapQw8oSlrwLtEy9OxXYn7IhpeZTusLh9Bqpuu7VpKU9aCRGY9e1wuJTrUsCOmy9cWylrmG09FipZsil1btyCLH+3ariXzs3yZtvmIqd8onr9zssTjOTFNNuBvx4NFxUto6SHs1vup9UArI89YL7X2SNrQumdfdj5R7iAr4lP++c9/cmtLVK4lNWjGwx3XtCWSizRFASskMhvZw0ody4QdMV2etqBJDaCFnmxDYqLQqnkwcx4qlmu04JGOheV3TpZ4POelyQZotpJ55qVhRVTuDC09XPppG8J6PUClBxYZeef9YWlP7R6RuUpoa14tXryY64sTb51rQatDErnMuAdcLkCryqeRPT1ttnPlYkx6701L81nZAe04tSO/j+fcMDU20DivmVrf+17dllsfafL4qUGyNvP4nfPURbvQEESGNce5YjaZeeG8NNmAvx0PVvzqzy9OgwvwGrBm4iW0+te8c0+i66yQ0Q5E9YXlePHAgQPphJcEETo0Mx/1Xpj0ZPG1WdWFK5AUv1Wqchm8YRmndsx/z7nBOjZ8ZTPqO68+GumL9KWEdzoWT9R00bplcMMulV0vTk5Mkw344/FgEfESWv2rKcghus4KGe2Cd19YYwuyssiPT8sGbx2KmI96sqjZrKYgR8q4R16YiYGxev57zg3SsRER2kxTNpK+8+yjXluvEKbj4J2ORUFLF0ram3AB+QFJcXaabMAfUsWrwTteQksPrib1w5JFD4EU08GrL2ZiC5o1a6Zyl//AczyQzNsOYSGY8pebcb64Ah+uO4j80irN9iJCg7HjjbvQrGnjv121bOZq0lTKuEce8IiBsXL+e84N0jV9xxt3IfVkQSPZaPrOs49abQFAQsppU79RrL9zJLpo3jQIX/3jdly8VIlQVGPwdKLucsF5abIYxUd7b0wkFiSesGQrmTY+QA+e8RJaW8RBoW1U9UDaDzUZeerAFxFt+7Z5/40dmds0E1vQoUMHpmfKBK8xS+ICGjesB2KvbYc9WXm6L0wAkF9ajdSTBaqyadksKLQNAPniHnnAK9bTqpguz7lB6h5s1jSIyt4KniV6RsRGc1+H1doy6wpkdZmSpgsJcrnw4M1Xobi4WKd3/HFemixEzUfrGyBKUtbE7DPtTpPviVrK/KrcY+j62xgvGc30Q6QORLTNu00zsQWpqano1asX9TMDFdLyMWbjObQ+r8o9hpDIaw2v80f8LdbTd27QlBbyhbRPH647iM92Z1uyfpvpj2cbzwyIrk/u6vE753IBI38XrdqG7OPAeWmyCK2U9UrSu6dju2JQ90iuOyAyp8n3xHeLuOnDV2NI7+sb9GCmHyJ1IKJtEW2euFhKdJ1abMGDDz5I9azLARL3iNm4Ra3PW3a7neg6f8TfYj3V5gar64ymT1au32ZdgRsyclTLB9W5gbk7s3FL5zaN+iD7OHACwS2AJMX/+oxc7i4jPb+wG8C/Vh5AFWHRUtF4psz/36blXi451hIuIsu/iGhbVJtL950yvE6r9MK8efOIn3U5YVQ+hrWsiVJuIreoHBGhzRrdX/LjD7r3+zMylYIxKvtRW+fG2Pj/cCt/RVMuhcfaRVPShKRUktZzjHJXqfVBpnGghrPTZAF25GUiyRuSX1qNvhO2YPzDMVLsOCl4licwozuRehfRtqg2c4srDa/TKr3Ao4zK5QhLPIeaW9aX1v0e8bsUGqTIkjbEyD3e8H2zWGxMSPf6HgCTa12v72qwrl1WhmuwrmeyjAMtnJ0mC7DDR0vaVn5plXTHlz3LE5jRnUi9i2jbzja1Si/wKqNyOUJzPFzriLUvhUkJfplCgxS704YYHfufsD6z4fvCpASv759bnIbnTJQMISnv5AvNWmB16S4z65nd40APZ6fJAuzw0dK2JdPx5ddee63h/5vRnUi9i2hbxjY9beFAD0lMCIkbIyI0GGPv74E2T9yE391wlRTzVBR2pQ0hcY/P2/VrfE5Y74cbfa8GTYoIpe8LE7Px4bqDhjKTzm87SneZXXtkTR/j7DRZgB0+WlofOa8K4CT+cqNrPvnkk4b/b0Z3IvUuom0Z2/S0hQMbRjEhpK70yLDmSN3wte0/GlbAGkdjBhI7eC5Vl/63jrhtmjW2SZALI2Kjua4FNK4y2pgnLXisZ3aMAyOclyYLUHy0ABoNIFE+Ws9nkmLWPbghIwf947di+LxkvJyQjuHzktE/fqvXti/JNcOGDVPtB63uROpdRNsytulpCwcx0LgxHHuIg3b9a3Ht7cYXMT6D91pA+txNmbmG6zMpdvzuWYHz0mQRdvholWdGhJKlnDfjHiTxl5P61NPS0lT7waI7kXoX0bZsbfrawoE/NG4Mxx7ioF3/qs7RlxiieQbPtYD0uQsST3CNeZI5NokVl9utVUry8qG4uBjh4eEoKipCWFiY0GeJzEytRVVNHfpO2KKZoVhJZ797zN1MstTWudE/fqvm9q9SXgJwIbdY+xpFhh3bt+Huu+9WfQ6r7vw9I7hdbW7dulXVFg78UOaPUbkJvbnhYB4jOwBA0C/JiN0Ayk/+iBZdbiJq28way2MtIO2blieOx2+EqPXXyt9vwAkEtxyrUvx70qxpEMY/HIPnF9f/lcr7CCdp2ns9PH3qISEhqtfQ6o50oqpdp/SLZJKLsClLm0b9JWnTt42mwf5de84foDli7Tk3RP0Q2fGHnQyQ2GHk76Ixd2c2XABcTYK9vner/H/Pe82EAphdX4z65ob2CxNgPi2OHb97onBemi4TeKTE14J3qoSirCzExsaaaoc0H4nada1/qaBd+EtFba17ZYJH/hW1Nppm7cTMNtdI2+9AgXR+Zv0yN0Tl25G97JJoSOxwS+c2eH9NJo5m5AC/6e71PdA4TxPv0lis6PXtvphIzE88YdiGLCVs7MRxz8H67T07EfFX5J6sPAyfl8xFvlcGXYeHrwtB586dmdvQKkWi9FLxpWtdp4bvvTJB2l+WNmqLz6NpWHsp+x2IGM3PU6dOIbM42LS91eAxjgIFIzvU1rmxOnE/glq1a/S97Dt1avLty84nWsOXjuwr3Y6R455zYIZksorYJlWOlurFZHQIC4HbDZwr0XfTJaScQnHyHoxlzERNmo/k7us7GObGUbt33Oqf0Kp5MC5eqpRiQeSRf0WvjUsZ29C631+lyuMVyBjNzy8WLcL6Jndwz7djRx4fmTGyQ5MgFzJ2rMGg4c/jfEm920pZC3iusSJewNTkI1nDIzmlxZH9pdII56UpQLBzW50kFmDcsB44nFuCaZuP6raVU1SBu59+llkW0nwkX+5pfErECCU267HP9jZ8ZrfrgkfpFb02wu74s5AyPw5s3P3XZzF//j7N71ltZUepJ39mQ0YO1rlux3yP3Rnea4GVa7pVpUsCwf3rpBwIAKxOj68GydHSru1Cidr6ZPpkZjlIfe4n88uYn+GJlTpWg0fpFb3vivYso36WgzhI5watrewo9eSvKOvtoR8WeX3Ocy2wY00XnR5Aht8pHjg7TX6OTNvqRmnvSXOFvDD6DWYZSJ/RJUK91hotdrsueJRe0fsu/I6/UD/LQRwvjH4DiTo7TQq0trKj1JM/4rnees4NgN9aYOeaLqp0iUy/U2Zxdpr8HJptdR4YpdjXS3vfJzoCkWHai66SVn/r158yy0eauv+JO7oSl5kxgreOaeBRqkCvjeI93wgp88MTXmUfZEGvP1u//lRIaSA7Sj1ZDY9x4rneFu/5ptH3JGuBkRxWr+m+iChdYnefeOLsNPk5Vm6rm/VHb8rMRUVNrep3nn7z7mHdmGUk9c03axqkeR0rdrgueMQi6LVxRcxdRG3YRSDESHhi1J8n//Y39P7l9BzP2BOrYlrsgtc48Zzjob/MDaPraOUIRFdpIPXJ2Wnyc6zaVjfrj1bu98x95EnrlsENfvPt27ebkpXUN691XeuWwQ25mmiwy3XBIxZBq42QC4ekPWoeKDESCiT92b59u7DYk0AseQHwHSeec7zi1AGi62jlCERXaSD1ydlp8nOsOCpq1h+td79CSNMgDO4eCQC45pprmGVVIPXNa10H/JoRvF1oCF775kecKxZ/HJcVHrEIam1Unw3HAAl/LAMpRgIg7098/6sBiIs9EdWuXfAeJ57rbdPWjeeF1lpAI4eVx/+tIpD65Lw0+TlWbKuzHkdW8nEkHrtgeLw/t7iy4f7KSv1cTqSQ5kvRus7zs/+7vzteWNK4WKpMrgte5RY829h6Ur1eod0E2hF50v78eLIYA35X/5mo0hSBVPKC9zjxXG9R671rrrcW0MoRaK5SEb9Tyu/LiZwLPEU1RGr33IQJE9C7d2+0atUK7du3x0MPPYTDhw97XeN2uzFu3Dh07NgRLVq0wJ133omffvrJJontQfS2Oos/ekNGDvrHb8XwecmYuY2sGrhy/4UL1k4CIzZk5ODDdZmq3/m768II2WyhEEgxEgC5nKd+zhUsSWAhYpwo620reKct0VsLaOUIRFcpzz55/r6MWa7tJhWB1DtNO3bswKhRo9C7d2/U1NTgnXfewT333IPMzEyEhtbn/Jk0aRKmTp2KhQsX4rrrrkNcXBwGDx6Mw4cPo1WrVjb3wDpEbqvT+qNpypOo3X/rrbdS3ikOo76MHXqDXy5gpMhkC08CKUYCIJez9229BEsSWIgaJ0NiorBm3N9Q0LQt0XrLIkeguUoBPn1i/X3hhdQvTRs2bPD69+eff4727dsjNTUVAwYMgNvtxvTp0/HOO+/gj3/8IwDgiy++QIcOHbBkyRI8+yx7Zml/RNS2Oo0/miR+SQ3P48yrV6/Ga6+9ZlZs0xj1xQXgw3UH8YeYKMsXMt6lCLTak8UWvtCOSTO6sqLsg1F/AKB1i2Ds3LwBf7qrt+0/nLKVwtCSR0lzklusvtNjJpZm3do1xHODxL4RocHo1aWN12eB5CpVMNMn1t8Xnkj90uRLUVERACAion6AZ2dnIzc3F/fcc0/DNSEhIRg4cCCSkpI0X5oqKyu94maKi4sFSu3/NAlyYdhNUfh0Z7bmNYo/ek9WHnV5EgB4pHfnhkX3hRdeYJaVJ7LGzfA+Zq/Xniy28IU0RmJTZq4pXVmV0kCvPwqF5dVYXR2D1PittqZUkC3Ng548AIjSnLC88NHMDRL75pdWY+DkbX6bLsMKjNZkK5A6pskTt9uNV199Ff3790dMTAwAIDe33r/foUMHr2s7dOjQ8J0aEyZMQHh4eMN/nTp1AgAcP34ckyZNQmVlJeLi4gAAcXFxOHv2LObPn4+UlBT88MMPWLFiBTIzM/Hxxx+juLjY69r8/HzMmjUL+/fvx+rVq7Fu3TqkpaXh008/xYULF7yuLSsrw5QpU3D48GEsW7YMW7ZsQVJSEhYuXIjTp097XVtbW4sJEybg5MmT+PLLL7F7925s374dCQkJOHr0KCZPnoyKigqve3JzczFv3jykpKRgw4YNWLlyJTIyMjBjxgwUFRV5XVtYWIiZM2fiwIEDWLVqFdavX4/U1FTMnTsXS7fvx6SJEwAAhUkJqKuuRPG+FajO/xmlB3fi9+Hn0KroOBYtWoSfjmShKOlruN11KExKgNtdh6Kkr1FTfB6XMrag4kwmyk/+iNKDO1Gd/zOK961AXXUl9q2c1yDL+++/j7lz5yI1NRXr16/HqlWrcODAAcycOROFhYVechcVFWHGjBnIyMjAypUrsWHDBqSkpGDevHnIzc31uraiogKTJ0/G0aNHkZCQgO3bt2P37t348ssvcfLkSUyYMAG1tbUN98ycGo+a4gu4dGAzKs4cRPmJdJQe3IXqvDO/yF2BwqQEnC+p1/uFCxfw6aefIi0tDevWrcPq1auxf/9+zJo1C/n5+V6yFBcX4+OPP0ZmZiZWrFiBH374ASkpKZg/fz7Onj3rdW1lZSUmTZqErKwsvDXpE4wYvxDZGf/FpZ+2oaboHIqSv0FOQSmGv/AmNmTkIC4uDmfOnMHnn3+O5ORkbNq0Cd988w0OHTqEadOm4dKlSw3tP/niGDwzdxuObF+BqnPHUXZsH8qO7cXJI5l47LU4jHhxjJcsJSUlmD59OjIzM7F8+XJs3LgRe/fuxYIFCxrJXV1djfj4eBw/fhxfffUVdu7ciZ07d+Krr77C8ePHER8fj+rq6kZzbcGCBdi7dy82btyI5cuXIzMzE9OnT0dJSYnXtb2jmmFo8AG0Kj2DsmN7UXZsH6rOHYfr0CZMHNoFSz+djucXp+Hg9wtRV1WO4pRVqM47jay9mzHiw/mY9tVafP755zhz5oxXuzU1NZg4cSK++GEfnnh7CrIz/ouKU/tRmrkD1QU5OLxxMZ5buBdPvjiG6xpxMnE1JtzXBTWp33rMtYr6uZZ3BqUHdyF/4yc48dP/8PiYSfhy838tXyNe+NdHeHraCmSlbEN5Vgoqc4+hJH0Dfj6b4zX+ysvLMWXKFBw9ehRff/01tm7disTERCxatAinTp3CRx99hLq6OsTFxaGurg4fffQRTp06hUWLFiExMRFbt27F119/jaNHj2LKlCkoLy/3kuXcuXOYO3cuZnz9A558/1NkpWxD1YUTKE5dg7qKSzj0/UI8tzgNj7zwJvILClGcugZVF06g7EgSyo+nojLnCGozN+GjIb/Bf1fNZ1ojpkyZgri4OJw+fRoLFy5EUlIStmzZgmXLluHw4cOYMmUKysrKGuT+76r5mHBfF7gObUZl7jGUZaWg7OheVJ3PRknaWtSWl+DQ9wvx/OI0PPniGOY1YunSpdi+fTt27dqFxYsX48SJE5g4cSJqamq87iFdI+Li4nDx4kXMmTMH6enpWLt2LdasWYP09HTMnj0beXl5lq0RM6fGo6YkD5f2b0Tl2cMoz05D6dFf6/9ZgcvtdvtF+txRo0Zh3bp12L17N37zm98AAJKSkhAbG4uzZ88iKurXN/ORI0fi9OnTjdx7Cmo7TZ06dUJRURHCwsLEdsTPqK1zo3/8Vt23+6jw5tg95u6Gnabh8+gH8dKRfaXbhibti1WyG9lCcTUotrC6PbtQc80AMNU3O3VTW+dGclYeRi1JQ2G5el4zO2wj23ghWZv0iAwLQeJbv7d8bFfV1KHvhC3IL1U/meov884O1NbkusoynJ7+F8t+v/1ip+nFF1/E6tWrsW3btoYXJgCIjKzP6+O7q3T+/PlGu0+ehISEICwszOs/f8Oq0hEk26Ge6e+NyjH4olaeQfmrgje0OuNVWoKXrXiXIiBp7+D3C02VNrBinKqVfTCrK9L7k7PyuPevSZALQUEu1RemwqQEIvlpIbETrU5F296sq0ZJc8IK6zqVerJA84UJEFtSxN9LDtH+vohA6pgmt9uNF198EStXrsT27dsRHR3t9X10dDQiIyOxadMm3HLLLQCAqqoq7NixA/Hx8XaIbAlWxhTQHpUl8d0raMUUjBw5kk1YHVh0xiO3CE9b8T4+TXJdq5v+wHxs387YF7M6IL3fdzeIV/+0nt/qpj8QXUcDqZ1odGqF7Xn03UwbrOuUXekyZItFY4Hm90UUUu80jRo1CosXL8aSJUvQqlUr5ObmIjc3F+Xl5QAAl8uF0aNHY/z48Q2++BEjRqBly5Z49NFHbZZeDFaXjmA9KquWj8P33UIrP8d3333HJqwGZnRmJrcIb1vxPj5Ncl3Z0b1Mx/btLnFiVgek9/vuBvHqn9bzy47uJbqOFBo7kT7rxMUyS2zPI52EmTZY1yk70mXYPR95orUmW4XUO02zZ88GANx5551en3/++ecYMWIEAODNN99EeXk5XnjhBRQUFOD222/Hxo0bAzJHkx2lI3p1aYMgF6C3ixvkQqOjsmr5OHp1aYPUkwWGx5R79eKXi4aHzlhyi4iwFe9SBCTtdby2O/VxbBlKnJjVFckRcTV49U/r+c0iryWSnwRaO5HotENYCJbuO2WJ7VltpMhqVn+s65TVJUVkmI+88VyTT+RcwKPTrXu21DtNbrdb9T/lhQmo320aN24ccnJyUFFRgR07djScrgskauvcWJiYzTWmhYTUkwW6L0xA/QtV6smCRp/7xpo0axrUKPZEjXPnzvEQHQC/OCC1uBkrnusrg3KM2vfpLMenSdr7c/dW1AspTTyQKMzqSu9+I0hsSxJb8kjvzo1+6OpKC2wpjwSQ6XR4n86aOZHU2jQDiTx635nVH+s6xXseG2FnfB4PtOaKsiYPvbGjpfJIvdPkUI+aL1oPnr5wO/zvVVX86p3ZFT8g6rnK1rTveIhkjE0waq/i2F6du9WhiQea+KeewuIpzOpK635StPRgFFuiN9/dtTXMtiaVT+86I51W1tRxfbYRRvIA4DZXfDGzTvGex3rYHZ9nBhnjsJyXJslhSRnP0xduh//9mmuu4daWXeU2RD6Xd3kFvfYOuOltQRMP9PziNKG1tMzqSrl/5tZjmLb5CNWz1fSgNZ+V2JJnBkRj7s5szfn+93tvx/in+RxFZx2jejrdQ7h7yHO+GdlYVCkSs+uUVWVSzMbn2VXrzmiu2CWX89IkMbQp43n7wgHr/e9Afc3Bnj17cmnLDvmteC7v8gpa7bHYgjbWRHQ8BQ9dJaScIr5Wy7ZGsSUAMG+X9guTC8CyNRsx/un7iWXRw8wY1dKpXfNNz8aiSpHwWKesKJNid3weCzRxWFYjdUyTLNiV24ImD4kIXzhgvf8dAB5//HFubdkhv9FzgfqJP3boDQ3PJR1jVo9FFlt49t0IkTlpeMFrHpK0o2dON4Daq/sb6op0jIiYGyTjXsR8swOe65RIRMfniUBETCgvnJcmAzZk5KB//FYMn5eMlxPSMXxeMvrHb7XkiCaN35/kCDwrZo7dszBz5kyu7Vktv9FzFT5cdxAbMnKIx5gdY5HVFkrfW7cIJrqed0wZT3jNQx59LE5bq9sO7RgRMTeUNsNbNrZ9a5XP/BXe65RItOws6/y0KxaVBL8poyKS4uJihIeHN0rDruVTVd7WRftUSct4jB16A0bERgv/6022yua02CX/+v05eGFJWqPP9ZKz+Y4xu8ciK4nHLuKxz4yDyWUso6PAax6ylhjy5ZVB1+HlQd0afW5mjPCeG/46XgMdXzvXud1Szk+aElY9rgxW/f0WhbPTpIGRT9UN4K3lB5B47KIwFwlpGQ8eL0wkW/q0x+5ZEVVGxSr5Pamtc+PDdZmq3+mNGuW799dkoqqmzjAW5v01mULGoVlb9L26reEYjgwLQZ3bbYnLkcW9yWse9omOQGRYCJvgv1CYlICl+04i8dhFrz6QxEvpjRGec8OMLP5U5oPXOmVln33tTDI/fUtFWSEvrxJWInACwTUgiT8oLK/GY5/tFXYEkkcZDxJkO9b54osvWv5MUZipj6X47b/cc4LYv8/7r0GztjAaw24AFTV1Xn/tihp7rOOc1zxsEuTC8D6dMW3zUeY+hPV6ALnFlY309UjvTraNEV9o4lE8ZZFtHTKCxzpld59px7ZV8lr128eCs9OkAY2vVGQqetHxODKm11+0aJHlzxQFD5/7yfwyy57lCw9baI1hJealsExMKRJPzI5zXvOwa7tQOsF9uJSxtdFnuUUVxC9iVsSAsMSjyLgOGWF2bsjSZ9KxbbW8dsWiGuHsNGlAk0dE9NFMUfk8ZE2vf9ddd1n2LNHwyEfTJaKlZc/yhZctfMdwu9AQvPbNjwCqG13Le+zxGuc85qFZGzXv3PiIu1053Mw+Q7lO1nXICDNzQ7Y+G41tu+S1KpcVDc5OkwZGPlVf/OHotC9WHOtk8X8fPcruvhCBGR8+7TjyRPHbP3FHV0v9+579XbsrjVvMgmc8RVCQy7JyGzzHudnYH5LxEOTSPhpeU3CW6nkKVsaA0MajyHS8nGaum1mnZOqzgt7YppGXd8yTHbGoejg7TRro+VT1ELH9LcqPLPpYJ6vcLVq0YHqeCMzqniSmR4/3HuiOZk2DLPPv+/a3/PgJfFe41bbSDjzmk0zHl0liNUb+rj4ruNr4cDU1DiS3OwaENh5FFvvQznUz65QsfSaFVI5Nmbl4dVm638SlseDsNOlglGdHDd7b3yL9yCJLfZiRu21bOY6e89K9UUyPFs8MiG5YaKzw76v1N6hFKyExC1aWt7GrlI4WRrZ8+77umutOUItWum2/Mug6KWJAaMarDPZhmetm1ikZ+kwDqRwLEhsfWpE5Lo0FZ6fJAMWnmpyV16igoSciygOI9iOLKnlgVu709HT07t2b6pm84a17mpgehdU/5uDNIb9mDRfp39fqb9W54wiJuo57zIKV5TbsKu2hh5EttcbLsfR6e2j14Z93X4t/3n2tFDEgpOPVbvuwznUz65TdfaaFpBRLkEs9o73McWksODtNBijJwC6WVuLvsdFwwbpyHGb93ka+Zb1yF2b6ZFbuBx54gPhZtP5z0utFxBzQxPRAo31R/n2t/ra89nYA/GMsrCxvY1cpHRK59Gzp+X1st3YYN6w7Wlx7u2EfzIwRO+JR7LYP61xXW6fsLGHDCmmOPiN5jUoA+VvMrxbOTpMOaj7u1irHpCMF+WzN+L1p/PPhLYMbHftu3TIYE/7Yk6lPZv31n332Gd59913D+2ljEGiuFx1zIFtMg9ZzSvb/gNb9HhEij+LC8bWJiPlk5bNEMSQmCne7DuBI+D1C+mBnziA77cM6F33XKVr9yTAmaWTWk/e+mEjMTzxh+DxZYrTM4Lw0aaBVBqCorBpuAK8M6oau7UKFbn+z+r21ZFd8y0alOQCgoEzbbUQrD+11pC9MJH1kvV50zIFsMQ1az/F8YdK7jhUrjxTLeHyZli9mxAspB0Q7P0Rgl31Y56LvCxOL/uwckywya8m7Lzuf6KVJlhgtMzjuORVIfNwJKadx/40dhR6BZEklT1rCQK80h9I2a2kOkmPVkWEhmqn5n3n1X7olFlamncG/VmYQl2lgKevAK42/1ta3HWUC9LbhteQpTEoQJo+ClUeKWZ8lS3mPuLi4Rn0AYEo2syVYeGLH8XLWuaiUUZGphA0pZmRWk5dWhzTzSZa5p+DsNKnAWgaANyyp5EllF1magyRdQ0VNHTZl5jbseHlu+bqDeqN/vPcxd7VtZFLZWezJI42/0da3lWUCjGTR6m94nz/aXrbAbuwudeHJ66+/zl02WdY7u2Cd64ot/FF/vGWm0SHNmJVp7ik4O00qyBRvQnvUnFQm0aU5FLm1jtUXlVXj+cVpmLA+s9FR3+LUNV7HVLWOA5PKzmpPM8f8SY4wW1UmgPQ4tZo8xalrbC9bYCeylLpQmDFjBnfZZFrv7IJlLiq28Ef9iZCZRIc0Y1a2uafg7DSpIFu8CY3fm1QmK0pzDO4eiXGrM6FVKgMA5u3KbrQT1bJb3wY36LjVPwFwUZWKUFBkN2NPlpgDmiPMomMaaI9T+8pTOfhK/Omu3pflDpNspS4A4KGHHuIum2zrnV3QzkXFFv6oP1Ey6+mQZszil/9Peq2VOC9NKpDkpIgIDUZucQX2ZOVZErin+JGNIM3/8cQdXfHZ7myheUL2ZecbHqtXc09X5R5DcMRVcAPILa6kfq6v7KQ66dWlDfZk5TWa7KS6V6Dd+tZr32zQL6trUvn/CQm70CSoD/HzRMAj8NmoDbXvZXS7pKamolu3blxl87ecQSKhmeuKLfxBf77ju1eXNsJk1tIhbWoH0mt7XKmfJJg3zkuTCiQxOfml1Xjl63QA9vtYPSH1LVtRmoN1O7rJFW2Yn6kmO4lOht0UhYGTt3HxnfPa+ubhzzcrS2Sk9X/JecJDB0ZtaH1/XwxZ3610uyj24Ole4RG/dzmi2EJ2/WmN72E3RamW6xElswiX4PmSCstfmpyYJg1oSqjY7WP1hdQ/Lzqmhnk7OqgJ8zO1ZNfr6zMD6mt98fKd89j65uXPNytL06b2/V3FQwdGbajF1CnfkxyhBqx1uyj24O1esSq+LpDwnBuy6k9v/M/dmY1nBkRbJjPNmJXZ5ensNOng6Z/NLSrHh+sOIr+0qtF1MqaJJ/XPi4ypIU2973Z7/6VTU3gO+E0PuAB0CAsB4MK5Yn1X6dj7eyAyTF92tb726tIGAydv4xq3Yna7nme8illZsrOz0b9/f91niICHDkiOVavF1Hl+rzY+Fexwuyj2EOESCoQ8VlbiOzdk0x/JHFr9Yw52vHEXUk8WCJeZdsySXlt6qYS7rHo4O00GKP7ZyPAWqi9MCqRp4q3MOUGa/0NUnhCj1Psu1Fd09/2+eaeYhn+PG9YD44bptzH+4Z54+BYy2X37mnqyQEi5FDMlEniWcDEry4ABAwyfQQrN2OehA6M2AP3SD8r3yg+MJ3a5XRR7GNnVDeCR3p2wdv9ZqnXGjpxBVqA19sysx2pzQ6YSNqRzKPVkgSU2p1mLZCoz44uz00QID3+sjDknRENSKuCWzm28vi/N3I7rh/zNSy+iyg2IOi5spkQCb5nMyLJkyRK8/fbbRM/Rg3bs89ABr1ijp2K74vuMXCnKr3jaQ8uuSpqPaZuPNnwW6OuMHnoxPat/zGFej3nNDT0ZzdhMxlQINGuRDGVm1HC53W5702tKQHFxMcLDw1FUVISwsDDVa/Zk5WH4vGTDtpaO7Kt6ckArZb3ynhzocQM0p5fatgzGHdde2eivCBHlI8za1QgWmUXJxCJLbW0tmjRhjzED2MY+Dx2QtkHyDOU0nd1uFzV7eNr1xMUyTN985LJdZ3zRKxWlBo2eeMwNQNxvg+i1zQw0a5HRtSS/3zxx3HOEmCl7waNMgWyp5Gmhqei+fdlczWrovLeRRZczYZFZlEwsskyYMIHqGb6wjn0eOiAp5xPkarz9r/YMXmPP7DxWs4ci2/03dkRCyikiXfv7ekKC3tjTgmQ9VnT3t5feNq07kSVsaOaQ1eOBZj7J5jJ23HOEmDlWajanyuXm1iMp2MsLGY8LyySTWVuwjn1FB88tTtO8z0gHJHoc+btoy45d85jHevYg1fXMrceQkHIq4NcTkpg2NfTWYy8bthqIxHnJpnQnMhcY6TqyKTP3svp9MYuz00QB67FSM75lWVPJi0QphGkVMh4XlkUms7awO67CSI9v39ddqlI2RujZg1SH0zYfuSzWE7Njyvd+XxsqxazN6E70/DAa/wAuu98Xszg7TZSwHCtlzTkhYxkHK3jyySctf6Zsx4VlkcmsLcyOfS1oxr6RHmUrZaOHnj3M5KwJxPXEbA4fz/vVbHhFzO8BmNOdFfmItMY3APSP33rZ/b6YxXlpYoC2rAZrThXSrdvkrDzEdmtHLI9I1IL2AFD9IG3ZsgUjRoywSOJfobUrK4qOcovKkV9ahYgrQlRzTIkIfCeVTXnmwR2b8dRTf6e6x1NO0WOfpgq73nUibc+zL3pzgyQvmh6+cujZ1Y6xSQurPtTGpJoNK07+iCt6DgLA7kYTkW9Lyza+cu3JypOuTJA/4Lw0WQBrjArpluyoJWmY+Keetvuf1WI2Wv9y/Lmw7NeivUb+8uuuu06soDaipiMFktIeIuMM1J55RWEJOvbJ0XymkZyix75MleO14NkXvblhpGvSF4fzJRW6dgXgFzEwJOWwfNEak2q2adrmqkaf0Y5H3vGLNOtGIM0xK3FimiyCJUaFdEu2sLzadv+zVsxGYVm11wsTYOwvLy8vFyannWjpSCGHoLSHKDtryXaxsETzmaRxOiLHvkyV47Xg2RejuaGn61cGdSOS48TFMk27Prc4Dc/5UQyMlj6iwpvj2QHRiCIck2q2cdc0LibOMh55xS/Sxs0F0hyzEmenyUJoYydot5ft8j/THu018pfn5eXxFtF2SHXkhn5pDxFxBnqy1ZbXlyjwfSZtnA7vsc/itrALnn0hmRt6MSwJKad15egQFoKl+/TTFqghcwyM3th7c8gNRGNSzYZ15b+W7zA7Hs3G1bHEzQXSHLMSZ6eJAJ45LGjzUyjb4UawlPvgBcvRXj15b7rpJk6SyQONjvSGlwg768nWrH206jNZypywjn3ZyijQwrMvpHNDTdckcgzv0xm5xWzuGM8YS9lyQHnqQ0lU+l36z9iXnY8+0RFEpaZ8ddesfbTXv8cOvaGhXaXfNL8dZvIRsc7HQJljVuLsNBlgd44kZev2reUHUFhebXi9Hf5nM89Uu3ft2rX47W9/a0Yk6eBtF57t6bVVnrUPwW1/AwDYlJnbEBBqRTyErGUUWODVF7Nzw0iOypo65rYVRi1J81qrZIp3MrOe++pOmRuRv5Rk+XDdQdPxnKywzsdAmmNW4bw06aCV3l7xEVuVL2dITBRaNQ/GY5/tNbzWDv+zmWeq3fv888+bEUdKeNuFZ3t6bV1xy30N/39B4gn0iY7AkJgoy+IhZEi7wAsefeExN/Tk2JNl3jXu+8ed1eulFjzWc0/dnX7wt+jUvg0KSqswaknjdn1jOWmfRYOZ+RhIc8wKHPecBiLT27PQ9+q2Qst9mIGkXIUvevJOnTqVm2yyoOiIBNLSHlbIVpyyyuvZypgXXX7GE9nKKJjBbF94zQ0tOVjmshF2rJe+8FzPFd0d2ZKAPtER+HAdXTwnzbNIMTsfA2mOicZ5adKAxUfsCe9aPnr+Z0Ueu/zPRrL5YuQvt7KMilUoOjLSjwv1pT2U/+/7HaCuNzPjTS92rnW/Rxr+v+eYtyIe4nKoj0aL6LlBYle174ywM+YSML+eq/Huu+9yj+dkJdDik2Se+85LkwZmS5/0j9+K4fOS8XJCOobPS0b/+K2mj+Mq/ufwX3zlnrRW+cxKtI7Ntm4Z3Eg2o6O0VpdRsQpFR1q7OlGMpT14jLchMVF4OrZro8+VUhGeKGNeZKkXUXPI37FibujZdc7jt2KO2jxvQbb+2JXzR0QMXlxcHPd4TjPIUnrJLLLPfZfb7ZbnFc4miouLER4ejqKiIoSFhQGoz5Y6fF6y4b1LR/b1ypaq5TdX3u95/JiIbN8sPDKCX7hwAVdeeaVVIlsOz4zgPMeD2pivLStCk5bhXp/5jnne2aFlH+N2YuXcoMkIXud2E8Vc+o4dq2Bdz/W4cOECjhUHEbVr9lk0+EO2di1Y5r7a77dInEBwDVhyWIiuFecPtei0ylHQLA4rVqzAs88+y1MsqSAt2WF0He/xoDbmy44kodXN9wLQztvCswQJTZ8AupfxQIBlbrD+iOrZ1fe72jq31Dl/ROQkWrFiBf4x8hnqUi2idUEzH3mWyjH7suYPv2+A89KkCUt6e971snwR3b4s9O7d224R/AIR9dl8x3yzyPos0lbFRZD2aebWY0hIOSV9KQ/e0M4Nq1Km8C4HwhsR8vXu3Zu6VIsMulDgWSqHxzjzl983J6ZJB1ofsejcNZdLraCcHDl817IjYjz4jvna0gIA1sVFbM7MJbpu2uYjflPKgyc0c4O2rIZZZI+p4S2fYgue8ZxWoTc2aEvl8Bpn/vL75uw0GUCTw0J07prLpVZQbW2t3SL4BaLGg+eYX7vmPO5/oK8lrq/aOjdWpv/MfL9MW/iiIJ0bdrk6ZM/5w1M+T1vola6RTRck6RfUUBs3PMeZv/y+OS9NBJD6iEXX8iFpv0NYCOrcbnyX/jO3SUoauMyLrl27cm/TLDIEV/rK0KtLG2HjTRnzoXf3wo0c4iNI2Jedj/xS46z3esiyhU8Lqe5I5wapqyM5Kw+x3doxSq0Ozxg3EfCSz9cWPOI5jeCxDrGkSVDwnV88XWr+UgvPeWniiGi/vlH7bgAVNXVep1jMxi+o+ap5ta3Frl27cOONN3Jt0wx2l9LRk2HYTVGYuzNbWBwJqS146Miq0jCyQaM7UnuQ9n/UkjRM/FNP291F/ojV6xSvdYjH3FDa4OlSkz0uTsGJaeKMaL++VvvhKnWOAHPxC1q+aoUcQbERw4cP59qeGayOC6GVYe7ObDwzIFrYeCOxBS8dWVUaRiZodUc6N0j7X1heHfBxYKKwcp3iuQ7xmBtKG7xdarLHxQHOTpMQRPv1fdtvFxqC1775EUBj1wZr/IKer9oX3rERn3zyiRRZwWU4Aksiw+ofc7DjjbuQerKA+3gzsgVPHRltzwNAZFgIABfOFcu9hU8Ci+5I5waJLj0J5DgwUVi1TlmRWoQU3/klwqUme1ycs9MkCNG1fDzbDwpyIbeYb4kAUr+3Z2wEr7T3MrwwAWJKL4iSIfVkgZDxZmQLnjoyKgXhAjBuWA+MG6ZfTugvt/0GycetL8FAW/qBRXekc0OvNA7Jc/wZq0pwWLVO8ZxjSkzUvTGRDS9cnuiVylFzkYko3yJD/Kgezk5TACDiqCat33vUkjSv6uZmYn7i4uKkeHGS4Qis3TIY2YK3fMr2vG/sRqTPeFK7RuE/W44BONbwbyviz1jiTVh0RzM3FF2+tfyA19wkeY6/YmX8oVXrFK85pqYblwvwrAmizDOgcZ4m3zmoQDpnSZAhftQI56UpABBxVJPW7+27KCu+dhY/9EsvvUR1vShkOAJrtwxGthAhH8n2vHLNzK3HMG3zEd32zIxFErRKPxg9l0V3tHNjSEwUWjUPJipx4i9xYFqw2oEVq9YpHnNMSzfKJtzTsV0xqHuk1zyjcZHxcKlZbT9WHPecH6NsQ+cWlSMitJlm5XEX6t/WafzKiq+aFWXgv78mk3p7fOHChczP5YmiA5569TcZjGwhSj5S93ZCyinDtsyMRSNIct5oPZdFdyxzo+/VbW0fx6IxYwdWrFqnWOeY8vuwMu0M/rUyQzN+yQVgfUZuo5cc2hATMyEpdtiPFeelyU/xrAT9yrIfkV9apRvUR+tXVnzVZjzJrLESgwYNMvFUfojw1/ubDEa2sFM+mnwzouJ2zMSbsOiOZW7YPYaswI74Q6vWKRb7qf0+aCFDTJsM8aOkOC9NfohRKgBfnhkQzbStqfiqtXacWrcIVv3cF9pYiUOHDlFdLxIZjsDaKQOJLeySjyUGh3fcjtl4E1rdsc4NGcaxSOyI/bNynaKxH+3vg4KdMW2k5ZNkiLtzYpr8DJpUAAqrf8zBm0NuYPpL0tNX7ZsRvM7tFhIrERoaSi2nSGQ4AmuXDKS2sEM+lhgc3nE7POJNaHRnZm7IMI5FYUfsn9XrFIn9WH4fFOyKaaMpnyRD3J3z0uRnsKTAN1tWQqs8QG2d2zDfR0RoMHp1aUP1vIgI+WIrZCgNIUoGvSO+NLawWkc0+WZE5W/ilaeGVHdm54YZG8l8FNyOEhxatjCjJ6N7jezH8vtgZW4ztf6Rlk9qG9pMirg756XJz2DdnhSxramX9l4hv7QaAydvozoyun//fvTu3ZurrA7qGB3xldkWJOMPEBu3Y3XpB7vsIftRcDtKcKjZwoye7ChFZGVMm1b/7ouJJLr/wZs7SvGS7sQ0+Rms25OitjW1fO2e0Kb6v/fee3mJ56ADSWkG2W1BMv5Ex+1YGS9khz1kKCVEgtVxW762MKMnu0oRWRXTpte/+YkniNoY3J3s5Uo0Lrfbbf8ZPpspLi5GeHg4ioqKEBYWZrc4utTWudE/fitxCnxl63X3mLuFvqVX1dSh74Qtmqc0aOSQJbllIKOMI62tfMVe99Yk4f/GjrVWOAY8t/3bhYYALuDipUpL3UhWuK+snhuk40T0+kKDVW5ET1uY0RNPHZP8PkSEBmPs/T0QGWbN3DDqHwlROv23+vfbcc/5GaQuCcDardfUkwXEx1qNYiqcFybxkB7xHTzyBeuEMkEgx5x5YvXcoDkKbrf+FawaC562MKMnnjomcVOOf7inpS5VljgrXx7p3Vmal/KAcc998skniI6ORvPmzdGrVy/s2rXLbpGEobUN7TumrDxOzPPIb1xcnFlxHAwgtdfMqfGCJXGgweq5YXcZH5nxtIUZPYkqRSRLegkeY6Nru5YcJOFDQOw0ff311xg9ejQ++eQTxMbG4tNPP8W9996LzMxMdO7c2W7xhKB2/LRXlzZCKt2TwPPI7xtvvGFWHAcDSO31zKjRYgVxoMLquWF3GR+Z8bSFGT3ZVYrIKniMDZnGV0DsNE2dOhVPP/00/vGPf+CGG27A9OnT0alTJ8yePdtu0YTim7a+WdMgIZXuSeBZTuM///kPV9kcGkNqrz1rvrRSLAcDrJ4bdpfxkRlPW5jRk92liERj1D89ZBxffr/TVFVVhdTUVLz11lten99zzz1ISkpSvaeyshKVlZUN/y4qKgJQH1DmwM7rd3XCq1//CKCxL90N4PW7uqH0UolhO/fcc49jCwsgsdc1zds6tpAIO+YGr3kdaPjawoyeAl3HRv3z/f+e/zbqu2IDy860uf2cn3/+2Q3AnZiY6PX5Rx995L7uuutU73nvvffcqLeH85/zn/Of85/zn/Of85+f/5eVlWXFK4fb73eaFFwu780/t9vd6DOFt99+G6+++mrDvwsLC9GlSxecOnUK4eHhQuV00Ke4uBidOnXC6dOnpU//EOg4tpALxx7y4NhCHoqKitC5c2fLKkn4/UtTu3bt0KRJE+Tmehf8O3/+PDp06KB6T0hICEJCQhp9Hh4e7kwASQgLC3NsIQmOLeTCsYc8OLaQh6Aga0K0/T4QvFmzZujVqxc2bdrk9fmmTZvQr18/m6RycHBwcHBwCDT8fqcJAF599VU88cQTuO2223DHHXdg7ty5OHXqFJ577jm7RXNwcHBwcHAIEALipemvf/0r8vLy8MEHHyAnJwcxMTFYv349unTpQnR/SEgI3nvvPVWXnYO1OLaQB8cWcuHYQx4cW8iD1bZwas85ODg4ODg4OBDg9zFNDg4ODg4ODg5W4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQ4Lw0OTg4ODg4ODgQcNm/NH3yySeIjo5G8+bN0atXL+zatctukQKOCRMmoHfv3mjVqhXat2+Phx56CIcPH/a6xu12Y9y4cejYsSNatGiBO++8Ez/99JPXNZWVlXjxxRfRrl07hIaGYtiwYThz5oyVXQk4JkyYAJfLhdGjRzd85tjCOn7++Wc8/vjjaNu2LVq2bImbb74ZqampDd87trCGmpoavPvuu4iOjkaLFi1w9dVX44MPPkBdXV3DNY4txLFz50488MAD6NixI1wuF1atWuX1PS/dFxQU4IknnkB4eDjCw8PxxBNPoLCwkE5YS4q1SEpCQoI7ODjYPW/ePHdmZqb75ZdfdoeGhrpPnjxpt2gBxR/+8Af3559/7s7IyHCnp6e7hw4d6u7cubP70qVLDddMnDjR3apVK/fy5cvdBw4ccP/1r391R0VFuYuLixuuee6559xXXXWVe9OmTe60tDT3XXfd5b7pppvcNTU1dnTL79m3b5+7a9eu7htvvNH98ssvN3zu2MIa8vPz3V26dHGPGDHCvXfvXnd2drZ78+bN7mPHjjVc49jCGuLi4txt27Z1r1271p2dne3+5ptv3FdccYV7+vTpDdc4thDH+vXr3e+88457+fLlbgDulStXen3PS/dDhgxxx8TEuJOSktxJSUnumJgY9/33308l62X90tSnTx/3c8895/XZ9ddf737rrbdskujy4Pz5824A7h07drjdbre7rq7OHRkZ6Z44cWLDNRUVFe7w8HD3nDlz3G63211YWOgODg52JyQkNFzz888/u4OCgtwbNmywtgMBQElJibtbt27uTZs2uQcOHNjw0uTYwjrGjBnj7t+/v+b3ji2sY+jQoe6nnnrK67M//vGP7scff9ztdju2sBLflyZeus/MzHQDcCcnJzdcs2fPHjcA96FDh4jlu2zdc1VVVUhNTcU999zj9fk999yDpKQkm6S6PCgqKgKAhgKL2dnZyM3N9bJFSEgIBg4c2GCL1NRUVFdXe13TsWNHxMTEOPZiYNSoURg6dCgGDRrk9bljC+tYvXo1brvtNvz5z39G+/btccstt2DevHkN3zu2sI7+/ftjy5YtOHLkCADgxx9/xO7du3HfffcBcGxhJ7x0v2fPHoSHh+P2229vuKZv374IDw+nsk9AZAT//+3da0iT7R8H8O/cmlrzmYe5rRLLQspydtA32YFOlIGSFFExPBQESpoWWWll9ULrRUgIIUSlgZa+EToRdHJaIS48oB2o7GQHy4pl0SypXc+Lh+7/f8/s/99im6bfD9zgrvvy/l1eP8Z+3rvv6/4d79+/x48fPxwe6qvT6Rwe/kvuI4TAtm3bMG/ePERHRwOANN8D5eL58+dSH6VSiaCgIIc+zJdrqqur0dLSgtu3bzvsYy6858mTJygrK8O2bdtQUFAAs9mMLVu2wNfXF6mpqcyFF+3cuRO9vb2YOnUq5HI5fvz4gaKiIqxfvx4A3xeDyV1z/+bNG2i1Wofja7Val/IzYoumn2Qymd1rIYRDG7lPVlYW2tvbcfPmTYd9v5ML5ss1L168QE5ODi5fvgw/P79f9mMuPM9msyEuLg7FxcUAgFmzZuHu3bsoKytDamqq1I+58LyamhpUVlbi9OnTmD59Otra2pCbm4tx48YhLS1N6sdcDB53zP1A/V3Nz4j9ek6j0UAulztUmD09PQ4VLblHdnY2zp07h7q6OoSFhUnter0eAP5nLvR6Pfr7+2GxWH7Zh/6/5uZm9PT0IDY2FgqFAgqFAvX19SgtLYVCoZDmkrnwvLFjx2LatGl2bVFRUejq6gLA94U35eXlYdeuXVi3bh0MBgNSUlKwdetWHDx4EABzMZjcNfd6vR5v3751OP67d+9cys+ILZqUSiViY2Nx5coVu/YrV64gPj5+kEY1PAkhkJWVhdraWly/fh0RERF2+yMiIqDX6+1y0d/fj/r6eikXsbGxGDVqlF2f7u5u3Llzh/lywZIlS9DR0YG2tjZpi4uLg9FoRFtbGyZNmsRceMncuXMdlt54+PCh9KBxvi+8x2q1wsfH/uNQLpdLSw4wF4PHXXM/Z84c9Pb2wmw2S32amprQ29vrWn6cv6Z9+Pm55MCJEyfEvXv3RG5urhgzZox49uzZYA9tWMnMzBRqtVqYTCbR3d0tbVarVepz6NAhoVarRW1trejo6BDr168f8JbSsLAwcfXqVdHS0iIWL17M23nd4L/vnhOCufAWs9ksFAqFKCoqEo8ePRJVVVVi9OjRorKyUurDXHhHWlqaGD9+vLTkQG1trdBoNGLHjh1SH+bCcz5//ixaW1tFa2urACBKSkpEa2urtPyPu+Y+ISFBxMTEiMbGRtHY2CgMBgOXHHDV0aNHxYQJE4RSqRSzZ8+WboMn9wEw4FZeXi71sdlsYt++fUKv1wtfX1+xYMEC0dHRYXecvr4+kZWVJYKDg4W/v79ITEwUXV1dXv5rhp9/F03MhfecP39eREdHC19fXzF16lRx7Ngxu/3MhXd8+vRJ5OTkiPDwcOHn5ycmTZokdu/eLb59+yb1YS48p66ubsDPiLS0NCGE++b+w4cPwmg0ioCAABEQECCMRqOwWCwujVUmhBC/ccaMiIiIaEQZsdc0EREREbmCRRMRERGRE1g0ERERETmBRRMRERGRE1g0ERERETmBRRMRERGRE1g0ERERETmBRRMRERGRE1g0EdGg2b9/P2bOnOn1uCaTCTKZDDKZDMnJyR6N9TNOYGCgR+MQkeexaCIij/hZLPxqS09Px/bt23Ht2rVBG+ODBw9QUVHh0Rjd3d04cuSIR2MQkXcoBnsARDQ8dXd3Sz/X1NSgsLAQDx48kNr8/f2hUqmgUqkGY3gAAK1W6/EzQHq9Hmq12qMxiMg7eKaJiDxCr9dLm1qthkwmc2j799dz6enpSE5ORnFxMXQ6HQIDA3HgwAF8//4deXl5CA4ORlhYGE6ePGkX69WrV1i7di2CgoIQEhKClStX4tmzZy6PeeHChcjOzkZubi6CgoKg0+lw7NgxfPnyBRs2bEBAQAAmT56MS5cuSb9jsVhgNBoRGhoKf39/REZGory8/HenjYiGMBZNRDSkXL9+Ha9fv0ZDQwNKSkqwf/9+JCYmIigoCE1NTcjIyEBGRgZevHgBALBarVi0aBFUKhUaGhpw8+ZNqFQqJCQkoL+/3+X4p06dgkajgdlsRnZ2NjIzM7FmzRrEx8ejpaUFy5cvR0pKCqxWKwBg7969uHfvHi5duoT79++jrKwMGo3GrXNCREMDiyYiGlKCg4NRWlqKKVOmYOPGjZgyZQqsVisKCgoQGRmJ/Px8KJVK3Lp1CwBQXV0NHx8fHD9+HAaDAVFRUSgvL0dXVxdMJpPL8WfMmIE9e/ZIsfz9/aHRaLBp0yZERkaisLAQHz58QHt7OwCgq6sLs2bNQlxcHCZOnIilS5ciKSnJnVNCREMEr2kioiFl+vTp8PH5z/9zOp0O0dHR0mu5XI6QkBD09PQAAJqbm9HZ2YmAgAC743z9+hWPHz92OX5MTIxDLIPBYDceAFL8zMxMrF69Gi0tLVi2bBmSk5MRHx/vclwiGvpYNBHRkDJq1Ci71zKZbMA2m80GALDZbIiNjUVVVZXDsUJDQ90eXyaTSXEBYMWKFXj+/DkuXryIq1evYsmSJdi8eTMOHz7scmwiGtpYNBHRH2327NmoqamBVqvFX3/9NShjCA0NRXp6OtLT0zF//nzk5eWxaCIahnhNExH90YxGIzQaDVauXIkbN27g6dOnqK+vR05ODl6+fOnx+IWFhTh79iw6Oztx9+5dXLhwAVFRUR6PS0Tex6KJiP5oo0ePRkNDA8LDw7Fq1SpERUVh48aN6Ovr88qZJ6VSifz8fMTExGDBggWQy+Worq72eFwi8j6ZEEIM9iCIiLzJZDJh0aJFsFgsXnm8SUVFBXJzc/Hx40ePxyIiz+E1TUQ0YoWFhSEpKQlnzpzxWAyVSoXv37/Dz8/PYzGIyDt4pomIRpy+vj68evUKwD9FjV6v91iszs5OAP8sXxAREeGxOETkeSyaiIiIiJzAC8GJiIiInMCiiYiIiMgJLJqIiIiInMCiiYiIiMgJLJqIiIiInMCiiYiIiMgJLJqIiIiInMCiiYiIiMgJfwPTh8J/S0WjfAAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3463,7 +3238,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -3481,7 +3256,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -3490,13 +3265,13 @@ "Text(0.5, 0.98, 'U')" ] }, - "execution_count": 67, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3531,12 +3306,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Comparison to theory" + "### Comparison to theory\n", + "\n", + "We now check that the average neuron state in the network returns to the equilibrium position after an initial transient [2]." ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -3545,13 +3322,13 @@ "(0.01, 6)" ] }, - "execution_count": 68, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3561,14 +3338,14 @@ } ], "source": [ - "def phi(x):\n", + "def Phi(x):\n", " return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n", "\n", "def nullcline1(x):\n", - " return phi(x)/lmbda\n", + " return Phi(x) / lmbda\n", "\n", "def nullcline2(x):\n", - " return beta/alpha*x/phi(x)\n", + " return beta / alpha * x / Phi(x)\n", "\n", "U_vec = np.logspace(np.log10(.1), np.log10(150), 100)\n", "\n", @@ -3589,18 +3366,13 @@ "\n", "R_pre_intrp[ R_pre_intrp <= 1] = 1.000001\n", "\n", - "#ax.loglog(U_avg[::200], R_pre_avg[:50] - 1)\n", "ax.loglog(U_avg_intrp, R_pre_intrp - 1)\n", "ax.loglog(U_avg[-1], R_pre_avg[-1] - 1, marker=\"o\")\n", "\n", - "#ax.scatter(U_avg[:199], R_pre_avg[:199])\n", - "\n", "ax.set_xlabel('Membrane potential')\n", "ax.set_ylabel('Residual calcium')\n", "ax.set_xlim(np.amin(U_vec), np.amax(U_vec))\n", - "ax.set_ylim(.01, 6)\n", - "\n", - "#ax.plot(U_avg, R_avg)" + "ax.set_ylim(.01, 6)" ] }, { @@ -3609,12 +3381,20 @@ "source": [ "## Acknowledgements\n", "\n", - "...\n", + "The authors would like to thank Renan Shimoura, Christophe Pouzat, Antonio Roque and Antonio Galves for their kind and helpful discussion and feedback.\n", "\n", "\n", "## References\n", "\n", - "...\n", + "[1] Brochini, L., de Andrade Costa, A., Abadi, M. et al. Phase transitions and self-organized criticality in networks of stochastic spiking neurons. Sci Rep 6, 35831 (2016). https://doi.org/10.1038/srep35831\n", + "\n", + "[2] Antonio Galves, Eva Löcherbach, Christophe Pouzat, Errico Presutti, \"A system of interacting neurons with short term synaptic facilitation\". arXiv:1903.01270v3 13 Sep 2019\n", + "\n", + "[3] Tsodyks MV, Markram H (1997). The neural code between neocortical pyramidal neurons depends on neurotransmitter release probability. PNAS, 94(2):719-23. DOI: https://doi.org/10.1073/pnas.94.2.719\n", + "\n", + "[4] Christophe Pouzat (2020). Spike Train Analysis and Modeling. (Syllabus) Latin-American School on Computational Neuroscience (LASCON) 2020, São Paulo, Brazil.\n", + "\n", + "[5] https://plmlab.math.cnrs.fr/xtof/interacting_neurons_with_stp\n", "\n", "\n", "## Copyright\n", @@ -3633,7 +3413,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -3647,7 +3427,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.4" } }, "nbformat": 4, From d6991b2f6112ebaad8741b3f7ca9bdc62fc24c28 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Mon, 26 Aug 2024 09:56:56 -0700 Subject: [PATCH 5/6] update GL tutorial notebook --- .../gl_model/gl_model_tutorial.ipynb | 1754 +++++++---------- 1 file changed, 676 insertions(+), 1078 deletions(-) diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb index b34032270..e2386b478 100644 --- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -8,7 +8,7 @@ "\n", "_In vivo_, neurons display variability in their spiking behavior: continuous fluctuations of the membrane potential can be observed, and they exhibit spontaneous firing and different responses to the same repeated input stimulus.\n", "\n", - "To capture these phenomena, the Galves-Löcherbach (GL) model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function $Φ(V)$ of membrane potential $V$. By subsuming all sources of randomness into a single function, the GL neuron model simplifies the analysis and simulation of noisy spiking neural networks [1].\n", + "To capture these phenomena, the Galves-Löcherbach (GL) model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function $Φ(V_\\text{m})$ of membrane potential $V_\\text{m}$. By subsuming all sources of randomness into a single function, the GL neuron model simplifies the analysis and simulation of noisy spiking neural networks [1].\n", "\n", "By combining the GL neuron model with a synapse model featuring short term synaptic facilitation, we reproduce the results on short-term memory dynamics in state space from [2]. The synapse model is formally equivalent to the Tsodyks-Markram model [3] when set to no depression, only facilitation." ] @@ -26,14 +26,6 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/charl/.local/lib/python3.11/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", - " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -42,8 +34,8 @@ " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.5.0-rc1\n", - " Built: Feb 21 2024 09:04:08\n", + " Version: 3.6.0-post0.dev0\n", + " Built: Mar 21 2024 03:47:13\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -87,7 +79,7 @@ "GL model with biophysical units\n", "-------------------------------\n", "\n", - "We formulate the GL model as a linear integrate-and-fire model with membrane time constant $\\tau_\\text{m}$, resting potential $V_\\text{m}$ and an instantaneous jump in the postsynaptic membrane potential (Dirac delta function postsynaptic kernel)." + "We formulate the GL model as a linear integrate-and-fire model with membrane time constant $\\tau_\\text{m}$, resting potential $V_\\text{r}$ and an instantaneous jump in the postsynaptic membrane potential upon receiving a spike (Dirac delta function postsynaptic kernel)." ] }, { @@ -116,7 +108,7 @@ "outputs": [], "source": [ "nestml_gl_exp_model = \"\"\"\n", - "neuron gl_exp:\n", + "model gl_exp_neuron:\n", " state:\n", " refr_spikes_buffer mV = 0 mV\n", " refr_tick integer = 0 # Counts number of tick during the refractory period\n", @@ -135,8 +127,7 @@ " V_reset mV = -65 mV # Reset potential of the membrane\n", " b real = 27 # Parameter for the exponential curve\n", " a mV = 5 mV # Parameter for the exponential curve\n", - " V_b mV = -51.3 mV # Membrane potential at which Phi(V)=1/b\n", - " with_refr_input boolean = false # If true, do not discard input during refractory period.\n", + " V_b mV = -51.3 mV # Membrane potential at which Phi(V)=1/b\n", " reset_after_spike boolean = true\n", "\n", " # constant external input current\n", @@ -159,24 +150,14 @@ " if refr_tick == 0: # neuron not refractory\n", " integrate_odes()\n", "\n", - " # if we have accumulated spikes from refractory period,\n", - " # add and reset accumulator\n", - " if with_refr_input and refr_spikes_buffer != 0.0 mV:\n", - " V_m += refr_spikes_buffer\n", - " refr_spikes_buffer = 0.0 mV\n", - "\n", " else: # neuron is absolute refractory\n", - " # read spikes from buffer and accumulate them, discounting\n", - " # for decay until end of refractory period\n", - " # the buffer is clear automatically\n", - " if with_refr_input:\n", - " refr_spikes_buffer += spikes * exp(-refr_tick * h / tau_m) * mV * s\n", " refr_tick -= 1\n", " \n", " if random_uniform(0, 1) <= 1E-3 * resolution() * Phi(V_m):\n", " refr_tick = RefractoryCounts\n", " if reset_after_spike:\n", " V_m = V_reset\n", + "\n", " emit_spike()\n", "\"\"\"" ] @@ -188,20 +169,34 @@ "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Did you try to import pygsl in the build directory?\n", + "\n", + "Well, that does not work out of the box. If you want to do that, please\n", + "use\n", + " python setup.py build_ext -i\n", + "to add the necessary extension module in the local pygsl/ directory!\n", + "\n", + "Please read the README first! Any further questions or missing information\n", + "please report on https://github.com/pygsl/pygsl!\n", + "WARNING:root:PyGSL is not available. The stiffness test will be skipped.\n", + "WARNING:root:Error when importing: libgsl.so.27: cannot open shared object file: No such file or directory\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_expa19b5725d62e4d56acf2da2f0101ed40.nestml\n", - "[3,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target'\n", - "[4,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_x2vykd5h'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.5.0-rc1\n", - " Built: Feb 21 2024 09:04:08\n", + " Version: 3.6.0-post0.dev0\n", + " Built: Mar 21 2024 03:47:13\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -211,155 +206,7 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "[5,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.5.0-rc1\n", - "[6,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[9,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", - "[10,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_expa19b5725d62e4d56acf2da2f0101ed40.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[12,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[13,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", - "[14,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", - "[15,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [10:73;10:73]]: Implicit magnitude conversion from pA to pA buffer with factor 1.0 \n", - "[16,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [10:15;10:68]]: Implicit magnitude conversion from mV / ms to pA / pF with factor 1.0 \n", - "[17,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[18,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [59:11;59:64]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([59:11;59:64])\n", - "[20,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[21,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [9:8;10:8]]: Variable 'G' has the same name as a physical unit!\n", - "[22,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"V_m' = (-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\",\n", - " \"initial_values\": {\n", - " \"V_m\": \"V_r\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", - " },\n", - " \"parameters\": {\n", - " \"C_m\": \"250\",\n", - " \"I_e\": \"0\",\n", - " \"V_b\": \"(-51.3)\",\n", - " \"V_r\": \"(-65)\",\n", - " \"V_reset\": \"(-65)\",\n", - " \"a\": \"5\",\n", - " \"b\": \"27\",\n", - " \"reset_after_spike\": \"true\",\n", - " \"t_ref\": \"2\",\n", - " \"tau_m\": \"10\",\n", - " \"tau_syn\": \"0.5\",\n", - " \"with_refr_input\": \"false\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:All known variables: [V_m], all parameters used in ODEs: {I_stim, V_r, I_e, C_m, tau_m}\n", - "INFO:No numerical value specified for parameter \"I_stim\"\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(-(V_m - V_r)) / tau_m + (1.0 / 1.0) * 0 + (I_e + I_stim) / C_m\"\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "INFO:Shape V_m: reconstituting expression -V_m/tau_m + V_r/tau_m + I_e/C_m + I_stim/C_m\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "INFO:Generating propagators for the following symbols: V_m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[23,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[24,GLOBAL, INFO]: Analysing/transforming neuron 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml'\n", - "[25,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [2:0;63:0]]: Starts processing of the model 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:update_expr[V_m] = V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"V_m\": \"V_r\"\n", - " },\n", - " \"parameters\": {\n", - " \"C_m\": \"250.000000000000\",\n", - " \"I_e\": \"0\",\n", - " \"V_r\": \"-65.0000000000000\",\n", - " \"tau_m\": \"10.0000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__V_m__V_m\": \"exp(-__h/tau_m)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"V_m\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"V_m\": \"V_m*__P__V_m__V_m - V_r*__P__V_m__V_m + V_r - I_e*__P__V_m__V_m*tau_m/C_m + I_e*tau_m/C_m - I_stim*__P__V_m__V_m*tau_m/C_m + I_stim*tau_m/C_m\"\n", - " }\n", - " }\n", - "]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[27,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [56:51;56:68]]: Implicit casting from (compatible) type 'h / ms' to 'real'.\n", - "[28,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, WARNING, [20:8;20:25]]: Variable 'a' has the same name as a physical unit!\n", - "[29,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [19:23;19:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[30,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp\n", - "[31,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.h\n", - "[32,gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml, INFO, [2:0;63:0]]: Successfully generated code for the model: 'gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "[33,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.cpp\n", - "[34,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.h\n", - "[35,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/CMakeLists.txt\n", - "[36,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "CMake Warning (dev) at CMakeLists.txt:93 (project):\n", - " cmake_minimum_required() should be called prior to this top-level project()\n", - " call. Please see the cmake-commands(7) manual for usage documentation of\n", - " both commands.\n", - "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\n", - "-- The CXX compiler identification is GNU 12.3.0\n", + "-- The CXX compiler identification is GNU 10.2.1\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", @@ -367,70 +214,71 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_a19b5725d62e4d56acf2da2f0101ed40_module Configuration Summary\n", + "nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", "Build static libs : OFF\n", "C++ compiler flags : \n", - "NEST compiler flags : -std=c++11 -Wall -fopenmp -O2 -fdiagnostics-color=auto -g\n", - "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", - "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli -fopenmp /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so\n", + "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", + "NEST include dirs : -I/home/charl/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/10/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.so\n", "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_a19b5725d62e4d56acf2da2f0101ed40_module' using\n", + "You can now build and install 'nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_a19b5725d62e4d56acf2da2f0101ed40_module.so will be installed to\n", - " /tmp/nestml_target_x2vykd5h\n", + "The library file libnestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so will be installed to\n", + " /tmp/nestml_target_bon4voq8\n", "The module can be loaded into NEST using\n", - " (nestml_a19b5725d62e4d56acf2da2f0101ed40_module) Install (in SLI)\n", - " nest.Install(nestml_a19b5725d62e4d56acf2da2f0101ed40_module) (in PyNEST)\n", + " (nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module) Install (in SLI)\n", + " nest.Install(nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module) (in PyNEST)\n", "\n", "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.26)\n", + " cmake_minimum_required(VERSION 3.18)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", "\n", - "-- Configuring done (0.2s)\n", - "-- Generating done (0.0s)\n", - "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", - "[ 33%] Building CXX object CMakeFiles/nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module.dir/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.o\n", - "[ 66%] Building CXX object CMakeFiles/nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module.dir/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.o\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp: In member function ‘void gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:166:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 166 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "-- Configuring done\n", + "-- Generating done\n", + "-- Build files have been written to: /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "\u001b[35m\u001b[1mScanning dependencies of target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\u001b[0m\n", + "[ 33%] \u001b[32mBuilding CXX object CMakeFiles/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module.dir/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.o\u001b[0m\n", + "[ 66%] \u001b[32mBuilding CXX object CMakeFiles/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module.dir/gl_exp_neuron_nestml.o\u001b[0m\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘void gl_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:175:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 175 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp: In member function ‘virtual void gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:296:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 296 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘virtual void gl_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:285:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 285 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml.cpp:294:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 294 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:276:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 276 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "[100%] Linking CXX shared module nestml_a19b5725d62e4d56acf2da2f0101ed40_module.so\n", - "[100%] Built target nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module\n", - "[100%] Built target nestml_a19b5725d62e4d56acf2da2f0101ed40_module_module\n", - "Install the project...\n", + "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so\u001b[0m\n", + "[100%] Built target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\n", + "[100%] Built target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\n", + "\u001b[36mInstall the project...\u001b[0m\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_x2vykd5h/nestml_a19b5725d62e4d56acf2da2f0101ed40_module.so\n", + "-- Installing: /tmp/nestml_target_bon4voq8/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so\n", "\n", - "Feb 27 06:34:06 Install [Info]: \n", - " loaded module nestml_a19b5725d62e4d56acf2da2f0101ed40_module\n" + "Aug 26 09:55:55 Install [Info]: \n", + " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n" ] } ], "source": [ "module_name, neuron_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", " nestml_neuron_model=nestml_gl_exp_model,\n", - " logging_level=\"INFO\" # try \"INFO\" for more debug information\n", + " logging_level=\"ERROR\" # try \"DEBUG\" for more debug information\n", ")\n", "\n", "nest.Install(module_name)" @@ -442,7 +290,7 @@ "source": [ "### Firing rate\n", "\n", - "This should correspond to the `Phi(U)` function in the neuron (see plot below for the theoretical curve)." + "This should correspond to the $\\Phi(V_\\text{m})$ function in the neuron (see plot below for the theoretical curve). Please note that in the literature, $\\Phi$ is sometimes defined as a probability of firing function with values between 0 and 1, but we here define it as giving the firing rate (in units of s${}^{-1}$)." ] }, { @@ -451,33 +299,34 @@ "metadata": {}, "outputs": [], "source": [ - "def measure_numerical_Phi_function(neuron_model_name, U_min=0., U_max=10., neuron_model_params=None, neuron_membrane_potential_name=\"U\"):\n", + "def measure_numerical_Phi_function(neuron_model_name, module_name, V_min=0., V_max=10., neuron_model_params=None, neuron_membrane_potential_name=\"V_m\"):\n", " nest.ResetKernel()\n", + " nest.Install(module_name)\n", " nest.resolution = 1. # check that results are independent of resolution...\n", - " \n", + "\n", " t_stop = 25000.\n", " \n", - " U_range = np.linspace(U_min, U_max, 12)\n", - " n_spikes = np.nan * np.ones_like(U_range)\n", - " for i, U in enumerate(U_range):\n", + " V_range = np.linspace(V_min, V_max, 12)\n", + " n_spikes = np.nan * np.ones_like(V_range)\n", + " for i, V_m in enumerate(V_range):\n", " neuron = nest.Create(neuron_model_name)\n", " if neuron_model_params:\n", " neuron.set(neuron_model_params)\n", " \n", - " neuron.set({neuron_membrane_potential_name: U})\n", - " assert neuron.get(neuron_membrane_potential_name) == U\n", - " \n", + " neuron.set({neuron_membrane_potential_name: V_m})\n", + " \n", " sr = nest.Create('spike_recorder')\n", " nest.Connect(neuron, sr)\n", " \n", + " assert neuron.get(neuron_membrane_potential_name) == V_m\n", " nest.Simulate(t_stop)\n", - " assert neuron.get(neuron_membrane_potential_name) == U\n", + " assert neuron.get(neuron_membrane_potential_name) == V_m\n", " \n", " n_spikes[i] = len(sr.events[\"times\"])\n", " \n", " spike_rate = n_spikes / (t_stop / 1E3)\n", "\n", - " return U_range, spike_rate" + " return V_range, spike_rate" ] }, { @@ -490,164 +339,167 @@ "output_type": "stream", "text": [ "\n", - "Feb 27 06:34:06 correlation_detector [Info]: \n", + "Aug 26 09:55:55 Install [Info]: \n", + " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "\n", + "Aug 26 09:55:55 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 27 06:34:06 correlomatrix_detector [Info]: \n", + "Aug 26 09:55:55 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 27 06:34:06 correlospinmatrix_detector [Info]: \n", + "Aug 26 09:55:55 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Feb 27 06:34:06 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", + "Aug 26 09:55:55 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:06 SimulationManager::set_status [Info]: \n", + "Aug 26 09:55:55 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:06 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Feb 27 06:34:06 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:06 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:55 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, @@ -663,7 +515,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -673,25 +525,24 @@ } ], "source": [ - "\n", - "# theoretical Phi vs U\n", - "U_range_theory = np.linspace(-60., -45., 100)\n", - "Phi_of_U_theory = (1 / params['b']) * np.exp((U_range_theory - params['V_b']) / params['a'])\n", - "\n", - "# numerical Phi vs U\n", - "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", - " U_min=-60.,\n", - " U_max=-45.,\n", + "# theoretical Phi vs V_m\n", + "V_range_theory = np.linspace(-60., -45., 100)\n", + "Phi_of_V_theory = (1 / params['b']) * np.exp((V_range_theory - params['V_b']) / params['a'])\n", + "\n", + "# numerical Phi vs V_m\n", + "V_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " module_name=module_name,\n", + " V_min=-60.,\n", + " V_max=-45.,\n", " neuron_model_params={\"reset_after_spike\": False,\n", " \"a\": params['a'],\n", " \"b\": params['b'],\n", " \"V_b\": params['V_b'],\n", - " \"tau_m\": 1E99},\n", - " neuron_membrane_potential_name=\"V_m\")\n", + " \"tau_m\": 1E99})\n", "\n", "fig, ax = plt.subplots()\n", - "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", - "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", + "ax.plot(V_range_theory, Phi_of_V_theory, label=\"theory\")\n", + "ax.plot(V_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", "ax.legend()\n", "ax.set_xlabel(\"$U$\")\n", "ax.set_ylabel(\"Firing rate [Hz]\")" @@ -714,13 +565,14 @@ "metadata": {}, "outputs": [], "source": [ - "def evaluate_neuron(neuron_name, nneurons=1, neuron_parms=None, stimulus_type=\"constant\", poisson_fr=0.0,\n", + "def evaluate_neuron(neuron_name, module_name, nneurons=1, neuron_parms=None, stimulus_type=\"constant\", poisson_fr=0.0,\n", " mu=500., sigma=0., t_sim=300., plot=False, rseed=1000, dt=0.1, input_freq=0.0):\n", " \"\"\"\n", " Run a simulation in NEST for the specified neuron. Inject a stepwise\n", " current and plot the membrane potential dynamics and spikes generated.\n", " \"\"\"\n", " nest.ResetKernel()\n", + " nest.Install(module_name)\n", " nest.SetKernelStatus({'rng_seed': rseed,\n", " 'resolution': dt})\n", " neuron = nest.Create(neuron_name, nneurons)\n", @@ -728,8 +580,6 @@ " for k, v in neuron_parms.items():\n", " nest.SetStatus(neuron, k, v)\n", " nest.SetStatus(neuron,{'V_m':np.random.uniform(-65.0, -50.0)})\n", - " nest.SetStatus(neuron, \"I_e\", mu)\n", - " # nest.SetStatus(neuron, {\"reset_after_spike\": False})\n", "\n", " if stimulus_type == \"noise\":\n", " # Create a noise generator\n", @@ -755,7 +605,8 @@ " # Connect the parrot neuron to each neuron\n", " nest.Connect(parrot, neuron)\n", " else:\n", - " raise Exception(\"Unknown stimulus type: \" + str(stimulus_type))\n", + " assert stimulus_type == \"constant\"\n", + " nest.SetStatus(neuron, \"I_e\", mu)\n", "\n", " multimeter = nest.Create(\"multimeter\")\n", " multimeter.set({\"record_from\": [\"V_m\"],\n", @@ -800,48 +651,54 @@ "output_type": "stream", "text": [ "\n", - "Feb 27 06:34:07 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", + "Aug 26 09:55:56 Install [Info]: \n", + " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "\n", + "Aug 26 09:55:56 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:07 SimulationManager::set_status [Info]: \n", + "Aug 26 09:55:56 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", - " Preparing 54 nodes for simulation.\n", + "Aug 26 09:55:56 NodeManager::prepare_nodes [Info]: \n", + " Preparing 52 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 54\n", + "Aug 26 09:55:56 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 52\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:56 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:07 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", + "Aug 26 09:55:56 Install [Info]: \n", + " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "\n", + "Aug 26 09:55:56 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:07 SimulationManager::set_status [Info]: \n", + "Aug 26 09:55:56 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Feb 27 06:34:07 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:55:56 NodeManager::prepare_nodes [Info]: \n", " Preparing 54 nodes for simulation.\n", "\n", - "Feb 27 06:34:07 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:55:56 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 54\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:07 SimulationManager::run [Info]: \n", + "Aug 26 09:55:56 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXwURfr/PxOOEK7hhoAJIHKoHCKCIiuKoIjoCh7g9Vt01XXlcL1Fv6y6GjYcRpD7WA65A5Ig9yEhhBBgYyACRkIMhIBJIAQy4UhCSPr3BzvjHN093dNV1dVDvV8vXppJp+v51FNPPTUzVf3YJEmSIBAIBAKBQCAQCAQCgYA4IWYbIBAIBAKBQCAQCAQCQbAi3nQLBAKBQCAQCAQCgUBACfGmWyAQCAQCgUAgEAgEAkqIN90CgUAgEAgEAoFAIBBQQrzpFggEAoFAIBAIBAKBgBLiTbdAIBAIBAKBQCAQCASUEG+6BQKBQCAQCAQCgUAgoIR40y0QCAQCgUAgEAgEAgElxJtugUAgEAgEAoFAIBAIKCHedAsENymvvPIK2rRpY7YZAoFAIBBYhoceeggPPfSQ2WZowmaz4YsvvmDe7hdffAGbzca8XYGAZ8SbboHlyc7Oxptvvolbb70VtWrVQv369dGnTx98++23KC0tNdW2zZs3M0t4KSkp+OKLL1BcXMykPdKw7CteycjIwBdffIGcnByzTREIBIKgYPHixbDZbK5/tWrVQocOHTB69GicPXvWbPMEDLD6+kgQHNgkSZLMNkIgCJRNmzbhueeeQ2hoKP7yl7+gc+fOuHbtGpKTk7F27Vq88sormDdvnmn2jR49GjNnzgSLMPv666/x4Ycf4uTJk5q+wa6oqEBVVRVCQ0Op26YFln3FK99//z2ee+457Nq1yzLfpAgEAgHPLF68GK+++iq+/PJLtG3bFmVlZUhOTsbSpUvRunVrHD16FLVr19Z8v2vXrgEAatasSctkYpSVlaF69eqoXr0603avX7+O69evo1atWkzbVULv+kggoAHbKBQICHLy5Ek8//zzaN26NRISEhAeHu763ahRo/Dbb79h06ZNJlrINzVq1DDbBK4pKytDzZo1ERLiuyHoypUrqFOnjglWCQQCgSAQBg0ahHvuuQcA8Prrr6Nx48b45ptv8MMPP+CFF17QfB8rvNl2YtabXjPe6AsEvCO2lwssy6RJk3D58mUsWLDA4w23k9tuuw3/+Mc/XD9fv34dX331Fdq1a4fQ0FC0adMGn376KcrLyz3+rk2bNnjiiSeQnJyMXr16oVatWrj11luxZMkSj+sqKirwr3/9C+3bt0etWrXQuHFj/OlPf8KOHTsA3DgzPXPmTADw2Nrm5Ouvv8b999+Pxo0bIywsDD169MD333/vo8Nms2H06NFYt24dOnfujNDQUNx5553YunWr65ovvvgCH374IQCgbdu2rrbUtil7n+nOycmBzWbD119/jXnz5rn6qWfPnkhNTfX527p16+LEiRMYOHAg6tSpg5YtW+LLL7/0+KY6MTERNpsNiYmJHn/vbGvx4sWa+kqJLVu24MEHH0S9evVQv3599OzZEytWrHD9vk2bNnjllVd8/s77TJ7TzlWrVmHcuHFo1aoVateujZKSEpfW7OxsPP7446hXrx5eeuklAEBVVRWmTp2KO++8E7Vq1ULz5s3x5ptv4uLFix7taRlTixcvxnPPPQcA6Nevn6sPvPtOIBAIBMZ5+OGHAdz4AB/QvkaQO9M9ffp03HnnnahduzYaNmyIe+65xyMXXbp0Ce+88w7atGmD0NBQNGvWDI888ggOHjzocZ81a9agR48eCAsLQ5MmTfDyyy/j999/97jGmZN+//13DBkyBHXr1kXTpk3xwQcfoLKy0uNa7zPdp06dwsiRI9GxY0eEhYWhcePGeO6553zWCs4t+Xv37sV7772Hpk2bok6dOhg6dCgKCwv99q3cmW4taxn3vz127BiGDRuG+vXro3HjxvjHP/6BsrIy13Xe6wgl3YGsjwQCGoiPoQSWZcOGDbj11ltx//33a7r+9ddfx3fffYdnn30W77//Pg4cOIDo6Gj8+uuviI+P97j2t99+w7PPPovXXnsNI0aMwMKFC/HKK6+gR48euPPOOwHcmMijo6Px+uuvo1evXigpKcFPP/2EgwcP4pFHHsGbb76JvLw87NixA0uXLvWx59tvv8Wf//xnvPTSS7h27RpWrVqF5557Dhs3bsTgwYM9rk1OTkZcXBxGjhyJevXqYdq0aXjmmWeQm5uLxo0b4+mnn8bx48excuVKTJkyBU2aNAEANG3aVHe/rlixApcuXcKbb74Jm82GSZMm4emnn8aJEyc8vh2vrKzEY489hvvuuw+TJk3C1q1b8fnnn+P69ev48ssvdbXpr6/kWLx4Mf7617/izjvvxCeffIIGDRrg0KFD2Lp1K1588UVd7Tv56quvULNmTXzwwQcoLy93faNx/fp1DBw4EH/605/w9ddfu7Yivvnmm66ti2+//TZOnjyJGTNm4NChQ9i7d69Hf/kbU3379sXbb7+NadOm4dNPP8Xtt98OAK7/CgQCgYAc2dnZAIDGjRsD0LdGcGf+/Pl4++238eyzz7reGB4+fBgHDhxw5aK///3v+P777zF69GjccccdKCoqQnJyMn799VfcfffdAP7YBt+zZ09ER0fj7Nmz+Pbbb7F3714cOnQIDRo0cLVZWVmJgQMH4t5778XXX3+NH3/8ETExMWjXrh3eeustRVtTU1ORkpKC559/HrfccgtycnIwe/ZsPPTQQ8jIyPDZZj9mzBg0bNgQn3/+OXJycjB16lSMHj0asbGxAfW5v7WMO8OGDUObNm0QHR2N/fv3Y9q0abh48aLPFyD+ILk+EggMIQkEFsThcEgApKeeekrT9enp6RIA6fXXX/d4/YMPPpAASAkJCa7XWrduLQGQkpKSXK+dO3dOCg0Nld5//33Xa926dZMGDx6s2u6oUaMkpTC7evWqx8/Xrl2TOnfuLD388MMerwOQatasKf3222+u137++WcJgDR9+nTXa5MnT5YASCdPnlS1ycmIESOk1q1bu34+efKkBEBq3LixdOHCBdfrP/zwgwRA2rBhg8ffApDGjBnjeq2qqkoaPHiwVLNmTamwsFCSJEnatWuXBEDatWuXR9vOthYtWuR6Ta2vvCkuLpbq1asn3XvvvVJpaanH76qqqlz/37p1a2nEiBE+f//ggw9KDz74oOtnp5233nqrj1+cWseOHevx+p49eyQA0vLlyz1e37p1q8/rWsfUmjVrZPtLIBAIBIGxaNEiCYD0448/SoWFhdLp06elVatWSY0bN5bCwsKkM2fO6FojeOePp556SrrzzjtVbbDb7dKoUaMUf3/t2jWpWbNmUufOnT1y2saNGyUA0meffeZ6zZmTvvzyS497dO/eXerRo4fHawCkzz//3PWzd36TJEnat2+fBEBasmSJ6zVnnw0YMMAjp7777rtStWrVpOLiYlW9n3/+uU8+17qWcf7tn//8Z4+/HzlypARA+vnnnyVJkl9HKOnWuz4SCGggtpcLLElJSQkAoF69epqu37x5MwDgvffe83j9/fffBwCfs9933HEHHnjgAdfPTZs2RceOHXHixAnXaw0aNMAvv/yCrKws/QIAhIWFuf7/4sWLcDgceOCBB3y2mwHAgAED0K5dO9fPXbt2Rf369T3sIcXw4cPRsGFD18/OfpBra/To0a7/d24du3btGn788UfidrmzY8cOXLp0CWPHjvU5s2akTMmIESM8/OKO97cHa9asgd1uxyOPPILz58+7/vXo0QN169bFrl27PK7XMqYEAoFAQIcBAwagadOmiIiIwPPPP4+6desiPj4erVq10r1GcKdBgwY4c+aMzzEs72sOHDiAvLw82d//9NNPOHfuHEaOHOmR0wYPHoxOnTrJtv/3v//d4+cHHnjAbz5xz28VFRUoKirCbbfdhgYNGsiuPf72t7955NQHHngAlZWVOHXqlGo7SuhZy4waNcrj5zFjxgD4Yz0nEFgN8aZbYEnq168P4MY5KS2cOnUKISEhuO222zxeb9GiBRo0aOCTQCIjI33u0bBhQ4+zul9++SWKi4vRoUMHdOnSBR9++CEOHz6sWcPGjRtx3333oVatWmjUqBGaNm2K2bNnw+Fw+FyrxR5SeLflfAPu3VZISAhuvfVWj9c6dOgAANTPSjm3BXbu3Jnofdu2bSv7evXq1XHLLbd4vJaVlQWHw4FmzZqhadOmHv8uX76Mc+fOeVzP0ocCgUAg8GTmzJnYsWMHdu3ahYyMDNczSQD9awR3Pv74Y9StWxe9evVC+/btMWrUKOzdu9fjmkmTJuHo0aOIiIhAr1698MUXX3i80XTev2PHjj7379Spk0/7tWrV8tkerSWflJaW4rPPPkNERARCQ0PRpEkTNG3aFMXFxZrWHkrrAa3oyYPt27f3+Lldu3YICQkRZ7EFlkWc6RZYkvr166Nly5Y4evSorr/T+i1otWrVZF+X3B4S1rdvX2RnZ+OHH37A9u3b8Z///AdTpkzBnDlz8Prrr6vef8+ePfjzn/+Mvn37YtasWQgPD0eNGjWwaNEij4ev6LGHFCTbUupv74e90EKtfTmdSt9yh4aG+jzFvKqqCs2aNcPy5ctl/8Z7QcTShwKBQCDwpFevXq6nlysRyE6p22+/HZmZmdi4cSO2bt2KtWvXYtasWfjss8/wr3/9C8CN88kPPPAA4uPjsX37dkyePBkTJ05EXFwcBg0apLtNpXzijzFjxmDRokV455130Lt3b9jtdthsNjz//POoqqrS3E6gecvI/eQezCYHq/WFQKAX8U23wLI88cQTyM7Oxr59+/xe27p1a1RVVflsBT979iyKi4vRunXrgGxo1KgRXn31VaxcuRKnT59G165dPZ4UqpQU1q5di1q1amHbtm3461//ikGDBmHAgAEB2eCvLVpUVVX5bAk7fvw4ALieiu78VLy4uNjjOrlvDfTY79ye5u9Dl4YNG/q0rdS+Xtq1a4eioiL06dMHAwYM8PnXrVs33fdk7UOBQCAQGF8j1KlTB8OHD8eiRYuQm5uLwYMHY/z48R5P2w4PD8fIkSOxbt06nDx5Eo0bN8b48eNd7QNAZmamz70zMzMDXqN48/3332PEiBGIiYnBs88+i0ceeQR/+tOfZPOk2Xj74rfffkNVVRX19YVAQAvxpltgWT766CPUqVMHr7/+Os6ePevz++zsbHz77bcAgMcffxwAMHXqVI9rvvnmGwDweVq4FoqKijx+rlu3Lm677TaP8iLOWs7eSaFatWqw2Wwen8jm5ORg3bp1uu3w1xZNZsyY4fp/SZIwY8YM1KhRA/379wdwYyFRrVo1JCUlefzdrFmzfO6lx/5HH30U9erVQ3R0tMeixmmHk3bt2mH//v24du2a67WNGzfi9OnT/sX5YdiwYaisrMRXX33l87vr168H5AczfCgQCAQ3O0bWCN5rgZo1a+KOO+6AJEmoqKhAZWWlz9btZs2aoWXLlq71wj333INmzZphzpw5HmuILVu24Ndffw1ojSJHtWrVfL5Vnj59OpffDjvLiDqZPn06ALh2BtSvXx9NmjQhvr4QCGghtpcLLEu7du2wYsUKDB8+HLfffjv+8pe/oHPnzrh27RpSUlKwZs0aV43mbt26YcSIEZg3bx6Ki4vx4IMP4r///S++++47DBkyBP369dPd/h133IGHHnoIPXr0QKNGjfDTTz+5SoI46dGjBwDg7bffxsCBA1GtWjU8//zzGDx4ML755hs89thjePHFF3Hu3DnMnDkTt912m65z4e442/q///s/PP/886hRowaefPJJV7IhTa1atbB161aMGDEC9957L7Zs2YJNmzbh008/dW2tttvteO655zB9+nTYbDa0a9cOGzdu9Dnv7G6/d1/JUb9+fUyZMgWvv/46evbsiRdffBENGzbEzz//jKtXr+K7774DcKMEzPfff4/HHnsMw4YNQ3Z2NpYtW+bxIJdAefDBB/Hmm28iOjoa6enpePTRR1GjRg1kZWVhzZo1+Pbbb/Hss8/quuddd92FatWqYeLEiXA4HAgNDcXDDz+MZs2aGbZXIBAIBPIYWSM8+uijaNGiBfr06YPmzZvj119/xYwZMzB48GDUq1cPxcXFuOWWW/Dss8+iW7duqFu3Ln788UekpqYiJiYGAFCjRg1MnDgRr776Kh588EG88MILrpJhbdq0wbvvvktE5xNPPIGlS5fCbrfjjjvuwL59+/Djjz/6lOvigZMnT+LPf/4zHnvsMezbtw/Lli3Diy++6LGL7PXXX8eECRPw+uuv45577kFSUpJrx507rNdHAoEsZj02XSAgxfHjx6U33nhDatOmjVSzZk2pXr16Up8+faTp06dLZWVlrusqKiqkf/3rX1Lbtm2lGjVqSBEREdInn3zicY0k3SjvJFcKzLtMSFRUlNSrVy+pQYMGUlhYmNSpUydp/Pjx0rVr11zXXL9+XRozZozUtGlTyWazeZTQWLBggdS+fXspNDRU6tSpk7Ro0SLFMhtypUbkymF99dVXUqtWraSQkBC/5TGUSoZNnjzZ51p4ld8YMWKEVKdOHSk7O1t69NFHpdq1a0vNmzeXPv/8c6mystLjbwsLC6VnnnlGql27ttSwYUPpzTfflI4ePepT6kOtr5RYv369dP/990thYWFS/fr1pV69ekkrV670uCYmJkZq1aqVFBoaKvXp00f66aefFEuGrVmzRraf6tSpo2jDvHnzpB49ekhhYWFSvXr1pC5dukgfffSRlJeX57pG65iSJEmaP3++dOutt0rVqlUT5cMEAoHAIM7yV6mpqarXaV0jeM/bc+fOlfr27Ss1btxYCg0Nldq1ayd9+OGHksPhkCRJksrLy6UPP/xQ6tatm1SvXj2pTp06Urdu3aRZs2b52BAbGyt1795dCg0NlRo1aiS99NJL0pkzZzyuUcpJSusH99x98eJF6dVXX5WaNGki1a1bVxo4cKB07Ngxn/WEUp8plQHVaouWtYzzbzMyMqRnn31WqlevntSwYUNp9OjRPiVCr169Kr322muS3W6X6tWrJw0bNkw6d+6cj25J0rc+EghoYJMk8RQfgUCgj1deeQXff/89Ll++bLYpAoFAIBAIgoQvvvgC//rXv1BYWIgmTZqYbY5AQAxxplsgEAgEAoFAIBAIBAJKiDfdAoFAIBAIBAKBQCAQUEK86RYIBAKBQCAQCAQCgYAS4ky3QCAQCAQCgUAgEAgElBDfdAsEAoFAIBAIBAKBQEAJ8aZbIBAIBAKBQCAQCAQCSlQ32wAeqKqqQl5eHurVqwebzWa2OQKBQCCwKJIk4dKlS2jZsiVCQsTn2rQR+VsgEAgEpKCZw8WbbgB5eXmIiIgw2wyBQCAQBAmnT5/GLbfcYrYZQY/I3wKBQCAgDY0cLt50A6hXrx6AGx1cv359k60xxqRJk/DRRx+ZbQYRgkVLsOgAgkdLsOgAgkdLsOgoKSlBRESEK68I6BJM+RsInjgIFh2A0MIjwaIDCB4twaKDZg4XTy/HjQ622+1wOByWT9qXL19G3bp1zTaDCMGiJVh0AMGjJVh0AMGjJVh0BFM+sQLB1t/BEgfBogMQWngkWHQAwaMlWHTQzCniwFmQMX/+fLNNIEawaAkWHUDwaAkWHUDwaAkWHQKBEYIlDoJFByC08Eiw6ACCR0uw6KAJ12+6v/jiC9hsNo9/nTp1cv2+rKwMo0aNQuPGjVG3bl0888wzOHv2rIkWm8+gQYPMNoEYwaIlWHQAwaMlWHQAwaMlWHQI/kDkcP0ESxwEiw5AaOGRYNEBBI+WYNFBE67fdAPAnXfeifz8fNe/5ORk1+/effddbNiwAWvWrMHu3buRl5eHp59+2kRrzefIkSNmm0CMYNESLDqA4NESLDqA4NESLDoEnogcro9giYNg0QEILTwSLDqA4NESLDpowv2D1KpXr44WLVr4vO5wOLBgwQKsWLECDz/8MABg0aJFuP3227F//37cd999RNrPd5Ti5PkraNukDsLtYUTuSZMGDRoQu5fZ2klqMZNg0QEY02L2eHLnZvUJTz7wxgo+4bn/eMXsHG41rBAHWqCpg3UcVtWyIyX7vGlxT1Kv2eOLlBZWOliMNS1aeMw93jaZPbasAPdvurOystCyZUvUqlULvXv3RnR0NCIjI5GWloaKigoMGDDAdW2nTp0QGRmJffv2EUnYsam5+CTuCKokIMQGRD/dBcN7Rhq+L01IPW2PB+3B8vTfYNEBBK6Fh/Hkzs3oE9584A3vPuG9/3jFzBxuRXiPA63Q0sE6DmNTczF2bwWkvQdMiXvSes0cXyS1sNDBaqz508Jj7pGzqXWQzF004Xp7+b333ovFixdj69atmD17Nk6ePIkHHngAly5dQkFBAWrWrOnzyUrz5s1RUFCget/y8nKUlJR4/PMm31HqGlAAUCUBn8YdRb6jlJQ8Kvz666+G78GLdhJaeCBYdACBaeFlPLlzs/mERx94w7NPrNB/PEIjhyvl74Ig8QXPcaAHGjpYx6GzPWeJH9ZxT0OvWeOLtBbaOliONTUtPOYeJZsOHM40zSarwPWb7kGDBuG5555D165dMXDgQGzevBnFxcVYvXq1oftGR0fDbre7/kVERAAATpw4gUmTJqG8vBxfTZnrGlBOKiUJa7YkIi4uDhkZGZg2bRpKSkoQFRUFAIiKisKFCxcwc+ZMHD58GOvXr8emTZtw8OBBzJ07F4WFhR7XXr16FTExMUg++Av+veB7rNn0I1JSUrB48WKcPn3a49rKykpER0fj1KlTWLp0KZKTk5GYmIhVq1YhKysLkydPRllZGTIyMlx/U1BQgPnz5yM1NRVbt25FfHw8jh49iunTp8PhcHjcv7i4GDNmzMCRI0ewbN12We05568iKioKpaWliImJQVZWFmJjY5GQkIC9e/diyZIl+CkjG6P+9S1+v3gFUVFRqKqqwvjx45Gbm4slS5Zg7969SEhIQGxsLLKyshATE4PS0lIPW86ePYt58+ahefPm2Lx5M9atW4cjR45gxowZKC4u9rjW4XBg+vTpOHr0KOLj47F161akpqZi/vz5KCgo8Li2rKwMkydPRlZWFlatWoXExEQkJydj6dKlOHXqFKKjo1FZWenxN6dPn8bixYuRkpKCnTt3YvXq1cjMzERMTAyuXr3qcW1hYSHmzp2LgwcPYtOmTVi/fj0OHz6M33//HRcuXPC4tqSkBNOmTUNGRgbi4uKwbds2pKamYsGCBcjLy/O4try8HJMmTUJ2djZWrlyJxMRE7NmzB8uWLUNOTg4mTJiA69eve/zNmTNnsGjRIuzfvx87duzAmjVrcOzYMUyZMgWXL1/2uPb8+fOYM2cO0tPTsXTtRsQs3YAfU9Iwe/ZsFBUVeVzbu3dvTJ06FRkZGVi7di22b9+OAwcOYOHChT52V1RUYOLEiUg58pvseHp/ynLknr/k8Td5eXlYuHAhDhw4gO3bt2Pt2rXIyMjA1KlTcemS57VFRUWYPXs20tPTsWHDBmzcuBHp6emYM2cOzp8/73Ht5cuXMWXKFBw7dgxr1qxBaGgo9u/fj0WLFuHMmTMe116/fh0TJkxATk4Oli1bhj179iAxMRErV65Edna2a47wtnvBggVITU3Ftm3biM8RmZmZWL16NXbu3OkzRzzyyCN+54jk9OOyPliVfBwxsxfoniPWrVuHzZs3Iy0tDfPmzcPZs2c9rlWbI3JzczF+/HhUVVV5zBF33HGH7jkiLS2NyRwxb+U62f77aspcnzkiLi4OghvQyOFK+fvAL/zFpvNarfnbPZ4Dzd80YjOQ/F2zQTNMWbEJi2PJxeaEmQtl43DZ7l/wf+O/Jp6/d/73iGx7GbmFAeXvOd+twuy1O/HD9t2a8vfmpJ8U5x3nte75e+PGjdiwYQPS09Mxcfo8bD10Ap98OdF17aVLl3Dq1Cld+fvEiRNYvnw5kpKSkJSUhOXLl+PEiROYOHEiKioqNOfvjNzzslp+3H9YNn9/8uVEpGTf+K93/t6xYwcaN25MNX8npmXI2nvkZAEmfDsHy3b8F9+tITNHZGRkKM4RC1dvVBwDZs0RUVPnydqUe7GMy/ytd42flZUFWliuTnfPnj0xYMAAPPLII+jfvz8uXrzo8Ul569at8c477+Ddd99VvEd5eTnKy8tdPzsLobvXZMt3lKLPhASPgVXNZkPy2H5Ez1OQ3jYSFRWFcePGGbIpUO08auEBq+jQ4r9AtMiNJydmbZWyik+0oEULjz7whmef6JkTg61uNGmM5nCl/J2ZW4AOEc1pm08dnuNAK7GpuRi79jAk2IjOL6znMZLrwEDWRzTWYmaNLz1aaK1FSNj70aCOmLjlGNGt3mpa8h2luD86Ae5D3mYDUsY+bNrZbqU47FXzd6z+8m+m2EQSUaf7f1y+fBnZ2dkIDw9Hjx49UKNGDezcudP1+8zMTOTm5qJ3796q9wkNDUX9+vU9/nkTbg9D9NNdUM1mA3Aj2P79dGeig5zGthESk1Ag2nnVwgNW0KHVf4Fo8R5P7pi1VcoKPtGKFi08+sAbnn3CIh/cDJDI4Vryt5XhOQ608MeW7BuxQnJ+YT2PkYr7QNdHNNZiZo0vrVporkWM2vvRY3+84VazTS+6tZj8VWm4PQwfP9bJ5/W0iltMX0fwDtdvuj/44APs3r0bOTk5SElJwdChQ1GtWjW88MILsNvteO211/Dee+9h165dSEtLw6uvvorevXsTewDL8J6RSB7bDyvfuA/JY/sR/ybo5Pkritu4A8W5bcIoerXzrMVsrKBDq/8C1eIcT+MG3+7zO6PjJBCs4BOtaNXCmw+84d0ntPNBMMIyh+cWBcdij/c48AeNtYA7rOex4T0jMSzsiKG4N9InpNdiZo4vLVpor0X04G1vl1vsVMa2mpaT56/4vMeWANPzdZdb7D6v8bCO4B2un15+5swZvPDCCygqKkLTpk3xpz/9Cfv370fTpk0BAFOmTEFISAieeeYZlJeXY+DAgZg1axZRG8LtYdS+zWjbpA5CbPDZvtKmSW2P6/SUChg7diwx+9y1+7NBqxY9kNQSCKRKNJitQwta/JfvKMWDw95AvqM0oP4It4dhcNdw/Hvzr4bGCQm/6PUJj+U6nOjRQsoHNNCig4Yf9NyTZj4IRljm8MjGweEXK+QLOZxxVKdmNeJrAW9Yz2Nfffo+qlcPfLlsdH2kZ96RaysEcLVl9vjyp0VrX7HS4W0vybHtjJkRb72jeA2NtbUelPKj7DizwfR1BO9w/U33qlWrkJeXh/Lycpw5cwarVq1Cu3btXL+vVasWZs6ciQsXLuDKlSuIi4uTrQfKK1q228Sm5qLPhAS8OP8A+kxIQGxqruo9v/76a+J2arGBxvZLGlq0orff1TBTh1b8+c/ZH/9v4U+G+sPoOCHlFz0+ITkWaKB3fPG6VdqfDhp+4N23VodlDm8RJB+GWCFfeOMeR0NnpWBo91aw/e/7OVrzS7g9DEO7t/J4bUj3llTmMaM+YWmrc35334AvAUg6XgiA//Glta/M0EEyd7rHTN/JiYq5x8x8rZYf5ex6oNYZ09cRvGO5B6nRwOwH3+Q7SpFz/iraNKntMWADeYhGTk4O2rRpQ9Q2PTYoaQkE0lq0QvohembpCAQ5/9F4qGAg44SkHVp9wuqBikYIdHyRjFUSqOmgNQZp+NbsfHKz4ezvYHmQmpXyBaAcRzOGtEGDJs2pzS8s52ajPmGdR9TaK794luvxpbWvzIwTo7kzkPHAOl9rtdHdLt7HllbEg9SCnHB7GHq3a+wTSIGcA0pOTiZqm1Yb8h2lSMk+DwCyWgKBtBatKGlOy7kY0P3M0hEIcmORxhk9pTEP/DGWvB/IQdIOrT5RGwtyNpqBPy1K/anmAzNQ00FjDNI+eypgS7Cc6eYpXyjNHe4oxVHqocPU5pd8Ryk2Hs5jFr9GfcJ6rlFrj6fxBfiOMa19ZbYOycDTzAIZD+H2MLRpUhsnz19hsu7Qug52X0eY7RMrwPWZ7pudQM5ytG7dmrkNpEuFOSGtRStymgHg7VWHcOXadd3azNJBCpZnitTGEkk7tPpErk0bbowF0uM9UNS00IpNGqjpoDEGj5xx+LzGw9l2QWAEy5luXvKF1rlDKTa73RpO3S5vaMWvUZ+0bVIHNsCn7BOtuUZtbrvOyfgC5MdY3w5NNc31ZsUJiZwaSD5jncsDWQfzMnfxjPimm2MCOctRWVnJ1AYapcKckNaiFadm7+AIVJtZOkjB6kyRv7FE0g6tPvFu0zkmaIz3QFHSQjM2aaDmE9JjMN9Riolbj/m8/tGgjtx88y+4OeEhX+iZO5Ri016T/MlFb7vcoXnWlYpPKB3s9De38TC+AOUxBkDTXG+GDlI5VW5doTZ2zcjlgayDeRlbPCO+6eac4T0j0bdDU81nOfLz85naoLZNxmjyo6FFK8N7RqJOaHWMXnHI4/VAtJmpgxTOMbBw9Qb8ddiTVBY2WsaS3nhQQo9P3NssulJOZEyQREkLzdikgT+fkPI9IN83ANC1VYOA7ykwl9yiUnSIMNsK4/CQL/TOHXKxuXLlXiZ2AcA/B9+Ox7uGU5vXjPpErewTaZv9zW08jC9AfYxpmevN0EEyp7pr/Dl5h+q31mblcr3rYF7GFs+IN90WQK7EgtJj/Hv16sXMBoDu1uO2d3RHSvZ508o09WjdkIg2Wj7RCqkyS+H2MDz/cA/TS+iRKNuk1yfONn8+fRE2GyBRGO+BoqTF7FIjetHiEz1zoRpW6xuBf4Jle7nZ+QJQLjtVu6by5kjv2KShQ8mu5vZaxNtyx6gWlvONv7bctZhZCtOfnU57Tp6/4vGzEzPiRM3mQPrSGTPN0JNpu3rwtw52b5+HuQvgu8Sr2F5uQdQe47927VqmttDaehybmosXVv5maikfUtpY+8Qd0iWRaGphWRojEB2xqbkYOivF5w232eW2lLQkHS/0sNVmU9/CZjaB+iSQ8c1r2TRB4ARLyTAz84UT7/gAgCoAQ2elaI4xGjq87XKekx694hDVdYJRLSznYn9zm1OL2eUS/dnpzz4z4kTJ5qTjhYb60p8WWu1qQc1P3j76asVO4u3rxexx7Q9RMgzWKvHi7zH+5eXlCA0NNcUuUuUMeCvTZFSbmT4h3Y8stLAojaFXh1xfhgCIH3U/ukU0JG+gDuS0KNm795OHuX1jScInesc3jbFmpXwSDARbyTCz8oUcP5++iCEyHzRqiTGaOvIdpUjLueh6oKVe2/RiRItZc7HS3FZeXo4LZVXcrLECLVNqZpy42wzAcF9q1UK6XT14+0l2XNuAvWPNW2OQWvOKkmFBipZyHN74KzUwefJkkiZqhmQ5A9rlNfT2u9HSSmb5hEY/stDCopSVXh1ppy769GUVgKvXqsgZFSByWuR8XwVwXQ5r8uTJumKTxPgmOdacthdw+qC6YCdYSoaZlS/kuHKtEt5fy6jFmHv80tQRbg8DZJ6sTKsMlxEtZszFzu21ch8mTp48matyiYGWKaU5vvzlIXebSfSlVi3OdgEwLZnn3rb7tn+fcS2Zu8bgaVwrIc50m0Sgj//3dw5m3LhxtExWhWQ5A5rnn8wooWSWT2j0o1laSKNHR2xqLsauPeLzOi9ngOW0WPHMcvuBf3F9Sq0lNnnS6FHG6Bo/Cf5mIljOdPM0x+qJMd/c+hdqdrGek434hHW5MH9rnHHjxiHfUcrN3CmHlnKOtOJE7xqRRB7Sux5hXTJPDtlxDXrjWgs8rQmUEN90m4CRx//7OwcTFRVFzW4lSJczcGq0/S+cSZ23NKuEkhk+AeicWzVLC2m06nCOGe/8FsLR+Wg5LVY7s5zvKMXYtYd1xSYvGuXmFYEgUHiaY7XGmFwMjF17mEpuNWNOJu4TiuXC/K1xoqKiuJk75dBazpFGnASyRiTRl3rXI6xL5mlFojWwNcLzuHYivuk2AaOP/1crp/DXv/6VtLl+oVHOYHjPSHSsX4XS6vWInbc0q+yCGT5xQrLMEmCuFpJo1aFUfmXa893xRLeWhK0KDCUtpH1PkxsldWwer2mJTR40Ko0RAVuCpWQYb3OslhiTiwEJNqYlsWjOyUZ8Yna5MO951KmFh7lTDq3lHGnESaBrRKN9aXQ9QrtknpItvqbQiXk98DqunYhvuk3AuQXCHb1bIJTOIm7ZsoWEiX5xP/NCQo/cvXft2kX0bC9pO7Wi1yeBnPVXg9S51XxHKWav3Ul9Z4CzLZJ94I1WnyiNmR5tzHl4mly/qGkJxPe0+16OG1vVPFO4XGzK2cbiGQBqyI0RAXuCZXs5qxzuREu8+4sxuRiwQaJaEssd2nOyEZ/I2RtCaXu5ljWOuxZac6eRHKJ1nUYjTrS2TToPGV2PsH7DrWQLrZjXi9lrAjXEm24ToLkFomvXrobv4Q/vR/InHS8kpsf93tNymhF93L9ZW0/0+ITXcgdOu5b+3oi6XSz6QKtPeNqupNQvJGPerPEXbg/Dm3fXV+1nXmNDbowI2BMsJcNY5HAnpGJKLgbevLs+lXnSjFKIRnziOi7nNi1I0g0dpNHSN7THl9ExpTXn0tChpW0aeUjPemRo91Yerw3p3tKU9YicLX0ja3H5RpcnxPZyk6C1BeLChQtE7qOE0pmX5LH9kDy2nyE93veWcOPefTs0JdY/Zmw90eoTpb4lqT8QWNrFqi09ccLDdiW1fiEV82aPv+72UsU5xGzb/OE+RhrXvI6OU8y2SGBVaOdwJ6RjynuePLw/ibDF8ue5bRLQt0NT4m25Y9QnfTs09TjHTWNto7VvaI4vUmNKS86lpUOtbVp5SM8aMf7Q7x6vrTuUhw8GdmSeB+Vs2ZNbjnxHKRc5mVfEN90mQnLbr3Ory5UrVwhZJ4+/My9G9LB63D/rrSdafRKIfhZbgVmWYWDVlt44MXu7klq/KGnROzZY9L2aTVeuXFHsZyuUAnGWTTxVxI9NAutBO4c7oRFT7vF75coV4vlJqfxWWs5FIvdXwqhP5M6/kp6/tJYmI5UvtNoQiE61kmdOaMYJ6zykRUu+o5R5mTA1rFiWlAfEN90Wx7u8wZj7Wvn/IwPQfCS/FR73HwidOnXSdJ1e/azKn7H0C6u2tPqEF9T6xS6jJZCxQbvv/dmk5hMrzA1OfdfLxKJDEDis5ibaMXWqWit8oKMEoBbkbAaAt1cdwpVr16mV/zTqExZlw7T6U04LqbUEiTGl1RYzcjitmPGnhZcyYe4oxeLh34tdtcQFvohvui2M3FaXafsKqX7rSfOMq/e9bZC4e9x/IPz444+artPTtyzLn7E818yqLa0+4QW1fvHWEujYoNn3WmxS8wlPZ+vlUCvlIhDogdXcRDvep+0rJJ6fnDZ7L1xpl/+k4hPCc4VWf5LKF0ZsUEKPLWbkcFoxo6aF1zJh4fYwfPyY74cFk7ZkMn0Iq9UQ33RbGJZlOtyhecbV42xkaBU63EL3rBYLXnnlFc3Xau1b1uXPnHZl5Bbijki652hZnKHW4xNeUOoXby1Gxgatvtdikz+f8HC2XglRNkxACpZzE814D6QEoBaG94xEndDqGL3iEJX7y2HUJ6zKhmnxJ8l8EagNSuixxawcTiNm1LTwVCbMmy632H1eY1GG18qIb7otjNIj+2vXDKF+zpfmGVfnvVcvnkvkfmaUQHJn2rRpuuzQ0rdmlD8Lt4dh3w9LNPncaJ/TPkPt9AltWJR/89ZidGyo9X2gerTYpMUnZpyt16JZlA0TkILV3OSERkxpLQEYKBENwzyeBk76/t4Y9YnROVnPvOvPn6TzRSA2KCFbXg1A7Zq+b1VYx4k7Tn0AiOR3NS1ay4SZVerTjDK8VsYmSdJN//l8SUkJ7HY7HA4H6tevb7Y5uohNzcWncUdRKUmoZrNhSPeWiD/0O/VzvlaB1blnM+zw9v2/n+7Mha956XOzMbMfaIwNo3p4Ha9q6NHs1FdRdgWnpw6zZD6xIs78vTDhKF7td6fZ5gj+B614lzvfaoX55P3V6Vh78I+nPT9zdyvEDLvL79+xyCM8zc3utjjhcR3BMr/784+Za41AxzXP0HxPKN50w9pvuoEbn3DlnL+K2jVDMGTmXo9tXdVsNiSP7WfJrR5RUVEYN25cwH+f7yhFn/89yMWJGf3xyZcTEVvamYodTt+z2m7rzye89Lk/jI4tf7DsByUtJMcGKT1qNtH2iV4C0ZzvKMUvJ8/ike5tLZtPrIYzf7d5dw1SPh/M1TwTCLzFQaBERUXhtTHvE81PcjEZAiB+1P3oFtHQ8P2VMGstQiOPsMgXRvn59EUMmZXiUXPcW7eZcULaL1q0KPnHzDWXVdZ7eqH5nlBsLw8CnFtdrlyrVDxHZUVGjhxp6O95KTP00JPDqNnBerutP5/w0uf+MDq2/MGyH5S0kBwbpPSo2UTbJ3oJRHO4PQy9bm1E2TKBHDzOM4HAWxwEysiRI4nnJ6UyRVevVRG5vxJmrUVo5BEW+cIoV65VwvvrQG/dZsYJab9o0cJjOU2rrPd4QrzpNojZ54XdkTtHpXQexgqsXLnS9f+B9DMv500OJW1TtYOnMeQPd5/I4a/PedG6cuVKqrZoHXskbPDnExKwiCXaPtGLkmYWz8wQ6CdYzhKyiGfSyMUtaR35jlIUXS43Jacb1VKnZrWAzqAbmXeV5lIrjC8tus3UEag/lQhEi9O/dWpWM22dy8sa20qIp5cbgLezq+H2MIy6txFm/7fYdR6mCsDQWSmm2xYIDzzwAIDA+9lZ3sH7LAzrT3If73c/2pY3kLWDtzHkD6dPlFDrc560lrbs7toWRcMWLWOPVH/48wkJWMQSbZ/oRU7zkO4tMXRWCjc2Cv7gsydv5+JbOqOwiGeSKM1jJHW4t2HDjRrXksSuZJIRLU7bvbdKa7E70HlXLbdYYXwlHS/06C+bDT66zdJhxJ9K6NXi7d+h3Vth3aE85uvccHsYhnZv5XGme0j3lkExD9PCUl+BTpgwATabDe+8847rtbKyMowaNQqNGzdG3bp18cwzz+Ds2bPUbWFZJ1kPHaqdR9zI3h6fwvFim15ycnIM9/PwnpFIHtsPK9+4D8lj+5myQM7JyZG1g9cxpEZOTo7fa3jXmu8oxcwDF6jbojb2SPaHFp+QgGYssfKJXtw1x43s7XpIJU82WgmaObzPbU0IWmoerOKZBGrzGCkd3m1IAGwSMPPF7sxyeqBa5GoshwCIG9lbs916511/uYX38eW0333Ppk0C+nbwLB9rhg4S/pRDjxY5/647lIe4kb2Zr3PzHaWIP/S7x2vrDuWJnKiCZd50p6amYu7cuejatavH6++++y42bNiANWvWYPfu3cjLy8PTTz9N3R5ezzJUq1ZN03kYK1CtWjXd/Sy3pcrss0rVqlWTtYPlGCK1bdepxR9mavWHWg3ZQFDrWxbnsLT6hAS0YomlT/Ti/swMXsawFaGdw3OLgmOhxzKejaI2j5HSoXSOu1GdUGY5PVAtpM6gu8+7/uY2f7nFXQuJeZL0kSClPvOeZ82IE1rPFNCjJe3URVn/Xr1WxXydy9O6zipYYnv55cuX8dJLL2H+/PmIiopyve5wOLBgwQKsWLECDz/8MABg0aJFuP3227F//37cd9991GxynmXwfmqf2WcZwsPDEc6pbXrRq4Wn7cvuhIeHy77OagyR7BclLf7gKV5uPPsAHp+kB2pLoH1Lsj8C9QlP8OATLTbyMoatBoscHtk4OLY0Wime5eLWZgPaNKmNUEI61NpgBcm8BwCHfy921XnWg5a5zd885dRCYp6kMddqnWfNiBNaY1GrltjUXIxde8TndZ7WUqxj02pY4pvuUaNGYfDgwRgwYIDH62lpaaioqPB4vVOnToiMjMS+ffsU71deXo6SkhKPf3pxnrWp9r993GadF/YmNTWVW9v0okcLT9uXvUlNTZV9nYWfSPeLkhZ/8DQmw+1hGNTkgmFbjPQtyf4I1Cc8wYNPtNjIyxi2GiRzOIn8zTOWj+f/xR5VHYwL3RrJex8/1snn9UlbMnXPSVrnNn/zVGpqKpF5ktZcq3We5SZOCIxFLVrktt0DNz7s4CoPMY5Nq8H9m+5Vq1bh4MGDiI6O9vldQUEBatasiQYNGni83rx5cxQUFCjeMzo6Gna73fUvIiICAHDixAlMmjQJ5eXlrk/jo6KikJeXhwULFiA1NRXbtm1DXFwcMjIycHbfOmwZ1ROP18pC8th+yNq2BBcuXMDMmTNx+PBhrF+/Hps2bcLBgwcxd+5cFBYWetz36tWriImJQWZmJlavXo2dO3ciJSUFixcvxunTpz2uraysRHR0NE6dOoWlS5ciOTkZiYmJWLVqFbKysjB58mSUlZW5zoZkbVuC+L92xsstz2PmY41gL8pAfHw8jh49iunTp8PhcHjcv7i4GDNmzMCRI0ewbt06bN68GWlpaZg3bx7Onj3rcW1paSliYmKQlZWF2NhYJCQkYO/evViyZAlyc3Mxfvx4VFVVISoqClVVVRg/fjxyc3OxZMkS7N27FwkJCYiNjUVWVhZiYmJQWlrqcf+zZ89i3rx5aNeuHTZv3ozQ3w/iP0PCMaxJPja/1QNZ25a4rnU4HJg+fTp2pf4iu83lqylzXdeWlZVh8uTJyMrKwqpVq5CYmIjk5GQsXboUp06dQnR0NCorKz1sOX36NBYvXoyUlBTs3LkTq1evRmZmJmJiYnD16lWPawsLCzF37lwcPHgQmzZtwvr163H48GFcvHgRFy5c8Li2pKQE06ZNQ5c6l/F/3crw3l0hmPlYI1w+vAN5eXke15aXl2PSpEnIzs7GypUrkZiYiD179mDZsmXIycnBhAkTcP36dY+/OXPmDBYtWoTNST/57Zfz589jzpw5SE9Px8aNG7Fhwwakp6dj9uzZKCoq8rjvo48+iqlTpyIjIwNr167F9u3bceDAASxcuNDH7oqKCkycOBEnTpzA8uXLEV6ag5iHauO1tpex4oV2yElYiYqKCp9YW7hwIQ4cOIDt27dj7dq1yMjIwNSpU3Hp0iWPa4uKijB79mykp6djw4YN2LhxI9LT0zFnzhycP3/e49rLly9jypQpOHbsGNasWYN+rWth2qN2jIi4iDUjOnmMqevXr2PChAnIycnBsmXLsGfPHiQmJmLlypXIzs52zRFfTZkr27drtiS65ohp06ahpKTEwxbnHHF7aDE+u/s6/tEFmD24KYoPbglojnj66ad1zRHu9y8oKMD8+fORmpqKrVu3mjpHvNG/M9657QL+r3cdTHwgFDixz+8ckZaWhs2bN2PdunU4cuQIpsxfLuuTKfOX4ejRo4iPj8fWrVuRmpqK+fPno6CgwOO+/uaIEz8ux+4PH/SY873niLi4OAj+gHQOV8rfB37J1pW/1WLTrPztHs88xaZS/p40a7HPGlsCMGNxrCt/O2NzxowZKC4u9rDFmb/VYvPG0RPfNtb9mMIkf8+cORP9+vWTzd8ZGRmIi4vDtm3bkJqaigULFvjkwU7Nfb/1q5QkzF/5g9/8vX//fuzYsQNr1qxB0sFjsnPbz9n5Pvm7Y40L+FvLM5g7/HYMCzuC4T0jERUVhUuXLqGwsBCJaRl+1wXe+TspKQlJSUlYvnw5Tpw4gejpC2TvMXvp94bzd/+2tTEs7AhWvnEfhoUdweDbG3nk7x07diAyMhKLFi3CmTNnPO6rNX8HMkd8NWWu7FjcsS/d0ByRk5Pjd46YMHOhT38DwFPNLuBWnDVljlDqj/gdyZrW+N75O9A5wnktqTV+VlaWb0cTwiZJ3qd/+eH06dO45557sGPHDtc5sIceegh33XUXpk6dihUrVuDVV19FeXm5x9/16tUL/fr1w8SJE2XvW15e7vE3JSUliIiIoFIInTVRUVEYN26c6+d8RylOnr+Ctk3q8PNJmEb0aMl3lLqefOykms2G5LH9mOlWss9bB0tI9wsLLSzGrFEd+Y5S/JRzAf9YlW7amHP204blCxD92cfU2yMFzThhMQ/4G58lJSWw2+1BkU+MQiOHK+Xv5F9y0OeO1nQFMcDMfKEXtXhbMD2GiA61NgAwWd8Y8Ymc/SE2YO/Yh3XZrHduU5tnXxvzvuF50uy51ow4oaVZi5afT1/EkFkpPk9NZ7nG9YaHdTcNaOZwrt90r1u3DkOHDvV4yEBlZSVsNhtCQkKwbds2DBgwABcvXvT4pLx169Z455138O6772pqJ1gXSbyecQ4ELVpiU3N9Smuw0stzX5vZL3rhuR+deJevgVf5Ghb2WqGf5GBhN83xrsX+YM0ngcAihzv7u/W7qzHxhXstEQfBBIv8ItcGAMvMgbGpuRjrVmbKBmDCM4GdodbS16zWS2bPtWZgxnrKvS+c8LCWc54xd5plswETOPGTEW7aN92XLl3CqVOnPF579dVX0alTJ3z88ceIiIhA06ZNsXLlSjzzzDMAgMzMTHTq1An79u3T/BCWYFokOT8xC4ZPoALRku8oRc75q2jTpDbTb7jV7OPhmwtS/UJTC8sxG6gO2W8tAEx/sTvubt2Q2TfcVoxtlnFCYx7Q2u/BlE+MwiKHO/s74p3VqFGrDvdx4A8e8oVe5OKNtA73NgAwnQNJ7Iy6PzrB50GRgdjrb27TM8+SmCfNmmvN3kFIUrOaFqU1R/yo+9EtoqHhtgNFzi5Awr5P+lt6/gXo5nCun15er149dO7c2eO1OnXqoHHjxq7XX3vtNbz33nto1KgR6tevjzFjxqB3795Un1zuDm/bt9977z0A6o/y58FOLQSiJdwepmt7FAnf+bPPqcNM5PolEP00tbAcs4Hq4KF8jb8yHTzNR+6QjhO18atnHtBKMMyprGGdw4PBHzzkC73IxRtpHe7lJy9cucY0Fo1qkTuXHqi9/uY2PfMsiXnSrLmWVZzI5RnSmtW00CpTZhQ5uwCb5edf2nD/IDV/TJkyBU888QSeeeYZ9O3bFy1atGD2IJvY1Fz0mZCAF+cfQJ8JCYhNzWXSrhqzZ88G8EfZBXesVt6GphaSvvNnn1MHTwSqn6aWI2ccPq/RGrOB6uAhrpRsOPx7MXfzkTsk48SMuZcH3wcjJHN4MPiDx3wRCKR1uMf8mBWH4BWKVH1vVIuztJI7tEoryc1TwI0yZYA1xpeW/mKhg1WeUdPCcuzoQW69ZoNkul28Y7k33YmJiZg6darr51q1amHmzJm4cOECrly5gri4OLRo0YK6HbyWqHriiScABEd5G1paSPvOn31OHbxgRD8tLfmOUkzceszn9Y8GdaQyZgPVwUNcedsQYgM+eqwjJm45xt185A6pODFr7uXB98EAzRxOa75gCW/5IlBI6vCOeecXbM43l7RjkYpPKB3s9FemzLLjy6u/aOtgmWd0azH5ULDSeu21e5pYfv6lDdfby3mG162GP//8Mzp27AgAGN4zEn07NGV+xpkUtLTQ8J2afe46eMCIflpa5LcqAV1bNSDeFmBMBw9x5W7DkX0J6HyLncv5yBsScWLm3MuD7wXK0JovWMJbvggUkjrkYl4CMP357mhcN5R6LBrVolT2jNac1eUWu89rzjnytAXGl5b+oh0nLPOMmhbWY0cLSuu1ao4z7I2xGOJNd4A4t/B4P+iB9dYK7/MmjRs39vg9jfM2rHDXQvLsPC3fOfs631GKlOzzij4hgZH+MKKfhhYlm0IAFF0pR76jlPgYNqrDO67MeLaD04arOY0U+692Tf42MynNSVp9onX80vKJlefUYCYYtpYD9OZY1jRu3JhYDCrFfI82bB5eadQnrOdntTnyqgXGl5Y5nnacsFzjq2lRGjtmznVKfXNbiwam2WQV+FuRWQQethrKnTcJCwuexaBTC+lzNTR9x8InRvvDiH5a48vbJhtufJo7esUhKmepSOow+9kOYWFhPv0H3HjYytBZKdyd7VZCq0+0jF+zfSJgz2dP3h4UH4YESw7ffy6EWAyG28MwtHsrj9eGdG/JzN9GfcJ6flbrLyuMr6TjhR71qG02+MzxtHVosYEUalqcY8f9XLf0P/vMQqlvWjW0/oeetBFvug0wvGckksf2w8o37kPy2H5Ma9MpnTdJ/eU3ZjbQ5vjx49TO1dDwHQufkOqPQPUfP35cr8m6bZrxQnfYbH8cW6JxloqUDh6e7eDUMrxnJOJG9obbuo7Ls91K6PGJ2vjlwScC9jzTI8JsE4hAc45lRb6jFP/5+QqxGMx3lCL+0O8er607lMcspkn4hOX8rNZfvI8v5/ztvnvZJgF9OzT1uI6mDq02kMKflr4dmnqMGwnm5TS1vuF9bPGAeNNtkHB7GHq3a8z8E3al8yZtu/TUfS/ndmizAlip7f79+/stj2QE0r7z5xMS/UyyPwLR379/f93taMW5FRFe25YAcj53EogOOf/RHJ9acddy5VqlxyfQtOyhMWfo9YnS+OXBJwJBoNCcY+WgEcs3zqF6PnPZSAyaHdOkfMJqflbrL9bjSy9KJbK8+4imDq02kMKfFrPHvz9bqgCk5VzkfmzxgHjTbVGUytfs275e133M3Ibpr+3vvvvOUmV61HxCqp/N7o/vvvuOyn1Zl4PRq0PJf2b7A/DUwsIeWnMGqbHFg08E7FmbdtpsE4hAa46Vg1Ys3yhz5LkyNxKD/spg0YaUT1iVxVQrM8VyfAWC1hJZNHWwziH+tLAsp+oPpVh8e9UhfPqfDcztsRriTbdFUTrXGP3Zx5rvYeY2TC1tjxs3jouz81pRsvXtf7xNrJ/N7o9x48YRv6cZ5WD06FAbq2b7A/DUQtsemnMGqbHFg08E7Plyw69BcYSAxhwrB81YDreHYcIzXYnFoL8yWLQh4RPWZTF9+J+fWY0vosg8KZumDtY5RE2L6ePGC2ffeL95rJKAlGttgmIOpol4ermFkStfExUVpXkyMrP0jpa2nVqsVKZHztaRX0xFldTe4zoj/Wxmf+gZX1oxoxwMyTgxe3x6a6FpD805g+TYMtsnAvbwWCIvEGjMsXLQzv9Z25Ygeez7xGJQrQwWbZ+T8AnLsphqZaYWTI/h+o231hJZtOOEZQ5R08K6nKoWhveMRJ3Q6hi94pDH68EyB9NEvOm2ON7laz755BPNf0ujJILWEiFa2nbXYqUyPd62fvr2G9g6OZFouZBA+oNE+RY940srZpSDIRUn7n3au505pVjktNCKl0DmDK3jjvTYstKcITBOsBwhMBIHeuZ42iWRXhn5LtGSfazLSrpDYm6qU7PajQeEMihBpeZbGjmcJFpLZLHQwSKH5DtK8dDwvymOYV7KE3vTo3VDXz/JHAMQeCK2lwcZkyZN0nwt6S00es6HaWlbjxaeWTp3munlnEid3aPhEzO2A5OIk6TjhVyUpWIZJ3p9pWfcBUu8C8whWEqGBRoHeud42qUzH5i0i+jcyLqspDtG56bY1FwMnZXi84abVp5TK3fF+zyrtUQW7zq04IzZlxekKo5hXo9LyZWlu636BdPt4h2bJHk/S/Hmo6SkBHa7HQ6HA/Xr1zfbHEOcOnUKrVu31vU3+Y5Sw1to8h2l6DMhwefTuOSx/VTvqdZ2IFp4xKnj59MXMUQm8frrI6ME6hs5aPqExDjUitE4AUCsT41iRpxo8ZXecRcs8R5M+cQKBFt/Bzo3BTofkZ53SeYbpfun5VzE26sOMZt/jcxNcv0RAiB+1P3oFtGQjIEa2tv7ycMIt4dZYp7VMoasoEMNvXHCcn2kBdlxZgP2jn2YC/uMQDOniG+6KcO6HFdSUpLuvyFROivQkgZqbQeihUecOkiVC9E7prT6Rst9afqEZfk9PTqc/QLAZR9PJTwC9YmRuUmLr/T2Ea2xZWZJRIFAL4HEgZH5iFXpTBJzI8uyku4YmZuUSixdvVZlzCgZ8h2l2Hg4T7XclRXWVVrGEA86jOQWvXESbg9Dmya1cfL8FS5ymey4luiVVQsWxJluisSm5rqeDhpiA6Kf7oLhPSOpttm2bVuq91dsl8K5E7O0kMapg0QfBTKmtLSr9b7B5hN/KPULT+esAvEJi7lJbx/RGFtmzMECc1ibdhqv9rvTbDMME0gccDUfUbLFPZZt+GN7Ock2lDAyN8n1B3Cj3BnJ54C494837n1jhRzuLBvmLsW7bJjZOozmFr1xwlsuUxzXZ8iO62BDfNNNCbPKcV2/fp3q/ZWgce7ELC2kceow2keBjil/7eq5b7D5RA3eS4U50esTVnOT3j4iPbbMLIkoYE+wlAwLJA54mo+8SwqRsMWMspLuGJmbWJQ78+4fd7z7xrI53EubmTpI5BY9MctjLgu3h+HjQTLjeiubMn5WRXzTTQmzynEVFBRQu7c/SJdYMFMLSdx1GOkjI2NKrV099w1GnyjBe6kwJ3p9wnJu0tNHpMeWmSURBewJFt8GGge8zEdOW4p/3YeufQYQscWMspLuGJ2baJc7Uyor9c/Bt+PxruEebVghh2spG2amDlK5xRmzC1dvxF+HPaH4t7zmsi6tzCvjZ1XEm25KmLXdq0ePHqq/J1E2Sg2SJRa8tdC2XQ96bPHWEWgfGR1Tcu3mO0pRdLlc8339jS+roEWHUukS91JvtEuKaBlnen3Cem7S2kdOHaTinKcttwL6BItvjcyxPJXJe7j33WhPaJup0lxMs6ykO0bzHu25SKl/7pHpH9o5nMT8raW/zFyLkPRnuD0Mwx66S7WveM1lvNrFM2J7OSXM2u61bt06xd+RKhvFCnctPNmu1xY1n+iBVom3MSvTIUk3zkz5uy8pLWajRYd3fwNsS71pHWd6fcLTVlR31q1bRzTOedUpoEOwlAy7meZYrWgtI0ULo1rUSniRQE+uojm+SM3fcuWohnRv6dFfZsYJ6dziTwvt8RMo3nYBEhd28YwoGQa6j4dn/Zj/srIy1KpVS9YOXkocacWphSfbA7FFySdGbKBR4i0EwPQXu+Pu1srfHpDWYhZ6dJhR6k3POAvUJ7yVIMk5W4yHp+4lHuesdQZbCSvecfZ3Zm4BOkQ0N9scw9yMc6wWzFwHGNHir4QXSbTkKlrji6R/tNyLhzghlVvUtLAcP3qQs8sGIMVku0ggSoZZGLlyHDRL2Hz99deyr+spT8C6xI5Se04tZpVnkrMrEFuUfBIoekq8KPWtUhmTRnVCVe9LWotZ6NFBqtSbHvSMs0B9ojaOzCizNWn2YipxzrIUncA8couC4+E9pOdYs0rm6dXhz04zyzQa8YlSrk3LuWjMKBm05CpaOZykf7Tci4e1CKncoqZFafyYXZor7dRF2ecsmG0X74gz3Yyh/dj/cePGyb6u9ewF67IEau05tZhxboRkqSgln9BGrW8D7VOztJBGjw4zxp+eNkn7xKzSJP98901slfl2Q5wPE2jhaH4xBtxlthXGIRnPZpYZ0qNDi51mnh814hOl0kpvrzqEK9euE/WHlvJktHI4Sf8cOePwec37XsGyFgHUtWgpn8aa2NRcjF17xOd1ka/9I77pZgiLx/5HRUXJvq7lDArrsgT+2nNqYX02k3SpKCWf0MRf3wbap2ZooYEeHWacDdbTJkmfmFmaZMH0GHEGWxAw3+74LShK1ZCKZ7PLDGnVodVOM5/RYMQn3iXUnNDwh5byZLRyOCn/5DtKMXHrMZ/XPxrU0eNewbIWAQLQYuKhYGe8epsQYgPur5kj8rUfxDfdDGHx2P/XX39d8Xf+SoqwLkvgrz13LSzLoZAuFaXmE1po8WUgfWqGFhro1WFGOR6tbZL0iZmlSV5//XW0aNGCm7JHAmsRLKVqSMWz2WWGtOrQY6dZZdGM+mR4z0jUCa2O0SsOebxOwx/+ypPRzOEk/KNU/qxrqwYePwfLWgRQ16KlfBpLlPwz7fnuuKd5cFS3oYn4ppsBzrNKdWpWQ4jN83ekt2Msj9+kei5K7QyKc3sQTfv0tLdhwwaPc16szmZq6Qd/trjbvWHDBprmyqLVl3r71IgWs84WyhGIDhJn6Wm0SXJ8sZ4D3HHqIBnnPI05AV2CZWsjqXg2M5YB7Tq02umMZQDMn9FAwic9Wjdk4g+5/gwBPNZVNDEyf7uXMHVHrp/MWFe5QzK3qGnx50/WKNkT0SjMdJ9YAfGmmzLuJRSGzkrB0O6tqG2Pik3NxYxTLQIu18B6+5a/9orsHU0pE2a0H7zLZhTZO9I0VxZavrzrrrsC+jueSr4BgevQAmutJLWYWZqEtE94G3MCugRLyTBScWB2yTytOrTYaXYsk/CJljJYJPBXXo1m7jOC3hKmZuogPR7VtJhdLk/JHrnydGasda0G19vLZ8+ejdmzZyMnJwcAcOedd+Kzzz7DoEGDANx4zP7777+PVatWoby8HAMHDsSsWbPQvDkfZUPkziqtO5SHuJG9cfVaFdHtUd7nLJznhfp2aKqrDdbbt5Tay3eUYu7BS4b1kLbLH3I+n3fwEkYMLGW+IKThy6KiIt1/o3Rmj5Uv5QhEhxbM0EpKi9xZLZsE9O3QlMj9/UHSJzyOuZsRljm8z21NSJpuGiTjwKzt2IA+HWp28hDLJHyS7yhF/KHfPV5bdygPHwzsSFxH3w5NYbPB9QGqhD/6jFbuM4K3jyUAIRIwQ6WEqVk6aIxHf1rU/GlGPhveMxKdWtTzKE9n5lrXSnD9Tfctt9yCCRMmIC0tDT/99BMefvhhPPXUU/jll18AAO+++y42bNiANWvWYPfu3cjLy8PTTz9tstV/oHRW6eq1Ks1bk422Fcjj+2lu45bTJtee3DkWVuVB1OzyB2/lHUhviS4t1b+VKtCxSXNrcCA6tMCyrI2rf4rJaDF77Lr7xKjvWZcXEtvY5WGZw4OlZBjpucmsknlOHVpjQ8lOLbFMO/5I+ESuxBKNOSnfUYqNh/MU26KV+4yglHsk6cbv5Pxqlg4aucWfFn9tmpF/5MrT8VDKjHe4/qb7ySef9Ph5/PjxmD17Nvbv349bbrkFCxYswIoVK/Dwww8DABYtWoTbb78d+/fvx3333WeGyR4EUkIh0BIfZpbT0IoebXJlEnjTI4dcqYsQk8s7aEGrb9q3b6/73izjQCuB6NACqzh07x8baqJ2u1zD/WP2HOL0CQnfs9Tibe8/H21DvA2rwjKHB0vJMFpzE2vat2/PJJZZlEUz6hNWJZbc+0KprXocji85H9two6yakl/NihMt5cz04k+LWgyYVRZQS3k6gS9Ev+kuKSnR/E8vlZWVWLVqFa5cuYLevXsjLS0NFRUVGDBggOuaTp06ITIyEvv27VO9V3l5uWF7tKD3TJWREh9/nPuQNLXFGr3awu1heKRBoaXKBymVuvhTvSLu7dbqm127dum+P8s40EogOrTA4hyl3FY8Ev1j9hnQXbt2EfM9Ky1y9n654VeibbDECjlcKX8HS8kwWnMTa9b/mEQ9llmVRTPiE7USSyTnJO++cMe9z3gcX94+dr4xUfOrGTq0ljPTiz8tSjEAwLSygFrK0wl8Ifqmu0GDBmjYsKHqP+c1Wjly5Ajq1q2L0NBQ/P3vf0d8fDzuuOMOFBQUoGbNmmjQoIHH9c2bN0dBQYHqPaOjo2G3213/IiIiAAAnTpzApEmTUF5e7qqbFxUVhby8PCxYsACpqanYtm0b4uLikJGRgWnTpqGkpMTj2gsXLmDmzJk4fPgw1q9fj7rnjmD24KZ4sUUhfnijG7K2LXFde/XqVcTExCAzMxOrV69G3PY9sltIvpoyF5WVlYiOjsapU6ewdOlSJCcnIzExEatWrUJWVhYmT56Mp7o0w5BqB7HyjfswLOwIHoyoifnz5yM1NRVbt25FfHw8jh49iunTp8PhcHjYXVxcjBkzZuDIkSNYt24dNm/ejLS0NMybNw9nz571uLa0tBQxMTHIyspCbGwsEhISsHfvXixZsgS5ubkYP348qqqqEBUVhaqqKowfPx4HMk7Kaps0azFKS0s97n/27FnMmzcPL/Vuiy97SRh1+3X8Z0g4Cg+sR3Fxsce1DocD06dPx9GjRxEfH4+tW7ciNTUV8+fPR0FBgce1ZWVlmDx5MrKysrBq1SokJiYiOTkZS5cuxalTpxAdHY3KykqPvzl9+jQWL16MlJQU7Ny5E6tXr0ZmZiZiYmJw9epVj2vTf/Pd0gUAjXAZFy5c8Li2pKQE06ZNQ0ZGBuLi4rBt2zakpqZiwYIFyMvL87i2vLwckyZNQnZ2NlauXInExETs2bMHy5YtQ05ODiZMmIDr1697/M2ZM2ewaNEi7N+/Hzt27MCaNWtw7NgxTJkyBZcvX/a49uds+a1o0xauRFFRkce1Q4cOxdSpU5GRkYG1a9di+/btOHDgABYuXOhjd0VFBSZOnIgTJ07g+vE9iHmoNj65NwzvdyxGz8bXMXHiRFRUVPjE2qyl38va8+vp8x7XFhUVYfbs2UhPT8eGDRuwceNGpKenY86cOTh/3vPay5cvY8qUKTh27BjWrFmDiIgI7N+/H4sWLcKZM2c8rr1+/TomTJiAnJwcLFu2DHv27EFiYiJWrlyJ7Oxsv3NEgwu/4v+6lWHCoy3w12YnMahjA9U5YtOmTTh48CDmzp2LwsJCj2u954idO3di4+7/yvbPiXOX/M4RZWVlHvcvKCjwmCNqnknDgiEtMaxJHraMvMdjvqI9R/Tr1w9zV8TLajued1F2jkhLS8PmzZuxbt06HDlyBDNmzHDNEcN7RmJY2BH858XOeK15Du4MKyE+R3w1Za6svVbFCjlcKX9XShImzFhANH/rjc2UlBQsXrwYp0+f9rhWS/52xuZf/vIX2dg0M3/n5uZiyZIl2Lt3LxISEhAbG4usrCzExMQo5u9GkR0V1zPOa7Xm76xtS7DznfsxpH4Olg5vAyk7BYmJidiw64Ditlu9+buwsBBz587FwYMHsWnTJqxfvx6HDx/GzJkz8eSTTwacv4/nF8uuC55rdRn3Nq0ynL/Pnz+POXPm4Mf9h2XbubfGGSSP7YesbUtw6dIlXL58WXf+Xr58OZKSkpCUlITly5fjxIkTivl74cKFOHDgALZv3461a9ciIyMDU6dOxaVLl1Tzd52zhzH3yeZ4ofk5RD3RTvZ4YdLBG/l7x44duP3226nkb7U5Qm6+B4Cwq+cMzRFnz571O0fkJsZi5zv34/FaWS5/Hjx+Rnb8T5m/jMkc8fMu36eVV0oS4ncka5oj1PK381oz1vhZWVm+TiaETZLIrRB2796t+doHH3xQ03XXrl1Dbm4uHA4Hvv/+e/znP//B7t27kZ6ejldffRXl5eUe1/fq1Qv9+vXDxIkTFe9ZXl7u8XclJSWIiIiAw+FA/fr1Pa7Nd5Ti5PkraNukDvVvfPIdpegzIcFnC0ny2H4AoMmOqKgojBs3jqqdgaCmTUkPr1qUUNI4LOwIoj/72DzD/KDHN0o+IRkngYwVvQQ6tljPB3JtsegfM4iKisJrY943XZseH8v5wnatFDlTnpPNJ7xjhRyulL/bvLsGKZ8P5joGtIwtq+U9J97aPvlyImJLO1ONZbn4CwEw7cXu6KHwAK5AMOITVvO11r6wwvj6+fRFj4d0Ab59ZoYOWr4MVIuWfqJJsK5FSkpKYLfbqeRwom+6WTBgwAC0a9cOw4cPR//+/XHx4kWPT8pbt26Nd955B++++67meyp1sBlnJWJTc/Fp3FFUSpLsFhKWZzZII6fNijrUsKpGI3bTiBMe+5HlfOCvLR77hxRmagvEx972jnu0Nf76cGdLvulmAekc7szfoxbtwYxX/kTJauOYdfaSBUraWMSyexvOIkYS+Orj91enY+3BP55c/szdrRAz7C7i7VihL/whdy6dpxzHypf+4KWfeOkPklj6TffVq1eRm5uLa9euebzetWvXgO738MMPIzIyEt9++y2aNm2KlStX4plnngEAZGZmolOnTti3b5+uh7DIdbCZn+DkO0pdpTMA6LKD908x3bX560fetSjhrdEqOrT4xlsLzTjRM1b0otcnLOcDrW05+2f98v9wvZNCK+4+oel7JYz42N3eOrYKagnbDHjP4c78zfM33SR2E/GKvx1eLGI531GKtJyLrgdvudtBYo62wjfd7u2p9cWC6THcji+lb+vjR92PbhGeR1pu5m+69fQTTcQ33fqh9vTywsJCvPrqq9iyZYvs7ysrK/3e45NPPsGgQYMQGRmJS5cuYcWKFUhMTMS2bdtgt9vx2muv4b333kOjRo1Qv359jBkzBr179w74yeUHThShc9saCLeHqT6in/ZgCreHudpIyT6vy47Ro0dTtU0rStvo3LX5w58Wllt99eCtUY9PzNSkxTfeWmjGifPvT56/4vEzCfTGCcv5QKmttJyLeKKbbyzd/vabRNvXA8nx6u4TPfMEKbT4WMu8VlJSwcxmmlgth7PKz4GgZ/7gJYdrRUnbw089D4BOLHvHYbg9DI3q0pujjfiE9VrSX1/wNr7cfalUOuzqtSqfvzNDBy1fkliPVAE4faGU6ZtuM98nWRVqdbrfeecdFBcX48CBAwgLC8PWrVvx3XffoX379li/fr2me5w7dw5/+ctf0LFjR/Tv39/1kINHHnkEADBlyhQ88cQTeOaZZ9C3b1+0aNECcXFxAdv82nc/oc+EBMSm5roeh++OGSWr9NqxbNkyBlapE5uaiz4TEvDi/AOu/gwENS2k2mCBVp9YQZO3FppxQrM/9MYJy/lAri3gRvkUuT4wK+ZJ+8fsucufj60QnySxWg7nuaSknvnD7DjQi5K2n3ZtptKeUhzSnKON+ERpPj/8e3HgBvlBrawVT+PL25dHzji4jhMa5cIAMusRQHmNQAta/RHMUHvTnZCQgG+++Qb33HMPQkJC0Lp1a7z88suYNGkSoqOjNd1jwYIFyMnJQXl5Oc6dO4cff/zRlawBoFatWpg5cyYuXLiAK1euIC4uDi1atDBkt/OR+wBMLZ/jRG/pG60Pt6EFyRIeSlpYlQkhhRafWEWTtxZapZlo94feOGFZTsvZlvfkrNQHZsQ8Df+YPXfxUJqIJ6yWwz978nZuv13RM3+YHQd6UdL2RH/y5+vV4pDmHG3EJ6xLK/kra8XL+JLz5aStmfh4UCcu44RWuTAg8PWI1jUCDWj2RzBDbXv5lStX0KxZMwBAw4YNUVhYiA4dOqBLly44ePAgrWaJ4NweMbxnJPp2aMr8bKE3euzIzs5Gly5dGFrnCcntJkparLalRYtPrKJJTguNOKHdH4HECcv5YHjPSNQJrY7RKw55vC7XB2bEPA3/mD13Aco+tkp8ksRqOfyZHhFmm6CK1vmDhzjQi5y2devWEdfhLw5pzdFGfdLlFrvPayyPJwFA11YNAPAzvpR82bVVAySP7cddnPjrVyMEuh7RukagAc3+CGaovenu2LEjMjMz0aZNG3Tr1g1z585FmzZtMGfOHISHh9Nqlgju2yO8zyOZdeZW67momjVrqv6etv3ObS/eD1bQs93EaeMVqQa1NgIlkP7z5xPAXE16UNJC+tyeXH+EAMT6Q4tP5GB51rhH64aaxkSgWoxAY7zq1UFrLpPzsVXikyRWzuG8omX+MCOeSeCtzV0HqVjVEoc05mijPmE5f/hri5fxpWRn7ZohmsYKbR3eY5amD7VokYshrWsEGtBeowUr1LaX/+Mf/0B+fj4A4PPPP8eWLVsQGRmJadOm4d///jetZg2jtp3FCmf6mjdvrvg7FvYb3eLlbuO4A5C1keVWXyXb9PSfmk+cmKVJL1q0kMDZH+7HliQASccLidyflQ4jaB0TZmihMV716GA9F1slPkli1RxudawwN2nBqYNkrJoVh0Z9knS80KOWss0GqseThnZv5fHakO4tXW3xMr7kfDmke0sMnZWiaazQ1CE3ZmmOPX9alGLIzLwkN876tq4V1DmRBNS+6X755Zdd/9+jRw+cOnUKx44dQ2RkJJo0aUKrWUMsHNETd7ZtLjtolM4S9e3QlKtBlpaWhh49evi8ztL+QLd4edsoQdlG1lv/jfSfkk+84eU4gxpatZCgb4emsNngWqyojQe9sNRhBC1jwiwtpMerVh1mzcVWiE+SWC2HFzhKg6JEm1XmJn+kpaWh5W13EI9VM+LQiE+c85X7TlybdCO/0SDfUYr4Q797vLbuUB4+GHjjrC1P48vdl7VrhmDorBTNY4WWDrX8QmvsqWnxl+/Mykty42z3qVLX8xUE8lB70+1N7dq1cffdd7NqLiB63doI9evLD5ZAzvSZsRX9qaeekn3djLIVeu+r10aWW32N9J+ST+RwP0Pq/jMvaNFCatzTHLN6fGI2/sa5ES1GfUUyBrXq4KWc480G7zk8t6gUHfg+1q0JGnOTWWuRbB2xqsfGQOMw0H4w4hOl8k605it/8yNvuc/pS6XyuJsO52Nw13CfvqKlQ61kZ6O6N8ZO73aNibappkVLvjMjL8nZJcEW1M85IQHRN93vvfcevvrqK9SpUwfvvfee6rXffPMNyaapo/c8R2xqruvTqRDbjSehD+8ZSd3O+fPnY9y4cT6vt21SBzbA89NW8HX+gufyA0bO8yj5RA6zxo1W/GkhaT/NM1R6fMI7gWrhbaxp1SE3LoAbJXhIL4ZuNqycwyMbB8dCj/TcZOZa5LUx72uaw1nYaKQNIz5hPV/5a4/X3Kdkd9SmX/Hvzb/6+IuWDjk7bLhRjovW+FTTwmu+k1uv2yBxsV7nGZskSZL/y7TRr18/xMfHo0GDBnjooYdgs8kUkgNgs9mQkJBAqlnDlJSUwG63w+FwqG5Pi03NxadxR1EpSa6zE3KBl+8oRZ8JCT6JJnlsP9M+Acp3lOL+6ATPN902IGXsw1x8KiXXZwDwyeOd8GbfduYY5YVW/wcKj+NGDzTsp93nNytWH2tzd2cjeotnuRJe7NeaT3jEijncyv1NGx7i3N8czsJGs/uB9XzF8/yohvtY8Yal/e52hODGl1XuFrHuS978aYX1uhFo5hSi33Tv2rXL9f+JiYkkb80FWs9OmLn9MSoqSvYTs5Pnr8B7GpMkeluc9GKF8gOBnp1R8ok3VihLpKaFhv20zitp9YkVCEQLj2NNjw6WJXhuJoI9h1sBknMTD2sRf3M4CxuNtmHUJ6znK7X2FkyP4Tb3OcfKpsP5iNr0q8fvvPuLZg53H7NFV8qpl+Xyp4W3fKe0Xv85YQPQ9x3m9lgJKk8vr6ioQPXq1XH06FEatzeVcHsYerdrLHseKSX7PPIdpa7tIO6w2ib9/vvve9jixKhNcvckiZx9ITZ+tr879QOQ9b8a77//vqbrWIwbo35U00LLfveYIzUOtfqEJLRiKBAtZs5RSujRwaP9wUQw53DeITk3mb0WcaK0bgICt1HPfGq0H4z6hJUfnH1Sp2Y1xfbMyH16CLeHYXDXcL/9RVKH3FhyjllnWS41W4ziTwtv+U52vQ7gw7dGmGKPHLTfswQKlTfdNWrUQGRkJCorK2ncnju8H+efdLzQtMf4j4pZTry0gFmlxh6qk8/Ft1ZG9c+aNUvTdbTLP5Dwo5oWK9jvRKtPSEEzhgLRwmMJLD06eLQ/mLjZcjhPkJybzIwTmnlP73xqtB+M+sRfGS8SuPfJ0FkpGNq9laxe1rkvELT0Fykd/sYSixjyp4XF+NGDs0+8S7p+NX+tKfZ4w3N5Z6Jnut1ZsGAB4uLisHTpUjRq1IhGE8Qwsn9f7awQAKaP8ddybinfUarLJtZnodztu3zuDNq3b0+8Db32GNWflZWlS4deH2m9Jwk/atHCs/1O9PrECLRjyIgWGr4KlEB08GS/k2A5Y2yVHB4s/e2ExtxkRpzQyntG5tNA+8GoT2jnAKX7x43sjavXqjz0ssx9gaKlv0jo0OMXmjHkT4vZzyTQalOIDdhr8nOiSPQVzZxC/JvupKQkVFRUYMaMGUhKSkLLli3RsWNH3H333R7/ggV/Z4WcTxdksc1BzRYnatu8Ar0nSdz7bM3un03fGkJC/8GDB3W1qddHcnhvrSHlRy1aSNjvDelxqNcnRrYq0Y4hvVrcoeGrQNGjw8hxD4E6Vs3hBZxtIwwUI/GshBlxTiPv5TtKsfFwXsDzaaD9YNQntHOA0v2vXqvy0UtjfJFGS3+R0KHHL+H2MLRpUhsnz18hvi71p4X1OlwLsqXw/vecKDPhsa/cIV6nu1+/fsjPz8eQIUNI35pL/JU1YlmuQ64smNFzHzTLNinxR5+F4T8TEkwtZURCf9OmTSlYpozcmOvboSkRP7LW4oT0ONSjw2gM044hs3xCGq06eCt1FmxYNYc/OiUJE1+41/Jj4WaLZ624x703tNckRrXQLocqWxJW4Zk4VhhfWvSQ0KEnN9PMO/608FhOl9dSZma8Z9ED8Tfdzt3qn3/+Oelbc4nzbIN3SQznQ5/ck0SVBHwadxR9OzSl8olzuD0Mr3cLw8LDZT62GLmnkj4asO4zf5DQHxoaStFCT5T6L3lsPyJ+ZKnFHdLjUKsOEuORdgyZ5RPSaNHB2/wQjFg1hwfLWLiZ4lkr3nHvDotz6ka05DtKMXHrMZ/XPxrUke44VTg4atnx5aWHhA6tuZl23lHTYtr48UO4PQwfP9bJp5TZpC2Z+HM388+bs3rPohfib7oBKNb2DFaUSmKYUa4jouIMksc+R/TsCa2yTXLwWMrIqP7s7Gz06dOHknWeqPUfCT+y1OINyXGoVQep8Ugzhsz0CUm06OBxfghGrJrDg2Es3EzxrBWlEkX/HHw7Hu8aTt3fRrSwKIcqWxIW8iVhrTC+tOghpUNLbqadd9S08FxOl7dSZk5YvmfRC5U33a+88orfT6Hi4uJoNG0a4fYwH8easc3hoYce8rAl31GKk+evoG2TOoa/8WYxcOvUrAab7UYNcSdmbQ3x7rtA9T/00ENkDVPB35gz6ketWkiNO29IjUOtOkjGcCC2a+lHluOLFHK6tOjgfetYsGDVHB4MY4FUPNOag7VCcl6Si/sQAPe0achEmxEtLOYspTZq1wxBSvZ53fOs2WhZB5LU4S830/ahmhYtbZsV6zzmY/e+MHObuxJUSobVq1cPdrtd9d/NAItSA94sXbrU9f88PzZfjtjUXAydleIz0ZqxNYRk37n7hDa0x5wWLVYYd1p9YkYMO9HajyzHFwmUdGnRYaY/biasmMODZSyQiGce5mCS85J33ANAFYChs1KYaDOihUW5J7l5cUj3lhg6KyWgedZMtK4DWa+raPpQTYu/nGdmrPv2i2RqKTMe5j1/EC8ZFhISgoKCAjRr1ozkbalCu+QIy3IdVVVVCAkJ4bLEgBqy5QcAxI+6H90iGppui5G+c/qEJbTGnD8tVhl3en3CuuSOnn40Y3wFipqu5vVCNevgsVSYE6uXsLJaDnf2d2ZuATpENDfbHMMYjWde5mAa89LPpy9iiMwbMtrajGhh6Q/nvFi7ZgiGzkoxPM+yRs86kGXeo+1DLVrkcp7ZsW52+7RssVTJMKueBSOBUlkhmuU6vNv897//DcC8x+YHWlpJtvwAgKvXqoi1YcQWub7TaofTJyyhMebyHaUY/eU0Vb28l2twotcnNMq4qaGnH80YX4GipsufDvf+M7vUGe05yEysmsNbcPbhS6AYjWdecj+NeenKtUp4f01UKUnYdDifaiwa0cLSH8558cq1yoDnWTPRsw5kqYO2D7Vokct5Zq+30k5d5Ga9Z3ZfaIXa08tvNswoYyPX5qeffgrA7FJf+vtA3l7fkhcs+llL3+mxw+kTK/OH3vbYqlLGjcczPnKw9onecaunH600vtR0qengqUwYT7bQ4GbN4bxgNJ55yf005iWlMkVRm37Fvzf/Si0WjWhRLK10hl5pJbWSWzznCz1lqFjqoB1TgWoxs5RYbGouxq49Ylr73lhl7Un8m+5du3ahUaNGAIDRo0fjwoULpJvgDqVyAjQ/eVVq8//Gfw2A/dlHo30gZ+/9NXM97GXVz/76Tq8d0dHRRO1jjR69Vjlzy9IngYxbPf1opfGlpktJhxnzqxI82UKLmzGH84TReOYl9zvXIiSRO9vthGYsGvFJuD0MHw/q5PP6pK2ZbOeN//mH53zhLEPlzaQtvn3FUgftmApEi5mlxJwx7/3xrA2Saes9q6w9iX/T3a5dO1SvfuO2K1aswEcffYRGjRqhS5cu2Lx5MyIiIkg3aTpmlLFRavO+AU+4frZaqS9veyschcTb0Ipa3+m14//9v/9H1DbW6NXLc7kGJyx9Eui41dqPVhtfSrqUdPBUJownW2hxM+ZwniARzzzkfve1CEmc2jYdzkfUpl992qURi0Z90qUV29JKaiW3eM8XWstQsdZBM6YC0WJmKTGltr94NNLUXV9WWHsS/6a7U6dOaN26NV588UWUlZXh9OnTAICcnBxUVFSQbo4LnNsa3KG5rSHfUYqiy+WybeZmHPR4jdXZR1J94G5vYmIilTac+DuXqdR3eu3w1mE19Op1lmzgddIDlH1C46yukXGrNAbd7WQxvkj3i5wuJR2s51cl1OZd3rawGeFmzOEkIBUjpOLZ7NzvXIvQmFPD7WEY3DXcp90QmSNpJDDqE9ZzmFp7vK9H5GyX86sZOpwxBYDomA5Ei2w/gc7419r278d9t5uzxuznvfiD+Jvu4uJirFmzBj169EBVVRUef/xxdOjQAeXl5di2bRvOnj1LuknTYbmtwflI/DEr0yFJN87puLd5d6e2xNvUAo0+aNeuHbU2jJQW0GuHtw6roUevFUo2API+oWU76djwtvN0jVuI2Km1PVo+VYoTHraN+Zt3eU3wgXAz5nCjkIwRq+ULpfi8u1NbqnOHs133neaSBCQdL1T+owAx6pOk44UeD4Cz2UB13lArccX7+NLqV7N00BjTgWhx9ZPbaxLojH+ltr1L+M3PacDtmo8XiJcMKy0tRVjYjYmkYcOGSEtLQ35+PgYMGIDOnTvjl19+QUREBDIzM/3eKzo6GnFxcTh27BjCwsJw//33Y+LEiejYsaPrmrKyMrz//vtYtWoVysvLMXDgQMyaNQvNm2svHULq8fC0y9golVOY/mJ33N26IcLtYUhISMDDDz9MvG09NpLqAyUtRtsgVVpAqx1m+4QU+Y5SxO9IxtBH/iSrl6fyEf7w9gkL20nEhtIcsPeTh5nNObR86i9OzCoTpmXedcfqJcOslsPN7m/SMWLVfOEdn99v3omP9pRRn1Pvj07w2EpNY34y4hPWc7ZSm85++TVtH/fjS4tfzYgTWvkwUC1mr7nMKuFHG0uVDGvQoAHuvfdevPfee7h27RpKS0vRp08fVK9eHbGxsbh48SIWLFig6V67d+/GqFGjsH//fuzYsQMVFRV49NFHceXKFdc17777LjZs2IA1a9Zg9+7dyMvLw9NPP01aliZolxVSKqfQqE6oq83CQvqfcqkh1weBbi9T0mK0n7WUFtBis1Y7zPYJKcLtYWhceUFRr1VKNgC+PmFhO4n5QWkOIN3HzvHPsiSIvzjRstWeBlrm3WDiZs7hgUB67rBqvvCOz+N55OcO71iXO7tMY34y4hNWc7a/Np39YoXxpcWvrHXkO0qx8XAelXyoRYtcnjN7zaVUwo/HNR8vEH+Q2u+//459+/YhJSUF169fR48ePdCzZ09cu3YNBw8exC233II//elPmu61detWj58XL16MZs2aIS0tDX379oXD4cCCBQuwYsUK16dEixYtwu233479+/fjvvvuIy2PKv5K0Wh5JP7dd9/N0mS/GCmvQ0uLv34kXRKIN58YQU2LVUo2AL46rGK7nJ2kzzG6j38b4FN6hla/BBInvJQQDCZEDtcH6fERLPnioXvuwH+yTxLrF7lY79uhKZPYNOITtfJdtFArJdXEAuNLSykslnHiPvb82RUI/rQo5Tmzc5OZJcusCvFvups0aYInn3wS0dHRqF27NlJTUzFmzBjYbDZ88MEHsNvtePDBBwO6t8Nxw8HOciZpaWmoqKjAgAEDXNd06tQJkZGR2Ldvn+J9ysvLUVJS4vHPbLSUotFytnH9+vVM7VbDaHkdWlrU+pFGSSCefGIUNS08nL3VircOq9guZ+dDdfKJbtd0H//OXO58aArNftEbJ7yUEAw2eM/hvOVv0uMjWPLFvp1biPWLUqwDYBKbxH1C9FCnJ/5KSfE+vrSWwmKlw3vsuUNqvKlpUctzZuYmeT9JTEqWWRnib7q9sdvtGDZsGGrUqIGEhAScPHkSI0eO1H2fqqoqvPPOO+jTpw86d+4MACgoKEDNmjXRoEEDj2ubN2+OgoICxXtFR0fDbre7/jlLoJw4cQKTJk1CeXk5oqKiAABRUVHIy8vDggULkJqaim3btiEuLg4ZGRmYNm0aSkpKPK69cOECZs6cicOHD2P9+vXYtGkTDh48iLlz56KwsNDj2qtXryImJgaZmZlY9P0mxW0iUVFRqKysRHR0NO5rJuHd9hfw6X11MPnBWpCyU5CVlYXJkyejrKzMtQCJiopCQUEB5s+fj9TUVGzduhXx8fE4evQopk+fDofD4WFLcXExZsyYgSNHjmDdunXYvHkz0tLSMG/ePJw9e9bj2tLSUsTExCArKwuxsbFISEjA3r17sWTJEuTm5mL8+PGoqqrCV1PmymqK35GM2NhYZGVlISYmBqWlpR73P3v2LObNm4f77rsPmzdvxrp163DkyBHMmDEDxcXFHtc6HA5Mnz4dR48eRXx8PLZu3YrU1FTMnz8fBQUFHteWlZVh8uTJyMrKgpSdgskP1sKn99XBu+0v4L5mEqKjo5F97pKszZt2/xc7d+7E6tWrkZmZiZiYGFy9etXj/oWFhZg7dy4OHjyITZs2Yf369Th8+DBCQkJw4cIFj2tLSkowbdo0ZGRkIC4uDtu2bUNqaioWLFiAvLw8j2vLy8sxadIkZGdnY+XKlUhMTMSePXuwbNky5OTkYMKECbh+/brH35w5cwaLFi1ybetcs2YNjh07hilTpuDy5cse154/fx5z5sxBeno6Nm7ciA0bNiA9PR2zZ89GUVGRx7X/7//9P0ydOhUZGRlYu3Yttm/fjgMHDmDhwoXIy8tD1rYlSB7bD4/XysKu9x9ATsJKnDhxAsuXL0dSUhKSkpKwfPlynDhxAhMnTkRFRYVPrC1cuBAHDhzA9u3bsXbtWmRkZGDq1Km4dOmSx7VFRUWYPXs20tPTsWHDBmzcuBHp6emYM2cOzp8/73Ht5cuXMWXKFBw7dgxr1qxBx44dsX//fixatAhnzpxBVFQUhveMxLCwI1j21554oV4G7m1ahWXLlmHPnj1ITEzEypUrkZ2dbdocsXr1auzcuRMRFWfw9q3nMW3IrRgWdgQz33/JY444deoUli5diuTkZCQmJmLVqlUec4T7/b3niKXx23zGvwTgwZonMf+Fzni9+SncUctBbI6IiopCVVUVxo8fjyeffBJLlizB3r17kZCQ4HeOmL44VjZWj+acIzJHrFq1ComJiUhOTsa1Y7ux6uUOeLJONnZ/+CCyti1x/c3p06exePFipKSkYOfOnYiLi0MwwVsO5zF/207ux4Q/1cS4++vi7VvP4/4WNo9r9cTmyJEjucjf7rGZm5urKzad+bte4VH8865r+PeAZni9+SkMbF8/oNhUWkts2HVAV2wGkr9nzpyJ559/PuD8fTy/WLZ81/yVP1DJ3yvW/yj7BvHnhA24dOkSqqqqFPO3+30rKiowceJE5vl72sJVsvYf37fDlb937NiBe+65xyN/O+97/fp1TJgwATk5OUTy9y+nCmXtee1uOz67+zrqnjuiK3+npKRg8eLFOH36tOvakpISxTli4eqNsmP/qylzUVBQgJL0bZj5WCO82y0E47qV486wEiZzxIlzl2X6xYaQi6c1zxFpaWnU1vju+Xvp0qU4deoUoqOjUVlZ6fE3cnNEVlaWr8MJQfxBau6cPn0arVq1QkhICDp37owtW7YEXOPzrbfewpYtW5CcnIxbbrnxtN4VK1bg1VdfRXl5uce1vXr1Qr9+/TBx4kTZe5WXl3v8TUlJCSIiIpg9iMVZUqltkzquT4RIPRAhKioK48aNI2KTUZQeIDLtxe7oIfMAIm8C1WIEGg+m0KODhh9IYoZPaOCug/c+9wdJLWY+mEXv2DL7ITJKmP1gL5LwmMPNzt+0CcY51ihKa4n4UfejW0RDIm2oYUQLa9v9zYtKWnjJg1ofPMcqTljkGTUtvOY5ObtskJDySX9LrqPcoZnDqb7pJsXo0aPxww8/ICkpCW3b/lESKyEhAf3798fFixc9Pilv3bo13nnnHbz77rua7s9ykaR2BjE2NRefxh1FpSS5tomwKDRP81ykuyZncQEJ9M5fkiAY/SCQJ5j6nJQWs8Z/IPBoazC96SYFzRwu+vvmwD3WnVhlzmZtu955kbc8GJuai7Frj7h2CNgATHjGPJvMzjPvr07H2oO/u35+5u5WiBl2F7P25fDxkQ2YYIFY1IKlnl5OEkmSMHr0aMTHxyMhIcEjWQNAjx49UKNGDezcudP1WmZmJnJzc9G7d2/W5vrF3xnE4T0jkTy2H1a+cR+Sx/YLaPA6t02QsskoTk0zXugOm+2Po0xa2tGrhRQk/OCOFh2szqcaxSyfkCYqKsoyfe4P0lpIj3+tBDK2zLJVoI1gy+EsCKY5liTDe0YibmRvj/rNrOZso1pY2642L3pr4TEP9u3Q1LNON3xtYhkntPOMmpZ8RyniD/3u8dq6Q3mm+sc5ZjweDigB6VtWmmaTVSD+9HKSjBo1CitWrMAPP/yAevXquc542e12hIWFwW6347XXXsN7772HRo0aoX79+hgzZgx69+7N5VNP1R7v79yOEW4PU9yaoWX7zxtvvEHcJi2o2RZuD0Ojuvrb0avFCN72q/lBL1p0kPKDGiS2j7H0CU3eeOMNZDPocxa88cYbSFUp7RWIFpLjXyt6xpZcvAr4I9hyOAuCYY7Nd5Si+2PDXQ97IoVaiSKacwAJn5y+WMrEdve5sXe7xj6/99bCYu2hFy02sY4TmnlGTYtSX2w6nI/BXcNN8ZFSGbzODz3J3BarwfU33bNnz4bD4cBDDz2E8PBw17/Y2FjXNVOmTMETTzyBZ555Bn379kWLFi24fZCN8/H+7mh9vH5sai76TEjAi/MPoM+EBMSm5spe98MPPzCzSY9tgbSjV0ugaO3bQNGig4Qf1CClkZVPaPPDDz9Q73NW/GvpDoxZccjndatp0Tq2aMergBzBlsNZYPU51hmfo74/Tjw+neW33KFdfgsw7pPY1Fwmc7SWudFbC495UIufrR4n7qhpkfMPAERt+tW0/Kdk07jNJ0Q+9gPXb7olSZL998orr7iuqVWrFmbOnIkLFy7gypUriIuLQ4sWLcwzWoVAH++vZ/tPjx49mNik17ZA2tGrJRBYbK3SooNm6QeSGln4hAU9evQIilJQ+Y5SbDnf0OfpuCE2WE6LlrHF41ZIgTLBlsNZYOU51pT4ZPBUIiM+kduKC5Cfo7X2vbcWy+RBrw60cpx4o6bF2z/umJX/nDZ5v4GUYBP52A9cby8PRob3jETfDk2Rc/4q2jSprWli07P95+zZs0xsCsQ2ve0EokUvLLZWadVhxA9qkNTIwicscOqg1eesOHn+iuyac9rz3fFEt5bM7TGClrHF41ZIgYAkVp5jacen3HwnAdTj34hP5PoEID9Ha+17OS285UEtfrZynHjjT4vTP5sO5yNq068evzMr/w3vGYk6odUx2msHh8jH6og33QFg9Gys3rMhzq0c3iUD5Lb/XLt2Tbc9em1y16/HNr3tBKpFD3rt90bLWNCjg8a5IaMa3dGihZfSI2q467DCmWClPr2xDU+C5LYZr5rNhh5t6JfR8YfecaBlbJEcy3qwwpgWBAcs8h4taMen3P1DGGwvN+ITJZtJz9Fa+95dC6/PxtCihXWc0MwBWrU0rx9qSv5TokfrhlzZYwW43l7OI2acJ9Sz/addu3ZUbfHWn3S8kNrWJNpaAGNbq7SOBRY61CC5fcyfFquctzXbJ3pQ69NwexhG39uYu62BgYwDLT4xYyukVca0IDiw0tzkDe34dN7f48nWEpB0vJDI/ZUw4hNWNmvte6cWnue1pOOFHg+ds8lsxWcZJ7T7Suu6aszKdEgSXGPJ7Hzv4ydY71gba8Q33TpQOjPTt0NT6oNM6/af3bt3o0uXLlRsUNKfPLYfksf2I741iaYWdwLZWqVnLLDSoQap7WNqWsyMD73w4BMtaOnT0N/TkDz2NW62BgY6DrT6hOVWSCuNaUFwYJW5SQlnfE6ZvxzvvvES8Tjp26Gpx/leZzkpmjFp1CesbNYyN+7evRtNIm/jdl5TKkfVt0NTj+tYxQmLHKBnXSUBCJGAGS92x92tG5rmLzk/SZB8/CTwRHzTrQO1MzNO8h2lSMk+T+VBAuH2MPRu11g1yF5++WXi7Trxd2bIWZ6ClH6aWrzR0rfuKPVFWs5Fn2tZ6lBDr0Y51LRoiQ/WKMUjLz7xh5Y+ffnll6nEX6ColThRs0uPT1jp5XFMC4Ibq8xNaoTbw/Dp688CIB+fcud9acekUZ+knbrIxGbnFmi1DyNffvllruc1pXJU3raxihMWfaV3XVUFoFGdUFM/IJF/VoGNizHEM+JNtw78lVbgYbvOjBkzqN2btX6aWoyiVDLh7VWHfHTzrEMvalp4Kz2iNh6t4hMtferUwsP8AwRe4kSvT1jo5W1MC4Ifq8xN/hgzZQWV+FSaXw7/Xkzk/nIY8QlP5cKAG1p4ntdky4XB99w+qzhh0Vf+1lVmlMnzx5EzDp/XbJBMt4t3bJIk+XxWcbNRUlICu90Oh8OB+vXrq14bm5qLT+OOolKSXOcphveMRL6jFH0mJPg8UCB5bD/Tt+uQ5GbX705sai4+WXsEVV6vB7tuNZTGB2uCaTxq6VPe9Lrb7A0Ju1jq1Tum9eQTgXGc/Z2ZW4AOEc3NNkcA+vE5d3c2orcc83iNx/ldrh+AGw9Si366C7HcGEh/85Krvcl3lOL+6ATP7eU2IGXsw6b51sy+ku0PACmfmNcfSuP6k8c74c2+1n0mhROaOVx8062T4T0jkTy2H1a+cR+Sx/ZzBR4v23WioqKo3p+lftpajDK8ZySmvdjd53Vv3bzr0IM/LUrjgzX+xqOVfOKvT6OioriZf5w4bR43+Haf3ynZpccnLPXyMqYF6uQWBUdtWCvNTUrQjs8ut9h9XqM53wXqE7VyYSTnET397dTC67wmWy5M8t1ezjJOaPeVmha18mlmoTSuf07YwN4YiyEepBYAcqUV9JTKoFl6YMyYMUTvJ4fT5pPnr7h+plEqRE0LixI+WtrQUjKBhU/koNFHSlp4Kz3ibzya5ZNAketTZ58PG/E31KtvTiktNcLtYRjcNRz/3vyrJrv0+IR16TAexrRAncjGweEfq81NcphROsx5f5Z5LxA7Q8CmXFgIgKIr5ch3lHr0g7sWHuc1rWXhWMcJzb4aM2aMallQf7HEuqSl0nh7afiz1Nu2OuKbbkJoLddA+xzikiVLiN5PDjkNNEqFKGlhcZZTaxtadLPwiTe0+khOCy9nid3x5xczfEIS9z4fOPO/VEv3GUHPvKDHJ2aUDhPwTYsg8b3V5ybgRnwOsBdSLx3mff+k44XM8p4eO93P5EqgXy7M9r92Rq845NMPvI8vrSXWeNehhw9nx6uWBVXLdTyUMQZuPNzt5e/SuVj/8Yw40w2y+/fzHaWK5RpYnEM8evQoOnfuTORecvjToKZfL3JaWPRhIG2o6abtEzlbaPWRtxbezhJ7o+QX1j4hiVqfA+CmdJg7WuaFQHxCcr4hhTjTzZZgO9Nt5bnJnaNHj6JxRDuq8eke/wCY5T29NrLKkfmOUqTlXMTbqw4ptmeF8SV3jtm7z6ygQwtatDqv844ls9dfP5++iCGzUjxqdfO0/gsUcabbQqiVZaJ9zinfUYrNP/1GtVyQPw3+ylLpKamWlZWlu30SBNKGmm45HUZR60eafeSthbezxN4o+YWGT1iRduqi39J9vCU8LXYF4hOjemmWeBSwJVjOdFt5bnLiXIsAoDofucc/y7ynh0BLKAZCuD0MjerWVO0H3sdXvqMUGw/n+S2xZoYOGvlCawk8uVynthZgwZVrlfD+2pan9R+PiDPdDKF5zik2NRefxB1BlVQDcyYkEH0ypjtGNPxho7and4aF+SZqFmc5Sbchp8MI/vqRZh95a5FrC7hRvsVZR5lHSPuEFbGpuRi79ojP62af3yYBa5/onY8EfBMsZ7qtOjc5YbUW8cZZWsn7qdc08p5eu+RyZNSmX/Hvzb8S7x9//cDz+HKfk73xznHBki/k/KUln/OwFqAZc8GK+KabIbTOIeY7Sj0mqioJ+DTuKJVvbwLVEIiNjRv7vmljcZaTdBtyOgJFSz/S7CNvLeH2MHz8WCef6yZtyeT620OSPmGF0/fe65EQICjOM7P0Ccs5UyDQgxXnJifcxRWhw5NGfCJ3/tUJs/5x6wdex5f32HFHbg0TLPki3B6GN++up2u9prgWsHGwFrjpDyyrI77pZszwnpHo26Ep0XNOatuqaARfIBoCsTE9PR09e/Yk0r5eSLahpCMQtPYjrT6S06JWvoXXN4IkfcIKpTIdTzW/EBTf0LL0Ces5U0Cf3KJSdIgw2wrjWHFucmJmXKmVVjLatlGfOPPxpsP5iNr0q8fvSPePv37gdXwp5bd/Dr4dj3cN9+mfYMoXjR2ZSB77sub1mlopuie6tTRsj1ZoxlywIt50mwDJ0gP5jlIUXS5nXi5Ir4ZAtjw/+eSTsq+zKo9Ayk9KOvSi19c0SlzIaWFdvokE3jpYl9wIBKV+fvWJB80zygsj/UgqTrRgxTErUCdYtpdriQMe5ysz1iLu/UAzpknNTc3rh5p+PI7lPKsHpTJU97RpKDvGgylfPPnkk2ihY72mZA/pUnROjJQzE3gitpdbGGepgDEr0yFJcJVY4LF8TiBbnv/zn//4vMZjeSp/yOnQCy++ltMSbg/D0O6tPF4b0r0lV+PPG3cdVhlTSccLPR5aYvvfVrL1sXyUTjHajyTiRCui5FjwESwlw/zFAY/zlRn5ybsfaJZNNDo3sewff3Mby3lWD0plqIbOSpEd46zzBc01jl4tSmsBFnGmVs7MBknkUT+IkmGwZokXuVIBIQCmv9gdd7eW/2SQB4yU+DG7PIJZ8O5rK/vFKrYrjYG9nzzMhZ1W6UdvaJQcs2I+sTLBVjJMDR7jzIz8ZKWyiWblbx7LKWqBxzJUPMUdy7WAVt1WHWtKiJJhJsNjWRm5Mx1VADbFrQ5o0LPSqKfET1RUlMfPvJenUsJbhxJKPlDydaM6oZp9Tcq/clqs6BenDt5td/pNrjRIFW4sLrWOL5qQ6Ed3HTzORwK+CZaSYWrxrCfOWMUQ6bWIFliXTdQ7x7r3PYn8HUi7Sv3AQ75QQ2sZKpY6aK8TtGjRshYgjRbdzjHepkltLJgeQ9yGYEOc6fYDr2VllM5SfPTWK7rvxavGDz74wONnq54f8dYhh5oPjOom6V85LVb0i1MHzyXP3P1mAxTLimgZX7QhMQacOnidjwR8EyxnutXiWWucsYwhkmsRLZhRKknPHOvd9x8/1olJftTqcx7yhRqKOfmMZ05mqYP2OsGfFq1rAdL4m2+8x9yXT75I3IZgQ3zTrQJ35S/cUDq3s2bJfF334Vnj9OnTPX626jlMbx3e+POBEd2k/SunxYp+cergteSZt9+cOS9E5iygv/HFAhJjYPr06VzPRwK+CZYz3WrxrCXOWMcQqbWIFswqlaR1jpXr+0lbM/HxoE5U86Men/OQL9QIt4fh40EyOXmrZ05mqYP2OkFNi561AGnU5hu5MffP9RkiV/tBfNOtAu9lZeTKQmU1GKLrHjxrHDJkiM9rLMqFkUZOhztafBCobtL+VdJiNb+46+Cx5Jmc3yQA05/vjsZ1Qz362N/4YoXRMTBkyBCu5yOBgAX+4tlfnJkRQyTWIlowq1SS1jlWqe+7tmqA5LH9qOVHPT7nJV+o0aWV/5zMWgfNdYKaFj1rARoozTfydtlErvaD+KZbBefWCnd42zbrfW4nLS1N8Vq5M148a1TSYrVzmN46vP2g1QeB6CbtX7XxZdQvLJ+dkJaW5mqvTs1q3MWAkt96tGno08dKPjHjWRRGxkBaWhqX8xGPz/QQBC9qc6wTtTgLJIZIjHE9a5FAUZsXaaJVi7++l3y+oyeDUru1a4b4+JWGX0jiXnrOHe8xzFpHnZrVXE+dV7IpUNS0yPk2BJBdC9BCbr6Rs8sGiYv3Djwj3nSrYMVtsy1atJB9Xemx/zxrVNJiNdx1yPmBpg9I35uWT1iXwcm83tjV3tBZKRjavRVXMaDHb3I+4bGskD9atGjB3XxkxX4UWBujc6zeGKI1xmnkCrPKU2rVotT3SccLqc4jcu0O6d4SQ2el+LTJ87pKT2k1ljpiU3MxVOaJ6qRyk5oWp2/d399KuFE2zEzkypa90pn8wwGDDe63lyclJWHy5Mk3vpnKz0d8fLzHVgxJkvD5559j/vz5KC4uRp8+fTB79my0b9+eSPtW2zZbvbqvS5XO+/Tt0BTh9jBuNcppsSJOHWp+oOkDkvem4RN/45NGe4uPXnN951AlAesO5SFuZG9cvVbFTQxo9Zu3T1j3JymcOniZj6zaj7zBKocXOEqDokQbiTlWawzRHOO0ckX8od89Xlt3KA8fDOxINSb1aPHuewAeZZdozSPu7dauGYKhs1Jk2+R1XSV3djlEAmYolFZjpcPbLuDGt5VxI3ujWwSZHRb+tPTt0BQ2G1xvciWYm4vknq1gk4C7mocyt8VqcP9N95UrV9CtWzfMnDlT9veTJk3CtGnTMGfOHBw4cAB16tTBwIEDUVZWRswGXrYza9kCdvLkSd/XNDz2nweN3vrktFgRpw5/fiDhA6UxQsq/NHzCumzXyfNXfDb5VUoSrl6rohIDRrZuavGbt094L4OmhLsOd91mbe+2aj/yBqscHiwlw0jNsXJzh0+OJTTG5WI0GHKFq12dWtz7nqXNznavXKtUbJO3dZW/UlhKpdVY6VAq+Xb1WhW5Nvxo4S0XKfXJz9m/y14v+AM+P/JyY9CgQRg0aJDs7yRJwtSpUzFu3Dg89dRTAIAlS5agefPmWLduHZ5//nmWplJFazmIvn37+rxmhZJOcvrktFgRpw7afmBRJoaGT1iPT5btmeETK8S7HHJjy8zyYVbtR95glcODpWQYrbwnm2M7NDU8xpVilFau8C6XZLOBekwa0SJrM+jafOSMw+c1p19bcrSuMlIKi9X6kEUe8KdFzZ9moFRCrWYLMjuMgxnuv+lW4+TJkygoKMCAAQNcr9ntdtx7773Yt2+f4t+Vl5ejpKTE4x/P6CkHsWLFCp/XeDsn6Y2SvnnL1phrGCGcPqHpB1ZlYuTGl1FYj89wexgeqHWaentm+YT3eFfCW4fZ5cOs2o9WIpAcbrX8rRcac6xSLAEwNMbVYpSGDlnoPJvMA+JabP4vCZR8Rykmbj3m8/pHg25swWfmFz8YLYXFSgeLPKCmxZ8/zUCphNrc/QXigaN+sPSb7oKCAgBA8+bNPV5v3ry563dyREdHw263u/5FREQAAE6cOIFJkyahvLwcUVFRAICoqCjk5eVhwYIFSE1NxbZt2xAXF4eMjAxMmzYNJSUlHtdeuHABM2fOxOHDh7F+/Xps2rQJBw8exNy5c1FYWOhx7dWrVxETE4PMzEysXr0aO3fuREpKChYvXozTp0+7rv1qylzZrSXrfkzBqlWrkJWVhcmTJ6OsrAwVFRWu+xcUFGD+/PlITU2FvSgD47qV498DmuO15jl4rIPdw5bi4mLMmDEDR44cwbp167B582akpaVh3rx5OHv2rMe1paWliImJQVZWFmJjY5GQkIC9e/diyZIlyM3Nxfjx41FVVYWoqChUVVVh/PjxyM3NxZIlS7B3714kJCQgNjYWWVlZN/T/7rutqFKScNtd92Hz5s1Yt24djhw5ghkzZqC4uNjDFofDgenTp+Po0aOIj4/H1q1bkZqaivnz56OgoMDj2rKyMkyePBlZWVlYtWoVEhMTkZycjKVLl+LUqVOIjo5GZWWlx9+cPn0aixcvRkpKCnbu3InVq1cjMzMTMTExuHr1qse1hYWFmDt3Lg4ePIhNmzZh/fr1OHz4MOrWrYsLFy4gKioKw3tGYljYESx4qQv+2uwkutS5jLi4OGzbtg2pqalYsGAB8vLyPO5bXl6OSZMmITs7GytXrkRiYiL27NmDZcuWIScnBxMmTMBvZ0tk+3Bz0k/YsWMH1qxZg2PHjmHKlCm4fPmyx/3Pnz+POXPmID09HRs3bsSGDRuQnp6O2bNno6ioyOPat956C1OnTkVGRgbWrl2L7du348CBA1i4cKGP3RUVFZg4cSJOnDiB5cuXIykpCUlJSVi+fDlOnDiBiRMnoqKiwqNfZjx9G8a0OYc2VfnYvn071q5di4yMDEydOhWXLl3yuH9RURFmz56N9PR0bNiwARs3bkR6ejrmzJmD8+fPe1x7+fJlTJkyBceOHcOaNWvwwr1tMO1RO0ZEXMSaEZ2QtW2J69rr169jwoQJyMnJwbJly7Bnzx4kJiZi5cqVyM7O1jxHJKZlyPrkyMkConPERx99hKioKFRWViI6OhqnTp3CtWO78c3DdfFxz1r46PZLuLtBuWuOcL+/+xyxdetWxMfH4+jRo5g+fTocDgfTOeL555/3mCMWrdkk239fTZmLs2fPYt68eUhLS6M6RzS/cgLfPFwXf21TglUvd8CJH5f7nSPi4uIg0EYgOVwpfx/4RXtssszf3rG5dOlSJCcnIzEx0Sd/u8czydhUWkMsWrMJTS/9hin96+HV1g7E/r+O+G37Us35e9KsxbL3nbE4Fv379ycemxNmLvR5jy0BOPDLCWr5e+bMmXj99dc9ri0pKcG0adOQkZHhN38fzy/2tVkC5q/8wZW/r1+/7vE3Z86cwaJFi7B//37d+XvF+h9ly6r9nLABly5dQmhoKPH87R5rCxcuxIEDB/zm759P5MuWwnqy8XnMGXY7hoUdwfCekbL5e8eOHejbty8WLVqEM2fOeNyXVP52nyOyti1B8th+eLxWFjb+vTvO/3cD0TmioqJCcY5YuHqjoj/NzN+dW/o+P0OCDRsTD/is8UtLSz3uzyp/B7rGz8rK8u1wQtgkSWLwOSEZbDabx0NYUlJS0KdPH+Tl5SE8PNx13bBhw2Cz2RAbGyt7n/LycpSXl7t+LikpQUREBBwOB5cPYsl3lHo8iAO48Wlb8th+Pp90RUVFYdy4cUTaPHn+Cto2qUP90zQlfcPCjiD6s4+ptq0Fo31ByidqdgHQPEaMQEuLHDTHIAsd/uKWlD6WPnGHtH+8deiZ93iipKQEdrud23xiJiRyuFL+zswtQIeI5j7XWw0a8fzz6YsYIvP0ZaOxpBajC6bHENPhnGvq1Kzm8YAw9/ZozglGfMJ6HvPXnln5whst/aKWY3jRQQI1LbzmQTm7bJCQ8kl/rvOzFmjmcEu/6T5x4gTatWuHQ4cO4a677nJd9+CDD+Kuu+7Ct99+q+m+zg5emHAUr/a7k4LlxolNzcWncUdRKUmu7S20zjaacY6SpT69dpl1plSvXQC47MNA4LXf9aI0rq2uj5X9vM4Laog33crQyOGiv9Vxj1UnJGOJdox6zzVDu7fCukN5lpoT3l+djrUH/3jI1DN3t0LMsLuCpr1AURs7Vs+RJOHRn7GpuRi79o8nmNtswIQg8RHNnGLp7eVt27ZFixYtsHPnTtdrJSUlOHDgAHr37q37fl9u+JXb8wjDe0YieWw/rHzjPiSP7ac4sJ3bJgLFrHOUcvqMajEKqb4grUOtzIuWMWIEFj5hMQZZjS25cU1aH+s4oeUfOR1a5z2BNSGZwws4zd16IRnPauWOSMWSUoyS0CE31zjLO7KcE4xoUSpzRmtN5a89s9dV7iiNHS05hicdRlHTwnr8aEGpZFj6lpWm2WQVuH96+eXLl/Hbb7+5fj558iTS09PRqFEjREZG4p133kFUVBTat2+Ptm3b4p///CdatmzpUQdUK5WShLSci2hUl822ar2E28P82jRixAhDbaiVJiC5JVYOb31GtQDGtsD66wutkNCh1S7aZd9GjBhB/egBqX5Xs5O0T/TYQEqfE1ZanARqv79xo6RDy7yntQ0Be1jl8NyiUnSIIGy8CZCMZxbljgD5GCWhQ2muOX2hFE90a2n4/loxooX0fG+0Pdb5wh9yY0dLn5mpg3SeUdPCevxoQWle6f3on02xRw3e1gTcf9P9008/oXv37ujevTsA4L333kP37t3x2WefAQA++ugjjBkzBn/729/Qs2dPXL58GVu3bkWtWrV0t2UD8PaqQ3hx/gH0mZCA2NRcklKY4P6NQSA4SwG44yxNEJuaiz4TEpj1j1EtRu1V6ws9GNXhDSm7AmHy2r3UxwAJff58T9onemwg7T8WWtwJxH4tsWh2vAvowCqHB0vJMJLxbGauIKFDzn7gxjqNZXwb0eIsGeYOzZJhsu25lVVjnS8CwZ8GwDwdNPKMmhYtfcEapbjcsPcwe2NU4HFNwP2b7oceegiSJPn8W7x4MYAbZ8S+/PJLFBQUoKysDD/++CM6dOgQcHtmlachhRHtgHJ5BADMt50b0UJiCyypUhFGfULLLr3kO0qxoaAe9TFgVJ8W35P2iR4bSPuPthZv9NqvNRbNjncBHVjl8BYcfItBApLxbGbZOxI6nPZ7L1RZxzfxOZZiyTBZ3L6VZJ0viOH1zaoZOmjlGd1aTH4Sl1LJsJ3n63KTc3ldE3C/vZwlEjznQrO3cARCaanxATW8ZyT6dmiKnPNX0aZJbYTbw5CSfZ75FhcjWkhtyZHrC72Q8AkNu/Ry8vwVn7me1hgwok+L72n4RI8NJP1HW4sceuzXGos8xLtAYDak49mMXAGQ0zG8ZyTqhFbH6BWHPF5nGd9G5ya5kmE0t5fLlVVztmdGvtCLPw2AOXmPVp5R06KlL8ygyy12n9eqKI5rvfC6JhBvut0waxuWXtTOKBQVFRFpw/ucjXM7ifcTUOX6h9QZCiNa9NjrDz1nSuXwpyPQ/jJql15ubHOSILl9NKWnT/XqDFSfFt+TihMjNgSiT64PaWtRwtt+Jf9qjUVe4l0PvJ0XE1gfGvFsJFcEOsZJ6ujRuqEp8e3ESnNTnZrVYLPBpzycsz2z8oUeeMjh3uQ7SlF0uZyKL9W0yPVFCMzdXg7I22WDZLpdTsxaE/iD++3lLPn8yTtM2YalB39nFLp160alXa3b1EieoTCixcxtdd6o6eDxzIkS4fYwvNOneUB9ylKnFt/TihM9NuhFqQ9pa9GCmn+19oXV4t1KsXszsDbttNkmEIGHeHZiZIyT1JF0vNDjTaTNBqb53IgWlrbHpuZiqEw9dvf2eBpfSoTbwzC0eyuP14Z0b8k0h7vjjIMxK9MhSTd8CJDLM2panLnN/TtBCTfGlZnI+WjAbfW5ec/E03sAd8Q33W480yMCj919K/NtWFpRKxXltHXjxo3o2LEjlfb9bVPTYp8ejGoxa1udN0o6SPcXC64fT0Ly2JG6+tQMnf58TzNOtNqgB7U+ZKElUNucmrX0hZXiXU1zHdbnNQUAbpT8fOzuW7mdO7Vidjw7MTpvk9KhVJ6ob4emhu+tlUC1sLRdrTxct4iGrtd4GV9qKJXJ+mBgRyZrXW9b3PtVAhAiATNe7I67WzckMt/409K3Q1OP3QsSzF8ryvnox99KXM+t4QFe3gO4I950e8F6y64etJxReOutt6jaoNY/es5QaNmyRkILD/701uHUfuHKNS7PnKjx1ltvoXZtbduKnZh1tkbN97TjRIsNelDrQ5patMSpVv/66wsrxbua5jub1qDevsAX3udOrdCI50C2iBudt9966y0ixy+UyhOxLO8aqE+UbKcxTrWWh2OV+4zAw1pXzZYqAPmOMmJt+NOi1B9mljiWs0mCjbs5mIf3AO6I7eUWQkv5j2+++YaxVX+gtTyJ1i1rZmohibsOd+1jVhzyeYgpD2dO1PD2iRZfmlm2RgmrjS21PqSlRWuckvKvlXzC45i+2QmW/icdB4FuETc6xt+cuJjI8Qs5O1iXdw3UJ0qllQ7/XmzMIBmOnHH4vCbnLyvMs1rKZLHSoeTDqE2/Eht7/rTwEANyNvl2Cz9nunlFvOm2EFrOKIwbN84s8zTZp+cx/mZqIYlTh9w2JeCPB/jxcuZEDXefaPUlj2drrDa21PqQhhY9cUrKv1byCY9j+mbnH4/cFhT9TzIOjJTNMTLG8x2l2HutNZFyPd52OBetLEsBBeqTcLt8aaVJWzKJ2pvvKMXErcd8Xv9oUEcff1lpnvXA61tVVjq8x587pMaePy08xIAWbMxr4VkPsb3cYvg7oxAVFWXqpOrPPj1b1szWQgqnDvntOMD057ujcd1Qbs6cqOHuEz2+5O1sjRXHllIf0tCid2spCf9azSe8jembnc7hDcw2gQgk48DoFvFAxzjpI0XudhRdKWdePsyIT+RKK5G2V66/AaBrqwY+r1lhntVSJoulDuf423Q4H1GbfvX4HQlfatFidgx4w2spM94Rb7otiHNAnzx/xeNnAHjzzTeZ2aF0XkvtDIWex/iz0MKi5I9Th5L2Hm3IPIyDJs5+GvLiq67X9JZkIH22xojvWMUJ6fEl14c0tARSbsOof+V08FaSy9se3s6L3cxENg4OP5CMZxJlcwIZ4zTK9TjtyHeUMi8FZMQnLEoX6V1X8TaveqNFD60crrauHdw1HP/e/CtxX2rVYmYMeCNbysxmfikz3hHbyy2I2hmtuLg4021QQ8+WNdpaWJX8ceqw6pZU9356ct4hVz+Zqceo71jECevxRRIzfOutg7eSXLzZI/CkBefzqFZIxrNZc3S4PQyPNb5ApV0zyocZ8Um43X/5K6Po8fPn323lfh7T4mMaec/fHE8rnvRqMbuEHiA/ru+sc5n79azZ2CRJktmUcnNRUlICu90Oh8OB+vXrm22OKvmOUvSZkODzCVfy2H4It4fh4MGDuPvuu021Qes9/G1Zo6mFhAateOvQop0XtPQTaz0kfEc7TswcXyRh6Vt3HSz7Twt67LFSPgkGnP2dmVuADhHNzTbHMDTi2Yycc/DgQYS3u51ou3JxGAJg7ycPU9VlxCcs5zJ/fs53lOL+6ASPbcFmzqtyaPUx6TjR4yfS8aRHi1kxoMkOG7B3LFs7aEAzh4tvuhXId5QiJfu86Q8m8EbtrBQA5OfnB3RfPXr92aCFcHsYerdrrBqc/rQY8REJDVrx1qFFu889TBqPWvopED20bfJHoHGiFTUbSfuSphaWvnXXwTI+tcCbPQJfcov4ytWBQjqendtlWX/Im5+fr2v+0DIvqpXgokl+fn7A87bS3LHpcD7xfO7e33L2yp3DZTWPae0/rT4mHSd65njSeVGLFmf/pZ26aEoMeCPrJ4m9HVZDnOmWITY11/XEzxAbEP10FwzvGWm2WQD8n3WprKzUfU+9elmcUQLUtRj1ESsNQGA+ccfM8ciyn1jaZNQn/lCy8fDvxXjpP/uJ+pK2Fla46+Bt3DnLo7ivMbxL2AjMJVjOdJOMZzNzhx4dWu00a15IzqvCmP99q6e3H+VsBm6UnPr35l+p+ESpP2/MYxIkt6dMs+g/PeNQq49J5z0zc44/Le79ZwN8cpEZuVEuJ4qSYf4R33R7YaTEBgv8nSlp06aNrvsFopfVOTElLSR8xPKsm16fuGP2ePQpVWHC2SF/NgXiOyM+0YKcjR891hETtxwj7kvaWljhrsMSzz+46Q9m8UWwnOkmFc9m5w6tOswoT6iHfEcpVmWHBNyPLEpOedur1J/h9jCMurcR8/7TMw61+ph03jMz56hpsVKpWVEyzD/im24vSJe6oIFaGY89e/aga9eumu8VqF4W5XKUtJDyEauSP3p94g4P49G9n3ZvXIPhPQczaVerTYH4zohPtOJtIy1fstDCAm8dPJXkEuVRBKwgFc9m5w6tOswoT6gHtS3ZWtumXXLK2161/gzLO4TksX9l2n96x6EWH9PIe2blHDUtvJaaFTkxMMSbbi9429aohFIZjxdeeEHXfYzopV0uR0kLKR+xKpvh1BFIe2aOR7nySB3/3zDq7WrFvXxGSvZ5Xf2qN06MIP0vNdHyJUstgaJl7MvpoD3HaMUqeUFgfUjFs9m547b7H3d9u6qGkfKEgcz9eiHZj83rh5pSPiwEfxyFeeGFF9CI4bxqpP8kle1EtPKeGTlHTYuSP/G/401m5UdRMiwwxPZyLyyxrVGFWbNm6bqeZ71KWkjYzLL8z6xZs5iUWCOJkr16xxdtAu1XFjq8bUs6XkjFl7z5xButPuJZB8/zpCC4IBUHZueON2MzNM3JgdrJKoeH28PQp+YpIuuNMSvTIUk3ngcR6L202Bv9dBePjb4SbpSZAtjPs4H4V4tvec4XelHT4t1/znPUo1ccMrXkW7jdt2RYu2pFIif6QZQMg/zj4a1U1okEVtQbqM2syxGxKrFGCt7KNSnBs51qtgGwXKwFCs8+CgQtcShKhrFF9Lc6Vskdeuw0Y14hud4IATD9xe64u3VDbtccNGzS0n882s4D+Y5SpOVcxNurDnHRN8HsJ1EyzARYl0FyYrScUFRUVEB/Z5ZeNdy1yPVLoDazLOEBAF9NmcukxBop1M5gBTq+9BJo+Rit/apFB62SdKR9yconTmiVF/Snw+wyjmaVXhLcXJCOZ3/zDcm4MjIn65kXWZfwi4qKIrreqALQqE4o8XlErawU6xzujVz/KZU10+JbnvOeXrRoCbeHoVHdmtyUrhRlNANDnOnmCBLlPd5++21K1rHHqYV02RPWJTzeef0lbJ35X8ucB1Urj8RifLEoH+NPh5VK0rGMeZrlBdV0mF3G0ez2BTcPPMezP1jNe7I5CvTOkxrxCatyg1rLSvGyRlQra6ZlDFk5TrzRqoWn0pWsYzBYEN90cwKp8h6LFy8mb5xJLF68mErZE9YlPLbGrbT+edD/9T/t8cWqfIyaDquVpGMV87TLCyrpMLv0kdntC24ueI5nf5j67AOK1YqI+4TwoU49ZaV4WCP6K2umZQxZOU68MaSFowPCag++E9xAfNPNCaTKewwYMICwZeYxYMAAamVPWJbwGDBgAO64g5/yR/5QKwVBe3yxKh+jpsNqJelYxTzt8oJKOswufWR2+4KbC97j2R/OeN+dloEHe9xBJUZkc5REr1yREZ+wKK2kp6wUD2tEf2NPS86wepy4o1ULT2W65GwBbCIv+kF8080YpXMhzi017gSyLevYsWNGTSSKkXMwx44dI9YvcoTbwzC4azi1+ztx+kTrmSba+GtTrc9pj69A/O3sVwCa+1JNB8kxx+IsPquYN9IvWvpBSQfNOUALau2bfc5cEHxYIZ79EW4PQ83iU7oeFKonjrTaTio+jfiExfwl10YIgB5tGvrMuzysEZXsLbpS7vKVv5wRDHHiRKsWs3OhP1sASWwv94N4080QtTIIpLZl1alTh6jNRjBa0qNOnTrUt6slHS+E+/P7bTYQ3w6n5BOWZcv0tKnW57THF6vyMWo6rFYeilXM0+4XJR1m+0Op/aTjhczjVxD8BHs8exNIHtRiO8n8asQncqWVhnRvybRMmDs8rBFJlMFiGSe0/adVCwtbtCI35gCb7JgT/EHQbC+fOXMmJk+ejIKCAnTr1g3Tp09Hr169zDbLhdK5kL4dmroChsR21EaNGpE0O2C06PWHUwutbbpOGz0eBCEBfTs0JXJ/J3I+IdE/etHTplKfsxhfev0dSF/608FqazgJWMY8zX5R02G2P7zbB+BRLsV9zNWheLY0mDGawwscpUFRMuxmiGcnRvKgmu2k86sRn+Q7ShF/6HeP19YdysMHAzsS7e++HZrCZoPrSwQJ8pp5WSM6/eddBkurr1jpYOE/rVpYjSWteI85gP461uoExTfdsbGxeO+99/D555/j4MGD6NatGwYOHIhz586ZbZoLrY/XN7od9fDhw4GaSBQS5QTctdDYpqtUyoN0yQM5n5hRbkFvm3J9zmp80S4fo0UHj2X05GAd87T6xZ8Os/3h3r4ol0IWEjk8tyg4tvjfLPEMGM+DSraTjk8jPmE1V2hth5c1ImCsDBYrHSz8p1ULb3mHN3usQFC86f7mm2/wxhtv4NVXX8Udd9yBOXPmoHbt2li4cKHZprlgdRZj0KBBRO8XKCT00tZipk/MOJtjBZ8EQiC6eNQRKMGixUo6eDpbFwyQyOGRjfn+cEwrVooDNbTooBVHpO9rxCes5gqt7fA2vgLtH1Y6WPhPqxbe8g5v9lgBy7/pvnbtGtLS0jye/hcSEoIBAwZg3759sn9TXl6OkpISj3+0YXUukZcPGkjopa3FTJ+YcU7VCj4JhEB08agjUIJFi5V0mH3OPJjQm8OV8neLIOl7K8WBGlp00Ioj0vc14hNWc4XWdngbX4H2DysdLPynVQtvecf3bL4k8qAfLP+m+/z586isrETz5s09Xm/evDkKCgpk/yY6Ohp2u931LyIiAgBw4sQJTJo0CeXl5YiKigIAREVFIS8vDwsWLEBqaiq2bduGuLg4ZGRkYNq0aSgpKfG49sKFC5g5cyYOHz6M9evXY9OmTTh48CDmzp2Lh9uEYVjYEax84z4MCzuCJ+9sgpiYGGRmZmL16tXYuXMnUlJSsHjxYpw+fdrjvpWVlYiOjsapU6ewdOlSJCcnIzExEatWrUJWVhYmT56MsrIyl8aoqCgUFBRg/vz5SE1NxdatWxEfH4+jR49i+vTpcDgcHvcvLi7GjBkzcOTIEaxbtw6bN29GWloa5s2bh7Nnz3pcW1paipiYGGRlZSE2NhYJCQnYu3cvlixZgtzcXIwfPx5VVVXI2rYESR89iMFhvyH2/3VE+a+J2Lt3LxISEhAbG4usrCzExMSgtLTU4/5nz57FvHnzMGjQIGzevBnr1q3DkSNHMGPGDBQXF3tc63A4MH36dBw9ehTx8fHYunUrUlNTMX/+fBQUFHhcW1ZWhsmTJyMrKwurVq1CYmIiWpXn4t32FzD1z23wfN0MPHt3K4+/OX36NBYvXoyUlBTs3LkTq1evRmZmJmJiYnD16lWPawsLCzF37lwcPHgQmzZtwvr163H48GE0bNgQFy5c8Li2pKQEZ/etw6Knb8HITtcw/r4Q3IqzWLBgAfLy8jyuLS8vx6RJk5CdnY2VK1ciMTERe/bswbJly5CTk4MJEybg+vXrHn9z5swZLFq0CPv378eOHTuwZs0aHDt2DHnJa7FtzL14vFYWksf2Q9a2JTh//jzmzJmD9PR0bNy4ERs2bEB6ejpmz56NoqIij/v+4x//wNSpU5GRkYG1a9di+/btOHDgABYuXOhjd0VFBSZOnIgTJ05g+fLlSEpKQlJSEpYvX44TJ05g4sSJqKio8Im1hQsX4sCBA9i+fTvWrl2LjIwMTJ06FZcuXfK4tqioCLNnz0Z6ejpqF/yML+6pwlf9muDNVr+jf9vaHtdevnwZU6ZMwbFjx7BmzRrce++92L9/PxYtWoQzZ854XHv9+nVMmDABOTk5WLZsGfbs2YPExESsXLkS2dnZVOeIwsJCj2uvXr3qd44YN26crjnC/f5mzxFRUVGoqqrC+PHj8Ze//AVLlizRNUekpaVRnyOSk5OxdOlSnDp1CtHR0aisrERUVBSG94zEsLAjmDbkVrx963lEVJzBzp07ERcXJ5t3BPLozeFm5e9AYtN5rZ7YdMYzT7GZm5urOza15u9z+3/AgiEtMer2CkTda8OtOGs4NgEga9sSrP5LR4yIKMbUAfXRpCQroPw9c+ZMjBw50id/T5s2DRkZGYiLi8O2bduQmpqqmL9P7VqF5c/fijfaXcHkB2uhZdmpgPL3lClTcPnyZY9r3fN3nbOH8XmPSnzVrwn+1vIMBtxax+PaS5cuoW7dupbP3zt27MCAAQOY5e+sbUuQPLYfHq+VhY1/747z/91AdI4AoHmOcLcl/q+dUZK+zdQ54rket2BY7aP49qm2eK99MW65dtoS+dv5N3Jr/KysLJ+8QwzJ4vz+++8SACklJcXj9Q8//FDq1auX7N+UlZVJDofD9e/06dMSAMnhcLAwmSpfffWV2SYQI1i0BIsOSQoeLcGiQ5KCR0uw6HA4HEGTT1igN4cHc/6WpOCJg2DRIUlCC48Eiw5JCh4twaKDZg63SZIkqb0p551r166hdu3a+P777zFkyBDX6yNGjEBxcTF++OEHv/coKSmB3W6Hw+Gw/NNPy8vLERoaarYZRAgWLcGiAwgeLcGiAwgeLcGiI5jyCQuM5vBg6+9giYNg0QEILTwSLDqA4NESLDpo5hTLby+vWbMmevTogZ07d7peq6qqws6dO9G7d28TLTOHb7/91mwTiBEsWoJFBxA8WoJFBxA8WoJFh0AfIod7EixxECw6AKGFR4JFBxA8WoJFB02Cok73e++9hxEjRuCee+5Br169MHXqVFy5cgWvvvqqpr93ftnP4oFqtHn00UeDQgcQPFqCRQcQPFqCRQcQPFqCRYdTg8U3kTHFSA4PpvwNBE8cBIsOQGjhkWDRAQSPlmDRQTOHB8Wb7uHDh6OwsBCfffYZCgoKcNddd2Hr1q0+D2ZRoqioCABcD2QRCAQCgcAIRUVFsNvtZpthCYzkcJG/BQKBQEAaGjnc8me6SVBcXIyGDRsiNzfX0oukkpISRERE4PTp05Y/2xYsWoJFBxA8WoJFBxA8WoJFBwA4HA5ERkbi4sWLaNCggdnmBD3Bkr+B4ImDYNEBCC08Eiw6gODREiw6ALo5PCi+6TZKSMiNo+12u93ygwUA6tevHxQ6gODREiw6gODREiw6gODREiw6gD/yioAuwZa/geCJg2DRAQgtPBIsOoDg0RIsOgA6OVysCgQCgUAgEAgEAoFAIKCEeNMtEAgEAoFAIBAIBAIBJcSbbgChoaH4/PPPLV9fLlh0AMGjJVh0AMGjJVh0AMGjJVh0AMGlxQoEU38Hi5Zg0QEILTwSLDqA4NESLDoAulrEg9QEAoFAIBAIBAKBQCCghPimWyAQCAQCgUAgEAgEAkqIN90CgUAgEAgEAoFAIBBQQrzpFggEAoFAIBAIBAKBgBLiTbdAIBAIBAKBQCAQCASUCNo33UlJSXjyySfRsmVL2Gw2rFu3zuP3kiThs88+Q3h4OMLCwjBgwABkZWV5XHPhwgW89NJLqF+/Pho0aIDXXnsNly9fZqjCv45XXnkFNpvN499jjz3mcQ0POqKjo9GzZ0/Uq1cPzZo1w5AhQ5CZmelxTVlZGUaNGoXGjRujbt26eOaZZ3D27FmPa3JzczF48GDUrl0bzZo1w4cffojr16+zlKJJy0MPPeTjl7///e8e1/CgZfbs2ejatSvq16+P+vXro3fv3tiyZYvr91bxiT8dVvGHNxMmTIDNZsM777zjes0qPvFGTotV/PLFF1/42NmpUyfX763qE54ROfwPeNAhcjifc5PI4Xzp8EbkcD60cJPDpSBl8+bN0v/93/9JcXFxEgApPj7e4/cTJkyQ7Ha7tG7dOunnn3+W/vznP0tt27aVSktLXdc89thjUrdu3aT9+/dLe/bskW677TbphRde4ErHiBEjpMcee0zKz893/btw4YLHNTzoGDhwoLRo0SLp6NGjUnp6uvT4449LkZGR0uXLl13X/P3vf5ciIiKknTt3Sj/99JN03333Sffff7/r99evX5c6d+4sDRgwQDp06JC0efNmqUmTJtInn3zCnZYHH3xQeuONNzz84nA4uNOyfv16adOmTdLx48elzMxM6dNPP5Vq1KghHT16VJIk6/jEnw6r+MOd//73v1KbNm2krl27Sv/4xz9cr1vFJ+4oabGKXz7//HPpzjvv9LCzsLDQ9Xsr+oR3RA7/Ax50iBzO59wkcjhfOtwROZwfLbzk8KB90+2Od6KrqqqSWrRoIU2ePNn1WnFxsRQaGiqtXLlSkiRJysjIkABIqamprmu2bNki2Ww26ffff2dmuztKCfupp55S/BsedUiSJJ07d04CIO3evVuSpBv9X6NGDWnNmjWua3799VcJgLRv3z5Jkm4sXkJCQqSCggLXNbNnz5bq168vlZeXsxXghrcWSboxEblPTN7wqkWSJKlhw4bSf/7zH0v7RJL+0CFJ1vPHpUuXpPbt20s7duzwsN2KPlHSIknW8cvnn38udevWTfZ3VvSJ1RA5nC8dkiRyOK9aJEnkcCc85j0r+kTkcHI6gnZ7uRonT55EQUEBBgwY4HrNbrfj3nvvxb59+wAA+/btQ4MGDXDPPfe4rhkwYABCQkJw4MAB5jarkZiYiGbNmqFjx4546623UFRU5PodrzocDgcAoFGjRgCAtLQ0VFRUePikU6dOiIyM9PBJly5d0Lx5c9c1AwcORElJCX755ReG1nvircXJ8uXL0aRJE3Tu3BmffPIJrl696vodj1oqKyuxatUqXLlyBb1797asT7x1OLGSP0aNGoXBgwd79D1gzThR0uLEKn7JyspCy5Ytceutt+Kll15Cbm4uAGv6xOqIHG6+DpHD+dMicjg/OkQOvwFPWnjI4dUJabEUBQUFAODRec6fnb8rKChAs2bNPH5fvXp1NGrUyHUNDzz22GN4+umn0bZtW2RnZ+PTTz/FoEGDsG/fPlSrVo1LHVVVVXjnnXfQp08fdO7cGcCN/q5ZsyYaNGjgca23T+R85vydGchpAYAXX3wRrVu3RsuWLXH48GF8/PHHyMzMRFxcnMteXrQcOXIEvXv3RllZGerWrYv4+HjccccdSE9Pt5RPlHQA1vLHqlWrcPDgQaSmpvr8zmpxoqYFsI5f7r33XixevBgdO3ZEfn4+/vWvf+GBBx7A0aNHLeeTYEDkcJHDSSFyOP86AGv5Q+Rw/vzCSw6/Kd90BxPPP/+86/+7dOmCrl27ol27dkhMTET//v1NtEyZUaNG4ejRo0hOTjbbFMMoafnb3/7m+v8uXbogPDwc/fv3R3Z2Ntq1a8faTFU6duyI9PR0OBwOfP/99xgxYgR2795ttlm6UdJxxx13WMYfp0+fxj/+8Q/s2LEDtWrVMtscQ2jRYhW/DBo0yPX/Xbt2xb333ovWrVtj9erVCAsLM9EygdUROdxcRA7nB5HD+ULkcPLclNvLW7RoAQA+T6Y7e/as63ctWrTAuXPnPH5//fp1XLhwwXUNj9x6661o0qQJfvvtNwD86Rg9ejQ2btyIXbt24ZZbbnG93qJFC1y7dg3FxcUe13v7RM5nzt+xRkmLHPfeey8AePiFFy01a9bEbbfdhh49eiA6OhrdunXDt99+azmfKOmQg1d/pKWl4dy5c7j77rtRvXp1VK9eHbt378a0adNQvXp1NG/e3DI+8aelsrLS52949Ys3DRo0QIcOHfDbb79ZLk6CAZHDRQ4ngcjh1tAhB6/+EDmcT794Y1YOvynfdLdt2xYtWrTAzp07Xa+VlJTgwIEDrvMjvXv3RnFxMdLS0lzXJCQkoKqqyjWoeOTMmTMoKipCeHg4AH50SJKE0aNHIz4+HgkJCWjbtq3H73v06IEaNWp4+CQzMxO5ubkePjly5IjHAmTHjh2oX7++awsSC/xpkSM9PR0APPzCgxY5qqqqUF5ebimfyOHUIQev/ujfvz+OHDmC9PR017977rkHL730kuv/reITf1qqVavm8ze8+sWby5cvIzs7G+Hh4ZaPEysicrjI4UYQOZw/n8ghcjjfWkQOD0CH/mfAWYNLly5Jhw4dkg4dOiQBkL755hvp0KFD0qlTpyRJulFupEGDBtIPP/wgHT58WHrqqadky410795dOnDggJScnCy1b9+eeZkONR2XLl2SPvjgA2nfvn3SyZMnpR9//FG6++67pfbt20tlZWVc6Xjrrbcku90uJSYmejyy/+rVq65r/v73v0uRkZFSQkKC9NNPP0m9e/eWevfu7fq985H9jz76qJSeni5t3bpVatq0KfPSA/60/Pbbb9KXX34p/fTTT9LJkyelH374Qbr11lulvn37cqdl7Nix0u7du6WTJ09Khw8flsaOHSvZbDZp+/btkiRZxydqOqzkDzm8nw5qFZ/I4a7FSn55//33pcTEROnkyZPS3r17pQEDBkhNmjSRzp07J0mStX3CKyKHixxulhYrzU0ih/OlQw6Rw83XwksOD9o33bt27ZIA+PwbMWKEJEk3So7885//lJo3by6FhoZK/fv3lzIzMz3uUVRUJL3wwgtS3bp1pfr160uvvvqqdOnSJW50XL16VXr00Uelpk2bSjVq1JBat24tvfHGGx6PtOdFh5wGANKiRYtc15SWlkojR46UGjZsKNWuXVsaOnSolJ+f73GfnJwcadCgQVJYWJjUpEkT6f3335cqKiq40pKbmyv17dtXatSokRQaGirddttt0ocffuhRu5AXLX/961+l1q1bSzVr1pSaNm0q9e/f35WsJck6PlHTYSV/yOGdsK3iEznctVjJL8OHD5fCw8OlmjVrSq1atZKGDx8u/fbbb67fW9knvCJyOF86RA7nc24SOZwvHXKIHG6+Fl5yuE2SJEn79+ICgUAgEAgEAoFAIBAItHJTnukWCAQCgUAgEAgEAoGABeJNt0AgEAgEAoFAIBAIBJQQb7oFAoFAIBAIBAKBQCCghHjTLRAIBAKBQCAQCAQCASXEm26BQCAQCAQCgUAgEAgoId50///2zju+qer9458kHeneE2gpUDZliYgDBwgCoqhf98Dx1Z9+Ub8O3KhfZaOA4gBFhogCooBQkCF7j0IXLW3pLt0rbZNmn98fyb1N0uwm6U0479crL2juzc355Nx7z33O85znoVAoFAqFQqFQKBQKxUlQo5tCoVAoFAqFQqFQKBQn4WXLzmq1GkePHsXx48dRWloKiUSCqKgojBw5EhMnTkSvXr2c1U4KhUKhUCgmoOMzhUKhUCjcxSpPd3t7O+bNm4devXph6tSp+Pvvv9Hc3AyBQICrV6/i008/RVJSEqZOnYozZ844u80UCoVCoVBAx2cKhUKhUNwBqzzd/fv3x7hx47B69Wrcfffd8Pb27rRPaWkpfvvtNzz22GP46KOP8OKLLzq8sRQKhUKhUDqg4zOFQqFQKNyHRwghlnbKzc3FoEGDrDqgQqFAWVkZ+vbt2+XGUSgUCoVCMQ0dnykUCoVC4T5WGd0UCoVCoVAoFAqFQqFQbMfm7OV9+vTBc889B5lMpvd+fX09+vTp47CGUSgUCoVCsR46PlMoFAqFwk1s9nTz+Xz069cPoaGh2LlzJ2JjYwEANTU1iI+Ph0qlckpDKRQKhUKhmIaOzxQKhUKhcBObPd08Hg979+5Fz549MXr0aJw/f94Z7aJQKBQKhWIDdHymUCgUCoWb2Gx0E0IQGBiIbdu24ZlnnsHtt9+OjRs3OqNtFAqFQqFQrISOzxQKhUKhcBOrSobpwuPx2P8vXLgQQ4YMwYsvvojHH3/coQ2jUCgUCoViPXR8plAoFAqFm9hsdBsuAX/qqafQt29fPPDAAw5rFIVCoVAoFNug4zOFQqFQKNzE5vBytVqN6OhovffGjRuHjIwMHDp0yGENo1AoFAqFYj2OHJ+PHTuG6dOnIz4+HjweDzt27NDbTgjBJ598gri4OPj5+WHixIkoKCjQ26exsRFPPvkkgoODERoaihdeeAFtbW16+2RmZuK2226DUChEr169sGTJEpvaSaFQKBSKO2Czp9sUMTExiImJcdThXIparUZlZSWCgoL0wvMoFAqFQrEFQghaW1sRHx8PPt/meW2nYM/4LBaLMXz4cDz//PN48MEHO21fsmQJVqxYgZ9//hlJSUn4+OOPMXnyZOTk5EAoFAIAnnzySVRVVeHAgQNQKBR47rnn8NJLL+G3334DALS0tGDSpEmYOHEiVq1ahaysLDz//PMIDQ3FSy+9ZFU76fhNoVAoFEfhzDHc6pJhI0eOtGpAu3jxYpcb5WoqKirQq1ev7m4GhUKhUDyE8vJy9OzZ0yXf5ezxmcfjYfv27ZgxYwYAzUNJfHw83n77bcyePRsAIBKJEBMTg/Xr1+Oxxx5Dbm4uBg8ejPPnz+OGG24AAOzduxdTp05FRUUF4uPjsXLlSnz00Ueorq6Gj48PAOD999/Hjh07cOXKFavaRsdvCoVCoTgaZ4zhVnu6mcEW0Ay4CxcuxMsvv4zw8HCHNqg7CAoKAqD5gYODg7u5NRQKhUJxV1paWtCrVy92XHEFrh6fi4uLUV1djYkTJ7LvhYSEYOzYsTh9+jQee+wxnD59GqGhoazBDQATJ04En8/H2bNn8cADD+D06dMYP348a3ADwOTJk7F48WI0NTUhLCys03fLZDLIZDI9vQAdvykUCoXSdZw6hhM7CQwMJIWFhfZ+nFOIRCICgIhEou5uSpeZO3euy7/zYG41efD7k+RqbatDj9sdWpyBp+ggxLla1Go1eXPLJTJne5bTvoOB9gn3sEbH8fw68sB3J0hOpWvv1aJ2OXn0h1Pk51PFlvflwHji6PEZANm+fTv798mTJwkAUllZqbffww8/TB555BFCCCHz588n/fv373SsqKgo8v333xNCCLn77rvJSy+9pLf98uXLBADJyckx2pZPP/2UAOj0unTpElm8eDGRSqXsuTR37lxy7do18tNPP5Fz586RvXv3kj///JNcvnyZfP3110QkEunt29DQQL799luSkZFB/vrrL5KamkrS0tLIqlWrSG1trd6+YrGYfPnll+TKlStky5Yt5J9//iEnT54k69atI2VlZXr7KpVKsmDBAlJSUkI2bNhAjh8/Tg4fPkw2bdpE8vPzyZIlS0h7ezuZO3cu+6qqqiI//vgjOXfuHPn777/Jtm3bSFZWFlmxYgVpbm7WO35TUxP55ptvSGZmJtm+fTvZvXs3uXDhAvnhhx9IdXW13r4SiYR8+eWXJD8/n2zevJkcPHiQnDhxgvz888+ktLSUzJs3j6hUKjJ37lyiUqnIvHnzSGlpKfn555/JiRMnyMGDB8nmzZtJfn4++fLLL4lEItE7fnV1Nfnhhx/Iyy+/THbv3k22b99OMjMzyTfffEOampr09m1ubiYrVqwgWVlZZNu2beTvv/8m586dIz/++COpqqrS27e9vZ0sWbKE5Ofnk02bNpHDhw+T48ePkw0bNpCSkhKyYMEColQq9T5TVlZG1q1bR06ePEn++ecfsmXLFnLlyhXy5ZdfErFYrLdvbW0tWbVqFUlLSyOpqankr7/+IhkZGeTbb78lH3zwgd6+IpGIfP311+Ty5cvkzz//JHv37iXnzp0jP/30E7l27ZrevlKplCxevJhcvXqV/Pbbb+Tw4cPk2LFj5JdffiHFxcVk4cKFRKFQ6H2mvLycrF27lpw+fZrs37+f/P777yQ3N5csW7aMtLa26u1bV1dHVq5cSS5dukR27dpFdu7cSS5dukS+//57Ul9fr7dvS0sLmTJlCrl8+TL5448/yL59+8iZM2fImjVrOrVbLpeTRYsWkcLCQrJx40Zy9OhRcvToUbJx40ZSWFhIFi1aRORyeadrbc2aNeTMmTNk37595I8//iCXL18my5cvJy0tLXr71tfXk++//55cunSJ7Ny5k+zatYtcunSJrFy5ktTV1ent29raSpYtW0Zyc3PJ77//Tvbv309eeuklsnbtWlJeXq63r0KhIAsXLiTFxcXkl19+IceOHSOHDx8mv/32G7l69Son7xETJkyw6R7BHL+77hEPffwjmbn2LPnf5/P07hEPPvigTfeICxcucPIeceHCBaeN4VaHlxsSFBSEjIwM9OnTxyHGf3fS0tKCkJAQiEQit58pr6mpcfna+ufXn8ehK7V4Z/IAzLqzn8OO2x1anIGn6ACcq+VacztuWaRJ9pT92WQE+jos5UQnaJ9wD2t0vLIxDX9nV+PVO/th9uQBLmoZ8HdWFV759SJ6hPrh5Pt3md2XC+OJo8dnw/DyU6dO4ZZbbkFlZSXi4uLY/R555BHweDxs2bIFCxYswM8//4y8vDy9Y0VHR+Ozzz7DK6+8gkmTJiEpKQk//PADuz0nJwdDhgxBTk4OBg0a1Kkthp5uxivhCeM3cH1dz+4C1cI9PEUH4H5aRn6+H00SBf585WaMTuyIRnI3HaZw5hjOjSwvFIfx119/ufw7SxvEAIC6VpmFPW2jO7Q4A0/RAThXS1VzO/v/2hap074HoH3CRazRkVfTCgCobXXu+WFIpUjzfdea29EmU7r0u7lIbGwsAM1Dli41NTXsttjYWNTW1uptVyqVaGxs1NvH2DF0v8MQX19fBAcH6708ievpenYXqBbu4Sk6APfSolITNLcrAADNErneNnfS0V1Qo9vDGD16tEu/T60mKG/SGEuOfhB2tRZn4Sk6AOdqYQwbAKh18ASOIbRPuIclHVKFCqUNEgDOPz8M0Z0QKtAa/tczSUlJiI2NxcGDB9n3WlpacPbsWYwbNw6AplRZc3Mz0tLS2H0OHToEtVqNsWPHsvscO3YMCoWC3efAgQMYMGCA0fXc1wPXy/XsTlAt3MNTdADupUXUrgATH90kUehtcycd3YXV8ZsrVqzQ+1upVGL9+vWIjIzUe//11193TMsodmHoNXD697VKIVeqAQC1LY59EHa1FmfhKToA52qpFul4up1sVNE+4R6WdBTViaFSa0Z7R99rLFGlE3mRX9OKkQncMgidMT63tbXh6tWr7N/FxcVIT09HeHg4EhIS8MYbb2DevHlITk5mS4bFx8ezIeiDBg3CPffcgxdffBGrVq2CQqHAq6++isceewzx8fEAgCeeeAKfffYZXnjhBbz33nvIzs7G119/jeXLl9v5S7g/18v17E5QLdzDU3QA7qWlUdzh3Tb0dLuTju7CaqPbcBCMjY3FL7/8ovcej8ezaVBfuHAhtm3bhitXrsDPzw8333wzFi9ejAEDOtbqSaVSvP3229i8eTNkMhkmT56M77//Xm/dQFlZGV555RUcPnwYgYGBmDlzJhYuXAgvL+etCeUqcrnc8k4OhPE8AUBdm2MfhF2txVl4ig7AuVoqmzsMG0cvVTCE9gn3sKSjoLbDw9ydnu78mjaXfrc1OGN8vnDhAu68807277feegsAMHPmTKxfvx7vvvsuxGIxXnrpJTQ3N+PWW2/F3r172RrdAPDrr7/i1VdfxYQJE8Dn8/HQQw/pTRCEhIRg//79mDVrFkaPHo3IyEh88sknVtfo9kSul+vZnbBXi1pNIJYrEST0dnCL7MdT+sVTdADupaVJx9DWNcAB99LRXVhtlRYXFzv8y48ePYpZs2ZhzJgxUCqV+PDDDzFp0iTk5OQgICAAAPDmm29i9+7d2Lp1K0JCQvDqq6/iwQcfxMmTJwEAKpUK06ZNQ2xsLE6dOoWqqio888wz8Pb2xoIFCxzeZq7Tt29fl35fWWOH0V3bIgMhxKp6sdbgai3OwlN0AM7VUqXn6Xbuml3aJ9zDko58nbDuRrEMKjWBgO+Ye40lqkT6nm6u4Yzx+Y477oC5PKs8Hg+ff/45Pv/8c5P7hIeH47fffjP7PSkpKTh+/Ljd7fQ0rpfr2Z2wV8us3y7icF4tjsy+E7EhQssfcAGe0i+eogNwLy26hrZheLk76eguunVN9969e/Hss89iyJAhGD58ONavX4+ysjJ2DZhIJMKaNWuwbNky3HXXXRg9ejTWrVuHU6dO4cyZMwCA/fv3IycnBxs3bsSIESMwZcoUzJ07F9999911Oety9OhRl35fmY6nu12hcmiSIVdrcRaeogNwrhZdw6bOyeHD7tgnpwrrjSaYc0ctxrCkI6+6w8OsJkCDgyNrTKFUqVHTwm2jm+I5XC/Xszthr5bzJU2QKtS4XClycIvsx1P6xVN0AO6lpclMeLk76egurDK6N2/ebPUBy8vLWS+0rYhEmhtTeHg4ACAtLQ0KhQITJ05k9xk4cCASEhJw+vRpAMDp06cxbNgwvXDzyZMno6WlBZcvX7arHe7MU0895dLvK9XxdAOODft0tRZn4Sk6AOdq0Q0vd3b4sLv1ycHcGjyx+ize/TOz0zZ302IKSzp0w8sB14WY17bKoCZgveo1LTKI2hUWPuU6XDU+U1zD9XI9uxP2aFGrCRuK6+zlUrbA5X6pErWjUmcpjzm4rMNW3ElLg56nW9/odicd3YVVRvfKlSsxaNAgLFmyBLm5uZ22i0Qi7NmzB0888QRGjRqFhoYGmxuiVqvxxhtv4JZbbsHQoUMBANXV1fDx8UFoaKjevjExMaiurmb3MawLx/zN7GOITCZDS0uL3stT+Pbbb136fWUGRrcjBxdXa3EWnqIDcJ4WmVKFeh3PpbMfUtytT7ZdugYASCtt6hTy625aTGFOR7tcxd5rYoM1YZquKhvGLHuIDRYiXhsiyqUM5q4Ynymu43q4nt0Ne7SI2hVs4kcuGd1c7ReFSo17V5zA1BXHIVOqLO7PVR324E5adD3dTWL9yWd30tFdWGV0Hz16FIsXL8aBAwcwdOhQBAcHIzk5GcOGDUPPnj0RERGB559/HgkJCcjOzsZ9991nc0NmzZqF7Oxsm2bt7WXhwoUICQlhX7169QIAFBUVYcmSJZDJZJg3bx4AYN68eaisrMSaNWtw/vx57Nu3D9u2bUNOTg5WrFiBlpYWvX0bGxvx3XffITMzEzt37sTu3btx8eJF/PDDD6irq9PbVyKRYOnSpcjLy8Pvv/+OgwcP4tSpU1i/fj3Ky8v19lWpVFi4cCFKS0vxyy+/4MSJEzhy5Ag2b96MgoICfPHFF5BKOx5C582bh+rqaqxevRrnz5/H3r17sX37dmRnZ+Obb76BSCTSO35zczO+/fZbZGVlYceOHdizZw/S0tLw448/oqamRm/f9vZ2LF26FAUFBSiobAIABHhrvEC5xdcwf/58qNVqzJs3D2q1GvPnz0dZWRk2bNiAkydP4tChQ9iyZQsKCgqwdOlStLe36x2/pqYGP/74I6ZMmYI9e/Zgx44dyMrKwrfffovm5ma9fUUiEb755htkZ2dj+/bt2Lt3L86fP4/Vq1ejurpab1+pVIovvvgCBQUF2Lx5M44cOYITJ07gl19+QWlpKRYuXAiVSqX3mfLycqxfvx6nTp3CwYMH8fvvvyMvLw9Lly6FRCLR27eurg4//PADLl68iN27d2Pnzp3IzMxEWFgYGhsb9fZtaWnBihUrkJOTg23btmHfvn04f/481qxZg8rKSr19ZTIZlixZgsLCQmzatAlHjhzB8ePHsXHjRpSUlGDRokVQKpV6n6moqMC6detw5swZHDhwAFu3bsWVK1ewfPlytLW16e1bX1+PVatWIT09Hampqdi1axfS09OxcuVKNDQ06O373//+F1999RVycnLw559/Yv/+/Th79izWrl3bqd0KhQKLFy9GUVERfv31Vxw7dgzHjh3Dr7/+iqKiIixevBgKhULT5yL9h5LKpjbs378ff/75J3JycvDVV1+htbVV7/gNDQ1YuXIl0tPTsWvXLqSmpiI9PR2rVq1CfX293r5tbW1Yvnw5rly5gq1bt2Ls2LE4c+YM1q1bh4qKCr19lUolFi1ahJKSEmzcuBHHjx/HkSNHsGnTJhQWFrr8HrHoy2X4J0czgdgqVWL3oZN694g5c+bYdI/QPb4r7hFbtmzBoUOHcPLkSWzYsAFlZWVG7xHPPPOMyXvE5fJ6EAKEB/jAW6zJkPpH6gGkpaU5/R5x+Gw6ACBcyINArKk7vXzdFpP3iG3btsGVuGJ8priOOXPmdHcTHIKn6ADs06LrEXR0ktmuwNV+qWuVoUEsR7NEYdUkBVd12IM7aWmUmPZ0u5OOboPYSF1dHdm+fTv56quvyMKFC8nq1avJhQsXiEqlsvVQLLNmzSI9e/YkRUVFeu8fPHiQACBNTU167yckJJBly5YRQgj5+OOPyfDhw/W2FxUVEQDk4sWLRr9PKpUSkUjEvsrLywkAIhKJ7NbAFebOneuy7xK1y0nie6kk8b1U8ty6cyTxvVSy+lihw47vSi3OxFN0EOI8LacL60nie6kk5X/72HNKprD/nmIJd+qTnenX2N8k8b1UcjSvVm+7O2kxhzkdf1woJ4nvpZJHVp0i727NIInvpZIV/+S7pF0/HL1KEt9LJa/9dpHMS71MEt9LJZ/+lW1yf5FI1G3jiTPGZ67Tnb+3M7germd3wx4tZ7RjWuJ7qeTlXy44oVX2wdV+uVTWxP5e6WVNFvfnqg57cCctz649y/ZT8od7iFqtZre5kw5zOHNMsbmmVmRkJFuH0wEGP1577TVs374dR44cQVJSkt720aNHw9vbGwcPHsRDDz0EAMjLy0NZWRnGjRsHABg3bhzmz5+P2tpaREdHAwAOHDiA4OBgDB482Oj3+vr6wtfX1yEauMZrr73msu9ikqhFBPggKVKTbd6RYVSu1OJMPEUH4DwtTAjvoLggpJU2QaEiqGuToUeon1O+z536ZHdmld7f+TWtGN8/iv3bnbSYw5yOfO167v4xQQj115TfcdWabibBX1yoEP2iAjXt4VB4uS6OHJ8p3cP1cD27G/Zo0c3yXM8hTzdX+0U3WWWD2PLvxVUd9mCNFuLAykBdoVEnY7lcpYZErkKAr8aU9KQ+cRbdmr181qxZ2LhxI3777TcEBQWhuroa1dXVaG/XPICHhITghRdewFtvvYXDhw8jLS0Nzz33HMaNG4ebbroJADBp0iQMHjwYTz/9NDIyMrBv3z7MmTMHs2bN8ljD2hwbNmxw2Xcxayx7hfsjOkjzWzvyQdiVWpyJp+gAnKeFMWziQ/wQFag5l5y5Ds5d+qRNpsThPE1I88RBmlwVhgafu2ixhDkd+dVaozs2SOde46I13c0d52b/mCBNezhqdFPcn+vhenY37NFSrxtezqE13VztF91nx/o2y5WHuKrDHixpqWuV4dbFh7Fk7xUXtcg0TQa1uXUnlzypT5xFtxrdK1euhEgkwh133IG4uDj2tWXLFnaf5cuX495778VDDz2E8ePHIzY2Vm/NnEAgQGpqKgQCAcaNG4ennnoKzzzzjNnaoZ7MnXfe6bLvYozuxAh/RAU53lBypRZn4ik6AOdpYQybuFAhophEWUbKYzkKd+mTf3JqIFOq0ScyADNGxgMA8mva9PZxFy2WMKeD0dw/OtAp9xpzMFEYcSFC9IvWeLrr2+R6DxsUiqO4Hq5nd8MeLQ0uTAxqC1ztlzpdT7cVRjdXddiDJS1ppY241tyOv9IrXdQi0xga3c06nm9P6hNn0a1GNyHE6OvZZ59l9xEKhfjuu+/Q2NgIsViMbdu2ITY2Vu84iYmJ2LNnDyQSCerq6vDll1/Cy8vmyHlOolIT/PvnC3hlYxoUKrXF/QsKClzQKg2l2vDyxHB/RAc5PqOwrpbLlSJM+fo4fr9Q7rDjuwpX9gnD2aIGTFp+FBfLmhx6XGdp6TBsOjzdzgwftkbHjkvXMOXr4yiqa7O4ryFnihpw15dHcCy/zp7msaRqQ8vvTYljvawFNa16Gcy74/xyBqZ0tMmUuKYtI9M/JghR7L3GNQ+ylUx4eYgfAny90Ctcs+SBerspzsDTr2d3xB4tupNyYrkKYpnSkU2yG672i+79vMGKcHyu6rAHS1qYSZsqUbtVdoCzkCvVaNWex0wVEd1kap7UJ86iW41uimUK69rwT24N/s6uxsojhRb39/NzzhpYY5Q1igFow8uDHW8oMVqkChX+uzkduVUt2OqGRrcr+4Rha1oF8mvasOFUiUOP6ywtTI3u+FChU84lQ6zRseF0CXKrWrD2ZLHNx9+VUYmiejG2Xaywp3kANCVnGKN9Wko8ekcEwFvAg1iuYo1QoHvOL2dgSgdTnisqyBdhAT56S1mIQfk0RyNXqtn1mHGhmoeM/tE0xJziPDz9enZH7NFi6K3lyrpurvaLntFtRRQRV3XYgyUtjNGtJkC1yDXLqozRrDWwBXweEiP8Aegb3Z7UJ87CbqNbLpcjLy8PSiU3Zu88Fd0HuxUHC3C5UmR2/4iICGc3iaUjvDyAfRBuliisqrFoDYyW5QfycbVW421kjDN3wpV9wsAkuUtzsKfbWVp0Pd3RLggftqSDEIICbUjz31nVUNo4u8xcG4ah4LZwIKcGcpUaydGBGBAbBB8vPpuwsEDnuN1xfjkDUzoYrf1jNKHdTHi5XKlGS7tzx5+aFikIAXy8+IgI8NG0I5b7Rjcdn90XT7+e3RF7tBgmA+NKiDlX+0U3StKaCQqu6rAHS1rqdCZwyrXPFt0BMxkS5u+NiEDNeKgbbu5JfeIsbDa6JRIJXnjhBfj7+2PIkCEoKysDoMlat2jRIoc38HqHeWjn8QClmuDt3zPMGrXp6ekuaZdCpWYN4MQIf4T4ecNHoDmdrEmCYQ3p6elIK23Ej8eL2PdqWqRQqZ3r3XI0ruoTXUq1UQjlje0ODfl3hpZ2uQpN2nVB8SF+7FKFOicmyrKko7pFyoZRNYjlOFvcaNPxmaUXV+va7D5fd2dq1m9NS4lj32NCzPN0DL7uOL+cgSkdjNZkrYdZ6C1AsFCzfKiuzbmTcJXNHeu5mcyxjPHflQkVZ0HHZ/fH069nd8QeLYynm0k4zRVPN1f7pbbFtkRqXNVhD5a06E7YVDS1m9nTuTSxRrcPQv21RrfOmm5P6hNnYbPR/cEHHyAjIwNHjhyBUChk3584caJeAjSKY2Cy9r58e1+EB/jgSnUrVhw0vW5i+vTpLmnXtaZ2qNQEvl58RAX6gsfjsR4oRyXAmnjPVLz9ewYIAWaMiAdfO/FgzXofLuGqPmGQKlSo0RnALpY2O+zYztDCeLn9fQQI9vPqOI+c6BmwpCOvWt+LmZppfQITpUrNhn/LlWqUNohtbl+zRI7jBfUAgHtT4tn3jWXPdvX55SxM6WC0DtB6mAEgmk2259x7AVsuLKRjrEvWCS93dni7rdDx2f3x9OvZHbFHC7OmOzFcE4bLFU83F/tFpSZ6kxLWPONxUYe9WNJS16ZrdHefp7tRG0oeFuCDMG3pzmad8HJP6hNnYbPRvWPHDnz77be49dZb9WrGDRkyBIWFltccU2yDqU87rk8E5s8YCgBYeaQQl0yEDf/0008uaRcTPpsQ7g8+X3MeONpYmvXjfpQ0SBAbLMRn9w9FjPZBu7Ib17TYg6v6hMEw/MiRydScoUXXsOHxeB1rdp1oUFnSwYQ0x2jXl/+dXW11ApPKZv1oDHs8ovsuV0OpJhgYG8RmzAY6vKy64eWuPr+chSkdhuHlAJxSotAYuqXsGPpFB4LP0yylqePYBCAdn90fT7+e3RFbtajUhDVQmMlCrhjdXOyXhjYZdAPCGsVyqC1EiHFRh71Y0lKvc+6Uc8DTHe7vgzAjnm5P6hNnYbPRXVdXh+jo6E7vi8ViThRu9yRkShUbpto/JghThsXhvuHxUBPg7a0ZkCo6h5nPmTPHJW0r1SkXxuBIo/tUYT1yFJrzbPG/UhDi5816m6qau++mYw+u6hMG5pxhSCt1nNHtDC1MCG98qMawYRKp1bfJLA689mJJB+NdffSGXogM9EGzRIGTV+utOjYT2s9QYMfaX92s5bqwGcxrW9nfxtXnl7MwpkPUrkC1NnKmX7SOp9tFtbrZXAOhHV5jobcAiRGatfX51dwKMafjs/vjydezu2KrlmaJHEwQDHPP5soEHRf7hXlmDPHTeE+VaoIWqcLcRzipw17MaSGEGISXd6OnW6zpE42nmzG6OzzdntQnzsJmo/uGG27A7t272b+Zgfynn37CuHHjHNcyCorqxFCpCYKFXqzH7fP7hyAqyBdFdWJ8uS+v02fmzZvnkraVNXRkLmewJwGWWKbE2hPF+O7wVb3XO1szAQBPjE3A7f2jAGiSbAGO83QfzqtF9jXziekcgav6hIGZEBkUFwwAyLomclhyO2doqTYI4Y3UlgxTqoneDd2RWNLBGN0D44Jxz1BNicLdWkPYEmUGkQZ5NhrdDW0ynCpsAKDJWq5LYkQAfLz4kCrUKNcOvq4+v2yhpF6Mf3JqrNrXmA5mwiIuRMg+kAE6E3xODi9n8lbE6Xi6ASA5mlnXza1kanR8dn+4fD3bgqfoAGzXwiScCvX3RmwIk6OEG0Y3F/uFmTztEeqHIG2+Dkvrurmow17MaWmRKiHXibLr1jXd2uex8ABvhAV4670HeFafOAubi1kvWLAAU6ZMQU5ODpRKJb7++mvk5OTg1KlTOHr0qDPaeN3CPND1jwliH55C/X2w+KFheH79Baw5WYxJQ2JxY1I4+5nZs2e7pG1s5nI9o9v2BFjvb8vCrgzj62V7hArx4dRB7N+O9HSXNojx/PrzEHoJsOe/t7FZoZ2Bq/qEgQkvH98/ErUtUjSI5bhc2YJRCWFdPrYztDCTKLFaw8ZbwEd4gA8axXLUtsoQoTXCHYk5HWo1QUEtE9IchPAAH2w8U4Z9l6sx/4Fh8PEyP1fJZI7vHeGPkgaJXii4NZy4Wg+VmmBwXHCn81LA56FvVCByq1qQX9OGxIgAl59ftvDapkvIuibC9v/cjJEWzj9jOpjQ/OSYIL332XuNk71HjKc7XsfTDWhCRvfn1KCglltGNx2f3R8uX8+24Ck6ANu1MEnUIgJ8EKUdv+oclGC2q3CxX5jJ05hgX0gVKrRKlWhok+ktrTKEizrsxZwWZrJGwOdBpSaobpFCplTB10vgquaxNOokUmM93eKOiARP6hNnYbOn+9Zbb0V6ejqUSiWGDRuG/fv3Izo6GqdPn8bo0aOd0cbrFsboNnzgvGtgDB4e3ROEALO3ZkAs6ygL880337ikbUwIMxNmCXSEBVvrfdqdWYVdGZUQ8Hn41+ieePSGXuzribEJuJVcRqBvx7xQnDb8uMoBnu7say0gBGhXqDB7a4ZTM6K7qk8YmMRdieEBrKFz0UEh5s7Qwho2OsmqnL1m15yOa83tkMhV8BHw0TvCH2N6hyM6yBctUiWOF9RZPDZzbUwcFAMAKKpvs3o9ONAxk81EKhgyIEbfy+rq88taRBIFsrSRJLlVlo1TYzrYJGox+g9ftt5r7IW518QGG3i6mSzy1dwyuun47P5w9Xq2FU/RAdiuhSkXFhHgy0bl1HPE083FfmHG+eggIVuKylKtbi7qsBdzWhijOzHcH37eAhACVHVT6dwOT3eH0a2bSM2T+sRZ2OzpBoC+ffti9erVjm4LxQDGy2P4wAkAH08fjJNX61HWKMGiv69grjbJ2owZM5zeLkII6+nWDS9nZnStMZTqWmWYsyMLAPCfO/ri7UkDOu1TUKDvXWKMskpR1z3dumGhaaVNWHOiCC+N79vl4xrDFX2ii+56+9GJYfgntwZppU34921dP7YztDADCDOpAmjCh69UtzotJM+cDubc6BMVAC9tGbypw+Kw/lQJdmdWYYLWmDYFc23c1CcCm86VQSxXoaRe3GnyzBQda9yFRrcnG2Qwd/X5ZS2XyjsmegzXuRvDmA5TE48d9xrnPXxIFSp2Zt+wL3QT2hFCOLVemo7P7g1Xr2db8RQdgO1amPtGRKAPa3TXtco4ca/gYr8w9/HoYF+I2jWeU0sZzLmow17MaWGiuaKCfCHg81BQ24aKpnb0dmJ0pilYT7eO0S2Wq1jPuyf1ibOw2dMtEAhQW1vb6f2GhgYIBK4Pd/BkdMPLDQkWemPJv4YDAH45U4oT2vJCaWlpTm9Xg1gOiVwFHg/oFd5hKDHeJ0uGEiEEH23PQpNEgUFxwXjtrmSj+xlqYT3dDpjlY8JCh/UIAQB8uT/froRX1uCKPmFQqwkqGjVGW0K4xugGNBMLjihv5AwtlUY93dqSUE4yqszpMBbSzCQ0259TYzSBIYPuhFTvSH8dA9n6EPOObO5+Rrf3NzimK88vW9CNrjDMqG8MYzryazrC/HVhPd1O9B4x/eDnLdBbTw4AfSID4cXnoVWmZBO9cQE6Prs/XL2ebcVTdAC2a2HWI4cH+LA5SuQqNVraleY+5hK42C9MxFJ0kC/r6ba0ppuLOuzFnBbmeToqyBc9wzTPBOXdlEyNyV4eEeCDIKEXtIWL0KzNYO5JfeIsbDa6TT24y2Qy+Pj4dLlBFA3tchX78G7KQ3ZrciSeuikBAPDuHxlokSoQGxvr9LYx4bNxwUK9dSWMoWQp6/T2S9ewP6cG3gIelj0y3OQaWUMtjFFW2yqF0oZwXWMwYaGzJw/AHQOiIFeq8fbWjC4f1xiu6BOG6hYp5Co1vPg8xIUIkdIzBF58HmpbZWzt6K7gaC1tMiVapZoHEV1Pt7PDh83pKDAS0jwqIQxxIUK0yZQ4mm86xLxRLEebdrlHzzB/1iNqS8ItxtMdZ8LTPUB7PyisbYNSpXbp+WULaTql6gwz6hvDUEejWM7Wbk02WNsXpb3XtEqVZidBukKVTj8Yeqd8vPisp4FLIeZ0fHZ/uHo924qn6ABs18J4aSMCfSH0FrDJweraun+Cjov9UsMalkI2hwsTom8KLuqwF3NaGKM7MtAXPcM0kaXdkcGcEMKG/If5+4DP53XKYO5JfeIsrA4vX7FiBQBNNtSffvoJgYEdD0EqlQrHjh3DwIEDHd/C65TCujYQwsyUmn5Y+mDKIBzL14SZz0vNwX2xdq0YsIlyI6HlgCaUisfTZJ1ulMjZGV5dqkVSfLrzMgDgvxOSTa5bBQAvL30tkYG+8BbwoFAR1LbK2BJTtiJTqlDClmILxKIHUzBp+VFkVoiw8kghXptg3PNuL4Y6nAlj3PQM84OXgA8vATAkPhgZFSKklTaxN217cbQWxrAJEnrprd9nk884yZNpTkeekZBmPp+HqcPisOZEMXZnVmHyEOODCzNRFhsshNBboOOVtt4wM1YbWpeeYX7w8xagXaFCaaPEpeeXtajUBOllzezfZQ0Si6GVhjqY36xnmB8CfPW3BQu94OvFh0ypRl2rrNO9yBFY6of+MYG4WtuGgpo23DGgc5kuV0LHZ8+Bi9ezPXiKDsB2LUwYLvPsFhXki1apEnWtcvRzwa2CEE0y0L5RgRDw9e+5XOyXupaO8PLaVu2abguebi7qsBdzWup1wsu9BZq+7I4M5u0KFWRKjVMqPEDTR6H+3mgQy9nz3ZP6xFlY7elevnw5li9fDkIIVq1axf69fPlyrFq1ChKJBKtWrXJmW68rGO9JcnSg2QfVAF8vfPnwcPB4wO8XKrA3swJqNdF7OSKsWJeOJGr6D7reAj7CtTNfxjyUhBC892cmWqVKDO8ZgpdvN7+Guri4WO9vPp+HmGBtBvMurOsurteUYgsSeiE2WIjYECE+u38IAGDFoQJcrnRsGTFDHc7E2ITIqETHJVMz1EII6XS+mXoZo9KEYWPtUgV7MdUnKjXB1VrjIc1MiPk/uTVolxv3rjJGd4L22rDV6JbIleyaNlOebj6fx2Z1Lahpden5ZS151a0Qy1UI8NFEwrTKlGwImikKi4r1zhdzy2t4PF5H2TAnLUFga3SHGO8HeyZUnAUdnz0HLl7P9uApOgDbtTTohJcDOpPILqrV/cuZUkxafgzrT5V02sa1fiGEsL9LTLAQEQFaT7cFo5trOrqCOS364eWa5wprlms5Gsaw9vHiw187rnckU9OM7Z7UJ87C6mkJ5se88847sW3bNoSFdb38kLtTXC/Goz+cxqNjehlNBNYV8mtNP3AacmNSOF64JQk/nSjGxrIgbPxwj972pMgA/PXqLQgWeps4gm0wSZF0M5czRAX5okEsNzq47MyoxNH8Ovh48bH0keFskipTjB8/vtN78SF+qGhqR2WzFKMT7Ws/M6GhW4ptxoge2JtdjX2Xa/D27xnY+eqtFktDWUKtJnht0yWkV8RiQnO7Wc/83NQc7Mmqwh+v3IweZvbbcr4MX/1TgLXPjjEaJdDRNx1G9+jEMKw7WaIX7msvun2SX9OKx388YzHLKMN9w+Ox4vGReu9VmQildvaabmPnFqAZzGRKNXy9+Egw8J6O6BWKHqF+uNbcjiN5tZgyLK7T55kJKeazzPVb0iCxqswHUxc60NfL7PXaPyYIWddEyKtuwwwdLdea2/H0mrMYmxSBhQ8OM/tdhqjVBM+uPw+lSo0Nz99o8fo0B3OujUoMQ35NK2paZChtlCAswHjUzk/Hi7AwNxyfGty7ANP3wOggX1Q0tTttCQIzIRRn4nrkktFNx2fPwdS9yd1wpA6RRIE3tlzCA6N64r7h8Q47rrXYqkU3ezkAvWRqroApw3qmqAEv3Jqkt41r51eTRAGFSjMpHxWos6bbQng513R0BXNadI3uCO342R2ebqY0WLi/j14JY6AjvNyT+sRZ2PxUdfjwYTqga0nNqERtqwzfHLpqVSkhW2Bq+/aPtS7j8ezJAzDYRKh2cb0Ye7OqHdY2ZpbN0CgBgGitJ7rWSHKhvdmaNrx4WxL6RVvW9dtvv3V6Lzak655u9rfVWbPL4/Ew/4FhCA/wwZXqVqw4WGD38Rk2ni3F7qwqXBPJ8d6fmSYjDvZdrsaaE8WoEknZ38gUv5wpRZVIim0XK4xuZ6MQwjsmRJhkarlVrZDIu5bIhekThUqNN7ekW21wA5pJF8MZ2koTScOcXTLM2LkFdISW94vuHJbH4/Fw92BN5vJThQ1GP29Yvz4m2BdBQi+o1ARFdZYzeFezv4dx7yoDu1a8tpXVQgjBe39koqhOjK0Xyk16401RUNuGY/l1OFXYgLPFjTZ91hAmqmJ0Yhh7LjKl7Iyx7eI1qIxcHj4CPu4aaDwe09m1upkJoXiTnm5NH5Q3tTs8mshe6Pjs/pi6N7kbjtSxO6sKh/PqsHR/nsOOaQu2amnQyV4OuNbobpUqcEm7tKeornMCT66dX8zEepi/N3y8+GxIviVPN9d0dAVzWtjs5YG+6KX1dNe2ypyWy8QUjZKOzOUM4QEaxwDj6fakPnEWdgXgV1RUYOfOnSgrK4Ncrn9hLFu2zCENcwd0PYfv/pGJfW+Od5g3mfXGRncuF2YMobcAqa/dioY2qV6W2nUni/HNoavYlVmJR8b0ckjbDL15upgylgghSNM+iI9PjrLqe959991O7zEe0couZDA3FbYaGeiLeTOG4j+/XsTKo4W4e3AMhvcKtes7SurFWLjnCvv38YJ6/Hq2DE/dpO+eb2iT4aPtWezfF0ubOs1MM0jkSrbecZqJUHFj4eVxIX6ICxGiSiRFRrkI4/pG2KUJ6OiT7w5fxeXKFoT4eWP7f25mZzxN8crGNJwtbsTurCq9ZQXVRjKXAx0PKRK5Cm0ypd56b0dg7NwCOpKomfKujukdjvWnSkz+/mXMtaGNNODxeOgfE4S00ibk17SazWEAdGRyN+VdZWDaV1DTihVaLRvPluHEVU0VA6WaILOiGWP7WN/XuppSMytxS79Iqz9r6lijEsJQ3tiOcyWNJkPiVGqCQu3D4c5Xb9HLO+DnLYCfj/HoAGcn26uy4OnuHRGAw7PvQEK4f7eXAdKFjs/ujal7k7vhSB1MtZHSBgkqLUSNOQNbtChVatYIYTyTrjS6zxQ1QqldzlXaIIFCpYa3TtQS186vjszlmmcAJjpA1K6AXKk2GXHINR1dwZQWlZqwSfmig3wR6u+NAB8BxHIVKpvb0SfKOvvAETCZyxlDG+gIL2dCzz2pT5yFzZ7ugwcPYsCAAVi5ciWWLl2Kw4cPY926dVi7di3S09Od0ERuolYTdjYxWOiFKpEUc3flOOTYYpmSzTRtTXg5A5/Pww8rliI8wId9PTiqJwCNZ67RBq+kKdrlKtagNlzTDZgeXK41t6O2VQYvPg8pPUOt+q6FCxd2eo9Z+9sVT7e5taJTh8Vh+vB4qNQEb2/NsGs2UaUmmL01A+0KFcb1icBYH41XesGeXNYoAzQTER//lY36NjmCtdlNL5oJAc8oF0GlHUyzr7VApuzcNt0a3bqw67q7GGK+cOFCZF8T4dtDVwEAc2cMRZ+oQL1zzthrujYkcHdmld7xGMMm1sDoDvD1YtcDO+NBxdi5BZguUcUwKjEUAHClugViWeeogTIjUSAdBrLlsmFszfJgC55ubQRMUZ0Y8xYsQmmDGAv35AKAzrnUbPH7dNE9N/7OrobCzkz+da0ylDVKwOMBIxJC2XPRVAbzMm1IvwBqDIkP0TtvTBncgPNrdVda8HR7CfhIigzoFBHRndDx2f0xdW9yNxypg8mzAWhCpl2NLVoYjyCP1xF+G+nCNd26UZdKNek02cm184t5nmQmUUP8vNl7KhO2bAyu6egKprQ0iuVQE825FB6gCetm13W7OMS8USdzOYNheLkn9YmzsNno/uCDDzB79mxkZWVBKBTizz//RHl5OW6//XY8/PDDzmgjJymqb4OoXQE/bwFWPT0aPB6wNa0CB3NrunzsAu0AExXka3INpCnmzJmj93dSZACGxAdDpSYWQ5etgakPGCz0MurdjDZhdDOer8HxwWYfpHUx1AJ0hN0yxpqtSLUZnwEgOcb4LOHn9w1BVJAvrta22RXOtvZEMS6UNiHAR4Al/0rBpv+9hLFJ4ZDIVZj9RwabVGxXZhX2ZFVDwOfhp5ljIODzUCWSsg/7hugaRXKVGtnXWvS2i9oV7Ay7YRTC6ISOet1d4Z33P8Bbv6dDqSaYOiwW01M6r2s2xpShsRDweci6JkJJfUeYMWvYGPFcmFuq0FWMnVuA7oSM8XMjLsQP8SFCqAmQUd6st02qULE1m3XzHTDHyrNi7S+bvMtEEjWG+BAhAn29oFQTPPria3hnayYkchXGJoXj1bv6AbC9r3UT7TVLFCZD6C0eR3ueDogJQrDQu8PoNuHpZqJ6BvUItcmAdWatbrFMiRZtKTvDCSEuQ8dn98fUvcndcKSOQh2j+7Sd96WuYIsWxjgJ9/dh72eMM6LeBZ7uEwWaaCcm+MZwWRPXzq8a7ZjJ/EZ8Po9NQGduwp1rOrqCKS1M5vJwfx82x0qvcM2zkqvLhjGGdbiOTRLmrx9e7kl94ixsNrpzc3PxzDPPANCkh29vb0dgYCA+//xzLF682OEN5CrMA21KzxDc3DcSL9yiCQl+f1sWG4ZhL/nV5h/8zTFv3rxO792bovEypmZWdqldgE5ouREvN2A6AdZFnXBTazGmhTHO7A0vv1qrKcUW5u/NesoMCQvwwSJtEqqfThTjfIn161sLalrxhdZQ//jewegV7o8FC+bji38Nh7+PAOeKG7HuVAlqW6X45K9sAMCsO/vhxqRwdk2+KWOJeZ+xSwyzkTMz2pGBPp1KLI3W8XR3Zf3pI5+tR35NGyICfDD3/qFWh9VGBPriZm1Y++4sjbebENIRwmvEsIly4rpuY+eWUqVmH1DMRZgwUQOG/cT8/kG+XuxgpHusAiuMblPZ3A3h8XjspNGzK/bgXEkjAnwE+PLh4RidGA7Atr5uFMtRpJ0MYbK0p2bYd79gr3Xt78QsdTAVXs78LtKaEpu+h73XOCG8nDkvg3y9EOSgJUOugI7P7o+xe5M74igdYpmSvS8CwOlu8HTbosUwcznguuzl5Y0SFNWLIeDzcHt/zTK+QoN13Vw7vxjDOkYnuosJyzeXM4ZrOrqCKS26SdQYOmp1d4+nW8/oDtD3dHtSnzgLm43ugIAAdp1YXFwcCgsL2W319fWOaxnHSdNJFARoEpn1jQpAXauMrUNtL4y3LdmKZGOGzJw5s9N707RZls8UNXQ5VJdJhqSbqEsXU94nZv0783tZgzEtjHFW3yYzGl5tiXydGszmDMYJg2Lwr9E9QQgwe2uGVQnIlCo1Zm/NgFypxh0DovCodg39zJkzkRDhj4+mDQIALNl7BbN+vYhmiQJD4oPx6p0az+RoE8YcoDFQGQ/iPUNjje5nbq394PhgCL35aJYoWOPKVi6WNSFLqfnuBQ8OQ4SJSQtTMOdhqjbEvKVdCYk22ZdhIjXAuUa3sXOrpEECuUoNfx+B2QzybD8ZhOqX6ayn1z23GKO7tFFicbmCqWzuxuivvT9UqzX/fjhtEHqF+2Noj2D4CPhoFMvZevSWYAzlvlEBbN6BfZerIVfaHmKeZjDBxiSVq26RGtWfr/ViTRwz2KbvYZeyOOFB1tqIA65Bx2f3x9i9yR1xlA7GaAwWekHA56Giqd3lJZNs0WKYRA3oiABsaJOxS8ScAZPTY0SvUAzXLuMz9HRz7fxiHDTROoYlE47fYObezjUdXcGUFuNGt+bZxNXXgFGjmwkv127zpD5xFjYb3TfddBNOnDgBAJg6dSrefvttzJ8/H88//zxuuukmhzewO2iXq/DT8SKzYa3MeknmAVzoLcDSR0aAz9NkaX7vj0ws2JPLvhbuycUlK9fTMg+hA6zMXK7LwYMHO72XEOGP4T1DoCbA3uwqI58yzuVKERb+naungylFYcrTza6zbJGxXjbdBGC2GN3GtIQH+MBXm1jDHg9XvpHM5ab4ZPpgxIUIUdogwf/9kqb3Oxh7zfrtIjIqRAgWemHRgyms4cXoeOLGBNyWHAmZUo3zJU3wFvCw9JHhbKIQxjNo7DwpqhejWaKA0JvPGkVpBp5Mc6XcvAV8pPQI1XzOjhBzqUKF2VszoCbAAyN7YPKQWJuPcc/QWHjxecitakFhXRubNCzM39vokgNTSxW6Sm5VCxb/eRJKgzXLHZNdgeCbCXMezfZTs179cVP16yMDfRDm7w1C9NcmGqPKRDZ3Y+guj7gtORJP3JgAAPD1EmBYzxAA1tdmv6gzKTamdziignzRIlXixFXbqjLIlWpkXhOxxwI012ygrxcIMR4Sx0T2tJTbtpTDmQ+y7Np6K/qBS1wP47OnY2zcc0ccpYO5Zw6OD0aK9r7m6nXdtmhhDEUmIRjArMcF1AQOya1jCia0/LbkSPSJ0jwHFNXrjzlcO78ME6kBHRMW5jKYc01HVzClRTdzOUN3e7p113QzEX1N2vByT+oTZ2FzSuBly5ahrU1zEX/22Wdoa2vDli1bkJyc7DGZUb87fBXfHr6KCyVNWPX06E7bmyVydiAYqRMuPaJXKP5zRz98e/gqtlwo7/S5nRmVOPneXWYf6IGuhZf379/f6PvTUuKQUSFCamYVnh7X2+JxmsRyPLvuvEmDp6+JrImMp7tdock6HST0ZhOAxQYLbco6akwLj8dDXIgQJdospr2MeHXNwYSyDrAiQV2w0BuLH0rBM2vP4XhBPY4XWOcp+uz+IXrrQBkdPB4Pix9KweSvjqFVqsSbd/fHwNiObNaMkXK5sgXtcpWeIcouZ+gRilEJYfDi81DXKkNFU8dvwCRpM/Wb3NA7DOdKGvHr2TI8OLKHTXWYl+zNQ1GdGGFCHv43fYjVn9Ml1N8HtyZH4kheHXZnVmFoD412U4aNs2p1v/9nJjKqg9D30FW8eXfHOaYbBWGOQXGaqAFRuwJF9W1s+Ts2iZqB0a0JBQ/CueJG5Ne0YmiPEKPHbZEq0KZNzhZvhYeVOY6/l+a80vWuj04MQ1ppE9LKmvDQ6J4Wj6UbuSPg8zBtWBzWnypBakYV7hoYY/HzDJcrRZAr1QgP8EFvnQzuvcL9kVvVgrJGiV65QIVKzT4Ujh1oW3WFiEBf8LUPsg1tMjYHgCNgJoSs6QcucT2Mz56OqTHc3XCUDuZZq190IIKE3rhU1ozTRQ14+AbHVGOxBlu0MIairqfbS8BHRIAP6tvkqGuV6XkuHYVKTVhP923JUaxzotDA082188swkRrQ4ek2V6ubazq6gikt5jzdrja6ja3pZvI6tUgVUKmJR/WJs7DJ6FapVKioqEBKSgoATSjbqlWrnNKw7oIQgl3atc+H8mrRKlV0WtPHZC3vExmgdwICwH8nJiPYzwv1BjN0v50tQ5VIirSyJozpHW7y+0XtCjYZkzW1rA1pbzd+IU5LiceCPVdwrqQRNS1SvfUzxvh052XUtcrQO8Ifkwy8muEBPuy6T0P8fbwQ6OuFNpkSda0yBAm99bxojtASF+KHkgaJXcnU8mutM6wYxvePwrdPjERmhciq/ftEBmDGiB567+nqiA/1w4bnb0R2ZQvrmWS3hQgRE+yLmhZZp3JPuutkhd4CDOkRgozyZlwsa+owug1qRBvy9LhE/HKmFBnlzfjhWBFmacPaLXG2qAHrThUDAGYO8kKIv/1rXO9NiceRvDqkZlay144pw8YZnm6lSs1GXXx3+ComDophvcJMdnFLEzLeAj5SeobiXHEj0kqbOhvdRn7//jGBWqPbtKeb8a6G+HnD38fyrXlsUjgWPDAM7ZV5nSazRiWEArDO061QqZFR0az9nOYavTdFY3Tvz6mBVKGC0Nu65Ie6oeW6kwCJWqPbMIN5aYMYChVBgI8A/rCtnwV8HiICfVHXKkNtq2ONbnf0dF8P4/P1gKlxz91wlA4msWy/qED0iQrEyiOFOFvUCEKIy0r12aKlwUgYLqAxJOvb5GxyLEeTdU0EUbsCQUIvDO8ZArk2kqtRLEezRM4aSFw6vwghRsPLrfF0c0lHVzGlhTlXInU83Uyt7vo2WSfnjDNpFGu82frZyzXPgoRobBdP6hNnYZPRLRAIMGnSJOTm5iI0NNRJTepesq91PBjKlWr8k1uDB0bqe4rSDBIF6eIt4OOl8X07vV/fJsO2i9eQmlFp1ui+qjUK40KECPGz3bhpaDAedtUj1A+jEkJxsawZe7Kq8NwtxmtBA8CerCrszKiEgM/D14+NtLlWdXSQL9pkStS2ytAnKrBTYiVrMaWFWdddaWPZMLFMifJG20ux3ZsSzyajswdDHSMTwvQiJBh4PB5GJ4ZhT1Y10sqa9IxuwxwCoxPCkFHejLTSJtyvNfJNhTczxIX44dPpQzB7awa++icfEwZF63najSGWKTH7jwwQAjw2phfiVVfM7m+JuwfHwEfAR35NG47m17HtMga7ptuBibJKGyXsw4hSTfD21nTseu1W+HoJ2OziprLa6zI6MYw1uh8do5k8MZfvgDHk880kU2PXEVuZLZvH4+GJsQn4/fcznbYxxnNeTStapAoEm0kGllvVAqlCjWChFxvBMiohDLHBQlS3SHEsv67TxJspmAk2prQag6myYXnV2gfqmCA0NV6z6jt0iQ7SGN2OXoJQaWNfcIHrYXy+HjA17rkbjtJRyHq6gzAqMRRefB6uNbejvLHd5DI3R2OLFja83CDnSVSQL65UtzqtVvcJbamwm/tGwEvAh5eAj7gQIapEUhTWiTE6UWvIcuj8apUpIVVoxmPd8PLIAMtrurmko6uY0mLM0x3i740goRdapUpca5bY5ZyzFUKIUU+3t4DPtqVRLPeoPnEWNq/pHjp0KIqKipzRFk6QmqXxcntpQ8BTMzqvgbbHcztda7Ttya42u/6QeQi11hNryPDhw01um5ZivFayLvVtMszZocmq/crtfW02uAEgUicBFiHEriRqgGktTHKjKhszmDNhapGBvp1moZ2JuT4xhDGWdD2UIomCne1nPJijDepuy5Vq1mgz5mlleGhUD0wcFAOFiuCtLRkWE2Ut2JOL8sZ29Aj1w0fTBtmkxRghft4Y3z8SAPCPtryeqWRVTLiZIxNlMcsLegZ7IzLQF/k1bVh+oABypZotZWbNhAxTgo3J7aBWE7ZuprFJj2SrjG5t5nIblmAAxs+v6GAheoX7gRgpbWaI7qQYs/SFz+dhGpPF3Mz9QhdCSMfkkMGkEvNwbJj8hS3RFh1o17nVkWzPsUsQ7O2L7sbTx+frga7eY7mCI3TIlWq21GC/6ED4+3ixzySuXNdtixZm7WukwTOGszOYH9Muf7s1OYp9j5lE1c1gzqXzi5lQDxJ66XlsWU+3mfXvXNLRVUxpMWZ0A3B5re4WqZK1W0INIh0Zz3ezRO5RfeIsbDa6582bh9mzZyM1NRVVVVVoaWnRe7kzhBDWIH3trmQAwLGCOojaFew+SpUa6dqHWFuMyFv6RSLEzxt1rTKcKzZdgkr3IdQeUlNTTW6bNiwOPB5wobTJaC1oQgg+3JaFRrEcA2OD8PqEZLvaEM16KKVsAjBfLz5bEstaTGlhPKNVNnq6LdVgdhbm+sSQDmO6mU2SdqlcY8gkRQaws+eMJzG3qhVimRLXmtuhJoCft8DsejEej4cFDw5FqL83cqpa8O3hqyb3PZZfh1/PlgEAvng4BUFCb5u0mIKJGmBywJkqj8XMfDeK5XZl0TYGM6kVKKvHggeGAgB+PFaIP9IqoFQTBPl6WeXdZKI2rta2oVkiR02rFHKlGl58ntHPM4Z8RVM7xDLjmfCZzOW21oU21SfW1mZPY5JCGhjKzBKSf3Jr0C63XCmgUiRFTYsMXnweUrSZcxmYiSDDWt0F2sieAbFBdp1b0U6IhiCEdGSRdyNPN+DZ4/P1giPusVzAETpKGsRQqQkCfb0Qo52EHaeNAHNl6TBbtJgKL49yUmJQAGiTKdnJ0/HJkez7bDI1nXXdXDq/mGTF0QbPLBFs9nLTRjeXdHQVU1rYRGqdjG7tum4XZTBnspMH+Ag6LTXTTabmSX3iLGw2uqdOnYqMjAzcd9996NmzJ8LCwhAWFobQ0FCEhdnmyeQamRXNqGhqh7+PAC+N74P+MYFQqAj2X65m97lS3QqJXIUgoRf6mUgmZgwfLz4mD9EkJDJXL5t5CO1vR+ZyAHjllVdMbosNEWKMtobvnqzO3qsd6dewP6cG3gIelj0ygs2qbSuMsVTXJtOrZ27r8UxpYdYA21qru8Podn44ji7m+sSQIfGa30m33BMzmI7UerkBzcRDfIgQKjVBRkUzG9qcYFCuyhjRQULMvV9jcH53+CqyjKxXF7Ur8N6fmQCAmeMScXPfSJu1mGLCoGi9c8GUkRnq5w1vgUaLo9bBMWv6p902CpOGxOLBUT2gJmBrpifHBFq1TjA8wAdJkZoHmktlzWzYdI8wP6MJ6sIDfNh1WQUmMph31Oi2zdAz1Sem6okbYmr5x4heoegR6geJXIUjebUW28F8z5D44E7rzJiQ+7JGiV7G97zqjhwL9pxbHcn2HPcg2ypTQmymlB2X8eTx+XrBEfdYLuAIHUx0Wt/ojvvyTYzRXdigV73DmdiixVx4OeAco/tsUQOUaoKEcH+96iWMp7tIx9PNpfOLTaIWpD/mMXW669tkJvuYSzq6ijEtMqUKzdqs4FEG51IvF2cwb9SGlocZiRDVrdXtSX3iLGy2qg4fPsy+Dh06xL6Yv92ZfZc14a4TBsXAz0eAacM0Hjnd8EomnHdkQpjFLOSGMB6+vdnVncoVMXSUtLLPMLSUoZYJGd2VWYUmsZx9Fda14dO/NPXFX78rGYPjbfNK68KGBbfI2PJXtq7nBkxrsd/T3bXf1l5syRrs48VHijYrNWPEmArPZ37Ti6VNJjNnm2L68HhMS4mDSruuua5Vpnc+fL4rB1UiKXpH+OO9KQPt0mKKIKE37hzQEQJnytPN5/NYQ9XQqFKriV1lopjw8uwT+wEAn04fgthgIZTaY9lybozS8SSXmamRzsBEWJgKMe9Y022boWeqT5j2pZc1m/ytqkTtuNbcDj4PnZaS8Hg81tu9I/2a3vlh7MWEexrLVxAfKoSAz4NcqWb7UqZUsRNL/WMC7Tq32HuNkQdZU/dYSzDLVkJNlLLjMp48Pl8veEqWeUfoYIzuZJ3Iv9GJYfAW8FDdIu2UI8JZWKtFrlSjs6U7rgAAQzlJREFURaqJZIow4el2RiK142xoeaTe+4ynWze8nEvnF5tELdjQ06357WRKNTsBagiXdHQVY1oYL78Xn9cpv5OrM5g3mYjeAPRrdXtSnzgLm0uG3X777c5oByfYd7kagIB90Lx3eByW/5OPk1fr0SSWIyzAh/UKGYZiWsPNfSMQ5u+NBrEcp4sacJvO2htAU8OWeXhMtjO8fM6cOWa3TxkWi//tuoyM8maMnHug0/aUniF45Y7OieBsIUrHUGJuqvb8Xqa0MEZak0RhU/bGgm4KL7fUJ4aMTgzDhdImpJU2YcaIeKQb1ITX3S81swoXy5rRR+t1NWf0GTL3/qE4W9SA/Jo2jJn/T6ftPB7w5cPD9TJp26rFFPemxLOTXDEhpsPho4N8USWS6hlVUoUKj/54BnUtUuyYdYvVWavlSjUbZvfJGy8C0KwxX/TQMDy77jwA23IpjE4Mw58XK9iJOMCS0R2EU4UNbElAQ9iM2TaWqTLVJwNjg+DvI0CrTImC2lajSfMuljZr9w1GoG/n4eDelHj8cKwI+y7XYN/lzvcLYxhbduMl4KNHqB/KGiUobRAjNkSI4npN6GiQ0AuxwUK7zq2Oe41+1Mu2ixV4549MvH/PQLw4vo9Nx2Qe9N3Nyw149vh8veCoe2x34wgduuXCGPx8BBjZS1P+8nRRA3pHdk5c6Wis1cIkmxIYMZSYCWRneLqPa5Ooje9kdGt+t7JGCZQqNbwEfE6dXx01uvWfAfx9vODvI4BErkJDm8zo2NQdOgghkCrUDp+MNaZFN3O5oYOPMbrLm1wz6WRqyQTQsca7SaLg1LnFVeyLH/ZQalo0F/ft/TXGcN+oQAyKC4ZSTbQGuWmvozV4Cfi4Z6jGoDdMZkYIwUfbNSGuY3qHIcDITcYa5s2bZ3Z7dJAQj5qobxkZ6IOlDw+3qX6z0e/QzloW1rWx3mV7PN2mtAT7aW7IANjyapZokSrY8F17k9TZi6U+MUTXg51X0wqxXIUgXy8kG2Sp1E2mVmIhc7kxwgN88MXDwyH07tzffB7w3wnJuMEg076tWkwxcVAMRiWE4oGRPeDrZXoAizJSq3v5gXxklDejUiTFB9uyrA4xLGkQQ6ldH7j2m6Xs+3cMiMasO/siJtgXdw+yviY18/unlzejWJuEzdzvz0SPGCs/RwjpqA1to7Fnqk+8BHyM0HqvGePaEEtJIYf2CMb4/lFGtxmjV7gfbjN48GNgM5hrozKY0PL+MUHg8Xh2nVvMvUY3EqK8UYKPd2RDpSZYvPcKsq9ZV+4P0GTrX7Q3FwBwUx/TVSYoFGfhqHtsd+MIHbrlwnRhrs3Tha5Z122tFsZQCvP36WQoseHlDvZ0X2tuR2GdGHweMK6v/r03LlgIP28BFKqORJ9cOr9MhZcDHd5uw/K7DK7SIZIosDuzCu/+kYGbFh7EoE/26i05dQTGtJhKogaALRPrck+3f2ejO1wnkRqXzi2uYp9l58HcPThGL1HAvSlxyK1qQWpmFe4aGI3yRiYUM8Su409PicOmc2XYe7kac2cMhbfWwN1yvhxH8+vg48XHwgeH2d3+//u//7O4z6KHUrDggc7fwePBIXUvmRsokwE4McJfr86gtZjSwuNpklUV1olR1dzOrq01B1ODOTbYvlJsXcGaPtGFCQvOr21ly2qNSAiFwGAQHxQXDKE3H80SBRvaa4unGwDuHBCN3M/vgTG71djyCVu1mMLPR4Bt/7nF4n6sUaWdEb9Q0ogfj2uyM3vxeTh4pRZb0yrwiImJJF3ydUqCvfywvo53Jg/EO5MHGvuYSZKjAxHk64VWmZLtpwQj5cIYmH7NqGiGXKnWW9feLFGwpVNsTaRmrk9GJ4bhVGED0kqb8MTYhE7bDUvRGcLj8bDh+Rv11mGbw9w9hDk3mQzmBexyj0CLOkyhu6abEAJCgHf+yIBYroIXnwelmmD21gz89eotZid3GBb+3ZGt/627+9vcHgqlqzjqHtvddFWHSk3Ytcj9DCL/buobgRWHruJMUYNL6nVbq4XNXB7Y2ThhonKaJQrIlCqr7kfWwJQKG94rtNOzDZ/PQ1JkAHKqWlBY24akyABOnV+mwssBICLAF+WN7SbLhjlbx8WyJizYnYtL5Z2XZ+1Iv2Z1GU1rMKbFnNHdQ+vpbhTLIZYp7XbSWYu5Nd2hOmu63+bQucVVqKfbACa03PDvU4X1OKAtcdQ/JghBZuremmNsnwhEBvqgWaLAiauadTjljRLMTc0BALwzaUCX6u5t27bNqv34fF6nl6MGLsNQIXtCywHzWphSPoz32hIFNtRgdjTW9glDVJAvEsL9QQiw4VQpgA6DTRdvAZ/NEt2mzYhtq9ENaIwkY+eDMWzV0lWidcrPSeRKzN6qqRn+0KieeHvSAADA3F05uGYkG78hTFh3/+ggh+jg83kYoU1uZ83v3ycyAKH+3pAp1cip0s8kzXi5IwJ8OmUHtYQ5LWwJurLOydSkChUuV4r09jOFsfPD1nsIm8FcG5VhmNjQnj5hHkjkSjVa2pXYcLoEZ4oa4ectwO8vj0NEgA+uVLdixcECi8c6XlCHjWe02fr/lWL3PZ5C6Qquvsc6i67quNbUDpl2crKXwX11VEIYfLz4qG2VoahebOIIjsNaLcw6XGNhuCE6iUHNZeW2FWY99239jEcYsRnM6zUTGFw6v8x5uiMtlA1zto75u3NxobQJKjVBcnQg/n1rEuZMGwQAOFPUaPVEtDUY08Ia3UYcVsFCb3aCxRXebvNrurXh5WIFp84trkKNbh0ChYJO66wTIwIwrEcI1AT46h/Ng5s9oeUMAj4PU3RCzNVqgnf/yIRYrsINiWF4/tYk+wUAGDNmTJc+7whC/TsGF8C+0HLAvJbYYKZWt3U3nLxuylwO2NcnzDnGhM+bOud03+fzOuo3OgtXn1+6GV8X/30FJQ0SxIUI8cn0wXhpfB+MTAhFq0yJ9/7ItBhmzix1SI4JdJgOw34xl8iOz+cZrcMO2L+eGzDfJ0zG++J6cSePQdY1ERQqgshAX/QKd/76ZcPwckOj254+EXoLECTUzPKfLW7Aor1XAAAfTh2IUQlhmK8tC7fySCGb1NEYLVIF3v1Dk63/mXGJuNnEAyyF4my4MIY7gq7quFqnuT/0iQzoFOUl9BZgpAvrdVurhTEQDTOXA/qJQR21rlulJqzzxtQyILZWd61mcoJL5xe7ptuEpxuASU+3M3WUN0qQVtoEHg/Y/+Z4HHjrdsy5dzCeGdcbft4CNIrlJquQ2IMxLabKhTF0JFNz/rruRrEmi3qYkfByNpGaRM6pc4urUKNbhwkDY4yWtWIyfjM3yq4Y3UCH93zf5WqsOVGM00UN8PMW4MuHh3caXGylqqpzKTBXw+Px9Gbn7P29zGmJs9nTrblBDugGo9uePtGdqODxwHpUDdGNIogL8bO7zJu1uPr8YmbAz5c04ufTGq//4odSEOLnDQGfh6XaNeknrtZjo7amuCnydWpCO0qH7rkdGehjNOGLsf3TDAzAKu3kij3Ju8xpCfX3YUMzL2kT8jGwSSETQ50engl0hN6XN0ogVahY45uJPrG3T5hoiPf+zIRUocYt/SLw5NhEAMA9Q+MwY0Q81AR4e2sGpArjmXDnarP1J0b44/0pti0zoFAcCRfGcEfQVR3GkqjpMq6vpnTYKRes67ZWC1suzIhHEHB8BvPLlSI0SxQI9PXqVH2CwdDTzZXzSyJXshFihtGRgOU13c7UsTNDU9b35r4Reo4aHy8+buitGcNPF9Y77PuMaWHsDWNLFQDXlg1jEgSGB3SO/uowuhWcObe4jM1P6CNHjsSoUaM6vUaPHo1bbrkFM2fOxOHDh53RVqdzz1DjazSmDdMPOe+q0T2mdziig3zRKlVi/h5N0p4Ppg50SBZOlcr4Q6WridJ6ogN9vez2LpvTwtQytrZsWH43hpfb0ye6xvSAmCAEmwh11TXO7QkttxVXn1/MYCxq18y0PjE2QW9Gv09UIN7VrsVeuCeXrVduiFShQok2DLF/TJDDdIzoFQrGXjUMgTSGaU83Uy7Mdk+3JS3MuWRo6Ftaz+1omCiARrEc6eXNIEQTmsZM0NnbJ8zETJP24XPJv4brLY/47L6hiA7yRVGdGF/uy+v0+YO5NdiaVgEeD1hqkK3f3fDk8fl6gStjuLW0y1X4J6cGrVKF3vtd1WHJ6GaiEg/m1rDhr87CWi1M2LhJo9vBnm4mtHxc3wg2P5AhHbW6NeMfV84vxsvt5y0wOlnNRAuYmqBwlg5CCHZcugYAuH94j07bmTrxZ4oaHfadxrTUs55u488EbAbzRud7upnry6inW2uIN0vkUCq5cW5xGZuN7nvuuQdFRUUICAjAnXfeiTvvvBOBgYEoLCzEmDFjUFVVhYkTJ+Kvv/5yRnudCnMxGdIr3J/NAhwR4NNl44bP52GqjiF/c98IPKX1zHSV3r17O+Q4XYUxlkb06pwAzFrMaWE83UxYLoNMqcKy/Xl4749M9vXO1gx27ZCrM5cD9vXJgNggBGgztBure8wQHuDDJpKzJXO5vbj6/NINO+sZ5ocPpw7qtM+zN/fG2KRwSOQqvLM10+haq6I6MdQECBZ6ITrI12E6goTebPREohX3heG9QiDg81AlkqJSZ2kEk3TQHk+3JS2jEkMBADvTK/Wui9PasExL67kdRaCvF/sw+k+OJj9GsjZzOWD/uaV7jnxy72D0CNX/DUP8vbH4oRQAwJqTxXjr93S93+G9PzVh5f++NalTtn53w5PH5+sFrozh1rJgTy7+veEC7vzyCDadK2OTTnVVhyWje1RCKAbHBUOqUOO3c+ajnLqKtVrMhZcDji8bxpQKM1UxAgD7fNAglqNZIufM+cWu5w72NRppxa7pNuHpdpaO3KpWFNS2wceLj3uGdXbEsUZ3cYPD1nUb02IukRrg2lrdjRJza7o17ynVBNE9Oidrpehjs9FdX1+Pt99+G8ePH8fSpUuxdOlSHDt2DLNnz4ZYLMb+/fsxZ84czJ071xntdSqmZgoBYMaIeACarJmOCMW8X3s8jWcmxWTiKls5fvy4Q47TVRgDpCtld8xpYTzdlQae7uUHCrDi0FVsuVDOvramVQDQrA2zFP7rDOzpEwGfh7Ham/vNfY1PBjEw2wfFda7D7GhcfX5FBvqyffblw8ON9h+fz9PWExfgXEmj0TV+TKTDgFiNkedIHTdry7RY8/v7+3hhUJzGSNdNbsYY4PF2rOm2pOXGJM35ca25Xe+6aJUq4e8jwNAe9lVisAfG2/0Pm5Sy44Ha3j7pHaF5qLxrYDQevqGn0X3uHBiNR2/oBUKAbRev6f0O9W1y9IsOZBPzuTOePD5fL3BlDLcGpUqN1ExNKG59mxwfbMvCtBXHcaKgvks6CCEd5cJMGN08Hg8vaHPgbDhdArlSbff3WcJaLQ1ijaFkzDgBHFs2TCJXstFKhrmIdAnw9WIjqArrxJw5v9jM5SaMSmaCgvlNDXGWjr/SNV7uuwZEG40wTOkZAn8fAZolClzRJmftKsa0WDK6mci6Mid7upUqNRtpaCx7udBbwJadPXTyrFPb4gnYbIH8/vvvSEtL6/T+Y489htGjR2P16tV4/PHHsWzZMoc0kCs8Pa43wgJ82HVEXWVkQhh+euYGxIUKHZr86vHHH3fYsbrCrDv7oX9MELse3h7MaWE83a1SzbqgQF8vpJU24cdjhQCAF25N0hv4eDzNQ3l3YG+fLHhgGM6XNHbKqG/Ie1MG4obeYZg2LN6u77EFV59f3gI+fn7+RsiUKpORKIBmALpveDw2ny9HalZVp0RYHcsLNAavI3W8Pak/hvYI1oteMcfohDBkX2tBWmkT7k3R9FlXPN2WtCRFBmD1Mzewv4EuY5PCbc6W3hUSwv1xqayZrSuvm2PB3j554bYk9Ar3x5ShsWYnRD+7fwgGxQVBLNcPgRPweZg2LM6lv4OzuF7HZ0+CK2O4NZwrbkSTRIHwAB/8546+WHGwAFeqW/HUmrO4re9IPC6WmzRAzVHXKkOrVAk+D2ZLgk4fHo9Fe6+gpkWGPVlVmDGycziwI7C2T8yVDAP0E4N2lbNFjVCoCHqG+aG3hSi3PlEBqBJJUVTXxpnzqyOJmvGJ5ggLnm5n6FCrCbuee8ZI489T3gI+bugdjmP5dThT1IDB8V13dhhqEcuU7DhlyugeEKsZO69Ut6C2VWo0A7wjELUrQIjmGTrURLndcH8fVIqkGD9xilPa4EnY7OkWCoU4depUp/dPnToFoVDT6Wq1mv2/pyDg83D/iB4OPbEnDo7BkHjHepm+//57hx7PXsICfPDImF5dqh9oTkugrxebtbha1I52uQqzt2ZATYAHRvbAx/cOxqw7+7Gv/9zRDwNjne8JNoa9fRIbIsT04fEWIyuChd54YGRPpydRA7rn/BqdGMZ6k83BGLB7s6uhVOl7PZjM5f21XhNH6gjw9cKDo3pabbQx6/CZdd1qNUE1a3Tbfn+xRsvdg2P0rgfm5epwasMQfN3lHvb2SbDQG/8a3dPivUboLcCztyR1+g1evr2vVevx3YHrdXz2JLgyhlvD3svVAIBJg2Pw79v64Og7d+LZm3tDwOfheGETFv99xa7jMqHlCeH+ZutZ+3jx8cxNmqV5a04UW6xgYS/W9om5kmGAYxOpHdMJLbf0jMBmMK8Tc+b86igXZtyoZLKXN0rknepkA865Ts6VNKJKJEWQ0At3DDDtpBmndQCcdlDmfEMtzPnh5y1glxka0jPMH6MSQqEmwK4M5yUwYyaSQvy84WUiGjhUG2K+cet2p7XDU7DZInrttdfw8ssvIy0tjU0Pf/78efz000/48MMPAQD79u3DiBEjHNpQinXMmTOnu5vgMCxpiQ/xQ560FZXNUvx6tgzF9WLEBPvif9OHuKiF1nE99Ul3clOfcEQE+KBBLMepwga9hGtseSrt7HB36mDWUF+ubIFUoUKrVAm5Sg0eTzPRYitc7hNDEiL0vVa6SRbdSQdXoeOz++Mu14FaTbA3W2N0T9YmoQ0L8MH/7huCCYOi8fSac9iVWYmPpw+2eVnX1TrzoeW6PHlTIr49fBVZ10Q4X9KEG5McP5FoTZ9IFSo2G7epNd2O9HSfYOpzmwktZ+ijjRYoqmvDjxw5vzrCy42PeWH+3uDxAEI02bMjDX5TZ1wnf6VrvNxThsaanURnIl7PFjVApSZdrjpkqIUxuiODfMxOqNw/ogculjVjZ/o1dqmFo2GM7nAjSdQYmGRq99z/kFPa4EnY7BqbM2cOVq9ejXPnzuH111/H66+/jnPnzmH16tX46KOPAAAvv/wydu3a5fDGUiwzb9687m6Cw7CkhalpvOPSNaw7WQJAW07K33gITHdxPfVJd+Il4LMVCHZndsz8tstVKNfWsmSMvO7U0TPMD9FBvlCqCTIrRGwG/qhAX7N5JUzB5T4xRDfZX2Sgj55HyJ10cBU6Prs/7nIdXCpvRm2rDEG+Xp3yjtzaLxIhPCkkchV2acN1baEjiZrlxKfhAT54cJQmrHzNiSKbv8sarOkTxjjxFvAQLDQ+yeCo7OVVonYU1LaBx7Oc8wUA+monL4rqxZw5v9jwchOebi8Bn03SZSzE3NE65Eo19mRpnhvuH2F+mcLQ+GAE+nqhRapEblVLl7/bUAu7ntvE5A3DtJQ4CPg8ZFSIUFxvvHJLV2HKhRlbz83AeLq3bN/tlDZ4EnbFoz755JM4ffo0Ghsb0djYiNOnT+OJJ55gt/v5+dHwtW7i9ddf7+4mOAxLWphQ3G3a8g6PjellNiSou7ie+qS7YUPML1eziXWu1raBEM3DGTNb3p06eDxeR73u0iZUajPwx4Xavp4b4H6f6KJb+cGwlKA76eAydHx2bxx5HYjaFU57GN+nDS2fMCi6Uwg4j8fDC3dqKk1stiOzuKXM5YY8f4vGy7c/p8Zk2ciuYE2fsB7BANPeyUitgSmWqyDWesXtgfFyp/QMZQ0ec/TRhpeXNojxn1dfs/t7HQnr6Q42bVgy1S4ajITjO3q8OJpfB1G7AtFBvmbzxwCaCYEx2nrdxhK32oqhFktJ1BgiA31xqzZ/DZMAztE0irVJ1MycZ4wXfPiYcU5pgydh9yJQuVyOiooKlJWV6b0o3cv69eu7uwkOw5IW3aRTPUL98NG0zuWkuMD11CfdzY1J4YgK8oWoXYGTVzUPJnlMaLlOpuzu1qFrdFdrPd3xdoSWA92vxRaig3zZTKeGRrc76eA6dHx2Xxx1HaSXN2PC0qO488sjePW3iw6t50sIwd/ZGq8gE11kiOTyYXgLNF64nErbvIG2Gt3JMUG4vX8UCAEb9eZIrOkTJiQ4PMC0oRTgI4CfNmy5K+u6mfrc482UCtMlLlgIoTcfChXBN2t/s/t7HUnHmm7T4x6TTK3eSB12R48XO7RG6/Th8VaFizOG+enCrhvdhlqsNbqBjoRvf6VXOiWnQRNbLsx0BGmYNrr0zKVsh3+/p2Gz0V1QUIDbbrsNfn5+SExMRFJSEpKSktC7d28kJTlnTQHFeiZOnNjdTXAYlrToJp364uEUBBkp78AFrqc+6W4EfB6mah8CU7Uh5gWs0d1h5HW3DiaZ2qWyJjZzuT3ruYHu12ILPB6P9XYnx+g/ULuTDq5Cx2f3xxHXwe7MKjz6w2nWsEvNrMKEZUexeO8VtEoVXT5+TlULyhvbIfTm6+XO0OW+yXfi7sExAIAt562f8BG1K1iDrG+U6czlhjBrWrdeKEeLAzTqYk2fWMpcDmjuf4whVdNin9GtVhOc0E4o39rPOqObz+ehT6TmfpswdIxd3+tIGsVyNEs0fRRjztPNlA0zMkHhyPGiTabEPzmaMpYzLISWMzDrus8VNxpN9GYLhlqYknJRgZafCe4eHAuhNx/F9WJkXRN1qR3GYM5ra8LLg6OcX0HH3bHZ6H722WfB5/ORmpqKtLQ0XLx4ERcvXsSlS5dw8eJFZ7SRYgNXrtiXLZSLWNJy+4AoDIwNwjuTB1iV3bq7uJ76hAvcO1xz49+fUw2ZUtWpXBjQ/TqGxAfDR8BHg1jOZkCNt6NcGND9Wmzl0TEJ6B8TiAkDY/TedzcdXISOz+5PV64DQgi+O3wVs367CJlSjbsGRuOPl8fh5r4RkCvVWHmkEHd+eQRbzpd1ySu2T5tA7fb+UfD3Mb5++cqVK3hsTAIAYPula5AqVJ32UajU2Jtdhd/OlrGvn45r1mXHBgttmki/LTkS/WMCIZarsOVcua2SzGJNn1jKXM6QrPXef3OoAGo7jLWcqhY0iuUI8BFgpDYppzX00U5gXCxwThiytRTXi/GvlZoKCz1C/RBiogwVAEQGmF7T7cjxYl92NWRKNfpEBmBoD+uq3AyJD0GQrxdaZUpcruyasWuoxRZPd6CvF+4erHE07Lhke/4ESzTZkEituskxdcs9GZuzl6enpyMtLQ0DBw50RnsoXSQgwPqZYa5jSUt0kBB73xjvotbYz/XUJ1xgdEIYYoOFqG6R4lh+PVsuTLcmdHfr8PUSYFjPEKSVNiGzQjNgM4kBbaW7tdjKC7cmGc206m46uAgdn90fe68DmVKFD7dl48+LFQCA527pjTnTBkPA5+HXf4/FP7m1WLAnF8X1Yrz3ZxbqWmV49a5ku77rb63RPWVonMl9AgICcGu/SPQI9cO15nb8nV2FB0b2ZLer1QRvbE7H7izj5Y4MI2EswePx8PwtSXh/WxaWHchH78gA1tPeVazpk3qxxlCKMBNeDgAfTB2IE1frcbygHutOldicdZoJLR/XN8KmMqHJ0UEAqnCg0gsrjxTiuVt6W13m0lGcKWrAyxvT0CxRoEeoH9Y8e4PZ7Nysp1vc2dPtqPGioU2Gbw4VAADuG2G5RCuDgM/DjUnhOHilFqcLG5DSM9TuNhhqqWuzHDWhy/3D47EroxK7Mivx0bRBXc6mrkujFYnUmPXeUrXzy9a6Ozb/QoMHD0Z9fb0z2kJxAOHhrq2760w8RYun6ADcQwufz8PUYZqHwS3ny3GtWbNmWndNNxd0MOu6GeLs9HRzQYsj8BQd3cn1PD63yzt7Ut0Re66DtNImPLzqNP68WAEBn4e5M4bi0+lD2IdvHo+HuwfHYN8b4/HmxP4AgC/35+OPtAqjx1Oo1Pjfzsu4bckhHNCG3TJcrW1DQW0bvAU83DnQdOLS8PBw8Pk8PDqmFwBgs4H3ecGeXOzOqoK3gIeJg2Jw9+CO19RhsXjz7v42/w4PjuqJ25Ij0a5Q4aVfLmD1sSKHrHO1pk8atYZShAVDqV90EOZo888s3nsFV6ptW+9+4qqmPre1oeUMz4xLRErPEEhVmu+duOwoUjOdsw7YGFsvlOPpNWfRLFFgRK9Q7Jh1CwbGmvcqs2u6jXi6HTFetMtV+PeGCyhpkKBHqB+e1tZ8txYmxLyrydQMtdTb4OkGgPH9oxDq7426VplD1pjrwni6I6wwuiUqanRbwuZfaPHixXj33Xdx5MgRNDQ0oKWlRe/VXXz33Xfo3bs3hEIhxo4di3PnznVbW7qTzMzM7m6Cw/AULZ6iA3AfLfcO1xjd/+RqHhijgnz1srxyQccog9DAeDs93VzQ4gg8RUd3wtXx2Rq6OoY3GvGGuSO2XAcVTRK8tukSHlp5CpkVIgT5emHds2NMGg8+Xnz8d2IyXr69LwDg/T8zcbygTm8fUbsCz607j/WnSlDe2N7JeGWylt/cN9JsaDCj4+EbeoLPA84WN6JIW397zYli/HSiGADw5cPD8dPMG7D6mY7X90+O7nR/tAYfLz7WPjsGT4xNACHA/D25+HB7NhQqtc3HAgCVmmD7pQr8fLzA4jEarDBOGJ66KRF3DYyGXKnGfzelGw29zyhvxg9HC3Hqaj1kSs32drkK54ubAAC3mVhLb4qwAB/s+M8tuD+mGbHBQlQ0tePV3y7h4VWnkV7ebNOxjKFWE2RWNOP7I1excE+u3uuNzZfwzh+ZUKgIpqXEYfNLN1llUDJRA8bWdHd1vFCpCV7ffAmXypoR4ueNn58fY7K+uimYZGrnS5qgtPEckyvVOFVYjx+OFmLP2Vz2fUKITeHlgOa8ZxwNjsxiXt4oYXPOWOPpFkldP/FZUi/GsgP5nc65L/Zd6XLYvzOwObycWfA/YcIEvfcJIeDxeFCpXP+jb9myBW+99RZWrVqFsWPH4quvvsLkyZORl5eH6GjulZByJlOmTOnuJjgMT9HiKToA99EyslcoG9YI6IeWA9zQMSoxlP2/gM8zm8XVHFzQ4gg8RUd3wsXx2RocMYY3Gslw7GzaZEr4eQsshnNK5Ep4C/jwFlj2c1hzHbTJlFh55Cp+Ol4MmVINHg94eHRPzJ40ANHBlu8j704egCpRO/5Kr8QrGy9iy//dhCHxIShtEOP59edRWCeGn7cA4/tHYt/lGszfk4ui+jZ8fv9Q7GVDy41nLTfUERfihzsGROPQlVpsuVCO4T1DMW93DgDg/SkDLdZEthVvAR/zZwxFn8gAzN+Ti03nylDeKMF3T44yO0lgyImCeszbnYMr1a0AQpCz/Bg+nDoIEwZFGw1BZo1uKww3Ho+HxQ+l4J6vjiGvphVL9ubhk+mDAQDXmtuxZO8V/JXesT7X30eAm/tGokeoEHKVGvEhQvSJtD28ms/n4b1H70RoZDR+PFaEH44W4UJpE2Z8dxIzRsTj3XsGIt6G0pWNYjmOF9ThSF4djuXXsb+BKV67qx/enNgffCvDn5nwamPH7cp4QQjB/3ZexoGcGvh48fHTzBusqglvyKC4YAQLNfW6sytbMKJXqNn9K5okOJJXh6P5dTh1tR5iNjonAnW/XcT7UwYiyNcbcq0BH2nDJMCMET3w29ky7M2uxtwZQ+1aOiBVqHCmqAFH8+twNK8ORTrlBmPM3FdCtWu6lYQHqULlkmULonYFvj1UgPWnSqBQGY/W+P5IoU33RVdgs9F9+PBhZ7SjSyxbtgwvvvginnvuOQDAqlWrsHv3bqxduxbvv/9+N7fOtaxduxZz5szp7mY4BE/R4ik6APfRwuPxMC0lDj8e0yTlMVwfyAUd0UFC9Ar3Q3ljO2KCfO1eh8UFLY7AU3R0J1wcn63BEWN4k8SxGauNoVCpcbG0SfNQml+Hy5UtCPX3xm3JUbijfxTG949CVJAv1GqCrGsi7QN2LdLLm+Hv44Wb+0bgjgHRuH1AFHqYMG6MXQeEEBTXi9nvPVPUAKlC82B+U59wzJk2GEN7hFitg8/nYcm/UlDbIsPpogY8t+48Pr53MD7deRmNYjlig4X4aeYNGBIfjLUnSzBvdw42nStHXnUrsq6JwOcBEy2sl9bV8diYXjh0pRabzpZh3ckSEKIJd/6/8X2sbrMt8Hg8/Pu2PugdEYDXN1/Ciav1GLfwIG7uG4nbB2j6qpe2ioIhhXVtWLA7Fwev1AIAQvy8IZNKUFQvxr83XMAt/SIwZ9pgDIoLRkWTBEfzNUZnjtarZimRGkNUkC+W/CsFL/x8AWtPFuPGpDBcrmzBj8eK2ImUW/pG4kp1K+rbZGzUFgDclhxl9dpjQ5h+eWNifzw2JgFL9l3BtovXsCO9EnsvV+Ol2/rg/27viwDfzuaBSk2QXt6sNcpqkXlNBN3o9AAfAW7uF4neEZ1/25v7ReLOAbY5wTqyl3c2ursyXqw6WoRfzpSCxwO+fnQExvS2L1RdwOdhbJ8IHMipwX82puGuQdG4vX80bu4bgQBfL0gVKpwrbmTvA4V1+jXkIwN9MDA2GCeu1iE1swr7c2owPUWTCDZY6GWT8XpDYhjiQ4SoFElx+EotpgwznW+BgRCConoxjuZ13Fdkyg6PvYDPw+jEMMwY0cPk/QoAgny94MXnQakmaJLI7V4qZw1KlRq/nSvD8gP57D3/ln4RGBynv1ShtEGC/Tk1+P1CBVIzq/CfO/ri37f1cXkeA0N4xFULOpyEXC6Hv78//vjjD8yYMYN9f+bMmWhubsZff/3V6TMymQwyWUe4SktLC3r16gWRSITgYOsyF1IoFG6TWdGM+749CQBY+OAwPH5jQje3qDNvbL6EHemVGJ0Yhj9fubm7m0NxAC0tLQgJCaHjiZXYOoabGr/vWbIXCbERTmunVKExuFtlSrP7DYwNQm2rzKLnPTk6EEmRAbBkOxECXKluRZlBne0+UQF4756BmDQ4xm4DTNSuwCOrTiOvpiPr8LAeIfhp5g16nq2DuTV4bdMlSLSeubFJ4djyf+Os/h6FSo2bFx1iw2YnDY7ByqdGOzThkykuV4rwn18vorSh8+/XLypQ7/eXK9U4XlAPpZrAi8/DUzcl4o2JyRDwefjucCHWniiGXKUGnwf0CvfvfMzIAOx67VajBqsp5uzIwsYz+iXVxiaF4+N7NRMpajVBTlULO+FS3ijBqqdGY7gFr6otZFY0Y15qLs6VNAIAooN8MTJB//hypRoXy5ohatef3BoYG6SZSOofhdGJYTYld7NEi1SBlP/tBwDted71YypUBIe0Eyqf3DsYz9uYyM6Qf3Jq2GoBDN4CHgbFBSO/ppWdHAM0RuyohFD29xocFww+n4fLlSLMS81lK5kAmnJ5B9++w6a2LPr7ClYdLURihD8Gxpr33BMC5FZrSv/pEhcixB0DonB7/yjc3C8SwVZWELhh3j+ob5Ph1n6RCPB1nmFbUNPGeuD7RQfio2mDTE7mpJU2YW5qDrt8Ij5EiGE9O09ODogNxls6OSScOYZbdXVkZmZCrVaz/zf3cjX19fVQqVSIidGfdY2JiUF1dbXRzyxcuBAhISHsq1cvTaKPoqIiLFmyBDKZDPPmzQMAzJs3D5WVlVizZg3Onz+Pffv2Ydu2bcjJycGKFSvQ0tKit29jYyO+++47ZGZmYufOndi9ezcuXryIH374AXV1dXr7SiQSLF26FHl5efj9999x8OBBnDp1CuvXr0d5ebneviqVCgsXLkRpaSl++eUXnDhxAkeOHMHmzZtRUFCAL774AlKplA0vnDdvHqqrq7F69WqcP38ee/fuxfbt25GdnY1vvvkGIpFI7/jNzc349ttvkZWVhR07dmDPnj1IS0vDjz/+iJqaGr1929vbsXTpUhQUFGDLli04dOgQTp48iQ0bNqCsrAzz58+HWq3GvHnzoFarMX/+fJSVlWHDhg04efIkDh06hC1btqCgoABLly5Fe3u73vFramrw448/4pVXXsGePXuwY8cOZGVl4dtvv0Vzc7PeviKRCN988w2ys7Oxfft27N27F+fPn8fq1atRXV2tt69UKsUXX3yBgoICbN68GUeOHMGJEyfwyy+/oLS0FAsXLoRKpdL7THl5OdavX49Tp07h4MGD+P3335GXl4elS5dCIpHo7VtXV4cffvgBFy9exO7du7Fz505kZmZi+vTpaGxs1Nu3paUFK1asQE5ODrZt24Z9+/bh/PnzWLNmDSorK/X2lclkWLJkCQoLC7Fp0yYcOXIEx48fx8aNG1FSUoJFixZBqVTqfaaiogLr1q3DmTNncODAAWzduhVXrlzB8uXL0dbWprdvfX09Vq1ahfT0dKSmpmLXrl1IT0/HypUr0dDQoLfvxx9/jK+++go5OTn4888/sX//fpw9exZr167t1G6FQoHFixejqKgIv/76K44dO4Zjx47h119/RVFRERYvXgyFQtHpWlu7di3Onj2L/fv3488//0ROTg6++uortLa26u3b0NCAlStXIj09Hbt27UJqairS09OxatUq1NfX469136JfdCAAggGRPli+fDmuXLmCrVu34tlnn8WZM2ewbt06VFRU6B1XqVRi0aJFKCkpwcaNG3H8+HEcOXIEmzZtQmFhoUPvEf6tmkRGYXyp3fcI5mXtPUL3+Fy6R8yePdvme0RaWhrn7hHbtm0zOu44Cy6Pz9Zg6xhuavy+XNmCfZdrnPY6ml+HVpkSYf7e6OvViEUzBuG58KtYNrUH7oqVIzFIYxFcqW5Fo1gOb6hwz5BY3OpbhuPv3I4HAwrwwo3RSPBXgAegoLYN+3Msf+/+nBqUNUog4BEMjxVifHAD/vz3SNwpOYHJQ2Ixf/58u6/NvTu34cUBCoQJNW2/LSkYo0XHERXoo3dtJgfI8GzPBoRr94tXVto0fl/JuYy+0PRlNL8NKx4fiYUL5rvk2jy/fzvm3+yDT8b64J54OYbGCMEDQVGduNPvfzivDko1wbBw4L3hSjzYW4Vf163Gws8/hTLtDxx8+3YkeTVBTTSeND4P6BOkxv1JfCyZEIYnQgshaqi1afz2zd3D1iNPjPDHRGERvpzaE+f3b8OZM2dw8OA/yD21HxPilBgnOYMDr43Frp+/ZY9vy/jd2tqKqVOndhq/L+zfhuXTEzBBWISEcH/Utso6nYeH8+ogaldAyFfjjj5BuNO/AifeGY9b247h/SkDcXDTStTXVjts/J43bx6CfL0g5GmMfGuuFWtejME9zLsGz9+a1OVnfFnxBay7Lwr/iqnHwyOiEcSTQaEiyKwQQapQI4CvwD3JwXg6SYqvxvvgzRQgoPQEQtQtWLBgPgDgv888hF+evwGT/UvQM0Rb85ons3n8Dm68Ah4056Y195XyxnYIQHBjQhBu9LmGA2+Ox1TlaXwyJRmX9/2GmvISq8fvuECNoX3iar1T78NF9WIE+fAwObIZ6x/rj5NbfzR5j2gtzsDbKWo83LMN0YHeqBRJjR5z1+nLes/4BQUF1gxddmGVp5vP56O6uhrR0dHg8/ng8XhGMx52x5qxyspK9OjRA6dOncK4cR0zr++++y6OHj2Ks2fPdvqMJ3u6ZTIZfH1tSwbBVTxFi6foANxPy7XmdlQ2t3cKH+OKDqVKjYNXajE2KVwv0ZstcEVLV/EUHa72dHN5fLYGW8dwU+P3j/9kwS/A9nWZ1sLn8TAkPhhDe4SY9NDWtcpwvqQREQE+GJUYZnINt0iiwKnCeqNrVZVKJby89D2lcSFC3NQnwiYPqi3Utkpx+VoLbu8fZXa9baNYjnPFjZg4KBpeFtanG17PcqUaB3NrML5/lNN0WEuLVIFTVxtQbyRB18DYINxgYbzIviZCtUiKMUnhNq0TN0VDmwxppU24fUAUfL2cG/5q6T4rU6qw/3JNJ482j6fJjTKiV6jFvnck+TWtOFfc2Ol9Y9eJtfQI9bN4rtsLIQQlDRJkVjRjQGwQBsQEWYxE0e0TuVKNw3m1GNkr1K51yKcK61FkEMZuCkfeV641t+Pg5UrwBc69toXeAtw9OMbm606qUGHf5Wq0SjtHKsUGC/WWyzh1DCdWUFJSQtRqNft/cy9XI5PJiEAgINu3b9d7/5lnniH33XefVccQiUQEABGJRE5ooWtZvHhxdzfBYXiKFk/RQYjnaPEUHYR4jhZP0eHq8YTL47M1dHUM96TxmxDPuQ48RQchVAsX8RQdhHiOFk/R4cwxxaopicRETfkJhUKBzz77DB9//DGSkrq2DsJR+Pj4YPTo0Th48CC7HkytVuPgwYN49dVXrToG0XoFuF5SxRomTZrkEToAz9HiKToAz9HiKToAz9HiKToYDcRF6VK4PD5bQ1fHcE8avwHPuQ48RQdAtXART9EBeI4WT9Hh1DHcVis9ODiYFBUVOdr47xKbN28mvr6+ZP369SQnJ4e89NJLJDQ0lFRXV1v1+cLCQgKAvuiLvuiLvujLIa/CwkInj3yd4eL4bA1dGcPp+E1f9EVf9EVfjn45Ywy3Ofh+xowZ2LFjB958801bP+o0Hn30UdTV1eGTTz5BdXU1RowYgb1793ZKzGKK8HDN+p2ysjKEhIQ4s6lOhVnbVl5e7vZr0z1Fi6foADxHi6foADxHi6foAACRSISEhAR2XHElXByfraErY7injN+A51wHnqIDoFq4iKfoADxHi6foAJw7httsdCcnJ+Pzzz/HyZMnMXr0aAQEBOhtf/311x3WOFt49dVXrQ4nN4TP1ySFCAkJcfuTBQCCg4M9QgfgOVo8RQfgOVo8RQfgOVo8RQfQMa64Eq6Oz9Zg7xjuaeM34DnXgafoAKgWLuIpOgDP0eIpOgDnjOE2G91r1qxBaGgo0tLSkJaWpreNx+NxelCnUCgUCsVToeMzhUKhUCjcxGaju7i42BntoFAoFAqF0gXo+EyhUCgUCjdxffwbB/H19cWnn37q9jViPUUH4DlaPEUH4DlaPEUH4DlaPEUH4Fla3AFP+r09RYun6ACoFi7iKToAz9HiKToA52rhEWI5J/pbb72FuXPnIiAgAG+99ZbZfZctW+awxlEoFAqFQjENHZ8pFAqFQuE+VoWXX7p0CQqFgv2/KXg8nmNaRaFQKBQKxSJ0fKZQKBQKhftY5ekGgKKiIiQlJdGBm0KhUCgUDkHHZwqFQqFQuI3Va7qTk5NRV1fH/v3oo4+ipqbGKY2iUCgUCoViHXR8plAoFAqF21htdBs6xPfs2QOxWOzwBjmKY8eOYfr06YiPjwePx8OOHTv0thNC8MknnyAuLg5+fn6YOHEiCgoK9PZpbGzEk08+ieDgYISGhuKFF15AW1ubC1VY1vHss8+Cx+Ppve655x69fbigY+HChRgzZgyCgoIQHR2NGTNmIC8vT28fqVSKWbNmISIiAoGBgXjooYc6PTiWlZVh2rRp8Pf3R3R0NN555x0olUpXSrFKyx133NGpX15++WW9fbigZeXKlUhJSWFrK44bNw5///03u91d+sSSDnfpD0MWLVoEHo+HN954g33PXfrEEGNa3KVf/ve//3Vq58CBA9nt3d0n7jY+WwMdwzvggg46hnPz3kTHcG7pMISO4dzQwpkxnFgJj8cjNTU17N+BgYGksLDQ2o+7nD179pCPPvqIbNu2jQAg27dv19u+aNEiEhISQnbs2EEyMjLIfffdR5KSkkh7ezu7zz333EOGDx9Ozpw5Q44fP0769etHHn/8cU7pmDlzJrnnnntIVVUV+2psbNTbhws6Jk+eTNatW0eys7NJeno6mTp1KklISCBtbW3sPi+//DLp1asXOXjwILlw4QK56aabyM0338xuVyqVZOjQoWTixInk0qVLZM+ePSQyMpJ88MEHnNNy++23kxdffFGvX0QiEee07Ny5k+zevZvk5+eTvLw88uGHHxJvb2+SnZ1NCHGfPrGkw136Q5dz586R3r17k5SUFPLf//6Xfd9d+kQXU1rcpV8+/fRTMmTIEL121tXVsdu7u0/cbXy2BjqGd8AFHXQM5+a9iY7h3NKhCx3DuaOFK2O41UY3n88ntbW17N+BgYGkqKjIpi/rLgwHOrVaTWJjY8kXX3zBvtfc3Ex8fX3Jpk2bCCGE5OTkEADk/Pnz7D5///034fF45Nq1ay5ruy6mBuz777/f5Ge4qIMQQmprawkAcvToUUKI5vf39vYmW7duZffJzc0lAMjp06cJIZqHFz6fT6qrq9l9Vq5cSYKDg4lMJnOtAB0MtRCiuRHp3pgM4aoWQggJCwsjP/30k1v3CSEdOghxv/5obW0lycnJ5MCBA3ptd8c+MaWFEPfpl08//ZQMHz7c6DYu9Ik7j8/WQMdwbukghI7hXNVCCB3DGbg47rljn9Ax3HE6bAovf/bZZ/Hggw/iwQcfhFQqxcsvv8z+zbzcgeLiYlRXV2PixInseyEhIRg7dixOnz4NADh9+jRCQ0Nxww03sPtMnDgRfD4fZ8+edXmbzXHkyBFER0djwIABeOWVV9DQ0MBu46oOkUgEAAgPDwcApKWlQaFQ6PXJwIEDkZCQoNcnw4YNQ0xMDLvP5MmT0dLSgsuXL7uw9foYamH49ddfERkZiaFDh+KDDz6ARCJht3FRi0qlwubNmyEWizFu3Di37RNDHQzu1B+zZs3CtGnT9H57wD2vE1NaGNylXwoKChAfH48+ffrgySefRFlZGQBu9Iknjc/WQMfw7tdBx3DuaaFjOHd00DFcA5e0cGEMt6pkGADMnDlT7++nnnrK6i/hGtXV1QCg9+MxfzPbqqurER0drbfdy8sL4eHh7D5c4J577sGDDz6IpKQkFBYW4sMPP8SUKVNw+vRpCAQCTupQq9V44403cMstt2Do0KEANL+3j48PQkND9fY17BNjfcZs6w6MaQGAJ554AomJiYiPj0dmZibee+895OXlYdu2bWx7uaIlKysL48aNg1QqRWBgILZv347BgwcjPT3drfrElA7Avfpj8+bNuHjxIs6fP99pm7tdJ+a0AO7TL2PHjsX69esxYMAAVFVV4bPPPsNtt92G7OxsTvSJJ43P1kDHcDqGOwo6hnNfB+Be/UHHcO71C1fGcKuN7nXr1ll9UIrreOyxx9j/Dxs2DCkpKejbty+OHDmCCRMmdGPLTDNr1ixkZ2fjxIkT3d2ULmNKy0svvcT+f9iwYYiLi8OECRNQWFiIvn37urqZZhkwYADS09MhEonwxx9/YObMmTh69Gh3N8tmTOkYPHiw2/RHeXk5/vvf/+LAgQMQCoXd3ZwuYY0Wd+mXKVOmsP9PSUnB2LFjkZiYiN9//x1+fn7d2DINdHx2X+gY3r3QMZw70DGcW9Ax3PFYHV7uScTGxgJAp8x0NTU17LbY2FjU1tbqbVcqlWhsbGT34SJ9+vRBZGQkrl69CoB7Ol599VWkpqbi8OHD6NmzJ/t+bGws5HI5mpub9fY37BNjfcZsczWmtBhj7NixAKDXL1zR4uPjg379+mH06NFYuHAhhg8fjq+//trt+sSUDmNwtT/S0tJQW1uLUaNGwcvLC15eXjh69ChWrFgBLy8vxMTEuE2fWNKiUqk6fYar/WJIaGgo+vfvj6tXr7rddeIJ0DGcjuGOgI7h7qHDGFztDzqGc7NfDOmuMfy6NLqTkpIQGxuLgwcPsu+1tLTg7Nmz7PqRcePGobm5GWlpaew+hw4dglqtZk8qLlJRUYGGhgbExcUB4I4OQgheffVVbN++HYcOHUJSUpLe9tGjR8Pb21uvT/Ly8lBWVqbXJ1lZWXoPIAcOHEBwcDAbguQKLGkxRnp6OgDo9QsXtBhDrVZDJpO5VZ8Yg9FhDK72x4QJE5CVlYX09HT2dcMNN+DJJ59k/+8ufWJJi0Ag6PQZrvaLIW1tbSgsLERcXJzbXyfuCB3D6RjeFegYzr0+MQYdw7mthY7hduiwNQOcu9Da2kouXbpELl26RACQZcuWkUuXLpHS0lJCiKbcSGhoKPnrr79IZmYmuf/++42WGxk5ciQ5e/YsOXHiBElOTnZ5mQ5zOlpbW8ns2bPJ6dOnSXFxMfnnn3/IqFGjSHJyMpFKpZzS8corr5CQkBBy5MgRvZT9EomE3efll18mCQkJ5NChQ+TChQtk3LhxZNy4cex2JmX/pEmTSHp6Otm7dy+JiopyeekBS1quXr1KPv/8c3LhwgVSXFxM/vrrL9KnTx8yfvx4zml5//33ydGjR0lxcTHJzMwk77//PuHxeGT//v2EEPfpE3M63Kk/jGGYHdRd+sQYulrcqV/efvttcuTIEVJcXExOnjxJJk6cSCIjI9mM4e7cJ1yFjuF0DO8uLe50b6JjOLd0GIOO4d2vhStjuMca3YcPHyYAOr1mzpxJCNGUHPn4449JTEwM8fX1JRMmTCB5eXl6x2hoaCCPP/44CQwMJMHBweS5554jra2tnNEhkUjIpEmTSFRUFPH29iaJiYnkxRdf1EtpzxUdxjQAIOvWrWP3aW9vJ//5z39IWFgY8ff3Jw888ACpqqrSO05JSQmZMmUK8fPzI5GRkeTtt98mCoWCU1rKysrI+PHjSXh4OPH19SX9+vUj77zzjl7tQq5oef7550liYiLx8fEhUVFRZMKECexgTYj79Ik5He7UH8YwHLDdpU+MoavFnfrl0UcfJXFxccTHx4f06NGDPProo+Tq1avsdnfuE65Cx3Bu6aBjODfvTXQM55YOY9AxvPu1cGUM5xFCiPV+cQqFQqFQKBQKhUKhUCjWcl2u6aZQKBQKhUKhUCgUCsUVUKObQqFQKBQKhUKhUCgUJ0GNbgqFQqFQKBQKhUKhUJwENbopFAqFQqFQKBQKhUJxEtToplAoFAqFQqFQKBQKxUlQo5tCoVAoFAqFQqFQKBQnQY1uCoVCoVAoFAqFQqFQnAQ1uikUCoVCoVAoFAqFQnES1OimUDycZ599FjNmzOi273/66aexYMECq/Z97LHHsHTpUie3iEKhUCgU7kPHbwrFc+ARQkh3N4JCodgHj8czu/3TTz/Fm2++CUIIQkNDXdMoHTIyMnDXXXehtLQUgYGBFvfPzs7G+PHjUVxcjJCQEBe0kEKhUCgU10PHbwrl+oIa3RSKG1NdXc3+f8uWLfjkk0+Ql5fHvhcYGGjVYOks/v3vf8PLywurVq2y+jNjxozBs88+i1mzZjmxZRQKhUKhdB90/KZQri9oeDmF4sbExsayr5CQEPB4PL33AgMDO4Wn3XHHHXjttdfwxhtvICwsDDExMVi9ejXEYjGee+45BAUFoV+/fvj777/1vis7OxtTpkxBYGAgYmJi8PTTT6O+vt5k21QqFf744w9Mnz5d7/3vv/8eycnJEAqFiImJwb/+9S+97dOnT8fmzZu7/uNQKBQKhcJR6PhNoVxfUKObQrkO+fnnnxEZGYlz587htddewyuvvIKHH34YN998My5evIhJkybh6aefhkQiAQA0NzfjrrvuwsiRI3HhwgXs3bsXNTU1eOSRR0x+R2ZmJkQiEW644Qb2vQsXLuD111/H559/jry8POzduxfjx4/X+9yNN96Ic+fOQSaTOUc8hUKhUChuCh2/KRT3hBrdFMp1yPDhwzFnzhwkJyfjgw8+gFAoRGRkJF588UUkJyfjk08+QUNDAzIzMwEA3377LUaOHIkFCxZg4MCBGDlyJNauXYvDhw8jPz/f6HeUlpZCIBAgOjqafa+srAwBAQG49957kZiYiJEjR+L111/X+1x8fDzkcrle6B2FQqFQKBQ6flMo7go1uimU65CUlBT2/wKBABERERg2bBj7XkxMDACgtrYWgCahyuHDh9k1ZoGBgRg4cCAAoLCw0Oh3tLe3w9fXVy9ZzN13343ExET06dMHTz/9NH799Vd2Np7Bz88PADq9T6FQKBTK9Q4dvykU94Qa3RTKdYi3t7fe3zweT+89ZqBVq9UAgLa2NkyfPh3p6el6r4KCgk7hZQyRkZGQSCSQy+Xse0FBQbh48SI2bdqEuLg4fPLJJxg+fDiam5vZfRobGwEAUVFRDtFKoVAoFIqnQMdvCsU9oUY3hUKxyKhRo3D58mX07t0b/fr103sFBAQY/cyIESMAADk5OXrve3l5YeLEiViyZAkyMzNRUlKCQ4cOsduzs7PRs2dPREZGOk0PhUKhUCjXA3T8plC4ATW6KRSKRWbNmoXGxkY8/vjjOH/+PAoLC7Fv3z4899xzUKlURj8TFRWFUaNG4cSJE+x7qampWLFiBdLT01FaWooNGzZArVZjwIAB7D7Hjx/HpEmTnK6JQqFQKBRPh47fFAo3oEY3hUKxSHx8PE6ePAmVSoVJkyZh2LBheOONNxAaGgo+3/Rt5N///jd+/fVX9u/Q0FBs27YNd911FwYNGoRVq1Zh06ZNGDJkCABAKpVix44dePHFF52uiUKhUCgUT4eO3xQKN+ARQkh3N4JCoXgm7e3tGDBgALZs2YJx48ZZ3H/lypXYvn079u/f74LWUSgUCoVCMQYdvykUx0I93RQKxWn4+flhw4YNqK+vt2p/b29vfPPNN05uFYVCoVAoFHPQ8ZtCcSzU002hUCgUCoVCoVAoFIqToJ5uCoVCoVAoFAqFQqFQnAQ1uikUCoVCoVAoFAqFQnES1OimUCgUCoVCoVAoFArFSVCjm0KhUCgUCoVCoVAoFCdBjW4KhUKhUCgUCoVCoVCcBDW6KRQKhUKhUCgUCoVCcRLU6KZQKBQKhUKhUCgUCsVJUKObQqFQKBQKhUKhUCgUJ0GNbgqFQqFQKBQKhUKhUJwENbopFAqFQqFQKBQKhUJxEv8Pcfp5FiBNrzwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -854,16 +711,28 @@ "dt = 0.1\n", "nneurons = 50\n", "\n", - "ts_const, ns_const = evaluate_neuron(neuron_model_name, nneurons=nneurons, neuron_parms=params, stimulus_type='poisson_spikes',\\\n", - " mu=550., t_sim=500.0, dt=dt, poisson_fr = 0.0)\n", - "\n", - "ts_noise, ns_noise = evaluate_neuron(neuron_model_name, nneurons=nneurons, neuron_parms=params, stimulus_type='poisson_spikes',\\\n", - " mu=550., t_sim=500.0, dt=dt, poisson_fr = 1000.0)\n", + "ts_const, ns_const = evaluate_neuron(neuron_model_name,\n", + " module_name,\n", + " nneurons=nneurons,\n", + " neuron_parms=params,\n", + " stimulus_type='constant',\n", + " mu=550.,\n", + " t_sim=500.0,\n", + " dt=dt,\n", + " poisson_fr=0.0)\n", + "\n", + "ts_noise, ns_noise = evaluate_neuron(neuron_model_name,\n", + " module_name,\n", + " nneurons=nneurons,\n", + " neuron_parms=params,\n", + " stimulus_type='poisson_spikes',\n", + " t_sim=500.0,\n", + " poisson_fr=2000.0)\n", "\n", "# PSTH parameters\n", "t_start = 0.0\n", - "t_stop = 500.0\n", - "t_step = 1.0\n", + "t_stop = 500.0\n", + "t_step = 5.0\n", "t_bins = np.arange(t_start, t_stop + t_step, t_step)\n", "\n", "# Calculate the PSTH\n", @@ -919,7 +788,7 @@ "outputs": [], "source": [ "nestml_gl_ca_neuron_model = '''\n", - "neuron gl_ca:\n", + "model gl_ca_neuron:\n", " state:\n", " U real = 0 # membrane potential\n", "\n", @@ -973,17 +842,19 @@ "outputs": [], "source": [ "nestml_gl_ca_synapse_model = '''\n", - "synapse syn_gl_ca:\n", + "model syn_gl_ca_synapse:\n", " state:\n", " R_pre real = 0.\n", + " w real = 1. # weight variable\n", "\n", " parameters:\n", - " the_delay ms = 1 ms @nest::delay # !!! cannot have a variable called \"delay\"\n", + " d ms = 1 ms\n", " lmbda real = 2.1555489309487914 # residual calcium decay rate\n", "\n", " onReceive(incoming_spikes):\n", + " w = R_pre\n", " R_pre += 1\n", - " deliver_spike(R_pre - 1, the_delay)\n", + " emit_spike(w, d)\n", "\n", " input:\n", " incoming_spikes <- spike\n", @@ -1014,17 +885,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml\n", - "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml\n", - "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_8zmlqzuo'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.5.0-rc1\n", - " Built: Feb 21 2024 09:04:08\n", + " Version: 3.6.0-post0.dev0\n", + " Built: Mar 21 2024 03:47:13\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -1034,288 +900,7 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: v3.5.0-rc1\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[8,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[9,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-gl-model/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[10,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", - "[11,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[13,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[14,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", - "[15,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[16,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [28:13;28:29]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", - "[17,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[18,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[19,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [35:11;35:62]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([35:11;35:62])\n", - "[20,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[21,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f.nestml'!\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[23,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[24,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[26,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[27,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", - "[28,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[29,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[30,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[31,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[33,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[34,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[36,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[37,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n", - "[38,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[39,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [28:13;28:29]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n", - "[40,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[41,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[42,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [35:11;35:62]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([35:11;35:62])\n", - "[43,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[45,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[46,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[47,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: []\n", - "[48,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: []\n", - "[49,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with suffixed external variable references\n", - "[50,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", - "[51,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", - "[52,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", - "[54,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[55,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [25:8;28:8]]: Variable 'K' has the same name as a physical unit!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", - " },\n", - " \"parameters\": {\n", - " \"a\": \"3.0\",\n", - " \"alpha_over_N\": \"1.0777744654743957\",\n", - " \"beta\": \"50\",\n", - " \"reset_after_spike\": \"true\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[56,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[57,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [4:17;4:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[58,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[59,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[61,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[62,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[63,GLOBAL, INFO]: Successfully constructed neuron-synapse pair gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml\n", - "[64,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", - "[65,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Starts processing of the model 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Generating propagators for the following symbols: U\n", - "INFO:update_expr[U] = U*__P__U__U\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " },\n", - " \"parameters\": {\n", - " \"beta\": \"50.0000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"U\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"U\": \"U*__P__U__U\"\n", - " }\n", - " }\n", - "]\n", - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", - " },\n", - " \"parameters\": {\n", - " \"a\": \"3.0\",\n", - " \"alpha_over_N\": \"1.0777744654743957\",\n", - " \"beta\": \"50\",\n", - " \"reset_after_spike\": \"true\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n", - "INFO:\n", - "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n", - "INFO:\tReturning shape: Shape \"U\" of order 1\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "INFO:Shape U: reconstituting expression -0.001*U*beta\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[67,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[68,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[69,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[70,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[71,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[72,GLOBAL, INFO]: Analysing/transforming neuron 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", - "[73,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Starts processing of the model 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "INFO:Generating propagators for the following symbols: U\n", - "INFO:update_expr[U] = U*__P__U__U\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"U\": \"0\"\n", - " },\n", - " \"parameters\": {\n", - " \"beta\": \"50.0000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"U\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"U\": \"U*__P__U__U\"\n", - " }\n", - " }\n", - "]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[75,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, ]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[76,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, WARNING, [7:8;7:17]]: Variable 'a' has the same name as a physical unit!\n", - "[77,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [20:19;20:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[78,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [9:20;9:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[79,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [38:20;38:20]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[80,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.\n", - "[81,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml'\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[83,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[84,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[86,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [21:21;21:48]]: Implicit casting from (compatible) type 'ms' to 'real'.\n", - "[87,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [11:17;11:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[88,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp\n", - "[89,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", - "[90,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Successfully generated code for the model: 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "ANTLR runtime and generated code versions disagree: 4.13.1!=4.10.1\n", - "[91,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp\n", - "[92,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", - "[93,gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;38:0]]: Successfully generated code for the model: 'gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "Generating code for the synapse syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.\n", - "[94,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h\n", - "[95,syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml' in: '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "[96,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp\n", - "[97,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.h\n", - "[98,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/CMakeLists.txt\n", - "[99,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target' !\n", - "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", - " cmake_minimum_required() should be called prior to this top-level project()\n", - " call. Please see the cmake-commands(7) manual for usage documentation of\n", - " both commands.\n", - "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\n", - "-- The CXX compiler identification is GNU 12.3.0\n", + "-- The CXX compiler identification is GNU 10.2.1\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", @@ -1323,160 +908,164 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_c0c551c19f05412b9d0d08b928dbfe0f_module Configuration Summary\n", + "nestml_24a1d5e6286c4f26852138f442b8afc8_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", "Build static libs : OFF\n", "C++ compiler flags : \n", - "NEST compiler flags : -std=c++11 -Wall -fopenmp -O2 -fdiagnostics-color=auto -g\n", - "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", - "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli -fopenmp /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so\n", + "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", + "NEST include dirs : -I/home/charl/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/10/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.so\n", "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_c0c551c19f05412b9d0d08b928dbfe0f_module' using\n", + "You can now build and install 'nestml_24a1d5e6286c4f26852138f442b8afc8_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so will be installed to\n", - " /tmp/nestml_target_8zmlqzuo\n", + "The library file libnestml_24a1d5e6286c4f26852138f442b8afc8_module.so will be installed to\n", + " /tmp/nestml_target_s0fu4oy8\n", "The module can be loaded into NEST using\n", - " (nestml_c0c551c19f05412b9d0d08b928dbfe0f_module) Install (in SLI)\n", - " nest.Install(nestml_c0c551c19f05412b9d0d08b928dbfe0f_module) (in PyNEST)\n", + " (nestml_24a1d5e6286c4f26852138f442b8afc8_module) Install (in SLI)\n", + " nest.Install(nestml_24a1d5e6286c4f26852138f442b8afc8_module) (in PyNEST)\n", "\n", "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.26)\n", + " cmake_minimum_required(VERSION 3.18)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", "\n", - "-- Configuring done (0.1s)\n", - "-- Generating done (0.0s)\n", - "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", - "[ 50%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module.dir/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.o\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:154:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 154 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "-- Configuring done\n", + "-- Generating done\n", + "-- Build files have been written to: /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "\u001b[35m\u001b[1mScanning dependencies of target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\u001b[0m\n", + "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/nestml_24a1d5e6286c4f26852138f442b8afc8_module.o\u001b[0m\n", + "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.o\u001b[0m\n", + "[ 75%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/gl_ca_neuron_nestml.o\u001b[0m\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘void gl_ca_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:164:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 164 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘virtual void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:247:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 247 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:262:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 262 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:245:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 245 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:253:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 253 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:159:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 159 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::init_state_internal_()’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:169:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 169 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp: In member function ‘virtual void gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:258:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 258 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:273:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 273 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.cpp:256:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 256 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:264:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 264 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "In file included from /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:52:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:61:24: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:543:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 543 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "In file included from /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_24a1d5e6286c4f26852138f442b8afc8_module.cpp:36:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:571:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 571 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:577:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:560:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 560 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:571:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 571 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:10: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:543:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:552:3: required from ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:61:24: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:532:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 532 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:577:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:560:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 560 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:552:3: required from ‘nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:158:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:10: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:35:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.cpp:111:145: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:532:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:400:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 400 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:401:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 401 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:420:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 420 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:421:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 421 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:450:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 450 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:456:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 456 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:332:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 332 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:335:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 335 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:334:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 334 | auto get_thread = [tid]()\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:337:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 337 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:417:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", - " 417 | const double _tr_t = __t_spike - __dendritic_delay;\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:418:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 418 | const double _tr_t = __t_spike - __dendritic_delay;\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:400:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 400 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:401:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 401 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:420:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 420 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:421:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 421 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:450:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 450 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:456:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 456 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:332:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 332 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:335:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 335 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:334:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 334 | auto get_thread = [tid]()\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:337:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 337 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:417:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", - " 417 | const double _tr_t = __t_spike - __dendritic_delay;\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:418:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 418 | const double _tr_t = __t_spike - __dendritic_delay;\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update_internal_state_(double, double, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:395:9: required from ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:596:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 596 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h: In instantiation of ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::update_internal_state_(double, double, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:395:9: required from ‘void nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml::send(nest::Event&, size_t, const nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:381:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:373:3: required from here\n", - "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml.h:596:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - "[100%] Linking CXX shared module nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so\n", - "[100%] Built target nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module\n", - "[100%] Built target nestml_c0c551c19f05412b9d0d08b928dbfe0f_module_module\n", - "Install the project...\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:396:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:618:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 618 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:396:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:618:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_24a1d5e6286c4f26852138f442b8afc8_module.so\u001b[0m\n", + "[100%] Built target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\n", + "[100%] Built target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\n", + "\u001b[36mInstall the project...\u001b[0m\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_8zmlqzuo/nestml_c0c551c19f05412b9d0d08b928dbfe0f_module.so\n", - "\n", - "Feb 27 06:34:21 Install [Info]: \n", - " loaded module nestml_c0c551c19f05412b9d0d08b928dbfe0f_module\n" + "-- Installing: /tmp/nestml_target_s0fu4oy8/nestml_24a1d5e6286c4f26852138f442b8afc8_module.so\n" ] } ], @@ -1484,10 +1073,10 @@ "module_name, neuron_model_name, synapse_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", " nestml_neuron_model=nestml_gl_ca_neuron_model,\n", " nestml_synapse_model=nestml_gl_ca_synapse_model,\n", - " logging_level=\"INFO\" # try \"INFO\" for more debug information\n", - ")\n", - "\n", - "nest.Install(module_name)" + " codegen_opts={\"delay_variable\": {\"syn_gl_ca_synapse\": \"d\"},\n", + " \"weight_variable\": {\"syn_gl_ca_synapse\": \"w\"}},\n", + " logging_level=\"ERROR\" # try \"DEBUG\" for more debug information\n", + ")" ] }, { @@ -1511,172 +1100,171 @@ "output_type": "stream", "text": [ "\n", - "Feb 27 06:34:21 correlation_detector [Info]: \n", + "Aug 26 09:56:10 Install [Info]: \n", + " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", + "\n", + "Aug 26 09:56:10 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 27 06:34:21 correlomatrix_detector [Info]: \n", + "Aug 26 09:56:10 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Feb 27 06:34:21 correlospinmatrix_detector [Info]: \n", + "Aug 26 09:56:10 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Feb 27 06:34:21 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", + "Aug 26 09:56:10 gl_ca_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", + "Aug 26 09:56:10 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:21 SimulationManager::set_status [Info]: \n", + "Aug 26 09:56:10 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, @@ -1692,7 +1280,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1709,9 +1297,11 @@ "\n", "# numerical Phi vs U\n", "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " module_name=module_name,\n", " neuron_model_params={\"reset_after_spike\": False,\n", " \"beta\": 1E-99, # a very low value, to prevent the membrane potential from decaying\n", - " \"a\": 3.})\n", + " \"a\": 3.},\n", + " neuron_membrane_potential_name=\"U\")\n", "\n", "fig, ax = plt.subplots()\n", "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", @@ -1738,6 +1328,7 @@ "source": [ "def measure_postsynaptic_response(neuron_model: str,\n", " synapse_model: str,\n", + " module_name: str,\n", " t_stop: float = 2250.,\n", " V_m_specifier: str = \"V_m\",\n", " custom_model_opts: Optional[Dict] = None):\n", @@ -1745,6 +1336,7 @@ " spike_times = np.array([100., 200., 250., 2000.])\n", " \n", " nest.ResetKernel()\n", + " nest.Install(module_name)\n", " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", @@ -1775,23 +1367,26 @@ "output_type": "stream", "text": [ "\n", - "Feb 27 06:34:21 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:10 Install [Info]: \n", + " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", + "\n", + "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Feb 27 06:34:21 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 2250\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:21 SimulationManager::run [Info]: \n", + "Aug 26 09:56:10 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -1800,7 +1395,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1810,7 +1405,10 @@ } ], "source": [ - "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name, synapse_model_name, V_m_specifier=\"U\")\n", + "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name,\n", + " synapse_model_name,\n", + " module_name,\n", + " V_m_specifier=\"U\")\n", "\n", "fig, ax = plt.subplots()\n", "ax.set_xlabel(\"$t$ [ms]\")\n", @@ -1907,1230 +1505,1230 @@ "output_type": "stream", "text": [ "\n", - "Feb 27 06:34:21 gl_expa19b5725d62e4d56acf2da2f0101ed40_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", + "Aug 26 09:56:11 Install [Info]: \n", + " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", "\n", - "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", + "Aug 26 09:56:11 gl_ca_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:21 gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml__with_syn_gl_cac0c551c19f05412b9d0d08b928dbfe0f_nestml [Warning]: \n", + "Aug 26 09:56:11 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Feb 27 06:34:21 SimulationManager::set_status [Info]: \n", + "Aug 26 09:56:11 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Feb 27 06:34:21 ConnectionManager [Warning]: \n", - "9900 synapses in the network\n", + "Aug 26 09:56:11 ConnectionManager [Warning]: \n", " New connections created, connection descriptors previously obtained using \n", " 'GetConnections' are now invalid.\n", + "9900 synapses in the network\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:11 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:12 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:22 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:22 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:22 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:13 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:23 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:23 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:23 SimulationManager::run [Info]: \n", + "Aug 26 09:56:14 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:15 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:24 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:24 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:24 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:16 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:17 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:25 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:25 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:25 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:18 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Feb 27 06:34:26 NodeManager::prepare_nodes [Info]: \n", + "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", " Preparing 102 nodes for simulation.\n", "\n", - "Feb 27 06:34:26 SimulationManager::start_updating_ [Info]: \n", + "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 102\n", " Simulation time (ms): 10\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Feb 27 06:34:26 SimulationManager::run [Info]: \n", + "Aug 26 09:56:19 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] } ], "source": [ "nest.ResetKernel()\n", + "nest.Install(module_name)\n", "nest.resolution = .1 # [ms]\n", "\n", "sim_time = 1000. # [ms] (was 120 seconds in original paper)\n", @@ -3178,7 +2776,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3218,7 +2816,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAG2CAYAAABiR7IfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAADQx0lEQVR4nOydeXxVxfn/PzcQAgSSsAgJyhIVqyyKIAhCtVqsuGv91UKxrl+sFHdFxYraEoVAESogCIJUEQIoIJsoq0hIIA0Ni0EMIWySRJKQfSHJvb8/0hPvvTnLzJyZc+Zczvv14qXJPWfmmXlm5k7meeZ5PD6fzwcXFxcXFxcXFxddwuwWwMXFxcXFxcXFCbibJhcXFxcXFxcXAtxNk4uLi4uLi4sLAe6mycXFxcXFxcWFAHfT5OLi4uLi4uJCgLtpcnFxcXFxcXEhwN00ubi4uLi4uLgQ4G6aXFxcXFxcXFwIcDdNLi4uLi4uLi4EuJsmFxcXFxcXFxcCbN007dy5E3fffTe6dOkCj8eDNWvWBHzu8/nw5ptvIi4uDq1atcLw4cORlZUV8ExRURFGjx6NqKgoxMTE4IknnkB5ebmFrXBxcXFxcXG5ELB101RRUYFrrrkGc+bMUf186tSpeP/99zFv3jzs2bMHkZGRuO2221BdXd34zOjRo/H9999j8+bNWL9+PXbu3Iknn3zSqia4uLi4uLi4XCB4ZEnY6/F4sHr1atx3330AGk6ZunTpgpdeegkvv/wyAKCkpASdO3fG4sWLMXLkSBw+fBi9evVCWloarrvuOgDApk2bcMcdd+D06dPo0qWLXc1xcXFxcXFxCTGa2y2AFjk5OcjLy8Pw4cMbfxcdHY3rr78eKSkpGDlyJFJSUhATE9O4YQKA4cOHIywsDHv27MH999+vWnZNTQ1qamoaf/Z6vSgqKkKHDh3g8XjENcrFxcXFxcWFGz6fD2VlZejSpQvCwsQbz6TdNOXl5QEAOnfuHPD7zp07N36Wl5eHTp06BXzevHlztG/fvvEZNSZPnoy///3vnCV2cXFxcXFxsYNTp07hkksuEV6PtJsmkUyYMAEvvvhi488lJSXo1q0bTp06haioKOZy9x4rwuP/TuMhIgBAOfN674/X4NZesdzKtZPNmXl4cfl+BNuE/dvaxVeI3r17c6mPVCeLHhmIQZe251KnGczIK6Kt33//PTdd2InTxoEaonVhpo9I5jXPNcxufco2L0T0v9kyrdJRaWkpunbtirZt2zKXQYO0m6bY2AZl5OfnIy4urvH3+fn56NevX+MzP//8c8B7dXV1KCoqanxfjYiICERERDT5fVRUlKlN081Xt8XFnbKRV1LdZKAphHkAnw+anwfjAfDP7adw36CeaBbmbNNhvdeHf25PgyeiNdRaorR1/K9KMWTIEC51GunEAyA2uiVuvrq7FP1rRl4Rbc3Pz+emCztx2jhQQ7QuWPuIdF7zXMPs1qdM80JE//Mo02odWeVaI22cpvj4eMTGxmLr1q2NvystLcWePXsaB+uQIUNQXFyM9PT0xme2bdsGr9eL66+/3nKZm4V58NbdvVQ/8/zv35hfxzf+TIIPQG5JNRYn56DeK4XPvib1Xh9SsgvxZcZPSMkubCLv3pwi5JZUa7z9S1tzztVoPkOLv07U+twHYOTAroblGLWNF3ryKj+/dXcv1UXGzLtatGjRgvhZs4jsY7N9Y5X+9VB0IUoW1j4indd7c4q4yGlGVhr0+tnKeWEkk4j+51GmFTqyA1tPmsrLy3H06NHGn3NycpCRkYH27dujW7dueP7555GQkICePXsiPj4eEydORJcuXRpv2F111VUYMWIExowZg3nz5qG2thZPP/00Ro4caevNuejW4SiurA34XUzrcEz+fV+M6BOHa7u1w9/XZeoOymAmbTiMj3bl4K27e2FEnzjjFyxm06HcJm2Ki24ZIO/PZYTtbRXNVbYRfeIw96H+mn0+Y0sWktJOafYtSduskDeWoE4z76oR7FMoCiv6mLVvrNa/Fp07dxYuC0sfkc5r4vlPCO+x7o9RP1s1L0hkuqMPmdmNpv956VSkjuzC1pADO3bswM0339zk94888ggWL14Mn8+Ht956C/Pnz0dxcTGGDRuGDz74AFdccUXjs0VFRXj66aexbt06hIWF4YEHHsD777+PNm3aEMtRWlqK6OholJSUmDLPbTqUi7FL9mma3uY91L9xkCh/ISQfPYvZ27OJylf243P9ypEBrXYHy5uSXYhRC1INy/tj2yNI/NuLhs/RUu/1Yfa2o5ix5ccmn2n1LWnbRKCMkZ/LqtGpbUsMim9PdbzO+q4/8+fPFx73zOo+pukbO/UfzLNvTcO6ml6WyELTR6TzetmYwRhyWQcu8vnDa6wrkOj85O51lsYD1JOJ9Aucpv9565S3jvzh9f1NijRxmuyER6fXe30YlrhN8/RIsd/uevWWJv4AwxK36fpBkZRDIyfPwUvTbgC6bVWe/eLR3ugSZ95pNLitA7q3w03TthPriFWnvPFvR8fICMADFJTXBOhP1KKUn58v9K9qWfpYdtnqvT4MeuMLFHpbGcoCQNgXlJZsQ6dsQ16p9qlDbFQEkl/7rfSmGFKdm12jaOarkUyKXFrfHyzj1Oh7yc55GYzVmyZpHcGdBo0N2H9nrth9xy7ZR/RXg1Y5JIg42qdtt1Zb/W3cixZ+hDfeeINJHgW1traPDEdRRa3mO8GysuqUJ2rt8CcuuiXuuSYOa/fnCjHZLFiwwLQu9JChj7WQSba9OUXI3vUlYm4YqSvL7G1HkZR20lJT4ubMPFTX1es+U13nxebMPKlOyNUg1fnb097H/PfeZaqDdh02kkmRSw1W3yG97yUn+yPxQFpHcKdhxgas2H1jo1tyr09BOd4Nnnx5JdUYu2QfNh3KpSqPVg7lOa22xka3bDQv8NgwqbVVb8OkJqtdvhoKWu3wJ7ekGh/uzOGuVwWRGybA/j7mUacVsv1cVq25YfJnxpYfhY0FNZQxGuzDGUxJZa0wGXhCqss7Hx7HVD7LOmxmfPmvq7SQrNUXIu5JEyc6tSXb8Gg9N6JPHG7tFYvFyTmYtOEwt/qAhqPWv6/LVP1rxIeGvxz+vi4Tt/aKpf7LgaXdSlu1jqcTEhKYv6z12kqKIqtZnZrBbDvM6lXBjC5IsLOPedVphWyd2rZE8e4koo1TMLzGQjA0Y1SUDLwh1eWGT+bg3n50J02s6zDL+IppFY45o/tj8KUdTPW10Vp9IeKeNHFiUHx7xEW31Awl4EHDEeygeO0gXs3CPHh0aLzpcoIxc33U6Hoza7ubhXkw5LIOuLffxRhyWeDEfumll1TLIrlqTXKUrUWwrIPi2yM2SnvBYtEFKWbaoaClV5or62q64Hnlnce8EYVMsg2Kb49fDR9FHKokGBHX/mnHqAgZtGAdo6Q6f28S/R8SrOuwkUxqFFfVIszj4RJCw3+tHhTfHntzimwNvWE37kkTJ3jZgEXYklnNDCS2dxHyfvDBB02+rEn9AFiPstVk1fPVEG3X52ny8S+L1p8iWBe8/eJk9p2QSbZmYR5cXbYHW5oNUpWF9KtL1Liy4j1SzIxRUp1/OG+u5h93WrCuw7R+r0b1sfaPLKE37MY9aeIILxswb1syi5mBxvbOW9577rkn4GcaWUjb2j4yMDhdsKxGvhoxrcOF2vV5mnyUslj8Kfx1IcovTmbfCZlke+XJhzRleWF4T6IyRIwrq94jgccYJdF58BpFghlzL4vfq1o5rP0jau47EfekiTO8bMA8bcnK8a7R9VHFzMBie+cp7759+9CzZ08mWUjb+u34m5F+4pyqrCS+GhHNw4TmAzRqBwn+emX1p1B0IdIvDpDbd0IW2fbt24c//vGPqrIAQFLaKeI5zgPaMSpCBn94jlEjnfuvUaTQrsNaMqVmF2Lc0n0orlL/g06rHNb+ET33nYa7aWJEL86GYgM2C89yaMwMZsIn8JD3oosuavx/UlkWJ+egY9sIdGrbEhPv7IVxS/Xb2qJ5mKasJL4aeaU1Qq+aNwvzYOKdvfDXpfuY3lfaPnJgV6w/cAYFZTVMOlV0IeL6vdocsjqsAClGY1tE/LPg8hRdaMlipSlRke/2PrFYlHzc0GzEQwajPuY9RvV07r9GkcLD3NsszIOhPTtiygN9MXZJw9pAWg5r//DoV5L5ITIAJk/cTRMDTrTt0oSzt/uqtX8yZdI6/G8cxkW3xJM3xjeJXUQaut/u9gMNY2zShkzD5+KiW6LPxVHYevhnBPtkRrZohhlbsqjqDW6TogvefeLEOaQF77Zolff/LinHLTrvWZWyQk0+j6chEblCmAcB49GsDDzTNPGYt2oJ30ngpSMr092Y7VcS3TlpPXA3TZRohbNXbLt2+2DoQWpmsPuqdXZ2NoYOHcpcR15JNebvzMGcP12LdpER1H+52N1+o3Q8z//2csRf1Aad2rbEuYrzGLe06bM+ABXn9QMOqhHcJkUXPPvEyXMoGN5t0StvSvK36H3tIMPcgyJNiVryKRukJ4b2wPBesRjQvZ2m+ZtXncF9bOW89V+jaLHLhYO1f8z0K4nuADhqPXA3TRSEgm2XxIRm1vauBs3R629+8xtiWdRQdDFpw2GmMP8i2k+KkT+VB8Dy/5wOSEvD49KvVpsUXfDok3qvD6nZhXjti4OWzyERR/+81wOj8lp260tUHi8zOY18QEN7Nx7Kw+t39uImA00fWzlv/dcoFuxw4WDtH9b3SHT39trvAXgc9Z3q3p6jwEy8Iyeh2N6BX2zkCiy+CZsO5WJY4jaMWpCK55IyMGpBKoYlbtO8cfHpp58SyaKHGV3wbj8NNGOMRywnQL9Nii7M9okyBkYv3KPpwAqImUO0448U3uuBUXnlh7bbur7Ysf7R1GnlvPVfo5wCa/+wvkeiu7zSGt2chTJ+p7qbJgpk8HWxCl5XrVmuqk6YMIFIFhJYdWHXVfMtmXlEz/1cVs1tnOm1yV8XrH1Ckg4mGF5tE3lVmvd6YPRc1JA/UJXHGzvWPxFpmngQvEY5Bdb+YXlPhphgInDNcxTY7etiNWZt76zmi3fffbdJ6o5gWQrKarinmwnG6qvm9V4fVmf8RPSs2TE28c6rGm8b6rUpWBe0fcKaDobHHBJtTue9Hhg9V5KyAjE3jLRtfbFj/RORpokHamuUU2DtH1E+VCTI9J3qbpoosNPXxS7M2N5Zr6q+/vrrurIovjExrcKpY5XQwtJ+Vv+ZvTlFREmFO0S2aGwXrb+X0i+PDo0nkklNFzR9wmJC9G+fGUSESfCH93pgVF7MkAcRGxUBr8+HLzN+svxath3rH2udovy6FLTWKCegtT6RrFu8fag6R0UA8CC/1Dnfqe6miQKZ0io4Adbj/MmTJ+Nvf/ub6rNqV1ODsVMXZq7OkvbXvf26NLaLJr0CS7/o6YIElmN1//aZQbQ5ifd6YFReccpKxAx/CKM/2tP4eyuvZdux/sm65pqdF3ahtT7dc01ckxAtZscWie7evqc3AEinXz1cnyZKZEqrIDusx/l//vOfVZ8j9Y2xSxdm/WdI+yu61S8pYLTGY0zrcMS0Dg/4HUu/aOmCFJZjdV6R1q0wJ/FeD7TKi24djsg+NzdJ62N1Ggs71j8Z11yz88IOtNan3JJqfLgzR4jfH4nuZNSvHh6fz0frbhBylJaWIjo6GiUlJYiKiiJ6xynRS+2k3uvDsMRthkfrwWEBPvnkEzz88MOqZeltmGJahWPO6P4YfGkHy3VhJJ9WW4PLGDplK/JKa3TrilMpR208AjA9RtV0QYPRGAhGrW2i6ibRCU1doiKCd4yMwEsr9+Po7g1o0+e3TZ7l2Q4W+axa/2Rac83OC6shWT/V4DW2REYEZ/n+NoNrnmNEtM2cFZkWFtaj9csuu6xJWSS+McVVtQjzeIhj4vDsJx7+M83CPBg1qJthFG+SFDa82qemCxpIM7SLOIo3qtsH4I4+DY6tZvWvth6Y0YF/eSnZhcgrrUbzGPW/uM36ZmlhRaooGmRac83OCwUr0u80C/MwhyfhNbZI54cs+tXD3TSFEDKGomcJ919T0/Skhad/ioh+4iVfj46Rpsvh2T41XdCiNQb84Z3qw6huJc3HwuTjWJh8nPs84akDRde+ev1LAjyvZcu4lsgEj3lhVfqdt+7uhZo6rylZeV/5d/L4cjdNIYLMqSlor6qePXu2ye94+aeI6qfjBRVc5DPbTt7tU9MFC8FjoGNkBOABCsprhJ+I+te9OTMPi5KPN8nTx3Oe8NaBomtvZQnRc2aReS2RBbPzwsr0O2OX7MPzw3uakpfnlX+njy/XETwEMIpHAzTEo6kP/qawEOV49t5+F2PIZfo+R/3792/yO+X6qtZbHjT8pWKUxkNEP9V7fVi296Thc0byAebaKaJ9arpgxX8MDO3ZEUMv70g0HnjVPSi+Pb46pB48lNc8EaEDZUxEdFY3CZGMfVJkX0vqvT6kZBfiy4yfkJJdaJscZuZFvdeHt9fy62MSnS3bexKxUdrrihY8xxYg//giwd00hQChlt5l7dq1TX7HI0WCqH7am1Nk6LwNACMHdjPcHJhpp4j2qenCqVgxT0TUoYyJyqN7hKcHkXktEZUOhwUz82L2tiyuqUNI05WMGtQNAHk6KhF+hjKPL1LcTVMIEGrpXf7617+q/t7s1VRR/UT6fI+OrYmeY22niPZp6cKJWDFPRNUxok8cPp76N+HXsmVdS0Smw2GBdV5sOpRreNFDgbcuenRsrbquxEW3xF9ujEecBVf+ZR1fNLg+TSFAqKV3mT59umaKAjMpEjq2iSCqn/Q5BRH9z9JOEXLo6cJpWDFPRNZxcNNS7Hr9b0Jvx8q4lohOh8MCy7xQ2kGKiDQ9Qy7roLmuvDLiKuE3r2UcX7S4m6YQINTSuxgtRsxXj0nN5JTmdKP+BxpiSHl9PtR7fUzXznnIwTIOZN4w0V7XJtFTbFSEqXkici4quhB5LduqtYRGd6LT4bDIyjIvaK790/gR0epMa12xIqSDqLXSSlzzXAjAw99HJhISEoSUW1BBdk2Y9DkFvf5XKK6qxeiP9gj1wRAxDkTpwiws/i0keqqu82JzprqzOAki56IVurBiLaHVnZ0mHS1ZH3nmVeqyaORjSb8DyL/+y7JWmsHdNIUITgtFr8eYMWOElCvyaFir/4MR7YPBexyI0oUZzPi3KP0THZRiRqGkstaS1BEsWKULkWsJi+7sMunoybodfanHCKl8Lwy/glv6HRnXf1nWSlbcNCqwPgy7SGSKCM7K/Pnz8eSTT3Iv14q0GvVeH1KzCzFu6T4UV6kHI7Qi7QWvcSBKF6zwS1ezTfMGk5WpI2iwWhciolWz6M7KdDikspZnbELPm+6jqpMkpVBsVASSX/utqfXHKes/r7XSTaPiYgqZUg2wMmDAACHlWpExvVmYB2FhHs1FAPjFByM1uxBhYR6mBc5oceQ1DkTpggb/thaU1RD7twyKb6+ZUoL0yrfShyxfRmZ1EFxnv2v7a34m4suR91pC45sUrLuJd/bCuKXi5i2trOGxl1P7UZGsP2/f07uxHTQ6Dn72rqu7SLtZAn6RN+VYAdFaKcpfjQV30+QiHfn5+cLKZknrQgup70LwX1ikaQSsTEEgUhckqLWVhM2ZeXhxRYaplBKKHu1I+aBWZ8u8/Zj58sUA4MgUFKTzQkt3T94Yj7X7c4XNWxpZvRXniJ4LhnT9oRlzTktJwjKnZQpB4G6aXKTj/PnzQss3E7aABFLfheC/sEjSCFidgkC0LvTQaisJi5KPN/kdbUqJTm1b2pLyQavOotJKPLVkn+o7TkhBQTovtHQ3f2cO5vzpWrSLjBBufjKS1VdfR/ScGkbrD82Yc1pKEtY5LVMIAnfTpIGTbMOhBq8M4nqINGOSXKtVwyjmDI94Ncq4ziupQlHFebRvE4HYKO3xbYUu1NBrqxFKMt5glD5SUkrkl+r7yAzo3g43TdtuaXwgvXY3b6f95WdXvCIaSOaFke4mbTjM5LvEOzxFeLs4U+lFtNYfmjmO//2/VePT7Hciy5yWMVyOu2lSwWnHnaHGt99+i759+9otBjN6vgtG6Nnwzcar0TsW1xrfdumCJqaNgtLXemmrlJQSLwy/AjO3/KjrI5N+4pzl8YH02l198iBaXNTDUnl4YuTTQ6I7lvaxrOdGslafPIi3Xvg9980pbZoRq8Ynj+9E2jktW7gEBTfkQBCyheu/EHnooYfsFsE0WtdqY1qpX3UPRs2GbyZejda4VsjVGN926YLFhyE2uiWeGNqD6FmtlBL+V7TtiA+kV1ab3jebLsNu9K7Gk+qOpn08wlOoyfrh358X8gc0zZizanzy+k6klUPGcAmAe9IUgIzh+i9EZs+eLXUkalLUfBe8Ph9Gf7TH8F01Gz5rvBqaY/Hg8W2XLkjbOvHOq9CxbUSjuWBvThEWqvjEqJWvl1KCRgae/hZ6ZZXuW4+YG0ZaKo8ItHx6Uo8VEumONM0Rj/VcS9bJ774D3MB/XogYc2bGA8/vRFI5nr75cgy9vKO0LjHupsmP9OPWH8eHArz9v0Jhw6QQ7LtQ7/Uxp6lgTXFBeiyuNr7N6EJvXBiNGdK2Pjo0nuk9o5QSLGWZwd/XrH1kC5yrON+kTqMNk5o8svpmqvY7pzRHSpuTj57lsp6rySpqjaIdc6LHJ88UNqRte+HWKxrrlm3cAu6mKYCz5c7PwGw1Ivy/EhISQmrj5I+ZWFGs79KOV//nWXWhNy4A4yvzrG3lGYvLirheAPkV7OLdSYYbJ395nOabySPNkVXX2UWtUbRjTvT45GkCJG3b5sw8qcet69Pkx0VtnJ+B2UpE+X8988wzPMSTFjMpD1jepR2v/s+z6EJvXDy1ZB+eIhwzrP3EM6WE6PQURr5m/kQNuFvzsw6RLVSvojvJN9OsaYqmL1nq9UfkGkUz5kSPT97mQiN5AUg/bt00KvglDHvRuWLcMfc/lobrdyo80lloMWvWrJDfOAHmTCe00YL1dKWgpjNaXZDWRVq/UiZLP/E0TYkwc5H0VbvWzeH1eVBSVYvS9HWqG6f2keFInTAcLZqHEZUr6zpmJl0Ky7iTfY0yExGclzlLVAobNXkBMI1bN42KjVh1HB+MrH4HWnLVe31YnJwjzP/r5pv1bwnJ2l+0mIkVRfOu/7jW+wvJhwbHav++NNJFMCyhAvzrVxszrP3EMxaXiLheJH11rrKuMTxCq26BoR8ULb17f9/GDRNJubL6ZppZf62+zk47L1igneMidCnqO1FN3pTsQqY0O5HQTsMiAnfTFIQVaTb8kdXvQEuue66Ja5LKQA8Wf4GsrCz06dOHSi67+0t2tMZ1MJM2HEZYmKexL/V0oQYPf78LxWeQtJ1KeITnpvwHNejR+HutNcmOUAm8YF1/Wa6zm1kzaOeFk7HqO5E1zY63ppJL/aS4myYVRKfZUJA1BL6WXLkl1fhwZw5VWSz+Aq1ataKSy+7+cgr+4/qb73Px8e4TTZ4J7kstXWjBw9/vQvEZpPEXGXJZB7z3p0Fo/6tBhmuSHaESeMKy/lp9nZ12XjgdK74TzaTZsRJ306SByDQbgLwxocykr/DHzHXXDh3MpRdwoqnOKpqFeTAovj1eXJGh+nlwX6rpQg/WFDKAnCkTREJ7vbzTRR0xkGBNsjJUgiho11+a6+w81gfaeREKiP5ONJNmx0rc23M2QRsu3yrM+KQomPUXyMjIoJZLq7/qvT6kZBfiy4yfkJJdiHqCGcfyDg2iyzeCpi8zMjJQ7/UhOasA//z6B/zz6yNIPlqgKbPiAwH8Mg4UPBr/7/+zbCkTRELSV/79oTYveJQbCljdZlJd8MLsmkHzvh3rk+Knenuf2MY/3PxRfrZ7wwS4J022IavfAY/6zNq677676Q0hlv5i8X8S7TMlg08WTV9G9hyEAQmbUVz5i7Pl7O1HEdM6HFN+31dVZiMfCKBpnCZRPoOyQ+MvojYveJQbKljZZhpdmMXsmkHzvh3rk1qdHg/gf68/Nrol7ugTSxQxXjRuyAFYf2URaLgpMGpBquFzy8YMtvSGC6lcWky886omUZppUQscR9tfWv5PilRq/k8s79AgunxSSPvyheFX4K1//EM3oOI8HZnNRAS/0CDpD5aAihdiP1vRZqsC8JpdM2jet2N90qpT4YmhPTC8V2zjbTm1dctbU4lTMx+07Pvb3TTBnk2TqPgXouXSgneMHVq5/OsH6ON9iI5tw6t8Hv15vs6LwZO3oqjivKYsnaMi4PMB+WX6UZpjoyKQ/NpvQ/6LWA0ZNiQyyCAaGeIV0cJDDrNrBs37ADB0yjbklVoX24u2fVrfAVZvmlzznE3YFRPKjFxaaMnLetSr9lccTX/RxPtQTvFEx7bhUT6Po3OlDL0NEwCMGtQNM7ZkGabuyCutwextR/Hc8J5E9YcKdpgxgueFDKZe0chqWtI7aeIlh9k1g+b9vTmFmhsmkrpYoG0fy3eTCFxHcBsRHQKft1xx0S3xlxvjEUcgr5k0Di+//DKVXMH1s/g/ifYxM1s+j7QYJGkmlL7s0TESABA96PeG5c7Y8qMU6Q2swq4UJf7zwolpUmihaaPV/aG1RvGUw+yaQRP3aMaWLK4y8SzL/zmt7wArcU+abMaqmFA85XplxFW68poNDzBr1iyMHz+eWi4Fljg1omPbmCmfR7gFklAS7SPD8e34m9GieRhSsgsBAKXp6xB9/QOGcl8o4R7sDH2hzIsLIfwGTRvxv/+3sj/U1ijeejG7JpG+vybjDNFzNGXyLCv4ueDvgEjU4taZ3MQyxN00SYBa/Itgm/iA7u2QfuKcpRsrrbgcRvE6zB4r33fffdRy+fdXx8gIxEa1RH4peZwa0bFtzJTPw7RHEkqiqKIWn6Ycx6ND4zEovj1ioyJQ23Ow7jsKwfXL4lvCG1Zd8OgPZV44NU0KDTRt9Pp8lveH2hrFWy9m1ySS99tFhmua6oOJM7H+qY1/mvapva/0YWlpKZNMrLibJglRs4kHB/WS2XfB7LFyeno6evYk95FR66+Y1uGNf92R+IuJ9jEzUz4P0yFpGZM2HMZHu3Lw1t298PY9vfHn179BePuLqeoPZV8bq0JfqKHMC1nDlfCExrS0at9PXMskQW2NopGZZNNkdk0ief/+fhcTX+NnXf/0xj9J+zZn5km1nrg+TZKhZRMPDuols++C2WPl2NhY4rq0+qvkf3GFoluHB5at4y8m2seMtXwepkOaY3VlbAHA+PuvR2REM+L6Q93XhlYXPPtDmRdOT5NCAk1KjeIqsoStPPtDbY2ikZlU72bXJKP3h/ciW2tfGH4F0/pnNP4B6MoHQLr1xD1pkgiaFCYy+y6YPVZu3pxsWJL4ELRsHobP/u96FJTXEJlFRPuYsZTPw3RIk97Ef2xNGdoJz/95qGGIgtjoBhPyTdO2h7SvDa1JgaePizIvQiFNihE8U2qI6A+1NUqR2cgMTqt3s2uS3vv1Xp9hP8dGReDpWy4nqssf0vG/69VbVOUDGkLHGL2/cex11LKZwT1pkgjaFCZ2pVoxwmxKg5wcsqTAJD4EeaU1CPN4cG+/ixuvrerB4ntCm3ZA8ckilUmvP4GGdt7Rp2HRYUlvooYytrbuPYQWzcPw7v194FF511+f6SfO2ZIayMq0DzRjm3eqJGVeXAhpUkjaSKNm3v2htkb5y6xHsN5Jxi/tmkH6vlE/ewC8fU9vpr6jGf9q8pG+n378HLVsZnBPmiRC9HV2KzGT0uDGG28kqoO3b4eMaVcUtPpT+Wt7YfJxLEw+rlu3Vhl6dO3VX/ddf31+mWG9b4kd/lOkY5v3+PSfFxdCmhS9NpKm1NBL92MGrTVqRJ84PDG0B5FsP5dVS+H/J2osWRUy4Wy5td9/7qZJIkRfZ7ca1mPlpUuXYsKECYbl8/Tt0Arnr9jOadKu6L1jBv/+3JyZh0XJxzV93fT8tm7tFYvFyTmYtOGwYZ37tq0H7ri+Sf1q+rTa18bq/vdHVOgLPYLnhazhSnii1ca9OUVEG5M5o/pjaM+O3OXSW6OG9yLb0B0vqMTMLT/aMn6DETGWrAqZcFEba7//3DQqsCeNihq0KUz0Qts7+cp3fX09mjUzdj7mlYqGJV2B6LQrevCom7Tvvn35JrQIJ/cxsyo1kJ39Twrv/iCdFxcCxON3/M1CQrXo6YJEts5REQA8lqYtsRqz45/0/Y1jr0P7djGWfX+7Pk0SQeN3oue7sOlQLoYlbsOoBal4LikDoxakYljiNsfcXJo8eTLRc7x8O1h8T3j7q9DAo27SvpuaOIVYLit9bezsf1J49wfpvLgQIOnbe66Jw03TtgtZB/V0QSLbqEHdiNOWOBWz419W3z130yQZWldEg8eF1pXTULjyTZM9nEeYABnTrvAo0+g5kr6jzeRuVWogp8Qq4tkftLoIdfT69skb4zF/Z46wddBIF0Z6V9IUGWH3+DWL6JAJdvjuuT5NEqJmXyaJCB4q6RX0kmGqYdYeL2PaFR5lkjxn1He0uiApkwdOilXEqz9YdBHqaK2VokNfkOhCT+9KmiIjZBi/ZhEZMsEO3E2TpKilCjGKIhsq6RUeeeQR6neMUrvowRL3xs5YObzr1us7NV2Q+MuZ0QcJTotVxKM/WObFhUBw36ZkFwpfB2nmhVodvMYvje+qnX6uZse/6PWEBqnNc/X19Zg4cSLi4+PRqlUrXHbZZZg0aRL8fdd9Ph/efPNNxMXFoVWrVhg+fDiyssgyNocaTjFZGLF161ZL62Oxndtpb7ey7mBdyOIvJ6u/g0isnhdOxYp10Oy84DF+aeqUZd6GAlJvmhITEzF37lzMnj0bhw8fRmJiIqZOnYpZs2Y1PjN16lS8//77mDdvHvbs2YPIyEjcdtttqK6We2MgAieZLPS44oorLK+TxXZup73dqrr9dSGbv5yM/g4isWNeOBEr1kEe88LM+KWpU7Z563SkNs/t3r0b9957L+68804AQI8ePbBs2TLs3bsXQMMp08yZM/HGG2/g3nvvBQB88skn6Ny5M9asWYORI0faJrsdOM1koUVVVZUt9bLYzu20t1tRt6ILWf3lZPN3EIld88JpWLEO8poXLOOXpk787/9lm7dORupN0w033ID58+fjxx9/xBVXXIH9+/dj165deO+99wA0hLLPy8vD8OHDG9+Jjo7G9ddfj5SUFM1NU01NDWpqahp/Li0tFdsQizCbFVsWCgvJnCRFwGI7t9PeLrpuRRcy+8ux9gFryhy7Nmha88LRMdkEyG7FOshzXtCOX9pwG7LOW6citXnutddew8iRI3HllVciPDwc1157LZ5//nmMHj0aAJCXlwcA6Ny5c8B7nTt3bvxMjcmTJyM6OrrxX9euXQEAx44dw9SpU1FTU4OEhAQADbckzpw5g4ULFyItLQ1ff/01Vq1ahczMTLz//vsoLS0NeLaoqAhz5szBgQMHsHbtWmzYsAH79u3Dhx9+iLNnzwY8W1lZienTp+PIkSNYsWIFtm7dit27d2Px4sU4depUwLP19fWYPHkyTpw4gU8//RS7du3Cjh07kJSUhKysLEybNg3V1dX4z5qFmPtQf9Slf4768nMoy9iEmtwf0TL/AB6Ky8clKMSsWbNQUlISUH5xcTFmz56NgwcPYs2aNdi4cSPS09Mxf/585OfnBzxbVVWF6dOnIysrC8uXL8e2bduQnJyMTz75BCdPnsQ777wDr9eLhIQEeL1evPPOOzh58iQ++eQTJCcnY9u2bVi+fDmysrIwffp0VFVVBZR/8cUXY/78+UhPT8fGjRuxZs0aHDx4ELNnz0ZxcXHAsyUlJZg1axYOHTqE1atXY9OmTUhLS8OCBQuQl5cX8Gx1dTWmTZuGrKwsJCUlYceOHdi1axc+/fRTnDhxApMnT0Z9fX3AO6dOncLixYuxe/dubN26FStWrMCRI0cwffp0VFZWBjx79uxZfPjhh9i3bx82bNiAtWvX4sCBA5gzZw6KiooCni0tLcX777+PzMxMrFq1Cl9//TXS0tKwcOFCnDlzJuDZmpoaTJ06FdnZ2Vi2bBl27NiB7777DkuWLMHx48cxZcoU1NXVBbxz+vRpfPzxx0hNTcXmzZuxcuVK/PDDD5gxYwbKy8sDni0oKMC8efOQkZGB9evXY926dcjIyMDcuXPRrVs3JCQk4OeyahTvToK3phKlaV/ifMFJVBxJRlXOPtScOYLyA9+grqwQs99LbCy3trYWiYmJOHbsGD777DPs3LkTO3fuxGeffYZjx44hMTERtbW1TebaokWLsGfPHnzzzTf44osvkJmZiZkzZ6KsrCzg2cLCQsydOxcZGRlYt24d1q9fj4yMDMybNw8FBQUBz5aXl2PGjBn44YcfsHLlSrw7PwnXjJuNu5+ZhHHzt+D2x57HsMRteOSZV1FXV4cpU6bg+PHjWLJkCb777jvs2LEDr039ANe9sgR3/N/LeHZJWsA7VqwRZ86cabJGPPLMqxiWuA23P/Y8nl2ajjsefxEDX1uG8ZNnaa4R/uXn5eVhwYIFSEtLw6ZNm7B69WocOnTIkjVi44Gf0OO2xzFy/m48+uwE/GH6Wvzqj69h+qdfGq4R+fn5umuE/zroralAafo6nD97HC1O/wdP9ChBh6rTptaI3bt3AwBmv5eIutKzKD+4BdWnD6PqeAYqDn+H2sLTKN27Ct7ahnnzc1k1tzXis08+Rl1ZIYp3JwEAincnwVdXi5I9n6P2XC4qMr9F9ckD2P7tt1iR9BnqSvJRkroSPm99wDt1pQUoP7AZNT/9gG82f8O8RhQWFgY8W1ZWhpkzZyIzMxNffPEFvvnmG+zZsweLFi1qsrbxWCO+/PJLze96EUgdETwpKQnjx4/HtGnT0Lt3b2RkZOD555/He++9h0ceeQS7d+/G0KFDcebMGcTF/WL/ffDBB+HxeLB8+XLVctVOmrp27Wp7RHCeOPmvz+nTp+Oll16yWwwX/KKLlOxCjFqQavj8sjGDpf+LVSv9ijI7aFLm6L3Dm+B5IYNMrFglu6h10M55QVMngJCZt1pYndFDavPc+PHjG0+bAKBv376Nu/1HHnkEsbENNtv8/PyATVN+fj769eunWW5ERAQiIiKEym43NEe+sm2wxo4da1ldsrVdNhRdhIq/HKk/yC1Xdm6Mi9a+VQu8vvqQ7X4h/vNCVh8zNYLn2IDu7SyTXZT52s55QVtnKMxbmZDaPFdZWYmwsEARmzVrBq/XCwCIj49HbGxswPXP0tJS7NmzB0OGDLFUVqci41VUxWdNNDK2XTYUXYTKFX9Sf5DBk7c2jos/f7wXRRXnDd8RnfLCf144IY0MoD7HBk/e4gjZ9bBzXtDUGSrzViak3jTdfffdeOedd7BhwwYcP34cq1evxnvvvYf7778fAODxePD8888jISEBa9euxcGDB/Hwww+jS5cuuO++++wV3gHIehXViqjHsrZdNvx1EQpX/Elj8+htksyWzYq/LpwQk01rjhVV1BK9L3M8ObvnBU2doTBvZUJq89ysWbMwceJE/PWvf8XPP/+MLl264C9/+QvefPPNxmdeeeUVVFRU4Mknn0RxcTGGDRuGTZs2oWVLuWMR2Y3Mx/ui00XI3HbZCNaF06/4i4xRJjr+mb8uZI/JpjfHSJE5npwM84KmTqfPW5mQ2hHcKqx2JJMBuxx7SXyIzp49i4suuohbncGEklOzCPx1FH6+HLdddwXxVfy8kioUVZxH+zYRiI2ydmEmGVv1Xh+GJW7T9PFgQfEL2fXqLULb6j8vjNphlUxakM4xNeyWnQTRa5QLOa4juIsl2HG8v+lQLv6+LjPguD4uuiXeurtXwBHxqlWr8Je//IVbvcE4wbRhF8E6Ksv4ClfcdH8THem944+afq2QW6tuvRg+ZrDCL8R/Xsgek4117sggOwmi1ygXeZHap8lFHFYf79P4EA0cOJBLnVrIbtqwCzUdtYjtqevnpaVXhVwLfMRo/dO0fDzaR4ZT190hsoVlfiHB80JmXxXSudM+skXAzzLIToLoNcpFXtyTpgsUK6/K0voQ5eaKdcIOlevzPNHSUX3FOU0/Lxq/FVE+Yqz+aWo+HgO6t8NN07YTm+7aR4YjZcJv0aK5NX97qs0LWX1VSOfYt+NvbgztIIvsJIheo1zkxd00SYzIGEJWHu/Tphqor683XaeCVh/KZNrwl7FjZATgAQrKa4R+iQT3i9fnU9fR/8J7qKVbMNKrgvJuanYhhvbsyLEV5tJYqMXwITHdKdp49/6+lm2YAGjOCzvT+GhBOsdaNA+TTnYS1HShFo+K54bQ7phydtcvC+6mSVJIfTTMoBzvB9cTy7keWh+iHj16cKnXqA+taDuLjP6I8AlSqzOmlbppqnl0p4Cf/XVJ67cybuk+THmgL9e28PZP0xoX/lg9RhR4zQurkGWOiSBYF2pzKswDeP12i2bmshXfBzLXLxPupklCtFIMKD4aPG3+Vhzv0/oQfffdd7j66qtN1Unah3aaNrRk1JNXVJ3FVeqxc2pOf48WneIbf/bXJa3PV3FVLffxK8I/LXhcWHX6ZwSPeWE1ds8xUfjrQmtOeYN+wTqXrfw+kLF+2XBDDkCukAPKVWKtv3KdcB03GNrr0UVFRWjfnt2fyAl9aCSjP7zkpamz8Z2qMjRr1VZVBpbyePe97FfveWJ2XrjwQ9EF7RygHY92r2V210+C1d/f7u05Heq9PqRkF+LLjJ+Qkl2I+uA/HQSU55T0CDTQhvL/4IMPTNXnhD4k9QcCzMnrP+YWJ+dQbXAAoOy/GzT9vBS90iyVpG0hnXt6Y0upb+TArhQSyovZecEDNb3wXiedgKILmnkM0M9lu9cyu+uXEdc8pwFvGy5peaEaQ4jGv8FsNHAn9CFL3bTvGPlLaRHTKrzRXBdzw0hdHxQSHyA19NpCO/eMZJixJQtJaacc739hRXohPVR94Vo3+MIVV/5i3r0QfF0UXbCuIbzXKFFrmd31y4h70qQC77xkNOWFcgyhEX3isOvVW7BszGD8a2Q/LBszGLtevaXJ4pqQkGCqHif0IUvdNO8YxU/SY86f+jfq6Hfnk1V15I+/Xsf95jKiOrTawjr3FBleGH6F6uehkFPQ7Lwwg5ZeiitrAzZMQGj0tRGKLljXEN5rlKi1zO76ZcTdNAVhFPfFB+D11Qdxvs7LpTygIY6McqStxDfRM3nEOTiGkHI9+t5+F2PIZR1U7eDPPvusqTqM+tADvn3IYp4g0bMCrbyseb+UegZf1qFRR/98+zUiXwVFry/+7lfMfU87V9RYtvek6u9J35cZs/MCYBurtOMpFPraCEUXNPMYoJ/LVq9lstUvI+6mKQgSG3VRRS0GT95K9JcUrU3Y30dDi3uuiXO8U6seixcvNvU+rQ+VGTYdysWwxG0YtSAVzyVlYNSCVAxL3GY4Nox8cczIS+tnoeBTqYdWF2b63qz/xOxtWcgrDV3/C7PzgnWssownp/e1EYouSOex/+c0c9nKtUzG+mXE3TQFQWqbLao4T3QEzWITHtEnDk/eGK/57PydOSF99D18+HDTZViRYsKsGVdLRrPy8vQvYNEFa9+b8Z/YdCgXM7ZkMb/vBMzMCzNj1Ux/ObWvjfDXhdZ4D95HsK49dqfLsbt+2XAdwYOgtc0apYdgsQnXe31Yu1//C1dUWgoZ+OGHH9Crl/5pGwkiY8Swpu8wkpFHTCBW/wI1mVl1wdL3rP4Tii5Icar/BasuzI5VM/3l1L42IlgXWml5eEUEtzveld31y4S7afKj3uuD1+sLuD2kh16KBgWWPGdmUkOYRYZQ+ZGRkdzKEpVigqeOeMtoNOa0UJPZjC5o28WaE5DGfORk/wtWXZgdqyzjyan5G0nXPzVdqI13o/FPs97anS7H7vplwd00+fG7Gd/ibE0z6vf0jqBZ8pzZdc1TllD5TgjgJ/NVXL0xR4K/zFbqgjUnIE0fO9n/glUXZscq7Xhyqq8LzfrHY17Ist660OH6NPmRX1rD9J7RETStTdiOa568wyyY4cCBA5bVxYrsV3FJ/KW08JfZal2w+E+Q9vELw69w9JcRqy54jFWa8RTTOtxxvi6065/ZeSHTeutCh3vSZAKaI2gamzCrmYIVXv45vLj99tuF12EWq3XEgjLmUrMLMW7pPiKTc5gHGNC9XePPduiC1n+CxHwUGxWBp2+5XJzQFsCqC15jdUSfONxyZWcMnrwVRRXnNZ+LaB6GW3vFMslqByzrn5l5Idt660KHe9LECOv1UaMYRcpzVl7zlC1U/qJFiyyphwUlzs36A2cwcmA3ANrpO2QwTzQL82Boz46Y8kBfoue9PiD9xLnGn+3SBelcUZ7Vmy8eAG/f01u3DCekAmHVBc/1JP3EOd0NEwDkldY4ItSAovMZm49Qr39m5oVM660Txr1suCdNhAQ7h+ulluABTdoRs8jmn2N3uggttNJInK/zovJ8fcCzSnoJWRjRJw5PDO2BhcnHDZ/117OsugjGzHxxim+JGV3wWk9kWytYYUkxxGteyNKHThn3suFumgiZ86f+CAvzWHqrzKprnrL55yQkJEj3Za34IAT/HRacQkKhpLIWY5fsk8q3Y3ivWKJNk7+eZdSFFizzRUuvim+JTPozqwse64lsawULWjo3gte8kKEPnTTuZcPdNBmg2PsHq5gIrLieb8U1T9n8c8aPH8/8rgidsKQlkdE3gUXPZnTBihkd0swXK3xLeI5Hf12wlmt2PZFtraCFZS7znhd296EMPlXB45dnTCvRuJsmP2js/aF0tMl61VsU//rXv/DKK69QvydKJ2bSkoiKp8UCi55ZdcGKlfNKdDw03m1RdGHn2iPbWkEL7VwWMS/s7kM74wAC6vMizNPgT6kg83ep6wjuR6eoiICfta45h+J1UZlC5T/wwAPU74jUiVnfApn8O2j1zKILVqyeVyJ9S0S05YEHHpBi7ZFpraCFVpei5oWdfWinT5XW+A32P5f5u9Q9afLjmxduwg+FdbpHhDIcbYpCllD5e/fuxWWXXUb8vGidmPUtkM2/g0bPtLpgxY55Jcq3RFRbUlP3YPbJzlKsPbKsFbSQ6vLpmy/H0Ms7Cp0XdvWhXT5VNKZRmb9L3U2THyT2fquONu1KZyJDqPy4uKZ/Zen1B6tOSPuYNS2JzP4dpHpW04UI7DAZiPAtqff6sDg5R0hbihFpq1klGBnWClKUuZ5XUoX2kS1wruK8rs5fuPUK3fWW17ywow/t8qmiNY3K5t6g4G6aKLHiaDOU/KVYaNYsMJWNUX+w6ISmj1nSkjjBv4OEYF2Iwg6TAW/fEtpr7LRtKampB8mSLZM5WAZI9UKjc6vmhQjs8qliHZeyjWfXp4kS0UebMvgs2M2JEyca/5+kP2h1wtLHWj4IcdEt8Zcb4xHnQP8OEvx1IRK7TAa8fEu0xpQetG2pOZcvpNxQhkYvNDq3al6Iwg6fKtZxKdt4dk+aKBF5tBnK/lI0DBs2DAB5f3w7/mZinZjpYz0fhFdGXOU4/w4SFF2Ixs5r2GZ9S2ivsbO25eH7R+Cb5ccce93fakj00j4yHBPv6o3YKDqdWzUvRGK1TxWtm4Os49k9aaJEZIoTmcLr20lSUhIA8v5IP3GOSCcAqPxN1NBK70GT9sNJKLrgiVrqBqtTBwVjRn80vhpm2rJyxXJb+8hpkOilqKIWsVEtqXUuYl7YgZXrlt4cD0bm8exumhgQdbQpS3h9u3n55ZcB0PWHkU4AYFjiNkzacJi4TJdfdMGLTYdyMSxxG0YtSMVzSRkYtSAVwxK3YdOhXMdeZacZK2ba8vLLLzu2j+xA5HrKe15cKGiN3+B9kczj2TXPMSLiaFOG8PoyMGXKFLzxxhvU/aGlk82ZedRpE0K9j0lRdMED0tQNTrvKTjpWJt55FR4dGs/cFkUXTuwjOxC5nvKcFxcaauPXSRHBPT6f74JPa1xaWoro6GiUlJQgKirKNjnqvT4MS9xm6LOw69VbpB1QPOHRH0oZNOaTUOhju0JW6Mmjpweafpe1bXbOW9n6xC78+6FjZAReWrkf+aXuehrKWP397Z40SYTd4fVlQUmGyaM/rPI3kQmeISt4JezlFYdJxnAcVs1bLV3I2Cd2oNYPMa3DGy948NSLkxJZu/DF9WmSDNdnAXj00Ucb/99sf1jlbyILvENW+OvCDDz8S2QOx2HFvFXThcx9YiVa/VBSWQsAiG4dHvB7s3rhNS9cnId70iQhF7rPwubNm/HYY481/mymP6zyN5EBESErgnXBiln/EieE4xA9b4N14YQ+sQKSfmjZPAyf/d/1KCiv4aIXXvPCxXm4mybJCPZNuOvqLtwXPNH+D2bLv+qqq7jJSRr/x+kbJkBMKhJFF2YxG4fJ7szspIhMixGsC6f0iWhI+iGvtAZhHg/u7Xcxlzp5zQsX5+FumiTCCt8E0XXwKL+srIybnBeSn5iIK9ZlZWWs4gRgVg9uOI6munD7pAE7+oHXvHBxHq5PkyRY4Zsgug5e5e84kMNVzgvFT0zEFevi4mJGaZpiRg9uOI6munD7pAE7+oHnvHBxFu5JkwRY4Zsgug5e5dd7fdhwOhy+CL5yXgh+YiJSkfTt25ebfAC7HuxMsyILwbpw+6QBO/qB97xwcQ7uSZMEWJE+RXQdNOWrpdHwL+fkgd1C5AzVVCcKIlKRfPXVV1Qy6OnWX05aPfBuG4mcdqAnV7Au7E49Q4uoPifph4l3NuSG5FF3vdeHuZ9+Lt3YcbEG96RJAqywyYuug/S9zZl5eHFFhqav0s9l1WhzzW3C5Ax1FBNYsD9YLKPf2pgxY4ifFe0vx6ttssY1MpJLTRe89S0KO8fGPdfEYdKGw1zqVtrxU9WV+DIpg3s7XOTHjQgO+yOCp2QXYtSCVMPnlo0ZzHwLRnQdpOWrofw1OPeh/ohu1QK3P/Y8Ym4YqfuOmb64EOB1Q5I0iJ9WihR/3fL6UjHTNivlpIFErv+sWaipC5kjgts5Ns5VnMe4pXzq9m9H8e6kxjXK7rFzoWP197e7aQK/TmdduMymYSCpV1SqB6XuvJIqTNpwGOcqzmvmeAvzAFon2Ur9346/GTdN2x6yqWRk/nJjhWeKFJHIKqescvHAzrbxTt0TqjqiQcb1y02j4lDMHD+buY5NWq+Iq/dqdauh1Kdn+ld8ldJPnMMVZ75BXuSNIRciQFazkB4kJ01OiRckq5ykco19+W+Y/967lsnFAzv7nGfdwWX5nzTRluVUnLh+icB1BOcAj6v2LNexaevlefVeq241YqNb4omhPYjK/bmsGtPfGh9yIQKcmu7iqaeeMnzGKfGCZJWTtL5f3z1KsCT8sbPPedYd/EzbfrebqtNpOHX9EoF70mQSnlf5aa5js9bL4+q9Xt0K7SPDMfGu3oiNaih/b04RFiYfNyy7U9uW+PzzlXjqqadCJkSAk9NdfP7554YbJ6fEC5JVTtL6Du76GrjZWVfd7exznnUHP1N5JBltr72DuU4n4eT1SwTupskkvI+fSdMwmKnXbKoHo7oBoKiiFrFRLRvroYml0mrwYC5yygKprhYn56Bj2wipNoiD/6cLPWSPF+Tvd9c+soWm351dcpL23x9v+62lcvGAZmzw9pfhOS6Dy4rociVzWSIQ6Wskq1nbLtxNk0nsOn7ekplnS700Zfo/R+NTdfr0afTr14+XuLZD2l+TNhxu/H9ZfAVIdCFzqhoavzvAHjlJ+y/3eDrQ/1pLZTMLads2Z+Zx95fhOS6Dy6orK0CLzpcylcUb0b5Gspq17cL1aTIJ6XHs8YJKbnVuOpRLZOoC5Dr2JvWpCrULnSw6kMVXgFQXMqaqofW7s9NfjqT/nDovjNoGQJi/DM9xGVjWL7qQcYzzXD9kNWvbhXvSZJJB8e0RGxWBvNIa3eeS0k7i6VsuN/2XiGJfJiHMAwzo3s5UfWqYOfYm8anq2rUrd5ntxKi/1JDFV4BGFzKlqmHxu7PbHGrUf06eF1ptA4BhiduE+svwHJdKWUs2NENM157SjnGe64fs5nercU+aGFFSAqw/cAbDLr/I8HmzaVAUSPyJFLw+IP3EOdN1BmM2fYNWGg2lT+et+Cqk0hPo9ZcePNLnmCUlJYXqeVlS1dD63dm9YVLQ6z8aXciYJia4bQCwODlHeAoptbrN6LtZmAeVpw9LP8Z59p2T0vWIxj1pYoDUTyIYHjZf2jJE2Zl5p2/w79P6qh7YtCBVGr8eHmj1Fwl2+go8+OCDttVthlD0wyDVhRPi6dCuobLpSYZ5YeUYd0q6HitwN02UaKUEIIGHzZe2DJF2Zl7H3sF9WvbfjYi5YWSjXd6psZmCCe6vgrKaAOdvLez0FZg7dy5RGhXZCEU/DBJdaK1PMs0lljVUNj3JMC+sHuMymd/txE2jAvIw7Eah9LXgGWKfVAanhPW/kNMTiEpt43Jh9q0T5hLtGiqDzLJyIY5xNaxOo+L6NBGg+AfM2HyEacME0Nt8tXwSFPsySUlOsDOr2eWLdyc1/j+JXV5G/w0SnOArkJCQYFvdZnBC39JipIvUY4VEPi6p2YWcJSOfg0Yy+iOznmSYF0Zj3Adg5MCuWH/gjOl1UdHv6n2nsfC7Y1j9X2ettTxxT5qgv1Nl9V9SYPElIPFJ0JNLNv8FPb7M+AnPJWUE/M5bU4mwiNYBv/vXyH64t9/FTd53gv+GETK3oaysDG3btrVVBjPI3Le06Oli06FcvPbFQRRX1RqWE9MqHFMe6Mut/aR9TCOjVhmyINO8UOv/mNbhAIDiyl/6mrU/Zf+usfqkyd00QbvTzfgvAcALw3vi6Vt6UifBVatTKcHfJ8E/0nFRxXm0bxMhzfVpUlKyCzFqQWrA70rTvkTUwHsDfrdszOAm0WZp+kp2ZMweDgAzZ87E888/b7cYppC1b2nR0gXLOuUBn/lBOgdpZZx451V4dGi8tHqSbV74j/HjBZWYueVHLusiid54jSVWrN40uY7gGpDEedHDAyAp7RSevqUnlzrV4m7wSjNi55eKWgyQlvG/RD3WigESavmQ7EgZQ6L33/3ud1TPy4gM6Xh49J2/LvzLZV2nzM4P0jl4y5WdiWVU5rssGyYtvanpwk6UMa74OfFYF2nGlpPWWrO4myYNaOIhqcGSj8eOHD92my/UUh3UFp5Ci47ddH0a3HxI5iDV++HDh9GrVy/bx4mT4dV3ii78YV2neMwP0jn4acpxKhll8WHS01vFkaa6kAGe6yLp2LrQ1lrXEVwDXnFBaMqxOraMFSH4SQhOdRDWohUA/fQEoRiHxypo9N62bVtpxokT4dl3aj40Zse3mfdJ3z1RRJZCKqZ1uDQmdSO9/VB43ibJ9OG5LsoSE1A23JMmDXjFtqApx8q4G7KZt/xjgOza7cWwGwbrmjBCMQ6PFdDqvU3bKLwk0ThxErznWHR0dJPfmR3fZt4nfbd7+9bGDwGYM6o/hvbsyCwPL0j0tiyjEK95fdKNeZ7rokwxAWXCPWnyY4Pf1UzF18bMlOgQ2YIqH49RnR40HA/zyPFjVQh+GhS7fIfas4bpCazsK1pkDoFAqnflWvqGb/faOk5k7ksjWOeYVpu///77Jp8N6N6OaZ3iMT9I1siYVuG4onNbxEYZz9XBHE07ZsYNid7yjmfZmt5IC57rolIWCTGtwuH1+YTPTxnWA+lPmn766Se8+uqr+Oqrr1BZWYnLL78cH3/8Ma677joADVnY33rrLSxYsADFxcUYOnQo5s6di549yR2wFV794iDCIlo32q2DfW1oubdfF6q/RNT8exR4xyyR2bw1YsQIw2es7CsaZPf9IdXnuKX7MOWBvri8/1BgWx63cmmQvS+NYJljem2O6HFtk8CQcdEtcc81cZi/M4d4neI1P/TmoEJxVS3+vGgvYlqHN57SiJ6rZscNid5axg+Q0hzFc130L8toXBVX1WL0R3uEzk8tvb58s7WJrKU+aTp37hyGDh2K8PBwfPXVV8jMzMT06dPRrl27xmemTp2K999/H/PmzcOePXsQGRmJ2267DdXV7ANasVsDCPC1UWgfGU5Uzq29YqnrDvbvUdDz72FBZvPWokWLiJ6zqq9IcYLvD6k+i6tqMXbJPny+7FOu5ZLihL40gnaO6bX5qSX7MO7t91Q/m78zB0/eGN9kHsRFt8RfboxvclrAc35ozcFgSv4XLyi6deDayXuu8hg3JHorP7hZWnMUz3VRKYv0xEnU/NTT64vL93Otywip4zS99tprSE5Oxnfffaf6uc/nQ5cuXfDSSy/h5ZdfBgCUlJSgc+fOWLx4MUaOHElUjxLnoevzKxqDKvqHoAcQcO10QPd2uGnads3w9UDDgmUmfL3o692hFIJfhqvwTkhhARjr3R8PgM5REQA8yC+1bpw4pS+NoJljAJhSNPmX8+34m5F+4lyTeWDF/Kj3+pCaXYhxS/dpBq9UxtP0B/uhoLyGuyy8xk2orI089e4fE7CgvAazt2ejREfPPPvHSK++mkqcnPmgm0YFANauXYvrrrsOf/jDH9CpUydce+21WLBgQePnOTk5yMvLw/Dhwxt/Fx0djeuvvx4pKSma5dbU1KC0tDTgXzD+/gaKr81dV3cBAHx1KBcjB3YDoB6+3gP242bFZrv+wBkAwF1Xd2n07+Fpz5U5zQRtioJg/fBIG0CLjD5iavjr3QgfgB82/RujBmmPdYD/OLGjL83MLaOUR4Bx35Fc7/ZPL+SP0h/pJ85hyGUdcG+/iwPWDCv+oGgW5kFYmEc32rcPQF5pDcI8ngAZecFr3JDo7Yoz30i9YQJ+WRd59LVS1v39L0Gfi2M0N0wAeT8Hz5vzdV7VeUSiVyuRetN07NixRv+kr7/+GmPHjsWzzz6Lf//73wCAvLwGX4vOnTsHvNe5c+fGz9SYPHkyoqOjG/917dpgE60tzkPJns/hq6ttXKBmv5eIM2fO4IV/TEe/Zz7AfRPmYMzfP0Bi0hacP7ABbcLONz5bvDsJHcPP445m+9HFexZr167Fhg0bsG/fPnz44Yc4e/Zs44YgISEBlZWVmD59Oo4cOYIVK1Zg8kcrcM1fZ+HuZxMwbv5m3P7Y8xiWuA2PPPMqNuw/jfjb/w9/+OdaPPHGe7j/rYXo+5f38Nq0ucjKysK0adNQXV0dUH5eXh4WLFiAtLQ0bNq0CatXr8ahQ4cwa9YslJSU4D9rFmLuQ/1Rl/45vNXlKE1fh/Nnj6PFT+l4rNs5XFRzBvPnz0d+fn5AuVVVVZg+fTqysrKwfPlybNu2DcnJyfjkk09w8uRJvPPOO/B6vUhISIDX68U777yDkydP4pNPPkFycjK2bduG5cuXIysrC9OnT0dVVVVA+Y8++ijmz5+P9PR0bNy4EWvWrMHBgwcxe/ZsFBcXBzxbUlKCWbNmYd7q7ej18D9w34Q5eGrGCtw17m0MeuNzPPLMq43PVldXY9q0acjKykJSUhJ27NiBXbt24dNPP8WJEycwefJk1NfXB5R/6tQpLF68GLt378bWrVuxYsUKHDlyBNOnT0dlZWXjs7PfS0R9ZQnKMr5CTd5RVGanoTJrD87/nIOyfetRX1WG4t1J+LmsQUelpaV4//33kZmZiVWrVuHrr79GWloaFi5ciDNnzgTIUFNTg6lTpyI7OxvLli3Djh078N1332HJkiU4fvw4pkyZgrq6uoB3Tp8+jY8//hipqanYvHkzVq5ciR9++AEzZszAsB5tcWPFTsS0Ckfx7qQGuf+7Eefzj6Hy6F5UHt2D8/nHUPbfjWhz9e+wdvGsX8ZJTSVK077E+YKTCD+1F/93aSnaVZzEokWLmshdW1uLxMREHDt2DJ999hl27tyJnTt34rPPPsOxY8eQmJiI2tragHfOnDmDpZ8uRs2ZI6jK2YeKI8k4X3ASpWlfwltTGTDXjp7Kxdy5c5GRkYF169Zh/fr1yMjIwLx581BQUBBQbnl5OWbMmIEffvgBK1euxObNm5GamoqPP/4Yn25JR4/bHseoBal45NnXMPLDZMTfMQb//novlixZgu+++w47duzAsmXLkJ2djalTp6KmpgYJCQnYdCgXPW57HH94bwMenzAVv//HJ+jzRCImzlyIzMxM/LhtJf55X0/UpX/eKHd9VRmQ+TVeGdgS54+lYcOGDUjZm4ayjK9QX1kS0EZvbTVK965CbeFpNI+ORdXxDFSfPozyg1tQV3o24Nnc4gpMnjwZJ06cwKeffop/frIGff/yHu55IRF//WAD7vi/8bghYVPAnDBaI/z7sLi4GLNnz8bBgwexZs0abNy4Eenp6Y1rxOz3Ev3krmmQu+gnVBzeiaoT+1F9OhPlh7bi+x+zTa8R+fn5TdaIvfv+i9L0dfBWlwf2YU1F49pW+eNubNr0FdLS0rBgwQLk5eUFlKusEZdFlOOPHU6iVeEPqD79PcoPbUNdyc+o/+8qzB51DS7t2Jp6jUhISMDZs2fx4YcfYt++fdiwYQPWrl2LAwcOYM6cOSgqKgp41s41ory8PODZgoICzJs3DxkZGdiwYX3AGlFfVRrU3w1rRHrGAXzxxRf45ptvsGfPnoA1Qpk3I+ftwqPPv4H/N20NLvn9K7j/zY/wl2lLcPfzk3Hdq0vw+At/w5misoDy68oKUX7gm1/WiKzAjBKikdo816JFC1x33XXYvXt34++effZZpKWlISUlBbt378bQoUNx5swZxMX9Yqd98MEH4fF4sHz5ctVya2pqUFNT0/hzaWkpunbtGmCeU1g2ZjBKqs5rpgrwoSFdSo+Okab+ktNLR6ClIF7pQmQwb/mTmJiIV199lfh5GdKpqKWDUUMtHYxdJB8twOiP9ug+U5L6OaIH/z/Me6h/Y0gI0ePEyr40M3ZYUh5p9R1JmxVdaOHfH3bMCbvngIj6tfRGu0aFEmb7mTSljjJWnx/eEzO2ZGk+562pxCkLzXNS356Li4trEnX1qquuwhdffAEAiI1tcLTOz88P2DTl5+ejX79+muVGREQgIiJCt27FLqv4L+nF7EhKO2Xaf0kvLogWvOLkyJBmwp8//OEPxM/KEm9KLR1MMO0jw5FXWo2U7ELuvhxqC7vRF/XgSzsgLrql7tF36yuHBfShmXFCujk36kut1Dos8rCOHd4pj0jGT+srh6n+Prg/7JoTIvRG8wediPqD9aaYlGJ6/5r7PJaVYB0oYS5Y+pkmNUtjTKy9JxEb1VLXr9JKpN40DR06FEeOHAn43Y8//oju3bsDAOLj4xEbG4utW7c2bpJKS0uxZ88ejB07lrlef3+D9BPnhKfrMJOyJRRD2KekpODSSy8lelaWdCok16+LKmrxwvIMAPyuzmtdw73nmjis3Z+re+1akfmp/90UVaPmp8MIj4k13Yc018CtCidhZuzwHnfNwjy455o4fLgzR/OZmp8Oo0VMrGF/2DUneOuNNnSA6HHjL0/599vRpvfNjgqBwYLe+qIW5sKon2m/6xQ/uBeGX4GZW35Urc/1afLjhRdeQGpqKt59910cPXoUS5cuxfz58zFu3DgAgMfjwfPPP4+EhASsXbsWBw8exMMPP4wuXbrgvvvuY67X/2qmFfGMeMT7kDFmCCuKjxkJMsWbIr1+DfC5mqt1DTe3pBof7swhunY9ok8cnhjaQ7OO5lEXNf4/ax+yXAO3IpyEmbHDe9xtOpSL+Tobpr/cGI9XHxhK1B92zgleemMNHSBq3ATLo8wLJ4XAoEVPB1phLoz6mXXM9ejYWlOv7/3xGqYyWZH6pGngwIFYvXo1JkyYgH/84x+Ij4/HzJkzMXr06MZnXnnlFVRUVODJJ59EcXExhg0bhk2bNqFlS/oYGokP9EWPuIsCjlytiGfEI96HrDFDRCNbvCn/dDB5JVWYtOEwiiqa5qkyayZhyW6vVefwXrFYmHzc8H2WPjRjKvLvSxF+VGbGDs9xR6LLtftz8e6Q9njx4RsN+6NjG33XA9rnaDGrN7PmRd7jRhYXACshafPa/bmaYS60YF2HO7VtiSGXdVDVa0V5GVOZrEi9aQKAu+66C3fddZfm5x6PB//4xz/wj3/8w3Rdd17dpYkjmRX+FQO6t0P7yBaqX65G8PLvMIKHszhpGadOnSIu0yr/FxKC29cpqqWuTs2YSXhmt9frw7rSs6b60KypSKS/nZmxw3PcpR4rNNRlbkk1vt13Cjf/5ibj/iDdSQu0a5jRGw/zIs9xoyZPXelZKnmcBqkOlDAXpJD47vkTPI9k8L+VftNkN1bZyUk2TCL9O/Tgkc6CpowhQ4YQyyZLOhW19sW0Ioscz3JkzTO7vV4ftrz4KgDsfSiT+TQYM2OH17jbdCgXr31xkEjeuCuuJnquoKLG+CEAW3/IlyJBbjCyjRm1eiL+Ny+MnnMqonRA4vupYHe8QC2k9mmSBavs5Hr8hcF+zAMeaQloy1i5ciWVjHanU9Fqn16gP39Yjqx5Z7fX6sOw46mm+lA282kwZsaO2XGnjBvScbJ/59dEz5H25aLk41L64sg2ZtTqqfxhF9FzTkWkDjTXmqB9kV3psIyQOk6TVShpVIziPPAOS0+aNkE5oqS1H5uFR1oCljJqa2sRHk52ShNcl9Xxpmj0GAxJ/xnVS3rMTVpncB9ee0lbtIxoQSUbjZxm+oAnZsYOy7ss83/7i78m0gVp2bL0fTCyjRk1eXz1dfA0a26LPFZghQ7UQhmwfL+Rfn/zwj1pooBnWHoanxS9NAki4ZGWgKWMxMREQ9nUUlfw1A8prL5FrEfP/ml2tFL5mKkzuA//OW0qsWxa5WmlbZHp+N3M2GF5l3bcvHV3LyJdKF9Et/eJNXxWltQ+wTQL82Dinb10Y/JYOWbU0qqU7PncFnl4ptLSw4o0W8HzpkXzMMvXbxZcnyabsMOPRVR9es+xlPHGG2/oPsvDx4oXpO2LaRUeYIaJZZBX1W/qf1njiyt/KVsrThNLnUa6ICW6dXiAjECD7JN/31e643crIB43rcMx5X99NKIP/bzgKYtVbDqUi0kbMlU/YxnDPFBMSkr/xtww0nJ5rF73gtusYJcOZMHdNNmEHX4sourTe46ljISEBM0va60Q/Ip/lNU2cNL2zflTf4SFeZhNh1rtLqms1Uzl88qIq0ybK/V0YUZuADhXSebLE4oQj5tR/RudtVnmBU9ZrMCoHRPvvMq2L2v/UAaz30vE0y++allEcLvWPdFhP5yIu2niBK1fA83VSyuvzfvD41o1SxmPP/544//792vHyAi8vdaaeCm8U34MNnHcTBIzRS2VD4/ruf66oMUo/lAoxrchhWbcKGjpgiVml38dVq8rWpCMl0kbDuO2PnEB48VKX0ZlTnX/2/Po0sWaq+92x4mS4Zq/TLg+TRzYdCgXwxK3YdSCVDyXlIFRC1IxLHGb7s0UPZuxGnb4ffCwa7OUsWnTpob/BvXr6IV7kFdqzseKBBp9WmH75+FbxoqiCxbslFt2zMyLYFj86mTyJ1NgGS8say8PzMwLWtx5JBfMmyav14sff/wRu3btws6dOwP+XUiYuZKv2IyjW+vfFHvyxnhbj6TNXuenLaN3795U4RiCMeOjIWPKDzvj1vTu3Zv5Xdni7cgGy7xQg6X/ZLzOTTteeIRDYcXMvKDFnUdywWSeS01NxZ/+9CecOHECwRELPB4P6uvruQgnOzyOTW/tFYu312YC0PbvWLs/F6+MuMq2vwh52LVpyig6V4x/bCtnDljM6qMha8oPO9NilJSUML8rW7wdGaEZN1q6IO2/iXdehY5tI6T1S6EZL3abrMzMC1rceSQXTJump556Ctdddx02bNiAuLg4eDxyTT6rMBvuv97rw+LkHF2TEwjKsMKer2fXJpWB1Db+3+xc5JZcZPhcMGZ9NHim/OAVg6SxYp7PUVBWxp7XSaYUNzJDOi+0dEHaz48OjZduo+QPzXjhkWrFDGbmBS2D4tsjNqql5vfEhTCP7IjBpwXTpikrKwuff/45Lr/8ct7yOAozx6a014NJy7D66r0IGaJiuwOnKqne4eGjwesYXK1PwjyAf0gVmj4iTYtB+hwNV13VNF0EKbKkuAkVtHQRKv1M0w67TVZm5gUtmzPzUF2nbr1xkn5ZkeF7zh8mn6brr78eR48e5S2L42A9NmXx1yEtwwp7vmgZjv53N/U7PHw0eByDa/VJcAw6mj6y83j+m2++MfW+3SluQgk9XYRKP5O2w26Tldl5QUpjqh2N8BwxrcMdpV9aZPieC4Ypjcrq1avxxhtvYPz48ejbt2+TlBdXX02WWFIWWMOws4Sap027wVKGFWH9RcpQXFKK2z9I0+3XzlERmP5gPxSU13A7rjWbOoCHbkXIZYaysjK0bdvWdDkyHa87FRJdhEo/G7XD7lQrvOaFHiTrSWxUBJJf+60jdWwE6XfMxrHXoX27GMvSqDCZ5x544AEAgXFDPB4PfD7fBeUIznIsTnM9mLUMxZ6fml3IlMWcZOHl6VMQXN/mpR/grfv/T7df376nN4ZezjdDu1kzB+3Vb9I+stP88q9//YtLVHA7Yr2EygZCgUQXoRJTJ9g/MDW7ECnHCgA0/H5gj/YYObAbZmz5scm7enOC15gI1gVr/kG9d0jWk7zSGqY11uxcUMrLK6lCUcV5tG8TgdgovnOM9Dsm/fg5LvWRwrRpysnJ4S2HY6ENNU9jYzdbxril+zDlAbo0FaT2Y5H+P3HRN2AQYEsIfzOpA1j9J0jesyulAa80KlYjmx8ED5yqCzNsOpSL11YdDDBPzd5+FB4PoGUj0ZoTPMeEvy5YyiV5R+wayz4X9Pxxec4x0vafLbc21AKTeS7U4JElmXQnn5JdiFELUg3Lm3jnVZq3XUjLABr+6iK1eWuF6lck8C+HVIZlYwZr/hWkmRpkdxJibhiJuQ/1ty2EP8tfZjR68Uevj3jIZQazaVTsgGYcOwkn6sIMmw7l4qkl+6jeeWF4Tzx9S88mc4L3mFB0wVIu6Tsi11jWdpOk66H5ztGDtP0fjeyNW6+Nt8w8xxzcMjs7G8888wyGDx+O4cOH49lnn0V2djZP2RwFaaZz5Vqt1tecBw27db3rwQ1XUMlj8vx9XaZhNmyjuCfB5ZC2Q+sarF59ba69o7E+ALZkvmbJXG/UJ8EY9REvucwwduxYoeXzhnYcOwmn6cIM9V4f3l77PdU7HjSkE1Iri/eYGDt2LFO5NO+IXGNZ2k2TrofHHCNt/4Ae7UzVQwvTpunrr79Gr169sHfvXlx99dW4+uqrsWfPHvTu3RubN2/mLWNIwSs1yahB3YjqIw2xT2o/nrH5R6RkFzbK6S+3gln/n8ofdplODVDv9SEluxBfZvyElOxC3Qms9yxNObSpcXwARg7sStokW1ixYoXdIlDBK+UEjd6twmm6MMPenCLkldKF0NDSrYg0JCtWrGAql2ad3ZtThIl3illjteTTg9Rnk1daFytSVLHA5NP02muv4YUXXsCUKVOa/P7VV1/FrbfeykW4UIWHf0qPjpFUdRrZh0ntx7O3H8Xs7Ucbbdci/H8iulxJLZc/NDZ8vWcBUPsCaOk2OE6TwowtWUhKOyWtr82QIUPsFoEKHn4gsvpDOU0XZjATXyn4XRExnYYMGYITDOWyrLNP3hiPtftzhflYiop5xSNGFsl3ZWlpqel6aGDaNB0+fFj1r57HH38cM2fONCvTBYHZtBu08UeMnqctT4mTMfeh/tj16i3U7dCrr67sLFp0vpRJLi2bu7+8ykKj96yWL4VaOcGo6XZA93aYuyNb9bYPSZl2cerUKfTr189uMYgxG7+HZvxYjdN0YQYz8ZWC3xUR0+nUqVPo1IvslNi/XJZ1dv7OHMz507VoFxnBbY0V+Rzr81qITFHFAtOm6aKLLkJGRgZ69uwZ8PuMjAx06tSJi2BOh8Rh18z1YMXea3RcqsSyGNC9HVKyCzXlMUphEExwfifadujX5yFKDaCWqoQkH9UtV3ZGWk4RXvvioK69Xw3SvFbBuq33+pCUdtJUmaJRG7NmUyRZ7bhuJnWL3fnMjLiQ0lUpfps0Jjot3YpI5+PxeIjWzNioiIByWdfZSRsOU8ec4t1u2u8cnmldZAqlwbRpGjNmDJ588kkcO3YMN9xwAwAgOTkZiYmJePHFF7kK6ESsON73j91jNPnuuSYON03briuPXiwgLczkd9Krr3nbhvhLevZqtT5uHxmOogrtxMeKvIMnb0VRxXkqedXKoWm33bmyjNAasw/1ZE8CbIeZy0xMK9l1dMkll1hep100C/Pg7Xt6E9+e09OtiDhnl1xyCdGaWV3nxebMPFvWWd7tpvnOCeW0LkyO4BMnTsSbb76JWbNm4aabbsJNN92E2bNn4+23376grsSqYWXYd8XeGxetfgyq2MPn78whkkcrhYERrLZrrfpansvWNYNo9bHehinwOfYNkz807bY7V5YeemP2zQVrmMasnekPWFOKyKwjAEhNpQ9n4WRG9InDvIf6I6Z1eJPPgg/djHTLO82Mogul3GgVGQGgpLLW1nWWd7tJvnNkdDPgCXWcprq6OixduhS33XYbOnfu3JjtWXRIeZHwiNME2JfeRCs664Du7ZqcMJHIo5SXfPQsZm83DiNBE2dIT37FhHNpWy86d7pI81maVCUioWk3j5grIjDqT29lCS6O60w1ZmVI86PIQWMalFVHCgUFBejYkW8UfCegFRE8/cQ5arMvL3Oxvy7qvT4MnbINeaXyrrNOjAhOCq/vb1KozXPNmzfHU089hcOHDwNw9maJN3Yd72vZe1OyC5nkUcobFN8eX+z7iasvAIn8ekH8aFOViICl3SL8Knhg1J+lGV8hrPVIIabIxck56Ng2gquvk5kvB1l1pDBv3jxMeP1v0jjEkvQ1jy/rZmEeDO3ZsUlKKJY1lJdvzLx58xrXqIbwCHKvs7x9gljLC4XURkw+TYMGDcJ///tfdO/enbc8jka2432z8tiV80zPxGtF3/m3lVe77cwfp4dRf8bcMJLoOZoyFSZtONz4/zx8ncz6UMmqI4Xr7nuiyQmeXaEQSPpa1tANPPBfo5y6zlpNqIwHJp+mv/71r3jppZcwe/ZspKSk4MCBAwH/LlREXd1khYc8vG3iJCQkJGh+RtqmNhGBfw+0j1T3OVAjNrol5j3UH/M4t9uOvjTCqD+LdycRPUdTphpmfZ14+VDJqCOgoX2j/vqKLT5iarIY9bWdPm1W4L9GOXWdtZJQGg9MuefCwprutTweD3w+HzweD+rr67kIZxW8fZqMjllF+3KIkMfKY9Xy8nK0adNGU46hU7YaXkWOjYrA9Af7oaC8pjEcwU3Ttute9Y1pFY45o/tj8KW/pCcR0W6ZjqiNxojvfBW6XNSOyaeJ9Fq1Auv8EOFDJaOOfjp7DmEtWjX53Mp1haSvO0dFAPBQ+/g4Cf81yqnrrFWI9nG02qeJ6aQpJyenyb9jx441/vdCRbaw70byKGk81h84g+SsAiQfLdBMG2FlzrMFCxZofkaaQiavtAZhHk+jvC2ah+n2hQfAlAf6YujlHQPaJqLdVuePM5JFr1/K9n/NbIpUK1MP1vQLItJkyKSj1GMNvonl+79W/ZxX2goj6r0+LE5uehM3WJa80hpiHx87MZMqx3+N4rnuyzTueCFiftoJk0+T68ukDY8UKVbIo1yRnbElS/U9O23Nt99+u+7npClkgn0IZNONLOj1y+vP/dmUKTK4TBJEpWuwK1SAGTYdysVrXxwEALS6dIDusyLbp+aPYhY79WHWvyZ4jXLXFm1CbX4ybZo++eQT3c8ffvhhJmFCBdnCvgfLc7ygEjO3/KhrOrEzbcTBgwdx5ZVXan5uxodANt3Igla/rPric25lFpTVBDh/ayEqXYNVvoS8CE7pcv7sCYR30E7dIap9WqllzGKXPnikylFbo9y1RZ1Qm59Mm6bnnnsu4Ofa2lpUVlaiRYsWaN269QW/aQLormRaYcdW5FHsy0YLoOi0EXptjomJ0X2X9Wp4cJ13Xd3lglvQ9Ppdbcwa6cII/zLrvT58tCuH+9Vq2UMFsKCW0iUsQv2ENbh9PNcTvdQyWrIoPk35pfLowz+u0KQNh02nytGaF7RX8UPRhykY3vMzuM+u7MC0jWGGqbZz5841+V1WVhbGjh2L8ePHmxbqQsLqa5g0cY5ExZUyarNR7C+WK7qhct3VDCx9wDMOm6ir1aF4ZVttnqo5gSso7eM9zmnWC6V3376nNwBIow8a0yLpmsdjXlwoaxLP+anWZxdFWHvxjMkRXI2ePXtiypQpTU6hXLSx4xomi92Yp62ZpM1K4FQ9aK7ohtJ1V1ZY+4BEFzSIulodale21eZcbeGpJr+LaR3e2D4R45xm7vv3tSz60OoTI4zabXZeXGhrEo/xoNVnP1MkdeYB13Ot5s2b48yZMzyLDFnsyqjOYjfmZWsmbXPS6OFE5ZH4EMieud4KzPTBrbfeyl0eUb4foeRTojbnWva4tsnv5ozqj6E9Owob56Rzf+KdV+HRofEBZdutD1rToj9G7TYzLy7UNcnMeDDqMyth2jStXbs24Gefz4fc3FzMnj0bQ4cO5SJYqGNXyhUj+3IwbVs2Q25xFVKyC00veKRtfmfmXMx/712iMo18CGTOXG+VP4OZPli8eLGQJNxm0zpo9R3vdBFm4J3SpfzQlsYI7YofyOD/tVXUOCf1RwneMCnYmW6DJeUSqX+YmXkh85okGtbxIEP6LAWmTdN9990X8LPH48FFF12EW265BdOnT+chV8hj1zVMf/syCWXV9Xhx5X4A5u3tpG258+FxTOWbqdPq665W+jOY6QMRGyazOMEXRERKF/8NExDoByJqnNvhL8ZLv7RtDW6Pnhxm5oWsa5LMyNQXTD5NXq834F99fT3y8vKwdOlSxMXJsWjJjp3XMEf0icOTN8ZTv5dr0t5O2pYNn8xhKt9MnVZed7Xan8FMH+iltLEDJ/iCiErpoqS0UfMDETnOrfRP4qlf2rb6t8dIjkeeeZWqbBa5nHIF3wpk6gtTPk3nz59HTk4OLrvsMjRvbu21P6dj5zXpeq8Pa/ezf7mw2ttJ2zzrpb8zy8Zap1XXn+3wZzDTB6+99hoXGXjgBF8Q3jL6+4Hk/r8+iGvXRtVUJXqcW+GfxLvvSFwR2keGY+JdvREb9Ut7SOQ40vm3qPf6mNov25rkBGjdSkTCdNJUWVmJxx9/HK1bt0bv3r1x8uRJAMAzzzyDKVOmcBUwVLEz5YoZ+7CZkPekbZ7xHj8TL00qGf9UCmZSLOhhR0oBM2Ptn//8Jzc5zOKEdAwiU7r8uGVZoz9I8Ni0Yj0xm+LDaE7x7jujPvEAePf+vrj/2sD2kMhxZMtSLE7O0WyLXltlS7dFgqj1kBSSPrMKpuOhCRMm4MCBA9ixYwdGjBjR+Pvhw4fj7bffluqvU5mxK/Q+D/swaxkkbb6yzUjT8pHUqZZKJi66Je65Jg5r9+cK8Zmxy5+BdayNHMlXF2Zwgi+ISBlHjhxp6O8jayoPEj8lEX3H0ick5UdedWNAdHv/tpC0VWZdBSOLD6HiVrLguxz4/PZsHot3TUybpjVr1mD58uUYPHgwPH4S9+7dG9nZ2dyEuxCw41ouD/uwmTKM2rxr1y706NHDtIx6dWqlksktqcaHO3OavM8rrYzdvmy0Y02ELlhxgi+ISBk/WLYeK0viDdN/yBZ2gTRtiai+o+0TkvKrT2eiTXTnxp+Vtjx5Yzzm78whStEio66C4ZFyhqcsan1r8aEX26bp7Nmz6NSpU5PfV1RUBGyiXMiuzjYL82BQfPvG5/bmFBFNHtZruYPi2yM2qqVuJnIteNnb9a6ekiaEpm0/bSoZf3j5zPDyZ7AqXIFMybmd4AsiSsZ6rw8bcurgU3lNbWzKclWdxk/JTN8ZzQeaPiHxn2kedVGTtgBoOAVReV5r/ZBJV8HI5ENoJuYWb5g2Tddddx02bNiAZ555BgAaN0offfQRhgwZwk86h0N6rMly/GnmyHRzZh6q69hDz4u2t9fXG8tmpv2sPl084qfwuMLN2naW90h0YRVOSJeiyPiURkgPH9hk3JtThMLyKrTU2GvJGtuHNiYRi355m4/0xtkvgntV39U79ZBVR1rIFE9KpjhNTI7g7777Ll5//XWMHTsWdXV1+Ne//oXf/e53+Pjjj/HOO+/wltGRkF6dZblia+ZarvJucWWt6ueRLZoh5n++PsHEWZQCITdX/2af2WvJZn1ezL5v5go3a9tZ3zPShdXIkp7Dan4uq0Z9edOcn2rPyQStnxKtfkWFoNCSQ4FEF1rIpiMtZPIhlKnPmE6ahg0bhoyMDEyZMgV9+/bFN998g/79+yMlJQV9+/blLaPjID3WvOXKztTHn2aOTEmOONu2bI6dr9yC9BPnkFdShaKK82jfJiLgSq5oBg0apPkZjyPjjpERpuTj4TPD4s/A2nYzfaanC7uQ2RdE6WstzKQzaRF3BdFzMsHip0SqX9Hmo2A5CspqGp2/SXShhWw60kImH0KZ+ow5uNJll12GBQsW8JQlZCA91vw05Tj18aeZI1OSI8680hqknzhn6/HxF198gVdeeUX1My5Hxozfrbx9Zmj9GVjbTvre4uScJukw9HRhhEi/Kx6+IGblU3tfZDqT5if3wtPuXmn9udRg9VMi0a8V5iN/Oeq9Pny0Kwd5JdWo/DEZ0df/vybPh3kAn0/dpCerjrSwyoeQZB7KFKeJatMUFhZm6Ojt8XhQV1dnSiinQ3qUeKKokro8M0emMh236vHcc89pfsajDQXl9FmxZfCZYW076XuTNhzGR7tyAnxB9HShhyzXlLUwK5/W+3f0iSWqnyWdyax3XsdzK76X1p9LDVE+XoD165m/r1P0gHsDPlOkH/PrhttzTtKRFlb4EJLOQxJZrILKp2n16tVYtWqV6r/x48cjIiLCjQwO8qPE7u1bU5dn5shUpuNWPaZNm6b5GY82sLRPBp8Z1rbTtDfYF0RPF1rInurErHx67y9MPk4kA8sYPLBxyQXpz6WFHeuZ4utUv//LgN8rOphwR6+Q0pFIH0LaeaglS6coc+4WtHh8Pp+p064jR47gtddew7p16zB69Gj84x//kOqaMgmlpaWIjo5GSUkJoqKiTJenXGk3Otb8dvzNuGnadsPndr16S4BPE0nZ/u/QyqX2rizwaANJGZ2jIjD9wX4oKK+RxmeGte1G75GWQyOjltnE7jFmVj6j9wEyE42Z9lsVboIHIseDneuZkQ6cpCMSeLfHzLgIluXKDs3Rvl0Mt+9vI5huzwHAmTNnMGbMGPTt2xd1dXXIyMjAv//9b8dtmNQwGzJeL+Q70LCY3tEnFuknzmHinXTh9M2E4HdK+H69JLE82kBSxtv39MbQyzsyp4xQQ+S4Umu7Ut/6A2cwcmA31ffU8PcFoU3Ya0WqEzP9aFY+Er9Ar+8XR2R/zM4xRRdm05lYCY0/XbA+jfRs53o2+d13dHXgJB2RoLTnrqu7AECTtFO0mJmHdvcttS2tpKQE7777LmbNmoV+/fph69at+PWvfy1CNlvg5YuhFSY/zNOwqC5MPo6FyccRF90ST94Y3yRth144fTMh+J0Qvv/xxx/X/ZxHG/RC8o/5dTz3fhA9roLbrlafEkpCK9xEMD+XVRvqQu0dns8FY7YfzcpH+v7jQ3vgq0N5XOcYrS5kgMafToEmlZFd65kTdWEWnn6KTvGvVYPKPDd16lQkJiYiNjYW7777Lu69917jlxyAYp77POUIXl6T1eSoV9nHsthwlaPEzZl5WKTi76CUPedP16JdZATV8aeZI1OZj48XLlyIJ554wvA5M23QSg8ANOiEp/+BVl08xpVa2/Xq8wH4f/0vxuf7fjKsY9mYwcjcsYZIFwop2YUYtSCVqGzaG008+tGsfDTv+0f55zHHSOeFTJD2Fwl6erZ6PXOiLszAew3juU7wdq8xguqk6bXXXkOrVq1w+eWX49///jf+/e9/qz63atUqLsJZzZSvfoAPzZr83kzMDyVFyosrMlQ/V8qetOEwte3dzLVrmcP3X3311cTpZ1jaQBKvild6AFGxZLTaTlLfrqMFiI1qifxS46vEzYuuJpYJEJtGxKhdb6/9Hm1bhuv6oZmVj+Z93nPs6qub6kLUZoFXuTyviuvNF6vXMzVdKIjewAWXP6B7O6SfOGcY08rMH9hvr+W7hjkhJZIWVJumhx9+OKRzy+WX1iAsQv1Gm5mYHzKFo3cC3+w7ime3lAq7rm6lPqzWPUl9eaU1eGH4FZi55UfDq8RFRXS+R6KuKZO2a/RHexp/x3p1WU8+O1O5BOtCVFgHnuUSpSShQJa1UmteiA61oVa+4vKhVZ9ZmWZvy9LNU8qiEyekRNKCyhF88eLF+Pjjjw3/hTIsNlYn22+tZtOhXPxr0yGh19Wt1IfVuictp0fH1kRXiSsqKqhlEHFNmaV/aK8uk8pnVyoXf12ICusgolyjlCQs2L1Wqs0L0aE2tMoP9sX2r49HeI0ZW7KI5KPViVNTIrlBlShhifnhlPhIdqOYYJp3uKTJZzyzandsQxbXg/Q5PazWPU19Qy7rYJiu4sorr2SSg3eqE5b+0RszZuWzI5WLogtRJl+RaUn0UpKwYPdaGTwvRKd0IXEpCK7v7bXfA/Awy2SUEigYFp3InBJJC3fT5EfnqAgU1PAPge9k+62VKCaY6uMZaNGxW5PP9dJ9UEFqI+AQr99q3dPWZ+QLsmXLFvTq1YtJFp5+Jqy+Mf5jpmPbiIBF2ax8VvvRKLoQZfIVbUrWSklCo08RayWLv0/wvGDpO5p6SUJdBNeXV6qf+cBInzR1xpnQCek8kuXykrtp8uO126/Ey2uyuNtYnWy/tRLleLdN3+G6z6ml+6ChoIIsjQrpc3pYrXve9T366KNc5DKLWd+Y4CvtsoTXoEHRhSiTr5WmZBZ9ipgvrP4+wfOCtu9o6xVpjjQbXgMQ//2l1183dIsUVq8azMEtQ5Fbe8UKs7E61X5rJcrxbmn6WsNnzfgJWG0ys1r3POt7//33ucpmBl6+MbKkc6FF0YWo8SvLvIiLbom/3BiPOMHzxYy/T/C8oOk7lnpFmiO1yiat84XhVwj9/jLqr82ZecLqVsN0GpVQIDjOg8hjQFmOGGXEqnQfdqVfsFr3oTrW/NvVMTICL63crxk+QQtROrYCUeNXtnkheh3mmd6FNnUWbb20ayMJRm0kqTM2KgLJr/1W2Bwi0VPHiHr85x/3yp9GJZQRGabd7hDwMqMc2RfvTqJO90GKshDf3idWSKoLPazSvX/6FAC46+ouzPXRplHxr581XYwR/v04tGdHvH2PdsoiLYzGjug2sOCfRoUlfYisaUm05oXI+ULqg/TyigwkHy1o0lfB84K079JPnGNKH2KUmosFH8jCa6jVqfw8alA30ylV9MYliZ7yDXy3eOOok6YpU6ZgwoQJeO655zBz5kwAQHV1NV566SUkJSWhpqYGt912Gz744AN07tyZuFyrI4q66LMyORPv7cwldkL818h+uLffxYbPscQ4cRq848QUFRWhfXtyB0/RcWpo6iVBbezY1QYjgnVBI6eoZ53Klxk/4bmkDOLnY1qHY8rv+za2X2teGPUdab1aaxrJGhbTKhzFVcapkh4f2gNv3t3b8DnSlEwsY4RHf3lrKnFq5oOWfX87ZtOUlpaGBx98EFFRUbj55psbN01jx47Fhg0bsHjxYkRHR+Ppp59GWFgYkpOTict2N01yMWfOHDw19q9YnJxDdC2ZJNS+XtoUAHhiaA8M7xXraBOWiHQtc+bMwbhx42yrnwZ/cw7plfbgsWN3G/RQ0wWJCYulTaFq2lVgTe8y7399pTcv9PqOR/oQo4jgXp8vIMgrSx16dR4vqMTMLT+aniMk4zK6VQvD/rJ60+QI81x5eTlGjx6NBQsWoF27do2/LykpwcKFC/Hee+/hlltuwYABA/Dxxx9j9+7dSE3lk+/IxXp+/etfo1mYB48ObXAG1VqqPSC76moU48QDYOOhPEd/MRjFiQEaYrLQHqGTJuMWVT8N/uYclrEjQxv0UNOFkQmLtU2h7kaghLCgbZXSV3rzQq/vjOolWdOCy2/RPCzg58GXduCybqrVedfVXZCUdtL0HCEdlwO6tzNsS+co8/H0aHDEpmncuHG48847MXx44FX09PR01NbWBvz+yiuvRLdu3ZCSkqJZXk1NDUpLSwP+yYy/zTc5qwDJRwuIfS1k9M0w4vjx4wD4+VjQxFBxKqLaqOjCrvpZYRk7srRBa86S6sIfWdokG6w+Qrkl1UjNLmTShVG9vPzGRNbBazyRlpN+4pxhW167nS0ALyvSb5qSkpKwb98+TJ48uclneXl5aNGiBWJiYgJ+37lzZ+TlaV9DnDx5MqKjoxv/de3aFQBw7NgxTJ06FTU1NY2OfgkJCThz5gwWLlyItLQ0fP3111i1ahUyMzPx/vvvo7S0NODZoqIizJkzBwcOHMDatWuxYcMG7Nu3Dx9++CHOnj0b8GxlZSWmT5+OI0eOYMWKFdi6dSt2796NxYsX49SpU0hISMCmQ7nocdvjGPlhMh597nX88b11uPf5yfjLPz/D/RPn48o/TcTCDcmYNm0aqqurA8pfumM/ev6/l/D7f3yCJ99diHvHv4f+LyzE2AkJKCkpCXi2uLgYs2fPxsGDB7FmzRps3LgR6enpmD9/PvLz8wOeraqqwvTp05GVlYXly5dj27ZtSE5OxieffIKTJ0/inXfegdfrRUJCArxeL9555x2cPHkSn3zyCZKTk7Ft2zYsX74cWVlZmD59OqqqqgLKLy0txfz585Geng7vyf/iz3H5iKo6g9L0dfBWl6N4dxJio1vixoqdGNK1NWbNmoVDhw5h9erV2LRpE9LS0rBgwQLk5eUhISEBP5dVo3h3Enx151Gy5wvUFv2EisxvUX3yAKpPf4/yQ9tQV/IzPpj5T9TX1wfIcurUKSxevBi7d+/G1q1bsWLFChw5cgTTp09HZWVlwLNnz57Fhx9+iH379mHDhg1Yu3YtDhw4gDlz5qCoqKhJG99//31kZmZi1apV+Prrr5GWloaFCxfizJkzAc/W1NRg6tSpyM7OxrJly7Bjxw589913WLJkCY4fP44pU6Yg91xDvwBA8e4k1JUWoPzAZtT89AOqcv6Lih92obbwFD6aOwvl5eUB5RcUFGDevHnIyMjA+vXrsW7dOmRkZGDu3LmoqKgIeLasrAwzZ85EZmYmvvjiC3zzzTfYs2cPln66GHVlhQEy+OrrUJL6OWqL81D+/XZUnzqE7Tt24LPPPsOxY8eQmJiI2traJnNt0aJF2LNnD7755ht88cUXyMzMxMyZM1FWVhbwbGFhIebOnYuMjAysW7cO69evR0ZGBubNm4eCggL8Z81CzH2oP+rSP4f3fBVK09agtvAUwk/uwZhLyxBTfgIff/wxTp8+HThOvPUoSV2JupL8RrmrTx5ARea3qD2Xi3mz3hO2RiTtPIQetz2OUQtS8cizr+GPH+zApXeNxUfrvmscg8FrhFJufX09Jk+ejBMnTuDTTz/Frl27sHX7tga5i35CyZ4v4Ks7H6Cj+vJzKMvYhOTUVGzatAmrV6/GoUOHMGvWLKnXiPz8/MY1YuPGjVizZg0OHjyI2bNno7i4OODZkpIS1TXiVMp6vDPiEtSlf/7LmDVYI0pSVuCvS9LwrwWfMK8RJ5LX4qX+zRGRm4HKrD04/3MOyvatR8fw87ixYidG9IkzvUa0LDiCcVfVotmxXagryUdJ6kr4vPWoS/8ccx/qj/+sWYjTp0/j448/RmpqKjZv3oyVK1fihx9+wIwZMzTXiNT/pKPy6F5UHt2D8/nHUPbfjaivKg0YU96aSnw0b3aTNWLRokWNcjfONZU1ovrUIZR/vx21xXmY9/50/PZXHXFjxU7ERrdsWNvKClF+4BtElubg/y4tRWWWsSmSJ1L7NJ06dQrXXXcdNm/e3JhV+je/+Q369euHmTNnYunSpXjsscdQUxPoPT9o0CDcfPPNSExMVC23pqYm4J3S0lJ07dpVOp8mIz8cQNuOLLNvhhH79u1D//79A35nxseChx+B7Ihqo5ourKyfB6Rjx+42GM3Zl/o3x9MP3kZVpt1tcgL1Xh9e/fwAPt93mvid83lHsejlB02toVb4jfGug9d4YilHqy1W+yRLHRE8PT0dP//8c8CiXV9fj507d2L27Nn4+uuvcf78eRQXFwecNuXn5yM2Nlaz3IiICERE8LWD8h6cpLmG1HIIic6DZBajvkpLS0P//v259amdaWyscqjl3UZF7k9Xbcafo7sbys1Sv1Hf8Oo70jQNdo8Tozn73tJNGPv/fkfVB24KJzJ2HT1L9fz5vCzTa6iZNDykc4N3qh9e42lQfHvERrVEXql+vCr/cqxOW6SF1Jum3/72tzh48GDA7x577DFceeWVePXVV9G1a1eEh4dj69ateOCBBwAAR44cwcmTJzFkyBDL5BRxRZcm709wDiHROaTMQNJXv//977n2qV1pbKy8us2zjf5y11d2xcYFqYZy09Zv1Dd2XHu3M90RyZyt6zaQes66KZyM2ZtTZJinLZhWV9wg9RoqCl7jaXNmHqrr6lU/k31cSu3T1LZtW/Tp0yfgX2RkJDp06IA+ffogOjoaTzzxBF588UVs374d6enpeOyxxzBkyBAMHjzYEhnNhOLXgyXXkPKOlTmkaCDtq5f/8U/ufWp1KhNR40IPHm0Mlrss4ytiuUnrN+qbyRszLe872jbwhmQulmV8xTRn3RRO+rD0qTIvZF1DRWJ2PClt8I/x5E9M63Cpx6XUJ00kzJgxA2FhYXjggQcCgltagUgzGEuuIeUdq3NIkUDaV7dc2Rk/dvkdfCp/dZvt0xF94nBrr1hL/AjsMo+aaaOa3DE3jKSS26h+kqvGC77LsdW0bNU48YdkLsbcMJJ5ztrRJqfA0qfKvOjYxrrr7jK5XbCOJxK3k4jmYbi1l7Z7jd04btO0Y8eOgJ9btmyJOXPmYM6cOZbLItIMZmQ79ifY/iujHwNpX32achyHv1rcuChpPcd6LG6FXdxu8yhrG9XkLt6dFLBxIpFbr34Ss7NeVAyrTMtW+0+QzNm69M8x6N07mOuQxSeEBT0fHrO+bzRrrULjvLDwGpXd60owLOOJZP7nldbYYvYkxXGbJpkQaQbTsx37o2b/ldGPgbQPThRVImrgfdzKswNZzaNGqMmjpgszcvNqs2x9ZxaSOTvr3TcuyJMhPR8eAKb9e0jXWn+UeVFQYV3eM6euK/6EQhuk9mmSHdFmMC3bsT9admTZ/BhI+6B7+9Yo/+9GbuXZgYzmURLU5FHThRm5ebVZtr7jgdGczd65xh7BbETPh+epJfvwFCf/HpK11h9lXlg5Do8XVBA9J/PccOra6I970mQCK8xgwbbjjpERgAcoKK8xPIqWyY+BtK/+PKQHZvX7NUqg/hefE65Iy2geJUFN7laXDWr8nIfcJKaQMA/g8zlX/2bQm7Px4XfZLZ6lkPi/qcHq3+Pf93klVZi04TDOVZxXrav1ZYOoU5GYod7rw7K9Jw2fs1ImFpy6NvrjnjSZwIqQ+Eo9Sm6hoT07YujlHXFvv4sxKL499uYU6aZIkSWHFGlftWgehju61Bg+Z0U7WFPQGKVo8EHO67Rqcp//OSfgZ9EpHjwAxvw6XvNzszI4Ia2Q1pzdv3+/I+TnBU3YlWAU/54Zm3+knrtDLuuA+/tfgnfv7wNAfRye/znH0jlMGhZh5MBu0q0r/lj1nSkS96TJJMqxbrBdPVZw3Aw7Y3WwMqJPHJ68Mb7hdpTfGubxNHxRKnL/9trLcWPnXpb3qT9m+1cZF6+tOtjkam1M63Du8vIieDyHtWoLgG/fk8yZa7u1465/J84Zf7JLgWGJ2xwrPy08/Fpmbz+K2duPMvWT3ji9525rXRxI+6JHx9aCJTGPXd+ZvJA6jYpV8AjDblXkZ8C5KVL00sJ48Ivcu3fvxg033GBpn5LISdu/TtUT8Mt43vndLtz462G2pHjgqX8n6wJokP+xKZ8h4pKrAn7vFPlZIE21QYKZflIbh3tSU3DDDTdwkY2EUEyHw2t+u2lUHIpyrKsMhPUHzlDHyCEZQDLF6vCXyUh2kvgcitw//vgjbrjhBluuSJvtX6UvFJ8ImfREg9L3R747J0wHRvrlpX8Z5wwNivy1535qsmkKlh8Ak/+jVr12+kOyhALQwoye1cahskZZRSj4AgVj9jvTLtxNE0dYj/9p3pMtVgep7DRy//a3vxUpsi5m+letL1jKkQk7dcEL2eYMLYr8Lbtfo/q5Iv/sbUeRlHZSs600JioZTJlGYRh8Kv+vB089Wz0vZAwjwwMZxhktriM4J1jD29O+J1OcCxrZaeT+97//zVVOGlj7V6sveNVnF3bqghcyzRkWFLnKD23VfW7Glh91xx/pVXwZUnUo6IVhmPdQf8yjCBOgwEPPdswL2cLImEWmcUaDe9LEAdbjf5b3ZIlzQSs7jdxvvPEGT1GpYOlfEtOj2frswk5d8EKWOcOKIpdWlHxSSM3LspkyjUKnKJ8lHz2L2duzDcvjoWe75oVMYWTMIOM4I8U9aeIAzfG/2fcU27bWMPJAPVYH76vKtLLTyJ2QkGBKNjOw9C/L1WgtPcmGnbrgBeucAewJURBc54Du7RAX3RIlu5NMl621FimwrmWi8Q/DEBxqBQCGXNYBL9z6K2Y9a6GlfzvnhSxhZIzQmzuyjjMS3JMmDrAe/7O8x2LbFmE3ppWdRu4JEyYwycQDlv6lPe53kg+CnbrgBas/iB3+Flp13nNNHHLP/UHXt4cGrTEruynTSCc8/X706gqFeSESIz3JPs70cE+aOMB6/M/6Ho1tW5TdmEV2UrmnTp3KJBMvaH0HaI/7neSDYLcueEGrUzv8LfTqnL8zB7/6ebuq/C8M70ldl9aYldmUSaITXn4/RnX930sTzTUmhCHRk8zjzAj3pIkDrNdBzVwjJbFti7Qbs8pOIvef/vQnKllEQOM7QHI1un1kOCbe1RuxUc7yQZBBF7wg1akd/hYkdZ7tNBCp429G+olzAfIDQFLaKaKr+UZX02W92k6jE7N+PyR17W/RB/Ven2PmsVWQ6unb8TdLOc5IcE+aOGAUGt4HYOTArlh/4EyAbddsSHkj27ZIu7EZ2Y3k3rlzJ7U8JND6pyhy3nV1FwBooj//54xSg7x7f1/cf63cPghqiNKFXZD4g9jhb0FS58nMdKSfONdEfqO0PQqka4qMaS5IdbI4OQdfZvyEvTlFGBTfnsnvh1QXZvQfqulwSPWUfuKclOOMBPekiRNaoeGj/5cyY8aWrMbf+dt2SVOLsCDabiwqHH58fDzTe3qIjqHl9NQAWojQhezY4W9BUlbzmM6az2mNP39Ix6KMY5m0rydtONz4/6z+Z2Z1YYQTYxORQjN37u13sXTjjAR308SR4GPh4wWVmLnlxybHj4ptd+5D/QEA83fmNHnG62v4/bXd2jEPHivsxiKuwNbV1TG/q4ZWCg1/Paj1Me17oXId2B/eunACdvhbEJXlrdd9Lnj8mYkILttYZulro/ltqi4DXWjBuhY5Bdq5I9s4I8HdNHHGPzT8sMRturbdt9d+D8BDlFqEZRBZ5Z/AO91JXl4et7KsjKFld9oJEeTl5UnRLitlsMOvh6TOtt4Kwzp5zkU70hhpwZJShdb/zD8FUvvIFjhXcd6ULtTKd2psIlJI9BQbFRHQdzKNMxLcTZMgSGy7eaU1umWYDfvv1ND7AwYM4FYWawoN2vdC9ci9om1XDEvcZmu7rO5bO+YNSZ2v/fl26eaqVej1jx6kayhpCiQzunB6Oh8SSPRUXefF5sw8x66LriO4IKz2d9DCiaH316xZw60sK2JoOTUdgBGbDuVi/D8X2touu/rWjnljVGdR5m7udToJpX8UP1Ea9OYzTQokM7pwcmwiGoz0VFJZ6+h10T1pEoTl/g46OM1u/Mwzz3ArS3QMrY6REXj58/0hd+SumBLaDri7yWdWtctuc4Yd80avzt9czm9eOJVbe8Xi7bWZAGqp3tOazyQpkNTChbDowsmxiWjR05OT10XAPWkSBknqhtioCMRG8Q37r4a/P0jHyAh4fT7N6/NG5VhxTfaf//wnt7JYU2iQvgcPHJsOQA/FlFCyd5Xq50q7UrMLhY0Jq6/+q41vO1JWaNXJc144lb05RcgrpTuJCfahCS7P6ISpqKIWsVEtdXVBsjaaSefjNIz0RDJ3ZQ3L4J40CYLER+Hte3oDgFDfCSNbPalviJV+JTyTYbL6p5C+V1Cu75em4LQjd0VeoySx45buQ3HVL39N8hwTVpoznOCTFgrJk83Coms9HxrWMeavC9Kx41QfUxbMzl2Z56N70iQQEr8Ikb4TJLZ6Et8Qq/1KeCfDZO1jkvdC9chdkbfYIEms/4YJ4DsmrOpbp/ikhULyZLOw6FrPh4Z1jCm6oB07TvQxZcHM3JV9Pnp8Pp8cZ142UlpaiujoaJSUlCAqKop7+STXpXlfqVZCHpA4NypXqHe9eouqXHrl6L3LSl5eHmJjY7mU5Q9rH+u9p/SP0fV0nv1jBUq7Tv+Ui2Zt2lG9y6vNVvStHeObFVHzwkkYjQkttPTIOsby8vJwUafOzGNHhjAeImHtV5b5KPr7Oxj3pMkCSPwiePtOkNjqFfTsy3aklFi3bh23svwJ7mMAjTbz5KwCJB8tULWf6+nGbNoJWe32Sruqju7RTc2hht6YoGmvFSk9WMe3HXojnReyjikekKaMCUZLj6xjbN26dcRjZ8bmH6nWFC2C9Xq+ziutnln71Y7vG1pcn6YQhcX2r/aOHddk+/Xrx60sLXj5egFgToUjs90eaGjXxEfvQFJOiwAZY1qFNzHLqRE8JljaKzqlB8v4tktvJPNC9jHFA5KUMVqo6ZtljPXr1w9nCMfO7O1HMXv7UVN6UNNrmKchc4SCbHpm6VcnhGVwN00hCovtX+0dO3x2CgsLuZWlhlYqA39o0hpsOpRLnQrHKekUfhXjwa5XbwkwJXh9Poz+aI/hu/5jwkx7RV79P15QQfSc0hY79WY0L5wypngQPCYKymoC8s5pobVO0Y6xwsJCdOp5KZXMrHrQ0mvwwZKMeqbtVyf4iLrmuRDF6HqrP3pXXe24JltVVcWtrGBI4rIAv9xs+fu6TN1jb5Lygsswij9EUq9VVFVVNTElDL60A9WY4NFeEVf/670+LNt70vA5pS12601vXtgtmx34j4lHh8abXqdoxlhVVRXVGguw6YF0vWIt3wpo+tUJYRncTVOIQmr7N/INMSrHp/MuKz179jT1vp5PBy9fL9Ly1Mqgecdu/xQ1XdD6K9jtp6DVhw2xZIxDRowc2A3NwjzE7VicnKOpLzP61JsXdvex3Vjh/+ZPz549mfyr/McIie5p1iv/8mn0bPca4w+pHoFf/FH3HrN2TLvmuRCGxPZP4huilPPaqoMorgz0ZYlhSGlgxPbt29GnTx+md418Onj5epF8pvUc6TubM/Pw4ooMW/1TtHRB469gp5+C3nioqfMSldGjY2sq+fzNRP76MutvpDcvnOALIhpW30IWFF2w+ldN2nAYH+3KMdQ9q75I35PRB85obQEQcMPOW1NpqXzupinECbYpd4yMADxAQXkNtW9ISWVT518lBgpPO/rDDz/M9B6JTwcvXy+Sz7SeI31nUfLxJr+z2m9BTxek/gp2+SkYjYfnh5OdaCpyscin1PXkjfGqfm80+tTThRN8QUTD4lvIir8u/OdB8tGzmL09m6gMEt2z6ovkPZl94LTWls2ZeYb+qKJxzXM2Y8XRqL9NeWjPjhh6eUfqq66i/SX8+2H83xOpyyKVcUD3dlx8vRRYbPAkvhBaarHab2HWrFm6n5P4K9jhp0AyHpbtPUmVxojWh0Wpywc0nH7oyEKiTz1dOMEXRCQsvoVmCNaFMg9euPVXiI0i2+iQ6F7RKymkeqZZ03l8R7GUoRYihtS/SyTupslGNh3KxbDEbRi1IBXPJWVg1IJUDEvcZnvE02BE+0sE98M3LYZS9wOpjOknznHx9VJg8aUgeUdvTbHSP4VH6g6r/U0AsvGQV1qDUYO6EcultINl0eahTz1d2NHHMmG1T5eWLjZn5qG6rp64HCO5/PVKWh6Jnkn7a/a2o6a/o3h9z9H6d4nC3TTZhOyh4v0R6S+h1g/Fu5Oo+4FGRq1UBv7QpDVgSY2g984TQ3sQt0U0vFJ3WJ0+grRvenRsLU1aCyOZjXRxoaToUMNqny41XShrWbDfJwl6co3oE0e8Jjw+tAeRnkn7YcaWH019R/H8npPFH8/1abIBo6NRDxqOIW/tFSvFX4ai/CW0+iGq/13U/UArI09fL7XySMrQemdvThEWqvgzabVFJE8//TS3skTGWwqGZjwMuawDkVzKeBWFkcwkurCyj2XCap+uYF3QhAZQw0iu4b1iidaEW3uRpdkx0w+kazPv7zlZ/PHcTZMN0BwlK7ZcO1Hs6kZ5hGj9JbT6ofz77YgacDdVP7DIqNjMecFSnto7ovoboM95tWTJEq4bJ959rgVtH5LIZcY84PEAWlk+9fTpr6+dq5dg6luvGH7BWNXHIqEdpyLnjBrB84J1bKjJpdZ23u0zKs8IkrWZx/ecf190jIxAbFRL5JeyycwLd9NkA067HqzY1ccu2QcPEDBgzfhLaLWvZbe+RM9ZIaMdiGoLy/Xim266iU54SRDRh2bmo96GSUuWYH2dP9sGuxO3SZUqQwQs49Tq+R88L1jGhppcem3n2T6j/iLdlPAOx+KPWl/EtA5vPKWya+Pk+jTZgBOvB4vwl9BqX925XKLnrJDRLni3hdW3IDub7Pq0jPDuQxHzUUsWNX3VncuV0ueRJ2Z8YKyc/8HzgmVsBMtl1HYAXNun118vUIbjoP3M6DmtvlDC3kQLiA9IinvSZANWHyXzgre/hFY/eJo1DEuWfgglnw5ebTHjW9CiRQtm+WWA53ggmbedoyIw/cF++Lm0GpM2HEZRxXnN8tpHhuPb8TejRfPAv1219OVp1lxKn0de8PCBsWr+B88LmrGh5jdJ2vZdr97CtX1a/QUASWmnTH1HsX7PkfRFy+Zh+Oz/rkdBeQ0iUYtbZxI1lwvupslC/O2zIwd2w8wtP1pylEzrH6AHT38JrSPisMh2qv1A2g41GXn2gehyeZdpxregc+fOzPXKAq8xS2ICevue3hh6eUekZBfqbpgAoKiiFuknzjWRTUtfYZHtAMjn88gLXr6eVvh0Bc8LmrGhBk2KnkeHxlvii2nWHMhqMiUNFxLm8eDefhejtLRUp3X8cTdNFqFlnwUQcEWVJK2J2XrtDpPvj1rI/PN5R9HjV30CZDTTDlF9IKJcEWWa8S1IT0/HgAEDmOoNRUjTx5jpc613z+cdRUTs5YbPORUn+XqqzQua1ELB0KToIUm/wgMz7fEvgza1jezjwN00WYBWuPqSylr4ALwwvCd6dIzkfpQsc5h8f4KPiJvffylGDLwywDmStR2i+kBEuaJkPV5QQfScmm/BvffeS11fqENiAjLjz6H1buue1xM951Sc5OupNS9YzYM0bbJy/TZr7mRJbSP7OHAdwQVDYp9NSjuFu67uQpzWhEe9PgCvrz6I84RJS0XjHzL/v5u/ILb1A9ppCESlfxFRrkhZl+09aficVuqFBQsWUNV3oWCUPoY1rUm91wev14eYVk0dXcv2f637rtORKRWMUdqPD+fP55r+iiZFj9lUSrQpTUhSJWnVw5LaRqZxoIZ70iQYu2IykcQNKaqoxeDJW/Hu/X2kOHFS8E9RYKb/RPW9iHJFyppXWmP43MiB3VQXQx5pVC5EWPw51Eyz/sTcMNJx4TNokCVsiJGJfNOhXHzV/AYsWpDa5HMATOZ1vbarwboeWOmuwbqmyTIOtHBPmgRjl32WtLyiivPSXWH2T1EgwjeE9TmR5dota4+OrVV/zyuNyoUIzRV4rSvW/hTvTnJk+Awa7A4bYnTtf/LGTIxdsg+Hv1rc5POnluzDUyZShpCkdwqGZj2wOnWXmTXN7nGgh3vSJBi77LO05cl0hfmll15q/H8RviGsz4ksV1ZZ/XXhQg+JTwiJGSOmVTgWffAubup1iRRzVCR2hQ0hMZEv+K7BPydq4P2qn6tBEyZCafvi5BxM2nDYUGbS+W1H6i6za4+s4WPckybB2GWfpbWR88oATmIvN3rmgw8+aPx/M/0nqu9FlCurrP66cGHDyCeExJReXFWL1Z99bPsXhlWw+tGYgUQPylJV/t8NVGXTrLHNwjx4dGg81/WAxlRG6/OkBY81zY5xYIS7aRKMYp8F0GTwiLTP+tdLilkT4aZDuRiWuA2jFqTiuaQMjFqQimGJ2wKOfUmeueeee1TbQdt/ovpeRLmyyuqvCxcxkM67XoNvFizJhQ3N+tfq8uuNHzJRB+/1gLTezZl5huszKXZ994nG3TRZgF32WaXe9pFkIefNmAhJ7OWkNvV9+/aptoOl/0T1vYhyZZQ1WBcu/CGddwUnjgiW5MKGZv07n8+WXoimDp7rAWm9i5KPc/V5ktk3iRWPz6eVSvLCobS0FNHR0SgpKUFUVJSwekRFpTbifJ0Xgydv1YxQrISz3/XqLUzy1Ht9GJa4TfP4V0khAHiQV6r9jCLDtzu245ZbblGth7X/LuSI4GbK3bZtm6ouXPihzB+jdBP/GAjcOvy3Vot3wWCkBwAI8zQkX648sR+tul9DXLaZNZbHekDaNi1LHI/vCFHffVZ9fyu4juAWYkV4fzVaNA/Du/f3aUz6yPsKJ2nYez38beoRERGqz9D2H+lEVXtOaRdLyhazsJZp1F6ScoPLaB7u7NxzToD0inXrkmMB7zlpw+4ESPQw5tfxmL8zB2HNAk/v/Z/nfU2exxpj1DYftDdMgPnQOHZ994nA3TRdIPAIia8Fz3AJP5dVoyQ7G0OHDjVVDmk8EtL0NjKlnlGDR/wVtTKaZ+/E7HaXSdvuUIFkfn7yyebGeeGUFD5Og0QP13Zrh6f/vhN1fu8pnwNN4zTxTo3Fil7b7ugTi4XJxw3LkCGFjd245jlYf7xnJyL+kkzJLsQov0BvZlg2ZjAuDq9At27dmMvQSkeitFKxpWs9p0bwuzJB2l6WMupLf0bzqE5StjsU0ZufJ0+eRLdu3bjoOxgRZToZo3Uy5/gJ5NW3Uf1c9tM6Nfn25hQRreHLxgyW7sTI6u9v1xE8RCC9JiriCifJ1dLObVvAqKowDzCgezt8+umnzLKQpiM5X+c1jI2j9u7ba79H8tECbukTzMIj/YpeGeWHthOV4cIHvfn56aefOiqFj5MxWieXfrYEg+Lbo1Pblvi57Jer+iTv0sDr+r8/avJZFRpHRHusxjXPhQB2H6uT+AL86frumLElS7ccrw9IP3EOEyZMYJaFNB7JpylNb4kYofhmjf5oT+Pv7DZf8Ei/oldG1JA/CEv140LHhAkTsMdBKXxCmWvvfrTJ5Rfea4GV67oVqUvs/p7ihXvS5HCsDo2vhdHV0h4dI4nK+bmsGu+++y6zHKQ29xNFlcx1+GN1PwfDI/2K3mclKSuo63IRw7vvvuuoFD6hyqZDuRj99GtC11w71nWR4QFk+Z7igXvS5GDsCI2vh17Y+5TsQqIyOrVtiddff51ZBtJ4JN3bq+dao8WOfvaHR/oVvc+ihzxIXZeLGF5//XXsyTlH9KwMKXxCEWXNjfKbFwq81gI713URqUtk+54yi3vS5GBojtV5QGKP1rLn09jMJ0+ezCwjaT1/HtKDOM2MEbz7mQYevgh6ZZSmrBSW6ocXoeAn4Y9WeyZPnuyoFD4ywWuMKGtuacpK1c9J1gIjWaxe14Ph7fdqd3t44540ORgrj9XN2qObhXlwzzVx+HBnjuYzis38z3/+M7OcpLb5Fs3DNJ9jxQ7zBQ9fBL0y2vS5magMuwgVPwkFvfb8+c9/FuJ7YoU/i53wHCPKHI/so5/SRmstIJEl1MylodYe96TJwVh1rM7DHr3pUC7m62yYnrwxvnHR2LFjhyl5SW3zWs/FtA5vjNVEg13mCx6+CFplRJz9Qdrr5qHkJwEYt+f9JWsAOCuFj93wHiPKHK8+eZDoORZZQs1cGmrtcU+aHIxyrG6UfsHMsToPe7ReGQpr9+filRFXoVmYB5dddhmzvAqktnmt54BfIoJ3jIzASyv3I79UXD+bhYcvgloZtWeicaOEX5ih5idB0p5NJ31I9PrQLMwjxPdERJl2ImKMKGvu8Rj1OaG1FtDIYsW6biWh1h530+RgrDhWZ72O7B9AraCsxvB6v38ZNTX6KVdIIQ3dr/Wc/+/evKsX/rq0afJamcwXvNIt+Jex7YR6vkK7CbVr8iTtOVtSEdAemVL4yIiIMaKsuY8e2EO15tLKEkrmUlHfU8p3zPHcs7xEJUJq89zkyZMxcOBAtG3bFp06dcJ9992HI0cCM31XV1dj3Lhx6NChA9q0aYMHHngA+fn5NklsPaKP1Vns0ZsO5WJY4jaMWpCK55IyMGnDYaoyzp61dhIYselQLiZtyFT9zOnmCyNk04VCqPlJkMjprSxxTHtkQNQYGdEnDo8NaE+15tLKEmrmUt7t8f+OefULfVMpb6Q+afr2228xbtw4DBw4EHV1dXj99dfxu9/9DpmZmYiMbIj788ILL2DDhg1YuXIloqOj8fTTT+P3v/89kpOTbZbeOkQeq9Pao2lSk2iV0b9/f4a3xWDUnol3XuW4BYwGmXThT6j5SZDI2aLzZY5pjwyIHCOP3/tbJFx2OfGayyJLqJlLebXHzHcMD6TeNG3atCng58WLF6NTp05IT0/HjTfeiJKSEixcuBBLly7FLbfcAgD4+OOPcdVVVyE1NRWDBw+2Q2xbEHWsTmOPJvFd0sL/SvPatWvx0ksvmRGbC0bt8QCYtOEwbusTZ+lCxju3lV55sugiGNpxydpfVuURM2oPAODkfzCg+/9xr5sF2fKrqckj0pdGmRekay6JfttHhmNA93YBvwslcylgvj1mvmN4IfWmKZiSkhIAQPv2DYM8PT0dtbW1GD58eOMzV155Jbp164aUlBTNTVNNTU2A30xpaalAqZ2NYo9+aklTfx6gwT6t2KNTsgupU5MojBzYrXHR/etf/8oqLldk9JvhfcXeqDxZdBEMqZ/E5sw85v6SJY1F4zO9R+CmadttD6cgW5gHPXlIw5zQQjsvSPRbVFErhX5lxmhNtgKpfZr88Xq9eP755zF06FD06dMHAJCXl4cWLVogJiYm4NnOnTsjLy9Ps6zJkycjOjq68V/Xrl0BAMeOHcPUqVNRU1ODhIQEAEBCQgLOnDmDhQsXIi0tDV9//TVWrVqFzMxMvP/++ygtLQ14tqioCHPmzMGBAwewdu1abNiwAfv27cOHH36Is2fPBjxbWVmJ6dOn48iRI1ixYgW2bt2K3bt3Y/HixTh16lTAs/X19Zg8eTJOnDiBTz/9FLt27cKOHTuQlJSErKwsTJs2DdXV1QHv5OXlYcGCBUhLS8OmTZuwevVqHDp0CLNmzUJJSUnAs8XFxZg9ezYOHjyINWvWYOPGjUhPT8f8+fNxruAsincnAQCKdyfBW1uD0r2rUFv0EyoO70TGnl1ITk7G8qVLUFf6M0p2L4fP50Xx7iT4fF6U7F6OutKfUX5oK6pPZ6LqxH5UHN6J2qKfULp3Fby1Ndi7ekGjLH//+98xf/58pKenY+PGjVizZg0OHjyI2bNno7i4OEDukpISzJo1C4cOHcLq1auxadMmpKWlYcGCBcjLywt4trq6GtOmTUNWVhaSkpKwY8cO7Nq1C59++ilOnDiByZMno76+vvGd2e8loq70LMoPbkH16cOoOp6BisPfobbw9P/krkbx7iT8XNbQ72fPnsWHH36Iffv2YcOGDVi7di0OHDiAOXPmoKioKECW0tJSvP/++8jMzMSqVavw9ddfIy0tDQsXLsSZM2cCnq2pqcHUqVOx6KsU/Pn1Gcg5uBfVpw6h/PvtqCvJxw9ff4qnPknDI8+82vjO6dOn8fHHHyM1NRWbN2/GypUr8cMPP2DGjBkoLy9HQkICNh3Kxai/voLTufko++9GnM8/hsqje3Es/Vs8Pv1zPD1xCiZNmhQgS1lZGWbOnInMzEx88cUX+Oabb7Bnzx4sWrSoidy1tbVITEzEsWPH8Nlnn2Hnzp3YuXMnPvvsMxw7dgyJiYmora1tMtcWLVqEPXv24JtvvsEXX3yBzMxMzJw5E2VlZQHPDoxrgTvDD6JtxWlUHt2DyqN7cT7/GDw/bMaUO7tj2YczMXbJPhz+ajG856tQmrYGtYWnkL1nCx6dtBAzPluPjz/+GKdPnw4ot66uDo8//zr+b85XyNr9FapPHUL1yQOoyPwWp47n4E/PvI61+45zXyNOJK/F5Du6oy79c7+5Vt0w1wpPo2DjTOTsT8VjUz7DSwkzbVkj/vr6O3hixipkp21HVXYaavKOoixjE3460zCWNh3KRUJCAqqqqjB9+nRkZWVh+fLl2LZtG5KTk/HJJ5/g5MmTeOedd+D1epGQkACv14t33nkHJ0+exCeffILk5GRs27YNy5cvR1ZWFqZPn46qqqoAWfLz8zF//nzMWv41Hvn7h8hO247zZ4+jNH0dvNXl+OGrxXhqyT4kTpkMb00FStPX4fzZ46j8cTeqjqWjJvdHXFv5H/Tr6GFaI+6+++7Gd06dOoXFixdj9+7d2Lp1K1asWIEjR45g+vTpqKysbCz/P2sWYvId3eH5YQtq8o6iMjsNlVl7cP7nHJTtW4/6qjL88NVijF2yD4888yrTGpGdnY1ly5Zhx44d+O6777BkyRIcP34cU6ZMQV1dXcA7JGuE8mxBQQHmzZuHjIwMrF+/HuvWrUNGRgbmzp2LwsJCy9aI2e8loq6sEOUHvkHNmSOoytmHiqxU9S96QXh8Pp8jwueOHTsWX331FXbt2oVLLrkEALB06VI89thjTW5bDRo0CDfffDMSExNVy1I7aeratStKSkoQFRUlrhEOpN7ra5KY0h/liHvXq7dgb04RRi1gG8DLxgyW7hg6JbuQqD1WyE6jB5K/nHmXZydqphkAzO2zu2/O13kxePJWFFWo31y0Szd29wutPEbE2TS+ZdWvE1Bbk701lTg180HLvr8dcdL09NNPY/369di+fXvjhgkAYmNjcf78eRQXFwc8n5+fj9jYWM3yIiIiEBUVFfDPaViVOoLGRGWUjkENtRQNyl8VvKHtMx7pJXinb9CCNhUBaXljX/4bpaSBWDFO1dI+mOkvmndFtC/9xDnVL1TltNeO9EgA/RgUrXuzphozfWhmjdLSr4LItCJOTznE8h3DG6l9mnw+H5555hmsXr0aO3bsQHx8fMDnAwYMQHh4OLZu3YoHHngAAHDkyBGcPHkSQ4YMsUNkS7DSp4DmqiyJ3d4frRgdY8aMYZJVD5Y+MxtfRET6BqufG3pn08SkpNjp+2KmH0jf3ZyZhxdXZHBvn1b9ba+5jUlOPWh0RNOnVuieR/tZyzCzRtkVLkM2XzQWaL9jRCD1SdO4ceOwZMkSLF26FG3btkVeXh7y8vJQVVUFAIiOjsYTTzyBF198Edu3b0d6ejoee+wxDBkyJGRvzlmdOoL2qixNahKtGB1ffvmlCYmbYqbPWOOLiErfYPVzmanbiJ4Lxu4UJ2b6gfTdRcnHhbRPq/7KrD1Ez5FCqyPS+o4XVFqiex7hF1jLMLNG2REuw+75yBOtNdkqpD5pmjt3LgDgN7/5TcDvP/74Yzz66KMAgBkzZiAsLAwPPPAAampqcNttt+GDDz6wWFJrsCN1xIDu7RDmAfROccM8CLgqS5KaRO+a8oABA7jIDvDpM9r4IiLTN/C6Pk1a3gPDbyQqzx8ZUpyY6S+S6+Fac4JH+7TqbxF7uaHspLDoiKRPO0dFYNnek5bonihMgwZm+9DMGmV1WhEZ5iNv/Nfk47ln8aeZ1tUt9UmTz+dT/adsmACgZcuWjbeTKioqsGrVKl1/Jiei2KFnbD7C1a+FhPQT53Q3TEDDl0f6iXMBv1PzM1H7nRo8I7rz8gUilZ1nncH1v3V3LwBoYs9nSUVAWl7B2Z+JZVQgbX9qdiF12aSY6S+9dxX05gSJfvV8S5qFeTDxzl5NvuS8FedsSY/kL5dRn44a1A15pdasUSTy6H1mpg/NrFG857IRNPNRNn8no3ky5LIOuPPqLpbKJPVJk4u6HdoInrZwO+zv58/zy3dmh/wi0zfMfah/k/EQy+iXQFLemqN7dEpQh7Rd45buw5QH+grzpzDTX1rvGp26+qPVD0a+JVppe3z1dcy6JpXN6DmjPq2p83Kt3wgjeQBwmy/+mF2jeM9lPWjmY3FVbePPdvs7yeqD5W6aJIY1XDxPW7gd9vfLLruMW1l2yC+yTt6pFYzKY9EFabuKq2oxdsk+obm0zPSX/7ubM/OwKPk48YYJUO8HrTmt+JY8eWM85u/MUZ3zzdvFcUvbY2aM6vVpCuHpIc/5ZqRjEalIeKxRVqVJoZmP/ihj0o5cd0bzxM78e+6mSVJYwsXztoUD1tvfgYacg3379uVSlh3yi66Td2oFvfJYdEHrayLan8JMfzUL82BQfHu8uCKD+B0t/Rr5lgDAgu/UN0wAUHPyICZtuJJL2h6zY1SrT+2Yb3ryGH3GCq81yoo0Kay+X3b5O8nugyW1T5MM2BXXgjYGiQhbOGC9/R0AHnroIW5l2SG/kU+MD8DIgV0Dfkc6zqwejyy68G+/ESJj0vCCZi7qjSmScvTUGdn7ZlO+Uv6ImhckY5/3fLMDnmuUaEh89LSwY36K8Anlibtp0mHToVwMS9yGUQtS8VxSBkYtSMWwxG2WXM+ktfkbXYE3A+u1e1Zmz57NtTyr5derU2HGlqzGsUQ6zuwYj6y6UNof0yrc+GHwj0nDExrZ9MaU2TaW7luvWw7t+BA1L5Ryo1s31X1w2BGnwnuNEo1mKBgJ56ddcaxIcUwaFZGUlpYiOjo6IAy7lk1V2amLtqmSpvB4+ubLMfTyjpZkGZctszktdshf7/Vh9rajmLHlxyaf6QVnCx5ndo9HVpKPFmD0R8bO5DKm0VEgnYsT77wKjw6N1xxTpOUY8cLwK/Dc8J4BvzMzPkTMC6eO11AnWNden0+6+Umbvkrt+1sk7kmTCkY2VR+A1744iOSjBcLMI6QpPF649QrDK/AkkBzr01y7N4OoNCpWyR9MUtpJ1d/rjRzls7+vy8T5Oq+hL8zf12UKGYtmdTH40g6G4zg2KgJen88SkyOLeZN0LuptmJRyYqMi2ATHL2lU/p2Sg9X//UV+El8pvfHBe16YkccpaT54rlFWtjlY1yTzMzhVlGh5eaSvEonrCK4Cie9BcVUtRn+0R9gVSLMpPGiQ7WrnM888Y3mdojCTH0ux3X+a0jTytNpze3OKuP81aFYXRuPYB6C6zhvw166oscc6znnNxWZhHowa1A0ztmQxyR814G4AQFFFLV5YntEo/8iBXW0bH2rQ+KT4yyPbOqQHrzXK7jbTjm0r5LXyu48F96RJBRpbqcgw9Fb44sgYXv+TTz6xvE5R8LC7nyiqtKyuYHjoQmscKz4vxZXqV515jj2z45zXXOzRMZJOcD/KDzVNaZNXUk28CbPKB4TFJ0XGdUgPHvNCljaTjm0r5bXDD5UU96RJBZoYIqKvQIqM5SHr1c6bb77ZsrpEwyMeTff2rS2rKxheuggexx0jI/DSyv0Aaps8y3vs8RrnPOaiGR217Nb0ijuNYUTE+DBTj/KcrOuQHmbnhWxtNhrbdshrVRwrWtyTJhWMbKrBiL4CqcSK6dS2JX4ua6iHhx3ZiqudLPbvrCw284UIzNrvaceSP4rt/s9Delhm4w9u75EjTR3YWfH3pwgL81iWboPnODfr/0MyHsI86lfD686doapLwWofEFqfFJmumJPOd7NrlExtVtAb2zTy8vR5sssPVQ/3pEkFPZuqHqKOv0XZkUVf7WSVu1WrVkz18YZHv7OOJX/bfYvmYZbY+NXa2yr/CCJ/lcv9ONzKa8UyXWEm8dcY8+uGqOBNPm9u7EQugw8IrU+KLPqhme9m1yhZ2kwKqRybM/Pw4ooMR/ilseKeNGlgFGdHDRHH3yLtyCLTfZiRu0MH+6+e8+x3lrEU0zo8wHYv2sav1d4Sb0sh/hVWprexI5WOHka6nHBHL9XPw1q11S33heFXSOMDQjNeZdAP7Xw3u0bJ0GYaSOVYlNz00oqsfmmsuCdNOig21dTswibJDP0RlRpAtB1ZVMoDs3JnZGRg4MCBVHXyRES/+9vn80qqMGnDYRRVaCf9jGgehlt7xWqWwdPGr9femvxjiIi7gru/gpXpNuxK7aGHkS7VxsvJ/+lCS/6nb7kcT99yuTQ+IKTj1W79sMx3s2uU3W2mhSQVi1Yya1n90lhxT5p0UAKBFVTU4LGh8fDAulQcgHm7t5FtuVmYBxPv7KU5aQG2dpmV++677yaqh8V2TvKOKH8DxT4fG91Kd8MEAHmlNarli7Dx67W39eXXC/GvsDK9jR2pdEjl0tOl8vn9/S/Bu/f3QavLrzeU38z4EBF/h0Qeu/XDMt+11ii709iwQBqjz0heveFid+oTnrgnTRqo2bdjVK5Ixwq015qxe5PY5zcdysWkDZmqZZppl1l7/UcffYQ33nhD910WfyPSd0T7G8jmz6BXT9mBrxFzw0gh8igmnGCdiJhTVtYlghF94nCL5yB+jP6dEPntjhdkp35Y5qPaGkXbhzKMSRqZ9eS9o08sFiYfN6xPFh8tM7ibJhW0UgCUVNbCB+CF4T3Ro2Ok8ONvVru3lvyKbXnuQ/0BQPUZhYl3XsU8ac3a60k2TEbtC5ad5h3R/gay+TPo1aNsmIyeY8XKa8WyXmEm5d+zEi1NeaI3n0Rgl35Y5qPahomlD+0ckywya8m7N6eIaNMki4+WGdxNUxAk9u2ktFPY9eotwgc2i92bRP63134PwKOb92zShsO4rU+cEF8pIPDKcfAXwealH+DNiRObvFPv9SE1uxCvfXGQyv+A1meBp7+B2pecXf4MWl+4evIU705CuxtGCvWvUEw4VsBalwx5FxMSEvDGG28EyK+YVljlki1ekJVjQYFlPiq6AMz3oR1tNiOzmry0fUgzn2SYe/64m6YgWFMAiIAlnDyJ/HmlNbr1mm2jv9xa3HNNw4ZM7Xi4c+vrMOhQ4DV3tedIZafVKa8w/npH31anCTA6hteSJ3rQ74XI4yTsNl0pvPzyy9zlkmm9swuW+e6vCyf2IW+ZafqQZtzKMvf8cR3Bg5DN34T2qjlPucyUNaJPHJ68MV7z8/k7czB5Y6bqNd+s7SsDrqhqXQfWw192Fp2aveJvdIUZgGVpAkiuU2uGRfj+K9vTFtiJLKkuAGDWrFnc5ZJtvbML2vnurwsn9qEImUn6kGbcyjT3/HFPmoKQzd8EoLN785TLTFn1Xh/W7tce1D4AC77LUT3KbdVzMICG4+FbruyseYysh7/srDpl9TcgPfre9eotwv0ZaI7h1drbrq4nrvzVhblhks10dd9993GXS8b1zi5o5ruiC8CZfShKZr0+pBm3+N//kz5rJe6mKQgS22znqAh4fT58mfGTZTZWUrs3qfyAB/ml4nxqjI5/Ae0rqufzjiK8/cXILanGpylNg6XpoSY7qb19QPd2qv4htEfqtEffWuXzsOWzmCb95UlK2owrf9U0NpCV8OgHozLUPpfN7JKeno6ePXtylctp8YJEQzrfFV0AzujD4PE9oHs7YTJr9SFtaAfSZ3tfFE4toxncTVMQRrZZH4DqOi9Gf7Sn8fd221j9IbEtv31PbwAQ6lNj5ii6WZt2jf9/oqiS+D0t2Un65J5r4nDTtO1cbOc8jr552fLNyhIba/1fcv7w6AejMrQ+v6MPWdutMrsouuBpWuHlv3eh4T8vZO9DrfF9zzVx6ul6/vdf3jKLMAn+XFZt+abJ9WlSQcs2G60Spwmw38YaDIltWXRaDlNH0WHNGv+3e/vWxK/pya7X3idvbMj1xct2bvbom6ct36wszZvb93cVj34wKkPLry6vpJroCjVgndlF0QVv04rotSAUCZ4Xsvah3vifvzMHT94Yb5nMNONWZpOne9KkQbBttmNkBF5auR9A01QqMoaJJ7HPi4wRQhp23+drmsS2rjgfnkt6Iza6Jf48pAc+2pWjW05Mq3DMGd0fgy/Vj4Cs1t4B3dvhpmnbufqtmDmu5+1HY9Z0kJOTg2HDhhnWwxse/WBUBqDtV6f8TmuMAtabXRRdiDAHOT2GldWozQvZ+pBkDq3dn4tvx9+M9BPnhMtMO25Jn60oL+Muqx7uSZMO/ikAwsI8yCslt8dqISJVgRakKQx4p+VQytULu+9BQzZ3tc9bde0DoOF4uEXzMMNypjzQF0Mv70gke3B700+c454yxUyKBN4pXMyma7jxxhuJ6iGBZuzz6AczfnX+nytfMP7YYXZRdEGi04l3XoW9OUVU64yotUAG1MaembVYa17IlMaGdA6lnzhnid5p1iKZ0swE4540ESKTn4pTIEkTcG23dk0+9xzbhbnTExr7RGS6AVHXhVllFnkVmKX/li5digkTJhDXpQXt2OfRD7x8jR4f2gNfHcqzPf2Kvy70dHrPNXGYtOHwBbPOGEGaEoumj3jNCz0ZzepMxlAINGuRDGlm1PD4fD5xRx0OobS0FNHR0SgpKUFUVJTqMynZhRi1INWwrGVjBqveHNAKWa/sk0PZd4D25tKAbtFoEd50Py8iMqxZvRpBK7NIeVj6r76+Hs2aNdN9xgiWsc+jH0jLIKlDuU1np9lFTRfBOj1XcR7jll6Y64waWmNPDZo+4jEvFER9N4he28zAMyI4yfc3T9yTJkLs9lORLZQ8DUbXeIM/909RQFMOC6KvC9PKLFIelv6bPHmyYS5APVjHPo9+MONXF1wHr7FnZh6r6cJfrnqvD8MStxHHtnHqekKK3thTg2YtHjt+Iu58eJzpvhMZC4xmDln9/UIzn+xIM6OHu2kixMy1UrNxVS40s56ZL2laZLsuLJs8ZnXBOvaVfnhKIxWPD8b9QNKXY34db9m1a7Pz2EgXpH09e9tRJKWdDPn1hMSnLRjitbjFUHyTlAHAXN+JjAVGupZszsy7oL5fzOI6glPAeq3UjG1Z1lDyIklISLC0PtmuC8skj1ld2O1XYdSXE+7oZUlf85jHRrog7cMZW368INYTM2PKaC0u3p3U+HszfSd6fhiNfwAX3PeLWdyTJkpYrpWyxpyQLY2DVTzyyCOW1ynbdWFZ5DGrC7NjXwuasW/Ul6L7mtc8NtKFmZg1obiemOkPo7W4TZ/fNn5mpu+siEekNb4BEJtzQ2E88MLdNDFglZ8K6dFtanYhhvbsSCyPSNRs4wCd/8TWrVvx6KOPWiTxL1hhO/fvn46REYAHKCivsX2TpiZfp7YtcfjbLXj88ceo3vFvh+ixT5OFncavjie82mI0L0h8uPQIlkNPr07wsWTpD9LxWH1iP9r0Hd74M6sZTYQPo5ZuguVKyS6UKk2QU3A3TRbA6qdCeiQ7buk+THmgr+32Z15Xe6+4wt5cZ6JQ6x9/SFJ7iPQzUKuzTXEZugzK1azTSE7RY1+mzPFa8GqL0bwgSQFFKoeeXgE4wgdGrz/UoBmPzdtdrFoG7Xjk7cNIs26E0hyzEtenySJY/FRIj2SLq2pttz9r+WwUV9ZSp52pqqoSJqddaPWPPySpPUTpWUu+guIyzTpJ/XREjn2ZMsdrwastJPNCr69fGN6TSI7jBZWaen1qyT485SAfGK3+iGkd3vgHnQLNePTV1ajWxzIeefkw0vrNhdIcsxL3pMlCaH0naI+X7bI/877aW1hYyFtEWyHtH5LUHiL8DPTkq69qSFEQXCetnw7vsW82FISV8GoL6bzQ82FJSjulK0fnqAgs23tSN7WMGjL7wOj1B+t49FYFpu4wOx7N+tWx+M2F0hyzEvekiQCe4e1pwuz7h5I3giXdBy/MXu0N5pprruEkmRzQ9o/e8BKhZz35WnSKV62TJc0J69iXLY0CLbzaQjMv1PqaRI5Rg7rppovSQ9H54uQcS9JE0aD0x11XdwEArD9wBntzijAovj3TeGzRKb7xM+UttdQ1NN8dZlKwsM7HUJljVuKeNBlgd4wk5ej2tS8OoriqabLgYOywP/O+2rt+/Xr86le/MiOSVIjQCc8y9cqqyt6L8A6XAAA2Z+Y1OoRa4Q8haxoFFni0hce8MJKjps5rqnwAmLThcOP/y+TrZHYt9++7I3t/mRdaqWvMpmqhgXU+htIcswp306SDVnh7xUZsVcycEX3i0LZlOEZ/tMfwWTvszzyv9gLA2LFjzYgjHSJ0wrNMvbLaXHtH4/8vSj6OQfHtMaJPnGX+ELKEXuCB2bbwmhd6cqRk8zWNW71WasFrLVf6bufdV6C0Lkw3dU2wLydLfaSYmY+hNMeswDXPaWBkIwYabMRWHT8PvrQD4qJbNjlGVfCg4a8YO+zPim2cZorpyfvee+9xk00GaPsnzNP0uFxBhJ4V+dQoTVsTULcy5o3axFNOM2YL2TDTFp7zQksOlrmshx1rZTC81/JmYR4kr/k37u13MQbFt8ekDXT+nLT1kWB2PobSHBONu2nSgMVG7A9PPyhA3/6syGOX/dlItmCM7OVWplGxAtL+8fzv35hfx6s+q9dvZsabnu9czA0jG//ff8xb4Q/Bew45HSvmBYle1T7Tw05/S8D8Wq6Gogve/pyshJp/ksxz3900aWA29cmwxG0YtSAVzyVlYNSCVAxL3Gb6Oq5if44OuioLoMn1WavhdbUXsD6NihVo9Y8/rKk9eIy3EX3i8MTQHk1+758uQkEZ8yLTvYiaQ07Gqnmhp9d5D/XHPINxrIVd8X5E+N8puuDtz2kGmdIvmUH2ue/x+XzybOFsorS0FNHR0SgpKUFUVBSAhmipoxakGr67bMzggGipWrZzZX/P48tEZPlm4RER/OzZs7jooousEtlSaCKCk0Rd5jke1MZ8fWUJmrWODvhd8JjnHR1a9jFuF1bPC9KI4AVlNQHO31oEjxurYF3L9VB0QVq22fpocEK0di1Y5r7a97dIXEdwDVhiWIjOFeeEXHRa6ShoFodVq1bhL3/5C0+xpIEmXYfRs7zHg9qYr/xxN9r2ux2AdtwWnilIaNoE0G3GnQ7rvGD9EtXTq/9n9V4fPtqVI228HxHxiBRd8EzVwgua+cgrVQ6PjZoTvt8Ad9OkCUt4e975soIRXb4sDBw40G4RHIGI/GzBY75FbEMUaav8IkjbNHvbUSSlnZQ+lQdPWOaFFSFTeKcC4Y0I+RRd8EzVYjW8UuXwGmNO+X5zfZp0oLURi45dc6HkCsrNlcN2LTsixkPwmK+vOAfAOr+ILZl5RM/N2PKjY1J58IJ2XtCm1TCD7P40vOXz1wVPf06r0BsbNKlyeI4xp3y/uSdNBtDEsBAdu+ZCyRVUX19vtwiOQNR48B/z69f9jLvuHmyJ6ave68PqjJ+Y35fpCF8ENPPCDlOH7PF+eMoXrAseqVqsgiQEgxpq5nGeY8wp32/upokAUhux6Fw+JOV3joqA1+fDlxk/cZukir06r6QKRRXn0b5NBGKjxC0APXr04F6mWWRwrgyWYUD3dsLGmzLmI28ZgKsJxj6P/tmbU4SiCuOo93rIcoRPC0n/0cwLUlNHanYhhvbsyCh1U3j6t4mAl3xquuDhz6kHrzWIJUyCQnC4BJ7mNKfkwnM3TRwRbds3Kt8HoLrOGxA53Kz/gpq9mlfZWnz33Xe4+uqruZZpBrtT6ejJcM81cZi/M0eYLwmJLnj1j1WpYWSDtP9o5gVp+8ct3YcpD/S13VzkNKxeo3iuQTzmBk0ZpM/K7hun4Po0cUa0bV+r/GiVPEeAOf8FLXu1Qq4gH5JRo0ZxLc8MVvqFsMgwf2cOnrwxXth4M9IFz/6xKjWMTND0H828IG1/cVVtSPuBicLKNYr3GsRjbnRq21KIOU123zjAPWkSgmjbfnD5HSMj8NLK/QCamjZY/Rf07N7B8PaN+OCDD6SICi7DFVgSGdbuz8W3429G+olz3Mebni6sCHkQTGxUBAAP8kvlPsIngbb/aOYF7VX4UPUDE4VVa5SINYglTIJC8PwSYU6T3TfOPWkShOhcPv7lh4V5kFfKN00Aqd3b3zeCV9h7GTZMgJj0C6JkSD9xTsh409MF7/4xSgXhAfD2Pb3x9j366YT+dvuV2JtTZHkKBtrUD7T9RzMv9FLjGNXjdKxIwWHVGsV7jil+Ubf3iW3cdPmjlyon2EQmKnWLDP6jergnTSGAiKuatHbvcUv3objql5MuMz4/CQkJUmycZLgCa7cMeroQGfIg2H8jNmg8qT2j8OzyDPh/T1rhf8bic0Lbf7TzQunL1744GDA3jepxMlb5H1q1RvGcY2p94/EA/jlBlHkGNI3TFDwHAfL5SooM/qNGuJumEECEbZnW7h28KCv2dhY79LPPPkv1vChkuAJrtwx6urAi5IHWX5sj+sTB6wX+unRfk/eDDxbMjEUStFI/GNVL238s82JEnzi0bRkecDnEqB6nwqoHFqxao3jNMa2+UebKE0N7YHiv2IB5Rmoi42VOs1J/ZnDNcw7F/wja6/UhNqqlZuZxDxp26zS2ZcXuzYoy8P++LpP6eHzx4sXM9fJE6QOe/eo0GfR0IVI2I/N2vdeHSRsyicoyMxaNIIl5o1Uvbf+xzovBl3awfRyLxoweWLBqjWKdY/7fD8lZBXh7rbZ/qgfAxkN5TTY6NC4mZt1RrNafGdxNkwMJzgI9euEelFbX6jr10dqWFXu1GUsyq6/E8OHDTdTKD1E2eyfJoKcLO2WjjTUjym/HjM8Jbf+xzgu7x5AVWO1/aNUaxaI7te8H3j6vvJHBf5QUd9PkMLSun1ae144W/OSN8UzHmoq9WuvEKaZVuOrvg6H1lfjhhx+onheJDFdg7ZTBSBd2ySY6FRHv8rSeo+k/M/NChnEsEqt9/6xco2h0ZxQmRg87fdpI0yfJ4Hfn+jQ5CJowAP6s3Z+LV0ZcxfSXpL+9OjgiuNfnE+IrERkZSS2nSGS4AmuXDCS6sEM20amIeJen9xxp/5mdFzKMY1FY7ftn9RpFojvW7wcFu3zaaNInyeB3526aHARr+HuzaSW00gPUe32G8T7aR4ZjQPd2VPW1by+fb4UM6SFEyaB3xZdUF1b3D22sGVHxm3ilfiDpPx7zwoyeZL4KbnUKDj1dmOknvXeNdMf6/WBVbDOttpGmT+oQ2UIKvzt30+QgzBxNijjW1At7r1BUUYubpm2nujJ64MABDBw4kKusLuoYXfGVVRckY09BpN+Olakf7NSF7FfBrU7BoaULM/1kto9Z1nirfNr02lZT5yUq495+XaTYpLs+TQ7CzNGkqGNNLXu7P7Th/m+//XZe4rnoQJKeQWZdaI294HVVtN+OVf5CdulChlRCJFjpt6WmCzP9xKOPWdZ4K3zajNpG6s90a69YEeJR4/H5fPbf4bOZ0tJSREdHo6SkBFFRUXaLo0m914dhiduowt8rR6+7Xr1F6C79fJ0XgydvRVHFedNyyBLcMpRRxpLWcb6ir9vrduPNiROtFY6S4GP/Ad3bCUkpQysH73rtmBek40T0+kKDFWbEYF2Y6SdefWz0/eAB0DkqAtMf7IeC8hpL5oZR2xS5jL7P4nTab/X3t2uecxA0JgnA2uvE6SfOaW6YgMAro0Y+Fe6GSTykV3xvHfNX64RiRM3Xww7/M9F+XXbMC5qr4Hb7/ClY4V8XrAsz/cSrj0lMlG/f0xtDL++oWQZvSPysSA4ARg7sJs2mPGTMc3PmzEGPHj3QsmVLXH/99di7d6/dIglB6wg6pnU4YloHhgCw8joxzyu/CQkJZsVxMYBUX7PfSxQsiQspdswLu9P4yEqwLsz0E88+li20BK9x0aNjay7l8CAkTpqWL1+OF198EfPmzcP111+PmTNn4rbbbsORI0fQqVMnu8Xjjtb1UwC23W7heeV3/PjxZsVxMYBUX0+Oe16sIC7E2DEv7E7jIyvBujDTT7z7WKbQErzGhUzjKyROmt577z2MGTMGjz32GHr16oV58+ahdevWWLRokd2iCUMtbL3ZUPZm4JlS41//+hdX2VyaQqqvlHWfWimWiw52zAu70/jISrAuzPSTiD6287vAH6O2AQ0XN5w0vhx/0nT+/Hmkp6djwoQJjb8LCwvD8OHDkZKSovpOTU0NampqGn8uKSkB0OBQ5sLOyzd3xYvL9wNoak/3AXj55p6oKC8zLOd3v/udqwsLINHXZS07uLqQBLvmBa95HUqo6cJMP4VyH+u1DQD+PLQ7FiefUP2cpO2KHiy70+ZzOD/99JMPgG/37t0Bvx8/frxv0KBBqu+89dZbPjTow/3n/nP/uf/cf+4/95/D/2VnZ1ux5fA5/qSJhQkTJuDFF19s/Lm4uBjdu3fHyZMnER0dbaNkLqWlpejatStOnToldfiHCwFXF/Lg6kIeXF3IRUlJCbp162ZZJgnHb5o6duyIZs2aIT8/P+D3+fn5iI1VD4YVERGBiIiIJr+Pjo52J4EkREVFubqQBFcX8uDqQh5cXchFWJg1LtqOdwRv0aIFBgwYgK1btzb+zuv1YuvWrRgyZIiNkrm4uLi4uLiEEo4/aQKAF198EY888giuu+46DBo0CDNnzkRFRQUee+wxu0VzcXFxcXFxCRFCYtP0xz/+EWfPnsWbb76JvLw89OvXD5s2bULnzp2J3o+IiMBbb72larJzsRZXF/Lg6kIeXF3Ig6sLubBaH27uORcXFxcXFxcXAhzv0+Ti4uLi4uLiYgXupsnFxcXFxcXFhQB30+Ti4uLi4uLiQoC7aXJxcXFxcXFxIeCC3zTNmTMHPXr0QMuWLXH99ddj7969dosUckyePBkDBw5E27Zt0alTJ9x33304cuRIwDPV1dUYN24cOnTogDZt2uCBBx5oErD05MmTuPPOO9G6dWt06tQJ48ePR11dnZVNCTmmTJkCj8eD559/vvF3ri6s46effsJDDz2EDh06oFWrVujbty/+85//NH7u8/nw5ptvIi4uDq1atcLw4cORlZUVUEZRURFGjx6NqKgoxMTE4IknnkB5ebnVTXE09fX1mDhxIuLj49GqVStcdtllmDRpUkA+M1cX4ti5cyfuvvtudOnSBR6PB2vWrAn4nFffHzhwAL/+9a/RsmVLdO3aFVOnTqUX1pJkLZKSlJTka9GihW/RokW+77//3jdmzBhfTEyMLz8/327RQorbbrvN9/HHH/sOHTrky8jI8N1xxx2+bt26+crLyxufeeqpp3xdu3b1bd261fef//zHN3jwYN8NN9zQ+HldXZ2vT58+vuHDh/v++9//+jZu3Ojr2LGjb8KECXY0KSTYu3evr0ePHr6rr77a99xzzzX+3tWFNRQVFfm6d+/ue/TRR3179uzxHTt2zPf111/7jh492vjMlClTfNHR0b41a9b49u/f77vnnnt88fHxvqqqqsZnRowY4bvmmmt8qampvu+++853+eWX+0aNGmVHkxzLO++84+vQoYNv/fr1vpycHN/KlSt9bdq08f3rX/9qfMbVhTg2btzo+9vf/uZbtWqVD4Bv9erVAZ/z6PuSkhJf586dfaNHj/YdOnTIt2zZMl+rVq18H374IZWsF/SmadCgQb5x48Y1/lxfX+/r0qWLb/LkyTZKFfr8/PPPPgC+b7/91ufz+XzFxcW+8PBw38qVKxufOXz4sA+ALyUlxefzNUyqsLAwX15eXuMzc+fO9UVFRflqamqsbUAIUFZW5uvZs6dv8+bNvptuuqlx0+TqwjpeffVV37BhwzQ/93q9vtjYWN+0adMaf1dcXOyLiIjwLVu2zOfz+XyZmZk+AL60tLTGZ7766iufx+Px/fTTT+KEDzHuvPNO3+OPPx7wu9///ve+0aNH+3w+VxdWErxp4tX3H3zwga9du3YBa9Srr77q+9WvfkUl3wVrnjt//jzS09Px/9u725imrj8O4N/S2iLeQZmdrTrwYeKKWme1m6ldzDIJytS4vWCZ0YIkuunqQzfjw550L5S5ZNmyaTYjiWKixvlCnVs2DYNuhgWRpyKoK0ZF9oKH+VCLYjZsz178w/17//A3xdEW4ftJblLuOfA79/xC+8u9nENGRoZ8Li4uDhkZGSgrK4vhyAa+27dvA4D8DxarqqrQ2dmpyIXZbEZqaqqci7KyMlgsFsWGpXPnzkUgEMD58+ejOPqBweVyYf78+Yo5B5iLaDpx4gRsNhuys7MxYsQIWK1WFBQUyO1Xr15FS0uLIhdJSUmYOXOmIhd6vR42m03uk5GRgbi4OJSXl0fvYh5zs2bNQnFxMRoaGgAAtbW1KC0tRVZWFgDmIpb6au7Lysowe/ZsaLVauc/cuXPh8/lw69atsMczIHYEfxTXr19HMBjstmu40WjE77//HqNRDXyhUAhutxsOhwNTpkwBALS0tECr1UKv1yv6Go1GtLS0yH16ylVXG4Xv8OHDqK6uRkVFRbc25iJ6rly5gm+++Qbvvvsu3n//fVRUVGDt2rXQarXIzc2V57KnuX4wFyNGjFC0azQaPPnkk8xFL2zevBmBQABmsxlqtRrBYBDbt2/HkiVLAIC5iKG+mvuWlhaMGzeu28/oaktOTg5rPIO2aKLYcLlcqK+vR2lpaayHMij98ccfWLduHYqKihAfHx/r4QxqoVAINpsN+fn5AACr1Yr6+nrs3r0bubm5MR7d4HLkyBEcPHgQhw4dwuTJk+H1euF2uzFq1CjmghQG7eM5g8EAtVrdbVVQa2srTCZTjEY1sK1evRo//PADPB4Pnn76afm8yWTC33//Db/fr+j/YC5MJlOPuepqo/BUVVWhra0N06dPh0ajgUajwa+//oqvvvoKGo0GRqORuYiSkSNHYtKkSYpz6enpaGpqAvDfuXzYe5TJZEJbW5ui/f79+7h58yZz0QsbNmzA5s2b8cYbb8BiscDpdOKdd97BJ598AoC5iKW+mvu+et8atEWTVqvFjBkzUFxcLJ8LhUIoLi6G3W6P4cgGHiEEVq9ejWPHjqGkpKTbLdIZM2ZgyJAhilz4fD40NTXJubDb7airq1P8YhQVFSExMbHbBw/9f3PmzEFdXR28Xq982Gw2LFmyRH7NXESHw+HotvVGQ0MDxowZAwAYN24cTCaTIheBQADl5eWKXPj9flRVVcl9SkpKEAqFMHPmzChcxcDQ0dGBuDjlx6FarUYoFALAXMRSX8293W7H6dOn0dnZKfcpKirCs88+G/ajOQDcckCn04nCwkJx4cIF8eabbwq9Xq9YFUT/3qpVq0RSUpL45ZdfRHNzs3x0dHTIfVauXClSU1NFSUmJqKysFHa7Xdjtdrm9a5l7Zmam8Hq94uTJk+Kpp57iMvc+8ODqOSGYi2g5e/as0Gg0Yvv27eLSpUvi4MGDIiEhQRw4cEDus2PHDqHX68V3330nzp07JxYtWtTjUmur1SrKy8tFaWmpSEtL4zL3XsrNzRWjR4+Wtxw4evSoMBgMYuPGjXIf5iJy2tvbRU1NjaipqREAxOeffy5qamrEtWvXhBB9M/d+v18YjUbhdDpFfX29OHz4sEhISOCWA721c+dOkZqaKrRarXjhhRfEmTNnYj2kAQdAj8e+ffvkPvfu3RNvv/22SE5OFgkJCeK1114Tzc3Nip/T2NgosrKyxNChQ4XBYBDr168XnZ2dUb6aged/iybmInq+//57MWXKFKHT6YTZbBZ79uxRtIdCIfHRRx8Jo9EodDqdmDNnjvD5fIo+N27cEIsXLxaSJInExESRl5cn2tvbo3kZj71AICDWrVsnUlNTRXx8vBg/frz44IMPFMvTmYvI8Xg8PX5G5ObmCiH6bu5ra2vFiy++KHQ6nRg9erTYsWNHr8eqEuKBLU+JiIiIqEeD9m+aiIiIiHqDRRMRERFRGFg0EREREYWBRRMRERFRGFg0EREREYWBRRMRERFRGFg0EREREYWBRRMRERFRGFg0EVHMLFu2DK+++mrU4xYWFkKlUkGlUsHtdkcsTmNjoxxn2rRpEYtDRNGhifUAiGhgUqlUD23funUrvvzyS8TqnxIkJibC5/Nh2LBhEYuRkpKC5uZmfPbZZ/j5558jFoeIooNFExFFRHNzs/z622+/xZYtW+Dz+eRzkiRBkqRYDA3Af4o6k8kU0RhqtRomkymm10lEfYeP54goIkwmk3wkJSXJRUrXIUlSt8dzL730EtasWQO3243k5GQYjUYUFBTg7t27yMvLwxNPPIEJEybgp59+UsSqr69HVlYWJEmC0WiE0+nE9evXez3msWPHYtu2bcjJyYEkSRgzZgxOnDiBP//8E4sWLYIkSZg6dSoqKyvl77l27RoWLlyI5ORkDBs2DJMnT8aPP/74yPNGRP0XiyYi6lf2798Pg8GAs2fPYs2aNVi1ahWys7Mxa9YsVFdXIzMzE06nEx0dHQAAv9+Pl19+GVarFZWVlTh58iRaW1vx+uuvP1L8L774Ag6HAzU1NZg/fz6cTidycnKwdOlSVFdX45lnnkFOTo78WNHlcuGvv/7C6dOnUVdXh08//ZR3logGKBZNRNSvPPfcc/jwww+RlpaG9957D/Hx8TAYDFixYgXS0tKwZcsW3LhxA+fOnQMA7Nq1C1arFfn5+TCbzbBardi7dy88Hg8aGhp6Hf+VV17BW2+9JccKBAJ4/vnnkZ2djYkTJ2LTpk24ePEiWltbAQBNTU1wOBywWCwYP348FixYgNmzZ/fpnBBR/8CiiYj6lalTp8qv1Wo1hg8fDovFIp8zGo0AgLa2NgBAbW0tPB6P/DdSkiTBbDYDAC5fvvyv4nfFelj8tWvXYtu2bXA4HNi6datczBHRwMOiiYj6lSFDhii+VqlUinNdq/JCoRAA4M6dO1i4cCG8Xq/iuHTp0iPd8ekp1sPiL1++HFeuXIHT6URdXR1sNht27tzZ67hE1P+xaCKix9r06dNx/vx5jB07FhMmTFAckdxO4EEpKSlYuXIljh49ivXr16OgoCAqcYkoulg0EdFjzeVy4ebNm1i8eDEqKipw+fJlnDp1Cnl5eQgGgxGP73a7cerUKVy9ehXV1dXweDxIT0+PeFwiij4WTUT0WBs1ahR+++03BINBZGZmwmKxwO12Q6/XIy4u8m9xwWAQLpcL6enpmDdvHiZOnIivv/464nGJKPpUIlbb8RIRxUhhYSHcbjf8fn9U4n388cc4fvw4vF5vVOIRUWTwThMRDUq3b9+GJEnYtGlTxGI0NTVBkiTk5+dHLAYRRQ/vNBHRoNPe3i7vs6TX62EwGCIS5/79+2hsbAQA6HQ6pKSkRCQOEUUHiyYiIiKiMPDxHBEREVEYWDQRERERhYFFExEREVEYWDQRERERhYFFExEREVEYWDQRERERhYFFExEREVEYWDQRERERheEfg3qpnVNhJIkAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3271,7 +2869,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3328,7 +2926,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3413,7 +3011,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -3427,7 +3025,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.9.2" } }, "nbformat": 4, From 53a8f9361cec83986aacfab3e74e5fe2a82d5446 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Thu, 10 Oct 2024 14:49:05 +0200 Subject: [PATCH 6/6] update GL tutorial notebook --- .../gl_model/gl_model_tutorial.ipynb | 1973 ++++------------- pynestml/utils/ast_utils.py | 3 +- 2 files changed, 381 insertions(+), 1595 deletions(-) diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb index e2386b478..b0eb7ec61 100644 --- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -34,8 +34,8 @@ " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0-post0.dev0\n", - " Built: Mar 21 2024 03:47:13\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -169,24 +169,6 @@ "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Did you try to import pygsl in the build directory?\n", - "\n", - "Well, that does not work out of the box. If you want to do that, please\n", - "use\n", - " python setup.py build_ext -i\n", - "to add the necessary extension module in the local pygsl/ directory!\n", - "\n", - "Please read the README first! Any further questions or missing information\n", - "please report on https://github.com/pygsl/pygsl!\n", - "WARNING:root:PyGSL is not available. The stiffness test will be skipped.\n", - "WARNING:root:Error when importing: libgsl.so.27: cannot open shared object file: No such file or directory\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -195,8 +177,8 @@ " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0-post0.dev0\n", - " Built: Mar 21 2024 03:47:13\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -206,7 +188,19 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "-- The CXX compiler identification is GNU 10.2.1\n", + "\n", + "Oct 10 14:43:49 NodeManager::add_node [Info]: \n", + " Neuron models emitting precisely timed spikes exist: the kernel property \n", + " off_grid_spiking has been set to true.\n", + " \n", + " NOTE: Mixing precise-spiking and normal neuron models may lead to inconsistent results.\n", + "CMake Warning (dev) at CMakeLists.txt:93 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", @@ -214,64 +208,63 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module Configuration Summary\n", + "nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", "Build static libs : OFF\n", "C++ compiler flags : \n", "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", - "NEST include dirs : -I/home/charl/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", - "NEST libraries flags : -L/home/charl/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/10/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.so\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module' using\n", + "You can now build and install 'nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so will be installed to\n", - " /tmp/nestml_target_bon4voq8\n", + "The library file libnestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so will be installed to\n", + " /tmp/nestml_target_ylwc6lqa\n", "The module can be loaded into NEST using\n", - " (nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module) Install (in SLI)\n", - " nest.Install(nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module) (in PyNEST)\n", + " (nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module) Install (in SLI)\n", + " nest.Install(nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module) (in PyNEST)\n", "\n", "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.18)\n", + " cmake_minimum_required(VERSION 3.26)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", "\n", - "-- Configuring done\n", - "-- Generating done\n", - "-- Build files have been written to: /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", - "\u001b[35m\u001b[1mScanning dependencies of target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\u001b[0m\n", - "[ 33%] \u001b[32mBuilding CXX object CMakeFiles/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module.dir/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.o\u001b[0m\n", - "[ 66%] \u001b[32mBuilding CXX object CMakeFiles/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module.dir/gl_exp_neuron_nestml.o\u001b[0m\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘void gl_exp_neuron_nestml::init_state_internal_()’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:175:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 175 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "-- Configuring done (0.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 33%] Building CXX object CMakeFiles/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module.dir/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.o\n", + "[ 66%] Building CXX object CMakeFiles/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module.dir/gl_exp_neuron_nestml.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘void gl_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:178:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 178 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘virtual void gl_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:285:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 285 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘virtual void gl_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:288:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 288 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:276:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 276 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:279:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 279 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so\u001b[0m\n", - "[100%] Built target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\n", - "[100%] Built target nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module_module\n", - "\u001b[36mInstall the project...\u001b[0m\n", + "[100%] Linking CXX shared module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so\n", + "[100%] Built target nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module\n", + "[100%] Built target nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module\n", + "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_bon4voq8/nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module.so\n", + "-- Installing: /tmp/nestml_target_ylwc6lqa/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so\n", "\n", - "Aug 26 09:55:55 Install [Info]: \n", - " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n" + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n" ] } ], @@ -339,167 +332,167 @@ "output_type": "stream", "text": [ "\n", - "Aug 26 09:55:55 Install [Info]: \n", - " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", "\n", - "Aug 26 09:55:55 correlation_detector [Info]: \n", + "Oct 10 14:43:53 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Aug 26 09:55:55 correlomatrix_detector [Info]: \n", + "Oct 10 14:43:53 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Aug 26 09:55:55 correlospinmatrix_detector [Info]: \n", + "Oct 10 14:43:53 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Aug 26 09:55:55 gl_exp_neuron_nestml [Warning]: \n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Aug 26 09:55:55 SimulationManager::set_status [Info]: \n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:55 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Aug 26 09:55:55 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:55 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, @@ -515,7 +508,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -651,54 +644,54 @@ "output_type": "stream", "text": [ "\n", - "Aug 26 09:55:56 Install [Info]: \n", - " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", "\n", - "Aug 26 09:55:56 gl_exp_neuron_nestml [Warning]: \n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Aug 26 09:55:56 SimulationManager::set_status [Info]: \n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Aug 26 09:55:56 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", " Preparing 52 nodes for simulation.\n", "\n", - "Aug 26 09:55:56 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 52\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:56 SimulationManager::run [Info]: \n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:55:56 Install [Info]: \n", - " loaded module nestml_84ffa9d0eb074a75aff4c599b4aedcfe_module\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", "\n", - "Aug 26 09:55:56 gl_exp_neuron_nestml [Warning]: \n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Aug 26 09:55:56 SimulationManager::set_status [Info]: \n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 0.1 ms.\n", "\n", - "Aug 26 09:55:56 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:43:54 NodeManager::prepare_nodes [Info]: \n", " Preparing 54 nodes for simulation.\n", "\n", - "Aug 26 09:55:56 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:43:54 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 54\n", " Simulation time (ms): 500\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:55:56 SimulationManager::run [Info]: \n", + "Oct 10 14:43:54 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXgURfrHvxOOEK7hhoAJIHKoHCKiIivKoYjoCh7g9Vt01XXlcL1Fl1VXw4bDCHIfy7HcAUmQ+5AQQgiwMRABIyEGQsAkEAKZcCQhJP37g51xju6e7umq6uqhPs/Do5l0ut5vvfXWWzNT1a9NkiQJAoFAIBAIBAKBQCAQCIgTYrYBAoFAIBAIBAKBQCAQBCviTbdAIBAIBAKBQCAQCASUEG+6BQKBQCAQCAQCgUAgoIR40y0QCAQCgUAgEAgEAgElxJtugUAgEAgEAoFAIBAIKCHedAsEAoFAIBAIBAKBQEAJ8aZbIBAIBAKBQCAQCAQCSog33QKBQCAQCAQCgUAgEFBCvOkWCAQCgUAgEAgEAoGAEuJNt0Bwk/LKK6+gTZs2ZpshEAgEAoFlePjhh/Hwww+bbYYmbDYbvvjiC+btfvHFF7DZbMzbFQh4RrzpFlie7OxsvPnmm7j11ltRq1Yt1K9fH71798a3336L0tJSU23bvHkzs4SXkpKCL774AsXFxUzaIw3LvuKVjIwMfPHFF8jJyTHbFIFAIAgKFi9eDJvN5vpXq1YtdOjQAaNHj8bZs2fNNk/AAKuvjwTBgU2SJMlsIwSCQNm0aROee+45hIaG4k9/+hM6d+6Ma9euITk5GWvXrsUrr7yCefPmmWbf6NGjMXPmTLAIs6+//hoffvghTp48qekb7IqKClRVVSE0NJS6bVpg2Ve88t133+G5557Drl27LPNNikAgEPDM4sWL8eqrr+LLL79E27ZtUVZWhuTkZCxduhStW7fG0aNHUbt2bc33u3btGgCgZs2atEwmRllZGapXr47q1aszbff69eu4fv06atWqxbRdJfSujwQCGrCNQoGAICdPnsTzzz+P1q1bIyEhAeHh4a7fjRo1Cr/++is2bdpkooV8U6NGDbNN4JqysjLUrFkTISG+G4KuXLmCOnXqmGCVQCAQCAJh0KBBuOeeewAAr7/+Oho3boxvvvkG33//PV544QXN97HCm20nZr3pNeONvkDAO2J7ucCyTJo0CZcvX8aCBQs83nA7ue222/C3v/3N9fP169fx1VdfoV27dggNDUWbNm3w6aefory83OPv2rRpgyeeeALJycm49957UatWLdx6661YsmSJx3UVFRX45z//ifbt26NWrVpo3Lgx/vCHP2DHjh0AbpyZnjlzJgB4bG1z8vXXX+OBBx5A48aNERYWhh49euC7777z0WGz2TB69GisW7cOnTt3RmhoKO68805s3brVdc0XX3yBDz/8EADQtm1bV1tq25S9z3Tn5OTAZrPh66+/xrx581z91LNnT6Smpvr8bd26dXHixAkMHDgQderUQcuWLfHll196fFOdmJgIm82GxMREj793trV48WJNfaXEli1b8NBDD6FevXqoX78+evbsiRUrVrh+36ZNG7zyyis+f+d9Js9p56pVqzBu3Di0atUKtWvXRklJiUtrdnY2Hn/8cdSrVw8vvfQSAKCqqgpTp07FnXfeiVq1aqF58+Z48803cfHiRY/2tIypxYsX47nnngMA9O3b19UH3n0nEAgEAuP069cPwI0P8AHtawS5M93Tp0/HnXfeidq1a6Nhw4a45557PHLRpUuX8M4776BNmzYIDQ1Fs2bN8Mgjj+DgwYMe91mzZg169OiBsLAwNGnSBC+//DJ+++03j2ucOem3337DkCFDULduXTRt2hQffPABKisrPa71PtN96tQpjBw5Eh07dkRYWBgaN26M5557zmet4NySv3fvXrz33nto2rQp6tSpg6FDh6KwsNBv38qd6daylnH/22PHjmHYsGGoX78+GjdujL/97W8oKytzXee9jlDSHcj6SCCggfgYSmBZNmzYgFtvvRUPPPCAputff/11/Oc//8Gzzz6L999/HwcOHEB0dDR++eUXxMfHe1z766+/4tlnn8Vrr72GESNGYOHChXjllVfQo0cP3HnnnQBuTOTR0dF4/fXXce+996KkpAQ//vgjDh48iEceeQRvvvkm8vLysGPHDixdutTHnm+//RZ//OMf8dJLL+HatWtYtWoVnnvuOWzcuBGDBw/2uDY5ORlxcXEYOXIk6tWrh2nTpuGZZ55Bbm4uGjdujKeffhrHjx/HypUrMWXKFDRp0gQA0LRpU939umLFCly6dAlvvvkmbDYbJk2ahKeffhonTpzw+Ha8srISjz32GO6//35MmjQJW7duxeeff47r16/jyy+/1NWmv76SY/Hixfjzn/+MO++8E5988gkaNGiAQ4cOYevWrXjxxRd1te/kq6++Qs2aNfHBBx+gvLzc9Y3G9evXMXDgQPzhD3/A119/7dqK+Oabb7q2Lr799ts4efIkZsyYgUOHDmHv3r0e/eVvTPXp0wdvv/02pk2bhk8//RS33347ALj+KxAIBAJyZGdnAwAaN24MQN8awZ358+fj7bffxrPPPut6Y3j48GEcOHDAlYv++te/4rvvvsPo0aNxxx13oKioCMnJyfjll19w9913A/h9G3zPnj0RHR2Ns2fP4ttvv8XevXtx6NAhNGjQwNVmZWUlBg4ciPvuuw9ff/01fvjhB8TExKBdu3Z46623FG1NTU1FSkoKnn/+edxyyy3IycnB7Nmz8fDDDyMjI8Nnm/2YMWPQsGFDfP7558jJycHUqVMxevRoxMbGBtTn/tYy7gwbNgxt2rRBdHQ09u/fj2nTpuHixYs+X4D4g+T6SCAwhCQQWBCHwyEBkJ566ilN16enp0sApNdff93j9Q8++EACICUkJLhea926tQRASkpKcr127tw5KTQ0VHr//fddr3Xr1k0aPHiwarujRo2SlMLs6tWrHj9fu3ZN6ty5s9SvXz+P1wFINWvWlH799VfXaz/99JMEQJo+fbrrtcmTJ0sApJMnT6ra5GTEiBFS69atXT+fPHlSAiA1btxYunDhguv177//XgIgbdiwweNvAUhjxoxxvVZVVSUNHjxYqlmzplRYWChJkiTt2rVLAiDt2rXLo21nW4sWLXK9ptZX3hQXF0v16tWT7rvvPqm0tNTjd1VVVa7/b926tTRixAifv3/ooYekhx56yPWz085bb73Vxy9OrWPHjvV4fc+ePRIAafny5R6vb9261ed1rWNqzZo1sv0lEAgEgsBYtGiRBED64YcfpMLCQun06dPSqlWrpMaNG0thYWHSmTNndK0RvPPHU089Jd15552qNtjtdmnUqFGKv7927ZrUrFkzqXPnzh45bePGjRIA6bPPPnO95sxJX375pcc9unfvLvXo0cPjNQDS559/7vrZO79JkiTt27dPAiAtWbLE9ZqzzwYMGOCRU999912pWrVqUnFxsarezz//3Cefa13LOP/2j3/8o8ffjxw5UgIg/fTTT5Ikya8jlHTrXR8JBDQQ28sFlqSkpAQAUK9ePU3Xb968GQDw3nvvebz+/vvvA4DP2e877rgDDz74oOvnpk2bomPHjjhx4oTrtQYNGuDnn39GVlaWfgEAwsLCXP9/8eJFOBwOPPjggz7bzQBgwIABaNeunevnrl27on79+h72kGL48OFo2LCh62dnP8i1NXr0aNf/O7eOXbt2DT/88ANxu9zZsWMHLl26hLFjx/qcWTNSpmTEiBEefnHH+9uDNWvWwG6345FHHsH58+dd/3r06IG6deti165dHtdrGVMCgUAgoMOAAQPQtGlTRERE4Pnnn0fdunURHx+PVq1a6V4juNOgQQOcOXPG5xiW9zUHDhxAXl6e7O9//PFHnDt3DiNHjvTIaYMHD0anTp1k2//rX//q8fODDz7oN5+457eKigoUFRXhtttuQ4MGDWTXHn/5y188cuqDDz6IyspKnDp1SrUdJfSsZUaNGuXx85gxYwD8vp4TCKyGeNMtsCT169cHcOOclBZOnTqFkJAQ3HbbbR6vt2jRAg0aNPBJIJGRkT73aNiwocdZ3S+//BLFxcXo0KEDunTpgg8//BCHDx/WrGHjxo24//77UatWLTRq1AhNmzbF7Nmz4XA4fK7VYg8pvNtyvgH3biskJAS33nqrx2sdOnQAAOpnpZzbAjt37kz0vm3btpV9vXr16rjllls8XsvKyoLD4UCzZs3QtGlTj3+XL1/GuXPnPK5n6UOBQCAQeDJz5kzs2LEDu3btQkZGhuuZJID+NYI7H3/8MerWrYt7770X7du3x6hRo7B3716PayZNmoSjR48iIiIC9957L7744guPN5rO+3fs2NHn/p06dfJpv1atWj7bo7Xkk9LSUnz22WeIiIhAaGgomjRpgqZNm6K4uFjT2kNpPaAVPXmwffv2Hj+3a9cOISEh4iy2wLKIM90CS1K/fn20bNkSR48e1fV3Wr8FrVatmuzrkttDwvr06YPs7Gx8//332L59O/79739jypQpmDNnDl5//XXV++/Zswd//OMf0adPH8yaNQvh4eGoUaMGFi1a5PHwFT32kIJkW0r97f2wF1qotS+nU+lb7tDQUJ+nmFdVVaFZs2ZYvny57N94L4hY+lAgEAgEntx7772up5crEchOqdtvvx2ZmZnYuHEjtm7dirVr12LWrFn47LPP8M9//hPAjfPJDz74IOLj47F9+3ZMnjwZEydORFxcHAYNGqS7TaV84o8xY8Zg0aJFeOedd9CrVy/Y7XbYbDY8//zzqKqq0txOoHnLyP3kHswmB6v1hUCgF/FNt8CyPPHEE8jOzsa+ffv8Xtu6dWtUVVX5bAU/e/YsiouL0bp164BsaNSoEV599VWsXLkSp0+fRteuXT2eFKqUFNauXYtatWph27Zt+POf/4xBgwZhwIABAdngry1aVFVV+WwJO378OAC4noru/FS8uLjY4zq5bw302O/cnubvQ5eGDRv6tK3Uvl7atWuHoqIi9O7dGwMGDPD5161bN933ZO1DgUAgEBhfI9SpUwfDhw/HokWLkJubi8GDB2P8+PEeT9sODw/HyJEjsW7dOpw8eRKNGzfG+PHjXe0DQGZmps+9MzMzA16jePPdd99hxIgRiImJwbPPPotHHnkEf/jDH2TzpNl4++LXX39FVVUV9fWFQEAL8aZbYFk++ugj1KlTB6+//jrOnj3r8/vs7Gx8++23AIDHH38cADB16lSPa7755hsA8HlauBaKioo8fq5bty5uu+02j/IizlrO3kmhWrVqsNlsHp/I5uTkYN26dbrt8NcWTWbMmOH6f0mSMGPGDNSoUQP9+/cHcGMhUa1aNSQlJXn83axZs3zupcf+Rx99FPXq1UN0dLTHosZph5N27dph//79uHbtmuu1jRs34vTp0/7F+WHYsGGorKzEV1995fO769evB+QHM3woEAgENztG1gjea4GaNWvijjvugCRJqKioQGVlpc/W7WbNmqFly5au9cI999yDZs2aYc6cOR5riC1btuCXX34JaI0iR7Vq1Xy+VZ4+fTqX3w47y4g6mT59OgC4dgbUr18fTZo0Ib6+EAhoIbaXCyxLu3btsGLFCgwfPhy33347/vSnP6Fz5864du0aUlJSsGbNGleN5m7dumHEiBGYN28eiouL8dBDD+G///0v/vOf/2DIkCHo27ev7vbvuOMOPPzww+jRowcaNWqEH3/80VUSxEmPHj0AAG+//TYGDhyIatWq4fnnn8fgwYPxzTff4LHHHsOLL76Ic+fOYebMmbjtttt0nQt3x9nW3//+dzz//POoUaMGnnzySVeyIU2tWrWwdetWjBgxAvfddx+2bNmCTZs24dNPP3Vtrbbb7Xjuuecwffp02Gw2tGvXDhs3bvQ57+xuv3dfyVG/fn1MmTIFr7/+Onr27IkXX3wRDRs2xE8//YSrV6/iP//5D4AbJWC+++47PPbYYxg2bBiys7OxbNkyjwe5BMpDDz2EN998E9HR0UhPT8ejjz6KGjVqICsrC2vWrMG3336LZ599Vtc977rrLlSrVg0TJ06Ew+FAaGgo+vXrh2bNmhm2VyAQCATyGFkjPProo2jRogV69+6N5s2b45dffsGMGTMwePBg1KtXD8XFxbjlllvw7LPPolu3bqhbty5++OEHpKamIiYmBgBQo0YNTJw4Ea+++ioeeughvPDCC66SYW3atMG7775LROcTTzyBpUuXwm6344477sC+ffvwww8/+JTr4oGTJ0/ij3/8Ix577DHs27cPy5Ytw4svvuixi+z111/HhAkT8Prrr+Oee+5BUlKSa8edO6zXRwKBLGY9Nl0gIMXx48elN954Q2rTpo1Us2ZNqV69elLv3r2l6dOnS2VlZa7rKioqpH/+859S27ZtpRo1akgRERHSJ5984nGNJN0o7yRXCsy7TEhUVJR07733Sg0aNJDCwsKkTp06SePHj5euXbvmuub69evSmDFjpKZNm0o2m82jhMaCBQuk9u3bS6GhoVKnTp2kRYsWKZbZkCs1IlcO66uvvpJatWolhYSE+C2PoVQybPLkyT7Xwqv8xogRI6Q6depI2dnZ0qOPPirVrl1bat68ufT5559LlZWVHn9bWFgoPfPMM1Lt2rWlhg0bSm+++aZ09OhRn1Ifan2lxPr166UHHnhACgsLk+rXry/de++90sqVKz2uiYmJkVq1aiWFhoZKvXv3ln788UfFkmFr1qyR7ac6deoo2jBv3jypR48eUlhYmFSvXj2pS5cu0kcffSTl5eW5rtE6piRJkubPny/deuutUrVq1UT5MIFAIDCIs/xVamqq6nVa1wje8/bcuXOlPn36SI0bN5ZCQ0Oldu3aSR9++KHkcDgkSZKk8vJy6cMPP5S6desm1atXT6pTp47UrVs3adasWT42xMbGSt27d5dCQ0OlRo0aSS+99JJ05swZj2uUcpLS+sE9d1+8eFF69dVXpSZNmkh169aVBg4cKB07dsxnPaHUZ0plQLXaomUt4/zbjIwM6dlnn5Xq1asnNWzYUBo9erRPidCrV69Kr732mmS326V69epJw4YNk86dO+ejW5L0rY8EAhrYJEk8xUcgEOjjlVdewXfffYfLly+bbYpAIBAIBIIg4YsvvsA///lPFBYWokmTJmabIxAQQ5zpFggEAoFAIBAIBAKBgBLiTbdAIBAIBAKBQCAQCASUEG+6BQKBQCAQCAQCgUAgoIQ40y0QCAQCgUAgEAgEAgElxDfdAoFAIBAIBAKBQCAQUEK86RYIBAKBQCAQCAQCgYAS1c02gAeqqqqQl5eHevXqwWazmW2OQCAQCCyKJEm4dOkSWrZsiZAQ8bk2bUT+FggEAgEpaOZw8aYbQF5eHiIiIsw2QyAQCARBwunTp3HLLbeYbUbQI/K3QCAQCEhDI4eLN90A6tWrB+BGB9evX99ka4wxadIkfPTRR2abQYRg0RIsOoDg0RIsOoDg0RIsOkpKShAREeHKKwK6BFP+BoInDoJFByC08Eiw6ACCR0uw6KCZw8XTy3Gjg+12OxwOh+WT9uXLl1G3bl2zzSBCsGgJFh1A8GgJFh1A8GgJFh3BlE+sQLD1d7DEQbDoAIQWHgkWHUDwaAkWHTRzijhwFmTMnz/fbBOIESxagkUHEDxagkUHEDxagkWHQGCEYImDYNEBCC08Eiw6gODREiw6aML1m+4vvvgCNpvN41+nTp1cvy8rK8OoUaPQuHFj1K1bF8888wzOnj1rosXmM2jQILNNIEawaAkWHUDwaAkWHUDwaAkWHYLfETlcP8ESB8GiAxBaeCRYdADBoyVYdNCE6zfdAHDnnXciPz/f9S85Odn1u3fffRcbNmzAmjVrsHv3buTl5eHpp5820VrzOXLkiNkmECNYtASLDiB4tASLDiB4tASLDoEnIofrI1jiIFh0AEILjwSLDiB4tASLDppw/yC16tWro0WLFj6vOxwOLFiwACtWrEC/fv0AAIsWLcLtt9+O/fv34/777yfSfr6jFCfPX0HbJnUQbg8jck+aNGjQgNi9zNZOUouZBIsOwJgWs8eTOzerT3jygTdW8AnP/ccrZudwq2GFONACTR2s47Cqlh0p2edNi3uSes0eX6S0sNLBYqxp0cJj7vG2yeyxZQW4f9OdlZWFli1bolatWujVqxeio6MRGRmJtLQ0VFRUYMCAAa5rO3XqhMjISOzbt49Iwo5NzcUncUdQJQEhNiD66S4Y3jPS8H1pQuppezxoD5an/waLDiBwLTyMJ3duRp/w5gNvePcJ7/3HK2bmcCvCexxohZYO1nEYm5qLsXsrIO09YErck9Zr5vgiqYWFDlZjzZ8WHnOPnE2tg2TuognX28vvu+8+LF68GFu3bsXs2bNx8uRJPPjgg7h06RIKCgpQs2ZNn09WmjdvjoKCAtX7lpeXo6SkxOOfN/mOUteAAoAqCfg07ijyHaWk5FHhl19+MXwPXrST0MIDwaIDCEwLL+PJnZvNJzz6wBuefWKF/uMRGjlcKX8XBIkveI4DPdDQwToOne05S/ywjnsaes0aX6S10NbBcqypaeEx9yjZdOBwpmk2WQWu33QPGjQIzz33HLp27YqBAwdi8+bNKC4uxurVqw3dNzo6Gna73fUvIiICAHDixAlMmjQJ5eXl+GrKXNeAclIpSVizJRFxcXHIyMjAtGnTUFJSgqioKABAVFQULly4gJkzZ+Lw4cNYv349Nm3ahIMHD2Lu3LkoLCz0uPbq1auIiYlB8sGf8a8F32HNph+QkpKCxYsX4/Tp0x7XVlZWIjo6GqdOncLSpUuRnJyMxMRErFq1CllZWZg8eTLKysqQkZHh+puCggLMnz8fqamp2Lp1K+Lj43H06FFMnz4dDofD4/7FxcWYMWMGjhw5gmXrtstqzzl/FVFRUSgtLUVMTAyysrIQGxuLhIQE7N27F0uWLMGPGdkY9c9v8dvFK4iKikJVVRXGjx+P3NxcLFmyBHv37kVCQgJiY2ORlZWFmJgYlJaWethy9uxZzJs3D82bN8fmzZuxbt06HDlyBDNmzEBxcbHHtQ6HA9OnT8fRo0cRHx+PrVu3IjU1FfPnz0dBQYHHtWVlZZg8eTKysrKwatUqJCYmIjk5GUuXLsWpU6cQHR2NyspKj785ffo0Fi9ejJSUFOzcuROrV69GZmYmYmJicPXqVY9rCwsLMXfuXBw8eBCbNm3C+vXrcfjwYfz222+4cOGCx7UlJSWYNm0aMjIyEBcXh23btiE1NRULFixAXl6ex7Xl5eWYNGkSsrOzsXLlSiQmJmLPnj1YtmwZcnJyMGHCBFy/ft3jb86cOYNFixZh//792LFjB9asWYNjx45hypQpuHz5sse158+fx5w5c5Ceno6lazciZukG/JCShtmzZ6OoqMjj2l69emHq1KnIyMjA2rVrsX37dhw4cAALFy70sbuiogITJ05EypFfZcfT+1OWI/f8JY+/ycvLw8KFC3HgwAFs374da9euRUZGBqZOnYpLlzyvLSoqwuzZs5Geno4NGzZg48aNSE9Px5w5c3D+/HmPay9fvowpU6bg2LFjWLNmDUJDQ7F//34sWrQIZ86c8bj2+vXrmDBhAnJycrBs2TLs2bMHiYmJWLlyJbKzs11zhLfdCxYsQGpqKrZt20Z8jsjMzMTq1auxc+dOnznikUce8TtHJKcfl/XBquTjiJm9QPccsW7dOmzevBlpaWmYN28ezp4963Gt2hyRm5uL8ePHo6qqymOOuOOOO3TPEWlpaUzmiHkr18n231dT5vrMEXFxcRDcgEYOV8rfB37mLzad12rN3+7xHGj+phGbgeTvmg2aYcqKTVgcSy42J8xcKBuHy3b/jL+P/5p4/t753yOy7WXkFgaUv+f8ZxVmr92J77fv1pS/Nyf9qDjvOK91z98bN27Ehg0bkJ6ejonT52HroRP45MuJrmsvXbqEU6dO6crfJ06cwPLly5GUlISkpCQsX74cJ06cwMSJE1FRUaE5f2fknpfV8sP+w7L5+5MvJyIl+8Z/vfP3jh070LhxY6r5OzEtQ9beIycLMOHbOVi247/4zxoyc0RGRobiHLFw9UbFMWDWHBE1dZ6sTbkXy7jM33rX+FlZWaCF5ep09+zZEwMGDMAjjzyC/v374+LFix6flLdu3RrvvPMO3n33XcV7lJeXo7y83PWzsxC6e022fEcpek9I8BhY1Ww2JI/tS/Q8BeltI1FRURg3bpwhmwLVzqMWHrCKDi3+C0SL3HhyYtZWKav4RAtatPDoA2949omeOTHY6kaTxmgOV8rfmbkF6BDRnLb51OE5DrQSm5qLsWsPQ4KN6PzCeh4juQ4MZH1EYy1m1vjSo4XWWoSEvR8N6oiJW44R3eqtpiXfUYoHohPgPuRtNiBlbD/TznYrxeG9NX/D6i//YopNJBF1uv/H5cuXkZ2djfDwcPTo0QM1atTAzp07Xb/PzMxEbm4uevXqpXqf0NBQ1K9f3+OfN+H2MEQ/3QXVbDYAN4LtX093JjrIaWwbITEJBaKdVy08YAUdWv0XiBbv8eSOWVulrOATrWjRwqMPvOHZJyzywc0AiRyuJX9bGZ7jQAu/b8m+ESsk5xfW8xipuA90fURjLWbW+NKqheZaxKi9Hz32+xtuNdv0oluLyV+VhtvD8PFjnXxeT6u4xfR1BO9w/ab7gw8+wO7du5GTk4OUlBQMHToU1apVwwsvvAC73Y7XXnsN7733Hnbt2oW0tDS8+uqr6NWrF7EHsAzvGYnksX2x8o37kTy2L/Fvgk6ev6K4jTtQnNsmjKJXO89azMYKOrT6L1AtzvE0bvDtPr8zOk4CwQo+0YpWLbz5wBvefUI7HwQjLHN4blFwLPZ4jwN/0FgLuMN6HhveMxLDwo4YinsjfUJ6LWbm+NKihfZaRA/e9na5xU5lbKtpOXn+is97bAkwPV93ucXu8xoP6wje4frp5WfOnMELL7yAoqIiNG3aFH/4wx+wf/9+NG3aFAAwZcoUhISE4JlnnkF5eTkGDhyIWbNmEbUh3B5G7duMtk3qIMQGn+0rbZrU9rhOT6mAsWPHErPPXbs/G7Rq0QNJLYFAqkSD2Tq0oMV/+Y5SPDTsDeQ7SgPqj3B7GAZ3Dce/Nv9iaJyQ8Iten/BYrsOJHi2kfEADLTpo+EHPPWnmg2CEZQ6PbBwcfrFCvpDDGUd1alYjvhbwhvU89tWn76N69cCXy0bXR3rmHbm2QgBXW2aPL39atPYVKx3e9pIc286YGfHWO4rX0Fhb60EpP8qOMxtMX0fwDtffdK9atQp5eXkoLy/HmTNnsGrVKrRr1871+1q1amHmzJm4cOECrly5gri4ONl6oLyiZbtNbGouek9IwIvzD6D3hATEpuaq3vPrr78mbqcWG2hsv6ShRSt6+10NM3VoxZ//nP3xfwt/NNQfRscJKb/o8QnJsUADveOL163S/nTQ8APvvrU6LHN4iyD5MMQK+cIb9zgaOisFQ7u3gu1/38/Rml/C7WEY2r2Vx2tDurekMo8Z9QlLW53zu/sGfAlA0vFCAPyPL619ZYYOkrnTPWb6TE5UzD1m5mu1/Chn14O1zpi+juAdyz1IjQZmP/gm31GKnPNX0aZJbY8BG8hDNHJyctCmTRuitumxQUlLIJDWohXSD9EzS0cgyPmPxkMFAxknJO3Q6hNWD1Q0QqDji2SskkBNB60xSMO3ZueTmw1nfwfLg9SslC8A5TiaMaQNGjRpTm1+YTk3G/UJ6zyi1l75xbNcjy+tfWVmnBjNnYGMB9b5WquN7nbxPra0Ih6kFuSE28PQq11jn0AK5BxQcnIyUdu02pDvKEVK9nkAkNUSCKS1aEVJc1rOxYDuZ5aOQJAbizTO6CmNeeD3seT9QA6Sdmj1idpYkLPRDPxpUepPNR+YgZoOGmOQ9tlTAVuC5Uw3T/lCae5wRymOUg8dpja/5DtKsfFwHrP4NeoT1nONWns8jS/Ad4xp7SuzdUgGnmYWyHgIt4ehTZPaOHn+CpN1h9Z1sPs6wmyfWAGuz3Tf7ARylqN169bMbSBdKswJaS1akdMMAG+vOoQr167r1maWDlKwPFOkNpZI2qHVJ3Jt2nBjLJAe74GipoVWbNJATQeNMXjkjMPnNR7OtgsCI1jOdPOSL7TOHUqx2e3WcOp2eUMrfo36pG2TOrABPmWfaM01anPbdU7GFyA/xvp0aKpprjcrTkjk1EDyGetcHsg6mJe5i2fEN90cE8hZjsrKSqY20CgV5oS0Fq04NXsHR6DazNJBClZnivyNJZJ2aPWJd5vOMUFjvAeKkhaasUkDNZ+QHoP5jlJM3HrM5/WPBnXk5pt/wc0JD/lCz9yhFJv2muRPLnrb5Q7Ns65UfELpYKe/uY2H8QUojzEAmuZ6M3SQyqly6wq1sWtGLg9kHczL2OIZ8U035wzvGYk+HZpqPsuRn5/P1Aa1bTJGkx8NLVoZ3jMSdUKrY/SKQx6vB6LNTB2kcI6Bhas34M/DnqSysNEylvTGgxJ6fOLeZtGVciJjgiRKWmjGJg38+YSU7wH5vgGArq0aBHxPgbnkFpWiQ4TZVhiHh3yhd+6Qi82VK/cysQsA/jH4djzeNZzavGbUJ2pln0jb7G9u42F8AepjTMtcb4YOkjnVXeNPyTtUv7U2K5frXQfzMrZ4RrzptgByJRaUHuN/7733MrMBoLv1uO0d3ZGSfd60Mk09Wjckoo2WT7RCqsxSuD0Mz/frYXoJPRJlm/T6xNnmT6cvwmYDJArjPVCUtJhdakQvWnyiZy5Uw2p9I/BPsGwvNztfAMplp2rXVN4c6R2bNHQo2dXcXot4W+4Y1cJyvvHXlrsWM0th+rPTac/J81c8fnZiRpyo2RxIXzpjphl6Mm1XD/7Wwe7t8zB3AXyXeBXbyy2I2mP8165dy9QWWluPY1Nz8cLKX00t5UNKG2ufuEO6JBJNLSxLYwSiIzY1F0Nnpfi84Ta73JaSlqTjhR622mzqW9jMJlCfBDK+eS2bJgicYCkZZma+cOIdHwBQBWDorBTNMUZDh7ddznPSo1ccorpOMKqF5Vzsb25zajG7XKI/O/3ZZ0acKNmcdLzQUF/600KrXS2o+cnbR1+t2Em8fb2YPa79IUqGwVolXvw9xr+8vByhoaGm2EWqnAFvZZqMajPTJ6T7kYUWFqUx9OqQ68sQAPGjHkC3iIbkDdSBnBYle/d+0o/bN5YkfKJ3fNMYa1bKJ8FAsJUMMytfyPHT6YsYIvNBo5YYo6kj31GKtJyLrgda6rVNL0a0mDUXK81t5eXluFBWxc0aK9AypWbGibvNAAz3pVYtpNvVg7efZMe1Ddg71rw1Bqk1rygZFqRoKcfhjb9SA5MnTyZpomZIljOgXV5Db78bLa1klk9o9CMLLSxKWenVkXbqok9fVgG4eq2KnFEBIqdFzvdVANflsCZPnqwrNkmMb5JjzWl7AacPqgt2gqVkmFn5Qo4r1yrh/bWMWoy5xy9NHeH2MEDmycq0ynAZ0WLGXOzcXiv3YeLkyZO5KpcYaJlSmuPLXx5yt5lEX2rV4mwXANOSee5tu2/79xnXkrlrDJ7GtRLiTLdJBPr4f3/nYMaNG0fLZFVIljOgef7JjBJKZvmERj+apYU0enTEpuZi7NojPq/zcgZYTosVzyy3H/gn16fUWmKTJ40eZYyu8ZPgbyaC5Uw3T3Osnhjzza1/omYX6znZiE9Ylwvzt8YZN24c8h2l3Mydcmgp50grTvSuEUnkIb3rEdYl8+SQHdegN661wNOaQAnxTbcJGHn8v79zMFFRUdTsVoJ0OQOnRtv/wpnUeUuzSiiZ4ROAzrlVs7SQRqsO55jxzm8hHJ2PltNitTPL+Y5SjF17WFds8qJRbl4RCAKFpzlWa4zJxcDYtYep5FYz5mTiPqFYLszfGicqKoqbuVMOreUcacRJIGtEEn2pdz3CumSeViRaA1sjPI9rJ+KbbhMw+vh/tXIKf/7zn0mb6xca5QyG94xEx/pVKK1ej9h5S7PKLpjhEyckyywB5mohiVYdSuVXpj3fHU90a0nYqsBQ0kLa9zS5UVLH5vGaltjkQaPSGBGwJVhKhvE2x2qJMbkYkGBjWhKL5pxsxCdmlwvznkedWniYO+XQWs6RRpwEukY02pdG1yO0S+Yp2eJrCp2Y1wOv49qJ+KbbBJxbINzRuwVC6Szili1bSJjoF/czLyT0yN17165dRM/2krZTK3p9EshZfzVInVvNd5Ri9tqd1HcGONsi2QfeaPWJ0pjp0cach6fJ9YualkB8T7vv5bixVc0zhcvFppxtLJ4BoIbcGBGwJ1i2l7PK4U60xLu/GJOLARskqiWx3KE9JxvxiZy9IZS2l2tZ47hroTV3GskhWtdpNOJEa9uk85DR9QjrN9xKttCKeb2YvSZQQ7zpNgGaWyC6du1q+B7+8H4kf9LxQmJ63O89LacZ0cf9m7X1RI9PeC134LRr6W+NqNvFog+0+oSn7UpK/UIy5s0af+H2MLx5d33VfuY1NuTGiIA9wVIyjEUOd0IqpuRi4M2761OZJ80ohWjEJ67jcm7TgiTd0EEaLX1De3wZHVNacy4NHVrappGH9KxHhnZv5fHakO4tTVmPyNnSJ7IWl290eUJsLzcJWlsgLly4QOQ+SiideUke2xfJY/sa0uN9bwk37t2nQ1Ni/WPG1hOtPlHqW5L6A4GlXaza0hMnPGxXUusXUjFv9vjrbi9VnEPMts0f7mOkcc3r6DjFbIsEVoV2DndCOqa858nD+5MIWyx/ntsmAX06NCXeljtGfdKnQ1OPc9w01jZa+4bm+CI1prTkXFo61NqmlYf0rBHjD/3m8dq6Q3n4YGBH5nlQzpY9ueXId5RykZN5RXzTbSIkt/06t7pcuXKFkHXy+DvzYkQPq8f9s956otUngehnsRWYZRkGVm3pjROztyup9YuSFr1jg0Xfq9l05coVxX62QikQZ9nEU0X82CSwHrRzuBMaMeUev1euXCGen5TKb6XlXCRyfyWM+kTu/Cvp+UtraTJS+UKrDYHoVCt55oRmnLDOQ1q05DtKmZcJU8OKZUl5QHzTbXG8yxuMub+V/z8yAM1H8lvhcf+B0KlTJ03X6dXPqvwZS7+wakurT3hBrV/sMloCGRu0+96fTWo+scLc4NR3vUwsOgSBw2puoh1Tp6q1wgc6SgBqQc5mAHh71SFcuXadWvlPoz5hUTZMqz/ltJBaS5AYU1ptMSOH04oZf1p4KRPmjlIsHv6t2FVLXOCL+KbbwshtdZm2r5Dqt540z7h639sGibvH/QfCDz/8oOk6PX3LsvwZy3PNrNrS6hNeUOsXby2Bjg2afa/FJjWf8HS2Xg61Ui4CgR5YzU20433avkLi+clps/fClXb5Tyo+ITxXaPUnqXxhxAYl9NhiRg6nFTNqWngtExZuD8PHj/l+WDBpSybTh7BaDfFNt4VhWabDHZpnXD3ORoZWocMtdM9qseCVV17RfK3WvmVd/sxpV0ZuIe6IpHuOlsUZaj0+4QWlfvHWYmRs0Op7LTb58wkPZ+uVEGXDBKRgOTfRjPdASgBqYXjPSNQJrY7RKw5Rub8cRn3CqmyYFn+SzBeB2qCEHlvMyuE0YkZNC09lwrzpcovd5zUWZXitjPim28IoPbK/ds0Q6ud8aZ5xdd579eK5RO5nRgkkd6ZNm6bLDi19a0b5s3B7GPZ9v0STz432Oe0z1E6f0IZF+TdvLUbHhlrfB6pHi01afGLG2XotmkXZMAEpWM1NTmjElNYSgIES0TDM42ngpO/vjVGfGJ2T9cy7/vxJOl8EYoMSsuXVANSu6ftWhXWcuOPUB4BIflfTorVMmFmlPs0ow2tlbJIk3fSfz5eUlMBut8PhcKB+/fpmm6OL2NRcfBp3FJWShGo2G4Z0b4n4Q79RP+drFVidezbDDm/f/+vpzlz4mpc+Nxsz+4HG2DCqh9fxqoYezU59FWVXcHrqMEvmEyvizN8LE47i1b53mm2O4H/Qine5861WmE/eX52OtQd/f9rzM3e3Qsywu/z+HYs8wtPc7G6LEx7XESzzuz//mLnWCHRc8wzN94TiTTes/aYbuPEJV875q6hdMwRDZu712NZVzWZD8ti+ltzqERUVhXHjxgX89/mOUvT+34NcnJjRH598ORGxpZ2p2OH0Pavttv58wkuf+8Po2PIHy35Q0kJybJDSo2YTbZ/oJRDN+Y5S/HzyLB7p3tay+cRqOPN3m3fXIOXzwVzNM4HAWxwESlRUFF4b8z7R/CQXkyEA4kc9gG4RDQ3fXwmz1iI08giLfGGUn05fxJBZKR41x711mxknpP2iRYuSf8xcc1llvacXmu8JxfbyIMC51eXKtUrFc1RWZOTIkYb+npcyQw8/OYyaHay32/rzCS997g+jY8sfLPtBSQvJsUFKj5pNtH2il0A0h9vDcO+tjShbJpCDx3kmEHiLg0AZOXIk8fykVKbo6rUqIvdXwqy1CI08wiJfGOXKtUp4fx3ordvMOCHtFy1aeCynaZX1Hk+IN90GMfu8sDty56iUzsNYgZUrV7r+P5B+5uW8yaGkbap28DSG/OHuEzn89TkvWleuXEnVFq1jj4QN/nxCAhaxRNsnelHSzOKZGQL9BMtZQhbxTBq5uCWtI99RiqLL5abkdKNa6tSsFtAZdCPzrtJcaoXxpUW3mToC9acSgWhx+rdOzWqmrXN5WWNbCfH0cgPwdnY13B6GUfc1wuz/FrvOw1QBGDorxXTbAuHBBx8EEHg/O8s7eJ+FYf1J7uN9H0Db8gaydvA2hvzh9IkSan3Ok9bSlt1d26Jo2KJl7JHqD38+IQGLWKLtE73IaR7SvSWGzkrhxkbB73z25O1cfEtnFBbxTBKleYykDvc2bLhR41qS2JVMMqLFabv3Vmktdgc676rlFiuMr6TjhR79ZbPBR7dZOoz4Uwm9Wrz9O7R7K6w7lMd8nRtuD8PQ7q08znQP6d4yKOZhWljqK9AJEybAZrPhnXfecb1WVlaGUaNGoXHjxqhbty6eeeYZnD17lrotLOsk66FDtfOIG9nL41M4XmzTS05OjuF+Ht4zEslj+2LlG/cjeWxfUxbIOTk5snbwOobUyMnJ8XsN71rzHaWYeeACdVvUxh7J/tDiExLQjCVWPtGLu+a4kb1cD6nkyUYrQTOH976tCUFLzYNVPJNAbR4jpcO7DQmATQJmvtidWU4PVItcjeUQAHEje2m2W++86y+38D6+nPa779m0SUCfDp7lY83QQcKfcujRIuffdYfyEDeyF/N1br6jFPGHfvN4bd2hPJETVbDMm+7U1FTMnTsXXbt29Xj93XffxYYNG7BmzRrs3r0beXl5ePrpp6nbw+tZhmrVqmk6D2MFqlWrpruf5bZUmX1WqVq1arJ2sBxDpLbtOrX4w0yt/lCrIRsIan3L4hyWVp+QgFYssfSJXtyfmcHLGLYitHN4blFwLPRYxrNR1OYxUjqUznE3qhPKLKcHqoXUGXT3edff3OYvt7hrITFPkj4SpNRn3vOsGXFC65kCerSknboo69+r16qYr3N5WtdZBUtsL798+TJeeuklzJ8/H1FRUa7XHQ4HFixYgBUrVqBfv34AgEWLFuH222/H/v37cf/991OzyXmWwfupfWafZQgPD0c4p7bpRa8WnrYvuxMeHi77OqsxRLJflLT4g6d4ufHsA3h8kh6oLYH2Lcn+CNQnPMGDT7TYyMsYthoscnhk4+DY0mileJaLW5sNaNOkNkIJ6VBrgxUk8x4AHP6t2FXnWQ9a5jZ/85RTC4l5ksZcq3WeNSNOaI1FrVpiU3Mxdu0Rn9d5Wkuxjk2rYYlvukeNGoXBgwdjwIABHq+npaWhoqLC4/VOnTohMjIS+/btU7xfeXk5SkpKPP7pxXnWptr/9nGbdV7Ym9TUVG5t04seLTxtX/YmNTVV9nUWfiLdL0pa/MHTmAy3h2FQkwuGbTHStyT7I1Cf8AQPPtFiIy9j2GqQzOEk8jfPWD6e/xd7VHUwLnRrJO99/Fgnn9cnbcnUPSdpndv8zVOpqalE5klac63WeZabOCEwFrVokdt2D9z4sIOrPMQ4Nq0G92+6V61ahYMHDyI6OtrndwUFBahZsyYaNGjg8Xrz5s1RUFCgeM/o6GjY7XbXv4iICADAiRMnMGnSJJSXl7s+jY+KikJeXh4WLFiA1NRUbNu2DXFxccjIyMDZfeuwZVRPPF4rC8lj+yJr2xJcuHABM2fOxOHDh7F+/Xps2rQJBw8exNy5c1FYWOhx36tXryImJgaZmZlYvXo1du7ciZSUFCxevBinT5/2uLayshLR0dE4deoUli5diuTkZCQmJmLVqlXIysrC5MmTUVZW5jobkrVtCeL/3BkvtzyPmY81gr0oA/Hx8Th69CimT58Oh8Phcf/i4mLMmDEDR44cwbp167B582akpaVh3rx5OHv2rMe1paWliImJQVZWFmJjY5GQkIC9e/diyZIlyM3Nxfjx41FVVYWoqChUVVVh/PjxyM3NxZIlS7B3714kJCQgNjYWWVlZiImJQWlpqcf9z549i3nz5qFdu3bYvHkzQn87iH8PCcewJvnY/FYPZG1b4rrW4XBg+vTp2JX6s+w2l6+mzHVdW1ZWhsmTJyMrKwurVq1CYmIikpOTsXTpUpw6dQrR0dGorKz0sOX06dNYvHgxUlJSsHPnTqxevRqZmZmIiYnB1atXPa4tLCzE3LlzcfDgQWzatAnr16/H4cOHcfHiRVy4cMHj2pKSEkybNg1d6lzG37uV4b27QjDzsUa4fHgH8vLyPK4tLy/HpEmTkJ2djZUrVyIxMRF79uzBsmXLkJOTgwkTJuD69esef3PmzBksWrQIm5N+9Nsv58+fx5w5c5Ceno6NGzdiw4YNSE9Px+zZs1FUVORx30cffRRTp05FRkYG1q5di+3bt+PAgQNYuHChj90VFRWYOHEiTpw4geXLlyO8NAcxD9fGa20vY8UL7ZCTsBIVFRU+sbZw4UIcOHAA27dvx9q1a5GRkYGpU6fi0qVLHtcWFRVh9uzZSE9Px4YNG7Bx40akp6djzpw5OH/+vMe1ly9fxpQpU3Ds2DGsWbMGfVvXwrRH7RgRcRFrRnTyGFPXr1/HhAkTkJOTg2XLlmHPnj1ITEzEypUrkZ2d7ZojvpoyV7Zv12xJdM0R06ZNQ0lJiYctzjni9tBifHb3dfytCzB7cFMUH9wS0Bzx9NNP65oj3O9fUFCA+fPnIzU1FVu3bjV1jnijf2e8c9sF/L1XHUx8MBQ4sc/vHJGWlobNmzdj3bp1OHLkCKbMXy7rkynzl+Ho0aOIj4/H1q1bkZqaivnz56OgoMDjvv7miBM/LMfuDx/ymPO954i4uDgIfod0DlfK3wd+ztaVv9Vi06z87R7PPMWmUv6eNGuxzxpbAjBjcawrfztjc8aMGSguLvawxZm/1WLzxtET3zbW/ZDCJH/PnDkTffv2lc3fGRkZiIuLw7Zt25CamooFCxb45MFOzX2/9auUJMxf+b3f/L1//37s2LEDa9asQdLBY7Jz20/Z+T75u2ONC/hLyzOYO/x2DAs7guE9IxEVFYVLly6hsLAQiWkZftcF3vk7KSkJSUlJWL58OU6cOIHo6Qtk7zF76XeG83f/trUxLOwIVr5xP4aFHcHg2xt55O8dO3YgMjISixYtwpkzZzzuqzV/BzJHfDVlruxY3LEv3dAckZOT43eOmDBzoU9/A8BTzS7gVpw1ZY5Q6o/4Hcma1vje+TvQOcJ5Lak1flZWlm9HE8ImSd6nf/nh9OnTuOeee7Bjxw7XObCHH34Yd911F6ZOnYoVK1bg1VdfRXl5ucff3Xvvvejbty8mTpwoe9/y8nKPvykpKUFERASVQuisiYqKwrhx41w/5ztKcfL8FbRtUoefT8I0okdLvqPU9eRjJ9VsNiSP7ctMt5J93jpYQrpfWGhhMWaN6sh3lOLHnAv426p008acs582LF+A6M8+pt4eKWjGCYt5wN/4LCkpgd1uD4p8YhQaOVwpfyf/nIPed7SmK4gBZuYLvajF24LpMUR0qLUBgMn6xohP5OwPsQF7x/bTZbPeuU1tnn1tzPuG50mz51oz4oSWZi1afjp9EUNmpfg8NZ3lGtcbHtbdNKCZw7l+071u3ToMHTrU4yEDlZWVsNlsCAkJwbZt2zBgwABcvHjR45Py1q1b45133sG7776rqZ1gXSTxesY5ELRoiU3N9SmtwUovz31tZr/ohed+dOJdvgZe5WtY2GuFfpKDhd00x7sW+4M1nwQCixzu7O/W767GxBfus0QcBBMs8otcGwAsMwfGpuZirFuZKRuACc8EdoZaS1+zWi+ZPdeagRnrKfe+cMLDWs55xtxpls0GTODET0a4ad90X7p0CadOnfJ47dVXX0WnTp3w8ccfIyIiAk2bNsXKlSvxzDPPAAAyMzPRqVMn7Nu3T/NDWIJpkeT8xCwYPoEKREu+oxQ556+iTZPaTL/hVrOPh28uSPULTS0sx2ygOmS/tQAw/cXuuLt1Q2bfcFsxtlnGCY15QGu/B1M+MQqLHO7s74h3VqNGrTrcx4E/eMgXepGLN9I63NsAwHQOJLEz6oHoBJ8HRQZir7+5Tc88S2KeNGuuNXsHIUnNalqU1hzxox5At4iGhtsOFDm7AAn7Pulv6fkXoJvDuX56eb169dC5c2eP1+rUqYPGjRu7Xn/ttdfw3nvvoVGjRqhfvz7GjBmDXr16UX1yuTu8bd9+7733AKg/yp8HO7UQiJZwe5iu7VEkfOfPPqcOM5Hrl0D009TCcswGqoOH8jX+ynTwNB+5QzpO1MavnnlAK8Ewp7KGdQ4PBn/wkC/0IhdvpHW4l5+8cOUa01g0qkXuXHqg9vqb2/TMsyTmSbPmWlZxIpdnSGtW00KrTJlR5OwCbJaff2nD/YPU/DFlyhQ88cQTeOaZZ9CnTx+0aNGC2YNsYlNz0XtCAl6cfwC9JyQgNjWXSbtqzJ49G8DvZRfcsVp5G5paSPrOn31OHTwRqH6aWo6ccfi8RmvMBqqDh7hSsuHwb8XczUfukIwTM+ZeHnwfjJDM4cHgDx7zRSCQ1uEe82NWHIJXKFL1vVEtztJK7tAqrSQ3TwE3ypQB1hhfWvqLhQ5WeUZNC8uxowe59ZoNkul28Y7l3nQnJiZi6tSprp9r1aqFmTNn4sKFC7hy5Qri4uLQokUL6nbwWqLqiSeeABAc5W1oaSHtO3/2OXXwghH9tLTkO0oxcesxn9c/GtSRypgNVAcPceVtQ4gN+Oixjpi45Rh385E7pOLErLmXB98HAzRzOK35giW85YtAIanDO+adX7A531zSjkUqPqF0sNNfmTLLji+v/qKtg2We0a3F5EPBSuu11+5pYvn5lzZcby/nGV63Gv7000/o2LEjAGB4z0j06dCU+RlnUtDSQsN3ava56+ABI/ppaZHfqgR0bdWAeFuAMR08xJW7DUf2JaDzLXYu5yNvSMSJmXMvD74XKENrvmAJb/kiUEjqkIt5CcD057ujcd1Q6rFoVItS2TNac1aXW+w+rznnyNMWGF9a+ot2nLDMM2paWI8dLSit16o5zrA3xmKIN90B4tzC4/2gB9ZbK7zPmzRu3Njj9zTO27DCXQvJs/O0fOfs63xHKVKyzyv6hARG+sOIfhpalGwKAVB0pRz5jlLiY9ioDu+4MuPZDk4bruY0Uuy/2jX528ykNCdp9YnW8UvLJ1aeU4OZYNhaDtCbY1nTuHFjYjGoFPM92rB5eKVRn7Cen9XmyKsWGF9a5njaccJyja+mRWnsmDnXKfXNbS0amGaTVeBvRWYReNhqKHfeJCwseBaDTi2kz9XQ9B0LnxjtDyP6aY0vb5tsuPFp7ugVh6icpSKpw+xnO4SFhfn0H3DjYStDZ6Vwd7ZbCa0+0TJ+zfaJgD2fPXl7UHwYEiw5fP+5EGIxGG4Pw9DurTxeG9K9JTN/G/UJ6/lZrb+sML6Sjhd61KO22eAzx9PWocUGUqhpcY4d93Pd0v/sMwulvmnV0PofetJGvOk2wPCekUge2xcr37gfyWP7Mq1Np3TeJPXnX5nZQJvjx49TO1dDw3csfEKqPwLVf/z4cb0m67ZpxgvdYbP9fmyJxlkqUjp4eLaDU8vwnpGIG9kLbus6Ls92K6HHJ2rjlwefCNjzTI8Is00gAs05lhX5jlL8+6crxGIw31GK+EO/eby27lAes5gm4ROW87Naf/E+vpzzt/vuZZsE9OnQ1OM6mjq02kAKf1r6dGjqMW4kmJfT1PqG97HFA+JNt0HC7WHo1a4x80/Ylc6btO3SU/e9nNuhzQpgpbb79+/vtzySEUj7zp9PSPQzyf4IRH///v11t6MV51ZEeG1bAsj53EkgOuT8R3N8asVdy5VrlR6fQNOyh8acodcnSuOXB58IBIFCc46Vg0Ys3ziH6vnMZSMxaHZMk/IJq/lZrb9Yjy+9KJXI8u4jmjq02kAKf1rMHv/+bKkCkJZzkfuxxQPiTbdFUSpfs2/7el33MXMbpr+2//Of/1iqTI+aT0j1s9n98Z///IfKfVmXg9GrQ8l/ZvsD8NTCwh5acwapscWDTwTsWZt22mwTiEBrjpWDVizfKHPkuTI3EoP+ymDRhpRPWJXFVCszxXJ8BYLWElk0dbDOIf60sCyn6g+lWHx71SF8+u8NzO2xGuJNt0VROtcY/dnHmu9h5jZMLW2PGzeOi7PzWlGy9e2/vU2sn83uj3HjxhG/pxnlYPToUBurZvsD8NRC2x6acwapscWDTwTs+XLDL0FxhIDGHCsHzVgOt4dhwjNdicWgvzJYtCHhE9ZlMX34n59ZjS+iyDwpm6YO1jlETYvp48YLZ994v3mskoCUa22CYg6miXh6uYWRK18TFRWleTIys/SOlradWqxUpkfO1pFfTEWV1N7jOiP9bGZ/6BlfWjGjHAzJODF7fHproWkPzTmD5Ngy2ycC9vBYIi8QaMyxctDO/1nbliB57PvEYlCtDBZtn5PwCcuymGplphZMj+H6jbfWElm044RlDlHTwrqcqhaG94xEndDqGL3ikMfrwTIH00S86bY43uVrPvnkE81/S6MkgtYSIVradtdipTI93rZ++vYb2Do5kWi5kED6g0T5Fj3jSytmlIMhFSfufdqrnTmlWOS00IqXQOYMreOO9Niy0pwhME6wHCEwEgd65njaJZFeGfku0ZJ9rMtKukNibqpTs9qNB4QyKEGl5lsaOZwkWktksdDBIofkO0rx8PC/KI5hXsoTe9OjdUNfP8kcAxB4IraXBxmTJk3SfC3pLTR6zodpaVuPFp5ZOnea6eWcSJ3do+ETM7YDk4iTpOOFXJSlYhknen2lZ9wFS7wLzCFYSoYFGgd653japTMfnLSL6NzIuqykO0bnptjUXAydleLzhptWnlMrd8X7PKu1RBbvOrTgjNmXF6QqjmFej0vJlaW7rfoF0+3iHZskeT9L8eajpKQEdrsdDocD9evXN9scQ5w6dQqtW7fW9Tf5jlLDW2jyHaXoPSHB59O45LF9Ve+p1nYgWnjEqeOn0xcxRCbx+usjowTqGzlo+oTEONSK0TgBQKxPjWJGnGjxld5xFyzxHkz5xAoEW38HOjcFOh+RnndJ5hul+6flXMTbqw4xm3+NzE1y/RECIH7UA+gW0ZCMgRra2/tJP4Tbwywxz2oZQ1bQoYbeOGG5PtKC7DizAXvH9uPCPiPQzCnim27KsC7HlZSUpPtvSJTOCrSkgVrbgWjhEacOUuVC9I4prb7Rcl+aPmFZfk+PDme/AHDZx1MJj0B9YmRu0uIrvX1Ea2yZWRJRINBLIHFgZD5iVTqTxNzIsqykO0bmJqUSS1evVRkzSoZ8Ryk2Hs5TLXdlhXWVljHEgw4juUVvnITbw9CmSW2cPH+Fi1wmO64lemXVggVxppsisam5rqeDhtiA6Ke7YHjPSKpttm3blur9FdulcO7ELC2kceog0UeBjCkt7Wq9b7D5xB9K/cLTOatAfMJibtLbRzTGlhlzsMAc1qadxqt97zTbDMMEEgdczUeUbHGPZRt+315Osg0ljMxNcv0B3Ch3RvI5IO79441731ghhzvLhrlL8S4bZrYOo7lFb5zwlssUx/UZsuM62BDfdFPCrHJc169fp3p/JWicOzFLC2mcOoz2UaBjyl+7eu4bbD5Rg/dSYU70+oTV3KS3j0iPLTNLIgrYEywlwwKJA57mI++SQiRsMaOspDtG5iYW5c68+8cd776xbA730mamDhK5RU/M8pjLwu1h+HiQzLjeyqaMn1UR33RTwqxyXAUFBdTu7Q/SJRbM1EISdx1G+sjImFJrV899g9EnSvBeKsyJXp+wnJv09BHpsWVmSUQBe4LFt4HGAS/zkdOW4l/2oWvvAURsMaOspDtG5yba5c6Uykr9Y/DteLxruEcbVsjhWsqGmamDVG5xxuzC1Rvx52FPKP4tr7msSyvzyvhZFfGmmxJmbffq0aOH6u9JlI1Sg2SJBW8ttG3Xgx5bvHUE2kdGx5Rcu/mOUhRdLtd8X3/jyypo0aFUusS91BvtkiJaxplen7Cem7T2kVMHqTjnacutgD7B4lsjcyxPZfL69bob7QltM1Wai2mWlXTHaN6jPRcp9c89Mv1DO4eTmL+19JeZaxGS/gy3h2HYw3ep9hWvuYxXu3hGbC+nhFnbvdatW6f4O1Jlo1jhroUn2/XaouYTPdAq8TZmZTok6caZKX/3JaXFbLTo8O5vgG2pN63jTK9PeNqK6s66deuIxjmvOgV0CJaSYTfTHKsVrWWkaGFUi1oJLxLoyVU0xxep+VuuHNWQ7i09+svMOCGdW/xpoT1+AsXbLkDiwi6eESXDQPfx8Kwf819WVoZatWrJ2sFLiSOtOLXwZHsgtij5xIgNNEq8hQCY/mJ33N1a+dsD0lrMQo8OM0q96RlngfqEtxIkOWeL0W/qXuJxzlpnsJWw4h1nf2fmFqBDRHOzzTHMzTjHasHMdYARLf5KeJFES66iNb5I+kfLvXiIE1K5RU0Ly/GjBzm7bABSTLaLBKJkmIWRK8dBs4TN119/Lfu6nvIErEvsKLXn1GJWeSY5uwKxRckngaKnxItS3yqVMWlUJ1T1vqS1mIUeHaRKvelBzzgL1Cdq48iMMluTZi+mEucsS9EJzCO3KDge3kN6jjWrZJ5eHf7sNLNMoxGfKOXatJyLxoySQUuuopXDSfpHy714WIuQyi1qWpTGj9mludJOXZR9zoLZdvGOONPNGNqP/R83bpzs61rPXrAuS6DWnlOLGedGSJaKUvIJbdT6NtA+NUsLafToMGP86WmTtE/MKk3yj3ffxFaZbzfE+TCBFo7mF2PAXWZbYRyS8WxmmSE9OrTYaeb5USM+USqt9PaqQ7hy7TpRf2gpT0Yrh5P0z5EzDp/XvO8VLGsRQF2LlvJprIlNzcXYtUd8Xhf52j/im26GsHjsf1RUlOzrWs6gsC5L4K89pxbWZzNJl4pS8glN/PVtoH1qhhYa6NFhxtlgPW2S9ImZpUkWTI8RZ7AFAfPtjl+DolQNqXg2u8yQVh1a7TTzGQ1GfOJdQs0JDX9oKU9GK4eT8k++oxQTtx7zef2jQR097hUsaxEgAC0mHgp2xqu3CSE24IGaOSJf+0F8080QFo/9f/311xV/56+kCOuyBP7ac9fCshwK6VJRaj6hhRZfBtKnZmihgV4dZpTj0domSZ+YWZrk9ddfR4sWLbgpeySwFsFSqoZUPJtdZkirDj12mlUWzahPhveMRJ3Q6hi94pDH6zT84a88Gc0cTsI/SuXPurZq4PFzsKxFAHUtWsqnsUTJP9Oe7457mgdHdRuaiG+6GeA8q1SnZjWE2Dx/R3o7xvL4TarnotTOoDi3B9G0T097GzZs8DjnxepsppZ+8GeLu90bNmygaa4sWn2pt0+NaDHrbKEcgeggcZaeRpskxxfrOcAdpw6Scc7TmBPQJVi2NpKKZzNjGdCuQ6udzlgGwPwZDSR80qN1Qyb+kOvPEMBjXUUTI/O3ewlTd+T6yYx1lTskc4uaFn/+ZI2SPRGNwkz3iRUQb7op415CYeisFAzt3ora9qjY1FzMONUi4HINrLdv+WuvyN7RlDJhRvvBu2xGkb0jTXNloeXLu+66K6C/46nkGxC4Di2w1kpSi5mlSUj7hLcxJ6BLsJQMIxUHZpfM06pDi51mxzIJn2gpg0UCf+XVaOY+I+gtYWqmDtLjUU2L2eXylOyRK09nxlrXanC9vXz27NmYPXs2cnJyAAB33nknPvvsMwwaNAjAjcfsv//++1i1ahXKy8sxcOBAzJo1C82b81E2RO6s0rpDeYgb2QtXr1UR3R7lfc7CeV6oT4emutpgvX1Lqb18RynmHrxkWA9pu/wh5/N5By9hxMBS5gtCGr4sKirS/TdKZ/ZY+VKOQHRowQytpLTIndWySUCfDk2J3N8fJH3C45i7GWGZw3vf1oSk6aZBMg7M2o4N6NOhZicPsUzCJ/mOUsQf+s3jtXWH8vDBwI7EdfTp0BQ2G1wfoEr4vc9o5T4jePtYAhAiATNUSpiapYPGePSnRc2fZuSz4T0j0alFPY/ydGauda0E199033LLLZgwYQLS0tLw448/ol+/fnjqqafw888/AwDeffddbNiwAWvWrMHu3buRl5eHp59+2mSrf0fprNLVa1WatyYbbSuQx/fT3MYtp02uPblzLKzKg6jZ5Q/eyjuQ3hJdWqp/K1WgY5Pm1uBAdGiBZVkbV/8Uk9Fi9th194lR37MuLyS2scvDMocHS8kw0nOTWSXznDq0xoaSnVpimXb8kfCJXIklGnNSvqMUGw/nKbZFK/cZQSn3SNKN38n51SwdNHKLPy3+2jQj/8iVp+OhlBnvcP1N95NPPunx8/jx4zF79mzs378ft9xyCxYsWIAVK1agX79+AIBFixbh9ttvx/79+3H//febYbIHgZRQCLTEh5nlNLSiR5tcmQTe9MghV+oixOTyDlrQ6pv27dvrvjfLONBKIDq0wCoO3fvHhpqo3S7XcP+YPYc4fULC9yy1eNv7j0fbEG/DqrDM4cFSMozW3MSa9u3bM4llFmXRjPqEVYkl975Qaqseh+NLzsc23CirpuRXs+JESzkzvfjTohYDZpUF1FKeTuAL0W+6S0pKNP/TS2VlJVatWoUrV66gV69eSEtLQ0VFBQYMGOC6plOnToiMjMS+fftU71VeXm7YHi3oPVNlpMTH7+c+JE1tsUavtnB7GB5pUGip8kFKpS7+UK+Ie7u1+mbXrl26788yDrQSiA4tsDhHKbcVj0T/mH0GdNeuXcR8z0qLnL1fbviFaBsssUIOV8rfwVIyjNbcxJr1PyRRj2VWZdGM+EStxBLJOcm7L9xx7zMex5e3j51vTNT8aoYOreXM9OJPi1IMADCtLKCW8nQCX4i+6W7QoAEaNmyo+s95jVaOHDmCunXrIjQ0FH/9618RHx+PO+64AwUFBahZsyYaNGjgcX3z5s1RUFCges/o6GjY7XbXv4iICADAiRMnMGnSJJSXl7vq5kVFRSEvLw8LFixAamoqtm3bhri4OGRkZGDatGkoKSnxuPbChQuYOXMmDh8+jPXr16PuuSOYPbgpXmxRiO/f6IasbUtc1169ehUxMTHIzMzE6tWrEbd9j+wWkq+mzEVlZSWio6Nx6tQpLF26FMnJyUhMTMSqVauQlZWFyZMn46kuzTCk2kGsfON+DAs7gociamL+/PlITU3F1q1bER8fj6NHj2L69OlwOBwedhcXF2PGjBk4cuQI1q1bh82bNyMtLQ3z5s3D2bNnPa4tLS1FTEwMsrKyEBsbi4SEBOzduxdLlixBbm4uxo8fj6qqKkRFRaGqqgrjx4/HgYyTstomzVqM0tJSj/ufPXsW8+bNw0u92uLLeyWMuv06/j0kHIUH1qO4uNjjWofDgenTp+Po0aOIj4/H1q1bkZqaivnz56OgoMDj2rKyMkyePBlZWVlYtWoVEhMTkZycjKVLl+LUqVOIjo5GZWWlx9+cPn0aixcvRkpKCnbu3InVq1cjMzMTMTExuHr1qse16b/6bukCgEa4jAsXLnhcW1JSgmnTpiEjIwNxcXHYtm0bUlNTsWDBAuTl5XlcW15ejkmTJiE7OxsrV65EYmIi9uzZg2XLliEnJwcTJkzA9evXPf7mzJkzWLRoEfbv348dO3ZgzZo1OHbsGKZMmYLLly97XPtTtvxWtGkLV6KoqMjj2qFDh2Lq1KnIyMjA2rVrsX37dhw4cAALFy70sbuiogITJ07EiRMncP34HsQ8XBuf3BeG9zsWo2fj65g4cSIqKip8Ym3W0u9k7fnl9HmPa4uKijB79mykp6djw4YN2LhxI9LT0zFnzhycP+957eXLlzFlyhQcO3YMa9asQUREBPbv349FixbhzJkzHtdev34dEyZMQE5ODpYtW4Y9e/YgMTERK1euRHZ2tt85osGFX/D3bmWY8GgL/LnZSQzq2EB1jti0aRMOHjyIuXPnorCw0ONa7zli586d2Lj7v7L9c+LcJb9zRFlZmcf9CwoKPOaImmfSsGBISwxrkoctI+/xmK9ozxF9+/bF3BXxstqO512UnSPS0tKwefNmrFu3DkeOHMGMGTNcc8TwnpEYFnYE/36xM15rnoM7w0qIzxFfTZkra69VsUIOV8rflZKECTMWEM3femMzJSUFixcvxunTpz2u1ZK/nbH5pz/9STY2zczfubm5WLJkCfbu3YuEhATExsYiKysLMTExivm7UWRHxfWM81qt+Ttr2xLsfOcBDKmfg6XD20DKTkFiYiI27DqguO1Wb/4uLCzE3LlzcfDgQWzatAnr16/H4cOHMXPmTDz55JMB5+/j+cWy64LnWl3GfU2rDOfv8+fPY86cOfhh/2HZdu6rcQbJY/sia9sSXLp0CZcvX9adv5cvX46kpCQkJSVh+fLlOHHihGL+XrhwIQ4cOIDt27dj7dq1yMjIwNSpU3Hp0iXV/F3n7GHMfbI5Xmh+DlFPtJM9Xph08Eb+3rFjB26//XYq+VttjpCb7wEg7Oo5Q3PE2bNn/c4RuYmx2PnOA3i8VpbLnwePn5Ed/1PmL2MyR/y0y/dp5ZWShPgdyZrmCLX87bzWjDV+VlaWr5MJYZMkciuE3bt3a772oYce0nTdtWvXkJubC4fDge+++w7//ve/sXv3bqSnp+PVV19FeXm5x/X33nsv+vbti4kTJyres7y83OPvSkpKEBERAYfDgfr163tcm+8oxcnzV9C2SR3q3/jkO0rRe0KCzxaS5LF9AUCTHVFRURg3bhxVOwNBTZuSHl61KKGkcVjYEUR/9rF5hvlBj2+UfEIyTgIZK3oJdGyxng/k2mLRP2YQFRWF18a8b7o2PT6W84XtWilypjwnm094xwo5XCl/t3l3DVI+H8x1DGgZW1bLe068tX3y5UTElnamGsty8RcCYNqL3dFD4QFcgWDEJ6zma619YYXx9dPpix4P6QJ8+8wMHbR8GagWLf1Ek2Bdi5SUlMBut1PJ4UTfdLNgwIABaNeuHYYPH47+/fvj4sWLHp+Ut27dGu+88w7effddzfdU6mAzzkrEpubi07ijqJQk2S0kLM9skEZOmxV1qGFVjUbsphEnPPYjy/nAX1s89g8pzNQWiI+97R33aGv8uV9nS77pZgHpHO7M36MW7cGMV/5AyWrjmHX2kgVK2ljEsnsbziJGEvjq4/dXp2Ptwd+fXP7M3a0QM+wu4u1YoS/8IXcunaccx8qX/uCln3jpD5JY+k331atXkZubi2vXrnm83rVr14Du169fP0RGRuLbb79F06ZNsXLlSjzzzDMAgMzMTHTq1An79u3T9RAWuQ428xOcfEepq3QGAF128P4pprs2f/3IuxYlvDVaRYcW33hroRknesaKXvT6hOV8oLUtZ/+sX/5vrndSaMXdJzR9r4QRH7vbW8dWQS1hmwHvOdyZv3n+ppvEbiJe8bfDi0Us5ztKkZZz0fXgLXc7SMzRVvim2709tb5YMD2G2/Gl9G19/KgH0C3C80jLzfxNt55+oon4pls/1J5eXlhYiFdffRVbtmyR/X1lZaXfe3zyyScYNGgQIiMjcenSJaxYsQKJiYnYtm0b7HY7XnvtNbz33nto1KgR6tevjzFjxqBXr15Enlyu9oh+PYMpkO2o4fYw17Up2ed12TF69GjNttFESbe7Nn/408Jyq68evDXq8YmZmrT4xlsLqThRssfZhvvPJNAbJzR1am0rLecinujmG0u3v/0m0fb1QHK8uvtEzzxBCi0+1jKvlZRUMLOZJlbL4bTikQR65g9ecrhWlLT1e+p5AHRi2TsOw+1haFSX3hxtxCcscwcAv33B2/hy96VS6bCr16p8/s4MHbR8SWI9UgXg9IVSpm+6WY/tYIBane533nkHxcXFOHDgAMLCwrB161b85z//Qfv27bF+/XpN9zh37hz+9Kc/oWPHjujfv7/rIQePPPIIAGDKlCl44okn8Mwzz6BPnz5o0aIF4uLiiNjvfBy+O3rLAsSm5qL3hAS8OP8Aek9IQGxqLnU7li1bprsN0pDQDahrIdUGC7T6xAqavLWQiBMlaPaH3jihqVNLW8CN8ilyfWBWzJP2j9lzlz8fWyE+SWK1HM5zSUk984fZcaAXJW0/7tpMpT2lOKQ5RxvxidJ8fvi34sAN8oNaWSuexpe3L4+ccXAdJzTKhQFk1iOA8hqBFrT6I5ih9qY7ISEB33zzDe655x6EhISgdevWePnllzFp0iRER0druseCBQuQk5OD8vJynDt3Dj/88IMrWQNArVq1MHPmTFy4cAFXrlxBXFwcWrRoQcR+oyVnzCp9o/XhNrQgWcJDSQurMiGk0OITq2jy1kKrNBPt/tAbJyzLaTnb8p6clfrAjJin4R+z5y4eShPxhNVy+GdP3s7ttyt65g+z40AvStqe6E/+fL1aHNKco434hHVpJX9lrXgZX3K+nLQ1Ex8P6sRlnNAqFwYEvh7RukagAc3+CGaobS+/cuUKmjVrBgBo2LAhCgsL0aFDB3Tp0gUHDx6k1SxRhveMRJ8OTQM6j0Ry24UeO7Kzs9GlSxdd9ycJSd1KWqy2pUWLT6yiSU6LkThRgnZ/BBInNHSqtVUntDpGrzjk8bpcH5gR8zT8Y/bcBSj72CrxSRKr5fBnekSYbYIqWucPHuJAL3La1q1bR1yHvzikNUcb9UmXW+w+r7E8ngQAXVs1AMDP+FLyZddWDZA8ti93ceKvX40Q6HpE6xqBBjT7I5ih9qa7Y8eOyMzMRJs2bdCtWzfMnTsXbdq0wZw5cxAeHk6rWeJ4n0fSeobRuf3D+wEDgW670HouqmbNmqq/p31mmIRup41XpBrU2giUQPrPn08AczXpQUkL6XN7cv0RAhDrDy0+kYPlWeMerRtqGhOBajECjfGqVwetuUzOx1aJT5IESw7nCS3zhxnxTAJvbe46SMWqljikMUcb9QnL+cNfW7yMLyU7a9cM0TRWaOvwHrM0fahFi1wMaV0j0ID2Gi1Yoba9/G9/+xvy8/MBAJ9//jm2bNmCyMhITJs2Df/6179oNUsVPWf6WG5Hdad58+aKv2NxJtGobncbxx2ArI1m9W2g/afmEydmadKLFi0kcPaH+7ElCUDS8UIi92elwwhax4QZWmiMVz06WJ+vtkp8kiQYc7gVsMLcpAWnDpKxyuO6SgtJxws9ainbbKB6PGlo91Yerw3p3tLVFi/jS86XQ7q3xNBZKZrGCk0dcmOW5tjzp0UphszMS3LjrE/rWkGdE0lA7Zvul19+2fX/PXr0wKlTp3Ds2DFERkaiSZMmtJqlhtJZoj4dmioOMpbbUZ2kpaWhR48ePq8HYn+gBKrb20YJyjay7lsj/afkE2/MGC960aqFBH06NIXNBtdiRW086IWlDiNoGRNmaSE9XrXqYDmXuWOF+CSJ1XJ4gaM0KEq0WWVu8kdaWhpa3nYH8VjlaV2lBed85b4T1ybdyG80yHeUIv7Qbx6vrTuUhw8G3jhry9P4cvdl7ZohGDorRfNYoaVDLb/QGntqWvzlO7Pyktw4232q1PV8BYE81N50e1O7dm3cfffdrJojTiBn+swo//TUU0/Jvm5G2Qq999VrI8utvkb6T8kncrifIXX/mRe0aCE17mmOWT0+MRt/49yIFqO+IhmDWnWYeb6a5ZzDG7zn8NyiUnTg+1i3JmjMTWatRbJ1xKoeGwONw0D7wYhPlMo70Zqv/M2PvOU+py+VyuNuOpyPwV3DffqKlg61kp2N6t4YO73aNSbappoWLfnOjLwkZ5cEW1A/54QERN90v/fee/jqq69Qp04dvPfee6rXfvPNNySbpo7e8xyxqbmuT6dCbED0010wvGckdTvnz5+PcePG+bzetkkd2ADPT1vB1/kLnssPGDnPo+QTOcwaN1rxp4Wk/TTPUOnxCe8EqoW3saZVh9y4AG6U4CG9GLrZsHIOj2wcHAs90nOTmWuR18a8r2kOZ2GjkTaM+IT1fOWvPV5zn5LdUZt+wb82/+LjL1o65Oyw4UY5LlrjU00Lr/lObr1ug8TFep1nbJIkSf4v00bfvn0RHx+PBg0a4OGHH4bNJlNIDoDNZkNCQgKpZg1TUlICu90Oh8Ohuj0tNjUXn8YdRaUkuc5OyAVevqMUvSck+CSa5LF9TfsEKN9RigeiEzzfdNuAlLH9uPhUSq7PAOCTxzvhzT7tzDHKC63+DxQex40eaNhPu89vVqw+1ubuzkb0Fs9yJbzYrzWf8IgVc7iV+5s2PMS5vzmchY1m9wPr+Yrn+VEN97HiDUv73e0IwY0vq9wtYt2XvPnTCut1I9DMKUS/6d61a5fr/xMTE0nemgu0np0wc/tjVFSU7CdmJ89fgfc0Jkn0tjjpxQrlBwI9O6PkE2+sUJZITQsN+2mdV9LqEysQiBYex5oeHSxL8NxMBHsOtwIk5yYe1iL+5nAWNhptw6hPWM9Xau0tmB7Dbe5zjpVNh/MRtekXj9959xfNHO4+ZouulFMvy+VPC2/5Tmm9/lPCBqDPO8ztsRJUnl5eUVGB6tWr4+jRozRubyrh9jD0atdY9jxSSvZ55DtKXdtB3GG1Tfr999/3sMWJUZvk7kkSOftCbPxsf3fqByDrfzXef/99TdexGDdG/aimhZb97jFHahxq9QlJaMVQIFrMnKOU0KODR/uDiWDO4bxDcm4yey3iRGndBARuo5751Gg/GPUJKz84+6ROzWqK7ZmR+/QQbg/D4K7hfvuLpA65seQcs86yXGq2GMWfFt7ynex6HcCHb40wxR45aL9nCRQqb7pr1KiByMhIVFZW0rg9d3g/zj/peKFpj/EfFbOceGkBs0qNPVwnn4tvrYzqnzVrlqbraJd/IOFHNS1WsN+JVp+QgmYMBaKFxxJYenTwaH8wcbPlcJ4gOTeZGSc0857e+dRoPxj1ib8yXiRw75Ohs1IwtHsrWb2sc18gaOkvUjr8jSUWMeRPC4vxowdnn3iXdP1q/lpT7PGGdUlRPRA90+3OggULEBcXh6VLl6JRo0Y0miCGkf37ameFADB9jL+Wc0v5jlJdNrE+C+Vu3+VzZ9C+fXvibei1x6j+rKwsXTr0+kjrPUn4UYsWnu13otcnRqAdQ0a00PBVoASigyf7nQTLGWOr5PBg6W8nNOYmM+KEVt4zMp8G2g9GfUI7ByjdP25kL1y9VuWhl2XuCxQt/UVChx6/0Iwhf1rMfiaBVptCbMBek58TRaKvaOYU4t90JyUloaKiAjNmzEBSUhJatmyJjh074u677/b4Fyz4OyvkfLogi20OarY4UdvmFeg9SeLeZ2t2/2T61hAS+g8ePKirTb0+ksN7aw0pP2rRQsJ+b0iPQ70+MbJViXYM6dXiDg1fBYoeHUaOewjUsWoOL+BsG2GgGIlnJcyIcxp5L99Rio2H8wKeTwPtB6M+oZ0DlO5/9VqVj14a44s0WvqLhA49fgm3h6FNk9o4ef4K8XWpPy2s1+FakC2F97/nRJkJj33lDvE63X379kV+fj6GDBlC+tZc4q+sEctyHXJlwYye+6BZtkmJ3/ssDP+ekGBqKSMS+ps2bUrBMmXkxlyfDk2J+JG1Fiekx6EeHUZjmHYMmeUT0mjVwVups2DDqjn80SlJmPjCfZYfCzdbPGvFPe69ob0mMaqFdjlU2ZKwCs/EscL40qKHhA49uZlm3vGnhcdyuryWMjPjPYseiL/pdu5W//zzz0nfmkucZxu8S2I4H/rkniSqJODTuKPo06EplU+cw+1heL1bGBYeLvOxxcg9lfTRgHWf+YOE/tDQUIoWeqLUf8lj+xLxI0st7pAeh1p1kBiPtGPILJ+QRosO3uaHYMSqOTxYxsLNFM9a8Y57d1icUzeiJd9Riolbj/m8/tGgjnTHqcLBUcuOLy89JHRozc20846aFtPGjx/C7WH4+LFOPqXMJm3JxB+7mX/enNV7Fr0Qf9MNQLG2Z7CiVBLDjHIdERVnkDz2OaJnT2iVbZKDx1JGRvVnZ2ejd+/elKzzRK3/SPiRpRZvSI5DrTpIjUeaMWSmT0iiRQeP80MwYtUcHgxj4WaKZ60olSj6x+Db8XjXcOr+NqKFRTlU2ZKwkC8Ja4XxpUUPKR1acjPtvKOmhedyuryVMnPC8j2LXqi86X7llVf8fgoVFxdHo2nTCLeH+TjWjG0ODz/8sIct+Y5SnDx/BW2b1DH8jTeLgVunZjXYbDdqiDsxa2uId98Fqv/hhx8ma5gK/sacUT9q1UJq3HlDahxq1UEyhgOxXUs/shxfpJDTpUUH71vHggWr5vBgGAuk4pnWHKwVkvOSXNyHALinTUMm2oxoYTFnKbVRu2YIUrLP655nzUbLOpCkDn+5mbYP1bRoadusWOcxH7v3hZnb3JWgUjKsXr16sNvtqv9uBliUGvBm6dKlrv/n+bH5csSm5mLorBSfidaMrSEk+87dJ7ShPea0aLHCuNPqEzNi2InWfmQ5vkigpEuLDjP9cTNhxRweLGOBRDzzMAeTnJe84x4AqgAMnZXCRJsRLSzKPcnNi0O6t8TQWSkBzbNmonUdyHpdRdOHalr85TwzY923XyRTS5nxMO/5g3jJsJCQEBQUFKBZs2Ykb0sV2iVHWJbrqKqqQkhICJclBtSQLT8AIH7UA+gW0dB0W4z0ndMnLKE15vxpscq40+sT1iV39PSjGeMrUNR0Na8XqlkHj6XCnFi9hJXVcrizvzNzC9AhornZ5hjGaDzzMgfTmJd+On0RQ2TekNHWZkQLS38458XaNUMwdFaK4XmWNXrWgSzzHm0fatEil/PMjnWz26dli6VKhln1LBgJlMoK0SzX4d3mv/71LwDmPTY/0NJKsuUHAFy9VkWsDSO2yPWdVjucPmEJjTGX7yjF6C+nqerlvVyDE70+oVHGTQ09/WjG+AoUNV3+dLj3n9mlzmjPQWZi1RzegrMPXwLFaDzzkvtpzEtXrlXC+2uiSknCpsP5VGPRiBaW/nDOi1euVQY8z5qJnnUgSx20fahFi1zOM3u9lXbqIjfrPbP7QivUnl5+s2FGGRu5Nj/99FMAZpf60t8H8vb6lrxg0c9a+k6PHU6fWJnf9bbHVpUybjye8ZGDtU/0jls9/Wil8aWmS00HT2XCeLKFBjdrDucFo/HMS+6nMS8plSmK2vQL/rX5F2qxaESLYmmlM/RKK6mV3OI5X+gpQ8VSB+2YClSLmaXEYlNzMXbtEdPa98Yqa0/i33Tv2rULjRo1AgCMHj0aFy5cIN0EdyiVE6D5yatSm38f/zUA9mcfjfaBnL0P1Mz1sJdVP/vrO712REdHE7WPNXr0WuXMLUufBDJu9fSjlcaXmi4lHWbMr0rwZAstbsYczhNG45mX3O9ci5BE7my3E5qxaMQn4fYwfDyok8/rk7Zmsp03/ucfnvOFswyVN5O2+PYVSx20YyoQLWaWEnPGvPfHszZIpq33rLL2JP5Nd7t27VC9+o3brlixAh999BEaNWqELl26YPPmzYiIiCDdpOmYUcZGqc37Bzzh+tlqpb687a1wFBJvQytqfafXjv/7v/8jahtr9OrluVyDE5Y+CXTcau1Hq40vJV1KOngqE8aTLbS4GXM4T5CIZx5yv/tahCRObZsO5yNq0y8+7dKIRaM+6dKKbWkltZJbvOcLrWWoWOugGVOBaDGzlJhS2188Gmnqri8rrD2Jf9PdqVMntG7dGi+++CLKyspw+vRpAEBOTg4qKipIN8cFzm0N7tDc1pDvKEXR5XLZNnMzDnq8xursI6k+cLc3MTGRShtO/J3LVOo7vXZ467AaevU6SzbwOukByj6hcVbXyLhVGoPudrIYX6T7RU6Xkg7W86sSavMub1vYjHAz5nASkIoRUvFsdu53rkVozKnh9jAM7hru026IzJE0Ehj1Ces5TK093tcjcrbL+dUMHc6YAkB0TAeiRbafQGf8a237t+O+281ZY/bzXvxB/E13cXEx1qxZgx49eqCqqgqPP/44OnTogPLycmzbtg1nz54l3aTpsNzW4Hwk/piV6ZCkG+d03Nu8u1Nb4m1qgUYftGvXjlobRkoL6LXDW4fV0KPXCiUbAHmf0LKddGx423m6xi1E7NTaHi2fKsUJD9vG/M27vCb4QLgZc7hRSMaI1fKFUnze3akt1bnD2a77TnNJApKOFyr/UYAY9UnS8UKPB8DZbKA6b6iVuOJ9fGn1q1k6aIzpQLS4+sntNQl0xr9S294l/ObnNOB2zccLxEuGlZaWIizsxkTSsGFDpKWlIT8/HwMGDEDnzp3x888/IyIiApmZmX7vFR0djbi4OBw7dgxhYWF44IEHMHHiRHTs2NF1TVlZGd5//32sWrUK5eXlGDhwIGbNmoXmzbWXDiH1eHjaZWyUyilMf7E77m7dEOH2MCQkJKBfv37E29ZjI6k+UNJitA1SpQW02mG2T0iR7yhF/I5kDH3kD7J6eSof4Q9vn7CwnURsKM0Bez/px2zOoeVTf3FiVpkwLfOuO1YvGWa1HG52f5OOEavmC+/4/G7zTny0p4z6nPpAdILHVmoa85MRn7Ces5XadPbLL2n7uB9fWvxqRpzQyoeBajF7zWVWCT/aWKpkWIMGDXDffffhvffew7Vr11BaWorevXujevXqiI2NxcWLF7FgwQJN99q9ezdGjRqF/fv3Y8eOHaioqMCjjz6KK1euuK559913sWHDBqxZswa7d+9GXl4enn76adKyNEG7rJBSOYVGdUJdbRYW0v+USw25Pgh0e5mSFqP9rKW0gBabtdphtk9IEW4PQ+PKC4p6rVKyAfD1CQvbScwPSnMA6T52jn+WJUH8xYmWrfY00DLvBhM3cw4PBNJzh1XzhXd8Hs8jP3d4x7rc2WUa85MRn7Cas/216ewXK4wvLX5lrSPfUYqNh/Oo5EMtWuTynNlrLqUSfjyu+XiB+IPUfvvtN+zbtw8pKSm4fv06evTogZ49e+LatWs4ePAgbrnlFvzhD3/QdK+tW7d6/Lx48WI0a9YMaWlp6NOnDxwOBxYsWIAVK1a4PiVatGgRbr/9duzfvx/3338/aXlU8VeKRssj8e+++26WJvvFSHkdWlr89SPpkkC8+cQIalqsUrIB8NVhFdvl7CR9jtF9/NsAn9IztPolkDjhpYRgMCFyuD5Ij49gyRcP33MH/p19kli/yMV6nw5NmcSmEZ+ole+ihVopqSYWGF9aSmGxjBP3sefPrkDwp0Upz5mdm8wsWWZViH/T3aRJEzz55JOIjo5G7dq1kZqaijFjxsBms+GDDz6A3W7HQw89FNC9HY4bDnaWM0lLS0NFRQUGDBjguqZTp06IjIzEvn37FO9TXl6OkpISj39mo6UUjZazjevXr2dqtxpGy+vQ0qLWjzRKAvHkE6OoaeHh7K1WvHVYxXY5Ox+uk090u6b7+HfmcudDU2j2i9444aWEYLDBew7nLX+THh/Bki/27dxCrF+UYh0Ak9gk7hOihzo98VdKivfxpbUUFisd3mPPHVLjTU2LWp4zMzfJ+0liUrLMyhB/0+2N3W7HsGHDUKNGDSQkJODkyZMYOXKk7vtUVVXhnXfeQe/evdG5c2cAQEFBAWrWrIkGDRp4XNu8eXMUFBQo3is6Ohp2u931z1kC5cSJE5g0aRLKy8sRFRUFAIiKikJeXh4WLFiA1NRUbNu2DXFxccjIyMC0adNQUlLice2FCxcwc+ZMHD58GOvXr8emTZtw8OBBzJ07F4WFhR7XXr16FTExMcjMzMSi7zYpbhOJiopCZWUloqOjcX8zCe+2v4BP76+DyQ/VgpSdgqysLEyePBllZWWuBUhUVBQKCgowf/58pKamYuvWrYiPj8fRo0cxffp0OBwOD1uKi4sxY8YMHDlyBOvWrcPmzZuRlpaGefPm4ezZsx7XlpaWIiYmBllZWYiNjUVCQgL27t2LJUuWIDc3F+PHj0dVVRW+mjJXVlP8jmTExsYiKysLMTExKC0t9bj/2bNnMW/ePNx///3YvHkz1q1bhyNHjmDGjBkoLi72uNbhcGD69Ok4evQo4uPjsXXrVqSmpmL+/PkoKCjwuLasrAyTJ09GVlYWpOwUTH6oFj69vw7ebX8B9zeTEB0djexzl2Rt3rT7v9i5cydWr16NzMxMxMTE4OrVqx73LywsxNy5c3Hw4EFs2rQJ69evx+HDhxESEoILFy54XFtSUoJp06YhIyMDcXFx2LZtG1JTU7FgwQLk5eV5XFteXo5JkyYhOzsbK1euRGJiIvbs2YNly5YhJycHEyZMwPXr1z3+5syZM1i0aJFrW+eaNWtw7NgxTJkyBZcvX/a49vz585gzZw7S09OxceNGbNiwAenp6Zg9ezaKioo8rv2///s/TJ06FRkZGVi7di22b9+OAwcOYOHChcjLy0PWtiVIHtsXj9fKwq73H0ROwkqcOHECy5cvR1JSEpKSkrB8+XKcOHECEydOREVFhU+sLVy4EAcOHMD27duxdu1aZGRkYOrUqbh06ZLHtUVFRZg9ezbS09OxYcMGbNy4Eenp6ZgzZw7Onz/vce3ly5cxZcoUHDt2DGvWrEHHjh2xf/9+LFq0CGfOnEFUVBSG94zEsLAjWPbnnnihXgbua1qFZcuWYc+ePUhMTMTKlSuRnZ1t2hyxevVq7Ny5ExEVZ/D2recxbcitGBZ2BDPff8ljjjh16hSWLl2K5ORkJCYmYtWqVR5zhPv9veeIpfHbfMa/BOChmicx/4XOeL35KdxRy0FsjoiKikJVVRXGjx+PJ598EkuWLMHevXuRkJDgd46YvjhWNlaP5pwjMkesWrUKiYmJSE5OxrVju7Hq5Q54sk42dn/4ELK2LXH9zenTp7F48WKkpKRg586diIuLQzDBWw7nMX/bTu7HhD/UxLgH6uLtW8/jgRY2j2v1xObIkSO5yN/usZmbm6srNp35u17hUfzjrmv414BmeL35KQxsXz+g2FRaS2zYdUBXbAaSv2fOnInnn38+4Px9PL9YtnzX/JXfU8nfK9b/IPsG8aeEDbh06RKqqqoU87f7fSsqKjBx4kTm+XvawlWy9h/ft8OVv3fs2IF77rnHI38773v9+nVMmDABOTk5RPL3z6cKZe157W47Prv7OuqeO6Irf6ekpGDx4sU4ffq069qSkhLFOWLh6o2yY/+rKXNRUFCAkvRtmPlYI7zbLQTjupXjzrASJnPEiXOXZfrFhpCLpzXPEWlpadTW+O75e+nSpTh16hSio6NRWVnp8Tdyc0RWVpavwwlB/EFq7pw+fRqtWrVCSEgIOnfujC1btgRc4/Ott97Cli1bkJycjFtuufG03hUrVuDVV19FeXm5x7X33nsv+vbti4kTJ8req7y83ONvSkpKEBERwexBLM6SSm2b1HF9IkTqgQhRUVEYN24cEZuMovQAkWkvdkcPmQcQeROoFiPQeDCFHh00/EASM3xCA3cdvPe5P0hqMfPBLHrHltkPkVHC7Ad7kYTHHG52/qZNMM6xRlFaS8SPegDdIhoSaUMNI1pY2+5vXlTSwkse1PrgOVZxwiLPqGnhNc/J2WWDhJRP+ltyHeUOzRxO9U03KUaPHo3vv/8eSUlJaNv295JYCQkJ6N+/Py5evOjxSXnr1q3xzjvv4N1339V0f5aLJLUziLGpufg07igqJcm1TYRFoXma5yLdNTmLC0igd/6SBMHoB4E8wdTnpLSYNf4DgUdbg+lNNylo5nDR3zcH7rHuxCpzNmvb9c6LvOXB2NRcjF17xLVDwAZgwjPm2WR2nnl/dTrWHvzN9fMzd7dCzLC7mLUvh4+PbMAEC8SiFiz19HKSSJKE0aNHIz4+HgkJCR7JGgB69OiBGjVqYOfOna7XMjMzkZubi169erE21y/+ziAO7xmJ5LF9sfKN+5E8tm9Ag9e5bYKUTUZxaprxQnfYbL8fZdLSjl4tpCDhB3e06GB1PtUoZvmENFFRUZbpc3+Q1kJ6/GslkLFllq0CbQRbDmdBMM2xJBneMxJxI3t51G9mNWcb1cLadrV50VsLj3mwT4emnnW64WsTyzihnWfUtOQ7ShF/6DeP19YdyjPVP84x4/FwQAlI37LSNJusAvGnl5Nk1KhRWLFiBb7//nvUq1fPdcbLbrcjLCwMdrsdr732Gt577z00atQI9evXx5gxY9CrVy8un3qq9nh/53aMcHuY4tYMLdt/3njjDeI2aUHNtnB7GBrV1d+OXi1G8LZfzQ960aKDlB/UILF9jKVPaPLGG28gm0Gfs+CNN95Aqkppr0C0kBz/WtEztuTiVcAfwZbDWRAMc2y+oxTdHxvuetgTKdRKFNGcA0j45PTFUia2u8+Nvdo19vm9txYWaw+9aLGJdZzQzDNqWpT6YtPhfAzuGm6Kj5TK4HV++EnmtlgNrr/pnj17NhwOBx5++GGEh4e7/sXGxrqumTJlCp544gk888wz6NOnD1q0aMHtg2ycj/d3R+vj9WNTc9F7QgJenH8AvSckIDY1V/a677//nplNemwLpB29WgJFa98GihYdJPygBimNrHxCm++//556n7Pin0t3YMyKQz6vW02L1rFFO14F5Ai2HM4Cq8+xzvgc9d1x4vHpLL/lDu3yW4Bxn8Sm5jKZo7XMjd5aeMyDWvxs9ThxR02LnH8AIGrTL6blPyWbxm0+IfKxH7h+0y1Jkuy/V155xXVNrVq1MHPmTFy4cAFXrlxBXFwcWrRoYZ7RKgT6eH8923969OjBxCa9tgXSjl4tgcBia5UWHTRLP5DUyMInLOjRo0dQlILKd5Riy/mGPk/HDbHBclq0jC0et0IKlAm2HM4CK8+xpsQng6cSGfGJ3FZcgPwcrbXvvbVYJg96daCV48QbNS3e/nHHrPzntMn7DaQEm8jHfuB6e3kwMrxnJPp0aIqc81fRpkltTRObnu0/Z8+eZWJTILbpbScQLXphsbVKqw4jflCDpEYWPmGBUwetPmfFyfNXZNec057vjie6tWRujxG0jC0et0IKBCSx8hxLOz7l5jsJoB7/Rnwi1ycA+Tlaa9/LaeEtD2rxs5XjxBt/Wpz+2XQ4H1GbfvH4nVn5b3jPSNQJrY7RXjs4RD5WR7zpDgCjZ2P1ng1xbuXwLhkgt/3n2rVruu3Ra5O7fj226W0nUC160Gu/N1rGgh4dNM4NGdXojhYtvJQeUcNdhxXOBCv16Y1teBIkt8141Ww29GhDv4yOP/SOAy1ji+RY1oMVxrQgOGCR92hBOz7l7h/CYHu5EZ8o2Ux6jtba9+5aeH02hhYtrOOEZg7QqqV5/VBT8p8SPVo35MoeK8D19nIeMeM8oZ7tP+3ataNqi7f+pOOF1LYm0dYCGNtapXUssNChBsntY/60WOW8rdk+0YNan4bbwzD6vsbcbQ0MZBxo8YkZWyGtMqYFwYGV5iZvaMen8/4eT7aWgKTjhUTur4QRn7CyWWvfO7XwPK8lHS/0eOicTWYrPss4od1XWtdVY1amQ5LgGktm53sfP8F6x9pYI77p1oHSmZk+HZpSH2Rat//s3r0bXbp0oWKDkv7ksX2RPLYv8a1JNLW4E8jWKj1jgZUONUhtH1PTYmZ86IUHn2hBS5+G/paG5LGvcbM1MNBxoNUnLLdCWmlMC4IDq8xNSjjjc8r85Xj3jZeIx0mfDk09zvc6y0nRjEmjPmFls5a5cffu3WgSeRu385pSOao+HZp6XMcqTljkAD3rKglAiATMeLE77m7d0DR/yflJguTjJ4En4ptuHaidmXGS7yhFSvZ5Kg8SCLeHoVe7xqpB9vLLLxNv14m/M0PO8hSk9NPU4o2WvnVHqS/Sci76XMtShxp6NcqhpkVLfLBGKR558Yk/tPTpyy+/TCX+AkWtxImaXXp8wkovj2NaENxYZW5SI9wehk9ffxYA+fiUO+9LOyaN+iTt1EUmNju3QKt9GPnyyy9zPa8plaPyto1VnLDoK73rqioAjeqEmvoBifyzCmxcjCGeEW+6deCvtAIP23VmzJhB7d6s9dPUYhSlkglvrzrko5tnHXpR08Jb6RG18WgVn2jpU6cWHuYfIPASJ3p9wkIvb2NaEPxYZW7yx5gpK6jEp9L8cvi3YiL3l8OIT3gqFwbc0MLzvCZbLgy+5/ZZxQmLvvK3rjKjTJ4/jpxx+Lxmg2S6XbxjkyTJ57OKm42SkhLY7XY4HA7Ur19f9drY1Fx8GncUlZLkOk8xvGck8h2l6D0hweeBAslj+5q+XYckN7t+d2JTc/HJ2iOo8no92HWroTQ+WBNM41FLn/Km191mb0jYxVKv3jGtJ58IjOPs78zcAnSIaG62OQLQj8+5u7MRveWYx2s8zu9y/QDceJBa9NNdiOXGQPqbl1ztTb6jFA9EJ3huL7cBKWP7meZbM/tKtj8ApHxiXn8ojetPHu+EN/tY95kUTmjmcPFNt06G94xE8ti+WPnG/Uge29cVeLxs14mKiqJ6f5b6aWsxyvCekZj2Ynef1711865DD/60KI0P1vgbj1byib8+jYqK4mb+ceK0edzg231+p2SXHp+w1MvLmBaok1sUHLVhrTQ3KUE7PrvcYvd5jeZ8F6hP1MqFkZxH9PS3Uwuv85psuTDJd3s5yzih3VdqWtTKp5mF0rj+KWEDe2MshniQWgDIlVbQUyqDZumBMWPGEL2fHE6bT56/4vqZRqkQNS0sSvhoaUNLyQQWPpGDRh8paeGt9Ii/8WiWTwJFrk+dfT5sxF9Qr745pbTUCLeHYXDXcPxr8y+a7NLjE9alw3gY0wJ1IhsHh3+sNjfJYUbpMOf9Wea9QOwMAZtyYSEAiq6UI99R6tEP7lp4nNe0loVjHSc0+2rMmDGqZUH9xRLrkpZK4+2l4c9Sb9vqiG+6CaG1XAPtc4hLliwhej855DTQKBWipIXFWU6tbWjRzcIn3tDqIzktvJwldsefX8zwCUnc+3zgzP9SLd1nBD3zgh6fmFE6TMA3LYLE91afm4Ab8TnAXki9dJj3/ZOOFzLLe3rsdD+TK4F+uTDb/9oZveKQTz/wPr60lljjXYcePpwdr1oWVC3X8VDGGLjxcLeX/5POxfqPZ8SZbpDdv5/vKFUs18DiHOLRo0fRuXNnIveSw58GNf16kdPCog8DaUNNN22fyNlCq4+8tfB2ltgbJb+w9glJ1PocADelw9zRMi8E4hOS8w0pxJlutgTbmW4rz03uHD16FI0j2lGNT/f4B8As7+m1kVWOzHeUIi3nIt5edUixPSuML7lzzN59ZgUdWtCi1XmddyyZvf766fRFDJmV4lGrm6f1X6CIM90WQq0sE+1zTvmOUmz+8Veq5YL8afBXlkpPSbWsrCzd7ZMgkDbUdMvpMIpaP9LsI28tvJ0l9kbJLzR8woq0Uxf9lu7jLeFpsSsQnxjVS7PEo4AtwXKm28pzkxPnWgQA1fnIPf5Z5j09BFpCMRDC7WFoVLemaj/wPr7yHaXYeDjPb4k1M3TQyBdaS+DJ5Tq1tQALrlyrhPfXtjyt/3hEnOlmCM1zTrGpufgk7giqpBqYMyGB6JMx3TGi4XcbtT29MyzMN1GzOMtJug05HUbw1480+8hbi1xbwI3yLc46yjxC2iesiE3Nxdi1R3xeN/v8NglY+0TvfCTgm2A5023VuckJq7WIN87SSt5PvaaR9/TaJZcjozb9gn9t/oV4//jrB57Hl/uc7I13jguWfCHnLy35nIe1AM2YC1bEN90MoXUOMd9R6jFRVUnAp3FHqXx7E6iGQGxs3Nj3TRuLs5yk25DTESha+pFmH3lrCbeH4ePHOvlcN2lLJtffHpL0CSucvvdej4QAQXGemaVPWM6ZAoEerDg3OeEurggdnjTiE7nzr06Y9Y9bP/A6vrzHjjtya5hgyRfh9jC8eXc9Xes1xbWAjYO1wE1/YFkd8U03Y4b3jESfDk2JnnNS21ZFI/gC0RCIjenp6ejZsyeR9vVCsg0lHYGgtR9p9ZGcFrXyLby+ESTpE1Yolel4qvmFoPiGlqVPWM+ZAvrkFpWiQ4TZVhjHinOTEzPjSq20ktG2jfrEmY83Hc5H1KZfPH5Hun/89QOv40spv/1j8O14vGu4T/8EU75o7MhE8tiXNa/X1ErRPdGtpWF7tEIz5oIV8abbBEiWHsh3lKLocjnzckF6NQSy5fnJJ5+UfZ1VeQRSflLSoRe9vqZR4kJOC+vyTSTw1sG65EYgKPXzq088ZJ5RXhjpR1JxogUrjlmBOsGyvVxLHPA4X5mxFnHvB5oxTWpual4/1PTjcSznWT0olaG6p01D2TEeTPniySefRAsd6zUle0iXonNipJyZwBOxvdzCOEsFjFmZDkmCq8QCj+VzAtny/O9//9vnNR7LU/lDTodeePG1nJZwexiGdm/l8dqQ7i25Gn/euOuwyphKOl7o8dAS2/+2kq2P5aN0itF+JBEnWhElx4KPYCkZ5i8OeJyvzMhP3v1As2yi0bmJZf/4m9tYzrN6UCpDNXRWiuwYZ50vaK5x9GpRWguwiDO1cmY2SCKP+kGUDIM1S7zIlQoIATD9xe64u7X8J4M8YKTEj9nlEcyCd19b2S9WsV1pDOz9pB8XdlqlH72hUXLMivnEygRbyTA1eIwzM/KTlcommpW/eSynqAUey1DxFHcs1wJadVt1rCkhSoaZDI9lZeTOdFQB2BS3OqBBz0qjnhI/UVFRHj/zXp5KCW8dSij5QMnXjeqEavY1Kf/KabGiX5w6eLfd6Te50iBVuLG41Dq+aEKiH9118DgfCfgmWEqGqcWznjhjFUOk1yJaYF02Ue8c6973JPJ3IO0q9QMP+UINrWWoWOqgvU7QokXLWoA0WnQ7x3ibJrWxYHoMcRuCDXGm2w+8lpVROkvx0Vuv6L4Xrxo/+OADj5+ten7EW4ccaj4wqpukf+W0WNEvTh08lzxz95sNUCwromV80YbEGHDq4HU+EvBNsJzpVotnrXHGMoZIrkW0YEapJD1zrHfff/xYJyb5UavPecgXaijm5DOeOZmlDtrrBH9atK4FSONvvvEec18++SJxG4IN8U23CtyVv3BD6dzOmiXzdd2HZ43Tp0/3+Nmq5zC9dXjjzwdGdJP2r5wWK/rFqYPXkmfefnPmvBCZs4D+xhcLSIyB6dOncz0fCfgmWM50q8WzljhjHUOk1iJaMKtUktY5Vq7vJ23NxMeDOlHNj3p8zkO+UCPcHoaPB8nk5K2eOZmlDtrrBDUtetYCpFGbb+TG3D/WZ4hc7QfxTbcKvJeVkSsLldVgiK578KxxyJAhPq+xKBdGGjkd7mjxQaC6SftXSYvV/OKug8eSZ3J+kwBMf747GtcN9ehjf+OLFUbHwJAhQ7iejwQCFviLZ39xZkYMkViLaMGsUkla51ilvu/aqgGSx/allh/1+JyXfKFGl1b+czJrHTTXCWpa9KwFaKA038jbZRO52g/im24VnFsr3OFt26z3uZ20tDTFa+XOePGsUUmL1c5heuvw9oNWHwSim7R/1caXUb+wfHZCWlqaq706NatxFwNKfuvRpqFPHyv5xIxnURgZA2lpaVzORzw+00MQvKjNsU7U4iyQGCIxxvWsRQJFbV6kiVYt/vpe8vmOngxK7dauGeLjVxp+IYl76Tl3vMcwax11alZzPXVeyaZAUdMi59sQQHYtQAu5+UbOLhskLt478Ix4062CFbfNtmjRQvZ1pcf+86xRSYvVcNch5weaPiB9b1o+YV0GJ/N6Y1d7Q2elYGj3VlzFgB6/yfmEx7JC/mjRogV385EV+1FgbYzOsXpjiNYYp5ErzCpPqVWLUt8nHS+kOo/ItTuke0sMnZXi0ybP6yo9pdVY6ohNzcVQmSeqk8pNalqcvnV/fyvhRtkwM5ErW/ZKZ/IPBww2uN9enpSUhMmTJ9/4Zio/H/Hx8R5bMSRJwueff4758+ejuLgYvXv3xuzZs9G+fXsi7Vtt22z16r4uVTrv06dDU4Tbw7jVKKfFijh1qPmBpg9I3puGT/yNTxrtLT56zfWdQ5UErDuUh7iRvXD1WhU3MaDVb94+Yd2fpHDq4GU+smo/8garHF7gKA2KEm0k5litMURzjNPKFfGHfvN4bd2hPHwwsCPVmNSjxbvvAXiUXaI1j7i3W7tmCIbOSpFtk9d1ldzZ5RAJmKFQWo2VDm+7gBvfVsaN7IVuEWR2WPjT0qdDU9hscL3JlWBuLpJ7toJNAu5qHsrcFqvB/TfdV65cQbdu3TBz5kzZ30+aNAnTpk3DnDlzcODAAdSpUwcDBw5EWVkZMRt42c6sZQvYyZMnfV/T8Nh/HjR665PTYkWcOvz5gYQPlMYIKf/S8Anrsl0nz1/x2eRXKUm4eq2KSgwY2bqpxW/ePuG9DJoS7jrcdZu1vduq/cgbrHJ4sJQMIzXHys0dPjmW0BiXi9FgyBWudnVqce97ljY7271yrVKxTd7WVf5KYSmVVmOlQ6nk29VrVeTa8KOFt1yk1Cc/Zf8me73gd/j8yMuNQYMGYdCgQbK/kyQJU6dOxbhx4/DUU08BAJYsWYLmzZtj3bp1eP7551maShWt5SD69Onj85oVSjrJ6ZPTYkWcOmj7gUWZGBo+YT0+WbZnhk+sEO9yyI0tM8uHWbUfeYNVDg+WkmG08p5sju3Q1PAYV4pRWrnCu1ySzQbqMWlEi6zNoGvzkTMOn9ecfm3J0brKSCksVutDFnnAnxY1f5qBUgm1mi3I7DAOZrj/pluNkydPoqCgAAMGDHC9Zrfbcd9992Hfvn2Kf1deXo6SkhKPfzyjpxzEihUrfF7j7ZykN0r65i1bY65hhHD6hKYfWJWJkRtfRmE9PsPtYXiw1mnq7ZnlE97jXQlvHWaXD7NqP1qJQHK41fK3XmjMsUqxBMDQGFeLURo6ZKHzbDIPiGux+b8kUPIdpZi49ZjP6x8NurEFn5lf/GC0FBYrHSzygJoWf/40A6USanP3F4gHjvrB0m+6CwoKAADNmzf3eL158+au38kRHR0Nu93u+hcREQEAOHHiBCZNmoTy8nJERUUBAKKiopCXl4cFCxYgNTUV27ZtQ1xcHDIyMjBt2jSUlJR4XHvhwgXMnDkThw8fxvr167Fp0yYcPHgQc+fORWFhoce1V69eRUxMDDIzM7F69Wrs3LkTKSkpWLx4MU6fPu269qspc2W3lqz7IQWrVq1CVlYWJk+ejLKyMlRUVLjuX1BQgPnz5yM1NRX2ogyM61aOfw1ojtea5+CxDnYPW4qLizFjxgwcOXIE69atw+bNm5GWloZ58+bh7NmzHteWlpYiJiYGWVlZiI2NRUJCAvbu3YslS5YgNzcX48ePR1VVFaKiolBVVYXx48cjNzcXS5Yswd69e5GQkIDY2FhkZWXd0P+b77aiSknCbXfdj82bN2PdunU4cuQIZsyYgeLiYg9bHA4Hpk+fjqNHjyI+Ph5bt25Famoq5s+fj4KCAo9ry8rKMHnyZGRlZWHVqlVITExEcnIyli5dilOnTiE6OhqVlZUef3P69GksXrwYKSkp2LlzJ1avXo3MzEzExMTg6tWrHtcWFhZi7ty5OHjwIDZt2oT169fj8OHDqFu3Li5cuICoqCgM7xmJYWFHsOClLvhzs5PoUucy4uLisG3bNqSmpmLBggXIy8vzuG95eTkmTZqE7OxsrFy5EomJidizZw+WLVuGnJwcTJgwAb+eLZHtw81JP2LHjh1Ys2YNjh07hilTpuDy5cse9z9//jzmzJmD9PR0bNy4ERs2bEB6ejpmz56NoqIij2vfeustTJ06FRkZGVi7di22b9+OAwcOYOHChT52V1RUYOLEiThx4gSWL1+OpKQkJCUlYfny5Thx4gQmTpyIiooKj36Z8fRtGNPmHNpU5WP79u1Yu3YtMjIyMHXqVFy6dMnj/kVFRZg9ezbS09OxYcMGbNy4Eenp6ZgzZw7Onz/vce3ly5cxZcoUHDt2DGvWrMEL97XBtEftGBFxEWtGdELWtiWua69fv44JEyYgJycHy5Ytw549e5CYmIiVK1ciOztb8xyRmJYh65MjJwuIzhEfffQRoqKiUFlZiejoaJw6dQrXju3GN/3q4uOetfDR7Zdwd4Ny1xzhfn/3OWLr1q2Ij4/H0aNHMX36dDgcDqZzxPPPP+8xRyxas0m2/76aMhdnz57FvHnzkJaWRnWOaH7lBL7pVxd/blOCVS93wIkflvudI+Li4iDQRiA5XCl/H/hZe2yyzN/esbl06VIkJycjMTHRJ3+7xzPJ2FRaQyxaswlNL/2KKf3r4dXWDsT+X0f8un2p5vw9adZi2fvOWByL/v37E4/NCTMX+rzHlgAc+PkEtfw9c+ZMvP766x7XlpSUYNq0acjIyPCbv4/nF/vaLAHzV37vyt/Xr1/3+JszZ85g0aJF2L9/v+78vWL9D7Jl1X5K2IBLly4hNDSUeP52j7WFCxfiwIEDfvP3TyfyZUthPdn4POYMux3Dwo5geM9I2fy9Y8cO9OnTB4sWLcKZM2c87ksqf7vPEVnbliB5bF88XisLG//aHef/u4HoHFFRUaE4RyxcvVHRn2bm784tfZ+fIcGGjYkHfNb4paWlHvdnlb8DXeNnZWX5djghbJIkMfickAw2m83jISwpKSno3bs38vLyEB4e7rpu2LBhsNlsiI2Nlb1PeXk5ysvLXT+XlJQgIiICDoeDywex5DtKPR7EAdz4tC15bF+fT7qioqIwbtw4Im2ePH8FbZvUof5pmpK+YWFHEP3Zx1Tb1oLRviDlEzW7AGgeI0agpUUOmmOQhQ5/cUtKH0ufuEPaP9469Mx7PFFSUgK73c5tPjETEjlcKX9n5hagQ0Rzn+utBo14/un0RQyRefqy0VhSi9EF02OI6XDONXVqVvN4QJh7ezTnBCM+YT2P+WvPrHzhjZZ+UcsxvOgggZoWXvOgnF02SEj5pD/X+VkLNHO4pd90nzhxAu3atcOhQ4dw1113ua576KGHcNddd+Hbb7/VdF9nBy9MOIpX+95JwXLjxKbm4tO4o6iUJNf2FlpnG804R8lSn167zDpTqtcuAFz2YSDw2u96URrXVtfHyn5e5wU1xJtuZWjkcNHf6rjHqhOSsUQ7Rr3nmqHdW2HdoTxLzQnvr07H2oO/P2TqmbtbIWbYXUHTXqCojR2r50iS8OjP2NRcjF37+xPMbTZgQpD4iGZOsfT28rZt26JFixbYuXOn67WSkhIcOHAAvXr10n2/Lzf8wu15hOE9I5E8ti9WvnE/ksf2VRzYzm0TgWLWOUo5fUa1GIVUX5DWoVbmRcsYMQILn7AYg6zGlty4Jq2PdZzQ8o+cDq3znsCakMzhBZzmbr2QjGe1ckekYkkpRknokJtrnOUdWc4JRrQolTmjtaby157Z6yp3lMaOlhzDkw6jqGlhPX60oFQyLH3LStNssgrcP7388uXL+PXXX10/nzx5Eunp6WjUqBEiIyPxzjvvICoqCu3bt0fbtm3xj3/8Ay1btvSoA6qVSklCWs5FNKrLZlu1XsLtYX5tGjFihKE21EoTkNwSK4e3PqNaAGNbYP31hVZI6NBqF+2ybyNGjKB+9IBUv6vZSdonemwgpc8JKy1OArXf37hR0qFl3tPahoA9rHJ4blEpOkQQNt4ESMYzi3JHgHyMktChNNecvlCKJ7q1NHx/rRjRQnq+N9oe63zhD7mxo6XPzNRBOs+oaWE9frSgNK/0evSPptijBm9rAu6/6f7xxx/RvXt3dO/eHQDw3nvvoXv37vjss88AAB999BHGjBmDv/zlL+jZsycuX76MrVu3olatWrrbsgF4e9UhvDj/AHpPSEBsai5JKUxw/8YgEJylANxxliaITc1F7wkJzPrHqBaj9qr1hR6M6vCGlF2BMHntXupjgIQ+f74n7RM9NpD2Hwst7gRiv5ZYNDveBXRglcODpWQYyXg2M1eQ0CFnP3BjncYyvo1ocZYMc4dmyTDZ9tzKqrHOF4HgTwNgng4aeUZNi5a+YI1SXG7Ye5i9MSrwuCbg/k33ww8/DEmSfP4tXrwYwI0zYl9++SUKCgpQVlaGH374AR06dAi4PbPK05DCiHZAuTwCAObbzo1oIbEFllSpCKM+oWWXXvIdpdhQUI/6GDCqT4vvSftEjw2k/Udbizd67dcai2bHu4AOrHJ4Cw6+xSAByXg2s+wdCR1O+70Xqqzjm/gcS7FkmCxu30qyzhfE8Ppm1QwdtPKMbi0mP4lLqWTYzvN1ucm5vK4JuN9ezhIJnnOh2Vs4AqG01PiAGt4zEn06NEXO+ato06Q2wu1hSMk+z3yLixEtpLbkyPWFXkj4hIZdejl5/orPXE9rDBjRp8X3NHyixwaS/qOtRQ499muNRR7iXSAwG9LxbEauAMjpGN4zEnVCq2P0ikMer7OMb6Nzk1zJMJrby+XKqjnbMyNf6MWfBsCcvEcrz6hp0dIXZtDlFrvPa1UUx7VeeF0TiDfdbpi1DUsvamcUioqKiLThfc7GuZ3E+wmocv1D6gyFES167PWHnjOlcvjTEWh/GbVLLze2OUmQ3D6a0tOnenUGqk+L70nFiREbAtEn14e0tSjhbb+Sf7XGIi/xrgfezosJrA+NeDaSKwId4yR19Gjd0JT4dmKlualOzWqw2eBTHs7Znln5Qg885HBv8h2lKLpcTsWXalrk+iIE5m4vB+TtskEy3S4nZq0J/MH99nKWfP7kHaZsw9KDvzMK3bp1o9Ku1m1qJM9QGNFi5rY6b9R08HjmRIlwexje6d08oD5lqVOL72nFiR4b9KLUh7S1aEHNv1r7wmrxbqXYvRlYm3babBOIwEM8OzEyxknqSDpe6PEm0mYD03xuRAtL22NTczFUph67e3s8jS8lwu1hGNq9lcdrQ7q3ZJrD3XHGwZiV6ZCkGz4EyOUZNS3O3Ob+naCEG+PKTOR8NOC2+ty8Z+LpPYA74ptuN57pEYHH7r6V+TYsraiVinLaunHjRnTs2JFK+/62qWmxTw9GtZi1rc4bJR2k+4sF148nIXnsSF19aoZOf76nGSdabdCDWh+y0BKobU7NWvrCSvGuprkO6/OaAgA3Sn4+dvet3M6dWjE7np0YnbdJ6VAqT9SnQ1PD99ZKoFpY2q5WHq5bREPXa7yMLzWUymR9MLAjk7Wuty3u/SoBCJGAGS92x92tGxKZb/xp6dOhqcfuBQnmrxXlfPTDryWu59bwAC/vAdwRb7q9YL1lVw9azii89dZbVG1Q6x89Zyi0bFkjoYUHf3rrcGq/cOUal2dO1HjrrbdQu7a2bcVOzDpbo+Z72nGixQY9qPUhTS1a4lSrf/31hZXiXU3znU1rUG9f4Avvc6dWaMRzIFvEjc7bb731FpHjF0rliViWdw3UJ0q20xinWsvDscp9RuBhratmSxWAfEcZsTb8aVHqDzNLHMvZJMHG3RzMw3sAd8T2cguhpfzHN998w9iq39FankTrljUztZDEXYe79jErDvk8xJSHMydqePtEiy/NLFujhNXGllof0tKiNU5J+ddKPuFxTN/sBEv/k46DQLeIGx3jb05cTOT4hZwdrMu7BuoTpdJKh38rNmaQDEfOOHxek/OXFeZZLWWyWOlQ8mHUpl+IjT1/WniIATmbfLuFnzPdvCLedFsILWcUxo0bZ5Z5muzT8xh/M7WQxKlDbpsS8PsD/Hg5c6KGu0+0+pLHszVWG1tqfUhDi544JeVfK/mExzF9s/O3R24Liv4nGQdGyuYYGeP5jlLsvdaaSLkebzuci1aWpYAC9Um4Xb600qQtmUTtzXeUYuLWYz6vfzSoo4+/rDTPeuD1rSorHd7jzx1SY8+fFh5iQAs25rXwrIfYXm4x/J1RiIqKMnVS9Wefni1rZmshhVOH/HYcYPrz3dG4big3Z07UcPeJHl/ydrbGimNLqQ9paNG7tZSEf63mE97G9M1O5/AGZptABJJxYHSLeKBjnPSRInc7iq6UMy8fZsQncqWVSNsr198A0LVVA5/XrDDPaimTxVKHc/xtOpyPqE2/ePyOhC+1aDE7BrzhtZQZ74g33RbEOaBPnr/i8TMAvPnmm8zsUDqvpXaGQs9j/FloYVHyx6lDSXuPNmQexkETZz8NefFV12t6SzKQPltjxHes4oT0+JLrQxpaAim3YdS/cjp4K8nlbQ9v58VuZiIbB4cfSMYzibI5gYxxGuV6nHbkO0qZlwIy4hMWpYv0rqt4m1e90aKHVg5XW9cO7hqOf23+hbgvtWoxMwa8kS1lZjO/lBnviO3lFkTtjFZcXJzpNqihZ8sabS2sSv44dVh1S6p7Pz0575Crn8zUY9R3LOKE9fgiiRm+9dbBW0ku3uwReNKC83lUKyTj2aw5OtwehscaX6DSrhnlw4z4JNzuv/yVUfT4+fP/bOV+HtPiYxp5z98cTyue9Goxu4QeID+u76xzmfv1rNnYJEmS2ZRyc1FSUgK73Q6Hw4H69eubbY4q+Y5S9J6Q4PMJV/LYvgi3h+HgwYO4++67TbVB6z38bVmjqYWEBq1469CinRe09BNrPSR8RztOzBxfJGHpW3cdLPtPC3rssVI+CQac/Z2ZW4AOEc3NNscwNOLZjJxz8OBBhLe7nWi7cnEYAmDvJ/2o6jLiE5ZzmT8/5ztK8UB0gse2YDPnVTm0+ph0nOjxE+l40qPFrBjQZIcN2DuWrR00oJnDxTfdCuQ7SpGSfd70BxN4o3ZWCgDy8/MDuq8evf5s0EK4PQy92jVWDU5/Woz4iIQGrXjr0KLd5x4mjUct/RSIHto2+SPQONGKmo2kfUlTC0vfuutgGZ9a4M0egS+5RXzl6kAhHc/O7bKsP+TNz8/XNX9omRfVSnDRJD8/P+B5W2nu2HQ4n3g+d+9vOXvlzuGymse09p9WH5OOEz1zPOm8qEWLs//STl00JQa8kfWTxN4OqyHOdMsQm5rreuJniA2IfroLhveMNNssAP7PulRWVuq+p169LM4oAepajPqIlQYgMJ+4Y+Z4ZNlPLG0y6hN/KNl4+LdivPTv/UR9SVsLK9x18DbunOVR3NcY3iVsBOYSLGe6ScazmblDjw6tdpo1LyTnVWHM/77V09uPcjYDN0pO/WvzL1R8otSfN+YxCZLbU6ZZ9J+ecajVx6Tznpk5x58W9/6zAT65yIzcKJcTRckw/4hvur0wUmKDBf7OlLRp00bX/QLRy+qcmJIWEj5iedZNr0/cMXs8+pSqMOHskD+bAvGdEZ9oQc7Gjx7riIlbjhH3JW0trHDXYYnnH9z0B7P4IljOdJOKZ7Nzh1YdZpQn1EO+oxSrskMC7kcWJae87VXqz3B7GEbd14h5/+kZh1p9TDrvmZlz1LRYqdSsKBnmH/FNtxekS13QQK2Mx549e9C1a1fN9wpUL4tyOUpaSPmIVckfvT5xh4fx6N5PuzeuwfCeg5m0q9WmQHxnxCda8baRli9ZaGGBtw6eSnKJ8igCVpCKZ7Nzh1YdZpQn1IPalmytbdMuOeVtr1p/huUdQvLYPzPtP73jUIuPaeQ9s3KOmhZeS82KnBgY4k23F7xta1RCqYzHCy+8oOs+RvTSLpejpIWUj1iVzXDqCKQ9M8ejXHmkjv83jHq7WnEvn5GSfV5Xv+qNEyNI/0tNtHzJUkugaBn7cjpozzFasUpeEFgfUvFsdu647YHHXd+uqmGkPGEgc79eSPZj8/qhppQPC8HvR2FeeOEFNGI4rxrpP0llOxGtvGdGzlHTouRP/O94k1n5UZQMCwyxvdwLS2xrVGHWrFm6rudZr5IWEjazLP8za9YsJiXWSKJkr97xRZtA+5WFDm/bko4XUvElbz7xRquPeNbB8zwpCC5IxYHZuePN2AxNc3KgdrLK4eH2MPSueYrIemPMynRI0o3nQQR6Ly32Rj/dxWOjr4QbZaYA9vNsIP7V4lue84Ve1LR495/zHPXoFYdMLfkWbvctGdauWpHIiX4QJcMg/3h4K5V1IoEV9QZqM+tyRKxKrJGCt3JNSvBsp5ptACwXa4HCs48CQUscipJhbBH9rY5VcoceO82YV0iuN0IATH+xO+5u3ZDbNQcNm7T0H4+280C+oxRpORfx9qpDXPRNMPtJlAwzAdZlkJwYLScUFRUV0N+ZpVcNdy1y/RKozSxLeADAV1PmMimxRgq1M1iBji+9BFo+Rmu/atFBqyQdaV+y8okTWuUF/ekwu4yjWaWXBDcXpOPZ33xDMq6MzMl65kXWJfyioqKIrjeqADSqE0p8HlErK8U6h3sj139KZc20+JbnvKcXLVrC7WFoVLcmN6UrRRnNwBBnujmCRHmPt99+m5J17HFqIV32hHUJj3defwlbZ/7XMudB1cojsRhfLMrH+NNhpZJ0LGOeZnlBNR1ml3E0u33BzQPP8ewPVvOebI4CvfOkRnzCqtyg1rJSvKwR1cqaaRlDVo4Tb7Rq4al0JesYDBbEN92cQKq8x+LFi8kbZxKLFy+mUvaEdQmPrXErrX8e9H/9T3t8sSofo6bDaiXpWMU87fKCSjrMLn1kdvuCmwue49kfpj77gGK1IuI+IXyoU09ZKR7WiP7KmmkZQ1aOE28MaeHogLDag+8ENxDfdHMCqfIeAwYMIGyZeQwYMIBa2ROWJTwGDBiAO+7gp/yRP9RKQdAeX6zKx6jpsFpJOlYxT7u8oJIOs0sfmd2+4OaC93j2hzPed6dl4KEed1CJEdkcJdErV2TEJyxKK+kpK8XDGtHf2NOSM6weJ+5o1cJTmS45WwCbyIt+EN90M0bpXIhzS407gWzLOnbsmFETiWLkHMyxY8eI9Ysc4fYwDO4aTu3+Tpw+0XqmiTb+2lTrc9rjKxB/O/sVgOa+VNNBcsyxOIvPKuaN9IuWflDSQXMO0IJa+2afMxcEH1aIZ3+E28NQs/iUrgeF6okjrbaTik8jPmExf8m1EQKgR5uGPvMuD2tEJXuLrpS7fOUvZwRDnDjRqsXsXOjPFkAS28v9IN50M0StDAKpbVl16tQharMRjJb0qFOnDvXtaknHC+H+/H6bDcS3wyn5hGXZMj1tqvU57fHFqnyMmg6rlYdiFfO0+0VJh9n+UGo/6Xgh8/gVBD/BHs/eBJIHtdhOMr8a8YlcaaUh3VsyLRPmDg9rRBJlsFjGCW3/adXCwhatyI05wCY75gS/EzTby2fOnInJkyejoKAA3bp1w/Tp03HvvfeabZYLpXMhfTo0dQUMie2ojRo1Iml2wGjR6w+nFlrbdJ02ejwIQgL6dGhK5P5O5HxCon/0oqdNpT5nMb70+juQvvSng9XWcBKwjHma/aKmw2x/eLcPwKNcivuYq0PxbGkwYzSHFzhKg6Jk2M0Qz06M5EE120nnVyM+yXeUIv7Qbx6vrTuUhw8GdiTa3306NIXNBteXCBLkNfOyRnT6z7sMllZfsdLBwn9atbAaS1rxHnMA/XWs1QmKb7pjY2Px3nvv4fPPP8fBgwfRrVs3DBw4EOfOnTPbNBdaH69vdDvq4cOHAzWRKCTKCbhrobFNV6mUB+mSB3I+MaPcgt425fqc1fiiXT5Giw4ey+jJwTrmafWLPx1m+8O9fVEuhSwkcnhuUXBs8b9Z4hkwngeVbCcdn0Z8wmqu0NoOL2tEwFgZLFY6WPhPqxbe8g5v9liBoHjT/c033+CNN97Aq6++ijvuuANz5sxB7dq1sXDhQrNNc8HqLMagQYOI3i9QSOilrcVMn5hxNscKPgmEQHTxqCNQgkWLlXTwdLYuGCCRwyMb8/3hmFasFAdqaNFBK45I39eIT1jNFVrb4W18Bdo/rHSw8J9WLbzlHd7ssQKWf9N97do1pKWleTz9LyQkBAMGDMC+fftk/6a8vBwlJSUe/2jD6lwiLx80kNBLW4uZPjHjnKoVfBIIgejiUUegBIsWK+kw+5x5MKE3hyvl7xZB0vdWigM1tOigFUek72vEJ6zmCq3t8Da+Au0fVjpY+E+rFt7yju/ZfEnkQT9Y/k33+fPnUVlZiebNm3u83rx5cxQUFMj+TXR0NOx2u+tfREQEAODEiROYNGkSysvLERUVBQCIiopCXl4eFixYgNTUVGzbtg1xcXHIyMjAtGnTUFJS4nHthQsXMHPmTBw+fBjr16/Hpk2bcPDgQcydOxf92oRhWNgRrHzjfgwLO4In72yCmJgYZGZmYvXq1di5cydSUlKwePFinD592uO+lZWViI6OxqlTp7B06VIkJycjMTERq1atQlZWFiZPnoyysjKXxqioKBQUFGD+/PlITU3F1q1bER8fj6NHj2L69OlwOBwe9y8uLsaMGTNw5MgRrFu3Dps3b0ZaWhrmzZuHs2fPelxbWlqKmJgYZGVlITY2FgkJCdi7dy+WLFmC3NxcjB8/HlVVVcjatgRJHz2EwWG/Ivb/OqL8l0Ts3bsXCQkJiI2NRVZWFmJiYlBaWupx/7Nnz2LevHkYNGgQNm/ejHXr1uHIkSOYMWMGiouLPa51OByYPn06jh49ivj4eGzduhWpqamYP38+CgoKPK4tKyvD5MmTkZWVhVWrViExMRGtynPxbvsLmPrHNni+bgaevbuVx9+cPn0aixcvRkpKCnbu3InVq1cjMzMTMTExuHr1qse1hYWFmDt3Lg4ePIhNmzZh/fr1OHz4MBo2bIgLFy54XFtSUoKz+9Zh0dO3YGSnaxh/fwhuxVksWLAAeXl5HteWl5dj0qRJyM7OxsqVK5GYmIg9e/Zg2bJlyMnJwYQJE3D9+nWPvzlz5gwWLVqE/fv3Y8eOHVizZg2OHTuGvOS12DbmPjxeKwvJY/sia9sSnD9/HnPmzEF6ejo2btyIDRs2ID09HbNnz0ZRUZHHff/2t79h6tSpyMjIwNq1a7F9+3YcOHAACxcu9LG7oqICEydOxIkTJ7B8+XIkJSUhKSkJy5cvx4kTJzBx4kRUVFT4xNrChQtx4MABbN++HWvXrkVGRgamTp2KS5cueVxbVFSE2bNnIz09HbULfsIX91Thq75N8Gar39C/bW2Pay9fvowpU6bg2LFjWLNmDe677z7s378fixYtwpkzZzyuvX79OiZMmICcnBwsW7YMe/bsQWJiIlauXIns7Gyqc0RhYaHHtVevXvU7R4wbN07XHOF+f7PniKioKFRVVWH8+PH405/+hCVLluiaI9LS0qjPEcnJyVi6dClOnTqF6OhoVFZWIioqCsN7RmJY2BFMG3Ir3r71PCIqzmDnzp2Ii4uTzTsCefTmcLPydyCx6bxWT2w645mn2MzNzdUdm1rz97n932PBkJYYdXsFou6z4VacNRybAJC1bQlW/6kjRkQUY+qA+mhSkhVQ/p45cyZGjhzpk7+nTZuGjIwMxMXFYdu2bUhNTVXM36d2rcLy52/FG+2uYPJDtdCy7FRA+XvKlCm4fPmyx7Xu+bvO2cP4vEclvurbBH9peQYDbq3jce2lS5dQt25dy+fvHTt2YMCAAczyd9a2JUge2xeP18rCxr92x/n/biA6RwDQPEe42xL/584oSd9m6hzxXI9bMKz2UXz7VFu8174Yt1w7bYn87fwbuTV+VlaWT94hhmRxfvvtNwmAlJKS4vH6hx9+KN17772yf1NWViY5HA7Xv9OnT0sAJIfDwcJkqnz11Vdmm0CMYNESLDokKXi0BIsOSQoeLcGiw+FwBE0+YYHeHB7M+VuSgicOgkWHJAktPBIsOiQpeLQEiw6aOdwmSZKk9qacd65du4batWvju+++w5AhQ1yvjxgxAsXFxfj+++/93qOkpAR2ux0Oh8PyTz8tLy9HaGio2WYQIVi0BIsOIHi0BIsOIHi0BIuOYMonLDCaw4Otv4MlDoJFByC08Eiw6ACCR0uw6KCZUyy/vbxmzZro0aMHdu7c6XqtqqoKO3fuRK9evUy0zBy+/fZbs00gRrBoCRYdQPBoCRYdQPBoCRYdAn2IHO5JsMRBsOgAhBYeCRYdQPBoCRYdNAmKOt3vvfceRowYgXvuuQf33nsvpk6diitXruDVV1/V9PfOL/tZPFCNNo8++mhQ6ACCR0uw6ACCR0uw6ACCR0uw6HBqsPgmMqYYyeHBlL+B4ImDYNEBCC08Eiw6gODREiw6aObwoHjTPXz4cBQWFuKzzz5DQUEB7rrrLmzdutXnwSxKFBUVAYDrgSwCgUAgEBihqKgIdrvdbDMsgZEcLvK3QCAQCEhDI4db/kw3CYqLi9GwYUPk5uZaepFUUlKCiIgInD592vJn24JFS7DoAIJHS7DoAIJHS7DoAACHw4HIyEhcvHgRDRo0MNucoCdY8jcQPHEQLDoAoYVHgkUHEDxagkUHQDeHB8U33UYJCblxtN1ut1t+sABA/fr1g0IHEDxagkUHEDxagkUHEDxagkUH8HteEdAl2PI3EDxxECw6AKGFR4JFBxA8WoJFB0Anh4tVgUAgEAgEAoFAIBAIBJQQb7oFAoFAIBAIBAKBQCCghHjTDSA0NBSff/655evLBYsOIHi0BIsOIHi0BIsOIHi0BIsOILi0WIFg6u9g0RIsOgChhUeCRQcQPFqCRQdAV4t4kJpAIBAIBAKBQCAQCASUEN90CwQCgUAgEAgEAoFAQAnxplsgEAgEAoFAIBAIBAJKiDfdAoFAIBAIBAKBQCAQUEK86RYIBAKBQCAQCAQCgYASQfumOykpCU8++SRatmwJm82GdevWefxekiR89tlnCA8PR1hYGAYMGICsrCyPay5cuICXXnoJ9evXR4MGDfDaa6/h8uXLDFX41/HKK6/AZrN5/Hvsscc8ruFBR3R0NHr27Il69eqhWbNmGDJkCDIzMz2uKSsrw6hRo9C4cWPUrVsXzzzzDM6ePetxTW5uLgYPHozatWujWbNm+PDDD3H9+nWWUjRpefjhh3388te//tXjGh60zJ49G127dkX9+vVRv3599OrVC1u2bHH93io+8afDKv7wZsKECbDZbHjnnXdcr1nFJ97IabGKX7744gsfOzt16uT6vVV9wjMih/8ODzpEDudzbhI5nC8d3ogczocWbnK4FKRs3rxZ+vvf/y7FxcVJAKT4+HiP30+YMEGy2+3SunXrpJ9++kn64x//KLVt21YqLS11XfPYY49J3bp1k/bv3y/t2bNHuu2226QXXniBKx0jRoyQHnvsMSk/P9/178KFCx7X8KBj4MCB0qJFi6SjR49K6enp0uOPPy5FRkZKly9fdl3z17/+VYqIiJB27twp/fjjj9L9998vPfDAA67fX79+XercubM0YMAA6dChQ9LmzZulJk2aSJ988gl3Wh566CHpjTfe8PCLw+HgTsv69eulTZs2ScePH5cyMzOlTz/9VKpRo4Z09OhRSZKs4xN/OqziD3f++9//Sm3atJG6du0q/e1vf3O9bhWfuKOkxSp++fzzz6U777zTw87CwkLX763oE94ROfx3eNAhcjifc5PI4XzpcEfkcH608JLDg/ZNtzveia6qqkpq0aKFNHnyZNdrxcXFUmhoqLRy5UpJkiQpIyNDAiClpqa6rtmyZYtks9mk3377jZnt7igl7Keeekrxb3jUIUmSdO7cOQmAtHv3bkmSbvR/jRo1pDVr1riu+eWXXyQA0r59+yRJurF4CQkJkQoKClzXzJ49W6pfv75UXl7OVoAb3lok6cZE5D4xecOrFkmSpIYNG0r//ve/Le0TSfpdhyRZzx+XLl2S2rdvL+3YscPDdiv6REmLJFnHL59//rnUrVs32d9Z0SdWQ+RwvnRIksjhvGqRJJHDnfCY96zoE5HDyekI2u3lapw8eRIFBQUYMGCA6zW73Y777rsP+/btAwDs27cPDRo0wD333OO6ZsCAAQgJCcGBAweY26xGYmIimjVrho4dO+Ktt95CUVGR63e86nA4HACARo0aAQDS0tJQUVHh4ZNOnTohMjLSwyddunRB8+bNXdcMHDgQJSUl+Pnnnxla74m3FifLly9HkyZN0LlzZ3zyySe4evWq63c8aqmsrMSqVatw5coV9OrVy7I+8dbhxEr+GDVqFAYPHuzR94A140RJixOr+CUrKwstW7bErbfeipdeegm5ubkArOkTqyNyuPk6RA7nT4vI4fzoEDn8Bjxp4SGHVyekxVIUFBQAgEfnOX92/q6goADNmjXz+H316tXRqFEj1zU88Nhjj+Hpp59G27ZtkZ2djU8//RSDBg3Cvn37UK1aNS51VFVV4Z133kHv3r3RuXNnADf6u2bNmmjQoIHHtd4+kfOZ83dmIKcFAF588UW0bt0aLVu2xOHDh/Hxxx8jMzMTcXFxLnt50XLkyBH06tULZWVlqFu3LuLj43HHHXcgPT3dUj5R0gFYyx+rVq3CwYMHkZqa6vM7q8WJmhbAOn657777sHjxYnTs2BH5+fn45z//iQcffBBHjx61nE+CAZHDRQ4nhcjh/OsArOUPkcP58wsvOfymfNMdTDz//POu/+/SpQu6du2Kdu3aITExEf379zfRMmVGjRqFo0ePIjk52WxTDKOk5S9/+Yvr/7t06YLw8HD0798f2dnZaNeuHWszVenYsSPS09PhcDjw3XffYcSIEdi9e7fZZulGSccdd9xhGX+cPn0af/vb37Bjxw7UqlXLbHMMoUWLVfwyaNAg1/937doV9913H1q3bo3Vq1cjLCzMRMsEVkfkcHMROZwfRA7nC5HDyXNTbi9v0aIFAPg8me7s2bOu37Vo0QLnzp3z+P3169dx4cIF1zU8cuutt6JJkyb49ddfAfCnY/To0di4cSN27dqFW265xfV6ixYtcO3aNRQXF3tc7+0TOZ85f8caJS1y3HfffQDg4RdetNSsWRO33XYbevTogejoaHTr1g3ffvut5XyipEMOXv2RlpaGc+fO4e6770b16tVRvXp17N69G9OmTUP16tXRvHlzy/jEn5bKykqfv+HVL940aNAAHTp0wK+//mq5OAkGRA4XOZwEIodbQ4ccvPpD5HA+/eKNWTn8pnzT3bZtW7Ro0QI7d+50vVZSUoIDBw64zo/06tULxcXFSEtLc12TkJCAqqoq16DikTNnzqCoqAjh4eEA+NEhSRJGjx6N+Ph4JCQkoG3bth6/79GjB2rUqOHhk8zMTOTm5nr45MiRIx4LkB07dqB+/fquLUgs8KdFjvT0dADw8AsPWuSoqqpCeXm5pXwih1OHHLz6o3///jhy5AjS09Nd/+655x689NJLrv+3ik/8aalWrZrP3/DqF28uX76M7OxshIeHWz5OrIjI4SKHG0HkcP58IofI4XxrETk8AB36nwFnDS5duiQdOnRIOnTokARA+uabb6RDhw5Jp06dkiTpRrmRBg0aSN9//710+PBh6amnnpItN9K9e3fpwIEDUnJystS+fXvmZTrUdFy6dEn64IMPpH379kknT56UfvjhB+nuu++W2rdvL5WVlXGl46233pLsdruUmJjo8cj+q1evuq7561//KkVGRkoJCQnSjz/+KPXq1Uvq1auX6/fOR/Y/+uijUnp6urR161apadOmzEsP+NPy66+/Sl9++aX0448/SidPnpS+//576dZbb5X69OnDnZaxY8dKu3fvlk6ePCkdPnxYGjt2rGSz2aTt27dLkmQdn6jpsJI/5PB+OqhVfCKHuxYr+eX999+XEhMTpZMnT0p79+6VBgwYIDVp0kQ6d+6cJEnW9gmviBwucrhZWqw0N4kczpcOOUQON18LLzk8aN9079q1SwLg82/EiBGSJN0oOfKPf/xDat68uRQaGir1799fyszM9LhHUVGR9MILL0h169aV6tevL7366qvSpUuXuNFx9epV6dFHH5WaNm0q1ahRQ2rdurX0xhtveDzSnhcdchoASIsWLXJdU1paKo0cOVJq2LChVLt2bWno0KFSfn6+x31ycnKkQYMGSWFhYVKTJk2k999/X6qoqOBKS25urtSnTx+pUaNGUmhoqHTbbbdJH374oUftQl60/PnPf5Zat24t1axZU2ratKnUv39/V7KWJOv4RE2Hlfwhh3fCtopP5HDXYiW/DB8+XAoPD5dq1qwptWrVSho+fLj066+/un5vZZ/wisjhfOkQOZzPuUnkcL50yCFyuPlaeMnhNkmSJO3fiwsEAoFAIBAIBAKBQCDQyk15plsgEAgEAoFAIBAIBAIWiDfdAoFAIBAIBAKBQCAQUEK86RYIBAKBQCAQCAQCgYAS4k23QCAQCAQCgUAgEAgElBBvugUCgUAgEAgEAoFAIKCEeNMtEAgEAoFAIBAIBAIBJcSbboFAIBAI/r+9845vqnr/+CdJR7r3hLYUKHsPEQeKIAKK4vq6xfHVn35Bvw7cqF9lo4giCg6GOACRPWTI3qOlu7Slu3SvdKTZ5/dHcm+TNLtJehPO+/XKC5rcJOeTc+499znPc56HQqFQKBQKxUF4WHOwSqXCiRMncOrUKZSUlEAsFiMiIgIjR47E5MmTERcX56h2UigUCoVCMQKdnykUCoVC4S4Webrb29uxYMECxMXFYfr06fj777/R1NQEgUCAa9eu4dNPP0ViYiKmT5+O8+fPO7rNFAqFQqFQQOdnCoVCoVBcAYs83f369cP48ePx008/4e6774anp2enY0pKSvDHH3/g8ccfx0cffYSXXnrJ7o2lUCgUCoXSAZ2fKRQKhULhPjxCCDF3UE5ODgYOHGjRB8rlcpSWlqJPnz5dbhyFQqFQKBTj0PmZQqFQKBTuY5HRTaFQKBQKhUKhUCgUCsV6rM5e3rt3bzz//POQSqU6z9fV1aF37952axiFQqFQKBTLofMzhUKhUCjcxGpPN5/PR9++fREcHIzdu3cjOjoaAFBdXY3Y2FgolUqHNJRCoVAoFIpx6PxMoVAoFAo3sdrTzePxcODAAfTs2ROjR4/GpUuXHNEuCoVCoVAoVkDnZwqFQqFQuInVRjchBP7+/ti+fTueffZZ3HHHHfjtt98c0TYKhUKhUCgWQudnCoVCoVC4iUUlw7Th8Xjs/xcvXozBgwfjpZdewhNPPGHXhlEoFAqFQrEcOj9TKBQKhcJNrDa69beAP/300+jTpw8efPBBuzWKQqFQKBSKddD5mUKhUCgUbmJ1eLlKpUJkZKTOc+PHj0daWhqOHj1qt4ZRKBQKhUKxHHvOzydPnsSMGTMQGxsLHo+HnTt36rxOCMEnn3yCmJgY+Pj4YPLkycjPz9c5pqGhAU899RQCAwMRHByMF198Ea2trTrHpKen4/bbb4dQKERcXByWLVtmVTspFAqFQnEFrPZ0GyMqKgpRUVH2+jinolKpUFFRgYCAAJ3wPAqFQqFQrIEQgpaWFsTGxoLPt3pd2yHYMj+3tbVh+PDheOGFF/DQQw91en3ZsmVYuXIlfvnlFyQmJuLjjz/GPffcg+zsbAiFQgDAU089hcrKShw+fBhyuRzPP/88Xn75Zfzxxx8AgObmZkyZMgWTJ0/GmjVrkJGRgRdeeAHBwcF4+eWXLWonnb8pFAqFYi8cOYdbXDJs5MiRFk1oKSkpXW6UsykvL0dcXFx3N4NCoVAobkJZWRl69uzplO9y9PzM4/GwY8cOzJw5E4D6piQ2NhZvv/025s6dCwAQiUSIiorChg0b8PjjjyMnJweDBg3CpUuXMGbMGADAgQMHMH36dJSXlyM2NharV6/GRx99hKqqKnh5eQEA3n//fezcuRNXr161qG10/qZQKBSKvXHEHG6xp5uZbAH1hLt48WK88sorCA0NtWuDuoOAgAAA6h84MDCwm1tDoVAoFFelubkZcXFx7LziDJw9PxcVFaGqqgqTJ09mnwsKCsK4ceNw7tw5PP744zh37hyCg4NZgxsAJk+eDD6fjwsXLuDBBx/EuXPnMGHCBNbgBoB77rkHS5cuRWNjI0JCQjp9t1QqhVQq1dEL0PmbQqFQKF3HoXM4sRF/f39SUFBg69s5hUgkIgCISCTq7qZ0mfnz5zv9O4/kVJGHvj9DrtW02PVzu0OLI3AXHYQ4VotKpSJvbrlC5u3IcNh3MNA+4R6W6DiVV0se/O40ya5w7rVa1C4jj/1wlvxytsj8sRyYT+w9PwMgO3bsYP8+c+YMAUAqKip0jnv00UfJv/71L0IIIQsXLiT9+vXr9FkRERHk+++/J4QQcvfdd5OXX35Z5/WsrCwCgGRnZxtsy6effkoAdHpcuXKFLF26lEgkEnYszZ8/n1y/fp38/PPP5OLFi+TAgQNk27ZtJCsri3zzzTdEJBLpHFtfX09WrVpF0tLSyK5du8jevXtJcnIyWbNmDampqdE5tq2tjXz55Zfk6tWrZMuWLeSff/4hZ86cIevXryelpaU6xyoUCrJo0SJSXFxMNm7cSE6dOkWOHTtGNm3aRPLy8siyZctIe3s7mT9/PvuorKwkP/74I7l48SL5+++/yfbt20lGRgZZuXIlaWpq0vn8xsZG8u2335L09HSyY8cOsm/fPnL58mXyww8/kKqqKp1jxWIx+fLLL0leXh7ZvHkzOXLkCDl9+jT55ZdfSElJCVmwYAFRKpVk/vz5RKlUkgULFpCSkhLyyy+/kNOnT5MjR46QzZs3k7y8PPLll18SsVis8/lVVVXkhx9+IK+88grZt28f2bFjB0lPTyfffvstaWxs1Dm2qamJrFy5kmRkZJDt27eTv//+m1y8eJH8+OOPpLKyUufY9vZ2smzZMpKXl0c2bdpEjh07Rk6dOkU2btxIiouLyaJFi4hCodB5T2lpKVm/fj05c+YM+eeff8iWLVvI1atXyZdffkna2tp0jq2pqSFr1qwhycnJZO/evWTXrl0kLS2NrFq1inzwwQc6x4pEIvLNN9+QrKwssm3bNnLgwAFy8eJF8vPPP5Pr16/rHCuRSMjSpUvJtWvXyB9//EGOHTtGTp48SX799VdSVFREFi9eTORyuc57ysrKyLp168i5c+fIoUOHyJ9//klycnLIV199RVpaWnSOra2tJatXryZXrlwhe/bsIbt37yZXrlwh33//Pamrq9M5trm5mUybNo1kZWWRv/76ixw8eJCcP3+erF27tlO7ZTIZWbJkCSkoKCC//fYbOXHiBDlx4gT57bffSEFBAVmyZAmRyWSdzrW1a9eS8+fPk4MHD5K//vqLZGVlkRUrVpDm5madY+vq6sj3339Prly5Qnbv3k327NlDrly5QlavXk1qa2t1jm1paSFfffUVycnJIX/++Sc5dOgQefnll8m6detIWVmZzrFyuZwsXryYFBUVkV9//ZWcPHmSHDt2jPzxxx/k2rVrnLxGTJo0yaprBPP53XWNePjjH8msdRfI/z5foHONeOihh6y6Rly+fJmT14jLly87bA63OLxcn4CAAKSlpaF37952Mf67k+bmZgQFBUEkErn8Snl1dbXT99a/sOESjl6twTv39MfsiX3t9rndocURuIsOwLFarje149Yl6mRPmZ/dA39vu6Wc6ATtE+5hiY5Xf0vG35lVmDOxL+be099JLQP+zqjEq7+noEewD868f5fJY7kwn9h7ftYPLz979ixuvfVWVFRUICYmhj3uX//6F3g8HrZs2YJFixbhl19+QW5urs5nRUZG4rPPPsOrr76KKVOmIDExET/88AP7enZ2NgYPHozs7GwMHDiwU1v0Pd2MV8Id5m/gxjqfXQWqhXu4iw7A9bSM/PwQGsVybHv1FoxO6IhGcjUdxnDkHM6NLC8Uu7Fr1y6nf2dJfRsAoLZFauZI6+gOLY7AXXQAjtVS2dTO/r+mWeKw7wFon3ARS3TkVrcAAGpaHDs+9KkQqb/velM7WqUKp343F4mOjgagvsnSprq6mn0tOjoaNTU1Oq8rFAo0NDToHGPoM7S/Qx9vb28EBgbqPNyJG+l8dhWoFu7hLjoA19KiVBE0tcsBAE1imc5rrqSju6BGt5sxevRop36fSkVQ1qg2lux9I+xsLY7CXXQAjtXCGDYAUGPnBRx9aJ9wD3M6JHIlSurFABw/PvTRXhDK1xj+NzKJiYmIjo7GkSNH2Oeam5tx4cIFjB8/HoC6VFlTUxOSk5PZY44ePQqVSoVx48axx5w8eRJyuZw95vDhw+jfv7/B/dw3AjfK+exKUC3cw110AK6lRdQuBxMf3SiW67zmSjq6C4vjN1euXKnzt0KhwIYNGxAeHq7z/Ouvv27xly9evBjbt2/H1atX4ePjg1tuuQVLly5F//4dYYMSiQRvv/02Nm/eDKlUinvuuQfff/+9TghDaWkpXn31VRw7dgz+/v6YNWsWFi9eDA8Px4WnchV9r4HDv69FAplCBQCoabbvjbCztTgKd9EBOFZLlUjL0+1go4r2Cfcwp6Owtg1KlXq2t/e1xhyVWpEXedUtGBnPLYPQEfNza2srrl27xv5dVFSE1NRUhIaGIj4+Hm+88QYWLFiApKQktmRYbGwsG4I+cOBATJ06FS+99BLWrFkDuVyOOXPm4PHHH0dsbCwA4Mknn8Rnn32GF198Ee+99x4yMzPxzTffYMWKFTb+Eq7PjXI+uxJUC/dwFx2Aa2lpaOvwbut7ul1JR3dhsVWqPwlGR0fj119/1XmOx+NZNamfOHECs2fPxtixY6FQKPDhhx9iypQpyM7Ohp+fHwDgzTffxL59+7B161YEBQVhzpw5eOihh3DmzBkAgFKpxL333ovo6GicPXsWlZWVePbZZ+Hp6YlFixZZ3BZ3QSaTmT/IjjCeJwCobbXvjbCztTgKd9EBOFZLRVOHYWPvrQr60D7hHuZ05Nd0eJi709OdV93q1O+2BEfMz5cvX8bEiRPZv9966y0AwKxZs7Bhwwa8++67aGtrw8svv4ympibcdtttOHDgAFujGwB+//13zJkzB5MmTQKfz8fDDz+ss0AQFBSEQ4cOYfbs2Rg9ejTCw8PxySefWFyj2x25Uc5nV8JWLSoVQZtMgQChp51bZDvu0i/uogNwLS2NWoa2tgEOuJaO7sJio7uoqMjuX37gwAGdvzds2IDIyEgkJydjwoQJEIlEWLt2Lf744w/cdZc6ec369esxcOBAnD9/HjfffDMOHTqE7Oxs/PPPP4iKisKIESMwf/58vPfee/jf//6nU4rkRqBPnz5O/b7Shg6ju6ZZCkKIRfViLcHZWhyFu+gAHKulUsfT7dg9u7RPuIc5HXlaYd0NbVIoVQQCvn2uNeaoFOl6urmGI+bnO++8E6byrPJ4PHz++ef4/PPPjR4TGhqKP/74w+T3DBs2DKdOnbK5ne7GjXI+uxK2apn9RwqO5dbg+NyJiA4Smn+DE3CXfnEXHYBradE2tPXDy11JR3fBqT3dIpEIANjaosnJyZDL5Tq1QAcMGID4+HicO3cOAHDu3DkMHTpUJ9z8nnvuQXNzM7KyspzYem5w4sQJp35fqZanu12utGuSIWdrcRTuogNwrBZtw6bWweHDrtgnZwvqDCaYc0UthjCnI7eqw8OsIkC9nSNrjKFQqlDdzG2jm+I+3Cjnsythq5ZLxY2QyFXIqhDZuUW24y794i46ANfS0mgivNyVdHQXFhndmzdvtvgDy8rK2NBva1CpVHjjjTdw6623YsiQIQCAqqoqeHl5ITg4WOfYqKgoVFVVscfop6hn/maO0UcqlaK5uVnn4S48/fTTTv2+Ei1PN2DfsE9na3EU7qIDcKwW7fByR4cPu1qfHMmpxpM/XcC729I7veZqWoxhTod2eDngvBDzmhYpVASsV726WQpRu9zMu5yHM+ZnivO4Uc5nV8IWLSoVYUNxHb1dyhq43C+VonZUaG3lMQWXdViLK2mp1/F06xrdrqSju7DI6F69ejUGDhyIZcuWIScnp9PrIpEI+/fvx5NPPolRo0ahvr7e6obMnj0bmZmZVt1A2MrixYsRFBTEPuLi4gAAhYWFWLZsGaRSKRYsWAAAWLBgASoqKrB27VpcunQJBw8exPbt25GdnY2VK1eiublZ59iGhgZ89913SE9Px+7du7Fv3z6kpKTghx9+QG1trc6xYrEYy5cvR25uLv78808cOXIEZ8+exYYNG1BWVqZzrFKpxOLFi1FSUoJff/0Vp0+fxvHjx7F582bk5+fjiy++gEQiwSOPPMK+p6qqCj/99BMuXbqEAwcOYMeOHcjMzMS3334LkUik8/lNTU1YtWoVMjIysHPnTuzfvx/Jycn48ccfUV1drXNse3s7li9fjvz8fKTml+n8tlnXSrFw4UKoVCosWLAAKpUKCxcuRGlpKTZu3IgzZ87g6NGj2LJlC/Lz87F8+XK0t7frfH51dTV+/PFHfPDBB9i/fz927tyJjIwMrFq1Ck1NTTrHikQifPvtt8jMzMSOHTtw4MABXLp0CT/99BOqqqp0jpVIJPjiiy+Qn5+PzZs34/jx4zh9+jR+/fVXlJSUYPHixVAqlTrvKSsrw4YNG3D27FkcOXIEf/75J3Jzc7F8+XKIxWKdY2tra/HDDz8gJSUF+/btw+7du5Geno5nnnkGDQ0NOsc2Nzdj5cqVyM7Oxvbt23Hw4EFcunQJa9euRUVFhc6xUqkUy5YtQ0FBATZt2oTjx4/j1KlT+O2331BcXIwlS5ZAoVDovKe8vBzr16/H+fPncfjwYWzduhVXr17FihUr0NraqnNsXV0d1qxZg9TUVOzduxd79uxBamoqVq9ejfr6ep1jly9fjq+//hrZ2dnYtm0bDh06hAsXLmDdunWd2i2Xy7F06VIUFhbi999/x8mTJ3Hy5En8/vvvKCwsxNKlSyGXy9UaFUrUaXkuS2oacejQIWzbtg3Z2dn4+uuv0dLSovP59fX1WL16NVJTU7Fnzx7s3bsXqampWLNmDerq6nSObW1txYoVK3D16lVs3boVb7zxBs6fP4/169ejvLxc51iFQoElS5aguLgYv/32G06dOoXjx49j06ZNKCgo6JZrxC8nrgIALhTU4syZMzrXiFWrVll1jdD+fGdcI7Zs2YKjR4/izJkz2LhxI0pLDV8jFixYYPQa0dDcypYm9OWpJ/qNW3ciOTnZ4deIAycvAAAi/Dzgr/nuj5atMnqN2L59O5yJM+ZnivNYtWpVdzfBLriLDsA2LaJ2OZv4kUtGN1f7Ra5U4b6VpzF95SlIFUqzx3NVhy24khZtT3djm+7isyvp6C54xNSmLS12796Nb7/9FkePHoWfnx+ioqIgFArR2NiIqqoqhIeH47nnnsObb75pdXH0OXPmYNeuXTh58iQSExPZ548ePYpJkyahsbFRx9udkJCAN954A2+++SY++eQT7N69G6mpqezrRUVF6N27N1JSUjBy5MhO3yeVSiGVdlwEm5ubERcX55BC6O7OyM8PoVEsR5CPJ0Ttcqx8YiTuHx7b3c2iuBil9WJM+OIY+3eIryeufDKlG1vEHcQyBUbP/wftcvWNyPkPJnFmf6CzyCgXYcaq0wj188LwnkE4lluLpQ8PxWNj4x3+3XvSKvDapisY2ysEvl4eOJFXi4UPDsFT4xIMHt/c3IygoCCnzieOnJ+5Tnf83hSKOa7VtGLyV+pw22fHJ+DzB4Z0c4u4TUVTO25ZchQAcPq9iegZ4tvNLaIY4q0/U7E95ToAIDLAGxc/mmzmHa6HI+cUi/d033///Th8+DCqq6uxceNGzJkzB0899RT+97//4cKFC6ioqMCSJUusmtAJIZgzZw527NiBo0eP6hjcgLrmm6enp04t0NzcXJSWlurUAs3IyEBNTQ17zOHDhxEYGIhBgwYZ/F5vb28EBgbqPNwFxmvjDJolcjaRwugEdQkdQ3tObcWZWhyJu+gAHKelQpNELchHneW1USxnS9E5AlfqkyM5NazBDXTeU+xKWkxhSgejOSnSH5EB6gUHZ5UNYxL8xQT5oF+UPwAgn2MZzB0xP1O6hxvhfHY1bNGinXOCS55urvaL9nah+lbzWbC5qsMWXEmL7p5uuU6yTVfS0V1YXcg6PDycrcPZVWbPno0//vgDu3btQkBAALsHOygoCD4+PggKCsKLL76It956C6GhoQgMDMRrr72G8ePH4+abbwYATJkyBYMGDcIzzzyDZcuWoaqqCvPmzcPs2bPh7e1tl3a6Eq+99prTvotJohbm54XEcHWJN3tOLs7U4kjcRQfgOC2MYTMwJgDJJY2QKwlqW6XoEezjkO9zpT7Zl16p83dedQsm9Itg/3YlLaYwpSNPs5+7X1QAgn3VCzPO2tPNJPiLCRaib4Ta6OZqMjV7zs+U7uFGOJ9dDVu0aGd5rnNS0kdL4Gq/aCerrG8z/3txVYctWKLFnpWBukKDVsZymVIFsUwJP2+1KelOfeIoujV7+erVqyESiXDnnXciJiaGfWzZsoU9ZsWKFbjvvvvw8MMPY8KECYiOjtbZMycQCLB3714IBAKMHz8eTz/9NJ599lmTZUzcmY0bNzrtu5hyYXGhvogMUC9w2PNG2JlaHIm76AAcp4UxbGKDfBDhrx5LjvQOuEqftEoVOJarjuKZPFDtpdQ3+FxFizlM6cir0hjd0QFa1xrHlpVjqGzqGJv9ogLU7eGo0U1xfW6E89nVsEVLnZbRzSVPN1f7Rfvesc4CTzdXddiCOS21LVLctvQYlh246qQWGadRrza39uKSO/WJo7Da021PLNlOLhQK8d133+G7774zekxCQgL2799vz6a5LBMnTnTadzFGd0KYLyIC7G8oOVOLI3EXHYDjtDCGTUywEBGBQlSIJHbdqqCPq/TJP9nVkCpU6B3uh5kjY/FPTjXy9EKbXUWLOUzpYDT3i/R3ekbgjvByIfpGqj3dda0yNLTJEOrn5ZQ2UG4cboTz2dWwRQtXw8u52i+12p5uC4xuruqwBXNakksacL2pHbtSK/Du1AFOapVh9I3uJrEcceoqz27VJ46CU3W6KZ1Rqgj+/ctlvPpbMuRK83tc8/PzndAqNSWa8PKEUN+OfZZ29D5pa8mqEGHaN6fw5+UyE+/gJs7sE4YLhfWYsuIEUkob7fq5jtKivW+W8XQ7MnzYEh07r1zHtG9OobDW+v275wvrcdeXx3Eyr9aW5rHs1YSW3zcshvWy5le36CxYdsf4cgTGdLRKFbiuKSPTLyoAEey1xjk3shVMeHmQD/y8PRAXqt7yQL3dFEfg7uezK2KLFm0PYJtMiTapwp5Nshmu9ovunm7z13au6rAFc1qYRZtKUbtFdoCjkClUaNGM4+hA9TysXTbMnfrEUVCjm+MU1Lbin5xq/J1ZhdXHC8we7+PjmD2whihtUJfwiQv1RWSg/Q0lRotErsR/N6cip7IZW13Q6HZmnzBsTS5HXnUrNp4ttuvnOkoLU6M7NljokLGkjyU6Np4rRk5lM9adKbL68/ekVaCwrg3bU8ptaR4AdckZxmi/d1gseoX5wVPAQ5tMyRqhQPeML0dgTEe+xriNCPBGiJ+XzlYWC4tv2IxMoWL3Y8YEq28y+kXSEHOK43D389kVsUWLvreWK/u6udovOkZ3m3lPN1d12II5LYzRrSJAlcg526oM0aQxsAV8HhLC1NnltY1ud+oTR2Gz0S2TyZCbmwuFghurd+6K9o3dyiP5yKoQmTw+LCzM0U1i6Qgv92NvhJvEcotqLFoCo2XF4Txcq1F7GxnjzJVwZp8wMEnuku3s6XaUFm1Pd6QDtiroY04HIYTNUP13RhUUVq4uM+eGfii4NRzOroZMqUJSpD/6RwfAy4PPJizUzp7dHePLERjTwWhlMoczW1lkChWa2x07/1Q3S0AI4OXBR5gmlLxfNPeNbjo/uy7ufj67IrZo0U8GxpUQc672i3aUpCULFFzVYQvmtNRqLeCUae4tugNmMSTE1xNh/ur5UDvc3J36xFFYbXSLxWK8+OKL8PX1xeDBg1FaWgpAnbVuyZIldm/gjQ5z087jAQoVwdt/ppk0arXrlTsSuVLFGsAJYb4I8vGEl0A9nCxJgmEJqampSC5pwI+nCtnnqpslUKoc692yN87qE21KNFEIZQ3tdg35d4SWdpmSLT0XG+TDblWodWCiLHM6qpolbBhVfZsMF4oarPp8ZuvFtdpWm8frvvQKAMC9w2LY55gQ81wtg687xpcjMKYjly0XptYu9BQgUKhOR1Lb6thFuIqmjv3cTOZYxvjvyoKKo6Dzs+vj7uezK2KLFsbTzSSc5oqnm6v9ol0C0pJ7SK7qsAVzWrQXbMob200c6VgaWaPbC8G+GqNbK5u5O/WJo7Da6P7ggw+QlpaG48ePQygUss9PnjxZJ+s4xT4wWXtfuaMPQv28cLWqBSuPGN83MWPGDKe063pjO5QqAm8PPiL8vcHj8VgPlL0SYE2eOh1v/5kGQoCZI2LB1yw8WLLfh0s4q08YJHIlqrUmsJSSJrt9tiO0MF5uXy8BAn08OsaRAz0D5nTkVul6MfdqDGBLUChVbPi3TKFCSX2b1e1rEstwKr8OAHDfsFj2eUPZs509vhyFMR2M1v4aDzMARAY6p1Y3Wy4sqGOuS9IKL3d0eLu10PnZ9XH389kVsUULs6c7IVQdhssVTzcX+0WpIjqLEpbc43FRh62Y01Lbqm10d5+nu0ETSh7i54UQTenOJq3wcnfqE0dhtdG9c+dOrFq1CrfddptOzbjBgwejoMD8nmOKdTD1acf3DsPCmUMAAKuPF+CKkbDhn3/+2SntYsJn40N9weerx4G9jaXZPx5Ccb0Y0YFCfPbAEERpbrQrunFPiy04q08Y9MOP7JlMzRFatA0bHo/XsWfXgQaVOR1MSHOUZn/535lVFicwqWjSjcawxSN6MKsKChXBgOgANmM20OFl1Q4vd/b4chTGdOiHlwNwSIlCQ2iXsmPoG+kPPk+9laaWYwuAdH52fdz9fHZFrNWiVBHWQGEWC7lidHOxX+pbpdAOCGtok0FlJkKMizpsxZyWOq2xU8YBT3eorxdCDHi63alPHIXVRndtbS0iIyM7Pd/W1saJwu3uhFShZMNU+0UFYNrQGNw/PBYqAry9NQ0Seecw83nz5jmlbSVa5cIY7Gl0ny2oQ7ZcPc6WPjIMQT6erLepsqn7Ljq24Kw+YWDGDENyif2MbkdoYUJ4Y4PVhg2TSK2uVWp24rUVczoY7+pjY+IQ7u+FJrEcZ67VWfTZTGg/Q74Ne3+1s5Zrw2Ywr2lhfxtnjy9HYUiHqF2OKk3kTN9ILU+3k2p1s7kGgju8xkJPARLC1Hvr86q4FWJO52fXx53PZ1fFWi1NYhmYIBjmms2VBTou9gtzzxjko/aeKlQEzRK5qbdwUoetmNJCCNELL+9GT3ebuk/Unm7G6O7wdLtTnzgKq43uMWPGYN++fezfzET+888/Y/z48fZrGQWFtW1QqggChR6sx+3zBwYjIsAbhbVt+PJgbqf3LFiwwCltK63vyFzOYEsCrDapAutOF+G7Y9d0Hu9sTQcAPDkuHnf0iwCgTrIF2M/TfSy3BpnXTSemswfO6hMGZkFkYEwgACDjushuye0coaVKL4Q3XFMyTKEiOhd0e2JOB2N0D4gJxNQh0QCAfRpD2BylepEGuVYa3fWtUpwtqAegzlquTUKYH7w8+JDIVSjTTL7OHl/WUFzXhn+yqy061pAOZsEiJkjI3pABWgt8Dg4vZ/JWxGh5ugEgKZLZ182tZGp0fnZ9uHw+W4O76ACs18IknAr29UR0EJOjhBtGNxf7hVk87RHsgwBNvg5z+7q5qMNWTGlpligg04qy69Y93Zr7sVA/T4T4eeo8B7hXnzgKD2vfsGjRIkybNg3Z2dlQKBT45ptvkJ2djbNnz+LEiROOaOMNC3ND1y8qgL15Cvb1wtKHh+KFDZex9kwRpgyOxk2Joex75s6d65S2sZnLdYxu6xNgvb89A3vSDO+X7REsxIfTB7J/29PTXVLfhhc2XILQQ4D9/72dzQrtCJzVJwxMePmEfuGoaZagvk2GrIpmjIoP6fJnO0ILs4gSrTFsPAV8hPp5oaFNhpoWKcI0Rrg9MaVDpSLIr2FCmgMQ6ueF386X4mBWFRY+OBReHqbXKpnM8b3CfFFcL9YJBbeE09fqoFQRDIoJ7DQuBXwe+kT4I6eyGXnVrUgI83P6+LKG1zZdQcZ1EXb85xaMNDP+DOlgQvOTogJ0nmevNQ72HjGe7lgtTzegDhk9lF2N/BpuGd10fnZ9uHw+W4O76ACs18IkUQvz80KEZv6qtVOC2a7CxX5hFk+jAr0hkSvRIlGgvlWqs7VKHy7qsBVTWpjFGgGfB6WKoKpZAqlCCW8PgbOax9KglUiN9XS3dUQkuFOfOAqrPd233XYbUlNToVAoMHToUBw6dAiRkZE4d+4cRo8e7Yg23rAwRrf+DeddA6Lw6OieIASYuzUNbdKOsjDffvutU9rGhDAzYZZAR1iwpd6nfemV2JNWAQGfh0dG98RjY+LYx5Pj4nEbyYK/d8e6UIwm/LjSDp7uzOvNIARolysxd2uaQzOiO6tPGJjEXQmhfqyhk2KnEHNHaGENG61kVY7es2tKx/WmdohlSngJ+OgV5ouxvUIRGeCNZokCp/JrzX42c25MHhgFACisa7V4PzjQsZLNRCro0z9K18vq7PFlKSKxHBmaSJKcSvPGqSEdbBK1KN2bL2uvNbbCXGuiA/U83UwW+SpuGd10fnZ9uHo+W4u76ACs18KUCwvz82ajcuo44unmYr8w83xkgJAtRWWuVjcXddiKKS2M0Z0Q6gsfTwEIASq7qXRuh6e7w+jWTqTmTn3iKKz2dANAnz598NNPP9m7LRQ9GC+P/g0nAHw8YxDOXKtDaYMYS/6+ivmaJGszZ850eLsIIaynWzu8nFnRtcRQqm2RYt7ODADAf+7sg7en9O90TH6+rneJMcoqRF33dGuHhSaXNGLt6UK8PKFPlz/XEM7oE22099uPTgjBPznVSC5pxL9v7/pnO0ILM4EwiyqAOnz4alWLw0LyTOlgxkbvCD94aMrgTR8agw1ni7EvvRKTNMa0MZhz4+beYdh0sRRtMiWK69o6LZ4Zo2OPu9Dg60l6GcydPb4s5UpZx0KP/j53QxjSYWzhseNa47ibD4lcya7s6/eFdkI7Qgin9kvT+dm14er5bC3uogOwXgtz3Qjz92KN7toWKSeuFVzsF+Y6HhnoDVG72nNqLoM5F3XYiiktTDRXRIA3BHwe8mtaUd7Yjl4OjM40Buvp1jK622RK1vPuTn3iKKz2dAsEAtTU1HR6vr6+HgKB88Md3Bnt8HJ9AoWeWPbIcADAr+dLcFpTXig5Odnh7apvk0EsU4LHA+JCOwwlxvtkzlAihOCjHRloFMsxMCYQr92VZPA4fS2sp9sOq3xMWOjQHkEAgC8P5dmU8MoSnNEnDCoVQXmD2miLD1Ub3YB6YcEe5Y0coaXCoKdbUxLKQUaVKR2GQpqZhGaHsqsNJjBk0F6Q6hXuq2UgWx5i3pHN3cfg6/30PtOZ48satKMr9DPqG8KQjrzqjjB/bVhPtwO9R0w/+HgKdPaTA0DvcH948HlokSrYRG9cgM7Prg9Xz2drcRcdgPVamP3IoX5ebI4SmVKF5naFqbc5BS72CxOxFBngzXq6ze3p5qIOWzGlhbmfjgjwRs8Q9T1BWTclU2Oyl4f5eSFA6AFN4SI0aTKYu1OfOAqrjW5jN+5SqRReXl5dbhBFTbtMyd68G/OQ3ZYUjqdvjgcAvPtXGpolckRHRzu8bUz4bEygUGdfCWMomcs6vePKdRzKroangIev/jXc6B5ZfS2MUVbTIoHCinBdQzBhoXPv6Y87+0dAplDh7a1pXf5cQzijTxiqmiWQKVXw4PMQEyTEsJ5B8ODzUNMiZWtHdwV7a2mVKtAiUd+IaHu6HR0+bEpHvoGQ5lHxIYgJEqJVqsCJPOMh5g1tMrRqtnv0DPFlPaLWJNxiPN0xRjzd/TXXg4KaViiUKqeOL2tI1ipVp59R3xD6OhraZGzt1iS9vX0RmmtNi0RhchGkK1Rq9YO+d8rLg896GrgUYk7nZ9eHq+eztbiLDsB6LYyXNszfG0JPAZscrLa1+xfouNgv1axhKWRzuDAh+sbgog5bMaWFMbrD/b3RM0QdWdodGcwJIWzIf4ivF/h8XqcM5u7UJ47C4vDylStXAlBnQ/3555/h799xE6RUKnHy5EkMGDDA/i28QSmobQUhzEqp8ZulD6YNxMk8dZj5gr3ZuD/aph0DVlFmILQcUIdS8XjqrNMNYhm7wqtNlUiCT3dnAQD+OynJ6L5VAPDw0NUS7u8NTwEPciVBTYuULTFlLVKFEsVsKTZ/LHloGKasOIH0chFWHy/Aa5MMe95tRV+HI2GMm54hPvAQ8OEhAAbHBiKtXITkkkb2om0r9tbCGDYBQg+d/fts8hkHeTJN6cg1ENLM5/MwfWgM1p4uwr70Stwz2PDkwiyURQcKIfQUaHmlLTfMDNWG1qZniA98PAVolytR0iB26viyFKWKILW0if27tF5sNrRSXwfzm/UM8YGft+5rgUIPeHvwIVWoUNsi7XQtsgfm+qFflD+u1bQiv7oVd/bvXKbLmdD52X3g4vlsC+6iA7BeCxOGy9y7RQR4o0WiQG2LDH2dcKkgRJ0MtE+EPwR83WsuF/ultrkjvLymRbOn24ynm4s6bMWUljqt8HJPgbovuyODebtcCalC7ZQK9VP3UbCvJ+rbZOx4d6c+cRQWe7pXrFiBFStWgBCCNWvWsH+vWLECa9asgVgsxpo1axzZVk5CCIFK1fnRVRjvSVKkv8kbVT9vD3z56HDweMCfl8txIL28U1vsEVasTUcSNd0bXU8BH6GalS9DHkpCCN7blo4WiQLDewbhlTtM76EuKirS+ZvP5yEqUJPBvAv7uovq1KXYAoQeiA4UIjpIiM8eGAwAWHk0H1kV9i0jpq/DkRhaEBmVYL9kavpajI1/S8+JCiOGjaVbFWzFWJ8oVQTXagyHNDMh5v/kVKNdZti7yhjd8Zpzw1qjWyxTsHvajHm6+Xwem9U1v7rFqePLUnKrWtAmU8LPSx0J0yJVsCFoxigoLNIZL6a21/B4vI6yYQ7agsDW6A4y3A+2LKg4Cjo/uw9cPJ9twV10ANZrqdcKLwe0FpGdVKv71/MlmLLiJDacLe70Gtf6hRDC/i5RgUKE+Wk83WaMbq7p6AqmtOiGl6vvKyzZrmVvGMPay4MPX8283pFMTT23u1OfOAqLlyWYH3PixInYvn07QkK6Xn7I1SmobcUjq8+i0cDN5FPj4rHwwaE2f3ZejfEbTn1uSgzFi7cm4ufTRfitNAC/fbhf5/XEcD/smnMrAoWeRj7BOpikSNqZyxkiArxR3yYzOLnsTqvAibxaeHnwsfxfw9kkVcaYMGFCp+dig3xQ3tiOiiYJRifY1n5mQUO7FNvMET1wILMKB7Oq8fafadg95zazpaHMoVIRvLbpClLLozGpqd2kZ37+3mzsz6jEX6/egh4mjttyqRRf/5OPdc+NNRgl0NE3HUb36IQQrD9TrBPuayvafZJX3YInfjxvNssow/3DY7HyiZE6z1UaCaV29J5uQ2MLUE9mUoUK3h58xOt5T0fEBaNHsA+uN7XjeG4Npg2N6fR+ZkGKeS9z/hbXiy0q88HUhfb39jB5vvaLCkDGdRFyq1oxU0vL9aZ2PLP2AsYlhmHxQ9Zdf1Qqguc2XIJCqcLGF24ye36aghlroxJCkFfdgupmKUoaxAjxMxy18/OpQizOCcWnetcuwPg1MDLAG+WN7Q7bgsAsCMUYOR+5ZHTT+dl9MHZtcjXsqUMkluONLVfw4KieuH94rN0+11Ks1aKdvRyATjI1Z8CUYT1fWI8Xb0vUeY1r46tRLIdcqV6Uj/DX2tNtJrycazq6gikt2kZ3mGb+7A5PN1MaLNTXS6eEMdARXu5OfeIorL6rOnbsGJ3QNexPrzRocAPA7xdKcSCz0ubPZmr79ou2LOPx3Hv6Y5CRUO2iujYcyKiyuS36MKts+kYJAERqPNE1BpILHchUt+Gl2xPRN9K8rj/++KPTc9FBXfd0s7+t1p5dHo+HhQ8ORaifF65WtWDlkXybP5/htwsl2JdRiesiGd7blm404uBgVhXWni5CpUjC/kbG+PV8CSpFEmxPKTf4OhuFENqxIMIkU8upbIFY1rVELkyfyJUqvLkl1WKDG1Avuuiv0FYYSRrm6JJhhsYW0BFa3jeyc1gej8fD3YPUmcvPFtQbfL9+/fqoQG8ECD2gVBEU1prP4F3F/h6GvasM7F7xmhZWCyEE7/2VjsLaNmy9XGbUG2+M/JpWnMyrxdmCelwoarDqvfowURWjE0LYsciUsjPE9pTrUBo4PbwEfNw1wHA8pqNrdTMLQrFGPd3qPihrbLd7NJGt0PnZ9TF2bXI17KljX0YljuXWYvmhXLt9pjVYq6VeK3s54Fyju0UixxXN1p7C2s4JPLk2vpiF9RBfT3h58NmQfHOebq7p6AqmtLDZy/29EafxdNe0SB2Wy8QYDeKOzOUMoX5qxwDj6XanPnEUNgXgl5eXY/fu3SgtLYVMpntifPXVV3ZpmCvAeHPemzoAj42NY5//4UQBfjhZiI92ZGJsr1A2MYQ1sN7YyM7lwgwh9BRg72u3ob5VopOldv2ZInx79Br2pFfgX1pt7Ar63jxtjBlLhBAka27EJyRFWPQ97777bqfnGI9oRRcymBsLWw3398aCmUPwn99TsPpEAe4eFIXhccE2fUdxXRsW77/K/n0qvw6/XyjF0zfruufrW6X4aEcG+3dKSWOnlWkGsUzB1jtONhIqbii8PCbIBzFBQlSKJEgrE2F8nzCbNAEdffLdsWvIqmhGkI8ndvznFnbF0xiv/paMC0UN2JdRqbOtoMpA5nKg4yZFLFOiVarQ2e9tDwyNLaAjiZox7+rYXqHYcLbY6O9fypwbmkgDHo+HflEBSC5pRF51i8kcBkBHJndj3lUGpn351S1YqdHy24VSnL6mrmKgUBGklzdhXG/L+1pb0970CtzaN9zi9xr7rFHxIShraMfF4gajIXFKFUGB5uZw95xbdfIO+HgK4ONlODrA0cn2Ks14unuF+eHY3DsRH+rb7WWAtKHzs2tj7NrkathTB1NtpKRejAozUWOOwBotCqWKNUIYz6Qzje7zhQ1QaLZzldSLIVeq4KkVtcS18dWRuVx9D8BEB4ja5ZApVEYjDrmmoysY06JUETYpX2SAN4J9PeHnJUCbTImKpnb0jrDMPrAHTOZyxtAGOsLLmdBzd+oTR2G1p/vIkSPo378/Vq9ejeXLl+PYsWNYv3491q1bh9TUVAc0kZuoVIRdTbytbzhC/bzYx1tT+qF/VADq22SYtzPTai9Im1TBZpq2JLycgc/n4YeVy3Xa8tCongDUnrkGK7ySxmiXKVmDWn9PN2B8crne1I6aFik8+DwM6xls0XctXry403PM3t+ueLpN7RWdPjQGM4bHQqkieHtrmk2riUoVwdytaWiXKzG+dxjGeam90ov257BGGaBeiPh4VybqWmUI1GQ3TTERAp5WJoJSM5lmXm+GVNG5bdo1urVh93V3McR88eLFyLwuwqqj1wAA82cOQe8If50xZ+gxQxMSuC9dN/qDMWyi9YxuP28Pdj+wI25UDI0twHiJKoZRCcEAgKtVzWiTdo4aKDUQBdJhIJsvG8bWLA804+nWRMAU1rZhwaIlKKlvw+L9OQCgNZaazH6fNtpj4+/MKshtzORf2yJFaYMYPB4wIj6YHYvGMpiXakL6BVBhcGyQzrgxZnADjq/VXWHG0+0h4CMx3K9TRER3Qudn18fYtcnVsKcOJs8GoA6ZdjbWaGE8gjxeR/htuBP3dJ/K76iuoVCRToudXBtfzP0ks4ga5OPJXlOZsGVDcE1HVzCmpaFNBhVRj6VQP3VYN7uv28kh5g1amcsZ9MPL3alPHIXVRvcHH3yAuXPnIiMjA0KhENu2bUNZWRnuuOMOPProo45oIycprGuFqF0OoScfA2J0b9C9PQTqPct8Hv7OrMJuzf4aS8nXTDARAd5G90AaY968eTp/J4b7YXBsIJQqYjZ02RKY+oCBQg+D3s1II0Y34/kaFBto8kZaG30tQEfYLWOsWYtEk/EZAJKiDK8Sfn7/YEQEeONaTatN4WzrThfhckkj/LwEWPbIMGz638sYlxgKsUyJuX+lsUnF9qRXYn9GFQR8Hn6eNRYCPg+VIgl7s6+PtlEkU6qQeb1Z53VRu5xdYdePQhgd31Gvuyu88/4HeOvPVChUBNOHRmPGsM77mg0xbUg0BHweMq6LUFzXEWbMGjYGPBemtip0FUNjC9BekDE8NmKCfBAbJISKAGllTTqvSeRKtmazdr4D5rNyLdj7yybvMpJEjSE2SAh/bw8oVASPvfQa3tmaDrFMiXGJoZhzV18A1ve1dqK9JrHcaAi92c/RjNP+UQEIFHp2GN1GPN1MVM/AHsFWGbCOrNXdJlWgWVPKTn9BiMvQ+dn1MXZtcjXsqaNAy+g+Z+N1qStYo4UxTkJ9vdjrGeOMqHOCp/t0vjraiQm+0d/WxLXxVa2ZM5nfiM/nsQnoTC24c01HVzCmhclcHurrxeZYiQtV3ys5u2wYY1iHatkkIb664eXu1CeOwmqjOycnB88++ywAdXr49vZ2+Pv74/PPP8fSpUvt3kCuwtzQDu8ZrBO6wzCkRxBeu0tdeuqTXVlWGQ55VaZv/E2xYMGCTs/dN0ztZdybbp3xb4gSvfBZfYwlwErRCje1FENaGOPM1vDyazXqUmwhvp6sp0yfED8vLNEkofr5dBEuFVu+vzW/ugVfaAz1j+8bhLhQXyxatBBfPDIcvl4CXCxqwPqzxahpkeCTXZkAgNkT++KmxFB2T74xY4l5nrFL9LORMyva4f5enUosjdbydHdl/+m/PtuAvOpWhPl5Yf4DQywOqw3z98YtmrD2fRlqbzchpCOE14BhE+HAfd2GxpZCqWJvUExFmDBRA/r9xPz+Ad4e7GSk/Vn5FhjdxrK568Pj8dhFo+dW7sfF4gb4eQnw5aPDMTohFIB1fd3QJkOhZjGEydK+18rFQgb2XNf8TsxWB2Ph5czvIqkutup72GuNA8LLmXEZ4O2BADsloHQGdH52fQxdm1wRe+lokyrY6yIAnOsGT7c1WvQzlwPOy15e1iBGYV0bBHwe7uin3sZXoLevm2vjizGso7Siu5iwfFM5Y7imoysY06KdRI2ho1Z393i6dYxuP11Ptzv1iaOw2uj28/Nj94nFxMSgoKCAfa2urs5+LeM4yVqJgozxn4l9MLRHEETtcnywPcPiG2DG25ZkQbIxfWbNmtXpuXs1WZbPF9Z3OVSXSYaknahLG2PeJ2b/u6nfSx9DWhjjrK5VajC82hx5WjWYTRmMkwZG4ZHRPUEIMHdrmkUJyBRKFeZuTYNMocKd/SPYff6zZs1CfJgvPrp3IABg2YGrmP17CprEcgyODcSciWrP5GgjxhygNlAZD+LUIdEGjzO1135QbCCEnnw0ieWscWUtKaWNyFCov3vRQ0OtzlXAjMO9mhDz5nYFxJpkX/qJ1ADHGt2GxlZxvRgypQq+XgKTGeTZftIL1S/V2k+vPbYYo7ukQWx2u4KxbO6G6Ke5PlSp1P9+eO9AxIX6YkiPQHgJ+Ghok7H16M3BGMp9IvzYvAMHs6ogU1gfYp6st8DGJJWrapYY1J+n8WJNHjvIqu9ht7I44EbW0ogDrkHnZ9fH0LXJFbGXDsZoDBR6QMDnobyx3eklk6zRop9EDeiIAKxvlbJbxBwBk9NjRFwwhmu28el7urk2vhgHTaSWYcmE49ebuLZzTUdXMKbFsNGtvjdx9jlg0Ohmwss1r7lTnzgKq43um2++GadPnwYATJ8+HW+//TYWLlyIF154ATfffLPdG9gdSORKrD1dZNJAZfZLmjIiPQXq0lheAj6OXK3B1mTDGaf1YW5C+1uYuVybI0eOdHouPswXw3sGQUVgVUb1rAoRFv+dg0X7Ox5MKQpjnm52n2WzlF1k0E4AZo3RbUhLqJ8XvDWJNWzxcOUZyFxujE9mDEJMkBAl9WL836/JOr+DocfsP1KQVi5CoNADSx4axhpejI4nb4rH7UnhkCpUuFTcCE8BTz0+NHoYz+AVA/uuC+va0CRWb2dgjKJkPU+mqVJungI+hvUIVr/PhhBziVyJuVvToCLAgyN74J7B0VZ/xtQh0fDg85BT2YyC2lY2aViIr6fBLQfGtip0lZzKZizddgYKvT3LHYtd/uCbCHMezfZTk079cWP168P9vRDi6wlCdPcmGqLSSDZ3Q2hvj7g9KRxP3hQPQL29ZWjPIACW12ZP0VoUG9srFBEB3miWKHD6Wq2Zd+oiU6iQfl3EfhagPmf9vT1AiOGQOCayp7nMuq0cjryRZffWW9APXOJGmJ/dHUPznitiLx3MNXNQbCCGaa5rzt7XbY0WxlBkEoIBzH5cQEVgl9w6xmBCy29PCkfvCPV9QGGd7pzDtfGln0gN6FiwMJXBnGs6uoIxLdqZyxm629Otvaebiehjqji5U584CquN7q+++grjxo0DAHz22WeYNGkStmzZgl69emHt2rV2b2B3sO5MEebvzcbHOzMNvt4klrETwUgz4dL9ogLw1pR+AICvDuXp3KQboyvh5f369TP4/L3DdL2M5mhsk+G59Zfww4lC/Hiy45FWrr6h7mMkayLj6W6Xq7NOAx0JwKIDhVZlHTWkhcfjsd5uY3ufTcGEsva3IEFdoNATSx8eBkCdfVz7dzD0OJhVDQD47IHBOvtAGR08Hg9LHx6GAE2iqzfv7ocB0R3ZrBkjJauiuVO5J8ZQHtYjGKPiQ+DB56G2Rapz4WWStMUZ8HQDwJhe6s///UJpJ4PTHMsO5KKwtg0hQh7+N2OwVe9lCPb1wm1J6ozY+9IrO7yJRgwbR9Xqfn9bOvZWBeBbTTI4Bu0oCFMMjFFHDYja5To3NGwSNT2jWx0Kbr6mc7NEzp4zsRZ4WIf0UN+A+nqox5W2d92YN94Y2pE7Aj6vIyohzbqyh1kVIsgUKoT6eaGXVgZ3ZkyW6q3Oy5Uq9jccN8C66gph/t7ga25kTXlEbIFZELKkH7jEjTA/uzvG5nBXw146mHutvpH+uFlTjcHZIebWaGEMRW1Pt4eAz4ZMOyqDuVJFWE/37UkR7D1agZ6nm2vjSz+RGtDh6TZVq5trOrqCMS2mPN3ONroN7elm8jo1S+RQqohb9YmjsKoOj1KpRHl5OYYNUxsifn5+WLNmjUMa1p1cKFTv4T2aW4MWibzTnj4ma3nvcD+dAWiM52/the+OXUNVswTJpY0Y2yvU6LGidjmbjMmSWtb6tLcbPhHvHRaLRfuv4mJxA6qbJTr7Zwzx6e4s1LZI0SvMF1P0vJqhfl7svk99fL084O/tgVapArUtUgQIPXW8aPbQEhPkg+J6sU3J1PJqLDOsGCb0i8CqJ0ciXbPYYI7e4X6YOaKHznPaOmKDfbDxhZuQWdHMeibZ14KEiAr0RnWztFO5J+19skJPAQb3CEJaWRNSShs7GTQJRozuZ8Yn4NfzJUgra8IPJwsxWxPWbo4LhfVYf7YIADBroAeCfG3f43rfsFgcz63F3vQK9twxZtg4wtOtUKrYqIvvjl3D5IFRrFeYyS5ubkHGU8DHsJ7BuFjUgOSSRvY8NZS5nKFflD8uFjWwkRaGYLyrQT6e8PUyf2kelxiKRQ8ORXtFbqfFrFHxwQAs83TLlSqklTdp3qc+R+8bFoMNZ4txKLsaErkSQk/Lkh9qh5ZrLwIkhPoip7K5Uwbzkvo2yJUEfl4C+MK6fhbweQjz90ZtixQ1LVI28Z49cEVP940yP7s7xuY9V8NeOpjEsn0j/NE7wh+rjxfgQmEDCCFOK9VnjZZ6A2G4gNqQrGuVscmx7E3GdRFE7XIECD0wvGcQZJqF9YY2GZrEMtZA4tL4IoQYDC+3xNPNJR1dxZgWZqyEa3m6mVrdda1StMuUFicm7ioNbWpvtm72cvW9ICFq28Wd+sRRWGV0CwQCTJkyBTk5OQgODnZQk7oXdSkw9Y2jTKHCPznVeHBkT51jkvUSBZnD20OAKYOisS2lHHvTKkwa3dc0RmFMkBBBPtYbN/X1hleAewT7YFR8MFJKm7A/oxLP32q4FjQA7M+oxO60Cgj4PHzz+Eira1VHBnijVapATYsUvSP8OyVWshRjWlhPt5Vlw9qkCpQ1WF+K7b5hsWwyOlvQ1zEyPsRghASPx8PohBDsz6hCcmmjjtGtn0NgdHwI0sqakFzSiAc0Rr6x8GaGmCAffDpjMOZuTcPX/+Rh0sBIHU+7IdqkCsz9Kw2EAI+PjUOs8qrJ481x96AoeAn4yKtuxYm8WrZdhmD3dNsxUVZJg5i9GVGoCN7emoo9r90Gbw8Bm13cWFZ7bUYnhLBG92Nj1YsnpvId9LfA093h+bfMeOTxeHhyXDz+/PN8p9cY4zm3ugXNEjkCTSQDy6lshkSuQqDQg/WOjIoPQXSgEFXNEpzMq+208GYMZoGNKa3GYKxsWG6V5oY6KgCNDdct+g5tIgPURre9vUcVVvYFF7gR5ucbAWPznqthLx0FrKc7AKMSguHB5+F6UzvKGtqNbnOzN9ZoYcPL9XKeRAR442pVi8M83ac1pcJu6RMGDwEfHgI+YoKEqBRJUFDbhtEJGkOWQ+OrRaqARK6ej7XDy8P9zO/p5pKOrmJMiyFPd5CvJwKEHmiRKHC9SWyTc85aCCEGPd2eAj7bloY2mVv1iaOwOrx8yJAhKCwsdERbOEFBbStbKgYwHF5pi+eW8Qzvz6wyuf+QuQm11BOrz/Dhw42+du8ww7WStalrlWKeJqz+1Tv6WG1wA0C4VgIsQohNSdQA41qY5EaVVmYwZ8LUwv29LYpQsBem+kQfxljS9lCKxHJ2tZ/xYI7Wq7stU6hYo82Qp5Xh4VE9MHlgFORKgre2pJlNlLVofw7KGtrRI9gHH9070Cothgjy8cSEfuoQ839y1OH4xpJVMeFm9kyUxWwv6BnoiXB/b+RVt2LF4XzIFCq2lJklCzJMCTYmt4NKRdi6mYYWPSwJL2ciN6zZggEYHl+RgULEhfqAGChtpo/2ohizl53P51m9JYUQ0rE4pLeoxNwc6yd/YUu0RfrbNLY6ku3ZdwuCrX3R3bj7/Hwj0NVrLFewhw6ZQsWWGuwb6Q9fLw/2nsSZ+7qt0cLsfQ3Xu8dwdAbzk5r93LclRbDPdYSYd0RYcWl8MQvqAUIPHY8t6+k2sf+dSzq6ijEthoxuAE6v1d0sUbB2S7BepCPj+W4Sy9yqTxyF1Ub3ggULMHfuXOzduxeVlZVobm7Webg6zE1jrMbDcTK/FqJ2Ofu6QqlCquYm1hoj8ta+4Qjy8URtixQXi4yXoNK+CbWFvXv3Gn3t3qEx4PGAyyWNBvdDE0Lw4fYMNLTJMCA6AK9PSrKpDZGsh1LCJgDz9uCzJbEsxZgWxjNaaaWn21wNZkdhqk/06TCmm9gkaVfK1GMyMdyPXT1nPIk5lS1okypwvakdKgL4eAo6XaC14fF4WPTQEAT7eiK7shmrjl0zeuzJvFr8fqEUAPDFo8MQIPS0SosxmKgBJgecsfJYzMp3Q5vMpizahmAWtfyldVj04BAAwI8nC/BXcjkUKoIAbw+LvJtM1Ma1mlY0iWWobpFAplDBg88z+H7GkC9vbEeb1HAmfCZzubV1oY31iaW12ZOZpJB6hjKzUPhPTnWnHAOGqBBJUN0shQefh2GazLkMzEKQfq3ufE1kT//oAJvGVqQDoiEIIR1Z5F3I0w24//x8I2CPaywXsIeO4vo2KFUE/t4eiNIswo7vhn3d1mgxFl4e4aDEoADQKlWwi6cTNHlTAHQkU9Pa182l8cWU0o3Uu2cJY7OXGze6uaSjqxjTwiZS62R0a/Z1OymDOZOd3M9L0GmrmXYyNXfqE0dhtdE9ffp0pKWl4f7770fPnj0REhKCkJAQBAcHIyTEOk8mF2FuUB8c1QNJkf6QKwkOZVWxr1+taoFYpkSA0AN9jSQTM4SXBx9TNSGapuplMzeh/WzIXA4Ar776qtHXooOEGKup4bs/o7P3amfqdRzKroangIev/jWCzaptLYyxVNsq7UgA1jPI6s8zpoXZA2xtre4Oo9vx4TjamOoTfQbHqn8n7XJPzGQ6UuPlBtQLD7FBQihVBGnlTWxoc7xeuSpDRAYIMf8BtcH53bFryDCwX13ULsd729IBALPGJ+CWPuFWazHGpIGROmPBmJEZ7OMJT4Fai732wTF7+u+9fRSmDI7GQ6N6QEXA1kxPivK3aJ9gqJ8XEsPVNzRXSpvYsOkeIT7wEHQe56F+Xuy+rHwjGcw7anRbZ+gZ6xNj9cT1Mbb9Y0RcMHoE+0AsU+J4bo3ZdjDfMzg2sNM+MybkvrRBrJNMMreqI8eCLWOrI9me/W5kW6QKtJkoZcdl3H1+vhGwxzWWC9hDBxOd1iey47rMJlMrqLe4DGtXsUaLqfBywDFG94XCeihUBPGhvjrVSxhPd6GWp5tL44tNohagO+cxSefqWqVG+5hLOrqKIS1ShRJNmqzgEXpjKc7JGcwbNKHlIQYiRLVrdbtTnzgKq62qY8eOsY+jR4+yD+ZvV0c7FJrxyGmHVzLhvCPjQ0yWFTIEE655ILPKaPbojpJWthmGX331lUVt2JNeicY2GfsoqG3Fp7uyAACv35WEQbHWeaW1YcOCm6Xs/nhr93MDxrXY7unu2m9rK+b6RBsvDz6GabJSM0aMsfB85jdNKWk0mjnbGDOGx+LeYTFQavY117ZIdcbD53uyUSmSoFeYL96bNsAmLcYIEHpiYv+OEDhjnm4+n8caqvpGlUpFbCoTxYSXZ54+BAD4dMZgRAcKodB8ljVjY5SWJ7nURI10BibCwliIubls7sYw1idM+1JLm4z+VpWidlxvagefh05bSXg8Huvt3pl6XWd8GHow4Z6G8hXEBgsh4PMgU6jYvpQqlOzCUr8of5vGFnutMXAja22GfgZm20qwkVJ2XMbd5+cbAXtcY7mAPXQwRneSVuTf6IQQeAp4qGqWdMoR4Sgs1SJTqNjtiWFGPN2OSKR2ig0tD9d5nvF0a4eXc2l8sUnUAvU93erfTqpQsQug+nBJR1cxpIXx8nvweZ3yOzk7g3mjkegNQLdWtzv1iaOwKpEaANxxxx2OaAcnaGyTsWE4I+NCEB/qhxX/5OHMtTo0tskQ4ufFeoX0QzEt4ZY+YQj180J9mwznCutxu9beG0Bdw5a5eUyyMbx83rx5Jl+fNjQa/9uThbSyJoycf7jT68N6Hbh86wAAQr5JREFUBuHVO/vY9N0MEVqGEnNRteX3MqaFMdIaxXKrsjfmd1N4ubk+0Wd0QggulzQiuaQRM0fEItVITfjRCSHYm16JlNIm9NZ4XU0ZffrMf2AILhTWI6+6FWMX/tPpdR4P+PLR4TqZtK3VYoz7hsWyJdaigoyHw0cGeKNSJNExqiRyJR778TxqmyXYOftWi7NWyxQq9vz+5I2XAKj3mC95eCieW38JgHW5FEYnhGBbSjm7EAeYM7oDcLagni0JqA+bMdvKMlXG+mRAdAB8vQRokSqQX9NiMGleSkmT5thA+Ht3ng7uGxaLHzTl8A5mdb5eGMLQthsPAR89gn1Q2iBGSX0booOEKKpTh44GCD0QHSi0aWx1XGt0o162p5Tjnb/S8f7UAXhpQm+rPpO50Xc1Lzfg3vPzjYK9rrHdjT10aJcLY/DxEmBkXAguFjfgXGE9eoV3TlxpbyzVwiSbEhgwlJgFZEd4uk9pkqhN6GR0q3+30gYxFEoVPAR8To2vjhrduvcAvl4e8PUSQCxTor5VanBu6g4dhBBI5Cq7L8Ya0qKduVzfwccY3WWNzll0MrZlAujY490olnNqbHEV2+KH3ZT0600A1KuDIX5e6BvpjwHRAVCoCA5qQsxtTQoGqG88pw5Rh5jrJzMjhOCjHeoQ17G9QuBn4CJjCQsWLDD5emSAEI+NMVwPN9zfC8sfHW4wPNYamFXLgtpW1rtsi6fbmJZAH/UFGQBbXs0czRI5G75ra5I6WzHXJ/poe7Bzq1vQJlMiwNsDSXpZKrWTqRWbyVxuiFA/L3zx6HAIPTv3N58H/HdSEsboZdq3VosxJg+Mwqj4YDw4sge8PYxPYBEGanWvOJyHtLImVIgk+GB7hsUhhsX1bVBo9geu+3Y5+/yd/SMxe2IfRAV64+6BURZrYH7/1LImFGmSsJn6/ZnoEUPl5wghHbWhrTT2jPWJh4CPERrvNWNc62MuKeSQHoGY0C/C4GuGiAv1we16N34MbAZzTVQGE1reLyoAPB7PprHFXGu0IyHKGsT4eGcmlCqCpQeuIvO6ZeX+AHW2/iUHcgAAN/c2XmWCQnEU9rrGdjf20KFdLkwb5tw8V+Ccfd2WamEMpRBfr06GEhtebmdP9/WmdhTUtoHPA8b30b32xgQK4eMpgFzZkeiTS+PLWHg50OHtrjOyr9tZOkRiOfalV+Ldv9Jw8+IjGPjJAZ0tp/bAkBZjSdQAsGVine7p9u1sdIdqJVLj0tjiKrZZdm5KqoGEQjOGx+JqVS72plfirgGRKGtoB48HDI8Lsuk77hsagz8ulOJAVhXmzxwCT42Bu+VSGU7k1cLLg4/FDw21WcP//d//mT1mycPDsOjBzt/B48EudS+ZCyiTATghzFenzqClGNPC46mTVRXUtqGyqZ3dW2sKpgZzdKBtpdi6giV9og0TFpxX08KW1RoRHwyB3iQ+MCYQQk8+msRyNrTXGk83AEzsH4mcz6fCkN1qaPuEtVqM4eMlwPb/3Gr2ONao0qyIXy5uwI+n1NmZPfg8HLlag63J5fiXkYUkbfK0SoK98qiujnfuGYB37hlg6G1GSYr0R4C3B1qkCraf4g2UC2Ng+jWtvAkyhUpnX3uTWM6WTrE2kZqpPhmdEIKzBfVILmnEk+PiO72uX4pOHx6Ph40v3KSzD9sUpq4hzNhkMpjns9s9/M3qMIb2nm5CCAgB3vkrDW0yJTz4PChUBHO3pmHXnFtNLu4wLP67I1v/W3f3s7o9FEpXsdc1trvpqg6lirB7kfvqRf7d3CcMK49ew/nCeqfU67ZUC5u53L+zccJE5TSJ5ZAqlBZdjyyBKRU2PC64070Nn89DYrgfsiubUVDTisRwP06NL2Ph5QAQ5ueNsoZ2o2XDHK0jpbQRi/bl4EpZ5+1ZO1OvW1xG0xIMaTFldPfQeLob2mRokypsdtJZiqk93cFae7rf5tDY4irU062Foazk9w5V72k8W1CHw5oSR/2jAhBgou6tKcb1DkO4vzeaxHKcvqbeh1PWIMb8vdkAgHem9O9S3b3t27dbdByfz+v0sNfEpR8qZEtoOWBaC1PKh/FemyPfihrM9sbSPmGICPBGfKgvCAE2ni0B0GGwaeMp4LNZols1GbGtNboBtZFkaDwYwlotXSVSq/ycWKbA3K3qmuEPj+qJt6f0BwDM35ON6way8evDhHX3iwywiw4+n4cRmuR2lvz+vcP9EOzrCalChexK3UzSjJc7zM+rU3ZQc5jSwpagK+2cTE0iVyKrQqRznDEMjQ9rryFsBnNNVIZ+YkNb+oS5IZEpVGhuV2DjuWKcL2yAj6cAf74yHmF+Xrha1YKVR/LNftap/Fr8dl6Trf+RYTZf4ymUruDsa6yj6KqO643tkGoWJ+P0rquj4kPg5cFHTYsUhXVtRj7BfliqhdmHaygMN0grMaiprNzWwuznvr2v4QgjNoN5nXoBg0vjy5SnO9xM2TBH61i4LweXSxqhVBEkRfrj37clYt69AwEA5wsbLF6ItgRDWlij24DDKlDoyS6wOMPbbXpPtya8vE3OqbHFVajRrUWGJgxR2+juFe6HIT0CoSLA1//kd3rdWgR8HqYP7QgxV6kI3v0rHW0yJcYkhOCF2xK7oAAYO3Zsl95vD4J9OyYXwLbQcsC0luhApla3ZRec3G7KXA7Y1ifMGGPC542NOe3n+byO+o2OwtnjSzvj69K/r6K4XoyYICE+mTEIL0/ojZHxwWiRKvDeX+lmw8yZrQ5JUf5206HfL6YS2fH5PIN12AHb93MDpvuEyXhfVNfWyWOQcV0EuZIg3N8bcaGO37+sH16ub3Tb0idCTwEChOpV/gtF9Vhy4CoA4MPpAzAqPgQLNWXhVh8vYJM6GqJZIse7f6mz9T87PgG3GLmBpVAcDRfmcHvQVR3XatXXh97hfp2ivISeAox0Yr1uS7UwBqJ+5nJANzGovfZ1K1WEdd4Y2wbE1uquUS9OcGl8sXu6jXi6ARj1dDtSR1mDGMkljeDxgENvTsDht+7AvPsG4dnxveDjKUBDm8xoFRJbMKTFWLkwho5kao7f193Qps6iHmIgvJxNpCaWcWpscRVqdGshkasQKPRgL1IMTBZz5kLZFaMb6PCeH8yqwtrTRThXWA8fTwG+fHR4p8nFWiorO5cCczY8Hk9ndc7W38uUlhirPd3qC2T/bjC6bekT7YUKHg+sR1Uf7SiCmCAfm8u8WYqzxxezAn6puAG/nFN7/Zc+PAxBPp4Q8HlYrtmTfvpaHX7T1BQ3Rp5WTWh76dAe2+H+XgYTvhg6PlnPAKzULK7YkrzLlJZgXy82NPOKZvsMA5sUMiHY4eGZQEfofVmDGBK5kjW+megTW/uEiYZ4b1s6JHIVbu0bhqfGJQAApg6JwcwRsVAR4O2taZDIDWfCna/J1p8Q5ov3p1m3zYBCsSdcmMPtQVd1GEqips34PurSYWedsK/bUi1suTADHkHA/hnMsypEaBLL4e/t0an6BIO+p5sr40ssU7ARYvrRkYD5Pd2O1LE7TV3W95Y+YTqOGi8PPsb0Us/h5wrq7PZ9hrQw9oahrQqAc8uGMQkCQ/06R391GN1yzowtLmP1HfrIkSMxatSoTo/Ro0fj1ltvxaxZs3Ds2DFHtNUpGCoFxhjJDF01usf2CkVUoDdaJAos3K9O2vPB9AF2ycKpVBq+qXQ2ERpPtL+3h83eZVNamFrGlpYNy+vG8HJb+kTbmO4fFYBAI6Gu2sa5LaHl1uLs8cVMxqJ29Urrk+PidVb0e0f4413NXuzF+3PYeuX6SORKFGvCEPtFBdhNx4i4YDD2qn4IpCGMe7qZcmHWe7rNaWHGkr6hb24/t71hogAa2mRILWsCIerQNGaBztY+YRZmGjU3n8seGa5zDf/s/iGIDPBGYW0bvjyY2+n9R3KqsTW5HDwesFwvW7+r4e7z840AV+ZwS2mXKfFPdjVaJHKd57uqw5zRzVR/OZJTzYa/OgpLtTBh40aNbjt7upnQ8vF9wtj8QPp01OpWz39cGV+Ml9vHU2BwsZqJFjC2QOEoHYQQ7LxyHQDwwPAenV5n6sSfL2yw23ca0lLHeroN3xOwGcwbHO/pZs4vg55ujSHeJJZBoeDG2OIyVhvdU6dORWFhIfz8/DBx4kRMnDgR/v7+KCgowNixY1FZWYnJkydj165djmivwzF0AxoX6suuIob5eXXZuOHzeZiuZcjf0icMT2s8M12lV69edvmcrsIYSyPiOicAsxRTWhhPNxOWyyBVKPHVoVy891c6+3hnaxq7d8jZmcsB2/qkf3QA/DQZ2g3VPWYI9fNiE8lZk7ncVpw9vrTDznqG+ODD6QM7HfPcLb0wLjEUYpkS72xNN7jXqrC2DSoCBAo9EBngbTcdAUJPNnoiwYLrwvC4IAj4PFSKJKjQ2hrBJB20xdNtTsuohGAAwO7UCp3z4pwmLNPcfm574e/twd6M/pOtzo+RpMlcDtg+trTHyCf3DUKPYN3fMMjXE0sfHgYAWHumCG/9marzO7y3TR1W/u/bEjtl63c13H1+vhHgyhxuKYv25+DfGy9j4pfHseliKZt0qqs6zBndo+KDMSgmEBK5Cn9cNB3l1FUs1WIqvBywf9kwplSYsYoRANj7g/o2GZrEMs6ML3Y/d6C3wUgrdk+3EU+3o3TkVLYgv6YVXh58TB3aOVkaa3QX1dttX7chLaYSqQHOrdXdIDa1p1v9nEJFENmjc7JWii5WG911dXV4++23cerUKSxfvhzLly/HyZMnMXfuXLS1teHQoUOYN28e5s+f74j2OhxjXp8HR6hDzG/uE2aXUMz7h6s/T+2ZGWY0cZW1nDp1yi6f01UYA6QrZXdMaWE83RV6nu4Vh/Ox8ug1bLlcxj62JpcDUO8NMxf+6whs6RMBn4dxmov7LZowOmMwrw+M6VyH2d44e3yF+3uzffblo8MN9h+fz9PUExfgYnGDwT1+TKRD/2i1kWdPHbdoyrRY8vv7enlgYIzaSNdObsYY4LE27Ok2p+WmRPX4uN7UrnNetEgU8PUSYEgP2yox2ALj7f5Hk5Syn1bkia190itMfVN514BIPDqmp8FjJg6IxGNj4kAIsD3lus7vUNcqQ99IfzYxnyvj7vPzjQBX5nBLUChV2JuuDsWta5Xhg+0ZuHflKZzOr+uSDkJIR7kwI0Y3j8fDi5ocOBvPFUOmUNn8feawVEt9m9pQMmScAPYtGyaWKdhoJcbrbwg/bw82gqqgto0z44vNXG7EqGQWKJjfVB9H6diVqvZy39U/0mCE4bCeQfD1EqBJLMdVTXLWrmJIizmjm4msK3Wwp1uhVLGRhoaylws9BWzZ2aNnLji0Le6A1RbIn3/+ieTk5E7PP/744xg9ejR++uknPPHEE/jqq6/s0kBnwufB6L6YZ8b3QoifF7uPqKuMjA/Bz8+OQUyw0K7Jr5544gm7fVZXmD2xL/pFBeDeYTHmDzaCKS2Mp7tFot4X5O/tgeSSRvx4sgAA8OJtiToTH4+nvinvDmztk0UPDsWl4gbcZ+Y3fG/aAIzpFYJ7h8ba9D3W4Ozx5Sng45cXboJUoWRXmA0RF+qL+4fHYvOlMuzNqOyUCKtje4Ha4LWnjren9MOQHoE60SumGB0fgszrzUguaWTzRXTF021OS2K4H356dgz7G2gzLjHU6mzpXSE+1BdXSpvYuvLaORZs7ZMXb09EXKgvpg2JNrkg+tkDgzEwJgBtMt0QOAGfh3uHxjj1d3AU7jw/3yhwZQ63hItFDWgUyxHq54X/3NkHK4/k42pVC55eewG39xmJJ9pkRg1QU9S2SNEiUYDPg8mSoDOGx2LJgauobpZif0YlZo7sHA5sDyztE1MlwwDdxKBd5UJhA+RKgp4hPuhlJsqtd4QfKkUSFNa2cmZ8dSRRM7zQHGbG0+0IHSoVYfdzzxxp+H7KU8DHmF6hOJlXi/OF9RgU23Vnh76WNqmCnaeMGd39o9Vz59WqZtS0SAxmgLcHonY5CFHfQwcbKbcb6uuFCpEEEyZPc0gb3AmrPd1CoRBnz57t9PzZs2chFKo7XaVSsf93JZKiAox6QgV8Hh4Y0cOuA3vyoCgMjrWvl+n777+36+fZSoifF/41Nq5L9QNNafH39mCzFleJ2tEuU2Lu1jSoCPDgyB74+L5BmD2xL/v4z519MSDa8Z5gQ9jaJ9FBQswYHms2siJQ6IkHR/Z0eBI1oHvG1+iEENabbArGgD2QWQWFUtfrwWQu76fxmthTh5+3Bx4a1dNio43Zh8/s61apCKpYo9v664slWu4eFKVzPjAPZ4dT64fga2/3sLVPAoWeeGR0T7PXGqGnAM/dmtjpN3jljj4W7cd3Bdx5fr5R4MocbgkHsqoAAFMGReHft/fGiXcm4rlbekHA5+FUQSOW/n3Vps9lQsvjQ31N1rP28uDj2ZvVW/PWni4yW8HCViztE1MlwwD7JlI7qRVabu4egc1gXtvGmfHVUS7MsFHJZC9vEMs61ckGHHOeXCxuQKVIggChB+7sb9xJM17jADhnp8z5+lqY8eHjKWC3GerTM8QXo+KDoSLAnjTHJTBjFpKCfDzhYSRvQLAmxPy3rTsc1g53wWqL6LXXXsMrr7yC5ORkNj38pUuX8PPPP+PDDz8EABw8eBAjRoywa0OdwYg454VZOop58+Z1dxPshjktsUE+yJW0oKJJgt8vlKKorg1Rgd7434zBTmqhZdxIfdKd3Nw7FGF+Xqhvk+FsQb1OwjW2PJVmdbg7dTB7qLMqmiGRK9EiUUCmVIHHUy+0WAuX+0Sf+DBdr5V2kkVX0sFV3Hl+vlFwlfNApSI4kKk2uu8Zot77GuLnhf/dPxiTBkbimbUXsSe9Ah/PGGT1tq5rtaZDy7V56uYErDp2DRnXRbhU3IibEu2/kGhJn0jkSjYbt7E93fb0dJ9m6nObCC1n6K2JFiisbcWPHBlfHeHlhue8EF9P8HgAIers2eF6v6kjzpNdqWov97Qh0SYX0ZmI1wuF9VCqSJerDulrYYzu8AAvkwsqD4zogZTSJuxOvc5utbA3jNEdaiCJGgOTTG3qAw87pA3uhNWusXnz5uGnn37CxYsX8frrr+P111/HxYsX8dNPP+Gjjz4CALzyyivYs2eP3RvraEYYCS13JRYsWNDdTbAb5rQwNY13XrmO9WeKAWjKSfkaDoHpLm6kPulOPAR8TNXc/O1L71j5bZcpUaapZckYed2po2eIDyIDvKFQEaSXi9gM/BH+3kYz0JqCy32ij3ayv3B/Lx2PkCvp4CruPD/fKLjKeXClrAk1LVIEeHt0yjtyW99wBPEkEMuU2KMJ17WGjiRq5hOfhvp54aFR6rDytacLrf4uS7CkTxjjxFPAQ6DQ8CKDvbKXV4rakV/TCh7PfM4XAOijWbworGvjzPhiw8uNeLo9BHw2SZehEHN765ApVNifob5veGCE6W0KQ2ID4e/tgWaJAjmVzV3+bn0t7H5uI4s3DPcOi4GAz0NauQhFdYYrt3QVplyYof3cDIyne8uOfQ5pgzthUzzqU089hXPnzqGhoQENDQ04d+4cnnzySfZ1Hx8flwxfGxHnnCy+juT111/v7ibYDXNamFDc7ZryDo+PjTMZEtRd3Eh90t2wIeZZVWxinWs1rSBEfXPGrJZ3pw4ej9dRr7ukERWaDPwxwdbv5wa43yfaaFd+0C8l6Eo6uIy7zs83CvY8D0TtcofdjB/UhJZPGhjZKQScx+PhxYnqShObbcgsbi5zuT4v3Kr28h3KrjZaNrIrWNInrEfQz7h3MlxjYLbJlGjTeMVtgfFyD+sZzBo8puitCS8vqW/Df+a8ZvP32hPW0x1o3LBkql3UGwjHt/d8cSKvFqJ2OSIDvE3mjwHUCwJjNfW6DSVutRZ9LeaSqDGE+3vjNk3+GiYBnL1paNMkUTMxzhgv+PCx4x3SBnfC5k2gMpkM5eXlKC0t1Xm4MkwKfldmw4YN3d0Eu2FOi3bSqR7BPvjo3s7lpLjAjdQn3c1NiaGICPCGqF2OM9fUNya5TGi5Vqbs7tahbXRXaTzdsTaElgPdr8UaIgO82Uyn+ka3K+ngOu44P98o2Os8SC1rwqTlJzDxy+OY80eKXev5EkLwd6baK8hEF+kjzjoGT4HaC5ddYZ030FqjOykqAHf0iwAhYKPe7IklfcKEBIf6GTeU/LwE8NGELXdlXzdTn3uCiVJh2sQECiH05EOuJPh23R82f6896djTbXzeY5Kp1Rmow27v+WKnxmidMTzWonBxxjA/V9B1o1tfi6VGN9CR8G1XaoVDcho0suXCjEeQhmiiS89fybT797sbVhvd+fn5uP322+Hj44OEhAQkJiYiMTERvXr1QmKiY/YUOAt7lALrbiZPntzdTbAb5rRoJ5364tFhCDBQ3oEL3Eh90t0I+DxM19wE7tWEmOezRneHkdfdOphkaldKG9nM5bbs5wa6X4s18Hg81tudFKV7Q+1KOriKO8/PNwr2OA/2pVfisR/OsYbd3vRKTPrqBJYeuIoWibzLn59d2YyyhnYIPfk6uTO0uf+eibh7UBQAYMslyxd8RO1y1iDrE2E8c7k+zJ7WrZfL0GwHjdpY0ifmMpcD6usfY0hVN9tmdKtUBKc1C8q39bXM6Obzeegdrr7exg8Za9P32pOGNhmaxOo+ijLl6WbKhhlYoLDnfNEqVeCfbHUZy5lmQssZmH3dF4saDCZ6swZ9LUxJuQh/8/cEdw+KhtCTj6K6NmRcF3WpHYZgxrUl4eWBEY6voOPqWG10P/fcc+Dz+di7dy+Sk5ORkpKClJQUXLlyBSkpKY5oI8UKrl61LVsoFzGn5Y7+ERgQHYB37ulvUXbr7uJG6hMucN9w9YX/UHYVpAplp3JhQPfrGBwbCC8BH/VtMjYDaqwN5cKA7tdiLY+NjUe/KH9MGhCl87yr6eAidH52fbpyHhBC8N2xa5j9RwqkChXuGhCJv14Zj1v6hEGmUGH18QJM/PI4tlwq7ZJX7KAmgdod/SLg62V4//LVq1fx+Nh4AMCOK9chkSs7HSNXqnAgsxJ/XChlHz+fUu/Ljg4UWrWQfntSOPpF+aNNpsSWi2XWSjKJJX1iLnM5Q5LGe//t0XyobDDWsiub0dAmg5+XACPjLd8S2VuzgJGS75gwZEspqmvDI6vVFRZ6BPsgyEgZKgAI9zO+p9ue88XBzCpIFSr0DvfDkB6WVbkZHBuEAG8PtEgVyKromrGrr8UaT7e/twfuHqR2NOy8Yn3+BHM0WpFIrarRPnXL3Rmrs5enpqYiOTkZAwYMcER7KF3Ez8/ylWGuY05LZIAQB96Y4KTW2M6N1CdcYHR8CKIDhahqluBkXh1bLky7JnR36/D2EGBozyAklzQivVw9YTOJAa2lu7VYy4u3JRrMtOpqOrgInZ9dH1vPA6lCiQ+3Z2JbSjkA4Plbe2HevYMg4PPw+7/H4Z+cGizan4Oiuja8ty0DtS1SzLkryabv+ltjdE8bEmP0GD8/P9zWNxw9gn1wvakdf2dW4sGRPdnXVSqCNzanYl+G4XJH+pEw5uDxeHjh1kS8vz0DXx3OQ69wP9bT3lUs6ZO6NrWhFGYivBwAPpg+AKev1eFUfh3Wny22Ous0E1o+vk+YVWVCkyIDAFTicIUHVh8vwPO39rK4zKW9OF9Yj1d+S0aTWI4ewT5Y+9wYkxGmrKe7rbOn217zRX2rFN8ezQcA3D/CfIlWBgGfh5sSQ3Hkag3OFdRjWM9gm9ugr6W21XzUhDYPDI/FnrQK7EmvwEf3DuxyNnVtGixIpMbs95aoHF+21tWx+hcaNGgQ6urqHNEWih0IDXVu3V1H4i5a3EUH4Bpa+Hwepg9V3wxuuVSG603qPdPae7q5oIPZ180QY6Onmwta7IG76OhObuT5uV3W2ZPqithyHiSXNOLRNeewLaUcAj4P82cOwaczBrM33zweD3cPisLBNybgzcn9AABfHsrDX8nlBj9PrlThf7uzcPuyozisCbtluFbTivyaVngKeJg4wHji0tDQUPD5PDw2Ng4AsFnP+7xofw72ZVTCU8DD5IFRuHtQx2P60Gi8eXc/q3+Hh0b1xO1J4WiXK/Hyr5fx08lCu+xztaRPGjSGUpgZQ6lvZADmafLPLD1wFVerrNvvfvqauj63paHlDM+OT8CwnkGQKNXfO/mrE9ib7ph9wIbYerkMz6y9gCaxHCPigrFz9q0YEG3aq8zu6Tbg6bbHfNEuU+LfGy+juF6MHsE+eEZT891SmBDzriZT09dSZ4WnGwAm9ItAsK8nalukdtljrg3j6Q6zwOgWK6nRbQ6rf6GlS5fi3XffxfHjx1FfX4/m5madR3fx3XffoVevXhAKhRg3bhwuXrzYbW3pTtLT07u7CXbDXbS4iw7AdbTcN1xtdP+To75hjAjw1snyygUdo/RCA2Nt9HRzQYs9cBcd3QlX52dL6Ooc3mDAG+aKWHMelDeK8dqmK3h49Vmkl4sQ4O2B9c+NNWo8eHnw8d/JSXjljj4AgPe3peNUfq3OMaJ2OZ5ffwkbzhajrKG9k/HKZC2/pU+4ydBgRsejY3qCzwMuFDWgUFN/e+3pIvx8uggA8OWjw/HzrDH46dmOx/dPje50fbQELw8+1j03Fk+OiwchwML9OfhwRybkSpXVnwUAShXBjivl+OVUvtnPqLfAOGF4+uYE3DUgEjKFCv/dlGow9D6trAk/nCjA2Wt1kCrUr7fLlLhU1AgAuN3IXnpjhPh5Yed/bsUDUU2IDhSivLEdc/64gkfXnENqWZNVn2UIlYogvbwJ3x+/hsX7c3Qeb2y+gnf+SodcSXDvsBhsfvlmiwxKJmrA0J7urs4XShXB65uv4EppE4J8PPHLC2ON1lc3BpNM7VJxIxRWjjGZQoWzBXX44UQB9l/IYZ8nhFgVXg6oxz3jaLBnFvOyBjGbc8YST7dI4vyFz+K6Nnx1OK/TmPvi4NUuh/07AqvDy5kN/5MmTdJ5nhACHo8HpdL5P/qWLVvw1ltvYc2aNRg3bhy+/vpr3HPPPcjNzUVkJPdKSDmSadOmdXcT7Ia7aHEXHYDraBkZF8yGNQK6oeUAN3SMSghm/y/g80xmcTUFF7TYA3fR0Z1wcX62BHvM4Q0GMhw7mlapAj6eArPhnGKZAp4CPjwF5v0clpwHrVIFVh+/hp9PFUGqUIHHAx4d3RNzp/RHZKD568i79/RHpagdu1Ir8OpvKdjyfzdjcGwQSurb8MKGSyiobYOPpwAT+oXjYFY1Fu7PQWFdKz5/YAgOsKHlhrOW6+uICfLBnf0jcfRqDbZcLsPwnsFYsC8bAPD+tAFmayJbi6eAj4Uzh6B3uB8W7s/BpoulKGsQ47unRplcJNDndH4dFuzLxtWqFgBByF5xEh9OH4hJAyMNhiCzRrcFhhuPx8PSh4dh6tcnkVvdgmUHcvHJjEEAgOtN7Vh24Cp2pXbsz/X1EuCWPuHoESyETKlCbJAQvcOtD6/m83l477GJCA6PxI8nC/HDiUJcLmnEzO/OYOaIWLw7dQBirShd2dAmw6n8WhzPrcXJvFr2NzDGa3f1xZuT+4FvYfgzE15t6HO7Ml8QQvC/3Vk4nF0NLw8+fp41xqKa8PoMjAlEoFBdrzuzohkj4oJNHl/eKMbx3FqcyKvF2Wt1aGOjc8JQ+0cK3p82AAHenpBpDPhwKxYBZo7ogT8ulOJAZhXmzxxi09YBiVyJ84X1OJFXixO5tSjUKjcYZeK6EqzZ060gPEjkSqdsWxC1y7HqaD42nC2GXGk4WuP74wVWXRedgdVG97FjxxzRji7x1Vdf4aWXXsLzzz8PAFizZg327duHdevW4f333+/m1jmXdevWYd68ed3dDLvgLlrcRQfgOlp4PB7uHRaDH0+qk/Lo7w/kgo7IACHiQn1Q1tCOqABvm/dhcUGLPXAXHd0JF+dnS7DHHN4otm/GakPIlSqklDSqb0rzapFV0YxgX0/cnhSBO/tFYEK/CEQEeEOlIsi4LtLcYNcgtawJvl4euKVPGO7sH4k7+keghxHjxtB5QAhBUV0b+73nC+shkatvzG/uHYp59w7CkB5BFuvg83lY9sgw1DRLca6wHs+vv4SP7xuET3dnoaFNhuhAIX6eNQaDYwOx7kwxFuzLxqaLZcitakHGdRH4PGCymf3S2joeHxuHo1drsOlCKdafKQYh6nDn/5vQ2+I2WwOPx8O/b++NXmF+eH3zFZy+Vofxi4/glj7huKO/uq/iNFUU9CmobcWifTk4crUGABDk4wmpRIzCujb8e+Nl3No3DPPuHYSBMYEobxTjRJ7a6MzWeNXMJVJjiAjwxrJHhuHFXy5j3Zki3JQYgqyKZvx4spBdSLm1TziuVrWgrlXKRm0BwO1JETZX22H65Y3J/fD42HgsO3gV21OuY2dqBQ5kVeHl23vj/+7oAz/vzuaBUkWQWtakMcpqkH5dBO3odD8vAW7pG45eYZ1/21v6hmNif+ucYB3Zyzsb3V2ZL9acKMSv50vA4wHfPDYCY3vZFqou4PMwrncYDmdX4z+/JeOugZG4o18kbukTBj9vD0jkSlwsamCvAwW1ujXkw/29MCA6EKev1WJveiUOZVdjxjB1IthAoYdVxuuYhBDEBglRIZLg2NUaTBtqPN8CAyEEhXVtOJHbcV2RKjo89gI+D6MTQjBzRA+j1ysACPD2gAefB4WKoFEss3mrnCUolCr8cbEUKw7nsdf8W/uGYVCM7laFknoxDmVX48/L5dibXon/3NkH/769t9PzGOjDI87a0OEgZDIZfH198ddff2HmzJns87NmzUJTUxN27drV6T1SqRRSaUe4SnNzM+Li4iASiRAYaFnmQgqFwm3Sy5tw/6ozAIDFDw3FEzfFd3OLOvPG5ivYmVqB0Qkh2PbqLd3dHIodaG5uRlBQEJ1PLMTaOdzY/D112QHER4c5rJ0SudrgbpEqTB43IDoANS1Ss573pEh/JIb7wZztRAhwtaoFpXp1tntH+OG9qQMwZVCUzQaYqF2Of605h9zqjqzDQ3sE4edZY3Q8W0dyqvHapisQazxz4xJDseX/xlv8PXKlCrcsOcqGzU4ZFIXVT4+2a8InY2RViPCf31NQUt/59+sb4a/z+8sUKpzKr4NCReDB5+HpmxPwxuQkCPg8fHesAOtOF0GmVIHPA+JCfTt/Zrgf9rx2m0GD1Rjzdmbgt/O6JdXGJYbi4/vUCykqFUF2ZTO74FLWIMaap0djuBmvqjWklzdhwd4cXCxuAABEBnhjZLzu58sUKqSUNkHUrru4NSA6QL2Q1C8CoxNCrEruZo5miRzD/ncIADTjvOufKVcSHNUsqHxy3yC8YGUiO33+ya5mqwUweAp4GBgTiLzqFnZxDFAbsaPig9nfa1BMIPh8HrIqRFiwN4etZAKoy+UdeftOq9qy5O+rWHOiAAlhvhgQbdpzTwiQU6Uu/adNTJAQd/aPwB39InBL33AEWlhBYMyCf1DXKsVtfcPh5+04wza/upX1wPeN9MdH9w40upiTXNKI+Xuz2e0TsUFCDO3ZeXGyf3Qg3tLKIeHIOdyisyM9PR0qlYr9v6mHs6mrq4NSqURUlO6qa1RUFKqqqgy+Z/HixQgKCmIfcXHqRB+FhYVYtmwZpFIpFixYAABYsGABKioqsHbtWly6dAkHDx7E9u3bkZ2djZUrV6K5uVnn2IaGBnz33XdIT0/H7t27sW/fPqSkpOCHH35AbW2tzrFisRjLly9Hbm4u/vzzTxw5cgRnz57Fhg0bUFZWpnOsUqnE4sWLUVJSgl9//RWnT5/G8ePHsXnzZuTn5+OLL76ARCJhwwsXLFiAqqoq/PTTT7h06RIOHDiAHTt2IDMzE99++y1EIpHO5zc1NWHVqlXIyMjAzp07sX//fiQnJ+PHH39EdXW1zrHt7e1Yvnw58vPzsWXLFhw9ehRnzpzBxo0bUVpaioULF0KlUmHBggVQqVRYuHAhSktLsXHjRpw5cwZHjx7Fli1bkJ+fj+XLl6O9vV3n86urq/Hjjz/i1Vdfxf79+7Fz505kZGRg1apVaGpq0jlWJBLh22+/RWZmJnbs2IEDBw7g0qVL+Omnn1BVVaVzrEQiwRdffIH8/Hxs3rwZx48fx+nTp/Hrr7+ipKQEixcvhlKp1HlPWVkZNmzYgLNnz+LIkSP4888/kZubi+XLl0MsFuscW1tbix9++AEpKSnYt28fdu/ejfT0dMyYMQMNDQ06xzY3N2PlypXIzs7G9u3bcfDgQVy6dAlr165FRUWFzrFSqRTLli1DQUEBNm3ahOPHj+PUqVP47bffUFxcjCVLlkChUOi8p7y8HOvXr8f58+dx+PBhbN26FVevXsWKFSvQ2tqqc2xdXR3WrFmD1NRU7N27F3v27EFqaipWr16N+vp6nWM//vhjfP3118jOzsa2bdtw6NAhXLhwAevWrevUbrlcjqVLl6KwsBC///47Tp48iZMnT+L3339HYWEhli5dCrlc3ulcW7duHS5cuIBDhw5h27ZtyM7Oxtdff42WlhadY+vr67F69WqkpqZiz5492Lt3L1JTU7FmzRrU1dVh1/pV6BvpD4Cgf7gXVqxYgatXr2Lr1q147rnncP78eaxfvx7l5eU6n6tQKLBkyRIUFxfjt99+w6lTp3D8+HFs2rQJBQUFdr1G+LaoExmF8CU2XyOYh6XXCO3P59I1Yu7cuVZfI5KTkzl3jdi+fbvBecdRcHl+tgRr53Bj83dWRTMOZlU77HEirxYtUgVCfD3Rx6MBS2YOxPOh1/DV9B64K1qGhAC1RXC1qgUNbTJ4Qompg6Nxm3cpTr1zBx7yy8eLN0Ui3lcOHoD8mlYcyjb/vYeyq1HaIIaARzA8WogJgfXY9u+RmCg+jXsGR2PhwoU2n5sHdm/HS/3lCBGq2357YiBGi04hwt9L59xM8pPiuZ71CNUcF6uosGr+vpqdhT5Q92UkvxUrnxiJxYsWOuXcvHRoBxbe4oVPxnlhaqwMQ6KE4IGgsLat0+9/LLcWChXB0FDgveEKPNRLid/X/4TFn38KRfJfOPL2HUj0aISKqD1pfB7QO0CFBxL5WDYpBE8GF0BUX2PV/O2ds5+tR54Q5ovJwkJ8Ob0nLh3ajvPnz+PIkX+Qc/YQJsUoMF58HodfG4c9v6xiP9+a+bulpQXTp0/vNH9fPrQdK2bEY5KwEPGhvqhpkXYah8dyayFql0PIV+HO3gGY6FuO0+9MwG2tJ/H+tAE4smk16mqq7DZ/L1iwAAHeHhDy1Ea+JeeKJQ/G4B7qWY0Xbkvs8j2+tOgy1t8fgUei6vDoiEgE8KSQKwnSy0WQyFXw48sxNSkQzyRK8PUEL7w5DPArOY0gVTMWLVoIAPjvsw/j1xfG4B7fYvQM0tS85kmtnr8DG66CB/XYtOS6UtbQDgEIbooPwE1e13H4zQmYrjiHT6YlIevgH6guK7Z4/o7xVxvap6/VOfQ6XFjXhgAvHu4Jb8KGx/vhzNYfjV4jWorS8PYwFR7t2YpIf09UiCQGP3PPuSyde/z8/HxLpi6bsMjTzefzUVVVhcjISPD5fPB4PIMZD7tjz1hFRQV69OiBs2fPYvz4jpXXd999FydOnMCFCxc6vcedPd1SqRTe3tYlg+Aq7qLFXXQArqflelM7KpraO4WPcUWHQqnCkas1GJcYqpPozRq4oqWruIsOZ3u6uTw/W4K1c7ix+fvHfzLg42f9vkxL4fN4GBwbiCE9gox6aGtbpLhU3IAwPy+MSggxuodbJJbjbEGdwb2qCoUCHh66ntKYICFu7h1mlQfVGmpaJMi63ow7+kWY3G/b0CbDxaIGTB4YCQ8z+9P1z2eZQoUjOdWY0C/CYTospVkix9lr9agzkKBrQHQAxpiZLzKvi1AlkmBsYqhV+8SNUd8qRXJJI+7oHwFvD8eGv5q7zkoVShzKqu7k0ebx1LlRRsQFm+17e5JX3YKLRQ2dnjd0nlhKj2Afs2PdVgghKK4XI728Cf2jA9A/KsBsJIp2n8gUKhzLrcHIuGCb9iGfLahDoV4YuzHseV253tSOI1kV4Asce24LPQW4e1CU1eedRK7EwawqtEg6RypFBwp1tss4dA4nFlBcXExUKhX7f1MPZyOVSolAICA7duzQef7ZZ58l999/v0WfIRKJCAAiEokc0ELnsnTp0u5ugt1wFy3uooMQ99HiLjoIcR8t7qLD2fMJl+dnS+jqHO5O8zch7nMeuIsOQqgWLuIuOghxHy3uosORc4pFSxIJCeryE3K5HJ999hk+/vhjJCZ2bR+EvfDy8sLo0aNx5MgRdj+YSqXCkSNHMGfOHIs+g2i8AlwvqWIJU6ZMcQsdgPtocRcdgPtocRcdgPtocRcdjAbipHQpXJ6fLaGrc7g7zd+A+5wH7qIDoFq4iLvoANxHi7vocOgcbq2VHhgYSAoLC+1t/HeJzZs3E29vb7JhwwaSnZ1NXn75ZRIcHEyqqqosen9BQQEBQB/0QR/0QR/0YZdHQUGBg2e+znBxfraErszhdP6mD/qgD/qgD3s/HDGHWx18P3PmTOzcuRNvvvmmtW91GI899hhqa2vxySefoKqqCiNGjMCBAwc6JWYxRmioev9OaWkpgoKCHNlUh8LsbSsrK3P5venuosVddADuo8VddADuo8VddACASCRCfHw8O684Ey7Oz5bQlTncXeZvwH3OA3fRAVAtXMRddADuo8VddACOncOtNrqTkpLw+eef48yZMxg9ejT8/Px0Xn/99dft1jhrmDNnjsXh5Prw+eqkEEFBQS4/WAAgMDDQLXQA7qPFXXQA7qPFXXQA7qPFXXQAHfOKM+Hq/GwJts7h7jZ/A+5zHriLDoBq4SLuogNwHy3uogNwzBxutdG9du1aBAcHIzk5GcnJyTqv8Xg8Tk/qFAqFQqG4K3R+plAoFAqFm1htdBcVFTmiHRQKhUKhULoAnZ8pFAqFQuEmzo9/4yDe3t749NNPXb5GrLvoANxHi7voANxHi7voANxHi7voANxLiyvgTr+3u2hxFx0A1cJF3EUH4D5a3EUH4FgtPELM50R/6623MH/+fPj5+eGtt94yeexXX31lt8ZRKBQKhUIxDp2fKRQKhULhPhaFl1+5cgVyuZz9vzF4PJ59WkWhUCgUCsUsdH6mUCgUCoX7WOTpBoDCwkIkJibSiZtCoVAoFA5B52cKhUKhULiNxXu6k5KSUFtby/792GOPobq62iGNolAoFAqFYhl0fqZQKBQKhdtYbHTrO8T379+PtrY2uzfIXpw8eRIzZsxAbGwseDwedu7cqfM6IQSffPIJYmJi4OPjg8mTJyM/P1/nmIaGBjz11FMIDAxEcHAwXnzxRbS2tjpRhXkdzz33HHg8ns5j6tSpOsdwQcfixYsxduxYBAQEIDIyEjNnzkRubq7OMRKJBLNnz0ZYWBj8/f3x8MMPd7pxLC0txb333gtfX19ERkbinXfegUKhcKYUi7TceeednfrllVde0TmGC1pWr16NYcOGsbUVx48fj7///pt93VX6xJwOV+kPfZYsWQIej4c33niDfc5V+kQfQ1pcpV/+97//dWrngAED2Ne7u09cbX62BDqHd8AFHXQO5+a1ic7h3NKhD53DuaGFM3M4sRAej0eqq6vZv/39/UlBQYGlb3c6+/fvJx999BHZvn07AUB27Nih8/qSJUtIUFAQ2blzJ0lLSyP3338/SUxMJO3t7ewxU6dOJcOHDyfnz58np06dIn379iVPPPEEp3TMmjWLTJ06lVRWVrKPhoYGnWO4oOOee+4h69evJ5mZmSQ1NZVMnz6dxMfHk9bWVvaYV155hcTFxZEjR46Qy5cvk5tvvpnccsst7OsKhYIMGTKETJ48mVy5coXs37+fhIeHkw8++IBzWu644w7y0ksv6fSLSCTinJbdu3eTffv2kby8PJKbm0s+/PBD4unpSTIzMwkhrtMn5nS4Sn9oc/HiRdKrVy8ybNgw8t///pd93lX6RBtjWlylXz799FMyePBgnXbW1tayr3d3n7ja/GwJdA7vgAs66BzOzWsTncO5pUMbOodzRwtX5nCLjW4+n09qamrYv/39/UlhYaFVX9Zd6E90KpWKREdHky+++IJ9rqmpiXh7e5NNmzYRQgjJzs4mAMilS5fYY/7++2/C4/HI9evXndZ2bYxN2A888IDR93BRByGE1NTUEADkxIkThBD17+/p6Um2bt3KHpOTk0MAkHPnzhFC1DcvfD6fVFVVscesXr2aBAYGEqlU6lwBWuhrIUR9IdK+MOnDVS2EEBISEkJ+/vlnl+4TQjp0EOJ6/dHS0kKSkpLI4cOHddruin1iTAshrtMvn376KRk+fLjB17jQJ648P1sCncO5pYMQOodzVQshdA5n4OK854p9Qudw++mwKrz8ueeew0MPPYSHHnoIEokEr7zyCvs383AFioqKUFVVhcmTJ7PPBQUFYdy4cTh37hwA4Ny5cwgODsaYMWPYYyZPngw+n48LFy44vc2mOH78OCIjI9G/f3+8+uqrqK+vZ1/jqg6RSAQACA0NBQAkJydDLpfr9MmAAQMQHx+v0ydDhw5FVFQUe8w999yD5uZmZGVlObH1uuhrYfj9998RHh6OIUOG4IMPPoBYLGZf46IWpVKJzZs3o62tDePHj3fZPtHXweBK/TF79mzce++9Or894JrniTEtDK7SL/n5+YiNjUXv3r3x1FNPobS0FAA3+sSd5mdLoHN49+ugczj3tNA5nDs66ByuhktauDCHW1QyDABmzZql8/fTTz9t8ZdwjaqqKgDQ+fGYv5nXqqqqEBkZqfO6h4cHQkND2WO4wNSpU/HQQw8hMTERBQUF+PDDDzFt2jScO3cOAoGAkzpUKhXeeOMN3HrrrRgyZAgA9e/t5eWF4OBgnWP1+8RQnzGvdQeGtADAk08+iYSEBMTGxiI9PR3vvfcecnNzsX37dra9XNGSkZGB8ePHQyKRwN/fHzt27MCgQYOQmprqUn1iTAfgWv2xefNmpKSk4NKlS51ec7XzxJQWwHX6Zdy4cdiwYQP69++PyspKfPbZZ7j99tuRmZnJiT5xp/nZEugcTudwe0HncO7rAFyrP+gczr1+4cocbrHRvX79eos/lOI8Hn/8cfb/Q4cOxbBhw9CnTx8cP34ckyZN6saWGWf27NnIzMzE6dOnu7spXcaYlpdffpn9/9ChQxETE4NJkyahoKAAffr0cXYzTdK/f3+kpqZCJBLhr7/+wqxZs3DixInubpbVGNMxaNAgl+mPsrIy/Pe//8Xhw4chFAq7uzldwhItrtIv06ZNY/8/bNgwjBs3DgkJCfjzzz/h4+PTjS1TQ+dn14XO4d0LncO5A53DuQWdw+2PxeHl7kR0dDQAdMpMV11dzb4WHR2NmpoandcVCgUaGhrYY7hI7969ER4ejmvXrgHgno45c+Zg7969OHbsGHr27Mk+Hx0dDZlMhqamJp3j9fvEUJ8xrzkbY1oMMW7cOADQ6ReuaPHy8kLfvn0xevRoLF68GMOHD8c333zjcn1iTIchuNofycnJqKmpwahRo+Dh4QEPDw+cOHECK1euhIeHB6KiolymT8xpUSqVnd7D1X7RJzg4GP369cO1a9dc7jxxB+gcTudwe0DncNfQYQiu9gedw7nZL/p01xx+QxrdiYmJiI6OxpEjR9jnmpubceHCBXb/yPjx49HU1ITk5GT2mKNHj0KlUrGDiouUl5ejvr4eMTExALijgxCCOXPmYMeOHTh69CgSExN1Xh89ejQ8PT11+iQ3NxelpaU6fZKRkaFzA3L48GEEBgayIUjOwJwWQ6SmpgKATr9wQYshVCoVpFKpS/WJIRgdhuBqf0yaNAkZGRlITU1lH2PGjMFTTz3F/t9V+sScFoFA0Ok9XO0XfVpbW1FQUICYmBiXP09cETqH0zm8K9A5nHt9Ygg6h3NbC53DbdBhbQY4V6GlpYVcuXKFXLlyhQAgX331Fbly5QopKSkhhKjLjQQHB5Ndu3aR9PR08sADDxgsNzJy5Ehy4cIFcvr0aZKUlOT0Mh2mdLS0tJC5c+eSc+fOkaKiIvLPP/+QUaNGkaSkJCKRSDil49VXXyVBQUHk+PHjOin7xWIxe8wrr7xC4uPjydGjR8nly5fJ+PHjyfjx49nXmZT9U6ZMIampqeTAgQMkIiLC6aUHzGm5du0a+fzzz8nly5dJUVER2bVrF+nduzeZMGEC57S8//775MSJE6SoqIikp6eT999/n/B4PHLo0CFCiOv0iSkdrtQfhtDPDuoqfWIIbS2u1C9vv/02OX78OCkqKiJnzpwhkydPJuHh4WzGcFfuE65C53A6h3eXFle6NtE5nFs6DEHn8O7XwpU53G2N7mPHjhEAnR6zZs0ihKhLjnz88cckKiqKeHt7k0mTJpHc3Fydz6ivrydPPPEE8ff3J4GBgeT5558nLS0tnNEhFovJlClTSEREBPH09CQJCQnkpZde0klpzxUdhjQAIOvXr2ePaW9vJ//5z39ISEgI8fX1JQ8++CCprKzU+Zzi4mIybdo04uPjQ8LDw8nbb79N5HI5p7SUlpaSCRMmkNDQUOLt7U369u1L3nnnHZ3ahVzR8sILL5CEhATi5eVFIiIiyKRJk9jJmhDX6RNTOlypPwyhP2G7Sp8YQluLK/XLY489RmJiYoiXlxfp0aMHeeyxx8i1a9fY1125T7gKncO5pYPO4dy8NtE5nFs6DEHn8O7XwpU5nEcIIZb7xSkUCoVCoVAoFAqFQqFYyg25p5tCoVAoFAqFQqFQKBRnQI1uCoVCoVAoFAqFQqFQHAQ1uikUCoVCoVAoFAqFQnEQ1OimUCgUCoVCoVAoFArFQVCjm0KhUCgUCoVCoVAoFAdBjW4KhUKhUCgUCoVCoVAcBDW6KRQKhUKhUCgUCoVCcRDU6KZQKBQKhUKhUCgUCsVBUKObQnFznnvuOcycObPbvv+ZZ57BokWLLDr28ccfx/Llyx3cIgqFQqFQuA+dvykU94FHCCHd3QgKhWIbPB7P5Ouffvop3nzzTRBCEBwc7JxGaZGWloa77roLJSUl8Pf3N3t8ZmYmJkyYgKKiIgQFBTmhhRQKhUKhOB86f1MoNxbU6KZQXJiqqir2/1u2bMEnn3yC3Nxc9jl/f3+LJktH8e9//xseHh5Ys2aNxe8ZO3YsnnvuOcyePduBLaNQKBQKpfug8zeFcmNBw8spFBcmOjqafQQFBYHH4+k85+/v3yk87c4778Rrr72GN954AyEhIYiKisJPP/2EtrY2PP/88wgICEDfvn3x999/63xXZmYmpk2bBn9/f0RFReGZZ55BXV2d0bYplUr89ddfmDFjhs7z33//PZKSkiAUChEVFYVHHnlE5/UZM2Zg8+bNXf9xKBQKhULhKHT+plBuLKjRTaHcgPzyyy8IDw/HxYsX8dprr+HVV1/Fo48+iltuuQUpKSmYMmUKnnnmGYjFYgBAU1MT7rrrLowcORKXL1/GgQMHUF1djX/9619GvyM9PR0ikQhjxoxhn7t8+TJef/11fP7558jNzcWBAwcwYcIEnffddNNNuHjxIqRSqWPEUygUCoXiotD5m0JxTajRTaHcgAwfPhzz5s1DUlISPvjgAwiFQoSHh+Oll15CUlISPvnkE9TX1yM9PR0AsGrVKowcORKLFi3CgAEDMHLkSKxbtw7Hjh1DXl6ewe8oKSmBQCBAZGQk+1xpaSn8/Pxw3333ISEhASNHjsTrr7+u877Y2FjIZDKd0DsKhUKhUCh0/qZQXBVqdFMoNyDDhg1j/y8QCBAWFoahQ4eyz0VFRQEAampqAKgTqhw7dozdY+bv748BAwYAAAoKCgx+R3t7O7y9vXWSxdx9991ISEhA79698cwzz+D3339nV+MZfHx8AKDT8xQKhUKh3OjQ+ZtCcU2o0U2h3IB4enrq/M3j8XSeYyZalUoFAGhtbcWMGTOQmpqq88jPz+8UXsYQHh4OsVgMmUzGPhcQEICUlBRs2rQJMTEx+OSTTzB8+HA0NTWxxzQ0NAAAIiIi7KKVQqFQKBR3gc7fFIprQo1uCoVillGjRiErKwu9evVC3759dR5+fn4G3zNixAgAQHZ2ts7zHh4emDx5MpYtW4b09HQUFxfj6NGj7OuZmZno2bMnwsPDHaaHQqFQKJQbATp/UyjcgBrdFArFLLNnz0ZDQwOeeOIJXLp0CQUFBTh48CCef/55KJVKg++JiIjAqFGjcPr0afa5vXv3YuXKlUhNTUVJSQk2btwIlUqF/v37s8ecOnUKU6ZMcbgmCoVCoVDcHTp/UyjcgBrdFArFLLGxsThz5gyUSiWmTJmCoUOH4o033kBwcDD4fOOXkX//+9/4/fff2b+Dg4Oxfft23HXXXRg4cCDWrFmDTZs2YfDgwQAAiUSCnTt34qWXXnK4JgqFQqFQ3B06f1Mo3IBHCCHd3QgKheKetLe3o3///tiyZQvGjx9v9vjVq1djx44dOHTokBNaR6FQKBQKxRB0/qZQ7Av1dFMoFIfh4+ODjRs3oq6uzqLjPT098e233zq4VRQKhUKhUExB528Kxb5QTzeFQqFQKBQKhUKhUCgOgnq6KRQKhUKhUCgUCoVCcRDU6KZQKBQKhUKhUCgUCsVBUKObQqFQKBQKhUKhUCgUB0GNbgqFQqFQKBQKhUKhUBwENbopFAqFQqFQKBQKhUJxENToplAoFAqFQqFQKBQKxUFQo5tCoVAoFAqFQqFQKBQHQY1uCoVCoVAoFAqFQqFQHAQ1uikUCoVCoVAoFAqFQnEQ1OimUCgUCoVCoVAoFArFQfw/vkYpeIDOY1MAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -844,7 +837,7 @@ "nestml_gl_ca_synapse_model = '''\n", "model syn_gl_ca_synapse:\n", " state:\n", - " R_pre real = 0.\n", + " R_pre real = 1.\n", " w real = 1. # weight variable\n", "\n", " parameters:\n", @@ -889,8 +882,8 @@ " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", "\n", - " Version: 3.6.0-post0.dev0\n", - " Built: Mar 21 2024 03:47:13\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", "\n", " This program is provided AS IS and comes with\n", " NO WARRANTY. See the file LICENSE for details.\n", @@ -900,7 +893,19 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "-- The CXX compiler identification is GNU 10.2.1\n", + "\n", + "Oct 10 14:43:54 NodeManager::add_node [Info]: \n", + " Neuron models emitting precisely timed spikes exist: the kernel property \n", + " off_grid_spiking has been set to true.\n", + " \n", + " NOTE: Mixing precise-spiking and normal neuron models may lead to inconsistent results.\n", + "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", @@ -908,164 +913,163 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_24a1d5e6286c4f26852138f442b8afc8_module Configuration Summary\n", + "nestml_5f96fafefab649e598c41c6b624997da_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", "Build static libs : OFF\n", "C++ compiler flags : \n", "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", - "NEST include dirs : -I/home/charl/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", - "NEST libraries flags : -L/home/charl/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/10/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.so\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_24a1d5e6286c4f26852138f442b8afc8_module' using\n", + "You can now build and install 'nestml_5f96fafefab649e598c41c6b624997da_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_24a1d5e6286c4f26852138f442b8afc8_module.so will be installed to\n", - " /tmp/nestml_target_s0fu4oy8\n", + "The library file libnestml_5f96fafefab649e598c41c6b624997da_module.so will be installed to\n", + " /tmp/nestml_target_6h6g7acb\n", "The module can be loaded into NEST using\n", - " (nestml_24a1d5e6286c4f26852138f442b8afc8_module) Install (in SLI)\n", - " nest.Install(nestml_24a1d5e6286c4f26852138f442b8afc8_module) (in PyNEST)\n", + " (nestml_5f96fafefab649e598c41c6b624997da_module) Install (in SLI)\n", + " nest.Install(nestml_5f96fafefab649e598c41c6b624997da_module) (in PyNEST)\n", "\n", "CMake Warning (dev) in CMakeLists.txt:\n", " No cmake_minimum_required command is present. A line of code such as\n", "\n", - " cmake_minimum_required(VERSION 3.18)\n", + " cmake_minimum_required(VERSION 3.26)\n", "\n", " should be added at the top of the file. The version specified may be lower\n", " if you wish to support older CMake versions for this project. For more\n", " information run \"cmake --help-policy CMP0000\".\n", "This warning is for project developers. Use -Wno-dev to suppress it.\n", "\n", - "-- Configuring done\n", - "-- Generating done\n", - "-- Build files have been written to: /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", - "\u001b[35m\u001b[1mScanning dependencies of target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\u001b[0m\n", - "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/nestml_24a1d5e6286c4f26852138f442b8afc8_module.o\u001b[0m\n", - "[ 50%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.o\u001b[0m\n", - "[ 75%] \u001b[32mBuilding CXX object CMakeFiles/nestml_24a1d5e6286c4f26852138f442b8afc8_module_module.dir/gl_ca_neuron_nestml.o\u001b[0m\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘void gl_ca_neuron_nestml::init_state_internal_()’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:164:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 164 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "-- Configuring done (0.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 25%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/nestml_5f96fafefab649e598c41c6b624997da_module.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/gl_ca_neuron_nestml.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘void gl_ca_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:167:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 167 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:262:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 262 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:265:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 265 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:253:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 253 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:256:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 256 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::init_state_internal_()’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:169:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 169 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:172:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 172 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:273:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 273 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:276:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 276 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:264:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 264 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:267:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 267 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "In file included from /home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_24a1d5e6286c4f26852138f442b8afc8_module.cpp:36:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:571:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 571 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "In file included from /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_5f96fafefab649e598c41c6b624997da_module.cpp:36:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:576:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 576 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:577:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:560:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 560 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:582:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:565:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 565 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:571:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 571 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:576:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 576 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:577:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const string&) [with ConnectorModelT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:474:95: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:560:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 560 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:582:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:565:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 565 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:401:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 401 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:404:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 404 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:421:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 421 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:426:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 426 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:463:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 463 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:456:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 456 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:335:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 335 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:334:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 334 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:337:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 337 | auto get_thread = [tid]()\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:336:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 336 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:418:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", - " 418 | const double _tr_t = __t_spike - __dendritic_delay;\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:423:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 423 | const double _tr_t = __t_spike - __dendritic_delay;\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:401:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 401 | auto get_t = [_tr_t](){ return _tr_t; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:421:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 421 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:404:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 404 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:456:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 456 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:426:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 426 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:463:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 463 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:335:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", - " 335 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:334:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 334 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", " | ^~~~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:337:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 337 | auto get_thread = [tid]()\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:336:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 336 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:418:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", - " 418 | const double _tr_t = __t_spike - __dendritic_delay;\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:423:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 423 | const double _tr_t = __t_spike - __dendritic_delay;\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:396:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:618:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 618 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:399:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:622:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 622 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:396:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:618:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - "[100%] \u001b[32m\u001b[1mLinking CXX shared module nestml_24a1d5e6286c4f26852138f442b8afc8_module.so\u001b[0m\n", - "[100%] Built target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\n", - "[100%] Built target nestml_24a1d5e6286c4f26852138f442b8afc8_module_module\n", - "\u001b[36mInstall the project...\u001b[0m\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:399:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:622:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "[100%] Linking CXX shared module nestml_5f96fafefab649e598c41c6b624997da_module.so\n", + "[100%] Built target nestml_5f96fafefab649e598c41c6b624997da_module_module\n", + "[100%] Built target nestml_5f96fafefab649e598c41c6b624997da_module_module\n", + "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_s0fu4oy8/nestml_24a1d5e6286c4f26852138f442b8afc8_module.so\n" + "-- Installing: /tmp/nestml_target_6h6g7acb/nestml_5f96fafefab649e598c41c6b624997da_module.so\n" ] } ], @@ -1100,171 +1104,171 @@ "output_type": "stream", "text": [ "\n", - "Aug 26 09:56:10 Install [Info]: \n", - " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", + "Oct 10 14:44:07 Install [Info]: \n", + " loaded module nestml_5f96fafefab649e598c41c6b624997da_module\n", "\n", - "Aug 26 09:56:10 correlation_detector [Info]: \n", + "Oct 10 14:44:07 correlation_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Aug 26 09:56:10 correlomatrix_detector [Info]: \n", + "Oct 10 14:44:07 correlomatrix_detector [Info]: \n", " Default for delta_tau changed from 0.5 to 5 ms\n", "\n", - "Aug 26 09:56:10 correlospinmatrix_detector [Info]: \n", + "Oct 10 14:44:07 correlospinmatrix_detector [Info]: \n", " Default for delta_tau changed from 0.1 to 1 ms\n", "\n", - "Aug 26 09:56:10 gl_ca_neuron_nestml [Warning]: \n", + "Oct 10 14:44:07 gl_ca_neuron_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Aug 26 09:56:10 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", + "Oct 10 14:44:07 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", " Simulation resolution has changed. Internal state and parameters of the \n", " model have been reset!\n", "\n", - "Aug 26 09:56:10 SimulationManager::set_status [Info]: \n", + "Oct 10 14:44:07 SimulationManager::set_status [Info]: \n", " Temporal resolution changed from 0.1 to 1 ms.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 2 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 2\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 4 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 4\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 6 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 6\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 8 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 8\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 10 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 10\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 12 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 12\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 14 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 14\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 16 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 16\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 18 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 18\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 20 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 20\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 22 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 22\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n", "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", " Preparing 24 nodes for simulation.\n", "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", " Number of local nodes: 24\n", " Simulation time (ms): 25000\n", " Number of OpenMP threads: 1\n", " Not using MPI\n", "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", " Simulation finished.\n" ] }, @@ -1280,7 +1284,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1290,7 +1294,7 @@ } ], "source": [ - "#theoretical Phi vs U\n", + "# theoretical Phi vs U\n", "a = 3\n", "U_range_theory = np.linspace(0., 10., 100)\n", "Phi_of_U_theory = (4 * a) / (1 + np.exp(a - U_range_theory)) - (4 * a) / (1 + np.exp(a))\n", @@ -1325,6 +1329,56 @@ "execution_count": 13, "metadata": {}, "outputs": [], + "source": [ + "def run_simulation_in_chunks(sim_chunks, sim_time, syn_recordables, neurons):\n", + " sim_time_per_chunk = sim_time / sim_chunks\n", + "\n", + " # Init log to collect the values of all recordables\n", + " log = {}\n", + " log[\"t\"] = []\n", + "\n", + " # Initialize all the arrays\n", + " # Additional one entry is to store the trace value before the simulation begins\n", + " for rec in syn_recordables:\n", + " log[rec] = (sim_chunks + 1) * [[]]\n", + "\n", + " # Get the value of trace values before the simulation\n", + " syn = nest.GetConnections(target=neurons, synapse_model=synapse_model_name)\n", + " print(str(len(syn)) + \" synapses in the network\")\n", + " for rec in syn_recordables:\n", + " log[rec][0] = syn.get(rec)\n", + " \n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Run the simulation in chunks\n", + " for i in range(sim_chunks):\n", + " sim_start_time = i * sim_time_per_chunk\n", + " sim_end_time = sim_start_time + sim_time_per_chunk\n", + "\n", + " nest.Simulate(np.round(sim_time/sim_chunks))\n", + " \n", + " # log current values\n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Get the value of trace after the simulation\n", + " for rec in syn_recordables:\n", + " if isinstance(syn.get(rec), float):\n", + " log[rec][i + 1] = syn.get(rec)\n", + " else:\n", + " log[rec][i + 1] = syn.get(rec).copy()\n", + " \n", + " #nest.Cleanup()\n", + "\n", + " nest.Simulate(np.round(sim_time/sim_chunks)) # let the multimeters capture one more data point\n", + " \n", + " return log\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], "source": [ "def measure_postsynaptic_response(neuron_model: str,\n", " synapse_model: str,\n", @@ -1333,71 +1387,64 @@ " V_m_specifier: str = \"V_m\",\n", " custom_model_opts: Optional[Dict] = None):\n", "\n", - " spike_times = np.array([100., 200., 250., 2000.])\n", + " spike_times = np.array([50., 150., 250., 350., 2000.])\n", " \n", " nest.ResetKernel()\n", " nest.Install(module_name)\n", + " nest.resolution = .1 # [ms]\n", + "\n", + " sim_time = 500. # [ms] (was 120 seconds in original paper)\n", + " chunk_length = 1. # [ms]\n", + " n_chunks = int(sim_time / chunk_length)\n", + " syn_recordables = [\"R_pre\"]\n", + " \n", " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", + " initial_V_m = neuron.get(V_m_specifier)\n", " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", " nest.Connect(spike_generator, neuron, syn_spec={'synapse_model': synapse_model})\n", "\n", " multimeter = nest.Create('multimeter')\n", - " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier]})\n", + " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier], \"interval\": chunk_length})\n", " nest.Connect(multimeter, neuron)\n", "\n", " sr = nest.Create('spike_recorder')\n", - " nest.Connect(neuron, sr)\n", + " nest.Connect(neuron, sr) \n", + " \n", + " log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, neuron)\n", "\n", - " nest.Simulate(t_stop)\n", + " log[V_m_specifier] = np.hstack([initial_V_m, multimeter.events[V_m_specifier]])\n", "\n", - " ts = multimeter.events[\"times\"]\n", - " Vms = multimeter.events[V_m_specifier]\n", - " \n", - " return ts, Vms" + " return log" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Aug 26 09:56:10 Install [Info]: \n", - " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", - "\n", - "Aug 26 09:56:10 NodeManager::prepare_nodes [Info]: \n", - " Preparing 4 nodes for simulation.\n", - "\n", - "Aug 26 09:56:10 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 4\n", - " Simulation time (ms): 2250\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:10 SimulationManager::run [Info]: \n", - " Simulation finished.\n" + "1 synapses in the network\n" ] }, { "data": { "text/plain": [ - "" + "Text(0, 0.5, 'R_pre')" ] }, - "execution_count": 14, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1405,16 +1452,17 @@ } ], "source": [ - "ts, Vms_gl = measure_postsynaptic_response(neuron_model_name,\n", - " synapse_model_name,\n", - " module_name,\n", - " V_m_specifier=\"U\")\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.set_xlabel(\"$t$ [ms]\")\n", - "ax.plot(ts, Vms_gl, label=\"gl\")\n", - "ax.set_ylabel(\"U\")\n", - "ax.legend()" + "log = measure_postsynaptic_response(neuron_model_name,\n", + " synapse_model_name,\n", + " module_name,\n", + " V_m_specifier=\"U\")\n", + "\n", + "fig, ax = plt.subplots(nrows=2)\n", + "ax[0].plot(log[\"t\"], log[\"U\"])\n", + "ax[1].plot(log[\"t\"], log[\"R_pre\"])\n", + "ax[-1].set_xlabel(\"$t$ [ms]\")\n", + "ax[0].set_ylabel(\"U\")\n", + "ax[1].set_ylabel(r\"R_pre\")" ] }, { @@ -1428,52 +1476,7 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "def run_simulation_in_chunks(sim_chunks, sim_time, syn_recordables, neurons):\n", - " sim_time_per_chunk = sim_time / sim_chunks\n", - "\n", - " # Init log to collect the values of all recordables\n", - " log = {}\n", - " log[\"t\"] = []\n", - "\n", - " # Initialize all the arrays\n", - " # Additional one entry is to store the trace value before the simulation begins\n", - " for rec in syn_recordables:\n", - " log[rec] = (sim_chunks + 1) * [[]]\n", - "\n", - " # Get the value of trace values before the simulation\n", - " syn = nest.GetConnections(target=neurons, synapse_model=synapse_model_name)\n", - " print(str(len(syn)) + \" synapses in the network\")\n", - " for rec in syn_recordables:\n", - " log[rec][0] = syn.get(rec)\n", - " \n", - " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", - "\n", - " # Run the simulation in chunks\n", - " for i in range(sim_chunks):\n", - " sim_start_time = i * sim_time_per_chunk\n", - " sim_end_time = sim_start_time + sim_time_per_chunk\n", - "\n", - " nest.Simulate(np.round(sim_time/sim_chunks))\n", - " \n", - " # log current values\n", - " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", - "\n", - " # Get the value of trace after the simulation\n", - " for rec in syn_recordables:\n", - " log[rec][i + 1] = syn.get(rec).copy()\n", - " \n", - " #nest.Cleanup()\n", - " \n", - " return log\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1495,7 +1498,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": { "scrolled": true }, @@ -1504,1225 +1507,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Aug 26 09:56:11 Install [Info]: \n", - " loaded module nestml_24a1d5e6286c4f26852138f442b8afc8_module\n", - "\n", - "Aug 26 09:56:11 gl_ca_neuron_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Aug 26 09:56:11 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", - " Simulation resolution has changed. Internal state and parameters of the \n", - " model have been reset!\n", - "\n", - "Aug 26 09:56:11 SimulationManager::set_status [Info]: \n", - " Temporal resolution changed from 0.1 to 0.1 ms.\n", - "\n", - "Aug 26 09:56:11 ConnectionManager [Warning]: \n", - " New connections created, connection descriptors previously obtained using \n", - " 'GetConnections' are now invalid.\n", - "9900 synapses in the network\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:11 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:11 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:11 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:12 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:12 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:12 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:13 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:13 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:13 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:14 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:14 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:14 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:15 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:15 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:15 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:16 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:16 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:16 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:17 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:17 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:17 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:18 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:18 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:18 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n", - "\n", - "Aug 26 09:56:19 NodeManager::prepare_nodes [Info]: \n", - " Preparing 102 nodes for simulation.\n", - "\n", - "Aug 26 09:56:19 SimulationManager::start_updating_ [Info]: \n", - " Number of local nodes: 102\n", - " Simulation time (ms): 10\n", - " Number of OpenMP threads: 1\n", - " Not using MPI\n", - "\n", - "Aug 26 09:56:19 SimulationManager::run [Info]: \n", - " Simulation finished.\n" + "9900 synapses in the network\n" ] } ], @@ -2761,7 +1546,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -2770,13 +1555,13 @@ "Text(0.5, 0.98, 'R')" ] }, - "execution_count": 18, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2801,7 +1586,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -2810,13 +1595,13 @@ "Text(0, 0.5, 'Neuron')" ] }, - "execution_count": 19, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAG2CAYAAABiR7IfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADRzklEQVR4nOydeXhVxfnHvzcQEggkYRESlCUqVlkUQRCEaqVYcdf6q4VqXYuV4q4oWFErUQgWoQKCIEgVIaACAkGUVSQQoKFhMYghhE2SSBKyLyS59/dHeuK9N2eZmTNzzpzL+TwPjyb3nJl35p2ZO5n3nff1+Hw+H1xcXFxcXFxcXHQJs1sAFxcXFxcXFxcn4G6aXFxcXFxcXFwIcDdNLi4uLi4uLi4EuJsmFxcXFxcXFxcC3E2Ti4uLi4uLiwsB7qbJxcXFxcXFxYUAd9Pk4uLi4uLi4kKAu2lycXFxcXFxcSHA3TS5uLi4uLi4uBDgbppcXFxcXFxcXAiwddO0bds23HHHHejcuTM8Hg9WrVoV8LnP58Nrr72G+Ph4tGzZEsOHD0dWVlbAM0VFRbj//vsRHR2N2NhYPPbYYygvL7ewFS4uLi4uLi7nA7ZumioqKnDVVVdh9uzZqp9PnToV7733HubOnYtdu3YhKioKN998M6qrqxufuf/++/H9999jw4YNWLt2LbZt24bHH3/cqia4uLi4uLi4nCd4ZEnY6/F4sHLlStx9990AGk6ZOnfujBdeeAEvvvgiAKCkpASdOnXCokWLMHLkSBw6dAg9e/bEnj17cM011wAA1q9fj1tvvRWnTp1C586d7WqOi4uLi4uLS4jR3G4BtMjJyUFeXh6GDx/e+LuYmBhce+212LlzJ0aOHImdO3ciNja2ccMEAMOHD0dYWBh27dqFe+65R7Xsmpoa1NTUNP7s9XpRVFSE9u3bw+PxiGuUi4uLi4uLCzd8Ph/KysrQuXNnhIWJN55Ju2nKy8sDAHTq1Cng9506dWr8LC8vDx07dgz4vHnz5mjXrl3jM2pMnjwZ//jHPzhL7OLi4uLi4mIHJ0+exEUXXSS8Hmk3TSKZMGECnn/++cafS0pK0LVrV5w8eRLR0dHM5e4+WoRH/72Hh4gAAOXM690/XoWbesZxK9dONmTm4fll+xBsE/Zva2dfIXr16sWlPlKdLHxoAAZe3I5LnWYwI6+Itn7//ffcdGEnThsHaojWhZk+IpnXPNcwu/Up27wQ0f9my7RKR6WlpejSpQvatGnDXAYN0m6a4uIalJGfn4/4+PjG3+fn56Nv376Nz/z8888B79XV1aGoqKjxfTUiIiIQERHR5PfR0dGmNk03XtkGF3bMRl5JdZOBphDmAXw+aH4ejAfAP7ecxN0De6BZmLNNh/VeH/65ZQ88Ea2g1hKlreN+VYrBgwdzqdNIJx4AcTGRuPHKblL0rxl5RbQ1Pz+fmy7sxGnjQA3RumDtI9J5zXMNs1ufMs0LEf3Po0yrdWSVa420cZoSEhIQFxeHTZs2Nf6utLQUu3btahysgwcPRnFxMdLT0xuf2bx5M7xeL6699lrLZW4W5sHrd/RU/czzv3+jf53Q+DMJPgC5JdVYlJqDeq8UPvua1Ht92JldiC8zfsLO7MIm8u7OKUJuSbXG27+0NedsjeYztPjrRK3PfQBGDuhiWI5R23ihJ6/y8+t39FRdZMy8q0WLFi2InzWLyD422zdW6V8PRReiZGHtI9J5vTuniIucZmSlQa+frZwXRjKJ6H8eZVqhIzuw9aSpvLwcR44cafw5JycHGRkZaNeuHbp27Ypnn30WiYmJ6NGjBxISEjBx4kR07ty58YbdFVdcgREjRmD06NGYO3cuamtr8eSTT2LkyJG23pyLaRWO4sragN/FtgrH5N/3wYje8bi6a1v8Y02m7qAMZlLKIXy4PQev39ETI3rHG79gMesP5jZpU3xMZIC8P5cRtrdlDFfZRvSOx5wH+mn2+fSNWUjec1Kzb0naZoW8cQR1mnlXjWCfQlFY0cesfWO1/rXo1KmTcFlY+oh0XhPPf0J4j3V/jPrZqnlBItOtvcnMbjT9z0unInVkF7aGHNi6dStuvPHGJr9/6KGHsGjRIvh8Prz++uuYN28eiouLMXToULz//vu47LLLGp8tKirCk08+iTVr1iAsLAz33nsv3nvvPbRu3ZpYjtLSUsTExKCkpMSUeW79wVyMWbxX0/Q294F+jYNE+Qsh9cgZzNqSTVS+sh+f41eODGi1O1jendmFGDU/zbC8P7Y5jKS/P2/4HC31Xh9mbT6C6Rt/bPKZVt+Stk0Eyhj5uawaHdtEYmBCO6rjddZ3/Zk3b57wuGdW9zFN39ip/2Cefv0drKnpaYksNH1EOq+Xjh6EwZe05yKfP7zGugKJzk/sWGNpPEA9mUi/wGn6n7dOeevIH17f36RIE6fJTnh0er3Xh6FJmzVPjxT77faXhzXxBxiatFnXD4qkHBo5eQ5emnYD0G2r8uwXD/dC53jzTqPBbe3frS1ueGcLsY5Ydcob/3Z0iIoAPEBBeU2A/kQtSvn5+UL/qpalj2WXrd7rw8BXv0Cht6WhLACEfUFpyTZkymbklWqfOsRFRyB1/G+lN8WQ6tzsGkUzX41kUuTS+v5gGadG30t2zstgrN40SesI7jRobMD+O3PF7jtm8V6ivxq0yiFBxNE+bbu12upv41644EO8+uqrTPIoqLW1XVQ4iipqNd8JlpVVpzxRa4c/8TGRuPOqeKzelyvEZDN//nzTutBDhj7WQibZducUIXv7l4i9bqSuLLM2H0HynhOWmhI3ZOahuq5e95nqOi82ZOZJdUKuBqnO33jnPcx7922mOmjXYSOZFLnUYPUd0vtecrI/Eg+kdQR3GmZswIrdNy4mknt9CsrxbvDkyyupxpjFe7H+YC5VebRyKM9ptTUuJrLRvMBjw6TWVr0Nk5qsdvlqKGi1w5/ckmp8sC2Hu14VRG6YAPv7mEedVsj2c1m15obJn+kbfxQ2FtRQxmiwD2cwJZW1wmTgCakub3twLFP5LOuwmfHlv67SQrJWn4+4J02c6NiGbMOj9dyI3vG4qWccFqXmYFLKIW71AQ1Hrf9Yk6n614gPDX85/GNNJm7qGUf9lwNLu5W2ah1PJyYmMn9Z67WVFEVWszo1g9l2mNWrghldkGBnH/Oq0wrZOraJRPGOZKKNUzC8xkIwNGNUlAy8IdVlysezcVdfupMm1nWYZXzFtgzH7Pv7YdDF7U31tdFafT7injRxYmBCO8THRGqGEvCg4Qh2YIJ2EK9mYR48PCTBdDnBmLk+anS9mbXdzcI8GHxJe9zV90IMviRwYr/wwguqZZFctSY5ytYiWNaBCe0QF629YLHoghQz7VDQ0ivNlXU1XfC88s5j3ohCJtkGJrTDr4aPIg5VEoyIa/+0Y1SEDFqwjlFSnb87if4PCdZ12EgmNYqrahHm8XAJoeG/Vg9MaIfdOUW2ht6wG/ekiRO8bMAibMmsZgYS27sIed9///0mX9akfgCsR9lqsur5aoi26/M0+fiXRetPEawL3n5xMvtOyCRbszAPrizbhY3NBqrKQvrVJWpcWfEeKWbGKKnOP5g7R/OPOy1Y12Fav1ej+lj7R5bQG3bjnjRxhJcNmLctmcXMQGN75y3vnXfeGfAzjSykbW0XFRicLlhWI1+N2FbhQu36PE0+Slks/hT+uhDlFyez74RMsr30+AOasjw3vAdRGSLGlVXvkcBjjJLoPHiNIsGMuZfF71WtHNb+ETX3nYh70sQZXjZgnrZk5XjX6PqoYmZgsb3zlHfv3r3o0aMHkyykbf123I1IP35WVVYSX42I5mFC8wEatYMEf72y+lMouhDpFwfI7Tshi2x79+7FH//4R1VZACB5z0niOc4D2jEqQgZ/eI5RI537r1Gk0K7DWjKlZRdi7JK9KK5S/4NOqxzW/hE9952Gu2liRC/OhmIDNgvPcmjMDGbCJ/CQ94ILLmj8f1JZFqXmoEObCHRsE4mJt/XE2CX6bW3RPExTVhJfjbzSGqFXzZuFeTDxtp7425K9TO8rbR85oAvW7j+NgrIaJp0quhBx/V5tDlkdVoAUo7EtIv5ZcHmKLrRksdKUqMh3S+84LEw9Zmg24iGDUR/zHqN6Ovdfo0jhYe5tFubBkB4dMOXePhizuGFtIC2HtX949CvJ/BAZAJMn7qaJASfadmnC2dt91do/mTJpHf43DuNjIvH49QlNYheRhu63u/1AwxiblJJp+Fx8TCR6XxiNTYd+RrBPZlSLZpi+MYuq3uA2Kbrg3SdOnENa8G6LVnn/d1E5hum8Z1XKCjX5PJ6GROQKYR4EjEezMvBM08Rj3qolfCeBl46sTHdjtl9JdOek9cDdNFGiFc5ese3a7YOhB6mZwe6r1tnZ2RgyZAhzHXkl1Zi3LQez/3Q12kZFUP/lYnf7jdLxPPvbS5FwQWt0bBOJsxXnMHZJ02d9ACrO6QccVCO4TYouePaJk+dQMLzbolfelNRv0evqgYa5B0WaErXkUzZIjw3pjuE949C/W1tN8zevOoP72Mp5679G0WKXCwdr/5jpVxLdAXDUeuBumigIBdsuiQnNrO1dDZqj19/85jfEsqih6GJSyiGmMP8i2k+KkT+VB8Cy/5wKSEvD49KvVpsUXfDok3qvD2nZhRj/xQHL55CIo3/e64FReZFd+xCVx8tMTiMf0NDedQfz8MptPbnJQNPHVs5b/zWKBTtcOFj7h/U9Et29sfp7AB5Hfae6t+coMBPvyEkotnfgFxu5AotvwvqDuRiatBmj5qfhmeQMjJqfhqFJmzVvXHzyySdEsuhhRhe8208DzRjjEcsJ0G+ToguzfaKMgfsX7NJ0YAXEzCHa8UcK7/XAqLzyg1tsXV/sWP9o6rRy3vqvUU6BtX9Y3yPRXV5pjW7OQhm/U91NEwUy+LpYBa+r1ixXVSdMmEAkCwmsurDrqvnGzDyi534uq+Y2zvTa5K8L1j4hSQcTDK+2ibwqzXs9MHouevAfqMrjjR3rn4g0TTwIXqOcAmv/sLwnQ0wwEbjmOQrs9nWxGrO2d1bzxdtvv90kdUewLAVlNdzTzQRj9VXzeq8PKzN+InrW7BibeNsVjbcN9doUrAvaPmFNB8NjDok2p/NeD4yeK9m5HLHXjbRtfbFj/RORpokHamuUU2DtH1E+VCTI9J3qbpoosNPXxS7M2N5Zr6q+8sorurIovjGxLcOpY5XQwtJ+Vv+Z3TlFREmF20e1aGwXrb+X0i8PD0kgkklNFzR9wmJC9G+fGUSESfCH93pgVF7s4PsQFx0Br8+HLzN+svxath3rH2udovy6FLTWKCegtT6RrFu8fag6RUcA8CC/1Dnfqe6miQKZ0io4Adbj/MmTJ+Pvf/+76rNqV1ODsVMXZq7OkvbXXX07N7aLJr0CS7/o6YIElmN1//aZQbQ5ifd6YFRe8c7PEDv8Adz/4a7G31t5LduO9U/WNdfsvLALrfXpzqvim4RoMTu2SHT3xp29AEA6/erh+jRRIlNaBdlhPc7/85//rPocqW+MXbow6z9D2l8xLX9JAaM1HmNbhSO2VXjA71j6RUsXpLAcq/OKtG6FOYn3eqBVXkyrcET1vrFJWh+r01jYsf7JuOaanRd2oLU+5ZZU44NtOUL8/kh0J6N+9fD4fD5ad4OQo7S0FDExMSgpKUF0dDTRO06JXmon9V4fhiZtNjxaDw4L8PHHH+PBBx9ULUtvwxTbMhyz7++HQRe3t1wXRvJptTW4jCFTNiGvtEa3rniVctTGIwDTY1RNFzQYjYFg1Nomqm4SndDUJSoieIeoCLzw2T4c2ZGC1r1/2+RZnu1gkc+q9U+mNdfsvLAakvVTDV5jS2REcJbvbzO45jlGRNvMWZFpYWE9Wr/kkkualEXiG1NcVYswj4c4Jg7PfuLhP9MszINRA7saRvEmSWHDq31quqCBNEO7iKN4o7p9AG7t3eDYalb/auuBGR34l7czuxB5pdVoHqv+F7dZ3ywtrEgVRYNMa67ZeaFgRfqdZmEe5vAkvMYW6fyQRb96uJumEELGUPQs4f5rapqetPD0TxHRT7zk694hynQ5PNunpgtatMaAP7xTfRjVraT5WJB6DAtSj3GfJzx1oOjaV69/SYDntWwZ1xKZ4DEvrEq/8/odPVFT5zUlK+8r/04eX+6mKUSQOTUF7VXVM2fONPkdL/8UUf10rKCCi3xm28m7fWq6YCF4DHSIigA8QEF5jfATUf+6N2TmYWHqsSZ5+njOE946UHTtrSwhes4sMq8lsmB2XliZfmfM4r14dngPU/LyvPLv9PHlOoKHAEbxaICGeDT1wd8UFqIcz97V90IMvkTf56hfv35NfqdcX9V6y4OGv1SM0niI6Kd6rw9Ld58wfM5IPsBcO0W0T00XrPiPgSE9OmDIpR2IxgOvugcmtMNXB9WDh/KaJyJ0oIyJiE7qJiGSsU+K7GtJvdeHndmF+DLjJ+zMLrRNDjPzot7rwxur+fUxic6W7j6BuGjtdUULnmMLkH98keBumkKAUEvvsnr16ia/45EiQVQ/7c4pMnTeBoCRA7oabg7MtFNE+9R04VSsmCci6lDGROWRXcLTg8i8lohKh8OCmXkxa3MW19QhpOlKRg3sCoA8HZUIP0OZxxcp7qYpBAi19C5/+9vfVH9v9mqqqH4ifb57h1ZEz7G2U0T7tHThRKyYJ6LqGNE7Hh9N/bvwa9myriUi0+GwwDov1h/MNbzoocBbF907tFJdV+JjIvHX6xMQb8GVf1nHFw2uT1MIEGrpXaZNm6aZosBMioQOrSOI6id9TkFE/7O0U4QcerpwGlbME5F1HFi/BNtf+bvQ27EyriWi0+GwwDIvlHaQIiJNz+BL2muuKy+NuEL4zWsZxxct7qYpBAi19C5GixHz1WNSMzmlOd2o/4GGGFJenw/1Xh/TtXMecrCMA5k3TLTXtUn0FBcdYWqeiJyLii5EXsu2ai2h0Z3odDgssrLMC5pr/zR+RLQ601pXrAjpIGqttBLXPBcC8PD3kYnExEQh5RZUkF0TJn1OQa//FYqranH/h7uE+mCIGAeidGEWFv8WEj1V13mxIVPdWZwEkXPRCl1YsZbQ6s5Ok46WrA899TJ1WTTysaTfAeRf/2VZK83gbppCBKeFotdj9OjRQsoVeTSs1f/BiPbB4D0OROnCDGb8W5T+iQlKMaNQUllrSeoIFqzShci1hEV3dpl09GTdgj7UY4RUvueGX8Yt/Y6M678sayUrbhoVWB+GXSQyRQRnZd68eXj88ce5l2tFWo16rw9p2YUYu2QviqvUgxFakfaC1zgQpQtW+KWr2ax5g8nK1BE0WK0LEdGqWXRnZTocUlnLM9ajxw13U9VJklIoLjoCqeN/a2r9ccr6z2utdNOouJhCplQDrPTv319IuVZkTG8W5kFYmEdzEQB+8cFIyy5EWJiHaYEzWhx5jQNRuqDBv60FZTXE/i0DE9ppppQgvfKt9CHLl5FZHQTX2ffqfpqfifhy5L2W0PgmBetu4m09MXaJuHlLK2t43KXUflQk688bd/ZqbAeNjoOfvf3KztJuloBf5N15tIBorRTlr8aCu2lykY78/HxhZbOkdaGF1Hch+C8s0jQCVqYgEKkLEtTaSsKGzDw8vzzDVEoJRY92pHxQqzMybx9mvHghADgyBQXpvNDS3ePXJ2D1vlxh85ZGVm/FWaLngiFdf2jGnNNSkrDMaZlCELibJhfpOHfunNDyzYQtIIHUdyH4LyySNAJWpyAQrQs9tNpKwsLUY01+R5tSomObSFtSPmjVWVRaiScW71V9xwkpKEjnhZbu5m3Lwew/XY22URHCzU9Gsvrq64ieU8No/aEZc05LScI6p/X62czFDRbcTZMGTrINhxq8MojrIdKMSXKtVg2jmDM84tUo4zqvpApFFefQrnUE4qK1x7cVulBDr61GKMl4g1H6SEkpkV+q7yPTv1tb3PDOFkvjA+m1u3lb7S8/u+IV0UAyL4x0NynlEJPvEu/wFOFt402lF9Faf2jmOP73/1aNT7PfiSxz2ijERb3Xhylf/UBRonncTZMKTjvuDDW+/fZb9OnTx24xmNHzXTBCz4ZvNl6N3rG41vi2Sxc0MW0UlL7WS1ulpJR4bvhlmLHxR10fmfTjZy2PD6TX7uoTB9Digu6WysMTI58eEt2xtI9lPTeStfrEAbz+3O+5b05p04xYNT55fCfSzmkSf7XdOUXIJ0hhxRM35EAQsoXrPx954IEH7BbBNFrXamNbql91D0bNhm8mXo3WuFbI1RjfdumCxYchLiYSjw3pTvSsVkoJ/yvadsQH0iurda8bTZdhN3pX40l1R9M+HuEp1GT94B/PCvkDmmbMWTU+eX0n0spBEi7BjrHunjT5IWO4/vORWbNmSR2JmhQ13wWvz4f7P9xl+K6aDZ81Xg3NsXjw+LZLF6RtnXjbFejQJqLRXLA7pwgLVHxi1MrXSylBIwPP+EB6ZZXuXYvY60ZaKo8ItHx60o4WEumONM0Rj/VcS9bJb78FXMd/XogYc2bGA8/vRFI5nrzxUgy5tAOR+c+Ose5umvxIP2b9cXwowNv/KxQ2TArBvgv1Xh9zmgrWFBekx+Jq49uMLvTGhdGYIW3rw0MSmN4zSinBUpYZ/H3N2kW1wNmKc03qNNowqckjq2+mar9zSnOktDn1yBku67marKLWKNoxJ3p88kxhQ9q25266rLFuo3E7MKEdOkVH4CRFm8zibpr8OFPu/AzMViPC/ysxMTGkNk7+mIkVxfou7Xj1f55VF3rjAjC+Ms/aVp6xuKyI6wWQX8Eu3pFsuHHyl8dpvpk80hxZdZ1d1BpFO+ZEj0+eJkDStm3IzCMet83CPBh/y+X4vzeJxOSC69PkxwWtnZ+B2UpE+X899dRTPMSTFjMpD1jepR2v/s+z6EJvXDyxeC+eIBwzrP3EM6WE6PQURr5m/kT3v0Pzs/ZRLVSvojvJN9OsaYqmL1nq9UfkGkUz5kSPT97mQiN5AVCPW+UmoVW4aVTwSxj2orPFuHXOfywN1+9UeKSz0GLmzJkhv3ECzJlOaKMF6+lKQU1ntLogrYu0fqVMln7iaZoSYeYi6au2rZrD6/OgpKoWpelrVDdO7aLCkTZhOFo0DyMqV9Z1zEy6FJZxJ/saZSYiOC8zrKgUNmryAmAat24aFRux6jg+GFn9DrTkqvf6sCg1R5j/14036t8SkrW/aDETK4rmXf9xrfcXkg8NjtX+fWmki2BYQgX41682Zlj7iWcsLhFxvUj66mxlXWN4hJZdA0M/KFp6+54+jRsmknJl9c00s/6KuM6uB+28YIF2jovQpajvRDV5d2YXMqXZiYJ2GhYRuJumIKxIs+GPrH4HWnLdeVV8k1QGerD4C2RlZaF3795UctndX7KjNa6DmZRyCGFhnsa+1NOFGjz8/c4Xn0HSdirhEZ6Z8h/UoHvj77XWJDtCJfCCdf1luc5uZs2gnRdOxqrvRNY0O96aSi71k+JumlQQnWZDQdYQ+Fpy5ZZU44NtOVRlsfgLtGzZkkouu/vLKfiP62++z8VHO443eSa4L7V0oQUPf7/zxWeQxl9k8CXt8e6fBqLdrwYarkl2hErgCcv6K+I6ux6088LpWPGdaCbNjpW4myYNRKbZAOSNCWUmfYU/Zq67tm9vLr2AE011VtEszIOBCe3w/PIM1c+D+1JNF3qwppAB+F7hdwK018s7XtABAwjWJCtDJYiCdv2luc7OY32gnRehgOjvRDNpdqzEvT1nE7Th8q3CjE+Kgll/gYyMDGq5tPqr3uvDzuxCfJnxE3ZmF6KeYMaxvEOD6PKNoOnLjIwM1Ht9SM0qwD+//gH//PowUo8UaMqs+EAAv4wDBY/G//v/LMJnUFZI+sq/P9TmBY9yQwGr20yqC16YXTNo3rdjfVL8VG/pHdf4h5s/ys92b5gA96TJNmT1O+BRn1lb9x13NL0hxNJfLP5Pon2mZPDJounLqB4D0T9xA4orf3G2nLXlCGJbhWPK7/uoymzkAwE0jdMkymdQdmj8RdTmBY9yQwUr20yjC7OYXTNo3rdjfVKr0+MB/O/1x8VE4tbecUQR40XjhhyA9VcWgYabAqPmpxk+t3T0IEtvuJDKpcXE265oEqWZFrXAcbT9peX/pEil5v/E8g4NossnhbQvnxt+GV5/803dgIpzdWQ2ExH8fIOkP1gCKp6P/WxFm60KwGt2zaB53471SatOhceGdMfwnnGNt+XU1i1vTSVOzrjPsu9vd9MEezZNouJfiJZLC94xdmjl8q8foI/3ITq2Da/yefTnuTovBk3ehKKKc5qydIqOgM8H5JfpR2mOi45A6vjfhvwXsRoybEhkkEE0MsQrooWHHGbXDJr3AWDIlM3IK7Uuthdt+7S+A6zeNLnmOZuwKyaUGbm00JKX9ahX7a84mv6iifehnOKJjm3Do3weR+dKGXobJgAYNbArpm/MMkzdkVdag1mbj+CZ4T2I6g8V7DBjBM8LGUy9opHVtKR30sRLDrNrBs37u3MKNTdMJHWxQNs+lu8mEbiO4DYiOgQ+b7niYyLx1+sTEE8gr5k0Di+++CKVXMH1s/g/ifYxM1s+j7QYJGkmlL7s3iEKABAz8PeG5U7f+KOUaTlEYVeKEv954cQ0KbTQtNHq/tBao3jKYXbNoIl7NH1jFleZeJbl/5zWd4CVuCdNNmNVTCiecr004gpdec2GB5g5cybGjRtHLZcCS5wa0bFtzJTPI9wCSSiJdlHh+HbcjWjRPAw7swsBAKXpaxBz7b2Gcp8v4R7sDH2hzIvzIfwGTRvxv/+3sj/U1ijeejG7JpG+vyrjNNFzNGXyLCv4ueDvgCjU4qYZ3MQyxN00SYBa/Itgm3j/bm2RfvyspRsrrbgcRvE6zB4r33333dRy+fdXh6gIxEVHIr+UPE6N6Ng2ZsrnYdojCSVRVFGLT3Yew8NDEjAwoR3ioiNQ22OQ7jsKwfXL4lvCG1Zd8OgPZV44NU0KDTRt9Pp8lveH2hrFWy9m1ySS99tGhWua6oOJN7H+qY1/mvapva/0YWlpKZNMrLibJglRs4kHB/WS2XfB7LFyeno6evQg95FR66/YVuGNf92R+IuJ9jEzUz4P0yFpGZNSDuHD7Tl4/Y6eeOPOXvjzK98gvN2FVPWHsq+NVaEv1FDmhazhSnhCY1pasfcnrmWSoLZG0chMsmkyuyaRvH9P3wuJr/Gzrn9645+kfRsy86RaT1yfJsnQsokHB/WS2XfB7LFyXFwccV1a/VXyv7hCMa3CA8vW8RcT7WPGWj4P0yHNsboytgBg3D3XIiqiGXH9oe5rQ6sLnv2hzAunp0khgSalRnEVWcJWnv2htkbRyEyqd7NrktH7w3uSrbXPDb+Maf0zGv8AdOUDIN164p40SQRNChOZfRfMHis3b042LEl8CCKbh+HTv1yLgvIaIrOIaB8zlvJ5mA5p0pv4j60pQzri2T8PMQxREBfTYEK+4Z0tIe1rQ2tS4OnjosyLUEiTYgTPlBoi+kNtjVJkNjKD0+rd7Jqk936912fYz3HREXhy2KVEdflDOv63vzxMVT6gIXSM0fvrxlxDLZsZ3JMmiaBNYWJXqhUjzKY0yMkhSwpM4kOQV1qDMI8Hd/W9sPHaqh4svie0aQcUnyxSmfT6E2ho5629GxYdlvQmaihja9Pug2jRPAxv39MbHpV3/fWZfvysLamBrEz7QDO2eadKUubF+ZAmhaSNNGrm3R9qa5S/zHoE651k/NKuGaTvG/WzB8Abd/Zi6jua8a8mH+n76cfOUstmBvekSSJEX2e3EjMpDa6//nqiOnj7dsiYdkVBqz+Vv7YXpB7DgtRjunVrlaFHl579dN/11+eXGdb7ltjhP0U6tnmPT/95cT6kSdFrI2lKDb10P2bQWqNG9I7HY0O6E8n2c1m1FP5/osaSVSETzpRb+/3nbpokQvR1dqthPVZesmQJJkyYYFg+T98OrXD+iu2cJu2K3jtm8O/PDZl5WJh6TNPXTc9v66aecViUmoNJKYcM69y7eS1w67VN6lfTp9W+Nlb3vz+iQl/oETwvZA1XwhOtNu7OKSLamMwe1Q9DenTgLpfeGjW8J9mG7lhBJWZs/NGW8RuMiLFkVciEC1pb+/3nplGBPWlU1KBNYaIX2t7JV77r6+vRrJmx8zGvVDQs6QpEp13Rg0fdpH337Ys3oEU4uY+ZVamB7Ox/Unj3B+m8OB8gHr/jbhQSqkVPFySydYqOAOCxNG2J1Zgd/6TvrxtzDdq1jbXs+9v1aZIIGr8TPd+F9QdzMTRpM0bNT8MzyRkYNT8NQ5M2O+bm0uTJk4me4+XbweJ7wttfhQYedZP23dSkKcRyWelrY2f/k8K7P0jnxfkASd/eeVU8bnhni5B1UE8XJLKNGtiVOG2JUzE7/mX13XM3TZKhdUU0eFxoXTkNhSvfNNnDeYQJkDHtCo8yjZ4j6TvaTO5WpQZySqwinv1Bq4tQR69vH78+AfO25QhbB410YaR3JU2REXaPX7OIDplgh++e69MkIWr2ZZKI4KGSXkEvGaYaZu3xMqZd4VEmyXNGfUerC5IyeeCkWEW8+oNFF6GO1lopOvQFiS709K6kKTJChvFrFpEhE+zA3TRJilqqEKMosqGSXuGhhx6ifscotYseLHFv7IyVw7tuvb5T0wWJv5wZfZDgtFhFPPqDZV6cDwT37c7sQuHrIM28UKuD1/il8V2108/V7PgXvZ7QILV5rr6+HhMnTkRCQgJatmyJSy65BJMmTYK/77rP58Nrr72G+Ph4tGzZEsOHD0dWFlnG5lDDKSYLIzZt2mRpfSy2czvt7VbWHawLWfzlZPV3EInV88KpWLEOmp0XPMYvTZ2yzNtQQOpNU1JSEubMmYNZs2bh0KFDSEpKwtSpUzFz5szGZ6ZOnYr33nsPc+fOxa5duxAVFYWbb74Z1dVybwxE4CSThR6XXXaZ5XWy2M7ttLdbVbe/LmTzl5PR30EkdswLJ2LFOshjXpgZvzR1yjZvnY7U5rkdO3bgrrvuwm233QYA6N69O5YuXYrdu3cDaDhlmjFjBl599VXcddddAICPP/4YnTp1wqpVqzBy5EjbZLcDp5kstKiqqrKlXhbbuZ32divqVnQhq7+cbP4OIrFrXjgNK9ZBXvOCZfzS1In//b9s89bJSL1puu666zBv3jz8+OOPuOyyy7Bv3z5s374d7777LoCGUPZ5eXkYPnx44zsxMTG49tprsXPnTs1NU01NDWpqahp/Li0tFdsQizCbFVsWCgvJnCRFwGI7t9PeLrpuRRcy+8ux9gFryhy7Nmha88LRMdkEyG7FOshzXtCOX9pwG7LOW6citXlu/PjxGDlyJC6//HKEh4fj6quvxrPPPov7778fAJCXlwcA6NSpU8B7nTp1avxMjcmTJyMmJqbxX5cuXQAAR48exdSpU1FTU4PExEQADbckTp8+jQULFmDPnj34+uuvsWLFCmRmZuK9995DaWlpwLNFRUWYPXs29u/fj9WrVyMlJQV79+7FBx98gDNnzgQ8W1lZiWnTpuHw4cNYvnw5Nm3ahB07dmDRokU4efJkwLP19fWYPHkyjh8/jk8++QTbt2/H1q1bkZycjKysLLzzzjuorq7Gf1YtwJwH+qEu/XPUl59FWcZ61OT+iMj8/XggPh8XoRAzZ85ESUlJQPnFxcWYNWsWDhw4gFWrVmHdunVIT0/HvHnzkJ+fH/BsVVUVpk2bhqysLCxbtgybN29GamoqPv74Y5w4cQJvvfUWvF4vEhMT4fV68dZbb+HEiRP4+OOPkZqais2bN2PZsmXIysrCtGnTUFVVFVD+hRdeiHnz5iE9PR3r1q3DqlWrcODAAcyaNQvFxcUBz5aUlGDmzJk4ePAgVq5cifXr12PPnj2YP38+8vLyAp6trq7GO++8g6ysLCQnJ2Pr1q3Yvn07PvnkExw/fhyTJ09GfX19wDsnT57EokWLsGPHDmzatAnLly/H4cOHMW3aNFRWVgY8e+bMGXzwwQfYu3cvUlJSsHr1auzfvx+zZ89GUVFRwLOlpaV47733kJmZiRUrVuDrr7/Gnj17sGDBApw+fTrg2ZqaGkydOhXZ2dlYunQptm7diu+++w6LFy/GsWPHMGXKFNTV1QW8c+rUKXz00UdIS0vDhg0b8Nlnn+GHH37A9OnTUV5eHvBsQUEB5s6di4yMDKxduxZr1qxBRkYG5syZg65duyIxMRE/l1WjeEcyvDWVKN3zJc4VnEDF4VRU5exFzenDKN//DerKCjHr3aTGcmtra5GUlISjR4/i008/xbZt27Bt2zZ8+umnOHr0KJKSklBbW9tkri1cuBC7du3CN998gy+++AKZmZmYMWMGysrKAp4tLCzEnDlzkJGRgTVr1mDt2rXIyMjA3LlzUVBQEPBseXk5pk+fjh9++AGfffYZ3p6XjKvGzsIdT03C2Hkbccsjz2Jo0mY89NTLqKurw5QpU3Ds2DEsXrwY3333HbZu3YrxU9/HNS8txq1/eRFPL94T8I4Va8Tp06ebrBEPPfUyhiZtxi2PPIunl6Tj1kefx4DxSzFu8kzNNcK//Ly8PMyfPx979uzB+vXrsXLlShw8eNCSNWLd/p/Q/eZHMXLeDjz89AT8Ydpq/OqP4zHtky8N14j8/HzdNcJ/HfTWVKA0fQ3OnTmGFqf+g8e6l6B91SlTa8SOHTsAALPeTUJd6RmUH9iI6lOHUHUsAxWHvkNt4SmU7l4Bb23DvPm5rJrbGvHpxx+hrqwQxTuSAQDFO5Lhq6tFya7PUXs2FxWZ36L6xH5s+fZbLE/+FHUl+ShJ+ww+b33AO3WlBSjfvwE1P/2AbzZ8w7xGFBYWBjxbVlaGGTNmIDMzE1988QW++eYb7Nq1CwsXLmyytvFYI7788kvN73oRSB0RPDk5GePGjcM777yDXr16ISMjA88++yzeffddPPTQQ9ixYweGDBmC06dPIz7+F/vvfffdB4/Hg2XLlqmWq3bS1KVLF9sjgvPEyX99Tps2DS+88ILdYrjgF13szC7EqPlphs8vHT1I+r9YtdKvKLODJmWO3ju8CZ4XMsjEilWyi1oH7ZwXNHUCCJl5q4XVGT2kNs+NGzeu8bQJAPr06dO423/ooYcQF9dgs83Pzw/YNOXn56Nv376a5UZERCAiIkKo7HZDc+Qr2wZrzJgxltUlW9tlQ9FFqPjLkfqDDLu8U2NctHYtW+CVlQdt9wvxnxey+pipETzH+ndra5nsoszXds4L2jpDYd7KhNTmucrKSoSFBYrYrFkzeL1eAEBCQgLi4uICrn+WlpZi165dGDx4sKWyOhUZr6IqPmuikbHtsqHoIlSu+JP6gwyavKlxXPz5o90oqjhn+I7olBf+88IJaWQA9Tk2aPJGR8iuh53zgqbOUJm3MiH1pumOO+7AW2+9hZSUFBw7dgwrV67Eu+++i3vuuQcA4PF48OyzzyIxMRGrV6/GgQMH8OCDD6Jz5864++677RXeAch6FdWKqMeytl02/HURClf8SWPz6G2SzJbNir8unBCTTWuOFVXUEr0vczw5u+cFTZ2hMG9lQmrz3MyZMzFx4kT87W9/w88//4zOnTvjr3/9K1577bXGZ1566SVUVFTg8ccfR3FxMYYOHYr169cjMlLuWER2I/Pxvuh0ETK3XTaCdeH0K/4iY5SJjn/mrwvZY7LpzTFSZI4nJ8O8oKnT6fNWJqR2BLcKqx3JZMAux14SH6IzZ87gggsu4FZnMKHk1CwCfx2FnyvHzddcRnwVP6+kCkUV59CudQTioq1dmEnGVr3Xh6FJmzV9PFhQ/EK2vzxMaFv954VRO6ySSQvSOaaG3bKTIHqNciHHdQR3sQQ7jvfXH8zFP9ZkBhzXx8dE4vU7egYcEa9YsQJ//etfudUbjBNMG3YRrKOyjK9w2Q33NNGR3jv+qOnXCrm16taL4WMGK/xC/OeF7DHZWOeODLKTIHqNcpEXqX2aXMRh9fE+jQ/RgAEDuNSpheymDbtQ01GLuB66fl5aelXItcBHjNY/TcvHo11UOHXd7aNaWOYXEjwvZPZVIZ077aJaBPwsg+wkiF6jXOTFPWk6T7HyqiytD1Furlgn7FC5Ps8TLR3VV5zV9POi8VsR5SPG6p+m5uPRv1tb3PDOFmLTXbuocOyc8Fu0aG7N355q80JWXxXSOfbtuBsbQzvIIjsJotcoF3lxN00SIzKGkJXH+7SpBurr603XqaDVhzKZNvxl7BAVAXiAgvIaoV8iwf3i9fnUdfS/8B5q6RaM9KqgvJuWXYghPTpwbIW5NBZqMXxITHeKNt6+p49lGyYAmvPCzjQ+WpDOsRbNw6STnQQ1XajFo+K5IbQ7ppzd9cuCu2mSFFIfDTMox/vB9cRxrofWh6h79+5c6jXqQyvaziKjPyJ8gtTqjG2pbppqHtMx4Gd/XdL6rYxdshdT7u3DtS28/dO0xoU/Vo8RBV7zwipkmWMiCNaF2pwK8wBev92imblsxfeBzPXLhLtpkhCtFAOKjwZPm78Vx/u0PkTfffcdrrzySlN1kvahnaYNLRn15BVVZ3GVeuycmlPfo0XHhMaf/XVJ6/NVXFXLffyK8E8LHhdWnf4ZwWNeWI3dc0wU/rrQmlPeoF+wzmUrvw9krF823JADkCvkgHKVWOuvXCdcxw2G9np0UVER2rVj9ydyQh8ayegPL3lp6mx8p6oMzVq2UZWBpTzefS/71XuemJ0XLvxQdEE7B2jHo91rmd31k2D197d7e06Heq8PO7ML8WXGT9iZXYj64D8dBJTnlPQINNCG8n///fdN1eeEPiT1BwLMyes/5hal5lBtcACg7L8pmn5eil5plkrStpDOPb2xpdQ3ckAXCgnlxey84IGaXnivk05A0QXNPAbo57Lda5nd9cuIa57TgLcNl7S8UI0hROPfYDYauBP6kKVu2neM/KW0iG0Z3miui71upK4PCokPkBp6baGde0YyTN+YheQ9Jx3vf2FFeiE9VH3hWjX4whVX/mLePR98XRRdsK4hvNcoUWuZ3fXLiHvSpALvvGQ05YVyDKERveOx/eVhWDp6EP41si+Wjh6E7S8Pa7K4JiYmmqrHCX3IUjfNO0bxk/SY/ad+jTr63blUVR3546/Xsb+5hKgOrbawzj1FhueGX6b6eSjkFDQ7L8ygpZfiytqADRMQGn1thKIL1jWE9xolai2zu34ZcTdNQRjFffEBeGXlAZyr83IpD2iII6McaSvxTfRMHvEOjiGkXI++q++FGHxJe1U7+NNPP22qDqM+9IBvH7KYJ0j0rEArL2veL6WeQZe0b9TRP98YT+SroOj1+d/9irnvaeeKGkt3n1D9Pen7MmN2XgBsY5V2PIVCXxuh6IJmHgP0c9nqtUy2+mXE3TQFQWKjLqqoxaDJm4j+kqK1Cfv7aGhx51Xxjndq1WPRokWm3qf1oTLD+oO5GJq0GaPmp+GZ5AyMmp+GoUmbDceGkS+OGXlp/SwUfCr10OrCTN+b9Z+YtTkLeaWh639hdl6wjlWW8eT0vjZC0QXpPPb/nGYuW7mWyVi/jLibpiBIbbNFFeeIjqBZbMIjesfj8esTNJ+dty0npI++hw8fbroMK1JMmDXjasloVl6e/gUsumDtezP+E+sP5mL6xizm952AmXlhZqya6S+n9rUR/rrQGu/B+wjWtcfudDl21y8briN4ELS2WaP0ECw24XqvD6v36X/hikpLIQM//PADevbUP20jQWSMGNb0HUYy8ogJxOpfoCYzqy5Y+p7Vf0LRBSlO9b9g1YXZsWqmv5za10YE60IrLQ+viOB2x7uyu36ZcDdNftR7ffB6fQG3h/TQS9GgwJLnzExqCLPIECo/KiqKW1miUkzw1BFvGY3GnBZqMpvRBW27WHMC0piPnOx/waoLs2OVZTw5NX8j6fqnpgu18W40/mnWW7vT5dhdvyy4myY/fjf9W5ypaUb9nt4RNEueM7uuecoSKt8JAfxkvoqrN+ZI8JfZSl2w5gSk6WMn+1+w6sLsWKUdT071daFZ/3jMC1nWWxc6XJ8mP/JLa5jeMzqCprUJ23HNk3eYBTPs37/fsrpYkf0qLom/lBb+MlutCxb/CdI+fm74ZY7+MmLVBY+xSjOeYluFO87XhXb9MzsvZFpvXehwT5pMQHMETWMTZjVTsMLLP4cXt9xyi/A6zGK1jlhQxlxadiHGLtlLZHIO8wD9u7Vt/NkOXdD6T5CYj+KiI/DksEvFCW0BrLrgNVZH9I7HsMs7YdDkTSiqOKf5XETzMNzUM45JVjtgWf/MzAvZ1lsXOtyTJkZYr48axShSnrPymqdsofIXLlxoST0sKHFu1u4/jZEDugLQTt8hg3miWZgHQ3p0wJR7+xA97/UB6cfPNv5sly5I54ryrN588QB4485eumU4IRUIqy54rifpx8/qbpgAIK+0xhGhBhSdT99wmHr9MzMvZFpvnTDuZcM9aSIk2DlcL7UED2jSjphFNv8cu9NFaKGVRuJcnReV5+oDnlXSS8jCiN7xeGxIdyxIPWb4rL+eZdVFMGbmi1N8S8zogtd6IttawQpLiiFe80KWPnTKuJcNd9NEyOw/9UNYmMfSW2VWXfOUzT8nMTFRui9rxQch+O+w4BQSCiWVtRizeK9Uvh3De8YRbZr89SyjLrRgmS9aelV8S2TSn1ld8FhPZFsrWNDSuRG85oUMfeikcS8b7qbJAMXeP0jFRGDF9XwrrnnK5p8zbtw45ndF6IQlLYmMvgksejajC1bM6JBmvljhW8JzPPrrgrVcs+uJbGsFLSxzmfe8sLsPZfCpCh6/PGNaicbdNPlBY+8PpaNN1qveovjXv/6Fl156ifo9UToxk5ZEVDwtFlj0zKoLVqycV6LjofFui6ILO9ce2dYKWmjnsoh5YXcf2hkHEFCfF2GeBn9KBZm/S11HcD86RkcE/Kx1zTkUr4vKFCr/3nvvpX5HpE7M+hbI5N9Bq2cWXbBi9bwS6Vsioi333nuvFGuPTGsFLbS6FDUv7OxDO32qtMZvsP+5zN+l7kmTH988dwN+KKzTPSKU4WhTFLKEyt+9ezcuueQS4udF68Ssb4Fs/h00eqbVBSt2zCtRviWi2pKWtguzTnSSYu2RZa2ghVSXT954KYZc2kHovLCrD+3yqaIxjcr8XepumvwgsfdbdbRpVzoTGULlx8c3/StLrz9YdULax6xpSWT27yDVs5ouRGCHyUCEb0m914dFqTlC2lKMKFvNKsHIsFaQosz1vJIqtItqgbMV53R1/txNl+mut7zmhR19aJdPFa1pVDb3BgV300SJFUeboeQvxUKzZoGpbIz6g0UnNH3MkpbECf4dJATrQhR2mAx4+5bQXmOnbUtJTT1IlmyZzMEyQKoXGp1bNS9EYJdPFeu4lG08uz5NlIg+2pTBZ8Fujh8/3vj/JP1BqxOWPtbyQYiPicRfr09AvAP9O0jw14VI7DIZ8PIt0RpTetC2peZsvpByQxkavdDo3Kp5IQo7fKpYx6Vs49k9aaJE5NFmKPtL0TB06FAA5P3x7bgbiXVipo/1fBBeGnGF4/w7SFB0IRo7r2Gb9S2hvcbO2pYH7xmBb5Yddex1f6sh0Uu7qHBMvL0X4qLpdG7VvBCJ1T5VtG4Oso5n96SJEpEpTmQKr28nycnJAMj7I/34WSKdAKDyN1FDK70HTdoPJ6HogidqqRusTh0UjBn90fhqmGnLZ8uX2dpHToNEL0UVtYiLjqTWuYh5YQdWrlt6czwYmvFsdeoXd9PEgKijTVnC69vNiy++CICuP4x0AgBDkzZjUsoh4jJdftEFL9YfzMXQpM0YNT8NzyRnYNT8NAxN2oz1B3Mde5WdZqyYacuLL77o2D6yA5HrKe95cb6gNX6D90Wk43n9wVz8bvq3vMXUxTXPMSLiaFOG8PoyMGXKFLz66qvU/aGlkw2ZedRpE0K9j0lRdMED0tQNTrvKTjpWJt52BR4eksDcFkUXTuwjOxC5nvKcF+cbauOXJSK4sp7U19RYJHkDHp/Pd96nNS4tLUVMTAxKSkoQHR1tmxz1Xh+GJm029FnY/vKw82KB5NEfShk05pNQ6GO7QlboyaOnB5p+l7Vtds5b2frELvz7oUNUBF74bB/yS931NNTwX0+8NZU4OeM+y76/3ZMmibA7vL4sKMkwefSHVf4mMsEzZAWvhL284jDJGI7DqnmrpQsZ+8QO1PohtlV44wUPnnpxUiLrUIQ1tRUPXJ8myXB9FoCHH3648f/N9odV/iaywDtkhb8uzMDDv0TmcBxWzFs1XcjcJ1ai1Q8llbUAgJhW4QG/N6sXXvPChQ07fU7dkyYJOd99FjZs2IBHHnmk8Wcz/WGVv4kMiAhZEawLVsz6lzghHIfoeRusCyf0iRWQ9ENk8zB8+pdrUVBew0UvvOaFCxt2+py6mybJCPZNuP3KztwXPNH+D2bLv+KKK7jJSRr/x+kbJkBMKhJFF2YxG4fJ7szspIhMixGsC6f0iWhI+iGvtAZhHg/u6nshlzp5zQsXNvzXE6txN00SYYVvgug6eJRfVlbGTc7zyU9MxBXrsrIyVnECMKsHNxxHU124fdKAHf3Aa164sBG8nliJ69MkCVb4Joiug1f5W/fncJXzfPETE3HFuri4mFGappjRgxuOo6ku3D5pwI5+4DkvXNhQ1pOO0RGW1uueNEmAFb4JouvgVX6914eUU+HwqcwDM3KeD35iIlKR9OnTh5t8ALse7EyzIgvBunD7pAE7+oH3vHBhY0TveFx70Q1o96Z1dbonTRJgRfoU0XXQlK+WRsO/nBP7dwiRM1RTnSiISEXy1VdfUcmgp1t/OWn1wLttJHLagZ5cwbqwO/UMLaL6nKQfJt7WkBuSR931Xh/mfPK5dGPnfMXq8e2eNEmAFTZ50XWQvrchMw/PL8/Q9FX6uawara+6WZicoY5yZB3sDxbH6Lc2evRo4mdF+8vxapuscY2M5FLTBW99i8LOsXHnVfGYlHKIS91KO36quhxfJmdwb4eL/LgRwWF/RPCd2YUYNT/N8Lmlowcx34IRXQdp+WoofyfMeaAfYlq2wC2PPIvY60bqvmOmL84HeN2QJA3ip5UixV+3vL5UzLTNSjlpIJHrP6sWaOpC5ojgdo6NsxXnMHYJn7r921G8I7lxjbJ77JzvWP397W6awK/TWRcus2kYSOoVlepBqTuvpAqTUg7hbMU5zRxvYR5A6yRbqf/bcTfihne2hGwqGZm/3FjhmSJFJLLKKatcPLCzbbxT94SqjmiQcf2yetPkmuc4Yeb42cx1bNJ6RVy9V6tbDaU+PdO/4quUfvwsLjv9DfKirg+5EAGymoX0IDlpckq8IFnlJJVrzIt/x7x337ZMLh7Y2ec86w4uy/+kibYsp+LE9UsEriM4B3hctWe5jk1bL8+r91p1qxEXE4nHhnQnKvfnsmpMe31cyIUIcGq6iyeeeMLwGafEC5JVTtL6fn3HKMGS8MfOPudZd/AzbfreYqpOp+HU9UsE7kmTSXhe5ae5js1aL4+r93p1K7SLCsfE23shLrqh/N05RViQesyw7I5tIvH555/hiSeeCJkQAU5Od/H5558bbpycEi9IVjlJ6zuw/WvgRmdddbezz3nWHfxM5eFUtLn6VuY6nYST1y8RuJsmk/A+fiZNw2CmXrOpHkgyTBdV1CIuOrKxHppYKi0HDeIipyyQ6mpRag46tImQaoM46H+60EP2eEH+fnftolpo+t3ZJSdp//3x5t9aKhcPaMYGb38ZnuMyuKyIzpczlyUCkb5Gspq17cLdNJnEruPnjZl5ttRLU6b/czQ+VadOnULfvn15iWs7pP01KeVQ4//L4itAoguZU9XQ+N0B9shJ2n+5x9KBfldbKptZSNu2ITOPu78Mz3EZXFZdWQFadLqYqSzeiPY1ktWsbReuT5NJSI9jjxVUcqtz/cFcIlMXINexN6lPVahd6GTRgSy+AqS6kDFVDa3fnZ3+ciT959R5YdQ2AML8ZXiOy8CyftGFjGOc5/ohq1nbLtyTJpMMTGiHuOgI5JXW6D6XvOcEnhx2qem/RBT7MglhHqB/t7am6lPDzLE3iU9Vly5duMtsJ0b9pYYsvgI0upApVQ2L353d5lCj/nPyvNBqGwAMTdos1F+G57hUylqc0gyxXXpIO8Z5rh+ym9+txj1pYkRJCbB2/2kMvfQCw+fNpkFRIPEnUvD6gPTjZ03XGYzZ9A1aaTSUPp27/KuQSk+g11968EifY5adO3dSPS9Lqhpavzu7N0wKev1HowsZ08QEtw0AFqXmCE8hpVa3GX03C/Og8tQh6cc4z75zUroe0bgnTQyQ+kkEw8PmS1uGKDsz7/QN/n1aX9Ud6+enSePXwwOt/iLBTl+B++67z7a6zRCKfhikunBCPB3aNVQ2PckwL6wc405J12MF7qaJEq2UACTwsPnSliHSzszr2Du4T8v+uw6x141stMs7NTZTMMH9VVBWE+D8rYWdvgJz5swhSqMiG6Hoh0GiC631Saa5xLKGyqYnGeaF1WNcJvO7nbhpVEAeht0olL4WPEPsk8rglLD+53N6AlGpbVzOz751wlyiXUNlkFlWzscxrobVaVRcnyYCFP+A6RsOM22YAHqbr5ZPgmJfJinJCXZmNbt88Y7kxv8nscvL6L9BghN8BRITE22r2wxO6FtajHSRdrSQyMclLbuQs2Tkc9BIRn9k1pMM88JojPsAjBzQBWv3nza9Lir6Xbn3FBZ8dxQr/+ustZYn7kkT9HeqrP5LCiy+BCQ+CXpyyea/oMeXGT/hmeSMgN95ayoRFtEq4Hf/GtkXd/W9sMn7TvDfMELmNpSVlaFNmza2ymAGmfuWFj1drD+Yi/FfHEBxVa1hObEtwzHl3j7c2k/axzQyapUhCzLNC7X+j20VDgAorvylr1n7U/bvGqtPmtxNE7Q73Yz/EgA8N7wHnhzWgzoJrlqdSgn+Pgn+kY6LKs6hXesIaa5Pk7IzuxCj5qcF/K50z5eIHnBXwO+Wjh7UJNosTV/JjozZwwFgxowZePbZZ+0WwxSy9i0tWrpgWac84DM/SOcgrYwTb7sCDw9JkFZPss0L/zF+rKASMzb+yGVdJNEbr7HEitWbJtcRXAOSOC96eAAk7zmJJ4f14FKnWtwNXmlG7PxSUYsBEpnwS9RjrRggoZYPyY6UMSR6/93vfkf1vIzIkI6HR9/568K/XNZ1yuz8IJ2Dwy7vRCyjMt9l2TBp6U1NF3aijHHFz4nHukgztpy01prF3TRpQBMPSQ2WfDx25Pix23yhluqgtvAkWnToquvT4OZDMgep3g8dOoSePXvaPk6cDK++U3ThD+s6xWN+kM7BT3Yeo5JRFh8mPb1VHG6qCxnguS6Sjq3zba11HcE14BUXhKYcq2PLWBGCn4TgVAdhLVoC0E9PEIpxeKyCRu9t2rSRZpw4EZ59p+ZDY3Z8m3mf9N3jRWQppGJbhUtjUjfS2w+F52ySTB+e66IsMQFlwz1p0oBXbAuacqyMuyGbecs/Bsj2HV4MvW6QrgkjFOPwWAGt3lu3icYLEo0TJ8F7jsXExDT5ndnxbeZ90ne7tWtl/BCA2aP6YUiPDszy8IJEb0szCjHe65NuzPNcF2WKCSgT7kmTHyl+VzMVXxszU6J9VAuqfDxGdXrQcDzMI8ePVSH4aVDs8u1rzximJ7Cyr2iROQQCqd6Va+kp3+62dZzI3JdGsM4xrTZ///33TT7r360t0zrFY36QrJGxLcNxWac2iIs2nquDOJp2zIwbEr3lHcuyNb2RFjzXRaUsEmJbhsPr8wmfnzKsB9KfNP300094+eWX8dVXX6GyshKXXnopPvroI1xzzTUAGrKwv/7665g/fz6Ki4sxZMgQzJkzBz16kDtgK7z8xQGERbRqtFsH+9rQclffzlR/iaj59yjwjlkis3lrxIgRhs9Y2Vc0yO77Q6rPsUv2Ysq9fXBpvyHA5jxu5dIge18awTLH9Noc0f3qJoEh42MicedV8Zi3LYd4neI1P/TmoEJxVS3+vHA3YluFN57SiJ6rZscNid4iE/pLaY7iuS76l2U0roqranH/h7uEzk8tvb54o7WJrKU+aTp79iyGDBmC8PBwfPXVV8jMzMS0adPQtm3bxmemTp2K9957D3PnzsWuXbsQFRWFm2++GdXV7ANasVsDCPC1UWgXFU5Uzk0946jrDvbvUdDz72FBZvPWwoULiZ6zqq9IcYLvD6k+i6tqMWbxXny+9BOu5ZLihL40gnaO6bX5icV7MfaNd1U/m7ctB49fn9BkHsTHROKv1yc0OS3gOT+05mAwJf+LFxTTKnDt5D1XeYwbEr2VH9ggrTmK57qolEV64iRqfurp9fll+7jWZYTUcZrGjx+P1NRUfPfdd6qf+3w+dO7cGS+88AJefPFFAEBJSQk6deqERYsWYeTIkUT1KHEeujy7vDGoon8IegAB1077d2uLG97Zohm+HmhYsMyErxd9vTuUQvDLcBXeCSksAGO9++MB0Ck6AoAH+aXWjROn9KURNHMMAFOKJv9yvh13I9KPn20yD6yYH/VeH9KyCzF2yV7N4JXKeJp2X18UlNdwl4XXuAmVtZGn3v1jAhaU12DWlmyU6OiZZ/8Y6dVXU4kTM+5z06gAwOrVq3HNNdfgD3/4Azp27Iirr74a8+fPb/w8JycHeXl5GD58eOPvYmJicO2112Lnzp2a5dbU1KC0tDTgXzD+/gaKr83tV3YGAHx1MBcjB3QFoB6+3gP242bFZrt2/2kAwO1Xdm707+Fpz5U5zQRtioJg/fBIG0CLjD5iavjr3QgfgB/W/xujBmqPdYD/OLGjL83MLaOUR4Bx35Fc7/ZPL+SP0h/px89i8CXtcVffCwPWDCv+oGgW5kFYmEc32rcPQF5pDcI8ngAZecFr3JDo7bLT30i9YQJ+WRd59LVS1j39LkLvC2M1N0wAeT8Hz5tzdV7VeUSiVyuRetN09OjRRv+kr7/+GmPGjMHTTz+Nf//73wCAvLwGX4tOnToFvNepU6fGz9SYPHkyYmJiGv916dJgE60tzkPJrs/hq6ttXKBmvZuE06dP47k3p6HvU+/j7gmzMfof7yMpeSPO7U9B67Bzjc8W70hGh/BzuLXZPnT2nsHq1auRkpKCvXv34oMPPsCZM2caNwSJiYmorKzEtGnTcPjwYSxfvhyTP1yOq/42E3c8nYix8zbglkeexdCkzXjoqZeRsu8UEm75C/7wz9V47NV3cc/rC9Dnr+9i/DtzkJWVhXfeeQfV1dUB5efl5WH+/PnYs2cP1q9fj5UrV+LgwYOYOXMmSkpK8J9VCzDngX6oS/8c3upylKavwbkzx9Dip3Q80vUsLqg5jXnz5iE/Pz+g3KqqKkybNg1ZWVlYtmwZNm/ejNTUVHz88cc4ceIE3nrrLXi9XiQmJsLr9eKtt97CiRMn8PHHHyM1NRWbN2/GsmXLkJWVhWnTpqGqqiqg/Icffhjz5s1Deno61q1bh1WrVuHAgQOYNWsWiouLA54tKSnBzJkzMXflFvR88E3cPWE2npi+HLePfQMDX/0cDz31cuOz1dXVeOedd5CVlYXk5GRs3boV27dvxyeffILjx49j8uTJqK+vDyj/5MmTWLRoEXbs2IFNmzZh+fLlOHz4MKZNm4bKysrGZ2e9m4T6yhKUZXyFmrwjqMzeg8qsXTj3cw7K9q5FfVUZinck4+eyBh2VlpbivffeQ2ZmJlasWIGvv/4ae/bswYIFC3D69OkAGWpqajB16lRkZ2dj6dKl2Lp1K7777jssXrwYx44dw5QpU1BXVxfwzqlTp/DRRx8hLS0NGzZswGeffYYffvgB06dPx9DubXB9xTbEtgxH8Y7kBrn/uw7n8o+i8shuVB7ZhXP5R1H233VofeXvsHrRzF/GSU0lSvd8iXMFJxB+cjf+cnEp2lacwMKFC5vIXVtbi6SkJBw9ehSffvoptm3bhm3btuHTTz/F0aNHkZSUhNra2oB3Tp8+jSWfLELN6cOoytmLisOpOFdwAqV7voS3pjJgrh05mYs5c+YgIyMDa9aswdq1a5GRkYG5c+eioKAgoNzy8nJMnz4dP/zwAz777DNs2LABaWlp+Oijj/DJxnR0v/lRjJqfhoeeHo+RH6Qi4dbR+PfXu7F48WJ899132Lp1K5YuXYrs7GxMnToVNTU1SExMxPqDueh+86P4w7speHTCVPz+zY/R+7EkTJyxAJmZmfhx82f45909UJf+eaPc9VVlQObXeGlAJM4d3YOUlBTs3L0HZRlfob6yJKCN3tpqlO5egdrCU2geE4eqYxmoPnUI5Qc2oq70TMCzucUVmDx5Mo4fP45PPvkE//x4Ffr89V3c+VwS/vZ+Cm79yzhcl7g+YE4YrRH+fVhcXIxZs2bhwIEDWLVqFdatW4f09PTGNWLWu0l+ctc0yF30EyoObUPV8X2oPpWJ8oOb8P2P2abXiPz8/CZrxO69/0Vp+hp4q8sD+7CmonFtq/xxB9av/wp79uzB/PnzkZeXF1CuskZcElGOP7Y/gZaFP6D61PcoP7gZdSU/o/6/KzBr1FW4uEMr6jUiMTERZ86cwQcffIC9e/ciJSUFq1evxv79+zF79mwUFRUFPGvnGlFeXh7wbEFBAebOnYuMjAykpKwNWCPqq0qD+rthjUjP2I8vvvgC33zzDXbt2hWwRijzZuTc7Xj42Vfxf++swkW/fwn3vPYh/vrOYtzx7GRc8/JiPPrc33G6qCyg/LqyQpTv/+aXNSIrMKOEaKQ2z7Vo0QLXXHMNduzY0fi7p59+Gnv27MHOnTuxY8cODBkyBKdPn0Z8/C922vvuuw8ejwfLli1TLbempgY1NTWNP5eWlqJLly4B5jmFpaMHoaTqnGaqAB8a0qV07xBl6i85vXQEWgrilS5EBvOWP0lJSXj55ZeJn5chnYpaOhg11NLB2EXqkQLc/+Eu3WdK0j5HzKD/w9wH+jWGhBA9TqzsSzNjhyXlkVbfkbRZ0YUW/v1hx5ywew6IqF9Lb7RrVChhtp9JU+ooY/XZ4T0wfWOW5nPemkqctNA8J/Xtufj4+CZRV6+44gp88cUXAIC4uAZH6/z8/IBNU35+Pvr27atZbkREBCIiInTrVuyyiv+SXsyO5D0nTfsv6cUF0YJXnBwZ0kz484c//IH4WVniTamlgwmmXVQ48kqrsTO7kLsvh9rCbvRFPeji9oiPidQ9+m51+dCAPjQzTkg350Z9qZVah0Ue1rHDO+URyfhpdflQ1d8H94ddc0KE3mj+oBNRf7DeFJNSbK9fc5/HshKsAyXMBUs/06RmaYyJtfsE4qIjdf0qrUTqTdOQIUNw+PDhgN/9+OOP6NatGwAgISEBcXFx2LRpU+MmqbS0FLt27cKYMWOY6/X3N0g/flZ4ug4zKVtCMYT9zp07cfHFFxM9K0s6FZLr10UVtXhuWQYAflfnta7h3nlVPFbvy9W9dq3I/MT/boqqUfPTIYTHxpnuQ5pr4FaFkzAzdniPu2ZhHtx5VTw+2Jaj+UzNT4fQIjbOsD/smhO89UYbOkD0uPGXp/z7LWjd60ZHhcBgQW99UQtzYdTPtN91ih/cc8Mvw4yNP6rW5/o0+fHcc88hLS0Nb7/9No4cOYIlS5Zg3rx5GDt2LADA4/Hg2WefRWJiIlavXo0DBw7gwQcfROfOnXH33Xcz1+t/NdOKeEY84n3IGDOEFcXHjASZ4k2RXr8G+FzN1bqGm1tSjQ+25RBdux7ROx6PDemuWUfz6Asa/5+1D1mugVsRTsLM2OE97tYfzMU8nQ3TX69PwMv3DiHqDzvnBC+9sYYOEDVuguVR5oWTQmDQoqcDrTAXRv3MOua6d2ilqdd3/3gVU5msSH3SNGDAAKxcuRITJkzAm2++iYSEBMyYMQP3339/4zMvvfQSKioq8Pjjj6O4uBhDhw7F+vXrERlJH0Mj6d4+6B5/QcCRqxXxjHjE+5A1ZohoZIs35Z8OJq+kCpNSDqGoommeKrNmEpbs9lp1Du8ZhwWpxwzfZ+lDM6Yi/74U4UdlZuzwHHckuly9LxdvD26H5x+83rA/OrTWdz2gfY4Ws3oza17kPW5kcQGwEpI2r96XqxnmQgvWdbhjm0gMvqS9ql4rysuYymRF6k0TANx+++24/fbbNT/3eDx488038eabb5qu67YrOzdxJLPCv6J/t7ZoF9VC9cvVCF7+HUbwcBYnLePkyZPEZVrl/0JCcPs6Rkfq6tSMmYRndnu9PqwrPWOqD82aikT625kZOzzHXdrRQkNd5pZU49u9J3Hjb24w7g/SnbRAu4YZvfEwL/IcN2ry1JWeoZLHaZDqQAlzQQqJ754/wfNIBv9b6TdNdmOVnZxkwyTSv0MPHuksaMoYPHgwsWyypFNRa19sS7LI8SxH1jyz2+v1YeSFVwBg70OZzKfBmBk7vMbd+oO5GP/FASJ54y+7kui5gooa44cAbPohX4oEucHINmbU6on437wwes6piNIBie+ngt3xArWQ2qdJFqyyk+vxVwb7MQ94pCWgLeOzzz6jktHudCpa7dML9OcPy5E17+z2Wn0YdizNVB/KZj4NxszYMTvulHFDOk72bfua6DnSvlyYekxKXxzZxoxaPZU/bCd6zqmI1IHmWhO0L7IrHZYRUsdpsgoljYpRnAfeYelJ0yYoR5S09mOz8EhLwFJGbW0twsPJTmmC67I63hSNHoMh6T+jekmPuUnrDO7Dqy9qg8iIFlSy0chppg94YmbssLzLMv+3PP9rIl2Qli1L3wcj25hRk8dXXwdPs+a2yGMFVuhALZQBy/cb6fc3L9yTJgp4hqWn8UnRS5MgEh5pCVjKSEpKMpRNLXUFT/2QwupbxHr07J9mRyuVj5k6g/vwn+9MJZZNqzyttC0yHb+bGTss79KOm9fv6EmkC+WL6JbecYbPypLaJ5hmYR5MvK2nbkweK8eMWlqVkl2f2yIPz1RaeliRZit43rRoHmb5+s2C69NkE3b4sYiqT+85ljJeffVV3Wd5+FjxgrR9sS3DA8wwcQzyqvpN/S9rfHHlL2VrxWliqdNIF6TEtAoPkBFokH3y7/tId/xuBcTjplU4pvyvj0b0pp8XPGWxivUHczEpJVP1M5YxzAPFpKT0b+x1Iy2Xx+p1L7jNCnbpQBbcTZNN2OHHIqo+vedYykhMTNT8stYKwa/4R1ltAydt3+w/9UNYmIfZdKjV7pLKWs1UPi+NuMK0uVJPF2bkBoCzlWS+PKEI8bgZ1a/RWZtlXvCUxQqM2jHxtits+7L2D2Uw690kPPn8y5ZFBLdr3RMd9sOJuJsmTtD6NdBcvbTy2rw/PK5Vs5Tx6KOPNv6/f792iIrAG6utiZfCO+XHIBPHzSQxU9RS+fC4nuuvC1qM4g+FYnwbUmjGjYKWLlhidvnXYfW6ogXJeJmUcgg3944PGC9W+jIqc6rb359F587WXH23O06UDNf8ZcL1aeLA+oO5GJq0GaPmp+GZ5AyMmp+GoUmbdW+m6NmM1bDD74OHXZuljPXr1zf8N6hf71+wC3ml5nysSKDRpxW2fx6+ZawoumDBTrllx8y8CIbFr04mfzIFlvHCsvbywMy8oMWdR3LBvGnyer348ccfsX37dmzbti3g3/mEmSv5is04ppX+TbHHr0+w9Uja7HV+2jJ69epFFY4hGDM+GjKm/LAzbk2vXr2Y35Ut3o5ssMwLNVj6T8br3LTjhUc4FFbMzAta3HkkF0zmubS0NPzpT3/C8ePHERyxwOPxoL6+notwssPj2PSmnnF4Y3UmAG3/jtX7cvHSiCts+4uQh12bpoyis8V4c3M5c8BiVh8NWVN+2JkWo6SkhPld2eLtyAjNuNHSBWn/TbztCnRoEyGtXwrNeLHbZGVmXtDiziO5YNo0PfHEE7jmmmuQkpKC+Ph4eDxyTT6rMBvuv97rw6LUHF2TEwjKsMKer2fXJpWB1Db+3+xc5JZcYPhcMGZ9NHim/OAVg6SxYp7PUVBWxp7XSaYUNzJDOi+0dEHazw8PSZBuo+QPzXjhkWrFDGbmBS0DE9ohLjpS83vifJhHdsTg04Jp05SVlYXPP/8cl156KW95HIWZY1Pa68GkZVh99V6EDNFx3YCTlVTv8PDR4HUMrtYnYR7AP6QKTR+RpsUgfY6GK65omi6CFFlS3IQKWroIlX6maYfdJisz84KWDZl5qK5Tt944Sb+syPA95w+TT9O1116LI0eO8JbFcbAem7L465CWYYU9X7QMR/67g/odHj4aPI7BtfokOAYdTR/ZeTz/zTffmHrf7hQ3oYSeLkKln0nbYbfJyuy8IKUx1Y5GeI7YVuGO0i8tMnzPBcOURmXlypV49dVXMW7cOPTp06dJyosrryRLLCkLrGHYWULN06bdYCnDirD+ImUoLinFLe/v0e3XTtERmHZfXxSU13A7rjWbOoCHbkXIZYaysjK0adPGdDkyHa87FRJdhEo/G7XD7lQrvOaFHiTrSVx0BFLH/9aROjaC9Dtm3Zhr0K5trGVpVJjMc/feey+AwLghHo8HPp/vvHIEZzkWp7kezFqGYs9Pyy5kymJOsvDy9CkIrm/Dkvfx+j1/0e3XN+7shSGX8s3QbtbMQXv1m7SP7DS//Otf/+ISFdyOWC+hsoFQINFFqMTUCfYPTMsuxM6jBQAafj+gezuMHNAV0zf+2ORdvTnBa0wE64I1/6DeOyTrSV5pDdMaa3YuKOXllVShqOIc2rWOQFw03zlG+h2Tfuwsl/pIYdo05eTk8JbDsdCGmqexsZstY+ySvZhyL12aClL7sUj/n/iY6zAQsCWEv5nUAaz+EyTv2ZXSgFcaFauRzQ+CB07VhRnWH8zF+BUHAsxTs7YcgccDaNlItOYEzzHhrwuWckneEbvGss8FPX9cnnOMtP1nyq0NtcBkngs1eGRJJt3J78wuxKj5aYblTbztCs3bLqRlAA1/dZHavLVC9SsS+JdDKsPS0YM0/wrSTA2yIxmx143EnAf62RbCn+UvMxq9+KPXRzzkMoPZNCp2QDOOnYQTdWGG9Qdz8cTivVTvPDe8B54c1qPJnOA9JhRdsJRL+o7INZa13STpemi+c/Qgbf+HI3vhpqsTLDPPMQe3zM7OxlNPPYXhw4dj+PDhePrpp5Gdnc1TNkdBmulcuVar9TXnQcNuXe96cMMVVPKYPP9Yk2mYDdso7klwOaTt0LoGq1df66tvbawPgC2Zr1ky1xv1STBGfcRLLjOMGTNGaPm8oR3HTsJpujBDvdeHN1Z/T/WOBw3phNTK4j0mxowZw1QuzTsi11iWdtOk6+Exx0jb37drrKl6aGHaNH399dfo2bMndu/ejSuvvBJXXnkldu3ahV69emHDhg28ZQwpeKUmGTWwK1F9pCH2Se3H0zf8iJ3ZhY1y+sutYNb/p/KH7aZTA9R7fdiZXYgvM37CzuxC3Qms9yxNObSpcXwARg7oQtokW1i+fLndIlDBK+UEjd6twmm6MMPunCLkldKF0NDSrYg0JMuXL2cql2ad3Z1ThIm3iVljteTTg9Rnk1daF9LvyowTxabqoYXJp2n8+PF47rnnMGXKlCa/f/nll3HTTTdxES5U4eGf0r1DFFWdRvZhUvvxrC1HMGvLkUbbtQj/n4jOl1PL5Q+NDV/vWQDUvgBaug2O06QwfWMWkveclNbXZvDgwXaLQAUPPxBZ/aGcpgszmImvFPyuiJhOgwcPxnGGclnW2cevT8DqfbnCfCxFxbziESOL5Lty6fYfTNdDA9Om6dChQ6p/9Tz66KOYMWOGWZnOC8ym3aCNP2L0PG15SpyMOQ/0w/aXh1G3Q6++urIzaNHpYia5tGzu/vIqC43es1q+FGrlBKOm2/7d2mLO1mzV2z4kZdrFyZMn0bdvX7vFIMZs/B6a8WM1TtOFGczEVwp+V0RMp5MnT6JjT7JTYv9yWdbZedtyMPtPV6NtVAS3NVbkc6zPa2H0XXlBazGxuLRg2jRdcMEFyMjIQI8ePQJ+n5GRgY4dO3IRzOmQOOyauR6s2HuNjkuVWBb9u7XFzuxCTXmMUhgEE5zfibYd+vV5iFIDqKUqIclHNezyTtiTU4TxXxzQtferQZrXKli39V4fkvecMFWmaNTGrNkUSVY7rptJ3WJ3PjMjzqd0VYrfJo2JTku3ItL5eDweojUzLjoioFzWdXZSyiHqmFO82037ncMzrYved2X/7m251UMC06Zp9OjRePzxx3H06FFcd911AIDU1FQkJSXh+eef5yqgE7HieN8/do/R5Lvzqnjc8M4WXXn0YgFpYSa/k159zds0xF/Ss9er9XG7qHAUVWgnPlbkHTR5E4oqzlHJq1YOTbvtzpVlhNaYfaAHexJgO8xcZmJaya6jiy66yPI67aJZmAdv3NmL+Pacnm5FxDm76KKLiNbM6jovNmTm2bLO8m43zXeOlWldrP4DhskRfOLEiXjttdcwc+ZM3HDDDbjhhhswa9YsvPHGG+fVlVg1rAz7rth742PUjycVe/i8bTlE8milMDCC1XatVV/k2WxdM4hWH+ttmAKfY98w+UPTbrtzZemhN2Zfm7+Kaczamf6ANaWIzDoCgLQ0+nAWTmZE73jMfaAfYluFN/ks+NDNSLe808woulDKjVGREQBKKmttXWd5t5vkO0dGNwOeUMdpqqurw5IlS3DzzTejU6dOjdmeRYeUFwmPOE2AfelNtKKz9u/WtskJE4k8SnmpR85g1hbjMBI0cYb05FdMOBe38aJTxws0n6VJVSISmnbziLkiAqP+9FaW4ML4TlRjVoY0P4ocNKZBWXWkUFBQgA4d+EbBdwJaEcHTj5+lNvvyMhf766Le68OQKZuRVyrvOuvEiOCk8Pr+JoXaPNe8eXM88cQTOHToEABnb5Z4Y9fxvpa9d2d2IZM8SnkDE9rhi70/cfUFIJFfL4gfbaoSEbC0W4RfBQ+M+rM04yuEtRopxBS5KDUHHdpEcPV1MvPlIKuOFObOnYsJr/xdmtQwJH3N48u6WZgHQ3p0aJISimUN5ZVmZu7cuY1rVEN4BLnXWd7pdVjLC4XURkw+TQMHDsR///tfdOvWjbc8jka2432z8tiV80zPxGtF3/m3lVe77cwfp4dRf8ZeN5LoOZoyFSalHGr8fx6+TmZ9qGTVkcI1dz/W5ATPrlAIJH0ta+gGHvivUU5dZ60mVMYDk0/T3/72N7zwwguYNWsWdu7cif379wf8O18RdXWTFR7y8LaJk5CYmKj5GWmbWkcE/j3QLkrd50CNuJhIzH2gH+ZybrcdfWmEUX8W70gmeo6mTDXM+jrx8qGSUUdAQ/tG/e0lW3zE1GQx6ms7fdqswH+Ncuo6ayWhNB6Ycs+FhTXda3k8Hvh8Png8HtTX13MRzip4+zQZHbOK9uUQIY+Vx6rl5eVo3bq1phxDpmwyvIocFx2Baff1RUF5TWM4ghve2aJ71Te2ZThm398Pgy7+JT2JiHbLdERtNEZ856rQ+YK2TD5NpNeqFVjnhwgfKhl19NOZswhr0bLJ51auKyR93Sk6AoCH2sfHSfivUU5dZ61CtI+j1T5NTCdNOTk5Tf4dPXq08b/nKzxSpFgpj5LGY+3+00jNKkDqkQLNtBFW5jybP3++5mekKWTySmsQ5vE0ytuieZhuX3gATLm3D4Zc2iGgbSLabXX+OCNZ9PqlbN/XzKZItTL1YE2/ICJNhkw6Sjva4JtYvu9r1c95pa0wot7rw6LUpjdxg2XJK60h9vGxEzOpcvzXKJ7rvkzjjhci5qedMPk0ub5M2vBIkWKFPMoV2ekbs1Tfs9PWfMstt+h+TppCJtiHQDbdyIJev7zyzJ9NmSKDyyRBVLoGu0IFmGH9wVyM/+IAAKDlxf11nxXZPjV/FLPYqQ+z/jXBa5S7tmgTavOTadP08ccf637+4IMPMgkTKphNkSJanmMFlZix8Udd04mdaSMOHDiAyy+/XPNzMz4EsulGFrT6ZcUXn3Mrs6CsJsD5WwtR6Rqs8iXkRXBKl3NnjiO8vXbqDlHt00otYxa79MEjVY7aGuWuLeqE2vxk2jQ988wzAT/X1taisrISLVq0QKtWrc77TRNAdyXTCju2Io9iXzZaAEWnjdBrc2xsrO67rFfDg+u8/crO592CptfvamPWSBdG+JdZ7/Xhw+053K9Wyx4qgAW1lC5hEeonrMHt47me6KWW0ZJF8WnKL5VHH/5xhSalHDKdKkdrXtBexQ9FH6ZgeM/P4D67vD3TNoYZptrOnj3b5HdZWVkYM2YMxo0bZ1qo8wmrr2HSxDkSFVfKqM1Gsb9YruiGynVXM7D0Ac84bKKuVofilW21earmBK6gtI/3OKdZL5TefePOXgAgjT5oTIukax6PeXG+rEk856dan10QYe3FMyZHcDV69OiBKVOmNDmFctHGjmuYLHZjnrZmkjYrgVP1oLmiG0rXXVlh7QMSXdAg6mp1qF3ZVptztYUnm/wutlV4Y/tEjHOaue/f17LoQ6tPjDBqt9l5cb6tSTzGg1af/UyR1JkHXM+1mjdvjtOnT/MsMmSxK6M6i92Yl62ZtM3J9w8nKo/Eh0D2zPVWYKYPbrrpJu7yiPL9CCWfErU5F9n96ia/mz2qH4b06CBsnJPO/Ym3XYGHhyQElG23PmhNi/4YtdvMvDhf1yQz48Goz6yEadO0evXqgJ99Ph9yc3Mxa9YsDBkyhItgoY5dKVeM7MvBtIlshtziKuzMLjS94JG2+a0ZczDv3beJyjTyIZA5c71V/gxm+mDRokVCknCbTeug1Xe800WYgXdKl/KDGxsjtCt+IIP+11ZR45zUHyV4w6RgZ7oNlpRLpP5hZuaFzGuSaFjHgwzpsxSYNk133313wM8ejwcXXHABhg0bhmnTpvGQK+Sx6xqmv32ZhLLqejz/2T4A5u3tpG257cGxTOWbqdPq665W+jOY6QMRGyazOMEXRERKF/8NExDoByJqnNvhL8ZLv7RtDW6Pnhxm5oWsa5LMyNQXTD5NXq834F99fT3y8vKwZMkSxMfLsWjJjp3XMEf0jsfj1ydQv5dr0t5O2paUj2czlW+mTiuvu1rtz2CmD/RS2tiBE3xBRKV0UVLaqPmBiBznVvon8dQvbVv922Mkx0NPvUxVNotcTrmCbwUy9YUpn6Zz584hJycHl1xyCZo3t/ban9Ox85p0vdeH1fvYv1xY7e2kbZ75wj+YZWOt06rrz3b4M5jpg/Hjx3ORgQdO8AXhLaO/H0ju//VGfNvWqqYq0ePcCv8k3n1H4orQLiocE2/vhbjoX9pDIsfhTr9FvdfH1H7Z1iQnQOtWIhKmk6bKyko8+uijaNWqFXr16oUTJ04AAJ566ilMmTKFq4Chip0pV8zYh82EvCdt8/R3+Zl4aVLJ+KdSMJNiQQ87UgqYGWv//Oc/uclhFiekYxCZ0uXHjUsb/UGCx6YV64nZFB9Gc4p33xn1iQfA2/f0wT1XB7aHRI7DG5dgUWqOZlv02ipbui0SRK2HpJD0mVUwHQ9NmDAB+/fvx9atWzFixIjG3w8fPhxvvPGGVH+dyoxdofd52IdZyyBp8+WtR5qWj6ROtVQy8TGRuPOqeKzelyvEZ8YufwbWsTZyJF9dmMEJviAiZRw5cqShv4+sqTxI/JRE9B1Ln5CUH3XF9QHR7f3bQtJWmXUVjCw+hIpbyfzvcuDz27N5LN41MW2aVq1ahWXLlmHQoEHw+Encq1cvZGdncxPufMCOa7k87MNmyjBq8/bt29G9e3fTMurVqZVKJrekGh9sy2nyPq+0Mnb7stGONRG6YMUJviAiZXx/6Vp8VpJgmP5DtrALpGlLRPUdbZ+QlF99KhOtYzo1/qy05fHrEzBvWw5RihYZdRUMj5QzPGVR61uLD73YNk1nzpxBx44dm/y+oqIiYBPlQnZ1tlmYBwMT2jU+tzuniGjysF7LHZjQDnHRkbqZyLXgZW/Xu3pKmhCatv20qWT84eUzw8ufwapwBTIl53aCL4goGeu9PqTk1MGn8pra2JTlqjqNn5KZvjOaDzR9QuI/0zz6giZtAdBwCqLyvNb6IZOugpHJh9BMzC3eMG2arrnmGqSkpOCpp54CgMaN0ocffojBgwfzk87hkB5rshx/mjky3ZCZh+o69tDzou3t9fXGsplpP6tPF4/4KTyucLO2neU9El1YhRPSpSgyPqER0sMHNhl35xShsLwKkRp7LVlj+9DGJGLRL2/zkd44+0Vwr+q7eqcesupIC5niSckUp4nJEfztt9/GK6+8gjFjxqCurg7/+te/8Lvf/Q4fffQR3nrrLd4yOhLSq7MsV2zNXMtV3i2urFX9PKpFM8T+z9cnmHiLUiDk5urf7DN7Ldmsz4vZ981c4WZtO+t7RrqwGlnSc1jNz2XVqC9vmvNT7TmZoPVTotWvqBAUWnIokOhCC9l0pIVMPoQy9RnTSdPQoUORkZGBKVOmoE+fPvjmm2/Qr18/7Ny5E3369OEto+MgPdYcdnkn6uNPM0emJEecbSKbY9tLw5B+/CzySqpQVHEO7VpHBFzJFc3AgQM1P+NxZNwhKsKUfDx8Zlj8GVjbbqbP9HRhFzL7gih9rYWZdCYt4i8jek4mWPyUSPUr2nwULEdBWU2j8zeJLrSQTUdayORDKFOfMQdXuuSSSzB//nyesoQMpMean+w8Rn38aebIlOSIM6+0BunHz9p6fPzFF1/gpZdeUv2My5Ex43crb58ZWn8G1raTvrcoNadJOgw9XRgh0u+Khy+IWfnU3heZzqT5id3wtL1LWn8uNVj9lEj0a4X5yF+Oeq8PH27PQV5JNSp/TEXMtf/X5PkwD+DzqZv0ZNWRFlb5EJLMQ5niNFFtmsLCwgwdvT0eD+rq6kwJ5XRIjxKPF1VSl2fmyFSm41Y9nnnmGc3PeLShoJw+K7YMPjOsbSd9b1LKIXy4PSfAF0RPF3rIck1ZC7Pyab1/a+84ovpZ0pnMfOsVPLP8e2n9udQQ5eMFWL+e+fs6xfS/K+AzRfrRv264PeckHWlhhQ8h6TwkkcUqqHyaVq5ciRUrVqj+GzduHCIiItzI4CA/SuzWrhV1eWaOTGU6btXjnXfe0fyMRxtY2ieDzwxr22naG+wLoqcLLWRPdWJWPr33F6QeI5KBZQzuX7f4vPTn0sKO9Uzxdarf92XA7xUdTLi1Z0jpSKQPIe081JKlY7Q5dwtaPD6fz9Rp1+HDhzF+/HisWbMG999/P958802primTUFpaipiYGJSUlCA6Otp0ecqVdqNjzW/H3Ygb3tli+Nz2l4cF+DSRlO3/Dq1cau/KAo82kJTRKToC0+7ri4LyGml8ZljbbvQeaTk0MmqZTeweY2blM3ofIDPRmGm/VeEmeCByPNi5nhnpwEk6IoF3e8yMi2BZLm/fHO3axnL7/jaC6fYcAJw+fRqjR49Gnz59UFdXh4yMDPz73/923IZJDbMh4/VCvgMNi+mtveOQfvwsJt5GF07fTAh+p4Tv10sSy6MNJGW8cWcvDLm0A3PKCDVEjiu1tiv1rd1/GiMHdFV9Tw1/XxDahL1WpDox049m5SPxC/T6fnFE9sfsHFN0YTadiZXQ+NMF69NIz3auZ5PffktXB07SEQlKe26/sjMANEk7RYuZeWh331Lb0kpKSvD2229j5syZ6Nu3LzZt2oRf//rXImSzBV6+GFph8sM8DYvqgtRjWJB6DPExkXj8+oQmaTv0wumbCcHvhPD9jz76qO7nPNqgF5J/9K8TuPeD6HEV3Ha1+pRQElrhJoL5uazaUBdq7/B8Lhiz/WhWPtL3Hx3SHV8dzOM6x2h1IQM0/nQKNKmM7FrPnKgLs/D0U3SKf60aVOa5qVOnIikpCXFxcXj77bdx1113Gb/kABTz3Oc7D+PFVVlNjnqVfSyLDVc5StyQmYeFKv4OStmz/3Q12kZFUB1/mjkylfn4eMGCBXjssccMnzPTBq30AECDTnj6H2jVxWNcqbVdrz4fgP/rdyE+3/uTYR1LRw9C5tZVRLpQ2JldiFHz04jKpr3RxKMfzcpH875/lH8ec4x0XsgEaX+RoKdnq9czJ+rCDLzXMJ7rBG/3GiOoTprGjx+Pli1b4tJLL8W///1v/Pvf/1Z9bsWKFVyEs5opX/0AH5o1+b2ZmB9KipTnl2eofq6UPSnlELXt3cy1a5nD91955ZXE6WdY2kASr4pXegBRsWS02k5S3/YjBYiLjkR+qfFV4uZFVxLLBIhNI2LUrjdWf482keG6fmhm5aN5n/ccu/LKproQtVngVS7Pq+J688Xq9UxNFwqiN3DB5ffv1hbpx88axrQy8wf2G6v5rmFOSImkBdWm6cEHHwzp3HL5pTUIi1C/0WYm5odM4eidwDd7j+DpjaXCrqtbqQ+rdU9SX15pDZ4bfhlmbPzR8CpxURGd75Goa8qk7br/w12Nv2O9uqwnn52pXIJ1ISqsA89yiVKSUCDLWqk1L0SH2lArX3H50KrPrEyzNmfp5ill0YkTUiJpQeUIvmjRInz00UeG/0IZFhurk+23VrP+YC7+tf6g0OvqVurDat2TltO9Qyuiq8QVFRXUMoi4pszSP7RXl0nlsyuVi78uRIV1EFGuUUoSFuxeK9XmhehQG1rlB/ti+9fHI7zG9I1ZRPLR6sSpKZHcoEqUsMT8cEp8JLtRTDDN21/U5DOeWbU7tCaL60H6nB5W656mvsGXtDdMV3H55ZczycE71QlL/+iNGbPy2ZHKRdGFKJOvyLQkeilJWLB7rQyeF6JTupC4FATX98bq7wF4mGUySgkUDItOZE6JpIW7afKjU3QECmr4h8B3sv3WShQTTPWxDLTo0LXJ53rpPqggtRFwiNdvte5p6zPyBdm4cSN69uzJJAtPPxNW3xj/MdOhTUTAomxWPqv9aBRdiDL5ijYla6UkodGniLWSxd8neF6w9B1NvSShLoLryyvVz3xgpE+aOuNN6IR0HslyecndNPkx/pbL8eKqLO42Vifbb61EOd5t3We47nNq6T5oKKggS6NC+pweVuued30PP/wwF7nMYtY3JvhKuyzhNWhQdCHK5GulKZlFnyLmC6u/T/C8oO072npFmiPNhtcAxH9/6fXXdV2jhNWrBnNwy1Dkpp5xwmysTrXfWolyvFuavtrwWTN+AlabzKzWPc/63nvvPa6ymYGXb4ws6VxoUXQhavzKMi/iYyLx1+sTEC94vpjx9wmeFzR9x1KvSHOkVtmkdT43/DKh319G/bUhM09Y3WqYTqMSCgTHeRB5DCjLEaOMWJXuw670C1brPlTHmn+7OkRF4IXP9mmGT9BClI6tQNT4lW1eiF6HeaZ3oU2dRVsv7dpIglEbSeqMi45A6vjfCptDJHrqEFGP/7x5l/xpVEIZkWHa7Q4BLzPKkX3xjmTqdB+kKAvxLb3jhKS60MMq3funTwGA26/szFwfbRoV//pZ08UY4d+PQ3p0wBt3aqcs0sJo7IhuAwv+aVRY0ofImpZEa16InC+kPkgvLs9A6pGCJn0VPC9I+y79+Fmm9CFGqblY8IEsvIZancrPowZ2NZ1SRW9ckugp38B3izeOOmmaMmUKJkyYgGeeeQYzZswAAFRXV+OFF15AcnIyampqcPPNN+P9999Hp06diMu1OqKoiz6fpWbi3W25xE6I/xrZF3f1vdDwOZYYJ06Dd5yYoqIitGtH7uApOk4NTb0kqI0du9pgRLAuaOQU9axT+TLjJzyTnEH8fGyrcEz5fZ/G9mvNC6O+I61Xa00jWcNiW4ajuMo4VdKjQ7rjtTt6GT5HmpKJZYzw6C9vTSVOzrjPsu9vx2ya9uzZg/vuuw/R0dG48cYbGzdNY8aMQUpKChYtWoSYmBg8+eSTCAsLQ2pqKnHZ7qZJLmbPno0nxvwNi1JziK4lk4Ta10ubAgCPDemO4T3jHG3CEpGuZfbs2Rg7dqxt9dPgb84hvdIePHbsboMearogMWGxtClUTbsKrOld5v6vr/TmhV7f8UgfYhQR3OvzBQR5ZalDr85jBZWYsfFH03OEZFzGtGxh2F9Wb5ocYZ4rLy/H/fffj/nz56Nt27aNvy8pKcGCBQvw7rvvYtiwYejfvz8++ugj7NixA2lpfPIduVjPr3/9azQL8+DhIQ3OoFpLtQdkV12NYpx4AKw7mOfoLwajODFAQ0wW2iN00mTcouqnwd+cwzJ2ZGiDHmq6MDJhsbYp1N0IlBAWtK1S+kpvXuj1nVG9JGtacPktmocF/Dzo4vZc1k21Om+/sjOS95wwPUdIx2X/bm0N29Ip2nw8PRocsWkaO3YsbrvtNgwfHngVPT09HbW1tQG/v/zyy9G1a1fs3LlTs7yamhqUlpYG/JMZf5tvalYBUo8UEPtayOibYcSxY8cA8POxoImh4lREtVHRhV31s8IydmRpg9acJdWFP7K0STZYfYRyS6qRll3IpAujenn5jYmsg9d4Ii0n/fhZw7aMv4UtAC8r0m+akpOTsXfvXkyePLnJZ3l5eWjRogViY2MDft+pUyfk5WlfQ5w8eTJiYmIa/3Xp0gUAcPToUUydOhU1NTWNjn6JiYk4ffo0FixYgD179uDrr7/GihUrkJmZiffeew+lpaUBzxYVFWH27NnYv38/Vq9ejZSUFOzduxcffPABzpw5E/BsZWUlpk2bhsOHD2P58uXYtGkTduzYgUWLFuHkyZNITEzE+oO56H7zoxj5QSoefuYV/PHdNbjr2cn46z8/xT0T5+HyP03EgpRUvPPOO6iurg4of8nWfejxfy/g929+jMffXoC7xr2Lfs8twJgJiSgpKQl4tri4GLNmzcKBAwewatUqrFu3Dunp6Zg3bx7y8/MDnq2qqsK0adOQlZWFZcuWYfPmzUhNTcXHH3+MEydO4K233oLX60ViYiK8Xi/eeustnDhxAh9//DFSU1OxefNmLFu2DFlZWZg2bRqqqqoCyi8tLcW8efOQnp4O74n/4s/x+YiuOo3S9DXwVpejeEcy4mIicX3FNgzu0gozZ87EwYMHsXLlSqxfvx579uzB/PnzkZeXh8TERPxcVo3iHcnw1Z1Dya4vUFv0Eyoyv0X1if2oPvU9yg9uRl3Jz3h/xj9RX18fIMvJkyexaNEi7NixA5s2bcLy5ctx+PBhTJs2DZWVlQHPnjlzBh988AH27t2LlJQUrF69Gvv378fs2bNRVFTUpI3vvfceMjMzsWLFCnz99dfYs2cPFixYgNOnTwc8W1NTg6lTpyI7OxtLly7F1q1b8d1332Hx4sU4duwYpkyZgtyzDf0CAMU7klFXWoDy/RtQ89MPqMr5Lyp+2I7awpP4cM5MlJeXB5RfUFCAuXPnIiMjA2vXrsWaNWuQkZGBOXPmoKKiIuDZsrIyzJgxA5mZmfjiiy/wzTffYNeuXVjyySLUlRUGyOCrr0NJ2ueoLc5D+fdbUH3yILZs3YpPP/0UR48eRVJSEmpra5vMtYULF2LXrl345ptv8MUXXyAzMxMzZsxAWVlZwLOFhYWYM2cOMjIysGbNGqxduxYZGRmYO3cuCgoK8J9VCzDngX6oS/8c3nNVKN2zCrWFJxF+YhdGX1yG2PLj+Oijj3Dq1KnAceKtR0naZ6gryW+Uu/rEflRkfovas7mYO/NdYWtE8raD6H7zoxg1Pw0PPT0ef3x/Ky6+fQw+XPNd4xgMXiOUcuvr6zF58mQcP34cn3zyCbZv345NWzY3yF30E0p2fQFf3bkAHdWXn0VZxnqkpqVh/fr1WLlyJQ4ePIiZM2dKvUbk5+c3rhHr1q3DqlWrcODAAcyaNQvFxcUBz5aUlKiuESd3rsVbIy5CXfrnv4xZgzWiZOdy/G3xHvxr/sfMa8Tx1NV4oV9zRORmoDJrF879nIOyvWvRIfwcrq/YhhG9402vEZEFhzH2ilo0O7oddSX5KEn7DD5vPerSP8ecB/rhP6sW4NSpU/joo4+QlpaGDRs24LPPPsMPP/yA6dOna64Raf9JR+WR3ag8sgvn8o+i7L/rUF9VGjCmvDWV+HDurCZrxMKFCxvlbpxrKmtE9cmDKP9+C2qL8zD3vWn47a864PqKbYiLiWxY28oKUb7/G0SV5uAvF5eiMsvYFMkTqX2aTp48iWuuuQYbNmxozCr9m9/8Bn379sWMGTOwZMkSPPLII6ipCfSeHzhwIG688UYkJSWplltTUxPwTmlpKbp06SKdT5ORHw6gbUeW2TfDiL1796Jfv34BvzPjY8HDj0B2RLVRTRdW1s8D0rFjdxuM5uwL/ZrjyftupirT7jY5gXqvDy9/vh+f7z1F/M65vCNY+OJ9ptZQK/zGeNfBazyxlKPVFqt9kqWOCJ6eno6ff/45YNGur6/Htm3bMGvWLHz99dc4d+4ciouLA06b8vPzERcXp1luREQEIiL42kF5D07SXENqOYRE50Eyi1Ff7dmzB/369ePWp3amsbHKoZZ3GxW5P1mxAX+O6WYoN0v9Rn3Dq+9I0zTYPU6M5uy7S9ZjzP/9jqoP3BROZGw/cobq+XN5WabXUDNpeEjnBu9UP7zG08CEdoiLjkReqX68Kv9yrE5bpIXUm6bf/va3OHDgQMDvHnnkEVx++eV4+eWX0aVLF4SHh2PTpk249957AQCHDx/GiRMnMHjwYMvkFHFFlybvT3AOIdE5pMxA0le///3vufapXWlsrLy6zbON/nLXV3bBuvlphnLT1m/UN3Zce7cz3RHJnK3rOoB6zropnIzZnVNkmKctmJaXXSf1GioKXuNpQ2YequvqVT+TfVxK7dPUpk0b9O7dO+BfVFQU2rdvj969eyMmJgaPPfYYnn/+eWzZsgXp6el45JFHMHjwYAwaNMgSGc2E4teDJdeQ8o6VOaRoIO2rF9/8J/c+tTqViahxoQePNgbLXZbxFbHcpPUb9c3kdZmW9x1tG3hDMhfLMr5imrNuCid9WPpUmReyrqEiMTuelDb4x3jyJ7ZVuNTjUuqTJhKmT5+OsLAw3HvvvQHBLa1ApBmMJdeQ8o7VOaRIIO2rYZd3wo+dfwefyl/dZvt0RO943NQzzhI/ArvMo2baqCZ37HUjqeQ2qp/kqvH873JsNS1bNU78IZmLsdeNZJ6zdrTJKbD0qTIvOrS27rq7TG4XrOOJxO0konkYbuqp7V5jN47bNG3dujXg58jISMyePRuzZ8+2XBaRZjAj27E/wfZfGf0YSPvqk53HcOirRY2LktZzrMfiVtjF7TaPsrZRTe7iHckBGycSufXqJzE760XFsMq0bLX/BMmcrUv/HAPfvpW5Dll8QljQ8+Ex6/tGs9YqNM4LC69R2b2uBMMynkjmf15pjS1mT1Ict2mSCZFmMD3bsT9q9l8Z/RhI++B4USWiB9zNrTw7kNU8aoSaPGq6MCM3rzbL1ndmIZmzM99+9bw8GdLz4QFg2r+HdK31R5kXBRXW5T1z6rriTyi0QWqfJtkRbQbTsh37o2VHls2PgbQPurVrhfL/ruNWnh3IaB4lQU0eNV2YkZtXm2XrOx4YzdnsbavsEcxG9Hx4nli8F09w8u8hWWv9UeaFlePwWEEF0XMyzw2nro3+uCdNJrDCDBZsO+4QFQF4gILyGsOjaJn8GEj76s+Du2Nm31+jBOp/8TnhirSM5lES1ORuecnAxs95yE1iCgnzAD6fc/VvBr05mxB+u93iWQqJ/5sarP49/n2fV1KFSSmHcLbinGpdrS4ZSJ2KxAz1Xh+W7j5h+JyVMrHg1LXRH/ekyQRWhMRX6lFyCw3p0QFDLu2Au/peiIEJ7bA7p0g3RYosOaRI+6pF8zDc2rnG8Dkr2sGagsYoRYMPcl6nVZP73M85AT+LTvHgATD61wman5uVwQlphbTm7L59+xwhPy9owq4Eo/j3TN/wI/XcHXxJe9zT7yK8fU9vAOrj8NzPOZbOYdKwCCMHdJVuXfHHqu9MkbgnTSZRjnWD7epxguNm2Bmrg5URvePx+PUJDbej/NYwj6fhi1KR+7dXX4rrO/W0vE/9Mdu/yrgYv+JAk6u1sa3CucvLi+DxHNayDQC+fU8yZ67u2pa7/p04Z/zJLgWGJm12rPy08PBrmbXlCGZtOcLUT3rj9M47rHVxIO2L7h1aCZbEPHZ9Z/JC6jQqVsEjDLtVkZ8B56ZI0UsL48Evcu/YsQPXXXedpX1KIidt/zpVT8Av43nbd9tx/a+H2pLigaf+nawLoEH+R6Z8ioiLrgj4vVPkZ4E01QYJZvpJbRzuStuJ6667jotsJIRiOhxe89tNo+JQlGNdZSCs3X+aOkYOyQCSKVaHv0xGspPE51Dk/vHHH3HdddfZckXabP8qfaH4RMikJxqUvj/83VlhOjDSLy/9yzhnaFDkrz37U5NNU7D8AJj8H7XqtdMfkiUUgBZm9Kw2DpU1yipCwRcoGLPfmXbhbpo4wnr8T/OebLE6SGWnkfu3v/2tSJF1MdO/an3BUo5M2KkLXsg2Z2hR5I/sdpXq54r8szYfQfKeE5ptpTFRyWDKNArD4FP5fz146tnqeSFjGBkeyDDOaHEdwTnBGt6e9j2Z4lzQyE4j97///W+uctLA2r9afcGrPruwUxe8kGnOsKDIVX5wk+5z0zf+qDv+SK/iy5CqQ0EvDMPcB/phLkWYAAUeerZjXsgWRsYsMo0zGtyTJg6wHv+zvCdLnAta2WnkfvXVV3mKSgVL/5KYHs3WZxd26oIXsswZVhS5tKLkk0JqXpbNlGkUOkX5LPXIGczakm1YHg892zUvZAojYwYZxxkp7kkTB2iO/82+p9i2tYaRB+qxOnhfVaaVnUbuxMREU7KZgaV/Wa5Ga+lJNuzUBS9Y5wxgT4iC4Dr7d2uL+JhIlOxINl221lqkwLqWicY/DENwqBUAGHxJezx306+Y9ayFlv7tnBeyhJExQm/uyDrOSHBPmjjAevzP8h6LbVuE3ZhWdhq5J0yYwCQTD1j6l/a430k+CHbqghes/iB2+Fto1XnnVfHIPfsHXd8eGrTGrOymTCOd8PT70asrFOaFSIz0JPs408M9aeIA6/E/63s0tm1RdmMW2Unlnjp1KpNMvKD1HaA97neSD4LduuAFrU7t8LfQq3Pethz86uctqvI/N7wHdV1aY1ZmUyaJTnj5/RjV9ZcXJpprTAhDoieZx5kR7kkTB1ivg5q5Rkpi2xZpN2aVnUTuP/3pT1SyiIDGd4DkanS7qHBMvL0X4qKd5YMggy54QapTO/wtSOo803EA0sbdiPTjZwPkB4DkPSeJruYbXU2X9Wo7jU7M+v2Q1LWvRW/Ue32OmcdWQaqnb8fdKOU4I8E9aeKAUWh4H4CRA7pg7f7TAbZdsyHljWzbIu3GZmQ3knvbtm3U8pBA65+iyHn7lZ0BoIn+/J8zSg3y9j19cM/VcvsgqCFKF3ZB4g9ih78FSZ0nMtORfvxsE/mN0vYokK4pMqa5INXJotQcfJnxE3bnFGFgQjsmvx9SXZjRf6imwyHVU/rxs1KOMxLckyZOaIWGj/lfyozpG7Maf+dv2yVNLcKCaLuxqHD4CQkJTO/pITqGltNTA2ghQheyY4e/BUlZzWM7aT6nNf78IR2LMo5l0r6elHKo8f9Z/c/M6sIIJ8YmIoVm7tzV90LpxhkJ7qaJI8HHwscKKjFj449Njh8V2+6cB/oBAOZty2nyjNfX8Puru7ZlHjxW2I1FXIGtq6tjflcNrRQa/npQ62Pa90LlOrA/vHXhBOzwtyAqy1uv+1zw+DMTEVy2sczS10bz21RdBrrQgnUtcgq0c0e2cUaCu2nijH9o+KFJm3Vtu2+s/h6Ahyi1CMsgsso/gXe6k7y8PG5lWRlDy+60EyLIy8uTol1WymCHXw9JnW28FYZ18pyLdqQx0oIlpQqt/5l/CqR2US1wtuKcKV2ole/U2ESkkOgpLjoioO9kGmckuJsmQZDYdvNKa3TLMBv236mh9/v378+tLNYUGrTvheqRe0WbLhiatNnWdlndt3bMG5I6x//5FunmqlXo9Y8epGsoaQokM7pwejofEkj0VF3nxYbMPMeui64juCCs9nfQwomh91etWsWtLCtiaDk1HYAR6w/mYtw/F9jaLrv61o55Y1RnUeYO7nU6CaV/FD9RGvTmM00KJDO6cHJsIhqM9FRSWevoddE9aRKE5f4OOjjNbvzUU09xK0t0DK0OURF48fN9IXfkrpgS2vS/o8lnVrXLbnOGHfNGr87fXMpvXjiVm3rG4Y3VmQBqqd7Tms8kKZDUwoWw6MLJsYlo0dOTk9dFwD1pEgZJ6oa46AjERfMN+6+Gvz9Ih6gIeH0+zevzRuVYcU32n//8J7eyWFNokL4HDxybDkAPxZRQsnuF6udKu9KyC4WNCauv/quNbztSVmjVyXNeOJXdOUXIK6U7iQn2oQkuz+iEqaiiFnHRkbq6IFkbzaTzcRpGeiKZu7KGZXBPmgRB4qPwxp29AECo74SRrZ7UN8RKvxKeyTBZ/VNI3yso1/dLU3Dakbsir1GS2LFL9qK46pe/JnmOCSvNGU7wSQuF5MlmYdG1ng8N6xjz1wXp2HGqjykLZueuzPPRPWkSCIlfhEjfCRJbPYlviNV+JbyTYbL2Mcl7oXrkrshbbJAk1n/DBPAdE1b1rVN80kIhebJZWHSt50PDOsYUXdCOHSf6mLJgZu7KPh89Pp9PjjMvGyktLUVMTAxKSkoQHR3NvXyS69K8r1QrIQ9InBuVK9TbXx6mKpdeOXrvspKXl4e4uDguZfnD2sd67yn9Y3Q9nWf/WIHSrlM/5aJZ67ZU7/JqsxV9a8f4ZkXUvHASRmNCCy09so6xvLw8XNCxE/PYkSGMh0hY+5VlPor+/g7GPWmyABK/CN6+EyS2egU9+7IdKSXWrFnDrSx/gvsYQKPNPDWrAKlHClTt53q6MZt2Qla7vdKuqiO7dFNzqKE3Jmjaa0VKD9bxbYfeSOeFrGOKB6QpY4LR0iPrGFuzZg3x2Jm+4UeqNUWLYL2eq/NKq2fWfrXj+4YW16cpRGGx/au9Y8c12b59+3IrSwtevl4AmFPhyGy3BxraNfHhW5Gc0yJAxtiW4U3McmoEjwmW9opO6cEyvu3SG8m8kH1M8YAkZYwWavpmGWN9+/bFacKxM2vLEczacsSUHtT0GuZpyByhIJueWfrVCWEZ3E1TiMJi+1d7xw6fncLCQm5lqaGVysAfmrQG6w/mUqfCcUo6hV/FerD95WEBpgSvz4f7P9xl+K7/mDDTXpFX/48VVBA9p7TFTr0ZzQunjCkeBI+JgrKagLxzWmitU7RjrLCwEB17XEwlM6setPQafLAko55p+9UJPqKueS5EMbre6o/eVVc7rslWVVVxKysYkrgswC83W/6xJlP32JukvOAyjOIPkdRrFVVVVU1MCYMubk81Jni0V8TV/3qvD0t3nzB8TmmL3XrTmxd2y2YH/mPi4SEJptcpmjFWVVVFtcYCbHogXa9Yy7cCmn51QlgGd9MUopDa/o18Q4zK8em8y0qPHj1Mva/n08HL14u0PLUyaN6x2z9FTRe0/gp2+ylo9WFDLBnjkBEjB3RFszAPcTsWpeZo6suMPvXmhd19bDdW+L/506NHDyb/Kv8xQqJ7mvXKv3waPdu9xvhDqkfgF3/U3UetHdOueS6EIbH9k/iGKOWMX3EAxZWBviyxDCkNjNiyZQt69+7N9K6RTwcvXy+Sz7SeI31nQ2Yenl+eYat/ipYuaPwV7PRT0BsPNXVeojK6d2hFJZ+/mchfX2b9jfTmhRN8QUTD6lvIgqILVv+qSSmH8OH2HEPds+qL9D0ZfeCM1hYAATfsvDWVlsrnbppCnGCbcoeoCMADFJTXUPuGlFQ2df5VYqDwtKM/+OCDTO+R+HTw8vUi+UzrOdJ3FqYea/I7q/0W9HRB6q9gl5+C0Xh4djjZiaYiF4t8Sl2PX5+g6vdGo089XTjBF0Q0LL6FrPjrwn8epB45g1lbsonKINE9q75I3pPZB05rbdmQmWfojyoa1zxnM1YcjfrblIf06IAhl3agvuoq2l/Cvx/G/SOJuixSGft3a8vF10uBxQZP4guhpRar/RZmzpyp+zmJv4Idfgok42Hp7hNUaYxofViUunxAw+mHjiwk+tTThRN8QUTC4ltohmBdKPPguZt+hbhoso0Oie4VvZJCqmeaNZ3HdxRLGWohYkj9u0TibppsZP3BXAxN2oxR89PwTHIGRs1Pw9CkzbZHPA1GtL9EcD9802IIdT+Qyph+/CwXXy8FFl8Kknf01hQr/VN4pO6w2t8EIBsPeaU1GDWwK7FcSjtYFm0e+tTThR19LBNW+3Rp6WJDZh6q6+qJyzGSy1+vpOWR6Jm0v2ZtPmL6O4rX9xytf5co3E2TTcgeKt4fkf4Sav1QvCOZuh9oZNRKZeAPTVoDltQIeu88NqQ7cVtEwyt1h9XpI0j7pnuHVtKktTCS2UgX50uKDjWs9ulS04WylgX7fZKgJ9eI3vHEa8KjQ7oT6Zm0H6Zv/NHUdxTP7zlZ/PFcnyYbMDoa9aDhGPKmnnFS/GUoyl9Cqx+i+91O3Q+0MvL09VIrj6QMrXd25xRhgYo/k1ZbRPLkk09yK0tkvKVgaMbD4EvaE8mljFdRGMlMogsr+1gmrPbpCtYFTWgANYzkGt4zjmhNuKknWZodM/1Aujbz/p6TxR/P3TTZAM1RsmLLtRPFrm6UR4jWX0KrH8q/34Lo/ndQ9QOLjIrNnBcs5am9I6q/AfqcV4sXL+a6ceLd51rQ9iGJXGbMAx4PoJXlU0+f/vratnIxpr7+kuEXjFV9LBLacSpyzqgRPC9Yx4aaXGpt590+o/KMIFmbeXzP+fdFh6gIxEVHIr+UTWZeuJsmG3Da9WDFrj5m8V54gIABa8ZfQqt9kV37ED1nhYx2IKotLNeLb7jhBjrhJUFEH5qZj3obJi1ZgvV17kxr7EjaLFWqDBGwjFOr53/wvGAZG2py6bWdZ/uM+ot0U8I7HIs/an0R2yq88ZTKro2T69NkA068HizCX0KrfXVnc4mes0JGu+DdFlbfguxssuvTMsK7D0XMRy1Z1PRVdzZXSp9HnpjxgbFy/gfPC5axESyXUdsBcG2fXn89RxmOg/Yzo+e0+kIJexMjID4gKe5Jkw1YfZTMC97+Elr94GnWMCxZ+iGUfDp4tcWMb0GLFi2Y5ZcBnuOBZN52io7AtPv64ufSakxKOYSiinOa5bWLCse3425Ei+aBf7tq6cvTrLmUPo+84OEDY9X8D54XNGNDzW+StO3bXx7GtX1a/QUAyXtOmvqOYv2eI+mLyOZh+PQv1+Ln0mq88cV/cJKsuVxwN00W4m+fHTmgK2Zs/NGSo2Ra/wA9ePpLaB0Rh0W1Ve0H0naoycizD0SXy7tMM74FnTp1Yq5XFniNWRIT0Bt39sKQSztgZ3ah7oYJAIoqapF+/GwT2bT0FRbVFoB8Po+84OXraYVPV/C8oBkbatCk6Hl4SIIlvphmzYGsJlPScCFhHg/iYlriLMNtRTO4myaL0LLPAgi4okqS1sRsvXaHyfdHLWT+ubwj6P6r3gEymmmHqD4QUa6IMs34FqSnp6N///5M9YYipOljzPS51rvn8o4gIu5Sw+ecipN8PdXmBU1qoWBoUvSQpF/hgZn2+JdBm9pG9nHgbposQCtcfUllLXwAnhveA907RHE/SpY5TL4/wUfEze+5GCMGXB7gHMnaDlF9IKJcUbIeK6ggek7Nt+Cuu+6iri/UITEBmfHn0Hq3VY9riZ5zKk7y9dSaF6zmQZo2Wbl+mzV3sqS2kX0cuI7ggiGxzybvOYnbr+xMnNaER70+AK+sPIBzhElLReMfMv+/G74gtvUD2mkIRKV/EVGuSFmX7j5h+JxW6oX58+dT1Xe+YJQ+hjWtSb3XB6/Xh9iWTR1dy/Z9rfuu05EpFYxR2o8P5s3jmv6KJkWP2VRKtClNSFIladXDktqGZhwMTGiHTtERRPLwwj1pEoxdMZlI4oYUVdRi0ORNePue3lKcOCn4pygw03+i+l5EuSJlzSutMXxu5ICuqoshjzQq5yMs/hxqpll/Yq8b6bjwGTTIEjbEyES+/mAuvmp+HRbOT2vyOQAm87pe29VgXQ+sdNdgXdNox8H4Wy7H/73JVXRd3JMmwdhlnyUtr6jinHRXmP1TFIjwDWF9TmS5dsvavUMr1d/zSqNyPkJzBV7rirU/xTuSHRk+gwa7w4YYXfufvC4TYxbvxaGvFjX5/InFe/GEiZQhJOmdgqFZD6xO3WVmTaMZB6RR0HnhnjQJxi77LG15Ml1hfuGFFxr/X4RvCOtzIsuVVVZ/XbjQQ+ITQmLGiG0ZjoXvv40bel4kxRwViV1hQ0hM5PO/a/DPiR5wj+rnatCEiVDavig1B5NSDhnKTDq/7UjdZXbtkTV8jHvSJBi77PS0NnJeGcBJ7OVGz7z//vuN/2+m/0T1vYhyZZXVXxcubBj5hJCY0ourarHy049s/8KwClY/GjOQ6EFZqsr/m0JVNs0a2yzMg4eHJHBdD2hMZbQ+T1rwWNOMxkG914fdR81/b9HgbpoEo9hnATQZPCLt9P71kmLWRLj+YC6GJm3GqPlpeCY5A6Pmp2Fo0uaAY1+SZ+68807VdtD2n6i+F1GurLL668JFDKTzruegGwVLcn5Ds/61vPRa44dM1MF7PSCtd0NmnuH6TIro7z7lu+TRf+9hep8Vd9NkAXbZ6ZV620WRhZw3YyIksZeT2tT37t2r2g6W/hPV9yLKlVHWYF248Id03hUcPyxYkvMbmvXvXD5beiGaOniuB6T1Lkw9xtXnSdSaRuIDKAqPz6eVSvL8obS0FDExMSgpKUF0dLSwekRFpTbiXJ0XgyZv0oxQrISz3/7yMCZ56r0+DE3arDmAlRQCgAd5pdrPKDJ8u3ULhg0bploPa/+dzxHBzZS7efNmVV248EOZP0bpJt4cANw0/LdWi3feYKQHAAjzNCRfrjy+Dy27XUVctpk1lsd6QNo2LUscj+8IXmta8PeNt6YSJ2fcJ/z7W8F1BLcQK8L7q9GieRjevqd3Y9JH3ld5ScPe6+FvU4+IUI+7Qdt/pBNV7TmlXSwpW8zCWqZRe0nKDS6jebizc885AdIr1q1Kjga856QNuxMg0cPoXydg3rYchDULPL33f553uAQea4xR23zQ3jAB5kPj8FwnSXzPROJums4TeITE14JnuISfy6pRkp2NIUOGmCqHNB4JaXobmVLPqMEj/opaGc2zt2FW20ukbXeoQDI/P/54Q+O8cEoKH6dBooeru7bFk//Yhjq/95TPgaZxmninxmJFr2239o7DgtRjhmXIkMLGbhlc8xysM8/JgIi/JHdmF2KUX6A3MywdPQgXhlega9euzGVopSNRWqnY0rWeUyP4XZkgbS9LGfWlP6N5dEcp2x2K6M3PEydOoGvXrlz0HYyIMp2M0TqZc+w48upbq34u+2mdmny7c4qI1vClowfZniQ6+PvGavOc6wgeIpBeExVxlZfkammnNi1gVFWYB+jfrS0++eQTZllI05Gcq/MaxsZRe/eN1d8j9UgBt/QJZuGRfkWvjPKDW4jKcOGD3vz85JNPHJXCx8kYrZNLPl2MgQnt0LFNJH4u++WqPsm7NPC6/u+PmnxWhcbh0R6acDoicM1zIYDdx+okvgB/urYbpm/M0i3H6wPSj5/FhAkTmGUhjUfyyc6mt0SMUHyz7v9wV+Pv7DZf8Ei/oldG9OA/CEv140LHhAkTsMtBKXxCmavveLjJ5Rfea4GV67oVKWx4tSdYVqtxT5ocjtWh8bUwulravUMUUTk/l1Xj7bffZpaD1N59vKiSuQ5/rO7nYHikX9H7rGTncuq6XMTw9ttvOyqFT6iy/mAu7n9yvNA11451XWRoHN7tYUk5wwv3pMnB2BEaXw+9sPc7swuJyujYJhKvvPIKswyk8Ui6tVPPtUaLHf3sD4/0K3qfxQy+j7ouFzG88sor2JVzluhZGVL4hCLKmhvtNy8UeK0Fdq7rIlKXiGqPIuuW/cdx0wxm8ahxT5ocDM2xOg9I7NFa9nwam/nkyZOZZSSt58+Du3Ozi/PuZxp4+CLolVG68zNhqX54IcLvw0602jN58mRHpfCRCV5jRFlzS3d+pvo5yVpgJIvV63owvP1eRbanWZgHAy+2dly6J00OxspjdbP26GZhHtx5VTw+2Jaj+YxiM//zn//MLCepbb5F8zDN51ixw3zBwxdBr4zWvW8kKsMu7Pbn441ee/785z8L8T2xwp/FTniOEWWOR/XWT2mjtRaQyBJq5tJQa4970uRgrDpW52GPXn8wF/N0NkyPX5/QuGhs3brVlLyktnmt52JbhTfGaqLBLvMFD18ErTIizvwg7XVzWfz5eGHUnvcWrwLgrBQ+dsN7jChzvPrEAaLnWGQJNXNpqLXHPWlyMMqxulH6BTPH6jzs0XplKKzel4uXRlyBZmEeXHLJJczyKpDa5rWeA36JCN4hKgIvfLYP+aXi+tksPHwR1MqoPR2D6yX8wpTNn88sJO1Zf8KHJK8PzcI8QnxPRJRpJyLGiLLmHotVnxNaawGNLFas61YSau1xN00OxopjddbryP4B1ArKagyv9/uXUVOjn3KFFNLQ/VrP+f/utdt74m9Lmiavlcl8wSvdgn8Zm4+r5yu0m1C7Jk/SnjMlFQHtkSmFj4yIGCPKmvvw/l1Uay6tLKFkLhX1PaV8xxzLPcNLVCKkNs9NnjwZAwYMQJs2bdCxY0fcfffdOHw4MNN3dXU1xo4di/bt26N169a49957kZ+fb5PE1iP6WJ3FHr3+YC6GJm3GqPlpeCY5A5NSDlGVceaMtZPAiPUHczEpJVP1M6ebL4yQTRcKoeYnQSKnt7LEMe2RAVFjZETveDzSvx3VmksrS6iZS3m3x/875uUv9E2lvJH6pOnbb7/F2LFjMWDAANTV1eGVV17B7373O2RmZiIqqiHuz3PPPYeUlBR89tlniImJwZNPPonf//73SE1NtVl66xB5rE5rj6ZJTaJVRr9+/RjeFoNReybedoXjFjAaZNKFP6HmJ0EiZ4tOlzimPTIgcow8etdvkXjJpcRrLossoWYu5dUeM98xPJB607R+/fqAnxctWoSOHTsiPT0d119/PUpKSrBgwQIsWbIEw4YNAwB89NFHuOKKK5CWloZBgwbZIbYtiDpWp7FHk/guaeF/pXn16tV44YUXzIjNBaP2eABMSjmEm3vHW7qQ8c5tpVeeLLoIhnZcsvaXVXnEjNoDADjxH/Tv9hfudbMgW341NXlE+tIo84J0zSXRb7uocPTv1jbgd6FkLgXMt8fMdwwvpN40BVNSUgIAaNeuYZCnp6ejtrYWw4cPb3zm8ssvR9euXbFz507NTVNNTU2A30xpaalAqZ2NYo9+YnFTfx6gwT6t2KN3ZhdSpyZRGDmga+Oi+7e//Y1VXK7I6DfD+4q9UXmy6CIYUj+JDZl5zP0lSxqLxmd6jcAN72yxPZyCbGEe9OQhDXNCC+28INFvUUWtFPqVGaM12Qqk9mnyx+v14tlnn8WQIUPQu3dvAEBeXh5atGiB2NjYgGc7deqEvLw8zbImT56MmJiYxn9dunQBABw9ehRTp05FTU0NEhMTAQCJiYk4ffo0FixYgD179uDrr7/GihUrkJmZiffeew+lpaUBzxYVFWH27NnYv38/Vq9ejZSUFOzduxcffPABzpw5E/BsZWUlpk2bhsOHD2P58uXYtGkTduzYgUWLFuHkyZMBz9bX12Py5Mk4fvw4PvnkE2zfvh1bt25FcnIysrKy8M4776C6ujrgnby8PMyfPx979uzB+vXrsXLlShw8eBAzZ85ESUlJwLPFxcWYNWsWDhw4gFWrVmHdunVIT0/HvHnzcLbgDIp3JAMAinckw1tbg9LdK1Bb9BMqDm1Dxq7tSE1NxbIli1FX+jNKdiyDz+dF8Y5k+HxelOxYhrrSn1F+cBOqT2Wi6vg+VBzahtqin1C6ewW8tTXYvXJ+oyz/+Mc/MG/ePKSnp2PdunVYtWoVDhw4gFmzZqG4uDhA7pKSEsycORMHDx7EypUrsX79euzZswfz589HXl5ewLPV1dV45513kJWVheTkZGzduhXbt2/HJ598guPHj2Py5Mmor69vfGfWu0moKz2D8gMbUX3qEKqOZaDi0HeoLTz1P7mrUbwjGT+XNfT7mTNn8MEHH2Dv3r1ISUnB6tWrsX//fsyePRtFRUUBspSWluK9995DZmYmVqxYga+//hp79uzBggULcPr06YBna2pqMHXqVCz8aif+/Mp05BzYjeqTB1H+/RbUleTjh68/wRMf78FDT73c+M6pU6fw0UcfIS0tDRs2bMBnn32GH374AdOnT0d5eTkSExOx/mAuRv3tJZzKzUfZf9fhXP5RVB7ZjaPp3+LRaZ/jyYlTMGnSpABZysrKMGPGDGRmZuKLL77AN998g127dmHhwoVN5K6trUVSUhKOHj2KTz/9FNu2bcO2bdvw6aef4ujRo0hKSkJtbW2TubZw4ULs2rUL33zzDb744gtkZmZixowZKCsrC3h2QHwL3BZ+AG0qTqHyyC5UHtmNc/lH4flhA6bc1g1LP5iBMYv34tBXi+A9V4XSPatQW3gS2bs24uFJCzD907X46KOPcOrUqYBy6+rq8Oizr+Avs79C1o6vUH3yIKpP7EdF5rc4eSwHf3rqFazee4z7GnE8dTUm39oNdemf+8216oa5VngKBetmIGdfGh6Z8ileSJxhyxrxt1fewmPTVyB7zxZUZe9BTd4RlGWsx0+nG8bS+oO5SExMRFVVFaZNm4asrCwsW7YMmzdvRmpqKj7++GOcOHECb731FrxeLxITE+H1evHWW2/hxIkT+Pjjj5GamorNmzdj2bJlyMrKwrRp01BVVRUgS35+PubNm4eZy77GQ//4ANl7tuDcmWMoTV8Db3U5fvhqEZ5YvBdJUybDW1OB0vQ1OHfmGCp/3IGqo+moyf0RV1f+B307eJjWiDvuuKPxnZMnT2LRokXYsWMHNm3ahOXLl+Pw4cOYNm0aKisrG8v/z6oFmHxrN3h+2IiavCOozN6DyqxdOPdzDsr2rkV9VRl++GoRxizei4eeeplpjcjOzsbSpUuxdetWfPfdd1i8eDGOHTuGKVOmoK6uLuAdkjVCebagoABz585FRkYG1q5dizVr1iAjIwNz5sxBYWGhZWvErHeTUFdWiPL936Dm9GFU5exFRVaa+he9IDw+n88R4XPHjBmDr776Ctu3b8dFF10EAFiyZAkeeeSRJretBg4ciBtvvBFJSUmqZamdNHXp0gUlJSWIjo4W1wgHUu/1NUlM6Y9yxL395WHYnVOEUfPZBvDS0YOkO4bemV1I1B4rZKfRA8lfzrzLsxM10wwA5vbZ3Tfn6rwYNHkTiirUby7apRu7+4VWHiPibRrfsurXCaityd6aSpyccZ9l39+OOGl68sknsXbtWmzZsqVxwwQAcXFxOHfuHIqLiwOez8/PR1xcnGZ5ERERiI6ODvjnNKxKHUFjojJKx6CGWooG5a8K3tD2GY/0ErzTN2hBm4qAtLwxL/6dUtJArBinamkfzPQXzbsi2pd+/KzqF6py2mtHeiSAfgyK1r1ZU42ZPjSzRmnpV0FkmhSnpxxi+Y7hjdQ+TT6fD0899RRWrlyJrVu3IiEhIeDz/v37Izw8HJs2bcK9994LADh8+DBOnDiBwYMH2yGyJVjpU0BzVZbEbu+PVoyO0aNHM8mqB0ufmY0vIiJ9g9XPDbmtaWJSUuz0fTHTD6TvbsjMw/PLM7i3T6v+NlfdzCSnHjQ6oulTK3TPo/2sZZhZo+wKlyGbLxoLtN8xIpD6pGns2LFYvHgxlixZgjZt2iAvLw95eXmoqqoCAMTExOCxxx7D888/jy1btiA9PR2PPPIIBg8eHLI356xOHUF7VZYmNYlWjI4vv/zShMRNMdNnrPFFRKVvsPq5zLTNRM8FY3eKEzP9QPruwtRjQtqnVX9l1i6i50ih1RFpfccKKi3RPY/wC6xlmFmj7AiXYfd85InWmmwVUp80zZkzBwDwm9/8JuD3H330ER5++GEAwPTp0xEWFoZ7770XNTU1uPnmm/H+++9bLKk12JE6on+3tgjzAHqnuGEeBFyVJUlNondNuX///lxkB/j0GW18EZHpG3hdnyYt797h1xOV548MKU7M9BfJ9XCtOcGjfVr1t4i71FB2Ulh0RNKnnaIjsHT3CUt0TxSmQQOzfWhmjbI6rYgM85E3/mvysdwz+NMM6+qW+qTJ5/Op/lM2TAAQGRnZeDupoqICK1as0PVnciKKHXr6hsNc/VpISD9+VnfDBDR8eaQfPxvwOzU/E7XfqcEzojsvXyBS2XnWGVz/63f0BIAm9nyWVASk5RWc+ZlYRgXS9qdlF1KXTYqZ/tJ7V0FvTpDoV8+3pFmYBxNv69nkS85bcdaW9Ej+chn16aiBXZFXas0aRSKP3mdm+tDMGsV7LhtBMx9l83cymieDL2mP267sbKlMUp80uajboY3gaQu3w/5+7hy/fGd2yC8yfcOcB/o1GQ9xjH4JJOWtOrJLpwR1SNs1dsleTLm3jzB/CjP9pfWu0amrP1r9YORbopW2x1dfx6xrUtmMnjPq05o6L9f6jTCSBwC3+eKP2TWK91zWg2Y+FlfVNv5st7+TrD5Y7qZJYljDxfO0hdthf7/kkku4lWWH/CLr5J1awag8Fl2Qtqu4qhZjFu8VmkvLTH/5v7shMw8LU48Rb5gA9X7QmtOKb8nj1ydg3rYc1TnfvG08t7Q9ZsaoXp/uJDw95DnfjHQsIhUJjzXKqjQpNPPRH2VM2pHrzmie2Jl/z900SQpLuHjetnDAevs70JBzsE+fPlzKskN+0XXyTq2gVx6LLmh9TUT7U5jpr2ZhHgxMaIfnl2cQv6OlXyPfEgCY/536hgkAak4cwKSUy7mk7TE7RrX61I75pieP0Wes8FqjrEiTwur7ZZe/k+w+WFL7NMmAXXEtaGOQiLCFA9bb3wHggQce4FaWHfIb+cT4AIwc0CXgd6TjzOrxyKIL//YbITImDS9o5qLemCIpR0+dUb1uNOUr5Y+oeUEy9nnPNzvguUaJhsRHTws75qcIn1CeuJsmHdYfzMXQpM0YNT8NzyRnYNT8NAxN2mzJ9Uxam7/RFXgzsF67Z2XWrFlcy7Nafr06FaZvzGocS6TjzI7xyKoLpf2xLcONHwb/mDQ8oZFNb0yZbWPp3rW65dCOD1HzQik3plVT3QeHHXEqvNco0WiGgpFwftoVx4oUx6RREUlpaSliYmICwrBr2VSVnbpomyppCo8nb7wUQy7tYEmWcdkym9Nih/z1Xh9mbT6C6Rt/bPKZXnC24HFm93hkJfVIAe7/0NiZXMY0Ogqkc3HibVfg4SEJmmOKtBwjnht+GZ4Z3iPgd2bGh4h54dTxGuoE69rr80k3P2nTV6l9f4vEPWlSwcim6gMw/osDSD1SIMw8QprC47mbLjO8Ak8CybE+zbV7M4hKo2KV/MEk7zmh+nu9kaN89o81mThX5zX0hfnHmkwhY9GsLgZd3N5wHMdFR8Dr81licmQxb5LORb0Nk1JOXHQEm+D4JY3Kv3fmYOV/f5GfxFdKb3zwnhdm5HFKmg+ea5SVbQ7WNcn8DE4VJVpeHumrROI6gqtA4ntQXFWL+z/cJewKpNkUHjTIdrXzqaeesrxOUZjJj6XY7j/Z2TTytNpzu3OKuP81aFYXRuPYB6C6zhvw166oscc6znnNxWZhHowa2BXTN2YxyR/d/w4AQFFFLZ5bltEo/8gBXWwbH2rQ+KT4yyPbOqQHrzXK7jbTjm0r5LXyu48F96RJBRpbqcgw9Fb44sgYXv/jjz+2vE5R8LC7Hy+qtKyuYHjoQmscKz4vxZXqV515jj2z45zXXOzeIYpOcD/KDzZNaZNXUk28CbPKB4TFJ0XGdUgPHvNCljaTjm0r5bXDD5UU96RJBZoYIqKvQIqM5SHr1c4bb7zRsrpEwyMeTbd2rSyrKxheuggexx2iIvDCZ/sA1DZ5lvfY4zXOecxFMzqK7Nr0ijuNYUTE+DBTj/KcrOuQHmbnhWxtNhrbdshrVRwrWtyTJhWMbKrBiL4CqcSK6dgmEj+XNdTDw45sxdVOFvt3Vhab+UIEZu33tGPJH8V2/+fB3S2z8Qe39/Dhpg7srPj7U4SFeSxLt8FznJv1/yEZD2Ee9avhdWdPU9WlYLUPCK1PikxXzEnnu9k1SqY2K+iNbRp5efo82eWHqod70qSCnk1VD1HH36LsyKKvdrLK3bJlS6b6eMOj31nHkr/tvkXzMEts/GrtbZl/GFG/yuV+HG7ltWKZrjCT+GuM/nVDVPAmnzc3diKXwQeE1idFFv3QzHeza5QsbSaFVI4NmXl4fnmGI/zSWHFPmjQwirOjhojjb5F2ZJHpPszI3b69/VfPefY7y1iKbRUeYLsXbePXam+JN1KIf4WV6W3sSKWjh5EuJ9zaU/XzsJZtdMt9bvhl0viA0IxXGfRDO9/NrlEytJkGUjkWpja9tCKrXxor7kmTDopNNS27sEkyQ39EpQYQbUcWlfLArNwZGRkYMGAAVZ08EdHv/vb5vJIqTEo5hKIK7aSfEc3DcFPPOM0yeNr49dpbk38UEfGXcfdXsDLdhl2pPfQw0qXaeDnxP11oyf/ksEvx5LBLpfEBIR2vduuHZb6bXaPsbjMtJKlYtJJZy+qXxop70qSDEgisoKIGjwxJgAfWpeIAzNu9jWzLzcI8mHhbT81JC7C1y6zcd9xxB1E9LLZzkndE+Rso9vm4mJa6GyYAyCutUS1fhI1fr72tLr1WiH+Flelt7EilQyqXni6Vz+/pdxHevqc3Wl56raH8ZsaHiPg7JPLYrR+W+a61RtmdxoYF0hh9RvLqDRe7U5/wxD1p0kDNvh2rckU6TqC91ozdm8Q+v/5gLialZKqWaaZdZu31H374IV599VXdd1n8jUjfEe1vIJs/g149Zfu/Rux1I4XIo5hwgnUiYk5ZWZcIRvSOxzDPAfwY8zsh8tsdL8hO/bDMR7U1irYPZRiTNDLryXtr7zgsSD1mWJ8sPlpmcDdNKmilACiprIUPwHPDe6B7hyjhx9+sdm8t+RXb8pwH+gGA6jMKE2+7gnnSmrXXk2yYjNoXLDvNO6L9DWTzZ9CrR9kwGT3HipXXimW9wkzKv2cmWZryRG8+icAu/bDMR7UNE0sf2jkmWWTWknd3ThHRpkkWHy0zuJumIEjs28l7TmL7y8OED2wWuzeJ/G+s/h6ARzfv2aSUQ7i5d7wQXykg8Mpx8BfBhiXv47WJE5u8U+/1IS27EOO/OEDlf0Drs8DT30DtS84ufwatL1w9eYp3JKPtdSOF+lcoJhwrYK1LhryLiYmJePXVVwPkV0wrrHLJFi/IyrGgwDIfFV0A5vvQjjabkVlNXto+pJlPMsw9f9xNUxCsKQBEwBJOnkT+vNIa3XrNttFfbi3uvKphQ6Z2PNyp1TUYeDDwmrvac6Sy0+qUVxh/vaNvq9MEGB3Da8kTM/D3QuRxEnabrhRefPFF7nLJtN7ZBct899eFE/uQt8w0fUgzbmWZe/64juBByOZvQnvVnKdcZsoa0Tsej1+foPn5vG05mLwuU/Wab9aWzwKuqGpdB9bDX3YWnZq94m90hRmAZWkCSK5Ta4ZF+P4r29MW2IksqS4AYObMmdzlkm29swva+e6vCyf2oQiZSfqQZtzKNPf8cU+agpDN3wSgs3vzlMtMWfVeH1bv0x7UPgDzv8tRPcpt2WMQgIbj4WGXd9I8RtbDX3ZWnbL6G5AefW9/eZhwfwaaY3i19rat64HLf3V+bphkM13dfffd3OWScb2zC5r5rugCcGYfipJZrw9pxi3+9/+kz1qJu2kKgsQ22yk6Al6fD19m/GSZjZXU7k0qP+BBfqk4nxqj419A+4rqubwjCG93IXJLqvHJzqbB0vRQk53U3t6/W1tV/xDaI3Xao2+t8nnY8llMk/7yJCdvwOW/ahobyEp49INRGWqfy2Z2SU9PR48ePbjK5bR4QaIhne+KLgBn9GHw+O7fra0wmbX6kDa0A+mzvS4Ip5bRDO6mKQgj26wPQHWdF/d/uKvx93bbWP0hsS2/cWcvABDqU2PmKLpZ67aN/3+8qJL4PS3ZSfrkzqviccM7W7jYznkcffOy5ZuVJS7O+r/k/OHRD0ZlaH1+a2+ytltldlF0wdO0wst/73zDf17I3oda4/vOq+LV0/X877+8ZRZhEvy5rNryTZPr06SClm02RiVOE2C/jTUYEtuy6LQcpo6iw5o1/m+3dq2IX9OTXa+9j1/fkOuLl+3c7NE3T1u+WVmaN7fv7yoe/WBUhpZfXV5JNdEVasA6s4uiC96mFdFrQSgSPC9k7UO98T9vWw4evz7BMplpxi3Nsxsy88yIRY170qRBsG22Q1QEXvhsH4CmqVRkDBNPYp8XGSOENOy+z9c0iW1dcT48F/VCXEwk/jy4Oz7cnqNbTmzLcMy+vx8GXawfAVmtvf27tcUN72zh6rdi5rietx+NWdNBTk4Ohg4dalgPb3j0g1EZgLZfnfI7rTEKWG92UXQhwhzk9BhWVqM2L2TrQ5I5tHpfLr4ddyPSj58VLjPtuCV1qXj641TusurhnjTp4J8CICzMg7xScnusFiJSFWhBmsKAd1oOpVy9sPseNGRzV/u8ZZfeABqOh1s0DzMsZ8q9fTDk0g5Esge3N/34We4pU8ykSOCdwsVsuobrr7+eqB4SaMY+j34w41fn/7nyBeOPHWYXRRckOp142xXYnVNEtc6IWgtkQG3smVmLteaFTGlsSOdQ+vGzluidZi0ifTb9+FnkG4TQ4Y170kSITH4qToEkTcDVXds2+dxzdDvmTEts7BOR6QZEXRdmlVnkVWCW/luyZAkmTJhAXJcWtGOfRz/w8jV6dEh3fHUwz/b0K/660NPpnVfFY1LKofNmnTGCNCUWTR/xmhd6MprVmYyhEGjWIpJnv8z4yTLZFTw+n0/cUYdDKC0tRUxMDEpKShAdHa36zM7sQoyan2ZY1tLRg1RvDmiFrFd2zaHsO0B7c6l/1xi0CG+6nxcRGdasXo2glVmkPCz9V19fj2bNmuk+YwTL2OfRD6RlkNSh3Kaz0+yipotgnZ6tOIexS87PdUYNrbGnBk0f8ZgXCqK+G0SvbWbgFRF8Z3Yh/jhrM07OuE/3+5sn7kkTIXb7qcgWSp4Go2u8wZ/7pyigKYcF0deFaWUWKQ9L/02ePNkwF6AerGOfRz+Y8asLroPX2DMzj9V04S9XvdeHoUmbiWPbOHU9IUVv7KlBsxaPGTcRtz041nTfiYwFRjOHrP5+oZlPes8OTGiHTtEROMlTOAPcTRMhZq6Vmo2rcr6Z9cx8SdMi23Vh2eQxqwvWsa/0wxMaqXh8MO4Hkr4c/esEy65dm53HRrog7etZm48gec+JkF9PSHzagiFei1sMwTfJGQDM9Z3IWGCka8mGzDzHfr80C/Ng/C2X4//etK5O1xGcAtZrpWZsy7KGkhdJYmKipfXJdl1YJnnM6sJuvwqjvpxwa09L+prHPDbSBWkfTt/443mxnpgZU0ZrcfGO5Mbfm+k70fPDaPwDcPz3i9VRwd2TJkpYrpWyxlWRLY2DVTz00EOW1ynbdWFZ5DGrC7NjXwuasW/Ul6L7mtc8NtKFmXhRobiemOkPo7W4de/fNn5mpu+sSMGiNb4BEJtzQ2E88MLdNDFglZ8K6dFtWnYhhvToQCyPSNRs4wCd/8SmTZvw8MMPWyTxL4jwmQrGv386REUAHqCgvMb2TZqafB3bROLQtxvx6KOPUL3j3w7RY58mCzuNXx1PeLXFaF6Q+HDpESyHnl6d4GPJ0h+k47H6+D607jO88WdWM5oIH0Yt3QTLtTO7UKo0QU7B3TRZAKufCumR7NglezHl3j622595Xe297DJ7c52JQq1//CFJ7SHSz0CtztbFZeg8MFezTiM5RY99mTLHa8GrLUbzgiQFFKkcenoF4AgfGL3+UINmPDZve6FqGbTjkbcPI826EUpzzEpcnyaLYPFTIT2SLa6qtd3+rOWzUVxZS512pqqqSpicdqHVP/6QpPYQpWct+QqKyzTrJPXTETn2ZcocrwWvtpDMC72+fm54DyI5jhVUaur1icV78YSDfGC0+iO2VXjjH3QKNOPRV6ceUJFlPPLyYaT1mwulOWYl7kmThdD6TtAeL9tlf+Z9tbewsJC3iLZC2j8kqT1E+BnoyVdfVQao1Enrp8N77JsNBWElvNpCOi/0fFiS95zUlaNTdASW7j6hm1pGDZl9YPT6g3U8ev83LxTMjkezfnUsfnOhNMesxD1pIoBneHuaMPv+oeSNYEn3wQuzV3uDueqqqzhJJge0/aM3vEToWU++Fh0TVOtkSXPCOvZlSGFiBl5toZkXan1NIseogV1100Xpoeh8UWqOJWmiaFD64/YrOwMA1u4/jd05RRiY0I5pPLbomND4mfKWWuoamu8OMylYWOdjqMwxK3FPmgywO0aScnQ7/osDKK5qmiw4GDvsz7yv9q5duxa/+tWvzIgkFSJ0wrNMvbKqsncjvP1FAIANmXmNDqFW+EOITJ9jNTzawmNeGMlRU+c1VT4ATEo51Pj/Mvk6mV3L/fvu8O5f5oVW6hqzqVpoYJ2PoTTHrMLdNOmgFd5esRFbFTNnRO94tIkMx/0f7jJ81g77M8+rvQAwZswYM+JIhwid8CxTr6zWV9/a+P8LU49hYEI7jOgdb5k/hCyhF3hgti285oWeHDuz+ZrGrV4rteC1lit9t+2Oy1BaF6abuibYl5OlPlLMzMdQmmNW4JrnNDCyEQMNNmKrjp8HXdwe8TGRTY5RFTxo+CvGDvuzYhunmWJ68r777rvcZJMB2v4J8zQ9LlcQoWdFPjVK96wKqFsZ80Zt4imnGbOFbJhpC895oSUHy1zWw461Mhjea3mzMA9SV/0bd/W9EAMT2mFSCp0/J219JJidj6E0x0Tjbpo0YLER+8PTDwrQtz8r8thlfzaSLRgje7mVaVSsgLR/PP/7N/rXCarP6vWbmfGm5zsXe93Ixv/3H/NW+EPwnkNOx4p5QaJXtc/0sNPfEjC/lquh6IK3PycroeafJPPcdzdNGphNfTI0aTNGzU/DM8kZGDU/DUOTNpu+jqvYn2OCrsoCaHJ91mp4Xe0FrE+jYgVa/eMPa2oPHuNtRO94PDake5Pf+6eLUFDGvMh0L6LmkJOxal7o6XXuA/0w12Aca2FXvB8R/neKLnj7c5pBpvRLZpB97nt8Pp88WzibKC0tRUxMDEpKShAdHQ2gIVrqqPlphu8uHT0oIFqqlu1c2d/z+DIRWb5ZeEQEP3PmDC644AKrRLYUmojgJFGXeY4HtTFfX1mCZq1iAn4XPOZ5R4eWfYzbhdXzgjQieEFZTYDztxbB48YqWNdyPRRdkJZttj4anBCtXQuWua/2/S0S1xFcA5YYFqJzxTkhF51WOgqaxWHFihX461//ylMsaaBJ12H0LO/xoDbmK3/cgTZ9bwGgHbeFZwoSmjYBdJtxp8M6L1i/RPX06v9ZvdeHD7fnSBvvR0Q8IkUXPFO18IJmPvJKlcNjo+aE7zfA3TRpwhLenne+rGBEly8LAwYMsFsERyAiP1vwmG8R1xBF2iq/CNI2zdp8BMl7TkifyoMnLPPCipApvFOB8EaEfIoueKZqsRpeqXJ4jTGnfL+5Pk060NqIRceuOV9yBeXmymG7lh0R4yF4zNdXnAVgnV/Exsw8ouemb/zRMak8eEE7L2jTaphBdn8a3vL564KnP6dV6I0NmlQ5PMeYU77f3JMmA2hiWIiOXXO+5Aqqr6+3WwRHIGo8+I/5tWt+xu13DLLE9FXv9WFlxk/M78t0hC8Cmnlhh6lD9ng/POUL1gWPVC1WQRKCQQ018zjPMeaU7zd300QAqY1YdC4fkvI7RUfA6/Phy4yfuE1SxV6dV1KFoopzaNc6AnHR4haA7t27cy/TLDI4VwbL0L9bW2HjTRnzUcP640qCsc+jf3bnFKGowjjqvR6yHOHTQtJ/NPOC1NSRll2IIT06MErdFJ7+bSLgJZ+aLnj4c+rBaw1iCZOgEBwugac5zSm58NxNE0dE2/aNyvcBqK7zBkQON+u/oGav5lW2Ft999x2uvPJKrmWawe5UOnoy3HlVPOZtyxHmS0KiC179Y1VqGNkg7T+aeUHa/rFL9mLKvX1sNxc5DavXKJ5rEI+5QVMG6bOy+8YpuD5NnBFt29cqP0YlzxFgzn9By16tkCvIh2TUqFFcyzODlX4hLDLM25aDx69PEDbejHTBs3+sSg0jEzT9RzMvSNtfXFUb0n5gorByjeK9BvGYGx3bRAoxp8nuGwe4J01CEG3bDy6/Q1QEXvhsH4Cmpg1W/wU9u3cwvH0j3n//fSmigstwBZZEhtX7cvHtuBuRfvws9/GmpwsrQh4EExcdAcCD/FK5j/BJoO0/mnlBexU+VP3ARGHVGiViDWIJk6AQPL9EmNNk941zT5oEITqXj3/5YWEe5JXyTRNAavf2943gFfZehg0TICb9gigZ0o+fFTLe9HTBu3+MUkF4ALxxZy+8cad+OqG/33I5ducUWZ6CgTb1A23/0cwLvdQ4RvU4HStScFi1RvGeY4pf1C294xo3Xf7opcoJNpGJSt0ig/+oHu5JUwgg4qomrd177JK9KK765aTLjM9PYmKiFBsnGa7A2i2Dni5EhjwI9t+ICxpPas8oPL0sA/7fk1b4n7H4nND2H+28UPpy/BcHAuamUT1Oxir/Q6vWKJ5zTK1vPB7APyeIMs+ApnGagucgQD5fSZHBf9QId9MUAoiwLdPavYMXZcXezmKHfvrpp6meF4UMV2DtlkFPF1aEPND6a3NE73h4vcDfluxt8n7wwYKZsUiCVuoHo3pp+49lXozoHY82keEBl0OM6nEqrHpgwao1itcc0+obZa48NqQ7hveMC5hnpCYyXuY0K/VnBtc851D8j6C9Xh/ioiM1M4970LBbp7EtK3ZvVpSB/481mdTH44sWLWKulydKH/DsV6fJoKcLkbIZmbfrvT5MSskkKsvMWDSCJOaNVr20/cc6LwZd3N72cSwaM3pgwao1inWO+X8/pGYV4I3V2v6pHgDrDuY12ejQuJiYdUexWn9mcDdNDiQ4C/T9C3ahtLpW16mP1ras2KvNWJJZfSWGDx9uolZ+iLLZO0kGPV3YKRttrBlRfjtmfE5o+491Xtg9hqzAav9Dq9YoFt2pfT/w9nnljQz+o6S4myaHoXX9tPKcdrTgx69PYDrWVOzVWidOsS3DVX8fDK2vxA8//ED1vEhkuAJrpwxGurBLNtGpiHiXp/UcTf+ZmRcyjGORWO37Z+UaRaM7ozAxetjp00aaPkkGvzvXp8lB0IQB8Gf1vly8NOIKpr8k/e3VwRHBvT6fEF+JqKgoajlFIsMVWLtkINGFHbKJTkXEuzy950j7z+y8kGEci8Jq3z+r1ygS3bF+PyjY5dNGkz5JBr87d9PkIFjD35tNK6GVHqDe6zOM99EuKhz9u7Wlqq9dO/l8K2RIDyFKBr0rvqS6sLp/aGPNiIrfxCv1A0n/8ZgXZvQk81Vwq1Nw6OnCTD/pvWukO9bvB6tim2m1jTR9UvuoFlL43bmbJgdh5mhSxLGmXth7haKKWtzwzhaqK6P79+/HgAEDuMrqoo7RFV9ZdUEy9hRE+u1YmfrBTl3IfhXc6hQcWrow009m+5hljbfKp02vbTV1XqIy7urbWYpNuuvT5CDMHE2KOtbUsrf7Qxvu/5ZbbuElnosOJOkZZNaF1tgLXldF++1Y5S9kly5kSCVEgpV+W2q6MNNPPPqYZY23wqfNqG2k/kw39YwTIR41Hp/PZ/8dPpspLS1FTEwMSkpKEB0dbbc4mtR7fRiatJkq/L1y9Lr95WFCd+nn6rwYNHkTiirOmZZDluCWoYwylrSO8xV93VK3A69NnGitcJQEH/v379ZWSEoZWjl412vHvCAdJ6LXFxqsMCMG68JMP/HqY6PvBw+ATtERmHZfXxSU11gyN4zapshl9H0Wr9N+q7+/XfOcg6AxSQDWXidOP35Wc8MEBF4ZNfKpcDdM4iG94nvT6L9ZJxQjar4edvififbrsmNe0FwFt9vnT8EK/7pgXZjpJ159TGKifOPOXhhyaQfNMnhD4mdFcgAwckBXaTblIWOemz17Nrp3747IyEhce+212L17t90iCUHrCDq2VThiWwWGALDyOjHPK7+JiYlmxXExgFRfs95NEiyJCyl2zAu70/jISrAuzPQTzz6WLbQEr3HRvUMrLuXwICROmpYtW4bnn38ec+fOxbXXXosZM2bg5ptvxuHDh9GxY0e7xeOO1vVTALbdbuF55XfcuHFmxXExgFRfj499VqwgLsTYMS/sTuMjK8G6MNNPvPtYptASvMaFTOMrJE6a3n33XYwePRqPPPIIevbsiblz56JVq1ZYuHCh3aIJQy1svdlQ9mbgmVLjX//6F1fZXJpCqq+daz6xUiwXHeyYF3an8ZGVYF2Y6ScRfWznd4E/Rm0DGi5uOGl8Of6k6dy5c0hPT8eECRMafxcWFobhw4dj586dqu/U1NSgpqam8eeSkhIADQ5lLuy8eGMXPL9sH4Cm9nQfgBdv7IGK8jLDcn73u9+5urAAEn1dEtne1YUk2DUveM3rUEJNF2b6KZT7WK9tAPDnId2wKPW46uckbVf0YNmdNp/D+emnn3wAfDt27Aj4/bhx43wDBw5Ufef111/3oUEf7j/3n/vP/ef+c/+5/xz+Lzs724oth8/xJ00sTJgwAc8//3zjz8XFxejWrRtOnDiBmJgYGyVzKS0tRZcuXXDy5Empwz+cD7i6kAdXF/Lg6kIuSkpK0LVrV8sySTh+09ShQwc0a9YM+fn5Ab/Pz89HXJx6MKyIiAhEREQ0+X1MTIw7CSQhOjra1YUkuLqQB1cX8uDqQi7Cwqxx0Xa8I3iLFi3Qv39/bNq0qfF3Xq8XmzZtwuDBg22UzMXFxcXFxSWUcPxJEwA8//zzeOihh3DNNddg4MCBmDFjBioqKvDII4/YLZqLi4uLi4tLiBASm6Y//vGPOHPmDF577TXk5eWhb9++WL9+PTp16kT0fkREBF5//XVVk52Ltbi6kAdXF/Lg6kIeXF3IhdX6cHPPubi4uLi4uLgQ4HifJhcXFxcXFxcXK3A3TS4uLi4uLi4uBLibJhcXFxcXFxcXAtxNk4uLi4uLi4sLAef9pmn27Nno3r07IiMjce2112L37t12ixRyTJ48GQMGDECbNm3QsWNH3H333Th8+HDAM9XV1Rg7dizat2+P1q1b4957720SsPTEiRO47bbb0KpVK3Ts2BHjxo1DXV2dlU0JOaZMmQKPx4Nnn3228XeuLqzjp59+wgMPPID27dujZcuW6NOnD/7zn/80fu7z+fDaa68hPj4eLVu2xPDhw5GVlRVQRlFREe6//35ER0cjNjYWjz32GMrLy61uiqOpr6/HxIkTkZCQgJYtW+KSSy7BpEmTAvKZuboQx7Zt23DHHXegc+fO8Hg8WLVqVcDnvPp+//79+PWvf43IyEh06dIFU6dOpRfWkmQtkpKcnOxr0aKFb+HChb7vv//eN3r0aF9sbKwvPz/fbtFCiptvvtn30Ucf+Q4ePOjLyMjw3Xrrrb6uXbv6ysvLG5954oknfF26dPFt2rTJ95///Mc3aNAg33XXXdf4eV1dna93796+4cOH+/773//61q1b5+vQoYNvwoQJdjQpJNi9e7eve/fuviuvvNL3zDPPNP7e1YU1FBUV+bp16+Z7+OGHfbt27fIdPXrU9/XXX/uOHDnS+MyUKVN8MTExvlWrVvn27dvnu/POO30JCQm+qqqqxmdGjBjhu+qqq3xpaWm+7777znfppZf6Ro0aZUeTHMtbb73la9++vW/t2rW+nJwc32effeZr3bq171//+lfjM64uxLFu3Trf3//+d9+KFSt8AHwrV64M+JxH35eUlPg6derku//++30HDx70LV261NeyZUvfBx98QCXreb1pGjhwoG/s2LGNP9fX1/s6d/7/9u4+tqnqjQP4t1vXzlG3Viut4MaLDDphaKFKRgkaWYZzEtRkRjK7OeMLOF6qRIdv4B8wMBqNYsC4RGciipqgohHI3CZkZo69dWyAHQHGjFk3AUunMzDa5/eH4f6om6TDtYXu+0lu0p1ztufc82Ttk3t3z8bJxo0bozir2Nfb2ysAZO/evSIi4vV6JSEhQb744gtlzOHDhwWA1NXVicjfv1RxcXHi8XiUMVu3bpXk5GQ5e/ZsZE8gBvT19Ul6erpUVlbKnXfeqRRNzEXklJaWyrx58/61PxAIiNlsltdff11p83q9otVq5dNPPxURkUOHDgkAaWhoUMbs2rVLVCqV/Prrr+GbfIzJy8uTxx57LKjtwQcflIKCAhFhLiLpn0XTSK39li1bxGAwBL1HlZaWyrRp04Y1v1F7e+7cuXNoampCdna20hYXF4fs7GzU1dVFcWax78yZMwCg/IPFpqYmDAwMBOXCYrEgLS1NyUVdXR0yMzODNixduHAhfD4fDh48GMHZx4aSkhLk5eUFrTnAXETSzp07YbPZkJ+fj7Fjx8JqtaK8vFzpP378ODweT1AuUlJSMGfOnKBc6PV62Gw2ZUx2djbi4uJQX18fuZO5ys2dOxdVVVXo6OgAALS2tqK2tha5ubkAmItoGqm1r6urw/z586HRaJQxCxcuhNvtxu+//x7yfGJiR/DLcfLkSfj9/kG7hptMJvz8889RmlXsCwQCcDqdsNvtmDFjBgDA4/FAo9FAr9cHjTWZTPB4PMqYoXJ1oY9Ct337djQ3N6OhoWFQH3MROceOHcPWrVvx7LPP4sUXX0RDQwNWrlwJjUaDoqIiZS2HWuuLczF27NigfrVajeuuu465GIY1a9bA5/PBYrEgPj4efr8fGzZsQEFBAQAwF1E0Umvv8XgwadKkQT/jQp/BYAhpPqO2aKLoKCkpQXt7O2pra6M9lVHpl19+wapVq1BZWYnExMRoT2dUCwQCsNlsKCsrAwBYrVa0t7fjvffeQ1FRUZRnN7p8/vnn2LZtGz755BNMnz4dLpcLTqcT48aNYy4oyKi9PWc0GhEfHz/oqaCenh6YzeYozSq2LV++HN9++y1qampw0003Ke1msxnnzp2D1+sNGn9xLsxm85C5utBHoWlqakJvby9mzZoFtVoNtVqNvXv34p133oFarYbJZGIuIuTGG2/ELbfcEtSWkZGBrq4uAP9fy0u9R5nNZvT29gb1nz9/HqdPn2YuhuG5557DmjVr8PDDDyMzMxMOhwPPPPMMNm7cCIC5iKaRWvuRet8atUWTRqPB7NmzUVVVpbQFAgFUVVUhKysrijOLPSKC5cuX48svv0R1dfWgS6SzZ89GQkJCUC7cbje6urqUXGRlZaGtrS3oF6OyshLJycmDPnjo3y1YsABtbW1wuVzKYbPZUFBQoLxmLiLDbrcP2nqjo6MDEyZMAABMmjQJZrM5KBc+nw/19fVBufB6vWhqalLGVFdXIxAIYM6cORE4i9jQ39+PuLjgj8P4+HgEAgEAzEU0jdTaZ2VlYd++fRgYGFDGVFZWYtq0aSHfmgPALQe0Wq1UVFTIoUOH5MknnxS9Xh/0VBD9d8uWLZOUlBT54YcfpLu7Wzn6+/uVMUuXLpW0tDSprq6WxsZGycrKkqysLKX/wmPuOTk54nK5ZPfu3XLDDTfwMfcRcPHTcyLMRaTs379f1Gq1bNiwQY4cOSLbtm2TpKQk+fjjj5UxmzZtEr1eL19//bUcOHBAFi9ePOSj1larVerr66W2tlbS09P5mPswFRUVyfjx45UtB3bs2CFGo1Gef/55ZQxzET59fX3S0tIiLS0tAkDefPNNaWlpkRMnTojIyKy91+sVk8kkDodD2tvbZfv27ZKUlMQtB4Zr8+bNkpaWJhqNRu644w756aefoj2lmANgyOPDDz9Uxvz111/y9NNPi8FgkKSkJHnggQeku7s76Od0dnZKbm6uXHPNNWI0GmX16tUyMDAQ4bOJPf8smpiLyPnmm29kxowZotVqxWKxyPvvvx/UHwgE5JVXXhGTySRarVYWLFggbrc7aMypU6dkyZIlotPpJDk5WYqLi6Wvry+Sp3HV8/l8smrVKklLS5PExESZPHmyvPTSS0GPpzMX4VNTUzPkZ0RRUZGIjNzat7a2yrx580Sr1cr48eNl06ZNw56rSuSiLU+JiIiIaEij9m+aiIiIiIaDRRMRERFRCFg0EREREYWARRMRERFRCFg0EREREYWARRMRERFRCFg0EREREYWARRMRERFRCFg0EVHUPProo7j//vsjHreiogIqlQoqlQpOpzNscTo7O5U4t912W9jiEFFkqKM9ASKKTSqV6pL969atw9tvv41o/VOC5ORkuN1ujBkzJmwxUlNT0d3djTfeeAPff/992OIQUWSwaCKisOju7lZef/bZZ1i7di3cbrfSptPpoNPpojE1AH8XdWazOawx4uPjYTabo3qeRDRyeHuOiMLCbDYrR0pKilKkXDh0Ot2g23N33XUXVqxYAafTCYPBAJPJhPLycvz5558oLi7GtddeiylTpmDXrl1Bsdrb25GbmwudTgeTyQSHw4GTJ08Oe84TJ07E+vXrUVhYCJ1OhwkTJmDnzp347bffsHjxYuh0OsycORONjY3K95w4cQKLFi2CwWDAmDFjMH36dHz33XeXvW5EdOVi0UREV5SPPvoIRqMR+/fvx4oVK7Bs2TLk5+dj7ty5aG5uRk5ODhwOB/r7+wEAXq8Xd999N6xWKxobG7F792709PTgoYceuqz4b731Fux2O1paWpCXlweHw4HCwkI88sgjaG5uxs0334zCwkLltmJJSQnOnj2Lffv2oa2tDa+99hqvLBHFKBZNRHRFufXWW/Hyyy8jPT0dL7zwAhITE2E0GvHEE08gPT0da9euxalTp3DgwAEAwLvvvgur1YqysjJYLBZYrVZ88MEHqKmpQUdHx7Dj33vvvXjqqaeUWD6fD7fffjvy8/MxdepUlJaW4vDhw+jp6QEAdHV1wW63IzMzE5MnT8Z9992H+fPnj+iaENGVgUUTEV1RZs6cqbyOj4/H9ddfj8zMTKXNZDIBAHp7ewEAra2tqKmpUf5GSqfTwWKxAACOHj36n+JfiHWp+CtXrsT69etht9uxbt06pZgjotjDoomIrigJCQlBX6tUqqC2C0/lBQIBAMAff/yBRYsWweVyBR1Hjhy5rCs+Q8W6VPzHH38cx44dg8PhQFtbG2w2GzZv3jzsuER05WPRRERXtVmzZuHgwYOYOHEipkyZEnSEczuBi6WmpmLp0qXYsWMHVq9ejfLy8ojEJaLIYtFERFe1kpISnD59GkuWLEFDQwOOHj2KPXv2oLi4GH6/P+zxnU4n9uzZg+PHj6O5uRk1NTXIyMgIe1wiijwWTUR0VRs3bhx+/PFH+P1+5OTkIDMzE06nE3q9HnFx4X+L8/v9KCkpQUZGBu655x5MnToVW7ZsCXtcIoo8lURrO14ioiipqKiA0+mE1+uNSLxXX30VX331FVwuV0TiEVF48EoTEY1KZ86cgU6nQ2lpadhidHV1QafToaysLGwxiChyeKWJiEadvr4+ZZ8lvV4Po9EYljjnz59HZ2cnAECr1SI1NTUscYgoMlg0EREREYWAt+eIiIiIQsCiiYiIiCgELJqIiIiIQsCiiYiIiCgELJqIiIiIQsCiiYiIiCgELJqIiIiIQsCiiYiIiCgE/wNSPDC+CvSWPwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2836,14 +1621,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Network average firing rate: 7.1 Hz\n" + "Network average firing rate: 7.16 Hz\n" ] } ], @@ -2854,7 +1639,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -2863,13 +1648,13 @@ "Text(0.5, 0.98, 'U')" ] }, - "execution_count": 21, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHgCAYAAAC/0ofgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3wU1drHfzNb04HQIfQOYkFQ7AqCePFer7x69Xrt7arX3u+1C9JEujQpUqRJ7z20UAIYIARCIJBCSEhv22fm/WOzZXZnZmf7JjnfzwfdnTkzc/LsmXOe85znPA/FcRwHAoFAIBAIhHoIHe4KEAgEAoFAIPgKUWQIBAKBQCDUW4giQyAQCAQCod5CFBkCgUAgEAj1FqLIEAgEAoFAqLcQRYZAIBAIBEK9hSgyBAKBQCAQ6i1EkSEQCAQCgVBvIYoMgUAgEAiEegtRZAgEAoFAINRbiCJDIBAihm+//RYURaGkpETwfL9+/fDAAw+EtlIEAiGiIYoMgUAgEAiEegtRZAgEAoFAINRbiCJDIBAIBAKh3kIUGQKBQCAQCPUWosgQCAQCgUCotxBFhkAgEAgEQr2FKDIEAqFeQVFUuKtAIBAiCKLIEAiEiEGr1QIA9Hq94HmdTmcvQyAQCABRZAgEQgTRsWNHAEBmZqbbOZ1Oh7y8PHsZAoFAAIgiQyAQIoghQ4ZArVZj1qxZYFmWd27u3LmwWCwYMWJEmGpHIBAiEYrjOC7clSAQCAQbY8aMwZdffom7774bf/3rXxEdHY2UlBQsX74cw4YNw7Zt20DTZA5GIBCsEEWGQCBEHMuWLcOMGTNw9uxZWCwWdO7cGc888ww+++wzaDSacFePQCBEEESRIRAIBAKBUG8h9lkCgUAgEAj1FqLIEAgEAoFAqLcQRYZAIBAIBEK9hSgyBAKBQCAQ6i1EkSEQCAQCgVBvIYoMgUAgEAiEegtRZAgEAoFAINRbiCJDIBAIBAKh3kIUGQKBQCAQCPUWosgQCAQCgUCotxBFhkAgEAgEQr2FKDIEAoFAIBDqLUSRIRAIBAKBUG8higyBQCAQCIR6C1FkCAQCgUAg1FuIIkMgEAgEAqHeQhQZAoFAIBAI9RaiyBAIBAKBQKi3EEWGQCAQCARCvYUoMgQCgUAgEOotRJEhEAgEAoFQbyGKDIFAIBAIhHoLUWQIBAKBQCDUW4giQyAQCAQCod5CFBkCgUAgEAj1FqLIEAgEAoFAqLcQRYZAIBAIBEK9hSgyBAKBQCAQ6i1EkSEQCAQCgVBvIYoMgUAgEAiEegtRZAgEAoFAINRblOGuQLBhWRYFBQWIi4sDRVHhrg6BQCAQCAQZcByH6upqtG3bFjQtbndp8IpMQUEBkpKSwl0NAoFAIBAIPpCXl4f27duLnm/wikxcXBwAqyDi4+MDeu9z586hb9++Ab0nwR0i5+BDZBwaiJyDD5Fx8AmVjKuqqpCUlGQfx8Vo8IqMbTkpPj4+4IpMUVERBg8eHNB7Etwhcg4+RMahgcg5+BAZB59Qy9iTWwhx9vUDtVod7io0Coicgw+RcWggcg4+RMbBJ9JkTBQZP2jVqlW4q9AoIHIOPkTGoYHIOfgQGQefSJMxUWT84OTJk+GuQqOAyDn4EBmHBiLn4ENkHHwiTcYUx3FcuCsRTKqqqpCQkIDKysqg+MhEmmbaECFyDj5ExqGByDn4EBkHn1DJWO74TSwyfjBv3rxwV6FRQOQcfIiMQwORc/AhMg4+kSZjYpEhEAgEAoEQcRCLTAgYPXp0uKvQKCByDj5ExqGByDn4EBkHn0iTMbHI+IFer0dUVFRA70lwh8g5+BAZhwYi5+BDZBx8QiVjYpEJAb/88ku4q9AoIHIOPkTGoYHIOfgQGQefSJMxUWT84K9//Wu4q9AoIHIOPkTGoYHIOfgQGQefSJMxUWT84NSpU+GuQqOAyDn4EBmHBiLn4ENkHHwiTcZEkfGDFi1ahLsKjQIi5+BDZBwaiJyDD5Fx8Ik0GRNFxg80Gk24q9AoIHIODOtWLcH1ggLBc0TGoYHIOfgQGQefSJMxUWT84PLly+GuQqOAyNl/vh73EaKa/Ijde94VPE9kHBqInIMPkXHwiTQZE0XGDx544IFwV6FRQOTsP80TS6BSmtC23Z+C54mMQwORc/AhMg4+kSZjosj4wZIlS8JdhUYBkbP/UGAkzxMZhwYi5+BDZBx8Ik3GYQ2IxzAMvv32WyxduhSFhYVo27YtXnzxRXz55ZegKAoAwHEcvvnmG8ybNw8VFRW4++67MWvWLHTv3l3WM4IZEI9lWdA00QWDDZGz/0yf8xz6dE8BAAx5yN0sTGQcGoicgw+RcfAJlYzrRUC88ePHY9asWZgxYwbOnz+P8ePHY8KECZg+fbq9zIQJEzBt2jTMnj0bx44dQ0xMDIYPHw6DwRDGmlv58ccfw12FRgGRs/+YKJXkeSLj0EDkHHyIjINPpMk4rBaZkSNHolWrVpg/f7792KhRoxAVFYWlS5eC4zi0bdsWH330ET7++GMAQGVlJVq1aoVFixbh6aefdrun0WiE0Wi0f6+qqkJSUhKxyNRjiJz95/tf38LdXXYAIBaZcELkHHyIjIMPscg4cdddd2HPnj24ePEiAOD06dM4dOgQRowYAQC4cuUKCgsLMXToUPs1CQkJuOOOO3DkyBHBe44dOxYJCQn2f0lJSQCA7OxsTJgwAUaj0Z7wavTo0SgoKMD8+fORmpqKHTt2YO3atcjIyMC0adNQVVXFK1tWVoaZM2fizJkz2LhxI1588UWcOnUKc+bMQXFxMa+sTqfDpEmTkJmZiVWrVmHPnj1ISUnBokWLkJeXxyvLMAzGjh2LnJwcLFmyBIcOHUJycjJWrFiBrKwsTJw4EQaDgXdNYWEh5s2bh9TUVGzfvh3r1q1Deno6pk+fjsrKSl7ZiooKzJgxA2fPnsX69euxdetWnDx5EnPnzkVRURGvrF6vx6RJk5CVlYWVK1di7969OHz4MBYvXozc3FyMGTMGLMti9OjRYFkWY8aMQW5uLhYvXozDhw9j7969WLlyJbKysjBp0iTo9Xre/YuKijB37lycPHkSW7duxfr163H27FnMmDEDFRUVvLKVlZWYPn063n//faxbtw7bt29Hamoq5s2bh8LCQl5Zg8GAiRMnIisrCytWrEBycjIOHTqEJUuWICcnB2PHjgXDMLxr8vLysGjRIqSkpGDPnj1YtWoVMjMzMWnSJOh0Ol7Z4uJizJkzB6dOncKWLVuwceNGnDlzBjNnzkRZWRmvbFVVFaZNm4aMjAysXbsWO3bsQGpqKubPn4+CggJeWaPRiAkTJuDy5ctYvnw5kpOTcfDgQSxduhRXr17FuHHjYLFYeNfk5+dj4cKFOHr0KHbt2oXVq1fjwoULmDx5MmpqanhlS0pKMHv2bDCcwv6OpKWlYdasWSgtLbWXHTZsGKqrqzFlyhRkZGRgzZo12LlzJ44dO4YFCxa41dtsNmP8+PHIzs7GsmXLcODAARw4cADLli1DdnY2xo8fD7PZ7PauLViwAMeOHcPOnTuxZs0aZGRkYMqUKaiuruaVLS0txaxZs5CWloZNmzZh8+bNSEtLw+zZs1FSUsIrW1NTg8mTJ+PChQtYvXo1du3ahaNHj2LhwoXIz8/nlbVYLBg3bhyuXr2KpUuX4uDBg0hOTsby5ctx+fLlgPcRW7Zs4fURw4YNI31EEPqI9PR0ex/x9ttvkz7Chz4iLS0NmzdvxqZNmwT7iNGjR9v7iA8++CAkfcSGDRsgh7BaZFiWxX//+19MmDABCoUCDMNgzJgx+OKLLwAAKSkpuPvuu1FQUIA2bdrYr3vqqadAURRWrlzpds9QWmRyc3PRoUOHgN6T4A6Rs/98Ofd9PNhtEwDAZJmKEcNG8s4TGYcGIufgQ2QcfEIl43phkVm1ahWWLVuG33//HadOncJvv/2Gn376Cb/99pvP99RoNIiPj+f9CxbJyclBuzfBAZGz/1BOFplz54+7nScyDg1EzsGHyDj4RJqMleF8+CeffILPP//c7uty00032U18L7zwAlq3bg0AKCoq4llkioqKcMstt4Sjyjy6du0a7io0Coic/eeB7uvtnyv1NW7niYxDA5Fz8CEyDj6RJuOwWmR0Op2bw5BCoQDLsgCAzp07o3Xr1tizZ4/9fFVVFY4dO4bBgweHtK5COC9hEYIHkXNgsdCU2zEi49BA5Bx8iIyDT6TJOKwWmcceewxjxoxBhw4d0LdvX/z555/4+eef8fLLLwMAKIrC+++/j9GjR6N79+7o3LkzvvrqK7Rt2xaPP/54OKsOACguLg53FRoFRM4BhnJXZIiMQwORc/AhMg4+kSbjsCoy06dPx1dffYW33noLN27cQNu2bfHGG2/g66+/tpf59NNPUVtbi9dffx0VFRW45557sH37dmi12jDW3Mptt90W7io0Coic5TNm3GegFCz++8lE0TKcwt0QS2QcGoicgw+RcfCJNBmHdWkpLi4OU6ZMQU5ODvR6PS5fvozRo0dDrVbby1AUhe+//x6FhYUwGAzYvXs3evToEcZaO9i4cWO4q9AoIHKWz52D/sAdA9bi+3Efi5YRMMgQGYcIIufgQ2QcfCJNxiRqkB+89dZb4a5Co4DI2XtYtUX8JOUecYHIODQQOQcfIuPgE2kyJoqMH0yaNCncVWgUEDl7D8WJKzJCATmJjEMDkXPwITIOPpEm47AGxAsFwUwaSSBEGnv2WrdFpp64H59/usDtOAAcOv0Yvvlgiv27yWiEWqMJWR0JBAJBDvUiIF59xxZamRBcIkXO5cWFmD/zy3BXQxZKhbhFhqJZ++c5S/+JNVuH44svPghFtRo9kdKWGzJExsEn0mRMFBk/eO2118JdhUZBpMj5mSM78b/eo/DyIvEdQZECTTGi5ziVw9u3W9tjaJmQB2VSTCiq1eiJlLbckCEyDj6RJmOiyPiB3IRWBP+IFDl3OFWEdZ++gXIkhLsqHqGdrC6uKBTuSo4G+mBWh1BHpLTlhgyRcfCJNBkTRcYPBgwYEO4qNAoiRc6v586D4YtSvLF9Sbir4hEhZcUGTbufM6mCWRuCjUhpyw0ZIuPgE2kyDmtAvPpOUVFRuKvQKIgUOVf+y6oAKEdGVlRLISgJi4zQspPUUhQhcERKW27IEBkHn0iTMbHI+IHJZAp3FRoFkSZnSi2uJEQKlEJiaYl2dwRWgigyoSDS2nJDhMg4+ESajIki4weRlgG0oRJxclZEfsQCoeUjG0ohRYaSCKBHCBgR15YbIETGwSfSZEwUGT/Yv39/uKvQKIg0OVN05CsyCglFpn+HwwLliSITCiKtLTdEiIyDT6TJmCgyfvCvf/0r3FVoFEScnJX1W5ERgqbMQaoJwZmIa8sNECLj4BNpMiaKjB/MmDEj3FVoFEScnBXhroBnpJaWhCAWmdAQcW25AdJYZLzghZmY/8ISbF61OuTPjjQZk11LfvDll/Ujymt9J9LkzNUDRcZbi4waxiDVhOBMpLXlhkhjkbE+qjcAIH/XaczfOgO6+Eq8M+1/IXl2pMmYWGT8INLCNDdUIk7OERpzxTltmlRAPCGiWF2gq0MQIOLacgOkscmYpfrBoO0D2jQ4ZM+MNBkTRcYP3nnnnXBXoVFA5CyPbyd+ZP/surTEsu6v+qz5jlQLZGkpNJC2HHwam4w5OvQm4kiTMVFk/GDx4sXhrkKjgMhZHnqnlWKlku+8azG7Z7e+biy3f6bpyIoL0VAhbTn4EBkHn0iTMfGR8YMHH3ww3FVoFBA5y4N2ClKlVLpaWPg7rS6dPw8l61B2iEUmNJC2HHwauoyX/DwdlvPV4BR3AAAoUGApMygudMN5pMmYWGT8ICsrK9xVaBQQOctDYXH4xbAs39xMuSgyu47tQI1S67hWIjcTIXCQthx8GrqMLWlR0CnuRHXCBZS1OA6D9gZKWx1BTfylkNUh0mRMFBk/iIqKCncVGgVEzsD8X6Zg/HjpnQK0k7LCCfjEOFNQfgOM0z5yhZsFhxAMSFsOPg1dxrroLgAAY1QxWIUR1U0uAAAM0ddDVodIkzFRZPwgMTEx3FVoFDRGOf8y4QesXTTf/r1lh99w+8DlGDf+C9FraMphkaFdcy1R/K8m1gKFyeE34+pTQwgOjbEthxoi4+ATaTImiowfpKWlhbsKjYJIkTPHUZ4LBYCfv/kcPW9fBHVzR9Cp6OgqAECruHyJKx318xQQj6MpgHO8/kSRCQ2R0pYbMkTGwSfSZEwUGT947LHHwl2FRkGkyJljQ7PNscetyQCAqDrlxZlKWtyhj5NUZPg+MhytAJzizhj0sd5XlOA1kdKWGzJExsEn0mRMFBk/+PXXX8NdhUZBxMiZDU0kvKj4Yvvn86dP8c6ZJd5Yg9KxVOTJIkMpOFDOAfRAnH1DQcS05QYMkXHwiTQZE0XGDyItTHNDJVLkrHLa3ngpPT0kzzy4ZyvvO02JKxxmheN1do7sO2HKO1CpXePEUKAo3yMBE3wjUtpyQ6ahy5gDB7OyOqx1iDQZE0XGDyItTHNDJVLkTLEORebkod3Be5DTElaCgr+lUsrSwrOwOJUb0H+re1kKULCOnUpuzsGEoBApbbkh09BlrIs5h4rmfwqeO75/b0jqEGkyJoqMH3z88cfhrkKjIFLk7KzIFF3PC9pzaMaxRJTYg7+0lBBbInqdyskPRkwxYRirkkRTDBLLbtiPU14mmST4RqS05YZMQ5exLq5M9NzJo8IKTqCJNBkTRcYPpk+fHu4qNAoiRc7OioyZDWLcFafnUEp+VuqOLSSCXjn587pabnbvqsb33xXhl5nFyM83g6ZZcLTTUhSxyISESGnLDZnGLOPScvcNAsEg0mRMUhT4weOPPx7uKjQKIkXOziHAKWUQB37OaXeUwhuFie/zcvJ4CgYMugt//FGB2bMcs7gDB6rx3CcViHF6+xVePYfgK5HSlhsyjVnGDMN5LhQAIk3GxCLjBydPngx3FRoFESNnztmZNohLMQHaHZWcug8AsGkjf5ZWXs7g4umLMCqccjOpzPjyl68D8lyCOBHTlhswjVrGbGhiXUWajMOqyHTq1AkURbn9e/vttwEABoMBb7/9NhITExEbG4tRo0ahqKgonFXm0bp163BXoVEQiXJWBHMpRiJejdkibkR17cJKayoAANeuuVtbtq88AM4lJs2gzhtkV5HgG5HYlhsajVnGlIfUJIEi0mQcVkUmNTUV169ft//btWsXAODJJ58EAHzwwQfYtGkTVq9ejf3796OgoABPPPFEOKvMQ6kkK3OhIHLk7DDbUgjiUkxNW9FTen20/XNRYSF+nPBfXL2cba0Ty5eTxWLGhbNnRe/FUfzyaoVRpCQhUEROW264NG4ZhyZoZ6TJOKyKTIsWLdC6dWv7v82bN6Nr1664//77UVlZifnz5+Pnn3/GQw89hAEDBmDhwoVISUnB0aNHw1ltO1euXAl3FRoFESNnp7grFB28kP4mVanoOaXTkta2jZ/gjttX4lDy54JlaYrD1etXRe9Fubz+KpKmIOhETFtuwDR0Gcex4gkb6RBZZCJNxhHjI2MymbB06VK8/PLLoCgKJ0+ehNlsxtChQ+1levXqhQ4dOuDIkSOi9zEajaiqquL9Cxb33Xdf0O5NcBApcuYQGkVGmXhV/BztsAQldUsBALTpbF2vdg5wBwBKcLh4cb3ovegQ5Y4iOIiUttyQaegyjoZa9BwVIh+ZSJNxxCgy69evR0VFBV588UUAQGFhIdRqNZo0acIr16pVKxQWForeZ+zYsUhISLD/S0pKAgBkZ2djwoQJMBqN9mA+o0ePRkFBAebPn4/U1FTs2LEDa9euRUZGBqZNm4aqqipe2bKyMsycORNnzpzBxo0b8fXXX+PUqVOYM2cOiouLeWV1Oh0mTZqEzMxMrFq1Cnv27EFKSgoWLVqEvLw8XlmGYTB27Fjk5ORgyZIlOHToEJKTk7FixQpkZWVh4sSJMBgMvGsKCwsxb948pKamYvv27Vi3bh3S09Mxffp0VFZW8spWVFRgxowZOHv2LNavX4+tW7fi5MmTmDt3LoqKinhl9Xo9Jk2ahKysLKxcuRJ79+7F4cOHsXjxYuTm5mLMmDFgWRajR48Gy7IYM2YMcnNzsXjxYhw+fBh79+7FypUrkZWVhUmTJkGv1/PuX1RUhLlz5+LkyZPYunUr1q9fj7Nnz2LGjBmoqKjgla2srMT06dPx888/Y926ddi+fTtSU1Mxb948FBYW8soaDAZMnDgRWVlZWLFiBZKTk3Ho0CEsWbIEOTk5GDt2LBiG4V2Tl5eHRYsWISUlBXv27MGqVauQmZmJSZMmQafT8coWFxfzLTIw48yZM5g5cybKysp4ZauqqjBt2jRkZGRg7dq12LFjB1JTUzF//nwUFBTwyhqNRkyYMAGXL1/G8uXLkZyc7NamLRaH8kLRLPLz87Fw4UKwTorIhQsXwLrkU6IpFn167xN9V9y9aoApU6YgIyMDa9aswc6dO3Hs2DEsWLDArd5msxnjx49HdnY2li1bhgMHDuDAgQNYtmwZsrOzMX78eJjNZrd3bcGCBTh27Bh27tyJNWvWICMjA1OmTEF1dTWvbGlpKWbNmoW0tDRs2rQJmzdvRlpaGmbPno2SkhJe2ZqaGkyePBkXLlzA6tWrsWvXLhw9ehQLFy5Efn4+r6zFYsG4ceNw9epVLF26FAcPHkRycjKWL1+Oy5cvB7yP2LJlC6+PePXVV+1lSR8RuD4iPT3d3kdMmDAhbH3EnDlzcOrUKWzZsgUbN24MSh+h4MSHbRoKjB492t5HHD16FLt27cLq1atx4cIFTJ48GTU1Nbz7l5SUYPbs2UhLS8PmzZuxadMmpKWlYdasWSgtLeWVra6uxpQpUzB58uSQ9BEbNsjz26M4jgvNfi0PDB8+HGq1Gps2bQIA/P7773jppZdgNPLX7QcNGoQHH3wQ48ePF7yP0WjkXVNVVYWkpCRUVlYiPj4+oHVmGAYKRWjWJBszkSLngxvvhSm2AACQdeom/Pvj9UF5zp69XR1fWBpDhmbZjzEWBYYNuwgA2LarF9QKq2VoyEOX8cWPn2DonWsd9T0+DPcM3IGHhwqbgb/58S3ce8d23rEhD10O5J9CcCFS2nJDpqHLeP5X05GnEF5+ji6NxafTgx+sLlQyrqqqQkJCgsfxOyIsMjk5Odi9e7d9tgJYvaJNJhMqKip4ZYuKiiQ9pjUaDeLj43n/gsXYsWODdm+Cg0iUswKh8SdRl3XlfacVDh8ZyuK6c4r/OishvbMqNi68+VoaI5HYlhsaDV3GColhW8paE0giTcYR4Xq8cOFCtGzZEn/5y1/sxwYMGACVSoU9e/Zg1KhRAIDMzEzk5uZi8ODB4aoqj0hLnNVQiQQ5z5v6JXp1cSgGFEJjyGQoA+875bQaxLEKoC5r9euvvYSM7EwUXCyvqx9QVpmOOwcCNA2wLjpN//5a9OtxLIg1JwgRCW25odPQZSypyAgsFweDSJNx2C0yLMti4cKFeOGFF3hbuhISEvDKK6/gww8/xL59+3Dy5Em89NJLGDx4MO68884w1thBpCXOaqhEgpxXde0FDoDZbFVgaCpEIf0V4oH3WMoROO/Eic04vPcIFv9WjsW/leO338px5HA6KIpCu3buAfY0GgoKiXsTgkMktOWGTkOXsZTVJVSKTKTJOOwWmd27dyM3Nxcvv/yy27nJkyeDpmmMGjUKRqMRw4cPxy+//BKGWgrzwgsvhLsKjYJIkHPib5vx7JETKLhuQt++Wrz4eHu/71laUoJTk0eBZdQYPm6XYBmTUjy2C8s4Xl+Vula0nErl3rmZTBxoKiLc4xoVkdCWGzoNXcZmVnxZWx0iRSbSZBx2i8ywYcPAcRx69Ojhdk6r1do9vmtra7F27dqIiii4Z8+ecFehURBuOV+/fh3r1q1C/jUTWBY4e9aAGYvS/L7vyglfgR6SD+WwbKyZJZyEzeyURsAV1ilmhJDLPkVZk0VmZ7vfw2ZZIoSWcLflxkCDl7HE/hxO3QpzX5kc9CpEmozDrsjUZ4SUL0LgCbec33z9OZhckrFdyatCdna2X/d13jBYWJBj/1xd2cL+mabdIwjPnvkO8nJzwTqlMqiucV/qKr5RhdNnDG7HAaLIhItwt+XGQEOXMSfhn0dRLMyqm4Neh0iTMVFk/ECv14e7Co2CcMs59YRwmP+zEuH/5aCgY+yfzU4hA5wVFKoukq/zJKx7763YtH48zyJz4bzwElR1lbAfDFFkwkO423JjoKHLWEqRQYh89yJNxkSR8YPSUvFQ8oTAEW45a0TWnV1jHHmLwqlD0nDOO6Ic2LJssy6JJKNii8Aynl9fo1G403vmn029qCkhUIS7LTcGGrqMpaYgxdG5YGnx5ehAEWkyDruzb33m5puDb8IjhF/OSnVwFJlO8Q6LjoZyKCWuisylzEywrIK3y6iSViJWRl4Vo8m921OpKAwZEut23GzSyKw5wVfC3ZYbAw1exk7mWYvFgkOHDuHq1ato3ry5NXVAkwwAjwS1CpEmY2KR8YPNmzeHuwqNgnDLmVYKR7D0V5GhOlfYPztvLHJWZCgKOLJ/OziXLZc0zYBjPO9QMBrcFRlK5DKaJtuxg02423JjoKHL2HlpaePGjdi/fz9ycnJw8uRJLFq0CHoq+NaSSJMxUWT84M033wx3FRoF4ZZzy6ZNBI/369fPr/tSrcvsnxW0Q7tQuSgtBUX5gEuCR5q2gJNhkamtdV8zN5k4/Pqr49lc3b1pmkGEZCxpsIS7LTcGGrqMubqpjtFoRHp6Ou9ceXm535sQ5BBpMiaKjB/8/PPP4a5CoyDcck5skiB4vF27dgF7Rqt2afbPtItPTjNljVt5LVcDTo6PjEnY+c9ZYWEZq8WJojls2r5OTnUJPhLuttwYaCwyLigoEJx4nD9/PujPjjQZEx8ZP4i0MM0NlfDLWdhKQdPezwOWf/UPtFOl47zpbnR7yOlEn2v2jzqFGc6qU4cB+9ycfbWcDhyrtX+nKOHwEga9ZwuLQunY4n320mn8FU94vIbgG+Fvyw2fBi/junlOXFyc4OmkpKSgVyHSZEwsMn4QaWGaGyrhlrPYcgsl5mwiQZv+J2C+x4A+iftlX6NUukfyVChZnn4ltiJUXS1skUlPF44vo7MIHycEhnC35cZAQ5bx5cuXMW31XEyaNAkrVqwIWz0iTcbEIuMHb7zxRrir0CgIt5xNnLATrC+KDJNo/b+5s5SlxLMVRaliYZFhbRFDV8u/lmVp0DQLC+eel4kQOMLdlhsDDVXGZrMZDz30EHJzcwEANTXuS86hItJkTCwyfrB27dpwV6FREG45cxC2aviytGSD0bhvdd6zZaPs6xU061dWFdeAeLa8TZQffxPBM+Fuy42Bhirj5ORkuxITbiJNxqTX8oOBAweGuwqNgnDLWSxYpi8WGRvOfik2Lpw8Kn6Bi/GFVjDuB70gP9+M8nKrpam2pqk9SjBHC281JwSGcLflxkBDlXE4l5JciTQZE0XGD65fvx7uKjQKwi1nMR8ZfywyHO3u92LSVQOAsKXFJVO1c3A8X7FtzaZBg2PrLDKhSZ7baAl3W24MNFQZKxSRM8mINBkTRcYPGIYEEAsF4ZYzRwXO2ddxsfs9tbbElCLPc8Y1eN0jjwjvYJDCeXmJs2/BDk2ulsZKuNtyY6ChyliplO/SenTf3iDWJPJkTBQZP+jUqVO4q9AoCLecxXYETZgwIaDPae5FjhSF0mIPjAUATz4pHOtGCrsiw1Hg6rZ3Kyl3SxEhcPjSlhdPvRfLZ9+Bgvz8wFeoARLu/iISOJFyLKj3jzQZE0XGDw4ePBjuKjQKwi1njhM26Z48cSKgz0m8+TgAQMF5tvSoVGaeh0yHjt7vNuJbZKyzPSVHFJlg4m1bzsrIQLubCtCyRwmWTPs2KHVqaIS7vwgWZWVlngsBSE1NRVlVbVDrEmkyJtuv/eCZZ54JdxUaBeGWc7ek1tglcLy8uCigz+ESrUrE9u1F2HfwOrQaBUaNisOtfZqCjpa+lqIoqFQKmM3yTb6ffXodffpoodffgMnIQaGy4Pl3/MsfRZDG27ZcW11i/0wr3B3ECe6Eu78IFnJ98oqKimSlL/GHSJMxscj4wS+//BLuKjQKwi3njp1ao00bd53fYAhw8DiVAVOmTMGsuVdx4bwRaWk6fPVVEZ5/9RJ++D4Pn39+HR9+WID33yuwFtfwlQ6VyjtnQIOBw6lTepw/X4PL2bW4lGWEkiIB8YKJt23ZxDgsZBRFFBk5hLu/CBYqlXyrKxVkRSbSZEwsMn4QaWGaGyrhljNDs9Bo3Jd7TBb5Pi02KFYJjhYfkGZP+M7tWFm5BUeO8INfsSyHZm0LecdUKv86L5YFwBJFJph425ZryquAKOtnBVFkZBGI/mLxp39BTHwONFHPYORH/wtArfynadOm8gsHWZEJd5/sCrHI+EGkhWluqIRbzgoOUKvdFRkL4/3AQjHSs6rM6xWy7mMyuXsgq9X+v84co/P7HgRxXNvyNQ8BzjinTWQKCQWY4CAQ/UW7Ry6gyV16mNhVAahRYPjf/+QrVBQb3K3a4e6TXSGKjB+8++674a5CoyDccqZACSoJFosPigwbmBQARiNfkdm8uQrFxe5KyK23ajFtelvZ9+VIrqWg4tyWp339ES6e+ytWTBQP915bXWn/rCHLfrKQ219cOZOGipISt+NLPn3E/lnTxvuwBsGiRYsW6NfhTlllFVxwh/Zw98muEEXGDxYtWhTuKjQKwi1nDpygRYYJoyKTlqbnfV+9qsKtjEoF/PvNRKiU8uPdcBbi7BtMnNty/9uOgtVUo8WA3aLldTrH76ylyW8jBzn9xcEFc3Dt9Ic4+/tzbufiOzp2B3ECEbjDyYtD5FllFFxwvUbC3Se7Qnxk/GDo0KHhrkKjINxyZkEJKjJmXxQZRu30WQVO4XDmvH5d/tbnQwdrcf/9sfbvQrFuBgyIxo0iCyZPdp91isEwZLAMJs5tmZKxzd7COtoETZaWZCGnv6jN2QzV/TlAO/dzFrQAUGr9ogjOUuv0l94AbaDR4qFb8NRr8hMwxsCCZs2aedyKrfDSRjHzi6/Q/OINlN7UAW9961lZCnef7AqxyPjBhQsXwl2FRkG45RwNLdQCzr6+KDJw8pGhLfw91TXV8qPq6vXWHUe/LyvH8eM6QUXm7FkDvvmmCGVl8rdksxbrwPnllC+wYt19+HHOh7KvJXiG15YZxzxy/bQXBZeYLAaHRYb4yMhDTn9hUTtkX5CTwzvHOC2v0orgRLo26a7BwOah6MApr64rU2bLivBLiUXxFKH1nxkoaaNFy2NnZJUPd5/sCrHI+EFMTEy4q9AoCKWcOZa1Z4BmLBY8uXEOOic1F7bImP1z9uX8SPp49KgOR49KzxZtuZS8galTZNolXkaLhGtokXANwM++VJEgAK8tMw6HzLh+ByHkjVFcmI6kftbPmubBDXLWUJDTX+jNLW2bwXBu5xq0fc2hsLMWh+KvaaJHMGFY+e/owd178Ou22bhx44bnwhbvUgicvfMmAEBFkyayykfa2EcsMn7QrFmzcFehURAqOV+/dAEP7/gdf980GwDw6S9fIaXJXdh9vhK7d9W4lTd5EXzOjpOPDKup4p3yXa0JHGxd3BJaSZaYggGvLTPuO0s2/r6U9/22oSn2z016VLoWJwggp79w1h/Ks9P554LsKMvDC8vJqfUnwXLy+hyG8S1Ct1mmP12kjX1EkfGDM2fkmeEI/hEqOc/eMgvp2n44EnsnLmekIZrR4Ncxn6HD1i2C5S0WVjQzthjmhKtuxxKyHwXgVZ8WNGw7sSwBckom8OG1ZQFF5vLZP0NYm4aJrP7CSVnhWBelnY3MFPBGBQdaLa+TOH4hNah1ibSxjygyfjBixIhwV6FRECo5a5kotL1RiOblpTi+bxva5hejTZur2JyVJXqNyeRdUDxO5b6F9jRV4HVdgwVDFJmg4tyWOYu7IsN58Lu6nJkZ8Do1NGT1F05yVij5Vg7OxSJz6fz5gNRLEE7+0lKurgZ5eXmyyq45tBE1Ne5W5EARaWMfUWT8YMGCBeGuQqMgVHJOKKnBsm8+wOr//gdFFcVQRxlQ8LS0iVav938NnakLXnX0SPh9IGwWGaXRh2Uzgkec2zInYJHxZNnfuW5FoKvU4JDTXzDOSzQuOYxYl9/lz83LAlIvYeSbYa/kX/QqdtXSpUs9F/K+GgAib+wjiowfRFqY5oZKqOQcpXNYSyycGdCacOSItENtIPItsazV577Ki11LwcJc5ySYUF3loSTBF5zbsqAi46FHrimVv5W+sSKnv2Aph8bomoyRNfO/V5XkB6ZigsjXIFTwzvqblpYmu6y327UjbewLuyJz7do1/Otf/0JiYiKioqJw00034cSJE/bzHMfh66+/Rps2bRAVFYWhQ4ciS8LUH0oiLUxzQyVUcmaUShR/ZEbZa2ZwFA0TpYTBIK1cBMIiw9Ztw/UmcF2wMNuXlhyd5tVLl8JVnQaHc1tmGffuV+lhu68FxFLmCTn9hbP6oHD9GSj+b8BRvjnOysKLpSUFvJvoeNM3Kb1UBSJt7AurIlNeXo67774bKpUK27ZtQ0ZGBiZNmsRLjjVhwgRMmzYNs2fPxrFjxxATE4Phw4cHPvOwD3zyySfhrkKjIFRyVsTrYO7KwXArBwXHgWUV6N9fK3mNt+1QW9nZ/jnrohGzZ5Vi3bo/ceWKCYoICIZgMVs7S4vTILv7+PZwVafB4dyWWQEfGaVCeoZOUUSR8YSs/sJp5KNcLDIURYuWDQS/fPWF/TPDleHXp9+TeaV3FfFGkVHICM7oTKSNfWFVZMaPH4+kpCQsXLgQgwYNQufOnTFs2DB07doVgNUaM2XKFHz55Zf429/+hv79+2Px4sUoKCjA+vXrw1l1AMDUqVPDXYVGQajkbIGzuZkBxdEeEzH6apFJTzfgvfcK8Mcfldi9Ox3vvXsNV68EceYnE9vSEuOUPTev4JrP95sw9XN89eu/MW7qZ37XrSHg3JaFFBm1B0WFCqZ1oIEgp7+gnGwytJtFxuU77Z3yuPC/o7Dul/sx77OXBM8zl8p53yu5y1g9/ReP92W93NYYTEUm0sa+sCoyGzduxO23344nn3wSLVu2xK233op58+bZz1+5cgWFhYW8cMgJCQm44447cOTIEcF7Go1GVFVV8f4Fi1GjRgXt3gQHoZKzs6mfphiAscBTEE1vLTK2zmjD+kpeBmudjsOxY+HPPG0y1SkyTjs3TJTvS14t26bigS670L79Ub/r1hBwbsuswOChVEgPmiqSb8kjsvoLJ9nTLvqkRaPhfae8jKjcYWga4nvlo2Uv4R1mFs49HlB+voydi16+ht7EevFWkYm0sS+sikx2djZmzZqF7t27Y8eOHXjzzTfx7rvv4rfffgMAFBYWAgBatWrFu65Vq1b2c66MHTsWCQkJ9n9JSUn2Z02YMAFGo9G+vjd69GgUFBRg/vz5SE1NxY4dO7B27VpkZGRg2rRpqKqq4pUtKyvDzJkzcebMGWzcuBFz5szBqVOnMGfOHBQXF/PK6nQ6TJo0CZmZmVi1ahX27NmDlJQULFq0CHl5ebyyDMNg7NixyMnJwZIlS3Do0CEkJydjxYoVyMrKwsSJE2EwGHjXFBYWYt68eUhNTcX27duxbt06pKenY/r06aisrOSVraiowIwZM3D27FmsX78eW7duxcmTJzF37lwUFRXxyur1ekyaNAlZWVlYuXIl9u7di8OHD2Px4sXIzc3FmDFjwLIsRo8eDZZlMWbMGOTm5mLx4sU4fPgw9u7di5UrVyIrKwuTJk2CXq/n3b+oqAhz587FyZMnsXXrVqxfvx5nz57FjBkzUFFRwStbWVmJ6dOnY82aNVi3bh22b9+O1NRUzJs3D4WFhbyyBoMBEydORFZWFlasWIHk5GQcOnQIS5YsQU5ODsaOHQuGYXjX5OXlYdGiRUhJScGePXt4Yb0p2gIwDBQK8Re8R+dobNiwAWVlZbz7VlVVYdq0acjIyMDatWuxY8cOpKamYv78+WDrZoL79oV/h5IQZjOLjIwMXrwKRqFEQUEB7280m80YP348srOzsWzZMhw4cAAHDhzAsmXLkJ2djfHjx8NsNiMp8SoAoE3TfBQUFGDBggU4duwYdu7ciTVr1iAjIwNTpkxBdXU17/6lpaWYNWsW0tLSsGnTJmzevBlpaWmYPXs2SkpKeGVramowefJkXLhwAatXr8auXbtw9OhRLFy4EPn5+byyFosF48aNw9WrV7F06VIcPHgQycnJWL58OS5fvhzwPmLLli28PuKLL76wl4WIIuPaR/DO02bSRwj0Eenp6fY+Yvny5R77CJriKzLOfQSj5Gs2NMXY+4hVq1YhMzMTkyZNgk6n492/uLgYc+bMsV+nTizHmTNnMHPmTF4fITTssgbW3ke4vmtGoxETJkzwOmBmixYtcPToUezatQurV6/GhQsXMHnyZNTU1PDuX1JSAuuKpnVZedOmTUhLS8OsWbNQWlrKK1tdXY0pU6Zg7dq1WLNmDXbu3Iljx45hwYIFPvcRru+acx+xYcMGWX8rxXkb0SuAqNVq3H777UhJcUSvfPfdd5GamoojR44gJSUFd999NwoKCtCmTRt7maeeegoURWHlypVu9zQajTAaHbOWqqoqJCUlobKyEvHx8QGtf3JyMh544IGA3pPgTqjkPOfbl9Htvv0AgMwT94Kq4nCucgtmzigVLL9j2a0Y9k/vcqXsX/sQLE1yMHRItt/1DQaPPRaP6ZNP4VLOMPuxXen/xLh3f/Dpfnv2drV/HvLQZb/rV99xbstbJz0Lza18S1X18fvw+OcL7d+d5QcAF/f1w5s/yOvcGyty+ovf//cqWg3ZBwBg0u7CsA+X2M/9OnkUOt+cZv+ef7AvXvhmo+zn234zi1GB4SMuup2f/PRzYDn+8hLd8mZ8MH2M5H0ff+RxbNgh/7ffuXMnHn74YVllF099Fa37HMCF8/eiQ/OH8fg/n5YsH6o+uaqqCgkJCR7H77BaZNq0aYM+ffrwjvXu3Ru5ubkAgNatWwMAioqKeGWKiors51zRaDSIj4/n/QsWCoX7Gndj5VpJIb783xsYNy/w3uyhkjPN+8xArzSJKjEAQCl9mQNEQPheCdq1U2L2tt94x1S0d9s+nWHZsG+MjCic23KUwHZahYelpdZdciTPE+T2F44dQJSrg7XLV4ryLSyCUsNg1aQhbscpoWGXDW+/0O6mfVAoGPTtl4yKDckey0fa2BfWXubuu+9GpkukyosXL6Jjx44AgM6dO6N169bYs2eP/XxVVRWOHTuGwYMHh7SuQuTkkE7FxoIfxqJN6T/QZm9CwO8dMjk7m5thQXW0dOfCaXyJfhv+WDHOxMXxu4DrhRYM7cMPAPZAnz/w/U8f+3R/lo2sDi/cOLdlFdwdd119ZIzZ/F1z8R2rg1OxBoSc/sJ5Uc81w7XrW097UC6lSLz1qsDD3YddSoYi422SWcpH3zZTK2EjgTORNvaFVZH54IMPcPToUfz444+4dOkSfv/9d8ydOxdvv/02AOsP8f7772P06NHYuHEjzp49i+effx5t27bF448/Hs6qAwDuueeecFchYmhRYTWn1iT0Dfi9QyVnzinaJ01bUObJmuch5ofIU7Bvb/BCh3tLtUsQvi2bqwSzZmvivPfpuXD+TyiVZJeNM/y27D7QKJQujqXhDy1U7/C2v6BcUxS4yJzy6T2XfKL7IUaGkhIio41CrfFYJtLGvrAqMgMHDsS6deuwfPly9OvXDz/88AOmTJmCZ5991l7m008/xTvvvIPXX38dAwcORE1NDbZv3w6tVjq+RyhYsYKEC7ehiCtD15GfommPnQG/d8jk7JTNmubM6HitTLI4pTTiarb3vi4nToR/d5IYFgtw9Kh7/ViV9535r7u9CJHeSHBuy0Ljkj+zf4IVOf0F56RMeFJU3Jae/EXIUhKEpSVfLTICUQHciLSxL+whuEaOHImRI0eKnqcoCt9//z2+//77ENZKHh9/7Ju5vSHS/LYUqKLL0eqW1QDGBfTeoZIzo3Z8pikGHUsrJMtTChOO7t6KTq//x4uncBE/y+7UyX3JTOlD/BIjHZk7s8KJp7ZMK6WXOQie8ba/oFysYJTL/heKDuyvwDBFbse4ICwteQPHUva/0yzDvBFpYx/xxPODceMCO2DXZ9ggvmShknNWW8faMM2Zoe1dIVmeUlhwTWY2Wh4RPjoJbTnXQDpezicz/4Mv577BOxZL+Z++oaHh3JY5AY2WJktLfuNtf0G5WMEol7QBlDIEfm0yFJkoTu2xjK9wjMOmYZZhgYq0sY8oMn4QaYmzwonJLWFJ4AiVnBmFwxKhoCzQxXlevmS8DlAW+SOTUA3jmArJax7pvQ0PdtuNT2Y5wq23MsQFtmINAF7SSKECrktLAj9GQX4wkxjWf+T0Fy0TnLY/uyoyrj4yoVBkZERBob0crufNni27rLNTvon2/PdG2thHFBk/iLTEWeEkmLtTQiXn+ApHZmGaskBXGy1Z/uDBWlwvvO7dQ6gIN8cAgoOnQiEvgnGi0uFXpOXCnw8t0nBuy1zdiKmsag31gZsAeHY8BYAju7cGr4INAE/9xabP/gbq9tOOA24O6fx31HW5zxOs2YfJiozkkZyXOx5X/vGH/Mc7WWRMMvJ5RdrYRxQZP3jxxRfDXYWIgWEciszhg3skSnpPqOTcIcOhlNAUA31ZG4nSwHffFuF4WrrXzwlfCEp5CPkIKmTmm2lqKrZ/ZuFdaPeGzJKpz2PfqqGgzOVu5+iyJtCq6mLKyHD2vXLB+zbXmPDUX0Q1dVEIFC4+Mi7lXZVLT7AW/rB6fK/nDRBytl97u3wfFyvfIuqsyCSZm3gsH2ljH1Fk/GDXrl3hrkLEwDopMgcPBVaRCYWcV84eD8YpLoyCNgOc5w6MsXjvBCumyAwfHuv1vZyJiqLcE+AFCE+B2mwonRQeBnwr3eED2wJap/pE25sOg21+BTe3d8TfcPaRoeuSdcLVR0YAiw9trj4x7a1nMfX1p3ElPc2n6z31FzrGJdaVwtUvycXZ11uLDMN/CU8d3uf5IhkWGcZLRcbsTTtx6r8tZs/5CSNt7COKjB/07t073FWIGGizo3Mw1QZ2SSEUcq7R1SKhj8OaQNMMYPQc78VskRf19siRI2jdujUeffYIdu0Svu+OHf7FlzEaOWg0/vvgCFpk5CoyTuUsLt3L8VQZHXoDR6sW9qlSMnVyqxtUT59ItX4X+C04Gab/+kxZy+4ob9sLm2aO9el6T/2FieVPGDgFf8CP0vJ329FeW2T4CryhpoL3nWFZZBWV4OTVfFTo6hziPSgyRqMRa3et86oeFrN8RUZPOerMyti2HWljX9i3X9dnqqtJlE0bDOfwJ1GwgXWOC4Wc2Voz2rA3YOuyaJoFuMDNjmmadku1EWhYFtDr/V+3EurG5CsyLMYsfB4Mp0Asxe/Qy82REwgwXCidMimXVBmQfqAG3ZTVuNWWbVxhwXf//Q/uGboNe/YCoKwO5+ZaFVQx1ramcLUgNFAo2jel3FN/oWFd2qGLIpPQKRt7dtfiWoEFt90WhY4t5fVn8z9/AtFxxUgcwL8fDce7YzQaseDQSWQW3gAAqJUKvHzPQPRq01Hy3mYvlBIbFoYBwzCy0gk4+zhqmt3wWD7Sxj6iyPhBRUVFuKsQMcQ1c9qGHOAAUqGQM2XUQaHgHIqMggEnowOQa77V6+vPVmS9wf33cw3jLkZ0LIM7WxwGAJw6+wDvHONLRocGhm2r75o1a/D0D1vBshyAG3htcFv840EtOIUZvTs6EklGtbdaN4tO34/2d+0GACgpb3fK1S/atMlE02bXUHSwnU/XS/UXJ7dvRvS9R3jHOIXDqqrX6/GXR6/avy/+rRxvva7A49I5FAEAnYadFj7hpLxu2LDBrsQAgMnCYOuZC+jZ+hbJex88eNBzBQQwGAyIiYnxWM7ZxzGm9RWP5SNt7CNLS35w0003hbsKEUPTNuftn+kAm75DIWcLSwGMk8+CgoVeY0a7dtK6vsUi72/dtq3++IdMn1bidkxuxFnayVrAuOiBIdnGGukorLPk119/vU6JsTLvSAHy8kzgFGZQJndLBGeJhr7MavVUe73lv37RrftxJCZeQ7Mu4glbpZDqLwqzzrgd42jHZGTQoEFu53+Zm4cds7tj/mf/8Kk+lJMi89VXX7mdzy2rAMtKW9kuXnTPoi0HnU5eFHGWdfRztNLzcnmkjX1EkfGD+jQ4hRJFgBWZUMiZ4xiY7nZ0JpSSBUex0GikXxGLWd7fGhUV5Vf9Qolr/iVAviJDOcWgUGv5nahGhiNrg0dpxrFjx1BW5p7+YvnvFeAUZjBmd+WZ4wCuzvei95A/cfGcyOy/AaGJ8S0AnFR/YWbd2zGnNOHyn8fAsizS04V3hOWpDOhw+zmf6hNb63immEJiZqSVB43Gc/4jIeQqMgxDo7zMAo7jwKkNWPjzz5LlI23sI4qMH7z22mvhrkLEYDA4zJe0jIBK3hAKOSto/hIRpWBBMzRycqQ7GLNMi0x0tHRMmkiiutr9b5JaWsq4cNKpnOPam7sc55VTNXAnVTmwCjPKy923YANAVpYJnMIEQ7WjreTnm7F4cTnW7juCvBuV9uO71/4v6HUNN95ue7Yh1V9YRLY5n9u2RnK5xGhkQSf6tjxsoq9h2jvWRMitWrUSLEN5GIp9zS0oR5HZv38/3nv3EJ58MhfP/jMPl6+WAsezJK+JtLGPKDJ+MGXKlHBXIWIoKuxm/6yUGXNELqGQs4Xlm/NrjRZMnZsKxsOfYjbzB3iWZfHe1B9w9AB/TbusqDAg9QwF7du7z4Rpid/00BnHoOoa7t0ZVYAV3PqISWkQtc4ZjSxAcahkWgAAcq6a8M5/rmHxb+XYfPAYPvosBxnnrD4z7TvlCN6jQeFj1mmp/sJs1CMnx4SzZw04cUKHw4dqsWdPDVL+TIVSKb6M7M/+BVrJgTVab/DMM88IltGopK1PPXr08OnZnhQZnU6HkSNHoqzM2q5u3LDgxx8zYWjTWvK6SBv7iLOvH0RamOZw4hwbRRngmXco5MyBX+fFf9xAzrVKkdIOXC0yn0/9Gg8WHsBmcznuvO9e+3Fj5iqf6/ba680wb650Ju5AQgv4OEstLXVtnuVUTnz5KNDtoj5CKS2iiozJZH2JYlVW6+DmzVW8ZT6DgcPatZXo01cLhbbhL9NJKcVSSPUXjJnBpJ+KkZHB9zPq2saCLyQiVapUvoc1oJUsmLqJEif6DOn7y9l5JIQnRWbz5s2oqeHv4qqstCD96mXJ6yJt7CMWGT+ItDDN4UTp1C8ofDQJixEKOVMuQbA27/KsxADuFpnBxmTEDb+Gh/pt4B1nu3nvoDn9H9+iZXwili0TXooIFsa6XUu1NxxWNtft199P+wQ/zvgIn0x/l3ecpsUHWFWALXX1EYo2iy4T2BSZTnenAQDWrXMPTJacbI1xotA2fFlSPm4zl+ovWNYErdZ92DOaLRJKBtCype9zflrJgfEYmyU4Odg8KTL79+8XPH6pQNriF2ljH1Fk/ODf//53uKsQkcSwJizaujpg9wuVnNetrcTrr+XjP/+5JvsaV0UmqrVVAXJNVCvVSQrRtm1z3Nn5NvRr1xO62tDmNDDWmcEpVtzcfXe/tbijz3o0j6vgHZe0yBBFBpTCIrqEUVXFoqBA3nb+xqHI+PY3SvUXHMdAo3VXGoxmBmyA41/ZoJWsxxQEHCU9FIs5IXvCkyIj5rtn8BDoM9LGPqLI+MEfXiTlakxw0a1ALzzpuaBMQiHnQ2nnMXNmKbKzTbhwXr71xOSytMR4cqqRidlsVQjCkSvbYOCwc2c1Jk5Pw6+/lqGkRFw5aUnxfX+kHL0VFPGRcbX8ufLOf64hN9fz9leh5b+GBqs0I+Ow9/FTpPoLM0dDK6jISFtkZAS7FcWqyFg/79692/3eADha2uLzwQcf+PRsXxUZEyOtUEfa2EcUGT+48847w12FiIF2GqSatj8NXdvAySYUcj5yWtpLXwyWBSwWp9gpTnlWeDM8L40qXbq0AQWADoMqU1howYTxxTh4NB8rllfgg/cLUFMjrKApPMS/4JUlPjIeqaxksW1rZEVNDRcKmkHyHwu8vk6qv+AsDPbtrXU7XqUzSioy/iR6pZUcKJYDy7I4d859C7ft1r+9YY0x8+vr3+PXF1dh/mvf28v4GknXUyBOsWVOIyP9Xkfa2EcUGT/Iz88PdxUihsuXS7B4cTl276qGIjoHnR7+IWD3DoWcrxZ4DssthnNnYaHa2z//d8o3Pt/TYZEJh02Gz/XrFhw7qsPRlGS3c0oZaRzsZRvp0lLqUb5VYe+W9ZLlV6+W9s/ydpnSH7774CNMfPJpfPPuhyF7po3YuDLQnPdbnqX6C6kWKGVNPXjAXfkRguM4ZF00YteuavsyIaVkQXEcjh8/Lnmtjm0CADDhThi1zWFQ3CPrmZL39GCREd1B52FpKdLGPrJryQ9C2aFEMr/++iu+m3TY/v3mbdUYOy5wA3Cky9lgMCAuLg4AwLEOU+3tjGMA8/YvsOZWoRCexSV3JkwoRvNWe3HnXQ/wjlNebKmWG1SvoVGT/zXQzPHdUpYnXlgGFgtAWUKzttTsSiZMGqDZtQsheZ4rtML7HEPSlhXx9io16M+eXYqRj8V7fO7MmaVYX+ekTdPAZ5+3RP9WTUFxHAoKCqSvrxuOPS0zeYMnRaZnz56Cx9Va6QB8kdYnE4uMHyQlJYW7CmGH4zh8/fXXvGOnTxuQ9mfgcgtFupydLTKxlCMwoDrW0YnU1nrnH3Lx4jVsOrMbO8/7lmNFiDuSbvb5WoYBqo3us1KlSv7f1ViXlthmubzvLTkKTZv6rogYjRyYotAkrjJraBibt4HJx4Bs/qJReT9ESfUXUsOv6zZkZwwC+cdcuXLFbFdiAOuy8y8zSwCKAcVxktG95+7dAMpinbRQrPfKmxieFJm7775b8Hh8fJzkdZHWJxNFxg+OHDniuVAEwXEcdNU6cBwHkyEwcSiys7Nx/fp1t+OzZvmWJ0WISJezwWCwf46FwyLjHETu6BF5ocJtGI1mfLd1qv+Vc+K1gU/5dT1TF8vih58/sh9r1kY6o/eNGxYcOlSLoiKzZFC9xkStQoP4eN+73tpaBlCFZkasb9cJphbtoOskPHMPNrTCe4ukZH/BibdBKUXGRs4V8YSKGze4LwlWVrI4l1UDsJxkdO8L13Nw6PIxAAAdQkVGTLnSaKSX2iOtTyZLS37w1FP+DQyhZvbbT6O9sSsqFSVoQ3dFbocavPRf/3xZxNaVi4oCF7ArFHJu2SweN8rc43bIwabIfDj5O/xd63ilFCoKP337EW6uPYLzXuyECgY/Pfop7uk4wL+b0BR+nP4J7rplvazimzZVYeoURwLKV1+OwpPCgU0bFWZQ+GVWO16WZW/YtKkazz3mOaNxILDEWJdTOJVvuX78hVJ4r7D52l/Icag9vXMNOr7xseC5nBxhBeRGqRGJkLbIAMCmk5sAADRjAqMMTEoTT4qMSqUCTdPuW88paaUu0sY+YpHxg1mzZoW7Cl7xWPx/cGuLEXig2XPo2eQutMzxf51dLCYGw3C4nOXbTiBXIl3OtqWlJjU3YOq53XEiSoU72a2gR0hbLQDYfWyCRZu45ohR+9c53tF7C+7ou1ZW2Zoa1i2L9sLfsiTz2TQWKDUrOugBQGysdLe8YnlFUC0yP/znQ0z9+98w9r0P/YvNHwB82WYu2V9IiE2ORaYoWzwLtVB8GgCY+3seGJaRTIEAANW6OkXKCwd6Ie4aejuee+45/PvF1zGgt+cs1WqV+zIla5L+3SOtTyaKjB9EWphmb0lQtvdcyANiobMZBtixc53f9wdClaLAM23btsUTTzyBtU9FYepzr2DSz20w/adu6Nu3LwDg7ru388orogwwPuA5Jgjg+/ZKuRjM1npolb6/8lq1fL+ngwdr3MZAhuEwf/58n5/fUFAqLdixQ/z3rqlhUVIsPZhpmpkx8X8fSZbxlejii7CoGagLL4ISyBYdSnyxyEj2FxJxfOQoMgxlED2nUYsvg10qui7fQdaLkAauKBOU6PVID3Tp0gXtOrRHoYwcb0qBPjwjs0Lymkgb+4gi4weRFqbZWxQB8I6XygFSVuTZEiGH0MjZcydTUFCAtWvXYtYJE+7q2hM33xyF3n3UKC8V9gdSaB3LSctXdAhYTX3BYLHW5fN7/Fde5VBUKNwZZ2RkhOT5kUxifA02rJdexty+3bNi2627e3C1QEOF2CKz4IO3+M/3oYuS6i9UJvGJRW2t5y3WCpHI1VcvZECtEVdkNqYdl/SR4eGjRUahAP7vzRZAdAUAgAEDi9Hz71cjsPx0/boeyXt2iF4TaWMfUWT84L333gt3FfxC4Usv4Q0SjnXeEBI5ezHxoyiAYuo6CKUZKTu2CRdUOxSZFi2UeOSR4C4fSaGvU2S6NA2NW5xGIJ8NIG+waOgkdvG85Jp/zbPDZ3wHzxYEX2C00ajucQsYbXRILTLT3/gHchNa8g8qvbfISPUXXVoWi54zmUzo37+/9M0FolNfSj+N82efhUYtPpyWVFeBpuUNt5yX/eaocR3wxRctsHhJB7z6cBSGd8q23ocCKNb3If7E7l2i5yJt7COKjB/UdzO5MgCKjHRY78DM5kIhZ84LTcbIqUHZOhsFg7zcbFnXffxJC7+23fqDwWxVZGJUgdsR4QzL0jCZHFt0aZHJqadIo40Dz23tllukHUODia5zH0ChtP4/QJMROdQ2cbdaUj68LlL9hbqruKUrLi4Op0+fFjzXvr3Vj0SlcLde7F4yDerEKlEfGQAwMQxWrFghet4ZVjJsH58Wj7VAq25RGDI0Dq1aWfvzRI2T1Yn1vY83V4orypE29hFFxg+GDRsW7ir4hTIAS0tSigyNwCgykSbn/dl6/GPOVPzrX7n4v1E52Lhnj2A55Y1+1mmRE0J5XkKBLQlcVJDCj1hMUWDNDkVmvcBWVAC47777glOBesS1s54tc1Lv1YMPhmbHEgCes29OgJz3xaDrdkCajA4ljlJ634dI9heM+AtgsxYOGOAu3xdebAoASLrfPcWAvi52VNMm0lrXpEmTJM/b4Jz6zTMnpLc5R3cXXq6i6/odmpOuk9RSL2MUX+JylvH29RuxdtEynDh4WLR8sCGKjB+cP38+3FXwCwXl/6gm1uE++GAMFAGKGxIKOQv9Gb16aqERWfe+VHwDhdctqKhgYDAKb3GkaRY0w9+22rZtaAKZuWKwWJ0Uo1XSitTrA/8hfg+D9KDCOQ0SxTeEf/ubbvK8i6KhUyUxQNiRMtqEUhd2ioS7Y6O8HWu+oo2qRL+bdkGtcVjtKIX3ioxUf1FeKT55sykyr77WComJDgXgvvtjcN994sqjClYrZ5yH2EBydibOfe0LcLHd7N8P7EiWLK/LEu57VLDWX8lIKzJCuZ9smC3ijdBZxnkHz+Di5cs4s1pkiT0EEEXGD4K9ZTbYBNMi07u3NmCRXEMh59IKdzPqhUwDjEbPywBms0iMGIURlIsi06JFeEI32S0yEruW3rjjWXz10NuYNbsdnhjlHo597pwyiSdQ4GSYsQuvXfNYpqFjUnte3pPa4EL5k4rZS5xD+udf97wDxh863nIGTZvyn+GLRUaqv/hliXiqBVvMlY4dtVj0WxJee+3vmDGjF776qiUUEoH5LJy836NNmzYey1RaBvO+11ZKK72ciLKhrLPEKP0IFWcxivffzjJmVQoYFCw4mT5AwYAExPODhISEcFfBL5QBsMjcuCEcAfJ4qg7dHwuMIhPpcjaJ7YRQGkEzat6K9/DhsbJ2pASaGUeW4Y72t6J/oniny9VN9bt312DhQnelZePGKrz7XnPesZUrK3DyhB4sq4CiLpdSdLR4h3bmTAqAl3z4CwJLxulUrNz3O/q36ItRz74atOdkZ2fj9GknCwMFnM0SdziVQ0V56PxWaNbhsWFk5YUS8BWVRmDQVnr/t0r1FzsO5Yqec3ZEj4qicUcHJSzKW0BR0skeTQrP/aiCptChaTxOeihnshgQrYm1f6ct0kqSWLwXRZ2NQuXBfCe1hGk2u8v+TNopmI1mnoybdEpDk2ZFMGd1lnxWMAmrIvPtt9/iu+++4x3r2bMnLlywas0GgwEfffQRVqxYAaPRiOHDh+OXX35Bq1atwlFdN86dO4c77rgj3NXwmUAoMrGxsYLHu3ZRQ+lDJyREpMvZZBbu4DmFERSj5h1r3boXAPeUDqGA41jESCwtcU6d3vFj8pxyr14x4dQpftm4OHFFJlfn3yAeKE4cn4z7+h+DueQcgOApMnPmzMGECd7/3lJ2wFOn9KiuZhAXF3zHccopcre3u2m8hWMcwxHHcaAoCpQPfYiv/YVDkbFKX8vUIOv6QNTUNMMtt24XvY6yqXoSP9pf+veGrlg6qzkAKGmXPpmTtnJEdXb4E23bVoVdu2pg0LOoKJkEvdkAs9GMt35+ByqBoHeeMDN8xTIvLw+n5q4Cq6CQ30Jjl7G2yQ3ENs9DcX5LoduEhLAvLfXt2xfXr1+3/zt06JD93AcffIBNmzZh9erV2L9/PwoKCvDEE0+EsbZ8HnnkkXBXwS8CEUemT58+6NWrl9vxR0bEQRkgH5lIl7PJLLxUwDotLdmCnF083y6UVXND0tm3To8xGsV3zDCMnxFllYFLXeEPSe2skyVV88tBfc41H5fSpJRBADiS4l3uLl+hnX5uOshbsSmKw769NXj5pTw88fcc/DSxGGbW+9QeYv2FlPWhSyeN26S6rlaorm4h/UC5YvHw6jx511uIjeJbkzjG2g6aN28udAniBziWgG/csODMaQMuXjThRlkxqqurYTAZJAP9ScnEYuG/q5uWLMTVllrkJmqQWO5sVbZ2HBwVPnUi7IqMUqlE69at7f9sP1hlZSXmz5+Pn3/+GQ899BAGDBiAhQsXIiUlBUePHhW9n9FoRFVVFe9fsFiwYEHQ7l2f+P3339Ek3rpjRaUC3nknEUlJaih9cNQTIhRybt+6ic/XGo3CigyjMAJ1Fpnlv5fj6adz8c33S31+jt9QFIrYQaKnOY7CuoxdGP+ReF4dV58hb9UajQ+RWoMBZVFLnv/y+0+wb919mDvNv2WwzMxMr6/p2k2NO++U3pk0YUKILFtOgxMVZItMZqYeY8feQG6uGdXVLLZvr8bCZeIpAcQQ6y8WLlwoek2nLmp3S79MXySqbpdRs0QlWrQQtpJRAFgPTT+phXVCyCj0qI7PAqPQg6uzyAhZVCgVBUWU43nRUcLDuZyIxUIYLfzfOzbPcR8lJdBHhPHVDrsik5WVhbZt26JLly549tlnkZtrXcM8efIkzGYzhg4dai/bq1cvdOjQQTLz5tixY5GQkGD/Z0s3np2djQkTJsBoNNqjEo4ePRoFBQWYP38+UlNTsWPHDqxduxYZGRmYNm0aqqqqeGXLysowc+ZMnDlzBhs3bsStt96KU6dOYc6cOSguLuaV1el0mDRpEjIzM7Fq1Srs2bMHKSkpWLRoEfLy8nhlGYbB2LFjkZOTgyVLluDQoUNITk7GihUrkJWVhYkTJ8JgMPCuKSwsxLx585Camort27dj3bp1SE9Px/Tp01FZWckrW1FRgRkzZgjKq6ioiFdWr9dj0qRJyMrKwsqVK7F3714cPnwYixcvRm5uLsaMGQOWZTF69GhMH/0xRn/8MhITEzFn/EjM+7U91q7rhL89bp1VKJQW6PV63v2Lioowd+5cnDx5Elu3bsX69etx9uxZzJgxAxUVFbyylZWVmD59Oh5//HGsW7cO27dvR2pqKubNm4fCwkJeWYPBgIkTJyIrKwsrVqxAcnIyDh06hCVLliAnJwdjx44FwzC8a/Ly8rBo0SKsXbsWRSW++62YTIxwpEulUXK7Zzg4pX9Z4iyFSyU5OHD+lGgJvd6zcirV/2tpBseOHcPOnTuxZs0aZGRkYMqUKaiurub9NqWlpZg1axbS0tKwadMmbN68GWlpaZg9ezZKSkp4ZWtqajB58mRcuHABq1evxq5du3D06FEsXLgQ+fn5vLIWiwXjxo2zK5gAkJycjOXLl+Py5cv2PuK+LhlgE66ha78D+O77D3zuI5wzo8vlyf9LQH6ePH+UQPcRZ8+ehcLotFTo5MCp4LzvI1iWxZgxY5Cbm4vFixfj8OHD2Lt3L1auXImsrCxMmjTJ3kfs3VvmltZi5+7rsvqI9PR0ex8xfPhwwT5i5syZonI0mRi89/Rf8corr2D8+Gv4+qtCTPjtGBYuXIiSkhKUl1nsbT8zMxOTJk2CTqez/o0UhZMnddi4oRK1teLvh0R2BACAuS5oZWWTDBiir6Oi2WmAoWE0GgWVkfhb+Q75USKKzI4dO7B69WpcuHABkydPRk1NjV0uS5YsEa2PhTWitLTUXja7ldNWbw5Ys2YNdu7cydNfnOVtNpsxfvx4ZGdnY9myZThw4AAOHDiAZcuWITs7G+PHj4fZbHYbjxcsWGDvIzZs2CAttDooTnYCiMCzbds21NTUoGfPnrh+/Tq+++47XLt2Denp6di0aRNeeuklGI180+KgQYPw4IMPYvz48YL3NBqNvGuqqqqQlJSEyspKxMe778Twh9GjR0dczgkp8j8/6Has7Y93y4446cqkf4y0fujdDR3al6JZlxTe+WvnbsXz7/zh072dCbac33//fUydOtXn62OilKjRmbFnb1e3c7QhHqy2CvPmlmLlSs9r5P7QTa1GFE3jrMjgueTJn2BufitenjVE8PzLd74A1lSNRafEt9ku+i3JHhwMAN5/rwDp6fznxcfTqKoS7tDf/GAofvlZPGJoqNi/eggsiVcBAEMecl9e2vP7CKC11RpAGxLw4KPiyp0Uf/nLX7B161bZ5UeNSsC/32yG9eurMHOGcOoLABh8VzR++KE1Wjdbhr633OlT3cQY89F7MMdZ46ZQNwqQY7CgZcuWUFcX4vuZiwL6LGfEdmNNevUpUNHx+GDqPFn3EesvPO32urlzW5y+UiB6/qOPm2PEiHi0iV+CPrffZT/+4ctPYcbSP2A2iw+lf7ulD2otauxOTxMt8+aIH9G3wx0obn3AfiymMB6fzP4Qbdu2xfXrfF+rhEEJSHorCffHmvH3pmbs2VODsT+6b744duwYBg0StsQ+/PDD2L1bONXFs0MextLdO+3fv/32W3Ts9CeUCjN0J/rhjakTAADrVzyEuJY5uJE2EM98KC/on1yqqqqQkJDgcfwOq7PviBEj7J/79++PO+64Ax07dsSqVas8pjwXQ6PRQKMJTcr5zz77LCTPCRQsx4B2CZW5ZsVCPPnPV/y6r/6GBXRH9xkkHSBn32DL2R8lBgAMJgbJu7YCAlZlVmtd2gzFdGFj5y4AgD6Z4ltMpaqRVXwZBy8fkijhiCXDcRyqqlg3JQaQtsgsX5SCX36WfERI4CzSljKWUdjN1azWdwVUzBleiH/c+z5ee2sjAF74FkFsvkp7t2wOuCJj83m4ePEiVq9aBQvDgKIoPPbAYA/XBYcbiZ0R58Vky9f+QiWxxRoADAarzE9sWs1TZNIyr0oqMQCwMS0DD/S/TbKMhalbouYou/mGYuT/3VFRwvWXSkgrpsQAsPsnTXr/XbS/5RYAHDp0SAcA5GY4dihRnkxNISDsS0vONGnSBD169MClS5fQunVrmEwmVFRU8MoUFRWhdevW4amgCz//HAE9shdYBJKRXT131q97FlRU4atZM/F/L6/C0CHZvH8VAcroHOlyZhgOGy7wrVGURStSOnx4WvL3pMQAgF7P4Y8/KvDM07kY9USOYJnKSvFRuKI8NE6qNibMeQ1jfnnL7TjnYcmPZQIzx4uJkR+FV6N0tBlPQ4Opzleppqrcl2p5hGEYrFmzBpa6XUscx2FT8hGUlJQE5XlStG9/FOqm8v08fOkv/v73eCiV0i/IzBml4DgOOgNf5vtSUj3enwOQfPZPyTJmxjoZpJyi8SYYNJjzv++QkpKCd955x/7v8xEPoPU/+eNgoH1kTl/Nxs9vvg61KgHs3hOIj3f4ZSk04c2K7kpEKTI1NTW4fPky2rRpgwEDBkClUmGPU/j3zMxM5ObmYvDg8MwMXHnyySfDXQWvYITSw5t938LZ8uYSxPcWjiMDAAaT9zsOhKgPcr69xDqzKSuz4MA+Ay5n6yR3BASD/TU1yJfI7gvAb4e8PburMXtWGUpKIqsjE2LC6E8xoPte3NlrB3asW8U7x3lQVBiL/4oMy7KSDqauUBQF1TVrVFdPbcfhdB2c3yE7O9stPhLHcZg9e3bAnnHt6lXMfOVpTH9F+v1OaJKN2wZskX1fsf6iQwfxDPQMA8S08Wx5u3jRBNrH3ZieflObRYZy2nJtiukJ9sYgdOrUCc2aNbP/ax4Xg8RmCrRROSYNUSLxm6QsMlJkXslHnLIVSmMUyOzSEjff4siGrQiQtT1QhFWR+fjjj7F//35cvXoVKSkp+Pvf/w6FQoFnnnkGCQkJeOWVV/Dhhx9i3759OHnyJF566SUMHjwYd94ZaFOqb0g5HUcijMCuA5Ufzqht7yxGQmfxl8TmvOYv9UHOlphaHDumw7P/zMX3owvw+ptXMWN6qb3zCoVK8+a1fAy7kg21yMySAuV3ePvNm/23soVKwaulHe0v7Sw/qBlndrT7vCtX3K61eAjtLodly5Z5fY3yutWh0tPSks0NUEkH5h1zpuDGDRw4cEDwXCCt4csmj0FxUi+UJvXFz599CJVI1Gnbko5cxPqLkSNHil5jMLBQqj0/57ffykDRwUm8WlhutXBSLvmRWIWm7jj/5f2+nQGftTYgsS5DuNjSkq8WGQAwmoUbomDE5ca6ayk/Px/PPPMMevbsiaeeegqJiYk4evQoWrSw7tufPHkyRo4ciVGjRuG+++5D69atsXZtcPN9eINtR1R9RhnEXTUmS2AigdYHOdfqWEyZXAznkDIbNlQhKyu40VCFMEnkSImEUN6hyoA9qIsjyaHOJSYG42SR2bXdsTPix3FfIDsrPSCKzMSJE72/yELhyhUTFiyQXjKyLS2paO93RUnx2muv4Zely5Gfny94vmnTpgF7lgaOdqCoLIZGLSxzo9G7MA5i/YVWK77cazByHpeWAODPU3p7BOtAs/v0SmTkHndTZGx0YoXj2XSuW+YRW1qSssh4ckSvYGsFj9OqyLLIhLVf85TWXKvVYubMmZLb5gj+oWaDFx3UKBLxtiGSmVOF4mL3l/u3ReX4/odWOHs2sAOOL1AUBSMH0JTnmBbBpKamBtHRwll7A0kUbbZPEl2XA1hGYffNzi2whnz4cdJ/cMegbbh4Ig0WNtHv5589653/Wc6NC/h153ks3C+sRDhjMln/MjUC166uXbuGX3/9NWD384SadiiXFm08nnqsFxasdJeZ0UuLjBhSisyB/cIDtitmM0BRfIsMhcAZIy4W/Im2Is7bWs466bzZ0gnZOGE/bstrq/XBR2bo0KFo2rQJyssrBM9fV5khpD4JR1wOZTZTPhHlI1PfyMvLC3cV/EblryIjsUwgFvHWW+qDnEuqhF+l9HQDvv22CBfOB34JwBdMHKDwMengW2/5P7gD/Jw2QcXiaNtql46XdTLTc3UD6h3tLgEAVK0ugvFit0igSE5fh4X7xXecOWNXZAK4tDRlyhSPZQKZsNLsdC9GqUH71sI7vAwyErc6I9ZfSCky3kC7WGR6d/EQ+dcLjGYDKIE++dC+vY7nuygM6rqvvuxaUqlUePnl50TPWywWUBQDN1WN+Mg0HCLF6VguQn1QMC0ykyZfwh0Db8bsZ/6N77790Of71Ac5R6uEX6XaWjZk4eQ9QdV1gAof4wbZBk9/CZUi47zzSO1ikXHeMqqxbXV18ptpedPhINfOPyoqLbBYOCgVgbN6/vTTTwG7lxxYTonOXU6gbbvzMKs10GiE+6KjR71rL2L9ha8hPZy5+WYtKJeI5UmdAzeol9UU8ZaWuDoF4ljyUbsq4brbWVOXR0KhoKDRuHfynnxk4uPjkZgoLPtWFgZ33b0CPXq67MrkpRoh26/rNatXrw53FbympLYcs48txze7p2L/leNQc/6tLnpqwnQxheh+ndHlou9r68GWc+/evf2+h7alf06wyiahW+WlaN9mpiYPsTLk4o/zoRDfTnsFkyb82+046+TnonWZQXJOLVdb5yzJSaQtuJiR4XW9gr3bbvLPxVApAud4mpgYGIubXKLidGjf/jy6dj0BOs4s6iOzeZP13UrZJm/nklh/EQiLzOnTBuQUVfCOeXLMdmb58uV4/vnnRc+fyz2GZet+xeTJk7FixQqU1xQBAMy14sqSxslCIxTd19OuJQVHQyWSTFbdJAM0zaJVq2zecSpCcqbZIIqMH3z4oe9WhlCir9Hhj99/R6WhBk/+/g7GJM/CgpNr8K9VH2NfxgnPN/CDzIoLaDd4LqKHep9zxkaw5cy6xkX3gegoWnA2JBdaE/xX0VLX4/qaLDQSLTLjp7yIe/sl45bb3aMF68odkUC1Enm/oupmtKzEluttG1d6Xbdg787asaMGTIB2BgKBsVh4g4pyKI5dup4QVWRs/Hlwh+R5G2L9RaD+Pr1LWAmOlf/eDxo0CJ07d5Yscy4rDVVVVcjMzMS0TR+D5VhQLA3btJFyWVqinTJ7Ci0vFV2Xzr7eptUVUUWmTCz7tjI4O7d8hSgyfiCWJiHSmPfFa2idUoXDV07jUlku79z6tH1ed7gH9m/EL5PlRc8sr7S+9E06+b6FOthyDsSAo9ez/iky6uC/imdrKwD4rshs2xqYBKyBtMh0iRFXinRO+ZTUroqM00+lqfN5kAqCV6rzPrpvKLaZF5YHTpZyHLAD6SOjYhw+MVqVHhoP7wCnr5B1X7H+IlAO5lv2X+V95zj5Mpn/zucAgAEDBsgqX1J1HVnX0jB23kQ8N+5tjB49Gk+MfwWf/bEN48e5x/CKFoglk5cr7WPYsUeK6I6t6OgiweOUsyITPh9fO0SR8YP6kmfpr1GvoFNsX/yw7xe3c9erSrwOmPTnLyugP3oOQGhC7wdbzr5YZPp1aIK7uvXCfffFYNiwWLRvr4JG69sbrW6tBqUOfm+gq4sc+sht//LpeqmIvd4QSIsMYxHvwpRwzMBVLg6aztLWKFn8OusFKLsfE70X7YMrWSgUmaYJgevCpeKsBAPnuFYalUnUR8aGUmYgOrH+4oMPPpBfOQkqq323yFQbrwEA7r//ftnXnLi0BwzDwMJYHP9nWTACr6NWwCJTq/Pso6cS6X8USuHJC6UQWloKn68MUWT8QDDjcQSipK1OjOV64VmltzNkCwIzM3flhckf4tVJn7gdD7acvR1w4qOaYOzzd2LG0y/j629a4dPPWmLA7dHQ+rg81PTepiGxyFwttiZHbJfontwylATU2bfGIbf8bP46fo3aEadEKbHLQqWwoHPPQ5LpiTU+xA4JhSITFR24Z9xzzz0eyzzxxBMBex6csmwr1HpoVdKKjEbmThmx/qKoSNi64C1Gk4u/lRcxh0wWBmAsiIuLk/88swF6o7zYS0KxZEwm8WWgwsJCXL1qgskkPEkxGkWCawr6ZpHt1/WSl19+OdxV8Aq1Qjj4XaCdL33h31M/xPM3b8Azt7oHPAy2nIcNG+ZVeTNjgZlSQsHyX2Zflpa6/a0bmj/aXFCR6diknez7PBwbi4diY/FWYiKGvdFSsEyXVj0AAM3j22DisGh8N7QHnrvvAwzqOtDrevtDINubxeyQ+b5N/OzInJNi0rSni7XF6ZyrtUYIbYQqMpQqcM9o3759wO4lh8LENvbPtNKM2hjxpT2O46CQ+bcGu79wVWRMJvlBRU0WBgqZSon9eRY9GNa9/Qm1LyFnX5PJiKmvfYZNDzyKCV98wzs3fvx4vPpKPq5eEVZ2CguF24SQIkMjMBZbXyCKjB9s37493FWQxbzUVeg/7TGYGOHG6s/AEqi++vFuyaLngi1nb31w2jfvCoZTQMGarJlq6/BlaanTw50QE3UfFLEKqGMUaKtUonWT9ujYogd6tegiet2392vQPlaDAVFR+NeQ9pjarj1mtGuP/zRvgR4PJiAujv9qt4xphi6tegIA4qOb4e07muL529vijt4jMazfEK/r7Q/Zl+XFSpGDxSneS2lNIe+c3F9DylpjI1IVGbmDuxxuv/320CozLv42q1aeEy1qMnFQSDhsOyPWXyiVgdkZaHKJEu0xG2sd8VoNWifEgatrmTGx8pyPc24Ib5TIvuy+9T4q2r0uJrMZQw9tQruK62iRzrdaXhdxBH777US8/35zdO3STPA8LaDIUGRpqX7St2/fcFdBFoXVxaLLSoD3ScVa3VaMLo/mIC/PhCvZnuNYsDLCyKqiHPXbc3Af71ykyXnYLf8ES9FQUzpQjMZ+XKhj8URRTBHU6j5o/1p7PPhdL+zu2g3fPDETX42ahV+fGCN4TRxN492kpvjhwV5Y0qEjeifxzdSsksbYca3Rsq11ptizeWcseeon0E7xY/4oHQ8dY+2ktCrxbcfB4Px5/zKuO2OhHIMbQ/PbWfM2l3jft691JI6k4NiFpZShpDhHoZVLfbPIUBSFefPmBWzA94aKilbQ68WXQAwGDpTMaon1FxZXBcRHjEYWC//nvT/RnV07IDHW4XB868Besq6rMVQIHs/JcZdXu3Yq9OqlQc+bo9G7Zy/0798ft/a8DSl33YWNj/8NnIsyuHKl8G68vz+RgJGPxePW24SX42iFBTkCOcrCRSSkXqm3VFZ6v5MhHBRUi2eoBoCBA71bWki8+Qa+/bYIx4/JM5EajRyioijM/8e7oBGHG31M+Owbfh4axqyFQmUNt558YjuG3Pug/Vww5Xz1Ygam/y4/J07vHv3Qo+0tYHEMGtSAZtQ4m1mBVasroNd7P6hwEn4ZAPDy7U9gwQn+cttbic1hqlSi4w1btlz+NSaOQq9eWiyfm4T2e2YhWm2d+WWW5NjLVDFtsL/qdQCAxscAeb5SqQ/gUqbzEpGLIGKaXeN9//PsCTzyxFO4fPky3h+/AxdzStG+vQoffmTATZCOMaIWSpLngUANnFLQMhIdesPQoUPx73//G/v27cO5c8IWEpZleUpxIGBZBbRacd8pvZ6FyMq4G8Huly0WIK6V9bf99fN/4b8/KPDoCBnXuXjnxifEQqVQwswErp38859N8c9/NkW2gUbF0edRSxsRVxqHa4nWyWpFO++iEEdFCb+rCoUFB3dsRsd/v+N3nQMBUWT8wNf06KFGq5SecXsbX2HjxirZSgxg7YSiomg0faQYmvjTYHcOcitjMUXZFRkdy/eyD5ac1y2fjW3VpdjWZgiARW7ntVoKm7d0xrVrZqxedTOaNm2Kbm1ugqJSCQqABtWgGS0OHKjFoYPBid77/t3P46huCzIyrDslhsTG4pkmTcBY9GhdYe0YHzjDH8xsOfY4DexKjBAsrCODJsQz8EAlEwUAUI4BVeNh6cHImcFxHEaOHInMq6UAgLw8M774/DpWruqImBjxwVkluEtDmlBEMKY1gVVkPv/8c8yYMUOyjE6nQ2yscDoB73DUvVmzAugN4nmj9HoOcQp5f6tQf5GTkyNQ0g8U1t+2afsC7Nghr3/ae+EyTudfB6c8DNA0OM6C9vGt8fMbPyBNcxVXzhVi8R9z3K578MEHsW/fPoE7iqOmOajqsompnBZZVdHyApO+9moBHv97LP7yl3jB8wqFGSV2mYY/si9RZPwgEBFhQ4GFk+6EvY0N8dsi6cy8rtgsFQkdjwMAWtzlPrgyxYlAjPW+VeCfD5acr+elYK5uA7bXdIHQhKpnT+uyUbt2KnvcB4XJ2jnQFKChqkAzGhQW+RccipPw5mgSFY+p09rC/BoFFUWhncqqfHAWxzVNXHQok81vR+akWavUeC4UQCwBysHlSrcBKZLnFbQF58+fx4ULfB8dg4HDrl3VePzxBNFr1T74yHg7QejW5mZcun7aq2uiY7wq7hE5Ckp1dXVAFJl27c/bPx9JqZVM3KjXs4hXybOKCfUXVVWB3WlpS5qYfKwAM5aWyL6utEYHwPHClqMKKsrap3CUcBvzZoeTDQ0FKOpSHSid+ndOZR3yZ/zwIxTnxJOTXrliwOSfDYiLpXHf/e6/tUJhAWtiYLFYwDAcGIYDy3JgGAY0TQc03pAciI+MH+zcuTPcVZDF/uzUgN7P2yUUnY7fASm07taLdvrb7J8H5PFzpQRLzkN1JwEAj8Rmo0uce7CsZ/7ZRPRaGgyUVDUoi8bnbddyoSgKndRquxIDAFW54sG9HknwzuKhCbkiE56s6BqFGX/++afguX37pJe75PjRuOLt8ktiXCuvyt97bwwomYO7XOQMmoHadda27UUAAMNwmDChWLKs1UdGvN+5nJZm/yzUX/Ts2dO3SopAq6ztYcdB6ai5clDX2RNqDcKWHbXaex82NQ0o66LyOse6Y+o+q/68hBYmz9vR164ViSNDcUg5lQaVSoVR/zyI4cOu4JlP/4BSqcSVMPjOEEXGD1555ZVwV0EW5frgxH2Ri0HP72xplfuMXAXxwTRYci5BEyznHsO5613wzk2doHXadfTX3kNwW0/hgSWv+CKOZ+RhSdplrNqYj927fevYlQJROIWQijgrRJKXfhNqZfASh/Keo6aRlKRC0yaByUIMwG1rUuoB8R1uWiUjaknQ6/gyY1kO+/bVYM4kM3buqAbDeZ8KwFtnX6VcJ5A6Dh6sxYo/Sr26xpn9WzZi9S+3Y873Vnvk2rVr8fHHH3u8LtDhGs6dM6C6Wloh0+tZUCJ+SgveHIHS0c9jycvWCdArr7yCJa/ehSWv3mUv44syIAWtsqAgPx9ZOf73rSpOCZPJhLWbhB1vNRrvJxoaigNdZ5mlnJZfLXUO8ZZmUUjvf5PH+6Sniy/30R78+0IJWVryg6lTp9ab6L5SHN2zE3+u34Y4ixZ/n/glYmKt9urDaakoKCnEk0Mf8+v+OhcLDqVyn5Fb4Fj+UgK4kJGOXn36AQienE/iFpRSLZDZphse1G7Gb+8nIf0UMPDaf3Fzm164zH0KFu6zpL1n1yA165Tfz2dsziwUBaP2FgDC1gJaYQEQvJ1FNEVBS9MwBCDnlBQL5w5Aq6RSnMu6I2D3VLt0YX+mbMXA+x4BAHCmaFBqh/UvSsGKWhz0dcq2ycThP29fQ7bzbrytALABnHteSkl69uyJbdu2yS6vVHj/G98oNiP74kV06dHD62vPHFuAPg+UoxmsS7qZmfLyoXnrszb5g7fQokMn/OuDTwXPl5V5tnYZ9Kx9OceVXm11qH6yFl1yrL/t/C/fw03PFAEU8Nvn/8YL42Z7VV85cCoGO+cGZoKlppS4fPmy6Hm5lr2a6/1QaqLRseMZqCnANj1x0mNgqVM+zC3aAPDs9xUbK/5smg5f3BhXiEXGDxqCEkOBwpHDO/FYzBN4IOFRLPz6e/u5E+N/QcGvf2DWb9P9eobezSLjmN1WVlXipZ8/h0nhOKYEsGq3Y6dOsORsNFtnOqdOncLvxivYu6cGVwuqsDVzP+YeX4ns80qkpxtQUOCwIHEAtKrA5GxxitCOquZvQxcnY+uDCBlJ/tXl17sHI1br/Vq8V7BWi4NKZqh5efBNMrUWx44VVs93VFQrGMTECDuV2JZLVSrwlRgnsl0iB3ti8uTJSPAihYBG5X1SQ4OBxa51y7y+DgBoly3lci1I3lhkxr33BmoUGuRnXRQto5GRnkOv50CJLO+ZbrMqVoaO1jhCifGx9mah4YJjjWaVJsQ0D8xAruIUSE5O9vq6m27iWzbNZg2u5fcBYPXho20+N07+KrZwBWpKA52M1AVaidhYFCX894faPwYgioxf1JcUBUO73iV6jgMHc62jA2tucARAsrDFsHClKEn1L4CZ3sVHhlY6zJVfLfgR/7plNWp6OBSX7lE0ypzWi4MlZ01dzpTDhw9j7pwyzJlThiWLKzD7+HKMSZ6FV/+bgvffK8DWuW1512nVgVFkeNBamKJu9enS43fQmPK4AlsGUvjkNe9faYWCRTMVg6YxwsGvAgUXFEXGxdqncPz9bN05S11Wa7WSFe1kbcq2VCc8depUr2snllVYiCMX5FtvbOzbV4sDR8VzRElhYR1LWZfPn5coyccbRYYyVoOJTYChpXigPbWMiNjVNSwMWmELAm3hW7J0OofzrVotvjTiD5evVMJiDkw7VkEBvV58FyhFUbizz8Nuxx/7G/99tShrwTilS6Bo699ucZp4MXUWGQVHSVqBbOhcJqEcx9kVXpomS0sNgjfffDPcVZBFq9hEyfMKs8K+cqHm3P0lKD83mbg6B1NOL0DTqAq38u1UNExOTdMbOR85chCDB98rq6yCZZCQUIioKOlZm7GCP4vXBMgiY4Orm09wtNDSgudOPr8thYpYCr8N9c3XhaI5dLpWAY0qgL4rAnB1CoUigIoMxfLrrHa6t4E2QwWAYVRQKi1QKS2iVgejkcOFCwacOik+oIhFQZWipET+31qt9243oA05M2shjE5ta9Mfi/HnmUsSpR14s7SkUmhgk+ilc+ewYepYmKISoKkpw83PWo9rZDjLz/+1DAnx2fjnM+7nKItDIfvti7fQ8oZj4qVUWpWfbbMmYVDn5jh+Rf4OIym2bK3Ea4+ID5/fPaDBN8ny/KpUUEr68JSVlSE+pgnvmFqpQJ8+UXBW5FmFCWYzgwP79TAYLShMP4xrBhPUeg1adm+BTp062cvSHIWMjAyPdTPoHYrLihWV2LC+EiwLDB8eB4oSToUSDohFxg9WrVrluVAEoGekY77MXuVwMlNT7g6HNGNtyN+9+zy+/fw1DBzonQncVat3xswKN0GWo/HqpM/x/s+fyJbzJ6NnInOpDp/8MFNWeSVM6H/zLo9pFrZfOIyMjAwUF1t3Vmh9WAKQ4tEDWwAAnJMfDOf2QRw5PneHitxzWDmw3iCaCrLTL2NtW0ofouSKQbsqMgLmbsb2XAlFJi6Oxn/eLsCCBeLKRCTkJBPCYvZNkamlHQNtTU0l/vjjD1nXeSMHJe2YBW1cvRS1zdrC2LQFqtp1c5SROZ2eMiVbOPGj2dFntTaeRfxLjuVFlQLY9svPaHJ1O/7vLZXsZ3mivIwBHcVgwADhvkCuEgMA6fmZKC0Vdtr+xz/+AbVajZ2pq3nHTRYG16+7PINlYTLo8f331zFhfDEWb9mGPXv2YFvKVuTm5tqLzXjuPVCsvIjpLGvdMbZndw3m/1qGkhIGZWUMli+vwK7jwgETydJSPWPw4MGeC0UAnpqV0eTwCVDDXZFRMBx++ORNxBaVIe6K97NSVx8ZZ1hOpAmaYnBr1jB0vzhCtpyHl/TF0LhojCiVl9IgsY88nwe92YjVq1fjfJ35PdBLS1qDVdHkaB8VCYmleova2qnXmIUHaI7j7AmzoungGmi5OqW1bVJ6wO7JuMTeaJrosK7duGHEju3VOHPGAIbhoFCaRRUZT7tmACA7S54zbKgRUmTGf/4yxn3+H8nrlLRjNwxLyVcu870ILhcFx9KOvroMrKZO8fShrbMsBIP1URbHvaLudfk7FDTUBdugG56N226LwoSJbTDi0Tjcfnt/NPt5ruizxox5A8df64fvW7UWPF9WxqBlv6s4d87/paunl74nem7lypVYu1Z4EuKqL1AWM5rlCrdRk1MfP+DiMVCgZKei0OtZbNniboUrLo+cgLBEkfGDvLy8cFchIDgrMiqBhCY0w4Kq9n223q2r+PbBWIvwbLJ5bXP75/1HDwiWqa0qx5zfJ9u/99Ja69hDK6+u0a2tsyBvU+IEemlJfnpDYdgoL/4Al+CI5tqNyCs9AIaioPVy+6+3KJ3iB23evNTn+5w76/AJMar4ikyTztZZ4pYtW/D2W+mYOLEYX/7vAn788QY4yujRoVVqg0jPPiVYPOM5n+sdLMwm/mA69tN/4/Zh+zFwmLTPTbzaobwpafkWhLTN6zH5c8/btAGAcWrbCrMFlMDOOG/evw3r17sfdFJkKBd/GZpWAg9lw2RikZFhgFJJ4dFH4zBgQH9IvXcmU2tEqxRoJhKaoKzc+h41bSre17RpGtzh1e3unDVmjFAbNhodv++OEY9AabZAoZDXTxqNHM6eDY6vUaAgPjJ+EA4Tmi9wHtYn+IqMwNISy1nd4H1k5swS7NlTg/ffb47mLfhNLooV2CFCcXBWFf4sFzZlvzt5Lm4quhmvFXyGeR97l8EaADhLnW+Kl9cFatdSoOBcXVtYOHo5jv+70ex1sArHFifWfBksgOK4KEQbg9sdMEaHGf7UuWMYOfJfXt/jpzn/xC1dTmHLsZvQpKYDaAFz1PjJL+HzDxfxju1PrkXelUNY8rv0/aV2oHMA2vVJweI5U/D8G+97XfdgUVPLnwzEaKSDy9noN8iRvFNByU85Uq2NAnNJOujZT28+B3VlDS9WkoqxwMQy4BQufUCU/AH/xvUCt2Osk4+Ms1IDAEqV9d4lJQzefcf52qV1/yTggGsiUah1dRskoiViQb0yNBqjVwdxOVKgS6YpClFRCtTW8hV8s8vfEV9TKntbt8noXQ9JlpbqGSFNeR9EDGanrc/OFhmKA0WzoDkOzq4s3g78FRUsjh7V4fPPr9tnxGknrbNqihK21jThKDwcr8Rt0Qo0rWwuWGZkySDcGxWFDjesMTQYb00rtk7Pa4tMYH1kKAAvbl4tcRbgJKKaGsr5s1DKBNFpLkcJb7G+1iwOVJCzNWdd1uHkSR0OHqxFudHRwX895V2MniIv+dyt3Y+BUpgxoMspdO2/XrDOndvvFbw2O6far4zUulqrltMuwRp0b9z3H2P6hP/6fL9AcSm/gvfdyDkG9pTdW2XdQ6WQP+M20CpYmkgHabMoYlDW42aUNOtsP6bg+BaZkhILvvm6EJN/lqd4AUBSiybuz2Ic/QPF8gdRSgGApb22ugKAmVKivUraSqmNEh+0O7cMrs+ZUiRAYLTAPMt5aQkATreLkm2ROXosOHnkAglRZPzg6NGj4a6CLJwVFSGMFjMY1qrBq2jHi9vj71fQ74Us0LQFYq4sYrw59O9ux65eNSMz01qXrdvXAABaWISzsXZDIqJpCklqGglmYUvBwBglWqlo3AOr97yFkx/XYc/WVVDXbZ+U28nZZhpR6sAkuEkcbt1NpgCLp/ZsxaNnjoiWZSXGDVONS2fLWf2ahFCajwseL0qIRXppcEOLfz95Pz77tBDffVuEikrrst7nU9/F/f23YHD/rfhkxrte31MhkChSqhn4pcjYfL1aZmHGxG8w8J516HO7cDRWANiwYYPPz/KqXgb+ciFPkUkWVupcUSvlp40wmUzg1NKKjKG51beEjXZEUqY4DhRjfedu3LiBp/+Ri8OHdTh3Tv6yVrTLDqffXrgbMDuewblYA2gVB9Astm2T78/xz7rUJGZahXtjhCNBN2lirUezpuJWTDYxuEu1boaPuu9CFi7npSUbKg9Kmg2p6L6RAlFk/OD//u//wl0FjyxYsAA7s8QHSBs1JqvW3SqqHcZ/YXU+i25hhELNIrplBWjagp7/l42k++Q5+0YrhAd7m1MlY7AmiDOJOBnSTtvAu7PS28fj6tIbMFJery6knt5nTzzivY+M/xYZVbQKTe+zZqK1xVWJNkl0GHX9ZWmzPrjU5W9gKelXV+miyNi+UZz49tOoIPvIOMNZrB2rspmjPXVs413CRABo1cXduVEpEbslEBYZANDrK+yfVy10z1hcUlKCxx9/3OdneYPeyF9GYJ26daNZXgZulZLBqFGjZJU1mUx1pg7v4AAoFXq0a5eBBQvme309AJgs/CWSPj1U4Po4rE4c5WKdrLNkHjroRSZyWz4izgIlRSFa4F2zxQf6p0Q+No3MFCS+4qrIxMbU4OWuqYKKjKtFBpCvyBRc8y7+BllaqmfMnh340NeBpLi4GK+++iosrOdYFrUmh/lwUFUv3jmF0oymLUugSjAgrms54mIVaNFCgRYSptMmKuF08bbgeLTC+nKYRTK+UnDcuzMtHXHWlq6e4eTH7FAwShhYq0LiyYfIlUDsWur6ZVdo21mdW1R1ypxChkXpdP+3kdthGK63cQ5y6NJxSFhkwBpQoc51O9y6ogbdY4WX8IIBa7QqbX0NDgefbqznEP2UxWW7dVN3nwkpXSUpKQn//e9/8fSIXnj6mSbyKluHc/JTxumnunjFPWDk0qXynZk7Nu3oVT08wYtTJjMIlFJlQQu1ZwVdq9WiS5cu0l7RAMDrc+xqNLrddApdup6E0ehb4lCjy4BcNZi/4YJz8eWzpTXIz5c/GNvG4RZmq9L/cJy7VUZXl5urW3fxNhstsewUCFwVhuhmlWiqNiBK4LlCiozc/FM5OcHJVh9IiCLjB5GeomD58uXyw46bHM5+MQp+aHdKbQbLKDHpp2I8OuIK9u2rQXExg+Ib4opDgjJB8Lgt75KirnNz3T5rQ8E6FBmtBw1fbVNkvLDI0BYVipV1AZ28XFoKxK4lZRuHSbpI38R6f9tz+E8VvL422rEttCzehDiTw9RPwVmRsV3P2f9/osVspHZI4d2vLEaLJzreIv8P8BPWZMB7s95Fy66OeigU0h3mmHGvglPKMHNLtPlOnTphzJgxeP3xvnj1Ve8iGeucEktGsY7PQsaxDz74QPZ94wKcGkLFOayhCoU8hUGlZNDNZMTDD7tHkHVmxIgRuOuuuzxaZGxLSDRtwe0D16Nnz0PgKBpNWt2QVR8xDGbpbeKU68us8j5mkf2NqVOKYgSUNr2eBcdxmDFdPGlnlER4/0Ag3i26TyKFFJmSksAEB4wEiCLjB5GeouDEiROyyzpbZJQuW7AVajPMAi+CFLEiyy+2mDLKuuUUoSGHgzXapQ2Nh/V7FWi8+b+NvMSThw578A1gzPZAad6ioBXQBCqyFgAG3pvp89s/iMq4TgCAsngzHsnpgTv1eswvtAYME7XIAAAFqM18mZpUSiibcvjL7S84ivnQD0/ucYuschajCXd03M+vllraqfDmHvxlpMxMI46k1GLv3hps3lyF1asqsHNHtaReeurYMRw/fhwTF5/E998LBFeTwNkiY3bKSK4VSWYoF8YL3y450E4ObSpKXPEzmx0zcoWaATgWd911Fzp2FLcQ2QZE151Hznz31hvgVNZ7N212DVFRNWjZ6gpYSgHO4t/ypd7kwTpAu5wXSFDriePHWej1epSaKVQzDKIFFBmWtSYYPX1GfLdXtJaGSgXExyqgiBf2BfQHsdeTotwtSEKKzLVr1wJcI9vzQ7+0RLZf+8H7778f7ipIIpbpV4jC+KO40eMMWlz8B5Q0jQ9+fAsj77Seo1U6RF2nvVqAKa4R1vZtS0s2vxCxJq/mHE0zipM2gWppCv9XG49KZRUuKS+iryUJRw7uwj13PyR6jdJosgdo88VtIkqlhdHix9bKALzrp259Hw8eeB8A0NQYja8Li2GhgQNcnJuPjA3bMhpDC8zQtBUYMeB93Nb1QeTkTUPHxKYor9Vh+/lsXLoub9CX63BtNpjQwtwU0DpkSKml5RmjMvNsbjOml+D8eb4TY8+eGtwuEXl649ql6Dfwfmw7fFVWPZ2pqHBSWJzEqxFJZigXk1mPru3VuJzv23ILYPX9sQ0grJOVUyVh5Sou7oS2ba3JHJUqFmdu5GDX3BTJVAx2RUYioF0UY4JNJWWdFD6OosGxGgC+L1UYjNLXcioXxU3p/bMuXqzChAkTMAFAS6USTzdpIlhOp+OQlyt8f4UCiIuhsW17F0QVNMGTB/+Ngrmve10XSQT6kNV4FGq1e8Rdf5x96wNeWWSaNm2KZs2auf3r3Lkzhg8fjl27dvlckXHjxoGiKJ5yYDAY8PbbbyMxMRGxsbEYNWqUcIjqMDFv3rxwV0GSKxfk76q61mIbyjtth67ZeahoNdqfdvhR0GoGjMz1VBufbZsseNyeZVhkScmG2sler5RhseipVeDPqEykK/OwTf0nLGbpaziKssf293bXEgBo1b7nJbrlllt431k5OQYE4Op2mKkYhynfesJhkaE451g5judYXGeuTvXoyenQv30bJERp0al5M3Ru00p2naIlZurOmI0mKC0uCofSw+4Vlt/xCsXwsJr8xW9x6tx5rxR8ZzgOYOrkSjMO65/Gw5KYJ2JoBf73uue8NSNHdhc9ZzA4BnDOSd3TyFxayr1ejaWHT3rMJ2UbEDmBrbv52dmY8n9/g66Nw6JjcbJ6WrQaGBn/FgH0RumlItelR04lf0eUGEJLS4C1rTEi3diTf3Usz5dXmlH0++d+18MVV8OHxaLEOfSESum+o4xhGGzYsMEendx6ff2IgyYHrywyU6ZMETxeUVGBkydPYuTIkfjjjz/w2GOPeVWJ1NRUzJkzB/379+cd/+CDD7BlyxasXr0aCQkJ+M9//oMnnngChw8f9ur+wWLEiBHhroIkt9P9sQ2nZJW1WUos2lJoaL5pWaFmAZXK+wAyAtjM82qFtEVG5fSSXeWq0UHGvSsU1p0JVbQesZDeIk0z/sV48DXf0k033YRHH30UG7HRfswkEg8CcIi8MqYLDNFtBMtEGTncnHEBuNNxTMFwiCrrBYVFWA5CigxXp8iwlms+22q1MkPPm4xmcIz7Q96Z/29Mf0XYiZ5zWQosLXMf1HJzzZKKzLHUNHwRHy9ewAM6HYu4OAW0JscAqfFh1u/M37rdiy7t9kuWSUqKxYgRHVBT0w7Jyclu56uqqhAVZW2Tzv6uapl1O3qqFKwMjV6rtSrwrMDvvPSrL2Dox8/gXni9GisvVCAujoY2SglG4Df3Bp2XFhnOk3LsAY4TV2Ty88Tr8ta/EuwzpJTTVWBqytzK3NnlNhzNltc/C+Gqh9TWWn2+lCJ9U1paGtLS0jB06FDcc8+diI0V9+/xh4hfWnrhhRckz99yyy0YO3asV4pMTU0Nnn32WcybN4/nc1JZWYn58+fj999/x0MPWZcIFi5ciN69e+Po0aO48847xW4ZMs6ePYtevXp5LhgGfv3u32ihlR+wr7ZOwWCVemhdtk5TUbR0yFMv2LChCs+/0JSnyOj1LObMKUXanwa0b6/Cd7fmolNsE/s1tEBGbiEojrIPxlqpwCsALLDg/PnjWLeuHKWl8pYGnB2nNT7uXHriiSfc66JgPAajS+shHhI+ygS0KXYs5VEAlBYObTOds4bzbTKMgCJj44YyjfddrsN4i/h2iJVpkTEYTGAZpZsi+1jHPaLXcGa+InP1ivDfUF4m/nveuFHqs0UGsC4nxMUowSodg5vWjySYGnUUeid2BEVR6NQpAVevVrqVee6553Dfg9cQraHsyoor1dXVaNXKajmzUA4rjFKmIrN2Y6GscjfddBMAd4vMr5MnwNyW39/k5ORg2bIVMNc56LZosQxdunSBH+KH2czCZDJh0fdfwlCWi74uETBYJd9nRZZzuATFjEVUkbl+XVy2WhpAXTP8ZYWwL8rHw17DmA3T8ed1z1mohbC9OwyrgIJmUFJine6pPViLU1JS8I+nY3D9enDjRoWSgDr7jhw5EhcuuG9FlOLtt9/GX/7yFwwdOpR3/OTJkzCbzbzjvXr1QocOHXDkiHhcFKPRiKqqKt6/YNFEZO00EmhX0MErA4rNUsIo3Z3XlGoWFKRN9t4w6okcXMyuM2FTwNgfb2Dzpmrk55tx9KgO/1j0X+hNDn8JtYi+7TrAqp2WoKI4aUVm04HDmPxzLrZtlR8oyznMt0YlHCjLF9qUWZUizkfHmQdPO5RM2x0UDAdWwA/GpsoIWWTE2P3nWc+FAAy5+UlEyc3fYrAIzs4VtLjCTBvkrel/8YX08oivisyQIbFQqwDQFjivkKiV7oqMXP+DF/7yAdQS8Xtad2qNLl26QK2hQSss0GiE27VzP+f8uytV/vnvuBIba233rj4yRWknwcTw5XrgwAG7EgMAxcXlSN5ntUzcd7/vQSWrq6uhN5SD6iOg1Lks07J+KjKAuEVGipoYR9tu30r4N4tSR+HT+17zuV42k8zWnH8hPf1BFFzrCQBQewhWqNPpoNfJS5jriWaJKrz7XnO8824iRg17DDNnzgzLuBhQRcZoNMremw4AK1aswKlTpzB27Fi3c4WFhVCr1W5CadWqFQoLxWcPY8eORUJCgv1fUpI1r0x2djYmTJgAo9Fot/yMHj0aBQUFmD9/PlJTU7Fjxw6sXbsWGRkZmDZtGqqqqnhly8rKMHPmTJw5cwYbN27EmTNncOrUKcyZMwfFxcW8sjqdDpMmTUJmZiZWrVqFPXv2ICUlBYsWLUJeXh6vLMMwGDt2LHJycrBkyRIcOnQIycnJWLFiBbKysjBx4kQYDAbeNYWFhZg3bx5SU1Oxfft2rFu3Dunp6Zg+fToqKytxU9N7vQr+ZQv2xSodO0cYhoPZzIFWMwDHobw8cJ3igjV/YuvWrdAbzDhyhL9bpUJfjW3nHbuOtJwK69atw/bt25Gamop58+ahsLAQZhdVzXmnk5rRYPvWbViyZAlycnIwduxYMAyD0aNHo7a2FgdPnYe3OCsyaqXvigzr5MOQGPcCVH76DaidxtFy4ydIOv01lBZaeDZaJzKLzPgi5bXycvB8PPw93NPnMWhkdvp6gxmsyN89evRolJaWYtasWUhLS8OmTZuwefNmsKw8Ra+iQtp6OH++b8HYvvhvSzRtZm1jCo2j7dkUGec+Qsxy4gotcymOAhATUy7av04Z/529j6Cc/cvUZsE+4mJGht3RVy7duzv56CiUyMrKwsqVK7F3716wMe5/b3a2+2C5dKnVCvD1163wvy89+wUJ8eOPP6LD3WfRp49wMtkzZ/SYMP4GJk64gTNnrX1Lhw7CyqL2Ec+rB0IB8QDp+CqswtFWb+8nrDhHqTQYlNQfvVt09VgHIWwrONVcHMrL2sM2nMsZg6tr3Daqe80DD8Rg+vRu+Otf4/G3vyXgrgGDUVZWhtjYWIwePRpmsxnjx49HdnY2li1bhgMHDuDAgQNYtmwZsrOzMX78eJjNZrfxeMGCBTh27Bh27twpOzp2QHctzZ8/382RUYy8vDy899572LVrl33dNRB88cUX+PDDD+3fq6qqkJSUhC5duuDTTz8F4Ij/Yvv/K6+84nafPn36CJZ9++23AQD9+/fHwoULcdttt+G2224TLPvRRx8BAHr27Gm/71133SVY9osvvgBgNSO78sknnwhe89pr7tp8v379AADV8C7Qm/PSEsdx2JF+Ed8+kQOzmcNDD8XivferYNgRuG2i14tr0b17d+zdXixo6Zmashj/uvVvAAAlxWH75eOY87FV4R04cCAAIBPnoXbSxVWcwm6SuM+UiLnppzHmU6uTnU2+X375JXbs2AGG8f5vcd7COOL2l9AzLhXL0rzPQ7K3rfPWcIX/rkdO47uBuR/aWoCq6QODgHXNBidh+bDe0Fqrkzn5ko9+pNc9mDnyO6RUZKESgEIlr0vRGyywsDSEulxb+37zTevS2C233IJfp36Gzjf5ZoJ3paDAPYieJ955lx9dWql2/GrKOkXGuY9YsmQJjh07Bk+UVxWD1bYFIOx0TtX9uBQ4REdXo1cv9x0pANCp0ylotVp8+eWXGPulwwVAobLY3xcbB1b/D3mFU3jHtFoaBoP0O5GVlYWDBw/CZDJhwIAB6N69u125OfrH75A7zcnIMODsWQPMJg49emhw8aJ3fizPP/88SkrXC547fVqPzz69Dkudcr9nTw3GjWuDVq2UyBXYYaR9YCgM2zdJPk/MIrNxozxrv9iEkgKgUiix8pmp6D9tpKx78a6ve+/NLhm65SgyNQHIZdm+vQotWzpbfSm3Meqzzz4DAGsQRRds51yvefnll+1l5K6oeKXIOCsIzlRWVuLUqVO4ePEiDhwQ1pJdOXnyJG7cuGFXAgCrZ/WBAwcwY8YM7NixAyaTCRUVFTyrTFFREVq3bi1wRysajUbU/BpoPAWPCjd5FfLSCQDA5k3VuHDeiBGDTqFbVXvsysiyn9u2rRrNmysQFeCQ25O++hQtY4SbIC+uDWcGV+Xu6GrmGMAp5o2zRUZBtcabZcLtRG7WV1ecZ9mtmiQhrpUGy+C9IlOpcfaDoECBQ3lCPzQruR2Aa5I/GVYIgX6SZrRgBRIB0nbTu7j6REEFDtYOqtogPsi89957eE5xd93SiHUYy0uUZ5HV6y2wcPKX0kxqaYXKG3yxyNx7L38pxHnJRtHlDFbM/BeeftsRzbdLly6yFJmVu2Zj2PAvILovzClKovoihZatygWLWRTCvxOtdlcvet6fjrffugajiQUFChQFj0qMjb17rUp4586dcSkjA93qJnyUF8uiX39V6NFqJoXr4GaxcLh61YR27VTYtrXarsRYzwGbN1eJtnZFC89WIV+WluTB4cwdnyLGEI/2i1ojv0qen5INe9Nw2SwgZ/zT6/z/mw4cqMWLLzmCSgY2GpJ3eKXI/Pnnn4LH4+Pj8fDDD2Pt2rXo3LmzYBlXhgwZgrNn+WvvL730Enr16oXPPvsMSUlJUKlU2LNnjz0HSGZmJnJzczF48GBvqh00Fi1aFNHRfXdf9pxjyZlLl0yYfukMgDNu55YsqXDrzP2F1hbghwXCSQyrTY7cKNFKLZoIWHHNLq9OVXklzhWeQ5s2bQAJX1zbOr8YD3ZXYl+Wu99DtEta2WquCQDhgUWMGq2wg935Pi8jSud9aAGxDpo2R4GNclhkbLNCW/weAGAtIlFWadreK7UQCM9uQ6PRwBGD0PoDyV0l0xkYryIxa30PsRIQmjXjd5VRKn6DbNGb/675k9NJGA60HohrrkBiYqJ9wtamTRGiY2i0bKl0LmpHoea347Gfv4VBw2BP3uorJpMJm1csxfvf/+j2TABo21bcV9IfJQawKjLaujnF6dN6fPN1EWpqWCiV4CkxNpKTawVjC2naakBFe+7TvFVk2jVxDO7l5Qwu5wn76XCaKmgTisEkFLv59sjCZpFxcbCXY5EpuG7A4UPy/QOFcLNwhXE3t1eKzL59+wL24Li4OPsyiI2YmBgkJibaj7/yyiv48MMP0axZM8THx+Odd97B4MGDI2LHEhD5KQrOFHrneO0JZYDjJy1alSq7bFeLNez2rgN78EfqTnzwl+ego4zIpqvQiW2JxSfX4qvdU+3lE4dSeGWAcFJPT/4Lj/ZRCSoyrjCc9wLRq4WtZDTr2xZellaBEggwRjNRgo6OFUbHMi7HuVuTOI6DRUXBNsHv1aYFIDB/iY2NhVKptCsytaZCGC0ZMETL8/nQ6xl4YZCB2RJZQcjb9j4dsBmoTQyPP94DhVmd0cHUCa1UNE7GZKAyxmIvQxkptGunwvffj8CNG1a/invvW+J+P5VDVq4WmT69DgWkzmlpaejV3LqNPf1EChRGflLGrt3kv9vecN99TXHmj4UY9BzAshx++N6qxADCSownqCjPuw9jZTqwA0CCNg7b3vkWNzAFALBkcTkOnRJeHqHqAn3m55uRX+n9JIaigLyinrjBtEEPOHYtylFkVq0M7NhQV6Mg3FMeER3Zd/LkyaBpGqNGjYLRaMTw4cPxyy+/hLtadkaPHh3xyowUgwfH4cgR+Vr5vr1eZJCVgS04nhw61u3s+GPPafQvGo7vlvyB6jOpKCkvxYOtB2LCHn67GLP3F/xf3+EQ2oDuaWlpd6bMHlGm86kzrn8xV/cfhUWeU60rjEILoUipHBPL24qqqMuNwzp1NlEWi8CVZt6OFLFUDAMHDoRKpUI1LGjFADUGeTubbOh0LFhW/u/PsDR0OharV1Xg4kUTevYKzfKxGKxG+r0ZMmQIVqxYIetetl/klltaoyT6FgzQDUZ3rQKKZmpcZIsBQ50iU6eX9uh5BKVl7cBYPPsW0i67lqLb6SS3DcslMzMTTW6yhp5YteBX0B16uJWJj6dRVRXYBYfevSnE9LHmcTt/3ijbumNLjeIKFSUtw25qNVSUNYWtHB+gQe37Q6tyKBJR0VJ9hPXc0iXeWXVv690cH/wvCpYbf8F5XRKiWvL75fDtpiWKDAC4BXrSarWYOXMmZs6cGZ4KeeDzzwMfrdFXCq+egq66GF1uGm4/9n/9HsEf6dtFr/n8i27421+FlwsjjZi6d2TgjVuQSBmRMvd35JZY/XiOwd0XwcxasPLMVjyZ1gY33XKr23kpdlwwY8kzP0GvtOCI0pHfx7WDqLK0BMDP/wMAQ3t3w+7zlwTvbVa6vuzW70qLAb50BBZlFCi4D6osE8vzkVHS7rO0KMYIt7kiZ7TGV69DK+K8a3N8VnlIHyGFySx/ayxnpvHl/wpx5oz1mmPHvPdNAoBBd0Th+DHvlMbBbYQzubuyf+dm3D/M6rT56quv4uv/fY7rN7wLOsY57SajOCffE4oDXScuiuIQF1+CijLhOFFGgxEHDtQgPk6Bnt35bYo10dizJwCengCMzZrV1dn9HMMoAxauwRmdnkXffslgLEoUeqGQnUsXXkqjPFhbOtZZN2JoGlUyYmntunQYgGPDhtLtfXew/sQeKM1V0HqZJfvU+RKcP98SvVtZ382el9MBrcOypAxgHjgpunbjv/tNqPCpE5Flr61n/PTTT+Gugp0DP8zCmclbcWjH7/Zj3w99T/Iai8X3QSjUaOoy+g6OVaK06E+7EiPFxZIr2LVztdtxOf4LTWPj0b+9NW6R7V+8S0RYs3YYhvSMw7Du92Bot7swrFtX3JTUDLFacbmyAm8cR1FQMuKDa83ZW0TPbR8gvEzGMrEA5eh4HX+zU9ZmATFwnAmcU2ZjJU1DIWDBYkqLoM2/DI0fcyGDRXhw2bjcPbJv8bUSuxLjKz16avDwUO9jyDzfVV7Cv0MHXBOVyhvJ7ZFQKYBzCn/grCBEpVKgDI4DQjmUVi6eh/Pnz+OnGevw/Xc38PHH1/HfL6/hz+MOPzTWRNujePuLobnVmT6Kdm+DFj+TQ4o+s86Ky1jUgikqAk6dyIUSR4riFCBRKvXY1F1LMWtWKaKivP87liwuB8BZrblsYGMFyWXkSH5/GMUF1mLvDRFlkalvPP300+Gugp27WjwPANi6bT7uGf5PAECcRtqRzdfsz6HikYWv4C+9HsD/9R2O4njry5qgoDA1ZZGs62tNeli8zNpt40JlNu5pLrSjwTE43dTpLrwxqAe6MP1Ry4zAfvYI9OUHcPiC+IDrqkNxFGBUa6A0GWBRuA8INICa07dDcJ8ygIP9Y9BPILYVx8bA2RG5zHQdHuJk1V1oBOWkyFAUBY1SCZ2LHE06HVTV5eBauQ/W9/XojAMXPUcNNYnsiMq4egp/dTl2PP2qx/t5om8fDebPdw8V74l1lwvRcaUSNdUs2rfTYPgI4feKckkeKT/8AYdkKKBDDZpRLJiE44BxsHUMrbsFZabgHPpHIRCx93L6aaxYtxU1tY72d/asAT9+9xVWb9kBwKrIRMcERgHg6mb+lEDCoWBNkmyBO1lGjZjY4CsyyroIzt4oMnarGgVZOz21Wu8tsXl5Zti0LItEQMVgkpBA4733rtmtXT3bzcWKM8fx22+/oVmzZh6uDizEIuMHhw4FxnEukMQw/E62iVY8r0ykW2TO3cjChAPzMGjW/6Go0mGiL66Vt6ZcaC6FUiCBmhyqjbX40+y+bOSKHmrEKpYgBs/ienUxTIxJ1K8EgIAZhIJeGwWlRXqphBax2Kjq/CRcFSSWi4ato8ur4Tte2pYrbAMt59RJc5zRzZCgEVheMloY3j2cubNLByhldPwVFcIzOE7DIftiOlYsneBcab9Zt64KhYXee4TuvF6FeXPLsHx5BSb+VIShQ7KR9qf779E81uU3lKnHGNTAalqNLSgGBw6Xoxxysf1WCs6xtAQASoFkkBRtwvr1692O/7F1p/0zY6QCZsmYOmUqrly5AlbgD2WC1Le0qltOYS0qqNV+NgoZl3/ewxrjx5udS0eyrdZihlN4rCMFyieLjDMWgf5m5DB3n6VA8/13N3hLdpnX8rF582bBTNvBhigyftCxY0fPhUKM2skBUG82osoovh5uMYfXYdIbXpn9lv1znMw8R0XmcrQ0us9W5CwtZRRcgqnOvU9lqoE2z+HzEkuXoLS6EF8sHoUh445B+UM1moyvwkez5+HIpSJJRcbd2ZdCYmU1WFolWu66lgbNCFuWNIxWsD/mePvPObfPzgoIR9GwRNdts+ZMdl2LrXNaFPKTMZjF/RNaxsfitfsHoWfrFmidEIf+XfsKljufI2y1USlZ7D/7Blq0nYPxY63BsaKiIkvp/lXAstN1AH9pqbBYnsJtcmovRtoCHe34bRS2X5fjeEtLQhYZDeXZb4g1U4gJkEWmoqoKFRUVcG5fer0e+flZuJqTi+rqwEcWeXiYH4mafOBiW6vMvVFk0vNzUVXVHGmld8hStrRaH38PW5Ruge2kWpkpMhoKRJHxA0Ysh3uIWbHoG/tnNawv+uxjy9F/2kiwEou0Fosar70WWhOgM4MHe5d40SbvWA9LZjZMJhMe0A/BqZMpvONlZZ6XF1anboNYEO9+0dugpFWo1lfAYObL12Rh0CJeuH7dunVzO9amKB9mbTeUJvYTuMLKtWhatC4qRnjXBYdYYS/MOiwK/jmOtg6mHOc+mxKyyBg87HXt2iIRr903CB8Pvw//GPJ3wTLLllYIHlcpLejQ1BocrHlba6wbnS70szwpLpz3XJ/b+rn/3kKYtY7YW2bazLPaJdU5aVMAVPmO30xZ5yNjMTt+Gw0trMjc0tdxfwujRIsWgfMoqKqqQgztsCBdvXoV8+f/jg8/kB+MUy7P/quJve4Wyv/cb91+8Pz7LBhGY9sAClc7yd+CbWIY5OZak2tGeVg2oiggyktnX6erAQAWgUStGpVvin90TABMn2GAKDJ+cP164F9WX2APOWIQqDgNUlJSMCZ5lqgzJWDdgmyxqNG9R3isMj16qNGylXcdanFxMcws69H3x4bNxLl75zre8R9//FHW9bZ+0vXV1tA10IpYhYwWCzRKJRIEtnWqVCo3haR7jlDOJ5ceWqJvUTNaQRVHQUlHLM1PdJG9bcbJmaCw62bWBwtZmIxmaSXeeQVNr/SsOLZNe9v+WePka9KCosBxHLYfEA7NH04uXDBAp2Oh07EwGt0nDF2TROP18mDUjsmE0SWTtsKW+Z3joCymkDhViZwcE06fKcCZM2fw+xIlfl9WjiWLy6FV6NG8eXO3+1NOG4cN6ua49dYoJCbKH5ilqKqqAls3jBQUFGDVqlUBuS8ArHx6CkZ8/RD+9swwvPH0VLz4omP3WHx8KUpK/JtIUrTnQbs2isLCYQpE/dVdrmKU1lTbFU15PjK+DcMsWJyM2S3oI6P1IuehDVpB44MP5Dm2S2F3Xg8hxNnXDwYNGhTuKgAA7mv+rP2zitLICsF+9913w2JRI1oyzkHwuHjRhIGDvLPIVFdXQ0MBcWrvFJnmLP85e/bskXW9XTKuPiNUDVQivjdGs7ilQugFV0OGz4bE1FNt0cLgwXxtv9rpPq67p7i6bagcZ3TKtGTlUlGx2z1LamphsjCiOhYNDo6z4vU/klKLoztioKhYgX+91hHN+uVA4zSYK5QsLl70LrlhqPjP246cTQMHRmHsOEcajYMHD2LdzqOy7uMc3t/koshUGhxt19idhSaTxtqlldiyNx/Aafs5tZrCkP8aBZdNFU5LVRZYFez332+Or77yPgibK1VVVeA4Cqmpqdi61TW9hn9QFIXOh9vgUm4OdukWYN+fBdDVsmjWTIFvvm2F77/zv/5yieklP6r5qtQjuPdF69b4GA+KDEX55uwLAAzFgAMHVmALuUbpff7Cp+a8g/s7bsSY0T5VJ6wQi4wfrFmzJtxVcENDqbFgwQLJMn37dkazZs2wb99lbNwgLylXMIj20sntfPoZ0BQte2mJoihw4PBgjby0Ge44bVV2+qyla0FTNDQq911GrktNErcEAGgoz4oMJbE8qGaioBedfIl3kAxNwahy+N3YguBxnMHNH5kRCVwntWzJn+yK1+Orr4qw5VA2Nqan4o2vU1BcbIFa4aTIKCxIS0sTvT5Sue+++2CRufSsoB3zSWdFxlknMVMaME2sB5pnuM8/TSYOgF5YkXHahk/VnR9wu3eTCDGqqqpQWl0TcCXGCoWrefnYmXUI2ddO42KmEfn5ZhQUmJFyuDZgcWqUvcSXdZ25pb88/5zX7h0CpdL6bsnZIabR+KbIlFZY/R+FxKD2QZEpy70Bmqbwfw/LWxIVg1hk6hnvvScdpyUcMKYE0XOt2yjRuZMaAwbcjhkz3OOrhJolXka03LBvM26LfhmJ0eJ/ozMJCQkwwQINvHcQ7JDYVvScus4nQKOKgtHM372iN1kHjf+7/SaYLAz07RxZX+Pj40Fx/MzLOk4NT11O06oKt2N/tt2NWwuGQs1ooRNZHaQZ2wl3Z1+WAhjn7cI2RQYGh9rhIT5FZptqDBXps2iOs6fnVcr0+SyvNGLv3ho89pdcp2pZkJa6Ud4N6iktyh2pX4y0WXBkMiq04Op0jwSL8LKQiRHe9q9QOP0AnPU3VaspqFQUzGbP2sCQIbGiQfSqqqrwy7odHu/hCxQl7A+n07GYO9f7bfRixL36Dso/fsNjOZXM9BuDu3SHRZkLhlGiUyfPTrcajT/OviK+cyrvFdWd3y+H7p5o/PjmQyg3tcHBzGNQVpmh03mnMRoM/sV78gVikfGDiRMnhrsKbmzJ3C96rvC6BUeO6Pze7hcoDAbvXpDSugE9SuZsw2g0wkRZUCLDR8OVO7r0h1gnoYQJNMyo0rnf90hWBcwMg95tWuLmpDbo07s3+vbti759+yIpKQkKlt+xFVkSRJ9jY9iJ3bzvaW33oCLKalZXM1oMuCR8fcsi8U6UowCF0/qS89KS61LUwE7CEWSvdBbfueSU5QC0F5tX5s0tQ3SsY6u9QmFBjx7eKbyB4H9PzcdDDzzo1TW00bPC7Bp19Y6+D0LhlLXJTAtb6CyUEmxds48V2UFjMJsELTK009KSzSLDMBxiZDh2PvJQZ7z1dqLo+czzZ1FZ41uUZU9QoBCrdrd66nRcQHdEqW4dKKucQma/Ga3V2LfHq9XS1xiNHLQ+WmTMdX5qjiVwDrRRD3AcVErpfHJi5OSYYWqdgccfexQ9xvXApMniEzoxVGHYMRUZI1o9JRLzLE065Nk/JjY2uKa/qM5RuOfLe7DpjV+R8u+VAbuvQq3FDX2e7PJGoxGnlNmopb3P8np/T+fOzX3TtIoSj8RrtsVYodRuoT1p1vuXPNrgeNbB9hNxtONGmOuyOioZNeJFqqI0Cc3KhCL7Uk75ldwdxO/v2cXtWM/W/8/ee8dbUpTp4091OjncfO/MvZOYnJhhSEPOIJKENYAiCmbQXXDVxbRBV8S4uquuAcMiiKIgZjIMSB5ymJzDnblz84md6vdHd5+u7q7uc869E/T3nefzgbmnu7qqurrqrbfe2IFlO3oC1x0IMfe9pUnYZBJRRSuJ4yBFXa+hp2UGEg1kRnZACGDKZWzduDGy3Aff+W4k5ySRyWdwzDHH4C2nvdfjXKYKfOZQJzJo3PpgGYEvGagYWggj436LF1+04uCce87mhvIUvePioyJVOGteerVuHRPFSGUMmVh0pvqJQpmzANSwXowQgtYj5gTKfHyJ9/uLDcbfKVIDhBnza943L7SsqlLEJmgjQ31/Kft2IbXpNSgDO6HEJ6Y6dLRCHVOs1DVDIdK/KEyZ0jzzM1kcZmQmgS9+8e/QKgqAIIQHydsfkPISYlNimNYyBX258M2uGVxz9Fsxe8ZsUFI/Yurxxydxyimn4KSTTsJ6sR8xs/nF2J1rDzXtIIRCJhHutzY1IFSFqHs3Jk1sPmiaxDBDJnEC0QVBqXc5mzRtlw15EWaHciQyMIPxarpzGVx6ySVIp9MghKBvWjcuP/ZIXylvG347m65/aMyDJwCpCsMQD044egaGWIESa5zpfOaZMnbuLuOe3wSzUbNYcMRszPrMLFz1yatw/vnnQ5JksF9TFfTa/GbNraYWttaVyJR0nc/I2KqlH/3oR/jm/7wUuB+GC465GqlYHjQiuWexvH/yNvFwzNQlyB4gRkZd/waGHhmq2b51nnw6JIZBbE8SXDHHK/klDUpkqr4YS8cdF+1BOFGvpa52r4o9ts/yoo0N9kOKTUwis22b1XclNgoAWAIdp0xvnH7efPPNE2p3sjhsIzMJXH311Ye6CyiU99Uv5EO12glBEGA2kARtQiB2PIz9hA8c8zbceNqH8GP6WGg8FRZXXdWC/n5XLUB5CY7qQK9jHyJFMDKeLZ0x+EzSMsbjXpd9yu74kzSS0+lUb91I29f5RjTUsAy9CSiEqq3X1gdBHe0G052lCxdg8dKl0HUdJXUb0tuGsY8pIkCGCZcJYtVJe3KAJDROap56sojjV9qnYakKXd//WZTroZjejFisudAEV717Oz7zKSvuzZIlS/DKK96M4MdMXVL7W2SY61enue/mSGQ06ChW3Q+QrY7AsPembEiiw5LKV0ut2TSObdu24f3vf38Tb2NJKgwtgXw2fCOrqgcmvk9rIofWZB7Z+IFhZABg96270X2V9Xdi6WJ85eJ/xBs7dmBcGscXjn4MHePeOWs0OIXLqooEI2bLpCW8+fRL8ceH7+KWn4jXUnePBIF4vwuFux6JEockEej6xCyiBVs1VhEIfv6WBC77VQnP7uKvwZNPTuHEeSdDa/sQPvnJiyfU3mRxWCIzCfz5z38+pO0/+vif8fv3XwcKiiKsjUgg9T8pIaRpIt0IPnDM23HByjOQXZ6tMTJRni2N4JOnvxMfP+UqSIKEhB5rSILx7HMlDAy4LsOvhgQKi4IUIr4HrI1fIuE5nFh+hDAM0QpzTUDKo4uN6l28Dy6ockLU+9Rdpp1o02vq6/7q72BSBNRxAaGyAkKIR/8twKipjVgmBgBguP0lxITYoKEkAIyMMskupQqefuHgudmyiMeb9/zYsNaKAM11tWcisCY19zS9rZNhZOz4I4Zvomt9Jsy0dS1UIqPpGB0dDVzv31vFv/zLvzT6Cl5QAZJEcOaZfIZCre6/AwuLL5/7zwCA3AGSyPihxiQs6J6Jz59xHa485SLMbg2Osdbgbtna2loLiOcg3xIeeDTKa+mcc/jvf+45GcAngaVMYDydyEgmJi6nEGy6pFCKvpyAZ96fxr5P8PvS2iZi+cLpSMUbV8XubxxmZCaBpUuXHtL2193xc5zcey0elF/BL+J/xVZhAN+7+N8aenZ/MzLLehbgc2dci/ed+w60nNxSY2QK6uQMAb/y8G14aOOTUA0NQhW4/YW/4A9rHsbcthmhz/z4lmF897vfxa233opdu3ZhtAEXZz8E4o+m4sKgUqREhmU62IR6Bme56VLzfQOAXjteDRuDhMDLNJqI3gRKcZaJ4qXCju5DEiUIJjCiBuPMKIbbF8EwISYaZ2Sef76M0VG3b39+aE3Dz+4PtPTOAqHihNbIL397P4D6aTBchtKrKHWMff1bm95NUZ1PUVlsIhPCyJQjYhg9++yzoffCwM6tiy/hq6M37zowTKZgv+OBlMiw0JTg/Nw51Z3DybIIvcHdclM2gWrV2+9YPFxNGeWuvPwovopowcIYCAimJMcAChBN9VjYm0TCVVfOmXA6CkHUMd56Nd6811UdtiUF5DhLolyysm1JmFyAwsngsGppEmgk1P2BREK0ok1uEa2N5CH5VcyJNWb/sr/USgs7Z+P6E9+LnE1w/pj5KwBXtdRo8LoofPi3X0Rn+nvQBRNDY417sGzatAk7duzA56/956baWzLVWq1hW5FKkxBJ+EmUJUuEuou7SoLELF9ojlA7Eut4UAYC//bn5FuiHmbHJXbUIzlqXASddqR+1Kpjdylo4Cq0GMCw9b6CaUBowlPuoQcLOOmkJE45xRqbNzYeXIlMz8lvATGl/c7ss4yBSYzAiRoIN/YFASAAQx/RUdphAFcFi5Qq4RvJRNY7u78uXNi8dGp/4EAZ+/qhxUSGpbRD/zO7oyaZ2P5Y/ZhbCztnM8JIdwCbsbdycMqpKZxySgr//e19HhfoXEbC8uUJ7HpNgEBMZEYGkN7ki3xNCFYe24dNW7fjj39sztlBMChEsYhK/HSo5N8hMUx5SiEYrXppxf33F/C2k1WU5YOr/mVxWCIzCRSL/Oy9BwtVnzuIQcyGTzBjY/snEN54tYDz5p6MldOWAwD65SG7L7ZrICFYvKSxgFNR2FsYbIqJcaCqKta9vAZf+PrnateWLVsW+UzX8VZuoLBzUqu0AwJ0TO/geyOEnbCqUGrEcrpyCganfAtxrblQ4nNjBlbt3YlcINha+KmOejgW/tnFlMM3bd3nP50jrpicEuDl4aDLf67btd2qxBNNqZYAoMC41/Z2HVjjdADokSS0iyKmvvUdmH7aZRDo/mdkLNiZx5kgdbU0BACqQoikj9k7Ej0hqqWKDjHEfkavkxvrbw0O03egjH0BILPMdZc36jAamkyx4NRwN3QHH115Jfe6lIre5N/6tmBsrDe/OYNYTMCXbuqpZf3uyCTx6Y/NgigSEJsR7ty9lVunrgmNJmD3YNqOMkTBUlPf3+Zde7vGgzVSCuzeNwxdOvjxYxwcZmQmgfnz5x/S9g3Du/gIJQ0t/IMSeZFp4oIL34xM5uBmrWVx28P34F2DWXz2ZstOYMqUKejultDVZf3nbFgfP+ka/PKqH2L97Hf5hKTu4pVJBXFhHCJUXHxc0HiytyUHReJvJlXItZoEKDClVoACgjSVW56HRXEdEoBlto1M5wjFmuk9vl6Ggxoug0FY9QcB44LtXgOA8aQOadSN7SLYZKOEcBdPSgk6ei6GnH4LSul0UxIZABgvuIS/f9+B84wBgDZRxINHzMajR8xG7zveCULIpCUyUaolQglyZdeLK6YxaQikKv87EmB0VzcAQBQJknJwDd999xgkkT/O42NB2xk/WltbsWzZMhy1eCmOn3ceprQG3e4PNnIHUrXEDKEpSTAj7OIAYMHKPNLp8Hmci6Vwykx+TJp6c+nqq1tx8dlTkU4L6O6W8C8facWJC61nFi+O4+e39eHu307Hpy85GbOmWfNFt6V3Bi82AaWgpjGh6MeJigFB0CFSDfNyjTHAn/vWb7F7YEfzje0nHFYtTQIPPPAAFi5ceMjaJ74cQnmaRLbB8P37C0YDImtFkfGud70L3/ve9w5Cj4IwTAOyeTxuHP8WbvzWP+OPf/wjHnzoiNr9x1Zdib6hFTg3mccwNQEUUAabcZrdNKxrAtEwe8qxePOSY/HHV54BAKRiabz1aK+RH6vWUaEE5CZEbIeo1GeI/S7UDsltLZDGOBgAFNHfioqixzjZeW9TSEAeHYKes06kAhFhADAhhjat6yJEMQ1R7oJgboCYFLHsgmXoRS/Gd+/Ao6tfjOwLG/AsEZcwXgw3rt5fIISAEuerC6HSjQnXb49nR2Ga53pcD65ZzrkXJpPpOhUXUOIk7qyqfNVUI9FWzzvvPMyZMwdSQUVL4Sz76j21+y35NIZHDixT6UejCWInAn2ESQchydB9DIF/reZzIr7xjR586+Z9eG1jUHJ2/LTFoQdJpU4SR1km+Odrp+HaTyoQTAVnPrEbL5YMVGzbMkIIMhnvfFQlSyNgcJJGwjRh6hL+/KfmY2gpdnTy5VgduJeUJZRCbLHu+sG/4idf/nAg6OPBwGGJzCTwnve859B2gOj47lO34a677sLdd9+Nn//2Dnz+gW8f1C4UtfDAcA4o6AES0zcHnXbhpuEfRpZJQMX10p0oEYGxIWFDT1kXRVQgEAHXnPoObPhoGh+74Gv4jyv+D1NbwtMnVIkrkXHqIYI7LqHxXsAQ1UhhWrSkjXiWO0WiUmVvBiUyNgwxAWLqTNH6ZMPQhZqNBQEBEQgWnr4QK1aswJLZR0Q/DKAw7m7SqeTBixQq1FR2+ymRDwe6zw5GMhtTLxqaOw4jpeYMK6scL7dgGe/mTEE9AYEuf/vJTbU5GQxWnVQeFDHpwHz/8maGdkkKhDqHsrhgYtYRMdx8Az821uKu8ANJI9FuDbkMQSA1iblkcPpDwHwTqxxPIkNMHeNG89Ks+e0C2oc1JEs6JF9CW0pJKBMDAKXxYfzlL39pus39gcOMzCTw7W8fXKYhAMHATY9+H6+88gpefvllPPfK87jnjQfqP7cfkYuHq4yK9olBF4wJubLubzjGr2veeCG0jAIV/yjdjQpDwL3B3SziIRDrhKvRNI5oFTB36nKI5tpAfXq+vfa3CplhjmxbCWNicTg88XSa1RTaj7bvG3EvEcHjvskWNAXZEw9HsOVBgil7DFhZ6IYrrSGUoH2sue/PqpZSyQN7whtk3k2Vm7NZCkOYaolSE4aPkVH0+sHLCAC96jK9epN2lWYDOgYjYHflfWbZ0R2YN/Wo2m9RFNGaPTD2S2+MPoXdpU14deRxKNKB36b0xHTs5RxC0kz4iIRgj0/oUFrrQuasiTB1/qLF7jc1JZuxsolE54DFfIp1PrYRWLeWt+Qba5p3RvnQCovhmrGtjIlY2Fx44YVNP7M/cJiRmQQOeYoCc+K2LpnUxCI/1gPrTKrX8sZQS7R68JOieuBEur3zjz+CWva+v0QcBsUiLKbAZIZmytEaI2O5lVepK/rWy49Htn+28bRbWW0smjPCrCdzaQa7u9qZXyQgkXFsaCSIIEawn7O1DyCh8+NjyLKOPbJll6ELJpRGg3DY2LJZhWl7UqVT+1fFE4YZZw+gnDiADDfhx1WKGd65SCnwB8Un1ieAobqn+q58OHM3UY1Y0CDYu5GVuwx8+E1fwoff9CW85fRLce2112LJ3MllSo7CxvEXsbu0EXH54Kgq9rXPCFxLUQq9OAvFTf+EwdI0rHq0gPd+LixNirX+5BCmJZfLQZZlpNNpTJ2qYO5cBR2zsti+yrJ9MiWtVs8v9n0L4zuXYdnLo1j53Ai3PgqLHpkc1RIxdJSKzXsRfew4i5GXdRNJFH1KdYLzjnpX03UeDBxmZCaBQ52iYP3OxvMOsZiT/C1uOX//cBX+E3mrxt/YCCGIH4JkYg6elTZgEAmYIMiQMnTbW2jd2pUAgOU1rxrb9TokTgy1l4zDyKhmEgWjvjcDAEzFQEAsfDDQ0LlKIMEd0GZkYlTy2M5Y/LMAATIKGv/U19UzgrVxN9O3zGg26sVYAazkdZdcsgVf/cpeKBzD1v2NWefvQaLN2kguHnCzUZ9xxhlN1+VX0QThfZ+q6FXPUgqMCEGPSFa1lM2Ek+6TTp6YXYk/R44VdZo5mKTK2HreaiyadhxWLjwFLS0tiCcOzIEIAHaW1kMg4iGjGwTAiUYF5W3XwKx249dvfBTFoomB4Wi1nmIzMv5Z/o//+I/49Kc/jS984XL87P968d3v9WLe2b0Y3xn8XkP6NJTMVrSNaDWbFbZfVgOODVtwLhDDgCA0L12sqbV0ijQKgZc4ft65Tdd5MHDY2HcS+MhHPnLI2qaU4qu/mVhCRgKK82fvn1Ou//Bh2jEGWE8MB5UQQ0QWK1YksHp1fbubZvGStBUvAViBM5AbHcC99+/Dnr1jyOf3YerU4KlSECpcVsO1bbE2mipN4bdD/xEot6VHx8zd7uk+bvqNLR3JzuQ3Alr7X0MlmZ8uU0URVC3VvJoE2ePhREEAYr1bQRsED4LobUvRBECx4pms2bKtkc6iVKS4994CgANvYBrLWpvTu176LeaK+7AalkFuZ2d0nhwebrnlFlx++eV49tmv1K7FCzksJieCmUG1e4/N+pXneX5IH4ryiKv6iMo9lZ5gELTu7m5fzyhaRfdXCkWUWwpIT12Nyh5LpRxLTCw5YT04rRpUR+IgSWR4fXiPVsCvIeJkyFgFLTIvUtWwM15DADjB4Rwm4YjZ3uCEhuqt03n3Z8bfganyq2iRo7yBQha+aWDDhonHX5J0irfiF+ga8DLl7dmDnxCyERyWyEwCv/jFLw5Z29/85jcn9XxKIejs3P9i9MWvWCd0gRPs61BieNiKQfOMsQj/d+uf8Z3vbsevfz2KH/3oXqxatSpQXiLlmprMw9BQh5GxNlcKEaNGcHE/cWTVetI2IDy7/Khd3q7GrlVKndlQ/3leLCxen+tm76WEb+tgmt4oy+x7nfvAg6AhEWMJRKgSm7iSIJ7/EABAEbxzqKVUxfIt/YE6YpoAalL85je/wYPPPMdt528B52+4H4Otk5MAjI2N4TOf+Qw++rH22n+fedccvGfFZVYB6mWRx+NeqZbGCSFLZUArJdH+ZQmZ/8xAksNt06JchMOwZEmKY8dB0Sq515KwmHcpMQJCre+uJA+MRKZQcUV4B0oi03lpJ+qdAGIAPgcFn0UC/4pEZF6k373xRwAc1ZI/LYnulZQYakg2c5rDnUNfDd5oQEBJDB3lSQRVl3SKVFFHfozx7LIb7sz1TrziA4S/rd3m7wwnn3zwrPj9uO222yb8rLN029onf9Lxq5acGH08z5Z5U/dPJuyJ4NFHLUZi+/bteGSLd6P/61//iqru9eoQBb67qqNaglgBibBv0SUARICgWvXkUw7jA8+/3HyWkbSVf/OpY4+ubZCU6KBCkNrplSd9V9x3lgwzNFgeIEBiciexplkiI76uiAks2DuGntGi3VO3rzFNwOCOQbz++ushbRw6sEM1lLHep5BdP+H6hoaG8IffutLSvXtnQLQzcVaMIuQQLyUnkSQvMSpVgHxFhLJNgDgkoKM73Mg2FcLI/NvHLsJv7jqeuxlnsyJGRkbQ39+PwRGL6TcFDQbTlSSsnVGQyxCoJYl5be3ExykKjnEyATkgEplYSkZ+ZR7SuNt/vyG+s9ZOgsW0nQgZ8Yh4SNtGhuynozkNDyNDEbR1ZBhdncZh0ObfnxgG0plwD8p6kHUzoNJykDhI0ZabwWFGZhLYsmXLIWv7+eefn3QdB9SukZHIOLQwEds/HiETwUsvvQQAePrppwP3VFXFL5//AygoHpBfxh9xOhSh7BGx+2EIGqSINAXW+aW+O3W5AfsPj1s2CRzorf747FtUgUOETK+Y2DRcZk02DIDwT4YEgMA0qjC6D7YrVSkOcLKGExDENAHrnzgwmx4LTsqcuvAOJ+VdbAqbN27EwGY3oey+gekoJLJ4YfBBFPQRzN97PPe55cNWBGxR5DAyIgV7+eTT5qGFEy25rU1EOs0fhK4Zr0AKsf/861/H8K1vfQvf//738c1b/hd/fO5n2Lz3dZjM3E+hgOpzT+Cx136H+1ffg3vvvRdvvPEGv8JJgABY0mupuSgosvuZUJ100kk4+YOLoHQooGJ9msQm8Ewk6k8MQ/P2t930qkb9Ehk/iC8hbdUMs3my+8KxOSOmjuXLl0d31IcjZ5xU+1s0AT3gLWa1l1AOMzL/v8L+Dph18GBN/Ch9b6MIcyvkqZYSdYJCWRVOtkfh0HUdhQLf3uLrD/0IY6SMLeIAnsUyKChxZR+iTWR0QYdQz+OIBJm52m/7Hg0ZP4+nVMSYeGPP2GovCmiseokG/gBAIQgugZRMGsrIOEhtfAWx3VuQCnEHFanhSZLJQtEEbH52c2T9+wP3vKN5m439Hei6v/9+9HZ4E2maRMD24hpQaqIi8VObLIrZ48rpT3GsFSJDrnP5Vpw8K7jBjY+byIQYAhdVHdu2l1Cp1Deo+vPq/8PWPes9lh4ydLx85zP43g834k/P3I6nnnqqbj0TwYXLFiJlH3pMauCM+fXjDjWKnp4enHnmmci02cxGBCPjfIYSs86j7I9OmGnbU/loX9JHJ1hGhv8lvAekj7f1cTvm8C8iJ9Al0XVkm3CNb0m14S0rP+Stg2GQxtIiblIsc4bkYUbm/1/o6Tl0qpKJIpVyiV9iEmneHWwf2R24JhheiUytPaW+rntan4wnP/4DfPatF+732DOGYUQG5hOZPsuCyhXxxwQrUqYuaoFs0w4oANEUEMWV5ekQjjOfwKw99Q2gaWRN/CdUbt+87xNggZicP0YiBfjCwwtqFcrIPk6cY/sZIta4gpYtb/I8G1NFzF554Fx1HZxzhIhHrmkutsn+5p3HixqEKUzGbttTjcLamHdnNwWe6S30otVWP/qn3YyZq6Fty4II7nrVdQXZWJDxVFWKWIz/Rjd9dRc+ev3LDb8HATyqJQDITMD+phGcuOACXH3W53HNVd/DKXNn1q6rZmW/hiYMHLy0cBdlCgE6FVBlVLDbKuFB785b6Es1Yp9A/FSWZWREgSNN8f3eILWG3gOALjVocE90i64kGkxW+bm3fhPtWe9+Jmtu3ySDomV7r13nwY0e3wgOMzKTwLPPPlu/0N8Y5sxxjUITEanlG4Vm6thYXQ+TmthasDKwxjTRw8gkbDqQiIUzJjNbp+DBexfi2uva0ZlpRSaRQEdHx6T7x0JRFCxatCj0PqsKClMbEWpd17hZiq13rvTMwEWbT/EkYnSYIoc0zMVaXGf+Fzh0LAhq1QAA8nBj226FsEZ6IQyMTyQtMJmxS9PmQhCamx8FJVuzjUoNehOFKpqA6cunN1Vfs/jq2TEIhOC4Phkdv3kQU99/FS69tD5Tw+5tAvXaqMyaNQvXX389rr/+epx66qkN9YNNrwAAkujMFQoTJggjYnu9y8oWH5eKEHnqQAB9fa/DNERIrLJzrIpsrDnyPTjYXDRgwKtWAYBM9sBIofOpdhx1xKnI57o91zWzGpi/+xPCK0ZA5epgs7EU79r1BWhw7/9ofbin6sx2vqTCn8jD0N11FeOoEf2I6X4pozeEg2wGJcNOJG65QfsiiRNUT2Ykr1rFZb6iVEsT8fLbHzikjMz3vvc9LF26FNlsFtlsFitXrsSf/+zqliuVCq699lq0tbUhnU7jsssuw549E3cp29+49NJLD3UXmoau6zVyGJ9Aanke9pgD+L/qnXhq4A9WvaoAgXN2yMTCxf6bh3bhttu94vjEfo5RQQjBtGnTIkowth8Bzx8vdEFzDX+dZ8ROUCLUovlWW1sBn/yiRpQnKAYwEnzCJxCWmFFUaP1Ae8QOzkYMDQ8smuGTBBCYto6cAnh4+QB7y9MWAMhUgkDgiTeT112CF9MEJHIHLuYIAIwyKhOhpRVd77gMH7m2PeIJC+zrmL4PI8tyjT61t9evCwDGx71zR5LU2ndXTdXDMPdnGlS3EUAUMiCJFsS7l8MsUK5EBgA+/7n9RCMJCbiCh6mtJovVGx6ymuTdPHB8DISSDGKWQ5oRsE2fgs1wPcTmSuGHMa+JMFNLxFqPSVbpwhOuYa7pkxrJRrgUmYDCIMFv4qh4xwqNhrII0ruePS4Dl6bu31HGvh/84AcbbG//4pAyMr29vfjyl7+M1atX47nnnsMZZ5yBiy++GK+9Zp3sr7/+evz+97/HnXfeiUcffRS7du36m2Ievv/97x+ytoWo1RGBBQsW1P7eX8a3uq8rMU0AoUEim4pH2y9s3FTFN78xgA/eeTN+dP+jWLdu3X7pH4tGmaMY0T1pClzY3hSSCtP3joTIUNsZ8Wwg4iZFjIYHSyNCfeZDbff2iUpA/NxBzMy/AXYbKHMIk5/EygXXP1OVRJgYR7lnBspTZgKCANNWZRBQnFjhZ/Vleg/Bo86ikKn1/rMG2zFKuqDED6yx9xuD0+yeNAdn33jr0q+DM20B+70azeAekMhIKkAIKKXQRb7KcVisl9SRgIoKUqd/Drkj34OjcBayTWYUbxYEQfusRlVLnznnU021pRnRuaCkkNAAEwVryC8Y0WM/xqybn2Ai9iE+OsJ6yZWtCVfd6NIlU4yewX4nBAPBSUs4RvdhOGvhbFAaHIPWEVfqzEqVomxkrrrqqobb3Z84pIzMhRdeiPPPPx9z5szB3Llz8Z//+Z9Ip9N46qmnMDo6iltuuQXf+MY3cMYZZ2DFihX4yU9+gieeeOKAGZk1i0OZouCqC/vqF/IhkVAwZ86c2pSM76dEjjrxbsAxVax5uZT08ZqiXRCj7UGKJQP33TeOB157Fut371/J24IF03HMsXdhypS9DZWXQFHlGoPYgeygQefEkzRiDEGSRAzVci0RthIkdO9YpKc+j1nnf47blyhjX6ODIrasgEWdXjVnmZsAz0tQdV8MEKJr0PPttSzXpuQSyAXqXLdck6yCAMCgCpTEgWVkLl30Zu71f7o+WpLivM1jLUdz78uyxXz29TW25ioVittvG8YPfzCIH/5gEL/61Rp89/bX8dSmzdBFCTz+eFCOPjlTClTiKRB7EzkCs9GVakzVtT/RqGqpZ+Y5TdW7sO/Y2t9Jyes2HJMl/MclzdVXH8xH8OU7oyCglGCGfhmuQQzhRw8vHIY4ar2ybWuahN0F57DT4JoSKHIzLVsqImjoGDoGBo/JM02AUpx79NzgPQaSIGDJ1G7AVpmvlU+FZkZJraMlMmHOHwcafzM2MoZh4I477kCxWMTKlSuxevVqaJqGs846q1Zm/vz5mDZtGp580h8Pw0W1WsXY2JjnvwOFQ5miINbTXLTTI45Q8OGPnO/JwhpXmjOm/fZ5wfLvO/ptUH2n/7gq1GwlHt/zG+dAi5Z0CiuPCF8k4wUDKU5enWnTpuGc409pqq9+5FsGEI8XsWTpY6Fl2P0lK5R9EgYH1kKNUwozwCxQT04iKohM+HDHRsZ6PmboYIlX74nfa/BNnF7Y9cneqw4aUS05MOx5QHy6dkl1T8l5kq/9TTn5gvzte65SoLM6CIVIDWUBngjSiThWTvMZYlKC3K0iLnp1RuSzZR14LH9U6H1JsrYyQRDQ1zc1tByLH/94GL/85Sh++ctR/OUva/Hzezbghe07YIhSJCO4ZHCJ5/ecuU84r4Kqz8ZsSurshvqSz4tYvLh5w3lCCJD2GvM3Y+x72uLGpecnLbSSDYYxAY2ktWgEmhY8TBGONEil85GnC/BexHAxvAx4Wwff7mRli2UEq9pBBGUhWso0ONZYnBd2vrTMdvczQVSRrvRCR/DbEgAwTVx80pFYtsy9f9QRnTh74RxMyWcxt6sd15x8DHrbZkKQZ9klKGQhOvJ2Qjls7BvAK6+8gnQ6jVgshg996EO4++67sXDhQvT390NRFOTzeU/5rq4u9PcHI4c6uOmmm5DL5Wr/OaeoTZs24Stf+Qqq1WqNAfniF7+IXbt24ZZbbsGzzz6Le++9F3fddRdef/11fPvb38bY2Jin7NDQEL7zne/g5Zdfxu9+9zssXLgQzz//PL7//e9jYGDAU7ZUKuHrX/861q5di1/96ld48MEH8cQTT+CnP/0ptm/f7ilrGAZuuukmbN26Fbfeeisef/xxPPLII7jjjjuwfv16fPWrX0WlUvE887//23hmU1EEvv+DXvT1eo1nE7HGbRZOXbkCH1gh4/LF7iI+YdpyfPykq6ETA2LFVVNki3LNJmBYdSUrrZk0LluxBHO6+CfkQsHg6uAlSQLkyU3VagMupyzKiKND5EmFbEbEBEx4CVVG3OvNSSSG91nxuSn7Y0947rGnHD+h5/JaFKZWX7UUbMh9RhobRvuunbXfLci7TRr1Pa38iFMVkiHsN0+0M89MY86caUhKElYkErjhH96EpOwk/LTKtAyXkHpSRPe2Ar7/7ehopFct/hIAy+W0wuQ0mjP3iZpEBgBOOnHphPusmyZ0UULU6XtKpaX2d16i6O7eaP8iqPgyc89s6cWVV74d73vf+/DRj34Ud93NN6Y+48wUjj5mYvZJpOcFz+9MtvF1eMnxH0D29LdElhEIwcXHXIqpbdZG6rdRctCowe91112Hz372szjpnJO49yuVoApFWBd8J4OGS/E6eoKSxXkdCjpTMaezAIApKT5DkEqNAAgGPpQiPKgcxPPBZLaUYyMDWAcTJZ7A174+Bbfd3odf3TkNV5+9BOcunosbzjkZHzj1OCyaOhty9ioQItt1mdDNbm59DqKMfb/zne8AsPYoTdNw8803Y9OmTbjtttuwatUqrFq1Crfddhs2bdqEm2++GZqmBfbjH//4x3j66adx33334Z577qk7JsDfQK6lefPm4cUXX8To6Ch+/etf46qrrqpFYZ0IbrzxRtxwww2132NjY+jr68OsWbPwyU9+EoCrEnL+veaaawL1LFy4kFv22muvBQAsXboUX//613HppZfiqKOO4pb9+Mc/XntHByeccAK37I033ggAuPLKKwN9+cQnPuEp+773vQ+f+xxfDcFDSGgPxBU+cbvhxPfi7pEHsPk1KynljBkzcNYpxyImrcftlyXxydO+i7Iuoy9n2YOoqgZl2FXZLNqSRdsxy4EQLc7VJx2N3z30FJ4cHvFcLxRMTJkSnJKVSgWEn4CmYTz/fBmf+XQ/bvx0J2bMlLFls3czvmSp93RbQgJxwonxbdNZxSAwUIEI1ytGhOaVyDCqGb8h4I5sC2ZjvHbfqKYA8HX163vcpJT+EythIu460h4KoMq1kfHD583E9D2+azNETYOTRDNjusSraoSrQcLi4gCAYALxeBzj4+OBey19Coa3R59gWXR2Sjj/zedj9v3bMGfTJjzR4bqo6raNActI9mbC7bPkZUejJFprgQLYOuR6XrS07MbQoMsETSYT97o9e3ESIR6vJT9yahqE5z5NCAjxbqApJYmzzxnFxg2WJCrMELdZVaCDRD6Y4ycs2B6LuUlrrCVRRvsV10O64h0Yev/buWX/45Kzkcm7aTqMkLHRjcYyObe1WWtlwbwFePy+YDb6WmwVRsIj7ItDWfcGKJlRuzakhdv4SIoCwEsb1g6o4ESLctugBkw7TlNn5xYAQFfbELDBYpgMKkHWKfQ6Aku9yvvGIZJQXYcqWeu3q8uqeDDmHUcKEwKzZikxodNuSPAKC+4e+kLt7yj36+uuuw6Au1d96lPWOM6aNStQ1rnn3wuvvvrqWplGNSqHXCKjKApmz56NFStW4KabbsKRRx6Jb33rW+ju7oaqqhgZGfGU37NnTy25GQ+xWKzmZeD8d6BwwQUXHLC6o/DAAw9M6nnNDi8eD5HIaKaOi99/Dn7x3jvwuct/jKuuugoxJphdZypXY2IAoEw0zwYmEBHTBzqQ0NKQSPD0smtkLMDEAJa3By+8eqlUquUsmgyefrqE731vH976D3nPdUIIzlt4qufUV0YcWk3pzRIoW2xsADonQ7E/IFxrKbhpA8C4TzJhqOGnnF35CAPDkGFRqduPRk+zXgNB6jkxKowOq2qWQW3VFWUST1r/hEWZAUyYoRKZpRc1lkHcwV7She25TuxN5e3WXakJz708Vgq3z0m90z3IZEoGVJ1lpikkRiIz0YSMtb6Z0RGfZRBMKwXDDvQijwvKwbhVPT3r0NZmnfzDtC/VampCnj9tM4PhJaKybjs4MZev/U0oILaGSzf8eZSMkC1pvNKopYqF7tZuJGYH6RsF8IclKwMpVEihcePYRJO2hVTQEUMIk25PBRMipJBAkyyMKnM4Ir6150Ni5yaoPvpLfAZabRmvKhMUMBFUee1S3XAK+WQ7ckn+ev1/3kbGgWmaqFarWLFiBWRZxoMPPli7t3btWmzbtg0rV648hD104YS9P9iICuoWDWeSWZ89LiW5a2C8WsTVe9+CrmwXOnJOQsRoSqi2ucxli9KF2B4goWURExOeZ3XDwC2P8ePvmCbw+mtBqcTIyAieff2VyPYB4Bvf7MHtv4g2VLv3LwV89ateN29KKY6f4Q3nXUYcKQQlD5pBoZsEskGgER6TEjZO1GPu6x92eTxCXcNVLdk1GcFWBeqVyIRtnH7RtqA1JhGpSkGiz2vBPxKEIjSy8it/aFxVCgBPCSfjFzNdtYUVnNDbiwSjRuj+rs6VWHS0ZaEsdw1Ns2NaIJ4Lq1pqbWlcasQDCQlvOGfUje/kxJ1xSonVHKYJH+bXR4Bs1prPf733BG6ZwcFpoUzORcv46RLY9lk0oloKBLYPOUyeMm9J4FoYI5NvMjnlvvg+7vWKrGBHa1fwRrVx261d2/hM1c4Wfh2GXIBCo+eNSSVPADoPqOsGb2pM0E4pmrkTtCoqxLtXFHa7ksm0VEVMbvHcp5Bh0mjPrEQsjbOW8SVshwqHlJG58cYbsWrVKmzZsgWvvPIKbrzxRjzyyCN45zvfiVwuh2uuuQY33HADHn74YaxevRrvfe97sXLlShx/fPjiO5hwxJgHG62trfULRWCFYamMCFUgcFw4x6tFtBhZeOKq1D3SuWSvapSRNC3CExO8Iv3tQ6MoqeGbdqnEb6cRqcKiRXF0x2Zh5bzz6pZlITgGuQzlLiGO+cJ2Tw8AoGKYeHxgBkRTQEX0MzLhfTQhQIDOT3tQ2YnsgGtU6d9AOscYyY/vcxGucxJFlRHVSEKINMIvTDENZIYWQNo76AlP7uDh5QPY2lXC6NR4oAqAAJR64gcJPjWBZJDQuTu0tbkTdyCvAGdg3/zAQ25fdKC1NagWacmnQVivDwpQw92QCLwbRlhCxkYxnspxVUtnVVJO89B8YjalGB1BXJKrePTRR/HvXwtLJBt+Sv7Q6XxPrzDEYgLkOvnB/KdyIkqInRo0TF4+PRjpOUy1lFBkLOhpPNjaMx3PcK8L9rxWNEdlYU+cCrtGot+vIvFTJhQqOv9xYiLGYWR27nUlb5ZExjuJq6K77p0q87NcmsNKCsPgl8iwumnVDK6HXvNllM0T69Ybhv8nJTJ79+7Fu9/9bsybNw9nnnlmzeD27LOtSf/Nb34TF1xwAS677DKccsop6O7uxl133XUou+zB/g7Y1igeeeSRCT/7cuvLiMccRkKAmAhO5rEq79Tc+ARVzTLSpsXAxETvGG0dGmm4Hk+dHG8DLijBhccGbZ6iwFt8e9AJd4f33ls71gHBBCpyAQL8/eKPUxUKUtIo1oXE7uFoqWpYsn3Ad4Vpw0P4if1/6kn2FxMal+DFKikIZT6BPFo5AU8vG8elo64rrGR7fAimirbCbg9DITtZe+0+iiZpOBZLXfgMHCti8B1bRkY9vzNJjtrS964UBNRH4NkNI5mYnNfVaCYfuNZX6MOitidBbHZ9HazJ4Gg7qBgRe8iQMTQ4UpcmhLHYuUSEB0rIkq8XFI/3WPb6z0A59kRAlCC0tuPa9y3B9PagZESHEHpoufzYIyPbdSTVBCaqIdIKIUw0pTb+XafOXMG9Xqo4zEqwjS64C3x01GLIRguu5MOkEkQmH8TJj/8zRuIcG6Uprm2OJNWXDhpEwRublgEAhjd6155qShjOeuvI6sOomnyD9qpX4/o3hUNq7HvLLbdE3o/H4/jOd75Ts4T+W8O6detqxrsHC1u2bGna7fvEEy2mQlbKkFQ30DkB0HFRB9oKbZitz0Y8HscpsR4sVtjgZ7x4lV5S5Sc8qllBws4novhUSzFpYsaSZY63gR+EAFQwkE22oqdnBnbv3tJQ3Q4js8fwqjf6YZ+YfIu2YkgQTAEVuQCprEJFfSJYRhwlhmHyh36Pyj8pUlqTQNSPURHssBLCyAgcA0pKww1537f3Urx378UQIQK22k3S7JgWlEKiusdQQ/KRF9Ek+4/5d8bS/rckBG1vij51RDoenHvlihogggKYOKeEelRLijy5EP3VeALxcS8jkCoUQTjDolECUGD60/8aWp9YTePJJ4P5zlhEnZIVKXzuelI3qCmYirUZp9MChobCbUp4Ub3FTBotX/4f0GoFkBUcu+ox7N2wBgTA812P45hhy2BZijgwJesE8DzmGItu1SJuczZbnqQRaM4g+spYCz7BuV4sqoAMFMzgqeQEbIaMcbxousxblUkBYkKExKiWZL1+RF65AYkMCMGm7QuBZxVUR4KGs6YZ4765RuOQiZfmGoKlHC8n+Go7q7lDI5E55F5Lf88488wz6xfaz/j973/f9DMf+rClAmtv3wZlh9cNtfXUVkwpTMHSAYsLX4oeTKsEY2XUVy15EdMFgABj6j4ArgouMcE4IsGYLXzo0jAAIJ1uLEYD4C4+wyfSHwVfeqBTETAJiolCLQO2aQxjqAogxV/IcVQ9EZArhgbGgbLhvtYiC3Pv8a8qHGkFACQrmrVhs9INswzRP9YM8RcDUUTD+16TyDjPGgRKIxnQG4EvsnVBbAl0ZXNvL0587vna73NXpLHwqBgyGRH9m06AlMmgp7WMW+37//iLHyOtlWEyEZapKdS1RWgO1pa5v8h9bEsG27ZtjCyjaRr29M8EMBzsTYMd6X3hBmw7+suAqNWVyOzq7ILf+iWDcYwhD2LHwjEY9V1FcqUM7bR5134ASC1djtNOO61uORIq72ELkcglObt1Gk5aeCYGYglMTRZA4iLOjL2MnlQMu7VhaI5hr12HpsWgwMBFeADPk4vAq9ygIuQIe2DLRJxi8I082haMAAD27Yu2B7T6QCGpOtTxBICgTZ+/J7sLCwEJKAidaKGWEblqJrClQ0LXqMW8mvJQww4EBwt/c8a+f0/42c9+dtDbvPnmm5t+pq3N2lA2rD8eiqEE0mpoTMTdisHzKqE4nTzD/PJLZILYN/I6TGp44sgAwJp+v5pk/4EQgCjWSSYekdfJDydIluTbpEmNaeC8oSmgpBRA7MHUK9HRpufBu9moTYQQ5xv7RhRvUCJTiQfVCpSWuZFnGwV7IvMzMoIpTMJQ3Qta9TIXJTEO/+CM+IxMz16QwRVXtOAK0oKlCxdi9uzZnthKl6y6H/f1ngnKDIAg6pBk9mRKMeX4ianHOt7+HvuvZtiY6LL5P+YxZ240c2ip7J/n3iMUkEKOs2zLSrEbombNlygX7C939+CFaz4auO6PjzvoOUO7LbWHeffY+M5bPs69PuNzX4IoWv1a3bY69PmxRLghq1B1N3qRhEu5ju5dgl9c+K/40jk34E1nnouTTjoJ7z4mj65kDDvEYCZq0xShO3SC1QqzZSAhOxYMsAkAmjKjRgNMO9xCdVTG3j22S7NPyiQlmIjPpgmpHC7deeEI73qs6vYBUHPn1C17/w9v9Ck1uiByGCIH/0/ayPy941CkKGhpaalfiIPBfb3QtDgUU4GTD5GAorDhn1EVXCJTVINEehrdiaPImojagzvflvGnuRFgNw80553SLATJarMZRsaB5DvlvwpL3M1jZEwqYDzu2hKRBtRLbC05eWIb+kTIhMJRuwAUghqUNPBUS2HCeB5Y427ZlDwliSkgmWz+u/BQeeBPnt8lQYK66aGQ0haEgtWTzJ/cjZgNwFZIpbA946YhUCBAllWPCJ9SAdMv6UA66/1+fTEZs2bNisyunrUNXltK0QHHmsEdm3bhpz9pLO1GGDIZPmPC7kmUmBC1tF0+fNu4KJdDe2f994ux8ZaoW5/IML8mCa6phd3TcMOJ7/Vc+9ilFyBeLeO9+CUK7bdhS3ZLaLuVsdHQe2Sv2w+DBg2sXxS9KqNjfQoNSaeIUT4dMG2rfE1wDzCK4SqYS2Ye6TFg8etjOOZ5S3Jm55NEOfOmQH3ju1Lwr0EjkUcs9z5I8RW1jZ0Ymp3Vnr+KR0PiIlHdnd9b2+N4bg5DQ0j5sETm/084FCkKohiZzja+Rwgh1qkAABRDgcnwKlRrR5KNRsvZoNQ6Wp1m1E6xOmnl58yZmOrh8svzntNAvE6CSh5KhC/WFniiYJOgkiiDOkYrQiO2H27/euNpVy9PGlfX+D8P5Q4ntf9vbcAF3dKNE+qVAtXsBRiG06i+BLEaHjnbgd9osmqrDAmjppJtCZdD9JLlWJ3s440jfZWVZdeJX1QWZWhb/+opE3Av59iws1FRX12y2HMvYW9UkuTOC02PIdsXx8c+fwIuu+wyXH755Xh+zlz8ed4svPOd78Sxxx6LMIjZPADgqF2uBw8JWGc0x6pqwuSsAwhIQxmtRT0BpWTZd6TrlM8W66dP6drsegQSyT3hC6bLCFBODKrVg/dhet8obrr0PHz0Pe/G5z//efS0tWI8ncN07EKeUU3poxzDM46KWmwgeOSrGMGLAS9FL3SR1CQvFlibOKtdkzDybMHb7pjRja59KrK2lXcK0TTMb+5jygKIYEkhRSfhq6EjF0+jUfU1tUMrmAwjc+9yqx8OvTCESmjQosMSmb9DONF4Dyb8KRtYRE0i0SbGm7KbAhl+JcYrwkv8rfqWBaQx9VVLYUjUYWSuv6ED+XzzQQxHRrxEIRZvzqiUAtgpjnDv8Rg1zRAgZQWYdjx8QpzIsOHfgIb8MmI9mKjhhBtwN1hBWfkatqsmnhxwYjH53oMTUIsa0ao/Sil2qCZoyAbKSuFciYzttUTphCWKLJRUDMoxXiN7hauq846HI5EBXKIctyO0Xvj6feGGoIyqSbMJvJzXsXjxYsydOxdxQcC+oo4vfOEL+MlPfhLa7xWbTL67fBTqWHe3JBq3BQtDOsylnNVoUgldb1yJ5OBCdBh892MAUClFruhu+Gzvz6D31v6+Nz3VvceMLzHdeaUxYQOeyy13r5tVyJKIjrbWGs0bt73B8owBe+sZwYNd8hJv/JN3ifcjDy/jFbQDA3SIKNVJeru7O47n5c3uM8wpgzIfvoXa70W8arQxwxsI0SCuRJM3M8PmKwCI9tgRXYfG2ChG12FCT1tq1JFxy0NsJ3JIVL12eYZYxfObHuXWx0sBcTBwmJGZBL7yla8c9DajNoI9+4L6WcCSyMhSFbvjO7A1vTVwPy5SPNH1BJ7qfAoC5xR0vFAvGB0Fb6kFxI+ERAa2uu66TsydG8OVV14YybDx4PeiSExAteRPmhgFnQpoiWXhBOMkTuCpkH1H9EsHmhTN8kY3CGL3TQEBUBRG8XzJqElkqE/yIzBpH96YHvRoIL5/AWBAp1hdcsd6WHfmnH1aY07Esk/MHsXkNYrZM+ci/ZUfQWz3xhR595anA/32gyeRacM+fJu+H5965HuIBaLHBmtyGJlybA+mTn0dR8y22v3WQLgnh4OjNpmY09947Cm5AWMlhWPn1BQIsGJFHabfluZKah59qz+JTi1cfTZqGMgW+WHlr8YP8BH6X/jP8U+hJPJVMAQCYK/DcUZ1UxHDc3S9PN91h04zEpe2c9qQP8mS1AqCgNTZb0byre/y9hcp5Il3YiyiwXD6OkQUSbj9znBWhqp454vOSJdMhpFR7G234rNdG9C87Zq8tAxsEzRckkRsCXEt7UgDSTcVUq5JZOh4Fz6a/RT+HecjWbX6IdrNnVg9CqrGZ1iMsHw4BxiHGZlJ4IorrjjobUYxMkfOnxe4Nm2aDEkikOQq9ijbuFQ+IRHsTu7GztTO4M1JQDOD9hbvXH4ut+yn3/0OXHCh9W5Tp3biYx/7GG644Qa8/ZhjuOX98OdoyuWaCxqoUYpRna8/Nxg3SWf8NFNEu5kFrQW68roDD8resQyPjmHBz2SEogFewLRPlCX4NyjvwxKTWLKiRIkK3J4XfDmvXixaG7lppyyQGOIs1U6krtk0ALTPCA9ZXw9XXf5+yAsWB65PL3Fsr3zEWygQSDu8YzC1OIg2DGE8KyFWre+dVGNkTIJZR6zGlCnrAAB3R9he1EAI2sftDZmRtBCBP/ZntgBhH3x93PIoMdomazxN8K4rW3Dfr/qw4eNL8NX3/g63/fBc/PaeGTjrrIxdwtuHty46P7S2UcNASyU4FgOkCwTAiXgM3WY/ZpWG4bwbBcUr3asAAOXkLlBbulZm7K3KXNWt9X139kwPXD5+z/E4YfAE9F7Ti3/5l3/BJz/5SbT98+dBRC+dGKepgESG54otQUZJjDBE5nwmjWHkDcLYBNn/su7XALBHm497hv4Vd/R/zaqS5z4eQUU8+eiINXaCoQUqEnMMrfH1O77dkgqJhoH3/eh2DClZvDojhnzBgGhX0036cOkJwUjTsVQcc+bMCVw/GDjMyEwCq1atOuhtRgUUWzj7CExtcdUyhABXvttiDiyDRd8isH/GmUid7JyfHvsVTsv8ILI/BtUDbssOVMObWG1e9mj8w9yrcPQ078njhNnTkU4kavYmoqaBECt4WrbBbMmq6n23qVOOgJhpXEUlE4I1Ifa6Buf0qFERU56pgDJpDCgAtcNyXdeJiq7dXluTU6a7ru/E+R8xMf9t70fx9MalQR5wAuI5H7YKBRIJnpwIBUApNMl9tipHn6Q0u06ljg5cYFROsq3DNGUF1c7eWr+OPD8Y2Gza1CS+dcknI+uOBq9f3jkRf11A55e837KjakkPDIlAUesHGNN0K+5Gf7l50ikQATEtyLASkb85xSKauLvVMmxevmRB0/3wtA0CUSRIJQVsN85DQkkhnZSRTjMRfKm3I61SuDHviGEgptVjCAlmlUY8V56cfjdGW15AIbMRNQYl1ou1qdl4pO1klCMkMoD7pSkBRCpiamkqppamIqWnoCiKx1tuxRuv1OjcME2jk4wE6vMjAyFSIsP7ggajJvME7eUuIYoRvQc71GUY0S0aMpIKhsGIapAwS5gSmwnVvXSFZE5EyrZ5OSIdlCIKTKqGV9tmYW/HTADAMetdOkIAzO1ZhrlTlnmeXXL2UW6U9IOMw3FkJoGZM2ce9Daj7GDiMQUfOW0lXty+C4lFO3DccUnMm2ctYEnSULQPNf4aEqJ7JaWVAcXSu89KRIc8f3DXjzGijgJT+7ilqqaXkelOzgIxCf759Etx12v3YdfoGGa0tWBpXw905r0UTa11Mt0gI1Mqe5kpQRDQ/uZLseeOn9Z9VnYMVUNOO7qgBLTmqilC2VWBniq6i0hwS8k0DoXxCtor+ly7bcV3svONuv0DAEoYfXtDT9j9IEGpWEwF7vnX5/DC7GnYnbLe3agjEJLtD8JKzylHtF27TYGMmcIem8nV2rqBQYtwdszsQMspLRheZXlnKArBv176VpyTvAAnXXs8btx7O+6789fcflRVL2MWNRbOZqXFRMhVPqMWN9zNSfB52XE3Jzs98UBVQMv3JYijwHgT4vS4JmNHbq0vQhFtOlLqmGhJEbriEZtdA1AY3+uEEJJp2GenQ/gW5gAsiUxUBvRalWBtPyhMwYSujHlcpQgF7uu0DKO7qns4tfDrZREzvBKryx74PT581y9w09usdkaRwvfk7+PP1eNqZVRoUHxeiDkQlMTww4ZoBj/g1NTWmjO5SYW60tS0OISC2Ql3VFw0opZlP5NhJ34khh6oTYwLeN+RTyJb1fHLQC3sXlCBbsegqspeBmW6sBYfftNNeH7TIxgY3YmZJ/RBTG2r28cDhcOMzCSg6xM8RU8CtI6uMyZLOG7WNCx7d0TMex8SbMRZUp+j1m1zuIqhQXdUKxxirhr8PiTlFI6dxWd+AEBWNcCmP5lGGZkiBUb7ENvg5o5JLVyCdOcsFPZuinxW0zSMmlpNPilTFRpjK2RyDFs1W9qgo2AvIu93kU0Fsuq+v9/Lp8Y0NRCql4LAkOxxcMLnTyLYywXPmoEqUkIP4IvhYdrzQmWOejWZD6VQx37G6WuQXjvGkwJMK7WjQDDlvVNw6THnQlcexUXHKJizrhvq6ofR0bcS02aHG5Pe+/AfgPMbyzrv9ENLhDMyRSkOgD9P2TQPl+GP+B3OxvzZj+FJ+1riJWvC9Bv1JTlWfwgUTYIZC1fjGZQ0pD50GJm4kUc6IaBQbtaKGLhw3mLItqqFEiBeY2R8c5U2fsoeMY26TJllUUdCjVgdJBjJDl+1FITf69LPyMRU1YqUbZf7sPQ7TCFDeES5Hr9UvwsAqELlMjJVO9gmD7lxHQWfoCopFaFCCf2ekuF9+yptwK6vQTMzKli2UzUbmdpIW99SFkwQAvSZ6wH02lV7+xMzNMh6FVMGdZz6mvdA1DOyGztaFuG4uVa6ktIR27Fj55bGOncAcFi1NAn099d3U93fWL58eei9Rl3far4q9k6WYJgXXahvqxEM6g5I5aAlZdWnWnIQF4MGijnB9b5gRfyZWGOMTLFoYnTtBZB3O+6v1lgk2sIZJhYVKmCpYDE8Sp2gXIBlIwMAmmgb0vruSzTWkKrC0Ooba7IuwkahscR5uuAEig/OiRaO0Wt/azBuhiZa7Rpc91QT1BxpqC+CTWYkRoJDCMHeOcNYekIauYwI8TcPoPryL1B56ecQY+ESjlI5jEFnDxUOk2j9q3NSEzh4vG0h85R3rExGZboI63AjvovWvBUojWUC82Kj9k0EkiEHvojHfjNwz707wqhARm1GRtQyE2Ji7O647ZIIiUwTRtr/qxn4cSLaBsoURVDJnfcCx0sIABI6w8jUUS2xYMcszgT4pAA0X/S/c8XnoAoiWskYM/bW8xXiBrGUQRDv/kPDfWion77PVjbCPdCizi2SbVwtVt0KiW0j41ct+dFGo9NbCKaJc1/wrjmTAka8BRqrjiY00vj4QOMwIzMJrFjBTx52IHHppZfinHPO4d6LIjfr1oVnDI836ftPfCtwg96BMU5iO5WTcwQAYqL35HHqG1vRLU+p/WYZgHSDkWBffbWCMTHYntSA91JHRwcAE6eLL1n9a4iRsT0PRIcr8BIMmSpQIoxHHTNHViLjFSUHSwOA1L4+tEJ2I9Y5UiQhwitr3dSgrYUhBslDPTmQySNmIVR4c9wyiM7/nwhiZ/jWdzyDvpPDDwi7+3fBLATjeYiSia2tXpuoK+6x0nlk+8vQQ5iNfa3s5uHtpz8flmWwHVwr6f1lF8BZhq0bXenTv+X+HeqmhzG07lcYk6zxEsz9k/KBAhDcSJnee0Jw3lxyBl+tvnNwAMZg/ejdbEwj1hCWxWttM2p/a5zgeK5hTPCSA79EZiwVtDFURRkZxtYtjBoSsYydS6Py/jUqJeWXq9Ac9761fLzXWAGvYDP3Amvr6/daco+vYN9Qgz87dq0GUAJsn7oYFZ9aKSUS0FgWesxLJ/3Z7g8mDjMyk8Bvf/vbQ9Lu5z//eRx7bAJHH5PAkUfmMGvWLMycORPxOH/TX/Pc8djTH7Qmd8JdJyPCyrOgVAGl7nnHmfODZhpljsHicGV74BoQlMjIhuk5RcUY25KYJDY8SQfjGh7q8va/c9EZ+Mb54fF+zjntLFx88cV4RXM3RyWQ0ZqF1U/NFCFIIqqSxcjopQc9pSSqoLPf0usPpHMc6ti4aoilD4SzqTjYqS6xayb2xu0niN73Ym0ZqJCE7mNcdGaDfpzwXfsdpGXb24Fzui7a0YJ5b9ym5ZF8xvtM+4aLkVD4kqqhoSGUfnN74B0IKWNbu/dEmyu4oqdyjK+aqKbcDVLzxeozOT0WOIbtQoMHAUVy1qefUwCe23Mu9vR7VWpCUUD75kvcCwSovvwLjG97ABWhijLHkLsZsGuOEhLqoUtFFaqPGb320uORzYbFnwleT1GG+aSASUQ441CVvJJbw553qsRssnXG2JFaBhgZ00sTR30OABvNmdAE2ZcFxKVwhu9QU+h+NrIfTgemdr8aXY7T1wBYiVnNKzKkgL8+O64V0f2HMu8zZcIydl5bLVOIQTHTKMXcZ7a1W/RVVDKgca+6aTKpTSaLw4zMJPDRjwZzihwMnHjiifjSTT348pd78LnPL8SVV16Jd7/73ehub8exG3airSvFBmuFYXo3Cr3UYv9lMzLMhhUL0febNIFd1Z9jl/pN7n2dc+Ad0/ih0/0SmcD9qrcPebExU65f9Z2E+7u9ZeXpi/DWJW/Csb1BT5kZrZ0465QzMHXqVBRI0dUiN7AiVVOEqRuoiAUkdX4MkZiq4pYT34y7l58aUM4Q3nEyFIwBpMeR2YvHx64GAJhUhFYbs8Y2WUNqg+Y7eWkMY/OC6P+WPiZJSnCve67Ym41kuPXyMiXHilPxtpM+1lC/a1UjaNTMQq2TtZoCUGd4mZRAhnIAqTUm+p7xuvYXk/VD8q9ccEbtb8Fnc6KYKYypHSgWo0MGOA78zvQckYKSqYmCZZYFjnfOoOJloNtiHfjGN6cEygGWDVTtb8czEi7TpZkizPh0TifsfyaxIfqFAmESGafYsDob1ZCYNgCFBr563I9iwvqmiq12z2f5UsVGViMv0J1jiB75vOm6vTsBOgmlsDYDViLjogRv7qm1bdZ30QUBlVQvjl1fQTHuzlfne0pKGkKMTdECVNLheawONA4zMpPA1772tUPdhQBk00S+LQlJc08ego8IqQU7lbxtsBojBOfnVJyd0dBRHOHWWzUXgyIJSmfD7+YLNGSzWoPC0Xe/lGckIj7bkhaOisOP3PE5bM26kTGd7uyJC9iYEtCaDOqfR8sMkYowaMyM7gpc0+3yqljEGbs/520UQH/M0q9rkgxTEMK9DpqVxjZQnoJAa8DWyf1mBIbcC13yPpMruZIxwz79h+0xpmGV5Ukxas3YG1zXkLu5aGZQ+rXkV5/D8lmn1u0/C6EOI1OJ8VUw7KZBKt7BlSDgJSyzb1r/ZH4j4fq/WIwrBcFYZhqePvZzdfu3dJYb+yaueQm+yRhTR+3h/jU2JFm2EcoEM8p75hJxLwgISv38TJ2oZnjR/u263LU0fdxSH74P/wsAeGHvEnzi6c9iTyLP7U5sz3botDFJk8mxn/OPX1xnDk0kKJFJUw2vdcwGAJwv+BO/UuwUrGS5z6Veq119ed6t8GPdEf5NPMISyuYGmtLE2PNUTjeYHZwwSVQ9h1OCQSbFhFHx0sUdKYuGrs/3QdBLkHSKlWvd7xHTrH7ExQSkuJeRNqUJzsP9gMOMzCRwKJJGBhCyGggTVVJPO6J9axJqgjWx2SfPyep4c15DGCkVicvt+xOjNXuAKgneJ0yf2NhvW9ISYUwpCMCshSlMefcUpEKiTd68MIZWTij30UoRpn3SKccH4YwIAfXomzNjQYM4x9iXSipkW3ViMie7TckXPeX/mnCJrinkUEUzgcy85qChbpnMn6ZkyTp4p1uDN2WICJ2RfLUVBjBlpOA0AsM+mT5VtDZddfxOz+OOIW9U2D9qM1cS04H868FNMzm8E5Io48QFfO8kWgkyLYQwaTZ8XVBTMqqKl5Fx80xZ/wiUQrCrlUUNsXIHOpCEBhk6400ilqy+i4aAp4/5LJ5b8SluH/3QmM0kqfntNNgOB6UZYXAkMpnEZKL71qy13LY5DacNEbvijK2Wmgn3oGTWc9/4btxCr8BSvAgA+N5L74VJRbwe5zOWylC4m7XK2MlUlBSoErd7zRyoABCGJsYMr0qx02e/ExfGUFCSeOy4llo8GVa1tIe8iDs6/x1f6HXjae1rex2PjHkDXuryBLbSBry7/Mj2OXaA0VwQIQRwoo0baq22XVNKGGeM3+c9GwwuCQAFOYGfzz8L7WNeWXLKNihOCgqU2IjbHiiMiDg7BxqHGZlJ4FAkjfSDUADDO2q/KQiqQ15PHd3HKEg1JqeZI0GDJ4EGMC5Et+uPsNoh8VVLn/tkH+753Qxc9qFeiEkRSU3zxbCwFu/zrRLakvnA8yaltdwgpuAVIUumW08FwZNf1Q52pTBB5Uoz5jMte4+r/9bhhqYf6foMRmCp9ySlvnqgkbgcfpCQMQOASm0P8darMTYJ6eq4x2U8Lvjsaww/c2dv8BERiilPtRTh6JCO8704zLGR2t+nDD8HAKioHYFyA63WGO88Po1yiNG4swmahIBUrXeIyyqyowsg2++yh7SwDwAAbrq1BaWUq1JaOT+YoZiFynjgJHQ/IxMQjXDBMonz9x6HEdtj7j3HXRrZdhj8NjJRyOgChpkgQqKaDVcBMes7n+9HHFUYdqCilGyts5GQaMYskowNkLq0BSVGJb2hLzw5J4uY4WWYPvzrn3l+J4i1/lSFUZ+wBQhBRd4A1Tf/DT14aDIpoIYYLrOod/Dzf4uu/tcCZYhAOUKfpK+MJSWSRre5imznhBbyudthrWtVlLEt2w3qo9UpO++STAQkFdduzgSgT9JmazI4zMhMAu973/sOdRcgGRSxmtudNenKg3PgLJedmIqd+1xddq7ShoTRfB6iKNhbQcPlg2aj3sXCGvtSEHSGbMpHLkkjkXCzFmXsuBOUakiMrEF72WUS2jiqJQAoFG1vGVn2EBiZOdXxMoKbtmopyeam8tnyhG0NhtyDcWRABBN9p34rpBS/piEDMDSC4l63XWoI2P3cacw5kkCQJfhJpmKnJEhVnXLe6jXZ3exl6t0AYqQx10ohiqQIDiPDeE2kwjfQVJwfmZmOjtT+ztgu/sOFpYFyY7bOXpTGUQkxhPd8Jc4rUhCMIh+4LhleZnvlvGhGRtPDDwIk4pe3L+73nLv32Jpq6b0LL0Na4bsnf/uCjzaUWJKS6A1WBMEPZltjuLf1RYuRiVAtOXXFE9Ya1HVrPmWjGHefriotuBsjjYkoia50xQyxa/GrcGOM80KyOI6kT20tOQEjCWEkO+xKogj6MVAYasl/Cc/ubC44YZi62ZBs12m7P8teugv+eSHFgwwTYWgRgVFzwRYLu4EQD1I/0rbkvShbY80JRF1DhrHRqgoyTHpYIvN3id///veHpN1Nr6xuuOx38Y+gjLHv4oHjQstSk8BkIsgaHrUVzxXXWeEmBLExozgdFP1MXRTAK8uXecooqkv01ZgSGqdjfMxazI4kPG0TKaPyPBKj6/G2jc/hPWt/BlCTayMDAMWSzchIMu7DKW4fGKlBlC47Zca4Bfz2Jn6cjEeDF0PbcW+0SiYGX09j6A1XJ59al0Om5CVsihKUusX0aGakyriqz6r2RpRsEvb4UJuRERlpV5iTnC4VIKf5W6s5Hox3Yka4IYsmQTnERqbe+VgAxQiHkfFjVvciXH1WuK3MjO5gIkJeF2iEdIZlZBJapqZaysUzuPOK/wlUe/qso3HezLn43ZX/y202KLsMn+hVYuKvHRK+efJjeH7xf0PT0+AEs7Ur5tRjf/MoRob4mL00G9JBEVAW6wfFizpOTdu5GZpjx2H3/a+F9wT7UfuLskVdNkcax0uzNgeeGyxPXMUXJ80ZbsuJ4FpmI20LMGqeSxase3qoYbPFOK0xjwIAmHYcqij1ZkJwGZcykZu399uPOBzZdxJYtmzZQW/zL3/5C35y80eQnDkCQgC1qGHfFhXHn+fzHWW9EBqwKjPUJDbf+6/IpTtqduwWUa1vAWMIKvc0y0MRFDtjsVpieSGWwqZZXrdTwhgDV+JxtIZ4LY2NW40m7PWULYyibfMbMHVXf53TxvDmh36DVo5xIQA8/PijePv0dwCUYshW94whjZklBWNCzNa3h49fXOP3TZMk7M2He6G0gJPkkEXIsGdFivJAzFMuL/VjpbIeP8d7a5eTjQQS9G04KuPyzHvj1dLzAJbUrze0PYuR8RDHkPccbn8e2DfMvUeLnIh+/JK1v2IqXyISlYQPABbhFTyMsxoyBFsy44TQezN6ZiEkPmTD0Bm1RUJPY5vkMnSLu+bigQdnob9fQ//P34kp2U4c37cMUukZzGg5Eh2pVgwUvXOOeH2OmT9tWzpdhixZ4/bd6QMAchhLVEGqFGNmDA89yP8ONCKBZjY2brcRnGHKXm+4hqxQhEhNzBCGsAkteKz1BEyp7MbL2cWBdKgAoNfJKS9pKgSf1GevNgc5+hgA4GWlAwvKVu+iQMQSBpKDiHZoohG/nGvu1VZpR0BSHfkuCZ4Ky5dXiRMN2YiIeURBMES9Hni9g+GqMsaZCSVBQdKYEVr2QOMwIzMJDA5Gx9Y4EPjTn/6EXz2yGXjEuTIMgezA8eeFhW0nEEzvKU+QK4Gjy4Y/3Ayqx4HQQ0WUyJsgUW0suikFsFeRMLeoYjCloK2oInC+lr2MTJix79i4DkBCypYOL1j9CPKD/YFT2cL1L6EteTG3jjUb1gLwvt04TUOmAloHj8JYbk2kREZWgWGBzzT4o4iyaMphgc0/Qzi6cQ6yiVTdYn5CqcXCEpJaJasRNXbGp+GotrNAt1g2CGxUXOcxyiWi4XWmQ9w5xd5pgWsmCWdJKIDxVPRp2QTBy+2WtJLd3+OoWBIZE3Xl17IYLhUSiMDl9QMbegMpQgAgpicxKgQZiZ72FE5dymSnro4BGYQY5lJXmkhITRrkhB+oFjog5y2PvR0xLyM4KlWxL2STo2qV+1nvWK8gTcJVHKTq5QyOS6yHoKbQLVWw9LW9uFteiB9New9ACE7FhsDzn2hZiPJoFbl4eGJdPyPDYh8c4+Ham1j/57zLeB0JNImUDfG/RUIYRtlk7LFMHWrhXm4NUjI49oLY5T4KoaZa8jYTYYyPoHdlWSFQyvxnOnedhted9gwDgj+43kHEYUZmEiiXo10+DwRM3kIkvn99YD1wdEGrMTFO8UJ/AtCDm7F3awjfcAiA9rFwL5ykmEUBeq22wRiwYuco9sk6xHgOfiEtZWw1qrEYligKLu7rw+gRRyCVSqHTMHDcqITsrPUANGzrsPqWHwyPCNvKMfb1vgPzrk0Y14oVA/en+LmBohiZZvDYguXeNhWf1xfHDSlnG7eG6eHLsgTV3jOd2lQ5Olu4HkEucrEOdCamYYQYEAG8kFqDNBZ6yjheS3tjbpqFtJ4EwI+APGXKFKSSGRRLXrF78pJ3BMoqIRIXBzu6+akdnPHRDXfz89P6UeQPaLCv0NkWkhXbeoag4s/fpceR7feqjml5PLR+j7EvdXsitVvOA3O2XYjy2HokhxYBrd62RoUC4jF+zbRaBY0H3yu1RgDdIQJhqbRECWDUSxIp4EhpO/agA7mKzQBFrM3782MQs8CF287j3icEkAzvPFEYbyOxlqLatZExBR13ZIOMkdnUhOCX9V9NCiMeRiZeWANTW88tLMruBbN9GoS9mwHBZVwoRM9vB4L9/s68r8qDiGmWfDwlDGGAugz/XFXEUFZErsxnWLOjc+BIgRYPb8JLTfuv7j8ctpGZBObMCUbLPdDgnax4Ylp2obHuiGUpeIrTivU3XO6GWOsLxXgifCNhI58SAHFsg2xSdI+VuGovk/GeoYKArlwC18+YgVNPPRVHH300lh0xG0fPOgbplL0xttiLMh5uxJxPRG/SUfAnfGRBylpook2Vie+RMfwMaLDOnlc+YNXpu85GpSWgEBXTs9vysgKkWSaKQ/wfXjgdIzFvv0updhCxB9V4jruHmhHSgqqdINTx1uK6YdsSmQKTZ6dLC1e/CYKAs055k2d+K8efDHnxkQCAE8pP166L1AAhec/ztSUg0tANcI1gMVvpistM6Y5NGSWIv0hQqiQDbxPm5XPW7BMD185bHJ4exO4p96qZ4M872+IImuH9Hsq+HKjPKNuwDd6j3OLDUM5vQNeadyOzd0WAkRsVx6HE+POBVlnvFbu3hGA4FQy14HnOb79BDKRDEnqGQaQypIjo5P6xFjjB+1iJTDUxsXx6hBmwiuw75DFdoEy5pOBTyUV8svJQ8OAoSayGgNSC4rEoZtsC19hnpul2YD8TOKEazAs2m/nmrGoypjaYb+wA4TAjMwk8/PDDB71NLiMToA0U+xSH3LFXKUpSAabm/exGtRHJQbRqqRhvzEhGFnRMSb3MVBt8H0P2iigLSRHxis+1j7OpqiFh6AFAqhsgLpxqtJpeAnN6l5tMzqi6DJzgS2g4lHUNjLttRqZdOQkA3zYjORzMdwT4RNuEQsktRe/x70ePbG3xSsqw63S/eZoTRNCppuozRCa2+wkVk1Ay78C+qcu5zDEQTjBySqe3D7wTq23rxObNGRFdaYshBA0RVxx1ND729i/irLPOwrve8k7k/+1rIJKMo+lTuHng3zxllcxF3L7NVMcgwMRjJ52E4izv6XqMWAwuu9FrutVPaQ/Q+gMZ7/zxXxrWBV6x/FLIzFxTpDhOOmplpMV4qMTEN4TOz3R2Ps6atg1HsGoIAO0/bUf8Ua/0yuDkparVX0fyqKbdQJCarzOjwghiCv95i5EJfv9i3FVf8Z40497120+7kQljZFJ8D5lFw4v45Z2+MX93DlPIanB8vElYJiplcN/QewDwK65cJAWvTZgphatDN9/LM8b3HpYIRyJj2gecMa0Lvxm8qSaNcTBFs9Zgt8Ff6YsSfDpqaMlQ6e/BwGFGZhJ497vffdDb5KqWAhMo3I6iJI8HVpCpNzIBo8o0vthjoop8egcAAlX062StvzVFwfTNWwAA+eFhFFIiEiVXjacnvdtsTTUSIZGph6i3S8DLROVk97fJSFqIaTEUL7S9AEKpJ2u1854x0dnwJ97PWPsNkGJpHJuScCpmgHDEJylRCDVk3djl3QBF+wRtkoQdSCtkg6IuqRRslxVFSuGEzosxJWHpC3ju14YvZohOJMzfmoZsSkhtt0TTO6acjEdP+S8MtHndqE1BxbSu2TjxxBOxaPYCEDuw3TiyESoTq29OkL5uo4zPKLdiV+9UjBzrzcys1vT6bm2OREYctK4tf3UNW3kkjpq2Ared9RGcN20FTl54Ef7pom9ixpTp0Q81ifzR1yE1NhvX773cc1008ohvZuyKaBX6uC2RaSDuv38jSu89qva3Jng9eMaEQbQVj+TW01ocCx2mSImML9FpRY95JDICo04BY+zK1pjVGpO85krA//yvgVPu//fIciRCumNQo0HSR92cYBHMUcInkaGE37ZRFaCOBe1RHKo4feCv1m8hz+mJxUw+O3QV+rX5gfvOaMrUCpz5ep/bzvGpIBPTkrVSl2TbX4RpHmZk/i7x3//93we9zUYkMompG9Ba84rx3sxXXUJeb9o1aiyaIyqyDainHExJW9E7h0/5AETOYlUlYMXq1TjqudU46bHHMZ4UIdvp6HumrMGR5/0R6sxN8BOEKNUSKMXbl5wfuHzycUFVAIuT8BzKptd1WyQmEqJ7Ioz5wuyrggpCzRrx6q30Q5xEintZYl13ve8chwQn1QSLWETQwTC1CLUDaKWMVm4OpEoxGHRuce856EvND5zuWd7F8GVL1wUJR7/Rik++dilyD1rzdN1cy+7llSUfxOrlN7h9EvkqyxG0gDHrsL0xwt85KVQhOua2jHThTdqfAADrc3OZ0rZUSQ5cqothnSI99QRc8Kav4O0n/yOmdcy1no14PqlHiftdzNHPtLpiGxUrpteuLb78SiSOeX/tt2S8Blq2TOmHyj61BYD7Nqzx/N4as9V8tvQotc9OQsqZu2NkH65Y8A/cfnafdhZ3qyYABCJjRUVEip0S6hSYakuA8dZzScQZ+6m4zPaDzwxUxPCgbKxQrGeIVb2H1UkhmkEpoVPNpurzEEKCwPlr4jJwvkJJke+lF/qY4Jes2sbaVIekFkCEFBIJr4TKMbinHJpBAVC7DgUE2ztc2rxuioEuTvTi+Uesxqzzb0QyuxlZ8eA7vzg4zMhMAociRUEjNjLt597u+a1JrvL3+B3nBuv0KG3DWg6fKv8Q346k2ggjY1Wei1nEdXbuKC6BTw1sgazrmLNhAyRCMM6cBGbPtrLPFk97NPBcAnwvFwcfPPYdyMZd4j8l0xnByFh97cAQqmZQxJuWLEaGEiBBOR4ETJCN/3s1PPt2I4gprsuzIACm7hOHGwmoZtBYe1RIoUrDPThYHEOfrHHEndoMbhm13BK45p97hi2zkQz3myU0vz6fQDIJFuhzoS3IwY/RXJg1qIseePNfjWV4Ug/vZHZO9+3vHIJob4rTdcvl97UOjls5Z0oP90W7tb9WMbFJ8RkW1zm1d1b5KkUWP+r8NfrMY0BSfKNlACCSt2+SuQ60Goy54+CKpSvcZwlwR4clgREChv/BFxgVxzBLXobTF3jHTV6yHDiCwxTaG2RPcj7OqCg4AI+OxAAAp8RJREFUww0vDaG0FKVt76/RoZTSgx9NuwpUkT3MTUKudxggkYwMi/EEY99R9tbrmdMhKkEKiiotQWBSt8gMg2wa3skzkrDWoRnh/tyrvOy7Ej1x5OEBxPq3Ba6bREJMtfsle6VmTo2JUKbJkcgQxDR3Z6BEQJETtVggFErayj0WF5uzZ9qfOMzITAKHIkUBT7Wk6tFhsU1bLKxoEuJGChNTbETZyDShR6beoFi8J5Ui69roZWSiq47ux5z2GfjMm87H245eisuPOQp/fs+P0JK3NmfWBOB0/NXbH+J1tSTEZWQAgjiPkWHCni4sbqo7QrlfNZZ7iQAwtSAR2qWxHkJWa4OjpzdUJwCchgc5LTUPwzY2rUrumHSmhpHJDATKloxxGDPSAXUSAM8GMtbiOHm6166BN8ibSMIDfTnowV7M09ehQ6/C0WIMJ8MZE55WQesEdrZMwBttAqYWQpmxswAFAUHqjH9t6FmZbAaBCif87sdWetXgBMD5c70M1LjEHwsKEwWPwTkwLFob5Q/P/yauvroFK09I4orLZyN/03+jmAg/UGRknnE3AdVa4XxfAhFlMQnKuIQDQDxjDeJMYRAzh/k2MiwjY/gSwbJ1sfyJXAxzlaaopIOMAnufhcgQEVn2MlS6KKJonIG3lC4Etbddr/0i0CFvwb0LvoVlL3wpok0X8f6tUIb3Qtpr+X06dmlVKY1YxaIRpuA9fEiq1a+ENBJSK+PFxfB3lAi1xKG/GH3a/xAAIBaVb+QA47D79SRw3XXXHdT2isUibrnllqaeYRevJvk33GjqKjToYrhWGYSZ0JAph4UN9y14wXQzN9UxOJRMgkLSYmSUqpWzRXRW2AT22lwiiWNn9UER4h6XbPbkNx078QrbB6KCDbBDQJFyJDIAJE6sdkJpbXh5KQ78SD2mYPeZA6in4bcYmVF4I4IRpIQRTzm52o9qg9F59UQK7djXUNlm4Ly1LKtYtvwveGzVlZ77xtAmxFfvxBOnfTr4rCkF1EqGbah4QeHPaE15g7vJnCGWfEz/BXgQackX/4NzlJNtgsxjZBRZxQevnIHz3yhg+gTSj5liFYLRGNMaW5cEbE2ws4aIz7NnTXwz5ldmRldEDVx/0nugGhr+sOZhZONpfPyEUazoW+I1pfVLe2u7PcWOFlcSZIp5DEmWzVpMUnDFO63NUq124sF4CmOGDsCrykokCiA0Ac1UIdYCXBKnevtXULXDIp4DRPosTo2IHMcamY+bGeTFUW5BlrTFCjoqbm98xr7NY5q8CLL0W/eCXd2wdgOmAdgcQQ/2ZjcgXpnYtixQERSAKqcRL++GSKvQfbFdqjHLKDcu8CV1oUloIYLYrtbDTGRH1iM2OhzhgcVhicwk8POf//ygtqcoQQOvACL2zCO3WCJ7/3QrKoBg8GN5+CseYgiDkyDwuUQ/dJ/BaVtsRu1vk7PRj/MmPc/RRTfRLVr9jlcqUNWgHYxLfye+kNgndZ6bsY/I1yQyhL3mZRQT9ulwd4wxMCUkUJdZscZxFX2+ob6aWtDeQYDukl9KkC6+DEkI8Vjxta+ls8iAKRtwQ60P3fSekBv5Eql1jzXRAkA5CSkrhpU8kMfItPrGKe0JxWr1kGe70JO1n+NYlJsgMAUBO9sbHx2BMeYx5WAgNVXgSxcIk5DUBAXvi/xXz889nl8e2N9Z3nEdNqgEnzn9w3j0g7/ET975I7x1cRoajXuK1mr3HWDYgwgFASUxjGWCqU5EyRo3IyQSNwCoIfl4FkIM9ZRzkFIrkDrXRpZh4U/cGoaY3yGSqcFbn69cSHfjgk8VHXgwenVoAsG21iwEg4lT5hffcCDYEqiqlIGijkIyKwHbtWK2BYIZFv/MW5YyXWUdF0xeBwiFeQjZicOMzCRw6qmnHtT2ZLm++DzwjK4hr+YBAEmVzwiZpQWRJOTN1S/hPzRLND3O6EGroQsCmJV1CR1P5VO7wslW7e2chpnEEoEnymWoKiPi9ne6gd0z3OWU/zDP2YMAjETGrU9iLFzH0hkoNmPTr3T4XKi9fdA5MSHCQADAp8rivZGsDkAh/FNXVeEReIpEiKtruDGk+20N2yDUIaat1ehIupTEahKWhkEd1QPbvjWnJeLaYTgQQ7MaupD14Dsl45yorXbdrw/NAwBs6mmckbFsnW3GSQ4eGHYn/ZnE7SYjfrH4xPRvcJ92emiMF7C2YqJkUtw3VsWzJQOWAkdlmAf3L9e8y5GYBNvW5fbANVFk6QG/v1oII3MjJ8O8H0dtX1+3DCshSMVNVPxiNeL5x8KAk2yW+grx32EiSleea3LYF13X3YpX+zqQ2/PnptooVqzULFUpg1h1tBb8zgNCQr2hPMW416yrMxP78CV/big6sXHZXzikjMxNN92EY445BplMBp2dnbjkkkuwdq2X465UKrj22mvR1taGdDqNyy67DHv27DlEPfZi48aN9QsdYizbxi5+4vvX/rXvrNrfvMW1UB6EIlgbBiXA7bFVuKf0R2hmuBRHIAJm505ESsohzsn54ZMqI64TKFUOkTNUJGNW/o8ZW7ZArbp1iTHD12dv78fkIHEsxH2Lmyt9oJ6AVlyDZNk19vWRP1BQGKIAw7SWV3/M9UqRzAh7pkYogSmAcOJLsIRSIDoUdS/kEIlMVeaowgAkbUYmrBtE4PSd8H9KWtT4UVQzl0CPpcO35yaposgpXxHqSzAJx+bMb9/AYlRtPrCiIRJotpTClJ3N3u1wXrfmtJEbwT7baLvTzHo8x8LC0LTpeQxJQQmdyege9ZIlyaqY3iOFR5VjRm0FwTEyRNdIW9CstkzD6vsUJteZHxrHngwID+jvZwCSWuOHuXUdnVCFBpjlQTvZLI/JiYDIeFRFJfsMIvrEtS9dPzlmGB5ZlEBr8UnL2JeTJJYCDTEyPDhvlRSreIBUUcls8dwXhMYkYAcCh5SRefTRR3Httdfiqaeewv333w9N03DOOeegWHRPhtdffz1+//vf484778Sjjz6KXbt24dJLLz2EvXbRkKrnEEAsuZ4qPUNMZMqaJCAoAXCWlqwHT6Ot0HCNMdsuRzEulDFCRzxlgsG7KGbnTsQFfR8C8agErD7ERC/TIup66PLPkXZASmD6lq3o2OPacihpL1H0k4c/zliMiuiE6rfubu123i+c2NQjQ4RQpCWWiSOB9jvUYXQkrA1mVMrU7rXo41i40xdduYGkng76XvoYYvljIsvIpApZG4BI+BIzf3PEsAheilW9cLokMIxMQFrue8CvarLgEjoq94Cm5kZ4KPG88yyUOBFLd6hBIqo5BHuCR0VhhHnQPq1PpCpVFmprj0o+JokCcYaB306zuHjKGC5Svd/YBIVEgweHdj2PklBBhXjH26CtIEnLsFarMTIu87LTp/6hVHAFLxGqJQDIVnWYYh5m0TLg7nv200gOLcD2rZ8CAPxz4cvBQQBgmDHsyAS9rggEDPjUV9b1IC7eEJFF3IenZy6EGlBzBWsltuFwhTjf2GsjkzRNnFsoIs4wvYu3UJyQ+b+6dUeBx84QALE6zhtReGxxAl+/+EQo1VGIHHOBvD4GaxaEHlfc/hGgZ9jqi2wWPMfgHhDosRHPk1VOQMuDhUPKyPzlL3/Be97zHixatAhHHnkkfvrTn2Lbtm1YvXo1AGB0dBS33HILvvGNb+CMM87AihUr8JOf/ARPPPEEnnrqKW6d1WoVY2Njnv8OFLq6uuoXOgQQK67XQJxJ0kbsiLkkJDYHAMhaMIXBVNMVI08k1DlvyQRS6EUY/bYYWQiJFqueJVEufn4CTLAt2+fpRDkWfvZrBinJ3TjCNC9ndK8OPKcSGZc8H/Tg8fQkJBXAYzPvRHrfspCnvAqXtsE/NUxXiaFDhRKqWnILhp+4FDtjeVR4eNE370wpiUo86MWiSwVQjvSH2u3vE5m4K/a8GeKoiKLAl036yhyAAF9mLMhcEkYF9obRw10KFBQZBCVFbVoeIMBgwAvFPaxURq1vwuZmeiLhZQYp5UUOsqALEhKquynGdBMzh1VUXvklACBe6EPfc5+CXpyD3j270cKJJjw0nseQsYSrrSGgGIAZSBHQeKTYYKVruqdBk2RUfep43iwRx7XwmwA+t28IXxsYxB3rdiNeMdA7WMX1ySeR9BgS+3pEg/33R0cOQ0zjS1LqQcnOBABs6epBTHUZmfH2lQAUaPlTsD3eDUJV8Ga+v7+CSXHkFovOKcZYjcETCxX8CGno8WG3MAHU/1cZGT9GR62J0dpqEbfVq1dD0zScdZar+pg/fz6mTZuGJ598klvHTTfdhFwuV/uvr8/ayDZt2oSvfOUrqFarNbfpL37xi9i1axduueUWPPvss7j33ntx11134fXXX8e3v/1tjI2NecoODQ3hO9/5Dl5++WX87ne/w09/+lM8//zz+P73v4+BgQFP2VKphK9//etYu3YtfvWrX+HBBx/EE088gZ/+9KfYvn27p6xhGLjpppuwdetW3HrrrXj88cfxyCOP4I477sD69evx1a9+FZVKBV/84hfxwQ9+MPDO7V352t+WXaFLGMuaKw3RKns9z3nUJ/YkjVeCQY0qxN2AEmYc/kUwIebGt6hZYs5SO5K0Ni2SaKlb5964T2UGilc6FqNt2nZoklV/2bYP8S/jCBOWYN8BpCQNlmKYoGKf/KlzYguoW9z3eSa7FLLBGy/3mibz3VfLcpDJZBucZedBkYglkXP2LcknmYmrPrdUUUQn9nglMt4ueTB9672hW4zAcS11IEruPHLuK744J7pUwHA73+hZFy3CvFcK2md4vh/1/lsNCaXvgT1YS5beF12uZj7hrXN3vk6IALsvFZkXNIxv7MVeNUHBO6e36XkAQL8S4XVmM2SVyITM4VuBDAXdQ86mZdWVUU0Y/a9A3fSI25eqFTfWLAY3tMx4BTKKIfOGYJCZMS3xHLdUI2DTdABAOeaVmpu17+dek4tayFy3Ll7AhIM4dvUITlk3hh4lyKzVo4N74n53cH75OEcl5AV/FAXmAKSo4zVGRk90IZa/FmZ8OoZIFaK6NbRmlplRGWNzgbpyqsTOMcjlEeixYc+TsubdWzVNw80334xNmzbhtttuw6pVq7Bq1Srcdttt2LRpE26++WZomhbYj3/84x/j6aefxn333Yd77rmnzlhY+JtxvzZNE//0T/+EE088EYsXLwYA9Pf3Q1EU5PN5T9muri709/OTed1444244QY3MujY2Bj6+vowa9YsfPKTnwTgBrJz/r3mmmsC9SxcuJBb9tprrwUALF26FMcddxy6urpw1FFHcct+/OMfBwDMmzevVu8JJ5zALXvjjVbQtCuv9LqoAsAnPvEJAMDll1+O884LZnbNt/iDnlkL5EUsR/eYiZ1xoCyWkTDaAALopTyQsnP4+deMTdAFuEyPwRRq1/ITnjUD5R0YKAxAKUgQCPV6M2l8NYjYYp0yhHg+0FU/dB9hiBk6dEXE1xeb+JVtelVM6ADCo3UGQWBQ2VeAQiQUaUlFQY+h2MRJRBc5Gx51jWWjEUIoqXWnV/ESSieuhfOUk2MpZjO3ar4DVBSh5VshgNZsZPxIoIwP46f4OT0eMoBUcRdodOxBfl9lI5DoWrBtJqrKEEqZzZC0iAB+gsUI7RNtRsbHcUrJYf8TAACN59Jkw38nmRhDeSSsZPCdVBH42RlZDGVEfOoufvumEQNs42cpQfHbRd/CovEZyKsWc66gj2kmfDOUOPO2T7fq2C3zGRlTEGrdHmEYaNez2t74aXhKC5Fz3k2pVQAU1ZdvhzLrNABAe5XCEETsjU9xC9pVJkgFEimFMjIaKBSm/T5hGKTarENv0E6lFIsxVwiKySww6HXdF0yK1IMC+vaVAY+A0JEACmi3U5HwDyHRkExL+jUqE/SWKYJWdS5UuQ+y0VhQP+qrgeru4iKgiDEHUMfJITH+J5Ac3+AaAIbEccA2vP7DMSl86F7roJGsKoxdI4U5vht6bARy2T1UtI8P4Nr/vBWAu6996lOWunHWrKBK0Lnn3wuvvvrqWplGNSp/MxKZa6+9Fq+++iruuOOOSdUTi8WQzWY9/x0o/PCHPzxgdfMwNDSEDRs2BK7PmjPVd8VaKM+WT8KAYkk0BuODEKgCgxLkR6w6oshEVrqz9jebP0d2uBhmE+EmCOQgLqVxVNvZwOMXgtiGYWHh8muwTxmOREZZxxOJ2kWZa7qSx95kCqZY8PSxHDfw+JJ90DMrA8/wQEEwqM/wdsn+N2N7oNTTDVNqYkMde6pGpFrhJfhvEYOXYOm+RJJGKgO1sxdQLJf2pF8iU6udogWjqHA52MbVL0QKigScE+BY66vQ5SIqyfrZhrWQ4He9J3/LW7dDeAUCNcDMWKOpR0Ra5cMnSQTwP9v/Ge/aezeKWX5dlcEjADtsgKHr6M9ugioFGXehFJ5iIx2i5ppp5tE9NhO7Fb66spJ2Oc4BnQLM4cHzJlyJTMi3JUBS5djrVE2UUklQxnCYgoBUgNwdEpLVkBp9Hi9FvYIzlQ2QxhSUI7yZBuTwhJgOxpOsCo3UQvT7+5G7S8LUfXwGYk+EOzkLEqJ6TapTIRq5gG0azyNy51S+fREXvhQFJsMAaaKIhMiZYzWJFf/bmvY7jPoMd5MVxeO9WH3lTlsi49YjNyL5PED4m2BkrrvuOvzhD3/Aww8/jN5eN4hXd3c3VFXFyMiIp/yePXvQ3d19kHsZxKFIUcAF8f9h/XvCxleg2h5DtY2SAqmS7e5pNGZU9mbt+GY6EQC1cxGl5TwAoM9cyTBRtmFfSFTRWu0NqJYc0iwlTsZ492mIT7sdlek/8PWSYGNvGSlxGfdZUFpfN2/fzkh+Ys5/7n55T90yk0ew3oTNyDh3VNlHkH0eO16JjLc+scGYHC6CVJpVLU0Gx5ef5V4nPuJLmJ2iqvBJnQ6fQTBhT8xB+OeGSA2cNPICvrThW0i0RUWBtSDb34DLuEZ45IyJBrdfCS2L89d8CP0clRUt9aOY8TNHjpTOpx72MDL1meqUGtz0c7pdL2sjXZTQ/XEZsfUCsqWQ2e8Tdo0w6sYh5EP7ULXtqLxqRXujti+OJVkPP8r9MxxWoX6pjtrQbZz94bkV03vc2w0e/BykZQK5AY+gWMo90O7LtyIlaejd8YinTKIas/vGp0NO1OGC4O1jshLzGPTT0l5oCe+ck+KHTsFzSBkZSimuu+463H333XjooYcwc+ZMz/0VK1ZAlmU8+KAbPn3t2rXYtm0bVq5cebC7G8DBTlEQlsE2EEiq0YViHBx3Oap7iV7SzspKQoTZpseX1vpbSOTrtuO+dnRorVw5mPzQeYKA+iLxBhe90+tsICaIs0lQz+nrOXkIkWiYrvELvrrhA9irzQ5cjyNchAwAYtlrc5PDiHW9rhKvkQ4Hv0CQkaGuZC/CRsOPz+/7CgCgZAfDa6RP1Ri/ft4MrPt2IV5m7xj7Zr0noWneMWhVXV0G8c9bliEAEOOElZe0LOIAhsWg/ZRZ6kchE/MwdCwoS/6pECAbUWQkqblzvypZDPCQQlBWvB6RRDZqzEU+zJacAnNHttd+lhkPrLUIzuvGYLW5J+OqPhqJsM2iQq13GeCpg+u27IXsSzwLhHu8+4ddIL46ud9FhpB1hQB7W9qgxAQcsYm1MSHYnbMOVS8Mv712dVnyt26f7H+HhOBxTnHs3+yo5XrcpWsE0UlbDzQOKSNz7bXX4uc//zluv/12ZDIZ9Pf3o7+/H+WyJRLL5XK45pprcMMNN+Dhhx/G6tWr8d73vhcrV67E8cc3IiU4sHBsYA41HLoqKVWoF1Wgpfm6+kgtjifNfDQam65uPSa8hEDmxPdgiWYlFXSvJfH6Epkwgu3tDWAKPFdvpgQzUA+PXRtsx/43wzAypihhKN7pK9e8Pr0eDCm4Ye0bXYZHxj6CQd0iQ6ZtdyJzkrx5+udIZHRHcmP111UxRfSfeP4JIM7EMaGGRWbkkAi2ACCGhO1fjldrfxeVOKaVdyFrWmNg0CncZ/ygACox/mYkGBymrYnPxqpG02L9NA+SLwjgzHH38Ka3+Z5n+pE2Ezh1xKJ51NDw2JH/DlOw5t/K6RuR1dgUGuPoVP4JqI6ikA5TaVLs07x2C7lC/fgl7NDs6ukBADwz71Y82iHhY0cloEqy0wkAgLHH/a6tY8EjAQAkjCEs2bfZvZrh9NkMfqeZgVARLivo9LMSS+LW487BrcedA5Aot2MebPVjg4/QCGa8s/AmJOwYUk7f9IgM9fyeBBqs/alk3up5s72t7VAUAtFUvSp323PQoO53mRVnPYDrLGymNyYTSkAS5LBeHhQcUkbme9/7HkZHR3Haaaehp6en9t8vf/nLWplvfvObuOCCC3DZZZfhlFNOQXd3N+66665D2GsX3/3udw9qe2ESGQczFr4O4xQNtBYq3zsb42WvKJC30e5JNZYtuREEUrd4PJO8/1Jq1tbBQKYt8IyQZFxu/e0E/qpDICLitjhj0ggTkmUCp6ltfFVnqzaCKRrLUHDarmcnZKObGDCUMM8lQK0Zdb7QUH1On4XBrXjpjVPrlhc46qWwU2WSuBurqVnvl5J4nh4ExdQ2GBybEQC4CPfj6vzdyM7ZhLuXn9Iwczh172607LVUFFQnqPgkMr7ph0bZ86hycTKGBNEhh8TvAQA9IkYIjfueY5paWprrudXZtRmqHcejfWgZ/m23680YE96AImyAWdyNaiKEkaFAlXrVTlMH83a71hirdSRzry1eBAAoJgbx8aMSWJMLMovmTpc5mrvLfaW+kdXosu2WRD2NIid4pb+/fhxhBG26EpVgH4rxJIrxZAPhmoKNhCthOE8bIZIbezxnFXyLpcGKTQIYXKbHZihmHQNB6vYyMi1tUGJhz1Dk5a0AgKriDS77emcC/74oDp9jI0qdoyG9s9qwGJlDJ5E5pF5L9TZmAIjH4/jOd76D73znOwehR83hoosuOqjthaqW7PmTbY1WYVBBBKgATUoDPsNOp+bRWpZb/qS8tf33QLHxkPosqmalVq1GRNuS3r7AWNyPpdxN0IABgxoQ5URUtywwqqUwJCoiRhUeY9H4aYInkQnD/7zxn/hZXMcu2zbiyE0V+AMSKr0FAHH09vYFK2CwsFk6UYdyU/v0rGgEw6Nd6GmNlihIMABI0ImbbSVs1HabO2pvKWfCbWNMQUbJFyGUBYGVvDTesw8FkkRHyT/HrXdsn/97z9Wf/vsn3B8UMEI2GQP11QbFOE9SERxbQoB3dXwYAhmDThVsrKzEI2Mf8ZSRbDWFYT9fFaqImaxnDTOimttGSQjapFTkMcTLwVhWJnUPI2bCS+KdsAcZM/jlRB9XulkYwGJ0Qwu6NgIAhtramF9MG1Fm6ZyzBgGxGJmo/cA33DlxMwiHz5qzIwu9HXUPB40sJTLBc369nFE1FbTHZMd6plUd4dYYhbw+DhVeqXZ/azvkUjXUsq0jvh4j2nSM5Fdjtx3OgILgx8dah5shLVmrryIT7GofAXZZ5Qjj5q3basCyUYQvk+1Bxd+Ese/fK55/vrEkfwcaFEAyOYxYshy47kAxFAznF3DXRKFrVe1vnjpigIwAAF6PbcLtHfz8H40QBp1JaaAm3cVjPe/2djTtlQqV9WgXPBGApBMs3OiqIcI2cdnwWyI4EphmYNvIMMa+guaqTQRGxHzG8DPoZuJC5IsFbmsEwLITToxsldg5sxrtn6dyXqmafYr1T9Gz2QcfkmCCmuN4uXus7kYxaLpeNJIvCCFr27lt2lmoD1rrj2eTZCi3mPAaYEg+VYSu8c9sBicRJWEMHf+65KhaegEgOK1En9u8IuyDRFTEhQIUEpQY+BOoVkSGQaEEWeaAwWriFMYQ28mAXRb4XmZO/ilCADXhMyC2x+xNxVKgf4pvjMa13bivdD/ujPFjdrndjtRZM/1ijw3ecSvJCd4jzDXvVjUz/kCgSEeZkeTye+pKXBs4t+TokaHd2R8IeDEBGJLiGOPbZ4diVmUHAEBgOKOdnV1IJHnbu78yipIdzLIgugfIdR3uvNEFHSrjkVVVXenMb1ofBgCMa3XsAA8wDjMyk0BHR9Bo9EAiVIJFgBVH/yFwWWBcJJN6EqYocxcllcfhLNe0EC4W550KGwGvTSMV7nU2lmFd5imKDiMj8sXkeYli1i7WOyFcDFuPgBFE29oA7h4eF3VI9gInjAdYUncp0ZiYQoz1nhFHuSc9kxBctq+OTUsdRqZ52ZIDCpMSlBqIZGuovsR9YUwS87eoZkJ1UFUlH9pWWbYlFcSsZdblqbcCDXKwXXbbua/zGIxIFrPcZdZ399ZFMVD/lIr1vMzNHRQO14bDPpV7IrNpeLP0Gve5bj343iXwJV0J0c0qXknzVTYUxBddmwaSygqGgX6jHyVS5a6JzKhzwGh8q3dKGj5xiiZEM9F+xrnIMcDtqExrqi+Nokkno4YhUsHDzGyPdSM38A08Pd/7rRt1yehV3eSj/a2dUGx1alvpDaseAQAo0qbLsLZL7rpkpZMDabcMoaXavN1nM00OyrU9geL/WRuZv3fEYhNTsUwE5aFB/PZbn+ffDDkRmUxkRndzDU44g7FdKMrNu8jOK7QhrzdpW5N0gpoFb416GBmCks3IkITr4fGXcVetN6wTGB53wfAF1T5qRSaeVbOZsDog1E7KNHCaDwMhQJrjUhwzYqgQGXvKeeyIe0X/XYXl3LoMQfQYIrJvsKbjKWhCFWa3u0EZ2stuP0L6V9ew0ZY0lJMiUkRDySdd4B+Mg94XPMhxd4PP7l6JznWXB+uiFL07H+U+X5ayeOqIo+1fJvNMI617C+WrGrRCAiU7suqdfWegINrrQfKWlfawFlcEIAQGs2kSUHQXp+D0N65vuh8AIOhexsLx6OlIbAURgBhPXwJgdunMwLViSHA2ibjSsIBExn7kpeKFqNIUojZ+/nHAvVpJxKFJUiDruKyE5PgCsNCW+ghN5BcDgA2610ZujMPIUE9sq3p2ctY/VanxLbBMpjVUru4c5enXAChUg1J9I1Bc5TCxACL5ht2dXRixVcdtFevwYRJSY0hrknCmC/6YShc9Y0kBRUPy9HT1bFJLsJlh6e4BSOnRKA4zMpPAwcx+/bNvvxtTjw1LY8+f0fGYKzoWIYJQBIgOAJiMRKY5q34Lx430ImV49aOjdc4RJO5jZJhXGGNVS9RkGJmW2uVd6MCaO2di46PdWFcVUI4ZzCPhBrELtmTQWZiGuXG+bQSflfCWYNUbGX8SQACbspsgUQPdiWFsj3fXSi/GHCgmn+GLsit4fNav8dNjPg0kBmryaLXwDMwIyZEZkeF2cFo3CrOXumXtfDRljt1EsKONRTEmvjgULdvO5pbTRf482dTRCl1y23IkMt48yY2fAI2CgqdXtOCvx7ZgMxNvg8peW4XYa0GSyEZjJhRYPHjkhPpgVRbyXUSKrDLWlKdboYFM0LpgwttHa/6MGZ1e92sbmb6nAduzxe9t6IemKLjrHy4DmECL11S+j54eN2gnGy9HT7nuwdb0aNzU+kl9BsB4mFU486Z+rKPg6EaNNsG4p28aCXc48BSs2wuL0dsrDfML+DoVxsfUijuqYdFLg69aeJyvW6xRDm/svS/QPWKNd9xI4F0DvbUaCglg/RRbgs/UadRJ1XYgcZiRmQROO+20g9bWvOV7QEMCioUdPqjh3ijYbrsmJSglvG7C2RFXIuNuFNaz/6tfGCBojaQ0G61DkKW4lygQ0Fo1J5SZ/lXHaoxMfMnbmZclqAzFsW9DznqaGQNqhtvUyIaAMze4aSBqtdW629zGlJXt06fdrw5sR1Eu1ojqXsWVIuV0foj24mOZus0aviSKcjJapaEq3QijrGoqASq7agSqWt+/EdVSEOHyoEYw1Nacyy8BxZA+vfZbLfJVQ6WYV/IhKAZMkaASFyEyCSZNTcK6dSeEt02Ih5HJVQsYk1kPjsbHTIyNQe/mB82jCWBF18ue47zaEk2ei0xyWB4I0VGWytj3MZZuRH+XqSt/5D7f5FqQTQ1nxPy5qtzxMdkcYtxhC2/PgABiuO/BTlVHyjBMk7WDWKM9JxGSm4T8XwClWFa1cxaRfJ3aGJstPQl56PSQRm3jp4CNDOFd9lcdQNx26d8Um+65vjXhqNu90mqDEmwonAHAie5ef7Smqs46tcoOOIJZtrOlwxKZv0vceuutB60tUU/DCBEl+68W9QwewDkY3GFx0UVhHH/t+iss0kQwnrFEpFSwFsDxf1aZCemt7evmZZGpDACgynEN9JgRcrI5d+eWcfsOAMcXmJgY5VEUdWvjELNTILY6sS84lnLuU4E63duNB0YLQ432JVqR80lk/DYcrIQrp/NDqqsb4g21n652QbG9VKRYnW+i1I+xoo9vQ2LbOtDKCACCEmvH4hvC7xvNeehpRb49FgsKQBdDTrm+DcaRHgiUIkGcwFwmVGVv4FEA2Nvq1mtqAvQ91iZaQQxyhdZUD3v3HIG9e46I7ihxv05bdRTjTMJAjYYzYv49svfMr0Ctc2xVlHLNbkbtiSbP1Woq8j4AlMUK1Hm8ucJ3R2fR6Iqg3L+CTxPNfXdNCE/HENoOYesP9niXlgOtBeSLnn3sXVXkj7OAUUzXdcxXNbtNVwK2ZY/Xw3BsrAMqc5rq2n02JJ/LvAvK/L8x8BXnPrVoQ/ZaFHS0l/lNQASj4f44ZfpzXkcBAEh3NBc4cH/iMCMzCTiJHg801q1bh2v/5WV8/Ibd3Pt+ffPa8gL8hHwQ1Dbq2ph4BQU7/gjL8zuMTBhMmkTarL8hbU4HS/CmtOdkzUhWvP/6nikNYlxnRLA+pkjkqMqkxEmhfSWcxHvNotZirhc5OdoAmjAkPRMI4GWDNmb7sXzXFcyvoLyZHZlCLMqV27YL0jVIxTHI1BqTcVuCl9CDm/OvjVPrdxDAjtie0HvE8M63oUQPRloW8wtT76C4VgUUEvvJQ6KVVZgIs+OqDHV7FpsxE+/HrXgu49opRQUxY9sFAJ0qUIQOdJUmlh6FgCLhc+X2p4BKZULUDdz66pPvMiffDsDZtELyBIVhd4ady43a2bhtqCKHCauzBijKqMgjeLHtRS4jM0MnMLP5RqryrLeyHRqBZ9Dcx8SAooTg9blp7G6N4cWNSzzlNm862vNbMMPj4hDCpxkUBJQo6B6sE1MnBEka/Na6IDJemta/TlA8AMC+Y5r+9gCwNx+UfGV7Jk9bJ4rDjMwk8KUvfemAt0Epxfnnn49XN4QTOEn3fsa0OAZZ12DErQUh8aKX+ttxJjtDH/qrP8LvkUOMyoF79ZBn/jb1iFD5DQSDGxRHYdYMUb2nmbgdodKpZTwpQBCDBqmi4TBvlkpFD0330AjsZ3NT6zMyTDsPtK30PN4sBBpOKEQAnbJQq36vHB2Txt8PQTCg2UyhRIMMboxoDZ0jTXuzMji5YUTdewofTE0JrS2hVSHaBJcSr0TG2yDH5qtKMK1/V+33wDIRAMFtIx+E6XO3lmU/8Q9/v1Vj78eGmR/AoqGlgXtjEZIZBwQU5UrZd829BwBHLHymbj3NoCgVvUssTA0dxkkHyhOAUFSZCNM1lQgFSiVvkt6w0RSZUAxTfPPakZYp8K4tCmD7lAexMbsRJoLZuuewTK39Z9J03YJ5S56CYDgX/u0KjAEsoRS7u+NYMyPLtS9im67G6kd59jNOlACEqmgpRCeYDUPSCDIye9rafWc/ClNgGJkQ4/IwxG1J2p4856YwQcK2H3CYkZkEPv3pTx/wNtauXVvXqFgxvNQmLw3jsucftQLgoSn+gyENBCYsopTxBzryzVeLBnov5j2t1p/gLFGiAPT2mdb1RAsKCb2mXmoWc7el8Q8PTYXsMDLEZu4c6l7L60Jr/6Z91nVCWITTXF8kI+PsDU7NWxMR6p6Ij+TcGpbDiWOL5N2t9pLwrO+8valSSSH0O1GgjBh0jpwttNvtwXExtTxbJRS97GlTMFwCnq2UQLNDtYi8rEQmVHpnX9/x+zYkq1b7vScNQW8FqvEUYuMcdUdY/5067XlCFeCNcnjMm520PfSe2xhFPO73dGzermDk8X9vqBwBUJJCpIB+WQnnVN4hBIPtAQChBHKVtUNzLfYNn9StolhjXorLns2/u/Bi7e/zaB5zs0GPoFhEuAfeTC3KQeYqY3pVj0FvJortCzuxtS2LnS1Bm6MiwwUkzXWee2vKp4X2T5eat3wt+rqWjXVAjK3A0V0xnmFiDc5jGxIzA/d2tvu/IQWbhL7U+ajPgD4aKck6JO7NE3gsHQ6deQyAw4zMpHDTTTcd8DY+/9kr6pbxS8dbpEHkPQkBfbrUMBUHg7GoKI0k8icAgKeQ4kW8DGNxyLJ3Qp59NgaPugClhImCNhLenxBc/FgPTni1DekKG9DMFyvD9iBgha+Ri4Iw75vtRdxnhOswZO7G670bfvAldYnBPk+GY690Q2U8jiQksU2XueJ3Gvor4q2VFLahGxpHUuN/HUfTl2HcmvXBdTCL+zyMDADEmBOkZChoG3Dzp2XK1kawfUoc1YRZ2wRDiS7TEYMJU08ECjFtQk0kkakE5z3Pi49Fx4h9oicEMifAXa3/3H55R4fARLUYHqcp+mkLxvBmgInlsS+zLlDG+e4aSaMayNDOh2mfzCljJ0UjNrjuHfz38I/mpnYTnz7hA7ht7jm1a6NEh2xWPWVzSpCJaG1AqsFilGG0RWoiY44GGBk/KIB0bxyv9XagrPjnt9fSJ0G3eO4+PPoRVGw6KTJ0gPfd9nLSBQRsG20ma0eHNbZJOQ85eSra4iIb5DmUaO5IBJnpXR1eRkaXepEpu6qrPdmn/I8AAObtVVG1h2O064XaddE2RxhOE3xmZwJlRiJaP6LxgcNhRmYSuPLKK+sXmiROOjXc5sDBnhbvyUX2ba7NhGxwivI2rVoZzkLyRyyNiilX0jmnFV95KZZFfPFboWdaUYwbKOgjdrHwrdjTR5CQm/ZCtKUuxHfUCT/vc5Cb2miapElh5p4eyBrFVJHdlIJidwcSSeOJQdc7hpV2mbEEUrA8qaqxKGNR5sUkS4qQqQwguDnzB6CTKWaO7kDpsa9A1LyblWhqtWb8ovqYoYOCYFtfEttm6S5jSJm+NTj4d+CduPvYU7Ghszdwz/CfAnxzZsGWjTZjQJAVw9fiNBK9YQJWr/127wnVkpyZDWb/Lj3xX57f95X3YV3uOW5ZkVJUBT4j42dynQB1Wsk1kt5ibA7tR27YVU+wTHs6443wWjCn4IXOubhr1unY2G21aYYsTf/XzEojuAJ349jko3XLJtQKCsU5td/pShlna39BlmFkuAbNhKDzjC5kp49ja3e08fQe6TLPbxMydPtgJDMepRp1xtxt8YEuO2aTGE6Pa5GtqPM0s24bmB68encyjAwBUEmfBmLPtaQwhHaFn7V66Z4SYvY2oib4DGWFEowZh455YXGYkZkEHnnkkUPdBQCAqniZiGd38T1M/JuOs1BMQQoa0TbVA4qS4XV5XocgAU3JlliywGNkIlCKGwGJjF9E3OhyopzM2+zzjdSjO5tO1toYTylsQVuW7zGwXSjgd5loN9l6OH79Yvz4vwx4a9kSysQVze32+NhGvWxJZtwExh1WpiJknU8O4kMqRArki1713ljChCx5DRPFkA2ZVkYgaRGeKjYVzowsAAXBg/NXeG8zkX2bcgsmwHbMwPMz52B3PnhiDUhkOGpSwFKnpITwMOwxouFR/bza79/GevFQIu+vBDD5Uo7BfdND6/ZA80pCqlTAquooxjIc9TMhAduXsLFzJTLWyk8MzUe17KrBaIw52FATQjU43wWOvYUI1z7usQXNrQMCYC62ICVY9CLskDFz325c9eRfcDTDaGYrRQAUWYPPYHryEiltmHXeDoyFZgoHtksSRqWTav2gvoB8bL/SgaCRFD8+QsFX58fwruPD14CfuXR+D7YoDdEl3pfdPKUvUrO/MMm+M8GKDRV89M8juGR8DXu5IRxKluYwIzMJHHFEHbfN/YAG8mqiO+ESN+UrKawbOaqpNlYvu95tr6Ya4YlC+QoTnnv2X+lIaHsFo5HowW6dpZiGguO5xFFrLdqUxXGvtQbue6Sx9kBWpE77nqvX5//rwh9HpyNmM2LxHKiSwhRtHDvT1mlwHC2esncqW3kv50G9byzrRu10BAB65dGAMIL9Wab9vnv8zdM03e9wVfU0LB6fwS0nqCYWV0RPKxQEFQ7dr9gJgnhELeNzF/bYVtkMRbzSgWFyGtZ3ucbKFMDLWGbXS0EY536P512YIWvEtSBzz3+AUoJt6orA9QWJ+2t/P2GcUfv7G10Uq5I8O6XGmbBmNobsuEuLJH2D3VKc01xNBGb/69iOeed/+4a3wGCdBFgGWKt46MOwYM35MuNS7Y6vW0dNtRj6Yn6my/k3SHfYkr0jA/AjWy6iQDJe1RLzDmwXdhr5WsDFMGyR3XlWFeIwEl6mrKpZTN9ivQ8SCTIeOiH45XQFW9MhqRgo51PZ32agTQHHdr42d5/MHem5PnXQHY/VC5fiqZlLPU+5f1GU1ZzHgP781SXkx0ys2e66jl++7021v8e1Ia5Envhe52DjMCMzCVSrjemfJ4p7770X//SPuyLLtOTiOGGKe1IkRQItPugpE1wgviu2UfDJmR9gOY1K/kX4fxvBVUYiPKVKDCOj27EPgiZ4LopxrRYUz71vE2BKccyaFmRLHI8e9rTtxB4RomVNQeLpRVzQmZh8BGbG6x1UhPc0pnmYiKiVHr7BuRFuref1UjAGiGYbOlZM99w6BItxCMvwXFW9Y3qCekxoH9oNp+2HQ8uMCyWX2eW9qhlU45m26sOQGfsTn3TwNSzF/cQipgKlEOyIqyAUpaQrOhf/1HzKkICNDxgmntn4dAS5tg92vQ1n5L5b+z1AXbds/tds1qsjemfonecyzWOp+gyz1YPGdxvNMGp98LD9lHrG5rkYb94EZZz6WNgBy2cVz5MkhtQehpd6Z2OP0I1Wg2Xq+fW9qE3Fh3FLw+0YnKjZjmpQhgg25EIU/GTY/21Uw6VpUe9LBqzYWm3jFq1pLYxjxetuCpPV0xb5GnJru3fdGagH51NXiIGHdt8eVbJuXQcKhxmZSWBgIHgS2F/YunUrzjvvvMgyskzw02+8Gcce6xVXElCASWI4mrEXXp3VtTTlzWxtNkp4OfM3OvGiE4CJuinhPeWp56RsigaKhpc5C0N4q77TXoREo5kWzGzQ7sLBPTtORCv1boAEzW0m3hb9UiQXpUSQqV4tWuoKlbMJe+rhaVd8aDEE6IIIag7bjwRL+RMBBlpTgyrFYqb+BrwZM2t/E1AIxK3HtBlTvZIBedUJE+D2jdbT4ftUSwIMz3j888du5Jaz+uJl4KtIYFj7EF7WrsAIJxcQAEgCXxrZ2/dq8GKU3Qyl6Jjmpru4I+VmsHfeXvUEqjQ9d8PmIGHyANVT4U3dZKmzFqq8RJf1aIeXGaKUglS984M/a4P1+nMEDSUzWD1jHvYK3chRA/PWW5u6QCnHawl4WJ2DAskGavZIdH19SMUdJwHvnVFiXS8pXprM9Uz2SWHCbRmj57BiWwL3DTo0n2LWTn4EaW9VtO43BoCkPY9eU8ZQCQR0ZCQ8YkSYjQOMw4zMJHDUUc2pcJpBI8H2NI1DjqjtoMqcfuOGZccwkqxvOFyrppnNto5uxL9ATcEyKLxPfgmPr1zh1sFU49jESDoBMQ3IijeOTNOo9dH6N/ztgvVLCF+gRpYfr8UgAvor7egymA2tyUzJYSAi5byAT0VCSc1dOmzEXDVisI4XfUbQLQaBKkcHvKp3DqWqJTVit3ilUid/DYBuuKfqQTkPk/HYildGAuUFxe2HWhC5m1fO9mDas2+29Yyg48hlf4bke+/tXZbLPG89OFGcVxlLcL36YQBA0bgAbxiX8Z8hFO15flDLFvv61vVLoay1pSAhjIxgAqf9dRBTzNW1Fl4XWUmq9Z1KUrAPUau66Em90ACG+7Hw2acg2jGeZujhxsEAAuEIWKwfex6k7EjaGmibqaQqeVmePdlWUCLgfPW3kBFH62jQWPXk16xvl1TZNRnsWYbmAQCzVaPW/zRKWDKdHxJjzPZsU5k8YYZQhUzrj22NhfRp0kwtGcLl8FX9AMH0PTxJPrHiaRX6fE9FfBgGHUa0xNNkIl4fbBxmZCaB3/3udwes7l/84hcNlQvjIUxGPL8jZblrKnoCPCrRKGtQMDT0Fnoj1UAx0WKaDKZ9UfaeTrbplspju8iXslCRor+8ianfREym0FFBJb/Rvlaf2ulSUOWVFfxRWR3GJkKMzZ7wfZuimZsOdkxzZB9bLRaWXR29qIdJ8AhAacQ7Uft5y+ZCTgUlHwJzKqUgyOj1DSv5FgMW/COXoiQQTC7a3TI4no5E5nzIoAAUAZDsIHkpycAHu96OKpOJ3RkPCa4UY1OyD2XjZLcPNnMohNhdpXsaU/9mMvuQzTrfjvneIHjpuMVgx+hX8+/An5Z9CoRQVKiMd2s34m7zZNQDARALyQxdrSZhmgL6t89DfK2tBg0ZXskwIZpA73P/UrtWJu6G7DB6IjcJaNjmR/HSFFZt6L1PzSC7O5aMYXtaqqkMCVeNyn8Jf8/WjQU9r/zdZ/MiqaYRuWZ7h4fQsdaETFxjdLb0lCgNuo0EqeLIqsVE9zDqcwXhNn4JWwLLBiEty9txXr+Vub592KV5QQab/1saF+oeFgHgkcVuyIype/k5yM56JQlsO9fXilW3XI0OxNel11Hdmocj+/5d4iMf+cih7gLu/NMa7wUKj6fCTv0ZaHaE1FlDXqMwPyHYbLr2Bv6TKQCUTQPHDRwHsYFpUxLcSS8yG2BBG4EBYGS3l3CxfRmZRtEedyUdpkgRkw3s61iFZpAuBXXZih33IYyda1bLa+Rn2PVaG+bx4n12PUHCI+q7JyxQkmecivw+K4O0nOJIdnw2nEqd0xMACHp0VGJ/X/0pLfxj1WJkkSuGt+tIZGQASQIohLinTkIhERWbuh+CpkTvMia1bEO0Xc/XnncsOQyVwKxa81M/J4ZYbvJSsMGuFmysHFf7vS85AE0qhJaXkmGSCQolJIBiNjfgFPGUZ/GC+CTnahCG3UR6fDi8DKTAjK9IhdDazQgDfTfZofWs8Xq0GzMvdk9WdiVzoh0DS/NFbY5JjW9XyfIoRkb6IJTzDT+TqjQ/VwTf91ypW0ayIhuOggDv2PEnfO5X/43//tq/udcDNjJ+WFd2rO+HxomG4T/4lBX3O/Tt4Uv+jtrCehn6jaujqV+sji9rYnRe5P0DicOMzCTw9a9//YDVfdJJ4fmCWPz8rtcwplqc8L5dU0Aqlm7bmZJTB60T4JGbJEimw3HzJ+wYXAKUIUF7hkYYGKfmguAuGDe9ACDYTI368t2hdehxV7JTjOvQRCAh6BhjDPdEm9HyR6h3fraOKYhrzMIjMrdcOHhmoEFYEhkXEnGMly0bAJbYaHGf0V3DIIgveyf709sjjpqps9zJu1HDZuU1CCGuwEFYLZlSvsHyfJijbiC3Fl+iUWcT1KQSyik+EQ70qhoU129f5W6INONEBfa29Q/99wYrC4lUSAlABQGPjrqHFip5pV8B2HYwXWqr9zqh3NA3OXMfEolxCILXjsX//XbHOzltuv1ul29EQljlGeeUyHf3rZpeiR3xbVL+4aDhkw1usEKrUKxaiWS2eGOWkd2xkoqWVE41vS1mE3w3ZH6of/vvSniEaz+m7fYav4e6qjvGyHIRxBezK11LVeHtqUhNvPnlR9A9FB7kLyChEa32f3jK676C/OdjmnujdWykNi4s31j1SKmbs9bbTKJVh+JhiczfJz772c8esLoXLFjQcFknK/auTZYLJgWpbVKSbm34CuewwTrwHJu+HUcKm4KFGGQpnyjWWwyUOZ0kpQwSpb0ADd9Ec9usGgvtL4EsfgCQKFK0iv4hV03TIVgn2IpIYDCWdImKVa/IRJB6U88aEMJfZEEBeDMiEwrEcjaRD4qFCSiGZYuQKqQFpeybQ6tpDlKAyAqeiKx2qRCpjIoy+pUtKMeSTlcb6hIVFIA06BlUZ1LkRQE6NWstRSupGiO3O1vSKO+rn6fmkoEHA9dq84D6rtqbS0pwVQImJ0qr1U8vzhs9oW5fAEDpctVp7HcVfGkDah53TPNpuAeOuPgK2pSvgBquTdd8xctMOfWLxC9hsZMLMnVThkEwhfCtwmW7HJsrRg0VNrfZdgAojARXy7QECwFoTSlNrBWb+S6nfWyf9WvM5jcGMrHAM2G1bRUtmmN5AVLkZv41onyECp+jdaP2M6IBtIzbczjGN553Vcve/rYWrOtVyWL4OlWvtIhQYDjBqvOtDkwvhDut6Iw33P/Jt9X+fvOfj8RxKd3ThYMRHDQMhxmZSeCLX/zioe4CgOgJVOPGOWuUPckck76zbjtbxPrBpRzIEclBMoUdofcAQClZbMDOo74JYdrL+I/ZFeS1oodA7jU7uc9KnGYX5pmF6lFFAM7AVO1M4cR3Nwz+bcA/BFpNnWbdycnzAaKgFLIJRsL3iFEJukzKanADz5T5Y7QFz9g9i1j+kyVKdTacI2QBZK970mx0f/rBy19BmE3PUJrjvWejs+wS8EKqXm52LwRRRJu8lSkZzVqRUPcT1vam/huLIUn42KsdxJ3bW6Wg/mE+XMmoTMoMs+Grk/gjvHrfQdAi1C6CV7UEuDQhrbueVaGkyCcZNOP+A1NznD6hLm3T/cGOfJ9mD5MwMlqKBLwkbrOrsJkkrX6i0EAldW6f+mIHEmpz4UgdmPZGMJq0xm9OLU2N+9LjMXceF81WUPAlT7l8EWM5E5WWFwAAT6YHMUZchntdepHFyDggjc3pA4XDjMwk8P73v/+A1U0biYRnQ7AJifNEvBIkpLUrbLUqzxvHPV85z9weexw/iz2CIuEbTiaMYF8XSUH1gFMqWQreKyW9xEsWvESiPNO7TF7RjrR7GY2diR5f63wUzMYkDU5744ETqpdMm75YKE7rssGW3T8gAGQ1KHHitmKa0EO+Yw10YqY8RaHc0Jvpe19DpyiglBRRyFrG285zQsTJf9nYGzh73/O+qxGsZ00FR7B80LUlG8xzpHMhHacABELRKm3jlqUgIGIBcusqEN+4bon5PEcaGJzozSAovVqU2IgP4DacUt2DTYoMddzdBLN9Zcx0jFQJRU50153snwNERFxSoaT5p/MYm7WbAALjFelM9ZoEiXkF0U51wpaXhQpKIhM3iHpPH2qrE7QyHEdo4TY7qao7D6sV5luzAfEc1VNEG2Fw7AcNjtqKL9nztkM51wDr0Dltj0sHne62FxJcW1//+KxaZNHMkaSlNpxfGoMfBuvyHmHzIhAjMrXNCx1z0S17GVBCQly+DwIOMzKTwD333DOp5w1Nw7bVfAPWRhmZ2TNa4F8SFbCL1/6Hsj/rU9QR6urQKSi0iBghMwpBNdGCba57ot+ILFmyJDuEOYlVEl7GJSZ6f4/3SpBtGwJpdJqXUYgYqoemnMEt5JdiZZlMu17LFi+cWkZDNlz/c2yrimZi9u4Io8kw0Zo/zLy0NlBEU9h6bcZWCJ6iRbWOgW+gFh8i5uW3elzRM43y9Crug1kdw7YZLtEWnNZ8tjMtIyqUinvilzyEOLhBSHFmntrTa0F5vefUqZWDTKtHpcOYh1FC0DN1fW1GrIuNwD8yib6fIN71J0itXlXDqOh1Rw2zuRDsPZ1S4vGQCyL4RZZpT2EK9uJTxddRIgTFve67EYmii0mUqdE4nBGLC+OeGikELGwPD74Z2JiZULOGrdYMi5EDADkmhpAhaKGbpJrv8Oq8vb2o9TfGzEP/uLaUxuG8p85h8K1nLFAAyVIBb/sdPyAeauUOhLShsQNNWzlet8xflicxnrS+w7EbLaZ9VtkZc3Yt1q8LcL+3wfbR012CpD9Nmdh8xu/9hcOMzCSwYkUwZHmj2PraM7jxhxfhha0fx+e/8A+B+40wMqIIXH7xQvfkSSg+8T4d6xPBjS4Kczb+V+Daj403BQs2AnsFdO3hx6zRTROCWd87QBa9YnIhV0WcpzdioEom1s1wRclPds9wj4t1prrjOioSE3qISJ/FmGjXRwiqogIN9QzdCFauGZugLIbALA/XfkmJ++BnzIa6LObQs7GTOsa8k1VqU+oh8FHEXs1M8Ww45ugOSDSoDjNN06PynLe+iOkbWcYj5DvaO6OUDEoKAGDuqCtSHyTRsWtST3rbyOW2BMp4zrWJnVbPlEHfvSi2NohCIe/5Xar6VSy2kSnXrdq6qzDiflMlyJX4xqW7VJ/hORGgGUyWeA4TDLi2H7pSDVyrQUCAUSGgEBRbNR1IZEmtrN6c1sJ/hSNT9UkGObQ0zfDzJz9zP6bvijZkJaCYCp9Lc12m0/5e1ERKL1uMt8ysl4DUhr8eBd9g7n3Jb/dEkK64a33WgEV755a9nnWiKWLB3kW+ZymjBncxrlmOH+xKoDX7OAInWCP7CqZ0Bbf/BwOHGZlJYE/IZt0Ifnnf53Hu/HVI54dw6okvYPeufuiqhhceexKGbtRlZGbNasF3vzcVxy2bUrs2ltQxngRK4iOo2Ikkd7QHxdGaHdfF2VhyIyrKvk3lKGQQhQJTnu2pEyTMI363/x7XhhrePCtt6zy/4+kipuRKnvqsH+7yf3LhKHb0uAzFtprRoEsknLIicwcAZmKX53c9vKEo2F7aA0IIVs1xPcx4hoWNwIwYF/bOnvm3gsQf89xvSb8InZHIbKic2HC7VgP7T9XlyQrBXB9kUgkAgLrpISTGXWmB7rifcYbfMVwPSDTcvcJ90P5n1f/X3pvH6VHU+ePv6u7nnGfuycxkck7uhByEK4YgoEQQEEH9oSKX4HogqBF3QdcVdhXlcJcVEY/lK6K7KOqKiCyCCJiAQMh9k2uSTI6ZJHM+z8w8V3fX74/up7u6u7qf55nJ5MB6v17JPN1dXVX96eqqT33O088Bqu3prXHIXpgv6H8t8BmUbruqYu8wiFn03ElK3IOb3/5QxsnIFBuZ03KyowE5qiOSYtW4dg1Z6v6+CYbyNsOoy9lAxnTPeJaBLdRg0IKO4d8XaX7WLOhkkigF1MOcyMbeboO9k7jeeQFbWlqZc0WoRoCqgT6zZICdFCguxV+D6ypU6VLNRtQ8JFD0XAp0POiVnLI9TcaZrOKmQ4RHBeV21QTQkGRyWpnf87T0AD7+gh3rrCpb7bhnSuRNxEODnu+qRiaAUvBEK5gtUEsV1TRQizpTNXl+wo4mrIcne/p1vCAYmREgx7UxKQ0V4c34h3/Yjw9cvgf/8vVOPPyjj+En912Cg52fwkPfuKro/R+4YjqmTjUmnsKwVhV7QKqm697WSc77DDdLc3AyW9Y8nMapC8EJXGDilbGvYEctM/Ew30Hho1Ca7cBzIdOVulAsG61FOOcUu5/7N6dYXuJkSg45XAe9H7MU4AnlKAcg4lJhaJYLqReU2tb5hRgYBMB1bxhea/vqJ7Klrf9JuJI1f/TvULG5lnmudM1Oj/pBk3KOOtJ6DSQtWEJ0sHmi5UbK71Jxg1XvFWpEDoX3adOxWsex1rkRLA+QNSdnSXbe6VXHSMw1Z0nAfj/Pvvu9zBWKHJXxueVP42fL70JjrhduZDK2KlWr81wOQBADWp5ExrSY9K2bcBYwFtNcasNwpQai2wtNOajongsQglzDWF5XsHWWPfdR17ejj/W2ZfCc9ibHMDJ1sv1+YPnswQASHNUrsTsax+tT53Lr827pDHVvddI7Hjx9KKmn9jPxYrL0LwGCQrHoIEgznkr5PD94ohsUGg7V2fN1Z7XxrRFK8dmnf4XqdMpzz4LaJ/H+mgdw3gSv59XMqGTRnEduhcqYKBs0Cw0y+aBOoNuSYGRGgOFmv06lUvjKVw5h7548MhmKN98cwq/+5w3MXLIXsfos5p63q2QbGXboRHL+r9O2kbHvkNj4LubnuZ3yQ+4XMKgMoifaA6Lw9aGFTNFybY1vXwnVIev2RPjBp/+ACfsPOBkiTnj2obi99+PBs6MilJEQFK5piDqqNgocooa6QeW0S5mIpRojcujJ9QMAZN1P5cWyCsVz1zjbtFGV9BrtsViIszEx6zQ8lHS+LjxbbzCY+VA5rqzAUVk3x6S9Y1RciUElTQLxUXtQEOgh0+6J8/p0KuF7uNmrBaDWf2VBJza9NRBsIoxEiNN+Ol2N0B4C5AC12m6vkJbBnR3abwSyKCXuUkBlRWr3QiJ55zfkUe8EdYEiYsaRivbMAKEyQowXlB5ipDWEQuPscyxGRbJ7SykwLSehTvffGJXzfgsUdUr+jPt1EAwqIWiS7POs3rPV6RxqkyWE+fWgvDEZgldV59wsOMSLAIBwmB9Y0P2NbJtWgZUz7O99d1OL4/qH13vDDQyqDSCEYnrdLs+1JsXdL3Z7ZmCB6czRu8uedwg5ceyEYGRGgOXLlw/rvmeffRbZrHM07t2bxzPPGAuWHMsVZWSSSa/nCW/HZuXT4X7ZhWv2xQN0TGC7PBxhdLH27ozfFwJgbMcbxSs1Fw6qhrDP9DwYTATbyLhnbmdKNOPXQKjPeYuZR6nOzKhsuyTzZSmai9FRdRV1g/ZE6JZklDrdBSXZ7A+73Yqd9YYRxgV9zskr4g7GZkIP2xOeO+lheFaNbx/+FM9BTXsN0yVWQuLR+TtPqDH/4GSSpKMP1dB1Csltn8HsDinPAMPZKACn1xgFwSGlwTrujvFjzTR8VzHGrfkg6UgUg/EiUWq5SybBxM4YlqQWuk5T6HrwlBvM7BLX33LBq9uoK6QDNVb6Du92nMpeRqR2IG3WakrTzPrDzylWS5V6CB8aiuCqXAN3TgiEq3g/GcIuyVtHMXVuUKsDEVui4E1pUj4DzUMYObQSryE1j2dv6jW+z/amAcTixuYqaLgr0fOws1WHyjAfk00bmcJ8WJnxbjpTeVtizo65znFDlmSllKdnpcN5tdQAm8cegpEZAa677rph3efntv3w97vx3P8l0d6eQ6ovWNw5pbWwUPGNEtwGYp21wYPMyrehs947/owRi4E8x52XI2bUTDF3QRrj66XDIh/FUTPHh54IFrXyPjz3Uw9GUtZT5Sm1aHaObFj6hz2BwpyIyM5Fdt9gOxJZm5GLIOPoSy9rOExdfy0QhDQNX3v8EW6bPdEauKfjTLT4p8tfOOzGZUai8uvw3xBisilTAHnFZqBUAFp2jae2yVmbgWKZGkN4Y78vWc9DczMyTPcSlWY2YaJj6vRCnJtSjUrAqP6Mv2wAN6eyi3DHXTzc56HXoBkSwLM4ljDDv2sLj5GkyGm82CO+A8OJMmlRzq0ypZDdIQPY+SRnj+vC6XPaOnDujgMM00ih5RWEXrb1JwozJhLZWrMU9XSS9+TuczsVJzPQHfPS0pLZcjYGquJVt24db9uN7BrnTTuxPxYkoea/r/n9Ombv/IB1XIipZeX19Ao8AAB51abVofq0rapxR+BmmyX2+AznKc7dmsZtfy6eA3BBHRs3jK8KNP7ylGr2uXBV3jp1sL+0vGajAcHIjAA/+MEPhnXf4KC/m9qDD3bh5psO4Kk/+A/G8ePHY0JtYddU2q5h3xgOI8O99djsQniojRjxIQZi1UVKOhmmg2njWZUKU9dLiTXJhlVbnE7h9qIB3FN4XspixeT/tY7tAGHEuivIwDMmOxmdnQO2m/kirHUwQhQEG0yJ/IDGz5bLYtHWjdzzDubRfN9ug8IC4syOVdJ8otyaN552sM1xSooaC9AR0gs1OgZb59zoviUQ43J2AD417dzBJwY6oFbwpUQJiSAWMhjEluouRz4iySOEk9DPxC1SlZizg+bA0IlUkiovXtGLadPexJzxtgF1sUWfcOImsV0IQi7HUflZs7DT/bped34ngQEMrTJBNjvUlyaK7n1umVlAlUFbvUmoUYtMKWrSWRTulECRU2MgINa0FMrai9uFbdcU7T+LSIHxMB+7WndKx0KFGDkm05KF7NlAEWIz02lXoL2eBJALMWb/HPL6UfPtnQVVJbtR8R8BuQEZZkgd5EP898iqrRNpBUhTtNWtR1fcnfKB36uwSnHRpjTqB4OzUGfGrkJzbAsAQPWo/PjPQDjMJwAopk2PEtEwuT5YejmaOKGMzIoVK3DFFVegpaUFhBA8/fTTjuuUUtx1110YO3YsYrEYli5dip07d56YznIwmikKeBg7diwWLroAnzlzNkLpQhyI0gS2VekSRa6ccVyqi63jHl9pC8W+sa3OfvANIyykQrWBbRVikBxu4MVIoaDUnuApgL44PzMsUMIiZv6daRp67+zfbZ2tR5+rpF2bTOLDVggM9z6pxCB/7gbSJIt81XRvsSKv/u2IzaxF65zvIpbpQ65uPAAgGfYacidkY8HRXakkojndtcsmFrOiKjHQhOk2X2GqOQpMrUMF4badsn9KRMfYlp2IhIYQBJZBIBnNU6ecdzHnlKBL7/c0m9e96jVq8jaSpKKmx76nkjoXBs2lluqSvhXY5zQUUKm0/Dey43E4I87rK8xcIp6Tklk+mvF+k7KuIORYQPkDq1I13kmSDIKEeiBBQoVme/IkI87xPUhD1rxT6JHiSEB67DZpVEPxD4Lac05yXwyeV++SmrO17W8cxIFwF/4882foriw99hMP7rdJmXg/gzm32trFCJqdYgMapqL2uCz0ORRXMbulZkT9HAlOKCMzODiIBQsW4JFH+CL1Bx54AN///vfx4x//GCtXrkRFRQUuueQSZDgfx4nAcFIUrFy5EqedNrzkgTfccAP+v8XnIx7h77SHIvYOyj14v/gMm87evBriWewVWTZLXFV5Oz+V5gEQtI1rDWyrm5F6EEqwqyfjsi3w6YTPxPJi/+3MB0rt4GsMjugGs9SP0pLM1ZoT6s7Ubo8MiO1lo/n9V4Xm+1dWZD4M6/ni74UDLovLLkDELmmIqJmFKNMFls4UQEhzTXKuqtfU2PGLQnGnCu7tGR9EIbDLay0LfPuc49DfKYmwW+1JJBCttaOJRrIq8gPGmNZKlMhYtersWyxiI6B637ik2l5PhPnnbIQik+VNuUYt8XgS57/Mz9+Tk3pQQWypSG/+s8gMLfQWZDqtgSBfM8XvKRyQQS3vOPtLKW3MFZgHydw0wEdaWEBtpgky9XHfYZlMs5Z+PYmKKd8DAISZmgtRaiOaMdZqCbMumIyUErbj6FDiVCsG2Z6YJfg0IOV9jlpOwtFNxecVtq2BuIreCp91rhjTGVScg+CvuvAt2Oe7K6vx2tR5AAAtY7xHSk8sM3FCGZlLL70U99xzDz70oQ95rlFK8b3vfQ//8i//giuvvBLz58/HL37xCxw6dMgjuTlR+MIXvlD2PXv37sWWLVuG3WaF5U7pHcB+3pn//KSG6R3eiYPIdlAjvxwsbpQe4dLbGdncbR+pH+u5ZvTH2GG92r3cYkpkKKiurUdmyK2WKP4BK1QHBcHOzLudFwo7JWaXuZtMZgv4LoJZcwarNXcou5JtcMeoAUxXcALEC7wlJ+hUqVAcOnJzcvVh2nq4Bnd8pXyfj1eE0Yy3Hktv7pOAk20m1Mboy4mE7vpZvjc46eZvo0QcFhpATtGQH7KldfO32YsWayMTvCB7FZCWhMFxWzBzQ6nuYJD9Wgwp3sSPBcTW+/fT+O7sMaRTr5RSyxGkDrCqK4KB2DjzJ+VHDXa4/xDXOfZ57HtTcec7ssc/qwL1fRTHPQW82uJl9FlmgUg5UJ06bN5SeScNmqWkp14l3MNIk/wlIAAQzZb+jSpyEceDoIaKFNPN91SR4ktU2eootVV7pUKmiuMVO1wiJJ+QIoRVLRFsHmd47GZ6jT5m+iIgJ5CdOGltZPbs2YPOzk4sXbrUOlddXY1FixbhjTf8vV6y2SySyaTj32jhF7/4Rdn3lJNDabRBVC/HrwXkuimpzhLOaT5uesRcWONDB1D4aCQiob+/H7Jqu8/6K62crSbDpYXjBoAKBKsW3KjUKSrkGLJ6ltshxZA9l8z2HatRwckW4QTT16AgfE44exermOZbsmBXEXt1EDSA6d7Vwgbto7a7PWexdb9X65hQaDlDEpLpGo8ww8SxO2+371oyZy+AUmFBMosQr5csJBKCzkyVYarhhn6nHYIKgs92Xm23yd1VUGia/wJY+Sf/hdR9V1pfDADoou8HAGT1mehYVYO+3U7m9CgaXHf6jzS3ipc9CjN2PKpMHa+U9fSLpdOOe3mtZWXnt0bkCPZXNXnKud1501oSc7LGQjsUkpBTnd93ForVL0u1FLFzR3nU3cRpAMwL6B0PedXQlAL1ennzhdlBV/v+9nyB0iJWqqoeHsbc4aqcqeBAvNZx2rcbrkAz4crhSY2PFU5aRqaz0xhATU3OAd7U1GRd4+Hee+9FdXW19W/CBMPqvK2tDQ888ACy2aylErrnnntw6NAh/PSnP8WqVavwwgsv4KmnnsLWrVvx/e9/H8lk0lG2p6cHjzzyCDZu3IhnnnkGsixj7dq1+MlPfoKjR486yg4NDeE//uM/sH37dvzmN7/BSy+9hNdffx1//etfh00Tw4rdPWy9gyeRSyCixwJKOJF9t1YmT18cxdR/mVCw7n5HzsiMnKN5KCEFWn+J9h4mfXorc8hxXEYBQOJY9VXC8FhQKM/y3jtVEABTwy3MkXdHKo87i6mBMNU4qX24ugIvzm3FQNgn1obr5WSiBAda+Jl3o4X5pcgLbeo+itqc00sjm2GlKEEV+F+TmMVQ62lzXGMX8bUzPoJUYrx9nxlVtjbeZ51L07inOW/sDQNK1hkLRJMkXxOG1V0Xe86phfw+nHtCoclQTWkIAcWVmcO4JuXMLKwRCRXUeCeNmoSIylFgEgrd7YHCXs750zUK2y6nIKsEgKP5G9Cd+yq6cv+G1H7vmNjcWdhhU9TIB63zOic7fUwrqJbMZ2Klcsy7IwTIZO3v21KvgUJRnZwgL0jaS9P/m/OEXrhpFcUaxMzx9Vy8Ap1hZ5LCXloB1mgfAChj28FL5KpKMvKyjr+efhSDUS8XywbZHDRjTRmPNAxVr2ts6bqTcT0YHcP0HEE8p92/EOtVZdxQ2Lxv3rS50JCzH0xH3E+huBJ4yuY485PXR2uNOUOJquhPpRxrYD6fx/3334+2tjY88cQTWLFiBVasWIEnnngCbW1tuP/++5HP5z3r8WOPPYaVK1fiz3/+c8n5DIOiFJ2S+NrXvobbb7/dOk4mk5gwYQKmTJmCO+64A4BtpFv4+6lPfcpTz5w5c7hlb731VgDA/Pnz8fvf/x5nnHEGzjjjDG7Zr3zlKwCAmTNnWvXu27cPP/nJT4b9fO7YHwacA+yCzgvsK6S4MkirpwgUSDCsebHaCqaZ0ShfGiLpKqAYMTqCsLd3LWYBGKKDAKoxZ+wc7IWR+ViL9Hp3NyaiOePDc4frKPRa5rkmANaOuxy7ivPGnYFtqV2MwNW+d0COQa6djDDNAfDxHmKgyhI2TmzEubv8E/cBxnPsmBXDUJcCnmNorRlPIl4dxmCff+Tp8Uc6QFHD1EsRjfozi+yU60ejM7bXgDAGz3pyP1BXUBlQyLJsxdPTpRCykRoABgNCTJeO+c1vYxNOBwDksm5DRP89oqS5ROxMQLwdsanWju1ofRhqt/c5jUWOz2RUVU8Dgb2zb9LswRfmBDqr1L0qswJkWfaKVwoIGHqS3uigrd1WFdIwUmQoFQrUQWd/ekkNJgBYEPs/LKn8BX56+HGzKW9j9mJg9l9m3KgV51IRiUSAQqgBYjMPzuS0NlRQKObZiBoHYHsT+T22JBWYRwNJJtfa1lAYZ7vKU0JsiYxZaSxaBxSE8u44U8Q4d7A1g70tQ1jESfzNMuZddDqAt23pnbvnZUokBiOS9R56QtV4ZNK1+MybBpNH2YdwgxHXyJEzUBi3BaaxqroK2mAKc+fNRc+qVSCu2DtBQtupA0cBGOpIBcD/N3gF27DvfdGaPBBa61kD77zzTgDAlCleW63CNfc9N998s1WmVI3KSSuRaTZD3LvzGR0+fNi6xkMkEkFVVZXj32ghxoljUAwjVS3pruSEvEUlqkVdZfhg7/W6IY8MahdnVjAhacWZq0JiPAoKQggmM6JnGu3zvV9RHdYOAIAKqds6IyOE0zJTmKsGdhPjnIowSt1tTe3jMChmpSpRENdtKYFCNd/MxpIZiGvQx4i7HMVTwTO4sq742MzDUMuEM8XrTxF7ZCg+Y7hy0E+i5KWnQ3ROgMGosbDt6J1jnY7lzXhDPlIY9rdEJQxF7fZvOPgHzBzaCwDIkxCmxI1vIhvhq28stQpjCqDQWtz0Yj9yHbWODUQ7k5k94suVAHVStbONYGH9yPWL1QWm0bbnyatG/5ZUGmpwWyMQMPVbpGDUcy6bKYedhllXwTiXlRsX/mYZ+uXlgjSn2HfmJEi6CKMgwTt/hcOVtoyG8Fnwsa1+tmKUG68pKLUHi3ztcucJ120aw2C0R8f6lgsCIba9C4WGLU2vYSAcEHcGbhWb0x6QdbmvZjpSqYWKWoBpZarnjyVOWkamtbUVzc3NeOklO7xyMpnEypUrsXjx4hPYMxv19cFZdHkYCSNDCEFecu5SQxNWIxEqZnhWrM3gL8cxaRUi7nrl5o4jNUD9F3MJChyLCKdvsixDlggy2eDF2dcQkzUQxSA+1XM5ACDCsQeiZYTZ/s0eHTKRGJdPZw9kmmMkQbpv/7J9RdRmLlG2kjffAVPhvmgKGb0DqwaNsVBZV1wVV2CKo2lez+z2jlZIcDrb8J/EPSRKDHEEAOirNGIrDWn24m9LujSmflbqYv8MMSqNaGMOn0n/zjquVXshF1kcYgUJAbNPIFAwvkdDx1NTrcYo4X8tjZpTRDgmypGXEVttw4X5wFrCfyQHQuIwkuYtR/LOHbHEnfqd9aumNxAKbu++vSq8mWBD86fm/gden/Q09tVuCajPvx0SeBXQJYLVC5ZYfZZ0CkWxN7K8TZoq6xg309/oXZcClu8R7vncLHWpxtKFUnp0jOOMSjvx6pTf4jsX9QW2S3W3Wp8/rthVZUa2xrdcAX+3KQoGBgawfv16rF+/HoBh4Lt+/Xq0t7eDEIJly5bhnnvuwTPPPINNmzbhhhtuQEtLC6666qoT2W0LhX4fT9AAKzAK4Kq/SUiFbENERVdK2umNXA7jbIQoIc+5Ajpqi3eI1XRnzaBaqUPGhysP8L2eDNI4665VZQzptsdTNFOqrU1x7Jo0E9MSpeXb2lQ5Hb0Jr11Q/94EdDX4M3ROwBThnHfB6Apl0K29hB5TJBOrsqU77rxVfDNUf2iEIiwThikLKF0Wn85O3Kblh+6NrhoirHjZJZEh3rN18wYcQqDzkit9u8fLoMzbt1NT9UV8rseoMy+zTHjSKQrdtEGgnEVL6TZ+qOO89avKtrKlpYrJWExqH0JjqC2wrFNGajJtzHsOktjqFiPj7Tdb+khlOza2vMLkrTKQ63o7sG+8unjoqq+xfodSvahq3wlJspkUd7oJSoA/vautdJVQkbEdD0oizBEE9rjzobltaCLGCUknCGmyt5wrRpBu2vltbyx4lRnPlXe1HeofZ3eLut6oz+4j4ucuf5LghNrIrF69Gu95z3us44Jty4033ojHH38cd9xxBwYHB/GZz3wGfX19OO+88/D888/72l8cb1xxxRXFC7ngJ5H58Ic/jNnT5mP5s2vw2tY/+t6vySHjm/D5qMb2EGxtzaISRrj5ZDhZ1t5npNLtAmqvvw5kO/9aRbq/tPQEhfIVFQAIxh/uRX3fF5AZbAHm2dfbG4dwtCaLnFukCmB2xjlWQiRYehXXkyiHCq1kPAoGRu6JnH1CncjIc8QCVCtOh7RcGvPlUBUS14LPLZ8FRQSHJ4VRX3S3xTCXQbtFJQTkOa4/wwFnjMjo5hQ0EM8Y7RJQZEkIEdOVe0PFPOg9Orxh+GxQc00ItxHEUwBcoZ5683aGc97jExdRNMqjAYUi8ReE6Fr7/nwLBY646pe3gWCuT++dCFUYbcegglAd0/YWF/m7c312kSQGkQZQg1IlugQUoAYtiCnEUSOFRKFuqtl15rp3AbVu7yoblwwO4eHKZrB2NTzk2RQEug4tnUS+y0670VvjzCNX6EFHZsg85jGwQd+ns3zUN3ksoFwkIaTryEHCnLdTqO3PIz1RRqF3bOTcQnxyYvJFTf1xKI15eIyrXCpACTaj1hcH6swC7ilGZkIWTOhJASiuWfhR/WaAF5Ce5cf/XiUyF154ISilnn+PP/44AGMy/uY3v4nOzk5kMhn85S9/wYwZM05klx34f//v/x2zuhoaGhAOhzFtrH/gNEIIdKX0RWJLYi1UMwFfUFJCA/7Xne6rpS3y4dZWXwbqL+cs8bliQzKZksoKFbn+ToBSyKCoPHom5FyNY2LcPjGFTdMsiz624+hzxXsIu/xrPX3kxE8JgtxXFbBTdu5yl7zdH1jCD/WJPkdHeffwzslaJyjy0CUfy2jzWbsSGtLEuZsMmr81n8XYvZiXCl2NAoQiFC4suD6qK0qhSJ2Mesa2xqCd9iJGCLAtYatSzk++hX3dwYu5Zq6j4Tb+lHg4N8vqWQujRrq90bhRlVyeISBs3Dyru5a6hgNdBv744cugV3ufnycJeqvO9R4KQeDi9ntokdzGknzaUlf9b4Z2ghZiH3Fucds4oXA/ARRqJ4206gga6UWGTa2u438OBxvBA4Cesb/1Iw2G1DbbGZw7DQA2Jnt9r6UzTP4xRz85zxP0HDEgmjf6F1J1RLO65wb3HO2b9s2HlIQR+3zmSwpeiO7GoTrg9fHOcqnT7PQ3sbzq6oVdedb83SensCa23yNJC+jKccdJayNzKmA4KQpW/t+vA68HMTIAoEaCEnMRp2SQGouTO4GkdZkj/uYukmWsT5Zdg68YiKCnuhaZmL9UTYvGMWaebSgbp2lg/xvD+mjceyT2WQ5wRMEqpLIW5O5BO78Qb89Z6PPYvi7UDQxPUlFfwUy0hJoaleLUkDAAKq8G9SYsAgAcrTF6fDjsN5Ez9gEckpRjAxMENVOFOfWr8a53/Q7T6nZ5rrsZxahpt8D2KXbUGTSQjfuSOYZyZwKK20wj4nWRMF6sMOQ8HYk+T1kvS0yhcBIXWlclgmzAd+H+OjfU2AvXoSjzrhRbgjcn2o/+yiACEKav1DxjnNvfMonbrqcGuWDDRKE2u8oX3HmLjBXeRosyYqJWbcijBnFvqhKwv+dc2AzU1pn3bbzwmW9K+TMylHGR7iGG6kayBr5bAutqx/WBlDWPBhrkuBggnw/xu9WvY9lnFeyut7+FF2b8FOlxb1nHjSmnlIvdInRYo4JClQYZGyiCi5c/zWlx5AYKw4VgZEaAslMUUIqnVqwILFJT4S9iBYBYf43vNZlo5jpnDKhkRZHZg3Gv5NkK8KB4koy5qqRuJ04b+6Uu/CW8BdFcFvum8kKnm7r5SBRZt0fQ/lW+9fLsPwklUHQJdaZuWS+4KDK7lg1D3qWmQspDpsR3lXZ4cgDYXNXMrKjUVbJ0W6DgQpytPa+mEjgLai6kobyMeGGFL4R2H7WAVsT1jpz9VKL9iChGHxJh/4SqAEVS/ZjLTdhciBnhhJaz0xNcP/deHIzW+L6JguogsqG0Z5eYmhZm/WwiCHg50AgBVNW7zTZUMrwx5CwT05wSPZ0AVMsj3/46mnt7mHvtcT1ZPQC1mKWzeaeeqjEPCiIWEtQlAMB/X/ohvBY6334OOBkMf80pmzTE55mjzjng0/1e+ykWDTlb+vTev/0fAEDtczLxjhQFrvtlznIoMdnuq3RWOVkeF5+v0EtQp/vVSUBJ2LdUlhQP71CAJmmgUj/8Zx679rB1hiIVcm4wZu72RqfXh4pLv0YLgpEZAf7xH/+xrPILzmjFoUN8v3g22N2YqnGe6xKR0NB9DiIDhsusezB3d49H/1AVf8fiJ4o0C28Nl/4hVKqVnnNNYTvPTCHeBE+TtUPpwD6lC59840+OEPIeUCDbb/Spr81sL1VctOzGpd3TsDDj9nQKnkzCJFi1NIga5MylVNFUHK2ps8hrL6sG8jLfOJJFzdTgTLUAkFdLcQlnF8MCODY5JiMzp20c4lmTJZDcUgDic2Tu2H26kldKdUx1Ipzwd9V/ufYcfPq0b5qtR5FUr0dH3vuOWKFTrNHJYAQxlNQ0hI7sLm0q9KvLy0PySwZJZGziee8M0yFcmfyO49z8Pg2b+lYis/ZxJF++G2/UG9ycxGR8rk7tgcJk685SezF2t6Lk/RZLvgP80Zo6PPbBj+KI3Gye9/bbTkbpkl4w0uCddSEoHJuisOQ8Nz8bHGQzZwbZnPv2Wow7vD+wrNlh12HwGGjWawOv+w0zSoB0g27HtqL2+QImDx3AeQcfcpwvqHKMP8yYt9oxCvaEa4L75eqkonmjKBeDwiQwpVBQOzDkmePlyIkzuRWMzAjw8MMPl1y2qbEeG9fvK6nsNRfc7jk3ZewMhFGJet27Yx3IK9i65T2gkErcKDi/4EOKzBhylr8UVYXshVAl3l0qz+U0PmTbLIRdKh4l2YPd4w0VWldVjomTwH7YxTEtzeZnKojN2TOchR5ArshX8XsYYeFnD/S56nF2rDdsT+3luHW7kfORgjkscHQdGZpgTgTXqTAijHDFgmH3jYWk28y4AX9JEnUe+uIT87/ruD+j6XYaBgLPYKickIYctqVhxyoukt0Du70Ha2sAAB/vfh8+3+m0Dp5adbrjuKJ5EwBA1Ya3aw1Tr6Hrmw0KNqMDACDnM9D0gtrZ7qOkq6hOGQzBC33/CJ2WsdjwbGMKfyn1pDMhoKh81mm3o/jsCxSFWRgJwcLkRsf1ttghVCnlxSU5UlUwWi1tgihFzqk7XJU9nE/J9cvp4O8/gww2hwPGRoDtXrGnZSVe2eg8RHT3RtnfbqoAxxxOJCxoP+J5/NCE0YvZVgyCkRkBSnUD//l/P44jR3uKFwTwWjSPo62n4X2nf9yKbFlbW4uPvesaAMVfGO96LjgbQFFozG7gQMWB4MLm6O7s899lA8CRRmNXMG3HTs8Hka+qw6CpFkvFeXYlxRcnyWfCZtc9XeuF+yOOIIfBcHD92zAdAHBuZczRF488hKk6lufbNnWsClYl8sBjAmQ1j361xTqWTDsSj/h8sB8ecJms8qeGiYeD/IKCUHwiBYAj4WqPVYIbg52GbUSB9seCkYmNYQyJmR78qioBqsu4tDqHmQu3MGWACRUzHS2Pf7ex6Qn5GEoXtyGxf+s5Ceu7luPZMXnsHmdbcp69ZUNgZbpPVGujz9TFFNqUc9uvVGk6buzp9mx6CCgqnyvNTVeXgiWfG6p3+/STjy0trcibKUncGx32uGLIXz3lVXFRjB20JeiEOL/hqokrUTKKDMMuWXb0M9CwuMhYqQlgmtRwKwK/bU4/KaGeNmWOh5bf0D4eEIzMCLBmzZqSyn3yhpuKlim4Za+MqHg9poK+5wb82zVP4LbPLcPnP/95tFS6sj/7Kv29p+JZ58naXjNuQ4DdAguVUbesaljlWw6A5fZ7tCNYWtVv7mZ5Rn5aRRV4D+K3KFHOQSyfcJThiY1zA097znWgsaT93LdxG6bU1BYq5/UE6qE1ttrJp9KBjoAM1A5wDIEclwkURhomK/xPO9xzxNMXuRBFuYhnWzG6KDrxKeTtcCigMr+xuCfujujtVuYB0drCrpY6i/m2VRzV02yJY4KJml1QpKXGuhY0SrA7ud6jngEAzSfXUsFduVRMfe0JfPMn/+54l4HxfQBQ3nRv3uI0ownuSIRSfL77qIeRUbnRPPgMtVJEMqSREtSUTIG2hhb/cuwtjGTDrYnVOFGaK6gtFYrJrzmuxRud8W98+ysDAxNVT7miTLbjfZY+OC7cFcPj/6FynTx4nkeuEj5nbDaPlGj/dzwhGJkRIChVQi6Xw1VXnY+WybyMOF5IkgQdhgEfAKQkitrEGNSPqYWiKEhF/WMosGpoY2ovGOsB78pLmOESooRyTruMzXJpLscq7J1U0UVNKs1DR/IRmRLdbicXqjHP2q2WrQLjuQxwEkSqZmhX54fqfdo8QnjulTVoTfbAjmxqgwBYIr3pOB4uIg6X3TI4WF84eyOZyQIdA8lzB+sR5/80JbCaAIBYiS4ck9P24G3O9DprIt66x57d523ZoU90t1ucbhIjoTuT2EaPRlUE0eQkzz3uODJWaoBhGlTzFo75O9/2pA7w9CNaY/3WA6Z744qfvMst4uCexdYS49wAgKIH2+UZOeLsHryi+M+13r7YR9GxLnF0APm9izxBhtgeYCn1Y1btR7MV6Nv1HlerPpLFKEW2TsdQ3GDeeuU4vtX6WaRl/0jlwZLH4DFEAMRzwKKs19byWLEfhJqVOb6nv9M4Mqc63InUWHzwgx/EH/7wKjr2FVHFAAiFoqivr0feldZdk9OAyTjk5NJ064prU3GOVsyEDRhkEuwFDXS/p/X1OijSLsCXyBBZcexGhggFrZlofTNS4NdYsIVxtq4X4ukw56M1Qa7spWEJ4TMZUS2Dd0mrLcbU2cXyFrNhhmcxwLmXna/3jB1Ex4SaIjeVM/15y1o0YC6pLFOq+S9qhcXsXX0b8NNNPzDOmQQhcisk2ZZC5RUJ4UrbFRgwGd50mTJvdzwPAlzacA/Gh9djcaWdublQaqBxXclVB+1kg2M18u+bt5sTdZJ5fZkp59s1BKiWeIjoRVynXcOkFd7owbsrDLsVNvN0Vba2bIYuGy6WhgXciSE2zsnISIxLd3Ov8fd9YwxpjjvsgkScNjohYj9fVlfgbxQfjP5QDI9M/ITvTbaxr1nErVnyHULOC+/OeRlsjhDTMSYjUuGc05qwlPhhtMwYXMcSgpEZAfbs2cM9v2PHDrzwwgsl1zPmXVdBURTkzbFza18EM+T96KuzDeBilgWqn+gPiGdkRPK2eJ+CIsgJh/vhjWDRDMwjw6DlwEH7Hu5XSR1urv10CL8Z491dBMK8XQXFr+c8AlUyGMGYai9qky46yLuzLMyoiDgkMgUKSNCRA9BuelKUkmLLr4hEKcdTiCLC5IEpbJBKqVNhfGJfn9sNLezMMqy64qlX5IK9RVjEMuUzh6EKO1rvjv55GBiw1agF2n6j7ceYO7Df8TxKNIlQ5RGmrA1HlGMKJPw8KkritoEx4d24su7f0BDaZ532T6PoX6k7gi57u+SJoFcc71nzpvcksyBnp15YQq8MZKp7rfspgPq8bTxs05NAhYKOcINDYnIl/V9ch58BAGLZvP1d+zAsmso35CUF5ok4+1sZHsDuqsn+nSeAxJGMGowMOxbs3wVD5OvGT8PFVXlUUaeaVyY9jnEUl1/3b58H6vjD9KFwPYA5G7lpFy7MtGJcF0XTALtBJp5oxTq7Re2t9tTDG5WHq2Jo+/N46EyS3h39O0bc5+FCMDIjwPnnn889zya6DMLCKRfgpou/gsYlHwZg628jIGiQU9BldlEwxJC88R0ypTbxrDevklbt3Q5bRnyMBwVn01wyZMUOtG0hoKIDTKjw3tpaz/XKnh5YtoBmPT/Su8tUnth96Y0zrtvMrlQK+ejhOZOv30766OEO7kvRIOOIwonT40YJD6XoGkjBxd3PDKUMnL6rJvB63pVhvbnnKM7p88aNKA5+T90shaTYjFJPtgl79ywEAByqbITuk5ATAMKVnVzaKzrFvIFdZg8I6mp6cXb9Wm5fSlsvvKWSErH6xr+Dfy1IilvAcN5v21jGrZrhsLLjz7Z+u1VLE0JOu6v0mCPmT1ffmQ6twdm4OfZbLFz8O7w5z3hPMTqEj+JXaECXb/+o62CwbyeGUu2ecnLaNsaNuAjRPj+FoRhfukZBkCykQ2BzRIUINkzrt485O4qQJOGy6jwUBwNfmHv93jFB8TfFvx5OSmZfnMyc13yFcn8yPKVvzwAgDBkPPqrhqu2sXRBFX8RpP8hWnaq1nTQWmfOATCVP53aMrUNyXyVySVuaenCg/BAZxwqCkRkBfvnLX3LPf/e73+WeZ3H54k/gU++7C62NdtJBNzNBTBdZOQfkov7i8Rhj4+JRCkQCpmrda8eiByQHO0icE5/1k8juU4ELxOG6eiRShp3OmKNe7yadeHmJbj2DXtmcAAJqT0e8uxw28mUUrIrOR6ctB09SF+J1LIThTnvkaBd64rVmv5yzDdvLMCaiHPjpyImuIBvzfrbVWrxk+xTHVQIQbl4gZ7s3v/V7xLNp8+zwtouFNWROToHisxBI+T7H8YFoIUEoZf4Ss77iKqPCW6iS/OKKFFRQzBnFaxPiNsy8qdk/Fgehsu8HoPvkocpN1pFPSCCEQlZLNQC3MRShePQSCWpMhxxhOBklhLXzqrBq8CPYn1sAdsonxBm2z/nN8cdNL7Hz8jxy9Y3GfZyyqsuFJa66pXoUWrbPOnqr5kxQANmGFqStQJ1u9TDBQIX/O98+Zjz3vCbzn+WhD7q+I2aeII7x5kVYinkW94xW3D20uj/PqLD8vyNPq9zQ2kWbM6TErspUSfFVV2er+qzfZ5lbjjomI30Qzh/H39gfDwhGZgS44447uOf9VE4s3jf9fdbvpb3Gos6qUwgIFNXgnCt7AY2WZiND4Vxo2MiUbjBSQSvsdpAl/YGisVBKW+AoCBaveA1nr3wLM7Z7xZE5xuOG/QZfjPtLpax7Q4UIvgXzRQqq2LF3HB91ERdQP1RhAFfiL5jd2mK2abr8uqRehSOFSsM28jTqsumhRvq4ZXQ/LXaRZnVCAeKdgN3joLG/tPABBaiN3gXH9oqiiPsa/vBHoMXkMw9JiiQAtcqVotdjoDa6Trg69GDFFOyIOO16tL4a63coU++9yYTMS4MMQGsEuhdUoLl5F+I9Mz3Xi3mJUAAvniFh7yeSHjfY3towVg1djeLTPeX88h65MUS8jBe1JGl+LTmvrKw9BwMzz4BaXQ+NsF9PKT0YnhRr7TSXMQoH3LFDgJqwN9FiJsJ/t6rHg5Df2y/29PkUI9w4VFLOaK+YDZ3T2qUYAnSfJmLpQcSyJy6KLw+CkRkB7r333mHdd+UHr4KcN3coFGjO+xnVUev/kI87LQBsT9rRdt3cdyji7+2U5kTXVXwm2kBY+nD7VF9+vP8aSowPc8qePVA0ezEqMGBjBvj6820RvlEo+8jNPRHnSeL0sjoW+YEKi8rZc6cWKWkgL4XQlShtV1MMlPAZ09fiXuZZ06XAiWt3ywBStVciEm0trw8+EhyNnWyZnx3N51rSxaJ1+4wa/oKiQ+5l7IQ4t8b14IzJ3AHhqidz1Dlp8+PcOuuZXnUGtzk+s0lR+UdDitM6ZS10hWeT5FVJ9dTbAchqzTxebhqUIz2zaOyqhIYi0EZsyFmCDZHk9J1i79CKSd+YjQI7Vtwt8RhCLcmz6+K9KZbR8zL/qsLvYybGqpj5T1+r6Vg6lDbrplAVAk5sUQd8c8JRzw/X9fI2VW9HnXPLpEN7IJW5ORhtCEZmBOAljXzzTY7xHYMvX/kQQtM/gcIgC1OgynQ1DhEV/xv+V4wPb8A/wM5QKiFkf4CcySatMRIMQlCbY+xOyhQETEXp6QrcICDImeJVOhyGyITisogklKBSYvtFuAveBWsbcFqbMbmH9ajZj6AO84kzLVNCeHMArS1jUFdT4+gVC/YowsmxUyoIY9TLWApap/5GtqFX9jGyDZAEHRyTQbrq0vKlRVL5Y0TWg5IhMlVzUi0CBdo6KUwkHdGt/lNYUq7A8tqzHOc6OpzSjqpKnl2H8z3GW8Kuq8H0CvIT5CX4Sw9VIbzbGNPZrDPIYgEa9bofV6dt24+qNH+kD/UXVsPiC8+5nTP8Ol32BqCU4r5lzMfPMFLofk1iL5n382vIhcKuMj4qZKs9nvTI/wk0WgFKY54yk7K9vvew1cY5VTerXunin+euM26RFIdtX+k8hHcc8XkY+2RGthnmtPl8/97ycyQjTsn5YNQ7B5CgtDOjDMHIjAC8pJFBiSTvveF3mNo8Fxsk257BELEbR1HkcZa0Ax+p+zc0EjtmhhaehkSmkBU7SPAOpBM11m+5qA2B94sY3r7L/ghj3N2kt9WgTQGJxVHoOgUQ0SJYNFBTlCmrHgwh4vrKJVowrOPopYlzkovR4KR0nn4SggVz7dgZ7AIXpnmrLQqCyV2dCOULE3MRKz0XIlGbCSh1DisW3M6G5GHAjNP+U0NjmB/Tw7HAc55loMdnbDCrZDzEl8bpHNG6W7UUceVguur072NIjoNHtTPP+gNaxm1DU+0RzzU3Gs9OOBisCRqvj6ytSYCqgsMRpFINlulPMjnGexOAhPw89/zKc85GsqoSfz6Pf1/bW53c82nFneOLIkT5tinyYBIR1+bizEPftH6/L8fvGwt3OoNyEYOCVPdpvtfZ3h1pGGv9PnTYmdIliCHjXuIFlfMJ5hfXi29WshGnlNSSFLOFzIOuKiOqcD7kNM4tNhEGSeEoEMgJTRzsslpwlxq+cnz0IRiZEeDGG2/0nFu1yj/ybWWsBgCwqHMLxg6yNgfGEGEnS9feM7Af7LgcqLEV/N2Rbu4i5RnHzIng5c+vH3byG1mx1Q4Vss/wKvJFdFcR5FxB+s7qsoNHBX2obs8MxXXspKrzacM0w1zzB3tt7uyZzHnnXr08Lb8/ZmpLPPVM380wXYHb5dL3xizzkxt7kaPEH85+r7UYjSFxjI/PDG42YDHXAXRKOobihvt7ilm8d/ZO85SPaRlMTHcwPS20UcxuxO6D7lLNxONJTJ26GiG3Ya8LO8eGMECTkBnpwD55uKkYgGzWm3S1eexOgAKR6CDGjPF68gCATPgMV6qqCn+67DLsaC0kk3XSfd/6bt5tGAj3mb8Y1Rxz/ShJAvkc4nu2InqwDemQcwcuURV3//I/MJXuwIX5V7htOColrArZ+yvoVgCoJjH0HTkH+bSfZM+oS1ZVLFr3qnV2Tzs/SS/AU8PxWIwAeO4vjnRMZlRfRSRFfvAtUGKfA9z8HZGPC3/tfB8eNJxmS6GG6wRwLCAYmRGA52Z95Ah/wjnjjDOt39e9/Wfrt3Ph408qLIoZ/SXr7d1Ipoh0JFJa8N2SQWB4FgAI/Kao4Qbii8H8IHKS03amWgvhgsEhqx2umUIACs1NjrRwzhqoIOWrf0KhEC7d8ALehTWYAa+dSskdDEAt9fa5NDtlUlQdTtnpJ2Cn9vK4RdhfZ9vSLGm6CtVht1Vs6aAEoGaQx3zesGt6AF9HKu/MPfXc2s/irZUfQ73aDzcdiStI0tEaZ6RUJ9PqQ7AiBKIAvvH63Y7v7vfRsfyCJaBg48SqRSLhIUACQqFgo4gcce3MSxhWuhm1uSTtoblgqdCsuuXMECRNRd1YpxQuSXQs2b4a38TXMIb651UrNKtwomj7gUdKBRJ0SFCzPnZyBJjWux9f+Pm9OG3neut8XnW995IllUY57nxrTkCeayVUPXF/UCJM/kvK+amNS4WT+y/5Nr71l6uM7PzKThQEIzMCzJjho1PmoLLS3omNHeqxBkfY45YIqDSMP/V+jVtPnnjFmrZ4kkCNV5fcp5DpNj1VO1bZvsoYyEGqJdeoLKiHLhoKmgT4+FuNwVwUJDNjwrb9kHsNU0r0grEobk6KLf2deD9WQA4IkVasqpJBCn/KuZFPbAoKkLBVV+CExanlvKYPB9zgrE1njJQLrzeUrQEAjJ9gxKjRQRBWjzp6ktDSGMO4ZBui8QIRnO9r2xRXPjLmLjfTY10pgYxZZZKD3mnC+15K5Kx9+hHax9zD13FAyzg/jMhUW3ql5/wWu/IXF4lj39Y4zulufpgYnnIAEI0WV8l6xmsZm48CBjQNHWpAklVKIbuNkgkcL1mXvA3zJAkUbnVOcRRjFs9Z04tpe8qfw/pjwepPdzwj3tNYvzh9ZDfQ/HmltLlmJJ6ZI4VgZEaAdNrrEdHe3o4xY7wTwdQpU5wnzJfeWTUBti2FhDUDH8ZjRx5HUufbIfCMIQvDTIrYTMyuql2ech6YfajT2YHsD7/N65F0n7tKB1Tdu8BzxZCUMNedqKmuCegZH3sT+7Bp9vcAAHKJE3pVqN9zToJTdJUscZK7b/LN5q/iexviG/LVDb9y5auuKH2XyTU6GTMAgFvfHyxEw/5Qh6s3bnrriMTdTLhRJqQYi/BX9/4Usu5k7D3eSsyhx97EPfiYY41GwAXXSIFtBDhU+xm/LrhvHBbkLkDKFq/HTX8pHocUN9RccoSvcmmcUsU9H9gCdR3DzqZegJEt2/gty6VuAMrqhTO2D4DNQ/Xo1mp87uLTL+Sn3i4VzBhLq+e6LrpHgpuJcl6PpzUQAId8vJvc77d6yHi307rOcBDD/UmkYhz7P+aQ5e1KSTXgut26Rw1Ptq7NPNSNuul9CCdODjdswciMAN3dtv55+fLluOCCCzB/3lzMnBXB1KmGCDQUCuGSSy5B69jpzJ32gBuM2BONihDeHLgeeVoQkduDbkftaxh76G9o1vo8/eDtKndUO63My42lUQ56zCSUKuWLxrUy265k+EMKg4YLTl9gnSPcBEZeEMXeKXLvIO6gdXmEOO7NOnW6Wo4FI0oP2IUcitqql2I9ppyd4khBEaw50cLO5xp4s8OnpIEgk5S2yAEobMh1zswSiRntHVB053RKbEYqnguyP3GZIAbl34CTmWpX/YJ1lUZ3zZEHzWsJVfoC4e2ztWCYbQwO1nrK8Nl7IDLdmFekKr4kds57+UHivMumfcyjCG+3PaIcYCXAzSb0qT7MKPyoA8xorXEV5Lwnzqm01O25qLs3MKRElR2ASauAgtnfz2q8htk87c9pBybiE2vvwoW7r/GpleD1yX/z78Qwpnz2lpi1wfZiYk8SEy/o8EjPTxSKx8sW8MWCBcbiumfPHlx22WUYMlUfr70KnHFGDHd/6TpolZMhyzJm9x+C7T/gHniFAeOn4iEYiAxh9o4/oPvsq82y3vsLUImKtJLmXDl2KDpxF/3C/e/vq3PqwSORCCoTlY57eC6wQS3GOW7lbnXDYTQgAju/TAEqwgBskXAVbI8PPwM3imHNI8VhLnY66zlRZjJAuy6j74Un0HoyMDgQwvwzm+CsWo7lnCfS97mhV6Iwll3qKCpRispcDfoq2FucVGTvMN6fv1qUzYGVpg1IoLiHkh+kkg3ig8chCZhyfeOCcBoeOkdD4vSZlssrkWWAcnb1jXHgYPHvVSKsd4/Xzo07zkuYXPhF+OETnKBwOyHIQZy0T3XNDRW+xWxyG/XWxWwHjN0Vf8T0PL9aLTqA9CWvIloTBvpn+/eJAWvTlvHz4OI8XlXWG3jPyUFS729PPcGqJR4mMjuRwtgp6oJ/4jRLQiIzEjz77LMAgGuuucZiYgpYuzaNVzcdgizLqO2uwvtyv7WuUQIcSBhcOYW95gd/3NT113ulgAMVwRm3rYUDFO+V1uKfU+sCy5eKyYm5Pldci1ERJmdvjVNcWaBtaYwB+9Hy79iU1rBuSPVky02hkvu1Fp90bbALr7X4E2JOyrKrh+WjMKkM5u1dnTbM/YgdfdXs0QgmIh0UfSG+VKAoTJqTQa96JNAWqKzIzGVQnUOHKCNtdHvGlVO9FmCCIFshbfgvQmEet++TGqTKuMVA0hIjf1tNcpvg6tm4p8JEhzbR/6FLIkcxvs2lbg2q0zeQIoBQZrN1HJQfy5nHPvgJ1Bl7EW90Sr31EYqo3DP8sIN3ujVMrCcSMZJGVqeYp3Xo8Aypah1TSXeoz7+zjmaFjcwpiVtuuQU//OEPsXLlSu51TdNAKcXp615CSGInGoIDCdbjw20HoKMy+QLUMLPzDxgj5Y73AWa9uE15GrNUr11IuSAgWDTm8pI7FRg0zHVcVVXluFLu55LpcBqltmV1tOf4HfSNhVsmkXtlGXuHfm4e2azjaOBQwp9xDZpb84qh6jkMpz2W+xZDRRVMAAqKtMKohUgRdaY8iLwr3YJUAo3ZIryYLH5lWcxAW3Ah6vw5Tur2u4xA0RMHIZ59hPkcmXn+z1MICOhG3jSEzmb58WLKAnH84V2y8IXGDPpvPMZujyYKY1Zh7LRies7YGAS+ch5jSxHK78OFr/8JkWwaoVyeuWLelTaew8FkBrgcs0inbdOAqOKmB/97t77Joir34jOdpPcWLVPO3OVmZQ9LHdAsyfUJFLkUgWBkRoAHH3wQP/7xj32vt7W1YdWqVaju7/AoQbMyo+pwDbQ5Wx9C2wynK+n0igD9sJsPKjJyj1gbZ4K0nxFkEXi579IHuU4kRAKC9dVGax219fX3AbCfK+ySQPg9bePAJABAvu8c69zuDGuYOLwtT7mfs6T7e3WU3wPvrjkdTprzLvEUS1X7LzYFu5wkjMk4NNEb48QGa5/C27FT9xAPhGTFMbExb8Cbd6s87ywnLImTi+GpwCCvONuoA3FXrHi+RLG0UZHnRHAtoDM8DqoaguabfNC91SZ2uojS1l1f6JSZb3jcr+uZlbLFBYwNTgm3SuFedOUOW8dDUvA8Ra3/nf0sHJ298W/4ws++gxAnaWf+sNdpozCanZ6Mwe+4XnFK5fWwbUtX/JnLUJX77rU0R1tUL0jrmDKcSlPE/7sv6y0Lr6VTE9dccw02bdrke33//v2glELWVKhZCQXz8eenvAcztUKiQft/wPiA3lzCUdHwtsllgb/1HIQtnumgdaDDHBLBn6Hz6s6m8ahI+seeqInUONT0NTU1xkfiX6VdmDl/sGoHqC6jIuS3cHktWcp2Pyzh49WU4cdb8bZXmLKHOWk4RRoAgKUw4hrJlc40EI7bijynh0Lc98OfUWtqDGlCreqONuteAMp7ZsoOIgYdEdbYskidrmH3ujbH3UhZCCn+asC9+87AG69/FDo3LxVPlu+0Y+KhsOEoJr0ylgJ3GYb58GEQiqFQbiBa/ngdYjLVr6xu9chbHDZFJdnrBNOAfcaEVlxt2bnmE47jZiagZrKi28nIMOXsb3d4bKfTKoa1I3I7Wxjt0ACnsu5oDA9U2FGa3bJjv03x0CLNwz0I1dIpCF3XceaZZwaWSSQSmDNnDhQ9j1zKnsC0+oWOcgWjUypp6K/dhGzU3n0QXYGSZwzWOOMqaFErbZoDvpW/Fhdl/73kT8s7wEvjtKr0GHZPbA2sOyw5XXD7+vpK7JWz2fXjXgJA8L0L/9lzmepD3MndnuyCNfLW36ILfAjJhtuGqRTzB39dcp0sJhUxGYtJhUB+BdUCR4vBl0G4jQ6DFxZV1zzXG8bsRTjsH7gxKH+VG+5rR5mYQSyGZFv6IEW8zBOvF3YbrgWd85wROeY9aUILyLll1C35vjaJuKLU6rrVPpH8pDj+rRl/nJsoszbjfyahq+RyY64DL0eVF82aUVd11hX/pZiWCM4hdDRcCfegasy2+JQOAtOqW/KWt9VEcZSibmcloBRxxspGlZ1MRYvOj7BcwJAWwi/2GOtJUdMv6xFYKSngpmghUrdDxUud0iedEO4gtlkt/lsauEQ7ltPZiCG8loaJdevWob8/eLDffPPNqDHTEmQ0GcQcFploHarNwZp3rUis3UA8NQnxwYkg1p18DF/4bt89gDiGEC1jp1XmDr0EqBGDnrMaXkZ13q6/qrLKUWfpU5Zxh+SicTb5C4CqfEamBFdxT/sBt2TjZ0INtwIlTvzFwW8slssAKC0xYwGHGgsB5CjzP1CVryxbAqi7J1EeI5NnJz9zki1rpLgnbn/ccNp3kFQMkbn7PbNHcrwvsB4nZbwo2L6RcJFUxYX2ZIVNTWbc6/nB70lenwjAXoiUsc3APkOaJZNwkZ6WDsIsYwXIjKfNOL0NEaTR+G8hQAOOfMufOZuoFgse6AXvO7cZSPss67lnsNEyJLW098AiNqceqV7nnDYYWu15T55+ewY58b1UbM4aVG1paMSkGXtPiBmnupVA0yU1hdNT1VItMYyRLld7mHFnXw3q16KQidxnRHE4BxEQ7xSEXyqCAm677TbU1tZC0o2dUnJTwhKtN+nGKGiXNfRIFCpnB5elCioGJ3kGq6xz5ITFhCOe4vYiUlhITqvfFnxTMbgWqOGw65TZxYwNFfoIDAwOeOpzJij0m745ogUAVOsC1fsAAmgu993iIvhCvaWimD6sTFjaEmddUa18w0tN8k6YgY1yj0q6xUBhh1iExsmoLYHkhoEvwTvEqT4aGdgQPxWuB5NMaWpI9doZqLp3UdU03vdrsktFFoL+/A2O48QFF9gHPrcSYisJHE0GthSMI7ksvtVZCeUIgdId3OeM+a4PVrniWpUQALIYL108KS7gNiB0yxABgIQLiWWZcpx4Up6qXbUdKwrvGRtsw5VqN+LZELk6YO4DYKrH9LS9zLuTr3rvdp6JgR/XSRrgy2hPFAQjM0w89d+P+F774Ac/iPp6w/9/3GHWAMw5SDZHjB1qNuwMrd6jx/FWxpk8r2vISCYn6165o1ezzeq2eSCeX2GTiRjuULQYriKTcbl61Dw14sgA5U8Ngeud6SLTBWecBoU7gZXe55JK+nasHNqwKoFhwuV+HdR6cRsZt1qLw0DypF2ciTgdtlWr4zOHHddKV336I5YpnqHdDzWumD0EQOLIQjQevNxx/mhmP7b3v+W53x0hl0UuzM8jVACFc8NzzHfAQYtijjVYpxjQSmu7wLYdrN5pNwMgmi3vHVDqdW+OMpsQv/E5XLuNshdGF+nCKC0/kpviIUnF8tODpbe6avaOKNxxHjWvqzmecYz7yYIptNNM7GqAZRx5avkTB8HIDBP1df6DbfZsI0iSpCk4b9MvrfPuF709ZA4015jYpDbjKHWGFu/PdPKKmufKG0IOe8+iwvMTg+92RrEipWBFKmTtYssJrw3zDq8kB4hOy2D8kk5PVMquikpMjuz3qceGVeOGJ0EGD3tKO3ESKZIBsM9ix9QoPgbiuRQqs67Iv6zqncNOe+HdD3MFN8xZNn8VLSPwXzHGKwhedZe/jQwAjFv/JVQeOctx7ki6HQOcsAaaD5WjLTnkLUaGTxUeSqE6Fx6tCPsyve1LQRajJTQjuwPolNDRYmreoCVYlw2pd2nDwKu24sJNl4CdkkJU3+qCnur0MQfKmjIOVL9t/ZZpFOfu+RDevcnYCGx7/RAAQGfUgu6281RxnEznnI0/0PIzu2xkqn1h2EFuRgenBCPzyCOPYPLkyYhGo1i0aBHeesu70zneGFOX4H4kH7nuGkSjpq0C0R1iaVbMuV/WoPoM2H4a9R3s/CmuzEFlVlJLUnivvL68e4ui2ORTGg7mJTzVF0an6h2iwfIMl/EbpzuxaVk0zOlznItjEP971kVWioKStPhv/hDxny4p44mPIVPj4EbLGS1MFQUhWgnjZ0LSzt3FiwFUkkTGLFOBHKTYQeusB77dlkumtZfhYKWQpX8vlPDeYPH36PdNqtydLEW4phRGwX8XPHyPkQDm0vEpUU+5smp3Dw9KkYrxXar5tXvfWjrCLtDlU8Brx+KVVJcMya2yCaKR/7Vyww30VNibC4mGMb/zQsQzzlGaYfJw9SdqHffrrs0BK/DfBw1Dsi05ozIjveZqloRqyRe//vWvcfvtt+Puu+/G2rVrsWDBAlxyySVFbVRGG6ed+4/eeEYyMG7CBOtwuhpsqQ4AcU7eoDQNQ3HVPa1xMQCANs40TrAbqDIjSobN2AiXyG9a53JScbvvY8OiELz7SHn2HIqicD6SUhYTv3LeJ4mQrFm6vImkaHmX1ONYQSlng8zaVTGDVjUD2JXyzDK139mY2ERuGQdv5eofJRpUGJPiWDkFIptGsmVEUtYRQ3cuD6IUV0u4M/qOhPrxfDtT78hATTGg5JYuFTX5Gl7Ltso3uD5dySAXD5IujoyRcQZUDP52Y6rOLZV12dVEqSOXhcf+g9tSIH9hl+YHZ/Sfg8JdHcE2MtT7k/fdeeXHQeBbERXuilUa9pksXTIRpy2XRHRHLRKjMgxsnfMKhft1AB588EF8+tOfxk033YQ5c+bgxz/+MeLxOB577LET2i9VVdHY6IwP0vzRZoQYPfel4d85XjhluJOXY3mchx2Yk3carKlUAtVDODfjZCwmjzfiVwzke4v2bUgyXEoJKOLmG9YZ98zZ0R7PPVtjY4vWqwUMVM8nleX7EBIA/7nOG4AqCEOZIRzKJfFkZZGs057ts0Hv1n1D/PK8/pXjtTTnKgxd/dugoigal2cYYc1jgzqUfHA/s2kVBZ02YQyBJYapSScWGNfN460dth0DC10CQpphQzW35jyEOcHJ8rJuLdIAQFzZnDOxIxiUvdFnm5u9Wdr9niylfhy7hzKQQ6UwMk50Z23PmhDHBTq8j+UknNccaSdKnKz9WCfNVNGMH7KTOUpELy35nqvKTLbTCohXlWrwE0CWjP4JfzV/cZjvHGOASkuXAo/VzDHoNroN+M66Y14j9F19rUhpEuCKkM50CeMHvJvbvv7hOeaWtKFxhPb3iJzA0m8X5TP/nnYZhk/Sh7k8m31JREyVPDu4JBkL4+utw5iScbxm1u6Kt8WwcJL5O5/UjEwul8OaNWuwdOlS65wkSVi6dCneeOMN7j3ZbBbJZNLxbzTwgQ98AFu2bMHkR36BhlsuxrRvT0PDJQ3QJHuh8H4MrH0CcBb2mlysPXh6aQxXDIUxJ2+PlPb6DKqiNWYNgcML0tAALn3pCK6vy+KWMVnUmMyTzkhcDoft9p7VFuGi7Hctrp235G9TW7Bfq8Z+wopy+XYEupmscmhdP1PWRh/xYSpcM3mImSQGpUFcsuNRbI0EG0PavWDbJajptyc/lQI6Z4KQTBFClONp4lWlmE+09WnQX33CU55FtsLIuixR6p3shonKlG55ywCG63NWUhAi9gK/eflBUMVcLDki376KPEAKY8Lo15Ek3+5rKBJGy2C7WRV/ytCphiHZ9nCgcvEFP9E/A7GQ8W7y5syYJ3lHgsYCevO3IU+nGHVzmL90yDU2XBNy96D9Xht67c0AzRtMWajNLq+5HJDYjOh5lBoJm4IbMt+cH/LEHpON+gEQ2X7mLPFxZ3a9x3XrrkMmY9hBNPT5ZbnmQ/fJHC7lKxA7Oq/QoH1h98tMKWoxZID9PWWz/pnLJcYHeCDcD12SIJteNapLGlzQJmeY532j4xzsz42BFLLfnQRnAMeJSYaRMe9dt9eZ1DEo1xJlxIhDfokdfaAgj7Qr/AErhMrBG+eHkmCvK6nMTU5hnsqbm8johpfNfji/p+aQvaFQQ87NH9uiBrfpFPONcHJZnkic1IxMV1cXNE1DU1OT43xTUxM6O/m5Re69915UV1db/yaYqp62tjY88MADyGazuOeeewAA99xzDw4dOoSf/vSnWLVqFV544QU89dRT2Lp1K77//e8jmUw6yvb09OCRRx7Bxo0b8cwzz+DLX/4yLlkwF4nLP4HwhDGgkLG9biOgy9CoBjWnomdcAnqYID+GIt60HirR0CGrSCv9eLfyJhLyYciajHAmAaoDXfkYxoc0qCSHVLgHeTmL9iYJi86cj2RVFZp2rEalUod899mQspWQs1XYoTdiUB4CNBXxI4cwNVSHhXoVZkQpKAU6J86BnO9Dbc9W1PSswf9UV6KHyPiBfDO+pN2KfXIMrZV7MTW2B/+b78cA1ZEjgAYNA3WbcfrMl7FRbsDnpv0V1XoEoEBfDUVYjgEgkCgwMTEFmchahCcPgsoyJEXB+p7l6M/1Qk11AroKQoH35OZgc6WEX73/I+iuqsb+WbOBUAzynCuhbD8XADCu5b9wXu9EKLqEmBaGpEtQICMtJbEhvh1DNI9WPYp9La1IVVQhkQ6j5WgUlYMhrK0cCxruwJHEHqTCvRijNUPSAIq/YEDLY138FeT3TEA6E8e6/aejWd+PKprC6pbpmNW5A9MG9uOt0GyMjaxHmAxAQh6KUoloPgU5n0I61IdKkjWWKaIgolAcRgLZAQWUAi1ZCfMyecRUCbc8T3DBxqNo7O3C1EP7UN+1HICGEFLoH5iGQ9kWdGYacaB5EkLRGFRFQWdVDLVH/4Kj0YM4OEaHygSz6AnvQj5dA33XfEyOrMSBXDcG9BRerH0Dr03II5FYhwqpC2PDGyGHJAAqGg9NAK2sA5Uk0EgFJE1HOqzh7enjIOkaGvVOpLYZ0rjZcyeAyPbOu3oghVjWeG96KIqkUg0pNsm6Hsop+O8xy9Ee7sCL2W5o1fXYOGcWklUJtN+ooE7qRUgbhCblkAv3QclXQtLC0ClBTg8DuSq0bfgEevU6tA9diDwUNFS8itM6tmH8QBY37EpitzQeKVqFIXUa+rY8iZSyE737z0R+qAaH981BfySOVCSOTdPOx6Aaw77BGvSEwpDJICJaFlPT+/DXg6ejaygBSDqqSApNO9vR1T4Jqf56SD0fB8lV49efuwyZUBiqJEEZ045QxWGoIRXt43K4tLIK+8llUGkttqWvQCw5F1SLQALBolgVsjSLtDaIo5mDoJRC0/PozB9CmhxCKpZFZctKRI+ehvDgWMyu2I+6bCN2VbWDSiqmt76KxN8oKqcOYEyFBJmq2CpvQ588gEebXsDRit0IKX9DF/kwMk0z0TFuGtadOQugIQAh1DccgCznQYmO8YPjsSIexxBk6FTCxuhH8bvfvIiOwamItGwwmCiiIatksHHcOrw1NID8UA3k3gYQNQp17yfQ9OojeBazkIzGMbGlBRFJxaKGdizpXYfqfA+InkZldgMkKuGv82VkFSD7QiuymRi2vX0ajjbUYygaxuHoJuSgI6cM4mh8Jz56YBWmDhgu8e/ZfTXeOq0ZMzu7AUhom3IO4nIaG7VmpJQo2hP7EdZD2Bw9DZmwjOVNswCFQCEaSNcSgIYxVHk5NtY1I4IQBmMVGB/agwmEINfQBCrLoFIISng6pgzUoTpTja1TBjGkRNA2aRxUScKmiWFQScFF1Rdh27YwJCmB/PjX0SUn8X+Vq/GsMgcpVGCV/DGsi5+GpFQLfehcRJKTQTQFWlJB7mAt4gMTIWezeG94A/4qtaAzlMeQDLxWR5GmIUTTOqLdMtr0VqRoDG20CZl8N2KZNmTjF6KnmiAdlyERIKFkoU/PYm63gtoBgsW9FVDygyBUQ/fb7wNUgnRbLdSKaoCEsH/cPhCEEBl8HUQbwLz2LJSQhMONC6HJYWiSYVO2YNcO9Ef241DNRlRnk0jvmYz14xvQJ8ewa0IcU6Qt6KiV0DEhic6qdejXB9FNdfwOOVy4cyHiGaC2awn2N0/GYLwCFZOHQNMSSJIAqgSdAgP5EDKZ8Y71Mp/P4/7770dbWxueeOIJrFixAitWrMATTzyBtrY23H///cjn8571+LHHHsPKlSvx5z//GX/4wx9K4hUI5fpEnhw4dOgQxo0bh9dffx2LFy+2zt9xxx1Yvnw5N1ljNptFNmu7viWTSUyYMAH9/f1M8kEBAQEBAQGBkxnJZBLV1dVF1++TWiLT0NAAWZZx+LDTCO3w4cNobm7m3hOJRFBVVeX4N1oocJICowtB59GHoPHxgaDz6EPQePRxstH4pJbIAMCiRYtwzjnn4OGHHwZg5DiaOHEibrvtNnz1q18ten+pHN1wkEwmhZTnOEDQefQhaHx8IOg8+hA0Hn0cLxq/IyQyAHD77bfj0Ucfxc9//nNs27YNt9xyCwYHB3HTTTed6K7h8ccfP9Fd+LuAoPPoQ9D4+EDQefQhaDz6ONlofJI5UXnxsY99DEePHsVdd92Fzs5OnH766Xj++ec9BsAnAqw3lcDoQdB59CFofHwg6Dz6EDQefZxsND7pJTKAkYBx3759yGazWLlyJRYtWnSiuwQAePvtt4sXEhgxBJ1HH4LGxweCzqMPQePRx8lG41OCkTlZUVFRUbyQwIgh6Dz6EDQ+PhB0Hn0IGo8+TjYaC0ZmBKirqyteSGDEEHQefQgaHx8IOo8+BI1HHycbjQUjMwJs3LjxRHfh7wKCzqMPQePjA0Hn0Yeg8ejjZKPxSe9+PVKMpvv1oUOH0NLSckzrFPBC0Hn0IWh8fCDoPPoQNB59HC8av2Pcr09mnOjElX8vEHQefQgaHx8IOo8+BI1HHycbjYVERkBAQEBAQOCkg5DIHAecbGGa36kQdB59CBofHwg6jz4EjUcfJxuNhURmBMhms4hEIse0TgEvBJ1HH4LGxweCzqMPQePRx/GisZDIHAc89NBDJ7oLfxcQdB59CBofHwg6jz4EjUcfJxuNT/oUBSNFQeCUTCaPed0XX3zxqNQr4ISg8+hD0Pj4QNB59CFoPPo4XjQutFFMcfSOZ2RSqRQAYMKECSe4JwICAgICAgLlIpVKobq62vf6O95GRtd1HDp0CJWVlSCEHLN6k8kkJkyYgP379wtvqFGEoPPoQ9D4+EDQefQhaDz6OJ40ppQilUqhpaUFkuRvCfOOl8hIkoTx48ePWv1VVVXigzkOEHQefQgaHx8IOo8+BI1HH8eLxkGSmAKEsa+AgICAgIDAKQvByAgICAgICAicshCMzDARiURw9913i3gFowxB59GHoPHxgaDz6EPQePRxMtL4HW/sKyAgICAgIPDOhZDICAgICAgICJyyEIyMgICAgICAwCkLwcgICAgICAgInLIQjIyAgICAgIDAKQvByAwTjzzyCCZPnoxoNIpFixbhrbfeOtFdOmVw77334uyzz0ZlZSUaGxtx1VVXYfv27Y4ymUwGt956K+rr65FIJPCRj3wEhw8fdpRpb2/H5Zdfjng8jsbGRvzTP/0TVFU9no9yyuC+++4DIQTLli2zzgkajxwHDx7Eddddh/r6esRiMcybNw+rV6+2rlNKcdddd2Hs2LGIxWJYunQpdu7c6aijp6cH1157LaqqqlBTU4NPfepTGBgYON6PctJC0zR84xvfQGtrK2KxGKZOnYpvfetbjvw7gs7lYcWKFbjiiivQ0tICQgiefvppx/VjRc+NGzfi3e9+N6LRKCZMmIAHHnhgdB6ICpSNJ598kobDYfrYY4/RLVu20E9/+tO0pqaGHj58+ER37ZTAJZdcQn/2s5/RzZs30/Xr19PLLruMTpw4kQ4MDFhlPve5z9EJEybQl156ia5evZq+613voueee651XVVVOnfuXLp06VK6bt06+txzz9GGhgb6ta997UQ80kmNt956i06ePJnOnz+ffulLX7LOCxqPDD09PXTSpEn0k5/8JF25ciVta2ujL7zwAt21a5dV5r777qPV1dX06aefphs2bKAf/OAHaWtrK02n01aZ97///XTBggX0zTffpK+++iqdNm0aveaaa07EI52U+Pa3v03r6+vps88+S/fs2UN/+9vf0kQiQR966CGrjKBzeXjuuefo17/+dfrUU09RAPT3v/+94/qxoGd/fz9tamqi1157Ld28eTP91a9+RWOxGP3JT35yzJ9HMDLDwDnnnENvvfVW61jTNNrS0kLvvffeE9irUxdHjhyhAOjy5csppZT29fXRUChEf/vb31pltm3bRgHQN954g1JqfIiSJNHOzk6rzI9+9CNaVVVFs9ns8X2AkxipVIpOnz6dvvjii/SCCy6wGBlB45HjzjvvpOedd57vdV3XaXNzM/3ud79rnevr66ORSIT+6le/opRSunXrVgqArlq1yirzpz/9iRJC6MGDB0ev86cQLr/8cnrzzTc7zn34wx+m1157LaVU0HmkcDMyx4qeP/zhD2ltba1jrrjzzjvpzJkzj/kzCNVSmcjlclizZg2WLl1qnZMkCUuXLsUbb7xxAnt26qK/vx8AUFdXBwBYs2YN8vm8g8azZs3CxIkTLRq/8cYbmDdvHpqamqwyl1xyCZLJJLZs2XIce39y49Zbb8Xll1/uoCUgaHws8Mwzz+Css87C1VdfjcbGRixcuBCPPvqodX3Pnj3o7Ox00Li6uhqLFi1y0LimpgZnnXWWVWbp0qWQJAkrV648fg9zEuPcc8/FSy+9hB07dgAANmzYgNdeew2XXnopAEHnY41jRc833ngD559/PsLhsFXmkksuwfbt29Hb23tM+/yOTxp5rNHV1QVN0xyTOwA0NTXh7bffPkG9OnWh6zqWLVuGJUuWYO7cuQCAzs5OhMNh1NTUOMo2NTWhs7PTKsN7B4VrAsCTTz6JtWvXYtWqVZ5rgsYjR1tbG370ox/h9ttvxz//8z9j1apV+OIXv4hwOIwbb7zRohGPhiyNGxsbHdcVRUFdXZ2gsYmvfvWrSCaTmDVrFmRZhqZp+Pa3v41rr70WAASdjzGOFT07OzvR2trqqaNwrba29pj1WTAyAicUt956KzZv3ozXXnvtRHflHYX9+/fjS1/6El588UVEo9ET3Z13JHRdx1lnnYXvfOc7AICFCxdi8+bN+PGPf4wbb7zxBPfunYPf/OY3eOKJJ/DLX/4Sp512GtavX49ly5ahpaVF0FkAgPBaKhsNDQ2QZdnj3XH48GE0NzefoF6dmrjtttvw7LPP4pVXXsH48eOt883Nzcjlcujr63OUZ2nc3NzMfQeFa3/vWLNmDY4cOYIzzjgDiqJAURQsX74c3//+96EoCpqamgSNR4ixY8dizpw5jnOzZ89Ge3s7AJtGQXNFc3Mzjhw54riuqip6enoEjU380z/9E7761a/i4x//OObNm4frr78eX/7yl3HvvfcCEHQ+1jhW9Dye84dgZMpEOBzGmWeeiZdeesk6p+s6XnrpJSxevPgE9uzUAaUUt912G37/+9/j5Zdf9ogfzzzzTIRCIQeNt2/fjvb2dovGixcvxqZNmxwf04svvoiqqirP4vL3iIsuugibNm3C+vXrrX9nnXUWrr32Wuu3oPHIsGTJEk/YgB07dmDSpEkAgNbWVjQ3NztonEwmsXLlSgeN+/r6sGbNGqvMyy+/DF3XsWjRouPwFCc/hoaGIEnOpUqWZei6DkDQ+VjjWNFz8eLFWLFiBfL5vFXmxRdfxMyZM4+pWgmAcL8eDp588kkaiUTo448/Trdu3Uo/85nP0JqaGod3h4A/brnlFlpdXU3/+te/0o6ODuvf0NCQVeZzn/scnThxIn355Zfp6tWr6eLFi+nixYut6wXX4IsvvpiuX7+ePv/883TMmDHCNTgArNcSpYLGI8Vbb71FFUWh3/72t+nOnTvpE088QePxOP2f//kfq8x9991Ha2pq6B/+8Ae6ceNGeuWVV3LdWBcuXEhXrlxJX3vtNTp9+vS/W7dgHm688UY6btw4y/36qaeeog0NDfSOO+6wygg6l4dUKkXXrVtH161bRwHQBx98kK5bt47u27ePUnps6NnX10ebmpro9ddfTzdv3kyffPJJGo/Hhfv1yYSHH36YTpw4kYbDYXrOOefQN99880R36ZQBAO6/n/3sZ1aZdDpNP//5z9Pa2loaj8fphz70IdrR0eGoZ+/evfTSSy+lsViMNjQ00K985Ss0n88f56c5deBmZASNR44//vGPdO7cuTQSidBZs2bR//qv/3Jc13WdfuMb36BNTU00EonQiy66iG7fvt1Rpru7m15zzTU0kUjQqqoqetNNN9FUKnU8H+OkRjKZpF/60pfoxIkTaTQapVOmTKFf//rXHW69gs7l4ZVXXuHOwTfeeCOl9NjRc8OGDfS8886jkUiEjhs3jt53332j8jyEUiY8ooCAgICAgIDAKQRhIyMgICAgICBwykIwMgICAgICAgKnLAQjIyAgICAgIHDKQjAyAgICAgICAqcsBCMjICAgICAgcMpCMDICAgICAgICpywEIyMgICAgICBwykIwMgICAgICAgKnLAQjIyAgMCr45Cc/iauuuuq4t/v444+DEAJCCJYtWzZq7ezdu9dq5/TTTx+1dgQEBIKhnOgOCAgInHoghARev/vuu/HQQw/hRAUOr6qqwvbt21FRUTFqbUyYMAEdHR3493//d/zlL38ZtXYEBASCIRgZAQGBstHR0WH9/vWvf4277rrLkQk6kUggkUiciK4BMBit5ubmUW1DlmU0Nzef0OcUEBAQqiUBAYFhoLm52fpXXV1tMQ6Ff4lEwqNauvDCC/GFL3wBy5YtQ21tLZqamvDoo49icHAQN910EyorKzFt2jT86U9/crS1efNmXHrppUgkEmhqasL111+Prq6usvs8efJk3HPPPbjhhhuQSCQwadIkPPPMMzh69CiuvPJKJBIJzJ8/H6tXr7bu2bdvH6644grU1taioqICp512Gp577rlh001AQODYQzAyAgICxw0///nP0dDQgLfeegtf+MIXcMstt+Dqq6/Gueeei7Vr1+Liiy/G9ddfj6GhIQBAX18f3vve92LhwoVYvXo1nn/+eRw+fBgf/ehHh9X+f/7nf2LJkiVYt24dLr/8clx//fW44YYbcN1112Ht2rWYOnUqbrjhBkslduuttyKbzWLFihXYtGkT7r//fiGBERA4ySAYGQEBgeOGBQsW4F/+5V8wffp0fO1rX0M0GkVDQwM+/elPY/r06bjrrrvQ3d2NjRs3AgB+8IMfYOHChfjOd76DWbNmYeHChXjsscfwyiuvYMeOHWW3f9lll+Gzn/2s1VYymcTZZ5+Nq6++GjNmzMCdd96Jbdu24fDhwwCA9vZ2LFmyBPPmzcOUKVPwgQ98AOeff/4xpYmAgMDIIBgZAQGB44b58+dbv2VZRn19PebNm2eda2pqAgAcOXIEALBhwwa88sorls1NIpHArFmzAAC7d+8eUfuFtoLa/+IXv4h77rkHS5Yswd13320xWAICAicPBCMjICBw3BAKhRzHhBDHuYI3lK7rAICBgQFcccUVWL9+vePfzp07hyUZ4bUV1P4//MM/oK2tDddffz02bdqEs846Cw8//HDZ7QoICIweBCMjICBw0uKMM87Ali1bMHnyZEybNs3xbzRdq1lMmDABn/vc5/DUU0/hK1/5Ch599NHj0q6AgEBpEIyMgIDASYtbb70VPT09uOaaa7Bq1Srs3r0bL7zwAm666SZomjbq7S9btgwvvPAC9uzZg7Vr1+KVV17B7NmzR71dAQGB0iEYGQEBgZMWLS0t+Nvf/gZN03DxxRdj3rx5WLZsGWpqaiBJoz99aZqGW2+9FbNnz8b73/9+zJgxAz/84Q9HvV0BAYHSQeiJCr0pICAgMAp4/PHHsWzZMvT19R2X9v71X/8VTz/9NNavX39c2hMQEHBCSGQEBATecejv70cikcCdd945am20t7cjkUjgO9/5zqi1ISAgUBxCIiMgIPCOQiqVsuLA1NTUoKGhYVTaUVUVe/fuBQBEIhFMmDBhVNoREBAIhmBkBAQEBAQEBE5ZCNWSgICAgICAwCkLwcgICAgICAgInLIQjIyAgICAgIDAKQvByAgICAgICAicshCMjICAgICAgMApC8HICAgICAgICJyyEIyMgICAgICAwCkLwcgICAgICAgInLL4/wFf0drmn8dCEQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2911,7 +1696,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -2920,13 +1705,13 @@ "(0.01, 6)" ] }, - "execution_count": 22, + "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": [ "
" ] @@ -3025,7 +1810,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.2" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/pynestml/utils/ast_utils.py b/pynestml/utils/ast_utils.py index d3d6f6ef5..41fb2f1f3 100644 --- a/pynestml/utils/ast_utils.py +++ b/pynestml/utils/ast_utils.py @@ -697,7 +697,8 @@ def get_post_ports_of_neuron_synapse_pair(cls, neuron, synapse, codegen_opts_pai for pair in codegen_opts_pairs: if pair["neuron"] == removesuffix(neuron.get_name().split("__with_")[0], FrontendConfiguration.suffix) \ and pair["synapse"] == removesuffix(synapse.get_name().split("__with_")[0], FrontendConfiguration.suffix) \ - and "post_ports" in pair.keys(): + and "post_ports" in pair.keys() \ + and pair["post_ports"]: return pair["post_ports"] return []