diff --git a/README.rst b/README.rst
index 911c910..cef91f2 100644
--- a/README.rst
+++ b/README.rst
@@ -61,7 +61,8 @@ To install BluePyEfe, run:
 Quick Start and Operating Principle
 ===================================
 
-For a hands-on introduction to BluePyEfe, have a look at the notebook `examples/example_of_extraction.ipynb <examples/example_of_extraction.ipynb>`_
+For a hands-on introduction to BluePyEfe, have a look at the notebook `examples/example_of_extraction.ipynb <examples/example_of_extraction.ipynb>`_.
+For an NWB-focused example, see `examples/nwb_extraction.ipynb <examples/nwb_extraction.ipynb>`_.
 
 The goal of the present package is to extract meaningful electrophysiological features (e-features) from voltage time series.
 The e-features considered in the present package are the one implemented in the `eFEL python library <https://github.com/openbraininstitute/eFEL>`_. See `this pdf <https://bluebrain.github.io/eFEL/efeature-documentation.pdf>`_ for a list of available e-features.
diff --git a/bluepyefe/ecode/__init__.py b/bluepyefe/ecode/__init__.py
index 4b6623b..3c7833b 100644
--- a/bluepyefe/ecode/__init__.py
+++ b/bluepyefe/ecode/__init__.py
@@ -18,7 +18,9 @@
 from . import DeHyperPol
 from . import HyperDePol
 from . import SpikeRec
+from . import capCheck
 from . import negCheops
+from . import pinkNoise
 from . import posCheops
 from . import ramp
 from . import sAHP
@@ -63,4 +65,6 @@
     "poscheops": posCheops.PosCheops,
     "spikerec": SpikeRec.SpikeRec,
     "sinespec": sineSpec.SineSpec,
+    "pinknoise": pinkNoise.PinkNoise,
+    "capcheck": capCheck.CapCheck,
 }
diff --git a/bluepyefe/ecode/capCheck.py b/bluepyefe/ecode/capCheck.py
new file mode 100644
index 0000000..99a4fcb
--- /dev/null
+++ b/bluepyefe/ecode/capCheck.py
@@ -0,0 +1,152 @@
+"""CapCheck eCode class"""
+
+"""
+Copyright 2026 Open Brain Institute
+
+ This file is part of BluePyEfe <https://github.com/openbraininstitute/BluePyEfe>
+
+ This library is free software; you can redistribute it and/or modify it under
+ the terms of the GNU Lesser General Public License version 3.0 as published
+ by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+"""
+import logging
+import numpy
+
+from ..recording import Recording
+from .tools import base_current
+
+logger = logging.getLogger(__name__)
+
+
+class CapCheck(Recording):
+    """Capacitance-check current stimulus.
+
+    This protocol applies a repeated capacitance-check current command.
+    The stimulus contains alternating positive/negative pulses around the holding current.
+    It is used to determine membrane capacitance from the passive voltage response.
+    """
+
+    def __init__(
+        self,
+        config_data,
+        reader_data,
+        protocol_name="CapCheck",
+        efel_settings=None
+    ):
+
+        super(CapCheck, self).__init__(config_data, reader_data, protocol_name)
+
+        self.ton = None
+        self.toff = None
+        self.tend = None
+        self.amp = None
+        self.hypamp = None
+        self.dt = None
+        self.waveform = None
+
+        self.amp_rel = None
+        self.hypamp_rel = None
+
+        if self.t is not None and self.current is not None:
+            self.interpret(
+                self.t, self.current, self.config_data, self.reader_data
+            )
+
+        if self.voltage is not None:
+            self.set_autothreshold()
+            self.compute_spikecount(efel_settings)
+
+        self.export_attr = ["ton", "toff", "tend", "amp", "hypamp", "dt",
+                            "waveform", "amp_rel", "hypamp_rel"]
+
+    def get_stimulus_parameters(self):
+        """Returns the eCode parameters"""
+        ecode_params = {
+            "delay": self.ton,
+            "amp": self.amp,
+            "thresh_perc": self.amp_rel,
+            "duration": self.toff - self.ton,
+            "totduration": self.tend,
+            "dt": self.dt,
+            "waveform": self.waveform,
+        }
+        return ecode_params
+
+    def _get_timing_index(self, name, config_data, reader_data):
+        if name in config_data and config_data[name] is not None:
+            return int(round(config_data[name] / self.dt))
+        if name in reader_data and reader_data[name] is not None:
+            return int(round(reader_data[name]))
+        return None
+
+    def _detect_stimulus_indexes(self, current):
+        deviation = numpy.abs(numpy.asarray(current) - self.hypamp)
+        edge = min(max(1, int(round(10.0 / self.dt))), len(deviation))
+        noise_level = numpy.std(
+            numpy.concatenate((deviation[:edge], deviation[-edge:]))
+        )
+        threshold = max(4.5 * noise_level, 0.02 * numpy.max(deviation), 1e-5)
+        active = numpy.flatnonzero(deviation > threshold)
+
+        if len(active) == 0:
+            logger.warning(
+                "The automatic cap-check detection failed for the recording "
+                f"{self.protocol_name} in files {self.files}. The whole trace "
+                "will be used as the stimulus waveform."
+            )
+            return 0, len(deviation)
+
+        return active[0], active[-1] + 1
+
+    def interpret(self, t, current, config_data, reader_data):
+        """Analyse a current array and extract from it the parameters
+        needed to reconstruct the array"""
+        self.dt = t[1]
+
+        ton = self._get_timing_index("ton", config_data, reader_data)
+        toff = self._get_timing_index("toff", config_data, reader_data)
+
+        hypamp_value = base_current(current, idx_ton=300 if ton is None else ton)
+        self.set_amplitudes_ecode("hypamp", config_data, reader_data, hypamp_value)
+
+        if ton is None or toff is None:
+            detected_ton, detected_toff = self._detect_stimulus_indexes(current)
+            ton = detected_ton if ton is None else ton
+            toff = detected_toff if toff is None else toff
+
+        ton = max(0, min(ton, len(current) - 1))
+        toff = max(ton + 1, min(toff, len(current)))
+
+        stimulus = numpy.asarray(current[ton:toff]) - self.hypamp
+        amp_value = numpy.max(numpy.abs(stimulus)) if len(stimulus) else 0.0
+        self.set_amplitudes_ecode("amp", config_data, reader_data, amp_value)
+
+        if self.amp == 0.0:
+            self.waveform = numpy.zeros(stimulus.shape)
+        else:
+            self.waveform = stimulus / self.amp
+
+        self.ton = t[ton]
+        self.toff = t[toff] if toff < len(t) else len(t) * self.dt
+        self.tend = len(t) * self.dt
+
+    def generate(self):
+        """Generate the current array from the parameters of the ecode"""
+        t = numpy.arange(0.0, self.tend, self.dt)
+        current = numpy.full(t.shape, numpy.float64(self.hypamp))
+
+        waveform = numpy.asarray(self.waveform)
+        ton = int(self.ton / self.dt)
+        toff = min(ton + len(waveform), len(current))
+        current[ton:toff] += numpy.float64(self.amp) * waveform[:toff - ton]
+
+        return t, current
diff --git a/bluepyefe/ecode/pinkNoise.py b/bluepyefe/ecode/pinkNoise.py
new file mode 100644
index 0000000..7942621
--- /dev/null
+++ b/bluepyefe/ecode/pinkNoise.py
@@ -0,0 +1,156 @@
+"""PinkNoise eCode class"""
+
+"""
+Copyright 2026 Open Brain Institute
+
+ This file is part of BluePyEfe <https://github.com/openbraininstitute/BluePyEfe>
+
+ This library is free software; you can redistribute it and/or modify it under
+ the terms of the GNU Lesser General Public License version 3.0 as published
+ by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+"""
+import logging
+import numpy
+
+from ..recording import Recording
+from .tools import base_current
+from .tools import scipy_signal2d
+
+logger = logging.getLogger(__name__)
+
+
+class PinkNoise(Recording):
+    """Rheobase-scaled pink-noise stimulation protocol.
+
+    This protocol applies a pink-noise current command scaled relative to the
+    rheobase. The stimulus uses three amplitude levels: 0.75x, 1x, and 1.5x
+    rheobase. It is used to measure the response to suprathreshold noisy
+    stimulation and for model fitting and validation.
+    """
+
+    def __init__(
+        self,
+        config_data,
+        reader_data,
+        protocol_name="PinkNoise",
+        efel_settings=None
+    ):
+
+        super(PinkNoise, self).__init__(config_data, reader_data, protocol_name)
+
+        self.ton = None
+        self.toff = None
+        self.tend = None
+        self.amp = None
+        self.hypamp = None
+        self.dt = None
+        self.waveform = None
+
+        self.amp_rel = None
+        self.hypamp_rel = None
+
+        if self.t is not None and self.current is not None:
+            self.interpret(
+                self.t, self.current, self.config_data, self.reader_data
+            )
+
+        if self.voltage is not None:
+            self.set_autothreshold()
+            self.compute_spikecount(efel_settings)
+
+        self.export_attr = ["ton", "toff", "tend", "amp", "hypamp", "dt",
+                            "waveform", "amp_rel", "hypamp_rel"]
+
+    def get_stimulus_parameters(self):
+        """Returns the eCode parameters"""
+        ecode_params = {
+            "delay": self.ton,
+            "amp": self.amp,
+            "thresh_perc": self.amp_rel,
+            "duration": self.toff - self.ton,
+            "totduration": self.tend,
+            "dt": self.dt,
+            "waveform": self.waveform,
+        }
+        return ecode_params
+
+    def _get_timing_index(self, name, config_data, reader_data):
+        if name in config_data and config_data[name] is not None:
+            return int(round(config_data[name] / self.dt))
+        if name in reader_data and reader_data[name] is not None:
+            return int(round(reader_data[name]))
+        return None
+
+    def _detect_stimulus_indexes(self, smooth_current):
+        deviation = numpy.abs(numpy.asarray(smooth_current) - self.hypamp)
+        edge = min(max(1, int(round(10.0 / self.dt))), len(deviation))
+        noise_level = numpy.std(
+            numpy.concatenate((deviation[:edge], deviation[-edge:]))
+        )
+        threshold = max(4.5 * noise_level, 0.02 * numpy.max(deviation), 1e-5)
+        active = numpy.flatnonzero(deviation > threshold)
+
+        if len(active) == 0:
+            logger.warning(
+                "The automatic pink-noise detection failed for the recording "
+                f"{self.protocol_name} in files {self.files}. The whole trace "
+                "will be used as the stimulus waveform."
+            )
+            return 0, len(deviation)
+
+        return active[0], active[-1] + 1
+
+    def interpret(self, t, current, config_data, reader_data):
+        """Analyse a current array and extract from it the parameters
+        needed to reconstruct the array"""
+        self.dt = t[1]
+
+        smooth_current = scipy_signal2d(current, 85)
+
+        ton = self._get_timing_index("ton", config_data, reader_data)
+        toff = self._get_timing_index("toff", config_data, reader_data)
+
+        hypamp_value = base_current(current, idx_ton=300 if ton is None else ton)
+        self.set_amplitudes_ecode("hypamp", config_data, reader_data, hypamp_value)
+
+        if ton is None or toff is None:
+            detected_ton, detected_toff = self._detect_stimulus_indexes(smooth_current)
+            ton = detected_ton if ton is None else ton
+            toff = detected_toff if toff is None else toff
+
+        ton = max(0, min(ton, len(current) - 1))
+        toff = max(ton + 1, min(toff, len(current)))
+
+        stimulus = numpy.asarray(current[ton:toff]) - self.hypamp
+        amp_value = numpy.max(numpy.abs(stimulus)) if len(stimulus) else 0.0
+        self.set_amplitudes_ecode("amp", config_data, reader_data, amp_value)
+
+        if self.amp == 0.0:
+            self.waveform = numpy.zeros(stimulus.shape)
+        else:
+            self.waveform = stimulus / self.amp
+
+        self.ton = t[ton]
+        self.toff = t[toff] if toff < len(t) else len(t) * self.dt
+        self.tend = len(t) * self.dt
+
+    def generate(self):
+        """Generate the current array from the parameters of the ecode"""
+        t = numpy.arange(0.0, self.tend, self.dt)
+        current = numpy.full(t.shape, numpy.float64(self.hypamp))
+
+        waveform = numpy.asarray(self.waveform)
+        ton = int(self.ton / self.dt)
+        toff = min(ton + len(waveform), len(current))
+        current[ton:toff] += numpy.float64(self.amp) * waveform[:toff - ton]
+
+        return t, current
diff --git a/bluepyefe/ecode/sineSpec.py b/bluepyefe/ecode/sineSpec.py
index 2a122f7..6b17b81 100644
--- a/bluepyefe/ecode/sineSpec.py
+++ b/bluepyefe/ecode/sineSpec.py
@@ -27,6 +27,20 @@
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_CHIRP_FREQUENCY_BASE = 1.0
+DEFAULT_CHIRP_FREQUENCY_SCALE = 1.0
+DEFAULT_CHIRP_FREQUENCY_DENOMINATOR = 5.15
+DEFAULT_CHIRP_TIME_OFFSET = 0.1
+
+
+def _get_metadata_float(name, config_data, reader_data, default):
+    """Return a numeric metadata value, preferring config over reader data."""
+    if name in config_data and config_data[name] is not None:
+        return float(config_data[name])
+    if name in reader_data and reader_data[name] is not None:
+        return float(reader_data[name])
+    return default
+
 
 class SineSpec(Recording):
 
@@ -51,6 +65,30 @@ def __init__(
 
         self.amp_rel = None
         self.hypamp_rel = None
+        self.chirp_frequency_base = _get_metadata_float(
+            "chirp_frequency_base",
+            self.config_data,
+            self.reader_data,
+            DEFAULT_CHIRP_FREQUENCY_BASE,
+        )
+        self.chirp_frequency_scale = _get_metadata_float(
+            "chirp_frequency_scale",
+            self.config_data,
+            self.reader_data,
+            DEFAULT_CHIRP_FREQUENCY_SCALE,
+        )
+        self.chirp_frequency_denominator = _get_metadata_float(
+            "chirp_frequency_denominator",
+            self.config_data,
+            self.reader_data,
+            DEFAULT_CHIRP_FREQUENCY_DENOMINATOR,
+        )
+        self.chirp_time_offset = _get_metadata_float(
+            "chirp_time_offset",
+            self.config_data,
+            self.reader_data,
+            DEFAULT_CHIRP_TIME_OFFSET,
+        )
 
         if self.t is not None and self.current is not None:
             self.interpret(
@@ -62,7 +100,11 @@ def __init__(
             self.compute_spikecount(efel_settings)
 
         self.export_attr = ["ton", "toff", "tend", "amp", "hypamp", "dt",
-                            "amp_rel", "hypamp_rel"]
+                            "amp_rel", "hypamp_rel",
+                            "chirp_frequency_base",
+                            "chirp_frequency_scale",
+                            "chirp_frequency_denominator",
+                            "chirp_time_offset"]
 
     def get_stimulus_parameters(self):
         """Returns the eCode parameters"""
@@ -72,6 +114,10 @@ def get_stimulus_parameters(self):
             "thresh_perc": self.amp_rel,
             "duration": self.toff - self.ton,
             "totduration": self.tend,
+            "chirp_frequency_base": self.chirp_frequency_base,
+            "chirp_frequency_scale": self.chirp_frequency_scale,
+            "chirp_frequency_denominator": self.chirp_frequency_denominator,
+            "chirp_time_offset": self.chirp_time_offset,
         }
         return ecode_params
 
@@ -121,11 +167,18 @@ def generate(self):
         t = numpy.arange(0.0, self.tend, self.dt)
         t_sine = numpy.arange(0.0, self.tend / 1e3, self.dt / 1e3)
 
+        t_shifted = t_sine - self.chirp_time_offset
         current = self.amp * numpy.sin(
             2.0
             * numpy.pi
-            * (1.0 + (1.0 / (5.15 - (t_sine - 0.1))))
-            * (t_sine - 0.1)
+            * (
+                self.chirp_frequency_base
+                + (
+                    self.chirp_frequency_scale
+                    / (self.chirp_frequency_denominator - t_shifted)
+                )
+            )
+            * t_shifted
         )
 
         current[:ton_idx] = 0.0
diff --git a/bluepyefe/nwbreader.py b/bluepyefe/nwbreader.py
index 6cd251c..da42c45 100644
--- a/bluepyefe/nwbreader.py
+++ b/bluepyefe/nwbreader.py
@@ -5,9 +5,26 @@
 
 PROTOCOL_VU_TO_BBP = {
     "X1PS_SubThresh_DA_0": "IV",
-    "X2LP_Search_DA_0": "IDthresh",
-    "X4PS_SupraThresh_DA_0": "IDrest",
-    "CCSteps_DA_0": "Step"
+    "X2LP_Search_DA_0": "IDThresh",
+    "X3LP_Rheo_DA_0": "IDRest",
+    "X4PS_SupraThresh_DA_0": "IDRest",
+    "X4PT_C2NSD1SHORT_DA_0": "PinkNoise",
+    "X4PU_C2NSD2SHORT_DA_0": "PinkNoise",
+    "X5SP_Search_DA_0": "IDThresh",
+    "X6SP_Rheo_DA_0": "IDRest",
+    "X6SQ_C2SSTRIPLE_DA_0": "SpikeRec",
+    "X7Ramp_DA_0": "Ramp",
+    "X8_CHIRP_DA_0": "SineSpec",
+    "X9_C1QCAPCHK_DA_0": "CapCheck",
+    "X9_C1SQCAPCHK_DA_0": "CapCheck",
+    "CCSteps_DA_0": "Step",
+    "steps_DA_0": "Step",
+}
+
+VU_STIMULI_REQUIRING_INITIAL_SAMPLE_REPLACEMENT = {
+    "CCSteps_DA_0",
+    "X1PS_SubThresh_DA_0",
+    "X4PS_SupraThresh_DA_0",
 }
 
 
@@ -428,6 +445,11 @@ def read(self):
 
         data = []
         target_protocols = self._get_target_protocols()
+        target_protocols_lower = (
+            [protocol.lower() for protocol in target_protocols]
+            if target_protocols
+            else None
+        )
         for sweep_name, current_sweep in list(self.content["stimulus"]["presentation"].items()):
 
             stimulus_description = None
@@ -440,7 +462,10 @@ def read(self):
                 continue
             translated_name = PROTOCOL_VU_TO_BBP[stimulus_description]
 
-            if translated_name not in target_protocols:
+            if (
+                target_protocols_lower and
+                translated_name.lower() not in target_protocols_lower
+            ):
                 continue
 
             voltage_sweep_name = sweep_name.replace("DA", "AD")
@@ -455,6 +480,10 @@ def read(self):
                 start_time=voltage_sweeps[voltage_sweep_name]["starting_time"],
                 trace_name=sweep_name
             ))
+            if len(data[-1]["voltage"]) == 0 or len(data[-1]["current"]) == 0:
+                logger.info("Skipping %s because voltage or current data is empty.", sweep_name)
+                data.pop(-1)
+                continue
 
             # Shorten protocols that finish with NaNs
             first_nan = numpy.argmax(numpy.isnan(data[-1]["current"]))
@@ -467,19 +496,23 @@ def read(self):
                 data.pop(-1)
             else:
                 # Offset the current with the holding current
-                holding_current = float(voltage_sweeps[voltage_sweep_name]["bias_current"][()]) * 1e-12  # in pA
+                bias_current = voltage_sweeps[voltage_sweep_name]["bias_current"][()]
+                holding_current = float(numpy.asarray(bias_current).reshape(-1)[0]) * 1e-12  # in pA
                 data[-1]["current"] = numpy.asarray(data[-1]["current"]) + holding_current
 
-            # For Step, IV and IDRest protocols, replace the first 90 ms with the value at 90 ms
-            # if stimulus_description == "CCSteps_DA_0":
-            if any(stimulus_description in s for s in ["CCSteps_DA_0", "X1PS_SubThresh_DA_0", "X4PS_SupraThresh_DA_0"]):
-                if int(0.090 / data[-1]["dt"]) < len(data[-1]["current"]):
-                    data[-1]["current"][0:int(0.090 / data[-1]["dt"])] = data[-1]["current"][int(0.090 / data[-1]["dt"])]
-                    data[-1]["voltage"][0:int(0.090 / data[-1]["dt"])] = data[-1]["voltage"][int(0.090 / data[-1]["dt"])]
+            # For selected VU Step/IV/IDRest stimuli, replace samples before 90 ms
+            # with the current and voltage values at 90 ms.
+            if stimulus_description in VU_STIMULI_REQUIRING_INITIAL_SAMPLE_REPLACEMENT:
+                replacement_index = int(0.090 / data[-1]["dt"])
+                if replacement_index < len(data[-1]["current"]):
+                    data[-1]["current"][:replacement_index] = data[-1]["current"][replacement_index]
+                    data[-1]["voltage"][:replacement_index] = data[-1]["voltage"][replacement_index]
                 else:
-                    # Handle the case when the index is out of bounds
-                    # You can choose to raise an exception, set a default value, or handle it in a different way
-                    logger.info(f"For {stimulus_description}, unable to replace 0-40 ms value with the one at 40th ms as current/voltage array is too short")
+                    logger.info(
+                        "For %s, unable to replace 0-90 ms values with the values at "
+                        "90 ms as current/voltage array is too short",
+                        stimulus_description,
+                    )
                     continue
 
         return data
diff --git a/examples/example_of_extraction.ipynb b/examples/example_of_extraction.ipynb
index 03f650a..3d6b542 100644
--- a/examples/example_of_extraction.ipynb
+++ b/examples/example_of_extraction.ipynb
@@ -100,7 +100,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -159,7 +159,7 @@
    ],
    "source": [
     "cell.read_recordings(\n",
-    "    protocol_data=[files_metadata], \n",
+    "    protocol_data=[files_metadata],\n",
     "    protocol_name=\"IDRest\"\n",
     ")\n",
     "\n",
@@ -191,7 +191,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 352.8x345.6 with 2 Axes>"
       ]
@@ -241,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -273,7 +273,7 @@
     "]\n",
     "\n",
     "cell.extract_efeatures(\n",
-    "    protocol_name='IDRest', \n",
+    "    protocol_name='IDRest',\n",
     "    efeatures=interesting_efeatures\n",
     ")\n",
     "\n",
@@ -298,7 +298,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -398,7 +398,7 @@
     "            \"dt\": 0.00025,\n",
     "            \"ljp\": 14.\n",
     "        })\n",
-    "        \n",
+    "\n",
     "files_metadata"
    ]
   },
@@ -594,7 +594,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAkAAAFSCAYAAACQdoYSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADJeklEQVR4nOzdd3gTV9bA4d+R3G1s03sNAUIIaZBOQnrv2TR2Uze9J5tv05PdNNI2vZHe66aHTQIEAgQIECC0QCD0bjDuuEi63x8zFpIty7ItayT7vM9jkEajmWNZV5o5c++5YoxBKaWUUkoppZRSyuV0AEoppZRSSimllIoPmiRQSimllFJKKaUUoEkCpZRSSimllFJK2TRJoJRSSimllFJKKUCTBEoppZRSSimllLJpkkAppZRSSimllFKAJgmUUkoplQBEpI+IGBFJsu9PEpG/Ox1XPBGRESKy1Ok4lFJKJTZNEiillFIqZkTkfBGZLSIlIrJRRP4nIoc08z7vE5Eqe58lIvK7iJxZY52z7eXFIrJYRE5rwPZXiciOgO2XiMhzUf9F6mGMmWKMGRjr/dZM4ET4nPtE5N2A+0ZESu3XbpuITBCRc2o8Z5KIlNvrbBWRz0SkaxNjHyki65qyDaWUamk0SaCUUkqpmBCRm4GngIeAzkAv4AXg1Bjs/iNjTJYxJgu4EXhXRDrbcXUH3gVuBrKBW4H3RaRTA7Z/cvX27Z9roxx/WA05QY9je9p/n4HAm8BzInJvjXWutdfpD2QBj8c2RKWUavk0SaCUUkqpZiciOcC/gWuMMZ8ZY0qNMVXGmK+NMbfa67hE5DYR+dO+mvyxiLSLdizGmO+BYmAXe1EPoMAY8z9j+RYoDXi80UTkRRH5b8D9R+yr5FJ9FVtE7rCvjK8SkVEB66aKyOMiskZENovISyKSbj9W/dx/isgm4I2aV8Xt7d0qIvPtq/SviUhnu/dGsYiMF5G2AesfICLTRKRARH4TkZEBj00SkftF5Gf7uT+ISAf74cn2/wX2Vf4Dm/KaGWO2GmPeAa4CbheR9iHWKQC+APYKiHGQiIwTkXwRWSoiZwc8doLdQ6RYRNaLyD9EJBP4H9AtoAdIt6bErpRSLYEmCZRSSikVCwcCacDnYda5DjgNOAzoBmwHnq9vwyLSyz6x7RXBuiIiJwIpwGJ78WzgdxE5RUTc9lCDCmB+fduLwC3AHiJykYiMAC4FLjTGGPvxLkAHoDtwITBGRKqHDIwGBmCdCPe317knYNtdgHZAb+DyOvZ/JnC0vZ2TsU6K7wA6Yh0HXg/+3hTfAg/Y2/wH8F8R6RiwrfOBi4FOWK/fP+zlh9r/59q9KKY35G8SxpdAErBfzQfsxMEZwHL7fiYwDnjfju9c4AURGWw/5TXgCmNMG2AI8KMxphQ4HtgQ0ANkQxPiVUqpFkGTBEoppZSKhfbAVmOMJ8w6VwJ3GmPWGWMqgPuAs+rrSm+MWWOMyTXGrAmz2tkiUgCUAF8BD9lXozHGeIG3sU4wK+z/r7BPIiP1hX1SXP1zmb3tMuBvwH+whjRcZ4ypOQb+bmNMhTHmJ6wT9bNFRLBO/G8yxuQbY4qxhmmcG/A8H3Cv/dwddcT1rDFmszFmPTAF+MUYM9cYU46VsNnbXu+vwFhjzFhjjM8YMw4reXJCwLbeMMb8Ye/rYwKu4tcU4d8kLGNMFbAVK2lR7RkRKbSXd8BKLAGcBKwyxrxhjPEYY+YC/wX+Yj9eBQwWkWxjzHZjzJzGxqWUUi2dJgmUUkopFQvbgA71nPD3Bj6vPtEGfge8WPULmupj+6Q1E2sYwQUicgWAiBwFPAqMxLpCfhjwqojs1YDtn2Zvv/rnleoHjDG/ACsAwTq5DrS9RjJiNVYvio5ABvBrwOvxnb28Wp59sh/O5oDbO0Lcz7Jv9wb+EpjoAA4BAgsDbgq4XRbw3GYhIslYv29+wOLrjTE5wFCgLdZQEbDi379G/KOweluA1aPiBGC1iPzU1CERSinVkmmSQCmllFKxMB3rKv1pYdZZCxxf42Q7zb4KHjXGmFVY3e5PthftBUw2xsy2r6LPAn4BjorG/kTkGiAV2AD8X42H29pd5av1stfbinUSv3vAa5FjF+3z/yrRiM+2FninxmufaYwZHcFzoxlHoFMBDzCz1g6NWYA1NOJ5u9fFWuCnGvFnGWOustefZYw5FWsowhfsTNY0V+xKKZWwNEmglFJKqWZnjCnEGk//vIicJiIZIpIsIseLyKP2ai8BD4pIbwAR6SgiUZ/5QER6AMcBi+xFs4AR1T0HRGRvYAR2TQK7IGCjTiZFZADWyexfsYYd/F+IHgr/EpEUu2bBScAnxhgf8ArwpNizLIhIdxE5tjFxROBd4GQROdauy5Bm/9496n0m5GENfegXjUBEpJ1YBRyfBx4xxmyrY9W3sHqZnAJ8AwwQkb/Z76tkERkuIrvZr+0oEcmxhzAU2fGC1bOivViFNZVSSqFJAqWUUkrFiDHmCaxpBu/COrFcC1yLdWUX4GmsegE/iEgxMAPYv77t2kXySuopkndOdQV7rKTAz8C/7Lh+wqp/8Km93/9i1Sz4wX5uT2BaPWF8HVAhv0REPreHVryLdaL7mzFmGVbRwHdEJNV+3iasAo0bgPeAK40xS+zH/olVmG+GiBQB47GmB4w6Y8xarCv3d7Dzb3MrERwr2nUXHgR+trv6HxDh36Sm3+y/z3Lg71j1GO6pa2VjTCXWe+Zuu2bDMVg1GzZgva6PYPXgACtBs8p+Ha/EGoqA/Vp/AKywY9fZDZRSrZ7sLK6rlFJKKaVqEpFXsa7ufx/l7Y4E3jXGRHK1XimllIqJsNWClVJKKaVaO2PM352OQSmllIoVHW6glFJKKaWUUkopQIcbKKWUUkoppZRSyqY9CZRSSimllFJKKQVokkAppZRSSimllFI2TRIopZRSSimllFIK0CSBUkoppZRSSimlbJokiAIRuUhETrJvDxKR++pY79NQzxORK0Vkl0bsdx8RWS0i6Y0KvOH7GyIi79k/Q2o8dr6IvCIib4tIpoiMFJEpIvKSPQ80IvKIiLwhIh+KSEoE+3tcRJ5unt9GxQNtO9p2VONo29G2oxpP24+2H9U42nZaT9tJcjqAlsp+Q7wMFAL5xph/Bzw2GhBgIPAq0AVItxtaG8ADLDHGvCEirwBbgAOB640xCwN2cwFwD/AX4G0ReRNYA+wGTAZ6AUnGmJtE5GfgE2B34D5jzPpG/Fo3ANcABngUuCLgsdONMX+xPzjOsOMoAdKAdQDGmH/av/8TQHtgo31/JHAzMBXoasebCrQDfCKSaYwpbUS8KgFp29G2oxpH2462HdV42n60/ajG0bbTMtuO9iSInqtF5CXgPvv+McBkY8yNQG8RyQYQkRygi/3mmR5iOx/bjx0jInsA64wxdwK/B64kImlAB+A94OSAh14CHgD6GmNuBXray3cYY54CXsBqaNXbaSciT9X46V/H75hjjCkwxhRiNexA1XNprgZ6AFOMMccD/wT+Ze+ri4i8DHQHttV4/s/GmEexPjwATgfGAl8C59QRj2oZtO1YtO2ohtK2Y9G2oxpD249F249qKG07lhbddrQnQfS8YIz5RkQGAediZc1MHetW2v9XhHisOnskNZbX3NaZWG+u54ABIjLAXl4EZNv/B6r+WyeH2GfN94F/3yJyEHA28DlQaDd4AxSH2A5Ymbx1xhiffX87kApgjNkEXCEi/4eVJfwp4Hk1f+/zgTx7X72B1+vYn0p82nYs2nZUQ2nbsWjbUY2h7cei7Uc1lLYdS4tuO5okaD4/AC/ZmbG1xpgiEcEYUygiG0XkFuBgYHldGzDGLBCR60TkAWBPrK4s1c4ETjbG7BCRocCl9cTjEpEHgV2BmwL2kQ9cGyaGacA0ABHZBjxrP/SovewdY8zfgC9E5EUgHbhGRM4AjgVygefsrjRPYDWATKyGHpKI9AHWG2Ousu8/ISKDjTGL6/kdVcugbUfbjmocbTvadlTjafvR9qMaR9tOC2w7YkxdiR8VD0TkUqw3eZrdjaex2/nUGHNW1AJTKs5p21GqcbTtKNV42n6UahxtO/FFkwRKKaWUUkoppZQCtHBhXJAYTeshIqNF5BmxKo0GLs8UkbfEms5jlL3sAREZIyIvikhGwHqzxZ76pJ59dRaRzSLSo3l+G6UscdB++onIa1J7up9LROQn+/Z+IvKRiDwe4b60/ahmF49tR0TuEpHXReTz6ve/fveoeBMHbec0+5jtIxE5RqyCbG/ay/5jr3OCiHxs/xwTwb5iOsWcar3isP0kiTV94UsislxEBoo1ZeNYe9keEeyrxbUfTRLEh8BpPbA/6P8tIp+INT7nMRF50n7sZxG50X5zd490ByLSC0g2xlwPuEWkZ8DDZwCfGmMuA06xlw0xxlwOTLQfB6tq58chtv2NiPzDjntowO90M3BxpDEq1UiOth9jzApjzKU11u+HVYk3z15nJlb7CbVtbT/KKXHXdoDdjTGXYH3XDLOX6XePijdOt50v7GO2K4FzjDH5xpiL7GU9RcQFHI7VFm4ATqix7akicrOIvC8i3UL9Tko1o3hrPx5jzJXA9cAiY8xSwAeUAW5gc41tt4r2o0kCh0nspvXoDqy1b6/BmrKjWo+Ax7z2/5+JyLPACKCHiBwNLMaavzSU/2AV6TjRvr+/MeY9YC8RqVm1VKmoiJP2UzMmF3AL8FQDfhVtPyqm4rHt2CaKyI9Yc1JP0O8eFW/irO3cBTwfsM0RWHPO+4APseaK/5za1dKLjTH/AT4ADgvzOykVVfHcfoDTsKYhBHjXrmvwLHBbjee1ivajSQLnhZvWo4KGT+sR+BN4gLSenQ2kJ7Au4LF1AY+5AIwxbxtjrgPmAUuAkcABWNN0XGafCFUrt7+QqoBUETkYK5P9kv27HV33r69Uk8RD+6mpuhfBo8CeInJCmHVB249yRjy2HbAqWB8B3IlVwXok+t2j4ovjbUcsjwD/M8bMsZeNxDrJucde7XbgMOBQap/kVE/BVoU1ZVtdv5NS0RaX7cd2LvARQMC0hluArBr7bRXtR6dAdF6spvVYIyJVYo1VqzDGrBWRm7GGE3yGNWXHicDXACJyIzAAq2fBDcaYL+zlFwFbAxpPKBcBZxpj1olIB+BJrOlRlIq2eGg/a4AHgb1F5HZjzMPAOQAi0sMYM9b+wrgX2F1ELjfGjAkT40Vo+1HNL17bziL7JL8j8G9jzG+g3z0qrsRD2xkBHAXk2FdPP8c6ufkCeFFEbsI6tnvV3tx3jfidQg6RU6qJ4q79GGNeEmuY6BZjTCmAiFwO7AO0B/7ViN8p4duPzm6QYESn9VCq0bT9KNU42naUahxtO0o1nrYf52iSQCmllFJKKaWUUoDWJFBKKaWUUkoppZRNkwRKKaWUUkoppZQCNEmglFJKKaUaSESeFJEpIvJ0jeUvizW3+VS7iBci0k1EfhSRaSJylDMRK6WUipQmCZRSSimlVMREZB8gyxgzAkgRkeEBD482xhwMXIw1qwtYU/DdDRyDNTe5UkqpONZqpkDs0KGD6dOnj9NhqDj066+/bjXGdHQ6jnilbUfVpSW0HRF5EhgGzDHG3BCw/E7gGuB1Y8xd9rI3gd2AHcAYY8z74batbUeFk+Dt5wBgnH17PHAgMAvAGLPSXl6FNY0ywB5Y0ykbESkWkWxjTM350P207ahwErztNDttP6ouDWk7rSZJ0KdPH2bPnu10GCoOichqp2Noqgae6AwBXgIEuMoYMz/ctrXtqLoketsJvBoqIi+KyHBjzCz74VeBacCRNZ42yhizPJLta9tR4SR4+8kFVti3C4HdQ6zzMPCMfdttdk6nVWg/PyhJYM9LfjlAr169tO2oOiV422l2+t2j6tKQtqPDDZRKcPV0+3wVGFXjKfcD5wFn27eVaq1CXQ0FwBizGag5R7AB3haRr0Wkd2xCVCouFQLZ9u1soCDwQRG5EVhsjJlqL/IFPFxrfQBjzBhjzDBjzLCOHfUisVJKOUmTBEolvoae6LQ1xqw1xqzHupqjVGuVy86rmdVXN8O5xRhzEPAI8ESoFUTkchGZLSKz8/LyohWnUvFmOjt72RwFzKh+QESOAQ4CHghYf76IHCgimUDYoQZKKaWc12qGGyhnFJRVcu6YGXx346FOh9KS5VJ/t89AgclBaY6AmsMXc9dz40fzeOqcvbjxo3l1rvfP4wbxyHdLmPSPkYx8fBJtUpMorvD4H181+kT63PYtAGfu04PMVDeLNxQxe/V2APbplcuAzm34cNZaAI4e3Jm9e+Xy6HdLa+3r2+sP4cRnptZaXr0fwL+vant0z2HB+kL//WG92zJ79Xb27pXL3DUF3HHCIHbvlsN/56xjxp/bmHb7kSxYV8jTE5aRkeJm1P69OGfMDL685mD27JlLn9u+ZdXoE7n+g7l89dsGAIb2yOHVC4aRnuJmj/t+YMIth7GtpJKzX54OwHPn781JQ7uFfb1bibBXQ2syxuTb/08VkdF1rDMGGAMwbNiwmgk6FWUjH5vIdzceSlqy2+lQWhVjzBwRKReRKcA8YI2I3GmMeRB4Fiv5NlFElhpjrgAeBd4G0tlZzFA1gs9nOOSRH5l2e82RUOHll1Yy6tVf+N8NI5opstoOHv0jP906kiS3XpNU8Wfh+kKeGv8Hr144vP6Vo+DHJZsZt3gzD58xNCb7aypttapZbSutZMmmYqfDaOkadKJDcM8CX6gV4vFq6LjfNwPw5bz1Ydd7a9oqAP7MKwEIShAAlAbc/++cdbw9fbU/QQAwZ02BP0EAMG7xZsZMXkEoizbUfTHM5zOUV3lrLQ9MEAD+fc9dUwDAx7PX8fPyrXw2Zz0bCssBmL++gPG/b+ar3zYwb22BvayQ4vIqALw+408QAMxfV8imonKKyq3fdfmWEn6znwcw+Y/4+JvGgTqvhoYiItn2/wOpv53FtW/nb6R6iPiX89bz3cJN/scWbShkhd1+avL5DN/O3xjysbJKDxN+38y8tQWszS+rc9/bSiq464sFQcvGLtiIzxc6p7JyaykL1xcGxVxt1bYydlQGt7OZK/PZUlRe5/5r+mb+hqD/Jy7ZEvQ5oUIzxtxgjBlhjLnOGLPJThBgjBlojBlujBlpJwgwxqwzxhxhjDnQGPODs5FHX4XHyxXvhB8D/tT4P/yfw2vzy+hz27eUV3m58p1fqfL6OPDhCTw57g88Xh+XvT2bWz7+jW0lFUHbmLkyn+cmLvd/N/yZV8KD3y4Ou9/Xpq5k6rKtbCjYwe8bi3h7+qqQ63m8Pvrc9i2/rs7nkjdnBT1WXuWlz23fsjUgng9mrmHc4s1c8uYsjntqMnd/sbDWNtcX7OCNn1fxk37nqBB2vXMsAFe/9ys/LNr5HfTa1JU8NPb3Wuv3v2Ns0P0zX5xW60JMJKq3s2B9IeN/39Lg5wf6dXU+59gXYKo9/L/fQ8Y1bfk2Ppi58/jyt7UFnPXiNM58cRq/rS1gzbYyDn98UpPiiSbHehKEKbRWq6haqIrSItINeBdIA+4xxoyP9e/QVCu3lpKZ6qZTm7Raj1V5fSxcX8jevdr6l1V6fCzaUMhePXP5dfV2hvVpV+e2Z63KZ3iYx6NpbX4ZSW6ha056g563dFMxVV4fHbJS6ZJjvQZz12xnR6WXg/p3aI5QW6rpwBXAx1gnOm/Ws36+iPTAShCEPMuNy6uhdhQi4Ts/bLJPDi59K/QB2+73ft/gXReUVYVcXhbmROKR75bwch3JhXCWbylh+ZbgEzSPd+efIL+sEoC7v1joPyi75eN5tbZzz5eLOHCX9oB1Yudy7XzdTHz8RR0X7mqoiFwKXA20E5G2xphrgPdEpC3Wu/Eq5yJvnB2VXtJTrCvu17w/h59vOwKAGz6cB8DyB4/HZ+CC12bSr2Mmn1x5EIVlVbRJS6LS6yMt2U1JpYdr3p/DiUNPpKCskrRkN+VVXjJSkpi2fBt/f9tqdyN27cArFwyjospHcpIgCEluobzKy6tTV/LujDU8cNoegHWCdfV7c5hx+5F0yUmjwuPF4zVkpiZhjOGfn85neV4J+aWVrHjoBKq8PlwC5R4rx1nu8VJUXoVbBJcIZ788nb8e0Is7TxhMlc9HerKbHVVeMpLdQVc0jTFUeHxc+/5cThrajWvfn8t+fdpx8ZuzeOIve3LCHl1JT7F+P+2p0Ho9+t0SklzCcxOX4zNw/RH9mbg0j9uPH8Q/PvmNtBQ320oqKdxR5e/ZNfKxiazaZiXK3r5kPwzw1PhlPDV+WdC2t5dV8t2iTTwzYRkbC8t5esIy3p+5hrxi62T8v3PW+dd9cdQ+TPtzG+/MsOqODb7nO8rsBNkrU1aSnZbEt9ePYMSjE8lJT6ZwRxWP/2VP7v8mOIlwz5eLGP2/Jdx01AAeHPs7D5+xB89OWMbfDuwDwJkvWic8r05ZQY+26WSlJvPCJKtW609L8yjYUVVrmwBLNhVz7RH92f+hCezTK5dT9+oOwIP2yd4lB/flnpMHN/rvoBLP94s28drUlcxcmV/nOtUn0zNW5HP5O78GPfaPYwYy4K7/AZCTnozHZ0KefF/8xkwmLq07EZWR4qas0suRgzoxYcmWoP3WvB1oUJc2/gudw/u05ejBnXlo7JKwvwdAh6wU/7LDBnSslSQ76j8/1TrOO/X5n4O2JRJ8rLbwX8eSlRrb03apmZWPyU6tQmtXGWMuE5EXsSqvz7If+xy4HusE5gVjzKl2kuCBwIrSIvIM8BHwG/CNMWZkuH0OGzbMxFulzz3u/Z5DB3bk+fP3qfXYz8u3MurVX/xdlsG6+nfB6zP5/d/Hsds93wU9VlP1F1UsjHxsIl1z0vng8gNqPbYir4QjnvgpZCzVDeqgXdrz/mUHBC2LVewAIvKrMWZYzHbYDETkaWAfrBOdB4FLa57oAGONMdeIyFDgRfup1xhj5oXbdry0nVGvzuDn5ducDiPmrjuiP9/M38jKraWN3kabtCSGdMth+grr9TtpaFeeC/G501Atoe00p3hpO2D1Djjxmal1DoMB+OsBvViysdjfu2X2XUcx7IHx3H3SYO7/ZjGrRp9IcXkVe9z3A9NvP4IDH/7R/9wRu3Zg/rpCCneETqgBjBzYkUkBB3LVsRzyyI+s274DgI8uP4BzxszwP179XVht5cMncMaL0+jcJo3vAq48hXNw//b8vHwbfzugN/efNsS//OvfNnDdB3P9+wr1mvxw06Ec8+TkZvlO0vZTt3hqO425UqlCi1Y70rYTXry0H2070TP37qNpm5nS5O00pO041ZOgzvl1sYuqAYhIrr2suqL0NuBaY8xqGjjnbrypKzkTarkxpt6rp/XtJ9zz69p+pPv1GoMrwoErDf1dmhpbaxHYG8dW3e3zNeC1GuvOBw6OUWhR0xoTBADP/hjRbHthFZd7/AkCgG/mb+S585u8WZVAqmtnhDtoe3fGmqD7wx6wOuhVXzUMfG5gggBgyrKt9cYwqcaVnlCxVCcIAPZ7cDxbioO7W/e9fWzNp9Sr+rPjnRmr/Vdha6rrdTnmyclBj+/ZI4cvrz2kwTEopVRrk0YFOZSSTzapVJKJ1dOzhHQ8uMnFuppeQTIFZNEZK0FtELbQlvYUkoTVW2Yb2aRTSYa9jWIy8OLyb6OcFIrIoJM9EtCHkEdbOlCI297GVnLIpJx0rO+VIjIwCDlYF2F2kEIJGXS0t+HFzVZy6EgBLnt0bh65ZFFGOlavzgKycOEjmzJ7G6mUkUp7u6OuBzfbyKEj23HZXWK3kEsOpaRS5d+GGx9t7G2UkUY5KbSzt+FDmLd2O4cP6hylv0xknEoS5FJ3obVQRdVuMcbki8ghWBWlz6IRc+7Gg5oHIt/O38i38+s+aAt14LLbPd/V+Vh9z20ua/N3hN1fuMem/bmt1uORxP7bvceQk54ceZBKKdUKlSTo+PqaCYJ48Nu6wvpXUi1KV7bRU6wuyutNBwrJZLA91XgRmSwxvRguSxAMBmGWGcRustp/wL/Y9CaHUrqLlUhbazpRSiqDxBqbXEAWy0x3hotVHNeLi1/NQHaXVWRi9bBZaPrSXgrpitVte5XpQiVJDBBrOMI2slllurCv/AFAFUnMNbsyRFaQYZ8Q/WZ2oats859ErTRd8SHsIlYtjq3ksM50ZC+xEtMVJPOb6c+estx/MjPP9KeH5NEBqx38abrhwtBXrDolm2nLJtOOPeVPAMpIZaHpx96yjB2kRvGvohLBfUlv0Vu2cIfnUvaQFZzstpLAn3oPZa3pyE1J/wVgnm8XXvaexAPJbwDW++aGqmu5Iukb+orVY+y+qgs4yL2IY1zWkIT3vEdSYLK4JulLAGb6BvKe9yj/NrabLP7PcwXXJn1Od7ESxXdUXcqx7lkc5poPwOve4/AaF5clWcnnqb4hfOU90L+NzSaXuzyXclPSJ3QU6xTzlqorOMs9hQNdVvL8Jc9JpEslF7qtUisTfHsz0buXfxtrTUf+7bmA25I/9CcSrq26jnPdE9nXZQ0/esZzOp1kO+e6JwHwnXc4M81A7kl6F4A/THcWrNyj1SQJwhVaq1VUrY6K0hHNuUu8jatWUVPlDVlzTymlVID3ZqymHUVsJ4s27PAf8BeRgQsfWfaVmTJSqSCZtvaVmSrcFNCGDhQi9ldzHjlkU0oqVuKhkEyS8PqvEJWSRhVJ/qs7lSRRSJb/yoy1jVxyKCHF3kYBWSTjCdqGB7f/6k4FSRSRSUf7xMQgbCWHXIpJtq8QbSeLVKr8J0QlpOHD5T8oqyCZYtLpEHBlZhs5tKWIJPtwIp82pFPhv0JUTDoG8W+jnBSKyYjGn0QlkD6uTRzpmgPAZN9QVphuHOO2unKvMl1Y4u3F0e5fceHDh4tZnkHs6/qDPvbJzQZvB/rJBg61T0wm+PZhk2nn38Yy04Pl3u7++xUk86tnIPu5fvcnFlZ5ujBQ1nGAfWLynXc4hWT5n7PY15t1pqP/fgnpzPXsykGuRXSSAms/nu4MkrUMc1nJiK+9B+Ihyf+c33y7kGdy/fe3mzb85u3PIa6FtBVrXPZiT2+GyCqGuqwkwOfeESTj8T9ntm8gRSbDf3+LyWWhtx8j3b9xsmsaCVjKRTVBHrm86DmF1aYLK01XvvIFd2K9rOqWsPcf8owKuv+JdySfeEc2aBv3eS4Kuv+u92je9R4dtGxm1W5ht3GH57Kg+697j+d17/E7FxiY6tsj7DZuqQp+77/kPQUCa+4amODbN+Q2DnEtYH9v5MV4o8WpJEG4Qmu1iqpVDyWoUVF6vogcCMxH59xtlVw63KBVOcY1i38nv0meyeF975HM8/Xn0eSXAevg5i7PpXyRchdufHhxc1rl/TyU9Cp7uKxOS/+oupJhrj841211k37DcxwrTDfuT34dgJm+3XjYcx6fp9wDQCnpnFt5N08kv8gA+4rPdVXXcYRrHqe7pwDwoucUtpkc7kp+B4ApvqG84DmFD1Ks6cHzTTYXVt3Gc8nP0Ns+YLy88hZOd0/leLc1zvopz5lUkcStSR8BMN67L+96j+LNlEcA2Gjac3nVLbyS/ARd7Gz4BZW3cVHSDxxhH7g+4jmPdCq4PukzAL7xHsjX3gN5OeU/gHUge13V9byd/DA9ZQv/8lwIxK7uh3JW7o61jE29ncMrnuB89wSG2ycJz3pOp50UMco9AYDvfMOZ7hvMv5LeAmCF6cqDnr9yX/Kb/hPny6tu5iL3D+xpnyQ84fkLvWQLf3H/BMCX3oNYZPpwR9L7ACwxPXnMcy4PJb/mP4m6rOoWLkv6lt3EGt7wkOd8dpdVnOqeBsAn3sNYbTrzj6SPAat9P+89ldHJrwBWl9Brq27gmqQv6WdfwbzXcyEHuhZznMsaufie90jyTTbXJX0OwCzfQN7yHuPfRgGZ3FJ1NTcm/Zce9onY7VV/5xj3bA53zQPgDe9xVJokrkj6BoBpvt1503tsFP8yKhHsLct4wPO3oGU179c8mal5ErLOdGSyb8+w26h5/43AkxBgvG9fxtc4iahvG2O8Jwfd/863H9/59gtatsjTJ+w2nveeFnT/K99BfOU7KGjZPE//sNt40nMW2Uml9EO1Jk94znY6hBbhdPdUdukS+6nkHSlcCGELrdUqqiYiXwP+itLGmIV2IsE/5259U+poEY+WZ949R5ObEdsiHq2Rtp2W5UDXIspMKl8+XLOMRcNp2wkvXtrOh2PHkTL9KW6uutrpUBLaAFnLFUnfcOb930Rle9p+6hYvbQdgwT17cnLlQ06HkfAEHytHn1z/ipFsS9tOWPHSfib850Le9R7DPvvsxxPj/uC8/XpSVO5hvz7tuPerRSGfM/b6EZzwzBTm3n003y3axPMTl9O3QyavXTicV6asoLzK6y/kfMcJu9EtN51XJq/wz6IxtEcO8wOGhV1wYG9O2bMbSzcXY4w1jO2ZCcs4Y+/ufDZ3PfedPBiXS7jny0UM692W2au3s0vHTAZ2acPYBbWL444+Yw9u+2wB/zl7TyYuzePr3zb4i/wCHLVbJ+4+aTCHPTYJgEMHdPRPO/3kOXtSWuElJz3ZXzT30kP6sk+vtjw09ndKKz0UlFWRm5FMx6xUdlR5eeuS/Vj64igGnXUn/QbvVyuehkqEwoXhCq3VKqpmjKn1qWKMWQcc0WwBqrgnaE+C1uRk1zRKSeNHX9Or8rdmi3x98GnbaVWq0trznfeg+ldUStWSnuzG7kjjV32CMeZv+9aati2Un287gtOf/5lT9+rGK1NW+pfv1TOXUfv34tZPraEI1bNsvPTXfXh/5louPLB30HS+yx88nv53/o+s1KSQtUYOHdCR+0/dncMem0R6spvf7z/On2D/9vpDqPIaTrOnWrv0kL68NtWKZfrtR/B/n873FyCd+s/DOeSRicy/7xjW5pdx80e/sXSzNeRg8q2Hc+hjE4P2e/HBfXjj51WcvGc3Kj1elmwqZrU9BWT1cwqePgiITpKgpQozPfzLwBCsi6VX2+dKcS/dV8KjZwym4y67ct2RuwY9duiAjnw7fwN/GdaT9QU72FJUwZXv/srgbtn+WTDO268X5+23s6bcNYcH91ipdtmh/bjs0J39VBauL6RtZgrdc3dOzR44bfzNRw8A4D/n7OVfdsGBfVi1tZQKj4+BXdoAMG7xZtKSXfzttZl8fvVBdM9Np1N2GufaMZ2xTw9O3KMrHbJSmXXnUazJL2Pf3tbU9fXN5LFXz1yKyqvYvVsOACcO7Vrnuj93HYk3LTbT2gdyLEmgVJPpeU6r0kEKSTaJWYAtnpzlnsx2kwX8xelQVIzs3bcz75rwBxg152RWtXlx4U5Jr39F1aK8m/FXVt19In977RemLNvqP/ivPsEIdTJw44dzaZuZQpvUJBZvLKZ7bjoz7zyKD2auYXDXbJZvKeH9y/b3n7gcM7gLe/77h6DtHTeka8jtRzqN4O/3HwfALh0zuebw/v6TkepExN0nDebukwb713/n0v1D7mf3bjl8f9Oh9LntW/q0z6BX+wzuOWkwYxds5NOrdiYf3/h5FY+eOZT0FDcAn/66jpd/+pNxNx8GQEWyO6K4Wyt7evgsY8wIEXlRRIZXTw8PjDbGrBSRXYHRwJnORdowdV3Q69shk2uPsBIHnbPTAPjvVdFJZg/pntOo5/XpkBl0/+jBnany+vjymoPZs2duyOccN6QLAB3bpNKxTeTFOXu2i7y+zeqM3dkvuU3E60dLhBPXKRV/tCRB63Jgv/ZOh9BiZKdrfrg1SStdz5254zh6cOjKyPv1acfKh0/k/b9bJwn79W3HaXt1o3f7DGbdeVTYbf/50Am1lu3ftx1Xj9zFv62D+1tt9/oaV5JC+eKanR0J+3W0DthuPCr089qkhn4fj7/5UI4c1CnoZOqKw/rxzqVWV809Ag4gR5+xB8cP6ULfDpmcvGc37jpxNzpkWcPYbjhyV/52QG8Auuemk9FtMD8NuLPe30G1LMY+yXnn0v0jPkF/6ty9uffk3bn5mIG8euHOnr3n7deLsTeM4I8Hjw+6spmTkRzxtiMRuK0Jt4zkjH161Pl4Q7Y56dbDAbjkkL5BCYLqx6sTBABn7dvDnyAAqBSd3aAeoaaHB8AYU939pIrgcndx7Z32N+FpV//nfrXqq/DxJNntqjNBECvH5b1OSuGqmO9XjxQdMMo9nrPc1tzLb3iOY63pyD124bNffLvxpOdMPrQLnxWbdC6oup3Hk1/yT1NzXdW1HOP6lZPd0wF4yXMyhWTyz6QPAav67mue43nLLny21eRwWdUtPJv8jL9A0+WVN3GWe4q/Au3TnjMwCDfa05GM8+7LJ97DGGMXPltnOnBd1fWMSX6CjmKN9bmw8v+4JOk7/1Qij3rOoQ1lXJX0NQDfeA/ge98wnk1+DrCKYN1SdRVvJY8mW6xuaOdW3sWNSf/lAJc1luj+qr/SXbZySZI1zeN/vSOY7hvM43aBut99vbjD83feSX4IKg+CtPj7QFHNY0PvUxm/bHmDn/fSX/fxX5E57fmfOWq3Tjz+wx/RDi/IqXt148t5Vnu9/7Qh3P3Fwoif+49jBvDmtNVsLYn+9G8pbhf5pg0uMutfWbUYxkBmahKvXGCdrDz34zIe/+GPWicKB/XvEPLk4W8H9Gbmynx/d+PqK5EAbpeQlZrEA6cN4bS9u/uf886M1XTNSePjKw4M2taUZXnMXVNA3w6ZrNxayqrRJ/Ldwo1c+e4cjt29M3v1zPXHsLmonP0fmsCNRw3g8IGdONXuJh0qxnu+XMjb01dz1G6d6d+pDa9dNDzkuqtGn8g1789h4YZCjIFz9+vl7zpa7e8jgsur3X/aEABWLlvI0u9fBZ6qtf/WKEzX6DuBa4DXjTF32cveBHYDdgBjjDHvxz7ixvlr2bvATU6HkfBuy3mUr50OIr7lUvf08NUeBp4J9eR4nPZ9RPFYXKXdoK2WrExEmiSIsdFJY3jScxYfeq1sbPXY4LMq7wWsjLUP8d+v9s+qndNveHHxpvdY3vIe06Bt3Fh1TdA2XvaexBjviUHbmFo5JOw2rqq6MWgbz3jO4FlOD9rGhMp9wm7jkqpbg7bxmOcc//RaPoS5pj9jK/cPuw0PbqSyFKuepWoN2pUs59ljszn40GM4d8wM8ssqWZFXyvIHj8cl1jtolzvGBj3nz4dOwBXQ4+Tzq60rH9Xj2rw+458lo7qntdi3pyzL46I3rJ5+E/8xkj7tM2p1xz72qclkpLj5/Grr6qcI+Ay4BJ48ey8M1u1R+/Xy3w7cZygiVnzGQL+A3+fJc/bkpo9+48+HTqj1e7558XAuemMWp+zZjf8t3MjS+4+n3x1j+b/jBvL61FUM7ZHDKxcMwyXQ93Yf7Wh6wU+VOHwpWWxIG0B1XXSXq2HdsP51yu4YILDQ8fIHd1Zen3fP0bhrbPOv+/fivOE9a23r0yt3Xn2s3l71Zl8YFVy5vXN2mn8/e/bM5exhPfh49rqQMd538u7cc9JgJMIuZlkpScy95+j6Vwzg8pTTvnJ9g57TUtXTNfpVYBpwZI2njTLGNDzTq1qE60ueAg5xOox4Fm56eETkRmCxMWZqqCfH47Tv/SqWIJUlToeR8LamdCfXnRbz/WqSIMbaizVTo5fgsVk1+w7Vfjz4fqjCY61pGyX2/NWq9ehQsoQ0d0eS3C7O2rcHJRUePpq1liT3zlFTxwzuzPjfN+Ozvx5rnrjUPIFIctf9HurfKYvDB3Zk4tI82melICK1hricv38vUpJcQSdd1ZsMXDfwdrh9BscKu3bKYtkW6wt2SLccTtijC26XsEf3HBasL6RNahJ7927LLh2zOGJQJ44f0oU+7TNwuYRzh/dkvz7tMMbqKl39WpyfNJFdOnUFGnaCpBJXVWZXprc73V8ybNT+vTmkf4eIn7/z/b3zvRvY7gJvVxORkO/14DZp3T58UCc+vfLAWu215rZvPXYQlxzSt84YXRF+J9xz0mCKjqwKGXdYOsYtUKiu0bMAjDGbRWS3Gusb4G0R2QZca4xZHbNIm2hGygFE3mFa1aWvZ0X9K7VudU4PLyLHAAcB5zgSmXLUjx0voHdO6O++5qRJAgfoyW3TXVd1Pb9ldnI6DBVDgWnx6u7BNbsFj7kgejMi9WibwRsXh59u5uKDm/dDO3A8J+y80nrvyYM566XpLPjXzjnbX7e7Vx+/hzW0YvSZQ4Hgir4Ap+7eFtJ0bGhrkrp9GWdseAL4CICc9GSG9sh1NKZAacnuWu/TUBpaGKounbPT/IWyGsKT3YtvO/6d4U2OoEXIpf6u0YFuMcbki8ghwBPAWTVXiMfu0gDfpx3L35wOQrV4xpg5IlIuIlOwpodfIyJ3GmMeBJ4FioCJIrLUGHOFk7FG6vucs7iyTTenw0h4p2/4D6n5V0O3/etfOYq0cGGM3Vx1NVtpXNVNtdPdSe8gZVudDkPF0Pq2wyloO9TpMOJCpF2qQz83ioGohKF/9qZzVRbTrywhZh6LhbBdo2syxuTb/08FutSxzhhjzDBjzLCOHTtGMdSmua/oPqdDaBGeaHNr/Su1csaYG4wxI4wx1xljNtkJAowxA40xw40xIxMlQQDQxlsAviqnw0h4yaYSY3wx32+9SQIR6SEi/xCRL0VklohMFpEXROREEdEkQwOd455IFmX1r9jM+nVI7MJlvWUTePWDpzXxuNLwOjAmKx6lJjX+o/ePnn9hbbfaFelbKxF5UkSmiMjTNZbfKSIbROSBgGVDRGSqiPwsIomTsRIXlS6duq+pXOUFDC6d4XQY8WI6O2sOHAWEfWFEJNv+fyD1JBRUy7Rn5TynQ1AxdlDJONw79IJeogp7pCkibwCvA5XAI8B5wNVY48+OA6aKyKHNHWRLcnzWMmbcejCrRp8YVHV5xu1H+pcFLq++v2eP2r0PqqeruumoAf51B3e1EvsDOmf5lwVu6+xhPXAJ/PiPkawafSJPnrNnyDjvCZg7N1RMQ2vEExh74PpT/u9wVo0+kf1CdCV99MyhrBp9IpkpoefOPd2ulL1q9Im0Sds5MmbV6BNpl6mF11qbPlsn037bbKfDiAu7d8tm5h01a4JFpsu2WbTbPjfKESWmwOJrQIqIBPYkfxUYVeMp92N9D55t304IFW135cvuNzsdhmpBjDFzgOqu0V7srtEAInIp1pCCUSLyvP2U90RkKla7us2JmBtrszv01KGqYY6sGO90CEolpE+730pFu5plXppffTUJnjDGhJq7ayHwmYikAPEzcCyB1VfMLDs9uday1GS3/f/OXE/bTGu99JTQf9rM1CTaZ+0c05niDn2Cnl7HiXu1nBDxhJObYa2f7BaqvCZoHx3apFK6rXbviszUnTF0zEqluNzjv/9GzrU8kB554S2V+OKiVG+cEBE6NWJMNUB22RqMJ7F7EkVRQ4uvtTXGrAUQkdxYBdlUyQUrOXLzW8CTToeS0LwZHZmZcxzRq3yS2AKnPbRVd41+DXitxronk6AebnMH3zgdhFIJ6Lf0A+iXlut0GAnvoPwvSCo6C7rnxnS/YZMEdSQIEJGewLnGmMcAnc6mAb7IPIdBqTuvwldfDeyQFVyMafKth7O+YIf//kt/3ZfNReVkpe78k3Vsk8qvdx1FdnoyZ9hX3V+/aDgD7/qOc4f35PULrUOZX+440j8O+Z/HDeLGIwf4t3H8kC6MvX4EJzwzhcfOGsqBu7THJUKnNqmMHNgx6MR8xu1H+qtPv/jXffEZw9D7fojoiuZT5+7F5qIKHh77OxOXbmHCzSPp0dbq/vrt9SOY8kcee/dqyxs/r+TlySv48ZbD6JabzvVHWDWFP7/mYETAYycY9qicA56DgYx6961ahoKMPpDZ3ukwVMuSS8OKrwX2vkuYYf4uTzltqzY6HUbCM+5kytzZ9a+oWpR7iv6FlUNUTfF5+un8n9NBqJj6M213TEobp8NIeF3Ll+Ouiv1UkhHPbiAiHYG/YHW17AZ83tidisiTwDBgTmAmWkSGAC9hHXxdZYyZLyIvA0OwLiRebS+7Dzgd2A58ZYz5T2NjibU0swORnddE67oa2Kt9Br3a7zwBzkxNol/HrFrrVfcKqN5OapJ19T3Z7fI/FljFOS3ZTVryziv0LpcwuFu2fx892u7cZ9ecdLoGjCrokrNzO1mpSXjteeYiuaKZkZJE3w5J/ucG/m5ZqUn+iuzVsVb/rtWx1uy5sO+O6UjlJYCeNLYW63OHIbmaFGqqdZ0OI8mtE9vYGlR8jeAOLSGrCMVrhXbVdEklmxiZ/zE6C1nr0ta33ekQWoStLu392dqcuf1V3MV9oV2u06GoRqivJkEbEblQRL4HZgK7AH2NMbsYY/7RmB3WMwY01HjP0caYg4GLgXsD1r3FrvKZMAkCgONLv4SK5s0G3Xz0AA7oV/90UoGuP3JX9u6V26DnuATOHd6zzscvOLB3remqLjq4D/eeXPfFusMHdeKfxw1qUByqddh9w8d02TCu/hVVWMneUpI8pU6HES8aVHwNyLeL+XbDmo6qlnis0F6e04dxXS5zOgylVCt2eekYp0NQKiFN6XAelW16x3y/9ZXI3gJcAjwA9DPG3IJVxLApQo0BrdbWGLPWGLMeqxsoxpiV9mNVWMVxqj0iIuNFZK8mxtPiXH/krkE9AiJx89ED6JrTsOrXIuKfiz2Uf586JKjXAsBBu3TgNHtoRCh9O2Ry1chd6t33+KyT8KXW7lmhWraE6d8dxzrlz6F9gU7jBo0qvnYv8BHwCXCPAyE3iruikD6l+jdvKl9KFqvSBte/ompR7s5OmBqlSsWVzUndwZ1a/4oqrLZVG3F5Yj8zXn1JgtuBVOAF4HYRqf/srX657LwCU2jfDxVPzfOBh4Fn7NvPGGP2Ba4Cno1CTDEzO+0ASNapqJqqTNqAzsDZqlS5M/G6te00lSZagoWZl/o1Y8y+xpi+xphr7GXzjTEH2z/zHA28AZLKt9K/eJbTYSQ8b3pHfsk93ukwVIydVv6F0yG0CL8l7+V0CCrGvmh7Eb7sHk6HkfCGFP5EUtnmmO837FmWMeYpY8wBwKn2oi+AbiLyTxEZUPczwwo3BjTkeE8RuRFYbIyZaseVb/+/LNyORORyEZktIrPz8vIaGW50zUkdrkmCKDi5+ENkh44TrBZmrvda87qLyJsi8ouITBKR852JuOEWdzuDzd2OcjqMhJefPYiCNrs6HYaKIaNTg0RFctEqzt34mNNhqBgbVqlT70bDBxkJc7ihouSSrY/h3r6y/hVVeOLM93hEl2KNMSuMMQ8ZY/bAKjiYA4xt5D7DjQGtNd5TRI4BDsIa8oC9LNv+vwNhii/G49jQKwqfQXYUOB2GakEaUecDYJRd0+P9GIbaJIM2fEmnjZOcDiPhFWf2pjhdM/utSVVmV+a1O9bpMJRSrdjDhf90OgQVY8m+CnQC66b7PfsQPOmxP49tcH9tY8xCY8wdxpj+jdlhuDGghB7v+SzQF5hoz3QA8JiI/Ax8DdzWmDhUYluaugckNW6e+BaoQXU+sD6x3xaRr0Uk9pVQGinNU0iSVwvuNVXvTT/Qc/MEp8NQMWTETYUr0+kwEp6RJHa4tRZOa/NG5sVOh6CUasW2pPbB58BUkhHNgyUiZwCPAJ2whrQKYIwxjZowOHDaQ1v1GND5wME11h0Y4vlXNGa/8WBzUlcGuZLrX1GFNTHzBE5IzXU6jHiRS91zvYeq83GLMSZfRA7BKsx2Vs0N6jRuLZvRzH6rklq8lv23fU6Ipq4awJPTm48738whTgeiYirDF/uCYS1RiSv2JznKWWM63s7DuX2dDiPhHZr3PimFWUC3mO430p4EjwKnGGNyjDHZxpg2jU0QtHavZV8N6blOh5Hwrtj+GK7iDU6HES8aVOcjoKbHVKBLqA3G41CdRV1PZ0vXw50OI+GVp3agIqVhU6SqxKYpoehILlnPqVtedDoMFWNn7/jY6RBahHuyH6h/JdWiHFf4Ma7S2BfcU9ERaZJgszHm92aNpJW4aftDUJbvdBiqZWlonY/qmh4DCU4oxLXORQvIKv7T6TAS3rouR7GusyZbWhNvag7rMnTqvibzVtLWs8XpKOJGmIK5d4rIBhEJrCVVq4iual3+Ufyo0yGoGOtduQzxljsdRsLLS+2DNzn2QwYjTRLMFpGPROQ8ETmj+qdZI2uhMkwpInpdp6lKXNkYl9vpMOJCI+p8vCciU4FXSaCaHh1KlpFRus7pMBJev7Wf0Xftl06HoWKoMrMr83N1ZhAVPfUUzH0VGFXjKXUV0Y17k1MPdTqEFqG7V7+/lWqMaZ3OpiK7X8z3G1FNAqwuzGXAMQHLDPBZ1CNSKgKvt7uJp9vEdmxOPGtgnY+TYxVXNOk4+uhwGw87y1Oo1iBt22JO2DAG2N/pUBKap00P/tvpWvZxOpD4EKpg7iwAY8xmEdmtxvptjTFrAUQkN1ZBRsO0lIO41OkglEpAX+X8leszOzsdRsI7Zd3jpPe+BHoeFtP9RjoF4sUhfi5p7uBaokdy74V0HQ/cVKO2v4gUb3Q6DBVDq9sdQlG7PZwOQ6nEpHmhJnNVFrF7yYz6V2wdcrGHsGHVxcmtZ/1QRXSDiMjlIjJbRGbn5eU1OcBoub34YadDaBEeanOH0yGoGOvk2YB4K5wOI+GJQxfJwiYJROQuEanzjFZEjhCRk6IfVst1WuknUFnidBgJr503D/FWOh2GijGjZzpNtrzXWSzroaPFWhPjSmKHWyuLN5WrspjdymY5HUa8CFcwN5RaRXRrrRCHBXNV9BxSOdXpEFSMHVg6ASkvcDqMhGdwO5ImqG+4wQLgaxEpB+YAeUAasCuwF1YXs4eaM8CWZlDVIvB5nA5DqYTTZ9sU0pP7A8OcDiWhdd06Da/PB+i0RK3Fjna78UO3q9GR1SqKpgNXAB9jFcx9s57180WkB1aCoKiedePKOncP+jsdRAswomKK0yEolZC+7nEzf+nYM+b7DduTwBjzpTHmYOBKYBHgxvpwfxfYzxhzkzEmfvqEqVbjrbbX4dOaBEo1WOaOjWTu0KE6rUna9qUcufE1p8NIeN709kzJPdXpMOJCuIK5InIp8AQwSkSet58SqohuQni8za1Oh6BUQpqZcRiktXU6jIR3UN5HpBYsi/l+IypcaIxZBsQ+uhbo/awL+VdK7KexaGn23TENyveAbH0tW4utmbvSIaO702EkPh2x0eq4vBVkeXTq3aYSXHjRWXWqhSmY+xrwWo11axXRTRT3F90F/OR0GAnvo4xzuMvpIFRMrUvpi0lKczqMhNehYi0uB4aqRzoFooqSDt48MCGH46kGGFI+B9HaDq3Kxuw9KcnWTp9NtbHToazrqB3PlWood/k2Rm7/1OkwVIxl+fRYIxp2kO50CCrGzix4A1fpFqfDUI2kSYIYO3bHt+DRSp9KNdQeGz+h46bJToeR8FIrC0ir1KvK1UTkSRGZIiJP11g+RESmisjPIjLUXvamiPwiIpNE5HxnIm64styBjO96udNhKKVasYvL3nA6hLgX5vvoThHZICIPOBWbcs7UTudTnrtrzPcbUZJARGp1EQu1TEXA6Fzv0TCuzWn4Mjo4HYaKJWMQ7SrfZO0LFtKhcIHTYcQFEdkHyDLGjABSRGR4wMP3A+cBZ9u3q40yxow0xrwfw1CbJLlsC/2LZzodRsLzJWeyLGNvp8NQMXZbzminQ1CtQD3fR68Co5yJrPHWJffFJKU6HUbC61S+CldFYcz3G2lPgmcjXBaxBl69iWhZIpiSNhJJSnE6jISnU+G1PuXJOXiStAaFiqoDgHH27fHAgQGPtTXGrDXGrGfnHPAGeFtEvhaR3rELs2mSyrfRu/Q3p8NIeL7UHH7NPtLpMFSMnV+WMPnAuDY7ZXj9K7VudX4fGWM2gyOz4DXJF7kXYDI7Ox1GwhtQPIPksk0x32/YJIGIHCgitwAdReTmgJ/7oPHVexpx9SbSZXFvcfLu4E52OoyEd3TJl4iOc2pVFnQ5k21dDnE6jISXnzOYrW12dzqMeJHLzunYCtmZDIDg78fqrOQtxpiDgEewqrfXIiKXi8hsEZmdlxcvk/8k3LFlXEoq2ch5mx53OgwVY3tWaYItGr5K05lB6pFL3d9H9YrH756rt/wbV+Eap8NQjVRfT4IUIAtrFoQ2AT9FwFlN2G9Dr95EuizuXVn8HFSWOR2GUgln6IaP6LhRK0w31Y70TpSmaWbfVghk27ezgYKAxwLPrH0Axph8+/+pQJdQGzTGjDHGDDPGDOvYsWPUA26Mija9+K3d8U6H0UJowkWpxvhX0d1OhxDvwn0f1Ssev3tc+BAdJ9pkv+ccSmVm7Gf3CjsFojHmJ+AnEXnTGLM6ivvNBVbYtwuBwMtaoa7eRLosiIhcDlwO0KtXr0aGquLR4tS96J+S5XQYKoZSvSW4vFr0s6m6bf4JT2U5MMzpUOLBdOAK4GPgKODNgMfyRaQHVoKgCEBEso0xRSIykAYewDnNaJ3ipnMnUeTWOb9bm5czr+Axp4NQrUG476OE5BOdMjYailI64XPHfirJSI8aUkVkjIj8ICI/Vv80Yb8NunrTgGVB4jGrtjqpD7j0YK2pZmeMwKTpwZpSqvGMMXOAchGZAniBNSJyp/3wvcBHwCfAPfay90RkKlYRqdtiHW9jpRatZq/8sU6HkfC8Wd34uPNNToehYqyTLz66bie6fFc7p0OIa+G+j0TkUqwhbqNE5HkHw2yQ5zvcjS+np9NhJLz98z4lrXB5zPcbtidBgE+Al7AOjLxR2G+Drt40YFnce63NlRyT0sbpMBLe37Y/h6uwB+Ts5nQoKkbmdDuPgV01MdRU5WmdqJRyp8OIG8aYG2osetBePh84uMa6J8cqrmjTDp9N5y7ZxLmb/wO863QoKoZO2/E5cJfTYSS8B7Lv5Wung4hzYb6PXgNei31ETXNGwZtI6e2QpYmCRBRpksBjjHkxWjs1xswRkeps2TzsbJkx5kF2Xr0BuMb+P9Jlce/ugruh4nNIynE6lMSn00m2Kr0LfiE7sx+gQ4eaYlOnEZRUeJwOQ8VQVVp71mQNRWuLN5Hx0Maz3eko4oaIPIk1bmlO4MmNiAzBurAkwFXGmPki8iawG7ADGJNIU4iq6Li9+AHgO6fDUDHUo2ol4q1yOoyEtyV9FzJTYn/eGGmS4GsRuRr4HPAPCq4u4tQYDbx6E9GyRJBiKp0OoUUocLfHuCN9+6qWoH3pclJ3ZDgdRsLrs+4LPOWlJFBvedVElRmdWZZ9YP0rKhWhwFmqRORFERlujJllP1w9+5QPeAGoLms/yhgT+z6zTTQh9Uh2dTqIFqCTV2ekUqox5nY4mW45sS9cGOng+AuBW4FpwK/2z+zmCkqp+nzY7kp8OQkzTblS8cP4/1GtRMa2RRyx8RWnw0h43syuvNflVqfDiBcNnaXKAG+LyNciklBf3vOS93I6BKUS0ke5l2EyOjgdRsI7dt0zZG6eE/P9RpQkMMb0DfHTr7mDa4nuyhkNWpW/yUblP4+rYKXTYagYWtb+SIraDXU6jMQnopXulWoEV0Uhw4vG1b9i65BL3XO6h5p96hZjzEHAI1gF2BLGP0oedzqEFuG+7PucDkHFWJ/KPxCdlSphRXSkKCIZInKXiIyx7+8qIic1b2gt04WlryNeLRrWVG28heDTcdWtSZKvHJdPx7Y11Zqep7Gkx9lOh6FiyLhTKU3Sop9NJZ4dDCib63QY8aJBs1RVD081xkwFuoTaoIhcLiKzRWR2Xp7OKNDSHFeu9QhamwPKJiGVJU6HkfCqXGkYB6aTjPRy0htAJXCQfX898ECzRNTCDfAsARNyxkbVAEZrdbc6ffOn0qZgidNhJLzOW6bQe0tTZrBViaa03e781PUSp8NIePqtE2Q6cKR9+yhgRsBj+SLSQ0S6Yfc2EJFs+/+BBCcU/OJx2mqAFUnacTYa9q/8xekQlEpI47tfTUmnvWO+30iTBLsYYx4FqgCMMWXo96Vy0Nvtr8eb28fpMOKGiDwpIlNE5Okay4eIyFQR+VlEhta1TLUeaRVbySjf7HQYKoYyti3gcK1J0GS+tLZMaHeO02HEhXBzurNz9qlPgHvsZe+JyFSsqbQTqmrqM1k162wrpSIxJfMYfKnZ9a+owjpw8wekb1sc8/1GWh6+UkTSsbuQicguBMxyoCL3StZVPJaU5nQYCe/A0h9xlfaBHK3v0Igq03VVno5rG9sMoXuWTn+oVEO5vJWke4qdDqNFSPbpoU+1Bs5SdXKs4oq2Rwr/D6vjhGqKdzL+xr+dDkLFVF5SF3DpTGRNlVu1CbenNOb7jbQnwb1Yk5v2FJH3gAnA/zVbVC1Yb89KMF6nw0h4u1YsQir0oNfW0CrToZbFvS1ZgyjP7OZ0GAlvU+fDWNHpKKfDUDFkjNH5LKLAVVHIYQWfOx2GijGdujo63Oixb2tzRsFbSHmB02G0CMaBL/F6kwQi4gLaAmcAFwEfAMOMMZOaNbIW6pgd3yFacE9FVy4NqzIdalmQeCwgtdeGj2m7ZabTYSS8jIrNZJVvcDoMFUOlHYYysfuVToehlGrFRpW953QIygEiOjq9qaZ2/itl7XaP+X7rTRIYY3zA/xljthljvjXGfGOM2RqD2JSq0/js0/FldXU6jHjRoCrTdSwLEq8FpLQSStNlF/5Bp8KFToehYii1ZC0DCyY7HUbCM8kZLMrc3+kwVIzdlPOk0yEolZBWpAwEd4rTYSS87mVLSS6P/al3pMMNxovIP0Skp4i0q/5p1shaqHHpx4Ir2ekwEl6Kr1yHbezUoCrTdSyLeyUpHfAmt3E6DKUSTtKObXQr05lBmsqXnMmCrIPqX1G1KFeUvex0CC3Cz6mHOB2CirFvss/BpOn0u03Vp/hXkks3xny/kSYJzgGuASYDv9o/s5srqJZsZVI/kEhfdlWXESXfISWbnA4jLjSiynSoZXFvfpczKOg03OkwEl5h7u5syt3L6TCUSjjusq2ct/k/ToehYmy3qt+dDqFF+DHlCKdDUDF2w9Z/IaU6m1KiqrfkpF2T4DZjzEfR2KGItAHeB9oBLxtj3q7x+CishEQ+cD5W1+gvgGSsq57nGWOKRWQSVudjA/zbGJMQE39fWfw8+M7E+nWUio4GVpmutSwRDF//NtnJ+8CgM50OJaFVpuRSnqKfP63Jjpxd+K3DiWhH+abRobVKNd5dxfcDpzkdhlIJZ0nbwxnapnfM9xtpTYJbo7jPy4APgUOBv4uIf7CKiCQDV9qPvQNcAVQBfzXGHAp8iVU8sdqRxpiRiZIgqKZFPJpuUfow7cLUyiR7y3EZLfrZVJ3yptNnS0J9ZDYrEXlSRKaIyNM1lg8Rkaki8rOIDK1rWSIQ4yVJp+5rMuNOZltSF6fDUDH2bNZ1ToegVEKqkDS0mFTTlSdl4XNgqLoTNQkOAMYZY7zAb8CggMd2BRYYYzzYU7kZY8qNMdUDMarAP4eKz47rw0Sqj7AsaYAON4iCJWl74UvLdToMpVQCE5F9gCxjzAggRUQCx7PcD5wHnG3frmtZ3EstXMng/AlOh5HwfOnt+aTT9U6HoWKsr2eV0yG0CJvcmmBrbZ7vcCdkdXY6jIS319ZvSC9YFvP9OlGTIJe6p2ur8zERycLqWfC+vegsY8xI4CvgrlA7isdp3F7LulwrfUbBGdtfw12wwukwVAxN734x+V1GOB1GwitP70xRWjenw4gXBwDj7NvjgQMDHmtrjFlrjFnPzu+iUMsSgl7LaTpX2VYu3PSg02GoGDux/BunQ2gRHmlzm9MhqBg7f/tLyI58p8NQjVRvTQIAY0zfhm5YRLpgDSsItImd07WVU3u6tpBTuYnVP/914E5jTIEdU/W77nOChyAExj0GGAMwbNgwE2qdWBtdcAt4foKUNKdDSXxx8RdVsTIg/0cyc4cAeoLbFFs7DGNLSrnTYcSLXKA621gIBE5EHJhElzDLgojI5cDlAL169YpKkE1VmdGZNW320poETWV8ZHiLnY5CqYR0X9G9gA51a026etaBT4eJNtXmjAGkpca+03xESQIRuSDU8ppFB2s8tgkYGWJbNwNHisjHwF5A4LxMfwBDRMRN8FRu/wZ+Dqw9ICLZxpgirAJsf0bye8QDQWsSRMO25C6YJE20tCbty1aSUq7dFZuqx7qxdCrcjDXJRasXMjFtC0xD+sIsCxKPyenK9I6szUqYEgoqQYjIk8AwYE5g8VwRGQK8hHXIc5UxZn6oZU7E3Bhj006gZmVg1XC5vgKnQ1AqIf2eezids2N/gSzS4QbDA35GAPcBpzRyn68Co4ApwOvGmEoROU5ETjTGVAGv2I9dCLxsz+X+T+B0EZkkIlfZ2/nRnvLtn8ADjYwl5jyR5WVUPb5qeyHe3AZ3cFEJzGjXkagx+lJWmw4cad8OTEwD5ItID/s7qCjMsriXtW0+B296x+kwEp4vowOvdk2YWWObVWup5wGwIqm/0yEolZDeanutFhmPgpEbxtBmS2NH+TdepMMNgkq7ikgutYcSRMS++n9SjWXfBdx+B2tmg2qFQK1B/MaYYY3Zv9PuyH2EL7QmQZOdt+05krbeBDl7OR2KipFFHU9gcLueToeR8HzuFHwuTVYCGGPmiEi5nXCeB6wRkTuNMQ9idbWonvr3Gvv/UMtUK+GqLOXwgs+BQ5wOJR6Equcxy77f1hizFvzHi3UtSwjXlTyNdd1KNcUd2Q/xsdNBqJjavXwueEcAmU6HkvCcuFDW2CPFUkAv4zbCVSXPgXc/cGmioCnSfDvAeOtfUbUYGZ4C3J4OToeR8DZ2P46NmTv0NMcW2E3a9qC9fD7WcLbAdWstSwRedwbFKR2dDiPhibeSXXYkTC/55pZLlOt5qJbtzPL/Asc5HYaKoeFlU3B5LnM6jIRXkZRFZrxOgSgiX4vIV/bPN8BSrIKBqoH6erQif7Roj+nWpd/2n8ko0vbTVB03T6X/prFOh6FiqLT9HszsOsrpMFTLEvV6HvE4IxXA0qRB9a+k6rVP5RynQ4h7IvKkiEwRkadrLB8iIlNF5GcR0QIzrczP3S+luFPsO9BHWpPgceAJ++dh4FBjjM5l0kji0iR6U73T/kY8HfSLu1XRrFBUpFYWkF65zekwVAy12TKbEetecTqMhOdLbcPY9trt3Bb1eh7GmDHGmGHGmGEdO8ZPz5eXsq52OgTVCjSizkfcG5d1CiZFhxo01X4b3yMrb17M9xs2SSAi/UXkYGPMTwE/PwO9RWSXGMXYojydeSOI2+kwEt6IkrG4i9Y6HYaKobXZe1PeJj6mlEtkRnv6tjriqyLZt8PpMBKeGB9tPDrnN1j1PIDqeh5e7Hoe9sPVtTs+Ae4Jsywh/KdA5zaIhtczL3E6hHgXqs5HtbbGmLXGmPVYQ30SQrErR895oiCrKh+Xpyzm+62vJsFTwO0hlhfZj50c5XhavCGehegl0abrVbEMqdD5qluTrRn96JamNQmaKq/LCDamlHCQ04EolWCkqpRDC78Crnc6lLjQGup5qOjJ9iXMhDBOyaVhdT6CiMjlwOUAvXrFxwWVM4veQSqPBdo4HYpqhPqGG3Q2xiyoudBe1qdZImrhji4fp/OPRYm+jK3L3ps+JXvrXKfDSHgZZetpV/qn02GoGCrsNJzJPa50OgylElKVxL5gWEv0lx2fOB1CvGtonY8g8TpcRzXdjK4XUNxhn5jvt74kQW6Yx9KjGIdjisurIrpf6fFRXhVcTb/C46XC46W4vIqSCg9bSyqo8HjZVFiOqfMMVs9so2FC7pl4c3r77wf+3aq8PvKKK2r9LVXi047yTZdVvIKOxYucDkPFUEbhn+yWP97pMBKecaczN/NQp8NQMfZ/OY85HYJqHRpa5yPu/Z66B0anfW+yniVzSS1dH/P91pckmC0iteauEJG/A782T0ixtcd9P0R0/64vFnDeKzOCHrv63Tlc895c9rjvB4bc+z3DHhjP1e/O4YCHJzBjRehxi1+mn4pIpPUiVV2yPdsRbzkAq7eVBv3d/jPuD4Y/OL7W31IltsLULnhSsutfUdVDUy2tTVL5NjqWae+RJktOZWnG3k5HoWLsupJnnA6hRZiYerjTIcS1RtT5iHs/ZJ2CpGQ5HUbC61aykJSyTTHfb301CW4EPheRUexMCgwDUoDTmzGuuLO1pJL124MLP60v2EFacnBBjnX2OiUVnpDb2ezqDKIH6U01rHQSrpK9gV6UVwX3vNpWUuFMUK3c0+OXkZWWxKWH9K133bemrWJbSQU3HzMw4u3P63QGB3Vo35QQFVDYdnfyfJ2dDkPFmn7tNJmroojztjyFlmNqXXbxaIItGn5J2Z9aVx1VkIbU+UgEN267Hyn/EDL1mKOpnBhiHTZJYIzZDBwkIocDQ+zF3xpjfmz2yGJo4F3/o8Kz80Szz23fBj0+4ffN/LhkS63H+nfKYt7agqB1l262iuld9vbskPv6KuUF0I/JJisoq+TGD+cyrWznXMo1/241l60afWJMYmstyqu8QUmyr35bT2ZqZEmC8b9v5veNxdx41AAqvb5aybZQRqx7meyskTDg1KaE3ep53elUuiPP7Hu81mdjklt7QCWq0ra78VvHZA5wOpAWQYcMKtUY/yx+BGsGP6VUQyxtdxSDc/rHfL8RHfUZYyYaY561f1pUggAIShCE8u38jSGXe316sOCUb3fswfIynXvVSYPu/o4py3Ymaf7MK2X+usKInut2CVtLKnj3l9UMuvs7Vm4trfc5Lp8HTPi2qurXLn8O/fIi/xi//sO53PDhvOYLSDU7l6eMDE+B02EkPONKYlNK7/pXVC3Kk1m3OB2CUgmp2JWN0SHWTeYTtyOvY8z3KCJtRORrEflZRC4I8fgoEZkmIt+ISLa9bKmITLJ/BtvLjhCR6SIyUUR6NCaW1dvqPzEB+Gxu6GIRkZzY1DTDN7jBz1G1LfT1oYiMBj0nv7SymaJpfcoqreE0t/13AVOXbWVt/s75W1+YtJx5awswxuD1Gd6dsZp3Zqzm9akrWbCukAXrCpm01EouTFm2FYAxk//E5zM89v0SnvhhKQAL1hUyd812Vm0t5ac/8sgrLo/xb9lCGfh9YyGPf7+Uu79YyCez1zJzZT7GGEoqPNz31SJ+W1vA4g1F5BVXMHbBJv7MK3E6atUE6UUr2XX7z06HkfBMajafdLzW6TBUjA3x1JrkSzXCmqReOi1VK/N8+9shLdfpMBLebtvGkVGwJOb7ra8mQXO4DPjQ/pkoIh8aYyoBRCQZuBI4FDgTuAJ4DMgzxoyssZ27gWOAwcDtwDUNDeSwxyY17jdogic8f+FyrUnQZNckfcH73iNZaPpF/JxhD4xjxcMta8iBiLQB3gfaAS8bY96u8fgorLaRD5xvjCkSkaVAdfeYq40xixu633emrwasuhx/fe2XoMce/W4psJQ/HzqBBesLueuLhXVuZ9zizQB8MHMtlxzcl+cnWmM/bzlmICc/N7XG2qfxTpfhDQ1V1bDO15YZRe0ZN3F50PLf7j2GJ8f9wZvTVvHmtFUAtM2wpv5asqk41mG2GsYYjAGXS/z3fcbqbVPzsfr4fAYREJGg7fgAo93km0zKC7hiw10YMxYJ+B732b0KA/9OXp9BwP/3UNHzZ14JHq9hYJfYzL1+VPk4YHRM9tWSPZl1M0dqW2hVLs1/CiqehwytJ9UUTjUbJ/qAHACMM8Z4gd+AQQGP7QosMMZ4gPHAgfbydiIyWUReFpE0EckAdhhjio0xvwC7x/IXaIpPUv7ldAitVgs9RK5Ouh0K/F1E/HPN1Ei6vYOVdAM76Wb/NDhBANQqFhnKLneM5bTnI796efSTk/23Q9WXONs9kaztjQpXBZhc0oPJvqG1lu/5rx/8yYFq28t0GtHm9tT4ZZz+4jT//Y9mreWg0RP8j50R8Fh9LnlrFvd9ZU1v+f2iTQy+5zsAHpxaykuru0cx6tZJMBQXF/HZnODehfd9vYi/16hDtMsdYznhmSk8NPb3WIbYKtz6yW9c98GcJm3D5zP8sbn+5Gfd01mrhnqw8A7wBR87rNpaSnmVl3Xby+os+K0SV0fvJkCHiTbVpsxBVKZ3ivl+nehJkMvOOT4L7fv1PXaIMSZfRO4ALgc+JXie0JBVz0Tkcnt9evXq1eTAo0Fa6qlqjK02XdhBaoOe00K/6w8ArjXGeEWkOuk2337Mn3QTkfHAK/bydiIyGfgduMEY0+B+/NvLYj90o59sIqkispoHqm6Vi77hEvcmXvSe4nQojnOqJ059RVZr3j/6Pz+xbIs15OPraw+p1ctmUJc2/t4eOenJvGX39KneThYpZNKzoWGqOtzyyW/c8slv/O2A3mwvq+Qbu25R9d+sukjukk3F9GrXsGFxKrwKj5etJZVkpLj5fWMR7bNS6NQmjS3F5XRqkxa07raSCnLSk4OKrvp8hm2llazJL+XMF6f7/1YlFR5cAhkptQ+Lv0w/jX8076/VKqSbHWwpLgeXi05t0iip8DDy8Uncd/Jg7vt6MZcc3JerD9+FthkplFR4KNpRRU9tP0qxMmd/2md1ifl+m60ngYh0CagjUP3zIdbJf/Vk59lAQcDTQj5mjMm3l32ONctC4HpgzSdaizFmjDFmmDFmWMeOHaPwWzVdsdEPvGh42Xsyfxq9Mkbjk26HAquxk2g1icjlIjJbRGbn5eXVenxVhPU8om326u2O7LclqZ6tQAEO9cRpqOoEARBiGE7wcJDCHbV7f+zl+pOLkr5vnuBaEV9qLhdW3ea//86M1f4EQaDABM8P9pCqliZa9aUa6okf/mBNfhlLNhVz/NNT2O/BCWwtqWC/BydQVumhpMJDlddHUXkV+z4wnremr6a8yovXZ9hYuIOv529g+IPjKbB7SVV5fZRXeTn9+Z+58t05VHl95JdWUlRuPV5cXsVqX+yv4LVEBsP+D09gvwcnUF7l5ZyXpwOQZ09bXbijimEPjOfDWWvY78HxjHh0opPhqgjc+slvzF6VX+fjL7a9FVJiMyyoJTtgw9vkbv6l/hWjrNl6EhhjNgEjay4XkZuBI0XkY2AvILASwx/AEBFxA0cBM+yDNjHGVGDNEfqnMaZURNJFJAurJkGjDtTaUsQVSdaX+RaTy+ve47nW/TlZYl1YfdJzJse5ZrKbay0An3gPJYdSjnH/CsAM3yAW+/pwSZLVpXO9ac873mO4KelTUrG+YB71nMOZ7snsItaBxO2ev/NTY4JVQe5Neos2soP1pj1Pev7CX93j6CFWEbzXPccx2LWKA1zWW2ucdx8KyGKF6epkyE0iIl2wTmYCbWJnwqycxiXdbgq1P2PMGGAMwLBhw2r1wVi1tZTdZRXJWN0DF5o+dJettMU6mVlpupCEl55iJRjyTA5byWE3WQPADlJYanoxRFaQZHdFm2/60Vs2k4OVgFhhupJKJd1lGwA/eveiYnMHLg77Sqn6lJNCGansIStw26/9b6YffWUT2VgFKP803Uijwv/aJ3LbqYcjPXFUYpKqMm5O+oTHPec4HUo8iFZ9qQYZM3lFrWXDHhgPwOB7rETY8D5tmbXKSijf/81i7v9mMd1y0thQuLOpXvqWNTzk9Bd+ZuF6K5e+bEsJu975P/86q0afyNB//cBXKS+yM0eoGuvk0ruxKnVYsyNVq65F9N856wC48/O66xip5rd4QxH3fbWImQEn/4FTiHt9xhpOtUcXxi7YRN+OmQzr0445a7bz5Lg/eOfS/dnjvu8pLvdwsft/4D0ESAuxJxWppZuKWZy/mkdHWvenLMvj/V/W8OJf9w1ab8i93+MSuPCgPrTPTOGig+ufkjwcJ4YbvIrVvfM6YIwxplJEjgPcxphvReQVYAqwHTgfaAv8T0RK7GV/tbfzIDAO6+TowsYE0r1je6ZsGwJAmbHewDN9g0gW68THg5ulphdbfTkAbDdtKCONKT7rOetNB0oD7lf3Epjh2w2XffBtgEW+PmwQq2hHgYl8fnJVt1c8J9LXtRGf3Rlmvq8fK8XqilNKGqtMF6p81tt7g+lAOcn+L6dE1JxJt8bE0zk7jUMKZ5JrJwWWeboz3LWUPcXa3IfeI0innFPd1njq6b7BzPIN4ky3VXdgo2nPUm8vTnLPIBPrwG2xpzcHuBYzWKyu0m97j6GDFHKCy8qeTvYNZV6FftE01Y++fQC4M+ld0rCGjSz09OEg1yIGipUQfdN7LF0kn+NcswB4y3uMM8E2v1yaPvztmcANxuMwtyKTwXrTwekwEp/xsLcsr3+91iFuE2zVCYJAgQmCQNUJglBCDQtSjXdL0sc84jkPXwOOxRasK2SPHjnNGFXrccLTU1i8sYhbjh7Ap3PWcfFBfbjv68iusYZqC2MXbAKsYtUzVuQz+Y+8Wuse5ZoDXq1t1FTrKtJZtcNHn9u+ZdXoE/nbazOB4Nf6vP16+et6PPvjcrpkpyVeksAYUwScVGPZdwG338Hq2lmtENgnxHbGYxU3bLS2uTlMydsjaNlMs1tQhbslpletincbfcFVOn/2BW9jui+4juJi06fFVs1zygY6sMG386B3vtkl6DUuNemsarlXPwNFK+nWIHv2zOWJlWcHLfvUexifcljQstmeQUH37/ZcEnR/tOf8oPsfeI8Mur/M9AhqT9rps+l27ZTFsi0lPOgJ/tO/6z066P6fpnutz7ZEFcueOPX1wgG4wP09I1zW1bJXPSfgEh+XuK2vwZ98Q/nOux8PJ78KwAbTjns9F/No0su0FSspd2PV1Zzn/pH97d5Sz3tOJVdKGOW2Ch7+4NuXn71D+FfyW4DVs+chzygeCPsqqfp4jYvdXFYS876kN/09bW6v+jvHuWdymMs6R37dexw+4+LvSWP5wbcv0LJm1bHlEuUEW7ya4RtM7VKvqqGqP68aYnNROXugSYJoWLzRapJPjPsDIOIEQSSqEwSqebzq3fkdUlfy8oOZa4Lubypqeg7WiZ4EcWNw12z/PO1KJaJoJd0a6h/HDAzZ7bO5/XDToTHfZ0sTWMQrlDP27s5nc4Ortw/v07Y5Q2p28dQTx+czfOk9mB+8wwAoIAsxhrt9FwFQRiqlpHN3lXXfa9flfcxztn94SBmpfOo9lG+8BwCwnTa4jY8lvp7242mUkerfhock+nXIbGioqoaqpAyOrHgcgOc9p+G2yyFtJ4uvvAcy3mt9tBaSiUG4u+oiykjjMccibrpYJtgi6YVziGsBNyV9CsCP3r35wHsEr6Q8AcBG045rq27g+eSn6CJWb4K/V97CKPcEDnfPA6xpqNOo5JqkLwH4n3c/vvUewHMpVr5ilenMLVVX82ryY/6k3N8qbw9dvEc1SDkpDJGV9JON/C1pHAAfeUcyz9ffnxRd4OvLfZ6L+DjlX6w1nSj3jHEy5BZF8PmHhPoQCmhDDiX+75UCskinwj9cutQeIlDd27OCZHaQ6u9B6sVFIVnkUozLvkq3nSwyKSfFHor6hvc4nk3T756musz9DStNV2b4dqOUtIj+jmUNLO4eSqtOEnTK1q7Liapfh0xWbG1Y8bxdO+lQj2hJSWpczdPBXbP92exI9W6fwept1lj57LTkRu1X7TS8T1t+D/M3uOnoAbWSBOftFx/d5ptBzHviiEAhWRQS/Hm0o8aYzU0E91jLIzhRU0DtYlBlYbbRLa1Vf91HRVmll+32uW9e0IVzKCKLohp/002kcmC/xJ4fPJYJtkh64Uzz7c7MSquHmg/Bg5vzKu+ynm93Y7+p6hr/+pUk8ZL3ZMZ4rVy6x066Ta3cw78NL65a27i66sagbaimO7/yTmsIrunD2Mr9AetE04fUev3/WnkHBuERjxbajZYsynky+QUAtpHNzVVX88+kD/w9om6puoqT3NM53DUPgJe9J2EQrnR/DcAk35585T2I/yS/CFhJuds8l3N38rt0wJp56rqq6zjP/SMHuaypeJ/1nEZSStNPVlu7daYjf3OPY4Cs5Q3vcf6/YyGZXF91HbcmfeSvAXZr1RUc657F595DmrzfVv3J1y1HkwSJamCXNg1OEvTrqNnMaAosZFOfmSvzOfvl6Yy9YQRPjf+Dp8YvC3p+n9u+9U+D1Kd9Bl1y0pixwrro9NOth/PH5mKOeXIyLlfi1pWIF/8+dQj/PnVI0LJPZq/l1k/nc/vxg+jZLoM9e+RQ5TWMvWGEQ1HGhhM9cURCv4f369MuqFAUwOl7d+fzgITNaXt144t5G4LWcbuE9pkpbCmuCLvfUfu32ERPzNScYg9gt67ZFO2oYn3BjpDP+eDyA5o7LKc4MtTNh4vKGhNzVZIc9r4nxKFu7W2E36ZquuoaUl529pCqFvj6P3LmHvzzvwsAGNQlGxUdxWQEzc4CcIfnsqD7b3qP403vcUHLag6hrrmNW6quCrr/svdkXvae7L/vruM7T0VuZaejuHDT/v77Nf8Gd3kuDbr/jvcYbjs+eLhvY7TqJMFxQ7qw5P7jgqqs/vHA8bgEKjw+3C7hynd/ZdJSKzuT7BZ+vftojA/SUlz47ASnwZDkcjHgrv/x+kXDOGgXa6z8oLu/Y8r/HU67zBROfm4qbVKT+O9VB8X892yJnj9/H0oqPVzyxiyW55Xwyx1HMvCunX/HY3fvzHPn70OV1/o7en2GtCR3mC2q5hT4HTFi1w4hp2nr1T6DkQM7ctiAjmSnJfuTBACd26QxYlctvNZcqgtD7de3HQAul+DTKzjNZtXoE+lz27d8c90hnPTsVDpkpXD04M48dMYQjvrPZFaNPpFhD4xnUJc2tZJxT527d53b/W7hRq58dw5vXDScwwd14uaP5/HZnPV0zk7lnOGaJGiqLjlpDUqOtmRODXWbcfuRbCzcwc/Lt/L4D39w78mD+dfXi3n63L0Y1CWbNfll9G6fwR+bi+nZNoPs9GTGLtjI3j1z2VHlJb+0kk7Zaezbuy0r80r9U4o+e97eXPfBXK48bBcmLd3Ckk3FDOmeTec2aUxYsqWpYSvg/b/vT6XXx5DuOcxelU/bjBR6tsugrNJLXnEF570yg1uPHcg5w3txQL/2/JlXwm5ddfq8aPnXKbtz71eL/P8Hqjn7R0Mc2K8901dsq/NxvbjTdN/deCjnvDydX1bm8/NtR3Dw6B+5+egBTFq6hTlrCkI+58rDdmnyflt1kkBESEsOPnGs7kZdPW438MQyLcldb3fnrNTkoG1mpiaRmZpEWpIbQ/3jgVVkXC4hOy2ZzNQk0pPdpCbV/Du6SXa7SNbXOy4EfkXs27sd+/ZuV2udjllpvHnxfv77t3zym/92TkYy71y6f63nqOgY1CU76OTHLVZiTTWfxf8+lnXbravPU/95BMluF26XsPjfx9rLDm/w59exu1szvKSnWJ+Hj5w5lLziCv7YXBzFyJVyTpecNLrkpLF3r7YcPqgTg7tmM7xPO4Z0txKdA7tYJ5UDOu88ubzm8P4ht7VHjxy+vOZgUpNdDOqSzaAubejVPoNbjx3Iz8u3MqhLG575cVnz/1KtxEH9dyb6jxsSXFi6f6csvr3+EHazew70bp9J7/ba+zOaLjyoDxce1Md/e+H6Qk56dipXjdyFfx43iFOem8r8ddawgbtPGsylh/Tl1Skr+PuIfv5t9LntW+45aTDTV2zj+iN29V9geHXKCi48qA/vzVjNRQf3xeszvD19FRc3sbq+2umjKw70364+Xrv+yF2bdZ9iTOs4EBw2bJiZPXt2yMe+nLeebrnp/LJiG9ceEfyCr9xaytgFGzmgXztEhH161V3A67uFGxk5sJM/SfDlvPWcNLQbbpewZFMRxlhdE1X0/JlXQlmFlz165PDF3PXkpCfjdgm92mXQJ8JCXSLyqzFmWDOHmrDCtZ1IlVd5mbhkC8fvEXrGif8t2MgRu3UKSvZ8NmcdSW4Xp+zZrUn7Vg33x+Ziqrw+du8Wvqq0tp3w6ms7lR4f4xZv5sSh0ZuJ5buFmxg5sKP/e2hFXgklFR6G9siN2j5UdGj7qVs0vneiYd32MjYWljO8T+3EtnKOtp3wIm0/M1Zso3f7DLrmpAPWeUvbjBR275ZN+6zatQQm/5FX52MqMTSk7WiSQLV6+mUTnrYdVRdtO+Fp21HhaPupm7YdFY62nfC0/ai6NKTtaF9spZRSSimllFJKAZokUEoppZRSSimllE2TBEoppZRSSimllAJaUU0CEckDVod4qAOwNcbhNJTGGB11xdjbGNMx1sEkCm07zS6RY9S2E4a2nWaXCDGCtp8GC9N2IDH+7hpjdGjbaQT97ml2iRxjxG2n1SQJ6iIis+O9+InGGB2JEGMiSYTXU2OMjkSIMZEkwuupMUZPosSZKBLh9dQYoyMRYkwkifB6aozREY0YdbiBUkoppZRSSimlAE0SKKWUUkoppZRSyqZJAhjjdAAR0BijIxFiTCSJ8HpqjNGRCDEmkkR4PTXG6EmUOBNFIryeGmN0JEKMiSQRXk+NMTqaHGOrr0mglFJKKaWUUkopi/YkUEoppZRSSimlFNDKkwQi8qSITBGRpx2MoZuIzBGRchFJqiuuSJc1U4z7i8g0EZkqIk/ay261778nIskNWdZMMQ6xY5wiIm+IJa5ex5YkHl4zbTtRi1HbTgzFw2umbSdqMWrbibF4eN3ivf1o21GhxMPrFu9tx96Pth9bq00SiMg+QJYxZgSQIiLDHQolHzgSmFFXXJEua8YYVwNHGGMOATqJyGHA4fb9+cBpItIpkmXNGONSY8xB9usBsB/x9zq2CHH0mmnbiQ5tOzESR6+Ztp3o0LYTQ3H0usV7+9G2o4LE0esW720HtP34tdokAXAAMM6+PR440IkgjDHlxpjtAYtCxRXpsuaKcZMxpty+WwXsDkyqse9hES5rrhirAu5WYH0IxdXr2ILExWumbSdqMWrbiZ24eM207UQtRm07sRUXr1u8tx9tOyqEuHjd4r3t2DFq+7G15iRBLlBk3y6078eDXGrHFemyZiUiQ4GOQEE8xigip4jIQqAzkByPMbYQucTna5ZLnP7Nte0oWy7x+ZrlEqd/c207KkAu8fm65RKHf3dtOypALvH5uuUSp393bT+tO0lQCGTbt7Ox3gTxIFRckS5rNiLSDngOuDReYzTGfGWMGQKsAzzxGGMLEa+vWVy+L7XtqADx+prF5ftS246qIV5ft7h7b2rbUTXE6+sWl+9NbT+W1pwkmI7VPQPgKOzxMXEgVFyRLmsWYhUXeRf4hzFmEzALOKzGviNd1lwxpgbcLQIMcfY6tiDx+ppp22lcjNp2YideXzNtO42LUdtObMXr6xZX7UfbjgohXl+3uGo7oO0nUKtNEhhj5gDlIjIF8BpjZjoRh4gki8h4YE/ge6wuI0FxhYo1xvH/BRgOPCoik4BdgMkiMhXYC/jCGLMlkmXNGONxIvKTiPyE1fVmNPH3OrYI8fKaaduJGm07MRIvr5m2najRthND8fK6JUD70bajgsTL65YAbQe0/fiJMaYZfwellFJKKaWUUkolilbbk0AppZRSSimllFLBNEmglFJKKaWUUkopQJMESimllFJKKaWUsmmSQCmllFJKKaWUUoAmCZRSSimllFJKKWXTJIFSSimllFJKKaUATRIopZRSSimllFLKpkkCpZRSSimllFJKAZokUEoppZRSSimllE2TBEoppZRSSimllAI0SaCUUkoppZRSSimbJgmUUkoppZRSSikFaJJAKaWUUkoppZRSNk0SKKWUUkoppZRSCtAkgVJKKaWUUkoppWyaJFBKKaWUUkoppRSgSQKllFJKKaWUUkrZNEmglFJKKaWUUkopQJMESimllFJKKaWUsmmSQCmllFJKKaWUUoAmCZRSSimllFJKKWXTJIFSSimllFJKKaUATRIopZRSSimllFLKpkkCpZRSSimllFJKAZokUEoppZRSSimllE2TBEoppZRSSimllAI0SaCUUkoppZRSSimbJgmUUkoppZRSSikFaJJAKaWUUkoppZRSNk0SKKWUUkoppZRSCtAkgVJKKaWUUkoppWyaJFBKKaWUUkoppRSgSQKllFJKKaWUUkrZNEmglFJKKaWUUkopQJMESimllFJKKaWUsmmSQCmllFJKKaWUUoAmCZRSSimllFJKKWXTJIFSSimllFJKKaUATRIopZRSSimllFLKpkkCpZRSSimllFJKAZokUEoppZRSSimllE2TBEoppZRSSimllAI0SaCUUkoppZRSSimbJgmUUkoppZRSSikFaJJAKaWUUkoppZRSNk0SKKWUUkoppZRSCtAkgVJKKaWUUkoppWyaJFBKKaWUUkoppRSgSQKllFJKKaWUUkrZNEmglFJKKaWUUkopQJMESimllFJKKaWUsmmSQCmllFJKKaWUUoAmCZRSSimllFJKKWXTJIFSSimllIoaEdlfRKaJyFQRedJeVigik+yfdk7HqFQ80raj4kWS0wEopZRS8UhE9geeBHzALGPMTSJSCMy1VznDGJPvWIBKxa/VwBHGmHIReU9E9gAWGGNGOhyXUvFO246KC60mSdChQwfTp08fp8NQcejXX3/daozp6HQczSEaJznadlRdWnLbsTXpYE3bjgqnJbcfY8ymgLtVgBfYTUSmAD8DtxtjTF3P17ajwtG2U3fbAW0/qm4NaTsJkSSIxolOnz59mD17djNHqhKRiKx2OoZm1OSMtLYdVZcW3naafLCmbUeF09LbD4CIDAU6GmMWi8iuwHbgJeBk4Ksa614OXA7Qq1cvbTuqTtp2gtuOvb62H1WvhrSdRKlJUH2icwjQKfBEx/7R7p5KhWCM2WSMKbfvBp3kiMhoEREHw1MqIQQerAG7AocCbbEO1mque7mIzBaR2Xl5eTGOVKn4YY+dfg64FMAYk28n1b4AhtRc3xgzxhgzzBgzrGPHFnmRWKmINLTt2Oto+1FRlRBJAj3RUappGnKSY6+vJzpKoSc6SjWGiCQB7wL/MMZsEpFMEXHbDx8M/OlcdErFL207Kl4kRJKgmp7oKNVwmpFWqnH0YE2pRvsLMBx4VEQmAUOBWSIyGegJfOpgbErFM207Ki4kRE0CCDrRORusEx17+RfA3oQYn2OMGQOMARg2bFjYIh+xVvDZ5+SecXrEtxuyXn3PjeZzYr3t+parYKFOcoByY4wX6yRngaMBNkLBZ58DkHvG6WFv1/w/3GPRXieaz61+TvXv3th9h/u8UHUKPFgDuB14XkRKgJXAvQ7G1mDV76e6BL7nQt2P1jp1td3GPL++7TV23XC3Vf2MMR8AH9RYvI8TsUTDhjvvImPffaO2vVDv+2iuX99z6tteY59b12M1v4dU3Vpa2yn47HPKfv2VjH339f+fSBrT9iJ9bkPbUqzbT0IkCVriiU7V+vUNut2Q9ep7bjSfE+tt17dc1dKiTnKgYW2n5v/hHov2OtF8blP3Wd/nhQqtpR2sRfK3j8bneSTrRPs7LNLvzoasq+1GVatcs4bkLl2ius2Gvqca8x4M95z6ttfY5+pxmwpUtX69v/00RzuKhaa8d5urncVCQiQJaIEnOkrFQks7yVFKKaWUUko1r4RIEuiJjlJKKaWUUkop1fwSqnChUkoppZRSSimlmo8mCZRSSimllFJKKQVokkAppZRSSimllFI2TRIopZRSSimllFIKSJDChS1RcvfuDbrdkPXqe240nxPrbde3XLV8DWk7Nf8P91i014nmc5u6z/o+L1TrEMnfPhqf55GsE+3vsEi/OxuyrrYbVS2lV6+ovwcaur3G7D/cc+rbXmOfq8dtKlBy9+7+9tMc7SgWmhJzc7WzWBBjjKMBxMqwYcPM7NmznQ5DxSER+dUYM8zpOOKVth1VF2074WnbUeFo+6mbth0Vjrad8LT9qLo0pO3ocAOllFJKKaWUUkoBmiRwhM9nWL2tFIBfV+fz3i+rAfD6DB6vz8nQlIprM1fm01p6PykVTSvySpwOQamEVFBWqd87SjVCaYWH8iqv02GoRtIkgQNmrNzGYY9NAuDTX9dz5+cLAbjvq0Vc8PpMACb8vplXJq/wP+eFSctZuL4QgCWbiqj0WMmEskoPizcUhd3fpsJyisqrGhTj9tJKCsoq/fdLKjxRPcjUL1zVGGe/PJ3xv29h4tItbCupcDocpRLGEU/85P/eUEpFbq9/j2Pan9ucDkOphHPmi9O464uFToehGkmTBA7w+kKfIK/bXsbKrVYPgy/mbeCp8X/4H3v0u6WM/30zAMc9NYVxi63bn/66jhOemVJrW3PWbPffPvapydz/9WL//ds/m89LP/0ZtP4qe7/VLnlrFle886v//iuTV3DEEz/V2s+5Y6bz+dx1/vuLNhRy5BOTgtaZu2Y7o/+3xH9/0tItDLjrf/77v67eTp/bvq217cKyKsoqPbWWq9btqfF/cP/Xi9n3gfFUeLz8ujqfWz7+jWcmLKOs0sO2kgq+mb+BHZVeSio8+Oz2Nv3PbRTuqGLyH3lsL62kcEdkiTPNgquWYuDd/6t/JaVULTsq9XtAqYbaWlJBQVnDLlKq+NGsSQIRyRQRd3Puo6WJ1gX2M16Y5r9dXuXFE5CYGP/7FmatzA9af+Tjk8gv3dlzYEell/KAq051XfmfsSKfJZuK/ffXbCvjz7zghMOUZVuDkhJbiiuo8u7cXl5x6CvCp73wM3d/sajW8lGvzqC0QpMHCqb8sZUzX5zO1OV5zF2zncH3fM/43zdz7ftz+ccnv/HXV3+h3x1jWbCukPNemcF3CzdyweszufCNmVz7/hxOeW4q//11HYPv+Q5jDHPXbGfh+kK+nLeeiUu3sKWonEF3f8eKvBL+8clvgJX0Ali+pYTxizez34PjmbNmO+/MWM27M1Zz8Rsz8foMXp/hxg/nMntVPsc/PYWVW0v9zwXYXFTOzJX5LFxfyOxV+RSXV1Fa4WHM5D+Zs2Y7c9dsD9nuqmoMSZqzZjvbSir4bM46Ppy5xr/c6zP+5NxWu9fFx7PXRvcP0EqJyJMiMkVEnnY6loYwBk56dgpXv/crJRUeqry+BvcyU6opErXtKOU0bTsq1qKaJBARl4icLyLfisgWYAmwUUQWi8hjItI/mvtrCUQCb0vQYzVPDwLPF0ytR8OrebIR6tm1TkgizVg008iB7WWVIZMBPy/fFvFVYBVaon/ZhHz/1ri/vazSn/gq2FEZ9Fj1OLn56wpZsbWEskovxRUeTn9hGh/MXMMNH87j4jdm8fnc9QCUVXr59Ferx8zpL0yjoKySo/7zE+u2l7GluILP56zn7i8WsmhDEROX5nHLx/O47oM5fDFvA3PXFPD7xiLWbS/j9BemsXJrKX1u+5bXf17J2S9P56Gxv3Pzx79x0RuzuO6DuTw0dgnfLdzE6S9Mw2es4UKAv7fNrndaV4MPHv0jE5du4YwXpvHOjNW8M2M1b/y8indmrOao//zEjiovL/30J+VVXoY9MB6A//t0fjRe/lZNRPYBsowxI4AUERnudEwNsXB9EWMXbOLvb83iLy9NZ+h9P3DEE5M45bmpgPV+KyyrwuczPDT2dzYXlddKTCnVGIncdqo//5VyQiK3nWY7SVDNLinK25sIjAduBxYaY3wAItIOOBx4REQ+N8a8G42diciTwDBgjjHmhmhsMxYEiWCdSLcVwTo1VqrrOdFoxjX31dTnNDQZouoX+GUjIi+KyHBjzCyn42qKutpU9fsnVL6relljeu/U95yV28qosIcp1IyhqI4EV0FZJS6pveyAhyewavSJtdZfX7CDddt3BMeFYW1+Gcu37Kwf4tP6H9F2ADDOvj0eOBBIuPYzY8XO3mQr7N5fBzw0gU1F5eRmJPu7iI6ZvIIRu3Zg395teWr8Mv553CBEYN/ebdmlYxZjJq/g+iP74xJhfcEOdumYhTGmVtJbKRK47Xy3aJPTIajWLUHbjn4PJLJoJwmOMsbUOgI2xuQD/wX+KyLJ0dhRIp/oJMyJb4wO8uo6hwm39wR5BeNVgn7Z7FTd66X6LWowtd4vod6+1cmESE9g6nuf1dxOY5uM9ZkgAYkL60Zd9Ut2PnFnAqLW79+4UFT9coHqqrKFwO7OhRJdm4qsXis1x5BOWbaVOautoTKPfGcNYQlMJPy4ZDNFOzxsKiqnd/sM1m3fwSH9O7B6WykbC8up8Pi4bERfUpPcFO6oYmtJBVcetgvz1hbw/MTlvHHxcLaWVPLDok18NGstyx86odG/g8frI8mt5ZbiVC5h2o6IXA5cDtCrV6+YBhaJX1fns0+vtqzJL6NzdhppyTqaVsVMLvV878R7+1GJJ9pJgi9E5H3gS2NMyFL4oZIIjZTwJzpxL/DsXa8KtSS5tJCTnOAhOPEjXGupqymFTFw0pmdOw5+iGqYQyLZvZwMFgQ+21AO1mu2rrGJnIbe1+Tso91j3V28rA2DWqnzKAoq9fTZnPR6f8Q8Va5+VwrszrBoaJz4zFZGd7fn5ictJcbt495fVfHv9CA57dCLnDO9J5+w0+nbI5PeNRezdqy1VXh/T/tzK1OXbuGxEXxasK+TlyStY9K9jKa3w8Oa0VfzfcYN4fepK+nbI5NABHflu4Sb27d2WLjlpQb9PpcdHSlL45EJ5lVdPDJsmbNsxxowBxgAMGzYsnj7SATjzxelB9zNT3Jw0tBsTlmwmKzWJYX3aceIeXTmof3u8PkNGSrQPsVUrFrbtQPy2n/G/b3E6BNVI0f4EGwOcCzwpIpOAD4BvjTGVYZ/VOLkkaFYt3HCDeOllEM2uovVd4dT8Q8zV+2UTr22nWq0r+AHvqkiG8zhJe/8nvOnAFcDHwFHAm4EPxuuBWiJ57Pul7Nkjh9Xbyhhy7/cAvDDpT1KTXFTYBXVz0pODatN8Nmc9Py6xDkYPe2wi/TpkMXNVPi9M+pPMFDd79szl4jet6wgnDu3K/n3b8fHstQzo3Ibuuek8++NyFv/7WFLc1j4+mb2WU/fqzvaySi55cxaXHdqPOz9fGHLoj4pY2LaTaEorvXxkF4PdWlLJqm1lQbULnjlvb07ZsxszV+bzwqTl3Hb8IDJTkujZLsOpkFXialFtRyWGqCYJjDFfAl+KSAZwMnAB8KKI/A943xgzLuwGGiZhs2qRqlVHMMxj9W6r1rYbtoFonnYl3B+i5an3yybe207N4Qb1rt+AbUeyzVp1Php1xb966EOYlRrazkOsH+9Jk0RjjJkjIuUiMgWYZ4yZ6XRMTmvM+79RtUAiXG9rSSXtMoOvTewImMr02/kb+Xb+RgC2lVTSv1MWAIc+Oondu2Xz0x95ACzaUMQn9knf0oBZfFTjtLa2c/0Hc7n+g7n++5OW5vlvn7VvD/bsmcuo/XqxtaSC3IwUklyCyyX4fIbiCg856VEZnatagERvOw9+u5g7TxzsdBiqgZqlL5Qxpgz4CPhIRIYCb2ElDKLZT69FZNWkrttRPK6veZLQqAO6BuxNxbdE/7JpyPs3XL2L6ofCvbfrK24YtuhmjedWbyJ8oc7w+6tzfaLb+0eFl0iFcuNJQ5PTTdtX8P1IWsfWkgrWbi/z3w8sCaI9gKJD247l01/X8emv63hh4nI22jPYHDGoEwft0p5fVuYzbvFmrh65C/933CC+nLeetGQ3x+7exeGolZMSue28MmUl/zxuEEluFz6f1WfaXbNSs4o7zZIkEJHOwNlYQw+6Yp3IXxTNfSTyiU5DTixaIv1YcF4if9kYE/+9UZw4X/efgGkDU80g2t9JcZvTivcPF9WiVCcIAH5cssU/ZAasITan792dGz6cB0CSS/jkygMZ0LkNhTuqeHv6alwCJ+zRFZ8xrMkv45PZ63jrkv0AeGfGav52QO+Y/j5K1aX/nf/jh5sO5YFvf2fNtlI6Z6fxy8p87jlpMBce1EeTBnEoqkkCEbkMOA8YiDWbwa3GmGnR3EegRD3RierBVjMeaQWG6dRMAy05WaLiQzx8LdW66umftUGpxFDfZ3XtIW/R3n/wBgO/GuvrZRNJLHGb1FAt2tFPTvbf9vgMp79Q+5D6hUl/Bt0//5UZ/OPYgdz9xULmrtnO7cfvxm9rC3hqwh8cMbATz/y43F9bY/mWErrlpoUsslhW6dHiiyqqjgl4P6+yi9z++5vF/Pubxf7l71+2P12y0+jTPpO128vo1S6DHVVefS86INqv+IHAw8AEY4wvyttuVUIekDTzGXNzbb6+g6u6Hg53YBfLbqsqvojUU/xSqv+LbLaAqObsGrJuzboGAbcb8/auazpGPblRza01fBy3ht9RtQzT/tzGGXYy4bM569lUWE5ReRUL1xexcH0RAH1u+5ax14/ghGem4HYJ/zl7TwZ2acPiDUW8MmUln155ILvf+z0jB3Zk1P69Gd6nLbkZKQAs3lBE28xkctKT8fgMJeUeRKBNWjJZqdZpRYXHiyD1zhiiVE3nv/ILAHecMIiHxi7hxVH7cNV7c3hx1D7s3689uenJuAJ6HazaWkrX3DRSk9zMWbOd3PRk+nXMcir8FiXahQsvqb5t1yLoE7gPY8xn0dxfooq82FrdRyUNPV4JVwSxuTX0CpNS9Qn1ngn1Pts5fKf2g3UlmkIlF2q2xVp1PkKHaT83eH+htu/vOdDAM5FI2rWe3Kh4EJVcVZj3cs0kWUPe9/Eyq5BSzWHan9tCLj/hmSkAeH3GP6Sh2u72rCKTluYxaWkeRwzqxE1HDeDk56aG3df1R+7KzUcP4Jr35jL+982M2LUD1x+5Kz8s2qSF61SDPDR2CQBXvTcn6P+ObVJ58+Lh/PfX9VxySB9GPj6J647oz0lDu3H+KzM4YlAnXhi1r2NxtyTNVZPgdWAosAio7lFgAE0S1BDcJbL59wF1VzsPiiVK+1IqHkXrfVpnLxgaduJR1wmNnuCreBHu/RxJe6o13KBp4dTefpjhBuFE+lGg322qNatZL6Euz0xYxg1H7sqGgh0ATFm2lSnLtgJokqAVao7PzbziCk58xkpWvf7zSgCe/XE5z/64HICxCzZx8OgfOW3vbvz0Rx6ZKUk8ePoQ+ndqE/1gWrjmGuBxgDFGPw0aqGZBtpon89E8qAp31TXUvprS0Bs73ECpusT65Lkp0wjWF2tzT1GoJzeqWUT5fdXQNl3f+7pBPQk0GadU1Oxyx1g6Z6fWWm6M0Vl4VEysL9jB8xN31uo46j+TOXJQJ87Ypwdt0pI4dEBHB6NLHM2VJJguIoONMYvrX1XVJZIrkY35uI32Z3Rz1gfQYzfVWBEP6wkzKUB1G4y0V0C0kmkNft8b44+/OunQ3MkHpapFVPivvsfFuRP7Onvy6DeQUo1S4aldlswYTVor50xYsoUJdm+Yty7Zj/6drLoFi9YXcvk7v9I1J43ptx/pZIhxp7mSBG9jJQo2ARXYvW+NMUObaX8tQmO6+zf2EEav7quWINT7OPTJft2P1VqnEW/+6qsjoU426tpeuDh33g/fwmsm6ELXXgi7CaUiUut91MD3VYPfhiEaTkNO2oOSblG4gqntSKnIheytGvswlArpwtdn1lq2sbCcS9+cxSsXDGPZlhKenvAHADccOYBjn5rsnxGksKyKovIq2mam+At1NrdFGwrp3ymL1CR3TPZXrbl+u9eAvwEL2FmTQDmoMdNPRXpQ1NCDL+1upppTJG9bQepcr0EnA/7kQM3x0BJQNLH+zUS6z4b02tGroCqawr2bovGRHi8n4eGG/CmlGs/6/tI2peLXhCVbOGj0j2wqKvcvG7tgE2DNCLJq9Ins+e8fALjysF247fhBQc/3+QzL80pYkVfCcUO6AjD5jzz27JlLTnpyrf0t31IcUa2EE5+ZyjPn7c0pe3Zr9O/WGM2VJMgzxnzVTNtuwSL/8NxZKT2aW22cwBOXaO5Lv0pUpKLxXonKNvRNq1Sj1BpuEOWsQZ2zmYhoQk2pGNBWphJBYIKgphkrds4U8uW89aQnuzlk1/asLyjnq3kbmLBks/+ra949R3PEEz+RX1oJwL9O2Z2ThnbFJcL7M9eweEMR3y7Y6O+hEEqFx+vvPeDE4WVzJQnmisj7wNdYww0AnQKxWvCU7kGzo4c9LorqGMyQy+quDt2UKyr19RwI97hWfVehhK203uht2s8P6qYc/H9dO4mkd0y44QwidUy9WHOKwzrHTu/cbs3t6wmQam7N8nkcxR5qpr7HA+LXPJ9SSqlQzh0zw397Y2E5T47/gyfHh153r3+PC7p/71eLeGvaKs7YpzuP//CHf/na/DLu/2Yx1xzen6y0JNZt38HqbaU89v1Siss9YZMIza25kgTpWMmBYwKW6RSIDdRcJ8IR1zuI0blFcxY+VK1H2HdRdXHCJo5zjqZwyYj6mkR1m2nuaeWU8mvo7AM1n97Mn/Phtq9fMUo5T9th66NJ12ArtpbyzfyNQctGPDoRgB8Wbw75nP0fqiMLEQPNkiQwxlzcHNtt+XY2p+Yetx9q6xK0/2bdfcTiJQ4VnxrawyXciUSjZgoJs7x6T01JQjQlCaAHZCqamppMs77TovemjOZ3g6njtlIqerRXW2RE5HLgEvvuM8aY90VkJPAWsBJYY4y5wKHwVIxtLqqof6Vm4ormxkTkLhFpF+bxI0TkpGjuUzVOfcMNGnuC0ZjkRmOGG6jWKzAx0NiDjsDxz9Xbi8ZbLVaFzrRdND8RuVxEZtg/59vLRorIahGZJCJvOx1jSxLNAp/Roic1jaNtR+lMO03ygzHmAGAEcEvA8neMMSM1QaBiJapJAqzZDL4WkQki8piI/J+I3CMi74jIAuBk4JeGblS/cOoW+Vzwzffp3GzDIrQXQZO1lrYTmGgKl3SKZLhBU952oU4qzM4uBXXEFPx/Y1UnKGp3827adlsxPVALJ3C4TAQn004OK6s3Pq1JEG3adpRqJGPMKvumx/6pdp6ITBGR82IflXKaE9+gUU0SGGO+NMYcDFwJLALcQBHwLrCfMeYmY0xeIzbdYr9wap8YhBlX2eirpqEKooXfVs2n6Al7wmqRbadmL4C614vOx6r/PD+KJzohCxXWF0eNWgS1ahhoQiBq9EAtWLTP8WtuL16+Y7QJNZ22HaWi4krgS/v2bGAQcBxwvYh0dCwq1Wo0V02CZcCyKG5vlX0z1BfOYcALxpgPorW/ZufAwVDQ3M8RHo01JikRJ8d5ytbi2g7N1wU4GidB/qv5EjBNaR2NormvvurJTtSEOlBLAcaLyPiaiW97POnlAL169YplnM2q1vupmZMGEcXQxO2Ffp62nCjStqP8tGkFE5EuwIc1Fm8yxpwrIvsDJwCnARhjSuzHq0RkMrAroO1HNavmmt2guTToCyfR1J66zDm1ehJEc9sNWlu/VaJED9bq04gx0ZHk25pj6tKGnMhoCwov2gdqxpgxwBiAYcOG6csfB4wJ/70TmLALGrqkae+wtO2ousTTTELxyhizCRhZc7mIdAeeAE4xxnjtZdnGmCIRcQPDgadDbC/u2k+89BBTjRNXSQLNqu0U7XYV0fYCPlKMab7GXc+U8xE9ooLpwVrtE+fAg5SQtQJq3Ij2AUx9PXbCnYA0KpYo1TZobaJ9oNYaxcMVwlrfK9oOmp22HVUXLVzYJPcAnYHP7OOI44Gz7XMaH/CBMWaDg/GpViKukgStIasWLZGOyfav38T9OXPA1aL+ZM2qNR2s1feeD3w08oRUQJsKTC7UdVQTUa+D4JUiOvGv+RwT+uGaJQj0Ck2z0AO1APHeDT9cwc76a30E3o7v3zNBaNtRtWjLiowx5ooQi1+1f1SCa+4p7qOpWZIEIjIAeBHobIwZIiJDsU5SHmjkJlvNF06445NGT0vYiBVrFy6MbCuRrJY4zaNFaHFtJ3D6wlAaeyASyfPqWydan/3R6OZc18mO+f/23js8rvJK/P+8o2kqo96t4iL33m2CsTHNVMcJoSUhLNlAymaXtA2pm4QUNpv9bbJPsvmuYUkhQEJ2CQk4OAnFYMBgbGzAxr3IuMgqtqRRHc3M+/tj5l7NjEbySBpJM5rzeR49mlvfc++8Z+495z3nvFon1UNqrJAXtXBG+wU/EXqoON+GhuiOIAhCdBLh2RYrIxVJ8ADwJeC/AbTWbyulHgWG5CQYzw+cUessQ7CAQm2MgWyKkXuNSiZVSkzGo+4Mxlk20j0otFBhPDGMkz6RBP2sH/BcMjIqpDqxz4AoDjRBiAPRVE6eRYIw9PfFsdCfuE6BGEKG1np7xDpv1D1TnAG/8nHyezqcdy55pgiRXGh0L1q6Qd+CgxcIR4hs05h6MMZjYokEiCVaZ7AjmTqGtkWnhLFggKogsZ9jGJ13QEd3yHnFkBGEkUE0SxCSq17OSDkJGpVSUwj+JiilbgTOjFBb44YR7TcDpBL0e0joMcOQTt65hHgSa1+Mtle0vj+0GQNimL4w4rxD0YP+axJc2GkhaifEk+H+jo92Md4+swWJQgjCmCI6KAhDZyz0Z6TSDT5DoGDgDKXUKeAY8JERaiupGajI2kAMOldygFSCfg+JMd1gJEkmj5swBgyyfwy3lkE8fqOjOiri+Ot/oalU5T1NiDeJ0Kf69POwwoXDl1DqEwjCMBEVSjlkGtn4MRbPoBFxEmitjwKXK6UyAYvW2j0S7YxHzC4wwIjnoBmCjipU+NzRsR4XZccLGfoDh4EObr0w/om348g43VD6VEyFOocgcOQsBv1tD2tn0K0IwugS2m2HFFnTz2eIbeaSaCgF/hhmQpCXXUEYHn55cRtzdu7cyc6dO1m7di07d+6kpaWFDRs28Ic//IGamhrS09N55513uOqqq9i6dSsej4d169bx9NNPM2PGDAD279/Pddddx+bNm7Hb7axatYq//OUvzJ07l87OTg4fPmyes/HtE/TkVNNV+zb20hr8HS14WxvImLaSjoPbSEvPxlZQSdfJvTjKp+NtrcfXdr53e1Ye1uxiuk8fwFkxm56m9/B1tprbrdlFWDJy8NQdxlk9D0/dYfzdHb3b88qwWO14GmpJn7SIrpN7wdeDc9JiOo+8ga2gAoCeppOkT1lK17GdkGbDWTGbzmNvYi+qxu/14D1/xjynxZGBvbRmyNd09twEPN6sQV9T8xUVbNz455i/p8zMTBYvXjys/jJSsxt8PmIZoAXYqbXePRJtJhOhLxuhBsRQXkFitT8iPVADhV2by7EWLhyh332JIhCiMbiifeH/jT4VtW5BtKzpGCNw+hgQIYuxRAkYvwN9dTC2i+29zhjSILRGXApCIhFriZCwZ1Kfc/TfpwOOgOgNKBVRuLCfc4iBIwjDwyc6NOYsXrzYNBxramrM9XfddZf5eeXKlQBUV1dH3X7JJZcAcOedd0bdvnbtWnPd/zQ+y9nWbmx55X1kcS1YZ362FVYCYC+eFHW7sd7YL3K7ozRwLaHthG2fMBOArJziqNudlXMC2+ddGXU71fP7yjzEayqZkE3DqdZBX1N2bgEfHMT3FA9GqibBEuCTwITg393AOuABpdQ/j1Cb446RDC1J9t9qcSAIoYTVz1B910WjjwoMIhWhf2dBbOeL3FdrHTezfTiREYIQK2HPp1j7WughAxj8MHj9vZD++PuR0aJUeOHCGNsTBGFwiKMt9ZAIrPgxFtozUjUJKoBFWus2AKXUvwCbgEuAncAPR6jdpGYkDd/w6IX+9ulfnoEUfbByx+M65VmT2kQbMY9l1D/ZnEuRlzCUl6y+0ygKwvAJPBOG3ptCnQwWpQbdt/vOWNL/vgrVb5SNYgC9EmVJSEY7ZLp935FhhRePx5DpC10ThaV0W7PCrunXDx3nY7fdNKjvKR4h04KQSAzVfhmLmXdGyklQDHSHLPcAJVrrTqVUdz/HpDx9XnoiDHPdzyhMTOeOeNuJGlo9gDzxTDcYVLj44E4tpBjDsfmHcmw8RkIi9Vop1W+aQb+zG4wDB4gwfojleRJJLI7rwRCZbtDXwdb/sX5/4L9lQEeDkCiMdsj0949uAoYeXmwwnkKmL3RNLqcVurxh1/ThO9ZSlJM+qO9JEIQA42l2g0eA15VSfwwuXw88Gixk+O4ItTkuCA97jE+PGMlaB33b6nvgUMON5KVMiEZo3xxIQ2INVzYN8gHOH2mcm/v201Z4KkH4/0gsqu8+vQZN+EH9OSl0xP+BkCicsWe0R0JzcnLoOd8a11HDju5WHDWB7Y7cIrQzfCS029uJdcoKcyTUlpVB+5ljWCoX0HVyL2+3uvCqSXQeeYOM4kp6fDpsJPS9uhy86ZP6HQnVLhfe/EnmNZ30HsG955C5vb60mB5rEV0n95JZOYMzDW7cJ071uabTh45RPG0+HQcOoLta8Sxbi3v381izizib04J79zac1fPY+/K7uPeeoKFh2ZC+p/LyvsaYIKQSAznqhPGJDF70JZn0YKRmN7hPKbUZuCi46pNa6x3Bzx8eiTbHA7GG94cdE+O5LxSlEPWY0P3jqOmxF1sUhOFhONr65C+HFRYM/x9NNwxHQr/Fz8zz9h7bb5X0KA4FjQ5b7+8nksBvOimibw9rYDCeA2FUGe2RUIAv79oU11FDW5qix6dxLVhnfg4dNXTaLHT1+M3jM9Jt2Mtm0O7xkZVTzNwlFezbcRLXgnXYrRbSvP6wkdDKqlwaTzT3OxKak26jpbPHvKbq2aXss04xtxcXZ9Fa34atsBKrRVFU4qIxv7XPNZXNnE26LY0MXYAtTWHPSje3l0yegKslB4CZy5az2/YeRUVFQ/qeBCHV8SeTdSTEBRmU6MtQ0wbGzRSIAFrrN5RStYATQClVpbU+MVLtJRMxG8mxVHseogwX6mx96hMMsR1BiDdaX3gkP9bzQN/ZDaI6EILL/TkJLBFxyoFq7eEOCuO/RUXuq0LaiX5MrzzRnQODuXyZ712IB4OtSaD1AD1vhLukZuAXM0OvI3UzVLGMlARBEIaGGIyCAL4hOsvGQn9GZHYDpdQNSqlDwDHgxeD/Z0aiLSE2Bm1ERVR8jmfIUOS5+ryYGfsNcA6pkpu69NcXh2r8RnalaHnJkc6CSFmi9em+qQo64hhltufXRpX1yGOiyxHZ/yOPHwhRHSHexNKnVERxwnj3wz7T/EZu76c9rXsjdPr8toQcI8+c2FFK3aGUOqCU2qKU+mFwnVUp9bBS6mWl1L1jLaMwwkRRF9Gh2BD9Gd8MVQ/GQntGKpLgPmAF8KzWeqFS6lLgI0M9mVLqDuArwBlgu9b6n5VSVuAXwCTgaa31/cMXO7GIfGGJZgTFc4Q/tN+G5klfqJ3BGmd9R1IHkmngHGxhYEZSd8Yqr7q29kX8BZPorG/gqd/tw9dRTt2h51AlxfR4cvnbE3vw1GdysnM/9bUn8VUtZdPjD9NxuJXjB+24d2+mzbKM9voTuE/W4Z59E+7dm3nub166646zY/MOejzleOoO80rXm/j8U3ji0V/SWdvFa9tcuHdv5kTtVNr2vsAW+z687mLeeGYnXU0OTuxtwr37DboKr+L09hdp69I0zc3AvXsze+doOmvf5vGHj+DrKOS1P/+O9qNttBasoOGNF8mcPpf21vO01dbSPu2DuHdvZvPT5+lpbGPjxo146j38edPTuHe/QH39Qty7N/NWzmk89d28/ucdeIunU3/gANtOW/D5p/DLhx6k82gDu3cV4t69mcOHp9O+7yUefOAEN3/oRqkwfQFS9bkTL/oW3tVho/Gj/Rve3xztGm0+Z/pzWENy5ZEmCP+mtX4wZPkGYL/W+qNKqaeVUqVa67qxEk4YfcRJMCjGhf5ITYK+JNOzZKScBD1a6yallEUpZdFav6CU+vEwzzkiCjMWho6laDLu3ZvZubOUw2/uwL17Dw0Ny9j3whOc77Cyb18lbz/7v3T5S3nqqac4c+YMvo4stj/zOE95F+Gpr+WvT+xhZvoNbH/hJfP4P/zhD1RVVVFUVGQaBTt37uTczlfpLLmejRs3UlNTQ2vtXg7vOUXtFWXmNXndVn79iwdZsWgeAMdffhrX1OU89NBD2O12mjIm4t69mW3b8sOuyb17M3v81Rye6eD5559HF0yi8+hONm48ZV7zrjovPY0WNm7cyIoVK9j+4pu4d+80ZW7yZ+Cpb2bjxo2sWrWKffv20djYSE97Pge2PMfmsnMUFRWZ31P7vpd49FdHuOv2W8XQiY0R0Z2xyquumjOTxrZu3FlVrL9lGf/30HZKl19HRV4GJ440ceUHr+OZ371F5fQiWotbqXd3c82H1vJk104mT5+Fa4GH7LIcXGUTaSxsJSM7D9eCday57FIcO15g2erJ7HrxKLa8clasrWH784e54ZYr+e0Dr7Nk2QpcC9xUVlWTNftSLls/n2d+/xbL1yzjzS1HmDx3Eq6WAjLzCilefDU9zZ3kFk/AtWAdM+YvIn2P4taPrebBf3+Ri6+4hdf/dpDckhIKllxLbn4G6T0+zuXNxBmU6bKrL+Y/Dr/MXXddy/ePbuLKqy/H9aaD/IJCXAvWMfeiGTzdsp8lq9ayv85NvrWIi5ZU8sZzh/jYnTfyHyf/xvyFC3EtaKSmpobMmZdwx8evIsthlQrTsTEuXtRGmljeeSIjCcKPH/xbUx8n+gCn0Fr337buPXYgJ8FYTD+V5NyjlLod+LbW+jkCA0f/G9z2ArAM+NNYCSeMLNG0JZmMowRA9Gec4k2i3LWRchI0K6WygJeAR5RS9UD7MM85IgozFobOa0ebcC1Yx+LFi6k55cTVVUFRURGzLv0grceamDlzJvOvuJFju05x/fXXAPD9ezexbPVNXH/1TD77yiau/MB8Zs6sYHlbJk+cr+hTTMm1oI6amhpqamr43r5cnK487vpIYHv2DqjMW0p1dbV5Td85uInbPnYjFXkZAEzZa6W5s4c77/wgAL969TiuBevMe2Fck2vBOmZfNNFsa8uBetLf8HDXXdea1+zbcoS/bt5vrqvVhTxypsiUeeuhBv77+HZz+8yZgWl+Hvzes0xfs4F165aZ3xVA5sxLuPmjqykqyhJDJzbG1cMmcn51439k4cFoUwuGhvh7fIF1ZjHAKIZC5LZIQ8PY00hRMGoTqJB0nd6ihxHHmPsG9jGid0JrFES2F1lAMVQ+I8VhIEMHhp4Pl6KMK90ZS5QKH80fzpS+0Yg8RR+nwABtGPuqAWSRUdBB8STwa6AA+KtSagmQC7QGt7cEl4VxSjSnmjjaYuZJRH/GLR6vOAnWA53A5wjMZpADfHsY53sSUZiwl5wLTasWiorIVe5vZoPwdIPwUZ9YQ4aizYIQmeMda00CSxQjz0AeNjHzJONMd0JH/sz8fvoWHgybWpDedYF9FFr7g9sCWw3jObQ3Rs4yEGkoWCzGeVXYsaEl3YzzRhYl7JVT4deQFtS5aMf2yhP5v9dZEKhtoEm7QKUZ0Z2YeZIh6I5S6i7gLoCqqqpREDN5GEzXG2w37a9+h0G/6QYRNQn6cwaIb60vSqlS4LcRq+u01rcEPzcopQ4CJQT0JTu4Phs4HOV8ojvjBIkkuDCiP6nJUKeFz7CnxVmSCzNSToJvaq2/DPiBXwEopf4V+PJAB6W6wijVO0WMIlpxspBRmJBjLoRFRY6+Rn8R8od7EmKuSRB6XLSib5FOgFhrElhU/6Oe8rAJJ9V0JzI82TC0jc+968KNfEtIJEGko80wIqJGEkRMOWjqX0jUQuj/UB2LNOwj858Nw8SQV6n+nRK91xMZpRA43ufvO9NCf9MoCgHirTta643ARoAlS5akxN2O5niK9iwY1Dkv2ObAMkQ+LweKBDAjCZQKm6Yt9BiJJOhLMNVmTeR6pVS21rpVKZUOTAUagG3AZcB24FLgsSjnSzndGa9Ee3fr6vGNgSSJi+hPatLY1j3WIsTMiMxuAFwRZd3VFzpIa12ntV4T8XeLUioboB+FgYDCvBHlfBu11ku01kuKioqGfDHxpr93J6XCp0nrGz4Z+rmvQdMfoQZUtOVo57eoiJeuAQs6hToJ+u7XN3Kgr3zRiIyACEWmcQsnVXTHILL/hk45GM1JEBpOHNhf9THiI2cfCF0XOXIf2m7oec20gxAd63UwhJ8rNKoBjemYC6RJhO/be93RHQ8B54IKpi2oYHtERYydcOKtO6lItB4VLapsMMcPNwchVHdCo48GasqvdZiTrSfkJKI2g+JzSqltwBbgfq11D/AUMEcp9TKwTWt9ZiwFFOKDtR9vYHeUkOr1P3tlpMUZL4j+jGO8STQFYlwjCZRSnwI+DUxWSr0dsskFDOfX4XNKqXUEnBr3a617lFJPAR8MKsyfk0lh+vueQ41iiyXaCGDoC0vsToLQ/OjAcvSRn7D0AsIdCQNHEvR+jiZP33VqgKWQ4ywDhH4mT0rPWDOudAei99/AKHpgnRFub7H0RuZEqyVgrDHO5fMb5w+NJNAR/8NlCY0GiFw2ZYxwMEQ6+HprCdCbbmBEN0Q0GBlhYKYyaCNi6MIjuH4JJYiVcac7Y8lgAwsu1EsjHysDRd7BwP3e2Nfr0/0aPXGdSmico7X+NhEppkFD58NjI5EwUgzV4BH6Zzzpj/xsxo+xGOCJd7rBo8AzwA+A0Hk83Vrrc0M96XhSGAhXmlADOi1kdDOasR36kmMYNJYBYkH8/sCoiDEPe2ib0X7XQw0viyV8tD7WaQqjvV+lRazsE0nQz0tZ6P2IREZDY2O86Y5BtGKDvX26N/S/16gOPz5aaH/0mgTBD8Z5Ik4U6RwIr3kQdqjp2DLbCalj0JtuEO5giGwv0kkQmW5g/B8IeaeLjfGqO6NFvF8O7VZLWMGnSAdae/fAocweX/SOr7WmI1jF1Ov309PPfhK8JgiCIIwVY/HuFm8nQRqBok6fidyglMofjqNgPBFqFIfax6E5+FGdBINMN/BrjQXVpwhh5HK081uUChut76/QRqCOQuhytEiCyOWBnQbhckbfJqQugSiXoJEcUqywN1XH+B+SUmAWD8TcHx09JSG8JkF4O5Ej+NGcA8ZyNEM+/NheWXSILKFRPP2mGxgOh1AnQTByIlK/Ikd6xMEmxINQJ3LULnUBL0GPr/fBES2yLTJ/Od2WFuYkMAx7g5bOnrDlSD043+GJKoe7y2vK2uPT/coleiMIgjA4UuFXc2FVLqebO1Eo6lq7zPU56TYy7Wmcbuldd9clk/n7iydx5Y9f4vaVE5lV5gICTu5Mh5WrZpfw3U37uH1lNb96tZZJhRlcP7+cJ3edGpOi0/F2EuwktKZXOBqYHOf2kpIwx0Cow8ASMo3bBV6weg2igZwEve2FpQ6o6B6p/qZbG0gei1L9Vo3u7+DI6If+clc7PD6ctujVPOV9LbWJHGG3hKTUGP0pLaSfR446Gk4FS4hzIZoRYI7c+419Av/bur2B80TsH14PIfwcxn9vRMRCZFRDqMMjUrf6S38wrlnTq27Gsa1dPVHPIQjDQYUl7fSlM8KIj3zmhBr1fh2IOAvV0wZ3d7/7R6O1qycsMiiS/orguru95GbYzOXQvUJlMHT+E7/ewQO3LxlQFkEQBCH50g1e/+plFLscPPL6CZo7PEwvzeaZd86Q5bRy+8qJuJxWGtu6sShFlsNKeW56n2hpHawRBdDe7SXNovrYMru/eWW/MnzjulkAfPP6Wea6UPtwNImrk0BrPSme5xuvhBrFofZx6AhpNMUKHbnxDxBx0OEJvMyEVmwONfjdXV6KXI4+x0VGBIT2x/4MC59fkxYiQzRP1/n28BGcyKiEnn7mDK1r7eKSaYVh657ff3ZAeYTxT6ghEFrDI9II8Pq16ZDrM3Vh0DD3hexjHB86kmgcZ7dawvZp6wo6CYJ93zD8e3UuSh2DYDveYDhze4QR1e314wiGVNuDhRXag4aJzx9+LuPcWY7AT7jLaeXU+U4y7VazYJRhpDUHR1B7UxgQhGHj8Q3ckSIjWIznkkFzhNEf6SS4kFMgUt/PtnaFvUR1e2OvpJ5pt9LcEWgv1DGw/4zb/Fzb1AHA3949G/N5BSEZWTYpn2ynlWf31QMwo9TFl9fNYO/pFn7014MAOG0WvD4dpudfuXoGM8uy+fM7Z3jvfAevHG7i2rllbHrnDLPKsnn3TGvU9oTxy2AK2MaTgkw7q6cV8cSuU+a6L6+bwdwJOcwoc1GY5UBrTbfXz/Gmdspz08l29jqLP7Ki2vx8xaySsHOXZDsHbDv0mjMd8TGzQ4ttjyYjNQUiSqkbgEuCi1u01k+PVFvJRqhRHWrkd/Z4SQ/Ogxlt0MNp7fVE2QaYDP1AXeDFJtSACu1cda1drJxSYC43BafjCN2nu8dnGkaA+QIVjdBRmPaIF0GAY43tYcvGiIzB+SjnrncHwnOKXeHK+JlHduGwWsRJkMIo+o6wW5QyK5EbxkN9azcl2U6OhvS/0AJlacHRfuNH3OiXocaP8dAw1NTYx90Vbrwb+nEu6BBzd3nJsKfh7vKaemTMcXs2GI5mjPCfa/eQl2Hn0Fk3RS4HXr8myxHY19DN2qbANRgODOP3ISfdZsrZ1u0ly2mlNWhcGTIasnX1BI6td3fhclrJy7T3d4sFIe5E5vq3RIT/eyKcxYNNNYvc/2xr7NNMGc8bq0WFGT3ukGfViXMdgxNIEMYAp83CjYsreOLNU3T1+JhVns0nVk2mwd3NL189zsnznXxqzRQsKvD8mFSYxfyKHFo6e5ha4uL2h7bzk5sXkJdp54+7T/Hu6Va+cs1MAC6dUcz6BRMoyLKTbktDKYXH6+eLv3+Ln9yywDSOLpkWmBGptauHbKeNrzZ3Up7j5IafyuwGqcZAddOGwg3zy6l3d7GkOp/TzZ3YrRbsVgvrF5Tz9skWzrd7eOtkC7+6cxkA/37TfE41d1Ka7cQaYTcpFRjhn1GaHa2phCIyIny0GBEngVLqfmAp8Ehw1T8ppS7SWn91JNpLNkIN3NC8S3eX1zRKjje1U5IdGO03RgAr8tLNffOChvmp5vAXl4n3burTTlePH0eIg8Hn1xRm9UYSGCMjoXbXe+c6mFSUaS7/7IU+04Hzp7dOA+FetYe31YZfq1/zyuFGlk3KN9edi4gsON3cGbastWbZ954DwtMx/rK3js4eHx9bWS21ClIYTW9fNYzmtm4v+RkBo7ezJ/BiX9faxYTcdI42tuMIhnoZo5NnWjupzMvgaGO7GQZmGBXtIYZBQZY9uC6gp+fau4Pt9YTt29TuIcOeRoO7m5x0G4fOtjGtxMXZ1m5Tj1s7A/sa/f1cmwelAk6DkmwHb51sYXppID/NeJi9fixQxsVw/DW1BXQnNGIBwGlL4+T5DqaXZpsjoYcb2gLtBfPhmjsDx976wGusmFzAwx9fHuMdF4T4k0hGt+HAWFCZy47a8wBMLsrkaEPAObdycgHbjjaNmXxC6pBhT6PD42PV1EKumVvGV554hzSL4oqZJVwzr4z3TSkg02Hl3TOtpNvS+IdH3+Snty1iZlk2RxramFKUBQRClo2INMN4//tV/Wf8Fgff434dNK4A1i+YwPoFE8L2q8zPCFu2Wy38560Lo57TeJ+dkNv77hoaii2Mf4YynleY5eDOiycyrdiFT2tqirMozXbS3u01+2k0Flfn91mnlKIiLyPK3slF6Axeo8lIRRJcAyzQWvsBlFK/AnYB4iQAGtt6jeTjje2mwb71UCOTg4b5vjNuZpcHvFuvHgm8nFgsCm/ESOLh+jbzXMZIzFeunsELB+rN0dYGdze5wRHHY43tWFR4XYSHX6tlzfSiMOfF6ZYuLp1RbC53eHyU5fQqp9aaf3xsF/dcPjUsLcGiFK6Q8JqthxtZUJkbVmTq7ZMtYfdjZ+15nLZeD99vXj8BwEN3LGHXiWZz/d0P7+SLV06jsc0zJgU8hMSgtbPHTL0xHE4N7m4KMwN6ZBjSZ1u7WFSVC/SmBxipL6ebu1g2MRBNY6TuGCP8h+rbqMrP4MS5DnM0/kjQ4DZCjo3R+ZNBg//U+Q7KcpycdXdR7HJwqL6N1cHRFCNayHDoGU6C2nMdVOdnUO/uZnF1HtDC1GIXrx09Z57fuJb9dW5cDivvnGoJO4eRqqO15mxrN5dMdXCwvo2pxVkcDDoWDp0N/DcMnh6fprtHcg6EsSXW950sh5WcdBungn3eYbVEnYPd4PKZJbx3roMDZ91h66+eU8rpli7yMmxsO9LE1JIs1s0upd3j4+dbjvDN62YxryIHpeBrf9jDt26YzeTCTG578HW+es1Mnt9fz388e3DI1ysIodQUZ7Fh4QT8fs2p5k4WVuXS2unlE5dMpt7dZUZR3rqsKurxi6ryAHjuC2vMdYaDAAgbGEoUrGmKHp/GbhUnQarQEyUtbXJRJo/8/XJONHXwtSf3kJ9h5/FPrjTTP/tzIsUrdD8ZsSjoGU/pBkAuYMxmkDOC7SQdoSPnB8+2Ma0k8MPutFmYWZaN1prWrh4zlPi+p99l6cQ8fH7N6eaAIWMY9Ifq26gpDhz/1slmbltexd2rp/DSoQZ0iG4WBmsQPL7jPTYsrDBf0A6edbP3dCsfXVFtntMwiIz5ohvc3aYnz2DroUYAJhZkmiOXfr/muf31pnMD4P9tOcKNiyv4vzdPAoEfjP978yRzJmSby8/vrzevAaC2sZ1f/t1SVIjn7GDwhe8f1k7lO0+9K5EEKcy5do/pEDMMB3eX10wTOHQ20H+9/t58ydpzAQPZGL30+bUZ/m+kIxh6eayxnQm56Zw412GGIRvOOMPQNo452tBGhj2NN080s2pqIQfPuqnIywikGgSjDU63BM57pL49TOYzLZ2U56Tz3vnz2NMsWFSvfG8cD/x0bjvaRGm2k/11rcwsy+btk81AwIlYmGVn7+lAjmdrlxeX04pfB6IdynPS2V/nJi/DxoE6N5X56ewLyQeNVpNEEIZCXoYtaspYKNlOK61dfVPRDELrjGQ7rdzxvklMKcqkKj+DCXnpOG1puBxWlFLsrD1PZX4gf/QfHn2T3Aw7DqsFn19zy7Iq5lfkoJQKOA6z7BxpaOdMSyerphbR1ePDlmbpU2jqS1dOD4ta23zPJebnZz+/GoC5FTnctryKL/7+rcHeIiHFsKUp7ls/h9pzHcyvyOHh12r5zceX880/7uXzV0y7YKpXZJrleMFhteDx+cNSWYXxTVfIgMRjn1jBisn5phOgLCfd/H2FvtOlC73Y0iy0XWCa35FgpJwEPwB2KaVeIJBCfAlw7wi1lXQYRoLWmpbOHnIzbGYBjXRbGifPd1KVn2Ea7afOd/LPV8/A4/Wz9XADEHAS9Pj8uIPGAcAL++u5uCZQ6M8ozGaMuDutFvx+zc+3HOGB25eYRshf99bxow/N552Tzabh/dPnDwfbCCw/uesUGxZO4NUjjeY1/HrbcTbfs4qDZ9tMObcdbeIDCydwsD5g0Pf4/Jzv8HD5rBIe3/EeANuPneO25VW8E4wmePVIE1fNLuFI0PjSWvPgy8f44lXTeeP4OVOGlw428P0Nc4PXJoULU5lQY8PoN9BboO9gfcA47vb6ze3bg2H7RxvaybSn0e7xmbUy3g0a2qHOsbqWLqwWxUsHA31+35lWCjLtPPV2IMXmQJ2bbKeVE+c6KMl2mm0rFAfr3Mwqy+bEuQ6UwhzR37y3Dgg49gqz7LgcNpo7enBaLew93cLMsmx2HD/HvIoc3j7ZQkVeOifPd1KS7eDg2TaWTczndzveY1FVLv+78z1ml+ewv87NjFIXO2vPUZLt5Fx7N/mZDnx+zcnzHUwuyqKutYu8DDuvHT3Hwqpcdp1oZkpIKpEgDIcffGAuDW0evvHkHr4SfE4VZDnw+f18eHk1++vcTC91YVEB51p3jx+X08qeUy34NVw8tRClYPOeOhZU5jK1OGvAcORA1E2ABz+2tN/9DEdYTXGW6YTub7YcS4wvp/Y0S9SRMSH1UAruXTeD082dXDazBKctjYkFGbR1e5kcMqIPsG5OGQD3vX/OWIiaMNitaXT3+MyCu8L4pzOYUn3FrJKwWmjC4HBY0+j2dl14xzgTV3eeUupnSqn3aa0fA1YATwD/B6zUWv8unm0lM6fOd5LlsHKmpQu/1vj98O6ZVrQOjMbvOdXCvAk5+LXm4Fk3NqsFl8OK1pqHXj5mOhDeOHaOpRPz8euAcf1fW45wUVAJjUqYhnHk14HRSZfDSpbDit8fcCA8s6eOq+eUmvv7/Jo/7DrFL/9uKZrAPk+9fZob5pebVdFrm9rp8PiYUZodVkzjd2+8x0dX9lYEfWZPHRdNKcSW1jt1x9Nvn+b6eeWmkf+n3af56MqJ5jF/3H2aOROycdrSSAuZleHX22pZG0x/sFjGpsqnkHgcOuumIDgqY0TZ1Ld24+7yUlOcZY6eG5EAx4PpAoEaAM3MLs/mVHNn0NAO5CLPKHVR19pFTXEWJ851MKPUxf46N5fPLKG5o4dZZdkcC6YJdQSdDaumFrH1UCMXTSnA3e1lQWUue04FdHrroUZWTg7o5fzKXGqbOmhs87BsUj4HzrqpKc7ieFMHGxZOoN3jMx+kVcHcz5PnOyl2OSgO1jZYXJ3HkYZ2Vk0t5J1TLayeXsQrh5tYNbWQFw404HJY2VF7npll2bi7emhq85DttLHrxHnmTggEdTntiReKKiQGl0wr4svrZgCwdkYxH15exROfvoiSbAfbv3oZz39hNb+4YylHv38Ne759FevmlPHRFdU894XV3L16Cp+9bCq3La/ioysnYrEoZpVnk2ZRKKWYUpTFrPJsKvMzuHpuGdfOKyMn3Ua208ZNSyqZVuJK6Hxlh80SVkdISD2+v2Euh793NYe+ezV3r57Ct9fP4ZJpRSyblE9xtrOPg0Do5UKpQsL4w4j6/PjFMvndcHBYLWOSJhrvmJ+DwI+UUseBzwHvaa3/pLWui3M7Sc3J5k7Kc51sevsM00sDhTm+9ae9pNvS8GvNS4cauHhqIX4/3Pzf2/jw8iqUCoRIO21p3Ly0Ep8fnt9fz2UzivH7Ne+cauH6+eXkBou3Gcb7H986zdVzSvFrzb/95QD3XjODNIsKOg0ChkSmw2oWxfjbu3XcsrSSvAw7fg0vHmygvrWbnAybaZj/elsttwedAUbEQktHD8eb2llQmQv01iy446KJgXNrjcfr57Ht77F8Uj5KBSIN/rq3jkVVuUFnieae3+3mH9dOBTDTDfadaeXEuQ5KgzURbGlKHjQCFgWNbd00BesMGOkGWQ4rXr9mebBY5rrZpbi7vFTlZ+C0WWj3+KjOz8Td5TWrMJflOM3iZWnBcrzXzy8HMM+zoCqXdFsaBVl2mjs8HG1sN50PRr2OGxdXBI4JOgV+eOM8vH7NkomB0c9sp5UilwOlMJ1e91wxDYAPLalkxeR8PrK8mitmlfDoJ1Zw7AfX8O83zec76+eY/T/dHhiFuSEo323BnNW7L5kCwHXzAqNW184t498/tIDff3Ilp1s6WT2tyEyp6PKIoZPK2NKU2a+XTczn2zfM5o2vXc7++9bxPx9bwqfWTGHPt6/ioTuW8r0Nc1lUlcfrX73cNIIunVGMxaLCRgSnpIBxZIRLC6nJ1n++lNuWV2FNs/SplC5cGLs4CVKWeRWSdT4cHLax0Z24xvxorX8C/EQpVQ3cAjyklEoHHgMe01pL1R/AG8zJ+tmWw/zdRZN451Qzbxw/z79/aD7PH6jnz2+e4tNranhmTx0Oaxp3r57ClgP17H6vmclFWWYkwKtHmvjiVdP58XMHueGnr/CTWxaYbWTY02ju8PBm7Xm+du1MXjzQQENbNx9YWMGxxnaaOz38fsd73LSkEoAsRxrt3V5+8cpxfvSh+bR1e+ny+Ljv6Xf54Y3zyLJb6fD4aO/28srhRr5ydWCkKd2eRlu3l/978yQ3zC9HqUDUwMOvBWY5qCrIwO/XdHt9PLn7FOsXlGOxBPfZVktmMM8U4GtP7mF2eTZXzi4FIC/Txrl2D1f/ZCvVBb3VSXPT7ZxoSpzK2MLo4I8oRFHscpJuT6OxzYPdasHj9eNyWFk8MY8DZ93cvnIiD2w9xo2LK9i8t47sdCuTCrPo9Pj4zvtns+7HW7l5SSU/33KEz1xaw/zKXC6dXkx5bjqVW9K5832T6PB4uWvVFG5aWsnM0mw2LJzApx95k4umFHLf++eQl2Fj0ztnWD2tiPULJpjzSa+dUcyqqYV8cFEFi6pymViQybXzyvpMtfPG1y6nMMvO8fuvBeC3d60E4IHblwABR9ma6QFnwvRSF7ctq0Ipxecun4pSigPfXYfDmsbDH19GaY6TW5dVcvPSSmqKs1hcnWfq1rOfW40KFgR69UgjzwfnvxZSj7kTcvjZbYuoKsigpaOHnJApbEORkOC+JHKUgzCyVOVn9KnsLwwOR/A5LaQeGXZ5ngwHhzVtTHRnRL41rXUt8K/AvyqlFgIPAd8EUj7G1evzB0fyNRV56dy4pIJXjzQyqyybRdV5fP3JPXi8fnIzbGw91MAVs0rJclgpynLwzJ46fnHHUtq6vfxlbx2TijJx2tLYfyYQcn3dvHKzncIsB7974z1WTy+iLMfJb16vpSIvg3R7GpX56bx6uInGtm5+eOO8wP4uB3/ZW4fPr6nMz6C5w8ORxnYy7FZztLWprZv/2nKY6+eXm170mqIsHn39BD/fcoTtX70MCEQ8fPOPe/n6tYG5dQ2nwNef3MOf/uF9poyP73iPX9651Dzmse0nwoqYVORlmIXZ/vq53kJSpTlOPvvYLlZNLZTQvhSiMyLMt661i8LgFIWP372Snz5/mO+sn43LaeXbN8zGlmbh+P3X0uHx8vjdKynLCTgVjNlEDMP82A+uQSnFkom90+f8y/WzAfjSVQFnWE5GMEzfksZDd4TnQRtTRBlRPJ9aExjRN6YYrCkOTGsYbS7ewRYQNIwU479RwXrV1ICO/uADAX0OvRYIz7nOsFvpkJDplCLUwXb/B+dSFXS69ucgEPpHMt1Sk8lSx2XYBPKq5dkjCIMlkKoz+rozIvFSSimrUup6pdQjwDPAAeADwzjfvUqpLcG/dqVUvlJqjVKqNrju13ETfoRpavdQkGmnrcuL05pGbrqN14+d46rZpRRm2ens8fGt62fhctro6vGbYf1TgoWXVk0tJDfDxtNvn2FVsEih16/59KU1YZVBq/IzePDlY3xocQXVBZl09fj5QjCs2eW0Udfaxfc2zDGNjTkTcnh8x0nmBHOWc9JtvPVeM1NDZh043dLFz144wi1LK811E3LT+du7Z4HeeXaNqadCc5AMY98wlPaebg0WXQssf2rNFCYWZITNcpDlsHLgrJsvXTU9bDqfS4IGUehUksL4x3ASpAeLj/3lnkt46rMX8+Rn3sf8ihwe/NgSynPTcTlt2EJCQTPsVpZNyqcyP8N0EISSaqODGfY0OiXd4IKMp+dOT7CgzGcuncLscgn7FEaW8aQ7BhlSx2XYSE2C2BhP+lOYZWd+MA1ZGDrjIt1AKXUFcCtwDbAd+C1wl9a6fcADL4DW+n7gfqVUIfC/WutzwRf7h7XWXx+m2KNKfWs3xS4nLxxoYO2MEnPezw8smoDLaePNb1xBfrAQ29vfupJsZ2CkpzDLYY58rpxcwMSCDG4OGuvG+lBuWVbFc/vqzVFMY7TUIPKYRVV5/P6TK1kaHIFUSvGfty7k6jml5j6/vWsFxxvbKQgxtCwWxbSSLL6zvrdq7+5vXEmP3x/W3stfvtS8LoAnPn0R2c7e7rd+wQRzRDaUI9+/ps+0KDkZNm5aUkGmQx7aF0IpdS+wLri4FKgE5gG/Ao4BJ7TWt4+ReIPCMGwXVefym48vD5tGR4iddFsaHZ7+p6MTAoyn545Rb8N4nghDJ8V8ikNiPOmOwYRcec4MF0k3iI3xpD9Xzi7l5iWVF95RGBB72jhwEgBfAR4FvqC1Ph/ncwPcAPwpZPlWpdRq4L+CMyokPPXuLkqCVcqvmFUChBvsoYZ0fy901jQLW7506YDtZDmsPHbXCnM5ltHSpREhykZhNIMVkwtYMbnvFCZ//dzqsOVoIawVeeG5fIuq8vrsE43+5k3NCNZIEAZmPD1sjO+7NDs95Ub/40mGPU10Z3Ak/XPHGyy2N7FQQqbjgd+vY542McVJet0BmFSYyT8HZ/wQho7dKrODDJKk1x+fT/f7Hi/EjsOWNia6E9d0A631Wq31gyPkIADYAPwh+HkHMIPAKOk/KqWKRqjNuFLv7qYo28lPbllgVpcWBk9msNCiEDPRHjZblVK3jpVAg8VIN5Cwz+GR6RAH2yBJ+ueOx+dn1dRCrppdeuGdhQHJy7BzvkNS3WIk6XUHAu8bNpnNYNhkOqy0y7NnMAxKf5RSdymldiildjQ0NIyimP3j0+IkiAdZDuuY2DwJVW5SKVVKIEUhlDqt9S1KKRdQqLU+BqC1bgtu71FKvQRMBcK0Qil1F3AXQFVV1YjKHitNbd1MLsrimrllYy1KUpNht9LeLQ+bQbAB+MfgZ+NhYweeVUo9q7VOeN3p8Hh5/4JyvnXD7LEWJalxjpFHOlFJhedOj0+btTyE4VGU5aCxzROWdpeqpILuCPEjJ91GS2fPWIuRMMRbf7TWG4GNAEuWLEmIEqs+v8YqToJh43JYaUt1J4HWug5Y08/mqwkUQQRAKZWttW5VSqURyLX+SZTzJZzCuLu9uJwJdduTkmKXg7OtXWMtRsKQCg+bTo+PqvwM8UrHCa21pG2QGs8dr8+PzSojofGgyOWgwd3N9FLXWIsy5qSC7gjxI9tp43jTsEqUjSvirT+JiFdSs+KCJTgr3qi3O+otDp0NwBMhyzcppbYDrwB/1FqfHhuxBoe7y4tLikcNmwl56Zxu7hxrMRIGrXWd1npNxN8twc19HjbB/8bD5vioCzwEOnt8pMtcu3Eha4y80knIuHju9Pj82ORFLS4UuRw0tImDOgbGhe4I8SMn3UZrl0QSxMi40B+/X5MmgxFJS9K8cWutb41YfhB4cIzEGTIBJ0HS3PaEZUJuOqfESRArG4DvhSzfFAzr9AOPJcvDpsPjI92WTH7NxKU428nZ1m5xWF6A8fLc6fFprJJTHRcKswKRBMLAjBfdEeJHboaNczJ1dUyMF/3xS02CuKFQo140V94aRpC7H97BxHs3ha1r6+rB5RAnwXApzXFyukVGc2JBa32r1npPyPKDWutlWusVWuukCFmDQLpBhkQSxIVil4N6t+hPquD1aSm8FicCkQTiJEglFGLkxIOKvHROnpfBnVTC59cybWycyM2wjXrRXHlriBP/u/MkE+/dxMR7N/HUW4GB2b/sPQvAw6/VAnCmpZPGNg/pUp192DisafTIfLspRVePD4dEEsSFkmwH9a1i6KQKXr8f8RHEB6MmgTA+0GOQ55uqSOHC1MOv+5/KXBgc5TnpnG4e3cGdlB6W8/s17R4v7i4vB8+6ebP2PP/5/GHuuXwqNcVZXDu3zCzsZRT5au7w0NLZw9nWbvIzbXz7qXfZeqgx7LyffWwXn31sFwBfvHIa33hyD9940hzIxS4FpOKCw2ah0+MTp0uCY7yE+fy9Ic9nW7v47qZ9vHyogc9fOZ3/euEw939wHqun9T8rVo/Pj10snbhQXZDJ8/vqef/CCWMtSkryx92nqMhL55XDTditFm6YX05ZjhOtAwWK6lq6WPGD55gzIZs9p1rj0mZVfkZczpPqFGVJFM5Y8tH/ed1855pcmIlS0ODuxm618JlLa+jx+ZlZlk2Hx8fdD+/sc/zXrpnJjtpz5iBOf9xx0USmFGfhtFp451TLiFxLqqGUIs2i8Pr8kv40Bmw91MDGl47ykRXVrJ1RjNWiaGr3UJjl4ExLJ2dbu6nOz+CdUy3kZdh56JVjTCrM5P/720GunVvGpnfOhJ3PalF4/b1OtpriLA7Xt0U2y3ffP2fEry0VmJCXzqnmDuZW5IxamyntJLjx/73Kmyea+6z/8bOHAPgHdsV0nhvml/PjmxeE5Yk8/fZpynLSWVydxydXT6GxzUN+pp1pX39GDJ04Mb3ExbP7znL9/PKxFiXleP1oEzdvfC0u5zIcaB97aPsF971vvUx/GA+ml7j43O928683zhtrUVKOrh4f//Tb3WHr7n9mf9R9Qx0Ev/n4cnadOI/Forh6Timf+PUOjjRErxQ+vyKHBZW5nGruJNtp44ldpzhxriNu15DK5GbYeOVwEz6/5NqOBZMKM00nwdHG8P7/n88d4nzHwCPV3/vzPvPzl66azqfXTGHroUZmlmVTkGnnF68e576n3+XVI4388tXjcZc/1ZlclMmh+jZmlmWPtSgpR0m2k6MN7VGdZ5HctKSCP+w6ZS5HOgggECEQ6iSozs9gcmEmf3033AEnUy7Hh6nFWeyvc7NuTtmotZnSToInPv2+Abc3tXXz6pEmVk4poCDTDhDzlGHXzes1XK1pFkpznAAcv//aIUorRHLpjGIe3Hr0gk4Cr8/Ph/57G59ZU8Pls0pGSbrxzeSiLC6uKeTlw41Rt3/+immU56ZzybRCctPtdPb4yLSn0dbt5Vy7h8lFWea+oYVYunp8bDvahAL+9u5ZHnn9BNBbqLK2SQydeDCxMJMMexotHT3kZEjxwtHEaUsb8nPg4qmF5ufnvrAm5uOKXA7++6WjQ2pTCMd4B/j847v5yS0Lx1ia1OM76+fwnfXxHZm8JCSC7eMXT+LjF08yl70+PzVfeybaYcIQWDW1iM176sRJMAZMK3Hxyr1rzeXIVBulVNjUyD+8cf6w25x47yYsUpQgLiyqzjPfiUeLlHYSXIiCLIeMUicwV80u5Z7f7uaPu0+xfkFv2HR9axdrfrSFDk+493J+Ze4oSzh+KXI5+M3fL495fyPFJjfDTm6GPWxbaASO05bGpdOLAVgzvZjvbZhrbnvf/c9TVSAh0/Fiw8IJ3PvE2/z8I4v73ae5w8NPnz/M1XNLWVydP4rSCfFkRpmLi2sKL7yjEBOPfmI5tz3wOt+4bhaFWY4+270+P/f8bjfXzC1jUVWeOUggJB+xDgwJsXH9/DKmf30zH1g0geqCzKj7aK1pbPPw42cP8pVrZpIlxb5HhGh9eyT6u6hQfCjJdvLy4UYeevkYd4Y4MiM5eb6DVT98gRe/eOmw35lF84Sk5rd3rWD9z17pE74LUJ7j5E+fvRiP1095bvroCyfElRe/tEbCe+PIP142lbnf+isT791EQaadpvb+q+am29PESZDEbFhYwYaFFWMtxrjhoimF/N37JrLku88CMKPUxf46d5/9nn47EKJ75PvXyG9XkmJRcM/lU8dajHGDw5rGdfPKWP1vW4DAAML0Ele/dR/+6fKp4iRIcuT7ix9fXjeD7zz9Lt95+t0L7vvQK8f41g3DS9GVb05IauZX5rL/vnXM+MZmAG5fWR33UEQhMZBCR/HF5bTx2CdWcOsDr0V1EPzqzmWsqikc1Tl5BSFZ+JfrZ3PdvDI++PNtpoPgA4smUOxyMrkok5uWVI6xhEI8UEpxz+XTxlqMccVPb1vE9JJD/Ofzh/B4/WEOgic/8z4WSNTnuEFSrOPLp9ZM4f0Ly1n5g+fD1udm2GgO1mMpyXbw6r2XxcUxLU4CIekZTo6vIKQyK6cUiO4IwhBZXJ0v+iMIQ+Czl03ls5dJhIYgDJaynPRRe+7I0JwgCIIgCIIgCIIgCIA4CQRBEARBEARBEARBCCJOAkEQBEEQBEEQBEEQAFCR82SOV5RSDUBtlE2FQPTJ3hMHkTE+9Cdjtda6KMp6AdGdUSCZZRTdGQDRnREnGWQE0Z9BM4DuQHJ87yJjfBDdGQLy7BlxklnGmHUnZZwE/aGU2qG1XjLWcgyEyBgfkkHGZCIZ7qfIGB+SQcZkIhnup8gYP5JFzmQhGe6nyBgfkkHGZCIZ7qfIGB/iIaOkGwiCIAiCIAiCIAiCAIiTQBAEQRAEQRAEQRCEIOIkgI1jLUAMiIzxIRlkTCaS4X6KjPEhGWRMJpLhfoqM8SNZ5EwWkuF+iozxIRlkTCaS4X6KjPFh2DKmfE0CQRAEQRAEQRAEQRACSCSBIAiCIAiCIAiCIAhAijsJlFL/oZTaqpT6yRjKUK6UelMp1aWUsvYnV6zrRkjG5UqpV5VSLyul/iO47kvB5UeUUrbBrBshGecEZdyqlPqFCpBQ93E8kQj3THQnbjKK7owiiXDPRHfiJqPoziiTCPct0fVHdEeIRiLct0TXnWA7oj9BUtZJoJRaBGRprVcBdqXU0jES5RxwGfBaf3LFum4EZawF1mqtLwaKlVKrgUuDy28D71dKFceybgRlPKC1vih4PwCWkXj3cVyQQPdMdCc+iO6MEgl0z0R34oPoziiSQPct0fVHdEcII4HuW6LrDoj+mKSskwBYAfwt+PlZYOVYCKG17tJanw9ZFU2uWNeNlIx1Wuuu4GIPMBvYEtH2khjXjZSMPSGL3QR+hBLqPo4jEuKeie7ETUbRndEjIe6Z6E7cZBTdGV0S4r4luv6I7ghRSIj7lui6E5RR9CdIKjsJcoHW4OeW4HIikEtfuWJdN6IopeYBRUBzIsqolLpBKbUHKAFsiSjjOCGXxLxnuSTody66IwTJJTHvWS4J+p2L7ggh5JKY9y2XBPzeRXeEEHJJzPuWS4J+76I/qe0kaAGyg5+zCXSCRCCaXLGuGzGUUvnAT4GPJ6qMWus/aa3nACcBbyLKOE5I1HuWkP1SdEcIIVHvWUL2S9EdIYJEvW8J1zdFd4QIEvW+JWTfFP0JkMpOgm0EwjMALieYH5MARJMr1nUjggoUF/kN8EWtdR3wBrA6ou1Y142UjI6QxVZAk2D3cRyRqPdMdGdoMorujB6Jes9Ed4Ymo+jO6JKo9y2h9Ed0R4hCot63hNIdEP0JJWWdBFrrN4EupdRWwKe13j4WciilbEqpZ4H5wF8IhIyEyRVN1lGW/0PAUuCHSqktwBTgJaXUy8AC4EmtdX0s60ZQxnVKqReVUi8SCL25n8S7j+OCRLlnojtxQ3RnlEiUeya6EzdEd0aRRLlvSaA/ojtCGIly35JAd0D0x0RprUfwGgRBEARBEARBEARBSBZSNpJAEARBEARBEARBEIRwxEkgCIIgCIIgCIIgCAIgTgJBEARBEARBEARBEIKIk0AQBEEQBEEQBEEQBECcBIIgCIIgCIIgCIIgBBEngSAIgiAIgiAIgiAIgDgJBEEQBEEQBEEQBEEIIk4CQRAEQRAEQRAEQRAA+P8BVTto01qayfUAAAAASUVORK5CYII=\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1512x360 with 12 Axes>"
       ]
@@ -830,429 +830,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "efel_settings is None. Default settings will be used\n",
-      "Cannot compute the relative current amplitude for the recordings of cell B6 because its rheobase is None.\n",
-      "Cannot compute the relative current amplitude for the recordings of cell B8 because its rheobase is None.\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/extract.py:410: RuntimeWarning: Mean of empty slice\n",
-      "  global_rheobase = numpy.nanmean(\n",
-      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_150. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_150. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_150. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_150. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_150. The efeature will be ignored\n",
-      "No efeatures for stimulus IDRest_150. The protocol will not be created.\n",
-      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_200. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_200. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_200. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_200. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_200. The efeature will be ignored\n",
-      "No efeatures for stimulus IDRest_200. The protocol will not be created.\n",
-      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_250. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_250. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_250. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_250. The efeature will be ignored\n",
-      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_250. The efeature will be ignored\n",
-      "No efeatures for stimulus IDRest_250. The protocol will not be created.\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/extract.py:473: RuntimeWarning: Mean of empty slice\n",
-      "  numpy.nanmean(list(threshold.values())),\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
-      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
-      "  ret = ret.dtype.type(ret / rcount)\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
-      "  return numpy.nanmean(self._values)\n",
-      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
-      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
-      "The output of the extraction is empty. Something went wrong. Please check that your targets, files_metadata and protocols_rheobase match the data you have available.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "_, _, current = bluepyefe.extract.extract_efeatures(\n",
     "    output_directory='MouseCells',\n",
@@ -1277,13 +857,6 @@
     "}\n",
     "assert current[\"holding_current\"] == [-0.032810899429023266, 0.020311509259045124]\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/examples/nwb_extraction.ipynb b/examples/nwb_extraction.ipynb
new file mode 100644
index 0000000..6912f79
--- /dev/null
+++ b/examples/nwb_extraction.ipynb
@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extracting efeatures from NWB files with BluePyEfe\n",
+    "\n",
+    "This notebook shows the NWB-specific workflow: inspect an NWB file, read traces through the automatic NWB reader and extract a couple of efeatures."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pathlib\n",
+    "import tempfile\n",
+    "from pprint import pprint\n",
+    "\n",
+    "import h5py\n",
+    "import matplotlib\n",
+    "import numpy as np\n",
+    "\n",
+    "matplotlib.use(\"Agg\")\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from bluepyefe.cell import Cell\n",
+    "from bluepyefe.reader import inspect_nwb, nwb_reader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The examples can be run either from the repository root or from the `examples` directory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cwd = pathlib.Path.cwd()\n",
+    "repo_root = cwd.parent if cwd.name == \"examples\" else cwd\n",
+    "\n",
+    "bbp_nwb_path = repo_root / \"tests\" / \"exp_data\" / \"hippocampus-portal\" / \"99111002.nwb\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Inspect the NWB file\n",
+    "\n",
+    "`inspect_nwb` chooses the reader class from the file layout and reports the protocols that BluePyEfe can parse."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'metadata': {'identifier': '99111002',\n",
+      "              'nwb_version': '2.4.0',\n",
+      "              'session_description': 'UCL'},\n",
+      " 'protocols': ['Step'],\n",
+      " 'reader': 'BBPNWBReader',\n",
+      " 'trace_count': 16}\n"
+     ]
+    }
+   ],
+   "source": [
+    "info = inspect_nwb(bbp_nwb_path)\n",
+    "\n",
+    "summary = {\n",
+    "    \"reader\": info[\"reader\"],\n",
+    "    \"protocols\": info[\"protocols\"],\n",
+    "    \"trace_count\": len(info[\"traces\"]),\n",
+    "    \"metadata\": {\n",
+    "        key: info[\"metadata\"].get(key)\n",
+    "        for key in (\"identifier\", \"nwb_version\", \"session_description\")\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "pprint(summary)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Read and plot the traces\n",
+    "\n",
+    "`nwb_reader` returns the raw trace dictionaries that are passed into BluePyEfe recording objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "traces = nwb_reader({\"filepath\": str(bbp_nwb_path), \"protocol_name\": \"Step\"})\n",
+    "trace = traces[0]\n",
+    "\n",
+    "t_ms = np.arange(trace[\"voltage\"].size) * trace[\"dt\"] * 1000.0\n",
+    "\n",
+    "fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(7, 5), sharex=True)\n",
+    "axes[0].plot(t_ms, trace[\"current\"], lw=0.8)\n",
+    "axes[0].set_ylabel(f\"Current ({trace['i_unit']})\")\n",
+    "axes[1].plot(t_ms, trace[\"voltage\"], lw=0.8)\n",
+    "axes[1].set_xlabel(\"Time (ms)\")\n",
+    "axes[1].set_ylabel(f\"Voltage ({trace['v_unit']})\")\n",
+    "\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extract efeatures from NWB recordings\n",
+    "\n",
+    "A `.nwb` file can be passed to `Cell.read_recordings` with the same `filepath` and `protocol_name` metadata used by `nwb_reader`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'amp_nA': -2.0,\n",
+      " 'efeatures': {'steady_state_voltage_stimend': -15.354062499997845,\n",
+      "               'voltage_base': -14.819999999999457},\n",
+      " 'first_recording': 'ic__Step__1',\n",
+      " 'recording_count': 16,\n",
+      " 'toff_ms': 431.1,\n",
+      " 'ton_ms': 31.200000000000003}\n"
+     ]
+    }
+   ],
+   "source": [
+    "efel_settings = {\n",
+    "    \"strict_stiminterval\": True,\n",
+    "    \"Threshold\": -20.0,\n",
+    "    \"interp_step\": 0.025,\n",
+    "}\n",
+    "\n",
+    "cell = Cell(name=bbp_nwb_path)\n",
+    "cell.read_recordings(\n",
+    "    protocol_data=[{\"filepath\": str(bbp_nwb_path), \"protocol_name\": \"Step\"}],\n",
+    "    protocol_name=\"Step\",\n",
+    "    efel_settings=efel_settings,\n",
+    ")\n",
+    "\n",
+    "cell.extract_efeatures(\n",
+    "    protocol_name=\"Step\",\n",
+    "    efeatures=[\"voltage_base\", \"steady_state_voltage_stimend\"],\n",
+    "    efel_settings=efel_settings,\n",
+    ")\n",
+    "\n",
+    "first_recording = cell.recordings[0]\n",
+    "feature_preview = {\n",
+    "    \"recording_count\": len(cell.recordings),\n",
+    "    \"first_recording\": first_recording.name,\n",
+    "    \"ton_ms\": float(first_recording.ton),\n",
+    "    \"toff_ms\": float(first_recording.toff),\n",
+    "    \"amp_nA\": float(first_recording.amp),\n",
+    "    \"efeatures\": {\n",
+    "        name: float(value)\n",
+    "        for name, value in first_recording.efeatures.items()\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "pprint(feature_preview)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/tests/ecode/test_waveform_ecodes.py b/tests/ecode/test_waveform_ecodes.py
new file mode 100644
index 0000000..2849633
--- /dev/null
+++ b/tests/ecode/test_waveform_ecodes.py
@@ -0,0 +1,83 @@
+"""CapCheck and PinkNoise eCode tests."""
+import numpy
+
+from bluepyefe.cell import Cell
+from bluepyefe.ecode import eCodes
+from bluepyefe.ecode.capCheck import CapCheck
+from bluepyefe.ecode.pinkNoise import PinkNoise
+
+
+def _reader_data(current):
+    return {
+        "voltage": numpy.full(len(current), -65.0),
+        "current": current,
+        "dt": 0.0001,
+        "i_unit": "nA",
+        "v_unit": "mV",
+        "t_unit": "s",
+    }
+
+
+def _read_recording(protocol_name, current, config=None):
+    config_data = {
+        "filepath": f"{protocol_name}.nwb",
+        "i_unit": "nA",
+        "v_unit": "mV",
+        "t_unit": "s",
+    }
+    if config:
+        config_data.update(config)
+
+    cell = Cell("cell")
+    cell.read_recordings(
+        protocol_data=[config_data],
+        protocol_name=protocol_name,
+        recording_reader=lambda _: [_reader_data(current)],
+    )
+    return cell.recordings[0]
+
+
+def test_waveform_ecodes_are_registered():
+    assert eCodes["pinknoise"] is PinkNoise
+    assert eCodes["capcheck"] is CapCheck
+
+
+def test_pink_noise_recording_can_be_read_and_generated():
+    current = numpy.zeros(600)
+    current[80:140] = 0.03 + 0.008 * numpy.sin(numpy.linspace(0.0, 20.0, 60))
+    current[240:320] = 0.06 + 0.012 * numpy.sin(numpy.linspace(0.0, 30.0, 80))
+    current[420:520] = 0.09 + 0.016 * numpy.sin(numpy.linspace(0.0, 40.0, 100))
+
+    recording = _read_recording(
+        "PinkNoise",
+        current,
+        config={"ton": 8.0, "toff": 52.0},
+    )
+    generated_t, generated_current = recording.generate()
+
+    assert isinstance(recording, PinkNoise)
+    numpy.testing.assert_allclose(recording.ton, 8.0)
+    numpy.testing.assert_allclose(recording.toff, 52.0)
+    assert recording.amp > 0.0
+    assert len(generated_t) == len(generated_current)
+    numpy.testing.assert_allclose(generated_current[80:520], current[80:520])
+
+
+def test_cap_check_recording_can_be_read_and_generated():
+    current = numpy.zeros(500)
+    cycle = numpy.linspace(-0.05, 0.05, 50, endpoint=False)
+    current[50:450] = numpy.tile(cycle, 8)
+
+    recording = _read_recording(
+        "CapCheck",
+        current,
+        config={"ton": 5.0, "toff": 45.0},
+    )
+    generated_t, generated_current = recording.generate()
+
+    assert isinstance(recording, CapCheck)
+    numpy.testing.assert_allclose(recording.ton, 5.0)
+    numpy.testing.assert_allclose(recording.toff, 45.0)
+    assert recording.amp > 0.0
+    assert len(generated_t) == len(generated_current)
+    numpy.testing.assert_allclose(generated_current[50:450], current[50:450])
diff --git a/tests/test_nwbreader.py b/tests/test_nwbreader.py
index fac3df0..a1016d3 100644
--- a/tests/test_nwbreader.py
+++ b/tests/test_nwbreader.py
@@ -13,7 +13,13 @@
     nwb_reader,
 )
 from bluepyefe.nwbreader import (
-    NWBReader, AIBSNWBReader, ScalaNWBReader, BBPNWBReader, TRTNWBReader, VUNWBReader
+    PROTOCOL_VU_TO_BBP,
+    NWBReader,
+    AIBSNWBReader,
+    ScalaNWBReader,
+    BBPNWBReader,
+    TRTNWBReader,
+    VUNWBReader,
 )
 
 
@@ -175,7 +181,12 @@ def test_nwb_inspection_detects_aibs_layout(dummy_content):
     assert _get_nwb_protocols(dummy_content, reader_class) == ["Step"]
 
 def make_vu_content_for_step(
-    bias_pA=0.0, with_nans=False, stimulus_description_in_attrs=True
+    bias_pA=0.0,
+    bias_current_as_array=False,
+    with_nans=False,
+    stimulus_description_in_attrs=True,
+    stimulus_description="CCSteps_DA_0",
+    current_values=None,
 ):
     # Voltage/data
     voltage_ds = DummyDS(
@@ -183,17 +194,24 @@ def make_vu_content_for_step(
         {"conversion": 1.0, "unit": "mV", "rate": 10000},
     )
     # Current/data with optional NaNs at tail
-    current_vals = np.array([0.1, 0.2, 0.3, 0.4], dtype=float)
-    if with_nans:
+    if current_values is None:
+        current_values = [0.1, 0.2, 0.3, 0.4]
+    current_vals = np.array(current_values, dtype=float)
+    if with_nans and current_vals.size:
         current_vals[-1] = np.nan
     current_ds = DummyDS(current_vals, {"conversion": 1.0, "unit": "pA"})
     start_time_ds = DummyDS([0.0], {"rate": 10000, "unit": "s"})
     sweep_children = {"data": current_ds}
     sweep_attrs = {}
     if stimulus_description_in_attrs:
-        sweep_attrs["stimulus_description"] = "CCSteps_DA_0"
+        sweep_attrs["stimulus_description"] = stimulus_description
     else:
-        sweep_children["stimulus_description"] = DummyDS([b"CCSteps_DA_0"], {})
+        sweep_children["stimulus_description"] = DummyDS(
+            [stimulus_description.encode("UTF-8")], {}
+        )
+    bias_current = bias_pA * 1e-12
+    if bias_current_as_array:
+        bias_current = [bias_current]
 
     # Group layout
     content = {
@@ -208,7 +226,7 @@ def make_vu_content_for_step(
                     {
                         "data": voltage_ds,
                         "starting_time": start_time_ds,
-                        "bias_current": DummyDS(bias_pA * 1e-12, {}),
+                        "bias_current": DummyDS(bias_current, {}),
                     },
                     attrs={},
                 ),
@@ -217,6 +235,26 @@ def make_vu_content_for_step(
     }
     return content
 
+
+def test_vu_protocol_mapping_covers_supported_protocols():
+    assert PROTOCOL_VU_TO_BBP == {
+        "X1PS_SubThresh_DA_0": "IV",
+        "X2LP_Search_DA_0": "IDThresh",
+        "X3LP_Rheo_DA_0": "IDRest",
+        "X4PS_SupraThresh_DA_0": "IDRest",
+        "X4PT_C2NSD1SHORT_DA_0": "PinkNoise",
+        "X4PU_C2NSD2SHORT_DA_0": "PinkNoise",
+        "X5SP_Search_DA_0": "IDThresh",
+        "X6SP_Rheo_DA_0": "IDRest",
+        "X6SQ_C2SSTRIPLE_DA_0": "SpikeRec",
+        "X7Ramp_DA_0": "Ramp",
+        "X8_CHIRP_DA_0": "SineSpec",
+        "X9_C1QCAPCHK_DA_0": "CapCheck",
+        "X9_C1SQCAPCHK_DA_0": "CapCheck",
+        "CCSteps_DA_0": "Step",
+        "steps_DA_0": "Step",
+    }
+
 def test_vunwbreader_protocol_filter_excludes_non_matching():
     # stimulus_description maps to "Step"; ask for IV -> excluded
     content = make_vu_content_for_step()
@@ -234,6 +272,30 @@ def test_vunwbreader_accepts_protocol_list():
     assert len(reader.read()) == 1
 
 
+def test_vunwbreader_matches_translated_protocol_case_insensitively():
+    content = make_vu_content_for_step(stimulus_description="X2LP_Search_DA_0")
+    in_data = {"protocol_name": "IDthresh"}
+    reader = VUNWBReader(content, target_protocols=["IDthresh"], in_data=in_data)
+
+    assert len(reader.read()) == 1
+
+
+def test_vunwbreader_skips_empty_data_trace():
+    content = make_vu_content_for_step(current_values=[])
+    in_data = {"protocol_name": "Step"}
+    reader = VUNWBReader(content, target_protocols=["Step"], in_data=in_data)
+
+    assert reader.read() == []
+
+
+def test_vunwbreader_accepts_array_bias_current():
+    content = make_vu_content_for_step(bias_pA=1.0, bias_current_as_array=True)
+    in_data = {"protocol_name": "Step"}
+    reader = VUNWBReader(content, target_protocols=["Step"], in_data=in_data)
+
+    assert len(reader.read()) == 1
+
+
 def test_nwb_inspection_detects_vu_layout():
     content = make_vu_content_for_step()
     reader_class = _get_nwb_reader_class(content)