From aad44cc3dbc148f028b365f9967b52852723df5d Mon Sep 17 00:00:00 2001 From: Pooja Babu Date: Mon, 26 Feb 2024 12:07:41 +0100 Subject: [PATCH] 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": "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", + "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": "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==", + "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,