From 189836408f5f54905a989a17694294f06c69e336 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=2E=20Fernando=20S=C3=A1nchez?= <balkian@gmail.com>
Date: Fri, 19 May 2023 16:19:50 +0200
Subject: [PATCH] Add rescheduling for received

---
 benchmarks/noop/_config.py               |   1 +
 benchmarks/noop/mesa_batchrunner.py      |   1 -
 benchmarks/noop/mesa_simulation.py       |   1 -
 benchmarks/noop/soil_state.py            |  21 +++
 benchmarks/noop/soil_step.py             |   9 +-
 benchmarks/noop/soilent_async.py         |   6 +-
 benchmarks/noop/soilent_async_pqueue.py  |   6 +-
 benchmarks/noop/soilent_gens.py          |   6 +-
 benchmarks/noop/soilent_gens_pqueue.py   |   6 +-
 benchmarks/noop/soilent_state.py         |  30 ++++
 benchmarks/noop/soilent_step.py          |   6 +-
 benchmarks/noop/soilent_step_pqueue.py   |   6 +-
 benchmarks/virusonnetwork/_config.py     |  22 ++-
 benchmarks/virusonnetwork/mesa_basic.py  |   2 +-
 benchmarks/virusonnetwork/soil_states.py |  21 ++-
 benchmarks/virusonnetwork/soil_step.py   |   6 +-
 docs/tutorial/soil_tutorial.ipynb        | 187 ++++++++++++++++-------
 examples/rabbits/rabbit_improved_sim.py  |   2 +-
 examples/rabbits/rabbits_basic_sim.py    |   6 +-
 soil/__init__.py                         |   1 -
 soil/agents/__init__.py                  |  21 +--
 soil/agents/evented.py                   |   2 +-
 soil/agents/fsm.py                       |  71 ++++++---
 soil/agents/meta.py                      |  77 ++++------
 soil/agents/view.py                      |   3 +
 soil/analysis.py                         |   7 +-
 soil/decorators.py                       |  38 ++++-
 soil/environment.py                      |  76 +++++++--
 soil/exporters.py                        |  25 +--
 soil/simulation.py                       |  22 +--
 soil/time.py                             |  53 +++++--
 soil/utils.py                            |   4 +-
 tests/test_agents.py                     | 153 +++++++++++++++++--
 tests/test_main.py                       |  36 ++++-
 34 files changed, 674 insertions(+), 260 deletions(-)
 create mode 100644 benchmarks/noop/soil_state.py
 create mode 100644 benchmarks/noop/soilent_state.py

diff --git a/benchmarks/noop/_config.py b/benchmarks/noop/_config.py
index f6e5486..c43248d 100644
--- a/benchmarks/noop/_config.py
+++ b/benchmarks/noop/_config.py
@@ -11,6 +11,7 @@ def run_sim(model, **kwargs):
                 dump=False,
                 num_processes=1,
                 parameters={'num_agents': NUM_AGENTS},
+                seed="",
                 max_steps=MAX_STEPS,
                 iterations=NUM_ITERS)
     opts.update(kwargs)
diff --git a/benchmarks/noop/mesa_batchrunner.py b/benchmarks/noop/mesa_batchrunner.py
index 326691f..a6a23ab 100644
--- a/benchmarks/noop/mesa_batchrunner.py
+++ b/benchmarks/noop/mesa_batchrunner.py
@@ -8,7 +8,6 @@ class NoopAgent(Agent):
         self.num_calls = 0
 
     def step(self):
-        # import pdb;pdb.set_trace()
         self.num_calls += 1 
 
 
diff --git a/benchmarks/noop/mesa_simulation.py b/benchmarks/noop/mesa_simulation.py
index 7da7e85..4cc45e3 100644
--- a/benchmarks/noop/mesa_simulation.py
+++ b/benchmarks/noop/mesa_simulation.py
@@ -10,7 +10,6 @@ class NoopAgent(Agent):
         self.num_calls = 0
 
     def step(self):
-        # import pdb;pdb.set_trace()
         self.num_calls += 1 
 
 
diff --git a/benchmarks/noop/soil_state.py b/benchmarks/noop/soil_state.py
new file mode 100644
index 0000000..dcb9644
--- /dev/null
+++ b/benchmarks/noop/soil_state.py
@@ -0,0 +1,21 @@
+from soil import Agent, Environment, Simulation, state
+
+
+class NoopAgent(Agent):
+    num_calls = 0
+
+    @state(default=True)
+    def unique(self):
+        self.num_calls += 1
+
+class NoopEnvironment(Environment):
+    num_agents = 100
+
+    def init(self):
+        self.add_agents(NoopAgent, k=self.num_agents)
+        self.add_agent_reporter("num_calls")
+
+
+from _config import *
+
+run_sim(model=NoopEnvironment)
diff --git a/benchmarks/noop/soil_step.py b/benchmarks/noop/soil_step.py
index 2f362c7..7d567f2 100644
--- a/benchmarks/noop/soil_step.py
+++ b/benchmarks/noop/soil_step.py
@@ -1,7 +1,7 @@
-from soil import BaseAgent, Environment, Simulation
+from soil import Agent, Environment, Simulation
 
 
-class NoopAgent(BaseAgent):
+class NoopAgent(Agent):
     num_calls = 0
 
     def step(self):
@@ -15,7 +15,6 @@ class NoopEnvironment(Environment):
         self.add_agent_reporter("num_calls")
 
 
-if __name__ == "__main__":
-    from _config import *
+from _config import *
 
-    run_sim(model=NoopEnvironment)
+run_sim(model=NoopEnvironment)
diff --git a/benchmarks/noop/soilent_async.py b/benchmarks/noop/soilent_async.py
index f3027c9..34e81b4 100644
--- a/benchmarks/noop/soilent_async.py
+++ b/benchmarks/noop/soilent_async.py
@@ -1,5 +1,5 @@
 from soil import Agent, Environment, Simulation
-from soilent import Scheduler
+from soil.time import SoilentActivation
 
 
 class NoopAgent(Agent):
@@ -14,7 +14,7 @@ class NoopAgent(Agent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = Scheduler
+    schedule_class = SoilentActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -26,4 +26,4 @@ if __name__ == "__main__":
 
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, Scheduler)
+        assert isinstance(r.schedule, SoilentActivation)
diff --git a/benchmarks/noop/soilent_async_pqueue.py b/benchmarks/noop/soilent_async_pqueue.py
index 37a41d8..a542410 100644
--- a/benchmarks/noop/soilent_async_pqueue.py
+++ b/benchmarks/noop/soilent_async_pqueue.py
@@ -1,5 +1,5 @@
 from soil import Agent, Environment
-from soilent import PQueueScheduler
+from soil.time import SoilentPQueueActivation
 
 
 class NoopAgent(Agent):
@@ -12,7 +12,7 @@ class NoopAgent(Agent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = PQueueScheduler
+    schedule_class = SoilentPQueueActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -24,4 +24,4 @@ if __name__ == "__main__":
 
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, PQueueScheduler)
+        assert isinstance(r.schedule, SoilentPQueueActivation)
diff --git a/benchmarks/noop/soilent_gens.py b/benchmarks/noop/soilent_gens.py
index 823966f..f138b5c 100644
--- a/benchmarks/noop/soilent_gens.py
+++ b/benchmarks/noop/soilent_gens.py
@@ -1,5 +1,5 @@
 from soil import Agent, Environment, Simulation
-from soilent import Scheduler
+from soil.time import SoilentActivation
 
 
 class NoopAgent(Agent):
@@ -13,7 +13,7 @@ class NoopAgent(Agent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = Scheduler
+    schedule_class = SoilentActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -25,4 +25,4 @@ if __name__ == "__main__":
 
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, Scheduler)
+        assert isinstance(r.schedule, SoilentActivation)
diff --git a/benchmarks/noop/soilent_gens_pqueue.py b/benchmarks/noop/soilent_gens_pqueue.py
index 5545dc9..1c01384 100644
--- a/benchmarks/noop/soilent_gens_pqueue.py
+++ b/benchmarks/noop/soilent_gens_pqueue.py
@@ -1,5 +1,5 @@
 from soil import Agent, Environment
-from soilent import PQueueScheduler
+from soil.time import SoilentPQueueActivation
 
 
 class NoopAgent(Agent):
@@ -13,7 +13,7 @@ class NoopAgent(Agent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = PQueueScheduler
+    schedule_class = SoilentPQueueActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -25,4 +25,4 @@ if __name__ == "__main__":
 
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, PQueueScheduler)
+        assert isinstance(r.schedule, SoilentPQueueActivation)
diff --git a/benchmarks/noop/soilent_state.py b/benchmarks/noop/soilent_state.py
new file mode 100644
index 0000000..2954a82
--- /dev/null
+++ b/benchmarks/noop/soilent_state.py
@@ -0,0 +1,30 @@
+from soil import Agent, Environment, Simulation, state
+from soil.time import SoilentActivation
+
+
+class NoopAgent(Agent):
+    num_calls = 0
+
+    @state(default=True)
+    async def unique(self):
+        while True:
+            self.num_calls += 1
+            # yield self.delay(1)
+            await self.delay()
+
+
+class NoopEnvironment(Environment):
+    num_agents = 100
+    schedule_class = SoilentActivation
+
+    def init(self):
+        self.add_agents(NoopAgent, k=self.num_agents)
+        self.add_agent_reporter("num_calls")
+
+
+if __name__ == "__main__":
+    from _config import *
+
+    res = run_sim(model=NoopEnvironment)
+    for r in res:
+        assert isinstance(r.schedule, SoilentActivation)
diff --git a/benchmarks/noop/soilent_step.py b/benchmarks/noop/soilent_step.py
index 9c766f2..285400d 100644
--- a/benchmarks/noop/soilent_step.py
+++ b/benchmarks/noop/soilent_step.py
@@ -1,5 +1,5 @@
 from soil import BaseAgent, Environment, Simulation
-from soilent import Scheduler
+from soil.time import SoilentActivation
 
 
 class NoopAgent(BaseAgent):
@@ -10,7 +10,7 @@ class NoopAgent(BaseAgent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = Scheduler
+    schedule_class = SoilentActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -21,4 +21,4 @@ if __name__ == "__main__":
     from _config import *
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, Scheduler)
+        assert isinstance(r.schedule, SoilentActivation)
diff --git a/benchmarks/noop/soilent_step_pqueue.py b/benchmarks/noop/soilent_step_pqueue.py
index 50dca26..ab74012 100644
--- a/benchmarks/noop/soilent_step_pqueue.py
+++ b/benchmarks/noop/soilent_step_pqueue.py
@@ -1,5 +1,5 @@
 from soil import BaseAgent, Environment, Simulation
-from soilent import PQueueScheduler
+from soil.time import SoilentPQueueActivation
 
 
 class NoopAgent(BaseAgent):
@@ -10,7 +10,7 @@ class NoopAgent(BaseAgent):
 
 class NoopEnvironment(Environment):
     num_agents = 100
-    schedule_class = PQueueScheduler
+    schedule_class = SoilentPQueueActivation
 
     def init(self):
         self.add_agents(NoopAgent, k=self.num_agents)
@@ -21,4 +21,4 @@ if __name__ == "__main__":
     from _config import *
     res = run_sim(model=NoopEnvironment)
     for r in res:
-        assert isinstance(r.schedule, PQueueScheduler)
+        assert isinstance(r.schedule, SoilentPqueueActivation)
diff --git a/benchmarks/virusonnetwork/_config.py b/benchmarks/virusonnetwork/_config.py
index 79c6751..4c2ef38 100644
--- a/benchmarks/virusonnetwork/_config.py
+++ b/benchmarks/virusonnetwork/_config.py
@@ -1,8 +1,9 @@
 import os
+from soil import simulation
 
 NUM_AGENTS = int(os.environ.get('NUM_AGENTS', 100))
 NUM_ITERS = int(os.environ.get('NUM_ITERS', 10))
-MAX_STEPS = int(os.environ.get('MAX_STEPS', 1000))
+MAX_STEPS = int(os.environ.get('MAX_STEPS', 500))
 
 
 def run_sim(model, **kwargs):
@@ -22,11 +23,16 @@ def run_sim(model, **kwargs):
                 iterations=NUM_ITERS)
     opts.update(kwargs)
     its = Simulation(**opts).run()
+    assert len(its) == NUM_ITERS
 
-    assert all(it.schedule.steps == MAX_STEPS for it in its)
-    ratios = list(it.resistant_susceptible_ratio() for it in its)
-    print("Max - Avg - Min ratio:", max(ratios), sum(ratios)/len(ratios), min(ratios))
-    assert all(sum([it.number_susceptible,
-                    it.number_infected,
-                    it.number_resistant]) == NUM_AGENTS for it in its)
-    return its
\ No newline at end of file
+    if not simulation._AVOID_RUNNING:
+        ratios = list(it.resistant_susceptible_ratio for it in its)
+        print("Max - Avg - Min ratio:", max(ratios), sum(ratios)/len(ratios), min(ratios))
+        infected = list(it.number_infected for it in its)
+        print("Max - Avg - Min infected:", max(infected), sum(infected)/len(infected), min(infected))
+
+        assert all((it.schedule.steps == MAX_STEPS or it.number_infected == 0) for it in its)
+        assert all(sum([it.number_susceptible,
+                        it.number_infected,
+                        it.number_resistant]) == NUM_AGENTS for it in its)
+    return its
diff --git a/benchmarks/virusonnetwork/mesa_basic.py b/benchmarks/virusonnetwork/mesa_basic.py
index a7d4a41..b34b074 100644
--- a/benchmarks/virusonnetwork/mesa_basic.py
+++ b/benchmarks/virusonnetwork/mesa_basic.py
@@ -100,6 +100,7 @@ class VirusOnNetwork(mesa.Model):
     def number_infected(self):
         return number_infected(self)
 
+    @property
     def resistant_susceptible_ratio(self):
         try:
             return number_state(self, State.RESISTANT) / number_state(
@@ -176,5 +177,4 @@ class VirusAgent(mesa.Agent):
 
 
 from _config import run_sim
-
 run_sim(model=VirusOnNetwork)
\ No newline at end of file
diff --git a/benchmarks/virusonnetwork/soil_states.py b/benchmarks/virusonnetwork/soil_states.py
index 266843a..522ba76 100644
--- a/benchmarks/virusonnetwork/soil_states.py
+++ b/benchmarks/virusonnetwork/soil_states.py
@@ -30,8 +30,12 @@ class VirusOnNetwork(Environment):
         for a in self.agents(node_id=infected_nodes):
             a.set_state(VirusAgent.infected)
         assert self.number_infected == self.initial_outbreak_size
+    
+    def step(self):
+        super().step()
 
     @report
+    @property
     def resistant_susceptible_ratio(self):
         try:
             return self.number_resistant / self.number_susceptible
@@ -59,34 +63,29 @@ class VirusAgent(Agent):
     virus_check_frequency = None # Inherit from model
     recovery_chance = None # Inherit from model
     gain_resistance_chance = None # Inherit from model
-    just_been_infected = False
 
     @state(default=True)
-    def susceptible(self):
-        if self.just_been_infected:
-            self.just_been_infected = False
-            return self.infected
+    async def susceptible(self):
+        await self.received()
+        return self.infected
 
     @state
     def infected(self):
         susceptible_neighbors = self.get_neighbors(state_id=self.susceptible.id)
         for a in susceptible_neighbors:
             if self.prob(self.virus_spread_chance):
-                a.just_been_infected = True
+                a.tell(True, sender=self)
         if self.prob(self.virus_check_frequency):
             if self.prob(self.recovery_chance):
                 if self.prob(self.gain_resistance_chance):
                     return self.resistant
                 else:
                     return self.susceptible
-            else:
-                return self.infected
 
     @state
     def resistant(self):
         return self.at(INFINITY)
 
 
-if __name__ == "__main__":
-    from _config import run_sim
-    run_sim(model=VirusOnNetwork)
\ No newline at end of file
+from _config import run_sim
+run_sim(model=VirusOnNetwork)
\ No newline at end of file
diff --git a/benchmarks/virusonnetwork/soil_step.py b/benchmarks/virusonnetwork/soil_step.py
index 1b91b2a..33be1a5 100644
--- a/benchmarks/virusonnetwork/soil_step.py
+++ b/benchmarks/virusonnetwork/soil_step.py
@@ -38,6 +38,7 @@ class VirusOnNetwork(Environment):
         assert self.number_infected == self.initial_outbreak_size
 
     @report
+    @property
     def resistant_susceptible_ratio(self):
         try:
             return self.number_resistant / self.number_susceptible
@@ -99,6 +100,5 @@ class VirusAgent(Agent):
 
 
 
-if __name__ == "__main__":
-    from _config import run_sim
-    run_sim(model=VirusOnNetwork)
\ No newline at end of file
+from _config import run_sim
+run_sim(model=VirusOnNetwork)
\ No newline at end of file
diff --git a/docs/tutorial/soil_tutorial.ipynb b/docs/tutorial/soil_tutorial.ipynb
index 5cb3349..77cb336 100644
--- a/docs/tutorial/soil_tutorial.ipynb
+++ b/docs/tutorial/soil_tutorial.ipynb
@@ -454,7 +454,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6f87549b81a84699900e5398ba5df413",
+       "model_id": "14d3f5ae767b4e4f88363ac8a60e5fb6",
        "version_major": 2,
        "version_minor": 0
       },
@@ -468,7 +468,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "27ce4ef734f6465f8a8cddd09a82aa1d",
+       "model_id": "25cf679897634ee69b9dbfe5fb2a14b4",
        "version_major": 2,
        "version_minor": 0
       },
@@ -627,7 +627,7 @@
    },
    "outputs": [],
    "source": [
-    "class NewsSpread(Agent):\n",
+    "class Viewer(Agent):\n",
     "    has_tv = False\n",
     "    infected_by_friends = False\n",
     "    \n",
@@ -681,7 +681,7 @@
     }
    ],
    "source": [
-    "NewsSpread.states()"
+    "Viewer.states()"
    ]
   },
   {
@@ -719,7 +719,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -763,7 +763,7 @@
     "    def init(self):\n",
     "        self.add_agent(EventGenerator)\n",
     "        self.G = generate_simple()\n",
-    "        self.populate_network(NewsSpread)\n",
+    "        self.populate_network(Viewer)\n",
     "        self.agent(node_id=0).has_tv = True\n",
     "        self.add_model_reporter('prob_tv_spread')\n",
     "        self.add_model_reporter('prob_neighbor_spread')"
@@ -780,7 +780,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a0ec3c65dc1f43cbac69d651ba4a1d52",
+       "model_id": "27211fdd070a4f768905e5d2187e79a3",
        "version_major": 2,
        "version_minor": 0
       },
@@ -794,7 +794,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c8c077d73a5c4c868cb30c43fdc5120c",
+       "model_id": "5c601a54aed4437c9a0f394e1f7cbc70",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1118,11 +1118,12 @@
     "            opts[\"m\"] = 2\n",
     "        self.create_network(generator=self.generator, **opts)\n",
     "\n",
-    "        self.populate_network([NewsSpread,\n",
-    "                               NewsSpread.w(has_tv=True)],\n",
+    "        self.populate_network([Viewer,\n",
+    "                               Viewer.w(has_tv=True)], # Part of the population has a TV\n",
     "                              [1-self.prob_tv, self.prob_tv])\n",
     "        self.add_model_reporter('prob_tv_spread')\n",
     "        self.add_model_reporter('prob_neighbor_spread')\n",
+    "        self.add_agent_reporter(\"has_tv\")\n",
     "        self.add_agent_reporter('state_id', lambda a: getattr(a, \"state_id\", None))"
    ]
   },
@@ -1147,13 +1148,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[INFO ][17:13:25] Output directory: /mnt/data/home/j/git/lab.gsi/soil/soil/docs/tutorial/soil_output\n"
+      "[INFO ][12:53:35] Output directory: /mnt/data/home/j/git/lab.gsi/soil/soil/docs/tutorial/soil_output\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a464d1f51eb44e02bf1a686cd7fa6c6e",
+       "model_id": "7b3f78c10bbf4e6cb3e22c7f8dd57915",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1176,7 +1177,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6fd9e62306a843a9a9d7e62299d0ed5d",
+       "model_id": "e7564141ee0544e380424251250fbcd4",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1199,7 +1200,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5b78dc37d1b04ea59b8047f92be52d08",
+       "model_id": "45750d718d9040799fa4e661a87da5da",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1222,7 +1223,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "34aa57dae29f4e39a424fdb4a81eb082",
+       "model_id": "faaebcb11afe4788a1120ba2732fd0ee",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1245,7 +1246,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "861293f830944ef2816dab34753eb7ce",
+       "model_id": "ee88cccc76fd44729b52abb4aee20f07",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1268,7 +1269,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "fdeb39e180ee443e8d3ee4cf38622691",
+       "model_id": "32dfb0a600f04bae9cc1fcbd99793cd1",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1291,7 +1292,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f18cfb2d7148469b8274f0ba4678ac21",
+       "model_id": "d20c600aba3143ee91408f54af0d82dd",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1314,7 +1315,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8d026960ec51460095d9453c6aaf42e4",
+       "model_id": "06bb40219baf496f996ce51f0d9cf2e5",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1337,7 +1338,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aad1914202cd4dec99658d703a20e040",
+       "model_id": "3e8c135a383f41beba10992aaa384fab",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1360,7 +1361,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "dc32f62b2d65413d9582f8a0da23c1fe",
+       "model_id": "53078ae627a54c729ccffd2ecc189b17",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1383,7 +1384,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "78d7c50814394e47bc0b06c065e785ac",
+       "model_id": "a8abd731892148e0b88c25717727f9df",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1419,6 +1420,50 @@
     "assert len(it) == len(probabilities) * len(generators) * DEFAULT_ITERATIONS"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False    2821\n",
+       "True      279\n",
+       "Name: has_tv, dtype: int64"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "it[0].agent_df().has_tv.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "neutral     3000\n",
+       "infected     100\n",
+       "Name: state_id, dtype: int64"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "it[0].agent_df().state_id.value_counts()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {
@@ -1438,7 +1483,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-11-01T14:05:56.404540Z",
@@ -1458,7 +1503,7 @@
       "    └── newspread.sqlite\n",
       "\n",
       "1 directory, 1 file\n",
-      "4.5M\tsoil_output/newspread\n"
+      "4.6M\tsoil_output/newspread\n"
      ]
     }
    ],
@@ -1537,7 +1582,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 17,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-10-19T15:57:44.101253Z",
@@ -1564,7 +1609,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -1593,7 +1638,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "neutral     136410\n",
+       "infected     18590\n",
+       "Name: state_id, dtype: int64"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res.agents.state_id.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
    "metadata": {
     "hideCode": false,
     "hidePrompt": false
@@ -1601,7 +1668,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHHCAYAAABtF1i4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAADI4ElEQVR4nOzdd3gUVdvA4d+W7Kb3BiEQOoRO6BZaMKAiKKLiq0hVFFBAVHhVUEADKk1FsQKCFUTk/QBpUqQLCFJClRBKCi092TrfH5ENSzokbMpzX9deZmfOzHlmMZlnzzlzjkpRFAUhhBBCCAdROzoAIYQQQlRtkowIIYQQwqEkGRFCCCGEQ0kyIoQQQgiHkmRECCGEEA4lyYgQQgghHEqSESGEEEI4lCQjQgghhHAoSUaEEEII4VCSjAjhYG+99RYqlcohdf/555906tQJNzc3VCoVBw4cyLfc5s2bUalUbN68+ZbqSUxM5NFHH8XPzw+VSsWcOXNuOeY77XavXQhRNElGhLjJwoULUalUtpdWqyUkJIRBgwZx4cKFWzpnZmYmb731Vrm6oZlMJvr378/Vq1eZPXs2ixcvplatWmVS19ixY1m7di0TJ05k8eLF9OzZs9TrePfdd1mxYkWpn1cIUfa0jg5AiPJqypQp1K5dm+zsbHbt2sXChQvZtm0bhw8fxtnZuUTnyszM5O233wagS5cudvveeOMNJkyYUFphF9vp06c5e/YsX3zxBcOGDSu07L333ktWVhY6ne6W6vr999/p06cP48ePv6Xji+Pdd9/l0UcfpW/fvmVWhxCibEgyIkQBevXqRZs2bQAYNmwY/v7+zJgxg5UrV/LYY4+VWj1arRat9s7/KiYlJQHg7e1dZFm1Wl3iBOzmuopTj7h9VqsVo9F4W/9eQtxp0k0jRDHdc889QE6LwnVGo5FJkyYRERGBl5cXbm5u3HPPPWzatMlWJjY2loCAAADefvttW/fPW2+9BeQ/ZsRsNjN16lTq1q2LXq8nLCyM//73vxgMhmLF+vvvv3PPPffg5uaGt7c3ffr0ISYmxrZ/0KBBdO7cGYD+/fujUqnytNjcKL9xE126dKFp06YcPXqUrl274urqSkhICO+9956tzPUuL0VRmDdvnu3ar0tOTmbMmDGEhoai1+upV68eM2bMwGq12tVvtVqZO3cuzZo1w9nZmYCAAHr27MnevXsBUKlUZGRksGjRIlsdgwYNsh1/4cIFhgwZQlBQEHq9niZNmvD111/nuc7z58/Tt29f3NzcCAwMZOzYscX+zAcNGkRYWFie7fn9+65fv567774bb29v3N3dadiwIf/973/tyhgMBiZPnky9evXQ6/WEhoby6quv5olHpVIxatQovv32W5o0aYJer+e3334D4IcffiAiIgIPDw88PT1p1qwZc+fOLdb1CHEnScuIEMUUGxsLgI+Pj21bamoqX375JQMGDGD48OGkpaXx1VdfERUVxZ49e2jZsiUBAQF8+umnPP/88zz88MM88sgjADRv3rzAuoYNG8aiRYt49NFHefnll9m9ezfR0dHExMTwyy+/FBrnhg0b6NWrF3Xq1OGtt94iKyuLjz76iLvuuov9+/cTFhbGc889R0hICO+++y4vvvgibdu2JSgoqMSfybVr1+jZsyePPPIIjz32GMuWLeO1116jWbNm9OrVi3vvvZfFixfz9NNP06NHDwYOHGg7NjMzk86dO3PhwgWee+45atasyY4dO5g4cSLx8fF2g1yHDh3KwoUL6dWrF8OGDcNsNvPHH3+wa9cu2rRpw+LFixk2bBjt2rXj2WefBaBu3bpAzuDZDh062G7aAQEBrFmzhqFDh5KamsqYMWMAyMrKonv37sTFxfHiiy9SvXp1Fi9ezO+//17iz6UwR44c4cEHH6R58+ZMmTIFvV7PqVOn2L59u62M1WrloYceYtu2bTz77LM0btyYQ4cOMXv2bE6cOJFnbMzvv//OTz/9xKhRo/D39ycsLIz169czYMAAunfvzowZMwCIiYlh+/btvPTSS6V6TULcNkUIYWfBggUKoGzYsEG5dOmScu7cOWXZsmVKQECAotfrlXPnztnKms1mxWAw2B1/7do1JSgoSBkyZIht26VLlxRAmTx5cp76Jk+erNz4q3jgwAEFUIYNG2ZXbvz48Qqg/P7774XG37JlSyUwMFC5cuWKbdvBgwcVtVqtDBw40LZt06ZNCqAsXbq08A/khrKbNm2ybevcubMCKN98841tm8FgUIKDg5V+/frZHQ8oI0eOtNs2depUxc3NTTlx4oTd9gkTJigajUaJi4tTFEVRfv/9dwVQXnzxxTxxWa1W289ubm7KM888k6fM0KFDlWrVqimXL1+22/7EE08oXl5eSmZmpqIoijJnzhwFUH766SdbmYyMDKVevXp5rj0/zzzzjFKrVq0822/+9509e7YCKJcuXSrwXIsXL1bUarXyxx9/2G2fP3++Aijbt2+3bQMUtVqtHDlyxK7sSy+9pHh6eipms7nQuIUoD6SbRogCREZGEhAQQGhoKI8++ihubm6sXLmSGjVq2MpoNBrboE6r1crVq1cxm820adOG/fv331K9q1evBmDcuHF2219++WUAVq1aVeCx8fHxHDhwgEGDBuHr62vb3rx5c3r06GE7d2lxd3fnqaeesr3X6XS0a9eOf/75p8hjly5dyj333IOPjw+XL1+2vSIjI7FYLGzduhWAn3/+GZVKxeTJk/Oco6hHohVF4eeff6Z3794oimJXT1RUFCkpKbZ/p9WrV1OtWjUeffRR2/Gurq62lpbScn3szK+//pqnO+q6pUuX0rhxYxo1amQXc7du3QDsugEBOnfuTHh4eJ56MjIyWL9+fanGL0RZkGREiALMmzeP9evXs2zZMu6//34uX76MXq/PU27RokU0b94cZ2dn/Pz8CAgIYNWqVaSkpNxSvWfPnkWtVlOvXj277cHBwXh7e3P27NlCjwVo2LBhnn2NGzfm8uXLZGRk3FJc+alRo0aehMDHx4dr164VeezJkyf57bffCAgIsHtFRkYCuQNsT58+TfXq1e2Sq+K6dOkSycnJfP7553nqGTx4sF09Z8+epV69enmuJ7/P8nY8/vjj3HXXXQwbNoygoCCeeOIJfvrpJ7vE5OTJkxw5ciRPzA0aNLCL+bratWvnqeeFF16gQYMG9OrVixo1ajBkyBDbWBIhyhsZMyJEAdq1a2d7mqZv377cfffdPPnkkxw/fhx3d3cAlixZwqBBg+jbty+vvPIKgYGBaDQaoqOj7Qa63gpHTYRWEhqNJt/tiqIUeazVaqVHjx68+uqr+e6/fuO9Hddv8E899RTPPPNMvmUKG7tTEgX9e1ksFrv3Li4ubN26lU2bNrFq1Sp+++03fvzxR7p168a6devQaDRYrVaaNWvGrFmz8j1naGhonnPeLDAwkAMHDrB27VrWrFnDmjVrWLBgAQMHDmTRokW3eJVClA1JRoQohusJRteuXfn4449t84IsW7aMOnXqsHz5crub0c1dCiVJLGrVqoXVauXkyZM0btzYtj0xMZHk5ORCJya7vu/48eN59h07dgx/f3/c3NyKHUtZqlu3Lunp6baWkMLKrV27lqtXrxbaOpLfZxwQEICHhwcWi6XIemrVqsXhw4dRFMXuXPl9lvnx8fEhOTk5z/b8WrLUajXdu3ene/fuzJo1i3fffZfXX3+dTZs2ERkZSd26dTl48CDdu3e/raRUp9PRu3dvevfujdVq5YUXXuCzzz7jzTffzNPyJoQjSTeNEMXUpUsX2rVrx5w5c8jOzgZyWwZubAnYvXs3O3futDvW1dUVIN+b1c3uv/9+gDxTpl//lvzAAw8UeGy1atVo2bIlixYtsqvr8OHDrFu3znbu8uCxxx5j586drF27Ns++5ORkzGYzAP369UNRFNukcTe68XN3c3PL8/lqNBr69evHzz//zOHDh/Mcf+nSJdvP999/PxcvXmTZsmW2bZmZmXz++efFup66deuSkpLC33//bdsWHx+f5+mnq1ev5jm2ZcuWALbHdh977DEuXLjAF198kadsVlZWsbrarly5YvderVbbWoGK+7iyEHeKtIwIUQKvvPIK/fv3Z+HChYwYMYIHH3yQ5cuX8/DDD/PAAw9w5swZ5s+fT3h4OOnp6bbjXFxcCA8P58cff6RBgwb4+vrStGlTmjZtmqeOFi1a8Mwzz/D555+TnJxM586d2bNnD4sWLaJv37507dq10Bjff/99evXqRceOHRk6dKjt0V4vLy/b3CblwSuvvMLKlSt58MEHGTRoEBEREWRkZHDo0CGWLVtGbGws/v7+dO3alaeffpoPP/yQkydP0rNnT6xWK3/88Qddu3Zl1KhRAERERLBhwwZmzZpF9erVqV27Nu3bt2f69Ols2rSJ9u3bM3z4cMLDw7l69Sr79+9nw4YNtuRg+PDhfPzxxwwcOJB9+/ZRrVo1Fi9ebEski/LEE0/w2muv8fDDD/Piiy+SmZnJp59+SoMGDewGM0+ZMoWtW7fywAMPUKtWLZKSkvjkk0+oUaMGd999NwBPP/00P/30EyNGjGDTpk3cddddWCwWjh07xk8//cTatWttXYgFGTZsGFevXqVbt27UqFGDs2fP8tFHH9GyZUu7FjchygUHPskjRLl0/dHeP//8M88+i8Wi1K1bV6lbt65iNpsVq9WqvPvuu0qtWrUUvV6vtGrVSvm///u/fB/z3LFjhxIREaHodDq7x3xvfvRTURTFZDIpb7/9tlK7dm3FyclJCQ0NVSZOnKhkZ2cX6xo2bNig3HXXXYqLi4vi6emp9O7dWzl69KhdmdJ4tLdJkyZ5yuZ37eTzaK+iKEpaWpoyceJEpV69eopOp1P8/f2VTp06KR988IFiNBpt5cxms/L+++8rjRo1UnQ6nRIQEKD06tVL2bdvn63MsWPHlHvvvVdxcXFRALvHfBMTE5WRI0cqoaGhipOTkxIcHKx0795d+fzzz+3iOXv2rPLQQw8prq6uir+/v/LSSy8pv/32W7Ee7VUURVm3bp3StGlTRafTKQ0bNlSWLFmS599348aNSp8+fZTq1asrOp1OqV69ujJgwIA8jzgbjUZlxowZSpMmTRS9Xq/4+PgoERERyttvv62kpKQU+dkuW7ZMue+++5TAwEBFp9MpNWvWVJ577jklPj6+yOsQ4k5TKUoxRpoJIYQQQpQRGTMihBBCCIeSZEQIIYQQDiXJiBBCCCEcSpIRIYQQQjiUJCNCCCGEcChJRoQQQgjhUBVi0jOr1crFixfx8PCoEOt1CCGEECJnluS0tDSqV6+OWl1w+0eFSEYuXryYZ2EoIYQQQlQM586do0aNGgXurxDJiIeHB5BzMZ6eng6ORgghhBDFkZqaSmhoqO0+XpAKkYxc75rx9PSUZEQIIYSoYIoaYiEDWIUQQgjhUJKMCCGEEMKhJBkRQgghhENJMiKEEEIIh5JkRAghhBAOJcmIEEIIIRxKkhEhhBBCOJQkI0IIIYRwKElGhBBCCOFQkowIIYQQwqEkGRFCCCGEQ0kyIoQQQgiHqhAL5QkhhBCVkcViIe7IMbLTM8vk/K7entQKb1gm5y5NkowIIYQQd8j5Y6c4sOY3Lh85RPa1BIyYMGnLrpPCzaxlxM8ryuz8pUWSESGEEKIMXI1PYv//rSH+wH4yk85hsmRhcNLkFtACqEFRUCtKmcSgUqnK5LylTZIRIYQQ4jZlpqXx1+qNnN29k/SLsZgMaWQ7qeB6MqAG1DmJiN5kRad1w61aTULatKX1gz3x9PF2WOzlgSQjQgghRAmYjSYObd7GyS1bSD17CmPGNQxasKpvaIXQ5XS96EwWdGpnnP2rE9ysJS0eiCI4rKaDIi+/JBkRQggh8mGxWIj9+whn9v7FldOnyIg/jyHtMga1BYvmhnEeupwkRGuxordq0XkH4t+wKc2iIqndsqmDoq9YJBkRQghRZRkyszi97yDnDh7iyj+nyLqcgCkzFYvFgFELVvVNg0udANSorVaczWqc3H3xrtOABp270KRzRzQaTX7ViCJIMiKEEKJSy0hJ5fjOvVw8cpjks2fIvnoJc1YaZsWEUaNCUd80yFMD/NvyoVIUdGYrWpzQOnvgXqMWYR070SqqO3pXlzt/MZWUJCNCiArBYrFw9WIil89d4NqFi6QlJZF59QrZKcmYs7IcHZ4oR6xmM8bUq5gN6ZgxY9SqcweSXnf9SRZAZVXQmxU0aie0rl64+AfhXSuM0OYtqN+uFS7ubnf8GqoaSUaEEHeUITOLS3EXuHzuPMkJCaQnXSYr+RrG1GRMGemYszOwGg1YLUasVgtWlRWrCswaFUoFeUxRlBNOkNPMARqLFScLaDV6nNy8cQkMxq9OPcIiWlGnZTO0OieHhlrVSTIiRDlgsVhIu5LMpbNxXL1wkdSEJDKuXCY7JRljWirmrAwshiysZgNWiwmrYsGqUirczdmqwn7gX0FU3PDXyb682qqgsVrRWFWoVWpUKi1qjfbfg4QAVCqc3LxwqxaCf7361GkTQWh4fRnPUY5JMiLEv7b98DMXDhwok3NbDAZM6amYszOxGLOxmo0oihmrYsWiVrCo1faPBRZE/e+rEiwrpbFY0VgVNIoalUqDWq1F7aRHo3dB6+aO3t0TvZc3bv7+eAYH4RcSgn9oCB5+3nJTEaKSkWREVHkH1m9m92dzSdeY7lylBXzrVykKWouCWgG1okat1qDW6lDrXNA6u+Dk5oHe0wsXX188AgJx8fBEVYHyEq1ej39oDQJqhsjgPyGEjSQjoso6f+wUv017i1TjNRSNChQFV7OmTKZPVqnUqLV61HpntK7u6Nw9cPb0xs3PD4+gIHxCqhFYqyZegX7yrV8IUeVIMiKqnNRryax4YxJXE0/ljF9QqXAza2g7dBQR9/dwdHhCCFHlSDIiqgyLxcKKaTO4ePAPjE4a0KhxNlqp1/1hokYNd3R4QghRZUkyIqqE3xd8y7GV35GlU4GTBiezhaAGbXn4rdfR6fWODk8IIao0SUZEpXZo83Z2fPxBzuBUnQqNxYq3Tyh9pk3FJyjQ0eEJIYRAkhFRScWfOsOqtyeTmn3FNjjVU+NB5MQ3ZOEqIYQoZyQZEZVKRkoqy1+fxNWEE5g1alCrcDOrafXM87R/qJejwxNCCJEPSUZEpWCxWFj57gdc+GszhhsGp9bp+hC9Xhzh6PCEEEIUQpIRUeFtXvwDR5cvIUuHbXBqYN3WPDJ1kgxOFUKICkCSEVFhHf1jF398+B7paiPoQG214u1Zgz7TpuFbTQanCiFERSHJiKhwEv6JY9Vbk0jJuoSizhmc6qF2p9uE16kX0dzR4QkhhCghSUZEhfL379vY8vE7OZOWqVW4mtS0evpZOjz8oKNDE0IIcYskGREVRsyOP22JiN5kIeyeB+j14vOylosQQlRwkoyICuHMgcNs/GDSv4mIlQffnk1Ys0aODksIIUQpuKXFx+fNm0dYWBjOzs60b9+ePXv2FOu4H374AZVKRd++fW+lWlFFnYs5weq3X8Xwb4tI1MR3JBERQohKpMTJyI8//si4ceOYPHky+/fvp0WLFkRFRZGUlFTocbGxsYwfP5577rnnloMVVU/CP3Gs/O8YsnVqdCYL3cZOpn7bVo4OSwghRCkqcTIya9Yshg8fzuDBgwkPD2f+/Pm4urry9ddfF3iMxWLhP//5D2+//TZ16tS5rYBF1XH5YgLLX36ebJ0aJ7OVu0e8Svg9HRwdlhBCiFJWomTEaDSyb98+IiMjc0+gVhMZGcnOnTsLPG7KlCkEBgYydOjQYtVjMBhITU21e4mqJTnpCktHDSNLp0JrttL+mdG0uq+ro8MSQghRBkqUjFy+fBmLxUJQUJDd9qCgIBISEvI9Ztu2bXz11Vd88cUXxa4nOjoaLy8v2ys0NLQkYYoKLiMllR+eH0ymE2gsViL6D5V1ZYQQohK7pQGsxZWWlsbTTz/NF198gb+/f7GPmzhxIikpKbbXuXPnyjBKUZ5kpWeweOhAMrRW1FYrzR/4D3c/0c/RYQkhhChDJXq019/fH41GQ2Jiot32xMREgoOD85Q/ffo0sbGx9O7d27bNarXmVKzVcvz4cerWrZvnOL1ej17WFKlyjAYD3wweSIbGjNqqEN7lYboN/o+jwxJCCFHGStQyotPpiIiIYOPGjbZtVquVjRs30rFjxzzlGzVqxKFDhzhw4IDt9dBDD9G1a1cOHDgg3S/Cxmw0sfCZgaSrDaisCvU7RBE1crijwxJCCHEHlHjSs3HjxvHMM8/Qpk0b2rVrx5w5c8jIyGDw4MEADBw4kJCQEKKjo3F2dqZp06Z2x3t7ewPk2S6qLovFwsLBg0hTMkBRqN38Xh58+UVHhyWEEOIOKXEy8vjjj3Pp0iUmTZpEQkICLVu25LfffrMNao2Li0OtLtOhKKISsVgsLBwylBRzCigKNRu04+E3X3N0WEIIIe4glaIoiqODKEpqaipeXl6kpKTg6enp6HBEKVo4/DmupF4AoHpoMwZ8EO3giIQQQpSW4t6/pQlDOMzikS/ZEpGgwPqSiAghRBUlyYhwiO/GvUrS5dMA+HuF8tRHsx0ckRBCCEeRZETccT/+dzLxF44C4OMSyDOff+rgiIQQQjiSJCPijvr57Xc5f2ovAF5OPjzzVfFn5hVCCFE5STIi7pj/vTeXs0e2g0qFp9qdwYsWotFoHB2WEEIIB5NkRNwRv330GSf/XIeiUuGhOPPMwkWSiAghhABuYZ4RIUpqwxeLiNn6K4pajbvFiWe+WYxOpvsXQgjxL2kZEWVq67dLObz2R6xqNW5mDU8v+Aa9q4ujwxJCCFGOSMuIKDO7fvk//vplARaNGleTiie/WIirh4ejwxJCCFHOSMuIKBNX45PYs2QeZo0aFyM8Pu8rPP18HB2WEEKIckhaRkSZWP/RPExaDTqThUdmf4ZvtUBHhySEEKKckpYRUSauHtsPgKd/GMFhNR0cjRBCiPJMkhFR6o7t2kum1gpAu0FDHByNEEKI8k6SEVHqdi9YACoVriYVjTu1dXQ4QgghyjlJRkSpslgspF06A4Bvw1YOjkYIIURFIMmIKFXbf1iOwUmN2mql++gXHB2OEEKICkCSEVGqTqxeAYCbyhX/6sGODUYIIUSFIMmIKDUZKalkZF8DIPTuSAdHI4QQoqKQZESUmvXzPsesVeNkttD9ucGODkcIIUQFIcmIKDUJ+7cD4OYeJAvhCSGEKDZJRkSpOH/sFJkqIwAt+g9wcDRCCCEqEklGRKnYMn8+ilqFi1GhzYNRjg5HCCFEBSLJiCgVKWdjAPAMbejgSIQQQlQ0koyI27Z/zQaydCpUikLn50c4OhwhhBAVjCQj4rYd+PE7AFwtToQ2buDgaIQQQlQ0koyI22I0GMhIjQcguFUnB0cjhBCiIpJkRNyWTV98g9FJg9Zipcdo6aIRQghRcpKMiNty9o91ALjqvHHz8nRwNEIIISoiSUbELbsan0SGNQOA+r0ecnA0QgghKipJRsQtW//RPKxqNXqTlXue7O/ocIQQQlRQkoyIW3b12H4APPxrodFoHByNEEKIikqSEXFLju3aS6bWCkC7QUMcHI0QQoiKTJIRcUt2L/gaVCpcTSoad2rr6HCEEEJUYJKMiBKzWCykXYoFwLdhK8cGI4QQosKTZESU2PYflmNwUqO2Wuk++gVHhyOEEKKCk2RElNiJVSsAcFO54l892LHBCCGEqPAkGRElkpGSSobhGgChd0c6OBohhBCVgSQjokTWz/scs1aNk9lC9+cGOzocIYQQlYAkI6JEEvZvA8DNPQidXu/gaIQQQlQGkoyIYjt/7BSZahMALfoPcHA0QgghKgtJRkSxbZk/H0WlwsWo0ObBKEeHI4QQopKQZEQUW8rZGAA8Qxs6OBIhhBCViSQjolj2rV5Plk6FSlHo/PwIR4cjhBCiEpFkRBTLwZ++B8DV4kRo4wYOjkYIIURlIsmIKJLRYCAjNR6A4FadHByNEEKIykaSEVGkTV98g9FJg9Zipcdo6aIRQghRuiQZEUU6+8c6AFx13rh5eTo4GiGEEJWNJCOiUJcvJpBhzQCgfq+HHByNEEKIykiSEVGojR9/ilWtRm+ycs+T/R0djhBCiEpIkhFRqKvH9gPg4V8LjUbj4GiEEEJURpKMiAId27WXTK0VgHaDhjg4GiGEEJWVJCOiQLsXfA0qFa4mFY07tXV0OEIIISopSUZEviwWC2mXYgHwbdjKscEIIYSo1CQZEfna/sNyDE5q1FYr3Ue/4OhwhBBCVGKSjIh8nVi1AgA3lSv+1YMdG4wQQohKTZIRkUdGSioZhmsAhN4d6eBohBBCVHaSjIg81s/7HLNWjZPZQvfnBjs6HCGEEJWcJCMij4T92wBwcw9Cp9c7OBohhBCVnSQjws75Y6fIVJsAaNF/gIOjEUIIURVIMiLsbJk/H0WlwsWo0ObBKEeHI4QQogqQZETYSTkbA4BnaEMHRyKEEKKqkGRE2OxbvZ4snQqVotD5+RGODkcIIUQVIcmIsDn40/cAuFqcCG3cwMHRCCGEqCokGREAGA0GMlLjAQhu1cnB0QghhKhKJBkRAGz64huMThq0Fis9RksXjRBCiDvnlpKRefPmERYWhrOzM+3bt2fPnj0Fll2+fDlt2rTB29sbNzc3WrZsyeLFi285YFE2zv6xDgBXnTduXp4OjkYIIURVUuJk5Mcff2TcuHFMnjyZ/fv306JFC6KiokhKSsq3vK+vL6+//jo7d+7k77//ZvDgwQwePJi1a9fedvCidFy+mECGNQOA+r0ecnA0QgghqhqVoihKSQ5o3749bdu25eOPPwbAarUSGhrK6NGjmTBhQrHO0bp1ax544AGmTp1arPKpqal4eXmRkpKCp6d8ay9tP/53MudP70NvsvL80v+h0WgcHZIQQohKoLj37xK1jBiNRvbt20dkZO7iaWq1msjISHbu3Fnk8YqisHHjRo4fP869995bkqpFGbp6bD8AHv61JBERQghxx2lLUvjy5ctYLBaCgoLstgcFBXHs2LECj0tJSSEkJASDwYBGo+GTTz6hR48eBZY3GAwYDAbb+9TU1JKEKUrgzN9HyNRaARXtBg1xdDhCCCGqoBIlI7fKw8ODAwcOkJ6ezsaNGxk3bhx16tShS5cu+ZaPjo7m7bffvhOhVXmHf9sAKhXORiuNO7V1dDhCCCGqoBIlI/7+/mg0GhITE+22JyYmEhwcXOBxarWaevXqAdCyZUtiYmKIjo4uMBmZOHEi48aNs71PTU0lNDS0JKGKYrpy4igATjp3B0cihBCiqirRmBGdTkdERAQbN260bbNarWzcuJGOHTsW+zxWq9WuG+Zmer0eT09Pu5coG9nXchJL16AQB0cihBCiqipxN824ceN45plnaNOmDe3atWPOnDlkZGQwePBgAAYOHEhISAjR0dFATpdLmzZtqFu3LgaDgdWrV7N48WI+/fTT0r0ScUtMigHQUK1FK0eHIoQQoooqcTLy+OOPc+nSJSZNmkRCQgItW7bkt99+sw1qjYuLQ63ObXDJyMjghRde4Pz587i4uNCoUSOWLFnC448/XnpXIW7JuZgTGJ1ynp5p0es+B0cjhBCiqirxPCOOIPOMlI01H87n6Pb/Q2+yMmr5akeHI4QQopIpk3lGROWSFHMYACeNi4MjEUIIUZVJMlKFZV++CICLfzUHRyKEEKIqk2SkCjNZsgAIatLCwZEIIYSoyiQZqaIunbuI4d/Bq03v6+7gaIQQQlRlkoxUUQd/Ww+AzmQhpEEdB0cjhBCiKpNkpIpK+PsAAE5qZ8cGIoQQosqTZKSKykw6D4CzT6CDIxFCCFHVSTJSRZmMGQD4NQh3cCRCCCGqOklGqqDkpCtkO6kACI/s6uBohBBCVHWSjFRBB9duBJUKJ7OVsOZNHB2OEEKIKk6SkSrowl/7ANChRaPRODgaIYQQVZ0kI1VQRvxZAHSeAQ6ORAghhJBkpEoyZacB4Fu3oYMjEUIIISQZqXKy0jPI1ub8XO+eexwbjBBCCAFoHR2AuLMOrt+EolahsVhpfHc7R4cjhBCiBCxGE8bLV3GpHmTbdvbbjWQnZmLNVrAaVGBWg0WDxsdIo9cecmC0xSfJSBVzdvduAPRWjQxeFeImVosF4+VrZCdewXApFXNaNt4tauNWuwYAGWfOk3zwTIHHe4aH4tEgDIDMuHiu7T9VcNlGIXg0ylmKIetiIlf3nCiwrHv9YLya1AcgO+kKV3YcLbCsW51AvJvndMEar1zj0h+HCyzrWtMPn9Y5cw2ZUtNJ+v2vAsu6VPfBt11TAMzpmSRu2FdgWedgb/w6NANybp4Jq3cVWFbv74H/3S1t7y+s+KPAsjpfVwLujcgtu/IPsOZf1snLhcCubWzv41ftwGqy5FtW664nKDL3y1n8mh1YDfmX1bg6EXxfB9v7hHW7sGSa8i2r1muo1quT7X3ixj8xp2XnKadYrShWhdBHu9i2xby7Emu6FpVFg1rRoEGDVqXBSaUi22qh3nu5yUjm3xY8VN55zpuSXMCHUw5JMlLFpJ37BwCdm4+DIxGi7FiyjGQnXsaQeBXDlVSM17IwpRmwZFqwZCsER9ax3VjPLFiLKcYJLRq0KhVqlcruXImXD1NnWE4ykvj7YXQn3QqsN+HCEVsycumPo2gO6QosG3/miC0ZubLrGOwpuNc8/niMLRm59tcJlILv7cQfOW5LRlJjzhZa9uLBU7ZkJOPM+cLPqztj+8wMl64WWjZBE5ebjGRkFlo2UXXRLhkprGwSlwi4N/e9abuC9qZ/r+suK1cJvGEapawtJnTq/D/ja9ZUgiJz36dvMuKizv/LWoo1k+D7bni/IRM3tVO+ZdOtRuh1Qz1rU3BX6/MpqcZotcCjN1bkjJfKBVTkvG7gpLK/DsUjm5QMM2itqJysqJ1B46rGO9Qr37jKI0lGqhhTZgrowDOsvqNDKTeyLiYS/9tfZJ0xg1VFk3cesO078tZKyC7ghqK20uTd+21vj05ZiZJZ0M1Hocn03L9KMe+uxJpa8I2q0ZTuaHQ5f+COzViJ5VrBZeu/1hGdT84fneMf/A/z5fz/MALUfqEFrjWrAXBizv9hSij4T0DNIQ3xaFAbgJPzVmE8V3BLWsjjtfBu1RiA05+vIfuf/G8QAEEPVcO/UwsAzixcR+axgr+9+d/nR1C3tgCc/X4j6Qfz/waqUlT4RnoT3KN9TgyfrcU1wdu2X4MODbmfYcrRi7Ybq2K24nrTzcSiKJgUK1as6N1y92lcnci05h8DgFMJympccz97jYuONGtWIWVzP3ttEWXVLrmfvdq5iBhcbjhOV3hZtbNi+1ml0RRaVuWa26qgUqkKLYuLfQtEoWX1Zru32YoRtZJ/gqE42Z/HoDJitub//7BFY7R7b1IZUKz5/x6Z1cY87zML+F/YrLKPwaI1kmnOG68CWFT216arayEjLRmtqwatpw6dtys6Pw+cg3zQB/vZlQ1/o2J0xRRGkpEqxGgwYNBYATV1O3V0dDgOYzGaSNq4l+S/LkGKC27o0anc0AHZVvs/jOpMFzwKWEzQaLnpL1CGHi+Va/51Korde2uqDi8K/oZtd2yKttCyVmPuHzxzsqrQspbs3CZi0zWl0LLmtMzcslcseOFZYFljSm5Z42UTXhTc8ma6lmH72XApu9Cyxqs3lE3KwosCvumpIOtCiu2t1i3nT5tJUTArFixYsKosKBoLaC34Vc99rD2waxOS/WPR+7mhD/DGpVoATt75X2utAd1hQP4hWCwWTCYT2f9+xv692tl9K87P9bI+XVvhU8RkyNfLerRrgkcRw72ul3VtWpeaTesWq6yudgg1p4QUq6w60IeaUzoVqyzOuuKXhRKVDZtyd7HL1n678AH7N5at83bnYpet+1aX4ped1K3YZUMGFvw/hBkwZ+ft7nEEJyenUunyl2SkCjm8aTsWjRq11UrTblX3SZpjkzbihRse+NiaPzOtJkwuGbiE2v9KuLZQkZWcmu951Fr7bzjurbRkXcm/rOqmpmTPNs5kJeZfFkB1Q7usV1t3si4WXFbrlpsA+bT3JiMupcCygQG+tp99O/iR/s+1Asv612icW7ZjEGknLhdY1rdOPdvPfh2rk3I0scCy1Ro1v6FsKMkHLxZYNrhpbgx+7WtxdV9cvuVUGhUBEbkx1HyqCyo0aFwKblG6zr1eTdzr1SyyXEEURSEhIYHk5ORbPocQFZm3tzfBwcF5/s6VhEpRbvrKVg6lpqbi5eVFSkoKnp4FfzsThVs2aSpnj+/GxQgv/PJ/jg6nTJnTMohf+ydpR1JRZ7hRc1S4rXsiJnolzsneZKozcKpmIbBLfVsfuxAlFR8fT3JyMoGBgbi6ut7WH2QhKhJFUcjMzCQpKQlvb2+qVauWp0xx79/SMlKFpMSeBkDnWnEGNRWX1WIheW8Ml7adwXzJCTfFFa1Kgyc+oIaEdQeoMyznF6X28LvRurmgdXEp4qxCFM5isdgSET8/v6IPEKKScfn372hSUhKBgYG33GUjyUgVYky/Ak7gUaO2o0Mpdf98uQ7nM+644Z2zQQUGq5Vsp3Sca6mpdl9LW1lnf998zyFESZlMOeN1XF3zHyskRFVw/f9/k8kkyYgonMViwai2AGpC27R1dDi3LPnv4ySsOY71qjPaYAMNxvYGIPDu+lz75yIZZKH2NeDbrjrV722FWuZSEXeAdM2Iqqw0/v+XZKSKOL5rL2aNGpVVoWXPwkd0lzfpp+K4sPIg1kRnPFTOuP878DQlMfdpFs8m9XCeEGB7xFUIIUTFIWvTVBEnNm8FwNkMrh4eDo6meCxGE0cm/Ma1L2JxS/LGQ+WMoiikKllkBiVT/TH7JyAkERHCMbp06cKYMWMcHUaZ2rx5MyqVSp6aKiOSjFQRV08fB8BJ7+7gSApmvJbCuZ822d5rdE45kw+qVKRbDWT4J+M9uAbhM+6jwdjetpkjhRCirHXq1In4+Hi8vAr+0vP555/TpUsXPD09S5S4zJs3j7CwMJydnWnfvj179uwppagrDummqSKMKZdAC27Vajk6FDvmrCwuLN9O+hEDbhYPtCotKU1O2qa+9o/yR+vhQo02TRwcqRBVm6IoWCwWtNryc9u4kzHpdDqCg4MLLZOZmUnPnj3p2bMnEydOLNZ5f/zxR8aNG8f8+fNp3749c+bMISoqiuPHjxMYGFgaoVcI0jJSRRjJmcK4euvWDo4ErEYz53/ZypE3/4+4yXvQHNLjZfVEq1KRZTWTfirBVjawaxt8JRERFYiiKGQazQ55lWTaKKvVSnR0NLVr18bFxYUWLVqwbNky2/7r3RJr1qwhIiICvV7Ptm3byMjIYODAgbi7u1OtWjVmzpyZ59zXrl1j4MCB+Pj44OrqSq9evTh58qRt/9mzZ+nduzc+Pj64ubnRpEkTVq9eXWTMBcVU3GvZuHEjbdq0wdXVlU6dOnH8eE6LcWxsLGq1mr1799rVN2fOHGrVqoXVai1WN82YMWOYMGECHTp0KLDMzWbNmsXw4cMZPHgw4eHhzJ8/H1dXV77++utin6MyKD8prigzZw4cxqTVgKLQMqqHo8PhzML16P9xz5naW/3vI7guqfi286Nuz07yBIyo0LJMFsInrXVI3UenROGqK96f9ejoaJYsWcL8+fOpX78+W7du5amnniIgIIDOnXOnQ58wYQIffPABderUwcfHh1deeYUtW7bw66+/EhgYyH//+1/2799Py5YtbccMGjSIkydPsnLlSjw9PXnttde4//77OXr0KE5OTowcORKj0cjWrVtxc3Pj6NGjuLsXvwv55piKey2vv/46M2fOJCAggBEjRjBkyBC2b99OWFgYkZGRLFiwgDZtclf6XbBgAYMGDUJdwAJ7t8toNLJv3z67VhS1Wk1kZCQ7d+4skzrLK0lGqoAjG38HwNmk4B14ZydmurzjIEm/n8XJR0P9kTkL0IX0acuFmUfI1qXh2dyNsN53FWvabiFE6TAYDLz77rts2LCBjh1z1qmqU6cO27Zt47PPPrO7gU+ZMoUePXK+xKSnp/PVV1+xZMkSunfvDsCiRYuoUaOGrfz1JGT79u106pSzzsy3335LaGgoK1asoH///sTFxdGvXz+aNWtmq7skboypJNfyzjvv2N5PmDCBBx54gOzsbJydnRk2bBgjRoxg1qxZ6PV69u/fz6FDh/j1119LFFtJXL58GYvFQlBQkN32oKAgjh07Vmb1lkeSjFQBV44dBcDJqXgLs5UGS5aRY29vxAt3PPEhPdVg2+cc5E/YtE62VWmFqExcnDQcnRLlsLqL49SpU2RmZtpu6NcZjUZatWplt+3GloLTp09jNBpp3769bZuvry8NG+YupxATE4NWq7Ur4+fnR8OGDYmJiQHgxRdf5Pnnn2fdunVERkbSr18/mjfPXbOoKDfGVJJrubGO61OXJyUlUbNmTfr27cvIkSP55ZdfeOKJJ1i4cCFdu3YlLCys2HGJWyfJSBWQfS0RNOASWPiKnKXp4v+244U7VkUhTZWJvq6C1WKxdcFIIiIqK5VKVeyuEkdJT08HYNWqVYSE2P9d0Ov1du/d3Er/S8ywYcOIiopi1apVrFu3jujoaGbOnMno0aOLdfyNMZXkWpyccv/uXJ+oy2rNma9Ip9MxcOBAFixYwCOPPMJ3333H3LlzS35xJeDv749GoyEx0X5hycTExCIHy95MURQsigWL1ZLz339/1qq1uOvK71OU15Xv3xhRKozWbNBoCG7a4o7VmXo4HS+8SdOl0mTqg3esXiFE0cLDw9Hr9cTFxdl1YxSlbt26ODk5sXv3bmrWzJnn59q1a5w4ccJ2nsaNG2M2m9m9e7etm+bKlSscP36c8PDcx/FDQ0MZMWIEI0aMYOLEiXzxxRfFTkZK41ryM2zYMJo2bconn3yC2WzmkUceua3zFUWn0xEREcHGjRvp27dvTkJhtbBx40aee+E5MkwZeZKLPD//+1+rYs23Dg+dhyQjwvEunPgH479Nt816dr8jdVqNZpyzPUAN7uGyGJ0oOZPFRIoxhVRjKqmGVFIMKaQYU0gx5GxLMaTYtqUaUsk0ZTokTj+tHwOrDUSdokaTVbEGXg8ZNYSXxrxEfFo8ER0iSE9NZ9/ufbh7uPPIgEe4kHYBgH+S/8FTyV1t9dGnHmXsy2PJ1mXj5+/HrHdmoVKrSM5O5tS1U6j8VUTeH8kzQ55h6uypuLm78cHbHxBYLZAm9zbh1LVTTJs4jc6RnQmrF0Zqcipr1q8htG4op66dKjTmgmK6lWuJS40DIDYlFvM1MwBOwU60bNOSV197lUf/8ygXsi9AduF13+hS4iUuJV3i8MHDAKzZsQY3dzeq16iOt483AAP7DqTHAz14evjTADz57JO8OvJVQhqF0KR1ExbPX0xaehr39r2X2JTYov8hb6JWqdGoNWhUOS9nrXOJz+EIkoxUcofXbwRAb7ISHFaziNKlI3H9HvRqDSZFIbR3xztSZ3miKAoZpozcm6YxBYPZUPSBVYDRasxJLv5NLK4nFzdvyzQ7JrkoqUxdJuYgM0arEbWlYs2U8MJrL+Dp48n82fM5d/Ycnl6eNG7WmOFjhmOwGDBac6YDMFgMGCy5//+OnTSWtPQ0nnvyOVzdXHnmhWdISUnBolhs5d6e+zbTX5/Os088i8lkIqJDBJ989wlWtRWDxYDJbGLyK5NJjE/E3cOdu7rdxWtTX7OrJz8FxXQr12Ky5CxyaLQY7c7V98m+7N+zn4cGPGS3vaC6b7T468V8+v6ntvdPPvAkANM+nEbfAX0BOHvmLJcuX7KdI7JPJOMvjefD6R9yOekyjZo24rMfPyMoOCgnobghsSjOzxV1nSSVUpIH0x0kNTUVLy8vUlJS8PTMPyMV+fvm+dFcunoGd6uO55YuvyN1xq/ewbWtqShaC02mPXBH6iwLZquZNGNavt/Kb7x53vhN/fqN1ayYHR1+hadChYfOAy+9F146Lzz1nrn/vWmbm5ObY/4Im8ApxYmatWqid9YXXV6Ue9Pfmc4vP//C7v2772i9apXallCoVeoKlVRkZ2dz5swZateujbOzfUtMce/f0jJSyWVdvghqcPatdsfqrHZ/J6rdD1aL5Y7VWVImq4mL6ReJS43jXNo5zqWdIy4tjkuZl2wJRZop7bbq0Kl1eOu98dR74qxxrlB/XMqKVq21JRGeun+Tin8Ti+s/X9/u7uSORl2+uz6ys7M5k34GVydXnJ0qRnO4yF96ejqxsbF8/unnTJs2Dbc7+PShkGSk0jNZskCtJiC86R2v29GTl2WZszifdt6WbJxLO0dcahxxaXEkZCRgUYqXLLk7udvdJPO7idrdXP/dVlH6aoUoL0aMGMGSJUvy3ffUU08xf/78Mqt71KhRfP/99/Tt25chQ4aUWT0if5KMVGKXLyZg0OZ8G2/So9sdqTN+zU5ca/rb1pYpa2nGNFurxvm087Zk41zaOZIykwo91lnjTKhnKKHuodT0rEmoRyjBbsF2XQAeOg+c1PIYshB3wpQpUxg/fny++8q6i37hwoUsXLiwTOsQBZNkpBI7+Nt6UKnQmSzUCm9Y9AGlIHVTJhZ1AtfCYwkbWPpTz6cZ0/jy0JfsTdzLudRzXDNcK7S8h5MHoZ6h1PTISTZCPXITjwCXAOk6EaIcCQwMrFKLw4lckoxUYgkHDwDgpLozA+uu7j2Cm1qHVVEI7FK63UKKorAhbgPTd08nKcu+xcPP2c+WZNTwqEFNj5q25MNL7yUJhxBClHOSjFRiGQnnANB735lvGkm/n8YdH9LJombN0hswezH9Iu/ufpct57cAUMuzFs81f476PvUJ9QiVgWZCCFHBSTJSiZmM6aBT41u/0R2pT7nsAmrQVjOWyvnMVjPfxnzLvAPzyDJnoVVrGdZsGMOaDUOvkccohRCispBkpJJKvZaMwSmne6Jxty5lX1/MaTzUziiKQrX7b7+L5sjlI7y9821iruYsrNU6sDWTO06mjnfJVvcUQghR/kkyUkn9vXYjikqF1mylbkTZr0mT8NtRXPEmHQOhDWrf8nnSjel8fOBjvj/2PVbFiqfOk5fbvEzfen1RqyrWDJdCCCGKR/66V1Ln9u4FQK9o0dyB+T7MCToAVP7Zt3yOjWc30ufXPnwb8y1WxcoDdR5gZd+VPFL/EUlEhChlXbp0YcyYMQ6rPywsjDlz5pTZ+Tdv3oxKpSI5OblUznfz51XW8Vc18he+kkq/EAuAzsPvjtRXe2xrDLXTqX5/4xIfm5CRwIu/v8iYzWNIykwi1COUz3p8xvR7puPncmfiF0JULp06dSI+Ph4vLy9Hh1JixU0UFUVh0qRJVKtWDRcXFyIjIzl58mShx7z11luoVCq7V6NGd2ZcYWGkm6aSMmWngk6Fd90Gd6Q+l+AA6j7Xq0THWKwWvj/2PR/99RGZ5ky0Ki2Dmw7m2ebPyuylQlRAiqJgsVjQah1/a9HpdAQHBzs6jBIxGo3odLpil3/vvff48MMPWbRoEbVr1+bNN98kKiqKo0eP5lkj5kZNmjRhw4YNtvfl4d9LWkYqoaz0DAz//r9V7+57HBtMAY5cOcKTq59kxp8zyDRn0jKgJUt7L+XF1i9KIiLEHWI2mxk1ahReXl74+/vz5ptvcuPaqYsXL6ZNmzZ4eHgQHBzMk08+SVJS7jw/17tC1qxZQ0REBHq9nm3btnH69Gn69OlDUFAQ7u7utG3b1u7md11aWhoDBgzAzc2NkJAQ5s2bZ7d/1qxZNGvWDDc3N0JDQ3nhhRdIT0+37T979iy9e/fGx8cHNzc3mjRpwurVq+1iK043zZUrVxgwYAAhISG4urrSrFkzvv/++yKPKyr+5ORkhg0bRkBAAJ6ennTr1o2DBw/a9r/11lu0bNmSL7/80rbI3KBBg9iyZQtz5861tVzExsbmqVtRFObMmcMbb7xBnz59aN68Od988w0XL15kxYoVhcat1WoJDg62vfz9/Yu81rImyUgl9PfvW7GqVWgsVsLvbl+mdWVfvkrMa+uJmb4Sc1ZWkeUzTZnM2DODJ1c9ydErR/HQeTCp4yQW9VpEPZ96ZRqrEHeUMaPglym7BGWzilf2FixatAitVsuePXuYO3cus2bN4ssvv7TtN5lMTJ06lYMHD7JixQpiY2MZNGhQnvNMmDCB6dOnExMTQ/PmzUlPT+f+++9n48aN/PXXX/Ts2ZPevXsTFxdnd9z7779PixYt+Ouvv5gwYQIvvfQS69evt+1Xq9V8+OGHHDlyhEWLFvH777/z6quv2vaPHDkSg8HA1q1bOXToEDNmzMDd3b3En0N2djYRERGsWrWKw4cP8+yzz/L000+zZ8+eQo8rKv7+/fuTlJTEmjVr2LdvH61bt6Z79+5cvXrVVubUqVP8/PPPLF++nAMHDjB37lw6duzI8OHDiY+PJz4+ntDQ0Dx1nzlzhoSEBCIjI23bvLy8aN++PTt37iw07pMnT1K9enXq1KnDf/7znzz/Lo7g+LYZUepid+0CQG9Vo9WV7boqF3/dg4fKjcyrWtRFNC9uitvEu3veJSEjAYBeYb14td2r+Ls4PisXotS9W73gffXvg/8szX3/fj0wZeZfttbdMHhV7vs5zSDzSt5yb6WUOMTQ0FBmz56NSqWiYcOGHDp0iNmzZzN8+HAAuwXj6tSpw4cffkjbtm1JT0+3u+lPmTKFHj1yl3/w9fWlRYvcp/imTp3KL7/8wsqVKxk1apRt+1133cWECRMAaNCgAdu3b2f27Nm2c908YHTatGmMGDGCTz75BIC4uDj69etHs2bNbDHeipCQELs1cUaPHs3atWv56aefaNeuXYHHFRb/tm3b2LNnD0lJSej1OfMiffDBB6xYsYJly5bx7LPPAjldM9988w0BAQG28+p0OlxdXQvtZkpIyPk7GhQUZLc9KCjIti8/7du3Z+HChTRs2JD4+Hjefvtt7rnnHg4fPoyHh0eBx5U1aRmphNLi/gHAyc23zOvKOm0FwOyeVuAqvYkZiYzdNJYXN71IQkYCIe4hfBr5Ke91fk8SESEcqEOHDnbLJXTs2JGTJ09iseSsaL1v3z569+5NzZo18fDwoHPnzgB5vkm3adPG7n16ejrjx4+ncePGeHt74+7uTkxMTJ7jOnbsmOd9TEyM7f2GDRvo3r07ISEheHh48PTTT3PlyhUyM3MStxdffJFp06Zx1113MXnyZP7+++9b+hwsFgtTp06lWbNm+Pr64u7uztq1a4tsMSgs/oMHD5Keno6fnx/u7u6215kzZzh9+rTtmFq1atklImWtV69e9O/fn+bNmxMVFcXq1atJTk7mp59+umMx5EdaRiohU+Y1cALPmmU7QZg5LQNXizuowKdN3qTCYrXww/Ef+Oivj8gwZaBVaXmmyTM81+I5XLQuZRqbEA7334sF71PdlLi/cqqQsjd9Zxxz6NZjKoGMjAyioqKIiori22+/JSAggLi4OKKiojAa7WdZdnOzX5Jh/PjxrF+/ng8++IB69erh4uLCo48+mue4wsTGxvLggw/y/PPP88477+Dr68u2bdsYOnQoRqMRV1dXhg0bRlRUFKtWrWLdunVER0czc+ZMRo8eXaJrff/995k7dy5z5syxjVEZM2ZMieK9WXp6OtWqVWPz5s159nl7e9t+vvmzK67rrSaJiYlUq5a7/EZiYiItW7Ys9nm8vb1p0KABp04V8v/gHSDJSCVjNpowqK2AmtrtOxZZ/nZcWLkLJ5WObKuFOpH2dWWaMhmxYQR/Jf0FQPOA5kzuOJkGPnfm6R4hHE5XgptMWZUtwu7du+3e79q1i/r166PRaDh27BhXrlxh+vTptjELe/+dv6go27dvZ9CgQTz88MNAzo05v0GYu/7tUr7xfePGOdMD7Nu3D6vVysyZM1GrcxKy/L69h4aGMmLECEaMGMHEiRP54osvSpyMbN++nT59+vDUU08BYLVaOXHiBOHh4YUeV1j8rVu3JiEhAa1WS1hYWIni0el0ttapgtSuXZvg4GA2btxoSz5SU1PZvXs3zz//fLHrSk9P5/Tp0zz99NMlirG0STdNJXPkj51YNGrUVivNI+8t07rSY3IG1hmc01DrcvNaRVF4Y/sb/JX0F+5O7rzR/g0W91osiYgQ5UxcXBzjxo3j+PHjfP/993z00Ue89NJLANSsWROdTsdHH33EP//8w8qVK5k6dWqxzlu/fn3bgMyDBw/y5JNPYrVa85Tbvn077733HidOnGDevHksXbrUVn+9evUwmUy2+hcvXsz8+fPtjh8zZgxr167lzJkz7N+/n02bNtmSgZKoX78+69evZ8eOHcTExPDcc8+RmJhY5HGFxR8ZGUnHjh3p27cv69atIzY2lh07dvD6668XmdSFhYWxe/duYmNjuXz5cr6fnUqlYsyYMUybNo2VK1dy6NAhBg4cSPXq1enbt6+tXPfu3fn4449t78ePH8+WLVts8Tz88MNoNBoGDBhQzE+rbEgyUsmc2rYNAL1Zhd617LpCLFlGXIw5g508m9sPevrq8FesP7serVrLJ5Gf8Hijx2UGVSHKoYEDB5KVlUW7du0YOXIkL730km1gZUBAAAsXLmTp0qWEh4czffp0Pvjgg2Kdd9asWfj4+NCpUyd69+5NVFQUrVu3zlPu5ZdfZu/evbRq1Ypp06Yxa9YsoqKiAGjRogWzZs1ixowZNG3alG+//Zbo6Gi74y0WCyNHjqRx48b07NmTBg0a2Aa3lsQbb7xB69atiYqKokuXLgQHB9vd0AtSWPwqlYrVq1dz7733MnjwYBo0aMATTzzB2bNn8ww6vdn48ePRaDSEh4fbusfy8+qrrzJ69GieffZZ28Di3377zW6OkdOnT3P58mXb+/PnzzNgwAAaNmzIY489hp+fH7t27bqj41byo1JufKi8nEpNTcXLy4uUlBQ8PT0dHU659tUzg0jOvoynxoPh3xX9nPytyoyL58z8v9CZXan9dnu0LjmJz7YL23hhwwsoKLzZ4U0ea/hYmcUghKNlZ2dz5swZ2xwRQlRFhf0eFPf+LWNGKhlj2lVwAveQsDKtx7VmNZq8Ww2r0WzrojmXeo5Xt76KgsIj9R+hf4P+ZRqDEEKIykHazisRi8WCUWUGoGabsp3s7LrriUimKZOXNr9EmjGN5v7Neb3963aPDAohhKP06tXL7vHaG1/vvvuuo8MTSMtIpXLyz78wa9WoFIWWPbuVWT0pR05iSsnEv1POpEaKojBpxyROXjuJn7Mfs7rMQqcp/voKQghRlr788kuyCpgh2te37OdjEkWTZKQSOb5pCwB6k4KbV9mNrbnwcwyemT4cWfs/mrzdm4VHFrI2di1alZZZXWYR5Fb44CwhhLiTQkJCHB2CKIJ001QiV08dA8BJX3ZT+lotFrTpOdNAu9TQsuPiDubsnwPAa+1eo3VQ3hHzQgghRGGkZaQSMSQngRbcgmqUWR1Xdx7CVe2ERVGgeyivbHkOq2Klb72+PN7w8TKrVwghROUlLSOViJGcqYurtSy71olLW3Oed09TZfLK4cmkGlNp6teUNzq8IQNWhRBC3BJJRiqJ2EPHMGk1oCi07Nmj6ANukSrZFYBDPrGcuHYCX2dfZnedjV6jL7M6hRBCVG63lIzMmzePsLAwnJ2dad++PXv27Cmw7BdffME999yDj48PPj4+REZGFlpe3JojGzcCoDcr+FYLLJM6kg8ew12tR1EUvvReilalZWbnmQS7FbzMtRBCCFGUEicjP/74I+PGjWPy5Mns37+fFi1aEBUVRVJSUr7lN2/ezIABA9i0aRM7d+4kNDSU++67jwsXLtx28CLX5ZgjADhpXMusjsT1JwG4SCZJzkm80vYV2gS3KeIoIURl16VLF8aMGePoMMrU5s2bUalUJCcnOzqUSqnEycisWbMYPnw4gwcPJjw8nPnz5+Pq6srXX3+db/lvv/2WF154gZYtW9KoUSO+/PJLrFYrG//9Ji9KR/aVeABcAquXWR0uTzbiC7/f+N7/Nx6q+xADGjl2YSUhhLhTOnXqRHx8PF5eXgWWyc7OZuTIkfj5+eHu7k6/fv0KXXDPZDLx2muv0axZM9zc3KhevToDBw7k4sWLduXCwsJQqVR2r+nTp5fatZUHJUpGjEYj+/btIzIyMvcEajWRkZHs3LmzWOfIzMzEZDIVOtGMwWAgNTXV7iUKZ7JmAxDcpHmZnD/LnMXL+/7L8sCVJDROYFLHSTJgVYgqRFEUzGazo8Owcydj0ul0BAcHF/p3b+zYsfzvf/9j6dKlbNmyhYsXL/LII48UWD4zM5P9+/fz5ptvsn//fpYvX87x48d56KGH8pSdMmUK8fHxttfo0aNL5brKixIlI5cvX8ZiseRZcTAoKIiEhIRineO1116jevXqdgnNzaKjo/Hy8rK9QkNDSxJmlZPwTxwGJw0Aze7rXurnVxSFt3e+zbGrx/B19mVO1zkyYFWICs5qtRIdHU3t2rVxcXGhRYsWLFu2zLb/erfEmjVriIiIQK/Xs23bNjIyMhg4cCDu7u5Uq1aNmTNn5jn3tWvXGDhwID4+Pri6utKrVy9Onjxp23/27Fl69+6Nj48Pbm5uNGnShNWrVxcZc0ExFfdaNm7cSJs2bXB1daVTp04cP34cgNjYWNRqNXv37rWrb86cOdSqVQur1VpkN01KSgpfffUVs2bNolu3bkRERLBgwQJ27NjBrl278j3Gy8uL9evX89hjj9GwYUM6dOjAxx9/zL59+/Ks1Ovh4UFwcLDt5ebmVuTnVZHc0adppk+fzg8//MAvv/xS6AqXEydOJCUlxfY6d+7cHYyy4vl77XoAdCYL1erVLvXzL4lZQqc1rXj95MvMqDFBBqwKUQhFUcg0ZTrkVZJF2KOjo/nmm2+YP38+R44cYezYsTz11FNs2bLFrtyECROYPn06MTExNG/enFdeeYUtW7bw66+/sm7dOjZv3sz+/fvtjhk0aBB79+5l5cqV7Ny5E0VRuP/++zGZTACMHDkSg8HA1q1bOXToEDNmzMDd3b3Ysd8cU3Gv5fXXX2fmzJns3bsXrVbLkCFDgJxukMjISBYsWGBXfsGCBQwaNAi1uuhb5b59+zCZTHZftBs1akTNmjWL3XMAOUmNSqXC29vbbvv06dPx8/OjVatWvP/+++Wulep2lWjSM39/fzQaTZ4+sMTERIKDC79BffDBB0yfPp0NGzbQvHnhXQl6vR69Xr55F1fi4b8B0KlLfwnzPfF7+Gr7V3xjmYLaqsJV61PqdQhRmWSZs2j/3Z1ZqPJmu5/cjatT0YPYDQYD7777Lhs2bKBjx44A1KlTh23btvHZZ5/RuXNnW9kpU6bQo0fOdAHp6el89dVXLFmyhO7dc1phFy1aRI0auRMtnjx5kpUrV7J9+3Y6deoE5IwdDA0NZcWKFfTv35+4uDj69etHs2bNbHWXxI0xleRa3nnnHdv7CRMm8MADD5CdnY2zszPDhg1jxIgRzJo1C71ez/79+zl06BC//vprsWJKSEhAp9PlSSJK0nOQnZ3Na6+9xoABA/D0zF3S48UXX6R169b4+vqyY8cOJk6cSHx8PLNmzSrWeSuCEiUjOp2OiIgINm7cSN++fQFsg1FHjRpV4HHvvfce77zzDmvXrqVNG3n6orRlXboAKnD2Ld0Wi4vpFxm/ZTw9E+9DrVKRYTVRo33TUq1DCHHnnTp1iszMTNsN/Tqj0UirVq3stt34N/v06dMYjUbat89Ntnx9fWnYsKHtfUxMDFqt1q6Mn58fDRs2JCYmBsi5uT7//POsW7eOyMhI+vXrV+SX1IJiKsm13FhHtWrVAEhKSqJmzZr07duXkSNH8ssvv/DEE0+wcOFCunbtSlhYWLHjuh0mk4nHHnsMRVH49NNP7faNGzfO7hp0Oh3PPfcc0dHRleaLe4mngx83bhzPPPMMbdq0oV27dsyZM4eMjAwGDx4MwMCBAwkJCSE6OhqAGTNmMGnSJL777jvCwsJsGeL15ZvF7TOZMkGnxq9hk1I7Z7Y5mzGbxnDNcI170nNW57V4ppfa+YWorFy0Lux+crfD6i6O9PSc3+VVq1blWUTu5ptbWYxNGDZsGFFRUaxatYp169YRHR3NzJkziz0o88aYSnItTk5Otp+vD0S1Wq1AzpftgQMHsmDBAh555BG+++475s6dW+xrCg4Oxmg0kpycbNc6Upyeg+uJyNmzZ/n999/tWkXy0759e8xmM7GxsXaJYEVW4mTk8ccf59KlS0yaNImEhARatmzJb7/9ZhvUGhcXZ9e/9umnn2I0Gnn00UftzjN58mTeeuut24tecC0xiWynnF+qJj26lso5FUVhys4pxFyNobq6OjUVL1CBX8dqpXJ+ISozlUpVrK4SRwoPD0ev1xMXF2fXjVGUunXr4uTkxO7du6lZsyaQM1j1xIkTtvM0btwYs9nM7t27bd00V65c4fjx44SHh9vOFRoayogRIxgxYgQTJ07kiy++uKUnRG71WvIzbNgwmjZtyieffILZbC70SZibRURE4OTkxMaNG+nXrx8Ax48fJy4uztZ9lJ/ricjJkyfZtGkTfn5+RdZ14MAB1Go1gYFlM8GlI9zSQnmjRo0qsFtm8+bNdu9jY2NvpQpRTAd/2wgqFU5mC7Wbl07LyHfHvuN///wPjUrD5KwhaFQqsqxmqneRFXmFqAw8PDwYP348Y8eOxWq1cvfdd5OSksL27dvx9PTkmWeeyfc4d3d3hg4dyiuvvIKfnx+BgYG8/vrrdl9A69evT58+fRg+fDifffYZHh4eTJgwgZCQEPr06QPAmDFj6NWrFw0aNODatWts2rSJxo0b39FryU/jxo3p0KEDr732GkOGDMHFpXgtTZDzZMzQoUMZN24cvr6+eHp6Mnr0aDp27EiHDh1s5Ro1akR0dDQPP/wwJpOJRx99lP379/N///d/WCwWW++Br68vOp2OnTt3snv3brp27YqHhwc7d+60DdD18ak8Y/hk1d4K7sKBnFHsOnSlcr4/E/7k/T/fB+DlNi/j9W1OV5rRNR21RlMqdQghHG/q1KkEBAQQHR3NP//8g7e3N61bt+a///1voce9//77pKen07t3bzw8PHj55ZdJSUmxK7NgwQJeeuklHnzwQYxGI/feey+rV6+2dZNYLBZGjhzJ+fPn8fT0pGfPnsyePfuOX0t+hg4dyo4dO2xP2pTE7NmzUavV9OvXD4PBQFRUFJ988oldmePHj9s+rwsXLrBy5UoAWrZsaVdu06ZNdOnSBb1ezw8//MBbb72FwWCgdu3ajB071m4cSWWgUkryLJiDpKam4uXlRUpKSpF9aVXN5088TpqSga9bMIO//vK2zhWfHs8Tq57gavZVHqjzANF3R3N0yv9wyfBCf7eakIfuKaWohagcsrOzOXPmDLVr1y50ugJRcUydOpWlS5fy999/OzqUCqOw34Pi3r+lZaSCMxnSQKfGp16j2zpPtjmbMZvHcDX7Ko18GzG542RUKhVNJj+EJcuISiMLPAshKq/09HRiY2P5+OOPmTZtmqPDqXLkDlOBZaSkYtDmDF5t0PnWWy0URWHqrqkcvXIUb703c7rOsRuVr3HRodZJ3iqEKFsjRoywPWl582vEiBFlWveoUaOIiIigS5cut9RFI26P3GEqsINrf0dRq9BarDTscOvzt3x/7HtWnl6JWqXm/c7vE+IegtVoJnHjnwR1byuJiBDijpgyZQrjx4/Pd19Zd9EvXLiQhQsXlmkdomByl6nA4vbuAUBn1aC5xcGlF9Mv2gasjosYR4dqOaO+E9buwrpd4eSmrdSP7iyDV4UQZS4wMLBSPa4qik+6aSqw9PNnAdB7FP1cekF+PvkzZsVM2+C2DAwfaNt+bf9VAMzaLElEhBBClClJRiowY1YyAJ5h9W7peJPVxC8nfwHgiYZP5M5IaLGgy/AAwLW+NJ4JIYQoW5KMVFBGgwGDNuep7Lp33XVL59h6fiuXsi7h6+xL19Dc2VsvbdmPi1qLRVEIeahdqcQrhBBCFESSkQrq0MatWNVqNBYrzbrcfUvnWHZiGQB96/XFSZO7ZsOVHfEApKsz0PlVnhn+hBBClE+SjFRQ/+zYAYDeokarcyqidF4X0y+y/cJ2APrV72e3T5OaM+uqvla5nw9PCCFEJSDJSAWVcvY0AE5u3rd0/PKTy1FQ6FCtAzU9a9q2X919GDe1E1ZFIeShiNIIVQhRyXXp0oUxY8Y4OowytXnzZlQqFcnJyY4OpVKSZKSCMmXkPO3iEVqnxMearWbbwNVHG9ivpuzVqiGqDpAdnIJL9aDbD1QIISqBTp06ER8fj5eXV4FlsrOzGTlyJH5+fri7u9OvXz8SExMLPe+gQYNQqVR2r549e5Z2+OWePCpRAZmNJgxqK6CmVruSDzDden4rSVlJ+Dr70i20m90+jc6JkL6yBo0Qwp6iKFgsFrTa8nPbuJMx6XQ6goODCy0zduxYVq1axdKlS/Hy8mLUqFE88sgjbN++vdDjevbsyYIFC2zv9Xp9qcRckUjLSAUUs2MPFo0alVWhRY+uRR9wk+sDV/vU62M3cFUIUXVYrVaio6OpXbs2Li4utGjRgmXLltn2X++WWLNmDREREej1erZt20ZGRgYDBw7E3d2datWqMXPmzDznvnbtGgMHDsTHxwdXV1d69erFyZMnbfvPnj1L79698fHxwc3NjSZNmrB69eoiYy4opuJey8aNG2nTpg2urq506tSJ48ePAxAbG4tarWbv3r129c2ZM4datWphtVqL7KZJSUnhq6++YtasWXTr1o2IiAgWLFjAjh072LVrV6HXpdfrCQ4Otr18fKregwPlJ8UVxXbqjz8AcDaDi7tbiY6NT49n24VtQN6Bq6fmr8Zw0YLf3QEE39ehdIIVoopRFAUlK8shdatcXGzzBRUlOjqaJUuWMH/+fOrXr8/WrVt56qmnCAgIoHPnzrZyEyZM4IMPPqBOnTr4+PjwyiuvsGXLFn799VcCAwP573//y/79+2nZsqXtmEGDBnHy5ElWrlyJp6cnr732Gvfffz9Hjx7FycmJkSNHYjQa2bp1K25ubhw9ehR3d/diX+fNMRX3Wl5//XVmzpxJQEAAI0aMYMiQIWzfvp2wsDAiIyNZsGABbdrkLq2xYMECBg0ahFpd9Pf2ffv2YTKZiIyMtG1r1KgRNWvWZOfOnXToUPDf1M2bNxMYGIiPjw/dunVj2rRp+PkVPZmloiiAgqKYURQLimJBo3FBpdL8u9+KSlUx2hwkGamArp0+AYCTc8nXalh+Kmfgavvg9tTyrGW3z3hGi5fKg+SDSQTfVyqhClHlKFlZHG/tmMHfDffvQ+XqWmQ5g8HAu+++y4YNG+jYsSMAderUYdu2bXz22Wd2N/ApU6bQo0cPIGdl26+++oolS5bQvXt3ABYtWkSNGjVs5a8nIdu3b6dTp04AfPvtt4SGhrJixQr69+9PXFwc/fr1o1mzZra6S+LGmEpyLe+8847t/YQJE3jggQfIzs7G2dmZYcOGMWLECGbNmoVer2f//v0cOnSIX3/9tVgxJSQkoNPp8Pb2ttseFBREQkJCgcf17NmThx9+mLCwWpw+fZI33phEz5738ccf61CrQVEsODn5oFbntGIbjdcwGi/lJB9YQLF/6tHVtQ5abc6XVElGRJkypl0GLbhVq1l04RuYrWaWn1wOwKMN7QeuZsRexANnAIIj65dOoEKIcunUqVNkZmbabujXGY1GWrVqZbftxpaC06dPYzQaad++vW2br68vDRs2tL2PiYlBq9XalfHz86Nhw4bExMQA8OKLL/L888+zbt06IiMj6devH82bNy92/DfGVJJrubGOatWqAZCUlETNmjXp27cvI0eO5JdffuGJJ55g4cKFdO3albCwsGLHdSOr1YjFko2iWLBYsjAYEm2tF4piRq+vjkaj54knnsBgSMJgSKR27UbUrTuLli3vZ9265XTpktOaotG42ZIRsGK1Gm6qTYVKpfm3RSQ3OakoiQhIMlLhWCwWjJgBNTUiSrZS7x/n/yApM2fgavfQ7nb7Lq76CxeVJ+lWIzVaNS7FiIWoWlQuLjTcv89hdRdHeno6AKtWrSIkJMRu382DJ93cStYVXBzDhg0jKiqKVatWsW7dOqKjo5k5cyajR48u1vE3xlSSa3Fyyh0jZ1v+wmoFcgaoDhw4kAULFvDww3347rvvmD37/TytC9nZiWRlpdtaJhTFAooFT89sjEYjycnJeHt7YzIlYzAkkpgYj5+fMwZDkl0sOp0J0P8by7/rf6nU1KlbGz8/H2JjE9FqPW9IMnJotR64uta2bc/Zp863e06SEVFm/tn/NyatGpWi0LJnZNEH3GDZyX8HrtbNO3DVeE6DC6B4Z5RWqEJUSSqVqlhdJY4UHh6OXq8nLi7OrhujKHXr1sXJyYndu3dTs2ZOy+y1a9c4ceKE7TyNGzfGbDaze/duWzfNlStXOH78OOHh4bZzhYaGMmLECEaMGMHEiRP54osvip2MFOdaFEX5t1XCgMWSDYDJlILRaMHJydtWzmhMJiPjNIpiYcCArrRvP4fZsydjNhu5776mWK0GNBqXG8pfxmQy5omjRYtGODk5sXHjRvr164dareP06XjOnYunU6dOOOl8UZGbQKjVuYmSk5MPTk4+qFRqzp8/z9WryYSFNcfVtVaeetRqHWq1rsSfU3knyUgFc2zTVgD0JgXPEkzVfuPA1UfqP2K3LzvpCu6KK6jA/97Q0gtWiHJGURTS049hNqdgMqVgMidjNiXbfnZxqUVYreds5bdtv8t2I7uZh0c44Y2/sL1PzziJYjXlW1at1uPmVtf2PiPjdD5N7TlUaifc3XK7SjMy/8FaQAwqlQZ399wukszMWCyWzHzLolLj4d7o39g9eOml4YwZ8yIZGefo2LE1qanp7Nr1Fx4ebvznP33tDs3KOofZnAbAwIGPMH78GFxc0ggI8GPKlLl2AzxrhLrywAPdGDp0IHPnTsbd3Y3Jk2dTrVoA3brVx2o1M27ceHr16kWtWt5cunSODRtWU79+CGlpR+3qdXOrZ7vxZhsSycyMBSAt7RgaTe6YudGjn2Hs2LFYrVbuvvtuLl06wx9/bMTDw40nn+xDdvbFf6/jPHq9JxpNbrKoKGbbZ9agQS3atm3O5MlzeOqph3F1dUfBfkyGTueHXu+DSqW1a51wc9MwZMgQxo0bh6+vL56enowe/RYdO3akc+fcz7NRo0ZER0fz8MMPk56ezttvv02/fv0IDg7m9OnTvPrqq9SrV4+oqKj8/x0rKUlGKpgrJ3J+WZ10JWs6/eXUL1gVK+2C2xHmFWa37+LKPehU7mRazVTvWPx+W5GX1WrGbE5Fo3G2/cHLyorj6tUdBR7j5dXKdkMxGJK4fPn3Ast6erbAwyOnG81ovMKlS+sLLOvhEY6nZ86/p8mUQlLSmgLLurs3xMsrp3/dbM4gMfF/BZZ1c6uHt3dOF6HFYiAh4ZcCy7q6huHjk9PvbbWaiY9fVmBZZ5ca+PnmrrN04cIPBZbVOwfj79flhrLfYzRewWROyUku/k02zOYUPD2aER7+PpDTarF3X78CEwEvrwi7ZARFwWxOzresxZxuv+Hf8QD5uXm7UkhZlXJT07piLbBs3noKLqu66aY6adI4fH1dmTXrC2Jjz+Pl5UGLFo15+eVh+cSbe94pU8aSnp7B44+PxN3djVGjBpKRYbWLd968KUyYMJ3HHhuJ0WiiU6fWLFs2D60259osFgsjR47k/PnzeHi4Ehl5F9HRrxZ+nYoVRbH+G4/95/fGGyOpXr0+0dHR/PPPP3h7e9K8eUNefnkYKpUatTrnVqfRuKHVenLjrBZarQcuLsG2pGLYsOcZPvw5nnvuZdvv2o2cnYPR673zDXHOnDloNBr69euHwWAgKiqKTz75xK7M8ePHSUlJ+TceDX///TeLFi0iOTmZ6tWrc9999zF16tQqN9eISlGUcr8ASWpqKl5eXqSkpODpWfInSCqT+f36kqE1ExRUn6c+nF2sY8xWMz1/7kliZiLv3fsevWr3stt/+tPVWM+4YnJPJXzSQ2URdoVjsWT/+605BZMpGbM5BQ+Ppjg7VwcgJeUv4s59nbPfnGy78V3/9hje+AOqVXsYgMuXf+fg38MLrKtB/UmEhj4DwLVre9j/14ACy9at+6rtZpmaeog/9/YtsGxY2Cjq1hkLQEbGKXbtLvibVs3QodSv/18AsrMvsn1HwRPfhYQ8SaOGUwEwma6x9Y+Cxy4FB/elSXjOPBQWSzabtzQpsGxAQBTNm+X+4d74ez0g/z9Pfr730rJl7iRRm7c0x2LJv4vRyyuCNhE/2d7v3vMgVqsJJycvnLReaJ28cHLyxknrhYtLLYKDc38HMjPPoijmfM+rVutRqfw5c+YMtWvXxslJVWC8KpXKrlneajVQ8J9eFRrNjWWNtpvwnSsLGo3zDWVNhSYKOZ+FqgzK6mzjHkpW1gwo/yYYJRs3MXXqVJYuXcrff/9douOqsuzsbNvvgbOzs92+4t6/pWWkgjEpBkBDtRatiix73bYL20jMTMRH70P3mt3z7K/7/P1YLRYsaVVjvIiiKBiNSWRmxeHqWhu9zh+AxMRVnDg5DbM5Gas1b5/wjQmGyXSNpKSCJ2kyW3K/NTs718DfvzuQ//wPLi65XWNOTt74+xc8FsjVJbcPWav1KLSsm2tut4BG41p42Ru6BdRqfaFl3d0a2X5WqbSFlvVwb3JDWVWhZT097Fvlcj6zAs7rYZ/UBPhHolbrcXLyRuvkjZPW89//eqHXB9qVbd/u/wo8783y67O/UXZ2bvfJjTf6otyYmBRdtvjjA8qurBNQvAkSy0fZkt/a0tPTiY2N5eOPP2batGklPl7cHklGKpBzMScwOuWMqm5+X/EHr94446pOk/8fILVGg9q78rU6ZWdf5PKVzWRlnSUr8yxZWXFkZsVhteZMShUePpNqwX2BnJu70Zg74l2l0qDV5n5r1mpzJ2Vyd29Eg/pv2m54Tk7eOTdCrSdarecNj+GBu3sDWjT/vFjx5pT9rFhlXV3Dil3W2bl6scvqdH7FLqvVehS7rFqtL3ZZoERlmzSZVeyyovwaMWIES5YsyXffU089xfz588us7lGjRvH999/Tt29fhgwZUmb1iPxJMlKBHF6fM5ZAb7ISEFq9WMckZCTwx4WcGVtvnnEVIH71DgK6tkJbzEcCyxOr1UBW1gWyss6SmRVLVlYcWVlnqRHyFP7+OWvupGec4PjxN/M5Wo2Lcw24oZnay6s1bdv+ipPWBycnTzQa9wJns3R2rk5o6KAyuCohqq4pU6Ywfvz4fPeVdRf9woULWbhwYZnWIQomyUgFknT0EABOmuInDr+czBm42ja4bZ6Bq+mnz2HaYiZu8x6CRzXAtWa10gy3zCQm/h+nTr/37wj5vP3unp6tbMmIm2s9/P264eJaCxeXmri65PzX2TkkTzO1VuuOp0fTO3EJQoh8BAYGEhgYWHRBUelIMlKBZF+JBzU4+xcvabBYLfx88mcAHq3/aJ79F1YcwE3ljUExlutExGxOw2RKto2t8PJqTXZ2PKCg0bji4lILF5datkTDyzt3Km4Xlxq0aPFFAWcWQghRHkgyUoGYLFmg1hAU3qxY5a8PXPXWe9O9Vt7BgEqiC6hBU80xi3oVJT39OOcvLCEhYQXe3m1p2eJrIKeLpF3blej0Aeic/Iq9MJgQQojySZKRCiIp7jyGfwevNu1R8FMGN7o+cPWhug+hv2mk/6Wt+3BX67EqCiEPO2ZRr/xYrSYuXVrH+QtLSE7eY9uenR2PxZJte9wwv+f/hRBCVEySjFQQe3/JmYRKZ7JQo1G9IssnZCSw9ULObK2PNsjbRXNp0wU88SFNnUHNsOINhi1rFy/+xOl/ZtueaFGpNAT430eNGk/h7d1eWkCEEKKSkmSkgri4dycAzrrijSi/PuNqm6A21PaqbbfPkmVEn+EJanBtpCngDGXv+toR1+cEUBQrRmMSOl0AIdWfoHr1x3F2Lr9jWYQQQpSOirOkXxVnSL8MgF94yyLLWqwWlp9cDuTfKpKwdjd6tQaj1Upov7vz7C9rZnM6588vYfeeXly8mDvld3DwQzRtMpe7Om2lTp0xkogIUYa6dOnCmDFjHFZ/WFgYc+bMKbPzb968GZVKRXJycqmc7+bPq6zjr2okGakATuzZT7ZODYpCxyefKLL89ovbSchIwEvvRWStvJOjhfS9B/39rqjCDWjd79zqoukZJzl+/C22bb+L4ycmk5FxkviE5bb9Go0rQUEPVsoVKYUQd1anTp2Ij4/Hy8vL0aGUWHETxeXLl3Pffffh55czkP/AgQPFOv/SpUtp1KgRzs7ONGvWjNWrC55N+k6RZKQC+OvnnBu2iwmq1atdRGlYemIpkP/A1esC7o2g9qD7Si/IQly6tI79+//D7t09OX9hMRZLOq6udWhQ/01atVx0R2IQQpQ9RVEwm/Nfy+dO0+l0BAcHV6ixZkZj3mUoCpORkcHdd9/NjBkzin3Mjh07GDBgAEOHDuWvv/6ib9++9O3bl8OHD5c03FIlyUgFkPxPzkq9Lr5FDzRNzEhk6/l/B67mM7eI1VK81T9L08X4n7mWvAtQE+Dfg1Ytv6FD+3WEhg5Cq/W44/EIIXKYzWZGjRqFl5cX/v7+vPnmm3YL+C1evJg2bdrg4eFBcHAwTz75JElJuUsmXO8KWbNmDREREej1erZt28bp06fp06cPQUFBuLu707ZtWzZs2JCn/rS0NAYMGICbmxshISHMmzfPbv+sWbNo1qwZbm5uhIaG8sILL5Cenrvu09mzZ+nduzc+Pj64ubnRpEkT27f8knTTXLlyhQEDBhASEoKrqyvNmjXj+++/L/K4ouJPTk5m2LBhBAQE4OnpSbdu3Th48KBt/1tvvUXLli358ssvbYvMDRo0iC1btjB37lxUKhUqlYrY2Nh863/66aeZNGkSkZHFXx5k7ty59OzZk1deeYXGjRszdepUWrduzccff1zsc5QFSUbKOaPBQLaSsxhXrbu7FFn++sDViKAI6njXybM/5vX1HPnvKq7tO1LaoRaoZugQwmo9z12dttC8+Xx8fe+qUN9WhLgVJoOlwJfZZCl+WWPxyt6KRYsWodVq2bNnD3PnzmXWrFl8+eWXuXWZTEydOpWDBw+yYsUKYmNjGTRoUJ7zTJgwgenTpxMTE0Pz5s1JT0/n/vvvZ+PGjfz111/07NmT3r17ExcXZ3fc+++/T4sWLfjrr7+YMGECL730EuvXr7ftV6vVfPjhhxw5coRFixbx+++/8+qrr9r2jxw5EoPBwNatWzl06BAzZszA3d2dksrOziYiIoJVq1Zx+PBhnn32WZ5++mn27NlT6HFFxd+/f3+SkpJYs2YN+/bto3Xr1nTv3p2rV6/aypw6dYqff/6Z5cuXc+DAAebOnUvHjh0ZPnw48fHxxMfHExoaml/1t2Tnzp15kpeoqCh27txZanXcCnmappzb+dOvmDVqNBYrdz3+SKFlixq4mvxXDF64oVgU1M5lNy7DZLpGfMIKaoQ8jVqtxcenPT4+7cusPiHKo89f2lLgvlpN/XhwVAvb+69f+QOz0Zpv2er1vXn45da299+8voPsdFOeciPndytxjKGhocyePRuVSkXDhg05dOgQs2fPZvjw4QB2C8bVqVOHDz/8kLZt25Kenm53058yZQo9evSwvff19aVFi9zrmzp1Kr/88gsrV65k1KhRtu133XUXEyZMAKBBgwZs376d2bNn285184DRadOmMWLECD755BMA4uLi6NevH82aNbPFeCtCQkLs1sQZPXo0a9eu5aeffqJdu3YFHldY/Nu2bWPPnj0kJSWh1+d0l3/wwQesWLGCZcuW8eyzzwI5XTPffPMNAQEBtvPqdDpcXV0JDg6+pespTEJCAkFBQXbbgoKCSEhIKPW6SkJaRsq5M1tzFsdzQY/etfA1aXZc3EF8RjyeOk961OqRZ3/8mpMApJGFV5P6efaXlhMnpnHy5DRijr1WZnUIIW5fhw4d7FopO3bsyMmTJ7H82527b98+evfuTc2aNfHw8KBz584AeVo42rRpY/c+PT2d8ePH07hxY7y9vXF3dycmJibPcR07dszzPiYmxvZ+w4YNdO/enZCQEDw8PHj66ae5cuUKmZmZALz44otMmzaNu+66i8mTJ/P333/f0udgsViYOnUqzZo1w9fXF3d3d9auXZsn3psVFv/BgwdJT0/Hz88Pd3d32+vMmTOcPn3adkytWrXsEpGqSlpGyrmsy+dBB55hjYosW9jAVavFgibZA9Sgq1V240YuX95EQuIKQE2NGgPLrB4hyrtn53YucJ/qpq+BQ96/p+CyN/VoDnyn0+2EVWwZGRlERUURFRXFt99+S0BAAHFxcURFReUZaOnm5mb3fvz48axfv54PPviAevXq4eLiwqOPPlqiAZqxsbE8+OCDPP/887zzzjv4+vqybds2hg4ditFoxNXVlWHDhhEVFcWqVatYt24d0dHRzJw5k9GjR5foWt9//33mzp3LnDlzbGNUxowZU+IBpTdKT0+nWrVqbN68Oc8+b29v2883f3ZlLTg4mMTERLttiYmJZdIKUxKSjJRjSXHnyXJSABUtHu5baFm7gav5zS2yZheuai1mRaHGYx3KINqcBe2OHX8DgJqhg/HybFHEEUJUXk764k8oWFZli7J7926797t27aJ+/fpoNBqOHTvGlStXmD59um3Mwt69e4t13u3btzNo0CAefvhhIOfGnN8gzF27duV537hxzlIP+/btw2q1MnPmTNTqnOztp59+ynOO0NBQRowYwYgRI5g4cSJffPFFiZOR7du306dPH5566ikArFYrJ06cIDw8vNDjCou/devWJCQkoNVqCQsLK1E8Op3O1jpV2jp27MjGjRvtusDWr1+fp5XnTpNumnJsx+LvUVQq9CYr4XcVPuZixakVWBQLrQNbU9e7bp7913ZfAyBDm4azv2+ZxHvy1HQMhgRcXGpRp87YMqlDCFF64uLiGDduHMePH+f777/no48+4qWXXgKgZs2a6HQ6PvroI/755x9WrlzJ1KlTi3Xe+vXr2wZkHjx4kCeffBKrNe+YmO3bt/Pee+9x4sQJ5s2bx9KlS23116tXD5PJZKt/8eLFzJ8/3+74MWPGsHbtWs6cOcP+/fvZtGmTLRkoifr167N+/Xp27NhBTEwMzz33XJ7Wg/wUFn9kZCQdO3akb9++rFu3jtjYWHbs2MHrr79eZFIXFhbG7t27iY2N5fLly/l+dgBXr17lwIEDHD2a88Tl8ePHOXDggN34j4EDBzJx4kTb+5deeonffvuNmTNncuzYMd566y327t1rN5bHESQZKccuHd4PgLNr4clDUQNXTanpuBpzHqH1bFU2TYJXr+20zabauFE0Gk3h41uEEI43cOBAsrKyaNeuHSNHjuSll16yDawMCAhg4cKFLF26lPDwcKZPn84HH3xQrPPOmjULHx8fOnXqRO/evYmKiqJ169Z5yr388svs3buXVq1aMW3aNGbNmkVUVBQALVq0YNasWcyYMYOmTZvy7bffEh0dbXe8xWJh5MiRNG7cmJ49e9KgQQPb4NaSeOONN2jdujVRUVF06dKF4OBg+vbtW+RxhcWvUqlYvXo19957L4MHD6ZBgwY88cQTnD17Ns8A0puNHz8ejUZDeHi4rXssPytXrqRVq1Y88MADADzxxBO0atXKLmmLi4sjPj7e9r5Tp0589913fP7557Ro0YJly5axYsUKmjZtWuT1liWVcuND5eVUamoqXl5epKSk4OlZvLVZKjqLxcIn/R/E6KShYbv7ePDlFwssu+3CNp7f8DyeOk829t+Is9bZbn/25auc+XIbyjU9Dad2Q6NzKtVYFcXKrt29yMw8RUjIkzRqWLxvT0JUdNnZ2Zw5c8Y2R4QQVVFhvwfFvX/LmJFy6tDvf2B00qCyKnQqYgr4pcdzB67enIgAOPv70njCQ2USJ4BKpaZZ04/458wc6tV9tegDhBBCiBtIN005dWTV/wHgYlHjWy2wwHJJmUlsOZ8zn0G/+v3uSGz5cXdvQPNmn8iMqkKIcqdXr152j9fe+Hr33XcdHZ5AWkbKrbRzJ0ELrkG1Ci13feBqq8BW1POpl2f/mW/WYc2yEPpYJ3Q+pbtglNVqICPjFB4eTUr1vEIIUZq+/PJLsrKy8t3n61s2A/pFyUgyUg5lpqWRrTIBaup3yzt52XVWxcrPJ34G8h+4CmA4rMZd7ULswq00GNu7VOM8c+ZjYs/Op27d8YTVeq5Uzy2EEKUlJCTE0SGIIkg3TTm0bclPWDRqnMxW2vW5v8ByOy/u5GLGRTx0HtxXK+8KvJe27sNdrceqKNTo1yafM9y6tLSjnI37DLDi6hJWqucWQghRtUgyUg6d370dAGeNG9pCnny5ccbV/AauXtp0AYA0dQauNauVWnxWq4mYmAkoioXAgF4EBkaV2rmFEEJUPZKMlENZKTkT1vg0KPi570uZl9h8bjOQ/8BVS5YRfUbOY1SujUpvxkaAuLgvSUs/glbrTYOGb5XquYUQQlQ9koyUM7GHjpGty/lnafv44wWWuz5wtWVAS+r75F307sKvf6BXazBarYT2u7vU4svIOM2Z2A8BaFD/DfQ6/1I7txBCiKpJkpFy5s8ffwTA2WglrFn+i+NZFSs/nyx84Gra39kAZLmkonV3LZXYFMVCTMxrWK1G/Pw6Exzct1TOK4QQomqTZKScuXbyMAAungVPF7zr4i4upF/Aw8mD+8LyDly1WiyorDkPSvl2Ks2WCxXBwQ+j1wfTqOE0u6XHhRBVV5cuXewWXquMNm/ejEqlIjk52dGhVEqSjJQjZqOJbHM6ADU6FNy1suzkMgAerPsgLtq8a8CoNRrCp0fhPiCAoMh2pRafSqWmRo3/0Knj7zg7Vy+18wohRHnXqVMn4uPj8fIqeL6m7OxsRo4ciZ+fH+7u7vTr16/IBfdUKlW+r/fff99WJiwsLM/+6dOnl9q1lQeSjJQjf/7vN0xaDWqrlbue7J9vmctZl9kUtwkouIvmOu8WjVBrbn/wqqIoWCyZtvdqtf62zymEqFgURcFsNjs6DDt3MiadTkdwcHChLcJjx47lf//7H0uXLmXLli1cvHiRRx55pNDzxsfH272+/vprVCoV/frZP5gwZcoUu3KjR48ulesqLyQZKUdObFgLgIvVCTev/BcUWnFqBWbFTIuAFjTwaZBnf2ZcPBmxF0s1rosXf2TX7l5cvbq9VM8rhHAcq9VKdHQ0tWvXxsXFxbaC63XXuyXWrFlDREQEer2ebdu2kZGRwcCBA3F3d6datWrMnDkzz7mvXbvGwIED8fHxwdXVlV69enHy5Enb/rNnz9K7d298fHxwc3OjSZMmrF69usiYC4qpuNeyceNG2rRpg6urK506deL48eMAxMbGolar2bt3r119c+bMoVatWlit1iK7aVJSUvjqq6+YNWsW3bp1IyIiggULFrBjxw527dpV4DUFBwfbvX799Ve6du1KnTp17Mp5eHjYlXNzK5sV2B1FkpFyJDPxLAAeNfJO6w45A1eXncj5BSuoVeTskj+58ukpjr67slRiys6O5+SpaLKzz5OefqxUzilEZaYoCqbsbIe8SrIIe3R0NN988w3z58/nyJEjjB07lqeeeootW7bYlZswYQLTp08nJiaG5s2b88orr7BlyxZ+/fVX1q1bx+bNm9m/f7/dMYMGDWLv3r2sXLmSnTt3oigK999/PyaTCYCRI0diMBjYunUrhw4dYsaMGbi7uxc79ptjKu61vP7668ycOZO9e/ei1WoZMmQIkNMNEhkZyYIFC+zKL1iwgEGDBqFWF32r3LdvHyaTicjISNu2Ro0aUbNmTXbu3Fms60pMTGTVqlUMHTo0z77p06fj5+dHq1ateP/998tdK9Xtkungy4lriUlkaayAiiYP5j9t+6743IGrUWF5JxqzWixokj1Qq1XofW7/n1ZRFI4fn4TFko6nZ0tCQwfd9jmFqOzMBgMfPlN4F2pZeXHRMpyc806AeDODwcC7777Lhg0b6NixIwB16tRh27ZtfPbZZ3Tu3NlWdsqUKfTokbMsRXp6Ol999RVLliyhe/fuACxatIgaNWrYyp88eZKVK1eyfft2OnXqBMC3335LaGgoK1asoH///sTFxdGvXz+aNWtmq7skboypJNfyzjvv2N5PmDCBBx54gOzsbJydnRk2bBgjRoxg1qxZ6PV69u/fz6FDh/j111+LFVNCQgI6nQ5vb2+77UFBQSQkJBTrHIsWLcLDwyNP186LL75I69at8fX1ZceOHUycOJH4+HhmzZpVrPNWBJKMlBPbl/yAolahM1lo1u2efMtcbxV5oM4D+Q5cTfxtN65qLWZFIaR/h9uOKTHxf1y+8jsqlRONG0WjUpXu5GlCCMc4deoUmZmZthv6dUajkVatWtlta9MmdymJ06dPYzQaad++vW2br68vDRs2tL2PiYlBq9XalfHz86Nhw4bExMQAOTfX559/nnXr1hEZGUm/fv1o3rx5seO/MaaSXMuNdVSrljMrdVJSEjVr1qRv376MHDmSX375hSeeeIKFCxfStWtXwsLCih3X7fr666/5z3/+g/NNCeW4ceNsPzdv3hydTsdzzz1HdHQ0en3lGMMnyUg5kfDXHgCc9d5o8hl0WpyBq1d3XcULLzK0aTj7395KlEbjZU6cnAJA7bCRuLvnHZ8ihMhLq9fz4qJlRRcso7qLIz0956m9VatW5VlE7uabW1mMTRg2bBhRUVGsWrWKdevWER0dzcyZM4s9KPPGmEpyLU5OuctrXB+IarVagZwBqgMHDmTBggU88sgjfPfdd8ydO7fY1xQcHIzRaCQ5OdmudSQxMZHg4OAij//jjz84fvw4P/4711Rh2rdvj9lsJjY21i4RrMgkGSknsjOvgpOagKat893/Xcx3toGrDX3z/s9nSk3H1egBKvBqdft/PI6feBuT6Rru7o2oVWvEbZ9PiKpCpVIVq6vEkcLDw9Hr9cTFxdl1YxSlbt26ODk5sXv3bmrWrAnkDFY9ceKE7TyNGzfGbDaze/duWzfNlStXOH78OOHh4bZzhYaGMmLECEaMGMHEiRP54osvbukJkVu9lvwMGzaMpk2b8sknn2A2m4t8EuZGERERODk5sXHjRtuTMMePHycuLs7WfVSYr776ioiICFq0aFFk2QMHDqBWqwkMDCx2fOWdJCPlQMyOPzE4qVEpCh3+k3cK+ExTJj+d+AmAgeED8z3HuWXb0KncyLZaqPPQ7U3/brUaUBQzKpWGxo2mo1YXvFifEKLi8fDwYPz48YwdOxar1crdd99NSkoK27dvx9PTk2eeeSbf49zd3Rk6dCivvPIKfn5+BAYG8vrrr9sN8Kxfvz59+vRh+PDhfPbZZ3h4eDBhwgRCQkLo06cPAGPGjKFXr140aNCAa9eusWnTJho3bnxHryU/jRs3pkOHDrz22msMGTIEF5e83eEF8fLyYujQoYwbNw5fX188PT0ZPXo0HTt2pEOH3G7zRo0aER0dzcMPP2zblpqaytKlS/N9Mmnnzp3s3r2brl274uHhwc6dO20DdH18fIodX3knyUg5cGD5cgCcTSqCw2rm2b/y9EpSDCmEuIfQvWb3fM+RdUJBBxjdU1Hrbu+fVa3W06zpJ2RknMDdvXI0AQoh7E2dOpWAgACio6P5559/8Pb2pnXr1vz3v/8t9Lj333+f9PR0evfujYeHBy+//DIpKSl2ZRYsWMBLL73Egw8+iNFo5N5772X16tW2bhKLxcLIkSM5f/48np6e9OzZk9mzZ9/xa8nP0KFD2bFjh+1Jm5KYPXs2arWafv36YTAYiIqK4pNPPrErc/z48Tyf1w8//ICiKAwYMCDPOfV6PT/88ANvvfUWBoOB2rVrM3bsWLtxJJWBSinJs2AOkpqaipeXFykpKXh65j//RkX22aMPk64x4ecZwqAvPrPbZ1Ws9P6lN3FpcUxoN4H/NP5PvufIiL3I+eX7CLi3Dr5tmtyJsIWo8rKzszlz5gy1a9fOM+hQVExTp05l6dKl/P33344OpcIo7PeguPdvaRlxMENmFlkYADW1783b6rH53Gbi0uLw0HnwcL2H8+y/zi2sOg3H3d4U7Veu/EF8ws80qP8mOp3fbZ1LCCEqkvT0dGJjY/n444+ZNm2ao8Opcm5p0rN58+YRFhaGs7Mz7du3Z8+ePQWWPXLkCP369bPNrT9nzpxbjbVS2vnTL1g0arQWKx0f65Nn/6IjiwDo36A/rk6ls/pufszmdI4d+y+Jif8jLu6rMqtHCCEKMmLECNzd3fN9jRhRtgPpR40aRUREBF26dLmlLhpxe0rcMvLjjz8ybtw45s+fT/v27ZkzZw5RUVEcP34835G9mZmZ1KlTh/79+zN27NhSCboyOfNHzuO6zjiju+kxtMOXD7M/aT9alZYnGz2Z7/GXtu7n8qrLaGuaqD/ygVuO4/TpD8g2XMTZuQZhYSNv+TxCCHGrpkyZwvjx4/PdV9Zd9AsXLmThwoVlWocoWImTkVmzZjF8+HAGDx4MwPz581m1ahVff/01EyZMyFO+bdu2tG3bFiDf/VVd1tWLoFPhVSfvSPLrrSK9avciyC0o3+MvbTqPp8qHlPOWW47hWvKfnL+wGIDGjd5Fq61cax4IISqGwMDASvW4qii+EnXTGI1G9u3bZzf3vlqtJjIysthz7xeHwWAgNTXV7lUZJfwTR9a/T822ftR+hcaL6RdZf3Y9AM80yf/RNIvRhD4j59uCa6Nbmx3VbE4nJiYnSaxe7TF8fe+6pfMIIYQQt6pEycjly5exWCwEBdl/Sy/J3PvFER0djZeXl+0VGhpaaucuT3Z++x2oVDgbrTRoZz/Z2ZKYJVgUC+2rtc93kjOAC8u3oldrMFqthPYr+dwiimLh8JExZGXFotcFUa/exFu6DiGEEOJ2lMtVeydOnEhKSortde7cOUeHVCYuH/kLAL27v932NGMay0/mzD3yTHjBE/ak/Z0NQJZLKlr3kg9uNRovk5lxOmdekeaf4uRU+R6bFkIIUf6VaMyIv78/Go2GxMREu+3FnXu/uPR6faVZ/KcgFouFbGMqOGmoFtHebt/PJ34mw5RBXa+63B2Sf4tHduJl3C0507/7dvLPt0xR9Pog2rT5mfT0GLw8i56CWAghhCgLJWoZ0el0REREsHHjRts2q9XKxo0bizX3vsh1cN0mjE4a1FaFu558wrbdZDWxJGYJAAObDLQt5nSzc0t3o1GpyLSaCIpsV6K6zeZ02886na+MExFCCOFQJe6mGTduHF988QWLFi0iJiaG559/noyMDNvTNQMHDmTixNyxB0ajkQMHDnDgwAGMRiMXLlzgwIEDnDp1qvSuogI6unoVAM4WDd6BuROMrYtdR2JmIr7OvjxQp+BHdZ2D3UglA6tfOup8VvktSEbGKXbs7MqFCz/cevBCiAqvS5cujBkzxmH1h4WFlem8U5s3b0alUpGcnFwq57v58yrr+KuaEicjjz/+OB988AGTJk2iZcuWHDhwgN9++802qDUuLo74+Hhb+YsXL9KqVStatWpFfHw8H3zwAa1atWLYsGGldxUVUPrF0wC4VQuzbVMUxfY474BGA9BrCu6qCn20C+HTe9JgfPHnFjEar3Lw4HBMpqvEJyzHajXfWvBCCFHOderUifj4eLy8vBwdSokVN1FUFIVJkyZRrVo1XFxciIyM5OTJk4Uec30C0ptfI0fmzi/VpUuXPPvLetK5W5oOftSoUYwaNSrffZs3b7Z7HxYWRgVY/uaOSr2WTJbaDKhpGNXLtn1v4l5irsbgrHHm8YZ5V+/NT3FbRaxWA4cOvUBWdhzOzqE0b/YparWsBiCEKD2KomCxWNBqHf+3RafTlepYxjvBaDSi0+mKXf69997jww8/ZNGiRdSuXZs333yTqKgojh49WuBaSX/++ScWS+68VIcPH6ZHjx7079/frtzw4cOZMmWK7b2ra9nNAA7l9Gmaym7nt0uxqtU4mS20eeA+2/brrSIP1X0IH+f8l4a2Wiwcn/U/Uo8Uv5tLURRijr1OcsqfaDTutGjxhaw9I4TAbDYzatQovLy88Pf3580337T78rh48WLatGmDh4cHwcHBPPnkkyQlJdn2X+8KWbNmDREREej1erZt28bp06fp06cPQUFBuLu707ZtWzZs2JCn/rS0NAYMGICbmxshISHMmzfPbv+sWbNo1qwZbm5uhIaG8sILL5Cenjvm7ezZs/Tu3RsfHx/c3Nxo0qQJq1evtoutON00V65cYcCAAYSEhODq6kqzZs34/vvvizyuqPiTk5MZNmwYAQEBeHp60q1bNw4ePGjb/9Zbb9GyZUu+/PJL2yJzgwYNYsuWLcydO9fWKhEbG5unbkVRmDNnDm+88QZ9+vShefPmfPPNN1y8eJEVK1YUGHNAQADBwcG21//93/9Rt25dOnfubFfO1dXVrlxZz4AryYgDnN+zHQBnrQeaf1s2/kn5hy3ntwDwVPhTBR6b+Ntu3JK8ufLNRcxpGcWq7+zZ+SQk/IJKpaFZ049wd6t/m1cghCiK1Wgp8KWYrCUoaylW2VuxaNEitFote/bsYe7cucyaNYsvv/zStt9kMjF16lQOHjzIihUriI2NZdCgQXnOM2HCBKZPn05MTAzNmzcnPT2d+++/n40bN/LXX3/Rs2dPevfuTVxcnN1x77//Pi1atOCvv/5iwoQJvPTSS6xfv962X61W8+GHH3LkyBEWLVrE77//zquvvmrbP3LkSAwGA1u3buXQoUPMmDEDd3f3En8O2dnZREREsGrVKg4fPsyzzz7L008/Xei6a8WJv3///iQlJbFmzRr27dtH69at6d69O1evXrWVOXXqFD///DPLly/nwIEDzJ07l44dOzJ8+HDi4+OJj4/Pd66tM2fOkJCQYDcJqZeXF+3bty/2JKRGo5ElS5YwZMiQPA9LfPvtt/j7+9O0aVMmTpxIZmZmsc55qxzfllYFZaclgU6Nb6Pmtm1LjuY8QdOlRhdqe9Uu8Niru6/ghTeZ2jS0HkVP256ScoDT/3wAQIP6k/Dzu/c2oxdCFMfFSTsK3Ofc0Af/wU1t7+On7sqToFynq+1F4HO5fysSZuzBmpF3vFeN6feUOMbQ0FBmz56NSqWiYcOGHDp0iNmzZzN8+HAAuwXj6tSpw4cffkjbtm1JT0+3u+lPmTKFHj162N77+vrSokXudAFTp07ll19+YeXKlXZd/HfddZdtmZAGDRqwfft2Zs+ebTvXzQNGp02bxogRI/jkk0+AnDGK/fr1o1mzZrYYb0VISIjdmjijR49m7dq1/PTTT7RrV/DTioXFv23b/7d353FRVf0fwD8zwLDvO8imIKIiCiqiz08tSDQ1TO0prdDcQnEh01zKtFAxF9yy7FFzSy01JcoVTTBB8REVUQEVwckEEZRlgGFg5vz+4OHGwMwwGDCg3/frxUvvzPeeOWfuLN8599xzLuDy5cvIz8/npqpYu3YtYmJicPjwYUybNg1ATUKwZ88eWFtbc+UKBAKuZ0KZ2olG/8kkpDExMSgqKmqQYI4fPx4uLi5wcHDAjRs3sGDBAmRmZuLIkSNqlfs8KBlpZdnXb0Is4AOMod+4mkt6n4qfIjYrFkDN5bzKVJWIYFBpAvAAk17qrR9jYuKDTh0/hkRSiA4dlPe4EEJePv369ZP7RRwQEIB169ZBKpVCS0sLKSkpWLZsGVJTU/Hs2TPIZDUJk1AoRNeuXbn9evfuLVeuSCTCsmXLcOzYMeTm5qK6uhoVFRUNekbqTwkREBAgd4XKmTNnEBUVhYyMDJSUlKC6uhpisRjl5eUwMDDA7NmzMX36dJw+fRpBQUEYM2YMevTogaaSSqVYuXIlDh48iL/++gsSiQSVlZWNjpNQVf/U1FSIRCJYWsqfEq+oqEBWVha37eLiIpeItKYdO3Zg2LBhcHBwkLu9NlECAG9vb9jb2yMwMBBZWVno1KlTi9SFkpFWdvngIQCAfhXQoYs7AOCnzJ9QKa1EV8uu6G3bW+m+fx6+AAHPEGKZFB3fUG/6dx6PB1fXGTSImJBW5vBlf6X31e8St1/ST0Ws/LbdgqbNK/S8ysrKEBwcjODgYOzbtw/W1tYQCoUIDg6GRCKRizU0lP9xNG/ePMTFxWHt2rVwd3eHvr4+xo4d22A/VXJycjBixAhMnz4dK1asgIWFBS5cuIDJkydDIpHAwMAAU6ZMQXBwMI4dO4bTp08jKioK69atw6xZs5rU1jVr1mDjxo3YsGEDN0YlIiKiSfWtTyQSwd7evsFFHQBgZmbG/b/+c6eu2l6Tx48fw97enrv98ePH6NmzZ6P7P3jwAGfOnFGrt8Pfv2Ziznv37lEy8qIounsL4AN6ZjUvpEppJX7MqJnzY0LXCUonOQOAijuAAIDEqAR8gfJDV11dhuycTXBznc2twKuqXEJI8+ML1J//p6ViG5OcnCy3fenSJXh4eEBLSwsZGRkoLCzEqlWruDELV65cUavcxMRETJw4EW+++SaAmi9mRYMwL1261GDby6tmBfOUlBTIZDKsW7cOfH7N8MaDBw82KMPJyQlhYWEICwvDokWLsG3btiYnI4mJiQgJCcF779X0HstkMty5c0eu90cRVfX39fVFXl4etLW14erq2qT6CAQCuSteFHFzc4OdnR3Onj3LJR8lJSVITk7G9OnTG32MnTt3wsbGBsOHNz49xPXr1wFALulpbjSAtRVVS6ogltUMAnLuXzN247es3/BU/BR2hnZ4zfU1pfuW3smBMavpMrR9zVVpHGNS3Lo9F0LhdqTdDFcaRwghQqEQc+fORWZmJg4cOIDNmzdjzpw5AABnZ2cIBAJs3rwZ9+/fR2xsLCIjI9Uq18PDgxuQmZqaivHjx3OneOpKTEzE6tWrcefOHWzZsgWHDh3iHt/d3R1VVVXc4+/duxdbt26V2z8iIgKnTp1CdnY2rl69inPnznHJQFN4eHggLi4OSUlJSE9Px4cffthg2RNFVNU/KCgIAQEBGDVqFE6fPo2cnBwkJSXh008/bTSpc3V1RXJyMnJyclBQUKDwuePxeIiIiMDy5csRGxuLtLQ0hIaGwsHBAaNGjeLiAgMD8fXXX8vtK5PJsHPnTkyYMKHBZdhZWVmIjIxESkoKcnJyEBsbi9DQUAwcOPC5ToGpi5KRVpR89BiqtfnQksowYNxYyJgMe27vAQC85/UedPg6Svd9+t8syACUysSwDFD+grh37ysUFJwBny9AR7fZzd0EQsgLJDQ0FBUVFejbty/Cw8MxZ84cbryAtbU1du3ahUOHDqFr165YtWoV1q5dq1a50dHRMDc3R//+/TFy5EgEBwfD19e3QdzHH3+MK1euoFevXli+fDmio6MRHBwMAPDx8UF0dDS++uordO/eHfv27UNUVJTc/lKpFOHh4fDy8sLQoUPRuXNnbnBrU3z22Wfw9fVFcHAwBg8eDDs7O7kvdGVU1Z/H4+H48eMYOHAgPvjgA3Tu3BnvvPMOHjx40GDQaX3z5s2DlpYWunbtyp0eU+STTz7BrFmzMG3aNG5g8cmTJ+XmGMnKykJBQYHcfmfOnIFQKJQboFxLIBDgzJkzGDJkCLp06YKPP/4YY8aMwa+//tro8/FP8Fg7GExQUlICU1NTFBcXt/i1zi1p94czUFAkhGG1NsJ+jsH5h+cRfjYchjqGiBsbB2OBscr9y//KQ/mDx7Dqr3hRu7/++hEZmZ8CALp1XQ87uzeavQ2EkL+JxWJkZ2dzc0QQ8jJS9T5Q9/ubxoy0ovInQkAHMHHuDADYc6umV2SMx5hGExEAMHC0g4Gj4ku9nj5NQuadpQAAN7c5lIgQQghpN+g0TSspeJSHCu2aTijvkBBkPM1Acl4ytHhaeM9L+SW3Mkk1ck8kQaZiMFN5eTbSboaDsWrY2o6Em2vTBm8RQsiLbNiwYTAyMlL4t3LlSk1Xj4B6RlpN0t4fwXg86FbJ4D14ABb9UbOy8RCXIbA3Uj5CWfhTPLRv6SIjIQ5dVrymcC2a6moR+HxdmJr0gleXr+jKGUIIqWP79u2oqKhQeJ+FhUUr14YoQslIK8lP/S8AQFfPDHlleTiZfRIAMKHbBJX7ld+UwYQHwECidFE8ExNv9Ol9BDy+AFoqVvolhJCXkaOjo6arQBpByUgrEYufATp82PTojf0Z+1HNquFn64duVt2U7pMXlwwTnj5kjKHDmK64WlyGHHHNJDyMMVRVPa2z4J3+//591rINIYRwtKskcJTKUFxVjQqthlO0E6JpOjwejLSbb26alkLJSCtIi09EpQ4fPMbQ6+038NXFminfJ3RV3StSeK4QpjBGkXYpduka4JurdxVEiRTcRghpDR34DCtN+NCqrAKP0RA80vaYaGtRMkJqpMX+AgDQr+bhfMUllFaVwtXEFYOcBindpzjtDoylRijTBlYE2iPhz5plu/uZGgLVTyESZQAADAw6Qk+v5WbFI4QoZ8Gk0ONXwkCLDy1tSkZI26On1T7GEFIy0gpKhHcALUDfqgN+SK9Znff9ru+Dz1P+4fXw5wyU6VsgwlcP93l86PJ52NDFGYEGfyElZTJkqEAHx/fh6am6d4UQ0nJq51dw1teleUYI+QcolW9hFaIyiFEzzoPn1wF/if6Cma4ZRnYaqXQfmVSK2wITTOhngPvG2rARaONoT3cMM6vEjdRpkMkqYGHxf/Dw+Ky1mkEIIYS0GEpGWljSTz9DqsWHdrUMp+1vAQDe9nwb+tr6Svc5/KQYH/c3xzNdProZ6uGEX2f4GGnjxo1pqJQ8hqGhB7y7bwafTx1bhJDnM3jwYERERGjs8V1dXbFhw4YWKz8+Ph48Hg9FRUXNUl7956ul6/+yoWSkhT1IPA8A0OXr4MazmxDwBXinyzsKY2WMYUXWI8xOF0LCGIZbmyLWzwOOegL89Wg/SktvQUfHAj49tkFbu/EZWwkh5GXVv39/5ObmwtTUVNNVaTJ1E0XGGD7//HPY29tDX18fQUFBuHtX0YUObR8lIy1M/CwXAFBkV7Pq4ohOI2Clb9Ugrqxaikk3s7FZWDNQNcLFFtu6ucLwf3OLdHAcj04d58HT80vo6zu1Uu0JIUR9jDFUV7eNS5wFAgHs7Oza1SSQEomkSfGrV6/Gpk2bsHXrViQnJ8PQ0BDBwcEQi8UtVMOWQ8lIC3qYcQ8V/1uI93fXPwEA73u93zBOLMEb1+7iZEEJdKQMn6eW4f2b98Cv8ybi83Xh6jodtjbDWqXuhJAXX3V1NWbOnAlTU1NYWVlhyZIlqLt26t69e9G7d28YGxvDzs4O48ePR35+Pnd/7amQEydOwM/PD7q6urhw4QKysrIQEhICW1tbGBkZoU+fPjhz5kyDxy8tLcW4ceNgaGgIR0dHbNmyRe7+6OhoeHt7w9DQEE5OTpgxYwZEor+nM3jw4AFGjhwJc3NzGBoaolu3bjh+/Lhc3dQ5TVNYWIhx48bB0dERBgYG8Pb2xoEDBxrdr7H6FxUVYcqUKbC2toaJiQleffVVpKamcvcvW7YMPXv2xPbt27lF5iZOnIiEhARs3LgRPB4PPB4POTk5DR6bMYYNGzbgs88+Q0hICHr06IE9e/bg0aNHiImJabTubQ0lIy0o+cefAB4PelVVyLWSYoDjALibu8vFXCkuw7CUO7glEsNSJsN//luO4blSmHm7AQAqKoSQyao0UX1CyD8gkUiU/lVVVTV77PPYvXs3tLW1cfnyZWzcuBHR0dHYvn07d39VVRUiIyORmpqKmJgY5OTkYOLEiQ3KWbhwIVatWoX09HT06NEDIpEIr7/+Os6ePYtr165h6NChGDlyJIRCodx+a9asgY+PD65du4aFCxdizpw5iIuL4+7n8/nYtGkTbt26hd27d+P333/HJ598wt0fHh6OyspKnD9/Hmlpafjqq69gZGTU5OdBLBbDz88Px44dw82bNzFt2jS8//77uHz5ssr9Gqv/W2+9hfz8fJw4cQIpKSnw9fVFYGAgnj59ysXcu3cPP//8M44cOYLr169j48aNCAgIwNSpU5Gbm4vc3Fw4OTXsDc/OzkZeXh6CgoK420xNTeHv74+LFy82+TnQNBoB2YIK02sy4Aq9cgANJzn7Oe8p5mb+iUoZQzcjPXx67AE6iw1QLCiBi1sHyGSVuHZ9Ivh8Aby7fwNDw46t3gZCyPNRtQCbh4cH3n33XW57zZo1DZKOWi4uLvjggw+47Q0bNqC8vLxB3LJly5pcRycnJ6xfvx48Hg+enp5IS0vD+vXrMXXqVADApEmTuNiOHTti06ZN6NOnD0QikdyX/pdffonXXnuN27awsICPjw+3HRkZiaNHjyI2NhYzZ87kbh8wYAAWLlwIAOjcuTMSExOxfv16rqz6A0aXL1+OsLAwfPPNNwAAoVCIMWPGwNvbm6vj83B0dMS8efO47VmzZuHUqVM4ePAg+vbtq3Q/VfW/cOECLl++jPz8fOjq1izTsXbtWsTExODw4cOYNm0agJrkcs+ePbC2tubKFQgEMDAwgJ2d4lXaASAvLw8AYGtrK3e7ra0td197Qj0jLUQqlUJcXQoAuOtQjs7mndHPvh+AmoGqUfdzEZ4uRKWMYaiVCXZJq+BRUXOFjd3rzgCAB8LtqKh4gKqqYujq2mimIYSQF1a/fv3kxlQEBATg7t27kP5vlfCUlBSMHDkSzs7OMDY2xqBBNRM11u/h6N27t9y2SCTCvHnz4OXlBTMzMxgZGSE9Pb3BfgEBAQ2209PTue0zZ84gMDAQjo6OMDY2xvvvv4/CwkIuGZs9ezaWL1+OAQMGYOnSpbhx48ZzPQ9SqRSRkZHw9vaGhYUFjIyMcOrUqQb1rU9V/VNTUyESiWBpaSm3SnB2djaysrK4fVxcXOQSkZcV9Yy0kKvHzqBKWwt8mQwpnSX4vNsE8Hg8lEmlmJ0uxLEnxQCAWc42WNTRHulLf4MpzwzFKEOHgP9DRcVfyMmpyf493BdBW7vpXY+EEM1ZvHix0vvqD6qcP3++2rGtdTluWVkZgoODERwcjH379sHa2hpCoRDBwcENTgsZGhrKbc+bNw9xcXFYu3Yt3N3doa+vj7FjxzbpdFJOTg5GjBiB6dOnY8WKFbCwsMCFCxcwefJkSCQSGBgYYMqUKQgODsaxY8dw+vRpREVFYd26dZg1a1aT2rpmzRps3LgRGzZs4MaoREREPPfpL6AmIbO3t0d8fHyD+8zMzLj/13/u1FXba/L48WPY2/89C/fjx4/Rs2fP5ypTkygZaSEZp2oGUenIxDA1s8Ew12H4SyzBxLRspIkqIODxsK6LE96ys0BZziMYVZoCPMC0b03vyN17KyCTiWFm5g9bW+UTpBFC2iaBQKDx2MYkJyfLbV+6dAkeHh7Q0tJCRkYGCgsLsWrVKm7MwpUrV9QqNzExERMnTsSbb74JoOaLWdEgzEuXLjXY9vLyAlDTKyOTybBu3Trw+TWd+AcPHmxQhpOTE8LCwhAWFoZFixZh27ZtTU5GEhMTERISgvfeew8AIJPJcOfOHXTt2lXlfqrq7+vri7y8PGhra8PV1bVJ9REIBFzvlDJubm6ws7PD2bNnueSjpKQEycnJmD59epMery2g0zQtRJSbDQAoNK3AOK9xSCuTYFjKHaSJKmCpo42fe7njLTsLAEDu8evQ4vEgklXCIeRfKCw8jydPToHH04Jn56Xt6tI0Qkj7IRQKMXfuXGRmZuLAgQPYvHkz5syZAwBwdnaGQCDA5s2bcf/+fcTGxiIyMlKtcj08PLgBmampqRg/fjxkMlmDuMTERKxevRp37tzBli1bcOjQIe7x3d3dUVVVxT3+3r17sXXrVrn9IyIicOrUKWRnZ+Pq1as4d+4clww0hYeHB+Li4pCUlIT09HR8+OGHePz4caP7qap/UFAQAgICMGrUKJw+fRo5OTlISkrCp59+2mhS5+rqiuTkZOTk5KCgoEDhc8fj8RAREYHly5cjNjYWaWlpCA0NhYODA0aNGtXk50DTKBlpAUX5hRBr1WS1GZ1kMLAYhtHX7iFfUg0vQz2c7N0ZfUz/7ppzn/E6dIbowWSgPsCrRuadLwAAHTpMgJGRp0baQAh58YWGhqKiogJ9+/ZFeHg45syZww2stLa2xq5du3Do0CF07doVq1atwtq1a9UqNzo6Gubm5ujfvz9GjhyJ4OBg+Pr6Noj7+OOPceXKFfTq1QvLly9HdHQ0goODAQA+Pj6Ijo7GV199he7du2Pfvn2IioqS218qlSI8PBxeXl4YOnQoOnfuzA1ubYrPPvsMvr6+CA4OxuDBg2FnZ6fWF7qq+vN4PBw/fhwDBw7EBx98gM6dO+Odd97BgwcPGgw6rW/evHnQ0tJC165dudNjinzyySeYNWsWpk2bxg0sPnnyZLtcJ4nH6l5U3kaVlJTA1NQUxcXFMDEx0XR1GnV847dITzoGnWopzsz5AJelnQEAQyxN8E1XF5XLOVdW5uPmrQiUl99HQL84mmmVkDasdqG82jkiCHkZqXofqPv9TWNGWsDD/yagSlsHsa+NQeb/EpFwZxss7mgPrTqnXGRSKcpzHsGo09/XkOvq2sC31z6IxY8oESGEEPJSoNM0LaCAJ8WBN6Ygs1Mv6PB42NDFCUs6OcglIgDw58F4FP4nG7eW/ip3O4/Hg76+Y2tWmRBCXljDhg2Tu7y27p+q+WBI66GekWZ27Pc4fP/vmRAZmcKYJ8UPPT3hb6b4styy69Uw4QkAHvD0aSIKCn5Hx44R1CNCCCHNaPv27aioqFB4n4WFRSvXhihCyUgzi777EKLOvWD5LB/Hhw2Ci76uwrj8c1dgwjOAjDHYv+mGzDsfobz8Pvha+nDvNE/hPoQQQprO0ZF6mts6Ok3TjL7Y9g1ude4FMBmmiXOVJiIA8ORMzWVjpVoilJglorz8PgQCK7i6fNha1SWEEELaBEpGmklh8TMcNq9ZF8H39mXMGT9BaWxpxn0YV9ecijEeJEN29mYAgHunBXSKhhBCyEuHkpFmErF9B55Y2kG/ogyRrwSojP3z4E3weTyUsAoUO56CTFYBU1M/2Nm92Uq1JYQQQtoOSkaawdlLF5DQ/V8AgMCMJPh181EaK5VUQSCqudaa+aYjP/84AD48O39BM60SQgh5KdEA1mYQdf0OJJ6+cMgT4usZqtdE0BLowH5GZzw8nILyjueBUqBDh/dgbKx6CuOSkhIYGhpCS6tmwrS8vDzExMQoje/bty8342FBQQEOHz6sNLZXr17w9/cHABQVFeHHH39UGuvt7Y0BAwYAqFlIa+/evUpjvby8uFU+KysrsXPnTqWx7u7uCAoKAlAzq+K2bduUxrq6umLo0KHc9n/+8x+F0yUDQIcOHTBixAhu+/vvv1e6+JWtrS23lgYA7N27F2VlZQpjLS0t8dZbb3HbBw4cQHFxscJYU1NTjBs3jts+dOgQCgsLFcYaGBggNDSU246JiVG6HLhAIJBb4v23337Dw4cPFcby+XxuZk0AOHnypMK1QmpNnTqVe62dPXsWd+/eVRr7wQcfcEukJyQkyK26Wt97773HLT2fmJiItLQ0pbHvvPMOt6BYcnIyrl27pjR27NixsLKyAgBcvXoVly9fVhobEhLCLSx248YNJCUlKY0dPnw4ty7L7du3cf78ebn79fT00LVrVxQWFsLKyop7HsRiMUpKSpSWa2Jiwk0OVVlZqfS1AwDGxsbQ169Zs0oikaCoqEhprJGREQwMDAAAVVVVePbsmdJYQ0NDbpG2xmINDAy441ZdXY2nT5+qFSuVSpW+1gFAX18fxsY1p6ZlMhkKCgqUxurp6XGTZjHG8OTJE6Wxurq6MDU15bafPHkCZfN7CgQCuYXrlE2/DgA6OjowNzfntgsLC5WuIaOtrS13pY6qWC0tLVhaWnLbT58+RXV1tcJYPp/PvdYB4NmzZ6iqqlIYW/c5a+soGfmHIrd/i5ueAQCT4X3ZU7VmYTR0dYDnPAdUSgKQk/01Orp9pDL+7t27OHLkCPz8/LgvbIlEovRLCqhZmKpWVVWVytjS0lLu/1KpVGWsi4uL2rEODg7c/2UymcrYum8uACpj637I1MYq+/Co/WCu9fjxY1RWViqM1daWfzvk5+fLPTd11f9ge/LkidIP6PrJT0FBgdJ1L2o/xGsVFhYqfS5qv/hqPX36VGls7UJjtZ49e6byOa7bvqKiIpWxdZ/74uJitWNLSkpUxtb9MBaJRCpj634YNyW2rKxMZWzd10pFRUWDWCMjI0ilUkilUrm2yWQypV8mtfdrOnbo0KHw8/PDhg0bwBhTu1wAKmPrf+Eqi/X398eMGTOwaNEitcqtf5+qWC0tLcTHx+OVV15R+WUNNHxvVFVVKUxcxo4dC29vb3z33XcAan4UTZo0CVOmTFFadv36KktG6j9edXW1ymRE3VhVz1FbQ8nIP/CsuAiHTF0BAL3S/4uPwlVfCSMueAo9q78zZV2BFTw9lymNl8lkiI+P536N3b9/H9XV1dDW1oa1tTW3wqQidTNyc3NzlbF1fxUYGxurjK2bCOjr66uMrZuRCwQClbF1v4R5PJ7K2PpLbo8fP15pbO0vylpvv/220sSlfiI5evRopR8e9VdODQkJUfqBp6OjI7c9fPhwpb0ztb0RtYKDgyEWixXG1v9QCgwMRP/+/RXG1jd48GD06dNH6f11yx4wYAB8fJSfeqz7XPTr10/lSqd1j0fv3r3h4eGhNLbu66dnz55yiXB9dX+tdu/eXS4Rrs/a2pr7f5cuXeS266u7NLu7u3uD16VUKkVlZSVMTU3lngddXV2V81fUfU0IBAKVsXWTZB0dnWaLrXuM6/+Kr6/u65LP56sdy+PxlMby+Xy550xVbP1yAdXzg/D5fPTv3x+5ubkwNTVV+SOx/vvIwsJCYTKira3d4H1vYGCgtB71T7ubmZkp7Z2pHzt27Fj06NFD4VpAdWMZY9iwYQO+//57FBUVISAgAJs2bYK7uzuAhs8ZAERFReHIkSPIyMiAvr4++vfvj6+++gqenn+vgzZ48GAkJCTI7ffhhx82WKiwOVEy8g/M2b4d+b5B0BOXY9n/+Tcan706BYzHYDS8FM4Dx6iMFYlE+Pnnn5GdXbP6b58+fRAcHMx92Ojr63MvuMbo6empHSsQCNSO1dHRUTtWS0tL7Vg+n692LIAmxXbs2FHtWDc3N7VjVX1R1ufs7Kx2bIcOHdSObcpcCnW/ZBtjZ2endqyNjQ1sbGzUirW2tlaZCNRlaWkp142tioWFhdoTWZmbm8slMqqYmpo26JWrXZNDV1dX7oNfS0tL4ReBIi0Vy+fzVX4J1/1SayxW3XIZY3IJvKpYHo/XIHFRtw7qxta+dpuyblD9HsdafD6/wXOvra2tdtnKyq1LIpFAIBCAz+erVfbq1auxZcsW7N69G25ubliyZAneeOMN3L59W+m+CQkJCA8PR58+fVBdXY3FixdjyJAhuH37ttwPvalTp+LLL7/ktuv3Mjc3GsD6nH5PTkJCt5pBq0HpifDv0VNlfO6xJBjz9cCzuI+71Z/gRtoMMKb4F/qDBw/w3XffITs7Gzo6Ohg9ejSGDx/e4DQCIYT8E9XV1Zg5cyZMTU1hZWWFJUuWyP1637t3L3r37g1jY2PY2dlh/PjxyM/P5+6Pj48Hj8fDiRMn4OfnB11dXVy4cAFZWVkICQmBra0tjIyM0KdPH5w5c6bB45eWlmLcuHEwNDSEo6MjtmzZInd/dHQ0vL29YWhoCCcnJ8yYMUPuFPSDBw8wcuRImJubw9DQEN26dcPx48fl6qZqjE2twsJCjBs3Do6OjjAwMIC3tzcOHDjQ6H6N1b+oqAhTpkyBtbU1TExM8OqrryI1NZW7f9myZejZsye2b9/OLTI3ceJEJCQkYOPGjeDxeODxeArHd9X2inz22WcICQlBjx49sGfPHjx69EjleMKTJ09i4sSJ6NatG3x8fLBr1y4IhUKkpKTIxRkYGMDOzo77a+mxJ5SMPKeoa+mo1NWDw2MhNobNaDT+6YUiMF41HnfdA6BmQTwer+HTLxaLceDAAZSWlsLKygpTp05Fjx49mr3+hJCWJZWWq/irbEKsWK3Y57F7925oa2vj8uXL2LhxI6Kjo7F9+3bu/qqqKkRGRiI1NRUxMTHIycnBxIkTG5SzcOFCrFq1Cunp6ejRowdEIhFef/11nD17FteuXcPQoUMxcuRICIVCuf3WrFkDHx8fXLt2DQsXLsScOXMQFxfH3c/n87Fp0ybcunULu3fvxu+//45PPvmEuz88PByVlZU4f/480tLS8NVXXzUYd6UOsVgMPz8/HDt2DDdv3sS0adPw/vvvqxwIrU7933rrLeTn5+PEiRNISUmBr68vAgMD5caX3bt3Dz///DOOHDmC69evY+PGjQgICMDUqVORm5uL3NxcbhB1XdnZ2cjLy+PGEQI1vXf+/v64ePGi2m2vHTxdvzdx3759sLKyQvfu3bFo0SKUlz/fa0xd9FP7OazYsRVpnv0AJsN71YUwNDBUGf/s6m2YyIzwzPUkpIaPoaNjgY5ucxXG6unp4fXXX8edO3cwcuRItbr2CCFtT3yCt9L7LC0Ho6fPDm77/B99IZMpXjvFzMwffr77ue3EpEGoqmo4WDrw1awm19HJyQnr168Hj8eDp6cn0tLSsH79ekydOhUA5K7W6tixIzZt2oQ+ffpAJBLJfel/+eWXeO2117htCwsLuXFGkZGROHr0KGJjYzFz5kzu9gEDBmDhwoUAgM6dOyMxMRHr16/nyoqIiOBiXV1dsXz5coSFheGbb74BAAiFQowZMwbe3t5cHZ+Ho6Mj5s37exmOWbNm4dSpUzh48CD69u2rdD9V9b9w4QIuX76M/Px87nN87dq1iImJweHDh7mr2yQSCfbs2SN3ylIgEHA9E8rUDqa2tbWVu93W1lbloOy6ZDIZIiIiMGDAAHTv3p27ffz48XBxcYGDgwNu3LiBBQsWIDMzE0eOHFGr3OdByUgTFZeW4CeTmnP+vTL+i7kzGp++/dEvWTDQYyjoFAOgZqZVHZ2/u7xyc3NRXV3NZb89evSAt7c3zTtCCGlR/fr1k/ucCQgIwLp16yCVSqGlpYWUlBQsW7YMqampePbsGTf4WygUyg1U7t27t1y5IpEIy5Ytw7Fjx7jPt4qKigY9IwEBAQ22N2zYwG2fOXMGUVFRyMjIQElJCaqrqyEWi1FeXg4DAwPMnj0b06dPx+nTpxEUFIQxY8Y8V0+yVCrFypUrcfDgQfz111+QSCSorKxsdJyEqvqnpqZCJBI1GOtUUVGBrKy/E0cXFxe1x041t/DwcNy8eRMXLlyQu73uNADe3t6wt7dHYGAgsrKy0KlTpxapCyUjTTRr23+Q36tm0OrnA3o3Gl/+Vx4MxabI77EVTLsSJia9YG8/mrv/6tWrOH78OPT09BAWFsb92qBEhJD2bfAg5XOoAPIDIQf+n6rTAfKncwf0T1AS17zKysoQHByM4OBg7Nu3D9bW1hAKhQgODm5wNVj9K9zmzZuHuLg4rF27Fu7u7tDX18fYsWOVXkWmSE5ODkaMGIHp06djxYoVsLCwwIULFzB58mRIJBIYGBhgypQpCA4OxrFjx3D69GlERUVh3bp1mDVL9XxP9a1ZswYbN27Ehg0buDEqERERTapvfSKRCPb29oiPj29wX90rGOs/d+qq7TV5/Pix3ID0x48fo2fPno3uP3PmTPz22284f/58owPla+ehunfvHiUjbUH8fy8ioWvNoNVX0xMRMGx+o/v8+eN/wbPIRal9MgAePD2XgcfjQyKR4Pjx47h+/TqAmqsb6l9iRghpv7S01L/6oKViG5OcnCy3fenSJXh4eEBLSwsZGRkoLCzEqlWruF7bK1euqFVuYmIiJk6cyE0iKBKJFA7CvHTpUoNtL6+aCSBTUlIgk8mwbt067rPx4MGDDcpwcnJCWFgYwsLCsGjRImzbtq3JyUhiYiJCQkK4S7dlMhnu3Lmj8jL1xurv6+uLvLw8aGtrw9XVtUn1EQgESqcVqOXm5gY7OzucPXuWSz5KSkqQnJyM6dOnK92PMYZZs2bh6NGjiI+PV+uqwbrfUy2Fvv2aYOWVW6jU1YP944fYpMagVQDoNCMIEodyaFdbwtHxXZgYd0dhYSF27NiB69evg8fjITAwEOPGjWvxS6cIIaQuoVCIuXPnIjMzEwcOHMDmzZsxZ84cADWXoAsEAmzevBn3799HbGwsIiMj1SrXw8ODG5CZmpqK8ePHK5zfJzExEatXr8adO3ewZcsWHDp0iHt8d3d3VFVVcY+/d+/eBvNcRERE4NSpU8jOzsbVq1dx7tw5LhloCg8PD8TFxSEpKQnp6en48MMPlU5MqG79g4KCEBAQgFGjRuH06dPIyclBUlISPv3000aTOldXVyQnJyMnJ0fpjLA8Hg8RERFYvnw5YmNjkZaWhtDQUDg4OGDUqFFcXGBgIL7++mtuOzw8HD/88AP2798PY2Nj5OXlIS8vDxUVNWOWsrKyEBkZiZSUFOTk5CA2NhahoaEYOHBgy15MwdqB4uJiBoAVFxdrrA4rv/+O2f5+jdn+fo2t2b29yftXV1ewqqpSduvWLbZixQq2dOlStnr1anb//v0WqC0hpDVUVFSw27dvs4qKCk1XpckGDRrEZsyYwcLCwpiJiQkzNzdnixcvZjKZjIvZv38/c3V1Zbq6uiwgIIDFxsYyAOzatWuMMcbOnTvHALBnz57JlZ2dnc1eeeUVpq+vz5ycnNjXX3/NBg0axObMmcPFuLi4sC+++IK99dZbzMDAgNnZ2bGNGzfKlRMdHc3s7e2Zvr4+Cw4OZnv27JF7vJkzZ7JOnToxXV1dZm1tzd5//31WUFCgsm6KFBYWspCQEGZkZMRsbGzYZ599xkJDQ1lISIjc89XU+peUlLBZs2YxBwcHpqOjw5ycnNi7777LhEIhY4yxpUuXMh8fnwb1yczMZP369WP6+voMAMvOzlZYb5lMxpYsWcJsbW2Zrq4uCwwMZJmZmXIxLi4ubOnSpdw2AIV/O3fuZIwxJhQK2cCBA5mFhQXT1dVl7u7ubP78+Sq/f1W9D9T9/ub9r3JtWklJCUxNTVFcXKyRefaLS0sw8MQFPLZ2QM/0yzg5Y1qj+8ikUsgkEmjXmwH00KFDuHXrFpydnTF27Nh2s24AIaSh2knPaueIIORlpOp9oO73N40ZUcPs//wHj/830+rSAX5q7fPX0T+QW7oPWloW8H1/JXi8mgFrI0eOhL29PQICAtSeSZEQQgh5kdGYkUacT7mM+G41q9S+kp6EAB/1kpGCrDSUuvyOIsefcezYdm5WQz09PfzrX/+iRIQQQlrJsGHDYGRkpPBv5cqVmq4eAfWMNGr55Ruo7NIbdvkPsTlM+Qjlup78cQWiLocAALm5Hrh3LxcdOqSqdbkVIYSQ5rV9+3ZugGZ96q5jRFoWJSMqfLV7G250qVnZdFxlHowamWm11t3b+yDx+AtVVbrIyekJX19fdOvWrSWrSgghRImmLCJJNIOSESVE5WU4oFezDLlP+n+xYMZUtfZL+OELVLqdgBaABzm+GDHibeoRIYQQQlSgZESJWd9+gzzf16AnrsDnAb3U2ufXXeNh4JwMLQCiIluEhKyBnV3LTRJDCCGEvAhoAKsCideu4Nz/ZlodnJ6IAb0an/YdAOxMBkAm46Pszz54pf9BSkQIIYQQNVDPiAJfXrwGsVcf2OX/ha9VDFq9/ttO5D9Jw5APogEAfUaHQ3itB5yD/q+1qkoIIYS0e9QzUs9Xe7Yj1et/g1bFjxQOWi1+9ACxu99Ggf4K8Jx+Rcbvfy+r7NyLEhFCCCGkKSgZqUNUXoYDujUrIfbIuIIFExoOWk34IRKJ19+AodMV8HgMFQUdYWCumeWfCSGkLRg8eDAiIiI0XY0WFR8fDx6Ph6KiIk1X5YVEyUgds7Z+izybDtCtrMBnfeUXBBJe+wO//DgU1Q67oKsnQqXYCNqPQvHGO6eoN4QQQl5w/fv3R25uLkxNTZXGiMVihIeHw9LSEkZGRhgzZoxaC+4RSkY4F1NTcM6rPwBg8K1EDPTry91Xmv8XbuVNh5HNXTDGQ9mffgjocRSD3luqqeoSQkirYoyhurpa09WQ05p1EggEsLOzA4/HUxrz0Ucf4ddff8WhQ4eQkJCAR48eYfTo0a1Sv/aOkpH/+SIxBWI9A9g+eYRN0+QXwjO2cYQ0rzfKS2xgWb4Yb0w4CPMOHTVUU0II+edkMhmioqLg5uYGfX19+Pj44PDhw9z9taclTpw4AT8/P+jq6uLChQsoKytDaGgojIyMYG9vj3Xr1jUo+9mzZwgNDYW5uTkMDAwwbNgw3L17l7v/wYMHGDlyJMzNzWFoaIhu3brh+PHjjdZZWZ3UbcvZs2fRu3dvGBgYoH///sjMzAQA5OTkgM/n48qVK3KPt2HDBri4uEAmkzV6mqa4uBg7duxAdHQ0Xn31Vfj5+WHnzp1ISkrCpUuXGm3by46upgGwds8OXPeq6Ql5p+wheGUl+PXnD2Fr1B99x84CAASOWQ8tHV0I9A00WVVCSBvHGEO5TKaRxzbg81X+cq8rKioKP/zwA7Zu3QoPDw+cP38e7733HqytrTFo0CAubuHChVi7di06duwIc3NzzJ8/HwkJCfjll19gY2ODxYsX4+rVq3KTO06cOBF3795FbGwsTExMsGDBArz++uu4ffs2dHR0EB4eDolEgvPnz8PQ0BC3b9+GkZGR2u2sXyd12/Lpp59i3bp1sLa2RlhYGCZNmoTExES4uroiKCgIO3fuRO/ef0/lsHPnTkycOBF8fuO/21NSUlBVVYWgoCDuti5dusDZ2RkXL15Ev3791G7fy+ilT0ZE5WXYJ7AFAHhnpuBfxk9wIWUEDJxLkS+6B4noAwiMjKBvYq7hmhJC2oNymQydzqdp5LGzBnrDUI1FOCsrK7Fy5UqcOXMGAQEBAICOHTviwoUL+O677+S+wL/88ku89tprAACRSIQdO3bghx9+QGBgIABg9+7d6NChAxdfm4QkJiaif/+aU9/79u2Dk5MTYmJi8NZbb0EoFGLMmDHw9vbmHrsp6tapKW1ZsWIFt71w4UIMHz4cYrEYenp6mDJlCsLCwhAdHQ1dXV1cvXoVaWlp+OWXX9SqU15eHgQCAczMzORut7W1RV5eXpPa9zJ6rtM0W7ZsgaurK/T09ODv74/Lly+rjD906BC6dOkCPT09eHt7q9Ud11pmb/0GubYdoCsRI9TsJCT230NXvxQSsSEMi4dB0IRsnRBC2oN79+6hvLwcr732mtwKtnv27EFWVpZcbN2egqysLEgkEvj7+3O3WVhYwNPTk9tOT0+Htra2XIylpSU8PT2Rnp4OAJg9ezaWL1+OAQMGYOnSpbhx40aT6l+3Tk1pS48ef1+YYG9fMyllfn4+AGDUqFHQ0tLC0aNHAQC7du3CK6+8AldX1ybVjTyfJveM/PTTT5g7dy62bt0Kf39/bNiwAcHBwcjMzISNjU2D+KSkJIwbNw5RUVEYMWIE9u/fj1GjRuHq1avo3r17szTieV1MTcHvXgMAAGP5P8LB5ioY46H8r1741+BVsHDupNH6EULaHwM+H1kDvTX22OoQiUQAgGPHjjVYRE5XV1du29BQvQVCm2LKlCkIDg7GsWPHcPr0aURFRWHdunWYNWuWWvvXrVNT2qKjo8P9v/Z0lux/p9QEAgFCQ0Oxc+dOjB49Gvv378fGjRvVbpOdnR0kEgmKiorkekceP34MOzs7tct5WTU5GYmOjsbUqVPxwQcfAAC2bt2KY8eO4fvvv8fChQsbxG/cuBFDhw7F/PnzAQCRkZGIi4vD119/ja1btzbpsQ8f3gN9XYHC+3hafOjZOnPb4vyHYEpGWfP4fOjZOePbDCHEXXrDmeUgWOsYKkqt4IApCApVb1E8Qgipj8fjqXWqRJO6du0KXV1dCIVCudMYjenUqRN0dHSQnJwMZ+eaz9tnz57hzp07XDleXl6orq5GcnIyd5qmsLAQmZmZ6Nq1K1eWk5MTwsLCEBYWhkWLFmHbtm1qJyPN0RZFpkyZgu7du+Obb75BdXV1k66E8fPzg46ODs6ePYsxY8YAADIzMyEUCrnTR0S5JiUjEokEKSkpWLRoEXcbn89HUFAQLl68qHCfixcvYu7cuXK3BQcHIyYmRunjVFZWorKyktsuKSkBACy06Qm+oZqnTRT00jTQpSbm38W/ofrZKxjy72g6LUMIeeEZGxtj3rx5+OijjyCTyfCvf/0LxcXFSExMhImJCSZMmKBwPyMjI0yePBnz58+HpaUlbGxs8Omnn8oN8PTw8EBISAimTp2K7777DsbGxli4cCEcHR0REhICAIiIiMCwYcPQuXNnPHv2DOfOnYOXl1ertkURLy8v9OvXDwsWLMCkSZOgr6+v9r6mpqaYPHky5s6dCwsLC5iYmGDWrFkICAigwatqaFIyUlBQAKlUCltbW7nbbW1tkZGRoXCfvLw8hfGqBvRERUXhiy++aHC7DpOAzyRK92PSv0eR87SY0jguljH4ZVxGxPRvoV2n+44QQl50kZGRsLa2RlRUFO7fvw8zMzP4+vpi8eLFKvdbs2YNRCIRRo4cCWNjY3z88ccoLi6Wi9m5cyfmzJmDESNGQCKRYODAgTh+/Dh3mkQqlSI8PBwPHz6EiYkJhg4divXr17d6WxSZPHkykpKSMGnSpCbvu379evD5fIwZMwaVlZUIDg7GN9980+RyXkY8xpjqb+06Hj16BEdHRyQlJcl1O33yySdISEhAcnJyg30EAgF2796NcePGcbd98803+OKLL5TOTKeoZ8TJyQnFxcUwMTFRt7qEENKixGIxsrOz4ebmBj09PU1XhzSDyMhIHDp0qMmDal9mqt4HJSUlMDU1bfT7u0k9I1ZWVtDS0mqQRKgaoGNnZ9ekeKBm0FH9gUeEEEJISxGJRMjJycHXX3+N5cuXa7o6L50mXdorEAjg5+eHs2fPcrfJZDKcPXtW6QCdgIAAuXgAiIuLowE9hBBC5ISFhcldnlv3LywsrEUfe+bMmfDz88PgwYOf6xQN+WeadJoGqLm0d8KECfjuu+/Qt29fbNiwAQcPHkRGRgZsbW0RGhoKR0dHREVFAai5tHfQoEFYtWoVhg8fjh9//BErV65s0qW96nbzEEJIa6LTNM0rPz+fu2ChPhMTE4XTRxDNa/XTNADw9ttv48mTJ/j888+Rl5eHnj174uTJk9wgVaFQKDeyun///ti/fz8+++wzLF68GB4eHoiJidH4HCOEEELaFhsbG0o4XlJN7hnRBOoZIYS0RdQzQkjz9IzQqr2EEPIPtYPfdIS0mOZ4/VMyQgghz6l23ozy8nIN14QQzal9/ev8g/m6XvpVewkh5HlpaWnBzMyMW2zNwMCAW/OEkBcdYwzl5eXIz8+HmZkZtP7BMgiUjBBCyD9QO2dSbUJCyMvGzMzsHy8GSMkIIYT8AzweD/b29rCxsUFVVZWmq0NIq9LR0flHPSK1KBkhhJBmoKWl1SwfyoS8jGgAKyGEEEI0ipIRQgghhGgUJSOEEEII0ah2MWakdkIVZWsWEEIIIaTtqf3ebmxitHaRjJSWlgIAnJycNFwTQgghhDRVaWkpTE1Nld7fLtamkclkePToEYyNjZt1QqGSkhI4OTnhzz//fOHWvKG2tU/UtvaJ2tZ+vcjtawttY4yhtLQUDg4Ocovo1tcuekb4fD46dOjQYuWbmJi8cC/CWtS29ona1j5R29qvF7l9mm6bqh6RWjSAlRBCCCEaRckIIYQQQjTqpU5GdHV1sXTpUujq6mq6Ks2O2tY+UdvaJ2pb+/Uit689ta1dDGAlhBBCyIvrpe4ZIYQQQojmUTJCCCGEEI2iZIQQQgghGkXJCCGEEEI06oVJRs6fP4+RI0fCwcEBPB4PMTExcvczxvD555/D3t4e+vr6CAoKwt27dxstd8uWLXB1dYWenh78/f1x+fLlFmqBcqraVlVVhQULFsDb2xuGhoZwcHBAaGgoHj16pLLMZcuWgcfjyf116dKlhVvSUGPHbeLEiQ3qOXTo0EbLbevHDUCDdtX+rVmzRmmZbeW4RUVFoU+fPjA2NoaNjQ1GjRqFzMxMuRixWIzw8HBYWlrCyMgIY8aMwePHj1WW+7zv0+bUWNuePn2KWbNmwdPTE/r6+nB2dsbs2bNRXFysstznfS03J3WO2+DBgxvUMywsTGW57eG45eTkKH3PHTp0SGm5beG4ffvtt+jRowc3eVlAQABOnDjB3d9e32t1vTDJSFlZGXx8fLBlyxaF969evRqbNm3C1q1bkZycDENDQwQHB0MsFist86effsLcuXOxdOlSXL16FT4+PggODkZ+fn5LNUMhVW0rLy/H1atXsWTJEly9ehVHjhxBZmYm3njjjUbL7datG3Jzc7m/CxcutET1VWrsuAHA0KFD5ep54MABlWW2h+MGQK5Nubm5+P7778Hj8TBmzBiV5baF45aQkIDw8HBcunQJcXFxqKqqwpAhQ1BWVsbFfPTRR/j1119x6NAhJCQk4NGjRxg9erTKcp/nfdrcGmvbo0eP8OjRI6xduxY3b97Erl27cPLkSUyePLnRspv6Wm5u6hw3AJg6dapcPVevXq2y3PZw3JycnBq857744gsYGRlh2LBhKsvW9HHr0KEDVq1ahZSUFFy5cgWvvvoqQkJCcOvWLQDt970mh72AALCjR49y2zKZjNnZ2bE1a9ZwtxUVFTFdXV124MABpeX07duXhYeHc9tSqZQ5ODiwqKioFqm3Ouq3TZHLly8zAOzBgwdKY5YuXcp8fHyat3L/kKK2TZgwgYWEhDSpnPZ63EJCQtirr76qMqYtHjfGGMvPz2cAWEJCAmOs5v2lo6PDDh06xMWkp6czAOzixYsKy3je92lLq982RQ4ePMgEAgGrqqpSGvM8r+WWpqhtgwYNYnPmzFG7jPZ83Hr27MkmTZqkspy2eNwYY8zc3Jxt3779hXmvvTA9I6pkZ2cjLy8PQUFB3G2mpqbw9/fHxYsXFe4jkUiQkpIitw+fz0dQUJDSfdqK4uJi8Hg8mJmZqYy7e/cuHBwc0LFjR7z77rsQCoWtU8Emio+Ph42NDTw9PTF9+nQUFhYqjW2vx+3x48c4duyYWr+u2+Jxqz1FYWFhAQBISUlBVVWV3HHo0qULnJ2dlR6H53mftob6bVMWY2JiAm1t1ct9NeW13BqUtW3fvn2wsrJC9+7dsWjRIpSXlysto70et5SUFFy/fl2t91xbOm5SqRQ//vgjysrKEBAQ8MK819rFQnn/VF5eHgDA1tZW7nZbW1vuvvoKCgoglUoV7pORkdEyFW0GYrEYCxYswLhx41QujOTv749du3bB09OT6678v//7P9y8eRPGxsatWGPVhg4ditGjR8PNzQ1ZWVlYvHgxhg0bhosXL0JLS6tBfHs9brt374axsXGjXatt8bjJZDJERERgwIAB6N69O4Ca95xAIGiQEKt6zz3P+7SlKWpbfQUFBYiMjMS0adNUltXU13JLU9a28ePHw8XFBQ4ODrhx4wYWLFiAzMxMHDlyRGE57fW47dixA15eXujfv7/KstrKcUtLS0NAQADEYjGMjIxw9OhRdO3aFdevX38h3msvRTLysqiqqsK///1vMMbw7bffqoyte460R48e8Pf3h4uLCw4ePKjWL4XW8s4773D/9/b2Ro8ePdCpUyfEx8cjMDBQgzVrXt9//z3effdd6OnpqYxri8ctPDwcN2/e1MjYlZbWWNtKSkowfPhwdO3aFcuWLVNZVlt7LStrW92kytvbG/b29ggMDERWVhY6derU2tV8Lo0dt4qKCuzfvx9LlixptKy2ctw8PT1x/fp1FBcX4/Dhw5gwYQISEhJa7fFb2ktxmsbOzg4AGowufvz4MXdffVZWVtDS0mrSPppUm4g8ePAAcXFxTV4u2szMDJ07d8a9e/daqIbNo2PHjrCyslJaz/Z23ADgjz/+QGZmJqZMmdLkfTV93GbOnInffvsN586dQ4cOHbjb7ezsIJFIUFRUJBev6jg8z/u0JSlrW63S0lIMHToUxsbGOHr0KHR0dJpUfmOv5ZbUWNvq8vf3BwCl9Wxvxw0ADh8+jPLycoSGhja5fE0dN4FAAHd3d/j5+SEqKgo+Pj7YuHHjC/FeA16SZMTNzQ12dnY4e/Ysd1tJSQmSk5MREBCgcB+BQAA/Pz+5fWQyGc6ePat0H02pTUTu3r2LM2fOwNLSsslliEQiZGVlwd7evgVq2HwePnyIwsJCpfVsT8et1o4dO+Dn5wcfH58m76up48YYw8yZM3H06FH8/vvvcHNzk7vfz88POjo6cschMzMTQqFQ6XF4nvdpS2isbbX1GjJkCAQCAWJjYxvt0VKksddyS1CnbfVdv34dAJTWsz0dt1o7duzAG2+8AWtr6yY/jiaOmyIymQyVlZXt+r0mRyPDZltAaWkpu3btGrt27RoDwKKjo9m1a9e4K0pWrVrFzMzM2C+//MJu3LjBQkJCmJubG6uoqODKePXVV9nmzZu57R9//JHp6uqyXbt2sdu3b7Np06YxMzMzlpeX12baJpFI2BtvvME6dOjArl+/znJzc7m/yspKpW37+OOPWXx8PMvOzmaJiYksKCiIWVlZsfz8/DbTttLSUjZv3jx28eJFlp2dzc6cOcN8fX2Zh4cHE4vFStvWHo5breLiYmZgYMC+/fZbhWW01eM2ffp0ZmpqyuLj4+Vec+Xl5VxMWFgYc3Z2Zr///ju7cuUKCwgIYAEBAXLleHp6siNHjnDb6rxPNd224uJi5u/vz7y9vdm9e/fkYqqrqxW2Td3Xsqbbdu/ePfbll1+yK1eusOzsbPbLL7+wjh07soEDB8qV0x6PW627d+8yHo/HTpw4obCctnjcFi5cyBISElh2dja7ceMGW7hwIePxeOz06dOMsfb7XqvrhUlGzp07xwA0+JswYQJjrOZSpiVLljBbW1umq6vLAgMDWWZmplwZLi4ubOnSpXK3bd68mTk7OzOBQMD69u3LLl261Eot+puqtmVnZyu8DwA7d+4cV0b9tr399tvM3t6eCQQC5ujoyN5++2127969NtW28vJyNmTIEGZtbc10dHSYi4sLmzp1aoOkoj0et1rfffcd09fXZ0VFRQrLaKvHTdlrbufOnVxMRUUFmzFjBjM3N2cGBgbszTffZLm5uQ3KqbuPOu/TltZY25QdVwAsOztbYdvUfS1rum1CoZANHDiQWVhYMF1dXebu7s7mz5/PiouLG5TT3o5brUWLFjEnJycmlUqVltPWjtukSZOYi4sLEwgEzNramgUGBnKJCGPt971WF48xxv5x9wohhBBCyHN6KcaMEEIIIaTtomSEEEIIIRpFyQghhBBCNIqSEUIIIYRoFCUjhBBCCNEoSkYIIYQQolGUjBBCCCFEoygZIYQQQohGUTJCCGlxEydOxKhRozRdDUJIG0XJCCGEEEI0ipIRQkizOXz4MLy9vaGvrw9LS0sEBQVh/vz52L17N3755RfweDzweDzEx8cDAP7880/8+9//hpmZGSwsLBASEoKcnByuvNoelS+++ALW1tYwMTFBWFgYJBKJZhpICGkR2pquACHkxZCbm4tx48Zh9erVePPNN1FaWoo//vgDoaGhEAqFKCkpwc6dOwEAFhYWqKqqQnBwMAICAvDHH39AW1sby5cvx9ChQ3Hjxg0IBAIAwNmzZ6Gnp4f4+Hjk5OTggw8+gKWlJVasWKHJ5hJCmhElI4SQZpGbm4vq6mqMHj0aLi4uAABvb28AgL6+PiorK2FnZ8fF//DDD5DJZNi+fTt4PB4AYOfOnTAzM0N8fDyGDBkCABAIBPj+++9hYGCAbt264csvv8T8+fMRGRkJPp86dwl5EdA7mRDSLHx8fBAYGAhvb2+89dZb2LZtG549e6Y0PjU1Fffu3YOxsTGMjIxgZGQECwsLiMViZGVlyZVrYGDAbQcEBEAkEuHPP/9s0fYQQloP9YwQQpqFlpYW4uLikJSUhNOnT2Pz5s349NNPkZycrDBeJBLBz88P+/bta3CftbV1S1eXENKGUDJCCGk2PB4PAwYMwIABA/D555/DxcUFR48ehUAggFQqlYv19fXFTz/9BBsbG5iYmCgtMzU1FRUVFdDX1wcAXLp0CUZGRnBycmrRthBCWg+dpiGENIvk5GSsXLkSV65cgVAoxJEjR/DkyRN4eXnB1dUVN27cQGZmJgoKClBVVYV3330XVlZWCAkJwR9//IHs7GzEx8dj9uzZePjwIVeuRCLB5MmTcfv2bRw/fhxLly7FzJkzabwIIS8Q6hkhhDQLExMTnD9/Hhs2bEBJSQlcXFywbt06DBs2DL1790Z8fDx69+4NkUiEc+fOYfDgwTh//jwWLFiA0aNHo7S0FI6OjggMDJTrKQkMDISHhwcGDhyIyspKjBs3DsuWLdNcQwkhzY7HGGOargQhhCgyceJEFBUVISYmRtNVIYS0IOrnJIQQQohGUTJCCCGEEI2i0zSEEEII0SjqGSGEEEKIRlEyQgghhBCNomSEEEIIIRpFyQghhBBCNIqSEUIIIYRoFCUjhBBCCNEoSkYIIYQQolGUjBBCCCFEoygZIYQQQohG/T9+VGRaPUuL3gAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1614,7 +1681,8 @@
     "for (g, group) in res.agents.dropna().groupby(\"params_id\"):\n",
     "    params = res.parameters.query(f'params_id == \"{g}\"').iloc[0]\n",
     "    title = f\"{params.generator.rstrip('_graph')} {params.prob_neighbor_spread}\"\n",
-    "    counts = group.groupby(by=[\"step\", \"state_id\"]).value_counts().unstack()\n",
+    "    # counts = group.groupby(by=[\"step\", \"state_id\"]).value_counts().unstack()\n",
+    "    counts = group.state_id.groupby(by=[\"step\"]).value_counts().unstack()\n",
     "    line = \"-\"\n",
     "    if \"barabasi\" in params.generator:\n",
     "        line = \"--\"\n",
@@ -1648,7 +1716,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -1691,7 +1759,7 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th rowspan=\"5\" valign=\"top\">newspread_1683213205.589173</th>\n",
+       "      <th rowspan=\"5\" valign=\"top\">newspread_1684407215.653166</th>\n",
        "      <th rowspan=\"5\" valign=\"top\">ff1d24a</th>\n",
        "      <th>0</th>\n",
        "      <td>0</td>\n",
@@ -1734,7 +1802,7 @@
       "text/plain": [
        "                                                    index    n  \\\n",
        "simulation_id               params_id iteration_id               \n",
-       "newspread_1683213205.589173 ff1d24a   0                 0  100   \n",
+       "newspread_1684407215.653166 ff1d24a   0                 0  100   \n",
        "                                      1                 0  100   \n",
        "                                      2                 0  100   \n",
        "                                      3                 0  100   \n",
@@ -1742,7 +1810,7 @@
        "\n",
        "                                                            generator  \\\n",
        "simulation_id               params_id iteration_id                      \n",
-       "newspread_1683213205.589173 ff1d24a   0             erdos_renyi_graph   \n",
+       "newspread_1684407215.653166 ff1d24a   0             erdos_renyi_graph   \n",
        "                                      1             erdos_renyi_graph   \n",
        "                                      2             erdos_renyi_graph   \n",
        "                                      3             erdos_renyi_graph   \n",
@@ -1750,14 +1818,14 @@
        "\n",
        "                                                   prob_neighbor_spread  \n",
        "simulation_id               params_id iteration_id                       \n",
-       "newspread_1683213205.589173 ff1d24a   0                               0  \n",
+       "newspread_1684407215.653166 ff1d24a   0                               0  \n",
        "                                      1                               0  \n",
        "                                      2                               0  \n",
        "                                      3                               0  \n",
        "                                      4                               0  "
       ]
      },
-     "execution_count": 18,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1778,7 +1846,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -1851,7 +1919,7 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>newspread_1683213205.589173</th>\n",
+       "      <th>newspread_1684407215.653166</th>\n",
        "      <td>0</td>\n",
        "      <td>2</td>\n",
        "      <td>None</td>\n",
@@ -1882,36 +1950,36 @@
       "text/plain": [
        "                             index version source_file       name description  \\\n",
        "simulation_id                                                                   \n",
-       "newspread_1683213205.589173      0       2        None  newspread               \n",
+       "newspread_1684407215.653166      0       2        None  newspread               \n",
        "\n",
        "                            group backup overwrite dry_run  dump  ...  \\\n",
        "simulation_id                                                     ...   \n",
-       "newspread_1683213205.589173  None  False      True   False  True  ...   \n",
+       "newspread_1684407215.653166  None  False      True   False  True  ...   \n",
        "\n",
        "                            num_processes  \\\n",
        "simulation_id                               \n",
-       "newspread_1683213205.589173             1   \n",
+       "newspread_1684407215.653166             1   \n",
        "\n",
        "                                                       exporters  \\\n",
        "simulation_id                                                      \n",
-       "newspread_1683213205.589173  [\"<class 'soil.exporters.SQLite'>\"]   \n",
+       "newspread_1684407215.653166  [\"<class 'soil.exporters.SQLite'>\"]   \n",
        "\n",
        "                            model_reporters agent_reporters tables  \\\n",
        "simulation_id                                                        \n",
-       "newspread_1683213205.589173              {}              {}     {}   \n",
+       "newspread_1684407215.653166              {}              {}     {}   \n",
        "\n",
        "                                                                        outdir  \\\n",
        "simulation_id                                                                    \n",
-       "newspread_1683213205.589173  /mnt/data/home/j/git/lab.gsi/soil/soil/docs/tu...   \n",
+       "newspread_1684407215.653166  /mnt/data/home/j/git/lab.gsi/soil/soil/docs/tu...   \n",
        "\n",
        "                            exporter_params level skip_test  debug  \n",
        "simulation_id                                                       \n",
-       "newspread_1683213205.589173              {}    20     False  False  \n",
+       "newspread_1684407215.653166              {}    20     False  False  \n",
        "\n",
        "[1 rows x 28 columns]"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1932,7 +2000,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -2033,7 +2101,7 @@
        "                       4                      0.0  "
       ]
      },
-     "execution_count": 20,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2056,7 +2124,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -2083,6 +2151,7 @@
        "      <th></th>\n",
        "      <th></th>\n",
        "      <th></th>\n",
+       "      <th>has_tv</th>\n",
        "      <th>state_id</th>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -2091,6 +2160,7 @@
        "      <th>step</th>\n",
        "      <th>agent_id</th>\n",
        "      <th></th>\n",
+       "      <th></th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
@@ -2100,21 +2170,26 @@
        "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
        "      <th>0</th>\n",
        "      <td>None</td>\n",
+       "      <td>None</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
+       "      <td>False</td>\n",
        "      <td>neutral</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
+       "      <td>False</td>\n",
        "      <td>neutral</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
+       "      <td>False</td>\n",
        "      <td>neutral</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
+       "      <td>False</td>\n",
        "      <td>neutral</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -2122,16 +2197,16 @@
        "</div>"
       ],
       "text/plain": [
-       "                                     state_id\n",
-       "params_id iteration_id step agent_id         \n",
-       "ff1d24a   0            0    0            None\n",
-       "                            1         neutral\n",
-       "                            2         neutral\n",
-       "                            3         neutral\n",
-       "                            4         neutral"
+       "                                     has_tv state_id\n",
+       "params_id iteration_id step agent_id                \n",
+       "ff1d24a   0            0    0          None     None\n",
+       "                            1         False  neutral\n",
+       "                            2         False  neutral\n",
+       "                            3         False  neutral\n",
+       "                            4         False  neutral"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/examples/rabbits/rabbit_improved_sim.py b/examples/rabbits/rabbit_improved_sim.py
index 142e25c..30f3a49 100644
--- a/examples/rabbits/rabbit_improved_sim.py
+++ b/examples/rabbits/rabbit_improved_sim.py
@@ -167,7 +167,7 @@ class RandomAccident(BaseAgent):
             if self.prob(prob_death):
                 self.debug("I killed a rabbit: {}".format(i.unique_id))
                 num_alive -= 1
-                i.die()
+                self.model.remove_agent(i)
         self.debug("Rabbits alive: {}".format(num_alive))
 
 
diff --git a/examples/rabbits/rabbits_basic_sim.py b/examples/rabbits/rabbits_basic_sim.py
index d70a958..1c99760 100644
--- a/examples/rabbits/rabbits_basic_sim.py
+++ b/examples/rabbits/rabbits_basic_sim.py
@@ -142,13 +142,15 @@ class RandomAccident(BaseAgent):
         prob_death = min(1, self.prob_death * num_alive/10)
         self.debug("Killing some rabbits with prob={}!".format(prob_death))
 
-        for i in self.get_agents(agent_class=Rabbit):
+        for i in alive:
             if i.state_id == i.dead.id:
                 continue
             if self.prob(prob_death):
                 self.debug("I killed a rabbit: {}".format(i.unique_id))
                 num_alive -= 1
-                i.die()
+                self.model.remove_agent(i)
+                i.alive = False
+                i.killed = True
         self.debug("Rabbits alive: {}".format(num_alive))
 
 
diff --git a/soil/__init__.py b/soil/__init__.py
index 537cac5..4e7f93f 100644
--- a/soil/__init__.py
+++ b/soil/__init__.py
@@ -259,7 +259,6 @@ def main(
     except Exception as ex:
         if args.pdb:
             from .debugging import post_mortem
-
             print(traceback.format_exc())
             post_mortem()
         else:
diff --git a/soil/agents/__init__.py b/soil/agents/__init__.py
index 5b83fb8..ce5f7da 100644
--- a/soil/agents/__init__.py
+++ b/soil/agents/__init__.py
@@ -30,8 +30,11 @@ class BaseAgent(MesaAgent, MutableMapping, metaclass=MetaAgent):
     Any attribute that is not preceded by an underscore (`_`) will also be added to its state.
     """
 
-    def __init__(self, unique_id, model, name=None, init=True, **kwargs):
-        assert isinstance(unique_id, int)
+    def __init__(self, unique_id=None, model=None, name=None, init=True, **kwargs):
+        # Ideally, model should be the first argument, but Mesa's Agent class has unique_id first
+        assert not (model is None), "Must provide a model"
+        if unique_id is None:
+            unique_id = model.next_id()
         super().__init__(unique_id=unique_id, model=model)
 
         self.name = (
@@ -191,25 +194,25 @@ class BaseAgent(MesaAgent, MutableMapping, metaclass=MetaAgent):
 
     def __repr__(self):
         return f"{self.__class__.__name__}({self.unique_id})"
-    
+
     def at(self, at):
         return time.Delay(float(at) - self.now)
-    
+
     def delay(self, delay=1):
         return time.Delay(delay)
 
 
-class Noop(BaseAgent):
-    def step(self):
-        return
-
-
 from .network_agents import *
 from .fsm import *
 from .evented import *
 from .view import *
 
 
+class Noop(EventedAgent, BaseAgent):
+    def step(self):
+        return
+
+
 class Agent(FSM, EventedAgent, NetworkAgent):
     """Default agent class, has network, FSM and event capabilities"""
 
diff --git a/soil/agents/evented.py b/soil/agents/evented.py
index d5db284..ad37b75 100644
--- a/soil/agents/evented.py
+++ b/soil/agents/evented.py
@@ -16,7 +16,7 @@ class EventedAgent(BaseAgent):
         self.model.register(self)
 
     def received(self, **kwargs):
-        return self.model.received(self, **kwargs)
+        return self.model.received(agent=self, **kwargs)
 
     def tell(self, msg, **kwargs):
         return self.model.tell(msg, recipient=self, **kwargs)
diff --git a/soil/agents/fsm.py b/soil/agents/fsm.py
index dca43bc..f380e94 100644
--- a/soil/agents/fsm.py
+++ b/soil/agents/fsm.py
@@ -6,39 +6,38 @@ import inspect
 
 
 class State:
-    __slots__ = ("awaitable", "f", "generator", "name", "default")
+    __slots__ = ("awaitable", "f", "attribute", "generator", "name", "default")
 
     def __init__(self, f, name, default, generator, awaitable):
         self.f = f
         self.name = name
+        self.attribute = "_{}".format(name)
         self.generator = generator
         self.awaitable = awaitable
         self.default = default
 
-    @coroutine
-    def step(self, obj):
-        if self.generator or self.awaitable:
-            f = self.f
-            next_state = yield from f(obj)
-            return next_state
-
-        else:
-            return self.f(obj)
-
     @property
     def id(self):
         return self.name
-
-    def __call__(self, *args, **kwargs):
-        raise Exception("States should not be called directly")
-
-class UnboundState(State):
+    
+    def __get__(self, obj, owner=None):
+        if obj is None:
+            return self
+        try:
+            return getattr(obj, self.attribute)
+        except AttributeError:
+            b = self.bind(obj)
+            setattr(obj, self.attribute, b)
+            return b
 
     def bind(self, obj):
         bs = BoundState(self.f, self.name, self.default, self.generator, self.awaitable, obj=obj)
         setattr(obj, self.name, bs)
         return bs
 
+    def __call__(self, *args, **kwargs):
+        raise Exception("States should not be called directly")
+
 
 class BoundState(State):
     __slots__ = ("obj", )
@@ -46,10 +45,21 @@ class BoundState(State):
     def __init__(self, *args, obj):
         super().__init__(*args)
         self.obj = obj
-    
+
+    @coroutine
+    def __call__(self):
+        if self.generator or self.awaitable:
+            f = self.f
+            next_state = yield from f(self.obj)
+            return next_state
+
+        else:
+            return self.f(self.obj)
+
+
     def delay(self, delta=0):
         return self, self.obj.delay(delta)
-    
+
     def at(self, when):
         return self, self.obj.at(when)
 
@@ -63,7 +73,7 @@ def state(name=None, default=False):
         name = name or func.__name__
         generator = inspect.isgeneratorfunction(func)
         awaitable = inspect.iscoroutinefunction(func) or inspect.isasyncgen(func)
-        return UnboundState(func, name, default, generator, awaitable)
+        return State(func, name, default, generator, awaitable)
 
     if callable(name):
         return decorator(name)
@@ -113,15 +123,24 @@ class MetaFSM(MetaAgent):
 class FSM(BaseAgent, metaclass=MetaFSM):
     def __init__(self, init=True, state_id=None, **kwargs):
         super().__init__(**kwargs, init=False)
+        bound_states = {}
+        for (k, v) in list(self._states.items()):
+            if isinstance(v, State):
+                v = v.bind(self)
+            bound_states[k] = v
+            setattr(self, k, v)
+
+        self._states = bound_states
+
         if state_id is not None:
             self._set_state(state_id)
+        else:
+            self._set_state(self._state)
         # If more than "dead" state is defined, but no default state
         if len(self._states) > 1 and not self._state:
             raise ValueError(
                 f"No default state specified for {type(self)}({self.unique_id})"
             )
-        for (k, v) in self._states.items():
-            setattr(self, k, v.bind(self))
 
         if init:
             self.init()
@@ -139,6 +158,7 @@ class FSM(BaseAgent, metaclass=MetaFSM):
             raise ValueError("Cannot change state after init")
         self._set_state(value)
 
+    @coroutine
     def step(self):
         if self._state is None:
             if len(self._states) == 1:
@@ -146,8 +166,7 @@ class FSM(BaseAgent, metaclass=MetaFSM):
             else:
                 raise Exception("Invalid state (None) for agent {}".format(self))
 
-        self._check_alive()
-        next_state = yield from self._state.step(self)
+        next_state = yield from self._state()
 
         try:
             next_state, when = next_state
@@ -167,7 +186,9 @@ class FSM(BaseAgent, metaclass=MetaFSM):
             if state not in self._states:
                 raise ValueError("{} is not a valid state".format(state))
             state = self._states[state]
-        if not isinstance(state, State):
+        if isinstance(state, State):
+            state = state.bind(self)
+        elif not isinstance(state, BoundState):
             raise ValueError("{} is not a valid state".format(state))
         self._state = state
 
@@ -177,4 +198,4 @@ class FSM(BaseAgent, metaclass=MetaFSM):
 
     @state
     def dead(self):
-        return time.INFINITY
\ No newline at end of file
+        return time.INFINITY
diff --git a/soil/agents/meta.py b/soil/agents/meta.py
index 4d4c5b2..d775ac4 100644
--- a/soil/agents/meta.py
+++ b/soil/agents/meta.py
@@ -2,44 +2,14 @@ from abc import ABCMeta
 from copy import copy
 from functools import wraps
 from .. import time
+from ..decorators import syncify, while_alive
 
 import types
 import inspect
 
-def decorate_generator_step(func, name):
-    @wraps(func)
-    def decorated(self):
-        if not self.alive:
-            return time.INFINITY
 
-        if self._coroutine is None:
-            self._coroutine = func(self)
-        try:
-            if self._last_except:
-                val = self._coroutine.throw(self._last_except)
-            else:
-                val = self._coroutine.send(self._last_return)
-        except StopIteration as ex:
-            self._coroutine = None
-            val = ex.value
-        finally:
-            self._last_return = None
-            self._last_except = None
-        return float(val) if val is not None else val
-    return decorated
-
-
-def decorate_normal_step(func, name):
-    @wraps(func)
-    def decorated(self):
-        # if not self.alive:
-        #     return time.INFINITY
-        val = func(self)
-        return float(val) if val is not None else val
-    return decorated
-
-
-class MetaAgent(ABCMeta):
+class MetaAnnotations(ABCMeta):
+    """This metaclass sets default values for agents based on class attributes"""
     def __new__(mcls, name, bases, namespace):
         defaults = {}
 
@@ -53,22 +23,7 @@ class MetaAgent(ABCMeta):
         }
 
         for attr, func in namespace.items():
-            if attr == "step":
-                if inspect.isgeneratorfunction(func) or inspect.iscoroutinefunction(func):
-                    func = decorate_generator_step(func, attr)
-                    new_nmspc.update({
-                        "_last_return": None,
-                        "_last_except": None,
-                        "_coroutine": None,
-                    })
-                elif inspect.isasyncgenfunction(func):
-                    raise ValueError("Illegal step function: {}. It probably mixes both async/await and yield".format(func))
-                elif inspect.isfunction(func):
-                    func = decorate_normal_step(func, attr)
-                else:
-                    raise ValueError("Illegal step function: {}".format(func))
-                new_nmspc[attr] = func
-            elif (
+            if (
                 isinstance(func, types.FunctionType)
                 or isinstance(func, property)
                 or isinstance(func, classmethod)
@@ -82,6 +37,28 @@ class MetaAgent(ABCMeta):
             else:
                 defaults[attr] = copy(func)
 
+        return super().__new__(mcls, name, bases, new_nmspc)
+
+
+class AutoAgent(ABCMeta):
+    def __new__(mcls, name, bases, namespace):
+        if "step" in namespace:
+            func = namespace["step"]
+            namespace["_orig_step"] = func
+            if inspect.isfunction(func):
+                if inspect.isgeneratorfunction(func) or inspect.iscoroutinefunction(func):
+                    func = syncify(func, method=True)
+                namespace["step"] = while_alive(func)
+            elif inspect.isasyncgenfunction(func):
+                raise ValueError("Illegal step function: {}. It probably mixes both async/await and yield".format(func))
+            else:
+                raise ValueError("Illegal step function: {}".format(func))
 
         # Add attributes for their use in the decorated functions
-        return super().__new__(mcls, name, bases, new_nmspc)
\ No newline at end of file
+        return super().__new__(mcls, name, bases, namespace)
+
+
+class MetaAgent(AutoAgent, MetaAnnotations):
+    """This metaclass sets default values for agents based on class attributes"""
+    pass
+
diff --git a/soil/agents/view.py b/soil/agents/view.py
index f91501c..1074113 100644
--- a/soil/agents/view.py
+++ b/soil/agents/view.py
@@ -1,5 +1,6 @@
 from collections.abc import Mapping, Set
 from itertools import islice
+from mesa import Agent
 
 
 class AgentView(Mapping, Set):
@@ -55,6 +56,8 @@ class AgentView(Mapping, Set):
         return list(self.filter(*args, **kwargs))
 
     def __contains__(self, agent_id):
+        if isinstance(agent_id, Agent):
+            agent_id = agent_id.unique_id
         return agent_id in self._agents
 
     def __str__(self):
diff --git a/soil/analysis.py b/soil/analysis.py
index 0312a28..d8adc51 100644
--- a/soil/analysis.py
+++ b/soil/analysis.py
@@ -19,7 +19,8 @@ def plot(env, agent_df=None, model_df=None, steps=False, ignore=["agent_count",
         try:
             agent_df = env.agent_df()
         except UserWarning:
-            print("No agent dataframe provided and no agent reporters found. Skipping agent plot.", file=sys.stderr)
+            print("No agent dataframe provided and no agent reporters found. "
+                  "Skipping agent plot.", file=sys.stderr)
             return
     if not agent_df.empty:
         agent_df.unstack().apply(lambda x: x.value_counts(),
@@ -48,9 +49,5 @@ def read_sql(fpath=None, name=None, include_agents=False):
         agents = pd.read_sql_table("agents", con=conn, index_col=["params_id", "iteration_id", "step", "agent_id"])
         config = pd.read_sql_table("configuration", con=conn, index_col="simulation_id")
         parameters = pd.read_sql_table("parameters", con=conn, index_col=["simulation_id", "params_id", "iteration_id"])
-        # try:
-        #     parameters = parameters.pivot(columns="key", values="value")
-        # except Exception as e:
-        #     print(f"warning: coult not pivot parameters: {e}")
 
         return Results(config, parameters, env, agents)
diff --git a/soil/decorators.py b/soil/decorators.py
index 94a4b08..fc3d2cf 100644
--- a/soil/decorators.py
+++ b/soil/decorators.py
@@ -1,6 +1,42 @@
+from functools import wraps
+from .time import INFINITY
+
 def report(f: property):
     if isinstance(f, property):
         setattr(f.fget, "add_to_report", True)
     else:
         setattr(f, "add_to_report", True)
-    return f
\ No newline at end of file
+    return f
+
+
+def syncify(func, method=True):
+    _coroutine = None
+
+    @wraps(func)
+    def wrapped(*args, **kwargs):
+        if not method:
+            nonlocal _coroutine
+        else:
+            _coroutine = getattr(args[0], "_coroutine", None)
+        _coroutine = _coroutine or func(*args, **kwargs)
+        try:
+            val = _coroutine.send(None)
+        except StopIteration as ex:
+            _coroutine = None
+            val = ex.value
+        finally:
+            if method:
+                args[0]._coroutine = _coroutine
+        return val
+
+    return wrapped
+
+
+def while_alive(func):
+    @wraps(func)
+    def wrapped(self, *args, **kwargs):
+        if self.alive:
+            return func(self, *args, **kwargs)
+        return INFINITY
+
+    return wrapped
\ No newline at end of file
diff --git a/soil/environment.py b/soil/environment.py
index 4ad8a76..8b9e523 100644
--- a/soil/environment.py
+++ b/soil/environment.py
@@ -11,6 +11,7 @@ import networkx as nx
 
 
 from mesa import Model
+from time import time as current_time
 
 from . import agents as agentmod, datacollection, utils, time, network, events
 
@@ -43,6 +44,7 @@ class BaseEnvironment(Model):
                 tables: Optional[Any] = None,
                 **kwargs: Any) -> Any:
         """Create a new model with a default seed value"""
+        seed = seed or str(current_time())
         self = super().__new__(cls, *args, seed=seed, **kwargs)
         self.dir_path = dir_path or os.getcwd()
         collector_class = collector_class or cls.collector_class
@@ -136,7 +138,7 @@ class BaseEnvironment(Model):
 
     @property
     def now(self):
-        if self.schedule:
+        if self.schedule is not None:
             return self.schedule.time
         raise Exception(
             "The environment has not been scheduled, so it has no sense of time"
@@ -160,6 +162,10 @@ class BaseEnvironment(Model):
         self.schedule.add(a)
         return a
 
+    def remove_agent(self, agent):
+        agent.alive = False
+        self.schedule.remove(agent)
+
     def add_agents(self, agent_classes: List[type], k, weights: Optional[List[float]] = None, **kwargs):
         if isinstance(agent_classes, type):
             agent_classes = [agent_classes]
@@ -188,12 +194,15 @@ class BaseEnvironment(Model):
         super().step()
         self.schedule.step()
         self.datacollector.collect(self)
+        if self.now == time.INFINITY:
+            self.running = False
 
         if self.logger.isEnabledFor(logging.DEBUG):
             msg = "Model data:\n"
             max_width = max(len(k) for k in self.datacollector.model_vars.keys())
             for (k, v) in self.datacollector.model_vars.items():
-                msg += f"\t{k:<{max_width}}: {v[-1]:>6}\n"
+                # msg += f"\t{k:<{max_width}}"
+                msg += f"\t{k:<{max_width}}: {v[-1]}\n"
             self.logger.debug(f"--- Steps: {self.schedule.steps:^5} - Time: {self.now:^5} --- " + msg)
 
     def add_model_reporter(self, name, func=None):
@@ -297,6 +306,11 @@ class NetworkEnvironment(BaseEnvironment):
         self.G.nodes[node_id]["agent"] = a
         return a
 
+    def remove_agent(self, agent, remove_node=True):
+        super().remove_agent(agent)
+        if remove_node and hasattr(agent, "remove_node"):
+            agent.remove_node()
+
     def add_agents(self, *args, k=None, **kwargs):
         if not k and not self.G:
             raise ValueError("Cannot add agents to an empty network")
@@ -344,6 +358,7 @@ class NetworkEnvironment(BaseEnvironment):
                 )
             if node_id is None:
                 node_id = f"Node_for_agent_{unique_id}"
+            assert node_id not in self.G.nodes
 
         if node_id not in self.G.nodes:
             self.G.add_node(node_id)
@@ -417,7 +432,10 @@ class EventedEnvironment(BaseEnvironment):
     def __init__(self, *args, **kwargs):
         self._inbox = dict()
         super().__init__(*args, **kwargs)
-    
+        self._can_reschedule = hasattr(self.schedule, "add_callback") and hasattr(self.schedule, "remove_callback")
+        self._can_reschedule = True
+        self._callbacks = {}
+
     def register(self, agent):
         self._inbox[agent.unique_id] = []
 
@@ -429,24 +447,47 @@ class EventedEnvironment(BaseEnvironment):
                             "Make sure your agent is of type EventedAgent and it is registered with the environment.")
 
     @coroutine
-    def received(self, agent, expiration=None, timeout=60, delay=1):
-        if not expiration:
-            expiration = self.now + timeout
+    def _polling_callback(self, agent, expiration, delay):
+        # this wakes the agent up at every step. It is better to wait until timeout (or inf)
+        # and if a message is received before that, reschedule the agent
+        # (That is implemented in the `received` method)
         inbox = self.inbox_for(agent)
-        if inbox:
-            return self.process_messages(inbox)
         while self.now < expiration:
-            # TODO: this wakes the agent up at every step. It would be better to wait until timeout (or inf)
-            # and if a message is received before that, reschedule the agent when
             if inbox:
                 return self.process_messages(inbox)
             yield time.Delay(delay)
         raise events.TimedOut("No message received")
 
-    def tell(self, msg, sender, recipient, expiration=None, timeout=None, **kwargs):
+    @coroutine
+    def received(self, agent, expiration=None, timeout=None, delay=1):
+        if not expiration:
+            if timeout:
+                expiration = self.now + timeout
+            else:
+                expiration = float("inf")
+        inbox = self.inbox_for(agent)
+        if inbox:
+            return self.process_messages(inbox)
+
+        if self._can_reschedule:
+            checked = False
+            def cb():
+                nonlocal checked
+                if checked:
+                    return time.INFINITY
+                checked = True
+                self.schedule.add_callback(self.now, agent.step)
+            self.schedule.add_callback(expiration, cb)
+            self._callbacks[agent.unique_id] = cb
+            yield time.INFINITY
+        res = yield from self._polling_callback(agent, expiration, delay)
+        return res
+
+
+    def tell(self, msg, recipient, sender=None, expiration=None, timeout=None, **kwargs):
         if expiration is None:
             expiration = float("inf") if timeout is None else self.now + timeout
-        self.inbox_for(recipient).append(
+        self._add_to_inbox(recipient.unique_id,
             events.Tell(timestamp=self.now,
                         payload=msg,
                         sender=sender,
@@ -463,18 +504,23 @@ class EventedEnvironment(BaseEnvironment):
             if agent_class and not isinstance(self.agents(unique_id=agent_id), agent_class):
                 continue
             self.logger.debug(f"Telling {agent_id}: {msg} ttl={ttl}")
-            inbox.append(
+            self._add_to_inbox(agent_id,
                 events.Tell(
                     payload=msg,
                     sender=sender,
                     expiration=expiration,
                 )
             )
+    def _add_to_inbox(self, inbox_id, msg):
+        self._inbox[inbox_id].append(msg)
+        if inbox_id in self._callbacks:
+            cb = self._callbacks.pop(inbox_id)
+            cb()
 
     @coroutine
     def ask(self, msg, recipient, sender=None, expiration=None, timeout=None, delay=1):
         ask = events.Ask(timestamp=self.now, payload=msg, sender=sender)
-        self.inbox_for(recipient).append(ask)
+        self._add_to_inbox(recipient.unique_id, ask)
         expiration = float("inf") if timeout is None else self.now + timeout
         while self.now < expiration:
             if ask.reply:
@@ -493,4 +539,4 @@ class EventedEnvironment(BaseEnvironment):
 
 
 class Environment(EventedEnvironment, NetworkEnvironment):
-    pass
\ No newline at end of file
+    pass
diff --git a/soil/exporters.py b/soil/exporters.py
index ce1964b..314b661 100644
--- a/soil/exporters.py
+++ b/soil/exporters.py
@@ -75,6 +75,13 @@ class Exporter:
     def iteration_end(self, env, params, params_id):
         """Method to call when a iteration ends"""
         pass
+    
+    def env_id(self, env):
+        try:
+            return env.id
+        except AttributeError:
+            return f"{env.__class__.__name__}_{current_time()}"
+
 
     def output(self, f, mode="w", **kwargs):
         if not self.dump:
@@ -90,7 +97,7 @@ class Exporter:
     def get_dfs(self, env, params_id, **kwargs):
         yield from get_dc_dfs(env.datacollector,
                               params_id,
-                              iteration_id=env.id,
+                              iteration_id=self.env_id(env),
                               **kwargs)
 
 
@@ -157,11 +164,11 @@ class SQLite(Exporter):
             return
 
         with timer(
-            "Dumping simulation {} iteration {}".format(self.simulation.name, env.id)
+            "Dumping simulation {} iteration {}".format(self.simulation.name, self.env_id(env))
         ):
             d = {"simulation_id": self.simulation.id,
                            "params_id": params_id,
-                           "iteration_id": env.id,
+                           "iteration_id": self.env_id(env),
             }
             for (k,v) in params.items():
                 d[k] = serialize(v)[0]
@@ -173,7 +180,7 @@ class SQLite(Exporter):
             pd.DataFrame([{
                 "simulation_id": self.simulation.id,
                 "params_id": params_id,
-                "iteration_id": env.id,
+                "iteration_id": self.env_id(env),
             }]).reset_index().to_sql("iterations",
                                      con=self.engine,
                                      if_exists="append",
@@ -191,11 +198,11 @@ class csv(Exporter):
     def iteration_end(self, env, params, params_id, *args, **kwargs):
         with timer(
             "[CSV] Dumping simulation {} iteration {} @ dir {}".format(
-                self.simulation.name, env.id, self.outdir
+                self.simulation.name, self.env_id(env), self.outdir
             )
         ):
             for (df_name, df) in self.get_dfs(env, params_id=params_id):
-                with self.output("{}.{}.csv".format(env.id, df_name), mode="a") as f:
+                with self.output("{}.{}.csv".format(self.env_id(env), df_name), mode="a") as f:
                     df.to_csv(f)
 
 
@@ -206,9 +213,9 @@ class gexf(Exporter):
             return
 
         with timer(
-            "[GEXF] Dumping simulation {} iteration {}".format(self.simulation.name, env.id)
+            "[GEXF] Dumping simulation {} iteration {}".format(self.simulation.name, self.env_id(env))
         ):
-            with self.output("{}.gexf".format(env.id), mode="wb") as f:
+            with self.output("{}.gexf".format(self.env_id(env)), mode="wb") as f:
                 nx.write_gexf(env.G, f)
 
 
@@ -242,7 +249,7 @@ class graphdrawing(Exporter):
             pos=nx.spring_layout(env.G, scale=100),
             ax=f.add_subplot(111),
         )
-        with open("graph-{}.png".format(env.id)) as f:
+        with open("graph-{}.png".format(self.env_id(env))) as f:
             f.savefig(f)
 
 
diff --git a/soil/simulation.py b/soil/simulation.py
index 9d1a20e..7bd1323 100644
--- a/soil/simulation.py
+++ b/soil/simulation.py
@@ -44,8 +44,8 @@ def do_not_run():
 
 def _iter_queued():
     while _QUEUED:
-        (cls, params) = _QUEUED.pop(0)
-        yield replace(cls, parameters=params)
+        slf = _QUEUED.pop(0)
+        yield slf
 
 
 # TODO: change documentation for simulation
@@ -130,11 +130,11 @@ class Simulation:
     def run(self, **kwargs):
         """Run the simulation and return the list of resulting environments"""
         if kwargs:
-            return replace(self, **kwargs).run()
+            res = replace(self, **kwargs)
+            return res.run()
 
-        param_combinations = self._collect_params(**kwargs)
         if _AVOID_RUNNING:
-            _QUEUED.extend((self, param) for param in param_combinations)
+            _QUEUED.append(self)
             return []
 
         self.logger.debug("Using exporters: %s", self.exporters or [])
@@ -154,6 +154,8 @@ class Simulation:
         for exporter in exporters:
             exporter.sim_start()
 
+        param_combinations = self._collect_params(**kwargs)
+
         for params in tqdm(param_combinations, desc=self.name, unit="configuration"):
             for (k, v) in params.items():
                 tqdm.write(f"{k} = {v}")
@@ -204,6 +206,7 @@ class Simulation:
                 for env in tqdm(utils.run_parallel(
                     func=func,
                     iterable=range(self.iterations),
+                    num_processes=self.num_processes,
                     **params,
                 ), total=self.iterations, leave=False):
                     if env is None and self.dry_run:
@@ -338,12 +341,13 @@ def iter_from_py(pyfile, module_name='imported_file', **kwargs):
             sims.append(sim)
         for sim in _iter_queued():
             sims.append(sim)
+        # Try to find environments to run, because we did not import a script that ran simulations
         if not sims:
             for (_name, env) in inspect.getmembers(module,
-                                                   lambda x: inspect.isclass(x) and
-                                                   issubclass(x, environment.Environment) and
-                                                   (getattr(x, "__module__", None) != environment.__name__)):
-                sims.append(Simulation(model=env, **kwargs))
+                                                lambda x: inspect.isclass(x) and
+                                                issubclass(x, environment.Environment) and
+                                                (getattr(x, "__module__", None) != environment.__name__)):
+                    sims.append(Simulation(model=env, **kwargs))
         del sys.modules[module_name]
     assert not _AVOID_RUNNING
     if not sims:
diff --git a/soil/time.py b/soil/time.py
index e062919..e7b815f 100644
--- a/soil/time.py
+++ b/soil/time.py
@@ -24,7 +24,10 @@ class Delay:
 
     def __float__(self):
         return self.delta
-    
+
+    def __eq__(self, other):
+        return float(self) == float(other)
+
     def __await__(self):
         return (yield self.delta)
 
@@ -87,6 +90,9 @@ class PQueueSchedule:
                 del self._queue[i]
                 break
 
+    def __len__(self):
+        return len(self._queue)
+
     def step(self) -> None:
         """
         Executes events in order, one at a time. After each step,
@@ -107,7 +113,8 @@ class PQueueSchedule:
                 next_time = when
                 break
 
-            when = event.func() or 1
+            when = event.func() 
+            when = float(when) if when is not None else 1.0
 
             if when == INFINITY:
                 heappop(self._queue)
@@ -153,12 +160,18 @@ class Schedule:
         return lst
 
     def insert(self, when, func, replace=False):
+        if when == INFINITY:
+            return
         lst = self._find_loc(when)
         lst.append(func)
     
     def add_bulk(self, funcs, when=None):
         lst = self._find_loc(when)
+        n = len(funcs)
+        #TODO: remove for performance
+        before = len(self)
         lst.extend(funcs)
+        assert len(self) == before + n
 
     def remove(self, func):
         for bucket in self._queue:
@@ -167,6 +180,9 @@ class Schedule:
                     bucket.remove(ix)
                     return
 
+    def __len__(self):
+        return sum(len(bucket[1]) for bucket in self._queue)
+
     def step(self) -> None:
         """
         Executes events in order, one at a time. After each step,
@@ -188,11 +204,14 @@ class Schedule:
             self.random.shuffle(bucket)
         next_batch = defaultdict(list)
         for func in bucket:
-            when = func() or 1
+            when = func()
+            when = float(when) if when is not None else 1
 
-            if when != INFINITY:
-                when += now
-                next_batch[when].append(func) 
+            if when == INFINITY:
+                continue
+
+            when += now
+            next_batch[when].append(func) 
         
         for (when, bucket) in next_batch.items():
             self.add_bulk(bucket, when)
@@ -229,6 +248,12 @@ class InnerActivation(BaseScheduler):
         self.agents_by_type[agent_class][agent.unique_id] = agent
         super().add(agent)
     
+    def add_callback(self, when, cb):
+        self.inner.insert(when, cb)
+
+    def remove_callback(self, when, cb):
+        self.inner.remove(cb)
+    
     def remove(self, agent):
         del self._agents[agent.unique_id]
         del self.agents_by_type[type(agent)][agent.unique_id]
@@ -241,6 +266,9 @@ class InnerActivation(BaseScheduler):
         """
         self.inner.step()
 
+    def __len__(self):
+        return len(self.inner)
+
 
 class BucketTimedActivation(InnerActivation):
     inner_class = Schedule
@@ -250,16 +278,19 @@ class PQueueActivation(InnerActivation):
     inner_class = PQueueSchedule
 
 
-# Set the bucket implementation as default
+#Set the bucket implementation as default
+TimedActivation = BucketTimedActivation
+
 try:
-    from soilent.soilent import BucketScheduler
+    from soilent.soilent import BucketScheduler, PQueueScheduler
 
-    class SoilBucketActivation(InnerActivation):
+    class SoilentActivation(InnerActivation):
         inner_class = BucketScheduler
+    class SoilentPQueueActivation(InnerActivation):
+        inner_class = PQueueScheduler
 
-    TimedActivation = SoilBucketActivation
+    # TimedActivation = SoilentBucketActivation
 except ImportError:
-    TimedActivation = BucketTimedActivation
     pass
 
 
diff --git a/soil/utils.py b/soil/utils.py
index 7917b6d..9b3ba75 100644
--- a/soil/utils.py
+++ b/soil/utils.py
@@ -93,15 +93,12 @@ def flatten_dict(d):
 
 def _flatten_dict(d, prefix=""):
     if not isinstance(d, dict):
-        # print('END:', prefix, d)
         yield prefix, d
         return
     if prefix:
         prefix = prefix + "."
     for k, v in d.items():
-        # print(k, v)
         res = list(_flatten_dict(v, prefix="{}{}".format(prefix, k)))
-        # print('RES:', res)
         yield from res
 
 
@@ -142,6 +139,7 @@ def run_and_return_exceptions(func, *args, **kwargs):
 
 def run_parallel(func, iterable, num_processes=1, **kwargs):
     if num_processes > 1 and not os.environ.get("SOIL_DEBUG", None):
+        logger.info("Running simulations in {} processes".format(num_processes))
         if num_processes < 1:
             num_processes = cpu_count() - num_processes
         p = Pool(processes=num_processes)
diff --git a/tests/test_agents.py b/tests/test_agents.py
index 64e7c4c..e9807a9 100644
--- a/tests/test_agents.py
+++ b/tests/test_agents.py
@@ -1,7 +1,7 @@
 from unittest import TestCase
 import pytest
 
-from soil import agents, environment
+from soil import agents, events, environment
 from soil import time as stime
 
 
@@ -25,7 +25,7 @@ class TestAgents(TestCase):
         assert d.alive
         d.step()
         assert not d.alive
-        when = d.step()
+        when = float(d.step())
         assert not d.alive
         assert when == stime.INFINITY
 
@@ -63,6 +63,7 @@ class TestAgents(TestCase):
             def other(self):
                 self.times_run += 1
 
+        assert MyAgent.other.id == "other"
         e = environment.Environment()
         a = e.add_agent(MyAgent)
         e.step()
@@ -73,6 +74,53 @@ class TestAgents(TestCase):
         a.step()
         assert a.times_run == 2
 
+    def test_state_decorator_multiple(self):
+        class MyAgent(agents.FSM):
+            times_run = 0
+
+            @agents.state(default=True)
+            def one(self):
+                return self.two
+
+            @agents.state
+            def two(self):
+                return self.one
+
+        e = environment.Environment()
+        first = e.add_agent(MyAgent, state_id=MyAgent.one)
+        second = e.add_agent(MyAgent, state_id=MyAgent.two)
+        assert first.state_id == MyAgent.one.id
+        assert second.state_id == MyAgent.two.id
+        e.step()
+        assert first.state_id == MyAgent.two.id
+        assert second.state_id == MyAgent.one.id
+
+    def test_state_decorator_multiple_async(self):
+        class MyAgent(agents.FSM):
+            times_run = 0
+
+            @agents.state(default=True)
+            def one(self):
+                yield self.delay(1)
+                return self.two
+
+            @agents.state
+            def two(self):
+                yield self.delay(1)
+                return self.one
+
+        e = environment.Environment()
+        first = e.add_agent(MyAgent, state_id=MyAgent.one)
+        second = e.add_agent(MyAgent, state_id=MyAgent.two)
+        for i in range(2):
+            assert first.state_id == MyAgent.one.id
+            assert second.state_id == MyAgent.two.id
+            e.step()
+        for i in range(2):
+            assert first.state_id == MyAgent.two.id
+            assert second.state_id == MyAgent.one.id
+            e.step()
+
     def test_broadcast(self):
         """
         An agent should be able to broadcast messages to every other agent, AND each receiver should be able
@@ -372,22 +420,105 @@ class TestAgents(TestCase):
         assert a.now == 17
         assert a.my_state == 5
     
-    def test_send_nonevent(self):
+    def test_receive(self):
         '''
-        Sending a non-event should raise an error.
+        An agent should be able to receive a message after waiting
         '''
         model = environment.Environment()
-        a = model.add_agent(agents.Noop)
+        class TestAgent(agents.Agent):
+            sent = False
+            woken = 0
+            def step(self):
+                self.woken += 1
+                return super().step()
+
+            @agents.state(default=True)
+            async def one(self):
+                try:
+                    self.sent = await self.received(timeout=15)
+                    return self.two.at(20)
+                except events.TimedOut:
+                    pass
+            @agents.state
+            def two(self):
+                return self.die()
+
+        a = model.add_agent(TestAgent)
+
+        class Sender(agents.Agent):
+            async def step(self):
+                await self.delay(10)
+                a.tell(1)
+                return stime.INFINITY
+
+        b = model.add_agent(Sender)
+
+        # Start and wait
+        model.step()
+        assert model.now == 10
+        assert a.woken == 1
+        assert not a.sent
+
+        # Sending the message
+        model.step()
+        assert model.now == 10
+        assert a.woken == 1
+        assert not a.sent
+
+        # The receiver callback
+        model.step()
+        assert model.now == 15
+        assert a.woken == 2
+        assert a.sent[0].payload == 1
+
+        # The timeout
+        model.step()
+        assert model.now == 20
+        assert a.woken == 2
+
+        # The last state of the agent
+        model.step()
+        assert a.woken == 3
+        assert model.now == float('inf')
+
+    def test_receive_timeout(self):
+        '''
+        A timeout should be raised if no messages are received after an expiration time
+        '''
+        model = environment.Environment()
+        timedout = False
         class TestAgent(agents.Agent):
             @agents.state(default=True)
             def one(self):
                 try:
-                    a.tell(b, 1)
+                    yield from self.received(timeout=10)
                     raise AssertionError('Should have raised an error.')
-                except AttributeError:
-                    self.model.tell(1, sender=self, recipient=a)
+                except events.TimedOut:
+                    nonlocal timedout
+                    timedout = True
 
-        model.add_agent(TestAgent)
+        a = model.add_agent(TestAgent)
 
-        with pytest.raises(ValueError):
-            model.step()
\ No newline at end of file
+        model.step()
+        assert model.now == 10
+        model.step()
+        # Wake up the callback
+        assert model.now == 10
+        assert not timedout
+        # The actual timeout
+        model.step()
+        assert model.now == 11
+        assert timedout
+
+    def test_attributes(self):
+        """Attributes should be individual per agent"""
+
+        class MyAgent(agents.Agent):
+            my_attribute = 0
+        
+        model = environment.Environment()
+        a = MyAgent(model=model)
+        assert a.my_attribute == 0
+        b = MyAgent(model=model, my_attribute=1)
+        assert b.my_attribute == 1
+        assert a.my_attribute == 0
diff --git a/tests/test_main.py b/tests/test_main.py
index ef8ad3b..a0910be 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -6,7 +6,7 @@ import networkx as nx
 from functools import partial
 
 from os.path import join
-from soil import simulation, Environment, agents, network, serialization, utils, config, from_file
+from soil import simulation, Environment, agents, serialization, from_file, time
 from mesa import Agent as MesaAgent
 
 ROOT = os.path.abspath(os.path.dirname(__file__))
@@ -194,7 +194,7 @@ class TestMain(TestCase):
                 return self.ping
 
         a = ToggleAgent(unique_id=1, model=Environment())
-        when = a.step()
+        when = float(a.step())
         assert when == 2
         when = a.step()
         assert when == None
@@ -252,4 +252,34 @@ class TestMain(TestCase):
         assert df["base"][(0,0)] == "base"
         assert df["base"][(0,1)] == "base"
         assert df["subclass"][(0,0)] is None
-        assert df["subclass"][(0,1)] == "subclass"
\ No newline at end of file
+        assert df["subclass"][(0,1)] == "subclass"
+    
+    def test_remove_agent(self):
+        """An agent that is scheduled should be removed from the schedule"""
+        model = Environment()
+        model.add_agent(agents.Noop)
+        model.step()
+        model.remove_agent(model.agents[0])
+        assert not model.agents
+        when = model.step()
+        assert when == None
+        assert not model.running
+
+    def test_remove_agent(self):
+        """An agent that is scheduled should be removed from the schedule"""
+
+        allagents = []
+        class Removed(agents.BaseAgent):
+            def step(self):
+                nonlocal allagents
+                assert self.alive
+                assert self in self.model.agents
+                for agent in allagents:
+                    self.model.remove_agent(agent)
+
+        model = Environment()
+        a1 = model.add_agent(Removed)
+        a2 = model.add_agent(Removed)
+        allagents = [a1, a2]
+        model.step()
+        assert not model.agents
\ No newline at end of file