From 7bf8b1f2fd79977932608f7aa135134c7e8cc60f Mon Sep 17 00:00:00 2001
From: Florent Pollet <flo1.raymond@gmail.com>
Date: Tue, 26 Mar 2024 16:32:54 +0100
Subject: [PATCH 1/3] feat: eprop neurons

---
 spyx/axn.py     |  16 +++++
 spyx/nn.py      | 156 +++++++++++++++++++++++++++++++++++++++++++++++-
 tests/shd.ipynb |   1 +
 3 files changed, 172 insertions(+), 1 deletion(-)
 create mode 100644 tests/shd.ipynb

diff --git a/spyx/axn.py b/spyx/axn.py
index 189034e..3ee1128 100644
--- a/spyx/axn.py
+++ b/spyx/axn.py
@@ -119,3 +119,19 @@ def grad_superspike(x):
         return 1 / (1 + k*jnp.abs(x))**2
     
     return custom(grad_superspike, heaviside)
+
+@jax.custom_gradient
+def eprop_SpikeFunction(v_scaled, dampening_factor):
+    z_ = jnp.greater(v_scaled, 0.)
+    z_ = z_.astype(jnp.float32)
+
+    def grad(dy):
+        dE_dz = dy
+        dz_dv_scaled = jnp.maximum(1 - jnp.abs(v_scaled), 0)
+        dz_dv_scaled *= dampening_factor
+
+        dE_dv_scaled = dE_dz * dz_dv_scaled
+
+        return (dE_dv_scaled, jnp.zeros_like(dampening_factor).astype(jnp.float32))
+
+    return z_, grad
\ No newline at end of file
diff --git a/spyx/nn.py b/spyx/nn.py
index ded735c..133d0ca 100644
--- a/spyx/nn.py
+++ b/spyx/nn.py
@@ -1,12 +1,14 @@
 import jax
 import jax.numpy as jnp
 import haiku as hk
-from .axn import superspike
+from .axn import superspike, eprop_SpikeFunction
 
 from collections.abc import Sequence
 from typing import Optional, Union
 import warnings
 
+from collections import namedtuple
+
 #needs fixed.
 class ALIF(hk.RNNCore): 
     """
@@ -80,6 +82,158 @@ def __call__(self, x, VT):
     # not sure if this is borked.
     def initial_state(self, batch_size): # this might need fixed to match CuBaLIF...
         return jnp.zeros((batch_size,) + tuple(2*s for s in self.hidden_shape))
+
+
+CustomALIFStateTuple = namedtuple('CustomALIFStateTuple', ('s', 'z', 'r', 'z_local'))
+
+
+class RecurrentLIFLight(hk.RNNCore):
+    """
+    Recurrent LIF
+    See LeakyLIF for the output neuron type of the original paper
+
+    Original code from https://github.com/IGITUGraz/eligibility_propagation for RecurrentLIFLight
+    Copyright 2019-2020, the e-prop team:
+    Guillaume Bellec, Franz Scherr, Anand Subramoney, Elias Hajek, Darjan Salaj, Robert Legenstein, Wolfgang Maass
+    from the Institute for theoretical computer science, TU Graz, Austria.
+    """
+
+    def __init__(self, 
+                 n_rec, tau=20., thr=.615, dt=1., dtype=jnp.float32, dampening_factor=0.3,
+                 tau_adaptation=200., beta=.16, tag='',
+                 stop_gradients=False, w_rec_init=None, n_refractory=1, rec=True,
+                 name="RecurrentLIFLight"):
+        super().__init__(name=name)
+
+        self.n_refractory = n_refractory
+        self.tau_adaptation = tau_adaptation
+        self.beta = beta
+        self.decay_b = jnp.exp(-dt / tau_adaptation)
+
+        if jnp.isscalar(tau): tau = jnp.ones(n_rec, dtype=dtype) * jnp.mean(tau)
+        if jnp.isscalar(thr): thr = jnp.ones(n_rec, dtype=dtype) * jnp.mean(thr)
+
+        tau = jnp.array(tau, dtype=dtype)
+        dt = jnp.array(dt, dtype=dtype)
+        self.rec = rec
+
+        self.dampening_factor = dampening_factor
+        self.stop_gradients = stop_gradients
+        self.dt = dt
+        self.n_rec = n_rec
+        self.data_type = dtype
+
+        self._num_units = self.n_rec
+
+        self.tau = tau
+        self._decay = jnp.exp(-dt / tau)
+        self.thr = thr
+
+        if rec:
+            init_w_rec_var = w_rec_init if w_rec_init is not None else hk.initializers.TruncatedNormal(1./jnp.sqrt(n_rec))
+            self.w_rec_var = hk.get_parameter("w_rec" + tag, (n_rec, n_rec), dtype, init_w_rec_var)
+
+            self.recurrent_disconnect_mask = jnp.diag(jnp.ones(n_rec, dtype=bool))
+
+            self.w_rec_val = jnp.where(self.recurrent_disconnect_mask, jnp.zeros_like(self.w_rec_var), self.w_rec_var)
+
+        self.built = True
+
+    def initial_state(self, batch_size, dtype=jnp.float32, n_rec=None):
+        if n_rec is None: n_rec = self.n_rec
+
+        s0 = jnp.zeros(shape=(batch_size, n_rec, 2), dtype=dtype)
+        z0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
+        z_local0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
+        r0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
+        return CustomALIFStateTuple(s=s0, z=z0, r=r0, z_local=z_local0)
+    
+    def compute_z(self, v, b):
+        adaptive_thr = self.thr + b * self.beta
+        v_scaled = (v - adaptive_thr) / self.thr
+        z = eprop_SpikeFunction(v_scaled, self.dampening_factor)
+        z = z * 1 / self.dt
+        return z
+        
+    def __call__(self, inputs, state, scope=None, dtype=jnp.float32):
+        decay = self._decay
+
+        z = state.z
+        z_local = state.z_local
+        s = state.s
+
+        if self.stop_gradients:
+            z = jax.lax.stop_gradient(z)
+            
+        i_in = inputs.reshape(-1, self.n_rec)
+
+        if self.rec:
+            if len(self.w_rec_val.shape) == 3:
+                i_rec = jnp.einsum('bi,bij->bj', z, self.w_rec_val)
+            else:
+                i_rec = jnp.matmul(z, self.w_rec_val)
+
+            i_t = i_in + i_rec
+        else:
+            i_t = i_in
+
+        def get_new_v_b(s, i_t):
+            v, b = s[..., 0], s[..., 1]
+            new_b = self.decay_b * b + z_local
+
+            I_reset = z * self.thr * self.dt
+            new_v = decay * v + i_t  - I_reset
+
+            return new_v, new_b
+        
+        new_v, new_b = get_new_v_b(s, i_t)
+
+        is_refractory = state.r > 0
+        zeros_like_spikes = jnp.zeros_like(z)
+        new_z = jnp.where(is_refractory, zeros_like_spikes, self.compute_z(new_v, new_b))
+        new_z_local = jnp.where(is_refractory, zeros_like_spikes, self.compute_z(new_v, new_b))
+        new_r = state.r + self.n_refractory * new_z - 1
+        new_r = jnp.clip(new_r, 0., float(self.n_refractory))
+
+        if self.stop_gradients:
+            new_r = jax.lax.stop_gradient(new_r)
+        new_s = jnp.stack((new_v, new_b), axis=-1)
+
+        new_state = CustomALIFStateTuple(s=new_s, z=new_z, r=new_r, z_local=new_z_local)
+        return new_z, new_state
+
+
+class LeakyLinear(hk.RNNCore):
+    """
+    Leaky real-valued output neuron from the code of the paper https://github.com/IGITUGraz/eligibility_propagation
+ 
+    """
+    def __init__(self, n_in, n_out, kappa, dtype=jnp.float32, name="LeakyLinear"):
+        super().__init__(name=name)
+        self.n_in = n_in
+        self.n_out = n_out
+        self.kappa = kappa
+
+        self.dtype = dtype
+
+        self.weights = hk.get_parameter("weights", shape=[n_in, n_out], dtype=dtype,
+                                        init=hk.initializers.TruncatedNormal(1./jnp.sqrt(n_in)))
+
+        self._num_units = self.n_out
+        self.built = True
+
+
+    def initial_state(self, batch_size, dtype=jnp.float32):
+        s0 = jnp.zeros(shape=(batch_size, self.n_out), dtype=dtype)
+        return s0
+
+    def __call__(self, inputs, state, scope=None, dtype=jnp.float32):
+        if len(self.weights.shape) == 3:
+            outputs = jnp.einsum('bi,bij->bj', inputs, self.weights)
+        else:
+            outputs = jnp.matmul(inputs, self.weights)
+        new_s = self.kappa * state  + (1 - self.kappa) * outputs
+        return new_s, new_s
          
 class LI(hk.RNNCore):
     """
diff --git a/tests/shd.ipynb b/tests/shd.ipynb
new file mode 100644
index 0000000..b7d21a2
--- /dev/null
+++ b/tests/shd.ipynb
@@ -0,0 +1 @@
+{"cells":[{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["from spyx.nn import LeakyLinear, RecurrentLIFLight"]},{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:26.124346Z","iopub.status.busy":"2024-03-25T00:51:26.123957Z","iopub.status.idle":"2024-03-25T00:51:45.375066Z","shell.execute_reply":"2024-03-25T00:51:45.374022Z","shell.execute_reply.started":"2024-03-25T00:51:26.124313Z"},"trusted":true},"outputs":[],"source":["import spyx\n","import spyx.nn as snn\n","\n","# JAX imports\n","import os\n","import jax\n","from jax import numpy as jnp\n","import jmp # jax mixed-precision\n","import numpy as np\n","\n","from jax_tqdm import scan_tqdm\n","from tqdm import tqdm\n","\n","# implement our SNN in DeepMind's Haiku\n","import haiku as hk\n","\n","# for surrogate loss training.\n","import optax\n","\n","# rendering tools\n","import matplotlib.pyplot as plt\n","from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:53.610008Z","iopub.status.busy":"2024-03-25T00:51:53.609590Z","iopub.status.idle":"2024-03-25T00:52:53.102621Z","shell.execute_reply":"2024-03-25T00:52:53.101491Z","shell.execute_reply.started":"2024-03-25T00:51:53.609973Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Downloading https://zenkelab.org/datasets/shd_train.h5.zip to ./data/SHD/shd_train.h5.zip\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"2a223b925860402a82d8731c8dc65a37","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/130863613 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Extracting ./data/SHD/shd_train.h5.zip to ./data/SHD\n","Downloading https://zenkelab.org/datasets/shd_test.h5.zip to ./data/SHD/shd_test.h5.zip\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"ae4e5785cb394ff59cc70e984693efab","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/38141465 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Extracting ./data/SHD/shd_test.h5.zip to ./data/SHD\n"]}],"source":["shd_dl = spyx.loaders.SHD_loader(256,128,128)"]},{"cell_type":"code","execution_count":16,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:34.878852Z","iopub.status.busy":"2024-03-25T00:59:34.877963Z","iopub.status.idle":"2024-03-25T00:59:34.894764Z","shell.execute_reply":"2024-03-25T00:59:34.893802Z","shell.execute_reply.started":"2024-03-25T00:59:34.878814Z"},"trusted":true},"outputs":[],"source":["key = jax.random.PRNGKey(0)\n","x,y = shd_dl.train_epoch(key)"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.107085Z","iopub.status.busy":"2024-03-25T00:59:35.106146Z","iopub.status.idle":"2024-03-25T00:59:35.116003Z","shell.execute_reply":"2024-03-25T00:59:35.114928Z","shell.execute_reply.started":"2024-03-25T00:59:35.107049Z"},"trusted":true},"outputs":[],"source":["\n","def lsnn_shd(x, state=None):\n","    n_rec = 400\n","    tau = 20\n","    dt = 1\n","    core = hk.DeepRNN([\n","        hk.Linear(n_rec),\n","        RecurrentLIFLight(n_rec,\n","            tau=tau,\n","            thr=0.8,\n","            dt=dt,\n","            dtype=jnp.float32,\n","            dampening_factor=0.3,\n","            tau_adaptation=500,\n","            beta=0.07 * jnp.ones(n_rec),\n","            tag='',\n","            stop_gradients=True,\n","            w_rec_init=None,\n","            n_refractory=3,\n","            rec=True,),\n","       LeakyLinear(n_rec, 20, jnp.exp(-dt/tau))\n","    ])\n","    spikes, hiddens = hk.dynamic_unroll(core, x, core.initial_state(x.shape[0]), time_major=False, unroll=128)#16) # unroll our model.\n","    \n","    return spikes, hiddens"]},{"cell_type":"code","execution_count":18,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.281232Z","iopub.status.busy":"2024-03-25T00:59:35.280138Z","iopub.status.idle":"2024-03-25T00:59:35.287667Z","shell.execute_reply":"2024-03-25T00:59:35.286683Z","shell.execute_reply.started":"2024-03-25T00:59:35.281194Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256, 16, 128)"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["x.shape"]},{"cell_type":"code","execution_count":19,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.472580Z","iopub.status.busy":"2024-03-25T00:59:35.471589Z","iopub.status.idle":"2024-03-25T00:59:35.479043Z","shell.execute_reply":"2024-03-25T00:59:35.477983Z","shell.execute_reply.started":"2024-03-25T00:59:35.472547Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256)"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["y.shape"]},{"cell_type":"code","execution_count":20,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.622628Z","iopub.status.busy":"2024-03-25T00:59:35.621698Z","iopub.status.idle":"2024-03-25T01:00:13.651070Z","shell.execute_reply":"2024-03-25T01:00:13.650089Z","shell.execute_reply.started":"2024-03-25T00:59:35.622595Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (1, 256, 128)\n","iin (1, 400)\n","iin (1, 400)\n"]}],"source":["# Create a random key\n","# Since there's nothing stochastic about the network, we can avoid using an RNG as a param!\n","SNN = hk.without_apply_rng(hk.transform(lsnn_shd))\n","\n","x0 = jnp.zeros((1, 256, 128))\n","params = SNN.init(rng=key, x=x0)\n"]},{"cell_type":"code","execution_count":21,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.654007Z","iopub.status.busy":"2024-03-25T01:00:13.653689Z","iopub.status.idle":"2024-03-25T01:00:13.671535Z","shell.execute_reply":"2024-03-25T01:00:13.670388Z","shell.execute_reply.started":"2024-03-25T01:00:13.653979Z"},"trusted":true},"outputs":[],"source":["def gd(SNN, params, dl, epochs=300, schedule=3e-4):\n","\n","    # We use optax for our optimizer.\n","    opt = optax.adam(learning_rate=schedule)\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    # create and initialize the optimizer\n","    opt_state = opt.init(params)\n","    grad_params = params\n","\n","    # define and compile our eval function that computes the loss for our SNN\n","    @jax.jit\n","    def net_eval(weights, events, targets):\n","        readout = SNN.apply(weights, events)\n","        traces, V_f = readout\n","        return Loss(traces, targets)\n","\n","    # Use JAX to create a function that calculates the loss and the gradient!\n","    surrogate_grad = jax.value_and_grad(net_eval)\n","\n","    rng = jax.random.PRNGKey(0)\n","\n","    # compile the meat of our training loop for speed\n","    @jax.jit\n","    def train_step(state, data):\n","        # unpack the parameters and optimizer state\n","        grad_params, opt_state = state\n","        # unpack the data into x, y\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1) # decompress temporal axis\n","        # compute loss and gradient\n","        loss, grads = surrogate_grad(grad_params, events, targets)\n","        # generate updates based on the gradients and optimizer\n","        updates, opt_state = opt.update(grads, opt_state, grad_params)\n","        # return the updated parameters\n","        new_state = [optax.apply_updates(grad_params, updates), opt_state]\n","        return new_state, loss\n","\n","    # For validation epochs, do the same as before but compute the\n","    # accuracy, predictions and losses (no gradients needed)\n","    @jax.jit\n","    def eval_step(grad_params, data):\n","        # unpack our data\n","        events, targets = data\n","        # decompress information along temporal axis\n","        events = jnp.unpackbits(events, axis=1)\n","        # apply the network to the data\n","        readout = SNN.apply(grad_params, events)\n","        # unpack the final layer outputs and end state of each SNN layer\n","        traces, V_f = readout\n","        # compute accuracy, predictions, and loss\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        # we return the parameters here because of how jax.scan is structured.\n","        return grad_params, jnp.array([acc, loss])\n","\n","\n","    val_data = dl.val_epoch()\n","\n","    # Here's the start of our training loop!\n","    @scan_tqdm(epochs)\n","    def epoch(epoch_state, epoch_num):\n","        curr_params, curr_opt_state = epoch_state\n","\n","        shuffle_rng = jax.random.fold_in(rng, epoch_num)\n","        train_data = dl.train_epoch(shuffle_rng)\n","\n","        # train epoch\n","        end_state, train_loss = jax.lax.scan(\n","            train_step,# our function which computes and updates gradients for one batch\n","            [curr_params, curr_opt_state], # initialize with parameters and optimizer state of current epoch\n","            train_data,# pass the newly shuffled training data\n","            train_data.obs.shape[0]# this corresponds to the number of training batches\n","        )\n","\n","        new_params, _ = end_state\n","\n","        # val epoch\n","        _, val_metrics = jax.lax.scan(\n","            eval_step,# func\n","            new_params,# init\n","            val_data,# xs\n","            val_data.obs.shape[0]# len\n","        )\n","        \n","        print(val_metrics)\n","\n","\n","        return end_state, jnp.concatenate([jnp.expand_dims(jnp.mean(train_loss),0), jnp.mean(val_metrics, axis=0)])\n","    # end epoch\n","\n","    # epoch loop\n","    final_state, metrics = jax.lax.scan(\n","        epoch,\n","        [grad_params, opt_state], # metric arrays\n","        jnp.arange(epochs), #\n","        epochs # len of loop\n","    )\n","\n","    final_params, final_optimizer_state = final_state\n","\n","\n","    # return our final, optimized network.\n","    return final_params, metrics"]},{"cell_type":"code","execution_count":22,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.673210Z","iopub.status.busy":"2024-03-25T01:00:13.672889Z","iopub.status.idle":"2024-03-25T01:01:39.734131Z","shell.execute_reply":"2024-03-25T01:01:39.732917Z","shell.execute_reply.started":"2024-03-25T01:00:13.673183Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","x_input (256, 128, 128)\n","iin (256, 400)\n","Traced<ShapedArray(float32[6,2])>with<DynamicJaxprTrace(level=1/0)>\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"27a910e6ae494f57addc365f80e51b15","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/60 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"}],"source":["grad_params, metrics = gd(SNN, params, shd_dl, epochs=60) # this takes a minute or two to compile on Colab because of weak CPU compute.\n"]},{"cell_type":"code","execution_count":23,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.737814Z","iopub.status.busy":"2024-03-25T01:01:39.737403Z","iopub.status.idle":"2024-03-25T01:01:39.748389Z","shell.execute_reply":"2024-03-25T01:01:39.747242Z","shell.execute_reply.started":"2024-03-25T01:01:39.737774Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["[3.3396416 2.7394361 2.5159357 2.3944805 2.311097  2.259231  2.254243\n"," 2.1969118 2.1640594 2.1198297 2.1289842 2.0941677 2.0898578 2.0560226\n"," 2.0525196 2.020626  2.0091455 1.9951267 1.9801593 1.9889545 1.9905777\n"," 1.9748755 1.9900997 1.9820318 1.9319314 1.9379961 1.9430561 1.9162053\n"," 1.9080309 1.9121706 1.9099082 1.8986979 1.9173098 1.8822697 1.8949358\n"," 1.8759296 1.8963922 1.872345  1.8697561 1.8655033 1.8835618 1.8791912\n"," 1.8660862 1.8646512 1.853204  1.8516091 1.8390594 1.842894  1.8579562\n"," 1.8335865 1.8404154 1.8479518 1.8314093 1.818244  1.8273256 1.8267124\n"," 1.8125165 1.8106669 1.8294351 1.8155215]\n","[0.13346355 0.30013022 0.40429688 0.4811198  0.5286459  0.57682294\n"," 0.5839844  0.6197917  0.6295573  0.6790365  0.66015625 0.69921875\n"," 0.69596356 0.718099   0.7285156  0.74609375 0.76171875 0.765625\n"," 0.7714844  0.7623698  0.75846356 0.780599   0.76627606 0.764974\n"," 0.79752606 0.8046875  0.7727865  0.8072917  0.8092448  0.8170573\n"," 0.8222656  0.8255209  0.8105469  0.8300781  0.82682294 0.8229167\n"," 0.81575525 0.83463544 0.8372396  0.843099   0.8261719  0.83658856\n"," 0.8378906  0.84375    0.85546875 0.8483073  0.86002606 0.85026044\n"," 0.83203125 0.8535156  0.85026044 0.8567709  0.8463542  0.858724\n"," 0.8645834  0.85481775 0.86263025 0.86002606 0.84765625 0.859375  ]\n"]}],"source":["print(metrics[:, 2])\n","print(metrics[:, 1])"]},{"cell_type":"code","execution_count":24,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.749919Z","iopub.status.busy":"2024-03-25T01:01:39.749580Z","iopub.status.idle":"2024-03-25T01:01:40.361273Z","shell.execute_reply":"2024-03-25T01:01:40.360235Z","shell.execute_reply.started":"2024-03-25T01:01:39.749890Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Performance: train_loss=1.655739426612854, val_acc=0.859375, val_loss=1.815521478652954\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACL1ElEQVR4nOzdd3hTZcMG8DtJm6Z70EnpAsooW5aVKUOGIuBgKsuJICgvDvSV4WKoCC4QVNBXEQQE+WQWZCigzDJkFgptoZPS3aZt8nx/PG3a0p2OpO39u65zJTk5OefJqZrbZyqEEAJEREREVOcpTV0AIiIiIqoeDHZERERE9QSDHREREVE9wWBHREREVE8w2BERERHVEwx2RERERPUEgx0RERFRPcFgR0RERFRPMNgRERER1RMMdkRE9cikSZPg7+9fZJ9CocD8+fNNUh4iql0MdkTV4Ny5c3jiiSfg5+cHjUYDb29vDBw4EJ9//nmR4/z9/fHII4+UeI4DBw5AoVBg06ZNhn1r166FQqEwbBqNBo0bN8agQYPw2WefITU1tcJlvHHjBiZPnoxmzZpBo9HA09MTvXv3xrx584z70nXMkSNHMH/+fCQlJdXI+cPDwzF9+nS0aNECNjY2sLGxQVBQEKZNm4azZ8/WyDXNybp167Bs2TJTF4OowbMwdQGI6rojR47gwQcfhK+vL5577jl4enoiMjISf//9N5YvX46XX365ytd49913ERAQgJycHMTExODAgQN45ZVXsHTpUmzbtg3t27cv8/NhYWHo2rUrrK2tMWXKFPj7+yM6OhqnTp3C4sWLsWDBgiqX0dwdOXIECxYswKRJk+Dk5FSt5/79998xevRoWFhYYPz48ejQoQOUSiUuXbqEX3/9FStWrEB4eDj8/Pyq9boVlZmZCQuLmv3P/bp163D+/Hm88sorNXodIiobgx1RFX3wwQdwdHTE8ePHiwWGuLi4arnGkCFD0KVLF8PrOXPm4I8//sAjjzyCRx99FBcvXoS1tXWpn//000+RlpaG0NDQYuGiusoIAOnp6bC1tS3xvYyMDNjY2FTbtczFtWvXMGbMGPj5+WHfvn3w8vIq8v7ixYvx1VdfQaksu4GkrHtXVRqNpkbOS0Tmh02xRFV07do1tGnTpsRaIHd39xq7br9+/fDOO+/g5s2b+PHHH8s89tq1a2jSpEmJNUb3lrG0/lj+/v6YNGmS4XV+M/HBgwfx0ksvwd3dHU2aNAEA9O3bF23btsXJkyfRu3dv2NjY4K233gIgg+QzzzwDDw8PaDQadOjQAd9//32x6925cwdPP/00HBwc4OTkhIkTJ+LMmTNQKBRYu3at4bizZ89i0qRJaNq0qaGJecqUKbhz547hmPnz5+O1114DAAQEBBiatm/cuGE45scff0Tnzp1hbW0NFxcXjBkzBpGRkWXeVwBYsmQJ0tPTsWbNmmKhDgAsLCwwY8YM+Pj4GPZNmjQJdnZ2uHbtGoYOHQp7e3uMHz8eAPDnn3/iySefhK+vL6ysrODj44NXX30VmZmZxc69detWtG3bFhqNBm3btsWWLVtKLGNJf9Nbt25hypQp8PDwgJWVFdq0aYPvvvuuyDH53QN++eUXfPDBB2jSpAk0Gg369++PsLAww3F9+/bF9u3bcfPmTcO9vbefHxHVDtbYEVWRn58fjh49ivPnz6Nt27blHp+Tk4OEhIRi+5OTkyt97aeffhpvvfUW9uzZg+eee67MMu7duxd//PEH+vXrV+nrlOWll16Cm5sb5s6di/T0dMP+O3fuYMiQIRgzZgyeeuopeHh4IDMzE3379kVYWBimT5+OgIAAbNy4EZMmTUJSUhJmzpwJANDr9Rg2bBiOHTuGqVOnolWrVvjtt98wceLEYtcPCQnB9evXMXnyZHh6euLff//FqlWr8O+//+Lvv/+GQqHAY489hitXruDnn3/Gp59+CldXVwCAm5sbAFnr+s4772DUqFF49tlnER8fj88//xy9e/fG6dOny2y6/f3339G8eXN07969UvctNzcXgwYNQs+ePfHxxx8bajM3btyIjIwMTJ06FY0aNcKxY8fw+eefIyoqChs3bjR8fs+ePXj88ccRFBSEhQsX4s6dO5g8ebIhXJclNjYW999/PxQKBaZPnw43Nzfs3LkTzzzzDFJSUoo1py5atAhKpRKzZ89GcnIylixZgvHjx+Off/4BALz99ttITk5GVFQUPv30UwCAnZ1dpe4HEVUTQURVsmfPHqFSqYRKpRLBwcHi9ddfF7t37xbZ2dnFjvXz8xMAytw2btxoOH7NmjUCgDh+/Hip13d0dBSdOnUqs4znz58X1tbWAoDo2LGjmDlzpti6datIT08vdiwAMW/evBLLPnHixGJl69mzp8jNzS1ybJ8+fQQAsXLlyiL7ly1bJgCIH3/80bAvOztbBAcHCzs7O5GSkiKEEGLz5s0CgFi2bJnhOJ1OJ/r16ycAiDVr1hj2Z2RkFCvrzz//LACIQ4cOGfZ99NFHAoAIDw8vcuyNGzeESqUSH3zwQZH9586dExYWFsX2F5acnCwAiBEjRhR77+7duyI+Pt6wFS7nxIkTBQDx5ptvFvtcSd9n4cKFQqFQiJs3bxr2dezYUXh5eYmkpCTDvj179ggAws/Pr8jn7/2bPvPMM8LLy0skJCQUOW7MmDHC0dHRUIb9+/cLAKJ169ZCq9Uajlu+fLkAIM6dO2fY9/DDDxe7LhHVPjbFElXRwIEDcfToUTz66KM4c+YMlixZgkGDBsHb2xvbtm0rdnz37t0REhJSbPv444+Nur6dnV25o2PbtGmD0NBQPPXUU7hx4waWL1+OESNGwMPDA6tXrzbquvmee+45qFSqYvutrKwwefLkIvt27NgBT09PjB071rDP0tISM2bMQFpaGg4ePAgA2LVrFywtLYvUQiqVSkybNq3YdQr3LczKykJCQgLuv/9+AMCpU6fKLf+vv/4KvV6PUaNGISEhwbB5enoiMDAQ+/fvL/WzKSkpAEqunerbty/c3NwM25dfflnsmKlTp5b5fdLT05GQkIAHHngAQgicPn0aABAdHY3Q0FBMnDgRjo6OhuMHDhyIoKCgMr+vEAKbN2/GsGHDIIQo8p0HDRqE5OTkYvdt8uTJUKvVhte9evUCAFy/fr3MaxFR7WNTLFE16Nq1K3799VdkZ2fjzJkz2LJlCz799FM88cQTCA0NLfJj6+rqigEDBhQ7h7GjFtPS0irUl69Fixb43//+B51OhwsXLuD333/HkiVL8PzzzyMgIKDEMlVEQEBAifu9vb2LhAEAuHnzJgIDA4sNJGjdurXh/fxHLy+vYoMtmjdvXuw6iYmJWLBgAdavX19sIEhFmrevXr0KIQQCAwNLfN/S0rLUz9rb2wOQf4N7ff3110hNTUVsbCyeeuqpYu9bWFiU2GwaERGBuXPnYtu2bbh7926R9/K/T/59KqnMLVu2LDPQxsfHIykpCatWrcKqVatKPObe++jr61vktbOzMwAUKx8RmR6DHVE1UqvV6Nq1K7p27YoWLVpg8uTJ2LhxY43NFRcVFYXk5OQSA09pVCoV2rVrh3bt2iE4OBgPPvggfvrpp3KDnU6nK3F/aaNxyxqlW51GjRqFI0eO4LXXXkPHjh1hZ2cHvV6PwYMHQ6/Xl/t5vV4PhUKBnTt3lljzWFZfMUdHR3h5eeH8+fPF3svvc1d4gEZhVlZWxQKuTqfDwIEDkZiYiDfeeAOtWrWCra0tbt26hUmTJlXo+5Qn/xxPPfVUiX0WARSbPqek+wLI2j8iMi8MdkQ1JH96kujo6Bq7xv/+9z8AwKBBg4z6fElldHZ2LjaJb3Z2drV8Dz8/P5w9exZ6vb5IqLl06ZLh/fzH/fv3F5sipfBITEDWGO3btw8LFizA3LlzDfuvXr1a7NoKhaLEMjVr1gxCCAQEBKBFixaV/k4PP/wwvvnmGxw7dgzdunWr9OcLO3fuHK5cuYLvv/8eEyZMMOwPCQkpclz+fSrpe16+fLnMa7i5ucHe3h46nc7oWtqSlHZ/iah2sY8dURXt37+/xJqLHTt2AJBNYzXhjz/+wHvvvYeAgADDVBml+fPPP5GTk1OhMjZr1gyHDh0qctyqVatKrbGrjKFDhyImJgYbNmww7MvNzcXnn38OOzs79OnTB4AMqjk5OUX6/+n1+mL91PJrku69/yWtgJA/R9y9ofWxxx6DSqXCggULip1HCFFk2pSSvP7667CxscGUKVMQGxtb7P3K1GqV9H2EEFi+fHmR47y8vNCxY0d8//33RZqbQ0JCcOHChXKv8fjjj2Pz5s0l1jTGx8dXuLyF2draGjWym4iqF2vsiKro5ZdfRkZGBkaOHIlWrVohOzsbR44cwYYNG+Dv719sAIExdu7ciUuXLiE3NxexsbH4448/EBISAj8/P2zbtq3cCWgXL16MkydP4rHHHjM0s506dQo//PADXFxcikxv8eyzz+LFF1/E448/joEDB+LMmTPYvXu3YYqQqnj++efx9ddfY9KkSTh58iT8/f2xadMmHD58GMuWLTP0WRsxYgS6deuG//znPwgLC0OrVq2wbds2JCYmAiioHXJwcEDv3r2xZMkS5OTkwNvbG3v27EF4eHixa3fu3BmAnJpjzJgxsLS0xLBhw9CsWTO8//77mDNnDm7cuIERI0bA3t4e4eHh2LJlC55//nnMnj271O8UGBiIdevWYezYsWjZsqVh5QkhBMLDw7Fu3ToolcoKTUPSqlUrNGvWDLNnz8atW7fg4OCAzZs3l9iXbeHChXj44YfRs2dPTJkyBYmJifj888/Rpk2bEvv8FbZo0SLs378f3bt3x3PPPYegoCAkJibi1KlT2Lt3r+E+V0bnzp2xYcMGzJo1C127doWdnR2GDRtW6fMQURWZYiguUX2yc+dOMWXKFNGqVSthZ2cn1Gq1aN68uXj55ZdFbGxskWP9/PzEww8/XOJ58qeWKGm6k/xNrVYLT09PMXDgQLF8+XLD9CDlOXz4sJg2bZpo27atcHR0FJaWlsLX11dMmjRJXLt2rcixOp1OvPHGG8LV1VXY2NiIQYMGibCwsFKnOylpKpY+ffqINm3alFiW2NhYMXnyZOHq6irUarVo165dkelL8sXHx4tx48YJe3t74ejoKCZNmiQOHz4sAIj169cbjouKihIjR44UTk5OwtHRUTz55JPi9u3bJU7b8t577wlvb2+hVCqLTX2yefNm0bNnT2FraytsbW1Fq1atxLRp08Tly5fLv8FCiLCwMDF16lTRvHlzodFohLW1tWjVqpV48cUXRWhoaJFjJ06cKGxtbUs8z4ULF8SAAQOEnZ2dcHV1Fc8995w4c+ZMsWle8svcunVrYWVlJYKCgsSvv/4qJk6cWO50J0LIv8O0adOEj4+PsLS0FJ6enqJ///5i1apVhmNK+mdSCCHCw8OLlSctLU2MGzdOODk5lTjlChHVDoUQ7P1KRHXD1q1bMXLkSPz111/o0aOHqYtDRGR2GOyIyCxlZmYWGVmr0+nw0EMP4cSJE4iJiam1UbdERHUJ+9gRkVl6+eWXkZmZieDgYGi1Wvz66684cuQIPvzwQ4Y6IqJSsMaOiMzSunXr8MknnyAsLAxZWVlo3rw5pk6diunTp5u6aEREZovTnRCRWRo3bhxOnjyJ5ORkaLVa/Pvvvwx1RFRjDh06hGHDhqFx48ZQKBTYunVruZ85cOAA7rvvPlhZWaF58+ZYu3ZtjZezPAx2RERE1OClp6ejQ4cOJa7rXJLw8HA8/PDDePDBBxEaGopXXnkFzz77LHbv3l3DJS0bm2KJiIiIClEoFNiyZQtGjBhR6jFvvPEGtm/fXmSi7zFjxiApKQm7du2qhVKWrE4PnsjNzcXp06fh4eFRbM1FIiIiarj0ej0iIiIQFBQEC4uCuGNlZQUrK6sqn//o0aPFluUbNGhQkQnfTaFOB7vTp09XeW1GIiIiajjmzZuH+fPnV/k8MTEx8PDwKLLPw8MDKSkpxaZrqk11Otjl39Bjx47By8vLxKUhIiIicxEdHY1u3brh/Pnz8PHxMeyvjto6c1ang11+86uXl1eF1mEkIiKihsXR0REODg7Vfl5PT0/ExsYW2RcbGwsHBweTzrXJjmlERERElRQcHIx9+/YV2RcSEoLg4GATlUhisCMiIqIGLy0tDaGhoQgNDQUgpzMJDQ1FREQEAGDOnDmYMGGC4fgXX3wR169fx+uvv45Lly7hq6++wi+//IJXX33VFMU3YLAjIiKiBu/EiRPo1KkTOnXqBACYNWsWOnXqhLlz5wKQffbyQx4ABAQEYPv27QgJCUGHDh3wySef4JtvvsGgQYNMUv58dXoeu6ioKPj4+CAyMrLMPnY6nQ45OTm1WDKqDpaWllCpVKYuBhFRqfj7Yjrl/UZUNCPUN3V68ER5hBCIiYlBUlKSqYtCRnJycoKnpycUCoWpi0JEZMDfF/PA34ji6nWwy/+Xzt3dHTY2NvzD1yFCCGRkZCAuLg4AOJ0NEZkV/r6YFn8jSldvg51OpzP8S9eoUSNTF4eMkD9cPC4uDu7u7myWJSKzwN8X88DfiJLV28ET+X0ebGxsTFwSqor8vx/7sBCRueDvi/ngb0Rx9TbY5WP1eN3Gvx8RmSv+98n0+Dcort4HOyIiIqKGgsGuAfD398eyZctMfg4iIqrb+Ftg/urt4Im6rG/fvujYsWO1/ctz/Phx2NraVsu5iIiIyHwx2NVRQgjodDpYWJT/J3Rzc6uFEhEREZGpsSnWzEyaNAkHDx7E8uXLoVAooFAocOPGDRw4cAAKhQI7d+5E586dYWVlhb/++gvXrl3D8OHD4eHhATs7O3Tt2hV79+4tcs57q84VCgW++eYbjBw5EjY2NggMDMS2bdsqVc6IiAgMHz4cdnZ2cHBwwKhRoxAbG2t4/8yZM3jwwQdhb28PBwcHdO7cGSdOnAAA3Lx5E8OGDYOzszNsbW3Rpk0b7Nixw/ibRkREZVq1ahUaN24MvV5fZP/w4cMxZcoUAKjQ70l5jh8/joEDB8LV1RWOjo7o06cPTp06VeSYpKQkvPDCC/Dw8IBGo0Hbtm3x+++/G94/fPgw+vbtCxsbGzg7O2PQoEG4e/eukd+84TFpsJs/f74hvORvrVq1qrHrCSGQkZ1b61tlVm1bvnw5goOD8dxzzyE6OhrR0dHw8fExvP/mm29i0aJFuHjxItq3b4+0tDQMHToU+/btw+nTpzF48GAMGzasyHp2JVmwYAFGjRqFs2fPYujQoRg/fjwSExMrVEa9Xo/hw4cjMTERBw8eREhICK5fv47Ro0cbjhk/fjyaNGmC48eP4+TJk3jzzTdhaWkJAJg2bRq0Wi0OHTqEc+fOYfHixbCzs6vwPSIiMitCAOnpptkq+Pvy5JNP4s6dO9i/f79hX2JiInbt2oXx48cDgNG/J4WlpqZi4sSJ+Ouvv/D3338jMDAQQ4cORWpqKgD5+zFkyBAcPnwYP/74Iy5cuIBFixYZ5qALDQ1F//79ERQUhKNHj+Kvv/7CsGHDoNPpKlyGhs7kTbFt2rQp8n8EFWlaNFZmjg5Bc3fX2PlLc+HdQbBRV+x7OTo6Qq1Ww8bGBp6ensXef/fddzFw4EDDaxcXF3To0MHw+r333sOWLVuwbds2TJ8+vdTrTJo0CWPHjgUAfPjhh/jss89w7NgxDB48uNwy7tu3D+fOnUN4eLghdP7www9o06YNjh8/jq5duyIiIgKvvfaaIagHBgYaPh8REYHHH38c7dq1AwA0bdq03GsSEZmtjAzAVP9zmpYGVKAPtbOzM4YMGYJ169ahf//+AIBNmzbB1dUVDz74IACgQ4cORv2eFNavX78ir1etWgUnJyccPHgQjzzyCPbu3Ytjx47h4sWLaNGiBYCivwFLlixBly5d8NVXXxn2tWnTpkLXJsnkTbEWFhbw9PQ0bK6urqYuklnr0qVLkddpaWmYPXs2WrduDScnJ9jZ2eHixYvl/h9W+/btDc9tbW3h4OBgWJqlPBcvXoSPj0+RmsSgoCA4OTnh4sWLAIBZs2bh2WefxYABA7Bo0SJcu3bNcOyMGTPw/vvvo0ePHpg3bx7Onj1boesSEZHxxo8fj82bN0Or1QIAfvrpJ4wZMwZKpYwCxv6eFBYbG4vnnnsOgYGBcHR0hIODA9LS0gznCA0NRZMmTQyh7l75NXZkPJPX2F29ehWNGzeGRqNBcHAwFi5cCF9f3xq5lrWlChfeHVQj5y7vutXl3tGts2fPRkhICD7++GM0b94c1tbWeOKJJ5CdnV3mefKbRfMpFIpifS+qYv78+Rg3bhy2b9+OnTt3Yt68eVi/fj1GjhyJZ599FoMGDcL27duxZ88eLFy4EJ988glefvnlars+EVGtsbGRNWemunYFDRs2DEIIbN++HV27dsWff/6JTz/91PC+sb8nhU2cOBF37tzB8uXL4efnBysrKwQHBxvOkb8MWGnKe5/KZ9Jg1717d6xduxYtW7ZEdHQ0FixYgF69euH8+fOwt7cvdrxWqzX8nwYAQ5t9RSkUigo3iZqSWq2ucH+Cw4cPY9KkSRg5ciQA+X9cN27cqMHSAa1bt0ZkZCQiIyMNtXYXLlxAUlISgoKCDMe1aNECLVq0wKuvvoqxY8dizZo1hnL6+PjgxRdfxIsvvog5c+Zg9erVDHZEVDcpFBVqDjU1jUaDxx57DD/99BPCwsLQsmVL3HfffYb3q+P35PDhw/jqq68wdOhQAEBkZCQSEhIM77dv3x5RUVG4cuVKibV27du3x759+7BgwQIjviEBJm6KHTJkCJ588km0b98egwYNwo4dO5CUlIRffvmlxOMXLlwIR0dHw1Y4RNQn/v7++Oeff3Djxg0kJCSUWZMWGBiIX3/9FaGhoThz5gzGjRtXrTVvJRkwYADatWuH8ePH49SpUzh27BgmTJiAPn36oEuXLsjMzMT06dNx4MAB3Lx5E4cPH8bx48fRunVrAMArr7yC3bt3Izw8HKdOncL+/fsN7xERUc0ZP348tm/fju+++84waCJfdfyeBAYG4n//+x8uXryIf/75B+PHjy9SC9enTx/07t0bjz/+OEJCQhAeHo6dO3di165dAIA5c+bg+PHjeOmll3D27FlcunQJK1asKBIOqWwm72NXmJOTE1q0aIGwsLAS358zZw6Sk5MN24ULF2q5hLVj9uzZUKlUCAoKgpubW5n9G5YuXQpnZ2c88MADGDZsGAYNGlTk/8BqgkKhwG+//QZnZ2f07t0bAwYMQNOmTbFhwwYAgEqlwp07dzBhwgS0aNECo0aNwpAhQwz/B6bT6TBt2jS0bt0agwcPRosWLYp0lCUioprRr18/uLi44PLlyxg3blyR96rj9+Tbb7/F3bt3cd999+Hpp5/GjBkz4O7uXuSYzZs3o2vXrhg7diyCgoLw+uuvG1qpWrRogT179uDMmTPo1q0bgoOD8dtvv9XowMr6RiEqMxdHDUtLS4Ovry/mz5+PGTNmlHt8VFQUfHx8EBkZiSZNmhR5LysrC+Hh4QgICIBGo6mpIlMN49+RiMwN/7tkPsr6W5SVEeozk9bYzZ49GwcPHsSNGzdw5MgRjBw5EiqVyjANBxERERFVnEnrNqOiojB27FjcuXMHbm5u6NmzJ/7++28ugUVERERkBJMGu/Xr15vy8kRERET1ilkNniAiIiIi4zHYEREREdUTDHZERERGqOk5Q6l8/BsUx4lhiIiIKkGtVkOpVOL27dtwc3ODWq2GQqEwdbEaFCEEsrOzER8fD6VSCbVabeoimQ0GOyIiokpQKpUICAhAdHQ0bt++beriNGg2Njbw9fWFUskGyHwMdkRERJWkVqvh6+uL3NzcCq/tTdVLpVLBwsKCtaX3YLArRWZ2Lm4nZ8FSqYBvI/Nf3Ple/v7+eOWVV/DKK6+U+P6kSZOQlJSErVu31mq5iIjqC4VCAUtLS1haWpq6KEQGDHal0AsgXZsLtYrVu0RERFQ3MLWUQqWUVbs681lKl4iIiKhMDHalyA92er2AqMVwt2rVKjRu3LjYEO7hw4djypQpAIBr165h+PDh8PDwgJ2dHbp27Yq9e/dW6bparRYzZsyAu7s7NBoNevbsiePHjxvev3v3LsaPHw83NzdYW1sjMDAQa9asAQBkZ2dj+vTp8PLygkajgZ+fHxYuXFil8hAREVHlNaymWCGAnIwKHarSCyjyjtVrLQxBzyiWNkAFO3c++eSTePnll7F//370798fAJCYmIhdu3Zhx44dAIC0tDQMHToUH3zwAaysrPDDDz9g2LBhuHz5Mnx9fY0q4uuvv47Nmzfj+++/h5+fH5YsWYJBgwYhLCwMLi4ueOedd3DhwgXs3LkTrq6uCAsLQ2ZmJgDgs88+w7Zt2/DLL7/A19cXkZGRiIyMNKocREREZLyGFexyMoAPG1foUCWAdtV13bduA+qKDcBwdnbGkCFDsG7dOkOw27RpE1xdXfHggw8CADp06IAOHToYPvPee+9hy5Yt2LZtG6ZPn17p4qWnp2PFihVYu3YthgwZAgBYvXo1QkJC8O233+K1115DREQEOnXqhC5dugCQgzPyRUREIDAwED179oRCoYCfn1+ly0BERERVx6ZYMzR+/Hhs3rwZWq0WAPDTTz9hzJgxhnl60tLSMHv2bLRu3RpOTk6ws7PDxYsXERERYdT1rl27hpycHPTo0cOwz9LSEt26dcPFixcBAFOnTsX69evRsWNHvP766zhy5Ijh2EmTJiE0NBQtW7bEjBkzsGfPHmO/OhEREVVBw6qxs7SRtWcVdDk2Fdm5ejR1tYWtVRVulaVNpQ4fNmwYhBDYvn07unbtij///BOffvqp4f3Zs2cjJCQEH3/8MZo3bw5ra2s88cQTyM7ONr6M5RgyZAhu3ryJHTt2ICQkBP3798e0adPw8ccf47777kN4eDh27tyJvXv3YtSoURgwYAA2bdpUY+UhIiKi4hpWsFMoKtwkCgBKtR5CoYPOwgZQ1948RRqNBo899hh++uknhIWFoWXLlrjvvvsM7x8+fBiTJk3CyJEjAcgavBs3bhh9vWbNmkGtVuPw4cOGZtScnBwcP368yDx4bm5umDhxIiZOnIhevXrhtddew8cffwwAcHBwwOjRozF69Gg88cQTGDx4MBITE+Hi4mJ0uYiIiKhyGlawqyTDyFgTTHkyfvx4PPLII/j333/x1FNPFXkvMDAQv/76K4YNGwaFQoF33nmnSgsh29raYurUqXjttdfg4uICX19fLFmyBBkZGXjmmWcAAHPnzkXnzp3Rpk0baLVa/P7772jdujUAYOnSpfDy8kKnTp2gVCqxceNGeHp6wsnJyegyERERUeUx2JXBMJedvvaDXb9+/eDi4oLLly9j3LhxRd5bunQppkyZggceeACurq544403kJKSUqXrLVq0CHq9Hk8//TRSU1PRpUsX7N69G87OzgDk8jlz5szBjRs3YG1tjV69emH9+vUAAHt7eyxZsgRXr16FSqVC165dsWPHDq7dR0REVMsUojYnaatmUVFR8PHxQWRkJJo0aVLkvaysLISHhyMgIAAajcao80cmZuBuRjY8HTVwtzfuHFQ11fF3JCKihqesjFCfsUqlDKassSMiIiKqLAa7MigLrT5BREREZO4Y7MqgUuSvF2vighARERFVAINdGdgUS0RERHUJg10ZVHnLu7IploiIiOqCej/dSVXmd8vvY6eruwOH67yq/P2IiBqk9HTg4EFg3z7AxQV4/nnAzc3UpaJaUm+DnVqthlKpxO3bt+Hm5ga1Wg1FXp+5isrNzoXIzUaOXomsrNpbeYIAIQSys7MRHx8PpVIJtVpt6iIREZknIYALF4Bdu+T2559A3lrjAIAPPgCeeQb4z38Af//yz3fnDrB+PfDjj/K5v3/Jm6cnUNX5SoWQq0JRtam3wU6pVCIgIADR0dG4fbvi68MWlqvTIy5FC6UCUKZbV3MJqSJsbGzg6+vLyY6JqOKEADZuBBYuBJo1A15/HejWzdSlql5CALt3A5s3yzAXFVX0fT8/4KGHgNOngRMngC++AFasAMaOlfejXbuix+fmyvOtXQts2wYUXnv86tWSy6BWA8HBwEcfAV27Vq786enAxx8D//wDbN/OcFeN6u0ExfmEEMjNzYVOp6v0+e+mZ+OJlUcAAHte7WMYTEG1Q6VSwcLCotI1rURUT6SlyfBQmRr7v/8GZs0Cjh4tuv/BB4E33wQGDjR9iMjOlk2lu3cDjRsDzz0H2NtX/POXLgEzZgAhIQX7NBqgb19g8GC5tWghv6cQwP79wKJFRY9/5BHgjTcAJycZ5n78EYiNLXi/Y0dg0iSgfXvg5k253bhRsEVGAvm/qwoF8OyzwIcfAq6uZZddrwd++AF4+20gv9IlJAQYMKDi37+CGuoExRB1WGRkpAAgIiMja+T8WTm5wu+N34XfG7+LpIzsGrkGERHd4/ZtIZ55RgiFQggnJyGmTBFizx4hcnJK/0x4uBBjxggho4wQNjZCvPOOEJMmCWFhUbC/Uych1q8XIje36uXcvVuIX38V4sIFIbTaso9NThZiwwYhxo4VwtGxoDyAEC4uQnz4oRApKWWfIyVFiNdeK/g+arUQL70kxM6dQmRklF/eEyeEGDVKCKWy6PXzNzc3IV55RYjTp8s/V06OEJcvC/H00wWfd3YW4osvSv877d8v73/+8QEBQvzyixB6ffnXM0JNZwRzxWBXjhZv7xB+b/wuIhPTa+waREQkhEhPF+Ldd4WwtS09eLz0khCHDgmh08nPJCUJ8cYbQlhZyWMUChkEb90qOG9EhAwsNjYF52rWTIiVK4XIzDSurB9+WLRsKpUQLVoI8eijQrz+uhDffSfEn38K8fXXQgwZIkNY4eM9PISYPFl+pnDA++ADGQIL0+uF+PFHIby8Co595BEhrl41ruxXrgjx/POyTBYWQowcKcRvvwmRbWQFxp9/CtGhQ0HZOnSQ+/JdvizE8OEF7zs4CPHRR0JkZRl3vQpisKuDauOP1vm9EOH3xu/i31vJ5R9MRESVp9MJ8cMPQnh7F/z4d+8uw8H+/UK88IIQjRoVDUbe3kI8+6wQrq4F+/r1K7u2KSFBiPnzZYDK/0ybNkLcvFm58i5dWvTzpQXRe7fAQBn6jhwpCKa5uTK0lRbwQkOF6NWraCD9/Xdj73RRKSkyGFeH3FwhvvxS1trll3X8eCFmziyoYVSphJg2TYi4uOq5ZjkY7Oqg2vijPfjRfuH3xu/i72sJNXYNIqIG6+BBITp3LggDfn5C/Pxz8ea57GzZ5DhpkqzxKRyYWrYU4v/+r+JNemlpQixfLmvNAFkTdupUxT77xRcF150/X+7T64WIjBQiJES+P326EAMGCOHrK0S3brJ278KFsstXUsBzdCxoNrWxkWHP2BrG2hIfL2sDFYqif6OHH5b3oBY11GBX7wdPVNXwL/7CmahkfDOhCwYEedTINYiIat2NG3KgQb9+gLt77V47IUF2mF+/Xo7ABOTggbffBmbOlAMBypKVJQce7NkjR3c+8wxgacSUVBERwNChwL//Ara2ciTtkCGlH//NN3KgAyAHYnz4YfUPxNDpgA0bgHffBS5flvtGjZIjSH18qvdaNenECeC114CMDOD99+WglVrWUAdP1NvpTqqLg7X8j0WqNsfEJSEiqoLMzIKRmLt2yZGVAODlBWzZAnTvXnPXzs0Fjh8vmGft+HFZjwPIedBeeAGYP7/iAVOjAYYPl1tV+PoCf/0FPP448McfwLBhckqQ/PBW2A8/yIl+AeDVV2sm1AGASgWMGweMHg38/rscZdqjR/Vfp6Z16SJH41KtY7Arh71G3qKUzFwTl4SIqBK0Wjn/2N69MkwdPChruvKpVHJVguhooHdvYOVKYPJk466VkwMkJ8stKalgi4sDDhyQtXN37xb9TLt2clqOSZOAoCDjrlsdnJyAnTtlmMsPbzduyFqm/OC2YYO8N0IA06YBn3xS81OmqFRVD67UIDHYlcPeKq/GLos1dkRkZiIjZc1b4fnF8rfo6IJasXxNmhTMc9a/vwwPEyfKGrspU4AzZ2STn0U5Pw2ZmcDq1cBXX8mJcdPTyy+rs7Nsjhs8WE6c6+1t1FeuEWq1nMvN3182gX74oZy37dtvgR07gPHj5fxrzz4LfPaZ6efBIyoDg1058mvsUrNYY0dEZkII4J135FJRZbGxkc14gwcDgwbJmrF7Q8mmTcB778mm0OXLgXPngF9+ARo1Kn6+zExg1So52W1MTPH37exkDZijo3x0cpJNcoMGyZUJyguMpqRQAAsWyBUbXngB+OknGZrPnpX93p5+Gvj666ovoUVUw8z43zLzkN/HLoXBjogKy8yUTYwODkCrVoCHR+3U5OTmyuDx3XfydevWQEBAyWt5urqWXyalEpg3D+jQQYaXP/6QIWzrVrnqACC/69dfA4sXFwQ6X1/grbfkigH5Yc6cg1tFTZkiazafeAI4eVLuGz1a3m+GOqoD6sG/hTWroMaOTbFElCcxUY6ePHasYJ+jI9CypQx5hbfAwOoLPBkZwJgxwP/9nwwZX38tmwerw4gRchmu4cOB69flGqCrV8t+coUDnZ+fHL06cWLllvqqSx56CPjzTznatlMn2eRcH0IrNQj8J7Uc9hrW2BHVG+npwJUrsont0iXZwf/ZZ4sviF6W27flD/+//8ow5+Ymg1Bysgx6hcMeIEdwtm0r197M39q3r9zaoIAMk8OGAUeOyHOuX1/9nevbtpUjVkePloMuxo8veK8hBLrCOnSQU3YQ1TEMduVgjR1RHaTXy75RR48WhLhLl+S8Zff6+mvgo4+A6dPLb7YMD5dNj9evy8XbQ0JkvzWtFggLK3qt/C0tTQaEe0NC8+Yy5D38sKwtc3Iq/bqRkbKf3IUL8rj/+z+gZ8/K3ZOKcnGRo0Rffx349NOGF+iI6jhOUFyOo9fuYOzqv9Hc3Q57Z/WpkWsQURXlB7kDB+R26FDx6TXyuboWNJPevCnDGSAnql2zpvS51P79V47qjI4GmjaVNVoBAeWXKzwcCA0tukVFFT1OrZZNu6NHy1o5O7uC9y5ckIMPoqLkSNJdu2TNWm2IipJ9B42Z/JfIxDhBMZWINXZEZurmTTlNR2lBzs4OeOAB2eyZH+RatpTBLp8QwBdfyBnyd+yQx37/vQxShR0/LmvMEhNlqNqzR07sWx6lEmjWTG6PP16wPyFBTi1y+LBc7eD8eeC33+RmbS3D3ejRcoqQxx+X361VKzm5sK+v0bes0hrQjyFRfcEau3JE3MlA74/2w9pShYvvDa6RaxBRBaWnA7/+Kucc++OPou/Z2QG9egF9+8rtvvsq3uH93Dlg7FhZKwfIlQUWLgSsrOTs+Y8+KptUu3eXAdDFpRq/FGSw27BB9psLCyv+/v33y1UISpqChIhKxBo7KlF+jV1mjg45Oj0sVRzuTlSrhJAjFNeulbVbaWkF7/XtK5swKxvk7tWunayVe/11WYP36acyOD7/PDBrluxD16+frFEr3ExaXdq2ldu77wKnTsmAt2GD7Fv38MPyua1t9V+XiOodBrty5Ac7AEjLyoWzLTsPE9UYrRaIjZVTa8TEAKdPy2Werl8vOKZpU7kM1dNPy7naqou1NfD557IZdvJk2VQ6bZp8b/hwGbbKW5y+qhQKoHNnuS1eLPvnNW3KlQ6IqMJY/VQOC5USNmoVAK4+QVStLl+WIy0ffFBOsuvsLIOTn59s8hw+XK6GcP26nBrkmWdkzV1YmFx1oTpDXWGPPCIHYgwcKF8//bSsKazpUHev/P55DHVEtebLL7+Ev78/NBoNunfvjmP3Tl90j2XLlqFly5awtraGj48PXn31VWQVXpPZBFhjVwH2GgtkZOuQwgEURFJCArB5swxdc+aUPVVHSbKyZBPjtWvF31OrAU9PORrTxwcYOVJutdkU6eUlByrcuiVHojJcEdV7GzZswKxZs7By5Up0794dy5Ytw6BBg3D58mW4lzBaft26dXjzzTfx3Xff4YEHHsCVK1cwadIkKBQKLF261ATfQGKwqwB7jSViU7QMdtSwJSXJZabWr5dTfeh0cn9UlFxXszIWL5ahrnFjOYecl5cMc56eMiSaQ5BSKDgqlKgBWbp0KZ577jlMnjwZALBy5Ups374d3333Hd58881ixx85cgQ9evTAuHHjAAD+/v4YO3Ys/vnnn1ot973YFFsBDoYpT9gUSw1MWhrw88+yWdTDQ/Y9271bhrpOnWRz4bp1csLcirp2TY44BeQghXHjijbHmkOoI6J6IzU1FSkpKYZNq9UWOyY7OxsnT57EgAEDDPuUSiUGDBiAo0ePlnjeBx54ACdPnjQ0116/fh07duzA0KFDa+aLVBCDXQXkLyvGYEcNyurVcrLeceOAbduA7Gy5ysJ778lluU6dAmbPlse++KKs0SuPEMCMGXKQxIABwJNP1uhXICIKCgqCo6OjYVuY/z+WhSQkJECn08HDw6PIfg8PD8Tkr5N8j3HjxuHdd99Fz549YWlpiWbNmqFv37546623auR7VBSbYisgf2RsSiabYqmBuHBBjgjNyZEd+MeMkdu9Kx7Mny8nCb56VYa8b74p+7y//SbngbO0lNOKsHaOiGrYhQsX4O3tbXhtZWVVLec9cOAAPvzwQ3z11Vfo3r07wsLCMHPmTLz33nt45513quUaxmCwqwDW2FGDotcDzz0nQ93DD8tm1tICmLU18O23QO/e8nH06ILRpPdKTwdmzpTPX3tNrgJBRFTD7O3t4eDgUOYxrq6uUKlUiI2NLbI/NjYWnp6eJX7mnXfewdNPP41nn30WANCuXTukp6fj+eefx9tvvw2l0jSNomyKrQAHay4rRg3IypXAkSNyIt4VK8qvVevVC5g+XT5/7rmiEwgX9uGHQESEXBLLxE0VRESFqdVqdO7cGfv27TPs0+v12LdvH4KDg0v8TEZGRrHwplLJ6dFMuagXg10FOLDGjhqKyEggf/TXokVyupGKWLhQzj9382bJoe3yZTn6FQCWL+cqCkRkdmbNmoXVq1fj+++/x8WLFzF16lSkp6cbRslOmDABc+bMMRw/bNgwrFixAuvXr0d4eDhCQkLwzjvvYNiwYYaAZwpsiq0AQx871thRfSYE8NJLQGoqEBwMTJ1a8c/a2cnBFg89JPvOjRoF9OxZcN7p02XT7tChcoQtEZGZGT16NOLj4zF37lzExMSgY8eO2LVrl2FARURERJEauv/+979QKBT473//i1u3bsHNzQ3Dhg3DBx98YKqvAABQCFPWF1ZRbS3wu+V0FF7dcAY9m7vix2e719h1iColNlaukNC/v5x2pKo2bJADJCwtgdBQOQK2sp55BvjuO6BFC3kOa2vgl19k3zsrK+Dff+VgDCKiGlZbGcHcsCm2AgqaYlljR2YiPFwuev/QQ3LakIiIqp3vzh3g5Zfl87ffNi7UAcAnn8jJhq9cARYskLV/r74q35szh6GOiKiGMdhVAEfFklm5fVuGudu35ev9+4F27YDvv5fNnsaYPRuIj5eBroQZ1ivMyUkOvgBkn7rx42U5mzYFXn/d+PMSEVGFMNhVAPvYkdlISJDTiVy/LsPSwYOyP1xKCjBpklxTNS6ucufcuxdYu1aOfv3mG9lkWhWPPgqMHSunTclfkeLzz2WzLBER1SgGuwooCHassaNyCAFcugQsWwYMHiwHEKxeDWRkVP3cKSnynBcuyIXp9+6V88f9+acclWppKScAbttWThpcERkZwPPPy+fTp8uQWB2WLwdcXeXzESPkoAkiIqpxDHYV4GAtm2Kzc/XQ5upMXBoyOykpwNatclmtgAC55umrr8o1VQ8flsHJx0dOA3LrlnHXyMgAhg0DTp6UgSkkRF4LAFQq2Xx6/Lhsko2PBx57DJg4EUhOLvu88+bJ/no+PkB1juRycwM2b5a1iCtWVN95iYioTJzupALs1BZQKGRlTGpWLqzsTDc/DZmYXi+DUGio3P78U4a33EK1uWq1rEkbPFi+/uIL4MYNWav20UdyfdRXXgG6davYNbOzgSeeAA4dAhwcZGBs3br4cR06yHA3fz6wZAnwww/A77/LAOjkVHxTqYClS+VnV6wA7O2NuSOl691bbkREVGvMJtgtWrQIc+bMwcyZM7Fs2TJTF6cIpVIBO7UFUrW5SMnMgatd9awzR2YuNxc4c6YgxIWGytepqcWPDQyUQW7wYKBPn6IT8L7yCrBtm2yePHgQ+Plnud1/v6zlCw4GmjcvecoSnQ546ilg507ZR237djkatjRWVjJADhsGTJgAXLsGJCaW/T3HjpVLhxERUZ1nFsHu+PHj+Prrr9G+fXtTF6VU9hoZ7DgytoE4d05OsnvpUvH3rKxkP7aOHYEuXeSUI02bln4ulUoOahg5Ejh9Wga8n38G/v5bboAMgu3by3Pmb23aADNmABs3yv5zW7YUTPpbngcekHPGnTwJ3L0LJCWVvGk0sj8gERHVCyYPdmlpaRg/fjxWr16N999/39TFKZWDtSVuJ2cx2NV3QsjF7F9+GcjKkk2fXbsWDVwtW8qgZYxOneQI1MWL5bQg27fLEJmeDhw9Krd7KZXA+vXAoEGVu5aVlQx4RETUYJg82E2bNg0PP/wwBgwYUG6w02q10Gq1htepJTWJ1ZD8kbGcpLgeS02VTaPr1snXQ4fKueHyR3dWJw8POXBh3jzZ5Hv1atEm39BQOW2JQiFXcnjsseovAxER1TsmDXbr16/HqVOncPz48Qodv3DhQixYsKCGS1Wy/EmKOZddPXX2rBzUcOWKbDr98EM5aW91LNVVHgsLORiidWvZ3y1fTIysNfT3r/kyEBFRvWCy6U4iIyMxc+ZM/PTTT9BoNBX6zJw5c5CcnGzYLly4UMOlLFBQY8em2HpFCGDVKqB7dxnqmjSRAxxef712Ql1ZPD0Z6oiIqFJMVmN38uRJxMXF4b5CI/x0Oh0OHTqEL774AlqtFipV0WlFrKysYFVoVvyUlJRaK6+DocaOwa7eSE0FXnhBDmQAarbplYiIqBaYLNj1798f586dK7Jv8uTJaNWqFd54441ioc7U2Meunrl2TU4JcvGibHpduBD4z39MX0tHRERUBSYLdvb29mjbtm2Rfba2tmjUqFGx/ebA0McukzV2dd6hQ3Iwwp07cmmuX37h6FEiIqoXWD1RQayxqyfWrgUGDJChrmtXuVIDQx0REdUTJp/upLADBw6Yugilyl8vloMn6ii9Xq7VunixfD1qlAx51tYmLRYREVF1Yo1dBRlq7LSssatz0tOBxx8vCHXvvCMHTDDUERFRPWNWNXbmzCEv2LGPXR0TFQU8+qhcykutlpP9jh9v6lIRERHVCAa7CsofPME+dnXIP//I9VmjowE3N2DrVvanIyKieo1NsRXkoCnoYyeEMHFpqExnzwJPPAHcf78MdW3aAMeOMdQREVG9x2BXQfl97HL1Alk5ehOXhkp05ozsS9ehA7B5s1xndfx44MgRruBAREQNAoNdBdmoVVApFQC4XqzZyQ90HTsCv/4qA92YMcD588CPPwIODqYuIRERUa1gsKsghUIBOyvOZWdWLlwoPdD9/DMQFGTqEhIREdUqDp6oBAdrCyRn5nC9WHPwzz9A//5yKhOFAhg9Wk5jwjBHREQNGINdJdhbWQLI5CTFpnb2LDBkiAx1vXsDK1Yw0BEREYHBrlLsDXPZsSnWZK5eBR56CLh7FwgOBnbsAGxtTV0qIiIis8A+dpVgr+GyYiYVESHXeY2NlSNfGeqIiIiKYLCrBAdrDp4wmdhYYOBAGe5atAD27AGcnExdKiIiIrPCYFcJDqyxM427d2Xz65UrgK8vsHcv4O5u6lIRERGZHQa7SjD0sWONXfXQ64HMzLKPSUsDhg6VAyY8PGSo8/GpnfIRERHVMRw8UQn5wY41dtVAqwW6dZOBzdcXaNWqYGvZUj66uAAjRgB//w04OwMhIUBgoKlLTkREZLYY7CqhoCmWNXZV9vXXMtQBst9cRITsN1eYpSWQkyMHSOzcCbRrV/vlJCIiqkMY7Cohf1QsJyiuotRU4P335fNPPgG6dwcuXSq6Xb8uQ51GA/zf/8ljiIiIqEwMdpXAeeyqySefAPHxsln15ZdlzVyPHkWP0WqBsDC5ziv71BEREVUIg10lsI9dNYiLk8EOAD74QIa6klhZAW3a1F65iIiI6gGOiq0EB2v2sauyDz6QI127dAGeeMLUpSEiIqpXGOwqIb/GLk2bC71emLg0dVB4uFzXFQAWLQIUCtOWh4iIqJ5hsKuE/FGxegGkZ7M5FleuyIEOFTV3rhwQMWAA0L9/zZWLiIiogWKwqwQrCyUsVbKWqcH3s7tzRzantm8P/Pxz+cefPQv89JN8vmhRzZaNiIiogWKwqwSFQsFlxfJ9+62ctiQnBxg3Dli2rOzj58wBhABGjQI6d66VIhIRETU0DHaVVDAytgEPoNDpgK++ks+7dZOPr74KvPmmDG/3OnQI2LEDUKkK5q8jIiKiasdgV0kFkxQ34GC3fTtw86Zc8uvAgYKm1cWLgcmTZS1ePiFk4AOAZ5/lkmBEREQ1iMGukjiXHYAvvpCPzz4LWFsDb7wBrFkja+S+/16u75qeLo/Ztg04elQeN3euyYpMRETUEDDYVZJDQ19W7NIlICRETlUydWrB/kmTgN9+kwFuxw456jUuDnjrLfn+K68AjRubosREREQNBoNdJTX4Pnb5feuGDQP8/Yu+9/DDwL59son2n3+AVq2ACxcAZ2fg9ddrvahEREQNDYNdJRn62GU2wBq71FRg7Vr5fPr0ko8JDgb++kuu73r3rtw3Zw7g5FQbJSQiImrQuFZsJTXoGrv//U+Gu5Yty55guHVr4MgRYPx4OXiitBBIRERE1YrBrpIK1ottYDV2QhQMmpg2DVCWU9nbpAlw8GDNl4uIiIgM2BRbSQ22xm7/fuDiRcDODpg40dSlISIiohIw2FWSQ16wa3CjYvNr6yZMABwcTFsWIiIiKhGDXSXZG5YUa0A1dhERcioTQDbDEhERkVlisKukBrlW7MqVgF4P9OsHBAWZujRERERUCga7SmpwK09kZQGrV8vnrK0jIiIyawx2lZQf7NK0udDpS1jwvr755RcgIUGOcn30UVOXhoiIiMrAYFdJ+X3sACCtIdTa5Q+amDoVsODsOEREROaMwa6S1BZKaCzlbUup7wMojh0Djh8H1Grg2WdNXRoiIiIqB4NdaaLPApueAX5/tdhb9g1lAEV+bd3o0YC7u2nLQkREROVisCtNbhZwfhNwaXuxt+wNc9nVwxo7IYC9e4GBA+USYgCXBCMiIqoj2GmqNO5BABRAWiyQFg/YuRneqpc1djodsGULsGgRcPKk3KdSAa++CnTrZtqyERERUYWwxq40VnaAS1P5PPZckbcc6tOyYlot8M03QOvWwJNPylBnbQ28/DIQFgZ89JGpS0hEREQVxBq7sni2BRKvATHngWb9DLvrzSTFq1cD8+YB0dHytbOzDHTTpwNubmV/loiIiMwOg11ZPNoBF34DYs8X2W3oY5dZh2vs/vgDeP55+dzbG/jPf4DnngPs7ExbLiIiIjIag11ZPNvKx5iiTbGG1Se0dbTGLjcXmDlTPp88WS4ZplabtkxERERUZexjVxaPvGCXcAXI1Rp2FzTF1tEau5UrgfPngUaNgI8/ZqgjIiKqJxjsyuLYBNA4AvpcIP6SYXfBdCd1sMbuzh1g7lz5/P33ARcX05aHiIioAbp+/XqNnJfBriwKhexnB8gBFHnypzupk33s3nkHuHsX6NBB9qkjIiIiAMCXX34Jf39/aDQadO/eHceOHSvz+KSkJEybNg1eXl6wsrJCixYtsGPHjgpdq3nz5njwwQfx448/IisrqzqKD4DBrnyeecEutnCwy5/upI7V2J05A3z9tXz+2WdynjoiIiLChg0bMGvWLMybNw+nTp1Chw4dMGjQIMTFxZV4fHZ2NgYOHIgbN25g06ZNuHz5MlavXg1vb+8KXe/UqVNo3749Zs2aBU9PT7zwwgvlBsmKYLArTwkDKBys62AfOyGAGTMAvR4YNQro3dvUJSIiIjIbS5cuxXPPPYfJkycjKCgIK1euhI2NDb777rsSj//uu++QmJiIrVu3okePHvD390efPn3QoUOHCl2vY8eOWL58OW7fvo3vvvsO0dHR6NmzJ9q2bYulS5ciPj7eqO/BYFee/AEUsedlOEIdrbHbuBE4dEhOPsxJh4mIqIFITU1FSkqKYdNqtcWOyc7OxsmTJzFgwADDPqVSiQEDBuDo0aMlnnfbtm0IDg7GtGnT4OHhgbZt2+LDDz+ETqerVPksLCzw2GOPYePGjVi8eDHCwsIwe/Zs+Pj4YMKECYjOn2u2ghjsyuPWClCogMy7QMotAAWjYuvMWrEZGcDs2fL5m28Cvr6mLQ8REVEtCQoKgqOjo2FbuHBhsWMSEhKg0+ng4eFRZL+HhwdiYmJKPO/169exadMm6HQ67NixA++88w4++eQTvP/++5Uq34kTJ/DSSy/By8sLS5cuxezZs3Ht2jWEhITg9u3bGD58eKXOx3nsymOpAVxbAPEX5QAKxyaGGrusHD1ydHpYqsw8Hy9ZAkRGAn5+wGuvmbo0REREtebChQtF+r1ZWVlVy3n1ej3c3d2xatUqqFQqdO7cGbdu3cJHH32EefPmlfv5pUuXYs2aNbh8+TKGDh2KH374AUOHDoVSKTNFQEAA1q5dC39//0qVi8GuIjzbymAXew5oORh2VgW3LTUrFy62ZjwP3M2bwOLF8vnHH8umWCIiogbC3t4eDg4OZR7j6uoKlUqF2NjYIvtjY2Ph6elZ4me8vLxgaWkJVaGBiK1bt0ZMTAyys7OhLmeO2BUrVmDKlCmYNGkSvLy8SjzG3d0d3377bZnnuZeZVzWZifx+dnlTnliolLBVyz+k2Q+gmD0byMoC+vYFHn/c1KUhIiIyO2q1Gp07d8a+ffsM+/R6Pfbt24fg4OASP9OjRw+EhYVBr9cb9l25cgVeXl7lhjoAuHr1KubMmVNqqMsv18SJEyvxTRjsKqbEKU/y57Iz4wEU+/cDmzYBSiWwfLmcl4+IiIiKmTVrFlavXo3vv/8eFy9exNSpU5Geno7JkycDACZMmIA5c+YYjp86dSoSExMxc+ZMXLlyBdu3b8eHH36IadOmVeh6a9aswcaNG4vt37hxI77//nujvweDXUXkB7s714DsdACFR8aaYY1dSgrwv/8VTEA8dSrQvr1py0RERGTGRo8ejY8//hhz585Fx44dERoail27dhkGVERERBQZoerj44Pdu3fj+PHjaN++PWbMmIGZM2fizTffrND1Fi5cCFdX12L73d3d8eGHHxr9PdjHriLs3AFbdyA9Doi7CDTpYn7LimVkAL//DmzYAGzfDuQP53Z3B95917RlIyIiqgOmT5+O6dOnl/jegQMHiu0LDg7G33//bdS1IiIiEBAQUGy/n58fIiIijDonwBq7ijNMVHwWgJlMUqzVAtu2AePGyQA3ejTw669yf6tWwPz5wIkTXA+WiIjIzLi7u+Ps2bPF9p85cwaNGjUy+ryssasoj7bAtT8MAygMfexMVWOXkgJ07w5culSwLyAAGDNGBrz27dmnjoiIyEyNHTsWM2bMgL29PXrnrQZ18OBBzJw5E2PGjDH6vCatsVuxYgXat28PBwcHODg4IDg4GDt37jRlkUp3zwAKk/ex++47GeqcnYFXXwX++Qe4dg348EOgQweGOiIiIjP23nvvoXv37ujfvz+sra1hbW2Nhx56CP369au7feyaNGmCRYsWITAwEEIIfP/99xg+fDhOnz6NNm3amLJoxRmWFvsX0OtNu6yYTgd8/rl8/uGHwIsv1n4ZiIiIyGhqtRobNmzAe++9hzNnzsDa2hrt2rWDn59flc5r0mA3bNiwIq8/+OADrFixAn///bf5BTvXQEBlBWSnAUk3DMuKmaTGbscO4Pp1wMkJePrp2r8+ERERVYsWLVqgRYsW1XY+s+ljp9PpsHHjRqSnp5c6GaBWqy2yeG9qamptFQ9QWQLurYDoM0DMeTho5PQhJpnHbvly+fjcc4Ctbe1fn4iIiKosKioK27ZtQ0REBLKzs4u8t3TpUqPOafJgd+7cOQQHByMrKwt2dnbYsmULgoKCSjx24cKFWLBgQS2XsBCPdjLYxZ6HvVNnAECqtpZr7M6fB/btk5MOV3ASRCIiIjIv+/btw6OPPoqmTZvi0qVLaNu2LW7cuAEhBO677z6jz2vy6U5atmyJ0NBQ/PPPP5g6dSomTpyICxculHjsnDlzkJycbNhKO67GGKY8OWe6PnaffSYfR44EqtgOT0RERKYxZ84czJ49G+fOnYNGo8HmzZsRGRmJPn364MknnzT6vCYPdmq1Gs2bN0fnzp2xcOFCdOjQAcvzmxrvYWVlZRhB6+DgAHt7+9otbKE1Y/PnsUvKqMUauzt35IoSADBjRu1dl4iIiKrVxYsXMWHCBACAhYUFMjMzYWdnh3fffReLFy82+rwmD3b30uv1RfrRmZX8GrvkCDS1y4VCAUQkZiAmOat2rr96NZCVBXTsCPTqVTvXJCIiompna2tr6Ffn5eWFa9euGd5LSEgw+rwm7WM3Z84cDBkyBL6+vkhNTcW6detw4MAB7N6925TFKp21M+DQBEiJQqO0q+jk44RTEUnYezEWT91fw82iOTnAl1/K5zNncp46IiKiOuz+++/HX3/9hdatW2Po0KH4z3/+g3PnzuHXX3/F/fffb/R5TRrs4uLiMGHCBERHR8PR0RHt27fH7t27MXDgQFMWq2ye7YCUKCD2PAYE9a+9YLd1KxAVBbi5ydUliIiIqM5aunQp0tLSAAALFixAWloaNmzYgMDAQKNHxAImDnbffvutKS9vHM+2wJWdQMw5PBQ8Dkt2XcaRsDtI0+bCzqoGb2d+v8MXXwQ0mpq7DhEREdUonU6HqKgotG8vp06ztbXFypUrq+XcZtfHzuwZVqA4j2ZudvBvZINsnR5/XomvuWuePAkcPgxYWgJTp9bcdYiIiKjGqVQqPPTQQ7h79261n5vBrrIMa8ZegEKvw4DWHgCAkIuxNXfN/Nq6UaMAL6+auw4RERHVirZt2+L69evVfl4Gu8pyDgAsbQGdFrgThoFBMtj9cSkOuTp99V8vJgZYv14+nzmz+s9PREREte7999/H7Nmz8fvvvyM6OhopKSlFNmOZfOWJOkepBDyCgKjjQOx5dA56DE42lkjKyMHJm3fRvWmj6r3eypVyROz99wNdu1bvuYmIiMgkhg4dCgB49NFHoSg004UQAgqFAjqdzqjzMtgZw7OdDHYx52DR7gn0a+mOX0/fQsiF2OoNdlotsGKFfM7aOiIionpj//79NXJeBjtjFBpAAQADgzxksLsYi7cfbl0keVfJL78AcXGAtzfw+OPVc04iIiIyuT59+tTIeRnsjJE/gCJGBrteLdygVilx804GrsWnobl7NSx1JkTBoImXXpIjYomIiKheOHToUJnv9+7d26jzGhXsIiMjoVAo0KRJEwDAsWPHsG7dOgQFBeH55583qiB1insQAAWQFgOkxcPOzg3BzRrh4JV47LkQWz3B7sgROc2JlRXQEO4pERFRA9K3b99i+wq3+Bnbx86oUbHjxo0ztA3HxMRg4MCBOHbsGN5++228++67RhWkTrGyA1wC5PPYcwBgGB2790I1TXvy6afy8emnAVfX6jknERERmYW7d+8W2eLi4rBr1y507doVe/bsMfq8RgW78+fPo1u3bgCAX375BW3btsWRI0fw008/Ye3atUYXpk7J72eX1xzbv7U7AOB0ZBLiU7VVO/eNG8CWLfI5B00QERHVO46OjkU2V1dXDBw4EIsXL8brr79u9HmNCnY5OTmwsrICAOzduxePPvooAKBVq1aIjo42ujB1imGiYhnsvByt0c7bEUIAf1yqYq3d558Dej0wcCDQtm0VC0pERER1hYeHBy5fvmz0543qY9emTRusXLkSDz/8MEJCQvDee+8BAG7fvo1Gjap5HjdzlR/sbp2UAx0UCgwM8sC5W8kIuRCH0V19jTtvairwzTfy+SuvVEtRiYiIyLycPXu2yGshBKKjo7Fo0SJ07NjR6PMaFewWL16MkSNH4qOPPsLEiRPRoUMHAMC2bdsMTbT1nk93wNIGuBMGXA0BWjyEAa09sDTkCv4Ki0dmtg7WalXlz7t2LZCSArRsCQweXO3FJiIiItPr2LEjFAoFhBBF9t9///347rvvjD6vUcGub9++SEhIQEpKCpydnQ37n3/+edjY2BhdmDrFxgXoMgU4+gVwcBEQOBCtvezh7WSNW0mZ+CsswTCgosJ0uoIpTmbOlKtcEBERUb0THh5e5LVSqYSbmxs0Gk2VzmtUcsjMzIRWqzWEups3b2LZsmW4fPky3N3dq1SgOqXHTMBCI5tjr+2DIq85FgBCLsRU/nzbtwPXrgHOzsCECdVcWCIiIjIXfn5+RTYfH58qhzrAyGA3fPhw/PDDDwCApKQkdO/eHZ988glGjBiBFflLYDUEdu6y1g4ADiwGhMCA1jLY7bsYB51elPHhEuRPcfL884CtbTUWlIiIiMzJjBkz8NlnnxXb/8UXX+CVKvSxNyrYnTp1Cr169QIAbNq0CR4eHrh58yZ++OGHEgtZr/WYCaisgKhjwPUD6N7UBfYaC9xJz0ZoZFLFzxMaChw4AKhUwLRpNVRYIiIiMgebN29Gjx49iu1/4IEHsGnTJqPPa1Swy8jIgL29XF1hz549eOyxx6BUKnH//ffj5s2bRhemTrL3BDpPks8PLoalUoG+LWVzdEhlJivO71v35JOAj0/1lpGIiIjMyp07d+Do6Fhsv4ODAxISEow+r1HBrnnz5ti6dSsiIyOxe/duPPTQQwCAuLg4ODg4GF2YOqvnK4BKDUQcBW78iQF5kxXvvVjBYBcTA6xbJ59zihMiIqJ6r3nz5ti1a1ex/Tt37kTTpk2NPq9Ro2Lnzp2LcePG4dVXX0W/fv0QHBwMQNbederUyejC1FkOjYH7JgLHVwMHFqPvmK2wUCoQFpeG8IR0BLiW019u5UogOxsIDga6d6+dMhMREZHJzJo1C9OnT0d8fDz69esHANi3bx8++eQTLFu2zOjzGhXsnnjiCfTs2RPR0dGGOewAoH///hg5cqTRhanTer4CnFwL3PwLjrH/oHtTFxwOu4O9F2LxXO8ykndWFvDVV/I5a+uIiIgahClTpkCr1eKDDz4wLPTg7++PFStWYEIVZsYweqI0T09PdOrUCbdv30ZUVBQAoFu3bmjVqpXRhanTHJsA9z0tnx9cbBgdu/N8dLHJB4v4+WcgPl72q3vssVooKBEREZmDqVOnIioqCrGxsUhJScH169erFOoAI4OdXq/Hu+++C0dHR8P8K05OTnjvvfeg1+urVKA6reergNISCD+EYU43YalS4FREErafK2X9XCGA/OrWl18GLIyqQCUiIqI6Jjw8HFevXgUAuLm5wc7ODgBw9epV3Lhxw+jzGhXs3n77bXzxxRdYtGgRTp8+jdOnT+PDDz/E559/jnfeecfowtR5Tr5Ax3EAANeTy/BS3+YAgPnb/kVSRnbx4/fvB86eBWxsgGefrc2SEhERkQlNmjQJR44cKbb/n3/+waRJk4w+r1HB7vvvv8c333yDqVOnon379mjfvj1eeuklrF69GmvXrjW6MPVCr/8ASgvg+n5MC7yD5u52SEjLxgfbLxY/Nr+2bvJkudoEERERNQinT58ucR67+++/H6GhoUaf16hgl5iYWGJfulatWiExMdHowtQLzn5AhzEAAPVfH2Px4+2gUAAbT0bhr6uF5qWJiAB+/10+nzHDBAUlIiIiU1EoFEhNTS22Pzk5GTqdzujzGhXsOnTogC+++KLY/i+++ALt27c3ujD1Rq//AAoVELYXnVXhePp+PwDAW1vOITM774+1e7fsY9ejB9CihQkLS0RERLWtd+/eWLhwYZEQp9PpsHDhQvTs2dPo8xrVW3/JkiV4+OGHsXfvXsMcdkePHkVkZCR27NhhdGHqDZemQPvRwJl1wL75eO3JjQi5EIuIxAx8uvcK3hraGtizRx6bN7kzERERNRyLFy9G79690bJlS8MyrX/++SdSUlLwxx9/GH1eo2rs+vTpgytXrmDkyJFISkpCUlISHnvsMfz777/43//+Z3Rh6pXes+UasuGHYL/vDbw/vA0A4Js/r+PczURg3z55HIMdERFRgxMUFISzZ89i1KhRiIuLQ2pqKiZMmIBLly6hbdu2Rp9XIcqcZK1yzpw5g/vuu69KbcOVERUVBR8fH0RGRqJJkya1cs1KufAb8MtEAALo/Tpejh2K/ztzGyOyo7Ds0xcBR0cgIYHTnBAREVUzs88IpUhKSsKPP/6I6dOnG/V5oycopgoIGg48slQ+P7QEC72PwsnGEk1O/CX39e/PUEdERETYt28fxo0bBy8vL8ybN8/o8zDY1bQuU4C+bwEA7P54Cys7RaDXjVAAQMIDfUxYMCIiIjKlyMhIvPvuuwgICMBDeV2ztmzZgpiYGKPPyWBXG/q8DnR9DoBA97/fQJdbFwAA72Y1Lnu5MSIiIqpXcnJysHHjRgwaNAgtW7ZEaGgoPvroIyiVSvz3v//F4MGDYWlpafT5K9UO+Fg5a5kmJSUZXZB6TaEAhiwG0uOh2LoRKr0e0c6u2JZqjQeOR2JMN19Tl5CIiIhqgbe3N1q1aoWnnnoK69evh3PeAgVjx46tlvNXKtg5OjqW+35VF6+tt5Qq4LFVwOo/AYTDLTAL/opozN2mhIutGg+18TR1CYmIiKiG5ebmQqFQQKFQQKVSVfv5KxXs1qxZU+0FaFAsrIBIWb1q4a/DJtuPMDTtHbz440kseqw9RnX1MXEBiYiIqCbdvn0bmzdvxrfffouZM2diyJAheOqpp6BQKKrl/OxjV5siI4HLVwClEujUDK65MfjdYRECEYHXN5/FyoPXTF1CIiIiqkEajQbjx4/HH3/8gXPnzqF169aYMWMGcnNz8cEHHyAkJKT2lxQjI4WEyMfu3YEX/g9w8IZ7diR+t56HJ1UHsGjnJXy44yIHVBARETUAzZo1w/vvv4+bN29i+/bt0Gq1eOSRR+Dh4WH0ORnsalP+MmIDBwLO/sALh4Bm/WGp1+Ijy1X42HIl/nfoAmZvPItcnd6kRSUiIqLaoVQqMWTIEGzatAlRUVF46623jD9XNZaLyqLXA3v3yuf5y4jZugLjNwH9/gsolHhCdQi/qd9B6Ol/8OKPJ5GVUzsreBAREZF5cHNzw6xZs4z+PINdbTl9GrhzB7C3B7p1K9ivVAK9XwMmbAPsPNBCeQv/p/4v7C7/iqe//QfJmTmmKzMRERHVKQx2tSW/GbZfP6CkiQcDegEv/gUE9IGNQotl6q/wWNQSjP7yD5y4kVi7ZSUiIqI6icGutuQPnBg4sPRj7NyBp7cAfedAQIGxFvvxdcp0/Lr6fby35STStLm1U1YiIiKqkxjsakN6OvDXX/J5fv+60ihVQN83oZiwFXpbd/gp4/Ch5bd4IfQxfP/Rq/jzPKdEISIiopJVaoJiMtKhQ0BODuDvDzRvXrHPNO0L5cxQ4NQP0B5aBveMGEzL/QEpGzdh7/6R6DL6LTi5N6nJUhMREVE1qsygiKVLlxp1DQa72lB4mpPKzCyttgXunwqrLs9AG7oBKXs/hlvWDQy48xO0X/2CGwGPw6/nWCg09oClrTw+f1OpK3ctIiIiqlGnT5+u0HFVWYWCwa425PevK68ZtjQWalh1eRpu943H9SOboN3/MVrrLsM/fD0Qvr7kzyhUgNoOaNwB6PMm4N/DuGsTERFRtdi/f3+NX4PBrqbdugX8+6+sPevXr2rnUirRtOcoZHd/HJu2bYTjmdXwQzRsFFrYKrSwV2hhIbLlsUIHaJOB8ENya9ZPzpfn3bnq34mIiIjMEoNdTcuvrevaFXBxqZZTqi1VeOLxMYh88FFsPBGJjSejEJ2cBQBQQYcuXlZ4soMLBjVVw/7sWuDUD8C1P+TW6hHgwbcAjzbVUhYiIiIyzokTJ/DLL78gIiIC2dnZRd779ddfjTonR8XWtIpMc2IkHxcbzHqoJf56ox/WTu6Koe08oVRZ4J/oXMzeFYcuq25jVsZEXH5yP9BhHKBQApd+B1b0ADY9A9zhCFsiIiJTWL9+PR544AFcvHgRW7ZsQU5ODv7991/88ccfcHR0NPq8ClGHV5yPioqCj48PIiMj0aSJGY4Q1esBT08gPh44eBDo3bvGL5mYno0tp2/hl+ORuBybath/f1MXzGivR3DEKigubJU7FSogaDjQ6mGgeX/A2rnGy0dERFQbzD0jtG/fHi+88AKmTZsGe3t7nDlzBgEBAXjhhRfg5eWFBQsWGHVeBruaFBoKdOoE2NoCiYmAWl1rlxZCIDQyCWsO38D2c9HQ6eWf2b+RDf7TLgtD4r+DxbU9BR9QqADfYKDFIKDFYMA1kKNqiYiozjL3jGBra4t///0X/v7+aNSoEQ4cOIB27drh4sWL6NevH6Kjo406L5tia1L+NCcPPliroQ6QQ6U7+Trjs7Gd8OfrD+KFPk3hoLHAjTsZePmAHvddexZrgtYgpfN0wK21HGxx8y8g5B3gy67AZ52AnW8CNw4DdTf7ExERVdiXX34Jf39/aDQadO/eHceOHavQ59avXw+FQoERI0ZU+FrOzs5ITZUta97e3jh//jwAICkpCRkZGZUuez4Gu5pUg/3rKqOxkzXmDGmNo3P6493hbeDfyAYpWblYcMoK7Q8/gEHZS7Cy46+I6D4Pomk/OQfe3XDgnxXA2qHAF12BI18A6XdM+j2IiIhqyoYNGzBr1izMmzcPp06dQocOHTBo0CDExcWV+bkbN25g9uzZ6NWrV6Wu17t3b4Tk5YQnn3wSM2fOxHPPPYexY8eif//+Rn8PNsXWlMxMwNkZ0GqBixeBVq1MXSIDvV7gj0txWHMkHEev3YG+0D8BzjaWGNzcDo87X0X7jKNQX9oG5KTLN1Vq2Sev8yTArwebaomIyGxVNiN0794dXbt2xRdffAEA0Ov18PHxwcsvv4w333yzxM/odDr07t0bU6ZMwZ9//omkpCRs3bq1zOucP38ebdu2RWJiIrKystC4cWPo9XosWbIER44cQWBgIP773//C2dm4fu8MdjXl4EGgb1+gcWMgKspsQ9Dd9GwcuhqPfRfjcOByHFKycg3vWSgVGNDMBq96nEGLqE1QxJwt+GCjQBnwfIOBjDtARgKQHg+kJ8jX6XmvrZ2BlkPkAA2HxrX/BYmIqEGqTEbIzs6GjY0NNm3aVKQ5deLEiUhKSsJvv/1W4ufmzZuHs2fPYsuWLZg0aVKFgp1SqUTXrl3x7LPPYsyYMbC3t6/sVysT57GrKSdPysfu3c021AGAs60awzt6Y3hHb+Tq9Dhx8y7+uBSHfRdjcS0+HbuupmPX1ebwb/QuXu2WgSHanVBf+BW4cxXY83bFLnJtH7BjtpwcudUjcnNrUbNfjIiICEBqaipSUlIMr62srGBlZVXkmISEBOh0Onh4eBTZ7+HhgUuXLpV43r/++gvffvstQkNDK1WegwcPYs2aNfjPf/6DV199FY8//jieffbZSjfllobBrqbkB7vOdWelBwuVEvc3bYT7mzbCW0Nb43p8Gn4+FoH1xyNx404GZh4C3lI/grEdn8bzzqfhHrYRSI0BbBsBNq6ArWveY6HXCVeBS9uBqGPArZNy27cAcG0hA57v/XJtW0trwNKm+KNSZerbQkREdVhQUFCR1/PmzcP8+fOrdM7U1FQ8/fTTWL16NVxdXSv12V69eqFXr174/PPP8csvv2Dt2rXo06cPmjdvjmeeeQYTJ06Ep6en0WVjU2xNadkSuHIF2LkTGDzY1KWpknRtLracvoXvj9zA1bg0w/5ega4Y280XPQNd4aCxLPskqTEy4F3aLpc40+dU7OL2XnIKlpYPAwG9AUtNFb4JERE1FPkZ4cKFC/D29jbsL6nGrrJNsaGhoejUqRNUqoLKB71eD0A2tV6+fBnNmjWrcFnDwsKwZs0a/O9//0NMTAwGDx6Mbdu2VebrGjDY1YSUFCB/1ui4OMDNzbTlqSZCCBy5dgdrDt/AvkuxhllQVEoFOvo4oVegK3oFuqFDE0dYqMoYcJ2ZBITtlatg3LkG5GYB2RlATgaQkwnkZpb8OUtboHk/oOVQIHCQrBkkIiIqgTGDJ7p164bPP/8cgAxqvr6+mD59erHBE1lZWQgLCyuy77///S9SU1OxfPlytGjRAupKTnOWnp6On376CXPmzEFSUhJ0Ol2lPp+PTbE14fRp+ejrW29CHSDnxuvR3BU9mrsi4k4GfvrnJkIuxuJ6fDpO3ryLkzfvYtneq7DXWKBHM1f0auGK+5s2gn8jW6iUhfoZWjsB7Z6QW0n0ehn2cjKA6FDg0g7g8k4g9TZw8f/kplACPvcDvt1lk62FJm+zKvpo7wl4tgeUnNmHiIhKN2vWLEycOBFdunRBt27dsGzZMqSnp2Py5MkAgAkTJsDb2xsLFy6ERqNB27Zti3zeyckJAIrtL8+hQ4fw3XffYfPmzVAqlRg1ahSeeeYZo7+HSYPdwoUL8euvv+LSpUuwtrbGAw88gMWLF6Nly5amLFbV1cH+dZXl28gGc4a2xpyhrRF1NwN/XU3An1cT8FdYApIzc7Dr3xjs+jcGAGBtqUILT3u09rRHay8HtPZyQEtPezhal9J8q1QCahu5NR8gt4c/AaLPAJd3yC3mHBBxRG7lsXEFAgfKrVk/Lp1GRETFjB49GvHx8Zg7dy5iYmLQsWNH7Nq1yzCgIiIiAspqqiS4ffs21q5di7Vr1yIsLAwPPPAAPvvsM4waNQq2trZVOrdJm2IHDx6MMWPGoGvXrsjNzcVbb72F8+fP48KFCxX6YmbbFDtuHPDzz8D77wNvV3DkaD2h0wucjUrCn1cT8OfVeJy7lYysHH2Jx3o7WaOttwM6+zmjs58L2no7wMqigoMlkiKBK7vk4AydFsjV5jXjamVtX65WNukmhAHZBWvmQqEEmnTLC3oPAZ7tzHrUMhERGcdcM8KQIUOwd+9euLq6YsKECZgyZUq1VmiZVR+7+Ph4uLu74+DBg+jdu3e5x5vrH80wcGLXLmDQIFOXxqR0eoEbd9JxMToFF6NTcCk6FRejU3A7OavYsWoLJdp7O+YFPbk1srMq4ayVkJsNRP4DXN0DXA0B4i8Wfd/KUc6v5+AlB2rYe93z3Buwc2f4IyKqY8w1Izz66KN45pln8MgjjxQZfFFdzCrYhYWFITAwEOfOnatQG7VZ/tEKD5yIjwcqOQy6oUjKyMbF6FSciUoy9M9LTM8udlxjRw28na3h7WSNxk7W8HbOe8zbbK0q2ZsgKUIGvLC9wPUDsh9feSw0gJNv3uYnH53zHp38ARsXBj8iIjNjlhmhFphNsNPr9Xj00UeRlJSEv/76q8RjtFottFqt4fWtW7cQFBRkXn+0/BUnfH2BmzdNXZo6QwiBG3cycOJGIk5F3MWJG3eLTK1SGi9HDfq2dEPflu7o0dwVdpUJerlaIPE6kBoNpETLx9RoOTVLym35PC0WECU3JRtYOcig5xwAOPsDLgEFz62dgcxEICMxb4WOOwWrc2TcAbQpgF4H6HMLPRZ6rlIDLv6AS1PApVneYwBgdc9M5ULIct8NBxLD8x6vy+taO8lyWLvIEFr4uYM34Ohd/DsREdVxDTXYmc2o2GnTpuH8+fOlhjpADrZYsGBBLZbKCCdOyMcuXUxbjjpGoVAgwNUWAa62eLKLDwAgOSMH1xLScDspE7fuZsrHpEzcSsrCrbsZSMnKRXRyFn4+Fomfj0XCUqVAtwAXPNjSHX1buqOZmy0UZdWkWVgB7q3lVprcbCDlFpB0U9b23c17zH+dGi3DWcw5udWEmyX8O2HrDjRqBmicZFkSw0ufJqY8zfoDD7wMNO3LmkciojrOLGrspk+fjt9++w2HDh1CQEBAqcfViRq7/IETH3wAvPWWqUtTr6Vm5eB0RBL2X47D/ktxuHGnaLOqj4s1uvi5wMnGEg4aSzhYW8JBYwEHa0vYayzgoLGEl6Omav34cjJl2Lt7o1BtWd7zuzflwA5LG8CmUdHN1lXWmFk5AioLQJm3KVRytY381zkZ8pyJ14HEa3m1cHdKLotCCTj6FNQYugTIAJiVLGsNM+/KGrzMuwW1iMmRBTWSHu1kwGv7GKAqZ8JpIiIz11Br7Ewa7IQQePnll7FlyxYcOHAAgYGBlfq8Wf7ROHDCZMIT0rH/Uhz2X47DP9cTka0rpwk1T4CrLbr4OaOrvwu6BrjAv5FN2TV9FaXX5wU766qfq7DMpLygdx3ISpL9/FwCZKizqNyEmLh7A/h7BXDqh4L+hg7eQPcXgc4TAY1j+efQ5QDZaUB2upxo2vA8Xb7vfZ8cgEJEVIvMMiPUApMGu5deegnr1q3Db7/9VmSor6OjI6yty/8xNLs/WnIykDdBIQdOmFZGdi6OhN3B1bg0pGblICUrBymZuXmPOUjJykVyZg4S0rS4998AVzs1uvi5oIu/M9p5O6KRnRpONmo4WVuWvaJGXZaRCJxcA/zztexXCABqe6DtSFlzqE0ttKUUfa0rPuilmEaBgN8DgF8P+ejkU7Pfh4gaPLPLCLXEpMGutFqRNWvWYNKkSeV+3uz+aAcOAA8+CPj5ATdumLo0VAHJmTk4dfMujt9IxIkbdxEalYTs3NJr+uw1FnC2UcPZxhJONmq42lnB18UGvo2s4etiAx8XG7jZWVVPjZ8p5GqBcxuBI58D8Zcq91mVWjY7q+0Ata2cYDonK+889/xnxtEX8O8BNOkqVwcxDOzIG9yhKqf7ry5H1jDmZsuma5UloLTMe6zi9AF6nWz+jr8oB9X4dAO8OrD/IVEdY3YZoZaYdPCEGXTvq14NYMWJ+sbR2hIPtnLHg61kU2FWjg7nbyXj+A0Z9q7Hp+FuRg6SM3MAAKlZuUjNykVEYunn1FgqZdhzsYF/I1u0a+KIdt6O8G9kC6XSzMOBhRXQ6Smgwzjg2j7gxp8yrFnZ520O9zzmhThL29KbgTMS5VyCNw8DN48At0OB5AjgTARw5ueSP2PlCNg4y+vosvPWEc6SfRpzMgBR1hqKChkyVZby+9i6y/Bo71X8UeMg1yuOvwjEXZKP8VdkE3phjr5Aq4eB1o8AvsFVD49ERDXELAZPGMvs0jgHTtRbuTo9kjNzcDcjB0kZ2bibkYO7GdmIS8lCZGImIhIzEJGYgdvJmcWadvPZW1mgjbcD2jdxQjtvGfb8SujPJ4SAELKOS6kovWa7ztKmApHHZMiLPiMHg+QP7shKNnXpJAtrwK2FXI4u4mjR+Q5tGgEthwKthwEBfWTITL4lB6Kk3Mp7HgWkRAHpd2Szs3trwD1IPjYKLDkEZ2cAcReB2LwR1jHnZT9KlwBZs+ndWT46Nqm92kMhWFNJdZbZZYRawmBXnVq0AK5eBXbvBh56yNSlIRPIztXjVlJB0Lsam4pzt5Jx4XYKtCU08aqUCigA6IWAAIqFQkuVAj55NX/+jWzh71rwvLGTpv71+dPlygEhGYky7GlTZa2bpY0chGKhKXhuaS1r5oRe1urpcuTcf4bnObKGLy0WSI0tmKPQ8Bgjw6SzP+DeCnBrVTD9jZNfQa1cdgZwfT9w8Xfgyk75mXxKC3nNylBaAI2ay+s4B8gBLLHngTth5c+ZCAB2nkCTLnLz7iybr/NrKFXqEp5XoGEmJ1Muzxd/WTadJ1yWz+9ck8Gu8D03PM97tPOQA3ccm8gQ69gEcGhS+YE8RNXM7DJCLWGwqy6FB04kJACNGpm0OGRecnR6hMWl4VxUMs7eSsK5qGRcjE6t8MjdkliqFGjsZA13eyu422vgZm8lNzsrw3MnG0uolAooFTJAKhQKQy2gUgFYWahgrWazYoXpcmRN48X/Ay5tB1Jvy/1WDnmTPTeREz47NJHPbRrJ4Bb3r6yNi7soB5+UxtYN8Ggr1zD2bCcnpb5zFYg6DkSdkAHQmCBpaZMXiu8JZiqLgul67u0HWSWKvMDnLZvqC0/jY3ie99rapegyfvnL+t07CXdt0+vk/wRonGSXA6pzzCoj1CIGu+rCgRNUSdm5eiSkaWXoUsAQvAo/T9fmIiIxA+EJ6bh5Jx3hCRm4eScdNxMzyhzkURneTtYI9LBDCw97BLrbITDvsdLLtTU0er1sfrV2qti0MICskk25lRfyLshA5eQr5xD0bAfYe5T9+ewM2Xx964QMe9FnZTNxfi2lLrtio5RLonGStYhuLWXtpWsLwDVQDkrJycjr35hZ6HnelDapMXKy7uQoeT+So4Dc4mtBV5raXvaFVNvkhcH8+R7vmevRplHBCioO+cHaW/afLEv+AJyU24VWayn0mBQha30VStmM3qSr3Hy6ycCtrERtuV4PaJPlVEWZd2WtdOZd+drKQU423qh5+WWmSjGrjFCL+F/u6pK/4gQHTlAFqS2UaOxU9rQ+LrZq+LjYoEfzolPn6PUC0SlZiErMQEJaNuJSsxCfqpVbmtbwPCkzx9BnTy8E9CX8b9ytvBU9DlyOL7I/P/A1dbVDgKsNAlztEOBmCy8HjfkPAqkNSqVcSq4yFIq8Wr0mQODAyl9TbQP4BcutNEIUNEnnamXIMoSywsEsQ77v2ESGOVu36ulPJ4TsN5kUIUNsrlbWfolCS+cJnXzU5QAZCYWW8YspWM0lOxW4k2p8OfJrUZUWclWWnCz5mKuV37/MATh5FCp5XOx5uZ1cI/drnAqCnsYByEqR/UOzkmVo0xZ6nZmU13e0AnUodh4y4DVqJvtiNmqeN0dlE9PXYBoj/2+vtjF1SRoUBrvqkj8ilkuJUS1QKhXwdrKGdznBsCSFg16aNhdX49JwJTYVV2Pl45XYNCSkaUsNfFYWSvg3ksu/+Taygb2VBWytLGCX92hrpTI8d7C2hIe9Vf3rC2jOFIq8PnaWshnUFNe3dZWb933GnUObVhDycrUFaygXDod6nQyv6fF5g1ai5MCVlCgZpLQpQHwZzd75rBzlesz5q7UUXvPZwVv20Yw6XtAcfvu0DG9hIXKrDEsbOZ2Pxinv0VHW3N0JA9Lj5LXSYuUI8ntpnGRfxvx+jPn9GpUqeQ/S78iQnJ6Q95j3OjdL1jpCIR8ViqKvNQ6yT6mzX6FHX/nc2qli30uXI/tjxl2QfTTzux0kXpd/MxvXQufN3/zzHn2qfxL3Bo5NsdWFAyeoHrmbno0rsakIi0/DjYR0hOdtEYkZyNFV7j8ZSgXg5WgNb2drNHGyRhNnazRxtpGvna3R2Mkalgx+VJ20aTLspdySNYiGgTfWcjCOhTVgqZGPFlaVq6nMzZa1d1EnZJO4LkcGNI1D3qOjDGEaR1lraO2UF+Sc5LVKk5Usw9GdsIIt4aqs+cxKqtLtMJrGUYYypUXBHJGGJvG8LT1ellOfY/x1ph2TtcbVzKwyQi1isKsOHDhBDUSuTo76zQ96t+5mIk2bizRtLtK1uUjX6uTzbPk6OTOn3CCYH/yaOFvDx8UGPs428HGRzz0dNFApFXkjhvOmgRGAQMGUMLk6PXL1Ark6gVx90ecKKODrIkOkis3HVFdpU/NqJKOK92cUIm/t6fw1qF2LvrawBpD/L46+6HOhL2g2T7opB9LkP2YkVK6Maru8keWtZJ9Et7xHSw2QFFlwjaSIgu3uTdnkPudWjQxQMZuMUMvYFFsdTp2Sj/7+DHVUr1molPBrZAu/RrboW4H/wdbrBRLStIi8m4mouxm4lZSJqLuZuJX3OupuJrR5U8TcSsrEP+FlzPxcBWoLJZq62qKZmx2audmimbsdmrnZwbeRDdQqZd6AlYIRw3LwSj2cQ5DqJiv7gql4aos2La+2MLmgKfzeTZcra/XcW8mm4dL+fbF2BrzaF98vhGyK5qjjasVgVx244gRRiZRKBdwdNHB30KCzn3Ox94UQiE/TIjJRBr3IxAxEJmYi8m4GIu9mIDZFK6vlFHmTNeOeEcQALFQKWKiUsFAq5HOlfK5SKqDTC8MI4ksxqbgUU7nO+EoF4GpnBU9HDTwcNPB00MDTseDRw0EDL0cNRxBT/WNlB3gE1ew1FAq5lCBVK/7XqDow2BEZRaFQwN1eA3f7koNfddDpBW7dzcS1+LS8LR3X4tNwPT4NCWllTw2iF0BcqhZxqVoApa+K4aCxQGMna3g5auDpaI3Gjhp4OVnDw0H2qcrR6ZGdK5uHc3R65OQKZOv00AsBB40lXGzVcLFVo5GdGs42amgsy59bUK8XyNHrYWXBeQiJqACDXXXgVCdEZkulVMC3kQ18G9kY1gTOl5Gdi1y97K+He/ruCSGQoxOIT9UiJiULMSlZiE3Oe0zJQnSyfJ2qzUVKVi5SjKgRLI2tWgWXvJCn0wtk5eigzdUjK0cPba58nj+Poa1aBY/8WsT8GsVCNYyN7NRoZGtVaxNR303PxqWYVFyOScH1hHQ0drLGfb7OaN/EsUKBlYiqhsGuqpKTgbAw+ZzBjqhOsVGX/59AT0cN2qH0CYhTs3IQnSyDXnRSJm7nPcakZCEuRQulUgFLlQKWKmWhR/lcqVAgOTMHienZuJOejbvp2cjVC6Rn65CemInIxMxyy5eercP1+HRcj08v8ziNpRIuNmpDYHSxlY/WahXUKiXUFsqCx0LPLVUKqAo1b+c3d+cPRrmRkI7LsamGMBeboi3x+pYqBYIaO6KzrzM6+8nN01FT7vcjosphsKsqDpwgatDsNZaw11iihUfVJ5AVQiAlMxd30rW4m5GNpIwcqJQKWFmooLFUQmOpgpVFwaOFSok7aVpDLWJMshYxyZl5NYxaxCZnITE9G9k6Wdt3OzkLt5OrYVWIcjRxtkYrT3s0dbNDZGIGTty8i/hULc5EJuFMZBK+OxwOAGjsqIG3s7VhHkS7QvMh2msK5ke01+RvlobXtmoLTpRNVAIGu6pi/zoiqiYKhQKONpZwtLGs8GccrS3R1K30UYVCyBrAu4VqBRPztrsZ2cjK0SNbp0N2XvNujk7Ipl6dHtm5Ouj0Arl6IR8LTSmjy9u8nWSIa+npgJae9mjhYQd7jWWxMkTdzcSpiLs4eVNuF6NTqhQ0FQrATm0Bq7yQa5VX0yifqwzPLVVKWKgUUOc9Fq4xtVQp4WRjCQ8HTaHNqkI1uUTmiv/0VlV+/zquOEFEZkihUBhqwnxcTLO0k0KhkHMUuthgeEdvAEC6NhfnbiUjMT1bzoWYJec+TCu8ZcnHVMNjDlKzCvpFpmpzkarNrfby2mssDCFPY6GCQMGSfEWX6BPQWKrgoLGEvUautGKvsYCDxtLwHAC0OTpk5eiRmaNDVo4u71EPbY4OagslnGzUcLK2hLOtJZxsZBO5k7U8B+dfpMpisKsq1tgREVWarZUF7m9a+e4rQsgaxdQsGfRkjaMMSbKWUW8YXKLN1SFbJ5CryxuNrBPI0emRm/eYrdMjMT0bsXn9IWNSspCRrcs7dxrC4tJq4JtXnEIha2SdrC3haKOGs4187mSjhqO1JZxtLGGtVkGhkP01lQo5WEiR91ypUEAIQCcEdHo9dHpAl1fjqs+ribVUKQ1htHA4tddYwjbv3KUReWE3V68vqNnVFarh1ethqVLC2UYNtQVXl6ktDHZVUXjgxH1GrolIREQVplAooLFUQWOpgpt9GUt0GUHkrZ8cm6JFbF6/xRyd3jBnolKhgFIpH/P3ZeXo5KjoTFmbmJKVU+S5QgFoLFSGMuf3ldRYKqGxUEGbq0dSZg6SMrIN/SqTMnKQps2FEDC8xp2Mav2uFaFUyMm99XmjxvVCGGovK7tmlb3GAo1s1XC2VaNR3vQ+LrZWaGSrxqguPpXqfkBlY7CrCg6cICKqNxQKhWEwTHN3066GkJ2rR1JmNpIzcvKCnwx/SRk5SMosCIDaXB30Qs7XmN88rNcXNBUrUDCaWalQwEKpgFJZ8JiTX/upzUFKZtHmbr0AsnL0RpVfjqZWIDtXD71AXi1oLm6UEFAf6eAFRzDYVRcGu6pg/zoiIqoBagulYfLu2iaEQFaOHqlZOcjW6fNqKPNqKoG8lWAKajELT4GTHxjz6fUCyZk5cuBORjbupOUP3tEiMT0HielaONuoa/071mcMdlXB/nVERFTPKBQKWKtV1TKptVKpgHNeEyzVDvZmrAoGOyIiIjIjDHbGSkriihNERERkVhjsjHX+vHz08wNcXExbFiIiIiIw2Bnvxg352KyZSYtBRERElI/Bzlj5wc7f35SlICIiIjJgsDMWgx0RERGZGQY7YzHYERERkZlhsDMWgx0RERGZGQY7Y+h0QESEfM5gR0RERGaCwc4Y0dFATg5gYQE0bmzq0hAREREBYLAzTn4zrK8voKr6kitERERE1YHBzhjsX0dERERmiMHOGAx2REREZIYY7IzBYEdERERmiMHOGAx2REREZIYY7IzBYEdERERmiMGusjiHHREREZkpBrvK4hx2REREZKYY7CqLc9gRERGRmWKwq6z8YBcQYNJiEBEREd2Lwa6ywsPlI/vXERERkZlhsKssjoglIiIiM8VgV1kMdkRERGSmGOwqi8GOiIiIzBSDXWVwDjsiIiIyYwx2lXH7NpCbC1haAl5epi4NERERUREMdpXBOeyIiIjIjDHYVQb71xEREZEZY7CrDAY7IiIiMmMMdpXBYEdERERmjMGuMhjsiIiIyIwx2FUGgx0RERGZMQa7iuIcdkRERGTmGOwqinPYERERkZljsKsozmFHREREZo7BrqLYv46IiIjMHINdRTHYERER1Wtffvkl/P39odFo0L17dxw7dqzUY1evXo1evXrB2dkZzs7OGDBgQJnH1xYGu4pisCMiIqq3NmzYgFmzZmHevHk4deoUOnTogEGDBiEuLq7E4w8cOICxY8di//79OHr0KHx8fPDQQw/h1q1btVzyohjsKio8XD4y2BEREdU7S5cuxXPPPYfJkycjKCgIK1euhI2NDb777rsSj//pp5/w0ksvoWPHjmjVqhW++eYb6PV67Nu3r5ZLXhSDXUXl19gFBJi0GERERFS9srOzcfLkSQwYMMCwT6lUYsCAATh69GiFzpGRkYGcnBy4uLjUVDErxMKkV68rcnOByEj5nDV2REREdUZqaipSUlIMr62srGBlZVXkmISEBOh0Onh4eBTZ7+HhgUuXLlXoOm+88QYaN25cJByagklr7A4dOoRhw4ahcePGUCgU2Lp1qymLUzrOYUdERFQnBQUFwdHR0bAtXLiw2q+xaNEirF+/Hlu2bIFGo6n281eGSWvs0tPT0aFDB0yZMgWPPfaYKYtStvxmWD8/QMnWayIiorriwoUL8Pb2Nry+t7YOAFxdXaFSqRAbG1tkf2xsLDw9Pcs8/8cff4xFixZh7969aN++ffUUugpMGuyGDBmCIUOGmLIIFcMRsURERHWSvb09HBwcyjxGrVajc+fO2LdvH0aMGAEAhoEQ06dPL/VzS5YswQcffIDdu3ejS5cu1Vlso9WpPnZarRZardbwOjU1tXYuzGBHRERUr82aNQsTJ05Ely5d0K1bNyxbtgzp6emYPHkyAGDChAnw9vY2NOUuXrwYc+fOxbp16+Dv74+YmBgAgJ2dHezs7Ez2PepUsFu4cCEWLFhQ+xdmsCMiIqrXRo8ejfj4eMydOxcxMTHo2LEjdu3aZRhQERERAWWh7lgrVqxAdnY2nnjiiSLnmTdvHubPn1+bRS9CIYQQJrt6IQqFAlu2bDFUgZbk3hq7W7duISgoCJGRkWjSpEnNFa5fP2D/fuDHH4Hx42vuOkRERFQtoqKi4OPjU/MZwczUqRq7e4coFx6+XKNYY0dERER1AId4lodz2BEREVEdYdIau7S0NISFhRleh4eHIzQ0FC4uLvD19TVhyQrhHHZERERUR5g02J04cQIPPvig4fWsWbMAABMnTsTatWtNVKp7cA47IiIiqiNMGuz69u0LMxm7UTr2ryMiIqI6glVQ5WGwIyIiojqCwa48DHZERERURzDYlYfBjoiIiOoIBrvyMNgRERFRHcFgV5bcXCAiQj5nsCMiIiIzx2BXllu3AJ2Oc9gRERFRncBgVxbOYUdERER1CNNKWdi/joiIiOoQBruy5Ae7gACTFoOIiIioIhjsysIaOyIiIqpDGOzKwmBHREREdQiDXVkY7IiIiKgOYbArTW4uEBkpnzPYERERUR3AYFea/Dns1GrA09PUpSEiIiIqF4NdaTiHHREREdUxFqYugNkKCACWL5erThARERHVAQx2pfH1BWbMMHUpiIiIiCqMbYxERERE9QSDHREREVE9wWBHREREVE8w2BERERHVEwx2RERERPUEgx0RERFRPcFgR0RERFRPMNgRERER1RMMdkRERET1BIMdERERUT3BYEdERERUTzDYEREREdUTDHZERERE9QSDHREREVE9wWBHREREVE8w2BERERHVEwx2RERERPUEgx0RERFRPcFgR0RERFRPMNgRERER1RMMdkRERET1BIMdERERUT3BYEdERERUTzDYEREREdUTDHZERERE9QSDHREREVE9wWBHREREVE8w2BERERHVEwx2RERERPUEgx0RERFRPcFgR0RERFRPMNgRERER1RMMdkRERET1BIMdERERUT3BYEdERERUTzDYEREREdUTDHZERERE9QSDHREREVE9wWBHREREVE8w2BERERHVEwx2RERERPUEgx0RERFRPcFgR0RERFRPMNgRERER1RNmEey+/PJL+Pv7Q6PRoHv37jh27Jipi0REREQNTGXzyMaNG9GqVStoNBq0a9cOO3bsqKWSls7kwW7Dhg2YNWsW5s2bh1OnTqFDhw4YNGgQ4uLiTF00IiIiaiAqm0eOHDmCsWPH4plnnsHp06cxYsQIjBgxAufPn6/lkhelEEIIUxage/fu6Nq1K7744gsAgF6vh4+PD15++WW8+eabZX42KioKPj4+iIyMRJMmTWqjuERERFQHVDYjVDaPjB49Gunp6fj9998N++6//3507NgRK1eurL4vUkkmrbHLzs7GyZMnMWDAAMM+pVKJAQMG4OjRoyYsGRERETUUxuSRo0ePFjkeAAYNGmTy/GJhyosnJCRAp9PBw8OjyH4PDw9cunSp2PFarRZardbwOjk5GQAQHR1dswUlIiKiOiU/GyQnJ8PBwcGw38rKClZWVkWOrWweAYCYmJgSj4+JiamO4hvNpMGushYuXIgFCxYU29+tWzcTlIaIiIjMXdu2bYu8njdvHubPn2+awtQCkwY7V1dXqFQqxMbGFtkfGxsLT0/PYsfPmTMHs2bNMrzOzc3FxYsX4ePjA6Wy+luVU1NTERQUhAsXLsDe3r7az1/f8f5VDe9f1fD+VR3vYdXw/lVNVe+fXq9HREQEgoKCYGFREHfura0DKp9HAMDT07NSx9cWkwY7tVqNzp07Y9++fRgxYgQA+YfYt28fpk+fXuz4kqpPe/ToUWPlS0lJAQB4e3sXqcaliuH9qxrev6rh/as63sOq4f2rmuq4f76+vhU6rrJ5BACCg4Oxb98+vPLKK4Z9ISEhCA4ONqqs1cXkTbGzZs3CxIkT0aVLF3Tr1g3Lli1Deno6Jk+ebOqiERERUQNRXh6ZMGECvL29sXDhQgDAzJkz0adPH3zyySd4+OGHsX79epw4cQKrVq0y5dcwfbAbPXo04uPjMXfuXMTExKBjx47YtWtXsQ6JRERERDWlvDwSERFRpNvXAw88gHXr1uG///0v3nrrLQQGBmLr1q3F+vTVNpMHOwCYPn16qVWdpmRlZYV58+aV2B5P5eP9qxrev6rh/as63sOq4f2rGlPcv7LyyIEDB4rte/LJJ/Hkk0/WcKkqx+QTFBMRERFR9TD5kmJEREREVD0Y7IiIiIjqCQY7IiIionqCwa4UX375Jfz9/aHRaNC9e3ccO3bM1EUyW4cOHcKwYcPQuHFjKBQKbN26tcj7QgjMnTsXXl5esLa2xoABA3D16lXTFNbMLFy4EF27doW9vT3c3d0xYsQIXL58ucgxWVlZmDZtGho1agQ7Ozs8/vjjxSbFbMhWrFiB9u3bw8HBAQ4ODggODsbOnTsN7/P+Vc6iRYugUCiKzM3Fe1i6+fPnQ6FQFNlatWpleJ/3rny3bt3CU089hUaNGsHa2hrt2rXDiRMnDO/zN6RyGOxKsGHDBsyaNQvz5s3DqVOn0KFDBwwaNAhxcXGmLppZSk9PR4cOHfDll1+W+P6SJUvw2WefYeXKlfjnn39ga2uLQYMGISsrq5ZLan4OHjyIadOm4e+//0ZISAhycnLw0EMPIT093XDMq6++iv/7v//Dxo0bcfDgQdy+fRuPPfaYCUttXpo0aYJFixbh5MmTOHHiBPr164fhw4fj33//BcD7VxnHjx/H119/jfbt2xfZz3tYtjZt2iA6Otqw/fXXX4b3eO/KdvfuXfTo0QOWlpbYuXMnLly4gE8++QTOzs6GY/gbUkmCiunWrZuYNm2a4bVOpxONGzcWCxcuNGGp6gYAYsuWLYbXer1eeHp6io8++siwLykpSVhZWYmff/7ZBCU0b3FxcQKAOHjwoBBC3itLS0uxceNGwzEXL14UAMTRo0dNVUyz5+zsLL755hvev0pITU0VgYGBIiQkRPTp00fMnDlTCMF/Bsszb9480aFDhxLf470r3xtvvCF69uxZ6vv8Dak81tjdIzs7GydPnsSAAQMM+5RKJQYMGICjR4+asGR1U3h4OGJiYorcT0dHR3Tv3p33swTJyckAABcXFwDAyZMnkZOTU+T+tWrVCr6+vrx/JdDpdFi/fj3S09MRHBzM+1cJ06ZNw8MPP1zkXgH8Z7Airl69isaNG6Np06YYP348IiIiAPDeVcS2bdvQpUsXPPnkk3B3d0enTp2wevVqw/v8Dak8Brt7JCQkQKfTFVv5wsPDAzExMSYqVd2Vf894P8un1+vxyiuvoEePHoaZy2NiYqBWq+Hk5FTkWN6/os6dOwc7OztYWVnhxRdfxJYtWxAUFMT7V0Hr16/HqVOnDEslFcZ7WLbu3btj7dq12LVrF1asWIHw8HD06tULqampvHcVcP36daxYsQKBgYHYvXs3pk6dihkzZuD7778HwN8QY5jFyhNEJGtMzp8/X6R/DlVMy5YtERoaiuTkZGzatAkTJ07EwYMHTV2sOiEyMhIzZ85ESEgINBqNqYtT5wwZMsTwvH379ujevTv8/Pzwyy+/wNra2oQlqxv0ej26dOmCDz/8EADQqVMnnD9/HitXrsTEiRNNXLq6iTV293B1dYVKpSo2aik2Nhaenp4mKlXdlX/PeD/LNn36dPz+++/Yv38/mjRpYtjv6emJ7OxsJCUlFTme968otVqN5s2bo3Pnzli4cCE6dOiA5cuX8/5VwMmTJxEXF4f77rsPFhYWsLCwwMGDB/HZZ5/BwsICHh4evIeV4OTkhBYtWiAsLIz//FWAl5cXgoKCiuxr3bq1oTmbvyGVx2B3D7Vajc6dO2Pfvn2GfXq9Hvv27UNwcLAJS1Y3BQQEwNPTs8j9TElJwT///MP7CTmMf/r06diyZQv++OMPBAQEFHm/c+fOsLS0LHL/Ll++jIiICN6/Muj1emi1Wt6/Cujfvz/OnTuH0NBQw9alSxeMHz/e8Jz3sOLS0tJw7do1eHl58Z+/CujRo0exKZ6uXLkCPz8/APwNMYqpR2+Yo/Xr1wsrKyuxdu1aceHCBfH8888LJycnERMTY+qimaXU1FRx+vRpcfr0aQFALF26VJw+fVrcvHlTCCHEokWLhJOTk/jtt9/E2bNnxfDhw0VAQIDIzMw0cclNb+rUqcLR0VEcOHBAREdHG7aMjAzDMS+++KLw9fUVf/zxhzhx4oQIDg4WwcHBJiy1eXnzzTfFwYMHRXh4uDh79qx48803hUKhEHv27BFC8P4Zo/CoWCF4D8vyn//8Rxw4cECEh4eLw4cPiwEDBghXV1cRFxcnhOC9K8+xY8eEhYWF+OCDD8TVq1fFTz/9JGxsbMSPP/5oOIa/IZXDYFeKzz//XPj6+gq1Wi26desm/v77b1MXyWzt379fACi2TZw4UQghh6u/8847wsPDQ1hZWYn+/fuLy5cvm7bQZqKk+wZArFmzxnBMZmameOmll4Szs7OwsbERI0eOFNHR0aYrtJmZMmWK8PPzE2q1Wri5uYn+/fsbQp0QvH/GuDfY8R6WbvTo0cLLy0uo1Wrh7e0tRo8eLcLCwgzv896V7//+7/9E27ZthZWVlWjVqpVYtWpVkff5G1I5CiGEME1dIRERERFVJ/axIyIiIqonGOyIiIiI6gkGOyIiIqJ6gsGOiIiIqJ5gsCMiIiKqJxjsiIiIiOoJBjsiIiKieoLBjoiIiKieYLAjogZHoVBg69atpi4GEVG1Y7Ajolo1adIkKBSKYtvgwYNNXTQiojrPwtQFIKKGZ/DgwVizZk2RfVZWViYqDRFR/cEaOyKqdVZWVvD09CyyOTs7A5DNpCtWrMCQIUNgbW2Npk2bYtOmTUU+f+7cOfTr1w/W1tZo1KgRnn/+eaSlpRU55rvvvkObNm1gZWUFLy8vTJ8+vcj7CQkJGDlyJGxsbBAYGIht27YZ3rt79y7Gjx8PNzc3WFtbIzAwsFgQJSIyRwx2RGR23nnnHTz++OM4c+YMxo8fjzFjxuDixYsAgPT0dAwaNAjOzs44fvw4Nm7ciL179xYJbitWrMC0adPw/PPP49y5c9i2bRuaN29e5BoLFizAqFGjcPbsWQwdOhTjx49HYmKi4foXLlzAzp07cfHiRaxYsQKurq61dwOIiIwliIhq0cSJE4VKpRK2trZFtg8++EAIIQQA8eKLLxb5TPfu3cXUqVOFEEKsWrVKODs7i7S0NMP727dvF0qlUsTExAghhGjcuLF4++23Sy0DAPHf//7X8DotLU0AEDt37hRCCDFs2DAxefLk6vnCRES1iH3siKjWPfjgg1ixYkWRfS4uLobnwcHBRd4LDg5GaGgoAODixYvo0KEDbG1tDe/36NEDer0ely9fhkKhwO3bt9G/f/8yy9C+fXvDc1tbWzg4OCAuLg4AMHXqVDz++OM4deoUHnroIYwYMQIPPPCAUd+ViKg2MdgRUa2ztbUt1jRaXaytrSt0nKWlZZHXCoUCer0eADBkyBDcvHkTO3bsQEhICPr3749p06bh448/rvbyEhFVJ/axIyKz8/fffxd73bp1awBA69atcebMGaSnpxveP3z4MJRKJVq2bAl7e3v4+/tj3759VSqDm5sbJk6ciB9//BHLli3DqlWrqnQ+IqLawBo7Iqp1Wq0WMTExRfZZWFgYBihs3LgRXbp0Qc+ePfHTTz/h2LFj+PbbbwEA48ePx7x58zBx4kTMnz8f8fHxePnll/H000/Dw8MDADB//ny8+OKLcHd3x5AhQ5CamorDhw/j5ZdfrlD55s6di86dO6NNmzbQav+/fTvETSCKwjD6jyFhNGZWQIJHsgcS8HgMBsMmYBmMwyBgJ0iWQdUgmpLUNU1b6Ms5csTLHffl5b63HI/HR1gCvDJhB/y50+mUpmk+fRsOh7lcLkneX6y2bZvlcpmmabLf7zMajZIkdV3nfD5ntVplPB6nruvMZrNst9vHWYvFIrfbLbvdLuv1OoPBIPP5/Mvz9Xq9bDabXK/X9Pv9TCaTtG37A38O8Luqruu6Zw8B8KGqqhwOh0yn02ePAvDv2LEDACiEsAMAKIQdO+Cl2A4B+D43dgAAhRB2AACFEHYAAIUQdgAAhRB2AACFEHYAAIUQdgAAhRB2AACFEHYAAIW4A4TJ/WYgfW6LAAAAAElFTkSuQmCC","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["print(\"Performance: train_loss={}, val_acc={}, val_loss={}\".format(*metrics[-1]))\n","\n","\n","fig, ax1 = plt.subplots()\n","ax1.plot(metrics[:,0], label=\"train loss\")\n","ax1.plot(metrics[:,2], label=\"val loss\")\n","ax1.legend(loc='upper left')\n","ax1.set_xlabel(\"Epochs\")\n","ax1.set_ylabel(\"Loss\")\n","ax1.set_ylim(0, max(np.max(metrics[:,0]), np.max(metrics[:,2]))*1.1)\n","ax2 = ax1.twinx()\n","ax2.plot(metrics[:,1], label=\"val acc\", color='r')\n","ax2.set_ylabel(\"Val Accuracy\")\n","ax2.set_ylim(0,1)\n","ax2.legend()\n","\n","plt.title(\"SHD Surrogate Gradient\")\n","plt.tight_layout()\n","plt.show()"]},{"cell_type":"code","execution_count":25,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.363053Z","iopub.status.busy":"2024-03-25T01:01:40.362629Z","iopub.status.idle":"2024-03-25T01:01:40.372790Z","shell.execute_reply":"2024-03-25T01:01:40.371148Z","shell.execute_reply.started":"2024-03-25T01:01:40.363023Z"},"trusted":true},"outputs":[],"source":["def test_gd(SNN, params, dl):\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    @jax.jit\n","    def test_step(params, data):\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1)\n","        readout = SNN.apply(params, events)\n","        traces, V_f = readout\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        return params, [acc, loss, pred, targets]\n","\n","    test_data = dl.test_epoch()\n","\n","    _, test_metrics = jax.lax.scan(\n","            test_step,# func\n","            params,# init\n","            test_data,# xs\n","            test_data.obs.shape[0]# len\n","    )\n","\n","    acc = jnp.mean(test_metrics[0])\n","    loss = jnp.mean(test_metrics[1])\n","    preds = jnp.array(test_metrics[2]).flatten()\n","    tgts = jnp.array(test_metrics[3]).flatten()\n","    return acc, loss, preds, tgts\n"]},{"cell_type":"code","execution_count":26,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.374642Z","iopub.status.busy":"2024-03-25T01:01:40.374229Z","iopub.status.idle":"2024-03-25T01:01:51.992083Z","shell.execute_reply":"2024-03-25T01:01:51.991062Z","shell.execute_reply.started":"2024-03-25T01:01:40.374600Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","Accuracy: 0.7529297 Loss: 2.0053806\n"]}],"source":["acc, loss, preds, tgts = test_gd(SNN, grad_params, shd_dl)\n","print(\"Accuracy:\", acc, \"Loss:\", loss)\n"]},{"cell_type":"code","execution_count":27,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:51.993950Z","iopub.status.busy":"2024-03-25T01:01:51.993610Z","iopub.status.idle":"2024-03-25T01:01:53.139665Z","shell.execute_reply":"2024-03-25T01:01:53.138548Z","shell.execute_reply.started":"2024-03-25T01:01:51.993921Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["cm = confusion_matrix(tgts, preds)\n","ConfusionMatrixDisplay(cm).plot()\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["LOSS REGULARIZATION PAPER + SOFTMAX"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[],"dockerImageVersionId":30665,"isGpuEnabled":true,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.13"}},"nbformat":4,"nbformat_minor":4}

From 3ff7920a90fed8065a240ef18c73e279fce57391 Mon Sep 17 00:00:00 2001
From: Florent Pollet <flo1.raymond@gmail.com>
Date: Sun, 5 May 2024 22:06:01 -0400
Subject: [PATCH 2/3] WIP eprop documentation, tests and refactoring

---
 .gitignore                                    |  1 +
 .../surrogate_gradient/shd_eprop.ipynb        |  1 +
 docs/index.rst                                |  1 +
 setup.py                                      |  2 +-
 spyx/axn.py                                   | 38 +++++----
 spyx/nn.py                                    | 83 ++++++++++++++-----
 tests/shd.ipynb                               |  1 -
 tests/test_eprop.py                           | 26 ++++++
 8 files changed, 117 insertions(+), 36 deletions(-)
 create mode 100644 docs/examples/surrogate_gradient/shd_eprop.ipynb
 delete mode 100644 tests/shd.ipynb
 create mode 100644 tests/test_eprop.py

diff --git a/.gitignore b/.gitignore
index 6fcbdb2..d34f32a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@
 
 .ipynb_checkpoints
 */.ipynb_checkpoints/*
+docs/examples/surrogate_gradient/data
 
 # datasets
 .h5
diff --git a/docs/examples/surrogate_gradient/shd_eprop.ipynb b/docs/examples/surrogate_gradient/shd_eprop.ipynb
new file mode 100644
index 0000000..af3268f
--- /dev/null
+++ b/docs/examples/surrogate_gradient/shd_eprop.ipynb
@@ -0,0 +1 @@
+{"cells":[{"cell_type":"markdown","metadata":{},"source":["# Eligibility propagation with Spyx\n","\n","References:\n","> A solution to the learning dilemma for recurrent networks of spiking neurons. G Bellec*, F Scherr*, A Subramoney, E Hajek, Darjan Salaj, R Legenstein, W Maass\n","\n","> Additional explanations can be found in this report [here](https://github.com/florian6973/btt-spyx/blob/main/Report.pdf).\n","\n","## Dependencies"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!pip install matplotlib scikit-learn spyx[loaders]"]},{"cell_type":"markdown","metadata":{},"source":["## Imports"]},{"cell_type":"code","execution_count":4,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:26.124346Z","iopub.status.busy":"2024-03-25T00:51:26.123957Z","iopub.status.idle":"2024-03-25T00:51:45.375066Z","shell.execute_reply":"2024-03-25T00:51:45.374022Z","shell.execute_reply.started":"2024-03-25T00:51:26.124313Z"},"trusted":true},"outputs":[],"source":["import spyx\n","from spyx.nn import LeakyLinear, RecurrentLIFLight\n","\n","# JAX imports\n","import os\n","import jax\n","from jax import numpy as jnp\n","import jmp # jax mixed-precision\n","import numpy as np\n","\n","from jax_tqdm import scan_tqdm\n","from tqdm import tqdm\n","\n","# implement our SNN in DeepMind's Haiku\n","import haiku as hk\n","\n","# for surrogate loss training.\n","import optax\n","\n","# rendering tools\n","import matplotlib.pyplot as plt\n","from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:53.610008Z","iopub.status.busy":"2024-03-25T00:51:53.609590Z","iopub.status.idle":"2024-03-25T00:52:53.102621Z","shell.execute_reply":"2024-03-25T00:52:53.101491Z","shell.execute_reply.started":"2024-03-25T00:51:53.609973Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Downloading https://zenkelab.org/datasets/shd_train.h5.zip to ./data\\SHD\\shd_train.h5.zip\n"]},{"name":"stderr","output_type":"stream","text":["130864128it [00:14, 9181086.13it/s]                                \n"]},{"name":"stdout","output_type":"stream","text":["Extracting ./data\\SHD\\shd_train.h5.zip to ./data\\SHD\n","Downloading https://zenkelab.org/datasets/shd_test.h5.zip to ./data\\SHD\\shd_test.h5.zip\n"]},{"name":"stderr","output_type":"stream","text":["38141952it [00:04, 8919111.29it/s]                               \n"]},{"name":"stdout","output_type":"stream","text":["Extracting ./data\\SHD\\shd_test.h5.zip to ./data\\SHD\n"]}],"source":["shd_dl = spyx.loaders.SHD_loader(256,128,128)"]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:34.878852Z","iopub.status.busy":"2024-03-25T00:59:34.877963Z","iopub.status.idle":"2024-03-25T00:59:34.894764Z","shell.execute_reply":"2024-03-25T00:59:34.893802Z","shell.execute_reply.started":"2024-03-25T00:59:34.878814Z"},"trusted":true},"outputs":[],"source":["key = jax.random.PRNGKey(0)\n","x,y = shd_dl.train_epoch(key)"]},{"cell_type":"code","execution_count":6,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.107085Z","iopub.status.busy":"2024-03-25T00:59:35.106146Z","iopub.status.idle":"2024-03-25T00:59:35.116003Z","shell.execute_reply":"2024-03-25T00:59:35.114928Z","shell.execute_reply.started":"2024-03-25T00:59:35.107049Z"},"trusted":true},"outputs":[],"source":["def lsnn_shd(x, state=None):\n","    n_rec = 400\n","    tau = 20\n","    dt = 1\n","    core = hk.DeepRNN([\n","        hk.Linear(n_rec),\n","        RecurrentLIFLight(n_rec,\n","            tau=tau,\n","            thr=0.8,\n","            dt=dt,\n","            dtype=jnp.float32,\n","            dampening_factor=0.3,\n","            tau_adaptation=500,\n","            beta=0.07 * jnp.ones(n_rec),\n","            tag='',\n","            stop_gradients=True,\n","            w_rec_init=None,\n","            n_refractory=3,\n","            rec=True,),\n","       LeakyLinear(n_rec, 20, jnp.exp(-dt/tau))\n","    ])\n","    spikes, hiddens = hk.dynamic_unroll(core, x, core.initial_state(x.shape[0]), time_major=False, unroll=128)#16) # unroll our model.\n","    \n","    return spikes, hiddens"]},{"cell_type":"code","execution_count":7,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.281232Z","iopub.status.busy":"2024-03-25T00:59:35.280138Z","iopub.status.idle":"2024-03-25T00:59:35.287667Z","shell.execute_reply":"2024-03-25T00:59:35.286683Z","shell.execute_reply.started":"2024-03-25T00:59:35.281194Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256, 16, 128)"]},"execution_count":7,"metadata":{},"output_type":"execute_result"}],"source":["x.shape"]},{"cell_type":"code","execution_count":8,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.472580Z","iopub.status.busy":"2024-03-25T00:59:35.471589Z","iopub.status.idle":"2024-03-25T00:59:35.479043Z","shell.execute_reply":"2024-03-25T00:59:35.477983Z","shell.execute_reply.started":"2024-03-25T00:59:35.472547Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256)"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["y.shape"]},{"cell_type":"code","execution_count":9,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.622628Z","iopub.status.busy":"2024-03-25T00:59:35.621698Z","iopub.status.idle":"2024-03-25T01:00:13.651070Z","shell.execute_reply":"2024-03-25T01:00:13.650089Z","shell.execute_reply.started":"2024-03-25T00:59:35.622595Z"},"trusted":true},"outputs":[],"source":["# Create a random key\n","# Since there's nothing stochastic about the network, we can avoid using an RNG as a param!\n","SNN = hk.without_apply_rng(hk.transform(lsnn_shd))\n","\n","x0 = jnp.zeros((1, 256, 128))\n","params = SNN.init(rng=key, x=x0)\n"]},{"cell_type":"code","execution_count":21,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.654007Z","iopub.status.busy":"2024-03-25T01:00:13.653689Z","iopub.status.idle":"2024-03-25T01:00:13.671535Z","shell.execute_reply":"2024-03-25T01:00:13.670388Z","shell.execute_reply.started":"2024-03-25T01:00:13.653979Z"},"trusted":true},"outputs":[],"source":["def gd(SNN, params, dl, epochs=300, schedule=3e-4):\n","\n","    # We use optax for our optimizer.\n","    opt = optax.adam(learning_rate=schedule)\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    # create and initialize the optimizer\n","    opt_state = opt.init(params)\n","    grad_params = params\n","\n","    # define and compile our eval function that computes the loss for our SNN\n","    @jax.jit\n","    def net_eval(weights, events, targets):\n","        readout = SNN.apply(weights, events)\n","        traces, V_f = readout\n","        return Loss(traces, targets)\n","\n","    # Use JAX to create a function that calculates the loss and the gradient!\n","    surrogate_grad = jax.value_and_grad(net_eval)\n","\n","    rng = jax.random.PRNGKey(0)\n","\n","    # compile the meat of our training loop for speed\n","    @jax.jit\n","    def train_step(state, data):\n","        # unpack the parameters and optimizer state\n","        grad_params, opt_state = state\n","        # unpack the data into x, y\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1) # decompress temporal axis\n","        # compute loss and gradient\n","        loss, grads = surrogate_grad(grad_params, events, targets)\n","        # generate updates based on the gradients and optimizer\n","        updates, opt_state = opt.update(grads, opt_state, grad_params)\n","        # return the updated parameters\n","        new_state = [optax.apply_updates(grad_params, updates), opt_state]\n","        return new_state, loss\n","\n","    # For validation epochs, do the same as before but compute the\n","    # accuracy, predictions and losses (no gradients needed)\n","    @jax.jit\n","    def eval_step(grad_params, data):\n","        # unpack our data\n","        events, targets = data\n","        # decompress information along temporal axis\n","        events = jnp.unpackbits(events, axis=1)\n","        # apply the network to the data\n","        readout = SNN.apply(grad_params, events)\n","        # unpack the final layer outputs and end state of each SNN layer\n","        traces, V_f = readout\n","        # compute accuracy, predictions, and loss\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        # we return the parameters here because of how jax.scan is structured.\n","        return grad_params, jnp.array([acc, loss])\n","\n","\n","    val_data = dl.val_epoch()\n","\n","    # Here's the start of our training loop!\n","    @scan_tqdm(epochs)\n","    def epoch(epoch_state, epoch_num):\n","        curr_params, curr_opt_state = epoch_state\n","\n","        shuffle_rng = jax.random.fold_in(rng, epoch_num)\n","        train_data = dl.train_epoch(shuffle_rng)\n","\n","        # train epoch\n","        end_state, train_loss = jax.lax.scan(\n","            train_step,# our function which computes and updates gradients for one batch\n","            [curr_params, curr_opt_state], # initialize with parameters and optimizer state of current epoch\n","            train_data,# pass the newly shuffled training data\n","            train_data.obs.shape[0]# this corresponds to the number of training batches\n","        )\n","\n","        new_params, _ = end_state\n","\n","        # val epoch\n","        _, val_metrics = jax.lax.scan(\n","            eval_step,# func\n","            new_params,# init\n","            val_data,# xs\n","            val_data.obs.shape[0]# len\n","        )\n","        \n","        print(val_metrics)\n","\n","\n","        return end_state, jnp.concatenate([jnp.expand_dims(jnp.mean(train_loss),0), jnp.mean(val_metrics, axis=0)])\n","    # end epoch\n","\n","    # epoch loop\n","    final_state, metrics = jax.lax.scan(\n","        epoch,\n","        [grad_params, opt_state], # metric arrays\n","        jnp.arange(epochs), #\n","        epochs # len of loop\n","    )\n","\n","    final_params, final_optimizer_state = final_state\n","\n","\n","    # return our final, optimized network.\n","    return final_params, metrics"]},{"cell_type":"code","execution_count":22,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.673210Z","iopub.status.busy":"2024-03-25T01:00:13.672889Z","iopub.status.idle":"2024-03-25T01:01:39.734131Z","shell.execute_reply":"2024-03-25T01:01:39.732917Z","shell.execute_reply.started":"2024-03-25T01:00:13.673183Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","x_input (256, 128, 128)\n","iin (256, 400)\n","Traced<ShapedArray(float32[6,2])>with<DynamicJaxprTrace(level=1/0)>\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"27a910e6ae494f57addc365f80e51b15","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/60 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"}],"source":["grad_params, metrics = gd(SNN, params, shd_dl, epochs=60) # this takes a minute or two to compile on Colab because of weak CPU compute.\n"]},{"cell_type":"code","execution_count":23,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.737814Z","iopub.status.busy":"2024-03-25T01:01:39.737403Z","iopub.status.idle":"2024-03-25T01:01:39.748389Z","shell.execute_reply":"2024-03-25T01:01:39.747242Z","shell.execute_reply.started":"2024-03-25T01:01:39.737774Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["[3.3396416 2.7394361 2.5159357 2.3944805 2.311097  2.259231  2.254243\n"," 2.1969118 2.1640594 2.1198297 2.1289842 2.0941677 2.0898578 2.0560226\n"," 2.0525196 2.020626  2.0091455 1.9951267 1.9801593 1.9889545 1.9905777\n"," 1.9748755 1.9900997 1.9820318 1.9319314 1.9379961 1.9430561 1.9162053\n"," 1.9080309 1.9121706 1.9099082 1.8986979 1.9173098 1.8822697 1.8949358\n"," 1.8759296 1.8963922 1.872345  1.8697561 1.8655033 1.8835618 1.8791912\n"," 1.8660862 1.8646512 1.853204  1.8516091 1.8390594 1.842894  1.8579562\n"," 1.8335865 1.8404154 1.8479518 1.8314093 1.818244  1.8273256 1.8267124\n"," 1.8125165 1.8106669 1.8294351 1.8155215]\n","[0.13346355 0.30013022 0.40429688 0.4811198  0.5286459  0.57682294\n"," 0.5839844  0.6197917  0.6295573  0.6790365  0.66015625 0.69921875\n"," 0.69596356 0.718099   0.7285156  0.74609375 0.76171875 0.765625\n"," 0.7714844  0.7623698  0.75846356 0.780599   0.76627606 0.764974\n"," 0.79752606 0.8046875  0.7727865  0.8072917  0.8092448  0.8170573\n"," 0.8222656  0.8255209  0.8105469  0.8300781  0.82682294 0.8229167\n"," 0.81575525 0.83463544 0.8372396  0.843099   0.8261719  0.83658856\n"," 0.8378906  0.84375    0.85546875 0.8483073  0.86002606 0.85026044\n"," 0.83203125 0.8535156  0.85026044 0.8567709  0.8463542  0.858724\n"," 0.8645834  0.85481775 0.86263025 0.86002606 0.84765625 0.859375  ]\n"]}],"source":["print(metrics[:, 2])\n","print(metrics[:, 1])"]},{"cell_type":"code","execution_count":24,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.749919Z","iopub.status.busy":"2024-03-25T01:01:39.749580Z","iopub.status.idle":"2024-03-25T01:01:40.361273Z","shell.execute_reply":"2024-03-25T01:01:40.360235Z","shell.execute_reply.started":"2024-03-25T01:01:39.749890Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Performance: train_loss=1.655739426612854, val_acc=0.859375, val_loss=1.815521478652954\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["print(\"Performance: train_loss={}, val_acc={}, val_loss={}\".format(*metrics[-1]))\n","\n","\n","fig, ax1 = plt.subplots()\n","ax1.plot(metrics[:,0], label=\"train loss\")\n","ax1.plot(metrics[:,2], label=\"val loss\")\n","ax1.legend(loc='upper left')\n","ax1.set_xlabel(\"Epochs\")\n","ax1.set_ylabel(\"Loss\")\n","ax1.set_ylim(0, max(np.max(metrics[:,0]), np.max(metrics[:,2]))*1.1)\n","ax2 = ax1.twinx()\n","ax2.plot(metrics[:,1], label=\"val acc\", color='r')\n","ax2.set_ylabel(\"Val Accuracy\")\n","ax2.set_ylim(0,1)\n","ax2.legend()\n","\n","plt.title(\"SHD Surrogate Gradient\")\n","plt.tight_layout()\n","plt.show()"]},{"cell_type":"code","execution_count":25,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.363053Z","iopub.status.busy":"2024-03-25T01:01:40.362629Z","iopub.status.idle":"2024-03-25T01:01:40.372790Z","shell.execute_reply":"2024-03-25T01:01:40.371148Z","shell.execute_reply.started":"2024-03-25T01:01:40.363023Z"},"trusted":true},"outputs":[],"source":["def test_gd(SNN, params, dl):\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    @jax.jit\n","    def test_step(params, data):\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1)\n","        readout = SNN.apply(params, events)\n","        traces, V_f = readout\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        return params, [acc, loss, pred, targets]\n","\n","    test_data = dl.test_epoch()\n","\n","    _, test_metrics = jax.lax.scan(\n","            test_step,# func\n","            params,# init\n","            test_data,# xs\n","            test_data.obs.shape[0]# len\n","    )\n","\n","    acc = jnp.mean(test_metrics[0])\n","    loss = jnp.mean(test_metrics[1])\n","    preds = jnp.array(test_metrics[2]).flatten()\n","    tgts = jnp.array(test_metrics[3]).flatten()\n","    return acc, loss, preds, tgts\n"]},{"cell_type":"code","execution_count":26,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.374642Z","iopub.status.busy":"2024-03-25T01:01:40.374229Z","iopub.status.idle":"2024-03-25T01:01:51.992083Z","shell.execute_reply":"2024-03-25T01:01:51.991062Z","shell.execute_reply.started":"2024-03-25T01:01:40.374600Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","Accuracy: 0.7529297 Loss: 2.0053806\n"]}],"source":["acc, loss, preds, tgts = test_gd(SNN, grad_params, shd_dl)\n","print(\"Accuracy:\", acc, \"Loss:\", loss)\n"]},{"cell_type":"code","execution_count":27,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:51.993950Z","iopub.status.busy":"2024-03-25T01:01:51.993610Z","iopub.status.idle":"2024-03-25T01:01:53.139665Z","shell.execute_reply":"2024-03-25T01:01:53.138548Z","shell.execute_reply.started":"2024-03-25T01:01:51.993921Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["cm = confusion_matrix(tgts, preds)\n","ConfusionMatrixDisplay(cm).plot()\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["LOSS REGULARIZATION PAPER + SOFTMAX"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[],"dockerImageVersionId":30665,"isGpuEnabled":true,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.14"}},"nbformat":4,"nbformat_minor":4}
diff --git a/docs/index.rst b/docs/index.rst
index 3b8180f..8e4eee8 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -25,6 +25,7 @@ Be sure to go give it a star on Github: https://github.com/kmheckel/spyx
    examples/surrogate_gradient/shd_sg_neuron_model_comparison
    examples/surrogate_gradient/shd_sg_surrogate_comparison
    examples/surrogate_gradient/shd_sg_template
+   examples/surrogate_gradient/shd_eprop
 
 Indices and tables
 ==================
diff --git a/setup.py b/setup.py
index 3e7f7dd..aa43dbf 100644
--- a/setup.py
+++ b/setup.py
@@ -25,7 +25,7 @@
     'loaders' : [
         'tonic',
         'torchvision',
-        'sklearn'
+        'scikit-learn'
     ]
 }
 
diff --git a/spyx/axn.py b/spyx/axn.py
index 3ee1128..83509f8 100644
--- a/spyx/axn.py
+++ b/spyx/axn.py
@@ -13,7 +13,7 @@ def custom(bwd=lambda x: x,
 
     It is assumed that the input to this layer has already had it's threshold subtracted within the neuron model dynamics.
 
-    The default behavior is a Heaviside forward activation with a stragiht through estimator surrogate gradient.
+    The default behavior is a Heaviside forward activation with a straight through estimator surrogate gradient.
     
     :bwd: Function that calculates the gradient to be used in the backwards pass.
     :fwd: Forward activation/spiking function. Default is the heaviside function centered at 0.
@@ -69,10 +69,10 @@ def triangular(k=2):
     :return: JIT compiled triangular surrogate gradient function.
     """
 
-    def grad_traingle(x):
+    def grad_triangle(x):
         return jnp.maximum(0, 1-jnp.abs(k*x))
     
-    return custom(grad_traingle, heaviside)
+    return custom(grad_triangle, heaviside)
 
 
 def arctan(k=2):
@@ -120,18 +120,28 @@ def grad_superspike(x):
     
     return custom(grad_superspike, heaviside)
 
-@jax.custom_gradient
-def eprop_SpikeFunction(v_scaled, dampening_factor):
-    z_ = jnp.greater(v_scaled, 0.)
-    z_ = z_.astype(jnp.float32)
+def abs_linear(dampening_factor=0.3):
+    """
+    This function implements the SpikeFunction surrogate gradient activation function for a spiking neuron.
 
-    def grad(dy):
-        dE_dz = dy
-        dz_dv_scaled = jnp.maximum(1 - jnp.abs(v_scaled), 0)
-        dz_dv_scaled *= dampening_factor
+    It was introduced in Bellec, Guillaume, et al. Long short-term memory and learning-to-learn in networks of spiking neurons. 
+    arXiv:1803.09574, arXiv, 25 dec 2018. arXiv.org, 
+    https://doi.org/10.48550/arXiv.1803.09574.
 
-        dE_dv_scaled = dE_dz * dz_dv_scaled
+    :v_scaled: The normalized membrane potential of the neuron scaled by the threshold.
+    :dampening_factor: The dampening factor for the surrogate gradient, 
+        which can improve the stability of the training process
+        for deep networks. Default is 0.3.
+    """
+    def fwd(v_scaled):
+        z_ = jnp.greater(v_scaled, 0.)
+        z_ = z_.astype(jnp.float32)
+        return z_
+
+    def grad(v_scaled):
+        dz_dv_scaled = jnp.maximum(1 - jnp.abs(v_scaled), 0).astype(v_scaled.dtype)
+        dz_dv_scaled *= dampening_factor
 
-        return (dE_dv_scaled, jnp.zeros_like(dampening_factor).astype(jnp.float32))
+        return dz_dv_scaled
 
-    return z_, grad
\ No newline at end of file
+    return custom(grad, fwd)
diff --git a/spyx/nn.py b/spyx/nn.py
index 133d0ca..86464fb 100644
--- a/spyx/nn.py
+++ b/spyx/nn.py
@@ -1,7 +1,7 @@
 import jax
 import jax.numpy as jnp
 import haiku as hk
-from .axn import superspike, eprop_SpikeFunction
+from .axn import superspike, abs_linear
 
 from collections.abc import Sequence
 from typing import Optional, Union
@@ -12,7 +12,7 @@
 #needs fixed.
 class ALIF(hk.RNNCore): 
     """
-    Adaptive LIF Neuron based on the model used in LSNNs:
+    Adaptive LIF Neuron based on the model used in LSNNs
 
     Bellec, G., Salaj, D., Subramoney, A., Legenstein, R. & Maass, W. 
     Long short- term memory and learning-to-learn in networks of spiking neurons. 
@@ -20,7 +20,6 @@ class ALIF(hk.RNNCore):
     
     """
 
-
     def __init__(self, hidden_shape, beta=None, gamma=None,
                  threshold = 1,
                  activation = superspike(),
@@ -89,13 +88,46 @@ def initial_state(self, batch_size): # this might need fixed to match CuBaLIF...
 
 class RecurrentLIFLight(hk.RNNCore):
     """
-    Recurrent LIF
-    See LeakyLIF for the output neuron type of the original paper
+    Recurrent Adaptive Leaky Integrate and Fire neuron model with threshold adaptation.
+    It can be used for LIF only by setting beta to 0.
 
     Original code from https://github.com/IGITUGraz/eligibility_propagation for RecurrentLIFLight
     Copyright 2019-2020, the e-prop team:
     Guillaume Bellec, Franz Scherr, Anand Subramoney, Elias Hajek, Darjan Salaj, Robert Legenstein, Wolfgang Maass
     from the Institute for theoretical computer science, TU Graz, Austria.
+
+    Params
+    ------
+    n_rec: int
+        Number of recurrent neurons.
+    tau: float
+        Membrane time constant (ms)
+    thr: float
+        Firing threshold.
+    dt: float
+        Time step (ms)
+    dtype:
+        Data type.
+    dampening_factor: float
+        Dampening factor for the surrogate gradient (see abs_linear).
+    tau_adaptation: float
+        Time constant for threshold adaptation (ALIF model)
+    beta: float
+        Decay rate for threshold adaptation (ALIF model)
+    tag: str
+        parameter tag.
+    stop_gradients: bool
+        Whether to stop gradients.
+        If True, e-prop will be applied
+        If False, exact BPTT will be applied
+    w_rec_init: array
+        Initial value for the recurrent weights.
+    n_refractory: float
+        Refractory period (ms)
+    rec: bool
+        Whether to include recurrent connections.   
+    name: str
+        Name of the Haiku module.
     """
 
     def __init__(self, 
@@ -139,23 +171,36 @@ def __init__(self,
 
         self.built = True
 
-    def initial_state(self, batch_size, dtype=jnp.float32, n_rec=None):
-        if n_rec is None: n_rec = self.n_rec
+    def initial_state(self, batch_size, dtype=jnp.float32):
+        """
+        Initialize the state of the neuron model.
+        
+        :batch_size: tuple
+            Batch size.
+        :dtype:
+            Data type.
+        """
+        n_rec = self.n_rec
 
         s0 = jnp.zeros(shape=(batch_size, n_rec, 2), dtype=dtype)
         z0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
         z_local0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
         r0 = jnp.zeros(shape=(batch_size, n_rec), dtype=dtype)
+
         return CustomALIFStateTuple(s=s0, z=z0, r=r0, z_local=z_local0)
     
     def compute_z(self, v, b):
+        """
+        Compute the surrogate gradient.
+        """
         adaptive_thr = self.thr + b * self.beta
         v_scaled = (v - adaptive_thr) / self.thr
-        z = eprop_SpikeFunction(v_scaled, self.dampening_factor)
+        z = abs_linear(self.dampening_factor)(v_scaled)
         z = z * 1 / self.dt
+
         return z
         
-    def __call__(self, inputs, state, scope=None, dtype=jnp.float32):
+    def __call__(self, inputs, state):
         decay = self._decay
 
         z = state.z
@@ -177,21 +222,17 @@ def __call__(self, inputs, state, scope=None, dtype=jnp.float32):
         else:
             i_t = i_in
 
-        def get_new_v_b(s, i_t):
-            v, b = s[..., 0], s[..., 1]
-            new_b = self.decay_b * b + z_local
+        v, b = s[..., 0], s[..., 1]
+        new_b = self.decay_b * b + z_local
 
-            I_reset = z * self.thr * self.dt
-            new_v = decay * v + i_t  - I_reset
-
-            return new_v, new_b
-        
-        new_v, new_b = get_new_v_b(s, i_t)
+        I_reset = z * self.thr * self.dt
+        new_v = decay * v + i_t  - I_reset
 
         is_refractory = state.r > 0
         zeros_like_spikes = jnp.zeros_like(z)
-        new_z = jnp.where(is_refractory, zeros_like_spikes, self.compute_z(new_v, new_b))
-        new_z_local = jnp.where(is_refractory, zeros_like_spikes, self.compute_z(new_v, new_b))
+        z_computed = self.compute_z(new_v, new_b)
+        new_z = jnp.where(is_refractory, zeros_like_spikes, z_computed)
+        new_z_local = jnp.where(is_refractory, zeros_like_spikes, z_computed)
         new_r = state.r + self.n_refractory * new_z - 1
         new_r = jnp.clip(new_r, 0., float(self.n_refractory))
 
@@ -206,6 +247,8 @@ def get_new_v_b(s, i_t):
 class LeakyLinear(hk.RNNCore):
     """
     Leaky real-valued output neuron from the code of the paper https://github.com/IGITUGraz/eligibility_propagation
+
+    To be replace with Linear + LI in the future.
  
     """
     def __init__(self, n_in, n_out, kappa, dtype=jnp.float32, name="LeakyLinear"):
diff --git a/tests/shd.ipynb b/tests/shd.ipynb
deleted file mode 100644
index b7d21a2..0000000
--- a/tests/shd.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells":[{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["from spyx.nn import LeakyLinear, RecurrentLIFLight"]},{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:26.124346Z","iopub.status.busy":"2024-03-25T00:51:26.123957Z","iopub.status.idle":"2024-03-25T00:51:45.375066Z","shell.execute_reply":"2024-03-25T00:51:45.374022Z","shell.execute_reply.started":"2024-03-25T00:51:26.124313Z"},"trusted":true},"outputs":[],"source":["import spyx\n","import spyx.nn as snn\n","\n","# JAX imports\n","import os\n","import jax\n","from jax import numpy as jnp\n","import jmp # jax mixed-precision\n","import numpy as np\n","\n","from jax_tqdm import scan_tqdm\n","from tqdm import tqdm\n","\n","# implement our SNN in DeepMind's Haiku\n","import haiku as hk\n","\n","# for surrogate loss training.\n","import optax\n","\n","# rendering tools\n","import matplotlib.pyplot as plt\n","from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:51:53.610008Z","iopub.status.busy":"2024-03-25T00:51:53.609590Z","iopub.status.idle":"2024-03-25T00:52:53.102621Z","shell.execute_reply":"2024-03-25T00:52:53.101491Z","shell.execute_reply.started":"2024-03-25T00:51:53.609973Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Downloading https://zenkelab.org/datasets/shd_train.h5.zip to ./data/SHD/shd_train.h5.zip\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"2a223b925860402a82d8731c8dc65a37","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/130863613 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Extracting ./data/SHD/shd_train.h5.zip to ./data/SHD\n","Downloading https://zenkelab.org/datasets/shd_test.h5.zip to ./data/SHD/shd_test.h5.zip\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"ae4e5785cb394ff59cc70e984693efab","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/38141465 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Extracting ./data/SHD/shd_test.h5.zip to ./data/SHD\n"]}],"source":["shd_dl = spyx.loaders.SHD_loader(256,128,128)"]},{"cell_type":"code","execution_count":16,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:34.878852Z","iopub.status.busy":"2024-03-25T00:59:34.877963Z","iopub.status.idle":"2024-03-25T00:59:34.894764Z","shell.execute_reply":"2024-03-25T00:59:34.893802Z","shell.execute_reply.started":"2024-03-25T00:59:34.878814Z"},"trusted":true},"outputs":[],"source":["key = jax.random.PRNGKey(0)\n","x,y = shd_dl.train_epoch(key)"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.107085Z","iopub.status.busy":"2024-03-25T00:59:35.106146Z","iopub.status.idle":"2024-03-25T00:59:35.116003Z","shell.execute_reply":"2024-03-25T00:59:35.114928Z","shell.execute_reply.started":"2024-03-25T00:59:35.107049Z"},"trusted":true},"outputs":[],"source":["\n","def lsnn_shd(x, state=None):\n","    n_rec = 400\n","    tau = 20\n","    dt = 1\n","    core = hk.DeepRNN([\n","        hk.Linear(n_rec),\n","        RecurrentLIFLight(n_rec,\n","            tau=tau,\n","            thr=0.8,\n","            dt=dt,\n","            dtype=jnp.float32,\n","            dampening_factor=0.3,\n","            tau_adaptation=500,\n","            beta=0.07 * jnp.ones(n_rec),\n","            tag='',\n","            stop_gradients=True,\n","            w_rec_init=None,\n","            n_refractory=3,\n","            rec=True,),\n","       LeakyLinear(n_rec, 20, jnp.exp(-dt/tau))\n","    ])\n","    spikes, hiddens = hk.dynamic_unroll(core, x, core.initial_state(x.shape[0]), time_major=False, unroll=128)#16) # unroll our model.\n","    \n","    return spikes, hiddens"]},{"cell_type":"code","execution_count":18,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.281232Z","iopub.status.busy":"2024-03-25T00:59:35.280138Z","iopub.status.idle":"2024-03-25T00:59:35.287667Z","shell.execute_reply":"2024-03-25T00:59:35.286683Z","shell.execute_reply.started":"2024-03-25T00:59:35.281194Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256, 16, 128)"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["x.shape"]},{"cell_type":"code","execution_count":19,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.472580Z","iopub.status.busy":"2024-03-25T00:59:35.471589Z","iopub.status.idle":"2024-03-25T00:59:35.479043Z","shell.execute_reply":"2024-03-25T00:59:35.477983Z","shell.execute_reply.started":"2024-03-25T00:59:35.472547Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(25, 256)"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["y.shape"]},{"cell_type":"code","execution_count":20,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T00:59:35.622628Z","iopub.status.busy":"2024-03-25T00:59:35.621698Z","iopub.status.idle":"2024-03-25T01:00:13.651070Z","shell.execute_reply":"2024-03-25T01:00:13.650089Z","shell.execute_reply.started":"2024-03-25T00:59:35.622595Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (1, 256, 128)\n","iin (1, 400)\n","iin (1, 400)\n"]}],"source":["# Create a random key\n","# Since there's nothing stochastic about the network, we can avoid using an RNG as a param!\n","SNN = hk.without_apply_rng(hk.transform(lsnn_shd))\n","\n","x0 = jnp.zeros((1, 256, 128))\n","params = SNN.init(rng=key, x=x0)\n"]},{"cell_type":"code","execution_count":21,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.654007Z","iopub.status.busy":"2024-03-25T01:00:13.653689Z","iopub.status.idle":"2024-03-25T01:00:13.671535Z","shell.execute_reply":"2024-03-25T01:00:13.670388Z","shell.execute_reply.started":"2024-03-25T01:00:13.653979Z"},"trusted":true},"outputs":[],"source":["def gd(SNN, params, dl, epochs=300, schedule=3e-4):\n","\n","    # We use optax for our optimizer.\n","    opt = optax.adam(learning_rate=schedule)\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    # create and initialize the optimizer\n","    opt_state = opt.init(params)\n","    grad_params = params\n","\n","    # define and compile our eval function that computes the loss for our SNN\n","    @jax.jit\n","    def net_eval(weights, events, targets):\n","        readout = SNN.apply(weights, events)\n","        traces, V_f = readout\n","        return Loss(traces, targets)\n","\n","    # Use JAX to create a function that calculates the loss and the gradient!\n","    surrogate_grad = jax.value_and_grad(net_eval)\n","\n","    rng = jax.random.PRNGKey(0)\n","\n","    # compile the meat of our training loop for speed\n","    @jax.jit\n","    def train_step(state, data):\n","        # unpack the parameters and optimizer state\n","        grad_params, opt_state = state\n","        # unpack the data into x, y\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1) # decompress temporal axis\n","        # compute loss and gradient\n","        loss, grads = surrogate_grad(grad_params, events, targets)\n","        # generate updates based on the gradients and optimizer\n","        updates, opt_state = opt.update(grads, opt_state, grad_params)\n","        # return the updated parameters\n","        new_state = [optax.apply_updates(grad_params, updates), opt_state]\n","        return new_state, loss\n","\n","    # For validation epochs, do the same as before but compute the\n","    # accuracy, predictions and losses (no gradients needed)\n","    @jax.jit\n","    def eval_step(grad_params, data):\n","        # unpack our data\n","        events, targets = data\n","        # decompress information along temporal axis\n","        events = jnp.unpackbits(events, axis=1)\n","        # apply the network to the data\n","        readout = SNN.apply(grad_params, events)\n","        # unpack the final layer outputs and end state of each SNN layer\n","        traces, V_f = readout\n","        # compute accuracy, predictions, and loss\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        # we return the parameters here because of how jax.scan is structured.\n","        return grad_params, jnp.array([acc, loss])\n","\n","\n","    val_data = dl.val_epoch()\n","\n","    # Here's the start of our training loop!\n","    @scan_tqdm(epochs)\n","    def epoch(epoch_state, epoch_num):\n","        curr_params, curr_opt_state = epoch_state\n","\n","        shuffle_rng = jax.random.fold_in(rng, epoch_num)\n","        train_data = dl.train_epoch(shuffle_rng)\n","\n","        # train epoch\n","        end_state, train_loss = jax.lax.scan(\n","            train_step,# our function which computes and updates gradients for one batch\n","            [curr_params, curr_opt_state], # initialize with parameters and optimizer state of current epoch\n","            train_data,# pass the newly shuffled training data\n","            train_data.obs.shape[0]# this corresponds to the number of training batches\n","        )\n","\n","        new_params, _ = end_state\n","\n","        # val epoch\n","        _, val_metrics = jax.lax.scan(\n","            eval_step,# func\n","            new_params,# init\n","            val_data,# xs\n","            val_data.obs.shape[0]# len\n","        )\n","        \n","        print(val_metrics)\n","\n","\n","        return end_state, jnp.concatenate([jnp.expand_dims(jnp.mean(train_loss),0), jnp.mean(val_metrics, axis=0)])\n","    # end epoch\n","\n","    # epoch loop\n","    final_state, metrics = jax.lax.scan(\n","        epoch,\n","        [grad_params, opt_state], # metric arrays\n","        jnp.arange(epochs), #\n","        epochs # len of loop\n","    )\n","\n","    final_params, final_optimizer_state = final_state\n","\n","\n","    # return our final, optimized network.\n","    return final_params, metrics"]},{"cell_type":"code","execution_count":22,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:00:13.673210Z","iopub.status.busy":"2024-03-25T01:00:13.672889Z","iopub.status.idle":"2024-03-25T01:01:39.734131Z","shell.execute_reply":"2024-03-25T01:01:39.732917Z","shell.execute_reply.started":"2024-03-25T01:00:13.673183Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","x_input (256, 128, 128)\n","iin (256, 400)\n","Traced<ShapedArray(float32[6,2])>with<DynamicJaxprTrace(level=1/0)>\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"27a910e6ae494f57addc365f80e51b15","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/60 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"}],"source":["grad_params, metrics = gd(SNN, params, shd_dl, epochs=60) # this takes a minute or two to compile on Colab because of weak CPU compute.\n"]},{"cell_type":"code","execution_count":23,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.737814Z","iopub.status.busy":"2024-03-25T01:01:39.737403Z","iopub.status.idle":"2024-03-25T01:01:39.748389Z","shell.execute_reply":"2024-03-25T01:01:39.747242Z","shell.execute_reply.started":"2024-03-25T01:01:39.737774Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["[3.3396416 2.7394361 2.5159357 2.3944805 2.311097  2.259231  2.254243\n"," 2.1969118 2.1640594 2.1198297 2.1289842 2.0941677 2.0898578 2.0560226\n"," 2.0525196 2.020626  2.0091455 1.9951267 1.9801593 1.9889545 1.9905777\n"," 1.9748755 1.9900997 1.9820318 1.9319314 1.9379961 1.9430561 1.9162053\n"," 1.9080309 1.9121706 1.9099082 1.8986979 1.9173098 1.8822697 1.8949358\n"," 1.8759296 1.8963922 1.872345  1.8697561 1.8655033 1.8835618 1.8791912\n"," 1.8660862 1.8646512 1.853204  1.8516091 1.8390594 1.842894  1.8579562\n"," 1.8335865 1.8404154 1.8479518 1.8314093 1.818244  1.8273256 1.8267124\n"," 1.8125165 1.8106669 1.8294351 1.8155215]\n","[0.13346355 0.30013022 0.40429688 0.4811198  0.5286459  0.57682294\n"," 0.5839844  0.6197917  0.6295573  0.6790365  0.66015625 0.69921875\n"," 0.69596356 0.718099   0.7285156  0.74609375 0.76171875 0.765625\n"," 0.7714844  0.7623698  0.75846356 0.780599   0.76627606 0.764974\n"," 0.79752606 0.8046875  0.7727865  0.8072917  0.8092448  0.8170573\n"," 0.8222656  0.8255209  0.8105469  0.8300781  0.82682294 0.8229167\n"," 0.81575525 0.83463544 0.8372396  0.843099   0.8261719  0.83658856\n"," 0.8378906  0.84375    0.85546875 0.8483073  0.86002606 0.85026044\n"," 0.83203125 0.8535156  0.85026044 0.8567709  0.8463542  0.858724\n"," 0.8645834  0.85481775 0.86263025 0.86002606 0.84765625 0.859375  ]\n"]}],"source":["print(metrics[:, 2])\n","print(metrics[:, 1])"]},{"cell_type":"code","execution_count":24,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:39.749919Z","iopub.status.busy":"2024-03-25T01:01:39.749580Z","iopub.status.idle":"2024-03-25T01:01:40.361273Z","shell.execute_reply":"2024-03-25T01:01:40.360235Z","shell.execute_reply.started":"2024-03-25T01:01:39.749890Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Performance: train_loss=1.655739426612854, val_acc=0.859375, val_loss=1.815521478652954\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["print(\"Performance: train_loss={}, val_acc={}, val_loss={}\".format(*metrics[-1]))\n","\n","\n","fig, ax1 = plt.subplots()\n","ax1.plot(metrics[:,0], label=\"train loss\")\n","ax1.plot(metrics[:,2], label=\"val loss\")\n","ax1.legend(loc='upper left')\n","ax1.set_xlabel(\"Epochs\")\n","ax1.set_ylabel(\"Loss\")\n","ax1.set_ylim(0, max(np.max(metrics[:,0]), np.max(metrics[:,2]))*1.1)\n","ax2 = ax1.twinx()\n","ax2.plot(metrics[:,1], label=\"val acc\", color='r')\n","ax2.set_ylabel(\"Val Accuracy\")\n","ax2.set_ylim(0,1)\n","ax2.legend()\n","\n","plt.title(\"SHD Surrogate Gradient\")\n","plt.tight_layout()\n","plt.show()"]},{"cell_type":"code","execution_count":25,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.363053Z","iopub.status.busy":"2024-03-25T01:01:40.362629Z","iopub.status.idle":"2024-03-25T01:01:40.372790Z","shell.execute_reply":"2024-03-25T01:01:40.371148Z","shell.execute_reply.started":"2024-03-25T01:01:40.363023Z"},"trusted":true},"outputs":[],"source":["def test_gd(SNN, params, dl):\n","\n","    Loss = spyx.fn.integral_crossentropy()\n","    Acc = spyx.fn.integral_accuracy()\n","\n","    @jax.jit\n","    def test_step(params, data):\n","        events, targets = data\n","        events = jnp.unpackbits(events, axis=1)\n","        readout = SNN.apply(params, events)\n","        traces, V_f = readout\n","        acc, pred = Acc(traces, targets)\n","        loss = Loss(traces, targets)\n","        return params, [acc, loss, pred, targets]\n","\n","    test_data = dl.test_epoch()\n","\n","    _, test_metrics = jax.lax.scan(\n","            test_step,# func\n","            params,# init\n","            test_data,# xs\n","            test_data.obs.shape[0]# len\n","    )\n","\n","    acc = jnp.mean(test_metrics[0])\n","    loss = jnp.mean(test_metrics[1])\n","    preds = jnp.array(test_metrics[2]).flatten()\n","    tgts = jnp.array(test_metrics[3]).flatten()\n","    return acc, loss, preds, tgts\n"]},{"cell_type":"code","execution_count":26,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:40.374642Z","iopub.status.busy":"2024-03-25T01:01:40.374229Z","iopub.status.idle":"2024-03-25T01:01:51.992083Z","shell.execute_reply":"2024-03-25T01:01:51.991062Z","shell.execute_reply.started":"2024-03-25T01:01:40.374600Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["x_input (256, 128, 128)\n","iin (256, 400)\n","Accuracy: 0.7529297 Loss: 2.0053806\n"]}],"source":["acc, loss, preds, tgts = test_gd(SNN, grad_params, shd_dl)\n","print(\"Accuracy:\", acc, \"Loss:\", loss)\n"]},{"cell_type":"code","execution_count":27,"metadata":{"execution":{"iopub.execute_input":"2024-03-25T01:01:51.993950Z","iopub.status.busy":"2024-03-25T01:01:51.993610Z","iopub.status.idle":"2024-03-25T01:01:53.139665Z","shell.execute_reply":"2024-03-25T01:01:53.138548Z","shell.execute_reply.started":"2024-03-25T01:01:51.993921Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["cm = confusion_matrix(tgts, preds)\n","ConfusionMatrixDisplay(cm).plot()\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["LOSS REGULARIZATION PAPER + SOFTMAX"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[],"dockerImageVersionId":30665,"isGpuEnabled":true,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.13"}},"nbformat":4,"nbformat_minor":4}
diff --git a/tests/test_eprop.py b/tests/test_eprop.py
new file mode 100644
index 0000000..5192bc0
--- /dev/null
+++ b/tests/test_eprop.py
@@ -0,0 +1,26 @@
+from spyx.axn import abs_linear
+import jax.numpy as jnp
+import jax
+import numpy as np
+
+
+def test_axn_abs_linear():
+    """
+    Test the abs_linear surrogate gradient function.
+    """
+
+    # Test the abs_linear surrogate gradient function.
+    x = jnp.linspace(-10, 10, 100, dtype=jnp.float32)
+    f = abs_linear(dampening_factor=0.3)
+
+    y = f(x)
+    y_grad = jax.jacrev(f)(x).diagonal()
+
+    y_true = jnp.greater(x, 0.).astype(jnp.float32)
+    y_true_grad = jnp.maximum(0.3*(1 - jnp.abs(x)), 0).astype(jnp.float32)
+ 
+    assert np.allclose(y, y_true, atol=1e-5)
+    assert np.allclose(y_grad, y_true_grad, atol=1e-5)
+
+def test_eprop():
+    pass
\ No newline at end of file

From 9f729c3c7a139b226c2d24035d449f7caf33c90e Mon Sep 17 00:00:00 2001
From: Florent Pollet <flo1.raymond@gmail.com>
Date: Sun, 5 May 2024 23:25:47 -0400
Subject: [PATCH 3/3] WIP LeakyLinear replacement

---
 spyx/nn.py          |  15 ++++---
 tests/test_eprop.py | 102 +++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 111 insertions(+), 6 deletions(-)

diff --git a/spyx/nn.py b/spyx/nn.py
index 86464fb..11621b0 100644
--- a/spyx/nn.py
+++ b/spyx/nn.py
@@ -100,9 +100,9 @@ class RecurrentLIFLight(hk.RNNCore):
     ------
     n_rec: int
         Number of recurrent neurons.
-    tau: float
+    tau: float or array
         Membrane time constant (ms)
-    thr: float
+    thr: float or array
         Firing threshold.
     dt: float
         Time step (ms)
@@ -110,9 +110,9 @@ class RecurrentLIFLight(hk.RNNCore):
         Data type.
     dampening_factor: float
         Dampening factor for the surrogate gradient (see abs_linear).
-    tau_adaptation: float
+    tau_adaptation: float or array
         Time constant for threshold adaptation (ALIF model)
-    beta: float
+    beta: float or array
         Decay rate for threshold adaptation (ALIF model)
     tag: str
         parameter tag.
@@ -143,7 +143,7 @@ def __init__(self,
         self.decay_b = jnp.exp(-dt / tau_adaptation)
 
         if jnp.isscalar(tau): tau = jnp.ones(n_rec, dtype=dtype) * jnp.mean(tau)
-        if jnp.isscalar(thr): thr = jnp.ones(n_rec, dtype=dtype) * jnp.mean(thr)
+        if jnp.isscalar(thr): thr = jnp.ones(n_rec, dtype=dtype) * jnp.mean(thr)        
 
         tau = jnp.array(tau, dtype=dtype)
         dt = jnp.array(dt, dtype=dtype)
@@ -261,6 +261,11 @@ def __init__(self, n_in, n_out, kappa, dtype=jnp.float32, name="LeakyLinear"):
 
         self.weights = hk.get_parameter("weights", shape=[n_in, n_out], dtype=dtype,
                                         init=hk.initializers.TruncatedNormal(1./jnp.sqrt(n_in)))
+        
+        # self.weights = hk.get_parameter("weights", shape=[n_in, n_out], dtype=dtype,
+        #                                 init=hk.initializers.Constant(
+        #                                     jnp.eye(n_in, n_out)
+        #                                 ))
 
         self._num_units = self.n_out
         self.built = True
diff --git a/tests/test_eprop.py b/tests/test_eprop.py
index 5192bc0..419499a 100644
--- a/tests/test_eprop.py
+++ b/tests/test_eprop.py
@@ -1,8 +1,11 @@
 from spyx.axn import abs_linear
+from spyx.nn import RecurrentLIFLight, LeakyLinear, LI
 import jax.numpy as jnp
 import jax
 import numpy as np
 
+import haiku as hk
+
 
 def test_axn_abs_linear():
     """
@@ -23,4 +26,101 @@ def test_axn_abs_linear():
     assert np.allclose(y_grad, y_true_grad, atol=1e-5)
 
 def test_eprop():
-    pass
\ No newline at end of file
+    n_in = 3
+    n_LIF = 2
+    n_ALIF = 2
+    n_rec = n_ALIF + n_LIF
+
+    dt = 1  # ms
+    tau_v = 20  # ms
+    tau_a = 500  # ms
+    T = 100  # ms
+    f0 = 100  # Hz
+
+    thr = 0.62 
+    beta = 0.07 * jnp.concatenate([jnp.zeros(n_LIF), jnp.ones(n_ALIF)])
+    dampening_factor = 0.3
+    n_ref = 3
+    batch_size = 5
+
+    key = jax.random.PRNGKey(2)
+    inputs = (jax.random.uniform(key, shape=(1, T, n_in)) < f0 * dt / 1000).astype(float)
+    print(inputs.shape, inputs)
+
+    def lsnn(x, state=None, batch_size=1):
+        core = hk.DeepRNN([
+            hk.Linear(n_rec),
+            RecurrentLIFLight(
+                n_rec,
+                tau=tau_v,
+                thr=thr,
+                dt=dt,
+                dtype=jnp.float32,
+                dampening_factor=dampening_factor,
+                tau_adaptation=tau_a,
+                beta=beta,
+                tag='',
+                stop_gradients=True,
+                w_rec_init=None,
+                n_refractory=n_ref,
+                rec=True,
+            ),
+            # LeakyLinear(n_rec, 20, jnp.exp(-dt/tau_v))
+            hk.Linear(20, with_bias=False, w_init=hk.initializers.Constant(
+                (1-jnp.exp(-dt/tau_v))*jnp.eye(n_rec, 20))),
+            LI((20,), jnp.exp(-dt/tau_v))
+        ])
+        if state is None:
+            state = core.initial_state(batch_size)
+        spikes, hiddens = core(x, state)
+        return spikes, hiddens
+
+    lsnn_hk = hk.without_apply_rng(hk.transform(lsnn))
+    # i0 = jnp.stack([inputs[:,0], inputs[:,0], inputs[:,0],inputs[:,0], inputs[:,0]], axis=0)
+    # i0 = jnp.zeros((batch_size, n_in))
+    i0 = []
+    for _ in range(batch_size):
+        i0.append(inputs[:,0])
+    i0 = jnp.stack(i0, axis=0)
+    print(i0.shape)
+    params = lsnn_hk.init(rng=key, x=i0, batch_size=batch_size)
+    print(params)
+    # w_in_copy = [[ 0.7967948 , -0.3821632 , -0.7605332 ,  0.45293623],
+    #    [-0.03456055,  0.65856   ,  0.58331513, -0.10983399],
+    #    [-0.4869853 ,  1.0580422 ,  0.53946483, -0.00187313]]
+    # w_in_copy = jnp.array(w_in_copy)
+
+    state = None
+    spikes = []
+    V = []
+    variations = []
+    # if w_rec is not None:
+    #     params['RecurrentLIFLight']['w_rec'] = w_rec
+    # if w_in is not None:
+    #     params['linear']['w'] = w_in
+    # if w_out is not None:
+    #     params['LeakyLinear']['weights'] = w_out
+    for t in range(T):
+        it = inputs[:, t]
+        it = jnp.expand_dims(it, axis=0)
+        outs, state = lsnn_hk.apply(params, it, state, batch_size)
+        # print(inputs[:,t], "->", outs)
+        spikes.append(outs)
+
+    y_out = jnp.stack([s[0] for s in spikes], axis=0)
+    y_target = jax.random.normal(key=key, shape=[T, 1])
+    print(y_out.shape, y_target.shape)
+    loss = 0.5 * jnp.sum((y_out - y_target) ** 2)
+    y_out = jnp.expand_dims(y_out, axis=0)
+    y_target = jnp.expand_dims(y_target, axis=0)
+
+    print(loss)
+    loss_target = 838.4397
+
+    assert np.allclose(loss, loss_target, atol=1e-5)
+
+    # TODO grad compute eprop and bptt
+
+if __name__ == "__main__":
+    # test_axn_abs_linear()
+    test_eprop()
\ No newline at end of file