From 4ca8e80ceead1ae12f1e50f5e0cc4600cf588544 Mon Sep 17 00:00:00 2001
From: kilianp14 <kilian.paul14@gmail.com>
Date: Mon, 27 May 2024 14:56:32 +0200
Subject: [PATCH 1/5] Updated SimpleBattery to new API + tests

---
 tests/test_signal.py  |  35 ++++----
 tests/test_storage.py | 191 +++++++++++++++++++++---------------------
 vessim/storage.py     |  53 ++++++++----
 3 files changed, 150 insertions(+), 129 deletions(-)

diff --git a/tests/test_signal.py b/tests/test_signal.py
index fda896e..2ca0486 100644
--- a/tests/test_signal.py
+++ b/tests/test_signal.py
@@ -97,20 +97,18 @@ def test_forecast_single_column(self, hist_signal_single):
             start_time="2023-01-01T00:00:00",
             end_time="2023-01-01T01:00:00",
         ) == {
-                np.datetime64("2023-01-01T00:30:00.000000000"): 2.0,
-                np.datetime64("2023-01-01T01:00:00.000000000"): 3.0,
-            }
-
+            np.datetime64("2023-01-01T00:30:00.000000000"): 2.0,
+            np.datetime64("2023-01-01T01:00:00.000000000"): 3.0,
+        }
 
     def test_forecast_static(self, hist_signal_static_forecast):
         assert hist_signal_static_forecast.forecast(
             start_time="2023-01-01T00:00:00",
             end_time="2023-01-01T02:00:00",
         ) == {
-                np.datetime64("2023-01-01T01:00:00.000000000"): 2.0,
-                np.datetime64("2023-01-01T02:00:00.000000000"): 4.0,
-            }
-
+            np.datetime64("2023-01-01T01:00:00.000000000"): 2.0,
+            np.datetime64("2023-01-01T02:00:00.000000000"): 4.0,
+        }
 
     @pytest.mark.parametrize(
         "start, end, column, expected",
@@ -122,7 +120,7 @@ def test_forecast_static(self, hist_signal_static_forecast):
                 {
                     np.datetime64("2023-01-01T00:10:00.000000000"): 2.0,
                     np.datetime64("2023-01-01T01:00:00.000000000"): 1.5,
-                }
+                },
             ),
             (
                 "2023-01-01T01:00:00",
@@ -159,7 +157,7 @@ def test_forecast_static(self, hist_signal_static_forecast):
                 {
                     np.datetime64("2023-01-01T02:00:00.000000000"): 3.0,
                     np.datetime64("2023-01-01T03:00:00.000000000"): 1.5,
-                }
+                },
             ),
         ],
     )
@@ -259,13 +257,16 @@ def test_forecast(self, hist_signal_forecast, start, end, column, expected):
     def test_forecast_with_frequency(
         self, hist_signal_forecast, start, end, column, frequency, method, expected
     ):
-        assert hist_signal_forecast.forecast(
-            start,
-            end,
-            column=column,
-            frequency=frequency,
-            resample_method=method,
-        ) == expected
+        assert (
+            hist_signal_forecast.forecast(
+                start,
+                end,
+                column=column,
+                frequency=frequency,
+                resample_method=method,
+            )
+            == expected
+        )
 
     def test_forecast_fails_if_column_not_specified(self, hist_signal):
         with pytest.raises(ValueError):
diff --git a/tests/test_storage.py b/tests/test_storage.py
index cc6eaf7..f372f9a 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -1,4 +1,5 @@
 import pytest
+import math
 
 import vessim as vs
 
@@ -6,65 +7,68 @@
 class TestSimpleBattery:
     @pytest.fixture
     def battery(self) -> vs.SimpleBattery:
-        return vs.SimpleBattery(capacity=100, charge_level=80, min_soc=0.1)
+        return vs.SimpleBattery(capacity=100, initial_soc=0.8, min_soc=0.1)
 
     @pytest.fixture
     def battery_c(self) -> vs.SimpleBattery:
         """This battery can only be (dis)charged at 10W max."""
-        return vs.SimpleBattery(capacity=3600, charge_level=1800, c_rate=10)
-
-    def test_soc(self, battery):
-        assert battery.soc() == 0.8
+        return vs.SimpleBattery(capacity=10, initial_soc=0.5, c_rate=1)
 
     @pytest.mark.parametrize(
-        "power, duration, exp_charge_energy, exp_charge_level",
+        "power, duration, exp_charge_energy, exp_charge_level, exp_soc",
         [
             # No charge
-            (0, 1000, 0, 80),
+            (0, 1000, 0, 80, 0.8),
             # Charge
-            (1, 1, 1, 81),
-            (10, 2, 20, 100),
-            (10, 4, 20, 100),
-            (100, 4, 20, 100),
+            (1, 1, 1, 81, 0.81),
+            (10, 2, 20, 100, 1),
+            (10, 4, 20, 100, 1),
+            (100, 4, 20, 100, 1),
             # Discharge
-            (-1, 1, -1, 79),
-            (-10, 7, -70, 10),
-            (-15, 7, -70, 10),
-            (-10, 14, -70, 10),
+            (-1, 1, -1, 79, 0.79),
+            (-10, 7, -70, 10, 0.1),
+            (-15, 7, -70, 10, 0.1),
+            (-10, 14, -70, 10, 0.1),
         ],
     )
-    def test_update(self, battery, power, duration, exp_charge_energy, exp_charge_level):
-        charge_energy = battery.update(power=power, duration=duration)
-        assert charge_energy == exp_charge_energy
-        assert battery.charge_level == exp_charge_level
+    def test_update(self, battery, power, duration, exp_charge_energy, exp_charge_level, exp_soc):
+        # duration in hours and charge_level in Wh
+        charge_energy = battery.update(power=power, duration=duration * 3600)
+        assert charge_energy == exp_charge_energy * 3600
+        assert battery.state()["charge_level"] == exp_charge_level
+        assert math.isclose(battery.state()["soc"], exp_soc)
 
     @pytest.mark.parametrize(
-        "power, duration, exp_delta, exp_charge_level",
+        "power, duration, exp_charge_energy, exp_charge_level, exp_soc",
         [
             # No charge
-            (0, 10, 0, 1800),
+            (0, 10, 0, 5, 0.5),
             # Charge
-            (10, 10, 100, 1900),
-            (20, 10, 100, 1900),
-            (50, 10, 100, 1900),
+            (10, 6, 1, 6, 0.6),
+            (20, 6, 1, 6, 0.6),
+            (50, 6, 1, 6, 0.6),
             # Discharge
-            (-10, 10, -100, 1700),
-            (-20, 10, -100, 1700),
-            (-50, 10, -100, 1700),
+            (-10, 6, -1, 4, 0.4),
+            (-20, 6, -1, 4, 0.4),
+            (-50, 6, -1, 4, 0.4),
             # Charge over capacity
-            (10, 180, 1800, 3600),
-            (10, 200, 1800, 3600),
-            (15, 200, 1800, 3600),
+            (10, 30, 5, 10, 1),
+            (10, 40, 5, 10, 1),
+            (15, 40, 5, 10, 1),
             # Discharge until empty
-            (-10, 180, -1800, 0),
-            (-10, 200, -1800, 0),
-            (-15, 200, -1800, 0),
+            (-10, 30, -5, 0, 0),
+            (-10, 40, -5, 0, 0),
+            (-15, 40, -5, 0, 0),
         ],
     )
-    def test_update_c_rate(self, battery_c, power, duration, exp_delta, exp_charge_level):
-        delta = battery_c.update(power=power, duration=duration)
-        assert delta == exp_delta
-        assert battery_c.charge_level == exp_charge_level
+    def test_update_c_rate(
+        self, battery_c, power, duration, exp_charge_energy, exp_charge_level, exp_soc
+    ):
+        # duration in minutes and charge_level in Wh
+        charge_energy = battery_c.update(power=power, duration=duration * 60)
+        assert charge_energy == exp_charge_energy * 3600
+        assert battery_c.state()["charge_level"] == exp_charge_level
+        assert math.isclose(battery_c.state()["soc"], exp_soc)
 
     def test_update_fails_if_duration_not_positive(self, battery):
         with pytest.raises(ValueError):
@@ -74,7 +78,7 @@ def test_update_fails_if_duration_not_positive(self, battery):
 class TestDefaultMicrogridPolicy:
     @pytest.fixture
     def battery(self) -> vs.SimpleBattery:
-        return vs.SimpleBattery(capacity=100, charge_level=80, min_soc=0.1)
+        return vs.SimpleBattery(capacity=100, initial_soc=0.8, min_soc=0.1)
 
     @pytest.fixture
     def policy(self) -> vs.DefaultMicrogridPolicy:
@@ -93,92 +97,88 @@ def policy_islanded(self) -> vs.DefaultMicrogridPolicy:
         return vs.DefaultMicrogridPolicy(mode="islanded")
 
     @pytest.mark.parametrize(
-        "power, duration, exp_delta, exp_charge_level",
+        "power, duration, exp_delta, exp_soc",
         [
             # No charge
-            (0, 1000, 0, 80),
+            (0, 1000, 0, 0.8),
             # Charge
-            (5, 2, 0, 90),
-            (100, 4, 380, 100),
+            (5, 2, 0, 0.9),
+            (10, 4, 20, 1),
             # Discharge
-            (-5, 2, 0, 70),
-            (-10, 14, -70, 10),
+            (-5, 2, 0, 0.7),
+            (-10, 14, -70, 0.1),
         ],
     )
-    def test_apply_no_charge_mode(
-        self, battery, policy, power, duration, exp_delta, exp_charge_level
-    ):
-        delta = policy.apply(power, duration, battery)
-        assert delta == exp_delta
-        assert battery.charge_level == exp_charge_level
+    def test_apply_no_charge_mode(self, battery, policy, power, duration, exp_delta, exp_soc):
+        # duration in hours and energy delta in Wh
+        delta = policy.apply(power, duration * 3600, battery)
+        assert delta == exp_delta * 3600
+        assert math.isclose(battery.state()["soc"], exp_soc)
 
     @pytest.mark.parametrize(
-        "power, duration, exp_delta, exp_charge_level",
+        "power, duration, exp_delta, exp_soc",
         [
             # Charge from grid without power-delta
-            (0, 1, -10, 90),
-            (0, 2, -20, 100),
-            (0, 10, -20, 100),
+            (0, 1, -10, 0.9),
+            (0, 2, -20, 1),
+            (0, 10, -20, 1),
             # Charge from grid with positive power-delta
-            (5, 1, -5, 90),
-            (5, 2, -10, 100),
-            (5, 10, 30, 100),
+            (5, 1, -5, 0.9),
+            (5, 2, -10, 1),
+            (5, 10, 30, 1),
             # Charge from grid with negative power-delta
-            (-5, 1, -15, 90),
-            (-5, 2, -30, 100),
-            (-5, 10, -70, 100),
+            (-5, 1, -15, 0.9),
+            (-5, 2, -30, 1),
+            (-5, 10, -70, 1),
         ],
     )
-    def test_apply_charge(
-        self, battery, policy_charge, power, duration, exp_delta, exp_charge_level
-    ):
-        delta = policy_charge.apply(power, duration, battery)
-        assert delta == exp_delta
-        assert battery.charge_level == exp_charge_level
+    def test_apply_charge(self, battery, policy_charge, power, duration, exp_delta, exp_soc):
+        # duration in hours and energy delta in Wh
+        delta = policy_charge.apply(power, duration * 3600, battery)
+        assert delta == exp_delta * 3600
+        assert math.isclose(battery.state()["soc"], exp_soc)
 
     @pytest.mark.parametrize(
-        "power, duration, exp_delta, exp_charge_level",
+        "power, duration, exp_delta, exp_soc",
         [
             # Discharge to grid without power-delta
-            (0, 1, 10, 70),
-            (0, 7, 70, 10),
-            (0, 10, 70, 10),
+            (0, 1, 10, 0.7),
+            (0, 7, 70, 0.1),
+            (0, 10, 70, 0.1),
             # Discharge to grid with positive power-delta
-            (5, 1, 15, 70),
-            (5, 7, 105, 10),
-            (5, 10, 120, 10),
+            (5, 1, 15, 0.7),
+            (5, 7, 105, 0.1),
+            (5, 10, 120, 0.1),
             # Discharge to grid with negative power-delta
-            (-5, 1, 5, 70),
-            (-5, 7, 35, 10),
-            (-5, 20, -30, 10),
+            (-5, 1, 5, 0.7),
+            (-5, 7, 35, 0.1),
+            (-5, 20, -30, 0.1),
         ],
     )
-    def test_apply_discharge(
-        self, battery, policy_discharge, power, duration, exp_delta, exp_charge_level
-    ):
-        delta = policy_discharge.apply(power, duration, battery)
-        assert delta == exp_delta
-        assert battery.charge_level == exp_charge_level
+    def test_apply_discharge(self, battery, policy_discharge, power, duration, exp_delta, exp_soc):
+        # duration in hours and energy delta in Wh
+        delta = policy_discharge.apply(power, duration * 3600, battery)
+        assert delta == exp_delta * 3600
+        assert math.isclose(battery.state()["soc"], exp_soc)
 
     @pytest.mark.parametrize(
-        "power, duration, exp_delta, exp_charge_level",
+        "power, duration, exp_delta, exp_soc",
         [
             # No charge
-            (0, 1000, 0, 80),
+            (0, 1000, 0, 0.8),
             # Charge
-            (5, 2, 0, 90),
-            (100, 4, 0, 100),
+            (5, 2, 0, 0.9),
+            (100, 4, 0, 1),
             # Discharge
-            (-5, 2, 0, 70),
-            (-10, 7, 0, 10),
+            (-5, 2, 0, 0.7),
+            (-10, 7, 0, 0.1),
         ],
     )
-    def test_apply_islanded(
-        self, battery, policy_islanded, power, duration, exp_delta, exp_charge_level
-    ):
-        delta = policy_islanded.apply(power, duration, battery)
-        assert delta == exp_delta
-        assert battery.charge_level == exp_charge_level
+    def test_apply_islanded(self, battery, policy_islanded, power, duration, exp_delta, exp_soc):
+        # duration in hours and energy delta in Wh
+        delta = policy_islanded.apply(power, duration * 3600, battery)
+        assert delta == exp_delta * 3600
+        assert math.isclose(battery.state()["soc"], exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_delta",
@@ -194,12 +194,13 @@ def test_apply_islanded(
         ],
     )
     def test_apply_no_storage(self, policy, power, duration, exp_delta):
+        # duration in seconds and energy delta in Ws
         delta = policy.apply(power, duration)
         assert delta == exp_delta
 
     def test_apply_fails_if_no_power_in_islanded_with_battery(self, battery, policy_islanded):
         with pytest.raises(RuntimeError):
-            policy_islanded.apply(-1, 71, battery)
+            policy_islanded.apply(-1, 71 * 3600, battery)
 
     def test_apply_fails_if_no_power_in_islanded_without_battery(self, policy_islanded):
         with pytest.raises(RuntimeError):
diff --git a/vessim/storage.py b/vessim/storage.py
index 06dae4a..66fe0fd 100644
--- a/vessim/storage.py
+++ b/vessim/storage.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Optional, Any
 
 from loguru import logger
 
@@ -18,6 +18,16 @@ def update(self, power: float, duration: int) -> float:
             The total energy in Ws that has been charged/discharged.
         """
 
+    def set_parameter(self, key: str, value: Any) -> None:
+        """Fuction to let a controller update a storage parameter during a simulation using Mosaik.
+
+        In the default case, the attribute with the name of the key is set on the storage object.
+        The function can be subclassed to allow other ways of setting parameters.
+        """
+        if not hasattr(self, key):
+            logger.warning(f"Attribute {key} of storage was never previously set.")
+        setattr(self, key, value)
+
     def state(self) -> dict:
         """Returns information about the current state of the storage. Should be overridden."""
         return {}
@@ -27,10 +37,10 @@ class SimpleBattery(Storage):
     """(Way too) simple battery.
 
     Args:
-        capacity: Battery capacity in watt-seconds (Ws).
-        charge_level: Initial charge level in watt-seconds (Ws). Defaults to 0Ws.
-        min_soc: Minimum allowed state of charge (SoC) for the battery.
-            Defaults to 0%. Can be altered during simulation.
+        capacity: Battery's energy capacity. (Wh).
+        initial_soc: Initial battery state-of-charge. Has to be between 0 and 1. Defaults to 0.
+        min_soc: Minimum allowed state of charge (SoC) for the battery. Has to be between 0 and 1.
+            Defaults to 0. Can be altered during simulation.
         c_rate: Optional C-rate, which defines the charge and discharge rate of the battery.
             For more information on C-rate, see `C-rate explanation <https://www.batterydesign.net/electrical/c-rate/>`_.
             Defaults to None.
@@ -39,24 +49,32 @@ class SimpleBattery(Storage):
     def __init__(
         self,
         capacity: float,
-        charge_level: float = 0,
+        initial_soc: float = 0,
         min_soc: float = 0,
         c_rate: Optional[float] = None,
     ):
         self.capacity = capacity
-        assert 0 <= charge_level <= self.capacity
-        self.charge_level = charge_level
-        assert 0 <= min_soc <= self.soc()
+        assert 0 <= initial_soc <= 1
+        self.charge_level = capacity * initial_soc
+        self.soc = initial_soc
+        assert 0 <= min_soc <= self.soc
         self.min_soc = min_soc
         self.c_rate = c_rate
 
     def update(self, power: float, duration: int) -> float:
+        """Charges the battery with specific power for a duration.
+
+        Updates batteries energy level according to power that is fed to/ drawn from the battery.
+        Battery won't be charged further than the capacity and won't be discharged further than the
+        minimum state-of-charge.
+        Batteries charging/ discharging rate is limited be the c_rate (if set).
+        """
         if duration <= 0.0:
             raise ValueError("Duration needs to be a positive value")
 
-        assert self.min_soc <= self.soc(), "Minimum SoC can not be smaller than the current SoC"
+        assert self.min_soc <= self.soc, "Minimum SoC can not be smaller than the current SoC"
         if self.c_rate is not None:
-            max_power = self.c_rate * self.capacity / 3600
+            max_power = self.c_rate * self.capacity
             if power >= max_power:
                 # Too high charge rate
                 logger.info(
@@ -73,7 +91,7 @@ def update(self, power: float, duration: int) -> float:
                 )
                 power = -max_power
 
-        charged_energy = power * duration  # Total energy to be (dis)charged in Ws
+        charged_energy = power * duration / 3600  # Total energy to be (dis)charged in Wh
         new_charge_level = self.charge_level + charged_energy
 
         abs_min_soc = self.min_soc * self.capacity
@@ -81,21 +99,22 @@ def update(self, power: float, duration: int) -> float:
             # Battery can not be discharged further than the minimum state-of-charge
             charged_energy = abs_min_soc - self.charge_level
             self.charge_level = abs_min_soc
+            self.soc = self.min_soc
         elif new_charge_level > self.capacity:
             # Battery can not be charged past its capacity
             charged_energy = self.capacity - self.charge_level
             self.charge_level = self.capacity
+            self.soc = 1.0
         else:
             self.charge_level = new_charge_level
+            self.soc = self.charge_level / self.capacity
 
-        return charged_energy
-
-    def soc(self) -> float:
-        return self.charge_level / self.capacity
+        return charged_energy * 3600 # Wh to Ws
 
     def state(self) -> dict:
+        """Returns state information of the battery as a dict."""
         return {
-            "soc": self.soc(),
+            "soc": self.soc,
             "charge_level": self.charge_level,
             "capacity": self.capacity,
             "min_soc": self.min_soc,

From e5c66636534af653d3bac75d081b9b29f98b98f3 Mon Sep 17 00:00:00 2001
From: kilianp14 <kilian.paul14@gmail.com>
Date: Mon, 27 May 2024 14:57:21 +0200
Subject: [PATCH 2/5] Started working on new message passing for updating of
 energy system parameters

---
 vessim/controller.py | 42 +++++++++--------------
 vessim/cosim.py      | 79 +++++++++++++++++++++++++++++---------------
 vessim/policy.py     | 16 +++++++--
 3 files changed, 81 insertions(+), 56 deletions(-)

diff --git a/vessim/controller.py b/vessim/controller.py
index b6c8e38..06d2df0 100644
--- a/vessim/controller.py
+++ b/vessim/controller.py
@@ -9,8 +9,6 @@
 import pandas as pd
 
 from vessim.signal import Signal
-from vessim.storage import Storage
-from vessim.policy import MicrogridPolicy
 
 if TYPE_CHECKING:
     from vessim.cosim import Microgrid
@@ -19,13 +17,14 @@
 class Controller(ABC):
     def __init__(self, step_size: Optional[int] = None):
         self.step_size = step_size
+        self.set_parameters: dict[str, Any] = {}
 
     def start(self, microgrid: Microgrid):
         """Function to be executed before simulation is started. Can be overridden."""
         pass
 
     @abstractmethod
-    def step(self, time: datetime, p_delta: float, e_delta: float, actor_states: dict) -> None:
+    def step(self, time: datetime, p_delta: float, e_delta: float, state: dict) -> None:
         """Performs a simulation step.
 
         Args:
@@ -33,9 +32,10 @@ def step(self, time: datetime, p_delta: float, e_delta: float, actor_states: dic
             p_delta: Power delta in W based on the consumption and production of all actors.
             e_delta: Total energy in Ws that has been drawn from/ fed to the utility grid
                 in the previous time step.
-            actor_states: Contains the last state dictionaries by all actors in the
-                microgrid. The state dictionary is defined by the actor and can contain
-                any information about the actor's state.
+            state: Contains the last state dictionaries by all actors, the policy, and the storage
+                in the microgrid. The state dictionary is defined by the microgrid components and
+                can contain any information about their custom defined state.
+                The keys are the actor names, `policy`, and `storage` respectively.
         """
 
     def finalize(self) -> None:
@@ -48,8 +48,6 @@ def __init__(
         self,
         step_size: Optional[int] = None,
         grid_signals: Optional[dict[str, Signal]] = None,
-        policy: Optional[MicrogridPolicy] = None,
-        storage: Optional[Storage] = None,
     ):
         super().__init__(step_size=step_size)
         self.monitor_log: dict[datetime, dict] = defaultdict(dict)
@@ -63,29 +61,15 @@ def fn(time):
 
                 self.add_monitor_fn(fn)
 
-        if policy is not None:
-
-            def fn(time):
-                return policy.state()
-
-            self.add_monitor_fn(fn)
-
-        if storage is not None:
-
-            def fn(time):
-                return storage.state()
-
-            self.add_monitor_fn(fn)
-
     def add_monitor_fn(self, fn: Callable[[float], dict[str, Any]]):
         self.custom_monitor_fns.append(fn)
 
-    def step(self, time: datetime, p_delta: float, e_delta: float, actor_states: dict) -> None:
+    def step(self, time: datetime, p_delta: float, e_delta: float, state: dict) -> None:
         log_entry = dict(
             p_delta=p_delta,
             e_delta=e_delta,
-            actor_states=actor_states,
         )
+        log_entry.update(state)
         for monitor_fn in self.custom_monitor_fns:
             log_entry.update(monitor_fn(time))
         self.monitor_log[time] = log_entry
@@ -114,7 +98,7 @@ class _ControllerSim(mosaik_api_v3.Simulator):
                 "public": True,
                 "any_inputs": True,
                 "params": ["controller"],
-                "attrs": [],
+                "attrs": ["set_parameters"],
             },
         },
     }
@@ -141,10 +125,12 @@ def step(self, time, inputs, max_advance):
         assert self.controller is not None
         now = self.clock.to_datetime(time)
         self.controller.step(now, *self._parse_controller_inputs(inputs[self.eid]))
+        self.set_parameters = self.controller.set_parameters.copy()
+        self.controller.set_parameters = {}
         return time + self.step_size
 
     def get_data(self, outputs):
-        return {}  # TODO so far unused
+        return {self.eid: {"set_parameters": self.set_parameters}}
 
     def finalize(self) -> None:
         """Stops the api server and the collector thread when the simulation finishes."""
@@ -162,7 +148,9 @@ def _parse_controller_inputs(
         for k in actor_keys:
             _, actor_name = k.split(".")
             actors[actor_name] = _get_val(inputs, k)
-        return p_delta, self.e - last_e, dict(actors)
+        state = dict(actors)
+        state.update(_get_val(inputs, "state"))
+        return p_delta, self.e - last_e, state
 
 
 def _get_val(inputs: dict, key: str) -> Any:
diff --git a/vessim/cosim.py b/vessim/cosim.py
index 3107980..b3d2632 100644
--- a/vessim/cosim.py
+++ b/vessim/cosim.py
@@ -41,10 +41,10 @@ def __init__(
             actor_entity = actor_sim.Actor(actor=actor)
             actor_names_and_entities.append((actor.name, actor_entity))
 
-        aggregator_sim = world.start("Aggregator", step_size=step_size)
-        aggregator_entity = aggregator_sim.Aggregator()
+        grid_sim = world.start("Grid", step_size=step_size)
+        grid_entity = grid_sim.Grid()
         for actor_name, actor_entity in actor_names_and_entities:
-            world.connect(actor_entity, aggregator_entity, "p")
+            world.connect(actor_entity, grid_entity, "p")
 
         controller_entities = []
         for controller in controllers:
@@ -54,24 +54,36 @@ def __init__(
                 raise ValueError("Controller step size has to be a multiple of grids step size.")
             controller_sim = world.start("Controller", clock=clock, step_size=controller_step_size)
             controller_entity = controller_sim.Controller(controller=controller)
-            world.connect(aggregator_entity, controller_entity, "p_delta")
+            world.connect(grid_entity, controller_entity, "p_delta")
             for actor_name, actor_entity in actor_names_and_entities:
                 world.connect(
                     actor_entity, controller_entity, ("state", f"actor.{actor_name}")
                 )
             controller_entities.append(controller_entity)
 
-        grid_sim = world.start("Grid", step_size=step_size)
-        grid_entity = grid_sim.Grid(storage=storage, policy=policy)
-        world.connect(aggregator_entity, grid_entity, "p_delta")
+        storage_sim = world.start("Storage", step_size=step_size)
+        storage_entity = storage_sim.Storage(storage=storage, policy=policy)
+        world.connect(grid_entity, storage_entity, "p_delta")
+        initial_state = {}
+        initial_state["policy"] = policy.state()
+        if storage:
+            initial_state["storage"] = storage.state()
         for controller_entity in controller_entities:
+            world.connect(controller_entity, storage_entity, "set_parameters")
             world.connect(
-                grid_entity,
+                storage_entity,
                 controller_entity,
                 "e",
                 time_shifted=True,
                 initial_data={"e": 0.0},
             )
+            world.connect(
+                storage_entity,
+                controller_entity,
+                "state",
+                time_shifted=True,
+                initial_data={"state": initial_state},
+            )
 
     def __getstate__(self) -> dict:
         """Returns a Dict with the current state of the microgrid for monitoring."""
@@ -93,9 +105,9 @@ def finalize(self):
 class Environment:
     COSIM_CONFIG = {
         "Actor": {"python": "vessim.actor:_ActorSim"},
-        "Aggregator": {"python": "vessim.cosim:_AggregatorSim"},
         "Controller": {"python": "vessim.controller:_ControllerSim"},
         "Grid": {"python": "vessim.cosim:_GridSim"},
+        "Storage": {"python": "vessim.cosim:_StorageSim"},
     }
 
     def __init__(self, sim_start):
@@ -148,11 +160,11 @@ def run(
             raise
 
 
-class _AggregatorSim(mosaik_api_v3.Simulator):
+class _GridSim(mosaik_api_v3.Simulator):
     META = {
         "type": "time-based",
         "models": {
-            "Aggregator": {
+            "Grid": {
                 "public": True,
                 "params": [],
                 "attrs": ["p", "p_delta"],
@@ -162,7 +174,7 @@ class _AggregatorSim(mosaik_api_v3.Simulator):
 
     def __init__(self):
         super().__init__(self.META)
-        self.eid = "Aggregator"
+        self.eid = "Grid"
         self.step_size = None
         self.p_delta = 0.0
 
@@ -182,40 +194,53 @@ def get_data(self, outputs):
         return {self.eid: {"p_delta": self.p_delta}}
 
 
-class _GridSim(mosaik_api_v3.Simulator):
+class _StorageSim(mosaik_api_v3.Simulator):
     META = {
         "type": "time-based",
         "models": {
-            "Grid": {
+            "Storage": {
                 "public": True,
                 "params": ["storage", "policy"],
-                "attrs": ["p_delta", "e"],
+                "attrs": ["p_delta", "set_parameters", "e", "state"],
             },
         },
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(self.META)
-        self.eid = "Grid"
-        self.step_size = None
-        self.storage = None
-        self.policy = None
-        self.e = 0.0
+        self.eid: str = "Storage"
 
-    def init(self, sid, time_resolution=1.0, **sim_params):
-        self.step_size = sim_params["step_size"]
+    def init(self, sid: str, time_resolution: float = 1.0, **sim_params):
+        self.step_size: int = sim_params["step_size"]
+        self.e: float = 0.0
+        self.state: dict = {}
         return self.meta
 
-    def create(self, num, model, **model_params):
+    def create(self, num: int, model, **model_params):
         assert num == 1, "Only one instance per simulation is supported"
-        self.storage = model_params["storage"]
-        self.policy = model_params["policy"]
+        self.storage: Optional[Storage] = model_params["storage"]
+        self.policy: MicrogridPolicy = model_params["policy"]
         return [{"eid": self.eid, "type": model}]
 
     def step(self, time, inputs, max_advance):
         p_delta = list(inputs[self.eid]["p_delta"].values())[0]
+        for parameters in inputs[self.eid]["set_parameters"].values():
+            for key, value in parameters.items():
+                key_split = key.split(":", 1)
+                if key_split[0] == "policy":
+                    self.policy.set_parameter(key_split[1], value)
+                elif key_split[0] == "storage":
+                    self.storage.set_parameter(key_split[1], value)
+                else:
+                    raise ValueError(
+                        f"Invalid parameter: {key}. Has to start with 'policy:' or 'storage:'."
+                    )
+
         self.e += self.policy.apply(p_delta, duration=self.step_size, storage=self.storage)
+        self.state["policy"] = self.policy.state()
+        if self.storage:
+            self.state["storage"] = self.storage.state()
         return time + self.step_size
 
     def get_data(self, outputs):
-        return {self.eid: {"e": self.e}}
+        return {self.eid: {"e": self.e, "state": self.state}}
diff --git a/vessim/policy.py b/vessim/policy.py
index 6cb0f5e..3c91ccc 100644
--- a/vessim/policy.py
+++ b/vessim/policy.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Optional, Literal
+from typing import Optional, Literal, Any
+
+from loguru import logger
 
 from vessim.storage import Storage
 
@@ -25,6 +27,16 @@ def apply(self, p_delta: float, duration: int, storage: Optional[Storage] = None
             Total energy in Ws that has to be drawn from/ is fed to the public grid.
         """
 
+    def set_parameter(self, key: str, value: Any) -> None:
+        """Fuction to let a controller update a policy parameter during a simulation using Mosaik.
+
+        In the default case, the attribute with the name of the key is set on the policy object.
+        The function can be subclassed to allow other ways of setting parameters.
+        """
+        if not hasattr(self, key):
+            logger.warning(f"Attribute {key} of policy was never previously set.")
+        setattr(self, key, value)
+
     def state(self) -> dict:
         """Returns information about the current state of the policy. Should be overridden."""
         return {}
@@ -55,7 +67,7 @@ def __init__(
         charge_power: Optional[float] = None,
     ):
         self.mode = mode
-        self.charge_power = charge_power
+        self.charge_power = charge_power if charge_power else 0.0
 
     def apply(self, p_delta: float, duration: int, storage: Optional[Storage] = None) -> float:
         energy_delta = p_delta * duration

From 52fc60a90d94bed8abb7734fbee7005db1a1018e Mon Sep 17 00:00:00 2001
From: kilianp14 <kilian.paul14@gmail.com>
Date: Fri, 7 Jun 2024 15:43:21 +0200
Subject: [PATCH 3/5] Updated examples and a bit of documentation

---
 examples/basic_example.ipynb      | 41 ++++++++++++++++---------------
 examples/controller_example.ipynb | 33 +++++++++++++------------
 vessim/policy.py                  | 13 ++++++++--
 vessim/storage.py                 |  2 +-
 4 files changed, 50 insertions(+), 39 deletions(-)

diff --git a/examples/basic_example.ipynb b/examples/basic_example.ipynb
index 62288d8..301fc57 100644
--- a/examples/basic_example.ipynb
+++ b/examples/basic_example.ipynb
@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -30,27 +30,27 @@
     "\n",
     "- A simulated `ComputingSystem` with two servers that consistently draw 200W and 250W, respectively. The datacenter has a [power usage effectiveness](https://en.wikipedia.org/wiki/Power_usage_effectiveness) of 1.6, resulting in a total power demand of 1.6 * (200 W + 250 W) = 720 W.\n",
     "- A `Generator` which represents a solar panel in Berlin, modeled according to the dataset `solcast2022_global` that comes with Vessim (see \"Signal\" example). The values are normalized to represent the panel's power production potential in percentages. For instance, on July 8th, 2022, in Berlin, the value given is 0.6, meaning that a solar panel would generate 60% of its maximum potential energy.\n",
-    "- A `SimpleBattery` with a usable capacity of 100 Wh which is initially charged with 80Wh.\n",
+    "- A `SimpleBattery` with a usable capacity of 500 Wh which is initially charged at 80%.\n",
     "- A `Monitor` which periodically stores the microgrid state and eventually writes it to a CSV file."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2024-04-22 11:32:52.325 | INFO     | mosaik.scenario:start:280 - Starting \"Actor\" as \"Actor-0\" ...\n",
-      "2024-04-22 11:32:52.326 | INFO     | mosaik.scenario:start:280 - Starting \"Actor\" as \"Actor-1\" ...\n",
-      "2024-04-22 11:32:52.327 | INFO     | mosaik.scenario:start:280 - Starting \"Aggregator\" as \"Aggregator-0\" ...\n",
-      "2024-04-22 11:32:52.327 | INFO     | mosaik.scenario:start:280 - Starting \"Controller\" as \"Controller-0\" ...\n",
-      "2024-04-22 11:32:52.328 | INFO     | mosaik.scenario:start:280 - Starting \"Grid\" as \"Grid-0\" ...\n",
-      "2024-04-22 11:32:52.330 | INFO     | mosaik.scenario:run:598 - Starting simulation.\n",
-      "100%|\u001b[32m██████████\u001b[0m| 86400/86400 [00:00<00:00, 130816.03steps/s]\n",
-      "2024-04-22 11:32:52.993 | INFO     | mosaik.scenario:run:646 - Simulation finished successfully.\n"
+      "2024-06-03 16:46:53.836 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-0\" ...\n",
+      "2024-06-03 16:46:53.837 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-1\" ...\n",
+      "2024-06-03 16:46:53.838 | INFO     | mosaik.scenario:start:306 - Starting \"Grid\" as \"Grid-0\" ...\n",
+      "2024-06-03 16:46:53.839 | INFO     | mosaik.scenario:start:306 - Starting \"Controller\" as \"Controller-0\" ...\n",
+      "2024-06-03 16:46:53.840 | INFO     | mosaik.scenario:start:306 - Starting \"Storage\" as \"Storage-0\" ...\n",
+      "2024-06-03 16:46:53.840 | INFO     | mosaik.scenario:run:646 - Starting simulation.\n",
+      "100%|\u001b[32m██████████\u001b[0m| 86400/86400 [00:00<00:00, 119199.20steps/s]\n",
+      "2024-06-03 16:46:54.567 | INFO     | mosaik.scenario:run:694 - Simulation finished successfully.\n"
      ]
     }
    ],
@@ -60,14 +60,15 @@
     "monitor = vs.Monitor()  # stores simulation result on each step\n",
     "environment.add_microgrid(\n",
     "    actors=[\n",
-    "        vs.ComputingSystem(power_meters=[vs.MockPowerMeter(p=200), vs.MockPowerMeter(p=250)], pue=1.6),\n",
+    "        vs.ComputingSystem(power_meters=[vs.MockPowerMeter(p=100), vs.MockPowerMeter(p=150)], pue=1.3),\n",
     "        vs.Generator(\n",
-    "            signal=vs.HistoricalSignal.from_dataset(\"solcast2022_global\", params={\"scale\": 5000}),\n",
+    "            name=\"solar\",\n",
+    "            signal=vs.HistoricalSignal.from_dataset(\"solcast2022_global\", params={\"scale\": 2500}),\n",
     "            column=\"Berlin\",\n",
     "        ),\n",
     "    ],\n",
     "    controllers=[monitor],\n",
-    "    storage=vs.SimpleBattery(capacity=100 * 3600, charge_level=80 * 3600),\n",
+    "    storage=vs.SimpleBattery(capacity=1500, initial_soc=0.8, min_soc=0.5),\n",
     "    step_size=60,  # global step size (can be overridden by actors or controllers)\n",
     ")\n",
     "\n",
@@ -88,12 +89,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -109,13 +110,13 @@
     "\n",
     "df = pd.read_csv(\"result.csv\", parse_dates=[0], index_col=0)\n",
     "# divide e_delta by step size because e_delta is energy\n",
-    "df[\"e_delta\"] = df[\"e_delta\"] / 60\n",
+    "df[\"grid_power\"] = df[\"e_delta\"] / 60\n",
     "\n",
     "fig, ax1 = plt.subplots()\n",
     "\n",
-    "ax1.plot(df.index, df[\"e_delta\"], color=\"b\", label=\"e_delta\")\n",
+    "ax1.plot(df.index, df[\"grid_power\"], color=\"b\", label=\"e_delta\")\n",
     "ax1.legend()\n",
-    "ax1.plot(df.index, df[\"actor_states.Generator-0.p\"], color=\"y\", label=\"solar\")\n",
+    "ax1.plot(df.index, df[\"solar.p\"], color=\"y\", label=\"solar\")\n",
     "ax1.legend()\n",
     "ax1.xaxis.set_major_formatter(mdates.DateFormatter(\"%H\"))\n",
     "ax1.grid()\n",
@@ -142,7 +143,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,
diff --git a/examples/controller_example.ipynb b/examples/controller_example.ipynb
index 1edf944..ba36576 100644
--- a/examples/controller_example.ipynb
+++ b/examples/controller_example.ipynb
@@ -51,7 +51,7 @@
     "        # save original meter power consumption\n",
     "        self.meter_p = {meter.name: meter.measure() for meter in self.power_meters}\n",
     "\n",
-    "    def step(self, time: int, p_delta: float, e_delta: float, actor_infos: dict) -> None:\n",
+    "    def step(self, time: int, p_delta: float, e_delta: float, state: dict) -> None:\n",
     "        for power_meter in self.power_meters:\n",
     "            new_power = self.meter_p[power_meter.name]\n",
     "            if p_delta < 0:\n",
@@ -77,15 +77,15 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2024-04-22 11:35:21.176 | INFO     | mosaik.scenario:start:280 - Starting \"Actor\" as \"Actor-0\" ...\n",
-      "2024-04-22 11:35:21.176 | INFO     | mosaik.scenario:start:280 - Starting \"Actor\" as \"Actor-1\" ...\n",
-      "2024-04-22 11:35:21.177 | INFO     | mosaik.scenario:start:280 - Starting \"Aggregator\" as \"Aggregator-0\" ...\n",
-      "2024-04-22 11:35:21.178 | INFO     | mosaik.scenario:start:280 - Starting \"Controller\" as \"Controller-0\" ...\n",
-      "2024-04-22 11:35:21.178 | INFO     | mosaik.scenario:start:280 - Starting \"Controller\" as \"Controller-1\" ...\n",
-      "2024-04-22 11:35:21.179 | INFO     | mosaik.scenario:start:280 - Starting \"Grid\" as \"Grid-0\" ...\n",
-      "2024-04-22 11:35:21.181 | INFO     | mosaik.scenario:run:598 - Starting simulation.\n",
-      "100%|\u001b[32m██████████\u001b[0m| 86400/86400 [00:00<00:00, 103307.89steps/s]\n",
-      "2024-04-22 11:35:22.020 | INFO     | mosaik.scenario:run:646 - Simulation finished successfully.\n"
+      "2024-06-03 15:01:17.494 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-0\" ...\n",
+      "2024-06-03 15:01:17.495 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-1\" ...\n",
+      "2024-06-03 15:01:17.496 | INFO     | mosaik.scenario:start:306 - Starting \"Grid\" as \"Grid-0\" ...\n",
+      "2024-06-03 15:01:17.496 | INFO     | mosaik.scenario:start:306 - Starting \"Controller\" as \"Controller-0\" ...\n",
+      "2024-06-03 15:01:17.497 | INFO     | mosaik.scenario:start:306 - Starting \"Controller\" as \"Controller-1\" ...\n",
+      "2024-06-03 15:01:17.497 | INFO     | mosaik.scenario:start:306 - Starting \"Storage\" as \"Storage-0\" ...\n",
+      "2024-06-03 15:01:17.498 | INFO     | mosaik.scenario:run:646 - Starting simulation.\n",
+      "100%|\u001b[32m██████████\u001b[0m| 86400/86400 [00:00<00:00, 89932.37steps/s]\n",
+      "2024-06-03 15:01:18.461 | INFO     | mosaik.scenario:run:694 - Simulation finished successfully.\n"
      ]
     }
    ],
@@ -102,11 +102,12 @@
     "    actors=[\n",
     "        vs.ComputingSystem(power_meters=power_meters, pue=1.6),\n",
     "        vs.Generator(\n",
+    "            name=\"solar\",\n",
     "            signal=vs.HistoricalSignal.from_dataset(\"solcast2022_global\", params={\"scale\": 5000}),\n",
     "            column=\"Berlin\",\n",
     "        ),\n",
     "    ],\n",
-    "    storage=vs.SimpleBattery(capacity=100 * 3600, charge_level=80 * 3600),\n",
+    "    storage=vs.SimpleBattery(capacity=500, initial_soc=0.8),\n",
     "    controllers=[monitor, load_balancer],\n",
     "    step_size=60,  # Global step size (can be overridden by actors or controllers)\n",
     ")\n",
@@ -129,7 +130,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGwCAYAAACjPMHLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHoklEQVR4nO3dd3wUdfoH8M9syaY3SCUhhF6kqxCUImIoHvaGWFDOCnqCWE9B9E7sHesd6PmzcHonp6hIpAuhE3rvkAaB9LJtfn9MZnc22b4zOyXP+/Xixezs7Mz3u5vsPHm+jWFZlgUhhBBCCAEA6OQuACGEEEKIklBwRAghhBAiQMERIYQQQogABUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQoiAQe4CqI3dbkdxcTHi4uLAMIzcxSGEEEKIH1iWRU1NDTIzM6HTec8NUXAUoOLiYmRnZ8tdDEIIIYQE4dSpU8jKyvJ6DAVHAYqLiwPAvbnx8fGinttisWDZsmXIz8+H0WgU9dxKoPX6AdqvI9VP/bReR63XD9B+HaWqX3V1NbKzsx33cW8oOAoQ35QWHx8vSXAUHR2N+Ph4zf7Aa7l+gPbrSPVTP63XUev1A7RfR6nr50+XGOqQTQghhBAiQMERIYQQQogABUeEEEIIIQLU54gQQggJkc1mg8ViCcu1LBYLDAYDGhsbYbPZwnLNcAq2fkajEXq9XpQyUHBECCGEBIllWZSWlqKysjKs10xPT8epU6c0Od9eKPVLTExEenp6yO8LBUeEEEJIkPjAKDU1FdHR0WEJVux2O2praxEbG+tzMkM1CqZ+LMuivr4e5eXlAICMjIyQykDBESGEEBIEm83mCIzatWsXtuva7XaYzWZERkZqNjgKpn5RUVEAgPLycqSmpobUxKa9d5UQQggJA76PUXR0tMwlITz+swi1/xcFR4QQQkgItNjvR63E+iwoOCKEEEIIEaDgiBBCCCFEgIIjQgghhIRk1apVYBgmoCkNOnXqhHfeeUeyMoWCgiNCCCEOdrsVZvM5NDUVo6mpRO7ikDaEYRgsXrxY7mIAoKH8hBBCmlksldi8uQ/M5mLHvuzsp9ClyysyloqQ8KPMESGEELAsi/LyrwWBETfq5/z5pfIVSoVYFqirk+cfywZWVrvdjnnz5iE3NxdRUVHo378/vv/+e79e+8svv6B79+6IiorCFVdcgePHj7c65o8//sDw4cMRFRWF7OxsPProo6irq3N7vk6dOgEArr/+euj1evTr1w8AcOTIEVx77bVIS0tDbGwsLrnkEvz++++BVTQIFBwRQgjB4cOP4dChaQCAlJSbcOml+wAAdXU7sGnTRTCbz8lZPNWorwdiY6X9Fx+vQ1ZWIuLjdS776+sDK+u8efPwr3/9Cx9//DH27NmDGTNm4I477sDq1au9vu7UqVO44YYbMHHiRBQVFeHPf/4znn76aZdjjhw5gnHjxuHGG2/Ezp07sWjRIvzxxx+YPn2623Nu3rwZALBw4UKcOXMGK1asAADU1tZiwoQJWL58ObZv345x48Zh4sSJOHnyZGCVDRA1qxFCCEFNzSbHdnr6FERGdkZkZGc0Nh5Fff0eVFWtRUrK9TKWkIipqakJL7/8Mn7//Xfk5eUBADp37ow//vgDn3zyCUaOHOnxtR999BG6dOmCN998EwDQo0cP7Nq1C6+++qrjmHnz5mHy5Ml47LHHAADdunXDe++9h5EjR+Kjjz5CZGSkyzlTUlIAONdGq66uBgD0798f/fv3dxz30ksv4YcffsCPP/7oMdASAwVHhBBCYLM1AAD69fsNycn5AIBLLtmDLVv6oqHhMKzWC3IWTzWio4HaWmmvYbfbUV1djfj4eJflNQKZqPvw4cOor6/HVVdd5bLfbDZj4MCBXl+7b98+DBkyxGUfH2DxduzYgZ07d+Krr75y7GNZFna7HceOHUOvXr38KmdtbS1eeOEF/PzzzygpKYHVakVDQwNljgghhEjPbufaZHS6KMc+vT4ScXFDKDgKAMMAMTHSXsNuB2w27jrBLq1W2xzB/fzzz+jQoYPLcyaTKdQiora2Fg888AAeffTRVs917NjR7/PMmjULBQUFeOONN9C1a1dERUXhpptugtlsDrmM3lBwRAhRlYMHH0ZJyT9hNLZHv35LERvbV+4iaYLdzmWO9HrX9IPRmAQAKCv7BhkZf4bBkBD2shHx9e7dGyaTCSdPnvTahOZOr1698OOPP7rs27Bhg8vjQYMGYe/evejatavf5zUajbDZbC771q1bhylTpuD667km3draWredv8WmmA7Za9aswcSJE5GZmel2roMpU6aAYRiXf+PGjXM55vz585g8eTLi4+ORmJiIqVOnOqJj3s6dOzF8+HBERkYiOzsbr732mtRVI4SIqLz8W7CsGWZzMSorV8hdHM2w2VpnjgDAYOBWm6+t3Yrdu6nPkVbExcVh1qxZmDFjBr744gscOXIE27Ztw/vvv48vvvjC62sffPBBHDp0CE888QQOHDiAr7/+Gp9//rnLMU899RTWr1+P6dOno6ioCIcOHcL//vc/r/2EOnXqhOXLl6O0tNQxmWS3bt3w3//+F0VFRdixYwduv/122O32UKvvk2KCo7q6OvTv3x/z58/3eMy4ceNQUlLi+PfNN9+4PD958mTs2bMHBQUFWLJkCdasWYP777/f8Xx1dTXy8/ORk5ODrVu34vXXX8cLL7yATz/9VLJ6EULEZbebBdtNMpZEW/jMkU7nmjlKS5sEvT4OANDQcCTs5SLSeemll/D8889j3rx56NWrF8aNG4eff/4Zubm5Xl/XsWNH/Oc//8HixYvRv39/fPzxx3j55ZddjunXrx9Wr16NgwcPYvjw4Rg4cCBmz56NzMxMj+d98803UVBQgJycHIwYMQIA8NZbbyEpKQnDhg3DxIkTMXbsWAwaNCj0yvugmGa18ePHY/z48V6PMZlMSE9Pd/vcvn37sHTpUmzevBkXX3wxAOD999/HhAkT8MYbbyAzMxNfffUVzGYzFixYgIiICPTp0wdFRUV46623XIIoQohysazFsU3BkTi4jrJ8s5pr5ig6ugcGDlyHLVv6wW5vlKN4RCIMw+Avf/kL/vKXvwT82j/96U/405/+5LLvnnvucXl8ySWXYNmyZR7P0bJ5bOLEiZg4caKjwznAZZP4Yf28adOmBVzeQCkmOPLHqlWrkJqaiqSkJIwePRp/+9vf0K4dl/ItLCxEYmKiIzACgDFjxkCn02Hjxo24/vrrUVhYiBEjRiAiIsJxzNixY/Hqq6/iwoULSEpKanXNpqYmNDU5v4D5D8xiscBisbQ6PhT8+cQ+r1JovX6A9usod/1YlgXLOjNHVmudqGWRu37h0LKONlsDjh2b4XjeZjO2qr/drm/+v1Hx7004P0OLxeIYgRWOph4e2zzbI39trQmlfna7HSzLwmKxQK/XuzwXyM+EaoKjcePG4YYbbkBubi6OHDmCZ599FuPHj0dhYSH0ej1KS0uRmprq8hqDwYDk5GSUlpYCAEpLS1ulC9PS0hzPuQuO5s2bh7lz57bav2zZMkQHMm4yAAUFBZKcVym0Xj9A+3WUr342JAj6Ax85sh979vwi+lW0/vkBzjoaDJsRE7MAAMCyMVi2bBUA15sKw5xFfDxgtdbjl1/Ef7+lEI7P0GAwID09HbW1tZKPnnKnpqZGkvPOmDED3333ndvnbr75Zrz99tuSXLelYOpnNpvR0NCANWvWwGq1ujxXH8AsmaoJjm677TbHdt++fdGvXz906dIFq1atwpVXXinZdZ955hnMnDnT8bi6uhrZ2dnIz89HfHy8qNeyWCwoKCjAVVddBaPRKOq5lUDr9QO0X0e562ez1UM4KCYnJxNdukwQ7fxy1y8cWtbx7NlaHDzIPTdw4CrExPR385qz2LQJYBgrxo8fB4ZRTHfVVsL5GTY2NuLUqVOIjY1tNamhlFiWRU1NDeLi4sAwjOjnnzdvHp555hm3z8XHx4t+72splPo1NjYiKioKI0aMaPWZ8C0//lBNcNRS586d0b59exw+fBhXXnkl0tPTUV5e7nKM1WrF+fPnHf2U0tPTUVZW5nIM/9hTXyaTyeR2zgej0SjZL56U51YCrdcP0H4d5apf6+9JsyTl0PrnBzjrqNNxTRhJSVchMfFit8cyTJxjW6+3Q68PfR4cqYXjM7TZbGAYBjqdzmUyRqnxTU38tcWWnp7u8Z4YDqHUT6fTgWEYt59/ID8Pyg3/fTh9+jQqKiqQkZEBgJuds7KyElu3bnUcs2LFCtjtdsdMnnl5eVizZo1Lu2NBQQF69OjhtkmNEKIswpFqAMCy1CE7VHwHd4bxfOPQ6Zx/gVOnbNIWKCY4qq2tRVFREYqKigAAx44dQ1FREU6ePIna2lo88cQT2LBhA44fP47ly5fj2muvRdeuXTF27FgAcAxDvO+++7Bp0yasW7cO06dPx2233eYYOnj77bcjIiICU6dOxZ49e7Bo0SK8++67Ls1mhBDlEo5UA+hGLQZ/giOGMYC/XdAIQdIWKCY42rJlCwYOHOhY02XmzJmOeRH0ej127tyJa665Bt27d8fUqVMxePBgrF271qXJ66uvvkLPnj1x5ZVXYsKECbj88std5jBKSEjAsmXLcOzYMQwePBiPP/44Zs+eTcP4CVGJlpmjs2e/R13dXplKow18cKTTeQuOGEf2qLZ2W1jKRYicFNPnaNSoUY7he+789ttvPs+RnJyMr7/+2usx/fr1w9q1awMuHyFEfi0zRwCwY8eVGDasRIbSaAPLciN6uOyQZzpdFOz2euzadTX69v0Z7dqJ1xGeEKVRTOaIEEJ84ec4YpgItG9/HQDAbC6VsUTqZ7f7blYDgOzsWY7t+vqDkpaJELlRcEQIUQ3+Rm40tkP37s4mc5bV3kR44eJPnyMAyMl5Gmlpd7u8hrQ9x48fB8Mwjv7BWkXBESFEFViWRW3tdgDcjZxh9ILnbJ5eRnzwNzgCnP2ShLOUE6JFFBwRQlShvPxbHDhwLwBAp4ug4Egk/nTI5jEMt/QSn8EjJBhyzCYeKAqOCCGqUF9/wLHdocNf4LrEBQVHwfK3QzZ3DGWOfGFZFjZbnSz/vA1qaun7779H3759ERUVhXbt2mHMmDGoq6uD3W7Hiy++iKysLJhMJgwYMABLly71eB6bzYapU6ciNzcXUVFR6NGjB959912XY6ZMmYLrrrsOf//735GZmYkePXoE/f6Gi2JGqxFCiHdcAJSZOQ1ZWdNhszU4nqHMUfD87ZANcBk7gPoceWO312Pt2lhZrj18eC30+hifx5WUlGDSpEl47bXXcP3116OmpgZr164Fy7J499138eabb+KTTz7BwIEDsWDBAlxzzTXYs2cPunXr1upcdrsdWVlZ+O6779CuXTusX78e999/PzIyMnDLLbc4jlu+fDni4+NVs24hBUeEEFXgAyC+OY2a1cQRSJ8j/piW800RdSkpKYHVasUNN9yAnJwcANyapQDwxhtv4KmnnnKsZ/rqq69i5cqVeOeddzB//vxW5zIajS6Ls+fm5qKwsBD//ve/XYKjmJgY/OMf/0BERISUVRMNBUeEEFXgR6RRcCSuwDpkU+bIF50uGsOH10p6DbvdjurqasTHx7usPabTRfv1+v79++PKK69E3759MXbsWOTn5+Omm26CXq9HcXExLrvsMpfjL7vsMuzYscPj+ebPn48FCxbg5MmTaGhogNlsxoABA1yO6du3r2oCI4D6HBFCVIMPgHQt/hc+RwLFL8HiX4dsyhz5wjAM9PoYWf75u4K9Xq9HQUEBfv31V/Tu3Rvvv/8+evTogWPHjgVc32+//RazZs3C1KlTsWzZMhQVFeGee+5p1ek6JsZ3c5+SUHBECFGF1s1qDPivMMocBefgwYdQWroQgL8dsvnMEQVHascwDC677DLMnTsX27dvR0REBJYvX47MzEysW7fO5dh169ahd+/ebs+zbt06DBs2DA8//DAGDhyIrl274siRI+GogqSoWY0QogotgyN+m2XtFBwF6dy5Hx3b8fF5Po93znNEzWpqtnHjRixfvhz5+flITU3Fxo0bcfbsWfTq1QtPPPEE5syZgy5dumDAgAFYuHAhioqK8NVXX7k9V7du3fCvf/0Lv/32G3Jzc/Hll19i8+bNyM3NDXOtxEXBESFEFTwHRxYKjoLED+MfNGgT4uMv8Xm8c54jyhypWXx8PNasWYN33nkH1dXVyMnJwZtvvonx48dj7NixqKqqwuOPP47y8nL07t0bP/74o9uRagDwwAMPYPv27bj11lvBMAwmTZqEhx9+GL/++muYayUuCo4IISrBLxEinN9I3+I5Egg+ONLr4/w63jnPEWWO1KxXr14e5y7S6XSYM2cO5syZ4/b5Tp06ucynZDKZsHDhQixcuNDluHnz5jm2P//889ALHWbU54gQogqeMkfC50hgApkAEnCOVquo+AknTvxdsnIRIjcKjgghqkDBkficw/j9C44iI539SI4dc59ZIEQLKDgihKhEy6H8wkCJgqNgBJo5Ski4HP36LWt+ZKOglGgWBUeEEFVwlzni+xzRTTo4fHDkzxxHADf8Oz5+qOMxdczmBLKmGZGWWJ8FBUeEEFWgZjVxcTOOczcSfzNH3LHOQKqtd8w2Grn3or6+XuaSEB7/WfCfTbBotBohRCVclw8RblNwFDg+awQEFhwJs0xtPTjS6/VITExEeXk5ACA6OtrvWapDYbfbYTab0djY6LJ8iFYEUz+WZVFfX4/y8nIkJiZCr9f7fpEXFBwRQlTBGQC1Do6oz1HghIFNYJkjPQAGAAu7vW0HRwCQnp4OAI4AKRxYlkVDQwOioqLCEoyFWyj1S0xMdHwmoaDgiBCiCtTnSFzBZo64441gWXObzxwBXD+sjIwMpKamwmIJz/thsViwZs0ajBgxIuTmIyUKtn5GozHkjBGPgiNCiCpQnyNxuQZHgd1gKThqTa/Xi3Zj9udaVqsVkZGRmgyOlFA/7TVWEkI0yvNQfgqOAucMjhgwTGC3AlpjjWgdBUeEEFXwljmiPkeBC3SOIyFaY41oHQVHhBBV4IaeU58jsQQ6O7YQrbFGtI6CI0KISnjOHO3ffy8aGo7LUSjVCiVzRM1qROsoOCKEqIK7ofwREWkAALP5DEpKPpWhVOrlDI4C7/DKv4aG8hOtouCIEKIK7vocde/+CfT6BACAzVYnS7nUiprVCPGMgiNCiCq4C44iI7ORlfWoy/PEN73+IIqKBgMILTiqqdlC64oRTaLgiBCiEvbm/12/tmjEWuD0+t2O7cTEUQG/XqczAQCOHn0SxcUfilUsQhSDgiNCiCq4nyEboBFrgWMYrr9RSspN6NXr/wJ+fWbmQ47t+voDopWLEKWg4IgQonj79k1BTc0mAK2DI75ZiIKjQHDBkdGYFtTaXBkZU9Cp0wsAqN8R0SYKjgghima1VqGs7AvH46io7i7PO2fJtoL4iwskdbqIoM/gnAiSgiOiPbS2GiFE0YQ336FDTyEyMsvleVpCJHAMw49UCyU44kes0SzZRHsoc0QIUThn0GMydWj1LHXIDgaXZeMncwwGTQRJtIyCI0KIojmby/Qe+sdQ5ihwfOd2MZrVKHNEtIeCI0KIojlHqbnvBUAdsltjWRZ2uxkWS6VjTTohfrRaaH2OKHNEtIv6HBFCFM25zEXLIfxw2d/WO2RbLBU4duw51NRsQW1tkeP9iIm5CIMHb2vRhBb80iE8alYjWkbBESFE0XxnjqhZbc+em3H27Pdun6ur243t2y9Hr15fIjqaH+nHB0fUrEaIO9SsRghRNH8zR221Q7bVWusSGKWl3YWBA9fhsssuIDn5agBATc0mnDz5quMYalYjxDvKHBFCFI36HHlmt1tRVvYvx+PLL6+GwRDneNy9+8fYvXsiamuL0NR0RvBKMZrVuMCKgiOiRZQ5IoTIorp6C06ffg/l5f/2unipM3Pk6W+5ttvn6MyZ93Do0DQAQExMX5fACAAiI7OQm/syAKC+fq9gzijxMkfUrEa0iDJHhJCwY1kbduwYA5utCgDQo0ct0tPv8TBU39OaanDZ3xYzRw0NRx3bOTnPuT0mIiINANDUdAobNnRCXFwejMYdAMSaBJIyR0R7KHNECAk7m63BERgBwIEDU7F3761uj/WVOWrLwZHd3gAAyM19Gampt7g9Jjq6N2JiLgIAmM3FqKj4j+C5nkFfm8861dXtQm3tzqDPQ4gSUXBECAk7lm1qta+q6g8Px/JBD3XIbslubwQA6HSRHo/R6yNx8cU7ERs70GX/JZecQGxs36CvrdNFO7a3br0UFktl0OciRGkoOCKEhJ3dzgdHelx66f7mfQ1uj/WdOWrLHbK590yni/J6HMMwMBrbC16XhIiIjJCuHRc3EJmZDwPggl2L5VxI5yNESSg4IoSIoqmpBI2NJ7x2rubxwZFOF+HIevBZkJaco9XcZ47acodsfzJHPIMh2bHNsnFejvQPw+jRvft8GAztms9JfY+IdlCHbEJISKqrt+Do0SdRWbkSAJCR8Wf06PGZ19fwK7nrdCaX4Ihl2VadsqnPkWd85kiv9545AgCTKUvwuvZejgyMc0g/jVoj2kHBESEkaBZLBbZvH+aSNSgp+QcyMh5AXNxgD6PPnJkjhjG5NAmxrBkMY3I5lmbI9iyQzFHHjk/CaEyC1dqAvXszRSsDzZRNtIia1QghQWtsPOkIjNLTpzj2b9t2Caqq1np8nbNZzeRyY7fZWvc78j1DNh80qTs4YlkWBw7cj02b+mDnzqths9X7fA3/fvnqcwQAERGpyMn5Kzp2nAO7vUPI5eVR5ohoEQVHhJCgWSwVALjFTXv2XIhOnV50PFdff9Dj64TBETdfDtO8312/I/8yR/X1+3HgwH2t+jxZLBXYt+9ObNt2Gdavz8TGjT1QXb3Rr/qFk9lcgpKSz1Bfvxfnz/+Cyso1Ho9lWRZ79tyMujpuviJ/MkdSocwR0SIKjgghQWFZG86fXwoAjk65nTo9j9TUyQAAm63ay2uFwRHjtVO2r8yRydQR/FdZSck/0NR0yuX5c+f+h7Ky/0N19XqYzSVoaDiIc+f+5281w8ZqrXR5bLGUeTy2qemkYz01holAVFRXKYvmFWWOiBZRcEQICcqRI0/g9Ok3AcBlmLjBEA8AsFqr3L4OEPY54m6sfLPQ2bOLBEtccHz1OYqMzMallx4QnNs1wLLZah3bcXFDmo9R3o285ftVXPwpLJYLbo8Vvkd5eSdhMonXhyhQlDkiWkTBESEkKHV1exzbGRl/dmwbDAkAPGeOamt3Y9euPwHgMkcAoNdzQ8uPHn0a5eXfOo5lWRb19fuaH3kayg9ER3eF0ZgCoPVNmh/RlZ4+BcnJVzWfV3k38pbBUXX1euzbd7vbY/lsmsGQ7FgeRC6UOSJaRMERISQoNlsdAKBPn/+gXbtxjv16PZc5On36HZSXf9fqdSUlnwDg+gWZTNkAgC5dXnU839R00rF96tQbOH78BQDeFp5F8/Pub9LOTsuRgixH6xm65dTUVIrjx2cDACIi0h2ZtMbGE26P970Yb/hQ5ohoEQVHhJCg8M1Ven2My/7IyE6O7cOH/+LmddworJiYvuje/SMAQGrqrejQ4ZHm550j1mprixzbaWl3eC0Pn8FonTnih7tHKTbLcfz4HNTUbAYAJCQMR//+vwPwPLGikoIjpb6nhISCgiNCVKap6QwqK9eiqemMrOWw27nMkU7nGhylpNyE3NyXAQA2W02r1/E39rS0O2E0Omdt5tfqstudQ9j5wKZbtw+Rnu4rODI1n999s5pOF6XYLIfZXAKAy2516jTHseK9p3LyQZMSgiOlvqeEhIKCI0JUxGw+i40bu6GoaAQ2bOgCs7lctrLwzWp6fazLfp3OiPT0uwB4Gn3G39iNLvv5WZ6Fa6w5h/z7Hqru6SYtDI6UmuXgs3A9e36OmJg+jvdGTZmjgwfvR0nJQplLQ4g4KDgiREXOn//FcbNn2SbU1x/w8QppWCwVjmxHy2Y1wBnMsKwVdrvrmmf8DV+nM7Z4DZc5Ek5+GMgM0J4CH2dwFOmYfVtpfY6cTZRcoOmpiZDnDI6Mbp8Pp/j4oY7tc+f+K2NJCBEPBUeEqMTRo3/F/v1TXPbJsRI6w5zF5s2dHI/dB0fCJUFcAxF+GHrLGzv/GtfMER8cuS4p4r5crQOKqqp1KCv7v+ZyRvkMOsRitVahrm4/rNbWzYru8MER30SppsxRdvZMdOnyBgDlBZ2EBIuCI0JUorq6sNW+c+f+G/Ybkl5/yhHwtG9/HSIiMlodIwxmWjateeovo9eLlTlyvh+7d9/g2DYYkj2OaBOT2VyGwsJsbN7cCxs2dPI63xOvZeZITcER4Bx1SMER0QoKjghRCT5Q6NPnB6Sn3wsAKCv7Pxw48ECYS8IFFvHxebjooh/cLi7LMHpBp+KWwZH7JiE+c3T+/M/Yu/cOl9cG0+eIZW2wWLg+WR06TEf79tdKnjmqqPgZ69enOzqiW63nUVe32+PxLGvDoUOPOGb1DrxZTRnBkafO8ISoFQVHhKiEcD2yjIypjv0NDYfCWg6GMTeXw/tip56WBPHUITs2tr9ju7z8K1itNSH1ORJmoDp3fhV6fbTkmaMTJ15ute/gwYc9zldUU7MVZ858AIAL7iIi0pu3+ffG1mqtOEB5wZFS+3IREiwKjghRCWGgkJAwDH37/uKyP3wCC46E8xYBnjtkx8T0xmWXOftQWSxnBWuw+ZM54m7QBw78GRcurBIsG8I4ysoHUDU1m7F37+1uA49Q8J3UO3Z81rHGXF3dThw+/Ljb461W5yzigwZtgNGY6FJOwH3TmtKCIz5zRMER0QoKjghRCWHmiPvf82KtUuIzR/zQe0/48u3YMRoNDUcc+50dslvf2I3Gds0LyQIbN3ZBU9Npl3N5ExmZ49g+ffodl348fNNfdHQPx3XLy79xNLuJoaHhOBobjwEA0tPvQW7uizCZuDKZzcVuX8PP6RQfPxRxcQMd+4VZNXdNaxQcESItCo4IUQnhSvbc//IER87MkfeAJTKyMwAuA1Revsix31OzGo9fI835OM0l8PEkN/dvjlm0bbYqt/MwRUbmYOjQU4KyuE4zEKza2h3YuDHX8TgiIg1RUZ3Rs+cCAJ4X4eWb/lpm4YTvjfvMkXImgQSEfY4oOCLaQMERISrRsv+NfJkjPkjznjm66KIfHJkTYf8fX3P0pKTcBIDr0J2b+zKGDj3mdrqAlvT6KKSk3AoAqKpaj61bBzXvd52k0mRKdzTBsazN53n9IVyENzNzGgyGuOZrc+vMeQqO+MwRP8cTTxj0qKFZTalr1hESLAqOCFEJ/sbD39id8wKFOzg673J9T4zGpOZAxzWj4CtzlJPzNEaNsmLkSDNycp7x2XwnxAclXIdrrj9RVFR3N3UwNB8nTuaIz1K1azcR3bt/IChPQvPz1R5exwVH/DQGzvIxjvenvHxRqyCOL3fLfltycTar0Wg1og0UHBGiEkrIHB05Mh0m02/N1/cdtLi7aUrZJNQyS5ScPA59+ixqdRzD6JvLIm5w1DLDZTDENz9fg8LCjjCby1ye95Q54s7F1eXw4UdRUfGzy3NKyxzxn7PNVuVxZB4haqKY4GjNmjWYOHEiMjMzwTAMFi9e7PI8y7KYPXs2MjIyEBUVhTFjxuDQIdchzOfPn8fkyZMRHx+PxMRETJ06FbW1tS7H7Ny5E8OHD0dkZCSys7Px2muvSV01QkLCsiwuXFglGOXVus+R2KOuPKmqWu3YTk7O93m8u466fIdsKbIeen2cy+PU1NvdNsk5M0fiNKt5WoTXaGyPmJiLAABNTadQXb3B8VxV1XocPfpUc7lbB0fdur3v2DabSx3bFksFios/BqCk4MgZKG/YkIuGhqMyloaQ0CkmOKqrq0P//v0xf/58t8+/9tpreO+99/Dxxx9j48aNiImJwdixY9HY6PyrefLkydizZw8KCgqwZMkSrFmzBvfff7/j+erqauTn5yMnJwdbt27F66+/jhdeeAGffvqp5PUjJFi1tduwY8cVjsfOYel8h2g7zp37b1gCJD4D1LfvGiQljfZ5vLCjLsvasGfPzWhq4jILUqwLxjdj8dzN3s1dW5pmtZaBGMPoMXjwdkRH93Y5DgCOHHnSaznT0iajffsbW5Xz6NGnUVu7HYD7jJMcjMYUpKfzc2+xaGg4LGt5CAmVMv7sADB+/HiMHz/e7XMsy+Kdd97Bc889h2uvvRYA8K9//QtpaWlYvHgxbrvtNuzbtw9Lly7F5s2bcfHFFwMA3n//fUyYMAFvvPEGMjMz8dVXX8FsNmPBggWIiIhAnz59UFRUhLfeessliCJESfjh7ACQmzsPBgPX3ML1xdEDsGHPnpswYMBaJCZeLmlZWo6Y80XYUbe+/gDOnv2+eb/JMWRfTBERaejY8a+orl6HyMhcJCaO8FAusZvV+L5D7taZMyAqqivq6/cK5l4CrNYKAEBKyq3IynrUQzlbZ7iEWaTs7JmhF14EDMOgZ89/oK5uJ2pqNlPfI6J6igmOvDl27BhKS0sxZswYx76EhAQMGTIEhYWFuO2221BYWIjExERHYAQAY8aMgU6nw8aNG3H99dejsLAQI0aMQESEc4K1sWPH4tVXX8WFCxeQlJTU6tpNTU1oanI2CVRXcx0rLRYLLBb36x4Fiz+f2OdVCq3XD5CmjhYLPxfOcGRmPi44tw6dO7+Lo0enAwAaGk4jJkba95a/6dlsOr/qyLKG5uMbYDY7F2EdPPgAGCZBkp+F7Ow5jm2bDbDZ3F2DK5fF0uhShmA+v5Mn/4YzZ95tfhTp9rUMw2V4zOZqx/P8orSZmTPBstFuX8eyTPOxTY7n+fp06/YPmEy9A34Ppfw95INhi6VOtt9z+p5RP6nqF8j5VBEclZZyfymlpaW57E9LS3M8V1paitTUVJfnDQYDkpOTXY7Jzc1tdQ7+OXfB0bx58zB37txW+5ctW4boaGlS2gUFBZKcVym0Xj9A3DoajZsRHQ1UVFTjl19+afFsFmJi+sFg2Int2zfBYvF/ZFcw4uPrwDBAYeEW2O1nfB5vNB5AdDRQWnoaJ06sRGwsYLNlYPnyIgBFkpbVm7g4M3Q6YP36tbDZWk8EGcjnFxf3AXTNHRT27TNj166WnxEQFVWBiAhg//5t2LGDez4+/gIYBvjjjy2w20vcnjsqqgwREcC+fbsdr4uOLoXRCOzYsQcWS+tr+UuK38OYmGoYDGj+WfQ9caeU6HtG/cSuX319ve+DmqkiOJLTM888g5kznanr6upqZGdnIz8/H/Hx8aJey2KxoKCgAFdddRWMRmUM0RWT1usHSFPHsrJzOHwYSE3NQO/eE1o9v2fPR6is3In+/fsgNbX182Jav94GlgUuv3w0YmNzfR5fXn4Bhw4B7dsnICtrAPbsAeLi2mHECGnL6cvWrXFobCxDXt6liI+/zLE/mM9v40YWVivQu/cSJCW576R+7NhKFBcXICcnBl27TgDLsli/nusvOXr0nzz2jTp0aDHKy4GePbshK4t7z3bvfgdVVcCAAYORkhL4+yjl7+HevR/jwoVd6NevN9LS5PmM6XtG/aSqH9/y4w9VBEfp6dxijGVlZcjIcH6JlJWVYcCAAY5jystd/wK0Wq04f/684/Xp6ekoK3MdSss/5o9pyWQywWRq3b/CaDRK9kMp5bmVQOv1A8Sto05na/7f5Pacej3XlMEwrKTvK8uyjgVbIyJi/LqW0cj1wbFay12WHZH789fpDM3/w21ZAvn8+JF4cXF9PL7GaORG0ZWV/QMMY0PHjk8BsAMATKYkGAzuX6fXc/tdP1tb8zkjQ3ofpfg9dI6ktMn+GdP3jPqJXb9AzqWY0Wre5ObmIj09HcuXL3fsq66uxsaNG5GXlwcAyMvLQ2VlJbZu3eo4ZsWKFbDb7RgyZIjjmDVr1ri0OxYUFKBHjx5um9QIUQLnEP4It8/zo77czaQsbjmcnWz97ZDNH1dXtwu7d1/bvE/apj9/OIfAhzaUn2XZVvNPuZOU5OwvWVq6EJs29XQ89jb7t7tRdUqb40iI1lgjWqGY4Ki2thZFRUUoKioCwHXCLioqwsmTJ8EwDB577DH87W9/w48//ohdu3bhrrvuQmZmJq677joAQK9evTBu3Djcd9992LRpE9atW4fp06fjtttuQ2ZmJgDg9ttvR0REBKZOnYo9e/Zg0aJFePfdd12azQhRGr4TtKeh7+EKjoQ3PL7jrS9xcZfAaHTtK+jPIrJSE2soP/d6LgPkrV6JiSNd1nTjdejwFzCM569hd0Gcs8z6QIsrOefUDTRajaibYv702LJlC664wjmXCx+w3H333fj888/x5JNPoq6uDvfffz8qKytx+eWXY+nSpYiMdH4hffXVV5g+fTquvPJK6HQ63HjjjXjvvfcczyckJGDZsmWYNm0aBg8ejPbt22P27Nk0jJ8omq/MET+ZovTBUeCZI5MpA8OGFeOPP5IcS2goITjiA4tQgyPh7OS+6hUR4RokZmfPQpcur3t9jbspB5ScOaI11ohWKOa3a9SoUV4nsWMYBi+++CJefPFFj8ckJyfj66+/9nqdfv36Ye3atUGXk5Bw8zdzxM88LQWWtaG8/Nvmbb3XbEdLDKODydQB9fV8cKScZjVxgyPvAaNOZ0RERAbMZm5kWmRkF5/ndzfPEb+txOCImtWIVijvt4sQ4oJvovDUlMXvl7Ipo6JiCQ4ffqT5UeCZH6MxBcA+AAhoIVmpiLV8CB8cMYwJDMP4PL5Xry9x7txiGAztkJZ2RwDlVEfmiM9uWq1VMpeEkNAo77eLEOLC2azmPnMUjma1pqZix3ZDw30Bvz4z8yGYzaVgGINfQYHUxM4c+dtUmJR0JZKSrgzgCmprVuMyR2fOvAuG0aNr1zdlLhEhwVFMh2xCiHvOZjXvo9WkbFbjm0nat78VFsuogF+flnYbhgw5gEsv3RNgcCANMZYPaWoqxd69twHwvw9WoNw3qyk3OEpMHOXYPn9+qXwFISREFBwRonB8YCLnUH6+yc5TGdRGjGa18vJvUVu7DQBgMmWJUq6WvDerKW+0Wrt249C//woANGKNqBsFR4Qo2OHDM1BcPB+AvEP5fWWv1IYPOi5c+D3ojJvdXufY7tPnP6KUqyX3o9WU2yEbAPR6bsJLWnyWqBkFR4Qo2Llz/3Nsx8fnuT0mHH2OWJbPXknTfBRufAasrOxfOHbsuaDOwd/8MzMfQlRUJ7GK5kJtzWqA872lzBFRMwqOCFEw/gY8YMBaJCdf5fYYPnNUXPwxTp16R9JyaCVzlJn5kGO7sfFYUOfgg1Ep3xO1jVYDaK4jog0UHBGiYPxf3wZDosdjoqK6O7ZPn35b0nJ4atpTm+TkfHTr9hGA4Dtl8wGjp1GEYlDbJJCAM3NEzWpEzSg4IkTBnDdgz9mJlJQb0bPnlwCka1rzpxxqE+pw/nBmjtwtH6LEDtlAeObdIkRqFBwRomD+3IAZhkFc3ECX48XGN5Hw89hoQejBkfTZNL6MZ89+jwsX+IW3ld0h29nnyOJ11QNClIyCI0IUzDmE3vsNWKxJDX2XQzuZo1A7svOj3KR8T4TNqXv3TsKFC8sFs3IrMzgSBvJSr/dHiFQoOCJEoViWFTSheL8BO4fzSxMcaa1DNqCOzFG7dtcgK+txAIDFchY7doxxPKeMBXxbEwaL1CmbqBUFR4QolPCvbl/ZCf5GL8Us2RUVv+Ds2UXN16HgiOdc1kW690Svj0ROzrOt9nfu/AqMxmTJrhsK4XQP1O+IqBUFR4QolHC0j+/MkXTNavv23eXYNhrbiX5+uYT6noUrm9YyQxQfPwwdOz4l6TVDwXUU524tNGKNqBUFR4QolPCvbl9NN87nbaJ3grVaKwEAOTnPITl5oqjnllOoa9I5O8tLO71By4k3dbooSa8nBj6bVliYifr6AzKXhpDAUXBEiEI5/+pmfA7bFnbOFTN7xM3MzI2Oysp6TFMdssXKHEn9njCM3iUA0+uVHxzFxw9zbFdWrpaxJIQEh4IjQhRKOIyfYRivx0oVHAk71GppGD8QWnBkt1vR0HC4+TzST4wpzB6pIXPUv38B4uOHAqCmNaJOyhwLSgjxexg/0DI4sgAQ5wYqDI50ugjYgl/EXnGCDY5YlsXWrRejsfFI83nCERxFwmarbd6WNjjavx/49VegqQmwWIC8PGDMGN+vE2IYHaKiuqK6eoNjXT5C1ISCI0IUqLZ2B7ZsGQDAvw6/whu0dJkjIwBppgqQQ7DTH9jtTair2wEAMBpTkZBwmehla0nYKVvq4OjGG4G9e52PTSagogKIiQnsPM411ihzRNSHmtUIUaALF1Y6thMSLvd5vLBPkrh9jpwzY/tq2lMbZ+YosA7Zwvd36NBjMJkyRC2XO67BkTTzG9XVAS++6AyM7rqLC4iamoAPPwTMAcY4zjXWKHNE1IeCI0IUiA9KkpLG4qKLFvs8ngtc+EVKxZvriL+xtRwxpQXBN6s5jw/XLNV6fZxj22CIl+Qa33wDzJnDbWdkAF98AfTtyz1+8kng5ZcDOx/fR43mOiJqRMERIQrEByWRkTl+Z2ycy2GI36ymzeAouPdLjuCoU6cX0a7dn5CaehvS06dIco3ycuf2N99w/z/3nHPfgQBH5FPmiKgZ9TkiRIGcw8T9D0qkmAjSuUSGdobw80LPHDFgmPD8fdm+/Z/Qvv2fJL1GQwP3//TpwMiR3PbVVwOffw5MmQKcPx/Y+fifXcocETWi4IgQCbGsHTU1W2G1VoFlLdDr45CQcJnPbBDfrBZMcCTmEiJKzBw1NAC//QZYrcBVVwEJCcGdh3+/rNbzqKnZjri4gX69zrnenba+Puvruf+jWvT3Tm5epeTChcDO5+yQTZkjoj7a+u0mRCGamk7i3LnVOHHiJTQ2Hnd5zmhMQ07Oc8jKmu7x9fwNJZCMDd9M1NBwADExPQMvdAs1NUXYvp0biaWk4Ojll4G//Y3bvuMO4MsvgzuPsGPz1q2DMWTIURgMHfx4JTefgdaCIz5zFB3tuj8pift/82bgpZe4pjZ/WnqdzWqUOSLqQ32OCBGZybQIW7Z0xYEDUx2BEcMYHTdji6UMR47MAsvaPZ4jmIwNHxzt3n0dzp37KcjSO/GLzQJAVFT3kM8nllOnnNsnTwZ/HpOpg2PFe4BFU5N/J9N65qhlcJST4wyGZs8GDh3y73zUIZuoGQVHhIiIZVkYDNscj9u1+xO6dn0HI0Y0YvjwevTt+0vzcU04f/5Xj+ugOSeA9D846tBhmmO7vn5/MMV3YbNxqYSEhOHo3fvbkM8nFuGQ8sbG4M/DMAy6dn0DMTH9AQB2u38n02pwxGeOWjarZWcDBQXOx9XV/p2PzxyVl3+DmpqtIpSQkPCh4IgQkVgsF7B1a3cYDNywnsGDt6Bv35+QlfUXMIwODMOgXbvxiIzsBADYtetPKC1d4PZcwTSr5eQ8i/T0qQDE+WudDxaSkq6CXi/N3DrBsAi6VDWJ0J2Fz+i15eCIZYHSUm67ZeYIAK68EujWjdv2NyA1GJydwXbtujbEEhISXhQcESKSmpotaGo6AQCIjOyK6Og+bo/r2PFpx3Zd3V63xwTbEZofzi9Gp2w+WJBq0sFgiZU54rX14IhlgdGjgTVruMctM0e8yOYfA3/f83btrkVq6mQAgMVS7uNoQpSFgiNCRGKxnAUA2GydMGjQLo/ZlszMB5Cb+7fmY1u3UbAsC5utBkDgwZFz7h4xgqOG5jIoKziizJG4bDZg1SpuW6cDhg51f1ygwZHBEIuuXd8CwP08empCJkSJtPHbTYjMWJZFbW0RAMBmy3RZzsMdvZ6b5dhqrWr13K5dE3HhAtfJg+/U6i9xgyNlZo6EwZG4mSP/Ii2tBUfC97OiAkhMdH9coMER4Brcs6xFk/NlEW3Sxm83ITI7ePAhlJR8AgBgWd8T7/BLQFitrpkjlrXh/PmfHY/j4i4OqBxtITgSNqtR5ih0wuDI5CUWDyY4EgZDdnuTo5M2IUpHzWqEiKCq6g/HttU6xOfxej0XQF248BvKyr5y7OdHiAHAZZddCHi+orbQ50i6zBEFR0aj5+P44CiQgFQYDNGQfqImFBwRIgKbjWse69evEFbrAJ/Hm0yZju19++6CxVIJALDb6x37g1lgtK1ljhobuQ7FoeCbfmpqtoBlbT6P13JwpPfSGhxc5kgPfkFkmgySqAkFR4SIgO875G9AExd3CXr04Ifx22G1VnJbgk7QwazbJUZwxLIsDhy4HzU1mxxlURLhzZxlgRtuAOrqgj+fTscNzzp79t84dOg+n8drLTiyNi8VZzR6n/maD46mTwe2bfN8XEu0AC1RIwqOCAkRy9odo8v45jJfGIZBRsY9MBrbAwDsdu7ubrNxmSP+hh0oMYIjs7kUJSWf8WdEVFTXoM8lBXOLBMTixcDq1cGfLyXlRsd2be0Wn8c7gyPvne7Vgg82vTWpAUBamnN79mz/z08L0BI1ouCIkBBYrTXYt+9Ox2PhxHf+0OliAAA2Wy0AYebIzUx8fp0v9D5HfFkAYMiQw4iKyg36XFLgb+bffOPc1zJgCkRi4nBcfHERAG4RWl+0ljnyNzh6+mlgxAhu299ZsgFagJaoEwVHhISgomIJysu/BsAtKBvovER6PR8cuWaO9Hr5Mkd8v6eIiAxERXUO+jxS4W/mXbsCl1/Obdt8dxXyymBo13zucvALy7pTXb0Zu3dfB0B7wZHBR3XatQMef9z1Nf7gm9Uoc0TUhIIjQkLA9xUCgAEDlgf8er0+FgAXHFks53HiBDc5ZLCZIzGCIz5QC7YMUnr3Xedis0ajswNxqMGR0djOsR0ffysaGg66Pa609HPHNr8MjNr5mzkSHhNIpo6fq4s6ZBM1oeCIkBDwTVBpaXciJsb9ciHe8JmjY8eew5Ejs3Dhwm8AAKMxOajyiBMc8dmrmKDPIYXDh4HHHnM+btdOvOBIr49CYuIVAACGsaK6utDtcXzTUELCCHTv/mloF1UIYYdsXyKaR+YHkznatWsi6usPB1g6QuRBwREhIeCzLHwGKFB8h+y6up0oLV3o2N+58+tBnY/vc3ThwgpYLBeCOgffOVyvV1bmqNbZFQr/+x+QlSVecAQA/fsvR2JifvP53Heq4fsbtWs3IeimT6WROnNkMmUDAKzWCpSVfRFg6QiRBwVHhITAGUgEl2Xp1OlFRESku+zr0WMh4uMDmxmbxzdhsKwZW7YMCGo9K34xXKU1q/EBUFYWcM013LaYwRHDMDCZsprPV+P2GGdnbD8iCZUIJDjiM0eBBEe9en0peF/rfRxNiDJQcERICJz9c4ILjmJieqJ373+77OOzScFISroCcXGXAACamk76Pesz78SJl3Hs2LMAlNesxgdAwokKxQyOuPPFN5/P03As7kJa6YwNBJc5CqRZLSIiFenpUwDQiDWiHhQcERKk6uqNKC7+CEBogUTLjr0mU4egz2U0tsPAgesdj/mpAfxVXb3JsZ2aelvQ5ZBCeIIjrnm0rm6X29mytTaMH5A+cwS4ZjQJUQPt/IYTEmZ79tzq2A4l2xMZmY0ePRaitnY7oqK6ITZ2QEjl0ukM4JZssAUcHPHNSb16fY20tEkhlUNsdjv3v07wJ51UmaPKygLs3DkB/fv/5vK81oKjujrgX//itn0N5QeCyxwBwlmyKTgi6qCN33BCZMDNiQOkpd2NlJSbQzpXRsYUAFNCLhNPr4+CzVbrspCtP/jRd8F2MJdSODJHSUlX4fhxbru6emOr57UWHL31lnMyzRg/kp/BZo6cs2RTsxpRB2pWIyQILMs6+vN07vwKDAZlBRP88iOB9jlyLoOirPoA4QmOoqP7oLqaWzrF3XunteCopMS57c+SIMFmjpyzZFPmiKgDBUeEBIGbR4gbCabEId3O4CjYzFGc6GUKVTiCIw4/V1RTq9F+WguO+DmOXnoJuOIK38cLM0eBDISkxWeJ2lBwREgQhEGH0latBwIPjljWhsOHH0dT0ykAbTdzBAAsG+HYbnkz11pw5O/SIbwI51uDsjL/r0MdsonaUHBESBCETS58k4GS8AGbv8FRdfUmnD79FgCuPi3nXlICPgCSskM2xzlsq2XTmtaCo0BmxwZcg6OMDODAAf9eRx2yidpQcERIEPibpk4XCYZhZC5Na3xT386d43D27A8+j+c7lwPAwIFrYTQmSlW0oIWvWc0AgPtM20pw5G/mKCYGmDzZ+XjfPv9eRx2yidpQcERIEPhRYHzzldIkJo5ybFdU/OTzeIvlPAAgOXk84uMvlapYIeGH8ksfHDGCzJv74AgwoLwcqhdocAQA//d/wIgR3La/HbP57Gpt7S6aJZuoAgVHhARBmDlSos6d5yE39+8AnIGPJ1ZrDcrLufHcBkNwC96GQ/gyR/AZHL36qgFpacDSpeJeN9wC7XPEC3SNNT5zZLfXYdOmHtS8RhSPgiNCAlRbuwtbtw4EoNzgCACioroD4Bb89Gbfvjtx4UIBAG6GbaUKZ3DEMNzn2tDguoo8HxwtX85FEy+/LO51wy3QPkc8vu+Rv5mjuLhLEBs7CADQ1HQaFsvZwC5ISJhRcERIgM6e/Y9jOzq6p4wl8c5o5LJAVVV/4MiRJz0uQltbux0A10SYkXFv2MoXKDkyR7t3T3Tps8UHRzZb2+xzxAt0viODIQ4XX7xVMIqSMkdE2Sg4IiRA/Aiw+Pg89OnzX5lL41lUVFfwHYtPnXoddXV7XJ5nWTvOnv0PmppOAgAuvfQgYmP7h7uYfnM3Wo3fFjs4Sku7x7FdW7vDsU3BESf4ZURoSD9RBwqOCAkQ3w8lMfEK6PXKbVaLjOyIQYMKHY9Pn34HVmuN43FFxRLs2XMTAIBhjIocvi8UzsxRdvbTyMp6DIDrCCutBkeBNquFPlM2jVojykbBESEBUnpnbKH4+CFISbkFAFBa+k9s334Z6usP4OzZ/2D37msdx3Xv/lHzgrXKFc7gCHBOXGi3czNlHz/+EhobjzdfT9nvlb9C7ZAdbOaImtWI0mnjN5yQMFJTcAQAWVmPobp6PZqaTqOubhc2bXLtJ9Wt20fIyJgqU+n8F76h/BznjbwJjY1Hcfw4v/gYg8rKFACBLaGhROFuVuMzR9SsRpSOMkeEBEhtwVFCQh6GDj2BlJRbERHRATodt/x6VFQ35Oa+jPT0u2QuoX/CnTniZ3VmWbNLc2T//stx9my2+BeUQajBkb9D+Xm0xhpRC8ocERIgtQVHAMAwOvTp8y0ANI9aY8Ew6vrbyFtwVC/BvIKuzWrczTwyshOSkvxYoVUlwjWUn0cdsolaqOvbkRAFUGNwJMQwjOoCI8D72mqffw5Mmybu9YTNanymgw+YtEKuZjXqc0SUTn3fkITIjL9RqjU4Uit3maPLL3du//KLuNdzDY4aXfZphXwdsqlZjSgbBUeEBODEib+jqmo1AAqOws1dcDRqFLBunevzYnF2Hm4SBMSuwZGaO2Rv2sTg0CFumzpkE+KKgiNC/GS1VuHYseccjyMjO8pYmrbHXXAEAFFRrs+LRTjs3FNwpFbV1UaMGuV8I6OjA3s9Hxx98AGwYoX/r+M7ZB8/PgdNTWcCuyghYUTBESF+stlqHdsDBqxR9GzSWuRuKL/wsVTBUWXlCtTWbm3ep41sYVWVCVYrN3v6rFnARRcF9vqUFOf29On+v85gSALArVl3/PgLgV2UkDDyOzg6duyYlOUgRPFsNm5IlF4fh8TE4ZJdZ/ly4PrrgeJiyS6hOk1NwMqV3LauxbcW3yQkdnCk18c6tk+efAWAdjpk22zcm5ieDrz+euv31Je77gL+/Gduu7ra/9d16jTHMZWExXIusIsSEkZ+/0p06dIFubm5uPfee/Hll1/i9OnTUpaLEMXh11TjF8+UypgxwOLFwIMPSnoZVXn4YeC337jtlsPO+cwRP/JKLImJI5GRcb/LPq00q1mt3Fd/oEP4eTExwKOPctuB9DuKju6Obt0+AECdsomy+d0Nb8WKFVi1ahVWrVqFb775BmazGZ07d8bo0aNxxRVX4IorrkBaWpqUZSVEVnxwpNcH2EEjSKdOheUyqnDkiHP7rhZzVkrZrNajxyeorFyNhoYDjn1Cau2QzTep8fMVBSPUuY4oOCJK5ndwNGrUKIwaNQoA0NjYiPXr1zuCpS+++AIWiwU9e/bEnj17vJ+IEJWy2cKTOSKt8Vmh//wHGDbM9TkpZ8kGgMjIHEdwpNfHSXORMOMzR6EER8HPkk3BEVG+oDpkR0ZGYvTo0Xjuuecwd+5cPProo4iNjcX+/fvFLp/DCy+80Dx5nfNfz57ONaIaGxsxbdo0tGvXDrGxsbjxxhtRVlbmco6TJ0/i6quvRnR0NFJTU/HEE0/AKnYunmiW3c71OaLgKPz4wMfdkHOpg6Pc3BeRlnYH0tOnICtrhjQXCbNQm9WErw1+lmwKjohyBTS7hdlsxoYNG7By5UqsWrUKGzduRHZ2NkaMGIEPPvgAI0eOlKqcAIA+ffrg999/dzw2CL4pZ8yYgZ9//hnfffcdEhISMH36dNxwww1Y1zwJis1mw9VXX4309HSsX78eJSUluOuuu2A0GvHyyy9LWm6iDQ0NXNtOuJrViBP/N0zLkWqAdB2yefHxQxAfP8TtcwwjzTWlJkbmiH+t2cw1L/r7XgiXZSFEqfwOjkaPHo2NGzciNzcXI0eOxAMPPICvv/4aGRkZUpbPhcFgQHp6eqv9VVVV+Oc//4mvv/4ao0ePBgAsXLgQvXr1woYNGzB06FAsW7YMe/fuxe+//460tDQMGDAAL730Ep566im88MILiPDwLdHU1ISmJucvcXXz0AyLxQJLoH8y+cCfT+zzKoWa61dc/B6OHZsFAGCYSI91EKeO3J/kLMvCYlFWZlOuz9BiMQBgAFhhsbh29OGG+BthtYZeLn/q9+CDevBJd7vdDotFoqgsCCzLrTO3fDmDigqgvp5BXByLyZNZR2BpsVgcfY6MxlDLz/2sNjZa/J5I0m7nCmKzNUryc6Tm7xl/ab2OUtUvkPP5HRytXbsWGRkZGD16NEaNGoWRI0eiXbt2QRUwWIcOHUJmZiYiIyORl5eHefPmoWPHjti6dSssFgvGjBnjOLZnz57o2LEjCgsLMXToUBQWFqJv374uncbHjh2Lhx56CHv27MHAgQPdXnPevHmYO3duq/3Lli1DdKAzp/mpoKBAkvMqhRrrFxX1g+Mv5eLiHjhxwvtaFaHV8VoAQHV1FX75ZXUI5wme2axDRUUUMjLq3D4f7s+wsnIUgARs3boJVutZl+eqqyMAjAcALFnyS8DD0nksC+ze3R5AO7BsgcdMyIIF1zq2L1y4gF9++SO4C4qovt6AwsJMfPppXzQ1tf5a37NnK0aOdI4wtlozAQDV1efxyy/rgrpmQ4MBwNUAgJ9+WgqTye7X6/T6g4iNBerrK/GL2Gu+CKjxeyZQWq+j2PWrD2CFar+Do8rKSqxduxarVq3Cq6++ikmTJqF79+4YOXKkI1hKEc4MJrIhQ4bg888/R48ePVBSUoK5c+di+PDh2L17N0pLSxEREYHExESX16SlpaG0tBQAUFpa2mo0Hf+YP8adZ555BjNnznQ8rq6uRnZ2NvLz8xEfHy9S7TgWiwUFBQW46qqrYAylM4BCqbl+e/d+jAsXgK5dP0Na2t0ejwu1jlVVzu34+ARMmDAhmOKGbPBgA3btYlBQYMXIkc5MjVyf4dNPc19Vw4Zd6lIeALhwwbk9duyEoPvRfP01g+ef567z+edNuP1231FWUlKSbJ+R0LRpOnz2mbPNMTaWxbBhLE6fZrB3L4O33x6M0tKB+OILGywWC1at2gcAyMhIDrr8goQ6Ro8eh4QE/15XV9cBRUWAyaTH8OHiv3dq/p7xl9brKFX9qgOYlMvv4CgmJgbjxo3DuHHjAAA1NTX4448/sHLlSrz22muYPHkyunXrht27dwdeYj+MHz/esd2vXz8MGTIEOTk5+Pe//42oKOk6yJpMJphMrec2MRqNkv1QSnluJVBj/ex2LoMSEZHgV9mDraPw7wuGYWR7n3bt4v7/5hsDBAlZh3B/hvzs2CaToVXwI/z11+mMIQRHzu1//9uIu+/2HRwxjA5Go/wLDfCfF8DNkTVhAgOjkUFhoXN03/ff6/DVV1xZ+UkgTabgy+/a/8v/991o5CbXtFhKodOZodfHBHV939dR3/dMoLReR7HrF8i5gv6tjomJQXJyMpKTk5GUlASDwYB9+/YFe7qAJSYmonv37jh8+DDS09NhNptRWVnpckxZWZmjj1J6enqr0Wv8Y3f9mAgRstlqAEgzlJtlgT17xJ/EUEv498bbaDXhcW2FzQY8+SSwYQP3eNMm4NprnSPJ8vKcmTWLBeC/Ip19joK/tk4HQT8mz8fZ7cC4cdxnd/iw61xR69dnwmwuD74QhEjE7+DIbrdj06ZNeO211zB+/HgkJiZi2LBh+PDDD5Geno758+fj6NGjUpbVRW1tLY4cOYKMjAwMHjwYRqMRy5cvdzx/4MABnDx5Enl5eQCAvLw87Nq1C+Xlzl/EgoICxMfHo3fv3mErN1Enq5ULjgwG8YOjjz7i1raaNMl1v1onGPTXzz8Dl14KDB3qXBrEE0+LzrbcJ9WINU/k/ow2b+aW/wC40WNdurQ+JjERjiavv/0NOH8e2L491fGaUPgz19HPP3Ozm9tsXJAUGdkRCQkjAAA2WzXq6vaGVghCJOB3s1piYiLq6uqQnp6OK664Am+//TZGjRqFLu5+GyUwa9YsTJw4ETk5OSguLsacOXOg1+sxadIkJCQkYOrUqZg5cyaSk5MRHx+PRx55BHl5eRg6dCgAID8/H71798add96J1157DaWlpXjuuecwbdo0t81mhACA3W7B3r2T0NjID+OP9fGKwL36Kvf/99+LfmpF+/BD7uYOAKNHcxM83nCD+2P9zRyFOziSm7CP2qpVQHKy++M6dOCOfest4K23jAC4DtmhfvUZjUBjo/fM0TnBEmpHjgAMo8fAgauxZcvFqK3d6miyJkRJ/A6OXn/9dVxxxRXo3r27lOXx6PTp05g0aRIqKiqQkpKCyy+/HBs2bHB0An/77beh0+lw4403oqmpCWPHjsWHH37oeL1er8eSJUvw0EMPIS8vDzExMbj77rvx4osvylIfog61tdtw7tx/AHCTP5pMHWUukW8rV3LBxsyZwJtvyl0az1oOHLnxRq7Zxd3fW+EOjnbuVMcERo2N3P9Dh3JNaJ689x7c9h3jF48NFp95uuEGLjsUyMwufF8jfkFnQpTE7+DogQcekLIcPn377bden4+MjMT8+fMxf/58j8fk5ORIOnSUaI9w5fBLLz0IozFJxtL4p3mqL7z1FjBvXuhNJ1LhRzuNGsVlPQCgrMx9cOStWY1huP4vdrt4wdHp0+oIjhq4FW3ga0zKlVdyzW9PPOHc99tvVowYEdA8wK1kZQEVFVyH8P/8B5g+3f/X8pOp2myUOSLKI/8wC0IUjA+OkpLyERmZJXNpAhdMn5gvvhC/HO7w/VSeeALo04fb5jMhLXnLHAHOoKmtdcjmg6PISN/HJiW1fBx6h6mff3b2OwpgChkAgE7HZY6oWY0oEQVHhHhQVVWI/funAACMxvBOeCqXhgZgypTAX8eywD/+AcyeDfzvf/69hs8cmUzOm7un4Mhb5ki4v611yObfL39mM2nZH0mMOXw7dHD+vAS6AK2zWY2CI6I8oeVUCdGwY8f+6tiOjMyVsSTBC/TmHegNDgC++w548EFuFBTANXGdOQP4miEjkODI38xRW+uQ7W+zGgAMHMi9z42NQFpaHdLTxWlvFa6xFgg+ODp69ClERXVHSsp1opSHEDFQ5oi0KRUVS7Fjx1XYuXMCamq2ej2Wb1Jr3/5GZGc/4fVYpQpHZuOll5yBEcD1/enfH9i+3fvrhMERf3NXeuZI6vfTagW2buXmvfLnWvz75U+zWqdOQEkJsGePBe+/vyKkOY6Egg2OoqKcnctOnPibOIUhRCQUHJE2gWVZVFT8gl27xuPChd9x/vyvOHPmQ6+vsVq5qeY7dnwCRmNiGEopvkBv5sHc/Pmpw/7+d+dcTeXlwGuveX+du8wRnwlpyVfmiN/vaao1iwU4eZLr+F1QANTWei8bAMyZ0/r9kDo4mjoVuPhibt6rDz7wfmxjIzdCDPAvcwRwcx516wZERPi3Dpo/gg2OOnR4BDk5cwAAVmuFaOUhRAwUHJE2obp6I3btutpln9V63sPRHClnxQ4XqW/mLMuNVgKAu+7ihoyPGsU9rvBxv+ODo4gI781qLOtcPsRT5ogPjsaNcwYMPKsV6NcPyMkBrrgCyM8Hbr7Ze9kA4MUXuQ7HLcsipaIi5/aWLd6PnTwZWLOG25ZwBSWfgg2OdLoIpKVNBgBYLN5/FwkJNwqOSJvQ1HTCsR0XdykAwGqt8nQ4WJZtk8GRp5Xo3amrAx591JnVadcOaN8emDGDe+xrjUf+Zuqrz5GwqcxT5ujBB53be/a4PnfuHLB/v+s+fyfzb7kiktSZJOGkji1WO2rl0CHn9u23i1uOQAQbHAGAwcANobPZqlFff8jH0YSEDwVHpE2w2bh2lOTkq9Gp0wsAPAdHNlsDDh58ECzLTftrMMSHpYxSOHNGunP/73/Opp+UFGf2Ir757fIWHDU0OId+C/sczZrVOlsjHJ7vKXM0dy5wzz3cdsubtLDTMr8GWTA3ckD6zJEwOPrtN+CFFzwfy78vK1YAAwZIWSrvQguOEgFwEfmmTd1RVVUoWrkICQUFR6RN4IMjgyEOBgO30FRt7TZUVLSeFPTChWUoKfm0+fhESZYMCZfm1XP8FkhmRNhs9tNPzm0+OCoudt9B+vRpIDXV+dhk4joL8/jlVAAuABD2XfKUOeLPA3gPjvgbOd+kFygpgyOWbR1Qzp3L9ZVyhw+O5F6UPdDgSLg+uE5nQFbWDMfjurqd4hWMkBBQcETaBD440utjYTSmOPbv2nU1Ghtd7z5Wa6Vju3//lWAYD+kKiYlxIxbeiMS+Jt+p+Z57gCFDnPv5RU6rqoCOHV1HsgHAzp3O1155JTf/zuOPA488wu2rqXEeu2oV1zEacA1u3PF0kxbOBRRKlgOQLjgqL+eG2vN9q3791fmcp8kVfXVSD5dA39N161wfd+36JtLS7gYAWCwXRCwZIcGj4Ii0CcLgKDq6Gzp3dqYjzOayFsdyqYb27a9HXNyAsJVRCQK5+dc1z90XE+O6v2NHrgM0wGWPdu92fZ6/qQ8ZAvz+O9fPyWQCbrqJ2y8csSbMTv33v96zJJ5u0sLMkafskr+kCo5+/x3YsYPb7twZGDsWSEvjHnta1FWtwZE7/LI8VisFR0QZKDgimldc/AlOnnwFABxNZB07PoGoKG4RZbvdtRew3c79qa7TRYexlP5buZJbMHTGDN+ddgMVTHAU26LV0Wjk5jji16hu2cmav9m3DHT4fkfCTAn/2nHjuH/e+BMciZ05EitY4rNlqance8cwzvfHU1mVFhz99JP/Hd1bMhi46btPnXoNNTU+JsgiJAxohmyieSdPOjux8AERAOh03BCplsERv0q4Xh+e8dGe+pR48sADzpFK7dsDf/2r9+MDEUyzWsvMEcDNks0vV+FvcBTdHIsKM0eBTHLoKziKjHQ9hmUDG50HSJc54t/L/Hxnny3+/VF65iha8DfEZZdx2cJA39eIiDTH9p49N2Lo0CCjLEJEQpkjonl8k1qPHv9EWtodjv06HRf82O2uMw/yj8OROSot9f/Yxkbgrbdch3AXF4tXFrPZd3aGt3o1g3/8g9t2FxwBnid29JU5CjU4atnZ2l3miGWDm01bquDIXRbOV5ZLKcFRfj4wYQK3XVrqOZjzJjX1VqSmcjOINjWdAiv3onWkzaPgiGgev7BlYuIVYAR/0nrKHPHNanq99MGRpxmh3fn+e67jstC5c+KV5eOPuaUr/HHnnc5O6sKRZ0Ke5i7ydFPnMxD19c4gJNTM0c8/A7feym0L+xy1PM5f/t6zN2wAnnkGmDfP93xPgDNzJAyO/M0cyT1aLT6eW1+PF8xIQIMhAd27cyNEWdbq+B0kRC4UHBFNY1nWY7DjLjgym8tRVvZ18/MyTjvsxtmzzu077+T+//e/gc8+E+f8R474fywflP3lL8ANN7g/xlNw5CtzxLLciCaWdd5ogw2OvvzSud23r+tot2Bu4v4ERxUVwOWXA6+8Ajz7LPDPf/o+5+HD3HYgwRG/X+7MERB60AnwC9FyQbdwxCghcqDgiGiasMmsZTMZ36dIeMyuXVfDYilvfl5Z8xvxQca99wIPPeTc/+CDrsPfW/IncxEIm42B1cpl4J5/3vPSFYEGR9HRzr4qw4cDhYWBZY7cjUTjMzIzZnDzJwkDCTEyRy0f//471w9M2GR3yMfEzzfcAPzwA7ctbKJUS7MawE3OyU/QGewcUgzDNE8KCZSULITdHsLwN0JCRMER0TS+czXgX+aooYHrCBoV1R0pKX4swBVGwoVahw7lskYANzcO32fFHX7eIV/8DaLMZmeTmrc1vfjn/A2OjEZuPTPenj3BNavt3eu8Bh8c5eVxncQZxnmcv02IQr4yR8I5fPgyf/SR6/ImLfHrowHcvE88b5kjllVWcAQ4g9NggyMAMBrbAwCOH38eJSU+Um6ESIiCI6JpjY3HAAAMY2o1mSMfHB0+/BgqKrhZ9/j+Sf37FyAyMjuMJW2t5Y1YGBwxDLd4qqcAJBiff+7fcWaz82vDW9DCP7dnj2tdvN3Un3vOuQzIjh3OZrFAgqODB4FLLuG2+YyasLmKP9fVVwPLlvk+r5Ddx2L2/NQKzz8PbNzo3P/JJ56ze/zUBSdOcBNB8vj6uAuOhOVQSnAU6uzjANC58zzHdmMjjVgj8qHgiGjWhQsrsG0bt8gs15/BVWRkrmP71KnXwLI2sCz3zR6uOY4CGZTjLovibcFWqfCZI5OJy8Z4wpftyy+5eZl4njJHvJTmCcznz3f2bfI0Ik5oxAggPZ3b3rGDu0m76+j89NPO7UDn5fH2eX3/PZclArgJHPv1A44fdz5f5WYpP7vd+dlFt/iR8zbPkXC9OaUER2JkjlJSrkenTlz60NvC0IRIjYIjolk1Ndsc2xkZU1s937HjU+jQgVuzwmqtbtEE58fdOMyEmSOep+HyUuKDI29NagBw7bXObWETlq/gqEMH18dXXw3ccovvcmVlAadOOR8fP85lkQDX4OiZZ7isG+AaZPjDU3BkswF3OGeJQG5z3J2TA7Rrx227a7YUfm6egiN3mSNhueUercbzNzi6+WZn0OoO3++IOmUTOVFwRDTLbueayDIzH0SXLq+1el6nMzn6FdlstY4mNYBxNLlJLZDJ8txljsRsVvNXU5OuVTncGTmSm82be41zv6/g6I47uA7Ud98N/PgjsGQJtySJPwwGZ7l69nTubzmLN59tCTU44h/X1Tnr+P773PIfPH5SR3eZI+Fs4C3fT2/NamrOHDU0cAGqJ3xwdP78MlgslaKUjZBAKeTXihDx8Zkgb01k/Ig0m63OZdkQJtApfsPAW+YolODIZgO6dPHv2Npa4KefuIN9ZY4A9zdMXx2Jk5O5yS6DFRvr+n5MnNi6fvzIqkAngvSUOeI7xDMMMG2aa9DLd4j/5z+B/v1dM0R8cBQV1bqJkg8eH3qIW28tP9/5nJqDIwBYv97zc3xwZLNVYfPm3hg69AR0OoWkx0ibQZkjoln+TObIB0dm8xns2HGlz+PDqeWNWKo+R0uXcp2B/fGPf+iwciWXxklM9H28uxumr8xRqOLinNtjxnDZp5aBh1iZI55wEd6WcTXfrPbPf3KTQrp7XcsmNcDZNAdw/a+E+HIzjPd+X+HEf9YPPBD4kjhCiYkjkJAwAgBgNpfAbA5gGnlCRKKQXytCxOdf5sjZt6ix8TgAIDKys6TlCsYHH3Cr0gPiZ47qA5iMWLjQ7dtv+z6+ZXDU1ASsXcttSxUcCZvQ+JXtW/I3OHrySaC83PnYn+CopWefdW4LO2ivWwf06cNtuwuO5s519mMSdso+exYYP57bVkrWCHDOlH70aOtgLhAGQwIGDlyNiIhMAHDMOwYAjY2ncPbsYpw4MQ9Hjz6HqqrCUIpMiEcUHBHN4vsQeetc3XKix8TEUejb90dJyyXk72i1J55wbgv73/DB0Q03eG+quPVWcdYF42/STz5pw8iRvo9vOTHjjTcCmzZx28LZqsUkzLgI+x0JBZI5Ena09tbnCHAfHI0e7RzFJpyP6vffndtXXNH6dRERzrXuhOX89Vdge/PC9Tk5vssfLvPnO7N27vpXBcpo5IYtHj8+FxZLBczms9i4sRv27Lkex449i5Mn/47t24dh27bLUF9/MPQLEiJAwRHRpPr6gzh7dhEAX5mjOMTE9G8+LhLdun2EiAgPi4VJwJ+ARTjce9Ei14kChX1pvC0j8u9/czNOh8pdvydvWmaO9u51Pnf99aGXx51//hP4v/9zvxYdL5A+R3ymC3D/edlszvmSPE05wO8XjtLi5z26917Pc0y5C+L4QFOnc510Um65ucBf/8pthzKcn2cyccMWKyp+wrp17bF+fapjqo3ExFGO46qr16O09F+hX5AQAQUlZQkRB8uy2L59uOOxwRDv8ViGYTB48BaYzaUwGBJhMIR3yRB/giPhaKWxY137tLz7LnD6NJdN8HVDOnkSGDas9f5A+t00NXEX9zc4Ei6BwbLOIG/7dm4eICm0bw9Mnuz9GDH7HL39NtcEBrQeFcfj9wszR3yglJPjedQiX05hEMeX+dprPS/6KxdfS54EolOnuWhqOom6ut2t9nfqNBsWywXs3383Kip+wsmTf4fZXIKePWlWbSIOyhwRzbHbGxz9FFJSbkZy8nivx+t0BkRGZoU9MAL8C46EN5qWTVFRUdw8QC2Pc2fSpNb7CguB22/3v3zBZo748gWyHIiUxAyOhGunPfaY+9e5yxzx28IO5C3xGS5hOZW2bIiQGBNB8uLjL8bFF+9Ep05zkZJyMzp2fBojRljQqdNsAIDRmITc3Jccx5eWLoDV6mWRQUICoMBfL0JCY7M5vyB79/4WDKPcvwF8LUcBuGaO3PXT8TYfji/8ZIj+4m96/vYXEgZHTU3OSQ/9mQZASu4yMv5wFxzx78lrr3merJLPHO3cyY0OHDfO/dImnsqpluBIjCVEhBiGcQRD7sTG9kde3mkUFmYBACyWChgMHTweT4i/lHvXICRINhv3J7lOF6PowAgILHPEMM5MgpC3mZRbGjHCuW2xAGfO+H6Nu7KYTP717hYGRwsXKidz5C4j4w93HbL9qVNysnN7wgTgzTe5KQYA75kjb81qSgyOWnbAD881O8Bk4oOjc+G7MNE0Zd85CAkCn1o3GLzcdRQikD5HnrI1gQRHa9dyzTksC3z1lX9lFOJvev5mjnQ6Z5OSsMlJ7uAomGY1luXm8GmJD468NTX26AG88orzPLNmOZ/j14Nzx10QxwdK7gJluYmdOfKXwcBNJrV9+zDU1haF9+JEkyg4IppjtV4A0HqYvhL506zGBySe5gUKJDgCuEyFTgfcc49/xwsF2ucIcD+KTinNaoEER0uWcB3fW/Inc8QwwFNPAcOHu+7/5BPXbJ4/5VRD5ijcwVF0NDdnA8taUFrqZdgmIX6i4IhoytmzP2DHjtEAuGH6ShdIs5qvzFE4mjKCCY4mTQKmT3c+Zhj5F0sNZvkQ4QSOQoE0FQpHl/XrB9x/v/cZrqlZzT89enyChARu4i3+jyNCQkHBEdGU8+eXOraTk8fJWBL/BNIhW6zMUbCefBLYuJH7yggkOAKAlBTndmRkYAvuSiHY0WruBBIcDRni3HY3rUJLahutJl+zWgLS06cAcB2QQUiwFPjrRUjw+L8ac3NfRk6Ol6W/FULMzJGUwVFFBfD6687HOTmBTbctnLVaCXPziBUcsawzEPAnOJo1C/jTn7jPil86xBu1Nqvt2cP1b2vZjCglfj4zm606fBclmqXAXy9Cgme1VgKAY/SK0nkLjvjnfHXIDmUov7/4IfgA8PbbK9Gz5+UBvf7mm7mh6xUVziUx5BTIUP7GRs+fk9XqXHvNn+CIYYBevfwrI+C+nPy2EoMj4ci7K64ASsO4ZqzBkAAAqKnZCCCABQMJcUOBv16EBMdsLsOFCwUAAIMhSebS+EfMDtlS9vPgzx0TwyI3N/C/zCMjgYcfFrlQIQh0KP/One7379rl3A60qdEfamtW69ePW0Lk73/ngrhzYRxZr9fzM+HbERd3P6zWq2A0tg9fAYimUJ8joglWaxU2buzmeGw0qiM48tWs1tDgHHIvZ7NaoEP4lS7QZjVh5sydLl38ayYLlLdmNSUO5WcY4G9/A9LSuMfh7JgdG9sPCQlcO55OV4vGxiPhuzjRHAqOiCbU1x9wdMRMTp6AuLiLZS6Rf3wFR++/7xwKH+1h/dxwBkdSZEfkwAcdixcD33wT2rmSk7klRLzNdB0stY1W44m5xpq/dDoTBg5cg+joiwAAVuv58F2caA4FR0T1rNYaFBd/AgCIixuCfv1+hk6njru4r2Y14QzWL7zg/hg+OCouBsrKRClWK1rLHAk7hT/4oO/jvY2ui4qSbvSd2prVeHIERzx+QkiLhYIjEjwKjoiq1dcfxNatg1FaugAAEBmZLXOJAuMrc8Rng154ARg71v0xwmxOTo4oxWol0DXVlG78eODtt7nt+hD77ko5Z5O7ZjUld8jmyTWkH3A2qR88eAeqqtaFvwBEEyg4IqrEsjaUl3+PTZt6oKGBWxY9IiITWVmPyVuwAPkKjnx1xgaArl2B66/ntqW6GflTDjUxGIDbb+e2rVb/plQoLna/X8qAUa3NanJNBsldu7Nj+9ix58JfAKIJFBwR1bHZ6lFUNBp79zqXlE9Pvwd5eaeQkHCZjCULnK9mNX+as3Q64L//BTp39nxMqLTW5whwDS78GdLPr43WkpQBoxaa1fwJPMWUnf0smprGAwAqK1ehrOwbsOEuBFE9Co6IqlRWrsXatbGoqloDgBu+O2DAavTsuQAMo74fZ3+b1fzJTkh5s3QGadq5yQiDmlAmgwxH5shuBwYOBCorKTjyxWCIR2PjZABcR7B9+27Hli39qYmNBER9dxPSZu3adQ2KikYA4L5t27e/EcOHVyEx0cvKnQrnb7Oa3MGR1vocAa7vl6+mNW/PSZk5Skpy9iMrKgLuvBP497+5x0ocys8TBkfusqPbtknd5BaLLl0+dDyqq9uF7dsvR13dfikvSjSEgiOieA0Nx7BjRz4qKn5q3qPHoEGbcNFF38taLjH426zmzw1Yypu01karAa2Do2BJnTnatw9ITOQeL1nifK5jR+muGyp/MkfXXittGdLTp+Lyy6uQk/O8Y9/mzb1QUfGztBcmmkDBEVG8M2fec8x8HR3dG8OH1yI+/hKZSyUONWSOFi0CJk/mtrXa58hiCX44vtSd1KOigAEDXPctWgRMmCDtdUMh7JDt6Wd86VL3+8VkMMQjN/dF5OTMduyrrt4s/YWJ6lFwRBSLZVkcPvw4Tp9+BwA/h9Gv0Ov9WMRKJXxljpTQ5+iHH5zbl16qnT5HDOP/MiJ5eZ6fC0c2reW6bWPGSDe3khj49+Trr4FqBawDm5s7F506zQUAVFT8BJutTuYSEaWj4IgoVmPjMZw+/Zbjcc+e/0RkpILbEoIgxlB+nlQZDL6/0Zw5wF//6sdicCoS6DIi7oRjeoOWwVFUlPTXDAU/m/uqVcCTT8paFIeIiEwAQG3tNmzZMphGsBGvKDgiimSxVODo0acdjwcP3oKYGAkWr5KZr07ASmhW44MjqSaYlJMYwZEcmaOWj5Vm+nS5S9Bau3YTEB3dEwDQ0HAAdnuIs38STaPgiCjS0aNP4+zZ7wAA7dpdg7i4wTKXSBremtXsdmU0q2lxjiMe/56Fsi5dODJHwvc+MlLZTWoAcPHFwLffyl0KVyZTJi65ZC8YhvtlsljOyVwiomQKnimDtGV1dXsBADpdFDp1miNzaaTjLXO0XzDqWAnNaloOjkLJHCUkiFMWb4SZIqU3qfGUOLKRYRgYje1hNhejvv4AIiM1mA4loqDMEVEUu92KAwceRHX1egDAgAGrEBc3SOZSScffbg98Hw5vpG5W02JwxAeUwQZHN9wAPPWUeOXxRI3BkVJ/XoxGbmHanTvHorT0S5lLQ5SKgiOiKNXV61BS8gkAQKeLRFRUN5lLJC1fo9UAYNo0rpnCFwqOAhdq5uitt6RdtoWnxuBIiZkjAEhLm+zYrqpaK2NJiJJRcEQUpbHxlGN70KCNjhW2tcpX5ig5GfjgA/9mQ5a6WU2pN7tQhBochavvT6dO7reVTKnBdMeOT6Fbtw8AABbLeZlLQ5SK+hwRxTh//nfs338nACAt7Q7ExvaTuUTS8xUcBXKDoQ7ZgROjQ3Y4/PnPQJcuQE0NMHKk3KXxj5KDaYMhGQBgtVJwRNyjzBFRjKNHnZ03+CG3WuerWU0JwZGWm9VC7XMULgYDcNVVXB+ndu3kLo1//Pl5qayUvBhu8f2OKitX4vDhGTTnEWmFgiOiGE1NZwAA2dmzkJX1mLyFCRNf38mB/PUtRbNaaSlQXMxtazE44gPKm24CjhyRtyxa48/P7htvSF8Od7i+jFyb6OnT76Cx8ag8BSGKRcERkR3L2lFR8TMsljIAXHCk18fIXKrwUHqzmnD9K6VPPBiMTG7SZJw7F1xwRAkHz/z52a2TaRWPqKhcDB68zfHYbD4rT0GIYlFwRGR3/vxv2LXrTwAAhjHAaGwvc4nCR8xmNSmbW266ST0dgQPx+edAhw5yl0KblNznCADi4gYgNpabJsRqrZC5NERpKDgisqur2+PY7tr1XTCMH0OzNELMZrUZM4Dhw0Mrjzt9+wLffQfoNPhtkZ4OPPCA3KXQJjU0w/J9jw4efBD19YdlLg1REg1+3RE1MZvLUFz8MQAgO/sJdOjwsMwlCi8xM0ft2wPPPRdaedzRYnOakNbrJ5fERCAlRe5SeGcyZQEAmppO49ixv8pcGqIkFBwRWRUVjUZjI9fZw2Rqe+0bYvY5AqRpytB68KD1+sklIgLYs8f3cXLq1GkOoqO5Ba2bmk75OJq0JRQcEdnY7U2or+fWUIuLG4KUlJtlLlH4idmsBkjTlKH14CGU+lGHbO98ZY7kfv8iI3PQvftHAGghWuKKgiMiC7vdguLiTwEADBOBQYMKYTJlylyq8PPVrBYbG9j5KDgKnNbrR7zjB4A0NBzCsWMvgGVtMpeIKAEFR0QWJSWf4vDhRwEAJlM2mHCtw6Aw3v5y7tkTmDUrsPNRs1rgtF4/4p3J1AEMw/3inDgxF5WVtN4aoeCIyKS2dqdju3PneTKWRF7egqNvvwUGDgzsfJQ5CpzW60e8Mxji0a/fr47H1PeIABQcERmcPfsNSkq4JrXu3T9Damrb62vE89WsFigKjgKnhiHnWvXuu0CFAqYYSkoajbS0OwAA5eXfwGqtlblERG5tNjiaP38+OnXqhMjISAwZMgSbNm2Su0htAsPU4ODBexyPo6O7y1ga+YndIZWa1QLXPoQ5R+XuUKwFU6bIXQJOREQ6AOD8+V+xd2/b/YONcNpkcLRo0SLMnDkTc+bMwbZt29C/f3+MHTsW5eXlchdN8/T6AwC4dEn37p8hIUGCWQtVROnBUe/ewK23intOpRk4EPjsM7lL0XYtWSJ3CThpaXfBYEgEAFRX0x/LbZ1E63gr21tvvYX77rsP99zDZTA+/vhj/Pzzz1iwYAGefvppWcq0b98hbNv2G4qLi1Fbewo6wXTEej3Qv3/gI5eUprj4H4iJ2Q4AiI8fhszMP0tynSVLgMWLAYuFCz6MRsBs5gIHi4U7xmDg9plM3D6G4d5ni4XbZzY795nNXPYkNhbo7iPRZbPpsHt3J5w8qYPej4m+N2wIubouxA6OlD5PjRgYBvjzn4H77pO7JG3Xhx8Gdvy+fUBDA9DUxP1+22zO3/WGBj2iozvjyisDW4w5NrYvhg49hT/+iIPVeh6FhR2RlnaHY6JIJbHZbIiI2I2SkpPQ+/NFozI2mw0Gw3kAE2QrQ5sLjsxmM7Zu3YpnnnnGsU+n02HMmDEoLCxsdXxTUxOampocj6urqwEAFosFFv5OK4K9ezehQ4dHPK7zVFIi2qUUoX37SaK+fwCwfTswZYoB+/bJOfJND6C/KGeKirIg0LeIi6kDuCP40PIz4h+L/dkpQ+Dvm9EY+Gckt3B/hoMG6bFtm/dGimnTxLyiDkBfREZa8PbbgdbRhOjoi1BfvxtNTadw8qRyB4tERQFHj8pdCukYjcNhsTwh6jkD+Zlvc8HRuXPnYLPZkJaW5rI/LS0N+/fvb3X8vHnzMHfu3Fb7ly1bhujoaNHKVVJSiZKS1lGy2axHTU0E4uLM6NtX/ZOU2Wwd0dR0K7Zv12H79l9EPfesWSNw+HCSqOd0Jy+vWNTzHT6ciLNnXX+Wrr/+EPbt24t9+wI/3z33dMHChReFXK6pU3fhl1/cf/sWFBSEfH6lefPNBDz++Ci/j7/llgPYurX1d4ZahOszfPjhSDz99HCcO+f++3Lo0GIEMpNHYaF/86F9/jmLq6761feBrfwVBsNuGI1/gGHMQbyeiMFm6yb6z2h9fb3fxzIs27a6FBYXF6NDhw5Yv3498vLyHPuffPJJrF69Ghs3bnQ53l3mKDs7G+fOnUN8fLyoZbNYLCgoKMBVV10FY3M+eM0aBmPGGNC1K4u9e62iXi/c3NVPTGlpBly4IG3WaMkSK/LzPf/KSF1HuVH91E/tdYyI8K/MiYksysvV/Z3pido/Q1+kql91dTXat2+Pqqoqn/fvNpc5at++PfR6PcrKylz2l5WVIT09vdXxJpMJJjdjfY1Go2Q/lMJzZ2Rw+yoqGM38Eoj93tXWcpMlXrgg2indeuUV4Oqr/fuVkfLnQwmofurXVuqoZVr/DMWuXyDnanOj1SIiIjB48GAsX77csc9ut2P58uUumSSl4IcZX7gg/pw4WrB0KRdAfvKJ9NcSOVFICJFQZSWDq66i700SnDYXHAHAzJkz8dlnn+GLL77Avn378NBDD6Gurs4xek1JhIGujZb8caiuBl57DRg/nsscAdxIsvfek7dchBDl+P13oFjcLoKkjWhzzWoAcOutt+Ls2bOYPXs2SktLMWDAACxdurRVJ20lEIzop7+Amm3eDNx0E3DypHPf668DjzwCbN0q3XVHjJDu3IQQaXTrBqxcCQwdKndJiJq0yeAIAKZPn47p06fLXQyfhFNYtPXMUV0d8M03rvPRpKcDX38NXHEF91gnYS60Tx/pzk0I8Q/DBDZ5amMjkJcHjBsH/PCD9md8J+Jok81qaiIMjtp65ujJJ10Do2nTgBMnnIERgICGBBNC1CeQ3/E5c5zbS5cCw4cDbmZsIaQVCo4UTpgJaauZo8pKoEcP5yy6JhOwbBnwwQetZ4Sm4IgQbQvkd3zaNG4C3X79uMdbtgAzZ0pTLqItFBwpHGWOgB9/BA4e5Lazs4Fz54CrrnJ/rFTB0SWXSHNeQkhgAmk6Zxiu6f3nn4HLL+f2aXlWaSIeCo4Urq1njmbMAO6+m9sePRo4fNj7GnNSBUc//STNeQkhgQk0OAKArCzgn//ktg8cAD7+uO3+sUn8Q8GRwrX14OjHH53bjz7qe2FVKYKj228HFDiQkZA2KZDfceGxHTo4p0Z56CFgxQpxy0W0hYIjFeADpLb0l05VFXDbbc4U+KlTwLXX+n4d9TkiRNuCDY5iYrjRrrxTp8QrE9EeCo5UgO931JYyR4sXA4sWcdtpaUCmf2tNUnBEiMYF06zGu/FG4I47uO1z6l/Hm0iIgiMV4IOjtpQ52ruX+z8mBvjjD/+/ECk4IkTbgs0c8fglmebO5fowEuIOBUcqwAcGbSVzdNtt3NIgAPDUU0DXrv6/loIjQrQt1OCIX1+8rg645RZxykS0h4IjFWhLzWosyzWp8fLzA3u9Pxkm/i9HQoj6hBocTZkCjBzJbR87JkqRiAa12eVD1KQtdcg+fx5oauK2a2u5ZrVA+PPFWV4u7TIjhBDphNLnCOD6MH73HZCayk0wa7UCBroTkhboFqECbSVz9McfzqxO+/aBB0aAf8ERNb0Rol6hBkcAkJTk3C4pCa08RJsoOFKBttIhe8kS5/bYscGdgwIfQrQt1GY1gMsUxcdz2x07cn+YESJEwZEKtJUO2aWl3P+PPQZ8+WVw56DgiBBtEyM4AoCbb3Zur14dfHmINlFwpAJtIXP03nvAF19w2/37Bx/kSBEcjRol/jkJIcERo1kNAP7xD+citBUVoZWJaA8FRyqg9czRhQvAX/7ifNyjR/DnEjs4euAB4N57xT0nISR4YgVHANcpG+AGghAiRMGRCmi9Q/aZM87tJUuAoUODP5e/wRH/nvoya5b/xxJCpCdWsxoAtGvH/f/FF1xzPiE8Co5UQMvNaocOAdddx2337QtcfXVo2R9/X7tmjbjnI4Qoj6/f3wEDnNvvvgs0NEhaHKIiFBypgJab1V55BThyhNvu1i308/kbzAwb5tqU5wnLhlYeQoi4xMwcXXyx6xIi1PeI8Cg4UgEtZ46OH+f+HzAAeOed0M9HmR5CCM+f74MuXYCMDG777Flpy0PUg4IjFdBi5ohlgdmzgRUruMdvvglkZ4d+XjE7a/p7DCEkfALJ5vr7+8tPPjtoELBsWeBlItpDwZEKaDFzVFQEvPQSt63TAd27i3NeCmYIITx/vw8uu8y5vWiRNGUh6kLBkQpocbSacMHH5cuBrCxxzuvry7Bfv8DOFxERfFkIIeITs88R78MPgaef5rbLygIvE9EeCo5UQGvNagsXMrjxRm77ppvEnWTR15fhtm2BnU+Mpj5CiLIxjDN79PPPwGefyVseIj8KjlRAa81qH3/snDho2DBxz+0rOApkziKxslmEEPFINYK0c2fn9v33A0ePSnMdog4UHKmAVjJHLAv88Ucmtm/nIpjvvxd/4jXqc0QICUbv3sD//Z/z8f/+B1it8pWHyMsgdwGIb3y24/nngfffl7csodi61YDz5y8BwAV8Y8eKH8wEcr7evcW9NiFEelL+ATR5Mtch+6efuHXXZs8G8vKku16wWFaPs2fz8MEHek3+QciyeqSnd8OECfKVgYIjFejQgft/xw55yxE67rc4Pp7FG28wiI2V4AoBfFHcey+XPieEEN699wJbtwLFxUBtLVBQIHeJ3NEBSJW7EBLSYfjweFlLQMGRCnzyCXDjjepP8VqtVhw8uBXPPz8IUVFGSa4RSHBEa6YRoj5Sz1p/3XXcv6IiYPduaa8VLKvVih07dqB///4wGLR3G7darSgpOQYgTbYyaO9d1aDkZOC22+QuRegsFha//FIKKX+XvQVHUVHSXZcQoi0DBriuvaYkFguLpKTTmDChH4zS/J0pK+5ecV7WMlCHbKIp3mbIXrs2fOUghEhDi31siPJQcEQ0xdsX5+DBgZ3r7bdDKwshhBB1ouCIaIpYf1W+/jo3QSUhhJC2h4IjoiliBUft2olzHkIIIepDwRHRFOqPQAghJFQUHBFNoeCIEEJIqCg4IpoSaHA0frw05SCEEKJeFBwRTQk0OFq8WJJiEEIIUTEKjoimeAqONm1yvz8iAhg0SLryEELElZEhdwlIW0DBEdEUT8HRJZeEtxyEEGl8843cJSBtAQVHRFOoQzYh2tatm9wlIG0BBUdEU7wtH0IIIYT4g24lRFMoc0QIISRUFBwRTaHgiBBCSKgoOCKaQsERIYSQUFFwRDSFgiNCCCGhouCIaIpYwdHw4eKchxBCiPpQcEQ0RYzgaP9+oGvX0M9DCCFEnSg4IpoiRnDUo0fo5yCEEKJeFBwRTQkmOEpJcW4/9phoRSGESOSrr+QuAdE6Co6IpgQTHH36qXN79mzxykIIkcbttwMXLshdCqJlBrkLQIiYggmOOnYEWFb8shBCpJOYCJjN3OLRhIiNMkeEEEJUyWiUuwREqyg4Ipr33ntyl4AQQoiaUHBENK1fP+CRR+QuBSFEKh98IHcJiBZRcEQ0zUC96gjRtGnTgJwcuUtBtIaCI0IIIapGywYRsVFwRAghhBAiQMERIYQQVXvzTblLQLSGgiOiabfeKncJCCFSu+EGuUtAtIaCI6JpM2fKXQJCCCFqQ8ER0TQarUYIISRQFBwRQgghhAhQcEQIIUT1KivlLgHREgqOCCGEqF5CgtwlIFpCwREhhBBCiAAFR0Rz3nqL+/+nn+QtByGEEHWi4IhozowZAMsCf/qT3CUhhBCiRhQcEUIIIYQIqCY46tSpExiGcfn3yiuvuByzc+dODB8+HJGRkcjOzsZrr73W6jzfffcdevbsicjISPTt2xe//PJLuKpACCGEEBVQTXAEAC+++CJKSkoc/x555BHHc9XV1cjPz0dOTg62bt2K119/HS+88AI+/fRTxzHr16/HpEmTMHXqVGzfvh3XXXcdrrvuOuzevVuO6hBCCCFEgVQ1f3BcXBzS09PdPvfVV1/BbDZjwYIFiIiIQJ8+fVBUVIS33noL999/PwDg3Xffxbhx4/DEE08AAF566SUUFBTggw8+wMcffxy2ehBCCCFEuVQVHL3yyit46aWX0LFjR9x+++2YMWMGDM3rQxQWFmLEiBGIiIhwHD927Fi8+uqruHDhApKSklBYWIiZLRbbGjt2LBYvXuzxmk1NTWhqanI8rq6uBgBYLBZYLBYRawfH+cQ+r1JovX6A9utI9VM/bdfR6PJIm3XU+mcoXf0COZ9qgqNHH30UgwYNQnJyMtavX49nnnkGJSUleKt53HZpaSlyc3NdXpOWluZ4LikpCaWlpY59wmNKS0s9XnfevHmYO3duq/3Lli1DdHR0qNVyq6CgQJLzKoXW6wdov45UP/XTYh379RuGnTtTHI+13qdUi5+hkNj1q6+v9/tYWYOjp59+Gq+++qrXY/bt24eePXu6ZHz69euHiIgIPPDAA5g3bx5MJpNkZXzmmWdcrl1dXY3s7Gzk5+cjPj5e1GtZLBYUFBTgqquugtFo9P0CldF6/QDt15Hqp35armNeHiD8+3fChAnyFUZCWv4MAenqx7f8+EPW4Ojxxx/HlClTvB7TuXNnt/uHDBkCq9WK48ePo0ePHkhPT0dZWZnLMfxjvp+Sp2M89WMCAJPJ5Db4MhqNkv1QSnluJdB6/QDt15Hqp35arGNqKnDvvXYsWMCNNdJa/VrS4mcoJHb9AjmXrMFRSkoKUlJSfB/oRlFREXQ6HVJTUwEAeXl5+Otf/wqLxeJ4AwoKCtCjRw8kJSU5jlm+fDkee+wxx3kKCgqQl5cXWkUIIYQQohmqGMpfWFiId955Bzt27MDRo0fx1VdfYcaMGbjjjjscgc/tt9+OiIgITJ06FXv27MGiRYvw7rvvujSJ/eUvf8HSpUvx5ptvYv/+/XjhhRewZcsWTJ8+Xa6qEUIIEZHJxMpdBKIBqgiOTCYTvv32W4wcORJ9+vTB3//+d8yYMcNlDqOEhAQsW7YMx44dw+DBg/H4449j9uzZjmH8ADBs2DB8/fXX+PTTT9G/f398//33WLx4MS666CI5qkUIIURkzz5rR1ZWDV55xSZ3UYiKqWK02qBBg7Bhwwafx/Xr1w9r1671eszNN9+Mm2++WayiEUIIUZC0NOCDD1Y0d8bWy10colKqyBwRQgghhIQLBUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQogABUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQogABUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQogABUeEEEIIIQIGuQugNizLAgCqq6tFP7fFYkF9fT2qq6thNBpFP7/ctF4/QPt1pPqpn9brqPX6Adqvo1T14+/b/H3cGwqOAlRTUwMAyM7OlrkkhBBCCAlUTU0NEhISvB7DsP6EUMTBbrejuLgYcXFxYBhG1HNXV1cjOzsbp06dQnx8vKjnVgKt1w/Qfh2pfuqn9TpqvX6A9usoVf1YlkVNTQ0yMzOh03nvVUSZowDpdDpkZWVJeo34+HhN/sDztF4/QPt1pPqpn9brqPX6AdqvoxT185Ux4lGHbEIIIYQQAQqOCCGEEEIEKDhSEJPJhDlz5sBkMsldFElovX6A9utI9VM/rddR6/UDtF9HJdSPOmQTQgghhAhQ5ogQQgghRICCI0IIIYQQAQqOCCGEEEIEKDgihBBCCBGg4Egm8+fPR6dOnRAZGYkhQ4Zg06ZNjucaGxsxbdo0tGvXDrGxsbjxxhtRVlYmY2kD561+DzzwALp06YKoqCikpKTg2muvxf79+2UsbXC81REACgsLMXr0aMTExCA+Ph4jRoxAQ0ODTKUNnLf6HTlyBNdffz1SUlIQHx+PW265RVU/o2vWrMHEiRORmZkJhmGwePFix3MWiwVPPfUU+vbti5iYGGRmZuKuu+5CcXGxfAUOkLf6AcCUKVPAMIzLv3HjxslT2CD5qmNtbS2mT5+OrKwsREVFoXfv3vj444/lKWwQ5s2bh0suuQRxcXFITU3FddddhwMHDrgc8+mnn2LUqFGIj48HwzCorKyUp7AhUOq9kIIjGSxatAgzZ87EnDlzsG3bNvTv3x9jx45FeXk5AGDGjBn46aef8N1332H16tUoLi7GDTfcIHOp/eerfoMHD8bChQuxb98+/Pbbb2BZFvn5+bDZbDKX3H++6lhYWIhx48YhPz8fmzZtwubNmzF9+nSfU9Yrhbf61dXVIT8/HwzDYMWKFVi3bh3MZjMmTpwIu90ud9H9UldXh/79+2P+/Pmtnquvr8e2bdvw/PPPY9u2bfjvf/+LAwcO4JprrpGhpMHxVj/euHHjUFJS4vj3zTffhLGEofNVx5kzZ2Lp0qX4v//7P+zbtw+PPfYYpk+fjh9//DHMJQ3O6tWrMW3aNGzYsAEFBQWwWCzIz89HXV2d45j6+nqMGzcOzz77rIwlDZ6i74UsCbtLL72UnTZtmuOxzWZjMzMz2Xnz5rGVlZWs0Whkv/vuO8fz+/btYwGwhYWFchQ3YN7q586OHTtYAOzhw4fDVcSQ+arjkCFD2Oeee06u4oXMW/1+++03VqfTsVVVVY7nKysrWYZh2IKCAjmKGxIA7A8//OD1mE2bNrEA2BMnToSnUCJyV7+7776bvfbaa2UpjxTc1bFPnz7siy++6LJv0KBB7F//+tcwlkw85eXlLAB29erVrZ5buXIlC4C9cOFC+AsWAiXfC9XxZ6yGmM1mbN26FWPGjHHs0+l0GDNmDAoLC7F161ZYLBaX53v27ImOHTuisLBQjiIHxFf9Wqqrq8PChQuRm5uL7OzscBY1aL7qWF5ejo0bNyI1NRXDhg1DWloaRo4ciT/++EPGUvvPV/2amprAMIzLBG2RkZHQ6XSqqWOgqqqqwDAMEhMT5S6KaFatWoXU1FT06NEDDz30ECoqKuQukqiGDRuGH3/8EWfOnAHLsli5ciUOHjyI/Px8uYsWlKqqKgBAcnKyzCURh9LvhRQchdm5c+dgs9mQlpbmsj8tLQ2lpaUoLS1FREREqy9h/nml81U/3ocffojY2FjExsbi119/RUFBASIiIsJd3KD4quPRo0cBAC+88ALuu+8+LF26FIMGDcKVV16JQ4cOyVHkgPiq39ChQxETE4OnnnoK9fX1qKurw6xZs2Cz2VBSUiJTqaXT2NiIp556CpMmTdLMIp/jxo3Dv/71LyxfvhyvvvoqVq9ejfHjx6uqaduX999/H71790ZWVhYiIiIwbtw4zJ8/HyNGjJC7aAGz2+147LHHcNlll+Giiy6SuziiUPq9kIIjIovJkydj+/btWL16Nbp3745bbrkFjY2NchdLFHy/mwceeAD33HMPBg4ciLfffhs9evTAggULZC5d6FJSUvDdd9/hp59+QmxsLBISElBZWYlBgwappk+VvywWC2655RawLIuPPvpI7uKI5rbbbsM111yDvn374rrrrsOSJUuwefNmrFq1Su6iieb999/Hhg0b8OOPP2Lr1q148803MW3aNPz+++9yFy1g06ZNw+7du/Htt9/KXZQ2wyB3Adqa9u3bQ6/Xt+pxX1ZWhvT0dKSnp8NsNqOystIlYuafVzpf9eMlJCQgISEB3bp1w9ChQ5GUlIQffvgBkyZNCneRA+arjhkZGQCA3r17uzzfq1cvnDx5MmzlDJY/n2F+fj6OHDmCc+fOwWAwIDExEenp6ejcubMcRZYEHxidOHECK1as0EzWyJ3OnTujffv2OHz4MK688kq5ixOyhoYGPPvss/jhhx9w9dVXAwD69euHoqIivPHGGy5NNUo3ffp0LFmyBGvWrEFWVpbcxRGN0u+F2vozTwUiIiIwePBgLF++3LHPbrdj+fLlyMvLw+DBg2E0Gl2eP3DgAE6ePIm8vDw5ihwQX/Vzh2VZsCyLpqamcBUzJL7q2KlTJ2RmZrYadnvw4EHk5OSEu7gBC+QzbN++PRITE7FixQqUl5erakSXN3xgdOjQIfz+++9o166d3EWS1OnTp1FRUeEI7NXOYrHAYrG0ymTq9XrVjKhkWRbTp0/HDz/8gBUrViA3N1fuIolK8fdCybt8k1a+/fZb1mQysZ9//jm7d+9e9v7772cTExPZ0tJSlmVZ9sEHH2Q7duzIrlixgt2yZQubl5fH5uXlyVxq/3mr35EjR9iXX36Z3bJlC3vixAl23bp17MSJE9nk5GS2rKxM7qL7zddn+Pbbb7Px8fHsd999xx46dIh97rnn2MjISNWMyPNVvwULFrCFhYXs4cOH2S+//JJNTk5mZ86cKXOp/VdTU8Nu376d3b59OwuAfeutt9jt27ezJ06cYM1mM3vNNdewWVlZbFFREVtSUuL419TUJHfR/eKtfjU1NeysWbPYwsJC9tixY+zvv//ODho0iO3WrRvb2Ngod9H95q2OLMuyI0eOZPv06cOuXLmSPXr0KLtw4UI2MjKS/fDDD2UuuX8eeughNiEhgV21apXLz2B9fb3jmJKSEnb79u3sZ599xgJg16xZw27fvp2tqKiQseT+U/K9kIIjmbz//vtsx44d2YiICPbSSy9lN2zY4HiuoaGBffjhh9mkpCQ2Ojqavf7669mSkhIZSxs4T/U7c+YMO378eDY1NZU1Go1sVlYWe/vtt7P79++XucSB8/YZsizLzps3j83KymKjo6PZvLw8du3atTKVNDje6vfUU0+xaWlprNFoZLt168a++eabrN1ul7G0geGHPrf8d/fdd7PHjh1z+xwAduXKlXIX3S/e6ldfX8/m5+ezKSkprNFoZHNyctj77rvPcUNSC291ZFkucJgyZQqbmZnJRkZGsj169FDVz6mnn8GFCxc6jpkzZ47PY5ROqfdChmVZVtrcFCGEEEKIelCfI0IIIYQQAQqOCCGEEEIEKDgihBBCCBGg4IgQQgghRICCI0IIIYQQAQqOCCGEEEIEKDgihBBCCBGg4IgQQgghRICCI0JImzJlyhRcd911cheDEKJgBrkLQAghYmEYxuvzc+bMwbvvvgtaGIAQ4g0FR4QQzSgpKXFsL1q0CLNnz8aBAwcc+2JjYxEbGytH0QghKkLNaoQQzUhPT3f8S0hIAMMwLvtiY2NbNauNGjUKjzzyCB577DEkJSUhLS0Nn332Gerq6nDPPfcgLi4OXbt2xa+//upyrd27d2P8+PGIjY1FWloa7rzzTpw7dy7MNSaESIGCI0JIm/fFF1+gffv22LRpEx555BE89NBDuPnmmzFs2DBs27YN+fn5uPPOO1FfXw8AqKysxOjRozFw4EBs2bIFS5cuRVlZGW655RaZa0IIEQMFR4SQNq9///547rnn0K1bNzzzzDOIjIxE+/btcd9996Fbt26YPXs2KioqsHPnTgDABx98gIEDB+Lll19Gz549MXDgQCxYsAArV67EwYMHZa4NISRU1OeIENLm9evXz7Gt1+vRrl079O3b17EvLS0NAFBeXg4A2LFjB1auXOm2/9KRI0fQvXt3iUtMCJESBUeEkDbPaDS6PGYYxmUfPwrObrcDAGprazFx4kS8+uqrrc6VkZEhYUkJIeFAwREhhARo0KBB+M9//oNOnTrBYKCvUUK0hvocEUJIgKZNm4bz589j0qRJ2Lx5M44cOYLffvsN99xzD2w2m9zFI4SEiIIjQggJUGZmJtatWwebzYb8/Hz07dsXjz32GBITE6HT0dcqIWrHsDRVLCGEEEKIA/2JQwghhBAiQMERIYQQQogABUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQogABUeEEEIIIQIUHBFCCCGECFBwRAghhBAiQMERIYQQQogABUeEEEIIIQL/D/GSdbpf+J0oAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -145,13 +146,13 @@
     "\n",
     "df = pd.read_csv(\"result.csv\", parse_dates=[0], index_col=0)\n",
     "# divide e_delta by step size because e_delta is energy\n",
-    "df[\"e_delta\"] = df[\"e_delta\"] / 60\n",
+    "df[\"grid_power\"] = df[\"e_delta\"] / 60\n",
     "\n",
     "fig, ax1 = plt.subplots()\n",
     "\n",
-    "ax1.plot(df.index, df[\"e_delta\"], color=\"b\", label=\"e_delta\")\n",
+    "ax1.plot(df.index, df[\"grid_power\"], color=\"b\", label=\"e_delta\")\n",
     "ax1.legend()\n",
-    "ax1.plot(df.index, df[\"actor_states.Generator-0.p\"], color=\"y\", label=\"solar\")\n",
+    "ax1.plot(df.index, df[\"solar.p\"], color=\"y\", label=\"solar\")\n",
     "ax1.legend()\n",
     "ax1.xaxis.set_major_formatter(mdates.DateFormatter(\"%H\"))\n",
     "ax1.grid()\n",
@@ -178,7 +179,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,
diff --git a/vessim/policy.py b/vessim/policy.py
index 3c91ccc..a3554dc 100644
--- a/vessim/policy.py
+++ b/vessim/policy.py
@@ -8,7 +8,15 @@
 
 
 class MicrogridPolicy(ABC):
-    """Policy that describes how the microgrid deals with specific power deltas."""
+    """Policy that describes how the microgrid deals with specific power deltas.
+
+    The policy manages energy excess and shortage of a microgrid. It can model the
+    (dis-)charging of a vessim `Storage`, the exchange of energy with the public grid, and things
+    like curtailment of energy.
+    Every `Microgrid` in a vessim co-simulation has a policy, and if not specified, the
+    `DefaultMicrogridPolicy` is used. The policy is thereby applied at every time-step with the
+    current power-delta and the duration of the time-step.
+    """
 
     @abstractmethod
     def apply(self, p_delta: float, duration: int, storage: Optional[Storage] = None) -> float:
@@ -25,6 +33,7 @@ def apply(self, p_delta: float, duration: int, storage: Optional[Storage] = None
 
         Returns:
             Total energy in Ws that has to be drawn from/ is fed to the public grid.
+            If the return value is smaller than 0, energy has been drawn.
         """
 
     def set_parameter(self, key: str, value: Any) -> None:
@@ -45,7 +54,7 @@ def state(self) -> dict:
 class DefaultMicrogridPolicy(MicrogridPolicy):
     """Policy that is used as default for simulations.
 
-    Policy tries to (dis)charge as much of the delta as possible using the battery if available.
+    Policy tries to (dis)charge as much of the delta as possible using the storage if available.
     In `grid-connected` mode the public utility grid is used to exchange the remaining energy delta
     (positive or negative). In `islanded` mode, an error is raised when the power consumption
     exceeds the available power as no power can be drawn from the grid.
diff --git a/vessim/storage.py b/vessim/storage.py
index 66fe0fd..7925d21 100644
--- a/vessim/storage.py
+++ b/vessim/storage.py
@@ -109,7 +109,7 @@ def update(self, power: float, duration: int) -> float:
             self.charge_level = new_charge_level
             self.soc = self.charge_level / self.capacity
 
-        return charged_energy * 3600 # Wh to Ws
+        return charged_energy * 3600  # Wh to Ws
 
     def state(self) -> dict:
         """Returns state information of the battery as a dict."""

From 7a36d00fabbd1d3eadfc74769840ea5cc954baa6 Mon Sep 17 00:00:00 2001
From: kilianp14 <kilian.paul14@gmail.com>
Date: Fri, 7 Jun 2024 15:43:42 +0200
Subject: [PATCH 4/5] updated and debugged sil example

---
 examples/sil_example.ipynb             | 310 +++++++++++++++++++++++--
 examples/util/example_node/sil_node.py |   2 +-
 vessim/sil.py                          |   5 +-
 3 files changed, 292 insertions(+), 25 deletions(-)

diff --git a/examples/sil_example.ipynb b/examples/sil_example.ipynb
index 6ddbba3..3ddf775 100644
--- a/examples/sil_example.ipynb
+++ b/examples/sil_example.ipynb
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -59,7 +59,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -103,14 +103,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def battery_min_soc_collector(events: dict, microgrid: Microgrid, **kwargs):\n",
+    "def battery_min_soc_collector(controller: vs.SilController, events: dict, **kwargs):\n",
     "    print(f\"Received battery.min_soc events: {events}\")\n",
-    "    assert isinstance(microgrid.storage, vs.SimpleBattery)\n",
-    "    microgrid.storage.min_soc = vs.get_latest_event(events)"
+    "    controller.set_parameters[\"storage:min_soc\"] = vs.get_latest_event(events)"
    ]
   },
   {
@@ -127,7 +126,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -153,7 +152,7 @@
     "        while True:\n",
     "            self._p = float(\n",
     "                requests.get(\n",
-    "                    f\"{self.address}:{self.port}/power\",\n",
+    "                    f\"http://{self.address}:{self.port}/power\",\n",
     "                ).text\n",
     "            )\n",
     "            time.sleep(self.collect_interval)"
@@ -186,29 +185,300 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-06-07 15:40:41.430 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-0\" ...\n",
+      "2024-06-07 15:40:41.431 | INFO     | mosaik.scenario:start:306 - Starting \"Actor\" as \"Actor-1\" ...\n",
+      "2024-06-07 15:40:41.431 | INFO     | mosaik.scenario:start:306 - Starting \"Grid\" as \"Grid-0\" ...\n",
+      "2024-06-07 15:40:41.432 | INFO     | mosaik.scenario:start:306 - Starting \"Controller\" as \"Controller-0\" ...\n",
+      "2024-06-07 15:40:41.435 | INFO     | vessim.sil:start:162 - Started SiL Controller API server process 'Vessim API for microgrid 140624548551888'\n",
+      "2024-06-07 15:40:41.437 | INFO     | mosaik.scenario:start:306 - Starting \"Controller\" as \"Controller-1\" ...\n",
+      "2024-06-07 15:40:41.439 | INFO     | mosaik.scenario:start:306 - Starting \"Storage\" as \"Storage-0\" ...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-06-07 15:40:41.444 | INFO     | mosaik.scenario:run:646 - Starting simulation.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:     Started server process [76596]\n",
+      "INFO:     Waiting for application startup.\n",
+      "INFO:     Application startup complete.\n",
+      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-06-07 15:40:43.456 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.010430321999592707s behind time.\n",
+      "2024-06-07 15:40:43.460 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.014199371998984134s behind time.\n",
+      "2024-06-07 15:40:43.462 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.016221137999309576s behind time.\n",
+      "2024-06-07 15:40:43.466 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.019496181999784312s behind time.\n",
+      "2024-06-07 15:40:44.471 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.02448437500061118s behind time.\n",
+      "2024-06-07 15:40:44.474 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.02756036199934897s behind time.\n",
+      "2024-06-07 15:40:44.477 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.030571895000321092s behind time.\n",
+      "2024-06-07 15:40:44.479 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.03292393400079163s behind time.\n",
+      "2024-06-07 15:40:45.482 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.03607998699953896s behind time.\n",
+      "2024-06-07 15:40:45.485 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.03919405499982531s behind time.\n",
+      "2024-06-07 15:40:45.487 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.04087900899867236s behind time.\n",
+      "2024-06-07 15:40:45.491 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.04466149700056121s behind time.\n",
+      "2024-06-07 15:40:46.497 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.05061028499949316s behind time.\n",
+      "2024-06-07 15:40:46.499 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.05327048099934473s behind time.\n",
+      "2024-06-07 15:40:46.501 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.055262896999920486s behind time.\n",
+      "2024-06-07 15:40:46.504 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.058162924000498606s behind time.\n",
+      "2024-06-07 15:40:47.509 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.062748611000643s behind time.\n",
+      "2024-06-07 15:40:47.512 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.06544801199925132s behind time.\n",
+      "2024-06-07 15:40:47.513 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.06731414299974858s behind time.\n",
+      "2024-06-07 15:40:47.516 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.0699585330003174s behind time.\n",
+      "2024-06-07 15:40:48.521 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.0750543470003322s behind time.\n",
+      "2024-06-07 15:40:48.524 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.07816387299862981s behind time.\n",
+      "2024-06-07 15:40:48.528 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.0814245799992932s behind time.\n",
+      "2024-06-07 15:40:48.531 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.08471880900106044s behind time.\n",
+      "2024-06-07 15:40:49.536 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.08966002399938588s behind time.\n",
+      "2024-06-07 15:40:49.539 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.09294630799922743s behind time.\n",
+      "2024-06-07 15:40:49.542 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.09618290700018406s behind time.\n",
+      "2024-06-07 15:40:49.550 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.10339025800021773s behind time.\n",
+      "2024-06-07 15:40:50.554 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.10795705099917541s behind time.\n",
+      "2024-06-07 15:40:50.557 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.11057602199980465s behind time.\n",
+      "2024-06-07 15:40:50.559 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.11301595499935502s behind time.\n",
+      "2024-06-07 15:40:50.562 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.11636549000104424s behind time.\n",
+      "2024-06-07 15:40:51.567 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.12044999200043094s behind time.\n",
+      "2024-06-07 15:40:51.570 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.12425783999970008s behind time.\n",
+      "2024-06-07 15:40:51.573 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.12706980499933707s behind time.\n",
+      "2024-06-07 15:40:51.577 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.13116282200098794s behind time.\n",
+      "2024-06-07 15:40:52.582 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.13641244400059804s behind time.\n",
+      "2024-06-07 15:40:52.585 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.13922273199932533s behind time.\n",
+      "2024-06-07 15:40:52.588 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.1416551000002073s behind time.\n",
+      "2024-06-07 15:40:52.593 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.14657456200075103s behind time.\n",
+      "2024-06-07 15:40:53.599 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.15282830300020578s behind time.\n",
+      "2024-06-07 15:40:53.603 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.1564035609990242s behind time.\n",
+      "2024-06-07 15:40:53.605 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.15896283599977323s behind time.\n",
+      "2024-06-07 15:40:53.608 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.16208271000141394s behind time.\n",
+      "2024-06-07 15:40:54.613 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.1673277150002832s behind time.\n",
+      "2024-06-07 15:40:54.616 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.17039535799995065s behind time.\n",
+      "2024-06-07 15:40:54.619 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.1726285069998994s behind time.\n",
+      "2024-06-07 15:40:54.622 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.1761068330015405s behind time.\n",
+      "2024-06-07 15:40:55.628 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.18172707799931231s behind time.\n",
+      "2024-06-07 15:40:55.631 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.18494181699861656s behind time.\n",
+      "2024-06-07 15:40:55.633 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.18658562899872777s behind time.\n",
+      "2024-06-07 15:40:55.637 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.19074696400093671s behind time.\n",
+      "2024-06-07 15:40:56.642 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.19593011100005242s behind time.\n",
+      "2024-06-07 15:40:56.645 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.19867407099991397s behind time.\n",
+      "2024-06-07 15:40:56.647 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2013468709992594s behind time.\n",
+      "2024-06-07 15:40:56.650 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.20366346100126975s behind time.\n",
+      "2024-06-07 15:40:57.654 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.20754429400039953s behind time.\n",
+      "2024-06-07 15:40:57.657 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.21050176399876364s behind time.\n",
+      "2024-06-07 15:40:57.659 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.21257263000006787s behind time.\n",
+      "2024-06-07 15:40:57.662 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.21542526000121143s behind time.\n",
+      "2024-06-07 15:40:58.665 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.21943249099967943s behind time.\n",
+      "2024-06-07 15:40:58.667 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.22128704199894855s behind time.\n",
+      "2024-06-07 15:40:58.669 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.22265509600038058s behind time.\n",
+      "2024-06-07 15:40:58.671 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.22447398400072416s behind time.\n",
+      "2024-06-07 15:40:59.674 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2278779989992472s behind time.\n",
+      "2024-06-07 15:40:59.676 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.22991590699894005s behind time.\n",
+      "2024-06-07 15:40:59.678 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.23161310799878265s behind time.\n",
+      "2024-06-07 15:40:59.680 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.23420067300139635s behind time.\n",
+      "Received battery.min_soc events: {datetime.datetime(2024, 6, 7, 15, 40, 59, 575874): 0.3}\n",
+      "2024-06-07 15:41:00.685 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2388765270006843s behind time.\n",
+      "2024-06-07 15:41:00.688 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.24181656600012502s behind time.\n",
+      "2024-06-07 15:41:00.691 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.24462342500009981s behind time.\n",
+      "2024-06-07 15:41:00.694 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.24762441700113413s behind time.\n",
+      "2024-06-07 15:41:01.698 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2523727269999654s behind time.\n",
+      "2024-06-07 15:41:01.702 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.25592537999909837s behind time.\n",
+      "2024-06-07 15:41:01.704 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.257586903999254s behind time.\n",
+      "2024-06-07 15:41:01.707 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2611982500002341s behind time.\n",
+      "2024-06-07 15:41:02.714 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.26779748700027994s behind time.\n",
+      "2024-06-07 15:41:02.717 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.27084053799990215s behind time.\n",
+      "2024-06-07 15:41:02.719 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.27301266500035126s behind time.\n",
+      "2024-06-07 15:41:02.724 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2774697760014533s behind time.\n",
+      "2024-06-07 15:41:03.730 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.28368203600075503s behind time.\n",
+      "2024-06-07 15:41:03.733 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2868823139997403s behind time.\n",
+      "2024-06-07 15:41:03.735 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.28880507899884833s behind time.\n",
+      "2024-06-07 15:41:03.738 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2917497230009758s behind time.\n",
+      "2024-06-07 15:41:04.742 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.2960948729996744s behind time.\n",
+      "2024-06-07 15:41:04.746 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.29953670099894225s behind time.\n",
+      "2024-06-07 15:41:04.748 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.30232062699906237s behind time.\n",
+      "2024-06-07 15:41:04.752 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3056473240012565s behind time.\n",
+      "2024-06-07 15:41:05.757 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3105442399992171s behind time.\n",
+      "2024-06-07 15:41:05.760 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.31374555900038104s behind time.\n",
+      "2024-06-07 15:41:05.761 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.31531164499938313s behind time.\n",
+      "2024-06-07 15:41:05.764 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.31774505600151315s behind time.\n",
+      "2024-06-07 15:41:06.769 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3225022490005358s behind time.\n",
+      "2024-06-07 15:41:06.772 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.32590082800015807s behind time.\n",
+      "2024-06-07 15:41:06.775 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3286606660003599s behind time.\n",
+      "2024-06-07 15:41:06.779 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.33272007900086464s behind time.\n",
+      "2024-06-07 15:41:07.785 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.33870878999914567s behind time.\n",
+      "2024-06-07 15:41:07.789 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.34251979399959964s behind time.\n",
+      "2024-06-07 15:41:07.792 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.34547864100022707s behind time.\n",
+      "2024-06-07 15:41:07.796 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.34939145400130656s behind time.\n",
+      "2024-06-07 15:41:08.800 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.35436738200041873s behind time.\n",
+      "2024-06-07 15:41:08.803 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.35695714699977543s behind time.\n",
+      "2024-06-07 15:41:08.806 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3595036459992116s behind time.\n",
+      "2024-06-07 15:41:08.807 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.36116800800118654s behind time.\n",
+      "2024-06-07 15:41:09.810 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.36378098699969996s behind time.\n",
+      "2024-06-07 15:41:09.813 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.36649086400029773s behind time.\n",
+      "2024-06-07 15:41:09.814 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3682236490003561s behind time.\n",
+      "2024-06-07 15:41:09.818 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3720468850006s behind time.\n",
+      "2024-06-07 15:41:10.822 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3758826550001686s behind time.\n",
+      "2024-06-07 15:41:10.824 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.37817374499900325s behind time.\n",
+      "2024-06-07 15:41:10.826 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.37999468299858563s behind time.\n",
+      "2024-06-07 15:41:10.828 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.38232091600002605s behind time.\n",
+      "2024-06-07 15:41:11.832 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3856051450002269s behind time.\n",
+      "2024-06-07 15:41:11.834 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.388232737999715s behind time.\n",
+      "2024-06-07 15:41:11.837 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.39050017800036585s behind time.\n",
+      "2024-06-07 15:41:11.841 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.39460226600021997s behind time.\n",
+      "2024-06-07 15:41:12.845 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.3990341120006633s behind time.\n",
+      "2024-06-07 15:41:12.848 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.401502843000344s behind time.\n",
+      "2024-06-07 15:41:12.850 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.40385455999967235s behind time.\n",
+      "2024-06-07 15:41:12.852 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4063197420000506s behind time.\n",
+      "2024-06-07 15:41:13.857 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4109596460002649s behind time.\n",
+      "2024-06-07 15:41:13.860 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.41384344899961434s behind time.\n",
+      "2024-06-07 15:41:13.862 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.41563997299999755s behind time.\n",
+      "2024-06-07 15:41:13.864 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.41775185900041834s behind time.\n",
+      "2024-06-07 15:41:14.868 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4221913380006299s behind time.\n",
+      "2024-06-07 15:41:14.871 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4248722229986015s behind time.\n",
+      "2024-06-07 15:41:14.874 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4283507729996927s behind time.\n",
+      "2024-06-07 15:41:14.878 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4314338710009906s behind time.\n",
+      "2024-06-07 15:41:15.881 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.43522625699915807s behind time.\n",
+      "2024-06-07 15:41:15.884 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4383582970003772s behind time.\n",
+      "2024-06-07 15:41:15.887 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4405219029995351s behind time.\n",
+      "2024-06-07 15:41:15.891 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4448192330000893s behind time.\n",
+      "2024-06-07 15:41:16.897 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.45081860599930224s behind time.\n",
+      "2024-06-07 15:41:16.900 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4537369769986981s behind time.\n",
+      "2024-06-07 15:41:16.902 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.45616749599867035s behind time.\n",
+      "2024-06-07 15:41:16.907 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.46079832299983536s behind time.\n",
+      "2024-06-07 15:41:17.912 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.46620753400020476s behind time.\n",
+      "2024-06-07 15:41:17.916 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.46948195599907194s behind time.\n",
+      "2024-06-07 15:41:17.918 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4719440389999363s behind time.\n",
+      "2024-06-07 15:41:17.921 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.47500657599994156s behind time.\n",
+      "2024-06-07 15:41:18.927 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.48144065700034844s behind time.\n",
+      "2024-06-07 15:41:18.931 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4845501620002324s behind time.\n",
+      "2024-06-07 15:41:18.933 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.48695914299969445s behind time.\n",
+      "2024-06-07 15:41:18.937 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.490648824001255s behind time.\n",
+      "2024-06-07 15:41:19.943 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.4965497180000966s behind time.\n",
+      "2024-06-07 15:41:19.946 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5000930030000745s behind time.\n",
+      "2024-06-07 15:41:19.948 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.502199844999268s behind time.\n",
+      "2024-06-07 15:41:19.951 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5047712030009279s behind time.\n",
+      "2024-06-07 15:41:20.956 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5098678060003294s behind time.\n",
+      "2024-06-07 15:41:20.959 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5134062399993127s behind time.\n",
+      "2024-06-07 15:41:20.963 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5170646360002138s behind time.\n",
+      "2024-06-07 15:41:20.966 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5200482260006538s behind time.\n",
+      "2024-06-07 15:41:21.971 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5251510460002464s behind time.\n",
+      "2024-06-07 15:41:21.974 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5279190849996667s behind time.\n",
+      "2024-06-07 15:41:21.975 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5293169069991563s behind time.\n",
+      "2024-06-07 15:41:21.977 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5310364280012436s behind time.\n",
+      "2024-06-07 15:41:22.980 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5340474980002909s behind time.\n",
+      "2024-06-07 15:41:22.982 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5360351849994913s behind time.\n",
+      "2024-06-07 15:41:22.985 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5385999089994584s behind time.\n",
+      "2024-06-07 15:41:22.989 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5428077209999174s behind time.\n",
+      "2024-06-07 15:41:23.994 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5478133029992023s behind time.\n",
+      "2024-06-07 15:41:23.997 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5509225249988958s behind time.\n",
+      "2024-06-07 15:41:24.000 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5534385729988571s behind time.\n",
+      "2024-06-07 15:41:24.003 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5565520760010259s behind time.\n",
+      "2024-06-07 15:41:25.006 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5602454149993719s behind time.\n",
+      "2024-06-07 15:41:25.008 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5624163739994401s behind time.\n",
+      "2024-06-07 15:41:25.011 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5649012449994189s behind time.\n",
+      "2024-06-07 15:41:25.014 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5677762169998459s behind time.\n",
+      "2024-06-07 15:41:26.019 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5732565140006045s behind time.\n",
+      "2024-06-07 15:41:26.023 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5768278279992956s behind time.\n",
+      "2024-06-07 15:41:26.026 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5795683540000027s behind time.\n",
+      "2024-06-07 15:41:26.029 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5831277670004056s behind time.\n",
+      "2024-06-07 15:41:27.034 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5883268870002212s behind time.\n",
+      "2024-06-07 15:41:27.037 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5913855660000991s behind time.\n",
+      "2024-06-07 15:41:27.040 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5939327729993238s behind time.\n",
+      "2024-06-07 15:41:27.044 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.5982035190008901s behind time.\n",
+      "2024-06-07 15:41:28.049 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6029032059996098s behind time.\n",
+      "2024-06-07 15:41:28.052 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6060520089995407s behind time.\n",
+      "2024-06-07 15:41:28.055 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6085094560003199s behind time.\n",
+      "2024-06-07 15:41:28.059 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6125005060002877s behind time.\n",
+      "2024-06-07 15:41:29.064 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6178621109993401s behind time.\n",
+      "2024-06-07 15:41:29.068 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6218916679990798s behind time.\n",
+      "2024-06-07 15:41:29.072 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6259414999985893s behind time.\n",
+      "2024-06-07 15:41:29.076 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6300431590007065s behind time.\n",
+      "2024-06-07 15:41:30.082 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6360496489996876s behind time.\n",
+      "2024-06-07 15:41:30.085 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6392153710003186s behind time.\n",
+      "2024-06-07 15:41:30.088 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6418221200001426s behind time.\n",
+      "2024-06-07 15:41:30.092 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6454240610000852s behind time.\n",
+      "2024-06-07 15:41:31.097 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6507047359991702s behind time.\n",
+      "2024-06-07 15:41:31.100 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6537561889999779s behind time.\n",
+      "2024-06-07 15:41:31.102 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6560739389988157s behind time.\n",
+      "2024-06-07 15:41:31.105 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6591579169999022s behind time.\n",
+      "2024-06-07 15:41:32.110 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.663872500999787s behind time.\n",
+      "2024-06-07 15:41:32.112 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6662411849993077s behind time.\n",
+      "2024-06-07 15:41:32.114 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.66788507199999s behind time.\n",
+      "2024-06-07 15:41:32.118 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.672323034999863s behind time.\n",
+      "2024-06-07 15:41:33.123 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6770962169994164s behind time.\n",
+      "2024-06-07 15:41:33.125 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6787988799987943s behind time.\n",
+      "2024-06-07 15:41:33.126 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.680351527998937s behind time.\n",
+      "2024-06-07 15:41:33.128 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.682266736001111s behind time.\n",
+      "2024-06-07 15:41:34.132 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6857943739996699s behind time.\n",
+      "2024-06-07 15:41:34.134 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.687496223999915s behind time.\n",
+      "2024-06-07 15:41:34.135 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6889175109990902s behind time.\n",
+      "2024-06-07 15:41:34.138 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6915217850000772s behind time.\n",
+      "2024-06-07 15:41:35.142 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6956163110007765s behind time.\n",
+      "2024-06-07 15:41:35.144 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6975421779989119s behind time.\n",
+      "2024-06-07 15:41:35.146 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.6998021179988427s behind time.\n",
+      "2024-06-07 15:41:35.148 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7015331290003815s behind time.\n",
+      "2024-06-07 15:41:36.152 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7057412119993387s behind time.\n",
+      "2024-06-07 15:41:36.155 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7089423750003334s behind time.\n",
+      "2024-06-07 15:41:36.157 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7104954610003915s behind time.\n",
+      "2024-06-07 15:41:36.159 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7128808600009506s behind time.\n",
+      "2024-06-07 15:41:37.164 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7175166359993455s behind time.\n",
+      "2024-06-07 15:41:37.166 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7200125449999177s behind time.\n",
+      "2024-06-07 15:41:37.168 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7219786959994963s behind time.\n",
+      "2024-06-07 15:41:37.170 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.724244193001141s behind time.\n",
+      "2024-06-07 15:41:38.174 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7280183319999196s behind time.\n",
+      "2024-06-07 15:41:38.177 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7306835079998564s behind time.\n",
+      "2024-06-07 15:41:38.178 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7322907469988422s behind time.\n",
+      "2024-06-07 15:41:38.182 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7355770340000163s behind time.\n",
+      "2024-06-07 15:41:39.188 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7414520300008007s behind time.\n",
+      "2024-06-07 15:41:39.190 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7443088820000412s behind time.\n",
+      "2024-06-07 15:41:39.193 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7468230429985852s behind time.\n",
+      "2024-06-07 15:41:39.196 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7500259389998973s behind time.\n",
+      "2024-06-07 15:41:40.202 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7554448789996968s behind time.\n",
+      "2024-06-07 15:41:40.205 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7590505039988784s behind time.\n",
+      "2024-06-07 15:41:40.208 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7615187399987917s behind time.\n",
+      "2024-06-07 15:41:40.211 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7645296919999964s behind time.\n",
+      "2024-06-07 15:41:41.213 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7670522049993451s behind time.\n",
+      "2024-06-07 15:41:41.216 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7700802099989232s behind time.\n",
+      "2024-06-07 15:41:41.219 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.773267885999303s behind time.\n",
+      "2024-06-07 15:41:41.222 | WARNING  | mosaik.scheduler:rt_check:371 - Simulation too slow for real-time factor 1.0 - 0.7763276960013172s behind time.\n",
+      "2024-06-07 15:41:41.225 | INFO     | mosaik.scenario:run:694 - Simulation finished successfully.\n"
+     ]
+    }
+   ],
    "source": [
-    "environment = Environment(sim_start=\"2022-06-09 00:00:00\")\n",
+    "environment = vs.Environment(sim_start=\"2022-06-09 00:00:00\")\n",
     "\n",
-    "monitor = Monitor()  # stores simulation result on each step\n",
-    "sil_controller = SilController(  # executes software-in-the-loop controller\n",
+    "monitor = vs.Monitor()  # stores simulation result on each step\n",
+    "sil_controller = vs.SilController(  # executes software-in-the-loop controller\n",
     "    api_routes=api_routes,\n",
     "    request_collectors={\"battery_min_soc\": battery_min_soc_collector},\n",
     ")\n",
     "environment.add_microgrid(\n",
     "    actors=[\n",
-    "        ComputingSystem(power_meters=[HttpPowerMeter(name=\"sample_app\", port=8001)]),\n",
-    "        Generator(signal=HistoricalSignal.from_dataset(\"solcast2022_global\"), column=\"Berlin\"),\n",
+    "        vs.ComputingSystem(power_meters=[HttpPowerMeter(name=\"sample_app\", port=8001)]),\n",
+    "        vs.Generator(signal=vs.HistoricalSignal.from_dataset(\"solcast2022_global\"), column=\"Berlin\"),\n",
     "    ],\n",
-    "    storage=SimpleBattery(capacity=100),\n",
+    "    storage=vs.SimpleBattery(capacity=50, initial_soc=0.8, min_soc=0.5),\n",
     "    controllers=[monitor, sil_controller],\n",
-    "    step_size=60,  # global step size (can be overridden by actors or controllers)\n",
+    "    step_size=1,  # global step size (can be overridden by actors or controllers)\n",
     ")\n",
     "\n",
-    "environment.run(until=24 * 3600, rt_factor=1, print_progress=False)\n",
-    "monitor.to_csv(\"result_csv\")"
+    "environment.run(until=60, rt_factor=1, print_progress=False)\n",
+    "monitor.to_csv(\"result.csv\")"
    ]
   },
   {
@@ -268,7 +538,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,
diff --git a/examples/util/example_node/sil_node.py b/examples/util/example_node/sil_node.py
index eed8d9e..e430c05 100644
--- a/examples/util/example_node/sil_node.py
+++ b/examples/util/example_node/sil_node.py
@@ -24,7 +24,7 @@ def _workload_sim(self):
             time.sleep(2)
 
     def start(self):
-        uvicorn.run(self.app, host="0.0.0.0", port=self.port)
+        uvicorn.run(self.app, host="127.0.0.1", port=self.port)
 
 
 if __name__ == "__main__":
diff --git a/vessim/sil.py b/vessim/sil.py
index 75fd88a..20b5d4d 100644
--- a/vessim/sil.py
+++ b/vessim/sil.py
@@ -185,10 +185,7 @@ def _collect_set_requests_loop(self):
                 event = self.events_pipe_out.recv()
                 events_by_category[event["category"]][event["time"]] = event["value"]
             for category, events in events_by_category.items():
-                self.request_collectors[category](
-                    events=events,
-                    microgrid=self.microgrid,
-                )
+                self.request_collectors[category](self, events=events)
             # Calculate elapsed time and sleep if necessary
             elapsed_time = time.monotonic() - start_time
             time_to_wait = self.request_collector_interval - elapsed_time

From 74cd7b3d3ba350e197fcc5122292bc6c064cb623 Mon Sep 17 00:00:00 2001
From: kilianp14 <kilian.paul14@gmail.com>
Date: Tue, 18 Jun 2024 12:46:08 +0200
Subject: [PATCH 5/5] Readded soc function

---
 tests/test_storage.py | 12 ++++++------
 vessim/storage.py     | 24 +++++++++++++++++-------
 2 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/tests/test_storage.py b/tests/test_storage.py
index f372f9a..5a12811 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -36,7 +36,7 @@ def test_update(self, battery, power, duration, exp_charge_energy, exp_charge_le
         charge_energy = battery.update(power=power, duration=duration * 3600)
         assert charge_energy == exp_charge_energy * 3600
         assert battery.state()["charge_level"] == exp_charge_level
-        assert math.isclose(battery.state()["soc"], exp_soc)
+        assert math.isclose(battery.soc(), exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_charge_energy, exp_charge_level, exp_soc",
@@ -68,7 +68,7 @@ def test_update_c_rate(
         charge_energy = battery_c.update(power=power, duration=duration * 60)
         assert charge_energy == exp_charge_energy * 3600
         assert battery_c.state()["charge_level"] == exp_charge_level
-        assert math.isclose(battery_c.state()["soc"], exp_soc)
+        assert math.isclose(battery_c.soc(), exp_soc)
 
     def test_update_fails_if_duration_not_positive(self, battery):
         with pytest.raises(ValueError):
@@ -113,7 +113,7 @@ def test_apply_no_charge_mode(self, battery, policy, power, duration, exp_delta,
         # duration in hours and energy delta in Wh
         delta = policy.apply(power, duration * 3600, battery)
         assert delta == exp_delta * 3600
-        assert math.isclose(battery.state()["soc"], exp_soc)
+        assert math.isclose(battery.soc(), exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_delta, exp_soc",
@@ -136,7 +136,7 @@ def test_apply_charge(self, battery, policy_charge, power, duration, exp_delta,
         # duration in hours and energy delta in Wh
         delta = policy_charge.apply(power, duration * 3600, battery)
         assert delta == exp_delta * 3600
-        assert math.isclose(battery.state()["soc"], exp_soc)
+        assert math.isclose(battery.soc(), exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_delta, exp_soc",
@@ -159,7 +159,7 @@ def test_apply_discharge(self, battery, policy_discharge, power, duration, exp_d
         # duration in hours and energy delta in Wh
         delta = policy_discharge.apply(power, duration * 3600, battery)
         assert delta == exp_delta * 3600
-        assert math.isclose(battery.state()["soc"], exp_soc)
+        assert math.isclose(battery.soc(), exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_delta, exp_soc",
@@ -178,7 +178,7 @@ def test_apply_islanded(self, battery, policy_islanded, power, duration, exp_del
         # duration in hours and energy delta in Wh
         delta = policy_islanded.apply(power, duration * 3600, battery)
         assert delta == exp_delta * 3600
-        assert math.isclose(battery.state()["soc"], exp_soc)
+        assert math.isclose(battery.soc(), exp_soc)
 
     @pytest.mark.parametrize(
         "power, duration, exp_delta",
diff --git a/vessim/storage.py b/vessim/storage.py
index 7925d21..88ceb8d 100644
--- a/vessim/storage.py
+++ b/vessim/storage.py
@@ -18,6 +18,13 @@ def update(self, power: float, duration: int) -> float:
             The total energy in Ws that has been charged/discharged.
         """
 
+    @abstractmethod
+    def soc(self) -> float:
+        """Returns the state-of-charge (SoC) of the battery.
+
+        Values should range between 0 (empty) and 1 (full).
+        """
+
     def set_parameter(self, key: str, value: Any) -> None:
         """Fuction to let a controller update a storage parameter during a simulation using Mosaik.
 
@@ -56,8 +63,8 @@ def __init__(
         self.capacity = capacity
         assert 0 <= initial_soc <= 1
         self.charge_level = capacity * initial_soc
-        self.soc = initial_soc
-        assert 0 <= min_soc <= self.soc
+        self._soc = initial_soc
+        assert 0 <= min_soc <= self._soc
         self.min_soc = min_soc
         self.c_rate = c_rate
 
@@ -72,7 +79,7 @@ def update(self, power: float, duration: int) -> float:
         if duration <= 0.0:
             raise ValueError("Duration needs to be a positive value")
 
-        assert self.min_soc <= self.soc, "Minimum SoC can not be smaller than the current SoC"
+        assert self.min_soc <= self._soc, "Minimum SoC can not be smaller than the current SoC"
         if self.c_rate is not None:
             max_power = self.c_rate * self.capacity
             if power >= max_power:
@@ -99,22 +106,25 @@ def update(self, power: float, duration: int) -> float:
             # Battery can not be discharged further than the minimum state-of-charge
             charged_energy = abs_min_soc - self.charge_level
             self.charge_level = abs_min_soc
-            self.soc = self.min_soc
+            self._soc = self.min_soc
         elif new_charge_level > self.capacity:
             # Battery can not be charged past its capacity
             charged_energy = self.capacity - self.charge_level
             self.charge_level = self.capacity
-            self.soc = 1.0
+            self._soc = 1.0
         else:
             self.charge_level = new_charge_level
-            self.soc = self.charge_level / self.capacity
+            self._soc = self.charge_level / self.capacity
 
         return charged_energy * 3600  # Wh to Ws
 
+    def soc(self) -> float:
+        return self._soc
+
     def state(self) -> dict:
         """Returns state information of the battery as a dict."""
         return {
-            "soc": self.soc,
+            "soc": self._soc,
             "charge_level": self.charge_level,
             "capacity": self.capacity,
             "min_soc": self.min_soc,