diff --git a/cryptarchia/longest-chain-cryptarchia.ipynb b/cryptarchia/longest-chain-cryptarchia.ipynb
index b61b5f6..de0c613 100644
--- a/cryptarchia/longest-chain-cryptarchia.ipynb
+++ b/cryptarchia/longest-chain-cryptarchia.ipynb
@@ -2,21 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 1,
    "id": "ad657d5a-bd36-4329-b134-6745daff7ae9",
    "metadata": {},
    "outputs": [],
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
-    "from dataclasses import dataclass\n",
+    "from dataclasses import dataclass, replace\n",
     "from pyvis.network import Network\n",
-    "from pyvis.options import Layout"
+    "from pyvis.options import Layout\n",
+    "import time"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 2,
    "id": "a9e0b910-c633-4dbe-827c-4ddb804f7a9a",
    "metadata": {},
    "outputs": [],
@@ -27,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 3,
    "id": "aa0aadce-a0be-4873-ba23-293be74db313",
    "metadata": {},
    "outputs": [],
@@ -43,23 +44,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 4,
    "id": "a538cf45-d551-4603-b484-dbbc3f3d0a73",
    "metadata": {},
    "outputs": [],
    "source": [
     "@dataclass\n",
     "class NetworkParams:\n",
-    "    mixnet_delay_mean: int # seconds\n",
-    "    mixnet_delay_var: int\n",
     "    broadcast_delay_mean: int # second\n",
     "    pol_proof_time: int # seconds\n",
+    "    # ---- blend network -- \n",
+    "    blending_delay: int\n",
+    "    desimenation_delay_mean: float\n",
+    "    # desimenation_delay_var: float\n",
+    "    blend_hops: int\n",
     "    no_network_delay: bool = False\n",
     "\n",
-    "    def sample_mixnet_delay(self):\n",
-    "        scale = self.mixnet_delay_var / self.mixnet_delay_mean\n",
-    "        shape = self.mixnet_delay_mean / scale\n",
-    "        return np.random.gamma(shape=shape, scale=scale)\n",
+    "    def sample_blending_delay(self):\n",
+    "        return np.random.uniform(0, self.blending_delay)\n",
+    "\n",
+    "    def sample_desimenation_delay(self):\n",
+    "        return np.random.exponential(self.desimenation_delay_mean)\n",
+    "        # scale = self.desimenation_delay_var / self.desimenation_delay_mean\n",
+    "        # shape = self.desimenation_delay_mean / scale\n",
+    "        # return np.random.gamma(shape=shape, scale=scale)\n",
+    "\n",
+    "    def sample_blend_network_delay(self):\n",
+    "        return sum(self.sample_blending_delay() + self.sample_desimenation_delay() for _ in range(self.blend_hops))\n",
     "    \n",
     "    def sample_broadcast_delay(self, blocks):\n",
     "        return np.random.exponential(self.broadcast_delay_mean, size=blocks.shape)\n",
@@ -67,14 +78,66 @@
     "    def block_arrival_slot(self, block_slot):\n",
     "        if self.no_network_delay:\n",
     "            return block_slot\n",
-    "        return self.pol_proof_time + self.sample_mixnet_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n",
+    "        # return self.pol_proof_time + self.sample_mixnet_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n",
+    "        return self.pol_proof_time + self.sample_blend_network_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n",
     "\n",
-    "\n"
+    "    def empirical_network_delay(self, N=10000, M=1000):\n",
+    "        return np.array([self.block_arrival_slot(np.zeros(M)) for _ in range(N)]).reshape(N*M)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 5,
+   "id": "17ef82f8-968c-48b0-bee7-f2642c8b3f3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "blend_net = NetworkParams(\n",
+    "    broadcast_delay_mean=0.5,\n",
+    "    pol_proof_time=1,\n",
+    "    blending_delay=3,\n",
+    "    desimenation_delay_mean=0.5,\n",
+    "    blend_hops=3,\n",
+    ")\n",
+    "no_blend_net = replace(blend_net, blend_hops=0)\n",
+    "\n",
+    "N = 100\n",
+    "M = 10000\n",
+    "no_blend_samples = no_blend_net.empirical_network_delay()\n",
+    "no_blend_mean = no_blend_samples.mean()\n",
+    "blend_samples = blend_net.empirical_network_delay()\n",
+    "blend_mean = blend_samples.mean()\n",
+    "\n",
+    "_ = plt.hist(no_blend_samples, bins=100, density=True, label=\"no-blend\")\n",
+    "_ = plt.hist(blend_samples, bins=100, density=True, label=\"blend\")\n",
+    "\n",
+    "for p in [50, 99, 99.9]:\n",
+    "    no_blend_pct = np.percentile(no_blend_samples, p)\n",
+    "    _ = plt.vlines(no_blend_pct, ymin=0, ymax=0.25, color='darkblue', label=f\"no-blend {p}p={no_blend_pct:.1f}s\")\n",
+    "\n",
+    "for p in [50, 99, 99.9]:\n",
+    "    blend_pct = np.percentile(blend_samples, p)\n",
+    "    _ = plt.vlines(blend_pct, ymin=0, ymax=0.25, color='brown', label=f\"blend {p}p={blend_pct:.1f}s\")\n",
+    "# _ = plt.vlines(blend_mean, ymin=0, ymax=1, color='brown', label=f\"blend 50p={blend_mean:.1f}s\")\n",
+    "# _ = plt.hist(blend_net.block_arrival_slot(np.zeros(1000)), bins=100, density=True, label=\"blend\")\n",
+    "_ = plt.legend()\n",
+    "_ = plt.xlabel(\"block delay\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
    "id": "24779de7-284f-4200-9e4a-d2aa6e1b823b",
    "metadata": {},
    "outputs": [],
@@ -104,7 +167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 503,
+   "execution_count": 7,
    "id": "a90495a8-fcda-4e47-92b4-cc5ceaa9ff9c",
    "metadata": {},
    "outputs": [],
@@ -115,10 +178,14 @@
     "        self.network = network\n",
     "        self.leaders = np.zeros((params.N, params.SLOTS), dtype=np.int64)\n",
     "        self.blocks = []\n",
-    "        self.block_slots = np.array([], dtype=np.int64)\n",
-    "        self.block_heights = np.array([], dtype=np.int64)\n",
-    "        self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n",
+    "        max_number_of_blocks = int(3 * params.SLOTS * params.f)\n",
+    "        self.block_slots = np.zeros(max_number_of_blocks, dtype=np.int64)\n",
+    "        self.block_heights = np.zeros(max_number_of_blocks, dtype=np.int64)\n",
+    "        self.block_arrivals = np.zeros(shape=(params.N, max_number_of_blocks), dtype=np.int64) # arrival time to each leader for each block\n",
+    "        self.block_arrivals[:,:] = self.params.SLOTS\n",
+    "        # self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n",
     "\n",
+    "    \n",
     "    def emit_block(self, leader, slot, height, parent):\n",
     "        assert type(leader) in [int, np.int64]\n",
     "        assert type(slot) in [int, np.int64]\n",
@@ -133,8 +200,8 @@
     "            leader=leader,\n",
     "        )\n",
     "        self.blocks.append(block)\n",
-    "        self.block_slots = np.append(self.block_slots, block.slot)\n",
-    "        self.block_heights = np.append(self.block_heights, block.height)\n",
+    "        self.block_slots[block.id] = block.slot\n",
+    "        self.block_heights[block.id] = block.height\n",
     "    \n",
     "        # decide when this block will arrive at each node\n",
     "        new_block_arrival_by_node = self.network.block_arrival_slot(np.repeat(block.slot, self.params.N))\n",
@@ -143,8 +210,9 @@
     "            # the new block cannot arrive before it's parent\n",
     "            parent_arrival_by_node = self.block_arrivals[:,parent]\n",
     "            new_block_arrival_by_node = np.maximum(new_block_arrival_by_node, parent_arrival_by_node)\n",
-    "        \n",
-    "        self.block_arrivals = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\n",
+    "\n",
+    "        self.block_arrivals[:,block.id] = new_block_arrival_by_node\n",
+    "        # self.block_arrivals = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\n",
     "\n",
     "        return block.id\n",
     "\n",
@@ -163,13 +231,14 @@
     "    def fork_choice(self, leader, slot):\n",
     "        assert type(leader) in [int, np.int64], type(leader)\n",
     "        assert isinstance(slot, int)\n",
-    "        arrived_blocks = self.block_arrivals[leader] <= slot\n",
-    "        return (self.block_heights * arrived_blocks).argmax()\n",
+    "        arrived_blocks = (self.block_arrivals[leader, :len(self.blocks)] <= slot) * self.block_heights[:len(self.blocks)]\n",
+    "        concurrent = (arrived_blocks == np.max(arrived_blocks)).nonzero()[0]\n",
+    "        return np.random.choice(concurrent)\n",
     "\n",
     "    def plot_spacetime_diagram(self, MAX_SLOT=1000):\n",
     "        alpha_index = sorted(range(self.params.N), key=lambda n: self.params.relative_stake[n])\n",
     "        nodes = [f\"$N_{n}$($\\\\alpha$={self.params.relative_stake[n]:.2f})\" for n in alpha_index]\n",
-    "        messages = [(nodes[alpha_index.index(self.blocks[b].leader)], nodes[alpha_index.index(node)], self.blocks[b].slot, arrival_slot, f\"$B_{{{b}}}$\") for b, arrival_slots in enumerate(self.block_arrivals.T) for node, arrival_slot in enumerate(arrival_slots) if arrival_slot < MAX_SLOT]\n",
+    "        messages = [(nodes[alpha_index.index(self.blocks[b].leader)], nodes[alpha_index.index(node)], self.blocks[b].slot, arrival_slot, f\"$B_{{{b}}}$\") for b, arrival_slots in enumerate(self.block_arrivals[:,:len(self.blocks)].T) for node, arrival_slot in enumerate(arrival_slots) if arrival_slot < MAX_SLOT]\n",
     "    \n",
     "        fig, ax = plt.subplots(figsize=(8,4))\n",
     "        \n",
@@ -237,6 +306,9 @@
     "        return G.show(\"chain.html\")\n",
     "\n",
     "    def run(self, seed=None):\n",
+    "        from collections import defaultdict\n",
+    "        timings = defaultdict(float)\n",
+    "        start_t = time.time()\n",
     "        if seed is not None:\n",
     "            np.random.seed(seed)\n",
     "\n",
@@ -247,60 +319,103 @@
     "            height=1,\n",
     "            parent=-1,\n",
     "        )\n",
-    "        self.block_arrivals[:,:] = 0 # all nodes see the genesis block\n",
-    "        \n",
+    "        self.block_arrivals[:,0] = 0 # all nodes see the genesis block\n",
+    "\n",
+    "        prep_t = time.time()\n",
+    "\n",
+    "\n",
     "        for s in range(1, self.params.SLOTS):\n",
+    "            slot_start_t = time.time()\n",
     "            # the adversary will not participate in the simulation\n",
     "            # (implemented by never delivering blocks to the adversary)\n",
-    "            self.block_arrivals[-1,:] = self.params.SLOTS\n",
+    "            # self.block_arrivals[-1,:] = self.params.SLOTS\n",
     "\n",
     "            self.leaders[:,s] = np.random.random(size=self.params.N) < self.params.slot_prob()\n",
+    "            leader_lottery_t = time.time()\n",
     "\n",
     "            for leader in np.nonzero(self.leaders[:,s])[0]:\n",
+    "                lead_start_t = time.time()\n",
     "                if self.params.adversary_control is not None and leader == self.params.N - 1:\n",
     "                    continue\n",
-    "                self.emit_leader_block(leader, s)\n",
+    "                \n",
+    "                parent = self.fork_choice(leader, s)\n",
+    "                fork_choice_t = time.time()\n",
+    "                \n",
+    "                self.emit_block(\n",
+    "                    leader,\n",
+    "                    s,\n",
+    "                    height=self.blocks[parent].height + 1,\n",
+    "                    parent=parent,\n",
+    "                )\n",
+    "                emit_leader_block_t = time.time()\n",
     "\n",
-    "    def adverserial_analysis(self, should_plot=True, seed=0):\n",
+    "                timings[\"forkchoice\"] += fork_choice_t - lead_start_t\n",
+    "                timings[\"emit_leader_block\"] += emit_leader_block_t - fork_choice_t\n",
+    "                    \n",
+    "                # self.emit_leader_block(leader, s)\n",
+    "            slot_end_t = time.time()\n",
+    "            timings[\"leader\"] += leader_lottery_t - slot_start_t\n",
+    "            timings[\"emit\"] += slot_end_t - leader_lottery_t\n",
+    "            timings[\"slot\"] += slot_end_t - slot_start_t\n",
+    "\n",
+    "        end_t = time.time()\n",
+    "        timings[\"prep\"] = prep_t - start_t\n",
+    "        timings[\"total\"] = end_t - start_t\n",
+    "        for phase, duration in timings.items():\n",
+    "            print(f\"{phase}\\t{duration:.2f}s\")\n",
+    "\n",
+    "    def adverserial_analysis(self, should_plot=False, seed=0):\n",
+    "        from collections import defaultdict\n",
+    "\n",
+    "        timings = defaultdict(float)\n",
+    "\n",
+    "        start_t = time.time()\n",
     "        np.random.seed(seed)\n",
-    "\n",
+    "        \n",
     "        adversary = self.params.N-1 # adversary is always the last node in our simulations\n",
     "\n",
-    "        self.block_arrivals[adversary,:] = self.block_slots # we will say the adversary receives the blocks immidiately\n",
+    "        self.block_arrivals[adversary,:len(self.blocks)] = self.block_slots[:len(self.blocks)] # we will say the adversary receives the blocks immidiately\n",
     "\n",
-    "        honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
-    "        for block in self.blocks:\n",
-    "            block_height = np.zeros(self.params.SLOTS, dtype=np.int64) + block.height\n",
-    "            block_height[:block.slot] = 0\n",
-    "            honest_height_by_slot = np.maximum(block_height, honest_height_by_slot)\n",
-    "        \n",
-    "        for slot in range(1, self.params.SLOTS):\n",
-    "            if honest_height_by_slot[slot] == 0:\n",
-    "                honest_height_by_slot[slot] = honest_height_by_slot[slot-1]\n",
-    "\n",
-    "        \n",
     "        honest_chain = self.honest_chain()\n",
     "        \n",
-    "        reorg_depths = np.array([], dtype=np.int64)\n",
+    "        honest_chain_t = time.time()\n",
+    "        \n",
+    "        honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
     "\n",
+    "        for block_id in honest_chain:\n",
+    "            honest_height_by_slot[self.blocks[block_id].slot] = 1\n",
+    "        honest_height_by_slot = honest_height_by_slot.cumsum()\n",
+    "        \n",
+    "        honest_height_by_slot_t = time.time()\n",
+    "        \n",
+    "        reorg_depths = []\n",
     "        if should_plot:\n",
     "            plt.figure(figsize=(20, 6))\n",
     "            ax = plt.subplot(121)\n",
     "        \n",
     "        adversary_active_slots = np.random.random(size=self.params.SLOTS) < phi(self.params.f, self.params.relative_stake[adversary])\n",
+    "        adversary_cumsum = adversary_active_slots.cumsum()\n",
+    "\n",
     "        all_active_slots = (self.leaders.sum(axis=0) + adversary_active_slots) > 0\n",
     "\n",
+    "        advantage = np.zeros(self.params.SLOTS)\n",
+    "        prep_t = time.time()\n",
+    "        timings[\"honest_chain\"] += honest_chain_t - start_t\n",
+    "        timings[\"honest_height_by_slot\"] += honest_height_by_slot_t - honest_chain_t\n",
+    "        timings[\"prep_analysis\"] += prep_t - start_t\n",
     "        for b in range(len(self.blocks)):\n",
-    "            if block.id > 0 and block.id % 1000 == 0:\n",
-    "                print(\"Processing block\", block)\n",
+    "            block_start_t = time.time()\n",
     "            block = self.blocks[b]\n",
+    "            if block.id > 0 and block.id % 5000 == 0:\n",
+    "                print(\"Processing block\", block)\n",
     "            \n",
     "            nearest_honest_block = block\n",
     "            while nearest_honest_block.height >= len(honest_chain) or honest_chain[nearest_honest_block.height-1] != nearest_honest_block.id:\n",
     "                nearest_honest_block = self.blocks[nearest_honest_block.parent]\n",
     "\n",
-    "            remaining_slots = adversary_active_slots[block.slot+1:]\n",
-    "            cumulative_rel_height = remaining_slots.cumsum()\n",
+    "            nearest_honest_t = time.time()\n",
+    "            \n",
+    "            cumulative_rel_height = adversary_cumsum[block.slot+1:] - adversary_cumsum[block.slot]\n",
     "\n",
     "            adverserial_height_by_slot = block.height + cumulative_rel_height\n",
     "\n",
@@ -309,22 +424,31 @@
     "            adverserial_wins = adverserial_height_by_slot > honest_height_by_slot_lookahead\n",
     "        \n",
     "            reorg_events = adverserial_wins & all_active_slots[block.slot+1:]\n",
-    "            reorg_depths = np.append(reorg_depths, honest_height_by_slot_lookahead[reorg_events] - nearest_honest_block.height)\n",
     "\n",
+    "                \n",
+    "            reorg_events_t = time.time()\n",
+    "            reorg_depth = honest_height_by_slot_lookahead[reorg_events] - nearest_honest_block.height\n",
+    "            reorg_depth_t = time.time()\n",
+    "            reorg_depths += list(reorg_depth)\n",
+    "            block_end_t = time.time()\n",
+    "            timings[\"nearest_honest\"] += nearest_honest_t - block_start_t\n",
+    "            timings[\"reorg_events\"] += reorg_events_t - nearest_honest_t\n",
+    "            timings[\"reorg_depth\"] += reorg_depth_t - reorg_events_t\n",
+    "            timings[\"depth_append\"] += block_end_t - reorg_depth_t\n",
+    "            \n",
     "            if should_plot:\n",
     "                if reorg_events.sum() > 0:\n",
     "                    first_slot = block.slot+1\n",
     "                    last_slot = first_slot + np.nonzero(reorg_events)[0].max() + 1\n",
+    "                    advantage[first_slot:last_slot] = np.maximum(advantage[first_slot:last_slot], adverserial_height_by_slot[:last_slot-first_slot]-honest_height_by_slot[first_slot:last_slot])\n",
     "\n",
-    "                    ax.plot(np.arange(first_slot, last_slot), adverserial_height_by_slot[:last_slot-first_slot]-honest_height_by_slot[first_slot:last_slot], lw=\"1\")\n",
-    "                    for event in np.nonzero(reorg_events)[0]:\n",
-    "                        plt.axvline(x = event + block.slot + 1, ymin = 0, ymax = 1, color ='red', lw=0.01)\n",
-    "\n",
-    "        \n",
+    "        for phase, duration in timings.items():\n",
+    "            print(f\"{phase}\\t{duration:.2f}s\")\n",
+    "                    \n",
     "        if should_plot:\n",
-    "            ax.plot(np.zeros(self.params.SLOTS), color=\"k\", label=f\"honest chain\")\n",
+    "            ax.plot(advantage, color='k', lw=\"0.5\")\n",
     "            _ = ax.set_title(f\"max chain weight with adversery controlling {self.params.relative_stake[adversary] * 100:.0f}% of stake\")\n",
-    "            _ = ax.set_ylabel(\"weight advantage\")\n",
+    "            _ = ax.set_ylabel(\"adversary height advantage\")\n",
     "            _ = ax.set_xlabel(\"slot\")\n",
     "            _ = ax.legend()\n",
     "\n",
@@ -339,19 +463,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 124,
-   "id": "d7eef71a-aa3c-49df-a711-9c9f7f5cb4a8",
+   "execution_count": 8,
+   "id": "5f2da916-30a0-4b1d-886f-1bc81c17056e",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "avg blocks per slot 0.04708\n",
-      "Number of blocks 4708\n",
-      "longest chain 2345\n",
-      "CPU times: user 6.42 s, sys: 7.49 s, total: 13.9 s\n",
-      "Wall time: 14.7 s\n"
+      "leader\t0.02s\n",
+      "emit\t0.01s\n",
+      "slot\t0.03s\n",
+      "forkchoice\t0.00s\n",
+      "emit_leader_block\t0.00s\n",
+      "prep\t0.00s\n",
+      "total\t0.03s\n",
+      "avg blocks per slot 0.168\n",
+      "Number of blocks 168\n",
+      "longest chain 95\n",
+      "CPU times: user 27.2 ms, sys: 1.37 ms, total: 28.6 ms\n",
+      "Wall time: 27.8 ms\n"
      ]
     }
    ],
@@ -360,20 +491,14 @@
     "np.random.seed(0)\n",
     "sim = Sim(\n",
     "    params=Params(\n",
-    "        SLOTS=100000,\n",
-    "        f=0.05,\n",
-    "        adversary_control = 0.1,\n",
+    "        SLOTS=1000,\n",
+    "        f=1/5,\n",
+    "        adversary_control = 0.3,\n",
     "        honest_stake = np.random.pareto(10, 1000)\n",
     "    ),\n",
-    "    network=NetworkParams(\n",
-    "        mixnet_delay_mean=10, # seconds\n",
-    "        mixnet_delay_var=4,\n",
-    "        broadcast_delay_mean=2, # second\n",
-    "        pol_proof_time=10, # seconds\n",
-    "        no_network_delay=False\n",
-    "    )\n",
+    "    network=blend_net\n",
     ")\n",
-    "sim.run(seed=5)\n",
+    "sim.run(seed=0)\n",
     "\n",
     "n_blocks_per_slot = len(sim.blocks) / sim.params.SLOTS\n",
     "print(\"avg blocks per slot\", n_blocks_per_slot)\n",
@@ -383,31 +508,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 125,
-   "id": "aabccc4e-8f47-403e-b7f9-7508e93ec18b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#sim.visualize_chain()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 126,
-   "id": "0b5b4d8d-85af-4252-b12a-f27fef099d29",
+   "execution_count": 9,
+   "id": "3130e27c-1ce6-439a-a6e7-436990b9315d",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 2.95 s, sys: 287 ms, total: 3.24 s\n",
-      "Wall time: 3.28 s\n"
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.00s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.00s\n",
+      "reorg_depth\t0.00s\n",
+      "depth_append\t0.00s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_24758/682093512.py:279: UserWarning: No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
+      "  _ = ax.legend()\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2000x600 with 2 Axes>"
       ]
@@ -417,51 +545,22 @@
     }
    ],
    "source": [
-    "%%time\n",
-    "reorgs = sim.adverserial_analysis()"
+    "_ = sim.adverserial_analysis(should_plot=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 127,
-   "id": "78567508-a1a3-4b89-abd3-9cd1b4bbb692",
+   "execution_count": 10,
+   "id": "13b4392d-d4ab-4b97-a7db-2bede9b3de9a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2.08% of slots were reorged with depth >= 0\n",
-      "1.41% of slots were reorged with depth >= 1\n",
-      "0.68% of slots were reorged with depth >= 2\n",
-      "0.29% of slots were reorged with depth >= 3\n",
-      "0.13% of slots were reorged with depth >= 4\n",
-      "0.06% of slots were reorged with depth >= 5\n",
-      "0.03% of slots were reorged with depth >= 6\n",
-      "0.01% of slots were reorged with depth >= 7\n",
-      "0.00% of slots were reorged with depth >= 8\n",
-      "0.00% of slots were reorged with depth >= 9\n",
-      "0.00% of slots were reorged with depth >= 10\n",
-      "0.00% of slots were reorged with depth >= 11\n",
-      "0.00% of slots were reorged with depth >= 12\n",
-      "0.00% of slots were reorged with depth >= 13\n",
-      "0.00% of slots were reorged with depth >= 14\n",
-      "0.00% of slots were reorged with depth >= 15\n",
-      "0.00% of slots were reorged with depth >= 16\n",
-      "0.00% of slots were reorged with depth >= 17\n",
-      "0.00% of slots were reorged with depth >= 18\n",
-      "0.00% of slots were reorged with depth >= 19\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "for DEPTH in range(20):\n",
-    "    print(f\"{len(reorgs[reorgs >= DEPTH]) / sim.params.SLOTS*100:.2f}% of slots were reorged with depth >= {DEPTH}\")"
+    "# sim.visualize_chain()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 128,
+   "execution_count": 11,
    "id": "76de5a72-cca5-4b00-9feb-7563cca9c03d",
    "metadata": {},
    "outputs": [
@@ -469,39 +568,57 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "simulating 1/10\n",
-      "simulating 2/10\n",
-      "simulating 3/10\n",
-      "simulating 4/10\n",
-      "simulating 5/10\n",
-      "simulating 6/10\n",
-      "simulating 7/10\n",
-      "simulating 8/10\n",
-      "simulating 9/10\n",
-      "simulating 10/10\n",
-      "finished simulation, starting analysis\n"
+      "simulating 1/2\n",
+      "leader\t0.84s\n",
+      "emit\t0.22s\n",
+      "slot\t1.06s\n",
+      "forkchoice\t0.06s\n",
+      "emit_leader_block\t0.06s\n",
+      "prep\t0.00s\n",
+      "total\t1.08s\n",
+      "simulating 2/2\n",
+      "leader\t0.83s\n",
+      "emit\t0.18s\n",
+      "slot\t1.01s\n",
+      "forkchoice\t0.04s\n",
+      "emit_leader_block\t0.04s\n",
+      "prep\t0.00s\n",
+      "total\t1.03s\n",
+      "finished simulation, starting analysis\n",
+      "Processing block Block(id=5000, slot=98845, height=3776, parent=np.int64(4999), leader=np.int64(18))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.01s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.14s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.00s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.10s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "CPU times: user 2.36 s, sys: 50.7 ms, total: 2.41 s\n",
+      "Wall time: 2.39 s\n"
      ]
     }
    ],
    "source": [
+    "%%time\n",
     "np.random.seed(0)\n",
     "stake = np.random.pareto(10, 100)\n",
     "\n",
     "sims = [Sim(\n",
     "    params=Params(\n",
-    "        SLOTS=10000,\n",
+    "        SLOTS=100000,\n",
     "        f=0.05,\n",
     "        adversary_control = i,\n",
     "        honest_stake = stake\n",
     "    ),\n",
-    "    network=NetworkParams(\n",
-    "        mixnet_delay_mean=10, # seconds\n",
-    "        mixnet_delay_var=4,\n",
-    "        broadcast_delay_mean=2, # second\n",
-    "        pol_proof_time=10, # seconds\n",
-    "        no_network_delay=False\n",
-    "    )\n",
-    ") for i in np.linspace(1e-3, 0.3, 10)]\n",
+    "    network=blend_net\n",
+    ") for i in np.linspace(1e-3, 0.3, 2)]\n",
     "\n",
     "for i, sim in enumerate(sims):\n",
     "    print(f\"simulating {i+1}/{len(sims)}\")\n",
@@ -513,13 +630,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 129,
+   "execution_count": 12,
    "id": "52ff4e83-c6f9-4933-9190-564124a479bc",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 4000x4000 with 2 Axes>"
       ]
@@ -529,14 +646,14 @@
     }
    ],
    "source": [
-    "max_reorg_depth = max(a.max() if len(a) > 0 else 0 for a in advs)\n",
+    "max_reorg_depth = max(max(a) if len(a) > 0 else 0 for a in advs)\n",
     "\n",
     "\n",
     "heatmap = np.zeros((len(advs), max_reorg_depth), dtype=np.int64)\n",
     "\n",
     "for i,  adv in enumerate(advs):\n",
     "    for depth in range(max_reorg_depth):\n",
-    "        heatmap[i][depth] = (adv == depth).sum()\n",
+    "        heatmap[i][depth] = (np.array(adv) == depth).sum()\n",
     "\n",
     "plt.figure(figsize=(40,40))\n",
     "ax = plt.subplot(121)\n",
@@ -555,9 +672,41 @@
     "_ = ax.set_ylabel(\"frequency\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1f552a04-a9bf-4723-b6a8-8faaa147762e",
+   "metadata": {},
+   "source": [
+    "# Reorg sensitivity to blending delay"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 542,
+   "execution_count": 13,
+   "id": "f2bbb618-96c0-4a6d-b1dc-3b73ebafa5e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def reorg_depth_analysis(sim, adv, MAX, **kwargs):\n",
+    "    max_depth = min(MAX, max(adv)  if sum(adv) > 0 else 0)\n",
+    "    \n",
+    "    count_by_depth = np.bincount(adv, minlength=max_depth)[:max_depth]\n",
+    "    \n",
+    "    # count_by_depth = np.zeros(max_depth)\n",
+    "    \n",
+    "    # for d in range(max_depth):\n",
+    "    #     count_by_depth[d] = (adv == d).sum()\n",
+    "\n",
+    "    block_time = 1 / sim.params.f\n",
+    "    honest_chain_length = len(sim.honest_chain())\n",
+    "    blocks = len(sim.blocks)\n",
+    "    expected_blocks = sim.params.SLOTS * sim.params.f\n",
+    "    plt.plot(np.arange(max_depth), count_by_depth / expected_blocks, **kwargs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
    "id": "9cca2f57-1083-446c-b083-1dd158e0e7ca",
    "metadata": {},
    "outputs": [
@@ -565,79 +714,87 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "simulating 1/5\n",
-      "simulating 2/5\n",
-      "simulating 3/5\n",
-      "simulating 4/5\n",
-      "simulating 5/5\n",
+      "simulating 1/4\n",
+      "leader\t1.85s\n",
+      "emit\t0.25s\n",
+      "slot\t2.10s\n",
+      "forkchoice\t0.03s\n",
+      "emit_leader_block\t0.05s\n",
+      "prep\t0.00s\n",
+      "total\t2.12s\n",
+      "simulating 2/4\n",
+      "leader\t1.85s\n",
+      "emit\t0.26s\n",
+      "slot\t2.11s\n",
+      "forkchoice\t0.03s\n",
+      "emit_leader_block\t0.06s\n",
+      "prep\t0.00s\n",
+      "total\t2.12s\n",
+      "simulating 3/4\n",
+      "leader\t1.85s\n",
+      "emit\t0.25s\n",
+      "slot\t2.10s\n",
+      "forkchoice\t0.03s\n",
+      "emit_leader_block\t0.05s\n",
+      "prep\t0.00s\n",
+      "total\t2.12s\n",
+      "simulating 4/4\n",
+      "leader\t1.88s\n",
+      "emit\t0.26s\n",
+      "slot\t2.14s\n",
+      "forkchoice\t0.03s\n",
+      "emit_leader_block\t0.06s\n",
+      "prep\t0.00s\n",
+      "total\t2.16s\n",
       "finished simulation, starting analysis\n",
-      "Processing block Block(id=1000, slot=21002, height=953, parent=999, leader=20)\n",
-      "Processing block Block(id=2000, slot=43475, height=1911, parent=1999, leader=72)\n",
-      "Processing block Block(id=3000, slot=64765, height=2867, parent=2999, leader=23)\n",
-      "Processing block Block(id=4000, slot=86142, height=3833, parent=3999, leader=70)\n",
-      "Processing block Block(id=5000, slot=107452, height=4794, parent=4999, leader=52)\n",
-      "Processing block Block(id=6000, slot=129648, height=5760, parent=5999, leader=41)\n",
-      "Processing block Block(id=7000, slot=150919, height=6702, parent=6999, leader=70)\n",
-      "Processing block Block(id=8000, slot=172689, height=7650, parent=7999, leader=66)\n",
-      "Processing block Block(id=9000, slot=194671, height=8614, parent=8999, leader=27)\n",
-      "Processing block Block(id=1000, slot=21002, height=724, parent=999, leader=20)\n",
-      "Processing block Block(id=2000, slot=43475, height=1451, parent=1997, leader=72)\n",
-      "Processing block Block(id=3000, slot=64765, height=2150, parent=2999, leader=23)\n",
-      "Processing block Block(id=4000, slot=86142, height=2886, parent=3999, leader=70)\n",
-      "Processing block Block(id=5000, slot=107452, height=3612, parent=4997, leader=52)\n",
-      "Processing block Block(id=6000, slot=129648, height=4345, parent=5998, leader=41)\n",
-      "Processing block Block(id=7000, slot=150919, height=5067, parent=6998, leader=70)\n",
-      "Processing block Block(id=8000, slot=172689, height=5777, parent=7998, leader=66)\n",
-      "Processing block Block(id=9000, slot=194671, height=6507, parent=8999, leader=27)\n",
-      "Processing block Block(id=1000, slot=21002, height=584, parent=999, leader=20)\n",
-      "Processing block Block(id=2000, slot=43475, height=1157, parent=1997, leader=72)\n",
-      "Processing block Block(id=3000, slot=64765, height=1733, parent=2998, leader=23)\n",
-      "Processing block Block(id=4000, slot=86142, height=2329, parent=3999, leader=70)\n",
-      "Processing block Block(id=5000, slot=107452, height=2912, parent=4997, leader=52)\n",
-      "Processing block Block(id=6000, slot=129648, height=3510, parent=5998, leader=41)\n",
-      "Processing block Block(id=7000, slot=150919, height=4102, parent=6995, leader=70)\n",
-      "Processing block Block(id=8000, slot=172689, height=4684, parent=7996, leader=66)\n",
-      "Processing block Block(id=9000, slot=194671, height=5264, parent=8998, leader=27)\n",
-      "Processing block Block(id=1000, slot=21002, height=476, parent=999, leader=20)\n",
-      "Processing block Block(id=2000, slot=43475, height=953, parent=1996, leader=72)\n",
-      "Processing block Block(id=3000, slot=64765, height=1429, parent=2998, leader=23)\n",
-      "Processing block Block(id=4000, slot=86142, height=1936, parent=3996, leader=70)\n",
-      "Processing block Block(id=5000, slot=107452, height=2429, parent=4998, leader=52)\n",
-      "Processing block Block(id=6000, slot=129648, height=2928, parent=5998, leader=41)\n",
-      "Processing block Block(id=7000, slot=150919, height=3419, parent=6996, leader=70)\n",
-      "Processing block Block(id=8000, slot=172689, height=3905, parent=7996, leader=66)\n",
-      "Processing block Block(id=9000, slot=194671, height=4406, parent=8998, leader=27)\n",
-      "Processing block Block(id=1000, slot=21002, height=421, parent=999, leader=20)\n",
-      "Processing block Block(id=2000, slot=43475, height=838, parent=1997, leader=72)\n",
-      "Processing block Block(id=3000, slot=64765, height=1254, parent=2998, leader=23)\n",
-      "Processing block Block(id=4000, slot=86142, height=1676, parent=3996, leader=70)\n",
-      "Processing block Block(id=5000, slot=107452, height=2098, parent=4998, leader=52)\n",
-      "Processing block Block(id=6000, slot=129648, height=2537, parent=5998, leader=41)\n",
-      "Processing block Block(id=7000, slot=150919, height=2950, parent=6992, leader=70)\n",
-      "Processing block Block(id=8000, slot=172689, height=3378, parent=7996, leader=66)\n",
-      "Processing block Block(id=9000, slot=194671, height=3810, parent=8996, leader=27)\n"
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.03s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.06s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.04s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.07s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.05s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.07s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.04s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t0.07s\n",
+      "reorg_depth\t0.01s\n",
+      "depth_append\t0.00s\n",
+      "CPU times: user 8.78 s, sys: 239 ms, total: 9.02 s\n",
+      "Wall time: 9.03 s\n"
      ]
     }
    ],
    "source": [
+    "%%time\n",
+    "\n",
     "np.random.seed(0)\n",
-    "stake = np.random.pareto(10, 100)\n",
+    "stake = np.random.pareto(10, 1000)\n",
     "\n",
     "sims = [Sim(\n",
     "    params=Params(\n",
-    "        SLOTS=200000,\n",
-    "        f=0.05,\n",
-    "        adversary_control = 0.1,\n",
+    "        SLOTS=100000,\n",
+    "        f=1/30,\n",
+    "        adversary_control = 0.3,\n",
     "        honest_stake = stake\n",
     "    ),\n",
-    "    network=NetworkParams(\n",
-    "        mixnet_delay_mean=i, # seconds\n",
-    "        mixnet_delay_var=(i / 5)**2,\n",
-    "        broadcast_delay_mean=1e-6, # second\n",
-    "        pol_proof_time=0, # seconds\n",
-    "        no_network_delay=False\n",
-    "    )\n",
-    ") for i in np.linspace(1, 30, 5)]\n",
+    "    network=replace(blend_net, blending_delay=i),\n",
+    ") for i in [1,3,5,10]]\n",
     "\n",
     "\n",
     "for i, sim in enumerate(sims):\n",
@@ -650,13 +807,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 543,
+   "execution_count": 15,
    "id": "1ff938f3-6bc4-4b8e-bd9a-492db140d7b9",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHFCAYAAADi7703AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADhrklEQVR4nOzdd3yN1x/A8c/NHjdbFjKshMQKEUWVFAlBtWoURYTaq63WHq1S0SqtWm0l1KZGUWJH7D1qpkhECEGsJDLv+f2RX25dmeQmQc/79Xpecp97nnPOc9fzdc55zlEIIQSSJEmSJElSrnRKuwKSJEmSJEmvMhksSZIkSZIk5UMGS5IkSZIkSfmQwZIkSZIkSVI+ZLAkSZIkSZKUDxksSZIkSZIk5UMGS5IkSZIkSfmQwZIkSZIkSVI+ZLAkSZIkSZKUDxksSYUWHh6OQqEgPDy8WMuZO3cuixYtyrP8P/74o1jLL2nR0dEoFAqNcz548CCTJk3i4cOHOdI3bdqUpk2bFns5RbF8+XJmzZql1Ty1YdGiRSgUCqKjo0u7KiQnJzNp0qQif5+K8r18lV4Pbdi9ezdBQUFUrVoVU1NTypUrR7t27Thx4kSu6U+ePEnz5s1RKpVYWlrSvn17rl27ppW6vMjv1aRJk1AoFFopNzeBgYEolcqXOnbLli1MmjQp1+dcXV0JDAx8+Yq9RmSwJL1y8gqW3lSOjo4cOnSI1q1bq/cdPHiQr776KtcgZu7cucydO7fYyymKVzVYat26NYcOHcLR0bG0q0JycjJfffVVsf/n41UnhGDDhg106NCBsmXLoqenh42NDY0bN2bOnDmkpKQUOq958+YRHR3NsGHD2LJlCz/++CPx8fG89dZb7N69WyPtpUuXaNq0KWlpaaxevZqQkBAiIyNp3Lgxd+/e1fZpvra2bNnCV199letz69evZ/z48SVco9KhV9oV+C9ITk7GxMTkjStL0g5DQ0PeeuutQqf38PAokXLeRLa2ttja2pZ2NaT/u3HjBp06deLs2bN0796d4OBgXFxcSE5O5vTp08yZM4dZs2axYsUKvL29C8xvzpw52NnZaexr2bIllStXZurUqbz77rvq/RMmTMDQ0JDNmzdjbm4OQN26dalSpQrff/89wcHB2j3ZN5CXl1dpV6HkCEmrJk6cKABx4sQJ8eGHHwpLS0vh4OAghBBCpVKJOXPmiFq1agkjIyNhaWkpPvzwQ3H16tUc+SxcuFDUrFlTGBoaCisrK/H++++LCxcuaKTp2bOnMDU1FWfPnhUtWrQQSqVSvPXWW0IIIR48eCCCgoKElZWVMDU1FQEBAeLq1asCEBMnTizwPC5evCj8/f2FsbGxsLGxEf369RMbN24UgNizZ49G2h07doh3331XmJmZCWNjY9GwYUOxc+fOXF+XkydPig8++ECYmZkJc3Nz0a1bNxEfH69O5+LiIgCNzcXFRQghxJ49ewQgli9fLsaMGSMcHR2FmZmZaNasmbh06VKB5xQfHy8++eQTUb58eWFgYCDKlCkjGjZsKHbs2PHS53Pu3Dnx0UcfCXNzc2FnZyd69eolHj58qJF29erVwsfHR5ibmwtjY2NRoUIF0atXL/XzUVFRAhChoaEaeT+/Zb/uTZo0EU2aNBFCCJGWliZsbW3Fxx9/nON8Hzx4IIyMjMSnn376wuVkf3aSkpJy5Ovr6ys8PDzyfJ2bNGmSa77Z7t+/LwYMGCDKli0r9PX1RYUKFcSYMWNESkpKnnk+m7enp6c4ePCgaNCggTAyMhIuLi4iJCRECCHE5s2bhZeXlzA2NhbVq1cXW7du1Tg+NDRUACIqKkoIIURkZKQwMzMTHTp00Ei3a9cuoaOjI8aNG6fe5+LiIlq3bi22bt0qvLy8hJGRkXB3dxcLFy7MUc+4uDjRt29fUa5cOaGvry9cXV3FpEmTRHp6uhDi3/fi+a1nz575nr+2v5fPvx5CCLF9+3bx3nvviXLlyglDQ0NRqVIl0bdvX3H37l11moiICPV38XmLFy8WgDh69Gi+53Lr1i1Rvnx58f7774v79+/nmiY9PV189dVXwsrKSpw9ezbf/PLj6+sr3NzcNPI1NjYW/fr1y5HWz89PVKlSRf04MzNTTJ48Wbi5uQkjIyNhYWEhatSoIWbNmpVvmdm/V0uWLBGffvqpsLe3F0ZGRuKdd94RJ0+e1Eib/V18VmZmpggODhbu7u7CwMBA2Nraiu7du4sbN27kKGvr1q3i3XffVf/GVK1aVUydOlX9fPa14ln79+8XNjY2onXr1iIxMTHXc+jZs2eun9Psz4uLi4vGZzb7nJctWya+/PJL4eDgIExNTUWbNm3E7du3xePHj8Unn3wibGxshI2NjQgMDBRPnjzRKPNFrpMlSQZLWpb9oXdxcREjR44UO3bsEBs2bBBCCPHJJ58IfX198fnnn4uwsDCxfPlyUbVqVWFvby9u376tzmPq1KkCEF26dBF//fWX+P3330XFihWFhYWFiIyMVKfr2bOn+of422+/Fbt27RLbtm0TmZmZ4u233xZGRkZi2rRpYvv27eKrr74SVapUKVSwdPv2bWFnZyfKlSsnQkNDxZYtW0S3bt2Es7Nzjh/lJUuWCIVCId5//32xbt06sWnTJtGmTRuhq6ur8cP87OvyxRdfiG3btokffvhBmJqaCi8vL5GWliaEEOLkyZOiYsWKwsvLSxw6dEgcOnRI/cOS/UV0dXUV3bp1E3/99ZdYsWKFcHZ2FlWqVBEZGRn5npe/v7+wtbUVv/zyiwgPDxcbNmwQEyZMECtXrnzp83F3dxcTJkwQO3bsED/88IMwNDTUCIQOHjwoFAqF+Oijj8SWLVvE7t27RWhoqOjevbs6zfNBzI0bN8SQIUMEINatW6d+HR49eiSE0AyWhBDi008/FcbGxurns82dO1cA6ovMi5Rz5swZAYhff/1VI8/z588LQMyZMyfP1/n8+fOiUaNGwsHBQZ3noUOHhBBCPH36VNSsWVOYmpqK77//Xmzfvl2MHz9e6OnpiYCAgHzfv+xzt7GxUQcp27ZtE23atBGA+Oqrr0SNGjXEihUrxJYtW8Rbb70lDA0Nxc2bN9XH5xYcrFy5UgDixx9/FEJkBTr29vaiSZMmGp8pFxcXUb58eeHh4SF+//13sW3bNtGxY0cBiL1796rTxcXFCScnJ+Hi4iIWLFggdu7cKSZPniwMDQ1FYGCgEEKIlJQUERYWJgDRu3dv9Wt05cqVPM+9OL6Xub0e8+bNE99++63YuHGj2Lt3r1i8eLGoVauWcHd3V39PhRDCy8tLNGrUKEc969WrJ+rVq5fPu5jFz89PtG/fXqhUqlyfV6lU6td//PjxombNmnmmzc/Dhw+FhYWF+OCDD9T7Ll26lOfneMSIEUKhUIinT58KIYT49ttvha6urpg4caLYtWuXCAsLE7NmzRKTJk3Kt9zs3ysnJyfRrl07sWnTJrF06VJRuXJlYW5urnHxzy1Y6tu3rwDE4MGDRVhYmJg/f76wtbUVTk5OGoHrb7/9JhQKhWjatKlYvny52Llzp5g7d64YOHCgOs3zwdKqVauEoaGhGDBgQL6/m1euXBEdOnQQgMZ3Ofs/NnkFSy4uLiIwMFBdb6VSKXx9fUWLFi3EiBEjxPbt20VwcLDQ1dUVQ4YM0SizsNfJkiaDJS3L/tBPmDBBY/+hQ4cEIGbMmKGx/8aNG8LY2Fh8+eWXQois1gBjY+McF46YmBhhaGgounbtqt6XHfVn/686219//SUAMW/ePI393377baGCpZEjRwqFQiFOnz6tsb9FixYaP8pJSUnC2tpatG3bViNdZmamqFWrlvDx8cnxumS3cmRbtmyZAMTSpUvV+zw9PTWCgWzZX8TnX5vVq1erv8z5USqVYvjw4Xk+/zLnM336dI20AwcOFEZGRuof9e+//14AOVqbnvV8ECOEEN99912Oi1i254Ols2fPCkD88ssvGul8fHxE3bp1i1RO7dq1NfYNGDBAmJub5/jf4PNat26tbhF81vz58wUgVq9erbE/ODhYAGL79u355pvdanX8+HH1vvv37wtdXV1hbGysERidPn1aAOKnn35S78stOMg+LwMDA3Ho0CHx7rvvCjs7O3Hr1i2NNC4uLsLIyEhcv35dve/p06fC2tpao4WiX79+QqlUaqQT4t/Pwvnz54UQQty9e7fQLb1CFM/3Mq/XI5tKpRLp6eni+vXrAhB//vlnjmNPnTql3nf06FEBiMWLF+d7Lvv37xempqYaLUrz5s0TFSpUEPr6+qJZs2bit99+U3+G0tLShKOjY46WscLo1q2b0NPT0/jMHDhwQABixYoVOdJn/2c1+/1v06ZNju9BYWT/XtWpU0cjyIuOjhb6+vqiT58+6n3PB0sXL14UgEbAI4QQR44cEYAYM2aMEEKIJ0+eCHNzc/H222/nG0g+GyxNmzZN6OrqiuDg4EKdx6BBg3IEctnyCpae/+wNHz5cAGLo0KEa+99//31hbW2tflzY62RpkAO8i8mHH36o8Xjz5s0oFAo+/vhjMjIy1JuDgwO1atVSD/I8dOgQT58+zXGHgZOTE++++y67du0qsKy9e/cC0KlTJ439Xbp0KVTd9+zZg6enJ7Vq1dLY37VrV43HBw8eJCEhgZ49e2qck0qlomXLlhw7doykpCSNY7p166bxuFOnTujp6bFnz55C1Q3gvffe03hcs2ZNAK5fv57vcT4+PixatIhvvvmGw4cPk56eXuTzya0uKSkpxMfHA1CvXj31ea5evZqbN28W+jwLq0aNGtStW5fQ0FD1vosXL3L06FGCgoJeOt9hw4Zx+vRpDhw4AMDjx49ZsmQJPXv2fOk7a3bv3o2pqSkdOnTQ2J/9ec/t8/08R0dH6tatq35sbW2NnZ0dtWvXpmzZsur91apVAwr+XADMnDkTT09PfH19CQ8PZ+nSpbkOAq9duzbOzs7qx0ZGRri5uWmUsXnzZnx9fSlbtqzG56hVq1bAv9/PF1Wc38tnxcfH079/f5ycnNDT00NfXx8XFxcg63OVrUuXLtjZ2TFnzhz1vtmzZ2Nra0vnzp3zPZfsAd3W1tYAbNy4kSFDhhAYGMj27dtp3LgxQ4cOVafX19enZcuWOQZpF2T8+PEsW7aMmTNnanxmsuV3B1r2cz4+Ppw5c4aBAweybds2Hj9+/EJ16Nq1q0Y5Li4uNGzYMN/fvOznnr8O+Pj4UK1aNfX35ODBgzx+/JiBAwcWeDedEIJ+/foxceJEli9fzpdffvlC5/Ei2rRpo/E4+7v47M0l2fsTEhJITEwECn+dLA0yWComz//Q3rlzByEE9vb26Ovra2yHDx/m3r17ANy/fz/X4wHKli2rfj6biYmJenBitvv376Onp6f+Icpmb29fqLrfv38fBweHHPuf33fnzh0AOnTokOOcgoODEUKQkJCQbx7Zd748f175sbGx0XhsaGgIwNOnT/M9btWqVfTs2ZPffvuNBg0aYG1tTY8ePbh9+/ZLn09BdXnnnXfYsGEDGRkZ9OjRg/Lly1O9enVWrFhR6PMtjKCgIA4dOsSlS5cACA0NxdDQsNABcm7atWuHq6ur+mK4aNEikpKSGDRo0Evnmf3Zev6H3c7ODj09vUJ9Dp7/XAMYGBjk2G9gYABQqLupDA0N6dq1KykpKdSuXZsWLVrkmu759zv72Gc/e3fu3GHTpk05PkOenp4A6u/6iyrO72U2lUqFn58f69at48svv2TXrl0cPXqUw4cPA5rfMUNDQ/r168fy5ct5+PAhd+/eZfXq1fTp00f9PchLZGSk+j85AAsWLCAwMJAJEybQtGlTJk6cmCPgsre3f6G71L766iu++eYbpkyZwuDBgzWey34fc/u8JSQkoFAosLS0BGD06NF8//33HD58mFatWmFjY0OzZs04fvx4oeqR13uW32e9sNeB7NejfPnyBdYjLS2NVatW4enpqQ7ci0te38WCvqOFvU6WBnk3XDF5/mJQpkwZFAoF+/bty/WHJHtf9pc4Li4uR5pbt25RpkyZfMvJziMjI4OEhASND2d2UFAQGxubXNM+vy+7LrNnz87zLqvnA7Tbt29Trlw59eOMjAzu37+f60VI28qUKcOsWbOYNWsWMTExbNy4kVGjRhEfH09YWNhLnU9htGvXjnbt2pGamsrhw4f59ttv6dq1K66urjRo0KBI55StS5cufPbZZyxatIgpU6awZMkS3n//faysrF46Tx0dHQYNGsSYMWOYMWMGc+fOpVmzZri7u790njY2Nhw5cgQhhMZnNz4+noyMjByf75Jy7tw5JkyYQL169Th27Bg//PADn3322UvlVaZMGWrWrMmUKVNyff7Z1q8XUZzfy2znzp3jzJkzLFq0iJ49e6r3X7lyJdf0AwYMYNq0aYSEhJCSkkJGRgb9+/cv8FzS09MxMjJSP46KisrRGlGvXj2NlqTY2FicnJwKzBuyAqVJkyYxadIkxowZk+P5SpUqYWxszN9//53jub///pvKlSur66enp8dnn33GZ599xsOHD9m5cydjxozB39+fGzduFHj3cV7vWX6/ec9eB54PhJ69DmTf2RkbG5tvHSDrGrNnzx78/f1p3rw5YWFhRfp9KA6FvU6WBtmyVELatGmDEIKbN2/i7e2dY6tRowYADRo0wNjYmKVLl2ocHxsby+7du2nWrFmBZTVp0gTIakl51sqVKwtVV19fX86fP8+ZM2c09i9fvlzjcaNGjbC0tOTChQu5npO3t7f6fw7Zli1bpvF49erVZGRkaEyy+Pz/1IuDs7MzgwcPpkWLFpw8efKlz+dFGBoa0qRJE/UtyadOnco3LRTcWpbNysqK999/n99//53Nmzdz+/btQnXBFVROnz59MDAwoFu3bly+fDnH/9Dzyze3PJs1a0ZiYiIbNmzQ2P/777+rny9pSUlJdOzYEVdXV/bs2cPgwYMZNWoUR44cean82rRpw7lz56hUqVKun6HsYOlF3+Pi/F5myw5gn78oLViwINf0jo6OdOzYkblz5zJ//nzatm2r0U2ZF2dnZyIjI9WP7e3tc0yMGRUVpf47ISGBjRs34u/vX2DekydPZtKkSYwbN46JEyfmmkZPT4+2bduybt06njx5ot4fExPDnj17aN++fa7HWVpa0qFDBwYNGkRCQkKhJvNcsWIFQgj14+vXr3Pw4MF8J5bNnuLg+evAsWPHuHjxovp70rBhQywsLJg/f75GGXnx8vJi7969xMbG0rRpU/Vwgfy86Oe0KAp7nSwNsmWphDRq1Ii+ffvSq1cvjh8/zjvvvIOpqSlxcXHs37+fGjVqMGDAACwtLRk/fjxjxoyhR48edOnShfv37/PVV19hZGSU55f/WS1btqRRo0Z8/vnnPH78mLp163Lo0CH1BUlHJ/8Yefjw4YSEhNC6dWu++eYb7O3tWbZsmbqLJ5tSqWT27Nn07NmThIQEOnTogJ2dHXfv3uXMmTPcvXuXefPmaRyzbt069PT0aNGiBefPn2f8+PHUqlVLY3xVjRo1WLlyJatWraJixYoYGRkV+Uvy6NEjfH196dq1K1WrVsXMzIxjx44RFham/mF8mfMpyIQJE4iNjaVZs2aUL1+ehw8f8uOPP6Kvr68OanOTfb4//vgjPXv2RF9fH3d3d8zMzPI8JigoiFWrVjF48GDKly9P8+bNC6xfQeVYWlrSo0cP5s2bh4uLC23bti3UedeoUYN169Yxb9486tati46ODt7e3vTo0YM5c+bQs2dPoqOjqVGjBvv372fq1KkEBAQUqs7a1r9/f2JiYjh69CimpqbMmDGDQ4cO8dFHH3Hq1Cl1d0xhff311+zYsYOGDRsydOhQ3N3dSUlJITo6mi1btjB//nzKly+PmZkZLi4u/PnnnzRr1gxra2vKlCmDq6trrvkW5/cyW9WqValUqRKjRo1CCIG1tTWbNm1ix44deZ7vsGHDqF+/PoDGuLn8+Pn5MXz4cKZPn46BgQGdOnVi1KhRNG7cmMaNG3PgwAEWLFiApaUlhw4dYsiQITRv3jzf7wzAjBkzmDBhAi1btqR169bq7sNsz7a0ffXVV9SrV482bdowatQoUlJSmDBhAmXKlOHzzz9Xp2vbti3Vq1fH29sbW1tbrl+/zqxZs3BxcaFKlSoFnmt8fDwffPABn3zyCY8ePWLixIkYGRkxevToPI9xd3enb9++zJ49Gx0dHVq1akV0dDTjx4/HycmJTz/9FMh6r2fMmEGfPn1o3rw5n3zyCfb29ly5coUzZ87w888/58i7WrVq7Nu3j+bNm/POO++wc+fOfLvxsn8jgoODadWqFbq6utSsWbNI/3HMS2Gvk6WidMaVv7my72p49tbOZ4WEhIj69esLU1NTYWxsLCpVqiR69OihcaeGEFm3g9asWVMYGBgICwsL0a5dO/VdNNlymzsjW0JCgujVq5ewtLQUJiYmokWLFuLw4cMat0jn58KFC6JFixbCyMhIWFtbi969e4s///wz1/lc9u7dK1q3bi2sra2Fvr6+KFeunGjdurVYs2ZNjtflxIkTom3btkKpVAozMzPRpUsXcefOHY38oqOjhZ+fnzAzM8t1nqVn8xUi97u8npeSkiL69+8vatasqZ6LxN3dXUycODHHXEIvcj7Pv8/P3120efNm0apVK1GuXDlhYGAg7OzsREBAgNi3b1+B9R89erQoW7as0NHRyXOepWdlZmYKJycnAYixY8fmeP5Fy8kWHh4uADFt2rRcXtncJSQkiA4dOghLS0uhUChyzLPUv39/4ejoKPT09ISLi4sYPXr0C82z9LzsOZCeB4hBgwapHz///vz666+5viZXrlwR5ubm4v333y+wjNzej7t374qhQ4eq7+6ytrYWdevWFWPHjtWY02bnzp3Cy8tLGBoaFmqeJW1/L3O7Gy67DDMzM2FlZSU6duwoYmJi8r1zz9XVVVSrVi3fuj8rPT1duLm5qW+/z8jIEP369VN/VhwdHcXXX38tAGFhYSFGjx4tUlNTC8w3rzm+srfnHT9+XDRr1kyYmJio3+/np2+YMWOGaNiwoShTpowwMDAQzs7Oonfv3iI6Ojrfujw7z9LQoUOFra2tMDQ0FI0bN87xe5/fPEtubm5CX19flClTRnz88ce5zrO0ZcsW0aRJE2FqaipMTEyEh4eHxt1uuV0rYmNjRdWqVYWrq2u+cxilpqaKPn36CFtbW/X7U9A8S8//Rmd/zo4dO5breT//O1rY62RJksHSf0j2bfoHDhwo8bILCiKlV9dnn30mjI2Nxb1790q7KtIrKHtOrvzm3srNgQMHhLGxsZg5c6Z634MHD8T58+dFWlqaePLkiYiMjCxw/jRJKgmyG+4NtWLFCm7evEmNGjXQ0dHh8OHDfPfdd7zzzjs0bNiwtKsnvQYOHz5MZGQkc+fOpV+/fiUyCF96fVy9epXr168zZswYHB0dX3hB1YYNG/Lnn3/y0Ucf8ccffzB48GAaNWpExYoVefDgAadPn2bZsmX8/fffHDhwAGNj4+I5EUkqhP/EAO/Nmzfj7u5OlSpV+O2330q7OiXCzMyMlStX0rlzZwICAvj1118JDAxk06ZNpV016TXRoEEDBgwYQJs2bfjmm29KuzrSK2by5Mm0aNGCxMRE1qxZ81JrUrZo0YKLFy9Sv359Pv/8c5ydnTE2Nsbe3p4uXbpgZGTEH3/8IQMlqdQphCjEEPrXWEZGBh4eHuzZswdzc3Pq1KnDkSNHcp2rRZIkSSo9N2/e5P79+5ibm+Pi4lLgRIuSVFLe+Jalo0eP4unpSbly5TAzMyMgIIBt27aVdrUkSZKk55QrV46aNWvi6uoqAyXplfLKB0sRERG0bduWsmXLolAocszPAjB37lwqVKiAkZERdevWZd++fernbt26pTEJYvny5YtlyQlJkiRJkt5Mr3ywlJSURK1atXKdLwKyJl4cPnw4Y8eO5dSpUzRu3JhWrVoRExMDkOtEXfJ/LJIkSZIkFdYrfzdcq1at8l3H5ocffqB379706dMHgFmzZrFt2zbmzZvHt99+S7ly5TRakmJjY9UTqOUmNTWV1NRU9WOVSkVCQgI2NjYyyJIkSZKk14QQgidPnlC2bNkCJ2MuTGavDUCsX79e/Tg1NVXo6uqKdevWaaQbOnSoeOedd4QQWZOfVa5cWcTGxorHjx+LypUr5ztfTPZ8QHKTm9zkJje5ye3133KbyPNFvfItS/m5d+8emZmZORaFtLe3Vy9eqKenx4wZM/D19UWlUvHll1/mO1/M6NGjNRbQfPToEc7Ozty4cQNzc/PiORFJkiRJkrTq8ePHODk55btMVGG91sFStue7x8RzK5q/9957vPfee4XKy9DQMNeVjc3NzWWwJEmSJEmvGW0MoXnlB3jnp0yZMujq6qpbkbLFx8fnaG2SJEmSJEl6Ga91sGRgYEDdunVzrIidveK3JEmSJElSUb3y3XCJiYlcuXJF/TgqKorTp09jbW2Ns7Mzn332Gd27d8fb25sGDRrwyy+/EBMTQ//+/Uux1pIkSZIkvSle+WDp+PHj+Pr6qh9nD77u2bMnixYtonPnzty/f5+vv/6auLg4qlevzpYtW3BxcSlSuXPmzGHOnDlkZmYWKR9JkqTnqVQq0tLSSrsakvRa09fXR1dXt0TKeuPXhiuqx48fY2FhwaNHj+QAb0mSiiwtLY2oqChUKlVpV0WSXnuWlpY4ODjkOohbm9fvV75lSZIk6U0hhCAuLg5dXV2cnJyKPlGeJP1HCSFITk4mPj4eAEdHx2ItTwZLkiRJJSQjI4Pk5GTKli2LiYlJaVdHkl5rxsbGQNYd8HZ2dsXaJSf/WyNJklRCssdAGhgYlHJNJOnNkP2fjvT09GItRwZLkiRJJUyuMylJ2lFS3yUZLOVhzpw5eHh4UK9evdKuiiRJkiRJpUgGS3kYNGgQFy5c4NixY6VdFUmSpFeaQqFAoVBgaWmplbw2bNhQ5HxKWnR0NAqFgtOnTxf6mKZNmzJ8+HCt1sPV1VX9fjx8+FCref+XyWBJkiRJyldgYKD6Avzs1rJlS3Wa0NBQIiMji1xWXFwcrVq1KnI+LyIwMJD333+/RMssLseOHWPt2rVFyiMiIoK2bdtStmzZFwpe9+7dS926dTEyMqJixYrMnz+/SPV4lchgSZIkSSpQy5YtiYuL09hWrFihft7S0hI7O7sil+Pg4JDrYuZS4dja2mJtbV2kPJKSkqhVqxY///xzoY+JiooiICCAxo0bc+rUKcaMGcPQoUOLHLi9KmSwJEmSJBXI0NAQBwcHjc3KyirP9JMmTaJ27dqEhITg7OyMUqlkwIABZGZmMn36dBwcHLCzs2PKlCkaxz3bkvH777+jVCr5559/1M8PGTIENzc3kpKSgKxup6lTpxIUFISZmRnOzs788ssvGnnevHmTzp07Y2VlhY2NDe3atSM6Olpdz8WLF/Pnn3+qW8zCw8MLfD2OHj2Kl5cXRkZGeHt7c+rUqRxpLly4QEBAAEqlEnt7e7p37869e/fyzHPp0qV4e3tjZmaGg4MDXbt2Vc8jJISgcuXKfP/99xrHnDt3Dh0dHa5evVpgnQurVatWfPPNN7Rv377Qx8yfPx9nZ2dmzZpFtWrV6NOnD0FBQRr1DQ8Px8fHB1NTUywtLWnUqBHXr1/XWr2LkwyWJEmSSokQguS0jFLZSmLxhqtXr7J161bCwsJYsWIFISEhtG7dmtjYWPbu3UtwcDDjxo3j8OHDuR7fo0cPAgIC6NatGxkZGYSFhbFgwQKWLVuGqampOt2MGTPUAcvAgQMZMGAAly5dAiA5ORlfX1+USiURERHs378fpVJJy5YtSUtLY8SIEXTq1Emj5ayghdiTkpJo06YN7u7unDhxgkmTJjFixAiNNHFxcTRp0oTatWtz/PhxwsLCuHPnDp06dcoz37S0NCZPnsyZM2fYsGEDUVFRBAYGAllBZFBQEKGhoRrHhISE0LhxYypVqpRnvvv27UOpVOa7TZ06Nd9zLsihQ4fw8/PT2Ofv78/x48dJT08nIyOD999/nyZNmnD27FkOHTpE3759X5s7Q+WklJIkSaXkaXomHhO2lUrZF772x8Sg8JeAzZs3o1QqNfaNHDmS8ePH53mMSqUiJCQEMzMzPDw88PX15fLly2zZsgUdHR3c3d0JDg4mPDyct956K9c8FixYQM2aNRk6dCjr1q1j4sSJOe5SDggIYODAgeo6zZw5k/DwcKpWrcrKlSvR0dHht99+U1+YQ0NDsbS0JDw8HD8/P4yNjUlNTcXBwaFQr8WyZcvIzMwkJCQEExMTPD09iY2NZcCAAeo08+bNo06dOhpBSEhICE5OTkRGRuLm5pYj36CgIPXfFStW5KeffsLHx4fExESUSiW9evViwoQJHD16FB8fH9LT01m6dCnfffddvvX19vYucOB5Ubvubt++jb29vcY+e3t7MjIyuHfvHoaGhjx69Ig2bdqoA7tq1aoVqcySJIOlPMiFdCVJkv7l6+vLvHnzNPYVdIF1dXXFzMxM/dje3h5dXV2NZV7s7e3VXU25sbKyYuHChfj7+9OwYUNGjRqVI03NmjXVfysUChwcHNR5njhxgitXrmjUAyAlJeWlu64uXrxIrVq1NGZhb9CggUaaEydOsGfPnhwBJmS1uOUWLJ06dYpJkyZx+vRpEhIS1OsHxsTE4OHhgaOjI61btyYkJAQfHx82b95MSkoKHTt2zLe+xsbGVK5c+WVO9YU830qU3XqpUCiwtrYmMDAQf39/WrRoQfPmzenUqVOxL1OiLTJYysOgQYMYNGiQeiE+SZIkbTPW1+XC1/6lVvaLMDU1feELrr6+vsZjhUKR676CFhWOiIhAV1eXW7dukZSUlGNR1PzyVKlU1K1bl2XLluXI19bWttDn8qzCdGGqVCratm1LcHBwjudyCxCSkpLw8/PDz8+PpUuXYmtrS0xMDP7+/qSlpanT9enTh+7duzNz5kxCQ0Pp3LlzgUvn7Nu3r8A7DMeMGcOYMWMKPK+8ODg4cPv2bY198fHx6OnpYWNjA2S16A0dOpSwsDBWrVrFuHHj2LFjR56tiq8SGSxJkiSVEoVC8UJdYf9FBw8eZPr06WzatIlRo0YxZMgQFi9eXOjj69Spw6pVq7Czs8tz5XkDA4MX6kXw8PBgyZIlPH36VL0+2fPjrurUqcPatWtxdXVFT6/g9/jSpUvcu3ePadOm4eTkBMDx48dzpAsICMDU1JR58+axdetWIiIiCsy7JLrhGjRowKZNmzT2bd++HW9vb41g1svLCy8vL0aPHk2DBg1Yvnz5axEsyQHekiRJUoFSU1O5ffu2xpbfnV3a8OTJE7p3786QIUNo1aoVy5cvZ/Xq1axZs6bQeXTr1o0yZcrQrl079u3bR1RUFHv37mXYsGHExsYCWd2FZ8+e5fLly9y7d6/Adca6du2Kjo4OvXv35sKFC2zZsiXHXWqDBg0iISGBLl26cPToUa5du8b27dsJCgrKNTBzdnbGwMCA2bNnc+3aNTZu3MjkyZNzpNPV1SUwMJDRo0dTuXLlHN1/ucnuhstvezZYSkxM5PTp0+oAKyoqitOnTxMTE6NOM3r0aHr06KF+3L9/f65fv85nn33GxYsXCQkJYeHCheqB71FRUYwePZpDhw5x/fp1tm/fTmRk5GszbkkGS5IkSVKBwsLCcHR01NjefvvtYi1z2LBhmJqaqgdJe3p6EhwcTP/+/bl582ah8jAxMSEiIgJnZ2fat29PtWrVCAoK4unTp+qWpk8++QR3d3e8vb2xtbXlwIED+eapVCrZtGkTFy5cwMvLi7Fjx+bobitbtiwHDhwgMzMTf39/qlevzrBhw7CwsNAYs5XN1taWRYsWsWbNGjw8PJg2bVqOACxb7969SUtL0xgQrk3Hjx9XtwABfPbZZ3h5eTFhwgR1mri4OI3gqUKFCmzZsoXw8HBq167N5MmT+emnn/jwww+BrPfh0qVLfPjhh7i5udG3b18GDx5Mv379iuUctE0hSuL+0ddY9pilR48e5dmEK0mSVBgpKSlERUVRoUIFjIyMSrs6WqNQKFi/fv0bMwv2q+7AgQM0bdqU2NjYHHegQdZ8Rr6+vjx48EArS9C8yvL7Tmnz+i07yyVJkqQi69KlCzY2NuquLUn7UlNTuXHjBuPHj6dTp065Bkqenp5cu3atFGr3ZpPBkiRJklQk2TNs6+q+2B12r6qpU6fmOUlj48aN2bp1awnXKMuKFSvo3bs3tWvXZsmSJbmm2bJli3rMlewN0R7ZDZeHZ+dZioyMlN1wkiQV2ZvaDfemSUhIICEhIdfnjI2NKVeuXAnXSMqL7IYrZXKeJUmSpP8ma2vrIt9KL71Z5N1wkiRJkiRJ+ZDBkiRJkiRJUj5ksCRJkiRJkpQPGSxJkiRJkiTlQwZLkiRJkiRJ+ZDBkiRJklQkCoUChUKhldmiFQoFGzZsKHI+JS06OhqFQlHggrXPatq0KcOHD9dqPVxdXdXvx8OHD7Wa93+ZDJYkSZKkfAUGBqovwM9uLVu2VKcJDQ0lMjKyyGXFxcXRqlWrIufzIgIDA9+YpVqOHTvG2rVri5RHRkYG48aNo0KFChgbG1OxYkW+/vprVCpVnsesW7eOFi1aYGtri7m5OQ0aNGDbtm1FqserRM6zJEmSJBWoZcuWhIaGauwzNDRU/21paYmdnV2Ry3FwcChyHv9ltra2RZ4jKjg4mPnz57N48WI8PT05fvw4vXr1wsLCgmHDhuV6TEREBC1atGDq1KlYWloSGhpK27ZtOXLkiHpB3teZbFnKw5w5c/Dw8KBevXqlXRVJkqRSZ2hoiIODg8ZmZWWVZ/pJkyZRu3ZtQkJCcHZ2RqlUMmDAADIzM5k+fToODg7Y2dkxZcoUjeOe7Yb7/fffUSqV6uVUAIYMGYKbmxtJSUlAVrfT1KlTCQoKwszMDGdnZ3755ReNPG/evEnnzp2xsrLCxsaGdu3aER0dra7n4sWL+fPPP9UtZuHh4QW+HkePHsXLywsjIyO8vb05depUjjQXLlwgICAApVKJvb093bt35969e3nmuXTpUry9vTEzM8PBwYGuXbsSHx8PgBCCypUr8/3332scc+7cOXR0dLh69WqBdS6sQ4cO0a5dO1q3bo2rqysdOnTAz8+P48eP53nMrFmz+PLLL6lXrx5VqlRh6tSpVKlShU2bNqnThIeH4+Pjg6mpKZaWljRq1Ijr169rrd7FSQZLeRg0aBAXLlzg2LFjpV0VSZLeVEJAWlLpbCWw0tXVq1fZunUrYWFhrFixgpCQEFq3bk1sbCx79+4lODiYcePGcfjw4VyP79GjBwEBAXTr1o2MjAzCwsJYsGABy5Ytw9TUVJ1uxowZ6oBl4MCBDBgwgEuXLgGQnJyMr68vSqWSiIgI9u/fj1KppGXLlqSlpTFixAg6depEy5YtiYuLIy4ujoYNG+Z7XklJSbRp0wZ3d3dOnDjBpEmTGDFihEaauLg4mjRpQu3atTl+/DhhYWHcuXOHTp065ZlvWloakydP5syZM2zYsIGoqCgCAwOBrCAyKCgoR+teSEgIjRs3plKlSnnmu2/fPpRKZb7bs2vhvf322+zatUvdrXrmzBn2799PQEBAvq/Ls1QqFU+ePFG3cmVkZPD+++/TpEkTzp49y6FDh+jbty8KhaLQeZYm2Q0nSZJUWtKTYWrZ0il7zC0wMC043f9t3rwZpVKpsW/kyJGMHz8+z2NUKhUhISGYmZnh4eGBr68vly9fZsuWLejo6ODu7k5wcDDh4eG89dZbueaxYMECatasydChQ1m3bh0TJ07M0eIfEBDAwIED1XWaOXMm4eHhVK1alZUrV6Kjo8Nvv/2mvjCHhoZiaWlJeHg4fn5+GBsbk5qaWuguwGXLlpGZmUlISAgmJiZ4enoSGxvLgAED1GnmzZtHnTp1NIKQkJAQnJyciIyMxM3NLUe+QUFB6r8rVqzITz/9hI+PD4mJiSiVSnr16sWECRM4evQoPj4+pKens3TpUr777rt86+vt7V3gwPNnu+5GjhzJo0ePqFq1Krq6umRmZjJlyhS6dOlS0EujNmPGDJKSktTB4ePHj3n06BFt2rRRB3bVqlUrdH6lTQZLkiRJUoF8fX2ZN2+exr6Cxsa4urpiZmamfmxvb4+uri46Ojoa+7K7mnJjZWXFwoUL8ff3p2HDhowaNSpHmpo1a6r/VigUODg4qPM8ceIEV65c0agHZC3A+rJdVxcvXqRWrVqYmJio9zVo0EAjzYkTJ9izZ0+OABOyWtxyC5ZOnTrFpEmTOH36NAkJCeoB1TExMXh4eODo6Ejr1q0JCQnBx8eHzZs3k5KSQseOHfOtr7GxMZUrVy70+a1atYqlS5eyfPlyPD09OX36NMOHD6ds2bL07NmzwONXrFjBpEmT+PPPP9Xj2KytrQkMDMTf358WLVrQvHlzOnXqhKOjY6HrVZpksCRJklRa9E2yWnhKq+wXYGpq+kIXXAB9fX2NxwqFItd9+d1lBVmDh3V1dbl16xZJSUk5VpDPL0+VSkXdunVZtmxZjnxtbW0LfS7PEoXowlSpVLRt25bg4OAcz+UWICQlJeHn54efnx9Lly7F1taWmJgY/P39SUtLU6fr06cP3bt3Z+bMmYSGhtK5c2eNoC03+/btK/AOwzFjxjBmzBgAvvjiC0aNGsVHH30EQI0aNbh+/TrffvttgcHSqlWr6N27N2vWrKF58+Yaz4WGhjJ06FDCwsJYtWoV48aNY8eOHXm2Kr5KZLAkSZJUWhSKF+oK+y86ePAg06dPZ9OmTYwaNYohQ4awePHiQh9fp04dVq1ahZ2dXY4gK5uBgQGZmZmFztPDw4MlS5bw9OlTjI2NAXKMu6pTpw5r167F1dUVPb2CL7WXLl3i3r17TJs2DScnJ4BcB1QHBARgamrKvHnz2Lp1KxEREQXm/aLdcMnJyRqtfwC6uroFBrUrVqwgKCiIFStW0Lp161zTeHl54eXlxejRo2nQoAHLly9/LYIlOcBbkiRJKlBqaiq3b9/W2PK7s0sbnjx5Qvfu3RkyZAitWrVi+fLlrF69mjVr1hQ6j27dulGmTBnatWvHvn37iIqKYu/evQwbNozY2Fggq7vw7NmzXL58mXv37pGenp5vnl27dkVHR4fevXtz4cIFtmzZkuMutUGDBpGQkECXLl04evQo165dY/v27QQFBeUamDk7O2NgYMDs2bO5du0aGzduZPLkyTnS6erqEhgYyOjRo6lcuXKO7r/cZHfD5bc9Gyy1bduWKVOm8NdffxEdHc369ev54Ycf+OCDD9RpRo8eTY8ePdSPV6xYQY8ePZgxYwZvvfWW+jPy6NEjAKKiohg9ejSHDh3i+vXrbN++ncjIyNdm3JIMliRJkqQChYWF4ejoqLG9/fbbxVrmsGHDMDU1VQ+S9vT0JDg4mP79+3Pz5s1C5WFiYkJERATOzs60b9+eatWqERQUxNOnT9UtTZ988gnu7u54e3tja2vLgQMH8s1TqVSyadMmLly4gJeXF2PHjs3R3Va2bFkOHDhAZmYm/v7+VK9enWHDhmFhYZGj1QayugQXLVrEmjVr8PDwYNq0aTkCsGy9e/cmLS1NY0C4Ns2ePZsOHTowcOBAqlWrxogRI+jXr59G8BYXF0dMTIz68YIFC8jIyGDQoEEan5HseZlMTEy4dOkSH374IW5ubvTt25fBgwfTr1+/YjkHbVOIwnS+/oc9fvwYCwsLHj16lGcTriRJUmGkpKQQFRVFhQoVMDIyKu3qaI1CoWD9+vVvzCzYr7oDBw7QtGlTYmNjsbe3z/F8eHg4vr6+PHjwQCtL0LzK8vtOafP6LccsSZIkSUXWpUsXbGxs1F1bkvalpqZy48YNxo8fT6dOnXINlDw9Pbl27Vop1O7NJoMlSZIkqUiyZ9jW1dUt5Zpox9SpUzXmR3pW48aN2bp1awnXKMuKFSvo3bs3tWvXZsmSJbmm2bJli3rMlewN0R7ZDVcA2Q0nSZK2vKndcG+ahIQEEhIScn3O2NiYcuXKlXCNpLzIbrhSNmfOHObMmfNCt5NKkiRJrz9ra+siL0YrvVnk3XB5kGvDSZIkSZIEMliSJEmSJEnKlwyWJEmSJEmS8iGDJUmSJEmSpHzIYEmSJEmSJCkfMliSJEmSikShUKBQKLQyW7RCoWDDhg1FzqekRUdHo1AoClyw9llNmzZl+PDhWq2Hq6ur+v14+PChVvP+L5PBkiRJkpSvwMBA9QX42a1ly5bqNKGhoURGRha5rLi4OFq1alXkfF5EYGDgG7NUy7Fjx1i7dm2R8oiIiKBt27aULVs2z+A1t8/EW2+9lW++ixYtyvVzlJKSUqT6lgQ5z5IkSZJUoJYtWxIaGqqxz9DQUP23paUldnZ2RS7HwcGhyHn8l9na2hZ5jqikpCRq1apFr169+PDDD/NM9/xnwsDAoMC8zc3NuXz5ssa+12GCVtmyJEmSJBXI0NAQBwcHjc3KyirP9JMmTaJ27dqEhITg7OyMUqlkwIABZGZmMn36dBwcHLCzs2PKlCkaxz3bkvH777+jVCrVy6kADBkyBDc3N5KSkoCsbqepU6cSFBSEmZkZzs7O/PLLLxp53rx5k86dO2NlZYWNjQ3t2rUjOjpaXc/Fixfz559/qls6wsPDC3w9jh49ipeXF0ZGRnh7e3Pq1KkcaS5cuEBAQABKpRJ7e3u6d+/OvXv38sxz6dKleHt7Y2ZmhoODA127diU+Ph4AIQSVK1fm+++/1zjm3Llz6OjocPXq1QLrXFitWrXim2++oX379vmme/4zUZggTaFQ5PgcPeuPP/6gRo0aGBsbY2NjQ/PmzdXvdWmSwZIkSVIpEUKQnJ5cKltJrHR19epVtm7dSlhYGCtWrCAkJITWrVsTGxvL3r17CQ4OZty4cRw+fDjX43v06EFAQADdunUjIyODsLAwFixYwLJlyzA1NVWnmzFjhjpgGThwIAMGDODSpUsAJCcn4+vri1KpJCIigv3796NUKmnZsiVpaWmMGDGCTp060bJlS+Li4oiLi6Nhw4b5nldSUhJt2rTB3d2dEydOMGnSJEaMGKGRJi4ujiZNmlC7dm2OHz9OWFgYd+7coVOnTnnmm5aWxuTJkzlz5gwbNmwgKiqKwMBAICvICAoKytG6FxISQuPGjalUqVKe+e7btw+lUpnvltdaePkJDw/Hzs4ONzc3PvnkE3Vgl5/ExERcXFwoX748bdq00Qgy4+Li6NKlC0FBQVy8eJHw8HDat29fIp/VgshuOEmSpFLyNOMp9ZfXL5Wyj3Q9gom+SaHTb968GaVSqbFv5MiRjB8/Ps9jVCoVISEhmJmZ4eHhga+vL5cvX2bLli3o6Ojg7u5OcHAw4eHheY53WbBgATVr1mTo0KGsW7eOiRMnUq9ePY00AQEBDBw4UF2nmTNnEh4eTtWqVVm5ciU6Ojr89ttvKBQKIGt8laWlJeHh4fj5+WFsbExqamqhuwCXLVtGZmYmISEhmJiY4OnpSWxsLAMGDFCnmTdvHnXq1NEIQkJCQnByciIyMhI3N7cc+QYFBan/rlixIj/99BM+Pj4kJiaiVCrp1asXEyZM4OjRo/j4+JCens7SpUv57rvv8q2vt7d3gQPPX7TrrlWrVnTs2BEXFxeioqIYP3487777LidOnNDonn1W1apVWbRoETVq1ODx48f8+OOPNGrUiDNnzlClShXi4uLIyMigffv2uLi4AFCjRo0XqldxkcGSJEmSVCBfX1/mzZunsa+gC6yrqytmZmbqx/b29ujq6qKjo6OxL78WCSsrKxYuXIi/vz8NGzZk1KhROdLUrFlT/Xd2N092nidOnODKlSsa9YCsBVhftuvq4sWL1KpVCxOTf4PNBg0aaKQ5ceIEe/bsyRFgQlaLW27B0qlTp5g0aRKnT58mISEBlUoFQExMDB4eHjg6OtK6dWtCQkLw8fFh8+bNpKSk0LFjx3zra2xsTOXKlV/mVPPUuXNn9d/Vq1fH29sbFxcX/vrrrzy779566y2NoLhRo0bUqVOH2bNn89NPP1GrVi2aNWtGjRo18Pf3x8/Pjw4dOuTb3VtSZLAkSZJUSoz1jDnS9Uiplf0iTE1NX/iCq6+vr/FYoVDkui87KMhLREQEurq63Lp1i6SkpBwryOeXp0qlom7duixbtixHvra2toU+l2cVpltIpVLRtm1bgoODczzn6OiYY19SUhJ+fn74+fmxdOlSbG1tiYmJwd/fn7S0NHW6Pn360L17d2bOnEloaCidO3fWCNpys2/fvgLvMBwzZgxjxowp8Lzy4ujoiIuLi8b4soLo6OhQr1499TG6urrs2LGDgwcPsn37dmbPns3YsWM5cuQIFSpUeOm6aYMMliRJkkqJQqF4oa6w/6KDBw8yffp0Nm3axKhRoxgyZAiLFy8u9PF16tRh1apV2NnZ5QiyshkYGJCZmVnoPD08PFiyZAlPnz7F2Dgr6Hx+3FWdOnVYu3Ytrq6u6OkVfKm9dOkS9+7dY9q0aTg5OQFw/PjxHOkCAgIwNTVl3rx5bN26lYiIiALzLo5uuOfdv3+fGzdu5BoI5kUIwenTpzW62hQKBY0aNaJRo0ZMmDABFxcX1q9fz2effVak+hWVHOAtSZIkFSg1NZXbt29rbPnd2aUNT548oXv37gwZMoRWrVqxfPlyVq9ezZo1awqdR7du3ShTpgzt2rVj3759REVFsXfvXoYNG0ZsbCyQ1V149uxZLl++zL1790hPT883z65du6Kjo0Pv3r25cOECW7ZsyXGX2qBBg0hISKBLly4cPXqUa9eusX37doKCgnINzJydnTEwMGD27Nlcu3aNjRs3Mnny5BzpdHV1CQwMZPTo0VSuXDlH919usrvh8tueDZYSExM5ffq0OsCKiori9OnTxMTEqJ8fMWIEhw4dIjo6mvDwcNq2bUuZMmX44IMP1Pn06NGD0aNHqx9/9dVXbNu2jWvXrnH69Gl69+7N6dOn6d+/PwBHjhxh6tSpHD9+nJiYGNatW8fdu3epVq1agedY3GSwlIc5c+bg4eGRYyChJEnSf1FYWBiOjo4a29tvv12sZQ4bNgxTU1P1IGlPT0+Cg4Pp378/N2/eLFQeJiYmRERE4OzsTPv27alWrRpBQUE8ffpU3dL0ySef4O7ujre3N7a2thw4cCDfPJVKJZs2beLChQt4eXkxduzYHN1tZcuW5cCBA2RmZuLv70/16tUZNmwYFhYWGmO2stna2rJo0SLWrFmDh4cH06ZNyxGAZevduzdpaWkaA8K16fjx43h5eeHl5QXAZ599hpeXFxMmTACyAra///6bdu3a4ebmRs+ePXFzc+PQoUMaY8NiYmKIi4tTP3748CF9+/alWrVq+Pn5cfPmTSIiIvDx8QGy5mCKiIggICAANzc3xo0bx4wZM0p8ktLcKMSrcE/eK+zx48dYWFjw6NGjPJtwJUmSCiMlJYWoqCgqVKjwWkzEV1gKhYL169e/MbNgv+oOHDhA06ZNiY2Nxd7ePsfz4eHh+Pr68uDBA60sQfMqy+87pc3rtxyzJEmSJBVZly5dsLGxUXdtSdqXmprKjRs3GD9+PJ06dco1UPL09OTatWulULs3mwyWJEmSpCJ59m6mN8HUqVPznKSxcePGbN26tYRrlGXFihX07t2b2rVrs2TJklzTbNmyRT3mSvaGaI/shiuA7IaTJElb3tRuuDdNQkICCQkJuT5nbGxMuXLlSrhGUl5kN5wkSZIklQJra+si30ovvVnk3XCSJEmSJEn5kMGSJEmSJElSPmSwJEmSJEmSlA8ZLEmSJEmSJOVDBkuSJEmSJEn5kMGSJEmSVCQKhQKFQqGV2aIVCgUbNmwocj4lLTo6GoVCUeCCtc9q2rQpw4cP12o9XF1d1e/Hw4cPtZr3f5kMliRJkqR8BQYGqi/Az24tW7ZUpwkNDSUyMrLIZcXFxZX4WmCBgYFvzFItx44dY+3atUXK49tvv6VevXqYmZlhZ2fH+++/z+XLl9XPp6enM3LkSGrUqIGpqSlly5alR48e3Lp1q8C8Z82ahbu7O8bGxjg5OfHpp5+SkpJSpPqWBDnPkiRJklSgli1bEhoaqrHP0NBQ/belpSV2dnZFLsfBwaHIefyX2draFnmOqL179zJo0CDq1atHRkYGY8eOxc/PjwsXLmBqakpycjInT55k/Pjx1KpViwcPHjB8+HDee+89jh8/nme+y5YtY9SoUYSEhNCwYUMiIyMJDAwEYObMmUWqc3GTLUuSJElSgQwNDXFwcNDYrKys8kw/adIkateuTUhICM7OziiVSgYMGEBmZibTp0/HwcEBOzs7pkyZonHcs91wv//+O0qlUr2cCsCQIUNwc3MjKSkJyOp2mjp1KkFBQZiZmeHs7Mwvv/yikefNmzfp3LkzVlZW2NjY0K5dO6Kjo9X1XLx4MX/++ae6xSw8PLzA1+Po0aN4eXlhZGSEt7c3p06dypHmwoULBAQEoFQqsbe3p3v37ty7dy/PPJcuXYq3tzdmZmY4ODjQtWtX4uPjARBCULlyZb7//nuNY86dO4eOjg5Xr14tsM6FFRYWRmBgIJ6entSqVYvQ0FBiYmI4ceIEABYWFuzYsYNOnTrh7u7OW2+9xezZszlx4gQxMTF55nvo0CEaNWpE165dcXV1xc/Pjy5dumgEWH/88Qc1atTA2NgYGxsbmjdvrn6vS5MMliRJkkqJEAJVcnKpbCWx0tXVq1fZunUrYWFhrFixgpCQEFq3bk1sbCx79+4lODiYcePGcfjw4VyP79GjBwEBAXTr1o2MjAzCwsJYsGABy5Ytw9TUVJ1uxowZ6oBl4MCBDBgwgEuXLgGQnJyMr68vSqWSiIgI9u/fj1KppGXLlqSlpTFixAg6depEy5YtiYuLIy4ujoYNG+Z7XklJSbRp0wZ3d3dOnDjBpEmTGDFihEaauLg4mjRpQu3atTl+/DhhYWHcuXOHTp065ZlvWloakydP5syZM2zYsIGoqCh1y4tCoSAoKChH615ISAiNGzemUqVKeea7b98+lEplvltea+EBPHr0CCDfFqtHjx4VOG7t7bff5sSJExw9ehSAa9eusWXLFlq3bg1kvWZdunQhKCiIixcvEh4eTvv27Uvks1oQ2Q0nSZJUSsTTp1yuU7dUynY/eQKFiUmh02/evBmlUqmxb+TIkYwfPz7PY1QqFSEhIZiZmeHh4YGvry+XL19my5Yt6Ojo4O7uTnBwMOHh4bz11lu55rFgwQJq1qzJ0KFDWbduHRMnTqRevXoaaQICAhg4cKC6TjNnziQ8PJyqVauycuVKdHR0+O2331AoFEDW+CpLS0vCw8Px8/PD2NiY1NTUQncBLlu2jMzMTEJCQjAxMcHT05PY2FgGDBigTjNv3jzq1KmjEYSEhITg5OREZGQkbm5uOfINCgpS/12xYkV++uknfHx8SExMRKlU0qtXLyZMmMDRo0fx8fEhPT2dpUuX8t133+VbX29v7wIHnucVCAkh+Oyzz3j77bepXr16rmlSUlIYNWoUXbt2zXcNto8++oi7d+/y9ttvI4QgIyODAQMGMGrUKCArWMrIyKB9+/a4uLgAUKNGjXzrXVJksCRJkiQVyNfXl3nz5mnsK2hsjKurK2ZmZurH9vb26OrqoqOjo7Evu6spN1ZWVixcuBB/f38aNmyovrA+q2bNmuq/FQoFDg4O6jxPnDjBlStXNOoBWRf4l+26unjxIrVq1cLkmWCzQYMGGmlOnDjBnj17cgSYkNXilluwdOrUKSZNmsTp06dJSEhApVIBEBMTg4eHB46OjrRu3ZqQkBB8fHzYvHkzKSkpdOzYMd/6GhsbU7ly5Zc5VQYPHszZs2fZv39/rs+np6fz0UcfoVKpmDt3br55hYeHM2XKFObOnUv9+vW5cuUKw4YNw9HRUT3+qVmzZtSoUQN/f3/8/Pzo0KFDvt29JUUGS5IkSaVEYWyM+8kTpVb2izA1NX3hC66+vr5mmQpFrvuyg4K8REREoKury61bt0hKSsrRepFfniqVirp167Js2bIc+dra2hb6XJ5VmG4hlUpF27ZtCQ4OzvGco6Njjn1JSUn4+fnh5+fH0qVLsbW1JSYmBn9/f9LS0tTp+vTpQ/fu3Zk5cyahoaF07txZI2jLzb59+wq8w3DMmDGMGTNGY9+QIUPYuHEjERERlC9fPscx6enpdOrUiaioKHbv3p1vqxLA+PHj6d69O3369AGyWo2SkpLo27cvY8eORVdXlx07dnDw4EG2b9/O7NmzGTt2LEeOHKFChQr55l3cZLD0BhNCEB/9hMijt0lPzcTLzxkrB9OCD5QkqUQoFIoX6gr7Lzp48CDTp09n06ZNjBo1iiFDhrB48eJCH1+nTh1WrVqFnZ1dnhdzAwMDMjMzC52nh4cHS5Ys4enTpxj/P+h8ftxVnTp1WLt2La6urujpFXypvXTpEvfu3WPatGk4OTkB5HpnWUBAAKampsybN4+tW7cSERFRYN4v2g0nhGDIkCGsX7+e8PDwXAOV7EDpn3/+Yc+ePdjY2BRYj+TkZI1WRQBdXV2EEOoAVKFQ0KhRIxo1asSECRNwcXFh/fr1fPbZZwXmX5xksPQGehifTOTRO0Qevc2j+Kfq/ZeP3qZe6wp4+TmjqyvH9kuSVHipqancvn1bY5+enh5lypQptjKfPHlC9+7dGTJkCK1atcLZ2Rlvb2/atGlTYNdTtm7duvHdd9/Rrl07vv76a8qXL09MTAzr1q3jiy++oHz58ri6urJt2zYuX76MjY0NFhYWOVqrntW1a1fGjh1L7969GTduHNHR0TnuUhs0aBC//vorXbp04YsvvqBMmTJcuXKFlStX8uuvv6Krq6uR3tnZGQMDA2bPnk3//v05d+4ckydPzlG2rq4ugYGBjB49msqVK+fo/svNi3bDDRo0iOXLl/Pnn39iZmamft8tLCwwNjYmIyODDh06cPLkSTZv3kxmZqY6jbW1NQYGBkDWAP1y5crx7bffAtC2bVt++OEHvLy81N1w48eP57333kNXV5cjR46wa9cu/Pz8sLOz48iRI9y9e5dq1aoVuu7FRV4x8zBnzhw8PDxyDCR8VT1NTOPv8Fj+CD7OsgmHObY5ikfxT9HT16FKPXucPa1RZQiO/HmNNd8e527Mk9KusiRJr5GwsDAcHR01trfffrtYyxw2bBimpqbqQdKenp4EBwfTv39/bt68Wag8TExMiIiIwNnZmfbt21OtWjWCgoJ4+vSpuqXpk08+wd3dHW9vb2xtbTlw4EC+eSqVSjZt2sSFCxfw8vJi7NixObrbypYty4EDB8jMzMTf35/q1aszbNgwLCwscrSuQFaX4KJFi1izZg0eHh5MmzYtRwCWrXfv3qSlpWkMCNemefPm8ejRI5o2barxfq9atQqA2NhYNm7cSGxsLLVr19ZIc/DgQXU+MTExxMXFqR+PGzeOzz//nHHjxuHh4UHv3r3x9/dnwYIFAJibmxMREUFAQABubm6MGzeOGTNmlPgkpblRiFfhnrxX2OPHj7GwsODRo0cF9seWtIy0TKLO3iPy6B1izt1HpcpuxoTy1axx97GnQm1bDIz0EEIQefQO+1ZHkpqUgUJHgVcLJ+q1roCegW4BJUmSpA0pKSlERUVRoUIFjIyMSrs6WqNQKFi/fv0bMwv2q+7AgQM0bdqU2NhY7O3tczwfHh6Or68vDx480MoSNK+y/L5T2rx+y26414xKJbgV+YDLR+9w9WQ86Sn/9rPbOpvh5mNPlXr2mFoYahynUChwr++AUzVr9q2O5MrxeE5ui+Hqqbu8270qZauU/t0GkiS9vrp06YKNjQ2xsbGlXZU3VmpqKjdu3GD8+PF06tQp10DJ09OTa9eulULt3mwyWHpN3ItNJPLIbSKP3SHpYap6v5m1EW4+9rj5OGBdtuDB2ybmBvj3qU4V77tErLjMo/inrJ9xiurvlKPBB5UwMJYfCUmSXkz2DNvPj8N5XU2dOjXPSRobN27M1q1bS7hGWVasWEHv3r2pXbs2S5YsyTXNli1bSE9PB3jlekNeZ7IbrgCl2Q33JCGFf45lDdS+f/Pf6d4NTfSoVNcOdx8HHCtZoNBRvFT+qcnpHFx3lQv7sxY/VFoZ0qSrO641im/ApiT9l72p3XBvmoSEBBISEnJ9ztjYmHLlypVwjaS8yG64/6jUpxlcPRlP5NHb3Ix8CP8PZXX0FLjWKIO7jwMu1W3Q1S/62HxDE318P65KFW879iy9xON7Kfw15yxuPva83akKxkqDIpchSZL0urG2ti7yYrTSm0UGS6+AzAwVMefvc/nIHaLP3iMz498J2spWscTNx55KdewwMs37VtaiKF/Vmo8m1Ofoxmuc2XUja8D4hQTe6exGZW879RIBkiRJkvRfJIOlUiKE4Pa1x0Qeuc0/J+6QmpShfs7KwQT3txyoUs8ec5sXm2X3Zekb6NKoQxUq17Vn95KLJNxKYvvC80Qeu0OTLu4orQwLzkSSJEmS3kAyWCphD24nqSeMfHwvRb3fxNyAKj72uPs4UMZJWWqtOfYVzOk0ph4nt13n+JZoos/e41bkAxp+WBmPRmVfenyUJEmSJL2uZLBUApIfp/HP8TtEHrlN/PV/J4PUM9Slkpct7j4OlKtqhc4rEojo6ulQr3UFKnrZsmfJJe5EPSZ82WX+OXaHph9XxdJOLs8gSZIk/XfIYKmYpKdmEnXmLpeP3OHGxQRE9oSROgqcPaxxq29PhZq26Bu+urfa2pRV0v6Luvy9J5bDf17lZuRDVk4+Sv22FanVrDw6cskUSZIk6T9ABktapMpUEXv5AZFH7nD19F0yUv+dMNLO1Rz3+vZUrmuPifnrc5eZjo6CWs2ccK1ZhvBll4i99ICD665w5cQd3u1RDZtyytKuoiRJpSx72ICFhQUPHz4scl6v42zg0dHRVKhQgVOnTlG7du1CHdO0aVNq167NrFmztFYPV1dXrl+/DvCfmMG7pMimgSISQnA35gn71/zD4tEH2fTTGS4fuU1GaibmZYzwbu1Kt6/eouMob2r6OpVYoCQyMkiJjOThhg3cnjKVO9O/I+PBg5fOz8LWmPeG1ca3e1UMjPWIv/6E1VOOcWTjNTLTVQVnIEnSayswMBCFQpFja9mypTpNaGgokZGRRS4rLi6uxNcCCwwMfO2Cs7wcO3aMtWvXFimPefPmUbNmTczNzTE3N6dBgwY5JuIUQjBp0iTKli2LsbExTZs25fz58wXmvXbtWjw8PDA0NMTDw4P169cXqa4lRbYsvaTH954SeSxrHNKD28nq/Uam+lT2tsO9vgP2FcxLZKC2yMgg9epVUs5fIOX8+azt0iVESopGuidhYZSf8zNGL7mCs0KhwKNRWVw8bdi74jJRZ+5xfEu0eskUh4oW2jgdSZJeQS1btiQ0NFRjn6Hhv3fJWlpaYmdnV+RyHBwcipzHf5mtrW2R54gqX74806ZNo3LlygAsXryYdu3acerUKTw9PQGYPn06P/zwA4sWLcLNzY1vvvmGFi1acPnyZczMzHLN99ChQ3Tu3JnJkyfzwQcfsH79ejp16sT+/fupX79+kepc3GTL0gtISUrn/L6brPv+BEvGHeLIn9d4cDsZXT0dKte1I2BgTQKDG9GkizsOFS2KJVAS6emkXLzIw7Vruf3110R17szlut5EtXufuDFjeLBsGU9Pn0akpKBjYoKxd12senRH39mZ9Fu3iO7SlUebNhepDqaWhrTqXwP/T6pjbKbPg7gk1n53gv2r/yH9ma5HSZLeHIaGhjg4OGhsVlZ5ryk5adIkateuTUhICM7OziiVSgYMGEBmZibTp0/HwcEBOzs7pkyZonGcQqFgw4YNAPz+++8olUr1cioAQ4YMwc3NjaSkrFUNXF1dmTp1KkFBQZiZmeHs7Mwvv/yikefNmzfp3LkzVlZW2NjY0K5dO6Kjo9X1XLx4MX/++ae6xSw8PLzA1+Po0aN4eXlhZGSEt7c3p06dypHmwoULBAQEoFQqsbe3p3v37ty7dy/PPJcuXYq3tzdmZmY4ODjQtWtX4uPjgayWnMqVK/P9999rHHPu3Dl0dHS4evVqgXUurLZt2xIQEICbmxtubm5MmTIFpVLJ4cOH1XWZNWsWY8eOpX379lSvXp3FixeTnJzM8uXL88x31qxZtGjRgtGjR1O1alVGjx5Ns2bNNLoh//jjD2rUqIGxsTE2NjY0b95c/V6XJtmyVEg7Fp4n/moKqoz/T6mtgHJuVrjXt6eilx2GxbCmmkhLI+Wff0i5kN1idIHUy5cRaWk50uqYmmLk4YGRp+f/Nw8MXF1R6GTFw5mDBnHziy9IitjHrS++IOX8eexGfI5C7+XqrVAoqFzXjvLuVuz/4x8uH77Nmd03uHbmLr4fV8Wpmpz9VpIKIoQgI610urH1DHSKveX76tWrbN26lbCwMK5evUqHDh2IiorCzc2NvXv3cvDgQYKCgmjWrBlvvfVWjuN79OjB5s2b6datGwcPHmTnzp0sWLCAAwcOYGr671qYM2bMYPLkyYwZM4Y//viDAQMG8M4771C1alWSk5Px9fWlcePGREREoKenxzfffEPLli05e/YsI0aM4OLFizx+/FjdclZQy0xSUhJt2rTh3XffZenSpURFRTFs2DCNNHFxcTRp0oRPPvmEH374gadPnzJy5Eg6derE7t27c803LS2NyZMn4+7uTnx8PJ9++imBgYFs2bIFhUJBUFAQoaGhjBgxQn1MSEgIjRs3plKlSnnWd9++fQV2bY4ZM4YxY8bk2J+ZmcmaNWtISkqiQYMGAERFRXH79m38/PzU6QwNDWnSpAkHDx6kX79+uZZx6NAhPv30U419/v7+6mApLi6OLl26MH36dD744AOePHnCvn37eBVWZZPBUiFF/X0PYwNTbMopcatvj1s9e5RW2lvbSZWWRurlyGcCo/OkRkYi/r8g4rN0zMz+DYw8PLICIxcXdWCUG10LC5zmzePuT7O5v2ABCYsWkXLpEuVm/oBePv87LIiRUp/mgR5UqWdP+LJLPLmfwsYfT1OtoSMNP6xcbLOOS9KbICNNxS/D9pZK2X1/bPJCd+Nu3rwZpVLzho6RI0cyfvz4PI9RqVSEhIRgZmaGh4cHvr6+XL58mS1btqCjo4O7uzvBwcGEh4fnGiwBLFiwgJo1azJ06FDWrVvHxIkTqVevnkaagIAABg4cqK7TzJkzCQ8Pp2rVqqxcuRIdHR1+++03dXAYGhqKpaUl4eHh+Pn5YWxsTGpqaqG7AJctW0ZmZiYhISGYmJjg6elJbGwsAwYMUKeZN28ederU0ViQNyQkBCcnJyIjI3Fzc8uRb1BQkPrvihUr8tNPP+Hj40NiYiJKpZJevXoxYcIEjh49io+PD+np6SxdupTvvvsu3/p6e3tz+vTpfNM8HyD+/fffNGjQgJSUFJRKJevXr8fDwwOA27dvA2Bvb69xjL29vXpweW5u376d6zHZ+cXFxZGRkUH79u1xcXEBoEaNGvnWu6TIYKmQar1bHq+mVShTvuh3f6lSU0mNjFQHRU/Pnyf1nyuQW2Bkbo6RpwfG6sDIE30np3wDo7wodHWx+3Q4Rh4e3Bo9muTDh4n+sAPlf56N0f+/BC/LxdOGLhPqc3jDNf7eG8vFg3FcP3efJl3cqehlW6S8JUkqfb6+vsybN09jX0EtMK6urhrjV+zt7dHV1UXnmd8ve3t7dVdTbqysrFi4cCH+/v40bNiQUaNG5UhTs2ZN9d8KhQIHBwd1nidOnODKlSs5xtGkpKS8dNfVxYsXqVWrFiYm/845l93qku3EiRPs2bMnR4AJWS1uuQVLp06dYtKkSZw+fZqEhARUqqxWx5iYGDw8PHB0dKR169aEhITg4+PD5s2bSUlJoWPHjvnW19jYWD3+qLDc3d05ffo0Dx8+ZO3atfTs2ZO9e/eqAyYgR8ukEKLA1sr8jqlVqxbNmjWjRo0a+Pv74+fnR4cOHfLt7i0pMlgqpPrvVcLc/MUDJVVKCqmXL/M0e+D1+QukXrkCGRk50upaWKi70LK70/TLl9d6U7m5vx+GFStwY/Bg0q/HEN2lK47fTMaibdsi5WtgpMc7H7lRxduO3Usu8fBOMlsX/E2lOrY07uyGqYVcMkWSnqVnoEPfH5uUWtkvwtTU9IUvuPr6mi3LCoUi133ZQUFeIiIi0NXV5datWyQlJeVYQT6/PFUqFXXr1mXZsmU58rW1fbn/yBWmW0ilUtG2bVuCg4NzPOfo6JhjX1JSEn5+fvj5+bF06VJsbW2JiYnB39+ftGeGXvTp04fu3bszc+ZMQkND6dy5s0bQlpuX6YYzMDBQv9/e3t4cO3aMH3/8kQULFqhb4G7fvq1xLvHx8Tlajp7l4OCgbkXK7RhdXV127NjBwYMH2b59O7Nnz2bs2LEcOXKEChUq5Fv/4iaDJS1SPX1KyqVLGnelpV69Cpk5Bz3rWlk90432/8CoXNkSW+bEsEoVKqxZkzWOaW8Et774kpRz57H7YsRLj2PK5ljZks7j6nH8r2hObo/h6sm7xF56wNsdq+D+loNcmFeS/k+hULzSE9O+Cg4ePMj06dPZtGkTo0aNYsiQISxevLjQx9epU4dVq1ZhZ2eXI8jKZmBgQGYuv9N58fDwYMmSJTx9+hRj46z1O7MHPz9b7tq1a3F1dUWvEL+ply5d4t69e0ybNg0nJycAjh8/niNdQEAApqamzJs3j61btxIREVFg3i/TDfc8IQSpqakAVKhQAQcHB3bs2IGXlxeQNd5q7969uQaH2Ro0aMCOHTs0xi1t376dhg0bqh8rFAoaNWpEo0aNmDBhAi4uLqxfv57PPvusoNMsVjJYekmq5OSswOjc/1uMLpwn9eo1yOV/SLo2NlmtRf8PjIw9PdFzdCz1oEHX3BynuXO5O3s29+cvIGHx4n/HMRXx1lM9fV3eer8Slerasfv3i9y7kciuxReJPHaHpl3dMS9TMgsES5KkHampqTlaBfT09ChTpkyxlfnkyRO6d+/OkCFDaNWqFc7Oznh7e9OmTZsCu56ydevWje+++4527drx9ddfU758eWJiYli3bh1ffPEF5cuXx9XVlW3btnH58mVsbGywsLDI0Vr1rK5duzJ27Fh69+7NuHHjiI6OznGX2qBBg/j111/p0qULX3zxBWXKlOHKlSusXLmSX3/9FV1dzSDZ2dkZAwMDZs+eTf/+/Tl37hyTJ0/OUbauri6BgYGMHj2aypUr5+j+y82LdsONGTOGVq1a4eTkxJMnT1i5ciXh4eGEhYUBWQHN8OHDmTp1KlWqVKFKlSpMnToVExMTunbtqs6nR48elCtXjm+//RaAYcOG8c477xAcHEy7du34888/2blzJ/v37wfgyJEj7Nq1Cz8/P+zs7Dhy5Ah3796l2ktOd6NNMlgqpOSTJ8m4fv3/3WkXSLt2DXJpitUtU+bfMUb/3/Ts7Us9MMqLQlcXu+H/H8c0ajTJR44Q1aED5WfPxvj/82kUha2TGR1HeXN65w2OborixoUEVkw+SoP3K1KjSXm5MK8kvSbCwsJydB+5u7tz6dKlYitz2LBhmJqaqgdJe3p6EhwcTP/+/WnYsCHlypUrMA8TExMiIiIYOXIk7du358mTJ5QrV45mzZqpW5o++eQTwsPD8fb2JjExkT179tC0adM881QqlWzatIn+/fvj5eWFh4cHwcHBfPjhh+o0ZcuW5cCBA4wcORJ/f39SU1NxcXGhZcuWGmO2stna2rJo0SLGjBnDTz/9RJ06dfj+++957733cqTt3bu3erqE4nDnzh26d+9OXFwcFhYW1KxZk7CwMFq0aKFO8+WXX/L06VMGDhzIgwcPqF+/Ptu3b9cYGxYTE6Nxrg0bNmTlypWMGzeO8ePHU6lSJVatWqWeY8nc3JyIiAhmzZrF48ePcXFxYcaMGSU+SWluFOJVuCfvFfb48WMsLCw4WrkKyuf+J6Bna/vMrfr/70qzL/qkbKUl9Z9/iB08hLTr11EYGuI4+WsscvmivqyHd5LZveQicVceAeBQ0QLf7lWxdjQt4EhJejOkpKQQFRVFhQoVMDLS3t20pe11XaLkdXXgwAGaNm1KbGxsrmOEwsPD8fX1/U8sd5Lfdyr7+v3o0aM8u2ALSwZLBch+sU82bESZWrX+HXzt4YG+FmarfdVkPn6sHscEYN2zB3ZffFHkcUzZhEpwft9NDq67SnpqJjp6CuoFVMDL3xlduTCv9IZ7k4MlIyMjbGxsiI2NLe3qvLFSU1O5ceMGffv2xdHRMddB656enly7do2UlBQZLMlgqeRo88V+XQiVKmsc07z5AJj4+FBu1swij2N61pOEFMKXXSbm/H0AbMopebdHVexc/huvsfTf9KYGS1euXAGyxtOU9l1L2jB16lSN+ZGe1bhx4xzrpJWURYsW0bt3b2rXrs3GjRtz7Ya8fv066f+fhqZixYq5dvm9SWSw9Ir4LwZL2R7v2EHcyFGokpPRK+uotXFM2YQQRB69w/7V/5CSlI5CR0Ht5k74tKmAnoG8Q0h687ypwdKbJiEhgYSEhFyfMzY2LtRYKalklFSwJAd4F9J/MaY0b9ECwwoViB00mLTr17netRuOX3+FRbt2WslfoVDgXt8Bp2rW7F8dyT/H4zm1PYZrp7OWTCnnVvoTkUmS9N9jbW1d5MVopTeLbFkqQHZkWm1eNQxNDNHT0UNXRzfrX0XWv3oKPfV+XYUu+jr66uey06rTKHRz7tPRVf/9bL7P7leX9TJpFLrYm9hjaWT5Uq9B5uPH3PriSxL3Zi3LYNWjO/ZffIEin1trX0bUmbvsXX6ZpEdZE7B5vlOOhh9UwqAY1t2TpNIgW5YkSbtky9IrKENkkJGZAYWfu+yVoa+jz9TGU2np2vKFj9U1N6f8vLnc+/ln7s2dx4Pfl5B66XLWfEw2NlqrY4VatpR1s+Lguitc2HeL8xE3uf73PZp0dce1RvHN5SJJJU3+H1WStKOkvkuyZakA2ZFp1O0ojJXGZIpMMlQZWYGTKoNMVdbjZ/dn79NII/7999nj1I//f3ymKpN0VTqZIlMjfY40Ip1MVWaux2nUR5VBamYqD1MfoqvQZerbUwmoGPDyr8ez45gc/z+Oqbr2xjFli738gD1LL/H47lMAqtSzp3GnKhibGWi9LEkqKenp6Vy5coWyZctiYWFR2tWRpNfe/fv3iY+Px83NLcdEn3KAdwl6EwZ4Z6oymXRoEhuubEBHocM3jb6hbaWXXwcu9erVrHFM0dEoDAxw+PorLIthfpX0tEyOborizM4YhAAjpT7vdHajsrfdKzvJpyTlRwhBTEwM6enplC1b9o2/U0mSiosQguTkZOLj47G0tMx1vT0ZLL2gDz74gPDwcJo1a8Yff/zxQse+CcESgEqo+PrQ16z9Zy0KFHzV8Cs+qPLBS+eX+eRJ1jim8HAArLp3x/5L7Y9jArgT/Zg9Sy5y/2YSAJW8bHmnizsm5rKVSXr9pKWlERUVVeDisZIkFczS0hIHh9zXHJXB0gvas2cPiYmJLF68+OWDpfmtMPfpCtXagtHr2XyuEiqmHpnKqsurAJjYYCId3Dq8dH5CpeLez3O4N3cuACb16mXNx6TFcUzZMjNUnNgazYmt11GpBEZKfZp0cady3TdvYlDpzadSqTRWkpck6cXp6+vn6Hp7lgyWXkJ4eDg///zzywdLo8wwN1SAriG4+UONjlDFD/RfrztahBAEHwtm2cWsmV/H1R9H56qdi5Tnk507uTVyFKqkpKxxTD/9hHGN6tqobg53Y56wa/EFdStTZW873vnIDWOlbGWSJEmS/qXNYKnUO8wjIiJo27YtZcuWRaFQsGHDhhxp5s6dq74tsG7duuzbt6/kK/rOF1DGHTJT4eJGWN0dvneDPwfBtXBQvR63yCkUCkbWG0kPjx4AfHPkG3Xg9LLMmjfHdfUqDFxdyYiL43q3bjzM5X3UBltnMzqOrod3gCsKHQVXjsez4qsjXDt1t1jKkyRJkqRSD5aSkpKoVasWP//8c67Pr1q1iuHDhzN27FhOnTpF48aNadWqFTExMeo0devWpXr16jm2W7duaa2eJ8t3h0FHoN8+aDgUzMtB6iM4tRR+bwc/eEDYGLh5El7xxjqFQsEI7xH0qt4LgGlHp7H4/OIi5WlYqRKua1ajbNoUkZZG3KjR3P5mCuL/0+5rk66eDvXfq0iHkXWxLmvK0yfpbF3wN9sXniclUfvlSZIkSf9tr1Q3XG4rV9evX586deowb9489b5q1arx/vvv8+233xY678J2w6WmppKamqp+/PjxY5ycnPAYtZY/hjanmuP/m/JUKog5CH+vgfMbIOXhv5lYV8rqpqvREcpULnQdS5oQgtmnZvPr378C8GndTwmqHlS0PFUq7s2Zy705cwAw8fam3I+zimUcE0Bmuoqjf0Vxatt1hAATcwOadnOnQi3bYilPkiRJej28Ud1w+UlLS+PEiRP4+flp7Pfz8+PgwYPFUua3336LhYWFenNycgLgSUomPUKOEnM/OSuhjg64vg1tf4QR/8BHK8CzPegZQ8JV2DsNfq4LvzSFQ3Pgye1iqW9RKBQKhngNYWCtgQDMPDGTX87+UrQ8dXSwHTKY8nN+RsfUlOTjx4n6sANP/z6njSrnoKuvQ4P3K/Hhl95YOZiQ/DiNLfP+ZmfoBVKSZCuTJEmSVHSvdLB07949MjMzsbe319hvb2/P7duFDz78/f3p2LEjW7ZsoXz58hw7dizPtKNHj+bRo0fq7caNGwC42Su5+ySVjxceIf5JiuZBegZQNQA6hsIX/8AHv0Dl5qDQhVunYNsY+KEaLH4PTi6BlEeFfxGKmUKhYEDtAQyuPRiA2admM+/0vAKOKphZs2a4rlmNQYUKZNy+nTWOad36IuebF/sK5nQaWw8vP2cUCrh85DYrvz5C9N/3iq1MSZIk6b/hlQ6Wsj0/f4IQ4oUmJdy2bRt3794lOTmZ2NhY6tWrl2daQ0NDzM3NNTaABR/XxdnahJiEZHosPMqjp3m0WhiaQa3O8PFa+PwyBHwP5X1AqCBqL2wcDN9VgVUfw4U/IT0l93xKWL9a/RheZzgAc8/MZfap2UWeRt6wYkVcV69C+e67WeOYxozh9uRvimUcE4Cevi4N21em/Rd1sbQ3IelRGn/NOcuu3y+SmixbmSRJkqSX80oHS2XKlEFXVzdHK1J8fHyO1qbiZmtuxNLe9bE1M+TS7Sf0XnSMp2kF3AGntAWfT6DPDhh6Gt4dD7ZV/39H3SZY3QO+rwIbBsHVPaV+R13vGr0Z4T0CgF/O/sKPJ38scsCka2ZG+Z9nU2ZwVsvVg2XLuN6rFxn3iq/Fx6GiBZ3H1qNWcydQwKWDcaycfJSY8/eLrUxJkiTpzfVKB0sGBgbUrVuXHTt2aOzfsWMHDRs2LPH6ONuY8HuQD2ZGehy//oCBy06QnlnIWXitK8A7I2DgYei/HxoNA/PykPoYTi+FJe9nddWFjYabJ0rtjrqenj0ZWW8kAAvPLWTG8RlFDpgUOjrYDh5E+blz0DE15enxE0R16MjTv//WRpVzpWegy9sdqvDB53WwsDUm8UEqm2afYc+Si6Q9zSi2ciVJkqQ3T6nfDZeYmMiVK1cA8PLy4ocffsDX1xdra2ucnZ1ZtWoV3bt3Z/78+TRo0IBffvmFX3/9lfPnz+Pi4lLs9cttNP2x6AS6LzxCSrqK92uX5YdOtdHReYm1ylQqiDmUdUfdhQ3w9MG/z5XyHXUrLq1g6pGpAHxc7WO+rPelVtZjS712LWtduaiorHXlJk3Csv3LL7tSGOlpmRzecJWzu2MBUFoZ8m6PajhVsy7WciVJkqTS80bN4B0eHo6vr2+O/T179mTRokVA1qSU06dPJy4ujurVqzNz5kzeeeedYq3XnDlzmDNnDpmZmURGRuZ4sfdciueT34+ToRIENnRlYluPogUTGWlwdVdW4HRpC2Q8/fc5x9pQs1PW3XbmORcLLC5rItfw9aGvAejs3pkx9cegoyh6Y2RmYiK3vhxJ4u7dAFh17Yr96FHFsq7cs25GPmD37xd5fC9rnJjnO+Vo2L4SBkZ6xVquJEmSVPLeqGDpVZffi73h1E2GrzoNwGct3BjarIp2Ck1NhMtb4OxquLobRPZYJgVUaJzV2lTtPTC21E55+Vj/z3omHpyIQNDBrQPj3xqvlYBJqFTcmzePe7OzJiM19q5L+Vmz0CtTpsh55yctJYPD66/y996bAJjZGPFuj2qUd7cq1nIlSZKkkiWDpRJU0Iu96EAUkzZdAGByO0+6N3DVbgWS7sH59VktTjeO/Ltf1yBrbboaHbPWqtM31m65z9h4dSPj9o9DIPig8gdMajhJKwETwJPde7j15ZeoEhPRs7en/OyfMK5ZUyt55yf2clYr05P7Wa1MNZqU460PZCuTJEnSm0IGSyWoMC/2zB2R/LjrHxQKmNW5Nu1qlyueyjyIhnNr4ewauHvx3/2G5lCtLdToABWagE7eqzC/rL+u/cWY/WNQCRXvVXqPrxt+ja6Wykm9FkXs4MGkXbuGQl8fh0kTsfzwQ63knZ+0lAwOrrvK+YisVibzMkY061mNslVkK5MkSdLrTgZLJagwL7YQgokbz/P7oevo6Sj4rac3Td3tiq9SQsCd81mtTX//AY9j/33O1A6qf5jV4lSuDmhhUHa2sKgwRu0bRabIJKBCAFPenoKejnZaYjITE7k1chSJu3YBYNW1C/ajRqEwMNBK/vm5cSGB3Usukvgga5mbmu+W5633K6FvoP2gU5IkSSoZMlgqQYV9sVUqwfBVp9l45hZG+jos61Ofui4lcLeVSgU3Dv9/jbr1z91RV/GZO+q0M55qx/UdfLn3SzJEBi1dWzK18VT0dbQzMDvHOKa6dSk/ayZ6tsW/zlva0wwO/PEPFw7EAWBha0yzntVwrGxZ7GVLkiRJ2ieDpRJQ0N1wuUnLUPHJ78fZG3kXcyM9VvdvQFWHor1BLyQjDa7tyRoYfnkLpCf/+5xTfei4WCt30+2O2c3nez8nQ5VBC5cWBDcORl9Xe3eyPdmzh1tfPDOO6acfMa5VS2v55+f6+fvsWXKJpIepoIBazZx4672K6MlWJkmSpNeKDJZK0Iu+2MlpGXz82xFOxjzEzsyQtQMa4mRtUgI1fU5qIlzeCn+vhiu7su6os68BvbaAUdEDuL039vJp+Kekq9LxdfJlRpMZWg2YSmscE0Bqcjr7/7jCpYNZrUyW9iY061kNh4oWJVK+JEmSVHQyWCpBL/NiP0xOo/OCw1y+8wQXGxPW9G+AnZlRMdc0H/evQog/JN2Fir7QbQ1oIbDZf3M/w3YPI02VRpPyTfih6Q8Y6GpvjFFmYiK3Ro0icWfWOCbLLh/hMHp0iYxjAoj++x57ll4i+VEaCgXUbuGMT9sK6OnLViZJkqRXnTaDpVd6uZPXlaWJAb/39sHJ2pjr95PpGXIs74V3S4JNJei6GvRNsrrpNg7VynIqb5d7m9nNZmOoa8je2L0M3TOU1MxULVQ4i65SSfmffqLM0CGgUPBwxUquB/Yi4+5drZWRH9caZegyoT7u9R0QAk5tj2H1lGPciXpcIuVLkiRJrwYZLBUTe3MjlgTVp4zSkItxj+mzuBAL7xancnWyxiwpdOHMctgzVSvZNizbkDnN5mCsZ8yBmwcYsmsIT5+dfbyIFDo62A4cmLWunFLJ05Mns9aVO3tWa2Xkx8hUn+a9PAgYUANjcwMe3E5m7fTjHNpwlcz0Qq4LKEmSJL3WZLBUjFzLmKoX3j0W/YDBy08WfuHd4uDmB21+yPo7YjqcWKSVbOs71lcHTIfiDjFk1xCSnx1crgVmvr64rl6NQcWKZNy5w/WPu/Nw3XqtlpGfCrVs6TqhPlXq2SMEnAy7zupvjxF/XbYySZIkvelksFTMPMqas7BnPQz1dNh1KZ4v/ziLSlWKw8TqBsI7X2b9vfkziNymlWzrOdRjfvP5mOiZcOT2EQbuGqj1gMmwYgVcV69C+e67iLQ04saM4faUqYj0kuniNFLq49fbk5b9qmNspk/CrST+CD7BkY3XyMyQrUySJElvKhks5WHOnDl4eHhQr169IuflU8Gaud3qoKujYP2pm0z+6wKlOq7edwzU6pp1h9yaQLh5UivZ1rGvwy9+v6DUV3Lizgn67+xPYlqiVvLOpqtUUv7n2ZQZNAiAB0uWEBPUm4yEBK2Wk59KXnZ0mVCfynXtECrB8S3RrPn2OHdvPCmxOkiSJEklR94NVwBtjqZffyqWT1edAWCEnxuD39XSwrsvIzMdlnXMGvBtagu9d4B1Ba1kfe7eOfru6MuTtCfUtK3J/ObzMTMw00rez3qycye3vhyJKjkZvbKOlJ89G2NPT62Xk58rJ+LZu+IyKYnp6OgoqBvgSt1WLujqyv+HSJIklSZ5N9xr6gOv8kxs6wHA99sjWXL4eulVRlcfOv0ODjWyphRY+iEk3ddK1tXLVOc3v98wNzDn7N2z9N3el0epj7SS97PMmjfHdfUqDFxcyLgVx/Wu3Xi0aZPWy8lP5bpZrUwVvWxRqQTHNkfxx7Tj3IvVbouaJEmSVHpksFTCejWqwNB3KwMw4c9zbDpzq/QqY2QOXdeAhRMkXIUVH0G6du5k87DxYKH/QiwNLTl3/xyfbP+kWAImw8qVcV2zGtN3GiNSU7n1xZfcCZ6OyMjQell5MTE3oGXf6vj19sTQVI97NxJZ8+0xjm+JRlWaA/olSZIkrZDBUin4tIUbH7/ljBDw2erT7I0smXmDcmXuCN3+ACMLiD0Ka/uASjtTHFS1rspC/4VYG1lzMeEivbf15kHKg4IPfEG65uY4zZuHTb9+ACSEhnKjb18yHmi/rLwoFAqq1LOny4T6VKhVBlWm4MjGa/wRfIL7t2QrkyRJ0utMjlkqgDb7PJ+VqRIMW3mKzWfjMNbXZdkn9anjbKW1/F9Y9AFY8j5kpoFPP2gVDAqFVrK++vAqvbf15n7KfapYVeHXFr9iY2yjlbyf9zhsG7fGjEEkJ6Nfvjzl5/yMkbt7sZSVFyEEkUfvsG9VJKnJGejoKfBpUwGvFs7oyLFMkiRJJUKOWXoD6Ooo+KFTbRpXKcPT9Ex6hR4j8k4p3k3l2gg+WJD199EFcOhnrWVdybISIS1DsDW25Z8H/9B7W2/uPb2ntfyfZd7SH9cVK9AvX5702FiiP+rC461bi6WsvCgUCtzrO9BlQn1ca9igyhAc3nCNtd+dJCEuqUTrIkmSJBWdDJZKkYGeDgu618XL2ZJHT9PpvvAINxK0OzfRC6neHvymZP29fRz8/YfWsq5oUZHQlqHYmdhx9dFVeoX1Ij45Xmv5P8vI3Y0Kf6zBtGFDxNOn3Pz0M+Jn/IDILNkZ1E0tDQkYWJNmPathYKxHfPRjVk85xsnt10t3ri1JkiTphchgqZSZGOgRGlgPN3sldx6n0n3hEe4+0d76ai+swSCoPyDr7w0DIHq/1rJ2MXdhkf8iHEwdiH4cTdC2IG4n3dZa/s/StbTE6ZcFWPcOAuD+r79yo/8AMh9pf5B5fhQKBVUbONJlgg/OntZkZqg4tO4q678/ycP4UgyMJUmSpEKTwVIetDkpZUEsTQz4Pag+5a2Mib6fTM+QozxOKaWFdxUK8J8C1d7LGr+0sivEX9Ra9k7mToT6h1JOWY7rj6/TK6wXcYlxWsv/WQo9Pey/+IKy33+PwsiIpH37iOrUidR//imW8vKjtDKizeBa+Havir6RLrevPWLVN0f5Ozy2dCcolSRJkgr0wgO8o6KiqFBBO5MXvg6Ka4B3bqLuJdFx/kHuJabhU8Ga34N8MNLXLdYy85T+FH5/H24cBvPy0Gdn1p1zWnIr8Ra9t/UmNjGWcspyLPRfSDllOa3l/7yUixeJHTSY9Fu30DExwTF4GuYtWhRbefl5fO8pu3+/yM3IhwA4VbPi3R7VUFoZlUp9JEmS3kSlOsC7cuXK+Pr6snTpUlJSUopUuKSpQhlTFvXywcxQj6NRCQxefpKM0pqnR98YuqwAmyrwODZrtu8U7S0aW1ZZltCWoTibOXMz8Sa9wnpx4/ENreX/PKNq1XBd+wcm9eujSk7m5pCh3P1pNkJV8q+veRlj2g334u1OVdDV1+HGxQes+Poolw/HyVYmSZKkV9ALB0tnzpzBy8uLzz//HAcHB/r168fRo0eLo27/SdXLWfBbT28M9XTYeTGekWv/Lr3BwCbW8PEfYGoHd/6G1d0hI01r2TuYOhDaMhRXc1fikuII3BbI9cfFN6u5npUVzgt/w7pnDwDuzZ1L7KDBZD4p+bsQFToKar3rROex9bBzNSftaQY7F10kbME5kh9r7zWWJEmSiu6l51nKyMhg06ZNLFq0iK1bt1KlShV69+5N9+7dsbW11XY9S01JdsM9a8eFO/RfeoJMlaD32xUY17oaCi3Ne/TCbp2C0NaQngS1usD787Q2BxPAvaf36L2tN9ceXcPW2JaF/gupYFG8Xb0PN2zg9oSJiLQ0DCpUoPycORhWLJ3uZVWmipPbYjj2VxSqTIGxmT5Nu1aloteb8z2SJEkqadq8fhd5UsrU1FTmzp3L6NGjSUtLQ19fn86dOxMcHIyjo/bGuJSW0gqWANaeiOXzNVkL737h784g38olWr6Gf3bA8s4gMuGdL+DdcVrN/v7T+/TZ3ocrD69gY2TDQv+FVLKspNUynvf073PEDhlCxu3b6CiVlP1uOma+vsVaZn7u3njCztALJNzKmovJ/S0HGneqgqGJfqnVSZIk6XX1SkxKefz4cQYOHIijoyM//PADI0aM4OrVq+zevZubN2/Srl27IlVMgg/rlmd8m6yFd7/bdpllR0px4d0qLaDtrKy/I76D46Fazd7G2IYQ/xDcrdy5n3KfoG1B/POgeO9aM65RnQp/rMHYuy6qxERiBw7i3rx5pTKOCcDWyYxOo+tRx98ZhQIuH77NyslHuXEhoVTqI0mSJGV54ZalH374gdDQUC5fvkxAQAB9+vQhICAAHZ1/464rV65QtWpVMkpwMdPiUpotS9m+33aZn/dcQaGAn7vUoXXNUmyx2/Mt7J0GCh34aAW4t9Rq9g9THtJ3R18uJlzE0tCS3/x+w926eJcrEWlp3JkWzIPlywEwa9ECx2+/RVdpWqzl5ifu6iN2LbrAo7tZCxtXb1KOhu0ro29YSndHSpIkvWZKtRuuSpUqBAUF0atXLxwcHHJNk5aWxooVK+jZs2eRKvcqeBWCJSEEYzecY/mRGPR1FYQE1qNxlVIazyIE/DkYTi8FfRMI3Azl6mq1iEepj+i/oz/n7p/DwtCCX1r8goeNh1bLyM2DNWu48/VkRHo6hlUqU/7nnzFwcSn2cvOSnprJoXVX+HvvTQAsbI1pFuiBYyWLUquTJEnS6+KVGrP0ppozZw5z5swhMzOTyMjIUg2WIGvh3aErTvHX33GYGOiyrE99vEpr4d3M9KzxS1d3gUkZ6LMDrCtqtYgnaU/ov7M/Z++exczAjF9a/EL1MtW1WkZunp4+TeyQoWTcvYuOuTnlZnyPsnHjYi83PzcuJrD794skPkhFoQAvP2d82lREV1/OKStJkpSXUg2WQkNDUSqVdOzYUWP/mjVrSE5OfiNak571KrQsZUvNyKTP4uPs++celib6rOnXgCr2ZqVUmScQGgC3z4J1Jei9A0xttFpEYloiA3cN5FT8KZT6Sua3mE8t21paLSM36fHx3Bw6jKenT4NCge1nn2LTp0/p3Y0IpCans2/1P1w+nLU8jHVZU5r38sDWqZTef0mSpFdcqQ7wnjZtGmXKlMmx387OjqlTpxapMlL+DPV0mf9xXWo7WfIwOZ3uC48S+6CU1hczNINua8DCGRKuworOkKbduigNlMxvPp+69nVJTE+k345+nIo/pdUycqNvZ4fz74ux7NgRhODujB+4+dlnqJJLby03QxN9mgd60Kp/DYzN9Em4lcQf3x7n+JYoVKU1cakkSdJ/xAsHS9evX891uRMXFxdiYmK0Uikpb6aGWQvvVrFTcvtxCt0XHuVeYiktvGvmkDVppZElxB6DdZ+AKlOrRZjomzC32Vx8HHxISk+i345+HLp1SKtl5EbHwADHyV/jMGkS6OnxZGsY0V26khYbW+xl56dibVs+Gl+firVtUakERzZGsfa7kzy4nVSq9ZIkSXqTvXCwZGdnx9mzZ3PsP3PmDDY22u2GkXJnZWrAkt71KWdpTNS9JHqGHOVJaS28a+sOXVaCriFc2gxbR2YNAtciE30Tfm72M43KNuJpxlMG7RrErphdWi0jL1YfdcZl8SJ0y5Qh9fJloj/sQNKh4g/W8mNibkDLftVp3ssDA2M94qMfs2rKMc7suoEordneJUmS3mAvHCx99NFHDB06lD179pCZmUlmZia7d+9m2LBhfPTRR8VRRykXDhZGLOntg42pAedvPabP4uOkpGu3VafQXBpA+18ABRz7FQ7+pPUijPWM+endn2jh0oJ0VTqfh3/OpqubtF5Obkzq1qXCH2swqlGDzEePiOndh/uLFpXqOm4KhQL3+g50meCDk4c1mekq9q/5hz9/PMXj+09LrV6SJElvohce4J2Wlkb37t1Zs2YNenp6AKhUKnr06MH8+fMxMDAoloqWlldpgHduzt18xEe/HCYxNYMWHvbM61YHPd1Sukvq0FzYNjrr7w8XQo0OWi8iQ5XBpIOT+PPqnwCMqT+GLlW7aL2c3KhSU7k9cRKPNmwAwLxtWxwnf42OkVGJlJ8XIQTnI25yYO0VMtJU6Bvp8nbHKlRr6Fiqg9IlSZJK0ysxdUBkZCRnzpzB2NiYGjVq4FKK89EUp1c9WAI4dPU+PUOPkpahokPd8nzXoWbpXSTDxsDhOaCjD93XQYV3tF6ESqiYfmw6yy4uA2Co11D61CiZu9WEEDxYuow706ZBZiZGHh6U/3k2+mXLFnvZBXkYn8zuxReJu/oIANcaNjT9uCqmFoalXDNJkqSS90oES/8Vr0OwBLD9/G0GLDtJpkrwSeMKjAkopYV3VSr4oxdc2ACGFhAUBvban1BSCMHcM3OZf2Y+AL2q9+LTOp+W2DknHTnKzeHDyXzwAF1ra8rNmompj0+JlJ0flUpwemcMRzZeQ5UhMDTVo0kXd6p425d21SRJkkpUqQZLmZmZLFq0iF27dhEfH4/quXW0du/eXaQKvWpel2AJ4I8TsYz4/8K7X7Z0Z2DTUlp4Nz0FlrwPMYfAvBz02QnmxdPysvj8Yr4//j0AHd06Mrb+WHR1SmZJkPSbN7kxZAipFy6Cri72o0dj1a3rK9H1df9mIjsXXeDejUQAqnjb8U4Xd4xM5aK8kiT9N5RqsDR48GAWLVpE69atcXTMOSZi5syZRarQq+Z1CpYAftt3jW/+ugjAt+1r0MXHuXQqkpwAIf5wLxLsq0OvLWBUPMt0rI1cy1eHvkIgaFWhFVPenoK+TskEBaqnT4kbP4HHmzcDYNG+PQ4TJ6BjWPpdX5kZKo5vieZE2HWESmBiYYDvx1VxrZFznjRJkqQ3TakGS2XKlOH3338nICCgSAW/Ll63YAlgetgl5oZfRUcBP3etQ0CNUlp498F1WNgCEu9AhSbQ7Q/QK54bAMKiwhi9bzQZIoMm5ZvwfZPvMdIrmYHXQggSQhcR//33oFJhVLMm5X/6Ef081k4saXeiH7Nr0QUe3M6aVNPj7bI06lAZAyO9Uq6ZJElS8SnVGbwNDAyoXLmUundK0Jw5c/Dw8KBevXqlXZUX9oW/O118nFAJGL7yNPv/uVc6FbFyyZrl20AJUXth4xCtz8GUrWWFlvz47o8Y6hqyN3Yvg3YNIim9ZCZqVCgU2AT1wvm3X9G1sCDl7FmiOnQk+eTJEim/IPau5nQaU49a7zoBcGH/LVZOPsrNyAelXDNJkqTXwwu3LM2YMYNr167x888/vxJjM4rb69iyBFkL7w5efpKt525jYqDL8k/eoraTZelU5spOWNYJRCY0HgHNxhdbUcduH2PI7iEkpSdRo0wN5jWfh4Vh8XT/5Sbtxg1iBw0mNTIS9PVxGDsWq486l1j5Bbl5+QG7fr/Ik/spoIBa7zrxVruK6BmUzDgvSZKkklKq3XAffPABe/bswdraGk9PT/T1NceGrFu3rkgVetW8rsESZC28G7ToGAeu3MfKRJ+Ng9/GydqkdCpzain8OSjr7zYzwTuo2Io6f+88/Xb241HqIypbVuaXFr9ga2JbbOU9T5WczK2xY3myNQwAy06dsB83Fp1XZA6ytJQMDqz5hwsH4gCwcjCheS8P7Fxer8+3JElSfko1WOrVq1e+z4eGhhapQq+a1zlYAkhMzaDrr4c5G/sIL2dL1vRrUHqTVoZPg/BvQaEDH60A95bFVtSVB1fou6Mvd5/excnMiV/9fqWcslyxlfc8IQT3f/uNuz/MBCEw9vKi3I+z0LezK7E6FCT673vsWXKJ5MdpKHQU1G3lgneAK7ql9fmQJEnSIjnPUgl63YMlgBsJyQT8uI8nqRkMebcyn/u5l05FhICNg7NamfRNoOdmKF+32Iq78eQGn2z/hJuJN7EzseNXv1+paFGx2MrLTWJEBDdHfIHq8WP07OwoP/snjGvVKtE65CclMZ29Ky9z5Xg8ALbOZjQLrIZNWWUp10ySJKloSnWAN0BGRgY7d+5kwYIFPHnyBIBbt26RmJhYpMpIxcPJ2oQp7WsA8POeKxy+dr90KqJQQJtZULk5pCfD8k6QcK3YinMyc2Jxy8VUsqhEfHI8gVsDuXD/QrGVlxvlO+9QYfUqDCpXIiM+nusfd+fh2rUlWof8GCn18e9THb8+nhia6nE35glrph7n1PYYVHJRXkmSJOAlWpauX79Oy5YtiYmJITU1lcjISCpWrMjw4cNJSUlh/vz5xVXXUvEmtCxlG7HmDH+ciMXRwoitwxpjaVJKY2hSE2FRAMSdAeuK0HsHmBbf3D8PUh7Qf2d/Lty/gFJfyZxmc6hjX6fYystNZmISt0aNJHHnLgCsPv4Y+1EjUei9OrfvJz1KZc/SS1z/OyuYdqxsQbOe1bCwLaVxbpIkSUVQqi1Lw4YNw9vbmwcPHmBsbKze/8EHH7Br164iVUYqXpPe88TVxoS4RymMWvs3pdYDa6iErmvA0jmrZWnFR5CWXGzFWRlZsdBvIXXt65KYnki/Hf04cPNAsZWXG12lKeV/+okyQ4cA8GDpUm707Uvmw4clWo/8mFoY0npgTXy7V0XfUJe4K49Y+c0xzkXcLL3PiiRJ0ivghYOl/fv3M27cOAyeu7PHxcWFmzdvaq1ikvYpDfX4qYsXejoKws7fZuWxG6VXGTN76LYWjCwh9his7QOqzGIrTmmgZH7z+TQu15iUzBQG7x7Mjus7iq283Ch0dLAdOJBys39CYWJC0sFDRHXuTOrVqyVaj/woFAo8GpXlo/E+lK1iSUZqJnuXX2bz7DMkPkgt7epJkiSVihcOllQqFZmZOS9qsbGxmJmZaaVSUvGpWd6SEf5ZA7y/2nSeK/GlOM7M1g26rARdQ7j8F2z9stgmrQQw0jPiR98f8Xf1J0OVwYi9I1j/z/piKy8v5i1a4LpiOfply5J+PYbozh+RuHdvidcjP+ZljHn/Uy/e7lgFXX0dYi4ksHLyES4fuS1bmSRJ+s954WCpRYsWzJo1S/1YoVCQmJjIxIkT/zNLoLzu+jauSKPKNqSkqxi64hSpGcXXolMglwbw4a+AAo79Bgd+LNbi9HX1CW4czIdVPkQlVEw4OIGlF5YWa5m5MXJ3x/WPNRh710WVmMiN/gO4vzDklQpEFDoKajVzovPYeti5mJGanMHO0Ats++UcT5+klXb1JEmSSswLD/C+devW/9q77+ioym6P498zk5n0QhJIQkIgdEKoCSi9IyBIR1EBAVF6B1FUsFGVHlSQIgqKgAIioPSmIL13AiFACAHSe+bcP0a5L9IhM2eS7M9aWWsySWb/JO+9s3PO8+yHBg0aoNfrOXv2LGFhYZw9exZvb2+2b99OIRuaI5MT8tIC7/91PSGNZtO2czslk561g/igZbC2gXZ/CetHmR+3+wYqdrRoOVVV+Xzf5yw6sQiAvpX70rtib6tPpVczMoj+5FPili0DwL11a3w//sgmDuL9X6ZsEwd+v8TeNRcxmVQcXQ006FKOoIpyKK8QwjZpPmcpNTWVH374gQMHDmAymahatSqvvfbaXQu+84q82iwBbDxxnTcX7QNgYfdq1C+jcaP7+2j4axboDNDlZwiqa9Fyqqry9ZGvCT8UDkDX4K4MDxtu/YZJVbn9/WKuT5gA2dk4VqpEwKyZ2BW03tTxx3UjMpGNC09w66r53L3qrYIIa1EsXxx9JITIXTRvlvKTvNwsAYxZdYxv/7qEt4uRdYPqUtBVwysaJhOs6AHHfwF7N+ixHnzKW7zs9ye+Z+LeiQC0K9WOD5//EL3O+melJf/5J1FDhmKKj8fO15eA8Fk4lrf8f/+Tys408efP5ziyJQqAUtV8aNi1LHYGOV9OCGE7NG2WFi1a9NCvd+3a9ZkC2Zq83iylZWbTetYuTl9PpF7pgix4oxo6nYZXCTLT4Lu2EPknuPmbZzC5W/6Ykl/O/sLYv8ZiUk28UOwFxtcej0FvePQP5rCMixe53LcfGRcuoDg4UHjcZ7jZ6FrA4zuusP2HM5hMKj5BbjTvXQFnd9u6fSiEyL80bZYKFChw1+eZmZmkpKRgNBpxcnLi1q1bzxTI1uT1ZgngdHQiL83aSXqWiQ9aBtOzdpC2gVJuwfxmEHsaCpWHHuvAwd3iZTdc2sDI7SPJMmVR2782U+pPwdHO+reWsxMTuTJ8OMnbtgPg1ac3BQcMQNHZ3pltUadvs/7ro6SnZOHiac+LfSvhHSBHpQghtKfpUMrbt2/f9ZGUlMTp06epXbs2P/zwwzOFsSXh4eEEBwdTrVo1raNYXBlfV95/sRwAE9ed4tiVeG0DOXnC68vBxQdijsPS1yHL8ruvmhRtwqyGs3DQO7Dzyk76bOxDUob1RyvoXV0pMns2nj16AHDzy6+4MmgQpuRkq2d5lIAyBejwThgePk4k3Urn58n7iTgSq3UsIYTIUTm2Zmnfvn28/vrrnDp1KidezmbkhytLYF5k3GvRfjaevE6Jgs78OqA2TkaNj+K4dhgWtICMJKjQCdrNMZ8vZ2EHrh+g36Z+JGUmEewVzFeNv6KAQ4FH/6AFxP2ykugPP0TNzMS+dGkCZs/GGGD525JPKi05k9/nHiPq1G1QoGa7klRuXEQWfgshNKP5Qbr3o9fruXr1ak69nLAyRVGY1KEiPm72nL+RzCdrrHvg7H35VYJOi0BnB0d/gk0fW6VsVZ+qzHthHgXsC3Di5gm6r+/O9eTrVqn9Xx5t21D0u0Xovb1JP3OGix07krJ3ryZZHsbB2UDLAZUoX6cwqPDninNs+f4U2VkmraMJIcQze+IrS6tXr77rc1VVuXbtGrNmzaJIkSKsW7cuRwNqLb9cWfrXrnOxvD5vD6oKX75WleYV/LSOBAcXw6q+5sctPofqvaxS9kLcBXpt6EVMSgz+Lv7MbTqXIq5FrFL7vzKjo4nq24+0EyfAzg7fDz+gQKdOmmR5GFVVObI5il3Lz6KqULiUB83froCDi/UXywsh8jdNF3jr/rPIVFEUChYsSMOGDfniiy/w87OBN9cclN+aJYAJ607x1bbzuDsaWDeoDoU9bGB+1rZJsOUz8+Omn0HN/lYpeyXpCr3+6MXlxMsUdCzInCZzKFmgpFVq/5cpNZVro0eTsNb8B0mB11/HZ9Q7KHYa3y69j0vHbvL7N8fITMvGraAjLftVpICvs9axhBD5iMxZsqL82CxlZpvo8OWfHI6Kp3qQJz/0eh69luMEwHxm3MYx/38cSr13oP67VlnDdCPlBm9teItzcedwt3fnq8ZfEeIdYvG696OqKje//pob08z/Ds41a+A/ZQp6Dw9N8jzMzatJ/BZ+hMSbaRgd7WjWK4QiwZ5axxJC5BM2uWZJ5B0GvY7pr1TB2ajn74hbzN5yTutI5qao8UfQ8APz59smwvp3zYMsLaygU0EWNltIBe8KxKfH8+Yfb7I3Wpt1Q4qi4N27NwGzZqI4OZH8519EvPwy6efPa5LnYbwKu9BxVBh+JdzJSM3i11mHObYtSutYQgjxxJ74ytLQoUMf+3unTJnyxIFsTX68svSvFfujGLbsMHqdwk9v1yC0qDY7wu7x91xYO9z8uPLr0Go66C1/Kyo5M5kBmwewN3ov9np7ptSfQt0Ayx7J8jBpp08T1acvmVevonNxwf+Lz3GpV0+zPA+SnWliy+JTnN4dDUCFBgHU7lASnV7+VhNCWI6mt+EaNGjAgQMHyMrKokyZMgCcOXMGvV5P1apV//+FFYXNmzc/UzhbkJ+bJVVVGfTjIVYfvkpAAUfWDqqDm4ONLNQ9/COs7AtqNpR7Cdp/A3aWnx6dlpXGiG0j2Bq1FTvFjvF1xtMsqJnF6z5I1q1bRA0cSOq+/aAoFBo+HM8e3W1uy76qqhz4/RK7V14AIDDYk6a9QrB3tL31VkKIvEHT23CtWrWiXr16REVFceDAAQ4cOMDly5dp0KABLVu2ZMuWLWzZsiVPNEr5naIofNo2hIACjkTdTuX9X45hM0vcKr0Cnb4FvRFOroYfOkNGisXLOtg5MKXBFJoHNSdLzWLk9pEsP7Pc4nUfxM7Tk6Lz5+PRsSOoKjGTJ3Nt1LuY0tM1y3Q/iqIQ2qwYzd4Owc6oI/LELVZM3Ef8jVStowkhxCM98ZUlf39//vjjD8r/54DPY8eO0bRp0zw3ayk/X1n61/5Lt+n09V9km1S+6FiJ9qEBWkf6f+c3w4+vQWYKBNaAV5da5WiUbFM2n+35jGVnlgEwPGw43cp3s3jdB1FVldvfL+b6hAmQnY1jpUr4z5yBoVAhzTI9yI3IRH6bfYTkuHQcnA00712BwqU8tI4lhMhjNL2ylJCQwPXr9w7oi4mJITEx8ZnCCNsUWrQAgxuVAuDDVce4GGtDx26UaAhdVoK9O0T+BQtbQrLlj9vQ6/R88PwHdA/pDsDn+z5n1sFZml15UxQFzy6vEzh3Djp3d1IPH+Zix06kHjuuSZ6HKRjoSsdRYRQq6kpaciarph3k5J/XtI4lhBAP9MTNUtu2benevTvLly8nKiqKqKgoli9fTs+ePWnXrp0lMgob0LdBSaoHeZKckc2gHw+SYUuTmQOfgzfWgHNBiD4CC5pD/BWLl1UUhSFVhzCo6iAAvj7yNRP3TsSkavdv41yzJkFLf8RYvDhZ169z6fXXSVi7VrM8D+LsYU+bYVUpUbUQpmyVzYtO8ufP51BNNnKbVwgh/scT34ZLSUlh+PDhzJ8/n8zMTADs7Ozo2bMnkydPxtk5bw2ek9tw/+9qXCrNpm0nIS2LPvVL8E6zslpHulvsOVjUGhKiwD0Quq4ErxJWKf3DqR8Yt2ccAK1LtGZszbHY6bRbvJydmMiV4cNJ3rYdAK8+vSk4YACKzrZ2oKkmlb/XRLBv7UUAgip507h7MEYHWfgthHg2NjGUMjk5mfPnz6OqKiVLlsxzTdK/pFm627qj1+iz+ACKAot7PkfNkt5aR7pb3GVzw3TrPLj4mG/R+QRbpfSv53/lg10fkK1m06RoEybUmYBRb7RK7ftRs7OJmTKFW/PmA+DapDGFJ0xAZ4P/t3p6TzRbvjOfJeddxIUWfSri6umgdSwhRC5mE0Mpr127xrVr1yhdujTOzs62s0tKWFTzCn50rl4EVYUhPx3iVnKG1pHu5lEEeqwHnxBIug4LW0DUfquUblWiFV/U+wKDzsCGSxsYsHkAKZmW36H3IIpej8+IEfhNGI9iMJC4YSMXO79KRpTlb1E+qTLP+dJmaBUcXQ3EXk5i+YR9XI9I0DqWEEIAT9Es3bx5k0aNGlG6dGlatGjBtWvmhZlvvvkmw4YNy/GAwvZ80DKYEgWduZ6QzsjlR2yvUXYpZF7DFFANUm/DopcgYrtVSjcq2ojwRuE42jny59U/6b2xNwkZ2r7pe7RpQ9HvFqEv6E36mTNc7NiRlL3aTCB/GN/i7nQYFYaXvzMpCRn8MuUAZ/fdu5lECCGs7YmbpSFDhmAwGIiMjMTJyenO8y+//DLr16/P0XDCNjkZ7Zj+ShWMeh0bT17n+z2RWke6l2MB8y24oHqQkQTfd4DT66xSukbhGsxpMgdXoysHYw7S8/ee3Ey9aZXaD+JYuTJBy5bhEBxM9u3bXOreg9s//aRppvtx83Kk3YhQilXwIjvTxB/fHOfvNRG215ALIfKVJ26W/vjjDyZOnEhAwN2zdkqVKsWlS5dyLJiwbSH+7oxsZp7g/umaE5yOtsGxEfYu8OpPUOZFyE6Hpa/DUesMkKxcqDILXliAp4Mnp26d4o31bxCdHG2V2g9i8PWl6OLvcWvRHLKyiP5wDNGffIqalaVprv8yOtjRvE9FKjcuAsDeNRFsmHecrIxsjZMJIfKrJ26WkpOT77qi9K/Y2Fjs7S1/3ISwHT1qBVGvdEHSs0wM/OEgaZk2+GZmcDBP+q74MpiyYMWbsG+BVUqX8SzDt82+xdfZl4sJF+m2rhuRCdpehdM5OlL4iy8oONg87uD24sVE9upFdlycprn+S6dTqNWhFA1eL4tOp3B2Xwwrpx4kOd62JpMLIfKHJ26W6taty6JFi+58rigKJpOJyZMn06BBgxwNJ2ybTqfwecdKeLsYOX09kfFrT2od6f70BmjzFYT1BFRYMxh2TbdK6WLuxVjUbBFF3YpyNfkqXdd15cztM1ap/SCKouDduzcBs2aiODmR8tduIl5+mfTz5zXNdT/BtQvTalBl7J3suB6RwPIJ+4iNssGrmEKIPO2JRwecOHGC+vXrExoayubNm3nppZc4fvw4t27dYteuXZQoYZ25NpYWHh5OeHg42dnZnDlzRkYHPMTW0zG8scC8YHhetzAalfPRONEDqCps+hh2TjF/XmcYNPwArHDobGxqLG9veJszt8/gZnTjm6bfUM6rnMXrPkra6dNE9elL5tWr6Fxc8P/ic1zq1dM61j3irqfw2+wjxF1Pwc5eT9MewQRVKqh1LCGEDdN8zlJ0dDRffvkl+/fvx2QyUbVqVfr164efn98zhbFFMmfp8Xz86wnm74rA09nI+kF1KORmwzNydk6FjWPNj6u/Bc0mghWGNcanx9N3U1+O3DhCQceCLHlxCb7Ovhav+yhZt25xZeAgUvbtA0Wh0PDhePbojmKFJvJJpCVn8vvcY0Sdug0K1GhbgipNAm0upxDCNmjWLGVmZtK0aVO+/vprSpcu/UyFcwtplh5PelY2bcL/5OS1BGqX9GZRj+rodDb8Jrb3G/htOKBCpc7w0izQW35qdGJGIl3WduF8/HlKFyjNouaLcDZoPyRSzcgg+tPPiPtnh5x769b4fvwROhtbh5idbWLn0rMc226eFVW2ph/1Xy2D3s62JpMLIbSn2VBKg8HAsWPH5C85cQ97Oz0zO1fGwaBj57lY5u64oHWkh6v2JrSbA4oeDv8Ay7pBluUXD7saXQlvHI6Xgxdnbp9h+LbhZJm0342mGI34fjQWn/ffB72e+FWriOzajcyYGK2j3UWv11G3c2nqvFwKRYFTf15j9fRDpCbZ2HBUIUSe8sR/jnXt2pV58+ZZIovI5UoWcmVMq/IATP79NEei4rQN9CgVO8HL34PeHk6tgSUvQ0ayxcv6u/gzs+FMHPQO7Lyykwl/T7CJOUKKouD5+msEfjMXnbs7qYcPc7FjJ1KPHdc62l0URaFigyK82L8SBgc9V8/GsXzCPm5ds/zvTgiRPz3xmqUBAwawaNEiSpYsSVhY2D1nwk2ZMiVHA2pNbsM9GVVV6fP9AdYfjybI25k1A2rjbG/jh6Je2Ao/vAqZyRBQHV5bBo4eFi+76dImhmwdgorKiLARdC3f1eI1H1fGpUtc7tOXjAsXUBwcKDzuM9xatNA61j1uXk1i7ewjJMSmYXS044Ve5QkM9tI6lhDCBlh9zdKRI0cICQlBp9M9dDyAoihs3rz5mQLZGmmWnlxcSgbNp+/gWnwaHUMDmNyxktaRHi1qH3zfHtLiwKcCdPkFXCy/2+rb49/y+b7PUVCY2mAqjQIbWbzm48pOTOTK8OEkbzMfFePVpzcFBwxAscJi+CeRmpjBuq+Pcu1cPIpOoU6nUlSoH/DoHxRC5GlWb5b0ej3Xrl2jUKFCFC9enL179+LllT/+epNm6ensvnCTznN3o6ows3MVWlUqrHWkR4s+Bt+1heQY8CoJXVeBu2XfdFVV5dPdn/LTmZ9w0DuwsNlCynuXt2jNJ6FmZxMzZQq35s0HwLVJYwpPmIDOWftF6f8rO9PE1sWnOLXbPCW9Qj1/ancqhU5vW42dEMJ6rL7A28PDg4iICAAuXryIyWR6pqIi73u+uBf9G5QE4L1fjnL5VorGiR6Dbwj0WA/uReDmOZjfDGLPWbSkoii8+9y71PKvRVp2Gv039+dq0lWL1nwSil6Pz4gR+E0Yj2IwkLhhIxc7v0pG1BWto91Fb9DRsFs5arQtAQoc3XaFNeFHSE/J1DqaECIPeKwrS2+99RaLFi3Cz8+PyMhIAgIC0Ov19/3eCxdsfBfUE5IrS08vM9tEp6//4mBkHKFFC7D0reexyw1/6cdHwaLW5obJuaD5QF7fEIuWTMpIotv6bpy5fYaSHiVZ1HwRrkZXi9Z8UqmHDnF5wACyb8SiL1CAgBnTcapWTetY97hw8AYbFhwnK8NEAV8nXuxXEfeC9x7RJITI2zSZs7R+/XrOnTvHwIED+fjjj3F1vf//Ix80aNAzBbI10iw9m8u3Umg+fQdJ6VkMalSKIU1yyXyupBvwfVuIPgoO7vDaCihi2cYgOjmaV397lRupN6jhV4PwxuEYdAaL1nxSmdHRRPXrT9rx4ygGA/7Tp+Pa0PaOOboRmchvs4+QHJeOg7OB5r1DKFyqgNaxhBBWpOkE7+7duzNjxowHNkt5jTRLz27VoSsM+vEQOgV+fKsG1YM8tY70eFLjYEknuLwHDM7QeQkUr2/RkidunuCN9W+QmpVK+1LtGVNjjM3NNTOlpnJ15DskbtgAdnb4T/kCt6ZNtY51j+S4dNZ+eYSYS4no9Ar1XytDuZq5YO2cECJHaDaUEmDBggX5plESOaN1ZX/aVfXHpMLgHw8Sn1vWkTh6mHfFFW9gHiuwuCOc+s2iJYO9gplUdxIKCivOrmDh8YUWrfc0dI6O+E+dgtuLL0JWFleGDCX+N8v+uzwNZw972gyrSsnQQpiyVTYvOsWfK85hMmk/00oIkbvkggUkIi/4uHUIRb2cuBqfxnu/HLWJIYyPxegMry6Fsi0hOwOWdoHDSy1asn6R+rxT/R0Apuyfwh8X/7Bovaeh2NlReNJE3Nu2hexsro4YSdwvK7WOdQ+DUU/TnuUJe7EYAAc3RLLuq6NkpGk/NV0IkXtIsySswsXejumvVMFOp/Db0Wss2xeldaTHZ2cPHb81nyGnZsMvb8Hfcy1a8rVyr/Fq2VcBeG/nexy5ccSi9Z6Gotfj99mneHTqBCYT1957j9vLlmkd6x6KTuG5VsVp0jMYvZ2Oi0di+fnzAyTeStM6mhAil5BmSVhN5SIeDG1qXuA9ZvVxzt9I0jjRE9DbQevZUP1t8+drh8MOy06rH1ltJPUC6pGenc6AzQOISrS9BlPR6fD9aCwFXnsNVJXoDz7k1uLFWse6r9LVfGkztAqOrgZuRiWxbMI+oiPitY4lhMgFpFkSVtW7bglqlvAiNTObgT8cJD0rW+tIj0+ng+YToe4I8+ebPoINY8BCtxT1Oj2T6k6inGc5bqXdou+mvsSn296bu6Io+Lw/Gs/u3QG4/smn3FywUNtQD+Bb3J0Oo8Lw8ncmNSGDlV8c5Oze61rHEkLYOGmWhFXpdApTOlWmgJOB41cT+Pz301pHejKKAg3fhyafmD/fNQ1+GwYWGtTqZHBiZsOZFHIqRER8BMO2DiMz2/YWyCuKQqGRI/Dqbb7yFjNxIrFfz9E41f25eTnSbkQoxSp4kZ1l4o95x9m39mLuWUcnhLA6aZaE1fm6OzCxfUUA5u6IYPuZGxonegq1BkLLaYAC++bBL2+DhZoYH2cfZjeajZOdE3ui9/Dx7o9t8o1dURQKDR6M98ABANyYOpUbM2fZZFajgx3N+1SkUuMiAOxZfYHN354kO0tOJxBC3EuaJaGJpuV9ef35QACG/nSY2KR0jRM9hbDu0P4b0NnB0Z/gp66QaZlFw2U8yzC53mR0io6V51byzdFvLFInJxTs25eCw4YCEBsezo0pU22yYdLpFGp3KEW9zqVRFDi1O5pfZxwiLdn2rtwJIbQlzZLQzPsvBlOqkAuxSemMWHbYJt9QH6lCB3h5Mdg5wOm1sKQjpFtm4XrdgLq8W/1dAGYcnMG6iHUWqZMTvHv1wufdUQDcnDuXmAkTbfb3G1IvgBf7VcJgr+fKmThWTNpP/I1ccJahEMJqpFkSmnEw6Jn5ahWMdjq2nL7Bwj8vah3p6ZRpBq8tB6MLRGw3nyuXcssipV4p+wpdgrsA8P7O9zkYc9AidXKCZ7du+I75EIBb337L9U8+QbXRQ7iLhnjRbkQoLgXsibuewvKJ+7l2Lk7rWEIIGyHNktBUWV83RrcoB8D4tac4eS1B40RPKagOdF0NjgXgyj5Y2BISLbPLaljoMBoUaUCGKYOBmwcSmRBpkTo5oUDnzvh9+gkoCreX/ED0mDE22zB5B7jQYVQYBQNdSUvKZNW0Q5zZG611LCGEDZBmSWiua42iNCpbiIxsEwN+OEhqRi4aJ/C/AkLhjbXg4gMxx2FBM4jL+UZGr9Mzoc4Egr2CiUuPo9+mfjY5UuBfHh06UHjiBNDpiFu2nGvvvoeabZu/Y2d3e9oOq0pQJW+ys0xsmHeCfWsjbPYWohDCOqRZEppTFIVJHSpSyNWeczFJfPrbCa0jPT2fYOixHjwC4dYFmN8MYs/meBkngxOzGs7C19mXiwkXGbRlEBnZGTleJ6e4v/QS/p9PBr2e+FWruDpiJGqmbS6kNtjrafZ2BSrf2SkXITvlhMjnpFkSNsHLxZ4pnSoDsHhPJOuP5eLbH57Foft68C4NCVfMDdO1nD+upKBTQcIbheNscGb/9f2M/XOsTV8BcWvRAv9pU8FgIGHtWq4MHYqaYZsNnk6nUKtDKeq9WgZFp3BqdzSrp8tOOSHyK2mWhM2oXcqbt+sWB2DUz0e4Fp+qcaJn4O4P3deBXyVIiTWvYYrck+NlShcozRf1vkCv6Pn1wq98deSrHK+Rk9yaNCFg5gwUo5HEDRuJGjgIU7rtjo0IqetPy34VMTjouXrWvFMuLkZ2ygmR30izJGzKsKZlqODvTlxKJkOWHiLbZLtXSh7J2Ru6/QqBNSA9Hr5rA+c353iZWv61GP38aABmH5rNr+d/zfEaOcm1fn0CZs9GsbcnaetWovr2w5Rqu41xYHkv2o8IxcXTvFNuxcT9XJWdckLkK9IsCZtitNMxo3MVnIx6dl+4xVfbzmsd6dk4uMPrP0PJxpCZAktehhOrc7xMx9Id6R5iPpttzJ9j2Be9L8dr5CSX2rUoMmcOipMTybt2cbl3H0wptnvFxsvfhQ7vhFGoqCtpyZmsmnaQM3/n4lvFQognIs2SsDlB3s589FJ5AKZsOMPByNsaJ3pGRid45QcIbg3ZGbCsG5zO+YGSg6sOpknRJmSaMhm8dTAX4y/meI2c5PxcdQK/mYvO2ZmUPXuI7PUW2UmWGeiZE5zd7WkzrCrFKxfElKWyYf4J9v4mO+WEyA+kWRI2qUNoAC0r+pFtUhn04yES03L5wlo7I3RYAJVeBdUEv/SGuMs5WkKn6BhXexwVvSsSnx5Pv039uJ1m242mU9WqBM6fh87VldT9+4ns2ZPsBNudtWUw6mn2VgiVm5iP6vn71wg2LTxJdqbslBMiL5NmSdgkRVH4rG0F/D0cibyVwphVx7WO9Ox0emg1HQpXhbQ4WN4jxw/fdbBzYHrD6fi7+BOZGMmgLYNIz7bdBdQAjpUqEbhwAXp3d9IOHyHyje5k3bbdJk/RKdRqX/LOTrnTe6JZLWfKCZGn5flm6fLly9SvX5/g4GAqVqzIsmXLtI4kHpO7o4Hpr1RGp8DPB6+w8uAVrSM9OzsjdFwA9u4Q9Tds/jTHS3g7ehPeKBxXgysHYw7ywa4PbP5WkWP58gQuWoTe05O0EyfMDdPNm1rHeqj/7pRbPnGf7JQTIo/K882SnZ0d06ZN48SJE2zcuJEhQ4aQnJysdSzxmMKKeTKoUWkA3l95jMibeeDNqEAxaD3T/HjXNDi7McdLlPAowZQGU7BT7FgXsY7wQ+E5XiOnOZQpTdFF36Iv6E366dNc6taNzJgYrWM91P/ulIuPSZWdckLkUXm+WfLz86Ny5coAFCpUCE9PT27dsswhp8Iy+jUoQbViBUhKz6LfkgOkZGRpHenZBbeGar3Mj395CxKu5XiJ5/2e58Ma5oNsvz7yNavOrcrxGjnNvmRJin33HXa+vmScO09kl65kRtv2rrP77ZQ7vce2MwshnozmzdL27dtp1aoVhQsXRlEUVq5cec/3zJ49m6CgIBwcHAgNDWXHjh1PVWvfvn2YTCaKFCnyjKmFNdnpdUx7pQoFnAwcvRLPoB9z+fylfzX9FHwrQMpNWPEmmHL+vLS2pdrSq4K5KRv711j+vvZ3jtfIacZixSj6/XcYChcm49IlLnXpSuYV274Fe2enXBXzTrmNC07w9xrZKSdEXqF5s5ScnEylSpWYNWvWfb++dOlSBg8ezOjRozl48CB16tShefPmREb+/wGloaGhhISE3PNx9erVO99z8+ZNunbtypw5cyz+3yRynr+HI990C8Nop2PDieu5+/y4fxkcoMNCMLrApZ2wbZJFyvSv0p9mxZqRZcpi8NbBXIi/YJE6OckYEGBumAIDybx8mYtdupARmfOHEuckg1FPs14hVPlnp9zeNRFsXHhCdsoJkQcoqg396aMoCr/88gtt2rS589xzzz1H1apV+fLLL+88V65cOdq0acP48eMf63XT09Np0qQJvXr1okuXLo/83vT/OX4hISGBIkWKEB8fj5ub25P9B4kct+bIVfovOQjAmFbBdK8VpHGiHHBkGfz8JqBA11VQvF6Ol0jPTufN39/k0I1D+Lv4s+TFJXg6eOZ4nZyWef06kW90JyMiArtChQhcuBD74rb/Oz++4wrbfjiDalLxK+lOi94VcXAxaB1LiHwlISEBd3f3HHn/1vzK0sNkZGSwf/9+mjZtetfzTZs25c8//3ys11BVlTfeeIOGDRs+slECGD9+PO7u7nc+5JadbWlZsTCjmpcF4OM1J/jjeB5YG1KxI1TpAqjwcy9IupHjJez19kxvOJ0AlwCuJF1h4OaBpGWl5XidnGbw8aHod4uwL1WSrJgYLnXtSvrZs1rHeqTydfxp1b8SRgc9187Fs3zSPuKu54HNCULkUzbdLMXGxpKdnY2Pj89dz/v4+BD9mIs+d+3axdKlS1m5ciWVK1emcuXKHD169IHf/+677xIfH3/n4/LlnB0cKJ7d23WL07l6IKoKA388yOHLcVpHenbNJ0HBspB03bzg25Tzt248HTyZ3Xg2bkY3Dt84zPu73sek2v4tIjtvbwK//Rb7smXJjo3lUtdupJ06pXWsRyoS7Em7kaG4ejoQH5PK8kn7uHrWdudHCSEezKabpX8pinLX56qq3vPcg9SuXRuTycShQ4fufFSoUOGB329vb4+bm9tdH8K2KIrCJ63LU690QdIyTfT8dh+Xb+Xyv9qNTtBxIdg5mg/b3TXNImWC3IOY1mAadjo7fr/4OzMOzLBInZxm5+lJ0YULcAgJIfv2bS51e4PUo8e0jvVIXoVd6DAqjELF3EhPzmLVtEOyU06IXMimmyVvb2/0ev09V5FiYmLuudok8hc7vY7w16pSzs+N2KR0ui/cS3xqLp+gXKgctJhsfrz5U7j0l0XKVPOtxkc1PwJg3rF5rDizwiJ1cprew4PABfNxrFwZU3w8kd27k3rokNaxHsnJzUiboVUoUaUgpux/dsr9ekF2ygmRi9h0s2Q0GgkNDWXDhg13Pb9hwwZq1qypUSphK1zs7Zj/Rhg+bvaci0miz/f7yciy/dtKD1XldajQCdRsWNETUiwzE+ylEi/Ru1JvAD7Z/Ql/Xn28NYBa07u6UuSbb3AKC8OUlERkj56k7NundaxHMhj1vNArhKov/LNT7reLbFwgO+WEyC00b5aSkpLu3B4DiIiI4NChQ3dGAwwdOpRvvvmG+fPnc/LkSYYMGUJkZCS9e/e2aK7w8HCCg4OpVq2aReuIZ+Pn7sj8N6rhbNTz5/mbvPvz0dz9F7uiQMsp4FkCEq7Ayj5gof+evpX60iKoBdlqNsO2DuPc7XMWqZPT9C7OFJnzNU41nseUkkJkr7dI/ssyV+FykqJTqNG2JA1eL4tOp3Dm7+usmn6QtKRcfkVUiHxA89EBW7dupUGDBvc8361bNxYuXAiYh1JOmjSJa9euERISwtSpU6lbt65V8uXk1kNhOVtOx/Dmt/vINqkMaVyaQY1LaR3p2Vw7At80hux0eGEc1OhnkTIZ2Rn0+qMXB2IOUNi5MItfXIy3o7dFauU0U1oaUQMGkrxjB4q9PQGzZuFSp7bWsR7L5ZO3WD/nGBmpWbgXdKRl/0p4+DhpHUuIPCUn3781b5ZsnTRLucfiPZcY/Yt50e/UlyvRtkqAxome0d5v4LdhoDNAj98hINQiZeLS4nh93etcSrhEiFcI85vNx9HO0SK1cpopI4Mrg4eQtHkzisGA//TpuDa8948vW3TrajJrwg+TeDMNe2c7WvSuQOFSBbSOJUSekW/mLAnxJF57rihv1ysOwMjlR/jrvG2fWv9IYT3NZ8iZMmF5d0iNs0gZDwcPwhuF42HvwbGbx3h3x7u5YqQAgM5oJGDaVFxfeAE1M5OogQNJ+P0PrWM9Fs/CznR4JwyfoP/ZKbc7588IFEI8O2mWRJ7yzgtlebGCH5nZKm9/t49zMYlaR3p6igKtZoBHUYi7BL8OtNj6paJuRZneYDoGnYFNkZuYun+qRepYgmI04v/F57i1bAlZWVwZOpT4Nb9pHeuxOLkZaTOkCiWq/rNTbuFJ9shOOSFsjjRLIk/R6RS+6FSJ0KIFSEjL4o0Fe7mRmP7oH7RVjh7QcYH5VtyJVbBvnsVKVfWpyqe1PgVg4fGF/HT6J4vVymmKnR2FJ07AvW1byM7m6siRxP2yUutYj8XOqOeFN0Oo+kJRAPb9dpEN80+QlZnzBysLIZ6ONEsPILvhci8Hg565XcMo6uVE1O1U3ly0j9SMXPzG4x8KTcxzkVj/nnnxt4W0KN6C/pX7AzBuzzh2XtlpsVo5TdHr8fvsUzw6dQKTiWvvvcftn3JHw2feKVeCBl3MO+XO7r3O6mmHSE3K0DqaEAJZ4P1IssA797pwI4l2X/5JXEomL5T3YfZroeh1jzf53eaoKvzwCpxZD14l4a2tYO9qoVIq7+96n9XnV+NscObbZt9SxrOMRWpZgqqqXP9sHLe//x4Anw/ex/O11zRO9fgun7rF+q/NO+XcCjrSsl9FCvg6ax1LiFxHFngL8RiKF3RhbtcwjHodvx+/zri1J7WO9PQUBdp8CW7+cPMcrBlqsfVLiqIwtsZYqvlWIzkzmX6b+hGTEmORWpagKAo+o9/Ds0cPAK5/8ik3FyzUNtQTKFLWk/YjQnH1ciDhRiorJu3nymk5U04ILUmzJPK0asU8+bxTJQDm7Yzg2z8vahvoWTh5Qvt5oOjh6E9w8HuLlTLoDUytP5VibsW4nnKd/pv6k5KZe87fUxSFQiOG49X7bQBiJk4k9quvNU71+O7aKZeSxeoZhzglO+WE0Iw0SyLPe6lSYUa8YL6N9NGvx9l44rrGiZ5B0RrQcLT58doREGO5q2Xu9u7MbjwbTwdPTt46yTs73iHblHvWfimKQqHBg/EeOACAG9OmcWPmrFyz0+zfnXIlQwthylbZtPAke1bLTjkhtCDNksgX+tYvwSvVimBSYcAPBzkaFa91pKdXawgUbwBZqbDsDciw3BWfIq5FmN5gOkadka2Xt/L5vs8tVstSCvbtS6HhwwCIDQ/nxpSpuabhsDPqadqzPKHN/tkpt1Z2ygmhBWmWRL6gKAqftAmhTilvUjOz6fHtXq7EpWod6+nodNBuDrj4wI1TsG6kRctVLlSZz+p8BsD3J79nycklFq1nCV5vvonPu6MAuDl3LjETJuSahknRKTzfpgQNu/5np1yi7JQTwlqkWRL5hkGvI/y1qpT1deVGYjrdF/xNQlouPcTUpRC0/wZQ4OB3cMSyW+SbFWvGoKqDAJi4dyLbo7ZbtJ4leHbrhu+YDwG49e0irn/yCaopd0wqByhXszCtBlbC3smOa+fjWT5xH7ejk7WOJUS+IM3SA8icpbzJzcHA/DeqUcjVnjPXk+jz/X4ysnLPG+ZdgupCvXfMj9cMgdhzFi3XM6Qn7Uq1w6SaGL5tOKdunbJoPUso0Lkzfp99CorC7SU/ED1mDGp27rmlFVDWk/YjQ3HzdiAhNk12yglhJTJn6RFkzlLedOxKPJ2+/ouUjGw6hgYwqUNFFCUXzmAyZcOi1nBxB/hWgJ4bweBgsXKZpkz6bOzDnmt7KORYiMUvLsbX2ddi9SwlfvVqro56F0wmnGvVwvejjzAG+Gsd67GlJmaw9ssjRF9IQKdXqP9aWcrV9NM6lhA2ReYsCfGMQvzdmfVqFXQKLNsfRfgWy16VsRidHtrNBScviD4Kf7xv0XIGnYEp9adQwr0EMakx9NvUj6SMJIvWtAT3l17C/4vPUYxGknft4kKrVtz69ttcc5XJ0dVI6yFVKBlm3im3edFJjm6N0jqWEHmWNEsi32pY1oePXioPwOd/nGHlwSsaJ3pKbn7Qdo758d655jPkLFnO6MbsxrPxdvTmzO0zDN82nExT7lv75da8OUErV+IUFoaamsr18RO4+Epn0k6f1jraY7Ez6GnaozxVmgQCsP3HM5z6S2YxCWEJ0iyJfK1LjWK8Vbc4ACOXH2HPhZsaJ3pKpRpDrcHmx6sGwK0Ii5Yr7FKYWQ1n4WjnyK6ru/hs92e5ZnfZ/7IvHkTgom/x/fgjdK6upB09SkT7DsRMm4Yp3fYPYFZ0CjXalaBiwwAANi86ybn9uWfauhC5hTRLIt8b1awszUN8ycg28dZ3+zl/I/fdVgKg4fsQUB3S42F5D8iy7Nby8t7lmVR3EjpFx4qzK5h3bJ5F61mKotNRoFMniq9Zg2uTxpCVxc2vviaidRtS9u7VOt4jKYpC7Y6lCK7lh6rChnnHuXgkVutYQuQp0iyJfE+nU5j6cmWqBHoQn5pJ9wV7iU2y/asK99AboMM8cPCAqwdg00cWL1m/SH3eqWbekTf9wHTWR6y3eE1LMfgUImDmTPxnTMeuYEEyLl7kUpeuXBszluzERK3jPZSiKNR7rSylqvlgMqmsn3OMy6duaR1LiDxDmiUhAAeDnrldwwj0dCLyVgq9Fu0jLTdOSfYIhDazzY//mgWn11m85KvlXqVLcBcARu8czYHrByxe05Lcmjal+G9r8OjUCYC4pUu50OJFEjZs0DjZw+l0Co3eKEdQJW+ys0ysnX2Ea+fitI4lRJ4gzdIDyJyl/MfbxZ4F3avh7mjgYGQcQ5YewmTKfetwKPsiPNfH/HhlH4i3/C6pYaHDaBTYiAxTBgO3DORSwiWL17QkvZsbfh9/ROCibzEWLUrWjRtcGTCQqAEDyYyx3TVBer2OF94MITDYk6wME2tmHSbmUoLWsYTI9WTO0iPInKX8Z8+Fm3SZ97d5DVPd4rzXopzWkZ5cVjrMawrXDkGR5+GN30BvZ9GSqVmp9Py9J0djj1LEtQjft/geTwdPi9a0BlNaGrFffsXNefMgKwudqyuFRo7Ao0MHm53NlZmRzZqZh7l6Ng57ZzvaDq2Kl7+L1rGEsCqZsySEBT1X3IvJHSsCMGf7Bb7766K2gZ6GnT10XAD2bnB5N2wdZ/GSjnaOzGg4A38Xfy4nXmbg5oGkZaVZvK6l6RwcKDRkMEHLl+EQEoIpMZHoDz4ksms30iMsu+vwaRmMel7sVxGfIDfSk7NYNf0Qcdctd+CyEHmdNEtC3Efryv4Ma1IagDGrj7P51HWNEz0Fz+LQarr58Y4pcG6TxUt6O3ozu9FsXI2uHL5xmNE7R2NSc+lxMv/hULYsxZb+SKFR76A4OpKydy8RrdsQ+/Uc1EzbmzNldLCjZf9KeAW4kJqQwappB0m4mUsPjxZCY9IsCfEA/RuWpGNoACYV+i85yLEr8VpHenIh7SCsB6DCL29DYrTFSxb3KM70BtOx09nxx6U/mHZgmsVrWoui1+P1xhsU/3U1zrVqoWZkcGPqVCI6diL16DGt493DwdnASwMrU8DXiaTb6ayadojkuFy401MIjUmzJMQDKIrCuHYVqF3Sm5SMbHos3MvVuFz4l/kL48AnBJJvwM+9zOfJWVg132p8XPNjABYcW8BPp3+yeE1rMgYEUOSbuRSeOAG9uzvpp05x8eWXuT5xEqYU27rd5eRm5KVBVcyH795IZdX0Q6QmWnYGlxB5jTRLQjyEQa9j9utVKe3jQkxiOj0W7iUxzfZuuTyUwRE6LACDM0Rsh+2fW6VsqxKt6Fe5HwCf7fmM7VHbrVLXWhRFwb11a4qv/Q23li3BZOLWggVceKk1Sbt2aR3vLi4F7Gk9uAouBey5fS2Z1TMOkZ6Sy/53LISGpFkS4hHcHAzMf6MaBV3tORWdSN/FB8jMzmXrcAqWhpZTzI+3TYCIHVYp+3bFt2ldojUm1cTwbcM5efOkVepak52XF/6fT6bI119h5+dHZlQUl3u+ydV3RpF1+7bW8e5w83bkpUGVcXQ1EHs5iV9nHiYjLUvrWELkCtIsCfEYAgo4Mb9bNRwNenacjeWDlcdy31lolV6Byq+BaoIVb0Ky5Y/EUBSFMTXG8Jzfc6RmpdJ/U3+iky2/bkoLLvXqUfzXXynQpQsoCvGrVnHhxZbEr/nNZv63UsDXmZcGVcHeyY7rEQms/fIIWRm5cPiqEFYmzZIQj6lCgDszO1dBp8CPey8ze+t5rSM9uRaTwbs0JEWbF3ybLH+FzKA3MKX+FEp6lCQmNYa+m/qSlJFLz997BL2LM76j36PYD0uwL1WS7Fu3uDp8OFG9+5B59arW8QDwDnCh1cDKGBz0XDkdx7qvj5GdlcuulAphZdIsPYBM8Bb30zjYhzGtygMw+ffTrDp0ReNET8joDB0Xgp0DnNsIf86wSlk3oxvhjcLxdvTm7O2zDNs2jExT3l0z41i5MkErVuA9cACKwUDStm1caNmKW999j5qt/ZUcn2JutOxXCTuDjsjjN9kw7zim3HZrWQgrkgnejyATvMX9fLLmBPN2RmDU61jc6zmqFctlk6r3L4RfB4Gih+7rIPA5q5Q9fvM43dd3JzUrlfal2jOmxhibnYKdU9LPn+faBx+SesB8Zp5jpUr4ffoJ9qVKaZwMLp+4xZrZhzFlqZR+zofG3YJRdHn79yHyD5ngLYTG3mtRjhfK+5CRbaLXon1cuJHLbitV7QYh7UHNhhU9IcU6J9SX9yrPpLqT0Ck6Vpxdwbxj86xSV0v2JUpQ9Pvv8B3zITpnZ1IPH+ZCu/bcmDETU4a2W/iLBHvSrFcIOp3CmT3X2fbDaZtZXyWELZFmSYinoNcpTHu5CpWKeBCXkkn3hXu5mZSLhv0pCrScZp7yHX8ZVvUHK71J1i9Sn1HVRwEw/cB01l5Ya5W6WlJ0Ogp07kzx39bg0rAhZGYSO3s2EW3bkfLPFSetBFUqSOMewaDA8R1X2bX8nDRMQvyHNEtCPCVHo55vuoYRUMCRSzdT6LVoH2mZ2q9HeWwObub5S3ojnP4N9nxttdKdy3ama3BXAN7f9T77r++3Wm0tGXx9CQifhf+0qei9vck4f55Lr75G9Mcfk52k3dXJUmE+NHi9LACHN13m719t88w7IbQizZIQz6Cgqz0Lu1fDzcGOA5FxDPvpMCZTLvqrvHBlaPqZ+fEf78MV613lGBY2jMaBjck0ZTJoyyAi4vPHG7SiKLg1a0aJ39bg3qE9ALeX/MCFF1uSuHmLZrmCaxWmzsvm8xD3rb3Igd8vaZZFCFsjzZIQz6hkIVe+7hKGQa/w29FrTPz9lNaRnkz1XlC2JZgyYXl3SLPOGXg6Rce4OuOo6F2R+PR4+m7sy60066ydsgV6d3cKf/opgQsXYAgMJOv6daL69iVqyBCyYi0/A+t+KjYIoEbbEgD89ct5jmyJ0iSHELZGmiUhckCNEl5MbF8RgK+3XWDxnlz0V7miQOtZ4B4Ity+ad8lZac2Ko50jMxrOwN/Fn6ikKAZsHkBaVppVatsK5+efp/iqlXi92RP0ehLXref8iy2JW/GzJmuHqr5QlLAWxQDYsfQMJ/+0jflQQmhJmiUhcki7qgEMaWy+jfHhquNsOR2jcaIn4FgAOswHnR0c/wX2L7BaaS9HL2Y3no2b0Y0jN47w3s73MKn5a+aPztGRQsOHE7TsJxyCgzHFx3Nt9Ggie/QgIzLS6nmqtwqiUqMiAGz57hRn9123egYhbIk0S0LkoIGNStK+agDZJpX+iw9w/Kp1bmnliCLVoNEY8+N1oyD6mNVKF3cvzvQG0zHoDGy4tIGp+6darbYtcQgOpthPSyk0YgSKgwMpf+3mwkutuTlvHmqW9c5xUxSFWh1KElynMKoKG+efIOKINrcGhbAF0iwJkYMURWF8uwrUKO5FckY2PRbu5Vp8qtaxHl+N/lCqKWSnw7I3IN16O7TCfMP4pNYnACw8vpAfT/1otdq2RLGzw6tnD4qvXoVTjedR09KImfw5EZ06kXbihPVyKAr1O5eh9HM+mEwq6+cc5fLJ/LOmTIj/Jc2SEDnMaKfjqy6hlCrkwvWEdLov2EtiWi452kOngzZfgasf3DwLa4dbtfyLxV9kQJUBAIz/ezzbo7Zbtb4tMQYGEjh/Pn7jxqFzdyf9xEkiOnYi5vPPMaVapwFXdAqNupajeJWCmLJU1n55hKvn4qxSWwhbIs3SA8jZcOJZuDsamP9GNbxd7DkVnUi/JQfJzC1nbzl7Qft5oOjg8A9waIlVy/eq0Iu2JdtiUk0M3zacEzetdzXF1iiKgke7tpT4bQ1uLZpDdjY3v5nHhdZtSN692yoZdHodTXuWJ7C8F1kZJtbMOkzMpQSr1BbCVsjZcI8gZ8OJZ3H4chwvz/mLtEwTnasHMq5tSO45C23bZNjyKRic4K2tULCM1UpnmjLpu7Evu6/tpqBjQRa3WIyfi5/V6tuqxM1biP74Y7KiowFwb98On5Ej0bu7W7x2VkY2a2Yd5sqZOOyd7Wg7tCpe/i4WryvE05Kz4YTIJSoV8WDGK1VQFPjh70i+3n5B60iPr85QKF4fMlPM65cyrbf2yqAzMKX+FEp6lORG6g36bupLYkai1erbKteGDSi+5lcKvPoqKArxK37m/IstSVi/3uK17Yx6WvStiE+QG+nJWayadpC46ykWryuELZBmSQgLa1relw9bBgMwYd0p1hzJJXNrdHpoOwecC0HMCVg/yqrlXY2uzG40G29Hb87FnWPo1qFkmnLJ2i8L0ru44PvhBxRd/D3GEiXIjo3lyuAhXPtwDKZ0y55PaHSwo2X/SngXcSE1MZNV0w6SEJuLNjAI8ZSkWRLCCrrXCuKNmsUAGPrTYfZdzCW7ilx9oN0cQIH9C+HocquW93PxI7xROI52juy+tptPd38qh7z+w6lqVYJ++RmvPr1BUYj76ScuvfY6mVeuWLSug7OBlwZWpoCvE0m301k17SBJt3PRIdJCPAVploSwkg9aBtO4nA8ZWSbWHo3WOs7jK9EA6v6zK+7XQXDzvFXLB3sFM7nuZHSKjp/P/sw3R7+xan1bpjMaKTRoEEXmzEHv7k7asWNEtGtP0o6dFq3r6Gqk9eAquHk7kBCbxurpB0lJyLBoTSG0JM2SEFai1ynM6FyZ8e0q8EHLclrHeTL1RkFgTchIMq9fyrLulYR6RerxbvV3AZhxcAa/XfjNqvVtnUud2gT9vAKHkBCy4+O5/NZb3Jg9G9VkuR2Yzh72tB5cBZcC9tyOTmH1jEOkJcttUpE3SbMkhBU5Ge3oXD0w9+yI+5feDtp/A46eEH0E/vjA6hFeKfsK3YK7AfDBrg/YF73P6hlsmcHfn6JLFuPx8sugqsTOmMnlPn3IjouzWE03b0daD66Co5uRm1FJrJl1mIw0600aF8JapFkSQjwed39o+5X58d9fw8lfrR5haNhQmhRtQqYpk0FbBhERH2H1DLZMZzTi99FY/MaNQ7G3J3nbdiLad7Do5G8PHydaD6qMvbMd1yMS+C38CJkZ2RarJ4QWpFkSQjy+0i9ATfOEbVb1g6QbVi2vU3SMqz2OigUrkpCRQN+NfbmZetOqGXIDj3ZtKfbjDxiKFCHzyhUuvtKZuBU/W6yel78LLw2sjNFBz9Wzcaz/+ijZmblkCKsQj0GaJSHEk2k0BnwrQlo8bBxr9fIOdg7MaDCDAJcAopKiGLh5IGlZaVbPYescypUjaPkyXOrXR83I4Nro0Vz74EOLjRcoVNSNlv0rYWfUEXn8Fn/MO44pt0ytF+IRpFkSQjwZvQFe/ML8+ND3cPlvq0fwcvRiduPZuBndOBJ7hHd3vItJlTfm/9K7uxMwO5yCgweZxwssW8alV18jI8oy4wX8SnrQom9F9HY6Lhy6wcaFJzGZZNSDyP2kWRJCPLki1aHy6+bHa4eDyfprVILcg5jeYDoGnYGNkRuZsm+K1TPkBopOh3fv3hT5Zi56Dw/Sjh/nYvv2JO3YYZF6Rcp60uytEHQ6hbN7r7NtyWmZjSVyPWmWhBBPp/FYcHCHa4dh/wJNIoT5hvFJrU8A+PbEt/xw6gdNcuQGLrVqmccLVKjwz3iBt7kxK9wi4wWKVfSmcY9gFAVO7LzKzmVnpWESuZo0S0KIp+NSEBq8b3686WNIjtUkxovFX2RglYEATPh7Atsub9MkR25gKFyYoou/x+OVf8YLzJrF5d69LTJeoFSYDw26mOeJHdkcxZ7VuehcRCH+Q5qlBwgPDyc4OJhq1appHUUI2xXWA3wqaLbY+19vVniTdqXaYVJNjNg+guM3j2uWxdbpjEb8xo7Fb8J483iB7TuIaN+B1OM5/29WrqYfdV8pDcD+dZfYv/5ijtcQwhoUVa6NPlRCQgLu7u7Ex8fj5uamdRwhbE/kbpj/gvnxm5sgIEyTGJmmTPpt7Mdf1/7C29GbJS2W4Ofip0mW3CLt1CmiBgwk8/JlFKMR3w8/wKNDhxyvc+CPS/z1s/mYnNqdSlGpYZEcryHEf+Xk+7dcWRJCPJvA56FSZ/Pj34ZpstgbwKAz8EX9LyhVoBSxqbH03dSXxIxETbLkFg5lyxK0YjkuDRqYxwu8/wFX338/x8cLVG1alLAXiwGw86eznNh1NUdfXwhLk2ZJCPHsmnwM9m5w7RAc+FazGK5GV2Y3mk1Bx4KcizvHkK1DyMyW88oeRu/mRkD4LAoOHgw6HfHLV3Cp86tkREXlaJ3qLYOo3Nh8RWnL96c4szcXHSYt8j1ploQQz86lEDR4z/x408eQckuzKL7OvoQ3CsfRzpE91/bw8e6PZSfWI5jHC7xN4Ddz0RcoQNqJE0S070DS9u05V0NRqNm+JOXr+oMKGxec5MIh606AF+JpSbMkhMgZ1XpBofKQehs2faRplHJe5fi83ufoFB0rz61kzpE5mubJLZxr1iRoxXIcKlbEFB/P5bd7c2PmrBwbL6AoCvVeKU2Z53xRTSq/f3OMyONyXI2wfdIsCSFyht4OXvzc/Hj/t3DlgKZx6gbUZfRzowGYdWgWv563/sG/uZGhcGGKfv8dHp1fMY8XCA/n8tu9ybp9O0deX9EpNOxalhJVC2LKUln31VGuns2Z1xbCUqRZEkLknKI1oeLLgPrPZG9tjyDpVKYT3ct3B+DDPz9kb/ReTfPkFjqjEb8xYyg8cQKKgwPJO3ZwsX0HUo/lzHgBnV5Hkx7lKRriRVamiTXhR7gekZAjry2EJUizJITIWU0+BqMrXNkPB7/TOg2DQwfTpGgTskxZDNoyiAtxMhzxcbm3bk2xH3/AEBhI5tWrXHr1VW4vW5Yjr62309HsrRD8yxQgMy2bX2ceIjYqKUdeW4icJs2SECJnufpCg3fNjzeO1XSxN4BO0TGu9jgqFqxIYkYifTf1JTZVm2njuZFD2bIELV+GS8OGqBkZRH/wIVdHj8aUlvbMr21n1NOiTwV8i7uRnpLF6ukHSU3MyIHUQuQsaZaEEDmv+ltQsByk3oLNn2qdBgc7B2Y2nEmASwBXkq4wcPNAUrNStY6Va+jd3AiYNZOCQ4aYxwus+JmLr+bMeAGjgx0t+1fCu4gLFRsWwdHVmAOJhchZ0iwJIXKe3vD/i733zYerhzSNA+Dp4MmXjb/E3d6do7FHeXfHu2RrNEAzN1J0OrzffovAed+gL1CA9BMnzeMFtj37WXz2TgbajwwlrHmxZw8qhAVIsySEsIxitSGkA7ay2BugmHsxpjeYjkFnYFPkJr7Y/4XWkXId5xo1CPp5BQ6V/me8wIyZqNnP1njaGfQ5lFCInCfNkhDCcpp+CkYXiNoLh5donQaAUJ9QPq1lvjX43YnvWHxyscaJch+Dnx9Fv/uOAq+aj7mJnT07R8cLCGFrpFkSQliOmx/Ue8f8eMMY88BKG9CieAsGVR0EwMS/J7IpcpPGiXIfndGI74cfUnjSRPN4gZ07zeMFjh7TOpoQOU6aJSGEZT3fB7zLQEosbBmndZo7eob0pEPpDqiovLP9HQ7fOKx1pFzJ/aWXKLb0RwxF/2e8wE8/yREzIk+RZkkIYVl6A7SYbH689xu4dkTbPP9QFIXRz42mjn8d0rPTGbBpAJEJkVrHypUcypQhaNkyXBo1Qs3MJPrDMVwb/X6OjBcQwhZIsySEsLzi9aB8W1BNsHYE2MhVBzudHZ/X+5xgr2Bup9+mz8Y+3ErTdi5UbqV3cyNg5gwKDh1qHi/w8z/jBS5f1jqaEM9MmiUhhHU0/QwMznB5Nxz+Ues0dzgZnAhvFI6/iz+RiZEM2DyAtCy5IvI0FJ0O77d6mccLeHreGS+QuHWr1tGEeCbSLAkhrMPdH+qNMD/e8AGkxmka5395O3ozu9Fs3IxuHLlxhFE7RskMpmfw73gBx0qVMCUkENW7DzdmzHjm8QJCaEWaJSGE9TzfD7xKQfIN2Dpe6zR3Ke5RnBkNZ9yZwTR532RZpPwMDL6+FP1uEQVefRWA2Nlfcvmtt2W8gMiVpFkSQliPnRFaTDI//nsORNvWNvNQn1DG1Tbv2Ft8cjGLTizSOFHuphiN+H74AYUnTzKPF9i1i4j27Uk9elTraEI8EWmWHiA8PJzg4GCqVaumdRQh8pYSDaHcS/8s9h5uM4u9/9UsqBnDQocB8Pm+z/n94u8aJ8r93Fu1otjSpRiKBpJ19RqXXn2N20tlvIDIPRRV/tf6UAkJCbi7uxMfH4+bm5vWcYTIG+IuQ3h1yEyBtnOg0staJ7qLqqqM2zOOH0//iFFnZG7TuVT1qap1rFwvOzGRq+++S9JG8xBQ97Zt8R3zIToHB42TibwoJ9+/5cqSEML6PIpA3eHmxxs+gLQEbfP8h6IojKo+igZFGpBhymDgloFExEdoHSvX07u6EjBzJoWGDzOPF/jlFy52lvECwvZJsySE0EaN/uBZApKuw9YJWqe5h16nZ2LdiVT0rkh8ejx9NvYhNjVW61i5nqIoeL35JoHz55nHC5z8Z7zAli1aRxPigaRZEkJow87+/xd77/kKrp/QNs99ONo5MrPRTIq4FuFK0hX6b+pPSmaK1rHyBOfnn797vECfvsRMmybjBYRNkmZJCKGdko2hbEtQs21qsvf/8nTw5MvGX+Jh78Hxm8cZuX0kWaYsrWPlCXfGC7z+OgDxq1djSkzUOJUQ95JmSQihrWbjwc4RLu2EYyu0TnNfRd2KMrPhTOz19myL2saEvyfITq4cohiN+L4/msKTJxMwfTp6Dw+tIwlxD2mWhBDa8giEOuat+vzxPqTb5pWFyoUqM6HOBBQUlp5eyvxj87WOlKe4t2qJY4UKWscQ4r6kWRJCaK/mACgQBInXYNtErdM8UOOijRlZbSQA0w5M47cLv2mcSAhhDdIsCSG0Z3CA5v8s9t79JcSc0jbPQ7we/DpdgrsA8P6u99kbvVfjREIIS5NmSQhhG0o3hTItwJQF62xzsfe/hocNp0nRJmSZshi0eRDnbp/TOpIQwoKkWRJC2I5m48HOASK2w/FftE7zQDpFx/g646lSqAqJmYn03dSXmJQYrWMJISxEmiUhhO0oUAxqDzE//n00pCdpGudh7PX2zGgwg2JuxbiWfI1+m/qRnJmsdSwhhAVIsySEsC21BoFHUUi8Ctsna53moTwcPJjdeDaeDp6cunWKYVuHkWnK1DqWECKHSbMkhLAtBkdo/s+OuL/CIfastnkeoYhrEcIbheNo58iuq7v4dPenMoNJiDxGmiUhhO0p0xxKvQCmTJud7P2/QrxDmFR3EjpFx89nf+brI19rHUkIkYOkWRJC2KbmE0BvDxe2wMnVWqd5pPpF6vNe9fcACD8UzqpzqzROJITIKdIsCSFsk2dx8/olgPXvQYbtL55+uezL9AjpAcDYP8fy19W/NE4khMgJ0iwJIWxX7SHgHggJUbD9c63TPJZBVQfRPKg5WWoWQ7YO4fSt01pHEkI8I2mWhBC2y+hkvh0H8OdMiLX94Y86RcentT4lzCeM5Mxk+m7qS3RytNaxhBDPQJolIYRtK9MCSjYxL/ZeN9LmF3sDGPVGpjWYRgn3EsSkxNB3U18SM2zzgGAhxKNJsySEsG2KYh4loDfC+U1wao3WiR6Lu707sxvPxtvRm7O3zzJk6xAys2UGkxC5kTRLQgjb51UCag40P17/LmSkaJvnMRV2KczsRrNxtHNkz7U9jP1rrMxgEiIXkmZJCJE71BkG7kUg/jLsnKJ1msdWzqscU+pPQa/oWX1+NeGHwrWOJIR4QtIsCSFyB6MTvDDO/HjXdLh5Xts8T6C2f20+rPEhAF8f+ZoVZ1ZonEgI8SSkWRJC5B7lWkGJhpCdAetH5YrF3v9qV6odb1d8G4BPdn/CjqgdGicSQjwuaZaEELmHokDzyaAzwNk/4PQ6rRM9kX6V+/FSiZfIVrMZtm0YJ26e0DqSEOIxSLMkhMhdvEtCzf7mx+vfgcxUbfM8AUVRGFtjLM/7PU9qVir9NvXjatJVrWMJIR5BmiUhRO5TdwS4+UNcJOycpnWaJ2LQG5hSfwqlCpQiNjWWPhv7EJ8er3UsIcRDSLMkhMh9jM7wwmfmxzunwq0IbfM8IVejK7MbzaaQUyEuxF9g8JbBZGRnaB1LCPEA0iwJIXKn4DYQVA+y082zl3IZX2dfZjeajYvBhX3X9/H+zvcxqSatYwkh7iPPN0uJiYlUq1aNypUrU6FCBebOnat1JCFETlAUaDEZdHZwZh2c+V3rRE+sjGcZpjaYip1ix7qL65h+YLrWkYQQ95HnmyUnJye2bdvGoUOH2LNnD+PHj+fmzZtaxxJC5ISCZeD5vubH60ZCZpq2eZ7C837P81GtjwCYf2w+S08t1TiREOK/8nyzpNfrcXJyAiAtLY3s7Gw5bkCIvKTeSHD1g9sX4c8ZWqd5Ki+VeIn+lc07/Mb9PY6tl7dqmkcIcTfNm6Xt27fTqlUrChcujKIorFy58p7vmT17NkFBQTg4OBAaGsqOHU82zC0uLo5KlSoREBDAyJEj8fb2zqH0QgjN2btC00/Nj3d8AbcvaZvnKb1V8S3al2qPSTUxcvtIjsUe0zqSEOIfmjdLycnJVKpUiVmzZt3360uXLmXw4MGMHj2agwcPUqdOHZo3b05kZOSd7wkNDSUkJOSej6tXzfNLPDw8OHz4MBERESxZsoTr169b5b9NCGElIe2hWB3ISoPf39M6zVNRFIXRz4+mln+tOzOYLide1jqWEAJQVBu6J6UoCr/88gtt2rS589xzzz1H1apV+fLLL+88V65cOdq0acP48eOfuEafPn1o2LAhHTt2vO/X09PTSU9Pv/N5fHw8gYGBXL58GTc3tyeuJ4SwkhunYd4LoGZBp0XmY1FyoeTMZPpu7Mvp26cJdA1kTpM5eDh4aB1LiFwnISGBIkWKEBcXh7u7+7O9mGpDAPWXX36583l6erqq1+vVn3/++a7vGzhwoFq3bt3Hes3o6Gg1Pj5eVVVVjY+PV4ODg9XDhw8/8PvHjBmjAvIhH/IhH/IhH/KRBz7Onz//5A3Jf9hhw2JjY8nOzsbHx+eu5318fIiOjn6s14iKiqJnz56oqoqqqvTv35+KFSs+8Pvfffddhg4deufzuLg4ihYtSmRk5LN3puKZ/PtXglzl0578LmyH/C5sh/wubMu/d4Y8PT2f+bVsuln6l6Iod32uquo9zz1IaGgohw4deuxa9vb22Nvb3/O8u7u7/I/fRri5ucnvwkbI78J2yO/CdsjvwrbodM++PFvzBd4P4+3tjV6vv+cqUkxMzD1Xm4QQQgghLMGmmyWj0UhoaCgbNmy46/kNGzZQs2ZNjVIJIYQQIj/R/DZcUlIS586du/N5REQEhw4dwtPTk8DAQIYOHUqXLl0ICwujRo0azJkzh8jISHr37m2VfPb29owZM+a+t+aEdcnvwnbI78J2yO/Cdsjvwrbk5O9D89EBW7dupUGDBvc8361bNxYuXAiYh1JOmjSJa9euERISwtSpU6lbt66VkwohhBAiP9K8WRJCCCGEsGU2vWZJCCGEEEJr0iwJIYQQQjyENEtCCCGEEA8hzdJDzJ49m6CgIBwcHAgNDWXHjh1aR8p3xo8fT7Vq1XB1daVQoUK0adOG06dPax1LYP7dKIrC4MGDtY6Sb125coXXX38dLy8vnJycqFy5Mvv379c6Vr6TlZXF+++/T1BQEI6OjhQvXpyPP/4Yk8mkdbQ8b/v27bRq1YrChQujKAorV6686+uqqjJ27FgKFy6Mo6Mj9evX5/jx409cR5qlB1i6dCmDBw9m9OjRHDx4kDp16tC8eXMiIyO1jpavbNu2jX79+rF79242bNhAVlYWTZs2JTk5Weto+drevXuZM2fOQ48OEpZ1+/ZtatWqhcFgYN26dZw4cYIvvvgCDw8PraPlOxMnTuSrr75i1qxZnDx5kkmTJjF58mRmzpypdbQ8Lzk5mUqVKjFr1qz7fn3SpElMmTKFWbNmsXfvXnx9fWnSpAmJiYlPVuiZT5fLo6pXr6727t37rufKli2rjho1SqNEQlVVNSYmRgXUbdu2aR0l30pMTFRLlSqlbtiwQa1Xr546aNAgrSPlS++8845au3ZtrWMIVVVffPFFtUePHnc9165dO/X111/XKFH+BKi//PLLnc9NJpPq6+urTpgw4c5zaWlpqru7u/rVV1890WvLlaX7yMjIYP/+/TRt2vSu55s2bcqff/6pUSoB5oMRgRw5GFE8nX79+vHiiy/SuHFjraPka6tXryYsLIyOHTtSqFAhqlSpwty5c7WOlS/Vrl2bTZs2cebMGQAOHz7Mzp07adGihcbJ8reIiAiio6Pvei+3t7enXr16T/xervkEb1sUGxtLdnb2PefP+fj43HNOnbAeVVUZOnQotWvXJiQkROs4+dKPP/7IgQMH2Lt3r9ZR8r0LFy7w5ZdfMnToUN577z3+/vtvBg4ciL29PV27dtU6Xr7yzjvvEB8fT9myZdHr9WRnZ/PZZ5/RuXNnraPla/++X9/vvfzSpUtP9FrSLD2Eoih3fa6q6j3PCevp378/R44cYefOnVpHyZcuX77MoEGD+OOPP3BwcNA6Tr5nMpkICwtj3LhxAFSpUoXjx4/z5ZdfSrNkZUuXLuX7779nyZIllC9fnkOHDjF48GAKFy5Mt27dtI6X7+XEe7k0S/fh7e2NXq+/5ypSTEzMPR2qsI4BAwawevVqtm/fTkBAgNZx8qX9+/cTExNDaGjoneeys7PZvn07s2bNIj09Hb1er2HC/MXPz4/g4OC7nitXrhwrVqzQKFH+NWLECEaNGsUrr7wCQIUKFbh06RLjx4+XZklDvr6+gPkKk5+f353nn+a9XNYs3YfRaCQ0NJQNGzbc9fyGDRuoWbOmRqnyJ1VV6d+/Pz///DObN28mKChI60j5VqNGjTh69CiHDh268xEWFsZrr73GoUOHpFGyslq1at0zRuPMmTMULVpUo0T5V0pKCjrd3W+ner1eRgdoLCgoCF9f37veyzMyMti2bdsTv5fLlaUHGDp0KF26dCEsLIwaNWowZ84cIiMj6d27t9bR8pV+/fqxZMkSVq1ahaur652rfe7u7jg6OmqcLn9xdXW9Z62Ys7MzXl5esoZMA0OGDKFmzZqMGzeOTp068ffffzNnzhzmzJmjdbR8p1WrVnz22WcEBgZSvnx5Dh48yJQpU+jRo4fW0fK8pKQkzp07d+fziIgIDh06hKenJ4GBgQwePJhx48ZRqlQpSpUqxbhx43BycuLVV199skI5sV0vrwoPD1eLFi2qGo1GtWrVqrJdXQPAfT8WLFigdTShqjI6QGO//vqrGhISotrb26tly5ZV58yZo3WkfCkhIUEdNGiQGhgYqDo4OKjFixdXR48eraanp2sdLc/bsmXLfd8junXrpqqqeXzAmDFjVF9fX9Xe3l6tW7euevTo0Seuo6iqquZEdyeEEEIIkRfJmiUhhBBCiIeQZkkIIYQQ4iGkWRJCCCGEeAhploQQQgghHkKaJSGEEEKIh5BmSQghhBDiIaRZEkIIIYR4CGmWhBDiPsaOHUvlypWtUqt+/foMHjzYKrWEEE9OmiUhhLCSrVu3oigKcXFxWkcRQjwBaZaEEFaVkZFhkddVVZWsrCyLvLYQIn+TZkkIYVH169enf//+DB06FG9vb5o0aQLAiRMnaNGiBS4uLvj4+NClSxdiY2Pv/Fx6ejoDBw6kUKFCODg4ULt2bfbu3Xvn6/9epfn9998JCwvD3t6eHTt2kJiYyGuvvYazszN+fn5MnTr1sW5zTZgwAR8fH1xdXenZsydpaWn3fM+CBQsoV64cDg4OlC1bltmzZ9/52sWLF1EUhR9//JGaNWvi4OBA+fLl2bp1652vN2jQAIACBQqgKApvvPHGnZ83mUyMHDkST09PfH19GTt27BP+SwshLCYnD7QTQoj/qlevnuri4qKOGDFCPXXqlHry5En16tWrqre3t/ruu++qJ0+eVA8cOKA2adJEbdCgwZ2fGzhwoFq4cGF17dq16vHjx9Vu3bqpBQoUUG/evKmq6v8foFmxYkX1jz/+UM+dO6fGxsaqb775plq0aFF148aN6tGjR9W2bduqrq6uDz3wd+nSparRaFTnzp2rnjp1Sh09erTq6uqqVqpU6c73zJkzR/Xz81NXrFihXrhwQV2xYoXq6empLly4UFVVVY2IiFABNSAgQF2+fLl64sQJ9c0331RdXV3V2NhYNSsrS12xYoUKqKdPn1avXbumxsXF3fk3cnNzU8eOHaueOXNG/fbbb1VFUdQ//vgj538hQognJs2SEMKi6tWrp1auXPmu5z744AO1adOmdz13+fLlO41EUlKSajAY1MWLF9/5ekZGhlq4cGF10qRJqqr+f7O0cuXKO9+TkJCgGgwGddmyZXeei4uLU52cnB7aLNWoUUPt3bv3Xc8999xzdzVLRYoUUZcsWXLX93zyySdqjRo1VFX9/2ZpwoQJd76emZmpBgQEqBMnTrwr8+3bt+/5N6pdu/Zdz1WrVk195513HphZCGE9dhpe1BJC5BNhYWF3fb5//362bNmCi4vLPd97/vx50tLSyMzMpFatWneeNxgMVK9enZMnTz7wtS9cuEBmZibVq1e/85y7uztlypR5aL6TJ0/Su3fvu56rUaMGW7ZsAeDGjRtcvnyZnj170qtXrzvfk5WVhbu7+z0/9y87OzvCwsLuyXw/FStWvOtzPz8/YmJiHvlzQgjLk2ZJCGFxzs7Od31uMplo1aoVEydOvOd7/fz8OHfuHACKotz1NVVV73nuf19bVdUH/tyzMJlMAMydO5fnnnvurq/p9fpH/vx/89yPwWC452f+rSuE0JYs8BZCWF3VqlU5fvw4xYoVo2TJknd9ODs7U7JkSYxGIzt37rzzM5mZmezbt49y5co98HVLlCiBwWDg77//vvNcQkICZ8+efWiecuXKsXv37rue+9/PfXx88Pf358KFC/fkDQoKeuDPZWVlsX//fsqWLQuA0WgEIDs7+6F5hBC2Ra4sCSGsrl+/fsydO5fOnTszYsQIvL29OXfuHD/++CNz587F2dmZPn36MGLECDw9PQkMDGTSpEmkpKTQs2fPB76uq6sr3bp1u/NzhQoVYsyYMeh0uode3Rk0aBDdunUjLCyM2rVrs3jxYo4fP07x4sXvfM/YsWMZOHAgbm5uNG/enPT0dPbt28ft27cZOnTone8LDw+nVKlSlCtXjqlTp3L79m169OgBQNGiRVEUhTVr1tCiRQscHR3veytSCGFb5MqSEMLqChcuzK5du8jOzuaFF14gJCSEQYMG4e7ujk5n/n9LEyZMoH379nTp0oWqVaty7tw5fv/9dwoUKPDQ154yZQo1atSgZcuWNG7cmFq1at3Z7v8gL7/8Mh9++CHvvPMOoaGhXLp0iT59+tz1PW+++SbffPMNCxcupEKFCtSrV4+FCxfec2VpwoQJTJw4kUqVKrFjxw5WrVqFt7c3AP7+/nz00UeMGjUKHx8f+vfv/zT/fEIIK1PUZ72ZL4QQNiw5ORl/f3+++OKLh16VelYXL14kKCiIgwcPWu2YFCGEdchtOCFEnnLw4EFOnTpF9erViY+P5+OPPwagdevWGicTQuRW0iwJIfKczz//nNOnT2M0GgkNDWXHjh13boUJIcSTkttwQgghhBAPIQu8hRBCCCEeQpolIYQQQoiHkGZJCCGEEOIhpFkSQgghhHgIaZaEEEIIIR5CmiUhhBBCiIeQZkkIIYQQ4iGkWRJCCCGEeAhploQQQgghHuL/ANp+2U/IX2L5AAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -666,26 +823,24 @@
     }
    ],
    "source": [
-    "for s in range(len(sims)):\n",
-    "    max_depth = advs[s].max()\n",
-    "    count_by_depth = np.zeros(max_depth)\n",
-    "    for d in range(max_depth):\n",
-    "        count_by_depth[d] = (advs[s] == d).sum() / (sims[s].params.SLOTS * sims[s].params.f)\n",
-    "    plt.plot(np.arange(max_depth), count_by_depth, label=f\"E[mixnet_delay]={sims[s].network.mixnet_delay_mean:.1f}s\")\n",
+    "MAX=min(40, max(max(adv) for adv in advs))\n",
     "\n",
-    "_ = plt.title(f\"reorg depth sensitivity to mixnet delay @ {1/sims[s].params.f:.0f}s block time\")\n",
+    "for s in range(len(sims)):\n",
+    "    reorg_depth_analysis(sims[s], advs[s], MAX, label=f\"blending_delay={sims[s].network.blending_delay}s\")\n",
+    "\n",
+    "_ = plt.title(f\"reorg depth sensitivity to blend network delay @ {1/sims[s].params.f:.0f}s block time\")\n",
     "_ = plt.xlabel(\"reorg depth\")\n",
     "_ = plt.ylabel(\"frequency\")\n",
     "_ = plt.legend()\n",
     "_ = plt.yscale(\"log\")\n",
-    "_ = plt.xlim(0, 25)\n",
-    "_ = plt.ylim(10**-3,10**0)\n",
+    "_ = plt.xlim(0, MAX)\n",
+    "_ = plt.ylim(10**-4,None)\n",
     "# _ = plt."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 492,
+   "execution_count": 16,
    "id": "8c9a369c-2d55-4c07-8bfe-9e270cfed90a",
    "metadata": {},
    "outputs": [
@@ -693,141 +848,262 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "simulating 1/4\n",
-      "simulating 2/4\n",
-      "simulating 3/4\n",
-      "simulating 4/4\n",
+      "simulating 1/5\n",
+      "leader\t17.13s\n",
+      "emit\t2.32s\n",
+      "slot\t19.46s\n",
+      "forkchoice\t0.29s\n",
+      "emit_leader_block\t0.43s\n",
+      "prep\t0.00s\n",
+      "total\t19.62s\n",
+      "simulating 2/5\n",
+      "leader\t16.95s\n",
+      "emit\t2.25s\n",
+      "slot\t19.20s\n",
+      "forkchoice\t0.28s\n",
+      "emit_leader_block\t0.38s\n",
+      "prep\t0.00s\n",
+      "total\t19.37s\n",
+      "simulating 3/5\n",
+      "leader\t16.92s\n",
+      "emit\t2.26s\n",
+      "slot\t19.18s\n",
+      "forkchoice\t0.28s\n",
+      "emit_leader_block\t0.41s\n",
+      "prep\t0.00s\n",
+      "total\t19.34s\n",
+      "simulating 4/5\n",
+      "leader\t17.43s\n",
+      "emit\t2.41s\n",
+      "slot\t19.84s\n",
+      "forkchoice\t0.30s\n",
+      "emit_leader_block\t0.49s\n",
+      "prep\t0.00s\n",
+      "total\t20.01s\n",
+      "simulating 5/5\n",
+      "leader\t17.40s\n",
+      "emit\t2.46s\n",
+      "slot\t19.86s\n",
+      "forkchoice\t0.30s\n",
+      "emit_leader_block\t0.52s\n",
+      "prep\t0.00s\n",
+      "total\t20.03s\n",
       "finished simulation, starting analysis\n",
-      "Processing block Block(id=1000, slot=6363, height=320, parent=996, leader=23)\n",
-      "Processing block Block(id=2000, slot=12555, height=639, parent=1993, leader=84)\n",
-      "Processing block Block(id=3000, slot=18477, height=952, parent=2996, leader=17)\n",
-      "Processing block Block(id=4000, slot=25149, height=1282, parent=3996, leader=20)\n",
-      "Processing block Block(id=5000, slot=31501, height=1599, parent=4998, leader=56)\n",
-      "Processing block Block(id=6000, slot=37990, height=1919, parent=5991, leader=8)\n",
-      "Processing block Block(id=7000, slot=44481, height=2251, parent=6997, leader=27)\n",
-      "Processing block Block(id=8000, slot=50868, height=2578, parent=7992, leader=36)\n",
-      "Processing block Block(id=9000, slot=57212, height=2896, parent=8996, leader=8)\n",
-      "Processing block Block(id=10000, slot=63774, height=3230, parent=9996, leader=52)\n",
-      "Processing block Block(id=11000, slot=70157, height=3546, parent=10993, leader=0)\n",
-      "Processing block Block(id=12000, slot=76603, height=3862, parent=11988, leader=23)\n",
-      "Processing block Block(id=13000, slot=82834, height=4181, parent=12995, leader=85)\n",
-      "Processing block Block(id=14000, slot=89666, height=4523, parent=13994, leader=62)\n",
-      "Processing block Block(id=15000, slot=95882, height=4848, parent=14996, leader=7)\n",
-      "Processing block Block(id=16000, slot=102488, height=5177, parent=15997, leader=8)\n",
-      "Processing block Block(id=17000, slot=108773, height=5491, parent=16995, leader=5)\n",
-      "Processing block Block(id=18000, slot=115521, height=5820, parent=17993, leader=89)\n",
-      "Processing block Block(id=19000, slot=121882, height=6133, parent=18994, leader=68)\n",
-      "Processing block Block(id=20000, slot=128075, height=6448, parent=19990, leader=35)\n",
-      "Processing block Block(id=21000, slot=134265, height=6774, parent=20996, leader=10)\n",
-      "Processing block Block(id=22000, slot=140656, height=7092, parent=21995, leader=98)\n",
-      "Processing block Block(id=23000, slot=146896, height=7405, parent=22997, leader=50)\n",
-      "Processing block Block(id=1000, slot=13599, height=507, parent=995, leader=38)\n",
-      "Processing block Block(id=2000, slot=27183, height=999, parent=1999, leader=85)\n",
-      "Processing block Block(id=3000, slot=40799, height=1491, parent=2995, leader=45)\n",
-      "Processing block Block(id=4000, slot=53827, height=1978, parent=3995, leader=20)\n",
-      "Processing block Block(id=5000, slot=66897, height=2473, parent=4994, leader=6)\n",
-      "Processing block Block(id=6000, slot=80538, height=2985, parent=5999, leader=19)\n",
-      "Processing block Block(id=7000, slot=94047, height=3485, parent=6996, leader=73)\n",
-      "Processing block Block(id=8000, slot=107291, height=3990, parent=7999, leader=10)\n",
-      "Processing block Block(id=9000, slot=120394, height=4502, parent=8998, leader=52)\n",
-      "Processing block Block(id=10000, slot=134175, height=5014, parent=9999, leader=70)\n",
-      "Processing block Block(id=11000, slot=147463, height=5517, parent=10997, leader=73)\n",
-      "Processing block Block(id=12000, slot=160780, height=6014, parent=11998, leader=21)\n",
-      "Processing block Block(id=13000, slot=174393, height=6517, parent=12999, leader=49)\n",
-      "Processing block Block(id=14000, slot=187294, height=6991, parent=13999, leader=17)\n",
-      "Processing block Block(id=15000, slot=201132, height=7503, parent=14999, leader=37)\n",
-      "Processing block Block(id=16000, slot=214289, height=7998, parent=15997, leader=23)\n",
-      "Processing block Block(id=17000, slot=227195, height=8491, parent=16999, leader=38)\n",
-      "Processing block Block(id=18000, slot=240271, height=8990, parent=17997, leader=13)\n",
-      "Processing block Block(id=19000, slot=254358, height=9507, parent=18998, leader=70)\n",
-      "Processing block Block(id=20000, slot=267926, height=10010, parent=19996, leader=19)\n",
-      "Processing block Block(id=21000, slot=281002, height=10497, parent=20999, leader=20)\n",
-      "Processing block Block(id=22000, slot=294406, height=10999, parent=21999, leader=32)\n",
-      "Processing block Block(id=1000, slot=27987, height=680, parent=999, leader=42)\n",
-      "Processing block Block(id=2000, slot=54664, height=1341, parent=1999, leader=8)\n",
-      "Processing block Block(id=3000, slot=81950, height=2006, parent=2999, leader=38)\n",
-      "Processing block Block(id=4000, slot=108979, height=2670, parent=3995, leader=38)\n",
-      "Processing block Block(id=5000, slot=136878, height=3343, parent=4999, leader=40)\n",
-      "Processing block Block(id=6000, slot=163748, height=4015, parent=5998, leader=70)\n",
-      "Processing block Block(id=7000, slot=192675, height=4698, parent=6999, leader=68)\n",
-      "Processing block Block(id=8000, slot=221466, height=5369, parent=7999, leader=1)\n",
-      "Processing block Block(id=9000, slot=248970, height=6030, parent=8999, leader=93)\n",
-      "Processing block Block(id=10000, slot=277928, height=6714, parent=9998, leader=66)\n",
-      "Processing block Block(id=11000, slot=305384, height=7372, parent=10999, leader=42)\n",
-      "Processing block Block(id=12000, slot=332509, height=8051, parent=11997, leader=92)\n",
-      "Processing block Block(id=13000, slot=359097, height=8708, parent=12998, leader=19)\n",
-      "Processing block Block(id=14000, slot=387363, height=9366, parent=13997, leader=33)\n",
-      "Processing block Block(id=15000, slot=414827, height=10023, parent=14995, leader=17)\n",
-      "Processing block Block(id=16000, slot=442300, height=10693, parent=15999, leader=89)\n",
-      "Processing block Block(id=17000, slot=470243, height=11365, parent=16999, leader=8)\n",
-      "Processing block Block(id=18000, slot=499093, height=12056, parent=17998, leader=83)\n",
-      "Processing block Block(id=19000, slot=526688, height=12721, parent=18999, leader=89)\n",
-      "Processing block Block(id=20000, slot=555973, height=13410, parent=19998, leader=38)\n",
-      "Processing block Block(id=21000, slot=583015, height=14057, parent=20998, leader=70)\n",
-      "Processing block Block(id=1000, slot=42927, height=756, parent=999, leader=21)\n",
-      "Processing block Block(id=2000, slot=84798, height=1524, parent=1999, leader=21)\n",
-      "Processing block Block(id=3000, slot=126990, height=2279, parent=2999, leader=35)\n",
-      "Processing block Block(id=4000, slot=168468, height=3022, parent=3999, leader=86)\n",
-      "Processing block Block(id=5000, slot=211518, height=3781, parent=4998, leader=13)\n",
-      "Processing block Block(id=6000, slot=254462, height=4515, parent=5999, leader=7)\n",
-      "Processing block Block(id=7000, slot=297291, height=5284, parent=6997, leader=30)\n",
-      "Processing block Block(id=8000, slot=337460, height=6021, parent=7999, leader=68)\n",
-      "Processing block Block(id=9000, slot=379964, height=6780, parent=8999, leader=4)\n",
-      "Processing block Block(id=10000, slot=421773, height=7525, parent=9997, leader=74)\n",
-      "Processing block Block(id=11000, slot=463452, height=8279, parent=10999, leader=2)\n",
-      "Processing block Block(id=12000, slot=508227, height=9044, parent=11999, leader=42)\n",
-      "Processing block Block(id=13000, slot=551336, height=9812, parent=12998, leader=4)\n",
-      "Processing block Block(id=14000, slot=593129, height=10575, parent=13997, leader=70)\n",
-      "Processing block Block(id=15000, slot=633453, height=11328, parent=14999, leader=13)\n",
-      "Processing block Block(id=16000, slot=674863, height=12062, parent=15999, leader=38)\n",
-      "Processing block Block(id=17000, slot=714726, height=12815, parent=16999, leader=68)\n",
-      "Processing block Block(id=18000, slot=757976, height=13567, parent=17998, leader=45)\n",
-      "Processing block Block(id=19000, slot=799790, height=14311, parent=18998, leader=17)\n",
-      "Processing block Block(id=20000, slot=841233, height=15063, parent=19997, leader=52)\n",
-      "Processing block Block(id=21000, slot=881361, height=15808, parent=20998, leader=89)\n"
+      "Processing block Block(id=5000, slot=295115, height=4478, parent=np.int64(4999), leader=np.int64(924))\n",
+      "Processing block Block(id=10000, slot=579425, height=8965, parent=np.int64(9999), leader=np.int64(472))\n",
+      "Processing block Block(id=15000, slot=869955, height=13467, parent=np.int64(14999), leader=np.int64(210))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t1.24s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t11.99s\n",
+      "reorg_depth\t4.60s\n",
+      "depth_append\t6.41s\n",
+      "Processing block Block(id=5000, slot=287253, height=4496, parent=np.int64(4999), leader=np.int64(716))\n",
+      "Processing block Block(id=10000, slot=576285, height=8998, parent=np.int64(9999), leader=np.int64(677))\n",
+      "Processing block Block(id=15000, slot=864933, height=13485, parent=np.int64(14998), leader=np.int64(172))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t1.52s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t11.31s\n",
+      "reorg_depth\t4.52s\n",
+      "depth_append\t6.44s\n",
+      "Processing block Block(id=5000, slot=286124, height=4486, parent=np.int64(4999), leader=np.int64(23))\n",
+      "Processing block Block(id=10000, slot=577264, height=9004, parent=np.int64(9999), leader=np.int64(451))\n",
+      "Processing block Block(id=15000, slot=870737, height=13510, parent=np.int64(14999), leader=np.int64(293))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t1.58s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t10.31s\n",
+      "reorg_depth\t4.34s\n",
+      "depth_append\t6.28s\n",
+      "Processing block Block(id=5000, slot=289500, height=4485, parent=np.int64(4999), leader=np.int64(185))\n",
+      "Processing block Block(id=10000, slot=579978, height=8984, parent=np.int64(9999), leader=np.int64(119))\n",
+      "Processing block Block(id=15000, slot=883026, height=13524, parent=np.int64(14998), leader=np.int64(617))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t1.39s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t10.64s\n",
+      "reorg_depth\t4.41s\n",
+      "depth_append\t6.32s\n",
+      "Processing block Block(id=5000, slot=290896, height=4530, parent=np.int64(4999), leader=np.int64(746))\n",
+      "Processing block Block(id=10000, slot=588507, height=9046, parent=np.int64(9999), leader=np.int64(982))\n",
+      "Processing block Block(id=15000, slot=876733, height=13547, parent=np.int64(14998), leader=np.int64(839))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t1.34s\n",
+      "nearest_honest\t0.03s\n",
+      "reorg_events\t11.18s\n",
+      "reorg_depth\t4.41s\n",
+      "depth_append\t6.31s\n",
+      "cardano parameters\n",
+      "simulating 1/5\n",
+      "leader\t11.67s\n",
+      "emit\t32.71s\n",
+      "slot\t44.38s\n",
+      "forkchoice\t31.16s\n",
+      "emit_leader_block\t0.46s\n",
+      "prep\t0.01s\n",
+      "total\t44.50s\n",
+      "simulating 2/5\n",
+      "leader\t11.29s\n",
+      "emit\t32.47s\n",
+      "slot\t43.76s\n",
+      "forkchoice\t31.02s\n",
+      "emit_leader_block\t0.41s\n",
+      "prep\t0.00s\n",
+      "total\t43.87s\n",
+      "simulating 3/5\n",
+      "leader\t11.23s\n",
+      "emit\t1.76s\n",
+      "slot\t13.00s\n",
+      "forkchoice\t0.29s\n",
+      "emit_leader_block\t0.43s\n",
+      "prep\t0.00s\n",
+      "total\t13.11s\n",
+      "simulating 4/5\n",
+      "leader\t11.23s\n",
+      "emit\t1.70s\n",
+      "slot\t12.93s\n",
+      "forkchoice\t0.27s\n",
+      "emit_leader_block\t0.37s\n",
+      "prep\t0.00s\n",
+      "total\t13.04s\n",
+      "simulating 5/5\n",
+      "leader\t11.20s\n",
+      "emit\t1.72s\n",
+      "slot\t12.92s\n",
+      "forkchoice\t0.28s\n",
+      "emit_leader_block\t0.39s\n",
+      "prep\t0.00s\n",
+      "total\t13.03s\n",
+      "Processing block Block(id=5000, slot=196522, height=4914, parent=np.int64(4999), leader=np.int64(641))\n",
+      "Processing block Block(id=10000, slot=383562, height=9832, parent=np.int64(9999), leader=np.int64(526))\n",
+      "Processing block Block(id=15000, slot=577797, height=14739, parent=np.int64(14999), leader=np.int64(289))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.99s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t5.51s\n",
+      "reorg_depth\t0.60s\n",
+      "depth_append\t0.44s\n",
+      "Processing block Block(id=5000, slot=190152, height=4908, parent=np.int64(4999), leader=np.int64(616))\n",
+      "Processing block Block(id=10000, slot=383390, height=9810, parent=np.int64(9999), leader=np.int64(395))\n",
+      "Processing block Block(id=15000, slot=579086, height=14731, parent=np.int64(14999), leader=np.int64(465))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.88s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t5.92s\n",
+      "reorg_depth\t0.71s\n",
+      "depth_append\t0.65s\n",
+      "Processing block Block(id=5000, slot=189522, height=4924, parent=np.int64(4999), leader=np.int64(8))\n",
+      "Processing block Block(id=10000, slot=378916, height=9838, parent=np.int64(9999), leader=np.int64(478))\n",
+      "Processing block Block(id=15000, slot=569140, height=14742, parent=np.int64(14999), leader=np.int64(599))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.88s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t5.65s\n",
+      "reorg_depth\t0.55s\n",
+      "depth_append\t0.30s\n",
+      "Processing block Block(id=5000, slot=188484, height=4922, parent=np.int64(4999), leader=np.int64(774))\n",
+      "Processing block Block(id=10000, slot=381539, height=9826, parent=np.int64(9999), leader=np.int64(216))\n",
+      "Processing block Block(id=15000, slot=572719, height=14758, parent=np.int64(14999), leader=np.int64(263))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.93s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t5.36s\n",
+      "reorg_depth\t0.60s\n",
+      "depth_append\t0.43s\n",
+      "Processing block Block(id=5000, slot=192729, height=4922, parent=np.int64(4999), leader=np.int64(300))\n",
+      "Processing block Block(id=10000, slot=386016, height=9850, parent=np.int64(9999), leader=np.int64(595))\n",
+      "Processing block Block(id=15000, slot=579762, height=14770, parent=np.int64(14999), leader=np.int64(256))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.88s\n",
+      "nearest_honest\t0.00s\n",
+      "reorg_events\t5.38s\n",
+      "reorg_depth\t0.60s\n",
+      "depth_append\t0.49s\n",
+      "CPU times: user 4min 35s, sys: 1min 31s, total: 6min 6s\n",
+      "Wall time: 6min 51s\n"
      ]
     }
    ],
    "source": [
+    "%%time\n",
+    "PATHS = 5\n",
+    "target_block_num = 30000\n",
     "np.random.seed(0)\n",
-    "stake = np.random.pareto(10, 100)\n",
-    "\n",
-    "mixnet_delay_mean = 10\n",
-    "\n",
+    "stake = np.random.pareto(10, 1000)\n",
+    "network = blend_net\n",
+    "sim_params = Params(\n",
+    "    SLOTS=0,\n",
+    "    f=0.05,\n",
+    "    adversary_control = 0.49,\n",
+    "    honest_stake = stake\n",
+    ")\n",
+    "np.random.seed(1)\n",
     "sims = [Sim(\n",
-    "    params=Params(\n",
-    "        SLOTS=int(30000 * 1 / (1/mixnet_delay_mean / i)),\n",
-    "        f=1/mixnet_delay_mean / i,\n",
-    "        adversary_control = 0.3,\n",
-    "        honest_stake = stake\n",
+    "    params=replace(\n",
+    "        sim_params,\n",
+    "        SLOTS=int(target_block_num * block_time),\n",
+    "        f=1/block_time\n",
     "    ),\n",
-    "    network=NetworkParams(\n",
-    "        mixnet_delay_mean=mixnet_delay_mean, # seconds\n",
-    "        mixnet_delay_var=4,\n",
-    "        broadcast_delay_mean=2, # second\n",
-    "        pol_proof_time=2, # seconds\n",
-    "        no_network_delay=False\n",
-    "    )\n",
-    ") for i in [1/2, 1, 2, 3]]\n",
+    "    network=network\n",
+    ") for block_time in np.array([30]).repeat(PATHS)]\n",
     "\n",
     "\n",
     "for i, sim in enumerate(sims):\n",
     "    print(f\"simulating {i+1}/{len(sims)}\")\n",
-    "    sim.run(seed=0)\n",
+    "    sim.run(seed=i)\n",
     "\n",
     "print(\"finished simulation, starting analysis\")\n",
-    "advs = [sim.adverserial_analysis(should_plot=False) for sim in sims]"
+    "advs = [sim.adverserial_analysis() for sim in sims]\n",
+    "\n",
+    "print(\"cardano parameters\")\n",
+    "cardano_block_time = 20\n",
+    "cardano_sims = [Sim(\n",
+    "    params=replace(\n",
+    "        sim_params,\n",
+    "        SLOTS=int(target_block_num * cardano_block_time),\n",
+    "        f=1/cardano_block_time,\n",
+    "    ),\n",
+    "    network=replace(network, blend_hops=0)\n",
+    ") for _ in range(PATHS)]\n",
+    "\n",
+    "for i, sim in enumerate(cardano_sims):\n",
+    "    print(f\"simulating {i+1}/{len(cardano_sims)}\")\n",
+    "    sim.run(seed=i)\n",
+    "\n",
+    "cardano_advs = [sim.adverserial_analysis() for sim in cardano_sims]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 501,
+   "execution_count": 17,
    "id": "87c8d0b8-c8d2-4c49-a9c4-2eaefd41c254",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 / 5\n",
+      "2 / 5\n",
+      "3 / 5\n",
+      "4 / 5\n",
+      "5 / 5\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -837,58 +1113,123 @@
     }
    ],
    "source": [
-    "MAX=40\n",
+    "k = 3000\n",
+    "MAX=min(k, max(max(adv) for adv in advs))\n",
+    "network_samples = network.empirical_network_delay()\n",
+    "network_delay_mean = network_samples.mean()\n",
+    "f_index = list({s.params.f for s in sims})\n",
+    "hops_index = list({s.network.blend_hops for s in sims})\n",
+    "delay_index = list({s.network.blending_delay for s in sims})\n",
+    "colors = ['#855C75FF', '#D9AF6BFF', '#AF6458FF', '#736F4CFF', '#526A83FF', '#625377FF', '#68855CFF', '#9C9C5EFF', '#A06177FF', '#8C785DFF', '#467378FF', '#7C7C7CFF']\n",
     "\n",
     "for s in range(len(sims)):\n",
-    "    \n",
-    "    max_depth = advs[s].max() if advs[s].sum() > 0 else 0\n",
-    "    max_depth = min(MAX, max_depth)\n",
-    "    count_by_depth = np.zeros(max_depth)\n",
-    "    for d in range(max_depth):\n",
-    "        count_by_depth[d] = (advs[s] == d).sum() \n",
+    "    print(f'{s+1} / {len(sims)}')\n",
     "    block_time = 1 / sims[s].params.f\n",
-    "    expected_blocks = sims[s].params.SLOTS / block_time\n",
-    "    plt.plot(np.arange(max_depth), count_by_depth / expected_blocks, label=f\"{block_time:.0f}s ~ {block_time / sims[s].network.mixnet_delay_mean:.1f}x mix delay\")\n",
+    "    c = colors[f_index.index(sims[s].params.f)]\n",
+    "    # c = colors[hops_index.index(sims[s].network.blend_hops)]\n",
+    "    # c = colors[delay_index.index(sims[s].network.blending_delay)]\n",
+    "    reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"{block_time:.1f}s ~ {block_time / network_delay_mean:.0f}x net delay\")\n",
+    "    # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"hops={sims[s].network.blend_hops}\")\n",
+    "    # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"blending delay={sims[s].network.blending_delay}\")\n",
     "\n",
-    "_ = plt.title(f\"reorg depth sensitivity to block time @ {mixnet_delay_mean}s mixnet delay\")\n",
+    "\n",
+    "for s in range(len(cardano_sims)):\n",
+    "    reorg_depth_analysis(cardano_sims[s], cardano_advs[s], MAX, lw=\"1\", color=\"k\", label=f\"cardano\")\n",
+    "\n",
+    "_ = plt.title(f\"reorg depth sensitivity\")\n",
     "_ = plt.xlabel(\"reorg depth\")\n",
     "_ = plt.ylabel(\"frequency (per block)\")\n",
-    "_ = plt.legend()\n",
     "_ = plt.yscale(\"log\")\n",
     "_ = plt.xlim(0, MAX)\n",
-    "_ = plt.ylim(10**-4, 4)\n"
+    "_ = plt.ylim(10**-4,None)\n",
+    "\n",
+    "# avoid duplicate legend entries with the same label\n",
+    "handles, labels = plt.gca().get_legend_handles_labels()\n",
+    "by_label = dict(zip(labels, handles))\n",
+    "_ = plt.legend(by_label.values(), by_label.keys())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4441306-0bd1-4cc4-914e-4c31dd5270a2",
+   "metadata": {},
+   "source": [
+    "# 30s Block Times Network Sensitivity Analysis"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 497,
-   "id": "af11b126-33b6-4b62-868e-b11a0090aa69",
+   "execution_count": 18,
+   "id": "ec1c7f73-5752-4fb2-bd3e-ed7eb4c9156d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "block_time = 30\n",
+    "\n",
+    "nomos_params = Params(\n",
+    "    SLOTS=3 * 2160 * block_time,\n",
+    "    f=1/block_time,\n",
+    "    adversary_control = 0.3,\n",
+    "    honest_stake = np.random.pareto(10, 1000)\n",
+    ")\n",
+    "nomos_net = NetworkParams(\n",
+    "    broadcast_delay_mean=0.5,\n",
+    "    pol_proof_time=1,\n",
+    "    blending_delay=3,\n",
+    "    desimenation_delay_mean=0.5,\n",
+    "    blend_hops=3,\n",
+    ")\n",
+    "\n",
+    "cardano_params = replace(nomos_params, f=1/20, SLOTS=10 * 2160 * 20)\n",
+    "cardano_net = replace(nomos_net, blend_hops=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "2ceb907e-c1b6-4867-81b0-e5d38ee6c50a",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "leader\t8.54s\n",
+      "emit\t1.51s\n",
+      "slot\t10.05s\n",
+      "forkchoice\t0.31s\n",
+      "emit_leader_block\t0.42s\n",
+      "prep\t0.00s\n",
+      "total\t10.14s\n",
+      "Processing block Block(id=5000, slot=142190, height=4884, parent=np.int64(4999), leader=np.int64(162))\n",
+      "Processing block Block(id=10000, slot=281660, height=9781, parent=np.int64(9999), leader=np.int64(896))\n",
+      "Processing block Block(id=15000, slot=422412, height=14683, parent=np.int64(14999), leader=np.int64(629))\n",
+      "honest_chain\t0.00s\n",
+      "honest_height_by_slot\t0.00s\n",
+      "prep_analysis\t0.43s\n",
+      "nearest_honest\t0.01s\n",
+      "reorg_events\t4.62s\n",
+      "reorg_depth\t0.22s\n",
+      "depth_append\t0.02s\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
-       "[(150000, 5.0), (300000, 10.0), (600000, 20.0), (900000, 30.0)]"
+       "(array([28.,  3.,  2.,  1.,  1.,  1.,  0.,  1.,  0.,  1.]),\n",
+       " array([5.0000e+00, 8.3640e+02, 1.6678e+03, 2.4992e+03, 3.3306e+03,\n",
+       "        4.1620e+03, 4.9934e+03, 5.8248e+03, 6.6562e+03, 7.4876e+03,\n",
+       "        8.3190e+03]),\n",
+       " <BarContainer object of 10 artists>)"
       ]
      },
-     "execution_count": 497,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "[(s.params.SLOTS, 1 / s.params.f) for s in sims]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 514,
-   "id": "23a226b5-b624-4ae9-86bd-2d7201bbb365",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -898,44 +1239,48 @@
     }
    ],
    "source": [
-    "# _ = plt.plot([s.network.mixnet_delay_mean for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n",
-    "_ = plt.scatter([1 / s.params.f for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n",
+    "cardano_params = replace(nomos_params, f=1/20, SLOTS=10 * 2160 * 20)\n",
+    "cardano_net = replace(nomos_net, blend_hops=0)\n",
     "\n",
-    "_ = plt.title(\"chain growth vs. block time multiple of network delay\")\n",
-    "_ = plt.ylabel(\"chain growth / slot\")\n",
-    "_ = plt.xlabel(\"block time multiple of network delay\")"
+    "cardano_sim = Sim(\n",
+    "    params=cardano_params,\n",
+    "    network=cardano_net\n",
+    ")\n",
+    "cardano_sim.run(seed=0)\n",
+    "\n",
+    "cardano_reorgs = cardano_sim.adverserial_analysis()\n",
+    "\n",
+    "plt.hist(np.bincount(cardano_reorgs))\n",
+    "    "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 499,
-   "id": "317dd511-6fda-44c3-88ff-622460b36665",
+   "execution_count": 20,
+   "id": "1a68a180-9800-4cd1-9d07-9aaa20162cac",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "ename": "NameError",
+     "evalue": "name 'test_params' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "File \u001b[0;32m<timed eval>:1\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'test_params' is not defined"
+     ]
     }
    ],
    "source": [
-    "# _ = plt.plot([(1 / s.params.f) / s.network.mixnet_delay_mean for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n",
-    "_ = plt.scatter([s.params.f for s in sims], [len(s.honest_chain()) / len(s.blocks) for s in sims])\n",
-    "\n",
-    "_ = plt.title(\"block efficiency\")\n",
-    "_ = plt.ylabel(\"% of blocks member of honest chain\")\n",
-    "_ = plt.xlabel(\"f\")"
+    "%%time\n",
+    "test_params(nomos_params, nomos_net)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5818b2d0-ba38-49bd-89c9-e78306f493f1",
+   "id": "fdc9ae28-5c4f-4ffd-a090-ae7a7225ec4c",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -957,7 +1302,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.9"
   }
  },
  "nbformat": 4,
diff --git a/efficient_fees/service_stake.ipynb b/efficient_fees/service_stake.ipynb
new file mode 100644
index 0000000..136b857
--- /dev/null
+++ b/efficient_fees/service_stake.ipynb
@@ -0,0 +1,139 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "id": "eca38ae3-3df1-40f9-9a4b-ddc539559aba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "\n",
+    "@dataclass\n",
+    "class ServiceNetwork:\n",
+    "    total_nmo_stake: int = 0\n",
+    "    total_lp_supply: int = 0\n",
+    "    \n",
+    "    def stake(self, nmo):\n",
+    "        if self.total_nmo_stake == 0:\n",
+    "            # this is the only staker in the network\n",
+    "            self.total_nmo_stake = nmo\n",
+    "            self.total_lp_supply = 1.0\n",
+    "            return self.total_lp_supply\n",
+    "        \n",
+    "        lp_tokens = nmo / self.total_nmo_stake * self.total_lp_supply\n",
+    "        self.total_nmo_stake += nmo\n",
+    "        self.total_lp_supply += lp_tokens\n",
+    "        return lp_tokens\n",
+    "\n",
+    "    def unstake(self, lp_tokens):\n",
+    "        nmo = self.query_stake(lp_tokens)\n",
+    "        self.total_nmo_stake -= nmo\n",
+    "        self.total_lp_supply -= lp_tokens\n",
+    "        return nmo\n",
+    "\n",
+    "    def query_stake(self, lp_tokens):\n",
+    "        nmo = lp_tokens / self.total_lp_supply * self.total_nmo_stake    \n",
+    "        return nmo\n",
+    "    \n",
+    "    def reward(self, r_nmo):\n",
+    "        self.total_nmo_stake += r_nmo\n",
+    "\n",
+    "def print_lp_positions(sn, lpers):\n",
+    "    print(f\"{\"actor\":^7}|{\"lp\":^5}|{\"nmo\":^7}\")\n",
+    "    print(\"-------+-----+-------\")\n",
+    "    for actor, lp in lpers.items():\n",
+    "        print(f\"{actor:7}|{lp:5.2f}|{sn.query_stake(lp):7.2f}\")\n",
+    "\n",
+    "    print(\"-------+-----+-------\")\n",
+    "    print(\"{actor:7}|{lp:5.2f}|{nmo:7.2f}\".format(actor=\"total\", lp=sum(lpers.values()), nmo=sum(sn.query_stake(lp) for lp in lpers.values())))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "id": "0b58cd02-3427-4388-992b-8347cb2a601a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " actor | lp  |  nmo  \n",
+      "-------+-----+-------\n",
+      "alice  | 1.00|  10.00\n",
+      "bob    | 1.00|  10.00\n",
+      "charlie| 3.00|  30.00\n",
+      "-------+-----+-------\n",
+      "total  | 5.00|  50.00\n",
+      "\n",
+      "network is rewarded by 5 NMO\n",
+      "\n",
+      " actor | lp  |  nmo  \n",
+      "-------+-----+-------\n",
+      "alice  | 1.00|  11.00\n",
+      "bob    | 1.00|  11.00\n",
+      "charlie| 3.00|  33.00\n",
+      "-------+-----+-------\n",
+      "total  | 5.00|  55.00\n",
+      "\n",
+      "new stakers after network rewards get fewer LP tokens\n",
+      "\n",
+      " actor | lp  |  nmo  \n",
+      "-------+-----+-------\n",
+      "alice  | 1.00|  11.00\n",
+      "bob    | 1.00|  11.00\n",
+      "charlie| 3.00|  33.00\n",
+      "dan    | 0.91|  10.00\n",
+      "-------+-----+-------\n",
+      "total  | 5.91|  65.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "sn = ServiceNetwork()\n",
+    "\n",
+    "stakers = {\"alice\": 10, \"bob\": 10, \"charlie\": 30}\n",
+    "\n",
+    "lpers = {actor: sn.stake(nmo) for actor, nmo in stakers.items()}\n",
+    "\n",
+    "print_lp_positions(sn, lpers)\n",
+    "\n",
+    "print(\"\")\n",
+    "print(\"network is rewarded by 5 NMO\")\n",
+    "sn.reward(5)\n",
+    "print(\"\")\n",
+    "\n",
+    "print_lp_positions(sn, lpers)\n",
+    "\n",
+    "print(\"\")\n",
+    "print(\"new stakers after network rewards get fewer LP tokens\")\n",
+    "print(\"\")\n",
+    "stakers[\"dan\"] = 10\n",
+    "lpers[\"dan\"] = sn.stake(stakers[\"dan\"])\n",
+    "print_lp_positions(sn, lpers)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/efficient_fees/shell.nix b/efficient_fees/shell.nix
new file mode 100644
index 0000000..8d96840
--- /dev/null
+++ b/efficient_fees/shell.nix
@@ -0,0 +1,23 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    # Defines a python + set of packages.
+    (python3.withPackages (ps: with ps; with python3Packages; [
+      jupyter
+      ipython
+
+      # Uncomment the following lines to make them available in the shell.
+      # pandas
+      numpy
+      matplotlib
+      scipy
+      sympy
+      pyvis
+      networkx
+    ]))
+  ];
+
+  # Automatically run jupyter when entering the shell.
+  shellHook = "jupyter notebook";
+}