diff --git a/.gitignore b/.gitignore
index 5c55ea52..4633c03a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -153,4 +153,8 @@ dmypy.json
 .pytype/
 
 # Cython debug symbols
-cython_debug/
\ No newline at end of file
+cython_debug/**/.DS_Store
+
+**/.DS_Store
+*.pkl
+cleo/test_store.py
diff --git a/cleo/base.py b/cleo/base.py
index ab11253a..8cb18433 100644
--- a/cleo/base.py
+++ b/cleo/base.py
@@ -341,6 +341,11 @@ def _default_registry(self):
     _processing_net_op: NetworkOperation = field(default=None, init=False, repr=False)
     _net_store_name: str = field(default="cleo default", init=False, repr=False)
 
+    @property
+    def registry(self):
+        """Returns the DeviceInteractionRegistry for this simulator."""
+        return registry_for_sim(self)
+
     def inject(
         self, device: InterfaceDevice, *neuron_groups: NeuronGroup, **kwparams: Any
     ) -> CLSimulator:
diff --git a/cleo/imaging/scope.py b/cleo/imaging/scope.py
index 53f2150e..36b69df6 100644
--- a/cleo/imaging/scope.py
+++ b/cleo/imaging/scope.py
@@ -2,20 +2,21 @@
 
 import warnings
 from datetime import datetime
-from typing import Callable
 
 import matplotlib as mpl
 import neo
 import quantities as pq
 from attrs import define, field, fields
-from brian2 import NeuronGroup, Quantity, Unit, meter, mm, ms, np, um
+from brian2 import NeuronGroup, Quantity, Unit, meter, mm, ms, np, um, second
 from jaxtyping import Float, UInt
 from matplotlib.artist import Artist
 from mpl_toolkits.mplot3d import Axes3D
+from numpy import pi
 
 from cleo.base import Recorder
 from cleo.coords import coords_from_ng
 from cleo.imaging.sensors import Sensor
+from cleo.light import Light, GaussianEllipsoid
 from cleo.utilities import (
     analog_signal,
     normalize_coords,
@@ -102,30 +103,38 @@ class Scope(Recorder):
     rho_rel_generator : Callable[[int], Float[np.ndarray, "n"], optional
         A function assigning expression levels. Takes n as an arg, outputs float array.
         ``lambda n: np.ones(n)`` by default.
-    focus_depth : Quantity, optional
-        The depth of the focal plane, by default that of the scope.
-    soma_radius : Quantity, optional
-        The radius of the soma of the neuron, by default that of the scope.
-        Used to compute noise focus factor, since smaller ROIs will have
-        a noisier distribution of fluorescence, averaged over fewer pixels.
+            focus_depth : Quantity, optional
+                The depth of the focal plane, by default that of the scope.
+            soma_radius : Quantity, optional
+                The radius of the soma of the neuron, by default that of the scope.
+                Used to compute noise focus factor, since smaller ROIs will have
+                a noisier distribution of fluorescence, averaged over fewer pixels.
     """
 
     sensor: Sensor = field()
     img_width: Quantity = field()
     """The width (diameter) of the (circular) image captured by the microscope.
     Specified in distance units."""
+
     focus_depth: Quantity = None
     """The depth of the focal plane, with distance units"""
+
     location: Quantity = [0, 0, 0] * mm
     """Location of the objective lens."""
+
     direction: Float[np.ndarray, "3"] = field(
         default=(0, 0, 1), converter=normalize_coords
     )
     """Direction in which the microscope is pointing.
     By default straight down (`+z` direction)"""
+
     soma_radius: Quantity = field(default=10 * um)
     """Assumed radius of neurons, used to compute noise focus factor.
     Smaller neurons have noisier signals."""
+
+    t_flyback: Quantity = field(default=0 * ms, kw_only=True)
+    """Dead time per scan cycle for the scanning mirror to reset (flyback)."""
+
     snr_cutoff: float = field(default=1)
     """SNR below which neurons are discarded.
     Applied only when focus_depth is not None"""
@@ -157,6 +166,9 @@ class Scope(Recorder):
     )
     """relative expression levels of neurons selected from each injection"""
 
+    imaging_light: Light = field(init=False, repr=False, default=None)
+    """raster scanning parameters"""
+
     @property
     def n(self) -> int:
         """Number of imaged ROIs"""
@@ -314,6 +326,10 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams) -> None
         self.sigma_per_injct.append(sigma_noise)
         self.focus_coords_per_injct.append(focus_coords)
         self.rho_rel_per_injct.append(rho_rel)
+        if self.imaging_light is not None:
+            self.sim.registry.set_img_width(
+                self.imaging_light, self.img_width, self.soma_radius
+            )
 
     def i_targets_for_neuron_group(self, neuron_group):
         """can handle multiple injections into same ng"""
@@ -451,3 +467,27 @@ def to_neo(self) -> neo.AnalogSignal:
             )
         return signal
         # want ROI coordinates and size in image
+
+    # Method for optional raster scanning
+    def create_imaging_light(self, wavelength=920e-9 * meter, pulse_freq=30):
+        spot_area = pi * self.soma_radius**2
+        img_width_area = pi * (self.img_width / 2) ** 2
+        effective_scan_time = (1 / pulse_freq) * second - self.t_flyback
+        pulse_width = spot_area / img_width_area * effective_scan_time
+        self.imaging_light = Light(
+            name=f"{self.name}_imlight",
+            light_model=GaussianEllipsoid(),
+            wavelength=wavelength,  # user can pass in wavelength values
+            pulse_freq=pulse_freq,  # user sets pulse freq when creating imaging light
+            pulse_stagger=True,
+            is_pulsed=True,
+            pulse_width=pulse_width,
+        )
+        return self.imaging_light
+
+    # keep img_width validator and update imaging width
+    @img_width.validator
+    def _update_img_width(self, attr, value):
+        # Make sure create_imaging_light has been called
+        if self.imaging_light is not None:
+            self.sim.registry.set_img_width(self.imaging_light, value, self.soma_radius)
diff --git a/cleo/light/light.py b/cleo/light/light.py
index 434c925c..cb364dfb 100644
--- a/cleo/light/light.py
+++ b/cleo/light/light.py
@@ -9,20 +9,15 @@
 
 import matplotlib as mpl
 import quantities as pq
-from attrs import define, field
+from attrs import define, field, setters
 from brian2 import (
     NeuronGroup,
     Subgroup,
     np,
 )
-from brian2.units import (
-    Quantity,
-    mm,
-    mm2,
-    mwatt,
-    nmeter,
-    um,
-)
+
+
+from brian2.units import Quantity, mm, mm2, mwatt, nmeter, um, second, ms
 from jaxtyping import Float
 from matplotlib import colors
 from matplotlib.artist import Artist
@@ -282,7 +277,22 @@ def _is_irr(q: Quantity) -> bool:
     return q.has_same_dimensions(mwatt / mm2)
 
 
-@define(eq=False)
+def _sync_scan_param_to_registry(instance, attribute, value):
+    """attrs on_setattr hook: pushes scan-related field changes down to the
+    Brian variable on light.source, if this Light is part of a running sim."""
+    if instance.sim is not None:
+        setter_name = f"set_{attribute.name}"
+        if hasattr(instance.sim.registry, setter_name):
+            getattr(instance.sim.registry, setter_name)(instance, value)
+    return value
+
+
+@define(
+    eq=False,
+    on_setattr=setters.pipe(
+        setters.convert, setters.validate, _sync_scan_param_to_registry
+    ),
+)
 class Light(Stimulator):
     """Delivers light to the network for photostimulation and (when implemented) imaging.
 
@@ -316,6 +326,18 @@ class Light(Stimulator):
     wavelength: Quantity = field(default=473 * nmeter, kw_only=True)
     """light wavelength with unit (usually nmeter)"""
 
+    pulse_freq: float = field(default=30, kw_only=True)
+    """Rate (Hz) at which the raster scan sweeps over target neurons."""
+
+    pulse_width: Quantity = field(default=0 * ms, kw_only=True)
+    """Duration of each per-neuron light pulse during raster scanning."""
+
+    is_pulsed: bool = field(default=False, kw_only=True)
+    """Whether this light delivers discrete pulses (raster scanning) vs. constant illumination."""
+
+    pulse_stagger: bool = field(default=False, kw_only=True)
+    """Whether per-neuron pulses are staggered in time to avoid simultaneous activation."""
+
     @coords.validator
     def _check_coords(self, attribute, value):
         if len(value.shape) != 2 or value.shape[1] != 3:
diff --git a/cleo/net.pkl b/cleo/net.pkl
deleted file mode 100644
index e69de29b..00000000
diff --git a/cleo/netstore.pkl b/cleo/netstore.pkl
deleted file mode 100644
index 848c1407..00000000
Binary files a/cleo/netstore.pkl and /dev/null differ
diff --git a/cleo/opto/__init__.py b/cleo/opto/__init__.py
index 7bb169f5..d4eae16f 100644
--- a/cleo/opto/__init__.py
+++ b/cleo/opto/__init__.py
@@ -7,6 +7,16 @@
     enphr3_3s,
     gtacr2_4s,
     vfchrimson_4s,
+    reachr_4s,
+    chrimsonr_4s,
+    cschrimson_4s,
+    breaches_4s,
+    chrmine_4s,
+    cheta_4s,
+    chronos_4s,
+    cheriff_4s,
+    nphr_3s,
+    jaws_3s,
 )
 from cleo.opto.opsins import (
     BansalFourStateOpsin,
diff --git a/cleo/opto/irradiance_data.py b/cleo/opto/irradiance_data.py
new file mode 100755
index 00000000..2fad7f87
--- /dev/null
+++ b/cleo/opto/irradiance_data.py
@@ -0,0 +1,586 @@
+"""Irradiance data for various opsins
+Source: https://doi.org/10.1088/1741-2552/ac1175
+2 photon: DOI:10.1088/1741-2552/ac1175"""
+
+from brian2.units import mW, mm2, nA
+
+import numpy as np
+
+
+# ChRmine
+def chrmine_irradiance():
+    """Irradiance data for ChRmine"""
+    irr_1p = np.array([0.01, 0.05, 0.22, 0.64, 1.42]) * mW / mm2  # Irradiance (1P)
+    I_1p = (
+        np.array(
+            [
+                0.2886803623803128,
+                2.4244584619798237,
+                4.114091789682305,
+                4.637010169751716,
+                4.663515508375585,
+            ]
+        )
+        * nA
+    )
+
+    power_2p = (
+        np.array(
+            [
+                1.758409161619387,
+                7.759939823443684,
+                18.27217199407987,
+                32.8363883380391,
+                50.840977407076835,
+            ]
+        )
+        * mW
+    )  # Total power (2P)
+
+    I_2p = (
+        np.array(
+            [
+                0.0677292632963725,
+                0.43824699419092045,
+                1.1215139595623866,
+                1.8266932442474064,
+                2.3784859137876424,
+            ]
+        )
+        * nA
+    )
+
+    # Convert power to irradiance for 2P
+    irr_2p = np.array(power_2p) / (np.pi * 0.01**2)  # Assuming 10 μm radius
+    irr_2p = irr_2p * mW / mm2  # Convert to mW/mm2
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p": I_1p,
+        "irr_2p": irr_2p,
+        "I_2p": I_2p,
+    }
+
+
+# Chr2
+def chr2_irradiance():
+    """Irradiance data for ChR2 (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.01752588842,
+                1.078120967,
+                1.61671549,
+                2.008185063,
+                2.358138874,
+                2.630057859,
+                2.846272932,
+                3.057799747,
+                3.182408719,
+                3.357971657,
+                3.940919571,
+                4.365700454,
+                4.675865757,
+                4.936495909,
+                5.177139276,
+                5.338884189,
+                5.516729569,
+                5.676192041,
+                6.679047516,
+                7.661422705,
+                8.237955108,
+                8.664895057,
+                8.979501868,
+                9.248953348,
+                9.492619408,
+                9.669724536,
+                9.825917565,
+                9.979889839,
+            ]
+        )
+        * mW
+        / mm2
+    )
+
+    I_1p = (
+        np.array(
+            [
+                1.83938394,
+                2.619124458,
+                3.007448349,
+                3.32136102,
+                3.546697741,
+                3.734241233,
+                3.851703334,
+                3.979124043,
+                4.095843888,
+                4.191285711,
+                4.529692848,
+                4.763936648,
+                4.937995812,
+                5.057746537,
+                5.15226054,
+                5.248382764,
+                5.309371512,
+                5.380937415,
+                5.700788139,
+                5.943011197,
+                6.017793545,
+                6.099503622,
+                6.096039758,
+                6.108225137,
+                6.143853452,
+                6.153379077,
+                6.170698397,
+                6.150781179,
+            ]
+        )
+        * nA
+    )  # original data was in pA, converted to nA
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p": I_1p,
+    }
+
+
+# ReaChR
+def reachr_irradiance():
+    """Irradiance data for ReaChR (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.04244768286,
+                1.006995153,
+                1.608017537,
+                2.041064559,
+                2.320941245,
+                2.639372688,
+                2.8001306,
+                3.018874865,
+                3.206158449,
+                3.378637006,
+                3.930309303,
+                4.3216555,
+                4.655817284,
+                4.918544815,
+                5.136610516,
+                5.334936182,
+                5.510375745,
+                5.67569854,
+                6.676456637,
+                7.65432863,
+                8.267750224,
+                8.674209886,
+                9.000167217,
+                9.273751768,
+                9.459863287,
+                9.675584859,
+                9.945591528,
+            ]
+        )
+        * mW
+        / mm2
+    )
+
+    I_1p = (
+        np.array(
+            [
+                1.993649595,
+                2.7515554,
+                3.206373108,
+                3.51020346,
+                3.750818296,
+                3.937310257,
+                4.119843517,
+                4.263222743,
+                4.380622989,
+                4.442601412,
+                4.863399028,
+                5.1241785,
+                5.318587864,
+                5.50291491,
+                5.600026811,
+                5.737653548,
+                5.822827489,
+                5.939609188,
+                6.40970501,
+                6.793575362,
+                6.935841203,
+                7.010623552,
+                7.093199594,
+                7.136312329,
+                7.13841539,
+                7.154497615,
+                7.158641881,
+            ]
+        )
+        * nA
+    )
+
+    power_2p = np.array([1.0, 2.0, 4.0, 6.0, 8.0]) * mW  # estimated mW at objective
+    I_2p = np.array([0.12, 0.38, 0.85, 1.28, 1.60]) * nA  # digitized peak currents
+
+    # Assuming 10 μm radius
+    spot_radius_mm = 0.01
+    spot_area_mm2 = np.pi * (spot_radius_mm**2)
+
+    irr_2p = power_2p / spot_area_mm2  # mW / mm²
+
+    return {"irr_1p": irr_1p, "I_1p": I_1p, "irr_2p": irr_2p, "I_2p": I_2p}
+
+
+# ChrimsonR
+def chrimsonr_irradiance():
+    """Irradiance data for ChrimsonR (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.01783432647,
+                1.60406953,
+                2.049083948,
+                2.331181389,
+                2.611613264,
+                2.845224243,
+                3.212388897,
+                3.916059465,
+                4.335720275,
+                4.677963136,
+                4.918236377,
+                5.18916836,
+                5.485330575,
+                6.680096206,
+                7.66851678,
+                8.192799778,
+                8.653791287,
+                9.000722406,
+                9.240008645,
+                9.477505943,
+                9.777554478,
+                9.984022909,
+            ]
+        )
+        * mW
+        / mm2
+    )
+
+    I_1p = (
+        np.array(
+            [
+                4.123183671,
+                4.712287962,
+                4.877007065,
+                4.99020119,
+                5.061024837,
+                5.192218684,
+                5.303124186,
+                5.521904307,
+                5.645490025,
+                5.725406315,
+                5.844167365,
+                5.911898276,
+                5.973876699,
+                6.233109803,
+                6.418797653,
+                6.56087793,
+                6.588526987,
+                6.62032031,
+                6.67963898,
+                6.67963898,
+                6.723741391,
+                6.732834033,
+            ]
+        )
+        * nA
+    )
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p": I_1p,
+    }
+
+
+# CSChrimson
+def cschrimson_irradiance():
+    """Irradiance data for ChrimsonCS (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.02313946093,
+                1.000888079,
+                1.592595634,
+                2.004792244,
+                2.36418426,
+                2.574415635,
+                2.826286147,
+                3.049410232,
+                3.23040168,
+                3.349828893,
+                3.941351385,
+                4.370758838,
+                4.640333694,
+                4.921875946,
+                5.161840748,
+                5.292865232,
+                5.4503537,
+                5.634429529,
+                6.629512365,
+                7.667899904,
+                8.293288894,
+                8.675011825,
+                8.968953287,
+                9.245745593,
+                9.489843465,
+                9.675708234,
+                9.812222915,
+                9.955461546,
+            ]
+        )
+        * mW
+        / mm2
+    )
+
+    I_1p = (
+        np.array(
+            [
+                3.828445961,
+                4.534022678,
+                4.918202304,
+                5.178919921,
+                5.383040476,
+                5.556914075,
+                5.681180195,
+                5.811075093,
+                5.878496731,
+                5.979196204,
+                6.263480467,
+                6.447312676,
+                6.527043402,
+                6.634979877,
+                6.717617774,
+                6.759617124,
+                6.791719721,
+                6.853574434,
+                7.10167369,
+                7.21072355,
+                7.240537522,
+                7.27214528,
+                7.302206671,
+                7.30035103,
+                7.304804569,
+                7.285505898,
+                7.297629422,
+                7.297629422,
+            ]
+        )
+        * nA
+    )
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p": I_1p,
+    }
+
+
+# bReaChEs
+def breaches_irradiance():
+    """Irradiance data for ChrimsonR-ET/BeaChR (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.00006829479144,
+                1.023465745,
+                1.581121739,
+                2.003558492,
+                2.323100312,
+                2.59569786,
+                2.831036093,
+                3.006290592,
+                3.202457192,
+                3.356737905,
+                3.905017382,
+                4.34102541,
+                4.639840193,
+                4.904048226,
+                5.132785884,
+                5.347397079,
+                5.505502424,
+                5.651146871,
+                6.647586835,
+                7.649146871,
+                8.234685665,
+                8.627574053,
+                8.975615548,
+                9.239700207,
+                9.480775387,
+                9.653562382,
+                9.813888481,
+                10.01449659,
+            ]
+        )
+        * mW
+        / mm2
+    )
+
+    I_1p = (
+        np.array(
+            [
+                5.597800041,
+                6.220120313,
+                6.60838235,
+                6.812008067,
+                6.985201264,
+                7.133776286,
+                7.237259222,
+                7.304371586,
+                7.395483579,
+                7.435689143,
+                7.707849882,
+                7.804899928,
+                7.91450648,
+                7.947042059,
+                7.991453744,
+                8.026649075,
+                8.069823666,
+                8.126111455,
+                8.196192845,
+                8.293861438,
+                8.2999232,
+                8.327386692,
+                8.296583045,
+                8.296583045,
+                8.304191175,
+                8.318727033,
+                8.289407898,
+                8.308953988,
+            ]
+        )
+        * nA
+    )
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p": I_1p,
+    }
+
+
+# need ChR2(H134R), Chronos, Cheriff, VfChrimson, Chrimson,
+def reachr_irradiance():
+    """Irradiance data for ReaChR (1P),
+    Data from Krause et al., Fig. B."""
+    irr_1p = (
+        np.array(
+            [
+                0.04244768286,
+                1.006995153,
+                1.608017537,
+                2.041064559,
+                2.320941245,
+                2.639372688,
+                2.8001306,
+                3.018874865,
+                3.206158449,
+                3.378637006,
+                3.930309303,
+                4.3216555,
+                4.655817284,
+                4.918544815,
+                5.136610516,
+                5.334936182,
+                5.510375745,
+                5.67569854,
+                6.676456637,
+                7.65432863,
+                8.267750224,
+                8.674209886,
+                9.000167217,
+                9.273751768,
+                9.459863287,
+                9.675584859,
+                9.945591528,
+            ]
+        )
+
+    )
+
+    I_1p = (
+        np.array(
+            [
+                1.993649595,
+                2.7515554,
+                3.206373108,
+                3.51020346,
+                3.750818296,
+                3.937310257,
+                4.119843517,
+                4.263222743,
+                4.380622989,
+                4.442601412,
+                4.863399028,
+                5.1241785,
+                5.318587864,
+                5.50291491,
+                5.600026811,
+                5.737653548,
+                5.822827489,
+                5.939609188,
+                6.40970501,
+                6.793575362,
+                6.935841203,
+                7.010623552,
+                7.093199594,
+                7.136312329,
+                7.13841539,
+                7.154497615,
+                7.158641881,
+            ]
+        )
+    )
+
+    power_2p = np.array([1.0, 2.0, 4.0, 6.0, 8.0])  # estimated mW
+    I_2p = np.array([0.12, 0.38, 0.85, 1.28, 1.60])
+
+    # Assuming 10 μm radius
+    spot_radius_mm = 0.01
+    spot_area_mm2 = np.pi * (spot_radius_mm**2)
+
+    irr_2p = power_2p / spot_area_mm2  # mW / mm²
+
+    return {"irr_1p": irr_1p, "I_1p": I_1p, "irr_2p": irr_2p, "I_2p": I_2p}
+
+
+
+def get_chrimsonR_irradiance_data(): #fix later asw
+    """
+    Returns ChrimsonR dose–response arrays for 1P and 2P excitation.
+
+    1P (590 nm) from Klapoetke et al. 2014, Fig.4C:
+      irr_1p [mW/mm²] → I_1p [nA]
+    2P (920 nm) approximated by scaling ChR2 values (Rickgauer & Tank 2009)
+      by σ2(ChrimsonR)/σ2(ChR2) ≈ 0.23.
+    """
+    # — One-photon (590 nm) —
+    irr_1p = np.array([0.10, 0.50, 1.00, 2.30, 4.60])       # mW/mm²
+    I_1p   = np.array([0.18, 1.20, 2.50, 4.00, 5.50])       # nA  [oai_citation:0‡PMC]https://pmc.ncbi.nlm.nih.gov/articles/PMC3943671/
+
+    # — Two-photon (920 nm) — same laser powers as for ChR2:
+    power_2p = np.array([5.0, 10.0, 20.0, 40.0, 80.0])      # mW total
+    # ChR2 I_2p (nA) from Rickgauer & Tank 2009
+    chr2_I2p  = np.array([0.0105, 0.0234, 0.0414, 0.0969, 0.1979])
+    # scale by σ₂(ChrimsonR)/σ₂(ChR2) ≈ 0.23 (Shemesh et al. 2017)
+    I_2p      = chr2_I2p * 0.23                           # nA
+
+    # convert 2P power → irradiance over 10 μm radius
+    irr_2p = power_2p / (np.pi * 0.01**2)     # mW/mm²
+
+    return {
+        "irr_1p": irr_1p,
+        "I_1p":   I_1p,
+        "irr_2p": irr_2p,
+        "I_2p":   I_2p,
+    }
\ No newline at end of file
diff --git a/cleo/opto/opsin_library.py b/cleo/opto/opsin_library.py
old mode 100644
new mode 100755
index 474efa4c..edee610c
--- a/cleo/opto/opsin_library.py
+++ b/cleo/opto/opsin_library.py
@@ -18,8 +18,8 @@
     FourStateOpsin,
 )
 
-
-ONE_P_TWO_P_RATIO = 270382.2996938772
+# This number is the average of the 1P/2P ratios calculated for ChRmine, ChroME, ChroME2f, and ChroME2s
+ONE_P_TWO_P_RATIO = 250394.05605233982
 
 
 def chr2_4s() -> FourStateOpsin:
@@ -28,7 +28,7 @@ def chr2_4s() -> FourStateOpsin:
     Params taken from try.projectpyrho.org's default 4-state configuration.
     Action spectrum from `Nagel et al., 2003, Fig. 4a
     <https://www.pnas.org/doi/full/10.1073/pnas.1936192100>`_,
-    extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
 
     Parameters can be changed after initialization but *before injection*.
     """
@@ -52,6 +52,7 @@ def chr2_4s() -> FourStateOpsin:
         v1=17.1 * mV,
         name="ChR2",
         spectrum=[
+            # Replaced ONE_P_TWO_P_RATIO with calculated value for ChR2 from notebook
             (400, 0.34),
             (422, 0.65),
             (460, 0.96),
@@ -74,13 +75,279 @@ def chr2_4s() -> FourStateOpsin:
     )
 
 
+def reachr_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state ReaChR model.
+
+    Params given in `Bansal et al., 2021, Table 1
+    <https://doi.org/10.1088/1741-2552/ac1175>`_,
+    Action spectrum from `Krause et al., 2017, Fig. 1b
+    <https://doi.org/10.1016/j.bpj.2017.02.001>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+
+    return BansalFourStateOpsin(
+        Gd1=7.7e-3 / ms,
+        Gd2=1.25e-3 / ms,
+        Gr0=3.33e-5 / ms,
+        g0=14.28 * nsiemens,
+        phim=5e17 / mm2 / second,
+        k1=1.2 / ms,
+        k2=0.01 / ms,
+        Gf0=0.0005 / ms,
+        Gb0=0.0005 / ms,
+        kf=0.012 / ms,
+        kb=0.001 / ms,
+        gamma=0.05,
+        p=1,
+        q=1,
+        E=7 * mV,
+        name="ReaChR",
+        spectrum=[
+            (390, 0.30),
+            (401, 0.27),
+            (411, 0.30),
+            (421, 0.33),
+            (431, 0.37),
+            (441, 0.41),
+            (451, 0.46),
+            (461, 0.53),
+            (472, 0.58),
+            (479, 0.67),
+            (490, 0.76),
+            (500, 0.86),
+            (511, 0.94),
+            (520, 0.97),
+            (531, 1),
+            (540, 0.98),
+            (549, 0.95),
+            (559, 0.86),
+            (571, 0.71),
+            (580, 0.52),
+            (590, 0.36),
+        ],
+    )
+
+
+def chrimsonr_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state ChrimsonR model.
+
+    Params given in `Bansal et al., 2021, Table 1
+    <https://doi.org/10.1088/1741-2552/ac1175>`_,
+    Action spectrum from `Cheong, Soon Keen et al., 2018, Fig. 2
+    <https://doi.org/10.1371/journal.pone.0194947>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalFourStateOpsin(
+        Gd1=0.067 / ms,
+        Gd2=0.01 / ms,
+        Gr0=0.5e-3 / ms,
+        g0=12.25 * nsiemens,
+        phim=20e17 / mm2 / second,
+        k1=6 / ms,
+        k2=0.2 / ms,
+        Gf0=0.02 / ms,
+        Gb0=0.05 / ms,
+        kf=0.1 / ms,
+        kb=0.001 / ms,
+        gamma=0.05,
+        p=0.6,
+        q=1,
+        E=0 * mV,
+        name="ChrimsonR",
+        spectrum=[
+            (386, 0.13),
+            (398, 0.15),
+            (406, 0.15),
+            (423, 0.16),
+            (439, 0.17),
+            (446, 0.18),
+            (453, 0.20),
+            (460, 0.23),
+            (467, 0.25),
+            (479, 0.31),
+            (496, 0.40),
+            (507, 0.46),
+            (518, 0.53),
+            (522, 0.56),
+            (528, 0.60),
+            (532, 0.63),
+            (535, 0.67),
+            (538, 0.71),
+            (546, 0.79),
+            (556, 0.85),
+            (569, 0.91),
+            (580, 0.95),
+            (590, 1),
+            (599, 0.94),
+            (605, 0.90),
+            (610, 0.87),
+            (619, 0.80),
+            (624, 0.76),
+            (629, 0.69),
+            (632, 0.64),
+            (634, 0.60),
+            (637, 0.56),
+            (639, 0.52),
+            (643, 0.47),
+            (647, 0.40),
+            (652, 0.32),
+            (660, 0.24),
+            (668, 0.16),
+            (678, 0.09),
+            (686, 0.06),
+        ],
+    )
+
+
+def cschrimson_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state CsChrimson model.
+
+    Params given in `Bansal et al., 2021, Table 1
+    <https://doi.org/10.1088/1741-2552/ac1175>`_,
+    Action spectrum from `Kim, Seungsoo, et al., 2015, Fig. 6.3a
+    <https://doi.org/10.1007/978-3-319-12913-6_6>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalFourStateOpsin(
+        Gd1=0.033 / ms,
+        Gd2=0.017 / ms,
+        Gr0=5e-6 / ms,
+        g0=18.48 * nsiemens,
+        phim=6e16 / mm2 / second,
+        k1=3 / ms,
+        k2=0.04 / ms,
+        Gf0=0.005 / ms,
+        Gb0=0.01 / ms,
+        kf=0.01 / ms,
+        kb=0.6 / ms,
+        gamma=0.05,
+        p=1,
+        q=1,
+        E=-10 * mV,
+        name="CsChrimson",
+        spectrum=[
+            (402, 0.16),
+            (419, 0.18),
+            (435, 0.20),
+            (449, 0.23),
+            (466, 0.30),
+            (482, 0.36),
+            (497, 0.46),
+            (514, 0.54),
+            (529, 0.63),
+            (545, 0.75),
+            (561, 0.85),
+            (576, 0.94),
+            (590, 1),
+            (591, 1.01),
+            (607, 0.94),
+            (622, 0.77),
+            (638, 0.51),
+            (652, 0.30),
+            (670, 0.13),
+            (684, 0.04),
+        ],
+    )
+
+
+def breaches_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state bReaChES model.
+
+    Params given in `Bansal et al., 2021, Table 1
+    <https://doi.org/10.1088/1741-2552/ac1175>`_,
+    Action spectrum from `Bansal, H., Pyari, G. & Roy, S., 2024, Fig. 1c
+    <https://doi.org/10.1038/s41598-024-62558-2>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalFourStateOpsin(
+        Gd1=0.025 / ms,
+        Gd2=0.01 / ms,
+        Gr0=3.3e-5 / ms,
+        g0=36.5 * nsiemens,
+        phim=6e15 / mm2 / second,
+        k1=0.4 / ms,
+        k2=0.01 / ms,
+        Gf0=0.002 / ms,
+        Gb0=0.002 / ms,
+        kf=0.01 / ms,
+        kb=0.04 / ms,
+        gamma=0.05,
+        p=1,
+        q=1,
+        E=10 * mV,
+        name="bReaChES",
+        spectrum=[
+            (390, 0.47),
+            (410, 0.66),
+            (430, 0.80),
+            (450, 0.89),
+            (470, 0.95),
+            (490, 0.96),
+            (510, 0.95),
+            (530, 0.94),
+            (550, 0.95),
+            (570, 1),
+            (590, 0.84),
+            (611, 0.34),
+            (631, 0.09),
+            (651, 0.02),
+        ],
+    )
+
+
+def chrmine_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state ChRmine model.
+
+    Params given in `Bansal et al., 2021, Table 1
+    <https://doi.org/10.1088/1741-2552/ac1175>`_,
+    Action spectrum from `Bansal, H., Pyari, G. & Roy, S., 2024, Fig. 1c
+    <https://doi.org/10.1038/s41598-024-62558-2>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalFourStateOpsin(
+        Gd1=0.02 / ms,
+        Gd2=0.013 / ms,
+        Gr0=5.9e-4 / ms,
+        g0=110 * nsiemens,
+        phim=2.1e15 / mm2 / second,
+        k1=0.2 / ms,
+        k2=0.01 / ms,
+        Gf0=0.0027 / ms,
+        Gb0=0.0005 / ms,
+        kf=0.001 / ms,
+        kb=0 / ms,
+        gamma=0.05,
+        p=0.8,
+        q=1,
+        E=5.64 * mV,
+        name="ChRmine",
+        spectrum=[
+            (390, 0.37),
+            (410, 0.55),
+            (430, 0.72),
+            (450, 0.85),
+            (470, 0.93),
+            (491, 0.99),
+            (510, 1),
+            (531, 0.98),
+            (551, 0.94),
+            (570, 0.86),
+            (591, 0.70),
+            (610, 0.48),
+            (630, 0.26),
+            (650, 0.10),
+        ],
+    )
+
+
 def chr2_b4s() -> BansalFourStateOpsin:
     """Returns a 4-state ChR2 model.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
     Action spectrum from `Nagel et al., 2003, Fig. 4a
     <https://www.pnas.org/doi/full/10.1073/pnas.1936192100>`_,
-    extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
 
     Parameters can be changed after initialization but *before injection*.
     """
@@ -102,6 +369,7 @@ def chr2_b4s() -> BansalFourStateOpsin:
         E=0 * mV,
         name="ChR2",
         spectrum=[
+            # Replaced ONE_P_TWO_P_RATIO with calculated value for ChR2 from notebook
             (400, 0.34),
             (422, 0.65),
             (460, 0.96),
@@ -127,7 +395,8 @@ def chr2_b4s() -> BansalFourStateOpsin:
 def chr2_h134r_4s() -> BansalFourStateOpsin:
     """Returns a 4-state ChR2(H134R) model.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
     Action spectrum is same as for :func:`~chr2_4s`, but blue-shifted 20 nm
     (I cannot find it directly in the literature).
 
@@ -173,10 +442,155 @@ def chr2_h134r_4s() -> BansalFourStateOpsin:
     )
 
 
+def cheta_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state ChETA model.
+
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
+    Action spectrum from `Gunaydin, L., Yizhar, O., Berndt, A. et al., 2010, Fig. 2b
+    <https://doi.org/10.1038/nn.2495>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+
+    return BansalFourStateOpsin(
+        Gd1=0.21 / ms,
+        Gd2=0.02 / ms,
+        Gr0=2e-4 / ms,
+        g0=21.5 * nsiemens,
+        phim=1e16 / mm2 / second,
+        k1=3 / ms,
+        k2=1 / ms,
+        Gf0=0.02 / ms,
+        Gb0=0.015 / ms,
+        kf=0.01 / ms,
+        kb=0.01 / ms,
+        gamma=0.05,
+        p=1,
+        q=1,
+        E=0 * mV,
+        name="ChETA",
+        spectrum=[
+            (445, 0.36),
+            (452, 0.47),
+            (460, 0.61),
+            (468, 0.77),
+            (478, 0.89),
+            (490, 1),
+            (500, 1),
+            (514, 0.89),
+            (530, 0.70),
+            (550, 0.42),
+            (576, 0.12),
+        ],
+    )
+
+
+def chronos_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state Chronos model.
+
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
+    Action spectrum from `Soor, Navjeevan S., et al., 2019, Fig. 1b
+    <https://doi.org/10.1088/1361-6463/aaf944>`_,
+    Extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+
+    return BansalFourStateOpsin(
+        Gd1=0.278 / ms,
+        Gd2=0.01 / ms,
+        Gr0=1.2e-3 / ms,
+        g0=39 * nsiemens,
+        phim=0.8e16 / mm2 / second,
+        k1=1.8 / ms,
+        k2=0.01 / ms,
+        Gf0=0.05 / ms,
+        Gb0=0.08 / ms,
+        kf=0.1 / ms,
+        kb=0.01 / ms,
+        gamma=0.05,
+        p=0.8,
+        q=0.9,
+        E=0 * mV,
+        name="Chronos",
+        spectrum=[
+            (388, 0.18),
+            (404, 0.21),
+            (419, 0.30),
+            (431, 0.41),
+            (439, 0.50),
+            (447, 0.57),
+            (457, 0.67),
+            (465, 0.74),
+            (472, 0.80),
+            (480, 0.86),
+            (490, 0.92),
+            (498, 1),
+            (507, 0.90),
+            (516, 0.84),
+            (528, 0.68),
+            (521, 0.76),
+            (533, 0.59),
+            (538, 0.49),
+            (544, 0.40),
+            (548, 0.32),
+            (554, 0.23),
+            (560, 0.14),
+            (576, 0.05),
+            (570, 0.08),
+            (591, 0.01),
+        ],
+    )
+
+
+def cheriff_4s() -> BansalFourStateOpsin:
+    """Returns a 4-state CheRiff model.
+
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
+    Action spectrum from `Hochbaum, Daniel R et al., 2014, Fig. 2a
+    <https://doi.org/10.1038/nmeth.3000>`_,
+    extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+
+    return BansalFourStateOpsin(
+        Gd1=0.063 / ms,
+        Gd2=2.5e-3 / ms,
+        Gr0=5e-4 / ms,
+        g0=40 * nsiemens,
+        phim=0.7e16 / mm2 / second,
+        k1=1.4 / ms,
+        k2=0.001 / ms,
+        Gf0=0.01 / ms,
+        Gb0=0.02 / ms,
+        kf=0.02 / ms,
+        kb=0.1 / ms,
+        gamma=0.05,
+        p=0.9,
+        q=1,
+        E=0 * mV,
+        name="CheRiff",
+        spectrum=[
+            (386, 0.30),
+            (403, 0.47),
+            (419, 0.67),
+            (435, 0.84),
+            (450, 0.97),
+            (466, 1),
+            (483, 0.95),
+            (498, 0.63),
+            (515, 0.29),
+            (529, 0.09),
+            (546, 0.02),
+            (560, 0.00),
+        ],
+    )
+
+
 def vfchrimson_4s() -> BansalFourStateOpsin:
     """Returns a 4-state vf-Chrimson model.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
     Action spectrum from `Mager et al., 2018, Supp. Fig. 1a
     <https://static-content.springer.com/esm/art%3A10.1038%2Fs41467-018-04146-3/MediaObjects/41467_2018_4146_MOESM1_ESM.docx>`_,
     extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
@@ -228,7 +642,8 @@ def vfchrimson_4s() -> BansalFourStateOpsin:
 def chrimson_4s() -> BansalFourStateOpsin:
     """Returns a 4-state Chrimson model.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
     Action spectrum from `Mager et al., 2018, Supp. Fig. 1a
     <https://static-content.springer.com/esm/art%3A10.1038%2Fs41467-018-04146-3/MediaObjects/41467_2018_4146_MOESM1_ESM.docx>`_,
     extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
@@ -280,7 +695,8 @@ def chrimson_4s() -> BansalFourStateOpsin:
 def gtacr2_4s() -> BansalFourStateOpsin:
     """Returns a 4-state model of GtACR2, an anion channel.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1016/j.neuroscience.2020.09.022>`_,
     Action spectra from `Govorunova et al., 2015, Fig. 1f
     <https://www.science.org/doi/10.1126/science.aaa7484#F1>`_,
     extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
@@ -346,7 +762,8 @@ def gtacr2_4s() -> BansalFourStateOpsin:
 def enphr3_3s():
     """Returns a 3-state model of eNpHR3, a chloride pump.
 
-    Params given in Bansal et al., 2020.
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1088/2057-1976/ab90a1>`_,
     Action spectrum from `Gradinaru et al., 2010 <https://doi.org/10.1016/j.cell.2010.02.037>`_,
     Figure 3F,
     extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
@@ -390,6 +807,96 @@ def enphr3_3s():
     )
 
 
+def nphr_3s():
+    """Returns a 3-state model of NpHR, a chloride pump.
+
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1088/2057-1976/ab90a1>`_,
+    Action spectrum from `Bamberg et al., 1984, Fig. 3,
+    <https://pubs.acs.org/doi/pdf/10.1021/bi00320a050>`_,
+    extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalThreeStatePump(
+        Gd=0.1099 / ms,
+        Gr=0.05 / ms,
+        ka=0.005 / ms,
+        p=0.5,
+        q=0.2,
+        phim=1.5e18 / mm2 / second,
+        E=-400 * mV,
+        g0=17.7 * nsiemens,
+        a=0.02e-2 * mM / pcoulomb,
+        b=5,
+        name="NpHR",
+        spectrum=[
+            (410, 0.194),
+            (420, 0.176),
+            (440, 0.199),
+            (470, 0.259),
+            (480, 0.346),
+            (490, 0.429),
+            (505, 0.502),
+            (510, 0.574),
+            (520, 0.667),
+            (530, 0.799),
+            (550, 0.844),
+            (565, 0.903),
+            (590, 0.947),
+            (578, 1.0),
+            (610, 0.853),
+            (620, 0.619),
+            (640, 0.457),
+            (650, 0.299),
+        ],
+    )
+
+
+def jaws_3s():
+    """Returns a 3-state model of Jaws, a chloride pump.
+
+    Params given in `Bansal et al., 2020, Table 1
+    <https://doi.org/10.1088/2057-1976/ab90a1>`_,
+    Action spectrum from `Chuong, Amy S et al., 2014, Fig. 1d
+    <https://doi.org/10.1038/nn.3752>`_,
+    extracted using `Plot Digitizer <https://plotdigitizer.com/>`_.
+    """
+    return BansalThreeStatePump(
+        Gd=0.167 / ms,
+        Gr=0.05 / ms,
+        ka=1 / ms,
+        p=0.8,
+        q=1,
+        phim=0.95e18 / mm2 / second,
+        E=-400 * mV,
+        g0=12.6 * nsiemens,
+        a=0.02e-2 * mM / pcoulomb,
+        b=6.5,
+        name="Jaws",
+        spectrum=[
+            (402, 0.29),
+            (419, 0.29),
+            (434, 0.32),
+            (450, 0.35),
+            (466, 0.43),
+            (482, 0.49),
+            (497, 0.55),
+            (514, 0.59),
+            (529, 0.69),
+            (545, 0.80),
+            (560, 0.91),
+            (577, 0.98),
+            (592, 1),
+            (600, 1),
+            (608, 0.94),
+            (624, 0.81),
+            (639, 0.54),
+            (654, 0.26),
+            (671, 0.09),
+            (685, 0.02),
+        ],
+    )
+
+
 if __name__ == "__main__":
     import matplotlib.pyplot as plt
 
diff --git a/cleo/registry.py b/cleo/registry.py
index b6c76388..c5468202 100644
--- a/cleo/registry.py
+++ b/cleo/registry.py
@@ -1,18 +1,24 @@
-"""Code for orchestrating inter-device interactions. 
+"""Code for orchestrating inter-device interactions.
 
 This should only be relevant for developers, not users, as this code is used
 under the hood when interacting devices are injected (e.g., light and opsin)."""
+
 from __future__ import annotations
 
 from typing import Tuple
 
 from attrs import define, field
-from brian2 import NeuronGroup, Subgroup, Synapses
+from brian2 import NeuronGroup, Subgroup, Synapses, defaultclock, ms
 from brian2.units.allunits import joule, kgram, meter, meter2, second
+from brian2 import Quantity
+from numpy import pi
+import numpy as np
 
 from cleo.coords import coords_from_ng
 from cleo.utilities import brian_safe_name
 
+import warnings
+
 
 @define(repr=False)
 class DeviceInteractionRegistry:
@@ -46,12 +52,17 @@ class DeviceInteractionRegistry:
     """Set of (light, light-dependent device, neuron group) tuples representing
     previously created connections."""
 
+    raster_img_width: int = field(default=500 * 1e-6 * meter, kw_only=True)
+
+    raster_enable: int = field(default=0, kw_only=True)
+
     light_prop_model = """
         T : 1
         epsilon : 1
         Ephoton : joule
-        Irr_post = epsilon * T * Irr0_pre : watt/meter**2 (summed)
-        phi_post = Irr_post / Ephoton : 1/second/meter**2 (summed)
+        scan_factor = (1 - is_pulsed_pre) + is_pulsed_pre * int(((t + pulse_stagger_pre * stagger_offset_pre) % scan_period_pre) < pulse_width_pre) : 1
+        Irr_post = epsilon * T * Irr0_pre * scan_factor * scale_pre : watt/meter**2 (summed)
+        phi_post = epsilon * T * Irr0_pre * scan_factor * scale_pre / Ephoton : 1/second/meter**2 (summed)
     """
     """Model used in light propagation synapses"""
 
@@ -74,6 +85,24 @@ def register(self, device: "InterfaceDevice", ng: NeuronGroup) -> None:
         elif "LightDependent" in ancestor_classes:
             self.register_ldd(device, ng)
 
+    # Translate user-set variables to Brian2 simulation variables
+    def _apply_to_img_light(self, light: "Light", **values):
+        src = self.source_for_light(light)
+        for k, v in values.items():
+            setattr(src, k, v)
+
+    # Make it easier to set light to scan
+    def set_is_pulsed(self, light: "Light", enable: bool = True):
+        self._apply_to_img_light(light, is_pulsed=int(bool(enable)))
+
+    # Change pulse frequency after initial setup
+    def set_pulse_freq(self, light: "Light", hz: float):
+        self._apply_to_img_light(light, scan_period=(1 / hz) * second)
+
+    # Change pulse width after initial setup
+    def set_pulse_width(self, light: "Light", width: Quantity):
+        self._apply_to_img_light(light, pulse_width=width)
+
     def connect_light_to_ldd_for_ng(
         self, light: "Light", ldd: "LightDependent", ng: NeuronGroup
     ) -> None:
@@ -97,13 +126,12 @@ def connect_light_to_ldd_for_ng(
         if epsilon == 0:
             return
 
-        light_prop_syn = self._get_or_create_light_prop_syn(ldd, ng)
         if (light, ldd, ng) in self.connections:
             raise ValueError(f"{light} already connected to {ldd.name} for {ng.name}")
-
+        light_prop_syn = self._get_or_create_light_prop_syn(ldd, ng)
         i_source = self.subgroup_idx_for_light[light]
-        light_prop_syn.epsilon[i_source, :] = epsilon
         light_prop_syn.T[i_source, :] = light.transmittance(coords_from_ng(ng)).ravel()
+        light_prop_syn.epsilon[i_source, :] = epsilon
         # fmt: off
         # Ephoton = h*c/lambda
         light_prop_syn.Ephoton[i_source, :] = (
@@ -112,7 +140,26 @@ def connect_light_to_ldd_for_ng(
             / light.wavelength
         )
         # fmt: on
-        self.connections.add((light, ldd, ng))
+        src = self.source_for_light(light)
+
+        # set scanning parameters from light object
+        src.scan_period = (1 / light.pulse_freq) * second
+        src.is_pulsed = int(bool(light.is_pulsed))
+        src.scale = 1
+
+        # add pulse_width and stagger
+        src.pulse_width = light.pulse_width
+        src.pulse_stagger = int(bool(light.pulse_stagger))
+
+        # calculate stagger offset per neuron so not all neurons activate simultaneously
+        N = src.N
+        scan_period_val = src.scan_period[0]
+        src.stagger_offset = np.arange(N) / N * scan_period_val
+
+        src.pulse_width = light.pulse_width
+        self.connections.add(
+            (light, ldd, ng)
+        )  # list of what is connected for rebuild later
 
     def _add_brian_object(self, obj):
         self.brian_objects.add(obj)
@@ -154,20 +201,40 @@ def register_ldd(self, ldd: "LightDependent", ng: NeuronGroup):
     def init_register_light(self, light: "Light") -> Subgroup:
         """Creates neurons for the light source, if they don't already exist"""
         if self.light_source_ng is not None:
-            Irr0_prev = self.light_source_ng.Irr0
+            Irr0_prev = self.light_source_ng.Irr0[:]
             n_prev = self.light_source_ng.N
+            scan_period_prev = self.light_source_ng.scan_period[:]
+            pulse_width_prev = self.light_source_ng.pulse_width[:]
+            is_pulsed_prev = self.light_source_ng.is_pulsed[:]
+            scale_prev = self.light_source_ng.scale[:]
+            stagger_offset_prev = self.light_source_ng.stagger_offset[:]
+            pulse_stagger_prev = self.light_source_ng.pulse_stagger[:]
             # need to remove the old light source from the network
             self._remove_brian_object(self.light_source_ng)
         else:
             Irr0_prev = []
             n_prev = 0
 
-        # create new one
+        # create new light
         self.light_source_ng = NeuronGroup(
-            n_prev + light.n, "Irr0: watt/meter**2", name="light_source"
+            n_prev + light.n,
+            """Irr0: watt/meter**2
+            scan_period : second
+            pulse_width : second
+            is_pulsed : 1
+            scale : 1
+            stagger_offset : second
+            pulse_stagger : 1""",
+            name="light_source",
         )
         if n_prev > 0:
             self.light_source_ng[:n_prev].Irr0 = Irr0_prev
+            self.light_source_ng[:n_prev].scan_period = scan_period_prev
+            self.light_source_ng[:n_prev].pulse_width = pulse_width_prev
+            self.light_source_ng[:n_prev].is_pulsed = is_pulsed_prev
+            self.light_source_ng[:n_prev].scale = scale_prev
+            self.light_source_ng[:n_prev].stagger_offset = stagger_offset_prev
+            self.light_source_ng[:n_prev].pulse_stagger = pulse_stagger_prev
         self._add_brian_object(self.light_source_ng)
         self.subgroup_idx_for_light[light] = slice(n_prev, n_prev + light.n)
 
@@ -177,8 +244,8 @@ def init_register_light(self, light: "Light") -> Subgroup:
         prev_cxns = self.connections.copy()
         self.connections.clear()
         self.light_prop_syns.clear()
-        for light, ldd, ng in prev_cxns:
-            self.connect_light_to_ldd_for_ng(light, ldd, ng)
+        for prev_light, prev_ldd, prev_ng in prev_cxns:
+            self.connect_light_to_ldd_for_ng(prev_light, prev_ldd, prev_ng)
         assert prev_cxns == self.connections
 
     def register_light(self, light: "Light", ng: NeuronGroup):
@@ -195,3 +262,31 @@ def source_for_light(self, light: "Light") -> Subgroup:
         """Returns the subgroup representing the given light source"""
         i = self.subgroup_idx_for_light[light]
         return self.light_source_ng[i]
+
+    def set_img_width(self, light: "Light", img_width, soma_radius):
+        src = self.source_for_light(light)
+        spot_radius = light.soma_radius
+        spot_area = pi * spot_radius**2
+        img_width_area = pi * (img_width / 2) ** 2
+        src.pulse_width = light.pulse_width
+        if img_width != self.raster_img_width:
+            warnings.warn(
+                "Multiple img_width values detected; CLEO currently assumes a single imaging width. Using latest value.",
+                UserWarning,
+            )
+            self.raster_img_width = img_width
+
+    def set_pulse_stagger(self, light: "Light", stagger: bool):
+        self._apply_to_img_light(light, pulse_stagger=int(bool(stagger)))
+
+
+registries: dict["CLSimulator", DeviceInteractionRegistry] = {}
+"""Maps simulator to its registry"""
+
+
+def registry_for_sim(sim: "CLSimulator") -> DeviceInteractionRegistry:
+    """Returns the registry for the given simulator"""
+    assert sim is not None
+    if sim not in registries:
+        registries[sim] = DeviceInteractionRegistry(sim)
+    return registries[sim]
diff --git a/cleo/test_store.py b/cleo/test_store.py
deleted file mode 100644
index 2d0c5585..00000000
--- a/cleo/test_store.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# %%
-import pickle
-import brian2.only as b2
-import numpy as np
-
-# %%
-ng = b2.NeuronGroup(10, "dv/dt = -v / (10*ms) : 1", threshold="v>1", name="neurons")
-ng.v = np.random.rand(10)
-syn = b2.Synapses(ng, ng, "w : 1", on_pre="v_post += w", name="synapses")
-syn.connect("i != j")
-syn.w = "rand()"
-st_mon = b2.StateMonitor(ng, "v", record=True, name="st_mon")
-spk_mon = b2.SpikeMonitor(ng, name="spk_mon")
-net = b2.Network(ng, syn, st_mon, spk_mon)
-net.store(filename="netstore.pkl")
-
-# %%
-ng = b2.NeuronGroup(10, "dv/dt = -v / (10*ms) : 1", threshold="v>1", name="neurons")
-ng.v = np.random.rand(10)
-syn = b2.Synapses(ng, ng, "w : 1", on_pre="v_post += w", name="synapses")
-syn.connect("i != j")
-# syn.w = "rand()"
-st_mon = b2.StateMonitor(ng, "v", record=True, name="st_mon")
-spk_mon = b2.SpikeMonitor(ng, name="spk_mon")
-net2 = b2.Network(ng, syn, st_mon, spk_mon)
-net2.restore(filename="netstore.pkl")
-# %%
-# net.__dir__
-import dill
-
-b2.prefs.codegen.target = "numpy"
-ng = b2.NeuronGroup(
-    10,
-    "dv/dt = -v / (10*ms) : volt \n du/dt = -u / ms : 1",
-    name="neurons",
-)
-ng.v = 1 * b2.mvolt
-st_mon = b2.StateMonitor(ng, ["v", "u"], record=True, name="st_mon")
-net = b2.Network(ng, st_mon)
-net.run(2 * b2.ms)
-# st_mon.get_states()
-# net.store(filename="netstore.pkl")
-
-with open("net.pkl", "wb") as f:
-    dill.dump(net, f)
-
-# %%
-import pickle
-
-with open("netstore.pkl", "rb") as f:
-    store = pickle.load(f)
-store
-
-# %%
-np.zeros_like(ng.v)
diff --git a/docs/tutorials/optogenetics.ipynb b/docs/tutorials/optogenetics.ipynb
index 0d4ad10a..6e8c1066 100644
--- a/docs/tutorials/optogenetics.ipynb
+++ b/docs/tutorials/optogenetics.ipynb
@@ -750,9 +750,13 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "python3",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.1"
   }
  },
  "nbformat": 4,
diff --git a/netstore.pkl b/netstore.pkl
deleted file mode 100644
index c1abc590..00000000
Binary files a/netstore.pkl and /dev/null differ
diff --git a/notebooks/1p_2p_ratio.ipynb b/notebooks/1p_2p_ratio.ipynb
old mode 100644
new mode 100755
index d252b7ed..829e0cdf
--- a/notebooks/1p_2p_ratio.ipynb
+++ b/notebooks/1p_2p_ratio.ipynb
@@ -9,7 +9,7 @@
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "\n",
-    "# ChRmine\n",
+    "# ChRmine https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3 \n",
     "irr_1p = np.array([0.01, 0.05, 0.22, 0.64, 1.42])  # mW/mm2\n",
     "I_1p = np.array(\n",
     "    [  # nA\n",
@@ -39,27 +39,220 @@
     "    ]\n",
     ")\n",
     "# divide by area of spot with 10 μm radius:\n",
-    "irr_2p = np.array(power_2p) / (np.pi * 0.01**2)"
+    "irr_2p = np.array(power_2p) / (np.pi * 0.01**2)\n",
+    "\n",
+    "#reachr\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chr2_irradiance_data():\n",
+    "\n",
+    "    #https://www.pnas.org/doi/10.1073/pnas.0907084106\n",
+    "\n",
+    "    irr_1p = np.array([0.33, 0.77, 1.26, 1.72])  # mW/mm2\n",
+    "    I_1p = np.array([\n",
+    "        0.4124079804,\n",
+    "        0.5099647925,\n",
+    "        0.5557303336,\n",
+    "        0.5797880214,\n",
+    "    ])  # nA\n",
+    "\n",
+    "\n",
+    "    power_2p = np.array([0.37, 0.54, 1.00, 1.53])  # mW/mm2\n",
+    "    I_2p = np.array([\n",
+    "        0.01438881888,\n",
+    "        0.04539752549,\n",
+    "        0.08182781533,\n",
+    "        0.1117224195,\n",
+    "    ])  # nA\n",
+    "\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * 0.01**2)  # mW/mm², assuming 10 µm radius\n",
+    "    irr_2p_35r = power_2p / (np.pi * 0.035**2)  # mW/mm², assuming 35 µm radius\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p,\n",
+    "        \"irr_2p_35r\": irr_2p_35r\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.009524139115,\n",
+    "        0.3450867178,\n",
+    "        0.7179277543,\n",
+    "        1.055845441,\n",
+    "        1.424556973\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.1682428241,\n",
+    "        0.6738337696,\n",
+    "        1.233987502,\n",
+    "        1.610873216,\n",
+    "        1.771141945\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        1.881570223,\n",
+    "        7.899540317,\n",
+    "        17.85275251,\n",
+    "        31.84104066,\n",
+    "        49.06685143\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.06614448185,\n",
+    "        0.1085880753,\n",
+    "        0.3343108222,\n",
+    "        0.6277696856,\n",
+    "        0.9260323922\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm r \n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }\n",
+    "      "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome2f():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.007604564695,\n",
+    "        0.3442317813,\n",
+    "        0.7163953209,\n",
+    "        1.053683903,\n",
+    "        1.425710331\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.2990966727,\n",
+    "        1.139206222,\n",
+    "        2.083417815,\n",
+    "        2.625293165,\n",
+    "        2.730696485\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        2.132272412,\n",
+    "        7.947967189,\n",
+    "        17.89223904,\n",
+    "        31.72742376,\n",
+    "        49.03965788\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.06874897508,\n",
+    "        0.2226648789,\n",
+    "        0.6037697628,\n",
+    "        0.9830032701,\n",
+    "        1.413053334\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm radius spot\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome2s():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.01033068299,\n",
+    "        0.345586775,\n",
+    "        0.7163469283,\n",
+    "        1.054329139,\n",
+    "        1.423782691\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.5189214544,\n",
+    "        1.716216012,\n",
+    "        2.733843756,\n",
+    "        3.06809,\n",
+    "        3.035437062\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        2.098001088,\n",
+    "        9.469688503,\n",
+    "        19.49889363,\n",
+    "        33.14558608,\n",
+    "        49.99403977\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.07833736869,\n",
+    "        0.323101855,\n",
+    "        0.7228433349,\n",
+    "        1.197034736,\n",
+    "        1.612615394\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm r\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f29aa5eacf0>"
+       "<matplotlib.legend.Legend at 0x11fa38310>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -82,22 +275,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f29a7fdfc20>"
+       "<matplotlib.legend.Legend at 0x11fdc1d50>"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -122,125 +315,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.28868036 0.33132946 0.37397855 0.41662764 0.45927673 0.50192583\n",
-      " 0.54457492 0.58722401 0.62987311 0.6725222  0.71517129 0.75782038\n",
-      " 0.80046948 0.84311857 0.88576766 0.92841676 0.97106585 1.01371494\n",
-      " 1.05636403 1.09901313 1.14166222 1.18431131 1.22696041 1.2696095\n",
-      " 1.31225859 1.35490768 1.39755678 1.44020587 1.48285496 1.52550406\n",
-      " 1.56815315 1.61080224 1.65345133 1.69610043 1.73874952 1.78139861\n",
-      " 1.82404771 1.8666968  1.90934589 1.95199498 1.99464408 2.03729317\n",
-      " 2.07994226 2.12259136 2.16524045 2.20788954 2.25053864 2.29318773\n",
-      " 2.33583682 2.37848591]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f75eb3d7500>]"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "I_overlap = np.linspace(max(I_1p[0], I_2p[0]), min(I_1p[-1], I_2p[-1]))\n",
-    "print(I_overlap)\n",
-    "irr_1p_overlap = np.interp(I_overlap, I_1p, irr_1p)\n",
-    "irr_2p_overlap = np.interp(I_overlap, I_2p, irr_2p)\n",
-    "plt.plot(I_overlap, irr_2p_overlap / irr_1p_overlap)\n",
-    "# ax.loglog((irr_1p), (I_1p), c=\"xkcd:carmine\", label=\"1P\")\n",
-    "# ax.plot((irr_2p), (I_2p), c=\"k\", label=\"2P\")\n",
-    "# ax.set(\n",
-    "#     xlabel=\"Irradiance (mW/mm2)\",\n",
-    "#     ylabel=\"Photocurrent (nA)\",\n",
-    "#     title=\"ChRmine power sensitivity\",\n",
-    "# )\n",
-    "# ax.legend()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fef0d3c2ea0>]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot((irr_1p), (I_1p), c=\"xkcd:carmine\", label=\"1P\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fef0d031490>]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot((irr_2p), (I_2p), c=\"k\", label=\"2P\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -260,7 +335,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_650116/3112391639.py:48: RuntimeWarning: invalid value encountered in sqrt\n",
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/4038616756.py:48: RuntimeWarning: invalid value encountered in sqrt\n",
       "  I_hat_1p = f_I_inv(m1p * irr_1p_transformed)\n"
      ]
     },
@@ -445,13 +520,13 @@
        "15    square    square -0.554560  0.966136  0.205788"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -557,43 +632,928 @@
     ")\n",
     "ax.legend()\n",
     "\n",
+    "\n",
     "df"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Okay, but we do actually need a pure linear function if we want just a constant.\n",
-    "Let's compute that ratio to use as a placeholder for now:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/1538624837.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===============\n",
+      "    RESULTS    \n",
+      "===============\n",
+      "best_f_irr: sqrt\n",
+      "best_f_I: identity\n",
+      "best mean r2: 0.7039\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/1538624837.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/1538624837.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/1538624837.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_11326/1538624837.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n"
+     ]
+    },
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "270382.2996938772"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 20,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "m1p, _ = opt(irr_1p, I_1p)\n",
-    "m2p, _ = opt(irr_2p, I_2p)\n",
-    "m1p / m2p"
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHLCAYAAAA0kLlRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC4cElEQVR4nOzdd1hT1xsH8G8YCTuAgkxBBATEiRPqQEFcqHW1bkRpVcRRR7VqFf25UKvWOupCHLhR61YUFPfEvVBRiwxFhoDMnN8fmJSYBBKGAXw/z5PnIeeee+97LxknZ3IYYwyEEEIIIdWEirIDIIQQQggpT1S4IYQQQki1QoUbQgghhFQrVLghhBBCSLVChRtCCCGEVCtUuCGEEEJItUKFG0IIIYRUK1S4IYQQQki1QoUbQgghhFQrVLj5BnA4HIwdO1bZYZCvYNu2bXBwcIC6ujr09fWVHU6VFRkZCQ6Hg3379ik7lGqJw+Fgzpw5So1B+D+OjIwst2NaW1vDx8en3I5HSo8KN1XY8+fP8fPPP8PGxgYaGhrQ09ODm5sbVq5ciU+fPiklpvbt24PD4cDOzk7q9tOnT4PD4Uh8cWzZskWULu1x5coVAEBycjKWLFmCtm3bwsjICPr6+mjVqhV2794t9Xz37t1D3759YWVlBQ0NDZibm8PT0xOrVq2SeQ3CDz15HpXJ48eP4ePjg7p162LDhg1Yv369skOqlCIjI9G7d2+YmJiAy+XC2NgY3t7eCAsLU1pMwtfTyJEjpW6fMWOGKM/79+9F6T4+PjJfmxoaGqJ8jx8/xtSpU9G4cWPo6urC1NQU3bp1w40bN6Se7/Dhw2jXrh2MjY2hpaUFGxsb9O/fHydOnCjxWop7//z4449S97l06RLmzJmD1NRUiW0LFizAwYMHSzxvRSrN5whRLjVlB0BK5+jRo+jXrx94PB6GDh0KZ2dn5Obm4sKFC5gyZQoePHigtC83DQ0NxMTE4Nq1a2jRooXYth07dkBDQwPZ2dlS9507dy7q1KkjkW5rawsAuHz5MmbMmIGuXbti5syZUFNTw/79+/Hjjz/i4cOHCAwMFO1z6dIluLu7o3bt2vDz84OJiQnevHmDK1euYOXKlQgICJAag6OjI7Zt2yaWNn36dOjo6GDGjBkK3YuvKTIyEgKBACtXrhTdLyJu9uzZmDt3Luzs7PDzzz/DysoKycnJOHbsGPr06YMdO3Zg4MCBSolNQ0MD+/fvx5o1a8DlcsW27dy5U+b7hsfjYePGjRLpqqqqor83btyITZs2oU+fPhgzZgzS0tLw999/o1WrVjhx4gQ8PDxEeZcuXYopU6agXbt2mD59OrS0tBATE4Pw8HDs2rULnTt3lut6xo0bh+bNm4ulWVtbAwA+ffoENbX/vn4uXbqEwMBA+Pj4SNQ4LliwAH379kWvXr3kOm95K+3nCFEyRqqcFy9eMB0dHebg4MDevn0rsf3Zs2dsxYoVoucAmL+/f6nOlZGRoVD+du3asfr167N69eqxCRMmiG379OkT09PTY3369GEA2N69e0XbgoODGQB2/fr1Yo//4sULFhsbK5YmEAhYhw4dGI/HE4u3a9euzMjIiKWkpEgcJzExUaHrql+/PmvXrl2xeQoKCtinT58UOm55CgwMZADYu3fvyu2YmZmZ5Xas8vDy5UsGgEVERCi87969exkA1rdvX5abmyux/cSJE+zw4cOMMcYiIiIkXqOKUPS+AWC9evViKioq7ODBg2LbLl68yACI3jdF/7/Dhg1j2traJR7/xo0b7OPHj2Jp79+/Z0ZGRszNzU2UlpeXx/T09Jinp6fU48jzvinNvVuyZAkDwF6+fCmxTVtbmw0bNkzuY8lLGGdJryVFPkesrKwqJFaiOGqWqoKCgoKQkZGBTZs2wdTUVGK7ra0txo8fL5F+8OBBODs7g8fjoX79+hJVzHPmzAGHw8HDhw8xcOBAGBgY4LvvvgMA5OfnY968eahbty54PB6sra3x22+/IScnR2qMAwYMwO7duyEQCERphw8fRlZWFvr371/qa69Tpw6srKzE0jgcDnr16oWcnBy8ePFClP78+XPUr19fat8TY2PjUsdQ9Lxjx47Fjh07UL9+ffB4PNE9Xbp0KVxdXVGjRg1oamrCxcVFav8N4TFK+t98/PgREyZMgLW1NXg8HoyNjeHp6Ylbt24BKPxFPHv2bACAkZGRRJ+GNWvWiGI0MzODv7+/RBNA+/bt4ezsjJs3b6Jt27bQ0tLCb7/9htjYWHA4HCxduhSrV6+GjY0NtLS00KlTJ7x58waMMcybNw8WFhbQ1NREz5498eHDB7Fj37hxA15eXqhZsyY0NTVRp04d+Pr6lvVfoJBZs2bB0NAQmzdvhrq6usR2Ly8vdO/eXSxNIBBg/vz5sLCwgIaGBjp27IiYmBixPLLuGwAkJSVhxIgRqFWrFjQ0NNCoUSOEhIRIjc/c3Bxt27ZFaGioWPqOHTvQoEEDODs7l/raXVxcoKOjI5ZWo0YNtGnTBo8ePRKlvX//Hunp6XBzc5N6nPJ43wDifW7mzJmDKVOmACh8fwubsISvu8zMTISEhIjSi/ZpiYuLg6+vL2rVqiV672zevFnifP/++y969eoFbW1tGBsbY+LEiTI/u75U1s+RFy9eoF+/fjA0NISWlhZatWqFo0ePiuURNuXt3r0bv/32G0xMTKCtrY0ePXrgzZs3Ese8evUqOnfuDD6fDy0tLbRr1w4XL14Uy1PSZ0Z1R81SVdDhw4dhY2MDV1dXufe5cOECwsLCMGbMGOjq6uLPP/9Enz598Pr1a9SoUUMsb79+/WBnZ4cFCxaAMQYAGDlyJEJCQtC3b19MmjQJV69excKFC/Ho0SMcOHBA4nwDBw7EnDlzEBkZiQ4dOgAAQkND0bFjx2I/ENLS0sT6FACFH4RfxvilhIQEAEDNmjVFaVZWVrh8+TLu379fpi+G4pw9exZ79uzB2LFjUbNmTVG1+8qVK9GjRw8MGjQIubm52LVrF/r164cjR46gW7duYseQ538zatQo7Nu3D2PHjoWTkxOSk5Nx4cIFPHr0CE2bNsWKFSuwdetWHDhwAGvXroWOjg4aNmwIoPDLIzAwEB4eHhg9ejSePHmCtWvX4vr167h48aLYF31ycjK6dOmCH3/8EYMHD0atWrVE23bs2IHc3FwEBATgw4cPCAoKQv/+/dGhQwdERkbi119/RUxMDFatWoXJkyeLvmSSkpLQqVMnGBkZYdq0adDX10dsbOxX7ePy7NkzPH78GL6+vtDV1ZV7v0WLFkFFRQWTJ09GWloagoKCMGjQIFy9elUsn7T79unTJ7Rv3x4xMTEYO3Ys6tSpg71798LHxwepqalSf4AMHDgQ48ePR0ZGBnR0dJCfn4+9e/fil19+kdmUC0DiPQMAXC4Xenp6xV5fQkKC2HvG2NgYmpqaOHz4MAICAmBoaFjSLZLp48ePEnEZGhpCRUX8N3Xv3r3x9OlT7Ny5E8uXLxfFY2RkhG3btmHkyJFo0aIFfvrpJwBA3bp1AQCJiYlo1aqV6AeCkZERjh8/jhEjRiA9PR0TJkwAUNgE1rFjR7x+/Rrjxo2DmZkZtm3bhrNnz8p1HWX5HElMTISrqyuysrIwbtw41KhRAyEhIejRowf27duH77//Xiz//PnzweFw8OuvvyIpKQkrVqyAh4cHoqOjoampCaDwM6dLly5wcXHB7NmzoaKiguDgYHTo0AFRUVGirgAlfWZUe8quOiKKSUtLYwBYz5495d4HAONyuSwmJkaUdufOHQaArVq1SpQ2e/ZsBoANGDBAbP/o6GgGgI0cOVIsffLkyQwAO3v2rChN2CzFGGPNmjVjI0aMYIwxlpKSwrhcLgsJCZFabS1slpL24PF4xV5fcnIyMzY2Zm3atBFLP3XqFFNVVWWqqqqsdevWbOrUqezkyZNSmyRKIq1ZCgBTUVFhDx48kMiflZUl9jw3N5c5OzuzDh06SBxDnv8Nn88vsWlR+P8r2myRlJTEuFwu69SpEysoKBCl//XXXwwA27x5syitXbt2DABbt26d2HGFTUFGRkYsNTVVlD59+nQGgDVq1Ijl5eWJ0gcMGMC4XC7Lzs5mjDF24MABuZoc5VHaZqlDhw4xAGz58uVy5Re+Rh0dHVlOTo4ofeXKlQwAu3fvnihN1n1bsWIFA8C2b98uSsvNzWWtW7dmOjo6LD09XZSOz03HHz58YFwul23bto0xxtjRo0cZh8NhsbGxUv+/w4YNk/m+8fLyKvYaz58/zzgcDps1a5ZY+u+//84AMG1tbdalSxc2f/58dvPmTbnuW9F7J+0hbHYCwGbPni3apzTNUiNGjGCmpqbs/fv3Yuk//vgj4/P5oveg8P+wZ88eUZ7MzExma2sr12tJkc+RL5ulJkyYwACwqKgoUdrHjx9ZnTp1mLW1teg9Kbxn5ubmYq+LPXv2MABs5cqVjLHCJng7Ozvm5eXFBAKBKF9WVharU6eOWHOiPJ8Z1Rk1S1Ux6enpAKDQr08A8PDwEP3iAYCGDRtCT09PrBlHaNSoUWLPjx07BgD45ZdfxNInTZoEABJVrEIDBw5EWFgYcnNzsW/fPqiqqkr8UvnS6tWrcfr0abHH8ePHZeYXCAQYNGgQUlNTJUYueHp64vLly+jRowfu3LmDoKAgeHl5wdzcHP/880+xccirXbt2cHJykkgX/soCgJSUFKSlpaFNmzZSq4Tl+d/o6+vj6tWrePv2rULxhYeHIzc3FxMmTBD7xezn5wc9PT2J/x2Px8Pw4cOlHqtfv37g8/mi5y1btgQADB48WKxzaMuWLZGbm4u4uDhR7ABw5MgR5OXlKRR/RkYG3r9/L3qkpKQA+K+GT/hIS0sr9jilfd8MHz5crHNvmzZtAEDifSPtvh07dgwmJiYYMGCAKE1dXR3jxo1DRkYGzp07J3E+AwMDdO7cGTt37gRQWNvp6uoq0RRblIaGhsR75vTp01i0aJHMfZKSkjBw4EDUqVMHU6dOFdsWGBiI0NBQNGnSBCdPnsSMGTPg4uKCpk2bijVhleT333+XiMnExETu/YvDGMP+/fvh7e0NxpjYa8HLywtpaWmi99qxY8dgamqKvn37ivbX0tIS1QSVpCyfI8eOHUOLFi1EzfsAoKOjg59++gmxsbF4+PChWP6hQ4eKvUb79u0LU1NT0WdwdHQ0nj17hoEDByI5OVl0zZmZmejYsSPOnz8v6gpQ2s+M6oKapaoYYTXzx48fFdqvdu3aEmkGBgaiL4uivhyt9OrVK6ioqEiMwDExMYG+vj5evXol9Zw//vgjJk+ejOPHj2PHjh3o3r17iV8uLVq0QLNmzUq6HJGAgACcOHECW7duRaNGjSS2N2/eXFTAunPnDg4cOIDly5ejb9++iI6OllowUYS0kV1A4Rf5//73P0RHR4u17UsbPi7P/yYoKAjDhg2DpaUlXFxc0LVrVwwdOhQ2NjbFxif839SrV08sncvlwsbGRuJ/Z25uLjFSR1acwoKOpaWl1HRh/O3atUOfPn0QGBiI5cuXo3379ujVqxcGDhwIHo9XbPxjx46V2kfly5Ez7dq1K3a+kvJ63xgYGACAxPtG2n179eoV7OzsJJphHB0dRdulGThwIIYMGYLXr1/j4MGDCAoKKjZGVVVVsdFOJcnMzET37t3x8eNHXLhwQaIvDlDYZ27AgAFIT0/H1atXsWXLFoSGhsLb2xv379+HhoaGqClYiM/nixXqGzRooFBcinj37h1SU1Oxfv16maNCk5KSABTeZ1tbW4n33pfvieKU9nPk1atXoh8BRRV9DRRt6vpyCg0OhwNbW1vExsYCKGxeBYBhw4bJjDUtLQ0GBgal/syoLqhwU8Xo6enBzMwM9+/fV2i/osNCi2Kf+9QUVfQDqihF53UxNTVF+/btsWzZMly8eBH79+9XaP+SBAYGYs2aNVi0aBGGDBlSbF4ul4vmzZujefPmsLe3x/Dhw7F3715RJ9zSknavoqKi0KNHD7Rt2xZr1qyBqakp1NXVERwcLNFZFJDvf9O/f3+0adMGBw4cwKlTp7BkyRIsXrwYYWFh6NKlS5muoaTrKSnOkuIXzml05coVHD58GCdPnoSvry+WLVuGK1euSP1yFZo6dSoGDx4sep6YmIjBgwdj6dKlYoVZYaFDFgcHBwCF85UoQt73TXH3TVE9evQAj8fDsGHDkJOTU6YO+F/Kzc1F7969cffuXZw8ebLEPiR6enrw9PSEp6cn1NXVERISgqtXr6Jdu3YSgxmCg4O/2gR2wtqJwYMHy/yiF/Y5K08V9TkiL+F1L1myBI0bN5aaR/h++lqfGZUVFW6qoO7du2P9+vW4fPkyWrduXeHns7KygkAgwLNnz0S/OIDCL5rU1NRiq8wHDhyIkSNHQl9fH127di23mFavXo05c+ZgwoQJ+PXXXxXaV1gzFB8fX27xFLV//35oaGjg5MmTYjUTwcHBZTquqakpxowZgzFjxiApKQlNmzbF/Pnzi/2gEv5vnjx5IvaLLTc3Fy9fvqywX9bStGrVCq1atcL8+fMRGhqKQYMGYdeuXTInrgMAJycnsV/Fwl+wLi4uaN++vdzntre3R7169XDo0CGsXLmy2AJVebGyssLdu3chEAjEam8eP34s2i6NpqYmevXqhe3bt6NLly5iHX7LQiAQYOjQoThz5gz27NmDdu3aKbR/s2bNEBISInrfnD59Wmx7/fr1Sx1bcT+cpG0zMjKCrq4uCgoKSnwNW1lZ4f79+2CMiR3ryZMnpY4XkO9zxMrKSup5ZL0GhDUzQowxxMTEiApqwuZrPT09ud67pfnMqC6oz00VNHXqVGhra2PkyJFITEyU2P78+XOsXLmy3M4nLJSsWLFCLP2PP/4AAInRP0X17dsXs2fPljoxWWnt3r0b48aNw6BBg0QxSBMRESG1ZkrYfq1ItbQiVFVVweFwUFBQIEqLjY0t9SyrBQUFEn1KjI2NYWZmVuJwVg8PD3C5XPz5559i92LTpk1IS0sr9n9XXlJSUiT+D8JfnfIOxy0PgYGBSE5OxsiRI5Gfny+x/dSpUzhy5Ei5na9r165ISEgQmz07Pz8fq1atgo6OTrGFi8mTJ2P27NmYNWtWucUTEBCA3bt3Y82aNejdu7fUPFlZWbh8+bLUbcK+b8L3jYeHh9hD2rQU8tLW1gYAqTMUa2trS6SrqqqiT58+2L9/v9Ra7Hfv3on+7tq1K96+fSs2FUNWVpbck5yW5XOka9euuHbtmtg9zczMxPr162FtbS3RnLV161axptN9+/YhPj5eVBhxcXFB3bp1sXTpUmRkZEicT3jdZfnMqC6o5qYKqlu3LkJDQ/HDDz/A0dFRbIbiS5cuiYablpdGjRph2LBhWL9+PVJTU9GuXTtcu3YNISEh6NWrF9zd3WXuy+fzFVpD5vjx46JfNUW5urrCxsYG165dw9ChQ1GjRg107NgRO3bskJoPKPwwz8rKwvfffw8HBwfR/dm9ezesra1ldpwtq27duuGPP/5A586dMXDgQCQlJWH16tWwtbXF3bt3FT7ex48fYWFhgb59+6JRo0bQ0dFBeHg4rl+/jmXLlhW7r5GREaZPn47AwEB07twZPXr0wJMnT7BmzRo0b95crMmnooSEhGDNmjX4/vvvUbduXXz8+BEbNmyAnp5eudbmleSHH37AvXv3MH/+fNy+fRsDBgwQzVB84sQJnDlzRmqzYWn99NNP+Pvvv+Hj44ObN2/C2toa+/btw8WLF7FixYpi+581atRIah8yafLz87F9+3ap277//ntoa2tjxYoVWLNmDVq3bg0tLS2J/MJ8WVlZcHV1RatWrdC5c2dYWloiNTUVBw8eRFRUFHr16oUmTZrIfxPk5OLiAqBwmYkff/wR6urq8Pb2hra2NlxcXBAeHo4//vgDZmZmqFOnDlq2bIlFixYhIiICLVu2hJ+fH5ycnPDhwwfcunUL4eHhormW/Pz88Ndff2Ho0KG4efMmTE1NsW3bNmhpackVW1k+R6ZNm4adO3eiS5cuGDduHAwNDRESEoKXL19i//79Ev2xDA0N8d1332H48OFITEzEihUrYGtrCz8/PwCAiooKNm7ciC5duqB+/foYPnw4zM3NERcXh4iICOjp6eHw4cNl+syoNpQzSIuUh6dPnzI/Pz9mbW3NuFwu09XVZW5ubmzVqlWiYbiMyZ6h+Mthi9KGmgrl5eWxwMBAVqdOHaaurs4sLS3Z9OnTxc7DmPhQcFkUHQoOgAUHByuUjzHGjh8/znx9fZmDgwPT0dFhXC6X2drasoCAgHKZoVjWfWWMsU2bNjE7OzvG4/GYg4MDCw4OFt1feY5R9H+Tk5PDpkyZwho1asR0dXWZtrY2a9SoEVuzZo3YPsX9//766y/m4ODA1NXVWa1atdjo0aMlZlyV9b8TDr9esmSJWLqsmWi/nG361q1bbMCAAax27dqMx+MxY2Nj1r17d3bjxg2p9644ZZmhWOjMmTOsZ8+ezNjYmKmpqTEjIyPm7e3NDh06VOK1Cc9f9HVW3Gs+MTGRDR8+nNWsWZNxuVzWoEEDsX2FinstCSk6FBxFhlbLmy8vL49t2LCB9erVi1lZWTEej8e0tLRYkyZN2JIlS8SGxcsizwzF+GIoOGOMzZs3j5mbmzMVFRWxmB4/fszatm3LNDU1GQCxz6zExETm7+/PLC0tmbq6OjMxMWEdO3Zk69evFzv2q1evWI8ePZiWlharWbMmGz9+PDtx4oRcryVFPkekzVD8/Plz1rdvX6avr880NDRYixYt2JEjR6Tes507d7Lp06czY2Njpqmpybp168ZevXolEdPt27dZ7969WY0aNRiPx2NWVlasf//+7MyZM4wx+T8zqjMOY1Lq2wghhBDyVURGRsLd3R179+4VG7JOSo/63BBCCCGkWqHCDSGEEEKqFSrcEEIIIaRaoT43hBBCCKlWqOaGEEIIIdUKFW4IIYQQUq18c5P4CQQCvH37Frq6ugqvlUQIIYQQ5WCM4ePHjzAzM5OYAPFL31zh5u3btxKrGBNCCCGkanjz5g0sLCyKzfPNFW6EU56/efMGenp6So6GEEIIIfJIT0+HpaVlsUuXCH1zhRthU5Senh4VbgghhJAqRp4uJdShmBBCCCHVilILN2vXrkXDhg1FtSitW7fG8ePHZebfsmULOByO2ENDQ+MrRkwIIYSQyk6pzVIWFhZYtGgR7OzswBhDSEgIevbsidu3b6N+/fpS99HT08OTJ09Ez2nEE6nMCgoKkJeXp+wwCCGkSuByuSWOhJKHUgs33t7eYs/nz5+PtWvX4sqVKzILNxwOByYmJnKfIycnBzk5OaLn6enppQuWEAUwxpCQkIDU1FRlh0IIIVWGiooK6tSpAy6XW6bjVJoOxQUFBdi7dy8yMzPRunVrmfkyMjJgZWUFgUCApk2bYsGCBTILQgCwcOFCBAYGVkTIhMgkLNgYGxtDS0uLahgJIaQEwnno4uPjUbt27TJ9bip9bal79+6hdevWyM7Oho6ODkJDQ9G1a1epeS9fvoxnz56hYcOGSEtLw9KlS3H+/Hk8ePBA5ph3aTU3lpaWSEtLo9FSpEIUFBTg6dOnMDY2Ro0aNZQdDiGEVBlpaWl4+/YtbG1toa6uLrYtPT0dfD5fru9vpdfc1KtXD9HR0UhLS8O+ffswbNgwnDt3Dk5OThJ5W7duLVar4+rqCkdHR/z999+YN2+e1OPzeDzweLwKi5+QLwn72GhpaSk5EkIIqVqEzVEFBQUShRtFKL1ww+VyYWtrCwBwcXHB9evXsXLlSvz9998l7quuro4mTZogJiamosMkRGHUFEUIIYopr8/NSjfPjUAgEGtGKk5BQQHu3bsHU1PTCo6KEEIIIVWFUmtupk+fji5duqB27dr4+PEjQkNDERkZiZMnTwIAhg4dCnNzcyxcuBAAMHfuXLRq1Qq2trZITU3FkiVL8OrVK4wcOVKZl0EIIYSQSkSphZukpCQMHToU8fHx4PP5aNiwIU6ePAlPT08AwOvXr8XGu6ekpMDPzw8JCQkwMDCAi4sLLl26JLV/DiFVnaCgAIlRV5AVnwgt01qo1aYVVFRVlR0WOBwODhw4gF69eik7lG8C3W9CFKfUZqlNmzYhNjYWOTk5SEpKQnh4uKhgAwCRkZHYsmWL6Pny5cvx6tUr5OTkICEhAUePHkWTJk2UEDkhFSs27Cj22LjgeMfeODd4NI537I09Ni6IDTtaoedNSEhAQEAAbGxswOPxYGlpCW9vb5w5c6ZCzwsAsbGx4HA4UFVVRVxcnNi2+Ph4qKmpgcPhIDY2Viy/tMeVK1cAAGFhYfD09ISRkZFoFnRhzbDQu3fvMHr0aNSuXRs8Hg8mJibw8vLCxYsXZcb64MED9OnTB9bW1uBwOFixYoVEHh8fH1E8wr6Fc+fORX5+ftluVAnmzJmDxo0bV+g5CKnsKl2fG0K+dbFhR3G2/whk/Rsvlp4Vl4Cz/UdUWAEnNjYWLi4uOHv2LJYsWYJ79+7hxIkTcHd3h7+/f6mPyxhT6Avd3NwcW7duFUsLCQmBubm51Pzh4eGIj48Xe7i4uAAAzp8/D09PTxw7dgw3b96Eu7s7vL29cfv2bdH+ffr0we3btxESEoKnT5/in3/+Qfv27ZGcnCwzxqysLNjY2GDRokXFTirauXNnxMfH49mzZ5g0aRLmzJmDJUuWyH0vCCGlxL4xaWlpDABLS0tTdiikmvr06RN7+PAh+/TpEyvIy2MfHj5hKQ+fsJyPH1luRkaxj+y0NLbToiHbpGIs/aFai+20bMSy09JKPFZuRgYTCARyx92lSxdmbm7OMjIyJLalpKSI/gbANmzYwHr16sU0NTWZra0tO3TokGh7REQEA8COHTvGmjZtytTV1VlERATLzs5mAQEBzMjIiPF4PObm5sauXbsm2u/ly5cMAJs5cyazs7MTO7+9vT2bNWsWA8Bevnwplv/27dtyXyNjjDk5ObHAwEDRdQFgkZGRCh2jKCsrK7Z8+XKJ9GHDhrGePXuKpXl6erJWrVrJPNbTp09ZmzZtGI/HY46OjuzUqVMMADtw4IAoz9SpU5mdnR3T1NRkderUYTNnzmS5ubmMMcaCg4MZALFHcHAwY4yxZcuWMWdnZ6alpcUsLCzY6NGj2cePH0t93YRUhKKfn19S5Ptb6UPBCanOCrJzkPP+A46171k+B2QMWXHx2GFgJ1f2IekvoK6tXWK+Dx8+4MSJE5g/fz60peTX19cXex4YGIigoCAsWbIEq1atwqBBg/Dq1SsYGhqK8kybNg1Lly6FjY0NDAwMMHXqVOzfvx8hISGwsrJCUFAQvLy8EBMTI7Zfjx49sG7dOly4cAHfffcdLly4gJSUFHh7e8ucz0peAoEAHz9+FJ1PR0cHOjo6OHjwIFq1alXhc2JpamrKrBESCATo3bs3atWqhatXryItLQ0TJkyQyKerq4stW7bAzMwM9+7dg5+fH3R1dTF16lT88MMPuH//Pk6cOIHw8HAAAJ/PB1A4rf2ff/6JOnXq4MWLFxgzZgymTp2KNWvWVNj1EqIs1CxFSAXK//RJ2SHIJSYmBowxODg4yJXfx8cHAwYMgK2tLRYsWICMjAxcu3ZNLM/cuXPh6emJunXrgsfjYe3atViyZAm6dOkCJycnbNiwAZqamti0aZPYfurq6hg8eDA2b94MANi8eTMGDx4sc0IvV1dXUSFF+JBl6dKlyMjIQP/+/QEAampq2LJlC0JCQqCvrw83Nzf89ttvuHv3rlz3QV6MMYSHh+PkyZPo0KGD1Dzh4eF4/Pgxtm7dikaNGqFt27ZYsGCBRL6ZM2fC1dUV1tbW8Pb2xuTJk7Fnzx4AhYUnHR0dqKmpwcTEBCYmJtDU1AQATJgwAe7u7rC2tkaHDh3wv//9T7QfIdUN1dwQUoEKPmVDVYOHPo8uQcu85AVfE6Ku4HS3gSXm8zwaCpM2rUrMpybnLMlMwVVYGjZsKPpbW1sbenp6SEpKEsvTrFkz0d/Pnz9HXl4e3NzcRGnq6upo0aIFHj16JHF8X19fuLq6YsGCBdi7dy8uX74ss9/O7t274ejoWGLMoaGhCAwMxKFDh2BsbCxK79OnD7p164aoqChcuXIFx48fR1BQEDZu3AgfH58Sj1ucI0eOQEdHB3l5eRAIBBg4cCDmzJkjNe+jR49gaWkJMzMzUZq0dfZ2796NP//8E8+fP0dGRgby8/PlWkomPDwcCxcuxOPHj5Geno78/HxkZ2cjKyuLZtMm1Q7V3BBSgQo+ZYPD4YBnaAB1be0SH+ae7aFlYQrImqWTw4G2pRnMPdvLdTx5Z/u0s7MDh8PB48eP5cr/ZS0Kh8OBQCAQS5PWvCWvBg0awMHBAQMGDICjoyOcnZ1l5rW0tIStra3Y40u7du3CyJEjsWfPHnh4eEhs19DQgKenJ2bNmoVLly7Bx8cHs2fPLnX8Qu7u7oiOjsazZ8/w6dMnhISElOm+XL58GYMGDULXrl1x5MgR3L59GzNmzEBubm6x+8XGxqJ79+5o2LAh9u/fj5s3b2L16tUAUOK+hFRFVLghpALlZ2cDAFQ1NeTKr6KqilbL5xc++bJg8vl5yz/+V+7z3RgaGsLLywurV69GZmamxPbU1NQyHb9u3brgcrliw6vz8vJw/fp1mfNU+fr6IjIyEr6+vmU6986dOzF8+HDs3LkT3bp1k2sfJycnqfdBUdra2rC1tUXt2rWhplZ8RbmjoyPevHmD+Pj/RskJh7QLXbp0CVZWVpgxYwaaNWsGOzs7vHr1SiwPl8tFQUGBWNrNmzchEAiwbNkytGrVCvb29nj79m0Zr46QyosKN4RUEMYYdCwtoGlmAjUN+TuqWvfuhg57Nkk0Y2lbmKLDnk2w7i3fF7SiVq9ejYKCArRo0QL79+/Hs2fP8OjRI/z5559Sm0cUoa2tjdGjR2PKlCk4ceIEHj58CD8/P2RlZWHEiBFS9/Hz88O7d+9KnIE8OTkZCQkJYo/sz4XK0NBQDB06FMuWLUPLli1F29PS0kT7dujQAdu3b8fdu3fx8uVL7N27F0FBQejZU3Yn8NzcXERHRyM6Ohq5ubmIi4tDdHR0mda58/DwgL29PYYNG4Y7d+4gKioKM2bMEMtjZ2eH169fY9euXXj+/Dn+/PNPHDhwQCyPtbU1Xr58iejoaLx//x45OTmwtbVFXl4eVq1ahRcvXmDbtm1Yt25dqWMlpNIr72FclR0NBScVrbihjIooyM9nbyMusJjQ/extxAVWkJ9fThHK9vbtW+bv78+srKwYl8tl5ubmrEePHiwiIkKUB18MTWaMMT6fLxpyLBwKXnT4OGOF9yUgIIDVrFmz2KHgsoZ23759W+pQcGmPnTt3MsYYa9eundTtw4YNY4wxlp2dzaZNm8aaNm3K+Hw+09LSYvXq1WMzZ85kWVlZMu+TrHO3a9dOlEfaUPCSPHnyhH333XeMy+Uye3t7duLECYn7PWXKFFajRg2mo6PDfvjhB7Z8+XLG5/NF27Ozs1mfPn2Yvr6+2FDwP/74g5mamjJNTU3m5eXFtm7dKvX/RIgylddQcA5jCvYkrOLS09PB5/ORlpYmVyc8QhSVnZ2Nly9fok6dOtDQkK85ihBCSPGfn4p8f1OzFCEVJDcjE7lp6RBU8HT7hBBCxFHhhpAKkp30DunPXiA37aOyQyGEkG8KFW4IqSAF2YVDbNXkHClFCCGkfFDhhpAKIMgvAAQFAIcDVQVGShFCCCk7KtwQUgEEeXkAAFUeDxwVepsRQsjXRJ+6hFQAUeGGmqQIIeSro8INIRVAWLih/jaEEPL1UeGGkAogyKWaG0IIURZaFZyQCsCrYQgtY2Oo6ZR+kURCCCGlQzU3hFQAVa46eAb6UP1i9ezqgMPh4ODBg8oOg5SRov9HHx8f9OrVq8R8Q4YMwYIFC0TPs7Ky0KdPH+jp6YHD4SA1NRXW1tZYsWKF4kGXQWRkpOj8lYG897M6mTZtGgICAr7KuahwQwgRSUhIQEBAAGxsbMDj8WBpaQlvb2+cOXOmws8dGxsLDocDVVVVxMXFiW2Lj4+HmpoaOBwOYmNjxfJLewhX0w4LC4OnpyeMjIygp6eH1q1b4+TJk2LHfvfuHUaPHo3atWuDx+PBxMQEXl5eYiuYf+nBgwfo06cPrK2tweFwpH5R+/j4iOLhcrmwtbXF3LlzkV+NZ6y+c+cOjh07hnHjxonSQkJCEBUVhUuXLiE+Ph58Ph/Xr1/HTz/9JMrzNQrMrq6uovNXNMYY1q9fj5YtW0JHRwf6+vpo1qwZVqxYgaysrAo/f/v27cHhcLBo0SKJbd26dQOHw8GcOXMk8n/5GDVqFIDC99qIESNQp04daGpqom7dupg9ezZyc3PFjr1hwwY0atRIdM1NmjTBwoULRdsnT56MkJAQvHjxomIuvAgq3BBSzhKiriDv40fkf16ZuqqIjY2Fi4sLzp49iyVLluDevXs4ceIE3N3d4e/vX+rjMsYU+kI3NzfH1q1bxdJCQkJgbm4uNX94eDji4+PFHi4uLgCA8+fPw9PTE8eOHcPNmzfh7u4Ob29v3L59W7R/nz59cPv2bYSEhODp06f4559/0L59eyQnJ8uMMSsrCzY2Nli0aBFMTExk5uvcuTPi4+Px7NkzTJo0CXPmzMGSJUvkvhdVzapVq9CvXz/o6OiI0p4/fw5HR0c4OzvDxMQEHA4HRkZG0NLS+qqxcblc0fkr2pAhQzBhwgT07NkTERERiI6OxqxZs3Do0CGcOnWq1Mf9sjBRHEtLS2zZskUsLS4uDmfOnIGpqalEfj8/P4n3UVBQEADg8ePHEAgE+Pvvv/HgwQMsX74c69atw2+//Sbaf/PmzZgwYQLGjRuH6OhoXLx4EVOnTkVGRoYoT82aNeHl5YW1a9cqeOWlUN4relZ2tCo4qWjnAqaxa8dPsg+v3oil52ZkyHzkfbECbrF5v1itWlY+RXXp0oWZm5uzDCn7Fl05GgDbsGED69WrF9PU1GS2trbs0KFDou3CVcGPHTvGmjZtytTV1VlERATLzs5mAQEBzMjIqNhVwWfOnMns7OzEzm9vb89mzZoldVVwWauIy+Lk5MQCAwNF1wWARUZGKnSMoqysrNjy5csl0qWtCu7p6clatWol81gA2Lp161i3bt2YpqYmc3BwYJcuXWLPnj1j7dq1Y1paWqx169YsJiZGbL81a9YwGxsbpq6uzuzt7dnWrVvFtj99+pS1adOG8Xg85ujoyE6dOiWx2vjr169Zv379GJ/PZwYGBqxHjx6iey3reorKz89nfD6fHTlyRJT25arswlXTi94zKysrsTxWVlZSjy9ttfkvV4qPjY1l3bt3Z/r6+kxLS4s5OTmxo0ePSt0/ODiY8fl8duLECebg4MC0tbWZl5cXe/v2rej4eXl5LCAggPH5fGZoaMimTp3Khg4dWux92L17NwPADh48KLFNIBCw1NRUsfu5ZMkSZmJiwgwNDdmYMWNYbm6uKL+VlRWbO3cuGzJkCNPV1RWtZr9v3z7m5OTEuFwus7KyYkuXLhU7T7t27djo0aNZjRo12IULF0Tp8+fPZ97e3qxRo0Zs9uzZYvnHjx8v85qkCQoKYnXq1BE979mzJ/Px8Slxv5CQEGZhYSFze3mtCk41N4SUs/SYwirXL2cm3qZnI/Nxtu8Isbw7TerLzHuq20CxvHttmkvNp4gPHz7gxIkT8Pf3h7a2ZCdofX19seeBgYHo378/7t69i65du2LQoEH48OGDWJ5p06Zh0aJFePToERo2bIipU6di//79CAkJwa1bt2BrawsvLy+J/Xr06IGUlBRcuHABAHDhwgWkpKTA29tboWuSRiAQ4OPHjzA0NAQA6OjoQEdHBwcPHkROTk6Zj18STU3NEn99z5s3D0OHDkV0dDQcHBwwcOBA/Pzzz5g+fTpu3LgBxhjGjh0ryn/gwAGMHz8ekyZNwv379/Hzzz9j+PDhiIiIAFB4zb179waXy8XVq1exbt06/Prrr2LnzMvLg5eXF3R1dREVFYWLFy9CR0cHnTt3lru24O7du0hLS0OzZs1EaWFhYfDz80Pr1q0RHx+PsLAwif2uX78OAAgODkZ8fLzoeWn4+/sjJycH58+fx71797B48WKxWqQvZWVlYenSpdi2bRvOnz+P169fY/LkyaLtixcvxo4dOxAcHIyLFy8iPT29xOazHTt2oF69eujZs6fENg6HI9YsFhERgefPnyMiIgIhISHYsmWLRG3L0qVL0ahRI9y+fRuzZs3CzZs30b9/f/z444+4d+8e5syZg1mzZknsx+VyMWjQIAQHB4vStmzZAl9f32Ljl1daWprofQQAJiYmuHLlCl69elXsfi1atMC///4ral6uKFS4IaQcCfLz8fHFawCShZvKLCYmBowxODg4yJXfx8cHAwYMgK2tLRYsWICMjAxcu3ZNLM/cuXPh6emJunXrgsfjYe3atViyZAm6dOkCJycnbNiwAZqamti0aZPYfurq6hg8eDA2b94MoLC6e/DgwVCX0Tnb1dVVVEgRPmRZunQpMjIy0L9/fwCAmpoatmzZgpCQEOjr68PNzQ2//fYb7t69K9d9kBdjDOHh4Th58iQ6dOhQbN7hw4ejf//+sLe3x6+//orY2FgMGjQIXl5ecHR0xPjx4xEZGSl2TT4+PhgzZgzs7e3xyy+/oHfv3li6dCmAwma7x48fY+vWrWjUqBHatm0r1uEXAHbv3g2BQICNGzeiQYMGcHR0RHBwMF6/fi12ruK8evUKqqqqMDY2FqUZGhpCS0tL1CRU9MtQyMjICEBhAdrExET0vDRev34NNzc3NGjQADY2NujevTvatm0rM39eXh7WrVuHZs2aoWnTphg7dqxY/7JVq1Zh+vTp+P777+Hg4IC//vpLoqD/pWfPnqFevXpyxWtgYIC//voLDg4O6N69O7p16ybRv61Dhw6YNGkS6tati7p16+KPP/5Ax44dMWvWLNjb28PHxwdjx46V2tzp6+uLPXv2IDMzE+fPn0daWhq6d+8uNZY1a9ZIvI927NghNW9MTAxWrVqFn3/+WZQ2e/Zs6Ovrw9raGvXq1YOPjw/27NkDgUAgtq+ZmRkAlFgIKisaCk5IOfr4PBaC3FyAowKVL76Mh6TL7kTHUVUVez4g4YHsvF8s59DvRel/6QoxxhTK37BhQ9Hf2tra0NPTQ1JSklieor/gnz9/jry8PLi5uYnS1NXV0aJFCzx69Eji+L6+vnB1dcWCBQuwd+9eXL58WWa/nd27d8PR0bHEmENDQxEYGIhDhw6JfQH36dMH3bp1Q1RUFK5cuYLjx48jKCgIGzduhI+PT4nHLc6RI0ego6ODvLw8CAQCDBw4UKwjpzRF722tWrUAAA0aNBBLy87ORnp6OvT09PDo0SOxzrkA4ObmhpUrVwIAHj16BEtLS9GXCgC0bt1aLP+dO3cQExMDXV1dsfTs7Gw8f/5crmv99OkTeDzeV+nTIsu4ceMwevRonDp1Ch4eHujTp4/Y/fySlpYW6tatK3puamoqeh2npaUhMTERLVq0EG1XVVWFi4uLxBd2UYq8l+rXrw/VIu99U1NT3Lt3TyxP0fcRUPj//LJWyM3NDStWrEBBQYHY8Ro1agQ7Ozvs27cPERERGDJkCNTUpH/tDxo0CDNmzBBLE77+ioqLi0Pnzp3Rr18/+Pn5icV++fJl3L9/H+fPn8elS5cwbNgwbNy4ESdOnIDK588tTU1NAKjwjtVUuCGkHKXcfwwAUFFXk/iQV5fS3CNLReWVxc7ODhwOB48fP5bvnF8U3DgcjsQHvrTmLXk1aNAADg4OGDBggKgzanR0tNS8lpaWsLW1LfZ4u3btwsiRI7F37154eHhIbNfQ0ICnpyc8PT0xa9YsjBw5ErNnzy5z4cbd3R1r164Fl8uFmZmZzC+WooreW+FrSFpacV+wisrIyICLi4vUX+ry1qTUrFkTWVlZyM3NBZfLLbfYhIRfjkULD3mfZwIXGjlyJLy8vHD06FGcOnUKCxcuxLJly2QOP5b2Ola0oP8le3v7SvM+Agp/KKxevRoPHz6UqF0tis/nl/g+evv2Ldzd3eHq6or169dLzePs7AxnZ2eMGTMGo0aNQps2bXDu3Dm4u7sDgKgZuiw1dPKgZilCylHKg8+FG27Vmt/G0NAQXl5eWL16NTIzMyW2l3VukLp164LL5YoNr87Ly8P169fh5OQkdR9fX19ERkaWuY/Azp07MXz4cOzcuRPdunWTax8nJyep90FR2trasLW1Re3ateUq2JSGo6OjxLD1ixcviu6ro6Mj3rx5g/j4eNF24VB5oaZNm+LZs2cwNjaGra2t2EPeodONGzcGADx8+FDha1BXV0dBQUGxeYRfhkWvQ1qB19LSEqNGjUJYWBgmTZqEDRs2KBwPUPhlX6tWLbE+QAUFBbh161ax+w0cOBBPnz7FoUOHJLYxxpCWllaqeIRk/b/t7e3Fam2KxnPv3j04OzvLfK/JIy4uDu3bt4eLiwuCg4NFhc3iCM9X9L10//59qKuro379+qWORR5Uc0NIOUp58AQAJJqkqoLVq1fDzc0NLVq0wNy5c9GwYUPk5+fj9OnTWLt2rdTmI3lpa2tj9OjRmDJlCgwNDVG7dm0EBQUhKysLI0aMkLqPn58f+vXrV2Ifh+TkZCQkJIil6evrQ0NDA6GhoRg2bBhWrlyJli1bivJpamqCz+cjOTkZ/fr1g6+vLxo2bAhdXV3cuHEDQUFBUjuECuXm5oq+xHNzcxEXF4fo6Gjo6OiU+Ou3vE2ZMgX9+/dHkyZN4OHhgcOHDyMsLAzh4eEAAA8PD9jb22PYsGFYsmQJ0tPTJZofBg0ahCVLlqBnz56YO3cuLCws8OrVK4SFhWHq1KmwsLAoMQ4jIyM0bdoUFy5cEBV05GVtbY0zZ87Azc0NPB4PBgYGEnlsbW1haWmJOXPmYP78+Xj69CmWLVsmlmfChAno0qUL7O3tkZKSgoiICLmaLGUJCAjAwoULYWtrCwcHB6xatQopKSnFNr31798fBw4cwIABAzBz5kx06tQJRkZGuHfvHpYvX46AgIAyTd43adIkNG/eHPPmzcMPP/yAy5cv46+//sKaNWuk5jcwMEB8fLzMPmtCWVlZEu8j4f9CWLCxsrLC0qVL8e7dO1Ee4VQIo0ePhpmZGTp06AALCwvEx8fjf//7H4yMjMSaQaOiotCmTRtR81SFKXE8VTVDQ8FJRcpJTWP/XrrG7t+9K3UoY2X39u1b5u/vz6ysrBiXy2Xm5uasR48eLCIiQpQHXwwhZowxPp/PgoODGWPSh+wyVjjEMyAggNWsWbPYoeCyhnZ/OexXmF/aY+fOnYwxyaHIwodwSG12djabNm0aa9q0KePz+UxLS4vVq1ePzZw5k2V9MeS+KFnnFg51ZqzkodPSfHlvpd0Tafe3pKHgT548Yd999x3jcrnM3t6enThxQuJc8fHxbOjQoaL/j42NDfPz8xN9VspzPWvWrJEY6j5+/Hix+8KY5PD5f/75h9na2jI1NTWZQ8EZY+zChQusQYMGTENDg7Vp04bt3btX7DUxduxYVrduXcbj8ZiRkREbMmQIe//+vdT7JhwKXtSBAwdY0a/FvLw8NnbsWKanp8cMDAzYr7/+yvr168d+/PHHYu9DQUEBW7t2LWvevDnT0tJienp6zMXFha1cuVL0upJ2P7+8V7KmGRAOBVdXV2e1a9dmS5YsEdte0tBuaUPBpb2evby8GGOF90rWe61oTF27dmWmpqaMy+UyMzMz1qdPH3b37l2xc9erV0/0/pSmvIaCcxgrYwNjFZOeng4+n4+0tDTo6ekpOxxSDWVnZ+Ply5eoU6cONDRo4Uzy7fj06RPq1auH3bt3S3Rarg4EAgEcHR3Rv39/zJs3T9nhVDnHjx/HpEmTcPfuXZnNtMV9firy/U3NUoSUgaCgAIlRV5AVnwgt01qo1aaVskMiRGk0NTWxdetWvH//XtmhlItXr17h1KlTaNeuHXJycvDXX3/h5cuXGDhwYMk7EwmZmZkIDg6usP5nRVHhhpBSig07iisTZyDr3/86OKrpaMFp2nho9/JSYmSEKE/79u2VHUK5UVFRwZYtWzB58mQwxuDs7Izw8PAy9eP5lvXt2/ernYsKN4SUQmzYUZztPwL4olU3PyMLTzZsQ8NOsicOI4RUDZaWlsUuoEoqLyrcEKIgQUEBrkycIVGwKSrnQyoYY2CMIS8jE4LcPKhw1aGuo63USc4IIeRbQIUbQhSUGHVFrClKGlaQj+x37/EpNR2C3P8mGlPhqkPb0hw8A/0KjpIQQr5dNIkfIQrKik+UK1920nuxgg0ACHLz8fH5K+SkpFZAZIQQQgAq3BCiMC1TyfVW5FfYlJX55m2Zp3knhBAiHRVuCFFQrTatoGVhCpS67wyDIDcXeRlln96fEEKIJKUWbtauXYuGDRtCT08Penp6aN26NY4fP17sPnv37oWDgwM0NDTQoEEDHDt27CtFS0ghFVVVtFo+v9gOxfL4ssmKEEJI+VBq4cbCwgKLFi3CzZs3cePGDXTo0AE9e/bEgwcPpOa/dOkSBgwYgBEjRuD27dvo1asXevXqhfv373/lyMm3zrp3N9Ro2lAiXdOsFhzHjpTrGCUtrllQUIDIyEjs3LkTkZGRJS4s+LVwOBwcPHhQ2WF8E2JjY8HhcGSuiE4IkU6phRtvb2907doVdnZ2sLe3x/z586GjoyOxYq3QypUr0blzZ0yZMgWOjo6YN28emjZtir/++usrR06+dXkZmUj9vEjmdxuXo932tehyJgw/xN6Gw89DwVFVAyCr2YoDFS4X6jraMo8fFhYGa2truLu7Y+DAgXB3d4e1tTXCwsLK/2KKSEhIQEBAAGxsbMDj8WBpaQlvb2+cOXOmQs8L/PdFrqqqiri4OLFt8fHxUFNTA4fDQWxsrFh+aQ/hZ0hYWBg8PT1hZGQkqh0+efKk2LHfvXuH0aNHo3bt2uDxeDAxMYGXl1ex85ts2LABbdq0gYGBAQwMDODh4YFr166J5Wnfvr0oHg0NDTg5Oclc3LA8+fj4lGlhRkKqg0rT56agoAC7du1CZmamzDVJLl++DA8PD7E0Ly8vXL58WeZxc3JykJ6eLvYgpKziTkagICcHunWtYeczAHUH9IZpezeoqKpCRVUVPEP9zzm/LOAUPte2NJM5301YWBj69u2Lf//9V/yccXHo27dvhRVwYmNj4eLigrNnz2LJkiW4d+8eTpw4AXd3d/j7+5f6uIwx5Ofny53f3NwcW7duFUsLCQmBubm51Pzh4eGIj48Xe7i4uAAAzp8/D09PTxw7dgw3b96Eu7s7vL29cfv2bdH+ffr0we3btxESEoKnT5/in3/+Qfv27ZGcnCwzxsjISAwYMAARERG4fPkyLC0t0alTJ4lCmZ+fH+Lj4/Hw4UP0798f/v7+2Llzp9z3ghBSSiUurVnB7t69y7S1tZmqqirj8/ns6NGjMvOqq6uz0NBQsbTVq1czY2NjmfvMnj1b6kqmtCo4KYvIIWPYJhVjdnXybPbu5h12qvtAdidoFWPsv1Vt0xISWfKd+yzp2i0We/4Siz1/ib2+fJ0lv/mXZWRkSH2kpaUxc3NzmSvwcjgcZmFhwdLS0mQeo+hDIBDIfU1dunRh5ubmLCMjQ2Jb0RWoAbANGzawXr16MU1NTWZra8sOHTok2i5cffnYsWOsadOmTF1dnUVERLDs7GwWEBDAjIyMil0VfObMmczOzk7s/Pb29mzWrFlSVwWXtYq4LE5OTiwwMFB0XQBYZGSkQsf4Un5+PtPV1WUhISGiNGkrM9vZ2RW7ovTVq1dZ48aNGY/HYy4uLiwsLEzsGvPz85mvry+ztrZmGhoazN7enq1YsUK0v7TPO+GK7lOnTmV2dnZMU1OT1alTh82cOZPl5uaW6boJKW/ltSq40mtu6tWrh+joaFy9ehWjR4/GsGHD8PDhw3I7/vTp05GWliZ6vHnzptyOTb5Ngrw8vDl6GgBQu2cXJN+8gzfHwhF/9oJYPi5fDwYNnKBmaQbrtq6wbuuK2q2bo4alBXR0dKQ++Hy+xK//ohhj+Pfff8Hn82Ueo+gjKytLrmv68OEDTpw4AX9/f2hrSzaX6evriz0PDAxE//79cffuXXTt2hWDBg3Chw8fxPJMmzYNixYtwqNHj9CwYUNMnToV+/fvR0hICG7dugVbW1t4eXlJ7NejRw+kpKTgwoXC+3nhwgWkpKTA29tbrmspjkAgwMePH2FoaAgAovt08OBB5OTklPq4WVlZyMvLEx1XFk1NTeTm5krdlpGRge7du8PJyQk3b97EnDlzMHnyZIn4LSwssHfvXjx8+BC///47fvvtN+zZswcAMHnyZPTv3x+dO3cW1WK5uroCAHR1dbFlyxY8fPgQK1euxIYNG7B8+fJSXzMhlVoFFLzKpGPHjuynn36Sus3S0pItX75cLO33339nDRs2lPv4ipT8CJEmLvwc26RizHbUcmQF+fns8vjfRLU4jEn+8sjIyJBZE1PRD2m1MNJcvXqVAWBhYWEl5sXn2hUh4fUdP36cMfZfzc3BgwfF8qirq7MdO3aI0nJzc5mZmRkLCgpijInXxEyYMIENHz6cMcbY8OHD2cSJE9nt27el1txoamoybW1tsYcsixcvZgYGBiwxMVGUtm/fPmZgYMA0NDSYq6srmz59Ortz544cd+0/o0ePZjY2NmK/NovW3OTn57Nt27YxAOyvv/6Seoy///6b1ahRQ+wYa9euLbF2yt/fn/Xp00f0fNiwYaxnz54lxrxkyRLm4uJSYj5CvqbyqrmpdMsvCAQCmb+gWrdujTNnzmDChAmitNOnT8vso0NIRXh1qHC6gtreXlBRVUXKg8cAAIP6DlLza2lpISMjQ65jnz9/Hl27di0x37Fjx9C2bcmLc2ppacl1XqbgsPaGDf8bKaatrQ09PT0kJSWJ5WnWrJno7+fPnyMvLw9ubm6iNHV1dbRo0QKPHj2SOL6vry9cXV2xYMEC7N27F5cvX5bZb2f37t1yrdIcGhqKwMBAHDp0CMbGxqL0Pn36oFu3boiKisKVK1dw/PhxBAUFYePGjfDx8SnxuIsWLcKuXbsQGRkJDQ0NsW1r1qzBxo0bkZubC1VVVUycOBGjR4+WehxhDVfRY0j7bFu9ejU2b96M169f49OnT8jNzUXjxo1LjHP37t34888/8fz5c2RkZCA/Px96enol7kdIVaTUws306dPRpUsX1K5dGx8/fkRoaCgiIyNFoxmGDh0Kc3NzLFy4EAAwfvx4tGvXDsuWLUO3bt2wa9cu3LhxA+vXr1fmZZBvCGMMrw+dAFDYJAUAKfcLCzf69etJ3YfD4Uht6pGmU6dOsLCwQFxcnNQCB4fDgYWFBTp16gRVVdXSXIJUdnZ24HA4ePz4sVz51dXFh7FzOBwIBAKxNHmvWZoGDRrAwcEBAwYMgKOjI5ydnWUOh7a0tIStrW2xx9u1axdGjhyJvXv3SgxKAAANDQ14enrC09MTs2bNwsiRIzF79uwSCzdLly7FokWLEB4eLlbgExo0aBBmzJgBTU1NmJqaQkWlbD0Bdu3ahcmTJ2PZsmVo3bo1dHV1sWTJEly9erXY/S5fvoxBgwYhMDAQXl5e4PP52LVrF5YtW1ameAiprJTa5yYpKQlDhw5FvXr10LFjR1y/fh0nT56Ep6cnAOD169eIj/9vgUJXV1eEhoZi/fr1aNSoEfbt24eDBw/C2dlZWZdAvjHJt+4i89+3UNPWglnHNvj07j2yk94DAPSd7Mt8fFVVVaxcuRIAJEZTCZ+vWLGiXAs2AGBoaAgvLy+sXr0amZmSMyenpqaW6fh169YFl8sVG16dl5eH69evw8nJSeo+vr6+iIyMhK+vb5nOvXPnTgwfPhw7d+5Et27d5NrHyclJ6n0oKigoCPPmzcOJEyfEaqmK4vP5sLW1hbm5eYkFG0dHR9y9exfZ2dmitC+nxbh48SJcXV0xZswYNGnSBLa2tnj+/LlYHi6XKzEn0qVLl2BlZYUZM2agWbNmsLOzw6tXr4qNh5CqTKk1N5s2bSp2e2RkpERav3790K9fvwqKiJDiCZukLLw6QE1TE4kXC+c20bWxgnoZaiqK6t27N/bt24fx48eLDQe3sLDAihUr0Lt373I5z5dWr14NNzc3tGjRAnPnzkXDhg2Rn5+P06dPY+3atVKbj+Slra2N0aNHY8qUKTA0NETt2rURFBSErKwsjBgxQuo+fn5+6Nevn0Rn5i8lJycjISFBLE1fXx8aGhoIDQ3FsGHDsHLlSrRs2VKUT1NTE3w+H8nJyejXrx98fX3RsGFD6Orq4saNGwgKCkLPnj1lnnPx4sX4/fffERoaCmtra9FxhR2US2PgwIGYMWMG/Pz8MH36dMTGxmLp0qVieezs7LB161acPHkSderUwbZt23D9+nXUqVNHlMfa2honT57EkydPUKNGDfD5fNjZ2eH169fYtWsXmjdvjqNHj+LAgQOlipOQKqHcewNVctShmJRFWMO2bJOKMXu2bS9jjLGYHfvYVv267Ez/kaI8xXWIU0R+fj6LiIhgoaGhLCIiguXn55fpePJ4+/Yt8/f3Z1ZWVozL5TJzc3PWo0cP0XBixgo7FB84cEBsPz6fz4KDgxlj/3UoLjp8nLHC+xIQEMBq1qxZ7FBwWZ1nZXUolvbYuXMnY6ywU6+07cOGDWOMMZadnc2mTZvGmjZtyvh8PtPS0mL16tVjM2fOZFlZWTLvk5WVldTjzp49W5RH2lDwkly+fJk1atSIcblc1rhxY7Z//36xe5Kdnc18fHwYn89n+vr6bPTo0WzatGmsUaNGomMkJSUxT09PpqOjIzYUfMqUKaxGjRpMR0eH/fDDD2z58uWMz+crFB8hFa28OhRzGPu2liZOT08Hn89HWloadaYjCkmPeYl99VqBo6qKgYkPwTPQBwAwgQB5HzPA5Re+nrKzs/Hy5UvUqVNHooMpIYQQ2Yr7/FTk+1vp89wQUlW8+qewI7FJe1dRwQYAOCoqooINIYQQ5aPCDSFyev25v43V51FShBBCKicq3BAih09J70Sdh2v36AwAiDt9DnvtW+LalDlKjIwQQsiXqHBDiBzeHD4FMIYaLo2gY1m4gOP7G7fx8Xksst4mlLA3IYSQr4kKN4TI4ZWoSaqzKO39jTsAgJrNGisjJEIIITJQ4YaQEuRlZOJt+HkA4v1t3t/8XLhxaaSUuAghhEhHhRtCShB3MgIFOTnQrWsN/c/rR31KTELmmziAw0GNJg2UHCEhhJCiqHBDSAleFRklJVwC4f3NuwAAfj1bqOuWbkZaQgghFYMKN4QUQ5CXhzdHTwP4b6FMoHCNKYCapAghpDKiwg0hxUg4fxm5qWnQMKoB49b/LY7Iq2GAGk0awKiVixKjUw4Oh4ODBw8qOwxSBrGxseBwODJXWpemffv2mDBhQon52rZti9DQUNHzhIQEeHp6QltbW7ROmDJeQ1u2bClxnbKvSd77WZ38+OOPX20leircEFIMYZNUbW8vqBRZidtx9HD0vBEOpzFlW7G6sklISEBAQABsbGzA4/FgaWkJb29vnDlzpsLPLfzCVVVVRVxcnNi2+Ph4qKmpgcPhIDY2Viy/tIdwNe2wsDB4enrCyMgIenp6aN26NU6ePCl27Hfv3mH06NGoXbs2eDweTExM4OXlJbaC+Zc2bNiANm3awMDAAAYGBvDw8MC1a9fE8rRv314Uj4aGBpycnLBmzZpyuFOV1z///IPExET8+OOPorTly5cjPj4e0dHRePr0KYDC/2eXLoU1oaUpaJXGDz/8IDp/RcvNzUVQUBAaNWoELS0t1KxZE25ubggODkZeXl6Fn9/a2hocDge7du2S2Fa/fn1wOBxs2bJFIv+Xj0WLFgEA7ty5gwEDBsDS0hKamppwdHTEypUrxY5bUFCARYsWwcHBAZqamjA0NETLli2xceNGUZ6ZM2di/vz5SEtLq5gLL0Kpq4ITUpkxxvD6UOGSC7W/gVmJY2Nj4ebmBn19fSxZsgQNGjRAXl4eTp48CX9/fzx+/LhUx2WMoaCgAGpq8n3cmJubY+vWrZg+fbooLSQkBObm5nj9+rVE/vDwcNSvX18srUaNGgCA8+fPw9PTEwsWLIC+vj6Cg4Ph7e2Nq1evokmTJgCAPn36IDc3FyEhIbCxsUFiYiLOnDmD5ORkmTFGRkZiwIABcHV1hYaGBhYvXoxOnTrhwYMHMDc3F+Xz8/PD3LlzkZWVha1bt8Lf3x8GBgYYMGCAXPeiqvnzzz8xfPhwqKj897v5+fPncHFxgZ2dnSjNxMTkq8emqakJTU3NCj9Pbm4uvLy8cOfOHcybNw9ubm7Q09PDlStXsHTpUjRp0gSNGzcu1bHz8vKgrq4uV15LS0sEBweLFTSvXLmChIQEaGtrS+SfO3cu/Pz8xNJ0dXUBADdv3oSxsTG2b98OS0tLXLp0CT/99BNUVVUxduxYAEBgYCD+/vtv/PXXX2jWrBnS09Nx48YNpKSkiI7n7OyMunXrYvv27fD391f4+hVS3it6Vna0KjiR17sb0WyTijEL0bVmeUVWiM5JS2f5OTky95O1qm1GRobMhyJ5v1ytWlY+RXXp0oWZm5tL3bfoCt8A2IYNG1ivXr2YpqYms7W1ZYcOHRJtF64KfuzYMda0aVOmrq7OIiIiWHZ2NgsICGBGRkbFrgo+c+ZMZmdnJ3Z+e3t7NmvWLKmrgstaRVwWJycnFhgYKLouACwyMlKhY3wpPz+f6erqspCQEFGatFXB7ezs2I8//ij1GMLr2b17N/vuu++YhoYGa9asGXvy5Am7du0ac3FxYdra2qxz584sKSlJtF9BQQELDAxk5ubmjMvlskaNGrHjx4+LHfvq1auscePGjMfjMRcXFxYWFiZx7+7du8c6d+7MtLW1mbGxMRs8eDB79+5dsddTVFJSEuNwOOz+/fuitC9XTxeuxo4iK8vji5XV27VrJ/X4wcHBEquYHzhwgBX9GouOjmbt27dnOjo6TFdXlzVt2pRdv35d6v6zZ89mjRo1Ylu3bmVWVlZMT0+P/fDDDyw9PV2UJz09nQ0cOJBpaWkxExMT9scff5R4HxYvXsxUVFTYrVu3JLbl5uaK3l/t2rVjAQEBbMqUKczAwIDVqlVLbFV54b1Zs2YN8/b2ZlpaWqLta9asYTY2NkxdXZ3Z29uzrVu3iu1nZWXFpk2bxng8Hnv9+rUo3c/PjwUEBDA+n8+Cg4PF8i9fvlzmNUkzZswY5u7uLnreqFEjNmfOnBL3CwwMZN99953M7eW1Kjg1SxHyBUFBAeIjLyJ6wXIAgHknd6gV+cV3f/k6bOPXxa3AJQodV0dHR+ajT58+YnmNjY1l5hVW5wtZW1tLzaeIDx8+4MSJE/D395f6q+7LvgqBgYHo378/7t69i65du2LQoEH48OGDWJ5p06Zh0aJFePToERo2bIipU6di//79CAkJwa1bt2BrawsvLy+J/Xr06IGUlBRcuHABAHDhwgWkpKTA29tboWuSRiAQ4OPHjzA0NATw3//k4MGDyMnJKfVxs7KykJeXJzquLJqamsjNzS02z+zZszFz5kzcunULampqGDhwIKZOnYqVK1ciKioKMTEx+P3330X5V65ciWXLlmHp0qW4e/cuvLy80KNHDzx79gwAkJGRge7du8PJyQk3b97EnDlzMHnyZLFzpqamokOHDmjSpAlu3LiBEydOIDExEf3795f7Hly4cAFaWlpwdHQUpV2/fh2dO3dG//79ER8fL9GUAUDUnBceHo74+HiEhYXJfc4vDRo0CBYWFrh+/Tpu3ryJadOmFVvT8fz5cxw8eBBHjhzBkSNHcO7cOVFTDAD88ssvuHjxIv755x+cPn0aUVFRuHXrVrEx7NixAx4eHqKawaLU1dXF3l8hISHQ1tbG1atXERQUhLlz5+L06dNi+8yZMwfff/897t27B19fXxw4cADjx4/HpEmTcP/+ffz8888YPnw4IiIixParVasWvLy8EBISAqDwNbp79274+pZPU3paWprY693ExARnz57Fu3fvit2vRYsWuHbtWpneb3IpsfhTzVDNDSnOy/1H2M7ajdgmFWPRY1sNe/Zy/xFRnlPdB7JNKsbswV8bpR5D1i8PfPELteija9euYnm1tLRk5v3yl23NmjWl5lPE1atXGQAWFhZWYl58rl0RysjIYABEtQXCmpuDBw+K5VFXV2c7duwQpeXm5jIzMzMWFBTEGBOviZkwYQIbPnw4Y4yx4cOHs4kTJ7Lbt29LrbnR1NRk2traYg9ZFi9ezAwMDFhiYqIobd++fczAwIBpaGgwV1dXNn36dHbnzh057tp/Ro8ezWxsbMT+50V/4efn57Nt27YxAOyvv/6Segzh9Wzc+N/raufOnQwAO3PmjCht4cKFrF69eqLnZmZmbP78+WLHat68ORszZgxjjLG///6b1ahRQyy2tWvXitXczJs3j3Xq1EnsGG/evGEA2JMnTySuR5rly5czGxsbifSePXuKamyEUKTmRt4aOHlqbnR1ddmWLVvk2n/27NlMS0tLrKZmypQprGXLloyxwlobdXV1tnfvXtH21NRUpqWlVex90NTUZOPGjSv2WhgrvJ9f1mA0b96c/frrr6LnANiECRPE8ri6ujI/Pz+xtH79+ol9hghrYg4ePMjq1q3LBAIBCwkJYU2aNGGMMak1N1wuV+J9dP78eamxX7x4kampqbGTJ0+K0h48eMAcHR2ZiooKa9CgAfv555/ZsWPHJPa9c+cOA8BiY2OlHru8am6ozw0hn8WGHcXZ/iMAxsTSc1PTcLb/CHTYswlW33ct9czEGRkZMrepFumsDABJSUky8xbtzwBA1MG2LNgX11yShg0biv7W1taGnp6eRMzNmv03uuz58+fIy8uDm5ubKE1dXR0tWrTAo0ePJI7v6+sLV1dXLFiwAHv37sXly5eRn58vNZbdu3eL1RbIEhoaisDAQBw6dAjGxsai9D59+qBbt26IiorClStXcPz4cQQFBWHjxo3w8fEp8biLFi3Crl27EBkZCQ0NDbFta9aswcaNG5GbmwtVVVVMnDgRo0ePLvZ4Re9trVq1AAANGjQQSxPe6/T0dLx9+1bsvgKAm5sb7twpfJ0Ka86Kxta6dWux/Hfu3EFERITUGr/nz5/D3t6+2JgB4NOnTxLX/7X98ssvGDlyJLZt2wYPDw/069cPdevWlZnf2tpa1K8EAExNTUX39sWLF8jLy0OLFi1E2/l8PurVq1dsDIq8l4r+r788v1DR9xFQ+P/86aefxNLc3Nyk1op169YNP//8M86fP4/NmzcXW2szZcoUidd70f5jQvfv30fPnj0xe/ZsdOrUSZTu5OSE+/fv4+bNm7h48SLOnz8Pb29v+Pj4iHUqFvZ7ysrKkhlLeaDCDSEobIq6MnGGRMEGQGEah4Orv8xEDZeG+JT4DhxVVRg2qi+ZtxjSmnu+dl5Z7OzswOFw5O40/GVVP4fDgUAgKLe4GjRoAAcHBwwYMACOjo5wdnaWOZrG0tIStra2xR5v165dGDlyJPbu3QsPDw+J7RoaGvD09ISnpydmzZqFkSNHYvbs2SUWbpYuXYpFixYhPDxc4osKKGwmmTFjBjQ1NWFqaipRMJWm6L0VThr5ZdqX97qsMjIy4O3tjcWLF0tsMzU1lesYNWvWFOs8Wt5UVFQkCg5fjjyaM2cOBg4ciKNHj+L48eOYPXs2du3ahe+//17qMeV5HSvK3t6+0ryP1NTUMGTIEMyePRtXr17FgQMHZOatWbNmie+jhw8fomPHjvjpp58wc+ZMie0qKipo3rw5mjdvjgkTJmD79u0YMmQIZsyYgTp16gCAqBnayMio1NclD+pzQwiAxKgryPo3XnYGxpD55i2eb9sLADBwdhDrh1PVGRoawsvLC6tXr0ZmZqbE9tTU1DIdv27duuByuWLDq/Py8nD9+nU4OTlJ3cfX1xeRkZFl7iOwc+dODB8+HDt37kS3bt3k2sfJyUnqfSgqKCgI8+bNw4kTJyR+XQvx+XzY2trC3NxcroKNovT09GBmZiYxbP3ixYui++ro6Ii7d+8iOztbtF04VF6oadOmePDgAaytrWFrayv2kPfLtUmTJkhISFC4gMPlcgEUDiUujpGRET5+/Cj2f5FW4LW3t8fEiRNx6tQp9O7dG8HBwQrFI2RjYwN1dXVcv35dlJaWllbicPKBAwciPDwct2/fltiWl5dX4uuqJI6OjsX+v7/k6+uLc+fOoWfPnjAwMCj1eR88eAB3d3cMGzYM8+fPl2sfYUxFr/n+/fuwsLBAzZo1Sx2LPKhwQwiArPhEufK9v1V9F8tcvXo1CgoK0KJFC+zfvx/Pnj3Do0eP8Oeff0o0YyhKW1sbo0ePxpQpU3DixAk8fPgQfn5+yMrKwogRI6Tu4+fnh3fv3mHkyJHFHjs5ORkJCQliD+EXeWhoKIYOHYply5ahZcuWou3CeTaSk5PRoUMHbN++HXfv3sXLly+xd+9eBAUFoWfPnjLPuXjxYsyaNQubN2+GtbW16LjFNT1WlClTpmDx4sXYvXs3njx5gmnTpiE6Ohrjx48HUPhly+Fw4Ofnh4cPH+LYsWNYunSp2DH8/f3x4cMHDBgwANevX8fz589x8uRJDB8+vMRCh1CTJk1Qs2bNYucHksbY2BiampqiTsyy5kBp2bIltLS08Ntvv+H58+cIDQ0Vm6vl06dPGDt2LCIjI/Hq1StcvHgR169fl6vJUhpdXV0MGzYMU6ZMQUREBB48eIARI0ZARUVFVKMmzYQJE+Dm5oaOHTti9erVuHPnDl68eIE9e/agVatWoo7epTVlyhRs2bIFa9euxbNnz/DHH38gLCxMopO4kKOjI96/f19iIe/jx48S76P09HQAhQUSd3d3dOrUCb/88otoe9HOw3379sXy5ctx9epVvHr1CpGRkfD394e9vT0cHBxE+aKiosSasyoKFW4IAaBlWkuufFlvEwAANZpWv8KNjY0Nbt26BXd3d0yaNAnOzs7w9PTEmTNnsHbt2jIff9GiRejTpw+GDBmCpk2bIiYmBidPnpT5a1JNTQ01a9YscX4cDw8PmJqaij2Es9+uX78e+fn58Pf3F9su/OLX0dFBy5YtsXz5crRt2xbOzs6YNWsW/Pz88Ndff8k859q1a5Gbm4u+ffuKHffLQsPXMG7cOPzyyy+YNGkSGjRogBMnTuCff/4RzSujo6ODw4cP4969e2jSpAlmzJgh0fwkrP0pKChAp06d0KBBA0yYMAH6+vpy1zipqqpi+PDh2LFjh0Lxq6mp4c8//8Tff/8NMzMzmYVKQ0NDbN++HceOHUODBg2wc+dOzJkzR+z8ycnJGDp0KOzt7dG/f3906dIFgYGBCsVT1B9//IHWrVuje/fu8PDwgJubGxwdHYvtW8Tj8XD69GlMnToVf//9N1q1aoXmzZvjzz//xLhx4+Ds7FzqeACgV69eWLlyJZYuXYr69evj77//RnBwMNq3by9znxo1apQ4x8/vv/8u8T6aOnUqAGDfvn149+4dtm/fLra9efPmov29vLxw+PBheHt7w97eHsOGDYODgwNOnToleg9nZ2fj4MGDEvPpVAQOU7QnYRWXnp4OPp+PtLQ06OnpKTscUkkICgqwx8YFWXEJ0vvdcDjQtjBFg6kBSDh3GY1+m4AaMvrcZGdn4+XLl6hTp47SO1gS8jUlJCSgfv36uHXrFqysrJQdTrnLzMyEubk5li1bJrPGkci2du1aHDhwAKdOnZKZp7jPT0W+v6nmhhAAKqqqaLVcRjvy5yroln/8D05jfNFh9waZBRtCvmUmJibYtGmT1Jmkq6Lbt29j586deP78OW7duoVBgwYBQLFNlkQ2dXV1rFq16quci0ZLEfKZde9u6LBnE84NGY2C7P8mmNK2MEXLP/4H697ydUYl5FvWq1cvZYdQrpYuXYonT56Ay+XCxcUFUVFRFd4Ztroqqf9ceaLCDSFFWPfuhksBfBQkJKHx7Ckwbdsatdq0goqqKj7cewg1LS3o2lgV26GQEFI9NGnSBDdv3lR2GKQUqFmKkCKyEpKQnZAEcDhoMGk0TNu7iVYDvzZpNvbZt8SzzaFKjpIQQkhxqHBDSBHJt+8BAPj1bKFeZH4Pxhje37oLAKjRVHKyNmnKe6I1Qgip7sprjBM1SxFSRPLtzwWYJg3E0j++fIXclFSocLnQr1/89OtcLhcqKip4+/YtjIyMwOVyqRmLEEJKwBjDu3fvwOFwil3wVB5UuCGkiA+37wOQLNy8v1E4eZ9hIyeofp5RVRYVFRXUqVMH8fHxePv2bcUESggh1RCHw4GFhYXEenuKosINIUW8l1FzkyxaLLOxXMfhcrmoXbs28vPz5Z7hlRBCvnXq6uplLtgAVLghRCQnJRUZLwvn55CoubkZDUCxZReEVatlrV4lhBCiGOpQTMhnH6ILm6R0rC3BM9AXpTOBAO9vfq7RqYZrShFCSHVDNTeEfPb+80ipGk3ER0MxgQBtNq7A+1t3YOBkr4zQCCGEKIAKN4R89kFUuBFf2E5FTQ3WfbrDuk93ZYRFCCFEQdQsRchnyTJqbgghhFQtVLghBEBeZibSnsQAkOxM/GzrHvx7MgJ5mZnKCI0QQoiCqHBDCICUuw/BBAJomhhDy7SWKF1QUIDLAdNwquuPyIh9o8QICSGEyIsKN4QASP48UqpGY/Fam/Snz5GfkQk1LU3wHeyUERohhBAFKbVws3DhQjRv3hy6urowNjZGr1698OTJk2L32bJlCzgcjthDQ0PjK0VMqqtk0bpR0mcmrtG0oWgBTUIIIZWbUgs3586dg7+/P65cuYLTp08jLy8PnTp1QmYJfRv09PQQHx8verx69eorRUyqK1k1N+9v/Ve4IYQQUjUodSj4iRMnxJ5v2bIFxsbGuHnzJtq2bStzPw6HAxMTk4oOj3wjCnJzkXLvEQApNTcKLrtACCFE+SpVn5u0tDQAgKGhYbH5MjIyYGVlBUtLS/Ts2RMPHjyQmTcnJwfp6eliD0KKSn3wBIK8PHD1+dCxri1KF+Tni+a+qdmMZiYmhJCqotIUbgQCASZMmAA3Nzc4OzvLzFevXj1s3rwZhw4dwvbt2yEQCODq6op///1Xav6FCxeCz+eLHpaWlhV1CaSKSi4yeR+HwxGlpz1+hvysT1DT0Qbfvq6ywiOEEKKgSjNDsb+/P+7fv48LFy4Um69169Zo3bq16LmrqyscHR3x999/Y968eRL5p0+fjl9++UX0PD09nQo4RIysyfv49WzR8+YZZL6JA0el0vwOIIQQUoJKUbgZO3Ysjhw5gvPnz8PCwkKhfdXV1dGkSRPExMRI3c7j8cDj8cojTFJNJUd/Ltw0/mLZBXV11GjsLJFOCCGkclPqz1HGGMaOHYsDBw7g7NmzqFOnjsLHKCgowL1792BqaloBEZLqTlBQIFoNnEZEEUJI9aDUwo2/vz+2b9+O0NBQ6OrqIiEhAQkJCfj06ZMoz9ChQzF9+nTR87lz5+LUqVN48eIFbt26hcGDB+PVq1cYOXKkMi6BVHHpz14U9qvR0oRekX41grw8XPCbiEdrg1GQm6vECAkhhChKqc1Sa9euBQC0b99eLD04OBg+Pj4AgNevX0OlSH+HlJQU+Pn5ISEhAQYGBnBxccGlS5fg5OT0tcIm1Yhw8j7DRvXFJulLefgUTzeHgrv/CBx+Hqas8AghhJSCUgs3jLES80RGRoo9X758OZYvX15BEZFvjXDyPsMvJu9LvhENAKjh0pA6ExNCSBVDn9rkm5Z8u7DmpmYTGZP3NaX5bQghpKqhwg35ZjHGkHz7c83NF4WbxEvXAAA1mzX+2mERQggpIyrckG9Wxqs3yE1JhYq6Ogzq1xOlZyUkiZZjMHV3U1Z4hBBCSokKN+SblXyrcH4b/fr1oFpkLqT4s1EAgBpNGkCjZg2lxEYIIaT0qHBDvlmiyfu+aJJKfx4LjooKzDrKXryVEEJI5VUpZigmRBmENTdfTt7XZNYkOI0dAUFenjLCIoQQUkZUuCHfrP+WXWggsY1noP+VoyGEEFJeqFmKfJOyEpLwKT4R4HBg2Oi/CSDlmXuJEEJI5UaFG/JNEq4Ezq9nC3VtbVF6xA9+ONKmOxKirigrNEIIIWVEzVLkmyScvK9oZ2JBfj7iTkciL/0j1DQ1lBUaIYSQMipzzU1OTk55xEHIV/Xh8+R9RQs3729EIy/9I7gG+hKT+hFCCKk6FC7cHD9+HMOGDYONjQ3U1dWhpaUFPT09tGvXDvPnz8fbt28rIk5CytV7KTU3b8+cBwCYdWgjtogmIYSQqkXuws2BAwdgb28PX19fqKmp4ddff0VYWBhOnjyJjRs3ol27dggPD4eNjQ1GjRqFd+/eVWTchJRaTkoqMl6+BgDUaOwsSn97pnDyPprfhhBCqja5+9wEBQVh+fLl6NKlC1SkrJLcv39/AEBcXBxWrVqF7du3Y+LEieUXKSHl5MPnlcB1rC3BMzQAAORlZCLp0nUAgJkHFW4IIaQqk7twc/nyZbnymZubY9GiRaUOiJCK9v625Pw2CVFXIMjLg461JXRtrJQVGiGEkHJQrkPBHz16hMmTJ5fnIQkpdx+EhZum/xVuuHq6sPq+G6x7dweHw1FWaIQQQspBmYeCZ2ZmYteuXdi0aROuXLkCJycnLF26tDxiI6RCCOe4qdHkv2UXarm1QC23FsoKiRBCSDkqdc3NxYsX4evri1q1auGnn36Cq6srHj58iPv375dnfISUq7zMTKQ9iQEguWAmIYSQ6kGhwk1SUhKCgoLg4OCAvn37Ql9fH5GRkVBRUYGvry8cHBwqKk5CykXK3YdgAgE0TYyhZVoLAJD27AXSY17S0guEEFJNKFS4sbKywr1797By5UrExcXhjz/+QLNmzSoqNkLKXfLnkVJFOxPfXbQS++q1wp0Fy5UVFiGEkHKkcOHmwoULOH/+PJ4+fVpRMRFSYZJvfZ6873NnYsaYaH4boxYuSouLEEJI+VGocPP48WNs374d8fHxaN68OVxcXLB8eeGvXRphQqqCL2tu0p8+R+abOKjyeKj1HXUoJoSQ6kDhDsVubm7YvHkz4uPjMWrUKOzduxcFBQUYM2YMNmzYQDMTk0qrIDcXKfceAfiv5ibu85ILxm7NoaapqbTYCCGElJ9Sj5bS0dGBn58fLl26hAcPHqBp06aYOXMmzMzMyjM+QspN6oMnEOTlgavPh451bQDA2/DP60nRkguEEFJtlMskfo6Ojli2bBni4uKwe/fu8jgkIeXuv/ltnMHhcCDIz0dC5EUAVLghhJDqpNST+AkEAsTExCApKQkCgUCUXrNmzXIJjJDyJizcGH7ub/P+5h3kpqWDa6CPGk0bFrcrIYSQKqRUhZsrV65g4MCBePXqlcTcIBwOBwUFBeUSHCHlKTm6sHBT8/PkfQb1HeBxIASfkt5DRVVVmaERQggpR6Uq3IwaNQrNmjXD0aNHYWpqSiOlSKUnKCgQrQYurKVR19FG7R6dlRkWIYSQClCqws2zZ8+wb98+2Nralnc8hFSI9GcvkJ/1CWpamtCzr6vscAghhFSgUnUobtmyJWJiYso7FkIqjHDyPsNG9aGiqoqkKzdw8/dFeHftlpIjI4QQUt5KVXMTEBCASZMmISEhAQ0aNIC6urrY9oYNqXMmqVyEk/cJOxO/3HcYD5avw6eEJBi1aKrM0AghhJSzUhVu+vTpAwDw9fUVpXE4HDDGqEMxqZSSbxfW3Ag7E789Q/PbEEJIdVWqws3Lly/LOw5CKgxjDMm3P9fcNGmAT4lJSLn7EABg2uE7ZYZGCCGkApSqcGNlZVXecRBSYTJevUFuSipU1NVhUL8eYsOOAgBqNGkATSOal4kQQqobuTsUX7lyRe6DZmVl4cGDB6UKiJDylnyrcH4b/fr1oMrj4W34OQDUJEUIIdWV3IWbIUOGwMvLC3v37kVmZqbUPA8fPsRvv/2GunXr4ubNm+UWJCFlIZy8r0aTBmCM4e2ZKABUuCGEkOpK7maphw8fYu3atZg5cyYGDhwIe3t7mJmZQUNDAykpKXj8+DEyMjLw/fff49SpU2jQoEFFxk2I3IQ1NzWaNEB20jvkZ2ZBhctFre9aKDkyQgghFYHDvlw/QQ43btzAhQsX8OrVK3z69Ak1a9ZEkyZN4O7uDkNDw4qIs9ykp6eDz+cjLS0Nenp6yg6HfAU7LRriU3wiukUdQS3X5hAUFOBjzEvw69EklIQQUlUo8v1dqg7FzZo1Q7NmzUoVHCFfU1ZCEj7FJwIcDgwbOQEAVFRVqWBDCCHVWKlmKCakqhCuBM6vZws1LS2JhV4JIYRUP0ot3CxcuBDNmzeHrq4ujI2N0atXLzx58qTE/fbu3QsHBwdoaGigQYMGOHbs2FeIllRFwsn7ajRpgHfXbmFPHRdcnfS7kqMihBBSkZRauDl37hz8/f1x5coVnD59Gnl5eejUqZPM0VgAcOnSJQwYMAAjRozA7du30atXL/Tq1Qv379//ipGTquLD58n7ajRpgLfh55D5Jg6Zr+OUHBUhhJCKVKoOxRXl3bt3MDY2xrlz59C2rfRhuj/88AMyMzNx5MgRUVqrVq3QuHFjrFu3rsRzUIfib8se2+bIePkanU/vQ/T//kDCuUtwXR0Eh1HDlB0aIYQQBSjy/V2qmputW7ciJydHIj03Nxdbt24tzSEBAGlpaQBQ7Iiry5cvw8PDQyzNy8sLly9flpo/JycH6enpYg/ybchJSUXGy9cAAL6dDZIuXQcAmHnQ/DaEEFKdlapwM3z4cFFBpKiPHz9i+PDhpQpEIBBgwoQJcHNzg7Ozs8x8CQkJqFWrllharVq1kJCQIDX/woULwefzRQ9LS8tSxUeqng+fVwLXsbbEh/uPIcjLg46VJXTrWis3MEIIIRWqVIUb4erfX/r333/B5/NLFYi/vz/u37+PXbt2lWp/WaZPn460tDTR482bN+V6fFJ5vf88UqpG4wZFVgFvI/W1SwghpPpQaJ6bJk2agMPhgMPhoGPHjlBT+2/3goICvHz5Ep07d1Y4iLFjx+LIkSM4f/48LCwsis1rYmKCxMREsbTExESYmJhIzc/j8cDj8RSOiVR9H4SFm6YN8HLfYQCAmUc7ZYZECCHkK1CocNOrVy8AQHR0NLy8vKCjoyPaxuVyYW1tjT59+sh9PMYYAgICcODAAURGRqJOnTol7tO6dWucOXMGEyZMEKWdPn0arVu3lvu85NsgnOPGsGF95HxIBQQCmHb4TrlBEUIIqXAKFW5mz54NALC2tsYPP/wADQ2NMp3c398foaGhOHToEHR1dUX9Zvh8PjQ1NQEAQ4cOhbm5ORYuXAgAGD9+PNq1a4dly5ahW7du2LVrF27cuIH169eXKRZSveRlZiLtSQwAoGazxqjt7aXkiAghhHwtpVp+YdiwwmG0ubm5SEpKgkAgENteu3ZtuY6zdu1aAED79u3F0oODg+Hj4wMAeP36NVRU/usa5OrqitDQUMycORO//fYb7OzscPDgwWI7IZNvT8rdh2ACATRNjKFlWqvkHQghhFQbpSrcPHv2DL6+vrh06ZJYurCjcUFBgVzHkWeKncjISIm0fv36oV+/fnKdg3ybkj+PlDJs5Iz4c5dg1LIp1MpY00gIIaRqKFXhxsfHB2pqajhy5AhMTU1p9AmpdJJvFS67oGttieMdvgdXn4+BCQ+goq6u5MgIIYRUtFIVbqKjo3Hz5k04ODiUdzyElAthzY0gPx8AUKOJMxVsCCHkG1GqeW6cnJzw/v378o6FkHJRkJuLlHuPAAAZr/8FAJh1pFmJCSHkW1Gqws3ixYsxdepUREZGIjk5mZY3IJVK6oMnEOTlQZ2vh/fXbgOgwg0hhHxLStUsJVzbqWPHjmLpinYoJqQiCOe30atrjeRbd8HV56OGSyMlR0UIIeRrKVXhJiIiorzjIKTcCAs3qhqFM1Obun8HFVVVZYZECCHkKypV4aZdO5rCnlReydGFhZucD6kAqEmKEEK+NaXqcwMAUVFRGDx4MFxdXREXFwcA2LZtGy5cuFBuwRGiKEFBgWg1cJf/TUfzoNmw7NqxhL0IIYRUJ6Uq3Ozfvx9eXl7Q1NTErVu3kJOTAwBIS0vDggULyjVAQhSR/uwF8rM+QVVTE7V7dEaDSWOgY2Wp7LAIIYR8RaUq3Pzvf//DunXrsGHDBqgXmTvEzc0Nt27dKrfgCFGUcPK+Go3rUz8bQgj5RpWqcPPkyRO0bSvZj4HP5yM1NbWsMRFSasLJ+wpychGzbS/yMjKVHBEhhJCvrVSFGxMTE8TExEikX7hwATY2NmUOipDSSr5dWHOTfOsuzvuMRX5WlpIjIoQQ8rWVqnDj5+eH8ePH4+rVq+BwOHj79i127NiByZMnY/To0eUdIyFyYYwh+fZ90XPDxs7QNDZSYkSEEEKUoVRDwadNmwaBQICOHTsiKysLbdu2BY/Hw+TJkxEQEFDeMRIil4xXb5CbkgpwOABjNAScEEK+UQoXbgoKCnDx4kX4+/tjypQpiImJQUZGBpycnKCjo1MRMRIil+RbhfPbqKipQZCXR4UbQgj5RilcuFFVVUWnTp3w6NEj6Ovrw8nJqSLiIkRhwsn7BHl5UOFyUeu7FkqOiBBCiDKUqs+Ns7MzXrx4Ud6xEFIqgoICxEdexJsjp0Vpxq7NoK6trcSoCCGEKEup+tz873//w+TJkzFv3jy4uLhA+4svET09vXIJjpCSxIYdxZWJM5D1b7xYupapiZIiIoQQomwcxhhTdCcVlf8qfDgcjujvqrAqeHp6Ovh8PtLS0qgQVsXFhh3F2f4jABkv4Q57N8O6d7evHBUhhJCKoMj3N60KTqokQUEBrkycIbNgAw4HV3+Zido9O9NMxYQQ8o1RuHCTl5eHuXPnYt26dbCzs6uImAgpUWLUFYmmKDGMIfPNWyRGXYFpe7evFxghhBClU7hDsbq6Ou7evVsRsRAit6z4xHLNRwghpPoo1WipwYMHY9OmTeUdCyFy0zKtVa75CCGEVB+l6nOTn5+PzZs3Izw8XOpoqT/++KNcgiNEllptWkHL3BRZcTKapjgcaFuYolabVl83MEIIIUpXqsLN/fv30bRpUwDA06dPxbYVHT1FSEVRUVWFUcumeBV2VHLj59dgyz/+R52JCSHkG0SjpUiVFHvgmKhgo6ajjfyMTNE2bQtTtPzjfzQMnBBCvlGl6nNDiDKlPn6GqOGFC7TW+2ko1HUKm0UtunRElzNh6Pf8BhVsCCHkG1aqmht3d/dim5/Onj1b6oAIKU5u+kec6e2DvI8ZMGnnCn1HOzxZvxX6jvbosG8z1DQ0lB0iIYR8swoKChAVFYX4+HiYmpqiTZs2UFVC94BSFW4aN24s9jwvLw/R0dG4f/8+hg0bVh5xESKBCQQ47xOAtCcx0DI3hfvOv6FZyxiatYyhV9eaCjaEEKJEYWFhGD9+PP79919RmoWFBVauXInevXt/1VhKtfyCLHPmzEFGRgaWLl1aXocsd7T8QtUVvWA5bs1aBBUuF93OHYJRi6bKDokQQggKCzZ9+/bFl0UKYSvPvn37ylzAUeT7u1wLNzExMWjRogU+fPhQXocsd1S4qZr+PXEWp7oPBBiD67qlyE1Jhd3wAdA0qqns0Agh5JtWUFAAa2trsRqbojgcDiwsLPDy5csyNVEp8v1drh2KL1++DA1qGiDlLP1FLCIHjwYYQz2/IVBRUcGN6f/DP807IT87W9nhEULINy0qKkpmwQYoXFT7zZs3iIqK+moxlarPzZdVS4wxxMfH48aNG5g1a1a5BEYIAORlZuJMn+HITUmFUcumcP5lFA417wQAcBo7gvrZEEKIksXHF7POXynylYdSFW74fL7YcxUVFdSrVw9z585Fp06dyiUwQhhjuPjTJKTcfQgN45pw37UB54cHID8jE8ZuLVB/4ihlh0gIId88U1PTcs1XHsq1z01VQH1uqo4HK//G1V9+B0dNDV1O70Ny9D1cnTgLalqa6HU7Anq2dZQdIiGEfPOEfW7i4uIkOhQDVajPzfXr13H16lWJ9KtXr+LGjRulOSQhYuIjL+LalEAAQIulc6BhXBM3ps8HADQPmkMFG0IIqSRUVVWxcuVKmQUbAFixYsVXne+mVIUbf39/vHnzRiI9Li4O/v7+ZQ6KfNsy3sQh4kc/sIIC1B3UF05jR+LWrEUoyM6GmUc7OIyiuZQIIaQy6d27N9zc3CTSLSwsymUYuKJK1efm4cOHooUzi2rSpAkePnxY5qDItys/Oxtn+/ki+10yDBs7w23dEnA4HHy3cTk0ahmh4a8BtDgrIYRUMgKBAE+ePAEA/Pnnn6hZs2bVm6GYx+MhMTERNjY2Yunx8fFQUyvVIQkBYwxXAqbj/fVo8AwN0HHfZqhpaQEAuHw9uP61SMkREkIIkebu3bt4//49dHR0MGrUKKirqys1nlI1S3Xq1AnTp09HWlqaKC01NRW//fYbPD095T7O+fPn4e3tDTMzM3A4HBw8eLDY/JGRkeBwOBKPhISE0lwGqWSebNiGp5tDwVFRQfsd66BlZoLnofultuMSQgipPE6fPg0AaNeundILNkApCzdLly7FmzdvYGVlBXd3d7i7u6NOnTpISEjAsmXL5D5OZmYmGjVqhNWrVyt0/idPniA+Pl70MDY2VvQSSCWTdOUGroz7DQDQ9H/TYd6pPW4HLsG5IWNw3idAydERQggpTnh4OAAoVMFRkUrVhmRubo67d+9ix44duHPnDjQ1NTF8+HAMGDBAoRJbly5d0KVLF4XPb2xsDH19fYX3I5VTVkISzvYbAUFeHqy+74aGUwOQeOk67i0pLPRa9eqq5AgJIYTIkp2djfPnzwMAPDw8lBxNoVJ3kNHW1sZPP/1UnrHIrXHjxsjJyYGzszPmzJkjtYe2UE5ODnJyckTP09PTv0aIRE6CvDxE/OiHrLcJ0He0R9vgP5GflYWo4QFgAgHqDu4H6++pcEMIIZXVpUuXkJ2dDVNTUzg5OSk7HABlWFvq+fPnCAgIgIeHBzw8PDBu3Dg8f/68PGOTYGpqinXr1mH//v3Yv38/LC0t0b59e9y6dUvmPgsXLgSfzxc9LC0tKzRGophrU+YgMeoK1PV00XF/MNR1dXBj+v+QHvMSWuamaLVyvrJDJIQQUgxhk5SHh0elGc1aqsLNyZMn4eTkhGvXrqFhw4Zo2LAhrl69ivr164s6FVWEevXq4eeff4aLiwtcXV2xefNmuLq6Yvny5TL3EXZ8Fj6kzc9DlCNm+z48XLURANAu5C/w69ni7ZnzeLR6MwCgzcYV4OnzizsEIYQQJRN+71eWJimglM1S06ZNw8SJE7Fo0SKJ9F9//fWrdihq0aIFLly4IHM7j8cDj8f7avEQ+STfvoeLP08CADSe+Qtq9+gMQV4eLvz0CwDAYZQPzDu1V2KEhBBCSvLhwwfcvHkTQOUq3JSq5ubRo0cYMWKERLqvr+9Xn8QvOjr6qy7GRcouO/kDzvQdjoLsbFh07ojGv08GAKioq6P9jnWw6NwRzRf/ruQoCSGElOTs2bNgjMHJyQlmZmbKDkekVDU3RkZGiI6Ohp2dnVh6dHS0QsOyMzIyEBMTI3r+8uVLREdHw9DQELVr18b06dMRFxeHrVu3Aihcm6JOnTqoX78+srOzsXHjRpw9exanTp0qzWUQJRAUFCBy4ChkxL6Bbl1rtNu+BipFZq80btUMnY6GKjFCQggh8qpsQ8CFSlW48fPzw08//YQXL17A1dUVAHDx4kUsXrwYv/zyi9zHuXHjBtzd3UXPhfsOGzYMW7ZsQXx8PF6/fi3anpubi0mTJiEuLg5aWlpo2LAhwsPDxY5BKrdbsxbibfg5qGlpouP+YPAM9JH9Phmfkt7DwKmessMjhBCigKKdiSsTDivF9K+MMaxYsQLLli3D27dvAQBmZmaYMmUKxo0bV2l6S0ujyJLppHzF7j+Cs/0LmzPb71gHmx+/B2MMET/44c2RU3Bb/wdsB/dVcpSEEELk8fLlS9jY2EBNTQ0fPnyArq5uhZ5Pke/vUtXccDgcTJw4ERMnTsTHjx8BoMIvilRtKQ+f4LzvOACA8y+jYfPj9wCAFzvDELv/MDhqatB3sldmiIQQQhQgrLVp1apVpSsDlKpDcYcOHZCamgqgsFAjvKj09HR06NCh3IIj1UNuWjrO9PZBfkYmTN3d0GzhTABA1tsEXA6YDqBwxFTNpg2VGSYhhBAFVMYh4EKlKtxERkYiNzdXIj07OxtRUVFlDopUH0wgwLmh/kh/9gLaluZov3M9VNTUwBhD1MiJyE1NQ81mjdFo2jhlh0oIIUROAoEAZ86cASDemTg9PV1q+eBrU6hZ6u7du6K/Hz58KLYad0FBAU6cOAFzc/Pyi45UeXcWrMCbI6egyuOh477N0DSqCaBwBfC4k2ehyuOh7ZZVUKkEq8gSQgiRz+3bt0X9bJo3by5KP378OH799VfMnz8fgwYNUlp8ChVuGjduDA6HAw6HI7X5SVNTE6tWrSq34EjV9uZYOG7NCQIAtF69GDWbNQYAZLx6g2uTZwMAXBb8Bn1H6mtDCCFVibC/jbu7u9iC2T/88AM6dOiAlJQUZYUGQMHCzcuXL8EYg42NDa5duwYjIyPRNi6XC2NjY6gWmbOEfLvSY17i3ODRAGNw+HkY7IcPEG3TMjdFo+njER9xEfXHKWfxVUIIIaVX3BBwIyMjsfKBMpRqKHhVRkPBK15eRiaOuHVFyv3HMG7dDF3OHoAqlyuRjwkE4KiUeu1WQgghSvDp0ycYGBggJycHDx8+hKOjIxhjePjwIerXr19h51Xk+7tKrQpOKj/GGC74TUTK/cfQNDFGhz2bRAWbzLh45Gdni/JSwYYQQqqeixcvIicnB+bm5nBwcABQONDI2dkZXbt2RWWoM6lSq4KTyu/+8nV4uecQOGpqcN+9EVpmJgAAQV4ewr8fhn9adELqo6dKjpIQQkhpFR0CLpy0V9jf1srKqlJM5FvlVwUnlcfbs1G48etcAEDL5fNg8l1L0bY7C1ci+eYdcA30weVTcyAhhFRVX64n9erVKxw6dAgAEBAQoLS4iqryq4KTyiHj9b+IHPAzmEAA2yH94Th6uGjb+5t3ED1/OQCg9aqFotocQgghVcv79+9x+/ZtAEDHjh0BAGvWrIFAIEDHjh3h5OSkzPBESlW4Ea4K/iVFVwUn1UP+p08409cX2e+TUaNpQ7iuDRJVS+ZnZ+O8TwBYfj6s+3iLll0ghBBS9Zw9exaMMTg7O8PExARZWVnYuHEjgMpTawMoeVVwUvUxxnDZfxqSb94Br4YhOu7bDDVNTdH2W78vRurDJ9CsZQTXNYsrRVssIYSQ0vmySSo0NBQfPnyAtbU1unfvrszQxJSqcDNr1izo6upi2bJlmD69cG0gMzMzzJkzB+PG0TT635LH60LwLGQXOCoqaB+6DjpWlqJtCVFXcP+PtQAAt3VLoVGzhrLCJIQQUkaMMYn1pPbs2QMA8Pf3r1Tz3JV5npuqtio4zXNTfhIvXcfxDt9DkJeH5ot/R4PJ/mLbM169wXnfcdC1qo02m1cqKUpCCCHl4fnz57C1tYW6ujo+fPgAHR0d5ObmYv/+/fDy8oKhoWGFnl+R7+9S1dwUVVUKNaR8ZcUn4mw/Xwjy8mDdtwecJ42RyKNjZYkup/ejICdHCRESQggpT8Jam9atW0NHRwdA4eoEAwYMKG43pShVh+LExEQMGTIEZmZmUFNTg6qqqtiDVG8Fubk4+8NIfEpIgn79emizaYVYX5rctHTR3xwVFbE+OIQQQqqmov1tMjMzUVBQoOSIZCtVzY2Pjw9ev36NWbNmwdTUlDqJfmOuTZqNpIvXwOXroeP+LVDX0RZty0lJxcHG7rD09kKLoN+hpqWlxEgJIYSUh4KCApw9exZAYX+b+fPnY+fOnQgKCkK/fv2UHJ2kUhVuLly4gKioKDRu3LicwyGV3bOQ3Xi0ZjMAoO3W1eDb2YhtvzJ+BjL/fYu34eeUER4hhJAKcOvWLaSkpIDP56N+/fro3r07kpOTxVYEr0xK1SxlaWlZKdaOIF/X+5t3cGn0FABA498no3b3TmLbY8OO4vmOfeCoqKBt8J9Ua0MIIdVAQUEB1q9fDwBwdnbGnj17kJycDCsrK3h7eys5OulKVbhZsWIFpk2bhtjY2HIOh1RWn969x5m+vijIyYFlN080mTVJfHvSO1HBp8EUfxi3bq6MMAkhhJSjsLAwWFtbiybqu3jxIkaPHg0AGDNmTKXtZyt3s5SBgYFY35rMzEzUrVsXWlpaEtVSHz58KL8IidIJ8vMROWgUMl//Cz07G7TdulpsRW/GGC6OmoLs98kwaOiEJrOnKDFaQggh5SEsLAx9+/aVaKnJy8sDANSqVUsZYclF7sLNihUrKjAMUpndnLEA8WeioKathY77g8HT54ttj9m2F68PHYeKujrabvkLqjyekiIlhBBSHgoKCjB+/Phiu6DMmjULgwcPrpS1N3IXboYNG1aRcZBK6sWeQ7i3dDUAoM2mlTCo7yCRR11HGzxDA9Sf+DNqNKr/tUMkhBBSzqKiovDvv/8Wm+fNmzeIiopC+/btv05QClBotJRAIMCSJUvwzz//IDc3Fx07dsTs2bOhSfOYVEsp9x/hwsgJAIAGk/1Rp18Pqfmse3eDsWtzaNSs2NkpCSGEfB3x8fHlmu9rU6hD8fz58/Hbb79BR0cH5ubmWLlyJfz9/UvekVQ5OalpONNnOPIzs2DasQ1c5v8mkUeQny/6W8vEGCpqZZ7wmhBCSCVgamparvm+NoUKN1u3bsWaNWtw8uRJHDx4EIcPH8aOHTsgEAgqKj6iBEwgwPmh/kiPeQkdK0u4h/4tUXBJj3mJfQ6t8erQcSVFSQghpKK0adMGFhYWMrdzOBxYWlqiTZs2XzEq+SlUuHn9+jW6du0qeu7h4QEOh4O3b9+We2BEeW7PW4Y3R09DVUMDHfZtlljNW1BQgPO+45Dx8jUertpAcx4RQkg1o6qqipUrpS94LBw5vWLFikrZmRhQsHCTn58PDQ0NsTR1dXXRsDBS9b0+fBLRc5cCAFzXBKFm04YSee7/sRZJF69BXVcHbTatpOU3CCGkGmrbtq3Uz3cLCwvs27cPvXv3VkJU8lGokwRjDD4+PuAVGeqbnZ2NUaNGQVv7v/WFwsLCyi9C8tWkPX2Oc0ML+1A5jvGF3bAfJPKk3H+EW78vBgC0/GMedKwsv2qMhBBCvo5jx46BMQYdHR1kZGSgffv2mD17Ntq0aVNpa2yEFCrcSBsOPnjw4HILhihPXkYmzvQZjrz0jzB2a4EWywIl8hTk5uK8TwAEubmw7OYJu+GVb5l7Qggh5ePw4cMAgIyMDKirq2Pjxo2oW7eukqOSj0KFm+Dg4IqKgygRYwxRvuOR+vAJNE1rocOeTVDlciXy3VmwAsm374FnaAC3v5dRcxQhhFRTOTk5OHHihOj5qFGjqkzBBijl2lKkerm3dDVi9x+Giro6Ou7dBC0TY4k8jDF8SkgCALRevRhappV32m1CCCFlc+7cOWRkZAAAdHR0MHPmTCVHpBiamOQbF3f6HG7+Nh8A0HL5/2QueMnhcOC2binqjRyMms0af8UICSGEfG3//POP6O8pU6bA2FjyR29lRjU337CPsa8ROfBnMIEAdj4/wmFUyUtsUMGGEEKqN8aYqL9N37598csvvyg5IsVR4eYblf/pE8729UXOhxTUbNYYrVcvltqHJuH8ZZzqPgiZcZVzim1CCCHl6969e3j9+jU0NDQQEhICHR0dZYekMCrcfIMYY7g0eiqSb9+DRs0a6LB3E9S+mL8IAPI+ZuD88AD8ezwc94JWKSFSQgghX1tISAgAwNPTE1paWkqOpnSocPMNerRmM2K27QFHRQXuu9ZDp7b0KbavTp6NjNg30LG2hMv/JNeWIoQQUr0kJCRgxYoVAIAOHTooN5gyoMLNNyYh6gqu/vI7AKDZ4t9h6v6d1HxvjoXj6cbtAIA2m/+Eum7Vq5YkhBCimOnTp4vWi+zfv7+Soyk9Ktx8Q7LeJiDih5Fg+fmo80MvOE8cJTVfzocUXPipsANZ/fE/wbSd69cMkxBCiBI8e/YM27ZtAwDUq1cPZmZmSo6o9JRauDl//jy8vb1hZmYGDoeDgwcPlrhPZGQkmjZtCh6PB1tbW2zZsqXC46wOCnJzcbb/CHxKfAeDBo74bsMfMifhuxwwHZ/iE8F3sIPLfGqOIoSQb8GMGTNQUFAAABg0aJCSoykbpRZuMjMz0ahRI6xevVqu/C9fvkS3bt3g7u6O6OhoTJgwASNHjsTJkycrONKq7+qEmUi6fANcfT467t8C9SJrgRWVk5KK9zfvgKOqirbBf0JNU/MrR0oIIeRru3btGvbu3St67u3trcRoyo7DGGPKDgIonCTuwIED6NWrl8w8v/76K44ePYr79++L0n788UekpqaKTRNdVE5ODnJyckTP09PTYWlpibS0NOjp6ZVb/JXZ082huOA3EeBw4Hl4Byy7dCw2f35WFuIjL8Gyq8dXipAQQoiyMMbQoUMHREZGAgAsLS3x6tWrSrfETnp6Ovh8vlzf31Wqz83ly5fh4SH+hevl5YXLly/L3GfhwoXg8/mih6Xlt7WK9bvrt3HJ/1cAQNM5U0ss2ACAmpYWFWwIIeQb8f79e8TFxUFFpbBI4O3tXekKNoqqUoWbhIQE1KolvqZRrVq1kJ6ejk+fPkndZ/r06UhLSxM93rx58zVCrRQ+Jb3D2b6+EOTmora3Fxr9NkFm3phte3F/+Tqwz73kCSGEfBuMjIxw7949GBgYAAB69Oih5IjKrtqvLcXj8cDj8ZQdxlcnyM9HxICfkPnvW+jZ10XbkL/AUZFels149QaXA6Yh72MGeDUMYTe06g7/I4QQorh79+4hOTkZOjo6aN++vbLDKbMqVXNjYmKCxMREsbTExETo6elBkzq+irk+bR4SIi9BTUcbHfcHg8uX3j7JBAJEjZyAvI8ZMHZtjrqD+nzlSAkhhChDTk4O1q9fj9zcXNFaUp06daoWFQJVquamdevWOHbsmFja6dOn0bp1ayVFVDk93xmGB8vXAQDabv4TBk71ZOZ9tGYz4s9egJqWJtoGr4KKqurXCpMQQogSrVmzBr/88gt27NiB9PR0ANWjSQpQcs1NRkbG/9u7+7ia7/6B469TVJISkSjl/m4jCylaZXbFNndhNia6MBtamA0zzLWbmLGwmLthrrnYLGaGXdaYkLvCuLhszBQqN+lWonO+vz/8nEtUTnPuOuf9fDx6PHw/38/3+31/zuk47z6fz/fz5dixYxw7dgy4e6v3sWPHSE1NBe7Ol4mIiNDWf+211/jjjz94++23+e9//8vixYv5+uuvmTBhginCN0tZv/6HvaPuLsDXdnIUPv1fKLNuzm/nODzlAwA6fjwT56aNjBKjEEII08rJyeGDD+7+///CCy9w7NgxVCoVzz33nIkj0w+TJjdHjhyhffv2tG/fHoCJEyfSvn17Zsy4+3iA9PR0baID0KhRI3744Qd27txJu3btmDdvHitWrCAsLMwk8ZubohvZJPSPRF1YSINnQ3jq/all1tUUF7MnMgp1YSH1n3malqOHGTFSIYQQpjRnzhyysrJo1aoVDv//4OTAwEDq1Klj4sj0w6TDUiEhIZS3zE5pqw+HhIRw9OhRA0ZVOWnUan55ZQx5f1zAyceL4K+WlDvEdPXQUa4n/4qdizNdV8aWOdlYCCGEZbl06ZL24ZizZ89myZIlQOVfuO9+lWrOjSjb0VlzubgjAVsHB575djUOtWuVW989sCO9DuygIO0STl4NjBSlEEIIU5s1axaFhYV06dKF0NBQBg4cCFhWcmM2KxQbS0VWOKwsLmzeRkL/SACeXhNH01cGmDgiIYQQ5uj06dM88cQTaDQa9u7dS2ZmJv3796dJkyb8/vvvZr14X0W+v6XnppLLOXOWPcOjAGgdNfKRic3pJauo27kDtds/aYzwhBBCmBFbW1vt7d5dunQhMvLuH8aWsCrx/aTnphK7k5fP9wE9yT79G/WeDqDHv7/BpmrVMutfOXCEH4J6gY0N4Sf24NK8iRGjFUIIYS4KCwuxs7PDw8ODq1evkpCQQLdu3UwdVrks9tlS4n8URWFP5Btkn/4NxwYehK5fVm5iU3zzJnsi30DRaGg8qK8kNkIIYUUe7MeoVq0aBw8e5OrVq7i4uBAUFGSiyAxDkptK6tc5C7mw6Qds7Ozo9s1KqrnXLbf+kXc+JPe3czg28KDzgg+NFKUQQghz8OGHHxIREUFeXp627N6qxD179qRqOX8cV0Yy56YSuvTv3SS/GwNA5wUfUtffr9z6l39O5NSiFQB0Xf4p9q41DR2iEEIIM5GYmMjMmTPRaDS88MILvPji3ecHbtmyBbCcVYnvJz03lUze+QvsGjwaFIXmI4bQ8tWIcuvfzsklccR4AFqOHoZnWKgRohRCCGEOrl+/zuDBg9FoNAwdOlSb2Pzxxx+cOnUKW1tbevToYeIo9U+Sm0qk+OZNEvpHcvtGNm6d2hOwKOaRx5xZvpaC1IvUaOxNx49nGiFKIYQQ5kBRFCIjI7l48SLNmzdn8eLF2n33hqSCgoJwdXU1VYgGI8NSlYSiKOwbPYms4//BoU5tnvnmC2x1eHLrExNfx8auKrXbt6WqU3UjRCqEEMIcLFy4kO+//x57e3s2bNiAk5OTdp8lD0mBJDeVxqlFyzm37ltUtraEblhBdc/6Oh2nsrGhzRuvGjg6IYQQ5iQ5OZm33noLgHnz5uHr66vdl52dzZ49ewDLWpX4fjIsVQmk/7KfQ5PeA6DT3Jl4BAc+8pjfvljHnYICA0cmhBDCHBUUFFCrVi369evHmDFjSuzbsWMHxcXFtGzZkqZNm5ooQsOSnhszV3DxMrteGoWiVtP45XBa69AL88f6TewdNYGT85fQJ/knnYavhBBCWI6nn36a48ePY2dn99DKw/fm21jqkBRIcmPW1EVF/PziCG5duUatdm3oumzeI5fHvnk5g/3jpgDQ6MU+ktgIIYQVuXXrFg4ODgC4u7s/tP/OnTts27YNsNwhKZBhKbOW9MY7XD2Ygp1rTbpt/IIqjo7l1lcUhb2jJnL7Rja1/drRbmq0kSIVQghhaqdOnaJRo0Zs2LChzDr79u0jOzub2rVrExAQYMTojEuSGzN1ZvlaflvxT1CpCPnnEpwb+zzymN9W/JOLOxKwtbfn6dWLyn0cgxBCCMtRWFjIoEGDyMjIYOXKlQ89bkGtVrN7927mzp0L3F2V2NbW1hShGoUkN2boysFkkt54BwC/96fg2ePRDzPLO3+Bg5PurmPz1AdTcW3dwqAxCiGEMB8TJkzg5MmTuLu7s3bt2hJTGOLj4/Hx8SE0NFQ7JLV9+3bi4+NNFa7BSXJjZgozr/DzwBFobt/Gu+9ztJ2i29DSwTdnUpxfgHtQZ9pEy63fQghhLb755huWLl2KSqVi7dq1JebaxMfHM2DAAC5evFjimKysLAYMGGCxCY4kN2ZEc+cOu156lZuX0nFp2YygVQsfOYH4nsC4Ofj070XQygXYWHBXoxBCiP85f/48I0eOBGDKlCk8++yz2n1qtZro6OiHhqjgf08JHz9+PGq12jjBGpEkN2bk0NuzyNiTRNUaTjzz7SrsnGvofKyjhzvdvl6BcxMfwwUohBDCbNy5c4eXXnqJ3NxcAgMDmTVrVon9iYmJD/XY3E9RFNLS0khMTDR0qEYnyY2ZOPfVRk4tXA7A06sXUbNls0ceoyku5tJPvxg6NCGEEGZIURS6du2Kq6sr69ato+oDN5Gkp6frdB5d61UmktyYgevHTrJ39CQA2r0zHu++z+l03K+zF/Jj2IscmPCuIcMTQghhhuzs7Jg3bx5nzpzB29v7of0eHh46nUfXepWJJDcmVpR1g4QBkagLC2kQ1o32772t03HXj57g6PvzAKjTwdeAEQohhDAnWVlZFBcXa7fr1KlTar2goCA8PT3LnLupUqnw8vIiKCjIIHGakiQ3JqRRq9k9+DXyz6dSo7E3If9crNNkYHVREXuGj0MpLsa73/M0HtzfCNEKIYQwNbVaTf/+/QkODiY1NbXcura2tixYsKDUCcX3Ep7Y2FiLXO9GHr9gQikzZnNp525sq1Wj28ZV2Ndy1e24mR9z4+R/cajrRuCSj3W+o0oIIUTl9uGHH7J7926qV69OYWHhI+v7+vpiY2ODRqMpUe7p6UlsbCzh4eGGCtWkJLkxkT/jf+DX2QsB6Lp8PrXbtdHpuMz9hznxSRwAXT7/hGp13AwWoxBCCPPxyy+/aO+IWrx4MS1aPHqx1piYGDQaDWFhYUyZMoX09HQ8PDwICgqyyB6beyS5MYHs07+xJzIKgDbjR9PkZd0yZ/Xt2yRGRoGi0DRiEN59ehoyTCGEEGbi2rVrDBkyBI1GQ0REBBEREY88JjU1lTVr1gAwY8YMAgMDDR2m2ZA5N0Z2OzePhP6RFOcXUC8kkI5zZuh8rK2dHZ0+mYVbR186x35gwCiFEEKYC0VRiIyM5NKlS7Ro0YK4uDidjpszZw537tyhW7duVpXYgPTcGJWi0bBn2Dhyzpylumd9Qv+1DJsqFXsLGvYKw+uFv8k8GyGEsBILFy5k69at2Nvbs379epycnB55zOXLl1m5ciUA06dPN3SIZkeSGyM6PnsBqVt2YGNnR7dvVlKtbum37z2oKDuH4oKbVG9wdy0CSWyEEMJ6hIWF0bZtW1599VV8fX11Ombu3LkUFRXRtWtXgoODDRugGVIppd0jZsFyc3NxcXEhJycHZ2dno103bXsCO3sNAUWh67L5NB8xROdj9wyPIvX7H3l61UIa9u5hwCiFEEKYo6KiIuzs7HT64/bKlSv4+PhQWFjIjz/+yN/+9jcjRGh4Ffn+ljk3RpB77k9+eeV1UBRavBpRocTmwuZtnF37NXdy83CoU9uAUQohhDAXGRkZfPHFF9pte3t7nXvt582bR2FhIR07dizxIE1rIsNSBnanoICE/sO5nZ1Dnc5+FZoIXHj1GvtefwuAJ98aS92AjoYKUwghhJlISkqif//+pKenU6tWLfr27avzsdevX9dOOJ4+fbrVTmOQnhsDUhSFvaMmcuPEaaq516Hb1yuxtbfX+dj9r7/NrSvXcH2yFe1nvmXgaIUQQpiSoigsWbKE4OBg0tPTad26NW3a6LYG2j2xsbEUFBTg6+vLCy+8YKBIzZ8kNwb0nwVLOb9hM6oqVQjdsEI7IVgXf6z7lgubfsCmalWeXv2ZzkmREEKIyufWrVuMGDGCMWPGcOfOHQYOHMjBgwdp1qyZzufIzs5m4cK7i8O+++67VttrAzIsZTDpu/Zy+O1/AOA/bxb1gjrrfGzBpXSS3ngHAN8Zb1Lb9wmDxCiEEML0UlNTCQ8PJzk5GRsbG2bPns2kSZMqnJwsWrSI3Nxc2rRpQ79+/QwUbeUgyY2eaNRqMhMPcDM9E5WtLUlRU1DUapq8MpBWY0dU6Fz2ri40fWUAVw8fpe3bUQaKWAghhDnYu3cvycnJ1K5dm/Xr19O9e/cKnyMvL4/Y2FgApk2bho2NdQ/MSHKjB3/G/8CBCdO4eTG9RLmTjxddPp9b4ey7iqMjnRd8hLqoqMKL/AkhhKhcBg8eTGZmJuHh4Xh7e/+lcyxevJisrCyaN2/Oiy++qOcIKx/rTu304M/4H/j5xREPJTYA+RfSuLj9Z53PVZR1A+W+J7fKPBshhLA8+fn5jBs3jszMTG3ZhAkT/nJiU1BQwLx58wB45513LPqBmLoyi+QmLi4OHx8fHBwc8Pf359ChQ2XWXb16NSqVqsSPg4ODEaP9H41azYEJ06DMdRBVHJz4Lhq1Wqdz/dRvGNufCSf/Qpp+AxVCCGEWfv/9dwICAoiLi2Po0KHoYx3dZcuWcfXqVRo1asTgwYP1EGXlZ/LkZsOGDUycOJGZM2eSkpJCu3btCAsL48qVK2Ue4+zsTHp6uvbnwoULRoz4fzITD5TaY6OlKBSkXSYz8cAjz/Wf2KVk7j3I9aMn9PLLLoQQwrxs3bqVjh07cvLkSerVq8d777332Hc03bp1i7lz5wIwdepUqlatqo9QKz2TJzfz589n1KhRREZG0rp1az7//HMcHR1LrMz4IJVKRb169bQ/7u7uRoz4f26mZz66kg71bvznvyS/GwOA/7x/UMOn4WPHJoQQwjxoNBpmzZpFr169yMnJITAwkJSUFL08qXvlypWkp6fj5eXFsGHD9BCtZTBpcnP79m2Sk5NLzAy3sbGhe/fuJCUllXlcfn4+3t7eeHl50adPH/7zn/+UWbeoqIjc3NwSP/ri6KFbUlVePc2dO+wZHoXm9m28nutOs79Ll6IQQliKnJwc+vbty3vvvQfA2LFj2bVrFx4euq97Vpbbt28zZ84cACZPnoydnd1jn9NSmDS5uXbtGmq1+qGeF3d3dzIyMko9pkWLFnzxxRd89913/POf/0Sj0RAYGMjFixdLrR8TE4OLi4v2x8vLS2/xuwd1xtHTA8rqVlSpqO5VH/dy1rg59lEs11N+xc61Jl2WzbfqRZeEEMISnTlzBnt7e1avXs1nn32mtyRkzZo1pKWl4eHhwYgRFVtyxNKZfFiqogICAoiIiMDX15fg4GDi4+OpU6cOS5cuLbX+1KlTycnJ0f6kpelvsq6NrS2dP/3w7saDScn/b/vP/wCbMmauXztyjOMffgpA4Gezde4JEkIIUTm4uLiwefNm9u3bp9dhozt37hATc3c6w1tvvWWyG2vMlUmTGzc3N2xtbUvcDgeQmZlJvXr1dDpH1apVad++PWfPni11v729Pc7OziV+9Mkn/Hm6fb0SxwYl463u6UG3r1fiE/58mcfa2NtRs3VzGg3sTeOXrHs1SSGEsATFxcW8/fbb2scgALRq1Qo/Pz+9XmfdunWcP3+eOnXqMHr0aL2e2xKYdIU4Ozs7/Pz8SEhI0D71VKPRkJCQwLhx43Q6h1qt5sSJEzz33HMGjLR8PuHP07BPD+0KxY4e7rgHdS6zx+aeWk+2pvfBH1HfKjJSpEIIIQzl6tWrvPTSS/z8889UqVKF3r174+Pjo/frqNVqPvroIwDefPNNHB0d9X6Nys7ky99OnDiRYcOG0aFDBzp16qR9omlkZCQAERERNGjQQNv99o9//IPOnTvTtGlTsrOzmTt3LhcuXGDkyJGmbAY2trZ4hHTRqa66qEi7QJ+tvb0s1ieEEJVccnIy4eHhpKamUr16dVavXm2QxAbg66+/5rfffqNWrVqMGTPGINeo7Eye3AwaNIirV68yY8YMMjIy8PX1ZceOHdpJxqmpqSWekXHjxg1GjRpFRkYGrq6u+Pn5sX//flq3bm2qJlTInbx8vuv0N5oOGUDbKW/I4xWEEKKSW716Na+99hpFRUU0a9aMTZs20aZNG4NcS6PR8OGHd+d6jh8/nho1ahjkOpWdSrGyFeNyc3NxcXEhJydH7/NvdLHvtUmcWb4WJ28v+h7bhZ2z/GIKIURlFR0drZ1f06tXL7788ktq1qxpsOt9++23DBgwAGdnZy5cuGDQa5mbinx/V7q7pSqzizt+5szytQAErYyVxEYIISo5b29vVCoVs2bNYvPmzQZNNhRF4YMPPgDgjTfesKrEpqJkTMRIim5ks3fUBABaR43EI7SriSMSQgjxV9y5c0f7mIMJEyYQHBys97uhSvPDDz9w7NgxnJycGD9+vMGvV5lJz42RJEVN5eblDJybN6HDR9NMHY4QQogKUhSFuLg4/Pz8tKvdq1QqoyQ2iqLw/vvvAzBmzBhq165t8GtWZpLcGMH5jd/zx7/iUdnY8PTqRVSR2/aEEKJSKSwsJDIyknHjxnHixIlyn39oCDt37uTQoUNUq1aNN99806jXroxkWMoIbmfnYOvgwBMTX6Ouv+EzfCGEEPpz4cIFwsPDSUlJwcbGho8//pjo6GijXf/+XpvRo0dTt25do127spK7pYwk5/c/cPL2xFYebCaEEJXGTz/9xEsvvcT169dxc3Njw4YNdOvWzagx7N69m9DQUOzs7Dh//jz169c36vXNRUW+v6XnxoAURdE+CNOlWWMTRyOEEKIi1q9fz5AhQ9BoNHTo0IFvv/2Whg0bGuXaarWaxMRE0tPTmTt3LgAjRoyw2sSmomTOjYHkp15ki38YmfsPmzoUIYQQf0FISAj16tUjMjKSxMREoyU28fHx+Pj4EBoayuDBgzl69CgA7dq1M8r1LYEMSxmAotGwo8eLpCckUrdLJ57/ZYu2B0cIIYT5unbtGm5ubtrtzMxM6tata7T/w+Pj4xkwYAClfTWrVCo2btxIeHi4UWIxN7KIn4mdXrKK9IREbKtVI2jlAklshBCiEtiyZQtNmjRh3bp12jJ3d3ej/R+uVquJjo4uNbG5Z/z48ajVaqPEU5lJcqNnOb//weHJd2e1d5wzXebaCCGEmdNoNMycOZM+ffqQm5vLl19+WW6CYSiJiYlcvHixzP2KopCWlkZiYqIRo6qcJLnRI41aTWJkFOrCQjyeCaLV65GmDkkIIUQ5bty4Qa9evfjHP/4BQFRUFN9//71JetzT09P1Ws+ayd1SenTikziuJB2hqnMNglbEorKR3FEIIczViRMn6NevH+fOncPBwYFly5YxdOhQk8SSkZHBqlWrdKrr4eFh4GgqP0lu9ERRFK4dujujvfOnH+DU0NPEEQkhhChLeno6AQEBFBQU4O3tTXx8PE899ZTR4yguLmbx4sVMnz5d+0iHsqhUKjw9PQkKCjJSdJWXdC3oiUqlotvGL3h26zqaDhtk6nCEEEKUw8PDg6ioKJ599lmSk5NNktjs3bsXPz8/oqOjyc3NpUOHDsyePRuVSvXQsNi97djYWGxtbY0ea2Ujt4ILIYSwSvfuOjJ2spCZmcnkyZNZs2YNAK6ursTExDBy5EhsbW2Jj48nOjq6xORiLy8vYmNjrfY2cKjY97ckN0IIIYQRFBcXs2TJEqZPn05OTg4AI0eOJCYmpsTaOlByhWIPDw+CgoKsvsdGHr8ghBBCmJF9+/YxduxYjh8/DoCfnx9xcXH4+/uXWt/W1paQkBAjRmhZZM6NEEIIYSBXrlwhMjKSrl27cvz4cVxdXVmyZAkHDx4sM7ERj096boQQQgg9Ky4u5vPPP+fdd9/VDkGNGDGCmJgY6tSpY+LoLJ8kN0IIIYQe7d+/n7Fjx3Ls2DEA2rdvz+LFi+ncubNpA7MiMiwlhBBC6MGVK1f4+9//TpcuXTh27Bg1a9Zk8eLFHD58WBIbI5OeGyGEEOIxqNVqli5dyrRp08jOzgbg73//O7Nnz5YhKBOR5EYIIYT4iw4cOMDYsWNJSUkBwNfXl8WLFxMQEGDiyKybDEsJIYQQFXT16lVGjhxJQEAAKSkp1KxZk88++4wjR45IYmMGpOdGCCGE0JFarWbZsmVMmzaNGzduABAZGcns2bOpW7euiaMT90hyI4QQQujg4MGDjBkzpsQQVFxcHIGBgSaOTDxIhqWEEEKIcly7do1Ro0bRuXNnUlJScHFxYdGiRRw+fFgSGzMlPTdCCCFEKdRqNStWrGDq1KnaIahhw4YxZ84c3N3dTRydKI8kN0IIIcQDDh06xNixYzly5AgAbdu2JS4ujq5du5o4MqELSW6EEEJYlfKeuH3t2jXeeecdVqxYgaIoODs78/777zNmzBiqVJGvzMpC3ikhhBBWIz4+nujoaC5evKgt8/T05NNPPyUrK4upU6eSlZUFQEREBHPmzKFevXqmClf8RZLcCCGEsArx8fEMGDAARVFKlF+8eJGBAwdqt5988kni4uIICgoydohCT+RuKSGEEBZPrVYTHR39UGJzP5VKxfz580lJSZHEppKT5EYIIYTFS0xMLDEUVRpFUWjfvr3MrbEAktwIIYSweOnp6XqtJ8ybJDdCCCEsnoeHh17rCfMmyY0QQgiLFxQUhKenJyqVqtT9KpUKLy8vmWtjISS5EUIIYfFsbW1ZsGABwEMJzr3t2NhY7Xo3onKT5EYIIYRVCA8PZ+PGjTRo0KBEuaenJxs3biQ8PNxEkQl9M4vkJi4uDh8fHxwcHPD39+fQoUPl1v/mm29o2bIlDg4OPPnkk2zbts1IkQohhKjMwsPD+fPPP9m1axfr1q1j165dnD9/XhIbC2Py5GbDhg1MnDiRmTNnkpKSQrt27QgLC+PKlSul1t+/fz8vv/wyI0aM4OjRo/Tt25e+ffty8uRJI0cuhBCiMrK1tSUkJISXX36ZkJAQGYqyQCqlvBWNjMDf35+OHTvy2WefAaDRaPDy8iIqKoopU6Y8VH/QoEEUFBSwdetWbVnnzp3x9fXl888/f6h+UVERRUVF2u3c3Fy8vLzIycnB2dnZAC0SQgghhL7l5ubi4uKi0/e3SXtubt++TXJyMt27d9eW2djY0L17d5KSkko9JikpqUR9gLCwsDLrx8TE4OLiov3x8vLSXwOEEEIIYXZMmtxcu3YNtVqNu7t7iXJ3d3cyMjJKPSYjI6NC9adOnUpOTo72Jy0tTT/BCyGEEMIsWfwa0/b29tjb25s6DCGEEEIYiUl7btzc3LC1tSUzM7NEeWZmZpmPmK9Xr16F6gshhBDCupg0ubGzs8PPz4+EhARtmUajISEhgYCAgFKPCQgIKFEfYOfOnWXWF0IIIYR1Mfmw1MSJExk2bBgdOnSgU6dOxMbGUlBQQGRkJAARERE0aNCAmJgYAKKjowkODmbevHk8//zzrF+/niNHjrBs2TJTNkMIIYQQZsLkyc2gQYO4evUqM2bMICMjA19fX3bs2KGdNJyamoqNzf86mAIDA1m3bh3vvvsu77zzDs2aNWPz5s088cQTpmqCEEIIIcyIyde5MbaK3CcvhBBCCPNQke9vk/fcGNu9XC43N9fEkQghhBBCV/e+t3Xpk7G65CYvLw9AFvMTQgghKqG8vDxcXFzKrWN1w1IajYbLly9To0YNVCoVHTt25PDhwyXqPFhW3va9f997rENaWppehrtKi+uv1i1rv6W3vSL7HvValFY/ISHBLNtd3n5Lf8/L2y9tN6+2V6Tdj6r/OO1+sEzec/Ntu6Io5OXlUb9+/RJzcUtjdT03NjY2eHp6ardtbW0fesMeLCtv+8F9zs7OevkFKC2uv1q3rP2W3vaK7HvUa1FefXNrd3n7Lf09L2+/tN282l6Rdj+q/uO0+8Eyec/Nu+2P6rG5x+RPBTe1sWPHPrKsvO3SjjdUXH+1bln7Lb3tFdn3qNdCl/qPS95z/dSVtutWbuq2V/Scf+Wzrku7HyyT91y36/5V+mx7eaxuWMpQrPkuLGttu7W2G6Tt0nbraru1thsqb9utvudGX+zt7Zk5c6ZVPsfKWtture0Gabu03brabq3thsrbdum5EUIIIYRFkZ4bIYQQQlgUSW6EEEIIYVEkuRFCCCGERZHkRgghhBAWRZIbIYQQQlgUSW6MLC0tjZCQEFq3bk3btm355ptvTB2SUfXr1w9XV1cGDBhg6lAMbuvWrbRo0YJmzZqxYsUKU4djVNb0Pt9jzZ/t7OxsOnTogK+vL0888QTLly83dUhGd/PmTby9vZk0aZKpQzEaHx8f2rZti6+vL6GhoaYOpwS5FdzI0tPTyczMxNfXl4yMDPz8/Pjtt9+oXr26qUMzit27d5OXl8eaNWvYuHGjqcMxmOLiYlq3bs2uXbtwcXHBz8+P/fv3U7t2bVOHZhTW8j7fz5o/22q1mqKiIhwdHSkoKOCJJ57gyJEjVvP7DjBt2jTOnj2Ll5cXn3zyianDMQofHx9OnjyJk5OTqUN5iPTcGJmHhwe+vr4A1KtXDzc3N7KyskwblBGFhIRQo0YNU4dhcIcOHaJNmzY0aNAAJycnevbsyb///W9Th2U01vI+38+aP9u2trY4OjoCUFRUhKIoWNPfzb///jv//e9/6dmzp6lDEf9PkpsH7Nmzh169elG/fn1UKhWbN29+qE5cXBw+Pj44ODjg7+/PoUOH/tK1kpOTUavVeHl5PWbU+mHMtpu7x30tLl++TIMGDbTbDRo04NKlS8YI/bFZ6++BPtttbp/tR9FH27Ozs2nXrh2enp689dZbuLm5GSn6x6OPtk+aNImYmBgjRawf+mi3SqUiODiYjh078tVXXxkpct1IcvOAgoIC2rVrR1xcXKn7N2zYwMSJE5k5cyYpKSm0a9eOsLAwrly5oq1zb9z5wZ/Lly9r62RlZREREcGyZcsM3iZdGavtlYE+XovKylrbrq92m+Nn+1H00faaNWty/Phxzp8/z7p168jMzDRW+I/lcdv+3Xff0bx5c5o3b27MsB+bPt7zvXv3kpyczJYtW/joo4/49ddfjRX+oymiTICyadOmEmWdOnVSxo4dq91Wq9VK/fr1lZiYGJ3Pe+vWLSUoKEj58ssv9RWq3hmq7YqiKLt27VL69++vjzCN4q+8Fvv27VP69u2r3R8dHa189dVXRolXnx7n96Cyvc/3+6vtrgyf7UfRx2f/9ddfV7755htDhmkQf6XtU6ZMUTw9PRVvb2+ldu3airOzszJr1ixjhv3Y9PGeT5o0SVm1apUBo6wY6bmpgNu3b5OcnEz37t21ZTY2NnTv3p2kpCSdzqEoCsOHD6dbt24MHTrUUKHqnT7abil0eS06derEyZMnuXTpEvn5+Wzfvp2wsDBThaw31vp7oEu7K+tn+1F0aXtmZiZ5eXkA5OTksGfPHlq0aGGSePVJl7bHxMSQlpbGn3/+ySeffMKoUaOYMWOGqULWC13aXVBQoH3P8/Pz+fnnn2nTpo1J4i2NJDcVcO3aNdRqNe7u7iXK3d3dycjI0Okc+/btY8OGDWzevBlfX198fX05ceKEIcLVK320HaB79+4MHDiQbdu24enpWSm/EHV5LapUqcK8efMIDQ3F19eXN9980yLuHNH198AS3uf76dLuyvrZfhRd2n7hwgWCgoJo164dQUFBREVF8eSTT5oiXL3S1/97lY0u7c7MzKRr1660a9eOzp07ExERQceOHU0RbqmqmDoAa9O1a1c0Go2pwzCZn376ydQhGE3v3r3p3bu3qcMwCWt6n++x5s92p06dOHbsmKnDMLnhw4ebOgSjady4McePHzd1GGWSnpsKcHNzw9bW9qGJcpmZmdSrV89EURmHNbf9Qdb8Wlhr26213SBtt8a2W0K7JbmpADs7O/z8/EhISNCWaTQaEhISCAgIMGFkhmfNbX+QNb8W1tp2a203SNutse2W0G4ZlnpAfn4+Z8+e1W6fP3+eY8eOUatWLRo2bMjEiRMZNmwYHTp0oFOnTsTGxlJQUEBkZKQJo9YPa277g6z5tbDWtltru0Habo1tt/h2m/p2LXOza9cuBXjoZ9iwYdo6ixYtUho2bKjY2dkpnTp1Ug4cOGC6gPXImtv+IGt+Lay17dbabkWRtltj2y293fJsKSGEEEJYFJlzI4QQQgiLIsmNEEIIISyKJDdCCCGEsCiS3AghhBDCokhyI4QQQgiLIsmNEEIIISyKJDdCCCGEsCiS3AghhBDCokhyI4QQQgiLIsmNEKJMPj4+xMbGardVKhWbN282WTwVMX36dF599VVTh2E2duzYga+vLxqNxtShCGFwktwIUUkMHz6cvn37mjSG9PR0evbsadIYdJGRkcGCBQuYNm3aY53Hw8OD2bNnlyibMmUKKpWK3bt3lygPCQlh6NChJcrWrFlD165dHyuGivruu+949tln8ff3JzAwkPPnzwPQo0cPqlatyldffWXUeIQwBUluhLAQt2/ffqhMURSKi4v1do169ephb2+vt/MZyooVKwgMDMTb2/uxzhMSEvJQErNr1y68vLxKlN+6dYsDBw7QrVu3EnW/++47evfu/VgxVFTPnj3ZuXMnBw8epHXr1uzYsUO7b/jw4SxcuNCo8QhhCpLcCFFJhYSEMG7cOMaPH4+bmxthYWHs3r0blUrF9u3b8fPzw97enr1793Lu3Dn69OmDu7s7Tk5OdOzYkZ9++qnE+a5cuUKvXr2oVq0ajRo1KvUv/AeHpSZPnkzz5s1xdHSkcePGTJ8+nTt37mj3v/fee/j6+rJ27Vp8fHxwcXHhpZdeIi8vT1tHo9Hw8ccf07RpU+zt7WnYsCEffvihdn9aWhovvvgiNWvWpFatWvTp04c///yz3Ndm/fr19OrV66HXKyoqivHjx+Pq6oq7uzvLly+noKCAyMhIatSoQdOmTdm+fbv2mNDQUPbt26dNEPPy8jh69CiTJ08ukdwkJSVRVFREaGiotuzWrVv8+9//1iY3Pj4+fPDBB0RERODk5IS3tzdbtmzh6tWr9OnTBycnJ9q2bcuRI0e051i9ejU1a9Zk69attGjRAkdHRwYMGMDNmzdZs2YNPj4+uLq68sYbb6BWqwGws7MD4IcffuDixYtERkZqz9erVy+OHDnCuXPnyn39hKjsJLkRohJbs2YNdnZ27Nu3j88//1xbPmXKFGbPns3p06dp27Yt+fn5PPfccyQkJHD06FF69OhBr169SE1N1R4zfPhw0tLS2LVrFxs3bmTx4sVcuXKl3OvXqFGD1atXc+rUKRYsWMDy5cv59NNPS9Q5d+4cmzdvZuvWrWzdupVffvmlxFDP1KlTmT17NtOnT+fUqVOsW7cOd3d3AO7cuUNYWBg1atQgMTGRffv24eTkRI8ePUrtqQLIysri1KlTdOjQodTXy83NjUOHDhEVFcXrr7/OwIEDCQwMJCUlhb/97W8MHTqUmzdvAneTm/z8fA4fPgxAYmIizZs3p3///hw8eJBbt24Bd3tzfHx88PHx0V4rISGBBg0a0LJlS23Zp59+SpcuXTh69CjPP/88Q4cOJSIigldeeYWUlBSaNGlCREQEiqJoj7l58yYLFy5k/fr17Nixg927d9OvXz+2bdvGtm3bWLt2LUuXLmXjxo3A3WTxgw8+YNOmTWzevBkHBwftuRo2bIi7uzuJiYnlvq9CVHqKEKJSGDZsmNKnTx/tdnBwsNK+ffsSdXbt2qUAyubNmx95vjZt2iiLFi1SFEVRzpw5owDKoUOHtPtPnz6tAMqnn36qLQOUTZs2lXnOuXPnKn5+ftrtmTNnKo6Ojkpubq627K233lL8/f0VRVGU3Nxcxd7eXlm+fHmp51u7dq3SokULRaPRaMuKioqUatWqKT/++GOpxxw9elQBlNTU1BLlwcHBSteuXbXbxcXFSvXq1ZWhQ4dqy9LT0xVASUpK0pY1aNBA+eijj7SxjxkzRlEURWnevLny888/K4qiKEFBQUpkZGSJ640aNUqZNGmSdtvb21t55ZVXHrrW9OnTtWVJSUkKoKSnpyuKoiirVq1SAOXs2bPaOqNHj1YcHR2VvLw8bVlYWJgyevRoRVEUZf78+YqDg4Pi7++v+Pv7KwsXLiwRV/v27ZX33nuv1NdOCEshPTdCVGJ+fn6llj/Ya5Gfn8+kSZNo1aoVNWvWxMnJidOnT2t7bk6fPk2VKlVKnK9ly5bUrFmz3Otv2LCBLl26UK9ePZycnHj33XdL9AbB3eGYGjVqaLc9PDy0PUKnT5+mqKiIZ555ptTzHz9+nLNnz1KjRg2cnJxwcnKiVq1a3Lp1q8yhlcLCQoASPRb3tG3bVvtvW1tbateuzZNPPqktu9djdH+P1f3zbnbv3k1ISAgAwcHB7N69m8LCQg4ePFhiSEpRFL7//vuH5tvcf/1713rU9R0dHWnSpEmJOj4+Pjg5OZUou3fMhAkTKCws5MCBAxw4cICoqKgSMVSrVk3bMyWEpapi6gCEEH9d9erVdSqfNGkSO3fu5JNPPqFp06ZUq1aNAQMGlDm0o4ukpCSGDBnCrFmzCAsLw8XFhfXr1zNv3rwS9apWrVpiW6VSaW9HrlatWrnXyM/Px8/Pr9T5P3Xq1Cn1GDc3NwBu3LjxUJ3SYrm/TKVSAZS4XTo0NJTo6GiuX7/O0aNHCQ4OBu4mN0uXLuXpp5/m9u3bJSYTHzp0iOLiYgIDA8u8/r1rPer6j4r5Xpmut3hnZWWV+doJYSkkuRHCCuzbt4/hw4fTr18/4G7ScP+k3JYtW1JcXExycjIdO3YE4MyZM2RnZ5d5zv379+Pt7V3idusLFy5UKK5mzZpRrVo1EhISGDly5EP7n3rqKTZs2EDdunVxdnbW6ZxNmjTB2dmZU6dO0bx58wrFU5rQ0FAKCgqYP38+zZo1o27dugA8/fTTjBgxgu3bt9OsWTMaNGigPea7777j+eefx9bW9rGvr0/3erzat29v6lCEMCgZlhLCCjRr1oz4+HiOHTvG8ePHGTx4cIm/9Fu0aEGPHj0YPXo0Bw8eJDk5mZEjR5bbs9KsWTNSU1NZv349586dY+HChWzatKlCcTk4ODB58mTefvttvvzyS86dO8eBAwdYuXIlAEOGDMHNzY0+ffqQmJjI+fPn2b17N2+88QYXL14s9Zw2NjZ0796dvXv3ViiWsjRu3JiGDRuyaNEiba8NgJeXF/Xr12fZsmUlhqQAtmzZYvRbwHVx4MAB7O3tCQgIMHUoQhiUJDdCWIH58+fj6upKYGAgvXr1IiwsjKeeeqpEnVWrVlG/fn2Cg4MJDw/n1Vdf1fZSlKZ3795MmDCBcePG4evry/79+5k+fXqFY5s+fTpvvvkmM2bMoFWrVgwaNEg7f8TR0ZE9e/bQsGFDwsPDadWqFSNGjODWrVvl9uSMHDmS9evX62013tDQUPLy8rTzbe4JDg4mLy+vRHJz7tw5zp49S1hYmF6urU//+te/GDJkCI6OjqYORQiDUinKffccCiGEBVAUBX9/fyZMmMDLL79s1GvPnz+fn376iW3bthn1uo9y7do1WrRowZEjR2jUqJGpwxHCoKTnRghhcVQqFcuWLdPr6sy68vT0ZOrUqUa/7qP8+eefLF68WBIbYRWk50YIIYQQFkV6boQQQghhUSS5EUIIIYRFkeRGCCGEEBZFkhshhBBCWBRJboQQQghhUSS5EUIIIYRFkeRGCCGEEBZFkhshhBBCWBRJboQQQghhUf4PN71HvQBQxX0AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>f_irr</th>\n",
+       "      <th>f_I</th>\n",
+       "      <th>r2_1p</th>\n",
+       "      <th>r2_2p</th>\n",
+       "      <th>mean_r2</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-0.460178</td>\n",
+       "      <td>0.970862</td>\n",
+       "      <td>0.255342</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.596008</td>\n",
+       "      <td>0.556113</td>\n",
+       "      <td>-0.019947</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-1.989953</td>\n",
+       "      <td>0.494364</td>\n",
+       "      <td>-0.747795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.447950</td>\n",
+       "      <td>0.886708</td>\n",
+       "      <td>0.667329</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>log</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-3.182423</td>\n",
+       "      <td>0.274285</td>\n",
+       "      <td>-1.454069</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>log</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-1.775753</td>\n",
+       "      <td>-0.245836</td>\n",
+       "      <td>-1.010795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>log</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-3.516459</td>\n",
+       "      <td>0.411338</td>\n",
+       "      <td>-1.552560</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>log</td>\n",
+       "      <td>square</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.024131</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>0.506932</td>\n",
+       "      <td>0.900775</td>\n",
+       "      <td>0.703853</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>log</td>\n",
+       "      <td>0.171196</td>\n",
+       "      <td>0.204009</td>\n",
+       "      <td>0.187602</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-0.877126</td>\n",
+       "      <td>0.967683</td>\n",
+       "      <td>0.045279</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.810713</td>\n",
+       "      <td>0.535467</td>\n",
+       "      <td>0.673090</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>square</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-1.470390</td>\n",
+       "      <td>0.634820</td>\n",
+       "      <td>-0.417785</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>square</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.717720</td>\n",
+       "      <td>0.626429</td>\n",
+       "      <td>-0.045646</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>square</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-2.200391</td>\n",
+       "      <td>-0.164472</td>\n",
+       "      <td>-1.182432</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>square</td>\n",
+       "      <td>square</td>\n",
+       "      <td>-0.554560</td>\n",
+       "      <td>0.966136</td>\n",
+       "      <td>0.205788</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       f_irr       f_I     r2_1p     r2_2p   mean_r2\n",
+       "0   identity  identity -0.460178  0.970862  0.255342\n",
+       "1   identity       log -0.596008  0.556113 -0.019947\n",
+       "2   identity      sqrt -1.989953  0.494364 -0.747795\n",
+       "3   identity    square  0.447950  0.886708  0.667329\n",
+       "4        log  identity -3.182423  0.274285 -1.454069\n",
+       "5        log       log -1.775753 -0.245836 -1.010795\n",
+       "6        log      sqrt -3.516459  0.411338 -1.552560\n",
+       "7        log    square       NaN  0.024131       NaN\n",
+       "8       sqrt  identity  0.506932  0.900775  0.703853\n",
+       "9       sqrt       log  0.171196  0.204009  0.187602\n",
+       "10      sqrt      sqrt -0.877126  0.967683  0.045279\n",
+       "11      sqrt    square  0.810713  0.535467  0.673090\n",
+       "12    square  identity -1.470390  0.634820 -0.417785\n",
+       "13    square       log -0.717720  0.626429 -0.045646\n",
+       "14    square      sqrt -2.200391 -0.164472 -1.182432\n",
+       "15    square    square -0.554560  0.966136  0.205788"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#For other opsins, turned the method into a function\n",
+    "from itertools import product\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy.optimize import curve_fit\n",
+    "\n",
+    "\n",
+    "def identity(x): return x\n",
+    "def square(x): return np.power(x, 2)\n",
+    "def f_lin(x, m): return x * m\n",
+    "\n",
+    "\n",
+    "fns_and_invs = [\n",
+    "    (identity, identity),\n",
+    "    (np.log, np.exp),\n",
+    "    (np.sqrt, square),\n",
+    "    (square, np.sqrt),\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def fit_best_transform(irr_1p, I_1p, irr_2p, I_2p, verbose=True):\n",
+    "    \"\"\"\n",
+    "    Finds the best (irradiance, current) transform pair for linear fitting.\n",
+    "    Returns the best functions, fits, predictions, and R² dataframe.\n",
+    "\n",
+    "    Parameters:\n",
+    "    - irr_1p, I_1p: arrays of 1P irradiance and current\n",
+    "    - irr_2p, I_2p: arrays of 2P irradiance and current\n",
+    "    - verbose: if True, print best result info\n",
+    "\n",
+    "    Returns:\n",
+    "    - best_f_irr, best_f_irr_inv\n",
+    "    - best_f_I, best_f_I_inv\n",
+    "    - best_I_hat_1p, best_I_hat_2p\n",
+    "    - best_m1p, best_m2p\n",
+    "    - r2_results_df: DataFrame of all R² comparisons\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def opt(x, y):\n",
+    "        opt = curve_fit(f_lin, x, y, [1], full_output=True)\n",
+    "        m = opt[0][0]\n",
+    "        percent_resid2 = np.sum(opt[2][\"fvec\"] ** 2) / np.sum(y ** 2)\n",
+    "        return m, percent_resid2\n",
+    "\n",
+    "    best_r2 = -np.inf\n",
+    "    df = pd.DataFrame(columns=[\"f_irr\", \"f_I\", \"r2_1p\", \"r2_2p\", \"mean_r2\"])\n",
+    "\n",
+    "    for (f_irr, f_irr_inv), (f_I, f_I_inv) in product(fns_and_invs, fns_and_invs):\n",
+    "        irr_1p_trans = f_irr(irr_1p)\n",
+    "        irr_2p_trans = f_irr(irr_2p)\n",
+    "        I_1p_trans = f_I(I_1p)\n",
+    "        I_2p_trans = f_I(I_2p)\n",
+    "\n",
+    "        m1p, _ = opt(irr_1p_trans, I_1p_trans)\n",
+    "        m2p, _ = opt(irr_2p_trans, I_2p_trans)\n",
+    "\n",
+    "        I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+    "        I_hat_2p = f_I_inv(m2p * irr_2p_trans)\n",
+    "\n",
+    "        r2_1p = 1 - np.sum((I_hat_1p - I_1p) ** 2) / np.sum((I_1p - np.mean(I_1p)) ** 2)\n",
+    "        r2_2p = 1 - np.sum((I_hat_2p - I_2p) ** 2) / np.sum((I_2p - np.mean(I_2p)) ** 2)\n",
+    "        mean_r2 = np.mean([r2_1p, r2_2p])\n",
+    "\n",
+    "        df.loc[len(df)] = [f_irr.__name__, f_I.__name__, r2_1p, r2_2p, mean_r2]\n",
+    "\n",
+    "        if mean_r2 > best_r2:\n",
+    "            best_r2 = mean_r2\n",
+    "            best_f_irr, best_f_irr_inv = f_irr, f_irr_inv\n",
+    "            best_f_I, best_f_I_inv = f_I, f_I_inv\n",
+    "            best_I_hat_1p, best_I_hat_2p = I_hat_1p, I_hat_2p\n",
+    "            best_m1p, best_m2p = m1p, m2p\n",
+    "\n",
+    "    if verbose:\n",
+    "        print(\"\\n===============\")\n",
+    "        print(\"    RESULTS    \")\n",
+    "        print(\"===============\")\n",
+    "        print(f\"best_f_irr: {best_f_irr.__name__}\")\n",
+    "        print(f\"best_f_I: {best_f_I.__name__}\")\n",
+    "        print(f\"best mean r2: {best_r2:.4f}\")\n",
+    "\n",
+    "    return (\n",
+    "        best_f_irr, best_f_irr_inv,\n",
+    "        best_f_I, best_f_I_inv,\n",
+    "        best_I_hat_1p, best_I_hat_2p,\n",
+    "        best_m1p, best_m2p,\n",
+    "        df\n",
+    "    )\n",
+    "(\n",
+    "    best_f_irr, best_f_irr_inv,\n",
+    "    best_f_I, best_f_I_inv,\n",
+    "    best_I_hat_1p, best_I_hat_2p,\n",
+    "    best_m1p, best_m2p,\n",
+    "    r2_results_df\n",
+    ") = fit_best_transform(irr_1p, I_1p, irr_2p, I_2p)\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "# 1P data and model (original space)\n",
+    "ax.semilogx(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "ax.plot(\n",
+    "    irr_1p,\n",
+    "    best_f_I_inv(best_m1p * best_f_irr(irr_1p)),\n",
+    "    c=\"xkcd:carmine\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"1P model\",\n",
+    ")\n",
+    "\n",
+    "# 2P data and model (original space)\n",
+    "ax.plot(irr_2p, I_2p, c=\"k\", label=\"2P data\")\n",
+    "ax.plot(\n",
+    "    irr_2p,\n",
+    "    best_f_I_inv(best_m2p * best_f_irr(irr_2p)),\n",
+    "    c=\"k\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"2P model\",\n",
+    ")\n",
+    "\n",
+    "ax.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine power sensitivity\"\n",
+    ")\n",
+    "ax.legend()\n",
+    "\n",
+    "#CHR2 \n",
+    "chr2 = get_chr2_irradiance_data()\n",
+    "chr2_irr_1p = chr2[\"irr_1p\"]\n",
+    "chr2_I_1p = chr2[\"I_1p\"]\n",
+    "chr2_irr_2p = chr2[\"irr_2p\"]\n",
+    "chr2_I_2p = chr2[\"I_2p\"]\n",
+    "chr2_irr_2p_35r = chr2[\"irr_2p_35r\"]\n",
+    "\n",
+    "(best_f_irr_chr2, best_f_irr_inv_chr2,\n",
+    " best_f_I_chr2, best_f_I_inv_chr2,\n",
+    " best_I_hat_1p_chr2, best_I_hat_2p_chr2,\n",
+    " best_m1p_chr2, best_m2p_chr2,\n",
+    " r2_results_df_chr2) = fit_best_transform(\n",
+    "    chr2_irr_1p, chr2_I_1p, chr2_irr_2p_35r, chr2_I_2p, verbose=False\n",
+    ")\n",
+    "fig2, ax2 = plt.subplots()\n",
+    "# 1P data and model (original space)\n",
+    "ax2.semilogx(chr2_irr_1p, chr2_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChR2 1P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_1p,\n",
+    "    best_f_I_inv_chr2(best_m1p_chr2 * best_f_irr_chr2(chr2_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChR2 1P model (fit using ChR2)\"\n",
+    ")\n",
+    "# 2P data and model (original space)\n",
+    "ax2.plot(chr2_irr_2p_35r, chr2_I_2p, 'o-', c=\"k\", label=\"ChR2 2P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_2p_35r,\n",
+    "    best_f_I_inv_chr2(best_m2p_chr2 * best_f_irr_chr2(chr2_irr_2p_35r)),\n",
+    "    '--', c=\"k\", label=\"ChR2 2P model (fit using ChR2)\"\n",
+    ")\n",
+    "ax2.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"RAW DATA ChR2-Fitted Slopes\"\n",
+    ")\n",
+    "ax2.legend()\n",
+    "\n",
+    "#chroME\n",
+    "chrome = get_chrome()\n",
+    "chrome_irr_1p = chrome[\"irr_1p\"]\n",
+    "chrome_I_1p = chrome[\"I_1p\"]\n",
+    "chrome_irr_2p = chrome[\"irr_2p\"]\n",
+    "chrome_I_2p = chrome[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome, best_f_irr_inv_chrome,\n",
+    " best_f_I_chrome, best_f_I_inv_chrome,\n",
+    " best_I_hat_1p_chrome, best_I_hat_2p_chrome,\n",
+    " best_m1p_chrome, best_m2p_chrome,\n",
+    " r2_results_df_chrome) = fit_best_transform(\n",
+    "    chrome_irr_1p, chrome_I_1p, chrome_irr_2p, chrome_I_2p, verbose=False\n",
+    ")\n",
+    "fig3, ax3 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax3.semilogx(chrome_irr_1p, chrome_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME 1P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_1p,\n",
+    "    best_f_I_inv_chrome(best_m1p_chrome * best_f_irr_chrome(chrome_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME 1P model (fit using ChroME)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax3.plot(chrome_irr_2p, chrome_I_2p, 'o-', c=\"k\", label=\"ChroME 2P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_2p,\n",
+    "    best_f_I_inv_chrome(best_m2p_chrome * best_f_irr_chrome(chrome_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME 2P model (fit using ChroME)\"\n",
+    ")\n",
+    "ax3.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME Transforms + ChroME-Fitted Slopes\"\n",
+    ")\n",
+    "ax3.legend()\n",
+    "\n",
+    "#chrome2f\n",
+    "chrome2f = get_chrome2f()\n",
+    "chrome2f_irr_1p = chrome2f[\"irr_1p\"]\n",
+    "chrome2f_I_1p = chrome2f[\"I_1p\"]\n",
+    "chrome2f_irr_2p = chrome2f[\"irr_2p\"]\n",
+    "chrome2f_I_2p = chrome2f[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome2f, best_f_irr_inv_chrome2f,\n",
+    " best_f_I_chrome2f, best_f_I_inv_chrome2f,\n",
+    " best_I_hat_1p_chrome2f, best_I_hat_2p_chrome2f,\n",
+    " best_m1p_chrome2f, best_m2p_chrome2f,\n",
+    " r2_results_df_chrome2f) = fit_best_transform(\n",
+    "    chrome2f_irr_1p, chrome2f_I_1p, chrome2f_irr_2p, chrome2f_I_2p, verbose=False\n",
+    ")\n",
+    "fig4, ax4 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax4.semilogx(chrome2f_irr_1p, chrome2f_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2F 1P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_1p,\n",
+    "    best_f_I_inv_chrome2f(best_m1p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2F 1P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax4.plot(chrome2f_irr_2p, chrome2f_I_2p, 'o-', c=\"k\", label=\"ChroME2F 2P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_2p,\n",
+    "    best_f_I_inv_chrome2f(best_m2p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2F 2P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "ax4.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME2F Transforms + ChroME2F-Fitted Slopes\"\n",
+    ")\n",
+    "ax4.legend()\n",
+    "\n",
+    "#chrome2s\n",
+    "chrome2s = get_chrome2s()\n",
+    "chrome2s_irr_1p = chrome2s[\"irr_1p\"]\n",
+    "chrome2s_I_1p = chrome2s[\"I_1p\"]\n",
+    "chrome2s_irr_2p = chrome2s[\"irr_2p\"]\n",
+    "chrome2s_I_2p = chrome2s[\"I_2p\"]    \n",
+    "\n",
+    "(best_f_irr_chrome2s, best_f_irr_inv_chrome2s,\n",
+    " best_f_I_chrome2s, best_f_I_inv_chrome2s,\n",
+    " best_I_hat_1p_chrome2s, best_I_hat_2p_chrome2s,\n",
+    " best_m1p_chrome2s, best_m2p_chrome2s,\n",
+    " r2_results_df_chrome2s) = fit_best_transform(\n",
+    "    chrome2s_irr_1p, chrome2s_I_1p, chrome2s_irr_2p, chrome2s_I_2p, verbose=False\n",
+    ")\n",
+    "fig5, ax5 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax5.semilogx(chrome2s_irr_1p, chrome2s_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2S 1P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_1p,\n",
+    "    best_f_I_inv_chrome2s(best_m1p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2S 1P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax5.plot(chrome2s_irr_2p, chrome2s_I_2p, 'o-', c=\"k\", label=\"ChroME2S 2P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_2p,\n",
+    "    best_f_I_inv_chrome2s(best_m2p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2S 2P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "ax5.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME2S Transforms + ChroME2S-Fitted Slopes\"\n",
+    ")\n",
+    "ax5.legend()\n",
+    "\n",
+    "plt.show()\n",
+    "df\n",
+    "#\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, but we do actually need a pure linear function if we want just a constant.\n",
+    "Let's compute that ratio to use as a placeholder for now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChRmine 1P/2P slope ratio: 270382.2997\n"
+     ]
+    }
+   ],
+   "source": [
+    "#chrmine\n",
+    "m1p, _ = opt(irr_1p, I_1p)\n",
+    "m2p, _ = opt(irr_2p, I_2p)\n",
+    "chrmine_ratio = m1p / m2p\n",
+    "print(f\"ChRmine 1P/2P slope ratio: {chrmine_ratio:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChR2: 18011.0523\n"
+     ]
+    }
+   ],
+   "source": [
+    "m1p_chr2, _ = opt(chr2_irr_1p, chr2_I_1p)\n",
+    "m2p_chr2, _ = opt(chr2_irr_2p, chr2_I_2p)\n",
+    "chr2_ratio = m1p_chr2 / m2p_chr2\n",
+    "print(f\"ChR2: {chr2_ratio:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236723.19655060302\n"
+     ]
+    }
+   ],
+   "source": [
+    "m1p_chrome, _ = opt(chrome_irr_1p, chrome_I_1p)\n",
+    "m2p_chrome, _ = opt(chrome_irr_2p, chrome_I_2p)\n",
+    "chrome_ratio = m1p_chrome / m2p_chrome\n",
+    "print(f\"ChroME: {chrome_ratio:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2f: 241883.7110\n"
+     ]
+    }
+   ],
+   "source": [
+    "m1p_chrome2f, _ = opt(chrome2f_irr_1p, chrome2f_I_1p)\n",
+    "m2p_chrome2f, _ = opt(chrome2f_irr_2p, chrome2f_I_2p)\n",
+    "# m1p_chrome2f / m2p_chrome2f\n",
+    "chrome2f_ratio = m1p_chrome2f / m2p_chrome2f\n",
+    "print(f\"ChroME2f: {chrome2f_ratio:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2s: 252587.0170\n"
+     ]
+    }
+   ],
+   "source": [
+    "m1p_chrome2s, _ = opt(chrome2s_irr_1p, chrome2s_I_1p)\n",
+    "m2p_chrome2s, _ = opt(chrome2s_irr_2p, chrome2s_I_2p)\n",
+    "# m1p_chrome2s / m2p_chrome2s\n",
+    "chrome2s_ratio = m1p_chrome2s / m2p_chrome2s\n",
+    "print(f\"ChroME2s: {chrome2s_ratio:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final Average 1P/2P slope ratio: 250394.05605233982\n"
+     ]
+    }
+   ],
+   "source": [
+    "average_opsin_ratio = np.mean([chrmine_ratio, chrome_ratio, chrome2f_ratio, chrome2s_ratio])\n",
+    "print(\"Final Average 1P/2P slope ratio:\", average_opsin_ratio)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Comparison of Power Sensitivities between Opsins:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x13f8f1d50>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].plot(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].plot(irr_1p, m1p * irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P\")\n",
+    "axs[1].plot(irr_2p, I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].plot(irr_2p, m2p * irr_2p, c=\"k\", linestyle=\"--\", label=\"2P\")\n",
+    "# ax.loglog((irr_1p), (I_1p), c=\"xkcd:carmine\", label=\"1P\")\n",
+    "# ax.plot((irr_2p), (I_2p), c=\"k\", label=\"2P\")\n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChRmine power sensitivity\")\n",
+    "fig.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChR2: 3869.1923507133474\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chr2_irr_1p, chr2_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chr2_irr_1p, m1p_chr2 * chr2_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chr2_irr_2p, chr2_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chr2_irr_2p, m2p_chr2 * chr2_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\")\n",
+    "\n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChR2 power sensitivity\")\n",
+    "fig.legend()    \n",
+    "\n",
+    "#slope for just first 2 points\n",
+    "delta_I_1p = chr2_I_1p[1] - chr2_I_1p[0]\n",
+    "delta_irr_1p = chr2_irr_1p[1] - chr2_irr_1p[0]\n",
+    "m1p_chr2_first2 = delta_I_1p / delta_irr_1p\n",
+    "\n",
+    "delta_I_2p = chr2_I_2p[1] - chr2_I_2p[0]\n",
+    "delta_irr_2p = chr2_irr_2p[1] - chr2_irr_2p[0]\n",
+    "m2p_chr2_first2 = delta_I_2p / delta_irr_2p\n",
+    "\n",
+    "ratio_chr2_first2 = m1p_chr2_first2 / m2p_chr2_first2\n",
+    "print(f\"ChR2: {ratio_chr2_first2}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x16b6a6b90>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chrome_irr_1p, chrome_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chrome_irr_1p, m1p_chrome * chrome_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chrome_irr_2p, chrome_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chrome_irr_2p, m2p_chrome * chrome_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\") \n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChroME power sensitivity\")\n",
+    "fig.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2F: 300161.46129641373\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chrome2f_irr_1p, chrome2f_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chrome2f_irr_1p, m1p_chrome2f * chrome2f_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chrome2f_irr_2p, chrome2f_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chrome2f_irr_2p, m2p_chrome2f * chrome2f_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\") \n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChroME2F power sensitivity\")\n",
+    "fig.legend()\n",
+    "\n",
+    "delta_I_1p = chrome2f_I_1p[1] - chrome2f_I_1p[0]\n",
+    "delta_irr_1p = chrome2f_irr_1p[1] - chrome2f_irr_1p[0]\n",
+    "m1p_chrome2f_first2 = delta_I_1p / delta_irr_1p \n",
+    "delta_I_2p = chrome2f_I_2p[1] - chrome2f_I_2p[0]\n",
+    "delta_irr_2p = chrome2f_irr_2p[1] - chrome2f_irr_2p[0]\n",
+    "m2p_chrome2f_first2 = delta_I_2p / delta_irr_2p\n",
+    "ratio_chrome2f_first2 = m1p_chrome2f_first2 / m2p_chrome2f_first2\n",
+    "print(f\"ChroME2F: {ratio_chrome2f_first2}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2s 342367.84086207947\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chrome2s_irr_1p, chrome2s_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chrome2s_irr_1p, m1p_chrome2s * chrome2s_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, chrome2s_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, m2p_chrome2s * chrome2s_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\") \n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChroME2S power sensitivity\")\n",
+    "fig.legend()\n",
+    "\n",
+    "# 1p2p just first 2 points\n",
+    "delta_I_1p = chrome2s_I_1p[1] - chrome2s_I_1p[0]\n",
+    "delta_irr_1p = chrome2s_irr_1p[1] - chrome2s_irr_1p[0]\n",
+    "m1p_first2 = delta_I_1p / delta_irr_1p\n",
+    "\n",
+    "delta_I_2p = chrome2s_I_2p[1] - chrome2s_I_2p[0]\n",
+    "delta_irr_2p = chrome2s_irr_2p[1] - chrome2s_irr_2p[0]\n",
+    "m2p_first2 = delta_I_2p / delta_irr_2p\n",
+    "\n",
+    "ratio_first2 = m1p_first2 / m2p_first2\n",
+    "print(f\"ChroME2s {ratio_first2}\")"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cleo",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -607,7 +1567,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.11.7"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/1p_2p_ratio_OLD.ipynb b/notebooks/1p_2p_ratio_OLD.ipynb
new file mode 100755
index 00000000..f375ebf7
--- /dev/null
+++ b/notebooks/1p_2p_ratio_OLD.ipynb
@@ -0,0 +1,2060 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# ChRmine\n",
+    "irr_1p = np.array([0.01, 0.05, 0.22, 0.64, 1.42])  # mW/mm2\n",
+    "I_1p = np.array(\n",
+    "    [  # nA\n",
+    "        0.2886803623803128,\n",
+    "        2.4244584619798237,\n",
+    "        4.114091789682305,\n",
+    "        4.637010169751716,\n",
+    "        4.663515508375585,\n",
+    "    ]\n",
+    ")\n",
+    "power_2p = np.array(\n",
+    "    [\n",
+    "        1.758409161619387,\n",
+    "        7.759939823443684,\n",
+    "        18.27217199407987,\n",
+    "        32.8363883380391,\n",
+    "        50.840977407076835,\n",
+    "    ]\n",
+    ")\n",
+    "I_2p = np.array(\n",
+    "    [\n",
+    "        0.0677292632963725,\n",
+    "        0.43824699419092045,\n",
+    "        1.1215139595623866,\n",
+    "        1.8266932442474064,\n",
+    "        2.3784859137876424,\n",
+    "    ]\n",
+    ")\n",
+    "# divide by area of spot with 10 μm radius:\n",
+    "irr_2p = np.array(power_2p) / (np.pi * 0.01**2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2s 342367.84086207947\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chrome2s_irr_1p, chrome2s_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chrome2s_irr_1p, m1p_chrome2s * chrome2s_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, chrome2s_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, m2p_chrome2s * chrome2s_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\") \n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChroME2S power sensitivity\")\n",
+    "fig.legend()\n",
+    "\n",
+    "# 1p2p just first 2 points\n",
+    "delta_I_1p = chrome2s_I_1p[1] - chrome2s_I_1p[0]\n",
+    "delta_irr_1p = chrome2s_irr_1p[1] - chrome2s_irr_1p[0]\n",
+    "m1p_first2 = delta_I_1p / delta_irr_1p\n",
+    "\n",
+    "delta_I_2p = chrome2s_I_2p[1] - chrome2s_I_2p[0]\n",
+    "delta_irr_2p = chrome2s_irr_2p[1] - chrome2s_irr_2p[0]\n",
+    "m2p_first2 = delta_I_2p / delta_irr_2p\n",
+    "\n",
+    "ratio_first2 = m1p_first2 / m2p_first2\n",
+    "print(f\"ChroME2s {ratio_first2}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2s 342367.84086207947\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHoCAYAAADJztIQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACrk0lEQVR4nOzdd1xV9f/A8ddlI8vJUBHcG9yGE1MzVMqyMrXcVoa5UpPMXCnutHLkt8xKzZWapmm49xZ3uFAcgBtkw73n9wc/bt4ABbxwuPB+Ph73UffczznnfUHgfT/j/dEoiqIghBBCCCFMhpnaAQghhBBCiJyRBE4IIYQQwsRIAieEEEIIYWIkgRNCCCGEMDGSwAkhhBBCmBgLtQMQQgghhPHpdDqSk5PVDkPkkpWVFWZmWfezSQInhBBCFDLJycmEhYWh0+nUDkXkkpmZGRUrVsTKyirT1zVSB04IIYQoPBRFITw8nJSUFMqWLfvMXhxRMOl0Ou7cuYOlpSUVKlRAo9FkaCM9cEIIIUQhkpqaSnx8PGXLlqVYsWJqhyNyqUyZMty5c4fU1FQsLS0zvC5puRBCCFGIaLVagCyH3oRpSP/+pX8//0sSOCGEEKIQymzYTZiO533/JIETQgghhDAxksAJkQWNRsPgwYPVDkOIbPP19cXX1zdbbfv06YOnp2eO73H9+nU0Gg1Lly7N8blCCOORBE4UOVevXuXDDz+kUqVK2NjY4OjoSPPmzZk3bx4JCQmqxOTr64tGo6Fq1aqZvh4cHIxGo0Gj0bB27Vr98aVLl+qPZ/Y4fPgwAA8ePGDmzJm0atWKMmXKULx4cV566SVWrVqV6f3Onj3LW2+9hYeHBzY2NpQrV4727dvz7bffGv/Nizxz584dJkyYQEhISJ7eZ8uWLUyYMCFP7yGKhr179+Lv70/ZsmXRaDRs2LDB4PX035UajQYbGxtq1arFggUL1AlWZbIKVRQpmzdv5u2338ba2ppevXpRp04dkpOT2b9/P6NGjeL8+fMsXrxYldhsbGy4cuUKR48epUmTJgavLV++HBsbGxITEzM9d9KkSVSsWDHD8SpVqgBw6NAhxo4dS8eOHfniiy+wsLDg999/59133+XChQtMnDhRf87Bgwdp06YNFSpUYODAgbi6unLz5k0OHz7MvHnz+OSTT4z4roUx/f333wbP79y5w8SJE/H09KRevXoGr/3vf//LVY0wDw8PEhISDFbFbdmyhfnz50sSJ15YXFwc3t7e9OvXjzfffDPTNgMHDmTSpEnEx8fzyy+/EBAQQIkSJejevXs+R6suSeBEkREWFsa7776Lh4cHO3fuxM3NTf9aQEAAV65cYfPmzUa5V1xcHHZ2djk6p3LlyqSmpvLbb78ZJHCJiYmsX7+eTp068fvvv2d6rp+fH40aNcry2rVr1+by5ct4eHjoj3388ce0a9eO6dOnM3r0aH28U6ZMwcnJiWPHjlG8eHGD69y9ezdH78lUJSYmPrcKekGUk1WHmZUlyI70ng8h8oKfnx9+fn7PbFOsWDFcXV0BmDBhAitWrGDjxo1FLoEzrd9OQryAGTNmEBsby48//miQvKWrUqUKQ4cOzXB8w4YN1KlTB2tra2rXrs3WrVsNXp8wYQIajYYLFy7Qo0cPSpQoQYsWLYC0ekyTJ0+mcuXKWFtb4+npyeeff05SUlKmMXbv3p1Vq1YZ9Ixs2rSJ+Ph43nnnnVy/94oVKxokb5D2h7hLly4kJSVx7do1/fGrV69Su3btDMkbgLOz83Pv5evrS506dThx4gTNmjXD1taWihUrsmjRogxt7969S//+/XFxccHGxgZvb29+/vlngzYNGjTI8Em8bt26aDQazpw5oz+2atUqNBoNFy9e1B+7ffs2/fr1w8XFRf/9W7JkicG1du/ejUajYeXKlXzxxReUK1eOYsWKERMTk+V7XLlyJQ0bNsTBwQFHR0fq1q3LvHnzDNo8fvyYYcOG4e7ujrW1NVWqVGH69OkG39v0+WSzZs1i8eLF+n8njRs35tixYwbXi4yMpG/fvpQvXx5ra2vc3Nx4/fXXuX79usHXPn0O3O7du2ncuDEAffv21Q87pc9de3oOXEpKCiVLlqRv374Z3mtMTAw2NjaMHDnSIOanrzN//nwAg+F7RVHw9PTk9ddfz3DNxMREnJyc+PDDD7P8GgvjURSFlLg4VR75sVeAra1tkdwyTHrgRJGxadMmKlWqRLNmzbJ9zv79+1m3bh0ff/wxDg4OfPPNN3Tt2pXw8HBKlSpl0Pbtt9+matWqTJ06Vf9La8CAAfz888+89dZbfPrppxw5coSgoCAuXrzI+vXrM9yvR48eTJgwgd27d/Pyyy8DsGLFCtq2bfvM5Ck6Opr79+8bHNNoNBli/K/IyEgASpcurT/m4eHBoUOHOHfuHHXq1Hnm+Vl59OgRHTt25J133qF79+6sXr2aQYMGYWVlRb9+/QBISEjA19eXK1euMHjwYCpWrMiaNWvo06cPjx8/1ifTLVu25LffftNf++HDh5w/fx4zMzP27duHl5cXAPv27aNMmTLUrFkTgKioKF566SX9YpQyZcrw119/0b9/f2JiYhg2bJhBzJMnT8bKyoqRI0eSlJSUZW9WcHAw3bt3p23btkyfPh2AixcvcuDAAX3M8fHxtG7dmtu3b/Phhx9SoUIFDh48SGBgIBEREcydO9fgmitWrODJkyd8+OGHaDQaZsyYwZtvvsm1a9f0PWVdu3bl/PnzfPLJJ3h6enL37l2Cg4MJDw/PdDFCzZo1mTRpEl9++SUffPABLVu2BMj037+lpSVvvPEG69at4/vvvzd47xs2bCApKYl3330306/Hhx9+yJ07dwgODubXX3/VH9doNLz33nvMmDGDhw8fUrJkSf1rmzZtIiYmhvfeey/TawrjSo2P51fHSqrc+/2Ya1jmcDQiu7RaLb/99htnzpzhgw8+yJN7FGiKEEVAdHS0Aiivv/56ts8BFCsrK+XKlSv6Y6dPn1YA5dtvv9UfGz9+vAIo3bt3Nzg/JCREAZQBAwYYHB85cqQCKDt37tQfa926tVK7dm1FURSlUaNGSv/+/RVFUZRHjx4pVlZWys8//6zs2rVLAZQ1a9boz/vpp58UINOHtbX1M9/fgwcPFGdnZ6Vly5YGx//++2/F3NxcMTc3V3x8fJTRo0cr27ZtU5KTk7PzZVNat26tAMrs2bP1x5KSkpR69eopzs7O+uvMnTtXAZRly5bp2yUnJys+Pj6Kvb29EhMToyiKoqxZs0YBlAsXLiiKoigbN25UrK2tlddee03p1q2b/lwvLy/ljTfe0D/v37+/4ubmpty/f98gvnfffVdxcnJS4uPjFUVR9F/XSpUq6Y89y9ChQxVHR0clNTU1yzaTJ09W7OzslEuXLhkcHzNmjGJubq6Eh4criqIoYWFhCqCUKlVKefjwob7dH3/8oQDKpk2bFEVJ+3cAKDNnznxmbK1bt1Zat26tf37s2DEFUH766acMbXv37q14eHjon2/bts3gnuk6duyoVKpUSf88PeanrxkQEKBk9uckNDRUAZSFCxcaHH/ttdcUT09PRafTPfP9iNxJSEhQLly4oCQkJCiKoijJsbHKj2bOqjySY2Nz/T4AZf369QbHWrdurVhaWip2dnaKpaWlYmNjowwfPlzRarUv8iUrkP77ffwv6YETRUL6cJiDg0OOzmvXrh2VK1fWP/fy8sLR0dFgyDHdRx99ZPB8y5YtAIwYMcLg+KeffsqsWbPYvHkzbdq0yXCdHj16MHnyZBYsWMDatWsxNzfnjTfe4MSJE1nGOX/+fKpVq2ZwzNzcPMv2Op2Onj178vjx4wwrS9u3b8+hQ4cICgpi27ZtHDp0iBkzZlCmTBl++OEHXnvttSyvm87CwsJgeMzKyooPP/yQQYMGceLECV566SW2bNmCq6urwbwVS0tLhgwZQvfu3dmzZw+dO3fW9xzt3buXmjVrsm/fPho3bkz79u0JCgoC0oYrz507R58+fYC0IaPff/+dd955B0VRDHonO3TowMqVKzl58iTNmzfXH+/duze2trbPfW/FixcnLi6O4OBgXn311UzbrFmzhpYtW1KiRAmDe7dr145p06axd+9eevbsqT/erVs3SpQooX+e/p7T/53Z2tpiZWXF7t276d+/v0FbY3n55ZcpXbo0q1atonPnzkBaT2pwcLB++DSnqlWrRtOmTVm+fLn+5+Phw4f89ddfjB49WgrN5hOLYsV4Pybj76z8urex9ezZk7Fjx2Jra4ubm5vJzVU1FkngRJHg6OgIwJMnT3J0XoUKFTIcK1GiBI8ePcpw/L+rQG/cuIGZmZl+JWg6V1dXihcvzo0bNzK957vvvsvIkSP566+/WL58OZ07d35u4tmkSZNnLmL4r08++YStW7fyyy+/4O3tneH1xo0bs27dOpKTkzl9+jTr16/n66+/5q233iIkJIRatWo98/ply5bNsIgjPcG8fv06L730Ejdu3KBq1aoZfvmmD4Gmf31cXFyoWrUq+/bt48MPP2Tfvn20adOGVq1a8cknn3Dt2jUuXryITqfTJz737t3j8ePHLF68OMtVxf9dkJHZKt7MfPzxx6xevRo/Pz/KlSvHK6+8wjvvvGOQzF2+fJkzZ85QpkyZbN37v//O0hO09H9n1tbWTJ8+nU8//RQXFxdeeuklOnfuTK9evfSTuV+UhYUFXbt2ZcWKFSQlJWFtbc26detISUmhW7duub5ur169GDx4MDdu3MDDw4M1a9aQkpLC+++/b5S4xfNpNJo8G8ZUg5OTU4bfq0VR0UxbRZHj6OhI2bJlOXfuXI7Oy6oXS8lkYm5WvTc57WVwc3PD19eX2bNns3fvXnr06JGj859n4sSJLFiwgGnTpj33j6iVlRWNGzdm6tSpLFy4kJSUFNasWWPUeLKjRYsW7Nu3j4SEBE6cOEHLli2pU6cOxYsXZ9++fezbtw97e3vq168PoF8o8N577xEcHJzp4+neN8j6+/dfzs7OhISEsHHjRl577TV27dqFn58fvXv31rfR6XS0b98+y3t37drV4JrZ+Xc2bNgwLl26RFBQEDY2NowbN46aNWty6tSpbMWdHe+++y5Pnjzhr7/+AmD16tXUqFEj0yQ/J9e0tLRk+fLlACxbtoxGjRpRvXp1o8QsCpfY2FhCQkL0tQvDwsIICQkhPDxc3cAKIOmBE0VG586dWbx4MYcOHcLHxyfP7+fh4YFOp+Py5cv6XiVIm1z/+PHjDKtCn9ajRw8GDBhA8eLF6dixo9FiSq/VNWzYMD777LMcnZvewxcREfHctnfu3MlQSuXSpUsA+gn3Hh4enDlzBp1OZ9AL988//+hfT9eyZUt++uknVq5ciVarpVmzZpiZmekTu4sXL9KsWTN9IlSmTBkcHBzQarW0a9cuR+8zO6ysrPD398ff3x+dTsfHH3/M999/z7hx46hSpQqVK1cmNjbW6PeuXLkyn376KZ9++imXL1+mXr16zJ49m2XLlmXaPqcfHlq1aoWbmxurVq2iRYsW7Ny5k7Fjxz73vGfdp2TJknTq1Inly5fTs2dPDhw4kGERhxDpjh8/bjC1JH0KSu/evWX3j/+QHjhRZKTXOhswYABRUVEZXr969WqGUhAvIj3x+u8fqzlz5gDQqVOnLM996623GD9+PAsWLMhRba9nWbVqFUOGDKFnz576GDKza9euTHsY0+f0ZafnJDU1le+//17/PDk5me+//54yZcrQsGFDIO3rExkZabAbRGpqKt9++y329va0bt1afzx9aHT69Ol4eXnh5OSkP75jxw6OHz+ubwNpPVpdu3bl999/z7TX9d69e899D1l58OCBwXMzMzP9Stj08jDvvPMOhw4dYtu2bRnOf/z4MampqTm6Z3x8fIYizpUrV8bBwSHLkjSAPoF+/Phxtu5jZmbGW2+9xaZNm/j1119JTU3N1vDp8+7z/vvvc+HCBUaNGoW5uXmWK1qF8PX1RVGUDI/05G337t3yAeD/SQ+cKDIqV67MihUr6NatGzVr1jTYieHgwYP6EhbG4u3tTe/evVm8eDGPHz+mdevWHD16lJ9//pkuXbpkuoAhnZOTU46q2v/111/6nqunNWvWjEqVKnH06FF69epFqVKlaNu2rX4467/tIG1+XHx8PG+88QY1atTQf31WrVqFp6dnprXC/qts2bJMnz6d69evU61aNVatWkVISAiLFy/Wl8X44IMP+P777+nTpw8nTpzA09OTtWvX6ntonp73V6VKFVxdXQkNDTXYCaJVq1b6nsSnEziAadOmsWvXLpo2bcrAgQOpVasWDx8+5OTJk2zfvp2HDx9m86traMCAATx8+JCXX36Z8uXLc+PGDb799lvq1aun72kdNWoUGzdupHPnzvTp04eGDRsSFxfH2bNnWbt2LdevXzco3fI8ly5dom3btrzzzjvUqlULCwsL1q9fT1RU1DOTocqVK1O8eHEWLVqEg4MDdnZ2NG3a9Jnz/bp168a3337L+PHjqVu3rkHvcVbSk/IhQ4bQoUOHDElap06dKFWqFGvWrMHPzy9b9QSFEM+RL2thhShALl26pAwcOFDx9PRUrKysFAcHB6V58+bKt99+qyQmJurbAUpAQECG8z08PJTevXvrn6eXEbl3716GtikpKcrEiROVihUrKpaWloq7u7sSGBhocB9FMSwjkpWclhHhqVIP2W2nKIry119/Kf369VNq1Kih2NvbK1ZWVkqVKlWUTz75RImKinpmjE+/l+PHjys+Pj6KjY2N4uHhoXz33XcZ2kZFRSl9+/ZVSpcurVhZWSl169bNtOSFoijK22+/rQDKqlWr9MeSk5OVYsWKKVZWVpkutY+KilICAgIUd3d3xdLSUnF1dVXatm2rLF68+Jlf12dZu3at8sorryjOzs6KlZWVUqFCBeXDDz9UIiIiDNo9efJECQwMVKpUqaJYWVkppUuXVpo1a6bMmjVLX0olvSRHZuVBAGX8+PGKoijK/fv3lYCAAKVGjRqKnZ2d4uTkpDRt2lRZvXq1wTn/LSOiKGklSWrVqqVYWFgYfK//W0YknU6nU9zd3RVA+eqrrzK8nlkZkdTUVOWTTz5RypQpo2g0mkxLinz88ccKoKxYsSLDa8K4nld+QpiG530fNYqSD2WShRBFhq+vL/fv38/xghFRuA0fPpwff/yRyMhIiuVBaQnxr8TERMLCwqhYsaJse2bCnvd9lDlwQggh8lRiYiLLli2ja9eukrwJYSQyB04IIUSeuHv3Ltu3b2ft2rU8ePAg072GhRC5IwmcEEKIPHHhwgV69uyJs7Mz33zzDfXq1VM7JCEKDUnghBBGtXv3brVDEAVEekkIIYTxyRw4IYQQQggTIwmcEEIIIcQLun79OhqNRr8NWHb4+voybNiwXN1PEjghhBBCqG7v3r34+/tTtmxZNBoNGzZsyNDG19cXjUaDRqPBxsaGWrVqsWDBgvwPtgCQBE4IIYQQqouLi8Pb25v58+c/s93AgQOJiIjgwoULvPPOOwQEBPDbb7/lU5QFhyRwQgghhFCdn58fX331FW+88cYz2xUrVgxXV1cqVarEhAkTqFq1Khs3bsy0bfqw5urVq2nZsiW2trY0btyYS5cucezYMRo1aoS9vT1+fn4GeyTrdDomTZpE+fLlsba2pl69emzdutXg2kePHqV+/frY2NjQqFEjTp06leH+586dw8/PD3t7e1xcXHj//fe5f/9+Lr46GUkCJ4QQQhQBKXFxWT5SExOz3zYhIVtt84utrS3JycnPbDN+/Hi++OILTp48iYWFBT169GD06NHMmzePffv2ceXKFb788kt9+3nz5jF79mxmzZrFmTNn6NChA6+99hqXL18GIDY2ls6dO1OrVi1OnDjBhAkTGDlypME9Hz9+zMsvv0z9+vU5fvw4W7duJSoqinfeecco71vKiAghhBBFwK+OlbJ8rbxfO175c7n++W+utUmNT8i0rWvrZnTcuV7/fE2lxiTef5ChXT9t1AtE+3xarZbffvuNM2fO8MEHHzyz7ciRI+nQoQMAQ4cOpXv37uzYsYPmzZsD0L9/f5YuXapvP2vWLD777DPeffddAKZPn86uXbuYO3cu8+fPZ8WKFeh0On788UdsbGyoXbs2t27dYtCgQfprfPfdd9SvX5+pU6fqjy1ZsgR3d3cuXbpEtWrVXuj9SwInhBBCCJOxYMECfvjhB5KTkzE3N2f48OEGiVNmvLy89P/v4uICQN26dQ2O3b17F4CYmBju3LmjT+7SNW/enNOnTwNw8eJFvLy8DPYo9fHxMWh/+vRpdu3ahb29fYZ4rl69KgmcEEIIIZ7v/ZhrWb6mMTc3eN498nzWbc0MZ1+9fe3YiwWWQz179mTs2LHY2tri5uaGmdnzZ4NZWlrq/1+j0WR6TKfTGTXO2NhY/P39mT59eobX3NzcXvj6ksAJIYQQRYClnZ3qbY3BycmJKlWq5Nn1HR0dKVu2LAcOHKB169b64wcOHKBJkyYA1KxZk19//ZXExER9L9zhw4cNrtOgQQN+//13PD09sbAwfrolixiEEEIIobrY2FhCQkL0hXDDwsIICQkhPDw832MZNWoU06dPZ9WqVYSGhjJmzBhCQkIYOnQoAD169ECj0TBw4EAuXLjAli1bmDVrlsE1AgICePjwId27d+fYsWNcvXqVbdu20bdvX7Ra7QvHKD1wQgghhFDd8ePHadOmjf75iBEjAOjdu7fBAoP8MGTIEKKjo/n000+5e/cutWrVYuPGjVStWhUAe3t7Nm3axEcffUT9+vWpVasW06dPp2vXrvprpPfiffbZZ7zyyiskJSXh4eHBq6++mq1h3+fRKLLTsBBCCFFoJCYmEhYWRsWKFQ0m2QvT8rzvowyhCiGEEEKYGEnghBBCCCFMjCRwQgghhBAmRhI4IYQQQggTIwmcEEIIIYSJkQROCCGEEMLESAInhBBCCGFiJIETQgghhDAxksAJIYQQQpgYSeCEEEIIIUyMJHBCCCGEUF1QUBCNGzfGwcEBZ2dnunTpQmhoqEEbT09PNBoNGo0GOzs7GjRowJo1a1SKWF2SwAkhhBBCdXv27CEgIIDDhw8THBxMSkoKr7zyCnFxcQbtJk2aREREBKdOnaJx48Z069aNgwcPqhS1egpMAjdt2jQ0Gg3Dhg17Zrs1a9ZQo0YNbGxsqFu3Llu2bMmfAIUQQgiRZ7Zu3UqfPn2oXbs23t7eLF26lPDwcE6cOGHQzsHBAVdXV6pVq8b8+fOxtbVl06ZNKkWtHgu1AwA4duwY33//PV5eXs9sd/DgQbp3705QUBCdO3dmxYoVdOnShZMnT1KnTp18ilYIIYQwHYqiEB8fr8q9ixUrhkajydW50dHRAJQsWTLLNhYWFlhaWpKcnJyre5gy1RO42NhYevbsyf/+9z+++uqrZ7adN28er776KqNGjQJg8uTJBAcH891337Fo0aL8CFcIIYQwKfHx8djb26ty79jYWOzs7HJ8nk6nY9iwYTRv3jzLDprk5GRmz55NdHQ0L7/88ouGanJUT+ACAgLo1KkT7dq1e24Cd+jQIUaMGGFwrEOHDmzYsCHLc5KSkkhKStI/1+l0PHz4kFKlSuX6U4EQ4sUoisKTJ08oW7YsZmYFZibHM+l0Ou7cuYODg4P87hAFWnJyMjqdDq1Wq3+oJbf3DwgI4Ny5c+zZs0d/vqIoAHz22Wd88cUXJCYmYm9vz7Rp0+jUqZNR4zYFqiZwK1eu5OTJkxw7dixb7SMjI3FxcTE45uLiQmRkZJbnBAUFMXHixBeKUwiRN27evEn58uXVDiNb7ty5g7u7u9phCPFcHh4eLFq0iISEBCAt8dm7d68qsYSGhub4A8+MGTPYs2cPixcv5t69e9y7d0//WnJyMiNGjKB///7Y29vj4uJSZD9QqZbA3bx5k6FDhxIcHIyNjU2e3ScwMNCg1y46OpoKFSpw8+ZNHB0d8+y+QoisxcTE4O7ujoODg9qhZFt6rPK7QxR0ycnJREVF4enpmad/X41NURSGDh3KgQMH2LNnD1WrVjV4Pb0nrnTp0lSpUkWNEAsU1RK4EydOcPfuXRo0aKA/ptVq2bt3L9999x1JSUmYm5sbnOPq6kpUVJTBsaioKFxdXbO8j7W1NdbW1hmOOzo6yi9hIVRmSp+c02OV3x2ioEtMTOTevXuYm5tn+DtakH388cesWLGCP/74g+LFi+t73pycnLC1tdW3M6XfG3lJtcknbdu25ezZs4SEhOgfjRo1omfPnoSEhGT6j87Hx4cdO3YYHAsODsbHxye/whZCCCFEHli4cCHR0dH4+vri5uamf6xatUrt0Aok1XrgHBwcMqwssbOzo1SpUvrjvXr1oly5cgQFBQEwdOhQWrduzezZs+nUqRMrV67k+PHjLF68ON/jF0IIIYTxpC9SeJaNGzdSv379fIim4CvQy7/Cw8OJiIjQP2/WrBkrVqxg8eLFeHt7s3btWjZs2CA14IQQQghRpKheRuRpu3fvfuZzgLfffpu33347fwISQgghhCiACnQPnBBCCCGEyEgSOCGEEEIIEyMJnBBCCCGEiZEETgghhBDCxEgCJ4QQQghhYiSBE0IIIYQwMZLACSGEEEKYGEnghBBCCCFe0O7du9FoNDx+/Djb53h6ejJ37txc3U8SOCGEEEKoLigoiMaNG+Pg4ICzszNdunQhNDTUoM1rr72GhYUFGo0GOzs7GjRowJo1a1SKWF2SwAkhhBBCdXv27CEgIIDDhw8THBxMSkoKr7zyCnFxcQbtJkyYQEREBKdOnaJx48Z069aNgwcPqhS1eiSBE0IIIYQq4uLiiIyMJD4+nq1bt9KnTx9q166Nt7c3S5cuJTw8nBMnThic4+DggKurK9WqVWP+/PnY2tqyadOmTK+fPqy5bds26tevj62tLS+//DJ3797lr7/+ombNmjg6OtKjRw/i4+P15yUlJTFkyBCcnZ2xsbGhRYsWHDt2zODaW7ZsoVq1atja2tKmTRuuX7+e4f779++nZcuW2Nra4u7uzpAhQzIkpLklCZwQQghRBMTFxWX5SExMzHbbhISEbLXNjkePHnHr1i3u3r2b4bXo6GgASpYsmeX5FhYWWFpakpyc/Mz7TJgwge+++46DBw9y8+ZN3nnnHebOncuKFSvYvHkzf//9N99++62+/ejRo/n999/5+eefOXnyJFWqVKFDhw48fPgQgJs3b/Lmm2/i7+9PSEgIAwYMYMyYMQb3vHr1Kq+++ipdu3blzJkzrFq1iv379zN48OBsfW2eSylioqOjFUCJjo5WOxQhCo2UhARlbc1myrZOPZSUuLjntjfFn0NTjFkUTQkJCcqFCxeUhIQEg+NAlo+OHTsatC1WrFiWbVu3bm3QtnTp0pm2y46LFy8qx44dU+7du2dwXKvVKp06dVKaN2+uP5aamqq4ubkps2fPVhRFUZKSkpSpU6cqgPLnn39mev1du3YpgLJ9+3b9saCgIAVQrl69qj/24YcfKh06dFAURVFiY2MVS0tLZfny5frXk5OTlbJlyyozZsxQFEVRAgMDlVq1ahnc67PPPlMA5dGjR4qiKEr//v2VDz74wKDNvn37FDMzM/33xsPDQ/n6668zjT2r72M6C+OkgUKIouzJtRtEh14hPiIKc1tbtcMRQpgAnU6nH7a0s7MzeC0gIIBz586xf//+DOcFBgby5ZdfkpiYiL29PdOmTaNTp07PvJeXl5f+/11cXChWrBiVKlUyOHb06FEgrecsJSWF5s2b61+3tLSkSZMmXLx4EYCLFy/StGlTg3v4+PgYPD99+jRnzpxh+fLl+mOKoqDT6QgLC6NmzZrPjPl5JIETQrywmMvXAHCsUhGNRqNyNEKIzMTGxmb5mrm5ucHzzIY005mZGc6+ymzuV3YkJCSg0+mwsLDAxsZGf3zw4MH8+eef7N27l/Lly2c479NPP6Vfv37Y29vj4uKSrd85lpaW+v/XaDQGz9OP6XS6XL2PrMTGxvLhhx8yZMiQDK9VqFDhha8vCZwQ4oXFXL0OpCVwQoiC6b+9XGq0fVp6QmlnZ4dGo0FRFD755BPWr1/P7t27qVgx898npUuXpkqVKrm6Z3ZUrlwZKysrDhw4gIeHBwApKSkcO3aMYcOGAVCzZk02btxocN7hw4cNnjdo0IALFy7kWayyiEEI8cKeXAkDJIETQmRf+kIHe3t7IG3YdNmyZaxYsQIHBwciIyOJjIzMsGgir9nZ2TFo0CBGjRrF1q1buXDhAgMHDiQ+Pp7+/fsD8NFHH3H58mVGjRpFaGgoK1asYOnSpQbX+eyzzzh48CCDBw8mJCSEy5cv88cffxhtEYMkcEKIFxZ9JX0ItdJzWgohRJr0BC69B2/hwoVER0fj6+uLm5ub/rFq1ap8j23atGl07dqV999/nwYNGnDlyhW2bdtGiRIlgLQh0N9//50NGzbg7e3NokWLmDp1qsE1vLy82LNnD5cuXaJly5bUr1+fL7/8krJlyxolRo2iKIpRrmQiYmJicHJyIjo6GkdHR7XDEaJQWF2pEbE3btJp7yZcmjd5bntT/Dk0xZhF0ZSYmEhYWBgVK1Y0mFtW0KQvYrC1tc0wBy8zWq2WU6dOUb9+/Wy1N3XP+z7KHDghxAvRabXYuJQm6dFjHKvKEKoQInvMzMz0w6ci5ySBE0K8EDNzc147tJUi1pkvhBCqkgROCGEUUj5ECJFdYWFhmJmZ4erqirW1tdrhmCRZxCCEEEKIfKPT6Xj48CH37t1TOxSTJgmcEOKFHBkxjt9rt+DKr2vUDkUIYQLi4+NRFAULCwusrKxk+kUuSQInhHghj879Q/Q/l1G02ny75969e/H396ds2bJoNBo2bNjw3HOSkpIYO3YsHh4eWFtb4+npyZIlS/I+WCFUUlATo/QCvvb29mg0Gv755x+uXr1KUlKSypEVLM/7/skcOCHEC4m5mlbE1yEfi/jGxcXh7e1Nv379ePPNN7N1zjvvvENUVBQ//vgjVapUISIiwuhb5whREKSX2EhOTsa2AO5N/HQCl5SURFxcHHFxcfpdD0Sa5ORkIOM2Z+kkgRNC5Jo2KYm48NtA/u7C4Ofnh5+fX7bbb926lT179nDt2jVKliwJgKenZx5FJ4S6LCwsKFasGPfu3cPS0jLD3qVqUhRFn8BZWlrq58HZ2dmRmppKampqludq/7+XPzExsdDXgdPpdNy7d49ixYphYZF5qiYJnBAi156EhaPodFjY22HrUkbtcLK0ceNGGjVqxIwZM/j111+xs7PjtddeY/LkyVn2UCQlJRkM6cTExORXuEK8EI1Gg5ubG2FhYdy4cUPtcAykpqYSGRkJQLFixYiKiiIpKQmtVktYWNgzz9XpdNy/f5/r168XqKQ0r5iZmVGhQoUsV/hLAieEyLWYp/ZALchlRK5du8b+/fuxsbFh/fr13L9/n48//pgHDx7w008/ZXpOUFAQEydOzOdIhTAOKysrqlatqh+GKyhOnTrFV199RYkSJVi8eDGdO3dGp9Oxfft2ypcv/8xzY2Nj6dSpE8ePHy8SBYCtrKyemahKAieEyLUYE9kDVafTodFoWL58OU5OTgDMmTOHt956iwULFmTaCxcYGMiIESP0z2NiYnB3d8+3mIV4UWZmZgVuKy0fHx/2799PfHw8a9euJSwsjLp161KlSpXnnpucnMyNGzewsrIqcO9LDZLACSFyzdLenpL16lDSq6baoTyTm5sb5cqV0ydvADVr1kRRFG7dukXVqlUznGNtbS0FRoXII8WKFWPjxo0AvP766ypHY5okgRNC5Fr1Ae9RfcB7aofxXM2bN2fNmjXExsbqh14uXbqEmZnZc4dthBDGodVq0Wg0mJmZkZiYyNatWwFJ4HKr8M8CFEIUOrGxsYSEhBASEgKkbcsTEhJCeHg4kDb82atXL337Hj16UKpUKfr27cuFCxfYu3cvo0aNol+/fgWyzIIQhdG+ffsoWbIkffr0YefOncTFxVGuXDkaNmyodmgmSdUEbuHChXh5eeHo6IijoyM+Pj789ddfWbZfunQpGo3G4CHj4EKoQ1EUFJXqqB0/fpz69etTv359AEaMGEH9+vX58ssvAYiIiNAnc5BWbyo4OJjHjx/TqFEjevbsib+/P998840q8QtRFB08eJDo6GgSEhL4448/AHjttdcK9AKogkzVIdTy5cszbdo0qlatiqIo/Pzzz7z++uucOnWK2rVrZ3qOo6MjoaGh+ufyjRdCHdGhV/ijYTtK1quN/4Et+XpvX1/fZ1YpX7p0aYZjNWrUIDg4OA+jEkI8y6FDhwB46aWXmDFjBiDDpy9C1QTO39/f4PmUKVNYuHAhhw8fzjKB02g0uLq65kd4QohniLkShjYxEW2ibH8jhHg2RVH0CZyTkxORkZE4ODjg6+urbmAmrMDMgdNqtaxcuZK4uDh8fHyybBcbG4uHhwfu7u68/vrrnD9/Ph+jFEKk05cQqZx/OzAIIUzT5cuXefDgATY2NvpRtFdffVVWer8A1Vehnj17Fh8fHxITE7G3t2f9+vXUqlUr07bVq1dnyZIleHl5ER0dzaxZs2jWrBnnz5/PciWZVFMXIm/EXLkOgGNVSeCEEM928OBBABo2bMjmzZsBGT59Uar3wFWvXp2QkBCOHDnCoEGD6N27NxcuXMi0rY+PD7169aJevXq0bt2adevWUaZMGb7//vssrx8UFISTk5P+IYU4hTCOJ+m7MEgPnBDiOdITuFq1anH+/HnMzc3p2LGjylGZNtUTOCsrK6pUqULDhg0JCgrC29ubefPmZetcS0tL6tevz5UrV7JsExgYSHR0tP5x8+ZNY4UuRJEWnT6EWrVg78IghFBf/fr1adu2rX7xUevWrSlRooTKUZk21RO4/9LpdAZDns+i1Wo5e/Ysbm5uWbaxtrbWlylJfwghXow2OZm4G7eAtH1QhRDiWQYNGsT27du5dOkSIMOnxqDqHLjAwED8/PyoUKECT548YcWKFezevZtt27YB0KtXL8qVK0dQUBAAkyZN4qWXXqJKlSo8fvyYmTNncuPGDQYMGKDm2xCiyEl5EkuF1/2Iu30HW1dntcMRQpiA+/fvs3//fiCt/pt4MaomcHfv3qVXr15ERETg5OSEl5cX27Zto3379gCEh4djZvZvJ+GjR48YOHAgkZGRlChRgoYNG3Lw4MEsFz0IIfKGTamStF27RO0whBAm4NKlS5QsWZLNmzej0+nw8vLC09NT7bBMnqoJ3I8//vjM13fv3m3w/Ouvv+brr7/Ow4iEEEIIYUyffPIJf//9t37LLBk+NY4CNwdOCFHwpTyJfeZOCEIIAWnz2g8fPgygr9sqCZxxSAInhMixne8M4FfHilz//U+1QxFCFGAXLlwgJiYGGxsbEhMTKV++PA0aNFA7rEJBEjghRI7FXLlGanwCNmVKqR2KEKIAS98+K71kiGxebzySwAkhckSbnEzs9bR6ilJCRAjxLOkFfNN3QZLVp8YjCZwQIkdib9xC0emwKGaLrZuL2uEIIQqw9B64uLg42bzeyCSBE0LkSMzltB0YHKpUlKEQIUSWHjx4oN+4HsDPz082rzciSeCEEDkSc1X2QBVCPJ+VlRVLliyhdOnSgKw+NTZJ4IQQOZLeA+dYVRI4IUTWHBwcaNmyJffv38fCwkI2rzcySeCEEDlSyrsOFV57lTKNpRSAEOLZ/vjjDyBt8/rixYurG0who+pODEII01Otf0+q9e+pdhhCiAIsNTWVBQsWsGzZMkBWn+YFSeCEEEIIYVRnzpxh6NCh+ucy/834ZAhVCJFtqQkJxEfelW20hBDPlF7/DcDb2xsPDw8VoymcJIETQmRbxO6DrCxXlz+by2RkIUTW0uu/gfS+5RVJ4IQQ2fbk/0uIFHNzVTkSIURB9nQPnCRweUMSOCFEtulLiMgWWkKILERGRnL9+nUAypYtS/369dUNqJCSBE4IkW0xV64DksAJIbL29PBply5dZMeWPCIJnBAi2/S7MEgCJ4TIwoEDB/T/L8OneUcSOCFEtuhSU3kSFg6AY9VKKkcjhCioOnXqBICdnZ1sXp+HJIETQmRL7I1bKKmpmNvYUKysLGIQQmTu77//BqBz585YWVmpHE3hJYV8hRDZYmZlSe1hH6JLTkFjJp/9hBCZS98+S4ZP85YkcEKIbLF3L0fT2ZPUDkMIUYDNnTuXixcvYm5ujp+fn9rhFGryMVoIYXL27t2Lv78/ZcuWRaPRsGHDhmyfe+DAASwsLKhXr16exSdEUfXTTz8B4OnpKZvX5zFJ4IQQ2fL4n8sk3n9QILbRiouLw9vbm/nz5+fovMePH9OrVy/atm2bR5EJUXQpisI///wDQMeOsltLXpMhVCFEtmzv0ouYy9fw27EON9/mqsbi5+eXq+GZjz76iB49emBubp6jXjshxPOFhISQnJwMwMcff6xyNIWf9MAJIZ7r6RIiDpU91Q0ml3766SeuXbvG+PHjs9U+KSmJmJgYg4cQImuLFy8GwNbWlho1aqgcTeEnCZwQ4rmeLiFiV85N7XBy7PLly4wZM4Zly5ZhYZG9gYegoCCcnJz0D3d39zyOUgjTll4+pG7duipHUjRIAieEeK70PVAdKnuYXAkRrVZLjx49mDhxItWqVcv2eYGBgURHR+sfN2/ezMMohTBtCQkJ+v1P33jjDXWDKSJkDpwQ4rn+3ULL9HZgePLkCcePH+fUqVMMHjwYAJ1Oh6IoWFhY8Pfff/Pyyy9nOM/a2hpra+v8DlcIk7Rt2zZ0Oh0A7777rsrRFA2SwAkhnivmiunugero6MjZs2cNji1YsICdO3eydu1aKlY0vfckREHz559/AtC7d288PDxUjqZokAROCPFcMZcLVgIXGxvLlStX9M/DwsIICQmhZMmSVKhQgcDAQG7fvs0vv/yCmZkZderUMTjf2dkZGxubDMeFEDmn0+nYtGkTAD179kSj0agcUdEgCZwQIlPxkXdJiXmCY9VKVO7xJo5VPCnTpIHaYQFw/Phx2rRpo38+YsQIIO3T/9KlS4mIiCA8PFyt8IQoUo4cOcLdu3dxdHSkdevWaodTZEgCJ4TIICHqLuvqtCT50WOsS5XEpVljnJs3ITUuHm1SEuYqzw3z9fV9ZkHhpUuXPvP8CRMmMGHCBOMGJUQRlV5T0d7engcPHuDmZnor1U2RJHBCiAxOTZpN8qPHACQ9eEj4pm2Eb9oGgLm1NaUaeePSrAkuzZvg3KwxNqVKqhitEEJNa9euBeDu3buULCm/C/KLqvUAFi5ciJeXF46Ojjg6OuLj48Nff/31zHPWrFlDjRo1sLGxoW7dumzZsiWfohWiaIi+dJXQ//0KQIetq2m34RdqfjKA8h3bY1OmFNqkJO4eOMrZmd+xvUsvVjjX5PfaLdj/wQguL13Jk7AbKr8DIUR+uXTpEteupZUZql+/vqzczkeqJnDly5dn2rRpnDhxguPHj/Pyyy/z+uuvc/78+UzbHzx4kO7du9O/f39OnTpFly5d6NKlC+fOncvnyIUovE6MnYqi1eLesR3l2rcm9uZtLn77A2YW5nSPOE/Xfw7R8sd5VOvfE6caVQGI/ucyl35czr7+Qzkz/VuV34EQIr/88ccf+v9v1aqVipEUPaoOofr7+xs8nzJlCgsXLuTw4cPUrl07Q/t58+bx6quvMmrUKAAmT55McHAw3333HYsWLcqXmIUozO4ePs71dX+CRkPDqWMBePJUCRGNRoNT1Uo4Va1E1T5ptZ4SHzzk7sFjRB08StSBo6rvkyqEyD8bN27U/7+Pj4+KkRQ9BWYOnFarZc2aNcTFxWX5j+DQoUP61WbpOnToIJtSC2EEiqJwPPArAKr26kbJurWAf3dhcKyceQkRm1IlqeDfgQr+HfInUCFEgXDv3j0OHDigfy4JXP5SPYE7e/YsPj4+JCYmYm9vz/r166lVq1ambSMjI3FxcTE45uLiQmRkZJbXT0pKIikpSf9cNqQWInM3NwcTufcQ5jY21J84Wn885up1AByrFowacEKIguHPP//Urwb39PSkbNmyKkdUtKi+qWH16tUJCQnhyJEjDBo0iN69e3PhwgWjXV82pBbi+XRaLcc/T+t9q/XJAOzdy+mPP7mWtiihoBTxFUIUDOnz3zw8PGjbtq3K0RQ9qidwVlZWVKlShYYNGxIUFIS3tzfz5s3LtK2rqytRUVEGx6KionB1dc3y+rIhtRDPd+XnVTw+H4pVieJ4ffaJ/nhc+C10KSmYW1tj9/9JnRBCxMfH8/fffwOwfv16fvjhB5UjKnpUT+D+S6fTGQx5Ps3Hx4cdO3YYHAsODn7muLu1tbW+TEn6Qwjxr9T4eE5OmAGA9+fDsC5RXP9azJXrADhU8kBjVuB+XQghVLJ9+3YSEhKoUKEC9erVUzucIknVOXCBgYH4+flRoUIFnjx5wooVK9i9ezfbtqUVDO3VqxflypUjKCgIgKFDh9K6dWtmz55Np06dWLlyJcePH2fx4sVqvg0hTNr5b38g/nYEdhXKU/PjvgavOVatSNOvJ2NubaNSdEKIgih99WmHDh1k71OVqJrA3b17l169ehEREYGTkxNeXl5s27aN9u3bAxAeHo7ZU5/6mzVrxooVK/jiiy/4/PPPqVq1Khs2bJANqYXIpcQHDzn7/3XbGk4ag4WNYaLm4FmB2kM+UCM0IUQBpdVq9ZvX//DDDyQnJz93+zphfKomcD/++OMzX9+9e3eGY2+//TZvv/12HkUkRNFyeupckqNjKOldm8o9u6odjhDCBKRvXm9paUlKSoqsPlWJTGoRooh6cj2ciwt+AqBR0LhM57iF//k394+HoE1Ozu/whBAFVPrqU1tbW0Dqv6lF9TpwQgh1nBw3DV1yMm5tW1LuFd8Mr+u0Wna+3R9dcjJvXz2Gg2eF/A9SCFHgpCdw6XVVJYFTh/TACVEEPTh1lqsrfgegcdC4TCchx928jS45GTMrKykhIoQAIDQ0lNDQUMzNzQGoWrUqpUuXVjmqokkSOCGKoGNjJgNQ6d03KN3QO9M2Mf+/B6pDJQ/M/v+XtRCiaEtffVqhQlqPfLNmzdQMp0iTBE6IIuZ28B7ubN+DmaUlDb8KzLLdk/+vAedY2TN/AhNCFHjpw6dWVlaAJHBqkjlwQhQhik7H8cC03rcag/rgUNEjy7bRV/5/E/uqlfIlNiFEwXb37l0OHjwIwEcffcTp06dp3bq1ylEVXZLACVGEXPttHQ9OncXS0YF6Y4c/s+2T/x9ClT1QhRDw7+b1DRo0YNiwYWqHU+TJEKoQRYQ2KYkTX04DwGv0YGxKl3pm+xh9Aic9cEKIf4dPX3vtNZUjESA9cEIUGRcX/kTs9ZsUK+tK7aHP312h8cwJRP9zmZLetfIhOiFEQRYfH09wcDAArq6uhISEUKdOHSwsJI1Qi/TACVEEJD2O5vSUuQDUHz8Ki2LFnnuOu19b6gz/CFvnMnkcnRCioEvfvN7Dw4OZM2dSv359duzYoXZYRZokcEIUAWdnfEvSw0cUr1mNqn3eVTscIYSJSR8+bdeuHVevXkWj0dC0aVOVoyrapO9TiEIu7tYdzs/7HwCNpo7FLBtDHuF//k1qfAKurXwo5uqc1yEKIQqwpzevT6//VqtWLYoXL65iVEJ64IQo5E5NnIk2MRHn5k1w9++QrXPOzVnI7u4fcHvrzjyOTghR0B0+fJh79+7h5OQk22cVIJLACVGIPboQyuWlKwFoPO3LTLfM+i9Fp+PByTMAlGrolafxCSEKvvTh044dO3L06FFACvgWBJLACVGIHQ/8CkWnw6NLR1yaNc7WOTGXr5HyJBZzW1uK16yWxxEKIQq69ASuU6dOHDt2DJAeuIJAEjghCqnIfYe5+effaMzNaTR1bLbPu3/iNACl6tXO1nw5IUThFRoayqVLl7C0tKRs2bIkJiZSsmRJqlWTD3dqk9/OQhRCiqJwbMwkAKr174lT9SrZPlefwDWQ4VMhirr03rc2bdrQtGlTgoODuXv3LmZm0v+jNknghCiE7h05wb3DJ7AoZkv9L0fm6Nz0+W+lG3jnRWhCCBOSnsC9/vrrFCtWjHbt2qkckUgnKbQQhVDYmo0AeHTpSDE3l2yfp+h03E9P4BpJAidEURYVFcWhQ4cA2T6rIJIETohCRtHpuL42rWZTxbdz+EtXo+GN07tps+oHnGpUzYPojGPv3r34+/tTtmxZNBoNGzZseGb7devW0b59e8qUKYOjoyM+Pj5s27Ytf4IVwkQ9vXm9ubk5I0eO1PfICfVJAidEIXP38Anibt3B0tGBsq/45uhcjUaDg2cFKr7lX6AXMMTFxeHt7c38+fOz1X7v3r20b9+eLVu2cOLECdq0aYO/vz+nTp3K40iFMF1PD5/u37+f2bNnM3HiRJWjEukK7m9oIUSuhK1J+6Vb4bVXsbCxUTmavOHn54efn1+228+dO9fg+dSpU/njjz/YtGkT9evXN3J0Qpi+pzevf/3111m6dCkg9d8KEknghChEXmj4FDg5fjrmNtZU6dUNu3Juxg6vwNDpdDx58oSSJUtm2SYpKYmkpCT98/QK9EIUBcHBwSQmJuLh4YGXl5d+LpzUfys4ZAhViEIk6sBR4u9EYuXkSLn2rXN0rqLTcX7eYk58EUTSw0d5FGHBMGvWLGJjY3nnnXeybBMUFISTk5P+4e7uno8RCqGudevWAWm9b0lJSZw8eRKQHriCRBI4IQoR/fDp636YW1vn6NyisgPDihUrmDhxIqtXr8bZ2TnLdoGBgURHR+sfN2/ezMcohVBPQkIC69evB+Dtt9/mxIkTpKSk4OLigqenp7rBCT1J4IQoJHRaLdd//xPI3fBpUdiBYeXKlQwYMIDVq1c/t56VtbU1jo6OBg8hioItW7bw5MkT3N3dadasGQcPHgTShk+zs5+yyB+SwAlRSETtP0JC5F2sShSnbLtWOT6/sO/A8Ntvv9G3b19+++03OnXqpHY4QhRYK1asAKB79+6YmZlx7tw5QIZPC5rC+TFbiCLo3+K9fphbWeX4fFPagSE2NpYrV67on4eFhRESEkLJkiWpUKECgYGB3L59m19++QVI+4PUu3dv5s2bR9OmTYmMjATA1tYWJycnVd6DEAVRdHQ0mzdvBtISOIClS5cyfvx47Ozs1AxN/If0wAlRCKQNn6avPn09x+crOh0PTp0FoFTDgt8Dd/z4cerXr68vATJixAjq16/Pl19+CUBERATh4eH69osXLyY1NZWAgADc3Nz0j6FDh6oSvxAF1YYNG0hKSqJGjRp4e6d9mNNoNFSqVAkXl+zv6iLy3gv3wCUlJWGdw8nSQgjjitp7iMS797EuWYKyL7fI8flxN2+jS04xmQUMvr6+KIqS5evpNavS7d69O28DEqKQ+O2334C03jeZ71aw5bgH7q+//qJ3795UqlQJS0tLihUrhqOjI61bt2bKlCncuXMnL+IUQjyDfvj0jY6YWVrm+Hx7D3fej75Kl5M7Cu0CBiHEs927d4/t27cD/w6fjh8/njfffJNdu3apGZrIRLYTuPXr11OtWjX69euHhYUFn332GevWrWPbtm388MMPtG7dmu3bt1OpUiU++ugj7t27l5dxCyH+ny41levr0lef5nz4NJ2ZpSVO1SobKywhhIlZs2YNWq2Whg0bUrVq2l7ImzZtYv369fI3vQDK9kftGTNm8PXXX+Pn54eZWca8L70g5u3bt/n2229ZtmwZw4cPN16kQohMRe45SOK9B1iXKolbm+ZqhyOEMFHpq0979OgBpC0WOn06bXW6rEAteLKdwKVvo/E85cqVY9q0abkOSAiRM+nDp55vdsrV8Kei07G5lT9O1avQZPYkrIvLqkwhiprw8HAOHDiARqOhW7duABw7dgydToe7uzvly5dXOULxX0ZdhXrx4kVGjhyZ7fZBQUE0btwYBwcHnJ2d6dKlC6Ghoc88Z+nSpWg0GoOHTSHdsFuI59GlpHB9XdqS/9wU7wWIvnSVu4eOc23VH1jaS5kAIYqilStXAtCqVSvKlSsHIPufFnAvnMDFxcXx448/0qxZM2rXrs3WrVuzfe6ePXsICAjg8OHDBAcHk5KSwiuvvEJcXNwzz3N0dCQiIkL/uHHjxou+DSFMUsSuAyQ9eIhNmVK4ts7dEMeDIrADgxDi2Z5efZoufQcGGT4tmHL92/rAgQP8+OOPrF69moSEBIYPH86SJUuoUaNGtq/x32Rv6dKlODs7c+LECVq1yrqSvEajwdXVNbehC1FopO996vlm51wnX/fTC/g2LPgFfIUQxvfPP/8QEhKChYUFb731FgCKokgPXAGXox64u3fvMmPGDGrUqMFbb71F8eLF2b17N2ZmZvTr1y9HyVtmoqOjAShZsuQz28XGxuLh4YG7uzuvv/4658+fz7JtUlISMTExBg8hCgNdSgrX128Bcj98Cv/uwFDKBHZgEEIYX3rvW4cOHShVqhQADx8+pFq1ajg5OVGvXj0VoxNZyVEC5+HhwdmzZ5k3bx63b99mzpw5NGrUyCiB6HQ6hg0bRvPmzalTp06W7apXr86SJUv4448/WLZsGTqdjmbNmnHr1q1M2wcFBeHk5KR/uLu7GyVeIdR2Z8c+kh89xsa5NC6tcvcJWdHpnuqBK/g7MAghjEtRFIO9T9OVKlWKQ4cOce/ePaxysTWfyHs5TuD279/P3r17uXTpklEDCQgI4Ny5c/qJlFnx8fGhV69e1KtXj9atW7Nu3TrKlCnD999/n2n7wMBAoqOj9Y+bN28aNW4h1KIfPu3qj5m5ea6uEX3pKqmxcZjb2uJUo6oxwxNCmIATJ05w5coVbG1tef31jHUkLXNRGFzkjxxNmvnnn3/0c98aN25MtWrVeO+99wBeaMuNwYMH8+eff7J3794cL1W2tLSkfv36BhtbP83a2lq2+hKFjjY5mRsb/gJebPg06cEjHKtVxqZMKVnAIEQRlD586u/vj729PQDx8fE8fPhQSocUcDlehdq8eXOWLFlCREQEH330kb5y88cff8z//ve/HFVrVhSFwYMHs379enbu3EnFihVzGg5arZazZ8/i5uaW43OFMFV3tu8l+XE0tq7OuLRomuvruDRvwlsXD9JxxzojRieEMAU6nY5Vq1YBhsOn69evp0KFCvTr10+t0EQ25LqMiL29PQMHDuTgwYOcP3+eBg0a8MUXX1C2bNlsXyMgIIBly5axYsUKHBwciIyMJDIykoSEBH2bXr16ERgYqH8+adIk/v77b65du8bJkyd57733uHHjBgMGDMjtWxHC5KQX7634Vu6HT5+Wm/1ThRCmbd++fdy+fRsnJyf8/Pz0x5ctW4aiKFSoUEHF6MTzGKWQb82aNZk9eza3b9/WZ/PZsXDhQqKjo/H19cXNzU3/ePoa4eHhRERE6J8/evSIgQMHUrNmTTp27EhMTAwHDx6kVq1axngrQhR42qQkwv9IGz71fIG9TxVFQdHpjBWWEMLEpA+fdu3aVT/VKCoqiuDgYAB69uypWmzi+XI96UWn03HlyhXu3r2L7qk/AqVLl872NRRFeW6b3bt3Gzz/+uuv+frrr7N9DyEKm9vBe0iOjqFYWVdcmjXO9XWi/7nMxpdexbXFS7yyeYURIxRCFHTJycmsWbMGMBw+XbVqFVqtliZNmug3tBcFU64SuMOHD9OjRw9u3LiRIQnTaDRotVqjBCeEyEi/9+lb/mjMct+Jfv/EGVJj40iW2ohCFDnBwcE8fPgQFxcX2rRpoz++bNkyAP0CRVFw5SqB++ijj2jUqBGbN2/Gzc3thVagCiGyLzUxkfCNaTuYVHyB4VOAByfTttAq3UDqvwlR1KQPn77zzjuY//882kuXLnHs2DHMzc31G9qLgitXCdzly5dZu3YtVapUMXY8QohnuL1tFykxT7ArXxbnlxq+0LXuyw4MQhRJ8fHxbNiwATAcPk0v6PvKK6/g7OysRmgiB3KVwDVt2pQrV65IAidEPjPW8KlOq+XBqbMAlG4kCZwQRcmff/5JXFwcnp6evPTSS/rjI0aMoGLFirJjkYnIVQL3ySef8OmnnxIZGUndunUzVGr28pIhGSGMLTUhgfBN24AXK94LEPP/OzBYFJMdGIQoap7eOuvpKVCOjo707t1brbBEDuUqgevatSuAQZE/jUaDoiiyiEGIPHJr6y5SY+Owq1CeMk1fcPj0RNrwacl6dYxSR04IYRoeP37MX3+llSF6evhUmJ5cJXBhYWHGjkMI8Rzpe59WfMv/hRcOWZcqQXm/dpRuXM8IkQkhTMW6detITk6mdu3a1K1bF4CUlBT8/Pzo2LEjgwYNwtbWVuUoRXbkKoHz8PAwdhxCiGdIjY/n5p9/Ay8+fArg7tcWd7+2L3wdIYRpSV99+nTv27Zt29ixYwfnzp1jyJAhaoUmcijbs6APHz6c7YvGx8dz/vz5XAUkhMjo1l87SY2Lx97DndKN66sdjhDCBEVGRrJz504A3n33Xf3x5cuX649ZWOS6vr/IZ9lO4N5//306dOjAmjVriIuLy7TNhQsX+Pzzz6lcuTInTpwwWpBCFHX64dO3X3vh4dOUJ7HER941RlhCCBOyZs0adDodTZs2pXLlygDExMToS4pI8V7Tku0E7sKFC3Tq1IkvvviC4sWLU7t2bdq3b4+/vz8tWrSgdOnSNGjQgLCwMP7++2969eqVl3ELUWSkxMVxc3Pa3oTGGD698cdWVpary/Yu8jMqRFHy9OrTdOvXrycxMZHq1avTsOGLLY4S+SvbfaWWlpYMGTKEIUOGcPz4cfbv38+NGzdISEjA29ub4cOH06ZNG0qWLJmX8QpR5NzasoPU+AQcKnlQquGL12xL34HB3qP8C19LCGEawsLCOHz4MGZmZrzzzjv64+nDpz179pRdlUxMrga7GzVqRKNGjYwdixAiE+nFe40xfAqyA4MQRdHKlSsB8PX1xc3NDYA7d+6wY8cOIC2BE6ZFZisKUYClxMZxc8t24MX3PoX/34Hh/xM42YFBiKIjs9Wn8fHxdO3alQcPHlCpUiW1QhO5JAmcEAXYzc3BaBMScKxSkZL16rzw9WIuXSU1Ll52YBCiCDl//jxnz57F0tJSX4gfoEqVKqxevRqdTqdidCK3cr+ZohAiz4WtTlt96mms4dNCsgPD3r178ff3p2zZsmg0Gv0qumfZvXs3DRo0wNramipVqrB06dI8j1OIgiC9983Pz48SJUpkeN3sBfZVFuqR75oQBVTKk1hu/ZU2P8UYw6cA90+EAFDaCIsh1BQXF4e3tzfz58/PVvuwsDA6depEmzZtCAkJYdiwYQwYMIBt27blcaRCqEtRlEyHT7dv305oaKhaYQkjyNUQ6i+//EK3bt2wtrY2OJ6cnMzKlSulhIgQRhC+aRvapCQcq1WmpFcto1yz/KttQadL+68J8/Pzw8/PL9vtFy1aRMWKFZk9ezYANWvWZP/+/Xz99dd06NAhr8IUQnVHjx7l2rVrFCtWDH9/fwB0Oh0DBw7k+vXrbNmyJUc/S6LgyFUPXN++fYmOjs5w/MmTJ/Tt2/eFgxJCGH/1KUD5Dm14ad5Uyr/6slGuZyoOHTpEu3btDI516NCBQ4cOZXlOUlISMTExBg8hTE1679vrr7+OnZ0dAAcPHuT69es4ODjg6+urYnTiReQqgVMUJdM/KLdu3cLJyemFgxKiqEuOecKtrWlb3hijeG9RFxkZiYuLi8ExFxcXYmJiSEhIyPScoKAgnJyc9A93d/f8CFUIo9FqtaxatQowHD5dtmwZAF27dpWN601YjoZQ69evj0ajQaPR0LZtW4M907RaLWFhYbz66qtGD1KIoiZ84zZ0yck41ahKiTo1jXLNx/9cJvH+Q0rVq4OlvZ1RrlmYBQYGMmLECP3zmJgYSeKESdmzZw+RkZGUKFFCP1UgKSmJ1atXA7J1lqnLUQLXpUsXAEJCQujQoQP29vb616ysrPD09DRYoiyEyB1j7n2aLnTxL5yft5hanwzgpblTjHJNU+Hq6kpUVJTBsaioKBwdHbPsgbC2ts4wz1cIU5I+fPrWW29hZWUFwF9//cWjR49wc3OT4VMTl6MEbvz48QB4enrSrVs3bGxs8iQoIYqypMfR3P57N2Dc4dOivAODj48PW7ZsMTgWHByMj4+PShEJkbeSkpJYu3YtkPnwaY8ePTA34VJCIperUHv37g2krTq9e/duhiKAFSpUePHIhCii0odPi9eqTonaNYxyTYMdGBp6GeWaaoqNjeXKlSv652FhYYSEhFCyZEkqVKhAYGAgt2/f5pdffgHgo48+4rvvvmP06NH069ePnTt3snr1ajZv3qzWWxAiT23bto3Hjx/j5uZGq1atgLS/2QcOHABk+LQwyFUCd/nyZfr168fBgwcNjqcvbtBqtUYJToii6PpTw6fGUth2YDh+/Dht2rTRP0+fq9a7d2+WLl1KREQE4eHh+tcrVqzI5s2bGT58OPPmzaN8+fL88MMPUkJEFFrpw6fdunXT97RZWVkRFhbGrl278PYuej3xhU2uErg+ffpgYWHBn3/+iZubm9Hm6AhR1CU9eszt4D0AeL7lb7TrFpYdGNL5+vqiKEqWr2e2y4Kvry+nTp3Kw6iEKBji4uLYuDGtDNHTw6cANjY2UvetkMhVAhcSEsKJEyeoUcM4wztCiDThf2xFl5JCiTo1KFGrutGu++DkacD0d2AQQjzfxo0biY+Pp3LlyjRu3BhIGz61tLSUDpdCJFd14GrVqsX9+/eNHYsQRd6/xXuNs3VWuqK8gEGIombFihVAWu9besI2b948qlWrpp8XKkxfrnrgpk+fzujRo5k6dSp169bF0tLS4HVHR0ejBCdEUZL44CG3t6cNnxq7eG+TGeO5e+QEbr7NjHpdIUTB8vDhQ/0ev/9dfXrlyhUSExPVCk0YWa4SuPQtadq2NdxPURYxCJF74Rv+QklNpaR3bZyqVzHqtcs0aUCZJg2Mek0hRMHz+++/k5KSgpeXF7Vqpe2hfObMGc6cOYOVlRVvv/22yhEKY8lVArdr1y5jxyFEkff03qdCCJEb6atPn+59W758OQCdOnWiRIkSqsQljC9XCVzr1q2NHYcQRVri/Qfc2bkPAM+3jJvAXf/9T1KexFK2XSvsypc16rWFEAXHnTt32L17NwDvvvsuADqdTj8nTmq/FS65WsQAsG/fPt577z2aNWvG7du3Afj111/Zv3+/0YIToqi4sX4LilZLqfp1capayajXPv/NYvb1H8qdnfKzKURhtnr1ahRFoVmzZnh6egKwd+9ebt26RfHixenYsaO6AQqjylUC9/vvv9OhQwdsbW05efIkSUlJAERHRzN16tRsXycoKIjGjRvj4OCAs7MzXbp0ITQ09LnnrVmzhho1amBjY0PdunUzbJEjhKlJHz71NPLwqU6r5cGpswCUbiQrUIUozJ5efZoufeust956S7a/LGRylcB99dVXLFq0iP/9738GK1CbN2/OyZMns32dPXv2EBAQwOHDhwkODiYlJYVXXnmFuLi4LM85ePAg3bt3p3///pw6dYouXbrQpUsXzp07l5u3IoTqEu7dJ2JXWu9YRSMPn0aHXknbgcGumNEXRgghCo4rV65w7NgxzMzMDBYq9OrVi759+9KnTx/1ghN5Ildz4EJDQ/V7qz3NycmJx48fZ/s6W7duNXi+dOlSnJ2dOXHiRKbXh7RaNq+++iqjRo0CYPLkyQQHB/Pdd9+xaNGi7L8JIQqIG+u2oOh0lGrojWNlT6Ne+0Eh24FBCJG5lStXAmnVIVxcXPTHW7VqleXfU2HactUD5+rqarCRdLr9+/dTqVLu5+9ER0cDULJkySzbHDp0SF/GJF2HDh04dOhQpu2TkpKIiYkxeAhRkIStNf7ep+nup+/A0MD0N7AXQmROUZRMV5+Kwi1XCdzAgQMZOnQoR44cQaPRcOfOHZYvX87IkSMZNGhQrgLR6XQMGzaM5s2bU6dOnSzbRUZGGny6AHBxcSEyMjLT9kFBQTg5Oekf7u7uuYpPiLyQEHWXyN0HAahoxL1P0z2QHRiEKPTOnj3LhQsXsLa25s033wTSCvoOHz6c48ePP3PfYGG6cjWEOmbMGHQ6HW3btiU+Pp5WrVphbW3NyJEj+eSTT3IVSEBAAOfOnTP6KtbAwEBGjBihfx4TEyNJnCgwrv//8GnpxvVwqOhh1GsrOp0sYBCiCEjvfevYsSNOTk5A2mK/uXPnsnPnTk6fPq1meCKP5DiB02q1HDhwgICAAEaNGsWVK1eIjY2lVq1a2Nvb5yqIwYMH8+eff7J3717Kly//zLaurq5ERUUZHIuKisLV1TXT9tbW1lhbW+cqLiHy2r/Dp8bd+xRAY2bG25ePcP/EGVnAIEQhldXwaXrxXqn9VnjleAjV3NycV155hUePHmFlZUWtWrVo0qRJrpI3RVEYPHgw69evZ+fOnVSsWPG55/j4+LBjxw6DY8HBwfj4+OT4/kKoKT4iisg9aXM382L4FMDWxRn3ju1kAYMQhdShQ4e4ceMG9vb2dO7cGYDr16+zb98+NBqNzIkrxHI1B65OnTpcu3bthW8eEBDAsmXLWLFiBQ4ODkRGRhIZGUlCQoK+Ta9evQgMDNQ/Hzp0KFu3bmX27Nn8888/TJgwgePHjzN48OAXjkeI/HR93Z+gKJRp2gB7DxnWF0LkXHrvW5cuXbC1tQX+rQfn6+v73FEtYbpyXQdu5MiR/Pnnn0REROR6lefChQuJjo7G19cXNzc3/WPVqlX6NuHh4UREROifN2vWjBUrVrB48WK8vb1Zu3YtGzZseObCByEKon/3PjX+8CnA0VETODEuiNjwW3lyfSGEulJTU1m9ejXw7/Cpoij64r0yfFq4aZRcLE8xM/s379NoNPr/VxQFjUaDVqs1TnR5ICYmBicnJ6Kjo3F0dFQ7HFFExd2OYJVHfVAU3rl+Env3cka9vk6rZVnxyqTGJ/DG2b2UqFXdqNd/Uab4c2iKMYvCLTg4mFdeeYVSpUoRERGBpaUlp06dokGDBlhbWxMVFaVf1FAYyM+goVytQt21a5ex4xCiSEkfPnVu1tjoyRuklQ9JjU/Awt5OFjAIUUilD5++/fbb+l2Rbt68iYuLC61atSpUyZvIKMcJXEpKCpMmTWLRokVUrVo1L2ISotD7d/jU+MV7AcJWp61ude/UXhYwCFEIJSYm8vvvvwOGq09fe+01OnbsmKNdkYRpyvEcOEtLS86cOZMXsQhRJMTdusPdA0cB8Oxq/NWnik6nT+AqvZM38+uEEOr666+/iImJoXz58rRo0cLgNQsLC0qXLq1SZCK/5GoRw3vvvcePP/5o7FiEKBKu/74JAJcWTbEr52b060cdOErcrTtYOjpQ7tWXjX59IYT60odPu3Xrpp+XfuHChQI9B10YV67mwKWmprJkyRK2b99Ow4YNsbOzM3h9zpw5RglOiMIor4dPr63aAIBHl45Y2NjkyT2EEOp58uQJmzalfRDs0aMHAPHx8TRt2hQHBwcOHz5MhQoV1AxR5INcJXDnzp2jQYMGAFy6dMngtadXpQohDMWG3+LuoeOg0eD5Zuc8uYelXTGsnByp1K1LnlxfCKGuP/74g8TERKpVq0b9+vUB2LRpE7GxsZQuXVq2iywiZBWqEPno+u9/AuDa8iWKlc18+7cX1Xj6lzSY9BkaWbwgRKGUXqi3e/fu+k6T9NpvPXv2lI6UIiJXCZwQInfC1qQtLvDMo+HTdOay/68QhdL9+/cJDg4G/l19ev/+fbZu3QqkJXCiaMhVAtemTZtnZvg7d+7MdUBCFFZProdz78jJPBs+1SYl8fDMBUo3qiefwIUopNauXUtqair169enevW0At2rV68mNTWVBg0aULNmTZUjFPklVwlcvXr1DJ6npKQQEhLCuXPn6N27tzHiEqLQub42bdKxa2sfirk6G/36t//ezfYuvXBp+RKddv9h9OsLIdSXvvr06dpvsnVW0ZSrBO7rr7/O9PiECROIjY19oYCEKKz0q0/fypvabOmrT0s38MqT6wsh1HXr1i327dsHwLvvvgvA9evXOXToEGZmZvpjomjIVR24rLz33nssWbLEmJcUolCIuXad+8dD0JiZ4flmR6NfPzU+nvCNaXNgKsrqUyEKpVWrVqEoCi1bttSvNPXw8ODo0aN88803uLkZv66kKLiMuojh0KFD2EjdKSEy0A+f+jbD1sX4w6c3N28nNS4ee093yjRpYPTrCyHU9/Tq03QajYbGjRvTuHFjtcISKslVAvfmm28aPFcUhYiICI4fP864ceOMEpgQhUl+DZ9W6talyCxgmD9/PjNnziQyMhJvb2++/fZbmjRpkmX7uXPnsnDhQsLDwyldujRvvfUWQUFB8qFTmIRLly5x8uRJzM3Neeutt9QORxQAuUrgnJycDJ6bmZlRvXp1Jk2axCuvvGKUwIQoLGKuhPHg5Bk05uZ45MHwaXLME25t2Q5AxW5vGP36BdGqVasYMWIEixYtomnTpsydO5cOHToQGhqKs3PGHs4VK1YwZswYlixZQrNmzbh06RJ9+vRBo9HIzjHCJKQvXmjfvj1lypQB4Msvv+TOnTsMHTqUunXrqhmeUEGuEriffvrJ2HEIUWiFrU3rfXNr0wLbMsbfYPrmn3+jTUrCqUZVSnrVMvr1C6I5c+YwcOBA+vbtC8CiRYvYvHkzS5YsYcyYMRnaHzx4kObNm+u3HfL09KR79+4cOXIkX+MWIjcURdEncOn/hlNTU/n++++5e/cub7zxhiRwRVCuErhjx46h0+lo2rSpwfEjR45gbm5Oo0aNjBKcEIVBXu99WrFbF2xdnUmNiy8Sw6fJycmcOHGCwMBA/TEzMzPatWvHoUOHMj2nWbNmLFu2jKNHj9KkSROuXbvGli1beP/997O8T1JSEklJSfrnMTExxnsTQuRASEgIoaGh2NjY0KVLFwC2b9/O3bt3KV26tIx8FVG5WoUaEBDAzZs3Mxy/ffs2AQEBLxyUEIVF9KWrPAw5lzZ8+obxh08BzMzNKftySyr4d8iT6xc09+/fR6vV4uLiYnDcxcWFyMjITM/p0aMHkyZNokWLFlhaWlK5cmV8fX35/PPPs7xPUFAQTk5O+ofsLynUkt771rlzZxwcHABYvnw5AN26dcPS0lK12IR6cpXAXbhwQb+Z/dPq16/PhQsXXjgoIQqDh2fOs+PNPgCUfbklNqVKqhtQEbZ7926mTp3KggULOHnyJOvWrWPz5s1Mnjw5y3MCAwOJjo7WPzL70CpEXtPpdBmK98bGxrJu3TpAivcWZbkaQrW2tiYqKopKlSoZHI+IiMDCQrZXFUWboihcXPgTx0ZOQJuUhK2bC42m5c3q7N3vDcLWuTS1h3+EvXu5PLlHQVO6dGnMzc2JiooyOB4VFYWrq2um54wbN47333+fAQMGAFC3bl3i4uL44IMPGDt2LGZmGT/LWltbYy17ygqVHThwgFu3buHo6EjHjmm9+H/88Qfx8fFUrlw5w1QmUXTkqgfulVde0X86Tff48WM+//xz2rdvb7TghDA1iQ8esuON3hz+JBBtUhLuHdvR5dROStWrY/R7xUdEcW3les7PW4yi1Rr9+gWVlZUVDRs2ZMeOHfpjOp2OHTt24OPjk+k58fHxGZI0c3NzIC3hFqKgSu99e+ONN/Qlb9KHT3v27Fkk5r2KzOWqu2zWrFm0atUKDw8P6tevD6RNsnRxceHXX381aoBCmIqI3QfY0yuA+NsRmFlZ0XjGl9QaPCDPfsGGrd0IioKzTyMcPCvkyT0KqhEjRtC7d28aNWpEkyZNmDt3LnFxcfpVqb169aJcuXIEBQUB4O/vz5w5c6hfvz5NmzblypUrjBs3Dn9/f30iJ0RBk5KSwpo1a4B/V58qioKPjw+XLl2iZ8+eaoYnVJarBK5cuXKcOXOG5cuXc/r0aWxtbenbty/du3eXyZSiyNGlpnJq0ixOT50LioJT9Sr4rvg+T3rdnhb2/8V7i+LWWd26dePevXt8+eWXREZGUq9ePbZu3apf2BAeHm7Q4/bFF1+g0Wj44osvuH37NmXKlMHf358pU6ao9RaEeK4dO3Zw//59nJ2defnll4G0nRfGjRun/zctii6NUsTGD2JiYnByciI6OhpHR0e1wxEm7sn1cPa8N4i7h44DUK1fD5rO/QpLO7s8v++ayo1Bo+Hdm6cp5uby/JMKEFP8OTTFmIVp6927N7/88gsBAQF89913aoejOvkZNJTrFQdXr15l7ty5XLx4EYBatWoxdOhQKleubLTghCjIwtZs5MCHn5IcHYOlowPNF82iUj71hqXXlnPzbWZyyZsQ4vkSEhL0K03TV5/euHGDkydP0rFjR1lgI3K3iGHbtm3UqlWLo0eP4uXlhZeXF0eOHKF27doEBwcbO0YhCpSUuDj2fzCCXe8OJDk6hjIvNaTLyR35lrzBU8On7+TfPYUQ+Wfz5s3ExsZSoUIF/eKcJUuW8Oabb8rcNwHksgduzJgxDB8+nGnTpmU4/tlnn8lKVFFoPTh9nt09PiT6n8ug0eA1ZggNxo/CLB/nfupSUnBt5UPSw8d4du2cb/cVQuSfp2u/mZmZoSgKy5YtA+DNN99UMzRRQORqDpyNjQ1nz56latWqBscvXbqEl5cXiYmJRgvQ2GQMXeSGoihcnP8jR0dNRJecTLGyrrT6+TvKvtxS1ZhMdRKzKf4cmmLMwjRFR0fj4uJCUlISISEheHt7c/jwYXx8fLCzsyMqKgq7PJ5nWxDJz6ChXPXAlSlThpCQkAwJXEhICM7OzkYJTIiCIvH+A/b1H8bNP/8GwL3zK7T8cS42pUupGpepJm9CiGfbsGEDSUlJ1KxZEy8vLwB979sbb7xRJJM3kVGuEriBAwfywQcfcO3aNZo1awakVYuePn06I0aMMGqAQqgpYtf+tNpudyIxs7Kiyczx1Azor1ry9CTsBk/CwnFt3QwzqV8mRKG0YsUKIG34VKPRkJKSwsqVKwHZOkv8K1cJ3Lhx43BwcGD27NkEBgYCULZsWSZMmMCQIUOMGqAQatClpHBy4kzOTPsmrbZbjapptd28a6saV+j/fuXM9G+p0qsbrX76RtVYhBDGd/fuXf0uI+mrT7dt28aDBw9wcXGhbdu2aoYnCpBcJXAajYbhw4czfPhwnjx5AoCDg4NRAxNCLU/CbrD7vUHcO3wCgGr9e9L068l5XtvteRRF4dr/rz5179hO1ViEEHljzZo1aLVaGjVqRJUqVQDYv38/kJbQyX7jIl2uyoi8/PLLPH78GEhL3NKTt5iYGH21aCFM0bVVG9jQoC33Dp/AyskR398W02LxHNWTN4B7R08Se/0mFvZ2uHeSBE6IwkZRFH755Rfg362zAKZNm8aFCxcYNmyYSpGJgihXCdzu3btJTk7OcDwxMZF9+/Zl+zp79+7F39+fsmXLotFo2LBhw3Pvq9FoMjwiIyNz+haEMJASF8f+gcPZ3eNDUmKe4OzTiNdP7qDSO6+rHZpeeu03j9dexaJYMXWDEUIY3YYNGzh69Ci2trb64dN0NWvWxMPDQ6XIREGUo77YM2fO6P//woULBomTVqtl69atlCtXLtvXi4uLw9vbm379+uWork1oaKjBEmJZ+SpexIOQc2m13UKvgEaD9+fDqP/lSMwK0FCFTqvl2uo/gKK596kQhV1ycjKjRo0CYOTIkbi6ugJpOzLY2tqqGZoooHL0F6pevXr6Xq/MhkptbW359ttvs309Pz8//Pz8chICkJawFS9ePMfnCfE0RVG48N0PHBs9SV/brfUv83Fr00Lt0DKI2n+EhIgorIo7Ue4VX7XDEUIY2fz587l69Squrq6MHj0agDt37lCtWjU6derEsmXLsMzHguGi4MtRAhcWFoaiKFSqVImjR49SpkwZ/WtWVlY4Oztjng+lDerVq0dSUhJ16tRhwoQJNG/ePM/vKQqXhHv32d9vKDe3bAeggn8HWvzwteq13bJy++9dAHi+2QlzKyuVoxFCGNODBw+YNGkSAFOmTMHe3h6AlStXEhcXx61btyR5ExnkKIFLH3/X6XR5EszzuLm5sWjRIho1akRSUhI//PADvr6+HDlyhAYNGmR6TlJSEklJSfrnMTEx+RWuKKDu7NzHnl4BJEREYW5tTeNZE6g5qG+BLozb8KvP8XyjExb26i+mEEIY16RJk3j8+DHe3t707t1bf3z58uWA1H4Tmcv1JJ+rV68yd+5cLl68CECtWrUYOnQolStXNlpw/1W9enWqV6+uf96sWTOuXr3K119/za+//prpOUFBQUycODHPYhKmQ5eSwskJMzgz/VtQFIrXrIbvikWU9FK3tlt2aDQaSjeqp3YYQggjCw0NZcGCBQDMnj1bP4p14cIFTp48iYWFBW+//baaIYoCKlerULdt20atWrU4evQoXl5eeHl5ceTIEWrXrk1wcLCxY3ymJk2acOXKlSxfDwwMJDo6Wv+4efNmPkYnCoonYTfY3Po1fWHe6gPf57Wj20wieVNU6vEWQuS90aNHk5qair+/v0GR3vTeNz8/P0qXLq1WeKIAy1UP3JgxYxg+fDjTpk3LcPyzzz6jffv2RgkuO0JCQnBzc8vydWtra6ytrfMtHlHwXFu5ngODRpES8wSr4k40/342Fd/yVzusbElNTGRdrRa4tWlO0zmTsXKSDZyFKCx27tzJxo0bsbCwYObMmfrjOp1Ohk/Fc+Uqgbt48SKrV6/OcLxfv37MnTs329eJjY016D0LCwsjJCSEkiVLUqFCBQIDA7l9+7a+sOHcuXOpWLEitWvXJjExkR9++IGdO3fy999/5+ZtiEIuJTaOw0M/5/LStD0EnZs3wffXBdh7uKscWfbd3rqT2Bs3ubN9L5YO9mqHI4QwEq1Wy6effgrAoEGDDKYHHTx4kBs3buDg4IC/v2l82BT5L1cJXJkyZQgJCaFq1aoGx0NCQnJUk+348eO0adNG/3zEiBEA9O7dm6VLlxIREUF4eLj+9eTkZD799FNu375NsWLF8PLyYvv27QbXEALgwamz7OrxITGXrqIxM8N77HDqfTGiQNV2y470rbMqvvM6GrNczXgQQhRAv/zyCyEhIRQvXpzx48cbvFatWjVmzpwpNeDEM+Xqr9nAgQP54IMPuHbtGs2aNQPgwIEDTJ8+XZ+EZYevry+KomT5+tKlSw2ejx49Wl8fR4jMKIrChW8Wc2zMV2m13cq50frXBbi1bqZ2aDmWEhfHzT/TepcrSfFeIQqN2NhYxo4dC8C4ceMoVcqwfJGzszMjR45UIzRhQnKVwI0bNw4HBwdmz55NYGAgAGXLlmXChAkMGTLEqAEKkV0J9+6zr+9Qbv31/7XdXns1rbZbqZIqR5Y7Nzf9TWp8Ag6VPSnV0FvtcIQQRjJz5kwiIiKoXLkyAQEBaocjTFSuEjiNRsPw4cMZPnw4T548AdBvaC+EGm5v38Pe3oNJiLyLubU1TWZPpMZHfQp0bbfnSR8+rdSti0m/DyHEv27duqVfsDBjxowMi+y++uorKlSowJtvvqkv6CtEZl54QpAkbkJNupQUTnw5jbMz56fVdqtVPa22W91aaof2QpIeR3Nr605Ahk+FKEzGjh1LQkICLVu25I033jB4bdeuXYwbNw5I23HIy8tLjRCFicjVrOioqCjef/99ypYti4WFBebm5gYPIfJDzLXr/NnKn7Mzvkur7fZBL147stXkkzcARavFa/RgKvh3oESdmmqHI4QwguPHj+urKsyZM8egZz02Npb+/fsD8OGHH0ryJp4rVz1wffr0ITw8nHHjxuHm5ibDOyLfXf1tHQcHjSLlSSxWxZ1osXgOnl07qx2W0diUKkmDiZ+pHYYQwkgURdGXDXn//fdp1KiRweuBgYGEhYVRoUIFZsyYoUaIwsTkKoHbv38/+/bto169ekYOR4hnS4mN4/CQz7n8c1ptN5cWTWn96wLsK5RXOTIhhMjahg0b2Lt3L7a2tkyZMsXgtT179vDdd98B8MMPP+DoKAW7xfPlKoFzd3d/ZvkPIfLC/ZNn2N3jQ2IuX0ur7fbFCOqNHW5ytd2e53bwHlJi4yjv9zIWNjZqhyOEeEHJycmMGjUKgJEjR+Lu/m8x8bi4OPr16weklejKz52MhGnL1Ry4uXPnMmbMGK5fv27kcITISNHpODd3EX8260jM5WvYlS+L3451NBg/qtAlbwCnp37Nzrf68s/CpWqHIoQwgvnz53P16lVcXV0z1DLdunUr165dw93dnVmzZqkUoTBF2f7rV6JECYO5bnFxcVSuXJlixYphaWlp0Pbhw4fGi1AUaQl376XVdtu6AwCPLh1p8b85WJcsoXJkeSPu1h0i9x0GwNNE9msVQmTtwYMHTJo0CYApU6ZkKA3StWtXdu/ejaIoMnQqciTbCVxO9jgVwhhuB+9hb+8AEqLuYW5jQ9PZk6j+Ya9CvWgmbO1GUBRcWjTF3r2c2uEIIV7QpEmTePz4Md7e3vTu3TvTNq1bt87nqERhkO0ELqt/eEIYmzY5mZNfTufszLRJvcVrV6fNiu+LRDkN/d6nUvvtuebPn8/MmTOJjIzE29ubb7/9liZNmmTZ/vHjx4wdO5Z169bx8OFDPDw8mDt3Lh07dszHqEVREhoayoIFCwCYPXu2QZmt77//nnbt2lG5cmW1whMmLkcTiHQ6HTNnzmTjxo0kJyfTtm1bxo8fL5vtCqOJuXqd3T0/5P6xEABqfNSHJrMmYFEE/o3FXLvO/aOn0JiZUbEQlUTJC6tWrWLEiBEsWrSIpk2bMnfuXDp06EBoaCjOzs4Z2icnJ9O+fXucnZ1Zu3Yt5cqV48aNGxQvXjz/gxdFxujRo0lNTcXf35+2bdvqjx84cIBBgwZha2tLaGgo5cvLKnqRczlK4KZMmcKECRNo164dtra2zJs3j7t377JkyZK8ik8UIVeXr+VgwGdptd1KFKfF/77G842i0zsStvoPANzatMDWJWMSIv41Z84cBg4cSN++fQFYtGgRmzdvZsmSJYwZMyZD+yVLlvDw4UMOHjyon7Pr6emZnyGLImbnzp1s3LgRCwsL/dZZAAkJCfTt2xdFUXjnnXckeRO5lqNVqL/88gsLFixg27ZtbNiwgU2bNrF8+XJ0Ol1exSeKgJQnsezt8wl7egWQ8iQWl5Yv0eXkjiKVvAE8OnsRkK2znic5OZkTJ07Qrl07/TEzMzPatWvHoUOHMj1n48aN+Pj4EBAQgIuLC3Xq1GHq1Klotdos75OUlERMTIzBQ4js0Gq1+qK9gwYNonr16vrXxo0bx+XLlylbtixz5sxRK0RRCOQogQsPDzeYL9KuXTs0Gg137twxemCiaLh/4jR/NGrHlV9XozEzo/74Ufht/71IFub1Xb6IrhcO4Pn2a2qHUqDdv38frVaLi4uLwXEXFxciIyMzPefatWusXbsWrVbLli1bGDduHLNnz+arr77K8j5BQUE4OTnpH0/X7hLiWX755RdCQkIoXrw448eP1x8/dOiQPmlbvHgxJUoUztX0In/kaAg1NTUVm/8UFrW0tCQlJcWoQYnCL6222/ec+HwKupQU7NzL0XrZQlxbNFU7NFU5Va+idgiFkk6nw9nZmcWLF2Nubk7Dhg25ffs2M2fONPgD+7TAwEBGjBihfx4TEyNJnHiu2NhYxo4dC6T1tpUqVQowHDrt1asXnTp1UjNMUQjkKIFTFIU+ffpgbW2tP5aYmMhHH32EnZ2d/ti6deuMF6EodBKi7rK371Bub9sJgMcbnWixeHahre32PIqikBobh6WD/fMbC0qXLo25uTlRUVEGx6OionB1dc30HDc3NywtLQ1WAdasWZPIyEiSk5OxsrLKcI61tbXB7zohsmPmzJlERERQuXJlAgIC9Mfnz59PaGgobm5uUpZLGEWOErjMSom89957RgtGFH63/97N3j6D/63tNmcy1T94v1DXdnueB6fOsrmlP55v+dNq6bdF+muRHVZWVjRs2JAdO3bQpUsXIK2HbceOHQwePDjTc5o3b86KFSvQ6XSYmaXNHLl06RJubm6ZJm9C5MatW7f0CxZmzJhh8AHgk08+ISYmhsaNG8vQqTCKHCVwP/30U17FIQo5bXIyJ74I4tzstJpIJerUwHfF95SoXUPlyNQXtmoD2sREtIlJkrxl04gRI+jduzeNGjWiSZMmzJ07l7i4OP2q1F69elGuXDmCgoKAtInk3333HUOHDuWTTz7h8uXLTJ06lSFDhqj5NkQhM3bsWBISEmjZsiVvvPGGwWvW1tb6HRmEMIbCt5GkKHBiroSxu+dH3D8eAkCNQX1pMnN8kajt9jyKTse1/y8fIqtPs69bt27cu3ePL7/8ksjISOrVq8fWrVv1CxvCw8P1PW0A7u7ubNu2jeHDh+Pl5UW5cuUYOnQon332mVpvQRQyx48f55dffgHSytykfxjbtWsXLVq0yLDlpBAvSqMoiqJ2EPkpJiYGJycnoqOjZd+5fHBl2VoOBowmNTYOqxLFafnD13h0KVrlQZ4l6uAxNrfsjKWDPd0jzhWZpNYUfw5NMWaRPxRFwdfXl7179/L+++/rE7ljx47x0ksvUa9ePXbv3o2Dg4PKkZo2+Rk0JD1wIk+kPInl4OAxXF22BgDXVj60+mW+7O/5H2Gr1gNQ4XW/IpO8CVHYbNiwgb1792Jra8uUKVOAtDqCffr0QafTUb16dUnehNFJAieM7v7xEHb1+JAnV6/ra7t5BQ7F7KkVgAJ0Wi1hazYCMnwqhKlKTk5m1KhRAIwcOVJfambSpElcuHABZ2dnvvnmGzVDFIWUJHDCaBSdjnNfL+L451NQUlOxq1Ae32ULcWme9QbjRVnknoMkRN3DumQJyrZrpXY4QohcmD9/PlevXsXV1ZXRo0cDcOLECaZPnw7AwoULKV26tJohikJKEjhhFPGRd9nX5xNuB+8GwPPNzjRfPBvrEsVVjasgK16rOo1nTkBJTcVcSlkIYXIePHigX1k6ZcoU7O3tSU5Opk+fPmi1Wrp168abb76pcpSisJIETrywW1t3srfvJyTevY+5rS0vfT2ZagPek5IYz1HM1Zm6IwapHYYQIpcmTZrE48eP8fb21tdJnTJlCufOnaNMmTJ8++23KkcoCjNJ4ESuaZOTOTF2KufmLASgRN2aabXdalV/zplCCGHaQkNDWbAgra7l7Nmz9bt8dO/eneDgYIYPH06ZMmXUDFEUcpLAiVyJvnyN3T0/4sGJ0wDUDOhH4xnjsfjPXrkic+e+XoR1qZJ4vtFRttASwgSNGjWK1NRU/P39adu2rf54jRo12L9/v0EdQiHygiRwIkcUReHKr2s4NPgzUuPisS5ZghY/fI3H635qh2YyUhMSODlhBqmxcThVrYizT2O1QxJC5MCOHTvYtGkTFhYW+q2zIiIicHNzA5DkTeQL+Vcmsi055gl7ewWwr+8npMbF4+rbjC6ndkrylkO3tuwgNTYOew93yrzUSO1whBA5oNVq+fTTT4G0LdqqV6/O6dOnqVixIiNHjiQ1NVXlCEVRIT1wIlvuHT3J7p4f8eTaDTTm5tSfMAqvz4ZIbbdcuLZqAwAV33ldFnoIYWJ+/vlnTp8+TfHixRk/fjwpKSn06dOHpKQkwsLC9HPhhMhrksCJZ1J0Os7OXsCJL4JQUlOx93Cn9bKFuDSTYb/cSHkSy83NwYAU7xXC1MTGxjJ27FgAxo0bR6lSpZg8eTIhISGULFmSBQsWyIcykW8kgRNZio+IYm+fT7izfQ8Anm+9RvPvZ2Fd3EnlyExX+MataBMTcaxWmZL16qgdjhAiB2bMmEFkZCSVK1cmICCAs2fPMnnyZAC+++47XFxcVI5QFCWSwIlM3fxrB/v6fkLivQdptd3mfkW1/j3l0+ULSh8+rdSti3wthTAhN2/eZNasWUBaImdmZkafPn1ISUmhS5cuvPvuuypHKIoaVRcx7N27F39/f8qWLYtGo2HDhg3PPWf37t00aNAAa2trqlSpwtKlS/M8zqJEm5TEkU+/JLhzDxLvPaCEVy1eP/Y31aUw7wtTdDq0Scmg0cjwqRAmZuzYsSQkJNCyZUveeOMNZs6cycmTJylRogQLFy6U348i36mawMXFxeHt7c38+fOz1T4sLIxOnTrRpk0bQkJCGDZsGAMGDGDbtm15HGnREH3pKn+26Mz5ud8DUGtwf/wP/UXxmtVUjqxw0JiZ8eq21bx764x8TYUwIcePH+fXX38FYM6cOWg0GsqVK4ejoyPffPMNrq6uKkcoiiJVh1D9/Pzw88t+CYpFixZRsWJFZs+eDUDNmjXZv38/X3/9NR06dMirMAs9RVG48vMqDg0JTKvtVqokLX+cSwV/+ZrmhWKuzmqHIITIJkVRGDFiBADvv/8+jRqllf7p3bs3fn5+stuCUI1JzYE7dOgQ7dq1MzjWoUMHhg0bluU5SUlJJCUl6Z/HxMTkVXgmKTnmCQcHjeLayvUAuLVpTquf52NXzk3lyAqX5JgnaJOSsC1TWu1QhBA5sH79evbt24etrS1TpkxBq9XqS4U4O8uHMaEekyrkGxkZmWGVj4uLCzExMSQkJGR6TlBQEE5OTvqHu7t7foRqEu4eOcGGBi9zbeV6NObmNPwqkA7b1kjylgeu/LqaleW8ODJinNqhCCGyKSkpidGjRwMwcuRInjx5Qo0aNdi6davKkQlhYglcbgQGBhIdHa1/3Lx5U+2QVKfodJyZ8S2bW71GbFg49h7udNrzB96Bw6Qwbx65tmoDilaLXYVyaocihMim+fPnc/XqVVxdXRkxYgR9+/blypUrfPfdd2qHJoRpDaG6uroSFRVlcCwqKgpHR0dsbW0zPcfa2hpra+v8CM8kxEdEsbf3YO7s2Auk7QbQbOFMqe2Wh2LDb3H3wFHQaKj49utqhyOEyIb79+8zadIkAKZMmcLixYs5evQoTk5OfP/99ypHJ4SJJXA+Pj5s2bLF4FhwcDA+Pj4qRWRabm7Zzr6+Q0i8/wCLYra8NG8qVft2l+XveSxszUYAXFv5yPC0ECZi0qRJREdH4+3tTZMmTfSLF+bOnUu5ctKTLtSn6hBqbGwsISEhhISEAGllQkJCQggPDwfShj979eqlb//RRx9x7do1Ro8ezT///MOCBQtYvXo1w4cPVyN8k6FNSuLIiHEE+/ck8f4DSnrX5rVjwVTr10OSt3ygL977ThdV4xBCZE/63xdIK9o7YMAAkpKS8PPzo3fv3ipHJ0QaVXvgjh8/Tps2bfTP05dq9+7dm6VLlxIREaFP5gAqVqzI5s2bGT58OPPmzaN8+fL88MMPUkLkGaJDr7Crx4c8DDkHQK0hA2kU9AUWNjYqR1Y0PDh9ngcnTqMxN8ejaye1wxFCZMPo0aPRarX4+/tz5swZjhw5gqOjI4sXL5YPvaLAUDWB8/X1RVGULF/PbJcFX19fTp06lYdRFQ6KonB56UoODwkkNT4Bm9KlaPHjXCp0fkXt0IqU9MS5bNtWUkJECBOwY8cONm3ahIWFBTNnzmT69OkAfP3115QvX17l6IT4l0nNgRPZkxwdw4FBowj7/6E7t5db0Prn+RQrK9XC85qi0xF74yYOFT0AqPL+29zatpN6X4xQOTIhxPNotVo+/fRTAAYNGkT16tVZsmQJvXv3plWrVipHJ4QhSeAKmbuHj7O750fEXr+JxtycBpPHUHdkgJQHyQcRuw9w7LNJxN26w1uXDmNpZ4fGzIw2K2TFmhCm4Oeff+b06dMUL16c8ePH64+3bt1axaiEyFyhrwNXVOi0Wk5Pm5dW2+36Tew93em0dyPenw2R5C2PPTp3kWD/nvzV9k3uHw8h5UksD06cUTssIUQOxMbGMnbsWCBtwdyQIUMylK0SoiCRHrhCIP5OJHt6BxCxcz8AFbt1ofnCmVg5OaocWeEWdzuCUxNmcHnpShSdDo2FBdUHvk/9cSOwdZEtdoQwJTNmzCAyMpLKlSuzb98+Dhw4QEpKCqtXr1Y7NCEyJQmciQv/82/29RtK0oOHWBSzxefbaVTp3U1WSuWx+Mi7/F7Dh9T4tC3cPN/sTMMpn+NUrbLKkQkhcurmzZvMmjULSFso9+OPP2Jvb8/MmTNVjkyIrEkCZ6K0SUkc+2wSF779AYCS9erQZsX3OFWvonJkhZeiKPrEuJirM+6d2hMfEUXjaeNw9mmscnRCiNwaO3YsCQkJNG7cmBUrVgAwa9YsPDw8VI5MiKxJAmeCHv9zmd09PuTh6fMA1B76AY2CvsBctgzLE4qiELZmIyGTZ9N+0zIcPCsA0OLHuVgUKya9nUKYsOPHj/Prr78CaatQExISePnll/nggw9UjkyIZ5NFDCZEURQu/bicjY3b8/D0eWxKl6L9xmU0nTNZkrc8ErHnIJt8XmV39w94fCGUszPn61+ztLOT5E1F8+fPx9PTExsbG5o2bcrRo0ezdd7KlSvRaDR06dIlbwMUBZ6iKPoC8k2aNOHkyZPY2dnx448/ys+2KPCkB85EJD2O5uCgUYSt/gMAt7Yt02q7ubmoHFnh9Oj8PxwP/Iqbm4MBsLArRt1Rg6kz/COVIxMAq1atYsSIESxatIimTZsyd+5cOnToQGhoKM7OWS8guX79OiNHjqRly5b5GK0oqNavX8++ffuwsbHh8ePHQNpiBk9PT1XjEiI7pAfOBNw9dIw/GrYlbPUfaCwsaBT0Ba9uXS3JWx45PPwLNtRrw83NwWjMzakxqC9vXz5C/XGfYmlvp3Z4ApgzZw4DBw6kb9++1KpVi0WLFlGsWDGWLFmS5TlarZaePXsyceJEKlWqlI/RioIoKSmJ0aNHA2lbZx0/fpzZs2fz0UfyIU2YBumBK8B0Wi1npn/DqQkzUbRa7CtWwHf5IpybNlQ7tELN0sEeRafD441ONJryuSwMKWCSk5M5ceIEgYGB+mNmZma0a9eOQ4cOZXnepEmTcHZ2pn///uzbt++590lKSiIpKUn/PCYm5sUCFwXK/PnzuXr1Km5ubowaNQp7e3v9cKoQpkASuAIq7nYEe3sHELHrAACV3n2DZgtmSG03I9MmJ/PP9z9TuoE3Ls2bAFB3ZADlX22LSzNZWVoQ3b9/H61Wi4uLYQ+0i4sL//zzT6bn7N+/nx9//JGQkJBs3ycoKIiJEye+SKiigLp//z6TJk0CoH379tjZSc+6MD0yhFoAhW/axob6LxOx6wAWdsVoueQbWi9bKMmbESmKwrXVf7CudguODPuCIyO/RFEUAKwcHSR5K0SePHnC+++/z//+9z9Kly6d7fMCAwOJjo7WP27evJmHUYr8NGnSJKKjo7G3t+eXX35hzJgxaockRI5JD1wBkpqYyPHPJnHhux8BKFW/Lr4rvpfisEYWsecgxz6byP1jIQDYupShWu/uabspyLZjBV7p0qUxNzfPsM1RVFQUrq6uGdpfvXqV69ev4+/vrz+m0+kAsLCwIDQ0lMqVM/6MWVtbYy2ruwudf/75hwULFgBp22fZ2tpKyRBhkiSBKyAeX7zErh4f8ujMBQBqD/+IRlM+l/IgRvT44iWOjZnMzT//Bv5/ZenIAOqMGCSLE0yIlZUVDRs2ZMeOHfpSIDqdjh07djB48OAM7WvUqMHZs2cNjn3xxRc8efKEefPm4e7unh9hiwJi9OjRaLVazM3N0Wq1TJs2LdMEXoiCThI4laXXdjs87Au0CQnYlClFy5++xd2vrdqhFTr3T5zh5p9/ozE3p/rA96k37lOKucqepaZoxIgR9O7dm0aNGtGkSRPmzp1LXFwcffv2BaBXr16UK1eOoKAgbGxsqFOnjsH5xYsXB8hwXBRuO3bsYNOmTWg0GrRaLS1atMg06RfCFEgCp6Kkx9Ec+HAk19duBKBsu9a0+vk7SSqMJDnmCTGXrlK6UT0AKvd4k4enz1F9wHuystTEdevWjXv37vHll18SGRlJvXr12Lp1q35hQ3h4OGZmMsVX/Eur1fLpp58CaR+cbWxsWLJkifw7ESZLo6TP3C4iYmJicHJyIjo6GkdH9RYFRB08xp73BhF742Zabbcpn1NnxCA08svkhWmTkwld/Ashk+dgZmVJ138OYimrzAqUgvJzmBOmGLP415IlS+jfvz8ajQZFUZgzZw7Dhw9XOyyRA/IzaEh64PKZTqvlzLR5nJo4C0WrxaGyJ77LFlKmSQO1QzN5iqJwfe0mjo+dwpOr1wFwrFaZuPDbFK9ZTd3ghBCqiY2NZezYsQAMGTKE6OhohgwZonJUQrwYSeDyUdytO+zpFUDknoMAVO7RFZ/507FydFA5MtMXufcQRz+byP2jp4C0laX1vxxFtf49MLO0VDk6IYSaZsyYQWRkJFWqVGHGjBlYWVmpHZIQL0wSuHxy44+/2D9gOEkPH2FhV4xm82dQ5f231Q6rUIgOvcKWNl0AWVkqhDB08+ZNZs6cCSDJmyhUJIHLY6mJiRwbPZGL89P2aCzVwCuttltV2YvxRaTGx2NRrBgATtWrUOndN7Aq7iQrS4UQBj7//HMSExPRaDTExcWpHY4QRiMJXB56dCGU3T0+5NHZiwDUGTGIhlM+x1w+AeZacswTzs78jn8W/czrJ7ZjX6E8AK1/XSALQIQQBo4fP86yZcsAsLS0pGFD2UdaFB6SwOUBRVEI/d+vHBnxZVptN+fStFr6HeU7tFE7NJOlTU4m9H+/EjJpNon3HwBw5ZfV1PsibfNpSd6EEE9TFIWAgAD988mTJ1OzZk0VIxLCuCSBM7KkR4/Tarv9vgmAcu19abn0WxnWyyVFUbj++5+cGDuFmCthQNrK0kZTv8Cji5/K0QkhCqp169Zx9OhRAOrVq8eIESNUjkgI45IEzoiiDhxl93uDiAu/lVbbbepY6gz/SHqHcklRFLa+8hYRO/cDYONcmgbjR8vKUiHEMyUlJfHxxx8DYG5uzvLly7GwkD93onCRf9FGoNNqOT11LiGTZqHodGm13ZYvokzj+mqHZtI0Gg3OLzXi3pGT1Pn0Y+qOGISlg73aYQkhCrAzZ84wbNgw7t69C6Tte1urVi2VoxLC+CSBe0Fxt+6w5/2Pidx7CIDK771Ns++mSaKRC/F3Ijk5cSZV3nsb15YvAeA1+hNqBvSXIWghxDNdunSJ8ePHs3LlSiDtA2C1atX44osvVI5MiLwhCdwLuLFhC/sHjkir7WZvR7Pvpkttt1xIjnnC2VnzOf/1IlLjE3h07iKd929Go9Fg6WAvybAQIkvh4eF8+eWX/PLLL6TvDNmtWzcmTpxI1apVZa9TUWhJApcLqQkJHB01kX8W/gRA6Ub18F2+CMcqFVWOzLToUlL453+/EjJpFon30laWOjdrTONpX6LRaFSOTghRkEVFRTF58mQWLVqEVqsFwM7Ojt27d9OoUSOVoxMi70kCl0OPzv+TVtvt3D8A1B0ZQIPJY6S2Ww7d/GsHR4Z/Qczla4DhylJJ3oQQWXn06BEzZsxgzpw5JCcn64+7uLgwffp06teXuceiaJAELpsURSF08a8cGTEObWIiti5laLX0O8q94qt2aCYp8d4DYi5fw8a5NPW/HEX1AT1lZakQIkuxsbHMmzePoKAggx0VihcvzoQJE/joo4+wtrZWMUIh8pckcNmQ9PAR+z/4lBvrNwNQ7pU2tFr6DbYuMrE+ux5fvETc7QjKtWsNQOWeXUmJiaFq73dljpsQIkuJiYksWrSIqVOncu/ePf1xGxsbxowZw4gRI3BwcFAxQiHUUSBmd86fPx9PT09sbGxo2rSpvvhiZpYuXYpGozF42NjY5FlskfsOs6FBW26s34yZpSVNZk3klc0rJHnLpviIKPZ/+CnrvVqzr+8QUuPjATAzN6fW4AGSvAkhMpWSksL//vc/PD09GT58OPfu3aNKlSosX76cefPmER4ezvjx4yV5E0WW6j1wq1atYsSIESxatIimTZsyd+5cOnToQGhoKM7OmSdJjo6OhIaG6p/nxZwpXWpqWm23ybNRdDocq1TEd8X3lG7obfR7FUYpT2I5O2s+5+YsJDU+AYDSjeuTHBOr34ReCCH+S6fTsXLlSj7//HNu3LgBpP2OnzNnDgEBAVjKVAshgAKQwM2ZM4eBAwfSt29fABYtWsTmzZtZsmQJY8aMyfQcjUaDq6trnsa1p1cAYas2AFClVzd8vpkqvUXZkOnKUp9GNJ4+HpfmTVSOTghRUCmKwsaNGwkMDOTixYsGr3Xu3JmuXbtK8ibEU1QdQk1OTubEiRO0a9dOf8zMzIx27dpx6NChLM+LjY3Fw8MDd3d3Xn/9dc6fP59l26SkJGJiYgwe2VHjg15YOTnS+pf5tPrpG0nesulByDkOfxJI4r0HOFatxMtrltBp35+SvAkhMqUoCtu3b6dx48Z06dLFIHlr2bIlhw4dYuPGjbi7u6sYpRAFj6o9cPfv30er1eLi4mJw3MXFhX/++SfTc6pXr86SJUvw8vIiOjqaWbNm0axZs/9r7/7jcrr//4E/6qKSfogopVxDfstFv9RmxZqY+bU1jVH6YGZjrNlIv8So+TE2mWGbmS/Lm9vE2xtvtBoq0o95r6HhjRquYo1+68d1vn/0duZSUarrdNXjfrtdt+28zuuc87zOuc7x7HXO63Xw22+/oVu3btXqR0REIDw8vN6xdfV4HpOvpULP1KTey7Y2hVl/wMi2at93dhqCvu/MgNnAvugzaxp7lhJRrZKSkhAUFIS4uDi18sGDB2P16tV4+eWXOawQUS0kv4VaX66urnB1dRWn3dzc0K9fP2zZsgUrVqyoVj8wMBABAQHidH5+fp3/kmPy9mT3Lv6OlKUrcfPfcXj9UqKYxLlt+lTiyIioOTt//jyCgoLwr39V9ezX09PDO++8A0NDQwwZMgTe3t58gwLRU0iawJmbm0MmkyEnJ0etPCcnp87PuLVt2xZDhgzBlStXapyvr6/PsYEaWfHtHKSHr8Hv3+yCoFJBRybD7bgE2Pn5SB0aETVjmZmZCA0NxT/+8Q+xbNKkSdiwYQNsbW0ljIxI+0j6J46enh4cHBwQGxsrlqlUKsTGxqq1sj1JZWUlfv31V3Tt2rWpwqT/KS8oRNqy1djX2wWZ23ZCUKlgO2EMJv3nZyZvRFSrGzduYObMmejXr59a8mZqaorp06czeSN6BpLfQg0ICICfnx8cHR3h7OyMDRs2oKioSOyV6uvrC2tra0RERAAAli9fjmHDhqFXr164d+8e1qxZgxs3bmDWrFlSfo0WT1Vejv0KDxRezwYAdB7mAKdPw2D5govEkRFRc6VUKrFq1Sps3rwZFRUVYrmBgQECAgLw0UcfoUOHDtIFSKTFJE/gfHx8cOfOHYSGhkKpVEKhUODo0aNix4asrCy1ZyH++usvzJ49G0qlEmZmZnBwcEBiYiL69+8v1VdosQRBEB8g1m3bFj2mvIbr+/4Jx5VB6P7aWD5cTEQ1ysvLw5o1a/DFF1+g+H+DdwOATCbDO++8g+Dg4CYfCoqopdMRBEGQOghNys/Ph6mpKe7fvw8TE3ZSqI3y9FmkLFkOx8hQsZWtorgYum3bsmcpNZg2nofaGLOmFRQU4PPPP8enn36KwsJCAICLiwscHR1x7949hIeHo2fPnhJHSdqK56A6yVvgqHm5d+kyUpauRNaBIwCA9OVrMObYPgDgGxSIqEalpaXYvHkzVq5ciT//rBrA29bWFlFRUXj11VfZWk/UBJjAEQCgWJn7d8/SykroyGToPfMtDAldJHVoRNRMlZeXY/v27QgPD8etW7fU5o0YMQLjxo2TKDKilo8JHOHCpm+QEvgJKoqqnlWxHT8ajquC0KFfb4kjI6LmqLKyEtHR0QgNDcV///tftXkDBw5EZGQkXnnlFYmiI2odmMAR2hoZoaKoGJ1dhlb1LB0+TOqQiKgZEgQBBw4cQEhICDIyMtTmyeVyfPLJJ3jzzTchk8kkipCo9eBQ162MIAi4/uO/cH3/YbGs5zRvvHzw/+HVhMNM3khrbNq0CXK5HAYGBnBxcUFycnKtdbdt24bhw4fDzMwMZmZm8PT0fGJ9UicIAo4fPw5nZ2dMmjQJGRkZ6NChA3x9fdG5c2dERUUhMzMTb731FpM3Ig1hAteKKE+fxb+Gv4qf3vg/nFmwFBX/696vK5PBZizfOUjaY8+ePQgICEBYWBjS0tIwePBgeHl5ITc3t8b68fHxmDJlCuLi4pCUlAQbGxuMGjUKN2/e1HDk2icxMREjR47EqFGjkJKSgrZt22Lp0qX473//i++++w7Xr1/He++9Bz09PalDJWpVOIxIK3Dv0mWkBH6CrINHAQBtDNthYMBcDPp4Htq2by9xdNQaNfQ8dHFxgZOTE6KiogBUvcHFxsYG8+fPx5IlS566fGVlJczMzBAVFQVfX1+NxKxtfvnlFwQHB4vvK32oS5cuyM7OZsJGGtfazsGnYQtcC1aszEXC3I+w394dWQePQkdXF71nTYN35hkMDV/M5I20UllZGVJTU+Hp6SmW6erqwtPTE0lJSXVaR3FxMcrLy9GxY8emClNrZWZmwsfHB0OGDFFL3nR1dTFr1iykpKQweSNqBtiJoQUrvHYDmVu/BwDYjvOCw6ogmPXvI3FURA1z9+5dVFZWim9recjCwgKXLl2q0zoWL14MKysrtSTwcQ8ePMCDBw/E6fz8/GcLWEvcuHED4eHh2LFjB1Qqldo8b29vrFixAn379pUoOiJ6HFvgWhBVeTlyz6SI011cnaAIDsArcTHwjPmeyRsRgMjISERHR2P//v0wMDCotV5ERARMTU3Fj42NjQaj1BylUon58+fDzs4O27dvh0qlwsiRIyGTyfDyyy/j3Llz2Lt3L5M3omaGCVwL8LBn6Y/27jjy0usozP77weyh4Yth+aKrhNERNS5zc3PIZDLk5OSolefk5Dz1/Zpr165FZGQkjh07Bnt7+yfWDQwMxP3798VPdnZ2g2NvTvLy8rBkyRI899xziIqKQnl5OV566SUkJSUhNjYWGRkZOHbsGBwdHaUOlYhqwAROy+UkJIs9S/N/v4q2xu2R//tVqcMiajJ6enpwcHBAbGysWKZSqRAbGwtX19r/WFm9ejVWrFiBo0eP1ikp0dfXh4mJidqnJSgoKMCKFSsgl8vx6aeforS0FACgo6ODjRs3YtiwqqGE2OJG1LzxGTgt9fg7S9sYtsOAD97BoEXvQc/EWOLoiJpWQEAA/Pz84OjoCGdnZ2zYsAFFRUXw9/cHAPj6+sLa2hoREREAgE8//RShoaHYvXs35HI5lEolAMDIyAhGRkaSfQ9NKikpwebNm7Fq1SrxfaUPdevWDeHh4bCzs5MoOiKqLyZwWqi8oBD/HDYa5QWF0NHVhd3/TcXQsI9gaPXk20dELYWPjw/u3LmD0NBQKJVKKBQKHD16VOzYkJWVBV3dv28wbN68GWVlZfD29lZbT1hYGJYtW6bJ0DWuvLwc3377LVasWFFt3LtOnTph6dKlePfdd5/4PCARNT8cB05LVJSWos0jF9iUpZ/gr98y4RgRzM4JpHW08TzUtpgrKyvxww8/ICwsTHxfqbW1Ne7duwcA+PDDD/Hhhx9qxXchArTvHGxqbIFr5lTl5fj9m91IX74GI/d+C4vnnQEAQ1cEQpevrCGixwiCgJiYGISEhOC3334DAHTu3BnBwcGYM2cOEhISMHDgQHTp0kXiSImoIZjANVOCIOBGzBGkLP1E7JRw8cu/Ezgmb0T0qIfvKw0KCkJKSoravKioKEyePBkAMHLkSCnCI6JGxgSuGcpJPIdzi8ORm3gOAGDQuRMUIR+iz+zpEkdGRM1RQkICgoKC8PPPP1ebN378eAwcOFCCqIioKTGBa2aS5gfi4pffAgBk7dphYAB7lhJRzdLT0xEcHIzDhw9Xmzd8+HBERkbCzc1NgsiIqKkxgWtmzB0GV/Us9Z+Cocs+Zs9SIqrm0qVLCA0Nxd69ewFUvae0Q4cOyMvLg0KhwKpVqzB69Gjo6OhIHCkRNRUmcBIqLyxCxmebYdLrOfSc+joAoOf0N9B5mAM69OV4TESk7vr16+L7Sh8OIDB16lQsW7YM2dnZyM3NxeTJk9WGUCGilokJnAQe7VlaknMHhtZd0X3SK2jTrh10ZTImb0Sk5vbt21i5ciW2bNmCiooKsXzhwoVYv349AHAQXqJWhgmcBj3sWZoatBL3M68AAIx7yuG4MggyDqJJRI/5888/sXr1amzcuBElJSVq80xNTdGzZ0+JIiMiqTGB05A/039F0vuBf/csNe8ERWhVz1KZnp7E0RFRc1JQUID169dj3bp1yM/PV5tnYGCABQsW4OOPP0bHjh0lipCIpMYETkMqSkqRm3iuqmfpB3Mw6KN57FlKRGpKSkrw5ZdfIjIyEnfv3gUAceR5mUyGWbNmISQkBNbW1hJHSkRSYwLXREpycnHnbBpsx48GAFi4OcE1KhK240ejvXVXiaMjouakrKxMfF/prVu3AAC9e/fG8uXLMWjQIKxYsQLLly/nc25EJGIC18ge9iz9de0mCJUqeGcmoX03KwBAv7n+EkdHRM1JZWUldu/ejbCwMFy7dg0AoKOjAzc3N8THx6NNm6pL9A8//CBlmETUDDGBaySqioqqnqXhq1GScwcAYO6kQNm9+2ICR0QEVHVo2r9/P0JCQnDhwgUAVYmbIAji8CAP/0tEVBMmcA0kCAKyDhxBytJHepb26A6HlUF47o3xHEiTiESCIODYsWMIDg4W31f6aOLWv39/rFq1CuPH89pBRE/GBK6BSnLuIP6tuagsLa3qWRoSgD5v+7JnKRGpOX36NIKCgnDy5EkAQNu2bVFeXg5BEGBra4vly5dj2rRpkMlkEkdKRNqACdwzKL6dA8OuFgAAQ8susF/yPiofPID9R/OgZ2oicXRE1JykpaUhODgYR44cAQDo6+vj3Xffxdy5czFu3DjMnTsX77zzDvT19SWOlIi0CRO4eijJyUX6is+QuW0nxsbHoIurEwBgSMiHEkdGRM3NxYsXERoain379ollFhYWOHfuHGxsbAAAFy5c4GuviOiZMIGrg/LCImSs/wq/rt2EisIiAEDWv46LCRwR0UPXrl1DeHg4du7cCZVKpTbvr7/+QkFBgTjN5I2InlWzuHps2rQJcrkcBgYGcHFxQXJy8hPr7927F3379oWBgQEGDRqEw4cPN0lcqooKXNryPfb1GYb0ZatRUVgEcycFxsT+CMdPljbJNolIe125cgV9+vTBjh071JI3XV1d+Pv74/Lly+jfv7+EERJRSyF5Ardnzx4EBAQgLCwMaWlpGDx4MLy8vJCbm1tj/cTEREyZMgUzZ85Eeno6Jk6ciIkTJyIjI6PRYzv2yhQkvvsRSpS5MO7RHR4/bMW4pKPo6vF8o2+LiLRfr169MGTIELUepJMmTcKvv/6Kb7/9Fra2thJGR0QtiY4g8WBDLi4ucHJyQlRUFABApVLBxsYG8+fPx5IlS6rV9/HxQVFREQ4dOiSWDRs2DAqFAl999dVTt5efny++msbE5MkdDn7/djfOLVkBRUgA+s7xY89SokZSn/OwuahrzPn5+XBzc0OXLl0QEREBFxcXDUZJ1HJp43WjKUn6DFxZWRlSU1MRGBgolunq6sLT0xNJSUk1LpOUlISAgAC1Mi8vL8TExDR6fL38fCB//VX2LCWiOjMxMcHJkydhZmbGsdyIqMlImsDdvXsXlZWVsLCwUCu3sLDApUuXalxGqVTWWF+pVNZY/8GDB3jw4IE4nZ+fX+f4dGUyJm9EVG8dO3aUOgQiauEkfwauqUVERMDU1FT8POy+T0RERKStJE3gzM3NIZPJkJOTo1aek5MDS0vLGpextLSsV/3AwEDcv39f/GRnZzdO8EREREQSkTSB09PTg4ODA2JjY8UylUqF2NhYuLq61riMq6urWn0AOH78eK319fX1YWJiovYhIiIi0maSD+QbEBAAPz8/ODo6wtnZGRs2bEBRURH8/f0BAL6+vrC2tkZERAQAYMGCBXB3d8e6deswduxYREdHIyUlBVu3bpXyaxARERFpjOQJnI+PD+7cuYPQ0FAolUooFAocPXpU7KiQlZWlNlq5m5sbdu/ejeDgYCxduhR2dnaIiYnBwIEDpfoKRERERBol+ThwmsZxZIikp43noTbGTNSS8BxU1+J7oRIRERG1NEzgiIiIiLQMEzgi0kqbNm2CXC6HgYEBXFxckJyc/MT6e/fuRd++fWFgYIBBgwbh8OHDGoqUiKjxMYEjIq2zZ88eBAQEICwsDGlpaRg8eDC8vLyQm5tbY/3ExERMmTIFM2fORHp6OiZOnIiJEyciIyNDw5ETETUOdmIgIo1r6Hno4uICJycnREVFAagaP9LGxgbz58/HkiVLqtX38fFBUVERDh06JJYNGzYMCoUCX331lUZiJqKG4Tmoji1wRKRVysrKkJqaCk9PT7FMV1cXnp6eSEpKqnGZpKQktfoA4OXlVWt9oOo9yvn5+WofIqLmggkcEWmVu3fvorKyUhwr8iELCwsolcoal1EqlfWqD/A9ykTUvEk+kK+mPbxjzL+miaTz8Pxrzk9wBAYGIiAgQJy+f/8+bG1tee0gkog2XDc0qdUlcAUFBQDAv6aJmoGCggKYmprWaxlzc3PIZDLk5OSolefk5MDS0rLGZSwtLetVH6h6j7K+vr44/fAfD147iKT1LNeNlqjVJXBWVlbIzs6GsbExdHR0xHInJyecO3cOQNWF2sbGBtnZ2Rp9UPLRGDS1jrrUf1qd2ubXp5z7/9nrPOt+rq1ME/tfEAQUFBTAysqq3svq6enBwcEBsbGxmDhxIoCqTgyxsbGYN29ejcu4uroiNjYWCxcuFMuOHz8OV1fXOm/38WtHXY91Q49xbfOkOk8aqjHOM01v51nX1RTXg7rWa4m/qYZcN1qiVpfA6erqolu3btXKZTJZtR+siYmJRn/ENcXQ1OuoS/2n1altfn3Kuf+fvU5D93Ntyzf1/m/IX9ABAQHw8/ODo6MjnJ2dsWHDBhQVFcHf3x8A4OvrC2tra0RERAAAFixYAHd3d6xbtw5jx45FdHQ0UlJSsHXr1jpv8/FrR12PdUOP8dOW1/R50lCNcZ5pejvPuq6muB7UtV5L/U2x5e1vrS6Bq817770ndQiNEkN911GX+k+rU9v8+pRz/z97nYbu5+aw7+vLx8cHd+7cQWhoKJRKJRQKBY4ePSp2VMjKyoKu7t99tNzc3LB7924EBwdj6dKlsLOzQ0xMDAYOHPjMMdR1vzX0GGvj8XkSTX2fxtzOs66rKa4Hda3Xmn5TrVWrGweuLjjWjLS4/6XF/a8deJyosfE3pV04jEgN9PX1ERYWpvYAM2kO97+0uP+1A48TNTb+prQLW+CIiIiItAxb4IiIiIi0DBM4IiIiIi3DBI6IiIhIyzCBIyIiItIyTOCIiIiItAwTuAbKzs6Gh4cH+vfvD3t7e+zdu1fqkFqVSZMmwczMDN7e3lKH0iocOnQIffr0gZ2dHb7++mupw6EnKC4uRvfu3bFo0SKpQ6EWQC6Xw97eHgqFAiNGjJA6HAKHEWmw27dvIycnBwqFAkqlEg4ODvj999/Rvn17qUNrFeLj41FQUIAdO3Zg3759UofTolVUVKB///6Ii4uDqakpHBwckJiYiE6dOkkdGtUgKCgIV65cgY2NDdauXSt1OKTl5HI5MjIyYGRkJHUo9D9sgWugrl27QqFQAAAsLS1hbm6OvLw8aYNqRTw8PGBsbCx1GK1CcnIyBgwYAGtraxgZGWHMmDE4duyY1GFRDS5fvoxLly5hzJgxUodCRE2kxSdwJ0+exLhx42BlZQUdHR3ExMRUq7Np0ybI5XIYGBjAxcUFycnJz7St1NRUVFZWwsbGpoFRtwya3Pf0dA09Hrdu3YK1tbU4bW1tjZs3b2oi9FalMc6bRYsWISIiQkMRU3PXGL8pHR0duLu7w8nJCbt27dJQ5PQkLT6BKyoqwuDBg7Fp06Ya5+/ZswcBAQEICwtDWloaBg8eDC8vL+Tm5op1FAoFBg4cWO1z69YtsU5eXh58fX2xdevWJv9O2kJT+57qpjGOBzW9hh6nAwcOoHfv3ujdu7cmw6ZmrDHO/dOnTyM1NRUHDx7EqlWr8J///EdT4VNthFYEgLB//361MmdnZ+G9994TpysrKwUrKyshIiKizustLS0Vhg8fLnz//feNFWqL01T7XhAEIS4uTnj99dcbI8xW41mOR0JCgjBx4kRx/oIFC4Rdu3ZpJN7W6lmO05IlS4Ru3boJ3bt3Fzp16iSYmJgI4eHhmgybmrHGuBYvWrRI2L59exNGSXXR4lvgnqSsrAypqanw9PQUy3R1deHp6YmkpKQ6rUMQBMyYMQMjR47E9OnTmyrUFqcx9j01nrocD2dnZ2RkZODmzZsoLCzEkSNH4OXlJVXIrVJdjlNERASys7Nx/fp1rF27FrNnz0ZoaKhUIVMzV5ffVFFREQoKCgAAhYWF+OmnnzBgwABJ4qW/tZE6ACndvXsXlZWVsLCwUCu3sLDApUuX6rSOhIQE7NmzB/b29uJzBTt37sSgQYMaO9wWpTH2PQB4enri/PnzKCoqQrdu3bB37164uro2drgtXl2OR5s2bbBu3TqMGDECKpUKH3/8MXugalhjnTdED9XlN5WTk4NJkyYBACorKzF79mw4OTlpPFZS16oTuMbwwgsvQKVSSR1Gq3XixAmpQ2hVxo8fj/Hjx0sdBtXRjBkzpA6BWoAePXrg/PnzUodBj2nVt1DNzc0hk8mQk5OjVp6TkwNLS0uJomoduO+bFx4P7cDjRI2Nvynt1aoTOD09PTg4OCA2NlYsU6lUiI2N5W24JsZ937zweGgHHidqbPxNaa8Wfwu1sLAQV65cEaevXbuGX375BR07doStrS0CAgLg5+cHR0dHODs7Y8OGDSgqKoK/v7+EUbcM3PfNC4+HduBxosbG31QLJXU32KYWFxcnAKj28fPzE+ts3LhRsLW1FfT09ARnZ2fhzJkz0gXcgnDfNy88HtqBx4kaG39TLRPfhUpERESkZVr1M3BERERE2ogJHBEREZGWYQJHREREpGWYwBERERFpGSZwRERERFqGCRwRERGRlmECR0RERKRlmMARERERaRkmcERERERahglcKyeXy7FhwwZxWkdHBzExMZLFUx8hISF4++23pQ6jWbp79y66dOmCP/74Q+pQiIioCTCBa0ZmzJiBiRMnShrD7du3MWbMGEljqAulUonPP/8cQUFBDVpP165dERkZqVa2ZMkS6OjoID4+Xq3cw8MD06dPVyvbsWMHXnjhhQbFUF/l5eVYvHgxBg0ahPbt28PKygq+vr64deuWWMfc3By+vr4ICwvTaGxERKQZTOC0SFlZWbUyQRBQUVHRaNuwtLSEvr5+o62vqXz99ddwc3ND9+7dG7QeDw+PaolaXFwcbGxs1MpLS0tx5swZjBw5Uq3ugQMHMH78+AbFUF/FxcVIS0tDSEgI0tLS8OOPPyIzM7NaHP7+/ti1axfy8vI0Gh8RETU9JnDNmIeHB+bNm4eFCxfC3NwcXl5eiI+Ph46ODo4cOQIHBwfo6+vj9OnTuHr1KiZMmAALCwsYGRnByckJJ06cUFtfbm4uxo0bh3bt2uG5557Drl27qm3z8VuoixcvRu/evWFoaIgePXogJCQE5eXl4vxly5ZBoVBg586dkMvlMDU1xZtvvomCggKxjkqlwurVq9GrVy/o6+vD1tYWK1euFOdnZ2dj8uTJ6NChAzp27IgJEybg+vXrT9w30dHRGDduXLX9NX/+fCxcuBBmZmawsLDAtm3bUFRUBH9/fxgbG6NXr144cuSIuMyIESOQkJAgJsEFBQVIT0/H4sWL1RK4pKQkPHjwACNGjBDLSktLcezYMTFxksvl+OSTT+Dr6wsjIyN0794dBw8exJ07dzBhwgQYGRnB3t4eKSkp4jq+++47dOjQAYcOHUKfPn1gaGgIb29vFBcXY8eOHZDL5TAzM8P777+PyspKAICpqSmOHz+OyZMno0+fPhg2bBiioqKQmpqKrKwscd0DBgyAlZUV9u/f/8R9SURE2ocJXDO3Y8cO6OnpISEhAV999ZVYvmTJEkRGRuLixYuwt7dHYWEhXnnlFcTGxiI9PR2jR4/GuHHj1P5BnzFjBrKzsxEXF4d9+/bhyy+/RG5u7hO3b2xsjO+++w4XLlzA559/jm3btmH9+vVqda5evYqYmBgcOnQIhw4dws8//6x2WzIwMBCRkZEICQnBhQsXsHv3blhYWACouh3o5eUFY2NjnDp1CgkJCTAyMsLo0aNrbHEEgLy8PFy4cAGOjo417i9zc3MkJydj/vz5mDt3Lt544w24ubkhLS0No0aNwvTp01FcXAygKoErLCzEuXPnAACnTp1C79698frrr+Ps2bMoLS0FUNUqJ5fLIZfLxW3FxsbC2toaffv2FcvWr1+P559/Hunp6Rg7diymT58OX19fTJs2DWlpaejZsyd8fX0hCIK4THFxMb744gtER0fj6NGjiI+Px6RJk3D48GEcPnwYO3fuxJYtW7Bv375aj9P9+/eho6ODDh06qJU7Ozvj1KlTtS5HRERaSqBmw8/PT5gwYYI47e7uLgwZMkStTlxcnABAiImJeer6BgwYIGzcuFEQBEHIzMwUAAjJycni/IsXLwoAhPXr14tlAIT9+/fXus41a9YIDg4O4nRYWJhgaGgo5Ofni2UfffSR4OLiIgiCIOTn5wv6+vrCtm3balzfzp07hT59+ggqlUose/DggdCuXTvh3//+d43LpKenCwCErKwstXJ3d3fhhRdeEKcrKiqE9u3bC9OnTxfLbt++LQAQkpKSxDJra2th1apVYuzvvvuuIAiC0Lt3b+Gnn34SBEEQhg8fLvj7+6ttb/bs2cKiRYvE6e7duwvTpk2rtq2QkBCxLCkpSQAg3L59WxAEQdi+fbsAQLhy5YpYZ86cOYKhoaFQUFAglnl5eQlz5sypcX+UlJQIQ4cOFaZOnVpt3gcffCB4eHjUuBwREWkvtsA1cw4ODjWWP976VFhYiEWLFqFfv37o0KEDjIyMcPHiRbEF7uLFi2jTpo3a+vr27VutxeZxe/bswfPPPw9LS0sYGRkhODhYrVUPqLp1aGxsLE537dpVbNm7ePEiHjx4gJdeeqnG9Z8/fx5XrlyBsbExjIyMYGRkhI4dO6K0tBRXr16tcZmSkhIAgIGBQbV59vb24v/LZDJ06tQJgwYNEssetvw92vL46HNw8fHx8PDwAAC4u7sjPj4eJSUlOHv2rNrtU0EQ8M9//rPac2ePbv/htp62fUNDQ/Ts2VOtjlwuh5GRkVpZTa2l5eXlmDx5MgRBwObNm6vNb9eundjaSERELUcbqQOgJ2vfvn2dyhctWoTjx49j7dq16NWrF9q1awdvb+9ab0PWRVJSEt566y2Eh4fDy8sLpqamiI6Oxrp169TqtW3bVm1aR0cHKpUKQFUC8SSFhYVwcHCo8Xm8zp0717iMubk5AOCvv/6qVqemWB4t09HRAQAxPqDqNuqCBQvw559/Ij09He7u7gCqErgtW7bgxRdfRFlZmVoHhuTkZFRUVMDNza3W7T/c1tO2/7SYH5Y9ugzwd/J248YN/PTTTzAxMcHj8vLyat2PRESkvdgC10IkJCRgxowZmDRpEgYNGgRLS0u1jgB9+/ZFRUUFUlNTxbLMzEzcu3ev1nUmJiaie/fuCAoKgqOjI+zs7HDjxo16xWVnZ4d27dohNja2xvlDhw7F5cuX0aVLF/Tq1UvtY2pqWuMyPXv2hImJCS5cuFCvWGozYsQIFBUV4bPPPoOdnR26dOkCAHjxxReRnJyMI0eOwM7ODtbW1uIyBw4cwNixYyGTyRolhvp6mLxdvnwZJ06cQKdOnWqsl5GRgSFDhmg4OiIiampM4FoIOzs7/Pjjj/jll19w/vx5TJ06Va3Fpk+fPhg9ejTmzJmDs2fPIjU1FbNmzXpiC5mdnR2ysrIQHR2Nq1ev4osvvqh3j0YDAwMsXrwYH3/8Mb7//ntcvXoVZ86cwTfffAMAeOutt2Bubo4JEybg1KlTuHbtGuLj4/H+++/XOgitrq4uPD09cfr06XrFUpsePXrA1tYWGzduFFvfAMDGxgZWVlbYunWr2u1TADh48KDGhw95qLy8HN7e3khJScGuXbtQWVkJpVIJpVKp1uJaXFyM1NRUjBo1SpI4iYio6TCBayE+++wzmJmZwc3NDePGjYOXlxeGDh2qVmf79u2wsrKCu7s7XnvtNbz99ttia1NNxo8fjw8++ADz5s2DQqFAYmIiQkJC6h1bSEgIPvzwQ4SGhqJfv37w8fERn+cyNDTEyZMnYWtri9deew39+vXDzJkzUVpaWuMtwYdmzZqF6OjoarcVn9WIESNQUFAgPv/2kLu7OwoKCtQSuKtXr+LKlSvw8vJqlG3X182bN3Hw4EH88ccfUCgU6Nq1q/hJTEwU6x04cAC2trYYPny4JHESEVHT0RGER8YzINISgiDAxcUFH3zwAaZMmaLRbX/22Wc4ceIEDh8+rNHt1tewYcPw/vvvY+rUqVKHQkREjYwtcKSVdHR0sHXr1kZ9C0VddevWDYGBgRrfbn3cvXsXr732msaTWyIi0gy2wBERERFpGbbAEREREWkZJnBEREREWoYJHBEREZGWYQJHREREpGWYwBERERFpGSZwRERERFqGCRwRERGRlmECR0RERKRlmMARERERaZn/D0LLTFA4C6xCAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2)\n",
+    "axs[0].semilogx(chrome2s_irr_1p, chrome2s_I_1p, c=\"xkcd:carmine\", label=\"1P\")\n",
+    "axs[0].semilogx(chrome2s_irr_1p, m1p_chrome2s * chrome2s_irr_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, chrome2s_I_2p, c=\"k\", label=\"2P\")\n",
+    "axs[1].semilogx(chrome2s_irr_2p, m2p_chrome2s * chrome2s_irr_2p, c=\"k\", linestyle=\"--\", label=\"2P model\") \n",
+    "axs[0].set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    ")\n",
+    "fig.suptitle(\"ChroME2S power sensitivity\")\n",
+    "fig.legend()\n",
+    "\n",
+    "# 1p2p just first 2 points\n",
+    "delta_I_1p = chrome2s_I_1p[1] - chrome2s_I_1p[0]\n",
+    "delta_irr_1p = chrome2s_irr_1p[1] - chrome2s_irr_1p[0]\n",
+    "m1p_first2 = delta_I_1p / delta_irr_1p\n",
+    "\n",
+    "delta_I_2p = chrome2s_I_2p[1] - chrome2s_I_2p[0]\n",
+    "delta_irr_2p = chrome2s_irr_2p[1] - chrome2s_irr_2p[0]\n",
+    "m2p_first2 = delta_I_2p / delta_irr_2p\n",
+    "\n",
+    "ratio_first2 = m1p_first2 / m2p_first2\n",
+    "print(f\"ChroME2s {ratio_first2}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# ChRmine https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3 \n",
+    "irr_1p = np.array([0.01, 0.05, 0.22, 0.64, 1.42])  # mW/mm2\n",
+    "I_1p = np.array(\n",
+    "    [  # nA\n",
+    "        0.2886803623803128,\n",
+    "        2.4244584619798237,\n",
+    "        4.114091789682305,\n",
+    "        4.637010169751716,\n",
+    "        4.663515508375585,\n",
+    "    ]\n",
+    ")\n",
+    "power_2p = np.array(\n",
+    "    [\n",
+    "        1.758409161619387,\n",
+    "        7.759939823443684,\n",
+    "        18.27217199407987,\n",
+    "        32.8363883380391,\n",
+    "        50.840977407076835,\n",
+    "    ]\n",
+    ")\n",
+    "I_2p = np.array(\n",
+    "    [\n",
+    "        0.0677292632963725,\n",
+    "        0.43824699419092045,\n",
+    "        1.1215139595623866,\n",
+    "        1.8266932442474064,\n",
+    "        2.3784859137876424,\n",
+    "    ]\n",
+    ")\n",
+    "# divide by area of spot with 10 μm radius:\n",
+    "irr_2p = np.array(power_2p) / (np.pi * 0.01**2)\n",
+    "\n",
+    "#reachr\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from brian2 import pA, nA, cm, watt, second, metre, joule\n",
+    "nm = metre / 1e9\n",
+    "mW = watt / 1e3\n",
+    "mm = metre / 1e3\n",
+    "\n",
+    "h = 6.62607015e-34 * joule * second\n",
+    "c = 2.99792458e8 * metre / second\n",
+    "\n",
+    "    \n",
+    "def flux_to_irradiance(x_flux, wavelength_nm):\n",
+    "    I = np.asarray(x_flux, float) / (cm**2 * second) # photons / (cm^2 s)\n",
+    "    lam = wavelength_nm * nm\n",
+    "    E = I * ((h * c) / lam) # W/cm^2\n",
+    "    E_W_cm2 = (E / (watt / (cm**2))).astype(float)\n",
+    "    E_mWmm2 =  E_W_cm2 * 10.0 # mW/mm^2 \n",
+    "    return  E_mWmm2\n",
+    "\n",
+    "def get_chr2_irradiance_data():\n",
+    "\n",
+    "    #https://www.pnas.org/doi/10.1073/pnas.0907084106\n",
+    "\n",
+    "    irr_1p_flux = np.array([0.33, 0.77, 1.26, 1.72]) *1e19  # flux, need mW/mm2\n",
+    "    irr_1p = flux_to_irradiance(irr_1p_flux, 470)\n",
+    "    I_1p_og = np.array([\n",
+    "        606.9894921, \n",
+    "        705.1046238, \n",
+    "        748.4110652, \n",
+    "        771.2480195\n",
+    "    ]) * pA # pA\n",
+    "    I_1p = (I_1p_og / nA).astype(float)   # nA\n",
+    "\n",
+    "    irr_2p_og = np.array([0.37, 0.54, 1.00, 1.53]) *1e49  # flux, need mW/mm2\n",
+    "    irr_2p_flux = np.sqrt(irr_2p_og) #since its i^2\n",
+    "    irr_2p = flux_to_irradiance(irr_2p_flux, 920)\n",
+    "    I_2p_og = np.array([\n",
+    "        0.01438881888,\n",
+    "        0.04539752549,\n",
+    "        0.08182781533,\n",
+    "        0.1117224195,\n",
+    "    ])  * pA # pA\n",
+    "\n",
+    "    I_2p = (I_2p_og / nA).astype(float)  # nA\n",
+    "\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p,\n",
+    "    }\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.009524139115,\n",
+    "        0.3450867178,\n",
+    "        0.7179277543,\n",
+    "        1.055845441,\n",
+    "        1.424556973\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.1682428241,\n",
+    "        0.6738337696,\n",
+    "        1.233987502,\n",
+    "        1.610873216,\n",
+    "        1.771141945\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        1.881570223,\n",
+    "        7.899540317,\n",
+    "        17.85275251,\n",
+    "        31.84104066,\n",
+    "        49.06685143\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.06614448185,\n",
+    "        0.1085880753,\n",
+    "        0.3343108222,\n",
+    "        0.6277696856,\n",
+    "        0.9260323922\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm r \n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }\n",
+    "      "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome2f():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.007604564695,\n",
+    "        0.3442317813,\n",
+    "        0.7163953209,\n",
+    "        1.053683903,\n",
+    "        1.425710331\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.2990966727,\n",
+    "        1.139206222,\n",
+    "        2.083417815,\n",
+    "        2.625293165,\n",
+    "        2.730696485\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        2.132272412,\n",
+    "        7.947967189,\n",
+    "        17.89223904,\n",
+    "        31.72742376,\n",
+    "        49.03965788\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.06874897508,\n",
+    "        0.2226648789,\n",
+    "        0.6037697628,\n",
+    "        0.9830032701,\n",
+    "        1.413053334\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm radius spot\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_chrome2s():\n",
+    "    #https://www.cell.com/neuron/fulltext/S0896-6273(22)00008-3\n",
+    "    irr_1p = np.array([\n",
+    "        0.01033068299,\n",
+    "        0.345586775,\n",
+    "        0.7163469283,\n",
+    "        1.054329139,\n",
+    "        1.423782691\n",
+    "    ])  # mW/mm²\n",
+    "\n",
+    "    I_1p = np.array([\n",
+    "        0.5189214544,\n",
+    "        1.716216012,\n",
+    "        2.733843756,\n",
+    "        3.06809,\n",
+    "        3.035437062\n",
+    "    ])  # nA\n",
+    "\n",
+    "    power_2p = np.array([\n",
+    "        2.098001088,\n",
+    "        9.469688503,\n",
+    "        19.49889363,\n",
+    "        33.14558608,\n",
+    "        49.99403977\n",
+    "    ])  # mW\n",
+    "\n",
+    "    I_2p = np.array([\n",
+    "        0.07833736869,\n",
+    "        0.323101855,\n",
+    "        0.7228433349,\n",
+    "        1.197034736,\n",
+    "        1.612615394\n",
+    "    ])  # nA\n",
+    "\n",
+    "    irr_2p = power_2p / (np.pi * (0.01 ** 2))  # mW/mm2, assuming 10 µm r\n",
+    "\n",
+    "    return {\n",
+    "        \"irr_1p\": irr_1p,\n",
+    "        \"I_1p\": I_1p,\n",
+    "        \"irr_2p\": irr_2p,\n",
+    "        \"I_2p\": I_2p\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING    /var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_12271/3249297530.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      " [py.warnings]\n",
+      "WARNING    /var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_12271/3249297530.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      " [py.warnings]\n",
+      "WARNING    /var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_12271/3249297530.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      " [py.warnings]\n",
+      "WARNING    /var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_12271/3249297530.py:57: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      " [py.warnings]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===============\n",
+      "    RESULTS    \n",
+      "===============\n",
+      "best_f_irr: sqrt\n",
+      "best_f_I: identity\n",
+      "best mean r2: 0.7039\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#made it into a function\n",
+    "from itertools import product\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy.optimize import curve_fit\n",
+    "\n",
+    "\n",
+    "def identity(x): return x\n",
+    "def square(x): return np.power(x, 2)\n",
+    "def f_lin(x, m): return x * m\n",
+    "\n",
+    "\n",
+    "fns_and_invs = [\n",
+    "    (identity, identity),\n",
+    "    (np.log, np.exp),\n",
+    "    (np.sqrt, square),\n",
+    "    (square, np.sqrt),\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def fit_best_transform(irr_1p, I_1p, irr_2p, I_2p, verbose=True):\n",
+    "    \"\"\"\n",
+    "    Finds the best (irradiance, current) transform pair for linear fitting.\n",
+    "    Returns the best functions, fits, predictions, and R² dataframe.\n",
+    "\n",
+    "    Parameters:\n",
+    "    - irr_1p, I_1p: arrays of 1P irradiance and current\n",
+    "    - irr_2p, I_2p: arrays of 2P irradiance and current\n",
+    "    - verbose: if True, print best result info\n",
+    "\n",
+    "    Returns:\n",
+    "    - best_f_irr, best_f_irr_inv\n",
+    "    - best_f_I, best_f_I_inv\n",
+    "    - best_I_hat_1p, best_I_hat_2p\n",
+    "    - best_m1p, best_m2p\n",
+    "    - r2_results_df: DataFrame of all R² comparisons\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def opt(x, y):\n",
+    "        opt = curve_fit(f_lin, x, y, [1], full_output=True)\n",
+    "        m = opt[0][0]\n",
+    "        percent_resid2 = np.sum(opt[2][\"fvec\"] ** 2) / np.sum(y ** 2)\n",
+    "        return m, percent_resid2\n",
+    "\n",
+    "    best_r2 = -np.inf\n",
+    "    df = pd.DataFrame(columns=[\"f_irr\", \"f_I\", \"r2_1p\", \"r2_2p\", \"mean_r2\"])\n",
+    "\n",
+    "    for (f_irr, f_irr_inv), (f_I, f_I_inv) in product(fns_and_invs, fns_and_invs):\n",
+    "        irr_1p_trans = f_irr(irr_1p)\n",
+    "        irr_2p_trans = f_irr(irr_2p)\n",
+    "        I_1p_trans = f_I(I_1p)\n",
+    "        I_2p_trans = f_I(I_2p)\n",
+    "\n",
+    "        m1p, _ = opt(irr_1p_trans, I_1p_trans)\n",
+    "        m2p, _ = opt(irr_2p_trans, I_2p_trans)\n",
+    "\n",
+    "        I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+    "        I_hat_2p = f_I_inv(m2p * irr_2p_trans)\n",
+    "\n",
+    "        r2_1p = 1 - np.sum((I_hat_1p - I_1p) ** 2) / np.sum((I_1p - np.mean(I_1p)) ** 2)\n",
+    "        r2_2p = 1 - np.sum((I_hat_2p - I_2p) ** 2) / np.sum((I_2p - np.mean(I_2p)) ** 2)\n",
+    "        mean_r2 = np.mean([r2_1p, r2_2p])\n",
+    "\n",
+    "        df.loc[len(df)] = [f_irr.__name__, f_I.__name__, r2_1p, r2_2p, mean_r2]\n",
+    "\n",
+    "        if mean_r2 > best_r2:\n",
+    "            best_r2 = mean_r2\n",
+    "            best_f_irr, best_f_irr_inv = f_irr, f_irr_inv\n",
+    "            best_f_I, best_f_I_inv = f_I, f_I_inv\n",
+    "            best_I_hat_1p, best_I_hat_2p = I_hat_1p, I_hat_2p\n",
+    "            best_m1p, best_m2p = m1p, m2p\n",
+    "\n",
+    "    if verbose:\n",
+    "        print(\"\\n===============\")\n",
+    "        print(\"    RESULTS    \")\n",
+    "        print(\"===============\")\n",
+    "        print(f\"best_f_irr: {best_f_irr.__name__}\")\n",
+    "        print(f\"best_f_I: {best_f_I.__name__}\")\n",
+    "        print(f\"best mean r2: {best_r2:.4f}\")\n",
+    "\n",
+    "    return (\n",
+    "        best_f_irr, best_f_irr_inv,\n",
+    "        best_f_I, best_f_I_inv,\n",
+    "        best_I_hat_1p, best_I_hat_2p,\n",
+    "        best_m1p, best_m2p,\n",
+    "        df\n",
+    "    )\n",
+    "(\n",
+    "    best_f_irr, best_f_irr_inv,\n",
+    "    best_f_I, best_f_I_inv,\n",
+    "    best_I_hat_1p, best_I_hat_2p,\n",
+    "    best_m1p, best_m2p,\n",
+    "    r2_results_df\n",
+    ") = fit_best_transform(irr_1p, I_1p, irr_2p, I_2p)\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "# 1P data and model (original space)\n",
+    "ax.semilogx(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "ax.plot(\n",
+    "    irr_1p,\n",
+    "    best_f_I_inv(best_m1p * best_f_irr(irr_1p)),\n",
+    "    c=\"xkcd:carmine\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"1P model\",\n",
+    ")\n",
+    "\n",
+    "# 2P data and model (original space)\n",
+    "ax.plot(irr_2p, I_2p, c=\"k\", label=\"2P data\")\n",
+    "ax.plot(\n",
+    "    irr_2p,\n",
+    "    best_f_I_inv(best_m2p * best_f_irr(irr_2p)),\n",
+    "    c=\"k\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"2P model\",\n",
+    ")\n",
+    "\n",
+    "ax.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine power sensitivity\"\n",
+    ")\n",
+    "ax.legend()\n",
+    "\n",
+    "#CHR2 \n",
+    "chr2 = get_chr2_irradiance_data()\n",
+    "chr2_irr_1p = chr2[\"irr_1p\"]\n",
+    "chr2_I_1p = chr2[\"I_1p\"]\n",
+    "chr2_irr_2p = chr2[\"irr_2p\"]\n",
+    "chr2_I_2p = chr2[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chr2, best_f_irr_inv_chr2,\n",
+    " best_f_I_chr2, best_f_I_inv_chr2,\n",
+    " best_I_hat_1p_chr2, best_I_hat_2p_chr2,\n",
+    " best_m1p_chr2, best_m2p_chr2,\n",
+    " r2_results_df_chr2) = fit_best_transform(\n",
+    "    chr2_irr_1p, chr2_I_1p, chr2_irr_2p, chr2_I_2p, verbose=False\n",
+    ")\n",
+    "\n",
+    "fig2, ax2 = plt.subplots()\n",
+    "# 1P data and model (original space)\n",
+    "ax2.semilogx(chr2_irr_1p, chr2_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChR2 1P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_1p,\n",
+    "    best_f_I_inv_chr2(best_m1p_chr2 * best_f_irr_chr2(chr2_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChR2 1P model (fit using ChR2)\"\n",
+    ")\n",
+    "# 2P data and model (original space)\n",
+    "ax2.plot(chr2_irr_2p, chr2_I_2p, 'o-', c=\"k\", label=\"ChR2 2P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_2p,\n",
+    "    best_f_I_inv_chr2(best_m2p_chr2 * best_f_irr_chr2(chr2_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChR2 2P model (fit using ChR2)\"\n",
+    ")\n",
+    "ax2.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"RAW DATA ChR2-Fitted Slopes\"\n",
+    ")\n",
+    "ax2.legend()\n",
+    "\n",
+    "fig6, ax6 = plt.subplots()\n",
+    "ax6.semilogy(chr2_irr_2p, chr2_I_2p, 'o-', c=\"xkcd:black\", label=\"ChR2 2P data\")  \n",
+    "ax2.plot(chr2_irr_2p, chr2_I_2p, 'o-', c=\"k\", label=\"ChR2 2P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_2p,\n",
+    "    best_f_I_inv_chr2(best_m2p_chr2 * best_f_irr_chr2(chr2_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChR2 2P model (fit using ChR2)\"\n",
+    ")\n",
+    "ax6.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChR2 2 photon data (log scale)\"\n",
+    ")\n",
+    "ax6.legend()\n",
+    "\n",
+    "#chroME\n",
+    "chrome = get_chrome()\n",
+    "chrome_irr_1p = chrome[\"irr_1p\"]\n",
+    "chrome_I_1p = chrome[\"I_1p\"]\n",
+    "chrome_irr_2p = chrome[\"irr_2p\"]\n",
+    "chrome_I_2p = chrome[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome, best_f_irr_inv_chrome,\n",
+    " best_f_I_chrome, best_f_I_inv_chrome,\n",
+    " best_I_hat_1p_chrome, best_I_hat_2p_chrome,\n",
+    " best_m1p_chrome, best_m2p_chrome,\n",
+    " r2_results_df_chrome) = fit_best_transform(\n",
+    "    chrome_irr_1p, chrome_I_1p, chrome_irr_2p, chrome_I_2p, verbose=False\n",
+    ")\n",
+    "fig3, ax3 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax3.semilogx(chrome_irr_1p, chrome_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME 1P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_1p,\n",
+    "    best_f_I_inv_chrome(best_m1p_chrome * best_f_irr_chrome(chrome_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME 1P model (fit using ChroME)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax3.plot(chrome_irr_2p, chrome_I_2p, 'o-', c=\"k\", label=\"ChroME 2P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_2p,\n",
+    "    best_f_I_inv_chrome(best_m2p_chrome * best_f_irr_chrome(chrome_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME 2P model (fit using ChroME)\"\n",
+    ")\n",
+    "ax3.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME Transforms + ChroME-Fitted Slopes\"\n",
+    ")\n",
+    "ax3.legend()\n",
+    "\n",
+    "#chrome2f\n",
+    "chrome2f = get_chrome2f()\n",
+    "chrome2f_irr_1p = chrome2f[\"irr_1p\"]\n",
+    "chrome2f_I_1p = chrome2f[\"I_1p\"]\n",
+    "chrome2f_irr_2p = chrome2f[\"irr_2p\"]\n",
+    "chrome2f_I_2p = chrome2f[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome2f, best_f_irr_inv_chrome2f,\n",
+    " best_f_I_chrome2f, best_f_I_inv_chrome2f,\n",
+    " best_I_hat_1p_chrome2f, best_I_hat_2p_chrome2f,\n",
+    " best_m1p_chrome2f, best_m2p_chrome2f,\n",
+    " r2_results_df_chrome2f) = fit_best_transform(\n",
+    "    chrome2f_irr_1p, chrome2f_I_1p, chrome2f_irr_2p, chrome2f_I_2p, verbose=False\n",
+    ")\n",
+    "fig4, ax4 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax4.semilogx(chrome2f_irr_1p, chrome2f_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2F 1P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_1p,\n",
+    "    best_f_I_inv_chrome2f(best_m1p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2F 1P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax4.plot(chrome2f_irr_2p, chrome2f_I_2p, 'o-', c=\"k\", label=\"ChroME2F 2P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_2p,\n",
+    "    best_f_I_inv_chrome2f(best_m2p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2F 2P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "ax4.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME2F Transforms + ChroME2F-Fitted Slopes\"\n",
+    ")\n",
+    "ax4.legend()\n",
+    "\n",
+    "#chrome2s\n",
+    "chrome2s = get_chrome2s()\n",
+    "chrome2s_irr_1p = chrome2s[\"irr_1p\"]\n",
+    "chrome2s_I_1p = chrome2s[\"I_1p\"]\n",
+    "chrome2s_irr_2p = chrome2s[\"irr_2p\"]\n",
+    "chrome2s_I_2p = chrome2s[\"I_2p\"]    \n",
+    "\n",
+    "(best_f_irr_chrome2s, best_f_irr_inv_chrome2s,\n",
+    " best_f_I_chrome2s, best_f_I_inv_chrome2s,\n",
+    " best_I_hat_1p_chrome2s, best_I_hat_2p_chrome2s,\n",
+    " best_m1p_chrome2s, best_m2p_chrome2s,\n",
+    " r2_results_df_chrome2s) = fit_best_transform(\n",
+    "    chrome2s_irr_1p, chrome2s_I_1p, chrome2s_irr_2p, chrome2s_I_2p, verbose=False\n",
+    ")\n",
+    "fig5, ax5 = plt.subplots()\n",
+    "# 1P (original space)\n",
+    "ax5.semilogx(chrome2s_irr_1p, chrome2s_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2S 1P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_1p,\n",
+    "    best_f_I_inv_chrome2s(best_m1p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2S 1P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "# 2P (original space)\n",
+    "ax5.plot(chrome2s_irr_2p, chrome2s_I_2p, 'o-', c=\"k\", label=\"ChroME2S 2P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_2p,\n",
+    "    best_f_I_inv_chrome2s(best_m2p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2S 2P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "ax5.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChroME2S Transforms + ChroME2S-Fitted Slopes\"\n",
+    ")\n",
+    "ax5.legend()\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING    /var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_12271/3140863352.py:76: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+      " [py.warnings]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===============\n",
+      "    RESULTS    \n",
+      "===============\n",
+      "best_f_irr: _safe_sqrt\n",
+      "best_f_I: identity\n",
+      "best mean r2: 0.7039\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "not enough values to unpack (expected 9, got 8)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[15], line 111\u001b[0m\n\u001b[1;32m    102\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m (\n\u001b[1;32m    103\u001b[0m         best_f_irr, best_f_irr_inv,\n\u001b[1;32m    104\u001b[0m         best_f_I,   best_f_I_inv,\n\u001b[1;32m    105\u001b[0m         best_I_hat_1p, best_I_hat_2p,\n\u001b[1;32m    106\u001b[0m         best_m1p, best_m2p,\n\u001b[1;32m    107\u001b[0m     )\n\u001b[1;32m    110\u001b[0m \u001b[38;5;66;03m# === usage (unchanged downstream) ===\u001b[39;00m\n\u001b[0;32m--> 111\u001b[0m (best_f_irr, best_f_irr_inv,\n\u001b[1;32m    112\u001b[0m  best_f_I, best_f_I_inv,\n\u001b[1;32m    113\u001b[0m  best_I_hat_1p, best_I_hat_2p,\n\u001b[1;32m    114\u001b[0m  best_m1p, best_m2p,\n\u001b[1;32m    115\u001b[0m  r2_results_df) \u001b[38;5;241m=\u001b[39m fit_best_transform(irr_1p, I_1p, irr_2p, I_2p)\n\u001b[1;32m    117\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots()\n\u001b[1;32m    119\u001b[0m \u001b[38;5;66;03m# 1P data and model (original space)\u001b[39;00m\n",
+      "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 9, got 8)"
+     ]
+    }
+   ],
+   "source": [
+    "#cleaned up code\n",
+    "# made it into a function\n",
+    "from itertools import product\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# --- transforms & inverses (safe) ---\n",
+    "def identity(x): return np.asarray(x, dtype=float)\n",
+    "def square(x):   return np.power(x, 2)\n",
+    "\n",
+    "_EPS = 1e-12\n",
+    "def _safe_log(x):   return np.log(np.clip(np.asarray(x, float), _EPS, None))\n",
+    "def _safe_sqrt(x):  return np.sqrt(np.clip(np.asarray(x, float), 0.0, None))\n",
+    "\n",
+    "fns_and_invs = [\n",
+    "    (identity,  identity),\n",
+    "    (_safe_log, np.exp),\n",
+    "    (_safe_sqrt, square),\n",
+    "    (square,    np.sqrt),\n",
+    "]\n",
+    "\n",
+    "# # linear model through origin: I_hat = m * irr\n",
+    "# def f_lin(x, m): return x * m\n",
+    "\n",
+    "def fit_best_transform(irr_1p, I_1p, irr_2p, I_2p, verbose=True):\n",
+    "    \"\"\"\n",
+    "    Match the original 'expected' methodology:\n",
+    "      - try all (f_irr, f_I) pairs\n",
+    "      - fit y = m * x in TRANSFORM space via curve_fit(..., full_output=True)\n",
+    "      - compute percent_resid2 from the solver residual vector (in transform space)\n",
+    "      - inverse-map predictions back to ORIGINAL current space for R^2\n",
+    "      - select pair by highest mean R^2 (original space)\n",
+    "    Returns:\n",
+    "      best_f_irr, best_f_irr_inv,\n",
+    "      best_f_I,   best_f_I_inv,\n",
+    "      best_I_hat_1p, best_I_hat_2p,\n",
+    "      best_m1p, best_m2p,\n",
+    "      r2_results_df\n",
+    "    \"\"\"\n",
+    "    import numpy as np\n",
+    "    import pandas as pd\n",
+    "    from scipy.optimize import curve_fit\n",
+    "\n",
+    "    def f_lin(x, m):  # y = m x\n",
+    "        return x * m\n",
+    "\n",
+    "    def opt(x, y):\n",
+    "        # Fit in transform space with full_output like the original block\n",
+    "        popt, pcov, infodict, errmsg, ier = curve_fit(\n",
+    "            f_lin, np.asarray(x, float), np.asarray(y, float),\n",
+    "            p0=[1.0], full_output=True\n",
+    "        )\n",
+    "        m = popt[0]\n",
+    "        # percent residual energy in transform space (use y actually passed in)\n",
+    "        percent_resid2 = np.sum(infodict[\"fvec\"]**2) / np.sum(np.asarray(y, float)**2)\n",
+    "        return m, percent_resid2\n",
+    "\n",
+    "    best_r2 = -np.inf\n",
+    "    df = pd.DataFrame(columns=[\"f_irr\", \"f_I\", \"r2_1p\", \"r2_2p\", \"mean_r2\"])\n",
+    "\n",
+    "    # iterate over transform pairs exactly like your script\n",
+    "    for (f_irr, f_irr_inv), (f_I, f_I_inv) in product(fns_and_invs, fns_and_invs):\n",
+    "        # transform axes\n",
+    "        irr_1p_trans = f_irr(irr_1p)\n",
+    "        irr_2p_trans = f_irr(irr_2p)\n",
+    "        I_1p_trans   = f_I(I_1p)\n",
+    "        I_2p_trans   = f_I(I_2p)\n",
+    "\n",
+    "        # fit slopes in transform space\n",
+    "        m1p, res1 = opt(irr_1p_trans, I_1p_trans)\n",
+    "        m2p, res2 = opt(irr_2p_trans, I_2p_trans)\n",
+    "        _ = 0.5 * (res1 + res2)  # tot_res (not used for selection, kept for parity)\n",
+    "\n",
+    "        # predictions mapped back to ORIGINAL current space\n",
+    "        I_hat_1p = f_I_inv(m1p * irr_1p_trans)\n",
+    "        I_hat_2p = f_I_inv(m2p * irr_2p_trans)\n",
+    "\n",
+    "        I_1p = np.asarray(I_1p, float)\n",
+    "        I_2p = np.asarray(I_2p, float)\n",
+    "        r2_1p = 1.0 - np.sum((I_hat_1p - I_1p)**2) / np.sum((I_1p - I_1p.mean())**2)\n",
+    "        r2_2p = 1.0 - np.sum((I_hat_2p - I_2p)**2) / np.sum((I_2p - I_2p.mean())**2)\n",
+    "        mean_r2 = 0.5 * (r2_1p + r2_2p)\n",
+    "\n",
+    "        df.loc[len(df)] = [f_irr.__name__, f_I.__name__, r2_1p, r2_2p, mean_r2]\n",
+    "\n",
+    "        if mean_r2 > best_r2:\n",
+    "            best_r2 = mean_r2\n",
+    "            best_f_irr, best_f_irr_inv = f_irr, f_irr_inv\n",
+    "            best_f_I,   best_f_I_inv   = f_I,   f_I_inv\n",
+    "            best_I_hat_1p, best_I_hat_2p = I_hat_1p, I_hat_2p\n",
+    "            best_m1p, best_m2p = m1p, m2p\n",
+    "\n",
+    "    if verbose:\n",
+    "        print(\"\\n===============\")\n",
+    "        print(\"    RESULTS    \")\n",
+    "        print(\"===============\")\n",
+    "        print(f\"best_f_irr: {best_f_irr.__name__}\")\n",
+    "        print(f\"best_f_I: {best_f_I.__name__}\")\n",
+    "        print(f\"best mean r2: {best_r2:.4f}\")\n",
+    "\n",
+    "    return (\n",
+    "        best_f_irr, best_f_irr_inv,\n",
+    "        best_f_I,   best_f_I_inv,\n",
+    "        best_I_hat_1p, best_I_hat_2p,\n",
+    "        best_m1p, best_m2p,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# === usage (unchanged downstream) ===\n",
+    "(best_f_irr, best_f_irr_inv,\n",
+    " best_f_I, best_f_I_inv,\n",
+    " best_I_hat_1p, best_I_hat_2p,\n",
+    " best_m1p, best_m2p,\n",
+    " r2_results_df) = fit_best_transform(irr_1p, I_1p, irr_2p, I_2p)\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "# 1P data and model (original space)\n",
+    "ax.semilogx(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "ax.plot(\n",
+    "    irr_1p,\n",
+    "    best_f_I_inv(best_m1p * best_f_irr(irr_1p)),\n",
+    "    c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P model\",\n",
+    ")\n",
+    "\n",
+    "# 2P data and model (original space)\n",
+    "ax.plot(irr_2p, I_2p, c=\"k\", label=\"2P data\")\n",
+    "ax.plot(\n",
+    "    irr_2p,\n",
+    "    best_f_I_inv(best_m2p * best_f_irr(irr_2p)),\n",
+    "    c=\"k\", linestyle=\"--\", label=\"2P model\",\n",
+    ")\n",
+    "\n",
+    "ax.set(xlabel=\"Irradiance (mW/mm²)\", ylabel=\"Photocurrent (nA)\",\n",
+    "       title=\"ChRmine power sensitivity\")\n",
+    "ax.legend()\n",
+    "\n",
+    "# CHR2\n",
+    "chr2 = get_chr2_irradiance_data()\n",
+    "chr2_irr_1p = chr2[\"irr_1p\"]\n",
+    "chr2_I_1p = chr2[\"I_1p\"]\n",
+    "chr2_irr_2p = chr2[\"irr_2p\"]\n",
+    "chr2_I_2p = chr2[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chr2, best_f_irr_inv_chr2,\n",
+    " best_f_I_chr2, best_f_I_inv_chr2,\n",
+    " best_I_hat_1p_chr2, best_I_hat_2p_chr2,\n",
+    " best_m1p_chr2, best_m2p_chr2,\n",
+    " r2_results_df_chr2) = fit_best_transform(\n",
+    "    chr2_irr_1p, chr2_I_1p, chr2_irr_2p, chr2_I_2p, verbose=False\n",
+    ")\n",
+    "\n",
+    "fig2, ax2 = plt.subplots()\n",
+    "ax2.semilogx(chr2_irr_1p, chr2_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChR2 1P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_1p,\n",
+    "    best_f_I_inv_chr2(best_m1p_chr2 * best_f_irr_chr2(chr2_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChR2 1P model (fit using ChR2)\"\n",
+    ")\n",
+    "ax2.plot(chr2_irr_2p, chr2_I_2p, 'o-', c=\"k\", label=\"ChR2 2P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_2p,\n",
+    "    best_f_I_inv_chr2(best_m2p_chr2 * best_f_irr_chr2(chr2_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChR2 2P model (fit using ChR2)\"\n",
+    ")\n",
+    "ax2.set(xlabel=\"Irradiance (mW/mm²)\", ylabel=\"Photocurrent (nA)\",\n",
+    "        title=\"RAW DATA ChR2-Fitted Slopes\")\n",
+    "ax2.legend()\n",
+    "\n",
+    "# chroME\n",
+    "chrome = get_chrome()\n",
+    "chrome_irr_1p = chrome[\"irr_1p\"]; chrome_I_1p = chrome[\"I_1p\"]\n",
+    "chrome_irr_2p = chrome[\"irr_2p\"]; chrome_I_2p = chrome[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome, best_f_irr_inv_chrome,\n",
+    " best_f_I_chrome, best_f_I_inv_chrome,\n",
+    " best_I_hat_1p_chrome, best_I_hat_2p_chrome,\n",
+    " best_m1p_chrome, best_m2p_chrome,\n",
+    " r2_results_df_chrome) = fit_best_transform(\n",
+    "    chrome_irr_1p, chrome_I_1p, chrome_irr_2p, chrome_I_2p, verbose=False\n",
+    ")\n",
+    "\n",
+    "fig3, ax3 = plt.subplots()\n",
+    "ax3.semilogx(chrome_irr_1p, chrome_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME 1P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_1p,\n",
+    "    best_f_I_inv_chrome(best_m1p_chrome * best_f_irr_chrome(chrome_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME 1P model (fit using ChroME)\"\n",
+    ")\n",
+    "ax3.plot(chrome_irr_2p, chrome_I_2p, 'o-', c=\"k\", label=\"ChroME 2P data\")\n",
+    "ax3.plot(\n",
+    "    chrome_irr_2p,\n",
+    "    best_f_I_inv_chrome(best_m2p_chrome * best_f_irr_chrome(chrome_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME 2P model (fit using ChroME)\"\n",
+    ")\n",
+    "ax3.set(xlabel=\"Irradiance (mW/mm²)\", ylabel=\"Photocurrent (nA)\",\n",
+    "        title=\"ChroME Transforms + ChroME-Fitted Slopes\")\n",
+    "ax3.legend()\n",
+    "\n",
+    "# chroME2f\n",
+    "chrome2f = get_chrome2f()\n",
+    "chrome2f_irr_1p = chrome2f[\"irr_1p\"]; chrome2f_I_1p = chrome2f[\"I_1p\"]\n",
+    "chrome2f_irr_2p = chrome2f[\"irr_2p\"]; chrome2f_I_2p = chrome2f[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome2f, best_f_irr_inv_chrome2f,\n",
+    " best_f_I_chrome2f, best_f_I_inv_chrome2f,\n",
+    " best_I_hat_1p_chrome2f, best_I_hat_2p_chrome2f,\n",
+    " best_m1p_chrome2f, best_m2p_chrome2f,\n",
+    " r2_results_df_chrome2f) = fit_best_transform(\n",
+    "    chrome2f_irr_1p, chrome2f_I_1p, chrome2f_irr_2p, chrome2f_I_2p, verbose=False\n",
+    ")\n",
+    "\n",
+    "fig4, ax4 = plt.subplots()\n",
+    "ax4.semilogx(chrome2f_irr_1p, chrome2f_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2F 1P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_1p,\n",
+    "    best_f_I_inv_chrome2f(best_m1p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2F 1P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "ax4.plot(chrome2f_irr_2p, chrome2f_I_2p, 'o-', c=\"k\", label=\"ChroME2F 2P data\")\n",
+    "ax4.plot(\n",
+    "    chrome2f_irr_2p,\n",
+    "    best_f_I_inv_chrome2f(best_m2p_chrome2f * best_f_irr_chrome2f(chrome2f_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2F 2P model (fit using ChroME2F)\"\n",
+    ")\n",
+    "ax4.set(xlabel=\"Irradiance (mW/mm²)\", ylabel=\"Photocurrent (nA)\",\n",
+    "        title=\"ChroME2F Transforms + ChroME2F-Fitted Slopes\")\n",
+    "ax4.legend()\n",
+    "\n",
+    "# chroME2s\n",
+    "chrome2s = get_chrome2s()\n",
+    "chrome2s_irr_1p = chrome2s[\"irr_1p\"]; chrome2s_I_1p = chrome2s[\"I_1p\"]\n",
+    "chrome2s_irr_2p = chrome2s[\"irr_2p\"]; chrome2s_I_2p = chrome2s[\"I_2p\"]\n",
+    "\n",
+    "(best_f_irr_chrome2s, best_f_irr_inv_chrome2s,\n",
+    " best_f_I_chrome2s, best_f_I_inv_chrome2s,\n",
+    " best_I_hat_1p_chrome2s, best_I_hat_2p_chrome2s,\n",
+    " best_m1p_chrome2s, best_m2p_chrome2s,\n",
+    " r2_results_df_chrome2s) = fit_best_transform(\n",
+    "    chrome2s_irr_1p, chrome2s_I_1p, chrome2s_irr_2p, chrome2s_I_2p, verbose=False\n",
+    ")\n",
+    "\n",
+    "fig5, ax5 = plt.subplots()\n",
+    "ax5.semilogx(chrome2s_irr_1p, chrome2s_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChroME2S 1P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_1p,\n",
+    "    best_f_I_inv_chrome2s(best_m1p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_1p)),\n",
+    "    '--', c=\"xkcd:carmine\", label=\"ChroME2S 1P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "ax5.plot(chrome2s_irr_2p, chrome2s_I_2p, 'o-', c=\"k\", label=\"ChroME2S 2P data\")\n",
+    "ax5.plot(\n",
+    "    chrome2s_irr_2p,\n",
+    "    best_f_I_inv_chrome2s(best_m2p_chrome2s * best_f_irr_chrome2s(chrome2s_irr_2p)),\n",
+    "    '--', c=\"k\", label=\"ChroME2S 2P model (fit using ChroME2S)\"\n",
+    ")\n",
+    "ax5.set(xlabel=\"Irradiance (mW/mm²)\", ylabel=\"Photocurrent (nA)\",\n",
+    "        title=\"ChroME2S Transforms + ChroME2S-Fitted Slopes\")\n",
+    "ax5.legend()\n",
+    "\n",
+    "plt.show()\n",
+    "\n",
+    "# expose the results table\n",
+    "r2_results_df\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===============\n",
+      "    RESULTS    \n",
+      "===============\n",
+      "best_f_irr: sqrt\n",
+      "best_f_I: identity\n",
+      "best mean r2 0.703853307246795\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_87002/3985390862.py:48: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_transformed)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>f_irr</th>\n",
+       "      <th>f_I</th>\n",
+       "      <th>r2_1p</th>\n",
+       "      <th>r2_2p</th>\n",
+       "      <th>mean_r2</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-0.460178</td>\n",
+       "      <td>0.970862</td>\n",
+       "      <td>0.255342</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.596008</td>\n",
+       "      <td>0.556113</td>\n",
+       "      <td>-0.019947</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-1.989953</td>\n",
+       "      <td>0.494364</td>\n",
+       "      <td>-0.747795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.447950</td>\n",
+       "      <td>0.886708</td>\n",
+       "      <td>0.667329</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>log</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-3.182423</td>\n",
+       "      <td>0.274285</td>\n",
+       "      <td>-1.454069</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>log</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-1.775753</td>\n",
+       "      <td>-0.245836</td>\n",
+       "      <td>-1.010795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>log</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-3.516459</td>\n",
+       "      <td>0.411338</td>\n",
+       "      <td>-1.552560</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>log</td>\n",
+       "      <td>square</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.024131</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>0.506932</td>\n",
+       "      <td>0.900775</td>\n",
+       "      <td>0.703853</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>log</td>\n",
+       "      <td>0.171196</td>\n",
+       "      <td>0.204009</td>\n",
+       "      <td>0.187602</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-0.877126</td>\n",
+       "      <td>0.967683</td>\n",
+       "      <td>0.045279</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.810713</td>\n",
+       "      <td>0.535467</td>\n",
+       "      <td>0.673090</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>square</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-1.470390</td>\n",
+       "      <td>0.634820</td>\n",
+       "      <td>-0.417785</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>square</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.717720</td>\n",
+       "      <td>0.626429</td>\n",
+       "      <td>-0.045646</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>square</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-2.200391</td>\n",
+       "      <td>-0.164472</td>\n",
+       "      <td>-1.182432</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>square</td>\n",
+       "      <td>square</td>\n",
+       "      <td>-0.554560</td>\n",
+       "      <td>0.966136</td>\n",
+       "      <td>0.205788</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       f_irr       f_I     r2_1p     r2_2p   mean_r2\n",
+       "0   identity  identity -0.460178  0.970862  0.255342\n",
+       "1   identity       log -0.596008  0.556113 -0.019947\n",
+       "2   identity      sqrt -1.989953  0.494364 -0.747795\n",
+       "3   identity    square  0.447950  0.886708  0.667329\n",
+       "4        log  identity -3.182423  0.274285 -1.454069\n",
+       "5        log       log -1.775753 -0.245836 -1.010795\n",
+       "6        log      sqrt -3.516459  0.411338 -1.552560\n",
+       "7        log    square       NaN  0.024131       NaN\n",
+       "8       sqrt  identity  0.506932  0.900775  0.703853\n",
+       "9       sqrt       log  0.171196  0.204009  0.187602\n",
+       "10      sqrt      sqrt -0.877126  0.967683  0.045279\n",
+       "11      sqrt    square  0.810713  0.535467  0.673090\n",
+       "12    square  identity -1.470390  0.634820 -0.417785\n",
+       "13    square       log -0.717720  0.626429 -0.045646\n",
+       "14    square      sqrt -2.200391 -0.164472 -1.182432\n",
+       "15    square    square -0.554560  0.966136  0.205788"
+      ]
+     },
+     "execution_count": 145,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from itertools import product\n",
+    "import pandas as pd\n",
+    "from scipy.optimize import curve_fit\n",
+    "\n",
+    "\n",
+    "# can we get a good linear fit\n",
+    "def identity(x):\n",
+    "    return np.multiply(x, 1)\n",
+    "\n",
+    "\n",
+    "def square(x):\n",
+    "    return np.power(x, 2)\n",
+    "\n",
+    "\n",
+    "fns_and_invs = [\n",
+    "    (identity, identity),\n",
+    "    (np.log, np.exp),\n",
+    "    (np.sqrt, square),\n",
+    "    (square, np.sqrt),\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def f_lin(x, m):\n",
+    "    return x * m\n",
+    "\n",
+    "\n",
+    "def opt(irr, I):\n",
+    "    opt = curve_fit(f_lin, irr, I, [1], full_output=True)\n",
+    "    m = opt[0][0]\n",
+    "    percent_resid2 = np.sum(opt[2][\"fvec\"] ** 2) / np.sum(I_1p_transformed**2)\n",
+    "    return m, percent_resid2\n",
+    "\n",
+    "\n",
+    "best_res = np.inf\n",
+    "best_r2 = -np.inf\n",
+    "df = pd.DataFrame(columns=[\"f_irr\", \"f_I\", \"r2_1p\", \"r2_2p\", \"mean_r2\"])\n",
+    "for (f_irr, f_irr_inv), (f_I, f_I_inv) in product(fns_and_invs, fns_and_invs):\n",
+    "    irr_1p_transformed = f_irr(irr_1p)\n",
+    "    irr_2p_transformed = f_irr(irr_2p)\n",
+    "    I_1p_transformed = f_I(I_1p)\n",
+    "    I_2p_transformed = f_I(I_2p)\n",
+    "\n",
+    "    m1p, percent_resid2_1p = opt(irr_1p_transformed, I_1p_transformed)\n",
+    "    m2p, percent_resid2_2p = opt(irr_2p_transformed, I_2p_transformed)\n",
+    "    # print(percent_resid2_1p, percent_resid2_2p)\n",
+    "    tot_res = np.mean([percent_resid2_1p, percent_resid2_2p])\n",
+    "\n",
+    "    I_hat_1p = f_I_inv(m1p * irr_1p_transformed)\n",
+    "    r2_1p = 1 - np.sum((I_hat_1p - I_1p) ** 2) / np.sum((I_1p - np.mean(I_1p)) ** 2)\n",
+    "    # r2_1p = np.corrcoef(I_1p, I_hat_1p)[0, 1] ** 2\n",
+    "\n",
+    "    I_hat_2p = f_I_inv(m2p * irr_2p_transformed)\n",
+    "    r2_2p = 1 - np.sum((I_hat_2p - I_2p) ** 2) / np.sum((I_2p - np.mean(I_2p)) ** 2)\n",
+    "    # r2_2p = np.corrcoef(I_2p, I_hat_2p)[0, 1] ** 2\n",
+    "\n",
+    "    mean_r2 = np.mean([r2_1p, r2_2p])\n",
+    "\n",
+    "    df.loc[len(df)] = [f_irr.__name__, f_I.__name__, r2_1p, r2_2p, mean_r2]\n",
+    "    # print(\n",
+    "    #     f\"f_irr={f_irr.__name__}, f_I={f_I.__name__}, r2_1p={r2_1p:.3f}, r2_2p={r2_2p:.3f}\"\n",
+    "    # )\n",
+    "\n",
+    "    # if tot_res < best_res:\n",
+    "    if mean_r2 > best_r2:\n",
+    "        # best_res = tot_res\n",
+    "        best_r2 = mean_r2\n",
+    "        best_f_irr = f_irr\n",
+    "        best_f_I = f_I\n",
+    "        best_I_hat_1p = I_hat_1p\n",
+    "        best_I_hat_2p = I_hat_2p\n",
+    "print(\"\\n===============\")\n",
+    "print(\"    RESULTS    \")\n",
+    "print(\"===============\")\n",
+    "print(f\"best_f_irr: {best_f_irr.__name__}\")\n",
+    "print(f\"best_f_I: {best_f_I.__name__}\")\n",
+    "# print(f\"best mean resid: {best_res}\")\n",
+    "print(\"best mean r2\", best_r2)\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.semilogx(best_f_irr(irr_1p), best_f_I(I_1p), c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "ax.plot(\n",
+    "    best_f_irr(irr_1p),\n",
+    "    best_I_hat_1p,\n",
+    "    c=\"xkcd:carmine\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"1P model\",\n",
+    ")\n",
+    "ax.plot(best_f_irr(irr_2p), best_f_I(I_2p), c=\"k\", label=\"2P data\")\n",
+    "ax.plot(best_f_irr(irr_2p), best_I_hat_2p, c=\"k\", linestyle=\"--\", label=\"2P model\")\n",
+    "ax.set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine power sensitivity\",\n",
+    ")\n",
+    "ax.legend()\n",
+    "\n",
+    "\n",
+    "# CHR2\n",
+    "chr2 = get_chr2_irradiance_data()\n",
+    "chr2_irr_1p = chr2[\"irr_1p\"]\n",
+    "chr2_I_1p   = chr2[\"I_1p\"]\n",
+    "chr2_irr_2p = chr2[\"irr_2p\"]\n",
+    "chr2_I_2p   = chr2[\"I_2p\"]\n",
+    "\n",
+    "# --- CHR2 (same style as first block) ---\n",
+    "\n",
+    "# fetch data\n",
+    "chr2 = get_chr2_irradiance_data()\n",
+    "chr2_irr_1p = chr2[\"irr_1p\"]\n",
+    "chr2_I_1p   = chr2[\"I_1p\"]\n",
+    "chr2_irr_2p = chr2[\"irr_2p\"]\n",
+    "chr2_I_2p   = chr2[\"I_2p\"]\n",
+    "\n",
+    "# transform using the already-selected best transforms\n",
+    "chr2_irr_1p_trans = best_f_irr(chr2_irr_1p)\n",
+    "chr2_I_1p_trans   = best_f_I(chr2_I_1p)\n",
+    "chr2_irr_2p_trans = best_f_irr(chr2_irr_2p)\n",
+    "chr2_I_2p_trans   = best_f_I(chr2_I_2p)\n",
+    "\n",
+    "# slope through origin in transform space (same math as inside fit_best_transform)\n",
+    "def _fit_slope_through_origin(x, y):\n",
+    "    x = np.asarray(x, float); y = np.asarray(y, float)\n",
+    "    return np.dot(x, y) / np.dot(x, x)\n",
+    "\n",
+    "best_m1p_chr2 = _fit_slope_through_origin(chr2_irr_1p_trans, chr2_I_1p_trans)\n",
+    "best_m2p_chr2 = _fit_slope_through_origin(chr2_irr_2p_trans, chr2_I_2p_trans)\n",
+    "\n",
+    "# predictions back in ORIGINAL current space (nA)\n",
+    "best_I_hat_1p_chr2 = best_f_I_inv(best_m1p_chr2 * chr2_irr_1p_trans)\n",
+    "best_I_hat_2p_chr2 = best_f_I_inv(best_m2p_chr2 * chr2_irr_2p_trans)\n",
+    "\n",
+    "# plot in ORIGINAL space (same style)\n",
+    "fig2, ax2 = plt.subplots()\n",
+    "ax2.semilogx(chr2_irr_1p, chr2_I_1p, 'o-', c=\"xkcd:carmine\", label=\"ChR2 1P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_1p,\n",
+    "    best_I_hat_1p_chr2,\n",
+    "    '--', c=\"xkcd:carmine\",\n",
+    "    label=\"ChR2 1P model (same transforms, refit slope)\"\n",
+    ")\n",
+    "ax2.plot(chr2_irr_2p, chr2_I_2p, 'o-', c=\"k\", label=\"ChR2 2P data\")\n",
+    "ax2.plot(\n",
+    "    chr2_irr_2p,\n",
+    "    best_I_hat_2p_chr2,\n",
+    "    '--', c=\"k\",\n",
+    "    label=\"ChR2 2P model (same transforms, refit slope)\"\n",
+    ")\n",
+    "ax2.set(\n",
+    "    xlabel=\"Irradiance (mW/mm²)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChR2 power sensitivity\"\n",
+    ")\n",
+    "ax2.legend()\n",
+    "\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x310857490>"
+      ]
+     },
+     "execution_count": 146,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.loglog((irr_1p), (I_1p), c=\"xkcd:carmine\", label=\"1P\")\n",
+    "ax.plot((irr_2p), (I_2p), c=\"k\", label=\"2P\")\n",
+    "ax.set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine power sensitivity\",\n",
+    ")\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===============\n",
+      "    RESULTS    \n",
+      "===============\n",
+      "best_f_irr: sqrt\n",
+      "best_f_I: identity\n",
+      "best mean r2 0.703853307246795\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/k8/vkc87z_97_9d7gp2l0pm5khr0000gn/T/ipykernel_87002/3855453677.py:48: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  I_hat_1p = f_I_inv(m1p * irr_1p_transformed)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>f_irr</th>\n",
+       "      <th>f_I</th>\n",
+       "      <th>r2_1p</th>\n",
+       "      <th>r2_2p</th>\n",
+       "      <th>mean_r2</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-0.460178</td>\n",
+       "      <td>0.970862</td>\n",
+       "      <td>0.255342</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.596008</td>\n",
+       "      <td>0.556113</td>\n",
+       "      <td>-0.019947</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-1.989953</td>\n",
+       "      <td>0.494364</td>\n",
+       "      <td>-0.747795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>identity</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.447950</td>\n",
+       "      <td>0.886708</td>\n",
+       "      <td>0.667329</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>log</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-3.182423</td>\n",
+       "      <td>0.274285</td>\n",
+       "      <td>-1.454069</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>log</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-1.775753</td>\n",
+       "      <td>-0.245836</td>\n",
+       "      <td>-1.010795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>log</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-3.516459</td>\n",
+       "      <td>0.411338</td>\n",
+       "      <td>-1.552560</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>log</td>\n",
+       "      <td>square</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.024131</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>0.506932</td>\n",
+       "      <td>0.900775</td>\n",
+       "      <td>0.703853</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>log</td>\n",
+       "      <td>0.171196</td>\n",
+       "      <td>0.204009</td>\n",
+       "      <td>0.187602</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-0.877126</td>\n",
+       "      <td>0.967683</td>\n",
+       "      <td>0.045279</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>square</td>\n",
+       "      <td>0.810713</td>\n",
+       "      <td>0.535467</td>\n",
+       "      <td>0.673090</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>square</td>\n",
+       "      <td>identity</td>\n",
+       "      <td>-1.470390</td>\n",
+       "      <td>0.634820</td>\n",
+       "      <td>-0.417785</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>square</td>\n",
+       "      <td>log</td>\n",
+       "      <td>-0.717720</td>\n",
+       "      <td>0.626429</td>\n",
+       "      <td>-0.045646</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>square</td>\n",
+       "      <td>sqrt</td>\n",
+       "      <td>-2.200391</td>\n",
+       "      <td>-0.164472</td>\n",
+       "      <td>-1.182432</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>square</td>\n",
+       "      <td>square</td>\n",
+       "      <td>-0.554560</td>\n",
+       "      <td>0.966136</td>\n",
+       "      <td>0.205788</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       f_irr       f_I     r2_1p     r2_2p   mean_r2\n",
+       "0   identity  identity -0.460178  0.970862  0.255342\n",
+       "1   identity       log -0.596008  0.556113 -0.019947\n",
+       "2   identity      sqrt -1.989953  0.494364 -0.747795\n",
+       "3   identity    square  0.447950  0.886708  0.667329\n",
+       "4        log  identity -3.182423  0.274285 -1.454069\n",
+       "5        log       log -1.775753 -0.245836 -1.010795\n",
+       "6        log      sqrt -3.516459  0.411338 -1.552560\n",
+       "7        log    square       NaN  0.024131       NaN\n",
+       "8       sqrt  identity  0.506932  0.900775  0.703853\n",
+       "9       sqrt       log  0.171196  0.204009  0.187602\n",
+       "10      sqrt      sqrt -0.877126  0.967683  0.045279\n",
+       "11      sqrt    square  0.810713  0.535467  0.673090\n",
+       "12    square  identity -1.470390  0.634820 -0.417785\n",
+       "13    square       log -0.717720  0.626429 -0.045646\n",
+       "14    square      sqrt -2.200391 -0.164472 -1.182432\n",
+       "15    square    square -0.554560  0.966136  0.205788"
+      ]
+     },
+     "execution_count": 147,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from itertools import product\n",
+    "import pandas as pd\n",
+    "from scipy.optimize import curve_fit\n",
+    "\n",
+    "\n",
+    "# can we get a good linear fit\n",
+    "def identity(x):\n",
+    "    return np.multiply(x, 1)\n",
+    "\n",
+    "\n",
+    "def square(x):\n",
+    "    return np.power(x, 2)\n",
+    "\n",
+    "\n",
+    "fns_and_invs = [\n",
+    "    (identity, identity),\n",
+    "    (np.log, np.exp),\n",
+    "    (np.sqrt, square),\n",
+    "    (square, np.sqrt),\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def f_lin(x, m):\n",
+    "    return x * m\n",
+    "\n",
+    "\n",
+    "def opt(irr, I):\n",
+    "    opt = curve_fit(f_lin, irr, I, [1], full_output=True)\n",
+    "    m = opt[0][0]\n",
+    "    percent_resid2 = np.sum(opt[2][\"fvec\"] ** 2) / np.sum(I_1p_transformed**2)\n",
+    "    return m, percent_resid2\n",
+    "\n",
+    "\n",
+    "best_res = np.inf\n",
+    "best_r2 = -np.inf\n",
+    "df = pd.DataFrame(columns=[\"f_irr\", \"f_I\", \"r2_1p\", \"r2_2p\", \"mean_r2\"])\n",
+    "for (f_irr, f_irr_inv), (f_I, f_I_inv) in product(fns_and_invs, fns_and_invs):\n",
+    "    irr_1p_transformed = f_irr(irr_1p)\n",
+    "    irr_2p_transformed = f_irr(irr_2p)\n",
+    "    I_1p_transformed = f_I(I_1p)\n",
+    "    I_2p_transformed = f_I(I_2p)\n",
+    "\n",
+    "    m1p, percent_resid2_1p = opt(irr_1p_transformed, I_1p_transformed)\n",
+    "    m2p, percent_resid2_2p = opt(irr_2p_transformed, I_2p_transformed)\n",
+    "    # print(percent_resid2_1p, percent_resid2_2p)\n",
+    "    tot_res = np.mean([percent_resid2_1p, percent_resid2_2p])\n",
+    "\n",
+    "    I_hat_1p = f_I_inv(m1p * irr_1p_transformed)\n",
+    "    r2_1p = 1 - np.sum((I_hat_1p - I_1p) ** 2) / np.sum((I_1p - np.mean(I_1p)) ** 2)\n",
+    "    # r2_1p = np.corrcoef(I_1p, I_hat_1p)[0, 1] ** 2\n",
+    "\n",
+    "    I_hat_2p = f_I_inv(m2p * irr_2p_transformed)\n",
+    "    r2_2p = 1 - np.sum((I_hat_2p - I_2p) ** 2) / np.sum((I_2p - np.mean(I_2p)) ** 2)\n",
+    "    # r2_2p = np.corrcoef(I_2p, I_hat_2p)[0, 1] ** 2\n",
+    "\n",
+    "    mean_r2 = np.mean([r2_1p, r2_2p])\n",
+    "\n",
+    "    df.loc[len(df)] = [f_irr.__name__, f_I.__name__, r2_1p, r2_2p, mean_r2]\n",
+    "    # print(\n",
+    "    #     f\"f_irr={f_irr.__name__}, f_I={f_I.__name__}, r2_1p={r2_1p:.3f}, r2_2p={r2_2p:.3f}\"\n",
+    "    # )\n",
+    "\n",
+    "    # if tot_res < best_res:\n",
+    "    if mean_r2 > best_r2:\n",
+    "        # best_res = tot_res\n",
+    "        best_r2 = mean_r2\n",
+    "        best_f_irr = f_irr\n",
+    "        best_f_I = f_I\n",
+    "        best_f_I_inv = f_I_inv #inverse of f_I\n",
+    "        best_I_hat_1p = I_hat_1p\n",
+    "        best_I_hat_2p = I_hat_2p\n",
+    "print(\"\\n===============\")\n",
+    "print(\"    RESULTS    \")\n",
+    "print(\"===============\")\n",
+    "print(f\"best_f_irr: {best_f_irr.__name__}\")\n",
+    "print(f\"best_f_I: {best_f_I.__name__}\")\n",
+    "# print(f\"best mean resid: {best_res}\")\n",
+    "print(\"best mean r2\", best_r2)\n",
+    "\n",
+    "# fig, ax = plt.subplots()\n",
+    "fig1, ax1 = plt.subplots()\n",
+    "ax1.semilogx(best_f_irr(irr_1p), best_f_I(I_1p), c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "ax1.plot(\n",
+    "    best_f_irr(irr_1p),\n",
+    "    best_I_hat_1p,\n",
+    "    c=\"xkcd:carmine\",\n",
+    "    linestyle=\"--\",\n",
+    "    label=\"1P model\",\n",
+    ")\n",
+    "ax1.plot(best_f_irr(irr_2p), best_f_I(I_2p), c=\"k\", label=\"2P data\")\n",
+    "ax1.plot(best_f_irr(irr_2p), best_I_hat_2p, c=\"k\", linestyle=\"--\", label=\"2P model\")\n",
+    "ax1.set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine power sensitivity\",\n",
+    ")\n",
+    "ax1.legend()\n",
+    "\n",
+    "#linear data\n",
+    "fig2, ax2 = plt.subplots()\n",
+    "ax2.set_ylim(0, 6) #to match the original plot\n",
+    "ax2.semilogx(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P data\") #original data\n",
+    "ax2.plot(\n",
+    "    irr_2p, I_2p, c=\"k\", label=\"2P data\"\n",
+    ")\n",
+    "\n",
+    "\n",
+    "#m1p and m2p eqs from lower block\n",
+    "irr_1p_linear = irr_1p[:3]\n",
+    "I_1p_linear = I_1p[:3]\n",
+    "m1p, _ = opt(irr_1p_linear, I_1p_linear)#only using the LINEAR part of the curves\n",
+    "# m2p, _ = opt(irr_2p, I_2p)\n",
+    "irr_2p_linear = irr_2p[:3]\n",
+    "I_2p_linear = I_2p[:3]\n",
+    "m2p, _ = opt(irr_2p_linear, I_2p_linear)\n",
+    "sensitivity_ratio = m1p / m2p\n",
+    "\n",
+    "ax2.plot(irr_1p_linear, m1p * irr_1p_linear, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P linear fit\") #1P linear model \n",
+    "ax2.plot(irr_2p_linear, m2p * irr_2p_linear, c=\"k\", linestyle=\"--\", label=\"2P linear fit\") #2p linear model\n",
+    "\n",
+    "ax2.set(\n",
+    "    xlabel=\"Irradiance (mW/mm2)\",\n",
+    "    ylabel=\"Photocurrent (nA)\",\n",
+    "    title=\"ChRmine linear model\",\n",
+    ")\n",
+    "ax2.legend()\n",
+    "\n",
+    "\n",
+    "#linear part of the data\n",
+    "# irr_1p_linear = irr_1p[:3]\n",
+    "# I_1p_linear = I_1p[:3]\n",
+    "# irr_2p_linear = irr_2p[:3]\n",
+    "# I_2p_linear = I_2p[:3]\n",
+    "\n",
+    "# # Transform the linear part of the data\n",
+    "# irr_1p_trans = best_f_irr(irr_1p_linear)\n",
+    "# I_1p_trans = best_f_I(I_1p_linear)\n",
+    "# irr_2p_trans = best_f_irr(irr_2p_linear)\n",
+    "# I_2p_trans = best_f_I(I_2p_linear)\n",
+    "\n",
+    "\n",
+    "# m1p, _ = opt(irr_1p_trans, I_1p_trans)\n",
+    "# m2p, _ = opt(irr_2p_trans, I_2p_trans)\n",
+    "# sensitivity_ratio = m1p / m2p\n",
+    "\n",
+    "# #rescale to original units\n",
+    "# I_hat_1p = best_f_I_inv(m1p * irr_1p_trans)\n",
+    "# I_hat_2p = best_f_I_inv(m2p * irr_2p_trans)\n",
+    "\n",
+    "# ax2.plot(irr_1p, I_1p, c=\"xkcd:carmine\", label=\"1P data\")\n",
+    "# ax2.plot(irr_2p, I_2p, c=\"k\", label=\"2P data\")\n",
+    "# ax2.plot(irr_1p_linear, I_hat_1p, c=\"xkcd:carmine\", linestyle=\"--\", label=\"1P linear fit (transformed)\")\n",
+    "# ax2.plot(irr_2p_linear, I_hat_2p, c=\"k\", linestyle=\"--\", label=\"2P linear fit (transformed)\")\n",
+    "\n",
+    "# ax2.set(\n",
+    "#     xlabel=\"Irradiance (mW/mm2)\",\n",
+    "#     ylabel=\"Photocurrent (nA)\",\n",
+    "#     title=\"ChRmine linear fit using transformed early region\",\n",
+    "# )\n",
+    "# ax2.legend()\n",
+    "\n",
+    "\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, but we do actually need a pure linear function if we want just a constant.\n",
+    "Let's compute that ratio to use as a placeholder for now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1P/2P sensitivity ratio: 270382.300\n"
+     ]
+    }
+   ],
+   "source": [
+    "m1p, _ = opt(irr_1p, I_1p)\n",
+    "m2p, _ = opt(irr_2p, I_2p)\n",
+    "sensitivity_ratio = m1p / m2p\n",
+    "\n",
+    "print(f\"1P/2P sensitivity ratio: {sensitivity_ratio:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChR2 1P/2P sensitivity ratio: 1217128552.608\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_m1p_chr2, _ = opt(chr2_irr_1p, chr2_I_1p)\n",
+    "best_m2p_chr2, _ = opt(chr2_irr_2p, chr2_I_2p)\n",
+    "sensitivity_ratio_chr2 = best_m1p_chr2 / best_m2p_chr2\n",
+    "print(f\"ChR2 1P/2P sensitivity ratio: {sensitivity_ratio_chr2:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2F 1P/2P sensitivity ratio: 241883.711\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_m1p_chrome2f, _ = opt(chrome2f_irr_1p, chrome2f_I_1p)\n",
+    "best_m2p_chrome2f, _ = opt(chrome2f_irr_2p, chrome2f_I_2p)\n",
+    "sensitivity_ratio_chrome2f = best_m1p_chrome2f / best_m2p_chrome2f\n",
+    "print(f\"ChroME2F 1P/2P sensitivity ratio: {sensitivity_ratio_chrome2f:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME 1P/2P sensitivity ratio: 236723.197\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_m1p_chrome, _ = opt(chrome_irr_1p, chrome_I_1p)\n",
+    "best_m2p_chrome, _ = opt(chrome_irr_2p, chrome_I_2p)\n",
+    "sensitivity_ratio_chrome = best_m1p_chrome / best_m2p_chrome\n",
+    "print(f\"ChroME 1P/2P sensitivity ratio: {sensitivity_ratio_chrome:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ChroME2S 1P/2P sensitivity ratio: 252587.017\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_m1p_chrome2s, _ = opt(chrome2s_irr_1p, chrome2s_I_1p)\n",
+    "best_m2p_chrome2s, _ = opt(chrome2s_irr_2p, chrome2s_I_2p)\n",
+    "sensitivity_ratio_chrome2s = best_m1p_chrome2s / best_m2p_chrome2s\n",
+    "print(f\"ChroME2S 1P/2P sensitivity ratio: {sensitivity_ratio_chrome2s:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(np.mean([sensitivity_ratio_chrome2s, sensitivity_ratio_chrome , sensitivity_ratio_chrome2f , sensitivity_ratio]))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cleosim-py3.11 (3.11.7)",
+   "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.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pyproject.toml b/pyproject.toml
index 0bfb5efc..b46b5f0b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,6 +49,7 @@ classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
 ]
+
 requires-poetry = ">=2.0"
 
 [build-system]
diff --git a/tests/imaging/test_scope.py b/tests/imaging/test_scope.py
index 1afde9fd..4e8d1497 100644
--- a/tests/imaging/test_scope.py
+++ b/tests/imaging/test_scope.py
@@ -1,6 +1,6 @@
 import pytest
 import quantities as pq
-from brian2 import Network, NeuronGroup, meter, ms, np, um
+from brian2 import Network, NeuronGroup, meter, ms, np, um, second
 
 import cleo
 from cleo.coords import assign_coords_rand_rect_prism, assign_xyz
@@ -11,6 +11,10 @@
     gcamp6f,
     target_neurons_in_plane,
 )
+from cleo.opto.opsin_library import chrmine_4s
+from cleo.opto.opsin_library import chr2_4s
+
+opsin = chr2_4s()
 
 
 def test_scope():
@@ -160,5 +164,125 @@ def test_scope_to_neo(regular):
     assert np.all(sig.array_annotations["i_roi"] == np.arange(scope.n))
 
 
+def test_no_simultaneous_neuron():
+    scope = Scope(
+        focus_depth=200 * um,
+        img_width=500 * um,
+        sensor=gcamp6f(),
+    )
+
+    ng = NeuronGroup(
+        100,
+        """dv/dt = (Iopto - v) / (10*ms) : volt
+    Iopto : amp""",
+        threshold="v > 1*volt",
+        method="euler",
+    )
+    assign_xyz(ng, 0, 0, 0)
+    ng.z[0:40] = 200 * um
+    ng.z[40:75] = 300 * um
+    ng.z[75:] = 400 * um
+
+    sim = cleo.CLSimulator(Network(ng))
+    opsin = chr2_4s()
+
+    sim.inject(scope, ng)
+    sim.inject(opsin, ng)
+    light = scope.create_imaging_light()
+    sim.inject(light, ng)
+    syn = list(sim.registry.light_prop_syns.values())[0]
+    print(list(syn.variables.keys()))
+    src = sim.registry.source_for_light(light)
+    print(list(src.variables.keys()))
+
+    N = src.N
+    scan_period = src.scan_period[0] / second
+    pulse_width = src.pulse_width[0] / second
+
+    # check at multiple timepoints across one scan period
+    for t in np.linspace(0, scan_period, 100):
+        # light prop model formula
+        active = sum(
+            int(((t + scan_period * (i / N)) % scan_period) < pulse_width)
+            for i in range(N)
+        )
+        assert active <= 1
+
+
+def test_rate_scale():
+    scope = Scope(
+        focus_depth=200 * um,
+        img_width=500 * um,
+        sensor=gcamp6f(),
+    )
+
+    ng = NeuronGroup(
+        100,
+        """dv/dt = (Iopto - v) / (10*ms) : volt
+    Iopto : amp""",
+        threshold="v > 1*volt",
+        method="euler",
+    )
+    assign_xyz(ng, 0, 0, 0)
+    ng.z[0:40] = 200 * um
+    ng.z[40:75] = 300 * um
+    ng.z[75:] = 400 * um
+
+    sim = cleo.CLSimulator(Network(ng))
+    opsin = chr2_4s()
+
+    sim.inject(scope, ng)
+    sim.inject(opsin, ng)
+    light = scope.create_imaging_light()
+    sim.inject(light, ng)
+
+    src = sim.registry.source_for_light(light)
+    print(list(src.variables.keys()))
+
+    light.pulse_freq = 50
+    assert np.isclose(src.scan_period[0] / second, 1 / 50, atol=1e-6)
+
+    light.pulse_freq = 60
+    assert np.isclose(src.scan_period[0] / second, 1 / 60, atol=1e-6)
+
+
+def test_irradiance_scale():
+    scope = Scope(
+        focus_depth=200 * um,
+        img_width=500 * um,
+        sensor=gcamp6f(),
+    )
+
+    ng = NeuronGroup(
+        100,
+        """dv/dt = (Iopto - v) / (10*ms) : volt
+    Iopto : amp""",
+        threshold="v > 1*volt",
+        method="euler",
+    )
+    assign_xyz(ng, 0, 0, 0)
+    ng.z[0:40] = 200 * um
+    ng.z[40:75] = 300 * um
+    ng.z[75:] = 400 * um
+
+    sim = cleo.CLSimulator(Network(ng))
+    opsin = chrmine_4s()
+
+    sim.inject(scope, ng)
+    sim.inject(opsin, ng)
+    light = scope.create_imaging_light()
+    sim.inject(light, ng)
+
+    src = sim.registry.source_for_light(light)
+    print(list(src.variables.keys()))
+
+    # doubling light.pulse_freq halves scan_period, so pulse_width should also half
+    light.pulse_freq = 30
+    pulse_width_30 = src.pulse_width[0] / second
+    light.pulse_freq = 60
+    pulse_width_60 = src.pulse_width[0] / second
+    assert np.isclose(pulse_width_60, 0.5 * pulse_width_30, atol=1e-10)
+
+
 if __name__ == "__main__":
     pytest.main(["-s", "--disable-warnings", __file__])
diff --git a/tests/test_registry.py b/tests/test_registry.py
index a1287562..1f7a182f 100644
--- a/tests/test_registry.py
+++ b/tests/test_registry.py
@@ -1,7 +1,23 @@
 import warnings
 
 import pytest
-from brian2 import Network, NeuronGroup, mm, mm2, ms, mV, mwatt, nmeter, np, umeter
+import cleo
+import brian2
+from brian2 import (
+    Network,
+    NeuronGroup,
+    mm,
+    mm2,
+    ms,
+    mV,
+    mwatt,
+    nmeter,
+    np,
+    umeter,
+    meter,
+    um,
+)
+
 
 from cleo import CLSimulator
 from cleo.coords import assign_coords_grid_rect_prism
@@ -9,6 +25,12 @@
 from cleo.opto import Opsin, chr2_4s, vfchrimson_4s
 
 
+from cleo.imaging.scope import Scope
+
+from cleo.imaging import gcamp6f
+from cleo.coords import assign_xyz
+
+
 @pytest.fixture
 def ng1() -> NeuronGroup:
     ng = NeuronGroup(
@@ -220,5 +242,51 @@ def test_multi_light_opsin(sim_ng1_ng2):
     assert np.all(ng1.v == -70 * mV)
 
 
+def test_connections_survive_rebuild():
+    """Verify that existing light-opsin connections are preserved when a second light is injected."""
+    scope = Scope(
+        focus_depth=200 * um,
+        img_width=500 * um,
+        sensor=gcamp6f(),
+    )
+    ng = NeuronGroup(
+        100,
+        """dv/dt = (Iopto - v) / (10*ms) : volt
+        Iopto : amp""",
+        threshold="v > 1*volt",
+        method="euler",
+    )
+    assign_xyz(ng, 0, 0, 0)
+    ng.z[0:40] = 200 * um
+
+    sim = cleo.CLSimulator(Network(ng))
+    sim.inject(scope, ng)
+
+    opsin = chr2_4s()
+    sim.inject(opsin, ng)
+
+    # inject first imaging light
+    light1 = scope.create_imaging_light(wavelength=473e-9 * meter)
+    sim.inject(light1, ng)
+
+    # verify connection exists
+    assert (light1, opsin, ng) in sim.registry.connections
+
+    # inject second light from a different scope (triggers registry rebuild)
+    scope2 = Scope(
+        name="scope2",
+        focus_depth=200 * um,
+        img_width=500 * um,
+        sensor=gcamp6f(),
+    )
+    sim.inject(scope2, ng)
+    light2 = scope2.create_imaging_light(wavelength=473e-9 * meter)
+    sim.inject(light2, ng)
+
+    # verify first connection survived the rebuild
+    assert (light1, opsin, ng) in sim.registry.connections
+    assert (light2, opsin, ng) in sim.registry.connections
+
+
 if __name__ == "__main__":
     pytest.main(["-s", __file__])